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
34#include <linux/completion.h>
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/sched.h>
42#include <linux/file.h>
43#include <linux/mount.h>
44#include <linux/cdev.h>
45#include <linux/idr.h>
46#include <linux/mutex.h>
47#include <linux/slab.h>
48
49#include <asm/uaccess.h>
50
51#include <rdma/ib_cm.h>
52#include <rdma/ib_user_cm.h>
53#include <rdma/ib_marshall.h>
54
55MODULE_AUTHOR("Libor Michalek");
56MODULE_DESCRIPTION("InfiniBand userspace Connection Manager access");
57MODULE_LICENSE("Dual BSD/GPL");
58
59struct ib_ucm_device {
60	int			devnum;
61	struct cdev		cdev;
62	struct device		dev;
63	struct ib_device	*ib_dev;
64};
65
66struct ib_ucm_file {
67	struct mutex file_mutex;
68	struct file *filp;
69	struct ib_ucm_device *device;
70
71	struct list_head  ctxs;
72	struct list_head  events;
73	wait_queue_head_t poll_wait;
74};
75
76struct ib_ucm_context {
77	int                 id;
78	struct completion   comp;
79	atomic_t            ref;
80	int		    events_reported;
81
82	struct ib_ucm_file *file;
83	struct ib_cm_id    *cm_id;
84	__u64		   uid;
85
86	struct list_head    events;    /* list of pending events. */
87	struct list_head    file_list; /* member in file ctx list */
88};
89
90struct ib_ucm_event {
91	struct ib_ucm_context *ctx;
92	struct list_head file_list; /* member in file event list */
93	struct list_head ctx_list;  /* member in ctx event list */
94
95	struct ib_cm_id *cm_id;
96	struct ib_ucm_event_resp resp;
97	void *data;
98	void *info;
99	int data_len;
100	int info_len;
101};
102
103enum {
104	IB_UCM_MAJOR = 231,
105	IB_UCM_BASE_MINOR = 224,
106	IB_UCM_MAX_DEVICES = 32
107};
108
109#define IB_UCM_BASE_DEV MKDEV(IB_UCM_MAJOR, IB_UCM_BASE_MINOR)
110
111static void ib_ucm_add_one(struct ib_device *device);
112static void ib_ucm_remove_one(struct ib_device *device);
113
114static struct ib_client ucm_client = {
115	.name   = "ucm",
116	.add    = ib_ucm_add_one,
117	.remove = ib_ucm_remove_one
118};
119
120static DEFINE_MUTEX(ctx_id_mutex);
121static DEFINE_IDR(ctx_id_table);
122static DECLARE_BITMAP(dev_map, IB_UCM_MAX_DEVICES);
123
124static struct ib_ucm_context *ib_ucm_ctx_get(struct ib_ucm_file *file, int id)
125{
126	struct ib_ucm_context *ctx;
127
128	mutex_lock(&ctx_id_mutex);
129	ctx = idr_find(&ctx_id_table, id);
130	if (!ctx)
131		ctx = ERR_PTR(-ENOENT);
132	else if (ctx->file != file)
133		ctx = ERR_PTR(-EINVAL);
134	else
135		atomic_inc(&ctx->ref);
136	mutex_unlock(&ctx_id_mutex);
137
138	return ctx;
139}
140
141static void ib_ucm_ctx_put(struct ib_ucm_context *ctx)
142{
143	if (atomic_dec_and_test(&ctx->ref))
144		complete(&ctx->comp);
145}
146
147static inline int ib_ucm_new_cm_id(int event)
148{
149	return event == IB_CM_REQ_RECEIVED || event == IB_CM_SIDR_REQ_RECEIVED;
150}
151
152static void ib_ucm_cleanup_events(struct ib_ucm_context *ctx)
153{
154	struct ib_ucm_event *uevent;
155
156	mutex_lock(&ctx->file->file_mutex);
157	list_del(&ctx->file_list);
158	while (!list_empty(&ctx->events)) {
159
160		uevent = list_entry(ctx->events.next,
161				    struct ib_ucm_event, ctx_list);
162		list_del(&uevent->file_list);
163		list_del(&uevent->ctx_list);
164		mutex_unlock(&ctx->file->file_mutex);
165
166		/* clear incoming connections. */
167		if (ib_ucm_new_cm_id(uevent->resp.event))
168			ib_destroy_cm_id(uevent->cm_id);
169
170		kfree(uevent);
171		mutex_lock(&ctx->file->file_mutex);
172	}
173	mutex_unlock(&ctx->file->file_mutex);
174}
175
176static struct ib_ucm_context *ib_ucm_ctx_alloc(struct ib_ucm_file *file)
177{
178	struct ib_ucm_context *ctx;
179
180	ctx = kzalloc(sizeof *ctx, GFP_KERNEL);
181	if (!ctx)
182		return NULL;
183
184	atomic_set(&ctx->ref, 1);
185	init_completion(&ctx->comp);
186	ctx->file = file;
187	INIT_LIST_HEAD(&ctx->events);
188
189	mutex_lock(&ctx_id_mutex);
190	ctx->id = idr_alloc(&ctx_id_table, ctx, 0, 0, GFP_KERNEL);
191	mutex_unlock(&ctx_id_mutex);
192	if (ctx->id < 0)
193		goto error;
194
195	list_add_tail(&ctx->file_list, &file->ctxs);
196	return ctx;
197
198error:
199	kfree(ctx);
200	return NULL;
201}
202
203static void ib_ucm_event_req_get(struct ib_ucm_req_event_resp *ureq,
204				 struct ib_cm_req_event_param *kreq)
205{
206	ureq->remote_ca_guid             = kreq->remote_ca_guid;
207	ureq->remote_qkey                = kreq->remote_qkey;
208	ureq->remote_qpn                 = kreq->remote_qpn;
209	ureq->qp_type                    = kreq->qp_type;
210	ureq->starting_psn               = kreq->starting_psn;
211	ureq->responder_resources        = kreq->responder_resources;
212	ureq->initiator_depth            = kreq->initiator_depth;
213	ureq->local_cm_response_timeout  = kreq->local_cm_response_timeout;
214	ureq->flow_control               = kreq->flow_control;
215	ureq->remote_cm_response_timeout = kreq->remote_cm_response_timeout;
216	ureq->retry_count                = kreq->retry_count;
217	ureq->rnr_retry_count            = kreq->rnr_retry_count;
218	ureq->srq                        = kreq->srq;
219	ureq->port			 = kreq->port;
220
221	ib_copy_path_rec_to_user(&ureq->primary_path, kreq->primary_path);
222	if (kreq->alternate_path)
223		ib_copy_path_rec_to_user(&ureq->alternate_path,
224					 kreq->alternate_path);
225}
226
227static void ib_ucm_event_rep_get(struct ib_ucm_rep_event_resp *urep,
228				 struct ib_cm_rep_event_param *krep)
229{
230	urep->remote_ca_guid      = krep->remote_ca_guid;
231	urep->remote_qkey         = krep->remote_qkey;
232	urep->remote_qpn          = krep->remote_qpn;
233	urep->starting_psn        = krep->starting_psn;
234	urep->responder_resources = krep->responder_resources;
235	urep->initiator_depth     = krep->initiator_depth;
236	urep->target_ack_delay    = krep->target_ack_delay;
237	urep->failover_accepted   = krep->failover_accepted;
238	urep->flow_control        = krep->flow_control;
239	urep->rnr_retry_count     = krep->rnr_retry_count;
240	urep->srq                 = krep->srq;
241}
242
243static void ib_ucm_event_sidr_rep_get(struct ib_ucm_sidr_rep_event_resp *urep,
244				      struct ib_cm_sidr_rep_event_param *krep)
245{
246	urep->status = krep->status;
247	urep->qkey   = krep->qkey;
248	urep->qpn    = krep->qpn;
249};
250
251static int ib_ucm_event_process(struct ib_cm_event *evt,
252				struct ib_ucm_event *uvt)
253{
254	void *info = NULL;
255
256	switch (evt->event) {
257	case IB_CM_REQ_RECEIVED:
258		ib_ucm_event_req_get(&uvt->resp.u.req_resp,
259				     &evt->param.req_rcvd);
260		uvt->data_len      = IB_CM_REQ_PRIVATE_DATA_SIZE;
261		uvt->resp.present  = IB_UCM_PRES_PRIMARY;
262		uvt->resp.present |= (evt->param.req_rcvd.alternate_path ?
263				      IB_UCM_PRES_ALTERNATE : 0);
264		break;
265	case IB_CM_REP_RECEIVED:
266		ib_ucm_event_rep_get(&uvt->resp.u.rep_resp,
267				     &evt->param.rep_rcvd);
268		uvt->data_len = IB_CM_REP_PRIVATE_DATA_SIZE;
269		break;
270	case IB_CM_RTU_RECEIVED:
271		uvt->data_len = IB_CM_RTU_PRIVATE_DATA_SIZE;
272		uvt->resp.u.send_status = evt->param.send_status;
273		break;
274	case IB_CM_DREQ_RECEIVED:
275		uvt->data_len = IB_CM_DREQ_PRIVATE_DATA_SIZE;
276		uvt->resp.u.send_status = evt->param.send_status;
277		break;
278	case IB_CM_DREP_RECEIVED:
279		uvt->data_len = IB_CM_DREP_PRIVATE_DATA_SIZE;
280		uvt->resp.u.send_status = evt->param.send_status;
281		break;
282	case IB_CM_MRA_RECEIVED:
283		uvt->resp.u.mra_resp.timeout =
284					evt->param.mra_rcvd.service_timeout;
285		uvt->data_len = IB_CM_MRA_PRIVATE_DATA_SIZE;
286		break;
287	case IB_CM_REJ_RECEIVED:
288		uvt->resp.u.rej_resp.reason = evt->param.rej_rcvd.reason;
289		uvt->data_len = IB_CM_REJ_PRIVATE_DATA_SIZE;
290		uvt->info_len = evt->param.rej_rcvd.ari_length;
291		info	      = evt->param.rej_rcvd.ari;
292		break;
293	case IB_CM_LAP_RECEIVED:
294		ib_copy_path_rec_to_user(&uvt->resp.u.lap_resp.path,
295					 evt->param.lap_rcvd.alternate_path);
296		uvt->data_len = IB_CM_LAP_PRIVATE_DATA_SIZE;
297		uvt->resp.present = IB_UCM_PRES_ALTERNATE;
298		break;
299	case IB_CM_APR_RECEIVED:
300		uvt->resp.u.apr_resp.status = evt->param.apr_rcvd.ap_status;
301		uvt->data_len = IB_CM_APR_PRIVATE_DATA_SIZE;
302		uvt->info_len = evt->param.apr_rcvd.info_len;
303		info	      = evt->param.apr_rcvd.apr_info;
304		break;
305	case IB_CM_SIDR_REQ_RECEIVED:
306		uvt->resp.u.sidr_req_resp.pkey =
307					evt->param.sidr_req_rcvd.pkey;
308		uvt->resp.u.sidr_req_resp.port =
309					evt->param.sidr_req_rcvd.port;
310		uvt->data_len = IB_CM_SIDR_REQ_PRIVATE_DATA_SIZE;
311		break;
312	case IB_CM_SIDR_REP_RECEIVED:
313		ib_ucm_event_sidr_rep_get(&uvt->resp.u.sidr_rep_resp,
314					  &evt->param.sidr_rep_rcvd);
315		uvt->data_len = IB_CM_SIDR_REP_PRIVATE_DATA_SIZE;
316		uvt->info_len = evt->param.sidr_rep_rcvd.info_len;
317		info	      = evt->param.sidr_rep_rcvd.info;
318		break;
319	default:
320		uvt->resp.u.send_status = evt->param.send_status;
321		break;
322	}
323
324	if (uvt->data_len) {
325		uvt->data = kmemdup(evt->private_data, uvt->data_len, GFP_KERNEL);
326		if (!uvt->data)
327			goto err1;
328
329		uvt->resp.present |= IB_UCM_PRES_DATA;
330	}
331
332	if (uvt->info_len) {
333		uvt->info = kmemdup(info, uvt->info_len, GFP_KERNEL);
334		if (!uvt->info)
335			goto err2;
336
337		uvt->resp.present |= IB_UCM_PRES_INFO;
338	}
339	return 0;
340
341err2:
342	kfree(uvt->data);
343err1:
344	return -ENOMEM;
345}
346
347static int ib_ucm_event_handler(struct ib_cm_id *cm_id,
348				struct ib_cm_event *event)
349{
350	struct ib_ucm_event *uevent;
351	struct ib_ucm_context *ctx;
352	int result = 0;
353
354	ctx = cm_id->context;
355
356	uevent = kzalloc(sizeof *uevent, GFP_KERNEL);
357	if (!uevent)
358		goto err1;
359
360	uevent->ctx = ctx;
361	uevent->cm_id = cm_id;
362	uevent->resp.uid = ctx->uid;
363	uevent->resp.id = ctx->id;
364	uevent->resp.event = event->event;
365
366	result = ib_ucm_event_process(event, uevent);
367	if (result)
368		goto err2;
369
370	mutex_lock(&ctx->file->file_mutex);
371	list_add_tail(&uevent->file_list, &ctx->file->events);
372	list_add_tail(&uevent->ctx_list, &ctx->events);
373	wake_up_interruptible(&ctx->file->poll_wait);
374	mutex_unlock(&ctx->file->file_mutex);
375	return 0;
376
377err2:
378	kfree(uevent);
379err1:
380	/* Destroy new cm_id's */
381	return ib_ucm_new_cm_id(event->event);
382}
383
384static ssize_t ib_ucm_event(struct ib_ucm_file *file,
385			    const char __user *inbuf,
386			    int in_len, int out_len)
387{
388	struct ib_ucm_context *ctx;
389	struct ib_ucm_event_get cmd;
390	struct ib_ucm_event *uevent;
391	int result = 0;
392
393	if (out_len < sizeof(struct ib_ucm_event_resp))
394		return -ENOSPC;
395
396	if (copy_from_user(&cmd, inbuf, sizeof(cmd)))
397		return -EFAULT;
398
399	mutex_lock(&file->file_mutex);
400	while (list_empty(&file->events)) {
401		mutex_unlock(&file->file_mutex);
402
403		if (file->filp->f_flags & O_NONBLOCK)
404			return -EAGAIN;
405
406		if (wait_event_interruptible(file->poll_wait,
407					     !list_empty(&file->events)))
408			return -ERESTARTSYS;
409
410		mutex_lock(&file->file_mutex);
411	}
412
413	uevent = list_entry(file->events.next, struct ib_ucm_event, file_list);
414
415	if (ib_ucm_new_cm_id(uevent->resp.event)) {
416		ctx = ib_ucm_ctx_alloc(file);
417		if (!ctx) {
418			result = -ENOMEM;
419			goto done;
420		}
421
422		ctx->cm_id = uevent->cm_id;
423		ctx->cm_id->context = ctx;
424		uevent->resp.id = ctx->id;
425	}
426
427	if (copy_to_user((void __user *)(unsigned long)cmd.response,
428			 &uevent->resp, sizeof(uevent->resp))) {
429		result = -EFAULT;
430		goto done;
431	}
432
433	if (uevent->data) {
434		if (cmd.data_len < uevent->data_len) {
435			result = -ENOMEM;
436			goto done;
437		}
438		if (copy_to_user((void __user *)(unsigned long)cmd.data,
439				 uevent->data, uevent->data_len)) {
440			result = -EFAULT;
441			goto done;
442		}
443	}
444
445	if (uevent->info) {
446		if (cmd.info_len < uevent->info_len) {
447			result = -ENOMEM;
448			goto done;
449		}
450		if (copy_to_user((void __user *)(unsigned long)cmd.info,
451				 uevent->info, uevent->info_len)) {
452			result = -EFAULT;
453			goto done;
454		}
455	}
456
457	list_del(&uevent->file_list);
458	list_del(&uevent->ctx_list);
459	uevent->ctx->events_reported++;
460
461	kfree(uevent->data);
462	kfree(uevent->info);
463	kfree(uevent);
464done:
465	mutex_unlock(&file->file_mutex);
466	return result;
467}
468
469static ssize_t ib_ucm_create_id(struct ib_ucm_file *file,
470				const char __user *inbuf,
471				int in_len, int out_len)
472{
473	struct ib_ucm_create_id cmd;
474	struct ib_ucm_create_id_resp resp;
475	struct ib_ucm_context *ctx;
476	int result;
477
478	if (out_len < sizeof(resp))
479		return -ENOSPC;
480
481	if (copy_from_user(&cmd, inbuf, sizeof(cmd)))
482		return -EFAULT;
483
484	mutex_lock(&file->file_mutex);
485	ctx = ib_ucm_ctx_alloc(file);
486	mutex_unlock(&file->file_mutex);
487	if (!ctx)
488		return -ENOMEM;
489
490	ctx->uid = cmd.uid;
491	ctx->cm_id = ib_create_cm_id(file->device->ib_dev,
492				     ib_ucm_event_handler, ctx);
493	if (IS_ERR(ctx->cm_id)) {
494		result = PTR_ERR(ctx->cm_id);
495		goto err1;
496	}
497
498	resp.id = ctx->id;
499	if (copy_to_user((void __user *)(unsigned long)cmd.response,
500			 &resp, sizeof(resp))) {
501		result = -EFAULT;
502		goto err2;
503	}
504	return 0;
505
506err2:
507	ib_destroy_cm_id(ctx->cm_id);
508err1:
509	mutex_lock(&ctx_id_mutex);
510	idr_remove(&ctx_id_table, ctx->id);
511	mutex_unlock(&ctx_id_mutex);
512	kfree(ctx);
513	return result;
514}
515
516static ssize_t ib_ucm_destroy_id(struct ib_ucm_file *file,
517				 const char __user *inbuf,
518				 int in_len, int out_len)
519{
520	struct ib_ucm_destroy_id cmd;
521	struct ib_ucm_destroy_id_resp resp;
522	struct ib_ucm_context *ctx;
523	int result = 0;
524
525	if (out_len < sizeof(resp))
526		return -ENOSPC;
527
528	if (copy_from_user(&cmd, inbuf, sizeof(cmd)))
529		return -EFAULT;
530
531	mutex_lock(&ctx_id_mutex);
532	ctx = idr_find(&ctx_id_table, cmd.id);
533	if (!ctx)
534		ctx = ERR_PTR(-ENOENT);
535	else if (ctx->file != file)
536		ctx = ERR_PTR(-EINVAL);
537	else
538		idr_remove(&ctx_id_table, ctx->id);
539	mutex_unlock(&ctx_id_mutex);
540
541	if (IS_ERR(ctx))
542		return PTR_ERR(ctx);
543
544	ib_ucm_ctx_put(ctx);
545	wait_for_completion(&ctx->comp);
546
547	/* No new events will be generated after destroying the cm_id. */
548	ib_destroy_cm_id(ctx->cm_id);
549	/* Cleanup events not yet reported to the user. */
550	ib_ucm_cleanup_events(ctx);
551
552	resp.events_reported = ctx->events_reported;
553	if (copy_to_user((void __user *)(unsigned long)cmd.response,
554			 &resp, sizeof(resp)))
555		result = -EFAULT;
556
557	kfree(ctx);
558	return result;
559}
560
561static ssize_t ib_ucm_attr_id(struct ib_ucm_file *file,
562			      const char __user *inbuf,
563			      int in_len, int out_len)
564{
565	struct ib_ucm_attr_id_resp resp;
566	struct ib_ucm_attr_id cmd;
567	struct ib_ucm_context *ctx;
568	int result = 0;
569
570	if (out_len < sizeof(resp))
571		return -ENOSPC;
572
573	if (copy_from_user(&cmd, inbuf, sizeof(cmd)))
574		return -EFAULT;
575
576	ctx = ib_ucm_ctx_get(file, cmd.id);
577	if (IS_ERR(ctx))
578		return PTR_ERR(ctx);
579
580	resp.service_id   = ctx->cm_id->service_id;
581	resp.service_mask = ctx->cm_id->service_mask;
582	resp.local_id     = ctx->cm_id->local_id;
583	resp.remote_id    = ctx->cm_id->remote_id;
584
585	if (copy_to_user((void __user *)(unsigned long)cmd.response,
586			 &resp, sizeof(resp)))
587		result = -EFAULT;
588
589	ib_ucm_ctx_put(ctx);
590	return result;
591}
592
593static ssize_t ib_ucm_init_qp_attr(struct ib_ucm_file *file,
594				   const char __user *inbuf,
595				   int in_len, int out_len)
596{
597	struct ib_uverbs_qp_attr resp;
598	struct ib_ucm_init_qp_attr cmd;
599	struct ib_ucm_context *ctx;
600	struct ib_qp_attr qp_attr;
601	int result = 0;
602
603	if (out_len < sizeof(resp))
604		return -ENOSPC;
605
606	if (copy_from_user(&cmd, inbuf, sizeof(cmd)))
607		return -EFAULT;
608
609	ctx = ib_ucm_ctx_get(file, cmd.id);
610	if (IS_ERR(ctx))
611		return PTR_ERR(ctx);
612
613	resp.qp_attr_mask = 0;
614	memset(&qp_attr, 0, sizeof qp_attr);
615	qp_attr.qp_state = cmd.qp_state;
616	result = ib_cm_init_qp_attr(ctx->cm_id, &qp_attr, &resp.qp_attr_mask);
617	if (result)
618		goto out;
619
620	ib_copy_qp_attr_to_user(&resp, &qp_attr);
621
622	if (copy_to_user((void __user *)(unsigned long)cmd.response,
623			 &resp, sizeof(resp)))
624		result = -EFAULT;
625
626out:
627	ib_ucm_ctx_put(ctx);
628	return result;
629}
630
631static int ucm_validate_listen(__be64 service_id, __be64 service_mask)
632{
633	service_id &= service_mask;
634
635	if (((service_id & IB_CMA_SERVICE_ID_MASK) == IB_CMA_SERVICE_ID) ||
636	    ((service_id & IB_SDP_SERVICE_ID_MASK) == IB_SDP_SERVICE_ID))
637		return -EINVAL;
638
639	return 0;
640}
641
642static ssize_t ib_ucm_listen(struct ib_ucm_file *file,
643			     const char __user *inbuf,
644			     int in_len, int out_len)
645{
646	struct ib_ucm_listen cmd;
647	struct ib_ucm_context *ctx;
648	int result;
649
650	if (copy_from_user(&cmd, inbuf, sizeof(cmd)))
651		return -EFAULT;
652
653	ctx = ib_ucm_ctx_get(file, cmd.id);
654	if (IS_ERR(ctx))
655		return PTR_ERR(ctx);
656
657	result = ucm_validate_listen(cmd.service_id, cmd.service_mask);
658	if (result)
659		goto out;
660
661	result = ib_cm_listen(ctx->cm_id, cmd.service_id, cmd.service_mask,
662			      NULL);
663out:
664	ib_ucm_ctx_put(ctx);
665	return result;
666}
667
668static ssize_t ib_ucm_notify(struct ib_ucm_file *file,
669			     const char __user *inbuf,
670			     int in_len, int out_len)
671{
672	struct ib_ucm_notify cmd;
673	struct ib_ucm_context *ctx;
674	int result;
675
676	if (copy_from_user(&cmd, inbuf, sizeof(cmd)))
677		return -EFAULT;
678
679	ctx = ib_ucm_ctx_get(file, cmd.id);
680	if (IS_ERR(ctx))
681		return PTR_ERR(ctx);
682
683	result = ib_cm_notify(ctx->cm_id, (enum ib_event_type) cmd.event);
684	ib_ucm_ctx_put(ctx);
685	return result;
686}
687
688static int ib_ucm_alloc_data(const void **dest, u64 src, u32 len)
689{
690	void *data;
691
692	*dest = NULL;
693
694	if (!len)
695		return 0;
696
697	data = memdup_user((void __user *)(unsigned long)src, len);
698	if (IS_ERR(data))
699		return PTR_ERR(data);
700
701	*dest = data;
702	return 0;
703}
704
705static int ib_ucm_path_get(struct ib_sa_path_rec **path, u64 src)
706{
707	struct ib_user_path_rec upath;
708	struct ib_sa_path_rec  *sa_path;
709
710	*path = NULL;
711
712	if (!src)
713		return 0;
714
715	sa_path = kmalloc(sizeof(*sa_path), GFP_KERNEL);
716	if (!sa_path)
717		return -ENOMEM;
718
719	if (copy_from_user(&upath, (void __user *)(unsigned long)src,
720			   sizeof(upath))) {
721
722		kfree(sa_path);
723		return -EFAULT;
724	}
725
726	ib_copy_path_rec_from_user(sa_path, &upath);
727	*path = sa_path;
728	return 0;
729}
730
731static ssize_t ib_ucm_send_req(struct ib_ucm_file *file,
732			       const char __user *inbuf,
733			       int in_len, int out_len)
734{
735	struct ib_cm_req_param param;
736	struct ib_ucm_context *ctx;
737	struct ib_ucm_req cmd;
738	int result;
739
740	param.private_data   = NULL;
741	param.primary_path   = NULL;
742	param.alternate_path = NULL;
743
744	if (copy_from_user(&cmd, inbuf, sizeof(cmd)))
745		return -EFAULT;
746
747	result = ib_ucm_alloc_data(&param.private_data, cmd.data, cmd.len);
748	if (result)
749		goto done;
750
751	result = ib_ucm_path_get(&param.primary_path, cmd.primary_path);
752	if (result)
753		goto done;
754
755	result = ib_ucm_path_get(&param.alternate_path, cmd.alternate_path);
756	if (result)
757		goto done;
758
759	param.private_data_len           = cmd.len;
760	param.service_id                 = cmd.sid;
761	param.qp_num                     = cmd.qpn;
762	param.qp_type                    = cmd.qp_type;
763	param.starting_psn               = cmd.psn;
764	param.peer_to_peer               = cmd.peer_to_peer;
765	param.responder_resources        = cmd.responder_resources;
766	param.initiator_depth            = cmd.initiator_depth;
767	param.remote_cm_response_timeout = cmd.remote_cm_response_timeout;
768	param.flow_control               = cmd.flow_control;
769	param.local_cm_response_timeout  = cmd.local_cm_response_timeout;
770	param.retry_count                = cmd.retry_count;
771	param.rnr_retry_count            = cmd.rnr_retry_count;
772	param.max_cm_retries             = cmd.max_cm_retries;
773	param.srq                        = cmd.srq;
774
775	ctx = ib_ucm_ctx_get(file, cmd.id);
776	if (!IS_ERR(ctx)) {
777		result = ib_send_cm_req(ctx->cm_id, &param);
778		ib_ucm_ctx_put(ctx);
779	} else
780		result = PTR_ERR(ctx);
781
782done:
783	kfree(param.private_data);
784	kfree(param.primary_path);
785	kfree(param.alternate_path);
786	return result;
787}
788
789static ssize_t ib_ucm_send_rep(struct ib_ucm_file *file,
790			       const char __user *inbuf,
791			       int in_len, int out_len)
792{
793	struct ib_cm_rep_param param;
794	struct ib_ucm_context *ctx;
795	struct ib_ucm_rep cmd;
796	int result;
797
798	param.private_data = NULL;
799
800	if (copy_from_user(&cmd, inbuf, sizeof(cmd)))
801		return -EFAULT;
802
803	result = ib_ucm_alloc_data(&param.private_data, cmd.data, cmd.len);
804	if (result)
805		return result;
806
807	param.qp_num              = cmd.qpn;
808	param.starting_psn        = cmd.psn;
809	param.private_data_len    = cmd.len;
810	param.responder_resources = cmd.responder_resources;
811	param.initiator_depth     = cmd.initiator_depth;
812	param.failover_accepted   = cmd.failover_accepted;
813	param.flow_control        = cmd.flow_control;
814	param.rnr_retry_count     = cmd.rnr_retry_count;
815	param.srq                 = cmd.srq;
816
817	ctx = ib_ucm_ctx_get(file, cmd.id);
818	if (!IS_ERR(ctx)) {
819		ctx->uid = cmd.uid;
820		result = ib_send_cm_rep(ctx->cm_id, &param);
821		ib_ucm_ctx_put(ctx);
822	} else
823		result = PTR_ERR(ctx);
824
825	kfree(param.private_data);
826	return result;
827}
828
829static ssize_t ib_ucm_send_private_data(struct ib_ucm_file *file,
830					const char __user *inbuf, int in_len,
831					int (*func)(struct ib_cm_id *cm_id,
832						    const void *private_data,
833						    u8 private_data_len))
834{
835	struct ib_ucm_private_data cmd;
836	struct ib_ucm_context *ctx;
837	const void *private_data = NULL;
838	int result;
839
840	if (copy_from_user(&cmd, inbuf, sizeof(cmd)))
841		return -EFAULT;
842
843	result = ib_ucm_alloc_data(&private_data, cmd.data, cmd.len);
844	if (result)
845		return result;
846
847	ctx = ib_ucm_ctx_get(file, cmd.id);
848	if (!IS_ERR(ctx)) {
849		result = func(ctx->cm_id, private_data, cmd.len);
850		ib_ucm_ctx_put(ctx);
851	} else
852		result = PTR_ERR(ctx);
853
854	kfree(private_data);
855	return result;
856}
857
858static ssize_t ib_ucm_send_rtu(struct ib_ucm_file *file,
859			       const char __user *inbuf,
860			       int in_len, int out_len)
861{
862	return ib_ucm_send_private_data(file, inbuf, in_len, ib_send_cm_rtu);
863}
864
865static ssize_t ib_ucm_send_dreq(struct ib_ucm_file *file,
866				const char __user *inbuf,
867				int in_len, int out_len)
868{
869	return ib_ucm_send_private_data(file, inbuf, in_len, ib_send_cm_dreq);
870}
871
872static ssize_t ib_ucm_send_drep(struct ib_ucm_file *file,
873				const char __user *inbuf,
874				int in_len, int out_len)
875{
876	return ib_ucm_send_private_data(file, inbuf, in_len, ib_send_cm_drep);
877}
878
879static ssize_t ib_ucm_send_info(struct ib_ucm_file *file,
880				const char __user *inbuf, int in_len,
881				int (*func)(struct ib_cm_id *cm_id,
882					    int status,
883					    const void *info,
884					    u8 info_len,
885					    const void *data,
886					    u8 data_len))
887{
888	struct ib_ucm_context *ctx;
889	struct ib_ucm_info cmd;
890	const void *data = NULL;
891	const void *info = NULL;
892	int result;
893
894	if (copy_from_user(&cmd, inbuf, sizeof(cmd)))
895		return -EFAULT;
896
897	result = ib_ucm_alloc_data(&data, cmd.data, cmd.data_len);
898	if (result)
899		goto done;
900
901	result = ib_ucm_alloc_data(&info, cmd.info, cmd.info_len);
902	if (result)
903		goto done;
904
905	ctx = ib_ucm_ctx_get(file, cmd.id);
906	if (!IS_ERR(ctx)) {
907		result = func(ctx->cm_id, cmd.status, info, cmd.info_len,
908			      data, cmd.data_len);
909		ib_ucm_ctx_put(ctx);
910	} else
911		result = PTR_ERR(ctx);
912
913done:
914	kfree(data);
915	kfree(info);
916	return result;
917}
918
919static ssize_t ib_ucm_send_rej(struct ib_ucm_file *file,
920			       const char __user *inbuf,
921			       int in_len, int out_len)
922{
923	return ib_ucm_send_info(file, inbuf, in_len, (void *)ib_send_cm_rej);
924}
925
926static ssize_t ib_ucm_send_apr(struct ib_ucm_file *file,
927			       const char __user *inbuf,
928			       int in_len, int out_len)
929{
930	return ib_ucm_send_info(file, inbuf, in_len, (void *)ib_send_cm_apr);
931}
932
933static ssize_t ib_ucm_send_mra(struct ib_ucm_file *file,
934			       const char __user *inbuf,
935			       int in_len, int out_len)
936{
937	struct ib_ucm_context *ctx;
938	struct ib_ucm_mra cmd;
939	const void *data = NULL;
940	int result;
941
942	if (copy_from_user(&cmd, inbuf, sizeof(cmd)))
943		return -EFAULT;
944
945	result = ib_ucm_alloc_data(&data, cmd.data, cmd.len);
946	if (result)
947		return result;
948
949	ctx = ib_ucm_ctx_get(file, cmd.id);
950	if (!IS_ERR(ctx)) {
951		result = ib_send_cm_mra(ctx->cm_id, cmd.timeout, data, cmd.len);
952		ib_ucm_ctx_put(ctx);
953	} else
954		result = PTR_ERR(ctx);
955
956	kfree(data);
957	return result;
958}
959
960static ssize_t ib_ucm_send_lap(struct ib_ucm_file *file,
961			       const char __user *inbuf,
962			       int in_len, int out_len)
963{
964	struct ib_ucm_context *ctx;
965	struct ib_sa_path_rec *path = NULL;
966	struct ib_ucm_lap cmd;
967	const void *data = NULL;
968	int result;
969
970	if (copy_from_user(&cmd, inbuf, sizeof(cmd)))
971		return -EFAULT;
972
973	result = ib_ucm_alloc_data(&data, cmd.data, cmd.len);
974	if (result)
975		goto done;
976
977	result = ib_ucm_path_get(&path, cmd.path);
978	if (result)
979		goto done;
980
981	ctx = ib_ucm_ctx_get(file, cmd.id);
982	if (!IS_ERR(ctx)) {
983		result = ib_send_cm_lap(ctx->cm_id, path, data, cmd.len);
984		ib_ucm_ctx_put(ctx);
985	} else
986		result = PTR_ERR(ctx);
987
988done:
989	kfree(data);
990	kfree(path);
991	return result;
992}
993
994static ssize_t ib_ucm_send_sidr_req(struct ib_ucm_file *file,
995				    const char __user *inbuf,
996				    int in_len, int out_len)
997{
998	struct ib_cm_sidr_req_param param;
999	struct ib_ucm_context *ctx;
1000	struct ib_ucm_sidr_req cmd;
1001	int result;
1002
1003	param.private_data = NULL;
1004	param.path = NULL;
1005
1006	if (copy_from_user(&cmd, inbuf, sizeof(cmd)))
1007		return -EFAULT;
1008
1009	result = ib_ucm_alloc_data(&param.private_data, cmd.data, cmd.len);
1010	if (result)
1011		goto done;
1012
1013	result = ib_ucm_path_get(&param.path, cmd.path);
1014	if (result)
1015		goto done;
1016
1017	param.private_data_len = cmd.len;
1018	param.service_id       = cmd.sid;
1019	param.timeout_ms       = cmd.timeout;
1020	param.max_cm_retries   = cmd.max_cm_retries;
1021
1022	ctx = ib_ucm_ctx_get(file, cmd.id);
1023	if (!IS_ERR(ctx)) {
1024		result = ib_send_cm_sidr_req(ctx->cm_id, &param);
1025		ib_ucm_ctx_put(ctx);
1026	} else
1027		result = PTR_ERR(ctx);
1028
1029done:
1030	kfree(param.private_data);
1031	kfree(param.path);
1032	return result;
1033}
1034
1035static ssize_t ib_ucm_send_sidr_rep(struct ib_ucm_file *file,
1036				    const char __user *inbuf,
1037				    int in_len, int out_len)
1038{
1039	struct ib_cm_sidr_rep_param param;
1040	struct ib_ucm_sidr_rep cmd;
1041	struct ib_ucm_context *ctx;
1042	int result;
1043
1044	param.info = NULL;
1045
1046	if (copy_from_user(&cmd, inbuf, sizeof(cmd)))
1047		return -EFAULT;
1048
1049	result = ib_ucm_alloc_data(&param.private_data,
1050				   cmd.data, cmd.data_len);
1051	if (result)
1052		goto done;
1053
1054	result = ib_ucm_alloc_data(&param.info, cmd.info, cmd.info_len);
1055	if (result)
1056		goto done;
1057
1058	param.qp_num		= cmd.qpn;
1059	param.qkey		= cmd.qkey;
1060	param.status		= cmd.status;
1061	param.info_length	= cmd.info_len;
1062	param.private_data_len	= cmd.data_len;
1063
1064	ctx = ib_ucm_ctx_get(file, cmd.id);
1065	if (!IS_ERR(ctx)) {
1066		result = ib_send_cm_sidr_rep(ctx->cm_id, &param);
1067		ib_ucm_ctx_put(ctx);
1068	} else
1069		result = PTR_ERR(ctx);
1070
1071done:
1072	kfree(param.private_data);
1073	kfree(param.info);
1074	return result;
1075}
1076
1077static ssize_t (*ucm_cmd_table[])(struct ib_ucm_file *file,
1078				  const char __user *inbuf,
1079				  int in_len, int out_len) = {
1080	[IB_USER_CM_CMD_CREATE_ID]     = ib_ucm_create_id,
1081	[IB_USER_CM_CMD_DESTROY_ID]    = ib_ucm_destroy_id,
1082	[IB_USER_CM_CMD_ATTR_ID]       = ib_ucm_attr_id,
1083	[IB_USER_CM_CMD_LISTEN]        = ib_ucm_listen,
1084	[IB_USER_CM_CMD_NOTIFY]        = ib_ucm_notify,
1085	[IB_USER_CM_CMD_SEND_REQ]      = ib_ucm_send_req,
1086	[IB_USER_CM_CMD_SEND_REP]      = ib_ucm_send_rep,
1087	[IB_USER_CM_CMD_SEND_RTU]      = ib_ucm_send_rtu,
1088	[IB_USER_CM_CMD_SEND_DREQ]     = ib_ucm_send_dreq,
1089	[IB_USER_CM_CMD_SEND_DREP]     = ib_ucm_send_drep,
1090	[IB_USER_CM_CMD_SEND_REJ]      = ib_ucm_send_rej,
1091	[IB_USER_CM_CMD_SEND_MRA]      = ib_ucm_send_mra,
1092	[IB_USER_CM_CMD_SEND_LAP]      = ib_ucm_send_lap,
1093	[IB_USER_CM_CMD_SEND_APR]      = ib_ucm_send_apr,
1094	[IB_USER_CM_CMD_SEND_SIDR_REQ] = ib_ucm_send_sidr_req,
1095	[IB_USER_CM_CMD_SEND_SIDR_REP] = ib_ucm_send_sidr_rep,
1096	[IB_USER_CM_CMD_EVENT]	       = ib_ucm_event,
1097	[IB_USER_CM_CMD_INIT_QP_ATTR]  = ib_ucm_init_qp_attr,
1098};
1099
1100static ssize_t ib_ucm_write(struct file *filp, const char __user *buf,
1101			    size_t len, loff_t *pos)
1102{
1103	struct ib_ucm_file *file = filp->private_data;
1104	struct ib_ucm_cmd_hdr hdr;
1105	ssize_t result;
1106
1107	if (len < sizeof(hdr))
1108		return -EINVAL;
1109
1110	if (copy_from_user(&hdr, buf, sizeof(hdr)))
1111		return -EFAULT;
1112
1113	if (hdr.cmd >= ARRAY_SIZE(ucm_cmd_table))
1114		return -EINVAL;
1115
1116	if (hdr.in + sizeof(hdr) > len)
1117		return -EINVAL;
1118
1119	result = ucm_cmd_table[hdr.cmd](file, buf + sizeof(hdr),
1120					hdr.in, hdr.out);
1121	if (!result)
1122		result = len;
1123
1124	return result;
1125}
1126
1127static unsigned int ib_ucm_poll(struct file *filp,
1128				struct poll_table_struct *wait)
1129{
1130	struct ib_ucm_file *file = filp->private_data;
1131	unsigned int mask = 0;
1132
1133	poll_wait(filp, &file->poll_wait, wait);
1134
1135	if (!list_empty(&file->events))
1136		mask = POLLIN | POLLRDNORM;
1137
1138	return mask;
1139}
1140
1141/*
1142 * ib_ucm_open() does not need the BKL:
1143 *
1144 *  - no global state is referred to;
1145 *  - there is no ioctl method to race against;
1146 *  - no further module initialization is required for open to work
1147 *    after the device is registered.
1148 */
1149static int ib_ucm_open(struct inode *inode, struct file *filp)
1150{
1151	struct ib_ucm_file *file;
1152
1153	file = kmalloc(sizeof(*file), GFP_KERNEL);
1154	if (!file)
1155		return -ENOMEM;
1156
1157	INIT_LIST_HEAD(&file->events);
1158	INIT_LIST_HEAD(&file->ctxs);
1159	init_waitqueue_head(&file->poll_wait);
1160
1161	mutex_init(&file->file_mutex);
1162
1163	filp->private_data = file;
1164	file->filp = filp;
1165	file->device = container_of(inode->i_cdev, struct ib_ucm_device, cdev);
1166
1167	return nonseekable_open(inode, filp);
1168}
1169
1170static int ib_ucm_close(struct inode *inode, struct file *filp)
1171{
1172	struct ib_ucm_file *file = filp->private_data;
1173	struct ib_ucm_context *ctx;
1174
1175	mutex_lock(&file->file_mutex);
1176	while (!list_empty(&file->ctxs)) {
1177		ctx = list_entry(file->ctxs.next,
1178				 struct ib_ucm_context, file_list);
1179		mutex_unlock(&file->file_mutex);
1180
1181		mutex_lock(&ctx_id_mutex);
1182		idr_remove(&ctx_id_table, ctx->id);
1183		mutex_unlock(&ctx_id_mutex);
1184
1185		ib_destroy_cm_id(ctx->cm_id);
1186		ib_ucm_cleanup_events(ctx);
1187		kfree(ctx);
1188
1189		mutex_lock(&file->file_mutex);
1190	}
1191	mutex_unlock(&file->file_mutex);
1192	kfree(file);
1193	return 0;
1194}
1195
1196static void ib_ucm_release_dev(struct device *dev)
1197{
1198	struct ib_ucm_device *ucm_dev;
1199
1200	ucm_dev = container_of(dev, struct ib_ucm_device, dev);
1201	cdev_del(&ucm_dev->cdev);
1202	if (ucm_dev->devnum < IB_UCM_MAX_DEVICES)
1203		clear_bit(ucm_dev->devnum, dev_map);
1204	else
1205		clear_bit(ucm_dev->devnum - IB_UCM_MAX_DEVICES, dev_map);
1206	kfree(ucm_dev);
1207}
1208
1209static const struct file_operations ucm_fops = {
1210	.owner	 = THIS_MODULE,
1211	.open	 = ib_ucm_open,
1212	.release = ib_ucm_close,
1213	.write	 = ib_ucm_write,
1214	.poll    = ib_ucm_poll,
1215	.llseek	 = no_llseek,
1216};
1217
1218static ssize_t show_ibdev(struct device *dev, struct device_attribute *attr,
1219			  char *buf)
1220{
1221	struct ib_ucm_device *ucm_dev;
1222
1223	ucm_dev = container_of(dev, struct ib_ucm_device, dev);
1224	return sprintf(buf, "%s\n", ucm_dev->ib_dev->name);
1225}
1226static DEVICE_ATTR(ibdev, S_IRUGO, show_ibdev, NULL);
1227
1228static dev_t overflow_maj;
1229static DECLARE_BITMAP(overflow_map, IB_UCM_MAX_DEVICES);
1230static int find_overflow_devnum(void)
1231{
1232	int ret;
1233
1234	if (!overflow_maj) {
1235		ret = alloc_chrdev_region(&overflow_maj, 0, IB_UCM_MAX_DEVICES,
1236					  "infiniband_cm");
1237		if (ret) {
1238			printk(KERN_ERR "ucm: couldn't register dynamic device number\n");
1239			return ret;
1240		}
1241	}
1242
1243	ret = find_first_zero_bit(overflow_map, IB_UCM_MAX_DEVICES);
1244	if (ret >= IB_UCM_MAX_DEVICES)
1245		return -1;
1246
1247	return ret;
1248}
1249
1250static void ib_ucm_add_one(struct ib_device *device)
1251{
1252	int devnum;
1253	dev_t base;
1254	struct ib_ucm_device *ucm_dev;
1255
1256	if (!device->alloc_ucontext ||
1257	    rdma_node_get_transport(device->node_type) != RDMA_TRANSPORT_IB)
1258		return;
1259
1260	ucm_dev = kzalloc(sizeof *ucm_dev, GFP_KERNEL);
1261	if (!ucm_dev)
1262		return;
1263
1264	ucm_dev->ib_dev = device;
1265
1266	devnum = find_first_zero_bit(dev_map, IB_UCM_MAX_DEVICES);
1267	if (devnum >= IB_UCM_MAX_DEVICES) {
1268		devnum = find_overflow_devnum();
1269		if (devnum < 0)
1270			goto err;
1271
1272		ucm_dev->devnum = devnum + IB_UCM_MAX_DEVICES;
1273		base = devnum + overflow_maj;
1274		set_bit(devnum, overflow_map);
1275	} else {
1276		ucm_dev->devnum = devnum;
1277		base = devnum + IB_UCM_BASE_DEV;
1278		set_bit(devnum, dev_map);
1279	}
1280
1281	cdev_init(&ucm_dev->cdev, &ucm_fops);
1282	ucm_dev->cdev.owner = THIS_MODULE;
1283	kobject_set_name(&ucm_dev->cdev.kobj, "ucm%d", ucm_dev->devnum);
1284	if (cdev_add(&ucm_dev->cdev, base, 1))
1285		goto err;
1286
1287	ucm_dev->dev.class = &cm_class;
1288	ucm_dev->dev.parent = device->dma_device;
1289	ucm_dev->dev.devt = ucm_dev->cdev.dev;
1290	ucm_dev->dev.release = ib_ucm_release_dev;
1291	dev_set_name(&ucm_dev->dev, "ucm%d", ucm_dev->devnum);
1292	if (device_register(&ucm_dev->dev))
1293		goto err_cdev;
1294
1295	if (device_create_file(&ucm_dev->dev, &dev_attr_ibdev))
1296		goto err_dev;
1297
1298	ib_set_client_data(device, &ucm_client, ucm_dev);
1299	return;
1300
1301err_dev:
1302	device_unregister(&ucm_dev->dev);
1303err_cdev:
1304	cdev_del(&ucm_dev->cdev);
1305	if (ucm_dev->devnum < IB_UCM_MAX_DEVICES)
1306		clear_bit(devnum, dev_map);
1307	else
1308		clear_bit(devnum, overflow_map);
1309err:
1310	kfree(ucm_dev);
1311	return;
1312}
1313
1314static void ib_ucm_remove_one(struct ib_device *device)
1315{
1316	struct ib_ucm_device *ucm_dev = ib_get_client_data(device, &ucm_client);
1317
1318	if (!ucm_dev)
1319		return;
1320
1321	device_unregister(&ucm_dev->dev);
1322}
1323
1324static CLASS_ATTR_STRING(abi_version, S_IRUGO,
1325			 __stringify(IB_USER_CM_ABI_VERSION));
1326
1327static int __init ib_ucm_init(void)
1328{
1329	int ret;
1330
1331	ret = register_chrdev_region(IB_UCM_BASE_DEV, IB_UCM_MAX_DEVICES,
1332				     "infiniband_cm");
1333	if (ret) {
1334		printk(KERN_ERR "ucm: couldn't register device number\n");
1335		goto error1;
1336	}
1337
1338	ret = class_create_file(&cm_class, &class_attr_abi_version.attr);
1339	if (ret) {
1340		printk(KERN_ERR "ucm: couldn't create abi_version attribute\n");
1341		goto error2;
1342	}
1343
1344	ret = ib_register_client(&ucm_client);
1345	if (ret) {
1346		printk(KERN_ERR "ucm: couldn't register client\n");
1347		goto error3;
1348	}
1349	return 0;
1350
1351error3:
1352	class_remove_file(&cm_class, &class_attr_abi_version.attr);
1353error2:
1354	unregister_chrdev_region(IB_UCM_BASE_DEV, IB_UCM_MAX_DEVICES);
1355error1:
1356	return ret;
1357}
1358
1359static void __exit ib_ucm_cleanup(void)
1360{
1361	ib_unregister_client(&ucm_client);
1362	class_remove_file(&cm_class, &class_attr_abi_version.attr);
1363	unregister_chrdev_region(IB_UCM_BASE_DEV, IB_UCM_MAX_DEVICES);
1364	if (overflow_maj)
1365		unregister_chrdev_region(overflow_maj, IB_UCM_MAX_DEVICES);
1366	idr_destroy(&ctx_id_table);
1367}
1368
1369module_init(ib_ucm_init);
1370module_exit(ib_ucm_cleanup);
1371