1 /*
2  * Copyright (c) 2004 Topspin Communications.  All rights reserved.
3  * Copyright (c) 2005 Voltaire, Inc. All rights reserved.
4  * Copyright (c) 2005 Sun Microsystems, Inc. All rights reserved.
5  * Copyright (c) 2008 Cisco. 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 #define pr_fmt(fmt) "user_mad: " fmt
37 
38 #include <linux/module.h>
39 #include <linux/init.h>
40 #include <linux/device.h>
41 #include <linux/err.h>
42 #include <linux/fs.h>
43 #include <linux/cdev.h>
44 #include <linux/dma-mapping.h>
45 #include <linux/poll.h>
46 #include <linux/mutex.h>
47 #include <linux/kref.h>
48 #include <linux/compat.h>
49 #include <linux/sched.h>
50 #include <linux/semaphore.h>
51 #include <linux/slab.h>
52 
53 #include <linux/uaccess.h>
54 
55 #include <rdma/ib_mad.h>
56 #include <rdma/ib_user_mad.h>
57 
58 #include "core_priv.h"
59 
60 MODULE_AUTHOR("Roland Dreier");
61 MODULE_DESCRIPTION("InfiniBand userspace MAD packet access");
62 MODULE_LICENSE("Dual BSD/GPL");
63 
64 enum {
65 	IB_UMAD_MAX_PORTS  = RDMA_MAX_PORTS,
66 	IB_UMAD_MAX_AGENTS = 32,
67 
68 	IB_UMAD_MAJOR      = 231,
69 	IB_UMAD_MINOR_BASE = 0,
70 	IB_UMAD_NUM_FIXED_MINOR = 64,
71 	IB_UMAD_NUM_DYNAMIC_MINOR = IB_UMAD_MAX_PORTS - IB_UMAD_NUM_FIXED_MINOR,
72 	IB_ISSM_MINOR_BASE        = IB_UMAD_NUM_FIXED_MINOR,
73 };
74 
75 /*
76  * Our lifetime rules for these structs are the following:
77  * device special file is opened, we take a reference on the
78  * ib_umad_port's struct ib_umad_device. We drop these
79  * references in the corresponding close().
80  *
81  * In addition to references coming from open character devices, there
82  * is one more reference to each ib_umad_device representing the
83  * module's reference taken when allocating the ib_umad_device in
84  * ib_umad_add_one().
85  *
86  * When destroying an ib_umad_device, we drop the module's reference.
87  */
88 
89 struct ib_umad_port {
90 	struct cdev           cdev;
91 	struct device	      dev;
92 	struct cdev           sm_cdev;
93 	struct device	      sm_dev;
94 	struct semaphore       sm_sem;
95 
96 	struct mutex	       file_mutex;
97 	struct list_head       file_list;
98 
99 	struct ib_device      *ib_dev;
100 	struct ib_umad_device *umad_dev;
101 	int                    dev_num;
102 	u8                     port_num;
103 };
104 
105 struct ib_umad_device {
106 	struct kref kref;
107 	struct ib_umad_port ports[];
108 };
109 
110 struct ib_umad_file {
111 	struct mutex		mutex;
112 	struct ib_umad_port    *port;
113 	struct list_head	recv_list;
114 	struct list_head	send_list;
115 	struct list_head	port_list;
116 	spinlock_t		send_lock;
117 	wait_queue_head_t	recv_wait;
118 	struct ib_mad_agent    *agent[IB_UMAD_MAX_AGENTS];
119 	int			agents_dead;
120 	u8			use_pkey_index;
121 	u8			already_used;
122 };
123 
124 struct ib_umad_packet {
125 	struct ib_mad_send_buf *msg;
126 	struct ib_mad_recv_wc  *recv_wc;
127 	struct list_head   list;
128 	int		   length;
129 	struct ib_user_mad mad;
130 };
131 
132 static const dev_t base_umad_dev = MKDEV(IB_UMAD_MAJOR, IB_UMAD_MINOR_BASE);
133 static const dev_t base_issm_dev = MKDEV(IB_UMAD_MAJOR, IB_UMAD_MINOR_BASE) +
134 				   IB_UMAD_NUM_FIXED_MINOR;
135 static dev_t dynamic_umad_dev;
136 static dev_t dynamic_issm_dev;
137 
138 static DEFINE_IDA(umad_ida);
139 
140 static void ib_umad_add_one(struct ib_device *device);
141 static void ib_umad_remove_one(struct ib_device *device, void *client_data);
142 
143 static void ib_umad_dev_free(struct kref *kref)
144 {
145 	struct ib_umad_device *dev =
146 		container_of(kref, struct ib_umad_device, kref);
147 
148 	kfree(dev);
149 }
150 
151 static void ib_umad_dev_get(struct ib_umad_device *dev)
152 {
153 	kref_get(&dev->kref);
154 }
155 
156 static void ib_umad_dev_put(struct ib_umad_device *dev)
157 {
158 	kref_put(&dev->kref, ib_umad_dev_free);
159 }
160 
161 static int hdr_size(struct ib_umad_file *file)
162 {
163 	return file->use_pkey_index ? sizeof (struct ib_user_mad_hdr) :
164 		sizeof (struct ib_user_mad_hdr_old);
165 }
166 
167 /* caller must hold file->mutex */
168 static struct ib_mad_agent *__get_agent(struct ib_umad_file *file, int id)
169 {
170 	return file->agents_dead ? NULL : file->agent[id];
171 }
172 
173 static int queue_packet(struct ib_umad_file *file,
174 			struct ib_mad_agent *agent,
175 			struct ib_umad_packet *packet)
176 {
177 	int ret = 1;
178 
179 	mutex_lock(&file->mutex);
180 
181 	for (packet->mad.hdr.id = 0;
182 	     packet->mad.hdr.id < IB_UMAD_MAX_AGENTS;
183 	     packet->mad.hdr.id++)
184 		if (agent == __get_agent(file, packet->mad.hdr.id)) {
185 			list_add_tail(&packet->list, &file->recv_list);
186 			wake_up_interruptible(&file->recv_wait);
187 			ret = 0;
188 			break;
189 		}
190 
191 	mutex_unlock(&file->mutex);
192 
193 	return ret;
194 }
195 
196 static void dequeue_send(struct ib_umad_file *file,
197 			 struct ib_umad_packet *packet)
198 {
199 	spin_lock_irq(&file->send_lock);
200 	list_del(&packet->list);
201 	spin_unlock_irq(&file->send_lock);
202 }
203 
204 static void send_handler(struct ib_mad_agent *agent,
205 			 struct ib_mad_send_wc *send_wc)
206 {
207 	struct ib_umad_file *file = agent->context;
208 	struct ib_umad_packet *packet = send_wc->send_buf->context[0];
209 
210 	dequeue_send(file, packet);
211 	rdma_destroy_ah(packet->msg->ah, RDMA_DESTROY_AH_SLEEPABLE);
212 	ib_free_send_mad(packet->msg);
213 
214 	if (send_wc->status == IB_WC_RESP_TIMEOUT_ERR) {
215 		packet->length = IB_MGMT_MAD_HDR;
216 		packet->mad.hdr.status = ETIMEDOUT;
217 		if (!queue_packet(file, agent, packet))
218 			return;
219 	}
220 	kfree(packet);
221 }
222 
223 static void recv_handler(struct ib_mad_agent *agent,
224 			 struct ib_mad_send_buf *send_buf,
225 			 struct ib_mad_recv_wc *mad_recv_wc)
226 {
227 	struct ib_umad_file *file = agent->context;
228 	struct ib_umad_packet *packet;
229 
230 	if (mad_recv_wc->wc->status != IB_WC_SUCCESS)
231 		goto err1;
232 
233 	packet = kzalloc(sizeof *packet, GFP_KERNEL);
234 	if (!packet)
235 		goto err1;
236 
237 	packet->length = mad_recv_wc->mad_len;
238 	packet->recv_wc = mad_recv_wc;
239 
240 	packet->mad.hdr.status	   = 0;
241 	packet->mad.hdr.length	   = hdr_size(file) + mad_recv_wc->mad_len;
242 	packet->mad.hdr.qpn	   = cpu_to_be32(mad_recv_wc->wc->src_qp);
243 	/*
244 	 * On OPA devices it is okay to lose the upper 16 bits of LID as this
245 	 * information is obtained elsewhere. Mask off the upper 16 bits.
246 	 */
247 	if (rdma_cap_opa_mad(agent->device, agent->port_num))
248 		packet->mad.hdr.lid = ib_lid_be16(0xFFFF &
249 						  mad_recv_wc->wc->slid);
250 	else
251 		packet->mad.hdr.lid = ib_lid_be16(mad_recv_wc->wc->slid);
252 	packet->mad.hdr.sl	   = mad_recv_wc->wc->sl;
253 	packet->mad.hdr.path_bits  = mad_recv_wc->wc->dlid_path_bits;
254 	packet->mad.hdr.pkey_index = mad_recv_wc->wc->pkey_index;
255 	packet->mad.hdr.grh_present = !!(mad_recv_wc->wc->wc_flags & IB_WC_GRH);
256 	if (packet->mad.hdr.grh_present) {
257 		struct rdma_ah_attr ah_attr;
258 		const struct ib_global_route *grh;
259 		int ret;
260 
261 		ret = ib_init_ah_attr_from_wc(agent->device, agent->port_num,
262 					      mad_recv_wc->wc,
263 					      mad_recv_wc->recv_buf.grh,
264 					      &ah_attr);
265 		if (ret)
266 			goto err2;
267 
268 		grh = rdma_ah_read_grh(&ah_attr);
269 		packet->mad.hdr.gid_index = grh->sgid_index;
270 		packet->mad.hdr.hop_limit = grh->hop_limit;
271 		packet->mad.hdr.traffic_class = grh->traffic_class;
272 		memcpy(packet->mad.hdr.gid, &grh->dgid, 16);
273 		packet->mad.hdr.flow_label = cpu_to_be32(grh->flow_label);
274 		rdma_destroy_ah_attr(&ah_attr);
275 	}
276 
277 	if (queue_packet(file, agent, packet))
278 		goto err2;
279 	return;
280 
281 err2:
282 	kfree(packet);
283 err1:
284 	ib_free_recv_mad(mad_recv_wc);
285 }
286 
287 static ssize_t copy_recv_mad(struct ib_umad_file *file, char __user *buf,
288 			     struct ib_umad_packet *packet, size_t count)
289 {
290 	struct ib_mad_recv_buf *recv_buf;
291 	int left, seg_payload, offset, max_seg_payload;
292 	size_t seg_size;
293 
294 	recv_buf = &packet->recv_wc->recv_buf;
295 	seg_size = packet->recv_wc->mad_seg_size;
296 
297 	/* We need enough room to copy the first (or only) MAD segment. */
298 	if ((packet->length <= seg_size &&
299 	     count < hdr_size(file) + packet->length) ||
300 	    (packet->length > seg_size &&
301 	     count < hdr_size(file) + seg_size))
302 		return -EINVAL;
303 
304 	if (copy_to_user(buf, &packet->mad, hdr_size(file)))
305 		return -EFAULT;
306 
307 	buf += hdr_size(file);
308 	seg_payload = min_t(int, packet->length, seg_size);
309 	if (copy_to_user(buf, recv_buf->mad, seg_payload))
310 		return -EFAULT;
311 
312 	if (seg_payload < packet->length) {
313 		/*
314 		 * Multipacket RMPP MAD message. Copy remainder of message.
315 		 * Note that last segment may have a shorter payload.
316 		 */
317 		if (count < hdr_size(file) + packet->length) {
318 			/*
319 			 * The buffer is too small, return the first RMPP segment,
320 			 * which includes the RMPP message length.
321 			 */
322 			return -ENOSPC;
323 		}
324 		offset = ib_get_mad_data_offset(recv_buf->mad->mad_hdr.mgmt_class);
325 		max_seg_payload = seg_size - offset;
326 
327 		for (left = packet->length - seg_payload, buf += seg_payload;
328 		     left; left -= seg_payload, buf += seg_payload) {
329 			recv_buf = container_of(recv_buf->list.next,
330 						struct ib_mad_recv_buf, list);
331 			seg_payload = min(left, max_seg_payload);
332 			if (copy_to_user(buf, ((void *) recv_buf->mad) + offset,
333 					 seg_payload))
334 				return -EFAULT;
335 		}
336 	}
337 	return hdr_size(file) + packet->length;
338 }
339 
340 static ssize_t copy_send_mad(struct ib_umad_file *file, char __user *buf,
341 			     struct ib_umad_packet *packet, size_t count)
342 {
343 	ssize_t size = hdr_size(file) + packet->length;
344 
345 	if (count < size)
346 		return -EINVAL;
347 
348 	if (copy_to_user(buf, &packet->mad, hdr_size(file)))
349 		return -EFAULT;
350 
351 	buf += hdr_size(file);
352 
353 	if (copy_to_user(buf, packet->mad.data, packet->length))
354 		return -EFAULT;
355 
356 	return size;
357 }
358 
359 static ssize_t ib_umad_read(struct file *filp, char __user *buf,
360 			    size_t count, loff_t *pos)
361 {
362 	struct ib_umad_file *file = filp->private_data;
363 	struct ib_umad_packet *packet;
364 	ssize_t ret;
365 
366 	if (count < hdr_size(file))
367 		return -EINVAL;
368 
369 	mutex_lock(&file->mutex);
370 
371 	while (list_empty(&file->recv_list)) {
372 		mutex_unlock(&file->mutex);
373 
374 		if (filp->f_flags & O_NONBLOCK)
375 			return -EAGAIN;
376 
377 		if (wait_event_interruptible(file->recv_wait,
378 					     !list_empty(&file->recv_list)))
379 			return -ERESTARTSYS;
380 
381 		mutex_lock(&file->mutex);
382 	}
383 
384 	packet = list_entry(file->recv_list.next, struct ib_umad_packet, list);
385 	list_del(&packet->list);
386 
387 	mutex_unlock(&file->mutex);
388 
389 	if (packet->recv_wc)
390 		ret = copy_recv_mad(file, buf, packet, count);
391 	else
392 		ret = copy_send_mad(file, buf, packet, count);
393 
394 	if (ret < 0) {
395 		/* Requeue packet */
396 		mutex_lock(&file->mutex);
397 		list_add(&packet->list, &file->recv_list);
398 		mutex_unlock(&file->mutex);
399 	} else {
400 		if (packet->recv_wc)
401 			ib_free_recv_mad(packet->recv_wc);
402 		kfree(packet);
403 	}
404 	return ret;
405 }
406 
407 static int copy_rmpp_mad(struct ib_mad_send_buf *msg, const char __user *buf)
408 {
409 	int left, seg;
410 
411 	/* Copy class specific header */
412 	if ((msg->hdr_len > IB_MGMT_RMPP_HDR) &&
413 	    copy_from_user(msg->mad + IB_MGMT_RMPP_HDR, buf + IB_MGMT_RMPP_HDR,
414 			   msg->hdr_len - IB_MGMT_RMPP_HDR))
415 		return -EFAULT;
416 
417 	/* All headers are in place.  Copy data segments. */
418 	for (seg = 1, left = msg->data_len, buf += msg->hdr_len; left > 0;
419 	     seg++, left -= msg->seg_size, buf += msg->seg_size) {
420 		if (copy_from_user(ib_get_rmpp_segment(msg, seg), buf,
421 				   min(left, msg->seg_size)))
422 			return -EFAULT;
423 	}
424 	return 0;
425 }
426 
427 static int same_destination(struct ib_user_mad_hdr *hdr1,
428 			    struct ib_user_mad_hdr *hdr2)
429 {
430 	if (!hdr1->grh_present && !hdr2->grh_present)
431 	   return (hdr1->lid == hdr2->lid);
432 
433 	if (hdr1->grh_present && hdr2->grh_present)
434 	   return !memcmp(hdr1->gid, hdr2->gid, 16);
435 
436 	return 0;
437 }
438 
439 static int is_duplicate(struct ib_umad_file *file,
440 			struct ib_umad_packet *packet)
441 {
442 	struct ib_umad_packet *sent_packet;
443 	struct ib_mad_hdr *sent_hdr, *hdr;
444 
445 	hdr = (struct ib_mad_hdr *) packet->mad.data;
446 	list_for_each_entry(sent_packet, &file->send_list, list) {
447 		sent_hdr = (struct ib_mad_hdr *) sent_packet->mad.data;
448 
449 		if ((hdr->tid != sent_hdr->tid) ||
450 		    (hdr->mgmt_class != sent_hdr->mgmt_class))
451 			continue;
452 
453 		/*
454 		 * No need to be overly clever here.  If two new operations have
455 		 * the same TID, reject the second as a duplicate.  This is more
456 		 * restrictive than required by the spec.
457 		 */
458 		if (!ib_response_mad(hdr)) {
459 			if (!ib_response_mad(sent_hdr))
460 				return 1;
461 			continue;
462 		} else if (!ib_response_mad(sent_hdr))
463 			continue;
464 
465 		if (same_destination(&packet->mad.hdr, &sent_packet->mad.hdr))
466 			return 1;
467 	}
468 
469 	return 0;
470 }
471 
472 static ssize_t ib_umad_write(struct file *filp, const char __user *buf,
473 			     size_t count, loff_t *pos)
474 {
475 	struct ib_umad_file *file = filp->private_data;
476 	struct ib_umad_packet *packet;
477 	struct ib_mad_agent *agent;
478 	struct rdma_ah_attr ah_attr;
479 	struct ib_ah *ah;
480 	struct ib_rmpp_mad *rmpp_mad;
481 	__be64 *tid;
482 	int ret, data_len, hdr_len, copy_offset, rmpp_active;
483 	u8 base_version;
484 
485 	if (count < hdr_size(file) + IB_MGMT_RMPP_HDR)
486 		return -EINVAL;
487 
488 	packet = kzalloc(sizeof *packet + IB_MGMT_RMPP_HDR, GFP_KERNEL);
489 	if (!packet)
490 		return -ENOMEM;
491 
492 	if (copy_from_user(&packet->mad, buf, hdr_size(file))) {
493 		ret = -EFAULT;
494 		goto err;
495 	}
496 
497 	if (packet->mad.hdr.id >= IB_UMAD_MAX_AGENTS) {
498 		ret = -EINVAL;
499 		goto err;
500 	}
501 
502 	buf += hdr_size(file);
503 
504 	if (copy_from_user(packet->mad.data, buf, IB_MGMT_RMPP_HDR)) {
505 		ret = -EFAULT;
506 		goto err;
507 	}
508 
509 	mutex_lock(&file->mutex);
510 
511 	agent = __get_agent(file, packet->mad.hdr.id);
512 	if (!agent) {
513 		ret = -EINVAL;
514 		goto err_up;
515 	}
516 
517 	memset(&ah_attr, 0, sizeof ah_attr);
518 	ah_attr.type = rdma_ah_find_type(agent->device,
519 					 file->port->port_num);
520 	rdma_ah_set_dlid(&ah_attr, be16_to_cpu(packet->mad.hdr.lid));
521 	rdma_ah_set_sl(&ah_attr, packet->mad.hdr.sl);
522 	rdma_ah_set_path_bits(&ah_attr, packet->mad.hdr.path_bits);
523 	rdma_ah_set_port_num(&ah_attr, file->port->port_num);
524 	if (packet->mad.hdr.grh_present) {
525 		rdma_ah_set_grh(&ah_attr, NULL,
526 				be32_to_cpu(packet->mad.hdr.flow_label),
527 				packet->mad.hdr.gid_index,
528 				packet->mad.hdr.hop_limit,
529 				packet->mad.hdr.traffic_class);
530 		rdma_ah_set_dgid_raw(&ah_attr, packet->mad.hdr.gid);
531 	}
532 
533 	ah = rdma_create_user_ah(agent->qp->pd, &ah_attr, NULL);
534 	if (IS_ERR(ah)) {
535 		ret = PTR_ERR(ah);
536 		goto err_up;
537 	}
538 
539 	rmpp_mad = (struct ib_rmpp_mad *) packet->mad.data;
540 	hdr_len = ib_get_mad_data_offset(rmpp_mad->mad_hdr.mgmt_class);
541 
542 	if (ib_is_mad_class_rmpp(rmpp_mad->mad_hdr.mgmt_class)
543 	    && ib_mad_kernel_rmpp_agent(agent)) {
544 		copy_offset = IB_MGMT_RMPP_HDR;
545 		rmpp_active = ib_get_rmpp_flags(&rmpp_mad->rmpp_hdr) &
546 						IB_MGMT_RMPP_FLAG_ACTIVE;
547 	} else {
548 		copy_offset = IB_MGMT_MAD_HDR;
549 		rmpp_active = 0;
550 	}
551 
552 	base_version = ((struct ib_mad_hdr *)&packet->mad.data)->base_version;
553 	data_len = count - hdr_size(file) - hdr_len;
554 	packet->msg = ib_create_send_mad(agent,
555 					 be32_to_cpu(packet->mad.hdr.qpn),
556 					 packet->mad.hdr.pkey_index, rmpp_active,
557 					 hdr_len, data_len, GFP_KERNEL,
558 					 base_version);
559 	if (IS_ERR(packet->msg)) {
560 		ret = PTR_ERR(packet->msg);
561 		goto err_ah;
562 	}
563 
564 	packet->msg->ah		= ah;
565 	packet->msg->timeout_ms = packet->mad.hdr.timeout_ms;
566 	packet->msg->retries	= packet->mad.hdr.retries;
567 	packet->msg->context[0] = packet;
568 
569 	/* Copy MAD header.  Any RMPP header is already in place. */
570 	memcpy(packet->msg->mad, packet->mad.data, IB_MGMT_MAD_HDR);
571 
572 	if (!rmpp_active) {
573 		if (copy_from_user(packet->msg->mad + copy_offset,
574 				   buf + copy_offset,
575 				   hdr_len + data_len - copy_offset)) {
576 			ret = -EFAULT;
577 			goto err_msg;
578 		}
579 	} else {
580 		ret = copy_rmpp_mad(packet->msg, buf);
581 		if (ret)
582 			goto err_msg;
583 	}
584 
585 	/*
586 	 * Set the high-order part of the transaction ID to make MADs from
587 	 * different agents unique, and allow routing responses back to the
588 	 * original requestor.
589 	 */
590 	if (!ib_response_mad(packet->msg->mad)) {
591 		tid = &((struct ib_mad_hdr *) packet->msg->mad)->tid;
592 		*tid = cpu_to_be64(((u64) agent->hi_tid) << 32 |
593 				   (be64_to_cpup(tid) & 0xffffffff));
594 		rmpp_mad->mad_hdr.tid = *tid;
595 	}
596 
597 	if (!ib_mad_kernel_rmpp_agent(agent)
598 	   && ib_is_mad_class_rmpp(rmpp_mad->mad_hdr.mgmt_class)
599 	   && (ib_get_rmpp_flags(&rmpp_mad->rmpp_hdr) & IB_MGMT_RMPP_FLAG_ACTIVE)) {
600 		spin_lock_irq(&file->send_lock);
601 		list_add_tail(&packet->list, &file->send_list);
602 		spin_unlock_irq(&file->send_lock);
603 	} else {
604 		spin_lock_irq(&file->send_lock);
605 		ret = is_duplicate(file, packet);
606 		if (!ret)
607 			list_add_tail(&packet->list, &file->send_list);
608 		spin_unlock_irq(&file->send_lock);
609 		if (ret) {
610 			ret = -EINVAL;
611 			goto err_msg;
612 		}
613 	}
614 
615 	ret = ib_post_send_mad(packet->msg, NULL);
616 	if (ret)
617 		goto err_send;
618 
619 	mutex_unlock(&file->mutex);
620 	return count;
621 
622 err_send:
623 	dequeue_send(file, packet);
624 err_msg:
625 	ib_free_send_mad(packet->msg);
626 err_ah:
627 	rdma_destroy_ah(ah, RDMA_DESTROY_AH_SLEEPABLE);
628 err_up:
629 	mutex_unlock(&file->mutex);
630 err:
631 	kfree(packet);
632 	return ret;
633 }
634 
635 static __poll_t ib_umad_poll(struct file *filp, struct poll_table_struct *wait)
636 {
637 	struct ib_umad_file *file = filp->private_data;
638 
639 	/* we will always be able to post a MAD send */
640 	__poll_t mask = EPOLLOUT | EPOLLWRNORM;
641 
642 	poll_wait(filp, &file->recv_wait, wait);
643 
644 	if (!list_empty(&file->recv_list))
645 		mask |= EPOLLIN | EPOLLRDNORM;
646 
647 	return mask;
648 }
649 
650 static int ib_umad_reg_agent(struct ib_umad_file *file, void __user *arg,
651 			     int compat_method_mask)
652 {
653 	struct ib_user_mad_reg_req ureq;
654 	struct ib_mad_reg_req req;
655 	struct ib_mad_agent *agent = NULL;
656 	int agent_id;
657 	int ret;
658 
659 	mutex_lock(&file->port->file_mutex);
660 	mutex_lock(&file->mutex);
661 
662 	if (!file->port->ib_dev) {
663 		dev_notice(&file->port->dev,
664 			   "ib_umad_reg_agent: invalid device\n");
665 		ret = -EPIPE;
666 		goto out;
667 	}
668 
669 	if (copy_from_user(&ureq, arg, sizeof ureq)) {
670 		ret = -EFAULT;
671 		goto out;
672 	}
673 
674 	if (ureq.qpn != 0 && ureq.qpn != 1) {
675 		dev_notice(&file->port->dev,
676 			   "ib_umad_reg_agent: invalid QPN %d specified\n",
677 			   ureq.qpn);
678 		ret = -EINVAL;
679 		goto out;
680 	}
681 
682 	for (agent_id = 0; agent_id < IB_UMAD_MAX_AGENTS; ++agent_id)
683 		if (!__get_agent(file, agent_id))
684 			goto found;
685 
686 	dev_notice(&file->port->dev,
687 		   "ib_umad_reg_agent: Max Agents (%u) reached\n",
688 		   IB_UMAD_MAX_AGENTS);
689 	ret = -ENOMEM;
690 	goto out;
691 
692 found:
693 	if (ureq.mgmt_class) {
694 		memset(&req, 0, sizeof(req));
695 		req.mgmt_class         = ureq.mgmt_class;
696 		req.mgmt_class_version = ureq.mgmt_class_version;
697 		memcpy(req.oui, ureq.oui, sizeof req.oui);
698 
699 		if (compat_method_mask) {
700 			u32 *umm = (u32 *) ureq.method_mask;
701 			int i;
702 
703 			for (i = 0; i < BITS_TO_LONGS(IB_MGMT_MAX_METHODS); ++i)
704 				req.method_mask[i] =
705 					umm[i * 2] | ((u64) umm[i * 2 + 1] << 32);
706 		} else
707 			memcpy(req.method_mask, ureq.method_mask,
708 			       sizeof req.method_mask);
709 	}
710 
711 	agent = ib_register_mad_agent(file->port->ib_dev, file->port->port_num,
712 				      ureq.qpn ? IB_QPT_GSI : IB_QPT_SMI,
713 				      ureq.mgmt_class ? &req : NULL,
714 				      ureq.rmpp_version,
715 				      send_handler, recv_handler, file, 0);
716 	if (IS_ERR(agent)) {
717 		ret = PTR_ERR(agent);
718 		agent = NULL;
719 		goto out;
720 	}
721 
722 	if (put_user(agent_id,
723 		     (u32 __user *) (arg + offsetof(struct ib_user_mad_reg_req, id)))) {
724 		ret = -EFAULT;
725 		goto out;
726 	}
727 
728 	if (!file->already_used) {
729 		file->already_used = 1;
730 		if (!file->use_pkey_index) {
731 			dev_warn(&file->port->dev,
732 				"process %s did not enable P_Key index support.\n",
733 				current->comm);
734 			dev_warn(&file->port->dev,
735 				"   Documentation/infiniband/user_mad.txt has info on the new ABI.\n");
736 		}
737 	}
738 
739 	file->agent[agent_id] = agent;
740 	ret = 0;
741 
742 out:
743 	mutex_unlock(&file->mutex);
744 
745 	if (ret && agent)
746 		ib_unregister_mad_agent(agent);
747 
748 	mutex_unlock(&file->port->file_mutex);
749 
750 	return ret;
751 }
752 
753 static int ib_umad_reg_agent2(struct ib_umad_file *file, void __user *arg)
754 {
755 	struct ib_user_mad_reg_req2 ureq;
756 	struct ib_mad_reg_req req;
757 	struct ib_mad_agent *agent = NULL;
758 	int agent_id;
759 	int ret;
760 
761 	mutex_lock(&file->port->file_mutex);
762 	mutex_lock(&file->mutex);
763 
764 	if (!file->port->ib_dev) {
765 		dev_notice(&file->port->dev,
766 			   "ib_umad_reg_agent2: invalid device\n");
767 		ret = -EPIPE;
768 		goto out;
769 	}
770 
771 	if (copy_from_user(&ureq, arg, sizeof(ureq))) {
772 		ret = -EFAULT;
773 		goto out;
774 	}
775 
776 	if (ureq.qpn != 0 && ureq.qpn != 1) {
777 		dev_notice(&file->port->dev,
778 			   "ib_umad_reg_agent2: invalid QPN %d specified\n",
779 			   ureq.qpn);
780 		ret = -EINVAL;
781 		goto out;
782 	}
783 
784 	if (ureq.flags & ~IB_USER_MAD_REG_FLAGS_CAP) {
785 		dev_notice(&file->port->dev,
786 			   "ib_umad_reg_agent2 failed: invalid registration flags specified 0x%x; supported 0x%x\n",
787 			   ureq.flags, IB_USER_MAD_REG_FLAGS_CAP);
788 		ret = -EINVAL;
789 
790 		if (put_user((u32)IB_USER_MAD_REG_FLAGS_CAP,
791 				(u32 __user *) (arg + offsetof(struct
792 				ib_user_mad_reg_req2, flags))))
793 			ret = -EFAULT;
794 
795 		goto out;
796 	}
797 
798 	for (agent_id = 0; agent_id < IB_UMAD_MAX_AGENTS; ++agent_id)
799 		if (!__get_agent(file, agent_id))
800 			goto found;
801 
802 	dev_notice(&file->port->dev,
803 		   "ib_umad_reg_agent2: Max Agents (%u) reached\n",
804 		   IB_UMAD_MAX_AGENTS);
805 	ret = -ENOMEM;
806 	goto out;
807 
808 found:
809 	if (ureq.mgmt_class) {
810 		memset(&req, 0, sizeof(req));
811 		req.mgmt_class         = ureq.mgmt_class;
812 		req.mgmt_class_version = ureq.mgmt_class_version;
813 		if (ureq.oui & 0xff000000) {
814 			dev_notice(&file->port->dev,
815 				   "ib_umad_reg_agent2 failed: oui invalid 0x%08x\n",
816 				   ureq.oui);
817 			ret = -EINVAL;
818 			goto out;
819 		}
820 		req.oui[2] =  ureq.oui & 0x0000ff;
821 		req.oui[1] = (ureq.oui & 0x00ff00) >> 8;
822 		req.oui[0] = (ureq.oui & 0xff0000) >> 16;
823 		memcpy(req.method_mask, ureq.method_mask,
824 			sizeof(req.method_mask));
825 	}
826 
827 	agent = ib_register_mad_agent(file->port->ib_dev, file->port->port_num,
828 				      ureq.qpn ? IB_QPT_GSI : IB_QPT_SMI,
829 				      ureq.mgmt_class ? &req : NULL,
830 				      ureq.rmpp_version,
831 				      send_handler, recv_handler, file,
832 				      ureq.flags);
833 	if (IS_ERR(agent)) {
834 		ret = PTR_ERR(agent);
835 		agent = NULL;
836 		goto out;
837 	}
838 
839 	if (put_user(agent_id,
840 		     (u32 __user *)(arg +
841 				offsetof(struct ib_user_mad_reg_req2, id)))) {
842 		ret = -EFAULT;
843 		goto out;
844 	}
845 
846 	if (!file->already_used) {
847 		file->already_used = 1;
848 		file->use_pkey_index = 1;
849 	}
850 
851 	file->agent[agent_id] = agent;
852 	ret = 0;
853 
854 out:
855 	mutex_unlock(&file->mutex);
856 
857 	if (ret && agent)
858 		ib_unregister_mad_agent(agent);
859 
860 	mutex_unlock(&file->port->file_mutex);
861 
862 	return ret;
863 }
864 
865 
866 static int ib_umad_unreg_agent(struct ib_umad_file *file, u32 __user *arg)
867 {
868 	struct ib_mad_agent *agent = NULL;
869 	u32 id;
870 	int ret = 0;
871 
872 	if (get_user(id, arg))
873 		return -EFAULT;
874 
875 	mutex_lock(&file->port->file_mutex);
876 	mutex_lock(&file->mutex);
877 
878 	if (id >= IB_UMAD_MAX_AGENTS || !__get_agent(file, id)) {
879 		ret = -EINVAL;
880 		goto out;
881 	}
882 
883 	agent = file->agent[id];
884 	file->agent[id] = NULL;
885 
886 out:
887 	mutex_unlock(&file->mutex);
888 
889 	if (agent)
890 		ib_unregister_mad_agent(agent);
891 
892 	mutex_unlock(&file->port->file_mutex);
893 
894 	return ret;
895 }
896 
897 static long ib_umad_enable_pkey(struct ib_umad_file *file)
898 {
899 	int ret = 0;
900 
901 	mutex_lock(&file->mutex);
902 	if (file->already_used)
903 		ret = -EINVAL;
904 	else
905 		file->use_pkey_index = 1;
906 	mutex_unlock(&file->mutex);
907 
908 	return ret;
909 }
910 
911 static long ib_umad_ioctl(struct file *filp, unsigned int cmd,
912 			  unsigned long arg)
913 {
914 	switch (cmd) {
915 	case IB_USER_MAD_REGISTER_AGENT:
916 		return ib_umad_reg_agent(filp->private_data, (void __user *) arg, 0);
917 	case IB_USER_MAD_UNREGISTER_AGENT:
918 		return ib_umad_unreg_agent(filp->private_data, (__u32 __user *) arg);
919 	case IB_USER_MAD_ENABLE_PKEY:
920 		return ib_umad_enable_pkey(filp->private_data);
921 	case IB_USER_MAD_REGISTER_AGENT2:
922 		return ib_umad_reg_agent2(filp->private_data, (void __user *) arg);
923 	default:
924 		return -ENOIOCTLCMD;
925 	}
926 }
927 
928 #ifdef CONFIG_COMPAT
929 static long ib_umad_compat_ioctl(struct file *filp, unsigned int cmd,
930 				 unsigned long arg)
931 {
932 	switch (cmd) {
933 	case IB_USER_MAD_REGISTER_AGENT:
934 		return ib_umad_reg_agent(filp->private_data, compat_ptr(arg), 1);
935 	case IB_USER_MAD_UNREGISTER_AGENT:
936 		return ib_umad_unreg_agent(filp->private_data, compat_ptr(arg));
937 	case IB_USER_MAD_ENABLE_PKEY:
938 		return ib_umad_enable_pkey(filp->private_data);
939 	case IB_USER_MAD_REGISTER_AGENT2:
940 		return ib_umad_reg_agent2(filp->private_data, compat_ptr(arg));
941 	default:
942 		return -ENOIOCTLCMD;
943 	}
944 }
945 #endif
946 
947 /*
948  * ib_umad_open() does not need the BKL:
949  *
950  *  - the ib_umad_port structures are properly reference counted, and
951  *    everything else is purely local to the file being created, so
952  *    races against other open calls are not a problem;
953  *  - the ioctl method does not affect any global state outside of the
954  *    file structure being operated on;
955  */
956 static int ib_umad_open(struct inode *inode, struct file *filp)
957 {
958 	struct ib_umad_port *port;
959 	struct ib_umad_file *file;
960 	int ret = -ENXIO;
961 
962 	port = container_of(inode->i_cdev, struct ib_umad_port, cdev);
963 
964 	mutex_lock(&port->file_mutex);
965 
966 	if (!port->ib_dev)
967 		goto out;
968 
969 	ret = -ENOMEM;
970 	file = kzalloc(sizeof *file, GFP_KERNEL);
971 	if (!file)
972 		goto out;
973 
974 	mutex_init(&file->mutex);
975 	spin_lock_init(&file->send_lock);
976 	INIT_LIST_HEAD(&file->recv_list);
977 	INIT_LIST_HEAD(&file->send_list);
978 	init_waitqueue_head(&file->recv_wait);
979 
980 	file->port = port;
981 	filp->private_data = file;
982 
983 	list_add_tail(&file->port_list, &port->file_list);
984 
985 	ret = nonseekable_open(inode, filp);
986 	if (ret) {
987 		list_del(&file->port_list);
988 		kfree(file);
989 		goto out;
990 	}
991 
992 	ib_umad_dev_get(port->umad_dev);
993 out:
994 	mutex_unlock(&port->file_mutex);
995 	return ret;
996 }
997 
998 static int ib_umad_close(struct inode *inode, struct file *filp)
999 {
1000 	struct ib_umad_file *file = filp->private_data;
1001 	struct ib_umad_device *dev = file->port->umad_dev;
1002 	struct ib_umad_packet *packet, *tmp;
1003 	int already_dead;
1004 	int i;
1005 
1006 	mutex_lock(&file->port->file_mutex);
1007 	mutex_lock(&file->mutex);
1008 
1009 	already_dead = file->agents_dead;
1010 	file->agents_dead = 1;
1011 
1012 	list_for_each_entry_safe(packet, tmp, &file->recv_list, list) {
1013 		if (packet->recv_wc)
1014 			ib_free_recv_mad(packet->recv_wc);
1015 		kfree(packet);
1016 	}
1017 
1018 	list_del(&file->port_list);
1019 
1020 	mutex_unlock(&file->mutex);
1021 
1022 	if (!already_dead)
1023 		for (i = 0; i < IB_UMAD_MAX_AGENTS; ++i)
1024 			if (file->agent[i])
1025 				ib_unregister_mad_agent(file->agent[i]);
1026 
1027 	mutex_unlock(&file->port->file_mutex);
1028 
1029 	kfree(file);
1030 	ib_umad_dev_put(dev);
1031 	return 0;
1032 }
1033 
1034 static const struct file_operations umad_fops = {
1035 	.owner		= THIS_MODULE,
1036 	.read		= ib_umad_read,
1037 	.write		= ib_umad_write,
1038 	.poll		= ib_umad_poll,
1039 	.unlocked_ioctl = ib_umad_ioctl,
1040 #ifdef CONFIG_COMPAT
1041 	.compat_ioctl	= ib_umad_compat_ioctl,
1042 #endif
1043 	.open		= ib_umad_open,
1044 	.release	= ib_umad_close,
1045 	.llseek		= no_llseek,
1046 };
1047 
1048 static int ib_umad_sm_open(struct inode *inode, struct file *filp)
1049 {
1050 	struct ib_umad_port *port;
1051 	struct ib_port_modify props = {
1052 		.set_port_cap_mask = IB_PORT_SM
1053 	};
1054 	int ret;
1055 
1056 	port = container_of(inode->i_cdev, struct ib_umad_port, sm_cdev);
1057 
1058 	if (filp->f_flags & O_NONBLOCK) {
1059 		if (down_trylock(&port->sm_sem)) {
1060 			ret = -EAGAIN;
1061 			goto fail;
1062 		}
1063 	} else {
1064 		if (down_interruptible(&port->sm_sem)) {
1065 			ret = -ERESTARTSYS;
1066 			goto fail;
1067 		}
1068 	}
1069 
1070 	ret = ib_modify_port(port->ib_dev, port->port_num, 0, &props);
1071 	if (ret)
1072 		goto err_up_sem;
1073 
1074 	filp->private_data = port;
1075 
1076 	ret = nonseekable_open(inode, filp);
1077 	if (ret)
1078 		goto err_clr_sm_cap;
1079 
1080 	ib_umad_dev_get(port->umad_dev);
1081 	return 0;
1082 
1083 err_clr_sm_cap:
1084 	swap(props.set_port_cap_mask, props.clr_port_cap_mask);
1085 	ib_modify_port(port->ib_dev, port->port_num, 0, &props);
1086 
1087 err_up_sem:
1088 	up(&port->sm_sem);
1089 
1090 fail:
1091 	return ret;
1092 }
1093 
1094 static int ib_umad_sm_close(struct inode *inode, struct file *filp)
1095 {
1096 	struct ib_umad_port *port = filp->private_data;
1097 	struct ib_port_modify props = {
1098 		.clr_port_cap_mask = IB_PORT_SM
1099 	};
1100 	int ret = 0;
1101 
1102 	mutex_lock(&port->file_mutex);
1103 	if (port->ib_dev)
1104 		ret = ib_modify_port(port->ib_dev, port->port_num, 0, &props);
1105 	mutex_unlock(&port->file_mutex);
1106 
1107 	up(&port->sm_sem);
1108 
1109 	ib_umad_dev_put(port->umad_dev);
1110 	return ret;
1111 }
1112 
1113 static const struct file_operations umad_sm_fops = {
1114 	.owner	 = THIS_MODULE,
1115 	.open	 = ib_umad_sm_open,
1116 	.release = ib_umad_sm_close,
1117 	.llseek	 = no_llseek,
1118 };
1119 
1120 static struct ib_client umad_client = {
1121 	.name   = "umad",
1122 	.add    = ib_umad_add_one,
1123 	.remove = ib_umad_remove_one
1124 };
1125 
1126 static ssize_t ibdev_show(struct device *dev, struct device_attribute *attr,
1127 			  char *buf)
1128 {
1129 	struct ib_umad_port *port = dev_get_drvdata(dev);
1130 
1131 	if (!port)
1132 		return -ENODEV;
1133 
1134 	return sprintf(buf, "%s\n", dev_name(&port->ib_dev->dev));
1135 }
1136 static DEVICE_ATTR_RO(ibdev);
1137 
1138 static ssize_t port_show(struct device *dev, struct device_attribute *attr,
1139 			 char *buf)
1140 {
1141 	struct ib_umad_port *port = dev_get_drvdata(dev);
1142 
1143 	if (!port)
1144 		return -ENODEV;
1145 
1146 	return sprintf(buf, "%d\n", port->port_num);
1147 }
1148 static DEVICE_ATTR_RO(port);
1149 
1150 static struct attribute *umad_class_dev_attrs[] = {
1151 	&dev_attr_ibdev.attr,
1152 	&dev_attr_port.attr,
1153 	NULL,
1154 };
1155 ATTRIBUTE_GROUPS(umad_class_dev);
1156 
1157 static char *umad_devnode(struct device *dev, umode_t *mode)
1158 {
1159 	return kasprintf(GFP_KERNEL, "infiniband/%s", dev_name(dev));
1160 }
1161 
1162 static ssize_t abi_version_show(struct class *class,
1163 				struct class_attribute *attr, char *buf)
1164 {
1165 	return sprintf(buf, "%d\n", IB_USER_MAD_ABI_VERSION);
1166 }
1167 static CLASS_ATTR_RO(abi_version);
1168 
1169 static struct attribute *umad_class_attrs[] = {
1170 	&class_attr_abi_version.attr,
1171 	NULL,
1172 };
1173 ATTRIBUTE_GROUPS(umad_class);
1174 
1175 static struct class umad_class = {
1176 	.name		= "infiniband_mad",
1177 	.devnode	= umad_devnode,
1178 	.class_groups	= umad_class_groups,
1179 	.dev_groups	= umad_class_dev_groups,
1180 };
1181 
1182 static void ib_umad_release_port(struct device *device)
1183 {
1184 	struct ib_umad_port *port = dev_get_drvdata(device);
1185 	struct ib_umad_device *umad_dev = port->umad_dev;
1186 
1187 	ib_umad_dev_put(umad_dev);
1188 }
1189 
1190 static void ib_umad_init_port_dev(struct device *dev,
1191 				  struct ib_umad_port *port,
1192 				  const struct ib_device *device)
1193 {
1194 	device_initialize(dev);
1195 	ib_umad_dev_get(port->umad_dev);
1196 	dev->class = &umad_class;
1197 	dev->parent = device->dev.parent;
1198 	dev_set_drvdata(dev, port);
1199 	dev->release = ib_umad_release_port;
1200 }
1201 
1202 static int ib_umad_init_port(struct ib_device *device, int port_num,
1203 			     struct ib_umad_device *umad_dev,
1204 			     struct ib_umad_port *port)
1205 {
1206 	int devnum;
1207 	dev_t base_umad;
1208 	dev_t base_issm;
1209 	int ret;
1210 
1211 	devnum = ida_alloc_max(&umad_ida, IB_UMAD_MAX_PORTS - 1, GFP_KERNEL);
1212 	if (devnum < 0)
1213 		return -1;
1214 	port->dev_num = devnum;
1215 	if (devnum >= IB_UMAD_NUM_FIXED_MINOR) {
1216 		base_umad = dynamic_umad_dev + devnum - IB_UMAD_NUM_FIXED_MINOR;
1217 		base_issm = dynamic_issm_dev + devnum - IB_UMAD_NUM_FIXED_MINOR;
1218 	} else {
1219 		base_umad = devnum + base_umad_dev;
1220 		base_issm = devnum + base_issm_dev;
1221 	}
1222 
1223 	port->ib_dev   = device;
1224 	port->umad_dev = umad_dev;
1225 	port->port_num = port_num;
1226 	sema_init(&port->sm_sem, 1);
1227 	mutex_init(&port->file_mutex);
1228 	INIT_LIST_HEAD(&port->file_list);
1229 
1230 	ib_umad_init_port_dev(&port->dev, port, device);
1231 	port->dev.devt = base_umad;
1232 	dev_set_name(&port->dev, "umad%d", port->dev_num);
1233 	cdev_init(&port->cdev, &umad_fops);
1234 	port->cdev.owner = THIS_MODULE;
1235 
1236 	ret = cdev_device_add(&port->cdev, &port->dev);
1237 	if (ret)
1238 		goto err_cdev;
1239 
1240 	ib_umad_init_port_dev(&port->sm_dev, port, device);
1241 	port->sm_dev.devt = base_issm;
1242 	dev_set_name(&port->sm_dev, "issm%d", port->dev_num);
1243 	cdev_init(&port->sm_cdev, &umad_sm_fops);
1244 	port->sm_cdev.owner = THIS_MODULE;
1245 
1246 	ret = cdev_device_add(&port->sm_cdev, &port->sm_dev);
1247 	if (ret)
1248 		goto err_dev;
1249 
1250 	return 0;
1251 
1252 err_dev:
1253 	put_device(&port->sm_dev);
1254 	cdev_device_del(&port->cdev, &port->dev);
1255 err_cdev:
1256 	put_device(&port->dev);
1257 	ida_free(&umad_ida, devnum);
1258 	return ret;
1259 }
1260 
1261 static void ib_umad_kill_port(struct ib_umad_port *port)
1262 {
1263 	struct ib_umad_file *file;
1264 	int id;
1265 
1266 	mutex_lock(&port->file_mutex);
1267 
1268 	/* Mark ib_dev NULL and block ioctl or other file ops to progress
1269 	 * further.
1270 	 */
1271 	port->ib_dev = NULL;
1272 
1273 	list_for_each_entry(file, &port->file_list, port_list) {
1274 		mutex_lock(&file->mutex);
1275 		file->agents_dead = 1;
1276 		mutex_unlock(&file->mutex);
1277 
1278 		for (id = 0; id < IB_UMAD_MAX_AGENTS; ++id)
1279 			if (file->agent[id])
1280 				ib_unregister_mad_agent(file->agent[id]);
1281 	}
1282 
1283 	mutex_unlock(&port->file_mutex);
1284 
1285 	cdev_device_del(&port->sm_cdev, &port->sm_dev);
1286 	put_device(&port->sm_dev);
1287 	cdev_device_del(&port->cdev, &port->dev);
1288 	put_device(&port->dev);
1289 	ida_free(&umad_ida, port->dev_num);
1290 }
1291 
1292 static void ib_umad_add_one(struct ib_device *device)
1293 {
1294 	struct ib_umad_device *umad_dev;
1295 	int s, e, i;
1296 	int count = 0;
1297 
1298 	s = rdma_start_port(device);
1299 	e = rdma_end_port(device);
1300 
1301 	umad_dev = kzalloc(struct_size(umad_dev, ports, e - s + 1), GFP_KERNEL);
1302 	if (!umad_dev)
1303 		return;
1304 
1305 	kref_init(&umad_dev->kref);
1306 	for (i = s; i <= e; ++i) {
1307 		if (!rdma_cap_ib_mad(device, i))
1308 			continue;
1309 
1310 		if (ib_umad_init_port(device, i, umad_dev,
1311 				      &umad_dev->ports[i - s]))
1312 			goto err;
1313 
1314 		count++;
1315 	}
1316 
1317 	if (!count)
1318 		goto free;
1319 
1320 	ib_set_client_data(device, &umad_client, umad_dev);
1321 
1322 	return;
1323 
1324 err:
1325 	while (--i >= s) {
1326 		if (!rdma_cap_ib_mad(device, i))
1327 			continue;
1328 
1329 		ib_umad_kill_port(&umad_dev->ports[i - s]);
1330 	}
1331 free:
1332 	ib_umad_dev_put(umad_dev);
1333 }
1334 
1335 static void ib_umad_remove_one(struct ib_device *device, void *client_data)
1336 {
1337 	struct ib_umad_device *umad_dev = client_data;
1338 	int i;
1339 
1340 	if (!umad_dev)
1341 		return;
1342 
1343 	for (i = 0; i <= rdma_end_port(device) - rdma_start_port(device); ++i) {
1344 		if (rdma_cap_ib_mad(device, i + rdma_start_port(device)))
1345 			ib_umad_kill_port(&umad_dev->ports[i]);
1346 	}
1347 	ib_umad_dev_put(umad_dev);
1348 }
1349 
1350 static int __init ib_umad_init(void)
1351 {
1352 	int ret;
1353 
1354 	ret = register_chrdev_region(base_umad_dev,
1355 				     IB_UMAD_NUM_FIXED_MINOR * 2,
1356 				     umad_class.name);
1357 	if (ret) {
1358 		pr_err("couldn't register device number\n");
1359 		goto out;
1360 	}
1361 
1362 	ret = alloc_chrdev_region(&dynamic_umad_dev, 0,
1363 				  IB_UMAD_NUM_DYNAMIC_MINOR * 2,
1364 				  umad_class.name);
1365 	if (ret) {
1366 		pr_err("couldn't register dynamic device number\n");
1367 		goto out_alloc;
1368 	}
1369 	dynamic_issm_dev = dynamic_umad_dev + IB_UMAD_NUM_DYNAMIC_MINOR;
1370 
1371 	ret = class_register(&umad_class);
1372 	if (ret) {
1373 		pr_err("couldn't create class infiniband_mad\n");
1374 		goto out_chrdev;
1375 	}
1376 
1377 	ret = ib_register_client(&umad_client);
1378 	if (ret) {
1379 		pr_err("couldn't register ib_umad client\n");
1380 		goto out_class;
1381 	}
1382 
1383 	return 0;
1384 
1385 out_class:
1386 	class_unregister(&umad_class);
1387 
1388 out_chrdev:
1389 	unregister_chrdev_region(dynamic_umad_dev,
1390 				 IB_UMAD_NUM_DYNAMIC_MINOR * 2);
1391 
1392 out_alloc:
1393 	unregister_chrdev_region(base_umad_dev,
1394 				 IB_UMAD_NUM_FIXED_MINOR * 2);
1395 
1396 out:
1397 	return ret;
1398 }
1399 
1400 static void __exit ib_umad_cleanup(void)
1401 {
1402 	ib_unregister_client(&umad_client);
1403 	class_unregister(&umad_class);
1404 	unregister_chrdev_region(base_umad_dev,
1405 				 IB_UMAD_NUM_FIXED_MINOR * 2);
1406 	unregister_chrdev_region(dynamic_umad_dev,
1407 				 IB_UMAD_NUM_DYNAMIC_MINOR * 2);
1408 }
1409 
1410 module_init(ib_umad_init);
1411 module_exit(ib_umad_cleanup);
1412