drivers/infiniband/core/ucma.c

   1 /*
   2  * Copyright (c) 2005-2006 Intel Corporation.  All rights reserved.
   3  *
   4  * This software is available to you under a choice of one of two
   5  * licenses.  You may choose to be licensed under the terms of the GNU
   6  * General Public License (GPL) Version 2, available from the file
   7  * COPYING in the main directory of this source tree, or the
   8  * OpenIB.org BSD license below:
   9  *
  10  *     Redistribution and use in source and binary forms, with or
  11  *     without modification, are permitted provided that the following
  12  *     conditions are met:
  13  *
  14  *      - Redistributions of source code must retain the above
  15  *      copyright notice, this list of conditions and the following
  16  *      disclaimer.
  17  *
  18  *      - Redistributions in binary form must reproduce the above
  19  *      copyright notice, this list of conditions and the following
  20  *      disclaimer in the documentation and/or other materials
  21  *      provided with the distribution.
  22  *
  23  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
  24  * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  25  * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
  26  * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
  27  * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
  28  * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
  29  * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
  30  * SOFTWARE.
  31  */
  32
  33 #include <linux/completion.h>
  34 #include <linux/file.h>
  35 #include <linux/mutex.h>
  36 #include <linux/poll.h>
  37 #include <linux/sched.h>
  38 #include <linux/idr.h>
  39 #include <linux/in.h>
  40 #include <linux/in6.h>
  41 #include <linux/miscdevice.h>
  42 #include <linux/slab.h>
  43 #include <linux/sysctl.h>
  44 #include <linux/module.h>
  45 #include <linux/nsproxy.h>
  46
  47 #include <linux/nospec.h>
  48
  49 #include <rdma/rdma_user_cm.h>
  50 #include <rdma/ib_marshall.h>
  51 #include <rdma/rdma_cm.h>
  52 #include <rdma/rdma_cm_ib.h>
  53 #include <rdma/ib_addr.h>
  54 #include <rdma/ib.h>
  55
  56 MODULE_AUTHOR("Sean Hefty");
  57 MODULE_DESCRIPTION("RDMA Userspace Connection Manager Access");
  58 MODULE_LICENSE("Dual BSD/GPL");
  59
  60 static unsigned int max_backlog = 1024;
  61
  62 static struct ctl_table_header *ucma_ctl_table_hdr;
  63 static struct ctl_table ucma_ctl_table[] = {
  64         {
  65                 .procname       = "max_backlog",
  66                 .data           = &max_backlog,
  67                 .maxlen         = sizeof max_backlog,
  68                 .mode           = 0644,
  69                 .proc_handler   = proc_dointvec,
  70         },
  71         { }
  72 };
  73
  74 struct ucma_file {
  75         struct mutex            mut;
  76         struct file             *filp;
  77         struct list_head        ctx_list;
  78         struct list_head        event_list;
  79         wait_queue_head_t       poll_wait;
  80         struct workqueue_struct *close_wq;
  81 };
  82
  83 struct ucma_context {
  84         int                     id;
  85         struct completion       comp;
  86         atomic_t                ref;
  87         int                     events_reported;
  88         int                     backlog;
  89
  90         struct ucma_file        *file;
  91         struct rdma_cm_id       *cm_id;
  92         struct mutex            mutex;
  93         u64                     uid;
  94
  95         struct list_head        list;
  96         struct list_head        mc_list;
  97         /* mark that device is in process of destroying the internal HW
  98          * resources, protected by the global mut
  99          */
 100         int                     closing;
 101         /* sync between removal event and id destroy, protected by file mut */
 102         int                     destroying;
 103         struct work_struct      close_work;
 104 };
 105
 106 struct ucma_multicast {
 107         struct ucma_context     *ctx;
 108         int                     id;
 109         int                     events_reported;
 110
 111         u64                     uid;
 112         u8                      join_state;
 113         struct list_head        list;
 114         struct sockaddr_storage addr;
 115 };
 116
 117 struct ucma_event {
 118         struct ucma_context     *ctx;
 119         struct ucma_multicast   *mc;
 120         struct list_head        list;
 121         struct rdma_cm_id       *cm_id;
 122         struct rdma_ucm_event_resp resp;
 123         struct work_struct      close_work;
 124 };
 125
 126 static DEFINE_MUTEX(mut);
 127 static DEFINE_IDR(ctx_idr);
 128 static DEFINE_IDR(multicast_idr);
 129
 130 static const struct file_operations ucma_fops;
 131
 132 static inline struct ucma_context *_ucma_find_context(int id,
 133                                                       struct ucma_file *file)
 134 {
 135         struct ucma_context *ctx;
 136
 137         ctx = idr_find(&ctx_idr, id);
 138         if (!ctx)
 139                 ctx = ERR_PTR(-ENOENT);
 140         else if (ctx->file != file || !ctx->cm_id)
 141                 ctx = ERR_PTR(-EINVAL);
 142         return ctx;
 143 }
 144
 145 static struct ucma_context *ucma_get_ctx(struct ucma_file *file, int id)
 146 {
 147         struct ucma_context *ctx;
 148
 149         mutex_lock(&mut);
 150         ctx = _ucma_find_context(id, file);
 151         if (!IS_ERR(ctx)) {
 152                 if (ctx->closing)
 153                         ctx = ERR_PTR(-EIO);
 154                 else
 155                         atomic_inc(&ctx->ref);
 156         }
 157         mutex_unlock(&mut);
 158         return ctx;
 159 }
 160
 161 static void ucma_put_ctx(struct ucma_context *ctx)
 162 {
 163         if (atomic_dec_and_test(&ctx->ref))
 164                 complete(&ctx->comp);
 165 }
 166
 167 /*
 168  * Same as ucm_get_ctx but requires that ->cm_id->device is valid, eg that the
 169  * CM_ID is bound.
 170  */
 171 static struct ucma_context *ucma_get_ctx_dev(struct ucma_file *file, int id)
 172 {
 173         struct ucma_context *ctx = ucma_get_ctx(file, id);
 174
 175         if (IS_ERR(ctx))
 176                 return ctx;
 177         if (!ctx->cm_id->device) {
 178                 ucma_put_ctx(ctx);
 179                 return ERR_PTR(-EINVAL);
 180         }
 181         return ctx;
 182 }
 183
 184 static void ucma_close_event_id(struct work_struct *work)
 185 {
 186         struct ucma_event *uevent_close =  container_of(work, struct ucma_event, close_work);
 187
 188         rdma_destroy_id(uevent_close->cm_id);
 189         kfree(uevent_close);
 190 }
 191
 192 static void ucma_close_id(struct work_struct *work)
 193 {
 194         struct ucma_context *ctx =  container_of(work, struct ucma_context, close_work);
 195
 196         /* once all inflight tasks are finished, we close all underlying
 197          * resources. The context is still alive till its explicit destryoing
 198          * by its creator.
 199          */
 200         ucma_put_ctx(ctx);
 201         wait_for_completion(&ctx->comp);
 202         /* No new events will be generated after destroying the id. */
 203         rdma_destroy_id(ctx->cm_id);
 204 }
 205
 206 static struct ucma_context *ucma_alloc_ctx(struct ucma_file *file)
 207 {
 208         struct ucma_context *ctx;
 209
 210         ctx = kzalloc(sizeof(*ctx), GFP_KERNEL);
 211         if (!ctx)
 212                 return NULL;
 213
 214         INIT_WORK(&ctx->close_work, ucma_close_id);
 215         atomic_set(&ctx->ref, 1);
 216         init_completion(&ctx->comp);
 217         INIT_LIST_HEAD(&ctx->mc_list);
 218         ctx->file = file;
 219         mutex_init(&ctx->mutex);
 220
 221         mutex_lock(&mut);
 222         ctx->id = idr_alloc(&ctx_idr, ctx, 0, 0, GFP_KERNEL);
 223         mutex_unlock(&mut);
 224         if (ctx->id < 0)
 225                 goto error;
 226
 227         list_add_tail(&ctx->list, &file->ctx_list);
 228         return ctx;
 229
 230 error:
 231         kfree(ctx);
 232         return NULL;
 233 }
 234
 235 static struct ucma_multicast* ucma_alloc_multicast(struct ucma_context *ctx)
 236 {
 237         struct ucma_multicast *mc;
 238
 239         mc = kzalloc(sizeof(*mc), GFP_KERNEL);
 240         if (!mc)
 241                 return NULL;
 242
 243         mutex_lock(&mut);
 244         mc->id = idr_alloc(&multicast_idr, NULL, 0, 0, GFP_KERNEL);
 245         mutex_unlock(&mut);
 246         if (mc->id < 0)
 247                 goto error;
 248
 249         mc->ctx = ctx;
 250         list_add_tail(&mc->list, &ctx->mc_list);
 251         return mc;
 252
 253 error:
 254         kfree(mc);
 255         return NULL;
 256 }
 257
 258 static void ucma_copy_conn_event(struct rdma_ucm_conn_param *dst,
 259                                  struct rdma_conn_param *src)
 260 {
 261         if (src->private_data_len)
 262                 memcpy(dst->private_data, src->private_data,
 263                        src->private_data_len);
 264         dst->private_data_len = src->private_data_len;
 265         dst->responder_resources =src->responder_resources;
 266         dst->initiator_depth = src->initiator_depth;
 267         dst->flow_control = src->flow_control;
 268         dst->retry_count = src->retry_count;
 269         dst->rnr_retry_count = src->rnr_retry_count;
 270         dst->srq = src->srq;
 271         dst->qp_num = src->qp_num;
 272 }
 273
 274 static void ucma_copy_ud_event(struct ib_device *device,
 275                                struct rdma_ucm_ud_param *dst,
 276                                struct rdma_ud_param *src)
 277 {
 278         if (src->private_data_len)
 279                 memcpy(dst->private_data, src->private_data,
 280                        src->private_data_len);
 281         dst->private_data_len = src->private_data_len;
 282         ib_copy_ah_attr_to_user(device, &dst->ah_attr, &src->ah_attr);
 283         dst->qp_num = src->qp_num;
 284         dst->qkey = src->qkey;
 285 }
 286
 287 static void ucma_set_event_context(struct ucma_context *ctx,
 288                                    struct rdma_cm_event *event,
 289                                    struct ucma_event *uevent)
 290 {
 291         uevent->ctx = ctx;
 292         switch (event->event) {
 293         case RDMA_CM_EVENT_MULTICAST_JOIN:
 294         case RDMA_CM_EVENT_MULTICAST_ERROR:
 295                 uevent->mc = (struct ucma_multicast *)
 296                              event->param.ud.private_data;
 297                 uevent->resp.uid = uevent->mc->uid;
 298                 uevent->resp.id = uevent->mc->id;
 299                 break;
 300         default:
 301                 uevent->resp.uid = ctx->uid;
 302                 uevent->resp.id = ctx->id;
 303                 break;
 304         }
 305 }
 306
 307 /* Called with file->mut locked for the relevant context. */
 308 static void ucma_removal_event_handler(struct rdma_cm_id *cm_id)
 309 {
 310         struct ucma_context *ctx = cm_id->context;
 311         struct ucma_event *con_req_eve;
 312         int event_found = 0;
 313
 314         if (ctx->destroying)
 315                 return;
 316
 317         /* only if context is pointing to cm_id that it owns it and can be
 318          * queued to be closed, otherwise that cm_id is an inflight one that
 319          * is part of that context event list pending to be detached and
 320          * reattached to its new context as part of ucma_get_event,
 321          * handled separately below.
 322          */
 323         if (ctx->cm_id == cm_id) {
 324                 mutex_lock(&mut);
 325                 ctx->closing = 1;
 326                 mutex_unlock(&mut);
 327                 queue_work(ctx->file->close_wq, &ctx->close_work);
 328                 return;
 329         }
 330
 331         list_for_each_entry(con_req_eve, &ctx->file->event_list, list) {
 332                 if (con_req_eve->cm_id == cm_id &&
 333                     con_req_eve->resp.event == RDMA_CM_EVENT_CONNECT_REQUEST) {
 334                         list_del(&con_req_eve->list);
 335                         INIT_WORK(&con_req_eve->close_work, ucma_close_event_id);
 336                         queue_work(ctx->file->close_wq, &con_req_eve->close_work);
 337                         event_found = 1;
 338                         break;
 339                 }
 340         }
 341         if (!event_found)
 342                 pr_err("ucma_removal_event_handler: warning: connect request event wasn't found\n");
 343 }
 344
 345 static int ucma_event_handler(struct rdma_cm_id *cm_id,
 346                               struct rdma_cm_event *event)
 347 {
 348         struct ucma_event *uevent;
 349         struct ucma_context *ctx = cm_id->context;
 350         int ret = 0;
 351
 352         uevent = kzalloc(sizeof(*uevent), GFP_KERNEL);
 353         if (!uevent)
 354                 return event->event == RDMA_CM_EVENT_CONNECT_REQUEST;
 355
 356         mutex_lock(&ctx->file->mut);
 357         uevent->cm_id = cm_id;
 358         ucma_set_event_context(ctx, event, uevent);
 359         uevent->resp.event = event->event;
 360         uevent->resp.status = event->status;
 361         if (cm_id->qp_type == IB_QPT_UD)
 362                 ucma_copy_ud_event(cm_id->device, &uevent->resp.param.ud,
 363                                    &event->param.ud);
 364         else
 365                 ucma_copy_conn_event(&uevent->resp.param.conn,
 366                                      &event->param.conn);
 367
 368         if (event->event == RDMA_CM_EVENT_CONNECT_REQUEST) {
 369                 if (!ctx->backlog) {
 370                         ret = -ENOMEM;
 371                         kfree(uevent);
 372                         goto out;
 373                 }
 374                 ctx->backlog--;
 375         } else if (!ctx->uid || ctx->cm_id != cm_id) {
 376                 /*
 377                  * We ignore events for new connections until userspace has set
 378                  * their context.  This can only happen if an error occurs on a
 379                  * new connection before the user accepts it.  This is okay,
 380                  * since the accept will just fail later. However, we do need
 381                  * to release the underlying HW resources in case of a device
 382                  * removal event.
 383                  */
 384                 if (event->event == RDMA_CM_EVENT_DEVICE_REMOVAL)
 385                         ucma_removal_event_handler(cm_id);
 386
 387                 kfree(uevent);
 388                 goto out;
 389         }
 390
 391         list_add_tail(&uevent->list, &ctx->file->event_list);
 392         wake_up_interruptible(&ctx->file->poll_wait);
 393         if (event->event == RDMA_CM_EVENT_DEVICE_REMOVAL)
 394                 ucma_removal_event_handler(cm_id);
 395 out:
 396         mutex_unlock(&ctx->file->mut);
 397         return ret;
 398 }
 399
 400 static ssize_t ucma_get_event(struct ucma_file *file, const char __user *inbuf,
 401                               int in_len, int out_len)
 402 {
 403         struct ucma_context *ctx;
 404         struct rdma_ucm_get_event cmd;
 405         struct ucma_event *uevent;
 406         int ret = 0;
 407
 408         /*
 409          * Old 32 bit user space does not send the 4 byte padding in the
 410          * reserved field. We don't care, allow it to keep working.
 411          */
 412         if (out_len < sizeof(uevent->resp) - sizeof(uevent->resp.reserved))
 413                 return -ENOSPC;
 414
 415         if (copy_from_user(&cmd, inbuf, sizeof(cmd)))
 416                 return -EFAULT;
 417
 418         mutex_lock(&file->mut);
 419         while (list_empty(&file->event_list)) {
 420                 mutex_unlock(&file->mut);
 421
 422                 if (file->filp->f_flags & O_NONBLOCK)
 423                         return -EAGAIN;
 424
 425                 if (wait_event_interruptible(file->poll_wait,
 426                                              !list_empty(&file->event_list)))
 427                         return -ERESTARTSYS;
 428
 429                 mutex_lock(&file->mut);
 430         }
 431
 432         uevent = list_entry(file->event_list.next, struct ucma_event, list);
 433
 434         if (uevent->resp.event == RDMA_CM_EVENT_CONNECT_REQUEST) {
 435                 ctx = ucma_alloc_ctx(file);
 436                 if (!ctx) {
 437                         ret = -ENOMEM;
 438                         goto done;
 439                 }
 440                 uevent->ctx->backlog++;
 441                 ctx->cm_id = uevent->cm_id;
 442                 ctx->cm_id->context = ctx;
 443                 uevent->resp.id = ctx->id;
 444         }
 445
 446         if (copy_to_user(u64_to_user_ptr(cmd.response),
 447                          &uevent->resp,
 448                          min_t(size_t, out_len, sizeof(uevent->resp)))) {
 449                 ret = -EFAULT;
 450                 goto done;
 451         }
 452
 453         list_del(&uevent->list);
 454         uevent->ctx->events_reported++;
 455         if (uevent->mc)
 456                 uevent->mc->events_reported++;
 457         kfree(uevent);
 458 done:
 459         mutex_unlock(&file->mut);
 460         return ret;
 461 }
 462
 463 static int ucma_get_qp_type(struct rdma_ucm_create_id *cmd, enum ib_qp_type *qp_type)
 464 {
 465         switch (cmd->ps) {
 466         case RDMA_PS_TCP:
 467                 *qp_type = IB_QPT_RC;
 468                 return 0;
 469         case RDMA_PS_UDP:
 470         case RDMA_PS_IPOIB:
 471                 *qp_type = IB_QPT_UD;
 472                 return 0;
 473         case RDMA_PS_IB:
 474                 *qp_type = cmd->qp_type;
 475                 return 0;
 476         default:
 477                 return -EINVAL;
 478         }
 479 }
 480
 481 static ssize_t ucma_create_id(struct ucma_file *file, const char __user *inbuf,
 482                               int in_len, int out_len)
 483 {
 484         struct rdma_ucm_create_id cmd;
 485         struct rdma_ucm_create_id_resp resp;
 486         struct ucma_context *ctx;
 487         struct rdma_cm_id *cm_id;
 488         enum ib_qp_type qp_type;
 489         int ret;
 490
 491         if (out_len < sizeof(resp))
 492                 return -ENOSPC;
 493
 494         if (copy_from_user(&cmd, inbuf, sizeof(cmd)))
 495                 return -EFAULT;
 496
 497         ret = ucma_get_qp_type(&cmd, &qp_type);
 498         if (ret)
 499                 return ret;
 500
 501         mutex_lock(&file->mut);
 502         ctx = ucma_alloc_ctx(file);
 503         mutex_unlock(&file->mut);
 504         if (!ctx)
 505                 return -ENOMEM;
 506
 507         ctx->uid = cmd.uid;
 508         cm_id = __rdma_create_id(current->nsproxy->net_ns,
 509                                  ucma_event_handler, ctx, cmd.ps, qp_type, NULL);
 510         if (IS_ERR(cm_id)) {
 511                 ret = PTR_ERR(cm_id);
 512                 goto err1;
 513         }
 514
 515         resp.id = ctx->id;
 516         if (copy_to_user(u64_to_user_ptr(cmd.response),
 517                          &resp, sizeof(resp))) {
 518                 ret = -EFAULT;
 519                 goto err2;
 520         }
 521
 522         ctx->cm_id = cm_id;
 523         return 0;
 524
 525 err2:
 526         rdma_destroy_id(cm_id);
 527 err1:
 528         mutex_lock(&mut);
 529         idr_remove(&ctx_idr, ctx->id);
 530         mutex_unlock(&mut);
 531         mutex_lock(&file->mut);
 532         list_del(&ctx->list);
 533         mutex_unlock(&file->mut);
 534         kfree(ctx);
 535         return ret;
 536 }
 537
 538 static void ucma_cleanup_multicast(struct ucma_context *ctx)
 539 {
 540         struct ucma_multicast *mc, *tmp;
 541
 542         mutex_lock(&mut);
 543         list_for_each_entry_safe(mc, tmp, &ctx->mc_list, list) {
 544                 list_del(&mc->list);
 545                 idr_remove(&multicast_idr, mc->id);
 546                 kfree(mc);
 547         }
 548         mutex_unlock(&mut);
 549 }
 550
 551 static void ucma_cleanup_mc_events(struct ucma_multicast *mc)
 552 {
 553         struct ucma_event *uevent, *tmp;
 554
 555         list_for_each_entry_safe(uevent, tmp, &mc->ctx->file->event_list, list) {
 556                 if (uevent->mc != mc)
 557                         continue;
 558
 559                 list_del(&uevent->list);
 560                 kfree(uevent);
 561         }
 562 }
 563
 564 /*
 565  * ucma_free_ctx is called after the underlying rdma CM-ID is destroyed. At
 566  * this point, no new events will be reported from the hardware. However, we
 567  * still need to cleanup the UCMA context for this ID. Specifically, there
 568  * might be events that have not yet been consumed by the user space software.
 569  * These might include pending connect requests which we have not completed
 570  * processing.  We cannot call rdma_destroy_id while holding the lock of the
 571  * context (file->mut), as it might cause a deadlock. We therefore extract all
 572  * relevant events from the context pending events list while holding the
 573  * mutex. After that we release them as needed.
 574  */
 575 static int ucma_free_ctx(struct ucma_context *ctx)
 576 {
 577         int events_reported;
 578         struct ucma_event *uevent, *tmp;
 579         LIST_HEAD(list);
 580
 581
 582         ucma_cleanup_multicast(ctx);
 583
 584         /* Cleanup events not yet reported to the user. */
 585         mutex_lock(&ctx->file->mut);
 586         list_for_each_entry_safe(uevent, tmp, &ctx->file->event_list, list) {
 587                 if (uevent->ctx == ctx)
 588                         list_move_tail(&uevent->list, &list);
 589         }
 590         list_del(&ctx->list);
 591         events_reported = ctx->events_reported;
 592         mutex_unlock(&ctx->file->mut);
 593
 594         list_for_each_entry_safe(uevent, tmp, &list, list) {
 595                 list_del(&uevent->list);
 596                 if (uevent->resp.event == RDMA_CM_EVENT_CONNECT_REQUEST)
 597                         rdma_destroy_id(uevent->cm_id);
 598                 kfree(uevent);
 599         }
 600
 601         mutex_destroy(&ctx->mutex);
 602         kfree(ctx);
 603         return events_reported;
 604 }
 605
 606 static ssize_t ucma_destroy_id(struct ucma_file *file, const char __user *inbuf,
 607                                int in_len, int out_len)
 608 {
 609         struct rdma_ucm_destroy_id cmd;
 610         struct rdma_ucm_destroy_id_resp resp;
 611         struct ucma_context *ctx;
 612         int ret = 0;
 613
 614         if (out_len < sizeof(resp))
 615                 return -ENOSPC;
 616
 617         if (copy_from_user(&cmd, inbuf, sizeof(cmd)))
 618                 return -EFAULT;
 619
 620         mutex_lock(&mut);
 621         ctx = _ucma_find_context(cmd.id, file);
 622         if (!IS_ERR(ctx))
 623                 idr_remove(&ctx_idr, ctx->id);
 624         mutex_unlock(&mut);
 625
 626         if (IS_ERR(ctx))
 627                 return PTR_ERR(ctx);
 628
 629         mutex_lock(&ctx->file->mut);
 630         ctx->destroying = 1;
 631         mutex_unlock(&ctx->file->mut);
 632
 633         flush_workqueue(ctx->file->close_wq);
 634         /* At this point it's guaranteed that there is no inflight
 635          * closing task */
 636         mutex_lock(&mut);
 637         if (!ctx->closing) {
 638                 mutex_unlock(&mut);
 639                 ucma_put_ctx(ctx);
 640                 wait_for_completion(&ctx->comp);
 641                 rdma_destroy_id(ctx->cm_id);
 642         } else {
 643                 mutex_unlock(&mut);
 644         }
 645
 646         resp.events_reported = ucma_free_ctx(ctx);
 647         if (copy_to_user(u64_to_user_ptr(cmd.response),
 648                          &resp, sizeof(resp)))
 649                 ret = -EFAULT;
 650
 651         return ret;
 652 }
 653
 654 static ssize_t ucma_bind_ip(struct ucma_file *file, const char __user *inbuf,
 655                               int in_len, int out_len)
 656 {
 657         struct rdma_ucm_bind_ip cmd;
 658         struct ucma_context *ctx;
 659         int ret;
 660
 661         if (copy_from_user(&cmd, inbuf, sizeof(cmd)))
 662                 return -EFAULT;
 663
 664         if (!rdma_addr_size_in6(&cmd.addr))
 665                 return -EINVAL;
 666
 667         ctx = ucma_get_ctx(file, cmd.id);
 668         if (IS_ERR(ctx))
 669                 return PTR_ERR(ctx);
 670
 671         mutex_lock(&ctx->mutex);
 672         ret = rdma_bind_addr(ctx->cm_id, (struct sockaddr *) &cmd.addr);
 673         mutex_unlock(&ctx->mutex);
 674
 675         ucma_put_ctx(ctx);
 676         return ret;
 677 }
 678
 679 static ssize_t ucma_bind(struct ucma_file *file, const char __user *inbuf,
 680                          int in_len, int out_len)
 681 {
 682         struct rdma_ucm_bind cmd;
 683         struct ucma_context *ctx;
 684         int ret;
 685
 686         if (copy_from_user(&cmd, inbuf, sizeof(cmd)))
 687                 return -EFAULT;
 688
 689         if (cmd.reserved || !cmd.addr_size ||
 690             cmd.addr_size != rdma_addr_size_kss(&cmd.addr))
 691                 return -EINVAL;
 692
 693         ctx = ucma_get_ctx(file, cmd.id);
 694         if (IS_ERR(ctx))
 695                 return PTR_ERR(ctx);
 696
 697         mutex_lock(&ctx->mutex);
 698         ret = rdma_bind_addr(ctx->cm_id, (struct sockaddr *) &cmd.addr);
 699         mutex_unlock(&ctx->mutex);
 700         ucma_put_ctx(ctx);
 701         return ret;
 702 }
 703
 704 static ssize_t ucma_resolve_ip(struct ucma_file *file,
 705                                const char __user *inbuf,
 706                                int in_len, int out_len)
 707 {
 708         struct rdma_ucm_resolve_ip cmd;
 709         struct ucma_context *ctx;
 710         int ret;
 711
 712         if (copy_from_user(&cmd, inbuf, sizeof(cmd)))
 713                 return -EFAULT;
 714
 715         if ((cmd.src_addr.sin6_family && !rdma_addr_size_in6(&cmd.src_addr)) ||
 716             !rdma_addr_size_in6(&cmd.dst_addr))
 717                 return -EINVAL;
 718
 719         ctx = ucma_get_ctx(file, cmd.id);
 720         if (IS_ERR(ctx))
 721                 return PTR_ERR(ctx);
 722
 723         mutex_lock(&ctx->mutex);
 724         ret = rdma_resolve_addr(ctx->cm_id, (struct sockaddr *) &cmd.src_addr,
 725                                 (struct sockaddr *) &cmd.dst_addr, cmd.timeout_ms);
 726         mutex_unlock(&ctx->mutex);
 727         ucma_put_ctx(ctx);
 728         return ret;
 729 }
 730
 731 static ssize_t ucma_resolve_addr(struct ucma_file *file,
 732                                  const char __user *inbuf,
 733                                  int in_len, int out_len)
 734 {
 735         struct rdma_ucm_resolve_addr cmd;
 736         struct ucma_context *ctx;
 737         int ret;
 738
 739         if (copy_from_user(&cmd, inbuf, sizeof(cmd)))
 740                 return -EFAULT;
 741
 742         if (cmd.reserved ||
 743             (cmd.src_size && (cmd.src_size != rdma_addr_size_kss(&cmd.src_addr))) ||
 744             !cmd.dst_size || (cmd.dst_size != rdma_addr_size_kss(&cmd.dst_addr)))
 745                 return -EINVAL;
 746
 747         ctx = ucma_get_ctx(file, cmd.id);
 748         if (IS_ERR(ctx))
 749                 return PTR_ERR(ctx);
 750
 751         mutex_lock(&ctx->mutex);
 752         ret = rdma_resolve_addr(ctx->cm_id, (struct sockaddr *) &cmd.src_addr,
 753                                 (struct sockaddr *) &cmd.dst_addr, cmd.timeout_ms);
 754         mutex_unlock(&ctx->mutex);
 755         ucma_put_ctx(ctx);
 756         return ret;
 757 }
 758
 759 static ssize_t ucma_resolve_route(struct ucma_file *file,
 760                                   const char __user *inbuf,
 761                                   int in_len, int out_len)
 762 {
 763         struct rdma_ucm_resolve_route cmd;
 764         struct ucma_context *ctx;
 765         int ret;
 766
 767         if (copy_from_user(&cmd, inbuf, sizeof(cmd)))
 768                 return -EFAULT;
 769
 770         ctx = ucma_get_ctx_dev(file, cmd.id);
 771         if (IS_ERR(ctx))
 772                 return PTR_ERR(ctx);
 773
 774         mutex_lock(&ctx->mutex);
 775         ret = rdma_resolve_route(ctx->cm_id, cmd.timeout_ms);
 776         mutex_unlock(&ctx->mutex);
 777         ucma_put_ctx(ctx);
 778         return ret;
 779 }
 780
 781 static void ucma_copy_ib_route(struct rdma_ucm_query_route_resp *resp,
 782                                struct rdma_route *route)
 783 {
 784         struct rdma_dev_addr *dev_addr;
 785
 786         resp->num_paths = route->num_paths;
 787         switch (route->num_paths) {
 788         case 0:
 789                 dev_addr = &route->addr.dev_addr;
 790                 rdma_addr_get_dgid(dev_addr,
 791                                    (union ib_gid *) &resp->ib_route[0].dgid);
 792                 rdma_addr_get_sgid(dev_addr,
 793                                    (union ib_gid *) &resp->ib_route[0].sgid);
 794                 resp->ib_route[0].pkey = cpu_to_be16(ib_addr_get_pkey(dev_addr));
 795                 break;
 796         case 2:
 797                 ib_copy_path_rec_to_user(&resp->ib_route[1],
 798                                          &route->path_rec[1]);
 799                 /* fall through */
 800         case 1:
 801                 ib_copy_path_rec_to_user(&resp->ib_route[0],
 802                                          &route->path_rec[0]);
 803                 break;
 804         default:
 805                 break;
 806         }
 807 }
 808
 809 static void ucma_copy_iboe_route(struct rdma_ucm_query_route_resp *resp,
 810                                  struct rdma_route *route)
 811 {
 812
 813         resp->num_paths = route->num_paths;
 814         switch (route->num_paths) {
 815         case 0:
 816                 rdma_ip2gid((struct sockaddr *)&route->addr.dst_addr,
 817                             (union ib_gid *)&resp->ib_route[0].dgid);
 818                 rdma_ip2gid((struct sockaddr *)&route->addr.src_addr,
 819                             (union ib_gid *)&resp->ib_route[0].sgid);
 820                 resp->ib_route[0].pkey = cpu_to_be16(0xffff);
 821                 break;
 822         case 2:
 823                 ib_copy_path_rec_to_user(&resp->ib_route[1],
 824                                          &route->path_rec[1]);
 825                 /* fall through */
 826         case 1:
 827                 ib_copy_path_rec_to_user(&resp->ib_route[0],
 828                                          &route->path_rec[0]);
 829                 break;
 830         default:
 831                 break;
 832         }
 833 }
 834
 835 static void ucma_copy_iw_route(struct rdma_ucm_query_route_resp *resp,
 836                                struct rdma_route *route)
 837 {
 838         struct rdma_dev_addr *dev_addr;
 839
 840         dev_addr = &route->addr.dev_addr;
 841         rdma_addr_get_dgid(dev_addr, (union ib_gid *) &resp->ib_route[0].dgid);
 842         rdma_addr_get_sgid(dev_addr, (union ib_gid *) &resp->ib_route[0].sgid);
 843 }
 844
 845 static ssize_t ucma_query_route(struct ucma_file *file,
 846                                 const char __user *inbuf,
 847                                 int in_len, int out_len)
 848 {
 849         struct rdma_ucm_query cmd;
 850         struct rdma_ucm_query_route_resp resp;
 851         struct ucma_context *ctx;
 852         struct sockaddr *addr;
 853         int ret = 0;
 854
 855         if (out_len < sizeof(resp))
 856                 return -ENOSPC;
 857
 858         if (copy_from_user(&cmd, inbuf, sizeof(cmd)))
 859                 return -EFAULT;
 860
 861         ctx = ucma_get_ctx(file, cmd.id);
 862         if (IS_ERR(ctx))
 863                 return PTR_ERR(ctx);
 864
 865         mutex_lock(&ctx->mutex);
 866         memset(&resp, 0, sizeof resp);
 867         addr = (struct sockaddr *) &ctx->cm_id->route.addr.src_addr;
 868         memcpy(&resp.src_addr, addr, addr->sa_family == AF_INET ?
 869                                      sizeof(struct sockaddr_in) :
 870                                      sizeof(struct sockaddr_in6));
 871         addr = (struct sockaddr *) &ctx->cm_id->route.addr.dst_addr;
 872         memcpy(&resp.dst_addr, addr, addr->sa_family == AF_INET ?
 873                                      sizeof(struct sockaddr_in) :
 874                                      sizeof(struct sockaddr_in6));
 875         if (!ctx->cm_id->device)
 876                 goto out;
 877
 878         resp.node_guid = (__force __u64) ctx->cm_id->device->node_guid;
 879         resp.port_num = ctx->cm_id->port_num;
 880
 881         if (rdma_cap_ib_sa(ctx->cm_id->device, ctx->cm_id->port_num))
 882                 ucma_copy_ib_route(&resp, &ctx->cm_id->route);
 883         else if (rdma_protocol_roce(ctx->cm_id->device, ctx->cm_id->port_num))
 884                 ucma_copy_iboe_route(&resp, &ctx->cm_id->route);
 885         else if (rdma_protocol_iwarp(ctx->cm_id->device, ctx->cm_id->port_num))
 886                 ucma_copy_iw_route(&resp, &ctx->cm_id->route);
 887
 888 out:
 889         mutex_unlock(&ctx->mutex);
 890         if (copy_to_user(u64_to_user_ptr(cmd.response),
 891                          &resp, sizeof(resp)))
 892                 ret = -EFAULT;
 893
 894         ucma_put_ctx(ctx);
 895         return ret;
 896 }
 897
 898 static void ucma_query_device_addr(struct rdma_cm_id *cm_id,
 899                                    struct rdma_ucm_query_addr_resp *resp)
 900 {
 901         if (!cm_id->device)
 902                 return;
 903
 904         resp->node_guid = (__force __u64) cm_id->device->node_guid;
 905         resp->port_num = cm_id->port_num;
 906         resp->pkey = (__force __u16) cpu_to_be16(
 907                      ib_addr_get_pkey(&cm_id->route.addr.dev_addr));
 908 }
 909
 910 static ssize_t ucma_query_addr(struct ucma_context *ctx,
 911                                void __user *response, int out_len)
 912 {
 913         struct rdma_ucm_query_addr_resp resp;
 914         struct sockaddr *addr;
 915         int ret = 0;
 916
 917         if (out_len < sizeof(resp))
 918                 return -ENOSPC;
 919
 920         memset(&resp, 0, sizeof resp);
 921
 922         addr = (struct sockaddr *) &ctx->cm_id->route.addr.src_addr;
 923         resp.src_size = rdma_addr_size(addr);
 924         memcpy(&resp.src_addr, addr, resp.src_size);
 925
 926         addr = (struct sockaddr *) &ctx->cm_id->route.addr.dst_addr;
 927         resp.dst_size = rdma_addr_size(addr);
 928         memcpy(&resp.dst_addr, addr, resp.dst_size);
 929
 930         ucma_query_device_addr(ctx->cm_id, &resp);
 931
 932         if (copy_to_user(response, &resp, sizeof(resp)))
 933                 ret = -EFAULT;
 934
 935         return ret;
 936 }
 937
 938 static ssize_t ucma_query_path(struct ucma_context *ctx,
 939                                void __user *response, int out_len)
 940 {
 941         struct rdma_ucm_query_path_resp *resp;
 942         int i, ret = 0;
 943
 944         if (out_len < sizeof(*resp))
 945                 return -ENOSPC;
 946
 947         resp = kzalloc(out_len, GFP_KERNEL);
 948         if (!resp)
 949                 return -ENOMEM;
 950
 951         resp->num_paths = ctx->cm_id->route.num_paths;
 952         for (i = 0, out_len -= sizeof(*resp);
 953              i < resp->num_paths && out_len > sizeof(struct ib_path_rec_data);
 954              i++, out_len -= sizeof(struct ib_path_rec_data)) {
 955                 struct sa_path_rec *rec = &ctx->cm_id->route.path_rec[i];
 956
 957                 resp->path_data[i].flags = IB_PATH_GMP | IB_PATH_PRIMARY |
 958                                            IB_PATH_BIDIRECTIONAL;
 959                 if (rec->rec_type == SA_PATH_REC_TYPE_OPA) {
 960                         struct sa_path_rec ib;
 961
 962                         sa_convert_path_opa_to_ib(&ib, rec);
 963                         ib_sa_pack_path(&ib, &resp->path_data[i].path_rec);
 964
 965                 } else {
 966                         ib_sa_pack_path(rec, &resp->path_data[i].path_rec);
 967                 }
 968         }
 969
 970         if (copy_to_user(response, resp,
 971                          sizeof(*resp) + (i * sizeof(struct ib_path_rec_data))))
 972                 ret = -EFAULT;
 973
 974         kfree(resp);
 975         return ret;
 976 }
 977
 978 static ssize_t ucma_query_gid(struct ucma_context *ctx,
 979                               void __user *response, int out_len)
 980 {
 981         struct rdma_ucm_query_addr_resp resp;
 982         struct sockaddr_ib *addr;
 983         int ret = 0;
 984
 985         if (out_len < sizeof(resp))
 986                 return -ENOSPC;
 987
 988         memset(&resp, 0, sizeof resp);
 989
 990         ucma_query_device_addr(ctx->cm_id, &resp);
 991
 992         addr = (struct sockaddr_ib *) &resp.src_addr;
 993         resp.src_size = sizeof(*addr);
 994         if (ctx->cm_id->route.addr.src_addr.ss_family == AF_IB) {
 995                 memcpy(addr, &ctx->cm_id->route.addr.src_addr, resp.src_size);
 996         } else {
 997                 addr->sib_family = AF_IB;
 998                 addr->sib_pkey = (__force __be16) resp.pkey;
 999                 rdma_read_gids(ctx->cm_id, (union ib_gid *)&addr->sib_addr,
1000                                NULL);
1001                 addr->sib_sid = rdma_get_service_id(ctx->cm_id, (struct sockaddr *)
1002                                                     &ctx->cm_id->route.addr.src_addr);
1003         }
1004
1005         addr = (struct sockaddr_ib *) &resp.dst_addr;
1006         resp.dst_size = sizeof(*addr);
1007         if (ctx->cm_id->route.addr.dst_addr.ss_family == AF_IB) {
1008                 memcpy(addr, &ctx->cm_id->route.addr.dst_addr, resp.dst_size);
1009         } else {
1010                 addr->sib_family = AF_IB;
1011                 addr->sib_pkey = (__force __be16) resp.pkey;
1012                 rdma_read_gids(ctx->cm_id, NULL,
1013                                (union ib_gid *)&addr->sib_addr);
1014                 addr->sib_sid = rdma_get_service_id(ctx->cm_id, (struct sockaddr *)
1015                                                     &ctx->cm_id->route.addr.dst_addr);
1016         }
1017
1018         if (copy_to_user(response, &resp, sizeof(resp)))
1019                 ret = -EFAULT;
1020
1021         return ret;
1022 }
1023
1024 static ssize_t ucma_query(struct ucma_file *file,
1025                           const char __user *inbuf,
1026                           int in_len, int out_len)
1027 {
1028         struct rdma_ucm_query cmd;
1029         struct ucma_context *ctx;
1030         void __user *response;
1031         int ret;
1032
1033         if (copy_from_user(&cmd, inbuf, sizeof(cmd)))
1034                 return -EFAULT;
1035
1036         response = u64_to_user_ptr(cmd.response);
1037         ctx = ucma_get_ctx(file, cmd.id);
1038         if (IS_ERR(ctx))
1039                 return PTR_ERR(ctx);
1040
1041         mutex_lock(&ctx->mutex);
1042         switch (cmd.option) {
1043         case RDMA_USER_CM_QUERY_ADDR:
1044                 ret = ucma_query_addr(ctx, response, out_len);
1045                 break;
1046         case RDMA_USER_CM_QUERY_PATH:
1047                 ret = ucma_query_path(ctx, response, out_len);
1048                 break;
1049         case RDMA_USER_CM_QUERY_GID:
1050                 ret = ucma_query_gid(ctx, response, out_len);
1051                 break;
1052         default:
1053                 ret = -ENOSYS;
1054                 break;
1055         }
1056         mutex_unlock(&ctx->mutex);
1057
1058         ucma_put_ctx(ctx);
1059         return ret;
1060 }
1061
1062 static void ucma_copy_conn_param(struct rdma_cm_id *id,
1063                                  struct rdma_conn_param *dst,
1064                                  struct rdma_ucm_conn_param *src)
1065 {
1066         dst->private_data = src->private_data;
1067         dst->private_data_len = src->private_data_len;
1068         dst->responder_resources =src->responder_resources;
1069         dst->initiator_depth = src->initiator_depth;
1070         dst->flow_control = src->flow_control;
1071         dst->retry_count = src->retry_count;
1072         dst->rnr_retry_count = src->rnr_retry_count;
1073         dst->srq = src->srq;
1074         dst->qp_num = src->qp_num;
1075         dst->qkey = (id->route.addr.src_addr.ss_family == AF_IB) ? src->qkey : 0;
1076 }
1077
1078 static ssize_t ucma_connect(struct ucma_file *file, const char __user *inbuf,
1079                             int in_len, int out_len)
1080 {
1081         struct rdma_ucm_connect cmd;
1082         struct rdma_conn_param conn_param;
1083         struct ucma_context *ctx;
1084         int ret;
1085
1086         if (copy_from_user(&cmd, inbuf, sizeof(cmd)))
1087                 return -EFAULT;
1088
1089         if (!cmd.conn_param.valid)
1090                 return -EINVAL;
1091
1092         ctx = ucma_get_ctx_dev(file, cmd.id);
1093         if (IS_ERR(ctx))
1094                 return PTR_ERR(ctx);
1095
1096         ucma_copy_conn_param(ctx->cm_id, &conn_param, &cmd.conn_param);
1097         mutex_lock(&ctx->mutex);
1098         ret = rdma_connect(ctx->cm_id, &conn_param);
1099         mutex_unlock(&ctx->mutex);
1100         ucma_put_ctx(ctx);
1101         return ret;
1102 }
1103
1104 static ssize_t ucma_listen(struct ucma_file *file, const char __user *inbuf,
1105                            int in_len, int out_len)
1106 {
1107         struct rdma_ucm_listen cmd;
1108         struct ucma_context *ctx;
1109         int ret;
1110
1111         if (copy_from_user(&cmd, inbuf, sizeof(cmd)))
1112                 return -EFAULT;
1113
1114         ctx = ucma_get_ctx(file, cmd.id);
1115         if (IS_ERR(ctx))
1116                 return PTR_ERR(ctx);
1117
1118         ctx->backlog = cmd.backlog > 0 && cmd.backlog < max_backlog ?
1119                        cmd.backlog : max_backlog;
1120         mutex_lock(&ctx->mutex);
1121         ret = rdma_listen(ctx->cm_id, ctx->backlog);
1122         mutex_unlock(&ctx->mutex);
1123         ucma_put_ctx(ctx);
1124         return ret;
1125 }
1126
1127 static ssize_t ucma_accept(struct ucma_file *file, const char __user *inbuf,
1128                            int in_len, int out_len)
1129 {
1130         struct rdma_ucm_accept cmd;
1131         struct rdma_conn_param conn_param;
1132         struct ucma_context *ctx;
1133         int ret;
1134
1135         if (copy_from_user(&cmd, inbuf, sizeof(cmd)))
1136                 return -EFAULT;
1137
1138         ctx = ucma_get_ctx_dev(file, cmd.id);
1139         if (IS_ERR(ctx))
1140                 return PTR_ERR(ctx);
1141
1142         if (cmd.conn_param.valid) {
1143                 ucma_copy_conn_param(ctx->cm_id, &conn_param, &cmd.conn_param);
1144                 mutex_lock(&file->mut);
1145                 mutex_lock(&ctx->mutex);
1146                 ret = __rdma_accept(ctx->cm_id, &conn_param, NULL);
1147                 mutex_unlock(&ctx->mutex);
1148                 if (!ret)
1149                         ctx->uid = cmd.uid;
1150                 mutex_unlock(&file->mut);
1151         } else {
1152                 mutex_lock(&ctx->mutex);
1153                 ret = __rdma_accept(ctx->cm_id, NULL, NULL);
1154                 mutex_unlock(&ctx->mutex);
1155         }
1156         ucma_put_ctx(ctx);
1157         return ret;
1158 }
1159
1160 static ssize_t ucma_reject(struct ucma_file *file, const char __user *inbuf,
1161                            int in_len, int out_len)
1162 {
1163         struct rdma_ucm_reject cmd;
1164         struct ucma_context *ctx;
1165         int ret;
1166
1167         if (copy_from_user(&cmd, inbuf, sizeof(cmd)))
1168                 return -EFAULT;
1169
1170         ctx = ucma_get_ctx_dev(file, cmd.id);
1171         if (IS_ERR(ctx))
1172                 return PTR_ERR(ctx);
1173
1174         mutex_lock(&ctx->mutex);
1175         ret = rdma_reject(ctx->cm_id, cmd.private_data, cmd.private_data_len);
1176         mutex_unlock(&ctx->mutex);
1177         ucma_put_ctx(ctx);
1178         return ret;
1179 }
1180
1181 static ssize_t ucma_disconnect(struct ucma_file *file, const char __user *inbuf,
1182                                int in_len, int out_len)
1183 {
1184         struct rdma_ucm_disconnect cmd;
1185         struct ucma_context *ctx;
1186         int ret;
1187
1188         if (copy_from_user(&cmd, inbuf, sizeof(cmd)))
1189                 return -EFAULT;
1190
1191         ctx = ucma_get_ctx_dev(file, cmd.id);
1192         if (IS_ERR(ctx))
1193                 return PTR_ERR(ctx);
1194
1195         mutex_lock(&ctx->mutex);
1196         ret = rdma_disconnect(ctx->cm_id);
1197         mutex_unlock(&ctx->mutex);
1198         ucma_put_ctx(ctx);
1199         return ret;
1200 }
1201
1202 static ssize_t ucma_init_qp_attr(struct ucma_file *file,
1203                                  const char __user *inbuf,
1204                                  int in_len, int out_len)
1205 {
1206         struct rdma_ucm_init_qp_attr cmd;
1207         struct ib_uverbs_qp_attr resp;
1208         struct ucma_context *ctx;
1209         struct ib_qp_attr qp_attr;
1210         int ret;
1211
1212         if (out_len < sizeof(resp))
1213                 return -ENOSPC;
1214
1215         if (copy_from_user(&cmd, inbuf, sizeof(cmd)))
1216                 return -EFAULT;
1217
1218         if (cmd.qp_state > IB_QPS_ERR)
1219                 return -EINVAL;
1220
1221         ctx = ucma_get_ctx_dev(file, cmd.id);
1222         if (IS_ERR(ctx))
1223                 return PTR_ERR(ctx);
1224
1225         resp.qp_attr_mask = 0;
1226         memset(&qp_attr, 0, sizeof qp_attr);
1227         qp_attr.qp_state = cmd.qp_state;
1228         mutex_lock(&ctx->mutex);
1229         ret = rdma_init_qp_attr(ctx->cm_id, &qp_attr, &resp.qp_attr_mask);
1230         mutex_unlock(&ctx->mutex);
1231         if (ret)
1232                 goto out;
1233
1234         ib_copy_qp_attr_to_user(ctx->cm_id->device, &resp, &qp_attr);
1235         if (copy_to_user(u64_to_user_ptr(cmd.response),
1236                          &resp, sizeof(resp)))
1237                 ret = -EFAULT;
1238
1239 out:
1240         ucma_put_ctx(ctx);
1241         return ret;
1242 }
1243
1244 static int ucma_set_option_id(struct ucma_context *ctx, int optname,
1245                               void *optval, size_t optlen)
1246 {
1247         int ret = 0;
1248
1249         switch (optname) {
1250         case RDMA_OPTION_ID_TOS:
1251                 if (optlen != sizeof(u8)) {
1252                         ret = -EINVAL;
1253                         break;
1254                 }
1255                 rdma_set_service_type(ctx->cm_id, *((u8 *) optval));
1256                 break;
1257         case RDMA_OPTION_ID_REUSEADDR:
1258                 if (optlen != sizeof(int)) {
1259                         ret = -EINVAL;
1260                         break;
1261                 }
1262                 ret = rdma_set_reuseaddr(ctx->cm_id, *((int *) optval) ? 1 : 0);
1263                 break;
1264         case RDMA_OPTION_ID_AFONLY:
1265                 if (optlen != sizeof(int)) {
1266                         ret = -EINVAL;
1267                         break;
1268                 }
1269                 ret = rdma_set_afonly(ctx->cm_id, *((int *) optval) ? 1 : 0);
1270                 break;
1271         default:
1272                 ret = -ENOSYS;
1273         }
1274
1275         return ret;
1276 }
1277
1278 static int ucma_set_ib_path(struct ucma_context *ctx,
1279                             struct ib_path_rec_data *path_data, size_t optlen)
1280 {
1281         struct sa_path_rec sa_path;
1282         struct rdma_cm_event event;
1283         int ret;
1284
1285         if (optlen % sizeof(*path_data))
1286                 return -EINVAL;
1287
1288         for (; optlen; optlen -= sizeof(*path_data), path_data++) {
1289                 if (path_data->flags == (IB_PATH_GMP | IB_PATH_PRIMARY |
1290                                          IB_PATH_BIDIRECTIONAL))
1291                         break;
1292         }
1293
1294         if (!optlen)
1295                 return -EINVAL;
1296
1297         if (!ctx->cm_id->device)
1298                 return -EINVAL;
1299
1300         memset(&sa_path, 0, sizeof(sa_path));
1301
1302         sa_path.rec_type = SA_PATH_REC_TYPE_IB;
1303         ib_sa_unpack_path(path_data->path_rec, &sa_path);
1304
1305         if (rdma_cap_opa_ah(ctx->cm_id->device, ctx->cm_id->port_num)) {
1306                 struct sa_path_rec opa;
1307
1308                 sa_convert_path_ib_to_opa(&opa, &sa_path);
1309                 mutex_lock(&ctx->mutex);
1310                 ret = rdma_set_ib_path(ctx->cm_id, &opa);
1311                 mutex_unlock(&ctx->mutex);
1312         } else {
1313                 mutex_lock(&ctx->mutex);
1314                 ret = rdma_set_ib_path(ctx->cm_id, &sa_path);
1315                 mutex_unlock(&ctx->mutex);
1316         }
1317         if (ret)
1318                 return ret;
1319
1320         memset(&event, 0, sizeof event);
1321         event.event = RDMA_CM_EVENT_ROUTE_RESOLVED;
1322         return ucma_event_handler(ctx->cm_id, &event);
1323 }
1324
1325 static int ucma_set_option_ib(struct ucma_context *ctx, int optname,
1326                               void *optval, size_t optlen)
1327 {
1328         int ret;
1329
1330         switch (optname) {
1331         case RDMA_OPTION_IB_PATH:
1332                 ret = ucma_set_ib_path(ctx, optval, optlen);
1333                 break;
1334         default:
1335                 ret = -ENOSYS;
1336         }
1337
1338         return ret;
1339 }
1340
1341 static int ucma_set_option_level(struct ucma_context *ctx, int level,
1342                                  int optname, void *optval, size_t optlen)
1343 {
1344         int ret;
1345
1346         switch (level) {
1347         case RDMA_OPTION_ID:
1348                 mutex_lock(&ctx->mutex);
1349                 ret = ucma_set_option_id(ctx, optname, optval, optlen);
1350                 mutex_unlock(&ctx->mutex);
1351                 break;
1352         case RDMA_OPTION_IB:
1353                 ret = ucma_set_option_ib(ctx, optname, optval, optlen);
1354                 break;
1355         default:
1356                 ret = -ENOSYS;
1357         }
1358
1359         return ret;
1360 }
1361
1362 static ssize_t ucma_set_option(struct ucma_file *file, const char __user *inbuf,
1363                                int in_len, int out_len)
1364 {
1365         struct rdma_ucm_set_option cmd;
1366         struct ucma_context *ctx;
1367         void *optval;
1368         int ret;
1369
1370         if (copy_from_user(&cmd, inbuf, sizeof(cmd)))
1371                 return -EFAULT;
1372
1373         if (unlikely(cmd.optlen > KMALLOC_MAX_SIZE))
1374                 return -EINVAL;
1375
1376         ctx = ucma_get_ctx(file, cmd.id);
1377         if (IS_ERR(ctx))
1378                 return PTR_ERR(ctx);
1379
1380         optval = memdup_user(u64_to_user_ptr(cmd.optval),
1381                              cmd.optlen);
1382         if (IS_ERR(optval)) {
1383                 ret = PTR_ERR(optval);
1384                 goto out;
1385         }
1386
1387         ret = ucma_set_option_level(ctx, cmd.level, cmd.optname, optval,
1388                                     cmd.optlen);
1389         kfree(optval);
1390
1391 out:
1392         ucma_put_ctx(ctx);
1393         return ret;
1394 }
1395
1396 static ssize_t ucma_notify(struct ucma_file *file, const char __user *inbuf,
1397                            int in_len, int out_len)
1398 {
1399         struct rdma_ucm_notify cmd;
1400         struct ucma_context *ctx;
1401         int ret = -EINVAL;
1402
1403         if (copy_from_user(&cmd, inbuf, sizeof(cmd)))
1404                 return -EFAULT;
1405
1406         ctx = ucma_get_ctx(file, cmd.id);
1407         if (IS_ERR(ctx))
1408                 return PTR_ERR(ctx);
1409
1410         mutex_lock(&ctx->mutex);
1411         if (ctx->cm_id->device)
1412                 ret = rdma_notify(ctx->cm_id, (enum ib_event_type)cmd.event);
1413         mutex_unlock(&ctx->mutex);
1414
1415         ucma_put_ctx(ctx);
1416         return ret;
1417 }
1418
1419 static ssize_t ucma_process_join(struct ucma_file *file,
1420                                  struct rdma_ucm_join_mcast *cmd,  int out_len)
1421 {
1422         struct rdma_ucm_create_id_resp resp;
1423         struct ucma_context *ctx;
1424         struct ucma_multicast *mc;
1425         struct sockaddr *addr;
1426         int ret;
1427         u8 join_state;
1428
1429         if (out_len < sizeof(resp))
1430                 return -ENOSPC;
1431
1432         addr = (struct sockaddr *) &cmd->addr;
1433         if (cmd->addr_size != rdma_addr_size(addr))
1434                 return -EINVAL;
1435
1436         if (cmd->join_flags == RDMA_MC_JOIN_FLAG_FULLMEMBER)
1437                 join_state = BIT(FULLMEMBER_JOIN);
1438         else if (cmd->join_flags == RDMA_MC_JOIN_FLAG_SENDONLY_FULLMEMBER)
1439                 join_state = BIT(SENDONLY_FULLMEMBER_JOIN);
1440         else
1441                 return -EINVAL;
1442
1443         ctx = ucma_get_ctx_dev(file, cmd->id);
1444         if (IS_ERR(ctx))
1445                 return PTR_ERR(ctx);
1446
1447         mutex_lock(&file->mut);
1448         mc = ucma_alloc_multicast(ctx);
1449         if (!mc) {
1450                 ret = -ENOMEM;
1451                 goto err1;
1452         }
1453         mc->join_state = join_state;
1454         mc->uid = cmd->uid;
1455         memcpy(&mc->addr, addr, cmd->addr_size);
1456         mutex_lock(&ctx->mutex);
1457         ret = rdma_join_multicast(ctx->cm_id, (struct sockaddr *)&mc->addr,
1458                                   join_state, mc);
1459         mutex_unlock(&ctx->mutex);
1460         if (ret)
1461                 goto err2;
1462
1463         resp.id = mc->id;
1464         if (copy_to_user(u64_to_user_ptr(cmd->response),
1465                          &resp, sizeof(resp))) {
1466                 ret = -EFAULT;
1467                 goto err3;
1468         }
1469
1470         mutex_lock(&mut);
1471         idr_replace(&multicast_idr, mc, mc->id);
1472         mutex_unlock(&mut);
1473
1474         mutex_unlock(&file->mut);
1475         ucma_put_ctx(ctx);
1476         return 0;
1477
1478 err3:
1479         mutex_lock(&ctx->mutex);
1480         rdma_leave_multicast(ctx->cm_id, (struct sockaddr *) &mc->addr);
1481         mutex_unlock(&ctx->mutex);
1482         ucma_cleanup_mc_events(mc);
1483 err2:
1484         mutex_lock(&mut);
1485         idr_remove(&multicast_idr, mc->id);
1486         mutex_unlock(&mut);
1487         list_del(&mc->list);
1488         kfree(mc);
1489 err1:
1490         mutex_unlock(&file->mut);
1491         ucma_put_ctx(ctx);
1492         return ret;
1493 }
1494
1495 static ssize_t ucma_join_ip_multicast(struct ucma_file *file,
1496                                       const char __user *inbuf,
1497                                       int in_len, int out_len)
1498 {
1499         struct rdma_ucm_join_ip_mcast cmd;
1500         struct rdma_ucm_join_mcast join_cmd;
1501
1502         if (copy_from_user(&cmd, inbuf, sizeof(cmd)))
1503                 return -EFAULT;
1504
1505         join_cmd.response = cmd.response;
1506         join_cmd.uid = cmd.uid;
1507         join_cmd.id = cmd.id;
1508         join_cmd.addr_size = rdma_addr_size_in6(&cmd.addr);
1509         if (!join_cmd.addr_size)
1510                 return -EINVAL;
1511
1512         join_cmd.join_flags = RDMA_MC_JOIN_FLAG_FULLMEMBER;
1513         memcpy(&join_cmd.addr, &cmd.addr, join_cmd.addr_size);
1514
1515         return ucma_process_join(file, &join_cmd, out_len);
1516 }
1517
1518 static ssize_t ucma_join_multicast(struct ucma_file *file,
1519                                    const char __user *inbuf,
1520                                    int in_len, int out_len)
1521 {
1522         struct rdma_ucm_join_mcast cmd;
1523
1524         if (copy_from_user(&cmd, inbuf, sizeof(cmd)))
1525                 return -EFAULT;
1526
1527         if (!rdma_addr_size_kss(&cmd.addr))
1528                 return -EINVAL;
1529
1530         return ucma_process_join(file, &cmd, out_len);
1531 }
1532
1533 static ssize_t ucma_leave_multicast(struct ucma_file *file,
1534                                     const char __user *inbuf,
1535                                     int in_len, int out_len)
1536 {
1537         struct rdma_ucm_destroy_id cmd;
1538         struct rdma_ucm_destroy_id_resp resp;
1539         struct ucma_multicast *mc;
1540         int ret = 0;
1541
1542         if (out_len < sizeof(resp))
1543                 return -ENOSPC;
1544
1545         if (copy_from_user(&cmd, inbuf, sizeof(cmd)))
1546                 return -EFAULT;
1547
1548         mutex_lock(&mut);
1549         mc = idr_find(&multicast_idr, cmd.id);
1550         if (!mc)
1551                 mc = ERR_PTR(-ENOENT);
1552         else if (mc->ctx->file != file)
1553                 mc = ERR_PTR(-EINVAL);
1554         else if (!atomic_inc_not_zero(&mc->ctx->ref))
1555                 mc = ERR_PTR(-ENXIO);
1556         else
1557                 idr_remove(&multicast_idr, mc->id);
1558         mutex_unlock(&mut);
1559
1560         if (IS_ERR(mc)) {
1561                 ret = PTR_ERR(mc);
1562                 goto out;
1563         }
1564
1565         mutex_lock(&mc->ctx->mutex);
1566         rdma_leave_multicast(mc->ctx->cm_id, (struct sockaddr *) &mc->addr);
1567         mutex_unlock(&mc->ctx->mutex);
1568
1569         mutex_lock(&mc->ctx->file->mut);
1570         ucma_cleanup_mc_events(mc);
1571         list_del(&mc->list);
1572         mutex_unlock(&mc->ctx->file->mut);
1573
1574         ucma_put_ctx(mc->ctx);
1575         resp.events_reported = mc->events_reported;
1576         kfree(mc);
1577
1578         if (copy_to_user(u64_to_user_ptr(cmd.response),
1579                          &resp, sizeof(resp)))
1580                 ret = -EFAULT;
1581 out:
1582         return ret;
1583 }
1584
1585 static void ucma_lock_files(struct ucma_file *file1, struct ucma_file *file2)
1586 {
1587         /* Acquire mutex's based on pointer comparison to prevent deadlock. */
1588         if (file1 < file2) {
1589                 mutex_lock(&file1->mut);
1590                 mutex_lock_nested(&file2->mut, SINGLE_DEPTH_NESTING);
1591         } else {
1592                 mutex_lock(&file2->mut);
1593                 mutex_lock_nested(&file1->mut, SINGLE_DEPTH_NESTING);
1594         }
1595 }
1596
1597 static void ucma_unlock_files(struct ucma_file *file1, struct ucma_file *file2)
1598 {
1599         if (file1 < file2) {
1600                 mutex_unlock(&file2->mut);
1601                 mutex_unlock(&file1->mut);
1602         } else {
1603                 mutex_unlock(&file1->mut);
1604                 mutex_unlock(&file2->mut);
1605         }
1606 }
1607
1608 static void ucma_move_events(struct ucma_context *ctx, struct ucma_file *file)
1609 {
1610         struct ucma_event *uevent, *tmp;
1611
1612         list_for_each_entry_safe(uevent, tmp, &ctx->file->event_list, list)
1613                 if (uevent->ctx == ctx)
1614                         list_move_tail(&uevent->list, &file->event_list);
1615 }
1616
1617 static ssize_t ucma_migrate_id(struct ucma_file *new_file,
1618                                const char __user *inbuf,
1619                                int in_len, int out_len)
1620 {
1621         struct rdma_ucm_migrate_id cmd;
1622         struct rdma_ucm_migrate_resp resp;
1623         struct ucma_context *ctx;
1624         struct fd f;
1625         struct ucma_file *cur_file;
1626         int ret = 0;
1627
1628         if (copy_from_user(&cmd, inbuf, sizeof(cmd)))
1629                 return -EFAULT;
1630
1631         /* Get current fd to protect against it being closed */
1632         f = fdget(cmd.fd);
1633         if (!f.file)
1634                 return -ENOENT;
1635         if (f.file->f_op != &ucma_fops) {
1636                 ret = -EINVAL;
1637                 goto file_put;
1638         }
1639
1640         /* Validate current fd and prevent destruction of id. */
1641         ctx = ucma_get_ctx(f.file->private_data, cmd.id);
1642         if (IS_ERR(ctx)) {
1643                 ret = PTR_ERR(ctx);
1644                 goto file_put;
1645         }
1646
1647         cur_file = ctx->file;
1648         if (cur_file == new_file) {
1649                 mutex_lock(&cur_file->mut);
1650                 resp.events_reported = ctx->events_reported;
1651                 mutex_unlock(&cur_file->mut);
1652                 goto response;
1653         }
1654
1655         /*
1656          * Migrate events between fd's, maintaining order, and avoiding new
1657          * events being added before existing events.
1658          */
1659         ucma_lock_files(cur_file, new_file);
1660         mutex_lock(&mut);
1661
1662         list_move_tail(&ctx->list, &new_file->ctx_list);
1663         ucma_move_events(ctx, new_file);
1664         ctx->file = new_file;
1665         resp.events_reported = ctx->events_reported;
1666
1667         mutex_unlock(&mut);
1668         ucma_unlock_files(cur_file, new_file);
1669
1670 response:
1671         if (copy_to_user(u64_to_user_ptr(cmd.response),
1672                          &resp, sizeof(resp)))
1673                 ret = -EFAULT;
1674
1675         ucma_put_ctx(ctx);
1676 file_put:
1677         fdput(f);
1678         return ret;
1679 }
1680
1681 static ssize_t (*ucma_cmd_table[])(struct ucma_file *file,
1682                                    const char __user *inbuf,
1683                                    int in_len, int out_len) = {
1684         [RDMA_USER_CM_CMD_CREATE_ID]     = ucma_create_id,
1685         [RDMA_USER_CM_CMD_DESTROY_ID]    = ucma_destroy_id,
1686         [RDMA_USER_CM_CMD_BIND_IP]       = ucma_bind_ip,
1687         [RDMA_USER_CM_CMD_RESOLVE_IP]    = ucma_resolve_ip,
1688         [RDMA_USER_CM_CMD_RESOLVE_ROUTE] = ucma_resolve_route,
1689         [RDMA_USER_CM_CMD_QUERY_ROUTE]   = ucma_query_route,
1690         [RDMA_USER_CM_CMD_CONNECT]       = ucma_connect,
1691         [RDMA_USER_CM_CMD_LISTEN]        = ucma_listen,
1692         [RDMA_USER_CM_CMD_ACCEPT]        = ucma_accept,
1693         [RDMA_USER_CM_CMD_REJECT]        = ucma_reject,
1694         [RDMA_USER_CM_CMD_DISCONNECT]    = ucma_disconnect,
1695         [RDMA_USER_CM_CMD_INIT_QP_ATTR]  = ucma_init_qp_attr,
1696         [RDMA_USER_CM_CMD_GET_EVENT]     = ucma_get_event,
1697         [RDMA_USER_CM_CMD_GET_OPTION]    = NULL,
1698         [RDMA_USER_CM_CMD_SET_OPTION]    = ucma_set_option,
1699         [RDMA_USER_CM_CMD_NOTIFY]        = ucma_notify,
1700         [RDMA_USER_CM_CMD_JOIN_IP_MCAST] = ucma_join_ip_multicast,
1701         [RDMA_USER_CM_CMD_LEAVE_MCAST]   = ucma_leave_multicast,
1702         [RDMA_USER_CM_CMD_MIGRATE_ID]    = ucma_migrate_id,
1703         [RDMA_USER_CM_CMD_QUERY]         = ucma_query,
1704         [RDMA_USER_CM_CMD_BIND]          = ucma_bind,
1705         [RDMA_USER_CM_CMD_RESOLVE_ADDR]  = ucma_resolve_addr,
1706         [RDMA_USER_CM_CMD_JOIN_MCAST]    = ucma_join_multicast
1707 };
1708
1709 static ssize_t ucma_write(struct file *filp, const char __user *buf,
1710                           size_t len, loff_t *pos)
1711 {
1712         struct ucma_file *file = filp->private_data;
1713         struct rdma_ucm_cmd_hdr hdr;
1714         ssize_t ret;
1715
1716         if (!ib_safe_file_access(filp)) {
1717                 pr_err_once("ucma_write: process %d (%s) changed security contexts after opening file descriptor, this is not allowed.\n",
1718                             task_tgid_vnr(current), current->comm);
1719                 return -EACCES;
1720         }
1721
1722         if (len < sizeof(hdr))
1723                 return -EINVAL;
1724
1725         if (copy_from_user(&hdr, buf, sizeof(hdr)))
1726                 return -EFAULT;
1727
1728         if (hdr.cmd >= ARRAY_SIZE(ucma_cmd_table))
1729                 return -EINVAL;
1730         hdr.cmd = array_index_nospec(hdr.cmd, ARRAY_SIZE(ucma_cmd_table));
1731
1732         if (hdr.in + sizeof(hdr) > len)
1733                 return -EINVAL;
1734
1735         if (!ucma_cmd_table[hdr.cmd])
1736                 return -ENOSYS;
1737
1738         ret = ucma_cmd_table[hdr.cmd](file, buf + sizeof(hdr), hdr.in, hdr.out);
1739         if (!ret)
1740                 ret = len;
1741
1742         return ret;
1743 }
1744
1745 static __poll_t ucma_poll(struct file *filp, struct poll_table_struct *wait)
1746 {
1747         struct ucma_file *file = filp->private_data;
1748         __poll_t mask = 0;
1749
1750         poll_wait(filp, &file->poll_wait, wait);
1751
1752         if (!list_empty(&file->event_list))
1753                 mask = EPOLLIN | EPOLLRDNORM;
1754
1755         return mask;
1756 }
1757
1758 /*
1759  * ucma_open() does not need the BKL:
1760  *
1761  *  - no global state is referred to;
1762  *  - there is no ioctl method to race against;
1763  *  - no further module initialization is required for open to work
1764  *    after the device is registered.
1765  */
1766 static int ucma_open(struct inode *inode, struct file *filp)
1767 {
1768         struct ucma_file *file;
1769
1770         file = kmalloc(sizeof *file, GFP_KERNEL);
1771         if (!file)
1772                 return -ENOMEM;
1773
1774         file->close_wq = alloc_ordered_workqueue("ucma_close_id",
1775                                                  WQ_MEM_RECLAIM);
1776         if (!file->close_wq) {
1777                 kfree(file);
1778                 return -ENOMEM;
1779         }
1780
1781         INIT_LIST_HEAD(&file->event_list);
1782         INIT_LIST_HEAD(&file->ctx_list);
1783         init_waitqueue_head(&file->poll_wait);
1784         mutex_init(&file->mut);
1785
1786         filp->private_data = file;
1787         file->filp = filp;
1788
1789         return nonseekable_open(inode, filp);
1790 }
1791
1792 static int ucma_close(struct inode *inode, struct file *filp)
1793 {
1794         struct ucma_file *file = filp->private_data;
1795         struct ucma_context *ctx, *tmp;
1796
1797         mutex_lock(&file->mut);
1798         list_for_each_entry_safe(ctx, tmp, &file->ctx_list, list) {
1799                 ctx->destroying = 1;
1800                 mutex_unlock(&file->mut);
1801
1802                 mutex_lock(&mut);
1803                 idr_remove(&ctx_idr, ctx->id);
1804                 mutex_unlock(&mut);
1805
1806                 flush_workqueue(file->close_wq);
1807                 /* At that step once ctx was marked as destroying and workqueue
1808                  * was flushed we are safe from any inflights handlers that
1809                  * might put other closing task.
1810                  */
1811                 mutex_lock(&mut);
1812                 if (!ctx->closing) {
1813                         mutex_unlock(&mut);
1814                         ucma_put_ctx(ctx);
1815                         wait_for_completion(&ctx->comp);
1816                         /* rdma_destroy_id ensures that no event handlers are
1817                          * inflight for that id before releasing it.
1818                          */
1819                         rdma_destroy_id(ctx->cm_id);
1820                 } else {
1821                         mutex_unlock(&mut);
1822                 }
1823
1824                 ucma_free_ctx(ctx);
1825                 mutex_lock(&file->mut);
1826         }
1827         mutex_unlock(&file->mut);
1828         destroy_workqueue(file->close_wq);
1829         kfree(file);
1830         return 0;
1831 }
1832
1833 static const struct file_operations ucma_fops = {
1834         .owner   = THIS_MODULE,
1835         .open    = ucma_open,
1836         .release = ucma_close,
1837         .write   = ucma_write,
1838         .poll    = ucma_poll,
1839         .llseek  = no_llseek,
1840 };
1841
1842 static struct miscdevice ucma_misc = {
1843         .minor          = MISC_DYNAMIC_MINOR,
1844         .name           = "rdma_cm",
1845         .nodename       = "infiniband/rdma_cm",
1846         .mode           = 0666,
1847         .fops           = &ucma_fops,
1848 };
1849
1850 static ssize_t show_abi_version(struct device *dev,
1851                                 struct device_attribute *attr,
1852                                 char *buf)
1853 {
1854         return sprintf(buf, "%d\n", RDMA_USER_CM_ABI_VERSION);
1855 }
1856 static DEVICE_ATTR(abi_version, S_IRUGO, show_abi_version, NULL);
1857
1858 static int __init ucma_init(void)
1859 {
1860         int ret;
1861
1862         ret = misc_register(&ucma_misc);
1863         if (ret)
1864                 return ret;
1865
1866         ret = device_create_file(ucma_misc.this_device, &dev_attr_abi_version);
1867         if (ret) {
1868                 pr_err("rdma_ucm: couldn't create abi_version attr\n");
1869                 goto err1;
1870         }
1871
1872         ucma_ctl_table_hdr = register_net_sysctl(&init_net, "net/rdma_ucm", ucma_ctl_table);
1873         if (!ucma_ctl_table_hdr) {
1874                 pr_err("rdma_ucm: couldn't register sysctl paths\n");
1875                 ret = -ENOMEM;
1876                 goto err2;
1877         }
1878         return 0;
1879 err2:
1880         device_remove_file(ucma_misc.this_device, &dev_attr_abi_version);
1881 err1:
1882         misc_deregister(&ucma_misc);
1883         return ret;
1884 }
1885
1886 static void __exit ucma_cleanup(void)
1887 {
1888         unregister_net_sysctl_table(ucma_ctl_table_hdr);
1889         device_remove_file(ucma_misc.this_device, &dev_attr_abi_version);
1890         misc_deregister(&ucma_misc);
1891         idr_destroy(&ctx_idr);
1892         idr_destroy(&multicast_idr);
1893 }
1894
1895 module_init(ucma_init);
1896 module_exit(ucma_cleanup);