1 /*-
2 * SPDX-License-Identifier: BSD-2-Clause OR GPL-2.0
3 *
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.
8 *
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:
14 *
15 * Redistribution and use in source and binary forms, with or
16 * without modification, are permitted provided that the following
17 * conditions are met:
18 *
19 * - Redistributions of source code must retain the above
20 * copyright notice, this list of conditions and the following
21 * disclaimer.
22 *
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.
27 *
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
35 * SOFTWARE.
36 */
37
38 #include <sys/cdefs.h>
39 __FBSDID("$FreeBSD$");
40
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>
56
57 #include <asm/atomic-long.h>
58
59 #include <rdma/ib_addr.h>
60 #include <rdma/ib_cache.h>
61 #include <rdma/ib_cm.h>
62 #include "cm_msgs.h"
63 #include "core_priv.h"
64
65 MODULE_AUTHOR("Sean Hefty");
66 MODULE_DESCRIPTION("InfiniBand CM");
67 MODULE_LICENSE("Dual BSD/GPL");
68
69 static const char * const ibcm_rej_reason_strs[] = {
70 [IB_CM_REJ_NO_QP] = "no QP",
71 [IB_CM_REJ_NO_EEC] = "no EEC",
72 [IB_CM_REJ_NO_RESOURCES] = "no resources",
73 [IB_CM_REJ_TIMEOUT] = "timeout",
74 [IB_CM_REJ_UNSUPPORTED] = "unsupported",
75 [IB_CM_REJ_INVALID_COMM_ID] = "invalid comm ID",
76 [IB_CM_REJ_INVALID_COMM_INSTANCE] = "invalid comm instance",
77 [IB_CM_REJ_INVALID_SERVICE_ID] = "invalid service ID",
78 [IB_CM_REJ_INVALID_TRANSPORT_TYPE] = "invalid transport type",
79 [IB_CM_REJ_STALE_CONN] = "stale conn",
80 [IB_CM_REJ_RDC_NOT_EXIST] = "RDC not exist",
81 [IB_CM_REJ_INVALID_GID] = "invalid GID",
82 [IB_CM_REJ_INVALID_LID] = "invalid LID",
83 [IB_CM_REJ_INVALID_SL] = "invalid SL",
84 [IB_CM_REJ_INVALID_TRAFFIC_CLASS] = "invalid traffic class",
85 [IB_CM_REJ_INVALID_HOP_LIMIT] = "invalid hop limit",
86 [IB_CM_REJ_INVALID_PACKET_RATE] = "invalid packet rate",
87 [IB_CM_REJ_INVALID_ALT_GID] = "invalid alt GID",
88 [IB_CM_REJ_INVALID_ALT_LID] = "invalid alt LID",
89 [IB_CM_REJ_INVALID_ALT_SL] = "invalid alt SL",
90 [IB_CM_REJ_INVALID_ALT_TRAFFIC_CLASS] = "invalid alt traffic class",
91 [IB_CM_REJ_INVALID_ALT_HOP_LIMIT] = "invalid alt hop limit",
92 [IB_CM_REJ_INVALID_ALT_PACKET_RATE] = "invalid alt packet rate",
93 [IB_CM_REJ_PORT_CM_REDIRECT] = "port CM redirect",
94 [IB_CM_REJ_PORT_REDIRECT] = "port redirect",
95 [IB_CM_REJ_INVALID_MTU] = "invalid MTU",
96 [IB_CM_REJ_INSUFFICIENT_RESP_RESOURCES] = "insufficient resp resources",
97 [IB_CM_REJ_CONSUMER_DEFINED] = "consumer defined",
98 [IB_CM_REJ_INVALID_RNR_RETRY] = "invalid RNR retry",
99 [IB_CM_REJ_DUPLICATE_LOCAL_COMM_ID] = "duplicate local comm ID",
100 [IB_CM_REJ_INVALID_CLASS_VERSION] = "invalid class version",
101 [IB_CM_REJ_INVALID_FLOW_LABEL] = "invalid flow label",
102 [IB_CM_REJ_INVALID_ALT_FLOW_LABEL] = "invalid alt flow label",
103 };
104
ibcm_reject_msg(int reason)105 const char *__attribute_const__ ibcm_reject_msg(int reason)
106 {
107 size_t index = reason;
108
109 if (index < ARRAY_SIZE(ibcm_rej_reason_strs) &&
110 ibcm_rej_reason_strs[index])
111 return ibcm_rej_reason_strs[index];
112 else
113 return "unrecognized reason";
114 }
115 EXPORT_SYMBOL(ibcm_reject_msg);
116
117 static void cm_add_one(struct ib_device *device);
118 static void cm_remove_one(struct ib_device *device, void *client_data);
119
120 static struct ib_client cm_client = {
121 .name = "cm",
122 .add = cm_add_one,
123 .remove = cm_remove_one
124 };
125
126 static struct ib_cm {
127 spinlock_t lock;
128 struct list_head device_list;
129 rwlock_t device_lock;
130 struct rb_root listen_service_table;
131 u64 listen_service_id;
132 /* struct rb_root peer_service_table; todo: fix peer to peer */
133 struct rb_root remote_qp_table;
134 struct rb_root remote_id_table;
135 struct rb_root remote_sidr_table;
136 struct idr local_id_table;
137 __be32 random_id_operand;
138 struct list_head timewait_list;
139 struct workqueue_struct *wq;
140 /* Sync on cm change port state */
141 spinlock_t state_lock;
142 } cm;
143
144 /* Counter indexes ordered by attribute ID */
145 enum {
146 CM_REQ_COUNTER,
147 CM_MRA_COUNTER,
148 CM_REJ_COUNTER,
149 CM_REP_COUNTER,
150 CM_RTU_COUNTER,
151 CM_DREQ_COUNTER,
152 CM_DREP_COUNTER,
153 CM_SIDR_REQ_COUNTER,
154 CM_SIDR_REP_COUNTER,
155 CM_LAP_COUNTER,
156 CM_APR_COUNTER,
157 CM_ATTR_COUNT,
158 CM_ATTR_ID_OFFSET = 0x0010,
159 };
160
161 enum {
162 CM_XMIT,
163 CM_XMIT_RETRIES,
164 CM_RECV,
165 CM_RECV_DUPLICATES,
166 CM_COUNTER_GROUPS
167 };
168
169 static char const counter_group_names[CM_COUNTER_GROUPS]
170 [sizeof("cm_rx_duplicates")] = {
171 "cm_tx_msgs", "cm_tx_retries",
172 "cm_rx_msgs", "cm_rx_duplicates"
173 };
174
175 struct cm_counter_group {
176 struct kobject obj;
177 atomic_long_t counter[CM_ATTR_COUNT];
178 };
179
180 struct cm_counter_attribute {
181 struct attribute attr;
182 int index;
183 };
184
185 #define CM_COUNTER_ATTR(_name, _index) \
186 struct cm_counter_attribute cm_##_name##_counter_attr = { \
187 .attr = { .name = __stringify(_name), .mode = 0444 }, \
188 .index = _index \
189 }
190
191 static CM_COUNTER_ATTR(req, CM_REQ_COUNTER);
192 static CM_COUNTER_ATTR(mra, CM_MRA_COUNTER);
193 static CM_COUNTER_ATTR(rej, CM_REJ_COUNTER);
194 static CM_COUNTER_ATTR(rep, CM_REP_COUNTER);
195 static CM_COUNTER_ATTR(rtu, CM_RTU_COUNTER);
196 static CM_COUNTER_ATTR(dreq, CM_DREQ_COUNTER);
197 static CM_COUNTER_ATTR(drep, CM_DREP_COUNTER);
198 static CM_COUNTER_ATTR(sidr_req, CM_SIDR_REQ_COUNTER);
199 static CM_COUNTER_ATTR(sidr_rep, CM_SIDR_REP_COUNTER);
200 static CM_COUNTER_ATTR(lap, CM_LAP_COUNTER);
201 static CM_COUNTER_ATTR(apr, CM_APR_COUNTER);
202
203 static struct attribute *cm_counter_default_attrs[] = {
204 &cm_req_counter_attr.attr,
205 &cm_mra_counter_attr.attr,
206 &cm_rej_counter_attr.attr,
207 &cm_rep_counter_attr.attr,
208 &cm_rtu_counter_attr.attr,
209 &cm_dreq_counter_attr.attr,
210 &cm_drep_counter_attr.attr,
211 &cm_sidr_req_counter_attr.attr,
212 &cm_sidr_rep_counter_attr.attr,
213 &cm_lap_counter_attr.attr,
214 &cm_apr_counter_attr.attr,
215 NULL
216 };
217
218 struct cm_port {
219 struct cm_device *cm_dev;
220 struct ib_mad_agent *mad_agent;
221 struct kobject port_obj;
222 u8 port_num;
223 struct list_head cm_priv_prim_list;
224 struct list_head cm_priv_altr_list;
225 struct cm_counter_group counter_group[CM_COUNTER_GROUPS];
226 };
227
228 struct cm_device {
229 struct list_head list;
230 struct ib_device *ib_device;
231 u8 ack_delay;
232 int going_down;
233 struct cm_port *port[0];
234 };
235
236 struct cm_av {
237 struct cm_port *port;
238 union ib_gid dgid;
239 struct ib_ah_attr ah_attr;
240 u16 pkey_index;
241 u8 timeout;
242 };
243
244 struct cm_work {
245 struct delayed_work work;
246 struct list_head list;
247 struct cm_port *port;
248 struct ib_mad_recv_wc *mad_recv_wc; /* Received MADs */
249 __be32 local_id; /* Established / timewait */
250 __be32 remote_id;
251 struct ib_cm_event cm_event;
252 struct ib_sa_path_rec path[0];
253 };
254
255 struct cm_timewait_info {
256 struct cm_work work; /* Must be first. */
257 struct list_head list;
258 struct rb_node remote_qp_node;
259 struct rb_node remote_id_node;
260 __be64 remote_ca_guid;
261 __be32 remote_qpn;
262 u8 inserted_remote_qp;
263 u8 inserted_remote_id;
264 };
265
266 struct cm_id_private {
267 struct ib_cm_id id;
268
269 struct rb_node service_node;
270 struct rb_node sidr_id_node;
271 spinlock_t lock; /* Do not acquire inside cm.lock */
272 struct completion comp;
273 atomic_t refcount;
274 /* Number of clients sharing this ib_cm_id. Only valid for listeners.
275 * Protected by the cm.lock spinlock. */
276 int listen_sharecount;
277
278 struct ib_mad_send_buf *msg;
279 struct cm_timewait_info *timewait_info;
280 /* todo: use alternate port on send failure */
281 struct cm_av av;
282 struct cm_av alt_av;
283
284 void *private_data;
285 __be64 tid;
286 __be32 local_qpn;
287 __be32 remote_qpn;
288 enum ib_qp_type qp_type;
289 __be32 sq_psn;
290 __be32 rq_psn;
291 int timeout_ms;
292 enum ib_mtu path_mtu;
293 __be16 pkey;
294 u8 private_data_len;
295 u8 max_cm_retries;
296 u8 peer_to_peer;
297 u8 responder_resources;
298 u8 initiator_depth;
299 u8 retry_count;
300 u8 rnr_retry_count;
301 u8 service_timeout;
302 u8 target_ack_delay;
303
304 struct list_head prim_list;
305 struct list_head altr_list;
306 /* Indicates that the send port mad is registered and av is set */
307 int prim_send_port_not_ready;
308 int altr_send_port_not_ready;
309
310 struct list_head work_list;
311 atomic_t work_count;
312 };
313
314 static void cm_work_handler(struct work_struct *work);
315
cm_deref_id(struct cm_id_private * cm_id_priv)316 static inline void cm_deref_id(struct cm_id_private *cm_id_priv)
317 {
318 if (atomic_dec_and_test(&cm_id_priv->refcount))
319 complete(&cm_id_priv->comp);
320 }
321
cm_alloc_msg(struct cm_id_private * cm_id_priv,struct ib_mad_send_buf ** msg)322 static int cm_alloc_msg(struct cm_id_private *cm_id_priv,
323 struct ib_mad_send_buf **msg)
324 {
325 struct ib_mad_agent *mad_agent;
326 struct ib_mad_send_buf *m;
327 struct ib_ah *ah;
328 struct cm_av *av;
329 unsigned long flags, flags2;
330 int ret = 0;
331
332 /* don't let the port to be released till the agent is down */
333 spin_lock_irqsave(&cm.state_lock, flags2);
334 spin_lock_irqsave(&cm.lock, flags);
335 if (!cm_id_priv->prim_send_port_not_ready)
336 av = &cm_id_priv->av;
337 else if (!cm_id_priv->altr_send_port_not_ready &&
338 (cm_id_priv->alt_av.port))
339 av = &cm_id_priv->alt_av;
340 else {
341 pr_info("%s: not valid CM id\n", __func__);
342 ret = -ENODEV;
343 spin_unlock_irqrestore(&cm.lock, flags);
344 goto out;
345 }
346 spin_unlock_irqrestore(&cm.lock, flags);
347 /* Make sure the port haven't released the mad yet */
348 mad_agent = cm_id_priv->av.port->mad_agent;
349 if (!mad_agent) {
350 pr_info("%s: not a valid MAD agent\n", __func__);
351 ret = -ENODEV;
352 goto out;
353 }
354 ah = ib_create_ah(mad_agent->qp->pd, &av->ah_attr);
355 if (IS_ERR(ah)) {
356 ret = PTR_ERR(ah);
357 goto out;
358 }
359
360 m = ib_create_send_mad(mad_agent, cm_id_priv->id.remote_cm_qpn,
361 av->pkey_index,
362 0, IB_MGMT_MAD_HDR, IB_MGMT_MAD_DATA,
363 GFP_ATOMIC,
364 IB_MGMT_BASE_VERSION);
365 if (IS_ERR(m)) {
366 ib_destroy_ah(ah);
367 ret = PTR_ERR(m);
368 goto out;
369 }
370
371 /* Timeout set by caller if response is expected. */
372 m->ah = ah;
373 m->retries = cm_id_priv->max_cm_retries;
374
375 atomic_inc(&cm_id_priv->refcount);
376 m->context[0] = cm_id_priv;
377 *msg = m;
378
379 out:
380 spin_unlock_irqrestore(&cm.state_lock, flags2);
381 return ret;
382 }
383
cm_alloc_response_msg_no_ah(struct cm_port * port,struct ib_mad_recv_wc * mad_recv_wc)384 static struct ib_mad_send_buf *cm_alloc_response_msg_no_ah(struct cm_port *port,
385 struct ib_mad_recv_wc *mad_recv_wc)
386 {
387 return ib_create_send_mad(port->mad_agent, 1, mad_recv_wc->wc->pkey_index,
388 0, IB_MGMT_MAD_HDR, IB_MGMT_MAD_DATA,
389 GFP_ATOMIC,
390 IB_MGMT_BASE_VERSION);
391 }
392
cm_create_response_msg_ah(struct cm_port * port,struct ib_mad_recv_wc * mad_recv_wc,struct ib_mad_send_buf * msg)393 static int cm_create_response_msg_ah(struct cm_port *port,
394 struct ib_mad_recv_wc *mad_recv_wc,
395 struct ib_mad_send_buf *msg)
396 {
397 struct ib_ah *ah;
398
399 ah = ib_create_ah_from_wc(port->mad_agent->qp->pd, mad_recv_wc->wc,
400 mad_recv_wc->recv_buf.grh, port->port_num);
401 if (IS_ERR(ah))
402 return PTR_ERR(ah);
403
404 msg->ah = ah;
405 return 0;
406 }
407
cm_free_msg(struct ib_mad_send_buf * msg)408 static void cm_free_msg(struct ib_mad_send_buf *msg)
409 {
410 if (msg->ah)
411 ib_destroy_ah(msg->ah);
412 if (msg->context[0])
413 cm_deref_id(msg->context[0]);
414 ib_free_send_mad(msg);
415 }
416
cm_alloc_response_msg(struct cm_port * port,struct ib_mad_recv_wc * mad_recv_wc,struct ib_mad_send_buf ** msg)417 static int cm_alloc_response_msg(struct cm_port *port,
418 struct ib_mad_recv_wc *mad_recv_wc,
419 struct ib_mad_send_buf **msg)
420 {
421 struct ib_mad_send_buf *m;
422 int ret;
423
424 m = cm_alloc_response_msg_no_ah(port, mad_recv_wc);
425 if (IS_ERR(m))
426 return PTR_ERR(m);
427
428 ret = cm_create_response_msg_ah(port, mad_recv_wc, m);
429 if (ret) {
430 cm_free_msg(m);
431 return ret;
432 }
433
434 *msg = m;
435 return 0;
436 }
437
cm_copy_private_data(const void * private_data,u8 private_data_len)438 static void * cm_copy_private_data(const void *private_data,
439 u8 private_data_len)
440 {
441 void *data;
442
443 if (!private_data || !private_data_len)
444 return NULL;
445
446 data = kmemdup(private_data, private_data_len, GFP_KERNEL);
447 if (!data)
448 return ERR_PTR(-ENOMEM);
449
450 return data;
451 }
452
cm_set_private_data(struct cm_id_private * cm_id_priv,void * private_data,u8 private_data_len)453 static void cm_set_private_data(struct cm_id_private *cm_id_priv,
454 void *private_data, u8 private_data_len)
455 {
456 if (cm_id_priv->private_data && cm_id_priv->private_data_len)
457 kfree(cm_id_priv->private_data);
458
459 cm_id_priv->private_data = private_data;
460 cm_id_priv->private_data_len = private_data_len;
461 }
462
cm_init_av_for_lap(struct cm_port * port,struct ib_wc * wc,struct ib_grh * grh,struct cm_av * av)463 static int cm_init_av_for_lap(struct cm_port *port, struct ib_wc *wc,
464 struct ib_grh *grh, struct cm_av *av)
465 {
466 struct ib_ah_attr new_ah_attr;
467 int ret;
468
469 av->port = port;
470 av->pkey_index = wc->pkey_index;
471
472 /*
473 * av->ah_attr might be initialized based on past wc during incoming
474 * connect request or while sending out connect request. So initialize
475 * a new ah_attr on stack. If initialization fails, old ah_attr is
476 * used for sending any responses. If initialization is successful,
477 * than new ah_attr is used by overwriting old one.
478 */
479 ret = ib_init_ah_from_wc(port->cm_dev->ib_device,
480 port->port_num, wc,
481 grh, &new_ah_attr);
482 if (ret)
483 return ret;
484
485 memcpy(&av->ah_attr, &new_ah_attr, sizeof(new_ah_attr));
486 return 0;
487 }
488
cm_init_av_for_response(struct cm_port * port,struct ib_wc * wc,struct ib_grh * grh,struct cm_av * av)489 static int cm_init_av_for_response(struct cm_port *port, struct ib_wc *wc,
490 struct ib_grh *grh, struct cm_av *av)
491 {
492 av->port = port;
493 av->pkey_index = wc->pkey_index;
494 return ib_init_ah_from_wc(port->cm_dev->ib_device, port->port_num, wc,
495 grh, &av->ah_attr);
496 }
497
cm_init_av_by_path(struct ib_sa_path_rec * path,struct cm_av * av,struct cm_id_private * cm_id_priv)498 static int cm_init_av_by_path(struct ib_sa_path_rec *path, struct cm_av *av,
499 struct cm_id_private *cm_id_priv)
500 {
501 struct cm_device *cm_dev;
502 struct cm_port *port = NULL;
503 unsigned long flags;
504 int ret;
505 u8 p;
506 struct ifnet *ndev = ib_get_ndev_from_path(path);
507
508 read_lock_irqsave(&cm.device_lock, flags);
509 list_for_each_entry(cm_dev, &cm.device_list, list) {
510 if (!ib_find_cached_gid(cm_dev->ib_device, &path->sgid,
511 path->gid_type, ndev, &p, NULL)) {
512 port = cm_dev->port[p-1];
513 break;
514 }
515 }
516 read_unlock_irqrestore(&cm.device_lock, flags);
517
518 if (ndev)
519 dev_put(ndev);
520
521 if (!port)
522 return -EINVAL;
523
524 ret = ib_find_cached_pkey(cm_dev->ib_device, port->port_num,
525 be16_to_cpu(path->pkey), &av->pkey_index);
526 if (ret)
527 return ret;
528
529 av->port = port;
530 ret = ib_init_ah_from_path(cm_dev->ib_device, port->port_num,
531 path, &av->ah_attr);
532 if (ret)
533 return ret;
534
535 av->timeout = path->packet_life_time + 1;
536
537 spin_lock_irqsave(&cm.lock, flags);
538 if (&cm_id_priv->av == av)
539 list_add_tail(&cm_id_priv->prim_list, &port->cm_priv_prim_list);
540 else if (&cm_id_priv->alt_av == av)
541 list_add_tail(&cm_id_priv->altr_list, &port->cm_priv_altr_list);
542 else
543 ret = -EINVAL;
544
545 spin_unlock_irqrestore(&cm.lock, flags);
546
547 return ret;
548 }
549
cm_alloc_id(struct cm_id_private * cm_id_priv)550 static int cm_alloc_id(struct cm_id_private *cm_id_priv)
551 {
552 unsigned long flags;
553 int id;
554
555 idr_preload(GFP_KERNEL);
556 spin_lock_irqsave(&cm.lock, flags);
557
558 id = idr_alloc_cyclic(&cm.local_id_table, cm_id_priv, 0, 0, GFP_NOWAIT);
559
560 spin_unlock_irqrestore(&cm.lock, flags);
561 idr_preload_end();
562
563 cm_id_priv->id.local_id = (__force __be32)id ^ cm.random_id_operand;
564 return id < 0 ? id : 0;
565 }
566
cm_free_id(__be32 local_id)567 static void cm_free_id(__be32 local_id)
568 {
569 spin_lock_irq(&cm.lock);
570 idr_remove(&cm.local_id_table,
571 (__force int) (local_id ^ cm.random_id_operand));
572 spin_unlock_irq(&cm.lock);
573 }
574
cm_get_id(__be32 local_id,__be32 remote_id)575 static struct cm_id_private * cm_get_id(__be32 local_id, __be32 remote_id)
576 {
577 struct cm_id_private *cm_id_priv;
578
579 cm_id_priv = idr_find(&cm.local_id_table,
580 (__force int) (local_id ^ cm.random_id_operand));
581 if (cm_id_priv) {
582 if (cm_id_priv->id.remote_id == remote_id)
583 atomic_inc(&cm_id_priv->refcount);
584 else
585 cm_id_priv = NULL;
586 }
587
588 return cm_id_priv;
589 }
590
cm_acquire_id(__be32 local_id,__be32 remote_id)591 static struct cm_id_private * cm_acquire_id(__be32 local_id, __be32 remote_id)
592 {
593 struct cm_id_private *cm_id_priv;
594
595 spin_lock_irq(&cm.lock);
596 cm_id_priv = cm_get_id(local_id, remote_id);
597 spin_unlock_irq(&cm.lock);
598
599 return cm_id_priv;
600 }
601
602 /*
603 * Trivial helpers to strip endian annotation and compare; the
604 * endianness doesn't actually matter since we just need a stable
605 * order for the RB tree.
606 */
be32_lt(__be32 a,__be32 b)607 static int be32_lt(__be32 a, __be32 b)
608 {
609 return (__force u32) a < (__force u32) b;
610 }
611
be32_gt(__be32 a,__be32 b)612 static int be32_gt(__be32 a, __be32 b)
613 {
614 return (__force u32) a > (__force u32) b;
615 }
616
be64_lt(__be64 a,__be64 b)617 static int be64_lt(__be64 a, __be64 b)
618 {
619 return (__force u64) a < (__force u64) b;
620 }
621
be64_gt(__be64 a,__be64 b)622 static int be64_gt(__be64 a, __be64 b)
623 {
624 return (__force u64) a > (__force u64) b;
625 }
626
cm_insert_listen(struct cm_id_private * cm_id_priv)627 static struct cm_id_private * cm_insert_listen(struct cm_id_private *cm_id_priv)
628 {
629 struct rb_node **link = &cm.listen_service_table.rb_node;
630 struct rb_node *parent = NULL;
631 struct cm_id_private *cur_cm_id_priv;
632 __be64 service_id = cm_id_priv->id.service_id;
633 __be64 service_mask = cm_id_priv->id.service_mask;
634
635 while (*link) {
636 parent = *link;
637 cur_cm_id_priv = rb_entry(parent, struct cm_id_private,
638 service_node);
639 if ((cur_cm_id_priv->id.service_mask & service_id) ==
640 (service_mask & cur_cm_id_priv->id.service_id) &&
641 (cm_id_priv->id.device == cur_cm_id_priv->id.device))
642 return cur_cm_id_priv;
643
644 if (cm_id_priv->id.device < cur_cm_id_priv->id.device)
645 link = &(*link)->rb_left;
646 else if (cm_id_priv->id.device > cur_cm_id_priv->id.device)
647 link = &(*link)->rb_right;
648 else if (be64_lt(service_id, cur_cm_id_priv->id.service_id))
649 link = &(*link)->rb_left;
650 else if (be64_gt(service_id, cur_cm_id_priv->id.service_id))
651 link = &(*link)->rb_right;
652 else
653 link = &(*link)->rb_right;
654 }
655 rb_link_node(&cm_id_priv->service_node, parent, link);
656 rb_insert_color(&cm_id_priv->service_node, &cm.listen_service_table);
657 return NULL;
658 }
659
cm_find_listen(struct ib_device * device,__be64 service_id)660 static struct cm_id_private * cm_find_listen(struct ib_device *device,
661 __be64 service_id)
662 {
663 struct rb_node *node = cm.listen_service_table.rb_node;
664 struct cm_id_private *cm_id_priv;
665
666 while (node) {
667 cm_id_priv = rb_entry(node, struct cm_id_private, service_node);
668 if ((cm_id_priv->id.service_mask & service_id) ==
669 cm_id_priv->id.service_id &&
670 (cm_id_priv->id.device == device))
671 return cm_id_priv;
672
673 if (device < cm_id_priv->id.device)
674 node = node->rb_left;
675 else if (device > cm_id_priv->id.device)
676 node = node->rb_right;
677 else if (be64_lt(service_id, cm_id_priv->id.service_id))
678 node = node->rb_left;
679 else if (be64_gt(service_id, cm_id_priv->id.service_id))
680 node = node->rb_right;
681 else
682 node = node->rb_right;
683 }
684 return NULL;
685 }
686
cm_insert_remote_id(struct cm_timewait_info * timewait_info)687 static struct cm_timewait_info * cm_insert_remote_id(struct cm_timewait_info
688 *timewait_info)
689 {
690 struct rb_node **link = &cm.remote_id_table.rb_node;
691 struct rb_node *parent = NULL;
692 struct cm_timewait_info *cur_timewait_info;
693 __be64 remote_ca_guid = timewait_info->remote_ca_guid;
694 __be32 remote_id = timewait_info->work.remote_id;
695
696 while (*link) {
697 parent = *link;
698 cur_timewait_info = rb_entry(parent, struct cm_timewait_info,
699 remote_id_node);
700 if (be32_lt(remote_id, cur_timewait_info->work.remote_id))
701 link = &(*link)->rb_left;
702 else if (be32_gt(remote_id, cur_timewait_info->work.remote_id))
703 link = &(*link)->rb_right;
704 else if (be64_lt(remote_ca_guid, cur_timewait_info->remote_ca_guid))
705 link = &(*link)->rb_left;
706 else if (be64_gt(remote_ca_guid, cur_timewait_info->remote_ca_guid))
707 link = &(*link)->rb_right;
708 else
709 return cur_timewait_info;
710 }
711 timewait_info->inserted_remote_id = 1;
712 rb_link_node(&timewait_info->remote_id_node, parent, link);
713 rb_insert_color(&timewait_info->remote_id_node, &cm.remote_id_table);
714 return NULL;
715 }
716
cm_find_remote_id(__be64 remote_ca_guid,__be32 remote_id)717 static struct cm_timewait_info * cm_find_remote_id(__be64 remote_ca_guid,
718 __be32 remote_id)
719 {
720 struct rb_node *node = cm.remote_id_table.rb_node;
721 struct cm_timewait_info *timewait_info;
722
723 while (node) {
724 timewait_info = rb_entry(node, struct cm_timewait_info,
725 remote_id_node);
726 if (be32_lt(remote_id, timewait_info->work.remote_id))
727 node = node->rb_left;
728 else if (be32_gt(remote_id, timewait_info->work.remote_id))
729 node = node->rb_right;
730 else if (be64_lt(remote_ca_guid, timewait_info->remote_ca_guid))
731 node = node->rb_left;
732 else if (be64_gt(remote_ca_guid, timewait_info->remote_ca_guid))
733 node = node->rb_right;
734 else
735 return timewait_info;
736 }
737 return NULL;
738 }
739
cm_insert_remote_qpn(struct cm_timewait_info * timewait_info)740 static struct cm_timewait_info * cm_insert_remote_qpn(struct cm_timewait_info
741 *timewait_info)
742 {
743 struct rb_node **link = &cm.remote_qp_table.rb_node;
744 struct rb_node *parent = NULL;
745 struct cm_timewait_info *cur_timewait_info;
746 __be64 remote_ca_guid = timewait_info->remote_ca_guid;
747 __be32 remote_qpn = timewait_info->remote_qpn;
748
749 while (*link) {
750 parent = *link;
751 cur_timewait_info = rb_entry(parent, struct cm_timewait_info,
752 remote_qp_node);
753 if (be32_lt(remote_qpn, cur_timewait_info->remote_qpn))
754 link = &(*link)->rb_left;
755 else if (be32_gt(remote_qpn, cur_timewait_info->remote_qpn))
756 link = &(*link)->rb_right;
757 else if (be64_lt(remote_ca_guid, cur_timewait_info->remote_ca_guid))
758 link = &(*link)->rb_left;
759 else if (be64_gt(remote_ca_guid, cur_timewait_info->remote_ca_guid))
760 link = &(*link)->rb_right;
761 else
762 return cur_timewait_info;
763 }
764 timewait_info->inserted_remote_qp = 1;
765 rb_link_node(&timewait_info->remote_qp_node, parent, link);
766 rb_insert_color(&timewait_info->remote_qp_node, &cm.remote_qp_table);
767 return NULL;
768 }
769
cm_insert_remote_sidr(struct cm_id_private * cm_id_priv)770 static struct cm_id_private * cm_insert_remote_sidr(struct cm_id_private
771 *cm_id_priv)
772 {
773 struct rb_node **link = &cm.remote_sidr_table.rb_node;
774 struct rb_node *parent = NULL;
775 struct cm_id_private *cur_cm_id_priv;
776 union ib_gid *port_gid = &cm_id_priv->av.dgid;
777 __be32 remote_id = cm_id_priv->id.remote_id;
778
779 while (*link) {
780 parent = *link;
781 cur_cm_id_priv = rb_entry(parent, struct cm_id_private,
782 sidr_id_node);
783 if (be32_lt(remote_id, cur_cm_id_priv->id.remote_id))
784 link = &(*link)->rb_left;
785 else if (be32_gt(remote_id, cur_cm_id_priv->id.remote_id))
786 link = &(*link)->rb_right;
787 else {
788 int cmp;
789 cmp = memcmp(port_gid, &cur_cm_id_priv->av.dgid,
790 sizeof *port_gid);
791 if (cmp < 0)
792 link = &(*link)->rb_left;
793 else if (cmp > 0)
794 link = &(*link)->rb_right;
795 else
796 return cur_cm_id_priv;
797 }
798 }
799 rb_link_node(&cm_id_priv->sidr_id_node, parent, link);
800 rb_insert_color(&cm_id_priv->sidr_id_node, &cm.remote_sidr_table);
801 return NULL;
802 }
803
cm_reject_sidr_req(struct cm_id_private * cm_id_priv,enum ib_cm_sidr_status status)804 static void cm_reject_sidr_req(struct cm_id_private *cm_id_priv,
805 enum ib_cm_sidr_status status)
806 {
807 struct ib_cm_sidr_rep_param param;
808
809 memset(¶m, 0, sizeof param);
810 param.status = status;
811 ib_send_cm_sidr_rep(&cm_id_priv->id, ¶m);
812 }
813
ib_create_cm_id(struct ib_device * device,ib_cm_handler cm_handler,void * context)814 struct ib_cm_id *ib_create_cm_id(struct ib_device *device,
815 ib_cm_handler cm_handler,
816 void *context)
817 {
818 struct cm_id_private *cm_id_priv;
819 int ret;
820
821 cm_id_priv = kzalloc(sizeof *cm_id_priv, GFP_KERNEL);
822 if (!cm_id_priv)
823 return ERR_PTR(-ENOMEM);
824
825 cm_id_priv->id.state = IB_CM_IDLE;
826 cm_id_priv->id.device = device;
827 cm_id_priv->id.cm_handler = cm_handler;
828 cm_id_priv->id.context = context;
829 cm_id_priv->id.remote_cm_qpn = 1;
830 ret = cm_alloc_id(cm_id_priv);
831 if (ret)
832 goto error;
833
834 spin_lock_init(&cm_id_priv->lock);
835 init_completion(&cm_id_priv->comp);
836 INIT_LIST_HEAD(&cm_id_priv->work_list);
837 INIT_LIST_HEAD(&cm_id_priv->prim_list);
838 INIT_LIST_HEAD(&cm_id_priv->altr_list);
839 atomic_set(&cm_id_priv->work_count, -1);
840 atomic_set(&cm_id_priv->refcount, 1);
841 return &cm_id_priv->id;
842
843 error:
844 kfree(cm_id_priv);
845 return ERR_PTR(-ENOMEM);
846 }
847 EXPORT_SYMBOL(ib_create_cm_id);
848
cm_dequeue_work(struct cm_id_private * cm_id_priv)849 static struct cm_work * cm_dequeue_work(struct cm_id_private *cm_id_priv)
850 {
851 struct cm_work *work;
852
853 if (list_empty(&cm_id_priv->work_list))
854 return NULL;
855
856 work = list_entry(cm_id_priv->work_list.next, struct cm_work, list);
857 list_del(&work->list);
858 return work;
859 }
860
cm_free_work(struct cm_work * work)861 static void cm_free_work(struct cm_work *work)
862 {
863 if (work->mad_recv_wc)
864 ib_free_recv_mad(work->mad_recv_wc);
865 kfree(work);
866 }
867
cm_convert_to_ms(int iba_time)868 static inline int cm_convert_to_ms(int iba_time)
869 {
870 /* approximate conversion to ms from 4.096us x 2^iba_time */
871 return 1 << max(iba_time - 8, 0);
872 }
873
874 /*
875 * calculate: 4.096x2^ack_timeout = 4.096x2^ack_delay + 2x4.096x2^life_time
876 * Because of how ack_timeout is stored, adding one doubles the timeout.
877 * To avoid large timeouts, select the max(ack_delay, life_time + 1), and
878 * increment it (round up) only if the other is within 50%.
879 */
cm_ack_timeout(u8 ca_ack_delay,u8 packet_life_time)880 static u8 cm_ack_timeout(u8 ca_ack_delay, u8 packet_life_time)
881 {
882 int ack_timeout = packet_life_time + 1;
883
884 if (ack_timeout >= ca_ack_delay)
885 ack_timeout += (ca_ack_delay >= (ack_timeout - 1));
886 else
887 ack_timeout = ca_ack_delay +
888 (ack_timeout >= (ca_ack_delay - 1));
889
890 return min(31, ack_timeout);
891 }
892
cm_cleanup_timewait(struct cm_timewait_info * timewait_info)893 static void cm_cleanup_timewait(struct cm_timewait_info *timewait_info)
894 {
895 if (timewait_info->inserted_remote_id) {
896 rb_erase(&timewait_info->remote_id_node, &cm.remote_id_table);
897 timewait_info->inserted_remote_id = 0;
898 }
899
900 if (timewait_info->inserted_remote_qp) {
901 rb_erase(&timewait_info->remote_qp_node, &cm.remote_qp_table);
902 timewait_info->inserted_remote_qp = 0;
903 }
904 }
905
cm_create_timewait_info(__be32 local_id)906 static struct cm_timewait_info * cm_create_timewait_info(__be32 local_id)
907 {
908 struct cm_timewait_info *timewait_info;
909
910 timewait_info = kzalloc(sizeof *timewait_info, GFP_KERNEL);
911 if (!timewait_info)
912 return ERR_PTR(-ENOMEM);
913
914 timewait_info->work.local_id = local_id;
915 INIT_DELAYED_WORK(&timewait_info->work.work, cm_work_handler);
916 timewait_info->work.cm_event.event = IB_CM_TIMEWAIT_EXIT;
917 return timewait_info;
918 }
919
cm_enter_timewait(struct cm_id_private * cm_id_priv)920 static void cm_enter_timewait(struct cm_id_private *cm_id_priv)
921 {
922 int wait_time;
923 unsigned long flags;
924 struct cm_device *cm_dev;
925
926 cm_dev = ib_get_client_data(cm_id_priv->id.device, &cm_client);
927 if (!cm_dev)
928 return;
929
930 spin_lock_irqsave(&cm.lock, flags);
931 cm_cleanup_timewait(cm_id_priv->timewait_info);
932 list_add_tail(&cm_id_priv->timewait_info->list, &cm.timewait_list);
933 spin_unlock_irqrestore(&cm.lock, flags);
934
935 /*
936 * The cm_id could be destroyed by the user before we exit timewait.
937 * To protect against this, we search for the cm_id after exiting
938 * timewait before notifying the user that we've exited timewait.
939 */
940 cm_id_priv->id.state = IB_CM_TIMEWAIT;
941 wait_time = cm_convert_to_ms(cm_id_priv->av.timeout);
942
943 /* Check if the device started its remove_one */
944 spin_lock_irqsave(&cm.lock, flags);
945 if (!cm_dev->going_down)
946 queue_delayed_work(cm.wq, &cm_id_priv->timewait_info->work.work,
947 msecs_to_jiffies(wait_time));
948 spin_unlock_irqrestore(&cm.lock, flags);
949
950 cm_id_priv->timewait_info = NULL;
951 }
952
cm_reset_to_idle(struct cm_id_private * cm_id_priv)953 static void cm_reset_to_idle(struct cm_id_private *cm_id_priv)
954 {
955 unsigned long flags;
956
957 cm_id_priv->id.state = IB_CM_IDLE;
958 if (cm_id_priv->timewait_info) {
959 spin_lock_irqsave(&cm.lock, flags);
960 cm_cleanup_timewait(cm_id_priv->timewait_info);
961 spin_unlock_irqrestore(&cm.lock, flags);
962 kfree(cm_id_priv->timewait_info);
963 cm_id_priv->timewait_info = NULL;
964 }
965 }
966
cm_destroy_id(struct ib_cm_id * cm_id,int err)967 static void cm_destroy_id(struct ib_cm_id *cm_id, int err)
968 {
969 struct cm_id_private *cm_id_priv;
970 struct cm_work *work;
971
972 cm_id_priv = container_of(cm_id, struct cm_id_private, id);
973 retest:
974 spin_lock_irq(&cm_id_priv->lock);
975 switch (cm_id->state) {
976 case IB_CM_LISTEN:
977 spin_unlock_irq(&cm_id_priv->lock);
978
979 spin_lock_irq(&cm.lock);
980 if (--cm_id_priv->listen_sharecount > 0) {
981 /* The id is still shared. */
982 cm_deref_id(cm_id_priv);
983 spin_unlock_irq(&cm.lock);
984 return;
985 }
986 rb_erase(&cm_id_priv->service_node, &cm.listen_service_table);
987 spin_unlock_irq(&cm.lock);
988 break;
989 case IB_CM_SIDR_REQ_SENT:
990 cm_id->state = IB_CM_IDLE;
991 ib_cancel_mad(cm_id_priv->av.port->mad_agent, cm_id_priv->msg);
992 spin_unlock_irq(&cm_id_priv->lock);
993 break;
994 case IB_CM_SIDR_REQ_RCVD:
995 spin_unlock_irq(&cm_id_priv->lock);
996 cm_reject_sidr_req(cm_id_priv, IB_SIDR_REJECT);
997 spin_lock_irq(&cm.lock);
998 if (!RB_EMPTY_NODE(&cm_id_priv->sidr_id_node))
999 rb_erase(&cm_id_priv->sidr_id_node,
1000 &cm.remote_sidr_table);
1001 spin_unlock_irq(&cm.lock);
1002 break;
1003 case IB_CM_REQ_SENT:
1004 case IB_CM_MRA_REQ_RCVD:
1005 ib_cancel_mad(cm_id_priv->av.port->mad_agent, cm_id_priv->msg);
1006 spin_unlock_irq(&cm_id_priv->lock);
1007 ib_send_cm_rej(cm_id, IB_CM_REJ_TIMEOUT,
1008 &cm_id_priv->id.device->node_guid,
1009 sizeof cm_id_priv->id.device->node_guid,
1010 NULL, 0);
1011 break;
1012 case IB_CM_REQ_RCVD:
1013 if (err == -ENOMEM) {
1014 /* Do not reject to allow future retries. */
1015 cm_reset_to_idle(cm_id_priv);
1016 spin_unlock_irq(&cm_id_priv->lock);
1017 } else {
1018 spin_unlock_irq(&cm_id_priv->lock);
1019 ib_send_cm_rej(cm_id, IB_CM_REJ_CONSUMER_DEFINED,
1020 NULL, 0, NULL, 0);
1021 }
1022 break;
1023 case IB_CM_REP_SENT:
1024 case IB_CM_MRA_REP_RCVD:
1025 ib_cancel_mad(cm_id_priv->av.port->mad_agent, cm_id_priv->msg);
1026 /* Fall through */
1027 case IB_CM_MRA_REQ_SENT:
1028 case IB_CM_REP_RCVD:
1029 case IB_CM_MRA_REP_SENT:
1030 spin_unlock_irq(&cm_id_priv->lock);
1031 ib_send_cm_rej(cm_id, IB_CM_REJ_CONSUMER_DEFINED,
1032 NULL, 0, NULL, 0);
1033 break;
1034 case IB_CM_ESTABLISHED:
1035 spin_unlock_irq(&cm_id_priv->lock);
1036 if (cm_id_priv->qp_type == IB_QPT_XRC_TGT)
1037 break;
1038 ib_send_cm_dreq(cm_id, NULL, 0);
1039 goto retest;
1040 case IB_CM_DREQ_SENT:
1041 ib_cancel_mad(cm_id_priv->av.port->mad_agent, cm_id_priv->msg);
1042 cm_enter_timewait(cm_id_priv);
1043 spin_unlock_irq(&cm_id_priv->lock);
1044 break;
1045 case IB_CM_DREQ_RCVD:
1046 spin_unlock_irq(&cm_id_priv->lock);
1047 ib_send_cm_drep(cm_id, NULL, 0);
1048 break;
1049 default:
1050 spin_unlock_irq(&cm_id_priv->lock);
1051 break;
1052 }
1053
1054 spin_lock_irq(&cm.lock);
1055 if (!list_empty(&cm_id_priv->altr_list) &&
1056 (!cm_id_priv->altr_send_port_not_ready))
1057 list_del(&cm_id_priv->altr_list);
1058 if (!list_empty(&cm_id_priv->prim_list) &&
1059 (!cm_id_priv->prim_send_port_not_ready))
1060 list_del(&cm_id_priv->prim_list);
1061 spin_unlock_irq(&cm.lock);
1062
1063 cm_free_id(cm_id->local_id);
1064 cm_deref_id(cm_id_priv);
1065 wait_for_completion(&cm_id_priv->comp);
1066 while ((work = cm_dequeue_work(cm_id_priv)) != NULL)
1067 cm_free_work(work);
1068 kfree(cm_id_priv->private_data);
1069 kfree(cm_id_priv);
1070 }
1071
ib_destroy_cm_id(struct ib_cm_id * cm_id)1072 void ib_destroy_cm_id(struct ib_cm_id *cm_id)
1073 {
1074 cm_destroy_id(cm_id, 0);
1075 }
1076 EXPORT_SYMBOL(ib_destroy_cm_id);
1077
1078 /**
1079 * __ib_cm_listen - Initiates listening on the specified service ID for
1080 * connection and service ID resolution requests.
1081 * @cm_id: Connection identifier associated with the listen request.
1082 * @service_id: Service identifier matched against incoming connection
1083 * and service ID resolution requests. The service ID should be specified
1084 * network-byte order. If set to IB_CM_ASSIGN_SERVICE_ID, the CM will
1085 * assign a service ID to the caller.
1086 * @service_mask: Mask applied to service ID used to listen across a
1087 * range of service IDs. If set to 0, the service ID is matched
1088 * exactly. This parameter is ignored if %service_id is set to
1089 * IB_CM_ASSIGN_SERVICE_ID.
1090 */
__ib_cm_listen(struct ib_cm_id * cm_id,__be64 service_id,__be64 service_mask)1091 static int __ib_cm_listen(struct ib_cm_id *cm_id, __be64 service_id,
1092 __be64 service_mask)
1093 {
1094 struct cm_id_private *cm_id_priv, *cur_cm_id_priv;
1095 int ret = 0;
1096
1097 service_mask = service_mask ? service_mask : ~cpu_to_be64(0);
1098 service_id &= service_mask;
1099 if ((service_id & IB_SERVICE_ID_AGN_MASK) == IB_CM_ASSIGN_SERVICE_ID &&
1100 (service_id != IB_CM_ASSIGN_SERVICE_ID))
1101 return -EINVAL;
1102
1103 cm_id_priv = container_of(cm_id, struct cm_id_private, id);
1104 if (cm_id->state != IB_CM_IDLE)
1105 return -EINVAL;
1106
1107 cm_id->state = IB_CM_LISTEN;
1108 ++cm_id_priv->listen_sharecount;
1109
1110 if (service_id == IB_CM_ASSIGN_SERVICE_ID) {
1111 cm_id->service_id = cpu_to_be64(cm.listen_service_id++);
1112 cm_id->service_mask = ~cpu_to_be64(0);
1113 } else {
1114 cm_id->service_id = service_id;
1115 cm_id->service_mask = service_mask;
1116 }
1117 cur_cm_id_priv = cm_insert_listen(cm_id_priv);
1118
1119 if (cur_cm_id_priv) {
1120 cm_id->state = IB_CM_IDLE;
1121 --cm_id_priv->listen_sharecount;
1122 ret = -EBUSY;
1123 }
1124 return ret;
1125 }
1126
ib_cm_listen(struct ib_cm_id * cm_id,__be64 service_id,__be64 service_mask)1127 int ib_cm_listen(struct ib_cm_id *cm_id, __be64 service_id, __be64 service_mask)
1128 {
1129 unsigned long flags;
1130 int ret;
1131
1132 spin_lock_irqsave(&cm.lock, flags);
1133 ret = __ib_cm_listen(cm_id, service_id, service_mask);
1134 spin_unlock_irqrestore(&cm.lock, flags);
1135
1136 return ret;
1137 }
1138 EXPORT_SYMBOL(ib_cm_listen);
1139
1140 /**
1141 * Create a new listening ib_cm_id and listen on the given service ID.
1142 *
1143 * If there's an existing ID listening on that same device and service ID,
1144 * return it.
1145 *
1146 * @device: Device associated with the cm_id. All related communication will
1147 * be associated with the specified device.
1148 * @cm_handler: Callback invoked to notify the user of CM events.
1149 * @service_id: Service identifier matched against incoming connection
1150 * and service ID resolution requests. The service ID should be specified
1151 * network-byte order. If set to IB_CM_ASSIGN_SERVICE_ID, the CM will
1152 * assign a service ID to the caller.
1153 *
1154 * Callers should call ib_destroy_cm_id when done with the listener ID.
1155 */
ib_cm_insert_listen(struct ib_device * device,ib_cm_handler cm_handler,__be64 service_id)1156 struct ib_cm_id *ib_cm_insert_listen(struct ib_device *device,
1157 ib_cm_handler cm_handler,
1158 __be64 service_id)
1159 {
1160 struct cm_id_private *cm_id_priv;
1161 struct ib_cm_id *cm_id;
1162 unsigned long flags;
1163 int err = 0;
1164
1165 /* Create an ID in advance, since the creation may sleep */
1166 cm_id = ib_create_cm_id(device, cm_handler, NULL);
1167 if (IS_ERR(cm_id))
1168 return cm_id;
1169
1170 spin_lock_irqsave(&cm.lock, flags);
1171
1172 if (service_id == IB_CM_ASSIGN_SERVICE_ID)
1173 goto new_id;
1174
1175 /* Find an existing ID */
1176 cm_id_priv = cm_find_listen(device, service_id);
1177 if (cm_id_priv) {
1178 if (cm_id->cm_handler != cm_handler || cm_id->context) {
1179 /* Sharing an ib_cm_id with different handlers is not
1180 * supported */
1181 spin_unlock_irqrestore(&cm.lock, flags);
1182 return ERR_PTR(-EINVAL);
1183 }
1184 atomic_inc(&cm_id_priv->refcount);
1185 ++cm_id_priv->listen_sharecount;
1186 spin_unlock_irqrestore(&cm.lock, flags);
1187
1188 ib_destroy_cm_id(cm_id);
1189 cm_id = &cm_id_priv->id;
1190 return cm_id;
1191 }
1192
1193 new_id:
1194 /* Use newly created ID */
1195 err = __ib_cm_listen(cm_id, service_id, 0);
1196
1197 spin_unlock_irqrestore(&cm.lock, flags);
1198
1199 if (err) {
1200 ib_destroy_cm_id(cm_id);
1201 return ERR_PTR(err);
1202 }
1203 return cm_id;
1204 }
1205 EXPORT_SYMBOL(ib_cm_insert_listen);
1206
cm_form_tid(struct cm_id_private * cm_id_priv)1207 static __be64 cm_form_tid(struct cm_id_private *cm_id_priv)
1208 {
1209 u64 hi_tid, low_tid;
1210
1211 hi_tid = ((u64) cm_id_priv->av.port->mad_agent->hi_tid) << 32;
1212 low_tid = (u64)cm_id_priv->id.local_id;
1213 return cpu_to_be64(hi_tid | low_tid);
1214 }
1215
cm_format_mad_hdr(struct ib_mad_hdr * hdr,__be16 attr_id,__be64 tid)1216 static void cm_format_mad_hdr(struct ib_mad_hdr *hdr,
1217 __be16 attr_id, __be64 tid)
1218 {
1219 hdr->base_version = IB_MGMT_BASE_VERSION;
1220 hdr->mgmt_class = IB_MGMT_CLASS_CM;
1221 hdr->class_version = IB_CM_CLASS_VERSION;
1222 hdr->method = IB_MGMT_METHOD_SEND;
1223 hdr->attr_id = attr_id;
1224 hdr->tid = tid;
1225 }
1226
cm_format_req(struct cm_req_msg * req_msg,struct cm_id_private * cm_id_priv,struct ib_cm_req_param * param)1227 static void cm_format_req(struct cm_req_msg *req_msg,
1228 struct cm_id_private *cm_id_priv,
1229 struct ib_cm_req_param *param)
1230 {
1231 struct ib_sa_path_rec *pri_path = param->primary_path;
1232 struct ib_sa_path_rec *alt_path = param->alternate_path;
1233
1234 cm_format_mad_hdr(&req_msg->hdr, CM_REQ_ATTR_ID,
1235 cm_form_tid(cm_id_priv));
1236
1237 req_msg->local_comm_id = cm_id_priv->id.local_id;
1238 req_msg->service_id = param->service_id;
1239 req_msg->local_ca_guid = cm_id_priv->id.device->node_guid;
1240 cm_req_set_local_qpn(req_msg, cpu_to_be32(param->qp_num));
1241 cm_req_set_init_depth(req_msg, param->initiator_depth);
1242 cm_req_set_remote_resp_timeout(req_msg,
1243 param->remote_cm_response_timeout);
1244 cm_req_set_qp_type(req_msg, param->qp_type);
1245 cm_req_set_flow_ctrl(req_msg, param->flow_control);
1246 cm_req_set_starting_psn(req_msg, cpu_to_be32(param->starting_psn));
1247 cm_req_set_local_resp_timeout(req_msg,
1248 param->local_cm_response_timeout);
1249 req_msg->pkey = param->primary_path->pkey;
1250 cm_req_set_path_mtu(req_msg, param->primary_path->mtu);
1251 cm_req_set_max_cm_retries(req_msg, param->max_cm_retries);
1252
1253 if (param->qp_type != IB_QPT_XRC_INI) {
1254 cm_req_set_resp_res(req_msg, param->responder_resources);
1255 cm_req_set_retry_count(req_msg, param->retry_count);
1256 cm_req_set_rnr_retry_count(req_msg, param->rnr_retry_count);
1257 cm_req_set_srq(req_msg, param->srq);
1258 }
1259
1260 if (pri_path->hop_limit <= 1) {
1261 req_msg->primary_local_lid = pri_path->slid;
1262 req_msg->primary_remote_lid = pri_path->dlid;
1263 } else {
1264 /* Work-around until there's a way to obtain remote LID info */
1265 req_msg->primary_local_lid = IB_LID_PERMISSIVE;
1266 req_msg->primary_remote_lid = IB_LID_PERMISSIVE;
1267 }
1268 req_msg->primary_local_gid = pri_path->sgid;
1269 req_msg->primary_remote_gid = pri_path->dgid;
1270 cm_req_set_primary_flow_label(req_msg, pri_path->flow_label);
1271 cm_req_set_primary_packet_rate(req_msg, pri_path->rate);
1272 req_msg->primary_traffic_class = pri_path->traffic_class;
1273 req_msg->primary_hop_limit = pri_path->hop_limit;
1274 cm_req_set_primary_sl(req_msg, pri_path->sl);
1275 cm_req_set_primary_subnet_local(req_msg, (pri_path->hop_limit <= 1));
1276 cm_req_set_primary_local_ack_timeout(req_msg,
1277 cm_ack_timeout(cm_id_priv->av.port->cm_dev->ack_delay,
1278 pri_path->packet_life_time));
1279
1280 if (alt_path) {
1281 if (alt_path->hop_limit <= 1) {
1282 req_msg->alt_local_lid = alt_path->slid;
1283 req_msg->alt_remote_lid = alt_path->dlid;
1284 } else {
1285 req_msg->alt_local_lid = IB_LID_PERMISSIVE;
1286 req_msg->alt_remote_lid = IB_LID_PERMISSIVE;
1287 }
1288 req_msg->alt_local_gid = alt_path->sgid;
1289 req_msg->alt_remote_gid = alt_path->dgid;
1290 cm_req_set_alt_flow_label(req_msg,
1291 alt_path->flow_label);
1292 cm_req_set_alt_packet_rate(req_msg, alt_path->rate);
1293 req_msg->alt_traffic_class = alt_path->traffic_class;
1294 req_msg->alt_hop_limit = alt_path->hop_limit;
1295 cm_req_set_alt_sl(req_msg, alt_path->sl);
1296 cm_req_set_alt_subnet_local(req_msg, (alt_path->hop_limit <= 1));
1297 cm_req_set_alt_local_ack_timeout(req_msg,
1298 cm_ack_timeout(cm_id_priv->av.port->cm_dev->ack_delay,
1299 alt_path->packet_life_time));
1300 }
1301
1302 if (param->private_data && param->private_data_len)
1303 memcpy(req_msg->private_data, param->private_data,
1304 param->private_data_len);
1305 }
1306
cm_validate_req_param(struct ib_cm_req_param * param)1307 static int cm_validate_req_param(struct ib_cm_req_param *param)
1308 {
1309 /* peer-to-peer not supported */
1310 if (param->peer_to_peer)
1311 return -EINVAL;
1312
1313 if (!param->primary_path)
1314 return -EINVAL;
1315
1316 if (param->qp_type != IB_QPT_RC && param->qp_type != IB_QPT_UC &&
1317 param->qp_type != IB_QPT_XRC_INI)
1318 return -EINVAL;
1319
1320 if (param->private_data &&
1321 param->private_data_len > IB_CM_REQ_PRIVATE_DATA_SIZE)
1322 return -EINVAL;
1323
1324 if (param->alternate_path &&
1325 (param->alternate_path->pkey != param->primary_path->pkey ||
1326 param->alternate_path->mtu != param->primary_path->mtu))
1327 return -EINVAL;
1328
1329 return 0;
1330 }
1331
ib_send_cm_req(struct ib_cm_id * cm_id,struct ib_cm_req_param * param)1332 int ib_send_cm_req(struct ib_cm_id *cm_id,
1333 struct ib_cm_req_param *param)
1334 {
1335 struct cm_id_private *cm_id_priv;
1336 struct cm_req_msg *req_msg;
1337 unsigned long flags;
1338 int ret;
1339
1340 ret = cm_validate_req_param(param);
1341 if (ret)
1342 return ret;
1343
1344 /* Verify that we're not in timewait. */
1345 cm_id_priv = container_of(cm_id, struct cm_id_private, id);
1346 spin_lock_irqsave(&cm_id_priv->lock, flags);
1347 if (cm_id->state != IB_CM_IDLE) {
1348 spin_unlock_irqrestore(&cm_id_priv->lock, flags);
1349 ret = -EINVAL;
1350 goto out;
1351 }
1352 spin_unlock_irqrestore(&cm_id_priv->lock, flags);
1353
1354 cm_id_priv->timewait_info = cm_create_timewait_info(cm_id_priv->
1355 id.local_id);
1356 if (IS_ERR(cm_id_priv->timewait_info)) {
1357 ret = PTR_ERR(cm_id_priv->timewait_info);
1358 goto out;
1359 }
1360
1361 ret = cm_init_av_by_path(param->primary_path, &cm_id_priv->av,
1362 cm_id_priv);
1363 if (ret)
1364 goto error1;
1365 if (param->alternate_path) {
1366 ret = cm_init_av_by_path(param->alternate_path,
1367 &cm_id_priv->alt_av, cm_id_priv);
1368 if (ret)
1369 goto error1;
1370 }
1371 cm_id->service_id = param->service_id;
1372 cm_id->service_mask = ~cpu_to_be64(0);
1373 cm_id_priv->timeout_ms = cm_convert_to_ms(
1374 param->primary_path->packet_life_time) * 2 +
1375 cm_convert_to_ms(
1376 param->remote_cm_response_timeout);
1377 cm_id_priv->max_cm_retries = param->max_cm_retries;
1378 cm_id_priv->initiator_depth = param->initiator_depth;
1379 cm_id_priv->responder_resources = param->responder_resources;
1380 cm_id_priv->retry_count = param->retry_count;
1381 cm_id_priv->path_mtu = param->primary_path->mtu;
1382 cm_id_priv->pkey = param->primary_path->pkey;
1383 cm_id_priv->qp_type = param->qp_type;
1384
1385 ret = cm_alloc_msg(cm_id_priv, &cm_id_priv->msg);
1386 if (ret)
1387 goto error1;
1388
1389 req_msg = (struct cm_req_msg *) cm_id_priv->msg->mad;
1390 cm_format_req(req_msg, cm_id_priv, param);
1391 cm_id_priv->tid = req_msg->hdr.tid;
1392 cm_id_priv->msg->timeout_ms = cm_id_priv->timeout_ms;
1393 cm_id_priv->msg->context[1] = (void *) (unsigned long) IB_CM_REQ_SENT;
1394
1395 cm_id_priv->local_qpn = cm_req_get_local_qpn(req_msg);
1396 cm_id_priv->rq_psn = cm_req_get_starting_psn(req_msg);
1397
1398 spin_lock_irqsave(&cm_id_priv->lock, flags);
1399 ret = ib_post_send_mad(cm_id_priv->msg, NULL);
1400 if (ret) {
1401 spin_unlock_irqrestore(&cm_id_priv->lock, flags);
1402 goto error2;
1403 }
1404 BUG_ON(cm_id->state != IB_CM_IDLE);
1405 cm_id->state = IB_CM_REQ_SENT;
1406 spin_unlock_irqrestore(&cm_id_priv->lock, flags);
1407 return 0;
1408
1409 error2: cm_free_msg(cm_id_priv->msg);
1410 error1: kfree(cm_id_priv->timewait_info);
1411 out: return ret;
1412 }
1413 EXPORT_SYMBOL(ib_send_cm_req);
1414
cm_issue_rej(struct cm_port * port,struct ib_mad_recv_wc * mad_recv_wc,enum ib_cm_rej_reason reason,enum cm_msg_response msg_rejected,void * ari,u8 ari_length)1415 static int cm_issue_rej(struct cm_port *port,
1416 struct ib_mad_recv_wc *mad_recv_wc,
1417 enum ib_cm_rej_reason reason,
1418 enum cm_msg_response msg_rejected,
1419 void *ari, u8 ari_length)
1420 {
1421 struct ib_mad_send_buf *msg = NULL;
1422 struct cm_rej_msg *rej_msg, *rcv_msg;
1423 int ret;
1424
1425 ret = cm_alloc_response_msg(port, mad_recv_wc, &msg);
1426 if (ret)
1427 return ret;
1428
1429 /* We just need common CM header information. Cast to any message. */
1430 rcv_msg = (struct cm_rej_msg *) mad_recv_wc->recv_buf.mad;
1431 rej_msg = (struct cm_rej_msg *) msg->mad;
1432
1433 cm_format_mad_hdr(&rej_msg->hdr, CM_REJ_ATTR_ID, rcv_msg->hdr.tid);
1434 rej_msg->remote_comm_id = rcv_msg->local_comm_id;
1435 rej_msg->local_comm_id = rcv_msg->remote_comm_id;
1436 cm_rej_set_msg_rejected(rej_msg, msg_rejected);
1437 rej_msg->reason = cpu_to_be16(reason);
1438
1439 if (ari && ari_length) {
1440 cm_rej_set_reject_info_len(rej_msg, ari_length);
1441 memcpy(rej_msg->ari, ari, ari_length);
1442 }
1443
1444 ret = ib_post_send_mad(msg, NULL);
1445 if (ret)
1446 cm_free_msg(msg);
1447
1448 return ret;
1449 }
1450
cm_format_paths_from_req(struct cm_req_msg * req_msg,struct ib_sa_path_rec * primary_path,struct ib_sa_path_rec * alt_path)1451 static void cm_format_paths_from_req(struct cm_req_msg *req_msg,
1452 struct ib_sa_path_rec *primary_path,
1453 struct ib_sa_path_rec *alt_path)
1454 {
1455 memset(primary_path, 0, sizeof *primary_path);
1456 primary_path->dgid = req_msg->primary_local_gid;
1457 primary_path->sgid = req_msg->primary_remote_gid;
1458 primary_path->dlid = req_msg->primary_local_lid;
1459 primary_path->slid = req_msg->primary_remote_lid;
1460 primary_path->flow_label = cm_req_get_primary_flow_label(req_msg);
1461 primary_path->hop_limit = req_msg->primary_hop_limit;
1462 primary_path->traffic_class = req_msg->primary_traffic_class;
1463 primary_path->reversible = 1;
1464 primary_path->pkey = req_msg->pkey;
1465 primary_path->sl = cm_req_get_primary_sl(req_msg);
1466 primary_path->mtu_selector = IB_SA_EQ;
1467 primary_path->mtu = cm_req_get_path_mtu(req_msg);
1468 primary_path->rate_selector = IB_SA_EQ;
1469 primary_path->rate = cm_req_get_primary_packet_rate(req_msg);
1470 primary_path->packet_life_time_selector = IB_SA_EQ;
1471 primary_path->packet_life_time =
1472 cm_req_get_primary_local_ack_timeout(req_msg);
1473 primary_path->packet_life_time -= (primary_path->packet_life_time > 0);
1474 primary_path->service_id = req_msg->service_id;
1475
1476 if (req_msg->alt_local_lid) {
1477 memset(alt_path, 0, sizeof *alt_path);
1478 alt_path->dgid = req_msg->alt_local_gid;
1479 alt_path->sgid = req_msg->alt_remote_gid;
1480 alt_path->dlid = req_msg->alt_local_lid;
1481 alt_path->slid = req_msg->alt_remote_lid;
1482 alt_path->flow_label = cm_req_get_alt_flow_label(req_msg);
1483 alt_path->hop_limit = req_msg->alt_hop_limit;
1484 alt_path->traffic_class = req_msg->alt_traffic_class;
1485 alt_path->reversible = 1;
1486 alt_path->pkey = req_msg->pkey;
1487 alt_path->sl = cm_req_get_alt_sl(req_msg);
1488 alt_path->mtu_selector = IB_SA_EQ;
1489 alt_path->mtu = cm_req_get_path_mtu(req_msg);
1490 alt_path->rate_selector = IB_SA_EQ;
1491 alt_path->rate = cm_req_get_alt_packet_rate(req_msg);
1492 alt_path->packet_life_time_selector = IB_SA_EQ;
1493 alt_path->packet_life_time =
1494 cm_req_get_alt_local_ack_timeout(req_msg);
1495 alt_path->packet_life_time -= (alt_path->packet_life_time > 0);
1496 alt_path->service_id = req_msg->service_id;
1497 }
1498 }
1499
cm_get_bth_pkey(struct cm_work * work)1500 static u16 cm_get_bth_pkey(struct cm_work *work)
1501 {
1502 struct ib_device *ib_dev = work->port->cm_dev->ib_device;
1503 u8 port_num = work->port->port_num;
1504 u16 pkey_index = work->mad_recv_wc->wc->pkey_index;
1505 u16 pkey;
1506 int ret;
1507
1508 ret = ib_get_cached_pkey(ib_dev, port_num, pkey_index, &pkey);
1509 if (ret) {
1510 dev_warn_ratelimited(&ib_dev->dev, "ib_cm: Couldn't retrieve pkey for incoming request (port %d, pkey index %d). %d\n",
1511 port_num, pkey_index, ret);
1512 return 0;
1513 }
1514
1515 return pkey;
1516 }
1517
cm_format_req_event(struct cm_work * work,struct cm_id_private * cm_id_priv,struct ib_cm_id * listen_id)1518 static void cm_format_req_event(struct cm_work *work,
1519 struct cm_id_private *cm_id_priv,
1520 struct ib_cm_id *listen_id)
1521 {
1522 struct cm_req_msg *req_msg;
1523 struct ib_cm_req_event_param *param;
1524
1525 req_msg = (struct cm_req_msg *)work->mad_recv_wc->recv_buf.mad;
1526 param = &work->cm_event.param.req_rcvd;
1527 param->listen_id = listen_id;
1528 param->bth_pkey = cm_get_bth_pkey(work);
1529 param->port = cm_id_priv->av.port->port_num;
1530 param->primary_path = &work->path[0];
1531 if (req_msg->alt_local_lid)
1532 param->alternate_path = &work->path[1];
1533 else
1534 param->alternate_path = NULL;
1535 param->remote_ca_guid = req_msg->local_ca_guid;
1536 param->remote_qkey = be32_to_cpu(req_msg->local_qkey);
1537 param->remote_qpn = be32_to_cpu(cm_req_get_local_qpn(req_msg));
1538 param->qp_type = cm_req_get_qp_type(req_msg);
1539 param->starting_psn = be32_to_cpu(cm_req_get_starting_psn(req_msg));
1540 param->responder_resources = cm_req_get_init_depth(req_msg);
1541 param->initiator_depth = cm_req_get_resp_res(req_msg);
1542 param->local_cm_response_timeout =
1543 cm_req_get_remote_resp_timeout(req_msg);
1544 param->flow_control = cm_req_get_flow_ctrl(req_msg);
1545 param->remote_cm_response_timeout =
1546 cm_req_get_local_resp_timeout(req_msg);
1547 param->retry_count = cm_req_get_retry_count(req_msg);
1548 param->rnr_retry_count = cm_req_get_rnr_retry_count(req_msg);
1549 param->srq = cm_req_get_srq(req_msg);
1550 param->ppath_sgid_index = cm_id_priv->av.ah_attr.grh.sgid_index;
1551 work->cm_event.private_data = &req_msg->private_data;
1552 }
1553
cm_process_work(struct cm_id_private * cm_id_priv,struct cm_work * work)1554 static void cm_process_work(struct cm_id_private *cm_id_priv,
1555 struct cm_work *work)
1556 {
1557 int ret;
1558
1559 /* We will typically only have the current event to report. */
1560 ret = cm_id_priv->id.cm_handler(&cm_id_priv->id, &work->cm_event);
1561 cm_free_work(work);
1562
1563 while (!ret && !atomic_add_negative(-1, &cm_id_priv->work_count)) {
1564 spin_lock_irq(&cm_id_priv->lock);
1565 work = cm_dequeue_work(cm_id_priv);
1566 spin_unlock_irq(&cm_id_priv->lock);
1567 BUG_ON(!work);
1568 ret = cm_id_priv->id.cm_handler(&cm_id_priv->id,
1569 &work->cm_event);
1570 cm_free_work(work);
1571 }
1572 cm_deref_id(cm_id_priv);
1573 if (ret)
1574 cm_destroy_id(&cm_id_priv->id, ret);
1575 }
1576
cm_format_mra(struct cm_mra_msg * mra_msg,struct cm_id_private * cm_id_priv,enum cm_msg_response msg_mraed,u8 service_timeout,const void * private_data,u8 private_data_len)1577 static void cm_format_mra(struct cm_mra_msg *mra_msg,
1578 struct cm_id_private *cm_id_priv,
1579 enum cm_msg_response msg_mraed, u8 service_timeout,
1580 const void *private_data, u8 private_data_len)
1581 {
1582 cm_format_mad_hdr(&mra_msg->hdr, CM_MRA_ATTR_ID, cm_id_priv->tid);
1583 cm_mra_set_msg_mraed(mra_msg, msg_mraed);
1584 mra_msg->local_comm_id = cm_id_priv->id.local_id;
1585 mra_msg->remote_comm_id = cm_id_priv->id.remote_id;
1586 cm_mra_set_service_timeout(mra_msg, service_timeout);
1587
1588 if (private_data && private_data_len)
1589 memcpy(mra_msg->private_data, private_data, private_data_len);
1590 }
1591
cm_format_rej(struct cm_rej_msg * rej_msg,struct cm_id_private * cm_id_priv,enum ib_cm_rej_reason reason,void * ari,u8 ari_length,const void * private_data,u8 private_data_len)1592 static void cm_format_rej(struct cm_rej_msg *rej_msg,
1593 struct cm_id_private *cm_id_priv,
1594 enum ib_cm_rej_reason reason,
1595 void *ari,
1596 u8 ari_length,
1597 const void *private_data,
1598 u8 private_data_len)
1599 {
1600 cm_format_mad_hdr(&rej_msg->hdr, CM_REJ_ATTR_ID, cm_id_priv->tid);
1601 rej_msg->remote_comm_id = cm_id_priv->id.remote_id;
1602
1603 switch(cm_id_priv->id.state) {
1604 case IB_CM_REQ_RCVD:
1605 rej_msg->local_comm_id = 0;
1606 cm_rej_set_msg_rejected(rej_msg, CM_MSG_RESPONSE_REQ);
1607 break;
1608 case IB_CM_MRA_REQ_SENT:
1609 rej_msg->local_comm_id = cm_id_priv->id.local_id;
1610 cm_rej_set_msg_rejected(rej_msg, CM_MSG_RESPONSE_REQ);
1611 break;
1612 case IB_CM_REP_RCVD:
1613 case IB_CM_MRA_REP_SENT:
1614 rej_msg->local_comm_id = cm_id_priv->id.local_id;
1615 cm_rej_set_msg_rejected(rej_msg, CM_MSG_RESPONSE_REP);
1616 break;
1617 default:
1618 rej_msg->local_comm_id = cm_id_priv->id.local_id;
1619 cm_rej_set_msg_rejected(rej_msg, CM_MSG_RESPONSE_OTHER);
1620 break;
1621 }
1622
1623 rej_msg->reason = cpu_to_be16(reason);
1624 if (ari && ari_length) {
1625 cm_rej_set_reject_info_len(rej_msg, ari_length);
1626 memcpy(rej_msg->ari, ari, ari_length);
1627 }
1628
1629 if (private_data && private_data_len)
1630 memcpy(rej_msg->private_data, private_data, private_data_len);
1631 }
1632
cm_dup_req_handler(struct cm_work * work,struct cm_id_private * cm_id_priv)1633 static void cm_dup_req_handler(struct cm_work *work,
1634 struct cm_id_private *cm_id_priv)
1635 {
1636 struct ib_mad_send_buf *msg = NULL;
1637 int ret;
1638
1639 atomic_long_inc(&work->port->counter_group[CM_RECV_DUPLICATES].
1640 counter[CM_REQ_COUNTER]);
1641
1642 /* Quick state check to discard duplicate REQs. */
1643 if (cm_id_priv->id.state == IB_CM_REQ_RCVD)
1644 return;
1645
1646 ret = cm_alloc_response_msg(work->port, work->mad_recv_wc, &msg);
1647 if (ret)
1648 return;
1649
1650 spin_lock_irq(&cm_id_priv->lock);
1651 switch (cm_id_priv->id.state) {
1652 case IB_CM_MRA_REQ_SENT:
1653 cm_format_mra((struct cm_mra_msg *) msg->mad, cm_id_priv,
1654 CM_MSG_RESPONSE_REQ, cm_id_priv->service_timeout,
1655 cm_id_priv->private_data,
1656 cm_id_priv->private_data_len);
1657 break;
1658 case IB_CM_TIMEWAIT:
1659 cm_format_rej((struct cm_rej_msg *) msg->mad, cm_id_priv,
1660 IB_CM_REJ_STALE_CONN, NULL, 0, NULL, 0);
1661 break;
1662 default:
1663 goto unlock;
1664 }
1665 spin_unlock_irq(&cm_id_priv->lock);
1666
1667 ret = ib_post_send_mad(msg, NULL);
1668 if (ret)
1669 goto free;
1670 return;
1671
1672 unlock: spin_unlock_irq(&cm_id_priv->lock);
1673 free: cm_free_msg(msg);
1674 }
1675
cm_match_req(struct cm_work * work,struct cm_id_private * cm_id_priv)1676 static struct cm_id_private * cm_match_req(struct cm_work *work,
1677 struct cm_id_private *cm_id_priv)
1678 {
1679 struct cm_id_private *listen_cm_id_priv, *cur_cm_id_priv;
1680 struct cm_timewait_info *timewait_info;
1681 struct cm_req_msg *req_msg;
1682 struct ib_cm_id *cm_id;
1683
1684 req_msg = (struct cm_req_msg *)work->mad_recv_wc->recv_buf.mad;
1685
1686 /* Check for possible duplicate REQ. */
1687 spin_lock_irq(&cm.lock);
1688 timewait_info = cm_insert_remote_id(cm_id_priv->timewait_info);
1689 if (timewait_info) {
1690 cur_cm_id_priv = cm_get_id(timewait_info->work.local_id,
1691 timewait_info->work.remote_id);
1692 spin_unlock_irq(&cm.lock);
1693 if (cur_cm_id_priv) {
1694 cm_dup_req_handler(work, cur_cm_id_priv);
1695 cm_deref_id(cur_cm_id_priv);
1696 }
1697 return NULL;
1698 }
1699
1700 /* Check for stale connections. */
1701 timewait_info = cm_insert_remote_qpn(cm_id_priv->timewait_info);
1702 if (timewait_info) {
1703 cm_cleanup_timewait(cm_id_priv->timewait_info);
1704 cur_cm_id_priv = cm_get_id(timewait_info->work.local_id,
1705 timewait_info->work.remote_id);
1706
1707 spin_unlock_irq(&cm.lock);
1708 cm_issue_rej(work->port, work->mad_recv_wc,
1709 IB_CM_REJ_STALE_CONN, CM_MSG_RESPONSE_REQ,
1710 NULL, 0);
1711 if (cur_cm_id_priv) {
1712 cm_id = &cur_cm_id_priv->id;
1713 ib_send_cm_dreq(cm_id, NULL, 0);
1714 cm_deref_id(cur_cm_id_priv);
1715 }
1716 return NULL;
1717 }
1718
1719 /* Find matching listen request. */
1720 listen_cm_id_priv = cm_find_listen(cm_id_priv->id.device,
1721 req_msg->service_id);
1722 if (!listen_cm_id_priv) {
1723 cm_cleanup_timewait(cm_id_priv->timewait_info);
1724 spin_unlock_irq(&cm.lock);
1725 cm_issue_rej(work->port, work->mad_recv_wc,
1726 IB_CM_REJ_INVALID_SERVICE_ID, CM_MSG_RESPONSE_REQ,
1727 NULL, 0);
1728 goto out;
1729 }
1730 atomic_inc(&listen_cm_id_priv->refcount);
1731 atomic_inc(&cm_id_priv->refcount);
1732 cm_id_priv->id.state = IB_CM_REQ_RCVD;
1733 atomic_inc(&cm_id_priv->work_count);
1734 spin_unlock_irq(&cm.lock);
1735 out:
1736 return listen_cm_id_priv;
1737 }
1738
1739 /*
1740 * Work-around for inter-subnet connections. If the LIDs are permissive,
1741 * we need to override the LID/SL data in the REQ with the LID information
1742 * in the work completion.
1743 */
cm_process_routed_req(struct cm_req_msg * req_msg,struct ib_wc * wc)1744 static void cm_process_routed_req(struct cm_req_msg *req_msg, struct ib_wc *wc)
1745 {
1746 if (!cm_req_get_primary_subnet_local(req_msg)) {
1747 if (req_msg->primary_local_lid == IB_LID_PERMISSIVE) {
1748 req_msg->primary_local_lid = cpu_to_be16(wc->slid);
1749 cm_req_set_primary_sl(req_msg, wc->sl);
1750 }
1751
1752 if (req_msg->primary_remote_lid == IB_LID_PERMISSIVE)
1753 req_msg->primary_remote_lid = cpu_to_be16(wc->dlid_path_bits);
1754 }
1755
1756 if (!cm_req_get_alt_subnet_local(req_msg)) {
1757 if (req_msg->alt_local_lid == IB_LID_PERMISSIVE) {
1758 req_msg->alt_local_lid = cpu_to_be16(wc->slid);
1759 cm_req_set_alt_sl(req_msg, wc->sl);
1760 }
1761
1762 if (req_msg->alt_remote_lid == IB_LID_PERMISSIVE)
1763 req_msg->alt_remote_lid = cpu_to_be16(wc->dlid_path_bits);
1764 }
1765 }
1766
cm_req_handler(struct cm_work * work)1767 static int cm_req_handler(struct cm_work *work)
1768 {
1769 struct ib_cm_id *cm_id;
1770 struct cm_id_private *cm_id_priv, *listen_cm_id_priv;
1771 struct cm_req_msg *req_msg;
1772 union ib_gid gid;
1773 struct ib_gid_attr gid_attr;
1774 int ret;
1775
1776 req_msg = (struct cm_req_msg *)work->mad_recv_wc->recv_buf.mad;
1777
1778 cm_id = ib_create_cm_id(work->port->cm_dev->ib_device, NULL, NULL);
1779 if (IS_ERR(cm_id))
1780 return PTR_ERR(cm_id);
1781
1782 cm_id_priv = container_of(cm_id, struct cm_id_private, id);
1783 cm_id_priv->id.remote_id = req_msg->local_comm_id;
1784 ret = cm_init_av_for_response(work->port, work->mad_recv_wc->wc,
1785 work->mad_recv_wc->recv_buf.grh,
1786 &cm_id_priv->av);
1787 if (ret)
1788 goto destroy;
1789 cm_id_priv->timewait_info = cm_create_timewait_info(cm_id_priv->
1790 id.local_id);
1791 if (IS_ERR(cm_id_priv->timewait_info)) {
1792 ret = PTR_ERR(cm_id_priv->timewait_info);
1793 goto destroy;
1794 }
1795 cm_id_priv->timewait_info->work.remote_id = req_msg->local_comm_id;
1796 cm_id_priv->timewait_info->remote_ca_guid = req_msg->local_ca_guid;
1797 cm_id_priv->timewait_info->remote_qpn = cm_req_get_local_qpn(req_msg);
1798
1799 listen_cm_id_priv = cm_match_req(work, cm_id_priv);
1800 if (!listen_cm_id_priv) {
1801 ret = -EINVAL;
1802 goto free_timeinfo;
1803 }
1804
1805 cm_id_priv->id.cm_handler = listen_cm_id_priv->id.cm_handler;
1806 cm_id_priv->id.context = listen_cm_id_priv->id.context;
1807 cm_id_priv->id.service_id = req_msg->service_id;
1808 cm_id_priv->id.service_mask = ~cpu_to_be64(0);
1809
1810 cm_process_routed_req(req_msg, work->mad_recv_wc->wc);
1811 cm_format_paths_from_req(req_msg, &work->path[0], &work->path[1]);
1812
1813 memcpy(work->path[0].dmac, cm_id_priv->av.ah_attr.dmac, ETH_ALEN);
1814 work->path[0].hop_limit = cm_id_priv->av.ah_attr.grh.hop_limit;
1815 ret = ib_get_cached_gid(work->port->cm_dev->ib_device,
1816 work->port->port_num,
1817 cm_id_priv->av.ah_attr.grh.sgid_index,
1818 &gid, &gid_attr);
1819 if (!ret) {
1820 if (gid_attr.ndev) {
1821 work->path[0].ifindex = gid_attr.ndev->if_index;
1822 work->path[0].net = dev_net(gid_attr.ndev);
1823 dev_put(gid_attr.ndev);
1824 }
1825 work->path[0].gid_type = gid_attr.gid_type;
1826 ret = cm_init_av_by_path(&work->path[0], &cm_id_priv->av,
1827 cm_id_priv);
1828 }
1829 if (ret) {
1830 int err = ib_get_cached_gid(work->port->cm_dev->ib_device,
1831 work->port->port_num, 0,
1832 &work->path[0].sgid,
1833 &gid_attr);
1834 if (!err && gid_attr.ndev) {
1835 work->path[0].ifindex = gid_attr.ndev->if_index;
1836 work->path[0].net = dev_net(gid_attr.ndev);
1837 dev_put(gid_attr.ndev);
1838 }
1839 work->path[0].gid_type = gid_attr.gid_type;
1840 ib_send_cm_rej(cm_id, IB_CM_REJ_INVALID_GID,
1841 &work->path[0].sgid, sizeof work->path[0].sgid,
1842 NULL, 0);
1843 goto rejected;
1844 }
1845 if (req_msg->alt_local_lid) {
1846 ret = cm_init_av_by_path(&work->path[1], &cm_id_priv->alt_av,
1847 cm_id_priv);
1848 if (ret) {
1849 ib_send_cm_rej(cm_id, IB_CM_REJ_INVALID_ALT_GID,
1850 &work->path[0].sgid,
1851 sizeof work->path[0].sgid, NULL, 0);
1852 goto rejected;
1853 }
1854 }
1855 cm_id_priv->tid = req_msg->hdr.tid;
1856 cm_id_priv->timeout_ms = cm_convert_to_ms(
1857 cm_req_get_local_resp_timeout(req_msg));
1858 cm_id_priv->max_cm_retries = cm_req_get_max_cm_retries(req_msg);
1859 cm_id_priv->remote_qpn = cm_req_get_local_qpn(req_msg);
1860 cm_id_priv->initiator_depth = cm_req_get_resp_res(req_msg);
1861 cm_id_priv->responder_resources = cm_req_get_init_depth(req_msg);
1862 cm_id_priv->path_mtu = cm_req_get_path_mtu(req_msg);
1863 cm_id_priv->pkey = req_msg->pkey;
1864 cm_id_priv->sq_psn = cm_req_get_starting_psn(req_msg);
1865 cm_id_priv->retry_count = cm_req_get_retry_count(req_msg);
1866 cm_id_priv->rnr_retry_count = cm_req_get_rnr_retry_count(req_msg);
1867 cm_id_priv->qp_type = cm_req_get_qp_type(req_msg);
1868
1869 cm_format_req_event(work, cm_id_priv, &listen_cm_id_priv->id);
1870 cm_process_work(cm_id_priv, work);
1871 cm_deref_id(listen_cm_id_priv);
1872 return 0;
1873
1874 rejected:
1875 atomic_dec(&cm_id_priv->refcount);
1876 cm_deref_id(listen_cm_id_priv);
1877 free_timeinfo:
1878 kfree(cm_id_priv->timewait_info);
1879 destroy:
1880 ib_destroy_cm_id(cm_id);
1881 return ret;
1882 }
1883
cm_format_rep(struct cm_rep_msg * rep_msg,struct cm_id_private * cm_id_priv,struct ib_cm_rep_param * param)1884 static void cm_format_rep(struct cm_rep_msg *rep_msg,
1885 struct cm_id_private *cm_id_priv,
1886 struct ib_cm_rep_param *param)
1887 {
1888 cm_format_mad_hdr(&rep_msg->hdr, CM_REP_ATTR_ID, cm_id_priv->tid);
1889 rep_msg->local_comm_id = cm_id_priv->id.local_id;
1890 rep_msg->remote_comm_id = cm_id_priv->id.remote_id;
1891 cm_rep_set_starting_psn(rep_msg, cpu_to_be32(param->starting_psn));
1892 rep_msg->resp_resources = param->responder_resources;
1893 cm_rep_set_target_ack_delay(rep_msg,
1894 cm_id_priv->av.port->cm_dev->ack_delay);
1895 cm_rep_set_failover(rep_msg, param->failover_accepted);
1896 cm_rep_set_rnr_retry_count(rep_msg, param->rnr_retry_count);
1897 rep_msg->local_ca_guid = cm_id_priv->id.device->node_guid;
1898
1899 if (cm_id_priv->qp_type != IB_QPT_XRC_TGT) {
1900 rep_msg->initiator_depth = param->initiator_depth;
1901 cm_rep_set_flow_ctrl(rep_msg, param->flow_control);
1902 cm_rep_set_srq(rep_msg, param->srq);
1903 cm_rep_set_local_qpn(rep_msg, cpu_to_be32(param->qp_num));
1904 } else {
1905 cm_rep_set_srq(rep_msg, 1);
1906 cm_rep_set_local_eecn(rep_msg, cpu_to_be32(param->qp_num));
1907 }
1908
1909 if (param->private_data && param->private_data_len)
1910 memcpy(rep_msg->private_data, param->private_data,
1911 param->private_data_len);
1912 }
1913
ib_send_cm_rep(struct ib_cm_id * cm_id,struct ib_cm_rep_param * param)1914 int ib_send_cm_rep(struct ib_cm_id *cm_id,
1915 struct ib_cm_rep_param *param)
1916 {
1917 struct cm_id_private *cm_id_priv;
1918 struct ib_mad_send_buf *msg;
1919 struct cm_rep_msg *rep_msg;
1920 unsigned long flags;
1921 int ret;
1922
1923 if (param->private_data &&
1924 param->private_data_len > IB_CM_REP_PRIVATE_DATA_SIZE)
1925 return -EINVAL;
1926
1927 cm_id_priv = container_of(cm_id, struct cm_id_private, id);
1928 spin_lock_irqsave(&cm_id_priv->lock, flags);
1929 if (cm_id->state != IB_CM_REQ_RCVD &&
1930 cm_id->state != IB_CM_MRA_REQ_SENT) {
1931 ret = -EINVAL;
1932 goto out;
1933 }
1934
1935 ret = cm_alloc_msg(cm_id_priv, &msg);
1936 if (ret)
1937 goto out;
1938
1939 rep_msg = (struct cm_rep_msg *) msg->mad;
1940 cm_format_rep(rep_msg, cm_id_priv, param);
1941 msg->timeout_ms = cm_id_priv->timeout_ms;
1942 msg->context[1] = (void *) (unsigned long) IB_CM_REP_SENT;
1943
1944 ret = ib_post_send_mad(msg, NULL);
1945 if (ret) {
1946 spin_unlock_irqrestore(&cm_id_priv->lock, flags);
1947 cm_free_msg(msg);
1948 return ret;
1949 }
1950
1951 cm_id->state = IB_CM_REP_SENT;
1952 cm_id_priv->msg = msg;
1953 cm_id_priv->initiator_depth = param->initiator_depth;
1954 cm_id_priv->responder_resources = param->responder_resources;
1955 cm_id_priv->rq_psn = cm_rep_get_starting_psn(rep_msg);
1956 cm_id_priv->local_qpn = cpu_to_be32(param->qp_num & 0xFFFFFF);
1957
1958 out: spin_unlock_irqrestore(&cm_id_priv->lock, flags);
1959 return ret;
1960 }
1961 EXPORT_SYMBOL(ib_send_cm_rep);
1962
cm_format_rtu(struct cm_rtu_msg * rtu_msg,struct cm_id_private * cm_id_priv,const void * private_data,u8 private_data_len)1963 static void cm_format_rtu(struct cm_rtu_msg *rtu_msg,
1964 struct cm_id_private *cm_id_priv,
1965 const void *private_data,
1966 u8 private_data_len)
1967 {
1968 cm_format_mad_hdr(&rtu_msg->hdr, CM_RTU_ATTR_ID, cm_id_priv->tid);
1969 rtu_msg->local_comm_id = cm_id_priv->id.local_id;
1970 rtu_msg->remote_comm_id = cm_id_priv->id.remote_id;
1971
1972 if (private_data && private_data_len)
1973 memcpy(rtu_msg->private_data, private_data, private_data_len);
1974 }
1975
ib_send_cm_rtu(struct ib_cm_id * cm_id,const void * private_data,u8 private_data_len)1976 int ib_send_cm_rtu(struct ib_cm_id *cm_id,
1977 const void *private_data,
1978 u8 private_data_len)
1979 {
1980 struct cm_id_private *cm_id_priv;
1981 struct ib_mad_send_buf *msg;
1982 unsigned long flags;
1983 void *data;
1984 int ret;
1985
1986 if (private_data && private_data_len > IB_CM_RTU_PRIVATE_DATA_SIZE)
1987 return -EINVAL;
1988
1989 data = cm_copy_private_data(private_data, private_data_len);
1990 if (IS_ERR(data))
1991 return PTR_ERR(data);
1992
1993 cm_id_priv = container_of(cm_id, struct cm_id_private, id);
1994 spin_lock_irqsave(&cm_id_priv->lock, flags);
1995 if (cm_id->state != IB_CM_REP_RCVD &&
1996 cm_id->state != IB_CM_MRA_REP_SENT) {
1997 ret = -EINVAL;
1998 goto error;
1999 }
2000
2001 ret = cm_alloc_msg(cm_id_priv, &msg);
2002 if (ret)
2003 goto error;
2004
2005 cm_format_rtu((struct cm_rtu_msg *) msg->mad, cm_id_priv,
2006 private_data, private_data_len);
2007
2008 ret = ib_post_send_mad(msg, NULL);
2009 if (ret) {
2010 spin_unlock_irqrestore(&cm_id_priv->lock, flags);
2011 cm_free_msg(msg);
2012 kfree(data);
2013 return ret;
2014 }
2015
2016 cm_id->state = IB_CM_ESTABLISHED;
2017 cm_set_private_data(cm_id_priv, data, private_data_len);
2018 spin_unlock_irqrestore(&cm_id_priv->lock, flags);
2019 return 0;
2020
2021 error: spin_unlock_irqrestore(&cm_id_priv->lock, flags);
2022 kfree(data);
2023 return ret;
2024 }
2025 EXPORT_SYMBOL(ib_send_cm_rtu);
2026
cm_format_rep_event(struct cm_work * work,enum ib_qp_type qp_type)2027 static void cm_format_rep_event(struct cm_work *work, enum ib_qp_type qp_type)
2028 {
2029 struct cm_rep_msg *rep_msg;
2030 struct ib_cm_rep_event_param *param;
2031
2032 rep_msg = (struct cm_rep_msg *)work->mad_recv_wc->recv_buf.mad;
2033 param = &work->cm_event.param.rep_rcvd;
2034 param->remote_ca_guid = rep_msg->local_ca_guid;
2035 param->remote_qkey = be32_to_cpu(rep_msg->local_qkey);
2036 param->remote_qpn = be32_to_cpu(cm_rep_get_qpn(rep_msg, qp_type));
2037 param->starting_psn = be32_to_cpu(cm_rep_get_starting_psn(rep_msg));
2038 param->responder_resources = rep_msg->initiator_depth;
2039 param->initiator_depth = rep_msg->resp_resources;
2040 param->target_ack_delay = cm_rep_get_target_ack_delay(rep_msg);
2041 param->failover_accepted = cm_rep_get_failover(rep_msg);
2042 param->flow_control = cm_rep_get_flow_ctrl(rep_msg);
2043 param->rnr_retry_count = cm_rep_get_rnr_retry_count(rep_msg);
2044 param->srq = cm_rep_get_srq(rep_msg);
2045 work->cm_event.private_data = &rep_msg->private_data;
2046 }
2047
cm_dup_rep_handler(struct cm_work * work)2048 static void cm_dup_rep_handler(struct cm_work *work)
2049 {
2050 struct cm_id_private *cm_id_priv;
2051 struct cm_rep_msg *rep_msg;
2052 struct ib_mad_send_buf *msg = NULL;
2053 int ret;
2054
2055 rep_msg = (struct cm_rep_msg *) work->mad_recv_wc->recv_buf.mad;
2056 cm_id_priv = cm_acquire_id(rep_msg->remote_comm_id,
2057 rep_msg->local_comm_id);
2058 if (!cm_id_priv)
2059 return;
2060
2061 atomic_long_inc(&work->port->counter_group[CM_RECV_DUPLICATES].
2062 counter[CM_REP_COUNTER]);
2063 ret = cm_alloc_response_msg(work->port, work->mad_recv_wc, &msg);
2064 if (ret)
2065 goto deref;
2066
2067 spin_lock_irq(&cm_id_priv->lock);
2068 if (cm_id_priv->id.state == IB_CM_ESTABLISHED)
2069 cm_format_rtu((struct cm_rtu_msg *) msg->mad, cm_id_priv,
2070 cm_id_priv->private_data,
2071 cm_id_priv->private_data_len);
2072 else if (cm_id_priv->id.state == IB_CM_MRA_REP_SENT)
2073 cm_format_mra((struct cm_mra_msg *) msg->mad, cm_id_priv,
2074 CM_MSG_RESPONSE_REP, cm_id_priv->service_timeout,
2075 cm_id_priv->private_data,
2076 cm_id_priv->private_data_len);
2077 else
2078 goto unlock;
2079 spin_unlock_irq(&cm_id_priv->lock);
2080
2081 ret = ib_post_send_mad(msg, NULL);
2082 if (ret)
2083 goto free;
2084 goto deref;
2085
2086 unlock: spin_unlock_irq(&cm_id_priv->lock);
2087 free: cm_free_msg(msg);
2088 deref: cm_deref_id(cm_id_priv);
2089 }
2090
cm_rep_handler(struct cm_work * work)2091 static int cm_rep_handler(struct cm_work *work)
2092 {
2093 struct cm_id_private *cm_id_priv;
2094 struct cm_rep_msg *rep_msg;
2095 int ret;
2096 struct cm_id_private *cur_cm_id_priv;
2097 struct ib_cm_id *cm_id;
2098 struct cm_timewait_info *timewait_info;
2099
2100 rep_msg = (struct cm_rep_msg *)work->mad_recv_wc->recv_buf.mad;
2101 cm_id_priv = cm_acquire_id(rep_msg->remote_comm_id, 0);
2102 if (!cm_id_priv) {
2103 cm_dup_rep_handler(work);
2104 return -EINVAL;
2105 }
2106
2107 cm_format_rep_event(work, cm_id_priv->qp_type);
2108
2109 spin_lock_irq(&cm_id_priv->lock);
2110 switch (cm_id_priv->id.state) {
2111 case IB_CM_REQ_SENT:
2112 case IB_CM_MRA_REQ_RCVD:
2113 break;
2114 default:
2115 spin_unlock_irq(&cm_id_priv->lock);
2116 ret = -EINVAL;
2117 goto error;
2118 }
2119
2120 cm_id_priv->timewait_info->work.remote_id = rep_msg->local_comm_id;
2121 cm_id_priv->timewait_info->remote_ca_guid = rep_msg->local_ca_guid;
2122 cm_id_priv->timewait_info->remote_qpn = cm_rep_get_qpn(rep_msg, cm_id_priv->qp_type);
2123
2124 spin_lock(&cm.lock);
2125 /* Check for duplicate REP. */
2126 if (cm_insert_remote_id(cm_id_priv->timewait_info)) {
2127 spin_unlock(&cm.lock);
2128 spin_unlock_irq(&cm_id_priv->lock);
2129 ret = -EINVAL;
2130 goto error;
2131 }
2132 /* Check for a stale connection. */
2133 timewait_info = cm_insert_remote_qpn(cm_id_priv->timewait_info);
2134 if (timewait_info) {
2135 rb_erase(&cm_id_priv->timewait_info->remote_id_node,
2136 &cm.remote_id_table);
2137 cm_id_priv->timewait_info->inserted_remote_id = 0;
2138 cur_cm_id_priv = cm_get_id(timewait_info->work.local_id,
2139 timewait_info->work.remote_id);
2140
2141 spin_unlock(&cm.lock);
2142 spin_unlock_irq(&cm_id_priv->lock);
2143 cm_issue_rej(work->port, work->mad_recv_wc,
2144 IB_CM_REJ_STALE_CONN, CM_MSG_RESPONSE_REP,
2145 NULL, 0);
2146 ret = -EINVAL;
2147 if (cur_cm_id_priv) {
2148 cm_id = &cur_cm_id_priv->id;
2149 ib_send_cm_dreq(cm_id, NULL, 0);
2150 cm_deref_id(cur_cm_id_priv);
2151 }
2152
2153 goto error;
2154 }
2155 spin_unlock(&cm.lock);
2156
2157 cm_id_priv->id.state = IB_CM_REP_RCVD;
2158 cm_id_priv->id.remote_id = rep_msg->local_comm_id;
2159 cm_id_priv->remote_qpn = cm_rep_get_qpn(rep_msg, cm_id_priv->qp_type);
2160 cm_id_priv->initiator_depth = rep_msg->resp_resources;
2161 cm_id_priv->responder_resources = rep_msg->initiator_depth;
2162 cm_id_priv->sq_psn = cm_rep_get_starting_psn(rep_msg);
2163 cm_id_priv->rnr_retry_count = cm_rep_get_rnr_retry_count(rep_msg);
2164 cm_id_priv->target_ack_delay = cm_rep_get_target_ack_delay(rep_msg);
2165 cm_id_priv->av.timeout =
2166 cm_ack_timeout(cm_id_priv->target_ack_delay,
2167 cm_id_priv->av.timeout - 1);
2168 cm_id_priv->alt_av.timeout =
2169 cm_ack_timeout(cm_id_priv->target_ack_delay,
2170 cm_id_priv->alt_av.timeout - 1);
2171
2172 /* todo: handle peer_to_peer */
2173
2174 ib_cancel_mad(cm_id_priv->av.port->mad_agent, cm_id_priv->msg);
2175 ret = atomic_inc_and_test(&cm_id_priv->work_count);
2176 if (!ret)
2177 list_add_tail(&work->list, &cm_id_priv->work_list);
2178 spin_unlock_irq(&cm_id_priv->lock);
2179
2180 if (ret)
2181 cm_process_work(cm_id_priv, work);
2182 else
2183 cm_deref_id(cm_id_priv);
2184 return 0;
2185
2186 error:
2187 cm_deref_id(cm_id_priv);
2188 return ret;
2189 }
2190
cm_establish_handler(struct cm_work * work)2191 static int cm_establish_handler(struct cm_work *work)
2192 {
2193 struct cm_id_private *cm_id_priv;
2194 int ret;
2195
2196 /* See comment in cm_establish about lookup. */
2197 cm_id_priv = cm_acquire_id(work->local_id, work->remote_id);
2198 if (!cm_id_priv)
2199 return -EINVAL;
2200
2201 spin_lock_irq(&cm_id_priv->lock);
2202 if (cm_id_priv->id.state != IB_CM_ESTABLISHED) {
2203 spin_unlock_irq(&cm_id_priv->lock);
2204 goto out;
2205 }
2206
2207 ib_cancel_mad(cm_id_priv->av.port->mad_agent, cm_id_priv->msg);
2208 ret = atomic_inc_and_test(&cm_id_priv->work_count);
2209 if (!ret)
2210 list_add_tail(&work->list, &cm_id_priv->work_list);
2211 spin_unlock_irq(&cm_id_priv->lock);
2212
2213 if (ret)
2214 cm_process_work(cm_id_priv, work);
2215 else
2216 cm_deref_id(cm_id_priv);
2217 return 0;
2218 out:
2219 cm_deref_id(cm_id_priv);
2220 return -EINVAL;
2221 }
2222
cm_rtu_handler(struct cm_work * work)2223 static int cm_rtu_handler(struct cm_work *work)
2224 {
2225 struct cm_id_private *cm_id_priv;
2226 struct cm_rtu_msg *rtu_msg;
2227 int ret;
2228
2229 rtu_msg = (struct cm_rtu_msg *)work->mad_recv_wc->recv_buf.mad;
2230 cm_id_priv = cm_acquire_id(rtu_msg->remote_comm_id,
2231 rtu_msg->local_comm_id);
2232 if (!cm_id_priv)
2233 return -EINVAL;
2234
2235 work->cm_event.private_data = &rtu_msg->private_data;
2236
2237 spin_lock_irq(&cm_id_priv->lock);
2238 if (cm_id_priv->id.state != IB_CM_REP_SENT &&
2239 cm_id_priv->id.state != IB_CM_MRA_REP_RCVD) {
2240 spin_unlock_irq(&cm_id_priv->lock);
2241 atomic_long_inc(&work->port->counter_group[CM_RECV_DUPLICATES].
2242 counter[CM_RTU_COUNTER]);
2243 goto out;
2244 }
2245 cm_id_priv->id.state = IB_CM_ESTABLISHED;
2246
2247 ib_cancel_mad(cm_id_priv->av.port->mad_agent, cm_id_priv->msg);
2248 ret = atomic_inc_and_test(&cm_id_priv->work_count);
2249 if (!ret)
2250 list_add_tail(&work->list, &cm_id_priv->work_list);
2251 spin_unlock_irq(&cm_id_priv->lock);
2252
2253 if (ret)
2254 cm_process_work(cm_id_priv, work);
2255 else
2256 cm_deref_id(cm_id_priv);
2257 return 0;
2258 out:
2259 cm_deref_id(cm_id_priv);
2260 return -EINVAL;
2261 }
2262
cm_format_dreq(struct cm_dreq_msg * dreq_msg,struct cm_id_private * cm_id_priv,const void * private_data,u8 private_data_len)2263 static void cm_format_dreq(struct cm_dreq_msg *dreq_msg,
2264 struct cm_id_private *cm_id_priv,
2265 const void *private_data,
2266 u8 private_data_len)
2267 {
2268 cm_format_mad_hdr(&dreq_msg->hdr, CM_DREQ_ATTR_ID,
2269 cm_form_tid(cm_id_priv));
2270 dreq_msg->local_comm_id = cm_id_priv->id.local_id;
2271 dreq_msg->remote_comm_id = cm_id_priv->id.remote_id;
2272 cm_dreq_set_remote_qpn(dreq_msg, cm_id_priv->remote_qpn);
2273
2274 if (private_data && private_data_len)
2275 memcpy(dreq_msg->private_data, private_data, private_data_len);
2276 }
2277
ib_send_cm_dreq(struct ib_cm_id * cm_id,const void * private_data,u8 private_data_len)2278 int ib_send_cm_dreq(struct ib_cm_id *cm_id,
2279 const void *private_data,
2280 u8 private_data_len)
2281 {
2282 struct cm_id_private *cm_id_priv;
2283 struct ib_mad_send_buf *msg;
2284 unsigned long flags;
2285 int ret;
2286
2287 if (private_data && private_data_len > IB_CM_DREQ_PRIVATE_DATA_SIZE)
2288 return -EINVAL;
2289
2290 cm_id_priv = container_of(cm_id, struct cm_id_private, id);
2291 spin_lock_irqsave(&cm_id_priv->lock, flags);
2292 if (cm_id->state != IB_CM_ESTABLISHED) {
2293 ret = -EINVAL;
2294 goto out;
2295 }
2296
2297 if (cm_id->lap_state == IB_CM_LAP_SENT ||
2298 cm_id->lap_state == IB_CM_MRA_LAP_RCVD)
2299 ib_cancel_mad(cm_id_priv->av.port->mad_agent, cm_id_priv->msg);
2300
2301 ret = cm_alloc_msg(cm_id_priv, &msg);
2302 if (ret) {
2303 cm_enter_timewait(cm_id_priv);
2304 goto out;
2305 }
2306
2307 cm_format_dreq((struct cm_dreq_msg *) msg->mad, cm_id_priv,
2308 private_data, private_data_len);
2309 msg->timeout_ms = cm_id_priv->timeout_ms;
2310 msg->context[1] = (void *) (unsigned long) IB_CM_DREQ_SENT;
2311
2312 ret = ib_post_send_mad(msg, NULL);
2313 if (ret) {
2314 cm_enter_timewait(cm_id_priv);
2315 spin_unlock_irqrestore(&cm_id_priv->lock, flags);
2316 cm_free_msg(msg);
2317 return ret;
2318 }
2319
2320 cm_id->state = IB_CM_DREQ_SENT;
2321 cm_id_priv->msg = msg;
2322 out: spin_unlock_irqrestore(&cm_id_priv->lock, flags);
2323 return ret;
2324 }
2325 EXPORT_SYMBOL(ib_send_cm_dreq);
2326
cm_format_drep(struct cm_drep_msg * drep_msg,struct cm_id_private * cm_id_priv,const void * private_data,u8 private_data_len)2327 static void cm_format_drep(struct cm_drep_msg *drep_msg,
2328 struct cm_id_private *cm_id_priv,
2329 const void *private_data,
2330 u8 private_data_len)
2331 {
2332 cm_format_mad_hdr(&drep_msg->hdr, CM_DREP_ATTR_ID, cm_id_priv->tid);
2333 drep_msg->local_comm_id = cm_id_priv->id.local_id;
2334 drep_msg->remote_comm_id = cm_id_priv->id.remote_id;
2335
2336 if (private_data && private_data_len)
2337 memcpy(drep_msg->private_data, private_data, private_data_len);
2338 }
2339
ib_send_cm_drep(struct ib_cm_id * cm_id,const void * private_data,u8 private_data_len)2340 int ib_send_cm_drep(struct ib_cm_id *cm_id,
2341 const void *private_data,
2342 u8 private_data_len)
2343 {
2344 struct cm_id_private *cm_id_priv;
2345 struct ib_mad_send_buf *msg;
2346 unsigned long flags;
2347 void *data;
2348 int ret;
2349
2350 if (private_data && private_data_len > IB_CM_DREP_PRIVATE_DATA_SIZE)
2351 return -EINVAL;
2352
2353 data = cm_copy_private_data(private_data, private_data_len);
2354 if (IS_ERR(data))
2355 return PTR_ERR(data);
2356
2357 cm_id_priv = container_of(cm_id, struct cm_id_private, id);
2358 spin_lock_irqsave(&cm_id_priv->lock, flags);
2359 if (cm_id->state != IB_CM_DREQ_RCVD) {
2360 spin_unlock_irqrestore(&cm_id_priv->lock, flags);
2361 kfree(data);
2362 return -EINVAL;
2363 }
2364
2365 cm_set_private_data(cm_id_priv, data, private_data_len);
2366 cm_enter_timewait(cm_id_priv);
2367
2368 ret = cm_alloc_msg(cm_id_priv, &msg);
2369 if (ret)
2370 goto out;
2371
2372 cm_format_drep((struct cm_drep_msg *) msg->mad, cm_id_priv,
2373 private_data, private_data_len);
2374
2375 ret = ib_post_send_mad(msg, NULL);
2376 if (ret) {
2377 spin_unlock_irqrestore(&cm_id_priv->lock, flags);
2378 cm_free_msg(msg);
2379 return ret;
2380 }
2381
2382 out: spin_unlock_irqrestore(&cm_id_priv->lock, flags);
2383 return ret;
2384 }
2385 EXPORT_SYMBOL(ib_send_cm_drep);
2386
cm_issue_drep(struct cm_port * port,struct ib_mad_recv_wc * mad_recv_wc)2387 static int cm_issue_drep(struct cm_port *port,
2388 struct ib_mad_recv_wc *mad_recv_wc)
2389 {
2390 struct ib_mad_send_buf *msg = NULL;
2391 struct cm_dreq_msg *dreq_msg;
2392 struct cm_drep_msg *drep_msg;
2393 int ret;
2394
2395 ret = cm_alloc_response_msg(port, mad_recv_wc, &msg);
2396 if (ret)
2397 return ret;
2398
2399 dreq_msg = (struct cm_dreq_msg *) mad_recv_wc->recv_buf.mad;
2400 drep_msg = (struct cm_drep_msg *) msg->mad;
2401
2402 cm_format_mad_hdr(&drep_msg->hdr, CM_DREP_ATTR_ID, dreq_msg->hdr.tid);
2403 drep_msg->remote_comm_id = dreq_msg->local_comm_id;
2404 drep_msg->local_comm_id = dreq_msg->remote_comm_id;
2405
2406 ret = ib_post_send_mad(msg, NULL);
2407 if (ret)
2408 cm_free_msg(msg);
2409
2410 return ret;
2411 }
2412
cm_dreq_handler(struct cm_work * work)2413 static int cm_dreq_handler(struct cm_work *work)
2414 {
2415 struct cm_id_private *cm_id_priv;
2416 struct cm_dreq_msg *dreq_msg;
2417 struct ib_mad_send_buf *msg = NULL;
2418 int ret;
2419
2420 dreq_msg = (struct cm_dreq_msg *)work->mad_recv_wc->recv_buf.mad;
2421 cm_id_priv = cm_acquire_id(dreq_msg->remote_comm_id,
2422 dreq_msg->local_comm_id);
2423 if (!cm_id_priv) {
2424 atomic_long_inc(&work->port->counter_group[CM_RECV_DUPLICATES].
2425 counter[CM_DREQ_COUNTER]);
2426 cm_issue_drep(work->port, work->mad_recv_wc);
2427 return -EINVAL;
2428 }
2429
2430 work->cm_event.private_data = &dreq_msg->private_data;
2431
2432 spin_lock_irq(&cm_id_priv->lock);
2433 if (cm_id_priv->local_qpn != cm_dreq_get_remote_qpn(dreq_msg))
2434 goto unlock;
2435
2436 switch (cm_id_priv->id.state) {
2437 case IB_CM_REP_SENT:
2438 case IB_CM_DREQ_SENT:
2439 ib_cancel_mad(cm_id_priv->av.port->mad_agent, cm_id_priv->msg);
2440 break;
2441 case IB_CM_ESTABLISHED:
2442 if (cm_id_priv->id.lap_state == IB_CM_LAP_SENT ||
2443 cm_id_priv->id.lap_state == IB_CM_MRA_LAP_RCVD)
2444 ib_cancel_mad(cm_id_priv->av.port->mad_agent, cm_id_priv->msg);
2445 break;
2446 case IB_CM_MRA_REP_RCVD:
2447 break;
2448 case IB_CM_TIMEWAIT:
2449 atomic_long_inc(&work->port->counter_group[CM_RECV_DUPLICATES].
2450 counter[CM_DREQ_COUNTER]);
2451 msg = cm_alloc_response_msg_no_ah(work->port, work->mad_recv_wc);
2452 if (IS_ERR(msg))
2453 goto unlock;
2454
2455 cm_format_drep((struct cm_drep_msg *) msg->mad, cm_id_priv,
2456 cm_id_priv->private_data,
2457 cm_id_priv->private_data_len);
2458 spin_unlock_irq(&cm_id_priv->lock);
2459
2460 if (cm_create_response_msg_ah(work->port, work->mad_recv_wc, msg) ||
2461 ib_post_send_mad(msg, NULL))
2462 cm_free_msg(msg);
2463 goto deref;
2464 case IB_CM_DREQ_RCVD:
2465 atomic_long_inc(&work->port->counter_group[CM_RECV_DUPLICATES].
2466 counter[CM_DREQ_COUNTER]);
2467 goto unlock;
2468 default:
2469 goto unlock;
2470 }
2471 cm_id_priv->id.state = IB_CM_DREQ_RCVD;
2472 cm_id_priv->tid = dreq_msg->hdr.tid;
2473 ret = atomic_inc_and_test(&cm_id_priv->work_count);
2474 if (!ret)
2475 list_add_tail(&work->list, &cm_id_priv->work_list);
2476 spin_unlock_irq(&cm_id_priv->lock);
2477
2478 if (ret)
2479 cm_process_work(cm_id_priv, work);
2480 else
2481 cm_deref_id(cm_id_priv);
2482 return 0;
2483
2484 unlock: spin_unlock_irq(&cm_id_priv->lock);
2485 deref: cm_deref_id(cm_id_priv);
2486 return -EINVAL;
2487 }
2488
cm_drep_handler(struct cm_work * work)2489 static int cm_drep_handler(struct cm_work *work)
2490 {
2491 struct cm_id_private *cm_id_priv;
2492 struct cm_drep_msg *drep_msg;
2493 int ret;
2494
2495 drep_msg = (struct cm_drep_msg *)work->mad_recv_wc->recv_buf.mad;
2496 cm_id_priv = cm_acquire_id(drep_msg->remote_comm_id,
2497 drep_msg->local_comm_id);
2498 if (!cm_id_priv)
2499 return -EINVAL;
2500
2501 work->cm_event.private_data = &drep_msg->private_data;
2502
2503 spin_lock_irq(&cm_id_priv->lock);
2504 if (cm_id_priv->id.state != IB_CM_DREQ_SENT &&
2505 cm_id_priv->id.state != IB_CM_DREQ_RCVD) {
2506 spin_unlock_irq(&cm_id_priv->lock);
2507 goto out;
2508 }
2509 cm_enter_timewait(cm_id_priv);
2510
2511 ib_cancel_mad(cm_id_priv->av.port->mad_agent, cm_id_priv->msg);
2512 ret = atomic_inc_and_test(&cm_id_priv->work_count);
2513 if (!ret)
2514 list_add_tail(&work->list, &cm_id_priv->work_list);
2515 spin_unlock_irq(&cm_id_priv->lock);
2516
2517 if (ret)
2518 cm_process_work(cm_id_priv, work);
2519 else
2520 cm_deref_id(cm_id_priv);
2521 return 0;
2522 out:
2523 cm_deref_id(cm_id_priv);
2524 return -EINVAL;
2525 }
2526
ib_send_cm_rej(struct ib_cm_id * cm_id,enum ib_cm_rej_reason reason,void * ari,u8 ari_length,const void * private_data,u8 private_data_len)2527 int ib_send_cm_rej(struct ib_cm_id *cm_id,
2528 enum ib_cm_rej_reason reason,
2529 void *ari,
2530 u8 ari_length,
2531 const void *private_data,
2532 u8 private_data_len)
2533 {
2534 struct cm_id_private *cm_id_priv;
2535 struct ib_mad_send_buf *msg;
2536 unsigned long flags;
2537 int ret;
2538
2539 if ((private_data && private_data_len > IB_CM_REJ_PRIVATE_DATA_SIZE) ||
2540 (ari && ari_length > IB_CM_REJ_ARI_LENGTH))
2541 return -EINVAL;
2542
2543 cm_id_priv = container_of(cm_id, struct cm_id_private, id);
2544
2545 spin_lock_irqsave(&cm_id_priv->lock, flags);
2546 switch (cm_id->state) {
2547 case IB_CM_REQ_SENT:
2548 case IB_CM_MRA_REQ_RCVD:
2549 case IB_CM_REQ_RCVD:
2550 case IB_CM_MRA_REQ_SENT:
2551 case IB_CM_REP_RCVD:
2552 case IB_CM_MRA_REP_SENT:
2553 ret = cm_alloc_msg(cm_id_priv, &msg);
2554 if (!ret)
2555 cm_format_rej((struct cm_rej_msg *) msg->mad,
2556 cm_id_priv, reason, ari, ari_length,
2557 private_data, private_data_len);
2558
2559 cm_reset_to_idle(cm_id_priv);
2560 break;
2561 case IB_CM_REP_SENT:
2562 case IB_CM_MRA_REP_RCVD:
2563 ret = cm_alloc_msg(cm_id_priv, &msg);
2564 if (!ret)
2565 cm_format_rej((struct cm_rej_msg *) msg->mad,
2566 cm_id_priv, reason, ari, ari_length,
2567 private_data, private_data_len);
2568
2569 cm_enter_timewait(cm_id_priv);
2570 break;
2571 default:
2572 ret = -EINVAL;
2573 goto out;
2574 }
2575
2576 if (ret)
2577 goto out;
2578
2579 ret = ib_post_send_mad(msg, NULL);
2580 if (ret)
2581 cm_free_msg(msg);
2582
2583 out: spin_unlock_irqrestore(&cm_id_priv->lock, flags);
2584 return ret;
2585 }
2586 EXPORT_SYMBOL(ib_send_cm_rej);
2587
cm_format_rej_event(struct cm_work * work)2588 static void cm_format_rej_event(struct cm_work *work)
2589 {
2590 struct cm_rej_msg *rej_msg;
2591 struct ib_cm_rej_event_param *param;
2592
2593 rej_msg = (struct cm_rej_msg *)work->mad_recv_wc->recv_buf.mad;
2594 param = &work->cm_event.param.rej_rcvd;
2595 param->ari = rej_msg->ari;
2596 param->ari_length = cm_rej_get_reject_info_len(rej_msg);
2597 param->reason = __be16_to_cpu(rej_msg->reason);
2598 work->cm_event.private_data = &rej_msg->private_data;
2599 }
2600
cm_acquire_rejected_id(struct cm_rej_msg * rej_msg)2601 static struct cm_id_private * cm_acquire_rejected_id(struct cm_rej_msg *rej_msg)
2602 {
2603 struct cm_timewait_info *timewait_info;
2604 struct cm_id_private *cm_id_priv;
2605 __be32 remote_id;
2606
2607 remote_id = rej_msg->local_comm_id;
2608
2609 if (__be16_to_cpu(rej_msg->reason) == IB_CM_REJ_TIMEOUT) {
2610 spin_lock_irq(&cm.lock);
2611 timewait_info = cm_find_remote_id( *((__be64 *) rej_msg->ari),
2612 remote_id);
2613 if (!timewait_info) {
2614 spin_unlock_irq(&cm.lock);
2615 return NULL;
2616 }
2617 cm_id_priv = idr_find(&cm.local_id_table, (__force int)
2618 (timewait_info->work.local_id ^
2619 cm.random_id_operand));
2620 if (cm_id_priv) {
2621 if (cm_id_priv->id.remote_id == remote_id)
2622 atomic_inc(&cm_id_priv->refcount);
2623 else
2624 cm_id_priv = NULL;
2625 }
2626 spin_unlock_irq(&cm.lock);
2627 } else if (cm_rej_get_msg_rejected(rej_msg) == CM_MSG_RESPONSE_REQ)
2628 cm_id_priv = cm_acquire_id(rej_msg->remote_comm_id, 0);
2629 else
2630 cm_id_priv = cm_acquire_id(rej_msg->remote_comm_id, remote_id);
2631
2632 return cm_id_priv;
2633 }
2634
cm_rej_handler(struct cm_work * work)2635 static int cm_rej_handler(struct cm_work *work)
2636 {
2637 struct cm_id_private *cm_id_priv;
2638 struct cm_rej_msg *rej_msg;
2639 int ret;
2640
2641 rej_msg = (struct cm_rej_msg *)work->mad_recv_wc->recv_buf.mad;
2642 cm_id_priv = cm_acquire_rejected_id(rej_msg);
2643 if (!cm_id_priv)
2644 return -EINVAL;
2645
2646 cm_format_rej_event(work);
2647
2648 spin_lock_irq(&cm_id_priv->lock);
2649 switch (cm_id_priv->id.state) {
2650 case IB_CM_REQ_SENT:
2651 case IB_CM_MRA_REQ_RCVD:
2652 case IB_CM_REP_SENT:
2653 case IB_CM_MRA_REP_RCVD:
2654 ib_cancel_mad(cm_id_priv->av.port->mad_agent, cm_id_priv->msg);
2655 /* fall through */
2656 case IB_CM_REQ_RCVD:
2657 case IB_CM_MRA_REQ_SENT:
2658 if (__be16_to_cpu(rej_msg->reason) == IB_CM_REJ_STALE_CONN)
2659 cm_enter_timewait(cm_id_priv);
2660 else
2661 cm_reset_to_idle(cm_id_priv);
2662 break;
2663 case IB_CM_DREQ_SENT:
2664 ib_cancel_mad(cm_id_priv->av.port->mad_agent, cm_id_priv->msg);
2665 /* fall through */
2666 case IB_CM_REP_RCVD:
2667 case IB_CM_MRA_REP_SENT:
2668 cm_enter_timewait(cm_id_priv);
2669 break;
2670 case IB_CM_ESTABLISHED:
2671 if (cm_id_priv->id.lap_state == IB_CM_LAP_UNINIT ||
2672 cm_id_priv->id.lap_state == IB_CM_LAP_SENT) {
2673 if (cm_id_priv->id.lap_state == IB_CM_LAP_SENT)
2674 ib_cancel_mad(cm_id_priv->av.port->mad_agent,
2675 cm_id_priv->msg);
2676 cm_enter_timewait(cm_id_priv);
2677 break;
2678 }
2679 /* fall through */
2680 default:
2681 spin_unlock_irq(&cm_id_priv->lock);
2682 ret = -EINVAL;
2683 goto out;
2684 }
2685
2686 ret = atomic_inc_and_test(&cm_id_priv->work_count);
2687 if (!ret)
2688 list_add_tail(&work->list, &cm_id_priv->work_list);
2689 spin_unlock_irq(&cm_id_priv->lock);
2690
2691 if (ret)
2692 cm_process_work(cm_id_priv, work);
2693 else
2694 cm_deref_id(cm_id_priv);
2695 return 0;
2696 out:
2697 cm_deref_id(cm_id_priv);
2698 return -EINVAL;
2699 }
2700
ib_send_cm_mra(struct ib_cm_id * cm_id,u8 service_timeout,const void * private_data,u8 private_data_len)2701 int ib_send_cm_mra(struct ib_cm_id *cm_id,
2702 u8 service_timeout,
2703 const void *private_data,
2704 u8 private_data_len)
2705 {
2706 struct cm_id_private *cm_id_priv;
2707 struct ib_mad_send_buf *msg;
2708 enum ib_cm_state cm_state;
2709 enum ib_cm_lap_state lap_state;
2710 enum cm_msg_response msg_response;
2711 void *data;
2712 unsigned long flags;
2713 int ret;
2714
2715 if (private_data && private_data_len > IB_CM_MRA_PRIVATE_DATA_SIZE)
2716 return -EINVAL;
2717
2718 data = cm_copy_private_data(private_data, private_data_len);
2719 if (IS_ERR(data))
2720 return PTR_ERR(data);
2721
2722 cm_id_priv = container_of(cm_id, struct cm_id_private, id);
2723
2724 spin_lock_irqsave(&cm_id_priv->lock, flags);
2725 switch(cm_id_priv->id.state) {
2726 case IB_CM_REQ_RCVD:
2727 cm_state = IB_CM_MRA_REQ_SENT;
2728 lap_state = cm_id->lap_state;
2729 msg_response = CM_MSG_RESPONSE_REQ;
2730 break;
2731 case IB_CM_REP_RCVD:
2732 cm_state = IB_CM_MRA_REP_SENT;
2733 lap_state = cm_id->lap_state;
2734 msg_response = CM_MSG_RESPONSE_REP;
2735 break;
2736 case IB_CM_ESTABLISHED:
2737 if (cm_id->lap_state == IB_CM_LAP_RCVD) {
2738 cm_state = cm_id->state;
2739 lap_state = IB_CM_MRA_LAP_SENT;
2740 msg_response = CM_MSG_RESPONSE_OTHER;
2741 break;
2742 }
2743 default:
2744 ret = -EINVAL;
2745 goto error1;
2746 }
2747
2748 if (!(service_timeout & IB_CM_MRA_FLAG_DELAY)) {
2749 ret = cm_alloc_msg(cm_id_priv, &msg);
2750 if (ret)
2751 goto error1;
2752
2753 cm_format_mra((struct cm_mra_msg *) msg->mad, cm_id_priv,
2754 msg_response, service_timeout,
2755 private_data, private_data_len);
2756 ret = ib_post_send_mad(msg, NULL);
2757 if (ret)
2758 goto error2;
2759 }
2760
2761 cm_id->state = cm_state;
2762 cm_id->lap_state = lap_state;
2763 cm_id_priv->service_timeout = service_timeout;
2764 cm_set_private_data(cm_id_priv, data, private_data_len);
2765 spin_unlock_irqrestore(&cm_id_priv->lock, flags);
2766 return 0;
2767
2768 error1: spin_unlock_irqrestore(&cm_id_priv->lock, flags);
2769 kfree(data);
2770 return ret;
2771
2772 error2: spin_unlock_irqrestore(&cm_id_priv->lock, flags);
2773 kfree(data);
2774 cm_free_msg(msg);
2775 return ret;
2776 }
2777 EXPORT_SYMBOL(ib_send_cm_mra);
2778
cm_acquire_mraed_id(struct cm_mra_msg * mra_msg)2779 static struct cm_id_private * cm_acquire_mraed_id(struct cm_mra_msg *mra_msg)
2780 {
2781 switch (cm_mra_get_msg_mraed(mra_msg)) {
2782 case CM_MSG_RESPONSE_REQ:
2783 return cm_acquire_id(mra_msg->remote_comm_id, 0);
2784 case CM_MSG_RESPONSE_REP:
2785 case CM_MSG_RESPONSE_OTHER:
2786 return cm_acquire_id(mra_msg->remote_comm_id,
2787 mra_msg->local_comm_id);
2788 default:
2789 return NULL;
2790 }
2791 }
2792
cm_mra_handler(struct cm_work * work)2793 static int cm_mra_handler(struct cm_work *work)
2794 {
2795 struct cm_id_private *cm_id_priv;
2796 struct cm_mra_msg *mra_msg;
2797 int timeout, ret;
2798
2799 mra_msg = (struct cm_mra_msg *)work->mad_recv_wc->recv_buf.mad;
2800 cm_id_priv = cm_acquire_mraed_id(mra_msg);
2801 if (!cm_id_priv)
2802 return -EINVAL;
2803
2804 work->cm_event.private_data = &mra_msg->private_data;
2805 work->cm_event.param.mra_rcvd.service_timeout =
2806 cm_mra_get_service_timeout(mra_msg);
2807 timeout = cm_convert_to_ms(cm_mra_get_service_timeout(mra_msg)) +
2808 cm_convert_to_ms(cm_id_priv->av.timeout);
2809
2810 spin_lock_irq(&cm_id_priv->lock);
2811 switch (cm_id_priv->id.state) {
2812 case IB_CM_REQ_SENT:
2813 if (cm_mra_get_msg_mraed(mra_msg) != CM_MSG_RESPONSE_REQ ||
2814 ib_modify_mad(cm_id_priv->av.port->mad_agent,
2815 cm_id_priv->msg, timeout))
2816 goto out;
2817 cm_id_priv->id.state = IB_CM_MRA_REQ_RCVD;
2818 break;
2819 case IB_CM_REP_SENT:
2820 if (cm_mra_get_msg_mraed(mra_msg) != CM_MSG_RESPONSE_REP ||
2821 ib_modify_mad(cm_id_priv->av.port->mad_agent,
2822 cm_id_priv->msg, timeout))
2823 goto out;
2824 cm_id_priv->id.state = IB_CM_MRA_REP_RCVD;
2825 break;
2826 case IB_CM_ESTABLISHED:
2827 if (cm_mra_get_msg_mraed(mra_msg) != CM_MSG_RESPONSE_OTHER ||
2828 cm_id_priv->id.lap_state != IB_CM_LAP_SENT ||
2829 ib_modify_mad(cm_id_priv->av.port->mad_agent,
2830 cm_id_priv->msg, timeout)) {
2831 if (cm_id_priv->id.lap_state == IB_CM_MRA_LAP_RCVD)
2832 atomic_long_inc(&work->port->
2833 counter_group[CM_RECV_DUPLICATES].
2834 counter[CM_MRA_COUNTER]);
2835 goto out;
2836 }
2837 cm_id_priv->id.lap_state = IB_CM_MRA_LAP_RCVD;
2838 break;
2839 case IB_CM_MRA_REQ_RCVD:
2840 case IB_CM_MRA_REP_RCVD:
2841 atomic_long_inc(&work->port->counter_group[CM_RECV_DUPLICATES].
2842 counter[CM_MRA_COUNTER]);
2843 /* fall through */
2844 default:
2845 goto out;
2846 }
2847
2848 cm_id_priv->msg->context[1] = (void *) (unsigned long)
2849 cm_id_priv->id.state;
2850 ret = atomic_inc_and_test(&cm_id_priv->work_count);
2851 if (!ret)
2852 list_add_tail(&work->list, &cm_id_priv->work_list);
2853 spin_unlock_irq(&cm_id_priv->lock);
2854
2855 if (ret)
2856 cm_process_work(cm_id_priv, work);
2857 else
2858 cm_deref_id(cm_id_priv);
2859 return 0;
2860 out:
2861 spin_unlock_irq(&cm_id_priv->lock);
2862 cm_deref_id(cm_id_priv);
2863 return -EINVAL;
2864 }
2865
cm_format_lap(struct cm_lap_msg * lap_msg,struct cm_id_private * cm_id_priv,struct ib_sa_path_rec * alternate_path,const void * private_data,u8 private_data_len)2866 static void cm_format_lap(struct cm_lap_msg *lap_msg,
2867 struct cm_id_private *cm_id_priv,
2868 struct ib_sa_path_rec *alternate_path,
2869 const void *private_data,
2870 u8 private_data_len)
2871 {
2872 cm_format_mad_hdr(&lap_msg->hdr, CM_LAP_ATTR_ID,
2873 cm_form_tid(cm_id_priv));
2874 lap_msg->local_comm_id = cm_id_priv->id.local_id;
2875 lap_msg->remote_comm_id = cm_id_priv->id.remote_id;
2876 cm_lap_set_remote_qpn(lap_msg, cm_id_priv->remote_qpn);
2877 /* todo: need remote CM response timeout */
2878 cm_lap_set_remote_resp_timeout(lap_msg, 0x1F);
2879 lap_msg->alt_local_lid = alternate_path->slid;
2880 lap_msg->alt_remote_lid = alternate_path->dlid;
2881 lap_msg->alt_local_gid = alternate_path->sgid;
2882 lap_msg->alt_remote_gid = alternate_path->dgid;
2883 cm_lap_set_flow_label(lap_msg, alternate_path->flow_label);
2884 cm_lap_set_traffic_class(lap_msg, alternate_path->traffic_class);
2885 lap_msg->alt_hop_limit = alternate_path->hop_limit;
2886 cm_lap_set_packet_rate(lap_msg, alternate_path->rate);
2887 cm_lap_set_sl(lap_msg, alternate_path->sl);
2888 cm_lap_set_subnet_local(lap_msg, 1); /* local only... */
2889 cm_lap_set_local_ack_timeout(lap_msg,
2890 cm_ack_timeout(cm_id_priv->av.port->cm_dev->ack_delay,
2891 alternate_path->packet_life_time));
2892
2893 if (private_data && private_data_len)
2894 memcpy(lap_msg->private_data, private_data, private_data_len);
2895 }
2896
ib_send_cm_lap(struct ib_cm_id * cm_id,struct ib_sa_path_rec * alternate_path,const void * private_data,u8 private_data_len)2897 int ib_send_cm_lap(struct ib_cm_id *cm_id,
2898 struct ib_sa_path_rec *alternate_path,
2899 const void *private_data,
2900 u8 private_data_len)
2901 {
2902 struct cm_id_private *cm_id_priv;
2903 struct ib_mad_send_buf *msg;
2904 unsigned long flags;
2905 int ret;
2906
2907 if (private_data && private_data_len > IB_CM_LAP_PRIVATE_DATA_SIZE)
2908 return -EINVAL;
2909
2910 cm_id_priv = container_of(cm_id, struct cm_id_private, id);
2911 spin_lock_irqsave(&cm_id_priv->lock, flags);
2912 if (cm_id->state != IB_CM_ESTABLISHED ||
2913 (cm_id->lap_state != IB_CM_LAP_UNINIT &&
2914 cm_id->lap_state != IB_CM_LAP_IDLE)) {
2915 ret = -EINVAL;
2916 goto out;
2917 }
2918
2919 ret = cm_init_av_by_path(alternate_path, &cm_id_priv->alt_av,
2920 cm_id_priv);
2921 if (ret)
2922 goto out;
2923 cm_id_priv->alt_av.timeout =
2924 cm_ack_timeout(cm_id_priv->target_ack_delay,
2925 cm_id_priv->alt_av.timeout - 1);
2926
2927 ret = cm_alloc_msg(cm_id_priv, &msg);
2928 if (ret)
2929 goto out;
2930
2931 cm_format_lap((struct cm_lap_msg *) msg->mad, cm_id_priv,
2932 alternate_path, private_data, private_data_len);
2933 msg->timeout_ms = cm_id_priv->timeout_ms;
2934 msg->context[1] = (void *) (unsigned long) IB_CM_ESTABLISHED;
2935
2936 ret = ib_post_send_mad(msg, NULL);
2937 if (ret) {
2938 spin_unlock_irqrestore(&cm_id_priv->lock, flags);
2939 cm_free_msg(msg);
2940 return ret;
2941 }
2942
2943 cm_id->lap_state = IB_CM_LAP_SENT;
2944 cm_id_priv->msg = msg;
2945
2946 out: spin_unlock_irqrestore(&cm_id_priv->lock, flags);
2947 return ret;
2948 }
2949 EXPORT_SYMBOL(ib_send_cm_lap);
2950
cm_format_path_from_lap(struct cm_id_private * cm_id_priv,struct ib_sa_path_rec * path,struct cm_lap_msg * lap_msg)2951 static void cm_format_path_from_lap(struct cm_id_private *cm_id_priv,
2952 struct ib_sa_path_rec *path,
2953 struct cm_lap_msg *lap_msg)
2954 {
2955 memset(path, 0, sizeof *path);
2956 path->dgid = lap_msg->alt_local_gid;
2957 path->sgid = lap_msg->alt_remote_gid;
2958 path->dlid = lap_msg->alt_local_lid;
2959 path->slid = lap_msg->alt_remote_lid;
2960 path->flow_label = cm_lap_get_flow_label(lap_msg);
2961 path->hop_limit = lap_msg->alt_hop_limit;
2962 path->traffic_class = cm_lap_get_traffic_class(lap_msg);
2963 path->reversible = 1;
2964 path->pkey = cm_id_priv->pkey;
2965 path->sl = cm_lap_get_sl(lap_msg);
2966 path->mtu_selector = IB_SA_EQ;
2967 path->mtu = cm_id_priv->path_mtu;
2968 path->rate_selector = IB_SA_EQ;
2969 path->rate = cm_lap_get_packet_rate(lap_msg);
2970 path->packet_life_time_selector = IB_SA_EQ;
2971 path->packet_life_time = cm_lap_get_local_ack_timeout(lap_msg);
2972 path->packet_life_time -= (path->packet_life_time > 0);
2973 }
2974
cm_lap_handler(struct cm_work * work)2975 static int cm_lap_handler(struct cm_work *work)
2976 {
2977 struct cm_id_private *cm_id_priv;
2978 struct cm_lap_msg *lap_msg;
2979 struct ib_cm_lap_event_param *param;
2980 struct ib_mad_send_buf *msg = NULL;
2981 int ret;
2982
2983 /* Currently Alternate path messages are not supported for
2984 * RoCE link layer.
2985 */
2986 if (rdma_protocol_roce(work->port->cm_dev->ib_device,
2987 work->port->port_num))
2988 return -EINVAL;
2989
2990 /* todo: verify LAP request and send reject APR if invalid. */
2991 lap_msg = (struct cm_lap_msg *)work->mad_recv_wc->recv_buf.mad;
2992 cm_id_priv = cm_acquire_id(lap_msg->remote_comm_id,
2993 lap_msg->local_comm_id);
2994 if (!cm_id_priv)
2995 return -EINVAL;
2996
2997 param = &work->cm_event.param.lap_rcvd;
2998 param->alternate_path = &work->path[0];
2999 cm_format_path_from_lap(cm_id_priv, param->alternate_path, lap_msg);
3000 work->cm_event.private_data = &lap_msg->private_data;
3001
3002 spin_lock_irq(&cm_id_priv->lock);
3003 if (cm_id_priv->id.state != IB_CM_ESTABLISHED)
3004 goto unlock;
3005
3006 switch (cm_id_priv->id.lap_state) {
3007 case IB_CM_LAP_UNINIT:
3008 case IB_CM_LAP_IDLE:
3009 break;
3010 case IB_CM_MRA_LAP_SENT:
3011 atomic_long_inc(&work->port->counter_group[CM_RECV_DUPLICATES].
3012 counter[CM_LAP_COUNTER]);
3013 msg = cm_alloc_response_msg_no_ah(work->port, work->mad_recv_wc);
3014 if (IS_ERR(msg))
3015 goto unlock;
3016
3017 cm_format_mra((struct cm_mra_msg *) msg->mad, cm_id_priv,
3018 CM_MSG_RESPONSE_OTHER,
3019 cm_id_priv->service_timeout,
3020 cm_id_priv->private_data,
3021 cm_id_priv->private_data_len);
3022 spin_unlock_irq(&cm_id_priv->lock);
3023
3024 if (cm_create_response_msg_ah(work->port, work->mad_recv_wc, msg) ||
3025 ib_post_send_mad(msg, NULL))
3026 cm_free_msg(msg);
3027 goto deref;
3028 case IB_CM_LAP_RCVD:
3029 atomic_long_inc(&work->port->counter_group[CM_RECV_DUPLICATES].
3030 counter[CM_LAP_COUNTER]);
3031 goto unlock;
3032 default:
3033 goto unlock;
3034 }
3035
3036 cm_id_priv->id.lap_state = IB_CM_LAP_RCVD;
3037 cm_id_priv->tid = lap_msg->hdr.tid;
3038 ret = cm_init_av_for_response(work->port, work->mad_recv_wc->wc,
3039 work->mad_recv_wc->recv_buf.grh,
3040 &cm_id_priv->av);
3041 if (ret)
3042 goto unlock;
3043 ret = cm_init_av_by_path(param->alternate_path, &cm_id_priv->alt_av,
3044 cm_id_priv);
3045 if (ret)
3046 goto unlock;
3047 ret = atomic_inc_and_test(&cm_id_priv->work_count);
3048 if (!ret)
3049 list_add_tail(&work->list, &cm_id_priv->work_list);
3050 spin_unlock_irq(&cm_id_priv->lock);
3051
3052 if (ret)
3053 cm_process_work(cm_id_priv, work);
3054 else
3055 cm_deref_id(cm_id_priv);
3056 return 0;
3057
3058 unlock: spin_unlock_irq(&cm_id_priv->lock);
3059 deref: cm_deref_id(cm_id_priv);
3060 return -EINVAL;
3061 }
3062
cm_format_apr(struct cm_apr_msg * apr_msg,struct cm_id_private * cm_id_priv,enum ib_cm_apr_status status,void * info,u8 info_length,const void * private_data,u8 private_data_len)3063 static void cm_format_apr(struct cm_apr_msg *apr_msg,
3064 struct cm_id_private *cm_id_priv,
3065 enum ib_cm_apr_status status,
3066 void *info,
3067 u8 info_length,
3068 const void *private_data,
3069 u8 private_data_len)
3070 {
3071 cm_format_mad_hdr(&apr_msg->hdr, CM_APR_ATTR_ID, cm_id_priv->tid);
3072 apr_msg->local_comm_id = cm_id_priv->id.local_id;
3073 apr_msg->remote_comm_id = cm_id_priv->id.remote_id;
3074 apr_msg->ap_status = (u8) status;
3075
3076 if (info && info_length) {
3077 apr_msg->info_length = info_length;
3078 memcpy(apr_msg->info, info, info_length);
3079 }
3080
3081 if (private_data && private_data_len)
3082 memcpy(apr_msg->private_data, private_data, private_data_len);
3083 }
3084
ib_send_cm_apr(struct ib_cm_id * cm_id,enum ib_cm_apr_status status,void * info,u8 info_length,const void * private_data,u8 private_data_len)3085 int ib_send_cm_apr(struct ib_cm_id *cm_id,
3086 enum ib_cm_apr_status status,
3087 void *info,
3088 u8 info_length,
3089 const void *private_data,
3090 u8 private_data_len)
3091 {
3092 struct cm_id_private *cm_id_priv;
3093 struct ib_mad_send_buf *msg;
3094 unsigned long flags;
3095 int ret;
3096
3097 if ((private_data && private_data_len > IB_CM_APR_PRIVATE_DATA_SIZE) ||
3098 (info && info_length > IB_CM_APR_INFO_LENGTH))
3099 return -EINVAL;
3100
3101 cm_id_priv = container_of(cm_id, struct cm_id_private, id);
3102 spin_lock_irqsave(&cm_id_priv->lock, flags);
3103 if (cm_id->state != IB_CM_ESTABLISHED ||
3104 (cm_id->lap_state != IB_CM_LAP_RCVD &&
3105 cm_id->lap_state != IB_CM_MRA_LAP_SENT)) {
3106 ret = -EINVAL;
3107 goto out;
3108 }
3109
3110 ret = cm_alloc_msg(cm_id_priv, &msg);
3111 if (ret)
3112 goto out;
3113
3114 cm_format_apr((struct cm_apr_msg *) msg->mad, cm_id_priv, status,
3115 info, info_length, private_data, private_data_len);
3116 ret = ib_post_send_mad(msg, NULL);
3117 if (ret) {
3118 spin_unlock_irqrestore(&cm_id_priv->lock, flags);
3119 cm_free_msg(msg);
3120 return ret;
3121 }
3122
3123 cm_id->lap_state = IB_CM_LAP_IDLE;
3124 out: spin_unlock_irqrestore(&cm_id_priv->lock, flags);
3125 return ret;
3126 }
3127 EXPORT_SYMBOL(ib_send_cm_apr);
3128
cm_apr_handler(struct cm_work * work)3129 static int cm_apr_handler(struct cm_work *work)
3130 {
3131 struct cm_id_private *cm_id_priv;
3132 struct cm_apr_msg *apr_msg;
3133 int ret;
3134
3135 /* Currently Alternate path messages are not supported for
3136 * RoCE link layer.
3137 */
3138 if (rdma_protocol_roce(work->port->cm_dev->ib_device,
3139 work->port->port_num))
3140 return -EINVAL;
3141
3142 apr_msg = (struct cm_apr_msg *)work->mad_recv_wc->recv_buf.mad;
3143 cm_id_priv = cm_acquire_id(apr_msg->remote_comm_id,
3144 apr_msg->local_comm_id);
3145 if (!cm_id_priv)
3146 return -EINVAL; /* Unmatched reply. */
3147
3148 work->cm_event.param.apr_rcvd.ap_status = apr_msg->ap_status;
3149 work->cm_event.param.apr_rcvd.apr_info = &apr_msg->info;
3150 work->cm_event.param.apr_rcvd.info_len = apr_msg->info_length;
3151 work->cm_event.private_data = &apr_msg->private_data;
3152
3153 spin_lock_irq(&cm_id_priv->lock);
3154 if (cm_id_priv->id.state != IB_CM_ESTABLISHED ||
3155 (cm_id_priv->id.lap_state != IB_CM_LAP_SENT &&
3156 cm_id_priv->id.lap_state != IB_CM_MRA_LAP_RCVD)) {
3157 spin_unlock_irq(&cm_id_priv->lock);
3158 goto out;
3159 }
3160 cm_id_priv->id.lap_state = IB_CM_LAP_IDLE;
3161 ib_cancel_mad(cm_id_priv->av.port->mad_agent, cm_id_priv->msg);
3162 cm_id_priv->msg = NULL;
3163
3164 ret = atomic_inc_and_test(&cm_id_priv->work_count);
3165 if (!ret)
3166 list_add_tail(&work->list, &cm_id_priv->work_list);
3167 spin_unlock_irq(&cm_id_priv->lock);
3168
3169 if (ret)
3170 cm_process_work(cm_id_priv, work);
3171 else
3172 cm_deref_id(cm_id_priv);
3173 return 0;
3174 out:
3175 cm_deref_id(cm_id_priv);
3176 return -EINVAL;
3177 }
3178
cm_timewait_handler(struct cm_work * work)3179 static int cm_timewait_handler(struct cm_work *work)
3180 {
3181 struct cm_timewait_info *timewait_info;
3182 struct cm_id_private *cm_id_priv;
3183 int ret;
3184
3185 timewait_info = (struct cm_timewait_info *)work;
3186 spin_lock_irq(&cm.lock);
3187 list_del(&timewait_info->list);
3188 spin_unlock_irq(&cm.lock);
3189
3190 cm_id_priv = cm_acquire_id(timewait_info->work.local_id,
3191 timewait_info->work.remote_id);
3192 if (!cm_id_priv)
3193 return -EINVAL;
3194
3195 spin_lock_irq(&cm_id_priv->lock);
3196 if (cm_id_priv->id.state != IB_CM_TIMEWAIT ||
3197 cm_id_priv->remote_qpn != timewait_info->remote_qpn) {
3198 spin_unlock_irq(&cm_id_priv->lock);
3199 goto out;
3200 }
3201 cm_id_priv->id.state = IB_CM_IDLE;
3202 ret = atomic_inc_and_test(&cm_id_priv->work_count);
3203 if (!ret)
3204 list_add_tail(&work->list, &cm_id_priv->work_list);
3205 spin_unlock_irq(&cm_id_priv->lock);
3206
3207 if (ret)
3208 cm_process_work(cm_id_priv, work);
3209 else
3210 cm_deref_id(cm_id_priv);
3211 return 0;
3212 out:
3213 cm_deref_id(cm_id_priv);
3214 return -EINVAL;
3215 }
3216
cm_format_sidr_req(struct cm_sidr_req_msg * sidr_req_msg,struct cm_id_private * cm_id_priv,struct ib_cm_sidr_req_param * param)3217 static void cm_format_sidr_req(struct cm_sidr_req_msg *sidr_req_msg,
3218 struct cm_id_private *cm_id_priv,
3219 struct ib_cm_sidr_req_param *param)
3220 {
3221 cm_format_mad_hdr(&sidr_req_msg->hdr, CM_SIDR_REQ_ATTR_ID,
3222 cm_form_tid(cm_id_priv));
3223 sidr_req_msg->request_id = cm_id_priv->id.local_id;
3224 sidr_req_msg->pkey = param->path->pkey;
3225 sidr_req_msg->service_id = param->service_id;
3226
3227 if (param->private_data && param->private_data_len)
3228 memcpy(sidr_req_msg->private_data, param->private_data,
3229 param->private_data_len);
3230 }
3231
ib_send_cm_sidr_req(struct ib_cm_id * cm_id,struct ib_cm_sidr_req_param * param)3232 int ib_send_cm_sidr_req(struct ib_cm_id *cm_id,
3233 struct ib_cm_sidr_req_param *param)
3234 {
3235 struct cm_id_private *cm_id_priv;
3236 struct ib_mad_send_buf *msg;
3237 unsigned long flags;
3238 int ret;
3239
3240 if (!param->path || (param->private_data &&
3241 param->private_data_len > IB_CM_SIDR_REQ_PRIVATE_DATA_SIZE))
3242 return -EINVAL;
3243
3244 cm_id_priv = container_of(cm_id, struct cm_id_private, id);
3245 ret = cm_init_av_by_path(param->path, &cm_id_priv->av, cm_id_priv);
3246 if (ret)
3247 goto out;
3248
3249 cm_id->service_id = param->service_id;
3250 cm_id->service_mask = ~cpu_to_be64(0);
3251 cm_id_priv->timeout_ms = param->timeout_ms;
3252 cm_id_priv->max_cm_retries = param->max_cm_retries;
3253 ret = cm_alloc_msg(cm_id_priv, &msg);
3254 if (ret)
3255 goto out;
3256
3257 cm_format_sidr_req((struct cm_sidr_req_msg *) msg->mad, cm_id_priv,
3258 param);
3259 msg->timeout_ms = cm_id_priv->timeout_ms;
3260 msg->context[1] = (void *) (unsigned long) IB_CM_SIDR_REQ_SENT;
3261
3262 spin_lock_irqsave(&cm_id_priv->lock, flags);
3263 if (cm_id->state == IB_CM_IDLE)
3264 ret = ib_post_send_mad(msg, NULL);
3265 else
3266 ret = -EINVAL;
3267
3268 if (ret) {
3269 spin_unlock_irqrestore(&cm_id_priv->lock, flags);
3270 cm_free_msg(msg);
3271 goto out;
3272 }
3273 cm_id->state = IB_CM_SIDR_REQ_SENT;
3274 cm_id_priv->msg = msg;
3275 spin_unlock_irqrestore(&cm_id_priv->lock, flags);
3276 out:
3277 return ret;
3278 }
3279 EXPORT_SYMBOL(ib_send_cm_sidr_req);
3280
cm_format_sidr_req_event(struct cm_work * work,const struct cm_id_private * rx_cm_id,struct ib_cm_id * listen_id)3281 static void cm_format_sidr_req_event(struct cm_work *work,
3282 const struct cm_id_private *rx_cm_id,
3283 struct ib_cm_id *listen_id)
3284 {
3285 struct cm_sidr_req_msg *sidr_req_msg;
3286 struct ib_cm_sidr_req_event_param *param;
3287
3288 sidr_req_msg = (struct cm_sidr_req_msg *)
3289 work->mad_recv_wc->recv_buf.mad;
3290 param = &work->cm_event.param.sidr_req_rcvd;
3291 param->pkey = __be16_to_cpu(sidr_req_msg->pkey);
3292 param->listen_id = listen_id;
3293 param->service_id = sidr_req_msg->service_id;
3294 param->bth_pkey = cm_get_bth_pkey(work);
3295 param->port = work->port->port_num;
3296 param->sgid_index = rx_cm_id->av.ah_attr.grh.sgid_index;
3297 work->cm_event.private_data = &sidr_req_msg->private_data;
3298 }
3299
cm_sidr_req_handler(struct cm_work * work)3300 static int cm_sidr_req_handler(struct cm_work *work)
3301 {
3302 struct ib_cm_id *cm_id;
3303 struct cm_id_private *cm_id_priv, *cur_cm_id_priv;
3304 struct cm_sidr_req_msg *sidr_req_msg;
3305 struct ib_wc *wc;
3306 int ret;
3307
3308 cm_id = ib_create_cm_id(work->port->cm_dev->ib_device, NULL, NULL);
3309 if (IS_ERR(cm_id))
3310 return PTR_ERR(cm_id);
3311 cm_id_priv = container_of(cm_id, struct cm_id_private, id);
3312
3313 /* Record SGID/SLID and request ID for lookup. */
3314 sidr_req_msg = (struct cm_sidr_req_msg *)
3315 work->mad_recv_wc->recv_buf.mad;
3316 wc = work->mad_recv_wc->wc;
3317 cm_id_priv->av.dgid.global.subnet_prefix = cpu_to_be64(wc->slid);
3318 cm_id_priv->av.dgid.global.interface_id = 0;
3319 ret = cm_init_av_for_lap(work->port, work->mad_recv_wc->wc,
3320 work->mad_recv_wc->recv_buf.grh,
3321 &cm_id_priv->av);
3322 if (ret)
3323 goto out;
3324 cm_id_priv->id.remote_id = sidr_req_msg->request_id;
3325 cm_id_priv->tid = sidr_req_msg->hdr.tid;
3326 atomic_inc(&cm_id_priv->work_count);
3327
3328 spin_lock_irq(&cm.lock);
3329 cur_cm_id_priv = cm_insert_remote_sidr(cm_id_priv);
3330 if (cur_cm_id_priv) {
3331 spin_unlock_irq(&cm.lock);
3332 atomic_long_inc(&work->port->counter_group[CM_RECV_DUPLICATES].
3333 counter[CM_SIDR_REQ_COUNTER]);
3334 goto out; /* Duplicate message. */
3335 }
3336 cm_id_priv->id.state = IB_CM_SIDR_REQ_RCVD;
3337 cur_cm_id_priv = cm_find_listen(cm_id->device,
3338 sidr_req_msg->service_id);
3339 if (!cur_cm_id_priv) {
3340 spin_unlock_irq(&cm.lock);
3341 cm_reject_sidr_req(cm_id_priv, IB_SIDR_UNSUPPORTED);
3342 goto out; /* No match. */
3343 }
3344 atomic_inc(&cur_cm_id_priv->refcount);
3345 atomic_inc(&cm_id_priv->refcount);
3346 spin_unlock_irq(&cm.lock);
3347
3348 cm_id_priv->id.cm_handler = cur_cm_id_priv->id.cm_handler;
3349 cm_id_priv->id.context = cur_cm_id_priv->id.context;
3350 cm_id_priv->id.service_id = sidr_req_msg->service_id;
3351 cm_id_priv->id.service_mask = ~cpu_to_be64(0);
3352
3353 cm_format_sidr_req_event(work, cm_id_priv, &cur_cm_id_priv->id);
3354 cm_process_work(cm_id_priv, work);
3355 cm_deref_id(cur_cm_id_priv);
3356 return 0;
3357 out:
3358 ib_destroy_cm_id(&cm_id_priv->id);
3359 return -EINVAL;
3360 }
3361
cm_format_sidr_rep(struct cm_sidr_rep_msg * sidr_rep_msg,struct cm_id_private * cm_id_priv,struct ib_cm_sidr_rep_param * param)3362 static void cm_format_sidr_rep(struct cm_sidr_rep_msg *sidr_rep_msg,
3363 struct cm_id_private *cm_id_priv,
3364 struct ib_cm_sidr_rep_param *param)
3365 {
3366 cm_format_mad_hdr(&sidr_rep_msg->hdr, CM_SIDR_REP_ATTR_ID,
3367 cm_id_priv->tid);
3368 sidr_rep_msg->request_id = cm_id_priv->id.remote_id;
3369 sidr_rep_msg->status = param->status;
3370 cm_sidr_rep_set_qpn(sidr_rep_msg, cpu_to_be32(param->qp_num));
3371 sidr_rep_msg->service_id = cm_id_priv->id.service_id;
3372 sidr_rep_msg->qkey = cpu_to_be32(param->qkey);
3373
3374 if (param->info && param->info_length)
3375 memcpy(sidr_rep_msg->info, param->info, param->info_length);
3376
3377 if (param->private_data && param->private_data_len)
3378 memcpy(sidr_rep_msg->private_data, param->private_data,
3379 param->private_data_len);
3380 }
3381
ib_send_cm_sidr_rep(struct ib_cm_id * cm_id,struct ib_cm_sidr_rep_param * param)3382 int ib_send_cm_sidr_rep(struct ib_cm_id *cm_id,
3383 struct ib_cm_sidr_rep_param *param)
3384 {
3385 struct cm_id_private *cm_id_priv;
3386 struct ib_mad_send_buf *msg;
3387 unsigned long flags;
3388 int ret;
3389
3390 if ((param->info && param->info_length > IB_CM_SIDR_REP_INFO_LENGTH) ||
3391 (param->private_data &&
3392 param->private_data_len > IB_CM_SIDR_REP_PRIVATE_DATA_SIZE))
3393 return -EINVAL;
3394
3395 cm_id_priv = container_of(cm_id, struct cm_id_private, id);
3396 spin_lock_irqsave(&cm_id_priv->lock, flags);
3397 if (cm_id->state != IB_CM_SIDR_REQ_RCVD) {
3398 ret = -EINVAL;
3399 goto error;
3400 }
3401
3402 ret = cm_alloc_msg(cm_id_priv, &msg);
3403 if (ret)
3404 goto error;
3405
3406 cm_format_sidr_rep((struct cm_sidr_rep_msg *) msg->mad, cm_id_priv,
3407 param);
3408 ret = ib_post_send_mad(msg, NULL);
3409 if (ret) {
3410 spin_unlock_irqrestore(&cm_id_priv->lock, flags);
3411 cm_free_msg(msg);
3412 return ret;
3413 }
3414 cm_id->state = IB_CM_IDLE;
3415 spin_unlock_irqrestore(&cm_id_priv->lock, flags);
3416
3417 spin_lock_irqsave(&cm.lock, flags);
3418 if (!RB_EMPTY_NODE(&cm_id_priv->sidr_id_node)) {
3419 rb_erase(&cm_id_priv->sidr_id_node, &cm.remote_sidr_table);
3420 RB_CLEAR_NODE(&cm_id_priv->sidr_id_node);
3421 }
3422 spin_unlock_irqrestore(&cm.lock, flags);
3423 return 0;
3424
3425 error: spin_unlock_irqrestore(&cm_id_priv->lock, flags);
3426 return ret;
3427 }
3428 EXPORT_SYMBOL(ib_send_cm_sidr_rep);
3429
cm_format_sidr_rep_event(struct cm_work * work)3430 static void cm_format_sidr_rep_event(struct cm_work *work)
3431 {
3432 struct cm_sidr_rep_msg *sidr_rep_msg;
3433 struct ib_cm_sidr_rep_event_param *param;
3434
3435 sidr_rep_msg = (struct cm_sidr_rep_msg *)
3436 work->mad_recv_wc->recv_buf.mad;
3437 param = &work->cm_event.param.sidr_rep_rcvd;
3438 param->status = sidr_rep_msg->status;
3439 param->qkey = be32_to_cpu(sidr_rep_msg->qkey);
3440 param->qpn = be32_to_cpu(cm_sidr_rep_get_qpn(sidr_rep_msg));
3441 param->info = &sidr_rep_msg->info;
3442 param->info_len = sidr_rep_msg->info_length;
3443 work->cm_event.private_data = &sidr_rep_msg->private_data;
3444 }
3445
cm_sidr_rep_handler(struct cm_work * work)3446 static int cm_sidr_rep_handler(struct cm_work *work)
3447 {
3448 struct cm_sidr_rep_msg *sidr_rep_msg;
3449 struct cm_id_private *cm_id_priv;
3450
3451 sidr_rep_msg = (struct cm_sidr_rep_msg *)
3452 work->mad_recv_wc->recv_buf.mad;
3453 cm_id_priv = cm_acquire_id(sidr_rep_msg->request_id, 0);
3454 if (!cm_id_priv)
3455 return -EINVAL; /* Unmatched reply. */
3456
3457 spin_lock_irq(&cm_id_priv->lock);
3458 if (cm_id_priv->id.state != IB_CM_SIDR_REQ_SENT) {
3459 spin_unlock_irq(&cm_id_priv->lock);
3460 goto out;
3461 }
3462 cm_id_priv->id.state = IB_CM_IDLE;
3463 ib_cancel_mad(cm_id_priv->av.port->mad_agent, cm_id_priv->msg);
3464 spin_unlock_irq(&cm_id_priv->lock);
3465
3466 cm_format_sidr_rep_event(work);
3467 cm_process_work(cm_id_priv, work);
3468 return 0;
3469 out:
3470 cm_deref_id(cm_id_priv);
3471 return -EINVAL;
3472 }
3473
cm_process_send_error(struct ib_mad_send_buf * msg,enum ib_wc_status wc_status)3474 static void cm_process_send_error(struct ib_mad_send_buf *msg,
3475 enum ib_wc_status wc_status)
3476 {
3477 struct cm_id_private *cm_id_priv;
3478 struct ib_cm_event cm_event;
3479 enum ib_cm_state state;
3480 int ret;
3481
3482 memset(&cm_event, 0, sizeof cm_event);
3483 cm_id_priv = msg->context[0];
3484
3485 /* Discard old sends or ones without a response. */
3486 spin_lock_irq(&cm_id_priv->lock);
3487 state = (enum ib_cm_state) (unsigned long) msg->context[1];
3488 if (msg != cm_id_priv->msg || state != cm_id_priv->id.state)
3489 goto discard;
3490
3491 switch (state) {
3492 case IB_CM_REQ_SENT:
3493 case IB_CM_MRA_REQ_RCVD:
3494 cm_reset_to_idle(cm_id_priv);
3495 cm_event.event = IB_CM_REQ_ERROR;
3496 break;
3497 case IB_CM_REP_SENT:
3498 case IB_CM_MRA_REP_RCVD:
3499 cm_reset_to_idle(cm_id_priv);
3500 cm_event.event = IB_CM_REP_ERROR;
3501 break;
3502 case IB_CM_DREQ_SENT:
3503 cm_enter_timewait(cm_id_priv);
3504 cm_event.event = IB_CM_DREQ_ERROR;
3505 break;
3506 case IB_CM_SIDR_REQ_SENT:
3507 cm_id_priv->id.state = IB_CM_IDLE;
3508 cm_event.event = IB_CM_SIDR_REQ_ERROR;
3509 break;
3510 default:
3511 goto discard;
3512 }
3513 spin_unlock_irq(&cm_id_priv->lock);
3514 cm_event.param.send_status = wc_status;
3515
3516 /* No other events can occur on the cm_id at this point. */
3517 ret = cm_id_priv->id.cm_handler(&cm_id_priv->id, &cm_event);
3518 cm_free_msg(msg);
3519 if (ret)
3520 ib_destroy_cm_id(&cm_id_priv->id);
3521 return;
3522 discard:
3523 spin_unlock_irq(&cm_id_priv->lock);
3524 cm_free_msg(msg);
3525 }
3526
cm_send_handler(struct ib_mad_agent * mad_agent,struct ib_mad_send_wc * mad_send_wc)3527 static void cm_send_handler(struct ib_mad_agent *mad_agent,
3528 struct ib_mad_send_wc *mad_send_wc)
3529 {
3530 struct ib_mad_send_buf *msg = mad_send_wc->send_buf;
3531 struct cm_port *port;
3532 u16 attr_index;
3533
3534 port = mad_agent->context;
3535 attr_index = be16_to_cpu(((struct ib_mad_hdr *)
3536 msg->mad)->attr_id) - CM_ATTR_ID_OFFSET;
3537
3538 /*
3539 * If the send was in response to a received message (context[0] is not
3540 * set to a cm_id), and is not a REJ, then it is a send that was
3541 * manually retried.
3542 */
3543 if (!msg->context[0] && (attr_index != CM_REJ_COUNTER))
3544 msg->retries = 1;
3545
3546 atomic_long_add(1 + msg->retries,
3547 &port->counter_group[CM_XMIT].counter[attr_index]);
3548 if (msg->retries)
3549 atomic_long_add(msg->retries,
3550 &port->counter_group[CM_XMIT_RETRIES].
3551 counter[attr_index]);
3552
3553 switch (mad_send_wc->status) {
3554 case IB_WC_SUCCESS:
3555 case IB_WC_WR_FLUSH_ERR:
3556 cm_free_msg(msg);
3557 break;
3558 default:
3559 if (msg->context[0] && msg->context[1])
3560 cm_process_send_error(msg, mad_send_wc->status);
3561 else
3562 cm_free_msg(msg);
3563 break;
3564 }
3565 }
3566
cm_work_handler(struct work_struct * _work)3567 static void cm_work_handler(struct work_struct *_work)
3568 {
3569 struct cm_work *work = container_of(_work, struct cm_work, work.work);
3570 int ret;
3571
3572 switch (work->cm_event.event) {
3573 case IB_CM_REQ_RECEIVED:
3574 ret = cm_req_handler(work);
3575 break;
3576 case IB_CM_MRA_RECEIVED:
3577 ret = cm_mra_handler(work);
3578 break;
3579 case IB_CM_REJ_RECEIVED:
3580 ret = cm_rej_handler(work);
3581 break;
3582 case IB_CM_REP_RECEIVED:
3583 ret = cm_rep_handler(work);
3584 break;
3585 case IB_CM_RTU_RECEIVED:
3586 ret = cm_rtu_handler(work);
3587 break;
3588 case IB_CM_USER_ESTABLISHED:
3589 ret = cm_establish_handler(work);
3590 break;
3591 case IB_CM_DREQ_RECEIVED:
3592 ret = cm_dreq_handler(work);
3593 break;
3594 case IB_CM_DREP_RECEIVED:
3595 ret = cm_drep_handler(work);
3596 break;
3597 case IB_CM_SIDR_REQ_RECEIVED:
3598 ret = cm_sidr_req_handler(work);
3599 break;
3600 case IB_CM_SIDR_REP_RECEIVED:
3601 ret = cm_sidr_rep_handler(work);
3602 break;
3603 case IB_CM_LAP_RECEIVED:
3604 ret = cm_lap_handler(work);
3605 break;
3606 case IB_CM_APR_RECEIVED:
3607 ret = cm_apr_handler(work);
3608 break;
3609 case IB_CM_TIMEWAIT_EXIT:
3610 ret = cm_timewait_handler(work);
3611 break;
3612 default:
3613 ret = -EINVAL;
3614 break;
3615 }
3616 if (ret)
3617 cm_free_work(work);
3618 }
3619
cm_establish(struct ib_cm_id * cm_id)3620 static int cm_establish(struct ib_cm_id *cm_id)
3621 {
3622 struct cm_id_private *cm_id_priv;
3623 struct cm_work *work;
3624 unsigned long flags;
3625 int ret = 0;
3626 struct cm_device *cm_dev;
3627
3628 cm_dev = ib_get_client_data(cm_id->device, &cm_client);
3629 if (!cm_dev)
3630 return -ENODEV;
3631
3632 work = kmalloc(sizeof *work, GFP_ATOMIC);
3633 if (!work)
3634 return -ENOMEM;
3635
3636 cm_id_priv = container_of(cm_id, struct cm_id_private, id);
3637 spin_lock_irqsave(&cm_id_priv->lock, flags);
3638 switch (cm_id->state)
3639 {
3640 case IB_CM_REP_SENT:
3641 case IB_CM_MRA_REP_RCVD:
3642 cm_id->state = IB_CM_ESTABLISHED;
3643 break;
3644 case IB_CM_ESTABLISHED:
3645 ret = -EISCONN;
3646 break;
3647 default:
3648 ret = -EINVAL;
3649 break;
3650 }
3651 spin_unlock_irqrestore(&cm_id_priv->lock, flags);
3652
3653 if (ret) {
3654 kfree(work);
3655 goto out;
3656 }
3657
3658 /*
3659 * The CM worker thread may try to destroy the cm_id before it
3660 * can execute this work item. To prevent potential deadlock,
3661 * we need to find the cm_id once we're in the context of the
3662 * worker thread, rather than holding a reference on it.
3663 */
3664 INIT_DELAYED_WORK(&work->work, cm_work_handler);
3665 work->local_id = cm_id->local_id;
3666 work->remote_id = cm_id->remote_id;
3667 work->mad_recv_wc = NULL;
3668 work->cm_event.event = IB_CM_USER_ESTABLISHED;
3669
3670 /* Check if the device started its remove_one */
3671 spin_lock_irqsave(&cm.lock, flags);
3672 if (!cm_dev->going_down) {
3673 queue_delayed_work(cm.wq, &work->work, 0);
3674 } else {
3675 kfree(work);
3676 ret = -ENODEV;
3677 }
3678 spin_unlock_irqrestore(&cm.lock, flags);
3679
3680 out:
3681 return ret;
3682 }
3683
cm_migrate(struct ib_cm_id * cm_id)3684 static int cm_migrate(struct ib_cm_id *cm_id)
3685 {
3686 struct cm_id_private *cm_id_priv;
3687 struct cm_av tmp_av;
3688 unsigned long flags;
3689 int tmp_send_port_not_ready;
3690 int ret = 0;
3691
3692 cm_id_priv = container_of(cm_id, struct cm_id_private, id);
3693 spin_lock_irqsave(&cm_id_priv->lock, flags);
3694 if (cm_id->state == IB_CM_ESTABLISHED &&
3695 (cm_id->lap_state == IB_CM_LAP_UNINIT ||
3696 cm_id->lap_state == IB_CM_LAP_IDLE)) {
3697 cm_id->lap_state = IB_CM_LAP_IDLE;
3698 /* Swap address vector */
3699 tmp_av = cm_id_priv->av;
3700 cm_id_priv->av = cm_id_priv->alt_av;
3701 cm_id_priv->alt_av = tmp_av;
3702 /* Swap port send ready state */
3703 tmp_send_port_not_ready = cm_id_priv->prim_send_port_not_ready;
3704 cm_id_priv->prim_send_port_not_ready = cm_id_priv->altr_send_port_not_ready;
3705 cm_id_priv->altr_send_port_not_ready = tmp_send_port_not_ready;
3706 } else
3707 ret = -EINVAL;
3708 spin_unlock_irqrestore(&cm_id_priv->lock, flags);
3709
3710 return ret;
3711 }
3712
ib_cm_notify(struct ib_cm_id * cm_id,enum ib_event_type event)3713 int ib_cm_notify(struct ib_cm_id *cm_id, enum ib_event_type event)
3714 {
3715 int ret;
3716
3717 switch (event) {
3718 case IB_EVENT_COMM_EST:
3719 ret = cm_establish(cm_id);
3720 break;
3721 case IB_EVENT_PATH_MIG:
3722 ret = cm_migrate(cm_id);
3723 break;
3724 default:
3725 ret = -EINVAL;
3726 }
3727 return ret;
3728 }
3729 EXPORT_SYMBOL(ib_cm_notify);
3730
cm_recv_handler(struct ib_mad_agent * mad_agent,struct ib_mad_send_buf * send_buf,struct ib_mad_recv_wc * mad_recv_wc)3731 static void cm_recv_handler(struct ib_mad_agent *mad_agent,
3732 struct ib_mad_send_buf *send_buf,
3733 struct ib_mad_recv_wc *mad_recv_wc)
3734 {
3735 struct cm_port *port = mad_agent->context;
3736 struct cm_work *work;
3737 enum ib_cm_event_type event;
3738 u16 attr_id;
3739 int paths = 0;
3740 int going_down = 0;
3741
3742 switch (mad_recv_wc->recv_buf.mad->mad_hdr.attr_id) {
3743 case CM_REQ_ATTR_ID:
3744 paths = 1 + (((struct cm_req_msg *) mad_recv_wc->recv_buf.mad)->
3745 alt_local_lid != 0);
3746 event = IB_CM_REQ_RECEIVED;
3747 break;
3748 case CM_MRA_ATTR_ID:
3749 event = IB_CM_MRA_RECEIVED;
3750 break;
3751 case CM_REJ_ATTR_ID:
3752 event = IB_CM_REJ_RECEIVED;
3753 break;
3754 case CM_REP_ATTR_ID:
3755 event = IB_CM_REP_RECEIVED;
3756 break;
3757 case CM_RTU_ATTR_ID:
3758 event = IB_CM_RTU_RECEIVED;
3759 break;
3760 case CM_DREQ_ATTR_ID:
3761 event = IB_CM_DREQ_RECEIVED;
3762 break;
3763 case CM_DREP_ATTR_ID:
3764 event = IB_CM_DREP_RECEIVED;
3765 break;
3766 case CM_SIDR_REQ_ATTR_ID:
3767 event = IB_CM_SIDR_REQ_RECEIVED;
3768 break;
3769 case CM_SIDR_REP_ATTR_ID:
3770 event = IB_CM_SIDR_REP_RECEIVED;
3771 break;
3772 case CM_LAP_ATTR_ID:
3773 paths = 1;
3774 event = IB_CM_LAP_RECEIVED;
3775 break;
3776 case CM_APR_ATTR_ID:
3777 event = IB_CM_APR_RECEIVED;
3778 break;
3779 default:
3780 ib_free_recv_mad(mad_recv_wc);
3781 return;
3782 }
3783
3784 attr_id = be16_to_cpu(mad_recv_wc->recv_buf.mad->mad_hdr.attr_id);
3785 atomic_long_inc(&port->counter_group[CM_RECV].
3786 counter[attr_id - CM_ATTR_ID_OFFSET]);
3787
3788 work = kmalloc(sizeof *work + sizeof(struct ib_sa_path_rec) * paths,
3789 GFP_KERNEL);
3790 if (!work) {
3791 ib_free_recv_mad(mad_recv_wc);
3792 return;
3793 }
3794
3795 INIT_DELAYED_WORK(&work->work, cm_work_handler);
3796 work->cm_event.event = event;
3797 work->mad_recv_wc = mad_recv_wc;
3798 work->port = port;
3799
3800 /* Check if the device started its remove_one */
3801 spin_lock_irq(&cm.lock);
3802 if (!port->cm_dev->going_down)
3803 queue_delayed_work(cm.wq, &work->work, 0);
3804 else
3805 going_down = 1;
3806 spin_unlock_irq(&cm.lock);
3807
3808 if (going_down) {
3809 kfree(work);
3810 ib_free_recv_mad(mad_recv_wc);
3811 }
3812 }
3813
cm_init_qp_init_attr(struct cm_id_private * cm_id_priv,struct ib_qp_attr * qp_attr,int * qp_attr_mask)3814 static int cm_init_qp_init_attr(struct cm_id_private *cm_id_priv,
3815 struct ib_qp_attr *qp_attr,
3816 int *qp_attr_mask)
3817 {
3818 unsigned long flags;
3819 int ret;
3820
3821 spin_lock_irqsave(&cm_id_priv->lock, flags);
3822 switch (cm_id_priv->id.state) {
3823 case IB_CM_REQ_SENT:
3824 case IB_CM_MRA_REQ_RCVD:
3825 case IB_CM_REQ_RCVD:
3826 case IB_CM_MRA_REQ_SENT:
3827 case IB_CM_REP_RCVD:
3828 case IB_CM_MRA_REP_SENT:
3829 case IB_CM_REP_SENT:
3830 case IB_CM_MRA_REP_RCVD:
3831 case IB_CM_ESTABLISHED:
3832 *qp_attr_mask = IB_QP_STATE | IB_QP_ACCESS_FLAGS |
3833 IB_QP_PKEY_INDEX | IB_QP_PORT;
3834 qp_attr->qp_access_flags = IB_ACCESS_REMOTE_WRITE;
3835 if (cm_id_priv->responder_resources)
3836 qp_attr->qp_access_flags |= IB_ACCESS_REMOTE_READ |
3837 IB_ACCESS_REMOTE_ATOMIC;
3838 qp_attr->pkey_index = cm_id_priv->av.pkey_index;
3839 qp_attr->port_num = cm_id_priv->av.port->port_num;
3840 ret = 0;
3841 break;
3842 default:
3843 ret = -EINVAL;
3844 break;
3845 }
3846 spin_unlock_irqrestore(&cm_id_priv->lock, flags);
3847 return ret;
3848 }
3849
cm_init_qp_rtr_attr(struct cm_id_private * cm_id_priv,struct ib_qp_attr * qp_attr,int * qp_attr_mask)3850 static int cm_init_qp_rtr_attr(struct cm_id_private *cm_id_priv,
3851 struct ib_qp_attr *qp_attr,
3852 int *qp_attr_mask)
3853 {
3854 unsigned long flags;
3855 int ret;
3856
3857 spin_lock_irqsave(&cm_id_priv->lock, flags);
3858 switch (cm_id_priv->id.state) {
3859 case IB_CM_REQ_RCVD:
3860 case IB_CM_MRA_REQ_SENT:
3861 case IB_CM_REP_RCVD:
3862 case IB_CM_MRA_REP_SENT:
3863 case IB_CM_REP_SENT:
3864 case IB_CM_MRA_REP_RCVD:
3865 case IB_CM_ESTABLISHED:
3866 *qp_attr_mask = IB_QP_STATE | IB_QP_AV | IB_QP_PATH_MTU |
3867 IB_QP_DEST_QPN | IB_QP_RQ_PSN;
3868 qp_attr->ah_attr = cm_id_priv->av.ah_attr;
3869 qp_attr->path_mtu = cm_id_priv->path_mtu;
3870 qp_attr->dest_qp_num = be32_to_cpu(cm_id_priv->remote_qpn);
3871 qp_attr->rq_psn = be32_to_cpu(cm_id_priv->rq_psn);
3872 if (cm_id_priv->qp_type == IB_QPT_RC ||
3873 cm_id_priv->qp_type == IB_QPT_XRC_TGT) {
3874 *qp_attr_mask |= IB_QP_MAX_DEST_RD_ATOMIC |
3875 IB_QP_MIN_RNR_TIMER;
3876 qp_attr->max_dest_rd_atomic =
3877 cm_id_priv->responder_resources;
3878 qp_attr->min_rnr_timer = 0;
3879 }
3880 if (cm_id_priv->alt_av.ah_attr.dlid) {
3881 *qp_attr_mask |= IB_QP_ALT_PATH;
3882 qp_attr->alt_port_num = cm_id_priv->alt_av.port->port_num;
3883 qp_attr->alt_pkey_index = cm_id_priv->alt_av.pkey_index;
3884 qp_attr->alt_timeout = cm_id_priv->alt_av.timeout;
3885 qp_attr->alt_ah_attr = cm_id_priv->alt_av.ah_attr;
3886 }
3887 ret = 0;
3888 break;
3889 default:
3890 ret = -EINVAL;
3891 break;
3892 }
3893 spin_unlock_irqrestore(&cm_id_priv->lock, flags);
3894 return ret;
3895 }
3896
cm_init_qp_rts_attr(struct cm_id_private * cm_id_priv,struct ib_qp_attr * qp_attr,int * qp_attr_mask)3897 static int cm_init_qp_rts_attr(struct cm_id_private *cm_id_priv,
3898 struct ib_qp_attr *qp_attr,
3899 int *qp_attr_mask)
3900 {
3901 unsigned long flags;
3902 int ret;
3903
3904 spin_lock_irqsave(&cm_id_priv->lock, flags);
3905 switch (cm_id_priv->id.state) {
3906 /* Allow transition to RTS before sending REP */
3907 case IB_CM_REQ_RCVD:
3908 case IB_CM_MRA_REQ_SENT:
3909
3910 case IB_CM_REP_RCVD:
3911 case IB_CM_MRA_REP_SENT:
3912 case IB_CM_REP_SENT:
3913 case IB_CM_MRA_REP_RCVD:
3914 case IB_CM_ESTABLISHED:
3915 if (cm_id_priv->id.lap_state == IB_CM_LAP_UNINIT) {
3916 *qp_attr_mask = IB_QP_STATE | IB_QP_SQ_PSN;
3917 qp_attr->sq_psn = be32_to_cpu(cm_id_priv->sq_psn);
3918 switch (cm_id_priv->qp_type) {
3919 case IB_QPT_RC:
3920 case IB_QPT_XRC_INI:
3921 *qp_attr_mask |= IB_QP_RETRY_CNT | IB_QP_RNR_RETRY |
3922 IB_QP_MAX_QP_RD_ATOMIC;
3923 qp_attr->retry_cnt = cm_id_priv->retry_count;
3924 qp_attr->rnr_retry = cm_id_priv->rnr_retry_count;
3925 qp_attr->max_rd_atomic = cm_id_priv->initiator_depth;
3926 /* fall through */
3927 case IB_QPT_XRC_TGT:
3928 *qp_attr_mask |= IB_QP_TIMEOUT;
3929 qp_attr->timeout = cm_id_priv->av.timeout;
3930 break;
3931 default:
3932 break;
3933 }
3934 if (cm_id_priv->alt_av.ah_attr.dlid) {
3935 *qp_attr_mask |= IB_QP_PATH_MIG_STATE;
3936 qp_attr->path_mig_state = IB_MIG_REARM;
3937 }
3938 } else {
3939 *qp_attr_mask = IB_QP_ALT_PATH | IB_QP_PATH_MIG_STATE;
3940 qp_attr->alt_port_num = cm_id_priv->alt_av.port->port_num;
3941 qp_attr->alt_pkey_index = cm_id_priv->alt_av.pkey_index;
3942 qp_attr->alt_timeout = cm_id_priv->alt_av.timeout;
3943 qp_attr->alt_ah_attr = cm_id_priv->alt_av.ah_attr;
3944 qp_attr->path_mig_state = IB_MIG_REARM;
3945 }
3946 ret = 0;
3947 break;
3948 default:
3949 ret = -EINVAL;
3950 break;
3951 }
3952 spin_unlock_irqrestore(&cm_id_priv->lock, flags);
3953 return ret;
3954 }
3955
ib_cm_init_qp_attr(struct ib_cm_id * cm_id,struct ib_qp_attr * qp_attr,int * qp_attr_mask)3956 int ib_cm_init_qp_attr(struct ib_cm_id *cm_id,
3957 struct ib_qp_attr *qp_attr,
3958 int *qp_attr_mask)
3959 {
3960 struct cm_id_private *cm_id_priv;
3961 int ret;
3962
3963 cm_id_priv = container_of(cm_id, struct cm_id_private, id);
3964 switch (qp_attr->qp_state) {
3965 case IB_QPS_INIT:
3966 ret = cm_init_qp_init_attr(cm_id_priv, qp_attr, qp_attr_mask);
3967 break;
3968 case IB_QPS_RTR:
3969 ret = cm_init_qp_rtr_attr(cm_id_priv, qp_attr, qp_attr_mask);
3970 break;
3971 case IB_QPS_RTS:
3972 ret = cm_init_qp_rts_attr(cm_id_priv, qp_attr, qp_attr_mask);
3973 break;
3974 default:
3975 ret = -EINVAL;
3976 break;
3977 }
3978 return ret;
3979 }
3980 EXPORT_SYMBOL(ib_cm_init_qp_attr);
3981
cm_show_counter(struct kobject * obj,struct attribute * attr,char * buf)3982 static ssize_t cm_show_counter(struct kobject *obj, struct attribute *attr,
3983 char *buf)
3984 {
3985 struct cm_counter_group *group;
3986 struct cm_counter_attribute *cm_attr;
3987
3988 group = container_of(obj, struct cm_counter_group, obj);
3989 cm_attr = container_of(attr, struct cm_counter_attribute, attr);
3990
3991 return sprintf(buf, "%ld\n",
3992 atomic_long_read(&group->counter[cm_attr->index]));
3993 }
3994
3995 static const struct sysfs_ops cm_counter_ops = {
3996 .show = cm_show_counter
3997 };
3998
3999 static struct kobj_type cm_counter_obj_type = {
4000 .sysfs_ops = &cm_counter_ops,
4001 .default_attrs = cm_counter_default_attrs
4002 };
4003
cm_devnode(struct device * dev,umode_t * mode)4004 static char *cm_devnode(struct device *dev, umode_t *mode)
4005 {
4006 if (mode)
4007 *mode = 0666;
4008 return kasprintf(GFP_KERNEL, "infiniband/%s", dev_name(dev));
4009 }
4010
4011 struct class cm_class = {
4012 .owner = THIS_MODULE,
4013 .name = "infiniband_cm",
4014 .devnode = cm_devnode,
4015 };
4016 EXPORT_SYMBOL(cm_class);
4017
cm_create_port_fs(struct cm_port * port)4018 static int cm_create_port_fs(struct cm_port *port)
4019 {
4020 int i, ret;
4021
4022 for (i = 0; i < CM_COUNTER_GROUPS; i++) {
4023 ret = ib_port_register_module_stat(port->cm_dev->ib_device,
4024 port->port_num,
4025 &port->counter_group[i].obj,
4026 &cm_counter_obj_type,
4027 counter_group_names[i]);
4028 if (ret)
4029 goto error;
4030 }
4031
4032 return 0;
4033
4034 error:
4035 while (i--)
4036 ib_port_unregister_module_stat(&port->counter_group[i].obj);
4037 return ret;
4038
4039 }
4040
cm_remove_port_fs(struct cm_port * port)4041 static void cm_remove_port_fs(struct cm_port *port)
4042 {
4043 int i;
4044
4045 for (i = 0; i < CM_COUNTER_GROUPS; i++)
4046 ib_port_unregister_module_stat(&port->counter_group[i].obj);
4047
4048 }
4049
cm_add_one(struct ib_device * ib_device)4050 static void cm_add_one(struct ib_device *ib_device)
4051 {
4052 struct cm_device *cm_dev;
4053 struct cm_port *port;
4054 struct ib_mad_reg_req reg_req = {
4055 .mgmt_class = IB_MGMT_CLASS_CM,
4056 .mgmt_class_version = IB_CM_CLASS_VERSION,
4057 };
4058 struct ib_port_modify port_modify = {
4059 .set_port_cap_mask = IB_PORT_CM_SUP
4060 };
4061 unsigned long flags;
4062 int ret;
4063 int count = 0;
4064 u8 i;
4065
4066 cm_dev = kzalloc(sizeof(*cm_dev) + sizeof(*port) *
4067 ib_device->phys_port_cnt, GFP_KERNEL);
4068 if (!cm_dev)
4069 return;
4070
4071 cm_dev->ib_device = ib_device;
4072 cm_dev->ack_delay = ib_device->attrs.local_ca_ack_delay;
4073 cm_dev->going_down = 0;
4074
4075 set_bit(IB_MGMT_METHOD_SEND, reg_req.method_mask);
4076 for (i = 1; i <= ib_device->phys_port_cnt; i++) {
4077 if (!rdma_cap_ib_cm(ib_device, i))
4078 continue;
4079
4080 port = kzalloc(sizeof *port, GFP_KERNEL);
4081 if (!port)
4082 goto error1;
4083
4084 cm_dev->port[i-1] = port;
4085 port->cm_dev = cm_dev;
4086 port->port_num = i;
4087
4088 INIT_LIST_HEAD(&port->cm_priv_prim_list);
4089 INIT_LIST_HEAD(&port->cm_priv_altr_list);
4090
4091 ret = cm_create_port_fs(port);
4092 if (ret)
4093 goto error1;
4094
4095 port->mad_agent = ib_register_mad_agent(ib_device, i,
4096 IB_QPT_GSI,
4097 ®_req,
4098 0,
4099 cm_send_handler,
4100 cm_recv_handler,
4101 port,
4102 0);
4103 if (IS_ERR(port->mad_agent))
4104 goto error2;
4105
4106 ret = ib_modify_port(ib_device, i, 0, &port_modify);
4107 if (ret)
4108 goto error3;
4109
4110 count++;
4111 }
4112
4113 if (!count)
4114 goto free;
4115
4116 ib_set_client_data(ib_device, &cm_client, cm_dev);
4117
4118 write_lock_irqsave(&cm.device_lock, flags);
4119 list_add_tail(&cm_dev->list, &cm.device_list);
4120 write_unlock_irqrestore(&cm.device_lock, flags);
4121 return;
4122
4123 error3:
4124 ib_unregister_mad_agent(port->mad_agent);
4125 error2:
4126 cm_remove_port_fs(port);
4127 error1:
4128 port_modify.set_port_cap_mask = 0;
4129 port_modify.clr_port_cap_mask = IB_PORT_CM_SUP;
4130 kfree(port);
4131 while (--i) {
4132 if (!rdma_cap_ib_cm(ib_device, i))
4133 continue;
4134
4135 port = cm_dev->port[i-1];
4136 ib_modify_port(ib_device, port->port_num, 0, &port_modify);
4137 ib_unregister_mad_agent(port->mad_agent);
4138 cm_remove_port_fs(port);
4139 kfree(port);
4140 }
4141 free:
4142 kfree(cm_dev);
4143 }
4144
cm_remove_one(struct ib_device * ib_device,void * client_data)4145 static void cm_remove_one(struct ib_device *ib_device, void *client_data)
4146 {
4147 struct cm_device *cm_dev = client_data;
4148 struct cm_port *port;
4149 struct cm_id_private *cm_id_priv;
4150 struct ib_mad_agent *cur_mad_agent;
4151 struct ib_port_modify port_modify = {
4152 .clr_port_cap_mask = IB_PORT_CM_SUP
4153 };
4154 unsigned long flags;
4155 int i;
4156
4157 if (!cm_dev)
4158 return;
4159
4160 write_lock_irqsave(&cm.device_lock, flags);
4161 list_del(&cm_dev->list);
4162 write_unlock_irqrestore(&cm.device_lock, flags);
4163
4164 spin_lock_irq(&cm.lock);
4165 cm_dev->going_down = 1;
4166 spin_unlock_irq(&cm.lock);
4167
4168 for (i = 1; i <= ib_device->phys_port_cnt; i++) {
4169 if (!rdma_cap_ib_cm(ib_device, i))
4170 continue;
4171
4172 port = cm_dev->port[i-1];
4173 ib_modify_port(ib_device, port->port_num, 0, &port_modify);
4174 /* Mark all the cm_id's as not valid */
4175 spin_lock_irq(&cm.lock);
4176 list_for_each_entry(cm_id_priv, &port->cm_priv_altr_list, altr_list)
4177 cm_id_priv->altr_send_port_not_ready = 1;
4178 list_for_each_entry(cm_id_priv, &port->cm_priv_prim_list, prim_list)
4179 cm_id_priv->prim_send_port_not_ready = 1;
4180 spin_unlock_irq(&cm.lock);
4181 /*
4182 * We flush the queue here after the going_down set, this
4183 * verify that no new works will be queued in the recv handler,
4184 * after that we can call the unregister_mad_agent
4185 */
4186 flush_workqueue(cm.wq);
4187 spin_lock_irq(&cm.state_lock);
4188 cur_mad_agent = port->mad_agent;
4189 port->mad_agent = NULL;
4190 spin_unlock_irq(&cm.state_lock);
4191 ib_unregister_mad_agent(cur_mad_agent);
4192 cm_remove_port_fs(port);
4193 kfree(port);
4194 }
4195
4196 kfree(cm_dev);
4197 }
4198
ib_cm_init(void)4199 static int __init ib_cm_init(void)
4200 {
4201 int ret;
4202
4203 memset(&cm, 0, sizeof cm);
4204 INIT_LIST_HEAD(&cm.device_list);
4205 rwlock_init(&cm.device_lock);
4206 spin_lock_init(&cm.lock);
4207 spin_lock_init(&cm.state_lock);
4208 cm.listen_service_table = RB_ROOT;
4209 cm.listen_service_id = be64_to_cpu(IB_CM_ASSIGN_SERVICE_ID);
4210 cm.remote_id_table = RB_ROOT;
4211 cm.remote_qp_table = RB_ROOT;
4212 cm.remote_sidr_table = RB_ROOT;
4213 idr_init(&cm.local_id_table);
4214 get_random_bytes(&cm.random_id_operand, sizeof cm.random_id_operand);
4215 INIT_LIST_HEAD(&cm.timewait_list);
4216
4217 ret = class_register(&cm_class);
4218 if (ret) {
4219 ret = -ENOMEM;
4220 goto error1;
4221 }
4222
4223 cm.wq = create_workqueue("ib_cm");
4224 if (!cm.wq) {
4225 ret = -ENOMEM;
4226 goto error2;
4227 }
4228
4229 ret = ib_register_client(&cm_client);
4230 if (ret)
4231 goto error3;
4232
4233 return 0;
4234 error3:
4235 destroy_workqueue(cm.wq);
4236 error2:
4237 class_unregister(&cm_class);
4238 error1:
4239 idr_destroy(&cm.local_id_table);
4240 return ret;
4241 }
4242
ib_cm_cleanup(void)4243 static void __exit ib_cm_cleanup(void)
4244 {
4245 struct cm_timewait_info *timewait_info, *tmp;
4246
4247 spin_lock_irq(&cm.lock);
4248 list_for_each_entry(timewait_info, &cm.timewait_list, list)
4249 cancel_delayed_work(&timewait_info->work.work);
4250 spin_unlock_irq(&cm.lock);
4251
4252 ib_unregister_client(&cm_client);
4253 destroy_workqueue(cm.wq);
4254
4255 list_for_each_entry_safe(timewait_info, tmp, &cm.timewait_list, list) {
4256 cancel_delayed_work_sync(&timewait_info->work.work);
4257 list_del(&timewait_info->list);
4258 kfree(timewait_info);
4259 }
4260
4261 class_unregister(&cm_class);
4262 idr_destroy(&cm.local_id_table);
4263 }
4264
4265 module_init_order(ib_cm_init, SI_ORDER_SECOND);
4266 module_exit_order(ib_cm_cleanup, SI_ORDER_SECOND);
4267
4268