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 <asm/unaligned.h>
40 #include <scsi/fc/fc_gs.h>
42 #include <scsi/libfc.h>
46 #define FC_DISC_RETRY_LIMIT 3 /* max retries */
47 #define FC_DISC_RETRY_DELAY 500UL /* (msecs) delay */
49 static void fc_disc_gpn_ft_req(struct fc_disc
*);
50 static void fc_disc_gpn_ft_resp(struct fc_seq
*, struct fc_frame
*, void *);
51 static void fc_disc_done(struct fc_disc
*, enum fc_disc_event
);
52 static void fc_disc_timeout(struct work_struct
*);
53 static int fc_disc_single(struct fc_lport
*, struct fc_disc_port
*);
54 static void fc_disc_restart(struct fc_disc
*);
57 * fc_disc_stop_rports() - Delete all the remote ports associated with the lport
58 * @disc: The discovery job to stop remote ports on
60 * Locking Note: This function expects that the lport mutex is locked before
63 void fc_disc_stop_rports(struct fc_disc
*disc
)
65 struct fc_lport
*lport
;
66 struct fc_rport_priv
*rdata
;
68 lport
= fc_disc_lport(disc
);
70 mutex_lock(&disc
->disc_mutex
);
71 list_for_each_entry_rcu(rdata
, &disc
->rports
, peers
)
72 lport
->tt
.rport_logoff(rdata
);
73 mutex_unlock(&disc
->disc_mutex
);
77 * fc_disc_recv_rscn_req() - Handle Registered State Change Notification (RSCN)
78 * @disc: The discovery object to which the RSCN applies
81 * Locking Note: This function expects that the disc_mutex is locked
82 * before it is called.
84 static void fc_disc_recv_rscn_req(struct fc_disc
*disc
, struct fc_frame
*fp
)
86 struct fc_lport
*lport
;
87 struct fc_els_rscn
*rp
;
88 struct fc_els_rscn_page
*pp
;
89 struct fc_seq_els_data rjt_data
;
92 enum fc_els_rscn_ev_qual ev_qual
;
93 enum fc_els_rscn_addr_fmt fmt
;
94 LIST_HEAD(disc_ports
);
95 struct fc_disc_port
*dp
, *next
;
97 lport
= fc_disc_lport(disc
);
99 FC_DISC_DBG(disc
, "Received an RSCN event\n");
101 /* make sure the frame contains an RSCN message */
102 rp
= fc_frame_payload_get(fp
, sizeof(*rp
));
105 /* make sure the page length is as expected (4 bytes) */
106 if (rp
->rscn_page_len
!= sizeof(*pp
))
108 /* get the RSCN payload length */
109 len
= ntohs(rp
->rscn_plen
);
110 if (len
< sizeof(*rp
))
112 /* make sure the frame contains the expected payload */
113 rp
= fc_frame_payload_get(fp
, len
);
116 /* payload must be a multiple of the RSCN page size */
118 if (len
% sizeof(*pp
))
121 for (pp
= (void *)(rp
+ 1); len
> 0; len
-= sizeof(*pp
), pp
++) {
122 ev_qual
= pp
->rscn_page_flags
>> ELS_RSCN_EV_QUAL_BIT
;
123 ev_qual
&= ELS_RSCN_EV_QUAL_MASK
;
124 fmt
= pp
->rscn_page_flags
>> ELS_RSCN_ADDR_FMT_BIT
;
125 fmt
&= ELS_RSCN_ADDR_FMT_MASK
;
127 * if we get an address format other than port
128 * (area, domain, fabric), then do a full discovery
131 case ELS_ADDR_FMT_PORT
:
132 FC_DISC_DBG(disc
, "Port address format for port "
133 "(%6.6x)\n", ntoh24(pp
->rscn_fid
));
134 dp
= kzalloc(sizeof(*dp
), GFP_KERNEL
);
140 dp
->port_id
= ntoh24(pp
->rscn_fid
);
141 list_add_tail(&dp
->peers
, &disc_ports
);
143 case ELS_ADDR_FMT_AREA
:
144 case ELS_ADDR_FMT_DOM
:
145 case ELS_ADDR_FMT_FAB
:
147 FC_DISC_DBG(disc
, "Address format is (%d)\n", fmt
);
152 lport
->tt
.seq_els_rsp_send(fp
, ELS_LS_ACC
, NULL
);
155 * If not doing a complete rediscovery, do GPN_ID on
156 * the individual ports mentioned in the list.
157 * If any of these get an error, do a full rediscovery.
158 * In any case, go through the list and free the entries.
160 list_for_each_entry_safe(dp
, next
, &disc_ports
, peers
) {
161 list_del(&dp
->peers
);
163 redisc
= fc_disc_single(lport
, dp
);
167 FC_DISC_DBG(disc
, "RSCN received: rediscovering\n");
168 fc_disc_restart(disc
);
170 FC_DISC_DBG(disc
, "RSCN received: not rediscovering. "
171 "redisc %d state %d in_prog %d\n",
172 redisc
, lport
->state
, disc
->pending
);
177 FC_DISC_DBG(disc
, "Received a bad RSCN frame\n");
178 rjt_data
.reason
= ELS_RJT_LOGIC
;
179 rjt_data
.explan
= ELS_EXPL_NONE
;
180 lport
->tt
.seq_els_rsp_send(fp
, ELS_LS_RJT
, &rjt_data
);
185 * fc_disc_recv_req() - Handle incoming requests
186 * @lport: The local port receiving the request
187 * @fp: The request frame
189 * Locking Note: This function is called from the EM and will lock
190 * the disc_mutex before calling the handler for the
193 static void fc_disc_recv_req(struct fc_lport
*lport
, struct fc_frame
*fp
)
196 struct fc_disc
*disc
= &lport
->disc
;
198 op
= fc_frame_payload_op(fp
);
201 mutex_lock(&disc
->disc_mutex
);
202 fc_disc_recv_rscn_req(disc
, fp
);
203 mutex_unlock(&disc
->disc_mutex
);
206 FC_DISC_DBG(disc
, "Received an unsupported request, "
207 "the opcode is (%x)\n", op
);
213 * fc_disc_restart() - Restart discovery
214 * @disc: The discovery object to be restarted
216 * Locking Note: This function expects that the disc mutex
219 static void fc_disc_restart(struct fc_disc
*disc
)
221 if (!disc
->disc_callback
)
224 FC_DISC_DBG(disc
, "Restarting discovery\n");
231 * Advance disc_id. This is an arbitrary non-zero number that will
232 * match the value in the fc_rport_priv after discovery for all
233 * freshly-discovered remote ports. Avoid wrapping to zero.
235 disc
->disc_id
= (disc
->disc_id
+ 2) | 1;
236 disc
->retry_count
= 0;
237 fc_disc_gpn_ft_req(disc
);
241 * fc_disc_start() - Start discovery on a local port
242 * @lport: The local port to have discovery started on
243 * @disc_callback: Callback function to be called when discovery is complete
245 static void fc_disc_start(void (*disc_callback
)(struct fc_lport
*,
247 struct fc_lport
*lport
)
249 struct fc_disc
*disc
= &lport
->disc
;
252 * At this point we may have a new disc job or an existing
253 * one. Either way, let's lock when we make changes to it
254 * and send the GPN_FT request.
256 mutex_lock(&disc
->disc_mutex
);
257 disc
->disc_callback
= disc_callback
;
258 fc_disc_restart(disc
);
259 mutex_unlock(&disc
->disc_mutex
);
263 * fc_disc_done() - Discovery has been completed
264 * @disc: The discovery context
265 * @event: The discovery completion status
267 * Locking Note: This function expects that the disc mutex is locked before
268 * it is called. The discovery callback is then made with the lock released,
269 * and the lock is re-taken before returning from this function
271 static void fc_disc_done(struct fc_disc
*disc
, enum fc_disc_event event
)
273 struct fc_lport
*lport
= fc_disc_lport(disc
);
274 struct fc_rport_priv
*rdata
;
276 FC_DISC_DBG(disc
, "Discovery complete\n");
279 if (disc
->requested
) {
280 fc_disc_restart(disc
);
285 * Go through all remote ports. If they were found in the latest
286 * discovery, reverify or log them in. Otherwise, log them out.
287 * Skip ports which were never discovered. These are the dNS port
288 * and ports which were created by PLOGI.
290 list_for_each_entry_rcu(rdata
, &disc
->rports
, peers
) {
293 if (rdata
->disc_id
== disc
->disc_id
)
294 lport
->tt
.rport_login(rdata
);
296 lport
->tt
.rport_logoff(rdata
);
299 mutex_unlock(&disc
->disc_mutex
);
300 disc
->disc_callback(lport
, event
);
301 mutex_lock(&disc
->disc_mutex
);
305 * fc_disc_error() - Handle error on dNS request
306 * @disc: The discovery context
307 * @fp: The error code encoded as a frame pointer
309 static void fc_disc_error(struct fc_disc
*disc
, struct fc_frame
*fp
)
311 struct fc_lport
*lport
= fc_disc_lport(disc
);
312 unsigned long delay
= 0;
314 FC_DISC_DBG(disc
, "Error %ld, retries %d/%d\n",
315 PTR_ERR(fp
), disc
->retry_count
,
316 FC_DISC_RETRY_LIMIT
);
318 if (!fp
|| PTR_ERR(fp
) == -FC_EX_TIMEOUT
) {
320 * Memory allocation failure, or the exchange timed out,
323 if (disc
->retry_count
< FC_DISC_RETRY_LIMIT
) {
324 /* go ahead and retry */
326 delay
= msecs_to_jiffies(FC_DISC_RETRY_DELAY
);
328 delay
= msecs_to_jiffies(lport
->e_d_tov
);
330 /* timeout faster first time */
331 if (!disc
->retry_count
)
335 schedule_delayed_work(&disc
->disc_work
, delay
);
337 fc_disc_done(disc
, DISC_EV_FAILED
);
342 * fc_disc_gpn_ft_req() - Send Get Port Names by FC-4 type (GPN_FT) request
343 * @lport: The discovery context
345 * Locking Note: This function expects that the disc_mutex is locked
346 * before it is called.
348 static void fc_disc_gpn_ft_req(struct fc_disc
*disc
)
351 struct fc_lport
*lport
= fc_disc_lport(disc
);
353 WARN_ON(!fc_lport_test_ready(lport
));
360 fp
= fc_frame_alloc(lport
,
361 sizeof(struct fc_ct_hdr
) +
362 sizeof(struct fc_ns_gid_ft
));
366 if (lport
->tt
.elsct_send(lport
, 0, fp
,
369 disc
, 3 * lport
->r_a_tov
))
372 fc_disc_error(disc
, NULL
);
376 * fc_disc_gpn_ft_parse() - Parse the body of the dNS GPN_FT response.
377 * @lport: The local port the GPN_FT was received on
378 * @buf: The GPN_FT response buffer
379 * @len: The size of response buffer
381 * Goes through the list of IDs and names resulting from a request.
383 static int fc_disc_gpn_ft_parse(struct fc_disc
*disc
, void *buf
, size_t len
)
385 struct fc_lport
*lport
;
386 struct fc_gpn_ft_resp
*np
;
391 struct fc_rport_identifiers ids
;
392 struct fc_rport_priv
*rdata
;
394 lport
= fc_disc_lport(disc
);
398 * Handle partial name record left over from previous call.
402 np
= (struct fc_gpn_ft_resp
*)bp
;
403 tlen
= disc
->buf_len
;
406 WARN_ON(tlen
>= sizeof(*np
));
407 plen
= sizeof(*np
) - tlen
;
409 WARN_ON(plen
>= sizeof(*np
));
412 np
= &disc
->partial_buf
;
413 memcpy((char *)np
+ tlen
, bp
, plen
);
416 * Set bp so that the loop below will advance it to the
417 * first valid full name element.
422 disc
->buf_len
= (unsigned char) plen
;
423 if (plen
== sizeof(*np
))
428 * Handle full name records, including the one filled from above.
429 * Normally, np == bp and plen == len, but from the partial case above,
430 * bp, len describe the overall buffer, and np, plen describe the
431 * partial buffer, which if would usually be full now.
432 * After the first time through the loop, things return to "normal".
434 while (plen
>= sizeof(*np
)) {
435 ids
.port_id
= ntoh24(np
->fp_fid
);
436 ids
.port_name
= ntohll(np
->fp_wwpn
);
438 if (ids
.port_id
!= lport
->port_id
&&
439 ids
.port_name
!= lport
->wwpn
) {
440 rdata
= lport
->tt
.rport_create(lport
, ids
.port_id
);
442 rdata
->ids
.port_name
= ids
.port_name
;
443 rdata
->disc_id
= disc
->disc_id
;
445 printk(KERN_WARNING
"libfc: Failed to allocate "
446 "memory for the newly discovered port "
447 "(%6.6x)\n", ids
.port_id
);
452 if (np
->fp_flags
& FC_NS_FID_LAST
) {
453 fc_disc_done(disc
, DISC_EV_SUCCESS
);
459 np
= (struct fc_gpn_ft_resp
*)bp
;
464 * Save any partial record at the end of the buffer for next time.
466 if (error
== 0 && len
> 0 && len
< sizeof(*np
)) {
467 if (np
!= &disc
->partial_buf
) {
468 FC_DISC_DBG(disc
, "Partial buffer remains "
470 memcpy(&disc
->partial_buf
, np
, len
);
472 disc
->buf_len
= (unsigned char) len
;
478 * fc_disc_timeout() - Handler for discovery timeouts
479 * @work: Structure holding discovery context that needs to retry discovery
481 static void fc_disc_timeout(struct work_struct
*work
)
483 struct fc_disc
*disc
= container_of(work
,
486 mutex_lock(&disc
->disc_mutex
);
487 fc_disc_gpn_ft_req(disc
);
488 mutex_unlock(&disc
->disc_mutex
);
492 * fc_disc_gpn_ft_resp() - Handle a response frame from Get Port Names (GPN_FT)
493 * @sp: The sequence that the GPN_FT response was received on
494 * @fp: The GPN_FT response frame
495 * @lp_arg: The discovery context
497 * Locking Note: This function is called without disc mutex held, and
498 * should do all its processing with the mutex held
500 static void fc_disc_gpn_ft_resp(struct fc_seq
*sp
, struct fc_frame
*fp
,
503 struct fc_disc
*disc
= disc_arg
;
504 struct fc_ct_hdr
*cp
;
505 struct fc_frame_header
*fh
;
506 enum fc_disc_event event
= DISC_EV_NONE
;
507 unsigned int seq_cnt
;
511 mutex_lock(&disc
->disc_mutex
);
512 FC_DISC_DBG(disc
, "Received a GPN_FT response\n");
515 fc_disc_error(disc
, fp
);
516 mutex_unlock(&disc
->disc_mutex
);
520 WARN_ON(!fc_frame_is_linear(fp
)); /* buffer must be contiguous */
521 fh
= fc_frame_header_get(fp
);
522 len
= fr_len(fp
) - sizeof(*fh
);
523 seq_cnt
= ntohs(fh
->fh_seq_cnt
);
524 if (fr_sof(fp
) == FC_SOF_I3
&& seq_cnt
== 0 && disc
->seq_count
== 0) {
525 cp
= fc_frame_payload_get(fp
, sizeof(*cp
));
527 FC_DISC_DBG(disc
, "GPN_FT response too short, len %d\n",
529 event
= DISC_EV_FAILED
;
530 } else if (ntohs(cp
->ct_cmd
) == FC_FS_ACC
) {
532 /* Accepted, parse the response. */
534 error
= fc_disc_gpn_ft_parse(disc
, cp
+ 1, len
);
535 } else if (ntohs(cp
->ct_cmd
) == FC_FS_RJT
) {
536 FC_DISC_DBG(disc
, "GPN_FT rejected reason %x exp %x "
537 "(check zoning)\n", cp
->ct_reason
,
539 event
= DISC_EV_FAILED
;
540 if (cp
->ct_reason
== FC_FS_RJT_UNABL
&&
541 cp
->ct_explan
== FC_FS_EXP_FTNR
)
542 event
= DISC_EV_SUCCESS
;
544 FC_DISC_DBG(disc
, "GPN_FT unexpected response code "
545 "%x\n", ntohs(cp
->ct_cmd
));
546 event
= DISC_EV_FAILED
;
548 } else if (fr_sof(fp
) == FC_SOF_N3
&& seq_cnt
== disc
->seq_count
) {
549 error
= fc_disc_gpn_ft_parse(disc
, fh
+ 1, len
);
551 FC_DISC_DBG(disc
, "GPN_FT unexpected frame - out of sequence? "
552 "seq_cnt %x expected %x sof %x eof %x\n",
553 seq_cnt
, disc
->seq_count
, fr_sof(fp
), fr_eof(fp
));
554 event
= DISC_EV_FAILED
;
557 fc_disc_error(disc
, fp
);
558 else if (event
!= DISC_EV_NONE
)
559 fc_disc_done(disc
, event
);
561 mutex_unlock(&disc
->disc_mutex
);
565 * fc_disc_gpn_id_resp() - Handle a response frame from Get Port Names (GPN_ID)
566 * @sp: The sequence the GPN_ID is on
567 * @fp: The response frame
568 * @rdata_arg: The remote port that sent the GPN_ID response
570 * Locking Note: This function is called without disc mutex held.
572 static void fc_disc_gpn_id_resp(struct fc_seq
*sp
, struct fc_frame
*fp
,
575 struct fc_rport_priv
*rdata
= rdata_arg
;
576 struct fc_rport_priv
*new_rdata
;
577 struct fc_lport
*lport
;
578 struct fc_disc
*disc
;
579 struct fc_ct_hdr
*cp
;
580 struct fc_ns_gid_pn
*pn
;
583 lport
= rdata
->local_port
;
586 mutex_lock(&disc
->disc_mutex
);
587 if (PTR_ERR(fp
) == -FC_EX_CLOSED
)
592 cp
= fc_frame_payload_get(fp
, sizeof(*cp
));
595 if (ntohs(cp
->ct_cmd
) == FC_FS_ACC
) {
596 if (fr_len(fp
) < sizeof(struct fc_frame_header
) +
597 sizeof(*cp
) + sizeof(*pn
))
599 pn
= (struct fc_ns_gid_pn
*)(cp
+ 1);
600 port_name
= get_unaligned_be64(&pn
->fn_wwpn
);
601 if (rdata
->ids
.port_name
== -1)
602 rdata
->ids
.port_name
= port_name
;
603 else if (rdata
->ids
.port_name
!= port_name
) {
604 FC_DISC_DBG(disc
, "GPN_ID accepted. WWPN changed. "
605 "Port-id %6.6x wwpn %16.16llx\n",
606 rdata
->ids
.port_id
, port_name
);
607 lport
->tt
.rport_logoff(rdata
);
609 new_rdata
= lport
->tt
.rport_create(lport
,
612 new_rdata
->disc_id
= disc
->disc_id
;
613 lport
->tt
.rport_login(new_rdata
);
617 rdata
->disc_id
= disc
->disc_id
;
618 lport
->tt
.rport_login(rdata
);
619 } else if (ntohs(cp
->ct_cmd
) == FC_FS_RJT
) {
620 FC_DISC_DBG(disc
, "GPN_ID rejected reason %x exp %x\n",
621 cp
->ct_reason
, cp
->ct_explan
);
622 lport
->tt
.rport_logoff(rdata
);
624 FC_DISC_DBG(disc
, "GPN_ID unexpected response code %x\n",
627 fc_disc_restart(disc
);
630 mutex_unlock(&disc
->disc_mutex
);
631 kref_put(&rdata
->kref
, lport
->tt
.rport_destroy
);
635 * fc_disc_gpn_id_req() - Send Get Port Names by ID (GPN_ID) request
636 * @lport: The local port to initiate discovery on
637 * @rdata: remote port private data
639 * Locking Note: This function expects that the disc_mutex is locked
640 * before it is called.
641 * On failure, an error code is returned.
643 static int fc_disc_gpn_id_req(struct fc_lport
*lport
,
644 struct fc_rport_priv
*rdata
)
648 fp
= fc_frame_alloc(lport
, sizeof(struct fc_ct_hdr
) +
649 sizeof(struct fc_ns_fid
));
652 if (!lport
->tt
.elsct_send(lport
, rdata
->ids
.port_id
, fp
, FC_NS_GPN_ID
,
653 fc_disc_gpn_id_resp
, rdata
,
656 kref_get(&rdata
->kref
);
661 * fc_disc_single() - Discover the directory information for a single target
662 * @lport: The local port the remote port is associated with
663 * @dp: The port to rediscover
665 * Locking Note: This function expects that the disc_mutex is locked
666 * before it is called.
668 static int fc_disc_single(struct fc_lport
*lport
, struct fc_disc_port
*dp
)
670 struct fc_rport_priv
*rdata
;
672 rdata
= lport
->tt
.rport_create(lport
, dp
->port_id
);
676 return fc_disc_gpn_id_req(lport
, rdata
);
680 * fc_disc_stop() - Stop discovery for a given lport
681 * @lport: The local port that discovery should stop on
683 void fc_disc_stop(struct fc_lport
*lport
)
685 struct fc_disc
*disc
= &lport
->disc
;
688 cancel_delayed_work_sync(&disc
->disc_work
);
689 fc_disc_stop_rports(disc
);
694 * fc_disc_stop_final() - Stop discovery for a given lport
695 * @lport: The lport that discovery should stop on
697 * This function will block until discovery has been
698 * completely stopped and all rports have been deleted.
700 void fc_disc_stop_final(struct fc_lport
*lport
)
703 lport
->tt
.rport_flush_queue();
707 * fc_disc_init() - Initialize the discovery layer for a local port
708 * @lport: The local port that needs the discovery layer to be initialized
710 int fc_disc_init(struct fc_lport
*lport
)
712 struct fc_disc
*disc
;
714 if (!lport
->tt
.disc_start
)
715 lport
->tt
.disc_start
= fc_disc_start
;
717 if (!lport
->tt
.disc_stop
)
718 lport
->tt
.disc_stop
= fc_disc_stop
;
720 if (!lport
->tt
.disc_stop_final
)
721 lport
->tt
.disc_stop_final
= fc_disc_stop_final
;
723 if (!lport
->tt
.disc_recv_req
)
724 lport
->tt
.disc_recv_req
= fc_disc_recv_req
;
727 INIT_DELAYED_WORK(&disc
->disc_work
, fc_disc_timeout
);
728 mutex_init(&disc
->disc_mutex
);
729 INIT_LIST_HEAD(&disc
->rports
);
735 EXPORT_SYMBOL(fc_disc_init
);