1 /* 2 * zfcp device driver 3 * 4 * Fibre Channel related functions for the zfcp device driver. 5 * 6 * Copyright IBM Corporation 2008, 2009 7 */ 8 9 #define KMSG_COMPONENT "zfcp" 10 #define pr_fmt(fmt) KMSG_COMPONENT ": " fmt 11 12 #include "zfcp_ext.h" 13 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, 19 }; 20 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, 26 }; 27 28 struct ct_iu_gpn_ft_req { 29 struct ct_hdr header; 30 u8 flags; 31 u8 domain_id_scope; 32 u8 area_id_scope; 33 u8 fc4_type; 34 } __attribute__ ((packed)); 35 36 struct gpn_ft_resp_acc { 37 u8 control; 38 u8 port_id[3]; 39 u8 reserved[4]; 40 u64 wwpn; 41 } __attribute__ ((packed)); 42 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) 50 51 struct ct_iu_gpn_ft_resp { 52 struct ct_hdr header; 53 struct gpn_ft_resp_acc accept[ZFCP_GPN_FT_ENTRIES]; 54 } __attribute__ ((packed)); 55 56 struct zfcp_gpn_ft { 57 struct zfcp_send_ct ct; 58 struct scatterlist sg_req; 59 struct scatterlist sg_resp[ZFCP_GPN_FT_BUFFERS]; 60 }; 61 62 struct zfcp_fc_ns_handler_data { 63 struct completion done; 64 void (*handler)(unsigned long); 65 unsigned long handler_data; 66 }; 67 68 static int zfcp_wka_port_get(struct zfcp_wka_port *wka_port) 69 { 70 if (mutex_lock_interruptible(&wka_port->mutex)) 71 return -ERESTARTSYS; 72 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; 78 } 79 80 mutex_unlock(&wka_port->mutex); 81 82 wait_event_timeout( 83 wka_port->completion_wq, 84 wka_port->status == ZFCP_WKA_PORT_ONLINE || 85 wka_port->status == ZFCP_WKA_PORT_OFFLINE, 86 HZ >> 1); 87 88 if (wka_port->status == ZFCP_WKA_PORT_ONLINE) { 89 atomic_inc(&wka_port->refcount); 90 return 0; 91 } 92 return -EIO; 93 } 94 95 static void zfcp_wka_port_offline(struct work_struct *work) 96 { 97 struct delayed_work *dw = to_delayed_work(work); 98 struct zfcp_wka_port *wka_port = 99 container_of(dw, struct zfcp_wka_port, work); 100 101 mutex_lock(&wka_port->mutex); 102 if ((atomic_read(&wka_port->refcount) != 0) || 103 (wka_port->status != ZFCP_WKA_PORT_ONLINE)) 104 goto out; 105 106 wka_port->status = ZFCP_WKA_PORT_CLOSING; 107 if (zfcp_fsf_close_wka_port(wka_port)) { 108 wka_port->status = ZFCP_WKA_PORT_OFFLINE; 109 wake_up(&wka_port->completion_wq); 110 } 111 out: 112 mutex_unlock(&wka_port->mutex); 113 } 114 115 static void zfcp_wka_port_put(struct zfcp_wka_port *wka_port) 116 { 117 if (atomic_dec_return(&wka_port->refcount) != 0) 118 return; 119 /* wait 10 miliseconds, other reqs might pop in */ 120 schedule_delayed_work(&wka_port->work, HZ / 100); 121 } 122 123 void zfcp_fc_nameserver_init(struct zfcp_adapter *adapter) 124 { 125 struct zfcp_wka_port *wka_port = &adapter->nsp; 126 127 init_waitqueue_head(&wka_port->completion_wq); 128 129 wka_port->adapter = adapter; 130 wka_port->d_id = ZFCP_DID_DIRECTORY_SERVICE; 131 132 wka_port->status = ZFCP_WKA_PORT_OFFLINE; 133 atomic_set(&wka_port->refcount, 0); 134 mutex_init(&wka_port->mutex); 135 INIT_DELAYED_WORK(&wka_port->work, zfcp_wka_port_offline); 136 } 137 138 void zfcp_fc_wka_port_force_offline(struct zfcp_wka_port *wka) 139 { 140 cancel_delayed_work_sync(&wka->work); 141 mutex_lock(&wka->mutex); 142 wka->status = ZFCP_WKA_PORT_OFFLINE; 143 mutex_unlock(&wka->mutex); 144 } 145 146 static void _zfcp_fc_incoming_rscn(struct zfcp_fsf_req *fsf_req, u32 range, 147 struct fcp_rscn_element *elem) 148 { 149 unsigned long flags; 150 struct zfcp_port *port; 151 152 read_lock_irqsave(&zfcp_data.config_lock, flags); 153 list_for_each_entry(port, &fsf_req->adapter->port_list_head, list) 154 if ((port->d_id & range) == (elem->nport_did & range)) 155 zfcp_test_link(port); 156 157 read_unlock_irqrestore(&zfcp_data.config_lock, flags); 158 } 159 160 static void zfcp_fc_incoming_rscn(struct zfcp_fsf_req *fsf_req) 161 { 162 struct fsf_status_read_buffer *status_buffer = (void *)fsf_req->data; 163 struct fcp_rscn_head *fcp_rscn_head; 164 struct fcp_rscn_element *fcp_rscn_element; 165 u16 i; 166 u16 no_entries; 167 u32 range_mask; 168 169 fcp_rscn_head = (struct fcp_rscn_head *) status_buffer->payload.data; 170 fcp_rscn_element = (struct fcp_rscn_element *) fcp_rscn_head; 171 172 /* see FC-FS */ 173 no_entries = fcp_rscn_head->payload_len / 174 sizeof(struct fcp_rscn_element); 175 176 for (i = 1; i < no_entries; i++) { 177 /* skip head and start with 1st element */ 178 fcp_rscn_element++; 179 range_mask = rscn_range_mask[fcp_rscn_element->addr_format]; 180 _zfcp_fc_incoming_rscn(fsf_req, range_mask, fcp_rscn_element); 181 } 182 schedule_work(&fsf_req->adapter->scan_work); 183 } 184 185 static void zfcp_fc_incoming_wwpn(struct zfcp_fsf_req *req, u64 wwpn) 186 { 187 struct zfcp_adapter *adapter = req->adapter; 188 struct zfcp_port *port; 189 unsigned long flags; 190 191 read_lock_irqsave(&zfcp_data.config_lock, flags); 192 list_for_each_entry(port, &adapter->port_list_head, list) 193 if (port->wwpn == wwpn) 194 break; 195 read_unlock_irqrestore(&zfcp_data.config_lock, flags); 196 197 if (port && (port->wwpn == wwpn)) 198 zfcp_erp_port_forced_reopen(port, 0, "fciwwp1", req); 199 } 200 201 static void zfcp_fc_incoming_plogi(struct zfcp_fsf_req *req) 202 { 203 struct fsf_status_read_buffer *status_buffer = 204 (struct fsf_status_read_buffer *)req->data; 205 struct fsf_plogi *els_plogi = 206 (struct fsf_plogi *) status_buffer->payload.data; 207 208 zfcp_fc_incoming_wwpn(req, els_plogi->serv_param.wwpn); 209 } 210 211 static void zfcp_fc_incoming_logo(struct zfcp_fsf_req *req) 212 { 213 struct fsf_status_read_buffer *status_buffer = 214 (struct fsf_status_read_buffer *)req->data; 215 struct fcp_logo *els_logo = 216 (struct fcp_logo *) status_buffer->payload.data; 217 218 zfcp_fc_incoming_wwpn(req, els_logo->nport_wwpn); 219 } 220 221 /** 222 * zfcp_fc_incoming_els - handle incoming ELS 223 * @fsf_req - request which contains incoming ELS 224 */ 225 void zfcp_fc_incoming_els(struct zfcp_fsf_req *fsf_req) 226 { 227 struct fsf_status_read_buffer *status_buffer = 228 (struct fsf_status_read_buffer *) fsf_req->data; 229 unsigned int els_type = status_buffer->payload.data[0]; 230 231 zfcp_san_dbf_event_incoming_els(fsf_req); 232 if (els_type == LS_PLOGI) 233 zfcp_fc_incoming_plogi(fsf_req); 234 else if (els_type == LS_LOGO) 235 zfcp_fc_incoming_logo(fsf_req); 236 else if (els_type == LS_RSCN) 237 zfcp_fc_incoming_rscn(fsf_req); 238 } 239 240 static void zfcp_fc_ns_handler(unsigned long data) 241 { 242 struct zfcp_fc_ns_handler_data *compl_rec = 243 (struct zfcp_fc_ns_handler_data *) data; 244 245 if (compl_rec->handler) 246 compl_rec->handler(compl_rec->handler_data); 247 248 complete(&compl_rec->done); 249 } 250 251 static void zfcp_fc_ns_gid_pn_eval(unsigned long data) 252 { 253 struct zfcp_gid_pn_data *gid_pn = (struct zfcp_gid_pn_data *) data; 254 struct zfcp_send_ct *ct = &gid_pn->ct; 255 struct ct_iu_gid_pn_req *ct_iu_req = sg_virt(ct->req); 256 struct ct_iu_gid_pn_resp *ct_iu_resp = sg_virt(ct->resp); 257 struct zfcp_port *port = gid_pn->port; 258 259 if (ct->status) 260 return; 261 if (ct_iu_resp->header.cmd_rsp_code != ZFCP_CT_ACCEPT) 262 return; 263 264 /* paranoia */ 265 if (ct_iu_req->wwpn != port->wwpn) 266 return; 267 /* looks like a valid d_id */ 268 port->d_id = ct_iu_resp->d_id & ZFCP_DID_MASK; 269 } 270 271 int static zfcp_fc_ns_gid_pn_request(struct zfcp_erp_action *erp_action, 272 struct zfcp_gid_pn_data *gid_pn) 273 { 274 struct zfcp_adapter *adapter = erp_action->adapter; 275 struct zfcp_fc_ns_handler_data compl_rec; 276 int ret; 277 278 /* setup parameters for send generic command */ 279 gid_pn->port = erp_action->port; 280 gid_pn->ct.wka_port = &adapter->nsp; 281 gid_pn->ct.handler = zfcp_fc_ns_handler; 282 gid_pn->ct.handler_data = (unsigned long) &compl_rec; 283 gid_pn->ct.timeout = ZFCP_NS_GID_PN_TIMEOUT; 284 gid_pn->ct.req = &gid_pn->req; 285 gid_pn->ct.resp = &gid_pn->resp; 286 sg_init_one(&gid_pn->req, &gid_pn->ct_iu_req, 287 sizeof(struct ct_iu_gid_pn_req)); 288 sg_init_one(&gid_pn->resp, &gid_pn->ct_iu_resp, 289 sizeof(struct ct_iu_gid_pn_resp)); 290 291 /* setup nameserver request */ 292 gid_pn->ct_iu_req.header.revision = ZFCP_CT_REVISION; 293 gid_pn->ct_iu_req.header.gs_type = ZFCP_CT_DIRECTORY_SERVICE; 294 gid_pn->ct_iu_req.header.gs_subtype = ZFCP_CT_NAME_SERVER; 295 gid_pn->ct_iu_req.header.options = ZFCP_CT_SYNCHRONOUS; 296 gid_pn->ct_iu_req.header.cmd_rsp_code = ZFCP_CT_GID_PN; 297 gid_pn->ct_iu_req.header.max_res_size = ZFCP_CT_SIZE_ONE_PAGE / 4; 298 gid_pn->ct_iu_req.wwpn = erp_action->port->wwpn; 299 300 init_completion(&compl_rec.done); 301 compl_rec.handler = zfcp_fc_ns_gid_pn_eval; 302 compl_rec.handler_data = (unsigned long) gid_pn; 303 ret = zfcp_fsf_send_ct(&gid_pn->ct, adapter->pool.fsf_req_erp, 304 erp_action); 305 if (!ret) 306 wait_for_completion(&compl_rec.done); 307 return ret; 308 } 309 310 /** 311 * zfcp_fc_ns_gid_pn_request - initiate GID_PN nameserver request 312 * @erp_action: pointer to zfcp_erp_action where GID_PN request is needed 313 * return: -ENOMEM on error, 0 otherwise 314 */ 315 int zfcp_fc_ns_gid_pn(struct zfcp_erp_action *erp_action) 316 { 317 int ret; 318 struct zfcp_gid_pn_data *gid_pn; 319 struct zfcp_adapter *adapter = erp_action->adapter; 320 321 gid_pn = mempool_alloc(adapter->pool.data_gid_pn, GFP_ATOMIC); 322 if (!gid_pn) 323 return -ENOMEM; 324 325 memset(gid_pn, 0, sizeof(*gid_pn)); 326 327 ret = zfcp_wka_port_get(&adapter->nsp); 328 if (ret) 329 goto out; 330 331 ret = zfcp_fc_ns_gid_pn_request(erp_action, gid_pn); 332 333 zfcp_wka_port_put(&adapter->nsp); 334 out: 335 mempool_free(gid_pn, adapter->pool.data_gid_pn); 336 return ret; 337 } 338 339 /** 340 * zfcp_fc_plogi_evaluate - evaluate PLOGI playload 341 * @port: zfcp_port structure 342 * @plogi: plogi payload 343 * 344 * Evaluate PLOGI playload and copy important fields into zfcp_port structure 345 */ 346 void zfcp_fc_plogi_evaluate(struct zfcp_port *port, struct fsf_plogi *plogi) 347 { 348 port->maxframe_size = plogi->serv_param.common_serv_param[7] | 349 ((plogi->serv_param.common_serv_param[6] & 0x0F) << 8); 350 if (plogi->serv_param.class1_serv_param[0] & 0x80) 351 port->supported_classes |= FC_COS_CLASS1; 352 if (plogi->serv_param.class2_serv_param[0] & 0x80) 353 port->supported_classes |= FC_COS_CLASS2; 354 if (plogi->serv_param.class3_serv_param[0] & 0x80) 355 port->supported_classes |= FC_COS_CLASS3; 356 if (plogi->serv_param.class4_serv_param[0] & 0x80) 357 port->supported_classes |= FC_COS_CLASS4; 358 } 359 360 struct zfcp_els_adisc { 361 struct zfcp_send_els els; 362 struct scatterlist req; 363 struct scatterlist resp; 364 struct zfcp_ls_adisc ls_adisc; 365 struct zfcp_ls_adisc ls_adisc_acc; 366 }; 367 368 static void zfcp_fc_adisc_handler(unsigned long data) 369 { 370 struct zfcp_els_adisc *adisc = (struct zfcp_els_adisc *) data; 371 struct zfcp_port *port = adisc->els.port; 372 struct zfcp_ls_adisc *ls_adisc = &adisc->ls_adisc_acc; 373 374 if (adisc->els.status) { 375 /* request rejected or timed out */ 376 zfcp_erp_port_forced_reopen(port, ZFCP_STATUS_COMMON_ERP_FAILED, 377 "fcadh_1", NULL); 378 goto out; 379 } 380 381 if (!port->wwnn) 382 port->wwnn = ls_adisc->wwnn; 383 384 if ((port->wwpn != ls_adisc->wwpn) || 385 !(atomic_read(&port->status) & ZFCP_STATUS_COMMON_OPEN)) { 386 zfcp_erp_port_reopen(port, ZFCP_STATUS_COMMON_ERP_FAILED, 387 "fcadh_2", NULL); 388 goto out; 389 } 390 391 /* port is good, unblock rport without going through erp */ 392 zfcp_scsi_schedule_rport_register(port); 393 out: 394 zfcp_port_put(port); 395 kfree(adisc); 396 } 397 398 static int zfcp_fc_adisc(struct zfcp_port *port) 399 { 400 struct zfcp_els_adisc *adisc; 401 struct zfcp_adapter *adapter = port->adapter; 402 403 adisc = kzalloc(sizeof(struct zfcp_els_adisc), GFP_ATOMIC); 404 if (!adisc) 405 return -ENOMEM; 406 407 adisc->els.req = &adisc->req; 408 adisc->els.resp = &adisc->resp; 409 sg_init_one(adisc->els.req, &adisc->ls_adisc, 410 sizeof(struct zfcp_ls_adisc)); 411 sg_init_one(adisc->els.resp, &adisc->ls_adisc_acc, 412 sizeof(struct zfcp_ls_adisc)); 413 414 adisc->els.adapter = adapter; 415 adisc->els.port = port; 416 adisc->els.d_id = port->d_id; 417 adisc->els.handler = zfcp_fc_adisc_handler; 418 adisc->els.handler_data = (unsigned long) adisc; 419 adisc->els.ls_code = adisc->ls_adisc.code = ZFCP_LS_ADISC; 420 421 /* acc. to FC-FS, hard_nport_id in ADISC should not be set for ports 422 without FC-AL-2 capability, so we don't set it */ 423 adisc->ls_adisc.wwpn = fc_host_port_name(adapter->scsi_host); 424 adisc->ls_adisc.wwnn = fc_host_node_name(adapter->scsi_host); 425 adisc->ls_adisc.nport_id = fc_host_port_id(adapter->scsi_host); 426 427 return zfcp_fsf_send_els(&adisc->els); 428 } 429 430 void zfcp_fc_link_test_work(struct work_struct *work) 431 { 432 struct zfcp_port *port = 433 container_of(work, struct zfcp_port, test_link_work); 434 int retval; 435 436 zfcp_port_get(port); 437 port->rport_task = RPORT_DEL; 438 zfcp_scsi_rport_work(&port->rport_work); 439 440 retval = zfcp_fc_adisc(port); 441 if (retval == 0) 442 return; 443 444 /* send of ADISC was not possible */ 445 zfcp_erp_port_forced_reopen(port, 0, "fcltwk1", NULL); 446 447 zfcp_port_put(port); 448 } 449 450 /** 451 * zfcp_test_link - lightweight link test procedure 452 * @port: port to be tested 453 * 454 * Test status of a link to a remote port using the ELS command ADISC. 455 * If there is a problem with the remote port, error recovery steps 456 * will be triggered. 457 */ 458 void zfcp_test_link(struct zfcp_port *port) 459 { 460 zfcp_port_get(port); 461 if (!queue_work(zfcp_data.work_queue, &port->test_link_work)) 462 zfcp_port_put(port); 463 } 464 465 static void zfcp_free_sg_env(struct zfcp_gpn_ft *gpn_ft, int buf_num) 466 { 467 struct scatterlist *sg = &gpn_ft->sg_req; 468 469 kfree(sg_virt(sg)); /* free request buffer */ 470 zfcp_sg_free_table(gpn_ft->sg_resp, buf_num); 471 472 kfree(gpn_ft); 473 } 474 475 static struct zfcp_gpn_ft *zfcp_alloc_sg_env(int buf_num) 476 { 477 struct zfcp_gpn_ft *gpn_ft; 478 struct ct_iu_gpn_ft_req *req; 479 480 gpn_ft = kzalloc(sizeof(*gpn_ft), GFP_KERNEL); 481 if (!gpn_ft) 482 return NULL; 483 484 req = kzalloc(sizeof(struct ct_iu_gpn_ft_req), GFP_KERNEL); 485 if (!req) { 486 kfree(gpn_ft); 487 gpn_ft = NULL; 488 goto out; 489 } 490 sg_init_one(&gpn_ft->sg_req, req, sizeof(*req)); 491 492 if (zfcp_sg_setup_table(gpn_ft->sg_resp, buf_num)) { 493 zfcp_free_sg_env(gpn_ft, buf_num); 494 gpn_ft = NULL; 495 } 496 out: 497 return gpn_ft; 498 } 499 500 501 static int zfcp_scan_issue_gpn_ft(struct zfcp_gpn_ft *gpn_ft, 502 struct zfcp_adapter *adapter, 503 int max_bytes) 504 { 505 struct zfcp_send_ct *ct = &gpn_ft->ct; 506 struct ct_iu_gpn_ft_req *req = sg_virt(&gpn_ft->sg_req); 507 struct zfcp_fc_ns_handler_data compl_rec; 508 int ret; 509 510 /* prepare CT IU for GPN_FT */ 511 req->header.revision = ZFCP_CT_REVISION; 512 req->header.gs_type = ZFCP_CT_DIRECTORY_SERVICE; 513 req->header.gs_subtype = ZFCP_CT_NAME_SERVER; 514 req->header.options = ZFCP_CT_SYNCHRONOUS; 515 req->header.cmd_rsp_code = ZFCP_CT_GPN_FT; 516 req->header.max_res_size = max_bytes / 4; 517 req->flags = 0; 518 req->domain_id_scope = 0; 519 req->area_id_scope = 0; 520 req->fc4_type = ZFCP_CT_SCSI_FCP; 521 522 /* prepare zfcp_send_ct */ 523 ct->wka_port = &adapter->nsp; 524 ct->handler = zfcp_fc_ns_handler; 525 ct->handler_data = (unsigned long)&compl_rec; 526 ct->timeout = 10; 527 ct->req = &gpn_ft->sg_req; 528 ct->resp = gpn_ft->sg_resp; 529 530 init_completion(&compl_rec.done); 531 compl_rec.handler = NULL; 532 ret = zfcp_fsf_send_ct(ct, NULL, NULL); 533 if (!ret) 534 wait_for_completion(&compl_rec.done); 535 return ret; 536 } 537 538 static void zfcp_validate_port(struct zfcp_port *port) 539 { 540 struct zfcp_adapter *adapter = port->adapter; 541 542 if (!(atomic_read(&port->status) & ZFCP_STATUS_COMMON_NOESC)) 543 return; 544 545 atomic_clear_mask(ZFCP_STATUS_COMMON_NOESC, &port->status); 546 547 if ((port->supported_classes != 0) || 548 !list_empty(&port->unit_list_head)) { 549 zfcp_port_put(port); 550 return; 551 } 552 zfcp_erp_port_shutdown(port, 0, "fcpval1", NULL); 553 zfcp_erp_wait(adapter); 554 zfcp_port_put(port); 555 zfcp_port_dequeue(port); 556 } 557 558 static int zfcp_scan_eval_gpn_ft(struct zfcp_gpn_ft *gpn_ft, int max_entries) 559 { 560 struct zfcp_send_ct *ct = &gpn_ft->ct; 561 struct scatterlist *sg = gpn_ft->sg_resp; 562 struct ct_hdr *hdr = sg_virt(sg); 563 struct gpn_ft_resp_acc *acc = sg_virt(sg); 564 struct zfcp_adapter *adapter = ct->wka_port->adapter; 565 struct zfcp_port *port, *tmp; 566 u32 d_id; 567 int ret = 0, x, last = 0; 568 569 if (ct->status) 570 return -EIO; 571 572 if (hdr->cmd_rsp_code != ZFCP_CT_ACCEPT) { 573 if (hdr->reason_code == ZFCP_CT_UNABLE_TO_PERFORM_CMD) 574 return -EAGAIN; /* might be a temporary condition */ 575 return -EIO; 576 } 577 578 if (hdr->max_res_size) { 579 dev_warn(&adapter->ccw_device->dev, 580 "The name server reported %d words residual data\n", 581 hdr->max_res_size); 582 return -E2BIG; 583 } 584 585 down(&zfcp_data.config_sema); 586 587 /* first entry is the header */ 588 for (x = 1; x < max_entries && !last; x++) { 589 if (x % (ZFCP_GPN_FT_ENTRIES + 1)) 590 acc++; 591 else 592 acc = sg_virt(++sg); 593 594 last = acc->control & 0x80; 595 d_id = acc->port_id[0] << 16 | acc->port_id[1] << 8 | 596 acc->port_id[2]; 597 598 /* don't attach ports with a well known address */ 599 if ((d_id & ZFCP_DID_WKA) == ZFCP_DID_WKA) 600 continue; 601 /* skip the adapter's port and known remote ports */ 602 if (acc->wwpn == fc_host_port_name(adapter->scsi_host)) 603 continue; 604 port = zfcp_get_port_by_wwpn(adapter, acc->wwpn); 605 if (port) 606 continue; 607 608 port = zfcp_port_enqueue(adapter, acc->wwpn, 609 ZFCP_STATUS_COMMON_NOESC, d_id); 610 if (IS_ERR(port)) 611 ret = PTR_ERR(port); 612 else 613 zfcp_erp_port_reopen(port, 0, "fcegpf1", NULL); 614 } 615 616 zfcp_erp_wait(adapter); 617 list_for_each_entry_safe(port, tmp, &adapter->port_list_head, list) 618 zfcp_validate_port(port); 619 up(&zfcp_data.config_sema); 620 return ret; 621 } 622 623 /** 624 * zfcp_scan_ports - scan remote ports and attach new ports 625 * @adapter: pointer to struct zfcp_adapter 626 */ 627 int zfcp_scan_ports(struct zfcp_adapter *adapter) 628 { 629 int ret, i; 630 struct zfcp_gpn_ft *gpn_ft; 631 int chain, max_entries, buf_num, max_bytes; 632 633 chain = adapter->adapter_features & FSF_FEATURE_ELS_CT_CHAINED_SBALS; 634 buf_num = chain ? ZFCP_GPN_FT_BUFFERS : 1; 635 max_entries = chain ? ZFCP_GPN_FT_MAX_ENTRIES : ZFCP_GPN_FT_ENTRIES; 636 max_bytes = chain ? ZFCP_GPN_FT_MAX_SIZE : ZFCP_CT_SIZE_ONE_PAGE; 637 638 if (fc_host_port_type(adapter->scsi_host) != FC_PORTTYPE_NPORT && 639 fc_host_port_type(adapter->scsi_host) != FC_PORTTYPE_NPIV) 640 return 0; 641 642 ret = zfcp_wka_port_get(&adapter->nsp); 643 if (ret) 644 return ret; 645 646 gpn_ft = zfcp_alloc_sg_env(buf_num); 647 if (!gpn_ft) { 648 ret = -ENOMEM; 649 goto out; 650 } 651 652 for (i = 0; i < 3; i++) { 653 ret = zfcp_scan_issue_gpn_ft(gpn_ft, adapter, max_bytes); 654 if (!ret) { 655 ret = zfcp_scan_eval_gpn_ft(gpn_ft, max_entries); 656 if (ret == -EAGAIN) 657 ssleep(1); 658 else 659 break; 660 } 661 } 662 zfcp_free_sg_env(gpn_ft, buf_num); 663 out: 664 zfcp_wka_port_put(&adapter->nsp); 665 return ret; 666 } 667 668 669 void _zfcp_scan_ports_later(struct work_struct *work) 670 { 671 zfcp_scan_ports(container_of(work, struct zfcp_adapter, scan_work)); 672 } 673