2 * Copyright(c) 2007 - 2008 Intel Corporation. All rights reserved.
4 * This program is free software; you can redistribute it and/or modify it
5 * under the terms and conditions of the GNU General Public License,
6 * version 2, as published by the Free Software Foundation.
8 * This program is distributed in the hope it will be useful, but WITHOUT
9 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
10 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
13 * You should have received a copy of the GNU General Public License along with
14 * this program; if not, write to the Free Software Foundation, Inc.,
15 * 51 Franklin St - Fifth Floor, Boston, MA 02110-1301 USA.
17 * Maintained at www.Open-FCoE.org
23 * This file contains all processing regarding fc_rports. It contains the
24 * rport state machine and does all rport interaction with the transport class.
25 * There should be no other places in libfc that interact directly with the
26 * transport class in regards to adding and deleting rports.
28 * fc_rport's represent N_Port's within the fabric.
34 * The rport should never hold the rport mutex and then attempt to acquire
35 * either the lport or disc mutexes. The rport's mutex is considered lesser
36 * than both the lport's mutex and the disc mutex. Refer to fc_lport.c for
37 * more comments on the heirarchy.
39 * The locking strategy is similar to the lport's strategy. The lock protects
40 * the rport's states and is held and released by the entry points to the rport
41 * block. All _enter_* functions correspond to rport states and expect the rport
42 * mutex to be locked before calling them. This means that rports only handle
43 * one request or response at a time, since they're not critical for the I/O
44 * path this potential over-use of the mutex is acceptable.
47 #include <linux/kernel.h>
48 #include <linux/spinlock.h>
49 #include <linux/interrupt.h>
50 #include <linux/rcupdate.h>
51 #include <linux/timer.h>
52 #include <linux/workqueue.h>
53 #include <asm/unaligned.h>
55 #include <scsi/libfc.h>
56 #include <scsi/fc_encode.h>
60 struct workqueue_struct
*rport_event_queue
;
62 static void fc_rport_enter_plogi(struct fc_rport_priv
*);
63 static void fc_rport_enter_prli(struct fc_rport_priv
*);
64 static void fc_rport_enter_rtv(struct fc_rport_priv
*);
65 static void fc_rport_enter_ready(struct fc_rport_priv
*);
66 static void fc_rport_enter_logo(struct fc_rport_priv
*);
67 static void fc_rport_enter_adisc(struct fc_rport_priv
*);
69 static void fc_rport_recv_plogi_req(struct fc_lport
*,
70 struct fc_seq
*, struct fc_frame
*);
71 static void fc_rport_recv_prli_req(struct fc_rport_priv
*,
72 struct fc_seq
*, struct fc_frame
*);
73 static void fc_rport_recv_prlo_req(struct fc_rport_priv
*,
74 struct fc_seq
*, struct fc_frame
*);
75 static void fc_rport_recv_logo_req(struct fc_lport
*,
76 struct fc_seq
*, struct fc_frame
*);
77 static void fc_rport_timeout(struct work_struct
*);
78 static void fc_rport_error(struct fc_rport_priv
*, struct fc_frame
*);
79 static void fc_rport_error_retry(struct fc_rport_priv
*, struct fc_frame
*);
80 static void fc_rport_work(struct work_struct
*);
82 static const char *fc_rport_state_names
[] = {
83 [RPORT_ST_INIT
] = "Init",
84 [RPORT_ST_PLOGI
] = "PLOGI",
85 [RPORT_ST_PRLI
] = "PRLI",
86 [RPORT_ST_RTV
] = "RTV",
87 [RPORT_ST_READY
] = "Ready",
88 [RPORT_ST_LOGO
] = "LOGO",
89 [RPORT_ST_ADISC
] = "ADISC",
90 [RPORT_ST_DELETE
] = "Delete",
91 [RPORT_ST_RESTART
] = "Restart",
95 * fc_rport_lookup() - Lookup a remote port by port_id
96 * @lport: The local port to lookup the remote port on
97 * @port_id: The remote port ID to look up
99 static struct fc_rport_priv
*fc_rport_lookup(const struct fc_lport
*lport
,
102 struct fc_rport_priv
*rdata
;
104 list_for_each_entry(rdata
, &lport
->disc
.rports
, peers
)
105 if (rdata
->ids
.port_id
== port_id
)
111 * fc_rport_create() - Create a new remote port
112 * @lport: The local port this remote port will be associated with
113 * @ids: The identifiers for the new remote port
115 * The remote port will start in the INIT state.
117 * Locking note: must be called with the disc_mutex held.
119 static struct fc_rport_priv
*fc_rport_create(struct fc_lport
*lport
,
122 struct fc_rport_priv
*rdata
;
124 rdata
= lport
->tt
.rport_lookup(lport
, port_id
);
128 rdata
= kzalloc(sizeof(*rdata
), GFP_KERNEL
);
132 rdata
->ids
.node_name
= -1;
133 rdata
->ids
.port_name
= -1;
134 rdata
->ids
.port_id
= port_id
;
135 rdata
->ids
.roles
= FC_RPORT_ROLE_UNKNOWN
;
137 kref_init(&rdata
->kref
);
138 mutex_init(&rdata
->rp_mutex
);
139 rdata
->local_port
= lport
;
140 rdata
->rp_state
= RPORT_ST_INIT
;
141 rdata
->event
= RPORT_EV_NONE
;
142 rdata
->flags
= FC_RP_FLAGS_REC_SUPPORTED
;
143 rdata
->e_d_tov
= lport
->e_d_tov
;
144 rdata
->r_a_tov
= lport
->r_a_tov
;
145 rdata
->maxframe_size
= FC_MIN_MAX_PAYLOAD
;
146 INIT_DELAYED_WORK(&rdata
->retry_work
, fc_rport_timeout
);
147 INIT_WORK(&rdata
->event_work
, fc_rport_work
);
148 if (port_id
!= FC_FID_DIR_SERV
)
149 list_add(&rdata
->peers
, &lport
->disc
.rports
);
154 * fc_rport_destroy() - Free a remote port after last reference is released
155 * @kref: The remote port's kref
157 static void fc_rport_destroy(struct kref
*kref
)
159 struct fc_rport_priv
*rdata
;
161 rdata
= container_of(kref
, struct fc_rport_priv
, kref
);
166 * fc_rport_state() - Return a string identifying the remote port's state
167 * @rdata: The remote port
169 static const char *fc_rport_state(struct fc_rport_priv
*rdata
)
173 cp
= fc_rport_state_names
[rdata
->rp_state
];
180 * fc_set_rport_loss_tmo() - Set the remote port loss timeout
181 * @rport: The remote port that gets a new timeout value
182 * @timeout: The new timeout value (in seconds)
184 void fc_set_rport_loss_tmo(struct fc_rport
*rport
, u32 timeout
)
187 rport
->dev_loss_tmo
= timeout
+ 5;
189 rport
->dev_loss_tmo
= 30;
191 EXPORT_SYMBOL(fc_set_rport_loss_tmo
);
194 * fc_plogi_get_maxframe() - Get the maximum payload from the common service
195 * parameters in a FLOGI frame
196 * @flp: The FLOGI payload
197 * @maxval: The maximum frame size upper limit; this may be less than what
198 * is in the service parameters
200 static unsigned int fc_plogi_get_maxframe(struct fc_els_flogi
*flp
,
206 * Get max payload from the common service parameters and the
207 * class 3 receive data field size.
209 mfs
= ntohs(flp
->fl_csp
.sp_bb_data
) & FC_SP_BB_DATA_MASK
;
210 if (mfs
>= FC_SP_MIN_MAX_PAYLOAD
&& mfs
< maxval
)
212 mfs
= ntohs(flp
->fl_cssp
[3 - 1].cp_rdfs
);
213 if (mfs
>= FC_SP_MIN_MAX_PAYLOAD
&& mfs
< maxval
)
219 * fc_rport_state_enter() - Change the state of a remote port
220 * @rdata: The remote port whose state should change
221 * @new: The new state
223 * Locking Note: Called with the rport lock held
225 static void fc_rport_state_enter(struct fc_rport_priv
*rdata
,
226 enum fc_rport_state
new)
228 if (rdata
->rp_state
!= new)
230 rdata
->rp_state
= new;
234 * fc_rport_work() - Handler for remote port events in the rport_event_queue
235 * @work: Handle to the remote port being dequeued
237 static void fc_rport_work(struct work_struct
*work
)
240 struct fc_rport_priv
*rdata
=
241 container_of(work
, struct fc_rport_priv
, event_work
);
242 struct fc_rport_libfc_priv
*rpriv
;
243 enum fc_rport_event event
;
244 struct fc_lport
*lport
= rdata
->local_port
;
245 struct fc_rport_operations
*rport_ops
;
246 struct fc_rport_identifiers ids
;
247 struct fc_rport
*rport
;
250 mutex_lock(&rdata
->rp_mutex
);
251 event
= rdata
->event
;
252 rport_ops
= rdata
->ops
;
253 rport
= rdata
->rport
;
255 FC_RPORT_DBG(rdata
, "work event %u\n", event
);
260 rdata
->event
= RPORT_EV_NONE
;
261 kref_get(&rdata
->kref
);
262 mutex_unlock(&rdata
->rp_mutex
);
265 rport
= fc_remote_port_add(lport
->host
, 0, &ids
);
267 FC_RPORT_DBG(rdata
, "Failed to add the rport\n");
268 lport
->tt
.rport_logoff(rdata
);
269 kref_put(&rdata
->kref
, lport
->tt
.rport_destroy
);
272 mutex_lock(&rdata
->rp_mutex
);
274 FC_RPORT_DBG(rdata
, "rport already allocated\n");
275 rdata
->rport
= rport
;
276 rport
->maxframe_size
= rdata
->maxframe_size
;
277 rport
->supported_classes
= rdata
->supported_classes
;
279 rpriv
= rport
->dd_data
;
280 rpriv
->local_port
= lport
;
281 rpriv
->rp_state
= rdata
->rp_state
;
282 rpriv
->flags
= rdata
->flags
;
283 rpriv
->e_d_tov
= rdata
->e_d_tov
;
284 rpriv
->r_a_tov
= rdata
->r_a_tov
;
285 mutex_unlock(&rdata
->rp_mutex
);
287 if (rport_ops
&& rport_ops
->event_callback
) {
288 FC_RPORT_DBG(rdata
, "callback ev %d\n", event
);
289 rport_ops
->event_callback(lport
, rdata
, event
);
291 kref_put(&rdata
->kref
, lport
->tt
.rport_destroy
);
294 case RPORT_EV_FAILED
:
297 port_id
= rdata
->ids
.port_id
;
298 mutex_unlock(&rdata
->rp_mutex
);
300 if (port_id
!= FC_FID_DIR_SERV
) {
302 * We must drop rp_mutex before taking disc_mutex.
303 * Re-evaluate state to allow for restart.
304 * A transition to RESTART state must only happen
305 * while disc_mutex is held and rdata is on the list.
307 mutex_lock(&lport
->disc
.disc_mutex
);
308 mutex_lock(&rdata
->rp_mutex
);
309 if (rdata
->rp_state
== RPORT_ST_RESTART
)
312 list_del(&rdata
->peers
);
313 rdata
->event
= RPORT_EV_NONE
;
314 mutex_unlock(&rdata
->rp_mutex
);
315 mutex_unlock(&lport
->disc
.disc_mutex
);
318 if (rport_ops
&& rport_ops
->event_callback
) {
319 FC_RPORT_DBG(rdata
, "callback ev %d\n", event
);
320 rport_ops
->event_callback(lport
, rdata
, event
);
322 cancel_delayed_work_sync(&rdata
->retry_work
);
325 * Reset any outstanding exchanges before freeing rport.
327 lport
->tt
.exch_mgr_reset(lport
, 0, port_id
);
328 lport
->tt
.exch_mgr_reset(lport
, port_id
, 0);
331 rpriv
= rport
->dd_data
;
332 rpriv
->rp_state
= RPORT_ST_DELETE
;
333 mutex_lock(&rdata
->rp_mutex
);
335 mutex_unlock(&rdata
->rp_mutex
);
336 fc_remote_port_delete(rport
);
339 mutex_lock(&rdata
->rp_mutex
);
340 FC_RPORT_DBG(rdata
, "work restart\n");
341 fc_rport_enter_plogi(rdata
);
342 mutex_unlock(&rdata
->rp_mutex
);
344 kref_put(&rdata
->kref
, lport
->tt
.rport_destroy
);
348 mutex_unlock(&rdata
->rp_mutex
);
354 * fc_rport_login() - Start the remote port login state machine
355 * @rdata: The remote port to be logged in to
357 * Locking Note: Called without the rport lock held. This
358 * function will hold the rport lock, call an _enter_*
359 * function and then unlock the rport.
361 * This indicates the intent to be logged into the remote port.
362 * If it appears we are already logged in, ADISC is used to verify
365 int fc_rport_login(struct fc_rport_priv
*rdata
)
367 mutex_lock(&rdata
->rp_mutex
);
369 switch (rdata
->rp_state
) {
371 FC_RPORT_DBG(rdata
, "ADISC port\n");
372 fc_rport_enter_adisc(rdata
);
374 case RPORT_ST_RESTART
:
376 case RPORT_ST_DELETE
:
377 FC_RPORT_DBG(rdata
, "Restart deleted port\n");
378 fc_rport_state_enter(rdata
, RPORT_ST_RESTART
);
381 FC_RPORT_DBG(rdata
, "Login to port\n");
382 fc_rport_enter_plogi(rdata
);
385 mutex_unlock(&rdata
->rp_mutex
);
391 * fc_rport_enter_delete() - Schedule a remote port to be deleted
392 * @rdata: The remote port to be deleted
393 * @event: The event to report as the reason for deletion
395 * Locking Note: Called with the rport lock held.
397 * Allow state change into DELETE only once.
399 * Call queue_work only if there's no event already pending.
400 * Set the new event so that the old pending event will not occur.
401 * Since we have the mutex, even if fc_rport_work() is already started,
402 * it'll see the new event.
404 static void fc_rport_enter_delete(struct fc_rport_priv
*rdata
,
405 enum fc_rport_event event
)
407 if (rdata
->rp_state
== RPORT_ST_DELETE
)
410 FC_RPORT_DBG(rdata
, "Delete port\n");
412 fc_rport_state_enter(rdata
, RPORT_ST_DELETE
);
414 if (rdata
->event
== RPORT_EV_NONE
)
415 queue_work(rport_event_queue
, &rdata
->event_work
);
416 rdata
->event
= event
;
420 * fc_rport_logoff() - Logoff and remove a remote port
421 * @rdata: The remote port to be logged off of
423 * Locking Note: Called without the rport lock held. This
424 * function will hold the rport lock, call an _enter_*
425 * function and then unlock the rport.
427 int fc_rport_logoff(struct fc_rport_priv
*rdata
)
429 mutex_lock(&rdata
->rp_mutex
);
431 FC_RPORT_DBG(rdata
, "Remove port\n");
433 if (rdata
->rp_state
== RPORT_ST_DELETE
) {
434 FC_RPORT_DBG(rdata
, "Port in Delete state, not removing\n");
438 if (rdata
->rp_state
== RPORT_ST_RESTART
)
439 FC_RPORT_DBG(rdata
, "Port in Restart state, deleting\n");
441 fc_rport_enter_logo(rdata
);
444 * Change the state to Delete so that we discard
447 fc_rport_enter_delete(rdata
, RPORT_EV_STOP
);
449 mutex_unlock(&rdata
->rp_mutex
);
454 * fc_rport_enter_ready() - Transition to the RPORT_ST_READY state
455 * @rdata: The remote port that is ready
457 * Locking Note: The rport lock is expected to be held before calling
460 static void fc_rport_enter_ready(struct fc_rport_priv
*rdata
)
462 fc_rport_state_enter(rdata
, RPORT_ST_READY
);
464 FC_RPORT_DBG(rdata
, "Port is Ready\n");
466 if (rdata
->event
== RPORT_EV_NONE
)
467 queue_work(rport_event_queue
, &rdata
->event_work
);
468 rdata
->event
= RPORT_EV_READY
;
472 * fc_rport_timeout() - Handler for the retry_work timer
473 * @work: Handle to the remote port that has timed out
475 * Locking Note: Called without the rport lock held. This
476 * function will hold the rport lock, call an _enter_*
477 * function and then unlock the rport.
479 static void fc_rport_timeout(struct work_struct
*work
)
481 struct fc_rport_priv
*rdata
=
482 container_of(work
, struct fc_rport_priv
, retry_work
.work
);
484 mutex_lock(&rdata
->rp_mutex
);
486 switch (rdata
->rp_state
) {
488 fc_rport_enter_plogi(rdata
);
491 fc_rport_enter_prli(rdata
);
494 fc_rport_enter_rtv(rdata
);
497 fc_rport_enter_logo(rdata
);
500 fc_rport_enter_adisc(rdata
);
504 case RPORT_ST_DELETE
:
505 case RPORT_ST_RESTART
:
509 mutex_unlock(&rdata
->rp_mutex
);
513 * fc_rport_error() - Error handler, called once retries have been exhausted
514 * @rdata: The remote port the error is happened on
515 * @fp: The error code encapsulated in a frame pointer
517 * Locking Note: The rport lock is expected to be held before
518 * calling this routine
520 static void fc_rport_error(struct fc_rport_priv
*rdata
, struct fc_frame
*fp
)
522 FC_RPORT_DBG(rdata
, "Error %ld in state %s, retries %d\n",
523 IS_ERR(fp
) ? -PTR_ERR(fp
) : 0,
524 fc_rport_state(rdata
), rdata
->retries
);
526 switch (rdata
->rp_state
) {
529 fc_rport_enter_delete(rdata
, RPORT_EV_FAILED
);
532 fc_rport_enter_ready(rdata
);
536 fc_rport_enter_logo(rdata
);
538 case RPORT_ST_DELETE
:
539 case RPORT_ST_RESTART
:
547 * fc_rport_error_retry() - Handler for remote port state retries
548 * @rdata: The remote port whose state is to be retried
549 * @fp: The error code encapsulated in a frame pointer
551 * If the error was an exchange timeout retry immediately,
552 * otherwise wait for E_D_TOV.
554 * Locking Note: The rport lock is expected to be held before
555 * calling this routine
557 static void fc_rport_error_retry(struct fc_rport_priv
*rdata
,
560 unsigned long delay
= FC_DEF_E_D_TOV
;
562 /* make sure this isn't an FC_EX_CLOSED error, never retry those */
563 if (PTR_ERR(fp
) == -FC_EX_CLOSED
)
564 return fc_rport_error(rdata
, fp
);
566 if (rdata
->retries
< rdata
->local_port
->max_rport_retry_count
) {
567 FC_RPORT_DBG(rdata
, "Error %ld in state %s, retrying\n",
568 PTR_ERR(fp
), fc_rport_state(rdata
));
570 /* no additional delay on exchange timeouts */
571 if (PTR_ERR(fp
) == -FC_EX_TIMEOUT
)
573 schedule_delayed_work(&rdata
->retry_work
, delay
);
577 return fc_rport_error(rdata
, fp
);
581 * fc_rport_plogi_recv_resp() - Handler for ELS PLOGI responses
582 * @sp: The sequence the PLOGI is on
583 * @fp: The PLOGI response frame
584 * @rdata_arg: The remote port that sent the PLOGI response
586 * Locking Note: This function will be called without the rport lock
587 * held, but it will lock, call an _enter_* function or fc_rport_error
588 * and then unlock the rport.
590 static void fc_rport_plogi_resp(struct fc_seq
*sp
, struct fc_frame
*fp
,
593 struct fc_rport_priv
*rdata
= rdata_arg
;
594 struct fc_lport
*lport
= rdata
->local_port
;
595 struct fc_els_flogi
*plp
= NULL
;
601 mutex_lock(&rdata
->rp_mutex
);
603 FC_RPORT_DBG(rdata
, "Received a PLOGI %s\n", fc_els_resp_type(fp
));
605 if (rdata
->rp_state
!= RPORT_ST_PLOGI
) {
606 FC_RPORT_DBG(rdata
, "Received a PLOGI response, but in state "
607 "%s\n", fc_rport_state(rdata
));
614 fc_rport_error_retry(rdata
, fp
);
618 op
= fc_frame_payload_op(fp
);
619 if (op
== ELS_LS_ACC
&&
620 (plp
= fc_frame_payload_get(fp
, sizeof(*plp
))) != NULL
) {
621 rdata
->ids
.port_name
= get_unaligned_be64(&plp
->fl_wwpn
);
622 rdata
->ids
.node_name
= get_unaligned_be64(&plp
->fl_wwnn
);
624 tov
= ntohl(plp
->fl_csp
.sp_e_d_tov
);
625 if (ntohs(plp
->fl_csp
.sp_features
) & FC_SP_FT_EDTR
)
627 if (tov
> rdata
->e_d_tov
)
628 rdata
->e_d_tov
= tov
;
629 csp_seq
= ntohs(plp
->fl_csp
.sp_tot_seq
);
630 cssp_seq
= ntohs(plp
->fl_cssp
[3 - 1].cp_con_seq
);
631 if (cssp_seq
< csp_seq
)
633 rdata
->max_seq
= csp_seq
;
634 rdata
->maxframe_size
= fc_plogi_get_maxframe(plp
, lport
->mfs
);
635 fc_rport_enter_prli(rdata
);
637 fc_rport_error_retry(rdata
, fp
);
642 mutex_unlock(&rdata
->rp_mutex
);
643 kref_put(&rdata
->kref
, rdata
->local_port
->tt
.rport_destroy
);
647 * fc_rport_enter_plogi() - Send Port Login (PLOGI) request
648 * @rdata: The remote port to send a PLOGI to
650 * Locking Note: The rport lock is expected to be held before calling
653 static void fc_rport_enter_plogi(struct fc_rport_priv
*rdata
)
655 struct fc_lport
*lport
= rdata
->local_port
;
658 FC_RPORT_DBG(rdata
, "Port entered PLOGI state from %s state\n",
659 fc_rport_state(rdata
));
661 fc_rport_state_enter(rdata
, RPORT_ST_PLOGI
);
663 rdata
->maxframe_size
= FC_MIN_MAX_PAYLOAD
;
664 fp
= fc_frame_alloc(lport
, sizeof(struct fc_els_flogi
));
666 fc_rport_error_retry(rdata
, fp
);
669 rdata
->e_d_tov
= lport
->e_d_tov
;
671 if (!lport
->tt
.elsct_send(lport
, rdata
->ids
.port_id
, fp
, ELS_PLOGI
,
672 fc_rport_plogi_resp
, rdata
,
674 fc_rport_error_retry(rdata
, NULL
);
676 kref_get(&rdata
->kref
);
680 * fc_rport_prli_resp() - Process Login (PRLI) response handler
681 * @sp: The sequence the PRLI response was on
682 * @fp: The PRLI response frame
683 * @rdata_arg: The remote port that sent the PRLI response
685 * Locking Note: This function will be called without the rport lock
686 * held, but it will lock, call an _enter_* function or fc_rport_error
687 * and then unlock the rport.
689 static void fc_rport_prli_resp(struct fc_seq
*sp
, struct fc_frame
*fp
,
692 struct fc_rport_priv
*rdata
= rdata_arg
;
694 struct fc_els_prli prli
;
695 struct fc_els_spp spp
;
697 u32 roles
= FC_RPORT_ROLE_UNKNOWN
;
701 mutex_lock(&rdata
->rp_mutex
);
703 FC_RPORT_DBG(rdata
, "Received a PRLI %s\n", fc_els_resp_type(fp
));
705 if (rdata
->rp_state
!= RPORT_ST_PRLI
) {
706 FC_RPORT_DBG(rdata
, "Received a PRLI response, but in state "
707 "%s\n", fc_rport_state(rdata
));
714 fc_rport_error_retry(rdata
, fp
);
718 /* reinitialize remote port roles */
719 rdata
->ids
.roles
= FC_RPORT_ROLE_UNKNOWN
;
721 op
= fc_frame_payload_op(fp
);
722 if (op
== ELS_LS_ACC
) {
723 pp
= fc_frame_payload_get(fp
, sizeof(*pp
));
724 if (pp
&& pp
->prli
.prli_spp_len
>= sizeof(pp
->spp
)) {
725 fcp_parm
= ntohl(pp
->spp
.spp_params
);
726 if (fcp_parm
& FCP_SPPF_RETRY
)
727 rdata
->flags
|= FC_RP_FLAGS_RETRY
;
730 rdata
->supported_classes
= FC_COS_CLASS3
;
731 if (fcp_parm
& FCP_SPPF_INIT_FCN
)
732 roles
|= FC_RPORT_ROLE_FCP_INITIATOR
;
733 if (fcp_parm
& FCP_SPPF_TARG_FCN
)
734 roles
|= FC_RPORT_ROLE_FCP_TARGET
;
736 rdata
->ids
.roles
= roles
;
737 fc_rport_enter_rtv(rdata
);
740 FC_RPORT_DBG(rdata
, "Bad ELS response for PRLI command\n");
741 fc_rport_enter_delete(rdata
, RPORT_EV_FAILED
);
747 mutex_unlock(&rdata
->rp_mutex
);
748 kref_put(&rdata
->kref
, rdata
->local_port
->tt
.rport_destroy
);
752 * fc_rport_logo_resp() - Handler for logout (LOGO) responses
753 * @sp: The sequence the LOGO was on
754 * @fp: The LOGO response frame
755 * @rdata_arg: The remote port that sent the LOGO response
757 * Locking Note: This function will be called without the rport lock
758 * held, but it will lock, call an _enter_* function or fc_rport_error
759 * and then unlock the rport.
761 static void fc_rport_logo_resp(struct fc_seq
*sp
, struct fc_frame
*fp
,
764 struct fc_rport_priv
*rdata
= rdata_arg
;
767 mutex_lock(&rdata
->rp_mutex
);
769 FC_RPORT_DBG(rdata
, "Received a LOGO %s\n", fc_els_resp_type(fp
));
771 if (rdata
->rp_state
!= RPORT_ST_LOGO
) {
772 FC_RPORT_DBG(rdata
, "Received a LOGO response, but in state "
773 "%s\n", fc_rport_state(rdata
));
780 fc_rport_error_retry(rdata
, fp
);
784 op
= fc_frame_payload_op(fp
);
785 if (op
!= ELS_LS_ACC
)
786 FC_RPORT_DBG(rdata
, "Bad ELS response op %x for LOGO command\n",
788 fc_rport_enter_delete(rdata
, RPORT_EV_LOGO
);
793 mutex_unlock(&rdata
->rp_mutex
);
794 kref_put(&rdata
->kref
, rdata
->local_port
->tt
.rport_destroy
);
798 * fc_rport_enter_prli() - Send Process Login (PRLI) request
799 * @rdata: The remote port to send the PRLI request to
801 * Locking Note: The rport lock is expected to be held before calling
804 static void fc_rport_enter_prli(struct fc_rport_priv
*rdata
)
806 struct fc_lport
*lport
= rdata
->local_port
;
808 struct fc_els_prli prli
;
809 struct fc_els_spp spp
;
814 * If the rport is one of the well known addresses
815 * we skip PRLI and RTV and go straight to READY.
817 if (rdata
->ids
.port_id
>= FC_FID_DOM_MGR
) {
818 fc_rport_enter_ready(rdata
);
822 FC_RPORT_DBG(rdata
, "Port entered PRLI state from %s state\n",
823 fc_rport_state(rdata
));
825 fc_rport_state_enter(rdata
, RPORT_ST_PRLI
);
827 fp
= fc_frame_alloc(lport
, sizeof(*pp
));
829 fc_rport_error_retry(rdata
, fp
);
833 if (!lport
->tt
.elsct_send(lport
, rdata
->ids
.port_id
, fp
, ELS_PRLI
,
834 fc_rport_prli_resp
, rdata
,
836 fc_rport_error_retry(rdata
, NULL
);
838 kref_get(&rdata
->kref
);
842 * fc_rport_els_rtv_resp() - Handler for Request Timeout Value (RTV) responses
843 * @sp: The sequence the RTV was on
844 * @fp: The RTV response frame
845 * @rdata_arg: The remote port that sent the RTV response
847 * Many targets don't seem to support this.
849 * Locking Note: This function will be called without the rport lock
850 * held, but it will lock, call an _enter_* function or fc_rport_error
851 * and then unlock the rport.
853 static void fc_rport_rtv_resp(struct fc_seq
*sp
, struct fc_frame
*fp
,
856 struct fc_rport_priv
*rdata
= rdata_arg
;
859 mutex_lock(&rdata
->rp_mutex
);
861 FC_RPORT_DBG(rdata
, "Received a RTV %s\n", fc_els_resp_type(fp
));
863 if (rdata
->rp_state
!= RPORT_ST_RTV
) {
864 FC_RPORT_DBG(rdata
, "Received a RTV response, but in state "
865 "%s\n", fc_rport_state(rdata
));
872 fc_rport_error(rdata
, fp
);
876 op
= fc_frame_payload_op(fp
);
877 if (op
== ELS_LS_ACC
) {
878 struct fc_els_rtv_acc
*rtv
;
882 rtv
= fc_frame_payload_get(fp
, sizeof(*rtv
));
884 toq
= ntohl(rtv
->rtv_toq
);
885 tov
= ntohl(rtv
->rtv_r_a_tov
);
888 rdata
->r_a_tov
= tov
;
889 tov
= ntohl(rtv
->rtv_e_d_tov
);
890 if (toq
& FC_ELS_RTV_EDRES
)
894 rdata
->e_d_tov
= tov
;
898 fc_rport_enter_ready(rdata
);
903 mutex_unlock(&rdata
->rp_mutex
);
904 kref_put(&rdata
->kref
, rdata
->local_port
->tt
.rport_destroy
);
908 * fc_rport_enter_rtv() - Send Request Timeout Value (RTV) request
909 * @rdata: The remote port to send the RTV request to
911 * Locking Note: The rport lock is expected to be held before calling
914 static void fc_rport_enter_rtv(struct fc_rport_priv
*rdata
)
917 struct fc_lport
*lport
= rdata
->local_port
;
919 FC_RPORT_DBG(rdata
, "Port entered RTV state from %s state\n",
920 fc_rport_state(rdata
));
922 fc_rport_state_enter(rdata
, RPORT_ST_RTV
);
924 fp
= fc_frame_alloc(lport
, sizeof(struct fc_els_rtv
));
926 fc_rport_error_retry(rdata
, fp
);
930 if (!lport
->tt
.elsct_send(lport
, rdata
->ids
.port_id
, fp
, ELS_RTV
,
931 fc_rport_rtv_resp
, rdata
,
933 fc_rport_error_retry(rdata
, NULL
);
935 kref_get(&rdata
->kref
);
939 * fc_rport_enter_logo() - Send a logout (LOGO) request
940 * @rdata: The remote port to send the LOGO request to
942 * Locking Note: The rport lock is expected to be held before calling
945 static void fc_rport_enter_logo(struct fc_rport_priv
*rdata
)
947 struct fc_lport
*lport
= rdata
->local_port
;
950 FC_RPORT_DBG(rdata
, "Port entered LOGO state from %s state\n",
951 fc_rport_state(rdata
));
953 fc_rport_state_enter(rdata
, RPORT_ST_LOGO
);
955 fp
= fc_frame_alloc(lport
, sizeof(struct fc_els_logo
));
957 fc_rport_error_retry(rdata
, fp
);
961 if (!lport
->tt
.elsct_send(lport
, rdata
->ids
.port_id
, fp
, ELS_LOGO
,
962 fc_rport_logo_resp
, rdata
,
964 fc_rport_error_retry(rdata
, NULL
);
966 kref_get(&rdata
->kref
);
970 * fc_rport_els_adisc_resp() - Handler for Address Discovery (ADISC) responses
971 * @sp: The sequence the ADISC response was on
972 * @fp: The ADISC response frame
973 * @rdata_arg: The remote port that sent the ADISC response
975 * Locking Note: This function will be called without the rport lock
976 * held, but it will lock, call an _enter_* function or fc_rport_error
977 * and then unlock the rport.
979 static void fc_rport_adisc_resp(struct fc_seq
*sp
, struct fc_frame
*fp
,
982 struct fc_rport_priv
*rdata
= rdata_arg
;
983 struct fc_els_adisc
*adisc
;
986 mutex_lock(&rdata
->rp_mutex
);
988 FC_RPORT_DBG(rdata
, "Received a ADISC response\n");
990 if (rdata
->rp_state
!= RPORT_ST_ADISC
) {
991 FC_RPORT_DBG(rdata
, "Received a ADISC resp but in state %s\n",
992 fc_rport_state(rdata
));
999 fc_rport_error(rdata
, fp
);
1004 * If address verification failed. Consider us logged out of the rport.
1005 * Since the rport is still in discovery, we want to be
1006 * logged in, so go to PLOGI state. Otherwise, go back to READY.
1008 op
= fc_frame_payload_op(fp
);
1009 adisc
= fc_frame_payload_get(fp
, sizeof(*adisc
));
1010 if (op
!= ELS_LS_ACC
|| !adisc
||
1011 ntoh24(adisc
->adisc_port_id
) != rdata
->ids
.port_id
||
1012 get_unaligned_be64(&adisc
->adisc_wwpn
) != rdata
->ids
.port_name
||
1013 get_unaligned_be64(&adisc
->adisc_wwnn
) != rdata
->ids
.node_name
) {
1014 FC_RPORT_DBG(rdata
, "ADISC error or mismatch\n");
1015 fc_rport_enter_plogi(rdata
);
1017 FC_RPORT_DBG(rdata
, "ADISC OK\n");
1018 fc_rport_enter_ready(rdata
);
1023 mutex_unlock(&rdata
->rp_mutex
);
1024 kref_put(&rdata
->kref
, rdata
->local_port
->tt
.rport_destroy
);
1028 * fc_rport_enter_adisc() - Send Address Discover (ADISC) request
1029 * @rdata: The remote port to send the ADISC request to
1031 * Locking Note: The rport lock is expected to be held before calling
1034 static void fc_rport_enter_adisc(struct fc_rport_priv
*rdata
)
1036 struct fc_lport
*lport
= rdata
->local_port
;
1037 struct fc_frame
*fp
;
1039 FC_RPORT_DBG(rdata
, "sending ADISC from %s state\n",
1040 fc_rport_state(rdata
));
1042 fc_rport_state_enter(rdata
, RPORT_ST_ADISC
);
1044 fp
= fc_frame_alloc(lport
, sizeof(struct fc_els_adisc
));
1046 fc_rport_error_retry(rdata
, fp
);
1049 if (!lport
->tt
.elsct_send(lport
, rdata
->ids
.port_id
, fp
, ELS_ADISC
,
1050 fc_rport_adisc_resp
, rdata
,
1051 2 * lport
->r_a_tov
))
1052 fc_rport_error_retry(rdata
, NULL
);
1054 kref_get(&rdata
->kref
);
1058 * fc_rport_recv_adisc_req() - Handler for Address Discovery (ADISC) requests
1059 * @rdata: The remote port that sent the ADISC request
1060 * @sp: The sequence the ADISC request was on
1061 * @in_fp: The ADISC request frame
1063 * Locking Note: Called with the lport and rport locks held.
1065 static void fc_rport_recv_adisc_req(struct fc_rport_priv
*rdata
,
1066 struct fc_seq
*sp
, struct fc_frame
*in_fp
)
1068 struct fc_lport
*lport
= rdata
->local_port
;
1069 struct fc_frame
*fp
;
1070 struct fc_exch
*ep
= fc_seq_exch(sp
);
1071 struct fc_els_adisc
*adisc
;
1072 struct fc_seq_els_data rjt_data
;
1075 FC_RPORT_DBG(rdata
, "Received ADISC request\n");
1077 adisc
= fc_frame_payload_get(in_fp
, sizeof(*adisc
));
1080 rjt_data
.reason
= ELS_RJT_PROT
;
1081 rjt_data
.explan
= ELS_EXPL_INV_LEN
;
1082 lport
->tt
.seq_els_rsp_send(sp
, ELS_LS_RJT
, &rjt_data
);
1086 fp
= fc_frame_alloc(lport
, sizeof(*adisc
));
1089 fc_adisc_fill(lport
, fp
);
1090 adisc
= fc_frame_payload_get(fp
, sizeof(*adisc
));
1091 adisc
->adisc_cmd
= ELS_LS_ACC
;
1092 sp
= lport
->tt
.seq_start_next(sp
);
1093 f_ctl
= FC_FC_EX_CTX
| FC_FC_LAST_SEQ
| FC_FC_END_SEQ
| FC_FC_SEQ_INIT
;
1094 fc_fill_fc_hdr(fp
, FC_RCTL_ELS_REP
, ep
->did
, ep
->sid
,
1095 FC_TYPE_ELS
, f_ctl
, 0);
1096 lport
->tt
.seq_send(lport
, sp
, fp
);
1098 fc_frame_free(in_fp
);
1102 * fc_rport_recv_rls_req() - Handle received Read Link Status request
1103 * @rdata: The remote port that sent the RLS request
1104 * @sp: The sequence that the RLS was on
1105 * @rx_fp: The PRLI request frame
1107 * Locking Note: The rport lock is expected to be held before calling
1110 static void fc_rport_recv_rls_req(struct fc_rport_priv
*rdata
,
1111 struct fc_seq
*sp
, struct fc_frame
*rx_fp
)
1114 struct fc_lport
*lport
= rdata
->local_port
;
1115 struct fc_frame
*fp
;
1116 struct fc_exch
*ep
= fc_seq_exch(sp
);
1117 struct fc_els_rls
*rls
;
1118 struct fc_els_rls_resp
*rsp
;
1119 struct fc_els_lesb
*lesb
;
1120 struct fc_seq_els_data rjt_data
;
1121 struct fc_host_statistics
*hst
;
1124 FC_RPORT_DBG(rdata
, "Received RLS request while in state %s\n",
1125 fc_rport_state(rdata
));
1127 rls
= fc_frame_payload_get(rx_fp
, sizeof(*rls
));
1129 rjt_data
.reason
= ELS_RJT_PROT
;
1130 rjt_data
.explan
= ELS_EXPL_INV_LEN
;
1134 fp
= fc_frame_alloc(lport
, sizeof(*rsp
));
1136 rjt_data
.reason
= ELS_RJT_UNAB
;
1137 rjt_data
.explan
= ELS_EXPL_INSUF_RES
;
1141 rsp
= fc_frame_payload_get(fp
, sizeof(*rsp
));
1142 memset(rsp
, 0, sizeof(*rsp
));
1143 rsp
->rls_cmd
= ELS_LS_ACC
;
1144 lesb
= &rsp
->rls_lesb
;
1145 if (lport
->tt
.get_lesb
) {
1146 /* get LESB from LLD if it supports it */
1147 lport
->tt
.get_lesb(lport
, lesb
);
1149 fc_get_host_stats(lport
->host
);
1150 hst
= &lport
->host_stats
;
1151 lesb
->lesb_link_fail
= htonl(hst
->link_failure_count
);
1152 lesb
->lesb_sync_loss
= htonl(hst
->loss_of_sync_count
);
1153 lesb
->lesb_sig_loss
= htonl(hst
->loss_of_signal_count
);
1154 lesb
->lesb_prim_err
= htonl(hst
->prim_seq_protocol_err_count
);
1155 lesb
->lesb_inv_word
= htonl(hst
->invalid_tx_word_count
);
1156 lesb
->lesb_inv_crc
= htonl(hst
->invalid_crc_count
);
1159 sp
= lport
->tt
.seq_start_next(sp
);
1160 f_ctl
= FC_FC_EX_CTX
| FC_FC_LAST_SEQ
| FC_FC_END_SEQ
;
1161 fc_fill_fc_hdr(fp
, FC_RCTL_ELS_REP
, ep
->did
, ep
->sid
,
1162 FC_TYPE_ELS
, f_ctl
, 0);
1163 lport
->tt
.seq_send(lport
, sp
, fp
);
1168 lport
->tt
.seq_els_rsp_send(sp
, ELS_LS_RJT
, &rjt_data
);
1170 fc_frame_free(rx_fp
);
1174 * fc_rport_recv_els_req() - Handler for validated ELS requests
1175 * @lport: The local port that received the ELS request
1176 * @sp: The sequence that the ELS request was on
1177 * @fp: The ELS request frame
1179 * Handle incoming ELS requests that require port login.
1180 * The ELS opcode has already been validated by the caller.
1182 * Locking Note: Called with the lport lock held.
1184 static void fc_rport_recv_els_req(struct fc_lport
*lport
,
1185 struct fc_seq
*sp
, struct fc_frame
*fp
)
1187 struct fc_rport_priv
*rdata
;
1188 struct fc_frame_header
*fh
;
1189 struct fc_seq_els_data els_data
;
1192 els_data
.reason
= ELS_RJT_UNAB
;
1193 els_data
.explan
= ELS_EXPL_PLOGI_REQD
;
1195 fh
= fc_frame_header_get(fp
);
1197 mutex_lock(&lport
->disc
.disc_mutex
);
1198 rdata
= lport
->tt
.rport_lookup(lport
, ntoh24(fh
->fh_s_id
));
1200 mutex_unlock(&lport
->disc
.disc_mutex
);
1203 mutex_lock(&rdata
->rp_mutex
);
1204 mutex_unlock(&lport
->disc
.disc_mutex
);
1206 switch (rdata
->rp_state
) {
1209 case RPORT_ST_READY
:
1210 case RPORT_ST_ADISC
:
1213 mutex_unlock(&rdata
->rp_mutex
);
1217 switch (fc_frame_payload_op(fp
)) {
1219 fc_rport_recv_prli_req(rdata
, sp
, fp
);
1222 fc_rport_recv_prlo_req(rdata
, sp
, fp
);
1225 fc_rport_recv_adisc_req(rdata
, sp
, fp
);
1229 lport
->tt
.seq_els_rsp_send(sp
, ELS_RRQ
, &els_data
);
1233 lport
->tt
.seq_els_rsp_send(sp
, ELS_REC
, &els_data
);
1236 fc_rport_recv_rls_req(rdata
, sp
, fp
);
1239 fc_frame_free(fp
); /* can't happen */
1243 mutex_unlock(&rdata
->rp_mutex
);
1247 lport
->tt
.seq_els_rsp_send(sp
, ELS_LS_RJT
, &els_data
);
1252 * fc_rport_recv_req() - Handler for requests
1253 * @sp: The sequence the request was on
1254 * @fp: The request frame
1255 * @lport: The local port that received the request
1257 * Locking Note: Called with the lport lock held.
1259 void fc_rport_recv_req(struct fc_seq
*sp
, struct fc_frame
*fp
,
1260 struct fc_lport
*lport
)
1262 struct fc_seq_els_data els_data
;
1265 * Handle PLOGI and LOGO requests separately, since they
1266 * don't require prior login.
1267 * Check for unsupported opcodes first and reject them.
1268 * For some ops, it would be incorrect to reject with "PLOGI required".
1270 switch (fc_frame_payload_op(fp
)) {
1272 fc_rport_recv_plogi_req(lport
, sp
, fp
);
1275 fc_rport_recv_logo_req(lport
, sp
, fp
);
1283 fc_rport_recv_els_req(lport
, sp
, fp
);
1288 els_data
.reason
= ELS_RJT_UNSUP
;
1289 els_data
.explan
= ELS_EXPL_NONE
;
1290 lport
->tt
.seq_els_rsp_send(sp
, ELS_LS_RJT
, &els_data
);
1296 * fc_rport_recv_plogi_req() - Handler for Port Login (PLOGI) requests
1297 * @lport: The local port that received the PLOGI request
1298 * @sp: The sequence that the PLOGI request was on
1299 * @rx_fp: The PLOGI request frame
1301 * Locking Note: The rport lock is held before calling this function.
1303 static void fc_rport_recv_plogi_req(struct fc_lport
*lport
,
1304 struct fc_seq
*sp
, struct fc_frame
*rx_fp
)
1306 struct fc_disc
*disc
;
1307 struct fc_rport_priv
*rdata
;
1308 struct fc_frame
*fp
= rx_fp
;
1310 struct fc_frame_header
*fh
;
1311 struct fc_els_flogi
*pl
;
1312 struct fc_seq_els_data rjt_data
;
1316 fh
= fc_frame_header_get(fp
);
1317 sid
= ntoh24(fh
->fh_s_id
);
1319 FC_RPORT_ID_DBG(lport
, sid
, "Received PLOGI request\n");
1321 pl
= fc_frame_payload_get(fp
, sizeof(*pl
));
1323 FC_RPORT_ID_DBG(lport
, sid
, "Received PLOGI too short\n");
1324 rjt_data
.reason
= ELS_RJT_PROT
;
1325 rjt_data
.explan
= ELS_EXPL_INV_LEN
;
1329 disc
= &lport
->disc
;
1330 mutex_lock(&disc
->disc_mutex
);
1331 rdata
= lport
->tt
.rport_create(lport
, sid
);
1333 mutex_unlock(&disc
->disc_mutex
);
1334 rjt_data
.reason
= ELS_RJT_UNAB
;
1335 rjt_data
.explan
= ELS_EXPL_INSUF_RES
;
1339 mutex_lock(&rdata
->rp_mutex
);
1340 mutex_unlock(&disc
->disc_mutex
);
1342 rdata
->ids
.port_name
= get_unaligned_be64(&pl
->fl_wwpn
);
1343 rdata
->ids
.node_name
= get_unaligned_be64(&pl
->fl_wwnn
);
1346 * If the rport was just created, possibly due to the incoming PLOGI,
1347 * set the state appropriately and accept the PLOGI.
1349 * If we had also sent a PLOGI, and if the received PLOGI is from a
1350 * higher WWPN, we accept it, otherwise an LS_RJT is sent with reason
1351 * "command already in progress".
1353 * XXX TBD: If the session was ready before, the PLOGI should result in
1354 * all outstanding exchanges being reset.
1356 switch (rdata
->rp_state
) {
1358 FC_RPORT_DBG(rdata
, "Received PLOGI in INIT state\n");
1360 case RPORT_ST_PLOGI
:
1361 FC_RPORT_DBG(rdata
, "Received PLOGI in PLOGI state\n");
1362 if (rdata
->ids
.port_name
< lport
->wwpn
) {
1363 mutex_unlock(&rdata
->rp_mutex
);
1364 rjt_data
.reason
= ELS_RJT_INPROG
;
1365 rjt_data
.explan
= ELS_EXPL_NONE
;
1371 case RPORT_ST_READY
:
1372 case RPORT_ST_ADISC
:
1373 FC_RPORT_DBG(rdata
, "Received PLOGI in logged-in state %d "
1374 "- ignored for now\n", rdata
->rp_state
);
1375 /* XXX TBD - should reset */
1377 case RPORT_ST_DELETE
:
1379 case RPORT_ST_RESTART
:
1380 FC_RPORT_DBG(rdata
, "Received PLOGI in state %s - send busy\n",
1381 fc_rport_state(rdata
));
1382 mutex_unlock(&rdata
->rp_mutex
);
1383 rjt_data
.reason
= ELS_RJT_BUSY
;
1384 rjt_data
.explan
= ELS_EXPL_NONE
;
1389 * Get session payload size from incoming PLOGI.
1391 rdata
->maxframe_size
= fc_plogi_get_maxframe(pl
, lport
->mfs
);
1392 fc_frame_free(rx_fp
);
1395 * Send LS_ACC. If this fails, the originator should retry.
1397 sp
= lport
->tt
.seq_start_next(sp
);
1400 fp
= fc_frame_alloc(lport
, sizeof(*pl
));
1404 fc_plogi_fill(lport
, fp
, ELS_LS_ACC
);
1405 f_ctl
= FC_FC_EX_CTX
| FC_FC_LAST_SEQ
| FC_FC_END_SEQ
| FC_FC_SEQ_INIT
;
1406 ep
= fc_seq_exch(sp
);
1407 fc_fill_fc_hdr(fp
, FC_RCTL_ELS_REP
, ep
->did
, ep
->sid
,
1408 FC_TYPE_ELS
, f_ctl
, 0);
1409 lport
->tt
.seq_send(lport
, sp
, fp
);
1410 fc_rport_enter_prli(rdata
);
1412 mutex_unlock(&rdata
->rp_mutex
);
1416 lport
->tt
.seq_els_rsp_send(sp
, ELS_LS_RJT
, &rjt_data
);
1421 * fc_rport_recv_prli_req() - Handler for process login (PRLI) requests
1422 * @rdata: The remote port that sent the PRLI request
1423 * @sp: The sequence that the PRLI was on
1424 * @rx_fp: The PRLI request frame
1426 * Locking Note: The rport lock is exected to be held before calling
1429 static void fc_rport_recv_prli_req(struct fc_rport_priv
*rdata
,
1430 struct fc_seq
*sp
, struct fc_frame
*rx_fp
)
1432 struct fc_lport
*lport
= rdata
->local_port
;
1434 struct fc_frame
*fp
;
1435 struct fc_frame_header
*fh
;
1437 struct fc_els_prli prli
;
1438 struct fc_els_spp spp
;
1440 struct fc_els_spp
*rspp
; /* request service param page */
1441 struct fc_els_spp
*spp
; /* response spp */
1444 enum fc_els_rjt_reason reason
= ELS_RJT_UNAB
;
1445 enum fc_els_rjt_explan explan
= ELS_EXPL_NONE
;
1446 enum fc_els_spp_resp resp
;
1447 struct fc_seq_els_data rjt_data
;
1450 u32 roles
= FC_RPORT_ROLE_UNKNOWN
;
1453 fh
= fc_frame_header_get(rx_fp
);
1455 FC_RPORT_DBG(rdata
, "Received PRLI request while in state %s\n",
1456 fc_rport_state(rdata
));
1458 switch (rdata
->rp_state
) {
1461 case RPORT_ST_READY
:
1462 case RPORT_ST_ADISC
:
1463 reason
= ELS_RJT_NONE
;
1466 fc_frame_free(rx_fp
);
1470 len
= fr_len(rx_fp
) - sizeof(*fh
);
1471 pp
= fc_frame_payload_get(rx_fp
, sizeof(*pp
));
1473 reason
= ELS_RJT_PROT
;
1474 explan
= ELS_EXPL_INV_LEN
;
1476 plen
= ntohs(pp
->prli
.prli_len
);
1477 if ((plen
% 4) != 0 || plen
> len
) {
1478 reason
= ELS_RJT_PROT
;
1479 explan
= ELS_EXPL_INV_LEN
;
1480 } else if (plen
< len
) {
1483 plen
= pp
->prli
.prli_spp_len
;
1484 if ((plen
% 4) != 0 || plen
< sizeof(*spp
) ||
1485 plen
> len
|| len
< sizeof(*pp
)) {
1486 reason
= ELS_RJT_PROT
;
1487 explan
= ELS_EXPL_INV_LEN
;
1491 if (reason
!= ELS_RJT_NONE
||
1492 (fp
= fc_frame_alloc(lport
, len
)) == NULL
) {
1493 rjt_data
.reason
= reason
;
1494 rjt_data
.explan
= explan
;
1495 lport
->tt
.seq_els_rsp_send(sp
, ELS_LS_RJT
, &rjt_data
);
1497 sp
= lport
->tt
.seq_start_next(sp
);
1499 pp
= fc_frame_payload_get(fp
, len
);
1502 pp
->prli
.prli_cmd
= ELS_LS_ACC
;
1503 pp
->prli
.prli_spp_len
= plen
;
1504 pp
->prli
.prli_len
= htons(len
);
1505 len
-= sizeof(struct fc_els_prli
);
1507 /* reinitialize remote port roles */
1508 rdata
->ids
.roles
= FC_RPORT_ROLE_UNKNOWN
;
1511 * Go through all the service parameter pages and build
1512 * response. If plen indicates longer SPP than standard,
1513 * use that. The entire response has been pre-cleared above.
1516 while (len
>= plen
) {
1517 spp
->spp_type
= rspp
->spp_type
;
1518 spp
->spp_type_ext
= rspp
->spp_type_ext
;
1519 spp
->spp_flags
= rspp
->spp_flags
& FC_SPP_EST_IMG_PAIR
;
1520 resp
= FC_SPP_RESP_ACK
;
1521 if (rspp
->spp_flags
& FC_SPP_RPA_VAL
)
1522 resp
= FC_SPP_RESP_NO_PA
;
1523 switch (rspp
->spp_type
) {
1524 case 0: /* common to all FC-4 types */
1527 fcp_parm
= ntohl(rspp
->spp_params
);
1528 if (fcp_parm
& FCP_SPPF_RETRY
)
1529 rdata
->flags
|= FC_RP_FLAGS_RETRY
;
1530 rdata
->supported_classes
= FC_COS_CLASS3
;
1531 if (fcp_parm
& FCP_SPPF_INIT_FCN
)
1532 roles
|= FC_RPORT_ROLE_FCP_INITIATOR
;
1533 if (fcp_parm
& FCP_SPPF_TARG_FCN
)
1534 roles
|= FC_RPORT_ROLE_FCP_TARGET
;
1535 rdata
->ids
.roles
= roles
;
1538 htonl(lport
->service_params
);
1541 resp
= FC_SPP_RESP_INVL
;
1544 spp
->spp_flags
|= resp
;
1546 rspp
= (struct fc_els_spp
*)((char *)rspp
+ plen
);
1547 spp
= (struct fc_els_spp
*)((char *)spp
+ plen
);
1551 * Send LS_ACC. If this fails, the originator should retry.
1553 f_ctl
= FC_FC_EX_CTX
| FC_FC_LAST_SEQ
;
1554 f_ctl
|= FC_FC_END_SEQ
| FC_FC_SEQ_INIT
;
1555 ep
= fc_seq_exch(sp
);
1556 fc_fill_fc_hdr(fp
, FC_RCTL_ELS_REP
, ep
->did
, ep
->sid
,
1557 FC_TYPE_ELS
, f_ctl
, 0);
1558 lport
->tt
.seq_send(lport
, sp
, fp
);
1561 * Get lock and re-check state.
1563 switch (rdata
->rp_state
) {
1565 fc_rport_enter_ready(rdata
);
1567 case RPORT_ST_READY
:
1568 case RPORT_ST_ADISC
:
1574 fc_frame_free(rx_fp
);
1578 * fc_rport_recv_prlo_req() - Handler for process logout (PRLO) requests
1579 * @rdata: The remote port that sent the PRLO request
1580 * @sp: The sequence that the PRLO was on
1581 * @fp: The PRLO request frame
1583 * Locking Note: The rport lock is exected to be held before calling
1586 static void fc_rport_recv_prlo_req(struct fc_rport_priv
*rdata
,
1588 struct fc_frame
*fp
)
1590 struct fc_lport
*lport
= rdata
->local_port
;
1592 struct fc_frame_header
*fh
;
1593 struct fc_seq_els_data rjt_data
;
1595 fh
= fc_frame_header_get(fp
);
1597 FC_RPORT_DBG(rdata
, "Received PRLO request while in state %s\n",
1598 fc_rport_state(rdata
));
1601 rjt_data
.reason
= ELS_RJT_UNAB
;
1602 rjt_data
.explan
= ELS_EXPL_NONE
;
1603 lport
->tt
.seq_els_rsp_send(sp
, ELS_LS_RJT
, &rjt_data
);
1608 * fc_rport_recv_logo_req() - Handler for logout (LOGO) requests
1609 * @lport: The local port that received the LOGO request
1610 * @sp: The sequence that the LOGO request was on
1611 * @fp: The LOGO request frame
1613 * Locking Note: The rport lock is exected to be held before calling
1616 static void fc_rport_recv_logo_req(struct fc_lport
*lport
,
1618 struct fc_frame
*fp
)
1620 struct fc_frame_header
*fh
;
1621 struct fc_rport_priv
*rdata
;
1624 lport
->tt
.seq_els_rsp_send(sp
, ELS_LS_ACC
, NULL
);
1626 fh
= fc_frame_header_get(fp
);
1627 sid
= ntoh24(fh
->fh_s_id
);
1629 mutex_lock(&lport
->disc
.disc_mutex
);
1630 rdata
= lport
->tt
.rport_lookup(lport
, sid
);
1632 mutex_lock(&rdata
->rp_mutex
);
1633 FC_RPORT_DBG(rdata
, "Received LOGO request while in state %s\n",
1634 fc_rport_state(rdata
));
1636 fc_rport_enter_delete(rdata
, RPORT_EV_LOGO
);
1639 * If the remote port was created due to discovery, set state
1640 * to log back in. It may have seen a stale RSCN about us.
1643 fc_rport_state_enter(rdata
, RPORT_ST_RESTART
);
1644 mutex_unlock(&rdata
->rp_mutex
);
1646 FC_RPORT_ID_DBG(lport
, sid
,
1647 "Received LOGO from non-logged-in port\n");
1648 mutex_unlock(&lport
->disc
.disc_mutex
);
1653 * fc_rport_flush_queue() - Flush the rport_event_queue
1655 static void fc_rport_flush_queue(void)
1657 flush_workqueue(rport_event_queue
);
1661 * fc_rport_init() - Initialize the remote port layer for a local port
1662 * @lport: The local port to initialize the remote port layer for
1664 int fc_rport_init(struct fc_lport
*lport
)
1666 if (!lport
->tt
.rport_lookup
)
1667 lport
->tt
.rport_lookup
= fc_rport_lookup
;
1669 if (!lport
->tt
.rport_create
)
1670 lport
->tt
.rport_create
= fc_rport_create
;
1672 if (!lport
->tt
.rport_login
)
1673 lport
->tt
.rport_login
= fc_rport_login
;
1675 if (!lport
->tt
.rport_logoff
)
1676 lport
->tt
.rport_logoff
= fc_rport_logoff
;
1678 if (!lport
->tt
.rport_recv_req
)
1679 lport
->tt
.rport_recv_req
= fc_rport_recv_req
;
1681 if (!lport
->tt
.rport_flush_queue
)
1682 lport
->tt
.rport_flush_queue
= fc_rport_flush_queue
;
1684 if (!lport
->tt
.rport_destroy
)
1685 lport
->tt
.rport_destroy
= fc_rport_destroy
;
1689 EXPORT_SYMBOL(fc_rport_init
);
1692 * fc_setup_rport() - Initialize the rport_event_queue
1694 int fc_setup_rport()
1696 rport_event_queue
= create_singlethread_workqueue("fc_rport_eq");
1697 if (!rport_event_queue
)
1703 * fc_destroy_rport() - Destroy the rport_event_queue
1705 void fc_destroy_rport()
1707 destroy_workqueue(rport_event_queue
);
1711 * fc_rport_terminate_io() - Stop all outstanding I/O on a remote port
1712 * @rport: The remote port whose I/O should be terminated
1714 void fc_rport_terminate_io(struct fc_rport
*rport
)
1716 struct fc_rport_libfc_priv
*rpriv
= rport
->dd_data
;
1717 struct fc_lport
*lport
= rpriv
->local_port
;
1719 lport
->tt
.exch_mgr_reset(lport
, 0, rport
->port_id
);
1720 lport
->tt
.exch_mgr_reset(lport
, rport
->port_id
, 0);
1722 EXPORT_SYMBOL(fc_rport_terminate_io
);