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 37 #include <sys/cdefs.h> 38 #include <linux/slab.h> 39 40 #include "mad_priv.h" 41 #include "mad_rmpp.h" 42 43 enum rmpp_state { 44 RMPP_STATE_ACTIVE, 45 RMPP_STATE_TIMEOUT, 46 RMPP_STATE_COMPLETE, 47 RMPP_STATE_CANCELING 48 }; 49 50 struct mad_rmpp_recv { 51 struct ib_mad_agent_private *agent; 52 struct list_head list; 53 struct delayed_work timeout_work; 54 struct delayed_work cleanup_work; 55 struct completion comp; 56 enum rmpp_state state; 57 spinlock_t lock; 58 atomic_t refcount; 59 60 struct ib_ah *ah; 61 struct ib_mad_recv_wc *rmpp_wc; 62 struct ib_mad_recv_buf *cur_seg_buf; 63 int last_ack; 64 int seg_num; 65 int newwin; 66 int repwin; 67 68 __be64 tid; 69 u32 src_qp; 70 u32 slid; 71 u8 mgmt_class; 72 u8 class_version; 73 u8 method; 74 u8 base_version; 75 }; 76 77 static inline void deref_rmpp_recv(struct mad_rmpp_recv *rmpp_recv) 78 { 79 if (atomic_dec_and_test(&rmpp_recv->refcount)) 80 complete(&rmpp_recv->comp); 81 } 82 83 static void destroy_rmpp_recv(struct mad_rmpp_recv *rmpp_recv) 84 { 85 deref_rmpp_recv(rmpp_recv); 86 wait_for_completion(&rmpp_recv->comp); 87 rdma_destroy_ah(rmpp_recv->ah, RDMA_DESTROY_AH_SLEEPABLE); 88 kfree(rmpp_recv); 89 } 90 91 void ib_cancel_rmpp_recvs(struct ib_mad_agent_private *agent) 92 { 93 struct mad_rmpp_recv *rmpp_recv, *temp_rmpp_recv; 94 unsigned long flags; 95 96 spin_lock_irqsave(&agent->lock, flags); 97 list_for_each_entry(rmpp_recv, &agent->rmpp_list, list) { 98 if (rmpp_recv->state != RMPP_STATE_COMPLETE) 99 ib_free_recv_mad(rmpp_recv->rmpp_wc); 100 rmpp_recv->state = RMPP_STATE_CANCELING; 101 } 102 spin_unlock_irqrestore(&agent->lock, flags); 103 104 list_for_each_entry(rmpp_recv, &agent->rmpp_list, list) { 105 cancel_delayed_work_sync(&rmpp_recv->timeout_work); 106 cancel_delayed_work_sync(&rmpp_recv->cleanup_work); 107 } 108 109 flush_workqueue(agent->qp_info->port_priv->wq); 110 111 list_for_each_entry_safe(rmpp_recv, temp_rmpp_recv, 112 &agent->rmpp_list, list) { 113 list_del(&rmpp_recv->list); 114 destroy_rmpp_recv(rmpp_recv); 115 } 116 } 117 118 static void format_ack(struct ib_mad_send_buf *msg, 119 struct ib_rmpp_mad *data, 120 struct mad_rmpp_recv *rmpp_recv) 121 { 122 struct ib_rmpp_mad *ack = msg->mad; 123 unsigned long flags; 124 125 memcpy(ack, &data->mad_hdr, msg->hdr_len); 126 127 ack->mad_hdr.method ^= IB_MGMT_METHOD_RESP; 128 ack->rmpp_hdr.rmpp_type = IB_MGMT_RMPP_TYPE_ACK; 129 ib_set_rmpp_flags(&ack->rmpp_hdr, IB_MGMT_RMPP_FLAG_ACTIVE); 130 131 spin_lock_irqsave(&rmpp_recv->lock, flags); 132 rmpp_recv->last_ack = rmpp_recv->seg_num; 133 ack->rmpp_hdr.seg_num = cpu_to_be32(rmpp_recv->seg_num); 134 ack->rmpp_hdr.paylen_newwin = cpu_to_be32(rmpp_recv->newwin); 135 spin_unlock_irqrestore(&rmpp_recv->lock, flags); 136 } 137 138 static void ack_recv(struct mad_rmpp_recv *rmpp_recv, 139 struct ib_mad_recv_wc *recv_wc) 140 { 141 struct ib_mad_send_buf *msg; 142 int ret, hdr_len; 143 144 hdr_len = ib_get_mad_data_offset(recv_wc->recv_buf.mad->mad_hdr.mgmt_class); 145 msg = ib_create_send_mad(&rmpp_recv->agent->agent, recv_wc->wc->src_qp, 146 recv_wc->wc->pkey_index, 1, hdr_len, 147 0, GFP_KERNEL, 148 IB_MGMT_BASE_VERSION); 149 if (IS_ERR(msg)) 150 return; 151 152 format_ack(msg, (struct ib_rmpp_mad *) recv_wc->recv_buf.mad, rmpp_recv); 153 msg->ah = rmpp_recv->ah; 154 ret = ib_post_send_mad(msg, NULL); 155 if (ret) 156 ib_free_send_mad(msg); 157 } 158 159 static struct ib_mad_send_buf *alloc_response_msg(struct ib_mad_agent *agent, 160 struct ib_mad_recv_wc *recv_wc) 161 { 162 struct ib_mad_send_buf *msg; 163 struct ib_ah *ah; 164 int hdr_len; 165 166 ah = ib_create_ah_from_wc(agent->qp->pd, recv_wc->wc, 167 recv_wc->recv_buf.grh, agent->port_num); 168 if (IS_ERR(ah)) 169 return (void *) ah; 170 171 hdr_len = ib_get_mad_data_offset(recv_wc->recv_buf.mad->mad_hdr.mgmt_class); 172 msg = ib_create_send_mad(agent, recv_wc->wc->src_qp, 173 recv_wc->wc->pkey_index, 1, 174 hdr_len, 0, GFP_KERNEL, 175 IB_MGMT_BASE_VERSION); 176 if (IS_ERR(msg)) 177 rdma_destroy_ah(ah, RDMA_DESTROY_AH_SLEEPABLE); 178 else { 179 msg->ah = ah; 180 msg->context[0] = ah; 181 } 182 183 return msg; 184 } 185 186 static void ack_ds_ack(struct ib_mad_agent_private *agent, 187 struct ib_mad_recv_wc *recv_wc) 188 { 189 struct ib_mad_send_buf *msg; 190 struct ib_rmpp_mad *rmpp_mad; 191 int ret; 192 193 msg = alloc_response_msg(&agent->agent, recv_wc); 194 if (IS_ERR(msg)) 195 return; 196 197 rmpp_mad = msg->mad; 198 memcpy(rmpp_mad, recv_wc->recv_buf.mad, msg->hdr_len); 199 200 rmpp_mad->mad_hdr.method ^= IB_MGMT_METHOD_RESP; 201 ib_set_rmpp_flags(&rmpp_mad->rmpp_hdr, IB_MGMT_RMPP_FLAG_ACTIVE); 202 rmpp_mad->rmpp_hdr.seg_num = 0; 203 rmpp_mad->rmpp_hdr.paylen_newwin = cpu_to_be32(1); 204 205 ret = ib_post_send_mad(msg, NULL); 206 if (ret) { 207 rdma_destroy_ah(msg->ah, RDMA_DESTROY_AH_SLEEPABLE); 208 ib_free_send_mad(msg); 209 } 210 } 211 212 void ib_rmpp_send_handler(struct ib_mad_send_wc *mad_send_wc) 213 { 214 if (mad_send_wc->send_buf->context[0] == mad_send_wc->send_buf->ah) 215 rdma_destroy_ah(mad_send_wc->send_buf->ah, 216 RDMA_DESTROY_AH_SLEEPABLE); 217 ib_free_send_mad(mad_send_wc->send_buf); 218 } 219 220 static 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 rdma_destroy_ah(msg->ah, RDMA_DESTROY_AH_SLEEPABLE); 245 ib_free_send_mad(msg); 246 } 247 } 248 249 static 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 271 static 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 287 static struct mad_rmpp_recv * 288 create_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 330 error: kfree(rmpp_recv); 331 return NULL; 332 } 333 334 static struct mad_rmpp_recv * 335 find_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 353 static struct mad_rmpp_recv * 354 acquire_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 368 static struct mad_rmpp_recv * 369 insert_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 381 static 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 389 static 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 397 static 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 406 static 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 411 static 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 427 static 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 439 static 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 464 static 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 480 static struct ib_mad_recv_wc * 481 continue_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); 529 out: 530 deref_rmpp_recv(rmpp_recv); 531 return done_wc; 532 533 drop3: spin_unlock_irqrestore(&rmpp_recv->lock, flags); 534 drop2: deref_rmpp_recv(rmpp_recv); 535 drop1: ib_free_recv_mad(mad_recv_wc); 536 return NULL; 537 } 538 539 static struct ib_mad_recv_wc * 540 start_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 579 static 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 610 static 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; 634 out: 635 spin_unlock_irqrestore(&agent->lock, flags); 636 } 637 638 static 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 650 static 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 660 static 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 } 750 out: 751 spin_unlock_irqrestore(&agent->lock, flags); 752 } 753 754 static struct ib_mad_recv_wc * 755 process_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 } 781 bad: 782 nack_recv(agent, mad_recv_wc, rmpp_status); 783 ib_free_recv_mad(mad_recv_wc); 784 return NULL; 785 } 786 787 static 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 801 static 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 816 struct ib_mad_recv_wc * 817 ib_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 } 849 out: 850 ib_free_recv_mad(mad_recv_wc); 851 return NULL; 852 } 853 854 static 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 rdma_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 (rdma_query_ah(mad_send_wr->send_buf.ah, &ah_attr)) 875 continue; 876 877 if (rmpp_recv->slid == rdma_ah_get_dlid(&ah_attr)) { 878 newwin = rmpp_recv->repwin; 879 break; 880 } 881 } 882 spin_unlock_irqrestore(&agent->lock, flags); 883 out: 884 return newwin; 885 } 886 887 int 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 912 int 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 951 int 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