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