Merge HEAD from master.kernel.org:/pub/scm/linux/kernel/git/roland/infiniband.git
[linux-2.6.git] / drivers / infiniband / core / ucm.c
1 /*
2  * Copyright (c) 2005 Topspin Communications.  All rights reserved.
3  * Copyright (c) 2005 Intel Corporation.  All rights reserved.
4  *
5  * This software is available to you under a choice of one of two
6  * licenses.  You may choose to be licensed under the terms of the GNU
7  * General Public License (GPL) Version 2, available from the file
8  * COPYING in the main directory of this source tree, or the
9  * OpenIB.org BSD license below:
10  *
11  *     Redistribution and use in source and binary forms, with or
12  *     without modification, are permitted provided that the following
13  *     conditions are met:
14  *
15  *      - Redistributions of source code must retain the above
16  *      copyright notice, this list of conditions and the following
17  *      disclaimer.
18  *
19  *      - Redistributions in binary form must reproduce the above
20  *      copyright notice, this list of conditions and the following
21  *      disclaimer in the documentation and/or other materials
22  *      provided with the distribution.
23  *
24  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
25  * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
26  * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
27  * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
28  * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
29  * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
30  * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
31  * SOFTWARE.
32  *
33  * $Id: ucm.c 2594 2005-06-13 19:46:02Z libor $
34  */
35 #include <linux/init.h>
36 #include <linux/fs.h>
37 #include <linux/module.h>
38 #include <linux/device.h>
39 #include <linux/err.h>
40 #include <linux/poll.h>
41 #include <linux/file.h>
42 #include <linux/mount.h>
43 #include <linux/cdev.h>
44
45 #include <asm/uaccess.h>
46
47 #include "ucm.h"
48
49 MODULE_AUTHOR("Libor Michalek");
50 MODULE_DESCRIPTION("InfiniBand userspace Connection Manager access");
51 MODULE_LICENSE("Dual BSD/GPL");
52
53 static int ucm_debug_level;
54
55 module_param_named(debug_level, ucm_debug_level, int, 0644);
56 MODULE_PARM_DESC(debug_level, "Enable debug tracing if > 0");
57
58 enum {
59         IB_UCM_MAJOR = 231,
60         IB_UCM_MINOR = 255
61 };
62
63 #define IB_UCM_DEV MKDEV(IB_UCM_MAJOR, IB_UCM_MINOR)
64
65 #define PFX "UCM: "
66
67 #define ucm_dbg(format, arg...)                 \
68         do {                                    \
69                 if (ucm_debug_level > 0)        \
70                         printk(KERN_DEBUG PFX format, ## arg); \
71         } while (0)
72
73 static struct semaphore ctx_id_mutex;
74 static struct idr       ctx_id_table;
75 static int              ctx_id_rover = 0;
76
77 static struct ib_ucm_context *ib_ucm_ctx_get(struct ib_ucm_file *file, int id)
78 {
79         struct ib_ucm_context *ctx;
80
81         down(&ctx_id_mutex);
82         ctx = idr_find(&ctx_id_table, id);
83         if (!ctx)
84                 ctx = ERR_PTR(-ENOENT);
85         else if (ctx->file != file)
86                 ctx = ERR_PTR(-EINVAL);
87         else
88                 atomic_inc(&ctx->ref);
89         up(&ctx_id_mutex);
90
91         return ctx;
92 }
93
94 static void ib_ucm_ctx_put(struct ib_ucm_context *ctx)
95 {
96         if (atomic_dec_and_test(&ctx->ref))
97                 wake_up(&ctx->wait);
98 }
99
100 static ssize_t ib_ucm_destroy_ctx(struct ib_ucm_file *file, int id)
101 {
102         struct ib_ucm_context *ctx;
103         struct ib_ucm_event *uevent;
104
105         down(&ctx_id_mutex);
106         ctx = idr_find(&ctx_id_table, id);
107         if (!ctx)
108                 ctx = ERR_PTR(-ENOENT);
109         else if (ctx->file != file)
110                 ctx = ERR_PTR(-EINVAL);
111         else
112                 idr_remove(&ctx_id_table, ctx->id);
113         up(&ctx_id_mutex);
114
115         if (IS_ERR(ctx))
116                 return PTR_ERR(ctx);
117
118         atomic_dec(&ctx->ref);
119         wait_event(ctx->wait, !atomic_read(&ctx->ref));
120
121         /* No new events will be generated after destroying the cm_id. */
122         if (!IS_ERR(ctx->cm_id))
123                 ib_destroy_cm_id(ctx->cm_id);
124
125         /* Cleanup events not yet reported to the user. */
126         down(&file->mutex);
127         list_del(&ctx->file_list);
128         while (!list_empty(&ctx->events)) {
129
130                 uevent = list_entry(ctx->events.next,
131                                     struct ib_ucm_event, ctx_list);
132                 list_del(&uevent->file_list);
133                 list_del(&uevent->ctx_list);
134
135                 /* clear incoming connections. */
136                 if (uevent->cm_id)
137                         ib_destroy_cm_id(uevent->cm_id);
138
139                 kfree(uevent);
140         }
141         up(&file->mutex);
142
143         kfree(ctx);
144         return 0;
145 }
146
147 static struct ib_ucm_context *ib_ucm_ctx_alloc(struct ib_ucm_file *file)
148 {
149         struct ib_ucm_context *ctx;
150         int result;
151
152         ctx = kmalloc(sizeof(*ctx), GFP_KERNEL);
153         if (!ctx)
154                 return NULL;
155
156         atomic_set(&ctx->ref, 1);
157         init_waitqueue_head(&ctx->wait);
158         ctx->file = file;
159
160         INIT_LIST_HEAD(&ctx->events);
161
162         list_add_tail(&ctx->file_list, &file->ctxs);
163
164         ctx_id_rover = (ctx_id_rover + 1) & INT_MAX;
165 retry:
166         result = idr_pre_get(&ctx_id_table, GFP_KERNEL);
167         if (!result)
168                 goto error;
169
170         down(&ctx_id_mutex);
171         result = idr_get_new_above(&ctx_id_table, ctx, ctx_id_rover, &ctx->id);
172         up(&ctx_id_mutex);
173
174         if (result == -EAGAIN)
175                 goto retry;
176         if (result)
177                 goto error;
178
179         ucm_dbg("Allocated CM ID <%d>\n", ctx->id);
180
181         return ctx;
182 error:
183         list_del(&ctx->file_list);
184         kfree(ctx);
185
186         return NULL;
187 }
188 /*
189  * Event portion of the API, handle CM events
190  * and allow event polling.
191  */
192 static void ib_ucm_event_path_get(struct ib_ucm_path_rec *upath,
193                                   struct ib_sa_path_rec  *kpath)
194 {
195         if (!kpath || !upath)
196                 return;
197
198         memcpy(upath->dgid, kpath->dgid.raw, sizeof *upath->dgid);
199         memcpy(upath->sgid, kpath->sgid.raw, sizeof *upath->sgid);
200
201         upath->dlid             = kpath->dlid;
202         upath->slid             = kpath->slid;
203         upath->raw_traffic      = kpath->raw_traffic;
204         upath->flow_label       = kpath->flow_label;
205         upath->hop_limit        = kpath->hop_limit;
206         upath->traffic_class    = kpath->traffic_class;
207         upath->reversible       = kpath->reversible;
208         upath->numb_path        = kpath->numb_path;
209         upath->pkey             = kpath->pkey;
210         upath->sl               = kpath->sl;
211         upath->mtu_selector     = kpath->mtu_selector;
212         upath->mtu              = kpath->mtu;
213         upath->rate_selector    = kpath->rate_selector;
214         upath->rate             = kpath->rate;
215         upath->packet_life_time = kpath->packet_life_time;
216         upath->preference       = kpath->preference;
217
218         upath->packet_life_time_selector =
219                 kpath->packet_life_time_selector;
220 }
221
222 static void ib_ucm_event_req_get(struct ib_ucm_context *ctx,
223                                  struct ib_ucm_req_event_resp *ureq,
224                                  struct ib_cm_req_event_param *kreq)
225 {
226         ureq->listen_id = ctx->id;
227
228         ureq->remote_ca_guid             = kreq->remote_ca_guid;
229         ureq->remote_qkey                = kreq->remote_qkey;
230         ureq->remote_qpn                 = kreq->remote_qpn;
231         ureq->qp_type                    = kreq->qp_type;
232         ureq->starting_psn               = kreq->starting_psn;
233         ureq->responder_resources        = kreq->responder_resources;
234         ureq->initiator_depth            = kreq->initiator_depth;
235         ureq->local_cm_response_timeout  = kreq->local_cm_response_timeout;
236         ureq->flow_control               = kreq->flow_control;
237         ureq->remote_cm_response_timeout = kreq->remote_cm_response_timeout;
238         ureq->retry_count                = kreq->retry_count;
239         ureq->rnr_retry_count            = kreq->rnr_retry_count;
240         ureq->srq                        = kreq->srq;
241
242         ib_ucm_event_path_get(&ureq->primary_path, kreq->primary_path);
243         ib_ucm_event_path_get(&ureq->alternate_path, kreq->alternate_path);
244 }
245
246 static void ib_ucm_event_rep_get(struct ib_ucm_rep_event_resp *urep,
247                                  struct ib_cm_rep_event_param *krep)
248 {
249         urep->remote_ca_guid      = krep->remote_ca_guid;
250         urep->remote_qkey         = krep->remote_qkey;
251         urep->remote_qpn          = krep->remote_qpn;
252         urep->starting_psn        = krep->starting_psn;
253         urep->responder_resources = krep->responder_resources;
254         urep->initiator_depth     = krep->initiator_depth;
255         urep->target_ack_delay    = krep->target_ack_delay;
256         urep->failover_accepted   = krep->failover_accepted;
257         urep->flow_control        = krep->flow_control;
258         urep->rnr_retry_count     = krep->rnr_retry_count;
259         urep->srq                 = krep->srq;
260 }
261
262 static void ib_ucm_event_sidr_req_get(struct ib_ucm_context *ctx,
263                                       struct ib_ucm_sidr_req_event_resp *ureq,
264                                       struct ib_cm_sidr_req_event_param *kreq)
265 {
266         ureq->listen_id = ctx->id;
267         ureq->pkey      = kreq->pkey;
268 }
269
270 static void ib_ucm_event_sidr_rep_get(struct ib_ucm_sidr_rep_event_resp *urep,
271                                       struct ib_cm_sidr_rep_event_param *krep)
272 {
273         urep->status = krep->status;
274         urep->qkey   = krep->qkey;
275         urep->qpn    = krep->qpn;
276 };
277
278 static int ib_ucm_event_process(struct ib_ucm_context *ctx,
279                                 struct ib_cm_event *evt,
280                                 struct ib_ucm_event *uvt)
281 {
282         void *info = NULL;
283
284         switch (evt->event) {
285         case IB_CM_REQ_RECEIVED:
286                 ib_ucm_event_req_get(ctx, &uvt->resp.u.req_resp,
287                                      &evt->param.req_rcvd);
288                 uvt->data_len      = IB_CM_REQ_PRIVATE_DATA_SIZE;
289                 uvt->resp.present  = IB_UCM_PRES_PRIMARY;
290                 uvt->resp.present |= (evt->param.req_rcvd.alternate_path ?
291                                       IB_UCM_PRES_ALTERNATE : 0);
292                 break;
293         case IB_CM_REP_RECEIVED:
294                 ib_ucm_event_rep_get(&uvt->resp.u.rep_resp,
295                                      &evt->param.rep_rcvd);
296                 uvt->data_len = IB_CM_REP_PRIVATE_DATA_SIZE;
297                 break;
298         case IB_CM_RTU_RECEIVED:
299                 uvt->data_len = IB_CM_RTU_PRIVATE_DATA_SIZE;
300                 uvt->resp.u.send_status = evt->param.send_status;
301                 break;
302         case IB_CM_DREQ_RECEIVED:
303                 uvt->data_len = IB_CM_DREQ_PRIVATE_DATA_SIZE;
304                 uvt->resp.u.send_status = evt->param.send_status;
305                 break;
306         case IB_CM_DREP_RECEIVED:
307                 uvt->data_len = IB_CM_DREP_PRIVATE_DATA_SIZE;
308                 uvt->resp.u.send_status = evt->param.send_status;
309                 break;
310         case IB_CM_MRA_RECEIVED:
311                 uvt->resp.u.mra_resp.timeout =
312                                         evt->param.mra_rcvd.service_timeout;
313                 uvt->data_len = IB_CM_MRA_PRIVATE_DATA_SIZE;
314                 break;
315         case IB_CM_REJ_RECEIVED:
316                 uvt->resp.u.rej_resp.reason = evt->param.rej_rcvd.reason;
317                 uvt->data_len = IB_CM_REJ_PRIVATE_DATA_SIZE;
318                 uvt->info_len = evt->param.rej_rcvd.ari_length;
319                 info          = evt->param.rej_rcvd.ari;
320                 break;
321         case IB_CM_LAP_RECEIVED:
322                 ib_ucm_event_path_get(&uvt->resp.u.lap_resp.path,
323                                       evt->param.lap_rcvd.alternate_path);
324                 uvt->data_len = IB_CM_LAP_PRIVATE_DATA_SIZE;
325                 uvt->resp.present = IB_UCM_PRES_ALTERNATE;
326                 break;
327         case IB_CM_APR_RECEIVED:
328                 uvt->resp.u.apr_resp.status = evt->param.apr_rcvd.ap_status;
329                 uvt->data_len = IB_CM_APR_PRIVATE_DATA_SIZE;
330                 uvt->info_len = evt->param.apr_rcvd.info_len;
331                 info          = evt->param.apr_rcvd.apr_info;
332                 break;
333         case IB_CM_SIDR_REQ_RECEIVED:
334                 ib_ucm_event_sidr_req_get(ctx, &uvt->resp.u.sidr_req_resp,
335                                           &evt->param.sidr_req_rcvd);
336                 uvt->data_len = IB_CM_SIDR_REQ_PRIVATE_DATA_SIZE;
337                 break;
338         case IB_CM_SIDR_REP_RECEIVED:
339                 ib_ucm_event_sidr_rep_get(&uvt->resp.u.sidr_rep_resp,
340                                           &evt->param.sidr_rep_rcvd);
341                 uvt->data_len = IB_CM_SIDR_REP_PRIVATE_DATA_SIZE;
342                 uvt->info_len = evt->param.sidr_rep_rcvd.info_len;
343                 info          = evt->param.sidr_rep_rcvd.info;
344                 break;
345         default:
346                 uvt->resp.u.send_status = evt->param.send_status;
347                 break;
348         }
349
350         if (uvt->data_len) {
351                 uvt->data = kmalloc(uvt->data_len, GFP_KERNEL);
352                 if (!uvt->data)
353                         goto err1;
354
355                 memcpy(uvt->data, evt->private_data, uvt->data_len);
356                 uvt->resp.present |= IB_UCM_PRES_DATA;
357         }
358
359         if (uvt->info_len) {
360                 uvt->info = kmalloc(uvt->info_len, GFP_KERNEL);
361                 if (!uvt->info)
362                         goto err2;
363
364                 memcpy(uvt->info, info, uvt->info_len);
365                 uvt->resp.present |= IB_UCM_PRES_INFO;
366         }
367         return 0;
368
369 err2:
370         kfree(uvt->data);
371 err1:
372         return -ENOMEM;
373 }
374
375 static int ib_ucm_event_handler(struct ib_cm_id *cm_id,
376                                 struct ib_cm_event *event)
377 {
378         struct ib_ucm_event *uevent;
379         struct ib_ucm_context *ctx;
380         int result = 0;
381         int id;
382
383         ctx = cm_id->context;
384
385         if (event->event == IB_CM_REQ_RECEIVED ||
386             event->event == IB_CM_SIDR_REQ_RECEIVED)
387                 id = IB_UCM_CM_ID_INVALID;
388         else
389                 id = ctx->id;
390
391         uevent = kmalloc(sizeof(*uevent), GFP_KERNEL);
392         if (!uevent)
393                 goto err1;
394
395         memset(uevent, 0, sizeof(*uevent));
396         uevent->resp.id    = id;
397         uevent->resp.event = event->event;
398
399         result = ib_ucm_event_process(ctx, event, uevent);
400         if (result)
401                 goto err2;
402
403         uevent->ctx   = ctx;
404         uevent->cm_id = (id == IB_UCM_CM_ID_INVALID) ? cm_id : NULL;
405
406         down(&ctx->file->mutex);
407         list_add_tail(&uevent->file_list, &ctx->file->events);
408         list_add_tail(&uevent->ctx_list, &ctx->events);
409         wake_up_interruptible(&ctx->file->poll_wait);
410         up(&ctx->file->mutex);
411         return 0;
412
413 err2:
414         kfree(uevent);
415 err1:
416         /* Destroy new cm_id's */
417         return (id == IB_UCM_CM_ID_INVALID);
418 }
419
420 static ssize_t ib_ucm_event(struct ib_ucm_file *file,
421                             const char __user *inbuf,
422                             int in_len, int out_len)
423 {
424         struct ib_ucm_context *ctx;
425         struct ib_ucm_event_get cmd;
426         struct ib_ucm_event *uevent = NULL;
427         int result = 0;
428         DEFINE_WAIT(wait);
429
430         if (out_len < sizeof(struct ib_ucm_event_resp))
431                 return -ENOSPC;
432
433         if (copy_from_user(&cmd, inbuf, sizeof(cmd)))
434                 return -EFAULT;
435         /*
436          * wait
437          */
438         down(&file->mutex);
439
440         while (list_empty(&file->events)) {
441
442                 if (file->filp->f_flags & O_NONBLOCK) {
443                         result = -EAGAIN;
444                         break;
445                 }
446
447                 if (signal_pending(current)) {
448                         result = -ERESTARTSYS;
449                         break;
450                 }
451
452                 prepare_to_wait(&file->poll_wait, &wait, TASK_INTERRUPTIBLE);
453
454                 up(&file->mutex);
455                 schedule();
456                 down(&file->mutex);
457
458                 finish_wait(&file->poll_wait, &wait);
459         }
460
461         if (result)
462                 goto done;
463
464         uevent = list_entry(file->events.next, struct ib_ucm_event, file_list);
465
466         if (!uevent->cm_id)
467                 goto user;
468
469         ctx = ib_ucm_ctx_alloc(file);
470         if (!ctx) {
471                 result = -ENOMEM;
472                 goto done;
473         }
474
475         ctx->cm_id          = uevent->cm_id;
476         ctx->cm_id->context = ctx;
477
478         uevent->resp.id = ctx->id;
479
480 user:
481         if (copy_to_user((void __user *)(unsigned long)cmd.response,
482                          &uevent->resp, sizeof(uevent->resp))) {
483                 result = -EFAULT;
484                 goto done;
485         }
486
487         if (uevent->data) {
488
489                 if (cmd.data_len < uevent->data_len) {
490                         result = -ENOMEM;
491                         goto done;
492                 }
493
494                 if (copy_to_user((void __user *)(unsigned long)cmd.data,
495                                  uevent->data, uevent->data_len)) {
496                         result = -EFAULT;
497                         goto done;
498                 }
499         }
500
501         if (uevent->info) {
502
503                 if (cmd.info_len < uevent->info_len) {
504                         result = -ENOMEM;
505                         goto done;
506                 }
507
508                 if (copy_to_user((void __user *)(unsigned long)cmd.info,
509                                  uevent->info, uevent->info_len)) {
510                         result = -EFAULT;
511                         goto done;
512                 }
513         }
514
515         list_del(&uevent->file_list);
516         list_del(&uevent->ctx_list);
517
518         kfree(uevent->data);
519         kfree(uevent->info);
520         kfree(uevent);
521 done:
522         up(&file->mutex);
523         return result;
524 }
525
526
527 static ssize_t ib_ucm_create_id(struct ib_ucm_file *file,
528                                 const char __user *inbuf,
529                                 int in_len, int out_len)
530 {
531         struct ib_ucm_create_id cmd;
532         struct ib_ucm_create_id_resp resp;
533         struct ib_ucm_context *ctx;
534         int result;
535
536         if (out_len < sizeof(resp))
537                 return -ENOSPC;
538
539         if (copy_from_user(&cmd, inbuf, sizeof(cmd)))
540                 return -EFAULT;
541
542         down(&file->mutex);
543         ctx = ib_ucm_ctx_alloc(file);
544         up(&file->mutex);
545         if (!ctx)
546                 return -ENOMEM;
547
548         ctx->cm_id = ib_create_cm_id(ib_ucm_event_handler, ctx);
549         if (IS_ERR(ctx->cm_id)) {
550                 result = PTR_ERR(ctx->cm_id);
551                 goto err;
552         }
553
554         resp.id = ctx->id;
555         if (copy_to_user((void __user *)(unsigned long)cmd.response,
556                          &resp, sizeof(resp))) {
557                 result = -EFAULT;
558                 goto err;
559         }
560
561         return 0;
562
563 err:
564         ib_ucm_destroy_ctx(file, ctx->id);
565         return result;
566 }
567
568 static ssize_t ib_ucm_destroy_id(struct ib_ucm_file *file,
569                                  const char __user *inbuf,
570                                  int in_len, int out_len)
571 {
572         struct ib_ucm_destroy_id cmd;
573
574         if (copy_from_user(&cmd, inbuf, sizeof(cmd)))
575                 return -EFAULT;
576
577         return ib_ucm_destroy_ctx(file, cmd.id);
578 }
579
580 static ssize_t ib_ucm_attr_id(struct ib_ucm_file *file,
581                               const char __user *inbuf,
582                               int in_len, int out_len)
583 {
584         struct ib_ucm_attr_id_resp resp;
585         struct ib_ucm_attr_id cmd;
586         struct ib_ucm_context *ctx;
587         int result = 0;
588
589         if (out_len < sizeof(resp))
590                 return -ENOSPC;
591
592         if (copy_from_user(&cmd, inbuf, sizeof(cmd)))
593                 return -EFAULT;
594
595         ctx = ib_ucm_ctx_get(file, cmd.id);
596         if (IS_ERR(ctx))
597                 return PTR_ERR(ctx);
598
599         resp.service_id   = ctx->cm_id->service_id;
600         resp.service_mask = ctx->cm_id->service_mask;
601         resp.local_id     = ctx->cm_id->local_id;
602         resp.remote_id    = ctx->cm_id->remote_id;
603
604         if (copy_to_user((void __user *)(unsigned long)cmd.response,
605                          &resp, sizeof(resp)))
606                 result = -EFAULT;
607
608         ib_ucm_ctx_put(ctx);
609         return result;
610 }
611
612 static ssize_t ib_ucm_listen(struct ib_ucm_file *file,
613                              const char __user *inbuf,
614                              int in_len, int out_len)
615 {
616         struct ib_ucm_listen cmd;
617         struct ib_ucm_context *ctx;
618         int result;
619
620         if (copy_from_user(&cmd, inbuf, sizeof(cmd)))
621                 return -EFAULT;
622
623         ctx = ib_ucm_ctx_get(file, cmd.id);
624         if (IS_ERR(ctx))
625                 return PTR_ERR(ctx);
626
627         result = ib_cm_listen(ctx->cm_id, cmd.service_id, cmd.service_mask);
628         ib_ucm_ctx_put(ctx);
629         return result;
630 }
631
632 static ssize_t ib_ucm_establish(struct ib_ucm_file *file,
633                                 const char __user *inbuf,
634                                 int in_len, int out_len)
635 {
636         struct ib_ucm_establish cmd;
637         struct ib_ucm_context *ctx;
638         int result;
639
640         if (copy_from_user(&cmd, inbuf, sizeof(cmd)))
641                 return -EFAULT;
642
643         ctx = ib_ucm_ctx_get(file, cmd.id);
644         if (IS_ERR(ctx))
645                 return PTR_ERR(ctx);
646
647         result = ib_cm_establish(ctx->cm_id);
648         ib_ucm_ctx_put(ctx);
649         return result;
650 }
651
652 static int ib_ucm_alloc_data(const void **dest, u64 src, u32 len)
653 {
654         void *data;
655
656         *dest = NULL;
657
658         if (!len)
659                 return 0;
660
661         data = kmalloc(len, GFP_KERNEL);
662         if (!data)
663                 return -ENOMEM;
664
665         if (copy_from_user(data, (void __user *)(unsigned long)src, len)) {
666                 kfree(data);
667                 return -EFAULT;
668         }
669
670         *dest = data;
671         return 0;
672 }
673
674 static int ib_ucm_path_get(struct ib_sa_path_rec **path, u64 src)
675 {
676         struct ib_ucm_path_rec ucm_path;
677         struct ib_sa_path_rec  *sa_path;
678
679         *path = NULL;
680
681         if (!src)
682                 return 0;
683
684         sa_path = kmalloc(sizeof(*sa_path), GFP_KERNEL);
685         if (!sa_path)
686                 return -ENOMEM;
687
688         if (copy_from_user(&ucm_path, (void __user *)(unsigned long)src,
689                            sizeof(ucm_path))) {
690
691                 kfree(sa_path);
692                 return -EFAULT;
693         }
694
695         memcpy(sa_path->dgid.raw, ucm_path.dgid, sizeof sa_path->dgid);
696         memcpy(sa_path->sgid.raw, ucm_path.sgid, sizeof sa_path->sgid);
697
698         sa_path->dlid             = ucm_path.dlid;
699         sa_path->slid             = ucm_path.slid;
700         sa_path->raw_traffic      = ucm_path.raw_traffic;
701         sa_path->flow_label       = ucm_path.flow_label;
702         sa_path->hop_limit        = ucm_path.hop_limit;
703         sa_path->traffic_class    = ucm_path.traffic_class;
704         sa_path->reversible       = ucm_path.reversible;
705         sa_path->numb_path        = ucm_path.numb_path;
706         sa_path->pkey             = ucm_path.pkey;
707         sa_path->sl               = ucm_path.sl;
708         sa_path->mtu_selector     = ucm_path.mtu_selector;
709         sa_path->mtu              = ucm_path.mtu;
710         sa_path->rate_selector    = ucm_path.rate_selector;
711         sa_path->rate             = ucm_path.rate;
712         sa_path->packet_life_time = ucm_path.packet_life_time;
713         sa_path->preference       = ucm_path.preference;
714
715         sa_path->packet_life_time_selector =
716                 ucm_path.packet_life_time_selector;
717
718         *path = sa_path;
719         return 0;
720 }
721
722 static ssize_t ib_ucm_send_req(struct ib_ucm_file *file,
723                                const char __user *inbuf,
724                                int in_len, int out_len)
725 {
726         struct ib_cm_req_param param;
727         struct ib_ucm_context *ctx;
728         struct ib_ucm_req cmd;
729         int result;
730
731         param.private_data   = NULL;
732         param.primary_path   = NULL;
733         param.alternate_path = NULL;
734
735         if (copy_from_user(&cmd, inbuf, sizeof(cmd)))
736                 return -EFAULT;
737
738         result = ib_ucm_alloc_data(&param.private_data, cmd.data, cmd.len);
739         if (result)
740                 goto done;
741
742         result = ib_ucm_path_get(&param.primary_path, cmd.primary_path);
743         if (result)
744                 goto done;
745
746         result = ib_ucm_path_get(&param.alternate_path, cmd.alternate_path);
747         if (result)
748                 goto done;
749
750         param.private_data_len           = cmd.len;
751         param.service_id                 = cmd.sid;
752         param.qp_num                     = cmd.qpn;
753         param.qp_type                    = cmd.qp_type;
754         param.starting_psn               = cmd.psn;
755         param.peer_to_peer               = cmd.peer_to_peer;
756         param.responder_resources        = cmd.responder_resources;
757         param.initiator_depth            = cmd.initiator_depth;
758         param.remote_cm_response_timeout = cmd.remote_cm_response_timeout;
759         param.flow_control               = cmd.flow_control;
760         param.local_cm_response_timeout  = cmd.local_cm_response_timeout;
761         param.retry_count                = cmd.retry_count;
762         param.rnr_retry_count            = cmd.rnr_retry_count;
763         param.max_cm_retries             = cmd.max_cm_retries;
764         param.srq                        = cmd.srq;
765
766         ctx = ib_ucm_ctx_get(file, cmd.id);
767         if (!IS_ERR(ctx)) {
768                 result = ib_send_cm_req(ctx->cm_id, &param);
769                 ib_ucm_ctx_put(ctx);
770         } else
771                 result = PTR_ERR(ctx);
772
773 done:
774         kfree(param.private_data);
775         kfree(param.primary_path);
776         kfree(param.alternate_path);
777         return result;
778 }
779
780 static ssize_t ib_ucm_send_rep(struct ib_ucm_file *file,
781                                const char __user *inbuf,
782                                int in_len, int out_len)
783 {
784         struct ib_cm_rep_param param;
785         struct ib_ucm_context *ctx;
786         struct ib_ucm_rep cmd;
787         int result;
788
789         param.private_data = NULL;
790
791         if (copy_from_user(&cmd, inbuf, sizeof(cmd)))
792                 return -EFAULT;
793
794         result = ib_ucm_alloc_data(&param.private_data, cmd.data, cmd.len);
795         if (result)
796                 return result;
797
798         param.qp_num              = cmd.qpn;
799         param.starting_psn        = cmd.psn;
800         param.private_data_len    = cmd.len;
801         param.responder_resources = cmd.responder_resources;
802         param.initiator_depth     = cmd.initiator_depth;
803         param.target_ack_delay    = cmd.target_ack_delay;
804         param.failover_accepted   = cmd.failover_accepted;
805         param.flow_control        = cmd.flow_control;
806         param.rnr_retry_count     = cmd.rnr_retry_count;
807         param.srq                 = cmd.srq;
808
809         ctx = ib_ucm_ctx_get(file, cmd.id);
810         if (!IS_ERR(ctx)) {
811                 result = ib_send_cm_rep(ctx->cm_id, &param);
812                 ib_ucm_ctx_put(ctx);
813         } else
814                 result = PTR_ERR(ctx);
815
816         kfree(param.private_data);
817         return result;
818 }
819
820 static ssize_t ib_ucm_send_private_data(struct ib_ucm_file *file,
821                                         const char __user *inbuf, int in_len,
822                                         int (*func)(struct ib_cm_id *cm_id,
823                                                     const void *private_data,
824                                                     u8 private_data_len))
825 {
826         struct ib_ucm_private_data cmd;
827         struct ib_ucm_context *ctx;
828         const void *private_data = NULL;
829         int result;
830
831         if (copy_from_user(&cmd, inbuf, sizeof(cmd)))
832                 return -EFAULT;
833
834         result = ib_ucm_alloc_data(&private_data, cmd.data, cmd.len);
835         if (result)
836                 return result;
837
838         ctx = ib_ucm_ctx_get(file, cmd.id);
839         if (!IS_ERR(ctx)) {
840                 result = func(ctx->cm_id, private_data, cmd.len);
841                 ib_ucm_ctx_put(ctx);
842         } else
843                 result = PTR_ERR(ctx);
844
845         kfree(private_data);
846         return result;
847 }
848
849 static ssize_t ib_ucm_send_rtu(struct ib_ucm_file *file,
850                                const char __user *inbuf,
851                                int in_len, int out_len)
852 {
853         return ib_ucm_send_private_data(file, inbuf, in_len, ib_send_cm_rtu);
854 }
855
856 static ssize_t ib_ucm_send_dreq(struct ib_ucm_file *file,
857                                 const char __user *inbuf,
858                                 int in_len, int out_len)
859 {
860         return ib_ucm_send_private_data(file, inbuf, in_len, ib_send_cm_dreq);
861 }
862
863 static ssize_t ib_ucm_send_drep(struct ib_ucm_file *file,
864                                 const char __user *inbuf,
865                                 int in_len, int out_len)
866 {
867         return ib_ucm_send_private_data(file, inbuf, in_len, ib_send_cm_drep);
868 }
869
870 static ssize_t ib_ucm_send_info(struct ib_ucm_file *file,
871                                 const char __user *inbuf, int in_len,
872                                 int (*func)(struct ib_cm_id *cm_id,
873                                             int status,
874                                             const void *info,
875                                             u8 info_len,
876                                             const void *data,
877                                             u8 data_len))
878 {
879         struct ib_ucm_context *ctx;
880         struct ib_ucm_info cmd;
881         const void *data = NULL;
882         const void *info = NULL;
883         int result;
884
885         if (copy_from_user(&cmd, inbuf, sizeof(cmd)))
886                 return -EFAULT;
887
888         result = ib_ucm_alloc_data(&data, cmd.data, cmd.data_len);
889         if (result)
890                 goto done;
891
892         result = ib_ucm_alloc_data(&info, cmd.info, cmd.info_len);
893         if (result)
894                 goto done;
895
896         ctx = ib_ucm_ctx_get(file, cmd.id);
897         if (!IS_ERR(ctx)) {
898                 result = func(ctx->cm_id, cmd.status, info, cmd.info_len,
899                               data, cmd.data_len);
900                 ib_ucm_ctx_put(ctx);
901         } else
902                 result = PTR_ERR(ctx);
903
904 done:
905         kfree(data);
906         kfree(info);
907         return result;
908 }
909
910 static ssize_t ib_ucm_send_rej(struct ib_ucm_file *file,
911                                const char __user *inbuf,
912                                int in_len, int out_len)
913 {
914         return ib_ucm_send_info(file, inbuf, in_len, (void *)ib_send_cm_rej);
915 }
916
917 static ssize_t ib_ucm_send_apr(struct ib_ucm_file *file,
918                                const char __user *inbuf,
919                                int in_len, int out_len)
920 {
921         return ib_ucm_send_info(file, inbuf, in_len, (void *)ib_send_cm_apr);
922 }
923
924 static ssize_t ib_ucm_send_mra(struct ib_ucm_file *file,
925                                const char __user *inbuf,
926                                int in_len, int out_len)
927 {
928         struct ib_ucm_context *ctx;
929         struct ib_ucm_mra cmd;
930         const void *data = NULL;
931         int result;
932
933         if (copy_from_user(&cmd, inbuf, sizeof(cmd)))
934                 return -EFAULT;
935
936         result = ib_ucm_alloc_data(&data, cmd.data, cmd.len);
937         if (result)
938                 return result;
939
940         ctx = ib_ucm_ctx_get(file, cmd.id);
941         if (!IS_ERR(ctx)) {
942                 result = ib_send_cm_mra(ctx->cm_id, cmd.timeout, data, cmd.len);
943                 ib_ucm_ctx_put(ctx);
944         } else
945                 result = PTR_ERR(ctx);
946
947         kfree(data);
948         return result;
949 }
950
951 static ssize_t ib_ucm_send_lap(struct ib_ucm_file *file,
952                                const char __user *inbuf,
953                                int in_len, int out_len)
954 {
955         struct ib_ucm_context *ctx;
956         struct ib_sa_path_rec *path = NULL;
957         struct ib_ucm_lap cmd;
958         const void *data = NULL;
959         int result;
960
961         if (copy_from_user(&cmd, inbuf, sizeof(cmd)))
962                 return -EFAULT;
963
964         result = ib_ucm_alloc_data(&data, cmd.data, cmd.len);
965         if (result)
966                 goto done;
967
968         result = ib_ucm_path_get(&path, cmd.path);
969         if (result)
970                 goto done;
971
972         ctx = ib_ucm_ctx_get(file, cmd.id);
973         if (!IS_ERR(ctx)) {
974                 result = ib_send_cm_lap(ctx->cm_id, path, data, cmd.len);
975                 ib_ucm_ctx_put(ctx);
976         } else
977                 result = PTR_ERR(ctx);
978
979 done:
980         kfree(data);
981         kfree(path);
982         return result;
983 }
984
985 static ssize_t ib_ucm_send_sidr_req(struct ib_ucm_file *file,
986                                     const char __user *inbuf,
987                                     int in_len, int out_len)
988 {
989         struct ib_cm_sidr_req_param param;
990         struct ib_ucm_context *ctx;
991         struct ib_ucm_sidr_req cmd;
992         int result;
993
994         param.private_data = NULL;
995         param.path = NULL;
996
997         if (copy_from_user(&cmd, inbuf, sizeof(cmd)))
998                 return -EFAULT;
999
1000         result = ib_ucm_alloc_data(&param.private_data, cmd.data, cmd.len);
1001         if (result)
1002                 goto done;
1003
1004         result = ib_ucm_path_get(&param.path, cmd.path);
1005         if (result)
1006                 goto done;
1007
1008         param.private_data_len = cmd.len;
1009         param.service_id       = cmd.sid;
1010         param.timeout_ms       = cmd.timeout;
1011         param.max_cm_retries   = cmd.max_cm_retries;
1012         param.pkey             = cmd.pkey;
1013
1014         ctx = ib_ucm_ctx_get(file, cmd.id);
1015         if (!IS_ERR(ctx)) {
1016                 result = ib_send_cm_sidr_req(ctx->cm_id, &param);
1017                 ib_ucm_ctx_put(ctx);
1018         } else
1019                 result = PTR_ERR(ctx);
1020
1021 done:
1022         kfree(param.private_data);
1023         kfree(param.path);
1024         return result;
1025 }
1026
1027 static ssize_t ib_ucm_send_sidr_rep(struct ib_ucm_file *file,
1028                                     const char __user *inbuf,
1029                                     int in_len, int out_len)
1030 {
1031         struct ib_cm_sidr_rep_param param;
1032         struct ib_ucm_sidr_rep cmd;
1033         struct ib_ucm_context *ctx;
1034         int result;
1035
1036         param.info = NULL;
1037
1038         if (copy_from_user(&cmd, inbuf, sizeof(cmd)))
1039                 return -EFAULT;
1040
1041         result = ib_ucm_alloc_data(&param.private_data,
1042                                    cmd.data, cmd.data_len);
1043         if (result)
1044                 goto done;
1045
1046         result = ib_ucm_alloc_data(&param.info, cmd.info, cmd.info_len);
1047         if (result)
1048                 goto done;
1049
1050         param.qp_num            = cmd.qpn;
1051         param.qkey              = cmd.qkey;
1052         param.status            = cmd.status;
1053         param.info_length       = cmd.info_len;
1054         param.private_data_len  = cmd.data_len;
1055
1056         ctx = ib_ucm_ctx_get(file, cmd.id);
1057         if (!IS_ERR(ctx)) {
1058                 result = ib_send_cm_sidr_rep(ctx->cm_id, &param);
1059                 ib_ucm_ctx_put(ctx);
1060         } else
1061                 result = PTR_ERR(ctx);
1062
1063 done:
1064         kfree(param.private_data);
1065         kfree(param.info);
1066         return result;
1067 }
1068
1069 static ssize_t (*ucm_cmd_table[])(struct ib_ucm_file *file,
1070                                   const char __user *inbuf,
1071                                   int in_len, int out_len) = {
1072         [IB_USER_CM_CMD_CREATE_ID]     = ib_ucm_create_id,
1073         [IB_USER_CM_CMD_DESTROY_ID]    = ib_ucm_destroy_id,
1074         [IB_USER_CM_CMD_ATTR_ID]       = ib_ucm_attr_id,
1075         [IB_USER_CM_CMD_LISTEN]        = ib_ucm_listen,
1076         [IB_USER_CM_CMD_ESTABLISH]     = ib_ucm_establish,
1077         [IB_USER_CM_CMD_SEND_REQ]      = ib_ucm_send_req,
1078         [IB_USER_CM_CMD_SEND_REP]      = ib_ucm_send_rep,
1079         [IB_USER_CM_CMD_SEND_RTU]      = ib_ucm_send_rtu,
1080         [IB_USER_CM_CMD_SEND_DREQ]     = ib_ucm_send_dreq,
1081         [IB_USER_CM_CMD_SEND_DREP]     = ib_ucm_send_drep,
1082         [IB_USER_CM_CMD_SEND_REJ]      = ib_ucm_send_rej,
1083         [IB_USER_CM_CMD_SEND_MRA]      = ib_ucm_send_mra,
1084         [IB_USER_CM_CMD_SEND_LAP]      = ib_ucm_send_lap,
1085         [IB_USER_CM_CMD_SEND_APR]      = ib_ucm_send_apr,
1086         [IB_USER_CM_CMD_SEND_SIDR_REQ] = ib_ucm_send_sidr_req,
1087         [IB_USER_CM_CMD_SEND_SIDR_REP] = ib_ucm_send_sidr_rep,
1088         [IB_USER_CM_CMD_EVENT]         = ib_ucm_event,
1089 };
1090
1091 static ssize_t ib_ucm_write(struct file *filp, const char __user *buf,
1092                             size_t len, loff_t *pos)
1093 {
1094         struct ib_ucm_file *file = filp->private_data;
1095         struct ib_ucm_cmd_hdr hdr;
1096         ssize_t result;
1097
1098         if (len < sizeof(hdr))
1099                 return -EINVAL;
1100
1101         if (copy_from_user(&hdr, buf, sizeof(hdr)))
1102                 return -EFAULT;
1103
1104         ucm_dbg("Write. cmd <%d> in <%d> out <%d> len <%Zu>\n",
1105                 hdr.cmd, hdr.in, hdr.out, len);
1106
1107         if (hdr.cmd < 0 || hdr.cmd >= ARRAY_SIZE(ucm_cmd_table))
1108                 return -EINVAL;
1109
1110         if (hdr.in + sizeof(hdr) > len)
1111                 return -EINVAL;
1112
1113         result = ucm_cmd_table[hdr.cmd](file, buf + sizeof(hdr),
1114                                         hdr.in, hdr.out);
1115         if (!result)
1116                 result = len;
1117
1118         return result;
1119 }
1120
1121 static unsigned int ib_ucm_poll(struct file *filp,
1122                                 struct poll_table_struct *wait)
1123 {
1124         struct ib_ucm_file *file = filp->private_data;
1125         unsigned int mask = 0;
1126
1127         poll_wait(filp, &file->poll_wait, wait);
1128
1129         if (!list_empty(&file->events))
1130                 mask = POLLIN | POLLRDNORM;
1131
1132         return mask;
1133 }
1134
1135 static int ib_ucm_open(struct inode *inode, struct file *filp)
1136 {
1137         struct ib_ucm_file *file;
1138
1139         file = kmalloc(sizeof(*file), GFP_KERNEL);
1140         if (!file)
1141                 return -ENOMEM;
1142
1143         INIT_LIST_HEAD(&file->events);
1144         INIT_LIST_HEAD(&file->ctxs);
1145         init_waitqueue_head(&file->poll_wait);
1146
1147         init_MUTEX(&file->mutex);
1148
1149         filp->private_data = file;
1150         file->filp = filp;
1151
1152         ucm_dbg("Created struct\n");
1153
1154         return 0;
1155 }
1156
1157 static int ib_ucm_close(struct inode *inode, struct file *filp)
1158 {
1159         struct ib_ucm_file *file = filp->private_data;
1160         struct ib_ucm_context *ctx;
1161
1162         down(&file->mutex);
1163         while (!list_empty(&file->ctxs)) {
1164
1165                 ctx = list_entry(file->ctxs.next,
1166                                  struct ib_ucm_context, file_list);
1167
1168                 up(&file->mutex);
1169                 ib_ucm_destroy_ctx(file, ctx->id);
1170                 down(&file->mutex);
1171         }
1172         up(&file->mutex);
1173         kfree(file);
1174         return 0;
1175 }
1176
1177 static struct file_operations ib_ucm_fops = {
1178         .owner   = THIS_MODULE,
1179         .open    = ib_ucm_open,
1180         .release = ib_ucm_close,
1181         .write   = ib_ucm_write,
1182         .poll    = ib_ucm_poll,
1183 };
1184
1185
1186 static struct class *ib_ucm_class;
1187 static struct cdev        ib_ucm_cdev;
1188
1189 static int __init ib_ucm_init(void)
1190 {
1191         int result;
1192
1193         result = register_chrdev_region(IB_UCM_DEV, 1, "infiniband_cm");
1194         if (result) {
1195                 ucm_dbg("Error <%d> registering dev\n", result);
1196                 goto err_chr;
1197         }
1198
1199         cdev_init(&ib_ucm_cdev, &ib_ucm_fops);
1200
1201         result = cdev_add(&ib_ucm_cdev, IB_UCM_DEV, 1);
1202         if (result) {
1203                 ucm_dbg("Error <%d> adding cdev\n", result);
1204                 goto err_cdev;
1205         }
1206
1207         ib_ucm_class = class_create(THIS_MODULE, "infiniband_cm");
1208         if (IS_ERR(ib_ucm_class)) {
1209                 result = PTR_ERR(ib_ucm_class);
1210                 ucm_dbg("Error <%d> creating class\n", result);
1211                 goto err_class;
1212         }
1213
1214         class_device_create(ib_ucm_class, IB_UCM_DEV, NULL, "ucm");
1215
1216         idr_init(&ctx_id_table);
1217         init_MUTEX(&ctx_id_mutex);
1218
1219         return 0;
1220 err_class:
1221         cdev_del(&ib_ucm_cdev);
1222 err_cdev:
1223         unregister_chrdev_region(IB_UCM_DEV, 1);
1224 err_chr:
1225         return result;
1226 }
1227
1228 static void __exit ib_ucm_cleanup(void)
1229 {
1230         class_device_destroy(ib_ucm_class, IB_UCM_DEV);
1231         class_destroy(ib_ucm_class);
1232         cdev_del(&ib_ucm_cdev);
1233         unregister_chrdev_region(IB_UCM_DEV, 1);
1234 }
1235
1236 module_init(ib_ucm_init);
1237 module_exit(ib_ucm_cleanup);