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