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
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.
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
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.
19 * Maintained at www.Open-FCoE.org
23 * Fibre Channel exchange and sequence handling.
26 #include <linux/timer.h>
27 #include <linux/slab.h>
28 #include <linux/err.h>
29 #include <linux/export.h>
30 #include <linux/log2.h>
32 #include <scsi/fc/fc_fc2.h>
34 #include <scsi/libfc.h>
35 #include <scsi/fc_encode.h>
39 u16 fc_cpu_mask
; /* cpu mask for possible cpus */
40 EXPORT_SYMBOL(fc_cpu_mask
);
41 static u16 fc_cpu_order
; /* 2's power to represent total possible cpus */
42 static struct kmem_cache
*fc_em_cachep
; /* cache for exchanges */
43 static struct workqueue_struct
*fc_exch_workqueue
;
46 * Structure and function definitions for managing Fibre Channel Exchanges
49 * The three primary structures used here are fc_exch_mgr, fc_exch, and fc_seq.
51 * fc_exch_mgr holds the exchange state for an N port
53 * fc_exch holds state for one exchange and links to its active sequence.
55 * fc_seq holds the state for an individual sequence.
59 * struct fc_exch_pool - Per cpu exchange pool
60 * @next_index: Next possible free exchange index
61 * @total_exches: Total allocated exchanges
62 * @lock: Exch pool lock
63 * @ex_list: List of exchanges
65 * This structure manages per cpu exchanges in array of exchange pointers.
66 * This array is allocated followed by struct fc_exch_pool memory for
67 * assigned range of exchanges to per cpu pool.
71 struct list_head ex_list
;
75 /* two cache of free slot in exch array */
78 } ____cacheline_aligned_in_smp
;
81 * struct fc_exch_mgr - The Exchange Manager (EM).
82 * @class: Default class for new sequences
83 * @kref: Reference counter
84 * @min_xid: Minimum exchange ID
85 * @max_xid: Maximum exchange ID
86 * @ep_pool: Reserved exchange pointers
87 * @pool_max_index: Max exch array index in exch pool
88 * @pool: Per cpu exch pool
89 * @stats: Statistics structure
91 * This structure is the center for creating exchanges and sequences.
92 * It manages the allocation of exchange IDs.
95 struct fc_exch_pool __percpu
*pool
;
104 atomic_t no_free_exch
;
105 atomic_t no_free_exch_xid
;
106 atomic_t xid_not_found
;
108 atomic_t seq_not_found
;
109 atomic_t non_bls_resp
;
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
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 offloads.
125 struct fc_exch_mgr_anchor
{
126 struct list_head ema_list
;
127 struct fc_exch_mgr
*mp
;
128 bool (*match
)(struct fc_frame
*);
131 static void fc_exch_rrq(struct fc_exch
*);
132 static void fc_seq_ls_acc(struct fc_frame
*);
133 static void fc_seq_ls_rjt(struct fc_frame
*, enum fc_els_rjt_reason
,
134 enum fc_els_rjt_explan
);
135 static void fc_exch_els_rec(struct fc_frame
*);
136 static void fc_exch_els_rrq(struct fc_frame
*);
139 * Internal implementation notes.
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.
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.
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.
156 * Notes on reference counts:
158 * Exchanges are reference counted and exchange gets freed when the reference
159 * count becomes zero.
162 * Sequences are timed out for E_D_TOV and R_A_TOV.
164 * Sequence event handling:
166 * The following events may occur on initiator sequences:
169 * For now, the whole thing is sent.
171 * This applies only to class F.
172 * The sequence is marked complete.
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).
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.
188 * The following events may occur on recipient sequences:
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.
196 * Deallocate sequence
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.
207 * The EM code run in a per-CPU worker thread.
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.
218 * opcode names for debugging.
220 static char *fc_exch_rctl_names
[] = FC_RCTL_NAMES_INIT
;
223 * fc_exch_name_lookup() - Lookup name by opcode
224 * @op: Opcode to be looked up
225 * @table: Opcode/name table
226 * @max_index: Index not to be exceeded
228 * This routine is used to determine a human-readable string identifying
231 static inline const char *fc_exch_name_lookup(unsigned int op
, char **table
,
232 unsigned int max_index
)
234 const char *name
= NULL
;
244 * fc_exch_rctl_name() - Wrapper routine for fc_exch_name_lookup()
245 * @op: The opcode to be looked up
247 static const char *fc_exch_rctl_name(unsigned int op
)
249 return fc_exch_name_lookup(op
, fc_exch_rctl_names
,
250 ARRAY_SIZE(fc_exch_rctl_names
));
254 * fc_exch_hold() - Increment an exchange's reference count
255 * @ep: Echange to be held
257 static inline void fc_exch_hold(struct fc_exch
*ep
)
259 atomic_inc(&ep
->ex_refcnt
);
263 * fc_exch_setup_hdr() - Initialize a FC header by initializing some fields
264 * and determine SOF and EOF.
265 * @ep: The exchange to that will use the header
266 * @fp: The frame whose header is to be modified
267 * @f_ctl: F_CTL bits that will be used for the frame header
269 * The fields initialized by this routine are: fh_ox_id, fh_rx_id,
270 * fh_seq_id, fh_seq_cnt and the SOF and EOF.
272 static void fc_exch_setup_hdr(struct fc_exch
*ep
, struct fc_frame
*fp
,
275 struct fc_frame_header
*fh
= fc_frame_header_get(fp
);
278 fr_sof(fp
) = ep
->class;
280 fr_sof(fp
) = fc_sof_normal(ep
->class);
282 if (f_ctl
& FC_FC_END_SEQ
) {
283 fr_eof(fp
) = FC_EOF_T
;
284 if (fc_sof_needs_ack(ep
->class))
285 fr_eof(fp
) = FC_EOF_N
;
288 * The number of fill bytes to make the length a 4-byte
289 * multiple is the low order 2-bits of the f_ctl.
290 * The fill itself will have been cleared by the frame
292 * After this, the length will be even, as expected by
295 fill
= fr_len(fp
) & 3;
298 /* TODO, this may be a problem with fragmented skb */
299 skb_put(fp_skb(fp
), fill
);
300 hton24(fh
->fh_f_ctl
, f_ctl
| fill
);
303 WARN_ON(fr_len(fp
) % 4 != 0); /* no pad to non last frame */
304 fr_eof(fp
) = FC_EOF_N
;
307 /* Initialize remaining fh fields from fc_fill_fc_hdr */
308 fh
->fh_ox_id
= htons(ep
->oxid
);
309 fh
->fh_rx_id
= htons(ep
->rxid
);
310 fh
->fh_seq_id
= ep
->seq
.id
;
311 fh
->fh_seq_cnt
= htons(ep
->seq
.cnt
);
315 * fc_exch_release() - Decrement an exchange's reference count
316 * @ep: Exchange to be released
318 * If the reference count reaches zero and the exchange is complete,
321 static void fc_exch_release(struct fc_exch
*ep
)
323 struct fc_exch_mgr
*mp
;
325 if (atomic_dec_and_test(&ep
->ex_refcnt
)) {
328 ep
->destructor(&ep
->seq
, ep
->arg
);
329 WARN_ON(!(ep
->esb_stat
& ESB_ST_COMPLETE
));
330 mempool_free(ep
, mp
->ep_pool
);
335 * fc_exch_timer_cancel() - cancel exch timer
336 * @ep: The exchange whose timer to be canceled
338 static inline void fc_exch_timer_cancel(struct fc_exch
*ep
)
340 if (cancel_delayed_work(&ep
->timeout_work
)) {
341 FC_EXCH_DBG(ep
, "Exchange timer canceled\n");
342 atomic_dec(&ep
->ex_refcnt
); /* drop hold for timer */
347 * fc_exch_timer_set_locked() - Start a timer for an exchange w/ the
348 * the exchange lock held
349 * @ep: The exchange whose timer will start
350 * @timer_msec: The timeout period
352 * Used for upper level protocols to time out the exchange.
353 * The timer is cancelled when it fires or when the exchange completes.
355 static inline void fc_exch_timer_set_locked(struct fc_exch
*ep
,
356 unsigned int timer_msec
)
358 if (ep
->state
& (FC_EX_RST_CLEANUP
| FC_EX_DONE
))
361 FC_EXCH_DBG(ep
, "Exchange timer armed : %d msecs\n", timer_msec
);
363 fc_exch_hold(ep
); /* hold for timer */
364 if (!queue_delayed_work(fc_exch_workqueue
, &ep
->timeout_work
,
365 msecs_to_jiffies(timer_msec
)))
370 * fc_exch_timer_set() - Lock the exchange and set the timer
371 * @ep: The exchange whose timer will start
372 * @timer_msec: The timeout period
374 static void fc_exch_timer_set(struct fc_exch
*ep
, unsigned int timer_msec
)
376 spin_lock_bh(&ep
->ex_lock
);
377 fc_exch_timer_set_locked(ep
, timer_msec
);
378 spin_unlock_bh(&ep
->ex_lock
);
382 * fc_exch_done_locked() - Complete an exchange with the exchange lock held
383 * @ep: The exchange that is complete
385 static int fc_exch_done_locked(struct fc_exch
*ep
)
390 * We must check for completion in case there are two threads
391 * tyring to complete this. But the rrq code will reuse the
392 * ep, and in that case we only clear the resp and set it as
393 * complete, so it can be reused by the timer to send the rrq.
396 if (ep
->state
& FC_EX_DONE
)
398 ep
->esb_stat
|= ESB_ST_COMPLETE
;
400 if (!(ep
->esb_stat
& ESB_ST_REC_QUAL
)) {
401 ep
->state
|= FC_EX_DONE
;
402 fc_exch_timer_cancel(ep
);
409 * fc_exch_ptr_get() - Return an exchange from an exchange pool
410 * @pool: Exchange Pool to get an exchange from
411 * @index: Index of the exchange within the pool
413 * Use the index to get an exchange from within an exchange pool. exches
414 * will point to an array of exchange pointers. The index will select
415 * the exchange within the array.
417 static inline struct fc_exch
*fc_exch_ptr_get(struct fc_exch_pool
*pool
,
420 struct fc_exch
**exches
= (struct fc_exch
**)(pool
+ 1);
421 return exches
[index
];
425 * fc_exch_ptr_set() - Assign an exchange to a slot in an exchange pool
426 * @pool: The pool to assign the exchange to
427 * @index: The index in the pool where the exchange will be assigned
428 * @ep: The exchange to assign to the pool
430 static inline void fc_exch_ptr_set(struct fc_exch_pool
*pool
, u16 index
,
433 ((struct fc_exch
**)(pool
+ 1))[index
] = ep
;
437 * fc_exch_delete() - Delete an exchange
438 * @ep: The exchange to be deleted
440 static void fc_exch_delete(struct fc_exch
*ep
)
442 struct fc_exch_pool
*pool
;
446 spin_lock_bh(&pool
->lock
);
447 WARN_ON(pool
->total_exches
<= 0);
448 pool
->total_exches
--;
450 /* update cache of free slot */
451 index
= (ep
->xid
- ep
->em
->min_xid
) >> fc_cpu_order
;
452 if (pool
->left
== FC_XID_UNKNOWN
)
454 else if (pool
->right
== FC_XID_UNKNOWN
)
457 pool
->next_index
= index
;
459 fc_exch_ptr_set(pool
, index
, NULL
);
460 list_del(&ep
->ex_list
);
461 spin_unlock_bh(&pool
->lock
);
462 fc_exch_release(ep
); /* drop hold for exch in mp */
465 static int fc_seq_send_locked(struct fc_lport
*lport
, struct fc_seq
*sp
,
469 struct fc_frame_header
*fh
= fc_frame_header_get(fp
);
472 u8 fh_type
= fh
->fh_type
;
474 ep
= fc_seq_exch(sp
);
475 WARN_ON(!(ep
->esb_stat
& ESB_ST_SEQ_INIT
));
477 f_ctl
= ntoh24(fh
->fh_f_ctl
);
478 fc_exch_setup_hdr(ep
, fp
, f_ctl
);
479 fr_encaps(fp
) = ep
->encaps
;
482 * update sequence count if this frame is carrying
483 * multiple FC frames when sequence offload is enabled
486 if (fr_max_payload(fp
))
487 sp
->cnt
+= DIV_ROUND_UP((fr_len(fp
) - sizeof(*fh
)),
495 error
= lport
->tt
.frame_send(lport
, fp
);
497 if (fh_type
== FC_TYPE_BLS
)
501 * Update the exchange and sequence flags,
502 * assuming all frames for the sequence have been sent.
503 * We can only be called to send once for each sequence.
505 ep
->f_ctl
= f_ctl
& ~FC_FC_FIRST_SEQ
; /* not first seq */
506 if (f_ctl
& FC_FC_SEQ_INIT
)
507 ep
->esb_stat
&= ~ESB_ST_SEQ_INIT
;
513 * fc_seq_send() - Send a frame using existing sequence/exchange pair
514 * @lport: The local port that the exchange will be sent on
515 * @sp: The sequence to be sent
516 * @fp: The frame to be sent on the exchange
518 static int fc_seq_send(struct fc_lport
*lport
, struct fc_seq
*sp
,
523 ep
= fc_seq_exch(sp
);
524 spin_lock_bh(&ep
->ex_lock
);
525 error
= fc_seq_send_locked(lport
, sp
, fp
);
526 spin_unlock_bh(&ep
->ex_lock
);
531 * fc_seq_alloc() - Allocate a sequence for a given exchange
532 * @ep: The exchange to allocate a new sequence for
533 * @seq_id: The sequence ID to be used
535 * We don't support multiple originated sequences on the same exchange.
536 * By implication, any previously originated sequence on this exchange
537 * is complete, and we reallocate the same sequence.
539 static struct fc_seq
*fc_seq_alloc(struct fc_exch
*ep
, u8 seq_id
)
551 * fc_seq_start_next_locked() - Allocate a new sequence on the same
552 * exchange as the supplied sequence
553 * @sp: The sequence/exchange to get a new sequence for
555 static struct fc_seq
*fc_seq_start_next_locked(struct fc_seq
*sp
)
557 struct fc_exch
*ep
= fc_seq_exch(sp
);
559 sp
= fc_seq_alloc(ep
, ep
->seq_id
++);
560 FC_EXCH_DBG(ep
, "f_ctl %6x seq %2x\n",
566 * fc_seq_start_next() - Lock the exchange and get a new sequence
567 * for a given sequence/exchange pair
568 * @sp: The sequence/exchange to get a new exchange for
570 static struct fc_seq
*fc_seq_start_next(struct fc_seq
*sp
)
572 struct fc_exch
*ep
= fc_seq_exch(sp
);
574 spin_lock_bh(&ep
->ex_lock
);
575 sp
= fc_seq_start_next_locked(sp
);
576 spin_unlock_bh(&ep
->ex_lock
);
582 * Set the response handler for the exchange associated with a sequence.
584 static void fc_seq_set_resp(struct fc_seq
*sp
,
585 void (*resp
)(struct fc_seq
*, struct fc_frame
*,
589 struct fc_exch
*ep
= fc_seq_exch(sp
);
591 spin_lock_bh(&ep
->ex_lock
);
594 spin_unlock_bh(&ep
->ex_lock
);
598 * fc_exch_abort_locked() - Abort an exchange
599 * @ep: The exchange to be aborted
600 * @timer_msec: The period of time to wait before aborting
602 * Locking notes: Called with exch lock held
604 * Return value: 0 on success else error code
606 static int fc_exch_abort_locked(struct fc_exch
*ep
,
607 unsigned int timer_msec
)
613 if (ep
->esb_stat
& (ESB_ST_COMPLETE
| ESB_ST_ABNORMAL
) ||
614 ep
->state
& (FC_EX_DONE
| FC_EX_RST_CLEANUP
))
618 * Send the abort on a new sequence if possible.
620 sp
= fc_seq_start_next_locked(&ep
->seq
);
624 ep
->esb_stat
|= ESB_ST_SEQ_INIT
| ESB_ST_ABNORMAL
;
626 fc_exch_timer_set_locked(ep
, timer_msec
);
629 * If not logged into the fabric, don't send ABTS but leave
630 * sequence active until next timeout.
636 * Send an abort for the sequence that timed out.
638 fp
= fc_frame_alloc(ep
->lp
, 0);
640 fc_fill_fc_hdr(fp
, FC_RCTL_BA_ABTS
, ep
->did
, ep
->sid
,
641 FC_TYPE_BLS
, FC_FC_END_SEQ
| FC_FC_SEQ_INIT
, 0);
642 error
= fc_seq_send_locked(ep
->lp
, sp
, fp
);
649 * fc_seq_exch_abort() - Abort an exchange and sequence
650 * @req_sp: The sequence to be aborted
651 * @timer_msec: The period of time to wait before aborting
653 * Generally called because of a timeout or an abort from the upper layer.
655 * Return value: 0 on success else error code
657 static int fc_seq_exch_abort(const struct fc_seq
*req_sp
,
658 unsigned int timer_msec
)
663 ep
= fc_seq_exch(req_sp
);
664 spin_lock_bh(&ep
->ex_lock
);
665 error
= fc_exch_abort_locked(ep
, timer_msec
);
666 spin_unlock_bh(&ep
->ex_lock
);
671 * fc_exch_timeout() - Handle exchange timer expiration
672 * @work: The work_struct identifying the exchange that timed out
674 static void fc_exch_timeout(struct work_struct
*work
)
676 struct fc_exch
*ep
= container_of(work
, struct fc_exch
,
678 struct fc_seq
*sp
= &ep
->seq
;
679 void (*resp
)(struct fc_seq
*, struct fc_frame
*fp
, void *arg
);
684 FC_EXCH_DBG(ep
, "Exchange timed out\n");
686 spin_lock_bh(&ep
->ex_lock
);
687 if (ep
->state
& (FC_EX_RST_CLEANUP
| FC_EX_DONE
))
690 e_stat
= ep
->esb_stat
;
691 if (e_stat
& ESB_ST_COMPLETE
) {
692 ep
->esb_stat
= e_stat
& ~ESB_ST_REC_QUAL
;
693 spin_unlock_bh(&ep
->ex_lock
);
694 if (e_stat
& ESB_ST_REC_QUAL
)
701 if (e_stat
& ESB_ST_ABNORMAL
)
702 rc
= fc_exch_done_locked(ep
);
703 spin_unlock_bh(&ep
->ex_lock
);
707 resp(sp
, ERR_PTR(-FC_EX_TIMEOUT
), arg
);
708 fc_seq_exch_abort(sp
, 2 * ep
->r_a_tov
);
712 spin_unlock_bh(&ep
->ex_lock
);
715 * This release matches the hold taken when the timer was set.
721 * fc_exch_em_alloc() - Allocate an exchange from a specified EM.
722 * @lport: The local port that the exchange is for
723 * @mp: The exchange manager that will allocate the exchange
725 * Returns pointer to allocated fc_exch with exch lock held.
727 static struct fc_exch
*fc_exch_em_alloc(struct fc_lport
*lport
,
728 struct fc_exch_mgr
*mp
)
733 struct fc_exch_pool
*pool
;
735 /* allocate memory for exchange */
736 ep
= mempool_alloc(mp
->ep_pool
, GFP_ATOMIC
);
738 atomic_inc(&mp
->stats
.no_free_exch
);
741 memset(ep
, 0, sizeof(*ep
));
744 pool
= per_cpu_ptr(mp
->pool
, cpu
);
745 spin_lock_bh(&pool
->lock
);
748 /* peek cache of free slot */
749 if (pool
->left
!= FC_XID_UNKNOWN
) {
751 pool
->left
= FC_XID_UNKNOWN
;
754 if (pool
->right
!= FC_XID_UNKNOWN
) {
756 pool
->right
= FC_XID_UNKNOWN
;
760 index
= pool
->next_index
;
761 /* allocate new exch from pool */
762 while (fc_exch_ptr_get(pool
, index
)) {
763 index
= index
== mp
->pool_max_index
? 0 : index
+ 1;
764 if (index
== pool
->next_index
)
767 pool
->next_index
= index
== mp
->pool_max_index
? 0 : index
+ 1;
769 fc_exch_hold(ep
); /* hold for exch in mp */
770 spin_lock_init(&ep
->ex_lock
);
772 * Hold exch lock for caller to prevent fc_exch_reset()
773 * from releasing exch while fc_exch_alloc() caller is
774 * still working on exch.
776 spin_lock_bh(&ep
->ex_lock
);
778 fc_exch_ptr_set(pool
, index
, ep
);
779 list_add_tail(&ep
->ex_list
, &pool
->ex_list
);
780 fc_seq_alloc(ep
, ep
->seq_id
++);
781 pool
->total_exches
++;
782 spin_unlock_bh(&pool
->lock
);
787 ep
->oxid
= ep
->xid
= (index
<< fc_cpu_order
| cpu
) + mp
->min_xid
;
791 ep
->f_ctl
= FC_FC_FIRST_SEQ
; /* next seq is first seq */
792 ep
->rxid
= FC_XID_UNKNOWN
;
793 ep
->class = mp
->class;
794 INIT_DELAYED_WORK(&ep
->timeout_work
, fc_exch_timeout
);
798 spin_unlock_bh(&pool
->lock
);
799 atomic_inc(&mp
->stats
.no_free_exch_xid
);
800 mempool_free(ep
, mp
->ep_pool
);
805 * fc_exch_alloc() - Allocate an exchange from an EM on a
806 * local port's list of EMs.
807 * @lport: The local port that will own the exchange
808 * @fp: The FC frame that the exchange will be for
810 * This function walks the list of exchange manager(EM)
811 * anchors to select an EM for a new exchange allocation. The
812 * EM is selected when a NULL match function pointer is encountered
813 * or when a call to a match function returns true.
815 static inline struct fc_exch
*fc_exch_alloc(struct fc_lport
*lport
,
818 struct fc_exch_mgr_anchor
*ema
;
820 list_for_each_entry(ema
, &lport
->ema_list
, ema_list
)
821 if (!ema
->match
|| ema
->match(fp
))
822 return fc_exch_em_alloc(lport
, ema
->mp
);
827 * fc_exch_find() - Lookup and hold an exchange
828 * @mp: The exchange manager to lookup the exchange from
829 * @xid: The XID of the exchange to look up
831 static struct fc_exch
*fc_exch_find(struct fc_exch_mgr
*mp
, u16 xid
)
833 struct fc_exch_pool
*pool
;
834 struct fc_exch
*ep
= NULL
;
836 if ((xid
>= mp
->min_xid
) && (xid
<= mp
->max_xid
)) {
837 pool
= per_cpu_ptr(mp
->pool
, xid
& fc_cpu_mask
);
838 spin_lock_bh(&pool
->lock
);
839 ep
= fc_exch_ptr_get(pool
, (xid
- mp
->min_xid
) >> fc_cpu_order
);
841 WARN_ON(ep
->xid
!= xid
);
844 spin_unlock_bh(&pool
->lock
);
851 * fc_exch_done() - Indicate that an exchange/sequence tuple is complete and
852 * the memory allocated for the related objects may be freed.
853 * @sp: The sequence that has completed
855 static void fc_exch_done(struct fc_seq
*sp
)
857 struct fc_exch
*ep
= fc_seq_exch(sp
);
860 spin_lock_bh(&ep
->ex_lock
);
861 rc
= fc_exch_done_locked(ep
);
862 spin_unlock_bh(&ep
->ex_lock
);
868 * fc_exch_resp() - Allocate a new exchange for a response frame
869 * @lport: The local port that the exchange was for
870 * @mp: The exchange manager to allocate the exchange from
871 * @fp: The response frame
873 * Sets the responder ID in the frame header.
875 static struct fc_exch
*fc_exch_resp(struct fc_lport
*lport
,
876 struct fc_exch_mgr
*mp
,
880 struct fc_frame_header
*fh
;
882 ep
= fc_exch_alloc(lport
, fp
);
884 ep
->class = fc_frame_class(fp
);
887 * Set EX_CTX indicating we're responding on this exchange.
889 ep
->f_ctl
|= FC_FC_EX_CTX
; /* we're responding */
890 ep
->f_ctl
&= ~FC_FC_FIRST_SEQ
; /* not new */
891 fh
= fc_frame_header_get(fp
);
892 ep
->sid
= ntoh24(fh
->fh_d_id
);
893 ep
->did
= ntoh24(fh
->fh_s_id
);
897 * Allocated exchange has placed the XID in the
898 * originator field. Move it to the responder field,
899 * and set the originator XID from the frame.
902 ep
->oxid
= ntohs(fh
->fh_ox_id
);
903 ep
->esb_stat
|= ESB_ST_RESP
| ESB_ST_SEQ_INIT
;
904 if ((ntoh24(fh
->fh_f_ctl
) & FC_FC_SEQ_INIT
) == 0)
905 ep
->esb_stat
&= ~ESB_ST_SEQ_INIT
;
907 fc_exch_hold(ep
); /* hold for caller */
908 spin_unlock_bh(&ep
->ex_lock
); /* lock from fc_exch_alloc */
914 * fc_seq_lookup_recip() - Find a sequence where the other end
915 * originated the sequence
916 * @lport: The local port that the frame was sent to
917 * @mp: The Exchange Manager to lookup the exchange from
918 * @fp: The frame associated with the sequence we're looking for
920 * If fc_pf_rjt_reason is FC_RJT_NONE then this function will have a hold
921 * on the ep that should be released by the caller.
923 static enum fc_pf_rjt_reason
fc_seq_lookup_recip(struct fc_lport
*lport
,
924 struct fc_exch_mgr
*mp
,
927 struct fc_frame_header
*fh
= fc_frame_header_get(fp
);
928 struct fc_exch
*ep
= NULL
;
929 struct fc_seq
*sp
= NULL
;
930 enum fc_pf_rjt_reason reject
= FC_RJT_NONE
;
934 f_ctl
= ntoh24(fh
->fh_f_ctl
);
935 WARN_ON((f_ctl
& FC_FC_SEQ_CTX
) != 0);
938 * Lookup or create the exchange if we will be creating the sequence.
940 if (f_ctl
& FC_FC_EX_CTX
) {
941 xid
= ntohs(fh
->fh_ox_id
); /* we originated exch */
942 ep
= fc_exch_find(mp
, xid
);
944 atomic_inc(&mp
->stats
.xid_not_found
);
945 reject
= FC_RJT_OX_ID
;
948 if (ep
->rxid
== FC_XID_UNKNOWN
)
949 ep
->rxid
= ntohs(fh
->fh_rx_id
);
950 else if (ep
->rxid
!= ntohs(fh
->fh_rx_id
)) {
951 reject
= FC_RJT_OX_ID
;
955 xid
= ntohs(fh
->fh_rx_id
); /* we are the responder */
958 * Special case for MDS issuing an ELS TEST with a
960 * XXX take this out once we do the proper reject.
962 if (xid
== 0 && fh
->fh_r_ctl
== FC_RCTL_ELS_REQ
&&
963 fc_frame_payload_op(fp
) == ELS_TEST
) {
964 fh
->fh_rx_id
= htons(FC_XID_UNKNOWN
);
965 xid
= FC_XID_UNKNOWN
;
969 * new sequence - find the exchange
971 ep
= fc_exch_find(mp
, xid
);
972 if ((f_ctl
& FC_FC_FIRST_SEQ
) && fc_sof_is_init(fr_sof(fp
))) {
974 atomic_inc(&mp
->stats
.xid_busy
);
975 reject
= FC_RJT_RX_ID
;
978 ep
= fc_exch_resp(lport
, mp
, fp
);
980 reject
= FC_RJT_EXCH_EST
; /* XXX */
983 xid
= ep
->xid
; /* get our XID */
985 atomic_inc(&mp
->stats
.xid_not_found
);
986 reject
= FC_RJT_RX_ID
; /* XID not found */
992 * At this point, we have the exchange held.
993 * Find or create the sequence.
995 if (fc_sof_is_init(fr_sof(fp
))) {
997 sp
->ssb_stat
|= SSB_ST_RESP
;
998 sp
->id
= fh
->fh_seq_id
;
1001 if (sp
->id
!= fh
->fh_seq_id
) {
1002 atomic_inc(&mp
->stats
.seq_not_found
);
1003 if (f_ctl
& FC_FC_END_SEQ
) {
1005 * Update sequence_id based on incoming last
1006 * frame of sequence exchange. This is needed
1007 * for FC target where DDP has been used
1008 * on target where, stack is indicated only
1009 * about last frame's (payload _header) header.
1010 * Whereas "seq_id" which is part of
1011 * frame_header is allocated by initiator
1012 * which is totally different from "seq_id"
1013 * allocated when XFER_RDY was sent by target.
1014 * To avoid false -ve which results into not
1015 * sending RSP, hence write request on other
1016 * end never finishes.
1018 spin_lock_bh(&ep
->ex_lock
);
1019 sp
->ssb_stat
|= SSB_ST_RESP
;
1020 sp
->id
= fh
->fh_seq_id
;
1021 spin_unlock_bh(&ep
->ex_lock
);
1023 /* sequence/exch should exist */
1024 reject
= FC_RJT_SEQ_ID
;
1029 WARN_ON(ep
!= fc_seq_exch(sp
));
1031 if (f_ctl
& FC_FC_SEQ_INIT
)
1032 ep
->esb_stat
|= ESB_ST_SEQ_INIT
;
1038 fc_exch_done(&ep
->seq
);
1039 fc_exch_release(ep
); /* hold from fc_exch_find/fc_exch_resp */
1044 * fc_seq_lookup_orig() - Find a sequence where this end
1045 * originated the sequence
1046 * @mp: The Exchange Manager to lookup the exchange from
1047 * @fp: The frame associated with the sequence we're looking for
1049 * Does not hold the sequence for the caller.
1051 static struct fc_seq
*fc_seq_lookup_orig(struct fc_exch_mgr
*mp
,
1052 struct fc_frame
*fp
)
1054 struct fc_frame_header
*fh
= fc_frame_header_get(fp
);
1056 struct fc_seq
*sp
= NULL
;
1060 f_ctl
= ntoh24(fh
->fh_f_ctl
);
1061 WARN_ON((f_ctl
& FC_FC_SEQ_CTX
) != FC_FC_SEQ_CTX
);
1062 xid
= ntohs((f_ctl
& FC_FC_EX_CTX
) ? fh
->fh_ox_id
: fh
->fh_rx_id
);
1063 ep
= fc_exch_find(mp
, xid
);
1066 if (ep
->seq
.id
== fh
->fh_seq_id
) {
1068 * Save the RX_ID if we didn't previously know it.
1071 if ((f_ctl
& FC_FC_EX_CTX
) != 0 &&
1072 ep
->rxid
== FC_XID_UNKNOWN
) {
1073 ep
->rxid
= ntohs(fh
->fh_rx_id
);
1076 fc_exch_release(ep
);
1081 * fc_exch_set_addr() - Set the source and destination IDs for an exchange
1082 * @ep: The exchange to set the addresses for
1083 * @orig_id: The originator's ID
1084 * @resp_id: The responder's ID
1086 * Note this must be done before the first sequence of the exchange is sent.
1088 static void fc_exch_set_addr(struct fc_exch
*ep
,
1089 u32 orig_id
, u32 resp_id
)
1092 if (ep
->esb_stat
& ESB_ST_RESP
) {
1102 * fc_seq_els_rsp_send() - Send an ELS response using information from
1103 * the existing sequence/exchange.
1104 * @fp: The received frame
1105 * @els_cmd: The ELS command to be sent
1106 * @els_data: The ELS data to be sent
1108 * The received frame is not freed.
1110 static void fc_seq_els_rsp_send(struct fc_frame
*fp
, enum fc_els_cmd els_cmd
,
1111 struct fc_seq_els_data
*els_data
)
1115 fc_seq_ls_rjt(fp
, els_data
->reason
, els_data
->explan
);
1121 fc_exch_els_rrq(fp
);
1124 fc_exch_els_rec(fp
);
1127 FC_LPORT_DBG(fr_dev(fp
), "Invalid ELS CMD:%x\n", els_cmd
);
1132 * fc_seq_send_last() - Send a sequence that is the last in the exchange
1133 * @sp: The sequence that is to be sent
1134 * @fp: The frame that will be sent on the sequence
1135 * @rctl: The R_CTL information to be sent
1136 * @fh_type: The frame header type
1138 static void fc_seq_send_last(struct fc_seq
*sp
, struct fc_frame
*fp
,
1139 enum fc_rctl rctl
, enum fc_fh_type fh_type
)
1142 struct fc_exch
*ep
= fc_seq_exch(sp
);
1144 f_ctl
= FC_FC_LAST_SEQ
| FC_FC_END_SEQ
| FC_FC_SEQ_INIT
;
1146 fc_fill_fc_hdr(fp
, rctl
, ep
->did
, ep
->sid
, fh_type
, f_ctl
, 0);
1147 fc_seq_send_locked(ep
->lp
, sp
, fp
);
1151 * fc_seq_send_ack() - Send an acknowledgement that we've received a frame
1152 * @sp: The sequence to send the ACK on
1153 * @rx_fp: The received frame that is being acknoledged
1155 * Send ACK_1 (or equiv.) indicating we received something.
1157 static void fc_seq_send_ack(struct fc_seq
*sp
, const struct fc_frame
*rx_fp
)
1159 struct fc_frame
*fp
;
1160 struct fc_frame_header
*rx_fh
;
1161 struct fc_frame_header
*fh
;
1162 struct fc_exch
*ep
= fc_seq_exch(sp
);
1163 struct fc_lport
*lport
= ep
->lp
;
1167 * Don't send ACKs for class 3.
1169 if (fc_sof_needs_ack(fr_sof(rx_fp
))) {
1170 fp
= fc_frame_alloc(lport
, 0);
1174 fh
= fc_frame_header_get(fp
);
1175 fh
->fh_r_ctl
= FC_RCTL_ACK_1
;
1176 fh
->fh_type
= FC_TYPE_BLS
;
1179 * Form f_ctl by inverting EX_CTX and SEQ_CTX (bits 23, 22).
1180 * Echo FIRST_SEQ, LAST_SEQ, END_SEQ, END_CONN, SEQ_INIT.
1181 * Bits 9-8 are meaningful (retransmitted or unidirectional).
1182 * Last ACK uses bits 7-6 (continue sequence),
1183 * bits 5-4 are meaningful (what kind of ACK to use).
1185 rx_fh
= fc_frame_header_get(rx_fp
);
1186 f_ctl
= ntoh24(rx_fh
->fh_f_ctl
);
1187 f_ctl
&= FC_FC_EX_CTX
| FC_FC_SEQ_CTX
|
1188 FC_FC_FIRST_SEQ
| FC_FC_LAST_SEQ
|
1189 FC_FC_END_SEQ
| FC_FC_END_CONN
| FC_FC_SEQ_INIT
|
1190 FC_FC_RETX_SEQ
| FC_FC_UNI_TX
;
1191 f_ctl
^= FC_FC_EX_CTX
| FC_FC_SEQ_CTX
;
1192 hton24(fh
->fh_f_ctl
, f_ctl
);
1194 fc_exch_setup_hdr(ep
, fp
, f_ctl
);
1195 fh
->fh_seq_id
= rx_fh
->fh_seq_id
;
1196 fh
->fh_seq_cnt
= rx_fh
->fh_seq_cnt
;
1197 fh
->fh_parm_offset
= htonl(1); /* ack single frame */
1199 fr_sof(fp
) = fr_sof(rx_fp
);
1200 if (f_ctl
& FC_FC_END_SEQ
)
1201 fr_eof(fp
) = FC_EOF_T
;
1203 fr_eof(fp
) = FC_EOF_N
;
1205 lport
->tt
.frame_send(lport
, fp
);
1210 * fc_exch_send_ba_rjt() - Send BLS Reject
1211 * @rx_fp: The frame being rejected
1212 * @reason: The reason the frame is being rejected
1213 * @explan: The explanation for the rejection
1215 * This is for rejecting BA_ABTS only.
1217 static void fc_exch_send_ba_rjt(struct fc_frame
*rx_fp
,
1218 enum fc_ba_rjt_reason reason
,
1219 enum fc_ba_rjt_explan explan
)
1221 struct fc_frame
*fp
;
1222 struct fc_frame_header
*rx_fh
;
1223 struct fc_frame_header
*fh
;
1224 struct fc_ba_rjt
*rp
;
1225 struct fc_lport
*lport
;
1228 lport
= fr_dev(rx_fp
);
1229 fp
= fc_frame_alloc(lport
, sizeof(*rp
));
1232 fh
= fc_frame_header_get(fp
);
1233 rx_fh
= fc_frame_header_get(rx_fp
);
1235 memset(fh
, 0, sizeof(*fh
) + sizeof(*rp
));
1237 rp
= fc_frame_payload_get(fp
, sizeof(*rp
));
1238 rp
->br_reason
= reason
;
1239 rp
->br_explan
= explan
;
1242 * seq_id, cs_ctl, df_ctl and param/offset are zero.
1244 memcpy(fh
->fh_s_id
, rx_fh
->fh_d_id
, 3);
1245 memcpy(fh
->fh_d_id
, rx_fh
->fh_s_id
, 3);
1246 fh
->fh_ox_id
= rx_fh
->fh_ox_id
;
1247 fh
->fh_rx_id
= rx_fh
->fh_rx_id
;
1248 fh
->fh_seq_cnt
= rx_fh
->fh_seq_cnt
;
1249 fh
->fh_r_ctl
= FC_RCTL_BA_RJT
;
1250 fh
->fh_type
= FC_TYPE_BLS
;
1253 * Form f_ctl by inverting EX_CTX and SEQ_CTX (bits 23, 22).
1254 * Echo FIRST_SEQ, LAST_SEQ, END_SEQ, END_CONN, SEQ_INIT.
1255 * Bits 9-8 are meaningful (retransmitted or unidirectional).
1256 * Last ACK uses bits 7-6 (continue sequence),
1257 * bits 5-4 are meaningful (what kind of ACK to use).
1258 * Always set LAST_SEQ, END_SEQ.
1260 f_ctl
= ntoh24(rx_fh
->fh_f_ctl
);
1261 f_ctl
&= FC_FC_EX_CTX
| FC_FC_SEQ_CTX
|
1262 FC_FC_END_CONN
| FC_FC_SEQ_INIT
|
1263 FC_FC_RETX_SEQ
| FC_FC_UNI_TX
;
1264 f_ctl
^= FC_FC_EX_CTX
| FC_FC_SEQ_CTX
;
1265 f_ctl
|= FC_FC_LAST_SEQ
| FC_FC_END_SEQ
;
1266 f_ctl
&= ~FC_FC_FIRST_SEQ
;
1267 hton24(fh
->fh_f_ctl
, f_ctl
);
1269 fr_sof(fp
) = fc_sof_class(fr_sof(rx_fp
));
1270 fr_eof(fp
) = FC_EOF_T
;
1271 if (fc_sof_needs_ack(fr_sof(fp
)))
1272 fr_eof(fp
) = FC_EOF_N
;
1274 lport
->tt
.frame_send(lport
, fp
);
1278 * fc_exch_recv_abts() - Handle an incoming ABTS
1279 * @ep: The exchange the abort was on
1280 * @rx_fp: The ABTS frame
1282 * This would be for target mode usually, but could be due to lost
1283 * FCP transfer ready, confirm or RRQ. We always handle this as an
1284 * exchange abort, ignoring the parameter.
1286 static void fc_exch_recv_abts(struct fc_exch
*ep
, struct fc_frame
*rx_fp
)
1288 struct fc_frame
*fp
;
1289 struct fc_ba_acc
*ap
;
1290 struct fc_frame_header
*fh
;
1295 spin_lock_bh(&ep
->ex_lock
);
1296 if (ep
->esb_stat
& ESB_ST_COMPLETE
) {
1297 spin_unlock_bh(&ep
->ex_lock
);
1300 if (!(ep
->esb_stat
& ESB_ST_REC_QUAL
))
1301 fc_exch_hold(ep
); /* hold for REC_QUAL */
1302 ep
->esb_stat
|= ESB_ST_ABNORMAL
| ESB_ST_REC_QUAL
;
1303 fc_exch_timer_set_locked(ep
, ep
->r_a_tov
);
1305 fp
= fc_frame_alloc(ep
->lp
, sizeof(*ap
));
1307 spin_unlock_bh(&ep
->ex_lock
);
1310 fh
= fc_frame_header_get(fp
);
1311 ap
= fc_frame_payload_get(fp
, sizeof(*ap
));
1312 memset(ap
, 0, sizeof(*ap
));
1314 ap
->ba_high_seq_cnt
= htons(0xffff);
1315 if (sp
->ssb_stat
& SSB_ST_RESP
) {
1316 ap
->ba_seq_id
= sp
->id
;
1317 ap
->ba_seq_id_val
= FC_BA_SEQ_ID_VAL
;
1318 ap
->ba_high_seq_cnt
= fh
->fh_seq_cnt
;
1319 ap
->ba_low_seq_cnt
= htons(sp
->cnt
);
1321 sp
= fc_seq_start_next_locked(sp
);
1322 fc_seq_send_last(sp
, fp
, FC_RCTL_BA_ACC
, FC_TYPE_BLS
);
1323 spin_unlock_bh(&ep
->ex_lock
);
1324 fc_frame_free(rx_fp
);
1328 fc_exch_send_ba_rjt(rx_fp
, FC_BA_RJT_UNABLE
, FC_BA_RJT_INV_XID
);
1330 fc_frame_free(rx_fp
);
1334 * fc_seq_assign() - Assign exchange and sequence for incoming request
1335 * @lport: The local port that received the request
1336 * @fp: The request frame
1338 * On success, the sequence pointer will be returned and also in fr_seq(@fp).
1339 * A reference will be held on the exchange/sequence for the caller, which
1340 * must call fc_seq_release().
1342 static struct fc_seq
*fc_seq_assign(struct fc_lport
*lport
, struct fc_frame
*fp
)
1344 struct fc_exch_mgr_anchor
*ema
;
1346 WARN_ON(lport
!= fr_dev(fp
));
1347 WARN_ON(fr_seq(fp
));
1350 list_for_each_entry(ema
, &lport
->ema_list
, ema_list
)
1351 if ((!ema
->match
|| ema
->match(fp
)) &&
1352 fc_seq_lookup_recip(lport
, ema
->mp
, fp
) == FC_RJT_NONE
)
1358 * fc_seq_release() - Release the hold
1359 * @sp: The sequence.
1361 static void fc_seq_release(struct fc_seq
*sp
)
1363 fc_exch_release(fc_seq_exch(sp
));
1367 * fc_exch_recv_req() - Handler for an incoming request
1368 * @lport: The local port that received the request
1369 * @mp: The EM that the exchange is on
1370 * @fp: The request frame
1372 * This is used when the other end is originating the exchange
1375 static void fc_exch_recv_req(struct fc_lport
*lport
, struct fc_exch_mgr
*mp
,
1376 struct fc_frame
*fp
)
1378 struct fc_frame_header
*fh
= fc_frame_header_get(fp
);
1379 struct fc_seq
*sp
= NULL
;
1380 struct fc_exch
*ep
= NULL
;
1381 enum fc_pf_rjt_reason reject
;
1383 /* We can have the wrong fc_lport at this point with NPIV, which is a
1384 * problem now that we know a new exchange needs to be allocated
1386 lport
= fc_vport_id_lookup(lport
, ntoh24(fh
->fh_d_id
));
1393 BUG_ON(fr_seq(fp
)); /* XXX remove later */
1396 * If the RX_ID is 0xffff, don't allocate an exchange.
1397 * The upper-level protocol may request one later, if needed.
1399 if (fh
->fh_rx_id
== htons(FC_XID_UNKNOWN
))
1400 return lport
->tt
.lport_recv(lport
, fp
);
1402 reject
= fc_seq_lookup_recip(lport
, mp
, fp
);
1403 if (reject
== FC_RJT_NONE
) {
1404 sp
= fr_seq(fp
); /* sequence will be held */
1405 ep
= fc_seq_exch(sp
);
1406 fc_seq_send_ack(sp
, fp
);
1407 ep
->encaps
= fr_encaps(fp
);
1410 * Call the receive function.
1412 * The receive function may allocate a new sequence
1413 * over the old one, so we shouldn't change the
1414 * sequence after this.
1416 * The frame will be freed by the receive function.
1417 * If new exch resp handler is valid then call that
1421 ep
->resp(sp
, fp
, ep
->arg
);
1423 lport
->tt
.lport_recv(lport
, fp
);
1424 fc_exch_release(ep
); /* release from lookup */
1426 FC_LPORT_DBG(lport
, "exch/seq lookup failed: reject %x\n",
1433 * fc_exch_recv_seq_resp() - Handler for an incoming response where the other
1434 * end is the originator of the sequence that is a
1435 * response to our initial exchange
1436 * @mp: The EM that the exchange is on
1437 * @fp: The response frame
1439 static void fc_exch_recv_seq_resp(struct fc_exch_mgr
*mp
, struct fc_frame
*fp
)
1441 struct fc_frame_header
*fh
= fc_frame_header_get(fp
);
1446 void (*resp
)(struct fc_seq
*, struct fc_frame
*fp
, void *arg
);
1450 ep
= fc_exch_find(mp
, ntohs(fh
->fh_ox_id
));
1452 atomic_inc(&mp
->stats
.xid_not_found
);
1455 if (ep
->esb_stat
& ESB_ST_COMPLETE
) {
1456 atomic_inc(&mp
->stats
.xid_not_found
);
1459 if (ep
->rxid
== FC_XID_UNKNOWN
)
1460 ep
->rxid
= ntohs(fh
->fh_rx_id
);
1461 if (ep
->sid
!= 0 && ep
->sid
!= ntoh24(fh
->fh_d_id
)) {
1462 atomic_inc(&mp
->stats
.xid_not_found
);
1465 if (ep
->did
!= ntoh24(fh
->fh_s_id
) &&
1466 ep
->did
!= FC_FID_FLOGI
) {
1467 atomic_inc(&mp
->stats
.xid_not_found
);
1472 if (fc_sof_is_init(sof
)) {
1473 sp
->ssb_stat
|= SSB_ST_RESP
;
1474 sp
->id
= fh
->fh_seq_id
;
1475 } else if (sp
->id
!= fh
->fh_seq_id
) {
1476 atomic_inc(&mp
->stats
.seq_not_found
);
1480 f_ctl
= ntoh24(fh
->fh_f_ctl
);
1482 if (f_ctl
& FC_FC_SEQ_INIT
)
1483 ep
->esb_stat
|= ESB_ST_SEQ_INIT
;
1485 if (fc_sof_needs_ack(sof
))
1486 fc_seq_send_ack(sp
, fp
);
1488 ex_resp_arg
= ep
->arg
;
1490 if (fh
->fh_type
!= FC_TYPE_FCP
&& fr_eof(fp
) == FC_EOF_T
&&
1491 (f_ctl
& (FC_FC_LAST_SEQ
| FC_FC_END_SEQ
)) ==
1492 (FC_FC_LAST_SEQ
| FC_FC_END_SEQ
)) {
1493 spin_lock_bh(&ep
->ex_lock
);
1495 rc
= fc_exch_done_locked(ep
);
1496 WARN_ON(fc_seq_exch(sp
) != ep
);
1497 spin_unlock_bh(&ep
->ex_lock
);
1503 * Call the receive function.
1504 * The sequence is held (has a refcnt) for us,
1505 * but not for the receive function.
1507 * The receive function may allocate a new sequence
1508 * over the old one, so we shouldn't change the
1509 * sequence after this.
1511 * The frame will be freed by the receive function.
1512 * If new exch resp handler is valid then call that
1516 resp(sp
, fp
, ex_resp_arg
);
1519 fc_exch_release(ep
);
1522 fc_exch_release(ep
);
1528 * fc_exch_recv_resp() - Handler for a sequence where other end is
1529 * responding to our sequence
1530 * @mp: The EM that the exchange is on
1531 * @fp: The response frame
1533 static void fc_exch_recv_resp(struct fc_exch_mgr
*mp
, struct fc_frame
*fp
)
1537 sp
= fc_seq_lookup_orig(mp
, fp
); /* doesn't hold sequence */
1540 atomic_inc(&mp
->stats
.xid_not_found
);
1542 atomic_inc(&mp
->stats
.non_bls_resp
);
1548 * fc_exch_abts_resp() - Handler for a response to an ABT
1549 * @ep: The exchange that the frame is on
1550 * @fp: The response frame
1552 * This response would be to an ABTS cancelling an exchange or sequence.
1553 * The response can be either BA_ACC or BA_RJT
1555 static void fc_exch_abts_resp(struct fc_exch
*ep
, struct fc_frame
*fp
)
1557 void (*resp
)(struct fc_seq
*, struct fc_frame
*fp
, void *arg
);
1559 struct fc_frame_header
*fh
;
1560 struct fc_ba_acc
*ap
;
1564 int rc
= 1, has_rec
= 0;
1566 fh
= fc_frame_header_get(fp
);
1567 FC_EXCH_DBG(ep
, "exch: BLS rctl %x - %s\n", fh
->fh_r_ctl
,
1568 fc_exch_rctl_name(fh
->fh_r_ctl
));
1570 if (cancel_delayed_work_sync(&ep
->timeout_work
)) {
1571 FC_EXCH_DBG(ep
, "Exchange timer canceled due to ABTS response\n");
1572 fc_exch_release(ep
); /* release from pending timer hold */
1575 spin_lock_bh(&ep
->ex_lock
);
1576 switch (fh
->fh_r_ctl
) {
1577 case FC_RCTL_BA_ACC
:
1578 ap
= fc_frame_payload_get(fp
, sizeof(*ap
));
1583 * Decide whether to establish a Recovery Qualifier.
1584 * We do this if there is a non-empty SEQ_CNT range and
1585 * SEQ_ID is the same as the one we aborted.
1587 low
= ntohs(ap
->ba_low_seq_cnt
);
1588 high
= ntohs(ap
->ba_high_seq_cnt
);
1589 if ((ep
->esb_stat
& ESB_ST_REC_QUAL
) == 0 &&
1590 (ap
->ba_seq_id_val
!= FC_BA_SEQ_ID_VAL
||
1591 ap
->ba_seq_id
== ep
->seq_id
) && low
!= high
) {
1592 ep
->esb_stat
|= ESB_ST_REC_QUAL
;
1593 fc_exch_hold(ep
); /* hold for recovery qualifier */
1597 case FC_RCTL_BA_RJT
:
1604 ex_resp_arg
= ep
->arg
;
1606 /* do we need to do some other checks here. Can we reuse more of
1607 * fc_exch_recv_seq_resp
1611 * do we want to check END_SEQ as well as LAST_SEQ here?
1613 if (ep
->fh_type
!= FC_TYPE_FCP
&&
1614 ntoh24(fh
->fh_f_ctl
) & FC_FC_LAST_SEQ
)
1615 rc
= fc_exch_done_locked(ep
);
1616 spin_unlock_bh(&ep
->ex_lock
);
1621 resp(sp
, fp
, ex_resp_arg
);
1626 fc_exch_timer_set(ep
, ep
->r_a_tov
);
1631 * fc_exch_recv_bls() - Handler for a BLS sequence
1632 * @mp: The EM that the exchange is on
1633 * @fp: The request frame
1635 * The BLS frame is always a sequence initiated by the remote side.
1636 * We may be either the originator or recipient of the exchange.
1638 static void fc_exch_recv_bls(struct fc_exch_mgr
*mp
, struct fc_frame
*fp
)
1640 struct fc_frame_header
*fh
;
1644 fh
= fc_frame_header_get(fp
);
1645 f_ctl
= ntoh24(fh
->fh_f_ctl
);
1648 ep
= fc_exch_find(mp
, (f_ctl
& FC_FC_EX_CTX
) ?
1649 ntohs(fh
->fh_ox_id
) : ntohs(fh
->fh_rx_id
));
1650 if (ep
&& (f_ctl
& FC_FC_SEQ_INIT
)) {
1651 spin_lock_bh(&ep
->ex_lock
);
1652 ep
->esb_stat
|= ESB_ST_SEQ_INIT
;
1653 spin_unlock_bh(&ep
->ex_lock
);
1655 if (f_ctl
& FC_FC_SEQ_CTX
) {
1657 * A response to a sequence we initiated.
1658 * This should only be ACKs for class 2 or F.
1660 switch (fh
->fh_r_ctl
) {
1666 FC_EXCH_DBG(ep
, "BLS rctl %x - %s received\n",
1668 fc_exch_rctl_name(fh
->fh_r_ctl
));
1673 switch (fh
->fh_r_ctl
) {
1674 case FC_RCTL_BA_RJT
:
1675 case FC_RCTL_BA_ACC
:
1677 fc_exch_abts_resp(ep
, fp
);
1681 case FC_RCTL_BA_ABTS
:
1682 fc_exch_recv_abts(ep
, fp
);
1684 default: /* ignore junk */
1690 fc_exch_release(ep
); /* release hold taken by fc_exch_find */
1694 * fc_seq_ls_acc() - Accept sequence with LS_ACC
1695 * @rx_fp: The received frame, not freed here.
1697 * If this fails due to allocation or transmit congestion, assume the
1698 * originator will repeat the sequence.
1700 static void fc_seq_ls_acc(struct fc_frame
*rx_fp
)
1702 struct fc_lport
*lport
;
1703 struct fc_els_ls_acc
*acc
;
1704 struct fc_frame
*fp
;
1706 lport
= fr_dev(rx_fp
);
1707 fp
= fc_frame_alloc(lport
, sizeof(*acc
));
1710 acc
= fc_frame_payload_get(fp
, sizeof(*acc
));
1711 memset(acc
, 0, sizeof(*acc
));
1712 acc
->la_cmd
= ELS_LS_ACC
;
1713 fc_fill_reply_hdr(fp
, rx_fp
, FC_RCTL_ELS_REP
, 0);
1714 lport
->tt
.frame_send(lport
, fp
);
1718 * fc_seq_ls_rjt() - Reject a sequence with ELS LS_RJT
1719 * @rx_fp: The received frame, not freed here.
1720 * @reason: The reason the sequence is being rejected
1721 * @explan: The explanation for the rejection
1723 * If this fails due to allocation or transmit congestion, assume the
1724 * originator will repeat the sequence.
1726 static void fc_seq_ls_rjt(struct fc_frame
*rx_fp
, enum fc_els_rjt_reason reason
,
1727 enum fc_els_rjt_explan explan
)
1729 struct fc_lport
*lport
;
1730 struct fc_els_ls_rjt
*rjt
;
1731 struct fc_frame
*fp
;
1733 lport
= fr_dev(rx_fp
);
1734 fp
= fc_frame_alloc(lport
, sizeof(*rjt
));
1737 rjt
= fc_frame_payload_get(fp
, sizeof(*rjt
));
1738 memset(rjt
, 0, sizeof(*rjt
));
1739 rjt
->er_cmd
= ELS_LS_RJT
;
1740 rjt
->er_reason
= reason
;
1741 rjt
->er_explan
= explan
;
1742 fc_fill_reply_hdr(fp
, rx_fp
, FC_RCTL_ELS_REP
, 0);
1743 lport
->tt
.frame_send(lport
, fp
);
1747 * fc_exch_reset() - Reset an exchange
1748 * @ep: The exchange to be reset
1750 static void fc_exch_reset(struct fc_exch
*ep
)
1753 void (*resp
)(struct fc_seq
*, struct fc_frame
*, void *);
1757 spin_lock_bh(&ep
->ex_lock
);
1758 fc_exch_abort_locked(ep
, 0);
1759 ep
->state
|= FC_EX_RST_CLEANUP
;
1760 fc_exch_timer_cancel(ep
);
1763 if (ep
->esb_stat
& ESB_ST_REC_QUAL
)
1764 atomic_dec(&ep
->ex_refcnt
); /* drop hold for rec_qual */
1765 ep
->esb_stat
&= ~ESB_ST_REC_QUAL
;
1768 rc
= fc_exch_done_locked(ep
);
1769 spin_unlock_bh(&ep
->ex_lock
);
1774 resp(sp
, ERR_PTR(-FC_EX_CLOSED
), arg
);
1778 * fc_exch_pool_reset() - Reset a per cpu exchange pool
1779 * @lport: The local port that the exchange pool is on
1780 * @pool: The exchange pool to be reset
1781 * @sid: The source ID
1782 * @did: The destination ID
1784 * Resets a per cpu exches pool, releasing all of its sequences
1785 * and exchanges. If sid is non-zero then reset only exchanges
1786 * we sourced from the local port's FID. If did is non-zero then
1787 * only reset exchanges destined for the local port's FID.
1789 static void fc_exch_pool_reset(struct fc_lport
*lport
,
1790 struct fc_exch_pool
*pool
,
1794 struct fc_exch
*next
;
1796 spin_lock_bh(&pool
->lock
);
1798 list_for_each_entry_safe(ep
, next
, &pool
->ex_list
, ex_list
) {
1799 if ((lport
== ep
->lp
) &&
1800 (sid
== 0 || sid
== ep
->sid
) &&
1801 (did
== 0 || did
== ep
->did
)) {
1803 spin_unlock_bh(&pool
->lock
);
1807 fc_exch_release(ep
);
1808 spin_lock_bh(&pool
->lock
);
1811 * must restart loop incase while lock
1812 * was down multiple eps were released.
1817 pool
->next_index
= 0;
1818 pool
->left
= FC_XID_UNKNOWN
;
1819 pool
->right
= FC_XID_UNKNOWN
;
1820 spin_unlock_bh(&pool
->lock
);
1824 * fc_exch_mgr_reset() - Reset all EMs of a local port
1825 * @lport: The local port whose EMs are to be reset
1826 * @sid: The source ID
1827 * @did: The destination ID
1829 * Reset all EMs associated with a given local port. Release all
1830 * sequences and exchanges. If sid is non-zero then reset only the
1831 * exchanges sent from the local port's FID. If did is non-zero then
1832 * reset only exchanges destined for the local port's FID.
1834 void fc_exch_mgr_reset(struct fc_lport
*lport
, u32 sid
, u32 did
)
1836 struct fc_exch_mgr_anchor
*ema
;
1839 list_for_each_entry(ema
, &lport
->ema_list
, ema_list
) {
1840 for_each_possible_cpu(cpu
)
1841 fc_exch_pool_reset(lport
,
1842 per_cpu_ptr(ema
->mp
->pool
, cpu
),
1846 EXPORT_SYMBOL(fc_exch_mgr_reset
);
1849 * fc_exch_lookup() - find an exchange
1850 * @lport: The local port
1851 * @xid: The exchange ID
1853 * Returns exchange pointer with hold for caller, or NULL if not found.
1855 static struct fc_exch
*fc_exch_lookup(struct fc_lport
*lport
, u32 xid
)
1857 struct fc_exch_mgr_anchor
*ema
;
1859 list_for_each_entry(ema
, &lport
->ema_list
, ema_list
)
1860 if (ema
->mp
->min_xid
<= xid
&& xid
<= ema
->mp
->max_xid
)
1861 return fc_exch_find(ema
->mp
, xid
);
1866 * fc_exch_els_rec() - Handler for ELS REC (Read Exchange Concise) requests
1867 * @rfp: The REC frame, not freed here.
1869 * Note that the requesting port may be different than the S_ID in the request.
1871 static void fc_exch_els_rec(struct fc_frame
*rfp
)
1873 struct fc_lport
*lport
;
1874 struct fc_frame
*fp
;
1876 struct fc_els_rec
*rp
;
1877 struct fc_els_rec_acc
*acc
;
1878 enum fc_els_rjt_reason reason
= ELS_RJT_LOGIC
;
1879 enum fc_els_rjt_explan explan
;
1884 lport
= fr_dev(rfp
);
1885 rp
= fc_frame_payload_get(rfp
, sizeof(*rp
));
1886 explan
= ELS_EXPL_INV_LEN
;
1889 sid
= ntoh24(rp
->rec_s_id
);
1890 rxid
= ntohs(rp
->rec_rx_id
);
1891 oxid
= ntohs(rp
->rec_ox_id
);
1893 ep
= fc_exch_lookup(lport
,
1894 sid
== fc_host_port_id(lport
->host
) ? oxid
: rxid
);
1895 explan
= ELS_EXPL_OXID_RXID
;
1898 if (ep
->oid
!= sid
|| oxid
!= ep
->oxid
)
1900 if (rxid
!= FC_XID_UNKNOWN
&& rxid
!= ep
->rxid
)
1902 fp
= fc_frame_alloc(lport
, sizeof(*acc
));
1906 acc
= fc_frame_payload_get(fp
, sizeof(*acc
));
1907 memset(acc
, 0, sizeof(*acc
));
1908 acc
->reca_cmd
= ELS_LS_ACC
;
1909 acc
->reca_ox_id
= rp
->rec_ox_id
;
1910 memcpy(acc
->reca_ofid
, rp
->rec_s_id
, 3);
1911 acc
->reca_rx_id
= htons(ep
->rxid
);
1912 if (ep
->sid
== ep
->oid
)
1913 hton24(acc
->reca_rfid
, ep
->did
);
1915 hton24(acc
->reca_rfid
, ep
->sid
);
1916 acc
->reca_fc4value
= htonl(ep
->seq
.rec_data
);
1917 acc
->reca_e_stat
= htonl(ep
->esb_stat
& (ESB_ST_RESP
|
1920 fc_fill_reply_hdr(fp
, rfp
, FC_RCTL_ELS_REP
, 0);
1921 lport
->tt
.frame_send(lport
, fp
);
1923 fc_exch_release(ep
);
1927 fc_exch_release(ep
);
1929 fc_seq_ls_rjt(rfp
, reason
, explan
);
1933 * fc_exch_rrq_resp() - Handler for RRQ responses
1934 * @sp: The sequence that the RRQ is on
1935 * @fp: The RRQ frame
1936 * @arg: The exchange that the RRQ is on
1938 * TODO: fix error handler.
1940 static void fc_exch_rrq_resp(struct fc_seq
*sp
, struct fc_frame
*fp
, void *arg
)
1942 struct fc_exch
*aborted_ep
= arg
;
1946 int err
= PTR_ERR(fp
);
1948 if (err
== -FC_EX_CLOSED
|| err
== -FC_EX_TIMEOUT
)
1950 FC_EXCH_DBG(aborted_ep
, "Cannot process RRQ, "
1951 "frame error %d\n", err
);
1955 op
= fc_frame_payload_op(fp
);
1960 FC_EXCH_DBG(aborted_ep
, "LS_RJT for RRQ\n");
1965 FC_EXCH_DBG(aborted_ep
, "unexpected response op %x for RRQ\n",
1971 fc_exch_done(&aborted_ep
->seq
);
1972 /* drop hold for rec qual */
1973 fc_exch_release(aborted_ep
);
1978 * fc_exch_seq_send() - Send a frame using a new exchange and sequence
1979 * @lport: The local port to send the frame on
1980 * @fp: The frame to be sent
1981 * @resp: The response handler for this request
1982 * @destructor: The destructor for the exchange
1983 * @arg: The argument to be passed to the response handler
1984 * @timer_msec: The timeout period for the exchange
1986 * The frame pointer with some of the header's fields must be
1987 * filled before calling this routine, those fields are:
1994 * - parameter or relative offset
1996 static struct fc_seq
*fc_exch_seq_send(struct fc_lport
*lport
,
1997 struct fc_frame
*fp
,
1998 void (*resp
)(struct fc_seq
*,
1999 struct fc_frame
*fp
,
2001 void (*destructor
)(struct fc_seq
*,
2003 void *arg
, u32 timer_msec
)
2006 struct fc_seq
*sp
= NULL
;
2007 struct fc_frame_header
*fh
;
2008 struct fc_fcp_pkt
*fsp
= NULL
;
2011 ep
= fc_exch_alloc(lport
, fp
);
2016 ep
->esb_stat
|= ESB_ST_SEQ_INIT
;
2017 fh
= fc_frame_header_get(fp
);
2018 fc_exch_set_addr(ep
, ntoh24(fh
->fh_s_id
), ntoh24(fh
->fh_d_id
));
2020 ep
->destructor
= destructor
;
2022 ep
->r_a_tov
= FC_DEF_R_A_TOV
;
2026 ep
->fh_type
= fh
->fh_type
; /* save for possbile timeout handling */
2027 ep
->f_ctl
= ntoh24(fh
->fh_f_ctl
);
2028 fc_exch_setup_hdr(ep
, fp
, ep
->f_ctl
);
2031 if (ep
->xid
<= lport
->lro_xid
&& fh
->fh_r_ctl
== FC_RCTL_DD_UNSOL_CMD
) {
2033 fc_fcp_ddp_setup(fr_fsp(fp
), ep
->xid
);
2036 if (unlikely(lport
->tt
.frame_send(lport
, fp
)))
2040 fc_exch_timer_set_locked(ep
, timer_msec
);
2041 ep
->f_ctl
&= ~FC_FC_FIRST_SEQ
; /* not first seq */
2043 if (ep
->f_ctl
& FC_FC_SEQ_INIT
)
2044 ep
->esb_stat
&= ~ESB_ST_SEQ_INIT
;
2045 spin_unlock_bh(&ep
->ex_lock
);
2049 fc_fcp_ddp_done(fsp
);
2050 rc
= fc_exch_done_locked(ep
);
2051 spin_unlock_bh(&ep
->ex_lock
);
2058 * fc_exch_rrq() - Send an ELS RRQ (Reinstate Recovery Qualifier) command
2059 * @ep: The exchange to send the RRQ on
2061 * This tells the remote port to stop blocking the use of
2062 * the exchange and the seq_cnt range.
2064 static void fc_exch_rrq(struct fc_exch
*ep
)
2066 struct fc_lport
*lport
;
2067 struct fc_els_rrq
*rrq
;
2068 struct fc_frame
*fp
;
2073 fp
= fc_frame_alloc(lport
, sizeof(*rrq
));
2077 rrq
= fc_frame_payload_get(fp
, sizeof(*rrq
));
2078 memset(rrq
, 0, sizeof(*rrq
));
2079 rrq
->rrq_cmd
= ELS_RRQ
;
2080 hton24(rrq
->rrq_s_id
, ep
->sid
);
2081 rrq
->rrq_ox_id
= htons(ep
->oxid
);
2082 rrq
->rrq_rx_id
= htons(ep
->rxid
);
2085 if (ep
->esb_stat
& ESB_ST_RESP
)
2088 fc_fill_fc_hdr(fp
, FC_RCTL_ELS_REQ
, did
,
2089 lport
->port_id
, FC_TYPE_ELS
,
2090 FC_FC_FIRST_SEQ
| FC_FC_END_SEQ
| FC_FC_SEQ_INIT
, 0);
2092 if (fc_exch_seq_send(lport
, fp
, fc_exch_rrq_resp
, NULL
, ep
,
2097 spin_lock_bh(&ep
->ex_lock
);
2098 if (ep
->state
& (FC_EX_RST_CLEANUP
| FC_EX_DONE
)) {
2099 spin_unlock_bh(&ep
->ex_lock
);
2100 /* drop hold for rec qual */
2101 fc_exch_release(ep
);
2104 ep
->esb_stat
|= ESB_ST_REC_QUAL
;
2105 fc_exch_timer_set_locked(ep
, ep
->r_a_tov
);
2106 spin_unlock_bh(&ep
->ex_lock
);
2110 * fc_exch_els_rrq() - Handler for ELS RRQ (Reset Recovery Qualifier) requests
2111 * @fp: The RRQ frame, not freed here.
2113 static void fc_exch_els_rrq(struct fc_frame
*fp
)
2115 struct fc_lport
*lport
;
2116 struct fc_exch
*ep
= NULL
; /* request or subject exchange */
2117 struct fc_els_rrq
*rp
;
2120 enum fc_els_rjt_explan explan
;
2123 rp
= fc_frame_payload_get(fp
, sizeof(*rp
));
2124 explan
= ELS_EXPL_INV_LEN
;
2129 * lookup subject exchange.
2131 sid
= ntoh24(rp
->rrq_s_id
); /* subject source */
2132 xid
= fc_host_port_id(lport
->host
) == sid
?
2133 ntohs(rp
->rrq_ox_id
) : ntohs(rp
->rrq_rx_id
);
2134 ep
= fc_exch_lookup(lport
, xid
);
2135 explan
= ELS_EXPL_OXID_RXID
;
2138 spin_lock_bh(&ep
->ex_lock
);
2139 if (ep
->oxid
!= ntohs(rp
->rrq_ox_id
))
2141 if (ep
->rxid
!= ntohs(rp
->rrq_rx_id
) &&
2142 ep
->rxid
!= FC_XID_UNKNOWN
)
2144 explan
= ELS_EXPL_SID
;
2149 * Clear Recovery Qualifier state, and cancel timer if complete.
2151 if (ep
->esb_stat
& ESB_ST_REC_QUAL
) {
2152 ep
->esb_stat
&= ~ESB_ST_REC_QUAL
;
2153 atomic_dec(&ep
->ex_refcnt
); /* drop hold for rec qual */
2155 if (ep
->esb_stat
& ESB_ST_COMPLETE
)
2156 fc_exch_timer_cancel(ep
);
2158 spin_unlock_bh(&ep
->ex_lock
);
2167 spin_unlock_bh(&ep
->ex_lock
);
2169 fc_seq_ls_rjt(fp
, ELS_RJT_LOGIC
, explan
);
2172 fc_exch_release(ep
); /* drop hold from fc_exch_find */
2176 * fc_exch_update_stats() - update exches stats to lport
2177 * @lport: The local port to update exchange manager stats
2179 void fc_exch_update_stats(struct fc_lport
*lport
)
2181 struct fc_host_statistics
*st
;
2182 struct fc_exch_mgr_anchor
*ema
;
2183 struct fc_exch_mgr
*mp
;
2185 st
= &lport
->host_stats
;
2187 list_for_each_entry(ema
, &lport
->ema_list
, ema_list
) {
2189 st
->fc_no_free_exch
+= atomic_read(&mp
->stats
.no_free_exch
);
2190 st
->fc_no_free_exch_xid
+=
2191 atomic_read(&mp
->stats
.no_free_exch_xid
);
2192 st
->fc_xid_not_found
+= atomic_read(&mp
->stats
.xid_not_found
);
2193 st
->fc_xid_busy
+= atomic_read(&mp
->stats
.xid_busy
);
2194 st
->fc_seq_not_found
+= atomic_read(&mp
->stats
.seq_not_found
);
2195 st
->fc_non_bls_resp
+= atomic_read(&mp
->stats
.non_bls_resp
);
2198 EXPORT_SYMBOL(fc_exch_update_stats
);
2201 * fc_exch_mgr_add() - Add an exchange manager to a local port's list of EMs
2202 * @lport: The local port to add the exchange manager to
2203 * @mp: The exchange manager to be added to the local port
2204 * @match: The match routine that indicates when this EM should be used
2206 struct fc_exch_mgr_anchor
*fc_exch_mgr_add(struct fc_lport
*lport
,
2207 struct fc_exch_mgr
*mp
,
2208 bool (*match
)(struct fc_frame
*))
2210 struct fc_exch_mgr_anchor
*ema
;
2212 ema
= kmalloc(sizeof(*ema
), GFP_ATOMIC
);
2218 /* add EM anchor to EM anchors list */
2219 list_add_tail(&ema
->ema_list
, &lport
->ema_list
);
2220 kref_get(&mp
->kref
);
2223 EXPORT_SYMBOL(fc_exch_mgr_add
);
2226 * fc_exch_mgr_destroy() - Destroy an exchange manager
2227 * @kref: The reference to the EM to be destroyed
2229 static void fc_exch_mgr_destroy(struct kref
*kref
)
2231 struct fc_exch_mgr
*mp
= container_of(kref
, struct fc_exch_mgr
, kref
);
2233 mempool_destroy(mp
->ep_pool
);
2234 free_percpu(mp
->pool
);
2239 * fc_exch_mgr_del() - Delete an EM from a local port's list
2240 * @ema: The exchange manager anchor identifying the EM to be deleted
2242 void fc_exch_mgr_del(struct fc_exch_mgr_anchor
*ema
)
2244 /* remove EM anchor from EM anchors list */
2245 list_del(&ema
->ema_list
);
2246 kref_put(&ema
->mp
->kref
, fc_exch_mgr_destroy
);
2249 EXPORT_SYMBOL(fc_exch_mgr_del
);
2252 * fc_exch_mgr_list_clone() - Share all exchange manager objects
2253 * @src: Source lport to clone exchange managers from
2254 * @dst: New lport that takes references to all the exchange managers
2256 int fc_exch_mgr_list_clone(struct fc_lport
*src
, struct fc_lport
*dst
)
2258 struct fc_exch_mgr_anchor
*ema
, *tmp
;
2260 list_for_each_entry(ema
, &src
->ema_list
, ema_list
) {
2261 if (!fc_exch_mgr_add(dst
, ema
->mp
, ema
->match
))
2266 list_for_each_entry_safe(ema
, tmp
, &dst
->ema_list
, ema_list
)
2267 fc_exch_mgr_del(ema
);
2270 EXPORT_SYMBOL(fc_exch_mgr_list_clone
);
2273 * fc_exch_mgr_alloc() - Allocate an exchange manager
2274 * @lport: The local port that the new EM will be associated with
2275 * @class: The default FC class for new exchanges
2276 * @min_xid: The minimum XID for exchanges from the new EM
2277 * @max_xid: The maximum XID for exchanges from the new EM
2278 * @match: The match routine for the new EM
2280 struct fc_exch_mgr
*fc_exch_mgr_alloc(struct fc_lport
*lport
,
2281 enum fc_class
class,
2282 u16 min_xid
, u16 max_xid
,
2283 bool (*match
)(struct fc_frame
*))
2285 struct fc_exch_mgr
*mp
;
2286 u16 pool_exch_range
;
2289 struct fc_exch_pool
*pool
;
2291 if (max_xid
<= min_xid
|| max_xid
== FC_XID_UNKNOWN
||
2292 (min_xid
& fc_cpu_mask
) != 0) {
2293 FC_LPORT_DBG(lport
, "Invalid min_xid 0x:%x and max_xid 0x:%x\n",
2299 * allocate memory for EM
2301 mp
= kzalloc(sizeof(struct fc_exch_mgr
), GFP_ATOMIC
);
2306 /* adjust em exch xid range for offload */
2307 mp
->min_xid
= min_xid
;
2309 /* reduce range so per cpu pool fits into PCPU_MIN_UNIT_SIZE pool */
2310 pool_exch_range
= (PCPU_MIN_UNIT_SIZE
- sizeof(*pool
)) /
2311 sizeof(struct fc_exch
*);
2312 if ((max_xid
- min_xid
+ 1) / (fc_cpu_mask
+ 1) > pool_exch_range
) {
2313 mp
->max_xid
= pool_exch_range
* (fc_cpu_mask
+ 1) +
2316 mp
->max_xid
= max_xid
;
2317 pool_exch_range
= (mp
->max_xid
- mp
->min_xid
+ 1) /
2321 mp
->ep_pool
= mempool_create_slab_pool(2, fc_em_cachep
);
2326 * Setup per cpu exch pool with entire exchange id range equally
2327 * divided across all cpus. The exch pointers array memory is
2328 * allocated for exch range per pool.
2330 mp
->pool_max_index
= pool_exch_range
- 1;
2333 * Allocate and initialize per cpu exch pool
2335 pool_size
= sizeof(*pool
) + pool_exch_range
* sizeof(struct fc_exch
*);
2336 mp
->pool
= __alloc_percpu(pool_size
, __alignof__(struct fc_exch_pool
));
2339 for_each_possible_cpu(cpu
) {
2340 pool
= per_cpu_ptr(mp
->pool
, cpu
);
2341 pool
->next_index
= 0;
2342 pool
->left
= FC_XID_UNKNOWN
;
2343 pool
->right
= FC_XID_UNKNOWN
;
2344 spin_lock_init(&pool
->lock
);
2345 INIT_LIST_HEAD(&pool
->ex_list
);
2348 kref_init(&mp
->kref
);
2349 if (!fc_exch_mgr_add(lport
, mp
, match
)) {
2350 free_percpu(mp
->pool
);
2355 * Above kref_init() sets mp->kref to 1 and then
2356 * call to fc_exch_mgr_add incremented mp->kref again,
2357 * so adjust that extra increment.
2359 kref_put(&mp
->kref
, fc_exch_mgr_destroy
);
2363 mempool_destroy(mp
->ep_pool
);
2368 EXPORT_SYMBOL(fc_exch_mgr_alloc
);
2371 * fc_exch_mgr_free() - Free all exchange managers on a local port
2372 * @lport: The local port whose EMs are to be freed
2374 void fc_exch_mgr_free(struct fc_lport
*lport
)
2376 struct fc_exch_mgr_anchor
*ema
, *next
;
2378 flush_workqueue(fc_exch_workqueue
);
2379 list_for_each_entry_safe(ema
, next
, &lport
->ema_list
, ema_list
)
2380 fc_exch_mgr_del(ema
);
2382 EXPORT_SYMBOL(fc_exch_mgr_free
);
2385 * fc_find_ema() - Lookup and return appropriate Exchange Manager Anchor depending
2388 * @lport: The local port the frame was received on
2389 * @fh: The received frame header
2391 static struct fc_exch_mgr_anchor
*fc_find_ema(u32 f_ctl
,
2392 struct fc_lport
*lport
,
2393 struct fc_frame_header
*fh
)
2395 struct fc_exch_mgr_anchor
*ema
;
2398 if (f_ctl
& FC_FC_EX_CTX
)
2399 xid
= ntohs(fh
->fh_ox_id
);
2401 xid
= ntohs(fh
->fh_rx_id
);
2402 if (xid
== FC_XID_UNKNOWN
)
2403 return list_entry(lport
->ema_list
.prev
,
2404 typeof(*ema
), ema_list
);
2407 list_for_each_entry(ema
, &lport
->ema_list
, ema_list
) {
2408 if ((xid
>= ema
->mp
->min_xid
) &&
2409 (xid
<= ema
->mp
->max_xid
))
2415 * fc_exch_recv() - Handler for received frames
2416 * @lport: The local port the frame was received on
2417 * @fp: The received frame
2419 void fc_exch_recv(struct fc_lport
*lport
, struct fc_frame
*fp
)
2421 struct fc_frame_header
*fh
= fc_frame_header_get(fp
);
2422 struct fc_exch_mgr_anchor
*ema
;
2426 if (!lport
|| lport
->state
== LPORT_ST_DISABLED
) {
2427 FC_LPORT_DBG(lport
, "Receiving frames for an lport that "
2428 "has not been initialized correctly\n");
2433 f_ctl
= ntoh24(fh
->fh_f_ctl
);
2434 ema
= fc_find_ema(f_ctl
, lport
, fh
);
2436 FC_LPORT_DBG(lport
, "Unable to find Exchange Manager Anchor,"
2437 "fc_ctl <0x%x>, xid <0x%x>\n",
2439 (f_ctl
& FC_FC_EX_CTX
) ?
2440 ntohs(fh
->fh_ox_id
) :
2441 ntohs(fh
->fh_rx_id
));
2447 * If frame is marked invalid, just drop it.
2449 switch (fr_eof(fp
)) {
2451 if (f_ctl
& FC_FC_END_SEQ
)
2452 skb_trim(fp_skb(fp
), fr_len(fp
) - FC_FC_FILL(f_ctl
));
2455 if (fh
->fh_type
== FC_TYPE_BLS
)
2456 fc_exch_recv_bls(ema
->mp
, fp
);
2457 else if ((f_ctl
& (FC_FC_EX_CTX
| FC_FC_SEQ_CTX
)) ==
2459 fc_exch_recv_seq_resp(ema
->mp
, fp
);
2460 else if (f_ctl
& FC_FC_SEQ_CTX
)
2461 fc_exch_recv_resp(ema
->mp
, fp
);
2462 else /* no EX_CTX and no SEQ_CTX */
2463 fc_exch_recv_req(lport
, ema
->mp
, fp
);
2466 FC_LPORT_DBG(lport
, "dropping invalid frame (eof %x)",
2471 EXPORT_SYMBOL(fc_exch_recv
);
2474 * fc_exch_init() - Initialize the exchange layer for a local port
2475 * @lport: The local port to initialize the exchange layer for
2477 int fc_exch_init(struct fc_lport
*lport
)
2479 if (!lport
->tt
.seq_start_next
)
2480 lport
->tt
.seq_start_next
= fc_seq_start_next
;
2482 if (!lport
->tt
.seq_set_resp
)
2483 lport
->tt
.seq_set_resp
= fc_seq_set_resp
;
2485 if (!lport
->tt
.exch_seq_send
)
2486 lport
->tt
.exch_seq_send
= fc_exch_seq_send
;
2488 if (!lport
->tt
.seq_send
)
2489 lport
->tt
.seq_send
= fc_seq_send
;
2491 if (!lport
->tt
.seq_els_rsp_send
)
2492 lport
->tt
.seq_els_rsp_send
= fc_seq_els_rsp_send
;
2494 if (!lport
->tt
.exch_done
)
2495 lport
->tt
.exch_done
= fc_exch_done
;
2497 if (!lport
->tt
.exch_mgr_reset
)
2498 lport
->tt
.exch_mgr_reset
= fc_exch_mgr_reset
;
2500 if (!lport
->tt
.seq_exch_abort
)
2501 lport
->tt
.seq_exch_abort
= fc_seq_exch_abort
;
2503 if (!lport
->tt
.seq_assign
)
2504 lport
->tt
.seq_assign
= fc_seq_assign
;
2506 if (!lport
->tt
.seq_release
)
2507 lport
->tt
.seq_release
= fc_seq_release
;
2511 EXPORT_SYMBOL(fc_exch_init
);
2514 * fc_setup_exch_mgr() - Setup an exchange manager
2516 int fc_setup_exch_mgr(void)
2518 fc_em_cachep
= kmem_cache_create("libfc_em", sizeof(struct fc_exch
),
2519 0, SLAB_HWCACHE_ALIGN
, NULL
);
2524 * Initialize fc_cpu_mask and fc_cpu_order. The
2525 * fc_cpu_mask is set for nr_cpu_ids rounded up
2526 * to order of 2's * power and order is stored
2527 * in fc_cpu_order as this is later required in
2528 * mapping between an exch id and exch array index
2529 * in per cpu exch pool.
2531 * This round up is required to align fc_cpu_mask
2532 * to exchange id's lower bits such that all incoming
2533 * frames of an exchange gets delivered to the same
2534 * cpu on which exchange originated by simple bitwise
2535 * AND operation between fc_cpu_mask and exchange id.
2537 fc_cpu_order
= ilog2(roundup_pow_of_two(nr_cpu_ids
));
2538 fc_cpu_mask
= (1 << fc_cpu_order
) - 1;
2540 fc_exch_workqueue
= create_singlethread_workqueue("fc_exch_workqueue");
2541 if (!fc_exch_workqueue
)
2545 kmem_cache_destroy(fc_em_cachep
);
2550 * fc_destroy_exch_mgr() - Destroy an exchange manager
2552 void fc_destroy_exch_mgr(void)
2554 destroy_workqueue(fc_exch_workqueue
);
2555 kmem_cache_destroy(fc_em_cachep
);