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.
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:
13 * Redistribution and use in source and binary forms, with or
14 * without modification, are permitted provided that the following
17 * - Redistributions of source code must retain the above
18 * copyright notice, this list of conditions and the following
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.
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
36 #define pr_fmt(fmt) "user_mad: " fmt
38 #include <linux/module.h>
39 #include <linux/init.h>
40 #include <linux/device.h>
41 #include <linux/err.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>
53 #include <linux/uaccess.h>
55 #include <rdma/ib_mad.h>
56 #include <rdma/ib_user_mad.h>
58 MODULE_AUTHOR("Roland Dreier");
59 MODULE_DESCRIPTION("InfiniBand userspace MAD packet access");
60 MODULE_LICENSE("Dual BSD/GPL");
63 IB_UMAD_MAX_PORTS
= 64,
64 IB_UMAD_MAX_AGENTS
= 32,
67 IB_UMAD_MINOR_BASE
= 0
71 * Our lifetime rules for these structs are the following:
72 * device special file is opened, we take a reference on the
73 * ib_umad_port's struct ib_umad_device. We drop these
74 * references in the corresponding close().
76 * In addition to references coming from open character devices, there
77 * is one more reference to each ib_umad_device representing the
78 * module's reference taken when allocating the ib_umad_device in
81 * When destroying an ib_umad_device, we drop the module's reference.
89 struct device
*sm_dev
;
90 struct semaphore sm_sem
;
92 struct mutex file_mutex
;
93 struct list_head file_list
;
95 struct ib_device
*ib_dev
;
96 struct ib_umad_device
*umad_dev
;
101 struct ib_umad_device
{
103 struct ib_umad_port port
[0];
106 struct ib_umad_file
{
108 struct ib_umad_port
*port
;
109 struct list_head recv_list
;
110 struct list_head send_list
;
111 struct list_head port_list
;
112 spinlock_t send_lock
;
113 wait_queue_head_t recv_wait
;
114 struct ib_mad_agent
*agent
[IB_UMAD_MAX_AGENTS
];
120 struct ib_umad_packet
{
121 struct ib_mad_send_buf
*msg
;
122 struct ib_mad_recv_wc
*recv_wc
;
123 struct list_head list
;
125 struct ib_user_mad mad
;
128 static struct class *umad_class
;
130 static const dev_t base_dev
= MKDEV(IB_UMAD_MAJOR
, IB_UMAD_MINOR_BASE
);
132 static DEFINE_SPINLOCK(port_lock
);
133 static DECLARE_BITMAP(dev_map
, IB_UMAD_MAX_PORTS
);
135 static void ib_umad_add_one(struct ib_device
*device
);
136 static void ib_umad_remove_one(struct ib_device
*device
, void *client_data
);
138 static void ib_umad_release_dev(struct kobject
*kobj
)
140 struct ib_umad_device
*dev
=
141 container_of(kobj
, struct ib_umad_device
, kobj
);
146 static struct kobj_type ib_umad_dev_ktype
= {
147 .release
= ib_umad_release_dev
,
150 static int hdr_size(struct ib_umad_file
*file
)
152 return file
->use_pkey_index
? sizeof (struct ib_user_mad_hdr
) :
153 sizeof (struct ib_user_mad_hdr_old
);
156 /* caller must hold file->mutex */
157 static struct ib_mad_agent
*__get_agent(struct ib_umad_file
*file
, int id
)
159 return file
->agents_dead
? NULL
: file
->agent
[id
];
162 static int queue_packet(struct ib_umad_file
*file
,
163 struct ib_mad_agent
*agent
,
164 struct ib_umad_packet
*packet
)
168 mutex_lock(&file
->mutex
);
170 for (packet
->mad
.hdr
.id
= 0;
171 packet
->mad
.hdr
.id
< IB_UMAD_MAX_AGENTS
;
172 packet
->mad
.hdr
.id
++)
173 if (agent
== __get_agent(file
, packet
->mad
.hdr
.id
)) {
174 list_add_tail(&packet
->list
, &file
->recv_list
);
175 wake_up_interruptible(&file
->recv_wait
);
180 mutex_unlock(&file
->mutex
);
185 static void dequeue_send(struct ib_umad_file
*file
,
186 struct ib_umad_packet
*packet
)
188 spin_lock_irq(&file
->send_lock
);
189 list_del(&packet
->list
);
190 spin_unlock_irq(&file
->send_lock
);
193 static void send_handler(struct ib_mad_agent
*agent
,
194 struct ib_mad_send_wc
*send_wc
)
196 struct ib_umad_file
*file
= agent
->context
;
197 struct ib_umad_packet
*packet
= send_wc
->send_buf
->context
[0];
199 dequeue_send(file
, packet
);
200 rdma_destroy_ah(packet
->msg
->ah
);
201 ib_free_send_mad(packet
->msg
);
203 if (send_wc
->status
== IB_WC_RESP_TIMEOUT_ERR
) {
204 packet
->length
= IB_MGMT_MAD_HDR
;
205 packet
->mad
.hdr
.status
= ETIMEDOUT
;
206 if (!queue_packet(file
, agent
, packet
))
212 static void recv_handler(struct ib_mad_agent
*agent
,
213 struct ib_mad_send_buf
*send_buf
,
214 struct ib_mad_recv_wc
*mad_recv_wc
)
216 struct ib_umad_file
*file
= agent
->context
;
217 struct ib_umad_packet
*packet
;
219 if (mad_recv_wc
->wc
->status
!= IB_WC_SUCCESS
)
222 packet
= kzalloc(sizeof *packet
, GFP_KERNEL
);
226 packet
->length
= mad_recv_wc
->mad_len
;
227 packet
->recv_wc
= mad_recv_wc
;
229 packet
->mad
.hdr
.status
= 0;
230 packet
->mad
.hdr
.length
= hdr_size(file
) + mad_recv_wc
->mad_len
;
231 packet
->mad
.hdr
.qpn
= cpu_to_be32(mad_recv_wc
->wc
->src_qp
);
232 packet
->mad
.hdr
.lid
= cpu_to_be16(mad_recv_wc
->wc
->slid
);
233 packet
->mad
.hdr
.sl
= mad_recv_wc
->wc
->sl
;
234 packet
->mad
.hdr
.path_bits
= mad_recv_wc
->wc
->dlid_path_bits
;
235 packet
->mad
.hdr
.pkey_index
= mad_recv_wc
->wc
->pkey_index
;
236 packet
->mad
.hdr
.grh_present
= !!(mad_recv_wc
->wc
->wc_flags
& IB_WC_GRH
);
237 if (packet
->mad
.hdr
.grh_present
) {
238 struct rdma_ah_attr ah_attr
;
239 const struct ib_global_route
*grh
;
241 ib_init_ah_from_wc(agent
->device
, agent
->port_num
,
242 mad_recv_wc
->wc
, mad_recv_wc
->recv_buf
.grh
,
245 grh
= rdma_ah_read_grh(&ah_attr
);
246 packet
->mad
.hdr
.gid_index
= grh
->sgid_index
;
247 packet
->mad
.hdr
.hop_limit
= grh
->hop_limit
;
248 packet
->mad
.hdr
.traffic_class
= grh
->traffic_class
;
249 memcpy(packet
->mad
.hdr
.gid
, &grh
->dgid
, 16);
250 packet
->mad
.hdr
.flow_label
= cpu_to_be32(grh
->flow_label
);
253 if (queue_packet(file
, agent
, packet
))
260 ib_free_recv_mad(mad_recv_wc
);
263 static ssize_t
copy_recv_mad(struct ib_umad_file
*file
, char __user
*buf
,
264 struct ib_umad_packet
*packet
, size_t count
)
266 struct ib_mad_recv_buf
*recv_buf
;
267 int left
, seg_payload
, offset
, max_seg_payload
;
270 recv_buf
= &packet
->recv_wc
->recv_buf
;
271 seg_size
= packet
->recv_wc
->mad_seg_size
;
273 /* We need enough room to copy the first (or only) MAD segment. */
274 if ((packet
->length
<= seg_size
&&
275 count
< hdr_size(file
) + packet
->length
) ||
276 (packet
->length
> seg_size
&&
277 count
< hdr_size(file
) + seg_size
))
280 if (copy_to_user(buf
, &packet
->mad
, hdr_size(file
)))
283 buf
+= hdr_size(file
);
284 seg_payload
= min_t(int, packet
->length
, seg_size
);
285 if (copy_to_user(buf
, recv_buf
->mad
, seg_payload
))
288 if (seg_payload
< packet
->length
) {
290 * Multipacket RMPP MAD message. Copy remainder of message.
291 * Note that last segment may have a shorter payload.
293 if (count
< hdr_size(file
) + packet
->length
) {
295 * The buffer is too small, return the first RMPP segment,
296 * which includes the RMPP message length.
300 offset
= ib_get_mad_data_offset(recv_buf
->mad
->mad_hdr
.mgmt_class
);
301 max_seg_payload
= seg_size
- offset
;
303 for (left
= packet
->length
- seg_payload
, buf
+= seg_payload
;
304 left
; left
-= seg_payload
, buf
+= seg_payload
) {
305 recv_buf
= container_of(recv_buf
->list
.next
,
306 struct ib_mad_recv_buf
, list
);
307 seg_payload
= min(left
, max_seg_payload
);
308 if (copy_to_user(buf
, ((void *) recv_buf
->mad
) + offset
,
313 return hdr_size(file
) + packet
->length
;
316 static ssize_t
copy_send_mad(struct ib_umad_file
*file
, char __user
*buf
,
317 struct ib_umad_packet
*packet
, size_t count
)
319 ssize_t size
= hdr_size(file
) + packet
->length
;
324 if (copy_to_user(buf
, &packet
->mad
, hdr_size(file
)))
327 buf
+= hdr_size(file
);
329 if (copy_to_user(buf
, packet
->mad
.data
, packet
->length
))
335 static ssize_t
ib_umad_read(struct file
*filp
, char __user
*buf
,
336 size_t count
, loff_t
*pos
)
338 struct ib_umad_file
*file
= filp
->private_data
;
339 struct ib_umad_packet
*packet
;
342 if (count
< hdr_size(file
))
345 mutex_lock(&file
->mutex
);
347 while (list_empty(&file
->recv_list
)) {
348 mutex_unlock(&file
->mutex
);
350 if (filp
->f_flags
& O_NONBLOCK
)
353 if (wait_event_interruptible(file
->recv_wait
,
354 !list_empty(&file
->recv_list
)))
357 mutex_lock(&file
->mutex
);
360 packet
= list_entry(file
->recv_list
.next
, struct ib_umad_packet
, list
);
361 list_del(&packet
->list
);
363 mutex_unlock(&file
->mutex
);
366 ret
= copy_recv_mad(file
, buf
, packet
, count
);
368 ret
= copy_send_mad(file
, buf
, packet
, count
);
372 mutex_lock(&file
->mutex
);
373 list_add(&packet
->list
, &file
->recv_list
);
374 mutex_unlock(&file
->mutex
);
377 ib_free_recv_mad(packet
->recv_wc
);
383 static int copy_rmpp_mad(struct ib_mad_send_buf
*msg
, const char __user
*buf
)
387 /* Copy class specific header */
388 if ((msg
->hdr_len
> IB_MGMT_RMPP_HDR
) &&
389 copy_from_user(msg
->mad
+ IB_MGMT_RMPP_HDR
, buf
+ IB_MGMT_RMPP_HDR
,
390 msg
->hdr_len
- IB_MGMT_RMPP_HDR
))
393 /* All headers are in place. Copy data segments. */
394 for (seg
= 1, left
= msg
->data_len
, buf
+= msg
->hdr_len
; left
> 0;
395 seg
++, left
-= msg
->seg_size
, buf
+= msg
->seg_size
) {
396 if (copy_from_user(ib_get_rmpp_segment(msg
, seg
), buf
,
397 min(left
, msg
->seg_size
)))
403 static int same_destination(struct ib_user_mad_hdr
*hdr1
,
404 struct ib_user_mad_hdr
*hdr2
)
406 if (!hdr1
->grh_present
&& !hdr2
->grh_present
)
407 return (hdr1
->lid
== hdr2
->lid
);
409 if (hdr1
->grh_present
&& hdr2
->grh_present
)
410 return !memcmp(hdr1
->gid
, hdr2
->gid
, 16);
415 static int is_duplicate(struct ib_umad_file
*file
,
416 struct ib_umad_packet
*packet
)
418 struct ib_umad_packet
*sent_packet
;
419 struct ib_mad_hdr
*sent_hdr
, *hdr
;
421 hdr
= (struct ib_mad_hdr
*) packet
->mad
.data
;
422 list_for_each_entry(sent_packet
, &file
->send_list
, list
) {
423 sent_hdr
= (struct ib_mad_hdr
*) sent_packet
->mad
.data
;
425 if ((hdr
->tid
!= sent_hdr
->tid
) ||
426 (hdr
->mgmt_class
!= sent_hdr
->mgmt_class
))
430 * No need to be overly clever here. If two new operations have
431 * the same TID, reject the second as a duplicate. This is more
432 * restrictive than required by the spec.
434 if (!ib_response_mad(hdr
)) {
435 if (!ib_response_mad(sent_hdr
))
438 } else if (!ib_response_mad(sent_hdr
))
441 if (same_destination(&packet
->mad
.hdr
, &sent_packet
->mad
.hdr
))
448 static ssize_t
ib_umad_write(struct file
*filp
, const char __user
*buf
,
449 size_t count
, loff_t
*pos
)
451 struct ib_umad_file
*file
= filp
->private_data
;
452 struct ib_umad_packet
*packet
;
453 struct ib_mad_agent
*agent
;
454 struct rdma_ah_attr ah_attr
;
456 struct ib_rmpp_mad
*rmpp_mad
;
458 int ret
, data_len
, hdr_len
, copy_offset
, rmpp_active
;
461 if (count
< hdr_size(file
) + IB_MGMT_RMPP_HDR
)
464 packet
= kzalloc(sizeof *packet
+ IB_MGMT_RMPP_HDR
, GFP_KERNEL
);
468 if (copy_from_user(&packet
->mad
, buf
, hdr_size(file
))) {
473 if (packet
->mad
.hdr
.id
>= IB_UMAD_MAX_AGENTS
) {
478 buf
+= hdr_size(file
);
480 if (copy_from_user(packet
->mad
.data
, buf
, IB_MGMT_RMPP_HDR
)) {
485 mutex_lock(&file
->mutex
);
487 agent
= __get_agent(file
, packet
->mad
.hdr
.id
);
493 memset(&ah_attr
, 0, sizeof ah_attr
);
494 ah_attr
.type
= rdma_ah_find_type(file
->port
->ib_dev
,
495 file
->port
->port_num
);
496 rdma_ah_set_dlid(&ah_attr
, be16_to_cpu(packet
->mad
.hdr
.lid
));
497 rdma_ah_set_sl(&ah_attr
, packet
->mad
.hdr
.sl
);
498 rdma_ah_set_path_bits(&ah_attr
, packet
->mad
.hdr
.path_bits
);
499 rdma_ah_set_port_num(&ah_attr
, file
->port
->port_num
);
500 if (packet
->mad
.hdr
.grh_present
) {
501 rdma_ah_set_grh(&ah_attr
, NULL
,
502 be32_to_cpu(packet
->mad
.hdr
.flow_label
),
503 packet
->mad
.hdr
.gid_index
,
504 packet
->mad
.hdr
.hop_limit
,
505 packet
->mad
.hdr
.traffic_class
);
506 rdma_ah_set_dgid_raw(&ah_attr
, packet
->mad
.hdr
.gid
);
509 ah
= rdma_create_ah(agent
->qp
->pd
, &ah_attr
);
515 rmpp_mad
= (struct ib_rmpp_mad
*) packet
->mad
.data
;
516 hdr_len
= ib_get_mad_data_offset(rmpp_mad
->mad_hdr
.mgmt_class
);
518 if (ib_is_mad_class_rmpp(rmpp_mad
->mad_hdr
.mgmt_class
)
519 && ib_mad_kernel_rmpp_agent(agent
)) {
520 copy_offset
= IB_MGMT_RMPP_HDR
;
521 rmpp_active
= ib_get_rmpp_flags(&rmpp_mad
->rmpp_hdr
) &
522 IB_MGMT_RMPP_FLAG_ACTIVE
;
524 copy_offset
= IB_MGMT_MAD_HDR
;
528 base_version
= ((struct ib_mad_hdr
*)&packet
->mad
.data
)->base_version
;
529 data_len
= count
- hdr_size(file
) - hdr_len
;
530 packet
->msg
= ib_create_send_mad(agent
,
531 be32_to_cpu(packet
->mad
.hdr
.qpn
),
532 packet
->mad
.hdr
.pkey_index
, rmpp_active
,
533 hdr_len
, data_len
, GFP_KERNEL
,
535 if (IS_ERR(packet
->msg
)) {
536 ret
= PTR_ERR(packet
->msg
);
540 packet
->msg
->ah
= ah
;
541 packet
->msg
->timeout_ms
= packet
->mad
.hdr
.timeout_ms
;
542 packet
->msg
->retries
= packet
->mad
.hdr
.retries
;
543 packet
->msg
->context
[0] = packet
;
545 /* Copy MAD header. Any RMPP header is already in place. */
546 memcpy(packet
->msg
->mad
, packet
->mad
.data
, IB_MGMT_MAD_HDR
);
549 if (copy_from_user(packet
->msg
->mad
+ copy_offset
,
551 hdr_len
+ data_len
- copy_offset
)) {
556 ret
= copy_rmpp_mad(packet
->msg
, buf
);
562 * Set the high-order part of the transaction ID to make MADs from
563 * different agents unique, and allow routing responses back to the
564 * original requestor.
566 if (!ib_response_mad(packet
->msg
->mad
)) {
567 tid
= &((struct ib_mad_hdr
*) packet
->msg
->mad
)->tid
;
568 *tid
= cpu_to_be64(((u64
) agent
->hi_tid
) << 32 |
569 (be64_to_cpup(tid
) & 0xffffffff));
570 rmpp_mad
->mad_hdr
.tid
= *tid
;
573 if (!ib_mad_kernel_rmpp_agent(agent
)
574 && ib_is_mad_class_rmpp(rmpp_mad
->mad_hdr
.mgmt_class
)
575 && (ib_get_rmpp_flags(&rmpp_mad
->rmpp_hdr
) & IB_MGMT_RMPP_FLAG_ACTIVE
)) {
576 spin_lock_irq(&file
->send_lock
);
577 list_add_tail(&packet
->list
, &file
->send_list
);
578 spin_unlock_irq(&file
->send_lock
);
580 spin_lock_irq(&file
->send_lock
);
581 ret
= is_duplicate(file
, packet
);
583 list_add_tail(&packet
->list
, &file
->send_list
);
584 spin_unlock_irq(&file
->send_lock
);
591 ret
= ib_post_send_mad(packet
->msg
, NULL
);
595 mutex_unlock(&file
->mutex
);
599 dequeue_send(file
, packet
);
601 ib_free_send_mad(packet
->msg
);
605 mutex_unlock(&file
->mutex
);
611 static unsigned int ib_umad_poll(struct file
*filp
, struct poll_table_struct
*wait
)
613 struct ib_umad_file
*file
= filp
->private_data
;
615 /* we will always be able to post a MAD send */
616 unsigned int mask
= POLLOUT
| POLLWRNORM
;
618 poll_wait(filp
, &file
->recv_wait
, wait
);
620 if (!list_empty(&file
->recv_list
))
621 mask
|= POLLIN
| POLLRDNORM
;
626 static int ib_umad_reg_agent(struct ib_umad_file
*file
, void __user
*arg
,
627 int compat_method_mask
)
629 struct ib_user_mad_reg_req ureq
;
630 struct ib_mad_reg_req req
;
631 struct ib_mad_agent
*agent
= NULL
;
635 mutex_lock(&file
->port
->file_mutex
);
636 mutex_lock(&file
->mutex
);
638 if (!file
->port
->ib_dev
) {
639 dev_notice(file
->port
->dev
,
640 "ib_umad_reg_agent: invalid device\n");
645 if (copy_from_user(&ureq
, arg
, sizeof ureq
)) {
650 if (ureq
.qpn
!= 0 && ureq
.qpn
!= 1) {
651 dev_notice(file
->port
->dev
,
652 "ib_umad_reg_agent: invalid QPN %d specified\n",
658 for (agent_id
= 0; agent_id
< IB_UMAD_MAX_AGENTS
; ++agent_id
)
659 if (!__get_agent(file
, agent_id
))
662 dev_notice(file
->port
->dev
,
663 "ib_umad_reg_agent: Max Agents (%u) reached\n",
669 if (ureq
.mgmt_class
) {
670 memset(&req
, 0, sizeof(req
));
671 req
.mgmt_class
= ureq
.mgmt_class
;
672 req
.mgmt_class_version
= ureq
.mgmt_class_version
;
673 memcpy(req
.oui
, ureq
.oui
, sizeof req
.oui
);
675 if (compat_method_mask
) {
676 u32
*umm
= (u32
*) ureq
.method_mask
;
679 for (i
= 0; i
< BITS_TO_LONGS(IB_MGMT_MAX_METHODS
); ++i
)
681 umm
[i
* 2] | ((u64
) umm
[i
* 2 + 1] << 32);
683 memcpy(req
.method_mask
, ureq
.method_mask
,
684 sizeof req
.method_mask
);
687 agent
= ib_register_mad_agent(file
->port
->ib_dev
, file
->port
->port_num
,
688 ureq
.qpn
? IB_QPT_GSI
: IB_QPT_SMI
,
689 ureq
.mgmt_class
? &req
: NULL
,
691 send_handler
, recv_handler
, file
, 0);
693 ret
= PTR_ERR(agent
);
698 if (put_user(agent_id
,
699 (u32 __user
*) (arg
+ offsetof(struct ib_user_mad_reg_req
, id
)))) {
704 if (!file
->already_used
) {
705 file
->already_used
= 1;
706 if (!file
->use_pkey_index
) {
707 dev_warn(file
->port
->dev
,
708 "process %s did not enable P_Key index support.\n",
710 dev_warn(file
->port
->dev
,
711 " Documentation/infiniband/user_mad.txt has info on the new ABI.\n");
715 file
->agent
[agent_id
] = agent
;
719 mutex_unlock(&file
->mutex
);
722 ib_unregister_mad_agent(agent
);
724 mutex_unlock(&file
->port
->file_mutex
);
729 static int ib_umad_reg_agent2(struct ib_umad_file
*file
, void __user
*arg
)
731 struct ib_user_mad_reg_req2 ureq
;
732 struct ib_mad_reg_req req
;
733 struct ib_mad_agent
*agent
= NULL
;
737 mutex_lock(&file
->port
->file_mutex
);
738 mutex_lock(&file
->mutex
);
740 if (!file
->port
->ib_dev
) {
741 dev_notice(file
->port
->dev
,
742 "ib_umad_reg_agent2: invalid device\n");
747 if (copy_from_user(&ureq
, arg
, sizeof(ureq
))) {
752 if (ureq
.qpn
!= 0 && ureq
.qpn
!= 1) {
753 dev_notice(file
->port
->dev
,
754 "ib_umad_reg_agent2: invalid QPN %d specified\n",
760 if (ureq
.flags
& ~IB_USER_MAD_REG_FLAGS_CAP
) {
761 dev_notice(file
->port
->dev
,
762 "ib_umad_reg_agent2 failed: invalid registration flags specified 0x%x; supported 0x%x\n",
763 ureq
.flags
, IB_USER_MAD_REG_FLAGS_CAP
);
766 if (put_user((u32
)IB_USER_MAD_REG_FLAGS_CAP
,
767 (u32 __user
*) (arg
+ offsetof(struct
768 ib_user_mad_reg_req2
, flags
))))
774 for (agent_id
= 0; agent_id
< IB_UMAD_MAX_AGENTS
; ++agent_id
)
775 if (!__get_agent(file
, agent_id
))
778 dev_notice(file
->port
->dev
,
779 "ib_umad_reg_agent2: Max Agents (%u) reached\n",
785 if (ureq
.mgmt_class
) {
786 memset(&req
, 0, sizeof(req
));
787 req
.mgmt_class
= ureq
.mgmt_class
;
788 req
.mgmt_class_version
= ureq
.mgmt_class_version
;
789 if (ureq
.oui
& 0xff000000) {
790 dev_notice(file
->port
->dev
,
791 "ib_umad_reg_agent2 failed: oui invalid 0x%08x\n",
796 req
.oui
[2] = ureq
.oui
& 0x0000ff;
797 req
.oui
[1] = (ureq
.oui
& 0x00ff00) >> 8;
798 req
.oui
[0] = (ureq
.oui
& 0xff0000) >> 16;
799 memcpy(req
.method_mask
, ureq
.method_mask
,
800 sizeof(req
.method_mask
));
803 agent
= ib_register_mad_agent(file
->port
->ib_dev
, file
->port
->port_num
,
804 ureq
.qpn
? IB_QPT_GSI
: IB_QPT_SMI
,
805 ureq
.mgmt_class
? &req
: NULL
,
807 send_handler
, recv_handler
, file
,
810 ret
= PTR_ERR(agent
);
815 if (put_user(agent_id
,
817 offsetof(struct ib_user_mad_reg_req2
, id
)))) {
822 if (!file
->already_used
) {
823 file
->already_used
= 1;
824 file
->use_pkey_index
= 1;
827 file
->agent
[agent_id
] = agent
;
831 mutex_unlock(&file
->mutex
);
834 ib_unregister_mad_agent(agent
);
836 mutex_unlock(&file
->port
->file_mutex
);
842 static int ib_umad_unreg_agent(struct ib_umad_file
*file
, u32 __user
*arg
)
844 struct ib_mad_agent
*agent
= NULL
;
848 if (get_user(id
, arg
))
851 mutex_lock(&file
->port
->file_mutex
);
852 mutex_lock(&file
->mutex
);
854 if (id
>= IB_UMAD_MAX_AGENTS
|| !__get_agent(file
, id
)) {
859 agent
= file
->agent
[id
];
860 file
->agent
[id
] = NULL
;
863 mutex_unlock(&file
->mutex
);
866 ib_unregister_mad_agent(agent
);
868 mutex_unlock(&file
->port
->file_mutex
);
873 static long ib_umad_enable_pkey(struct ib_umad_file
*file
)
877 mutex_lock(&file
->mutex
);
878 if (file
->already_used
)
881 file
->use_pkey_index
= 1;
882 mutex_unlock(&file
->mutex
);
887 static long ib_umad_ioctl(struct file
*filp
, unsigned int cmd
,
891 case IB_USER_MAD_REGISTER_AGENT
:
892 return ib_umad_reg_agent(filp
->private_data
, (void __user
*) arg
, 0);
893 case IB_USER_MAD_UNREGISTER_AGENT
:
894 return ib_umad_unreg_agent(filp
->private_data
, (__u32 __user
*) arg
);
895 case IB_USER_MAD_ENABLE_PKEY
:
896 return ib_umad_enable_pkey(filp
->private_data
);
897 case IB_USER_MAD_REGISTER_AGENT2
:
898 return ib_umad_reg_agent2(filp
->private_data
, (void __user
*) arg
);
905 static long ib_umad_compat_ioctl(struct file
*filp
, unsigned int cmd
,
909 case IB_USER_MAD_REGISTER_AGENT
:
910 return ib_umad_reg_agent(filp
->private_data
, compat_ptr(arg
), 1);
911 case IB_USER_MAD_UNREGISTER_AGENT
:
912 return ib_umad_unreg_agent(filp
->private_data
, compat_ptr(arg
));
913 case IB_USER_MAD_ENABLE_PKEY
:
914 return ib_umad_enable_pkey(filp
->private_data
);
915 case IB_USER_MAD_REGISTER_AGENT2
:
916 return ib_umad_reg_agent2(filp
->private_data
, compat_ptr(arg
));
924 * ib_umad_open() does not need the BKL:
926 * - the ib_umad_port structures are properly reference counted, and
927 * everything else is purely local to the file being created, so
928 * races against other open calls are not a problem;
929 * - the ioctl method does not affect any global state outside of the
930 * file structure being operated on;
932 static int ib_umad_open(struct inode
*inode
, struct file
*filp
)
934 struct ib_umad_port
*port
;
935 struct ib_umad_file
*file
;
938 port
= container_of(inode
->i_cdev
, struct ib_umad_port
, cdev
);
940 mutex_lock(&port
->file_mutex
);
946 file
= kzalloc(sizeof *file
, GFP_KERNEL
);
950 mutex_init(&file
->mutex
);
951 spin_lock_init(&file
->send_lock
);
952 INIT_LIST_HEAD(&file
->recv_list
);
953 INIT_LIST_HEAD(&file
->send_list
);
954 init_waitqueue_head(&file
->recv_wait
);
957 filp
->private_data
= file
;
959 list_add_tail(&file
->port_list
, &port
->file_list
);
961 ret
= nonseekable_open(inode
, filp
);
963 list_del(&file
->port_list
);
968 kobject_get(&port
->umad_dev
->kobj
);
971 mutex_unlock(&port
->file_mutex
);
975 static int ib_umad_close(struct inode
*inode
, struct file
*filp
)
977 struct ib_umad_file
*file
= filp
->private_data
;
978 struct ib_umad_device
*dev
= file
->port
->umad_dev
;
979 struct ib_umad_packet
*packet
, *tmp
;
983 mutex_lock(&file
->port
->file_mutex
);
984 mutex_lock(&file
->mutex
);
986 already_dead
= file
->agents_dead
;
987 file
->agents_dead
= 1;
989 list_for_each_entry_safe(packet
, tmp
, &file
->recv_list
, list
) {
991 ib_free_recv_mad(packet
->recv_wc
);
995 list_del(&file
->port_list
);
997 mutex_unlock(&file
->mutex
);
1000 for (i
= 0; i
< IB_UMAD_MAX_AGENTS
; ++i
)
1002 ib_unregister_mad_agent(file
->agent
[i
]);
1004 mutex_unlock(&file
->port
->file_mutex
);
1007 kobject_put(&dev
->kobj
);
1012 static const struct file_operations umad_fops
= {
1013 .owner
= THIS_MODULE
,
1014 .read
= ib_umad_read
,
1015 .write
= ib_umad_write
,
1016 .poll
= ib_umad_poll
,
1017 .unlocked_ioctl
= ib_umad_ioctl
,
1018 #ifdef CONFIG_COMPAT
1019 .compat_ioctl
= ib_umad_compat_ioctl
,
1021 .open
= ib_umad_open
,
1022 .release
= ib_umad_close
,
1023 .llseek
= no_llseek
,
1026 static int ib_umad_sm_open(struct inode
*inode
, struct file
*filp
)
1028 struct ib_umad_port
*port
;
1029 struct ib_port_modify props
= {
1030 .set_port_cap_mask
= IB_PORT_SM
1034 port
= container_of(inode
->i_cdev
, struct ib_umad_port
, sm_cdev
);
1036 if (filp
->f_flags
& O_NONBLOCK
) {
1037 if (down_trylock(&port
->sm_sem
)) {
1042 if (down_interruptible(&port
->sm_sem
)) {
1048 ret
= ib_modify_port(port
->ib_dev
, port
->port_num
, 0, &props
);
1052 filp
->private_data
= port
;
1054 ret
= nonseekable_open(inode
, filp
);
1056 goto err_clr_sm_cap
;
1058 kobject_get(&port
->umad_dev
->kobj
);
1063 swap(props
.set_port_cap_mask
, props
.clr_port_cap_mask
);
1064 ib_modify_port(port
->ib_dev
, port
->port_num
, 0, &props
);
1073 static int ib_umad_sm_close(struct inode
*inode
, struct file
*filp
)
1075 struct ib_umad_port
*port
= filp
->private_data
;
1076 struct ib_port_modify props
= {
1077 .clr_port_cap_mask
= IB_PORT_SM
1081 mutex_lock(&port
->file_mutex
);
1083 ret
= ib_modify_port(port
->ib_dev
, port
->port_num
, 0, &props
);
1084 mutex_unlock(&port
->file_mutex
);
1088 kobject_put(&port
->umad_dev
->kobj
);
1093 static const struct file_operations umad_sm_fops
= {
1094 .owner
= THIS_MODULE
,
1095 .open
= ib_umad_sm_open
,
1096 .release
= ib_umad_sm_close
,
1097 .llseek
= no_llseek
,
1100 static struct ib_client umad_client
= {
1102 .add
= ib_umad_add_one
,
1103 .remove
= ib_umad_remove_one
1106 static ssize_t
show_ibdev(struct device
*dev
, struct device_attribute
*attr
,
1109 struct ib_umad_port
*port
= dev_get_drvdata(dev
);
1114 return sprintf(buf
, "%s\n", port
->ib_dev
->name
);
1116 static DEVICE_ATTR(ibdev
, S_IRUGO
, show_ibdev
, NULL
);
1118 static ssize_t
show_port(struct device
*dev
, struct device_attribute
*attr
,
1121 struct ib_umad_port
*port
= dev_get_drvdata(dev
);
1126 return sprintf(buf
, "%d\n", port
->port_num
);
1128 static DEVICE_ATTR(port
, S_IRUGO
, show_port
, NULL
);
1130 static CLASS_ATTR_STRING(abi_version
, S_IRUGO
,
1131 __stringify(IB_USER_MAD_ABI_VERSION
));
1133 static dev_t overflow_maj
;
1134 static DECLARE_BITMAP(overflow_map
, IB_UMAD_MAX_PORTS
);
1135 static int find_overflow_devnum(struct ib_device
*device
)
1139 if (!overflow_maj
) {
1140 ret
= alloc_chrdev_region(&overflow_maj
, 0, IB_UMAD_MAX_PORTS
* 2,
1143 dev_err(&device
->dev
,
1144 "couldn't register dynamic device number\n");
1149 ret
= find_first_zero_bit(overflow_map
, IB_UMAD_MAX_PORTS
);
1150 if (ret
>= IB_UMAD_MAX_PORTS
)
1156 static int ib_umad_init_port(struct ib_device
*device
, int port_num
,
1157 struct ib_umad_device
*umad_dev
,
1158 struct ib_umad_port
*port
)
1163 spin_lock(&port_lock
);
1164 devnum
= find_first_zero_bit(dev_map
, IB_UMAD_MAX_PORTS
);
1165 if (devnum
>= IB_UMAD_MAX_PORTS
) {
1166 spin_unlock(&port_lock
);
1167 devnum
= find_overflow_devnum(device
);
1171 spin_lock(&port_lock
);
1172 port
->dev_num
= devnum
+ IB_UMAD_MAX_PORTS
;
1173 base
= devnum
+ overflow_maj
;
1174 set_bit(devnum
, overflow_map
);
1176 port
->dev_num
= devnum
;
1177 base
= devnum
+ base_dev
;
1178 set_bit(devnum
, dev_map
);
1180 spin_unlock(&port_lock
);
1182 port
->ib_dev
= device
;
1183 port
->port_num
= port_num
;
1184 sema_init(&port
->sm_sem
, 1);
1185 mutex_init(&port
->file_mutex
);
1186 INIT_LIST_HEAD(&port
->file_list
);
1188 cdev_init(&port
->cdev
, &umad_fops
);
1189 port
->cdev
.owner
= THIS_MODULE
;
1190 cdev_set_parent(&port
->cdev
, &umad_dev
->kobj
);
1191 kobject_set_name(&port
->cdev
.kobj
, "umad%d", port
->dev_num
);
1192 if (cdev_add(&port
->cdev
, base
, 1))
1195 port
->dev
= device_create(umad_class
, device
->dev
.parent
,
1196 port
->cdev
.dev
, port
,
1197 "umad%d", port
->dev_num
);
1198 if (IS_ERR(port
->dev
))
1201 if (device_create_file(port
->dev
, &dev_attr_ibdev
))
1203 if (device_create_file(port
->dev
, &dev_attr_port
))
1206 base
+= IB_UMAD_MAX_PORTS
;
1207 cdev_init(&port
->sm_cdev
, &umad_sm_fops
);
1208 port
->sm_cdev
.owner
= THIS_MODULE
;
1209 cdev_set_parent(&port
->sm_cdev
, &umad_dev
->kobj
);
1210 kobject_set_name(&port
->sm_cdev
.kobj
, "issm%d", port
->dev_num
);
1211 if (cdev_add(&port
->sm_cdev
, base
, 1))
1214 port
->sm_dev
= device_create(umad_class
, device
->dev
.parent
,
1215 port
->sm_cdev
.dev
, port
,
1216 "issm%d", port
->dev_num
);
1217 if (IS_ERR(port
->sm_dev
))
1220 if (device_create_file(port
->sm_dev
, &dev_attr_ibdev
))
1222 if (device_create_file(port
->sm_dev
, &dev_attr_port
))
1228 device_destroy(umad_class
, port
->sm_cdev
.dev
);
1231 cdev_del(&port
->sm_cdev
);
1234 device_destroy(umad_class
, port
->cdev
.dev
);
1237 cdev_del(&port
->cdev
);
1238 if (port
->dev_num
< IB_UMAD_MAX_PORTS
)
1239 clear_bit(devnum
, dev_map
);
1241 clear_bit(devnum
, overflow_map
);
1246 static void ib_umad_kill_port(struct ib_umad_port
*port
)
1248 struct ib_umad_file
*file
;
1251 dev_set_drvdata(port
->dev
, NULL
);
1252 dev_set_drvdata(port
->sm_dev
, NULL
);
1254 device_destroy(umad_class
, port
->cdev
.dev
);
1255 device_destroy(umad_class
, port
->sm_cdev
.dev
);
1257 cdev_del(&port
->cdev
);
1258 cdev_del(&port
->sm_cdev
);
1260 mutex_lock(&port
->file_mutex
);
1262 port
->ib_dev
= NULL
;
1264 list_for_each_entry(file
, &port
->file_list
, port_list
) {
1265 mutex_lock(&file
->mutex
);
1266 file
->agents_dead
= 1;
1267 mutex_unlock(&file
->mutex
);
1269 for (id
= 0; id
< IB_UMAD_MAX_AGENTS
; ++id
)
1270 if (file
->agent
[id
])
1271 ib_unregister_mad_agent(file
->agent
[id
]);
1274 mutex_unlock(&port
->file_mutex
);
1276 if (port
->dev_num
< IB_UMAD_MAX_PORTS
)
1277 clear_bit(port
->dev_num
, dev_map
);
1279 clear_bit(port
->dev_num
- IB_UMAD_MAX_PORTS
, overflow_map
);
1282 static void ib_umad_add_one(struct ib_device
*device
)
1284 struct ib_umad_device
*umad_dev
;
1288 s
= rdma_start_port(device
);
1289 e
= rdma_end_port(device
);
1291 umad_dev
= kzalloc(sizeof *umad_dev
+
1292 (e
- s
+ 1) * sizeof (struct ib_umad_port
),
1297 kobject_init(&umad_dev
->kobj
, &ib_umad_dev_ktype
);
1299 for (i
= s
; i
<= e
; ++i
) {
1300 if (!rdma_cap_ib_mad(device
, i
))
1303 umad_dev
->port
[i
- s
].umad_dev
= umad_dev
;
1305 if (ib_umad_init_port(device
, i
, umad_dev
,
1306 &umad_dev
->port
[i
- s
]))
1315 ib_set_client_data(device
, &umad_client
, umad_dev
);
1321 if (!rdma_cap_ib_mad(device
, i
))
1324 ib_umad_kill_port(&umad_dev
->port
[i
- s
]);
1327 kobject_put(&umad_dev
->kobj
);
1330 static void ib_umad_remove_one(struct ib_device
*device
, void *client_data
)
1332 struct ib_umad_device
*umad_dev
= client_data
;
1338 for (i
= 0; i
<= rdma_end_port(device
) - rdma_start_port(device
); ++i
) {
1339 if (rdma_cap_ib_mad(device
, i
+ rdma_start_port(device
)))
1340 ib_umad_kill_port(&umad_dev
->port
[i
]);
1343 kobject_put(&umad_dev
->kobj
);
1346 static char *umad_devnode(struct device
*dev
, umode_t
*mode
)
1348 return kasprintf(GFP_KERNEL
, "infiniband/%s", dev_name(dev
));
1351 static int __init
ib_umad_init(void)
1355 ret
= register_chrdev_region(base_dev
, IB_UMAD_MAX_PORTS
* 2,
1358 pr_err("couldn't register device number\n");
1362 umad_class
= class_create(THIS_MODULE
, "infiniband_mad");
1363 if (IS_ERR(umad_class
)) {
1364 ret
= PTR_ERR(umad_class
);
1365 pr_err("couldn't create class infiniband_mad\n");
1369 umad_class
->devnode
= umad_devnode
;
1371 ret
= class_create_file(umad_class
, &class_attr_abi_version
.attr
);
1373 pr_err("couldn't create abi_version attribute\n");
1377 ret
= ib_register_client(&umad_client
);
1379 pr_err("couldn't register ib_umad client\n");
1386 class_destroy(umad_class
);
1389 unregister_chrdev_region(base_dev
, IB_UMAD_MAX_PORTS
* 2);
1395 static void __exit
ib_umad_cleanup(void)
1397 ib_unregister_client(&umad_client
);
1398 class_destroy(umad_class
);
1399 unregister_chrdev_region(base_dev
, IB_UMAD_MAX_PORTS
* 2);
1401 unregister_chrdev_region(overflow_maj
, IB_UMAD_MAX_PORTS
* 2);
1404 module_init(ib_umad_init
);
1405 module_exit(ib_umad_cleanup
);