1/* 2 3 * Copyright (c) 2005 Intel Inc. All rights reserved. 4 * Copyright (c) 2005-2006 Voltaire, Inc. 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 "mad_priv.h" 36 #include "mad_rmpp.h" 37 38 enum rmpp_state { 39 RMPP_STATE_ACTIVE, 40 RMPP_STATE_TIMEOUT, 41 RMPP_STATE_COMPLETE, 42 RMPP_STATE_CANCELING 43 }; 44 45 struct mad_rmpp_recv { 46 struct ib_mad_agent_private *agent; 47 struct list_head list; 48 struct delayed_work timeout_work; 49 struct delayed_work cleanup_work; 50 struct completion comp; 51 enum rmpp_state state; 52 spinlock_t lock; 53 atomic_t refcount; 54 55 struct ib_ah *ah; 56 struct ib_mad_recv_wc *rmpp_wc; 57 struct ib_mad_recv_buf *cur_seg_buf; 58 int last_ack; 59 int seg_num; 60 int newwin; 61 int repwin; 62 63 __be64 tid; 64 u32 src_qp; 65 u16 slid; 66 u8 mgmt_class; 67 u8 class_version; 68 u8 method; 69 }; 70 71 static inline void deref_rmpp_recv(struct mad_rmpp_recv *rmpp_recv) 72 { 73 if (atomic_dec_and_test(&rmpp_recv->refcount)) 74 complete(&rmpp_recv->comp); 75 } 76 77 static void destroy_rmpp_recv(struct mad_rmpp_recv *rmpp_recv) 78 { 79 deref_rmpp_recv(rmpp_recv); 80 wait_for_completion(&rmpp_recv->comp); 81 ib_destroy_ah(rmpp_recv->ah); 82 kfree(rmpp_recv); 83 } 84 85 void ib_cancel_rmpp_recvs(struct ib_mad_agent_private *agent) 86 { 87 struct mad_rmpp_recv *rmpp_recv, *temp_rmpp_recv; 88 unsigned long flags; 89 90 spin_lock_irqsave(&agent->lock, flags); 91 list_for_each_entry(rmpp_recv, &agent->rmpp_list, list) { 92 if (rmpp_recv->state != RMPP_STATE_COMPLETE) 93 ib_free_recv_mad(rmpp_recv->rmpp_wc); 94 rmpp_recv->state = RMPP_STATE_CANCELING; 95 } 96 spin_unlock_irqrestore(&agent->lock, flags); 97 98 list_for_each_entry(rmpp_recv, &agent->rmpp_list, list) { 99 cancel_delayed_work(&rmpp_recv->timeout_work); 100 cancel_delayed_work(&rmpp_recv->cleanup_work); 101 } 102 103 flush_workqueue(agent->qp_info->port_priv->wq); 104 105 list_for_each_entry_safe(rmpp_recv, temp_rmpp_recv, 106 &agent->rmpp_list, list) { 107 list_del(&rmpp_recv->list); 108 destroy_rmpp_recv(rmpp_recv); 109 } 110 } 111 112 static void format_ack(struct ib_mad_send_buf *msg, 113 struct ib_rmpp_mad *data, 114 struct mad_rmpp_recv *rmpp_recv) 115 { 116 struct ib_rmpp_mad *ack = msg->mad; 117 unsigned long flags; 118 119 memcpy(ack, &data->mad_hdr, msg->hdr_len); 120 121 ack->mad_hdr.method ^= IB_MGMT_METHOD_RESP; 122 ack->rmpp_hdr.rmpp_type = IB_MGMT_RMPP_TYPE_ACK; 123 ib_set_rmpp_flags(&ack->rmpp_hdr, IB_MGMT_RMPP_FLAG_ACTIVE); 124 125 spin_lock_irqsave(&rmpp_recv->lock, flags); 126 rmpp_recv->last_ack = rmpp_recv->seg_num; 127 ack->rmpp_hdr.seg_num = cpu_to_be32(rmpp_recv->seg_num); 128 ack->rmpp_hdr.paylen_newwin = cpu_to_be32(rmpp_recv->newwin); 129 spin_unlock_irqrestore(&rmpp_recv->lock, flags); 130 } 131 132 static void ack_recv(struct mad_rmpp_recv *rmpp_recv, 133 struct ib_mad_recv_wc *recv_wc) 134 { 135 struct ib_mad_send_buf *msg; 136 int ret, hdr_len; 137 138 hdr_len = ib_get_mad_data_offset(recv_wc->recv_buf.mad->mad_hdr.mgmt_class); 139 msg = ib_create_send_mad(&rmpp_recv->agent->agent, recv_wc->wc->src_qp, 140 recv_wc->wc->pkey_index, 1, hdr_len, 141 0, GFP_KERNEL); 142 if (IS_ERR(msg)) 143 return; 144 145 format_ack(msg, (struct ib_rmpp_mad *) recv_wc->recv_buf.mad, rmpp_recv); 146 msg->ah = rmpp_recv->ah; 147 ret = ib_post_send_mad(msg, NULL); 148 if (ret) 149 ib_free_send_mad(msg); 150 } 151 152 static struct ib_mad_send_buf *alloc_response_msg(struct ib_mad_agent *agent, 153 struct ib_mad_recv_wc *recv_wc) 154 { 155 struct ib_mad_send_buf *msg; 156 struct ib_ah *ah; 157 int hdr_len; 158 159 ah = ib_create_ah_from_wc(agent->qp->pd, recv_wc->wc, 160 recv_wc->recv_buf.grh, agent->port_num); 161 if (IS_ERR(ah)) 162 return (void *) ah; 163 164 hdr_len = ib_get_mad_data_offset(recv_wc->recv_buf.mad->mad_hdr.mgmt_class); 165 msg = ib_create_send_mad(agent, recv_wc->wc->src_qp, 166 recv_wc->wc->pkey_index, 1, 167 hdr_len, 0, GFP_KERNEL); 168 if (IS_ERR(msg)) 169 ib_destroy_ah(ah); 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 ib_destroy_ah(msg->ah); 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 ib_destroy_ah(mad_send_wc->send_buf->ah); 208 ib_free_send_mad(mad_send_wc->send_buf); 209 } 210 211 static void nack_recv(struct ib_mad_agent_private *agent, 212 struct ib_mad_recv_wc *recv_wc, u8 rmpp_status) 213 { 214 struct ib_mad_send_buf *msg; 215 struct ib_rmpp_mad *rmpp_mad; 216 int ret; 217 218 msg = alloc_response_msg(&agent->agent, recv_wc); 219 if (IS_ERR(msg)) 220 return; 221 222 rmpp_mad = msg->mad; 223 memcpy(rmpp_mad, recv_wc->recv_buf.mad, msg->hdr_len); 224 225 rmpp_mad->mad_hdr.method ^= IB_MGMT_METHOD_RESP; 226 rmpp_mad->rmpp_hdr.rmpp_version = IB_MGMT_RMPP_VERSION; 227 rmpp_mad->rmpp_hdr.rmpp_type = IB_MGMT_RMPP_TYPE_ABORT; 228 ib_set_rmpp_flags(&rmpp_mad->rmpp_hdr, IB_MGMT_RMPP_FLAG_ACTIVE); 229 rmpp_mad->rmpp_hdr.rmpp_status = rmpp_status; 230 rmpp_mad->rmpp_hdr.seg_num = 0; 231 rmpp_mad->rmpp_hdr.paylen_newwin = 0; 232 233 ret = ib_post_send_mad(msg, NULL); 234 if (ret) { 235 ib_destroy_ah(msg->ah); 236 ib_free_send_mad(msg); 237 } 238 } 239 240 static void recv_timeout_handler(struct work_struct *work) 241 { 242 struct mad_rmpp_recv *rmpp_recv = 243 container_of(work, struct mad_rmpp_recv, timeout_work.work); 244 struct ib_mad_recv_wc *rmpp_wc; 245 unsigned long flags; 246 247 spin_lock_irqsave(&rmpp_recv->agent->lock, flags); 248 if (rmpp_recv->state != RMPP_STATE_ACTIVE) { 249 spin_unlock_irqrestore(&rmpp_recv->agent->lock, flags); 250 return; 251 } 252 rmpp_recv->state = RMPP_STATE_TIMEOUT; 253 list_del(&rmpp_recv->list); 254 spin_unlock_irqrestore(&rmpp_recv->agent->lock, flags); 255 256 rmpp_wc = rmpp_recv->rmpp_wc; 257 nack_recv(rmpp_recv->agent, rmpp_wc, IB_MGMT_RMPP_STATUS_T2L); 258 destroy_rmpp_recv(rmpp_recv); 259 ib_free_recv_mad(rmpp_wc); 260 } 261 262 static void recv_cleanup_handler(struct work_struct *work) 263 { 264 struct mad_rmpp_recv *rmpp_recv = 265 container_of(work, struct mad_rmpp_recv, cleanup_work.work); 266 unsigned long flags; 267 268 spin_lock_irqsave(&rmpp_recv->agent->lock, flags); 269 if (rmpp_recv->state == RMPP_STATE_CANCELING) { 270 spin_unlock_irqrestore(&rmpp_recv->agent->lock, flags); 271 return; 272 } 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(sizeof *rmpp_recv, GFP_KERNEL); 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 atomic_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 return rmpp_recv; 319 320 error: kfree(rmpp_recv); 321 return NULL; 322 } 323 324 static struct mad_rmpp_recv * 325 find_rmpp_recv(struct ib_mad_agent_private *agent, 326 struct ib_mad_recv_wc *mad_recv_wc) 327 { 328 struct mad_rmpp_recv *rmpp_recv; 329 struct ib_mad_hdr *mad_hdr = &mad_recv_wc->recv_buf.mad->mad_hdr; 330 331 list_for_each_entry(rmpp_recv, &agent->rmpp_list, list) { 332 if (rmpp_recv->tid == mad_hdr->tid && 333 rmpp_recv->src_qp == mad_recv_wc->wc->src_qp && 334 rmpp_recv->slid == mad_recv_wc->wc->slid && 335 rmpp_recv->mgmt_class == mad_hdr->mgmt_class && 336 rmpp_recv->class_version == mad_hdr->class_version && 337 rmpp_recv->method == mad_hdr->method) 338 return rmpp_recv; 339 } 340 return NULL; 341 } 342 343 static struct mad_rmpp_recv * 344 acquire_rmpp_recv(struct ib_mad_agent_private *agent, 345 struct ib_mad_recv_wc *mad_recv_wc) 346 { 347 struct mad_rmpp_recv *rmpp_recv; 348 unsigned long flags; 349 350 spin_lock_irqsave(&agent->lock, flags); 351 rmpp_recv = find_rmpp_recv(agent, mad_recv_wc); 352 if (rmpp_recv) 353 atomic_inc(&rmpp_recv->refcount); 354 spin_unlock_irqrestore(&agent->lock, flags); 355 return rmpp_recv; 356 } 357 358 static struct mad_rmpp_recv * 359 insert_rmpp_recv(struct ib_mad_agent_private *agent, 360 struct mad_rmpp_recv *rmpp_recv) 361 { 362 struct mad_rmpp_recv *cur_rmpp_recv; 363 364 cur_rmpp_recv = find_rmpp_recv(agent, rmpp_recv->rmpp_wc); 365 if (!cur_rmpp_recv) 366 list_add_tail(&rmpp_recv->list, &agent->rmpp_list); 367 368 return cur_rmpp_recv; 369 } 370 371 static inline int get_last_flag(struct ib_mad_recv_buf *seg) 372 { 373 struct ib_rmpp_mad *rmpp_mad; 374 375 rmpp_mad = (struct ib_rmpp_mad *) seg->mad; 376 return ib_get_rmpp_flags(&rmpp_mad->rmpp_hdr) & IB_MGMT_RMPP_FLAG_LAST; 377 } 378 379 static inline int get_seg_num(struct ib_mad_recv_buf *seg) 380 { 381 struct ib_rmpp_mad *rmpp_mad; 382 383 rmpp_mad = (struct ib_rmpp_mad *) seg->mad; 384 return be32_to_cpu(rmpp_mad->rmpp_hdr.seg_num); 385 } 386 387 static inline struct ib_mad_recv_buf * get_next_seg(struct list_head *rmpp_list, 388 struct ib_mad_recv_buf *seg) 389 { 390 if (seg->list.next == rmpp_list) 391 return NULL; 392 393 return container_of(seg->list.next, struct ib_mad_recv_buf, list); 394 } 395 396 static inline int window_size(struct ib_mad_agent_private *agent) 397 { 398 return max(agent->qp_info->recv_queue.max_active >> 3, 1); 399 } 400 401 static struct ib_mad_recv_buf * find_seg_location(struct list_head *rmpp_list, 402 int seg_num) 403 { 404 struct ib_mad_recv_buf *seg_buf; 405 int cur_seg_num; 406 407 list_for_each_entry_reverse(seg_buf, rmpp_list, list) { 408 cur_seg_num = get_seg_num(seg_buf); 409 if (seg_num > cur_seg_num) 410 return seg_buf; 411 if (seg_num == cur_seg_num) 412 break; 413 } 414 return NULL; 415 } 416 417 static void update_seg_num(struct mad_rmpp_recv *rmpp_recv, 418 struct ib_mad_recv_buf *new_buf) 419 { 420 struct list_head *rmpp_list = &rmpp_recv->rmpp_wc->rmpp_list; 421 422 while (new_buf && (get_seg_num(new_buf) == rmpp_recv->seg_num + 1)) { 423 rmpp_recv->cur_seg_buf = new_buf; 424 rmpp_recv->seg_num++; 425 new_buf = get_next_seg(rmpp_list, new_buf); 426 } 427 } 428 429 static inline int get_mad_len(struct mad_rmpp_recv *rmpp_recv) 430 { 431 struct ib_rmpp_mad *rmpp_mad; 432 int hdr_size, data_size, pad; 433 434 rmpp_mad = (struct ib_rmpp_mad *)rmpp_recv->cur_seg_buf->mad; 435 436 hdr_size = ib_get_mad_data_offset(rmpp_mad->mad_hdr.mgmt_class); 437 data_size = sizeof(struct ib_rmpp_mad) - hdr_size; 438 pad = IB_MGMT_RMPP_DATA - be32_to_cpu(rmpp_mad->rmpp_hdr.paylen_newwin); 439 if (pad > IB_MGMT_RMPP_DATA || pad < 0) 440 pad = 0; 441 442 return hdr_size + rmpp_recv->seg_num * data_size - pad; 443 } 444 445 static struct ib_mad_recv_wc * complete_rmpp(struct mad_rmpp_recv *rmpp_recv) 446 { 447 struct ib_mad_recv_wc *rmpp_wc; 448 449 ack_recv(rmpp_recv, rmpp_recv->rmpp_wc); 450 if (rmpp_recv->seg_num > 1) 451 cancel_delayed_work(&rmpp_recv->timeout_work); 452 453 rmpp_wc = rmpp_recv->rmpp_wc; 454 rmpp_wc->mad_len = get_mad_len(rmpp_recv); 455 10 seconds until we can find the packet lifetime 456 queue_delayed_work(rmpp_recv->agent->qp_info->port_priv->wq, 457 &rmpp_recv->cleanup_work, msecs_to_jiffies(10000)); 458 return rmpp_wc; 459 } 460 461 static struct ib_mad_recv_wc * 462 continue_rmpp(struct ib_mad_agent_private *agent, 463 struct ib_mad_recv_wc *mad_recv_wc) 464 { 465 struct mad_rmpp_recv *rmpp_recv; 466 struct ib_mad_recv_buf *prev_buf; 467 struct ib_mad_recv_wc *done_wc; 468 int seg_num; 469 unsigned long flags; 470 471 rmpp_recv = acquire_rmpp_recv(agent, mad_recv_wc); 472 if (!rmpp_recv) 473 goto drop1; 474 475 seg_num = get_seg_num(&mad_recv_wc->recv_buf); 476 477 spin_lock_irqsave(&rmpp_recv->lock, flags); 478 if ((rmpp_recv->state == RMPP_STATE_TIMEOUT) || 479 (seg_num > rmpp_recv->newwin)) 480 goto drop3; 481 482 if ((seg_num <= rmpp_recv->last_ack) || 483 (rmpp_recv->state == RMPP_STATE_COMPLETE)) { 484 spin_unlock_irqrestore(&rmpp_recv->lock, flags); 485 ack_recv(rmpp_recv, mad_recv_wc); 486 goto drop2; 487 } 488 489 prev_buf = find_seg_location(&rmpp_recv->rmpp_wc->rmpp_list, seg_num); 490 if (!prev_buf) 491 goto drop3; 492 493 done_wc = NULL; 494 list_add(&mad_recv_wc->recv_buf.list, &prev_buf->list); 495 if (rmpp_recv->cur_seg_buf == prev_buf) { 496 update_seg_num(rmpp_recv, &mad_recv_wc->recv_buf); 497 if (get_last_flag(rmpp_recv->cur_seg_buf)) { 498 rmpp_recv->state = RMPP_STATE_COMPLETE; 499 spin_unlock_irqrestore(&rmpp_recv->lock, flags); 500 done_wc = complete_rmpp(rmpp_recv); 501 goto out; 502 } else if (rmpp_recv->seg_num == rmpp_recv->newwin) { 503 rmpp_recv->newwin += window_size(agent); 504 spin_unlock_irqrestore(&rmpp_recv->lock, flags); 505 ack_recv(rmpp_recv, mad_recv_wc); 506 goto out; 507 } 508 } 509 spin_unlock_irqrestore(&rmpp_recv->lock, flags); 510 out: 511 deref_rmpp_recv(rmpp_recv); 512 return done_wc; 513 514 drop3: spin_unlock_irqrestore(&rmpp_recv->lock, flags); 515 drop2: deref_rmpp_recv(rmpp_recv); 516 drop1: ib_free_recv_mad(mad_recv_wc); 517 return NULL; 518 } 519 520 static struct ib_mad_recv_wc * 521 start_rmpp(struct ib_mad_agent_private *agent, 522 struct ib_mad_recv_wc *mad_recv_wc) 523 { 524 struct mad_rmpp_recv *rmpp_recv; 525 unsigned long flags; 526 527 rmpp_recv = create_rmpp_recv(agent, mad_recv_wc); 528 if (!rmpp_recv) { 529 ib_free_recv_mad(mad_recv_wc); 530 return NULL; 531 } 532 533 spin_lock_irqsave(&agent->lock, flags); 534 if (insert_rmpp_recv(agent, rmpp_recv)) { 535 spin_unlock_irqrestore(&agent->lock, flags); 536 duplicate first MAD 537 destroy_rmpp_recv(rmpp_recv); 538 return continue_rmpp(agent, mad_recv_wc); 539 } 540 atomic_inc(&rmpp_recv->refcount); 541 542 if (get_last_flag(&mad_recv_wc->recv_buf)) { 543 rmpp_recv->state = RMPP_STATE_COMPLETE; 544 spin_unlock_irqrestore(&agent->lock, flags); 545 complete_rmpp(rmpp_recv); 546 } else { 547 spin_unlock_irqrestore(&agent->lock, flags); 548 40 seconds until we can find the packet lifetimes 549 queue_delayed_work(agent->qp_info->port_priv->wq, 550 &rmpp_recv->timeout_work, 551 msecs_to_jiffies(40000)); 552 rmpp_recv->newwin += window_size(agent); 553 ack_recv(rmpp_recv, mad_recv_wc); 554 mad_recv_wc = NULL; 555 } 556 deref_rmpp_recv(rmpp_recv); 557 return mad_recv_wc; 558 } 559 560 static int send_next_seg(struct ib_mad_send_wr_private *mad_send_wr) 561 { 562 struct ib_rmpp_mad *rmpp_mad; 563 int timeout; 564 u32 paylen = 0; 565 566 rmpp_mad = mad_send_wr->send_buf.mad; 567 ib_set_rmpp_flags(&rmpp_mad->rmpp_hdr, IB_MGMT_RMPP_FLAG_ACTIVE); 568 rmpp_mad->rmpp_hdr.seg_num = cpu_to_be32(++mad_send_wr->seg_num); 569 570 if (mad_send_wr->seg_num == 1) { 571 rmpp_mad->rmpp_hdr.rmpp_rtime_flags |= IB_MGMT_RMPP_FLAG_FIRST; 572 paylen = mad_send_wr->send_buf.seg_count * IB_MGMT_RMPP_DATA - 573 mad_send_wr->pad; 574 } 575 576 if (mad_send_wr->seg_num == mad_send_wr->send_buf.seg_count) { 577 rmpp_mad->rmpp_hdr.rmpp_rtime_flags |= IB_MGMT_RMPP_FLAG_LAST; 578 paylen = IB_MGMT_RMPP_DATA - mad_send_wr->pad; 579 } 580 rmpp_mad->rmpp_hdr.paylen_newwin = cpu_to_be32(paylen); 581 582 2 seconds for an ACK until we can find the packet lifetime 583 timeout = mad_send_wr->send_buf.timeout_ms; 584 if (!timeout || timeout > 2000) 585 mad_send_wr->timeout = msecs_to_jiffies(2000); 586 587 return ib_send_mad(mad_send_wr); 588 } 589 590 static void abort_send(struct ib_mad_agent_private *agent, 591 struct ib_mad_recv_wc *mad_recv_wc, u8 rmpp_status) 592 { 593 struct ib_mad_send_wr_private *mad_send_wr; 594 struct ib_mad_send_wc wc; 595 unsigned long flags; 596 597 spin_lock_irqsave(&agent->lock, flags); 598 mad_send_wr = ib_find_send_mad(agent, mad_recv_wc); 599 if (!mad_send_wr) 600 goto out; Unmatched send 601 602 if ((mad_send_wr->last_ack == mad_send_wr->send_buf.seg_count) || 603 (!mad_send_wr->timeout) || (mad_send_wr->status != IB_WC_SUCCESS)) 604 goto out; Send is already done 605 606 ib_mark_mad_done(mad_send_wr); 607 spin_unlock_irqrestore(&agent->lock, flags); 608 609 wc.status = IB_WC_REM_ABORT_ERR; 610 wc.vendor_err = rmpp_status; 611 wc.send_buf = &mad_send_wr->send_buf; 612 ib_mad_complete_send_wr(mad_send_wr, &wc); 613 return; 614 out: 615 spin_unlock_irqrestore(&agent->lock, flags); 616 } 617 618 static inline void adjust_last_ack(struct ib_mad_send_wr_private *wr, 619 int seg_num) 620 { 621 struct list_head *list; 622 623 wr->last_ack = seg_num; 624 list = &wr->last_ack_seg->list; 625 list_for_each_entry(wr->last_ack_seg, list, list) 626 if (wr->last_ack_seg->num == seg_num) 627 break; 628 } 629 630 static void process_ds_ack(struct ib_mad_agent_private *agent, 631 struct ib_mad_recv_wc *mad_recv_wc, int newwin) 632 { 633 struct mad_rmpp_recv *rmpp_recv; 634 635 rmpp_recv = find_rmpp_recv(agent, mad_recv_wc); 636 if (rmpp_recv && rmpp_recv->state == RMPP_STATE_COMPLETE) 637 rmpp_recv->repwin = newwin; 638 } 639 640 static void process_rmpp_ack(struct ib_mad_agent_private *agent, 641 struct ib_mad_recv_wc *mad_recv_wc) 642 { 643 struct ib_mad_send_wr_private *mad_send_wr; 644 struct ib_rmpp_mad *rmpp_mad; 645 unsigned long flags; 646 int seg_num, newwin, ret; 647 648 rmpp_mad = (struct ib_rmpp_mad *)mad_recv_wc->recv_buf.mad; 649 if (rmpp_mad->rmpp_hdr.rmpp_status) { 650 abort_send(agent, mad_recv_wc, IB_MGMT_RMPP_STATUS_BAD_STATUS); 651 nack_recv(agent, mad_recv_wc, IB_MGMT_RMPP_STATUS_BAD_STATUS); 652 return; 653 } 654 655 seg_num = be32_to_cpu(rmpp_mad->rmpp_hdr.seg_num); 656 newwin = be32_to_cpu(rmpp_mad->rmpp_hdr.paylen_newwin); 657 if (newwin < seg_num) { 658 abort_send(agent, mad_recv_wc, IB_MGMT_RMPP_STATUS_W2S); 659 nack_recv(agent, mad_recv_wc, IB_MGMT_RMPP_STATUS_W2S); 660 return; 661 } 662 663 spin_lock_irqsave(&agent->lock, flags); 664 mad_send_wr = ib_find_send_mad(agent, mad_recv_wc); 665 if (!mad_send_wr) { 666 if (!seg_num) 667 process_ds_ack(agent, mad_recv_wc, newwin); 668 goto out; Unmatched or DS RMPP ACK 669 } 670 671 if ((mad_send_wr->last_ack == mad_send_wr->send_buf.seg_count) && 672 (mad_send_wr->timeout)) { 673 spin_unlock_irqrestore(&agent->lock, flags); 674 ack_ds_ack(agent, mad_recv_wc); 675 return; Repeated ACK for DS RMPP transaction 676 } 677 678 if ((mad_send_wr->last_ack == mad_send_wr->send_buf.seg_count) || 679 (!mad_send_wr->timeout) || (mad_send_wr->status != IB_WC_SUCCESS)) 680 goto out; Send is already done 681 682 if (seg_num > mad_send_wr->send_buf.seg_count || 683 seg_num > mad_send_wr->newwin) { 684 spin_unlock_irqrestore(&agent->lock, flags); 685 abort_send(agent, mad_recv_wc, IB_MGMT_RMPP_STATUS_S2B); 686 nack_recv(agent, mad_recv_wc, IB_MGMT_RMPP_STATUS_S2B); 687 return; 688 } 689 690 if (newwin < mad_send_wr->newwin || seg_num < mad_send_wr->last_ack) 691 goto out; Old ACK 692 693 if (seg_num > mad_send_wr->last_ack) { 694 adjust_last_ack(mad_send_wr, seg_num); 695 mad_send_wr->retries_left = mad_send_wr->max_retries; 696 } 697 mad_send_wr->newwin = newwin; 698 if (mad_send_wr->last_ack == mad_send_wr->send_buf.seg_count) { 699 If no response is expected, the ACK completes the send 700 if (!mad_send_wr->send_buf.timeout_ms) { 701 struct ib_mad_send_wc wc; 702 703 ib_mark_mad_done(mad_send_wr); 704 spin_unlock_irqrestore(&agent->lock, flags); 705 706 wc.status = IB_WC_SUCCESS; 707 wc.vendor_err = 0; 708 wc.send_buf = &mad_send_wr->send_buf; 709 ib_mad_complete_send_wr(mad_send_wr, &wc); 710 return; 711 } 712 if (mad_send_wr->refcount == 1) 713 ib_reset_mad_timeout(mad_send_wr, 714 mad_send_wr->send_buf.timeout_ms); 715 spin_unlock_irqrestore(&agent->lock, flags); 716 ack_ds_ack(agent, mad_recv_wc); 717 return; 718 } else if (mad_send_wr->refcount == 1 && 719 mad_send_wr->seg_num < mad_send_wr->newwin && 720 mad_send_wr->seg_num < mad_send_wr->send_buf.seg_count) { 721 Send failure will just result in a timeout/retry 722 ret = send_next_seg(mad_send_wr); 723 if (ret) 724 goto out; 725 726 mad_send_wr->refcount++; 727 list_move_tail(&mad_send_wr->agent_list, 728 &mad_send_wr->mad_agent_priv->send_list); 729 } 730 out: 731 spin_unlock_irqrestore(&agent->lock, flags); 732 } 733 734 static struct ib_mad_recv_wc * 735 process_rmpp_data(struct ib_mad_agent_private *agent, 736 struct ib_mad_recv_wc *mad_recv_wc) 737 { 738 struct ib_rmpp_hdr *rmpp_hdr; 739 u8 rmpp_status; 740 741 rmpp_hdr = &((struct ib_rmpp_mad *)mad_recv_wc->recv_buf.mad)->rmpp_hdr; 742 743 if (rmpp_hdr->rmpp_status) { 744 rmpp_status = IB_MGMT_RMPP_STATUS_BAD_STATUS; 745 goto bad; 746 } 747 748 if (rmpp_hdr->seg_num == cpu_to_be32(1)) { 749 if (!(ib_get_rmpp_flags(rmpp_hdr) & IB_MGMT_RMPP_FLAG_FIRST)) { 750 rmpp_status = IB_MGMT_RMPP_STATUS_BAD_SEG; 751 goto bad; 752 } 753 return start_rmpp(agent, mad_recv_wc); 754 } else { 755 if (ib_get_rmpp_flags(rmpp_hdr) & IB_MGMT_RMPP_FLAG_FIRST) { 756 rmpp_status = IB_MGMT_RMPP_STATUS_BAD_SEG; 757 goto bad; 758 } 759 return continue_rmpp(agent, mad_recv_wc); 760 } 761 bad: 762 nack_recv(agent, mad_recv_wc, rmpp_status); 763 ib_free_recv_mad(mad_recv_wc); 764 return NULL; 765 } 766 767 static void process_rmpp_stop(struct ib_mad_agent_private *agent, 768 struct ib_mad_recv_wc *mad_recv_wc) 769 { 770 struct ib_rmpp_mad *rmpp_mad; 771 772 rmpp_mad = (struct ib_rmpp_mad *)mad_recv_wc->recv_buf.mad; 773 774 if (rmpp_mad->rmpp_hdr.rmpp_status != IB_MGMT_RMPP_STATUS_RESX) { 775 abort_send(agent, mad_recv_wc, IB_MGMT_RMPP_STATUS_BAD_STATUS); 776 nack_recv(agent, mad_recv_wc, IB_MGMT_RMPP_STATUS_BAD_STATUS); 777 } else 778 abort_send(agent, mad_recv_wc, rmpp_mad->rmpp_hdr.rmpp_status); 779 } 780 781 static void process_rmpp_abort(struct ib_mad_agent_private *agent, 782 struct ib_mad_recv_wc *mad_recv_wc) 783 { 784 struct ib_rmpp_mad *rmpp_mad; 785 786 rmpp_mad = (struct ib_rmpp_mad *)mad_recv_wc->recv_buf.mad; 787 788 if (rmpp_mad->rmpp_hdr.rmpp_status < IB_MGMT_RMPP_STATUS_ABORT_MIN || 789 rmpp_mad->rmpp_hdr.rmpp_status > IB_MGMT_RMPP_STATUS_ABORT_MAX) { 790 abort_send(agent, mad_recv_wc, IB_MGMT_RMPP_STATUS_BAD_STATUS); 791 nack_recv(agent, mad_recv_wc, IB_MGMT_RMPP_STATUS_BAD_STATUS); 792 } else 793 abort_send(agent, mad_recv_wc, rmpp_mad->rmpp_hdr.rmpp_status); 794 } 795 796 struct ib_mad_recv_wc * 797 ib_process_rmpp_recv_wc(struct ib_mad_agent_private *agent, 798 struct ib_mad_recv_wc *mad_recv_wc) 799 { 800 struct ib_rmpp_mad *rmpp_mad; 801 802 rmpp_mad = (struct ib_rmpp_mad *)mad_recv_wc->recv_buf.mad; 803 if (!(rmpp_mad->rmpp_hdr.rmpp_rtime_flags & IB_MGMT_RMPP_FLAG_ACTIVE)) 804 return mad_recv_wc; 805 806 if (rmpp_mad->rmpp_hdr.rmpp_version != IB_MGMT_RMPP_VERSION) { 807 abort_send(agent, mad_recv_wc, IB_MGMT_RMPP_STATUS_UNV); 808 nack_recv(agent, mad_recv_wc, IB_MGMT_RMPP_STATUS_UNV); 809 goto out; 810 } 811 812 switch (rmpp_mad->rmpp_hdr.rmpp_type) { 813 case IB_MGMT_RMPP_TYPE_DATA: 814 return process_rmpp_data(agent, mad_recv_wc); 815 case IB_MGMT_RMPP_TYPE_ACK: 816 process_rmpp_ack(agent, mad_recv_wc); 817 break; 818 case IB_MGMT_RMPP_TYPE_STOP: 819 process_rmpp_stop(agent, mad_recv_wc); 820 break; 821 case IB_MGMT_RMPP_TYPE_ABORT: 822 process_rmpp_abort(agent, mad_recv_wc); 823 break; 824 default: 825 abort_send(agent, mad_recv_wc, IB_MGMT_RMPP_STATUS_BADT); 826 nack_recv(agent, mad_recv_wc, IB_MGMT_RMPP_STATUS_BADT); 827 break; 828 } 829 out: 830 ib_free_recv_mad(mad_recv_wc); 831 return NULL; 832 } 833 834 static int init_newwin(struct ib_mad_send_wr_private *mad_send_wr) 835 { 836 struct ib_mad_agent_private *agent = mad_send_wr->mad_agent_priv; 837 struct ib_mad_hdr *mad_hdr = mad_send_wr->send_buf.mad; 838 struct mad_rmpp_recv *rmpp_recv; 839 struct ib_ah_attr ah_attr; 840 unsigned long flags; 841 int newwin = 1; 842 843 if (!(mad_hdr->method & IB_MGMT_METHOD_RESP)) 844 goto out; 845 846 spin_lock_irqsave(&agent->lock, flags); 847 list_for_each_entry(rmpp_recv, &agent->rmpp_list, list) { 848 if (rmpp_recv->tid != mad_hdr->tid || 849 rmpp_recv->mgmt_class != mad_hdr->mgmt_class || 850 rmpp_recv->class_version != mad_hdr->class_version || 851 (rmpp_recv->method & IB_MGMT_METHOD_RESP)) 852 continue; 853 854 if (ib_query_ah(mad_send_wr->send_buf.ah, &ah_attr)) 855 continue; 856 857 if (rmpp_recv->slid == ah_attr.dlid) { 858 newwin = rmpp_recv->repwin; 859 break; 860 } 861 } 862 spin_unlock_irqrestore(&agent->lock, flags); 863 out: 864 return newwin; 865 } 866 867 int ib_send_rmpp_mad(struct ib_mad_send_wr_private *mad_send_wr) 868 { 869 struct ib_rmpp_mad *rmpp_mad; 870 int ret; 871 872 rmpp_mad = mad_send_wr->send_buf.mad; 873 if (!(ib_get_rmpp_flags(&rmpp_mad->rmpp_hdr) & 874 IB_MGMT_RMPP_FLAG_ACTIVE)) 875 return IB_RMPP_RESULT_UNHANDLED; 876 877 if (rmpp_mad->rmpp_hdr.rmpp_type != IB_MGMT_RMPP_TYPE_DATA) { 878 mad_send_wr->seg_num = 1; 879 return IB_RMPP_RESULT_INTERNAL; 880 } 881 882 mad_send_wr->newwin = init_newwin(mad_send_wr); 883 884 We need to wait for the final ACK even if there isn't a response 885 mad_send_wr->refcount += (mad_send_wr->timeout == 0); 886 ret = send_next_seg(mad_send_wr); 887 if (!ret) 888 return IB_RMPP_RESULT_CONSUMED; 889 return ret; 890 } 891 */ 892int ib_process_rmpp_send_wc(struct ib_mad_send_wr_private *mad_send_wr, 893 struct ib_mad_send_wc *mad_send_wc) { 894 struct ib_rmpp_mad *rmpp_mad; 895 int ret; 896 897 rmpp_mad = mad_send_wr->send_buf.mad; 898 if (!(ib_get_rmpp_flags(&rmpp_mad->rmpp_hdr) & IB_MGMT_RMPP_FLAG_ACTIVE)) 899 return IB_RMPP_RESULT_UNHANDLED; /*RMPP not active */ 900 901 if (rmpp_mad->rmpp_hdr.rmpp_type != IB_MGMT_RMPP_TYPE_DATA) 902 return IB_RMPP_RESULT_INTERNAL; /*ACK, STOP, or ABORT*/ 903 904 if (mad_send_wc->status != IB_WC_SUCCESS 905 || mad_send_wr->status != IB_WC_SUCCESS) 906 return IB_RMPP_RESULT_PROCESSED; /*Canceled or send error*/ 907 908 if (!mad_send_wr->timeout) 909 return IB_RMPP_RESULT_PROCESSED; /*Response received */ 910 911 if (mad_send_wr->last_ack == mad_send_wr->send_buf.seg_count) { 912 mad_send_wr->timeout = msecs_to_jiffies( 913 mad_send_wr->send_buf.timeout_ms); 914 return IB_RMPP_RESULT_PROCESSED; /*Send done */ 915 } 916 917 if (mad_send_wr->seg_num == mad_send_wr->newwin 918 || mad_send_wr->seg_num == mad_send_wr->send_buf.seg_count) 919 return IB_RMPP_RESULT_PROCESSED; /*Wait for ACK */ 920 921 ret = send_next_seg(mad_send_wr); 922 if (ret) { 923 mad_send_wc->status = IB_WC_GENERAL_ERR; 924 return IB_RMPP_RESULT_PROCESSED; 925 } 926 return IB_RMPP_RESULT_CONSUMED; 927} 928/* 929 int ib_retry_rmpp(struct ib_mad_send_wr_private *mad_send_wr) 930 { 931 struct ib_rmpp_mad *rmpp_mad; 932 int ret; 933 934 rmpp_mad = mad_send_wr->send_buf.mad; 935 if (!(ib_get_rmpp_flags(&rmpp_mad->rmpp_hdr) & 936 IB_MGMT_RMPP_FLAG_ACTIVE)) 937 return IB_RMPP_RESULT_UNHANDLED; RMPP not active 938 939 if (mad_send_wr->last_ack == mad_send_wr->send_buf.seg_count) 940 return IB_RMPP_RESULT_PROCESSED; 941 942 mad_send_wr->seg_num = mad_send_wr->last_ack; 943 mad_send_wr->cur_seg = mad_send_wr->last_ack_seg; 944 945 ret = send_next_seg(mad_send_wr); 946 if (ret) 947 return IB_RMPP_RESULT_PROCESSED; 948 949 return IB_RMPP_RESULT_CONSUMED; 950 } 951 */ 952