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