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/err.h>
37 #include <asm/unaligned.h>
39 #include <scsi/fc/fc_gs.h>
41 #include <scsi/libfc.h>
43 #define FC_DISC_RETRY_LIMIT 3 /* max retries */
44 #define FC_DISC_RETRY_DELAY 500UL /* (msecs) delay */
46 #define FC_DISC_DELAY 3
48 static void fc_disc_gpn_ft_req(struct fc_disc
*);
49 static void fc_disc_gpn_ft_resp(struct fc_seq
*, struct fc_frame
*, void *);
50 static int fc_disc_new_target(struct fc_disc
*, struct fc_rport
*,
51 struct fc_rport_identifiers
*);
52 static void fc_disc_del_target(struct fc_disc
*, struct fc_rport
*);
53 static void fc_disc_done(struct fc_disc
*);
54 static void fc_disc_timeout(struct work_struct
*);
55 static void fc_disc_single(struct fc_disc
*, struct fc_disc_port
*);
56 static void fc_disc_restart(struct fc_disc
*);
59 * fc_disc_lookup_rport() - lookup a remote port by port_id
60 * @lport: Fibre Channel host port instance
61 * @port_id: remote port port_id to match
63 struct fc_rport
*fc_disc_lookup_rport(const struct fc_lport
*lport
,
66 const struct fc_disc
*disc
= &lport
->disc
;
67 struct fc_rport
*rport
, *found
= NULL
;
68 struct fc_rport_priv
*rdata
;
71 list_for_each_entry(rdata
, &disc
->rports
, peers
) {
72 rport
= PRIV_TO_RPORT(rdata
);
73 if (rport
->port_id
== port_id
) {
87 * fc_disc_stop_rports() - delete all the remote ports associated with the lport
88 * @disc: The discovery job to stop rports on
90 * Locking Note: This function expects that the lport mutex is locked before
93 void fc_disc_stop_rports(struct fc_disc
*disc
)
95 struct fc_lport
*lport
;
96 struct fc_rport
*rport
;
97 struct fc_rport_priv
*rdata
, *next
;
101 mutex_lock(&disc
->disc_mutex
);
102 list_for_each_entry_safe(rdata
, next
, &disc
->rports
, peers
) {
103 rport
= PRIV_TO_RPORT(rdata
);
104 list_del(&rdata
->peers
);
105 lport
->tt
.rport_logoff(rport
);
108 list_for_each_entry_safe(rdata
, next
, &disc
->rogue_rports
, peers
) {
109 rport
= PRIV_TO_RPORT(rdata
);
110 lport
->tt
.rport_logoff(rport
);
113 mutex_unlock(&disc
->disc_mutex
);
117 * fc_disc_rport_callback() - Event handler for rport events
118 * @lport: The lport which is receiving the event
119 * @rport: The rport which the event has occured on
120 * @event: The event that occured
122 * Locking Note: The rport lock should not be held when calling
125 static void fc_disc_rport_callback(struct fc_lport
*lport
,
126 struct fc_rport
*rport
,
127 enum fc_rport_event event
)
129 struct fc_rport_priv
*rdata
= rport
->dd_data
;
130 struct fc_disc
*disc
= &lport
->disc
;
132 FC_DISC_DBG(disc
, "Received a %d event for port (%6x)\n", event
,
136 case RPORT_EV_CREATED
:
138 mutex_lock(&disc
->disc_mutex
);
139 list_add_tail(&rdata
->peers
, &disc
->rports
);
140 mutex_unlock(&disc
->disc_mutex
);
144 case RPORT_EV_FAILED
:
146 mutex_lock(&disc
->disc_mutex
);
147 mutex_lock(&rdata
->rp_mutex
);
148 if (rdata
->trans_state
== FC_PORTSTATE_ROGUE
)
149 list_del(&rdata
->peers
);
150 mutex_unlock(&rdata
->rp_mutex
);
151 mutex_unlock(&disc
->disc_mutex
);
160 * fc_disc_recv_rscn_req() - Handle Registered State Change Notification (RSCN)
161 * @sp: Current sequence of the RSCN exchange
163 * @lport: Fibre Channel host port instance
165 * Locking Note: This function expects that the disc_mutex is locked
166 * before it is called.
168 static void fc_disc_recv_rscn_req(struct fc_seq
*sp
, struct fc_frame
*fp
,
169 struct fc_disc
*disc
)
171 struct fc_lport
*lport
;
172 struct fc_rport
*rport
;
173 struct fc_rport_priv
*rdata
;
174 struct fc_els_rscn
*rp
;
175 struct fc_els_rscn_page
*pp
;
176 struct fc_seq_els_data rjt_data
;
179 enum fc_els_rscn_ev_qual ev_qual
;
180 enum fc_els_rscn_addr_fmt fmt
;
181 LIST_HEAD(disc_ports
);
182 struct fc_disc_port
*dp
, *next
;
186 FC_DISC_DBG(disc
, "Received an RSCN event\n");
188 /* make sure the frame contains an RSCN message */
189 rp
= fc_frame_payload_get(fp
, sizeof(*rp
));
192 /* make sure the page length is as expected (4 bytes) */
193 if (rp
->rscn_page_len
!= sizeof(*pp
))
195 /* get the RSCN payload length */
196 len
= ntohs(rp
->rscn_plen
);
197 if (len
< sizeof(*rp
))
199 /* make sure the frame contains the expected payload */
200 rp
= fc_frame_payload_get(fp
, len
);
203 /* payload must be a multiple of the RSCN page size */
205 if (len
% sizeof(*pp
))
208 for (pp
= (void *)(rp
+ 1); len
> 0; len
-= sizeof(*pp
), pp
++) {
209 ev_qual
= pp
->rscn_page_flags
>> ELS_RSCN_EV_QUAL_BIT
;
210 ev_qual
&= ELS_RSCN_EV_QUAL_MASK
;
211 fmt
= pp
->rscn_page_flags
>> ELS_RSCN_ADDR_FMT_BIT
;
212 fmt
&= ELS_RSCN_ADDR_FMT_MASK
;
214 * if we get an address format other than port
215 * (area, domain, fabric), then do a full discovery
218 case ELS_ADDR_FMT_PORT
:
219 FC_DISC_DBG(disc
, "Port address format for port "
220 "(%6x)\n", ntoh24(pp
->rscn_fid
));
221 dp
= kzalloc(sizeof(*dp
), GFP_KERNEL
);
227 dp
->ids
.port_id
= ntoh24(pp
->rscn_fid
);
228 dp
->ids
.port_name
= -1;
229 dp
->ids
.node_name
= -1;
230 dp
->ids
.roles
= FC_RPORT_ROLE_UNKNOWN
;
231 list_add_tail(&dp
->peers
, &disc_ports
);
233 case ELS_ADDR_FMT_AREA
:
234 case ELS_ADDR_FMT_DOM
:
235 case ELS_ADDR_FMT_FAB
:
237 FC_DISC_DBG(disc
, "Address format is (%d)\n", fmt
);
242 lport
->tt
.seq_els_rsp_send(sp
, ELS_LS_ACC
, NULL
);
244 FC_DISC_DBG(disc
, "RSCN received: rediscovering\n");
245 fc_disc_restart(disc
);
247 FC_DISC_DBG(disc
, "RSCN received: not rediscovering. "
248 "redisc %d state %d in_prog %d\n",
249 redisc
, lport
->state
, disc
->pending
);
250 list_for_each_entry_safe(dp
, next
, &disc_ports
, peers
) {
251 list_del(&dp
->peers
);
252 rport
= lport
->tt
.rport_lookup(lport
, dp
->ids
.port_id
);
254 rdata
= rport
->dd_data
;
255 list_del(&rdata
->peers
);
256 lport
->tt
.rport_logoff(rport
);
258 fc_disc_single(disc
, dp
);
264 FC_DISC_DBG(disc
, "Received a bad RSCN frame\n");
266 rjt_data
.reason
= ELS_RJT_LOGIC
;
267 rjt_data
.explan
= ELS_EXPL_NONE
;
268 lport
->tt
.seq_els_rsp_send(sp
, ELS_LS_RJT
, &rjt_data
);
273 * fc_disc_recv_req() - Handle incoming requests
274 * @sp: Current sequence of the request exchange
276 * @lport: The FC local port
278 * Locking Note: This function is called from the EM and will lock
279 * the disc_mutex before calling the handler for the
282 static void fc_disc_recv_req(struct fc_seq
*sp
, struct fc_frame
*fp
,
283 struct fc_lport
*lport
)
286 struct fc_disc
*disc
= &lport
->disc
;
288 op
= fc_frame_payload_op(fp
);
291 mutex_lock(&disc
->disc_mutex
);
292 fc_disc_recv_rscn_req(sp
, fp
, disc
);
293 mutex_unlock(&disc
->disc_mutex
);
296 FC_DISC_DBG(disc
, "Received an unsupported request, "
297 "the opcode is (%x)\n", op
);
303 * fc_disc_restart() - Restart discovery
304 * @lport: FC discovery context
306 * Locking Note: This function expects that the disc mutex
309 static void fc_disc_restart(struct fc_disc
*disc
)
311 struct fc_rport
*rport
;
312 struct fc_rport_priv
*rdata
, *next
;
313 struct fc_lport
*lport
= disc
->lport
;
315 FC_DISC_DBG(disc
, "Restarting discovery\n");
317 list_for_each_entry_safe(rdata
, next
, &disc
->rports
, peers
) {
318 rport
= PRIV_TO_RPORT(rdata
);
319 list_del(&rdata
->peers
);
320 lport
->tt
.rport_logoff(rport
);
325 fc_disc_gpn_ft_req(disc
);
329 * fc_disc_start() - Fibre Channel Target discovery
330 * @lport: FC local port
332 * Returns non-zero if discovery cannot be started.
334 static void fc_disc_start(void (*disc_callback
)(struct fc_lport
*,
336 struct fc_lport
*lport
)
338 struct fc_rport
*rport
;
339 struct fc_rport_identifiers ids
;
340 struct fc_disc
*disc
= &lport
->disc
;
343 * At this point we may have a new disc job or an existing
344 * one. Either way, let's lock when we make changes to it
345 * and send the GPN_FT request.
347 mutex_lock(&disc
->disc_mutex
);
349 disc
->disc_callback
= disc_callback
;
352 * If not ready, or already running discovery, just set request flag.
357 mutex_unlock(&disc
->disc_mutex
);
362 * Handle point-to-point mode as a simple discovery
363 * of the remote port. Yucky, yucky, yuck, yuck!
365 rport
= disc
->lport
->ptp_rp
;
367 ids
.port_id
= rport
->port_id
;
368 ids
.port_name
= rport
->port_name
;
369 ids
.node_name
= rport
->node_name
;
370 ids
.roles
= FC_RPORT_ROLE_UNKNOWN
;
371 get_device(&rport
->dev
);
373 if (!fc_disc_new_target(disc
, rport
, &ids
)) {
374 disc
->event
= DISC_EV_SUCCESS
;
377 put_device(&rport
->dev
);
379 fc_disc_gpn_ft_req(disc
); /* get ports by FC-4 type */
382 mutex_unlock(&disc
->disc_mutex
);
385 static struct fc_rport_operations fc_disc_rport_ops
= {
386 .event_callback
= fc_disc_rport_callback
,
390 * fc_disc_new_target() - Handle new target found by discovery
391 * @lport: FC local port
392 * @rport: The previous FC remote port (NULL if new remote port)
393 * @ids: Identifiers for the new FC remote port
395 * Locking Note: This function expects that the disc_mutex is locked
396 * before it is called.
398 static int fc_disc_new_target(struct fc_disc
*disc
,
399 struct fc_rport
*rport
,
400 struct fc_rport_identifiers
*ids
)
402 struct fc_lport
*lport
= disc
->lport
;
403 struct fc_rport_priv
*rdata
;
406 if (rport
&& ids
->port_name
) {
407 if (rport
->port_name
== -1) {
409 * Set WWN and fall through to notify of create.
411 fc_rport_set_name(rport
, ids
->port_name
,
413 } else if (rport
->port_name
!= ids
->port_name
) {
415 * This is a new port with the same FCID as
416 * a previously-discovered port. Presumably the old
417 * port logged out and a new port logged in and was
418 * assigned the same FCID. This should be rare.
419 * Delete the old one and fall thru to re-create.
421 fc_disc_del_target(disc
, rport
);
425 if (((ids
->port_name
!= -1) || (ids
->port_id
!= -1)) &&
426 ids
->port_id
!= fc_host_port_id(lport
->host
) &&
427 ids
->port_name
!= lport
->wwpn
) {
429 rport
= lport
->tt
.rport_lookup(lport
, ids
->port_id
);
431 rport
= lport
->tt
.rport_create(lport
, ids
);
437 rdata
= rport
->dd_data
;
438 rdata
->ops
= &fc_disc_rport_ops
;
439 rdata
->rp_state
= RPORT_ST_INIT
;
440 list_add_tail(&rdata
->peers
, &disc
->rogue_rports
);
441 lport
->tt
.rport_login(rport
);
448 * fc_disc_del_target() - Delete a target
449 * @disc: FC discovery context
450 * @rport: The remote port to be removed
452 static void fc_disc_del_target(struct fc_disc
*disc
, struct fc_rport
*rport
)
454 struct fc_lport
*lport
= disc
->lport
;
455 struct fc_rport_priv
*rdata
= rport
->dd_data
;
456 list_del(&rdata
->peers
);
457 lport
->tt
.rport_logoff(rport
);
461 * fc_disc_done() - Discovery has been completed
462 * @disc: FC discovery context
463 * Locking Note: This function expects that the disc mutex is locked before
464 * it is called. The discovery callback is then made with the lock released,
465 * and the lock is re-taken before returning from this function
467 static void fc_disc_done(struct fc_disc
*disc
)
469 struct fc_lport
*lport
= disc
->lport
;
470 enum fc_disc_event event
;
472 FC_DISC_DBG(disc
, "Discovery complete\n");
475 disc
->event
= DISC_EV_NONE
;
478 fc_disc_gpn_ft_req(disc
);
482 mutex_unlock(&disc
->disc_mutex
);
483 disc
->disc_callback(lport
, event
);
484 mutex_lock(&disc
->disc_mutex
);
488 * fc_disc_error() - Handle error on dNS request
489 * @disc: FC discovery context
490 * @fp: The frame pointer
492 static void fc_disc_error(struct fc_disc
*disc
, struct fc_frame
*fp
)
494 struct fc_lport
*lport
= disc
->lport
;
495 unsigned long delay
= 0;
497 FC_DISC_DBG(disc
, "Error %ld, retries %d/%d\n",
498 PTR_ERR(fp
), disc
->retry_count
,
499 FC_DISC_RETRY_LIMIT
);
501 if (!fp
|| PTR_ERR(fp
) == -FC_EX_TIMEOUT
) {
503 * Memory allocation failure, or the exchange timed out,
506 if (disc
->retry_count
< FC_DISC_RETRY_LIMIT
) {
507 /* go ahead and retry */
509 delay
= msecs_to_jiffies(FC_DISC_RETRY_DELAY
);
511 delay
= msecs_to_jiffies(lport
->e_d_tov
);
513 /* timeout faster first time */
514 if (!disc
->retry_count
)
518 schedule_delayed_work(&disc
->disc_work
, delay
);
520 /* exceeded retries */
521 disc
->event
= DISC_EV_FAILED
;
528 * fc_disc_gpn_ft_req() - Send Get Port Names by FC-4 type (GPN_FT) request
529 * @lport: FC discovery context
531 * Locking Note: This function expects that the disc_mutex is locked
532 * before it is called.
534 static void fc_disc_gpn_ft_req(struct fc_disc
*disc
)
537 struct fc_lport
*lport
= disc
->lport
;
539 WARN_ON(!fc_lport_test_ready(lport
));
546 fp
= fc_frame_alloc(lport
,
547 sizeof(struct fc_ct_hdr
) +
548 sizeof(struct fc_ns_gid_ft
));
552 if (lport
->tt
.elsct_send(lport
, NULL
, fp
,
555 disc
, lport
->e_d_tov
))
558 fc_disc_error(disc
, fp
);
562 * fc_disc_gpn_ft_parse() - Parse the list of IDs and names resulting from a request
563 * @lport: Fibre Channel host port instance
564 * @buf: GPN_FT response buffer
565 * @len: size of response buffer
567 static int fc_disc_gpn_ft_parse(struct fc_disc
*disc
, void *buf
, size_t len
)
569 struct fc_lport
*lport
;
570 struct fc_gpn_ft_resp
*np
;
575 struct fc_rport_identifiers ids
;
576 struct fc_rport
*rport
;
577 struct fc_rport_priv
*rdata
;
582 * Handle partial name record left over from previous call.
586 np
= (struct fc_gpn_ft_resp
*)bp
;
587 tlen
= disc
->buf_len
;
589 WARN_ON(tlen
>= sizeof(*np
));
590 plen
= sizeof(*np
) - tlen
;
592 WARN_ON(plen
>= sizeof(*np
));
595 np
= &disc
->partial_buf
;
596 memcpy((char *)np
+ tlen
, bp
, plen
);
599 * Set bp so that the loop below will advance it to the
600 * first valid full name element.
605 disc
->buf_len
= (unsigned char) plen
;
606 if (plen
== sizeof(*np
))
611 * Handle full name records, including the one filled from above.
612 * Normally, np == bp and plen == len, but from the partial case above,
613 * bp, len describe the overall buffer, and np, plen describe the
614 * partial buffer, which if would usually be full now.
615 * After the first time through the loop, things return to "normal".
617 while (plen
>= sizeof(*np
)) {
618 ids
.port_id
= ntoh24(np
->fp_fid
);
619 ids
.port_name
= ntohll(np
->fp_wwpn
);
621 ids
.roles
= FC_RPORT_ROLE_UNKNOWN
;
623 if (ids
.port_id
!= fc_host_port_id(lport
->host
) &&
624 ids
.port_name
!= lport
->wwpn
) {
625 rport
= lport
->tt
.rport_create(lport
, &ids
);
627 rdata
= rport
->dd_data
;
628 rdata
->ops
= &fc_disc_rport_ops
;
629 rdata
->local_port
= lport
;
630 list_add_tail(&rdata
->peers
,
631 &disc
->rogue_rports
);
632 lport
->tt
.rport_login(rport
);
634 printk(KERN_WARNING
"libfc: Failed to allocate "
635 "memory for the newly discovered port "
636 "(%6x)\n", ids
.port_id
);
639 if (np
->fp_flags
& FC_NS_FID_LAST
) {
640 disc
->event
= DISC_EV_SUCCESS
;
647 np
= (struct fc_gpn_ft_resp
*)bp
;
652 * Save any partial record at the end of the buffer for next time.
654 if (error
== 0 && len
> 0 && len
< sizeof(*np
)) {
655 if (np
!= &disc
->partial_buf
) {
656 FC_DISC_DBG(disc
, "Partial buffer remains "
658 memcpy(&disc
->partial_buf
, np
, len
);
660 disc
->buf_len
= (unsigned char) len
;
668 * fc_disc_timeout() - Retry handler for the disc component
669 * @work: Structure holding disc obj that needs retry discovery
671 * Handle retry of memory allocation for remote ports.
673 static void fc_disc_timeout(struct work_struct
*work
)
675 struct fc_disc
*disc
= container_of(work
,
678 mutex_lock(&disc
->disc_mutex
);
679 if (disc
->requested
&& !disc
->pending
)
680 fc_disc_gpn_ft_req(disc
);
681 mutex_unlock(&disc
->disc_mutex
);
685 * fc_disc_gpn_ft_resp() - Handle a response frame from Get Port Names (GPN_FT)
686 * @sp: Current sequence of GPN_FT exchange
687 * @fp: response frame
688 * @lp_arg: Fibre Channel host port instance
690 * Locking Note: This function is called without disc mutex held, and
691 * should do all its processing with the mutex held
693 static void fc_disc_gpn_ft_resp(struct fc_seq
*sp
, struct fc_frame
*fp
,
696 struct fc_disc
*disc
= disc_arg
;
697 struct fc_ct_hdr
*cp
;
698 struct fc_frame_header
*fh
;
699 unsigned int seq_cnt
;
704 mutex_lock(&disc
->disc_mutex
);
705 FC_DISC_DBG(disc
, "Received a GPN_FT response\n");
708 fc_disc_error(disc
, fp
);
709 mutex_unlock(&disc
->disc_mutex
);
713 WARN_ON(!fc_frame_is_linear(fp
)); /* buffer must be contiguous */
714 fh
= fc_frame_header_get(fp
);
715 len
= fr_len(fp
) - sizeof(*fh
);
716 seq_cnt
= ntohs(fh
->fh_seq_cnt
);
717 if (fr_sof(fp
) == FC_SOF_I3
&& seq_cnt
== 0 &&
718 disc
->seq_count
== 0) {
719 cp
= fc_frame_payload_get(fp
, sizeof(*cp
));
721 FC_DISC_DBG(disc
, "GPN_FT response too short, len %d\n",
723 } else if (ntohs(cp
->ct_cmd
) == FC_FS_ACC
) {
725 /* Accepted, parse the response. */
728 } else if (ntohs(cp
->ct_cmd
) == FC_FS_RJT
) {
729 FC_DISC_DBG(disc
, "GPN_FT rejected reason %x exp %x "
730 "(check zoning)\n", cp
->ct_reason
,
732 disc
->event
= DISC_EV_FAILED
;
735 FC_DISC_DBG(disc
, "GPN_FT unexpected response code "
736 "%x\n", ntohs(cp
->ct_cmd
));
738 } else if (fr_sof(fp
) == FC_SOF_N3
&&
739 seq_cnt
== disc
->seq_count
) {
742 FC_DISC_DBG(disc
, "GPN_FT unexpected frame - out of sequence? "
743 "seq_cnt %x expected %x sof %x eof %x\n",
744 seq_cnt
, disc
->seq_count
, fr_sof(fp
), fr_eof(fp
));
747 error
= fc_disc_gpn_ft_parse(disc
, buf
, len
);
749 fc_disc_error(disc
, fp
);
755 mutex_unlock(&disc
->disc_mutex
);
759 * fc_disc_single() - Discover the directory information for a single target
760 * @lport: FC local port
761 * @dp: The port to rediscover
763 * Locking Note: This function expects that the disc_mutex is locked
764 * before it is called.
766 static void fc_disc_single(struct fc_disc
*disc
, struct fc_disc_port
*dp
)
768 struct fc_lport
*lport
;
769 struct fc_rport
*new_rport
;
770 struct fc_rport_priv
*rdata
;
774 if (dp
->ids
.port_id
== fc_host_port_id(lport
->host
))
777 new_rport
= lport
->tt
.rport_create(lport
, &dp
->ids
);
779 rdata
= new_rport
->dd_data
;
780 rdata
->ops
= &fc_disc_rport_ops
;
782 list_add_tail(&rdata
->peers
, &disc
->rogue_rports
);
783 lport
->tt
.rport_login(new_rport
);
791 * fc_disc_stop() - Stop discovery for a given lport
792 * @lport: The lport that discovery should stop for
794 void fc_disc_stop(struct fc_lport
*lport
)
796 struct fc_disc
*disc
= &lport
->disc
;
799 cancel_delayed_work_sync(&disc
->disc_work
);
800 fc_disc_stop_rports(disc
);
805 * fc_disc_stop_final() - Stop discovery for a given lport
806 * @lport: The lport that discovery should stop for
808 * This function will block until discovery has been
809 * completely stopped and all rports have been deleted.
811 void fc_disc_stop_final(struct fc_lport
*lport
)
814 lport
->tt
.rport_flush_queue();
818 * fc_disc_init() - Initialize the discovery block
819 * @lport: FC local port
821 int fc_disc_init(struct fc_lport
*lport
)
823 struct fc_disc
*disc
;
825 if (!lport
->tt
.disc_start
)
826 lport
->tt
.disc_start
= fc_disc_start
;
828 if (!lport
->tt
.disc_stop
)
829 lport
->tt
.disc_stop
= fc_disc_stop
;
831 if (!lport
->tt
.disc_stop_final
)
832 lport
->tt
.disc_stop_final
= fc_disc_stop_final
;
834 if (!lport
->tt
.disc_recv_req
)
835 lport
->tt
.disc_recv_req
= fc_disc_recv_req
;
837 if (!lport
->tt
.rport_lookup
)
838 lport
->tt
.rport_lookup
= fc_disc_lookup_rport
;
841 INIT_DELAYED_WORK(&disc
->disc_work
, fc_disc_timeout
);
842 mutex_init(&disc
->disc_mutex
);
843 INIT_LIST_HEAD(&disc
->rports
);
844 INIT_LIST_HEAD(&disc
->rogue_rports
);
847 disc
->delay
= FC_DISC_DELAY
;
848 disc
->event
= DISC_EV_NONE
;
852 EXPORT_SYMBOL(fc_disc_init
);