ucm.c revision 256179
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/init.h> 36#include <linux/fs.h> 37#include <linux/module.h> 38#include <linux/device.h> 39#include <linux/err.h> 40#include <linux/poll.h> 41#include <linux/file.h> 42#include <linux/mount.h> 43#include <linux/cdev.h> 44#include <linux/idr.h> 45#include <linux/mutex.h> 46 47#include <asm/uaccess.h> 48 49#include <rdma/ib_cm.h> 50#include <rdma/ib_user_cm.h> 51#include <rdma/ib_marshall.h> 52 53MODULE_AUTHOR("Libor Michalek"); 54MODULE_DESCRIPTION("InfiniBand userspace Connection Manager access"); 55MODULE_LICENSE("Dual BSD/GPL"); 56 57struct ib_ucm_device { 58 int devnum; 59 struct cdev cdev; 60 struct device dev; 61 struct ib_device *ib_dev; 62}; 63 64struct ib_ucm_file { 65 struct mutex file_mutex; 66 struct file *filp; 67 struct ib_ucm_device *device; 68 69 struct list_head ctxs; 70 struct list_head events; 71 wait_queue_head_t poll_wait; 72}; 73 74struct ib_ucm_context { 75 int id; 76 struct completion comp; 77 atomic_t ref; 78 int events_reported; 79 80 struct ib_ucm_file *file; 81 struct ib_cm_id *cm_id; 82 __u64 uid; 83 84 struct list_head events; /* list of pending events. */ 85 struct list_head file_list; /* member in file ctx list */ 86}; 87 88struct ib_ucm_event { 89 struct ib_ucm_context *ctx; 90 struct list_head file_list; /* member in file event list */ 91 struct list_head ctx_list; /* member in ctx event list */ 92 93 struct ib_cm_id *cm_id; 94 struct ib_ucm_event_resp resp; 95 void *data; 96 void *info; 97 int data_len; 98 int info_len; 99}; 100 101enum { 102 IB_UCM_MAJOR = 231, 103 IB_UCM_BASE_MINOR = 224, 104 IB_UCM_MAX_DEVICES = 32 105}; 106 107#define IB_UCM_BASE_DEV MKDEV(IB_UCM_MAJOR, IB_UCM_BASE_MINOR) 108 109static void ib_ucm_add_one(struct ib_device *device); 110static void ib_ucm_remove_one(struct ib_device *device); 111 112static struct ib_client ucm_client = { 113 .name = "ucm", 114 .add = ib_ucm_add_one, 115 .remove = ib_ucm_remove_one 116}; 117 118static DEFINE_MUTEX(ctx_id_mutex); 119static DEFINE_IDR(ctx_id_table); 120static DECLARE_BITMAP(dev_map, IB_UCM_MAX_DEVICES); 121 122static struct ib_ucm_context *ib_ucm_ctx_get(struct ib_ucm_file *file, int id) 123{ 124 struct ib_ucm_context *ctx; 125 126 mutex_lock(&ctx_id_mutex); 127 ctx = idr_find(&ctx_id_table, id); 128 if (!ctx) 129 ctx = ERR_PTR(-ENOENT); 130 else if (ctx->file != file) 131 ctx = ERR_PTR(-EINVAL); 132 else 133 atomic_inc(&ctx->ref); 134 mutex_unlock(&ctx_id_mutex); 135 136 return ctx; 137} 138 139static void ib_ucm_ctx_put(struct ib_ucm_context *ctx) 140{ 141 if (atomic_dec_and_test(&ctx->ref)) 142 complete(&ctx->comp); 143} 144 145static inline int ib_ucm_new_cm_id(int event) 146{ 147 return event == IB_CM_REQ_RECEIVED || event == IB_CM_SIDR_REQ_RECEIVED; 148} 149 150static void ib_ucm_cleanup_events(struct ib_ucm_context *ctx) 151{ 152 struct ib_ucm_event *uevent; 153 154 mutex_lock(&ctx->file->file_mutex); 155 list_del(&ctx->file_list); 156 while (!list_empty(&ctx->events)) { 157 158 uevent = list_entry(ctx->events.next, 159 struct ib_ucm_event, ctx_list); 160 list_del(&uevent->file_list); 161 list_del(&uevent->ctx_list); 162 mutex_unlock(&ctx->file->file_mutex); 163 164 /* clear incoming connections. */ 165 if (ib_ucm_new_cm_id(uevent->resp.event)) 166 ib_destroy_cm_id(uevent->cm_id); 167 168 kfree(uevent); 169 mutex_lock(&ctx->file->file_mutex); 170 } 171 mutex_unlock(&ctx->file->file_mutex); 172} 173 174static struct ib_ucm_context *ib_ucm_ctx_alloc(struct ib_ucm_file *file) 175{ 176 struct ib_ucm_context *ctx; 177 int result; 178 179 ctx = kzalloc(sizeof *ctx, GFP_KERNEL); 180 if (!ctx) 181 return NULL; 182 183 atomic_set(&ctx->ref, 1); 184 init_completion(&ctx->comp); 185 ctx->file = file; 186 INIT_LIST_HEAD(&ctx->events); 187 188 do { 189 result = idr_pre_get(&ctx_id_table, GFP_KERNEL); 190 if (!result) 191 goto error; 192 193 mutex_lock(&ctx_id_mutex); 194 result = idr_get_new(&ctx_id_table, ctx, &ctx->id); 195 mutex_unlock(&ctx_id_mutex); 196 } while (result == -EAGAIN); 197 198 if (result) 199 goto error; 200 201 list_add_tail(&ctx->file_list, &file->ctxs); 202 return ctx; 203 204error: 205 kfree(ctx); 206 return NULL; 207} 208 209static void ib_ucm_event_req_get(struct ib_ucm_req_event_resp *ureq, 210 struct ib_cm_req_event_param *kreq) 211{ 212 ureq->remote_ca_guid = kreq->remote_ca_guid; 213 ureq->remote_qkey = kreq->remote_qkey; 214 ureq->remote_qpn = kreq->remote_qpn; 215 ureq->qp_type = kreq->qp_type; 216 ureq->starting_psn = kreq->starting_psn; 217 ureq->responder_resources = kreq->responder_resources; 218 ureq->initiator_depth = kreq->initiator_depth; 219 ureq->local_cm_response_timeout = kreq->local_cm_response_timeout; 220 ureq->flow_control = kreq->flow_control; 221 ureq->remote_cm_response_timeout = kreq->remote_cm_response_timeout; 222 ureq->retry_count = kreq->retry_count; 223 ureq->rnr_retry_count = kreq->rnr_retry_count; 224 ureq->srq = kreq->srq; 225 ureq->port = kreq->port; 226 227 ib_copy_path_rec_to_user(&ureq->primary_path, kreq->primary_path); 228 if (kreq->alternate_path) 229 ib_copy_path_rec_to_user(&ureq->alternate_path, 230 kreq->alternate_path); 231} 232 233static void ib_ucm_event_rep_get(struct ib_ucm_rep_event_resp *urep, 234 struct ib_cm_rep_event_param *krep) 235{ 236 urep->remote_ca_guid = krep->remote_ca_guid; 237 urep->remote_qkey = krep->remote_qkey; 238 urep->remote_qpn = krep->remote_qpn; 239 urep->starting_psn = krep->starting_psn; 240 urep->responder_resources = krep->responder_resources; 241 urep->initiator_depth = krep->initiator_depth; 242 urep->target_ack_delay = krep->target_ack_delay; 243 urep->failover_accepted = krep->failover_accepted; 244 urep->flow_control = krep->flow_control; 245 urep->rnr_retry_count = krep->rnr_retry_count; 246 urep->srq = krep->srq; 247} 248 249static void ib_ucm_event_sidr_rep_get(struct ib_ucm_sidr_rep_event_resp *urep, 250 struct ib_cm_sidr_rep_event_param *krep) 251{ 252 urep->status = krep->status; 253 urep->qkey = krep->qkey; 254 urep->qpn = krep->qpn; 255}; 256 257static int ib_ucm_event_process(struct ib_cm_event *evt, 258 struct ib_ucm_event *uvt) 259{ 260 void *info = NULL; 261 262 switch (evt->event) { 263 case IB_CM_REQ_RECEIVED: 264 ib_ucm_event_req_get(&uvt->resp.u.req_resp, 265 &evt->param.req_rcvd); 266 uvt->data_len = IB_CM_REQ_PRIVATE_DATA_SIZE; 267 uvt->resp.present = IB_UCM_PRES_PRIMARY; 268 uvt->resp.present |= (evt->param.req_rcvd.alternate_path ? 269 IB_UCM_PRES_ALTERNATE : 0); 270 break; 271 case IB_CM_REP_RECEIVED: 272 ib_ucm_event_rep_get(&uvt->resp.u.rep_resp, 273 &evt->param.rep_rcvd); 274 uvt->data_len = IB_CM_REP_PRIVATE_DATA_SIZE; 275 break; 276 case IB_CM_RTU_RECEIVED: 277 uvt->data_len = IB_CM_RTU_PRIVATE_DATA_SIZE; 278 uvt->resp.u.send_status = evt->param.send_status; 279 break; 280 case IB_CM_DREQ_RECEIVED: 281 uvt->data_len = IB_CM_DREQ_PRIVATE_DATA_SIZE; 282 uvt->resp.u.send_status = evt->param.send_status; 283 break; 284 case IB_CM_DREP_RECEIVED: 285 uvt->data_len = IB_CM_DREP_PRIVATE_DATA_SIZE; 286 uvt->resp.u.send_status = evt->param.send_status; 287 break; 288 case IB_CM_MRA_RECEIVED: 289 uvt->resp.u.mra_resp.timeout = 290 evt->param.mra_rcvd.service_timeout; 291 uvt->data_len = IB_CM_MRA_PRIVATE_DATA_SIZE; 292 break; 293 case IB_CM_REJ_RECEIVED: 294 uvt->resp.u.rej_resp.reason = evt->param.rej_rcvd.reason; 295 uvt->data_len = IB_CM_REJ_PRIVATE_DATA_SIZE; 296 uvt->info_len = evt->param.rej_rcvd.ari_length; 297 info = evt->param.rej_rcvd.ari; 298 break; 299 case IB_CM_LAP_RECEIVED: 300 ib_copy_path_rec_to_user(&uvt->resp.u.lap_resp.path, 301 evt->param.lap_rcvd.alternate_path); 302 uvt->data_len = IB_CM_LAP_PRIVATE_DATA_SIZE; 303 uvt->resp.present = IB_UCM_PRES_ALTERNATE; 304 break; 305 case IB_CM_APR_RECEIVED: 306 uvt->resp.u.apr_resp.status = evt->param.apr_rcvd.ap_status; 307 uvt->data_len = IB_CM_APR_PRIVATE_DATA_SIZE; 308 uvt->info_len = evt->param.apr_rcvd.info_len; 309 info = evt->param.apr_rcvd.apr_info; 310 break; 311 case IB_CM_SIDR_REQ_RECEIVED: 312 uvt->resp.u.sidr_req_resp.pkey = 313 evt->param.sidr_req_rcvd.pkey; 314 uvt->resp.u.sidr_req_resp.port = 315 evt->param.sidr_req_rcvd.port; 316 uvt->data_len = IB_CM_SIDR_REQ_PRIVATE_DATA_SIZE; 317 break; 318 case IB_CM_SIDR_REP_RECEIVED: 319 ib_ucm_event_sidr_rep_get(&uvt->resp.u.sidr_rep_resp, 320 &evt->param.sidr_rep_rcvd); 321 uvt->data_len = IB_CM_SIDR_REP_PRIVATE_DATA_SIZE; 322 uvt->info_len = evt->param.sidr_rep_rcvd.info_len; 323 info = evt->param.sidr_rep_rcvd.info; 324 break; 325 default: 326 uvt->resp.u.send_status = evt->param.send_status; 327 break; 328 } 329 330 if (uvt->data_len) { 331 uvt->data = kmemdup(evt->private_data, uvt->data_len, GFP_KERNEL); 332 if (!uvt->data) 333 goto err1; 334 335 uvt->resp.present |= IB_UCM_PRES_DATA; 336 } 337 338 if (uvt->info_len) { 339 uvt->info = kmemdup(info, uvt->info_len, GFP_KERNEL); 340 if (!uvt->info) 341 goto err2; 342 343 uvt->resp.present |= IB_UCM_PRES_INFO; 344 } 345 return 0; 346 347err2: 348 kfree(uvt->data); 349err1: 350 return -ENOMEM; 351} 352 353static int ib_ucm_event_handler(struct ib_cm_id *cm_id, 354 struct ib_cm_event *event) 355{ 356 struct ib_ucm_event *uevent; 357 struct ib_ucm_context *ctx; 358 int result = 0; 359 360 ctx = cm_id->context; 361 362 uevent = kzalloc(sizeof *uevent, GFP_KERNEL); 363 if (!uevent) 364 goto err1; 365 366 uevent->ctx = ctx; 367 uevent->cm_id = cm_id; 368 uevent->resp.uid = ctx->uid; 369 uevent->resp.id = ctx->id; 370 uevent->resp.event = event->event; 371 372 result = ib_ucm_event_process(event, uevent); 373 if (result) 374 goto err2; 375 376 mutex_lock(&ctx->file->file_mutex); 377 list_add_tail(&uevent->file_list, &ctx->file->events); 378 list_add_tail(&uevent->ctx_list, &ctx->events); 379 wake_up_interruptible(&ctx->file->poll_wait); 380 if (ctx->file->filp) 381 selwakeup(&ctx->file->filp->f_selinfo); 382 mutex_unlock(&ctx->file->file_mutex); 383 return 0; 384 385err2: 386 kfree(uevent); 387err1: 388 /* Destroy new cm_id's */ 389 return ib_ucm_new_cm_id(event->event); 390} 391 392static ssize_t ib_ucm_event(struct ib_ucm_file *file, 393 const char __user *inbuf, 394 int in_len, int out_len) 395{ 396 struct ib_ucm_context *ctx; 397 struct ib_ucm_event_get cmd; 398 struct ib_ucm_event *uevent; 399 int result = 0; 400 DEFINE_WAIT(wait); 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 < 0 || 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 = kzalloc(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 0; 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 clear_bit(ucm_dev->devnum, dev_map); 1217 kfree(ucm_dev); 1218} 1219 1220static const struct file_operations ucm_fops = { 1221 .owner = THIS_MODULE, 1222 .open = ib_ucm_open, 1223 .release = ib_ucm_close, 1224 .write = ib_ucm_write, 1225 .poll = ib_ucm_poll, 1226}; 1227 1228static ssize_t show_ibdev(struct device *dev, struct device_attribute *attr, 1229 char *buf) 1230{ 1231 struct ib_ucm_device *ucm_dev; 1232 1233 ucm_dev = container_of(dev, struct ib_ucm_device, dev); 1234 return sprintf(buf, "%s\n", ucm_dev->ib_dev->name); 1235} 1236static DEVICE_ATTR(ibdev, S_IRUGO, show_ibdev, NULL); 1237 1238static void ib_ucm_add_one(struct ib_device *device) 1239{ 1240 struct ib_ucm_device *ucm_dev; 1241 1242 if (!device->alloc_ucontext || 1243 rdma_node_get_transport(device->node_type) != RDMA_TRANSPORT_IB) 1244 return; 1245 1246 ucm_dev = kzalloc(sizeof *ucm_dev, GFP_KERNEL); 1247 if (!ucm_dev) 1248 return; 1249 1250 ucm_dev->ib_dev = device; 1251 1252 ucm_dev->devnum = find_first_zero_bit(dev_map, IB_UCM_MAX_DEVICES); 1253 if (ucm_dev->devnum >= IB_UCM_MAX_DEVICES) 1254 goto err; 1255 1256 set_bit(ucm_dev->devnum, dev_map); 1257 1258 cdev_init(&ucm_dev->cdev, &ucm_fops); 1259 ucm_dev->cdev.owner = THIS_MODULE; 1260 kobject_set_name(&ucm_dev->cdev.kobj, "ucm%d", ucm_dev->devnum); 1261 if (cdev_add(&ucm_dev->cdev, IB_UCM_BASE_DEV + ucm_dev->devnum, 1)) 1262 goto err; 1263 1264 ucm_dev->dev.class = &cm_class; 1265 ucm_dev->dev.parent = device->dma_device; 1266 ucm_dev->dev.devt = ucm_dev->cdev.dev; 1267 ucm_dev->dev.release = ib_ucm_release_dev; 1268 dev_set_name(&ucm_dev->dev, "ucm%d", ucm_dev->devnum); 1269 if (device_register(&ucm_dev->dev)) 1270 goto err_cdev; 1271 1272 if (device_create_file(&ucm_dev->dev, &dev_attr_ibdev)) 1273 goto err_dev; 1274 1275 ib_set_client_data(device, &ucm_client, ucm_dev); 1276 return; 1277 1278err_dev: 1279 device_unregister(&ucm_dev->dev); 1280err_cdev: 1281 cdev_del(&ucm_dev->cdev); 1282 clear_bit(ucm_dev->devnum, dev_map); 1283err: 1284 kfree(ucm_dev); 1285 return; 1286} 1287 1288static void ib_ucm_remove_one(struct ib_device *device) 1289{ 1290 struct ib_ucm_device *ucm_dev = ib_get_client_data(device, &ucm_client); 1291 1292 if (!ucm_dev) 1293 return; 1294 1295 device_unregister(&ucm_dev->dev); 1296} 1297 1298static ssize_t show_abi_version(struct class *class, char *buf) 1299{ 1300 return sprintf(buf, "%d\n", IB_USER_CM_ABI_VERSION); 1301} 1302static CLASS_ATTR(abi_version, S_IRUGO, show_abi_version, NULL); 1303 1304static int __init ib_ucm_init(void) 1305{ 1306 int ret; 1307 1308 ret = register_chrdev_region(IB_UCM_BASE_DEV, IB_UCM_MAX_DEVICES, 1309 "infiniband_cm"); 1310 if (ret) { 1311 printk(KERN_ERR "ucm: couldn't register device number\n"); 1312 goto error1; 1313 } 1314 1315 ret = class_create_file(&cm_class, &class_attr_abi_version); 1316 if (ret) { 1317 printk(KERN_ERR "ucm: couldn't create abi_version attribute\n"); 1318 goto error2; 1319 } 1320 1321 ret = ib_register_client(&ucm_client); 1322 if (ret) { 1323 printk(KERN_ERR "ucm: couldn't register client\n"); 1324 goto error3; 1325 } 1326 return 0; 1327 1328error3: 1329 class_remove_file(&cm_class, &class_attr_abi_version); 1330error2: 1331 unregister_chrdev_region(IB_UCM_BASE_DEV, IB_UCM_MAX_DEVICES); 1332error1: 1333 return ret; 1334} 1335 1336static void __exit ib_ucm_cleanup(void) 1337{ 1338 ib_unregister_client(&ucm_client); 1339 class_remove_file(&cm_class, &class_attr_abi_version); 1340 unregister_chrdev_region(IB_UCM_BASE_DEV, IB_UCM_MAX_DEVICES); 1341 idr_destroy(&ctx_id_table); 1342} 1343 1344module_init_order(ib_ucm_init, SI_ORDER_THIRD); 1345module_exit(ib_ucm_cleanup); 1346