1 /* 2 * Copyright (c) 2005 Topspin Communications. All rights reserved. 3 * Copyright (c) 2005, 2006 Cisco Systems. All rights reserved. 4 * Copyright (c) 2005 Mellanox Technologies. All rights reserved. 5 * Copyright (c) 2005 Voltaire, Inc. All rights reserved. 6 * Copyright (c) 2005 PathScale, Inc. All rights reserved. 7 * 8 * This software is available to you under a choice of one of two 9 * licenses. You may choose to be licensed under the terms of the GNU 10 * General Public License (GPL) Version 2, available from the file 11 * COPYING in the main directory of this source tree, or the 12 * OpenIB.org BSD license below: 13 * 14 * Redistribution and use in source and binary forms, with or 15 * without modification, are permitted provided that the following 16 * conditions are met: 17 * 18 * - Redistributions of source code must retain the above 19 * copyright notice, this list of conditions and the following 20 * disclaimer. 21 * 22 * - Redistributions in binary form must reproduce the above 23 * copyright notice, this list of conditions and the following 24 * disclaimer in the documentation and/or other materials 25 * provided with the distribution. 26 * 27 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, 28 * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF 29 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND 30 * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS 31 * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN 32 * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN 33 * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE 34 * SOFTWARE. 35 */ 36 37 #include <linux/module.h> 38 #include <linux/init.h> 39 #include <linux/device.h> 40 #include <linux/err.h> 41 #include <linux/fs.h> 42 #include <linux/poll.h> 43 #include <linux/sched.h> 44 #include <linux/file.h> 45 #include <linux/cdev.h> 46 #include <linux/anon_inodes.h> 47 #include <linux/slab.h> 48 49 #include <linux/uaccess.h> 50 51 #include <rdma/ib.h> 52 #include <rdma/uverbs_std_types.h> 53 54 #include "uverbs.h" 55 #include "core_priv.h" 56 #include "rdma_core.h" 57 58 MODULE_AUTHOR("Roland Dreier"); 59 MODULE_DESCRIPTION("InfiniBand userspace verbs access"); 60 MODULE_LICENSE("Dual BSD/GPL"); 61 62 enum { 63 IB_UVERBS_MAJOR = 231, 64 IB_UVERBS_BASE_MINOR = 192, 65 IB_UVERBS_MAX_DEVICES = 32 66 }; 67 68 #define IB_UVERBS_BASE_DEV MKDEV(IB_UVERBS_MAJOR, IB_UVERBS_BASE_MINOR) 69 70 static struct class *uverbs_class; 71 72 static DEFINE_SPINLOCK(map_lock); 73 static DECLARE_BITMAP(dev_map, IB_UVERBS_MAX_DEVICES); 74 75 static ssize_t (*uverbs_cmd_table[])(struct ib_uverbs_file *file, 76 struct ib_device *ib_dev, 77 const char __user *buf, int in_len, 78 int out_len) = { 79 [IB_USER_VERBS_CMD_GET_CONTEXT] = ib_uverbs_get_context, 80 [IB_USER_VERBS_CMD_QUERY_DEVICE] = ib_uverbs_query_device, 81 [IB_USER_VERBS_CMD_QUERY_PORT] = ib_uverbs_query_port, 82 [IB_USER_VERBS_CMD_ALLOC_PD] = ib_uverbs_alloc_pd, 83 [IB_USER_VERBS_CMD_DEALLOC_PD] = ib_uverbs_dealloc_pd, 84 [IB_USER_VERBS_CMD_REG_MR] = ib_uverbs_reg_mr, 85 [IB_USER_VERBS_CMD_REREG_MR] = ib_uverbs_rereg_mr, 86 [IB_USER_VERBS_CMD_DEREG_MR] = ib_uverbs_dereg_mr, 87 [IB_USER_VERBS_CMD_ALLOC_MW] = ib_uverbs_alloc_mw, 88 [IB_USER_VERBS_CMD_DEALLOC_MW] = ib_uverbs_dealloc_mw, 89 [IB_USER_VERBS_CMD_CREATE_COMP_CHANNEL] = ib_uverbs_create_comp_channel, 90 [IB_USER_VERBS_CMD_CREATE_CQ] = ib_uverbs_create_cq, 91 [IB_USER_VERBS_CMD_RESIZE_CQ] = ib_uverbs_resize_cq, 92 [IB_USER_VERBS_CMD_POLL_CQ] = ib_uverbs_poll_cq, 93 [IB_USER_VERBS_CMD_REQ_NOTIFY_CQ] = ib_uverbs_req_notify_cq, 94 [IB_USER_VERBS_CMD_DESTROY_CQ] = ib_uverbs_destroy_cq, 95 [IB_USER_VERBS_CMD_CREATE_QP] = ib_uverbs_create_qp, 96 [IB_USER_VERBS_CMD_QUERY_QP] = ib_uverbs_query_qp, 97 [IB_USER_VERBS_CMD_MODIFY_QP] = ib_uverbs_modify_qp, 98 [IB_USER_VERBS_CMD_DESTROY_QP] = ib_uverbs_destroy_qp, 99 [IB_USER_VERBS_CMD_POST_SEND] = ib_uverbs_post_send, 100 [IB_USER_VERBS_CMD_POST_RECV] = ib_uverbs_post_recv, 101 [IB_USER_VERBS_CMD_POST_SRQ_RECV] = ib_uverbs_post_srq_recv, 102 [IB_USER_VERBS_CMD_CREATE_AH] = ib_uverbs_create_ah, 103 [IB_USER_VERBS_CMD_DESTROY_AH] = ib_uverbs_destroy_ah, 104 [IB_USER_VERBS_CMD_ATTACH_MCAST] = ib_uverbs_attach_mcast, 105 [IB_USER_VERBS_CMD_DETACH_MCAST] = ib_uverbs_detach_mcast, 106 [IB_USER_VERBS_CMD_CREATE_SRQ] = ib_uverbs_create_srq, 107 [IB_USER_VERBS_CMD_MODIFY_SRQ] = ib_uverbs_modify_srq, 108 [IB_USER_VERBS_CMD_QUERY_SRQ] = ib_uverbs_query_srq, 109 [IB_USER_VERBS_CMD_DESTROY_SRQ] = ib_uverbs_destroy_srq, 110 [IB_USER_VERBS_CMD_OPEN_XRCD] = ib_uverbs_open_xrcd, 111 [IB_USER_VERBS_CMD_CLOSE_XRCD] = ib_uverbs_close_xrcd, 112 [IB_USER_VERBS_CMD_CREATE_XSRQ] = ib_uverbs_create_xsrq, 113 [IB_USER_VERBS_CMD_OPEN_QP] = ib_uverbs_open_qp, 114 }; 115 116 static int (*uverbs_ex_cmd_table[])(struct ib_uverbs_file *file, 117 struct ib_device *ib_dev, 118 struct ib_udata *ucore, 119 struct ib_udata *uhw) = { 120 [IB_USER_VERBS_EX_CMD_CREATE_FLOW] = ib_uverbs_ex_create_flow, 121 [IB_USER_VERBS_EX_CMD_DESTROY_FLOW] = ib_uverbs_ex_destroy_flow, 122 [IB_USER_VERBS_EX_CMD_QUERY_DEVICE] = ib_uverbs_ex_query_device, 123 [IB_USER_VERBS_EX_CMD_CREATE_CQ] = ib_uverbs_ex_create_cq, 124 [IB_USER_VERBS_EX_CMD_CREATE_QP] = ib_uverbs_ex_create_qp, 125 [IB_USER_VERBS_EX_CMD_CREATE_WQ] = ib_uverbs_ex_create_wq, 126 [IB_USER_VERBS_EX_CMD_MODIFY_WQ] = ib_uverbs_ex_modify_wq, 127 [IB_USER_VERBS_EX_CMD_DESTROY_WQ] = ib_uverbs_ex_destroy_wq, 128 [IB_USER_VERBS_EX_CMD_CREATE_RWQ_IND_TBL] = ib_uverbs_ex_create_rwq_ind_table, 129 [IB_USER_VERBS_EX_CMD_DESTROY_RWQ_IND_TBL] = ib_uverbs_ex_destroy_rwq_ind_table, 130 [IB_USER_VERBS_EX_CMD_MODIFY_QP] = ib_uverbs_ex_modify_qp, 131 }; 132 133 static void ib_uverbs_add_one(struct ib_device *device); 134 static void ib_uverbs_remove_one(struct ib_device *device, void *client_data); 135 136 int uverbs_dealloc_mw(struct ib_mw *mw) 137 { 138 struct ib_pd *pd = mw->pd; 139 int ret; 140 141 ret = mw->device->dealloc_mw(mw); 142 if (!ret) 143 atomic_dec(&pd->usecnt); 144 return ret; 145 } 146 147 static void ib_uverbs_release_dev(struct kobject *kobj) 148 { 149 struct ib_uverbs_device *dev = 150 container_of(kobj, struct ib_uverbs_device, kobj); 151 152 cleanup_srcu_struct(&dev->disassociate_srcu); 153 kfree(dev); 154 } 155 156 static struct kobj_type ib_uverbs_dev_ktype = { 157 .release = ib_uverbs_release_dev, 158 }; 159 160 static void ib_uverbs_release_async_event_file(struct kref *ref) 161 { 162 struct ib_uverbs_async_event_file *file = 163 container_of(ref, struct ib_uverbs_async_event_file, ref); 164 165 kfree(file); 166 } 167 168 void ib_uverbs_release_ucq(struct ib_uverbs_file *file, 169 struct ib_uverbs_completion_event_file *ev_file, 170 struct ib_ucq_object *uobj) 171 { 172 struct ib_uverbs_event *evt, *tmp; 173 174 if (ev_file) { 175 spin_lock_irq(&ev_file->ev_queue.lock); 176 list_for_each_entry_safe(evt, tmp, &uobj->comp_list, obj_list) { 177 list_del(&evt->list); 178 kfree(evt); 179 } 180 spin_unlock_irq(&ev_file->ev_queue.lock); 181 182 uverbs_uobject_put(&ev_file->uobj_file.uobj); 183 } 184 185 spin_lock_irq(&file->async_file->ev_queue.lock); 186 list_for_each_entry_safe(evt, tmp, &uobj->async_list, obj_list) { 187 list_del(&evt->list); 188 kfree(evt); 189 } 190 spin_unlock_irq(&file->async_file->ev_queue.lock); 191 } 192 193 void ib_uverbs_release_uevent(struct ib_uverbs_file *file, 194 struct ib_uevent_object *uobj) 195 { 196 struct ib_uverbs_event *evt, *tmp; 197 198 spin_lock_irq(&file->async_file->ev_queue.lock); 199 list_for_each_entry_safe(evt, tmp, &uobj->event_list, obj_list) { 200 list_del(&evt->list); 201 kfree(evt); 202 } 203 spin_unlock_irq(&file->async_file->ev_queue.lock); 204 } 205 206 void ib_uverbs_detach_umcast(struct ib_qp *qp, 207 struct ib_uqp_object *uobj) 208 { 209 struct ib_uverbs_mcast_entry *mcast, *tmp; 210 211 list_for_each_entry_safe(mcast, tmp, &uobj->mcast_list, list) { 212 ib_detach_mcast(qp, &mcast->gid, mcast->lid); 213 list_del(&mcast->list); 214 kfree(mcast); 215 } 216 } 217 218 static int ib_uverbs_cleanup_ucontext(struct ib_uverbs_file *file, 219 struct ib_ucontext *context, 220 bool device_removed) 221 { 222 context->closing = 1; 223 uverbs_cleanup_ucontext(context, device_removed); 224 put_pid(context->tgid); 225 226 ib_rdmacg_uncharge(&context->cg_obj, context->device, 227 RDMACG_RESOURCE_HCA_HANDLE); 228 229 return context->device->dealloc_ucontext(context); 230 } 231 232 static void ib_uverbs_comp_dev(struct ib_uverbs_device *dev) 233 { 234 complete(&dev->comp); 235 } 236 237 void ib_uverbs_release_file(struct kref *ref) 238 { 239 struct ib_uverbs_file *file = 240 container_of(ref, struct ib_uverbs_file, ref); 241 struct ib_device *ib_dev; 242 int srcu_key; 243 244 srcu_key = srcu_read_lock(&file->device->disassociate_srcu); 245 ib_dev = srcu_dereference(file->device->ib_dev, 246 &file->device->disassociate_srcu); 247 if (ib_dev && !ib_dev->disassociate_ucontext) 248 module_put(ib_dev->owner); 249 srcu_read_unlock(&file->device->disassociate_srcu, srcu_key); 250 251 if (atomic_dec_and_test(&file->device->refcount)) 252 ib_uverbs_comp_dev(file->device); 253 254 kobject_put(&file->device->kobj); 255 kfree(file); 256 } 257 258 static ssize_t ib_uverbs_event_read(struct ib_uverbs_event_queue *ev_queue, 259 struct ib_uverbs_file *uverbs_file, 260 struct file *filp, char __user *buf, 261 size_t count, loff_t *pos, 262 size_t eventsz) 263 { 264 struct ib_uverbs_event *event; 265 int ret = 0; 266 267 spin_lock_irq(&ev_queue->lock); 268 269 while (list_empty(&ev_queue->event_list)) { 270 spin_unlock_irq(&ev_queue->lock); 271 272 if (filp->f_flags & O_NONBLOCK) 273 return -EAGAIN; 274 275 if (wait_event_interruptible(ev_queue->poll_wait, 276 (!list_empty(&ev_queue->event_list) || 277 /* The barriers built into wait_event_interruptible() 278 * and wake_up() guarentee this will see the null set 279 * without using RCU 280 */ 281 !uverbs_file->device->ib_dev))) 282 return -ERESTARTSYS; 283 284 /* If device was disassociated and no event exists set an error */ 285 if (list_empty(&ev_queue->event_list) && 286 !uverbs_file->device->ib_dev) 287 return -EIO; 288 289 spin_lock_irq(&ev_queue->lock); 290 } 291 292 event = list_entry(ev_queue->event_list.next, struct ib_uverbs_event, list); 293 294 if (eventsz > count) { 295 ret = -EINVAL; 296 event = NULL; 297 } else { 298 list_del(ev_queue->event_list.next); 299 if (event->counter) { 300 ++(*event->counter); 301 list_del(&event->obj_list); 302 } 303 } 304 305 spin_unlock_irq(&ev_queue->lock); 306 307 if (event) { 308 if (copy_to_user(buf, event, eventsz)) 309 ret = -EFAULT; 310 else 311 ret = eventsz; 312 } 313 314 kfree(event); 315 316 return ret; 317 } 318 319 static ssize_t ib_uverbs_async_event_read(struct file *filp, char __user *buf, 320 size_t count, loff_t *pos) 321 { 322 struct ib_uverbs_async_event_file *file = filp->private_data; 323 324 return ib_uverbs_event_read(&file->ev_queue, file->uverbs_file, filp, 325 buf, count, pos, 326 sizeof(struct ib_uverbs_async_event_desc)); 327 } 328 329 static ssize_t ib_uverbs_comp_event_read(struct file *filp, char __user *buf, 330 size_t count, loff_t *pos) 331 { 332 struct ib_uverbs_completion_event_file *comp_ev_file = 333 filp->private_data; 334 335 return ib_uverbs_event_read(&comp_ev_file->ev_queue, 336 comp_ev_file->uobj_file.ufile, filp, 337 buf, count, pos, 338 sizeof(struct ib_uverbs_comp_event_desc)); 339 } 340 341 static unsigned int ib_uverbs_event_poll(struct ib_uverbs_event_queue *ev_queue, 342 struct file *filp, 343 struct poll_table_struct *wait) 344 { 345 unsigned int pollflags = 0; 346 347 poll_wait(filp, &ev_queue->poll_wait, wait); 348 349 spin_lock_irq(&ev_queue->lock); 350 if (!list_empty(&ev_queue->event_list)) 351 pollflags = POLLIN | POLLRDNORM; 352 spin_unlock_irq(&ev_queue->lock); 353 354 return pollflags; 355 } 356 357 static unsigned int ib_uverbs_async_event_poll(struct file *filp, 358 struct poll_table_struct *wait) 359 { 360 return ib_uverbs_event_poll(filp->private_data, filp, wait); 361 } 362 363 static unsigned int ib_uverbs_comp_event_poll(struct file *filp, 364 struct poll_table_struct *wait) 365 { 366 struct ib_uverbs_completion_event_file *comp_ev_file = 367 filp->private_data; 368 369 return ib_uverbs_event_poll(&comp_ev_file->ev_queue, filp, wait); 370 } 371 372 static int ib_uverbs_async_event_fasync(int fd, struct file *filp, int on) 373 { 374 struct ib_uverbs_event_queue *ev_queue = filp->private_data; 375 376 return fasync_helper(fd, filp, on, &ev_queue->async_queue); 377 } 378 379 static int ib_uverbs_comp_event_fasync(int fd, struct file *filp, int on) 380 { 381 struct ib_uverbs_completion_event_file *comp_ev_file = 382 filp->private_data; 383 384 return fasync_helper(fd, filp, on, &comp_ev_file->ev_queue.async_queue); 385 } 386 387 static int ib_uverbs_async_event_close(struct inode *inode, struct file *filp) 388 { 389 struct ib_uverbs_async_event_file *file = filp->private_data; 390 struct ib_uverbs_file *uverbs_file = file->uverbs_file; 391 struct ib_uverbs_event *entry, *tmp; 392 int closed_already = 0; 393 394 mutex_lock(&uverbs_file->device->lists_mutex); 395 spin_lock_irq(&file->ev_queue.lock); 396 closed_already = file->ev_queue.is_closed; 397 file->ev_queue.is_closed = 1; 398 list_for_each_entry_safe(entry, tmp, &file->ev_queue.event_list, list) { 399 if (entry->counter) 400 list_del(&entry->obj_list); 401 kfree(entry); 402 } 403 spin_unlock_irq(&file->ev_queue.lock); 404 if (!closed_already) { 405 list_del(&file->list); 406 ib_unregister_event_handler(&uverbs_file->event_handler); 407 } 408 mutex_unlock(&uverbs_file->device->lists_mutex); 409 410 kref_put(&uverbs_file->ref, ib_uverbs_release_file); 411 kref_put(&file->ref, ib_uverbs_release_async_event_file); 412 413 return 0; 414 } 415 416 static int ib_uverbs_comp_event_close(struct inode *inode, struct file *filp) 417 { 418 struct ib_uverbs_completion_event_file *file = filp->private_data; 419 struct ib_uverbs_event *entry, *tmp; 420 421 spin_lock_irq(&file->ev_queue.lock); 422 list_for_each_entry_safe(entry, tmp, &file->ev_queue.event_list, list) { 423 if (entry->counter) 424 list_del(&entry->obj_list); 425 kfree(entry); 426 } 427 spin_unlock_irq(&file->ev_queue.lock); 428 429 uverbs_close_fd(filp); 430 431 return 0; 432 } 433 434 const struct file_operations uverbs_event_fops = { 435 .owner = THIS_MODULE, 436 .read = ib_uverbs_comp_event_read, 437 .poll = ib_uverbs_comp_event_poll, 438 .release = ib_uverbs_comp_event_close, 439 .fasync = ib_uverbs_comp_event_fasync, 440 .llseek = no_llseek, 441 }; 442 443 static const struct file_operations uverbs_async_event_fops = { 444 .owner = THIS_MODULE, 445 .read = ib_uverbs_async_event_read, 446 .poll = ib_uverbs_async_event_poll, 447 .release = ib_uverbs_async_event_close, 448 .fasync = ib_uverbs_async_event_fasync, 449 .llseek = no_llseek, 450 }; 451 452 void ib_uverbs_comp_handler(struct ib_cq *cq, void *cq_context) 453 { 454 struct ib_uverbs_event_queue *ev_queue = cq_context; 455 struct ib_ucq_object *uobj; 456 struct ib_uverbs_event *entry; 457 unsigned long flags; 458 459 if (!ev_queue) 460 return; 461 462 spin_lock_irqsave(&ev_queue->lock, flags); 463 if (ev_queue->is_closed) { 464 spin_unlock_irqrestore(&ev_queue->lock, flags); 465 return; 466 } 467 468 entry = kmalloc(sizeof *entry, GFP_ATOMIC); 469 if (!entry) { 470 spin_unlock_irqrestore(&ev_queue->lock, flags); 471 return; 472 } 473 474 uobj = container_of(cq->uobject, struct ib_ucq_object, uobject); 475 476 entry->desc.comp.cq_handle = cq->uobject->user_handle; 477 entry->counter = &uobj->comp_events_reported; 478 479 list_add_tail(&entry->list, &ev_queue->event_list); 480 list_add_tail(&entry->obj_list, &uobj->comp_list); 481 spin_unlock_irqrestore(&ev_queue->lock, flags); 482 483 wake_up_interruptible(&ev_queue->poll_wait); 484 kill_fasync(&ev_queue->async_queue, SIGIO, POLL_IN); 485 } 486 487 static void ib_uverbs_async_handler(struct ib_uverbs_file *file, 488 __u64 element, __u64 event, 489 struct list_head *obj_list, 490 u32 *counter) 491 { 492 struct ib_uverbs_event *entry; 493 unsigned long flags; 494 495 spin_lock_irqsave(&file->async_file->ev_queue.lock, flags); 496 if (file->async_file->ev_queue.is_closed) { 497 spin_unlock_irqrestore(&file->async_file->ev_queue.lock, flags); 498 return; 499 } 500 501 entry = kmalloc(sizeof *entry, GFP_ATOMIC); 502 if (!entry) { 503 spin_unlock_irqrestore(&file->async_file->ev_queue.lock, flags); 504 return; 505 } 506 507 entry->desc.async.element = element; 508 entry->desc.async.event_type = event; 509 entry->desc.async.reserved = 0; 510 entry->counter = counter; 511 512 list_add_tail(&entry->list, &file->async_file->ev_queue.event_list); 513 if (obj_list) 514 list_add_tail(&entry->obj_list, obj_list); 515 spin_unlock_irqrestore(&file->async_file->ev_queue.lock, flags); 516 517 wake_up_interruptible(&file->async_file->ev_queue.poll_wait); 518 kill_fasync(&file->async_file->ev_queue.async_queue, SIGIO, POLL_IN); 519 } 520 521 void ib_uverbs_cq_event_handler(struct ib_event *event, void *context_ptr) 522 { 523 struct ib_ucq_object *uobj = container_of(event->element.cq->uobject, 524 struct ib_ucq_object, uobject); 525 526 ib_uverbs_async_handler(uobj->uverbs_file, uobj->uobject.user_handle, 527 event->event, &uobj->async_list, 528 &uobj->async_events_reported); 529 } 530 531 void ib_uverbs_qp_event_handler(struct ib_event *event, void *context_ptr) 532 { 533 struct ib_uevent_object *uobj; 534 535 /* for XRC target qp's, check that qp is live */ 536 if (!event->element.qp->uobject) 537 return; 538 539 uobj = container_of(event->element.qp->uobject, 540 struct ib_uevent_object, uobject); 541 542 ib_uverbs_async_handler(context_ptr, uobj->uobject.user_handle, 543 event->event, &uobj->event_list, 544 &uobj->events_reported); 545 } 546 547 void ib_uverbs_wq_event_handler(struct ib_event *event, void *context_ptr) 548 { 549 struct ib_uevent_object *uobj = container_of(event->element.wq->uobject, 550 struct ib_uevent_object, uobject); 551 552 ib_uverbs_async_handler(context_ptr, uobj->uobject.user_handle, 553 event->event, &uobj->event_list, 554 &uobj->events_reported); 555 } 556 557 void ib_uverbs_srq_event_handler(struct ib_event *event, void *context_ptr) 558 { 559 struct ib_uevent_object *uobj; 560 561 uobj = container_of(event->element.srq->uobject, 562 struct ib_uevent_object, uobject); 563 564 ib_uverbs_async_handler(context_ptr, uobj->uobject.user_handle, 565 event->event, &uobj->event_list, 566 &uobj->events_reported); 567 } 568 569 void ib_uverbs_event_handler(struct ib_event_handler *handler, 570 struct ib_event *event) 571 { 572 struct ib_uverbs_file *file = 573 container_of(handler, struct ib_uverbs_file, event_handler); 574 575 ib_uverbs_async_handler(file, event->element.port_num, event->event, 576 NULL, NULL); 577 } 578 579 void ib_uverbs_free_async_event_file(struct ib_uverbs_file *file) 580 { 581 kref_put(&file->async_file->ref, ib_uverbs_release_async_event_file); 582 file->async_file = NULL; 583 } 584 585 void ib_uverbs_init_event_queue(struct ib_uverbs_event_queue *ev_queue) 586 { 587 spin_lock_init(&ev_queue->lock); 588 INIT_LIST_HEAD(&ev_queue->event_list); 589 init_waitqueue_head(&ev_queue->poll_wait); 590 ev_queue->is_closed = 0; 591 ev_queue->async_queue = NULL; 592 } 593 594 struct file *ib_uverbs_alloc_async_event_file(struct ib_uverbs_file *uverbs_file, 595 struct ib_device *ib_dev) 596 { 597 struct ib_uverbs_async_event_file *ev_file; 598 struct file *filp; 599 600 ev_file = kzalloc(sizeof(*ev_file), GFP_KERNEL); 601 if (!ev_file) 602 return ERR_PTR(-ENOMEM); 603 604 ib_uverbs_init_event_queue(&ev_file->ev_queue); 605 ev_file->uverbs_file = uverbs_file; 606 kref_get(&ev_file->uverbs_file->ref); 607 kref_init(&ev_file->ref); 608 filp = anon_inode_getfile("[infinibandevent]", &uverbs_async_event_fops, 609 ev_file, O_RDONLY); 610 if (IS_ERR(filp)) 611 goto err_put_refs; 612 613 mutex_lock(&uverbs_file->device->lists_mutex); 614 list_add_tail(&ev_file->list, 615 &uverbs_file->device->uverbs_events_file_list); 616 mutex_unlock(&uverbs_file->device->lists_mutex); 617 618 WARN_ON(uverbs_file->async_file); 619 uverbs_file->async_file = ev_file; 620 kref_get(&uverbs_file->async_file->ref); 621 INIT_IB_EVENT_HANDLER(&uverbs_file->event_handler, 622 ib_dev, 623 ib_uverbs_event_handler); 624 ib_register_event_handler(&uverbs_file->event_handler); 625 /* At that point async file stuff was fully set */ 626 627 return filp; 628 629 err_put_refs: 630 kref_put(&ev_file->uverbs_file->ref, ib_uverbs_release_file); 631 kref_put(&ev_file->ref, ib_uverbs_release_async_event_file); 632 return filp; 633 } 634 635 static int verify_command_mask(struct ib_device *ib_dev, __u32 command) 636 { 637 u64 mask; 638 639 if (command <= IB_USER_VERBS_CMD_OPEN_QP) 640 mask = ib_dev->uverbs_cmd_mask; 641 else 642 mask = ib_dev->uverbs_ex_cmd_mask; 643 644 if (mask & ((u64)1 << command)) 645 return 0; 646 647 return -1; 648 } 649 650 static ssize_t ib_uverbs_write(struct file *filp, const char __user *buf, 651 size_t count, loff_t *pos) 652 { 653 struct ib_uverbs_file *file = filp->private_data; 654 struct ib_device *ib_dev; 655 struct ib_uverbs_cmd_hdr hdr; 656 __u32 command; 657 __u32 flags; 658 int srcu_key; 659 ssize_t ret; 660 661 if (!ib_safe_file_access(filp)) { 662 pr_err_once("uverbs_write: process %d (%s) changed security contexts after opening file descriptor, this is not allowed.\n", 663 task_tgid_vnr(current), current->comm); 664 return -EACCES; 665 } 666 667 if (count < sizeof hdr) 668 return -EINVAL; 669 670 if (copy_from_user(&hdr, buf, sizeof hdr)) 671 return -EFAULT; 672 673 srcu_key = srcu_read_lock(&file->device->disassociate_srcu); 674 ib_dev = srcu_dereference(file->device->ib_dev, 675 &file->device->disassociate_srcu); 676 if (!ib_dev) { 677 ret = -EIO; 678 goto out; 679 } 680 681 if (hdr.command & ~(__u32)(IB_USER_VERBS_CMD_FLAGS_MASK | 682 IB_USER_VERBS_CMD_COMMAND_MASK)) { 683 ret = -EINVAL; 684 goto out; 685 } 686 687 command = hdr.command & IB_USER_VERBS_CMD_COMMAND_MASK; 688 if (verify_command_mask(ib_dev, command)) { 689 ret = -EOPNOTSUPP; 690 goto out; 691 } 692 693 if (!file->ucontext && 694 command != IB_USER_VERBS_CMD_GET_CONTEXT) { 695 ret = -EINVAL; 696 goto out; 697 } 698 699 flags = (hdr.command & 700 IB_USER_VERBS_CMD_FLAGS_MASK) >> IB_USER_VERBS_CMD_FLAGS_SHIFT; 701 702 if (!flags) { 703 if (command >= ARRAY_SIZE(uverbs_cmd_table) || 704 !uverbs_cmd_table[command]) { 705 ret = -EINVAL; 706 goto out; 707 } 708 709 if (hdr.in_words * 4 != count) { 710 ret = -EINVAL; 711 goto out; 712 } 713 714 ret = uverbs_cmd_table[command](file, ib_dev, 715 buf + sizeof(hdr), 716 hdr.in_words * 4, 717 hdr.out_words * 4); 718 719 } else if (flags == IB_USER_VERBS_CMD_FLAG_EXTENDED) { 720 struct ib_uverbs_ex_cmd_hdr ex_hdr; 721 struct ib_udata ucore; 722 struct ib_udata uhw; 723 size_t written_count = count; 724 725 if (command >= ARRAY_SIZE(uverbs_ex_cmd_table) || 726 !uverbs_ex_cmd_table[command]) { 727 ret = -ENOSYS; 728 goto out; 729 } 730 731 if (!file->ucontext) { 732 ret = -EINVAL; 733 goto out; 734 } 735 736 if (count < (sizeof(hdr) + sizeof(ex_hdr))) { 737 ret = -EINVAL; 738 goto out; 739 } 740 741 if (copy_from_user(&ex_hdr, buf + sizeof(hdr), sizeof(ex_hdr))) { 742 ret = -EFAULT; 743 goto out; 744 } 745 746 count -= sizeof(hdr) + sizeof(ex_hdr); 747 buf += sizeof(hdr) + sizeof(ex_hdr); 748 749 if ((hdr.in_words + ex_hdr.provider_in_words) * 8 != count) { 750 ret = -EINVAL; 751 goto out; 752 } 753 754 if (ex_hdr.cmd_hdr_reserved) { 755 ret = -EINVAL; 756 goto out; 757 } 758 759 if (ex_hdr.response) { 760 if (!hdr.out_words && !ex_hdr.provider_out_words) { 761 ret = -EINVAL; 762 goto out; 763 } 764 765 if (!access_ok(VERIFY_WRITE, 766 (void __user *) (unsigned long) ex_hdr.response, 767 (hdr.out_words + ex_hdr.provider_out_words) * 8)) { 768 ret = -EFAULT; 769 goto out; 770 } 771 } else { 772 if (hdr.out_words || ex_hdr.provider_out_words) { 773 ret = -EINVAL; 774 goto out; 775 } 776 } 777 778 INIT_UDATA_BUF_OR_NULL(&ucore, buf, (unsigned long) ex_hdr.response, 779 hdr.in_words * 8, hdr.out_words * 8); 780 781 INIT_UDATA_BUF_OR_NULL(&uhw, 782 buf + ucore.inlen, 783 (unsigned long) ex_hdr.response + ucore.outlen, 784 ex_hdr.provider_in_words * 8, 785 ex_hdr.provider_out_words * 8); 786 787 ret = uverbs_ex_cmd_table[command](file, 788 ib_dev, 789 &ucore, 790 &uhw); 791 if (!ret) 792 ret = written_count; 793 } else { 794 ret = -ENOSYS; 795 } 796 797 out: 798 srcu_read_unlock(&file->device->disassociate_srcu, srcu_key); 799 return ret; 800 } 801 802 static int ib_uverbs_mmap(struct file *filp, struct vm_area_struct *vma) 803 { 804 struct ib_uverbs_file *file = filp->private_data; 805 struct ib_device *ib_dev; 806 int ret = 0; 807 int srcu_key; 808 809 srcu_key = srcu_read_lock(&file->device->disassociate_srcu); 810 ib_dev = srcu_dereference(file->device->ib_dev, 811 &file->device->disassociate_srcu); 812 if (!ib_dev) { 813 ret = -EIO; 814 goto out; 815 } 816 817 if (!file->ucontext) 818 ret = -ENODEV; 819 else 820 ret = ib_dev->mmap(file->ucontext, vma); 821 out: 822 srcu_read_unlock(&file->device->disassociate_srcu, srcu_key); 823 return ret; 824 } 825 826 /* 827 * ib_uverbs_open() does not need the BKL: 828 * 829 * - the ib_uverbs_device structures are properly reference counted and 830 * everything else is purely local to the file being created, so 831 * races against other open calls are not a problem; 832 * - there is no ioctl method to race against; 833 * - the open method will either immediately run -ENXIO, or all 834 * required initialization will be done. 835 */ 836 static int ib_uverbs_open(struct inode *inode, struct file *filp) 837 { 838 struct ib_uverbs_device *dev; 839 struct ib_uverbs_file *file; 840 struct ib_device *ib_dev; 841 int ret; 842 int module_dependent; 843 int srcu_key; 844 845 dev = container_of(inode->i_cdev, struct ib_uverbs_device, cdev); 846 if (!atomic_inc_not_zero(&dev->refcount)) 847 return -ENXIO; 848 849 srcu_key = srcu_read_lock(&dev->disassociate_srcu); 850 mutex_lock(&dev->lists_mutex); 851 ib_dev = srcu_dereference(dev->ib_dev, 852 &dev->disassociate_srcu); 853 if (!ib_dev) { 854 ret = -EIO; 855 goto err; 856 } 857 858 /* In case IB device supports disassociate ucontext, there is no hard 859 * dependency between uverbs device and its low level device. 860 */ 861 module_dependent = !(ib_dev->disassociate_ucontext); 862 863 if (module_dependent) { 864 if (!try_module_get(ib_dev->owner)) { 865 ret = -ENODEV; 866 goto err; 867 } 868 } 869 870 file = kzalloc(sizeof(*file), GFP_KERNEL); 871 if (!file) { 872 ret = -ENOMEM; 873 if (module_dependent) 874 goto err_module; 875 876 goto err; 877 } 878 879 file->device = dev; 880 spin_lock_init(&file->idr_lock); 881 idr_init(&file->idr); 882 file->ucontext = NULL; 883 file->async_file = NULL; 884 kref_init(&file->ref); 885 mutex_init(&file->mutex); 886 mutex_init(&file->cleanup_mutex); 887 888 filp->private_data = file; 889 kobject_get(&dev->kobj); 890 list_add_tail(&file->list, &dev->uverbs_file_list); 891 mutex_unlock(&dev->lists_mutex); 892 srcu_read_unlock(&dev->disassociate_srcu, srcu_key); 893 894 return nonseekable_open(inode, filp); 895 896 err_module: 897 module_put(ib_dev->owner); 898 899 err: 900 mutex_unlock(&dev->lists_mutex); 901 srcu_read_unlock(&dev->disassociate_srcu, srcu_key); 902 if (atomic_dec_and_test(&dev->refcount)) 903 ib_uverbs_comp_dev(dev); 904 905 return ret; 906 } 907 908 static int ib_uverbs_close(struct inode *inode, struct file *filp) 909 { 910 struct ib_uverbs_file *file = filp->private_data; 911 912 mutex_lock(&file->cleanup_mutex); 913 if (file->ucontext) { 914 ib_uverbs_cleanup_ucontext(file, file->ucontext, false); 915 file->ucontext = NULL; 916 } 917 mutex_unlock(&file->cleanup_mutex); 918 idr_destroy(&file->idr); 919 920 mutex_lock(&file->device->lists_mutex); 921 if (!file->is_closed) { 922 list_del(&file->list); 923 file->is_closed = 1; 924 } 925 mutex_unlock(&file->device->lists_mutex); 926 927 if (file->async_file) 928 kref_put(&file->async_file->ref, 929 ib_uverbs_release_async_event_file); 930 931 kref_put(&file->ref, ib_uverbs_release_file); 932 933 return 0; 934 } 935 936 static const struct file_operations uverbs_fops = { 937 .owner = THIS_MODULE, 938 .write = ib_uverbs_write, 939 .open = ib_uverbs_open, 940 .release = ib_uverbs_close, 941 .llseek = no_llseek, 942 #if IS_ENABLED(CONFIG_INFINIBAND_EXP_USER_ACCESS) 943 .unlocked_ioctl = ib_uverbs_ioctl, 944 #endif 945 }; 946 947 static const struct file_operations uverbs_mmap_fops = { 948 .owner = THIS_MODULE, 949 .write = ib_uverbs_write, 950 .mmap = ib_uverbs_mmap, 951 .open = ib_uverbs_open, 952 .release = ib_uverbs_close, 953 .llseek = no_llseek, 954 #if IS_ENABLED(CONFIG_INFINIBAND_EXP_USER_ACCESS) 955 .unlocked_ioctl = ib_uverbs_ioctl, 956 #endif 957 }; 958 959 static struct ib_client uverbs_client = { 960 .name = "uverbs", 961 .add = ib_uverbs_add_one, 962 .remove = ib_uverbs_remove_one 963 }; 964 965 static ssize_t show_ibdev(struct device *device, struct device_attribute *attr, 966 char *buf) 967 { 968 int ret = -ENODEV; 969 int srcu_key; 970 struct ib_uverbs_device *dev = dev_get_drvdata(device); 971 struct ib_device *ib_dev; 972 973 if (!dev) 974 return -ENODEV; 975 976 srcu_key = srcu_read_lock(&dev->disassociate_srcu); 977 ib_dev = srcu_dereference(dev->ib_dev, &dev->disassociate_srcu); 978 if (ib_dev) 979 ret = sprintf(buf, "%s\n", ib_dev->name); 980 srcu_read_unlock(&dev->disassociate_srcu, srcu_key); 981 982 return ret; 983 } 984 static DEVICE_ATTR(ibdev, S_IRUGO, show_ibdev, NULL); 985 986 static ssize_t show_dev_abi_version(struct device *device, 987 struct device_attribute *attr, char *buf) 988 { 989 struct ib_uverbs_device *dev = dev_get_drvdata(device); 990 int ret = -ENODEV; 991 int srcu_key; 992 struct ib_device *ib_dev; 993 994 if (!dev) 995 return -ENODEV; 996 srcu_key = srcu_read_lock(&dev->disassociate_srcu); 997 ib_dev = srcu_dereference(dev->ib_dev, &dev->disassociate_srcu); 998 if (ib_dev) 999 ret = sprintf(buf, "%d\n", ib_dev->uverbs_abi_ver); 1000 srcu_read_unlock(&dev->disassociate_srcu, srcu_key); 1001 1002 return ret; 1003 } 1004 static DEVICE_ATTR(abi_version, S_IRUGO, show_dev_abi_version, NULL); 1005 1006 static CLASS_ATTR_STRING(abi_version, S_IRUGO, 1007 __stringify(IB_USER_VERBS_ABI_VERSION)); 1008 1009 static dev_t overflow_maj; 1010 static DECLARE_BITMAP(overflow_map, IB_UVERBS_MAX_DEVICES); 1011 1012 /* 1013 * If we have more than IB_UVERBS_MAX_DEVICES, dynamically overflow by 1014 * requesting a new major number and doubling the number of max devices we 1015 * support. It's stupid, but simple. 1016 */ 1017 static int find_overflow_devnum(void) 1018 { 1019 int ret; 1020 1021 if (!overflow_maj) { 1022 ret = alloc_chrdev_region(&overflow_maj, 0, IB_UVERBS_MAX_DEVICES, 1023 "infiniband_verbs"); 1024 if (ret) { 1025 pr_err("user_verbs: couldn't register dynamic device number\n"); 1026 return ret; 1027 } 1028 } 1029 1030 ret = find_first_zero_bit(overflow_map, IB_UVERBS_MAX_DEVICES); 1031 if (ret >= IB_UVERBS_MAX_DEVICES) 1032 return -1; 1033 1034 return ret; 1035 } 1036 1037 static void ib_uverbs_add_one(struct ib_device *device) 1038 { 1039 int devnum; 1040 dev_t base; 1041 struct ib_uverbs_device *uverbs_dev; 1042 int ret; 1043 1044 if (!device->alloc_ucontext) 1045 return; 1046 1047 uverbs_dev = kzalloc(sizeof *uverbs_dev, GFP_KERNEL); 1048 if (!uverbs_dev) 1049 return; 1050 1051 ret = init_srcu_struct(&uverbs_dev->disassociate_srcu); 1052 if (ret) { 1053 kfree(uverbs_dev); 1054 return; 1055 } 1056 1057 atomic_set(&uverbs_dev->refcount, 1); 1058 init_completion(&uverbs_dev->comp); 1059 uverbs_dev->xrcd_tree = RB_ROOT; 1060 mutex_init(&uverbs_dev->xrcd_tree_mutex); 1061 kobject_init(&uverbs_dev->kobj, &ib_uverbs_dev_ktype); 1062 mutex_init(&uverbs_dev->lists_mutex); 1063 INIT_LIST_HEAD(&uverbs_dev->uverbs_file_list); 1064 INIT_LIST_HEAD(&uverbs_dev->uverbs_events_file_list); 1065 1066 spin_lock(&map_lock); 1067 devnum = find_first_zero_bit(dev_map, IB_UVERBS_MAX_DEVICES); 1068 if (devnum >= IB_UVERBS_MAX_DEVICES) { 1069 spin_unlock(&map_lock); 1070 devnum = find_overflow_devnum(); 1071 if (devnum < 0) 1072 goto err; 1073 1074 spin_lock(&map_lock); 1075 uverbs_dev->devnum = devnum + IB_UVERBS_MAX_DEVICES; 1076 base = devnum + overflow_maj; 1077 set_bit(devnum, overflow_map); 1078 } else { 1079 uverbs_dev->devnum = devnum; 1080 base = devnum + IB_UVERBS_BASE_DEV; 1081 set_bit(devnum, dev_map); 1082 } 1083 spin_unlock(&map_lock); 1084 1085 rcu_assign_pointer(uverbs_dev->ib_dev, device); 1086 uverbs_dev->num_comp_vectors = device->num_comp_vectors; 1087 1088 cdev_init(&uverbs_dev->cdev, NULL); 1089 uverbs_dev->cdev.owner = THIS_MODULE; 1090 uverbs_dev->cdev.ops = device->mmap ? &uverbs_mmap_fops : &uverbs_fops; 1091 cdev_set_parent(&uverbs_dev->cdev, &uverbs_dev->kobj); 1092 kobject_set_name(&uverbs_dev->cdev.kobj, "uverbs%d", uverbs_dev->devnum); 1093 if (cdev_add(&uverbs_dev->cdev, base, 1)) 1094 goto err_cdev; 1095 1096 uverbs_dev->dev = device_create(uverbs_class, device->dev.parent, 1097 uverbs_dev->cdev.dev, uverbs_dev, 1098 "uverbs%d", uverbs_dev->devnum); 1099 if (IS_ERR(uverbs_dev->dev)) 1100 goto err_cdev; 1101 1102 if (device_create_file(uverbs_dev->dev, &dev_attr_ibdev)) 1103 goto err_class; 1104 if (device_create_file(uverbs_dev->dev, &dev_attr_abi_version)) 1105 goto err_class; 1106 1107 if (!device->specs_root) { 1108 const struct uverbs_object_tree_def *default_root[] = { 1109 uverbs_default_get_objects()}; 1110 1111 uverbs_dev->specs_root = uverbs_alloc_spec_tree(1, 1112 default_root); 1113 if (IS_ERR(uverbs_dev->specs_root)) 1114 goto err_class; 1115 1116 device->specs_root = uverbs_dev->specs_root; 1117 } 1118 1119 ib_set_client_data(device, &uverbs_client, uverbs_dev); 1120 1121 return; 1122 1123 err_class: 1124 device_destroy(uverbs_class, uverbs_dev->cdev.dev); 1125 1126 err_cdev: 1127 cdev_del(&uverbs_dev->cdev); 1128 if (uverbs_dev->devnum < IB_UVERBS_MAX_DEVICES) 1129 clear_bit(devnum, dev_map); 1130 else 1131 clear_bit(devnum, overflow_map); 1132 1133 err: 1134 if (atomic_dec_and_test(&uverbs_dev->refcount)) 1135 ib_uverbs_comp_dev(uverbs_dev); 1136 wait_for_completion(&uverbs_dev->comp); 1137 kobject_put(&uverbs_dev->kobj); 1138 return; 1139 } 1140 1141 static void ib_uverbs_free_hw_resources(struct ib_uverbs_device *uverbs_dev, 1142 struct ib_device *ib_dev) 1143 { 1144 struct ib_uverbs_file *file; 1145 struct ib_uverbs_async_event_file *event_file; 1146 struct ib_event event; 1147 1148 /* Pending running commands to terminate */ 1149 synchronize_srcu(&uverbs_dev->disassociate_srcu); 1150 event.event = IB_EVENT_DEVICE_FATAL; 1151 event.element.port_num = 0; 1152 event.device = ib_dev; 1153 1154 mutex_lock(&uverbs_dev->lists_mutex); 1155 while (!list_empty(&uverbs_dev->uverbs_file_list)) { 1156 struct ib_ucontext *ucontext; 1157 file = list_first_entry(&uverbs_dev->uverbs_file_list, 1158 struct ib_uverbs_file, list); 1159 file->is_closed = 1; 1160 list_del(&file->list); 1161 kref_get(&file->ref); 1162 mutex_unlock(&uverbs_dev->lists_mutex); 1163 1164 1165 mutex_lock(&file->cleanup_mutex); 1166 ucontext = file->ucontext; 1167 file->ucontext = NULL; 1168 mutex_unlock(&file->cleanup_mutex); 1169 1170 /* At this point ib_uverbs_close cannot be running 1171 * ib_uverbs_cleanup_ucontext 1172 */ 1173 if (ucontext) { 1174 /* We must release the mutex before going ahead and 1175 * calling disassociate_ucontext. disassociate_ucontext 1176 * might end up indirectly calling uverbs_close, 1177 * for example due to freeing the resources 1178 * (e.g mmput). 1179 */ 1180 ib_uverbs_event_handler(&file->event_handler, &event); 1181 ib_dev->disassociate_ucontext(ucontext); 1182 mutex_lock(&file->cleanup_mutex); 1183 ib_uverbs_cleanup_ucontext(file, ucontext, true); 1184 mutex_unlock(&file->cleanup_mutex); 1185 } 1186 1187 mutex_lock(&uverbs_dev->lists_mutex); 1188 kref_put(&file->ref, ib_uverbs_release_file); 1189 } 1190 1191 while (!list_empty(&uverbs_dev->uverbs_events_file_list)) { 1192 event_file = list_first_entry(&uverbs_dev-> 1193 uverbs_events_file_list, 1194 struct ib_uverbs_async_event_file, 1195 list); 1196 spin_lock_irq(&event_file->ev_queue.lock); 1197 event_file->ev_queue.is_closed = 1; 1198 spin_unlock_irq(&event_file->ev_queue.lock); 1199 1200 list_del(&event_file->list); 1201 ib_unregister_event_handler( 1202 &event_file->uverbs_file->event_handler); 1203 event_file->uverbs_file->event_handler.device = 1204 NULL; 1205 1206 wake_up_interruptible(&event_file->ev_queue.poll_wait); 1207 kill_fasync(&event_file->ev_queue.async_queue, SIGIO, POLL_IN); 1208 } 1209 mutex_unlock(&uverbs_dev->lists_mutex); 1210 } 1211 1212 static void ib_uverbs_remove_one(struct ib_device *device, void *client_data) 1213 { 1214 struct ib_uverbs_device *uverbs_dev = client_data; 1215 int wait_clients = 1; 1216 1217 if (!uverbs_dev) 1218 return; 1219 1220 dev_set_drvdata(uverbs_dev->dev, NULL); 1221 device_destroy(uverbs_class, uverbs_dev->cdev.dev); 1222 cdev_del(&uverbs_dev->cdev); 1223 1224 if (uverbs_dev->devnum < IB_UVERBS_MAX_DEVICES) 1225 clear_bit(uverbs_dev->devnum, dev_map); 1226 else 1227 clear_bit(uverbs_dev->devnum - IB_UVERBS_MAX_DEVICES, overflow_map); 1228 1229 if (device->disassociate_ucontext) { 1230 /* We disassociate HW resources and immediately return. 1231 * Userspace will see a EIO errno for all future access. 1232 * Upon returning, ib_device may be freed internally and is not 1233 * valid any more. 1234 * uverbs_device is still available until all clients close 1235 * their files, then the uverbs device ref count will be zero 1236 * and its resources will be freed. 1237 * Note: At this point no more files can be opened since the 1238 * cdev was deleted, however active clients can still issue 1239 * commands and close their open files. 1240 */ 1241 rcu_assign_pointer(uverbs_dev->ib_dev, NULL); 1242 ib_uverbs_free_hw_resources(uverbs_dev, device); 1243 wait_clients = 0; 1244 } 1245 1246 if (atomic_dec_and_test(&uverbs_dev->refcount)) 1247 ib_uverbs_comp_dev(uverbs_dev); 1248 if (wait_clients) 1249 wait_for_completion(&uverbs_dev->comp); 1250 if (uverbs_dev->specs_root) { 1251 uverbs_free_spec_tree(uverbs_dev->specs_root); 1252 device->specs_root = NULL; 1253 } 1254 1255 kobject_put(&uverbs_dev->kobj); 1256 } 1257 1258 static char *uverbs_devnode(struct device *dev, umode_t *mode) 1259 { 1260 if (mode) 1261 *mode = 0666; 1262 return kasprintf(GFP_KERNEL, "infiniband/%s", dev_name(dev)); 1263 } 1264 1265 static int __init ib_uverbs_init(void) 1266 { 1267 int ret; 1268 1269 ret = register_chrdev_region(IB_UVERBS_BASE_DEV, IB_UVERBS_MAX_DEVICES, 1270 "infiniband_verbs"); 1271 if (ret) { 1272 pr_err("user_verbs: couldn't register device number\n"); 1273 goto out; 1274 } 1275 1276 uverbs_class = class_create(THIS_MODULE, "infiniband_verbs"); 1277 if (IS_ERR(uverbs_class)) { 1278 ret = PTR_ERR(uverbs_class); 1279 pr_err("user_verbs: couldn't create class infiniband_verbs\n"); 1280 goto out_chrdev; 1281 } 1282 1283 uverbs_class->devnode = uverbs_devnode; 1284 1285 ret = class_create_file(uverbs_class, &class_attr_abi_version.attr); 1286 if (ret) { 1287 pr_err("user_verbs: couldn't create abi_version attribute\n"); 1288 goto out_class; 1289 } 1290 1291 ret = ib_register_client(&uverbs_client); 1292 if (ret) { 1293 pr_err("user_verbs: couldn't register client\n"); 1294 goto out_class; 1295 } 1296 1297 return 0; 1298 1299 out_class: 1300 class_destroy(uverbs_class); 1301 1302 out_chrdev: 1303 unregister_chrdev_region(IB_UVERBS_BASE_DEV, IB_UVERBS_MAX_DEVICES); 1304 1305 out: 1306 return ret; 1307 } 1308 1309 static void __exit ib_uverbs_cleanup(void) 1310 { 1311 ib_unregister_client(&uverbs_client); 1312 class_destroy(uverbs_class); 1313 unregister_chrdev_region(IB_UVERBS_BASE_DEV, IB_UVERBS_MAX_DEVICES); 1314 if (overflow_maj) 1315 unregister_chrdev_region(overflow_maj, IB_UVERBS_MAX_DEVICES); 1316 } 1317 1318 module_init(ib_uverbs_init); 1319 module_exit(ib_uverbs_cleanup); 1320