4 * Fibre Channel related functions for the zfcp device driver.
6 * Copyright IBM Corporation 2008
9 #define KMSG_COMPONENT "zfcp"
10 #define pr_fmt(fmt) KMSG_COMPONENT ": " fmt
14 enum rscn_address_format
{
15 RSCN_PORT_ADDRESS
= 0x0,
16 RSCN_AREA_ADDRESS
= 0x1,
17 RSCN_DOMAIN_ADDRESS
= 0x2,
18 RSCN_FABRIC_ADDRESS
= 0x3,
21 static u32 rscn_range_mask
[] = {
22 [RSCN_PORT_ADDRESS
] = 0xFFFFFF,
23 [RSCN_AREA_ADDRESS
] = 0xFFFF00,
24 [RSCN_DOMAIN_ADDRESS
] = 0xFF0000,
25 [RSCN_FABRIC_ADDRESS
] = 0x000000,
28 struct ct_iu_gpn_ft_req
{
34 } __attribute__ ((packed
));
36 struct gpn_ft_resp_acc
{
41 } __attribute__ ((packed
));
43 #define ZFCP_CT_SIZE_ONE_PAGE (PAGE_SIZE - sizeof(struct ct_hdr))
44 #define ZFCP_GPN_FT_ENTRIES (ZFCP_CT_SIZE_ONE_PAGE \
45 / sizeof(struct gpn_ft_resp_acc))
46 #define ZFCP_GPN_FT_BUFFERS 4
47 #define ZFCP_GPN_FT_MAX_SIZE (ZFCP_GPN_FT_BUFFERS * PAGE_SIZE \
48 - sizeof(struct ct_hdr))
49 #define ZFCP_GPN_FT_MAX_ENTRIES ZFCP_GPN_FT_BUFFERS * (ZFCP_GPN_FT_ENTRIES + 1)
51 struct ct_iu_gpn_ft_resp
{
53 struct gpn_ft_resp_acc accept
[ZFCP_GPN_FT_ENTRIES
];
54 } __attribute__ ((packed
));
57 struct zfcp_send_ct ct
;
58 struct scatterlist sg_req
;
59 struct scatterlist sg_resp
[ZFCP_GPN_FT_BUFFERS
];
62 struct zfcp_fc_ns_handler_data
{
63 struct completion done
;
64 void (*handler
)(unsigned long);
65 unsigned long handler_data
;
68 static int zfcp_wka_port_get(struct zfcp_wka_port
*wka_port
)
70 if (mutex_lock_interruptible(&wka_port
->mutex
))
73 if (wka_port
->status
== ZFCP_WKA_PORT_OFFLINE
||
74 wka_port
->status
== ZFCP_WKA_PORT_CLOSING
) {
75 wka_port
->status
= ZFCP_WKA_PORT_OPENING
;
76 if (zfcp_fsf_open_wka_port(wka_port
))
77 wka_port
->status
= ZFCP_WKA_PORT_OFFLINE
;
80 mutex_unlock(&wka_port
->mutex
);
83 wka_port
->completion_wq
,
84 wka_port
->status
== ZFCP_WKA_PORT_ONLINE
||
85 wka_port
->status
== ZFCP_WKA_PORT_OFFLINE
,
88 if (wka_port
->status
== ZFCP_WKA_PORT_ONLINE
) {
89 atomic_inc(&wka_port
->refcount
);
95 static void zfcp_wka_port_offline(struct work_struct
*work
)
97 struct delayed_work
*dw
= container_of(work
, struct delayed_work
, work
);
98 struct zfcp_wka_port
*wka_port
=
99 container_of(dw
, struct zfcp_wka_port
, work
);
101 wait_event(wka_port
->completion_wq
,
102 atomic_read(&wka_port
->refcount
) == 0);
104 mutex_lock(&wka_port
->mutex
);
105 if ((atomic_read(&wka_port
->refcount
) != 0) ||
106 (wka_port
->status
!= ZFCP_WKA_PORT_ONLINE
))
109 wka_port
->status
= ZFCP_WKA_PORT_CLOSING
;
110 if (zfcp_fsf_close_wka_port(wka_port
)) {
111 wka_port
->status
= ZFCP_WKA_PORT_OFFLINE
;
112 wake_up(&wka_port
->completion_wq
);
115 mutex_unlock(&wka_port
->mutex
);
118 static void zfcp_wka_port_put(struct zfcp_wka_port
*wka_port
)
120 if (atomic_dec_return(&wka_port
->refcount
) != 0)
122 /* wait 10 miliseconds, other reqs might pop in */
123 schedule_delayed_work(&wka_port
->work
, HZ
/ 100);
126 void zfcp_fc_nameserver_init(struct zfcp_adapter
*adapter
)
128 struct zfcp_wka_port
*wka_port
= &adapter
->nsp
;
130 init_waitqueue_head(&wka_port
->completion_wq
);
132 wka_port
->adapter
= adapter
;
133 wka_port
->d_id
= ZFCP_DID_DIRECTORY_SERVICE
;
135 wka_port
->status
= ZFCP_WKA_PORT_OFFLINE
;
136 atomic_set(&wka_port
->refcount
, 0);
137 mutex_init(&wka_port
->mutex
);
138 INIT_DELAYED_WORK(&wka_port
->work
, zfcp_wka_port_offline
);
141 static void _zfcp_fc_incoming_rscn(struct zfcp_fsf_req
*fsf_req
, u32 range
,
142 struct fcp_rscn_element
*elem
)
145 struct zfcp_port
*port
;
147 read_lock_irqsave(&zfcp_data
.config_lock
, flags
);
148 list_for_each_entry(port
, &fsf_req
->adapter
->port_list_head
, list
) {
149 if (!(atomic_read(&port
->status
) & ZFCP_STATUS_PORT_PHYS_OPEN
))
150 /* Try to connect to unused ports anyway. */
151 zfcp_erp_port_reopen(port
,
152 ZFCP_STATUS_COMMON_ERP_FAILED
,
154 else if ((port
->d_id
& range
) == (elem
->nport_did
& range
))
155 /* Check connection status for connected ports */
156 zfcp_test_link(port
);
158 read_unlock_irqrestore(&zfcp_data
.config_lock
, flags
);
161 static void zfcp_fc_incoming_rscn(struct zfcp_fsf_req
*fsf_req
)
163 struct fsf_status_read_buffer
*status_buffer
= (void *)fsf_req
->data
;
164 struct fcp_rscn_head
*fcp_rscn_head
;
165 struct fcp_rscn_element
*fcp_rscn_element
;
170 fcp_rscn_head
= (struct fcp_rscn_head
*) status_buffer
->payload
.data
;
171 fcp_rscn_element
= (struct fcp_rscn_element
*) fcp_rscn_head
;
174 no_entries
= fcp_rscn_head
->payload_len
/
175 sizeof(struct fcp_rscn_element
);
177 for (i
= 1; i
< no_entries
; i
++) {
178 /* skip head and start with 1st element */
180 range_mask
= rscn_range_mask
[fcp_rscn_element
->addr_format
];
181 _zfcp_fc_incoming_rscn(fsf_req
, range_mask
, fcp_rscn_element
);
183 schedule_work(&fsf_req
->adapter
->scan_work
);
186 static void zfcp_fc_incoming_wwpn(struct zfcp_fsf_req
*req
, u64 wwpn
)
188 struct zfcp_adapter
*adapter
= req
->adapter
;
189 struct zfcp_port
*port
;
192 read_lock_irqsave(&zfcp_data
.config_lock
, flags
);
193 list_for_each_entry(port
, &adapter
->port_list_head
, list
)
194 if (port
->wwpn
== wwpn
)
196 read_unlock_irqrestore(&zfcp_data
.config_lock
, flags
);
198 if (port
&& (port
->wwpn
== wwpn
))
199 zfcp_erp_port_forced_reopen(port
, 0, 83, req
);
202 static void zfcp_fc_incoming_plogi(struct zfcp_fsf_req
*req
)
204 struct fsf_status_read_buffer
*status_buffer
=
205 (struct fsf_status_read_buffer
*)req
->data
;
206 struct fsf_plogi
*els_plogi
=
207 (struct fsf_plogi
*) status_buffer
->payload
.data
;
209 zfcp_fc_incoming_wwpn(req
, els_plogi
->serv_param
.wwpn
);
212 static void zfcp_fc_incoming_logo(struct zfcp_fsf_req
*req
)
214 struct fsf_status_read_buffer
*status_buffer
=
215 (struct fsf_status_read_buffer
*)req
->data
;
216 struct fcp_logo
*els_logo
=
217 (struct fcp_logo
*) status_buffer
->payload
.data
;
219 zfcp_fc_incoming_wwpn(req
, els_logo
->nport_wwpn
);
223 * zfcp_fc_incoming_els - handle incoming ELS
224 * @fsf_req - request which contains incoming ELS
226 void zfcp_fc_incoming_els(struct zfcp_fsf_req
*fsf_req
)
228 struct fsf_status_read_buffer
*status_buffer
=
229 (struct fsf_status_read_buffer
*) fsf_req
->data
;
230 unsigned int els_type
= status_buffer
->payload
.data
[0];
232 zfcp_san_dbf_event_incoming_els(fsf_req
);
233 if (els_type
== LS_PLOGI
)
234 zfcp_fc_incoming_plogi(fsf_req
);
235 else if (els_type
== LS_LOGO
)
236 zfcp_fc_incoming_logo(fsf_req
);
237 else if (els_type
== LS_RSCN
)
238 zfcp_fc_incoming_rscn(fsf_req
);
241 static void zfcp_fc_ns_handler(unsigned long data
)
243 struct zfcp_fc_ns_handler_data
*compl_rec
=
244 (struct zfcp_fc_ns_handler_data
*) data
;
246 if (compl_rec
->handler
)
247 compl_rec
->handler(compl_rec
->handler_data
);
249 complete(&compl_rec
->done
);
252 static void zfcp_fc_ns_gid_pn_eval(unsigned long data
)
254 struct zfcp_gid_pn_data
*gid_pn
= (struct zfcp_gid_pn_data
*) data
;
255 struct zfcp_send_ct
*ct
= &gid_pn
->ct
;
256 struct ct_iu_gid_pn_req
*ct_iu_req
= sg_virt(ct
->req
);
257 struct ct_iu_gid_pn_resp
*ct_iu_resp
= sg_virt(ct
->resp
);
258 struct zfcp_port
*port
= gid_pn
->port
;
262 if (ct_iu_resp
->header
.cmd_rsp_code
!= ZFCP_CT_ACCEPT
) {
263 atomic_set_mask(ZFCP_STATUS_PORT_INVALID_WWPN
, &port
->status
);
267 if (ct_iu_req
->wwpn
!= port
->wwpn
)
269 /* looks like a valid d_id */
270 port
->d_id
= ct_iu_resp
->d_id
& ZFCP_DID_MASK
;
273 int static zfcp_fc_ns_gid_pn_request(struct zfcp_erp_action
*erp_action
,
274 struct zfcp_gid_pn_data
*gid_pn
)
276 struct zfcp_adapter
*adapter
= erp_action
->adapter
;
277 struct zfcp_fc_ns_handler_data compl_rec
;
280 /* setup parameters for send generic command */
281 gid_pn
->port
= erp_action
->port
;
282 gid_pn
->ct
.wka_port
= &adapter
->nsp
;
283 gid_pn
->ct
.handler
= zfcp_fc_ns_handler
;
284 gid_pn
->ct
.handler_data
= (unsigned long) &compl_rec
;
285 gid_pn
->ct
.timeout
= ZFCP_NS_GID_PN_TIMEOUT
;
286 gid_pn
->ct
.req
= &gid_pn
->req
;
287 gid_pn
->ct
.resp
= &gid_pn
->resp
;
288 sg_init_one(&gid_pn
->req
, &gid_pn
->ct_iu_req
,
289 sizeof(struct ct_iu_gid_pn_req
));
290 sg_init_one(&gid_pn
->resp
, &gid_pn
->ct_iu_resp
,
291 sizeof(struct ct_iu_gid_pn_resp
));
293 /* setup nameserver request */
294 gid_pn
->ct_iu_req
.header
.revision
= ZFCP_CT_REVISION
;
295 gid_pn
->ct_iu_req
.header
.gs_type
= ZFCP_CT_DIRECTORY_SERVICE
;
296 gid_pn
->ct_iu_req
.header
.gs_subtype
= ZFCP_CT_NAME_SERVER
;
297 gid_pn
->ct_iu_req
.header
.options
= ZFCP_CT_SYNCHRONOUS
;
298 gid_pn
->ct_iu_req
.header
.cmd_rsp_code
= ZFCP_CT_GID_PN
;
299 gid_pn
->ct_iu_req
.header
.max_res_size
= ZFCP_CT_SIZE_ONE_PAGE
/ 4;
300 gid_pn
->ct_iu_req
.wwpn
= erp_action
->port
->wwpn
;
302 init_completion(&compl_rec
.done
);
303 compl_rec
.handler
= zfcp_fc_ns_gid_pn_eval
;
304 compl_rec
.handler_data
= (unsigned long) gid_pn
;
305 ret
= zfcp_fsf_send_ct(&gid_pn
->ct
, adapter
->pool
.fsf_req_erp
,
308 wait_for_completion(&compl_rec
.done
);
313 * zfcp_fc_ns_gid_pn_request - initiate GID_PN nameserver request
314 * @erp_action: pointer to zfcp_erp_action where GID_PN request is needed
315 * return: -ENOMEM on error, 0 otherwise
317 int zfcp_fc_ns_gid_pn(struct zfcp_erp_action
*erp_action
)
320 struct zfcp_gid_pn_data
*gid_pn
;
321 struct zfcp_adapter
*adapter
= erp_action
->adapter
;
323 gid_pn
= mempool_alloc(adapter
->pool
.data_gid_pn
, GFP_ATOMIC
);
327 memset(gid_pn
, 0, sizeof(*gid_pn
));
329 ret
= zfcp_wka_port_get(&adapter
->nsp
);
333 ret
= zfcp_fc_ns_gid_pn_request(erp_action
, gid_pn
);
335 zfcp_wka_port_put(&adapter
->nsp
);
337 mempool_free(gid_pn
, adapter
->pool
.data_gid_pn
);
342 * zfcp_fc_plogi_evaluate - evaluate PLOGI playload
343 * @port: zfcp_port structure
344 * @plogi: plogi payload
346 * Evaluate PLOGI playload and copy important fields into zfcp_port structure
348 void zfcp_fc_plogi_evaluate(struct zfcp_port
*port
, struct fsf_plogi
*plogi
)
350 port
->maxframe_size
= plogi
->serv_param
.common_serv_param
[7] |
351 ((plogi
->serv_param
.common_serv_param
[6] & 0x0F) << 8);
352 if (plogi
->serv_param
.class1_serv_param
[0] & 0x80)
353 port
->supported_classes
|= FC_COS_CLASS1
;
354 if (plogi
->serv_param
.class2_serv_param
[0] & 0x80)
355 port
->supported_classes
|= FC_COS_CLASS2
;
356 if (plogi
->serv_param
.class3_serv_param
[0] & 0x80)
357 port
->supported_classes
|= FC_COS_CLASS3
;
358 if (plogi
->serv_param
.class4_serv_param
[0] & 0x80)
359 port
->supported_classes
|= FC_COS_CLASS4
;
362 struct zfcp_els_adisc
{
363 struct zfcp_send_els els
;
364 struct scatterlist req
;
365 struct scatterlist resp
;
366 struct zfcp_ls_adisc ls_adisc
;
367 struct zfcp_ls_adisc ls_adisc_acc
;
370 static void zfcp_fc_adisc_handler(unsigned long data
)
372 struct zfcp_els_adisc
*adisc
= (struct zfcp_els_adisc
*) data
;
373 struct zfcp_port
*port
= adisc
->els
.port
;
374 struct zfcp_ls_adisc
*ls_adisc
= &adisc
->ls_adisc_acc
;
376 if (adisc
->els
.status
) {
377 /* request rejected or timed out */
378 zfcp_erp_port_forced_reopen(port
, 0, 63, NULL
);
383 port
->wwnn
= ls_adisc
->wwnn
;
385 if (port
->wwpn
!= ls_adisc
->wwpn
)
386 zfcp_erp_port_reopen(port
, 0, 64, NULL
);
393 static int zfcp_fc_adisc(struct zfcp_port
*port
)
395 struct zfcp_els_adisc
*adisc
;
396 struct zfcp_adapter
*adapter
= port
->adapter
;
398 adisc
= kzalloc(sizeof(struct zfcp_els_adisc
), GFP_ATOMIC
);
402 adisc
->els
.req
= &adisc
->req
;
403 adisc
->els
.resp
= &adisc
->resp
;
404 sg_init_one(adisc
->els
.req
, &adisc
->ls_adisc
,
405 sizeof(struct zfcp_ls_adisc
));
406 sg_init_one(adisc
->els
.resp
, &adisc
->ls_adisc_acc
,
407 sizeof(struct zfcp_ls_adisc
));
409 adisc
->els
.adapter
= adapter
;
410 adisc
->els
.port
= port
;
411 adisc
->els
.d_id
= port
->d_id
;
412 adisc
->els
.handler
= zfcp_fc_adisc_handler
;
413 adisc
->els
.handler_data
= (unsigned long) adisc
;
414 adisc
->els
.ls_code
= adisc
->ls_adisc
.code
= ZFCP_LS_ADISC
;
416 /* acc. to FC-FS, hard_nport_id in ADISC should not be set for ports
417 without FC-AL-2 capability, so we don't set it */
418 adisc
->ls_adisc
.wwpn
= fc_host_port_name(adapter
->scsi_host
);
419 adisc
->ls_adisc
.wwnn
= fc_host_node_name(adapter
->scsi_host
);
420 adisc
->ls_adisc
.nport_id
= fc_host_port_id(adapter
->scsi_host
);
422 return zfcp_fsf_send_els(&adisc
->els
);
426 * zfcp_test_link - lightweight link test procedure
427 * @port: port to be tested
429 * Test status of a link to a remote port using the ELS command ADISC.
430 * If there is a problem with the remote port, error recovery steps
433 void zfcp_test_link(struct zfcp_port
*port
)
438 retval
= zfcp_fc_adisc(port
);
442 /* send of ADISC was not possible */
444 if (retval
!= -EBUSY
)
445 zfcp_erp_port_forced_reopen(port
, 0, 65, NULL
);
448 static void zfcp_free_sg_env(struct zfcp_gpn_ft
*gpn_ft
, int buf_num
)
450 struct scatterlist
*sg
= &gpn_ft
->sg_req
;
452 kfree(sg_virt(sg
)); /* free request buffer */
453 zfcp_sg_free_table(gpn_ft
->sg_resp
, buf_num
);
458 static struct zfcp_gpn_ft
*zfcp_alloc_sg_env(int buf_num
)
460 struct zfcp_gpn_ft
*gpn_ft
;
461 struct ct_iu_gpn_ft_req
*req
;
463 gpn_ft
= kzalloc(sizeof(*gpn_ft
), GFP_KERNEL
);
467 req
= kzalloc(sizeof(struct ct_iu_gpn_ft_req
), GFP_KERNEL
);
473 sg_init_one(&gpn_ft
->sg_req
, req
, sizeof(*req
));
475 if (zfcp_sg_setup_table(gpn_ft
->sg_resp
, buf_num
)) {
476 zfcp_free_sg_env(gpn_ft
, buf_num
);
484 static int zfcp_scan_issue_gpn_ft(struct zfcp_gpn_ft
*gpn_ft
,
485 struct zfcp_adapter
*adapter
,
488 struct zfcp_send_ct
*ct
= &gpn_ft
->ct
;
489 struct ct_iu_gpn_ft_req
*req
= sg_virt(&gpn_ft
->sg_req
);
490 struct zfcp_fc_ns_handler_data compl_rec
;
493 /* prepare CT IU for GPN_FT */
494 req
->header
.revision
= ZFCP_CT_REVISION
;
495 req
->header
.gs_type
= ZFCP_CT_DIRECTORY_SERVICE
;
496 req
->header
.gs_subtype
= ZFCP_CT_NAME_SERVER
;
497 req
->header
.options
= ZFCP_CT_SYNCHRONOUS
;
498 req
->header
.cmd_rsp_code
= ZFCP_CT_GPN_FT
;
499 req
->header
.max_res_size
= max_bytes
/ 4;
501 req
->domain_id_scope
= 0;
502 req
->area_id_scope
= 0;
503 req
->fc4_type
= ZFCP_CT_SCSI_FCP
;
505 /* prepare zfcp_send_ct */
506 ct
->wka_port
= &adapter
->nsp
;
507 ct
->handler
= zfcp_fc_ns_handler
;
508 ct
->handler_data
= (unsigned long)&compl_rec
;
510 ct
->req
= &gpn_ft
->sg_req
;
511 ct
->resp
= gpn_ft
->sg_resp
;
513 init_completion(&compl_rec
.done
);
514 compl_rec
.handler
= NULL
;
515 ret
= zfcp_fsf_send_ct(ct
, NULL
, NULL
);
517 wait_for_completion(&compl_rec
.done
);
521 static void zfcp_validate_port(struct zfcp_port
*port
)
523 struct zfcp_adapter
*adapter
= port
->adapter
;
525 atomic_clear_mask(ZFCP_STATUS_COMMON_NOESC
, &port
->status
);
527 if ((port
->supported_classes
!= 0) ||
528 !list_empty(&port
->unit_list_head
)) {
532 zfcp_erp_port_shutdown(port
, 0, 151, NULL
);
533 zfcp_erp_wait(adapter
);
535 zfcp_port_dequeue(port
);
538 static int zfcp_scan_eval_gpn_ft(struct zfcp_gpn_ft
*gpn_ft
, int max_entries
)
540 struct zfcp_send_ct
*ct
= &gpn_ft
->ct
;
541 struct scatterlist
*sg
= gpn_ft
->sg_resp
;
542 struct ct_hdr
*hdr
= sg_virt(sg
);
543 struct gpn_ft_resp_acc
*acc
= sg_virt(sg
);
544 struct zfcp_adapter
*adapter
= ct
->wka_port
->adapter
;
545 struct zfcp_port
*port
, *tmp
;
547 int ret
= 0, x
, last
= 0;
552 if (hdr
->cmd_rsp_code
!= ZFCP_CT_ACCEPT
) {
553 if (hdr
->reason_code
== ZFCP_CT_UNABLE_TO_PERFORM_CMD
)
554 return -EAGAIN
; /* might be a temporary condition */
558 if (hdr
->max_res_size
) {
559 dev_warn(&adapter
->ccw_device
->dev
,
560 "The name server reported %d words residual data\n",
565 down(&zfcp_data
.config_sema
);
567 /* first entry is the header */
568 for (x
= 1; x
< max_entries
&& !last
; x
++) {
569 if (x
% (ZFCP_GPN_FT_ENTRIES
+ 1))
574 last
= acc
->control
& 0x80;
575 d_id
= acc
->port_id
[0] << 16 | acc
->port_id
[1] << 8 |
578 /* don't attach ports with a well known address */
579 if ((d_id
& ZFCP_DID_WKA
) == ZFCP_DID_WKA
)
581 /* skip the adapter's port and known remote ports */
582 if (acc
->wwpn
== fc_host_port_name(adapter
->scsi_host
))
584 port
= zfcp_get_port_by_wwpn(adapter
, acc
->wwpn
);
590 port
= zfcp_port_enqueue(adapter
, acc
->wwpn
,
591 ZFCP_STATUS_COMMON_NOESC
, d_id
);
595 zfcp_erp_port_reopen(port
, 0, 149, NULL
);
598 zfcp_erp_wait(adapter
);
599 list_for_each_entry_safe(port
, tmp
, &adapter
->port_list_head
, list
)
600 zfcp_validate_port(port
);
601 up(&zfcp_data
.config_sema
);
606 * zfcp_scan_ports - scan remote ports and attach new ports
607 * @adapter: pointer to struct zfcp_adapter
609 int zfcp_scan_ports(struct zfcp_adapter
*adapter
)
612 struct zfcp_gpn_ft
*gpn_ft
;
613 int chain
, max_entries
, buf_num
, max_bytes
;
615 chain
= adapter
->adapter_features
& FSF_FEATURE_ELS_CT_CHAINED_SBALS
;
616 buf_num
= chain
? ZFCP_GPN_FT_BUFFERS
: 1;
617 max_entries
= chain
? ZFCP_GPN_FT_MAX_ENTRIES
: ZFCP_GPN_FT_ENTRIES
;
618 max_bytes
= chain
? ZFCP_GPN_FT_MAX_SIZE
: ZFCP_CT_SIZE_ONE_PAGE
;
620 if (fc_host_port_type(adapter
->scsi_host
) != FC_PORTTYPE_NPORT
)
623 ret
= zfcp_wka_port_get(&adapter
->nsp
);
627 gpn_ft
= zfcp_alloc_sg_env(buf_num
);
633 for (i
= 0; i
< 3; i
++) {
634 ret
= zfcp_scan_issue_gpn_ft(gpn_ft
, adapter
, max_bytes
);
636 ret
= zfcp_scan_eval_gpn_ft(gpn_ft
, max_entries
);
643 zfcp_free_sg_env(gpn_ft
, buf_num
);
645 zfcp_wka_port_put(&adapter
->nsp
);
650 void _zfcp_scan_ports_later(struct work_struct
*work
)
652 zfcp_scan_ports(container_of(work
, struct zfcp_adapter
, scan_work
));