1 /* 2 * Copyright(c) 2007 Intel Corporation. All rights reserved. 3 * Copyright(c) 2008 Red Hat, Inc. All rights reserved. 4 * Copyright(c) 2008 Mike Christie 5 * 6 * This program is free software; you can redistribute it and/or modify it 7 * under the terms and conditions of the GNU General Public License, 8 * version 2, as published by the Free Software Foundation. 9 * 10 * This program is distributed in the hope it will be useful, but WITHOUT 11 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or 12 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for 13 * more details. 14 * 15 * You should have received a copy of the GNU General Public License along with 16 * this program; if not, write to the Free Software Foundation, Inc., 17 * 51 Franklin St - Fifth Floor, Boston, MA 02110-1301 USA. 18 * 19 * Maintained at www.Open-FCoE.org 20 */ 21 22 /* 23 * Fibre Channel exchange and sequence handling. 24 */ 25 26 #include <linux/timer.h> 27 #include <linux/slab.h> 28 #include <linux/err.h> 29 30 #include <scsi/fc/fc_fc2.h> 31 32 #include <scsi/libfc.h> 33 #include <scsi/fc_encode.h> 34 35 #include "fc_libfc.h" 36 37 u16 fc_cpu_mask; /* cpu mask for possible cpus */ 38 EXPORT_SYMBOL(fc_cpu_mask); 39 static u16 fc_cpu_order; /* 2's power to represent total possible cpus */ 40 static struct kmem_cache *fc_em_cachep; /* cache for exchanges */ 41 struct workqueue_struct *fc_exch_workqueue; 42 43 /* 44 * Structure and function definitions for managing Fibre Channel Exchanges 45 * and Sequences. 46 * 47 * The three primary structures used here are fc_exch_mgr, fc_exch, and fc_seq. 48 * 49 * fc_exch_mgr holds the exchange state for an N port 50 * 51 * fc_exch holds state for one exchange and links to its active sequence. 52 * 53 * fc_seq holds the state for an individual sequence. 54 */ 55 56 /** 57 * struct fc_exch_pool - Per cpu exchange pool 58 * @next_index: Next possible free exchange index 59 * @total_exches: Total allocated exchanges 60 * @lock: Exch pool lock 61 * @ex_list: List of exchanges 62 * 63 * This structure manages per cpu exchanges in array of exchange pointers. 64 * This array is allocated followed by struct fc_exch_pool memory for 65 * assigned range of exchanges to per cpu pool. 66 */ 67 struct fc_exch_pool { 68 u16 next_index; 69 u16 total_exches; 70 spinlock_t lock; 71 struct list_head ex_list; 72 }; 73 74 /** 75 * struct fc_exch_mgr - The Exchange Manager (EM). 76 * @class: Default class for new sequences 77 * @kref: Reference counter 78 * @min_xid: Minimum exchange ID 79 * @max_xid: Maximum exchange ID 80 * @ep_pool: Reserved exchange pointers 81 * @pool_max_index: Max exch array index in exch pool 82 * @pool: Per cpu exch pool 83 * @stats: Statistics structure 84 * 85 * This structure is the center for creating exchanges and sequences. 86 * It manages the allocation of exchange IDs. 87 */ 88 struct fc_exch_mgr { 89 enum fc_class class; 90 struct kref kref; 91 u16 min_xid; 92 u16 max_xid; 93 mempool_t *ep_pool; 94 u16 pool_max_index; 95 struct fc_exch_pool *pool; 96 97 /* 98 * currently exchange mgr stats are updated but not used. 99 * either stats can be expose via sysfs or remove them 100 * all together if not used XXX 101 */ 102 struct { 103 atomic_t no_free_exch; 104 atomic_t no_free_exch_xid; 105 atomic_t xid_not_found; 106 atomic_t xid_busy; 107 atomic_t seq_not_found; 108 atomic_t non_bls_resp; 109 } stats; 110 }; 111 #define fc_seq_exch(sp) container_of(sp, struct fc_exch, seq) 112 113 /** 114 * struct fc_exch_mgr_anchor - primary structure for list of EMs 115 * @ema_list: Exchange Manager Anchor list 116 * @mp: Exchange Manager associated with this anchor 117 * @match: Routine to determine if this anchor's EM should be used 118 * 119 * When walking the list of anchors the match routine will be called 120 * for each anchor to determine if that EM should be used. The last 121 * anchor in the list will always match to handle any exchanges not 122 * handled by other EMs. The non-default EMs would be added to the 123 * anchor list by HW that provides FCoE offloads. 124 */ 125 struct fc_exch_mgr_anchor { 126 struct list_head ema_list; 127 struct fc_exch_mgr *mp; 128 bool (*match)(struct fc_frame *); 129 }; 130 131 static void fc_exch_rrq(struct fc_exch *); 132 static void fc_seq_ls_acc(struct fc_seq *); 133 static void fc_seq_ls_rjt(struct fc_seq *, enum fc_els_rjt_reason, 134 enum fc_els_rjt_explan); 135 static void fc_exch_els_rec(struct fc_seq *, struct fc_frame *); 136 static void fc_exch_els_rrq(struct fc_seq *, struct fc_frame *); 137 138 /* 139 * Internal implementation notes. 140 * 141 * The exchange manager is one by default in libfc but LLD may choose 142 * to have one per CPU. The sequence manager is one per exchange manager 143 * and currently never separated. 144 * 145 * Section 9.8 in FC-FS-2 specifies: "The SEQ_ID is a one-byte field 146 * assigned by the Sequence Initiator that shall be unique for a specific 147 * D_ID and S_ID pair while the Sequence is open." Note that it isn't 148 * qualified by exchange ID, which one might think it would be. 149 * In practice this limits the number of open sequences and exchanges to 256 150 * per session. For most targets we could treat this limit as per exchange. 151 * 152 * The exchange and its sequence are freed when the last sequence is received. 153 * It's possible for the remote port to leave an exchange open without 154 * sending any sequences. 155 * 156 * Notes on reference counts: 157 * 158 * Exchanges are reference counted and exchange gets freed when the reference 159 * count becomes zero. 160 * 161 * Timeouts: 162 * Sequences are timed out for E_D_TOV and R_A_TOV. 163 * 164 * Sequence event handling: 165 * 166 * The following events may occur on initiator sequences: 167 * 168 * Send. 169 * For now, the whole thing is sent. 170 * Receive ACK 171 * This applies only to class F. 172 * The sequence is marked complete. 173 * ULP completion. 174 * The upper layer calls fc_exch_done() when done 175 * with exchange and sequence tuple. 176 * RX-inferred completion. 177 * When we receive the next sequence on the same exchange, we can 178 * retire the previous sequence ID. (XXX not implemented). 179 * Timeout. 180 * R_A_TOV frees the sequence ID. If we're waiting for ACK, 181 * E_D_TOV causes abort and calls upper layer response handler 182 * with FC_EX_TIMEOUT error. 183 * Receive RJT 184 * XXX defer. 185 * Send ABTS 186 * On timeout. 187 * 188 * The following events may occur on recipient sequences: 189 * 190 * Receive 191 * Allocate sequence for first frame received. 192 * Hold during receive handler. 193 * Release when final frame received. 194 * Keep status of last N of these for the ELS RES command. XXX TBD. 195 * Receive ABTS 196 * Deallocate sequence 197 * Send RJT 198 * Deallocate 199 * 200 * For now, we neglect conditions where only part of a sequence was 201 * received or transmitted, or where out-of-order receipt is detected. 202 */ 203 204 /* 205 * Locking notes: 206 * 207 * The EM code run in a per-CPU worker thread. 208 * 209 * To protect against concurrency between a worker thread code and timers, 210 * sequence allocation and deallocation must be locked. 211 * - exchange refcnt can be done atomicly without locks. 212 * - sequence allocation must be locked by exch lock. 213 * - If the EM pool lock and ex_lock must be taken at the same time, then the 214 * EM pool lock must be taken before the ex_lock. 215 */ 216 217 /* 218 * opcode names for debugging. 219 */ 220 static char *fc_exch_rctl_names[] = FC_RCTL_NAMES_INIT; 221 222 #define FC_TABLE_SIZE(x) (sizeof(x) / sizeof(x[0])) 223 224 /** 225 * fc_exch_name_lookup() - Lookup name by opcode 226 * @op: Opcode to be looked up 227 * @table: Opcode/name table 228 * @max_index: Index not to be exceeded 229 * 230 * This routine is used to determine a human-readable string identifying 231 * a R_CTL opcode. 232 */ 233 static inline const char *fc_exch_name_lookup(unsigned int op, char **table, 234 unsigned int max_index) 235 { 236 const char *name = NULL; 237 238 if (op < max_index) 239 name = table[op]; 240 if (!name) 241 name = "unknown"; 242 return name; 243 } 244 245 /** 246 * fc_exch_rctl_name() - Wrapper routine for fc_exch_name_lookup() 247 * @op: The opcode to be looked up 248 */ 249 static const char *fc_exch_rctl_name(unsigned int op) 250 { 251 return fc_exch_name_lookup(op, fc_exch_rctl_names, 252 FC_TABLE_SIZE(fc_exch_rctl_names)); 253 } 254 255 /** 256 * fc_exch_hold() - Increment an exchange's reference count 257 * @ep: Echange to be held 258 */ 259 static inline void fc_exch_hold(struct fc_exch *ep) 260 { 261 atomic_inc(&ep->ex_refcnt); 262 } 263 264 /** 265 * fc_exch_setup_hdr() - Initialize a FC header by initializing some fields 266 * and determine SOF and EOF. 267 * @ep: The exchange to that will use the header 268 * @fp: The frame whose header is to be modified 269 * @f_ctl: F_CTL bits that will be used for the frame header 270 * 271 * The fields initialized by this routine are: fh_ox_id, fh_rx_id, 272 * fh_seq_id, fh_seq_cnt and the SOF and EOF. 273 */ 274 static void fc_exch_setup_hdr(struct fc_exch *ep, struct fc_frame *fp, 275 u32 f_ctl) 276 { 277 struct fc_frame_header *fh = fc_frame_header_get(fp); 278 u16 fill; 279 280 fr_sof(fp) = ep->class; 281 if (ep->seq.cnt) 282 fr_sof(fp) = fc_sof_normal(ep->class); 283 284 if (f_ctl & FC_FC_END_SEQ) { 285 fr_eof(fp) = FC_EOF_T; 286 if (fc_sof_needs_ack(ep->class)) 287 fr_eof(fp) = FC_EOF_N; 288 /* 289 * From F_CTL. 290 * The number of fill bytes to make the length a 4-byte 291 * multiple is the low order 2-bits of the f_ctl. 292 * The fill itself will have been cleared by the frame 293 * allocation. 294 * After this, the length will be even, as expected by 295 * the transport. 296 */ 297 fill = fr_len(fp) & 3; 298 if (fill) { 299 fill = 4 - fill; 300 /* TODO, this may be a problem with fragmented skb */ 301 skb_put(fp_skb(fp), fill); 302 hton24(fh->fh_f_ctl, f_ctl | fill); 303 } 304 } else { 305 WARN_ON(fr_len(fp) % 4 != 0); /* no pad to non last frame */ 306 fr_eof(fp) = FC_EOF_N; 307 } 308 309 /* 310 * Initialize remainig fh fields 311 * from fc_fill_fc_hdr 312 */ 313 fh->fh_ox_id = htons(ep->oxid); 314 fh->fh_rx_id = htons(ep->rxid); 315 fh->fh_seq_id = ep->seq.id; 316 fh->fh_seq_cnt = htons(ep->seq.cnt); 317 } 318 319 /** 320 * fc_exch_release() - Decrement an exchange's reference count 321 * @ep: Exchange to be released 322 * 323 * If the reference count reaches zero and the exchange is complete, 324 * it is freed. 325 */ 326 static void fc_exch_release(struct fc_exch *ep) 327 { 328 struct fc_exch_mgr *mp; 329 330 if (atomic_dec_and_test(&ep->ex_refcnt)) { 331 mp = ep->em; 332 if (ep->destructor) 333 ep->destructor(&ep->seq, ep->arg); 334 WARN_ON(!(ep->esb_stat & ESB_ST_COMPLETE)); 335 mempool_free(ep, mp->ep_pool); 336 } 337 } 338 339 /** 340 * fc_exch_done_locked() - Complete an exchange with the exchange lock held 341 * @ep: The exchange that is complete 342 */ 343 static int fc_exch_done_locked(struct fc_exch *ep) 344 { 345 int rc = 1; 346 347 /* 348 * We must check for completion in case there are two threads 349 * tyring to complete this. But the rrq code will reuse the 350 * ep, and in that case we only clear the resp and set it as 351 * complete, so it can be reused by the timer to send the rrq. 352 */ 353 ep->resp = NULL; 354 if (ep->state & FC_EX_DONE) 355 return rc; 356 ep->esb_stat |= ESB_ST_COMPLETE; 357 358 if (!(ep->esb_stat & ESB_ST_REC_QUAL)) { 359 ep->state |= FC_EX_DONE; 360 if (cancel_delayed_work(&ep->timeout_work)) 361 atomic_dec(&ep->ex_refcnt); /* drop hold for timer */ 362 rc = 0; 363 } 364 return rc; 365 } 366 367 /** 368 * fc_exch_ptr_get() - Return an exchange from an exchange pool 369 * @pool: Exchange Pool to get an exchange from 370 * @index: Index of the exchange within the pool 371 * 372 * Use the index to get an exchange from within an exchange pool. exches 373 * will point to an array of exchange pointers. The index will select 374 * the exchange within the array. 375 */ 376 static inline struct fc_exch *fc_exch_ptr_get(struct fc_exch_pool *pool, 377 u16 index) 378 { 379 struct fc_exch **exches = (struct fc_exch **)(pool + 1); 380 return exches[index]; 381 } 382 383 /** 384 * fc_exch_ptr_set() - Assign an exchange to a slot in an exchange pool 385 * @pool: The pool to assign the exchange to 386 * @index: The index in the pool where the exchange will be assigned 387 * @ep: The exchange to assign to the pool 388 */ 389 static inline void fc_exch_ptr_set(struct fc_exch_pool *pool, u16 index, 390 struct fc_exch *ep) 391 { 392 ((struct fc_exch **)(pool + 1))[index] = ep; 393 } 394 395 /** 396 * fc_exch_delete() - Delete an exchange 397 * @ep: The exchange to be deleted 398 */ 399 static void fc_exch_delete(struct fc_exch *ep) 400 { 401 struct fc_exch_pool *pool; 402 403 pool = ep->pool; 404 spin_lock_bh(&pool->lock); 405 WARN_ON(pool->total_exches <= 0); 406 pool->total_exches--; 407 fc_exch_ptr_set(pool, (ep->xid - ep->em->min_xid) >> fc_cpu_order, 408 NULL); 409 list_del(&ep->ex_list); 410 spin_unlock_bh(&pool->lock); 411 fc_exch_release(ep); /* drop hold for exch in mp */ 412 } 413 414 /** 415 * fc_exch_timer_set_locked() - Start a timer for an exchange w/ the 416 * the exchange lock held 417 * @ep: The exchange whose timer will start 418 * @timer_msec: The timeout period 419 * 420 * Used for upper level protocols to time out the exchange. 421 * The timer is cancelled when it fires or when the exchange completes. 422 */ 423 static inline void fc_exch_timer_set_locked(struct fc_exch *ep, 424 unsigned int timer_msec) 425 { 426 if (ep->state & (FC_EX_RST_CLEANUP | FC_EX_DONE)) 427 return; 428 429 FC_EXCH_DBG(ep, "Exchange timer armed\n"); 430 431 if (queue_delayed_work(fc_exch_workqueue, &ep->timeout_work, 432 msecs_to_jiffies(timer_msec))) 433 fc_exch_hold(ep); /* hold for timer */ 434 } 435 436 /** 437 * fc_exch_timer_set() - Lock the exchange and set the timer 438 * @ep: The exchange whose timer will start 439 * @timer_msec: The timeout period 440 */ 441 static void fc_exch_timer_set(struct fc_exch *ep, unsigned int timer_msec) 442 { 443 spin_lock_bh(&ep->ex_lock); 444 fc_exch_timer_set_locked(ep, timer_msec); 445 spin_unlock_bh(&ep->ex_lock); 446 } 447 448 /** 449 * fc_seq_send() - Send a frame using existing sequence/exchange pair 450 * @lport: The local port that the exchange will be sent on 451 * @sp: The sequence to be sent 452 * @fp: The frame to be sent on the exchange 453 */ 454 static int fc_seq_send(struct fc_lport *lport, struct fc_seq *sp, 455 struct fc_frame *fp) 456 { 457 struct fc_exch *ep; 458 struct fc_frame_header *fh = fc_frame_header_get(fp); 459 int error; 460 u32 f_ctl; 461 462 ep = fc_seq_exch(sp); 463 WARN_ON((ep->esb_stat & ESB_ST_SEQ_INIT) != ESB_ST_SEQ_INIT); 464 465 f_ctl = ntoh24(fh->fh_f_ctl); 466 fc_exch_setup_hdr(ep, fp, f_ctl); 467 468 /* 469 * update sequence count if this frame is carrying 470 * multiple FC frames when sequence offload is enabled 471 * by LLD. 472 */ 473 if (fr_max_payload(fp)) 474 sp->cnt += DIV_ROUND_UP((fr_len(fp) - sizeof(*fh)), 475 fr_max_payload(fp)); 476 else 477 sp->cnt++; 478 479 /* 480 * Send the frame. 481 */ 482 error = lport->tt.frame_send(lport, fp); 483 484 /* 485 * Update the exchange and sequence flags, 486 * assuming all frames for the sequence have been sent. 487 * We can only be called to send once for each sequence. 488 */ 489 spin_lock_bh(&ep->ex_lock); 490 ep->f_ctl = f_ctl & ~FC_FC_FIRST_SEQ; /* not first seq */ 491 if (f_ctl & FC_FC_SEQ_INIT) 492 ep->esb_stat &= ~ESB_ST_SEQ_INIT; 493 spin_unlock_bh(&ep->ex_lock); 494 return error; 495 } 496 497 /** 498 * fc_seq_alloc() - Allocate a sequence for a given exchange 499 * @ep: The exchange to allocate a new sequence for 500 * @seq_id: The sequence ID to be used 501 * 502 * We don't support multiple originated sequences on the same exchange. 503 * By implication, any previously originated sequence on this exchange 504 * is complete, and we reallocate the same sequence. 505 */ 506 static struct fc_seq *fc_seq_alloc(struct fc_exch *ep, u8 seq_id) 507 { 508 struct fc_seq *sp; 509 510 sp = &ep->seq; 511 sp->ssb_stat = 0; 512 sp->cnt = 0; 513 sp->id = seq_id; 514 return sp; 515 } 516 517 /** 518 * fc_seq_start_next_locked() - Allocate a new sequence on the same 519 * exchange as the supplied sequence 520 * @sp: The sequence/exchange to get a new sequence for 521 */ 522 static struct fc_seq *fc_seq_start_next_locked(struct fc_seq *sp) 523 { 524 struct fc_exch *ep = fc_seq_exch(sp); 525 526 sp = fc_seq_alloc(ep, ep->seq_id++); 527 FC_EXCH_DBG(ep, "f_ctl %6x seq %2x\n", 528 ep->f_ctl, sp->id); 529 return sp; 530 } 531 532 /** 533 * fc_seq_start_next() - Lock the exchange and get a new sequence 534 * for a given sequence/exchange pair 535 * @sp: The sequence/exchange to get a new exchange for 536 */ 537 static struct fc_seq *fc_seq_start_next(struct fc_seq *sp) 538 { 539 struct fc_exch *ep = fc_seq_exch(sp); 540 541 spin_lock_bh(&ep->ex_lock); 542 sp = fc_seq_start_next_locked(sp); 543 spin_unlock_bh(&ep->ex_lock); 544 545 return sp; 546 } 547 548 /** 549 * fc_seq_exch_abort() - Abort an exchange and sequence 550 * @req_sp: The sequence to be aborted 551 * @timer_msec: The period of time to wait before aborting 552 * 553 * Generally called because of a timeout or an abort from the upper layer. 554 */ 555 static int fc_seq_exch_abort(const struct fc_seq *req_sp, 556 unsigned int timer_msec) 557 { 558 struct fc_seq *sp; 559 struct fc_exch *ep; 560 struct fc_frame *fp; 561 int error; 562 563 ep = fc_seq_exch(req_sp); 564 565 spin_lock_bh(&ep->ex_lock); 566 if (ep->esb_stat & (ESB_ST_COMPLETE | ESB_ST_ABNORMAL) || 567 ep->state & (FC_EX_DONE | FC_EX_RST_CLEANUP)) { 568 spin_unlock_bh(&ep->ex_lock); 569 return -ENXIO; 570 } 571 572 /* 573 * Send the abort on a new sequence if possible. 574 */ 575 sp = fc_seq_start_next_locked(&ep->seq); 576 if (!sp) { 577 spin_unlock_bh(&ep->ex_lock); 578 return -ENOMEM; 579 } 580 581 ep->esb_stat |= ESB_ST_SEQ_INIT | ESB_ST_ABNORMAL; 582 if (timer_msec) 583 fc_exch_timer_set_locked(ep, timer_msec); 584 spin_unlock_bh(&ep->ex_lock); 585 586 /* 587 * If not logged into the fabric, don't send ABTS but leave 588 * sequence active until next timeout. 589 */ 590 if (!ep->sid) 591 return 0; 592 593 /* 594 * Send an abort for the sequence that timed out. 595 */ 596 fp = fc_frame_alloc(ep->lp, 0); 597 if (fp) { 598 fc_fill_fc_hdr(fp, FC_RCTL_BA_ABTS, ep->did, ep->sid, 599 FC_TYPE_BLS, FC_FC_END_SEQ | FC_FC_SEQ_INIT, 0); 600 error = fc_seq_send(ep->lp, sp, fp); 601 } else 602 error = -ENOBUFS; 603 return error; 604 } 605 606 /** 607 * fc_exch_timeout() - Handle exchange timer expiration 608 * @work: The work_struct identifying the exchange that timed out 609 */ 610 static void fc_exch_timeout(struct work_struct *work) 611 { 612 struct fc_exch *ep = container_of(work, struct fc_exch, 613 timeout_work.work); 614 struct fc_seq *sp = &ep->seq; 615 void (*resp)(struct fc_seq *, struct fc_frame *fp, void *arg); 616 void *arg; 617 u32 e_stat; 618 int rc = 1; 619 620 FC_EXCH_DBG(ep, "Exchange timed out\n"); 621 622 spin_lock_bh(&ep->ex_lock); 623 if (ep->state & (FC_EX_RST_CLEANUP | FC_EX_DONE)) 624 goto unlock; 625 626 e_stat = ep->esb_stat; 627 if (e_stat & ESB_ST_COMPLETE) { 628 ep->esb_stat = e_stat & ~ESB_ST_REC_QUAL; 629 spin_unlock_bh(&ep->ex_lock); 630 if (e_stat & ESB_ST_REC_QUAL) 631 fc_exch_rrq(ep); 632 goto done; 633 } else { 634 resp = ep->resp; 635 arg = ep->arg; 636 ep->resp = NULL; 637 if (e_stat & ESB_ST_ABNORMAL) 638 rc = fc_exch_done_locked(ep); 639 spin_unlock_bh(&ep->ex_lock); 640 if (!rc) 641 fc_exch_delete(ep); 642 if (resp) 643 resp(sp, ERR_PTR(-FC_EX_TIMEOUT), arg); 644 fc_seq_exch_abort(sp, 2 * ep->r_a_tov); 645 goto done; 646 } 647 unlock: 648 spin_unlock_bh(&ep->ex_lock); 649 done: 650 /* 651 * This release matches the hold taken when the timer was set. 652 */ 653 fc_exch_release(ep); 654 } 655 656 /** 657 * fc_exch_em_alloc() - Allocate an exchange from a specified EM. 658 * @lport: The local port that the exchange is for 659 * @mp: The exchange manager that will allocate the exchange 660 * 661 * Returns pointer to allocated fc_exch with exch lock held. 662 */ 663 static struct fc_exch *fc_exch_em_alloc(struct fc_lport *lport, 664 struct fc_exch_mgr *mp) 665 { 666 struct fc_exch *ep; 667 unsigned int cpu; 668 u16 index; 669 struct fc_exch_pool *pool; 670 671 /* allocate memory for exchange */ 672 ep = mempool_alloc(mp->ep_pool, GFP_ATOMIC); 673 if (!ep) { 674 atomic_inc(&mp->stats.no_free_exch); 675 goto out; 676 } 677 memset(ep, 0, sizeof(*ep)); 678 679 cpu = get_cpu(); 680 pool = per_cpu_ptr(mp->pool, cpu); 681 spin_lock_bh(&pool->lock); 682 put_cpu(); 683 index = pool->next_index; 684 /* allocate new exch from pool */ 685 while (fc_exch_ptr_get(pool, index)) { 686 index = index == mp->pool_max_index ? 0 : index + 1; 687 if (index == pool->next_index) 688 goto err; 689 } 690 pool->next_index = index == mp->pool_max_index ? 0 : index + 1; 691 692 fc_exch_hold(ep); /* hold for exch in mp */ 693 spin_lock_init(&ep->ex_lock); 694 /* 695 * Hold exch lock for caller to prevent fc_exch_reset() 696 * from releasing exch while fc_exch_alloc() caller is 697 * still working on exch. 698 */ 699 spin_lock_bh(&ep->ex_lock); 700 701 fc_exch_ptr_set(pool, index, ep); 702 list_add_tail(&ep->ex_list, &pool->ex_list); 703 fc_seq_alloc(ep, ep->seq_id++); 704 pool->total_exches++; 705 spin_unlock_bh(&pool->lock); 706 707 /* 708 * update exchange 709 */ 710 ep->oxid = ep->xid = (index << fc_cpu_order | cpu) + mp->min_xid; 711 ep->em = mp; 712 ep->pool = pool; 713 ep->lp = lport; 714 ep->f_ctl = FC_FC_FIRST_SEQ; /* next seq is first seq */ 715 ep->rxid = FC_XID_UNKNOWN; 716 ep->class = mp->class; 717 INIT_DELAYED_WORK(&ep->timeout_work, fc_exch_timeout); 718 out: 719 return ep; 720 err: 721 spin_unlock_bh(&pool->lock); 722 atomic_inc(&mp->stats.no_free_exch_xid); 723 mempool_free(ep, mp->ep_pool); 724 return NULL; 725 } 726 727 /** 728 * fc_exch_alloc() - Allocate an exchange from an EM on a 729 * local port's list of EMs. 730 * @lport: The local port that will own the exchange 731 * @fp: The FC frame that the exchange will be for 732 * 733 * This function walks the list of exchange manager(EM) 734 * anchors to select an EM for a new exchange allocation. The 735 * EM is selected when a NULL match function pointer is encountered 736 * or when a call to a match function returns true. 737 */ 738 static inline struct fc_exch *fc_exch_alloc(struct fc_lport *lport, 739 struct fc_frame *fp) 740 { 741 struct fc_exch_mgr_anchor *ema; 742 743 list_for_each_entry(ema, &lport->ema_list, ema_list) 744 if (!ema->match || ema->match(fp)) 745 return fc_exch_em_alloc(lport, ema->mp); 746 return NULL; 747 } 748 749 /** 750 * fc_exch_find() - Lookup and hold an exchange 751 * @mp: The exchange manager to lookup the exchange from 752 * @xid: The XID of the exchange to look up 753 */ 754 static struct fc_exch *fc_exch_find(struct fc_exch_mgr *mp, u16 xid) 755 { 756 struct fc_exch_pool *pool; 757 struct fc_exch *ep = NULL; 758 759 if ((xid >= mp->min_xid) && (xid <= mp->max_xid)) { 760 pool = per_cpu_ptr(mp->pool, xid & fc_cpu_mask); 761 spin_lock_bh(&pool->lock); 762 ep = fc_exch_ptr_get(pool, (xid - mp->min_xid) >> fc_cpu_order); 763 if (ep) { 764 fc_exch_hold(ep); 765 WARN_ON(ep->xid != xid); 766 } 767 spin_unlock_bh(&pool->lock); 768 } 769 return ep; 770 } 771 772 773 /** 774 * fc_exch_done() - Indicate that an exchange/sequence tuple is complete and 775 * the memory allocated for the related objects may be freed. 776 * @sp: The sequence that has completed 777 */ 778 static void fc_exch_done(struct fc_seq *sp) 779 { 780 struct fc_exch *ep = fc_seq_exch(sp); 781 int rc; 782 783 spin_lock_bh(&ep->ex_lock); 784 rc = fc_exch_done_locked(ep); 785 spin_unlock_bh(&ep->ex_lock); 786 if (!rc) 787 fc_exch_delete(ep); 788 } 789 790 /** 791 * fc_exch_resp() - Allocate a new exchange for a response frame 792 * @lport: The local port that the exchange was for 793 * @mp: The exchange manager to allocate the exchange from 794 * @fp: The response frame 795 * 796 * Sets the responder ID in the frame header. 797 */ 798 static struct fc_exch *fc_exch_resp(struct fc_lport *lport, 799 struct fc_exch_mgr *mp, 800 struct fc_frame *fp) 801 { 802 struct fc_exch *ep; 803 struct fc_frame_header *fh; 804 805 ep = fc_exch_alloc(lport, fp); 806 if (ep) { 807 ep->class = fc_frame_class(fp); 808 809 /* 810 * Set EX_CTX indicating we're responding on this exchange. 811 */ 812 ep->f_ctl |= FC_FC_EX_CTX; /* we're responding */ 813 ep->f_ctl &= ~FC_FC_FIRST_SEQ; /* not new */ 814 fh = fc_frame_header_get(fp); 815 ep->sid = ntoh24(fh->fh_d_id); 816 ep->did = ntoh24(fh->fh_s_id); 817 ep->oid = ep->did; 818 819 /* 820 * Allocated exchange has placed the XID in the 821 * originator field. Move it to the responder field, 822 * and set the originator XID from the frame. 823 */ 824 ep->rxid = ep->xid; 825 ep->oxid = ntohs(fh->fh_ox_id); 826 ep->esb_stat |= ESB_ST_RESP | ESB_ST_SEQ_INIT; 827 if ((ntoh24(fh->fh_f_ctl) & FC_FC_SEQ_INIT) == 0) 828 ep->esb_stat &= ~ESB_ST_SEQ_INIT; 829 830 fc_exch_hold(ep); /* hold for caller */ 831 spin_unlock_bh(&ep->ex_lock); /* lock from fc_exch_alloc */ 832 } 833 return ep; 834 } 835 836 /** 837 * fc_seq_lookup_recip() - Find a sequence where the other end 838 * originated the sequence 839 * @lport: The local port that the frame was sent to 840 * @mp: The Exchange Manager to lookup the exchange from 841 * @fp: The frame associated with the sequence we're looking for 842 * 843 * If fc_pf_rjt_reason is FC_RJT_NONE then this function will have a hold 844 * on the ep that should be released by the caller. 845 */ 846 static enum fc_pf_rjt_reason fc_seq_lookup_recip(struct fc_lport *lport, 847 struct fc_exch_mgr *mp, 848 struct fc_frame *fp) 849 { 850 struct fc_frame_header *fh = fc_frame_header_get(fp); 851 struct fc_exch *ep = NULL; 852 struct fc_seq *sp = NULL; 853 enum fc_pf_rjt_reason reject = FC_RJT_NONE; 854 u32 f_ctl; 855 u16 xid; 856 857 f_ctl = ntoh24(fh->fh_f_ctl); 858 WARN_ON((f_ctl & FC_FC_SEQ_CTX) != 0); 859 860 /* 861 * Lookup or create the exchange if we will be creating the sequence. 862 */ 863 if (f_ctl & FC_FC_EX_CTX) { 864 xid = ntohs(fh->fh_ox_id); /* we originated exch */ 865 ep = fc_exch_find(mp, xid); 866 if (!ep) { 867 atomic_inc(&mp->stats.xid_not_found); 868 reject = FC_RJT_OX_ID; 869 goto out; 870 } 871 if (ep->rxid == FC_XID_UNKNOWN) 872 ep->rxid = ntohs(fh->fh_rx_id); 873 else if (ep->rxid != ntohs(fh->fh_rx_id)) { 874 reject = FC_RJT_OX_ID; 875 goto rel; 876 } 877 } else { 878 xid = ntohs(fh->fh_rx_id); /* we are the responder */ 879 880 /* 881 * Special case for MDS issuing an ELS TEST with a 882 * bad rxid of 0. 883 * XXX take this out once we do the proper reject. 884 */ 885 if (xid == 0 && fh->fh_r_ctl == FC_RCTL_ELS_REQ && 886 fc_frame_payload_op(fp) == ELS_TEST) { 887 fh->fh_rx_id = htons(FC_XID_UNKNOWN); 888 xid = FC_XID_UNKNOWN; 889 } 890 891 /* 892 * new sequence - find the exchange 893 */ 894 ep = fc_exch_find(mp, xid); 895 if ((f_ctl & FC_FC_FIRST_SEQ) && fc_sof_is_init(fr_sof(fp))) { 896 if (ep) { 897 atomic_inc(&mp->stats.xid_busy); 898 reject = FC_RJT_RX_ID; 899 goto rel; 900 } 901 ep = fc_exch_resp(lport, mp, fp); 902 if (!ep) { 903 reject = FC_RJT_EXCH_EST; /* XXX */ 904 goto out; 905 } 906 xid = ep->xid; /* get our XID */ 907 } else if (!ep) { 908 atomic_inc(&mp->stats.xid_not_found); 909 reject = FC_RJT_RX_ID; /* XID not found */ 910 goto out; 911 } 912 } 913 914 /* 915 * At this point, we have the exchange held. 916 * Find or create the sequence. 917 */ 918 if (fc_sof_is_init(fr_sof(fp))) { 919 sp = &ep->seq; 920 sp->ssb_stat |= SSB_ST_RESP; 921 sp->id = fh->fh_seq_id; 922 } else { 923 sp = &ep->seq; 924 if (sp->id != fh->fh_seq_id) { 925 atomic_inc(&mp->stats.seq_not_found); 926 reject = FC_RJT_SEQ_ID; /* sequence/exch should exist */ 927 goto rel; 928 } 929 } 930 WARN_ON(ep != fc_seq_exch(sp)); 931 932 if (f_ctl & FC_FC_SEQ_INIT) 933 ep->esb_stat |= ESB_ST_SEQ_INIT; 934 935 fr_seq(fp) = sp; 936 out: 937 return reject; 938 rel: 939 fc_exch_done(&ep->seq); 940 fc_exch_release(ep); /* hold from fc_exch_find/fc_exch_resp */ 941 return reject; 942 } 943 944 /** 945 * fc_seq_lookup_orig() - Find a sequence where this end 946 * originated the sequence 947 * @mp: The Exchange Manager to lookup the exchange from 948 * @fp: The frame associated with the sequence we're looking for 949 * 950 * Does not hold the sequence for the caller. 951 */ 952 static struct fc_seq *fc_seq_lookup_orig(struct fc_exch_mgr *mp, 953 struct fc_frame *fp) 954 { 955 struct fc_frame_header *fh = fc_frame_header_get(fp); 956 struct fc_exch *ep; 957 struct fc_seq *sp = NULL; 958 u32 f_ctl; 959 u16 xid; 960 961 f_ctl = ntoh24(fh->fh_f_ctl); 962 WARN_ON((f_ctl & FC_FC_SEQ_CTX) != FC_FC_SEQ_CTX); 963 xid = ntohs((f_ctl & FC_FC_EX_CTX) ? fh->fh_ox_id : fh->fh_rx_id); 964 ep = fc_exch_find(mp, xid); 965 if (!ep) 966 return NULL; 967 if (ep->seq.id == fh->fh_seq_id) { 968 /* 969 * Save the RX_ID if we didn't previously know it. 970 */ 971 sp = &ep->seq; 972 if ((f_ctl & FC_FC_EX_CTX) != 0 && 973 ep->rxid == FC_XID_UNKNOWN) { 974 ep->rxid = ntohs(fh->fh_rx_id); 975 } 976 } 977 fc_exch_release(ep); 978 return sp; 979 } 980 981 /** 982 * fc_exch_set_addr() - Set the source and destination IDs for an exchange 983 * @ep: The exchange to set the addresses for 984 * @orig_id: The originator's ID 985 * @resp_id: The responder's ID 986 * 987 * Note this must be done before the first sequence of the exchange is sent. 988 */ 989 static void fc_exch_set_addr(struct fc_exch *ep, 990 u32 orig_id, u32 resp_id) 991 { 992 ep->oid = orig_id; 993 if (ep->esb_stat & ESB_ST_RESP) { 994 ep->sid = resp_id; 995 ep->did = orig_id; 996 } else { 997 ep->sid = orig_id; 998 ep->did = resp_id; 999 } 1000 } 1001 1002 /** 1003 * fc_seq_els_rsp_send() - Send an ELS response using infomation from 1004 * the existing sequence/exchange. 1005 * @sp: The sequence/exchange to get information from 1006 * @els_cmd: The ELS command to be sent 1007 * @els_data: The ELS data to be sent 1008 */ 1009 static void fc_seq_els_rsp_send(struct fc_seq *sp, enum fc_els_cmd els_cmd, 1010 struct fc_seq_els_data *els_data) 1011 { 1012 switch (els_cmd) { 1013 case ELS_LS_RJT: 1014 fc_seq_ls_rjt(sp, els_data->reason, els_data->explan); 1015 break; 1016 case ELS_LS_ACC: 1017 fc_seq_ls_acc(sp); 1018 break; 1019 case ELS_RRQ: 1020 fc_exch_els_rrq(sp, els_data->fp); 1021 break; 1022 case ELS_REC: 1023 fc_exch_els_rec(sp, els_data->fp); 1024 break; 1025 default: 1026 FC_EXCH_DBG(fc_seq_exch(sp), "Invalid ELS CMD:%x\n", els_cmd); 1027 } 1028 } 1029 1030 /** 1031 * fc_seq_send_last() - Send a sequence that is the last in the exchange 1032 * @sp: The sequence that is to be sent 1033 * @fp: The frame that will be sent on the sequence 1034 * @rctl: The R_CTL information to be sent 1035 * @fh_type: The frame header type 1036 */ 1037 static void fc_seq_send_last(struct fc_seq *sp, struct fc_frame *fp, 1038 enum fc_rctl rctl, enum fc_fh_type fh_type) 1039 { 1040 u32 f_ctl; 1041 struct fc_exch *ep = fc_seq_exch(sp); 1042 1043 f_ctl = FC_FC_LAST_SEQ | FC_FC_END_SEQ | FC_FC_SEQ_INIT; 1044 f_ctl |= ep->f_ctl; 1045 fc_fill_fc_hdr(fp, rctl, ep->did, ep->sid, fh_type, f_ctl, 0); 1046 fc_seq_send(ep->lp, sp, fp); 1047 } 1048 1049 /** 1050 * fc_seq_send_ack() - Send an acknowledgement that we've received a frame 1051 * @sp: The sequence to send the ACK on 1052 * @rx_fp: The received frame that is being acknoledged 1053 * 1054 * Send ACK_1 (or equiv.) indicating we received something. 1055 */ 1056 static void fc_seq_send_ack(struct fc_seq *sp, const struct fc_frame *rx_fp) 1057 { 1058 struct fc_frame *fp; 1059 struct fc_frame_header *rx_fh; 1060 struct fc_frame_header *fh; 1061 struct fc_exch *ep = fc_seq_exch(sp); 1062 struct fc_lport *lport = ep->lp; 1063 unsigned int f_ctl; 1064 1065 /* 1066 * Don't send ACKs for class 3. 1067 */ 1068 if (fc_sof_needs_ack(fr_sof(rx_fp))) { 1069 fp = fc_frame_alloc(lport, 0); 1070 if (!fp) 1071 return; 1072 1073 fh = fc_frame_header_get(fp); 1074 fh->fh_r_ctl = FC_RCTL_ACK_1; 1075 fh->fh_type = FC_TYPE_BLS; 1076 1077 /* 1078 * Form f_ctl by inverting EX_CTX and SEQ_CTX (bits 23, 22). 1079 * Echo FIRST_SEQ, LAST_SEQ, END_SEQ, END_CONN, SEQ_INIT. 1080 * Bits 9-8 are meaningful (retransmitted or unidirectional). 1081 * Last ACK uses bits 7-6 (continue sequence), 1082 * bits 5-4 are meaningful (what kind of ACK to use). 1083 */ 1084 rx_fh = fc_frame_header_get(rx_fp); 1085 f_ctl = ntoh24(rx_fh->fh_f_ctl); 1086 f_ctl &= FC_FC_EX_CTX | FC_FC_SEQ_CTX | 1087 FC_FC_FIRST_SEQ | FC_FC_LAST_SEQ | 1088 FC_FC_END_SEQ | FC_FC_END_CONN | FC_FC_SEQ_INIT | 1089 FC_FC_RETX_SEQ | FC_FC_UNI_TX; 1090 f_ctl ^= FC_FC_EX_CTX | FC_FC_SEQ_CTX; 1091 hton24(fh->fh_f_ctl, f_ctl); 1092 1093 fc_exch_setup_hdr(ep, fp, f_ctl); 1094 fh->fh_seq_id = rx_fh->fh_seq_id; 1095 fh->fh_seq_cnt = rx_fh->fh_seq_cnt; 1096 fh->fh_parm_offset = htonl(1); /* ack single frame */ 1097 1098 fr_sof(fp) = fr_sof(rx_fp); 1099 if (f_ctl & FC_FC_END_SEQ) 1100 fr_eof(fp) = FC_EOF_T; 1101 else 1102 fr_eof(fp) = FC_EOF_N; 1103 1104 lport->tt.frame_send(lport, fp); 1105 } 1106 } 1107 1108 /** 1109 * fc_exch_send_ba_rjt() - Send BLS Reject 1110 * @rx_fp: The frame being rejected 1111 * @reason: The reason the frame is being rejected 1112 * @explan: The explaination for the rejection 1113 * 1114 * This is for rejecting BA_ABTS only. 1115 */ 1116 static void fc_exch_send_ba_rjt(struct fc_frame *rx_fp, 1117 enum fc_ba_rjt_reason reason, 1118 enum fc_ba_rjt_explan explan) 1119 { 1120 struct fc_frame *fp; 1121 struct fc_frame_header *rx_fh; 1122 struct fc_frame_header *fh; 1123 struct fc_ba_rjt *rp; 1124 struct fc_lport *lport; 1125 unsigned int f_ctl; 1126 1127 lport = fr_dev(rx_fp); 1128 fp = fc_frame_alloc(lport, sizeof(*rp)); 1129 if (!fp) 1130 return; 1131 fh = fc_frame_header_get(fp); 1132 rx_fh = fc_frame_header_get(rx_fp); 1133 1134 memset(fh, 0, sizeof(*fh) + sizeof(*rp)); 1135 1136 rp = fc_frame_payload_get(fp, sizeof(*rp)); 1137 rp->br_reason = reason; 1138 rp->br_explan = explan; 1139 1140 /* 1141 * seq_id, cs_ctl, df_ctl and param/offset are zero. 1142 */ 1143 memcpy(fh->fh_s_id, rx_fh->fh_d_id, 3); 1144 memcpy(fh->fh_d_id, rx_fh->fh_s_id, 3); 1145 fh->fh_ox_id = rx_fh->fh_ox_id; 1146 fh->fh_rx_id = rx_fh->fh_rx_id; 1147 fh->fh_seq_cnt = rx_fh->fh_seq_cnt; 1148 fh->fh_r_ctl = FC_RCTL_BA_RJT; 1149 fh->fh_type = FC_TYPE_BLS; 1150 1151 /* 1152 * Form f_ctl by inverting EX_CTX and SEQ_CTX (bits 23, 22). 1153 * Echo FIRST_SEQ, LAST_SEQ, END_SEQ, END_CONN, SEQ_INIT. 1154 * Bits 9-8 are meaningful (retransmitted or unidirectional). 1155 * Last ACK uses bits 7-6 (continue sequence), 1156 * bits 5-4 are meaningful (what kind of ACK to use). 1157 * Always set LAST_SEQ, END_SEQ. 1158 */ 1159 f_ctl = ntoh24(rx_fh->fh_f_ctl); 1160 f_ctl &= FC_FC_EX_CTX | FC_FC_SEQ_CTX | 1161 FC_FC_END_CONN | FC_FC_SEQ_INIT | 1162 FC_FC_RETX_SEQ | FC_FC_UNI_TX; 1163 f_ctl ^= FC_FC_EX_CTX | FC_FC_SEQ_CTX; 1164 f_ctl |= FC_FC_LAST_SEQ | FC_FC_END_SEQ; 1165 f_ctl &= ~FC_FC_FIRST_SEQ; 1166 hton24(fh->fh_f_ctl, f_ctl); 1167 1168 fr_sof(fp) = fc_sof_class(fr_sof(rx_fp)); 1169 fr_eof(fp) = FC_EOF_T; 1170 if (fc_sof_needs_ack(fr_sof(fp))) 1171 fr_eof(fp) = FC_EOF_N; 1172 1173 lport->tt.frame_send(lport, fp); 1174 } 1175 1176 /** 1177 * fc_exch_recv_abts() - Handle an incoming ABTS 1178 * @ep: The exchange the abort was on 1179 * @rx_fp: The ABTS frame 1180 * 1181 * This would be for target mode usually, but could be due to lost 1182 * FCP transfer ready, confirm or RRQ. We always handle this as an 1183 * exchange abort, ignoring the parameter. 1184 */ 1185 static void fc_exch_recv_abts(struct fc_exch *ep, struct fc_frame *rx_fp) 1186 { 1187 struct fc_frame *fp; 1188 struct fc_ba_acc *ap; 1189 struct fc_frame_header *fh; 1190 struct fc_seq *sp; 1191 1192 if (!ep) 1193 goto reject; 1194 spin_lock_bh(&ep->ex_lock); 1195 if (ep->esb_stat & ESB_ST_COMPLETE) { 1196 spin_unlock_bh(&ep->ex_lock); 1197 goto reject; 1198 } 1199 if (!(ep->esb_stat & ESB_ST_REC_QUAL)) 1200 fc_exch_hold(ep); /* hold for REC_QUAL */ 1201 ep->esb_stat |= ESB_ST_ABNORMAL | ESB_ST_REC_QUAL; 1202 fc_exch_timer_set_locked(ep, ep->r_a_tov); 1203 1204 fp = fc_frame_alloc(ep->lp, sizeof(*ap)); 1205 if (!fp) { 1206 spin_unlock_bh(&ep->ex_lock); 1207 goto free; 1208 } 1209 fh = fc_frame_header_get(fp); 1210 ap = fc_frame_payload_get(fp, sizeof(*ap)); 1211 memset(ap, 0, sizeof(*ap)); 1212 sp = &ep->seq; 1213 ap->ba_high_seq_cnt = htons(0xffff); 1214 if (sp->ssb_stat & SSB_ST_RESP) { 1215 ap->ba_seq_id = sp->id; 1216 ap->ba_seq_id_val = FC_BA_SEQ_ID_VAL; 1217 ap->ba_high_seq_cnt = fh->fh_seq_cnt; 1218 ap->ba_low_seq_cnt = htons(sp->cnt); 1219 } 1220 sp = fc_seq_start_next_locked(sp); 1221 spin_unlock_bh(&ep->ex_lock); 1222 fc_seq_send_last(sp, fp, FC_RCTL_BA_ACC, FC_TYPE_BLS); 1223 fc_frame_free(rx_fp); 1224 return; 1225 1226 reject: 1227 fc_exch_send_ba_rjt(rx_fp, FC_BA_RJT_UNABLE, FC_BA_RJT_INV_XID); 1228 free: 1229 fc_frame_free(rx_fp); 1230 } 1231 1232 /** 1233 * fc_exch_recv_req() - Handler for an incoming request where is other 1234 * end is originating the sequence 1235 * @lport: The local port that received the request 1236 * @mp: The EM that the exchange is on 1237 * @fp: The request frame 1238 */ 1239 static void fc_exch_recv_req(struct fc_lport *lport, struct fc_exch_mgr *mp, 1240 struct fc_frame *fp) 1241 { 1242 struct fc_frame_header *fh = fc_frame_header_get(fp); 1243 struct fc_seq *sp = NULL; 1244 struct fc_exch *ep = NULL; 1245 enum fc_pf_rjt_reason reject; 1246 1247 /* We can have the wrong fc_lport at this point with NPIV, which is a 1248 * problem now that we know a new exchange needs to be allocated 1249 */ 1250 lport = fc_vport_id_lookup(lport, ntoh24(fh->fh_d_id)); 1251 if (!lport) { 1252 fc_frame_free(fp); 1253 return; 1254 } 1255 1256 fr_seq(fp) = NULL; 1257 reject = fc_seq_lookup_recip(lport, mp, fp); 1258 if (reject == FC_RJT_NONE) { 1259 sp = fr_seq(fp); /* sequence will be held */ 1260 ep = fc_seq_exch(sp); 1261 fc_seq_send_ack(sp, fp); 1262 1263 /* 1264 * Call the receive function. 1265 * 1266 * The receive function may allocate a new sequence 1267 * over the old one, so we shouldn't change the 1268 * sequence after this. 1269 * 1270 * The frame will be freed by the receive function. 1271 * If new exch resp handler is valid then call that 1272 * first. 1273 */ 1274 if (ep->resp) 1275 ep->resp(sp, fp, ep->arg); 1276 else 1277 lport->tt.lport_recv(lport, sp, fp); 1278 fc_exch_release(ep); /* release from lookup */ 1279 } else { 1280 FC_LPORT_DBG(lport, "exch/seq lookup failed: reject %x\n", 1281 reject); 1282 fc_frame_free(fp); 1283 } 1284 } 1285 1286 /** 1287 * fc_exch_recv_seq_resp() - Handler for an incoming response where the other 1288 * end is the originator of the sequence that is a 1289 * response to our initial exchange 1290 * @mp: The EM that the exchange is on 1291 * @fp: The response frame 1292 */ 1293 static void fc_exch_recv_seq_resp(struct fc_exch_mgr *mp, struct fc_frame *fp) 1294 { 1295 struct fc_frame_header *fh = fc_frame_header_get(fp); 1296 struct fc_seq *sp; 1297 struct fc_exch *ep; 1298 enum fc_sof sof; 1299 u32 f_ctl; 1300 void (*resp)(struct fc_seq *, struct fc_frame *fp, void *arg); 1301 void *ex_resp_arg; 1302 int rc; 1303 1304 ep = fc_exch_find(mp, ntohs(fh->fh_ox_id)); 1305 if (!ep) { 1306 atomic_inc(&mp->stats.xid_not_found); 1307 goto out; 1308 } 1309 if (ep->esb_stat & ESB_ST_COMPLETE) { 1310 atomic_inc(&mp->stats.xid_not_found); 1311 goto out; 1312 } 1313 if (ep->rxid == FC_XID_UNKNOWN) 1314 ep->rxid = ntohs(fh->fh_rx_id); 1315 if (ep->sid != 0 && ep->sid != ntoh24(fh->fh_d_id)) { 1316 atomic_inc(&mp->stats.xid_not_found); 1317 goto rel; 1318 } 1319 if (ep->did != ntoh24(fh->fh_s_id) && 1320 ep->did != FC_FID_FLOGI) { 1321 atomic_inc(&mp->stats.xid_not_found); 1322 goto rel; 1323 } 1324 sof = fr_sof(fp); 1325 sp = &ep->seq; 1326 if (fc_sof_is_init(sof)) { 1327 sp->ssb_stat |= SSB_ST_RESP; 1328 sp->id = fh->fh_seq_id; 1329 } else if (sp->id != fh->fh_seq_id) { 1330 atomic_inc(&mp->stats.seq_not_found); 1331 goto rel; 1332 } 1333 1334 f_ctl = ntoh24(fh->fh_f_ctl); 1335 fr_seq(fp) = sp; 1336 if (f_ctl & FC_FC_SEQ_INIT) 1337 ep->esb_stat |= ESB_ST_SEQ_INIT; 1338 1339 if (fc_sof_needs_ack(sof)) 1340 fc_seq_send_ack(sp, fp); 1341 resp = ep->resp; 1342 ex_resp_arg = ep->arg; 1343 1344 if (fh->fh_type != FC_TYPE_FCP && fr_eof(fp) == FC_EOF_T && 1345 (f_ctl & (FC_FC_LAST_SEQ | FC_FC_END_SEQ)) == 1346 (FC_FC_LAST_SEQ | FC_FC_END_SEQ)) { 1347 spin_lock_bh(&ep->ex_lock); 1348 rc = fc_exch_done_locked(ep); 1349 WARN_ON(fc_seq_exch(sp) != ep); 1350 spin_unlock_bh(&ep->ex_lock); 1351 if (!rc) 1352 fc_exch_delete(ep); 1353 } 1354 1355 /* 1356 * Call the receive function. 1357 * The sequence is held (has a refcnt) for us, 1358 * but not for the receive function. 1359 * 1360 * The receive function may allocate a new sequence 1361 * over the old one, so we shouldn't change the 1362 * sequence after this. 1363 * 1364 * The frame will be freed by the receive function. 1365 * If new exch resp handler is valid then call that 1366 * first. 1367 */ 1368 if (resp) 1369 resp(sp, fp, ex_resp_arg); 1370 else 1371 fc_frame_free(fp); 1372 fc_exch_release(ep); 1373 return; 1374 rel: 1375 fc_exch_release(ep); 1376 out: 1377 fc_frame_free(fp); 1378 } 1379 1380 /** 1381 * fc_exch_recv_resp() - Handler for a sequence where other end is 1382 * responding to our sequence 1383 * @mp: The EM that the exchange is on 1384 * @fp: The response frame 1385 */ 1386 static void fc_exch_recv_resp(struct fc_exch_mgr *mp, struct fc_frame *fp) 1387 { 1388 struct fc_seq *sp; 1389 1390 sp = fc_seq_lookup_orig(mp, fp); /* doesn't hold sequence */ 1391 1392 if (!sp) 1393 atomic_inc(&mp->stats.xid_not_found); 1394 else 1395 atomic_inc(&mp->stats.non_bls_resp); 1396 1397 fc_frame_free(fp); 1398 } 1399 1400 /** 1401 * fc_exch_abts_resp() - Handler for a response to an ABT 1402 * @ep: The exchange that the frame is on 1403 * @fp: The response frame 1404 * 1405 * This response would be to an ABTS cancelling an exchange or sequence. 1406 * The response can be either BA_ACC or BA_RJT 1407 */ 1408 static void fc_exch_abts_resp(struct fc_exch *ep, struct fc_frame *fp) 1409 { 1410 void (*resp)(struct fc_seq *, struct fc_frame *fp, void *arg); 1411 void *ex_resp_arg; 1412 struct fc_frame_header *fh; 1413 struct fc_ba_acc *ap; 1414 struct fc_seq *sp; 1415 u16 low; 1416 u16 high; 1417 int rc = 1, has_rec = 0; 1418 1419 fh = fc_frame_header_get(fp); 1420 FC_EXCH_DBG(ep, "exch: BLS rctl %x - %s\n", fh->fh_r_ctl, 1421 fc_exch_rctl_name(fh->fh_r_ctl)); 1422 1423 if (cancel_delayed_work_sync(&ep->timeout_work)) 1424 fc_exch_release(ep); /* release from pending timer hold */ 1425 1426 spin_lock_bh(&ep->ex_lock); 1427 switch (fh->fh_r_ctl) { 1428 case FC_RCTL_BA_ACC: 1429 ap = fc_frame_payload_get(fp, sizeof(*ap)); 1430 if (!ap) 1431 break; 1432 1433 /* 1434 * Decide whether to establish a Recovery Qualifier. 1435 * We do this if there is a non-empty SEQ_CNT range and 1436 * SEQ_ID is the same as the one we aborted. 1437 */ 1438 low = ntohs(ap->ba_low_seq_cnt); 1439 high = ntohs(ap->ba_high_seq_cnt); 1440 if ((ep->esb_stat & ESB_ST_REC_QUAL) == 0 && 1441 (ap->ba_seq_id_val != FC_BA_SEQ_ID_VAL || 1442 ap->ba_seq_id == ep->seq_id) && low != high) { 1443 ep->esb_stat |= ESB_ST_REC_QUAL; 1444 fc_exch_hold(ep); /* hold for recovery qualifier */ 1445 has_rec = 1; 1446 } 1447 break; 1448 case FC_RCTL_BA_RJT: 1449 break; 1450 default: 1451 break; 1452 } 1453 1454 resp = ep->resp; 1455 ex_resp_arg = ep->arg; 1456 1457 /* do we need to do some other checks here. Can we reuse more of 1458 * fc_exch_recv_seq_resp 1459 */ 1460 sp = &ep->seq; 1461 /* 1462 * do we want to check END_SEQ as well as LAST_SEQ here? 1463 */ 1464 if (ep->fh_type != FC_TYPE_FCP && 1465 ntoh24(fh->fh_f_ctl) & FC_FC_LAST_SEQ) 1466 rc = fc_exch_done_locked(ep); 1467 spin_unlock_bh(&ep->ex_lock); 1468 if (!rc) 1469 fc_exch_delete(ep); 1470 1471 if (resp) 1472 resp(sp, fp, ex_resp_arg); 1473 else 1474 fc_frame_free(fp); 1475 1476 if (has_rec) 1477 fc_exch_timer_set(ep, ep->r_a_tov); 1478 1479 } 1480 1481 /** 1482 * fc_exch_recv_bls() - Handler for a BLS sequence 1483 * @mp: The EM that the exchange is on 1484 * @fp: The request frame 1485 * 1486 * The BLS frame is always a sequence initiated by the remote side. 1487 * We may be either the originator or recipient of the exchange. 1488 */ 1489 static void fc_exch_recv_bls(struct fc_exch_mgr *mp, struct fc_frame *fp) 1490 { 1491 struct fc_frame_header *fh; 1492 struct fc_exch *ep; 1493 u32 f_ctl; 1494 1495 fh = fc_frame_header_get(fp); 1496 f_ctl = ntoh24(fh->fh_f_ctl); 1497 fr_seq(fp) = NULL; 1498 1499 ep = fc_exch_find(mp, (f_ctl & FC_FC_EX_CTX) ? 1500 ntohs(fh->fh_ox_id) : ntohs(fh->fh_rx_id)); 1501 if (ep && (f_ctl & FC_FC_SEQ_INIT)) { 1502 spin_lock_bh(&ep->ex_lock); 1503 ep->esb_stat |= ESB_ST_SEQ_INIT; 1504 spin_unlock_bh(&ep->ex_lock); 1505 } 1506 if (f_ctl & FC_FC_SEQ_CTX) { 1507 /* 1508 * A response to a sequence we initiated. 1509 * This should only be ACKs for class 2 or F. 1510 */ 1511 switch (fh->fh_r_ctl) { 1512 case FC_RCTL_ACK_1: 1513 case FC_RCTL_ACK_0: 1514 break; 1515 default: 1516 FC_EXCH_DBG(ep, "BLS rctl %x - %s received", 1517 fh->fh_r_ctl, 1518 fc_exch_rctl_name(fh->fh_r_ctl)); 1519 break; 1520 } 1521 fc_frame_free(fp); 1522 } else { 1523 switch (fh->fh_r_ctl) { 1524 case FC_RCTL_BA_RJT: 1525 case FC_RCTL_BA_ACC: 1526 if (ep) 1527 fc_exch_abts_resp(ep, fp); 1528 else 1529 fc_frame_free(fp); 1530 break; 1531 case FC_RCTL_BA_ABTS: 1532 fc_exch_recv_abts(ep, fp); 1533 break; 1534 default: /* ignore junk */ 1535 fc_frame_free(fp); 1536 break; 1537 } 1538 } 1539 if (ep) 1540 fc_exch_release(ep); /* release hold taken by fc_exch_find */ 1541 } 1542 1543 /** 1544 * fc_seq_ls_acc() - Accept sequence with LS_ACC 1545 * @req_sp: The request sequence 1546 * 1547 * If this fails due to allocation or transmit congestion, assume the 1548 * originator will repeat the sequence. 1549 */ 1550 static void fc_seq_ls_acc(struct fc_seq *req_sp) 1551 { 1552 struct fc_seq *sp; 1553 struct fc_els_ls_acc *acc; 1554 struct fc_frame *fp; 1555 1556 sp = fc_seq_start_next(req_sp); 1557 fp = fc_frame_alloc(fc_seq_exch(sp)->lp, sizeof(*acc)); 1558 if (fp) { 1559 acc = fc_frame_payload_get(fp, sizeof(*acc)); 1560 memset(acc, 0, sizeof(*acc)); 1561 acc->la_cmd = ELS_LS_ACC; 1562 fc_seq_send_last(sp, fp, FC_RCTL_ELS_REP, FC_TYPE_ELS); 1563 } 1564 } 1565 1566 /** 1567 * fc_seq_ls_rjt() - Reject a sequence with ELS LS_RJT 1568 * @req_sp: The request sequence 1569 * @reason: The reason the sequence is being rejected 1570 * @explan: The explaination for the rejection 1571 * 1572 * If this fails due to allocation or transmit congestion, assume the 1573 * originator will repeat the sequence. 1574 */ 1575 static void fc_seq_ls_rjt(struct fc_seq *req_sp, enum fc_els_rjt_reason reason, 1576 enum fc_els_rjt_explan explan) 1577 { 1578 struct fc_seq *sp; 1579 struct fc_els_ls_rjt *rjt; 1580 struct fc_frame *fp; 1581 1582 sp = fc_seq_start_next(req_sp); 1583 fp = fc_frame_alloc(fc_seq_exch(sp)->lp, sizeof(*rjt)); 1584 if (fp) { 1585 rjt = fc_frame_payload_get(fp, sizeof(*rjt)); 1586 memset(rjt, 0, sizeof(*rjt)); 1587 rjt->er_cmd = ELS_LS_RJT; 1588 rjt->er_reason = reason; 1589 rjt->er_explan = explan; 1590 fc_seq_send_last(sp, fp, FC_RCTL_ELS_REP, FC_TYPE_ELS); 1591 } 1592 } 1593 1594 /** 1595 * fc_exch_reset() - Reset an exchange 1596 * @ep: The exchange to be reset 1597 */ 1598 static void fc_exch_reset(struct fc_exch *ep) 1599 { 1600 struct fc_seq *sp; 1601 void (*resp)(struct fc_seq *, struct fc_frame *, void *); 1602 void *arg; 1603 int rc = 1; 1604 1605 spin_lock_bh(&ep->ex_lock); 1606 ep->state |= FC_EX_RST_CLEANUP; 1607 if (cancel_delayed_work(&ep->timeout_work)) 1608 atomic_dec(&ep->ex_refcnt); /* drop hold for timer */ 1609 resp = ep->resp; 1610 ep->resp = NULL; 1611 if (ep->esb_stat & ESB_ST_REC_QUAL) 1612 atomic_dec(&ep->ex_refcnt); /* drop hold for rec_qual */ 1613 ep->esb_stat &= ~ESB_ST_REC_QUAL; 1614 arg = ep->arg; 1615 sp = &ep->seq; 1616 rc = fc_exch_done_locked(ep); 1617 spin_unlock_bh(&ep->ex_lock); 1618 if (!rc) 1619 fc_exch_delete(ep); 1620 1621 if (resp) 1622 resp(sp, ERR_PTR(-FC_EX_CLOSED), arg); 1623 } 1624 1625 /** 1626 * fc_exch_pool_reset() - Reset a per cpu exchange pool 1627 * @lport: The local port that the exchange pool is on 1628 * @pool: The exchange pool to be reset 1629 * @sid: The source ID 1630 * @did: The destination ID 1631 * 1632 * Resets a per cpu exches pool, releasing all of its sequences 1633 * and exchanges. If sid is non-zero then reset only exchanges 1634 * we sourced from the local port's FID. If did is non-zero then 1635 * only reset exchanges destined for the local port's FID. 1636 */ 1637 static void fc_exch_pool_reset(struct fc_lport *lport, 1638 struct fc_exch_pool *pool, 1639 u32 sid, u32 did) 1640 { 1641 struct fc_exch *ep; 1642 struct fc_exch *next; 1643 1644 spin_lock_bh(&pool->lock); 1645 restart: 1646 list_for_each_entry_safe(ep, next, &pool->ex_list, ex_list) { 1647 if ((lport == ep->lp) && 1648 (sid == 0 || sid == ep->sid) && 1649 (did == 0 || did == ep->did)) { 1650 fc_exch_hold(ep); 1651 spin_unlock_bh(&pool->lock); 1652 1653 fc_exch_reset(ep); 1654 1655 fc_exch_release(ep); 1656 spin_lock_bh(&pool->lock); 1657 1658 /* 1659 * must restart loop incase while lock 1660 * was down multiple eps were released. 1661 */ 1662 goto restart; 1663 } 1664 } 1665 spin_unlock_bh(&pool->lock); 1666 } 1667 1668 /** 1669 * fc_exch_mgr_reset() - Reset all EMs of a local port 1670 * @lport: The local port whose EMs are to be reset 1671 * @sid: The source ID 1672 * @did: The destination ID 1673 * 1674 * Reset all EMs associated with a given local port. Release all 1675 * sequences and exchanges. If sid is non-zero then reset only the 1676 * exchanges sent from the local port's FID. If did is non-zero then 1677 * reset only exchanges destined for the local port's FID. 1678 */ 1679 void fc_exch_mgr_reset(struct fc_lport *lport, u32 sid, u32 did) 1680 { 1681 struct fc_exch_mgr_anchor *ema; 1682 unsigned int cpu; 1683 1684 list_for_each_entry(ema, &lport->ema_list, ema_list) { 1685 for_each_possible_cpu(cpu) 1686 fc_exch_pool_reset(lport, 1687 per_cpu_ptr(ema->mp->pool, cpu), 1688 sid, did); 1689 } 1690 } 1691 EXPORT_SYMBOL(fc_exch_mgr_reset); 1692 1693 /** 1694 * fc_exch_els_rec() - Handler for ELS REC (Read Exchange Concise) requests 1695 * @sp: The sequence the REC is on 1696 * @rfp: The REC frame 1697 * 1698 * Note that the requesting port may be different than the S_ID in the request. 1699 */ 1700 static void fc_exch_els_rec(struct fc_seq *sp, struct fc_frame *rfp) 1701 { 1702 struct fc_frame *fp; 1703 struct fc_exch *ep; 1704 struct fc_exch_mgr *em; 1705 struct fc_els_rec *rp; 1706 struct fc_els_rec_acc *acc; 1707 enum fc_els_rjt_reason reason = ELS_RJT_LOGIC; 1708 enum fc_els_rjt_explan explan; 1709 u32 sid; 1710 u16 rxid; 1711 u16 oxid; 1712 1713 rp = fc_frame_payload_get(rfp, sizeof(*rp)); 1714 explan = ELS_EXPL_INV_LEN; 1715 if (!rp) 1716 goto reject; 1717 sid = ntoh24(rp->rec_s_id); 1718 rxid = ntohs(rp->rec_rx_id); 1719 oxid = ntohs(rp->rec_ox_id); 1720 1721 /* 1722 * Currently it's hard to find the local S_ID from the exchange 1723 * manager. This will eventually be fixed, but for now it's easier 1724 * to lookup the subject exchange twice, once as if we were 1725 * the initiator, and then again if we weren't. 1726 */ 1727 em = fc_seq_exch(sp)->em; 1728 ep = fc_exch_find(em, oxid); 1729 explan = ELS_EXPL_OXID_RXID; 1730 if (ep && ep->oid == sid) { 1731 if (ep->rxid != FC_XID_UNKNOWN && 1732 rxid != FC_XID_UNKNOWN && 1733 ep->rxid != rxid) 1734 goto rel; 1735 } else { 1736 if (ep) 1737 fc_exch_release(ep); 1738 ep = NULL; 1739 if (rxid != FC_XID_UNKNOWN) 1740 ep = fc_exch_find(em, rxid); 1741 if (!ep) 1742 goto reject; 1743 } 1744 1745 fp = fc_frame_alloc(fc_seq_exch(sp)->lp, sizeof(*acc)); 1746 if (!fp) { 1747 fc_exch_done(sp); 1748 goto out; 1749 } 1750 acc = fc_frame_payload_get(fp, sizeof(*acc)); 1751 memset(acc, 0, sizeof(*acc)); 1752 acc->reca_cmd = ELS_LS_ACC; 1753 acc->reca_ox_id = rp->rec_ox_id; 1754 memcpy(acc->reca_ofid, rp->rec_s_id, 3); 1755 acc->reca_rx_id = htons(ep->rxid); 1756 if (ep->sid == ep->oid) 1757 hton24(acc->reca_rfid, ep->did); 1758 else 1759 hton24(acc->reca_rfid, ep->sid); 1760 acc->reca_fc4value = htonl(ep->seq.rec_data); 1761 acc->reca_e_stat = htonl(ep->esb_stat & (ESB_ST_RESP | 1762 ESB_ST_SEQ_INIT | 1763 ESB_ST_COMPLETE)); 1764 sp = fc_seq_start_next(sp); 1765 fc_seq_send_last(sp, fp, FC_RCTL_ELS_REP, FC_TYPE_ELS); 1766 out: 1767 fc_exch_release(ep); 1768 fc_frame_free(rfp); 1769 return; 1770 1771 rel: 1772 fc_exch_release(ep); 1773 reject: 1774 fc_seq_ls_rjt(sp, reason, explan); 1775 fc_frame_free(rfp); 1776 } 1777 1778 /** 1779 * fc_exch_rrq_resp() - Handler for RRQ responses 1780 * @sp: The sequence that the RRQ is on 1781 * @fp: The RRQ frame 1782 * @arg: The exchange that the RRQ is on 1783 * 1784 * TODO: fix error handler. 1785 */ 1786 static void fc_exch_rrq_resp(struct fc_seq *sp, struct fc_frame *fp, void *arg) 1787 { 1788 struct fc_exch *aborted_ep = arg; 1789 unsigned int op; 1790 1791 if (IS_ERR(fp)) { 1792 int err = PTR_ERR(fp); 1793 1794 if (err == -FC_EX_CLOSED || err == -FC_EX_TIMEOUT) 1795 goto cleanup; 1796 FC_EXCH_DBG(aborted_ep, "Cannot process RRQ, " 1797 "frame error %d\n", err); 1798 return; 1799 } 1800 1801 op = fc_frame_payload_op(fp); 1802 fc_frame_free(fp); 1803 1804 switch (op) { 1805 case ELS_LS_RJT: 1806 FC_EXCH_DBG(aborted_ep, "LS_RJT for RRQ"); 1807 /* fall through */ 1808 case ELS_LS_ACC: 1809 goto cleanup; 1810 default: 1811 FC_EXCH_DBG(aborted_ep, "unexpected response op %x " 1812 "for RRQ", op); 1813 return; 1814 } 1815 1816 cleanup: 1817 fc_exch_done(&aborted_ep->seq); 1818 /* drop hold for rec qual */ 1819 fc_exch_release(aborted_ep); 1820 } 1821 1822 1823 /** 1824 * fc_exch_seq_send() - Send a frame using a new exchange and sequence 1825 * @lport: The local port to send the frame on 1826 * @fp: The frame to be sent 1827 * @resp: The response handler for this request 1828 * @destructor: The destructor for the exchange 1829 * @arg: The argument to be passed to the response handler 1830 * @timer_msec: The timeout period for the exchange 1831 * 1832 * The frame pointer with some of the header's fields must be 1833 * filled before calling this routine, those fields are: 1834 * 1835 * - routing control 1836 * - FC port did 1837 * - FC port sid 1838 * - FC header type 1839 * - frame control 1840 * - parameter or relative offset 1841 */ 1842 static struct fc_seq *fc_exch_seq_send(struct fc_lport *lport, 1843 struct fc_frame *fp, 1844 void (*resp)(struct fc_seq *, 1845 struct fc_frame *fp, 1846 void *arg), 1847 void (*destructor)(struct fc_seq *, 1848 void *), 1849 void *arg, u32 timer_msec) 1850 { 1851 struct fc_exch *ep; 1852 struct fc_seq *sp = NULL; 1853 struct fc_frame_header *fh; 1854 int rc = 1; 1855 1856 ep = fc_exch_alloc(lport, fp); 1857 if (!ep) { 1858 fc_frame_free(fp); 1859 return NULL; 1860 } 1861 ep->esb_stat |= ESB_ST_SEQ_INIT; 1862 fh = fc_frame_header_get(fp); 1863 fc_exch_set_addr(ep, ntoh24(fh->fh_s_id), ntoh24(fh->fh_d_id)); 1864 ep->resp = resp; 1865 ep->destructor = destructor; 1866 ep->arg = arg; 1867 ep->r_a_tov = FC_DEF_R_A_TOV; 1868 ep->lp = lport; 1869 sp = &ep->seq; 1870 1871 ep->fh_type = fh->fh_type; /* save for possbile timeout handling */ 1872 ep->f_ctl = ntoh24(fh->fh_f_ctl); 1873 fc_exch_setup_hdr(ep, fp, ep->f_ctl); 1874 sp->cnt++; 1875 1876 if (ep->xid <= lport->lro_xid && fh->fh_r_ctl == FC_RCTL_DD_UNSOL_CMD) 1877 fc_fcp_ddp_setup(fr_fsp(fp), ep->xid); 1878 1879 if (unlikely(lport->tt.frame_send(lport, fp))) 1880 goto err; 1881 1882 if (timer_msec) 1883 fc_exch_timer_set_locked(ep, timer_msec); 1884 ep->f_ctl &= ~FC_FC_FIRST_SEQ; /* not first seq */ 1885 1886 if (ep->f_ctl & FC_FC_SEQ_INIT) 1887 ep->esb_stat &= ~ESB_ST_SEQ_INIT; 1888 spin_unlock_bh(&ep->ex_lock); 1889 return sp; 1890 err: 1891 rc = fc_exch_done_locked(ep); 1892 spin_unlock_bh(&ep->ex_lock); 1893 if (!rc) 1894 fc_exch_delete(ep); 1895 return NULL; 1896 } 1897 1898 /** 1899 * fc_exch_rrq() - Send an ELS RRQ (Reinstate Recovery Qualifier) command 1900 * @ep: The exchange to send the RRQ on 1901 * 1902 * This tells the remote port to stop blocking the use of 1903 * the exchange and the seq_cnt range. 1904 */ 1905 static void fc_exch_rrq(struct fc_exch *ep) 1906 { 1907 struct fc_lport *lport; 1908 struct fc_els_rrq *rrq; 1909 struct fc_frame *fp; 1910 u32 did; 1911 1912 lport = ep->lp; 1913 1914 fp = fc_frame_alloc(lport, sizeof(*rrq)); 1915 if (!fp) 1916 goto retry; 1917 1918 rrq = fc_frame_payload_get(fp, sizeof(*rrq)); 1919 memset(rrq, 0, sizeof(*rrq)); 1920 rrq->rrq_cmd = ELS_RRQ; 1921 hton24(rrq->rrq_s_id, ep->sid); 1922 rrq->rrq_ox_id = htons(ep->oxid); 1923 rrq->rrq_rx_id = htons(ep->rxid); 1924 1925 did = ep->did; 1926 if (ep->esb_stat & ESB_ST_RESP) 1927 did = ep->sid; 1928 1929 fc_fill_fc_hdr(fp, FC_RCTL_ELS_REQ, did, 1930 lport->port_id, FC_TYPE_ELS, 1931 FC_FC_FIRST_SEQ | FC_FC_END_SEQ | FC_FC_SEQ_INIT, 0); 1932 1933 if (fc_exch_seq_send(lport, fp, fc_exch_rrq_resp, NULL, ep, 1934 lport->e_d_tov)) 1935 return; 1936 1937 retry: 1938 spin_lock_bh(&ep->ex_lock); 1939 if (ep->state & (FC_EX_RST_CLEANUP | FC_EX_DONE)) { 1940 spin_unlock_bh(&ep->ex_lock); 1941 /* drop hold for rec qual */ 1942 fc_exch_release(ep); 1943 return; 1944 } 1945 ep->esb_stat |= ESB_ST_REC_QUAL; 1946 fc_exch_timer_set_locked(ep, ep->r_a_tov); 1947 spin_unlock_bh(&ep->ex_lock); 1948 } 1949 1950 1951 /** 1952 * fc_exch_els_rrq() - Handler for ELS RRQ (Reset Recovery Qualifier) requests 1953 * @sp: The sequence that the RRQ is on 1954 * @fp: The RRQ frame 1955 */ 1956 static void fc_exch_els_rrq(struct fc_seq *sp, struct fc_frame *fp) 1957 { 1958 struct fc_exch *ep = NULL; /* request or subject exchange */ 1959 struct fc_els_rrq *rp; 1960 u32 sid; 1961 u16 xid; 1962 enum fc_els_rjt_explan explan; 1963 1964 rp = fc_frame_payload_get(fp, sizeof(*rp)); 1965 explan = ELS_EXPL_INV_LEN; 1966 if (!rp) 1967 goto reject; 1968 1969 /* 1970 * lookup subject exchange. 1971 */ 1972 ep = fc_seq_exch(sp); 1973 sid = ntoh24(rp->rrq_s_id); /* subject source */ 1974 xid = ep->did == sid ? ntohs(rp->rrq_ox_id) : ntohs(rp->rrq_rx_id); 1975 ep = fc_exch_find(ep->em, xid); 1976 1977 explan = ELS_EXPL_OXID_RXID; 1978 if (!ep) 1979 goto reject; 1980 spin_lock_bh(&ep->ex_lock); 1981 if (ep->oxid != ntohs(rp->rrq_ox_id)) 1982 goto unlock_reject; 1983 if (ep->rxid != ntohs(rp->rrq_rx_id) && 1984 ep->rxid != FC_XID_UNKNOWN) 1985 goto unlock_reject; 1986 explan = ELS_EXPL_SID; 1987 if (ep->sid != sid) 1988 goto unlock_reject; 1989 1990 /* 1991 * Clear Recovery Qualifier state, and cancel timer if complete. 1992 */ 1993 if (ep->esb_stat & ESB_ST_REC_QUAL) { 1994 ep->esb_stat &= ~ESB_ST_REC_QUAL; 1995 atomic_dec(&ep->ex_refcnt); /* drop hold for rec qual */ 1996 } 1997 if (ep->esb_stat & ESB_ST_COMPLETE) { 1998 if (cancel_delayed_work(&ep->timeout_work)) 1999 atomic_dec(&ep->ex_refcnt); /* drop timer hold */ 2000 } 2001 2002 spin_unlock_bh(&ep->ex_lock); 2003 2004 /* 2005 * Send LS_ACC. 2006 */ 2007 fc_seq_ls_acc(sp); 2008 goto out; 2009 2010 unlock_reject: 2011 spin_unlock_bh(&ep->ex_lock); 2012 reject: 2013 fc_seq_ls_rjt(sp, ELS_RJT_LOGIC, explan); 2014 out: 2015 fc_frame_free(fp); 2016 if (ep) 2017 fc_exch_release(ep); /* drop hold from fc_exch_find */ 2018 } 2019 2020 /** 2021 * fc_exch_mgr_add() - Add an exchange manager to a local port's list of EMs 2022 * @lport: The local port to add the exchange manager to 2023 * @mp: The exchange manager to be added to the local port 2024 * @match: The match routine that indicates when this EM should be used 2025 */ 2026 struct fc_exch_mgr_anchor *fc_exch_mgr_add(struct fc_lport *lport, 2027 struct fc_exch_mgr *mp, 2028 bool (*match)(struct fc_frame *)) 2029 { 2030 struct fc_exch_mgr_anchor *ema; 2031 2032 ema = kmalloc(sizeof(*ema), GFP_ATOMIC); 2033 if (!ema) 2034 return ema; 2035 2036 ema->mp = mp; 2037 ema->match = match; 2038 /* add EM anchor to EM anchors list */ 2039 list_add_tail(&ema->ema_list, &lport->ema_list); 2040 kref_get(&mp->kref); 2041 return ema; 2042 } 2043 EXPORT_SYMBOL(fc_exch_mgr_add); 2044 2045 /** 2046 * fc_exch_mgr_destroy() - Destroy an exchange manager 2047 * @kref: The reference to the EM to be destroyed 2048 */ 2049 static void fc_exch_mgr_destroy(struct kref *kref) 2050 { 2051 struct fc_exch_mgr *mp = container_of(kref, struct fc_exch_mgr, kref); 2052 2053 mempool_destroy(mp->ep_pool); 2054 free_percpu(mp->pool); 2055 kfree(mp); 2056 } 2057 2058 /** 2059 * fc_exch_mgr_del() - Delete an EM from a local port's list 2060 * @ema: The exchange manager anchor identifying the EM to be deleted 2061 */ 2062 void fc_exch_mgr_del(struct fc_exch_mgr_anchor *ema) 2063 { 2064 /* remove EM anchor from EM anchors list */ 2065 list_del(&ema->ema_list); 2066 kref_put(&ema->mp->kref, fc_exch_mgr_destroy); 2067 kfree(ema); 2068 } 2069 EXPORT_SYMBOL(fc_exch_mgr_del); 2070 2071 /** 2072 * fc_exch_mgr_list_clone() - Share all exchange manager objects 2073 * @src: Source lport to clone exchange managers from 2074 * @dst: New lport that takes references to all the exchange managers 2075 */ 2076 int fc_exch_mgr_list_clone(struct fc_lport *src, struct fc_lport *dst) 2077 { 2078 struct fc_exch_mgr_anchor *ema, *tmp; 2079 2080 list_for_each_entry(ema, &src->ema_list, ema_list) { 2081 if (!fc_exch_mgr_add(dst, ema->mp, ema->match)) 2082 goto err; 2083 } 2084 return 0; 2085 err: 2086 list_for_each_entry_safe(ema, tmp, &dst->ema_list, ema_list) 2087 fc_exch_mgr_del(ema); 2088 return -ENOMEM; 2089 } 2090 2091 /** 2092 * fc_exch_mgr_alloc() - Allocate an exchange manager 2093 * @lport: The local port that the new EM will be associated with 2094 * @class: The default FC class for new exchanges 2095 * @min_xid: The minimum XID for exchanges from the new EM 2096 * @max_xid: The maximum XID for exchanges from the new EM 2097 * @match: The match routine for the new EM 2098 */ 2099 struct fc_exch_mgr *fc_exch_mgr_alloc(struct fc_lport *lport, 2100 enum fc_class class, 2101 u16 min_xid, u16 max_xid, 2102 bool (*match)(struct fc_frame *)) 2103 { 2104 struct fc_exch_mgr *mp; 2105 u16 pool_exch_range; 2106 size_t pool_size; 2107 unsigned int cpu; 2108 struct fc_exch_pool *pool; 2109 2110 if (max_xid <= min_xid || max_xid == FC_XID_UNKNOWN || 2111 (min_xid & fc_cpu_mask) != 0) { 2112 FC_LPORT_DBG(lport, "Invalid min_xid 0x:%x and max_xid 0x:%x\n", 2113 min_xid, max_xid); 2114 return NULL; 2115 } 2116 2117 /* 2118 * allocate memory for EM 2119 */ 2120 mp = kzalloc(sizeof(struct fc_exch_mgr), GFP_ATOMIC); 2121 if (!mp) 2122 return NULL; 2123 2124 mp->class = class; 2125 /* adjust em exch xid range for offload */ 2126 mp->min_xid = min_xid; 2127 mp->max_xid = max_xid; 2128 2129 mp->ep_pool = mempool_create_slab_pool(2, fc_em_cachep); 2130 if (!mp->ep_pool) 2131 goto free_mp; 2132 2133 /* 2134 * Setup per cpu exch pool with entire exchange id range equally 2135 * divided across all cpus. The exch pointers array memory is 2136 * allocated for exch range per pool. 2137 */ 2138 pool_exch_range = (mp->max_xid - mp->min_xid + 1) / (fc_cpu_mask + 1); 2139 mp->pool_max_index = pool_exch_range - 1; 2140 2141 /* 2142 * Allocate and initialize per cpu exch pool 2143 */ 2144 pool_size = sizeof(*pool) + pool_exch_range * sizeof(struct fc_exch *); 2145 mp->pool = __alloc_percpu(pool_size, __alignof__(struct fc_exch_pool)); 2146 if (!mp->pool) 2147 goto free_mempool; 2148 for_each_possible_cpu(cpu) { 2149 pool = per_cpu_ptr(mp->pool, cpu); 2150 spin_lock_init(&pool->lock); 2151 INIT_LIST_HEAD(&pool->ex_list); 2152 } 2153 2154 kref_init(&mp->kref); 2155 if (!fc_exch_mgr_add(lport, mp, match)) { 2156 free_percpu(mp->pool); 2157 goto free_mempool; 2158 } 2159 2160 /* 2161 * Above kref_init() sets mp->kref to 1 and then 2162 * call to fc_exch_mgr_add incremented mp->kref again, 2163 * so adjust that extra increment. 2164 */ 2165 kref_put(&mp->kref, fc_exch_mgr_destroy); 2166 return mp; 2167 2168 free_mempool: 2169 mempool_destroy(mp->ep_pool); 2170 free_mp: 2171 kfree(mp); 2172 return NULL; 2173 } 2174 EXPORT_SYMBOL(fc_exch_mgr_alloc); 2175 2176 /** 2177 * fc_exch_mgr_free() - Free all exchange managers on a local port 2178 * @lport: The local port whose EMs are to be freed 2179 */ 2180 void fc_exch_mgr_free(struct fc_lport *lport) 2181 { 2182 struct fc_exch_mgr_anchor *ema, *next; 2183 2184 flush_workqueue(fc_exch_workqueue); 2185 list_for_each_entry_safe(ema, next, &lport->ema_list, ema_list) 2186 fc_exch_mgr_del(ema); 2187 } 2188 EXPORT_SYMBOL(fc_exch_mgr_free); 2189 2190 /** 2191 * fc_exch_recv() - Handler for received frames 2192 * @lport: The local port the frame was received on 2193 * @fp: The received frame 2194 */ 2195 void fc_exch_recv(struct fc_lport *lport, struct fc_frame *fp) 2196 { 2197 struct fc_frame_header *fh = fc_frame_header_get(fp); 2198 struct fc_exch_mgr_anchor *ema; 2199 u32 f_ctl, found = 0; 2200 u16 oxid; 2201 2202 /* lport lock ? */ 2203 if (!lport || lport->state == LPORT_ST_DISABLED) { 2204 FC_LPORT_DBG(lport, "Receiving frames for an lport that " 2205 "has not been initialized correctly\n"); 2206 fc_frame_free(fp); 2207 return; 2208 } 2209 2210 f_ctl = ntoh24(fh->fh_f_ctl); 2211 oxid = ntohs(fh->fh_ox_id); 2212 if (f_ctl & FC_FC_EX_CTX) { 2213 list_for_each_entry(ema, &lport->ema_list, ema_list) { 2214 if ((oxid >= ema->mp->min_xid) && 2215 (oxid <= ema->mp->max_xid)) { 2216 found = 1; 2217 break; 2218 } 2219 } 2220 2221 if (!found) { 2222 FC_LPORT_DBG(lport, "Received response for out " 2223 "of range oxid:%hx\n", oxid); 2224 fc_frame_free(fp); 2225 return; 2226 } 2227 } else 2228 ema = list_entry(lport->ema_list.prev, typeof(*ema), ema_list); 2229 2230 /* 2231 * If frame is marked invalid, just drop it. 2232 */ 2233 switch (fr_eof(fp)) { 2234 case FC_EOF_T: 2235 if (f_ctl & FC_FC_END_SEQ) 2236 skb_trim(fp_skb(fp), fr_len(fp) - FC_FC_FILL(f_ctl)); 2237 /* fall through */ 2238 case FC_EOF_N: 2239 if (fh->fh_type == FC_TYPE_BLS) 2240 fc_exch_recv_bls(ema->mp, fp); 2241 else if ((f_ctl & (FC_FC_EX_CTX | FC_FC_SEQ_CTX)) == 2242 FC_FC_EX_CTX) 2243 fc_exch_recv_seq_resp(ema->mp, fp); 2244 else if (f_ctl & FC_FC_SEQ_CTX) 2245 fc_exch_recv_resp(ema->mp, fp); 2246 else 2247 fc_exch_recv_req(lport, ema->mp, fp); 2248 break; 2249 default: 2250 FC_LPORT_DBG(lport, "dropping invalid frame (eof %x)", 2251 fr_eof(fp)); 2252 fc_frame_free(fp); 2253 } 2254 } 2255 EXPORT_SYMBOL(fc_exch_recv); 2256 2257 /** 2258 * fc_exch_init() - Initialize the exchange layer for a local port 2259 * @lport: The local port to initialize the exchange layer for 2260 */ 2261 int fc_exch_init(struct fc_lport *lport) 2262 { 2263 if (!lport->tt.seq_start_next) 2264 lport->tt.seq_start_next = fc_seq_start_next; 2265 2266 if (!lport->tt.exch_seq_send) 2267 lport->tt.exch_seq_send = fc_exch_seq_send; 2268 2269 if (!lport->tt.seq_send) 2270 lport->tt.seq_send = fc_seq_send; 2271 2272 if (!lport->tt.seq_els_rsp_send) 2273 lport->tt.seq_els_rsp_send = fc_seq_els_rsp_send; 2274 2275 if (!lport->tt.exch_done) 2276 lport->tt.exch_done = fc_exch_done; 2277 2278 if (!lport->tt.exch_mgr_reset) 2279 lport->tt.exch_mgr_reset = fc_exch_mgr_reset; 2280 2281 if (!lport->tt.seq_exch_abort) 2282 lport->tt.seq_exch_abort = fc_seq_exch_abort; 2283 2284 return 0; 2285 } 2286 EXPORT_SYMBOL(fc_exch_init); 2287 2288 /** 2289 * fc_setup_exch_mgr() - Setup an exchange manager 2290 */ 2291 int fc_setup_exch_mgr() 2292 { 2293 fc_em_cachep = kmem_cache_create("libfc_em", sizeof(struct fc_exch), 2294 0, SLAB_HWCACHE_ALIGN, NULL); 2295 if (!fc_em_cachep) 2296 return -ENOMEM; 2297 2298 /* 2299 * Initialize fc_cpu_mask and fc_cpu_order. The 2300 * fc_cpu_mask is set for nr_cpu_ids rounded up 2301 * to order of 2's * power and order is stored 2302 * in fc_cpu_order as this is later required in 2303 * mapping between an exch id and exch array index 2304 * in per cpu exch pool. 2305 * 2306 * This round up is required to align fc_cpu_mask 2307 * to exchange id's lower bits such that all incoming 2308 * frames of an exchange gets delivered to the same 2309 * cpu on which exchange originated by simple bitwise 2310 * AND operation between fc_cpu_mask and exchange id. 2311 */ 2312 fc_cpu_mask = 1; 2313 fc_cpu_order = 0; 2314 while (fc_cpu_mask < nr_cpu_ids) { 2315 fc_cpu_mask <<= 1; 2316 fc_cpu_order++; 2317 } 2318 fc_cpu_mask--; 2319 2320 fc_exch_workqueue = create_singlethread_workqueue("fc_exch_workqueue"); 2321 if (!fc_exch_workqueue) 2322 return -ENOMEM; 2323 return 0; 2324 } 2325 2326 /** 2327 * fc_destroy_exch_mgr() - Destroy an exchange manager 2328 */ 2329 void fc_destroy_exch_mgr() 2330 { 2331 destroy_workqueue(fc_exch_workqueue); 2332 kmem_cache_destroy(fc_em_cachep); 2333 } 2334