1/* 2 * Copyright (c) 2005 Topspin Communications. All rights reserved. 3 * Copyright (c) 2005 Intel Corporation. All rights reserved. 4 * 5 * This software is available to you under a choice of one of two 6 * licenses. You may choose to be licensed under the terms of the GNU 7 * General Public License (GPL) Version 2, available from the file 8 * COPYING in the main directory of this source tree, or the 9 * OpenIB.org BSD license below: 10 * 11 * Redistribution and use in source and binary forms, with or 12 * without modification, are permitted provided that the following 13 * conditions are met: 14 * 15 * - Redistributions of source code must retain the above 16 * copyright notice, this list of conditions and the following 17 * disclaimer. 18 * 19 * - Redistributions in binary form must reproduce the above 20 * copyright notice, this list of conditions and the following 21 * disclaimer in the documentation and/or other materials 22 * provided with the distribution. 23 * 24 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, 25 * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF 26 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND 27 * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS 28 * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN 29 * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN 30 * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE 31 * SOFTWARE. 32 */ 33 34#include <linux/completion.h> 35#include <linux/fs.h> 36#include <linux/module.h> 37#include <linux/device.h> 38#include <linux/err.h> 39#include <linux/poll.h> 40#include <linux/sched.h> 41#include <linux/file.h> 42#include <linux/cdev.h> 43#include <linux/idr.h> 44#include <linux/mutex.h> 45#include <linux/slab.h> 46#include <linux/string.h> 47 48#include <asm/uaccess.h> 49 50#include <rdma/ib_cm.h> 51#include <rdma/ib_user_cm.h> 52#include <rdma/ib_marshall.h> 53 54MODULE_AUTHOR("Libor Michalek"); 55MODULE_DESCRIPTION("InfiniBand userspace Connection Manager access"); 56MODULE_LICENSE("Dual BSD/GPL"); 57 58struct ib_ucm_device { 59 int devnum; 60 struct cdev cdev; 61 struct device dev; 62 struct ib_device *ib_dev; 63}; 64 65struct ib_ucm_file { 66 struct mutex file_mutex; 67 struct file *filp; 68 struct ib_ucm_device *device; 69 70 struct list_head ctxs; 71 struct list_head events; 72 wait_queue_head_t poll_wait; 73}; 74 75struct ib_ucm_context { 76 int id; 77 struct completion comp; 78 atomic_t ref; 79 int events_reported; 80 81 struct ib_ucm_file *file; 82 struct ib_cm_id *cm_id; 83 __u64 uid; 84 85 struct list_head events; /* list of pending events. */ 86 struct list_head file_list; /* member in file ctx list */ 87}; 88 89struct ib_ucm_event { 90 struct ib_ucm_context *ctx; 91 struct list_head file_list; /* member in file event list */ 92 struct list_head ctx_list; /* member in ctx event list */ 93 94 struct ib_cm_id *cm_id; 95 struct ib_ucm_event_resp resp; 96 void *data; 97 void *info; 98 int data_len; 99 int info_len; 100}; 101 102enum { 103 IB_UCM_MAJOR = 231, 104 IB_UCM_BASE_MINOR = 224, 105 IB_UCM_MAX_DEVICES = 32 106}; 107 108#define IB_UCM_BASE_DEV MKDEV(IB_UCM_MAJOR, IB_UCM_BASE_MINOR) 109 110static void ib_ucm_add_one(struct ib_device *device); 111static void ib_ucm_remove_one(struct ib_device *device); 112 113static struct ib_client ucm_client = { 114 .name = "ucm", 115 .add = ib_ucm_add_one, 116 .remove = ib_ucm_remove_one 117}; 118 119static DEFINE_MUTEX(ctx_id_mutex); 120static DEFINE_IDR(ctx_id_table); 121static DECLARE_BITMAP(dev_map, IB_UCM_MAX_DEVICES); 122 123static struct ib_ucm_context *ib_ucm_ctx_get(struct ib_ucm_file *file, int id) 124{ 125 struct ib_ucm_context *ctx; 126 127 mutex_lock(&ctx_id_mutex); 128 ctx = idr_find(&ctx_id_table, id); 129 if (!ctx) 130 ctx = ERR_PTR(-ENOENT); 131 else if (ctx->file != file) 132 ctx = ERR_PTR(-EINVAL); 133 else 134 atomic_inc(&ctx->ref); 135 mutex_unlock(&ctx_id_mutex); 136 137 return ctx; 138} 139 140static void ib_ucm_ctx_put(struct ib_ucm_context *ctx) 141{ 142 if (atomic_dec_and_test(&ctx->ref)) 143 complete(&ctx->comp); 144} 145 146static inline int ib_ucm_new_cm_id(int event) 147{ 148 return event == IB_CM_REQ_RECEIVED || event == IB_CM_SIDR_REQ_RECEIVED; 149} 150 151static void ib_ucm_cleanup_events(struct ib_ucm_context *ctx) 152{ 153 struct ib_ucm_event *uevent; 154 155 mutex_lock(&ctx->file->file_mutex); 156 list_del(&ctx->file_list); 157 while (!list_empty(&ctx->events)) { 158 159 uevent = list_entry(ctx->events.next, 160 struct ib_ucm_event, ctx_list); 161 list_del(&uevent->file_list); 162 list_del(&uevent->ctx_list); 163 mutex_unlock(&ctx->file->file_mutex); 164 165 /* clear incoming connections. */ 166 if (ib_ucm_new_cm_id(uevent->resp.event)) 167 ib_destroy_cm_id(uevent->cm_id); 168 169 kfree(uevent); 170 mutex_lock(&ctx->file->file_mutex); 171 } 172 mutex_unlock(&ctx->file->file_mutex); 173} 174 175static struct ib_ucm_context *ib_ucm_ctx_alloc(struct ib_ucm_file *file) 176{ 177 struct ib_ucm_context *ctx; 178 int result; 179 180 ctx = kzalloc(sizeof *ctx, GFP_KERNEL); 181 if (!ctx) 182 return NULL; 183 184 atomic_set(&ctx->ref, 1); 185 init_completion(&ctx->comp); 186 ctx->file = file; 187 INIT_LIST_HEAD(&ctx->events); 188 189 do { 190 result = idr_pre_get(&ctx_id_table, GFP_KERNEL); 191 if (!result) 192 goto error; 193 194 mutex_lock(&ctx_id_mutex); 195 result = idr_get_new(&ctx_id_table, ctx, &ctx->id); 196 mutex_unlock(&ctx_id_mutex); 197 } while (result == -EAGAIN); 198 199 if (result) 200 goto error; 201 202 list_add_tail(&ctx->file_list, &file->ctxs); 203 return ctx; 204 205error: 206 kfree(ctx); 207 return NULL; 208} 209 210static void ib_ucm_event_req_get(struct ib_ucm_req_event_resp *ureq, 211 struct ib_cm_req_event_param *kreq) 212{ 213 ureq->remote_ca_guid = kreq->remote_ca_guid; 214 ureq->remote_qkey = kreq->remote_qkey; 215 ureq->remote_qpn = kreq->remote_qpn; 216 ureq->qp_type = kreq->qp_type; 217 ureq->starting_psn = kreq->starting_psn; 218 ureq->responder_resources = kreq->responder_resources; 219 ureq->initiator_depth = kreq->initiator_depth; 220 ureq->local_cm_response_timeout = kreq->local_cm_response_timeout; 221 ureq->flow_control = kreq->flow_control; 222 ureq->remote_cm_response_timeout = kreq->remote_cm_response_timeout; 223 ureq->retry_count = kreq->retry_count; 224 ureq->rnr_retry_count = kreq->rnr_retry_count; 225 ureq->srq = kreq->srq; 226 ureq->port = kreq->port; 227 228 ib_copy_path_rec_to_user(&ureq->primary_path, kreq->primary_path); 229 if (kreq->alternate_path) 230 ib_copy_path_rec_to_user(&ureq->alternate_path, 231 kreq->alternate_path); 232} 233 234static void ib_ucm_event_rep_get(struct ib_ucm_rep_event_resp *urep, 235 struct ib_cm_rep_event_param *krep) 236{ 237 urep->remote_ca_guid = krep->remote_ca_guid; 238 urep->remote_qkey = krep->remote_qkey; 239 urep->remote_qpn = krep->remote_qpn; 240 urep->starting_psn = krep->starting_psn; 241 urep->responder_resources = krep->responder_resources; 242 urep->initiator_depth = krep->initiator_depth; 243 urep->target_ack_delay = krep->target_ack_delay; 244 urep->failover_accepted = krep->failover_accepted; 245 urep->flow_control = krep->flow_control; 246 urep->rnr_retry_count = krep->rnr_retry_count; 247 urep->srq = krep->srq; 248} 249 250static void ib_ucm_event_sidr_rep_get(struct ib_ucm_sidr_rep_event_resp *urep, 251 struct ib_cm_sidr_rep_event_param *krep) 252{ 253 urep->status = krep->status; 254 urep->qkey = krep->qkey; 255 urep->qpn = krep->qpn; 256}; 257 258static int ib_ucm_event_process(struct ib_cm_event *evt, 259 struct ib_ucm_event *uvt) 260{ 261 void *info = NULL; 262 263 switch (evt->event) { 264 case IB_CM_REQ_RECEIVED: 265 ib_ucm_event_req_get(&uvt->resp.u.req_resp, 266 &evt->param.req_rcvd); 267 uvt->data_len = IB_CM_REQ_PRIVATE_DATA_SIZE; 268 uvt->resp.present = IB_UCM_PRES_PRIMARY; 269 uvt->resp.present |= (evt->param.req_rcvd.alternate_path ? 270 IB_UCM_PRES_ALTERNATE : 0); 271 break; 272 case IB_CM_REP_RECEIVED: 273 ib_ucm_event_rep_get(&uvt->resp.u.rep_resp, 274 &evt->param.rep_rcvd); 275 uvt->data_len = IB_CM_REP_PRIVATE_DATA_SIZE; 276 break; 277 case IB_CM_RTU_RECEIVED: 278 uvt->data_len = IB_CM_RTU_PRIVATE_DATA_SIZE; 279 uvt->resp.u.send_status = evt->param.send_status; 280 break; 281 case IB_CM_DREQ_RECEIVED: 282 uvt->data_len = IB_CM_DREQ_PRIVATE_DATA_SIZE; 283 uvt->resp.u.send_status = evt->param.send_status; 284 break; 285 case IB_CM_DREP_RECEIVED: 286 uvt->data_len = IB_CM_DREP_PRIVATE_DATA_SIZE; 287 uvt->resp.u.send_status = evt->param.send_status; 288 break; 289 case IB_CM_MRA_RECEIVED: 290 uvt->resp.u.mra_resp.timeout = 291 evt->param.mra_rcvd.service_timeout; 292 uvt->data_len = IB_CM_MRA_PRIVATE_DATA_SIZE; 293 break; 294 case IB_CM_REJ_RECEIVED: 295 uvt->resp.u.rej_resp.reason = evt->param.rej_rcvd.reason; 296 uvt->data_len = IB_CM_REJ_PRIVATE_DATA_SIZE; 297 uvt->info_len = evt->param.rej_rcvd.ari_length; 298 info = evt->param.rej_rcvd.ari; 299 break; 300 case IB_CM_LAP_RECEIVED: 301 ib_copy_path_rec_to_user(&uvt->resp.u.lap_resp.path, 302 evt->param.lap_rcvd.alternate_path); 303 uvt->data_len = IB_CM_LAP_PRIVATE_DATA_SIZE; 304 uvt->resp.present = IB_UCM_PRES_ALTERNATE; 305 break; 306 case IB_CM_APR_RECEIVED: 307 uvt->resp.u.apr_resp.status = evt->param.apr_rcvd.ap_status; 308 uvt->data_len = IB_CM_APR_PRIVATE_DATA_SIZE; 309 uvt->info_len = evt->param.apr_rcvd.info_len; 310 info = evt->param.apr_rcvd.apr_info; 311 break; 312 case IB_CM_SIDR_REQ_RECEIVED: 313 uvt->resp.u.sidr_req_resp.pkey = 314 evt->param.sidr_req_rcvd.pkey; 315 uvt->resp.u.sidr_req_resp.port = 316 evt->param.sidr_req_rcvd.port; 317 uvt->data_len = IB_CM_SIDR_REQ_PRIVATE_DATA_SIZE; 318 break; 319 case IB_CM_SIDR_REP_RECEIVED: 320 ib_ucm_event_sidr_rep_get(&uvt->resp.u.sidr_rep_resp, 321 &evt->param.sidr_rep_rcvd); 322 uvt->data_len = IB_CM_SIDR_REP_PRIVATE_DATA_SIZE; 323 uvt->info_len = evt->param.sidr_rep_rcvd.info_len; 324 info = evt->param.sidr_rep_rcvd.info; 325 break; 326 default: 327 uvt->resp.u.send_status = evt->param.send_status; 328 break; 329 } 330 331 if (uvt->data_len) { 332 uvt->data = kmemdup(evt->private_data, uvt->data_len, GFP_KERNEL); 333 if (!uvt->data) 334 goto err1; 335 336 uvt->resp.present |= IB_UCM_PRES_DATA; 337 } 338 339 if (uvt->info_len) { 340 uvt->info = kmemdup(info, uvt->info_len, GFP_KERNEL); 341 if (!uvt->info) 342 goto err2; 343 344 uvt->resp.present |= IB_UCM_PRES_INFO; 345 } 346 return 0; 347 348err2: 349 kfree(uvt->data); 350err1: 351 return -ENOMEM; 352} 353 354static int ib_ucm_event_handler(struct ib_cm_id *cm_id, 355 struct ib_cm_event *event) 356{ 357 struct ib_ucm_event *uevent; 358 struct ib_ucm_context *ctx; 359 int result = 0; 360 361 ctx = cm_id->context; 362 363 uevent = kzalloc(sizeof *uevent, GFP_KERNEL); 364 if (!uevent) 365 goto err1; 366 367 uevent->ctx = ctx; 368 uevent->cm_id = cm_id; 369 uevent->resp.uid = ctx->uid; 370 uevent->resp.id = ctx->id; 371 uevent->resp.event = event->event; 372 373 result = ib_ucm_event_process(event, uevent); 374 if (result) 375 goto err2; 376 377 mutex_lock(&ctx->file->file_mutex); 378 list_add_tail(&uevent->file_list, &ctx->file->events); 379 list_add_tail(&uevent->ctx_list, &ctx->events); 380 wake_up_interruptible(&ctx->file->poll_wait); 381 if (ctx->file->filp) 382 selwakeup(&ctx->file->filp->f_selinfo); 383 mutex_unlock(&ctx->file->file_mutex); 384 return 0; 385 386err2: 387 kfree(uevent); 388err1: 389 /* Destroy new cm_id's */ 390 return ib_ucm_new_cm_id(event->event); 391} 392 393static ssize_t ib_ucm_event(struct ib_ucm_file *file, 394 const char __user *inbuf, 395 int in_len, int out_len) 396{ 397 struct ib_ucm_context *ctx; 398 struct ib_ucm_event_get cmd; 399 struct ib_ucm_event *uevent; 400 int result = 0; 401 402 if (out_len < sizeof(struct ib_ucm_event_resp)) 403 return -ENOSPC; 404 405 if (copy_from_user(&cmd, inbuf, sizeof(cmd))) 406 return -EFAULT; 407 408 mutex_lock(&file->file_mutex); 409 while (list_empty(&file->events)) { 410 mutex_unlock(&file->file_mutex); 411 412 if (file->filp->f_flags & O_NONBLOCK) 413 return -EAGAIN; 414 415 if (wait_event_interruptible(file->poll_wait, 416 !list_empty(&file->events))) 417 return -ERESTARTSYS; 418 419 mutex_lock(&file->file_mutex); 420 } 421 422 uevent = list_entry(file->events.next, struct ib_ucm_event, file_list); 423 424 if (ib_ucm_new_cm_id(uevent->resp.event)) { 425 ctx = ib_ucm_ctx_alloc(file); 426 if (!ctx) { 427 result = -ENOMEM; 428 goto done; 429 } 430 431 ctx->cm_id = uevent->cm_id; 432 ctx->cm_id->context = ctx; 433 uevent->resp.id = ctx->id; 434 } 435 436 if (copy_to_user((void __user *)(unsigned long)cmd.response, 437 &uevent->resp, sizeof(uevent->resp))) { 438 result = -EFAULT; 439 goto done; 440 } 441 442 if (uevent->data) { 443 if (cmd.data_len < uevent->data_len) { 444 result = -ENOMEM; 445 goto done; 446 } 447 if (copy_to_user((void __user *)(unsigned long)cmd.data, 448 uevent->data, uevent->data_len)) { 449 result = -EFAULT; 450 goto done; 451 } 452 } 453 454 if (uevent->info) { 455 if (cmd.info_len < uevent->info_len) { 456 result = -ENOMEM; 457 goto done; 458 } 459 if (copy_to_user((void __user *)(unsigned long)cmd.info, 460 uevent->info, uevent->info_len)) { 461 result = -EFAULT; 462 goto done; 463 } 464 } 465 466 list_del(&uevent->file_list); 467 list_del(&uevent->ctx_list); 468 uevent->ctx->events_reported++; 469 470 kfree(uevent->data); 471 kfree(uevent->info); 472 kfree(uevent); 473done: 474 mutex_unlock(&file->file_mutex); 475 return result; 476} 477 478static ssize_t ib_ucm_create_id(struct ib_ucm_file *file, 479 const char __user *inbuf, 480 int in_len, int out_len) 481{ 482 struct ib_ucm_create_id cmd; 483 struct ib_ucm_create_id_resp resp; 484 struct ib_ucm_context *ctx; 485 int result; 486 487 if (out_len < sizeof(resp)) 488 return -ENOSPC; 489 490 if (copy_from_user(&cmd, inbuf, sizeof(cmd))) 491 return -EFAULT; 492 493 mutex_lock(&file->file_mutex); 494 ctx = ib_ucm_ctx_alloc(file); 495 mutex_unlock(&file->file_mutex); 496 if (!ctx) 497 return -ENOMEM; 498 499 ctx->uid = cmd.uid; 500 ctx->cm_id = ib_create_cm_id(file->device->ib_dev, 501 ib_ucm_event_handler, ctx); 502 if (IS_ERR(ctx->cm_id)) { 503 result = PTR_ERR(ctx->cm_id); 504 goto err1; 505 } 506 507 resp.id = ctx->id; 508 if (copy_to_user((void __user *)(unsigned long)cmd.response, 509 &resp, sizeof(resp))) { 510 result = -EFAULT; 511 goto err2; 512 } 513 return 0; 514 515err2: 516 ib_destroy_cm_id(ctx->cm_id); 517err1: 518 mutex_lock(&ctx_id_mutex); 519 idr_remove(&ctx_id_table, ctx->id); 520 mutex_unlock(&ctx_id_mutex); 521 kfree(ctx); 522 return result; 523} 524 525static ssize_t ib_ucm_destroy_id(struct ib_ucm_file *file, 526 const char __user *inbuf, 527 int in_len, int out_len) 528{ 529 struct ib_ucm_destroy_id cmd; 530 struct ib_ucm_destroy_id_resp resp; 531 struct ib_ucm_context *ctx; 532 int result = 0; 533 534 if (out_len < sizeof(resp)) 535 return -ENOSPC; 536 537 if (copy_from_user(&cmd, inbuf, sizeof(cmd))) 538 return -EFAULT; 539 540 mutex_lock(&ctx_id_mutex); 541 ctx = idr_find(&ctx_id_table, cmd.id); 542 if (!ctx) 543 ctx = ERR_PTR(-ENOENT); 544 else if (ctx->file != file) 545 ctx = ERR_PTR(-EINVAL); 546 else 547 idr_remove(&ctx_id_table, ctx->id); 548 mutex_unlock(&ctx_id_mutex); 549 550 if (IS_ERR(ctx)) 551 return PTR_ERR(ctx); 552 553 ib_ucm_ctx_put(ctx); 554 wait_for_completion(&ctx->comp); 555 556 /* No new events will be generated after destroying the cm_id. */ 557 ib_destroy_cm_id(ctx->cm_id); 558 /* Cleanup events not yet reported to the user. */ 559 ib_ucm_cleanup_events(ctx); 560 561 resp.events_reported = ctx->events_reported; 562 if (copy_to_user((void __user *)(unsigned long)cmd.response, 563 &resp, sizeof(resp))) 564 result = -EFAULT; 565 566 kfree(ctx); 567 return result; 568} 569 570static ssize_t ib_ucm_attr_id(struct ib_ucm_file *file, 571 const char __user *inbuf, 572 int in_len, int out_len) 573{ 574 struct ib_ucm_attr_id_resp resp; 575 struct ib_ucm_attr_id cmd; 576 struct ib_ucm_context *ctx; 577 int result = 0; 578 579 if (out_len < sizeof(resp)) 580 return -ENOSPC; 581 582 if (copy_from_user(&cmd, inbuf, sizeof(cmd))) 583 return -EFAULT; 584 585 ctx = ib_ucm_ctx_get(file, cmd.id); 586 if (IS_ERR(ctx)) 587 return PTR_ERR(ctx); 588 589 resp.service_id = ctx->cm_id->service_id; 590 resp.service_mask = ctx->cm_id->service_mask; 591 resp.local_id = ctx->cm_id->local_id; 592 resp.remote_id = ctx->cm_id->remote_id; 593 594 if (copy_to_user((void __user *)(unsigned long)cmd.response, 595 &resp, sizeof(resp))) 596 result = -EFAULT; 597 598 ib_ucm_ctx_put(ctx); 599 return result; 600} 601 602static ssize_t ib_ucm_init_qp_attr(struct ib_ucm_file *file, 603 const char __user *inbuf, 604 int in_len, int out_len) 605{ 606 struct ib_uverbs_qp_attr resp; 607 struct ib_ucm_init_qp_attr cmd; 608 struct ib_ucm_context *ctx; 609 struct ib_qp_attr qp_attr; 610 int result = 0; 611 612 if (out_len < sizeof(resp)) 613 return -ENOSPC; 614 615 if (copy_from_user(&cmd, inbuf, sizeof(cmd))) 616 return -EFAULT; 617 618 ctx = ib_ucm_ctx_get(file, cmd.id); 619 if (IS_ERR(ctx)) 620 return PTR_ERR(ctx); 621 622 resp.qp_attr_mask = 0; 623 memset(&qp_attr, 0, sizeof qp_attr); 624 qp_attr.qp_state = cmd.qp_state; 625 result = ib_cm_init_qp_attr(ctx->cm_id, &qp_attr, &resp.qp_attr_mask); 626 if (result) 627 goto out; 628 629 ib_copy_qp_attr_to_user(&resp, &qp_attr); 630 631 if (copy_to_user((void __user *)(unsigned long)cmd.response, 632 &resp, sizeof(resp))) 633 result = -EFAULT; 634 635out: 636 ib_ucm_ctx_put(ctx); 637 return result; 638} 639 640static int ucm_validate_listen(__be64 service_id, __be64 service_mask) 641{ 642 service_id &= service_mask; 643 644 if (((service_id & IB_CMA_SERVICE_ID_MASK) == IB_CMA_SERVICE_ID) || 645 ((service_id & IB_SDP_SERVICE_ID_MASK) == IB_SDP_SERVICE_ID)) 646 return -EINVAL; 647 648 return 0; 649} 650 651static ssize_t ib_ucm_listen(struct ib_ucm_file *file, 652 const char __user *inbuf, 653 int in_len, int out_len) 654{ 655 struct ib_ucm_listen cmd; 656 struct ib_ucm_context *ctx; 657 int result; 658 659 if (copy_from_user(&cmd, inbuf, sizeof(cmd))) 660 return -EFAULT; 661 662 ctx = ib_ucm_ctx_get(file, cmd.id); 663 if (IS_ERR(ctx)) 664 return PTR_ERR(ctx); 665 666 result = ucm_validate_listen(cmd.service_id, cmd.service_mask); 667 if (result) 668 goto out; 669 670 result = ib_cm_listen(ctx->cm_id, cmd.service_id, cmd.service_mask, 671 NULL); 672out: 673 ib_ucm_ctx_put(ctx); 674 return result; 675} 676 677static ssize_t ib_ucm_notify(struct ib_ucm_file *file, 678 const char __user *inbuf, 679 int in_len, int out_len) 680{ 681 struct ib_ucm_notify cmd; 682 struct ib_ucm_context *ctx; 683 int result; 684 685 if (copy_from_user(&cmd, inbuf, sizeof(cmd))) 686 return -EFAULT; 687 688 ctx = ib_ucm_ctx_get(file, cmd.id); 689 if (IS_ERR(ctx)) 690 return PTR_ERR(ctx); 691 692 result = ib_cm_notify(ctx->cm_id, (enum ib_event_type) cmd.event); 693 ib_ucm_ctx_put(ctx); 694 return result; 695} 696 697static int ib_ucm_alloc_data(const void **dest, u64 src, u32 len) 698{ 699 void *data; 700 701 *dest = NULL; 702 703 if (!len) 704 return 0; 705 706 data = kmalloc(len, GFP_KERNEL); 707 if (!data) 708 return -ENOMEM; 709 710 if (copy_from_user(data, (void __user *)(unsigned long)src, len)) { 711 kfree(data); 712 return -EFAULT; 713 } 714 715 *dest = data; 716 return 0; 717} 718 719static int ib_ucm_path_get(struct ib_sa_path_rec **path, u64 src) 720{ 721 struct ib_user_path_rec upath; 722 struct ib_sa_path_rec *sa_path; 723 724 *path = NULL; 725 726 if (!src) 727 return 0; 728 729 sa_path = kmalloc(sizeof(*sa_path), GFP_KERNEL); 730 if (!sa_path) 731 return -ENOMEM; 732 733 if (copy_from_user(&upath, (void __user *)(unsigned long)src, 734 sizeof(upath))) { 735 736 kfree(sa_path); 737 return -EFAULT; 738 } 739 740 ib_copy_path_rec_from_user(sa_path, &upath); 741 *path = sa_path; 742 return 0; 743} 744 745static ssize_t ib_ucm_send_req(struct ib_ucm_file *file, 746 const char __user *inbuf, 747 int in_len, int out_len) 748{ 749 struct ib_cm_req_param param; 750 struct ib_ucm_context *ctx; 751 struct ib_ucm_req cmd; 752 int result; 753 754 param.private_data = NULL; 755 param.primary_path = NULL; 756 param.alternate_path = NULL; 757 758 if (copy_from_user(&cmd, inbuf, sizeof(cmd))) 759 return -EFAULT; 760 761 result = ib_ucm_alloc_data(¶m.private_data, cmd.data, cmd.len); 762 if (result) 763 goto done; 764 765 result = ib_ucm_path_get(¶m.primary_path, cmd.primary_path); 766 if (result) 767 goto done; 768 769 result = ib_ucm_path_get(¶m.alternate_path, cmd.alternate_path); 770 if (result) 771 goto done; 772 773 param.private_data_len = cmd.len; 774 param.service_id = cmd.sid; 775 param.qp_num = cmd.qpn; 776 param.qp_type = cmd.qp_type; 777 param.starting_psn = cmd.psn; 778 param.peer_to_peer = cmd.peer_to_peer; 779 param.responder_resources = cmd.responder_resources; 780 param.initiator_depth = cmd.initiator_depth; 781 param.remote_cm_response_timeout = cmd.remote_cm_response_timeout; 782 param.flow_control = cmd.flow_control; 783 param.local_cm_response_timeout = cmd.local_cm_response_timeout; 784 param.retry_count = cmd.retry_count; 785 param.rnr_retry_count = cmd.rnr_retry_count; 786 param.max_cm_retries = cmd.max_cm_retries; 787 param.srq = cmd.srq; 788 789 ctx = ib_ucm_ctx_get(file, cmd.id); 790 if (!IS_ERR(ctx)) { 791 result = ib_send_cm_req(ctx->cm_id, ¶m); 792 ib_ucm_ctx_put(ctx); 793 } else 794 result = PTR_ERR(ctx); 795 796done: 797 kfree(param.private_data); 798 kfree(param.primary_path); 799 kfree(param.alternate_path); 800 return result; 801} 802 803static ssize_t ib_ucm_send_rep(struct ib_ucm_file *file, 804 const char __user *inbuf, 805 int in_len, int out_len) 806{ 807 struct ib_cm_rep_param param; 808 struct ib_ucm_context *ctx; 809 struct ib_ucm_rep cmd; 810 int result; 811 812 param.private_data = NULL; 813 814 if (copy_from_user(&cmd, inbuf, sizeof(cmd))) 815 return -EFAULT; 816 817 result = ib_ucm_alloc_data(¶m.private_data, cmd.data, cmd.len); 818 if (result) 819 return result; 820 821 param.qp_num = cmd.qpn; 822 param.starting_psn = cmd.psn; 823 param.private_data_len = cmd.len; 824 param.responder_resources = cmd.responder_resources; 825 param.initiator_depth = cmd.initiator_depth; 826 param.failover_accepted = cmd.failover_accepted; 827 param.flow_control = cmd.flow_control; 828 param.rnr_retry_count = cmd.rnr_retry_count; 829 param.srq = cmd.srq; 830 831 ctx = ib_ucm_ctx_get(file, cmd.id); 832 if (!IS_ERR(ctx)) { 833 ctx->uid = cmd.uid; 834 result = ib_send_cm_rep(ctx->cm_id, ¶m); 835 ib_ucm_ctx_put(ctx); 836 } else 837 result = PTR_ERR(ctx); 838 839 kfree(param.private_data); 840 return result; 841} 842 843static ssize_t ib_ucm_send_private_data(struct ib_ucm_file *file, 844 const char __user *inbuf, int in_len, 845 int (*func)(struct ib_cm_id *cm_id, 846 const void *private_data, 847 u8 private_data_len)) 848{ 849 struct ib_ucm_private_data cmd; 850 struct ib_ucm_context *ctx; 851 const void *private_data = NULL; 852 int result; 853 854 if (copy_from_user(&cmd, inbuf, sizeof(cmd))) 855 return -EFAULT; 856 857 result = ib_ucm_alloc_data(&private_data, cmd.data, cmd.len); 858 if (result) 859 return result; 860 861 ctx = ib_ucm_ctx_get(file, cmd.id); 862 if (!IS_ERR(ctx)) { 863 result = func(ctx->cm_id, private_data, cmd.len); 864 ib_ucm_ctx_put(ctx); 865 } else 866 result = PTR_ERR(ctx); 867 868 kfree(private_data); 869 return result; 870} 871 872static ssize_t ib_ucm_send_rtu(struct ib_ucm_file *file, 873 const char __user *inbuf, 874 int in_len, int out_len) 875{ 876 return ib_ucm_send_private_data(file, inbuf, in_len, ib_send_cm_rtu); 877} 878 879static ssize_t ib_ucm_send_dreq(struct ib_ucm_file *file, 880 const char __user *inbuf, 881 int in_len, int out_len) 882{ 883 return ib_ucm_send_private_data(file, inbuf, in_len, ib_send_cm_dreq); 884} 885 886static ssize_t ib_ucm_send_drep(struct ib_ucm_file *file, 887 const char __user *inbuf, 888 int in_len, int out_len) 889{ 890 return ib_ucm_send_private_data(file, inbuf, in_len, ib_send_cm_drep); 891} 892 893static ssize_t ib_ucm_send_info(struct ib_ucm_file *file, 894 const char __user *inbuf, int in_len, 895 int (*func)(struct ib_cm_id *cm_id, 896 int status, 897 const void *info, 898 u8 info_len, 899 const void *data, 900 u8 data_len)) 901{ 902 struct ib_ucm_context *ctx; 903 struct ib_ucm_info cmd; 904 const void *data = NULL; 905 const void *info = NULL; 906 int result; 907 908 if (copy_from_user(&cmd, inbuf, sizeof(cmd))) 909 return -EFAULT; 910 911 result = ib_ucm_alloc_data(&data, cmd.data, cmd.data_len); 912 if (result) 913 goto done; 914 915 result = ib_ucm_alloc_data(&info, cmd.info, cmd.info_len); 916 if (result) 917 goto done; 918 919 ctx = ib_ucm_ctx_get(file, cmd.id); 920 if (!IS_ERR(ctx)) { 921 result = func(ctx->cm_id, cmd.status, info, cmd.info_len, 922 data, cmd.data_len); 923 ib_ucm_ctx_put(ctx); 924 } else 925 result = PTR_ERR(ctx); 926 927done: 928 kfree(data); 929 kfree(info); 930 return result; 931} 932 933static ssize_t ib_ucm_send_rej(struct ib_ucm_file *file, 934 const char __user *inbuf, 935 int in_len, int out_len) 936{ 937 return ib_ucm_send_info(file, inbuf, in_len, (void *)ib_send_cm_rej); 938} 939 940static ssize_t ib_ucm_send_apr(struct ib_ucm_file *file, 941 const char __user *inbuf, 942 int in_len, int out_len) 943{ 944 return ib_ucm_send_info(file, inbuf, in_len, (void *)ib_send_cm_apr); 945} 946 947static ssize_t ib_ucm_send_mra(struct ib_ucm_file *file, 948 const char __user *inbuf, 949 int in_len, int out_len) 950{ 951 struct ib_ucm_context *ctx; 952 struct ib_ucm_mra cmd; 953 const void *data = NULL; 954 int result; 955 956 if (copy_from_user(&cmd, inbuf, sizeof(cmd))) 957 return -EFAULT; 958 959 result = ib_ucm_alloc_data(&data, cmd.data, cmd.len); 960 if (result) 961 return result; 962 963 ctx = ib_ucm_ctx_get(file, cmd.id); 964 if (!IS_ERR(ctx)) { 965 result = ib_send_cm_mra(ctx->cm_id, cmd.timeout, data, cmd.len); 966 ib_ucm_ctx_put(ctx); 967 } else 968 result = PTR_ERR(ctx); 969 970 kfree(data); 971 return result; 972} 973 974static ssize_t ib_ucm_send_lap(struct ib_ucm_file *file, 975 const char __user *inbuf, 976 int in_len, int out_len) 977{ 978 struct ib_ucm_context *ctx; 979 struct ib_sa_path_rec *path = NULL; 980 struct ib_ucm_lap cmd; 981 const void *data = NULL; 982 int result; 983 984 if (copy_from_user(&cmd, inbuf, sizeof(cmd))) 985 return -EFAULT; 986 987 result = ib_ucm_alloc_data(&data, cmd.data, cmd.len); 988 if (result) 989 goto done; 990 991 result = ib_ucm_path_get(&path, cmd.path); 992 if (result) 993 goto done; 994 995 ctx = ib_ucm_ctx_get(file, cmd.id); 996 if (!IS_ERR(ctx)) { 997 result = ib_send_cm_lap(ctx->cm_id, path, data, cmd.len); 998 ib_ucm_ctx_put(ctx); 999 } else 1000 result = PTR_ERR(ctx); 1001 1002done: 1003 kfree(data); 1004 kfree(path); 1005 return result; 1006} 1007 1008static ssize_t ib_ucm_send_sidr_req(struct ib_ucm_file *file, 1009 const char __user *inbuf, 1010 int in_len, int out_len) 1011{ 1012 struct ib_cm_sidr_req_param param; 1013 struct ib_ucm_context *ctx; 1014 struct ib_ucm_sidr_req cmd; 1015 int result; 1016 1017 param.private_data = NULL; 1018 param.path = NULL; 1019 1020 if (copy_from_user(&cmd, inbuf, sizeof(cmd))) 1021 return -EFAULT; 1022 1023 result = ib_ucm_alloc_data(¶m.private_data, cmd.data, cmd.len); 1024 if (result) 1025 goto done; 1026 1027 result = ib_ucm_path_get(¶m.path, cmd.path); 1028 if (result) 1029 goto done; 1030 1031 param.private_data_len = cmd.len; 1032 param.service_id = cmd.sid; 1033 param.timeout_ms = cmd.timeout; 1034 param.max_cm_retries = cmd.max_cm_retries; 1035 1036 ctx = ib_ucm_ctx_get(file, cmd.id); 1037 if (!IS_ERR(ctx)) { 1038 result = ib_send_cm_sidr_req(ctx->cm_id, ¶m); 1039 ib_ucm_ctx_put(ctx); 1040 } else 1041 result = PTR_ERR(ctx); 1042 1043done: 1044 kfree(param.private_data); 1045 kfree(param.path); 1046 return result; 1047} 1048 1049static ssize_t ib_ucm_send_sidr_rep(struct ib_ucm_file *file, 1050 const char __user *inbuf, 1051 int in_len, int out_len) 1052{ 1053 struct ib_cm_sidr_rep_param param; 1054 struct ib_ucm_sidr_rep cmd; 1055 struct ib_ucm_context *ctx; 1056 int result; 1057 1058 param.info = NULL; 1059 1060 if (copy_from_user(&cmd, inbuf, sizeof(cmd))) 1061 return -EFAULT; 1062 1063 result = ib_ucm_alloc_data(¶m.private_data, 1064 cmd.data, cmd.data_len); 1065 if (result) 1066 goto done; 1067 1068 result = ib_ucm_alloc_data(¶m.info, cmd.info, cmd.info_len); 1069 if (result) 1070 goto done; 1071 1072 param.qp_num = cmd.qpn; 1073 param.qkey = cmd.qkey; 1074 param.status = cmd.status; 1075 param.info_length = cmd.info_len; 1076 param.private_data_len = cmd.data_len; 1077 1078 ctx = ib_ucm_ctx_get(file, cmd.id); 1079 if (!IS_ERR(ctx)) { 1080 result = ib_send_cm_sidr_rep(ctx->cm_id, ¶m); 1081 ib_ucm_ctx_put(ctx); 1082 } else 1083 result = PTR_ERR(ctx); 1084 1085done: 1086 kfree(param.private_data); 1087 kfree(param.info); 1088 return result; 1089} 1090 1091static ssize_t (*ucm_cmd_table[])(struct ib_ucm_file *file, 1092 const char __user *inbuf, 1093 int in_len, int out_len) = { 1094 [IB_USER_CM_CMD_CREATE_ID] = ib_ucm_create_id, 1095 [IB_USER_CM_CMD_DESTROY_ID] = ib_ucm_destroy_id, 1096 [IB_USER_CM_CMD_ATTR_ID] = ib_ucm_attr_id, 1097 [IB_USER_CM_CMD_LISTEN] = ib_ucm_listen, 1098 [IB_USER_CM_CMD_NOTIFY] = ib_ucm_notify, 1099 [IB_USER_CM_CMD_SEND_REQ] = ib_ucm_send_req, 1100 [IB_USER_CM_CMD_SEND_REP] = ib_ucm_send_rep, 1101 [IB_USER_CM_CMD_SEND_RTU] = ib_ucm_send_rtu, 1102 [IB_USER_CM_CMD_SEND_DREQ] = ib_ucm_send_dreq, 1103 [IB_USER_CM_CMD_SEND_DREP] = ib_ucm_send_drep, 1104 [IB_USER_CM_CMD_SEND_REJ] = ib_ucm_send_rej, 1105 [IB_USER_CM_CMD_SEND_MRA] = ib_ucm_send_mra, 1106 [IB_USER_CM_CMD_SEND_LAP] = ib_ucm_send_lap, 1107 [IB_USER_CM_CMD_SEND_APR] = ib_ucm_send_apr, 1108 [IB_USER_CM_CMD_SEND_SIDR_REQ] = ib_ucm_send_sidr_req, 1109 [IB_USER_CM_CMD_SEND_SIDR_REP] = ib_ucm_send_sidr_rep, 1110 [IB_USER_CM_CMD_EVENT] = ib_ucm_event, 1111 [IB_USER_CM_CMD_INIT_QP_ATTR] = ib_ucm_init_qp_attr, 1112}; 1113 1114static ssize_t ib_ucm_write(struct file *filp, const char __user *buf, 1115 size_t len, loff_t *pos) 1116{ 1117 struct ib_ucm_file *file = filp->private_data; 1118 struct ib_ucm_cmd_hdr hdr; 1119 ssize_t result; 1120 1121 if (len < sizeof(hdr)) 1122 return -EINVAL; 1123 1124 if (copy_from_user(&hdr, buf, sizeof(hdr))) 1125 return -EFAULT; 1126 1127 if (hdr.cmd >= ARRAY_SIZE(ucm_cmd_table)) 1128 return -EINVAL; 1129 1130 if (hdr.in + sizeof(hdr) > len) 1131 return -EINVAL; 1132 1133 result = ucm_cmd_table[hdr.cmd](file, buf + sizeof(hdr), 1134 hdr.in, hdr.out); 1135 if (!result) 1136 result = len; 1137 1138 return result; 1139} 1140 1141static unsigned int ib_ucm_poll(struct file *filp, 1142 struct poll_table_struct *wait) 1143{ 1144 struct ib_ucm_file *file = filp->private_data; 1145 unsigned int mask = 0; 1146 1147 poll_wait(filp, &file->poll_wait, wait); 1148 1149 if (!list_empty(&file->events)) 1150 mask = POLLIN | POLLRDNORM; 1151 1152 return mask; 1153} 1154 1155/* 1156 * ib_ucm_open() does not need the BKL: 1157 * 1158 * - no global state is referred to; 1159 * - there is no ioctl method to race against; 1160 * - no further module initialization is required for open to work 1161 * after the device is registered. 1162 */ 1163static int ib_ucm_open(struct inode *inode, struct file *filp) 1164{ 1165 struct ib_ucm_file *file; 1166 1167 file = kmalloc(sizeof(*file), GFP_KERNEL); 1168 if (!file) 1169 return -ENOMEM; 1170 1171 INIT_LIST_HEAD(&file->events); 1172 INIT_LIST_HEAD(&file->ctxs); 1173 init_waitqueue_head(&file->poll_wait); 1174 1175 mutex_init(&file->file_mutex); 1176 1177 filp->private_data = file; 1178 file->filp = filp; 1179 file->device = container_of(inode->i_cdev->si_drv1, struct ib_ucm_device, cdev); 1180 1181 return nonseekable_open(inode, filp); 1182} 1183 1184static int ib_ucm_close(struct inode *inode, struct file *filp) 1185{ 1186 struct ib_ucm_file *file = filp->private_data; 1187 struct ib_ucm_context *ctx; 1188 1189 mutex_lock(&file->file_mutex); 1190 while (!list_empty(&file->ctxs)) { 1191 ctx = list_entry(file->ctxs.next, 1192 struct ib_ucm_context, file_list); 1193 mutex_unlock(&file->file_mutex); 1194 1195 mutex_lock(&ctx_id_mutex); 1196 idr_remove(&ctx_id_table, ctx->id); 1197 mutex_unlock(&ctx_id_mutex); 1198 1199 ib_destroy_cm_id(ctx->cm_id); 1200 ib_ucm_cleanup_events(ctx); 1201 kfree(ctx); 1202 1203 mutex_lock(&file->file_mutex); 1204 } 1205 mutex_unlock(&file->file_mutex); 1206 kfree(file); 1207 return 0; 1208} 1209 1210static void ib_ucm_release_dev(struct device *dev) 1211{ 1212 struct ib_ucm_device *ucm_dev; 1213 1214 ucm_dev = container_of(dev, struct ib_ucm_device, dev); 1215 cdev_del(&ucm_dev->cdev); 1216 if (ucm_dev->devnum < IB_UCM_MAX_DEVICES) 1217 clear_bit(ucm_dev->devnum, dev_map); 1218 else 1219 clear_bit(ucm_dev->devnum - IB_UCM_MAX_DEVICES, dev_map); 1220 kfree(ucm_dev); 1221} 1222 1223static const struct file_operations ucm_fops = { 1224 .owner = THIS_MODULE, 1225 .open = ib_ucm_open, 1226 .release = ib_ucm_close, 1227 .write = ib_ucm_write, 1228 .poll = ib_ucm_poll, 1229 .llseek = no_llseek, 1230}; 1231 1232static ssize_t show_ibdev(struct device *dev, struct device_attribute *attr, 1233 char *buf) 1234{ 1235 struct ib_ucm_device *ucm_dev; 1236 1237 ucm_dev = container_of(dev, struct ib_ucm_device, dev); 1238 return sprintf(buf, "%s\n", ucm_dev->ib_dev->name); 1239} 1240static DEVICE_ATTR(ibdev, S_IRUGO, show_ibdev, NULL); 1241 1242static dev_t overflow_maj; 1243static DECLARE_BITMAP(overflow_map, IB_UCM_MAX_DEVICES); 1244static int find_overflow_devnum(void) 1245{ 1246 int ret; 1247 1248 if (!overflow_maj) { 1249 ret = alloc_chrdev_region(&overflow_maj, 0, IB_UCM_MAX_DEVICES, 1250 "infiniband_cm"); 1251 if (ret) { 1252 printk(KERN_ERR "ucm: couldn't register dynamic device number\n"); 1253 return ret; 1254 } 1255 } 1256 1257 ret = find_first_zero_bit(overflow_map, IB_UCM_MAX_DEVICES); 1258 if (ret >= IB_UCM_MAX_DEVICES) 1259 return -1; 1260 1261 return ret; 1262} 1263 1264static void ib_ucm_add_one(struct ib_device *device) 1265{ 1266 int devnum; 1267 dev_t base; 1268 struct ib_ucm_device *ucm_dev; 1269 1270 if (!device->alloc_ucontext || 1271 rdma_node_get_transport(device->node_type) != RDMA_TRANSPORT_IB) 1272 return; 1273 1274 ucm_dev = kzalloc(sizeof *ucm_dev, GFP_KERNEL); 1275 if (!ucm_dev) 1276 return; 1277 1278 ucm_dev->ib_dev = device; 1279 1280 devnum = find_first_zero_bit(dev_map, IB_UCM_MAX_DEVICES); 1281 if (devnum >= IB_UCM_MAX_DEVICES) { 1282 devnum = find_overflow_devnum(); 1283 if (devnum < 0) 1284 goto err; 1285 1286 ucm_dev->devnum = devnum + IB_UCM_MAX_DEVICES; 1287 base = devnum + overflow_maj; 1288 set_bit(devnum, overflow_map); 1289 } else { 1290 ucm_dev->devnum = devnum; 1291 base = devnum + IB_UCM_BASE_DEV; 1292 set_bit(devnum, dev_map); 1293 } 1294 1295 cdev_init(&ucm_dev->cdev, &ucm_fops); 1296 ucm_dev->cdev.owner = THIS_MODULE; 1297 kobject_set_name(&ucm_dev->cdev.kobj, "ucm%d", ucm_dev->devnum); 1298 if (cdev_add(&ucm_dev->cdev, base, 1)) 1299 goto err; 1300 1301 ucm_dev->dev.class = &cm_class; 1302 ucm_dev->dev.parent = device->dma_device; 1303 ucm_dev->dev.devt = ucm_dev->cdev.dev; 1304 ucm_dev->dev.release = ib_ucm_release_dev; 1305 dev_set_name(&ucm_dev->dev, "ucm%d", ucm_dev->devnum); 1306 if (device_register(&ucm_dev->dev)) 1307 goto err_cdev; 1308 1309 if (device_create_file(&ucm_dev->dev, &dev_attr_ibdev)) 1310 goto err_dev; 1311 1312 ib_set_client_data(device, &ucm_client, ucm_dev); 1313 return; 1314 1315err_dev: 1316 device_unregister(&ucm_dev->dev); 1317err_cdev: 1318 cdev_del(&ucm_dev->cdev); 1319 if (ucm_dev->devnum < IB_UCM_MAX_DEVICES) 1320 clear_bit(devnum, dev_map); 1321 else 1322 clear_bit(devnum, overflow_map); 1323err: 1324 kfree(ucm_dev); 1325 return; 1326} 1327 1328static void ib_ucm_remove_one(struct ib_device *device) 1329{ 1330 struct ib_ucm_device *ucm_dev = ib_get_client_data(device, &ucm_client); 1331 1332 if (!ucm_dev) 1333 return; 1334 1335 device_unregister(&ucm_dev->dev); 1336} 1337 1338static ssize_t show_abi_version(struct class *class, struct class_attribute *attr, char *buf) 1339{ 1340 return sprintf(buf, "%d\n", IB_USER_CM_ABI_VERSION); 1341} 1342 1343static CLASS_ATTR(abi_version, S_IRUGO, show_abi_version, NULL); 1344 1345static int __init ib_ucm_init(void) 1346{ 1347 int ret; 1348 1349 ret = register_chrdev_region(IB_UCM_BASE_DEV, IB_UCM_MAX_DEVICES, 1350 "infiniband_cm"); 1351 if (ret) { 1352 printk(KERN_ERR "ucm: couldn't register device number\n"); 1353 goto error1; 1354 } 1355 1356 ret = class_create_file(&cm_class, &class_attr_abi_version); 1357 if (ret) { 1358 printk(KERN_ERR "ucm: couldn't create abi_version attribute\n"); 1359 goto error2; 1360 } 1361 1362 ret = ib_register_client(&ucm_client); 1363 if (ret) { 1364 printk(KERN_ERR "ucm: couldn't register client\n"); 1365 goto error3; 1366 } 1367 return 0; 1368 1369error3: 1370 class_remove_file(&cm_class, &class_attr_abi_version); 1371error2: 1372 unregister_chrdev_region(IB_UCM_BASE_DEV, IB_UCM_MAX_DEVICES); 1373error1: 1374 return ret; 1375} 1376 1377static void __exit ib_ucm_cleanup(void) 1378{ 1379 ib_unregister_client(&ucm_client); 1380 class_remove_file(&cm_class, &class_attr_abi_version); 1381 unregister_chrdev_region(IB_UCM_BASE_DEV, IB_UCM_MAX_DEVICES); 1382 if (overflow_maj) 1383 unregister_chrdev_region(overflow_maj, IB_UCM_MAX_DEVICES); 1384 idr_destroy(&ctx_id_table); 1385} 1386 1387module_init_order(ib_ucm_init, SI_ORDER_THIRD); 1388module_exit(ib_ucm_cleanup); 1389