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 block discovers all FC-4 remote ports, including FCP initiators. It
24 * also handles RSCN events and re-discovery if necessary.
30 * The disc mutex is can be locked when acquiring rport locks, but may not
31 * be held when acquiring the lport lock. Refer to fc_lport.c for more
35 #include <linux/timer.h>
36 #include <linux/slab.h>
37 #include <linux/err.h>
38 #include <linux/export.h>
39 #include <linux/rculist.h>
41 #include <asm/unaligned.h>
43 #include <scsi/fc/fc_gs.h>
45 #include <scsi/libfc.h>
49 #define FC_DISC_RETRY_LIMIT 3 /* max retries */
50 #define FC_DISC_RETRY_DELAY 500UL /* (msecs) delay */
52 static void fc_disc_gpn_ft_req(struct fc_disc
*);
53 static void fc_disc_gpn_ft_resp(struct fc_seq
*, struct fc_frame
*, void *);
54 static void fc_disc_done(struct fc_disc
*, enum fc_disc_event
);
55 static void fc_disc_timeout(struct work_struct
*);
56 static int fc_disc_single(struct fc_lport
*, struct fc_disc_port
*);
57 static void fc_disc_restart(struct fc_disc
*);
60 * fc_disc_stop_rports() - Delete all the remote ports associated with the lport
61 * @disc: The discovery job to stop remote ports on
63 * Locking Note: This function expects that the lport mutex is locked before
66 static void fc_disc_stop_rports(struct fc_disc
*disc
)
68 struct fc_lport
*lport
;
69 struct fc_rport_priv
*rdata
;
71 lport
= fc_disc_lport(disc
);
74 list_for_each_entry_rcu(rdata
, &disc
->rports
, peers
) {
75 if (kref_get_unless_zero(&rdata
->kref
)) {
76 fc_rport_logoff(rdata
);
77 kref_put(&rdata
->kref
, fc_rport_destroy
);
84 * fc_disc_recv_rscn_req() - Handle Registered State Change Notification (RSCN)
85 * @disc: The discovery object to which the RSCN applies
88 * Locking Note: This function expects that the disc_mutex is locked
89 * before it is called.
91 static void fc_disc_recv_rscn_req(struct fc_disc
*disc
, struct fc_frame
*fp
)
93 struct fc_lport
*lport
;
94 struct fc_els_rscn
*rp
;
95 struct fc_els_rscn_page
*pp
;
96 struct fc_seq_els_data rjt_data
;
99 enum fc_els_rscn_ev_qual ev_qual
;
100 enum fc_els_rscn_addr_fmt fmt
;
101 LIST_HEAD(disc_ports
);
102 struct fc_disc_port
*dp
, *next
;
104 lport
= fc_disc_lport(disc
);
106 FC_DISC_DBG(disc
, "Received an RSCN event\n");
108 /* make sure the frame contains an RSCN message */
109 rp
= fc_frame_payload_get(fp
, sizeof(*rp
));
112 /* make sure the page length is as expected (4 bytes) */
113 if (rp
->rscn_page_len
!= sizeof(*pp
))
115 /* get the RSCN payload length */
116 len
= ntohs(rp
->rscn_plen
);
117 if (len
< sizeof(*rp
))
119 /* make sure the frame contains the expected payload */
120 rp
= fc_frame_payload_get(fp
, len
);
123 /* payload must be a multiple of the RSCN page size */
125 if (len
% sizeof(*pp
))
128 for (pp
= (void *)(rp
+ 1); len
> 0; len
-= sizeof(*pp
), pp
++) {
129 ev_qual
= pp
->rscn_page_flags
>> ELS_RSCN_EV_QUAL_BIT
;
130 ev_qual
&= ELS_RSCN_EV_QUAL_MASK
;
131 fmt
= pp
->rscn_page_flags
>> ELS_RSCN_ADDR_FMT_BIT
;
132 fmt
&= ELS_RSCN_ADDR_FMT_MASK
;
134 * if we get an address format other than port
135 * (area, domain, fabric), then do a full discovery
138 case ELS_ADDR_FMT_PORT
:
139 FC_DISC_DBG(disc
, "Port address format for port "
140 "(%6.6x)\n", ntoh24(pp
->rscn_fid
));
141 dp
= kzalloc(sizeof(*dp
), GFP_KERNEL
);
147 dp
->port_id
= ntoh24(pp
->rscn_fid
);
148 list_add_tail(&dp
->peers
, &disc_ports
);
150 case ELS_ADDR_FMT_AREA
:
151 case ELS_ADDR_FMT_DOM
:
152 case ELS_ADDR_FMT_FAB
:
154 FC_DISC_DBG(disc
, "Address format is (%d)\n", fmt
);
159 fc_seq_els_rsp_send(fp
, ELS_LS_ACC
, NULL
);
162 * If not doing a complete rediscovery, do GPN_ID on
163 * the individual ports mentioned in the list.
164 * If any of these get an error, do a full rediscovery.
165 * In any case, go through the list and free the entries.
167 list_for_each_entry_safe(dp
, next
, &disc_ports
, peers
) {
168 list_del(&dp
->peers
);
170 redisc
= fc_disc_single(lport
, dp
);
174 FC_DISC_DBG(disc
, "RSCN received: rediscovering\n");
175 fc_disc_restart(disc
);
177 FC_DISC_DBG(disc
, "RSCN received: not rediscovering. "
178 "redisc %d state %d in_prog %d\n",
179 redisc
, lport
->state
, disc
->pending
);
184 FC_DISC_DBG(disc
, "Received a bad RSCN frame\n");
185 rjt_data
.reason
= ELS_RJT_LOGIC
;
186 rjt_data
.explan
= ELS_EXPL_NONE
;
187 fc_seq_els_rsp_send(fp
, ELS_LS_RJT
, &rjt_data
);
192 * fc_disc_recv_req() - Handle incoming requests
193 * @lport: The local port receiving the request
194 * @fp: The request frame
196 * Locking Note: This function is called from the EM and will lock
197 * the disc_mutex before calling the handler for the
200 static void fc_disc_recv_req(struct fc_lport
*lport
, struct fc_frame
*fp
)
203 struct fc_disc
*disc
= &lport
->disc
;
205 op
= fc_frame_payload_op(fp
);
208 mutex_lock(&disc
->disc_mutex
);
209 fc_disc_recv_rscn_req(disc
, fp
);
210 mutex_unlock(&disc
->disc_mutex
);
213 FC_DISC_DBG(disc
, "Received an unsupported request, "
214 "the opcode is (%x)\n", op
);
221 * fc_disc_restart() - Restart discovery
222 * @disc: The discovery object to be restarted
224 * Locking Note: This function expects that the disc mutex
227 static void fc_disc_restart(struct fc_disc
*disc
)
229 if (!disc
->disc_callback
)
232 FC_DISC_DBG(disc
, "Restarting discovery\n");
239 * Advance disc_id. This is an arbitrary non-zero number that will
240 * match the value in the fc_rport_priv after discovery for all
241 * freshly-discovered remote ports. Avoid wrapping to zero.
243 disc
->disc_id
= (disc
->disc_id
+ 2) | 1;
244 disc
->retry_count
= 0;
245 fc_disc_gpn_ft_req(disc
);
249 * fc_disc_start() - Start discovery on a local port
250 * @lport: The local port to have discovery started on
251 * @disc_callback: Callback function to be called when discovery is complete
253 static void fc_disc_start(void (*disc_callback
)(struct fc_lport
*,
255 struct fc_lport
*lport
)
257 struct fc_disc
*disc
= &lport
->disc
;
260 * At this point we may have a new disc job or an existing
261 * one. Either way, let's lock when we make changes to it
262 * and send the GPN_FT request.
264 mutex_lock(&disc
->disc_mutex
);
265 disc
->disc_callback
= disc_callback
;
266 fc_disc_restart(disc
);
267 mutex_unlock(&disc
->disc_mutex
);
271 * fc_disc_done() - Discovery has been completed
272 * @disc: The discovery context
273 * @event: The discovery completion status
275 * Locking Note: This function expects that the disc mutex is locked before
276 * it is called. The discovery callback is then made with the lock released,
277 * and the lock is re-taken before returning from this function
279 static void fc_disc_done(struct fc_disc
*disc
, enum fc_disc_event event
)
281 struct fc_lport
*lport
= fc_disc_lport(disc
);
282 struct fc_rport_priv
*rdata
;
284 FC_DISC_DBG(disc
, "Discovery complete\n");
287 if (disc
->requested
) {
288 fc_disc_restart(disc
);
293 * Go through all remote ports. If they were found in the latest
294 * discovery, reverify or log them in. Otherwise, log them out.
295 * Skip ports which were never discovered. These are the dNS port
296 * and ports which were created by PLOGI.
299 list_for_each_entry_rcu(rdata
, &disc
->rports
, peers
) {
300 if (!kref_get_unless_zero(&rdata
->kref
))
302 if (rdata
->disc_id
) {
303 if (rdata
->disc_id
== disc
->disc_id
)
304 fc_rport_login(rdata
);
306 fc_rport_logoff(rdata
);
308 kref_put(&rdata
->kref
, fc_rport_destroy
);
311 mutex_unlock(&disc
->disc_mutex
);
312 disc
->disc_callback(lport
, event
);
313 mutex_lock(&disc
->disc_mutex
);
317 * fc_disc_error() - Handle error on dNS request
318 * @disc: The discovery context
319 * @fp: The error code encoded as a frame pointer
321 static void fc_disc_error(struct fc_disc
*disc
, struct fc_frame
*fp
)
323 struct fc_lport
*lport
= fc_disc_lport(disc
);
324 unsigned long delay
= 0;
326 FC_DISC_DBG(disc
, "Error %ld, retries %d/%d\n",
327 PTR_ERR(fp
), disc
->retry_count
,
328 FC_DISC_RETRY_LIMIT
);
330 if (!fp
|| PTR_ERR(fp
) == -FC_EX_TIMEOUT
) {
332 * Memory allocation failure, or the exchange timed out,
335 if (disc
->retry_count
< FC_DISC_RETRY_LIMIT
) {
336 /* go ahead and retry */
338 delay
= msecs_to_jiffies(FC_DISC_RETRY_DELAY
);
340 delay
= msecs_to_jiffies(lport
->e_d_tov
);
342 /* timeout faster first time */
343 if (!disc
->retry_count
)
347 schedule_delayed_work(&disc
->disc_work
, delay
);
349 fc_disc_done(disc
, DISC_EV_FAILED
);
350 } else if (PTR_ERR(fp
) == -FC_EX_CLOSED
) {
352 * if discovery fails due to lport reset, clear
353 * pending flag so that subsequent discovery can
361 * fc_disc_gpn_ft_req() - Send Get Port Names by FC-4 type (GPN_FT) request
362 * @lport: The discovery context
364 * Locking Note: This function expects that the disc_mutex is locked
365 * before it is called.
367 static void fc_disc_gpn_ft_req(struct fc_disc
*disc
)
370 struct fc_lport
*lport
= fc_disc_lport(disc
);
372 WARN_ON(!fc_lport_test_ready(lport
));
379 fp
= fc_frame_alloc(lport
,
380 sizeof(struct fc_ct_hdr
) +
381 sizeof(struct fc_ns_gid_ft
));
385 if (lport
->tt
.elsct_send(lport
, 0, fp
,
388 disc
, 3 * lport
->r_a_tov
))
391 fc_disc_error(disc
, NULL
);
395 * fc_disc_gpn_ft_parse() - Parse the body of the dNS GPN_FT response.
396 * @lport: The local port the GPN_FT was received on
397 * @buf: The GPN_FT response buffer
398 * @len: The size of response buffer
400 * Goes through the list of IDs and names resulting from a request.
402 static int fc_disc_gpn_ft_parse(struct fc_disc
*disc
, void *buf
, size_t len
)
404 struct fc_lport
*lport
;
405 struct fc_gpn_ft_resp
*np
;
410 struct fc_rport_identifiers ids
;
411 struct fc_rport_priv
*rdata
;
413 lport
= fc_disc_lport(disc
);
417 * Handle partial name record left over from previous call.
421 np
= (struct fc_gpn_ft_resp
*)bp
;
422 tlen
= disc
->buf_len
;
425 WARN_ON(tlen
>= sizeof(*np
));
426 plen
= sizeof(*np
) - tlen
;
428 WARN_ON(plen
>= sizeof(*np
));
431 np
= &disc
->partial_buf
;
432 memcpy((char *)np
+ tlen
, bp
, plen
);
435 * Set bp so that the loop below will advance it to the
436 * first valid full name element.
441 disc
->buf_len
= (unsigned char) plen
;
442 if (plen
== sizeof(*np
))
447 * Handle full name records, including the one filled from above.
448 * Normally, np == bp and plen == len, but from the partial case above,
449 * bp, len describe the overall buffer, and np, plen describe the
450 * partial buffer, which if would usually be full now.
451 * After the first time through the loop, things return to "normal".
453 while (plen
>= sizeof(*np
)) {
454 ids
.port_id
= ntoh24(np
->fp_fid
);
455 ids
.port_name
= ntohll(np
->fp_wwpn
);
457 if (ids
.port_id
!= lport
->port_id
&&
458 ids
.port_name
!= lport
->wwpn
) {
459 rdata
= fc_rport_create(lport
, ids
.port_id
);
461 rdata
->ids
.port_name
= ids
.port_name
;
462 rdata
->disc_id
= disc
->disc_id
;
464 printk(KERN_WARNING
"libfc: Failed to allocate "
465 "memory for the newly discovered port "
466 "(%6.6x)\n", ids
.port_id
);
471 if (np
->fp_flags
& FC_NS_FID_LAST
) {
472 fc_disc_done(disc
, DISC_EV_SUCCESS
);
478 np
= (struct fc_gpn_ft_resp
*)bp
;
483 * Save any partial record at the end of the buffer for next time.
485 if (error
== 0 && len
> 0 && len
< sizeof(*np
)) {
486 if (np
!= &disc
->partial_buf
) {
487 FC_DISC_DBG(disc
, "Partial buffer remains "
489 memcpy(&disc
->partial_buf
, np
, len
);
491 disc
->buf_len
= (unsigned char) len
;
497 * fc_disc_timeout() - Handler for discovery timeouts
498 * @work: Structure holding discovery context that needs to retry discovery
500 static void fc_disc_timeout(struct work_struct
*work
)
502 struct fc_disc
*disc
= container_of(work
,
505 mutex_lock(&disc
->disc_mutex
);
506 fc_disc_gpn_ft_req(disc
);
507 mutex_unlock(&disc
->disc_mutex
);
511 * fc_disc_gpn_ft_resp() - Handle a response frame from Get Port Names (GPN_FT)
512 * @sp: The sequence that the GPN_FT response was received on
513 * @fp: The GPN_FT response frame
514 * @lp_arg: The discovery context
516 * Locking Note: This function is called without disc mutex held, and
517 * should do all its processing with the mutex held
519 static void fc_disc_gpn_ft_resp(struct fc_seq
*sp
, struct fc_frame
*fp
,
522 struct fc_disc
*disc
= disc_arg
;
523 struct fc_ct_hdr
*cp
;
524 struct fc_frame_header
*fh
;
525 enum fc_disc_event event
= DISC_EV_NONE
;
526 unsigned int seq_cnt
;
530 mutex_lock(&disc
->disc_mutex
);
531 FC_DISC_DBG(disc
, "Received a GPN_FT response\n");
534 fc_disc_error(disc
, fp
);
535 mutex_unlock(&disc
->disc_mutex
);
539 WARN_ON(!fc_frame_is_linear(fp
)); /* buffer must be contiguous */
540 fh
= fc_frame_header_get(fp
);
541 len
= fr_len(fp
) - sizeof(*fh
);
542 seq_cnt
= ntohs(fh
->fh_seq_cnt
);
543 if (fr_sof(fp
) == FC_SOF_I3
&& seq_cnt
== 0 && disc
->seq_count
== 0) {
544 cp
= fc_frame_payload_get(fp
, sizeof(*cp
));
546 FC_DISC_DBG(disc
, "GPN_FT response too short, len %d\n",
548 event
= DISC_EV_FAILED
;
549 } else if (ntohs(cp
->ct_cmd
) == FC_FS_ACC
) {
551 /* Accepted, parse the response. */
553 error
= fc_disc_gpn_ft_parse(disc
, cp
+ 1, len
);
554 } else if (ntohs(cp
->ct_cmd
) == FC_FS_RJT
) {
555 FC_DISC_DBG(disc
, "GPN_FT rejected reason %x exp %x "
556 "(check zoning)\n", cp
->ct_reason
,
558 event
= DISC_EV_FAILED
;
559 if (cp
->ct_reason
== FC_FS_RJT_UNABL
&&
560 cp
->ct_explan
== FC_FS_EXP_FTNR
)
561 event
= DISC_EV_SUCCESS
;
563 FC_DISC_DBG(disc
, "GPN_FT unexpected response code "
564 "%x\n", ntohs(cp
->ct_cmd
));
565 event
= DISC_EV_FAILED
;
567 } else if (fr_sof(fp
) == FC_SOF_N3
&& seq_cnt
== disc
->seq_count
) {
568 error
= fc_disc_gpn_ft_parse(disc
, fh
+ 1, len
);
570 FC_DISC_DBG(disc
, "GPN_FT unexpected frame - out of sequence? "
571 "seq_cnt %x expected %x sof %x eof %x\n",
572 seq_cnt
, disc
->seq_count
, fr_sof(fp
), fr_eof(fp
));
573 event
= DISC_EV_FAILED
;
576 fc_disc_error(disc
, ERR_PTR(error
));
577 else if (event
!= DISC_EV_NONE
)
578 fc_disc_done(disc
, event
);
580 mutex_unlock(&disc
->disc_mutex
);
584 * fc_disc_gpn_id_resp() - Handle a response frame from Get Port Names (GPN_ID)
585 * @sp: The sequence the GPN_ID is on
586 * @fp: The response frame
587 * @rdata_arg: The remote port that sent the GPN_ID response
589 * Locking Note: This function is called without disc mutex held.
591 static void fc_disc_gpn_id_resp(struct fc_seq
*sp
, struct fc_frame
*fp
,
594 struct fc_rport_priv
*rdata
= rdata_arg
;
595 struct fc_rport_priv
*new_rdata
;
596 struct fc_lport
*lport
;
597 struct fc_disc
*disc
;
598 struct fc_ct_hdr
*cp
;
599 struct fc_ns_gid_pn
*pn
;
602 lport
= rdata
->local_port
;
605 if (PTR_ERR(fp
) == -FC_EX_CLOSED
)
610 cp
= fc_frame_payload_get(fp
, sizeof(*cp
));
613 if (ntohs(cp
->ct_cmd
) == FC_FS_ACC
) {
614 if (fr_len(fp
) < sizeof(struct fc_frame_header
) +
615 sizeof(*cp
) + sizeof(*pn
))
617 pn
= (struct fc_ns_gid_pn
*)(cp
+ 1);
618 port_name
= get_unaligned_be64(&pn
->fn_wwpn
);
619 mutex_lock(&rdata
->rp_mutex
);
620 if (rdata
->ids
.port_name
== -1)
621 rdata
->ids
.port_name
= port_name
;
622 else if (rdata
->ids
.port_name
!= port_name
) {
623 FC_DISC_DBG(disc
, "GPN_ID accepted. WWPN changed. "
624 "Port-id %6.6x wwpn %16.16llx\n",
625 rdata
->ids
.port_id
, port_name
);
626 mutex_unlock(&rdata
->rp_mutex
);
627 fc_rport_logoff(rdata
);
628 mutex_lock(&lport
->disc
.disc_mutex
);
629 new_rdata
= fc_rport_create(lport
, rdata
->ids
.port_id
);
630 mutex_unlock(&lport
->disc
.disc_mutex
);
632 new_rdata
->disc_id
= disc
->disc_id
;
633 fc_rport_login(new_rdata
);
637 rdata
->disc_id
= disc
->disc_id
;
638 mutex_unlock(&rdata
->rp_mutex
);
639 fc_rport_login(rdata
);
640 } else if (ntohs(cp
->ct_cmd
) == FC_FS_RJT
) {
641 FC_DISC_DBG(disc
, "GPN_ID rejected reason %x exp %x\n",
642 cp
->ct_reason
, cp
->ct_explan
);
643 fc_rport_logoff(rdata
);
645 FC_DISC_DBG(disc
, "GPN_ID unexpected response code %x\n",
648 mutex_lock(&disc
->disc_mutex
);
649 fc_disc_restart(disc
);
650 mutex_unlock(&disc
->disc_mutex
);
653 kref_put(&rdata
->kref
, fc_rport_destroy
);
657 * fc_disc_gpn_id_req() - Send Get Port Names by ID (GPN_ID) request
658 * @lport: The local port to initiate discovery on
659 * @rdata: remote port private data
661 * Locking Note: This function expects that the disc_mutex is locked
662 * before it is called.
663 * On failure, an error code is returned.
665 static int fc_disc_gpn_id_req(struct fc_lport
*lport
,
666 struct fc_rport_priv
*rdata
)
670 fp
= fc_frame_alloc(lport
, sizeof(struct fc_ct_hdr
) +
671 sizeof(struct fc_ns_fid
));
674 if (!lport
->tt
.elsct_send(lport
, rdata
->ids
.port_id
, fp
, FC_NS_GPN_ID
,
675 fc_disc_gpn_id_resp
, rdata
,
678 kref_get(&rdata
->kref
);
683 * fc_disc_single() - Discover the directory information for a single target
684 * @lport: The local port the remote port is associated with
685 * @dp: The port to rediscover
687 * Locking Note: This function expects that the disc_mutex is locked
688 * before it is called.
690 static int fc_disc_single(struct fc_lport
*lport
, struct fc_disc_port
*dp
)
692 struct fc_rport_priv
*rdata
;
694 rdata
= fc_rport_create(lport
, dp
->port_id
);
698 return fc_disc_gpn_id_req(lport
, rdata
);
702 * fc_disc_stop() - Stop discovery for a given lport
703 * @lport: The local port that discovery should stop on
705 static void fc_disc_stop(struct fc_lport
*lport
)
707 struct fc_disc
*disc
= &lport
->disc
;
710 cancel_delayed_work_sync(&disc
->disc_work
);
711 fc_disc_stop_rports(disc
);
715 * fc_disc_stop_final() - Stop discovery for a given lport
716 * @lport: The lport that discovery should stop on
718 * This function will block until discovery has been
719 * completely stopped and all rports have been deleted.
721 static void fc_disc_stop_final(struct fc_lport
*lport
)
724 fc_rport_flush_queue();
728 * fc_disc_config() - Configure the discovery layer for a local port
729 * @lport: The local port that needs the discovery layer to be configured
730 * @priv: Private data structre for users of the discovery layer
732 void fc_disc_config(struct fc_lport
*lport
, void *priv
)
734 struct fc_disc
*disc
= &lport
->disc
;
736 if (!lport
->tt
.disc_start
)
737 lport
->tt
.disc_start
= fc_disc_start
;
739 if (!lport
->tt
.disc_stop
)
740 lport
->tt
.disc_stop
= fc_disc_stop
;
742 if (!lport
->tt
.disc_stop_final
)
743 lport
->tt
.disc_stop_final
= fc_disc_stop_final
;
745 if (!lport
->tt
.disc_recv_req
)
746 lport
->tt
.disc_recv_req
= fc_disc_recv_req
;
752 EXPORT_SYMBOL(fc_disc_config
);
755 * fc_disc_init() - Initialize the discovery layer for a local port
756 * @lport: The local port that needs the discovery layer to be initialized
758 void fc_disc_init(struct fc_lport
*lport
)
760 struct fc_disc
*disc
= &lport
->disc
;
762 INIT_DELAYED_WORK(&disc
->disc_work
, fc_disc_timeout
);
763 mutex_init(&disc
->disc_mutex
);
764 INIT_LIST_HEAD(&disc
->rports
);
766 EXPORT_SYMBOL(fc_disc_init
);