2 * SPDX-License-Identifier: BSD-2-Clause OR GPL-2.0
4 * Copyright (c) 2004-2007 Intel Corporation. All rights reserved.
5 * Copyright (c) 2004 Topspin Corporation. All rights reserved.
6 * Copyright (c) 2004, 2005 Voltaire Corporation. All rights reserved.
7 * Copyright (c) 2005 Sun Microsystems, Inc. All rights reserved.
9 * This software is available to you under a choice of one of two
10 * licenses. You may choose to be licensed under the terms of the GNU
11 * General Public License (GPL) Version 2, available from the file
12 * COPYING in the main directory of this source tree, or the
13 * OpenIB.org BSD license below:
15 * Redistribution and use in source and binary forms, with or
16 * without modification, are permitted provided that the following
19 * - Redistributions of source code must retain the above
20 * copyright notice, this list of conditions and the following
23 * - Redistributions in binary form must reproduce the above
24 * copyright notice, this list of conditions and the following
25 * disclaimer in the documentation and/or other materials
26 * provided with the distribution.
28 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
29 * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
30 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
31 * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
32 * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
33 * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
34 * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
38 #include <sys/cdefs.h>
39 __FBSDID("$FreeBSD$");
41 #include <linux/completion.h>
42 #include <linux/dma-mapping.h>
43 #include <linux/device.h>
44 #include <linux/module.h>
45 #include <linux/err.h>
46 #include <linux/idr.h>
47 #include <linux/interrupt.h>
48 #include <linux/random.h>
49 #include <linux/rbtree.h>
50 #include <linux/spinlock.h>
51 #include <linux/slab.h>
52 #include <linux/sysfs.h>
53 #include <linux/workqueue.h>
54 #include <linux/kdev_t.h>
55 #include <linux/etherdevice.h>
57 #include <asm/atomic-long.h>
59 #include <rdma/ib_cache.h>
60 #include <rdma/ib_cm.h>
63 MODULE_AUTHOR("Sean Hefty");
64 MODULE_DESCRIPTION("InfiniBand CM");
65 MODULE_LICENSE("Dual BSD/GPL");
67 static void cm_add_one(struct ib_device *device);
68 static void cm_remove_one(struct ib_device *device, void *client_data);
70 static struct ib_client cm_client = {
73 .remove = cm_remove_one
78 struct list_head device_list;
80 struct rb_root listen_service_table;
81 u64 listen_service_id;
82 /* struct rb_root peer_service_table; todo: fix peer to peer */
83 struct rb_root remote_qp_table;
84 struct rb_root remote_id_table;
85 struct rb_root remote_sidr_table;
86 struct idr local_id_table;
87 __be32 random_id_operand;
88 struct list_head timewait_list;
89 struct workqueue_struct *wq;
90 /* Sync on cm change port state */
91 spinlock_t state_lock;
94 /* Counter indexes ordered by attribute ID */
108 CM_ATTR_ID_OFFSET = 0x0010,
119 static char const counter_group_names[CM_COUNTER_GROUPS]
120 [sizeof("cm_rx_duplicates")] = {
121 "cm_tx_msgs", "cm_tx_retries",
122 "cm_rx_msgs", "cm_rx_duplicates"
125 struct cm_counter_group {
127 atomic_long_t counter[CM_ATTR_COUNT];
130 struct cm_counter_attribute {
131 struct attribute attr;
135 #define CM_COUNTER_ATTR(_name, _index) \
136 struct cm_counter_attribute cm_##_name##_counter_attr = { \
137 .attr = { .name = __stringify(_name), .mode = 0444 }, \
141 static CM_COUNTER_ATTR(req, CM_REQ_COUNTER);
142 static CM_COUNTER_ATTR(mra, CM_MRA_COUNTER);
143 static CM_COUNTER_ATTR(rej, CM_REJ_COUNTER);
144 static CM_COUNTER_ATTR(rep, CM_REP_COUNTER);
145 static CM_COUNTER_ATTR(rtu, CM_RTU_COUNTER);
146 static CM_COUNTER_ATTR(dreq, CM_DREQ_COUNTER);
147 static CM_COUNTER_ATTR(drep, CM_DREP_COUNTER);
148 static CM_COUNTER_ATTR(sidr_req, CM_SIDR_REQ_COUNTER);
149 static CM_COUNTER_ATTR(sidr_rep, CM_SIDR_REP_COUNTER);
150 static CM_COUNTER_ATTR(lap, CM_LAP_COUNTER);
151 static CM_COUNTER_ATTR(apr, CM_APR_COUNTER);
153 static struct attribute *cm_counter_default_attrs[] = {
154 &cm_req_counter_attr.attr,
155 &cm_mra_counter_attr.attr,
156 &cm_rej_counter_attr.attr,
157 &cm_rep_counter_attr.attr,
158 &cm_rtu_counter_attr.attr,
159 &cm_dreq_counter_attr.attr,
160 &cm_drep_counter_attr.attr,
161 &cm_sidr_req_counter_attr.attr,
162 &cm_sidr_rep_counter_attr.attr,
163 &cm_lap_counter_attr.attr,
164 &cm_apr_counter_attr.attr,
169 struct cm_device *cm_dev;
170 struct ib_mad_agent *mad_agent;
171 struct kobject port_obj;
173 struct list_head cm_priv_prim_list;
174 struct list_head cm_priv_altr_list;
175 struct cm_counter_group counter_group[CM_COUNTER_GROUPS];
179 struct list_head list;
180 struct ib_device *ib_device;
181 struct device *device;
184 struct cm_port *port[0];
188 struct cm_port *port;
190 struct ib_ah_attr ah_attr;
196 struct delayed_work work;
197 struct list_head list;
198 struct cm_port *port;
199 struct ib_mad_recv_wc *mad_recv_wc; /* Received MADs */
200 __be32 local_id; /* Established / timewait */
202 struct ib_cm_event cm_event;
203 struct ib_sa_path_rec path[0];
206 struct cm_timewait_info {
207 struct cm_work work; /* Must be first. */
208 struct list_head list;
209 struct rb_node remote_qp_node;
210 struct rb_node remote_id_node;
211 __be64 remote_ca_guid;
213 u8 inserted_remote_qp;
214 u8 inserted_remote_id;
217 struct cm_id_private {
220 struct rb_node service_node;
221 struct rb_node sidr_id_node;
222 spinlock_t lock; /* Do not acquire inside cm.lock */
223 struct completion comp;
225 /* Number of clients sharing this ib_cm_id. Only valid for listeners.
226 * Protected by the cm.lock spinlock. */
227 int listen_sharecount;
229 struct ib_mad_send_buf *msg;
230 struct cm_timewait_info *timewait_info;
231 /* todo: use alternate port on send failure */
239 enum ib_qp_type qp_type;
243 enum ib_mtu path_mtu;
248 u8 responder_resources;
255 struct list_head prim_list;
256 struct list_head altr_list;
257 /* Indicates that the send port mad is registered and av is set */
258 int prim_send_port_not_ready;
259 int altr_send_port_not_ready;
261 struct list_head work_list;
265 static void cm_work_handler(struct work_struct *work);
267 static inline void cm_deref_id(struct cm_id_private *cm_id_priv)
269 if (atomic_dec_and_test(&cm_id_priv->refcount))
270 complete(&cm_id_priv->comp);
273 static int cm_alloc_msg(struct cm_id_private *cm_id_priv,
274 struct ib_mad_send_buf **msg)
276 struct ib_mad_agent *mad_agent;
277 struct ib_mad_send_buf *m;
280 unsigned long flags, flags2;
283 /* don't let the port to be released till the agent is down */
284 spin_lock_irqsave(&cm.state_lock, flags2);
285 spin_lock_irqsave(&cm.lock, flags);
286 if (!cm_id_priv->prim_send_port_not_ready)
287 av = &cm_id_priv->av;
288 else if (!cm_id_priv->altr_send_port_not_ready &&
289 (cm_id_priv->alt_av.port))
290 av = &cm_id_priv->alt_av;
292 pr_info("%s: not valid CM id\n", __func__);
294 spin_unlock_irqrestore(&cm.lock, flags);
297 spin_unlock_irqrestore(&cm.lock, flags);
298 /* Make sure the port haven't released the mad yet */
299 mad_agent = cm_id_priv->av.port->mad_agent;
301 pr_info("%s: not a valid MAD agent\n", __func__);
305 ah = ib_create_ah(mad_agent->qp->pd, &av->ah_attr);
311 m = ib_create_send_mad(mad_agent, cm_id_priv->id.remote_cm_qpn,
313 0, IB_MGMT_MAD_HDR, IB_MGMT_MAD_DATA,
315 IB_MGMT_BASE_VERSION);
322 /* Timeout set by caller if response is expected. */
324 m->retries = cm_id_priv->max_cm_retries;
326 atomic_inc(&cm_id_priv->refcount);
327 m->context[0] = cm_id_priv;
331 spin_unlock_irqrestore(&cm.state_lock, flags2);
335 static struct ib_mad_send_buf *cm_alloc_response_msg_no_ah(struct cm_port *port,
336 struct ib_mad_recv_wc *mad_recv_wc)
338 return ib_create_send_mad(port->mad_agent, 1, mad_recv_wc->wc->pkey_index,
339 0, IB_MGMT_MAD_HDR, IB_MGMT_MAD_DATA,
341 IB_MGMT_BASE_VERSION);
344 static int cm_create_response_msg_ah(struct cm_port *port,
345 struct ib_mad_recv_wc *mad_recv_wc,
346 struct ib_mad_send_buf *msg)
350 ah = ib_create_ah_from_wc(port->mad_agent->qp->pd, mad_recv_wc->wc,
351 mad_recv_wc->recv_buf.grh, port->port_num);
359 static void cm_free_msg(struct ib_mad_send_buf *msg)
362 ib_destroy_ah(msg->ah);
364 cm_deref_id(msg->context[0]);
365 ib_free_send_mad(msg);
368 static int cm_alloc_response_msg(struct cm_port *port,
369 struct ib_mad_recv_wc *mad_recv_wc,
370 struct ib_mad_send_buf **msg)
372 struct ib_mad_send_buf *m;
375 m = cm_alloc_response_msg_no_ah(port, mad_recv_wc);
379 ret = cm_create_response_msg_ah(port, mad_recv_wc, m);
389 static void * cm_copy_private_data(const void *private_data,
394 if (!private_data || !private_data_len)
397 data = kmemdup(private_data, private_data_len, GFP_KERNEL);
399 return ERR_PTR(-ENOMEM);
404 static void cm_set_private_data(struct cm_id_private *cm_id_priv,
405 void *private_data, u8 private_data_len)
407 if (cm_id_priv->private_data && cm_id_priv->private_data_len)
408 kfree(cm_id_priv->private_data);
410 cm_id_priv->private_data = private_data;
411 cm_id_priv->private_data_len = private_data_len;
414 static int cm_init_av_for_response(struct cm_port *port, struct ib_wc *wc,
415 struct ib_grh *grh, struct cm_av *av)
418 av->pkey_index = wc->pkey_index;
419 return ib_init_ah_from_wc(port->cm_dev->ib_device, port->port_num, wc,
423 static int cm_init_av_by_path(struct ib_sa_path_rec *path, struct cm_av *av,
424 struct cm_id_private *cm_id_priv)
426 struct cm_device *cm_dev;
427 struct cm_port *port = NULL;
431 struct net_device *ndev = ib_get_ndev_from_path(path);
433 read_lock_irqsave(&cm.device_lock, flags);
434 list_for_each_entry(cm_dev, &cm.device_list, list) {
435 if (!ib_find_cached_gid(cm_dev->ib_device, &path->sgid,
436 path->gid_type, ndev, &p, NULL)) {
437 port = cm_dev->port[p-1];
441 read_unlock_irqrestore(&cm.device_lock, flags);
449 ret = ib_find_cached_pkey(cm_dev->ib_device, port->port_num,
450 be16_to_cpu(path->pkey), &av->pkey_index);
455 ret = ib_init_ah_from_path(cm_dev->ib_device, port->port_num,
460 av->timeout = path->packet_life_time + 1;
462 spin_lock_irqsave(&cm.lock, flags);
463 if (&cm_id_priv->av == av)
464 list_add_tail(&cm_id_priv->prim_list, &port->cm_priv_prim_list);
465 else if (&cm_id_priv->alt_av == av)
466 list_add_tail(&cm_id_priv->altr_list, &port->cm_priv_altr_list);
470 spin_unlock_irqrestore(&cm.lock, flags);
475 static int cm_alloc_id(struct cm_id_private *cm_id_priv)
480 idr_preload(GFP_KERNEL);
481 spin_lock_irqsave(&cm.lock, flags);
483 id = idr_alloc_cyclic(&cm.local_id_table, cm_id_priv, 0, 0, GFP_NOWAIT);
485 spin_unlock_irqrestore(&cm.lock, flags);
488 cm_id_priv->id.local_id = (__force __be32)id ^ cm.random_id_operand;
489 return id < 0 ? id : 0;
492 static void cm_free_id(__be32 local_id)
494 spin_lock_irq(&cm.lock);
495 idr_remove(&cm.local_id_table,
496 (__force int) (local_id ^ cm.random_id_operand));
497 spin_unlock_irq(&cm.lock);
500 static struct cm_id_private * cm_get_id(__be32 local_id, __be32 remote_id)
502 struct cm_id_private *cm_id_priv;
504 cm_id_priv = idr_find(&cm.local_id_table,
505 (__force int) (local_id ^ cm.random_id_operand));
507 if (cm_id_priv->id.remote_id == remote_id)
508 atomic_inc(&cm_id_priv->refcount);
516 static struct cm_id_private * cm_acquire_id(__be32 local_id, __be32 remote_id)
518 struct cm_id_private *cm_id_priv;
520 spin_lock_irq(&cm.lock);
521 cm_id_priv = cm_get_id(local_id, remote_id);
522 spin_unlock_irq(&cm.lock);
528 * Trivial helpers to strip endian annotation and compare; the
529 * endianness doesn't actually matter since we just need a stable
530 * order for the RB tree.
532 static int be32_lt(__be32 a, __be32 b)
534 return (__force u32) a < (__force u32) b;
537 static int be32_gt(__be32 a, __be32 b)
539 return (__force u32) a > (__force u32) b;
542 static int be64_lt(__be64 a, __be64 b)
544 return (__force u64) a < (__force u64) b;
547 static int be64_gt(__be64 a, __be64 b)
549 return (__force u64) a > (__force u64) b;
552 static struct cm_id_private * cm_insert_listen(struct cm_id_private *cm_id_priv)
554 struct rb_node **link = &cm.listen_service_table.rb_node;
555 struct rb_node *parent = NULL;
556 struct cm_id_private *cur_cm_id_priv;
557 __be64 service_id = cm_id_priv->id.service_id;
558 __be64 service_mask = cm_id_priv->id.service_mask;
562 cur_cm_id_priv = rb_entry(parent, struct cm_id_private,
564 if ((cur_cm_id_priv->id.service_mask & service_id) ==
565 (service_mask & cur_cm_id_priv->id.service_id) &&
566 (cm_id_priv->id.device == cur_cm_id_priv->id.device))
567 return cur_cm_id_priv;
569 if (cm_id_priv->id.device < cur_cm_id_priv->id.device)
570 link = &(*link)->rb_left;
571 else if (cm_id_priv->id.device > cur_cm_id_priv->id.device)
572 link = &(*link)->rb_right;
573 else if (be64_lt(service_id, cur_cm_id_priv->id.service_id))
574 link = &(*link)->rb_left;
575 else if (be64_gt(service_id, cur_cm_id_priv->id.service_id))
576 link = &(*link)->rb_right;
578 link = &(*link)->rb_right;
580 rb_link_node(&cm_id_priv->service_node, parent, link);
581 rb_insert_color(&cm_id_priv->service_node, &cm.listen_service_table);
585 static struct cm_id_private * cm_find_listen(struct ib_device *device,
588 struct rb_node *node = cm.listen_service_table.rb_node;
589 struct cm_id_private *cm_id_priv;
592 cm_id_priv = rb_entry(node, struct cm_id_private, service_node);
593 if ((cm_id_priv->id.service_mask & service_id) ==
594 cm_id_priv->id.service_id &&
595 (cm_id_priv->id.device == device))
598 if (device < cm_id_priv->id.device)
599 node = node->rb_left;
600 else if (device > cm_id_priv->id.device)
601 node = node->rb_right;
602 else if (be64_lt(service_id, cm_id_priv->id.service_id))
603 node = node->rb_left;
604 else if (be64_gt(service_id, cm_id_priv->id.service_id))
605 node = node->rb_right;
607 node = node->rb_right;
612 static struct cm_timewait_info * cm_insert_remote_id(struct cm_timewait_info
615 struct rb_node **link = &cm.remote_id_table.rb_node;
616 struct rb_node *parent = NULL;
617 struct cm_timewait_info *cur_timewait_info;
618 __be64 remote_ca_guid = timewait_info->remote_ca_guid;
619 __be32 remote_id = timewait_info->work.remote_id;
623 cur_timewait_info = rb_entry(parent, struct cm_timewait_info,
625 if (be32_lt(remote_id, cur_timewait_info->work.remote_id))
626 link = &(*link)->rb_left;
627 else if (be32_gt(remote_id, cur_timewait_info->work.remote_id))
628 link = &(*link)->rb_right;
629 else if (be64_lt(remote_ca_guid, cur_timewait_info->remote_ca_guid))
630 link = &(*link)->rb_left;
631 else if (be64_gt(remote_ca_guid, cur_timewait_info->remote_ca_guid))
632 link = &(*link)->rb_right;
634 return cur_timewait_info;
636 timewait_info->inserted_remote_id = 1;
637 rb_link_node(&timewait_info->remote_id_node, parent, link);
638 rb_insert_color(&timewait_info->remote_id_node, &cm.remote_id_table);
642 static struct cm_timewait_info * cm_find_remote_id(__be64 remote_ca_guid,
645 struct rb_node *node = cm.remote_id_table.rb_node;
646 struct cm_timewait_info *timewait_info;
649 timewait_info = rb_entry(node, struct cm_timewait_info,
651 if (be32_lt(remote_id, timewait_info->work.remote_id))
652 node = node->rb_left;
653 else if (be32_gt(remote_id, timewait_info->work.remote_id))
654 node = node->rb_right;
655 else if (be64_lt(remote_ca_guid, timewait_info->remote_ca_guid))
656 node = node->rb_left;
657 else if (be64_gt(remote_ca_guid, timewait_info->remote_ca_guid))
658 node = node->rb_right;
660 return timewait_info;
665 static struct cm_timewait_info * cm_insert_remote_qpn(struct cm_timewait_info
668 struct rb_node **link = &cm.remote_qp_table.rb_node;
669 struct rb_node *parent = NULL;
670 struct cm_timewait_info *cur_timewait_info;
671 __be64 remote_ca_guid = timewait_info->remote_ca_guid;
672 __be32 remote_qpn = timewait_info->remote_qpn;
676 cur_timewait_info = rb_entry(parent, struct cm_timewait_info,
678 if (be32_lt(remote_qpn, cur_timewait_info->remote_qpn))
679 link = &(*link)->rb_left;
680 else if (be32_gt(remote_qpn, cur_timewait_info->remote_qpn))
681 link = &(*link)->rb_right;
682 else if (be64_lt(remote_ca_guid, cur_timewait_info->remote_ca_guid))
683 link = &(*link)->rb_left;
684 else if (be64_gt(remote_ca_guid, cur_timewait_info->remote_ca_guid))
685 link = &(*link)->rb_right;
687 return cur_timewait_info;
689 timewait_info->inserted_remote_qp = 1;
690 rb_link_node(&timewait_info->remote_qp_node, parent, link);
691 rb_insert_color(&timewait_info->remote_qp_node, &cm.remote_qp_table);
695 static struct cm_id_private * cm_insert_remote_sidr(struct cm_id_private
698 struct rb_node **link = &cm.remote_sidr_table.rb_node;
699 struct rb_node *parent = NULL;
700 struct cm_id_private *cur_cm_id_priv;
701 union ib_gid *port_gid = &cm_id_priv->av.dgid;
702 __be32 remote_id = cm_id_priv->id.remote_id;
706 cur_cm_id_priv = rb_entry(parent, struct cm_id_private,
708 if (be32_lt(remote_id, cur_cm_id_priv->id.remote_id))
709 link = &(*link)->rb_left;
710 else if (be32_gt(remote_id, cur_cm_id_priv->id.remote_id))
711 link = &(*link)->rb_right;
714 cmp = memcmp(port_gid, &cur_cm_id_priv->av.dgid,
717 link = &(*link)->rb_left;
719 link = &(*link)->rb_right;
721 return cur_cm_id_priv;
724 rb_link_node(&cm_id_priv->sidr_id_node, parent, link);
725 rb_insert_color(&cm_id_priv->sidr_id_node, &cm.remote_sidr_table);
729 static void cm_reject_sidr_req(struct cm_id_private *cm_id_priv,
730 enum ib_cm_sidr_status status)
732 struct ib_cm_sidr_rep_param param;
734 memset(¶m, 0, sizeof param);
735 param.status = status;
736 ib_send_cm_sidr_rep(&cm_id_priv->id, ¶m);
739 struct ib_cm_id *ib_create_cm_id(struct ib_device *device,
740 ib_cm_handler cm_handler,
743 struct cm_id_private *cm_id_priv;
746 cm_id_priv = kzalloc(sizeof *cm_id_priv, GFP_KERNEL);
748 return ERR_PTR(-ENOMEM);
750 cm_id_priv->id.state = IB_CM_IDLE;
751 cm_id_priv->id.device = device;
752 cm_id_priv->id.cm_handler = cm_handler;
753 cm_id_priv->id.context = context;
754 cm_id_priv->id.remote_cm_qpn = 1;
755 ret = cm_alloc_id(cm_id_priv);
759 spin_lock_init(&cm_id_priv->lock);
760 init_completion(&cm_id_priv->comp);
761 INIT_LIST_HEAD(&cm_id_priv->work_list);
762 INIT_LIST_HEAD(&cm_id_priv->prim_list);
763 INIT_LIST_HEAD(&cm_id_priv->altr_list);
764 atomic_set(&cm_id_priv->work_count, -1);
765 atomic_set(&cm_id_priv->refcount, 1);
766 return &cm_id_priv->id;
770 return ERR_PTR(-ENOMEM);
772 EXPORT_SYMBOL(ib_create_cm_id);
774 static struct cm_work * cm_dequeue_work(struct cm_id_private *cm_id_priv)
776 struct cm_work *work;
778 if (list_empty(&cm_id_priv->work_list))
781 work = list_entry(cm_id_priv->work_list.next, struct cm_work, list);
782 list_del(&work->list);
786 static void cm_free_work(struct cm_work *work)
788 if (work->mad_recv_wc)
789 ib_free_recv_mad(work->mad_recv_wc);
793 static inline int cm_convert_to_ms(int iba_time)
795 /* approximate conversion to ms from 4.096us x 2^iba_time */
796 return 1 << max(iba_time - 8, 0);
800 * calculate: 4.096x2^ack_timeout = 4.096x2^ack_delay + 2x4.096x2^life_time
801 * Because of how ack_timeout is stored, adding one doubles the timeout.
802 * To avoid large timeouts, select the max(ack_delay, life_time + 1), and
803 * increment it (round up) only if the other is within 50%.
805 static u8 cm_ack_timeout(u8 ca_ack_delay, u8 packet_life_time)
807 int ack_timeout = packet_life_time + 1;
809 if (ack_timeout >= ca_ack_delay)
810 ack_timeout += (ca_ack_delay >= (ack_timeout - 1));
812 ack_timeout = ca_ack_delay +
813 (ack_timeout >= (ca_ack_delay - 1));
815 return min(31, ack_timeout);
818 static void cm_cleanup_timewait(struct cm_timewait_info *timewait_info)
820 if (timewait_info->inserted_remote_id) {
821 rb_erase(&timewait_info->remote_id_node, &cm.remote_id_table);
822 timewait_info->inserted_remote_id = 0;
825 if (timewait_info->inserted_remote_qp) {
826 rb_erase(&timewait_info->remote_qp_node, &cm.remote_qp_table);
827 timewait_info->inserted_remote_qp = 0;
831 static struct cm_timewait_info * cm_create_timewait_info(__be32 local_id)
833 struct cm_timewait_info *timewait_info;
835 timewait_info = kzalloc(sizeof *timewait_info, GFP_KERNEL);
837 return ERR_PTR(-ENOMEM);
839 timewait_info->work.local_id = local_id;
840 INIT_DELAYED_WORK(&timewait_info->work.work, cm_work_handler);
841 timewait_info->work.cm_event.event = IB_CM_TIMEWAIT_EXIT;
842 return timewait_info;
845 static void cm_enter_timewait(struct cm_id_private *cm_id_priv)
849 struct cm_device *cm_dev;
851 cm_dev = ib_get_client_data(cm_id_priv->id.device, &cm_client);
855 spin_lock_irqsave(&cm.lock, flags);
856 cm_cleanup_timewait(cm_id_priv->timewait_info);
857 list_add_tail(&cm_id_priv->timewait_info->list, &cm.timewait_list);
858 spin_unlock_irqrestore(&cm.lock, flags);
861 * The cm_id could be destroyed by the user before we exit timewait.
862 * To protect against this, we search for the cm_id after exiting
863 * timewait before notifying the user that we've exited timewait.
865 cm_id_priv->id.state = IB_CM_TIMEWAIT;
866 wait_time = cm_convert_to_ms(cm_id_priv->av.timeout);
868 /* Check if the device started its remove_one */
869 spin_lock_irqsave(&cm.lock, flags);
870 if (!cm_dev->going_down)
871 queue_delayed_work(cm.wq, &cm_id_priv->timewait_info->work.work,
872 msecs_to_jiffies(wait_time));
873 spin_unlock_irqrestore(&cm.lock, flags);
875 cm_id_priv->timewait_info = NULL;
878 static void cm_reset_to_idle(struct cm_id_private *cm_id_priv)
882 cm_id_priv->id.state = IB_CM_IDLE;
883 if (cm_id_priv->timewait_info) {
884 spin_lock_irqsave(&cm.lock, flags);
885 cm_cleanup_timewait(cm_id_priv->timewait_info);
886 spin_unlock_irqrestore(&cm.lock, flags);
887 kfree(cm_id_priv->timewait_info);
888 cm_id_priv->timewait_info = NULL;
892 static void cm_destroy_id(struct ib_cm_id *cm_id, int err)
894 struct cm_id_private *cm_id_priv;
895 struct cm_work *work;
897 cm_id_priv = container_of(cm_id, struct cm_id_private, id);
899 spin_lock_irq(&cm_id_priv->lock);
900 switch (cm_id->state) {
902 spin_unlock_irq(&cm_id_priv->lock);
904 spin_lock_irq(&cm.lock);
905 if (--cm_id_priv->listen_sharecount > 0) {
906 /* The id is still shared. */
907 cm_deref_id(cm_id_priv);
908 spin_unlock_irq(&cm.lock);
911 rb_erase(&cm_id_priv->service_node, &cm.listen_service_table);
912 spin_unlock_irq(&cm.lock);
914 case IB_CM_SIDR_REQ_SENT:
915 cm_id->state = IB_CM_IDLE;
916 ib_cancel_mad(cm_id_priv->av.port->mad_agent, cm_id_priv->msg);
917 spin_unlock_irq(&cm_id_priv->lock);
919 case IB_CM_SIDR_REQ_RCVD:
920 spin_unlock_irq(&cm_id_priv->lock);
921 cm_reject_sidr_req(cm_id_priv, IB_SIDR_REJECT);
922 spin_lock_irq(&cm.lock);
923 if (!RB_EMPTY_NODE(&cm_id_priv->sidr_id_node))
924 rb_erase(&cm_id_priv->sidr_id_node,
925 &cm.remote_sidr_table);
926 spin_unlock_irq(&cm.lock);
929 case IB_CM_MRA_REQ_RCVD:
930 ib_cancel_mad(cm_id_priv->av.port->mad_agent, cm_id_priv->msg);
931 spin_unlock_irq(&cm_id_priv->lock);
932 ib_send_cm_rej(cm_id, IB_CM_REJ_TIMEOUT,
933 &cm_id_priv->id.device->node_guid,
934 sizeof cm_id_priv->id.device->node_guid,
938 if (err == -ENOMEM) {
939 /* Do not reject to allow future retries. */
940 cm_reset_to_idle(cm_id_priv);
941 spin_unlock_irq(&cm_id_priv->lock);
943 spin_unlock_irq(&cm_id_priv->lock);
944 ib_send_cm_rej(cm_id, IB_CM_REJ_CONSUMER_DEFINED,
949 case IB_CM_MRA_REP_RCVD:
950 ib_cancel_mad(cm_id_priv->av.port->mad_agent, cm_id_priv->msg);
952 case IB_CM_MRA_REQ_SENT:
954 case IB_CM_MRA_REP_SENT:
955 spin_unlock_irq(&cm_id_priv->lock);
956 ib_send_cm_rej(cm_id, IB_CM_REJ_CONSUMER_DEFINED,
959 case IB_CM_ESTABLISHED:
960 spin_unlock_irq(&cm_id_priv->lock);
961 if (cm_id_priv->qp_type == IB_QPT_XRC_TGT)
963 ib_send_cm_dreq(cm_id, NULL, 0);
965 case IB_CM_DREQ_SENT:
966 ib_cancel_mad(cm_id_priv->av.port->mad_agent, cm_id_priv->msg);
967 cm_enter_timewait(cm_id_priv);
968 spin_unlock_irq(&cm_id_priv->lock);
970 case IB_CM_DREQ_RCVD:
971 spin_unlock_irq(&cm_id_priv->lock);
972 ib_send_cm_drep(cm_id, NULL, 0);
975 spin_unlock_irq(&cm_id_priv->lock);
979 spin_lock_irq(&cm.lock);
980 if (!list_empty(&cm_id_priv->altr_list) &&
981 (!cm_id_priv->altr_send_port_not_ready))
982 list_del(&cm_id_priv->altr_list);
983 if (!list_empty(&cm_id_priv->prim_list) &&
984 (!cm_id_priv->prim_send_port_not_ready))
985 list_del(&cm_id_priv->prim_list);
986 spin_unlock_irq(&cm.lock);
988 cm_free_id(cm_id->local_id);
989 cm_deref_id(cm_id_priv);
990 wait_for_completion(&cm_id_priv->comp);
991 while ((work = cm_dequeue_work(cm_id_priv)) != NULL)
993 kfree(cm_id_priv->private_data);
997 void ib_destroy_cm_id(struct ib_cm_id *cm_id)
999 cm_destroy_id(cm_id, 0);
1001 EXPORT_SYMBOL(ib_destroy_cm_id);
1004 * __ib_cm_listen - Initiates listening on the specified service ID for
1005 * connection and service ID resolution requests.
1006 * @cm_id: Connection identifier associated with the listen request.
1007 * @service_id: Service identifier matched against incoming connection
1008 * and service ID resolution requests. The service ID should be specified
1009 * network-byte order. If set to IB_CM_ASSIGN_SERVICE_ID, the CM will
1010 * assign a service ID to the caller.
1011 * @service_mask: Mask applied to service ID used to listen across a
1012 * range of service IDs. If set to 0, the service ID is matched
1013 * exactly. This parameter is ignored if %service_id is set to
1014 * IB_CM_ASSIGN_SERVICE_ID.
1016 static int __ib_cm_listen(struct ib_cm_id *cm_id, __be64 service_id,
1017 __be64 service_mask)
1019 struct cm_id_private *cm_id_priv, *cur_cm_id_priv;
1022 service_mask = service_mask ? service_mask : ~cpu_to_be64(0);
1023 service_id &= service_mask;
1024 if ((service_id & IB_SERVICE_ID_AGN_MASK) == IB_CM_ASSIGN_SERVICE_ID &&
1025 (service_id != IB_CM_ASSIGN_SERVICE_ID))
1028 cm_id_priv = container_of(cm_id, struct cm_id_private, id);
1029 if (cm_id->state != IB_CM_IDLE)
1032 cm_id->state = IB_CM_LISTEN;
1033 ++cm_id_priv->listen_sharecount;
1035 if (service_id == IB_CM_ASSIGN_SERVICE_ID) {
1036 cm_id->service_id = cpu_to_be64(cm.listen_service_id++);
1037 cm_id->service_mask = ~cpu_to_be64(0);
1039 cm_id->service_id = service_id;
1040 cm_id->service_mask = service_mask;
1042 cur_cm_id_priv = cm_insert_listen(cm_id_priv);
1044 if (cur_cm_id_priv) {
1045 cm_id->state = IB_CM_IDLE;
1046 --cm_id_priv->listen_sharecount;
1052 int ib_cm_listen(struct ib_cm_id *cm_id, __be64 service_id, __be64 service_mask)
1054 unsigned long flags;
1057 spin_lock_irqsave(&cm.lock, flags);
1058 ret = __ib_cm_listen(cm_id, service_id, service_mask);
1059 spin_unlock_irqrestore(&cm.lock, flags);
1063 EXPORT_SYMBOL(ib_cm_listen);
1066 * Create a new listening ib_cm_id and listen on the given service ID.
1068 * If there's an existing ID listening on that same device and service ID,
1071 * @device: Device associated with the cm_id. All related communication will
1072 * be associated with the specified device.
1073 * @cm_handler: Callback invoked to notify the user of CM events.
1074 * @service_id: Service identifier matched against incoming connection
1075 * and service ID resolution requests. The service ID should be specified
1076 * network-byte order. If set to IB_CM_ASSIGN_SERVICE_ID, the CM will
1077 * assign a service ID to the caller.
1079 * Callers should call ib_destroy_cm_id when done with the listener ID.
1081 struct ib_cm_id *ib_cm_insert_listen(struct ib_device *device,
1082 ib_cm_handler cm_handler,
1085 struct cm_id_private *cm_id_priv;
1086 struct ib_cm_id *cm_id;
1087 unsigned long flags;
1090 /* Create an ID in advance, since the creation may sleep */
1091 cm_id = ib_create_cm_id(device, cm_handler, NULL);
1095 spin_lock_irqsave(&cm.lock, flags);
1097 if (service_id == IB_CM_ASSIGN_SERVICE_ID)
1100 /* Find an existing ID */
1101 cm_id_priv = cm_find_listen(device, service_id);
1103 if (cm_id->cm_handler != cm_handler || cm_id->context) {
1104 /* Sharing an ib_cm_id with different handlers is not
1106 spin_unlock_irqrestore(&cm.lock, flags);
1107 return ERR_PTR(-EINVAL);
1109 atomic_inc(&cm_id_priv->refcount);
1110 ++cm_id_priv->listen_sharecount;
1111 spin_unlock_irqrestore(&cm.lock, flags);
1113 ib_destroy_cm_id(cm_id);
1114 cm_id = &cm_id_priv->id;
1119 /* Use newly created ID */
1120 err = __ib_cm_listen(cm_id, service_id, 0);
1122 spin_unlock_irqrestore(&cm.lock, flags);
1125 ib_destroy_cm_id(cm_id);
1126 return ERR_PTR(err);
1130 EXPORT_SYMBOL(ib_cm_insert_listen);
1132 static __be64 cm_form_tid(struct cm_id_private *cm_id_priv,
1133 enum cm_msg_sequence msg_seq)
1135 u64 hi_tid, low_tid;
1137 hi_tid = ((u64) cm_id_priv->av.port->mad_agent->hi_tid) << 32;
1138 low_tid = (u64) ((__force u32)cm_id_priv->id.local_id |
1140 return cpu_to_be64(hi_tid | low_tid);
1143 static void cm_format_mad_hdr(struct ib_mad_hdr *hdr,
1144 __be16 attr_id, __be64 tid)
1146 hdr->base_version = IB_MGMT_BASE_VERSION;
1147 hdr->mgmt_class = IB_MGMT_CLASS_CM;
1148 hdr->class_version = IB_CM_CLASS_VERSION;
1149 hdr->method = IB_MGMT_METHOD_SEND;
1150 hdr->attr_id = attr_id;
1154 static void cm_format_req(struct cm_req_msg *req_msg,
1155 struct cm_id_private *cm_id_priv,
1156 struct ib_cm_req_param *param)
1158 struct ib_sa_path_rec *pri_path = param->primary_path;
1159 struct ib_sa_path_rec *alt_path = param->alternate_path;
1161 cm_format_mad_hdr(&req_msg->hdr, CM_REQ_ATTR_ID,
1162 cm_form_tid(cm_id_priv, CM_MSG_SEQUENCE_REQ));
1164 req_msg->local_comm_id = cm_id_priv->id.local_id;
1165 req_msg->service_id = param->service_id;
1166 req_msg->local_ca_guid = cm_id_priv->id.device->node_guid;
1167 cm_req_set_local_qpn(req_msg, cpu_to_be32(param->qp_num));
1168 cm_req_set_init_depth(req_msg, param->initiator_depth);
1169 cm_req_set_remote_resp_timeout(req_msg,
1170 param->remote_cm_response_timeout);
1171 cm_req_set_qp_type(req_msg, param->qp_type);
1172 cm_req_set_flow_ctrl(req_msg, param->flow_control);
1173 cm_req_set_starting_psn(req_msg, cpu_to_be32(param->starting_psn));
1174 cm_req_set_local_resp_timeout(req_msg,
1175 param->local_cm_response_timeout);
1176 req_msg->pkey = param->primary_path->pkey;
1177 cm_req_set_path_mtu(req_msg, param->primary_path->mtu);
1178 cm_req_set_max_cm_retries(req_msg, param->max_cm_retries);
1180 if (param->qp_type != IB_QPT_XRC_INI) {
1181 cm_req_set_resp_res(req_msg, param->responder_resources);
1182 cm_req_set_retry_count(req_msg, param->retry_count);
1183 cm_req_set_rnr_retry_count(req_msg, param->rnr_retry_count);
1184 cm_req_set_srq(req_msg, param->srq);
1187 if (pri_path->hop_limit <= 1) {
1188 req_msg->primary_local_lid = pri_path->slid;
1189 req_msg->primary_remote_lid = pri_path->dlid;
1191 /* Work-around until there's a way to obtain remote LID info */
1192 req_msg->primary_local_lid = IB_LID_PERMISSIVE;
1193 req_msg->primary_remote_lid = IB_LID_PERMISSIVE;
1195 req_msg->primary_local_gid = pri_path->sgid;
1196 req_msg->primary_remote_gid = pri_path->dgid;
1197 cm_req_set_primary_flow_label(req_msg, pri_path->flow_label);
1198 cm_req_set_primary_packet_rate(req_msg, pri_path->rate);
1199 req_msg->primary_traffic_class = pri_path->traffic_class;
1200 req_msg->primary_hop_limit = pri_path->hop_limit;
1201 cm_req_set_primary_sl(req_msg, pri_path->sl);
1202 cm_req_set_primary_subnet_local(req_msg, (pri_path->hop_limit <= 1));
1203 cm_req_set_primary_local_ack_timeout(req_msg,
1204 cm_ack_timeout(cm_id_priv->av.port->cm_dev->ack_delay,
1205 pri_path->packet_life_time));
1208 if (alt_path->hop_limit <= 1) {
1209 req_msg->alt_local_lid = alt_path->slid;
1210 req_msg->alt_remote_lid = alt_path->dlid;
1212 req_msg->alt_local_lid = IB_LID_PERMISSIVE;
1213 req_msg->alt_remote_lid = IB_LID_PERMISSIVE;
1215 req_msg->alt_local_gid = alt_path->sgid;
1216 req_msg->alt_remote_gid = alt_path->dgid;
1217 cm_req_set_alt_flow_label(req_msg,
1218 alt_path->flow_label);
1219 cm_req_set_alt_packet_rate(req_msg, alt_path->rate);
1220 req_msg->alt_traffic_class = alt_path->traffic_class;
1221 req_msg->alt_hop_limit = alt_path->hop_limit;
1222 cm_req_set_alt_sl(req_msg, alt_path->sl);
1223 cm_req_set_alt_subnet_local(req_msg, (alt_path->hop_limit <= 1));
1224 cm_req_set_alt_local_ack_timeout(req_msg,
1225 cm_ack_timeout(cm_id_priv->av.port->cm_dev->ack_delay,
1226 alt_path->packet_life_time));
1229 if (param->private_data && param->private_data_len)
1230 memcpy(req_msg->private_data, param->private_data,
1231 param->private_data_len);
1234 static int cm_validate_req_param(struct ib_cm_req_param *param)
1236 /* peer-to-peer not supported */
1237 if (param->peer_to_peer)
1240 if (!param->primary_path)
1243 if (param->qp_type != IB_QPT_RC && param->qp_type != IB_QPT_UC &&
1244 param->qp_type != IB_QPT_XRC_INI)
1247 if (param->private_data &&
1248 param->private_data_len > IB_CM_REQ_PRIVATE_DATA_SIZE)
1251 if (param->alternate_path &&
1252 (param->alternate_path->pkey != param->primary_path->pkey ||
1253 param->alternate_path->mtu != param->primary_path->mtu))
1259 int ib_send_cm_req(struct ib_cm_id *cm_id,
1260 struct ib_cm_req_param *param)
1262 struct cm_id_private *cm_id_priv;
1263 struct cm_req_msg *req_msg;
1264 unsigned long flags;
1267 ret = cm_validate_req_param(param);
1271 /* Verify that we're not in timewait. */
1272 cm_id_priv = container_of(cm_id, struct cm_id_private, id);
1273 spin_lock_irqsave(&cm_id_priv->lock, flags);
1274 if (cm_id->state != IB_CM_IDLE) {
1275 spin_unlock_irqrestore(&cm_id_priv->lock, flags);
1279 spin_unlock_irqrestore(&cm_id_priv->lock, flags);
1281 cm_id_priv->timewait_info = cm_create_timewait_info(cm_id_priv->
1283 if (IS_ERR(cm_id_priv->timewait_info)) {
1284 ret = PTR_ERR(cm_id_priv->timewait_info);
1288 ret = cm_init_av_by_path(param->primary_path, &cm_id_priv->av,
1292 if (param->alternate_path) {
1293 ret = cm_init_av_by_path(param->alternate_path,
1294 &cm_id_priv->alt_av, cm_id_priv);
1298 cm_id->service_id = param->service_id;
1299 cm_id->service_mask = ~cpu_to_be64(0);
1300 cm_id_priv->timeout_ms = cm_convert_to_ms(
1301 param->primary_path->packet_life_time) * 2 +
1303 param->remote_cm_response_timeout);
1304 cm_id_priv->max_cm_retries = param->max_cm_retries;
1305 cm_id_priv->initiator_depth = param->initiator_depth;
1306 cm_id_priv->responder_resources = param->responder_resources;
1307 cm_id_priv->retry_count = param->retry_count;
1308 cm_id_priv->path_mtu = param->primary_path->mtu;
1309 cm_id_priv->pkey = param->primary_path->pkey;
1310 cm_id_priv->qp_type = param->qp_type;
1312 ret = cm_alloc_msg(cm_id_priv, &cm_id_priv->msg);
1316 req_msg = (struct cm_req_msg *) cm_id_priv->msg->mad;
1317 cm_format_req(req_msg, cm_id_priv, param);
1318 cm_id_priv->tid = req_msg->hdr.tid;
1319 cm_id_priv->msg->timeout_ms = cm_id_priv->timeout_ms;
1320 cm_id_priv->msg->context[1] = (void *) (unsigned long) IB_CM_REQ_SENT;
1322 cm_id_priv->local_qpn = cm_req_get_local_qpn(req_msg);
1323 cm_id_priv->rq_psn = cm_req_get_starting_psn(req_msg);
1325 spin_lock_irqsave(&cm_id_priv->lock, flags);
1326 ret = ib_post_send_mad(cm_id_priv->msg, NULL);
1328 spin_unlock_irqrestore(&cm_id_priv->lock, flags);
1331 BUG_ON(cm_id->state != IB_CM_IDLE);
1332 cm_id->state = IB_CM_REQ_SENT;
1333 spin_unlock_irqrestore(&cm_id_priv->lock, flags);
1336 error2: cm_free_msg(cm_id_priv->msg);
1337 error1: kfree(cm_id_priv->timewait_info);
1340 EXPORT_SYMBOL(ib_send_cm_req);
1342 static int cm_issue_rej(struct cm_port *port,
1343 struct ib_mad_recv_wc *mad_recv_wc,
1344 enum ib_cm_rej_reason reason,
1345 enum cm_msg_response msg_rejected,
1346 void *ari, u8 ari_length)
1348 struct ib_mad_send_buf *msg = NULL;
1349 struct cm_rej_msg *rej_msg, *rcv_msg;
1352 ret = cm_alloc_response_msg(port, mad_recv_wc, &msg);
1356 /* We just need common CM header information. Cast to any message. */
1357 rcv_msg = (struct cm_rej_msg *) mad_recv_wc->recv_buf.mad;
1358 rej_msg = (struct cm_rej_msg *) msg->mad;
1360 cm_format_mad_hdr(&rej_msg->hdr, CM_REJ_ATTR_ID, rcv_msg->hdr.tid);
1361 rej_msg->remote_comm_id = rcv_msg->local_comm_id;
1362 rej_msg->local_comm_id = rcv_msg->remote_comm_id;
1363 cm_rej_set_msg_rejected(rej_msg, msg_rejected);
1364 rej_msg->reason = cpu_to_be16(reason);
1366 if (ari && ari_length) {
1367 cm_rej_set_reject_info_len(rej_msg, ari_length);
1368 memcpy(rej_msg->ari, ari, ari_length);
1371 ret = ib_post_send_mad(msg, NULL);
1378 static void cm_format_paths_from_req(struct cm_req_msg *req_msg,
1379 struct ib_sa_path_rec *primary_path,
1380 struct ib_sa_path_rec *alt_path)
1382 memset(primary_path, 0, sizeof *primary_path);
1383 primary_path->dgid = req_msg->primary_local_gid;
1384 primary_path->sgid = req_msg->primary_remote_gid;
1385 primary_path->dlid = req_msg->primary_local_lid;
1386 primary_path->slid = req_msg->primary_remote_lid;
1387 primary_path->flow_label = cm_req_get_primary_flow_label(req_msg);
1388 primary_path->hop_limit = req_msg->primary_hop_limit;
1389 primary_path->traffic_class = req_msg->primary_traffic_class;
1390 primary_path->reversible = 1;
1391 primary_path->pkey = req_msg->pkey;
1392 primary_path->sl = cm_req_get_primary_sl(req_msg);
1393 primary_path->mtu_selector = IB_SA_EQ;
1394 primary_path->mtu = cm_req_get_path_mtu(req_msg);
1395 primary_path->rate_selector = IB_SA_EQ;
1396 primary_path->rate = cm_req_get_primary_packet_rate(req_msg);
1397 primary_path->packet_life_time_selector = IB_SA_EQ;
1398 primary_path->packet_life_time =
1399 cm_req_get_primary_local_ack_timeout(req_msg);
1400 primary_path->packet_life_time -= (primary_path->packet_life_time > 0);
1401 primary_path->service_id = req_msg->service_id;
1403 if (req_msg->alt_local_lid) {
1404 memset(alt_path, 0, sizeof *alt_path);
1405 alt_path->dgid = req_msg->alt_local_gid;
1406 alt_path->sgid = req_msg->alt_remote_gid;
1407 alt_path->dlid = req_msg->alt_local_lid;
1408 alt_path->slid = req_msg->alt_remote_lid;
1409 alt_path->flow_label = cm_req_get_alt_flow_label(req_msg);
1410 alt_path->hop_limit = req_msg->alt_hop_limit;
1411 alt_path->traffic_class = req_msg->alt_traffic_class;
1412 alt_path->reversible = 1;
1413 alt_path->pkey = req_msg->pkey;
1414 alt_path->sl = cm_req_get_alt_sl(req_msg);
1415 alt_path->mtu_selector = IB_SA_EQ;
1416 alt_path->mtu = cm_req_get_path_mtu(req_msg);
1417 alt_path->rate_selector = IB_SA_EQ;
1418 alt_path->rate = cm_req_get_alt_packet_rate(req_msg);
1419 alt_path->packet_life_time_selector = IB_SA_EQ;
1420 alt_path->packet_life_time =
1421 cm_req_get_alt_local_ack_timeout(req_msg);
1422 alt_path->packet_life_time -= (alt_path->packet_life_time > 0);
1423 alt_path->service_id = req_msg->service_id;
1427 static u16 cm_get_bth_pkey(struct cm_work *work)
1429 struct ib_device *ib_dev = work->port->cm_dev->ib_device;
1430 u8 port_num = work->port->port_num;
1431 u16 pkey_index = work->mad_recv_wc->wc->pkey_index;
1435 ret = ib_get_cached_pkey(ib_dev, port_num, pkey_index, &pkey);
1437 dev_warn_ratelimited(&ib_dev->dev, "ib_cm: Couldn't retrieve pkey for incoming request (port %d, pkey index %d). %d\n",
1438 port_num, pkey_index, ret);
1445 static void cm_format_req_event(struct cm_work *work,
1446 struct cm_id_private *cm_id_priv,
1447 struct ib_cm_id *listen_id)
1449 struct cm_req_msg *req_msg;
1450 struct ib_cm_req_event_param *param;
1452 req_msg = (struct cm_req_msg *)work->mad_recv_wc->recv_buf.mad;
1453 param = &work->cm_event.param.req_rcvd;
1454 param->listen_id = listen_id;
1455 param->bth_pkey = cm_get_bth_pkey(work);
1456 param->port = cm_id_priv->av.port->port_num;
1457 param->primary_path = &work->path[0];
1458 if (req_msg->alt_local_lid)
1459 param->alternate_path = &work->path[1];
1461 param->alternate_path = NULL;
1462 param->remote_ca_guid = req_msg->local_ca_guid;
1463 param->remote_qkey = be32_to_cpu(req_msg->local_qkey);
1464 param->remote_qpn = be32_to_cpu(cm_req_get_local_qpn(req_msg));
1465 param->qp_type = cm_req_get_qp_type(req_msg);
1466 param->starting_psn = be32_to_cpu(cm_req_get_starting_psn(req_msg));
1467 param->responder_resources = cm_req_get_init_depth(req_msg);
1468 param->initiator_depth = cm_req_get_resp_res(req_msg);
1469 param->local_cm_response_timeout =
1470 cm_req_get_remote_resp_timeout(req_msg);
1471 param->flow_control = cm_req_get_flow_ctrl(req_msg);
1472 param->remote_cm_response_timeout =
1473 cm_req_get_local_resp_timeout(req_msg);
1474 param->retry_count = cm_req_get_retry_count(req_msg);
1475 param->rnr_retry_count = cm_req_get_rnr_retry_count(req_msg);
1476 param->srq = cm_req_get_srq(req_msg);
1477 param->ppath_sgid_index = cm_id_priv->av.ah_attr.grh.sgid_index;
1478 work->cm_event.private_data = &req_msg->private_data;
1481 static void cm_process_work(struct cm_id_private *cm_id_priv,
1482 struct cm_work *work)
1486 /* We will typically only have the current event to report. */
1487 ret = cm_id_priv->id.cm_handler(&cm_id_priv->id, &work->cm_event);
1490 while (!ret && !atomic_add_negative(-1, &cm_id_priv->work_count)) {
1491 spin_lock_irq(&cm_id_priv->lock);
1492 work = cm_dequeue_work(cm_id_priv);
1493 spin_unlock_irq(&cm_id_priv->lock);
1495 ret = cm_id_priv->id.cm_handler(&cm_id_priv->id,
1499 cm_deref_id(cm_id_priv);
1501 cm_destroy_id(&cm_id_priv->id, ret);
1504 static void cm_format_mra(struct cm_mra_msg *mra_msg,
1505 struct cm_id_private *cm_id_priv,
1506 enum cm_msg_response msg_mraed, u8 service_timeout,
1507 const void *private_data, u8 private_data_len)
1509 cm_format_mad_hdr(&mra_msg->hdr, CM_MRA_ATTR_ID, cm_id_priv->tid);
1510 cm_mra_set_msg_mraed(mra_msg, msg_mraed);
1511 mra_msg->local_comm_id = cm_id_priv->id.local_id;
1512 mra_msg->remote_comm_id = cm_id_priv->id.remote_id;
1513 cm_mra_set_service_timeout(mra_msg, service_timeout);
1515 if (private_data && private_data_len)
1516 memcpy(mra_msg->private_data, private_data, private_data_len);
1519 static void cm_format_rej(struct cm_rej_msg *rej_msg,
1520 struct cm_id_private *cm_id_priv,
1521 enum ib_cm_rej_reason reason,
1524 const void *private_data,
1525 u8 private_data_len)
1527 cm_format_mad_hdr(&rej_msg->hdr, CM_REJ_ATTR_ID, cm_id_priv->tid);
1528 rej_msg->remote_comm_id = cm_id_priv->id.remote_id;
1530 switch(cm_id_priv->id.state) {
1531 case IB_CM_REQ_RCVD:
1532 rej_msg->local_comm_id = 0;
1533 cm_rej_set_msg_rejected(rej_msg, CM_MSG_RESPONSE_REQ);
1535 case IB_CM_MRA_REQ_SENT:
1536 rej_msg->local_comm_id = cm_id_priv->id.local_id;
1537 cm_rej_set_msg_rejected(rej_msg, CM_MSG_RESPONSE_REQ);
1539 case IB_CM_REP_RCVD:
1540 case IB_CM_MRA_REP_SENT:
1541 rej_msg->local_comm_id = cm_id_priv->id.local_id;
1542 cm_rej_set_msg_rejected(rej_msg, CM_MSG_RESPONSE_REP);
1545 rej_msg->local_comm_id = cm_id_priv->id.local_id;
1546 cm_rej_set_msg_rejected(rej_msg, CM_MSG_RESPONSE_OTHER);
1550 rej_msg->reason = cpu_to_be16(reason);
1551 if (ari && ari_length) {
1552 cm_rej_set_reject_info_len(rej_msg, ari_length);
1553 memcpy(rej_msg->ari, ari, ari_length);
1556 if (private_data && private_data_len)
1557 memcpy(rej_msg->private_data, private_data, private_data_len);
1560 static void cm_dup_req_handler(struct cm_work *work,
1561 struct cm_id_private *cm_id_priv)
1563 struct ib_mad_send_buf *msg = NULL;
1566 atomic_long_inc(&work->port->counter_group[CM_RECV_DUPLICATES].
1567 counter[CM_REQ_COUNTER]);
1569 /* Quick state check to discard duplicate REQs. */
1570 if (cm_id_priv->id.state == IB_CM_REQ_RCVD)
1573 ret = cm_alloc_response_msg(work->port, work->mad_recv_wc, &msg);
1577 spin_lock_irq(&cm_id_priv->lock);
1578 switch (cm_id_priv->id.state) {
1579 case IB_CM_MRA_REQ_SENT:
1580 cm_format_mra((struct cm_mra_msg *) msg->mad, cm_id_priv,
1581 CM_MSG_RESPONSE_REQ, cm_id_priv->service_timeout,
1582 cm_id_priv->private_data,
1583 cm_id_priv->private_data_len);
1585 case IB_CM_TIMEWAIT:
1586 cm_format_rej((struct cm_rej_msg *) msg->mad, cm_id_priv,
1587 IB_CM_REJ_STALE_CONN, NULL, 0, NULL, 0);
1592 spin_unlock_irq(&cm_id_priv->lock);
1594 ret = ib_post_send_mad(msg, NULL);
1599 unlock: spin_unlock_irq(&cm_id_priv->lock);
1600 free: cm_free_msg(msg);
1603 static struct cm_id_private * cm_match_req(struct cm_work *work,
1604 struct cm_id_private *cm_id_priv)
1606 struct cm_id_private *listen_cm_id_priv, *cur_cm_id_priv;
1607 struct cm_timewait_info *timewait_info;
1608 struct cm_req_msg *req_msg;
1610 req_msg = (struct cm_req_msg *)work->mad_recv_wc->recv_buf.mad;
1612 /* Check for possible duplicate REQ. */
1613 spin_lock_irq(&cm.lock);
1614 timewait_info = cm_insert_remote_id(cm_id_priv->timewait_info);
1615 if (timewait_info) {
1616 cur_cm_id_priv = cm_get_id(timewait_info->work.local_id,
1617 timewait_info->work.remote_id);
1618 spin_unlock_irq(&cm.lock);
1619 if (cur_cm_id_priv) {
1620 cm_dup_req_handler(work, cur_cm_id_priv);
1621 cm_deref_id(cur_cm_id_priv);
1626 /* Check for stale connections. */
1627 timewait_info = cm_insert_remote_qpn(cm_id_priv->timewait_info);
1628 if (timewait_info) {
1629 cm_cleanup_timewait(cm_id_priv->timewait_info);
1630 spin_unlock_irq(&cm.lock);
1631 cm_issue_rej(work->port, work->mad_recv_wc,
1632 IB_CM_REJ_STALE_CONN, CM_MSG_RESPONSE_REQ,
1637 /* Find matching listen request. */
1638 listen_cm_id_priv = cm_find_listen(cm_id_priv->id.device,
1639 req_msg->service_id);
1640 if (!listen_cm_id_priv) {
1641 cm_cleanup_timewait(cm_id_priv->timewait_info);
1642 spin_unlock_irq(&cm.lock);
1643 cm_issue_rej(work->port, work->mad_recv_wc,
1644 IB_CM_REJ_INVALID_SERVICE_ID, CM_MSG_RESPONSE_REQ,
1648 atomic_inc(&listen_cm_id_priv->refcount);
1649 atomic_inc(&cm_id_priv->refcount);
1650 cm_id_priv->id.state = IB_CM_REQ_RCVD;
1651 atomic_inc(&cm_id_priv->work_count);
1652 spin_unlock_irq(&cm.lock);
1654 return listen_cm_id_priv;
1658 * Work-around for inter-subnet connections. If the LIDs are permissive,
1659 * we need to override the LID/SL data in the REQ with the LID information
1660 * in the work completion.
1662 static void cm_process_routed_req(struct cm_req_msg *req_msg, struct ib_wc *wc)
1664 if (!cm_req_get_primary_subnet_local(req_msg)) {
1665 if (req_msg->primary_local_lid == IB_LID_PERMISSIVE) {
1666 req_msg->primary_local_lid = cpu_to_be16(wc->slid);
1667 cm_req_set_primary_sl(req_msg, wc->sl);
1670 if (req_msg->primary_remote_lid == IB_LID_PERMISSIVE)
1671 req_msg->primary_remote_lid = cpu_to_be16(wc->dlid_path_bits);
1674 if (!cm_req_get_alt_subnet_local(req_msg)) {
1675 if (req_msg->alt_local_lid == IB_LID_PERMISSIVE) {
1676 req_msg->alt_local_lid = cpu_to_be16(wc->slid);
1677 cm_req_set_alt_sl(req_msg, wc->sl);
1680 if (req_msg->alt_remote_lid == IB_LID_PERMISSIVE)
1681 req_msg->alt_remote_lid = cpu_to_be16(wc->dlid_path_bits);
1685 static int cm_req_handler(struct cm_work *work)
1687 struct ib_cm_id *cm_id;
1688 struct cm_id_private *cm_id_priv, *listen_cm_id_priv;
1689 struct cm_req_msg *req_msg;
1691 struct ib_gid_attr gid_attr;
1694 req_msg = (struct cm_req_msg *)work->mad_recv_wc->recv_buf.mad;
1696 cm_id = ib_create_cm_id(work->port->cm_dev->ib_device, NULL, NULL);
1698 return PTR_ERR(cm_id);
1700 cm_id_priv = container_of(cm_id, struct cm_id_private, id);
1701 cm_id_priv->id.remote_id = req_msg->local_comm_id;
1702 ret = cm_init_av_for_response(work->port, work->mad_recv_wc->wc,
1703 work->mad_recv_wc->recv_buf.grh,
1707 cm_id_priv->timewait_info = cm_create_timewait_info(cm_id_priv->
1709 if (IS_ERR(cm_id_priv->timewait_info)) {
1710 ret = PTR_ERR(cm_id_priv->timewait_info);
1713 cm_id_priv->timewait_info->work.remote_id = req_msg->local_comm_id;
1714 cm_id_priv->timewait_info->remote_ca_guid = req_msg->local_ca_guid;
1715 cm_id_priv->timewait_info->remote_qpn = cm_req_get_local_qpn(req_msg);
1717 listen_cm_id_priv = cm_match_req(work, cm_id_priv);
1718 if (!listen_cm_id_priv) {
1720 kfree(cm_id_priv->timewait_info);
1724 cm_id_priv->id.cm_handler = listen_cm_id_priv->id.cm_handler;
1725 cm_id_priv->id.context = listen_cm_id_priv->id.context;
1726 cm_id_priv->id.service_id = req_msg->service_id;
1727 cm_id_priv->id.service_mask = ~cpu_to_be64(0);
1729 cm_process_routed_req(req_msg, work->mad_recv_wc->wc);
1730 cm_format_paths_from_req(req_msg, &work->path[0], &work->path[1]);
1732 memcpy(work->path[0].dmac, cm_id_priv->av.ah_attr.dmac, ETH_ALEN);
1733 work->path[0].hop_limit = cm_id_priv->av.ah_attr.grh.hop_limit;
1734 ret = ib_get_cached_gid(work->port->cm_dev->ib_device,
1735 work->port->port_num,
1736 cm_id_priv->av.ah_attr.grh.sgid_index,
1739 if (gid_attr.ndev) {
1740 work->path[0].ifindex = gid_attr.ndev->if_index;
1741 work->path[0].net = dev_net(gid_attr.ndev);
1742 dev_put(gid_attr.ndev);
1744 work->path[0].gid_type = gid_attr.gid_type;
1745 ret = cm_init_av_by_path(&work->path[0], &cm_id_priv->av,
1749 int err = ib_get_cached_gid(work->port->cm_dev->ib_device,
1750 work->port->port_num, 0,
1751 &work->path[0].sgid,
1753 if (!err && gid_attr.ndev) {
1754 work->path[0].ifindex = gid_attr.ndev->if_index;
1755 work->path[0].net = dev_net(gid_attr.ndev);
1756 dev_put(gid_attr.ndev);
1758 work->path[0].gid_type = gid_attr.gid_type;
1759 ib_send_cm_rej(cm_id, IB_CM_REJ_INVALID_GID,
1760 &work->path[0].sgid, sizeof work->path[0].sgid,
1764 if (req_msg->alt_local_lid) {
1765 ret = cm_init_av_by_path(&work->path[1], &cm_id_priv->alt_av,
1768 ib_send_cm_rej(cm_id, IB_CM_REJ_INVALID_ALT_GID,
1769 &work->path[0].sgid,
1770 sizeof work->path[0].sgid, NULL, 0);
1774 cm_id_priv->tid = req_msg->hdr.tid;
1775 cm_id_priv->timeout_ms = cm_convert_to_ms(
1776 cm_req_get_local_resp_timeout(req_msg));
1777 cm_id_priv->max_cm_retries = cm_req_get_max_cm_retries(req_msg);
1778 cm_id_priv->remote_qpn = cm_req_get_local_qpn(req_msg);
1779 cm_id_priv->initiator_depth = cm_req_get_resp_res(req_msg);
1780 cm_id_priv->responder_resources = cm_req_get_init_depth(req_msg);
1781 cm_id_priv->path_mtu = cm_req_get_path_mtu(req_msg);
1782 cm_id_priv->pkey = req_msg->pkey;
1783 cm_id_priv->sq_psn = cm_req_get_starting_psn(req_msg);
1784 cm_id_priv->retry_count = cm_req_get_retry_count(req_msg);
1785 cm_id_priv->rnr_retry_count = cm_req_get_rnr_retry_count(req_msg);
1786 cm_id_priv->qp_type = cm_req_get_qp_type(req_msg);
1788 cm_format_req_event(work, cm_id_priv, &listen_cm_id_priv->id);
1789 cm_process_work(cm_id_priv, work);
1790 cm_deref_id(listen_cm_id_priv);
1794 atomic_dec(&cm_id_priv->refcount);
1795 cm_deref_id(listen_cm_id_priv);
1797 ib_destroy_cm_id(cm_id);
1801 static void cm_format_rep(struct cm_rep_msg *rep_msg,
1802 struct cm_id_private *cm_id_priv,
1803 struct ib_cm_rep_param *param)
1805 cm_format_mad_hdr(&rep_msg->hdr, CM_REP_ATTR_ID, cm_id_priv->tid);
1806 rep_msg->local_comm_id = cm_id_priv->id.local_id;
1807 rep_msg->remote_comm_id = cm_id_priv->id.remote_id;
1808 cm_rep_set_starting_psn(rep_msg, cpu_to_be32(param->starting_psn));
1809 rep_msg->resp_resources = param->responder_resources;
1810 cm_rep_set_target_ack_delay(rep_msg,
1811 cm_id_priv->av.port->cm_dev->ack_delay);
1812 cm_rep_set_failover(rep_msg, param->failover_accepted);
1813 cm_rep_set_rnr_retry_count(rep_msg, param->rnr_retry_count);
1814 rep_msg->local_ca_guid = cm_id_priv->id.device->node_guid;
1816 if (cm_id_priv->qp_type != IB_QPT_XRC_TGT) {
1817 rep_msg->initiator_depth = param->initiator_depth;
1818 cm_rep_set_flow_ctrl(rep_msg, param->flow_control);
1819 cm_rep_set_srq(rep_msg, param->srq);
1820 cm_rep_set_local_qpn(rep_msg, cpu_to_be32(param->qp_num));
1822 cm_rep_set_srq(rep_msg, 1);
1823 cm_rep_set_local_eecn(rep_msg, cpu_to_be32(param->qp_num));
1826 if (param->private_data && param->private_data_len)
1827 memcpy(rep_msg->private_data, param->private_data,
1828 param->private_data_len);
1831 int ib_send_cm_rep(struct ib_cm_id *cm_id,
1832 struct ib_cm_rep_param *param)
1834 struct cm_id_private *cm_id_priv;
1835 struct ib_mad_send_buf *msg;
1836 struct cm_rep_msg *rep_msg;
1837 unsigned long flags;
1840 if (param->private_data &&
1841 param->private_data_len > IB_CM_REP_PRIVATE_DATA_SIZE)
1844 cm_id_priv = container_of(cm_id, struct cm_id_private, id);
1845 spin_lock_irqsave(&cm_id_priv->lock, flags);
1846 if (cm_id->state != IB_CM_REQ_RCVD &&
1847 cm_id->state != IB_CM_MRA_REQ_SENT) {
1852 ret = cm_alloc_msg(cm_id_priv, &msg);
1856 rep_msg = (struct cm_rep_msg *) msg->mad;
1857 cm_format_rep(rep_msg, cm_id_priv, param);
1858 msg->timeout_ms = cm_id_priv->timeout_ms;
1859 msg->context[1] = (void *) (unsigned long) IB_CM_REP_SENT;
1861 ret = ib_post_send_mad(msg, NULL);
1863 spin_unlock_irqrestore(&cm_id_priv->lock, flags);
1868 cm_id->state = IB_CM_REP_SENT;
1869 cm_id_priv->msg = msg;
1870 cm_id_priv->initiator_depth = param->initiator_depth;
1871 cm_id_priv->responder_resources = param->responder_resources;
1872 cm_id_priv->rq_psn = cm_rep_get_starting_psn(rep_msg);
1873 cm_id_priv->local_qpn = cpu_to_be32(param->qp_num & 0xFFFFFF);
1875 out: spin_unlock_irqrestore(&cm_id_priv->lock, flags);
1878 EXPORT_SYMBOL(ib_send_cm_rep);
1880 static void cm_format_rtu(struct cm_rtu_msg *rtu_msg,
1881 struct cm_id_private *cm_id_priv,
1882 const void *private_data,
1883 u8 private_data_len)
1885 cm_format_mad_hdr(&rtu_msg->hdr, CM_RTU_ATTR_ID, cm_id_priv->tid);
1886 rtu_msg->local_comm_id = cm_id_priv->id.local_id;
1887 rtu_msg->remote_comm_id = cm_id_priv->id.remote_id;
1889 if (private_data && private_data_len)
1890 memcpy(rtu_msg->private_data, private_data, private_data_len);
1893 int ib_send_cm_rtu(struct ib_cm_id *cm_id,
1894 const void *private_data,
1895 u8 private_data_len)
1897 struct cm_id_private *cm_id_priv;
1898 struct ib_mad_send_buf *msg;
1899 unsigned long flags;
1903 if (private_data && private_data_len > IB_CM_RTU_PRIVATE_DATA_SIZE)
1906 data = cm_copy_private_data(private_data, private_data_len);
1908 return PTR_ERR(data);
1910 cm_id_priv = container_of(cm_id, struct cm_id_private, id);
1911 spin_lock_irqsave(&cm_id_priv->lock, flags);
1912 if (cm_id->state != IB_CM_REP_RCVD &&
1913 cm_id->state != IB_CM_MRA_REP_SENT) {
1918 ret = cm_alloc_msg(cm_id_priv, &msg);
1922 cm_format_rtu((struct cm_rtu_msg *) msg->mad, cm_id_priv,
1923 private_data, private_data_len);
1925 ret = ib_post_send_mad(msg, NULL);
1927 spin_unlock_irqrestore(&cm_id_priv->lock, flags);
1933 cm_id->state = IB_CM_ESTABLISHED;
1934 cm_set_private_data(cm_id_priv, data, private_data_len);
1935 spin_unlock_irqrestore(&cm_id_priv->lock, flags);
1938 error: spin_unlock_irqrestore(&cm_id_priv->lock, flags);
1942 EXPORT_SYMBOL(ib_send_cm_rtu);
1944 static void cm_format_rep_event(struct cm_work *work, enum ib_qp_type qp_type)
1946 struct cm_rep_msg *rep_msg;
1947 struct ib_cm_rep_event_param *param;
1949 rep_msg = (struct cm_rep_msg *)work->mad_recv_wc->recv_buf.mad;
1950 param = &work->cm_event.param.rep_rcvd;
1951 param->remote_ca_guid = rep_msg->local_ca_guid;
1952 param->remote_qkey = be32_to_cpu(rep_msg->local_qkey);
1953 param->remote_qpn = be32_to_cpu(cm_rep_get_qpn(rep_msg, qp_type));
1954 param->starting_psn = be32_to_cpu(cm_rep_get_starting_psn(rep_msg));
1955 param->responder_resources = rep_msg->initiator_depth;
1956 param->initiator_depth = rep_msg->resp_resources;
1957 param->target_ack_delay = cm_rep_get_target_ack_delay(rep_msg);
1958 param->failover_accepted = cm_rep_get_failover(rep_msg);
1959 param->flow_control = cm_rep_get_flow_ctrl(rep_msg);
1960 param->rnr_retry_count = cm_rep_get_rnr_retry_count(rep_msg);
1961 param->srq = cm_rep_get_srq(rep_msg);
1962 work->cm_event.private_data = &rep_msg->private_data;
1965 static void cm_dup_rep_handler(struct cm_work *work)
1967 struct cm_id_private *cm_id_priv;
1968 struct cm_rep_msg *rep_msg;
1969 struct ib_mad_send_buf *msg = NULL;
1972 rep_msg = (struct cm_rep_msg *) work->mad_recv_wc->recv_buf.mad;
1973 cm_id_priv = cm_acquire_id(rep_msg->remote_comm_id,
1974 rep_msg->local_comm_id);
1978 atomic_long_inc(&work->port->counter_group[CM_RECV_DUPLICATES].
1979 counter[CM_REP_COUNTER]);
1980 ret = cm_alloc_response_msg(work->port, work->mad_recv_wc, &msg);
1984 spin_lock_irq(&cm_id_priv->lock);
1985 if (cm_id_priv->id.state == IB_CM_ESTABLISHED)
1986 cm_format_rtu((struct cm_rtu_msg *) msg->mad, cm_id_priv,
1987 cm_id_priv->private_data,
1988 cm_id_priv->private_data_len);
1989 else if (cm_id_priv->id.state == IB_CM_MRA_REP_SENT)
1990 cm_format_mra((struct cm_mra_msg *) msg->mad, cm_id_priv,
1991 CM_MSG_RESPONSE_REP, cm_id_priv->service_timeout,
1992 cm_id_priv->private_data,
1993 cm_id_priv->private_data_len);
1996 spin_unlock_irq(&cm_id_priv->lock);
1998 ret = ib_post_send_mad(msg, NULL);
2003 unlock: spin_unlock_irq(&cm_id_priv->lock);
2004 free: cm_free_msg(msg);
2005 deref: cm_deref_id(cm_id_priv);
2008 static int cm_rep_handler(struct cm_work *work)
2010 struct cm_id_private *cm_id_priv;
2011 struct cm_rep_msg *rep_msg;
2014 rep_msg = (struct cm_rep_msg *)work->mad_recv_wc->recv_buf.mad;
2015 cm_id_priv = cm_acquire_id(rep_msg->remote_comm_id, 0);
2017 cm_dup_rep_handler(work);
2021 cm_format_rep_event(work, cm_id_priv->qp_type);
2023 spin_lock_irq(&cm_id_priv->lock);
2024 switch (cm_id_priv->id.state) {
2025 case IB_CM_REQ_SENT:
2026 case IB_CM_MRA_REQ_RCVD:
2029 spin_unlock_irq(&cm_id_priv->lock);
2034 cm_id_priv->timewait_info->work.remote_id = rep_msg->local_comm_id;
2035 cm_id_priv->timewait_info->remote_ca_guid = rep_msg->local_ca_guid;
2036 cm_id_priv->timewait_info->remote_qpn = cm_rep_get_qpn(rep_msg, cm_id_priv->qp_type);
2038 spin_lock(&cm.lock);
2039 /* Check for duplicate REP. */
2040 if (cm_insert_remote_id(cm_id_priv->timewait_info)) {
2041 spin_unlock(&cm.lock);
2042 spin_unlock_irq(&cm_id_priv->lock);
2046 /* Check for a stale connection. */
2047 if (cm_insert_remote_qpn(cm_id_priv->timewait_info)) {
2048 rb_erase(&cm_id_priv->timewait_info->remote_id_node,
2049 &cm.remote_id_table);
2050 cm_id_priv->timewait_info->inserted_remote_id = 0;
2051 spin_unlock(&cm.lock);
2052 spin_unlock_irq(&cm_id_priv->lock);
2053 cm_issue_rej(work->port, work->mad_recv_wc,
2054 IB_CM_REJ_STALE_CONN, CM_MSG_RESPONSE_REP,
2059 spin_unlock(&cm.lock);
2061 cm_id_priv->id.state = IB_CM_REP_RCVD;
2062 cm_id_priv->id.remote_id = rep_msg->local_comm_id;
2063 cm_id_priv->remote_qpn = cm_rep_get_qpn(rep_msg, cm_id_priv->qp_type);
2064 cm_id_priv->initiator_depth = rep_msg->resp_resources;
2065 cm_id_priv->responder_resources = rep_msg->initiator_depth;
2066 cm_id_priv->sq_psn = cm_rep_get_starting_psn(rep_msg);
2067 cm_id_priv->rnr_retry_count = cm_rep_get_rnr_retry_count(rep_msg);
2068 cm_id_priv->target_ack_delay = cm_rep_get_target_ack_delay(rep_msg);
2069 cm_id_priv->av.timeout =
2070 cm_ack_timeout(cm_id_priv->target_ack_delay,
2071 cm_id_priv->av.timeout - 1);
2072 cm_id_priv->alt_av.timeout =
2073 cm_ack_timeout(cm_id_priv->target_ack_delay,
2074 cm_id_priv->alt_av.timeout - 1);
2076 /* todo: handle peer_to_peer */
2078 ib_cancel_mad(cm_id_priv->av.port->mad_agent, cm_id_priv->msg);
2079 ret = atomic_inc_and_test(&cm_id_priv->work_count);
2081 list_add_tail(&work->list, &cm_id_priv->work_list);
2082 spin_unlock_irq(&cm_id_priv->lock);
2085 cm_process_work(cm_id_priv, work);
2087 cm_deref_id(cm_id_priv);
2091 cm_deref_id(cm_id_priv);
2095 static int cm_establish_handler(struct cm_work *work)
2097 struct cm_id_private *cm_id_priv;
2100 /* See comment in cm_establish about lookup. */
2101 cm_id_priv = cm_acquire_id(work->local_id, work->remote_id);
2105 spin_lock_irq(&cm_id_priv->lock);
2106 if (cm_id_priv->id.state != IB_CM_ESTABLISHED) {
2107 spin_unlock_irq(&cm_id_priv->lock);
2111 ib_cancel_mad(cm_id_priv->av.port->mad_agent, cm_id_priv->msg);
2112 ret = atomic_inc_and_test(&cm_id_priv->work_count);
2114 list_add_tail(&work->list, &cm_id_priv->work_list);
2115 spin_unlock_irq(&cm_id_priv->lock);
2118 cm_process_work(cm_id_priv, work);
2120 cm_deref_id(cm_id_priv);
2123 cm_deref_id(cm_id_priv);
2127 static int cm_rtu_handler(struct cm_work *work)
2129 struct cm_id_private *cm_id_priv;
2130 struct cm_rtu_msg *rtu_msg;
2133 rtu_msg = (struct cm_rtu_msg *)work->mad_recv_wc->recv_buf.mad;
2134 cm_id_priv = cm_acquire_id(rtu_msg->remote_comm_id,
2135 rtu_msg->local_comm_id);
2139 work->cm_event.private_data = &rtu_msg->private_data;
2141 spin_lock_irq(&cm_id_priv->lock);
2142 if (cm_id_priv->id.state != IB_CM_REP_SENT &&
2143 cm_id_priv->id.state != IB_CM_MRA_REP_RCVD) {
2144 spin_unlock_irq(&cm_id_priv->lock);
2145 atomic_long_inc(&work->port->counter_group[CM_RECV_DUPLICATES].
2146 counter[CM_RTU_COUNTER]);
2149 cm_id_priv->id.state = IB_CM_ESTABLISHED;
2151 ib_cancel_mad(cm_id_priv->av.port->mad_agent, cm_id_priv->msg);
2152 ret = atomic_inc_and_test(&cm_id_priv->work_count);
2154 list_add_tail(&work->list, &cm_id_priv->work_list);
2155 spin_unlock_irq(&cm_id_priv->lock);
2158 cm_process_work(cm_id_priv, work);
2160 cm_deref_id(cm_id_priv);
2163 cm_deref_id(cm_id_priv);
2167 static void cm_format_dreq(struct cm_dreq_msg *dreq_msg,
2168 struct cm_id_private *cm_id_priv,
2169 const void *private_data,
2170 u8 private_data_len)
2172 cm_format_mad_hdr(&dreq_msg->hdr, CM_DREQ_ATTR_ID,
2173 cm_form_tid(cm_id_priv, CM_MSG_SEQUENCE_DREQ));
2174 dreq_msg->local_comm_id = cm_id_priv->id.local_id;
2175 dreq_msg->remote_comm_id = cm_id_priv->id.remote_id;
2176 cm_dreq_set_remote_qpn(dreq_msg, cm_id_priv->remote_qpn);
2178 if (private_data && private_data_len)
2179 memcpy(dreq_msg->private_data, private_data, private_data_len);
2182 int ib_send_cm_dreq(struct ib_cm_id *cm_id,
2183 const void *private_data,
2184 u8 private_data_len)
2186 struct cm_id_private *cm_id_priv;
2187 struct ib_mad_send_buf *msg;
2188 unsigned long flags;
2191 if (private_data && private_data_len > IB_CM_DREQ_PRIVATE_DATA_SIZE)
2194 cm_id_priv = container_of(cm_id, struct cm_id_private, id);
2195 spin_lock_irqsave(&cm_id_priv->lock, flags);
2196 if (cm_id->state != IB_CM_ESTABLISHED) {
2201 if (cm_id->lap_state == IB_CM_LAP_SENT ||
2202 cm_id->lap_state == IB_CM_MRA_LAP_RCVD)
2203 ib_cancel_mad(cm_id_priv->av.port->mad_agent, cm_id_priv->msg);
2205 ret = cm_alloc_msg(cm_id_priv, &msg);
2207 cm_enter_timewait(cm_id_priv);
2211 cm_format_dreq((struct cm_dreq_msg *) msg->mad, cm_id_priv,
2212 private_data, private_data_len);
2213 msg->timeout_ms = cm_id_priv->timeout_ms;
2214 msg->context[1] = (void *) (unsigned long) IB_CM_DREQ_SENT;
2216 ret = ib_post_send_mad(msg, NULL);
2218 cm_enter_timewait(cm_id_priv);
2219 spin_unlock_irqrestore(&cm_id_priv->lock, flags);
2224 cm_id->state = IB_CM_DREQ_SENT;
2225 cm_id_priv->msg = msg;
2226 out: spin_unlock_irqrestore(&cm_id_priv->lock, flags);
2229 EXPORT_SYMBOL(ib_send_cm_dreq);
2231 static void cm_format_drep(struct cm_drep_msg *drep_msg,
2232 struct cm_id_private *cm_id_priv,
2233 const void *private_data,
2234 u8 private_data_len)
2236 cm_format_mad_hdr(&drep_msg->hdr, CM_DREP_ATTR_ID, cm_id_priv->tid);
2237 drep_msg->local_comm_id = cm_id_priv->id.local_id;
2238 drep_msg->remote_comm_id = cm_id_priv->id.remote_id;
2240 if (private_data && private_data_len)
2241 memcpy(drep_msg->private_data, private_data, private_data_len);
2244 int ib_send_cm_drep(struct ib_cm_id *cm_id,
2245 const void *private_data,
2246 u8 private_data_len)
2248 struct cm_id_private *cm_id_priv;
2249 struct ib_mad_send_buf *msg;
2250 unsigned long flags;
2254 if (private_data && private_data_len > IB_CM_DREP_PRIVATE_DATA_SIZE)
2257 data = cm_copy_private_data(private_data, private_data_len);
2259 return PTR_ERR(data);
2261 cm_id_priv = container_of(cm_id, struct cm_id_private, id);
2262 spin_lock_irqsave(&cm_id_priv->lock, flags);
2263 if (cm_id->state != IB_CM_DREQ_RCVD) {
2264 spin_unlock_irqrestore(&cm_id_priv->lock, flags);
2269 cm_set_private_data(cm_id_priv, data, private_data_len);
2270 cm_enter_timewait(cm_id_priv);
2272 ret = cm_alloc_msg(cm_id_priv, &msg);
2276 cm_format_drep((struct cm_drep_msg *) msg->mad, cm_id_priv,
2277 private_data, private_data_len);
2279 ret = ib_post_send_mad(msg, NULL);
2281 spin_unlock_irqrestore(&cm_id_priv->lock, flags);
2286 out: spin_unlock_irqrestore(&cm_id_priv->lock, flags);
2289 EXPORT_SYMBOL(ib_send_cm_drep);
2291 static int cm_issue_drep(struct cm_port *port,
2292 struct ib_mad_recv_wc *mad_recv_wc)
2294 struct ib_mad_send_buf *msg = NULL;
2295 struct cm_dreq_msg *dreq_msg;
2296 struct cm_drep_msg *drep_msg;
2299 ret = cm_alloc_response_msg(port, mad_recv_wc, &msg);
2303 dreq_msg = (struct cm_dreq_msg *) mad_recv_wc->recv_buf.mad;
2304 drep_msg = (struct cm_drep_msg *) msg->mad;
2306 cm_format_mad_hdr(&drep_msg->hdr, CM_DREP_ATTR_ID, dreq_msg->hdr.tid);
2307 drep_msg->remote_comm_id = dreq_msg->local_comm_id;
2308 drep_msg->local_comm_id = dreq_msg->remote_comm_id;
2310 ret = ib_post_send_mad(msg, NULL);
2317 static int cm_dreq_handler(struct cm_work *work)
2319 struct cm_id_private *cm_id_priv;
2320 struct cm_dreq_msg *dreq_msg;
2321 struct ib_mad_send_buf *msg = NULL;
2324 dreq_msg = (struct cm_dreq_msg *)work->mad_recv_wc->recv_buf.mad;
2325 cm_id_priv = cm_acquire_id(dreq_msg->remote_comm_id,
2326 dreq_msg->local_comm_id);
2328 atomic_long_inc(&work->port->counter_group[CM_RECV_DUPLICATES].
2329 counter[CM_DREQ_COUNTER]);
2330 cm_issue_drep(work->port, work->mad_recv_wc);
2334 work->cm_event.private_data = &dreq_msg->private_data;
2336 spin_lock_irq(&cm_id_priv->lock);
2337 if (cm_id_priv->local_qpn != cm_dreq_get_remote_qpn(dreq_msg))
2340 switch (cm_id_priv->id.state) {
2341 case IB_CM_REP_SENT:
2342 case IB_CM_DREQ_SENT:
2343 ib_cancel_mad(cm_id_priv->av.port->mad_agent, cm_id_priv->msg);
2345 case IB_CM_ESTABLISHED:
2346 if (cm_id_priv->id.lap_state == IB_CM_LAP_SENT ||
2347 cm_id_priv->id.lap_state == IB_CM_MRA_LAP_RCVD)
2348 ib_cancel_mad(cm_id_priv->av.port->mad_agent, cm_id_priv->msg);
2350 case IB_CM_MRA_REP_RCVD:
2352 case IB_CM_TIMEWAIT:
2353 atomic_long_inc(&work->port->counter_group[CM_RECV_DUPLICATES].
2354 counter[CM_DREQ_COUNTER]);
2355 msg = cm_alloc_response_msg_no_ah(work->port, work->mad_recv_wc);
2359 cm_format_drep((struct cm_drep_msg *) msg->mad, cm_id_priv,
2360 cm_id_priv->private_data,
2361 cm_id_priv->private_data_len);
2362 spin_unlock_irq(&cm_id_priv->lock);
2364 if (cm_create_response_msg_ah(work->port, work->mad_recv_wc, msg) ||
2365 ib_post_send_mad(msg, NULL))
2368 case IB_CM_DREQ_RCVD:
2369 atomic_long_inc(&work->port->counter_group[CM_RECV_DUPLICATES].
2370 counter[CM_DREQ_COUNTER]);
2375 cm_id_priv->id.state = IB_CM_DREQ_RCVD;
2376 cm_id_priv->tid = dreq_msg->hdr.tid;
2377 ret = atomic_inc_and_test(&cm_id_priv->work_count);
2379 list_add_tail(&work->list, &cm_id_priv->work_list);
2380 spin_unlock_irq(&cm_id_priv->lock);
2383 cm_process_work(cm_id_priv, work);
2385 cm_deref_id(cm_id_priv);
2388 unlock: spin_unlock_irq(&cm_id_priv->lock);
2389 deref: cm_deref_id(cm_id_priv);
2393 static int cm_drep_handler(struct cm_work *work)
2395 struct cm_id_private *cm_id_priv;
2396 struct cm_drep_msg *drep_msg;
2399 drep_msg = (struct cm_drep_msg *)work->mad_recv_wc->recv_buf.mad;
2400 cm_id_priv = cm_acquire_id(drep_msg->remote_comm_id,
2401 drep_msg->local_comm_id);
2405 work->cm_event.private_data = &drep_msg->private_data;
2407 spin_lock_irq(&cm_id_priv->lock);
2408 if (cm_id_priv->id.state != IB_CM_DREQ_SENT &&
2409 cm_id_priv->id.state != IB_CM_DREQ_RCVD) {
2410 spin_unlock_irq(&cm_id_priv->lock);
2413 cm_enter_timewait(cm_id_priv);
2415 ib_cancel_mad(cm_id_priv->av.port->mad_agent, cm_id_priv->msg);
2416 ret = atomic_inc_and_test(&cm_id_priv->work_count);
2418 list_add_tail(&work->list, &cm_id_priv->work_list);
2419 spin_unlock_irq(&cm_id_priv->lock);
2422 cm_process_work(cm_id_priv, work);
2424 cm_deref_id(cm_id_priv);
2427 cm_deref_id(cm_id_priv);
2431 int ib_send_cm_rej(struct ib_cm_id *cm_id,
2432 enum ib_cm_rej_reason reason,
2435 const void *private_data,
2436 u8 private_data_len)
2438 struct cm_id_private *cm_id_priv;
2439 struct ib_mad_send_buf *msg;
2440 unsigned long flags;
2443 if ((private_data && private_data_len > IB_CM_REJ_PRIVATE_DATA_SIZE) ||
2444 (ari && ari_length > IB_CM_REJ_ARI_LENGTH))
2447 cm_id_priv = container_of(cm_id, struct cm_id_private, id);
2449 spin_lock_irqsave(&cm_id_priv->lock, flags);
2450 switch (cm_id->state) {
2451 case IB_CM_REQ_SENT:
2452 case IB_CM_MRA_REQ_RCVD:
2453 case IB_CM_REQ_RCVD:
2454 case IB_CM_MRA_REQ_SENT:
2455 case IB_CM_REP_RCVD:
2456 case IB_CM_MRA_REP_SENT:
2457 ret = cm_alloc_msg(cm_id_priv, &msg);
2459 cm_format_rej((struct cm_rej_msg *) msg->mad,
2460 cm_id_priv, reason, ari, ari_length,
2461 private_data, private_data_len);
2463 cm_reset_to_idle(cm_id_priv);
2465 case IB_CM_REP_SENT:
2466 case IB_CM_MRA_REP_RCVD:
2467 ret = cm_alloc_msg(cm_id_priv, &msg);
2469 cm_format_rej((struct cm_rej_msg *) msg->mad,
2470 cm_id_priv, reason, ari, ari_length,
2471 private_data, private_data_len);
2473 cm_enter_timewait(cm_id_priv);
2483 ret = ib_post_send_mad(msg, NULL);
2487 out: spin_unlock_irqrestore(&cm_id_priv->lock, flags);
2490 EXPORT_SYMBOL(ib_send_cm_rej);
2492 static void cm_format_rej_event(struct cm_work *work)
2494 struct cm_rej_msg *rej_msg;
2495 struct ib_cm_rej_event_param *param;
2497 rej_msg = (struct cm_rej_msg *)work->mad_recv_wc->recv_buf.mad;
2498 param = &work->cm_event.param.rej_rcvd;
2499 param->ari = rej_msg->ari;
2500 param->ari_length = cm_rej_get_reject_info_len(rej_msg);
2501 param->reason = __be16_to_cpu(rej_msg->reason);
2502 work->cm_event.private_data = &rej_msg->private_data;
2505 static struct cm_id_private * cm_acquire_rejected_id(struct cm_rej_msg *rej_msg)
2507 struct cm_timewait_info *timewait_info;
2508 struct cm_id_private *cm_id_priv;
2511 remote_id = rej_msg->local_comm_id;
2513 if (__be16_to_cpu(rej_msg->reason) == IB_CM_REJ_TIMEOUT) {
2514 spin_lock_irq(&cm.lock);
2515 timewait_info = cm_find_remote_id( *((__be64 *) rej_msg->ari),
2517 if (!timewait_info) {
2518 spin_unlock_irq(&cm.lock);
2521 cm_id_priv = idr_find(&cm.local_id_table, (__force int)
2522 (timewait_info->work.local_id ^
2523 cm.random_id_operand));
2525 if (cm_id_priv->id.remote_id == remote_id)
2526 atomic_inc(&cm_id_priv->refcount);
2530 spin_unlock_irq(&cm.lock);
2531 } else if (cm_rej_get_msg_rejected(rej_msg) == CM_MSG_RESPONSE_REQ)
2532 cm_id_priv = cm_acquire_id(rej_msg->remote_comm_id, 0);
2534 cm_id_priv = cm_acquire_id(rej_msg->remote_comm_id, remote_id);
2539 static int cm_rej_handler(struct cm_work *work)
2541 struct cm_id_private *cm_id_priv;
2542 struct cm_rej_msg *rej_msg;
2545 rej_msg = (struct cm_rej_msg *)work->mad_recv_wc->recv_buf.mad;
2546 cm_id_priv = cm_acquire_rejected_id(rej_msg);
2550 cm_format_rej_event(work);
2552 spin_lock_irq(&cm_id_priv->lock);
2553 switch (cm_id_priv->id.state) {
2554 case IB_CM_REQ_SENT:
2555 case IB_CM_MRA_REQ_RCVD:
2556 case IB_CM_REP_SENT:
2557 case IB_CM_MRA_REP_RCVD:
2558 ib_cancel_mad(cm_id_priv->av.port->mad_agent, cm_id_priv->msg);
2560 case IB_CM_REQ_RCVD:
2561 case IB_CM_MRA_REQ_SENT:
2562 if (__be16_to_cpu(rej_msg->reason) == IB_CM_REJ_STALE_CONN)
2563 cm_enter_timewait(cm_id_priv);
2565 cm_reset_to_idle(cm_id_priv);
2567 case IB_CM_DREQ_SENT:
2568 ib_cancel_mad(cm_id_priv->av.port->mad_agent, cm_id_priv->msg);
2570 case IB_CM_REP_RCVD:
2571 case IB_CM_MRA_REP_SENT:
2572 cm_enter_timewait(cm_id_priv);
2574 case IB_CM_ESTABLISHED:
2575 if (cm_id_priv->id.lap_state == IB_CM_LAP_UNINIT ||
2576 cm_id_priv->id.lap_state == IB_CM_LAP_SENT) {
2577 if (cm_id_priv->id.lap_state == IB_CM_LAP_SENT)
2578 ib_cancel_mad(cm_id_priv->av.port->mad_agent,
2580 cm_enter_timewait(cm_id_priv);
2585 spin_unlock_irq(&cm_id_priv->lock);
2590 ret = atomic_inc_and_test(&cm_id_priv->work_count);
2592 list_add_tail(&work->list, &cm_id_priv->work_list);
2593 spin_unlock_irq(&cm_id_priv->lock);
2596 cm_process_work(cm_id_priv, work);
2598 cm_deref_id(cm_id_priv);
2601 cm_deref_id(cm_id_priv);
2605 int ib_send_cm_mra(struct ib_cm_id *cm_id,
2607 const void *private_data,
2608 u8 private_data_len)
2610 struct cm_id_private *cm_id_priv;
2611 struct ib_mad_send_buf *msg;
2612 enum ib_cm_state cm_state;
2613 enum ib_cm_lap_state lap_state;
2614 enum cm_msg_response msg_response;
2616 unsigned long flags;
2619 if (private_data && private_data_len > IB_CM_MRA_PRIVATE_DATA_SIZE)
2622 data = cm_copy_private_data(private_data, private_data_len);
2624 return PTR_ERR(data);
2626 cm_id_priv = container_of(cm_id, struct cm_id_private, id);
2628 spin_lock_irqsave(&cm_id_priv->lock, flags);
2629 switch(cm_id_priv->id.state) {
2630 case IB_CM_REQ_RCVD:
2631 cm_state = IB_CM_MRA_REQ_SENT;
2632 lap_state = cm_id->lap_state;
2633 msg_response = CM_MSG_RESPONSE_REQ;
2635 case IB_CM_REP_RCVD:
2636 cm_state = IB_CM_MRA_REP_SENT;
2637 lap_state = cm_id->lap_state;
2638 msg_response = CM_MSG_RESPONSE_REP;
2640 case IB_CM_ESTABLISHED:
2641 if (cm_id->lap_state == IB_CM_LAP_RCVD) {
2642 cm_state = cm_id->state;
2643 lap_state = IB_CM_MRA_LAP_SENT;
2644 msg_response = CM_MSG_RESPONSE_OTHER;
2652 if (!(service_timeout & IB_CM_MRA_FLAG_DELAY)) {
2653 ret = cm_alloc_msg(cm_id_priv, &msg);
2657 cm_format_mra((struct cm_mra_msg *) msg->mad, cm_id_priv,
2658 msg_response, service_timeout,
2659 private_data, private_data_len);
2660 ret = ib_post_send_mad(msg, NULL);
2665 cm_id->state = cm_state;
2666 cm_id->lap_state = lap_state;
2667 cm_id_priv->service_timeout = service_timeout;
2668 cm_set_private_data(cm_id_priv, data, private_data_len);
2669 spin_unlock_irqrestore(&cm_id_priv->lock, flags);
2672 error1: spin_unlock_irqrestore(&cm_id_priv->lock, flags);
2676 error2: spin_unlock_irqrestore(&cm_id_priv->lock, flags);
2681 EXPORT_SYMBOL(ib_send_cm_mra);
2683 static struct cm_id_private * cm_acquire_mraed_id(struct cm_mra_msg *mra_msg)
2685 switch (cm_mra_get_msg_mraed(mra_msg)) {
2686 case CM_MSG_RESPONSE_REQ:
2687 return cm_acquire_id(mra_msg->remote_comm_id, 0);
2688 case CM_MSG_RESPONSE_REP:
2689 case CM_MSG_RESPONSE_OTHER:
2690 return cm_acquire_id(mra_msg->remote_comm_id,
2691 mra_msg->local_comm_id);
2697 static int cm_mra_handler(struct cm_work *work)
2699 struct cm_id_private *cm_id_priv;
2700 struct cm_mra_msg *mra_msg;
2703 mra_msg = (struct cm_mra_msg *)work->mad_recv_wc->recv_buf.mad;
2704 cm_id_priv = cm_acquire_mraed_id(mra_msg);
2708 work->cm_event.private_data = &mra_msg->private_data;
2709 work->cm_event.param.mra_rcvd.service_timeout =
2710 cm_mra_get_service_timeout(mra_msg);
2711 timeout = cm_convert_to_ms(cm_mra_get_service_timeout(mra_msg)) +
2712 cm_convert_to_ms(cm_id_priv->av.timeout);
2714 spin_lock_irq(&cm_id_priv->lock);
2715 switch (cm_id_priv->id.state) {
2716 case IB_CM_REQ_SENT:
2717 if (cm_mra_get_msg_mraed(mra_msg) != CM_MSG_RESPONSE_REQ ||
2718 ib_modify_mad(cm_id_priv->av.port->mad_agent,
2719 cm_id_priv->msg, timeout))
2721 cm_id_priv->id.state = IB_CM_MRA_REQ_RCVD;
2723 case IB_CM_REP_SENT:
2724 if (cm_mra_get_msg_mraed(mra_msg) != CM_MSG_RESPONSE_REP ||
2725 ib_modify_mad(cm_id_priv->av.port->mad_agent,
2726 cm_id_priv->msg, timeout))
2728 cm_id_priv->id.state = IB_CM_MRA_REP_RCVD;
2730 case IB_CM_ESTABLISHED:
2731 if (cm_mra_get_msg_mraed(mra_msg) != CM_MSG_RESPONSE_OTHER ||
2732 cm_id_priv->id.lap_state != IB_CM_LAP_SENT ||
2733 ib_modify_mad(cm_id_priv->av.port->mad_agent,
2734 cm_id_priv->msg, timeout)) {
2735 if (cm_id_priv->id.lap_state == IB_CM_MRA_LAP_RCVD)
2736 atomic_long_inc(&work->port->
2737 counter_group[CM_RECV_DUPLICATES].
2738 counter[CM_MRA_COUNTER]);
2741 cm_id_priv->id.lap_state = IB_CM_MRA_LAP_RCVD;
2743 case IB_CM_MRA_REQ_RCVD:
2744 case IB_CM_MRA_REP_RCVD:
2745 atomic_long_inc(&work->port->counter_group[CM_RECV_DUPLICATES].
2746 counter[CM_MRA_COUNTER]);
2752 cm_id_priv->msg->context[1] = (void *) (unsigned long)
2753 cm_id_priv->id.state;
2754 ret = atomic_inc_and_test(&cm_id_priv->work_count);
2756 list_add_tail(&work->list, &cm_id_priv->work_list);
2757 spin_unlock_irq(&cm_id_priv->lock);
2760 cm_process_work(cm_id_priv, work);
2762 cm_deref_id(cm_id_priv);
2765 spin_unlock_irq(&cm_id_priv->lock);
2766 cm_deref_id(cm_id_priv);
2770 static void cm_format_lap(struct cm_lap_msg *lap_msg,
2771 struct cm_id_private *cm_id_priv,
2772 struct ib_sa_path_rec *alternate_path,
2773 const void *private_data,
2774 u8 private_data_len)
2776 cm_format_mad_hdr(&lap_msg->hdr, CM_LAP_ATTR_ID,
2777 cm_form_tid(cm_id_priv, CM_MSG_SEQUENCE_LAP));
2778 lap_msg->local_comm_id = cm_id_priv->id.local_id;
2779 lap_msg->remote_comm_id = cm_id_priv->id.remote_id;
2780 cm_lap_set_remote_qpn(lap_msg, cm_id_priv->remote_qpn);
2781 /* todo: need remote CM response timeout */
2782 cm_lap_set_remote_resp_timeout(lap_msg, 0x1F);
2783 lap_msg->alt_local_lid = alternate_path->slid;
2784 lap_msg->alt_remote_lid = alternate_path->dlid;
2785 lap_msg->alt_local_gid = alternate_path->sgid;
2786 lap_msg->alt_remote_gid = alternate_path->dgid;
2787 cm_lap_set_flow_label(lap_msg, alternate_path->flow_label);
2788 cm_lap_set_traffic_class(lap_msg, alternate_path->traffic_class);
2789 lap_msg->alt_hop_limit = alternate_path->hop_limit;
2790 cm_lap_set_packet_rate(lap_msg, alternate_path->rate);
2791 cm_lap_set_sl(lap_msg, alternate_path->sl);
2792 cm_lap_set_subnet_local(lap_msg, 1); /* local only... */
2793 cm_lap_set_local_ack_timeout(lap_msg,
2794 cm_ack_timeout(cm_id_priv->av.port->cm_dev->ack_delay,
2795 alternate_path->packet_life_time));
2797 if (private_data && private_data_len)
2798 memcpy(lap_msg->private_data, private_data, private_data_len);
2801 int ib_send_cm_lap(struct ib_cm_id *cm_id,
2802 struct ib_sa_path_rec *alternate_path,
2803 const void *private_data,
2804 u8 private_data_len)
2806 struct cm_id_private *cm_id_priv;
2807 struct ib_mad_send_buf *msg;
2808 unsigned long flags;
2811 if (private_data && private_data_len > IB_CM_LAP_PRIVATE_DATA_SIZE)
2814 cm_id_priv = container_of(cm_id, struct cm_id_private, id);
2815 spin_lock_irqsave(&cm_id_priv->lock, flags);
2816 if (cm_id->state != IB_CM_ESTABLISHED ||
2817 (cm_id->lap_state != IB_CM_LAP_UNINIT &&
2818 cm_id->lap_state != IB_CM_LAP_IDLE)) {
2823 ret = cm_init_av_by_path(alternate_path, &cm_id_priv->alt_av,
2827 cm_id_priv->alt_av.timeout =
2828 cm_ack_timeout(cm_id_priv->target_ack_delay,
2829 cm_id_priv->alt_av.timeout - 1);
2831 ret = cm_alloc_msg(cm_id_priv, &msg);
2835 cm_format_lap((struct cm_lap_msg *) msg->mad, cm_id_priv,
2836 alternate_path, private_data, private_data_len);
2837 msg->timeout_ms = cm_id_priv->timeout_ms;
2838 msg->context[1] = (void *) (unsigned long) IB_CM_ESTABLISHED;
2840 ret = ib_post_send_mad(msg, NULL);
2842 spin_unlock_irqrestore(&cm_id_priv->lock, flags);
2847 cm_id->lap_state = IB_CM_LAP_SENT;
2848 cm_id_priv->msg = msg;
2850 out: spin_unlock_irqrestore(&cm_id_priv->lock, flags);
2853 EXPORT_SYMBOL(ib_send_cm_lap);
2855 static void cm_format_path_from_lap(struct cm_id_private *cm_id_priv,
2856 struct ib_sa_path_rec *path,
2857 struct cm_lap_msg *lap_msg)
2859 memset(path, 0, sizeof *path);
2860 path->dgid = lap_msg->alt_local_gid;
2861 path->sgid = lap_msg->alt_remote_gid;
2862 path->dlid = lap_msg->alt_local_lid;
2863 path->slid = lap_msg->alt_remote_lid;
2864 path->flow_label = cm_lap_get_flow_label(lap_msg);
2865 path->hop_limit = lap_msg->alt_hop_limit;
2866 path->traffic_class = cm_lap_get_traffic_class(lap_msg);
2867 path->reversible = 1;
2868 path->pkey = cm_id_priv->pkey;
2869 path->sl = cm_lap_get_sl(lap_msg);
2870 path->mtu_selector = IB_SA_EQ;
2871 path->mtu = cm_id_priv->path_mtu;
2872 path->rate_selector = IB_SA_EQ;
2873 path->rate = cm_lap_get_packet_rate(lap_msg);
2874 path->packet_life_time_selector = IB_SA_EQ;
2875 path->packet_life_time = cm_lap_get_local_ack_timeout(lap_msg);
2876 path->packet_life_time -= (path->packet_life_time > 0);
2879 static int cm_lap_handler(struct cm_work *work)
2881 struct cm_id_private *cm_id_priv;
2882 struct cm_lap_msg *lap_msg;
2883 struct ib_cm_lap_event_param *param;
2884 struct ib_mad_send_buf *msg = NULL;
2887 /* todo: verify LAP request and send reject APR if invalid. */
2888 lap_msg = (struct cm_lap_msg *)work->mad_recv_wc->recv_buf.mad;
2889 cm_id_priv = cm_acquire_id(lap_msg->remote_comm_id,
2890 lap_msg->local_comm_id);
2894 param = &work->cm_event.param.lap_rcvd;
2895 param->alternate_path = &work->path[0];
2896 cm_format_path_from_lap(cm_id_priv, param->alternate_path, lap_msg);
2897 work->cm_event.private_data = &lap_msg->private_data;
2899 spin_lock_irq(&cm_id_priv->lock);
2900 if (cm_id_priv->id.state != IB_CM_ESTABLISHED)
2903 switch (cm_id_priv->id.lap_state) {
2904 case IB_CM_LAP_UNINIT:
2905 case IB_CM_LAP_IDLE:
2907 case IB_CM_MRA_LAP_SENT:
2908 atomic_long_inc(&work->port->counter_group[CM_RECV_DUPLICATES].
2909 counter[CM_LAP_COUNTER]);
2910 msg = cm_alloc_response_msg_no_ah(work->port, work->mad_recv_wc);
2914 cm_format_mra((struct cm_mra_msg *) msg->mad, cm_id_priv,
2915 CM_MSG_RESPONSE_OTHER,
2916 cm_id_priv->service_timeout,
2917 cm_id_priv->private_data,
2918 cm_id_priv->private_data_len);
2919 spin_unlock_irq(&cm_id_priv->lock);
2921 if (cm_create_response_msg_ah(work->port, work->mad_recv_wc, msg) ||
2922 ib_post_send_mad(msg, NULL))
2925 case IB_CM_LAP_RCVD:
2926 atomic_long_inc(&work->port->counter_group[CM_RECV_DUPLICATES].
2927 counter[CM_LAP_COUNTER]);
2933 cm_id_priv->id.lap_state = IB_CM_LAP_RCVD;
2934 cm_id_priv->tid = lap_msg->hdr.tid;
2935 ret = cm_init_av_for_response(work->port, work->mad_recv_wc->wc,
2936 work->mad_recv_wc->recv_buf.grh,
2940 ret = cm_init_av_by_path(param->alternate_path, &cm_id_priv->alt_av,
2944 ret = atomic_inc_and_test(&cm_id_priv->work_count);
2946 list_add_tail(&work->list, &cm_id_priv->work_list);
2947 spin_unlock_irq(&cm_id_priv->lock);
2950 cm_process_work(cm_id_priv, work);
2952 cm_deref_id(cm_id_priv);
2955 unlock: spin_unlock_irq(&cm_id_priv->lock);
2956 deref: cm_deref_id(cm_id_priv);
2960 static void cm_format_apr(struct cm_apr_msg *apr_msg,
2961 struct cm_id_private *cm_id_priv,
2962 enum ib_cm_apr_status status,
2965 const void *private_data,
2966 u8 private_data_len)
2968 cm_format_mad_hdr(&apr_msg->hdr, CM_APR_ATTR_ID, cm_id_priv->tid);
2969 apr_msg->local_comm_id = cm_id_priv->id.local_id;
2970 apr_msg->remote_comm_id = cm_id_priv->id.remote_id;
2971 apr_msg->ap_status = (u8) status;
2973 if (info && info_length) {
2974 apr_msg->info_length = info_length;
2975 memcpy(apr_msg->info, info, info_length);
2978 if (private_data && private_data_len)
2979 memcpy(apr_msg->private_data, private_data, private_data_len);
2982 int ib_send_cm_apr(struct ib_cm_id *cm_id,
2983 enum ib_cm_apr_status status,
2986 const void *private_data,
2987 u8 private_data_len)
2989 struct cm_id_private *cm_id_priv;
2990 struct ib_mad_send_buf *msg;
2991 unsigned long flags;
2994 if ((private_data && private_data_len > IB_CM_APR_PRIVATE_DATA_SIZE) ||
2995 (info && info_length > IB_CM_APR_INFO_LENGTH))
2998 cm_id_priv = container_of(cm_id, struct cm_id_private, id);
2999 spin_lock_irqsave(&cm_id_priv->lock, flags);
3000 if (cm_id->state != IB_CM_ESTABLISHED ||
3001 (cm_id->lap_state != IB_CM_LAP_RCVD &&
3002 cm_id->lap_state != IB_CM_MRA_LAP_SENT)) {
3007 ret = cm_alloc_msg(cm_id_priv, &msg);
3011 cm_format_apr((struct cm_apr_msg *) msg->mad, cm_id_priv, status,
3012 info, info_length, private_data, private_data_len);
3013 ret = ib_post_send_mad(msg, NULL);
3015 spin_unlock_irqrestore(&cm_id_priv->lock, flags);
3020 cm_id->lap_state = IB_CM_LAP_IDLE;
3021 out: spin_unlock_irqrestore(&cm_id_priv->lock, flags);
3024 EXPORT_SYMBOL(ib_send_cm_apr);
3026 static int cm_apr_handler(struct cm_work *work)
3028 struct cm_id_private *cm_id_priv;
3029 struct cm_apr_msg *apr_msg;
3032 apr_msg = (struct cm_apr_msg *)work->mad_recv_wc->recv_buf.mad;
3033 cm_id_priv = cm_acquire_id(apr_msg->remote_comm_id,
3034 apr_msg->local_comm_id);
3036 return -EINVAL; /* Unmatched reply. */
3038 work->cm_event.param.apr_rcvd.ap_status = apr_msg->ap_status;
3039 work->cm_event.param.apr_rcvd.apr_info = &apr_msg->info;
3040 work->cm_event.param.apr_rcvd.info_len = apr_msg->info_length;
3041 work->cm_event.private_data = &apr_msg->private_data;
3043 spin_lock_irq(&cm_id_priv->lock);
3044 if (cm_id_priv->id.state != IB_CM_ESTABLISHED ||
3045 (cm_id_priv->id.lap_state != IB_CM_LAP_SENT &&
3046 cm_id_priv->id.lap_state != IB_CM_MRA_LAP_RCVD)) {
3047 spin_unlock_irq(&cm_id_priv->lock);
3050 cm_id_priv->id.lap_state = IB_CM_LAP_IDLE;
3051 ib_cancel_mad(cm_id_priv->av.port->mad_agent, cm_id_priv->msg);
3052 cm_id_priv->msg = NULL;
3054 ret = atomic_inc_and_test(&cm_id_priv->work_count);
3056 list_add_tail(&work->list, &cm_id_priv->work_list);
3057 spin_unlock_irq(&cm_id_priv->lock);
3060 cm_process_work(cm_id_priv, work);
3062 cm_deref_id(cm_id_priv);
3065 cm_deref_id(cm_id_priv);
3069 static int cm_timewait_handler(struct cm_work *work)
3071 struct cm_timewait_info *timewait_info;
3072 struct cm_id_private *cm_id_priv;
3075 timewait_info = (struct cm_timewait_info *)work;
3076 spin_lock_irq(&cm.lock);
3077 list_del(&timewait_info->list);
3078 spin_unlock_irq(&cm.lock);
3080 cm_id_priv = cm_acquire_id(timewait_info->work.local_id,
3081 timewait_info->work.remote_id);
3085 spin_lock_irq(&cm_id_priv->lock);
3086 if (cm_id_priv->id.state != IB_CM_TIMEWAIT ||
3087 cm_id_priv->remote_qpn != timewait_info->remote_qpn) {
3088 spin_unlock_irq(&cm_id_priv->lock);
3091 cm_id_priv->id.state = IB_CM_IDLE;
3092 ret = atomic_inc_and_test(&cm_id_priv->work_count);
3094 list_add_tail(&work->list, &cm_id_priv->work_list);
3095 spin_unlock_irq(&cm_id_priv->lock);
3098 cm_process_work(cm_id_priv, work);
3100 cm_deref_id(cm_id_priv);
3103 cm_deref_id(cm_id_priv);
3107 static void cm_format_sidr_req(struct cm_sidr_req_msg *sidr_req_msg,
3108 struct cm_id_private *cm_id_priv,
3109 struct ib_cm_sidr_req_param *param)
3111 cm_format_mad_hdr(&sidr_req_msg->hdr, CM_SIDR_REQ_ATTR_ID,
3112 cm_form_tid(cm_id_priv, CM_MSG_SEQUENCE_SIDR));
3113 sidr_req_msg->request_id = cm_id_priv->id.local_id;
3114 sidr_req_msg->pkey = param->path->pkey;
3115 sidr_req_msg->service_id = param->service_id;
3117 if (param->private_data && param->private_data_len)
3118 memcpy(sidr_req_msg->private_data, param->private_data,
3119 param->private_data_len);
3122 int ib_send_cm_sidr_req(struct ib_cm_id *cm_id,
3123 struct ib_cm_sidr_req_param *param)
3125 struct cm_id_private *cm_id_priv;
3126 struct ib_mad_send_buf *msg;
3127 unsigned long flags;
3130 if (!param->path || (param->private_data &&
3131 param->private_data_len > IB_CM_SIDR_REQ_PRIVATE_DATA_SIZE))
3134 cm_id_priv = container_of(cm_id, struct cm_id_private, id);
3135 ret = cm_init_av_by_path(param->path, &cm_id_priv->av, cm_id_priv);
3139 cm_id->service_id = param->service_id;
3140 cm_id->service_mask = ~cpu_to_be64(0);
3141 cm_id_priv->timeout_ms = param->timeout_ms;
3142 cm_id_priv->max_cm_retries = param->max_cm_retries;
3143 ret = cm_alloc_msg(cm_id_priv, &msg);
3147 cm_format_sidr_req((struct cm_sidr_req_msg *) msg->mad, cm_id_priv,
3149 msg->timeout_ms = cm_id_priv->timeout_ms;
3150 msg->context[1] = (void *) (unsigned long) IB_CM_SIDR_REQ_SENT;
3152 spin_lock_irqsave(&cm_id_priv->lock, flags);
3153 if (cm_id->state == IB_CM_IDLE)
3154 ret = ib_post_send_mad(msg, NULL);
3159 spin_unlock_irqrestore(&cm_id_priv->lock, flags);
3163 cm_id->state = IB_CM_SIDR_REQ_SENT;
3164 cm_id_priv->msg = msg;
3165 spin_unlock_irqrestore(&cm_id_priv->lock, flags);
3169 EXPORT_SYMBOL(ib_send_cm_sidr_req);
3171 static void cm_format_sidr_req_event(struct cm_work *work,
3172 const struct cm_id_private *rx_cm_id,
3173 struct ib_cm_id *listen_id)
3175 struct cm_sidr_req_msg *sidr_req_msg;
3176 struct ib_cm_sidr_req_event_param *param;
3178 sidr_req_msg = (struct cm_sidr_req_msg *)
3179 work->mad_recv_wc->recv_buf.mad;
3180 param = &work->cm_event.param.sidr_req_rcvd;
3181 param->pkey = __be16_to_cpu(sidr_req_msg->pkey);
3182 param->listen_id = listen_id;
3183 param->service_id = sidr_req_msg->service_id;
3184 param->bth_pkey = cm_get_bth_pkey(work);
3185 param->port = work->port->port_num;
3186 param->sgid_index = rx_cm_id->av.ah_attr.grh.sgid_index;
3187 work->cm_event.private_data = &sidr_req_msg->private_data;
3190 static int cm_sidr_req_handler(struct cm_work *work)
3192 struct ib_cm_id *cm_id;
3193 struct cm_id_private *cm_id_priv, *cur_cm_id_priv;
3194 struct cm_sidr_req_msg *sidr_req_msg;
3198 cm_id = ib_create_cm_id(work->port->cm_dev->ib_device, NULL, NULL);
3200 return PTR_ERR(cm_id);
3201 cm_id_priv = container_of(cm_id, struct cm_id_private, id);
3203 /* Record SGID/SLID and request ID for lookup. */
3204 sidr_req_msg = (struct cm_sidr_req_msg *)
3205 work->mad_recv_wc->recv_buf.mad;
3206 wc = work->mad_recv_wc->wc;
3207 cm_id_priv->av.dgid.global.subnet_prefix = cpu_to_be64(wc->slid);
3208 cm_id_priv->av.dgid.global.interface_id = 0;
3209 ret = cm_init_av_for_response(work->port, work->mad_recv_wc->wc,
3210 work->mad_recv_wc->recv_buf.grh,
3214 cm_id_priv->id.remote_id = sidr_req_msg->request_id;
3215 cm_id_priv->tid = sidr_req_msg->hdr.tid;
3216 atomic_inc(&cm_id_priv->work_count);
3218 spin_lock_irq(&cm.lock);
3219 cur_cm_id_priv = cm_insert_remote_sidr(cm_id_priv);
3220 if (cur_cm_id_priv) {
3221 spin_unlock_irq(&cm.lock);
3222 atomic_long_inc(&work->port->counter_group[CM_RECV_DUPLICATES].
3223 counter[CM_SIDR_REQ_COUNTER]);
3224 goto out; /* Duplicate message. */
3226 cm_id_priv->id.state = IB_CM_SIDR_REQ_RCVD;
3227 cur_cm_id_priv = cm_find_listen(cm_id->device,
3228 sidr_req_msg->service_id);
3229 if (!cur_cm_id_priv) {
3230 spin_unlock_irq(&cm.lock);
3231 cm_reject_sidr_req(cm_id_priv, IB_SIDR_UNSUPPORTED);
3232 goto out; /* No match. */
3234 atomic_inc(&cur_cm_id_priv->refcount);
3235 atomic_inc(&cm_id_priv->refcount);
3236 spin_unlock_irq(&cm.lock);
3238 cm_id_priv->id.cm_handler = cur_cm_id_priv->id.cm_handler;
3239 cm_id_priv->id.context = cur_cm_id_priv->id.context;
3240 cm_id_priv->id.service_id = sidr_req_msg->service_id;
3241 cm_id_priv->id.service_mask = ~cpu_to_be64(0);
3243 cm_format_sidr_req_event(work, cm_id_priv, &cur_cm_id_priv->id);
3244 cm_process_work(cm_id_priv, work);
3245 cm_deref_id(cur_cm_id_priv);
3248 ib_destroy_cm_id(&cm_id_priv->id);
3252 static void cm_format_sidr_rep(struct cm_sidr_rep_msg *sidr_rep_msg,
3253 struct cm_id_private *cm_id_priv,
3254 struct ib_cm_sidr_rep_param *param)
3256 cm_format_mad_hdr(&sidr_rep_msg->hdr, CM_SIDR_REP_ATTR_ID,
3258 sidr_rep_msg->request_id = cm_id_priv->id.remote_id;
3259 sidr_rep_msg->status = param->status;
3260 cm_sidr_rep_set_qpn(sidr_rep_msg, cpu_to_be32(param->qp_num));
3261 sidr_rep_msg->service_id = cm_id_priv->id.service_id;
3262 sidr_rep_msg->qkey = cpu_to_be32(param->qkey);
3264 if (param->info && param->info_length)
3265 memcpy(sidr_rep_msg->info, param->info, param->info_length);
3267 if (param->private_data && param->private_data_len)
3268 memcpy(sidr_rep_msg->private_data, param->private_data,
3269 param->private_data_len);
3272 int ib_send_cm_sidr_rep(struct ib_cm_id *cm_id,
3273 struct ib_cm_sidr_rep_param *param)
3275 struct cm_id_private *cm_id_priv;
3276 struct ib_mad_send_buf *msg;
3277 unsigned long flags;
3280 if ((param->info && param->info_length > IB_CM_SIDR_REP_INFO_LENGTH) ||
3281 (param->private_data &&
3282 param->private_data_len > IB_CM_SIDR_REP_PRIVATE_DATA_SIZE))
3285 cm_id_priv = container_of(cm_id, struct cm_id_private, id);
3286 spin_lock_irqsave(&cm_id_priv->lock, flags);
3287 if (cm_id->state != IB_CM_SIDR_REQ_RCVD) {
3292 ret = cm_alloc_msg(cm_id_priv, &msg);
3296 cm_format_sidr_rep((struct cm_sidr_rep_msg *) msg->mad, cm_id_priv,
3298 ret = ib_post_send_mad(msg, NULL);
3300 spin_unlock_irqrestore(&cm_id_priv->lock, flags);
3304 cm_id->state = IB_CM_IDLE;
3305 spin_unlock_irqrestore(&cm_id_priv->lock, flags);
3307 spin_lock_irqsave(&cm.lock, flags);
3308 if (!RB_EMPTY_NODE(&cm_id_priv->sidr_id_node)) {
3309 rb_erase(&cm_id_priv->sidr_id_node, &cm.remote_sidr_table);
3310 RB_CLEAR_NODE(&cm_id_priv->sidr_id_node);
3312 spin_unlock_irqrestore(&cm.lock, flags);
3315 error: spin_unlock_irqrestore(&cm_id_priv->lock, flags);
3318 EXPORT_SYMBOL(ib_send_cm_sidr_rep);
3320 static void cm_format_sidr_rep_event(struct cm_work *work)
3322 struct cm_sidr_rep_msg *sidr_rep_msg;
3323 struct ib_cm_sidr_rep_event_param *param;
3325 sidr_rep_msg = (struct cm_sidr_rep_msg *)
3326 work->mad_recv_wc->recv_buf.mad;
3327 param = &work->cm_event.param.sidr_rep_rcvd;
3328 param->status = sidr_rep_msg->status;
3329 param->qkey = be32_to_cpu(sidr_rep_msg->qkey);
3330 param->qpn = be32_to_cpu(cm_sidr_rep_get_qpn(sidr_rep_msg));
3331 param->info = &sidr_rep_msg->info;
3332 param->info_len = sidr_rep_msg->info_length;
3333 work->cm_event.private_data = &sidr_rep_msg->private_data;
3336 static int cm_sidr_rep_handler(struct cm_work *work)
3338 struct cm_sidr_rep_msg *sidr_rep_msg;
3339 struct cm_id_private *cm_id_priv;
3341 sidr_rep_msg = (struct cm_sidr_rep_msg *)
3342 work->mad_recv_wc->recv_buf.mad;
3343 cm_id_priv = cm_acquire_id(sidr_rep_msg->request_id, 0);
3345 return -EINVAL; /* Unmatched reply. */
3347 spin_lock_irq(&cm_id_priv->lock);
3348 if (cm_id_priv->id.state != IB_CM_SIDR_REQ_SENT) {
3349 spin_unlock_irq(&cm_id_priv->lock);
3352 cm_id_priv->id.state = IB_CM_IDLE;
3353 ib_cancel_mad(cm_id_priv->av.port->mad_agent, cm_id_priv->msg);
3354 spin_unlock_irq(&cm_id_priv->lock);
3356 cm_format_sidr_rep_event(work);
3357 cm_process_work(cm_id_priv, work);
3360 cm_deref_id(cm_id_priv);
3364 static void cm_process_send_error(struct ib_mad_send_buf *msg,
3365 enum ib_wc_status wc_status)
3367 struct cm_id_private *cm_id_priv;
3368 struct ib_cm_event cm_event;
3369 enum ib_cm_state state;
3372 memset(&cm_event, 0, sizeof cm_event);
3373 cm_id_priv = msg->context[0];
3375 /* Discard old sends or ones without a response. */
3376 spin_lock_irq(&cm_id_priv->lock);
3377 state = (enum ib_cm_state) (unsigned long) msg->context[1];
3378 if (msg != cm_id_priv->msg || state != cm_id_priv->id.state)
3382 case IB_CM_REQ_SENT:
3383 case IB_CM_MRA_REQ_RCVD:
3384 cm_reset_to_idle(cm_id_priv);
3385 cm_event.event = IB_CM_REQ_ERROR;
3387 case IB_CM_REP_SENT:
3388 case IB_CM_MRA_REP_RCVD:
3389 cm_reset_to_idle(cm_id_priv);
3390 cm_event.event = IB_CM_REP_ERROR;
3392 case IB_CM_DREQ_SENT:
3393 cm_enter_timewait(cm_id_priv);
3394 cm_event.event = IB_CM_DREQ_ERROR;
3396 case IB_CM_SIDR_REQ_SENT:
3397 cm_id_priv->id.state = IB_CM_IDLE;
3398 cm_event.event = IB_CM_SIDR_REQ_ERROR;
3403 spin_unlock_irq(&cm_id_priv->lock);
3404 cm_event.param.send_status = wc_status;
3406 /* No other events can occur on the cm_id at this point. */
3407 ret = cm_id_priv->id.cm_handler(&cm_id_priv->id, &cm_event);
3410 ib_destroy_cm_id(&cm_id_priv->id);
3413 spin_unlock_irq(&cm_id_priv->lock);
3417 static void cm_send_handler(struct ib_mad_agent *mad_agent,
3418 struct ib_mad_send_wc *mad_send_wc)
3420 struct ib_mad_send_buf *msg = mad_send_wc->send_buf;
3421 struct cm_port *port;
3424 port = mad_agent->context;
3425 attr_index = be16_to_cpu(((struct ib_mad_hdr *)
3426 msg->mad)->attr_id) - CM_ATTR_ID_OFFSET;
3429 * If the send was in response to a received message (context[0] is not
3430 * set to a cm_id), and is not a REJ, then it is a send that was
3433 if (!msg->context[0] && (attr_index != CM_REJ_COUNTER))
3436 atomic_long_add(1 + msg->retries,
3437 &port->counter_group[CM_XMIT].counter[attr_index]);
3439 atomic_long_add(msg->retries,
3440 &port->counter_group[CM_XMIT_RETRIES].
3441 counter[attr_index]);
3443 switch (mad_send_wc->status) {
3445 case IB_WC_WR_FLUSH_ERR:
3449 if (msg->context[0] && msg->context[1])
3450 cm_process_send_error(msg, mad_send_wc->status);
3457 static void cm_work_handler(struct work_struct *_work)
3459 struct cm_work *work = container_of(_work, struct cm_work, work.work);
3462 switch (work->cm_event.event) {
3463 case IB_CM_REQ_RECEIVED:
3464 ret = cm_req_handler(work);
3466 case IB_CM_MRA_RECEIVED:
3467 ret = cm_mra_handler(work);
3469 case IB_CM_REJ_RECEIVED:
3470 ret = cm_rej_handler(work);
3472 case IB_CM_REP_RECEIVED:
3473 ret = cm_rep_handler(work);
3475 case IB_CM_RTU_RECEIVED:
3476 ret = cm_rtu_handler(work);
3478 case IB_CM_USER_ESTABLISHED:
3479 ret = cm_establish_handler(work);
3481 case IB_CM_DREQ_RECEIVED:
3482 ret = cm_dreq_handler(work);
3484 case IB_CM_DREP_RECEIVED:
3485 ret = cm_drep_handler(work);
3487 case IB_CM_SIDR_REQ_RECEIVED:
3488 ret = cm_sidr_req_handler(work);
3490 case IB_CM_SIDR_REP_RECEIVED:
3491 ret = cm_sidr_rep_handler(work);
3493 case IB_CM_LAP_RECEIVED:
3494 ret = cm_lap_handler(work);
3496 case IB_CM_APR_RECEIVED:
3497 ret = cm_apr_handler(work);
3499 case IB_CM_TIMEWAIT_EXIT:
3500 ret = cm_timewait_handler(work);
3510 static int cm_establish(struct ib_cm_id *cm_id)
3512 struct cm_id_private *cm_id_priv;
3513 struct cm_work *work;
3514 unsigned long flags;
3516 struct cm_device *cm_dev;
3518 cm_dev = ib_get_client_data(cm_id->device, &cm_client);
3522 work = kmalloc(sizeof *work, GFP_ATOMIC);
3526 cm_id_priv = container_of(cm_id, struct cm_id_private, id);
3527 spin_lock_irqsave(&cm_id_priv->lock, flags);
3528 switch (cm_id->state)
3530 case IB_CM_REP_SENT:
3531 case IB_CM_MRA_REP_RCVD:
3532 cm_id->state = IB_CM_ESTABLISHED;
3534 case IB_CM_ESTABLISHED:
3541 spin_unlock_irqrestore(&cm_id_priv->lock, flags);
3549 * The CM worker thread may try to destroy the cm_id before it
3550 * can execute this work item. To prevent potential deadlock,
3551 * we need to find the cm_id once we're in the context of the
3552 * worker thread, rather than holding a reference on it.
3554 INIT_DELAYED_WORK(&work->work, cm_work_handler);
3555 work->local_id = cm_id->local_id;
3556 work->remote_id = cm_id->remote_id;
3557 work->mad_recv_wc = NULL;
3558 work->cm_event.event = IB_CM_USER_ESTABLISHED;
3560 /* Check if the device started its remove_one */
3561 spin_lock_irqsave(&cm.lock, flags);
3562 if (!cm_dev->going_down) {
3563 queue_delayed_work(cm.wq, &work->work, 0);
3568 spin_unlock_irqrestore(&cm.lock, flags);
3574 static int cm_migrate(struct ib_cm_id *cm_id)
3576 struct cm_id_private *cm_id_priv;
3577 struct cm_av tmp_av;
3578 unsigned long flags;
3579 int tmp_send_port_not_ready;
3582 cm_id_priv = container_of(cm_id, struct cm_id_private, id);
3583 spin_lock_irqsave(&cm_id_priv->lock, flags);
3584 if (cm_id->state == IB_CM_ESTABLISHED &&
3585 (cm_id->lap_state == IB_CM_LAP_UNINIT ||
3586 cm_id->lap_state == IB_CM_LAP_IDLE)) {
3587 cm_id->lap_state = IB_CM_LAP_IDLE;
3588 /* Swap address vector */
3589 tmp_av = cm_id_priv->av;
3590 cm_id_priv->av = cm_id_priv->alt_av;
3591 cm_id_priv->alt_av = tmp_av;
3592 /* Swap port send ready state */
3593 tmp_send_port_not_ready = cm_id_priv->prim_send_port_not_ready;
3594 cm_id_priv->prim_send_port_not_ready = cm_id_priv->altr_send_port_not_ready;
3595 cm_id_priv->altr_send_port_not_ready = tmp_send_port_not_ready;
3598 spin_unlock_irqrestore(&cm_id_priv->lock, flags);
3603 int ib_cm_notify(struct ib_cm_id *cm_id, enum ib_event_type event)
3608 case IB_EVENT_COMM_EST:
3609 ret = cm_establish(cm_id);
3611 case IB_EVENT_PATH_MIG:
3612 ret = cm_migrate(cm_id);
3619 EXPORT_SYMBOL(ib_cm_notify);
3621 static void cm_recv_handler(struct ib_mad_agent *mad_agent,
3622 struct ib_mad_send_buf *send_buf,
3623 struct ib_mad_recv_wc *mad_recv_wc)
3625 struct cm_port *port = mad_agent->context;
3626 struct cm_work *work;
3627 enum ib_cm_event_type event;
3632 switch (mad_recv_wc->recv_buf.mad->mad_hdr.attr_id) {
3633 case CM_REQ_ATTR_ID:
3634 paths = 1 + (((struct cm_req_msg *) mad_recv_wc->recv_buf.mad)->
3635 alt_local_lid != 0);
3636 event = IB_CM_REQ_RECEIVED;
3638 case CM_MRA_ATTR_ID:
3639 event = IB_CM_MRA_RECEIVED;
3641 case CM_REJ_ATTR_ID:
3642 event = IB_CM_REJ_RECEIVED;
3644 case CM_REP_ATTR_ID:
3645 event = IB_CM_REP_RECEIVED;
3647 case CM_RTU_ATTR_ID:
3648 event = IB_CM_RTU_RECEIVED;
3650 case CM_DREQ_ATTR_ID:
3651 event = IB_CM_DREQ_RECEIVED;
3653 case CM_DREP_ATTR_ID:
3654 event = IB_CM_DREP_RECEIVED;
3656 case CM_SIDR_REQ_ATTR_ID:
3657 event = IB_CM_SIDR_REQ_RECEIVED;
3659 case CM_SIDR_REP_ATTR_ID:
3660 event = IB_CM_SIDR_REP_RECEIVED;
3662 case CM_LAP_ATTR_ID:
3664 event = IB_CM_LAP_RECEIVED;
3666 case CM_APR_ATTR_ID:
3667 event = IB_CM_APR_RECEIVED;
3670 ib_free_recv_mad(mad_recv_wc);
3674 attr_id = be16_to_cpu(mad_recv_wc->recv_buf.mad->mad_hdr.attr_id);
3675 atomic_long_inc(&port->counter_group[CM_RECV].
3676 counter[attr_id - CM_ATTR_ID_OFFSET]);
3678 work = kmalloc(sizeof *work + sizeof(struct ib_sa_path_rec) * paths,
3681 ib_free_recv_mad(mad_recv_wc);
3685 INIT_DELAYED_WORK(&work->work, cm_work_handler);
3686 work->cm_event.event = event;
3687 work->mad_recv_wc = mad_recv_wc;
3690 /* Check if the device started its remove_one */
3691 spin_lock_irq(&cm.lock);
3692 if (!port->cm_dev->going_down)
3693 queue_delayed_work(cm.wq, &work->work, 0);
3696 spin_unlock_irq(&cm.lock);
3700 ib_free_recv_mad(mad_recv_wc);
3704 static int cm_init_qp_init_attr(struct cm_id_private *cm_id_priv,
3705 struct ib_qp_attr *qp_attr,
3708 unsigned long flags;
3711 spin_lock_irqsave(&cm_id_priv->lock, flags);
3712 switch (cm_id_priv->id.state) {
3713 case IB_CM_REQ_SENT:
3714 case IB_CM_MRA_REQ_RCVD:
3715 case IB_CM_REQ_RCVD:
3716 case IB_CM_MRA_REQ_SENT:
3717 case IB_CM_REP_RCVD:
3718 case IB_CM_MRA_REP_SENT:
3719 case IB_CM_REP_SENT:
3720 case IB_CM_MRA_REP_RCVD:
3721 case IB_CM_ESTABLISHED:
3722 *qp_attr_mask = IB_QP_STATE | IB_QP_ACCESS_FLAGS |
3723 IB_QP_PKEY_INDEX | IB_QP_PORT;
3724 qp_attr->qp_access_flags = IB_ACCESS_REMOTE_WRITE;
3725 if (cm_id_priv->responder_resources)
3726 qp_attr->qp_access_flags |= IB_ACCESS_REMOTE_READ |
3727 IB_ACCESS_REMOTE_ATOMIC;
3728 qp_attr->pkey_index = cm_id_priv->av.pkey_index;
3729 qp_attr->port_num = cm_id_priv->av.port->port_num;
3736 spin_unlock_irqrestore(&cm_id_priv->lock, flags);
3740 static int cm_init_qp_rtr_attr(struct cm_id_private *cm_id_priv,
3741 struct ib_qp_attr *qp_attr,
3744 unsigned long flags;
3747 spin_lock_irqsave(&cm_id_priv->lock, flags);
3748 switch (cm_id_priv->id.state) {
3749 case IB_CM_REQ_RCVD:
3750 case IB_CM_MRA_REQ_SENT:
3751 case IB_CM_REP_RCVD:
3752 case IB_CM_MRA_REP_SENT:
3753 case IB_CM_REP_SENT:
3754 case IB_CM_MRA_REP_RCVD:
3755 case IB_CM_ESTABLISHED:
3756 *qp_attr_mask = IB_QP_STATE | IB_QP_AV | IB_QP_PATH_MTU |
3757 IB_QP_DEST_QPN | IB_QP_RQ_PSN;
3758 qp_attr->ah_attr = cm_id_priv->av.ah_attr;
3759 qp_attr->path_mtu = cm_id_priv->path_mtu;
3760 qp_attr->dest_qp_num = be32_to_cpu(cm_id_priv->remote_qpn);
3761 qp_attr->rq_psn = be32_to_cpu(cm_id_priv->rq_psn);
3762 if (cm_id_priv->qp_type == IB_QPT_RC ||
3763 cm_id_priv->qp_type == IB_QPT_XRC_TGT) {
3764 *qp_attr_mask |= IB_QP_MAX_DEST_RD_ATOMIC |
3765 IB_QP_MIN_RNR_TIMER;
3766 qp_attr->max_dest_rd_atomic =
3767 cm_id_priv->responder_resources;
3768 qp_attr->min_rnr_timer = 0;
3770 if (cm_id_priv->alt_av.ah_attr.dlid) {
3771 *qp_attr_mask |= IB_QP_ALT_PATH;
3772 qp_attr->alt_port_num = cm_id_priv->alt_av.port->port_num;
3773 qp_attr->alt_pkey_index = cm_id_priv->alt_av.pkey_index;
3774 qp_attr->alt_timeout = cm_id_priv->alt_av.timeout;
3775 qp_attr->alt_ah_attr = cm_id_priv->alt_av.ah_attr;
3783 spin_unlock_irqrestore(&cm_id_priv->lock, flags);
3787 static int cm_init_qp_rts_attr(struct cm_id_private *cm_id_priv,
3788 struct ib_qp_attr *qp_attr,
3791 unsigned long flags;
3794 spin_lock_irqsave(&cm_id_priv->lock, flags);
3795 switch (cm_id_priv->id.state) {
3796 /* Allow transition to RTS before sending REP */
3797 case IB_CM_REQ_RCVD:
3798 case IB_CM_MRA_REQ_SENT:
3800 case IB_CM_REP_RCVD:
3801 case IB_CM_MRA_REP_SENT:
3802 case IB_CM_REP_SENT:
3803 case IB_CM_MRA_REP_RCVD:
3804 case IB_CM_ESTABLISHED:
3805 if (cm_id_priv->id.lap_state == IB_CM_LAP_UNINIT) {
3806 *qp_attr_mask = IB_QP_STATE | IB_QP_SQ_PSN;
3807 qp_attr->sq_psn = be32_to_cpu(cm_id_priv->sq_psn);
3808 switch (cm_id_priv->qp_type) {
3810 case IB_QPT_XRC_INI:
3811 *qp_attr_mask |= IB_QP_RETRY_CNT | IB_QP_RNR_RETRY |
3812 IB_QP_MAX_QP_RD_ATOMIC;
3813 qp_attr->retry_cnt = cm_id_priv->retry_count;
3814 qp_attr->rnr_retry = cm_id_priv->rnr_retry_count;
3815 qp_attr->max_rd_atomic = cm_id_priv->initiator_depth;
3817 case IB_QPT_XRC_TGT:
3818 *qp_attr_mask |= IB_QP_TIMEOUT;
3819 qp_attr->timeout = cm_id_priv->av.timeout;
3824 if (cm_id_priv->alt_av.ah_attr.dlid) {
3825 *qp_attr_mask |= IB_QP_PATH_MIG_STATE;
3826 qp_attr->path_mig_state = IB_MIG_REARM;
3829 *qp_attr_mask = IB_QP_ALT_PATH | IB_QP_PATH_MIG_STATE;
3830 qp_attr->alt_port_num = cm_id_priv->alt_av.port->port_num;
3831 qp_attr->alt_pkey_index = cm_id_priv->alt_av.pkey_index;
3832 qp_attr->alt_timeout = cm_id_priv->alt_av.timeout;
3833 qp_attr->alt_ah_attr = cm_id_priv->alt_av.ah_attr;
3834 qp_attr->path_mig_state = IB_MIG_REARM;
3842 spin_unlock_irqrestore(&cm_id_priv->lock, flags);
3846 int ib_cm_init_qp_attr(struct ib_cm_id *cm_id,
3847 struct ib_qp_attr *qp_attr,
3850 struct cm_id_private *cm_id_priv;
3853 cm_id_priv = container_of(cm_id, struct cm_id_private, id);
3854 switch (qp_attr->qp_state) {
3856 ret = cm_init_qp_init_attr(cm_id_priv, qp_attr, qp_attr_mask);
3859 ret = cm_init_qp_rtr_attr(cm_id_priv, qp_attr, qp_attr_mask);
3862 ret = cm_init_qp_rts_attr(cm_id_priv, qp_attr, qp_attr_mask);
3870 EXPORT_SYMBOL(ib_cm_init_qp_attr);
3872 static ssize_t cm_show_counter(struct kobject *obj, struct attribute *attr,
3875 struct cm_counter_group *group;
3876 struct cm_counter_attribute *cm_attr;
3878 group = container_of(obj, struct cm_counter_group, obj);
3879 cm_attr = container_of(attr, struct cm_counter_attribute, attr);
3881 return sprintf(buf, "%ld\n",
3882 atomic_long_read(&group->counter[cm_attr->index]));
3885 static const struct sysfs_ops cm_counter_ops = {
3886 .show = cm_show_counter
3889 static struct kobj_type cm_counter_obj_type = {
3890 .sysfs_ops = &cm_counter_ops,
3891 .default_attrs = cm_counter_default_attrs
3894 static void cm_release_port_obj(struct kobject *obj)
3896 struct cm_port *cm_port;
3898 cm_port = container_of(obj, struct cm_port, port_obj);
3902 static struct kobj_type cm_port_obj_type = {
3903 .release = cm_release_port_obj
3906 static char *cm_devnode(struct device *dev, umode_t *mode)
3910 return kasprintf(GFP_KERNEL, "infiniband/%s", dev_name(dev));
3913 struct class cm_class = {
3914 .owner = THIS_MODULE,
3915 .name = "infiniband_cm",
3916 .devnode = cm_devnode,
3918 EXPORT_SYMBOL(cm_class);
3920 static int cm_create_port_fs(struct cm_port *port)
3924 ret = kobject_init_and_add(&port->port_obj, &cm_port_obj_type,
3925 &port->cm_dev->device->kobj,
3926 "%d", port->port_num);
3932 for (i = 0; i < CM_COUNTER_GROUPS; i++) {
3933 ret = kobject_init_and_add(&port->counter_group[i].obj,
3934 &cm_counter_obj_type,
3936 "%s", counter_group_names[i]);
3945 kobject_put(&port->counter_group[i].obj);
3946 kobject_put(&port->port_obj);
3951 static void cm_remove_port_fs(struct cm_port *port)
3955 for (i = 0; i < CM_COUNTER_GROUPS; i++)
3956 kobject_put(&port->counter_group[i].obj);
3958 kobject_put(&port->port_obj);
3961 static void cm_add_one(struct ib_device *ib_device)
3963 struct cm_device *cm_dev;
3964 struct cm_port *port;
3965 struct ib_mad_reg_req reg_req = {
3966 .mgmt_class = IB_MGMT_CLASS_CM,
3967 .mgmt_class_version = IB_CM_CLASS_VERSION,
3969 struct ib_port_modify port_modify = {
3970 .set_port_cap_mask = IB_PORT_CM_SUP
3972 unsigned long flags;
3977 cm_dev = kzalloc(sizeof(*cm_dev) + sizeof(*port) *
3978 ib_device->phys_port_cnt, GFP_KERNEL);
3982 cm_dev->ib_device = ib_device;
3983 cm_dev->ack_delay = ib_device->attrs.local_ca_ack_delay;
3984 cm_dev->going_down = 0;
3985 cm_dev->device = device_create(&cm_class, &ib_device->dev,
3987 "%s", ib_device->name);
3988 if (IS_ERR(cm_dev->device)) {
3993 set_bit(IB_MGMT_METHOD_SEND, reg_req.method_mask);
3994 for (i = 1; i <= ib_device->phys_port_cnt; i++) {
3995 if (!rdma_cap_ib_cm(ib_device, i))
3998 port = kzalloc(sizeof *port, GFP_KERNEL);
4002 cm_dev->port[i-1] = port;
4003 port->cm_dev = cm_dev;
4006 INIT_LIST_HEAD(&port->cm_priv_prim_list);
4007 INIT_LIST_HEAD(&port->cm_priv_altr_list);
4009 ret = cm_create_port_fs(port);
4013 port->mad_agent = ib_register_mad_agent(ib_device, i,
4021 if (IS_ERR(port->mad_agent))
4024 ret = ib_modify_port(ib_device, i, 0, &port_modify);
4034 ib_set_client_data(ib_device, &cm_client, cm_dev);
4036 write_lock_irqsave(&cm.device_lock, flags);
4037 list_add_tail(&cm_dev->list, &cm.device_list);
4038 write_unlock_irqrestore(&cm.device_lock, flags);
4042 ib_unregister_mad_agent(port->mad_agent);
4044 cm_remove_port_fs(port);
4046 port_modify.set_port_cap_mask = 0;
4047 port_modify.clr_port_cap_mask = IB_PORT_CM_SUP;
4049 if (!rdma_cap_ib_cm(ib_device, i))
4052 port = cm_dev->port[i-1];
4053 ib_modify_port(ib_device, port->port_num, 0, &port_modify);
4054 ib_unregister_mad_agent(port->mad_agent);
4055 cm_remove_port_fs(port);
4058 device_unregister(cm_dev->device);
4062 static void cm_remove_one(struct ib_device *ib_device, void *client_data)
4064 struct cm_device *cm_dev = client_data;
4065 struct cm_port *port;
4066 struct cm_id_private *cm_id_priv;
4067 struct ib_mad_agent *cur_mad_agent;
4068 struct ib_port_modify port_modify = {
4069 .clr_port_cap_mask = IB_PORT_CM_SUP
4071 unsigned long flags;
4077 write_lock_irqsave(&cm.device_lock, flags);
4078 list_del(&cm_dev->list);
4079 write_unlock_irqrestore(&cm.device_lock, flags);
4081 spin_lock_irq(&cm.lock);
4082 cm_dev->going_down = 1;
4083 spin_unlock_irq(&cm.lock);
4085 for (i = 1; i <= ib_device->phys_port_cnt; i++) {
4086 if (!rdma_cap_ib_cm(ib_device, i))
4089 port = cm_dev->port[i-1];
4090 ib_modify_port(ib_device, port->port_num, 0, &port_modify);
4091 /* Mark all the cm_id's as not valid */
4092 spin_lock_irq(&cm.lock);
4093 list_for_each_entry(cm_id_priv, &port->cm_priv_altr_list, altr_list)
4094 cm_id_priv->altr_send_port_not_ready = 1;
4095 list_for_each_entry(cm_id_priv, &port->cm_priv_prim_list, prim_list)
4096 cm_id_priv->prim_send_port_not_ready = 1;
4097 spin_unlock_irq(&cm.lock);
4099 * We flush the queue here after the going_down set, this
4100 * verify that no new works will be queued in the recv handler,
4101 * after that we can call the unregister_mad_agent
4103 flush_workqueue(cm.wq);
4104 spin_lock_irq(&cm.state_lock);
4105 cur_mad_agent = port->mad_agent;
4106 port->mad_agent = NULL;
4107 spin_unlock_irq(&cm.state_lock);
4108 ib_unregister_mad_agent(cur_mad_agent);
4109 cm_remove_port_fs(port);
4112 device_unregister(cm_dev->device);
4116 static int __init ib_cm_init(void)
4120 memset(&cm, 0, sizeof cm);
4121 INIT_LIST_HEAD(&cm.device_list);
4122 rwlock_init(&cm.device_lock);
4123 spin_lock_init(&cm.lock);
4124 spin_lock_init(&cm.state_lock);
4125 cm.listen_service_table = RB_ROOT;
4126 cm.listen_service_id = be64_to_cpu(IB_CM_ASSIGN_SERVICE_ID);
4127 cm.remote_id_table = RB_ROOT;
4128 cm.remote_qp_table = RB_ROOT;
4129 cm.remote_sidr_table = RB_ROOT;
4130 idr_init(&cm.local_id_table);
4131 get_random_bytes(&cm.random_id_operand, sizeof cm.random_id_operand);
4132 INIT_LIST_HEAD(&cm.timewait_list);
4134 ret = class_register(&cm_class);
4140 cm.wq = create_workqueue("ib_cm");
4146 ret = ib_register_client(&cm_client);
4152 destroy_workqueue(cm.wq);
4154 class_unregister(&cm_class);
4156 idr_destroy(&cm.local_id_table);
4160 static void __exit ib_cm_cleanup(void)
4162 struct cm_timewait_info *timewait_info, *tmp;
4164 spin_lock_irq(&cm.lock);
4165 list_for_each_entry(timewait_info, &cm.timewait_list, list)
4166 cancel_delayed_work(&timewait_info->work.work);
4167 spin_unlock_irq(&cm.lock);
4169 ib_unregister_client(&cm_client);
4170 destroy_workqueue(cm.wq);
4172 list_for_each_entry_safe(timewait_info, tmp, &cm.timewait_list, list) {
4173 cancel_delayed_work_sync(&timewait_info->work.work);
4174 list_del(&timewait_info->list);
4175 kfree(timewait_info);
4178 class_unregister(&cm_class);
4179 idr_destroy(&cm.local_id_table);
4182 module_init_order(ib_cm_init, SI_ORDER_SECOND);
4183 module_exit_order(ib_cm_cleanup, SI_ORDER_SECOND);