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 #include "core_priv.h"
60 MODULE_AUTHOR("Roland Dreier");
61 MODULE_DESCRIPTION("InfiniBand userspace MAD packet access");
62 MODULE_LICENSE("Dual BSD/GPL");
65 IB_UMAD_MAX_PORTS = RDMA_MAX_PORTS,
66 IB_UMAD_MAX_AGENTS = 32,
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,
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().
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
86 * When destroying an ib_umad_device, we drop the module's reference.
94 struct semaphore sm_sem;
96 struct mutex file_mutex;
97 struct list_head file_list;
99 struct ib_device *ib_dev;
100 struct ib_umad_device *umad_dev;
105 struct ib_umad_device {
107 struct ib_umad_port ports[];
110 struct ib_umad_file {
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];
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;
129 struct ib_user_mad mad;
132 #define CREATE_TRACE_POINTS
133 #include <trace/events/ib_umad.h>
135 static const dev_t base_umad_dev = MKDEV(IB_UMAD_MAJOR, IB_UMAD_MINOR_BASE);
136 static const dev_t base_issm_dev = MKDEV(IB_UMAD_MAJOR, IB_UMAD_MINOR_BASE) +
137 IB_UMAD_NUM_FIXED_MINOR;
138 static dev_t dynamic_umad_dev;
139 static dev_t dynamic_issm_dev;
141 static DEFINE_IDA(umad_ida);
143 static void ib_umad_add_one(struct ib_device *device);
144 static void ib_umad_remove_one(struct ib_device *device, void *client_data);
146 static void ib_umad_dev_free(struct kref *kref)
148 struct ib_umad_device *dev =
149 container_of(kref, struct ib_umad_device, kref);
154 static void ib_umad_dev_get(struct ib_umad_device *dev)
156 kref_get(&dev->kref);
159 static void ib_umad_dev_put(struct ib_umad_device *dev)
161 kref_put(&dev->kref, ib_umad_dev_free);
164 static int hdr_size(struct ib_umad_file *file)
166 return file->use_pkey_index ? sizeof (struct ib_user_mad_hdr) :
167 sizeof (struct ib_user_mad_hdr_old);
170 /* caller must hold file->mutex */
171 static struct ib_mad_agent *__get_agent(struct ib_umad_file *file, int id)
173 return file->agents_dead ? NULL : file->agent[id];
176 static int queue_packet(struct ib_umad_file *file,
177 struct ib_mad_agent *agent,
178 struct ib_umad_packet *packet)
182 mutex_lock(&file->mutex);
184 for (packet->mad.hdr.id = 0;
185 packet->mad.hdr.id < IB_UMAD_MAX_AGENTS;
186 packet->mad.hdr.id++)
187 if (agent == __get_agent(file, packet->mad.hdr.id)) {
188 list_add_tail(&packet->list, &file->recv_list);
189 wake_up_interruptible(&file->recv_wait);
194 mutex_unlock(&file->mutex);
199 static void dequeue_send(struct ib_umad_file *file,
200 struct ib_umad_packet *packet)
202 spin_lock_irq(&file->send_lock);
203 list_del(&packet->list);
204 spin_unlock_irq(&file->send_lock);
207 static void send_handler(struct ib_mad_agent *agent,
208 struct ib_mad_send_wc *send_wc)
210 struct ib_umad_file *file = agent->context;
211 struct ib_umad_packet *packet = send_wc->send_buf->context[0];
213 dequeue_send(file, packet);
214 rdma_destroy_ah(packet->msg->ah, RDMA_DESTROY_AH_SLEEPABLE);
215 ib_free_send_mad(packet->msg);
217 if (send_wc->status == IB_WC_RESP_TIMEOUT_ERR) {
218 packet->length = IB_MGMT_MAD_HDR;
219 packet->mad.hdr.status = ETIMEDOUT;
220 if (!queue_packet(file, agent, packet))
226 static void recv_handler(struct ib_mad_agent *agent,
227 struct ib_mad_send_buf *send_buf,
228 struct ib_mad_recv_wc *mad_recv_wc)
230 struct ib_umad_file *file = agent->context;
231 struct ib_umad_packet *packet;
233 if (mad_recv_wc->wc->status != IB_WC_SUCCESS)
236 packet = kzalloc(sizeof *packet, GFP_KERNEL);
240 packet->length = mad_recv_wc->mad_len;
241 packet->recv_wc = mad_recv_wc;
243 packet->mad.hdr.status = 0;
244 packet->mad.hdr.length = hdr_size(file) + mad_recv_wc->mad_len;
245 packet->mad.hdr.qpn = cpu_to_be32(mad_recv_wc->wc->src_qp);
247 * On OPA devices it is okay to lose the upper 16 bits of LID as this
248 * information is obtained elsewhere. Mask off the upper 16 bits.
250 if (rdma_cap_opa_mad(agent->device, agent->port_num))
251 packet->mad.hdr.lid = ib_lid_be16(0xFFFF &
252 mad_recv_wc->wc->slid);
254 packet->mad.hdr.lid = ib_lid_be16(mad_recv_wc->wc->slid);
255 packet->mad.hdr.sl = mad_recv_wc->wc->sl;
256 packet->mad.hdr.path_bits = mad_recv_wc->wc->dlid_path_bits;
257 packet->mad.hdr.pkey_index = mad_recv_wc->wc->pkey_index;
258 packet->mad.hdr.grh_present = !!(mad_recv_wc->wc->wc_flags & IB_WC_GRH);
259 if (packet->mad.hdr.grh_present) {
260 struct rdma_ah_attr ah_attr;
261 const struct ib_global_route *grh;
264 ret = ib_init_ah_attr_from_wc(agent->device, agent->port_num,
266 mad_recv_wc->recv_buf.grh,
271 grh = rdma_ah_read_grh(&ah_attr);
272 packet->mad.hdr.gid_index = grh->sgid_index;
273 packet->mad.hdr.hop_limit = grh->hop_limit;
274 packet->mad.hdr.traffic_class = grh->traffic_class;
275 memcpy(packet->mad.hdr.gid, &grh->dgid, 16);
276 packet->mad.hdr.flow_label = cpu_to_be32(grh->flow_label);
277 rdma_destroy_ah_attr(&ah_attr);
280 if (queue_packet(file, agent, packet))
287 ib_free_recv_mad(mad_recv_wc);
290 static ssize_t copy_recv_mad(struct ib_umad_file *file, char __user *buf,
291 struct ib_umad_packet *packet, size_t count)
293 struct ib_mad_recv_buf *recv_buf;
294 int left, seg_payload, offset, max_seg_payload;
297 recv_buf = &packet->recv_wc->recv_buf;
298 seg_size = packet->recv_wc->mad_seg_size;
300 /* We need enough room to copy the first (or only) MAD segment. */
301 if ((packet->length <= seg_size &&
302 count < hdr_size(file) + packet->length) ||
303 (packet->length > seg_size &&
304 count < hdr_size(file) + seg_size))
307 if (copy_to_user(buf, &packet->mad, hdr_size(file)))
310 buf += hdr_size(file);
311 seg_payload = min_t(int, packet->length, seg_size);
312 if (copy_to_user(buf, recv_buf->mad, seg_payload))
315 if (seg_payload < packet->length) {
317 * Multipacket RMPP MAD message. Copy remainder of message.
318 * Note that last segment may have a shorter payload.
320 if (count < hdr_size(file) + packet->length) {
322 * The buffer is too small, return the first RMPP segment,
323 * which includes the RMPP message length.
327 offset = ib_get_mad_data_offset(recv_buf->mad->mad_hdr.mgmt_class);
328 max_seg_payload = seg_size - offset;
330 for (left = packet->length - seg_payload, buf += seg_payload;
331 left; left -= seg_payload, buf += seg_payload) {
332 recv_buf = container_of(recv_buf->list.next,
333 struct ib_mad_recv_buf, list);
334 seg_payload = min(left, max_seg_payload);
335 if (copy_to_user(buf, ((void *) recv_buf->mad) + offset,
341 trace_ib_umad_read_recv(file, &packet->mad.hdr, &recv_buf->mad->mad_hdr);
343 return hdr_size(file) + packet->length;
346 static ssize_t copy_send_mad(struct ib_umad_file *file, char __user *buf,
347 struct ib_umad_packet *packet, size_t count)
349 ssize_t size = hdr_size(file) + packet->length;
354 if (copy_to_user(buf, &packet->mad, hdr_size(file)))
357 buf += hdr_size(file);
359 if (copy_to_user(buf, packet->mad.data, packet->length))
362 trace_ib_umad_read_send(file, &packet->mad.hdr,
363 (struct ib_mad_hdr *)&packet->mad.data);
368 static ssize_t ib_umad_read(struct file *filp, char __user *buf,
369 size_t count, loff_t *pos)
371 struct ib_umad_file *file = filp->private_data;
372 struct ib_umad_packet *packet;
375 if (count < hdr_size(file))
378 mutex_lock(&file->mutex);
380 while (list_empty(&file->recv_list)) {
381 mutex_unlock(&file->mutex);
383 if (filp->f_flags & O_NONBLOCK)
386 if (wait_event_interruptible(file->recv_wait,
387 !list_empty(&file->recv_list)))
390 mutex_lock(&file->mutex);
393 packet = list_entry(file->recv_list.next, struct ib_umad_packet, list);
394 list_del(&packet->list);
396 mutex_unlock(&file->mutex);
399 ret = copy_recv_mad(file, buf, packet, count);
401 ret = copy_send_mad(file, buf, packet, count);
405 mutex_lock(&file->mutex);
406 list_add(&packet->list, &file->recv_list);
407 mutex_unlock(&file->mutex);
410 ib_free_recv_mad(packet->recv_wc);
416 static int copy_rmpp_mad(struct ib_mad_send_buf *msg, const char __user *buf)
420 /* Copy class specific header */
421 if ((msg->hdr_len > IB_MGMT_RMPP_HDR) &&
422 copy_from_user(msg->mad + IB_MGMT_RMPP_HDR, buf + IB_MGMT_RMPP_HDR,
423 msg->hdr_len - IB_MGMT_RMPP_HDR))
426 /* All headers are in place. Copy data segments. */
427 for (seg = 1, left = msg->data_len, buf += msg->hdr_len; left > 0;
428 seg++, left -= msg->seg_size, buf += msg->seg_size) {
429 if (copy_from_user(ib_get_rmpp_segment(msg, seg), buf,
430 min(left, msg->seg_size)))
436 static int same_destination(struct ib_user_mad_hdr *hdr1,
437 struct ib_user_mad_hdr *hdr2)
439 if (!hdr1->grh_present && !hdr2->grh_present)
440 return (hdr1->lid == hdr2->lid);
442 if (hdr1->grh_present && hdr2->grh_present)
443 return !memcmp(hdr1->gid, hdr2->gid, 16);
448 static int is_duplicate(struct ib_umad_file *file,
449 struct ib_umad_packet *packet)
451 struct ib_umad_packet *sent_packet;
452 struct ib_mad_hdr *sent_hdr, *hdr;
454 hdr = (struct ib_mad_hdr *) packet->mad.data;
455 list_for_each_entry(sent_packet, &file->send_list, list) {
456 sent_hdr = (struct ib_mad_hdr *) sent_packet->mad.data;
458 if ((hdr->tid != sent_hdr->tid) ||
459 (hdr->mgmt_class != sent_hdr->mgmt_class))
463 * No need to be overly clever here. If two new operations have
464 * the same TID, reject the second as a duplicate. This is more
465 * restrictive than required by the spec.
467 if (!ib_response_mad(hdr)) {
468 if (!ib_response_mad(sent_hdr))
471 } else if (!ib_response_mad(sent_hdr))
474 if (same_destination(&packet->mad.hdr, &sent_packet->mad.hdr))
481 static ssize_t ib_umad_write(struct file *filp, const char __user *buf,
482 size_t count, loff_t *pos)
484 struct ib_umad_file *file = filp->private_data;
485 struct ib_umad_packet *packet;
486 struct ib_mad_agent *agent;
487 struct rdma_ah_attr ah_attr;
489 struct ib_rmpp_mad *rmpp_mad;
491 int ret, data_len, hdr_len, copy_offset, rmpp_active;
494 if (count < hdr_size(file) + IB_MGMT_RMPP_HDR)
497 packet = kzalloc(sizeof *packet + IB_MGMT_RMPP_HDR, GFP_KERNEL);
501 if (copy_from_user(&packet->mad, buf, hdr_size(file))) {
506 if (packet->mad.hdr.id >= IB_UMAD_MAX_AGENTS) {
511 buf += hdr_size(file);
513 if (copy_from_user(packet->mad.data, buf, IB_MGMT_RMPP_HDR)) {
518 mutex_lock(&file->mutex);
520 trace_ib_umad_write(file, &packet->mad.hdr,
521 (struct ib_mad_hdr *)&packet->mad.data);
523 agent = __get_agent(file, packet->mad.hdr.id);
529 memset(&ah_attr, 0, sizeof ah_attr);
530 ah_attr.type = rdma_ah_find_type(agent->device,
531 file->port->port_num);
532 rdma_ah_set_dlid(&ah_attr, be16_to_cpu(packet->mad.hdr.lid));
533 rdma_ah_set_sl(&ah_attr, packet->mad.hdr.sl);
534 rdma_ah_set_path_bits(&ah_attr, packet->mad.hdr.path_bits);
535 rdma_ah_set_port_num(&ah_attr, file->port->port_num);
536 if (packet->mad.hdr.grh_present) {
537 rdma_ah_set_grh(&ah_attr, NULL,
538 be32_to_cpu(packet->mad.hdr.flow_label),
539 packet->mad.hdr.gid_index,
540 packet->mad.hdr.hop_limit,
541 packet->mad.hdr.traffic_class);
542 rdma_ah_set_dgid_raw(&ah_attr, packet->mad.hdr.gid);
545 ah = rdma_create_user_ah(agent->qp->pd, &ah_attr, NULL);
551 rmpp_mad = (struct ib_rmpp_mad *) packet->mad.data;
552 hdr_len = ib_get_mad_data_offset(rmpp_mad->mad_hdr.mgmt_class);
554 if (ib_is_mad_class_rmpp(rmpp_mad->mad_hdr.mgmt_class)
555 && ib_mad_kernel_rmpp_agent(agent)) {
556 copy_offset = IB_MGMT_RMPP_HDR;
557 rmpp_active = ib_get_rmpp_flags(&rmpp_mad->rmpp_hdr) &
558 IB_MGMT_RMPP_FLAG_ACTIVE;
560 copy_offset = IB_MGMT_MAD_HDR;
564 base_version = ((struct ib_mad_hdr *)&packet->mad.data)->base_version;
565 data_len = count - hdr_size(file) - hdr_len;
566 packet->msg = ib_create_send_mad(agent,
567 be32_to_cpu(packet->mad.hdr.qpn),
568 packet->mad.hdr.pkey_index, rmpp_active,
569 hdr_len, data_len, GFP_KERNEL,
571 if (IS_ERR(packet->msg)) {
572 ret = PTR_ERR(packet->msg);
576 packet->msg->ah = ah;
577 packet->msg->timeout_ms = packet->mad.hdr.timeout_ms;
578 packet->msg->retries = packet->mad.hdr.retries;
579 packet->msg->context[0] = packet;
581 /* Copy MAD header. Any RMPP header is already in place. */
582 memcpy(packet->msg->mad, packet->mad.data, IB_MGMT_MAD_HDR);
585 if (copy_from_user(packet->msg->mad + copy_offset,
587 hdr_len + data_len - copy_offset)) {
592 ret = copy_rmpp_mad(packet->msg, buf);
598 * Set the high-order part of the transaction ID to make MADs from
599 * different agents unique, and allow routing responses back to the
600 * original requestor.
602 if (!ib_response_mad(packet->msg->mad)) {
603 tid = &((struct ib_mad_hdr *) packet->msg->mad)->tid;
604 *tid = cpu_to_be64(((u64) agent->hi_tid) << 32 |
605 (be64_to_cpup(tid) & 0xffffffff));
606 rmpp_mad->mad_hdr.tid = *tid;
609 if (!ib_mad_kernel_rmpp_agent(agent)
610 && ib_is_mad_class_rmpp(rmpp_mad->mad_hdr.mgmt_class)
611 && (ib_get_rmpp_flags(&rmpp_mad->rmpp_hdr) & IB_MGMT_RMPP_FLAG_ACTIVE)) {
612 spin_lock_irq(&file->send_lock);
613 list_add_tail(&packet->list, &file->send_list);
614 spin_unlock_irq(&file->send_lock);
616 spin_lock_irq(&file->send_lock);
617 ret = is_duplicate(file, packet);
619 list_add_tail(&packet->list, &file->send_list);
620 spin_unlock_irq(&file->send_lock);
627 ret = ib_post_send_mad(packet->msg, NULL);
631 mutex_unlock(&file->mutex);
635 dequeue_send(file, packet);
637 ib_free_send_mad(packet->msg);
639 rdma_destroy_ah(ah, RDMA_DESTROY_AH_SLEEPABLE);
641 mutex_unlock(&file->mutex);
647 static __poll_t ib_umad_poll(struct file *filp, struct poll_table_struct *wait)
649 struct ib_umad_file *file = filp->private_data;
651 /* we will always be able to post a MAD send */
652 __poll_t mask = EPOLLOUT | EPOLLWRNORM;
654 poll_wait(filp, &file->recv_wait, wait);
656 if (!list_empty(&file->recv_list))
657 mask |= EPOLLIN | EPOLLRDNORM;
662 static int ib_umad_reg_agent(struct ib_umad_file *file, void __user *arg,
663 int compat_method_mask)
665 struct ib_user_mad_reg_req ureq;
666 struct ib_mad_reg_req req;
667 struct ib_mad_agent *agent = NULL;
671 mutex_lock(&file->port->file_mutex);
672 mutex_lock(&file->mutex);
674 if (!file->port->ib_dev) {
675 dev_notice(&file->port->dev,
676 "ib_umad_reg_agent: invalid device\n");
681 if (copy_from_user(&ureq, arg, sizeof ureq)) {
686 if (ureq.qpn != 0 && ureq.qpn != 1) {
687 dev_notice(&file->port->dev,
688 "ib_umad_reg_agent: invalid QPN %d specified\n",
694 for (agent_id = 0; agent_id < IB_UMAD_MAX_AGENTS; ++agent_id)
695 if (!__get_agent(file, agent_id))
698 dev_notice(&file->port->dev,
699 "ib_umad_reg_agent: Max Agents (%u) reached\n",
705 if (ureq.mgmt_class) {
706 memset(&req, 0, sizeof(req));
707 req.mgmt_class = ureq.mgmt_class;
708 req.mgmt_class_version = ureq.mgmt_class_version;
709 memcpy(req.oui, ureq.oui, sizeof req.oui);
711 if (compat_method_mask) {
712 u32 *umm = (u32 *) ureq.method_mask;
715 for (i = 0; i < BITS_TO_LONGS(IB_MGMT_MAX_METHODS); ++i)
717 umm[i * 2] | ((u64) umm[i * 2 + 1] << 32);
719 memcpy(req.method_mask, ureq.method_mask,
720 sizeof req.method_mask);
723 agent = ib_register_mad_agent(file->port->ib_dev, file->port->port_num,
724 ureq.qpn ? IB_QPT_GSI : IB_QPT_SMI,
725 ureq.mgmt_class ? &req : NULL,
727 send_handler, recv_handler, file, 0);
729 ret = PTR_ERR(agent);
734 if (put_user(agent_id,
735 (u32 __user *) (arg + offsetof(struct ib_user_mad_reg_req, id)))) {
740 if (!file->already_used) {
741 file->already_used = 1;
742 if (!file->use_pkey_index) {
743 dev_warn(&file->port->dev,
744 "process %s did not enable P_Key index support.\n",
746 dev_warn(&file->port->dev,
747 " Documentation/infiniband/user_mad.txt has info on the new ABI.\n");
751 file->agent[agent_id] = agent;
755 mutex_unlock(&file->mutex);
758 ib_unregister_mad_agent(agent);
760 mutex_unlock(&file->port->file_mutex);
765 static int ib_umad_reg_agent2(struct ib_umad_file *file, void __user *arg)
767 struct ib_user_mad_reg_req2 ureq;
768 struct ib_mad_reg_req req;
769 struct ib_mad_agent *agent = NULL;
773 mutex_lock(&file->port->file_mutex);
774 mutex_lock(&file->mutex);
776 if (!file->port->ib_dev) {
777 dev_notice(&file->port->dev,
778 "ib_umad_reg_agent2: invalid device\n");
783 if (copy_from_user(&ureq, arg, sizeof(ureq))) {
788 if (ureq.qpn != 0 && ureq.qpn != 1) {
789 dev_notice(&file->port->dev,
790 "ib_umad_reg_agent2: invalid QPN %d specified\n",
796 if (ureq.flags & ~IB_USER_MAD_REG_FLAGS_CAP) {
797 dev_notice(&file->port->dev,
798 "ib_umad_reg_agent2 failed: invalid registration flags specified 0x%x; supported 0x%x\n",
799 ureq.flags, IB_USER_MAD_REG_FLAGS_CAP);
802 if (put_user((u32)IB_USER_MAD_REG_FLAGS_CAP,
803 (u32 __user *) (arg + offsetof(struct
804 ib_user_mad_reg_req2, flags))))
810 for (agent_id = 0; agent_id < IB_UMAD_MAX_AGENTS; ++agent_id)
811 if (!__get_agent(file, agent_id))
814 dev_notice(&file->port->dev,
815 "ib_umad_reg_agent2: Max Agents (%u) reached\n",
821 if (ureq.mgmt_class) {
822 memset(&req, 0, sizeof(req));
823 req.mgmt_class = ureq.mgmt_class;
824 req.mgmt_class_version = ureq.mgmt_class_version;
825 if (ureq.oui & 0xff000000) {
826 dev_notice(&file->port->dev,
827 "ib_umad_reg_agent2 failed: oui invalid 0x%08x\n",
832 req.oui[2] = ureq.oui & 0x0000ff;
833 req.oui[1] = (ureq.oui & 0x00ff00) >> 8;
834 req.oui[0] = (ureq.oui & 0xff0000) >> 16;
835 memcpy(req.method_mask, ureq.method_mask,
836 sizeof(req.method_mask));
839 agent = ib_register_mad_agent(file->port->ib_dev, file->port->port_num,
840 ureq.qpn ? IB_QPT_GSI : IB_QPT_SMI,
841 ureq.mgmt_class ? &req : NULL,
843 send_handler, recv_handler, file,
846 ret = PTR_ERR(agent);
851 if (put_user(agent_id,
853 offsetof(struct ib_user_mad_reg_req2, id)))) {
858 if (!file->already_used) {
859 file->already_used = 1;
860 file->use_pkey_index = 1;
863 file->agent[agent_id] = agent;
867 mutex_unlock(&file->mutex);
870 ib_unregister_mad_agent(agent);
872 mutex_unlock(&file->port->file_mutex);
878 static int ib_umad_unreg_agent(struct ib_umad_file *file, u32 __user *arg)
880 struct ib_mad_agent *agent = NULL;
884 if (get_user(id, arg))
887 mutex_lock(&file->port->file_mutex);
888 mutex_lock(&file->mutex);
890 if (id >= IB_UMAD_MAX_AGENTS || !__get_agent(file, id)) {
895 agent = file->agent[id];
896 file->agent[id] = NULL;
899 mutex_unlock(&file->mutex);
902 ib_unregister_mad_agent(agent);
904 mutex_unlock(&file->port->file_mutex);
909 static long ib_umad_enable_pkey(struct ib_umad_file *file)
913 mutex_lock(&file->mutex);
914 if (file->already_used)
917 file->use_pkey_index = 1;
918 mutex_unlock(&file->mutex);
923 static long ib_umad_ioctl(struct file *filp, unsigned int cmd,
927 case IB_USER_MAD_REGISTER_AGENT:
928 return ib_umad_reg_agent(filp->private_data, (void __user *) arg, 0);
929 case IB_USER_MAD_UNREGISTER_AGENT:
930 return ib_umad_unreg_agent(filp->private_data, (__u32 __user *) arg);
931 case IB_USER_MAD_ENABLE_PKEY:
932 return ib_umad_enable_pkey(filp->private_data);
933 case IB_USER_MAD_REGISTER_AGENT2:
934 return ib_umad_reg_agent2(filp->private_data, (void __user *) arg);
941 static long ib_umad_compat_ioctl(struct file *filp, unsigned int cmd,
945 case IB_USER_MAD_REGISTER_AGENT:
946 return ib_umad_reg_agent(filp->private_data, compat_ptr(arg), 1);
947 case IB_USER_MAD_UNREGISTER_AGENT:
948 return ib_umad_unreg_agent(filp->private_data, compat_ptr(arg));
949 case IB_USER_MAD_ENABLE_PKEY:
950 return ib_umad_enable_pkey(filp->private_data);
951 case IB_USER_MAD_REGISTER_AGENT2:
952 return ib_umad_reg_agent2(filp->private_data, compat_ptr(arg));
960 * ib_umad_open() does not need the BKL:
962 * - the ib_umad_port structures are properly reference counted, and
963 * everything else is purely local to the file being created, so
964 * races against other open calls are not a problem;
965 * - the ioctl method does not affect any global state outside of the
966 * file structure being operated on;
968 static int ib_umad_open(struct inode *inode, struct file *filp)
970 struct ib_umad_port *port;
971 struct ib_umad_file *file;
974 port = container_of(inode->i_cdev, struct ib_umad_port, cdev);
976 mutex_lock(&port->file_mutex);
983 if (!rdma_dev_access_netns(port->ib_dev, current->nsproxy->net_ns)) {
988 file = kzalloc(sizeof(*file), GFP_KERNEL);
994 mutex_init(&file->mutex);
995 spin_lock_init(&file->send_lock);
996 INIT_LIST_HEAD(&file->recv_list);
997 INIT_LIST_HEAD(&file->send_list);
998 init_waitqueue_head(&file->recv_wait);
1001 filp->private_data = file;
1003 list_add_tail(&file->port_list, &port->file_list);
1005 stream_open(inode, filp);
1007 mutex_unlock(&port->file_mutex);
1011 static int ib_umad_close(struct inode *inode, struct file *filp)
1013 struct ib_umad_file *file = filp->private_data;
1014 struct ib_umad_packet *packet, *tmp;
1018 mutex_lock(&file->port->file_mutex);
1019 mutex_lock(&file->mutex);
1021 already_dead = file->agents_dead;
1022 file->agents_dead = 1;
1024 list_for_each_entry_safe(packet, tmp, &file->recv_list, list) {
1025 if (packet->recv_wc)
1026 ib_free_recv_mad(packet->recv_wc);
1030 list_del(&file->port_list);
1032 mutex_unlock(&file->mutex);
1035 for (i = 0; i < IB_UMAD_MAX_AGENTS; ++i)
1037 ib_unregister_mad_agent(file->agent[i]);
1039 mutex_unlock(&file->port->file_mutex);
1045 static const struct file_operations umad_fops = {
1046 .owner = THIS_MODULE,
1047 .read = ib_umad_read,
1048 .write = ib_umad_write,
1049 .poll = ib_umad_poll,
1050 .unlocked_ioctl = ib_umad_ioctl,
1051 #ifdef CONFIG_COMPAT
1052 .compat_ioctl = ib_umad_compat_ioctl,
1054 .open = ib_umad_open,
1055 .release = ib_umad_close,
1056 .llseek = no_llseek,
1059 static int ib_umad_sm_open(struct inode *inode, struct file *filp)
1061 struct ib_umad_port *port;
1062 struct ib_port_modify props = {
1063 .set_port_cap_mask = IB_PORT_SM
1067 port = container_of(inode->i_cdev, struct ib_umad_port, sm_cdev);
1069 if (filp->f_flags & O_NONBLOCK) {
1070 if (down_trylock(&port->sm_sem)) {
1075 if (down_interruptible(&port->sm_sem)) {
1081 if (!rdma_dev_access_netns(port->ib_dev, current->nsproxy->net_ns)) {
1086 ret = ib_modify_port(port->ib_dev, port->port_num, 0, &props);
1090 filp->private_data = port;
1092 nonseekable_open(inode, filp);
1102 static int ib_umad_sm_close(struct inode *inode, struct file *filp)
1104 struct ib_umad_port *port = filp->private_data;
1105 struct ib_port_modify props = {
1106 .clr_port_cap_mask = IB_PORT_SM
1110 mutex_lock(&port->file_mutex);
1112 ret = ib_modify_port(port->ib_dev, port->port_num, 0, &props);
1113 mutex_unlock(&port->file_mutex);
1120 static const struct file_operations umad_sm_fops = {
1121 .owner = THIS_MODULE,
1122 .open = ib_umad_sm_open,
1123 .release = ib_umad_sm_close,
1124 .llseek = no_llseek,
1127 static struct ib_client umad_client = {
1129 .add = ib_umad_add_one,
1130 .remove = ib_umad_remove_one
1133 static ssize_t ibdev_show(struct device *dev, struct device_attribute *attr,
1136 struct ib_umad_port *port = dev_get_drvdata(dev);
1141 return sprintf(buf, "%s\n", dev_name(&port->ib_dev->dev));
1143 static DEVICE_ATTR_RO(ibdev);
1145 static ssize_t port_show(struct device *dev, struct device_attribute *attr,
1148 struct ib_umad_port *port = dev_get_drvdata(dev);
1153 return sprintf(buf, "%d\n", port->port_num);
1155 static DEVICE_ATTR_RO(port);
1157 static struct attribute *umad_class_dev_attrs[] = {
1158 &dev_attr_ibdev.attr,
1159 &dev_attr_port.attr,
1162 ATTRIBUTE_GROUPS(umad_class_dev);
1164 static char *umad_devnode(struct device *dev, umode_t *mode)
1166 return kasprintf(GFP_KERNEL, "infiniband/%s", dev_name(dev));
1169 static ssize_t abi_version_show(struct class *class,
1170 struct class_attribute *attr, char *buf)
1172 return sprintf(buf, "%d\n", IB_USER_MAD_ABI_VERSION);
1174 static CLASS_ATTR_RO(abi_version);
1176 static struct attribute *umad_class_attrs[] = {
1177 &class_attr_abi_version.attr,
1180 ATTRIBUTE_GROUPS(umad_class);
1182 static struct class umad_class = {
1183 .name = "infiniband_mad",
1184 .devnode = umad_devnode,
1185 .class_groups = umad_class_groups,
1186 .dev_groups = umad_class_dev_groups,
1189 static void ib_umad_release_port(struct device *device)
1191 struct ib_umad_port *port = dev_get_drvdata(device);
1192 struct ib_umad_device *umad_dev = port->umad_dev;
1194 ib_umad_dev_put(umad_dev);
1197 static void ib_umad_init_port_dev(struct device *dev,
1198 struct ib_umad_port *port,
1199 const struct ib_device *device)
1201 device_initialize(dev);
1202 ib_umad_dev_get(port->umad_dev);
1203 dev->class = &umad_class;
1204 dev->parent = device->dev.parent;
1205 dev_set_drvdata(dev, port);
1206 dev->release = ib_umad_release_port;
1209 static int ib_umad_init_port(struct ib_device *device, int port_num,
1210 struct ib_umad_device *umad_dev,
1211 struct ib_umad_port *port)
1218 devnum = ida_alloc_max(&umad_ida, IB_UMAD_MAX_PORTS - 1, GFP_KERNEL);
1221 port->dev_num = devnum;
1222 if (devnum >= IB_UMAD_NUM_FIXED_MINOR) {
1223 base_umad = dynamic_umad_dev + devnum - IB_UMAD_NUM_FIXED_MINOR;
1224 base_issm = dynamic_issm_dev + devnum - IB_UMAD_NUM_FIXED_MINOR;
1226 base_umad = devnum + base_umad_dev;
1227 base_issm = devnum + base_issm_dev;
1230 port->ib_dev = device;
1231 port->umad_dev = umad_dev;
1232 port->port_num = port_num;
1233 sema_init(&port->sm_sem, 1);
1234 mutex_init(&port->file_mutex);
1235 INIT_LIST_HEAD(&port->file_list);
1237 ib_umad_init_port_dev(&port->dev, port, device);
1238 port->dev.devt = base_umad;
1239 dev_set_name(&port->dev, "umad%d", port->dev_num);
1240 cdev_init(&port->cdev, &umad_fops);
1241 port->cdev.owner = THIS_MODULE;
1243 ret = cdev_device_add(&port->cdev, &port->dev);
1247 ib_umad_init_port_dev(&port->sm_dev, port, device);
1248 port->sm_dev.devt = base_issm;
1249 dev_set_name(&port->sm_dev, "issm%d", port->dev_num);
1250 cdev_init(&port->sm_cdev, &umad_sm_fops);
1251 port->sm_cdev.owner = THIS_MODULE;
1253 ret = cdev_device_add(&port->sm_cdev, &port->sm_dev);
1260 put_device(&port->sm_dev);
1261 cdev_device_del(&port->cdev, &port->dev);
1263 put_device(&port->dev);
1264 ida_free(&umad_ida, devnum);
1268 static void ib_umad_kill_port(struct ib_umad_port *port)
1270 struct ib_umad_file *file;
1273 mutex_lock(&port->file_mutex);
1275 /* Mark ib_dev NULL and block ioctl or other file ops to progress
1278 port->ib_dev = NULL;
1280 list_for_each_entry(file, &port->file_list, port_list) {
1281 mutex_lock(&file->mutex);
1282 file->agents_dead = 1;
1283 mutex_unlock(&file->mutex);
1285 for (id = 0; id < IB_UMAD_MAX_AGENTS; ++id)
1286 if (file->agent[id])
1287 ib_unregister_mad_agent(file->agent[id]);
1290 mutex_unlock(&port->file_mutex);
1292 cdev_device_del(&port->sm_cdev, &port->sm_dev);
1293 cdev_device_del(&port->cdev, &port->dev);
1294 ida_free(&umad_ida, port->dev_num);
1296 /* balances device_initialize() */
1297 put_device(&port->sm_dev);
1298 put_device(&port->dev);
1301 static void ib_umad_add_one(struct ib_device *device)
1303 struct ib_umad_device *umad_dev;
1307 s = rdma_start_port(device);
1308 e = rdma_end_port(device);
1310 umad_dev = kzalloc(struct_size(umad_dev, ports, e - s + 1), GFP_KERNEL);
1314 kref_init(&umad_dev->kref);
1315 for (i = s; i <= e; ++i) {
1316 if (!rdma_cap_ib_mad(device, i))
1319 if (ib_umad_init_port(device, i, umad_dev,
1320 &umad_dev->ports[i - s]))
1329 ib_set_client_data(device, &umad_client, umad_dev);
1335 if (!rdma_cap_ib_mad(device, i))
1338 ib_umad_kill_port(&umad_dev->ports[i - s]);
1341 /* balances kref_init */
1342 ib_umad_dev_put(umad_dev);
1345 static void ib_umad_remove_one(struct ib_device *device, void *client_data)
1347 struct ib_umad_device *umad_dev = client_data;
1353 rdma_for_each_port (device, i) {
1354 if (rdma_cap_ib_mad(device, i))
1356 &umad_dev->ports[i - rdma_start_port(device)]);
1358 /* balances kref_init() */
1359 ib_umad_dev_put(umad_dev);
1362 static int __init ib_umad_init(void)
1366 ret = register_chrdev_region(base_umad_dev,
1367 IB_UMAD_NUM_FIXED_MINOR * 2,
1370 pr_err("couldn't register device number\n");
1374 ret = alloc_chrdev_region(&dynamic_umad_dev, 0,
1375 IB_UMAD_NUM_DYNAMIC_MINOR * 2,
1378 pr_err("couldn't register dynamic device number\n");
1381 dynamic_issm_dev = dynamic_umad_dev + IB_UMAD_NUM_DYNAMIC_MINOR;
1383 ret = class_register(&umad_class);
1385 pr_err("couldn't create class infiniband_mad\n");
1389 ret = ib_register_client(&umad_client);
1391 pr_err("couldn't register ib_umad client\n");
1398 class_unregister(&umad_class);
1401 unregister_chrdev_region(dynamic_umad_dev,
1402 IB_UMAD_NUM_DYNAMIC_MINOR * 2);
1405 unregister_chrdev_region(base_umad_dev,
1406 IB_UMAD_NUM_FIXED_MINOR * 2);
1412 static void __exit ib_umad_cleanup(void)
1414 ib_unregister_client(&umad_client);
1415 class_unregister(&umad_class);
1416 unregister_chrdev_region(base_umad_dev,
1417 IB_UMAD_NUM_FIXED_MINOR * 2);
1418 unregister_chrdev_region(dynamic_umad_dev,
1419 IB_UMAD_NUM_DYNAMIC_MINOR * 2);
1422 module_init(ib_umad_init);
1423 module_exit(ib_umad_cleanup);