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