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 u16 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 ib_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 ib_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 ib_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 ib_destroy_ah(mad_send_wc->send_buf->ah, RDMA_DESTROY_AH_SLEEPABLE); 216 ib_free_send_mad(mad_send_wc->send_buf); 217 } 218 219 static void nack_recv(struct ib_mad_agent_private *agent, 220 struct ib_mad_recv_wc *recv_wc, u8 rmpp_status) 221 { 222 struct ib_mad_send_buf *msg; 223 struct ib_rmpp_mad *rmpp_mad; 224 int ret; 225 226 msg = alloc_response_msg(&agent->agent, recv_wc); 227 if (IS_ERR(msg)) 228 return; 229 230 rmpp_mad = msg->mad; 231 memcpy(rmpp_mad, recv_wc->recv_buf.mad, msg->hdr_len); 232 233 rmpp_mad->mad_hdr.method ^= IB_MGMT_METHOD_RESP; 234 rmpp_mad->rmpp_hdr.rmpp_version = IB_MGMT_RMPP_VERSION; 235 rmpp_mad->rmpp_hdr.rmpp_type = IB_MGMT_RMPP_TYPE_ABORT; 236 ib_set_rmpp_flags(&rmpp_mad->rmpp_hdr, IB_MGMT_RMPP_FLAG_ACTIVE); 237 rmpp_mad->rmpp_hdr.rmpp_status = rmpp_status; 238 rmpp_mad->rmpp_hdr.seg_num = 0; 239 rmpp_mad->rmpp_hdr.paylen_newwin = 0; 240 241 ret = ib_post_send_mad(msg, NULL); 242 if (ret) { 243 ib_destroy_ah(msg->ah, RDMA_DESTROY_AH_SLEEPABLE); 244 ib_free_send_mad(msg); 245 } 246 } 247 248 static void recv_timeout_handler(struct work_struct *work) 249 { 250 struct mad_rmpp_recv *rmpp_recv = 251 container_of(work, struct mad_rmpp_recv, timeout_work.work); 252 struct ib_mad_recv_wc *rmpp_wc; 253 unsigned long flags; 254 255 spin_lock_irqsave(&rmpp_recv->agent->lock, flags); 256 if (rmpp_recv->state != RMPP_STATE_ACTIVE) { 257 spin_unlock_irqrestore(&rmpp_recv->agent->lock, flags); 258 return; 259 } 260 rmpp_recv->state = RMPP_STATE_TIMEOUT; 261 list_del(&rmpp_recv->list); 262 spin_unlock_irqrestore(&rmpp_recv->agent->lock, flags); 263 264 rmpp_wc = rmpp_recv->rmpp_wc; 265 nack_recv(rmpp_recv->agent, rmpp_wc, IB_MGMT_RMPP_STATUS_T2L); 266 destroy_rmpp_recv(rmpp_recv); 267 ib_free_recv_mad(rmpp_wc); 268 } 269 270 static void recv_cleanup_handler(struct work_struct *work) 271 { 272 struct mad_rmpp_recv *rmpp_recv = 273 container_of(work, struct mad_rmpp_recv, cleanup_work.work); 274 unsigned long flags; 275 276 spin_lock_irqsave(&rmpp_recv->agent->lock, flags); 277 if (rmpp_recv->state == RMPP_STATE_CANCELING) { 278 spin_unlock_irqrestore(&rmpp_recv->agent->lock, flags); 279 return; 280 } 281 list_del(&rmpp_recv->list); 282 spin_unlock_irqrestore(&rmpp_recv->agent->lock, flags); 283 destroy_rmpp_recv(rmpp_recv); 284 } 285 286 static struct mad_rmpp_recv * 287 create_rmpp_recv(struct ib_mad_agent_private *agent, 288 struct ib_mad_recv_wc *mad_recv_wc) 289 { 290 struct mad_rmpp_recv *rmpp_recv; 291 struct ib_mad_hdr *mad_hdr; 292 293 rmpp_recv = kmalloc(sizeof *rmpp_recv, GFP_KERNEL); 294 if (!rmpp_recv) 295 return NULL; 296 297 rmpp_recv->ah = ib_create_ah_from_wc(agent->agent.qp->pd, 298 mad_recv_wc->wc, 299 mad_recv_wc->recv_buf.grh, 300 agent->agent.port_num); 301 if (IS_ERR(rmpp_recv->ah)) 302 goto error; 303 304 rmpp_recv->agent = agent; 305 init_completion(&rmpp_recv->comp); 306 INIT_DELAYED_WORK(&rmpp_recv->timeout_work, recv_timeout_handler); 307 INIT_DELAYED_WORK(&rmpp_recv->cleanup_work, recv_cleanup_handler); 308 spin_lock_init(&rmpp_recv->lock); 309 rmpp_recv->state = RMPP_STATE_ACTIVE; 310 atomic_set(&rmpp_recv->refcount, 1); 311 312 rmpp_recv->rmpp_wc = mad_recv_wc; 313 rmpp_recv->cur_seg_buf = &mad_recv_wc->recv_buf; 314 rmpp_recv->newwin = 1; 315 rmpp_recv->seg_num = 1; 316 rmpp_recv->last_ack = 0; 317 rmpp_recv->repwin = 1; 318 319 mad_hdr = &mad_recv_wc->recv_buf.mad->mad_hdr; 320 rmpp_recv->tid = mad_hdr->tid; 321 rmpp_recv->src_qp = mad_recv_wc->wc->src_qp; 322 rmpp_recv->slid = mad_recv_wc->wc->slid; 323 rmpp_recv->mgmt_class = mad_hdr->mgmt_class; 324 rmpp_recv->class_version = mad_hdr->class_version; 325 rmpp_recv->method = mad_hdr->method; 326 rmpp_recv->base_version = mad_hdr->base_version; 327 return rmpp_recv; 328 329 error: kfree(rmpp_recv); 330 return NULL; 331 } 332 333 static struct mad_rmpp_recv * 334 find_rmpp_recv(struct ib_mad_agent_private *agent, 335 struct ib_mad_recv_wc *mad_recv_wc) 336 { 337 struct mad_rmpp_recv *rmpp_recv; 338 struct ib_mad_hdr *mad_hdr = &mad_recv_wc->recv_buf.mad->mad_hdr; 339 340 list_for_each_entry(rmpp_recv, &agent->rmpp_list, list) { 341 if (rmpp_recv->tid == mad_hdr->tid && 342 rmpp_recv->src_qp == mad_recv_wc->wc->src_qp && 343 rmpp_recv->slid == mad_recv_wc->wc->slid && 344 rmpp_recv->mgmt_class == mad_hdr->mgmt_class && 345 rmpp_recv->class_version == mad_hdr->class_version && 346 rmpp_recv->method == mad_hdr->method) 347 return rmpp_recv; 348 } 349 return NULL; 350 } 351 352 static struct mad_rmpp_recv * 353 acquire_rmpp_recv(struct ib_mad_agent_private *agent, 354 struct ib_mad_recv_wc *mad_recv_wc) 355 { 356 struct mad_rmpp_recv *rmpp_recv; 357 unsigned long flags; 358 359 spin_lock_irqsave(&agent->lock, flags); 360 rmpp_recv = find_rmpp_recv(agent, mad_recv_wc); 361 if (rmpp_recv) 362 atomic_inc(&rmpp_recv->refcount); 363 spin_unlock_irqrestore(&agent->lock, flags); 364 return rmpp_recv; 365 } 366 367 static struct mad_rmpp_recv * 368 insert_rmpp_recv(struct ib_mad_agent_private *agent, 369 struct mad_rmpp_recv *rmpp_recv) 370 { 371 struct mad_rmpp_recv *cur_rmpp_recv; 372 373 cur_rmpp_recv = find_rmpp_recv(agent, rmpp_recv->rmpp_wc); 374 if (!cur_rmpp_recv) 375 list_add_tail(&rmpp_recv->list, &agent->rmpp_list); 376 377 return cur_rmpp_recv; 378 } 379 380 static inline int get_last_flag(struct ib_mad_recv_buf *seg) 381 { 382 struct ib_rmpp_mad *rmpp_mad; 383 384 rmpp_mad = (struct ib_rmpp_mad *) seg->mad; 385 return ib_get_rmpp_flags(&rmpp_mad->rmpp_hdr) & IB_MGMT_RMPP_FLAG_LAST; 386 } 387 388 static inline int get_seg_num(struct ib_mad_recv_buf *seg) 389 { 390 struct ib_rmpp_mad *rmpp_mad; 391 392 rmpp_mad = (struct ib_rmpp_mad *) seg->mad; 393 return be32_to_cpu(rmpp_mad->rmpp_hdr.seg_num); 394 } 395 396 static inline struct ib_mad_recv_buf * get_next_seg(struct list_head *rmpp_list, 397 struct ib_mad_recv_buf *seg) 398 { 399 if (seg->list.next == rmpp_list) 400 return NULL; 401 402 return container_of(seg->list.next, struct ib_mad_recv_buf, list); 403 } 404 405 static inline int window_size(struct ib_mad_agent_private *agent) 406 { 407 return max(agent->qp_info->recv_queue.max_active >> 3, 1); 408 } 409 410 static struct ib_mad_recv_buf * find_seg_location(struct list_head *rmpp_list, 411 int seg_num) 412 { 413 struct ib_mad_recv_buf *seg_buf; 414 int cur_seg_num; 415 416 list_for_each_entry_reverse(seg_buf, rmpp_list, list) { 417 cur_seg_num = get_seg_num(seg_buf); 418 if (seg_num > cur_seg_num) 419 return seg_buf; 420 if (seg_num == cur_seg_num) 421 break; 422 } 423 return NULL; 424 } 425 426 static void update_seg_num(struct mad_rmpp_recv *rmpp_recv, 427 struct ib_mad_recv_buf *new_buf) 428 { 429 struct list_head *rmpp_list = &rmpp_recv->rmpp_wc->rmpp_list; 430 431 while (new_buf && (get_seg_num(new_buf) == rmpp_recv->seg_num + 1)) { 432 rmpp_recv->cur_seg_buf = new_buf; 433 rmpp_recv->seg_num++; 434 new_buf = get_next_seg(rmpp_list, new_buf); 435 } 436 } 437 438 static inline int get_mad_len(struct mad_rmpp_recv *rmpp_recv) 439 { 440 struct ib_rmpp_mad *rmpp_mad; 441 int hdr_size, data_size, pad; 442 bool opa = rdma_cap_opa_mad(rmpp_recv->agent->qp_info->port_priv->device, 443 rmpp_recv->agent->qp_info->port_priv->port_num); 444 445 rmpp_mad = (struct ib_rmpp_mad *)rmpp_recv->cur_seg_buf->mad; 446 447 hdr_size = ib_get_mad_data_offset(rmpp_mad->mad_hdr.mgmt_class); 448 if (opa && rmpp_recv->base_version == OPA_MGMT_BASE_VERSION) { 449 data_size = sizeof(struct opa_rmpp_mad) - hdr_size; 450 pad = OPA_MGMT_RMPP_DATA - be32_to_cpu(rmpp_mad->rmpp_hdr.paylen_newwin); 451 if (pad > OPA_MGMT_RMPP_DATA || pad < 0) 452 pad = 0; 453 } else { 454 data_size = sizeof(struct ib_rmpp_mad) - hdr_size; 455 pad = IB_MGMT_RMPP_DATA - be32_to_cpu(rmpp_mad->rmpp_hdr.paylen_newwin); 456 if (pad > IB_MGMT_RMPP_DATA || pad < 0) 457 pad = 0; 458 } 459 460 return hdr_size + rmpp_recv->seg_num * data_size - pad; 461 } 462 463 static struct ib_mad_recv_wc * complete_rmpp(struct mad_rmpp_recv *rmpp_recv) 464 { 465 struct ib_mad_recv_wc *rmpp_wc; 466 467 ack_recv(rmpp_recv, rmpp_recv->rmpp_wc); 468 if (rmpp_recv->seg_num > 1) 469 cancel_delayed_work(&rmpp_recv->timeout_work); 470 471 rmpp_wc = rmpp_recv->rmpp_wc; 472 rmpp_wc->mad_len = get_mad_len(rmpp_recv); 473 /* 10 seconds until we can find the packet lifetime */ 474 queue_delayed_work(rmpp_recv->agent->qp_info->port_priv->wq, 475 &rmpp_recv->cleanup_work, msecs_to_jiffies(10000)); 476 return rmpp_wc; 477 } 478 479 static struct ib_mad_recv_wc * 480 continue_rmpp(struct ib_mad_agent_private *agent, 481 struct ib_mad_recv_wc *mad_recv_wc) 482 { 483 struct mad_rmpp_recv *rmpp_recv; 484 struct ib_mad_recv_buf *prev_buf; 485 struct ib_mad_recv_wc *done_wc; 486 int seg_num; 487 unsigned long flags; 488 489 rmpp_recv = acquire_rmpp_recv(agent, mad_recv_wc); 490 if (!rmpp_recv) 491 goto drop1; 492 493 seg_num = get_seg_num(&mad_recv_wc->recv_buf); 494 495 spin_lock_irqsave(&rmpp_recv->lock, flags); 496 if ((rmpp_recv->state == RMPP_STATE_TIMEOUT) || 497 (seg_num > rmpp_recv->newwin)) 498 goto drop3; 499 500 if ((seg_num <= rmpp_recv->last_ack) || 501 (rmpp_recv->state == RMPP_STATE_COMPLETE)) { 502 spin_unlock_irqrestore(&rmpp_recv->lock, flags); 503 ack_recv(rmpp_recv, mad_recv_wc); 504 goto drop2; 505 } 506 507 prev_buf = find_seg_location(&rmpp_recv->rmpp_wc->rmpp_list, seg_num); 508 if (!prev_buf) 509 goto drop3; 510 511 done_wc = NULL; 512 list_add(&mad_recv_wc->recv_buf.list, &prev_buf->list); 513 if (rmpp_recv->cur_seg_buf == prev_buf) { 514 update_seg_num(rmpp_recv, &mad_recv_wc->recv_buf); 515 if (get_last_flag(rmpp_recv->cur_seg_buf)) { 516 rmpp_recv->state = RMPP_STATE_COMPLETE; 517 spin_unlock_irqrestore(&rmpp_recv->lock, flags); 518 done_wc = complete_rmpp(rmpp_recv); 519 goto out; 520 } else if (rmpp_recv->seg_num == rmpp_recv->newwin) { 521 rmpp_recv->newwin += window_size(agent); 522 spin_unlock_irqrestore(&rmpp_recv->lock, flags); 523 ack_recv(rmpp_recv, mad_recv_wc); 524 goto out; 525 } 526 } 527 spin_unlock_irqrestore(&rmpp_recv->lock, flags); 528 out: 529 deref_rmpp_recv(rmpp_recv); 530 return done_wc; 531 532 drop3: spin_unlock_irqrestore(&rmpp_recv->lock, flags); 533 drop2: deref_rmpp_recv(rmpp_recv); 534 drop1: ib_free_recv_mad(mad_recv_wc); 535 return NULL; 536 } 537 538 static struct ib_mad_recv_wc * 539 start_rmpp(struct ib_mad_agent_private *agent, 540 struct ib_mad_recv_wc *mad_recv_wc) 541 { 542 struct mad_rmpp_recv *rmpp_recv; 543 unsigned long flags; 544 545 rmpp_recv = create_rmpp_recv(agent, mad_recv_wc); 546 if (!rmpp_recv) { 547 ib_free_recv_mad(mad_recv_wc); 548 return NULL; 549 } 550 551 spin_lock_irqsave(&agent->lock, flags); 552 if (insert_rmpp_recv(agent, rmpp_recv)) { 553 spin_unlock_irqrestore(&agent->lock, flags); 554 /* duplicate first MAD */ 555 destroy_rmpp_recv(rmpp_recv); 556 return continue_rmpp(agent, mad_recv_wc); 557 } 558 atomic_inc(&rmpp_recv->refcount); 559 560 if (get_last_flag(&mad_recv_wc->recv_buf)) { 561 rmpp_recv->state = RMPP_STATE_COMPLETE; 562 spin_unlock_irqrestore(&agent->lock, flags); 563 complete_rmpp(rmpp_recv); 564 } else { 565 spin_unlock_irqrestore(&agent->lock, flags); 566 /* 40 seconds until we can find the packet lifetimes */ 567 queue_delayed_work(agent->qp_info->port_priv->wq, 568 &rmpp_recv->timeout_work, 569 msecs_to_jiffies(40000)); 570 rmpp_recv->newwin += window_size(agent); 571 ack_recv(rmpp_recv, mad_recv_wc); 572 mad_recv_wc = NULL; 573 } 574 deref_rmpp_recv(rmpp_recv); 575 return mad_recv_wc; 576 } 577 578 static int send_next_seg(struct ib_mad_send_wr_private *mad_send_wr) 579 { 580 struct ib_rmpp_mad *rmpp_mad; 581 int timeout; 582 u32 paylen = 0; 583 584 rmpp_mad = mad_send_wr->send_buf.mad; 585 ib_set_rmpp_flags(&rmpp_mad->rmpp_hdr, IB_MGMT_RMPP_FLAG_ACTIVE); 586 rmpp_mad->rmpp_hdr.seg_num = cpu_to_be32(++mad_send_wr->seg_num); 587 588 if (mad_send_wr->seg_num == 1) { 589 rmpp_mad->rmpp_hdr.rmpp_rtime_flags |= IB_MGMT_RMPP_FLAG_FIRST; 590 paylen = (mad_send_wr->send_buf.seg_count * 591 mad_send_wr->send_buf.seg_rmpp_size) - 592 mad_send_wr->pad; 593 } 594 595 if (mad_send_wr->seg_num == mad_send_wr->send_buf.seg_count) { 596 rmpp_mad->rmpp_hdr.rmpp_rtime_flags |= IB_MGMT_RMPP_FLAG_LAST; 597 paylen = mad_send_wr->send_buf.seg_rmpp_size - mad_send_wr->pad; 598 } 599 rmpp_mad->rmpp_hdr.paylen_newwin = cpu_to_be32(paylen); 600 601 /* 2 seconds for an ACK until we can find the packet lifetime */ 602 timeout = mad_send_wr->send_buf.timeout_ms; 603 if (!timeout || timeout > 2000) 604 mad_send_wr->timeout = msecs_to_jiffies(2000); 605 606 return ib_send_mad(mad_send_wr); 607 } 608 609 static void abort_send(struct ib_mad_agent_private *agent, 610 struct ib_mad_recv_wc *mad_recv_wc, u8 rmpp_status) 611 { 612 struct ib_mad_send_wr_private *mad_send_wr; 613 struct ib_mad_send_wc wc; 614 unsigned long flags; 615 616 spin_lock_irqsave(&agent->lock, flags); 617 mad_send_wr = ib_find_send_mad(agent, mad_recv_wc); 618 if (!mad_send_wr) 619 goto out; /* Unmatched send */ 620 621 if ((mad_send_wr->last_ack == mad_send_wr->send_buf.seg_count) || 622 (!mad_send_wr->timeout) || (mad_send_wr->status != IB_WC_SUCCESS)) 623 goto out; /* Send is already done */ 624 625 ib_mark_mad_done(mad_send_wr); 626 spin_unlock_irqrestore(&agent->lock, flags); 627 628 wc.status = IB_WC_REM_ABORT_ERR; 629 wc.vendor_err = rmpp_status; 630 wc.send_buf = &mad_send_wr->send_buf; 631 ib_mad_complete_send_wr(mad_send_wr, &wc); 632 return; 633 out: 634 spin_unlock_irqrestore(&agent->lock, flags); 635 } 636 637 static inline void adjust_last_ack(struct ib_mad_send_wr_private *wr, 638 int seg_num) 639 { 640 struct list_head *list; 641 642 wr->last_ack = seg_num; 643 list = &wr->last_ack_seg->list; 644 list_for_each_entry(wr->last_ack_seg, list, list) 645 if (wr->last_ack_seg->num == seg_num) 646 break; 647 } 648 649 static void process_ds_ack(struct ib_mad_agent_private *agent, 650 struct ib_mad_recv_wc *mad_recv_wc, int newwin) 651 { 652 struct mad_rmpp_recv *rmpp_recv; 653 654 rmpp_recv = find_rmpp_recv(agent, mad_recv_wc); 655 if (rmpp_recv && rmpp_recv->state == RMPP_STATE_COMPLETE) 656 rmpp_recv->repwin = newwin; 657 } 658 659 static void process_rmpp_ack(struct ib_mad_agent_private *agent, 660 struct ib_mad_recv_wc *mad_recv_wc) 661 { 662 struct ib_mad_send_wr_private *mad_send_wr; 663 struct ib_rmpp_mad *rmpp_mad; 664 unsigned long flags; 665 int seg_num, newwin, ret; 666 667 rmpp_mad = (struct ib_rmpp_mad *)mad_recv_wc->recv_buf.mad; 668 if (rmpp_mad->rmpp_hdr.rmpp_status) { 669 abort_send(agent, mad_recv_wc, IB_MGMT_RMPP_STATUS_BAD_STATUS); 670 nack_recv(agent, mad_recv_wc, IB_MGMT_RMPP_STATUS_BAD_STATUS); 671 return; 672 } 673 674 seg_num = be32_to_cpu(rmpp_mad->rmpp_hdr.seg_num); 675 newwin = be32_to_cpu(rmpp_mad->rmpp_hdr.paylen_newwin); 676 if (newwin < seg_num) { 677 abort_send(agent, mad_recv_wc, IB_MGMT_RMPP_STATUS_W2S); 678 nack_recv(agent, mad_recv_wc, IB_MGMT_RMPP_STATUS_W2S); 679 return; 680 } 681 682 spin_lock_irqsave(&agent->lock, flags); 683 mad_send_wr = ib_find_send_mad(agent, mad_recv_wc); 684 if (!mad_send_wr) { 685 if (!seg_num) 686 process_ds_ack(agent, mad_recv_wc, newwin); 687 goto out; /* Unmatched or DS RMPP ACK */ 688 } 689 690 if ((mad_send_wr->last_ack == mad_send_wr->send_buf.seg_count) && 691 (mad_send_wr->timeout)) { 692 spin_unlock_irqrestore(&agent->lock, flags); 693 ack_ds_ack(agent, mad_recv_wc); 694 return; /* Repeated ACK for DS RMPP transaction */ 695 } 696 697 if ((mad_send_wr->last_ack == mad_send_wr->send_buf.seg_count) || 698 (!mad_send_wr->timeout) || (mad_send_wr->status != IB_WC_SUCCESS)) 699 goto out; /* Send is already done */ 700 701 if (seg_num > mad_send_wr->send_buf.seg_count || 702 seg_num > mad_send_wr->newwin) { 703 spin_unlock_irqrestore(&agent->lock, flags); 704 abort_send(agent, mad_recv_wc, IB_MGMT_RMPP_STATUS_S2B); 705 nack_recv(agent, mad_recv_wc, IB_MGMT_RMPP_STATUS_S2B); 706 return; 707 } 708 709 if (newwin < mad_send_wr->newwin || seg_num < mad_send_wr->last_ack) 710 goto out; /* Old ACK */ 711 712 if (seg_num > mad_send_wr->last_ack) { 713 adjust_last_ack(mad_send_wr, seg_num); 714 mad_send_wr->retries_left = mad_send_wr->max_retries; 715 } 716 mad_send_wr->newwin = newwin; 717 if (mad_send_wr->last_ack == mad_send_wr->send_buf.seg_count) { 718 /* If no response is expected, the ACK completes the send */ 719 if (!mad_send_wr->send_buf.timeout_ms) { 720 struct ib_mad_send_wc wc; 721 722 ib_mark_mad_done(mad_send_wr); 723 spin_unlock_irqrestore(&agent->lock, flags); 724 725 wc.status = IB_WC_SUCCESS; 726 wc.vendor_err = 0; 727 wc.send_buf = &mad_send_wr->send_buf; 728 ib_mad_complete_send_wr(mad_send_wr, &wc); 729 return; 730 } 731 if (mad_send_wr->refcount == 1) 732 ib_reset_mad_timeout(mad_send_wr, 733 mad_send_wr->send_buf.timeout_ms); 734 spin_unlock_irqrestore(&agent->lock, flags); 735 ack_ds_ack(agent, mad_recv_wc); 736 return; 737 } else if (mad_send_wr->refcount == 1 && 738 mad_send_wr->seg_num < mad_send_wr->newwin && 739 mad_send_wr->seg_num < mad_send_wr->send_buf.seg_count) { 740 /* Send failure will just result in a timeout/retry */ 741 ret = send_next_seg(mad_send_wr); 742 if (ret) 743 goto out; 744 745 mad_send_wr->refcount++; 746 list_move_tail(&mad_send_wr->agent_list, 747 &mad_send_wr->mad_agent_priv->send_list); 748 } 749 out: 750 spin_unlock_irqrestore(&agent->lock, flags); 751 } 752 753 static struct ib_mad_recv_wc * 754 process_rmpp_data(struct ib_mad_agent_private *agent, 755 struct ib_mad_recv_wc *mad_recv_wc) 756 { 757 struct ib_rmpp_hdr *rmpp_hdr; 758 u8 rmpp_status; 759 760 rmpp_hdr = &((struct ib_rmpp_mad *)mad_recv_wc->recv_buf.mad)->rmpp_hdr; 761 762 if (rmpp_hdr->rmpp_status) { 763 rmpp_status = IB_MGMT_RMPP_STATUS_BAD_STATUS; 764 goto bad; 765 } 766 767 if (rmpp_hdr->seg_num == cpu_to_be32(1)) { 768 if (!(ib_get_rmpp_flags(rmpp_hdr) & IB_MGMT_RMPP_FLAG_FIRST)) { 769 rmpp_status = IB_MGMT_RMPP_STATUS_BAD_SEG; 770 goto bad; 771 } 772 return start_rmpp(agent, mad_recv_wc); 773 } else { 774 if (ib_get_rmpp_flags(rmpp_hdr) & IB_MGMT_RMPP_FLAG_FIRST) { 775 rmpp_status = IB_MGMT_RMPP_STATUS_BAD_SEG; 776 goto bad; 777 } 778 return continue_rmpp(agent, mad_recv_wc); 779 } 780 bad: 781 nack_recv(agent, mad_recv_wc, rmpp_status); 782 ib_free_recv_mad(mad_recv_wc); 783 return NULL; 784 } 785 786 static void process_rmpp_stop(struct ib_mad_agent_private *agent, 787 struct ib_mad_recv_wc *mad_recv_wc) 788 { 789 struct ib_rmpp_mad *rmpp_mad; 790 791 rmpp_mad = (struct ib_rmpp_mad *)mad_recv_wc->recv_buf.mad; 792 793 if (rmpp_mad->rmpp_hdr.rmpp_status != IB_MGMT_RMPP_STATUS_RESX) { 794 abort_send(agent, mad_recv_wc, IB_MGMT_RMPP_STATUS_BAD_STATUS); 795 nack_recv(agent, mad_recv_wc, IB_MGMT_RMPP_STATUS_BAD_STATUS); 796 } else 797 abort_send(agent, mad_recv_wc, rmpp_mad->rmpp_hdr.rmpp_status); 798 } 799 800 static void process_rmpp_abort(struct ib_mad_agent_private *agent, 801 struct ib_mad_recv_wc *mad_recv_wc) 802 { 803 struct ib_rmpp_mad *rmpp_mad; 804 805 rmpp_mad = (struct ib_rmpp_mad *)mad_recv_wc->recv_buf.mad; 806 807 if (rmpp_mad->rmpp_hdr.rmpp_status < IB_MGMT_RMPP_STATUS_ABORT_MIN || 808 rmpp_mad->rmpp_hdr.rmpp_status > IB_MGMT_RMPP_STATUS_ABORT_MAX) { 809 abort_send(agent, mad_recv_wc, IB_MGMT_RMPP_STATUS_BAD_STATUS); 810 nack_recv(agent, mad_recv_wc, IB_MGMT_RMPP_STATUS_BAD_STATUS); 811 } else 812 abort_send(agent, mad_recv_wc, rmpp_mad->rmpp_hdr.rmpp_status); 813 } 814 815 struct ib_mad_recv_wc * 816 ib_process_rmpp_recv_wc(struct ib_mad_agent_private *agent, 817 struct ib_mad_recv_wc *mad_recv_wc) 818 { 819 struct ib_rmpp_mad *rmpp_mad; 820 821 rmpp_mad = (struct ib_rmpp_mad *)mad_recv_wc->recv_buf.mad; 822 if (!(rmpp_mad->rmpp_hdr.rmpp_rtime_flags & IB_MGMT_RMPP_FLAG_ACTIVE)) 823 return mad_recv_wc; 824 825 if (rmpp_mad->rmpp_hdr.rmpp_version != IB_MGMT_RMPP_VERSION) { 826 abort_send(agent, mad_recv_wc, IB_MGMT_RMPP_STATUS_UNV); 827 nack_recv(agent, mad_recv_wc, IB_MGMT_RMPP_STATUS_UNV); 828 goto out; 829 } 830 831 switch (rmpp_mad->rmpp_hdr.rmpp_type) { 832 case IB_MGMT_RMPP_TYPE_DATA: 833 return process_rmpp_data(agent, mad_recv_wc); 834 case IB_MGMT_RMPP_TYPE_ACK: 835 process_rmpp_ack(agent, mad_recv_wc); 836 break; 837 case IB_MGMT_RMPP_TYPE_STOP: 838 process_rmpp_stop(agent, mad_recv_wc); 839 break; 840 case IB_MGMT_RMPP_TYPE_ABORT: 841 process_rmpp_abort(agent, mad_recv_wc); 842 break; 843 default: 844 abort_send(agent, mad_recv_wc, IB_MGMT_RMPP_STATUS_BADT); 845 nack_recv(agent, mad_recv_wc, IB_MGMT_RMPP_STATUS_BADT); 846 break; 847 } 848 out: 849 ib_free_recv_mad(mad_recv_wc); 850 return NULL; 851 } 852 853 static int init_newwin(struct ib_mad_send_wr_private *mad_send_wr) 854 { 855 struct ib_mad_agent_private *agent = mad_send_wr->mad_agent_priv; 856 struct ib_mad_hdr *mad_hdr = mad_send_wr->send_buf.mad; 857 struct mad_rmpp_recv *rmpp_recv; 858 struct ib_ah_attr ah_attr; 859 unsigned long flags; 860 int newwin = 1; 861 862 if (!(mad_hdr->method & IB_MGMT_METHOD_RESP)) 863 goto out; 864 865 spin_lock_irqsave(&agent->lock, flags); 866 list_for_each_entry(rmpp_recv, &agent->rmpp_list, list) { 867 if (rmpp_recv->tid != mad_hdr->tid || 868 rmpp_recv->mgmt_class != mad_hdr->mgmt_class || 869 rmpp_recv->class_version != mad_hdr->class_version || 870 (rmpp_recv->method & IB_MGMT_METHOD_RESP)) 871 continue; 872 873 if (ib_query_ah(mad_send_wr->send_buf.ah, &ah_attr)) 874 continue; 875 876 if (rmpp_recv->slid == ah_attr.dlid) { 877 newwin = rmpp_recv->repwin; 878 break; 879 } 880 } 881 spin_unlock_irqrestore(&agent->lock, flags); 882 out: 883 return newwin; 884 } 885 886 int ib_send_rmpp_mad(struct ib_mad_send_wr_private *mad_send_wr) 887 { 888 struct ib_rmpp_mad *rmpp_mad; 889 int ret; 890 891 rmpp_mad = mad_send_wr->send_buf.mad; 892 if (!(ib_get_rmpp_flags(&rmpp_mad->rmpp_hdr) & 893 IB_MGMT_RMPP_FLAG_ACTIVE)) 894 return IB_RMPP_RESULT_UNHANDLED; 895 896 if (rmpp_mad->rmpp_hdr.rmpp_type != IB_MGMT_RMPP_TYPE_DATA) { 897 mad_send_wr->seg_num = 1; 898 return IB_RMPP_RESULT_INTERNAL; 899 } 900 901 mad_send_wr->newwin = init_newwin(mad_send_wr); 902 903 /* We need to wait for the final ACK even if there isn't a response */ 904 mad_send_wr->refcount += (mad_send_wr->timeout == 0); 905 ret = send_next_seg(mad_send_wr); 906 if (!ret) 907 return IB_RMPP_RESULT_CONSUMED; 908 return ret; 909 } 910 911 int ib_process_rmpp_send_wc(struct ib_mad_send_wr_private *mad_send_wr, 912 struct ib_mad_send_wc *mad_send_wc) 913 { 914 struct ib_rmpp_mad *rmpp_mad; 915 int ret; 916 917 rmpp_mad = mad_send_wr->send_buf.mad; 918 if (!(ib_get_rmpp_flags(&rmpp_mad->rmpp_hdr) & 919 IB_MGMT_RMPP_FLAG_ACTIVE)) 920 return IB_RMPP_RESULT_UNHANDLED; /* RMPP not active */ 921 922 if (rmpp_mad->rmpp_hdr.rmpp_type != IB_MGMT_RMPP_TYPE_DATA) 923 return IB_RMPP_RESULT_INTERNAL; /* ACK, STOP, or ABORT */ 924 925 if (mad_send_wc->status != IB_WC_SUCCESS || 926 mad_send_wr->status != IB_WC_SUCCESS) 927 return IB_RMPP_RESULT_PROCESSED; /* Canceled or send error */ 928 929 if (!mad_send_wr->timeout) 930 return IB_RMPP_RESULT_PROCESSED; /* Response received */ 931 932 if (mad_send_wr->last_ack == mad_send_wr->send_buf.seg_count) { 933 mad_send_wr->timeout = 934 msecs_to_jiffies(mad_send_wr->send_buf.timeout_ms); 935 return IB_RMPP_RESULT_PROCESSED; /* Send done */ 936 } 937 938 if (mad_send_wr->seg_num == mad_send_wr->newwin || 939 mad_send_wr->seg_num == mad_send_wr->send_buf.seg_count) 940 return IB_RMPP_RESULT_PROCESSED; /* Wait for ACK */ 941 942 ret = send_next_seg(mad_send_wr); 943 if (ret) { 944 mad_send_wc->status = IB_WC_GENERAL_ERR; 945 return IB_RMPP_RESULT_PROCESSED; 946 } 947 return IB_RMPP_RESULT_CONSUMED; 948 } 949 950 int ib_retry_rmpp(struct ib_mad_send_wr_private *mad_send_wr) 951 { 952 struct ib_rmpp_mad *rmpp_mad; 953 int ret; 954 955 rmpp_mad = mad_send_wr->send_buf.mad; 956 if (!(ib_get_rmpp_flags(&rmpp_mad->rmpp_hdr) & 957 IB_MGMT_RMPP_FLAG_ACTIVE)) 958 return IB_RMPP_RESULT_UNHANDLED; /* RMPP not active */ 959 960 if (mad_send_wr->last_ack == mad_send_wr->send_buf.seg_count) 961 return IB_RMPP_RESULT_PROCESSED; 962 963 mad_send_wr->seg_num = mad_send_wr->last_ack; 964 mad_send_wr->cur_seg = mad_send_wr->last_ack_seg; 965 966 ret = send_next_seg(mad_send_wr); 967 if (ret) 968 return IB_RMPP_RESULT_PROCESSED; 969 970 return IB_RMPP_RESULT_CONSUMED; 971 } 972