leandrof/linux
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

IB/core: Change completion channel to use the reworked objects schema

Browse Source 
This patch adds the standard fd based type - completion_channel.
The completion_channel is now prefixed with ib_uobject, similarly
to the rest of the uobjects.
This requires a few changes:
(1) We define a new completion channel fd based object type.
(2) completion_event and async_event are now two different types.
    This means they use different fops.
(3) We release the completion_channel exactly as we release other
    idr based objects.
(4) Since ib_uobjects are already kref-ed, we only add the kref to the
    async event.

A fd object requires filling out several parameters. Its op pointer
should point to uverbs_fd_ops and its size should be at least the
size if ib_uobject. We use a macro to make the type declaration
easier.

Signed-off-by: Matan Barak <matanb@mellanox.com>
Reviewed-by: Yishai Hadas <yishaih@mellanox.com>
Signed-off-by: Doug Ledford <dledford@redhat.com>
This commit is contained in:
Matan Barak 2017-04-04 13:31:47 +03:00 committed by Doug Ledford
parent cf8966b347
commit 1e7710f3f6
6 changed files with 256 additions and 147 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

26
drivers/infiniband/core/uverbs.h
View File

@ -102,17 +102,25 @@ struct ib_uverbs_device {
}; };
struct ib_uverbs_event_file { struct ib_uverbs_event_file {
struct kref ref;
int is_async;
struct ib_uverbs_file *uverbs_file;
spinlock_t lock; spinlock_t lock;
int is_closed; int is_closed;
wait_queue_head_t poll_wait; wait_queue_head_t poll_wait;
struct fasync_struct *async_queue; struct fasync_struct *async_queue;
struct list_head event_list; struct list_head event_list;
};
struct ib_uverbs_async_event_file {
struct ib_uverbs_event_file ev_file;
struct ib_uverbs_file *uverbs_file;
struct kref ref;
struct list_head list; struct list_head list;
}; };
struct ib_uverbs_completion_event_file {
struct ib_uobject_file uobj_file;
struct ib_uverbs_event_file ev_file;
};
struct ib_uverbs_file { struct ib_uverbs_file {
struct kref ref; struct kref ref;
struct mutex mutex; struct mutex mutex;
@ -120,7 +128,7 @@ struct ib_uverbs_file {
struct ib_uverbs_device *device; struct ib_uverbs_device *device;
struct ib_ucontext *ucontext; struct ib_ucontext *ucontext;
struct ib_event_handler event_handler; struct ib_event_handler event_handler;
struct ib_uverbs_event_file *async_file; struct ib_uverbs_async_event_file *async_file;
struct list_head list; struct list_head list;
int is_closed; int is_closed;
@ -182,14 +190,14 @@ struct ib_ucq_object {
u32 async_events_reported; u32 async_events_reported;
}; };
struct file *ib_uverbs_alloc_event_file(struct ib_uverbs_file *uverbs_file, extern const struct file_operations uverbs_event_fops;
struct ib_device *ib_dev, void ib_uverbs_init_event_file(struct ib_uverbs_event_file *ev_file);
int is_async); struct file *ib_uverbs_alloc_async_event_file(struct ib_uverbs_file *uverbs_file,
struct ib_device *ib_dev);
void ib_uverbs_free_async_event_file(struct ib_uverbs_file *uverbs_file); void ib_uverbs_free_async_event_file(struct ib_uverbs_file *uverbs_file);
struct ib_uverbs_event_file *ib_uverbs_lookup_comp_file(int fd);
void ib_uverbs_release_ucq(struct ib_uverbs_file *file, void ib_uverbs_release_ucq(struct ib_uverbs_file *file,
struct ib_uverbs_event_file *ev_file, struct ib_uverbs_completion_event_file *ev_file,
struct ib_ucq_object *uobj); struct ib_ucq_object *uobj);
void ib_uverbs_release_uevent(struct ib_uverbs_file *file, void ib_uverbs_release_uevent(struct ib_uverbs_file *file,
struct ib_uevent_object *uobj); struct ib_uevent_object *uobj);

57
drivers/infiniband/core/uverbs_cmd.c
View File

@ -47,6 +47,24 @@
#include "uverbs.h" #include "uverbs.h"
#include "core_priv.h" #include "core_priv.h"
static struct ib_uverbs_completion_event_file *
ib_uverbs_lookup_comp_file(int fd, struct ib_ucontext *context)
{
struct ib_uobject *uobj = uobj_get_read(uobj_get_type(comp_channel),
fd, context);
struct ib_uobject_file *uobj_file;
if (IS_ERR(uobj))
return (void *)uobj;
uverbs_uobject_get(uobj);
uobj_put_read(uobj);
uobj_file = container_of(uobj, struct ib_uobject_file, uobj);
return container_of(uobj_file, struct ib_uverbs_completion_event_file,
uobj_file);
}
ssize_t ib_uverbs_get_context(struct ib_uverbs_file *file, ssize_t ib_uverbs_get_context(struct ib_uverbs_file *file,
struct ib_device *ib_dev, struct ib_device *ib_dev,
const char __user *buf, const char __user *buf,
@ -116,7 +134,7 @@ ssize_t ib_uverbs_get_context(struct ib_uverbs_file *file,
goto err_free; goto err_free;
resp.async_fd = ret; resp.async_fd = ret;
filp = ib_uverbs_alloc_event_file(file, ib_dev, 1); filp = ib_uverbs_alloc_async_event_file(file, ib_dev);
if (IS_ERR(filp)) { if (IS_ERR(filp)) {
ret = PTR_ERR(filp); ret = PTR_ERR(filp);
goto err_fd; goto err_fd;
@ -908,8 +926,8 @@ ssize_t ib_uverbs_create_comp_channel(struct ib_uverbs_file *file,
{ {
struct ib_uverbs_create_comp_channel cmd; struct ib_uverbs_create_comp_channel cmd;
struct ib_uverbs_create_comp_channel_resp resp; struct ib_uverbs_create_comp_channel_resp resp;
struct file *filp; struct ib_uobject *uobj;
int ret; struct ib_uverbs_completion_event_file *ev_file;
if (out_len < sizeof resp) if (out_len < sizeof resp)
return -ENOSPC; return -ENOSPC;
@ -917,25 +935,23 @@ ssize_t ib_uverbs_create_comp_channel(struct ib_uverbs_file *file,
if (copy_from_user(&cmd, buf, sizeof cmd)) if (copy_from_user(&cmd, buf, sizeof cmd))
return -EFAULT; return -EFAULT;
ret = get_unused_fd_flags(O_CLOEXEC); uobj = uobj_alloc(uobj_get_type(comp_channel), file->ucontext);
if (ret < 0) if (IS_ERR(uobj))
return ret; return PTR_ERR(uobj);
resp.fd = ret;
filp = ib_uverbs_alloc_event_file(file, ib_dev, 0); resp.fd = uobj->id;
if (IS_ERR(filp)) {
put_unused_fd(resp.fd); ev_file = container_of(uobj, struct ib_uverbs_completion_event_file,
return PTR_ERR(filp); uobj_file.uobj);
} ib_uverbs_init_event_file(&ev_file->ev_file);
if (copy_to_user((void __user *) (unsigned long) cmd.response, if (copy_to_user((void __user *) (unsigned long) cmd.response,
&resp, sizeof resp)) { &resp, sizeof resp)) {
put_unused_fd(resp.fd); uobj_alloc_abort(uobj);
fput(filp);
return -EFAULT; return -EFAULT;
} }
fd_install(resp.fd, filp); uobj_alloc_commit(uobj);
return in_len; return in_len;
} }
@ -953,7 +969,7 @@ static struct ib_ucq_object *create_cq(struct ib_uverbs_file *file,
void *context) void *context)
{ {
struct ib_ucq_object *obj; struct ib_ucq_object *obj;
struct ib_uverbs_event_file *ev_file = NULL; struct ib_uverbs_completion_event_file *ev_file = NULL;
struct ib_cq *cq; struct ib_cq *cq;
int ret; int ret;
struct ib_uverbs_ex_create_cq_resp resp; struct ib_uverbs_ex_create_cq_resp resp;
@ -968,9 +984,10 @@ static struct ib_ucq_object *create_cq(struct ib_uverbs_file *file,
return obj; return obj;
if (cmd->comp_channel >= 0) { if (cmd->comp_channel >= 0) {
ev_file = ib_uverbs_lookup_comp_file(cmd->comp_channel); ev_file = ib_uverbs_lookup_comp_file(cmd->comp_channel,
if (!ev_file) { file->ucontext);
ret = -EINVAL; if (IS_ERR(ev_file)) {
ret = PTR_ERR(ev_file);
goto err; goto err;
} }
} }
@ -998,7 +1015,7 @@ static struct ib_ucq_object *create_cq(struct ib_uverbs_file *file,
cq->uobject = &obj->uobject; cq->uobject = &obj->uobject;
cq->comp_handler = ib_uverbs_comp_handler; cq->comp_handler = ib_uverbs_comp_handler;
cq->event_handler = ib_uverbs_cq_event_handler; cq->event_handler = ib_uverbs_cq_event_handler;
cq->cq_context = ev_file; cq->cq_context = &ev_file->ev_file;
atomic_set(&cq->usecnt, 0); atomic_set(&cq->usecnt, 0);
obj->uobject.object = cq; obj->uobject.object = cq;

277
drivers/infiniband/core/uverbs_main.c
View File

@ -156,37 +156,37 @@ static struct kobj_type ib_uverbs_dev_ktype = {
.release = ib_uverbs_release_dev, .release = ib_uverbs_release_dev,
}; };
static void ib_uverbs_release_event_file(struct kref *ref) static void ib_uverbs_release_async_event_file(struct kref *ref)
{ {
struct ib_uverbs_event_file *file = struct ib_uverbs_async_event_file *file =
container_of(ref, struct ib_uverbs_event_file, ref); container_of(ref, struct ib_uverbs_async_event_file, ref);
kfree(file); kfree(file);
} }
void ib_uverbs_release_ucq(struct ib_uverbs_file *file, void ib_uverbs_release_ucq(struct ib_uverbs_file *file,
struct ib_uverbs_event_file *ev_file, struct ib_uverbs_completion_event_file *ev_file,
struct ib_ucq_object *uobj) struct ib_ucq_object *uobj)
{ {
struct ib_uverbs_event *evt, *tmp; struct ib_uverbs_event *evt, *tmp;
if (ev_file) { if (ev_file) {
spin_lock_irq(&ev_file->lock); spin_lock_irq(&ev_file->ev_file.lock);
list_for_each_entry_safe(evt, tmp, &uobj->comp_list, obj_list) { list_for_each_entry_safe(evt, tmp, &uobj->comp_list, obj_list) {
list_del(&evt->list); list_del(&evt->list);
kfree(evt); kfree(evt);
} }
spin_unlock_irq(&ev_file->lock); spin_unlock_irq(&ev_file->ev_file.lock);
kref_put(&ev_file->ref, ib_uverbs_release_event_file); uverbs_uobject_put(&ev_file->uobj_file.uobj);
} }
spin_lock_irq(&file->async_file->lock); spin_lock_irq(&file->async_file->ev_file.lock);
list_for_each_entry_safe(evt, tmp, &uobj->async_list, obj_list) { list_for_each_entry_safe(evt, tmp, &uobj->async_list, obj_list) {
list_del(&evt->list); list_del(&evt->list);
kfree(evt); kfree(evt);
} }
spin_unlock_irq(&file->async_file->lock); spin_unlock_irq(&file->async_file->ev_file.lock);
} }
void ib_uverbs_release_uevent(struct ib_uverbs_file *file, void ib_uverbs_release_uevent(struct ib_uverbs_file *file,
@ -194,12 +194,12 @@ void ib_uverbs_release_uevent(struct ib_uverbs_file *file,
{ {
struct ib_uverbs_event *evt, *tmp; struct ib_uverbs_event *evt, *tmp;
spin_lock_irq(&file->async_file->lock); spin_lock_irq(&file->async_file->ev_file.lock);
list_for_each_entry_safe(evt, tmp, &uobj->event_list, obj_list) { list_for_each_entry_safe(evt, tmp, &uobj->event_list, obj_list) {
list_del(&evt->list); list_del(&evt->list);
kfree(evt); kfree(evt);
} }
spin_unlock_irq(&file->async_file->lock); spin_unlock_irq(&file->async_file->ev_file.lock);
} }
void ib_uverbs_detach_umcast(struct ib_qp *qp, void ib_uverbs_detach_umcast(struct ib_qp *qp,
@ -253,10 +253,12 @@ void ib_uverbs_release_file(struct kref *ref)
kfree(file); kfree(file);
} }
static ssize_t ib_uverbs_event_read(struct file *filp, char __user *buf, static ssize_t ib_uverbs_event_read(struct ib_uverbs_event_file *file,
size_t count, loff_t *pos) struct ib_uverbs_file *uverbs_file,
struct file *filp, char __user *buf,
size_t count, loff_t *pos,
bool is_async)
{ {
struct ib_uverbs_event_file *file = filp->private_data;
struct ib_uverbs_event *event; struct ib_uverbs_event *event;
int eventsz; int eventsz;
int ret = 0; int ret = 0;
@ -275,12 +277,12 @@ static ssize_t ib_uverbs_event_read(struct file *filp, char __user *buf,
* and wake_up() guarentee this will see the null set * and wake_up() guarentee this will see the null set
* without using RCU * without using RCU
*/ */
!file->uverbs_file->device->ib_dev))) !uverbs_file->device->ib_dev)))
return -ERESTARTSYS; return -ERESTARTSYS;
/* If device was disassociated and no event exists set an error */ /* If device was disassociated and no event exists set an error */
if (list_empty(&file->event_list) && if (list_empty(&file->event_list) &&
!file->uverbs_file->device->ib_dev) !uverbs_file->device->ib_dev)
return -EIO; return -EIO;
spin_lock_irq(&file->lock); spin_lock_irq(&file->lock);
@ -288,7 +290,7 @@ static ssize_t ib_uverbs_event_read(struct file *filp, char __user *buf,
event = list_entry(file->event_list.next, struct ib_uverbs_event, list); event = list_entry(file->event_list.next, struct ib_uverbs_event, list);
if (file->is_async) if (is_async)
eventsz = sizeof (struct ib_uverbs_async_event_desc); eventsz = sizeof (struct ib_uverbs_async_event_desc);
else else
eventsz = sizeof (struct ib_uverbs_comp_event_desc); eventsz = sizeof (struct ib_uverbs_comp_event_desc);
@ -318,11 +320,31 @@ static ssize_t ib_uverbs_event_read(struct file *filp, char __user *buf,
return ret; return ret;
} }
static unsigned int ib_uverbs_event_poll(struct file *filp, static ssize_t ib_uverbs_async_event_read(struct file *filp, char __user *buf,
size_t count, loff_t *pos)
{
struct ib_uverbs_async_event_file *file = filp->private_data;
return ib_uverbs_event_read(&file->ev_file, file->uverbs_file, filp,
buf, count, pos, true);
}
static ssize_t ib_uverbs_comp_event_read(struct file *filp, char __user *buf,
size_t count, loff_t *pos)
{
struct ib_uverbs_completion_event_file *comp_ev_file =
filp->private_data;
return ib_uverbs_event_read(&comp_ev_file->ev_file,
comp_ev_file->uobj_file.ufile, filp,
buf, count, pos, false);
}
static unsigned int ib_uverbs_event_poll(struct ib_uverbs_event_file *file,
struct file *filp,
struct poll_table_struct *wait) struct poll_table_struct *wait)
{ {
unsigned int pollflags = 0; unsigned int pollflags = 0;
struct ib_uverbs_event_file *file = filp->private_data;
poll_wait(filp, &file->poll_wait, wait); poll_wait(filp, &file->poll_wait, wait);
@ -334,49 +356,98 @@ static unsigned int ib_uverbs_event_poll(struct file *filp,
return pollflags; return pollflags;
} }
static int ib_uverbs_event_fasync(int fd, struct file *filp, int on) static unsigned int ib_uverbs_async_event_poll(struct file *filp,
struct poll_table_struct *wait)
{
return ib_uverbs_event_poll(filp->private_data, filp, wait);
}
static unsigned int ib_uverbs_comp_event_poll(struct file *filp,
struct poll_table_struct *wait)
{
struct ib_uverbs_completion_event_file *comp_ev_file =
filp->private_data;
return ib_uverbs_event_poll(&comp_ev_file->ev_file, filp, wait);
}
static int ib_uverbs_async_event_fasync(int fd, struct file *filp, int on)
{ {
struct ib_uverbs_event_file *file = filp->private_data; struct ib_uverbs_event_file *file = filp->private_data;
return fasync_helper(fd, filp, on, &file->async_queue); return fasync_helper(fd, filp, on, &file->async_queue);
} }
static int ib_uverbs_event_close(struct inode *inode, struct file *filp) static int ib_uverbs_comp_event_fasync(int fd, struct file *filp, int on)
{ {
struct ib_uverbs_event_file *file = filp->private_data; struct ib_uverbs_completion_event_file *comp_ev_file =
filp->private_data;
return fasync_helper(fd, filp, on, &comp_ev_file->ev_file.async_queue);
}
static int ib_uverbs_async_event_close(struct inode *inode, struct file *filp)
{
struct ib_uverbs_async_event_file *file = filp->private_data;
struct ib_uverbs_file *uverbs_file = file->uverbs_file;
struct ib_uverbs_event *entry, *tmp; struct ib_uverbs_event *entry, *tmp;
int closed_already = 0; int closed_already = 0;
mutex_lock(&file->uverbs_file->device->lists_mutex); mutex_lock(&uverbs_file->device->lists_mutex);
spin_lock_irq(&file->lock); spin_lock_irq(&file->ev_file.lock);
closed_already = file->is_closed; closed_already = file->ev_file.is_closed;
file->is_closed = 1; file->ev_file.is_closed = 1;
list_for_each_entry_safe(entry, tmp, &file->event_list, list) { list_for_each_entry_safe(entry, tmp, &file->ev_file.event_list, list) {
if (entry->counter) if (entry->counter)
list_del(&entry->obj_list); list_del(&entry->obj_list);
kfree(entry); kfree(entry);
} }
spin_unlock_irq(&file->lock); spin_unlock_irq(&file->ev_file.lock);
if (!closed_already) { if (!closed_already) {
list_del(&file->list); list_del(&file->list);
if (file->is_async) ib_unregister_event_handler(&uverbs_file->event_handler);
ib_unregister_event_handler(&file->uverbs_file->
event_handler);
} }
mutex_unlock(&file->uverbs_file->device->lists_mutex); mutex_unlock(&uverbs_file->device->lists_mutex);
kref_put(&file->uverbs_file->ref, ib_uverbs_release_file); kref_put(&uverbs_file->ref, ib_uverbs_release_file);
kref_put(&file->ref, ib_uverbs_release_event_file); kref_put(&file->ref, ib_uverbs_release_async_event_file);
return 0; return 0;
} }
static const struct file_operations uverbs_event_fops = { static int ib_uverbs_comp_event_close(struct inode *inode, struct file *filp)
{
struct ib_uverbs_completion_event_file *file = filp->private_data;
struct ib_uverbs_event *entry, *tmp;
spin_lock_irq(&file->ev_file.lock);
list_for_each_entry_safe(entry, tmp, &file->ev_file.event_list, list) {
if (entry->counter)
list_del(&entry->obj_list);
kfree(entry);
}
spin_unlock_irq(&file->ev_file.lock);
uverbs_close_fd(filp);
return 0;
}
const struct file_operations uverbs_event_fops = {
.owner = THIS_MODULE, .owner = THIS_MODULE,
.read = ib_uverbs_event_read, .read = ib_uverbs_comp_event_read,
.poll = ib_uverbs_event_poll, .poll = ib_uverbs_comp_event_poll,
.release = ib_uverbs_event_close, .release = ib_uverbs_comp_event_close,
.fasync = ib_uverbs_event_fasync, .fasync = ib_uverbs_comp_event_fasync,
.llseek = no_llseek,
};
static const struct file_operations uverbs_async_event_fops = {
.owner = THIS_MODULE,
.read = ib_uverbs_async_event_read,
.poll = ib_uverbs_async_event_poll,
.release = ib_uverbs_async_event_close,
.fasync = ib_uverbs_async_event_fasync,
.llseek = no_llseek, .llseek = no_llseek,
}; };
@ -423,15 +494,15 @@ static void ib_uverbs_async_handler(struct ib_uverbs_file *file,
struct ib_uverbs_event *entry; struct ib_uverbs_event *entry;
unsigned long flags; unsigned long flags;
spin_lock_irqsave(&file->async_file->lock, flags); spin_lock_irqsave(&file->async_file->ev_file.lock, flags);
if (file->async_file->is_closed) { if (file->async_file->ev_file.is_closed) {
spin_unlock_irqrestore(&file->async_file->lock, flags); spin_unlock_irqrestore(&file->async_file->ev_file.lock, flags);
return; return;
} }
entry = kmalloc(sizeof *entry, GFP_ATOMIC); entry = kmalloc(sizeof *entry, GFP_ATOMIC);
if (!entry) { if (!entry) {
spin_unlock_irqrestore(&file->async_file->lock, flags); spin_unlock_irqrestore(&file->async_file->ev_file.lock, flags);
return; return;
} }
@ -440,13 +511,13 @@ static void ib_uverbs_async_handler(struct ib_uverbs_file *file,
entry->desc.async.reserved = 0; entry->desc.async.reserved = 0;
entry->counter = counter; entry->counter = counter;
list_add_tail(&entry->list, &file->async_file->event_list); list_add_tail(&entry->list, &file->async_file->ev_file.event_list);
if (obj_list) if (obj_list)
list_add_tail(&entry->obj_list, obj_list); list_add_tail(&entry->obj_list, obj_list);
spin_unlock_irqrestore(&file->async_file->lock, flags); spin_unlock_irqrestore(&file->async_file->ev_file.lock, flags);
wake_up_interruptible(&file->async_file->poll_wait); wake_up_interruptible(&file->async_file->ev_file.poll_wait);
kill_fasync(&file->async_file->async_queue, SIGIO, POLL_IN); kill_fasync(&file->async_file->ev_file.async_queue, SIGIO, POLL_IN);
} }
void ib_uverbs_cq_event_handler(struct ib_event *event, void *context_ptr) void ib_uverbs_cq_event_handler(struct ib_event *event, void *context_ptr)
@ -509,15 +580,23 @@ void ib_uverbs_event_handler(struct ib_event_handler *handler,
void ib_uverbs_free_async_event_file(struct ib_uverbs_file *file) void ib_uverbs_free_async_event_file(struct ib_uverbs_file *file)
{ {
kref_put(&file->async_file->ref, ib_uverbs_release_event_file); kref_put(&file->async_file->ref, ib_uverbs_release_async_event_file);
file->async_file = NULL; file->async_file = NULL;
} }
struct file *ib_uverbs_alloc_event_file(struct ib_uverbs_file *uverbs_file, void ib_uverbs_init_event_file(struct ib_uverbs_event_file *ev_file)
struct ib_device *ib_dev,
int is_async)
{ {
struct ib_uverbs_event_file *ev_file; spin_lock_init(&ev_file->lock);
INIT_LIST_HEAD(&ev_file->event_list);
init_waitqueue_head(&ev_file->poll_wait);
ev_file->is_closed = 0;
ev_file->async_queue = NULL;
}
struct file *ib_uverbs_alloc_async_event_file(struct ib_uverbs_file *uverbs_file,
struct ib_device *ib_dev)
{
struct ib_uverbs_async_event_file *ev_file;
struct file *filp; struct file *filp;
int ret; int ret;
@ -525,16 +604,11 @@ struct file *ib_uverbs_alloc_event_file(struct ib_uverbs_file *uverbs_file,
if (!ev_file) if (!ev_file)
return ERR_PTR(-ENOMEM); return ERR_PTR(-ENOMEM);
kref_init(&ev_file->ref); ib_uverbs_init_event_file(&ev_file->ev_file);
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->uverbs_file = uverbs_file;
kref_get(&ev_file->uverbs_file->ref); kref_get(&ev_file->uverbs_file->ref);
ev_file->async_queue = NULL; kref_init(&ev_file->ref);
ev_file->is_closed = 0; filp = anon_inode_getfile("[infinibandevent]", &uverbs_async_event_fops,
filp = anon_inode_getfile("[infinibandevent]", &uverbs_event_fops,
ev_file, O_RDONLY); ev_file, O_RDONLY);
if (IS_ERR(filp)) if (IS_ERR(filp))
goto err_put_refs; goto err_put_refs;
@ -544,64 +618,33 @@ struct file *ib_uverbs_alloc_event_file(struct ib_uverbs_file *uverbs_file,
&uverbs_file->device->uverbs_events_file_list); &uverbs_file->device->uverbs_events_file_list);
mutex_unlock(&uverbs_file->device->lists_mutex); mutex_unlock(&uverbs_file->device->lists_mutex);
if (is_async) { WARN_ON(uverbs_file->async_file);
WARN_ON(uverbs_file->async_file); uverbs_file->async_file = ev_file;
uverbs_file->async_file = ev_file; kref_get(&uverbs_file->async_file->ref);
kref_get(&uverbs_file->async_file->ref); INIT_IB_EVENT_HANDLER(&uverbs_file->event_handler,
INIT_IB_EVENT_HANDLER(&uverbs_file->event_handler, ib_dev,
ib_dev, ib_uverbs_event_handler);
ib_uverbs_event_handler); ret = ib_register_event_handler(&uverbs_file->event_handler);
ret = ib_register_event_handler(&uverbs_file->event_handler); if (ret)
if (ret) goto err_put_file;
goto err_put_file;
/* At that point async file stuff was fully set */ /* At that point async file stuff was fully set */
ev_file->is_async = 1;
}
return filp; return filp;
err_put_file: err_put_file:
fput(filp); fput(filp);
kref_put(&uverbs_file->async_file->ref, ib_uverbs_release_event_file); kref_put(&uverbs_file->async_file->ref,
ib_uverbs_release_async_event_file);
uverbs_file->async_file = NULL; uverbs_file->async_file = NULL;
return ERR_PTR(ret); return ERR_PTR(ret);
err_put_refs: err_put_refs:
kref_put(&ev_file->uverbs_file->ref, ib_uverbs_release_file); kref_put(&ev_file->uverbs_file->ref, ib_uverbs_release_file);
kref_put(&ev_file->ref, ib_uverbs_release_event_file); kref_put(&ev_file->ref, ib_uverbs_release_async_event_file);
return filp; return filp;
} }
/*
* 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 fd f = fdget(fd);
if (!f.file)
return NULL;
if (f.file->f_op != &uverbs_event_fops)
goto out;
ev_file = f.file->private_data;
if (ev_file->is_async) {
ev_file = NULL;
goto out;
}
kref_get(&ev_file->ref);
out:
fdput(f);
return ev_file;
}
static int verify_command_mask(struct ib_device *ib_dev, __u32 command) static int verify_command_mask(struct ib_device *ib_dev, __u32 command)
{ {
u64 mask; u64 mask;
@ -896,7 +939,8 @@ static int ib_uverbs_close(struct inode *inode, struct file *filp)
mutex_unlock(&file->device->lists_mutex); mutex_unlock(&file->device->lists_mutex);
if (file->async_file) if (file->async_file)
kref_put(&file->async_file->ref, ib_uverbs_release_event_file); kref_put(&file->async_file->ref,
ib_uverbs_release_async_event_file);
kref_put(&file->ref, ib_uverbs_release_file); kref_put(&file->ref, ib_uverbs_release_file);
kobject_put(&dev->kobj); kobject_put(&dev->kobj);
@ -1095,7 +1139,7 @@ static void ib_uverbs_free_hw_resources(struct ib_uverbs_device *uverbs_dev,
struct ib_device *ib_dev) struct ib_device *ib_dev)
{ {
struct ib_uverbs_file *file; struct ib_uverbs_file *file;
struct ib_uverbs_event_file *event_file; struct ib_uverbs_async_event_file *event_file;
struct ib_event event; struct ib_event event;
/* Pending running commands to terminate */ /* Pending running commands to terminate */
@ -1144,21 +1188,20 @@ static void ib_uverbs_free_hw_resources(struct ib_uverbs_device *uverbs_dev,
while (!list_empty(&uverbs_dev->uverbs_events_file_list)) { while (!list_empty(&uverbs_dev->uverbs_events_file_list)) {
event_file = list_first_entry(&uverbs_dev-> event_file = list_first_entry(&uverbs_dev->
uverbs_events_file_list, uverbs_events_file_list,
struct ib_uverbs_event_file, struct ib_uverbs_async_event_file,
list); list);
spin_lock_irq(&event_file->lock); spin_lock_irq(&event_file->ev_file.lock);
event_file->is_closed = 1; event_file->ev_file.is_closed = 1;
spin_unlock_irq(&event_file->lock); spin_unlock_irq(&event_file->ev_file.lock);
list_del(&event_file->list); list_del(&event_file->list);
if (event_file->is_async) { ib_unregister_event_handler(
ib_unregister_event_handler(&event_file->uverbs_file-> &event_file->uverbs_file->event_handler);
event_handler); event_file->uverbs_file->event_handler.device =
event_file->uverbs_file->event_handler.device = NULL; NULL;
}
wake_up_interruptible(&event_file->poll_wait); wake_up_interruptible(&event_file->ev_file.poll_wait);
kill_fasync(&event_file->async_queue, SIGIO, POLL_IN); kill_fasync(&event_file->ev_file.async_queue, SIGIO, POLL_IN);
} }
mutex_unlock(&uverbs_dev->lists_mutex); mutex_unlock(&uverbs_dev->lists_mutex);
} }

33
drivers/infiniband/core/uverbs_std_types.c
View File

@ -145,7 +145,11 @@ int uverbs_free_cq(struct ib_uobject *uobject,
ret = ib_destroy_cq(cq); ret = ib_destroy_cq(cq);
if (!ret || why != RDMA_REMOVE_DESTROY) if (!ret || why != RDMA_REMOVE_DESTROY)
ib_uverbs_release_ucq(uobject->context->ufile, ev_file, ucq); ib_uverbs_release_ucq(uobject->context->ufile, ev_file ?
container_of(ev_file,
struct ib_uverbs_completion_event_file,
ev_file) : NULL,
ucq);
return ret; return ret;
} }
@ -186,6 +190,33 @@ int uverbs_free_pd(struct ib_uobject *uobject,
return 0; return 0;
} }
int uverbs_hot_unplug_completion_event_file(struct ib_uobject_file *uobj_file,
enum rdma_remove_reason why)
{
struct ib_uverbs_completion_event_file *comp_event_file =
container_of(uobj_file, struct ib_uverbs_completion_event_file,
uobj_file);
struct ib_uverbs_event_file *event_file = &comp_event_file->ev_file;
spin_lock_irq(&event_file->lock);
event_file->is_closed = 1;
spin_unlock_irq(&event_file->lock);
if (why == RDMA_REMOVE_DRIVER_REMOVE) {
wake_up_interruptible(&event_file->poll_wait);
kill_fasync(&event_file->async_queue, SIGIO, POLL_IN);
}
return 0;
};
const struct uverbs_obj_fd_type uverbs_type_attrs_comp_channel = {
.type = UVERBS_TYPE_ALLOC_FD(sizeof(struct ib_uverbs_completion_event_file), 0),
.context_closed = uverbs_hot_unplug_completion_event_file,
.fops = &uverbs_event_fops,
.name = "[infinibandevent]",
.flags = O_RDONLY,
};
const struct uverbs_obj_idr_type uverbs_type_attrs_cq = { const struct uverbs_obj_idr_type uverbs_type_attrs_cq = {
.type = UVERBS_TYPE_ALLOC_IDR_SZ(sizeof(struct ib_ucq_object), 0), .type = UVERBS_TYPE_ALLOC_IDR_SZ(sizeof(struct ib_ucq_object), 0),
.destroy_object = uverbs_free_cq, .destroy_object = uverbs_free_cq,

1
include/rdma/uverbs_std_types.h
View File

@ -35,6 +35,7 @@
#include <rdma/uverbs_types.h> #include <rdma/uverbs_types.h>
extern const struct uverbs_obj_fd_type uverbs_type_attrs_comp_channel;
extern const struct uverbs_obj_idr_type uverbs_type_attrs_cq; extern const struct uverbs_obj_idr_type uverbs_type_attrs_cq;
extern const struct uverbs_obj_idr_type uverbs_type_attrs_qp; extern const struct uverbs_obj_idr_type uverbs_type_attrs_qp;
extern const struct uverbs_obj_idr_type uverbs_type_attrs_rwq_ind_table; extern const struct uverbs_obj_idr_type uverbs_type_attrs_rwq_ind_table;

9
include/rdma/uverbs_types.h
View File

@ -146,9 +146,18 @@ struct uverbs_obj_fd_type {
}; };
extern const struct uverbs_obj_type_class uverbs_idr_class; extern const struct uverbs_obj_type_class uverbs_idr_class;
extern const struct uverbs_obj_type_class uverbs_fd_class;
#define UVERBS_BUILD_BUG_ON(cond) (sizeof(char[1 - 2 * !!(cond)]) - \ #define UVERBS_BUILD_BUG_ON(cond) (sizeof(char[1 - 2 * !!(cond)]) - \
sizeof(char)) sizeof(char))
#define UVERBS_TYPE_ALLOC_FD(_size, _order) \
{ \
.destroy_order = _order, \
.type_class = &uverbs_fd_class, \
.obj_size = (_size) + \
UVERBS_BUILD_BUG_ON((_size) < \
sizeof(struct ib_uobject_file)),\
}
#define UVERBS_TYPE_ALLOC_IDR_SZ(_size, _order) \ #define UVERBS_TYPE_ALLOC_IDR_SZ(_size, _order) \
{ \ { \
.destroy_order = _order, \ .destroy_order = _order, \