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
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 gpn_ft_resp_acc
{
33 } __attribute__ ((packed
));
35 #define ZFCP_CT_SIZE_ONE_PAGE (PAGE_SIZE - sizeof(struct ct_hdr))
36 #define ZFCP_GPN_FT_ENTRIES (ZFCP_CT_SIZE_ONE_PAGE \
37 / sizeof(struct gpn_ft_resp_acc))
38 #define ZFCP_GPN_FT_BUFFERS 4
39 #define ZFCP_GPN_FT_MAX_SIZE (ZFCP_GPN_FT_BUFFERS * PAGE_SIZE \
40 - sizeof(struct ct_hdr))
41 #define ZFCP_GPN_FT_MAX_ENTRIES ZFCP_GPN_FT_BUFFERS * (ZFCP_GPN_FT_ENTRIES + 1)
43 struct ct_iu_gpn_ft_resp
{
45 struct gpn_ft_resp_acc accept
[ZFCP_GPN_FT_ENTRIES
];
46 } __attribute__ ((packed
));
49 struct zfcp_send_ct ct
;
50 struct scatterlist sg_req
;
51 struct scatterlist sg_resp
[ZFCP_GPN_FT_BUFFERS
];
54 struct zfcp_fc_ns_handler_data
{
55 struct completion done
;
56 void (*handler
)(unsigned long);
57 unsigned long handler_data
;
60 static int zfcp_fc_wka_port_get(struct zfcp_wka_port
*wka_port
)
62 if (mutex_lock_interruptible(&wka_port
->mutex
))
65 if (wka_port
->status
== ZFCP_WKA_PORT_OFFLINE
||
66 wka_port
->status
== ZFCP_WKA_PORT_CLOSING
) {
67 wka_port
->status
= ZFCP_WKA_PORT_OPENING
;
68 if (zfcp_fsf_open_wka_port(wka_port
))
69 wka_port
->status
= ZFCP_WKA_PORT_OFFLINE
;
72 mutex_unlock(&wka_port
->mutex
);
74 wait_event(wka_port
->completion_wq
,
75 wka_port
->status
== ZFCP_WKA_PORT_ONLINE
||
76 wka_port
->status
== ZFCP_WKA_PORT_OFFLINE
);
78 if (wka_port
->status
== ZFCP_WKA_PORT_ONLINE
) {
79 atomic_inc(&wka_port
->refcount
);
85 static void zfcp_fc_wka_port_offline(struct work_struct
*work
)
87 struct delayed_work
*dw
= to_delayed_work(work
);
88 struct zfcp_wka_port
*wka_port
=
89 container_of(dw
, struct zfcp_wka_port
, work
);
91 mutex_lock(&wka_port
->mutex
);
92 if ((atomic_read(&wka_port
->refcount
) != 0) ||
93 (wka_port
->status
!= ZFCP_WKA_PORT_ONLINE
))
96 wka_port
->status
= ZFCP_WKA_PORT_CLOSING
;
97 if (zfcp_fsf_close_wka_port(wka_port
)) {
98 wka_port
->status
= ZFCP_WKA_PORT_OFFLINE
;
99 wake_up(&wka_port
->completion_wq
);
102 mutex_unlock(&wka_port
->mutex
);
105 static void zfcp_fc_wka_port_put(struct zfcp_wka_port
*wka_port
)
107 if (atomic_dec_return(&wka_port
->refcount
) != 0)
109 /* wait 10 milliseconds, other reqs might pop in */
110 schedule_delayed_work(&wka_port
->work
, HZ
/ 100);
113 static void zfcp_fc_wka_port_init(struct zfcp_wka_port
*wka_port
, u32 d_id
,
114 struct zfcp_adapter
*adapter
)
116 init_waitqueue_head(&wka_port
->completion_wq
);
118 wka_port
->adapter
= adapter
;
119 wka_port
->d_id
= d_id
;
121 wka_port
->status
= ZFCP_WKA_PORT_OFFLINE
;
122 atomic_set(&wka_port
->refcount
, 0);
123 mutex_init(&wka_port
->mutex
);
124 INIT_DELAYED_WORK(&wka_port
->work
, zfcp_fc_wka_port_offline
);
127 static void zfcp_fc_wka_port_force_offline(struct zfcp_wka_port
*wka
)
129 cancel_delayed_work_sync(&wka
->work
);
130 mutex_lock(&wka
->mutex
);
131 wka
->status
= ZFCP_WKA_PORT_OFFLINE
;
132 mutex_unlock(&wka
->mutex
);
135 void zfcp_fc_wka_ports_force_offline(struct zfcp_wka_ports
*gs
)
137 zfcp_fc_wka_port_force_offline(&gs
->ms
);
138 zfcp_fc_wka_port_force_offline(&gs
->ts
);
139 zfcp_fc_wka_port_force_offline(&gs
->ds
);
140 zfcp_fc_wka_port_force_offline(&gs
->as
);
141 zfcp_fc_wka_port_force_offline(&gs
->ks
);
144 static void _zfcp_fc_incoming_rscn(struct zfcp_fsf_req
*fsf_req
, u32 range
,
145 struct fcp_rscn_element
*elem
)
148 struct zfcp_port
*port
;
150 read_lock_irqsave(&zfcp_data
.config_lock
, flags
);
151 list_for_each_entry(port
, &fsf_req
->adapter
->port_list_head
, list
) {
152 if ((port
->d_id
& range
) == (elem
->nport_did
& range
))
153 zfcp_fc_test_link(port
);
155 zfcp_erp_port_reopen(port
,
156 ZFCP_STATUS_COMMON_ERP_FAILED
,
160 read_unlock_irqrestore(&zfcp_data
.config_lock
, flags
);
163 static void zfcp_fc_incoming_rscn(struct zfcp_fsf_req
*fsf_req
)
165 struct fsf_status_read_buffer
*status_buffer
= (void *)fsf_req
->data
;
166 struct fcp_rscn_head
*fcp_rscn_head
;
167 struct fcp_rscn_element
*fcp_rscn_element
;
172 fcp_rscn_head
= (struct fcp_rscn_head
*) status_buffer
->payload
.data
;
173 fcp_rscn_element
= (struct fcp_rscn_element
*) fcp_rscn_head
;
176 no_entries
= fcp_rscn_head
->payload_len
/
177 sizeof(struct fcp_rscn_element
);
179 for (i
= 1; i
< no_entries
; i
++) {
180 /* skip head and start with 1st element */
182 range_mask
= rscn_range_mask
[fcp_rscn_element
->addr_format
];
183 _zfcp_fc_incoming_rscn(fsf_req
, range_mask
, fcp_rscn_element
);
185 schedule_work(&fsf_req
->adapter
->scan_work
);
188 static void zfcp_fc_incoming_wwpn(struct zfcp_fsf_req
*req
, u64 wwpn
)
190 struct zfcp_adapter
*adapter
= req
->adapter
;
191 struct zfcp_port
*port
;
194 read_lock_irqsave(&zfcp_data
.config_lock
, flags
);
195 list_for_each_entry(port
, &adapter
->port_list_head
, list
)
196 if (port
->wwpn
== wwpn
)
198 read_unlock_irqrestore(&zfcp_data
.config_lock
, flags
);
200 if (port
&& (port
->wwpn
== wwpn
))
201 zfcp_erp_port_forced_reopen(port
, 0, "fciwwp1", req
);
204 static void zfcp_fc_incoming_plogi(struct zfcp_fsf_req
*req
)
206 struct fsf_status_read_buffer
*status_buffer
=
207 (struct fsf_status_read_buffer
*)req
->data
;
208 struct fsf_plogi
*els_plogi
=
209 (struct fsf_plogi
*) status_buffer
->payload
.data
;
211 zfcp_fc_incoming_wwpn(req
, els_plogi
->serv_param
.wwpn
);
214 static void zfcp_fc_incoming_logo(struct zfcp_fsf_req
*req
)
216 struct fsf_status_read_buffer
*status_buffer
=
217 (struct fsf_status_read_buffer
*)req
->data
;
218 struct fcp_logo
*els_logo
=
219 (struct fcp_logo
*) status_buffer
->payload
.data
;
221 zfcp_fc_incoming_wwpn(req
, els_logo
->nport_wwpn
);
225 * zfcp_fc_incoming_els - handle incoming ELS
226 * @fsf_req - request which contains incoming ELS
228 void zfcp_fc_incoming_els(struct zfcp_fsf_req
*fsf_req
)
230 struct fsf_status_read_buffer
*status_buffer
=
231 (struct fsf_status_read_buffer
*) fsf_req
->data
;
232 unsigned int els_type
= status_buffer
->payload
.data
[0];
234 zfcp_dbf_san_incoming_els(fsf_req
);
235 if (els_type
== LS_PLOGI
)
236 zfcp_fc_incoming_plogi(fsf_req
);
237 else if (els_type
== LS_LOGO
)
238 zfcp_fc_incoming_logo(fsf_req
);
239 else if (els_type
== LS_RSCN
)
240 zfcp_fc_incoming_rscn(fsf_req
);
243 static void zfcp_fc_ns_handler(unsigned long data
)
245 struct zfcp_fc_ns_handler_data
*compl_rec
=
246 (struct zfcp_fc_ns_handler_data
*) data
;
248 if (compl_rec
->handler
)
249 compl_rec
->handler(compl_rec
->handler_data
);
251 complete(&compl_rec
->done
);
254 static void zfcp_fc_ns_gid_pn_eval(unsigned long data
)
256 struct zfcp_gid_pn_data
*gid_pn
= (struct zfcp_gid_pn_data
*) data
;
257 struct zfcp_send_ct
*ct
= &gid_pn
->ct
;
258 struct ct_iu_gid_pn_req
*ct_iu_req
= sg_virt(ct
->req
);
259 struct ct_iu_gid_pn_resp
*ct_iu_resp
= sg_virt(ct
->resp
);
260 struct zfcp_port
*port
= gid_pn
->port
;
264 if (ct_iu_resp
->header
.cmd_rsp_code
!= ZFCP_CT_ACCEPT
)
268 if (ct_iu_req
->wwpn
!= port
->wwpn
)
270 /* looks like a valid d_id */
271 port
->d_id
= ct_iu_resp
->d_id
& ZFCP_DID_MASK
;
274 static int zfcp_fc_ns_gid_pn_request(struct zfcp_port
*port
,
275 struct zfcp_gid_pn_data
*gid_pn
)
277 struct zfcp_adapter
*adapter
= port
->adapter
;
278 struct zfcp_fc_ns_handler_data compl_rec
;
281 /* setup parameters for send generic command */
283 gid_pn
->ct
.wka_port
= &adapter
->gs
->ds
;
284 gid_pn
->ct
.handler
= zfcp_fc_ns_handler
;
285 gid_pn
->ct
.handler_data
= (unsigned long) &compl_rec
;
286 gid_pn
->ct
.timeout
= ZFCP_NS_GID_PN_TIMEOUT
;
287 gid_pn
->ct
.req
= &gid_pn
->req
;
288 gid_pn
->ct
.resp
= &gid_pn
->resp
;
289 sg_init_one(&gid_pn
->req
, &gid_pn
->ct_iu_req
,
290 sizeof(struct ct_iu_gid_pn_req
));
291 sg_init_one(&gid_pn
->resp
, &gid_pn
->ct_iu_resp
,
292 sizeof(struct ct_iu_gid_pn_resp
));
294 /* setup nameserver request */
295 gid_pn
->ct_iu_req
.header
.revision
= ZFCP_CT_REVISION
;
296 gid_pn
->ct_iu_req
.header
.gs_type
= ZFCP_CT_DIRECTORY_SERVICE
;
297 gid_pn
->ct_iu_req
.header
.gs_subtype
= ZFCP_CT_NAME_SERVER
;
298 gid_pn
->ct_iu_req
.header
.options
= ZFCP_CT_SYNCHRONOUS
;
299 gid_pn
->ct_iu_req
.header
.cmd_rsp_code
= ZFCP_CT_GID_PN
;
300 gid_pn
->ct_iu_req
.header
.max_res_size
= ZFCP_CT_SIZE_ONE_PAGE
/ 4;
301 gid_pn
->ct_iu_req
.wwpn
= port
->wwpn
;
303 init_completion(&compl_rec
.done
);
304 compl_rec
.handler
= zfcp_fc_ns_gid_pn_eval
;
305 compl_rec
.handler_data
= (unsigned long) gid_pn
;
306 ret
= zfcp_fsf_send_ct(&gid_pn
->ct
, adapter
->pool
.gid_pn_req
);
308 wait_for_completion(&compl_rec
.done
);
313 * zfcp_fc_ns_gid_pn_request - initiate GID_PN nameserver request
314 * @port: port where GID_PN request is needed
315 * return: -ENOMEM on error, 0 otherwise
317 static int zfcp_fc_ns_gid_pn(struct zfcp_port
*port
)
320 struct zfcp_gid_pn_data
*gid_pn
;
321 struct zfcp_adapter
*adapter
= port
->adapter
;
323 gid_pn
= mempool_alloc(adapter
->pool
.gid_pn_data
, GFP_ATOMIC
);
327 memset(gid_pn
, 0, sizeof(*gid_pn
));
329 ret
= zfcp_fc_wka_port_get(&adapter
->gs
->ds
);
333 ret
= zfcp_fc_ns_gid_pn_request(port
, gid_pn
);
335 zfcp_fc_wka_port_put(&adapter
->gs
->ds
);
337 mempool_free(gid_pn
, adapter
->pool
.gid_pn_data
);
341 void zfcp_fc_port_did_lookup(struct work_struct
*work
)
344 struct zfcp_port
*port
= container_of(work
, struct zfcp_port
,
347 ret
= zfcp_fc_ns_gid_pn(port
);
349 /* could not issue gid_pn for some reason */
350 zfcp_erp_adapter_reopen(port
->adapter
, 0, "fcgpn_1", NULL
);
355 zfcp_erp_port_failed(port
, "fcgpn_2", NULL
);
359 zfcp_erp_port_reopen(port
, 0, "fcgpn_3", NULL
);
365 * zfcp_fc_plogi_evaluate - evaluate PLOGI playload
366 * @port: zfcp_port structure
367 * @plogi: plogi payload
369 * Evaluate PLOGI playload and copy important fields into zfcp_port structure
371 void zfcp_fc_plogi_evaluate(struct zfcp_port
*port
, struct fsf_plogi
*plogi
)
373 port
->maxframe_size
= plogi
->serv_param
.common_serv_param
[7] |
374 ((plogi
->serv_param
.common_serv_param
[6] & 0x0F) << 8);
375 if (plogi
->serv_param
.class1_serv_param
[0] & 0x80)
376 port
->supported_classes
|= FC_COS_CLASS1
;
377 if (plogi
->serv_param
.class2_serv_param
[0] & 0x80)
378 port
->supported_classes
|= FC_COS_CLASS2
;
379 if (plogi
->serv_param
.class3_serv_param
[0] & 0x80)
380 port
->supported_classes
|= FC_COS_CLASS3
;
381 if (plogi
->serv_param
.class4_serv_param
[0] & 0x80)
382 port
->supported_classes
|= FC_COS_CLASS4
;
385 struct zfcp_els_adisc
{
386 struct zfcp_send_els els
;
387 struct scatterlist req
;
388 struct scatterlist resp
;
389 struct zfcp_ls_adisc ls_adisc
;
390 struct zfcp_ls_adisc ls_adisc_acc
;
393 static void zfcp_fc_adisc_handler(unsigned long data
)
395 struct zfcp_els_adisc
*adisc
= (struct zfcp_els_adisc
*) data
;
396 struct zfcp_port
*port
= adisc
->els
.port
;
397 struct zfcp_ls_adisc
*ls_adisc
= &adisc
->ls_adisc_acc
;
399 if (adisc
->els
.status
) {
400 /* request rejected or timed out */
401 zfcp_erp_port_forced_reopen(port
, ZFCP_STATUS_COMMON_ERP_FAILED
,
407 port
->wwnn
= ls_adisc
->wwnn
;
409 if ((port
->wwpn
!= ls_adisc
->wwpn
) ||
410 !(atomic_read(&port
->status
) & ZFCP_STATUS_COMMON_OPEN
)) {
411 zfcp_erp_port_reopen(port
, ZFCP_STATUS_COMMON_ERP_FAILED
,
416 /* port is good, unblock rport without going through erp */
417 zfcp_scsi_schedule_rport_register(port
);
419 atomic_clear_mask(ZFCP_STATUS_PORT_LINK_TEST
, &port
->status
);
424 static int zfcp_fc_adisc(struct zfcp_port
*port
)
426 struct zfcp_els_adisc
*adisc
;
427 struct zfcp_adapter
*adapter
= port
->adapter
;
429 adisc
= kzalloc(sizeof(struct zfcp_els_adisc
), GFP_ATOMIC
);
433 adisc
->els
.req
= &adisc
->req
;
434 adisc
->els
.resp
= &adisc
->resp
;
435 sg_init_one(adisc
->els
.req
, &adisc
->ls_adisc
,
436 sizeof(struct zfcp_ls_adisc
));
437 sg_init_one(adisc
->els
.resp
, &adisc
->ls_adisc_acc
,
438 sizeof(struct zfcp_ls_adisc
));
440 adisc
->els
.adapter
= adapter
;
441 adisc
->els
.port
= port
;
442 adisc
->els
.d_id
= port
->d_id
;
443 adisc
->els
.handler
= zfcp_fc_adisc_handler
;
444 adisc
->els
.handler_data
= (unsigned long) adisc
;
445 adisc
->els
.ls_code
= adisc
->ls_adisc
.code
= ZFCP_LS_ADISC
;
447 /* acc. to FC-FS, hard_nport_id in ADISC should not be set for ports
448 without FC-AL-2 capability, so we don't set it */
449 adisc
->ls_adisc
.wwpn
= fc_host_port_name(adapter
->scsi_host
);
450 adisc
->ls_adisc
.wwnn
= fc_host_node_name(adapter
->scsi_host
);
451 adisc
->ls_adisc
.nport_id
= fc_host_port_id(adapter
->scsi_host
);
453 return zfcp_fsf_send_els(&adisc
->els
);
456 void zfcp_fc_link_test_work(struct work_struct
*work
)
458 struct zfcp_port
*port
=
459 container_of(work
, struct zfcp_port
, test_link_work
);
463 port
->rport_task
= RPORT_DEL
;
464 zfcp_scsi_rport_work(&port
->rport_work
);
466 /* only issue one test command at one time per port */
467 if (atomic_read(&port
->status
) & ZFCP_STATUS_PORT_LINK_TEST
)
470 atomic_set_mask(ZFCP_STATUS_PORT_LINK_TEST
, &port
->status
);
472 retval
= zfcp_fc_adisc(port
);
476 /* send of ADISC was not possible */
477 atomic_clear_mask(ZFCP_STATUS_PORT_LINK_TEST
, &port
->status
);
478 zfcp_erp_port_forced_reopen(port
, 0, "fcltwk1", NULL
);
485 * zfcp_fc_test_link - lightweight link test procedure
486 * @port: port to be tested
488 * Test status of a link to a remote port using the ELS command ADISC.
489 * If there is a problem with the remote port, error recovery steps
492 void zfcp_fc_test_link(struct zfcp_port
*port
)
495 if (!queue_work(port
->adapter
->work_queue
, &port
->test_link_work
))
499 static void zfcp_free_sg_env(struct zfcp_gpn_ft
*gpn_ft
, int buf_num
)
501 struct scatterlist
*sg
= &gpn_ft
->sg_req
;
503 kmem_cache_free(zfcp_data
.gpn_ft_cache
, sg_virt(sg
));
504 zfcp_sg_free_table(gpn_ft
->sg_resp
, buf_num
);
509 static struct zfcp_gpn_ft
*zfcp_alloc_sg_env(int buf_num
)
511 struct zfcp_gpn_ft
*gpn_ft
;
512 struct ct_iu_gpn_ft_req
*req
;
514 gpn_ft
= kzalloc(sizeof(*gpn_ft
), GFP_KERNEL
);
518 req
= kmem_cache_alloc(zfcp_data
.gpn_ft_cache
, GFP_KERNEL
);
524 sg_init_one(&gpn_ft
->sg_req
, req
, sizeof(*req
));
526 if (zfcp_sg_setup_table(gpn_ft
->sg_resp
, buf_num
)) {
527 zfcp_free_sg_env(gpn_ft
, buf_num
);
535 static int zfcp_fc_send_gpn_ft(struct zfcp_gpn_ft
*gpn_ft
,
536 struct zfcp_adapter
*adapter
, int max_bytes
)
538 struct zfcp_send_ct
*ct
= &gpn_ft
->ct
;
539 struct ct_iu_gpn_ft_req
*req
= sg_virt(&gpn_ft
->sg_req
);
540 struct zfcp_fc_ns_handler_data compl_rec
;
543 /* prepare CT IU for GPN_FT */
544 req
->header
.revision
= ZFCP_CT_REVISION
;
545 req
->header
.gs_type
= ZFCP_CT_DIRECTORY_SERVICE
;
546 req
->header
.gs_subtype
= ZFCP_CT_NAME_SERVER
;
547 req
->header
.options
= ZFCP_CT_SYNCHRONOUS
;
548 req
->header
.cmd_rsp_code
= ZFCP_CT_GPN_FT
;
549 req
->header
.max_res_size
= max_bytes
/ 4;
551 req
->domain_id_scope
= 0;
552 req
->area_id_scope
= 0;
553 req
->fc4_type
= ZFCP_CT_SCSI_FCP
;
555 /* prepare zfcp_send_ct */
556 ct
->wka_port
= &adapter
->gs
->ds
;
557 ct
->handler
= zfcp_fc_ns_handler
;
558 ct
->handler_data
= (unsigned long)&compl_rec
;
560 ct
->req
= &gpn_ft
->sg_req
;
561 ct
->resp
= gpn_ft
->sg_resp
;
563 init_completion(&compl_rec
.done
);
564 compl_rec
.handler
= NULL
;
565 ret
= zfcp_fsf_send_ct(ct
, NULL
);
567 wait_for_completion(&compl_rec
.done
);
571 static void zfcp_fc_validate_port(struct zfcp_port
*port
)
573 struct zfcp_adapter
*adapter
= port
->adapter
;
575 if (!(atomic_read(&port
->status
) & ZFCP_STATUS_COMMON_NOESC
))
578 atomic_clear_mask(ZFCP_STATUS_COMMON_NOESC
, &port
->status
);
580 if ((port
->supported_classes
!= 0) ||
581 !list_empty(&port
->unit_list_head
)) {
585 zfcp_erp_port_shutdown(port
, 0, "fcpval1", NULL
);
586 zfcp_erp_wait(adapter
);
588 zfcp_port_dequeue(port
);
591 static int zfcp_fc_eval_gpn_ft(struct zfcp_gpn_ft
*gpn_ft
, int max_entries
)
593 struct zfcp_send_ct
*ct
= &gpn_ft
->ct
;
594 struct scatterlist
*sg
= gpn_ft
->sg_resp
;
595 struct ct_hdr
*hdr
= sg_virt(sg
);
596 struct gpn_ft_resp_acc
*acc
= sg_virt(sg
);
597 struct zfcp_adapter
*adapter
= ct
->wka_port
->adapter
;
598 struct zfcp_port
*port
, *tmp
;
600 int ret
= 0, x
, last
= 0;
605 if (hdr
->cmd_rsp_code
!= ZFCP_CT_ACCEPT
) {
606 if (hdr
->reason_code
== ZFCP_CT_UNABLE_TO_PERFORM_CMD
)
607 return -EAGAIN
; /* might be a temporary condition */
611 if (hdr
->max_res_size
) {
612 dev_warn(&adapter
->ccw_device
->dev
,
613 "The name server reported %d words residual data\n",
618 down(&zfcp_data
.config_sema
);
620 /* first entry is the header */
621 for (x
= 1; x
< max_entries
&& !last
; x
++) {
622 if (x
% (ZFCP_GPN_FT_ENTRIES
+ 1))
627 last
= acc
->control
& 0x80;
628 d_id
= acc
->port_id
[0] << 16 | acc
->port_id
[1] << 8 |
631 /* don't attach ports with a well known address */
632 if ((d_id
& ZFCP_DID_WKA
) == ZFCP_DID_WKA
)
634 /* skip the adapter's port and known remote ports */
635 if (acc
->wwpn
== fc_host_port_name(adapter
->scsi_host
))
637 port
= zfcp_get_port_by_wwpn(adapter
, acc
->wwpn
);
641 port
= zfcp_port_enqueue(adapter
, acc
->wwpn
,
642 ZFCP_STATUS_COMMON_NOESC
, d_id
);
646 zfcp_erp_port_reopen(port
, 0, "fcegpf1", NULL
);
649 zfcp_erp_wait(adapter
);
650 list_for_each_entry_safe(port
, tmp
, &adapter
->port_list_head
, list
)
651 zfcp_fc_validate_port(port
);
652 up(&zfcp_data
.config_sema
);
657 * zfcp_fc_scan_ports - scan remote ports and attach new ports
658 * @adapter: pointer to struct zfcp_adapter
660 int zfcp_fc_scan_ports(struct zfcp_adapter
*adapter
)
663 struct zfcp_gpn_ft
*gpn_ft
;
664 int chain
, max_entries
, buf_num
, max_bytes
;
666 chain
= adapter
->adapter_features
& FSF_FEATURE_ELS_CT_CHAINED_SBALS
;
667 buf_num
= chain
? ZFCP_GPN_FT_BUFFERS
: 1;
668 max_entries
= chain
? ZFCP_GPN_FT_MAX_ENTRIES
: ZFCP_GPN_FT_ENTRIES
;
669 max_bytes
= chain
? ZFCP_GPN_FT_MAX_SIZE
: ZFCP_CT_SIZE_ONE_PAGE
;
671 if (fc_host_port_type(adapter
->scsi_host
) != FC_PORTTYPE_NPORT
&&
672 fc_host_port_type(adapter
->scsi_host
) != FC_PORTTYPE_NPIV
)
675 ret
= zfcp_fc_wka_port_get(&adapter
->gs
->ds
);
679 gpn_ft
= zfcp_alloc_sg_env(buf_num
);
685 for (i
= 0; i
< 3; i
++) {
686 ret
= zfcp_fc_send_gpn_ft(gpn_ft
, adapter
, max_bytes
);
688 ret
= zfcp_fc_eval_gpn_ft(gpn_ft
, max_entries
);
695 zfcp_free_sg_env(gpn_ft
, buf_num
);
697 zfcp_fc_wka_port_put(&adapter
->gs
->ds
);
702 void _zfcp_fc_scan_ports_later(struct work_struct
*work
)
704 zfcp_fc_scan_ports(container_of(work
, struct zfcp_adapter
, scan_work
));
707 struct zfcp_els_fc_job
{
708 struct zfcp_send_els els
;
709 struct fc_bsg_job
*job
;
712 static void zfcp_fc_generic_els_handler(unsigned long data
)
714 struct zfcp_els_fc_job
*els_fc_job
= (struct zfcp_els_fc_job
*) data
;
715 struct fc_bsg_job
*job
= els_fc_job
->job
;
716 struct fc_bsg_reply
*reply
= job
->reply
;
718 if (els_fc_job
->els
.status
) {
719 /* request rejected or timed out */
720 reply
->reply_data
.ctels_reply
.status
= FC_CTELS_STATUS_REJECT
;
724 reply
->reply_data
.ctels_reply
.status
= FC_CTELS_STATUS_OK
;
725 reply
->reply_payload_rcv_len
= job
->reply_payload
.payload_len
;
728 job
->state_flags
= FC_RQST_STATE_DONE
;
733 int zfcp_fc_execute_els_fc_job(struct fc_bsg_job
*job
)
735 struct zfcp_els_fc_job
*els_fc_job
;
736 struct fc_rport
*rport
= job
->rport
;
737 struct Scsi_Host
*shost
;
738 struct zfcp_adapter
*adapter
;
739 struct zfcp_port
*port
;
742 shost
= rport
? rport_to_shost(rport
) : job
->shost
;
743 adapter
= (struct zfcp_adapter
*)shost
->hostdata
[0];
745 if (!(atomic_read(&adapter
->status
) & ZFCP_STATUS_COMMON_OPEN
))
748 els_fc_job
= kzalloc(sizeof(struct zfcp_els_fc_job
), GFP_KERNEL
);
752 els_fc_job
->els
.adapter
= adapter
;
754 read_lock_irq(&zfcp_data
.config_lock
);
755 port
= zfcp_get_port_by_wwpn(adapter
, rport
->port_name
);
757 els_fc_job
->els
.d_id
= port
->d_id
;
758 read_unlock_irq(&zfcp_data
.config_lock
);
764 port_did
= job
->request
->rqst_data
.h_els
.port_id
;
765 els_fc_job
->els
.d_id
= (port_did
[0] << 16) +
766 (port_did
[1] << 8) + port_did
[2];
769 els_fc_job
->els
.req
= job
->request_payload
.sg_list
;
770 els_fc_job
->els
.resp
= job
->reply_payload
.sg_list
;
771 els_fc_job
->els
.handler
= zfcp_fc_generic_els_handler
;
772 els_fc_job
->els
.handler_data
= (unsigned long) els_fc_job
;
773 els_fc_job
->job
= job
;
775 return zfcp_fsf_send_els(&els_fc_job
->els
);
778 struct zfcp_ct_fc_job
{
779 struct zfcp_send_ct ct
;
780 struct fc_bsg_job
*job
;
783 static void zfcp_fc_generic_ct_handler(unsigned long data
)
785 struct zfcp_ct_fc_job
*ct_fc_job
= (struct zfcp_ct_fc_job
*) data
;
786 struct fc_bsg_job
*job
= ct_fc_job
->job
;
788 job
->reply
->reply_data
.ctels_reply
.status
= ct_fc_job
->ct
.status
?
789 FC_CTELS_STATUS_REJECT
: FC_CTELS_STATUS_OK
;
790 job
->reply
->reply_payload_rcv_len
= job
->reply_payload
.payload_len
;
791 job
->state_flags
= FC_RQST_STATE_DONE
;
794 zfcp_fc_wka_port_put(ct_fc_job
->ct
.wka_port
);
799 int zfcp_fc_execute_ct_fc_job(struct fc_bsg_job
*job
)
803 struct fc_rport
*rport
= job
->rport
;
804 struct Scsi_Host
*shost
;
805 struct zfcp_adapter
*adapter
;
806 struct zfcp_ct_fc_job
*ct_fc_job
;
809 shost
= rport
? rport_to_shost(rport
) : job
->shost
;
811 adapter
= (struct zfcp_adapter
*)shost
->hostdata
[0];
812 if (!(atomic_read(&adapter
->status
) & ZFCP_STATUS_COMMON_OPEN
))
815 ct_fc_job
= kzalloc(sizeof(struct zfcp_ct_fc_job
), GFP_KERNEL
);
819 preamble_word1
= job
->request
->rqst_data
.r_ct
.preamble_word1
;
820 gs_type
= (preamble_word1
& 0xff000000) >> 24;
824 ct_fc_job
->ct
.wka_port
= &adapter
->gs
->as
;
827 ct_fc_job
->ct
.wka_port
= &adapter
->gs
->ms
;
830 ct_fc_job
->ct
.wka_port
= &adapter
->gs
->ts
;
833 ct_fc_job
->ct
.wka_port
= &adapter
->gs
->ds
;
837 return -EINVAL
; /* no such service */
840 ret
= zfcp_fc_wka_port_get(ct_fc_job
->ct
.wka_port
);
846 ct_fc_job
->ct
.req
= job
->request_payload
.sg_list
;
847 ct_fc_job
->ct
.resp
= job
->reply_payload
.sg_list
;
848 ct_fc_job
->ct
.timeout
= ZFCP_FSF_REQUEST_TIMEOUT
;
849 ct_fc_job
->ct
.handler
= zfcp_fc_generic_ct_handler
;
850 ct_fc_job
->ct
.handler_data
= (unsigned long) ct_fc_job
;
851 ct_fc_job
->ct
.completion
= NULL
;
852 ct_fc_job
->job
= job
;
854 ret
= zfcp_fsf_send_ct(&ct_fc_job
->ct
, NULL
);
857 zfcp_fc_wka_port_put(ct_fc_job
->ct
.wka_port
);
862 int zfcp_fc_gs_setup(struct zfcp_adapter
*adapter
)
864 struct zfcp_wka_ports
*wka_ports
;
866 wka_ports
= kzalloc(sizeof(struct zfcp_wka_ports
), GFP_KERNEL
);
870 adapter
->gs
= wka_ports
;
871 zfcp_fc_wka_port_init(&wka_ports
->ms
, FC_FID_MGMT_SERV
, adapter
);
872 zfcp_fc_wka_port_init(&wka_ports
->ts
, FC_FID_TIME_SERV
, adapter
);
873 zfcp_fc_wka_port_init(&wka_ports
->ds
, FC_FID_DIR_SERV
, adapter
);
874 zfcp_fc_wka_port_init(&wka_ports
->as
, FC_FID_ALIASES
, adapter
);
875 zfcp_fc_wka_port_init(&wka_ports
->ks
, FC_FID_SEC_KEY
, adapter
);
880 void zfcp_fc_gs_destroy(struct zfcp_adapter
*adapter
)