4 * Fibre Channel related functions for the zfcp device driver.
6 * Copyright IBM Corporation 2008, 2010
9 #define KMSG_COMPONENT "zfcp"
10 #define pr_fmt(fmt) KMSG_COMPONENT ": " fmt
12 #include <linux/types.h>
13 #include <linux/slab.h>
14 #include <scsi/fc/fc_els.h>
15 #include <scsi/libfc.h>
19 static u32 zfcp_fc_rscn_range_mask
[] = {
20 [ELS_ADDR_FMT_PORT
] = 0xFFFFFF,
21 [ELS_ADDR_FMT_AREA
] = 0xFFFF00,
22 [ELS_ADDR_FMT_DOM
] = 0xFF0000,
23 [ELS_ADDR_FMT_FAB
] = 0x000000,
27 * zfcp_fc_post_event - post event to userspace via fc_transport
28 * @work: work struct with enqueued events
30 void zfcp_fc_post_event(struct work_struct
*work
)
32 struct zfcp_fc_event
*event
= NULL
, *tmp
= NULL
;
34 struct zfcp_fc_events
*events
= container_of(work
,
35 struct zfcp_fc_events
, work
);
36 struct zfcp_adapter
*adapter
= container_of(events
, struct zfcp_adapter
,
39 spin_lock_bh(&events
->list_lock
);
40 list_splice_init(&events
->list
, &tmp_lh
);
41 spin_unlock_bh(&events
->list_lock
);
43 list_for_each_entry_safe(event
, tmp
, &tmp_lh
, list
) {
44 fc_host_post_event(adapter
->scsi_host
, fc_get_event_number(),
45 event
->code
, event
->data
);
46 list_del(&event
->list
);
53 * zfcp_fc_enqueue_event - safely enqueue FC HBA API event from irq context
54 * @adapter: The adapter where to enqueue the event
55 * @event_code: The event code (as defined in fc_host_event_code in
56 * scsi_transport_fc.h)
57 * @event_data: The event data (e.g. n_port page in case of els)
59 void zfcp_fc_enqueue_event(struct zfcp_adapter
*adapter
,
60 enum fc_host_event_code event_code
, u32 event_data
)
62 struct zfcp_fc_event
*event
;
64 event
= kmalloc(sizeof(struct zfcp_fc_event
), GFP_ATOMIC
);
68 event
->code
= event_code
;
69 event
->data
= event_data
;
71 spin_lock(&adapter
->events
.list_lock
);
72 list_add_tail(&event
->list
, &adapter
->events
.list
);
73 spin_unlock(&adapter
->events
.list_lock
);
75 queue_work(adapter
->work_queue
, &adapter
->events
.work
);
78 static int zfcp_fc_wka_port_get(struct zfcp_fc_wka_port
*wka_port
)
80 if (mutex_lock_interruptible(&wka_port
->mutex
))
83 if (wka_port
->status
== ZFCP_FC_WKA_PORT_OFFLINE
||
84 wka_port
->status
== ZFCP_FC_WKA_PORT_CLOSING
) {
85 wka_port
->status
= ZFCP_FC_WKA_PORT_OPENING
;
86 if (zfcp_fsf_open_wka_port(wka_port
))
87 wka_port
->status
= ZFCP_FC_WKA_PORT_OFFLINE
;
90 mutex_unlock(&wka_port
->mutex
);
92 wait_event(wka_port
->completion_wq
,
93 wka_port
->status
== ZFCP_FC_WKA_PORT_ONLINE
||
94 wka_port
->status
== ZFCP_FC_WKA_PORT_OFFLINE
);
96 if (wka_port
->status
== ZFCP_FC_WKA_PORT_ONLINE
) {
97 atomic_inc(&wka_port
->refcount
);
103 static void zfcp_fc_wka_port_offline(struct work_struct
*work
)
105 struct delayed_work
*dw
= to_delayed_work(work
);
106 struct zfcp_fc_wka_port
*wka_port
=
107 container_of(dw
, struct zfcp_fc_wka_port
, work
);
109 mutex_lock(&wka_port
->mutex
);
110 if ((atomic_read(&wka_port
->refcount
) != 0) ||
111 (wka_port
->status
!= ZFCP_FC_WKA_PORT_ONLINE
))
114 wka_port
->status
= ZFCP_FC_WKA_PORT_CLOSING
;
115 if (zfcp_fsf_close_wka_port(wka_port
)) {
116 wka_port
->status
= ZFCP_FC_WKA_PORT_OFFLINE
;
117 wake_up(&wka_port
->completion_wq
);
120 mutex_unlock(&wka_port
->mutex
);
123 static void zfcp_fc_wka_port_put(struct zfcp_fc_wka_port
*wka_port
)
125 if (atomic_dec_return(&wka_port
->refcount
) != 0)
127 /* wait 10 milliseconds, other reqs might pop in */
128 schedule_delayed_work(&wka_port
->work
, HZ
/ 100);
131 static void zfcp_fc_wka_port_init(struct zfcp_fc_wka_port
*wka_port
, u32 d_id
,
132 struct zfcp_adapter
*adapter
)
134 init_waitqueue_head(&wka_port
->completion_wq
);
136 wka_port
->adapter
= adapter
;
137 wka_port
->d_id
= d_id
;
139 wka_port
->status
= ZFCP_FC_WKA_PORT_OFFLINE
;
140 atomic_set(&wka_port
->refcount
, 0);
141 mutex_init(&wka_port
->mutex
);
142 INIT_DELAYED_WORK(&wka_port
->work
, zfcp_fc_wka_port_offline
);
145 static void zfcp_fc_wka_port_force_offline(struct zfcp_fc_wka_port
*wka
)
147 cancel_delayed_work_sync(&wka
->work
);
148 mutex_lock(&wka
->mutex
);
149 wka
->status
= ZFCP_FC_WKA_PORT_OFFLINE
;
150 mutex_unlock(&wka
->mutex
);
153 void zfcp_fc_wka_ports_force_offline(struct zfcp_fc_wka_ports
*gs
)
157 zfcp_fc_wka_port_force_offline(&gs
->ms
);
158 zfcp_fc_wka_port_force_offline(&gs
->ts
);
159 zfcp_fc_wka_port_force_offline(&gs
->ds
);
160 zfcp_fc_wka_port_force_offline(&gs
->as
);
163 static void _zfcp_fc_incoming_rscn(struct zfcp_fsf_req
*fsf_req
, u32 range
,
164 struct fc_els_rscn_page
*page
)
167 struct zfcp_adapter
*adapter
= fsf_req
->adapter
;
168 struct zfcp_port
*port
;
170 read_lock_irqsave(&adapter
->port_list_lock
, flags
);
171 list_for_each_entry(port
, &adapter
->port_list
, list
) {
172 if ((port
->d_id
& range
) == (ntoh24(page
->rscn_fid
) & range
))
173 zfcp_fc_test_link(port
);
175 zfcp_erp_port_reopen(port
,
176 ZFCP_STATUS_COMMON_ERP_FAILED
,
179 read_unlock_irqrestore(&adapter
->port_list_lock
, flags
);
182 static void zfcp_fc_incoming_rscn(struct zfcp_fsf_req
*fsf_req
)
184 struct fsf_status_read_buffer
*status_buffer
= (void *)fsf_req
->data
;
185 struct fc_els_rscn
*head
;
186 struct fc_els_rscn_page
*page
;
191 head
= (struct fc_els_rscn
*) status_buffer
->payload
.data
;
192 page
= (struct fc_els_rscn_page
*) head
;
195 no_entries
= head
->rscn_plen
/ sizeof(struct fc_els_rscn_page
);
197 for (i
= 1; i
< no_entries
; i
++) {
198 /* skip head and start with 1st element */
200 afmt
= page
->rscn_page_flags
& ELS_RSCN_ADDR_FMT_MASK
;
201 _zfcp_fc_incoming_rscn(fsf_req
, zfcp_fc_rscn_range_mask
[afmt
],
203 zfcp_fc_enqueue_event(fsf_req
->adapter
, FCH_EVT_RSCN
,
206 queue_work(fsf_req
->adapter
->work_queue
, &fsf_req
->adapter
->scan_work
);
209 static void zfcp_fc_incoming_wwpn(struct zfcp_fsf_req
*req
, u64 wwpn
)
212 struct zfcp_adapter
*adapter
= req
->adapter
;
213 struct zfcp_port
*port
;
215 read_lock_irqsave(&adapter
->port_list_lock
, flags
);
216 list_for_each_entry(port
, &adapter
->port_list
, list
)
217 if (port
->wwpn
== wwpn
) {
218 zfcp_erp_port_forced_reopen(port
, 0, "fciwwp1", req
);
221 read_unlock_irqrestore(&adapter
->port_list_lock
, flags
);
224 static void zfcp_fc_incoming_plogi(struct zfcp_fsf_req
*req
)
226 struct fsf_status_read_buffer
*status_buffer
;
227 struct fc_els_flogi
*plogi
;
229 status_buffer
= (struct fsf_status_read_buffer
*) req
->data
;
230 plogi
= (struct fc_els_flogi
*) status_buffer
->payload
.data
;
231 zfcp_fc_incoming_wwpn(req
, plogi
->fl_wwpn
);
234 static void zfcp_fc_incoming_logo(struct zfcp_fsf_req
*req
)
236 struct fsf_status_read_buffer
*status_buffer
=
237 (struct fsf_status_read_buffer
*)req
->data
;
238 struct fc_els_logo
*logo
=
239 (struct fc_els_logo
*) status_buffer
->payload
.data
;
241 zfcp_fc_incoming_wwpn(req
, logo
->fl_n_port_wwn
);
245 * zfcp_fc_incoming_els - handle incoming ELS
246 * @fsf_req - request which contains incoming ELS
248 void zfcp_fc_incoming_els(struct zfcp_fsf_req
*fsf_req
)
250 struct fsf_status_read_buffer
*status_buffer
=
251 (struct fsf_status_read_buffer
*) fsf_req
->data
;
252 unsigned int els_type
= status_buffer
->payload
.data
[0];
254 zfcp_dbf_san_incoming_els(fsf_req
);
255 if (els_type
== ELS_PLOGI
)
256 zfcp_fc_incoming_plogi(fsf_req
);
257 else if (els_type
== ELS_LOGO
)
258 zfcp_fc_incoming_logo(fsf_req
);
259 else if (els_type
== ELS_RSCN
)
260 zfcp_fc_incoming_rscn(fsf_req
);
263 static void zfcp_fc_ns_gid_pn_eval(void *data
)
265 struct zfcp_fc_gid_pn
*gid_pn
= data
;
266 struct zfcp_fsf_ct_els
*ct
= &gid_pn
->ct
;
267 struct zfcp_fc_gid_pn_req
*gid_pn_req
= sg_virt(ct
->req
);
268 struct zfcp_fc_gid_pn_resp
*gid_pn_resp
= sg_virt(ct
->resp
);
269 struct zfcp_port
*port
= gid_pn
->port
;
273 if (gid_pn_resp
->ct_hdr
.ct_cmd
!= FC_FS_ACC
)
277 if (gid_pn_req
->gid_pn
.fn_wwpn
!= port
->wwpn
)
279 /* looks like a valid d_id */
280 port
->d_id
= ntoh24(gid_pn_resp
->gid_pn
.fp_fid
);
283 static void zfcp_fc_complete(void *data
)
288 static int zfcp_fc_ns_gid_pn_request(struct zfcp_port
*port
,
289 struct zfcp_fc_gid_pn
*gid_pn
)
291 struct zfcp_adapter
*adapter
= port
->adapter
;
292 DECLARE_COMPLETION_ONSTACK(completion
);
295 /* setup parameters for send generic command */
297 gid_pn
->ct
.handler
= zfcp_fc_complete
;
298 gid_pn
->ct
.handler_data
= &completion
;
299 gid_pn
->ct
.req
= &gid_pn
->sg_req
;
300 gid_pn
->ct
.resp
= &gid_pn
->sg_resp
;
301 sg_init_one(&gid_pn
->sg_req
, &gid_pn
->gid_pn_req
,
302 sizeof(struct zfcp_fc_gid_pn_req
));
303 sg_init_one(&gid_pn
->sg_resp
, &gid_pn
->gid_pn_resp
,
304 sizeof(struct zfcp_fc_gid_pn_resp
));
306 /* setup nameserver request */
307 gid_pn
->gid_pn_req
.ct_hdr
.ct_rev
= FC_CT_REV
;
308 gid_pn
->gid_pn_req
.ct_hdr
.ct_fs_type
= FC_FST_DIR
;
309 gid_pn
->gid_pn_req
.ct_hdr
.ct_fs_subtype
= FC_NS_SUBTYPE
;
310 gid_pn
->gid_pn_req
.ct_hdr
.ct_options
= 0;
311 gid_pn
->gid_pn_req
.ct_hdr
.ct_cmd
= FC_NS_GID_PN
;
312 gid_pn
->gid_pn_req
.ct_hdr
.ct_mr_size
= ZFCP_FC_CT_SIZE_PAGE
/ 4;
313 gid_pn
->gid_pn_req
.gid_pn
.fn_wwpn
= port
->wwpn
;
315 ret
= zfcp_fsf_send_ct(&adapter
->gs
->ds
, &gid_pn
->ct
,
316 adapter
->pool
.gid_pn_req
,
319 wait_for_completion(&completion
);
320 zfcp_fc_ns_gid_pn_eval(gid_pn
);
326 * zfcp_fc_ns_gid_pn_request - initiate GID_PN nameserver request
327 * @port: port where GID_PN request is needed
328 * return: -ENOMEM on error, 0 otherwise
330 static int zfcp_fc_ns_gid_pn(struct zfcp_port
*port
)
333 struct zfcp_fc_gid_pn
*gid_pn
;
334 struct zfcp_adapter
*adapter
= port
->adapter
;
336 gid_pn
= mempool_alloc(adapter
->pool
.gid_pn
, GFP_ATOMIC
);
340 memset(gid_pn
, 0, sizeof(*gid_pn
));
342 ret
= zfcp_fc_wka_port_get(&adapter
->gs
->ds
);
346 ret
= zfcp_fc_ns_gid_pn_request(port
, gid_pn
);
348 zfcp_fc_wka_port_put(&adapter
->gs
->ds
);
350 mempool_free(gid_pn
, adapter
->pool
.gid_pn
);
354 void zfcp_fc_port_did_lookup(struct work_struct
*work
)
357 struct zfcp_port
*port
= container_of(work
, struct zfcp_port
,
360 ret
= zfcp_fc_ns_gid_pn(port
);
362 /* could not issue gid_pn for some reason */
363 zfcp_erp_adapter_reopen(port
->adapter
, 0, "fcgpn_1", NULL
);
368 zfcp_erp_port_failed(port
, "fcgpn_2", NULL
);
372 zfcp_erp_port_reopen(port
, 0, "fcgpn_3", NULL
);
374 put_device(&port
->dev
);
378 * zfcp_fc_trigger_did_lookup - trigger the d_id lookup using a GID_PN request
379 * @port: The zfcp_port to lookup the d_id for.
381 void zfcp_fc_trigger_did_lookup(struct zfcp_port
*port
)
383 get_device(&port
->dev
);
384 if (!queue_work(port
->adapter
->work_queue
, &port
->gid_pn_work
))
385 put_device(&port
->dev
);
389 * zfcp_fc_plogi_evaluate - evaluate PLOGI playload
390 * @port: zfcp_port structure
391 * @plogi: plogi payload
393 * Evaluate PLOGI playload and copy important fields into zfcp_port structure
395 void zfcp_fc_plogi_evaluate(struct zfcp_port
*port
, struct fc_els_flogi
*plogi
)
397 if (plogi
->fl_wwpn
!= port
->wwpn
) {
399 dev_warn(&port
->adapter
->ccw_device
->dev
,
400 "A port opened with WWPN 0x%016Lx returned data that "
401 "identifies it as WWPN 0x%016Lx\n",
402 (unsigned long long) port
->wwpn
,
403 (unsigned long long) plogi
->fl_wwpn
);
407 port
->wwnn
= plogi
->fl_wwnn
;
408 port
->maxframe_size
= plogi
->fl_csp
.sp_bb_data
;
410 if (plogi
->fl_cssp
[0].cp_class
& FC_CPC_VALID
)
411 port
->supported_classes
|= FC_COS_CLASS1
;
412 if (plogi
->fl_cssp
[1].cp_class
& FC_CPC_VALID
)
413 port
->supported_classes
|= FC_COS_CLASS2
;
414 if (plogi
->fl_cssp
[2].cp_class
& FC_CPC_VALID
)
415 port
->supported_classes
|= FC_COS_CLASS3
;
416 if (plogi
->fl_cssp
[3].cp_class
& FC_CPC_VALID
)
417 port
->supported_classes
|= FC_COS_CLASS4
;
420 static void zfcp_fc_adisc_handler(void *data
)
422 struct zfcp_fc_els_adisc
*adisc
= data
;
423 struct zfcp_port
*port
= adisc
->els
.port
;
424 struct fc_els_adisc
*adisc_resp
= &adisc
->adisc_resp
;
426 if (adisc
->els
.status
) {
427 /* request rejected or timed out */
428 zfcp_erp_port_forced_reopen(port
, ZFCP_STATUS_COMMON_ERP_FAILED
,
434 port
->wwnn
= adisc_resp
->adisc_wwnn
;
436 if ((port
->wwpn
!= adisc_resp
->adisc_wwpn
) ||
437 !(atomic_read(&port
->status
) & ZFCP_STATUS_COMMON_OPEN
)) {
438 zfcp_erp_port_reopen(port
, ZFCP_STATUS_COMMON_ERP_FAILED
,
443 /* port is good, unblock rport without going through erp */
444 zfcp_scsi_schedule_rport_register(port
);
446 atomic_clear_mask(ZFCP_STATUS_PORT_LINK_TEST
, &port
->status
);
447 put_device(&port
->dev
);
448 kmem_cache_free(zfcp_data
.adisc_cache
, adisc
);
451 static int zfcp_fc_adisc(struct zfcp_port
*port
)
453 struct zfcp_fc_els_adisc
*adisc
;
454 struct zfcp_adapter
*adapter
= port
->adapter
;
457 adisc
= kmem_cache_zalloc(zfcp_data
.adisc_cache
, GFP_ATOMIC
);
461 adisc
->els
.port
= port
;
462 adisc
->els
.req
= &adisc
->req
;
463 adisc
->els
.resp
= &adisc
->resp
;
464 sg_init_one(adisc
->els
.req
, &adisc
->adisc_req
,
465 sizeof(struct fc_els_adisc
));
466 sg_init_one(adisc
->els
.resp
, &adisc
->adisc_resp
,
467 sizeof(struct fc_els_adisc
));
469 adisc
->els
.handler
= zfcp_fc_adisc_handler
;
470 adisc
->els
.handler_data
= adisc
;
472 /* acc. to FC-FS, hard_nport_id in ADISC should not be set for ports
473 without FC-AL-2 capability, so we don't set it */
474 adisc
->adisc_req
.adisc_wwpn
= fc_host_port_name(adapter
->scsi_host
);
475 adisc
->adisc_req
.adisc_wwnn
= fc_host_node_name(adapter
->scsi_host
);
476 adisc
->adisc_req
.adisc_cmd
= ELS_ADISC
;
477 hton24(adisc
->adisc_req
.adisc_port_id
,
478 fc_host_port_id(adapter
->scsi_host
));
480 ret
= zfcp_fsf_send_els(adapter
, port
->d_id
, &adisc
->els
,
483 kmem_cache_free(zfcp_data
.adisc_cache
, adisc
);
488 void zfcp_fc_link_test_work(struct work_struct
*work
)
490 struct zfcp_port
*port
=
491 container_of(work
, struct zfcp_port
, test_link_work
);
494 get_device(&port
->dev
);
495 port
->rport_task
= RPORT_DEL
;
496 zfcp_scsi_rport_work(&port
->rport_work
);
498 /* only issue one test command at one time per port */
499 if (atomic_read(&port
->status
) & ZFCP_STATUS_PORT_LINK_TEST
)
502 atomic_set_mask(ZFCP_STATUS_PORT_LINK_TEST
, &port
->status
);
504 retval
= zfcp_fc_adisc(port
);
508 /* send of ADISC was not possible */
509 atomic_clear_mask(ZFCP_STATUS_PORT_LINK_TEST
, &port
->status
);
510 zfcp_erp_port_forced_reopen(port
, 0, "fcltwk1", NULL
);
513 put_device(&port
->dev
);
517 * zfcp_fc_test_link - lightweight link test procedure
518 * @port: port to be tested
520 * Test status of a link to a remote port using the ELS command ADISC.
521 * If there is a problem with the remote port, error recovery steps
524 void zfcp_fc_test_link(struct zfcp_port
*port
)
526 get_device(&port
->dev
);
527 if (!queue_work(port
->adapter
->work_queue
, &port
->test_link_work
))
528 put_device(&port
->dev
);
531 static void zfcp_free_sg_env(struct zfcp_fc_gpn_ft
*gpn_ft
, int buf_num
)
533 struct scatterlist
*sg
= &gpn_ft
->sg_req
;
535 kmem_cache_free(zfcp_data
.gpn_ft_cache
, sg_virt(sg
));
536 zfcp_sg_free_table(gpn_ft
->sg_resp
, buf_num
);
541 static struct zfcp_fc_gpn_ft
*zfcp_alloc_sg_env(int buf_num
)
543 struct zfcp_fc_gpn_ft
*gpn_ft
;
544 struct zfcp_fc_gpn_ft_req
*req
;
546 gpn_ft
= kzalloc(sizeof(*gpn_ft
), GFP_KERNEL
);
550 req
= kmem_cache_zalloc(zfcp_data
.gpn_ft_cache
, GFP_KERNEL
);
556 sg_init_one(&gpn_ft
->sg_req
, req
, sizeof(*req
));
558 if (zfcp_sg_setup_table(gpn_ft
->sg_resp
, buf_num
)) {
559 zfcp_free_sg_env(gpn_ft
, buf_num
);
567 static int zfcp_fc_send_gpn_ft(struct zfcp_fc_gpn_ft
*gpn_ft
,
568 struct zfcp_adapter
*adapter
, int max_bytes
)
570 struct zfcp_fsf_ct_els
*ct
= &gpn_ft
->ct
;
571 struct zfcp_fc_gpn_ft_req
*req
= sg_virt(&gpn_ft
->sg_req
);
572 DECLARE_COMPLETION_ONSTACK(completion
);
575 /* prepare CT IU for GPN_FT */
576 req
->ct_hdr
.ct_rev
= FC_CT_REV
;
577 req
->ct_hdr
.ct_fs_type
= FC_FST_DIR
;
578 req
->ct_hdr
.ct_fs_subtype
= FC_NS_SUBTYPE
;
579 req
->ct_hdr
.ct_options
= 0;
580 req
->ct_hdr
.ct_cmd
= FC_NS_GPN_FT
;
581 req
->ct_hdr
.ct_mr_size
= max_bytes
/ 4;
582 req
->gpn_ft
.fn_domain_id_scope
= 0;
583 req
->gpn_ft
.fn_area_id_scope
= 0;
584 req
->gpn_ft
.fn_fc4_type
= FC_TYPE_FCP
;
586 /* prepare zfcp_send_ct */
587 ct
->handler
= zfcp_fc_complete
;
588 ct
->handler_data
= &completion
;
589 ct
->req
= &gpn_ft
->sg_req
;
590 ct
->resp
= gpn_ft
->sg_resp
;
592 ret
= zfcp_fsf_send_ct(&adapter
->gs
->ds
, ct
, NULL
,
595 wait_for_completion(&completion
);
599 static void zfcp_fc_validate_port(struct zfcp_port
*port
, struct list_head
*lh
)
601 if (!(atomic_read(&port
->status
) & ZFCP_STATUS_COMMON_NOESC
))
604 atomic_clear_mask(ZFCP_STATUS_COMMON_NOESC
, &port
->status
);
606 if ((port
->supported_classes
!= 0) ||
607 !list_empty(&port
->unit_list
))
610 list_move_tail(&port
->list
, lh
);
613 static int zfcp_fc_eval_gpn_ft(struct zfcp_fc_gpn_ft
*gpn_ft
,
614 struct zfcp_adapter
*adapter
, int max_entries
)
616 struct zfcp_fsf_ct_els
*ct
= &gpn_ft
->ct
;
617 struct scatterlist
*sg
= gpn_ft
->sg_resp
;
618 struct fc_ct_hdr
*hdr
= sg_virt(sg
);
619 struct fc_gpn_ft_resp
*acc
= sg_virt(sg
);
620 struct zfcp_port
*port
, *tmp
;
622 LIST_HEAD(remove_lh
);
624 int ret
= 0, x
, last
= 0;
629 if (hdr
->ct_cmd
!= FC_FS_ACC
) {
630 if (hdr
->ct_reason
== FC_BA_RJT_UNABLE
)
631 return -EAGAIN
; /* might be a temporary condition */
635 if (hdr
->ct_mr_size
) {
636 dev_warn(&adapter
->ccw_device
->dev
,
637 "The name server reported %d words residual data\n",
642 /* first entry is the header */
643 for (x
= 1; x
< max_entries
&& !last
; x
++) {
644 if (x
% (ZFCP_FC_GPN_FT_ENT_PAGE
+ 1))
649 last
= acc
->fp_flags
& FC_NS_FID_LAST
;
650 d_id
= ntoh24(acc
->fp_fid
);
652 /* don't attach ports with a well known address */
653 if (d_id
>= FC_FID_WELL_KNOWN_BASE
)
655 /* skip the adapter's port and known remote ports */
656 if (acc
->fp_wwpn
== fc_host_port_name(adapter
->scsi_host
))
659 port
= zfcp_port_enqueue(adapter
, acc
->fp_wwpn
,
660 ZFCP_STATUS_COMMON_NOESC
, d_id
);
662 zfcp_erp_port_reopen(port
, 0, "fcegpf1", NULL
);
663 else if (PTR_ERR(port
) != -EEXIST
)
667 zfcp_erp_wait(adapter
);
668 write_lock_irqsave(&adapter
->port_list_lock
, flags
);
669 list_for_each_entry_safe(port
, tmp
, &adapter
->port_list
, list
)
670 zfcp_fc_validate_port(port
, &remove_lh
);
671 write_unlock_irqrestore(&adapter
->port_list_lock
, flags
);
673 list_for_each_entry_safe(port
, tmp
, &remove_lh
, list
) {
674 zfcp_erp_port_shutdown(port
, 0, "fcegpf2", NULL
);
675 zfcp_device_unregister(&port
->dev
, &zfcp_sysfs_port_attrs
);
682 * zfcp_fc_scan_ports - scan remote ports and attach new ports
683 * @work: reference to scheduled work
685 void zfcp_fc_scan_ports(struct work_struct
*work
)
687 struct zfcp_adapter
*adapter
= container_of(work
, struct zfcp_adapter
,
690 struct zfcp_fc_gpn_ft
*gpn_ft
;
691 int chain
, max_entries
, buf_num
, max_bytes
;
693 chain
= adapter
->adapter_features
& FSF_FEATURE_ELS_CT_CHAINED_SBALS
;
694 buf_num
= chain
? ZFCP_FC_GPN_FT_NUM_BUFS
: 1;
695 max_entries
= chain
? ZFCP_FC_GPN_FT_MAX_ENT
: ZFCP_FC_GPN_FT_ENT_PAGE
;
696 max_bytes
= chain
? ZFCP_FC_GPN_FT_MAX_SIZE
: ZFCP_FC_CT_SIZE_PAGE
;
698 if (fc_host_port_type(adapter
->scsi_host
) != FC_PORTTYPE_NPORT
&&
699 fc_host_port_type(adapter
->scsi_host
) != FC_PORTTYPE_NPIV
)
702 if (zfcp_fc_wka_port_get(&adapter
->gs
->ds
))
705 gpn_ft
= zfcp_alloc_sg_env(buf_num
);
709 for (i
= 0; i
< 3; i
++) {
710 ret
= zfcp_fc_send_gpn_ft(gpn_ft
, adapter
, max_bytes
);
712 ret
= zfcp_fc_eval_gpn_ft(gpn_ft
, adapter
, max_entries
);
719 zfcp_free_sg_env(gpn_ft
, buf_num
);
721 zfcp_fc_wka_port_put(&adapter
->gs
->ds
);
724 static void zfcp_fc_ct_els_job_handler(void *data
)
726 struct fc_bsg_job
*job
= data
;
727 struct zfcp_fsf_ct_els
*zfcp_ct_els
= job
->dd_data
;
728 struct fc_bsg_reply
*jr
= job
->reply
;
730 jr
->reply_payload_rcv_len
= job
->reply_payload
.payload_len
;
731 jr
->reply_data
.ctels_reply
.status
= FC_CTELS_STATUS_OK
;
732 jr
->result
= zfcp_ct_els
->status
? -EIO
: 0;
736 static struct zfcp_fc_wka_port
*zfcp_fc_job_wka_port(struct fc_bsg_job
*job
)
740 struct zfcp_adapter
*adapter
;
742 preamble_word1
= job
->request
->rqst_data
.r_ct
.preamble_word1
;
743 gs_type
= (preamble_word1
& 0xff000000) >> 24;
745 adapter
= (struct zfcp_adapter
*) job
->shost
->hostdata
[0];
749 return &adapter
->gs
->as
;
751 return &adapter
->gs
->ms
;
753 return &adapter
->gs
->ts
;
756 return &adapter
->gs
->ds
;
763 static void zfcp_fc_ct_job_handler(void *data
)
765 struct fc_bsg_job
*job
= data
;
766 struct zfcp_fc_wka_port
*wka_port
;
768 wka_port
= zfcp_fc_job_wka_port(job
);
769 zfcp_fc_wka_port_put(wka_port
);
771 zfcp_fc_ct_els_job_handler(data
);
774 static int zfcp_fc_exec_els_job(struct fc_bsg_job
*job
,
775 struct zfcp_adapter
*adapter
)
777 struct zfcp_fsf_ct_els
*els
= job
->dd_data
;
778 struct fc_rport
*rport
= job
->rport
;
779 struct zfcp_port
*port
;
783 port
= zfcp_get_port_by_wwpn(adapter
, rport
->port_name
);
788 put_device(&port
->dev
);
790 d_id
= ntoh24(job
->request
->rqst_data
.h_els
.port_id
);
792 els
->handler
= zfcp_fc_ct_els_job_handler
;
793 return zfcp_fsf_send_els(adapter
, d_id
, els
, job
->req
->timeout
/ HZ
);
796 static int zfcp_fc_exec_ct_job(struct fc_bsg_job
*job
,
797 struct zfcp_adapter
*adapter
)
800 struct zfcp_fsf_ct_els
*ct
= job
->dd_data
;
801 struct zfcp_fc_wka_port
*wka_port
;
803 wka_port
= zfcp_fc_job_wka_port(job
);
807 ret
= zfcp_fc_wka_port_get(wka_port
);
811 ct
->handler
= zfcp_fc_ct_job_handler
;
812 ret
= zfcp_fsf_send_ct(wka_port
, ct
, NULL
, job
->req
->timeout
/ HZ
);
814 zfcp_fc_wka_port_put(wka_port
);
819 int zfcp_fc_exec_bsg_job(struct fc_bsg_job
*job
)
821 struct Scsi_Host
*shost
;
822 struct zfcp_adapter
*adapter
;
823 struct zfcp_fsf_ct_els
*ct_els
= job
->dd_data
;
825 shost
= job
->rport
? rport_to_shost(job
->rport
) : job
->shost
;
826 adapter
= (struct zfcp_adapter
*)shost
->hostdata
[0];
828 if (!(atomic_read(&adapter
->status
) & ZFCP_STATUS_COMMON_OPEN
))
831 ct_els
->req
= job
->request_payload
.sg_list
;
832 ct_els
->resp
= job
->reply_payload
.sg_list
;
833 ct_els
->handler_data
= job
;
835 switch (job
->request
->msgcode
) {
837 case FC_BSG_HST_ELS_NOLOGIN
:
838 return zfcp_fc_exec_els_job(job
, adapter
);
841 return zfcp_fc_exec_ct_job(job
, adapter
);
847 int zfcp_fc_timeout_bsg_job(struct fc_bsg_job
*job
)
849 /* hardware tracks timeout, reset bsg timeout to not interfere */
853 int zfcp_fc_gs_setup(struct zfcp_adapter
*adapter
)
855 struct zfcp_fc_wka_ports
*wka_ports
;
857 wka_ports
= kzalloc(sizeof(struct zfcp_fc_wka_ports
), GFP_KERNEL
);
861 adapter
->gs
= wka_ports
;
862 zfcp_fc_wka_port_init(&wka_ports
->ms
, FC_FID_MGMT_SERV
, adapter
);
863 zfcp_fc_wka_port_init(&wka_ports
->ts
, FC_FID_TIME_SERV
, adapter
);
864 zfcp_fc_wka_port_init(&wka_ports
->ds
, FC_FID_DIR_SERV
, adapter
);
865 zfcp_fc_wka_port_init(&wka_ports
->as
, FC_FID_ALIASES
, adapter
);
870 void zfcp_fc_gs_destroy(struct zfcp_adapter
*adapter
)