Linux Kernel  3.7.1
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Groups Pages
ucma.c
Go to the documentation of this file.
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 
46 #include <rdma/rdma_user_cm.h>
47 #include <rdma/ib_marshall.h>
48 #include <rdma/rdma_cm.h>
49 #include <rdma/rdma_cm_ib.h>
50 
51 MODULE_AUTHOR("Sean Hefty");
52 MODULE_DESCRIPTION("RDMA Userspace Connection Manager Access");
53 MODULE_LICENSE("Dual BSD/GPL");
54 
55 static unsigned int max_backlog = 1024;
56 
57 static struct ctl_table_header *ucma_ctl_table_hdr;
58 static ctl_table ucma_ctl_table[] = {
59  {
60  .procname = "max_backlog",
61  .data = &max_backlog,
62  .maxlen = sizeof max_backlog,
63  .mode = 0644,
64  .proc_handler = proc_dointvec,
65  },
66  { }
67 };
68 
69 struct ucma_file {
70  struct mutex mut;
71  struct file *filp;
75 };
76 
77 struct ucma_context {
78  int id;
79  struct completion comp;
82  int backlog;
83 
84  struct ucma_file *file;
85  struct rdma_cm_id *cm_id;
87 
88  struct list_head list;
90 };
91 
93  struct ucma_context *ctx;
94  int id;
96 
98  struct list_head list;
100 };
101 
102 struct ucma_event {
103  struct ucma_context *ctx;
105  struct list_head list;
106  struct rdma_cm_id *cm_id;
108 };
109 
110 static DEFINE_MUTEX(mut);
111 static DEFINE_IDR(ctx_idr);
112 static DEFINE_IDR(multicast_idr);
113 
114 static inline struct ucma_context *_ucma_find_context(int id,
115  struct ucma_file *file)
116 {
117  struct ucma_context *ctx;
118 
119  ctx = idr_find(&ctx_idr, id);
120  if (!ctx)
121  ctx = ERR_PTR(-ENOENT);
122  else if (ctx->file != file)
123  ctx = ERR_PTR(-EINVAL);
124  return ctx;
125 }
126 
127 static struct ucma_context *ucma_get_ctx(struct ucma_file *file, int id)
128 {
129  struct ucma_context *ctx;
130 
131  mutex_lock(&mut);
132  ctx = _ucma_find_context(id, file);
133  if (!IS_ERR(ctx))
134  atomic_inc(&ctx->ref);
135  mutex_unlock(&mut);
136  return ctx;
137 }
138 
139 static void ucma_put_ctx(struct ucma_context *ctx)
140 {
141  if (atomic_dec_and_test(&ctx->ref))
142  complete(&ctx->comp);
143 }
144 
145 static struct ucma_context *ucma_alloc_ctx(struct ucma_file *file)
146 {
147  struct ucma_context *ctx;
148  int ret;
149 
150  ctx = kzalloc(sizeof(*ctx), GFP_KERNEL);
151  if (!ctx)
152  return NULL;
153 
154  atomic_set(&ctx->ref, 1);
155  init_completion(&ctx->comp);
156  INIT_LIST_HEAD(&ctx->mc_list);
157  ctx->file = file;
158 
159  do {
160  ret = idr_pre_get(&ctx_idr, GFP_KERNEL);
161  if (!ret)
162  goto error;
163 
164  mutex_lock(&mut);
165  ret = idr_get_new(&ctx_idr, ctx, &ctx->id);
166  mutex_unlock(&mut);
167  } while (ret == -EAGAIN);
168 
169  if (ret)
170  goto error;
171 
172  list_add_tail(&ctx->list, &file->ctx_list);
173  return ctx;
174 
175 error:
176  kfree(ctx);
177  return NULL;
178 }
179 
180 static struct ucma_multicast* ucma_alloc_multicast(struct ucma_context *ctx)
181 {
182  struct ucma_multicast *mc;
183  int ret;
184 
185  mc = kzalloc(sizeof(*mc), GFP_KERNEL);
186  if (!mc)
187  return NULL;
188 
189  do {
190  ret = idr_pre_get(&multicast_idr, GFP_KERNEL);
191  if (!ret)
192  goto error;
193 
194  mutex_lock(&mut);
195  ret = idr_get_new(&multicast_idr, mc, &mc->id);
196  mutex_unlock(&mut);
197  } while (ret == -EAGAIN);
198 
199  if (ret)
200  goto error;
201 
202  mc->ctx = ctx;
203  list_add_tail(&mc->list, &ctx->mc_list);
204  return mc;
205 
206 error:
207  kfree(mc);
208  return NULL;
209 }
210 
211 static void ucma_copy_conn_event(struct rdma_ucm_conn_param *dst,
212  struct rdma_conn_param *src)
213 {
214  if (src->private_data_len)
215  memcpy(dst->private_data, src->private_data,
216  src->private_data_len);
219  dst->initiator_depth = src->initiator_depth;
220  dst->flow_control = src->flow_control;
221  dst->retry_count = src->retry_count;
222  dst->rnr_retry_count = src->rnr_retry_count;
223  dst->srq = src->srq;
224  dst->qp_num = src->qp_num;
225 }
226 
227 static void ucma_copy_ud_event(struct rdma_ucm_ud_param *dst,
228  struct rdma_ud_param *src)
229 {
230  if (src->private_data_len)
231  memcpy(dst->private_data, src->private_data,
232  src->private_data_len);
235  dst->qp_num = src->qp_num;
236  dst->qkey = src->qkey;
237 }
238 
239 static void ucma_set_event_context(struct ucma_context *ctx,
240  struct rdma_cm_event *event,
241  struct ucma_event *uevent)
242 {
243  uevent->ctx = ctx;
244  switch (event->event) {
247  uevent->mc = (struct ucma_multicast *)
248  event->param.ud.private_data;
249  uevent->resp.uid = uevent->mc->uid;
250  uevent->resp.id = uevent->mc->id;
251  break;
252  default:
253  uevent->resp.uid = ctx->uid;
254  uevent->resp.id = ctx->id;
255  break;
256  }
257 }
258 
259 static int ucma_event_handler(struct rdma_cm_id *cm_id,
260  struct rdma_cm_event *event)
261 {
262  struct ucma_event *uevent;
263  struct ucma_context *ctx = cm_id->context;
264  int ret = 0;
265 
266  uevent = kzalloc(sizeof(*uevent), GFP_KERNEL);
267  if (!uevent)
268  return event->event == RDMA_CM_EVENT_CONNECT_REQUEST;
269 
270  mutex_lock(&ctx->file->mut);
271  uevent->cm_id = cm_id;
272  ucma_set_event_context(ctx, event, uevent);
273  uevent->resp.event = event->event;
274  uevent->resp.status = event->status;
275  if (cm_id->qp_type == IB_QPT_UD)
276  ucma_copy_ud_event(&uevent->resp.param.ud, &event->param.ud);
277  else
278  ucma_copy_conn_event(&uevent->resp.param.conn,
279  &event->param.conn);
280 
281  if (event->event == RDMA_CM_EVENT_CONNECT_REQUEST) {
282  if (!ctx->backlog) {
283  ret = -ENOMEM;
284  kfree(uevent);
285  goto out;
286  }
287  ctx->backlog--;
288  } else if (!ctx->uid) {
289  /*
290  * We ignore events for new connections until userspace has set
291  * their context. This can only happen if an error occurs on a
292  * new connection before the user accepts it. This is okay,
293  * since the accept will just fail later.
294  */
295  kfree(uevent);
296  goto out;
297  }
298 
299  list_add_tail(&uevent->list, &ctx->file->event_list);
300  wake_up_interruptible(&ctx->file->poll_wait);
301 out:
302  mutex_unlock(&ctx->file->mut);
303  return ret;
304 }
305 
306 static ssize_t ucma_get_event(struct ucma_file *file, const char __user *inbuf,
307  int in_len, int out_len)
308 {
309  struct ucma_context *ctx;
310  struct rdma_ucm_get_event cmd;
311  struct ucma_event *uevent;
312  int ret = 0;
313 
314  if (out_len < sizeof uevent->resp)
315  return -ENOSPC;
316 
317  if (copy_from_user(&cmd, inbuf, sizeof(cmd)))
318  return -EFAULT;
319 
320  mutex_lock(&file->mut);
321  while (list_empty(&file->event_list)) {
322  mutex_unlock(&file->mut);
323 
324  if (file->filp->f_flags & O_NONBLOCK)
325  return -EAGAIN;
326 
328  !list_empty(&file->event_list)))
329  return -ERESTARTSYS;
330 
331  mutex_lock(&file->mut);
332  }
333 
334  uevent = list_entry(file->event_list.next, struct ucma_event, list);
335 
336  if (uevent->resp.event == RDMA_CM_EVENT_CONNECT_REQUEST) {
337  ctx = ucma_alloc_ctx(file);
338  if (!ctx) {
339  ret = -ENOMEM;
340  goto done;
341  }
342  uevent->ctx->backlog++;
343  ctx->cm_id = uevent->cm_id;
344  ctx->cm_id->context = ctx;
345  uevent->resp.id = ctx->id;
346  }
347 
348  if (copy_to_user((void __user *)(unsigned long)cmd.response,
349  &uevent->resp, sizeof uevent->resp)) {
350  ret = -EFAULT;
351  goto done;
352  }
353 
354  list_del(&uevent->list);
355  uevent->ctx->events_reported++;
356  if (uevent->mc)
357  uevent->mc->events_reported++;
358  kfree(uevent);
359 done:
360  mutex_unlock(&file->mut);
361  return ret;
362 }
363 
364 static int ucma_get_qp_type(struct rdma_ucm_create_id *cmd, enum ib_qp_type *qp_type)
365 {
366  switch (cmd->ps) {
367  case RDMA_PS_TCP:
368  *qp_type = IB_QPT_RC;
369  return 0;
370  case RDMA_PS_UDP:
371  case RDMA_PS_IPOIB:
372  *qp_type = IB_QPT_UD;
373  return 0;
374  case RDMA_PS_IB:
375  *qp_type = cmd->qp_type;
376  return 0;
377  default:
378  return -EINVAL;
379  }
380 }
381 
382 static ssize_t ucma_create_id(struct ucma_file *file, const char __user *inbuf,
383  int in_len, int out_len)
384 {
385  struct rdma_ucm_create_id cmd;
386  struct rdma_ucm_create_id_resp resp;
387  struct ucma_context *ctx;
388  enum ib_qp_type qp_type;
389  int ret;
390 
391  if (out_len < sizeof(resp))
392  return -ENOSPC;
393 
394  if (copy_from_user(&cmd, inbuf, sizeof(cmd)))
395  return -EFAULT;
396 
397  ret = ucma_get_qp_type(&cmd, &qp_type);
398  if (ret)
399  return ret;
400 
401  mutex_lock(&file->mut);
402  ctx = ucma_alloc_ctx(file);
403  mutex_unlock(&file->mut);
404  if (!ctx)
405  return -ENOMEM;
406 
407  ctx->uid = cmd.uid;
408  ctx->cm_id = rdma_create_id(ucma_event_handler, ctx, cmd.ps, qp_type);
409  if (IS_ERR(ctx->cm_id)) {
410  ret = PTR_ERR(ctx->cm_id);
411  goto err1;
412  }
413 
414  resp.id = ctx->id;
415  if (copy_to_user((void __user *)(unsigned long)cmd.response,
416  &resp, sizeof(resp))) {
417  ret = -EFAULT;
418  goto err2;
419  }
420  return 0;
421 
422 err2:
423  rdma_destroy_id(ctx->cm_id);
424 err1:
425  mutex_lock(&mut);
426  idr_remove(&ctx_idr, ctx->id);
427  mutex_unlock(&mut);
428  kfree(ctx);
429  return ret;
430 }
431 
432 static void ucma_cleanup_multicast(struct ucma_context *ctx)
433 {
434  struct ucma_multicast *mc, *tmp;
435 
436  mutex_lock(&mut);
437  list_for_each_entry_safe(mc, tmp, &ctx->mc_list, list) {
438  list_del(&mc->list);
439  idr_remove(&multicast_idr, mc->id);
440  kfree(mc);
441  }
442  mutex_unlock(&mut);
443 }
444 
445 static void ucma_cleanup_mc_events(struct ucma_multicast *mc)
446 {
447  struct ucma_event *uevent, *tmp;
448 
449  list_for_each_entry_safe(uevent, tmp, &mc->ctx->file->event_list, list) {
450  if (uevent->mc != mc)
451  continue;
452 
453  list_del(&uevent->list);
454  kfree(uevent);
455  }
456 }
457 
458 /*
459  * We cannot hold file->mut when calling rdma_destroy_id() or we can
460  * deadlock. We also acquire file->mut in ucma_event_handler(), and
461  * rdma_destroy_id() will wait until all callbacks have completed.
462  */
463 static int ucma_free_ctx(struct ucma_context *ctx)
464 {
465  int events_reported;
466  struct ucma_event *uevent, *tmp;
467  LIST_HEAD(list);
468 
469  /* No new events will be generated after destroying the id. */
470  rdma_destroy_id(ctx->cm_id);
471 
472  ucma_cleanup_multicast(ctx);
473 
474  /* Cleanup events not yet reported to the user. */
475  mutex_lock(&ctx->file->mut);
476  list_for_each_entry_safe(uevent, tmp, &ctx->file->event_list, list) {
477  if (uevent->ctx == ctx)
478  list_move_tail(&uevent->list, &list);
479  }
480  list_del(&ctx->list);
481  mutex_unlock(&ctx->file->mut);
482 
483  list_for_each_entry_safe(uevent, tmp, &list, list) {
484  list_del(&uevent->list);
485  if (uevent->resp.event == RDMA_CM_EVENT_CONNECT_REQUEST)
486  rdma_destroy_id(uevent->cm_id);
487  kfree(uevent);
488  }
489 
490  events_reported = ctx->events_reported;
491  kfree(ctx);
492  return events_reported;
493 }
494 
495 static ssize_t ucma_destroy_id(struct ucma_file *file, const char __user *inbuf,
496  int in_len, int out_len)
497 {
498  struct rdma_ucm_destroy_id cmd;
499  struct rdma_ucm_destroy_id_resp resp;
500  struct ucma_context *ctx;
501  int ret = 0;
502 
503  if (out_len < sizeof(resp))
504  return -ENOSPC;
505 
506  if (copy_from_user(&cmd, inbuf, sizeof(cmd)))
507  return -EFAULT;
508 
509  mutex_lock(&mut);
510  ctx = _ucma_find_context(cmd.id, file);
511  if (!IS_ERR(ctx))
512  idr_remove(&ctx_idr, ctx->id);
513  mutex_unlock(&mut);
514 
515  if (IS_ERR(ctx))
516  return PTR_ERR(ctx);
517 
518  ucma_put_ctx(ctx);
519  wait_for_completion(&ctx->comp);
520  resp.events_reported = ucma_free_ctx(ctx);
521 
522  if (copy_to_user((void __user *)(unsigned long)cmd.response,
523  &resp, sizeof(resp)))
524  ret = -EFAULT;
525 
526  return ret;
527 }
528 
529 static ssize_t ucma_bind_addr(struct ucma_file *file, const char __user *inbuf,
530  int in_len, int out_len)
531 {
532  struct rdma_ucm_bind_addr cmd;
533  struct ucma_context *ctx;
534  int ret;
535 
536  if (copy_from_user(&cmd, inbuf, sizeof(cmd)))
537  return -EFAULT;
538 
539  ctx = ucma_get_ctx(file, cmd.id);
540  if (IS_ERR(ctx))
541  return PTR_ERR(ctx);
542 
543  ret = rdma_bind_addr(ctx->cm_id, (struct sockaddr *) &cmd.addr);
544  ucma_put_ctx(ctx);
545  return ret;
546 }
547 
548 static ssize_t ucma_resolve_addr(struct ucma_file *file,
549  const char __user *inbuf,
550  int in_len, int out_len)
551 {
552  struct rdma_ucm_resolve_addr cmd;
553  struct ucma_context *ctx;
554  int ret;
555 
556  if (copy_from_user(&cmd, inbuf, sizeof(cmd)))
557  return -EFAULT;
558 
559  ctx = ucma_get_ctx(file, cmd.id);
560  if (IS_ERR(ctx))
561  return PTR_ERR(ctx);
562 
563  ret = rdma_resolve_addr(ctx->cm_id, (struct sockaddr *) &cmd.src_addr,
564  (struct sockaddr *) &cmd.dst_addr,
565  cmd.timeout_ms);
566  ucma_put_ctx(ctx);
567  return ret;
568 }
569 
570 static ssize_t ucma_resolve_route(struct ucma_file *file,
571  const char __user *inbuf,
572  int in_len, int out_len)
573 {
574  struct rdma_ucm_resolve_route cmd;
575  struct ucma_context *ctx;
576  int ret;
577 
578  if (copy_from_user(&cmd, inbuf, sizeof(cmd)))
579  return -EFAULT;
580 
581  ctx = ucma_get_ctx(file, cmd.id);
582  if (IS_ERR(ctx))
583  return PTR_ERR(ctx);
584 
585  ret = rdma_resolve_route(ctx->cm_id, cmd.timeout_ms);
586  ucma_put_ctx(ctx);
587  return ret;
588 }
589 
590 static void ucma_copy_ib_route(struct rdma_ucm_query_route_resp *resp,
591  struct rdma_route *route)
592 {
593  struct rdma_dev_addr *dev_addr;
594 
595  resp->num_paths = route->num_paths;
596  switch (route->num_paths) {
597  case 0:
598  dev_addr = &route->addr.dev_addr;
599  rdma_addr_get_dgid(dev_addr,
600  (union ib_gid *) &resp->ib_route[0].dgid);
601  rdma_addr_get_sgid(dev_addr,
602  (union ib_gid *) &resp->ib_route[0].sgid);
603  resp->ib_route[0].pkey = cpu_to_be16(ib_addr_get_pkey(dev_addr));
604  break;
605  case 2:
607  &route->path_rec[1]);
608  /* fall through */
609  case 1:
611  &route->path_rec[0]);
612  break;
613  default:
614  break;
615  }
616 }
617 
618 static void ucma_copy_iboe_route(struct rdma_ucm_query_route_resp *resp,
619  struct rdma_route *route)
620 {
621  struct rdma_dev_addr *dev_addr;
622  struct net_device *dev;
623  u16 vid = 0;
624 
625  resp->num_paths = route->num_paths;
626  switch (route->num_paths) {
627  case 0:
628  dev_addr = &route->addr.dev_addr;
629  dev = dev_get_by_index(&init_net, dev_addr->bound_dev_if);
630  if (dev) {
631  vid = rdma_vlan_dev_vlan_id(dev);
632  dev_put(dev);
633  }
634 
635  iboe_mac_vlan_to_ll((union ib_gid *) &resp->ib_route[0].dgid,
636  dev_addr->dst_dev_addr, vid);
637  iboe_addr_get_sgid(dev_addr,
638  (union ib_gid *) &resp->ib_route[0].sgid);
639  resp->ib_route[0].pkey = cpu_to_be16(0xffff);
640  break;
641  case 2:
643  &route->path_rec[1]);
644  /* fall through */
645  case 1:
647  &route->path_rec[0]);
648  break;
649  default:
650  break;
651  }
652 }
653 
654 static void ucma_copy_iw_route(struct rdma_ucm_query_route_resp *resp,
655  struct rdma_route *route)
656 {
657  struct rdma_dev_addr *dev_addr;
658 
659  dev_addr = &route->addr.dev_addr;
660  rdma_addr_get_dgid(dev_addr, (union ib_gid *) &resp->ib_route[0].dgid);
661  rdma_addr_get_sgid(dev_addr, (union ib_gid *) &resp->ib_route[0].sgid);
662 }
663 
664 static ssize_t ucma_query_route(struct ucma_file *file,
665  const char __user *inbuf,
666  int in_len, int out_len)
667 {
668  struct rdma_ucm_query_route cmd;
669  struct rdma_ucm_query_route_resp resp;
670  struct ucma_context *ctx;
671  struct sockaddr *addr;
672  int ret = 0;
673 
674  if (out_len < sizeof(resp))
675  return -ENOSPC;
676 
677  if (copy_from_user(&cmd, inbuf, sizeof(cmd)))
678  return -EFAULT;
679 
680  ctx = ucma_get_ctx(file, cmd.id);
681  if (IS_ERR(ctx))
682  return PTR_ERR(ctx);
683 
684  memset(&resp, 0, sizeof resp);
685  addr = (struct sockaddr *) &ctx->cm_id->route.addr.src_addr;
686  memcpy(&resp.src_addr, addr, addr->sa_family == AF_INET ?
687  sizeof(struct sockaddr_in) :
688  sizeof(struct sockaddr_in6));
689  addr = (struct sockaddr *) &ctx->cm_id->route.addr.dst_addr;
690  memcpy(&resp.dst_addr, addr, addr->sa_family == AF_INET ?
691  sizeof(struct sockaddr_in) :
692  sizeof(struct sockaddr_in6));
693  if (!ctx->cm_id->device)
694  goto out;
695 
696  resp.node_guid = (__force __u64) ctx->cm_id->device->node_guid;
697  resp.port_num = ctx->cm_id->port_num;
698  switch (rdma_node_get_transport(ctx->cm_id->device->node_type)) {
699  case RDMA_TRANSPORT_IB:
700  switch (rdma_port_get_link_layer(ctx->cm_id->device,
701  ctx->cm_id->port_num)) {
703  ucma_copy_ib_route(&resp, &ctx->cm_id->route);
704  break;
706  ucma_copy_iboe_route(&resp, &ctx->cm_id->route);
707  break;
708  default:
709  break;
710  }
711  break;
713  ucma_copy_iw_route(&resp, &ctx->cm_id->route);
714  break;
715  default:
716  break;
717  }
718 
719 out:
720  if (copy_to_user((void __user *)(unsigned long)cmd.response,
721  &resp, sizeof(resp)))
722  ret = -EFAULT;
723 
724  ucma_put_ctx(ctx);
725  return ret;
726 }
727 
728 static void ucma_copy_conn_param(struct rdma_conn_param *dst,
729  struct rdma_ucm_conn_param *src)
730 {
731  dst->private_data = src->private_data;
734  dst->initiator_depth = src->initiator_depth;
735  dst->flow_control = src->flow_control;
736  dst->retry_count = src->retry_count;
737  dst->rnr_retry_count = src->rnr_retry_count;
738  dst->srq = src->srq;
739  dst->qp_num = src->qp_num;
740 }
741 
742 static ssize_t ucma_connect(struct ucma_file *file, const char __user *inbuf,
743  int in_len, int out_len)
744 {
745  struct rdma_ucm_connect cmd;
746  struct rdma_conn_param conn_param;
747  struct ucma_context *ctx;
748  int ret;
749 
750  if (copy_from_user(&cmd, inbuf, sizeof(cmd)))
751  return -EFAULT;
752 
753  if (!cmd.conn_param.valid)
754  return -EINVAL;
755 
756  ctx = ucma_get_ctx(file, cmd.id);
757  if (IS_ERR(ctx))
758  return PTR_ERR(ctx);
759 
760  ucma_copy_conn_param(&conn_param, &cmd.conn_param);
761  ret = rdma_connect(ctx->cm_id, &conn_param);
762  ucma_put_ctx(ctx);
763  return ret;
764 }
765 
766 static ssize_t ucma_listen(struct ucma_file *file, const char __user *inbuf,
767  int in_len, int out_len)
768 {
769  struct rdma_ucm_listen cmd;
770  struct ucma_context *ctx;
771  int ret;
772 
773  if (copy_from_user(&cmd, inbuf, sizeof(cmd)))
774  return -EFAULT;
775 
776  ctx = ucma_get_ctx(file, cmd.id);
777  if (IS_ERR(ctx))
778  return PTR_ERR(ctx);
779 
780  ctx->backlog = cmd.backlog > 0 && cmd.backlog < max_backlog ?
781  cmd.backlog : max_backlog;
782  ret = rdma_listen(ctx->cm_id, ctx->backlog);
783  ucma_put_ctx(ctx);
784  return ret;
785 }
786 
787 static ssize_t ucma_accept(struct ucma_file *file, const char __user *inbuf,
788  int in_len, int out_len)
789 {
790  struct rdma_ucm_accept cmd;
791  struct rdma_conn_param conn_param;
792  struct ucma_context *ctx;
793  int ret;
794 
795  if (copy_from_user(&cmd, inbuf, sizeof(cmd)))
796  return -EFAULT;
797 
798  ctx = ucma_get_ctx(file, cmd.id);
799  if (IS_ERR(ctx))
800  return PTR_ERR(ctx);
801 
802  if (cmd.conn_param.valid) {
803  ucma_copy_conn_param(&conn_param, &cmd.conn_param);
804  mutex_lock(&file->mut);
805  ret = rdma_accept(ctx->cm_id, &conn_param);
806  if (!ret)
807  ctx->uid = cmd.uid;
808  mutex_unlock(&file->mut);
809  } else
810  ret = rdma_accept(ctx->cm_id, NULL);
811 
812  ucma_put_ctx(ctx);
813  return ret;
814 }
815 
816 static ssize_t ucma_reject(struct ucma_file *file, const char __user *inbuf,
817  int in_len, int out_len)
818 {
819  struct rdma_ucm_reject cmd;
820  struct ucma_context *ctx;
821  int ret;
822 
823  if (copy_from_user(&cmd, inbuf, sizeof(cmd)))
824  return -EFAULT;
825 
826  ctx = ucma_get_ctx(file, cmd.id);
827  if (IS_ERR(ctx))
828  return PTR_ERR(ctx);
829 
830  ret = rdma_reject(ctx->cm_id, cmd.private_data, cmd.private_data_len);
831  ucma_put_ctx(ctx);
832  return ret;
833 }
834 
835 static ssize_t ucma_disconnect(struct ucma_file *file, const char __user *inbuf,
836  int in_len, int out_len)
837 {
838  struct rdma_ucm_disconnect cmd;
839  struct ucma_context *ctx;
840  int ret;
841 
842  if (copy_from_user(&cmd, inbuf, sizeof(cmd)))
843  return -EFAULT;
844 
845  ctx = ucma_get_ctx(file, cmd.id);
846  if (IS_ERR(ctx))
847  return PTR_ERR(ctx);
848 
849  ret = rdma_disconnect(ctx->cm_id);
850  ucma_put_ctx(ctx);
851  return ret;
852 }
853 
854 static ssize_t ucma_init_qp_attr(struct ucma_file *file,
855  const char __user *inbuf,
856  int in_len, int out_len)
857 {
858  struct rdma_ucm_init_qp_attr cmd;
859  struct ib_uverbs_qp_attr resp;
860  struct ucma_context *ctx;
861  struct ib_qp_attr qp_attr;
862  int ret;
863 
864  if (out_len < sizeof(resp))
865  return -ENOSPC;
866 
867  if (copy_from_user(&cmd, inbuf, sizeof(cmd)))
868  return -EFAULT;
869 
870  ctx = ucma_get_ctx(file, cmd.id);
871  if (IS_ERR(ctx))
872  return PTR_ERR(ctx);
873 
874  resp.qp_attr_mask = 0;
875  memset(&qp_attr, 0, sizeof qp_attr);
876  qp_attr.qp_state = cmd.qp_state;
877  ret = rdma_init_qp_attr(ctx->cm_id, &qp_attr, &resp.qp_attr_mask);
878  if (ret)
879  goto out;
880 
881  ib_copy_qp_attr_to_user(&resp, &qp_attr);
882  if (copy_to_user((void __user *)(unsigned long)cmd.response,
883  &resp, sizeof(resp)))
884  ret = -EFAULT;
885 
886 out:
887  ucma_put_ctx(ctx);
888  return ret;
889 }
890 
891 static int ucma_set_option_id(struct ucma_context *ctx, int optname,
892  void *optval, size_t optlen)
893 {
894  int ret = 0;
895 
896  switch (optname) {
897  case RDMA_OPTION_ID_TOS:
898  if (optlen != sizeof(u8)) {
899  ret = -EINVAL;
900  break;
901  }
902  rdma_set_service_type(ctx->cm_id, *((u8 *) optval));
903  break;
905  if (optlen != sizeof(int)) {
906  ret = -EINVAL;
907  break;
908  }
909  ret = rdma_set_reuseaddr(ctx->cm_id, *((int *) optval) ? 1 : 0);
910  break;
912  if (optlen != sizeof(int)) {
913  ret = -EINVAL;
914  break;
915  }
916  ret = rdma_set_afonly(ctx->cm_id, *((int *) optval) ? 1 : 0);
917  break;
918  default:
919  ret = -ENOSYS;
920  }
921 
922  return ret;
923 }
924 
925 static int ucma_set_ib_path(struct ucma_context *ctx,
926  struct ib_path_rec_data *path_data, size_t optlen)
927 {
928  struct ib_sa_path_rec sa_path;
929  struct rdma_cm_event event;
930  int ret;
931 
932  if (optlen % sizeof(*path_data))
933  return -EINVAL;
934 
935  for (; optlen; optlen -= sizeof(*path_data), path_data++) {
936  if (path_data->flags == (IB_PATH_GMP | IB_PATH_PRIMARY |
938  break;
939  }
940 
941  if (!optlen)
942  return -EINVAL;
943 
944  ib_sa_unpack_path(path_data->path_rec, &sa_path);
945  ret = rdma_set_ib_paths(ctx->cm_id, &sa_path, 1);
946  if (ret)
947  return ret;
948 
949  memset(&event, 0, sizeof event);
950  event.event = RDMA_CM_EVENT_ROUTE_RESOLVED;
951  return ucma_event_handler(ctx->cm_id, &event);
952 }
953 
954 static int ucma_set_option_ib(struct ucma_context *ctx, int optname,
955  void *optval, size_t optlen)
956 {
957  int ret;
958 
959  switch (optname) {
960  case RDMA_OPTION_IB_PATH:
961  ret = ucma_set_ib_path(ctx, optval, optlen);
962  break;
963  default:
964  ret = -ENOSYS;
965  }
966 
967  return ret;
968 }
969 
970 static int ucma_set_option_level(struct ucma_context *ctx, int level,
971  int optname, void *optval, size_t optlen)
972 {
973  int ret;
974 
975  switch (level) {
976  case RDMA_OPTION_ID:
977  ret = ucma_set_option_id(ctx, optname, optval, optlen);
978  break;
979  case RDMA_OPTION_IB:
980  ret = ucma_set_option_ib(ctx, optname, optval, optlen);
981  break;
982  default:
983  ret = -ENOSYS;
984  }
985 
986  return ret;
987 }
988 
989 static ssize_t ucma_set_option(struct ucma_file *file, const char __user *inbuf,
990  int in_len, int out_len)
991 {
992  struct rdma_ucm_set_option cmd;
993  struct ucma_context *ctx;
994  void *optval;
995  int ret;
996 
997  if (copy_from_user(&cmd, inbuf, sizeof(cmd)))
998  return -EFAULT;
999 
1000  ctx = ucma_get_ctx(file, cmd.id);
1001  if (IS_ERR(ctx))
1002  return PTR_ERR(ctx);
1003 
1004  optval = memdup_user((void __user *) (unsigned long) cmd.optval,
1005  cmd.optlen);
1006  if (IS_ERR(optval)) {
1007  ret = PTR_ERR(optval);
1008  goto out;
1009  }
1010 
1011  ret = ucma_set_option_level(ctx, cmd.level, cmd.optname, optval,
1012  cmd.optlen);
1013  kfree(optval);
1014 
1015 out:
1016  ucma_put_ctx(ctx);
1017  return ret;
1018 }
1019 
1020 static ssize_t ucma_notify(struct ucma_file *file, const char __user *inbuf,
1021  int in_len, int out_len)
1022 {
1023  struct rdma_ucm_notify cmd;
1024  struct ucma_context *ctx;
1025  int ret;
1026 
1027  if (copy_from_user(&cmd, inbuf, sizeof(cmd)))
1028  return -EFAULT;
1029 
1030  ctx = ucma_get_ctx(file, cmd.id);
1031  if (IS_ERR(ctx))
1032  return PTR_ERR(ctx);
1033 
1034  ret = rdma_notify(ctx->cm_id, (enum ib_event_type) cmd.event);
1035  ucma_put_ctx(ctx);
1036  return ret;
1037 }
1038 
1039 static ssize_t ucma_join_multicast(struct ucma_file *file,
1040  const char __user *inbuf,
1041  int in_len, int out_len)
1042 {
1043  struct rdma_ucm_join_mcast cmd;
1044  struct rdma_ucm_create_id_resp resp;
1045  struct ucma_context *ctx;
1046  struct ucma_multicast *mc;
1047  int ret;
1048 
1049  if (out_len < sizeof(resp))
1050  return -ENOSPC;
1051 
1052  if (copy_from_user(&cmd, inbuf, sizeof(cmd)))
1053  return -EFAULT;
1054 
1055  ctx = ucma_get_ctx(file, cmd.id);
1056  if (IS_ERR(ctx))
1057  return PTR_ERR(ctx);
1058 
1059  mutex_lock(&file->mut);
1060  mc = ucma_alloc_multicast(ctx);
1061  if (!mc) {
1062  ret = -ENOMEM;
1063  goto err1;
1064  }
1065 
1066  mc->uid = cmd.uid;
1067  memcpy(&mc->addr, &cmd.addr, sizeof cmd.addr);
1068  ret = rdma_join_multicast(ctx->cm_id, (struct sockaddr *) &mc->addr, mc);
1069  if (ret)
1070  goto err2;
1071 
1072  resp.id = mc->id;
1073  if (copy_to_user((void __user *)(unsigned long)cmd.response,
1074  &resp, sizeof(resp))) {
1075  ret = -EFAULT;
1076  goto err3;
1077  }
1078 
1079  mutex_unlock(&file->mut);
1080  ucma_put_ctx(ctx);
1081  return 0;
1082 
1083 err3:
1084  rdma_leave_multicast(ctx->cm_id, (struct sockaddr *) &mc->addr);
1085  ucma_cleanup_mc_events(mc);
1086 err2:
1087  mutex_lock(&mut);
1088  idr_remove(&multicast_idr, mc->id);
1089  mutex_unlock(&mut);
1090  list_del(&mc->list);
1091  kfree(mc);
1092 err1:
1093  mutex_unlock(&file->mut);
1094  ucma_put_ctx(ctx);
1095  return ret;
1096 }
1097 
1098 static ssize_t ucma_leave_multicast(struct ucma_file *file,
1099  const char __user *inbuf,
1100  int in_len, int out_len)
1101 {
1102  struct rdma_ucm_destroy_id cmd;
1103  struct rdma_ucm_destroy_id_resp resp;
1104  struct ucma_multicast *mc;
1105  int ret = 0;
1106 
1107  if (out_len < sizeof(resp))
1108  return -ENOSPC;
1109 
1110  if (copy_from_user(&cmd, inbuf, sizeof(cmd)))
1111  return -EFAULT;
1112 
1113  mutex_lock(&mut);
1114  mc = idr_find(&multicast_idr, cmd.id);
1115  if (!mc)
1116  mc = ERR_PTR(-ENOENT);
1117  else if (mc->ctx->file != file)
1118  mc = ERR_PTR(-EINVAL);
1119  else {
1120  idr_remove(&multicast_idr, mc->id);
1121  atomic_inc(&mc->ctx->ref);
1122  }
1123  mutex_unlock(&mut);
1124 
1125  if (IS_ERR(mc)) {
1126  ret = PTR_ERR(mc);
1127  goto out;
1128  }
1129 
1130  rdma_leave_multicast(mc->ctx->cm_id, (struct sockaddr *) &mc->addr);
1131  mutex_lock(&mc->ctx->file->mut);
1132  ucma_cleanup_mc_events(mc);
1133  list_del(&mc->list);
1134  mutex_unlock(&mc->ctx->file->mut);
1135 
1136  ucma_put_ctx(mc->ctx);
1137  resp.events_reported = mc->events_reported;
1138  kfree(mc);
1139 
1140  if (copy_to_user((void __user *)(unsigned long)cmd.response,
1141  &resp, sizeof(resp)))
1142  ret = -EFAULT;
1143 out:
1144  return ret;
1145 }
1146 
1147 static void ucma_lock_files(struct ucma_file *file1, struct ucma_file *file2)
1148 {
1149  /* Acquire mutex's based on pointer comparison to prevent deadlock. */
1150  if (file1 < file2) {
1151  mutex_lock(&file1->mut);
1152  mutex_lock(&file2->mut);
1153  } else {
1154  mutex_lock(&file2->mut);
1155  mutex_lock(&file1->mut);
1156  }
1157 }
1158 
1159 static void ucma_unlock_files(struct ucma_file *file1, struct ucma_file *file2)
1160 {
1161  if (file1 < file2) {
1162  mutex_unlock(&file2->mut);
1163  mutex_unlock(&file1->mut);
1164  } else {
1165  mutex_unlock(&file1->mut);
1166  mutex_unlock(&file2->mut);
1167  }
1168 }
1169 
1170 static void ucma_move_events(struct ucma_context *ctx, struct ucma_file *file)
1171 {
1172  struct ucma_event *uevent, *tmp;
1173 
1174  list_for_each_entry_safe(uevent, tmp, &ctx->file->event_list, list)
1175  if (uevent->ctx == ctx)
1176  list_move_tail(&uevent->list, &file->event_list);
1177 }
1178 
1179 static ssize_t ucma_migrate_id(struct ucma_file *new_file,
1180  const char __user *inbuf,
1181  int in_len, int out_len)
1182 {
1183  struct rdma_ucm_migrate_id cmd;
1184  struct rdma_ucm_migrate_resp resp;
1185  struct ucma_context *ctx;
1186  struct fd f;
1187  struct ucma_file *cur_file;
1188  int ret = 0;
1189 
1190  if (copy_from_user(&cmd, inbuf, sizeof(cmd)))
1191  return -EFAULT;
1192 
1193  /* Get current fd to protect against it being closed */
1194  f = fdget(cmd.fd);
1195  if (!f.file)
1196  return -ENOENT;
1197 
1198  /* Validate current fd and prevent destruction of id. */
1199  ctx = ucma_get_ctx(f.file->private_data, cmd.id);
1200  if (IS_ERR(ctx)) {
1201  ret = PTR_ERR(ctx);
1202  goto file_put;
1203  }
1204 
1205  cur_file = ctx->file;
1206  if (cur_file == new_file) {
1207  resp.events_reported = ctx->events_reported;
1208  goto response;
1209  }
1210 
1211  /*
1212  * Migrate events between fd's, maintaining order, and avoiding new
1213  * events being added before existing events.
1214  */
1215  ucma_lock_files(cur_file, new_file);
1216  mutex_lock(&mut);
1217 
1218  list_move_tail(&ctx->list, &new_file->ctx_list);
1219  ucma_move_events(ctx, new_file);
1220  ctx->file = new_file;
1221  resp.events_reported = ctx->events_reported;
1222 
1223  mutex_unlock(&mut);
1224  ucma_unlock_files(cur_file, new_file);
1225 
1226 response:
1227  if (copy_to_user((void __user *)(unsigned long)cmd.response,
1228  &resp, sizeof(resp)))
1229  ret = -EFAULT;
1230 
1231  ucma_put_ctx(ctx);
1232 file_put:
1233  fdput(f);
1234  return ret;
1235 }
1236 
1237 static ssize_t (*ucma_cmd_table[])(struct ucma_file *file,
1238  const char __user *inbuf,
1239  int in_len, int out_len) = {
1240  [RDMA_USER_CM_CMD_CREATE_ID] = ucma_create_id,
1241  [RDMA_USER_CM_CMD_DESTROY_ID] = ucma_destroy_id,
1242  [RDMA_USER_CM_CMD_BIND_ADDR] = ucma_bind_addr,
1243  [RDMA_USER_CM_CMD_RESOLVE_ADDR] = ucma_resolve_addr,
1244  [RDMA_USER_CM_CMD_RESOLVE_ROUTE]= ucma_resolve_route,
1245  [RDMA_USER_CM_CMD_QUERY_ROUTE] = ucma_query_route,
1246  [RDMA_USER_CM_CMD_CONNECT] = ucma_connect,
1247  [RDMA_USER_CM_CMD_LISTEN] = ucma_listen,
1248  [RDMA_USER_CM_CMD_ACCEPT] = ucma_accept,
1249  [RDMA_USER_CM_CMD_REJECT] = ucma_reject,
1250  [RDMA_USER_CM_CMD_DISCONNECT] = ucma_disconnect,
1251  [RDMA_USER_CM_CMD_INIT_QP_ATTR] = ucma_init_qp_attr,
1252  [RDMA_USER_CM_CMD_GET_EVENT] = ucma_get_event,
1254  [RDMA_USER_CM_CMD_SET_OPTION] = ucma_set_option,
1255  [RDMA_USER_CM_CMD_NOTIFY] = ucma_notify,
1256  [RDMA_USER_CM_CMD_JOIN_MCAST] = ucma_join_multicast,
1257  [RDMA_USER_CM_CMD_LEAVE_MCAST] = ucma_leave_multicast,
1258  [RDMA_USER_CM_CMD_MIGRATE_ID] = ucma_migrate_id
1259 };
1260 
1261 static ssize_t ucma_write(struct file *filp, const char __user *buf,
1262  size_t len, loff_t *pos)
1263 {
1264  struct ucma_file *file = filp->private_data;
1265  struct rdma_ucm_cmd_hdr hdr;
1266  ssize_t ret;
1267 
1268  if (len < sizeof(hdr))
1269  return -EINVAL;
1270 
1271  if (copy_from_user(&hdr, buf, sizeof(hdr)))
1272  return -EFAULT;
1273 
1274  if (hdr.cmd >= ARRAY_SIZE(ucma_cmd_table))
1275  return -EINVAL;
1276 
1277  if (hdr.in + sizeof(hdr) > len)
1278  return -EINVAL;
1279 
1280  if (!ucma_cmd_table[hdr.cmd])
1281  return -ENOSYS;
1282 
1283  ret = ucma_cmd_table[hdr.cmd](file, buf + sizeof(hdr), hdr.in, hdr.out);
1284  if (!ret)
1285  ret = len;
1286 
1287  return ret;
1288 }
1289 
1290 static unsigned int ucma_poll(struct file *filp, struct poll_table_struct *wait)
1291 {
1292  struct ucma_file *file = filp->private_data;
1293  unsigned int mask = 0;
1294 
1295  poll_wait(filp, &file->poll_wait, wait);
1296 
1297  if (!list_empty(&file->event_list))
1298  mask = POLLIN | POLLRDNORM;
1299 
1300  return mask;
1301 }
1302 
1303 /*
1304  * ucma_open() does not need the BKL:
1305  *
1306  * - no global state is referred to;
1307  * - there is no ioctl method to race against;
1308  * - no further module initialization is required for open to work
1309  * after the device is registered.
1310  */
1311 static int ucma_open(struct inode *inode, struct file *filp)
1312 {
1313  struct ucma_file *file;
1314 
1315  file = kmalloc(sizeof *file, GFP_KERNEL);
1316  if (!file)
1317  return -ENOMEM;
1318 
1319  INIT_LIST_HEAD(&file->event_list);
1320  INIT_LIST_HEAD(&file->ctx_list);
1322  mutex_init(&file->mut);
1323 
1324  filp->private_data = file;
1325  file->filp = filp;
1326 
1327  return nonseekable_open(inode, filp);
1328 }
1329 
1330 static int ucma_close(struct inode *inode, struct file *filp)
1331 {
1332  struct ucma_file *file = filp->private_data;
1333  struct ucma_context *ctx, *tmp;
1334 
1335  mutex_lock(&file->mut);
1336  list_for_each_entry_safe(ctx, tmp, &file->ctx_list, list) {
1337  mutex_unlock(&file->mut);
1338 
1339  mutex_lock(&mut);
1340  idr_remove(&ctx_idr, ctx->id);
1341  mutex_unlock(&mut);
1342 
1343  ucma_free_ctx(ctx);
1344  mutex_lock(&file->mut);
1345  }
1346  mutex_unlock(&file->mut);
1347  kfree(file);
1348  return 0;
1349 }
1350 
1351 static const struct file_operations ucma_fops = {
1352  .owner = THIS_MODULE,
1353  .open = ucma_open,
1354  .release = ucma_close,
1355  .write = ucma_write,
1356  .poll = ucma_poll,
1357  .llseek = no_llseek,
1358 };
1359 
1360 static struct miscdevice ucma_misc = {
1361  .minor = MISC_DYNAMIC_MINOR,
1362  .name = "rdma_cm",
1363  .nodename = "infiniband/rdma_cm",
1364  .mode = 0666,
1365  .fops = &ucma_fops,
1366 };
1367 
1368 static ssize_t show_abi_version(struct device *dev,
1369  struct device_attribute *attr,
1370  char *buf)
1371 {
1372  return sprintf(buf, "%d\n", RDMA_USER_CM_ABI_VERSION);
1373 }
1374 static DEVICE_ATTR(abi_version, S_IRUGO, show_abi_version, NULL);
1375 
1376 static int __init ucma_init(void)
1377 {
1378  int ret;
1379 
1380  ret = misc_register(&ucma_misc);
1381  if (ret)
1382  return ret;
1383 
1384  ret = device_create_file(ucma_misc.this_device, &dev_attr_abi_version);
1385  if (ret) {
1386  printk(KERN_ERR "rdma_ucm: couldn't create abi_version attr\n");
1387  goto err1;
1388  }
1389 
1390  ucma_ctl_table_hdr = register_net_sysctl(&init_net, "net/rdma_ucm", ucma_ctl_table);
1391  if (!ucma_ctl_table_hdr) {
1392  printk(KERN_ERR "rdma_ucm: couldn't register sysctl paths\n");
1393  ret = -ENOMEM;
1394  goto err2;
1395  }
1396  return 0;
1397 err2:
1398  device_remove_file(ucma_misc.this_device, &dev_attr_abi_version);
1399 err1:
1400  misc_deregister(&ucma_misc);
1401  return ret;
1402 }
1403 
1404 static void __exit ucma_cleanup(void)
1405 {
1406  unregister_net_sysctl_table(ucma_ctl_table_hdr);
1407  device_remove_file(ucma_misc.this_device, &dev_attr_abi_version);
1408  misc_deregister(&ucma_misc);
1409  idr_destroy(&ctx_idr);
1410 }
1411 
1412 module_init(ucma_init);
1413 module_exit(ucma_cleanup);