Merge branch 'cell-merge' of git://git.kernel.org/pub/scm/linux/kernel/git/arnd/cell...
[linux-2.6] / 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/mutex.h>
35 #include <linux/poll.h>
36 #include <linux/idr.h>
37 #include <linux/in.h>
38 #include <linux/in6.h>
39 #include <linux/miscdevice.h>
40
41 #include <rdma/rdma_user_cm.h>
42 #include <rdma/ib_marshall.h>
43 #include <rdma/rdma_cm.h>
44
45 MODULE_AUTHOR("Sean Hefty");
46 MODULE_DESCRIPTION("RDMA Userspace Connection Manager Access");
47 MODULE_LICENSE("Dual BSD/GPL");
48
49 enum {
50         UCMA_MAX_BACKLOG        = 128
51 };
52
53 struct ucma_file {
54         struct mutex            mut;
55         struct file             *filp;
56         struct list_head        ctx_list;
57         struct list_head        event_list;
58         wait_queue_head_t       poll_wait;
59 };
60
61 struct ucma_context {
62         int                     id;
63         struct completion       comp;
64         atomic_t                ref;
65         int                     events_reported;
66         int                     backlog;
67
68         struct ucma_file        *file;
69         struct rdma_cm_id       *cm_id;
70         u64                     uid;
71
72         struct list_head        list;
73         struct list_head        mc_list;
74 };
75
76 struct ucma_multicast {
77         struct ucma_context     *ctx;
78         int                     id;
79         int                     events_reported;
80
81         u64                     uid;
82         struct list_head        list;
83         struct sockaddr         addr;
84         u8                      pad[sizeof(struct sockaddr_in6) -
85                                     sizeof(struct sockaddr)];
86 };
87
88 struct ucma_event {
89         struct ucma_context     *ctx;
90         struct ucma_multicast   *mc;
91         struct list_head        list;
92         struct rdma_cm_id       *cm_id;
93         struct rdma_ucm_event_resp resp;
94 };
95
96 static DEFINE_MUTEX(mut);
97 static DEFINE_IDR(ctx_idr);
98 static DEFINE_IDR(multicast_idr);
99
100 static inline struct ucma_context *_ucma_find_context(int id,
101                                                       struct ucma_file *file)
102 {
103         struct ucma_context *ctx;
104
105         ctx = idr_find(&ctx_idr, id);
106         if (!ctx)
107                 ctx = ERR_PTR(-ENOENT);
108         else if (ctx->file != file)
109                 ctx = ERR_PTR(-EINVAL);
110         return ctx;
111 }
112
113 static struct ucma_context *ucma_get_ctx(struct ucma_file *file, int id)
114 {
115         struct ucma_context *ctx;
116
117         mutex_lock(&mut);
118         ctx = _ucma_find_context(id, file);
119         if (!IS_ERR(ctx))
120                 atomic_inc(&ctx->ref);
121         mutex_unlock(&mut);
122         return ctx;
123 }
124
125 static void ucma_put_ctx(struct ucma_context *ctx)
126 {
127         if (atomic_dec_and_test(&ctx->ref))
128                 complete(&ctx->comp);
129 }
130
131 static struct ucma_context *ucma_alloc_ctx(struct ucma_file *file)
132 {
133         struct ucma_context *ctx;
134         int ret;
135
136         ctx = kzalloc(sizeof(*ctx), GFP_KERNEL);
137         if (!ctx)
138                 return NULL;
139
140         atomic_set(&ctx->ref, 1);
141         init_completion(&ctx->comp);
142         INIT_LIST_HEAD(&ctx->mc_list);
143         ctx->file = file;
144
145         do {
146                 ret = idr_pre_get(&ctx_idr, GFP_KERNEL);
147                 if (!ret)
148                         goto error;
149
150                 mutex_lock(&mut);
151                 ret = idr_get_new(&ctx_idr, ctx, &ctx->id);
152                 mutex_unlock(&mut);
153         } while (ret == -EAGAIN);
154
155         if (ret)
156                 goto error;
157
158         list_add_tail(&ctx->list, &file->ctx_list);
159         return ctx;
160
161 error:
162         kfree(ctx);
163         return NULL;
164 }
165
166 static struct ucma_multicast* ucma_alloc_multicast(struct ucma_context *ctx)
167 {
168         struct ucma_multicast *mc;
169         int ret;
170
171         mc = kzalloc(sizeof(*mc), GFP_KERNEL);
172         if (!mc)
173                 return NULL;
174
175         do {
176                 ret = idr_pre_get(&multicast_idr, GFP_KERNEL);
177                 if (!ret)
178                         goto error;
179
180                 mutex_lock(&mut);
181                 ret = idr_get_new(&multicast_idr, mc, &mc->id);
182                 mutex_unlock(&mut);
183         } while (ret == -EAGAIN);
184
185         if (ret)
186                 goto error;
187
188         mc->ctx = ctx;
189         list_add_tail(&mc->list, &ctx->mc_list);
190         return mc;
191
192 error:
193         kfree(mc);
194         return NULL;
195 }
196
197 static void ucma_copy_conn_event(struct rdma_ucm_conn_param *dst,
198                                  struct rdma_conn_param *src)
199 {
200         if (src->private_data_len)
201                 memcpy(dst->private_data, src->private_data,
202                        src->private_data_len);
203         dst->private_data_len = src->private_data_len;
204         dst->responder_resources =src->responder_resources;
205         dst->initiator_depth = src->initiator_depth;
206         dst->flow_control = src->flow_control;
207         dst->retry_count = src->retry_count;
208         dst->rnr_retry_count = src->rnr_retry_count;
209         dst->srq = src->srq;
210         dst->qp_num = src->qp_num;
211 }
212
213 static void ucma_copy_ud_event(struct rdma_ucm_ud_param *dst,
214                                struct rdma_ud_param *src)
215 {
216         if (src->private_data_len)
217                 memcpy(dst->private_data, src->private_data,
218                        src->private_data_len);
219         dst->private_data_len = src->private_data_len;
220         ib_copy_ah_attr_to_user(&dst->ah_attr, &src->ah_attr);
221         dst->qp_num = src->qp_num;
222         dst->qkey = src->qkey;
223 }
224
225 static void ucma_set_event_context(struct ucma_context *ctx,
226                                    struct rdma_cm_event *event,
227                                    struct ucma_event *uevent)
228 {
229         uevent->ctx = ctx;
230         switch (event->event) {
231         case RDMA_CM_EVENT_MULTICAST_JOIN:
232         case RDMA_CM_EVENT_MULTICAST_ERROR:
233                 uevent->mc = (struct ucma_multicast *)
234                              event->param.ud.private_data;
235                 uevent->resp.uid = uevent->mc->uid;
236                 uevent->resp.id = uevent->mc->id;
237                 break;
238         default:
239                 uevent->resp.uid = ctx->uid;
240                 uevent->resp.id = ctx->id;
241                 break;
242         }
243 }
244
245 static int ucma_event_handler(struct rdma_cm_id *cm_id,
246                               struct rdma_cm_event *event)
247 {
248         struct ucma_event *uevent;
249         struct ucma_context *ctx = cm_id->context;
250         int ret = 0;
251
252         uevent = kzalloc(sizeof(*uevent), GFP_KERNEL);
253         if (!uevent)
254                 return event->event == RDMA_CM_EVENT_CONNECT_REQUEST;
255
256         uevent->cm_id = cm_id;
257         ucma_set_event_context(ctx, event, uevent);
258         uevent->resp.event = event->event;
259         uevent->resp.status = event->status;
260         if (cm_id->ps == RDMA_PS_UDP || cm_id->ps == RDMA_PS_IPOIB)
261                 ucma_copy_ud_event(&uevent->resp.param.ud, &event->param.ud);
262         else
263                 ucma_copy_conn_event(&uevent->resp.param.conn,
264                                      &event->param.conn);
265
266         mutex_lock(&ctx->file->mut);
267         if (event->event == RDMA_CM_EVENT_CONNECT_REQUEST) {
268                 if (!ctx->backlog) {
269                         ret = -ENOMEM;
270                         kfree(uevent);
271                         goto out;
272                 }
273                 ctx->backlog--;
274         } else if (!ctx->uid) {
275                 /*
276                  * We ignore events for new connections until userspace has set
277                  * their context.  This can only happen if an error occurs on a
278                  * new connection before the user accepts it.  This is okay,
279                  * since the accept will just fail later.
280                  */
281                 kfree(uevent);
282                 goto out;
283         }
284
285         list_add_tail(&uevent->list, &ctx->file->event_list);
286         wake_up_interruptible(&ctx->file->poll_wait);
287 out:
288         mutex_unlock(&ctx->file->mut);
289         return ret;
290 }
291
292 static ssize_t ucma_get_event(struct ucma_file *file, const char __user *inbuf,
293                               int in_len, int out_len)
294 {
295         struct ucma_context *ctx;
296         struct rdma_ucm_get_event cmd;
297         struct ucma_event *uevent;
298         int ret = 0;
299         DEFINE_WAIT(wait);
300
301         if (out_len < sizeof uevent->resp)
302                 return -ENOSPC;
303
304         if (copy_from_user(&cmd, inbuf, sizeof(cmd)))
305                 return -EFAULT;
306
307         mutex_lock(&file->mut);
308         while (list_empty(&file->event_list)) {
309                 if (file->filp->f_flags & O_NONBLOCK) {
310                         ret = -EAGAIN;
311                         break;
312                 }
313
314                 if (signal_pending(current)) {
315                         ret = -ERESTARTSYS;
316                         break;
317                 }
318
319                 prepare_to_wait(&file->poll_wait, &wait, TASK_INTERRUPTIBLE);
320                 mutex_unlock(&file->mut);
321                 schedule();
322                 mutex_lock(&file->mut);
323                 finish_wait(&file->poll_wait, &wait);
324         }
325
326         if (ret)
327                 goto done;
328
329         uevent = list_entry(file->event_list.next, struct ucma_event, list);
330
331         if (uevent->resp.event == RDMA_CM_EVENT_CONNECT_REQUEST) {
332                 ctx = ucma_alloc_ctx(file);
333                 if (!ctx) {
334                         ret = -ENOMEM;
335                         goto done;
336                 }
337                 uevent->ctx->backlog++;
338                 ctx->cm_id = uevent->cm_id;
339                 ctx->cm_id->context = ctx;
340                 uevent->resp.id = ctx->id;
341         }
342
343         if (copy_to_user((void __user *)(unsigned long)cmd.response,
344                          &uevent->resp, sizeof uevent->resp)) {
345                 ret = -EFAULT;
346                 goto done;
347         }
348
349         list_del(&uevent->list);
350         uevent->ctx->events_reported++;
351         if (uevent->mc)
352                 uevent->mc->events_reported++;
353         kfree(uevent);
354 done:
355         mutex_unlock(&file->mut);
356         return ret;
357 }
358
359 static ssize_t ucma_create_id(struct ucma_file *file,
360                                 const char __user *inbuf,
361                                 int in_len, int out_len)
362 {
363         struct rdma_ucm_create_id cmd;
364         struct rdma_ucm_create_id_resp resp;
365         struct ucma_context *ctx;
366         int ret;
367
368         if (out_len < sizeof(resp))
369                 return -ENOSPC;
370
371         if (copy_from_user(&cmd, inbuf, sizeof(cmd)))
372                 return -EFAULT;
373
374         mutex_lock(&file->mut);
375         ctx = ucma_alloc_ctx(file);
376         mutex_unlock(&file->mut);
377         if (!ctx)
378                 return -ENOMEM;
379
380         ctx->uid = cmd.uid;
381         ctx->cm_id = rdma_create_id(ucma_event_handler, ctx, cmd.ps);
382         if (IS_ERR(ctx->cm_id)) {
383                 ret = PTR_ERR(ctx->cm_id);
384                 goto err1;
385         }
386
387         resp.id = ctx->id;
388         if (copy_to_user((void __user *)(unsigned long)cmd.response,
389                          &resp, sizeof(resp))) {
390                 ret = -EFAULT;
391                 goto err2;
392         }
393         return 0;
394
395 err2:
396         rdma_destroy_id(ctx->cm_id);
397 err1:
398         mutex_lock(&mut);
399         idr_remove(&ctx_idr, ctx->id);
400         mutex_unlock(&mut);
401         kfree(ctx);
402         return ret;
403 }
404
405 static void ucma_cleanup_multicast(struct ucma_context *ctx)
406 {
407         struct ucma_multicast *mc, *tmp;
408
409         mutex_lock(&mut);
410         list_for_each_entry_safe(mc, tmp, &ctx->mc_list, list) {
411                 list_del(&mc->list);
412                 idr_remove(&multicast_idr, mc->id);
413                 kfree(mc);
414         }
415         mutex_unlock(&mut);
416 }
417
418 static void ucma_cleanup_events(struct ucma_context *ctx)
419 {
420         struct ucma_event *uevent, *tmp;
421
422         list_for_each_entry_safe(uevent, tmp, &ctx->file->event_list, list) {
423                 if (uevent->ctx != ctx)
424                         continue;
425
426                 list_del(&uevent->list);
427
428                 /* clear incoming connections. */
429                 if (uevent->resp.event == RDMA_CM_EVENT_CONNECT_REQUEST)
430                         rdma_destroy_id(uevent->cm_id);
431
432                 kfree(uevent);
433         }
434 }
435
436 static void ucma_cleanup_mc_events(struct ucma_multicast *mc)
437 {
438         struct ucma_event *uevent, *tmp;
439
440         list_for_each_entry_safe(uevent, tmp, &mc->ctx->file->event_list, list) {
441                 if (uevent->mc != mc)
442                         continue;
443
444                 list_del(&uevent->list);
445                 kfree(uevent);
446         }
447 }
448
449 static int ucma_free_ctx(struct ucma_context *ctx)
450 {
451         int events_reported;
452
453         /* No new events will be generated after destroying the id. */
454         rdma_destroy_id(ctx->cm_id);
455
456         ucma_cleanup_multicast(ctx);
457
458         /* Cleanup events not yet reported to the user. */
459         mutex_lock(&ctx->file->mut);
460         ucma_cleanup_events(ctx);
461         list_del(&ctx->list);
462         mutex_unlock(&ctx->file->mut);
463
464         events_reported = ctx->events_reported;
465         kfree(ctx);
466         return events_reported;
467 }
468
469 static ssize_t ucma_destroy_id(struct ucma_file *file, const char __user *inbuf,
470                                int in_len, int out_len)
471 {
472         struct rdma_ucm_destroy_id cmd;
473         struct rdma_ucm_destroy_id_resp resp;
474         struct ucma_context *ctx;
475         int ret = 0;
476
477         if (out_len < sizeof(resp))
478                 return -ENOSPC;
479
480         if (copy_from_user(&cmd, inbuf, sizeof(cmd)))
481                 return -EFAULT;
482
483         mutex_lock(&mut);
484         ctx = _ucma_find_context(cmd.id, file);
485         if (!IS_ERR(ctx))
486                 idr_remove(&ctx_idr, ctx->id);
487         mutex_unlock(&mut);
488
489         if (IS_ERR(ctx))
490                 return PTR_ERR(ctx);
491
492         ucma_put_ctx(ctx);
493         wait_for_completion(&ctx->comp);
494         resp.events_reported = ucma_free_ctx(ctx);
495
496         if (copy_to_user((void __user *)(unsigned long)cmd.response,
497                          &resp, sizeof(resp)))
498                 ret = -EFAULT;
499
500         return ret;
501 }
502
503 static ssize_t ucma_bind_addr(struct ucma_file *file, const char __user *inbuf,
504                               int in_len, int out_len)
505 {
506         struct rdma_ucm_bind_addr cmd;
507         struct ucma_context *ctx;
508         int ret;
509
510         if (copy_from_user(&cmd, inbuf, sizeof(cmd)))
511                 return -EFAULT;
512
513         ctx = ucma_get_ctx(file, cmd.id);
514         if (IS_ERR(ctx))
515                 return PTR_ERR(ctx);
516
517         ret = rdma_bind_addr(ctx->cm_id, (struct sockaddr *) &cmd.addr);
518         ucma_put_ctx(ctx);
519         return ret;
520 }
521
522 static ssize_t ucma_resolve_addr(struct ucma_file *file,
523                                  const char __user *inbuf,
524                                  int in_len, int out_len)
525 {
526         struct rdma_ucm_resolve_addr cmd;
527         struct ucma_context *ctx;
528         int ret;
529
530         if (copy_from_user(&cmd, inbuf, sizeof(cmd)))
531                 return -EFAULT;
532
533         ctx = ucma_get_ctx(file, cmd.id);
534         if (IS_ERR(ctx))
535                 return PTR_ERR(ctx);
536
537         ret = rdma_resolve_addr(ctx->cm_id, (struct sockaddr *) &cmd.src_addr,
538                                 (struct sockaddr *) &cmd.dst_addr,
539                                 cmd.timeout_ms);
540         ucma_put_ctx(ctx);
541         return ret;
542 }
543
544 static ssize_t ucma_resolve_route(struct ucma_file *file,
545                                   const char __user *inbuf,
546                                   int in_len, int out_len)
547 {
548         struct rdma_ucm_resolve_route cmd;
549         struct ucma_context *ctx;
550         int ret;
551
552         if (copy_from_user(&cmd, inbuf, sizeof(cmd)))
553                 return -EFAULT;
554
555         ctx = ucma_get_ctx(file, cmd.id);
556         if (IS_ERR(ctx))
557                 return PTR_ERR(ctx);
558
559         ret = rdma_resolve_route(ctx->cm_id, cmd.timeout_ms);
560         ucma_put_ctx(ctx);
561         return ret;
562 }
563
564 static void ucma_copy_ib_route(struct rdma_ucm_query_route_resp *resp,
565                                struct rdma_route *route)
566 {
567         struct rdma_dev_addr *dev_addr;
568
569         resp->num_paths = route->num_paths;
570         switch (route->num_paths) {
571         case 0:
572                 dev_addr = &route->addr.dev_addr;
573                 ib_addr_get_dgid(dev_addr,
574                                  (union ib_gid *) &resp->ib_route[0].dgid);
575                 ib_addr_get_sgid(dev_addr,
576                                  (union ib_gid *) &resp->ib_route[0].sgid);
577                 resp->ib_route[0].pkey = cpu_to_be16(ib_addr_get_pkey(dev_addr));
578                 break;
579         case 2:
580                 ib_copy_path_rec_to_user(&resp->ib_route[1],
581                                          &route->path_rec[1]);
582                 /* fall through */
583         case 1:
584                 ib_copy_path_rec_to_user(&resp->ib_route[0],
585                                          &route->path_rec[0]);
586                 break;
587         default:
588                 break;
589         }
590 }
591
592 static ssize_t ucma_query_route(struct ucma_file *file,
593                                 const char __user *inbuf,
594                                 int in_len, int out_len)
595 {
596         struct rdma_ucm_query_route cmd;
597         struct rdma_ucm_query_route_resp resp;
598         struct ucma_context *ctx;
599         struct sockaddr *addr;
600         int ret = 0;
601
602         if (out_len < sizeof(resp))
603                 return -ENOSPC;
604
605         if (copy_from_user(&cmd, inbuf, sizeof(cmd)))
606                 return -EFAULT;
607
608         ctx = ucma_get_ctx(file, cmd.id);
609         if (IS_ERR(ctx))
610                 return PTR_ERR(ctx);
611
612         memset(&resp, 0, sizeof resp);
613         addr = &ctx->cm_id->route.addr.src_addr;
614         memcpy(&resp.src_addr, addr, addr->sa_family == AF_INET ?
615                                      sizeof(struct sockaddr_in) :
616                                      sizeof(struct sockaddr_in6));
617         addr = &ctx->cm_id->route.addr.dst_addr;
618         memcpy(&resp.dst_addr, addr, addr->sa_family == AF_INET ?
619                                      sizeof(struct sockaddr_in) :
620                                      sizeof(struct sockaddr_in6));
621         if (!ctx->cm_id->device)
622                 goto out;
623
624         resp.node_guid = ctx->cm_id->device->node_guid;
625         resp.port_num = ctx->cm_id->port_num;
626         switch (rdma_node_get_transport(ctx->cm_id->device->node_type)) {
627         case RDMA_TRANSPORT_IB:
628                 ucma_copy_ib_route(&resp, &ctx->cm_id->route);
629                 break;
630         default:
631                 break;
632         }
633
634 out:
635         if (copy_to_user((void __user *)(unsigned long)cmd.response,
636                          &resp, sizeof(resp)))
637                 ret = -EFAULT;
638
639         ucma_put_ctx(ctx);
640         return ret;
641 }
642
643 static void ucma_copy_conn_param(struct rdma_conn_param *dst,
644                                  struct rdma_ucm_conn_param *src)
645 {
646         dst->private_data = src->private_data;
647         dst->private_data_len = src->private_data_len;
648         dst->responder_resources =src->responder_resources;
649         dst->initiator_depth = src->initiator_depth;
650         dst->flow_control = src->flow_control;
651         dst->retry_count = src->retry_count;
652         dst->rnr_retry_count = src->rnr_retry_count;
653         dst->srq = src->srq;
654         dst->qp_num = src->qp_num;
655 }
656
657 static ssize_t ucma_connect(struct ucma_file *file, const char __user *inbuf,
658                             int in_len, int out_len)
659 {
660         struct rdma_ucm_connect cmd;
661         struct rdma_conn_param conn_param;
662         struct ucma_context *ctx;
663         int ret;
664
665         if (copy_from_user(&cmd, inbuf, sizeof(cmd)))
666                 return -EFAULT;
667
668         if (!cmd.conn_param.valid)
669                 return -EINVAL;
670
671         ctx = ucma_get_ctx(file, cmd.id);
672         if (IS_ERR(ctx))
673                 return PTR_ERR(ctx);
674
675         ucma_copy_conn_param(&conn_param, &cmd.conn_param);
676         ret = rdma_connect(ctx->cm_id, &conn_param);
677         ucma_put_ctx(ctx);
678         return ret;
679 }
680
681 static ssize_t ucma_listen(struct ucma_file *file, const char __user *inbuf,
682                            int in_len, int out_len)
683 {
684         struct rdma_ucm_listen cmd;
685         struct ucma_context *ctx;
686         int ret;
687
688         if (copy_from_user(&cmd, inbuf, sizeof(cmd)))
689                 return -EFAULT;
690
691         ctx = ucma_get_ctx(file, cmd.id);
692         if (IS_ERR(ctx))
693                 return PTR_ERR(ctx);
694
695         ctx->backlog = cmd.backlog > 0 && cmd.backlog < UCMA_MAX_BACKLOG ?
696                        cmd.backlog : UCMA_MAX_BACKLOG;
697         ret = rdma_listen(ctx->cm_id, ctx->backlog);
698         ucma_put_ctx(ctx);
699         return ret;
700 }
701
702 static ssize_t ucma_accept(struct ucma_file *file, const char __user *inbuf,
703                            int in_len, int out_len)
704 {
705         struct rdma_ucm_accept cmd;
706         struct rdma_conn_param conn_param;
707         struct ucma_context *ctx;
708         int ret;
709
710         if (copy_from_user(&cmd, inbuf, sizeof(cmd)))
711                 return -EFAULT;
712
713         ctx = ucma_get_ctx(file, cmd.id);
714         if (IS_ERR(ctx))
715                 return PTR_ERR(ctx);
716
717         if (cmd.conn_param.valid) {
718                 ctx->uid = cmd.uid;
719                 ucma_copy_conn_param(&conn_param, &cmd.conn_param);
720                 ret = rdma_accept(ctx->cm_id, &conn_param);
721         } else
722                 ret = rdma_accept(ctx->cm_id, NULL);
723
724         ucma_put_ctx(ctx);
725         return ret;
726 }
727
728 static ssize_t ucma_reject(struct ucma_file *file, const char __user *inbuf,
729                            int in_len, int out_len)
730 {
731         struct rdma_ucm_reject cmd;
732         struct ucma_context *ctx;
733         int ret;
734
735         if (copy_from_user(&cmd, inbuf, sizeof(cmd)))
736                 return -EFAULT;
737
738         ctx = ucma_get_ctx(file, cmd.id);
739         if (IS_ERR(ctx))
740                 return PTR_ERR(ctx);
741
742         ret = rdma_reject(ctx->cm_id, cmd.private_data, cmd.private_data_len);
743         ucma_put_ctx(ctx);
744         return ret;
745 }
746
747 static ssize_t ucma_disconnect(struct ucma_file *file, const char __user *inbuf,
748                                int in_len, int out_len)
749 {
750         struct rdma_ucm_disconnect cmd;
751         struct ucma_context *ctx;
752         int ret;
753
754         if (copy_from_user(&cmd, inbuf, sizeof(cmd)))
755                 return -EFAULT;
756
757         ctx = ucma_get_ctx(file, cmd.id);
758         if (IS_ERR(ctx))
759                 return PTR_ERR(ctx);
760
761         ret = rdma_disconnect(ctx->cm_id);
762         ucma_put_ctx(ctx);
763         return ret;
764 }
765
766 static ssize_t ucma_init_qp_attr(struct ucma_file *file,
767                                  const char __user *inbuf,
768                                  int in_len, int out_len)
769 {
770         struct rdma_ucm_init_qp_attr cmd;
771         struct ib_uverbs_qp_attr resp;
772         struct ucma_context *ctx;
773         struct ib_qp_attr qp_attr;
774         int ret;
775
776         if (out_len < sizeof(resp))
777                 return -ENOSPC;
778
779         if (copy_from_user(&cmd, inbuf, sizeof(cmd)))
780                 return -EFAULT;
781
782         ctx = ucma_get_ctx(file, cmd.id);
783         if (IS_ERR(ctx))
784                 return PTR_ERR(ctx);
785
786         resp.qp_attr_mask = 0;
787         memset(&qp_attr, 0, sizeof qp_attr);
788         qp_attr.qp_state = cmd.qp_state;
789         ret = rdma_init_qp_attr(ctx->cm_id, &qp_attr, &resp.qp_attr_mask);
790         if (ret)
791                 goto out;
792
793         ib_copy_qp_attr_to_user(&resp, &qp_attr);
794         if (copy_to_user((void __user *)(unsigned long)cmd.response,
795                          &resp, sizeof(resp)))
796                 ret = -EFAULT;
797
798 out:
799         ucma_put_ctx(ctx);
800         return ret;
801 }
802
803 static ssize_t ucma_notify(struct ucma_file *file, const char __user *inbuf,
804                            int in_len, int out_len)
805 {
806         struct rdma_ucm_notify cmd;
807         struct ucma_context *ctx;
808         int ret;
809
810         if (copy_from_user(&cmd, inbuf, sizeof(cmd)))
811                 return -EFAULT;
812
813         ctx = ucma_get_ctx(file, cmd.id);
814         if (IS_ERR(ctx))
815                 return PTR_ERR(ctx);
816
817         ret = rdma_notify(ctx->cm_id, (enum ib_event_type) cmd.event);
818         ucma_put_ctx(ctx);
819         return ret;
820 }
821
822 static ssize_t ucma_join_multicast(struct ucma_file *file,
823                                    const char __user *inbuf,
824                                    int in_len, int out_len)
825 {
826         struct rdma_ucm_join_mcast cmd;
827         struct rdma_ucm_create_id_resp resp;
828         struct ucma_context *ctx;
829         struct ucma_multicast *mc;
830         int ret;
831
832         if (out_len < sizeof(resp))
833                 return -ENOSPC;
834
835         if (copy_from_user(&cmd, inbuf, sizeof(cmd)))
836                 return -EFAULT;
837
838         ctx = ucma_get_ctx(file, cmd.id);
839         if (IS_ERR(ctx))
840                 return PTR_ERR(ctx);
841
842         mutex_lock(&file->mut);
843         mc = ucma_alloc_multicast(ctx);
844         if (IS_ERR(mc)) {
845                 ret = PTR_ERR(mc);
846                 goto err1;
847         }
848
849         mc->uid = cmd.uid;
850         memcpy(&mc->addr, &cmd.addr, sizeof cmd.addr);
851         ret = rdma_join_multicast(ctx->cm_id, &mc->addr, mc);
852         if (ret)
853                 goto err2;
854
855         resp.id = mc->id;
856         if (copy_to_user((void __user *)(unsigned long)cmd.response,
857                          &resp, sizeof(resp))) {
858                 ret = -EFAULT;
859                 goto err3;
860         }
861
862         mutex_unlock(&file->mut);
863         ucma_put_ctx(ctx);
864         return 0;
865
866 err3:
867         rdma_leave_multicast(ctx->cm_id, &mc->addr);
868         ucma_cleanup_mc_events(mc);
869 err2:
870         mutex_lock(&mut);
871         idr_remove(&multicast_idr, mc->id);
872         mutex_unlock(&mut);
873         list_del(&mc->list);
874         kfree(mc);
875 err1:
876         mutex_unlock(&file->mut);
877         ucma_put_ctx(ctx);
878         return ret;
879 }
880
881 static ssize_t ucma_leave_multicast(struct ucma_file *file,
882                                     const char __user *inbuf,
883                                     int in_len, int out_len)
884 {
885         struct rdma_ucm_destroy_id cmd;
886         struct rdma_ucm_destroy_id_resp resp;
887         struct ucma_multicast *mc;
888         int ret = 0;
889
890         if (out_len < sizeof(resp))
891                 return -ENOSPC;
892
893         if (copy_from_user(&cmd, inbuf, sizeof(cmd)))
894                 return -EFAULT;
895
896         mutex_lock(&mut);
897         mc = idr_find(&multicast_idr, cmd.id);
898         if (!mc)
899                 mc = ERR_PTR(-ENOENT);
900         else if (mc->ctx->file != file)
901                 mc = ERR_PTR(-EINVAL);
902         else {
903                 idr_remove(&multicast_idr, mc->id);
904                 atomic_inc(&mc->ctx->ref);
905         }
906         mutex_unlock(&mut);
907
908         if (IS_ERR(mc)) {
909                 ret = PTR_ERR(mc);
910                 goto out;
911         }
912
913         rdma_leave_multicast(mc->ctx->cm_id, &mc->addr);
914         mutex_lock(&mc->ctx->file->mut);
915         ucma_cleanup_mc_events(mc);
916         list_del(&mc->list);
917         mutex_unlock(&mc->ctx->file->mut);
918
919         ucma_put_ctx(mc->ctx);
920         resp.events_reported = mc->events_reported;
921         kfree(mc);
922
923         if (copy_to_user((void __user *)(unsigned long)cmd.response,
924                          &resp, sizeof(resp)))
925                 ret = -EFAULT;
926 out:
927         return ret;
928 }
929
930 static ssize_t (*ucma_cmd_table[])(struct ucma_file *file,
931                                    const char __user *inbuf,
932                                    int in_len, int out_len) = {
933         [RDMA_USER_CM_CMD_CREATE_ID]    = ucma_create_id,
934         [RDMA_USER_CM_CMD_DESTROY_ID]   = ucma_destroy_id,
935         [RDMA_USER_CM_CMD_BIND_ADDR]    = ucma_bind_addr,
936         [RDMA_USER_CM_CMD_RESOLVE_ADDR] = ucma_resolve_addr,
937         [RDMA_USER_CM_CMD_RESOLVE_ROUTE]= ucma_resolve_route,
938         [RDMA_USER_CM_CMD_QUERY_ROUTE]  = ucma_query_route,
939         [RDMA_USER_CM_CMD_CONNECT]      = ucma_connect,
940         [RDMA_USER_CM_CMD_LISTEN]       = ucma_listen,
941         [RDMA_USER_CM_CMD_ACCEPT]       = ucma_accept,
942         [RDMA_USER_CM_CMD_REJECT]       = ucma_reject,
943         [RDMA_USER_CM_CMD_DISCONNECT]   = ucma_disconnect,
944         [RDMA_USER_CM_CMD_INIT_QP_ATTR] = ucma_init_qp_attr,
945         [RDMA_USER_CM_CMD_GET_EVENT]    = ucma_get_event,
946         [RDMA_USER_CM_CMD_GET_OPTION]   = NULL,
947         [RDMA_USER_CM_CMD_SET_OPTION]   = NULL,
948         [RDMA_USER_CM_CMD_NOTIFY]       = ucma_notify,
949         [RDMA_USER_CM_CMD_JOIN_MCAST]   = ucma_join_multicast,
950         [RDMA_USER_CM_CMD_LEAVE_MCAST]  = ucma_leave_multicast,
951 };
952
953 static ssize_t ucma_write(struct file *filp, const char __user *buf,
954                           size_t len, loff_t *pos)
955 {
956         struct ucma_file *file = filp->private_data;
957         struct rdma_ucm_cmd_hdr hdr;
958         ssize_t ret;
959
960         if (len < sizeof(hdr))
961                 return -EINVAL;
962
963         if (copy_from_user(&hdr, buf, sizeof(hdr)))
964                 return -EFAULT;
965
966         if (hdr.cmd < 0 || hdr.cmd >= ARRAY_SIZE(ucma_cmd_table))
967                 return -EINVAL;
968
969         if (hdr.in + sizeof(hdr) > len)
970                 return -EINVAL;
971
972         if (!ucma_cmd_table[hdr.cmd])
973                 return -ENOSYS;
974
975         ret = ucma_cmd_table[hdr.cmd](file, buf + sizeof(hdr), hdr.in, hdr.out);
976         if (!ret)
977                 ret = len;
978
979         return ret;
980 }
981
982 static unsigned int ucma_poll(struct file *filp, struct poll_table_struct *wait)
983 {
984         struct ucma_file *file = filp->private_data;
985         unsigned int mask = 0;
986
987         poll_wait(filp, &file->poll_wait, wait);
988
989         if (!list_empty(&file->event_list))
990                 mask = POLLIN | POLLRDNORM;
991
992         return mask;
993 }
994
995 static int ucma_open(struct inode *inode, struct file *filp)
996 {
997         struct ucma_file *file;
998
999         file = kmalloc(sizeof *file, GFP_KERNEL);
1000         if (!file)
1001                 return -ENOMEM;
1002
1003         INIT_LIST_HEAD(&file->event_list);
1004         INIT_LIST_HEAD(&file->ctx_list);
1005         init_waitqueue_head(&file->poll_wait);
1006         mutex_init(&file->mut);
1007
1008         filp->private_data = file;
1009         file->filp = filp;
1010         return 0;
1011 }
1012
1013 static int ucma_close(struct inode *inode, struct file *filp)
1014 {
1015         struct ucma_file *file = filp->private_data;
1016         struct ucma_context *ctx, *tmp;
1017
1018         mutex_lock(&file->mut);
1019         list_for_each_entry_safe(ctx, tmp, &file->ctx_list, list) {
1020                 mutex_unlock(&file->mut);
1021
1022                 mutex_lock(&mut);
1023                 idr_remove(&ctx_idr, ctx->id);
1024                 mutex_unlock(&mut);
1025
1026                 ucma_free_ctx(ctx);
1027                 mutex_lock(&file->mut);
1028         }
1029         mutex_unlock(&file->mut);
1030         kfree(file);
1031         return 0;
1032 }
1033
1034 static const struct file_operations ucma_fops = {
1035         .owner   = THIS_MODULE,
1036         .open    = ucma_open,
1037         .release = ucma_close,
1038         .write   = ucma_write,
1039         .poll    = ucma_poll,
1040 };
1041
1042 static struct miscdevice ucma_misc = {
1043         .minor  = MISC_DYNAMIC_MINOR,
1044         .name   = "rdma_cm",
1045         .fops   = &ucma_fops,
1046 };
1047
1048 static ssize_t show_abi_version(struct device *dev,
1049                                 struct device_attribute *attr,
1050                                 char *buf)
1051 {
1052         return sprintf(buf, "%d\n", RDMA_USER_CM_ABI_VERSION);
1053 }
1054 static DEVICE_ATTR(abi_version, S_IRUGO, show_abi_version, NULL);
1055
1056 static int __init ucma_init(void)
1057 {
1058         int ret;
1059
1060         ret = misc_register(&ucma_misc);
1061         if (ret)
1062                 return ret;
1063
1064         ret = device_create_file(ucma_misc.this_device, &dev_attr_abi_version);
1065         if (ret) {
1066                 printk(KERN_ERR "rdma_ucm: couldn't create abi_version attr\n");
1067                 goto err;
1068         }
1069         return 0;
1070 err:
1071         misc_deregister(&ucma_misc);
1072         return ret;
1073 }
1074
1075 static void __exit ucma_cleanup(void)
1076 {
1077         device_remove_file(ucma_misc.this_device, &dev_attr_abi_version);
1078         misc_deregister(&ucma_misc);
1079         idr_destroy(&ctx_idr);
1080 }
1081
1082 module_init(ucma_init);
1083 module_exit(ucma_cleanup);