4 * Fibre Channel related functions for the zfcp device driver.
6 * Copyright IBM Corporation 2008, 2009
9 #define KMSG_COMPONENT "zfcp"
10 #define pr_fmt(fmt) KMSG_COMPONENT ": " fmt
12 #include <linux/types.h>
13 #include <scsi/fc/fc_els.h>
14 #include <scsi/libfc.h>
18 static u32 zfcp_fc_rscn_range_mask
[] = {
19 [ELS_ADDR_FMT_PORT
] = 0xFFFFFF,
20 [ELS_ADDR_FMT_AREA
] = 0xFFFF00,
21 [ELS_ADDR_FMT_DOM
] = 0xFF0000,
22 [ELS_ADDR_FMT_FAB
] = 0x000000,
25 static int zfcp_fc_wka_port_get(struct zfcp_fc_wka_port
*wka_port
)
27 if (mutex_lock_interruptible(&wka_port
->mutex
))
30 if (wka_port
->status
== ZFCP_FC_WKA_PORT_OFFLINE
||
31 wka_port
->status
== ZFCP_FC_WKA_PORT_CLOSING
) {
32 wka_port
->status
= ZFCP_FC_WKA_PORT_OPENING
;
33 if (zfcp_fsf_open_wka_port(wka_port
))
34 wka_port
->status
= ZFCP_FC_WKA_PORT_OFFLINE
;
37 mutex_unlock(&wka_port
->mutex
);
39 wait_event(wka_port
->completion_wq
,
40 wka_port
->status
== ZFCP_FC_WKA_PORT_ONLINE
||
41 wka_port
->status
== ZFCP_FC_WKA_PORT_OFFLINE
);
43 if (wka_port
->status
== ZFCP_FC_WKA_PORT_ONLINE
) {
44 atomic_inc(&wka_port
->refcount
);
50 static void zfcp_fc_wka_port_offline(struct work_struct
*work
)
52 struct delayed_work
*dw
= to_delayed_work(work
);
53 struct zfcp_fc_wka_port
*wka_port
=
54 container_of(dw
, struct zfcp_fc_wka_port
, work
);
56 mutex_lock(&wka_port
->mutex
);
57 if ((atomic_read(&wka_port
->refcount
) != 0) ||
58 (wka_port
->status
!= ZFCP_FC_WKA_PORT_ONLINE
))
61 wka_port
->status
= ZFCP_FC_WKA_PORT_CLOSING
;
62 if (zfcp_fsf_close_wka_port(wka_port
)) {
63 wka_port
->status
= ZFCP_FC_WKA_PORT_OFFLINE
;
64 wake_up(&wka_port
->completion_wq
);
67 mutex_unlock(&wka_port
->mutex
);
70 static void zfcp_fc_wka_port_put(struct zfcp_fc_wka_port
*wka_port
)
72 if (atomic_dec_return(&wka_port
->refcount
) != 0)
74 /* wait 10 milliseconds, other reqs might pop in */
75 schedule_delayed_work(&wka_port
->work
, HZ
/ 100);
78 static void zfcp_fc_wka_port_init(struct zfcp_fc_wka_port
*wka_port
, u32 d_id
,
79 struct zfcp_adapter
*adapter
)
81 init_waitqueue_head(&wka_port
->completion_wq
);
83 wka_port
->adapter
= adapter
;
84 wka_port
->d_id
= d_id
;
86 wka_port
->status
= ZFCP_FC_WKA_PORT_OFFLINE
;
87 atomic_set(&wka_port
->refcount
, 0);
88 mutex_init(&wka_port
->mutex
);
89 INIT_DELAYED_WORK(&wka_port
->work
, zfcp_fc_wka_port_offline
);
92 static void zfcp_fc_wka_port_force_offline(struct zfcp_fc_wka_port
*wka
)
94 cancel_delayed_work_sync(&wka
->work
);
95 mutex_lock(&wka
->mutex
);
96 wka
->status
= ZFCP_FC_WKA_PORT_OFFLINE
;
97 mutex_unlock(&wka
->mutex
);
100 void zfcp_fc_wka_ports_force_offline(struct zfcp_fc_wka_ports
*gs
)
104 zfcp_fc_wka_port_force_offline(&gs
->ms
);
105 zfcp_fc_wka_port_force_offline(&gs
->ts
);
106 zfcp_fc_wka_port_force_offline(&gs
->ds
);
107 zfcp_fc_wka_port_force_offline(&gs
->as
);
110 static void _zfcp_fc_incoming_rscn(struct zfcp_fsf_req
*fsf_req
, u32 range
,
111 struct fc_els_rscn_page
*page
)
114 struct zfcp_adapter
*adapter
= fsf_req
->adapter
;
115 struct zfcp_port
*port
;
117 read_lock_irqsave(&adapter
->port_list_lock
, flags
);
118 list_for_each_entry(port
, &adapter
->port_list
, list
) {
119 if ((port
->d_id
& range
) == (ntoh24(page
->rscn_fid
) & range
))
120 zfcp_fc_test_link(port
);
122 zfcp_erp_port_reopen(port
,
123 ZFCP_STATUS_COMMON_ERP_FAILED
,
126 read_unlock_irqrestore(&adapter
->port_list_lock
, flags
);
129 static void zfcp_fc_incoming_rscn(struct zfcp_fsf_req
*fsf_req
)
131 struct fsf_status_read_buffer
*status_buffer
= (void *)fsf_req
->data
;
132 struct fc_els_rscn
*head
;
133 struct fc_els_rscn_page
*page
;
138 head
= (struct fc_els_rscn
*) status_buffer
->payload
.data
;
139 page
= (struct fc_els_rscn_page
*) head
;
142 no_entries
= head
->rscn_plen
/ sizeof(struct fc_els_rscn_page
);
144 for (i
= 1; i
< no_entries
; i
++) {
145 /* skip head and start with 1st element */
147 afmt
= page
->rscn_page_flags
& ELS_RSCN_ADDR_FMT_MASK
;
148 _zfcp_fc_incoming_rscn(fsf_req
, zfcp_fc_rscn_range_mask
[afmt
],
151 queue_work(fsf_req
->adapter
->work_queue
, &fsf_req
->adapter
->scan_work
);
154 static void zfcp_fc_incoming_wwpn(struct zfcp_fsf_req
*req
, u64 wwpn
)
157 struct zfcp_adapter
*adapter
= req
->adapter
;
158 struct zfcp_port
*port
;
160 read_lock_irqsave(&adapter
->port_list_lock
, flags
);
161 list_for_each_entry(port
, &adapter
->port_list
, list
)
162 if (port
->wwpn
== wwpn
) {
163 zfcp_erp_port_forced_reopen(port
, 0, "fciwwp1", req
);
166 read_unlock_irqrestore(&adapter
->port_list_lock
, flags
);
169 static void zfcp_fc_incoming_plogi(struct zfcp_fsf_req
*req
)
171 struct fsf_status_read_buffer
*status_buffer
;
172 struct fc_els_flogi
*plogi
;
174 status_buffer
= (struct fsf_status_read_buffer
*) req
->data
;
175 plogi
= (struct fc_els_flogi
*) status_buffer
->payload
.data
;
176 zfcp_fc_incoming_wwpn(req
, plogi
->fl_wwpn
);
179 static void zfcp_fc_incoming_logo(struct zfcp_fsf_req
*req
)
181 struct fsf_status_read_buffer
*status_buffer
=
182 (struct fsf_status_read_buffer
*)req
->data
;
183 struct fc_els_logo
*logo
=
184 (struct fc_els_logo
*) status_buffer
->payload
.data
;
186 zfcp_fc_incoming_wwpn(req
, logo
->fl_n_port_wwn
);
190 * zfcp_fc_incoming_els - handle incoming ELS
191 * @fsf_req - request which contains incoming ELS
193 void zfcp_fc_incoming_els(struct zfcp_fsf_req
*fsf_req
)
195 struct fsf_status_read_buffer
*status_buffer
=
196 (struct fsf_status_read_buffer
*) fsf_req
->data
;
197 unsigned int els_type
= status_buffer
->payload
.data
[0];
199 zfcp_dbf_san_incoming_els(fsf_req
);
200 if (els_type
== ELS_PLOGI
)
201 zfcp_fc_incoming_plogi(fsf_req
);
202 else if (els_type
== ELS_LOGO
)
203 zfcp_fc_incoming_logo(fsf_req
);
204 else if (els_type
== ELS_RSCN
)
205 zfcp_fc_incoming_rscn(fsf_req
);
208 static void zfcp_fc_ns_gid_pn_eval(void *data
)
210 struct zfcp_fc_gid_pn
*gid_pn
= data
;
211 struct zfcp_fsf_ct_els
*ct
= &gid_pn
->ct
;
212 struct zfcp_fc_gid_pn_req
*gid_pn_req
= sg_virt(ct
->req
);
213 struct zfcp_fc_gid_pn_resp
*gid_pn_resp
= sg_virt(ct
->resp
);
214 struct zfcp_port
*port
= gid_pn
->port
;
218 if (gid_pn_resp
->ct_hdr
.ct_cmd
!= FC_FS_ACC
)
222 if (gid_pn_req
->gid_pn
.fn_wwpn
!= port
->wwpn
)
224 /* looks like a valid d_id */
225 port
->d_id
= ntoh24(gid_pn_resp
->gid_pn
.fp_fid
);
228 static void zfcp_fc_complete(void *data
)
233 static int zfcp_fc_ns_gid_pn_request(struct zfcp_port
*port
,
234 struct zfcp_fc_gid_pn
*gid_pn
)
236 struct zfcp_adapter
*adapter
= port
->adapter
;
237 DECLARE_COMPLETION_ONSTACK(completion
);
240 /* setup parameters for send generic command */
242 gid_pn
->ct
.handler
= zfcp_fc_complete
;
243 gid_pn
->ct
.handler_data
= &completion
;
244 gid_pn
->ct
.req
= &gid_pn
->sg_req
;
245 gid_pn
->ct
.resp
= &gid_pn
->sg_resp
;
246 sg_init_one(&gid_pn
->sg_req
, &gid_pn
->gid_pn_req
,
247 sizeof(struct zfcp_fc_gid_pn_req
));
248 sg_init_one(&gid_pn
->sg_resp
, &gid_pn
->gid_pn_resp
,
249 sizeof(struct zfcp_fc_gid_pn_resp
));
251 /* setup nameserver request */
252 gid_pn
->gid_pn_req
.ct_hdr
.ct_rev
= FC_CT_REV
;
253 gid_pn
->gid_pn_req
.ct_hdr
.ct_fs_type
= FC_FST_DIR
;
254 gid_pn
->gid_pn_req
.ct_hdr
.ct_fs_subtype
= FC_NS_SUBTYPE
;
255 gid_pn
->gid_pn_req
.ct_hdr
.ct_options
= 0;
256 gid_pn
->gid_pn_req
.ct_hdr
.ct_cmd
= FC_NS_GID_PN
;
257 gid_pn
->gid_pn_req
.ct_hdr
.ct_mr_size
= ZFCP_FC_CT_SIZE_PAGE
/ 4;
258 gid_pn
->gid_pn_req
.gid_pn
.fn_wwpn
= port
->wwpn
;
260 ret
= zfcp_fsf_send_ct(&adapter
->gs
->ds
, &gid_pn
->ct
,
261 adapter
->pool
.gid_pn_req
);
263 wait_for_completion(&completion
);
264 zfcp_fc_ns_gid_pn_eval(gid_pn
);
270 * zfcp_fc_ns_gid_pn_request - initiate GID_PN nameserver request
271 * @port: port where GID_PN request is needed
272 * return: -ENOMEM on error, 0 otherwise
274 static int zfcp_fc_ns_gid_pn(struct zfcp_port
*port
)
277 struct zfcp_fc_gid_pn
*gid_pn
;
278 struct zfcp_adapter
*adapter
= port
->adapter
;
280 gid_pn
= mempool_alloc(adapter
->pool
.gid_pn
, GFP_ATOMIC
);
284 memset(gid_pn
, 0, sizeof(*gid_pn
));
286 ret
= zfcp_fc_wka_port_get(&adapter
->gs
->ds
);
290 ret
= zfcp_fc_ns_gid_pn_request(port
, gid_pn
);
292 zfcp_fc_wka_port_put(&adapter
->gs
->ds
);
294 mempool_free(gid_pn
, adapter
->pool
.gid_pn
);
298 void zfcp_fc_port_did_lookup(struct work_struct
*work
)
301 struct zfcp_port
*port
= container_of(work
, struct zfcp_port
,
304 ret
= zfcp_fc_ns_gid_pn(port
);
306 /* could not issue gid_pn for some reason */
307 zfcp_erp_adapter_reopen(port
->adapter
, 0, "fcgpn_1", NULL
);
312 zfcp_erp_port_failed(port
, "fcgpn_2", NULL
);
316 zfcp_erp_port_reopen(port
, 0, "fcgpn_3", NULL
);
318 put_device(&port
->sysfs_device
);
322 * zfcp_fc_trigger_did_lookup - trigger the d_id lookup using a GID_PN request
323 * @port: The zfcp_port to lookup the d_id for.
325 void zfcp_fc_trigger_did_lookup(struct zfcp_port
*port
)
327 get_device(&port
->sysfs_device
);
328 if (!queue_work(port
->adapter
->work_queue
, &port
->gid_pn_work
))
329 put_device(&port
->sysfs_device
);
333 * zfcp_fc_plogi_evaluate - evaluate PLOGI playload
334 * @port: zfcp_port structure
335 * @plogi: plogi payload
337 * Evaluate PLOGI playload and copy important fields into zfcp_port structure
339 void zfcp_fc_plogi_evaluate(struct zfcp_port
*port
, struct fc_els_flogi
*plogi
)
341 if (plogi
->fl_wwpn
!= port
->wwpn
) {
343 dev_warn(&port
->adapter
->ccw_device
->dev
,
344 "A port opened with WWPN 0x%016Lx returned data that "
345 "identifies it as WWPN 0x%016Lx\n",
346 (unsigned long long) port
->wwpn
,
347 (unsigned long long) plogi
->fl_wwpn
);
351 port
->wwnn
= plogi
->fl_wwnn
;
352 port
->maxframe_size
= plogi
->fl_csp
.sp_bb_data
;
354 if (plogi
->fl_cssp
[0].cp_class
& FC_CPC_VALID
)
355 port
->supported_classes
|= FC_COS_CLASS1
;
356 if (plogi
->fl_cssp
[1].cp_class
& FC_CPC_VALID
)
357 port
->supported_classes
|= FC_COS_CLASS2
;
358 if (plogi
->fl_cssp
[2].cp_class
& FC_CPC_VALID
)
359 port
->supported_classes
|= FC_COS_CLASS3
;
360 if (plogi
->fl_cssp
[3].cp_class
& FC_CPC_VALID
)
361 port
->supported_classes
|= FC_COS_CLASS4
;
364 static void zfcp_fc_adisc_handler(void *data
)
366 struct zfcp_fc_els_adisc
*adisc
= data
;
367 struct zfcp_port
*port
= adisc
->els
.port
;
368 struct fc_els_adisc
*adisc_resp
= &adisc
->adisc_resp
;
370 if (adisc
->els
.status
) {
371 /* request rejected or timed out */
372 zfcp_erp_port_forced_reopen(port
, ZFCP_STATUS_COMMON_ERP_FAILED
,
378 port
->wwnn
= adisc_resp
->adisc_wwnn
;
380 if ((port
->wwpn
!= adisc_resp
->adisc_wwpn
) ||
381 !(atomic_read(&port
->status
) & ZFCP_STATUS_COMMON_OPEN
)) {
382 zfcp_erp_port_reopen(port
, ZFCP_STATUS_COMMON_ERP_FAILED
,
387 /* port is good, unblock rport without going through erp */
388 zfcp_scsi_schedule_rport_register(port
);
390 atomic_clear_mask(ZFCP_STATUS_PORT_LINK_TEST
, &port
->status
);
391 put_device(&port
->sysfs_device
);
392 kmem_cache_free(zfcp_data
.adisc_cache
, adisc
);
395 static int zfcp_fc_adisc(struct zfcp_port
*port
)
397 struct zfcp_fc_els_adisc
*adisc
;
398 struct zfcp_adapter
*adapter
= port
->adapter
;
401 adisc
= kmem_cache_alloc(zfcp_data
.adisc_cache
, GFP_ATOMIC
);
405 adisc
->els
.port
= port
;
406 adisc
->els
.req
= &adisc
->req
;
407 adisc
->els
.resp
= &adisc
->resp
;
408 sg_init_one(adisc
->els
.req
, &adisc
->adisc_req
,
409 sizeof(struct fc_els_adisc
));
410 sg_init_one(adisc
->els
.resp
, &adisc
->adisc_resp
,
411 sizeof(struct fc_els_adisc
));
413 adisc
->els
.handler
= zfcp_fc_adisc_handler
;
414 adisc
->els
.handler_data
= 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
->adisc_req
.adisc_wwpn
= fc_host_port_name(adapter
->scsi_host
);
419 adisc
->adisc_req
.adisc_wwnn
= fc_host_node_name(adapter
->scsi_host
);
420 adisc
->adisc_req
.adisc_cmd
= ELS_ADISC
;
421 hton24(adisc
->adisc_req
.adisc_port_id
,
422 fc_host_port_id(adapter
->scsi_host
));
424 ret
= zfcp_fsf_send_els(adapter
, port
->d_id
, &adisc
->els
);
426 kmem_cache_free(zfcp_data
.adisc_cache
, adisc
);
431 void zfcp_fc_link_test_work(struct work_struct
*work
)
433 struct zfcp_port
*port
=
434 container_of(work
, struct zfcp_port
, test_link_work
);
437 get_device(&port
->sysfs_device
);
438 port
->rport_task
= RPORT_DEL
;
439 zfcp_scsi_rport_work(&port
->rport_work
);
441 /* only issue one test command at one time per port */
442 if (atomic_read(&port
->status
) & ZFCP_STATUS_PORT_LINK_TEST
)
445 atomic_set_mask(ZFCP_STATUS_PORT_LINK_TEST
, &port
->status
);
447 retval
= zfcp_fc_adisc(port
);
451 /* send of ADISC was not possible */
452 atomic_clear_mask(ZFCP_STATUS_PORT_LINK_TEST
, &port
->status
);
453 zfcp_erp_port_forced_reopen(port
, 0, "fcltwk1", NULL
);
456 put_device(&port
->sysfs_device
);
460 * zfcp_fc_test_link - lightweight link test procedure
461 * @port: port to be tested
463 * Test status of a link to a remote port using the ELS command ADISC.
464 * If there is a problem with the remote port, error recovery steps
467 void zfcp_fc_test_link(struct zfcp_port
*port
)
469 get_device(&port
->sysfs_device
);
470 if (!queue_work(port
->adapter
->work_queue
, &port
->test_link_work
))
471 put_device(&port
->sysfs_device
);
474 static void zfcp_free_sg_env(struct zfcp_fc_gpn_ft
*gpn_ft
, int buf_num
)
476 struct scatterlist
*sg
= &gpn_ft
->sg_req
;
478 kmem_cache_free(zfcp_data
.gpn_ft_cache
, sg_virt(sg
));
479 zfcp_sg_free_table(gpn_ft
->sg_resp
, buf_num
);
484 static struct zfcp_fc_gpn_ft
*zfcp_alloc_sg_env(int buf_num
)
486 struct zfcp_fc_gpn_ft
*gpn_ft
;
487 struct zfcp_fc_gpn_ft_req
*req
;
489 gpn_ft
= kzalloc(sizeof(*gpn_ft
), GFP_KERNEL
);
493 req
= kmem_cache_alloc(zfcp_data
.gpn_ft_cache
, GFP_KERNEL
);
499 sg_init_one(&gpn_ft
->sg_req
, req
, sizeof(*req
));
501 if (zfcp_sg_setup_table(gpn_ft
->sg_resp
, buf_num
)) {
502 zfcp_free_sg_env(gpn_ft
, buf_num
);
510 static int zfcp_fc_send_gpn_ft(struct zfcp_fc_gpn_ft
*gpn_ft
,
511 struct zfcp_adapter
*adapter
, int max_bytes
)
513 struct zfcp_fsf_ct_els
*ct
= &gpn_ft
->ct
;
514 struct zfcp_fc_gpn_ft_req
*req
= sg_virt(&gpn_ft
->sg_req
);
515 DECLARE_COMPLETION_ONSTACK(completion
);
518 /* prepare CT IU for GPN_FT */
519 req
->ct_hdr
.ct_rev
= FC_CT_REV
;
520 req
->ct_hdr
.ct_fs_type
= FC_FST_DIR
;
521 req
->ct_hdr
.ct_fs_subtype
= FC_NS_SUBTYPE
;
522 req
->ct_hdr
.ct_options
= 0;
523 req
->ct_hdr
.ct_cmd
= FC_NS_GPN_FT
;
524 req
->ct_hdr
.ct_mr_size
= max_bytes
/ 4;
525 req
->gpn_ft
.fn_domain_id_scope
= 0;
526 req
->gpn_ft
.fn_area_id_scope
= 0;
527 req
->gpn_ft
.fn_fc4_type
= FC_TYPE_FCP
;
529 /* prepare zfcp_send_ct */
530 ct
->handler
= zfcp_fc_complete
;
531 ct
->handler_data
= &completion
;
532 ct
->req
= &gpn_ft
->sg_req
;
533 ct
->resp
= gpn_ft
->sg_resp
;
535 ret
= zfcp_fsf_send_ct(&adapter
->gs
->ds
, ct
, NULL
);
537 wait_for_completion(&completion
);
541 static void zfcp_fc_validate_port(struct zfcp_port
*port
, struct list_head
*lh
)
543 if (!(atomic_read(&port
->status
) & ZFCP_STATUS_COMMON_NOESC
))
546 atomic_clear_mask(ZFCP_STATUS_COMMON_NOESC
, &port
->status
);
548 if ((port
->supported_classes
!= 0) ||
549 !list_empty(&port
->unit_list
))
552 list_move_tail(&port
->list
, lh
);
555 static int zfcp_fc_eval_gpn_ft(struct zfcp_fc_gpn_ft
*gpn_ft
,
556 struct zfcp_adapter
*adapter
, int max_entries
)
558 struct zfcp_fsf_ct_els
*ct
= &gpn_ft
->ct
;
559 struct scatterlist
*sg
= gpn_ft
->sg_resp
;
560 struct fc_ct_hdr
*hdr
= sg_virt(sg
);
561 struct fc_gpn_ft_resp
*acc
= sg_virt(sg
);
562 struct zfcp_port
*port
, *tmp
;
564 LIST_HEAD(remove_lh
);
566 int ret
= 0, x
, last
= 0;
571 if (hdr
->ct_cmd
!= FC_FS_ACC
) {
572 if (hdr
->ct_reason
== FC_BA_RJT_UNABLE
)
573 return -EAGAIN
; /* might be a temporary condition */
577 if (hdr
->ct_mr_size
) {
578 dev_warn(&adapter
->ccw_device
->dev
,
579 "The name server reported %d words residual data\n",
584 /* first entry is the header */
585 for (x
= 1; x
< max_entries
&& !last
; x
++) {
586 if (x
% (ZFCP_FC_GPN_FT_ENT_PAGE
+ 1))
591 last
= acc
->fp_flags
& FC_NS_FID_LAST
;
592 d_id
= ntoh24(acc
->fp_fid
);
594 /* don't attach ports with a well known address */
595 if (d_id
>= FC_FID_WELL_KNOWN_BASE
)
597 /* skip the adapter's port and known remote ports */
598 if (acc
->fp_wwpn
== fc_host_port_name(adapter
->scsi_host
))
601 port
= zfcp_port_enqueue(adapter
, acc
->fp_wwpn
,
602 ZFCP_STATUS_COMMON_NOESC
, d_id
);
604 zfcp_erp_port_reopen(port
, 0, "fcegpf1", NULL
);
605 else if (PTR_ERR(port
) != -EEXIST
)
609 zfcp_erp_wait(adapter
);
610 write_lock_irqsave(&adapter
->port_list_lock
, flags
);
611 list_for_each_entry_safe(port
, tmp
, &adapter
->port_list
, list
)
612 zfcp_fc_validate_port(port
, &remove_lh
);
613 write_unlock_irqrestore(&adapter
->port_list_lock
, flags
);
615 list_for_each_entry_safe(port
, tmp
, &remove_lh
, list
) {
616 zfcp_erp_port_shutdown(port
, 0, "fcegpf2", NULL
);
617 zfcp_device_unregister(&port
->sysfs_device
,
618 &zfcp_sysfs_port_attrs
);
625 * zfcp_fc_scan_ports - scan remote ports and attach new ports
626 * @work: reference to scheduled work
628 void zfcp_fc_scan_ports(struct work_struct
*work
)
630 struct zfcp_adapter
*adapter
= container_of(work
, struct zfcp_adapter
,
633 struct zfcp_fc_gpn_ft
*gpn_ft
;
634 int chain
, max_entries
, buf_num
, max_bytes
;
636 chain
= adapter
->adapter_features
& FSF_FEATURE_ELS_CT_CHAINED_SBALS
;
637 buf_num
= chain
? ZFCP_FC_GPN_FT_NUM_BUFS
: 1;
638 max_entries
= chain
? ZFCP_FC_GPN_FT_MAX_ENT
: ZFCP_FC_GPN_FT_ENT_PAGE
;
639 max_bytes
= chain
? ZFCP_FC_GPN_FT_MAX_SIZE
: ZFCP_FC_CT_SIZE_PAGE
;
641 if (fc_host_port_type(adapter
->scsi_host
) != FC_PORTTYPE_NPORT
&&
642 fc_host_port_type(adapter
->scsi_host
) != FC_PORTTYPE_NPIV
)
645 if (zfcp_fc_wka_port_get(&adapter
->gs
->ds
))
648 gpn_ft
= zfcp_alloc_sg_env(buf_num
);
652 for (i
= 0; i
< 3; i
++) {
653 ret
= zfcp_fc_send_gpn_ft(gpn_ft
, adapter
, max_bytes
);
655 ret
= zfcp_fc_eval_gpn_ft(gpn_ft
, adapter
, max_entries
);
662 zfcp_free_sg_env(gpn_ft
, buf_num
);
664 zfcp_fc_wka_port_put(&adapter
->gs
->ds
);
667 static void zfcp_fc_ct_els_job_handler(void *data
)
669 struct fc_bsg_job
*job
= data
;
670 struct zfcp_fsf_ct_els
*zfcp_ct_els
= job
->dd_data
;
671 int status
= zfcp_ct_els
->status
;
674 reply_status
= status
? FC_CTELS_STATUS_REJECT
: FC_CTELS_STATUS_OK
;
675 job
->reply
->reply_data
.ctels_reply
.status
= reply_status
;
676 job
->reply
->reply_payload_rcv_len
= job
->reply_payload
.payload_len
;
680 static struct zfcp_fc_wka_port
*zfcp_fc_job_wka_port(struct fc_bsg_job
*job
)
684 struct zfcp_adapter
*adapter
;
686 preamble_word1
= job
->request
->rqst_data
.r_ct
.preamble_word1
;
687 gs_type
= (preamble_word1
& 0xff000000) >> 24;
689 adapter
= (struct zfcp_adapter
*) job
->shost
->hostdata
[0];
693 return &adapter
->gs
->as
;
695 return &adapter
->gs
->ms
;
697 return &adapter
->gs
->ts
;
700 return &adapter
->gs
->ds
;
707 static void zfcp_fc_ct_job_handler(void *data
)
709 struct fc_bsg_job
*job
= data
;
710 struct zfcp_fc_wka_port
*wka_port
;
712 wka_port
= zfcp_fc_job_wka_port(job
);
713 zfcp_fc_wka_port_put(wka_port
);
715 zfcp_fc_ct_els_job_handler(data
);
718 static int zfcp_fc_exec_els_job(struct fc_bsg_job
*job
,
719 struct zfcp_adapter
*adapter
)
721 struct zfcp_fsf_ct_els
*els
= job
->dd_data
;
722 struct fc_rport
*rport
= job
->rport
;
723 struct zfcp_port
*port
;
727 port
= zfcp_get_port_by_wwpn(adapter
, rport
->port_name
);
732 put_device(&port
->sysfs_device
);
734 d_id
= ntoh24(job
->request
->rqst_data
.h_els
.port_id
);
736 els
->handler
= zfcp_fc_ct_els_job_handler
;
737 return zfcp_fsf_send_els(adapter
, d_id
, els
);
740 static int zfcp_fc_exec_ct_job(struct fc_bsg_job
*job
,
741 struct zfcp_adapter
*adapter
)
744 struct zfcp_fsf_ct_els
*ct
= job
->dd_data
;
745 struct zfcp_fc_wka_port
*wka_port
;
747 wka_port
= zfcp_fc_job_wka_port(job
);
751 ret
= zfcp_fc_wka_port_get(wka_port
);
755 ct
->handler
= zfcp_fc_ct_job_handler
;
756 ret
= zfcp_fsf_send_ct(wka_port
, ct
, NULL
);
758 zfcp_fc_wka_port_put(wka_port
);
763 int zfcp_fc_exec_bsg_job(struct fc_bsg_job
*job
)
765 struct Scsi_Host
*shost
;
766 struct zfcp_adapter
*adapter
;
767 struct zfcp_fsf_ct_els
*ct_els
= job
->dd_data
;
769 shost
= job
->rport
? rport_to_shost(job
->rport
) : job
->shost
;
770 adapter
= (struct zfcp_adapter
*)shost
->hostdata
[0];
772 if (!(atomic_read(&adapter
->status
) & ZFCP_STATUS_COMMON_OPEN
))
775 ct_els
->req
= job
->request_payload
.sg_list
;
776 ct_els
->resp
= job
->reply_payload
.sg_list
;
777 ct_els
->handler_data
= job
;
779 switch (job
->request
->msgcode
) {
781 case FC_BSG_HST_ELS_NOLOGIN
:
782 return zfcp_fc_exec_els_job(job
, adapter
);
785 return zfcp_fc_exec_ct_job(job
, adapter
);
791 int zfcp_fc_timeout_bsg_job(struct fc_bsg_job
*job
)
793 /* hardware tracks timeout, reset bsg timeout to not interfere */
797 int zfcp_fc_gs_setup(struct zfcp_adapter
*adapter
)
799 struct zfcp_fc_wka_ports
*wka_ports
;
801 wka_ports
= kzalloc(sizeof(struct zfcp_fc_wka_ports
), GFP_KERNEL
);
805 adapter
->gs
= wka_ports
;
806 zfcp_fc_wka_port_init(&wka_ports
->ms
, FC_FID_MGMT_SERV
, adapter
);
807 zfcp_fc_wka_port_init(&wka_ports
->ts
, FC_FID_TIME_SERV
, adapter
);
808 zfcp_fc_wka_port_init(&wka_ports
->ds
, FC_FID_DIR_SERV
, adapter
);
809 zfcp_fc_wka_port_init(&wka_ports
->as
, FC_FID_ALIASES
, adapter
);
814 void zfcp_fc_gs_destroy(struct zfcp_adapter
*adapter
)