4 * Fibre Channel related functions for the zfcp device driver.
6 * Copyright IBM Corporation 2008
11 struct ct_iu_gpn_ft_req
{
17 } __attribute__ ((packed
));
19 struct gpn_ft_resp_acc
{
24 } __attribute__ ((packed
));
26 #define ZFCP_GPN_FT_ENTRIES ((PAGE_SIZE - sizeof(struct ct_hdr)) \
27 / sizeof(struct gpn_ft_resp_acc))
28 #define ZFCP_GPN_FT_BUFFERS 4
29 #define ZFCP_GPN_FT_MAX_ENTRIES ZFCP_GPN_FT_BUFFERS * (ZFCP_GPN_FT_ENTRIES + 1)
31 struct ct_iu_gpn_ft_resp
{
33 struct gpn_ft_resp_acc accept
[ZFCP_GPN_FT_ENTRIES
];
34 } __attribute__ ((packed
));
37 struct zfcp_send_ct ct
;
38 struct scatterlist sg_req
;
39 struct scatterlist sg_resp
[ZFCP_GPN_FT_BUFFERS
];
42 static struct zfcp_port
*zfcp_get_port_by_did(struct zfcp_adapter
*adapter
,
45 struct zfcp_port
*port
;
47 list_for_each_entry(port
, &adapter
->port_list_head
, list
)
48 if ((port
->d_id
== d_id
) &&
49 !atomic_test_mask(ZFCP_STATUS_COMMON_REMOVE
, &port
->status
))
54 static void _zfcp_fc_incoming_rscn(struct zfcp_fsf_req
*fsf_req
, u32 range
,
55 struct fcp_rscn_element
*elem
)
58 struct zfcp_port
*port
;
60 read_lock_irqsave(&zfcp_data
.config_lock
, flags
);
61 list_for_each_entry(port
, &fsf_req
->adapter
->port_list_head
, list
) {
62 if (atomic_test_mask(ZFCP_STATUS_PORT_WKA
, &port
->status
))
64 /* FIXME: ZFCP_STATUS_PORT_DID_DID check is racy */
65 if (!atomic_test_mask(ZFCP_STATUS_PORT_DID_DID
, &port
->status
))
66 /* Try to connect to unused ports anyway. */
67 zfcp_erp_port_reopen(port
,
68 ZFCP_STATUS_COMMON_ERP_FAILED
,
70 else if ((port
->d_id
& range
) == (elem
->nport_did
& range
))
71 /* Check connection status for connected ports */
74 read_unlock_irqrestore(&zfcp_data
.config_lock
, flags
);
77 static void zfcp_fc_incoming_rscn(struct zfcp_fsf_req
*fsf_req
)
79 struct fsf_status_read_buffer
*status_buffer
= (void *)fsf_req
->data
;
80 struct fcp_rscn_head
*fcp_rscn_head
;
81 struct fcp_rscn_element
*fcp_rscn_element
;
86 fcp_rscn_head
= (struct fcp_rscn_head
*) status_buffer
->payload
.data
;
87 fcp_rscn_element
= (struct fcp_rscn_element
*) fcp_rscn_head
;
90 no_entries
= fcp_rscn_head
->payload_len
/
91 sizeof(struct fcp_rscn_element
);
93 for (i
= 1; i
< no_entries
; i
++) {
94 /* skip head and start with 1st element */
96 switch (fcp_rscn_element
->addr_format
) {
97 case ZFCP_PORT_ADDRESS
:
98 range_mask
= ZFCP_PORTS_RANGE_PORT
;
100 case ZFCP_AREA_ADDRESS
:
101 range_mask
= ZFCP_PORTS_RANGE_AREA
;
103 case ZFCP_DOMAIN_ADDRESS
:
104 range_mask
= ZFCP_PORTS_RANGE_DOMAIN
;
106 case ZFCP_FABRIC_ADDRESS
:
107 range_mask
= ZFCP_PORTS_RANGE_FABRIC
;
112 _zfcp_fc_incoming_rscn(fsf_req
, range_mask
, fcp_rscn_element
);
114 schedule_work(&fsf_req
->adapter
->scan_work
);
117 static void zfcp_fc_incoming_wwpn(struct zfcp_fsf_req
*req
, wwn_t wwpn
)
119 struct zfcp_adapter
*adapter
= req
->adapter
;
120 struct zfcp_port
*port
;
123 read_lock_irqsave(&zfcp_data
.config_lock
, flags
);
124 list_for_each_entry(port
, &adapter
->port_list_head
, list
)
125 if (port
->wwpn
== wwpn
)
127 read_unlock_irqrestore(&zfcp_data
.config_lock
, flags
);
129 if (port
&& (port
->wwpn
== wwpn
))
130 zfcp_erp_port_forced_reopen(port
, 0, 83, req
);
133 static void zfcp_fc_incoming_plogi(struct zfcp_fsf_req
*req
)
135 struct fsf_status_read_buffer
*status_buffer
=
136 (struct fsf_status_read_buffer
*)req
->data
;
137 struct fsf_plogi
*els_plogi
=
138 (struct fsf_plogi
*) status_buffer
->payload
.data
;
140 zfcp_fc_incoming_wwpn(req
, els_plogi
->serv_param
.wwpn
);
143 static void zfcp_fc_incoming_logo(struct zfcp_fsf_req
*req
)
145 struct fsf_status_read_buffer
*status_buffer
=
146 (struct fsf_status_read_buffer
*)req
->data
;
147 struct fcp_logo
*els_logo
=
148 (struct fcp_logo
*) status_buffer
->payload
.data
;
150 zfcp_fc_incoming_wwpn(req
, els_logo
->nport_wwpn
);
154 * zfcp_fc_incoming_els - handle incoming ELS
155 * @fsf_req - request which contains incoming ELS
157 void zfcp_fc_incoming_els(struct zfcp_fsf_req
*fsf_req
)
159 struct fsf_status_read_buffer
*status_buffer
=
160 (struct fsf_status_read_buffer
*) fsf_req
->data
;
161 unsigned int els_type
= status_buffer
->payload
.data
[0];
163 zfcp_san_dbf_event_incoming_els(fsf_req
);
164 if (els_type
== LS_PLOGI
)
165 zfcp_fc_incoming_plogi(fsf_req
);
166 else if (els_type
== LS_LOGO
)
167 zfcp_fc_incoming_logo(fsf_req
);
168 else if (els_type
== LS_RSCN
)
169 zfcp_fc_incoming_rscn(fsf_req
);
172 static void zfcp_ns_gid_pn_handler(unsigned long data
)
174 struct zfcp_gid_pn_data
*gid_pn
= (struct zfcp_gid_pn_data
*) data
;
175 struct zfcp_send_ct
*ct
= &gid_pn
->ct
;
176 struct ct_iu_gid_pn_req
*ct_iu_req
= sg_virt(ct
->req
);
177 struct ct_iu_gid_pn_resp
*ct_iu_resp
= sg_virt(ct
->resp
);
178 struct zfcp_port
*port
= gid_pn
->port
;
182 if (ct_iu_resp
->header
.cmd_rsp_code
!= ZFCP_CT_ACCEPT
) {
183 atomic_set_mask(ZFCP_STATUS_PORT_INVALID_WWPN
, &port
->status
);
187 if (ct_iu_req
->wwpn
!= port
->wwpn
)
189 /* looks like a valid d_id */
190 port
->d_id
= ct_iu_resp
->d_id
& ZFCP_DID_MASK
;
191 atomic_set_mask(ZFCP_STATUS_PORT_DID_DID
, &port
->status
);
193 mempool_free(gid_pn
, port
->adapter
->pool
.data_gid_pn
);
197 * zfcp_fc_ns_gid_pn_request - initiate GID_PN nameserver request
198 * @erp_action: pointer to zfcp_erp_action where GID_PN request is needed
199 * return: -ENOMEM on error, 0 otherwise
201 int zfcp_fc_ns_gid_pn_request(struct zfcp_erp_action
*erp_action
)
204 struct zfcp_gid_pn_data
*gid_pn
;
205 struct zfcp_adapter
*adapter
= erp_action
->adapter
;
207 gid_pn
= mempool_alloc(adapter
->pool
.data_gid_pn
, GFP_ATOMIC
);
211 memset(gid_pn
, 0, sizeof(*gid_pn
));
213 /* setup parameters for send generic command */
214 gid_pn
->port
= erp_action
->port
;
215 gid_pn
->ct
.port
= adapter
->nameserver_port
;
216 gid_pn
->ct
.handler
= zfcp_ns_gid_pn_handler
;
217 gid_pn
->ct
.handler_data
= (unsigned long) gid_pn
;
218 gid_pn
->ct
.timeout
= ZFCP_NS_GID_PN_TIMEOUT
;
219 gid_pn
->ct
.req
= &gid_pn
->req
;
220 gid_pn
->ct
.resp
= &gid_pn
->resp
;
221 gid_pn
->ct
.req_count
= 1;
222 gid_pn
->ct
.resp_count
= 1;
223 sg_init_one(&gid_pn
->req
, &gid_pn
->ct_iu_req
,
224 sizeof(struct ct_iu_gid_pn_req
));
225 sg_init_one(&gid_pn
->resp
, &gid_pn
->ct_iu_resp
,
226 sizeof(struct ct_iu_gid_pn_resp
));
228 /* setup nameserver request */
229 gid_pn
->ct_iu_req
.header
.revision
= ZFCP_CT_REVISION
;
230 gid_pn
->ct_iu_req
.header
.gs_type
= ZFCP_CT_DIRECTORY_SERVICE
;
231 gid_pn
->ct_iu_req
.header
.gs_subtype
= ZFCP_CT_NAME_SERVER
;
232 gid_pn
->ct_iu_req
.header
.options
= ZFCP_CT_SYNCHRONOUS
;
233 gid_pn
->ct_iu_req
.header
.cmd_rsp_code
= ZFCP_CT_GID_PN
;
234 gid_pn
->ct_iu_req
.header
.max_res_size
= ZFCP_CT_MAX_SIZE
;
235 gid_pn
->ct_iu_req
.wwpn
= erp_action
->port
->wwpn
;
237 ret
= zfcp_fsf_send_ct(&gid_pn
->ct
, adapter
->pool
.fsf_req_erp
,
240 mempool_free(gid_pn
, adapter
->pool
.data_gid_pn
);
245 * zfcp_fc_plogi_evaluate - evaluate PLOGI playload
246 * @port: zfcp_port structure
247 * @plogi: plogi payload
249 * Evaluate PLOGI playload and copy important fields into zfcp_port structure
251 void zfcp_fc_plogi_evaluate(struct zfcp_port
*port
, struct fsf_plogi
*plogi
)
253 port
->maxframe_size
= plogi
->serv_param
.common_serv_param
[7] |
254 ((plogi
->serv_param
.common_serv_param
[6] & 0x0F) << 8);
255 if (plogi
->serv_param
.class1_serv_param
[0] & 0x80)
256 port
->supported_classes
|= FC_COS_CLASS1
;
257 if (plogi
->serv_param
.class2_serv_param
[0] & 0x80)
258 port
->supported_classes
|= FC_COS_CLASS2
;
259 if (plogi
->serv_param
.class3_serv_param
[0] & 0x80)
260 port
->supported_classes
|= FC_COS_CLASS3
;
261 if (plogi
->serv_param
.class4_serv_param
[0] & 0x80)
262 port
->supported_classes
|= FC_COS_CLASS4
;
265 struct zfcp_els_adisc
{
266 struct zfcp_send_els els
;
267 struct scatterlist req
;
268 struct scatterlist resp
;
269 struct zfcp_ls_adisc ls_adisc
;
270 struct zfcp_ls_adisc_acc ls_adisc_acc
;
273 static void zfcp_fc_adisc_handler(unsigned long data
)
275 struct zfcp_els_adisc
*adisc
= (struct zfcp_els_adisc
*) data
;
276 struct zfcp_port
*port
= adisc
->els
.port
;
277 struct zfcp_ls_adisc_acc
*ls_adisc
= &adisc
->ls_adisc_acc
;
279 if (adisc
->els
.status
) {
280 /* request rejected or timed out */
281 zfcp_erp_port_forced_reopen(port
, 0, 63, NULL
);
286 port
->wwnn
= ls_adisc
->wwnn
;
288 if (port
->wwpn
!= ls_adisc
->wwpn
)
289 zfcp_erp_port_reopen(port
, 0, 64, NULL
);
296 static int zfcp_fc_adisc(struct zfcp_port
*port
)
298 struct zfcp_els_adisc
*adisc
;
299 struct zfcp_adapter
*adapter
= port
->adapter
;
301 adisc
= kzalloc(sizeof(struct zfcp_els_adisc
), GFP_ATOMIC
);
305 adisc
->els
.req
= &adisc
->req
;
306 adisc
->els
.resp
= &adisc
->resp
;
307 sg_init_one(adisc
->els
.req
, &adisc
->ls_adisc
,
308 sizeof(struct zfcp_ls_adisc
));
309 sg_init_one(adisc
->els
.resp
, &adisc
->ls_adisc_acc
,
310 sizeof(struct zfcp_ls_adisc_acc
));
312 adisc
->els
.req_count
= 1;
313 adisc
->els
.resp_count
= 1;
314 adisc
->els
.adapter
= adapter
;
315 adisc
->els
.port
= port
;
316 adisc
->els
.d_id
= port
->d_id
;
317 adisc
->els
.handler
= zfcp_fc_adisc_handler
;
318 adisc
->els
.handler_data
= (unsigned long) adisc
;
319 adisc
->els
.ls_code
= adisc
->ls_adisc
.code
= ZFCP_LS_ADISC
;
321 /* acc. to FC-FS, hard_nport_id in ADISC should not be set for ports
322 without FC-AL-2 capability, so we don't set it */
323 adisc
->ls_adisc
.wwpn
= fc_host_port_name(adapter
->scsi_host
);
324 adisc
->ls_adisc
.wwnn
= fc_host_node_name(adapter
->scsi_host
);
325 adisc
->ls_adisc
.nport_id
= fc_host_port_id(adapter
->scsi_host
);
327 return zfcp_fsf_send_els(&adisc
->els
);
331 * zfcp_test_link - lightweight link test procedure
332 * @port: port to be tested
334 * Test status of a link to a remote port using the ELS command ADISC.
335 * If there is a problem with the remote port, error recovery steps
338 void zfcp_test_link(struct zfcp_port
*port
)
343 retval
= zfcp_fc_adisc(port
);
344 if (retval
== 0 || retval
== -EBUSY
)
347 /* send of ADISC was not possible */
349 zfcp_erp_port_forced_reopen(port
, 0, 65, NULL
);
352 static int zfcp_scan_get_nameserver(struct zfcp_adapter
*adapter
)
356 if (!adapter
->nameserver_port
)
359 if (!atomic_test_mask(ZFCP_STATUS_COMMON_UNBLOCKED
,
360 &adapter
->nameserver_port
->status
)) {
361 ret
= zfcp_erp_port_reopen(adapter
->nameserver_port
, 0, 148,
365 zfcp_erp_wait(adapter
);
366 zfcp_port_put(adapter
->nameserver_port
);
368 return !atomic_test_mask(ZFCP_STATUS_COMMON_UNBLOCKED
,
369 &adapter
->nameserver_port
->status
);
372 static void zfcp_gpn_ft_handler(unsigned long _done
)
374 complete((struct completion
*)_done
);
377 static void zfcp_free_sg_env(struct zfcp_gpn_ft
*gpn_ft
)
379 struct scatterlist
*sg
= &gpn_ft
->sg_req
;
381 kfree(sg_virt(sg
)); /* free request buffer */
382 zfcp_sg_free_table(gpn_ft
->sg_resp
, ZFCP_GPN_FT_BUFFERS
);
387 static struct zfcp_gpn_ft
*zfcp_alloc_sg_env(void)
389 struct zfcp_gpn_ft
*gpn_ft
;
390 struct ct_iu_gpn_ft_req
*req
;
392 gpn_ft
= kzalloc(sizeof(*gpn_ft
), GFP_KERNEL
);
396 req
= kzalloc(sizeof(struct ct_iu_gpn_ft_req
), GFP_KERNEL
);
402 sg_init_one(&gpn_ft
->sg_req
, req
, sizeof(*req
));
404 if (zfcp_sg_setup_table(gpn_ft
->sg_resp
, ZFCP_GPN_FT_BUFFERS
)) {
405 zfcp_free_sg_env(gpn_ft
);
413 static int zfcp_scan_issue_gpn_ft(struct zfcp_gpn_ft
*gpn_ft
,
414 struct zfcp_adapter
*adapter
)
416 struct zfcp_send_ct
*ct
= &gpn_ft
->ct
;
417 struct ct_iu_gpn_ft_req
*req
= sg_virt(&gpn_ft
->sg_req
);
418 struct completion done
;
421 /* prepare CT IU for GPN_FT */
422 req
->header
.revision
= ZFCP_CT_REVISION
;
423 req
->header
.gs_type
= ZFCP_CT_DIRECTORY_SERVICE
;
424 req
->header
.gs_subtype
= ZFCP_CT_NAME_SERVER
;
425 req
->header
.options
= ZFCP_CT_SYNCHRONOUS
;
426 req
->header
.cmd_rsp_code
= ZFCP_CT_GPN_FT
;
427 req
->header
.max_res_size
= (sizeof(struct gpn_ft_resp_acc
) *
428 (ZFCP_GPN_FT_MAX_ENTRIES
- 1)) >> 2;
430 req
->domain_id_scope
= 0;
431 req
->area_id_scope
= 0;
432 req
->fc4_type
= ZFCP_CT_SCSI_FCP
;
434 /* prepare zfcp_send_ct */
435 ct
->port
= adapter
->nameserver_port
;
436 ct
->handler
= zfcp_gpn_ft_handler
;
437 ct
->handler_data
= (unsigned long)&done
;
439 ct
->req
= &gpn_ft
->sg_req
;
440 ct
->resp
= gpn_ft
->sg_resp
;
442 ct
->resp_count
= ZFCP_GPN_FT_BUFFERS
;
444 init_completion(&done
);
445 ret
= zfcp_fsf_send_ct(ct
, NULL
, NULL
);
447 wait_for_completion(&done
);
451 static void zfcp_validate_port(struct zfcp_port
*port
)
453 struct zfcp_adapter
*adapter
= port
->adapter
;
455 atomic_clear_mask(ZFCP_STATUS_COMMON_NOESC
, &port
->status
);
457 if (port
== adapter
->nameserver_port
)
459 if ((port
->supported_classes
!= 0) || (port
->units
!= 0)) {
463 zfcp_erp_port_shutdown(port
, 0, 151, NULL
);
464 zfcp_erp_wait(adapter
);
466 zfcp_port_dequeue(port
);
469 static int zfcp_scan_eval_gpn_ft(struct zfcp_gpn_ft
*gpn_ft
)
471 struct zfcp_send_ct
*ct
= &gpn_ft
->ct
;
472 struct scatterlist
*sg
= gpn_ft
->sg_resp
;
473 struct ct_hdr
*hdr
= sg_virt(sg
);
474 struct gpn_ft_resp_acc
*acc
= sg_virt(sg
);
475 struct zfcp_adapter
*adapter
= ct
->port
->adapter
;
476 struct zfcp_port
*port
, *tmp
;
483 if (hdr
->cmd_rsp_code
!= ZFCP_CT_ACCEPT
) {
484 if (hdr
->reason_code
== ZFCP_CT_UNABLE_TO_PERFORM_CMD
)
485 return -EAGAIN
; /* might be a temporary condition */
489 if (hdr
->max_res_size
)
492 down(&zfcp_data
.config_sema
);
494 /* first entry is the header */
495 for (x
= 1; x
< ZFCP_GPN_FT_MAX_ENTRIES
; x
++) {
496 if (x
% (ZFCP_GPN_FT_ENTRIES
+ 1))
501 d_id
= acc
->port_id
[0] << 16 | acc
->port_id
[1] << 8 |
504 /* skip the adapter's port and known remote ports */
505 if (acc
->wwpn
== fc_host_port_name(adapter
->scsi_host
) ||
506 zfcp_get_port_by_did(adapter
, d_id
))
509 port
= zfcp_port_enqueue(adapter
, acc
->wwpn
,
510 ZFCP_STATUS_PORT_DID_DID
|
511 ZFCP_STATUS_COMMON_NOESC
, d_id
);
515 zfcp_erp_port_reopen(port
, 0, 149, NULL
);
516 if (acc
->control
& 0x80) /* last entry */
520 zfcp_erp_wait(adapter
);
521 list_for_each_entry_safe(port
, tmp
, &adapter
->port_list_head
, list
)
522 zfcp_validate_port(port
);
523 up(&zfcp_data
.config_sema
);
528 * zfcp_scan_ports - scan remote ports and attach new ports
529 * @adapter: pointer to struct zfcp_adapter
531 int zfcp_scan_ports(struct zfcp_adapter
*adapter
)
534 struct zfcp_gpn_ft
*gpn_ft
;
536 zfcp_erp_wait(adapter
); /* wait until adapter is finished with ERP */
537 if (fc_host_port_type(adapter
->scsi_host
) != FC_PORTTYPE_NPORT
)
540 ret
= zfcp_scan_get_nameserver(adapter
);
544 gpn_ft
= zfcp_alloc_sg_env();
548 for (i
= 0; i
< 3; i
++) {
549 ret
= zfcp_scan_issue_gpn_ft(gpn_ft
, adapter
);
551 ret
= zfcp_scan_eval_gpn_ft(gpn_ft
);
558 zfcp_free_sg_env(gpn_ft
);
564 void _zfcp_scan_ports_later(struct work_struct
*work
)
566 zfcp_scan_ports(container_of(work
, struct zfcp_adapter
, scan_work
));