ib_mad_rmpp.c revision 331785
1/*- 2 * SPDX-License-Identifier: BSD-2-Clause OR GPL-2.0 3 * 4 * Copyright (c) 2005 Intel Inc. All rights reserved. 5 * Copyright (c) 2005-2006 Voltaire, Inc. All rights reserved. 6 * Copyright (c) 2014 Intel Corporation. All rights reserved. 7 * 8 * This software is available to you under a choice of one of two 9 * licenses. You may choose to be licensed under the terms of the GNU 10 * General Public License (GPL) Version 2, available from the file 11 * COPYING in the main directory of this source tree, or the 12 * OpenIB.org BSD license below: 13 * 14 * Redistribution and use in source and binary forms, with or 15 * without modification, are permitted provided that the following 16 * conditions are met: 17 * 18 * - Redistributions of source code must retain the above 19 * copyright notice, this list of conditions and the following 20 * disclaimer. 21 * 22 * - Redistributions in binary form must reproduce the above 23 * copyright notice, this list of conditions and the following 24 * disclaimer in the documentation and/or other materials 25 * provided with the distribution. 26 * 27 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, 28 * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF 29 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND 30 * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS 31 * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN 32 * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN 33 * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE 34 * SOFTWARE. 35 * 36 * $FreeBSD: stable/11/sys/ofed/drivers/infiniband/core/ib_mad_rmpp.c 331785 2018-03-30 18:37:51Z hselasky $ 37 */ 38 39#include <linux/slab.h> 40 41#include "mad_priv.h" 42#include "mad_rmpp.h" 43 44enum rmpp_state { 45 RMPP_STATE_ACTIVE, 46 RMPP_STATE_TIMEOUT, 47 RMPP_STATE_COMPLETE, 48 RMPP_STATE_CANCELING 49}; 50 51struct mad_rmpp_recv { 52 struct ib_mad_agent_private *agent; 53 struct list_head list; 54 struct delayed_work timeout_work; 55 struct delayed_work cleanup_work; 56 struct completion comp; 57 enum rmpp_state state; 58 spinlock_t lock; 59 atomic_t refcount; 60 61 struct ib_ah *ah; 62 struct ib_mad_recv_wc *rmpp_wc; 63 struct ib_mad_recv_buf *cur_seg_buf; 64 int last_ack; 65 int seg_num; 66 int newwin; 67 int repwin; 68 69 __be64 tid; 70 u32 src_qp; 71 u16 slid; 72 u8 mgmt_class; 73 u8 class_version; 74 u8 method; 75 u8 base_version; 76}; 77 78static inline void deref_rmpp_recv(struct mad_rmpp_recv *rmpp_recv) 79{ 80 if (atomic_dec_and_test(&rmpp_recv->refcount)) 81 complete(&rmpp_recv->comp); 82} 83 84static void destroy_rmpp_recv(struct mad_rmpp_recv *rmpp_recv) 85{ 86 deref_rmpp_recv(rmpp_recv); 87 wait_for_completion(&rmpp_recv->comp); 88 ib_destroy_ah(rmpp_recv->ah); 89 kfree(rmpp_recv); 90} 91 92void ib_cancel_rmpp_recvs(struct ib_mad_agent_private *agent) 93{ 94 struct mad_rmpp_recv *rmpp_recv, *temp_rmpp_recv; 95 unsigned long flags; 96 97 spin_lock_irqsave(&agent->lock, flags); 98 list_for_each_entry(rmpp_recv, &agent->rmpp_list, list) { 99 if (rmpp_recv->state != RMPP_STATE_COMPLETE) 100 ib_free_recv_mad(rmpp_recv->rmpp_wc); 101 rmpp_recv->state = RMPP_STATE_CANCELING; 102 } 103 spin_unlock_irqrestore(&agent->lock, flags); 104 105 list_for_each_entry(rmpp_recv, &agent->rmpp_list, list) { 106 cancel_delayed_work_sync(&rmpp_recv->timeout_work); 107 cancel_delayed_work_sync(&rmpp_recv->cleanup_work); 108 } 109 110 flush_workqueue(agent->qp_info->port_priv->wq); 111 112 list_for_each_entry_safe(rmpp_recv, temp_rmpp_recv, 113 &agent->rmpp_list, list) { 114 list_del(&rmpp_recv->list); 115 destroy_rmpp_recv(rmpp_recv); 116 } 117} 118 119static void format_ack(struct ib_mad_send_buf *msg, 120 struct ib_rmpp_mad *data, 121 struct mad_rmpp_recv *rmpp_recv) 122{ 123 struct ib_rmpp_mad *ack = msg->mad; 124 unsigned long flags; 125 126 memcpy(ack, &data->mad_hdr, msg->hdr_len); 127 128 ack->mad_hdr.method ^= IB_MGMT_METHOD_RESP; 129 ack->rmpp_hdr.rmpp_type = IB_MGMT_RMPP_TYPE_ACK; 130 ib_set_rmpp_flags(&ack->rmpp_hdr, IB_MGMT_RMPP_FLAG_ACTIVE); 131 132 spin_lock_irqsave(&rmpp_recv->lock, flags); 133 rmpp_recv->last_ack = rmpp_recv->seg_num; 134 ack->rmpp_hdr.seg_num = cpu_to_be32(rmpp_recv->seg_num); 135 ack->rmpp_hdr.paylen_newwin = cpu_to_be32(rmpp_recv->newwin); 136 spin_unlock_irqrestore(&rmpp_recv->lock, flags); 137} 138 139static void ack_recv(struct mad_rmpp_recv *rmpp_recv, 140 struct ib_mad_recv_wc *recv_wc) 141{ 142 struct ib_mad_send_buf *msg; 143 int ret, hdr_len; 144 145 hdr_len = ib_get_mad_data_offset(recv_wc->recv_buf.mad->mad_hdr.mgmt_class); 146 msg = ib_create_send_mad(&rmpp_recv->agent->agent, recv_wc->wc->src_qp, 147 recv_wc->wc->pkey_index, 1, hdr_len, 148 0, GFP_KERNEL, 149 IB_MGMT_BASE_VERSION); 150 if (IS_ERR(msg)) 151 return; 152 153 format_ack(msg, (struct ib_rmpp_mad *) recv_wc->recv_buf.mad, rmpp_recv); 154 msg->ah = rmpp_recv->ah; 155 ret = ib_post_send_mad(msg, NULL); 156 if (ret) 157 ib_free_send_mad(msg); 158} 159 160static struct ib_mad_send_buf *alloc_response_msg(struct ib_mad_agent *agent, 161 struct ib_mad_recv_wc *recv_wc) 162{ 163 struct ib_mad_send_buf *msg; 164 struct ib_ah *ah; 165 int hdr_len; 166 167 ah = ib_create_ah_from_wc(agent->qp->pd, recv_wc->wc, 168 recv_wc->recv_buf.grh, agent->port_num); 169 if (IS_ERR(ah)) 170 return (void *) ah; 171 172 hdr_len = ib_get_mad_data_offset(recv_wc->recv_buf.mad->mad_hdr.mgmt_class); 173 msg = ib_create_send_mad(agent, recv_wc->wc->src_qp, 174 recv_wc->wc->pkey_index, 1, 175 hdr_len, 0, GFP_KERNEL, 176 IB_MGMT_BASE_VERSION); 177 if (IS_ERR(msg)) 178 ib_destroy_ah(ah); 179 else { 180 msg->ah = ah; 181 msg->context[0] = ah; 182 } 183 184 return msg; 185} 186 187static void ack_ds_ack(struct ib_mad_agent_private *agent, 188 struct ib_mad_recv_wc *recv_wc) 189{ 190 struct ib_mad_send_buf *msg; 191 struct ib_rmpp_mad *rmpp_mad; 192 int ret; 193 194 msg = alloc_response_msg(&agent->agent, recv_wc); 195 if (IS_ERR(msg)) 196 return; 197 198 rmpp_mad = msg->mad; 199 memcpy(rmpp_mad, recv_wc->recv_buf.mad, msg->hdr_len); 200 201 rmpp_mad->mad_hdr.method ^= IB_MGMT_METHOD_RESP; 202 ib_set_rmpp_flags(&rmpp_mad->rmpp_hdr, IB_MGMT_RMPP_FLAG_ACTIVE); 203 rmpp_mad->rmpp_hdr.seg_num = 0; 204 rmpp_mad->rmpp_hdr.paylen_newwin = cpu_to_be32(1); 205 206 ret = ib_post_send_mad(msg, NULL); 207 if (ret) { 208 ib_destroy_ah(msg->ah); 209 ib_free_send_mad(msg); 210 } 211} 212 213void ib_rmpp_send_handler(struct ib_mad_send_wc *mad_send_wc) 214{ 215 if (mad_send_wc->send_buf->context[0] == mad_send_wc->send_buf->ah) 216 ib_destroy_ah(mad_send_wc->send_buf->ah); 217 ib_free_send_mad(mad_send_wc->send_buf); 218} 219 220static void nack_recv(struct ib_mad_agent_private *agent, 221 struct ib_mad_recv_wc *recv_wc, u8 rmpp_status) 222{ 223 struct ib_mad_send_buf *msg; 224 struct ib_rmpp_mad *rmpp_mad; 225 int ret; 226 227 msg = alloc_response_msg(&agent->agent, recv_wc); 228 if (IS_ERR(msg)) 229 return; 230 231 rmpp_mad = msg->mad; 232 memcpy(rmpp_mad, recv_wc->recv_buf.mad, msg->hdr_len); 233 234 rmpp_mad->mad_hdr.method ^= IB_MGMT_METHOD_RESP; 235 rmpp_mad->rmpp_hdr.rmpp_version = IB_MGMT_RMPP_VERSION; 236 rmpp_mad->rmpp_hdr.rmpp_type = IB_MGMT_RMPP_TYPE_ABORT; 237 ib_set_rmpp_flags(&rmpp_mad->rmpp_hdr, IB_MGMT_RMPP_FLAG_ACTIVE); 238 rmpp_mad->rmpp_hdr.rmpp_status = rmpp_status; 239 rmpp_mad->rmpp_hdr.seg_num = 0; 240 rmpp_mad->rmpp_hdr.paylen_newwin = 0; 241 242 ret = ib_post_send_mad(msg, NULL); 243 if (ret) { 244 ib_destroy_ah(msg->ah); 245 ib_free_send_mad(msg); 246 } 247} 248 249static void recv_timeout_handler(struct work_struct *work) 250{ 251 struct mad_rmpp_recv *rmpp_recv = 252 container_of(work, struct mad_rmpp_recv, timeout_work.work); 253 struct ib_mad_recv_wc *rmpp_wc; 254 unsigned long flags; 255 256 spin_lock_irqsave(&rmpp_recv->agent->lock, flags); 257 if (rmpp_recv->state != RMPP_STATE_ACTIVE) { 258 spin_unlock_irqrestore(&rmpp_recv->agent->lock, flags); 259 return; 260 } 261 rmpp_recv->state = RMPP_STATE_TIMEOUT; 262 list_del(&rmpp_recv->list); 263 spin_unlock_irqrestore(&rmpp_recv->agent->lock, flags); 264 265 rmpp_wc = rmpp_recv->rmpp_wc; 266 nack_recv(rmpp_recv->agent, rmpp_wc, IB_MGMT_RMPP_STATUS_T2L); 267 destroy_rmpp_recv(rmpp_recv); 268 ib_free_recv_mad(rmpp_wc); 269} 270 271static void recv_cleanup_handler(struct work_struct *work) 272{ 273 struct mad_rmpp_recv *rmpp_recv = 274 container_of(work, struct mad_rmpp_recv, cleanup_work.work); 275 unsigned long flags; 276 277 spin_lock_irqsave(&rmpp_recv->agent->lock, flags); 278 if (rmpp_recv->state == RMPP_STATE_CANCELING) { 279 spin_unlock_irqrestore(&rmpp_recv->agent->lock, flags); 280 return; 281 } 282 list_del(&rmpp_recv->list); 283 spin_unlock_irqrestore(&rmpp_recv->agent->lock, flags); 284 destroy_rmpp_recv(rmpp_recv); 285} 286 287static struct mad_rmpp_recv * 288create_rmpp_recv(struct ib_mad_agent_private *agent, 289 struct ib_mad_recv_wc *mad_recv_wc) 290{ 291 struct mad_rmpp_recv *rmpp_recv; 292 struct ib_mad_hdr *mad_hdr; 293 294 rmpp_recv = kmalloc(sizeof *rmpp_recv, GFP_KERNEL); 295 if (!rmpp_recv) 296 return NULL; 297 298 rmpp_recv->ah = ib_create_ah_from_wc(agent->agent.qp->pd, 299 mad_recv_wc->wc, 300 mad_recv_wc->recv_buf.grh, 301 agent->agent.port_num); 302 if (IS_ERR(rmpp_recv->ah)) 303 goto error; 304 305 rmpp_recv->agent = agent; 306 init_completion(&rmpp_recv->comp); 307 INIT_DELAYED_WORK(&rmpp_recv->timeout_work, recv_timeout_handler); 308 INIT_DELAYED_WORK(&rmpp_recv->cleanup_work, recv_cleanup_handler); 309 spin_lock_init(&rmpp_recv->lock); 310 rmpp_recv->state = RMPP_STATE_ACTIVE; 311 atomic_set(&rmpp_recv->refcount, 1); 312 313 rmpp_recv->rmpp_wc = mad_recv_wc; 314 rmpp_recv->cur_seg_buf = &mad_recv_wc->recv_buf; 315 rmpp_recv->newwin = 1; 316 rmpp_recv->seg_num = 1; 317 rmpp_recv->last_ack = 0; 318 rmpp_recv->repwin = 1; 319 320 mad_hdr = &mad_recv_wc->recv_buf.mad->mad_hdr; 321 rmpp_recv->tid = mad_hdr->tid; 322 rmpp_recv->src_qp = mad_recv_wc->wc->src_qp; 323 rmpp_recv->slid = mad_recv_wc->wc->slid; 324 rmpp_recv->mgmt_class = mad_hdr->mgmt_class; 325 rmpp_recv->class_version = mad_hdr->class_version; 326 rmpp_recv->method = mad_hdr->method; 327 rmpp_recv->base_version = mad_hdr->base_version; 328 return rmpp_recv; 329 330error: kfree(rmpp_recv); 331 return NULL; 332} 333 334static struct mad_rmpp_recv * 335find_rmpp_recv(struct ib_mad_agent_private *agent, 336 struct ib_mad_recv_wc *mad_recv_wc) 337{ 338 struct mad_rmpp_recv *rmpp_recv; 339 struct ib_mad_hdr *mad_hdr = &mad_recv_wc->recv_buf.mad->mad_hdr; 340 341 list_for_each_entry(rmpp_recv, &agent->rmpp_list, list) { 342 if (rmpp_recv->tid == mad_hdr->tid && 343 rmpp_recv->src_qp == mad_recv_wc->wc->src_qp && 344 rmpp_recv->slid == mad_recv_wc->wc->slid && 345 rmpp_recv->mgmt_class == mad_hdr->mgmt_class && 346 rmpp_recv->class_version == mad_hdr->class_version && 347 rmpp_recv->method == mad_hdr->method) 348 return rmpp_recv; 349 } 350 return NULL; 351} 352 353static struct mad_rmpp_recv * 354acquire_rmpp_recv(struct ib_mad_agent_private *agent, 355 struct ib_mad_recv_wc *mad_recv_wc) 356{ 357 struct mad_rmpp_recv *rmpp_recv; 358 unsigned long flags; 359 360 spin_lock_irqsave(&agent->lock, flags); 361 rmpp_recv = find_rmpp_recv(agent, mad_recv_wc); 362 if (rmpp_recv) 363 atomic_inc(&rmpp_recv->refcount); 364 spin_unlock_irqrestore(&agent->lock, flags); 365 return rmpp_recv; 366} 367 368static struct mad_rmpp_recv * 369insert_rmpp_recv(struct ib_mad_agent_private *agent, 370 struct mad_rmpp_recv *rmpp_recv) 371{ 372 struct mad_rmpp_recv *cur_rmpp_recv; 373 374 cur_rmpp_recv = find_rmpp_recv(agent, rmpp_recv->rmpp_wc); 375 if (!cur_rmpp_recv) 376 list_add_tail(&rmpp_recv->list, &agent->rmpp_list); 377 378 return cur_rmpp_recv; 379} 380 381static inline int get_last_flag(struct ib_mad_recv_buf *seg) 382{ 383 struct ib_rmpp_mad *rmpp_mad; 384 385 rmpp_mad = (struct ib_rmpp_mad *) seg->mad; 386 return ib_get_rmpp_flags(&rmpp_mad->rmpp_hdr) & IB_MGMT_RMPP_FLAG_LAST; 387} 388 389static inline int get_seg_num(struct ib_mad_recv_buf *seg) 390{ 391 struct ib_rmpp_mad *rmpp_mad; 392 393 rmpp_mad = (struct ib_rmpp_mad *) seg->mad; 394 return be32_to_cpu(rmpp_mad->rmpp_hdr.seg_num); 395} 396 397static inline struct ib_mad_recv_buf * get_next_seg(struct list_head *rmpp_list, 398 struct ib_mad_recv_buf *seg) 399{ 400 if (seg->list.next == rmpp_list) 401 return NULL; 402 403 return container_of(seg->list.next, struct ib_mad_recv_buf, list); 404} 405 406static inline int window_size(struct ib_mad_agent_private *agent) 407{ 408 return max(agent->qp_info->recv_queue.max_active >> 3, 1); 409} 410 411static struct ib_mad_recv_buf * find_seg_location(struct list_head *rmpp_list, 412 int seg_num) 413{ 414 struct ib_mad_recv_buf *seg_buf; 415 int cur_seg_num; 416 417 list_for_each_entry_reverse(seg_buf, rmpp_list, list) { 418 cur_seg_num = get_seg_num(seg_buf); 419 if (seg_num > cur_seg_num) 420 return seg_buf; 421 if (seg_num == cur_seg_num) 422 break; 423 } 424 return NULL; 425} 426 427static void update_seg_num(struct mad_rmpp_recv *rmpp_recv, 428 struct ib_mad_recv_buf *new_buf) 429{ 430 struct list_head *rmpp_list = &rmpp_recv->rmpp_wc->rmpp_list; 431 432 while (new_buf && (get_seg_num(new_buf) == rmpp_recv->seg_num + 1)) { 433 rmpp_recv->cur_seg_buf = new_buf; 434 rmpp_recv->seg_num++; 435 new_buf = get_next_seg(rmpp_list, new_buf); 436 } 437} 438 439static inline int get_mad_len(struct mad_rmpp_recv *rmpp_recv) 440{ 441 struct ib_rmpp_mad *rmpp_mad; 442 int hdr_size, data_size, pad; 443 bool opa = rdma_cap_opa_mad(rmpp_recv->agent->qp_info->port_priv->device, 444 rmpp_recv->agent->qp_info->port_priv->port_num); 445 446 rmpp_mad = (struct ib_rmpp_mad *)rmpp_recv->cur_seg_buf->mad; 447 448 hdr_size = ib_get_mad_data_offset(rmpp_mad->mad_hdr.mgmt_class); 449 if (opa && rmpp_recv->base_version == OPA_MGMT_BASE_VERSION) { 450 data_size = sizeof(struct opa_rmpp_mad) - hdr_size; 451 pad = OPA_MGMT_RMPP_DATA - be32_to_cpu(rmpp_mad->rmpp_hdr.paylen_newwin); 452 if (pad > OPA_MGMT_RMPP_DATA || pad < 0) 453 pad = 0; 454 } else { 455 data_size = sizeof(struct ib_rmpp_mad) - hdr_size; 456 pad = IB_MGMT_RMPP_DATA - be32_to_cpu(rmpp_mad->rmpp_hdr.paylen_newwin); 457 if (pad > IB_MGMT_RMPP_DATA || pad < 0) 458 pad = 0; 459 } 460 461 return hdr_size + rmpp_recv->seg_num * data_size - pad; 462} 463 464static struct ib_mad_recv_wc * complete_rmpp(struct mad_rmpp_recv *rmpp_recv) 465{ 466 struct ib_mad_recv_wc *rmpp_wc; 467 468 ack_recv(rmpp_recv, rmpp_recv->rmpp_wc); 469 if (rmpp_recv->seg_num > 1) 470 cancel_delayed_work(&rmpp_recv->timeout_work); 471 472 rmpp_wc = rmpp_recv->rmpp_wc; 473 rmpp_wc->mad_len = get_mad_len(rmpp_recv); 474 /* 10 seconds until we can find the packet lifetime */ 475 queue_delayed_work(rmpp_recv->agent->qp_info->port_priv->wq, 476 &rmpp_recv->cleanup_work, msecs_to_jiffies(10000)); 477 return rmpp_wc; 478} 479 480static struct ib_mad_recv_wc * 481continue_rmpp(struct ib_mad_agent_private *agent, 482 struct ib_mad_recv_wc *mad_recv_wc) 483{ 484 struct mad_rmpp_recv *rmpp_recv; 485 struct ib_mad_recv_buf *prev_buf; 486 struct ib_mad_recv_wc *done_wc; 487 int seg_num; 488 unsigned long flags; 489 490 rmpp_recv = acquire_rmpp_recv(agent, mad_recv_wc); 491 if (!rmpp_recv) 492 goto drop1; 493 494 seg_num = get_seg_num(&mad_recv_wc->recv_buf); 495 496 spin_lock_irqsave(&rmpp_recv->lock, flags); 497 if ((rmpp_recv->state == RMPP_STATE_TIMEOUT) || 498 (seg_num > rmpp_recv->newwin)) 499 goto drop3; 500 501 if ((seg_num <= rmpp_recv->last_ack) || 502 (rmpp_recv->state == RMPP_STATE_COMPLETE)) { 503 spin_unlock_irqrestore(&rmpp_recv->lock, flags); 504 ack_recv(rmpp_recv, mad_recv_wc); 505 goto drop2; 506 } 507 508 prev_buf = find_seg_location(&rmpp_recv->rmpp_wc->rmpp_list, seg_num); 509 if (!prev_buf) 510 goto drop3; 511 512 done_wc = NULL; 513 list_add(&mad_recv_wc->recv_buf.list, &prev_buf->list); 514 if (rmpp_recv->cur_seg_buf == prev_buf) { 515 update_seg_num(rmpp_recv, &mad_recv_wc->recv_buf); 516 if (get_last_flag(rmpp_recv->cur_seg_buf)) { 517 rmpp_recv->state = RMPP_STATE_COMPLETE; 518 spin_unlock_irqrestore(&rmpp_recv->lock, flags); 519 done_wc = complete_rmpp(rmpp_recv); 520 goto out; 521 } else if (rmpp_recv->seg_num == rmpp_recv->newwin) { 522 rmpp_recv->newwin += window_size(agent); 523 spin_unlock_irqrestore(&rmpp_recv->lock, flags); 524 ack_recv(rmpp_recv, mad_recv_wc); 525 goto out; 526 } 527 } 528 spin_unlock_irqrestore(&rmpp_recv->lock, flags); 529out: 530 deref_rmpp_recv(rmpp_recv); 531 return done_wc; 532 533drop3: spin_unlock_irqrestore(&rmpp_recv->lock, flags); 534drop2: deref_rmpp_recv(rmpp_recv); 535drop1: ib_free_recv_mad(mad_recv_wc); 536 return NULL; 537} 538 539static struct ib_mad_recv_wc * 540start_rmpp(struct ib_mad_agent_private *agent, 541 struct ib_mad_recv_wc *mad_recv_wc) 542{ 543 struct mad_rmpp_recv *rmpp_recv; 544 unsigned long flags; 545 546 rmpp_recv = create_rmpp_recv(agent, mad_recv_wc); 547 if (!rmpp_recv) { 548 ib_free_recv_mad(mad_recv_wc); 549 return NULL; 550 } 551 552 spin_lock_irqsave(&agent->lock, flags); 553 if (insert_rmpp_recv(agent, rmpp_recv)) { 554 spin_unlock_irqrestore(&agent->lock, flags); 555 /* duplicate first MAD */ 556 destroy_rmpp_recv(rmpp_recv); 557 return continue_rmpp(agent, mad_recv_wc); 558 } 559 atomic_inc(&rmpp_recv->refcount); 560 561 if (get_last_flag(&mad_recv_wc->recv_buf)) { 562 rmpp_recv->state = RMPP_STATE_COMPLETE; 563 spin_unlock_irqrestore(&agent->lock, flags); 564 complete_rmpp(rmpp_recv); 565 } else { 566 spin_unlock_irqrestore(&agent->lock, flags); 567 /* 40 seconds until we can find the packet lifetimes */ 568 queue_delayed_work(agent->qp_info->port_priv->wq, 569 &rmpp_recv->timeout_work, 570 msecs_to_jiffies(40000)); 571 rmpp_recv->newwin += window_size(agent); 572 ack_recv(rmpp_recv, mad_recv_wc); 573 mad_recv_wc = NULL; 574 } 575 deref_rmpp_recv(rmpp_recv); 576 return mad_recv_wc; 577} 578 579static int send_next_seg(struct ib_mad_send_wr_private *mad_send_wr) 580{ 581 struct ib_rmpp_mad *rmpp_mad; 582 int timeout; 583 u32 paylen = 0; 584 585 rmpp_mad = mad_send_wr->send_buf.mad; 586 ib_set_rmpp_flags(&rmpp_mad->rmpp_hdr, IB_MGMT_RMPP_FLAG_ACTIVE); 587 rmpp_mad->rmpp_hdr.seg_num = cpu_to_be32(++mad_send_wr->seg_num); 588 589 if (mad_send_wr->seg_num == 1) { 590 rmpp_mad->rmpp_hdr.rmpp_rtime_flags |= IB_MGMT_RMPP_FLAG_FIRST; 591 paylen = (mad_send_wr->send_buf.seg_count * 592 mad_send_wr->send_buf.seg_rmpp_size) - 593 mad_send_wr->pad; 594 } 595 596 if (mad_send_wr->seg_num == mad_send_wr->send_buf.seg_count) { 597 rmpp_mad->rmpp_hdr.rmpp_rtime_flags |= IB_MGMT_RMPP_FLAG_LAST; 598 paylen = mad_send_wr->send_buf.seg_rmpp_size - mad_send_wr->pad; 599 } 600 rmpp_mad->rmpp_hdr.paylen_newwin = cpu_to_be32(paylen); 601 602 /* 2 seconds for an ACK until we can find the packet lifetime */ 603 timeout = mad_send_wr->send_buf.timeout_ms; 604 if (!timeout || timeout > 2000) 605 mad_send_wr->timeout = msecs_to_jiffies(2000); 606 607 return ib_send_mad(mad_send_wr); 608} 609 610static void abort_send(struct ib_mad_agent_private *agent, 611 struct ib_mad_recv_wc *mad_recv_wc, u8 rmpp_status) 612{ 613 struct ib_mad_send_wr_private *mad_send_wr; 614 struct ib_mad_send_wc wc; 615 unsigned long flags; 616 617 spin_lock_irqsave(&agent->lock, flags); 618 mad_send_wr = ib_find_send_mad(agent, mad_recv_wc); 619 if (!mad_send_wr) 620 goto out; /* Unmatched send */ 621 622 if ((mad_send_wr->last_ack == mad_send_wr->send_buf.seg_count) || 623 (!mad_send_wr->timeout) || (mad_send_wr->status != IB_WC_SUCCESS)) 624 goto out; /* Send is already done */ 625 626 ib_mark_mad_done(mad_send_wr); 627 spin_unlock_irqrestore(&agent->lock, flags); 628 629 wc.status = IB_WC_REM_ABORT_ERR; 630 wc.vendor_err = rmpp_status; 631 wc.send_buf = &mad_send_wr->send_buf; 632 ib_mad_complete_send_wr(mad_send_wr, &wc); 633 return; 634out: 635 spin_unlock_irqrestore(&agent->lock, flags); 636} 637 638static inline void adjust_last_ack(struct ib_mad_send_wr_private *wr, 639 int seg_num) 640{ 641 struct list_head *list; 642 643 wr->last_ack = seg_num; 644 list = &wr->last_ack_seg->list; 645 list_for_each_entry(wr->last_ack_seg, list, list) 646 if (wr->last_ack_seg->num == seg_num) 647 break; 648} 649 650static void process_ds_ack(struct ib_mad_agent_private *agent, 651 struct ib_mad_recv_wc *mad_recv_wc, int newwin) 652{ 653 struct mad_rmpp_recv *rmpp_recv; 654 655 rmpp_recv = find_rmpp_recv(agent, mad_recv_wc); 656 if (rmpp_recv && rmpp_recv->state == RMPP_STATE_COMPLETE) 657 rmpp_recv->repwin = newwin; 658} 659 660static void process_rmpp_ack(struct ib_mad_agent_private *agent, 661 struct ib_mad_recv_wc *mad_recv_wc) 662{ 663 struct ib_mad_send_wr_private *mad_send_wr; 664 struct ib_rmpp_mad *rmpp_mad; 665 unsigned long flags; 666 int seg_num, newwin, ret; 667 668 rmpp_mad = (struct ib_rmpp_mad *)mad_recv_wc->recv_buf.mad; 669 if (rmpp_mad->rmpp_hdr.rmpp_status) { 670 abort_send(agent, mad_recv_wc, IB_MGMT_RMPP_STATUS_BAD_STATUS); 671 nack_recv(agent, mad_recv_wc, IB_MGMT_RMPP_STATUS_BAD_STATUS); 672 return; 673 } 674 675 seg_num = be32_to_cpu(rmpp_mad->rmpp_hdr.seg_num); 676 newwin = be32_to_cpu(rmpp_mad->rmpp_hdr.paylen_newwin); 677 if (newwin < seg_num) { 678 abort_send(agent, mad_recv_wc, IB_MGMT_RMPP_STATUS_W2S); 679 nack_recv(agent, mad_recv_wc, IB_MGMT_RMPP_STATUS_W2S); 680 return; 681 } 682 683 spin_lock_irqsave(&agent->lock, flags); 684 mad_send_wr = ib_find_send_mad(agent, mad_recv_wc); 685 if (!mad_send_wr) { 686 if (!seg_num) 687 process_ds_ack(agent, mad_recv_wc, newwin); 688 goto out; /* Unmatched or DS RMPP ACK */ 689 } 690 691 if ((mad_send_wr->last_ack == mad_send_wr->send_buf.seg_count) && 692 (mad_send_wr->timeout)) { 693 spin_unlock_irqrestore(&agent->lock, flags); 694 ack_ds_ack(agent, mad_recv_wc); 695 return; /* Repeated ACK for DS RMPP transaction */ 696 } 697 698 if ((mad_send_wr->last_ack == mad_send_wr->send_buf.seg_count) || 699 (!mad_send_wr->timeout) || (mad_send_wr->status != IB_WC_SUCCESS)) 700 goto out; /* Send is already done */ 701 702 if (seg_num > mad_send_wr->send_buf.seg_count || 703 seg_num > mad_send_wr->newwin) { 704 spin_unlock_irqrestore(&agent->lock, flags); 705 abort_send(agent, mad_recv_wc, IB_MGMT_RMPP_STATUS_S2B); 706 nack_recv(agent, mad_recv_wc, IB_MGMT_RMPP_STATUS_S2B); 707 return; 708 } 709 710 if (newwin < mad_send_wr->newwin || seg_num < mad_send_wr->last_ack) 711 goto out; /* Old ACK */ 712 713 if (seg_num > mad_send_wr->last_ack) { 714 adjust_last_ack(mad_send_wr, seg_num); 715 mad_send_wr->retries_left = mad_send_wr->max_retries; 716 } 717 mad_send_wr->newwin = newwin; 718 if (mad_send_wr->last_ack == mad_send_wr->send_buf.seg_count) { 719 /* If no response is expected, the ACK completes the send */ 720 if (!mad_send_wr->send_buf.timeout_ms) { 721 struct ib_mad_send_wc wc; 722 723 ib_mark_mad_done(mad_send_wr); 724 spin_unlock_irqrestore(&agent->lock, flags); 725 726 wc.status = IB_WC_SUCCESS; 727 wc.vendor_err = 0; 728 wc.send_buf = &mad_send_wr->send_buf; 729 ib_mad_complete_send_wr(mad_send_wr, &wc); 730 return; 731 } 732 if (mad_send_wr->refcount == 1) 733 ib_reset_mad_timeout(mad_send_wr, 734 mad_send_wr->send_buf.timeout_ms); 735 spin_unlock_irqrestore(&agent->lock, flags); 736 ack_ds_ack(agent, mad_recv_wc); 737 return; 738 } else if (mad_send_wr->refcount == 1 && 739 mad_send_wr->seg_num < mad_send_wr->newwin && 740 mad_send_wr->seg_num < mad_send_wr->send_buf.seg_count) { 741 /* Send failure will just result in a timeout/retry */ 742 ret = send_next_seg(mad_send_wr); 743 if (ret) 744 goto out; 745 746 mad_send_wr->refcount++; 747 list_move_tail(&mad_send_wr->agent_list, 748 &mad_send_wr->mad_agent_priv->send_list); 749 } 750out: 751 spin_unlock_irqrestore(&agent->lock, flags); 752} 753 754static struct ib_mad_recv_wc * 755process_rmpp_data(struct ib_mad_agent_private *agent, 756 struct ib_mad_recv_wc *mad_recv_wc) 757{ 758 struct ib_rmpp_hdr *rmpp_hdr; 759 u8 rmpp_status; 760 761 rmpp_hdr = &((struct ib_rmpp_mad *)mad_recv_wc->recv_buf.mad)->rmpp_hdr; 762 763 if (rmpp_hdr->rmpp_status) { 764 rmpp_status = IB_MGMT_RMPP_STATUS_BAD_STATUS; 765 goto bad; 766 } 767 768 if (rmpp_hdr->seg_num == cpu_to_be32(1)) { 769 if (!(ib_get_rmpp_flags(rmpp_hdr) & IB_MGMT_RMPP_FLAG_FIRST)) { 770 rmpp_status = IB_MGMT_RMPP_STATUS_BAD_SEG; 771 goto bad; 772 } 773 return start_rmpp(agent, mad_recv_wc); 774 } else { 775 if (ib_get_rmpp_flags(rmpp_hdr) & IB_MGMT_RMPP_FLAG_FIRST) { 776 rmpp_status = IB_MGMT_RMPP_STATUS_BAD_SEG; 777 goto bad; 778 } 779 return continue_rmpp(agent, mad_recv_wc); 780 } 781bad: 782 nack_recv(agent, mad_recv_wc, rmpp_status); 783 ib_free_recv_mad(mad_recv_wc); 784 return NULL; 785} 786 787static void process_rmpp_stop(struct ib_mad_agent_private *agent, 788 struct ib_mad_recv_wc *mad_recv_wc) 789{ 790 struct ib_rmpp_mad *rmpp_mad; 791 792 rmpp_mad = (struct ib_rmpp_mad *)mad_recv_wc->recv_buf.mad; 793 794 if (rmpp_mad->rmpp_hdr.rmpp_status != IB_MGMT_RMPP_STATUS_RESX) { 795 abort_send(agent, mad_recv_wc, IB_MGMT_RMPP_STATUS_BAD_STATUS); 796 nack_recv(agent, mad_recv_wc, IB_MGMT_RMPP_STATUS_BAD_STATUS); 797 } else 798 abort_send(agent, mad_recv_wc, rmpp_mad->rmpp_hdr.rmpp_status); 799} 800 801static void process_rmpp_abort(struct ib_mad_agent_private *agent, 802 struct ib_mad_recv_wc *mad_recv_wc) 803{ 804 struct ib_rmpp_mad *rmpp_mad; 805 806 rmpp_mad = (struct ib_rmpp_mad *)mad_recv_wc->recv_buf.mad; 807 808 if (rmpp_mad->rmpp_hdr.rmpp_status < IB_MGMT_RMPP_STATUS_ABORT_MIN || 809 rmpp_mad->rmpp_hdr.rmpp_status > IB_MGMT_RMPP_STATUS_ABORT_MAX) { 810 abort_send(agent, mad_recv_wc, IB_MGMT_RMPP_STATUS_BAD_STATUS); 811 nack_recv(agent, mad_recv_wc, IB_MGMT_RMPP_STATUS_BAD_STATUS); 812 } else 813 abort_send(agent, mad_recv_wc, rmpp_mad->rmpp_hdr.rmpp_status); 814} 815 816struct ib_mad_recv_wc * 817ib_process_rmpp_recv_wc(struct ib_mad_agent_private *agent, 818 struct ib_mad_recv_wc *mad_recv_wc) 819{ 820 struct ib_rmpp_mad *rmpp_mad; 821 822 rmpp_mad = (struct ib_rmpp_mad *)mad_recv_wc->recv_buf.mad; 823 if (!(rmpp_mad->rmpp_hdr.rmpp_rtime_flags & IB_MGMT_RMPP_FLAG_ACTIVE)) 824 return mad_recv_wc; 825 826 if (rmpp_mad->rmpp_hdr.rmpp_version != IB_MGMT_RMPP_VERSION) { 827 abort_send(agent, mad_recv_wc, IB_MGMT_RMPP_STATUS_UNV); 828 nack_recv(agent, mad_recv_wc, IB_MGMT_RMPP_STATUS_UNV); 829 goto out; 830 } 831 832 switch (rmpp_mad->rmpp_hdr.rmpp_type) { 833 case IB_MGMT_RMPP_TYPE_DATA: 834 return process_rmpp_data(agent, mad_recv_wc); 835 case IB_MGMT_RMPP_TYPE_ACK: 836 process_rmpp_ack(agent, mad_recv_wc); 837 break; 838 case IB_MGMT_RMPP_TYPE_STOP: 839 process_rmpp_stop(agent, mad_recv_wc); 840 break; 841 case IB_MGMT_RMPP_TYPE_ABORT: 842 process_rmpp_abort(agent, mad_recv_wc); 843 break; 844 default: 845 abort_send(agent, mad_recv_wc, IB_MGMT_RMPP_STATUS_BADT); 846 nack_recv(agent, mad_recv_wc, IB_MGMT_RMPP_STATUS_BADT); 847 break; 848 } 849out: 850 ib_free_recv_mad(mad_recv_wc); 851 return NULL; 852} 853 854static int init_newwin(struct ib_mad_send_wr_private *mad_send_wr) 855{ 856 struct ib_mad_agent_private *agent = mad_send_wr->mad_agent_priv; 857 struct ib_mad_hdr *mad_hdr = mad_send_wr->send_buf.mad; 858 struct mad_rmpp_recv *rmpp_recv; 859 struct ib_ah_attr ah_attr; 860 unsigned long flags; 861 int newwin = 1; 862 863 if (!(mad_hdr->method & IB_MGMT_METHOD_RESP)) 864 goto out; 865 866 spin_lock_irqsave(&agent->lock, flags); 867 list_for_each_entry(rmpp_recv, &agent->rmpp_list, list) { 868 if (rmpp_recv->tid != mad_hdr->tid || 869 rmpp_recv->mgmt_class != mad_hdr->mgmt_class || 870 rmpp_recv->class_version != mad_hdr->class_version || 871 (rmpp_recv->method & IB_MGMT_METHOD_RESP)) 872 continue; 873 874 if (ib_query_ah(mad_send_wr->send_buf.ah, &ah_attr)) 875 continue; 876 877 if (rmpp_recv->slid == ah_attr.dlid) { 878 newwin = rmpp_recv->repwin; 879 break; 880 } 881 } 882 spin_unlock_irqrestore(&agent->lock, flags); 883out: 884 return newwin; 885} 886 887int ib_send_rmpp_mad(struct ib_mad_send_wr_private *mad_send_wr) 888{ 889 struct ib_rmpp_mad *rmpp_mad; 890 int ret; 891 892 rmpp_mad = mad_send_wr->send_buf.mad; 893 if (!(ib_get_rmpp_flags(&rmpp_mad->rmpp_hdr) & 894 IB_MGMT_RMPP_FLAG_ACTIVE)) 895 return IB_RMPP_RESULT_UNHANDLED; 896 897 if (rmpp_mad->rmpp_hdr.rmpp_type != IB_MGMT_RMPP_TYPE_DATA) { 898 mad_send_wr->seg_num = 1; 899 return IB_RMPP_RESULT_INTERNAL; 900 } 901 902 mad_send_wr->newwin = init_newwin(mad_send_wr); 903 904 /* We need to wait for the final ACK even if there isn't a response */ 905 mad_send_wr->refcount += (mad_send_wr->timeout == 0); 906 ret = send_next_seg(mad_send_wr); 907 if (!ret) 908 return IB_RMPP_RESULT_CONSUMED; 909 return ret; 910} 911 912int ib_process_rmpp_send_wc(struct ib_mad_send_wr_private *mad_send_wr, 913 struct ib_mad_send_wc *mad_send_wc) 914{ 915 struct ib_rmpp_mad *rmpp_mad; 916 int ret; 917 918 rmpp_mad = mad_send_wr->send_buf.mad; 919 if (!(ib_get_rmpp_flags(&rmpp_mad->rmpp_hdr) & 920 IB_MGMT_RMPP_FLAG_ACTIVE)) 921 return IB_RMPP_RESULT_UNHANDLED; /* RMPP not active */ 922 923 if (rmpp_mad->rmpp_hdr.rmpp_type != IB_MGMT_RMPP_TYPE_DATA) 924 return IB_RMPP_RESULT_INTERNAL; /* ACK, STOP, or ABORT */ 925 926 if (mad_send_wc->status != IB_WC_SUCCESS || 927 mad_send_wr->status != IB_WC_SUCCESS) 928 return IB_RMPP_RESULT_PROCESSED; /* Canceled or send error */ 929 930 if (!mad_send_wr->timeout) 931 return IB_RMPP_RESULT_PROCESSED; /* Response received */ 932 933 if (mad_send_wr->last_ack == mad_send_wr->send_buf.seg_count) { 934 mad_send_wr->timeout = 935 msecs_to_jiffies(mad_send_wr->send_buf.timeout_ms); 936 return IB_RMPP_RESULT_PROCESSED; /* Send done */ 937 } 938 939 if (mad_send_wr->seg_num == mad_send_wr->newwin || 940 mad_send_wr->seg_num == mad_send_wr->send_buf.seg_count) 941 return IB_RMPP_RESULT_PROCESSED; /* Wait for ACK */ 942 943 ret = send_next_seg(mad_send_wr); 944 if (ret) { 945 mad_send_wc->status = IB_WC_GENERAL_ERR; 946 return IB_RMPP_RESULT_PROCESSED; 947 } 948 return IB_RMPP_RESULT_CONSUMED; 949} 950 951int ib_retry_rmpp(struct ib_mad_send_wr_private *mad_send_wr) 952{ 953 struct ib_rmpp_mad *rmpp_mad; 954 int ret; 955 956 rmpp_mad = mad_send_wr->send_buf.mad; 957 if (!(ib_get_rmpp_flags(&rmpp_mad->rmpp_hdr) & 958 IB_MGMT_RMPP_FLAG_ACTIVE)) 959 return IB_RMPP_RESULT_UNHANDLED; /* RMPP not active */ 960 961 if (mad_send_wr->last_ack == mad_send_wr->send_buf.seg_count) 962 return IB_RMPP_RESULT_PROCESSED; 963 964 mad_send_wr->seg_num = mad_send_wr->last_ack; 965 mad_send_wr->cur_seg = mad_send_wr->last_ack_seg; 966 967 ret = send_next_seg(mad_send_wr); 968 if (ret) 969 return IB_RMPP_RESULT_PROCESSED; 970 971 return IB_RMPP_RESULT_CONSUMED; 972} 973