1 /* 2 * zfcp device driver 3 * 4 * Fibre Channel related functions for the zfcp device driver. 5 * 6 * Copyright IBM Corp. 2008, 2010 7 */ 8 9 #define KMSG_COMPONENT "zfcp" 10 #define pr_fmt(fmt) KMSG_COMPONENT ": " fmt 11 12 #include <linux/types.h> 13 #include <linux/slab.h> 14 #include <linux/utsname.h> 15 #include <scsi/fc/fc_els.h> 16 #include <scsi/libfc.h> 17 #include "zfcp_ext.h" 18 #include "zfcp_fc.h" 19 20 struct kmem_cache *zfcp_fc_req_cache; 21 22 static u32 zfcp_fc_rscn_range_mask[] = { 23 [ELS_ADDR_FMT_PORT] = 0xFFFFFF, 24 [ELS_ADDR_FMT_AREA] = 0xFFFF00, 25 [ELS_ADDR_FMT_DOM] = 0xFF0000, 26 [ELS_ADDR_FMT_FAB] = 0x000000, 27 }; 28 29 /** 30 * zfcp_fc_post_event - post event to userspace via fc_transport 31 * @work: work struct with enqueued events 32 */ 33 void zfcp_fc_post_event(struct work_struct *work) 34 { 35 struct zfcp_fc_event *event = NULL, *tmp = NULL; 36 LIST_HEAD(tmp_lh); 37 struct zfcp_fc_events *events = container_of(work, 38 struct zfcp_fc_events, work); 39 struct zfcp_adapter *adapter = container_of(events, struct zfcp_adapter, 40 events); 41 42 spin_lock_bh(&events->list_lock); 43 list_splice_init(&events->list, &tmp_lh); 44 spin_unlock_bh(&events->list_lock); 45 46 list_for_each_entry_safe(event, tmp, &tmp_lh, list) { 47 fc_host_post_event(adapter->scsi_host, fc_get_event_number(), 48 event->code, event->data); 49 list_del(&event->list); 50 kfree(event); 51 } 52 53 } 54 55 /** 56 * zfcp_fc_enqueue_event - safely enqueue FC HBA API event from irq context 57 * @adapter: The adapter where to enqueue the event 58 * @event_code: The event code (as defined in fc_host_event_code in 59 * scsi_transport_fc.h) 60 * @event_data: The event data (e.g. n_port page in case of els) 61 */ 62 void zfcp_fc_enqueue_event(struct zfcp_adapter *adapter, 63 enum fc_host_event_code event_code, u32 event_data) 64 { 65 struct zfcp_fc_event *event; 66 67 event = kmalloc(sizeof(struct zfcp_fc_event), GFP_ATOMIC); 68 if (!event) 69 return; 70 71 event->code = event_code; 72 event->data = event_data; 73 74 spin_lock(&adapter->events.list_lock); 75 list_add_tail(&event->list, &adapter->events.list); 76 spin_unlock(&adapter->events.list_lock); 77 78 queue_work(adapter->work_queue, &adapter->events.work); 79 } 80 81 static int zfcp_fc_wka_port_get(struct zfcp_fc_wka_port *wka_port) 82 { 83 if (mutex_lock_interruptible(&wka_port->mutex)) 84 return -ERESTARTSYS; 85 86 if (wka_port->status == ZFCP_FC_WKA_PORT_OFFLINE || 87 wka_port->status == ZFCP_FC_WKA_PORT_CLOSING) { 88 wka_port->status = ZFCP_FC_WKA_PORT_OPENING; 89 if (zfcp_fsf_open_wka_port(wka_port)) 90 wka_port->status = ZFCP_FC_WKA_PORT_OFFLINE; 91 } 92 93 mutex_unlock(&wka_port->mutex); 94 95 wait_event(wka_port->completion_wq, 96 wka_port->status == ZFCP_FC_WKA_PORT_ONLINE || 97 wka_port->status == ZFCP_FC_WKA_PORT_OFFLINE); 98 99 if (wka_port->status == ZFCP_FC_WKA_PORT_ONLINE) { 100 atomic_inc(&wka_port->refcount); 101 return 0; 102 } 103 return -EIO; 104 } 105 106 static void zfcp_fc_wka_port_offline(struct work_struct *work) 107 { 108 struct delayed_work *dw = to_delayed_work(work); 109 struct zfcp_fc_wka_port *wka_port = 110 container_of(dw, struct zfcp_fc_wka_port, work); 111 112 mutex_lock(&wka_port->mutex); 113 if ((atomic_read(&wka_port->refcount) != 0) || 114 (wka_port->status != ZFCP_FC_WKA_PORT_ONLINE)) 115 goto out; 116 117 wka_port->status = ZFCP_FC_WKA_PORT_CLOSING; 118 if (zfcp_fsf_close_wka_port(wka_port)) { 119 wka_port->status = ZFCP_FC_WKA_PORT_OFFLINE; 120 wake_up(&wka_port->completion_wq); 121 } 122 out: 123 mutex_unlock(&wka_port->mutex); 124 } 125 126 static void zfcp_fc_wka_port_put(struct zfcp_fc_wka_port *wka_port) 127 { 128 if (atomic_dec_return(&wka_port->refcount) != 0) 129 return; 130 /* wait 10 milliseconds, other reqs might pop in */ 131 schedule_delayed_work(&wka_port->work, HZ / 100); 132 } 133 134 static void zfcp_fc_wka_port_init(struct zfcp_fc_wka_port *wka_port, u32 d_id, 135 struct zfcp_adapter *adapter) 136 { 137 init_waitqueue_head(&wka_port->completion_wq); 138 139 wka_port->adapter = adapter; 140 wka_port->d_id = d_id; 141 142 wka_port->status = ZFCP_FC_WKA_PORT_OFFLINE; 143 atomic_set(&wka_port->refcount, 0); 144 mutex_init(&wka_port->mutex); 145 INIT_DELAYED_WORK(&wka_port->work, zfcp_fc_wka_port_offline); 146 } 147 148 static void zfcp_fc_wka_port_force_offline(struct zfcp_fc_wka_port *wka) 149 { 150 cancel_delayed_work_sync(&wka->work); 151 mutex_lock(&wka->mutex); 152 wka->status = ZFCP_FC_WKA_PORT_OFFLINE; 153 mutex_unlock(&wka->mutex); 154 } 155 156 void zfcp_fc_wka_ports_force_offline(struct zfcp_fc_wka_ports *gs) 157 { 158 if (!gs) 159 return; 160 zfcp_fc_wka_port_force_offline(&gs->ms); 161 zfcp_fc_wka_port_force_offline(&gs->ts); 162 zfcp_fc_wka_port_force_offline(&gs->ds); 163 zfcp_fc_wka_port_force_offline(&gs->as); 164 } 165 166 static void _zfcp_fc_incoming_rscn(struct zfcp_fsf_req *fsf_req, u32 range, 167 struct fc_els_rscn_page *page) 168 { 169 unsigned long flags; 170 struct zfcp_adapter *adapter = fsf_req->adapter; 171 struct zfcp_port *port; 172 173 read_lock_irqsave(&adapter->port_list_lock, flags); 174 list_for_each_entry(port, &adapter->port_list, list) { 175 if ((port->d_id & range) == (ntoh24(page->rscn_fid) & range)) 176 zfcp_fc_test_link(port); 177 if (!port->d_id) 178 zfcp_erp_port_reopen(port, 179 ZFCP_STATUS_COMMON_ERP_FAILED, 180 "fcrscn1"); 181 } 182 read_unlock_irqrestore(&adapter->port_list_lock, flags); 183 } 184 185 static void zfcp_fc_incoming_rscn(struct zfcp_fsf_req *fsf_req) 186 { 187 struct fsf_status_read_buffer *status_buffer = (void *)fsf_req->data; 188 struct fc_els_rscn *head; 189 struct fc_els_rscn_page *page; 190 u16 i; 191 u16 no_entries; 192 unsigned int afmt; 193 194 head = (struct fc_els_rscn *) status_buffer->payload.data; 195 page = (struct fc_els_rscn_page *) head; 196 197 /* see FC-FS */ 198 no_entries = head->rscn_plen / sizeof(struct fc_els_rscn_page); 199 200 for (i = 1; i < no_entries; i++) { 201 /* skip head and start with 1st element */ 202 page++; 203 afmt = page->rscn_page_flags & ELS_RSCN_ADDR_FMT_MASK; 204 _zfcp_fc_incoming_rscn(fsf_req, zfcp_fc_rscn_range_mask[afmt], 205 page); 206 zfcp_fc_enqueue_event(fsf_req->adapter, FCH_EVT_RSCN, 207 *(u32 *)page); 208 } 209 queue_work(fsf_req->adapter->work_queue, &fsf_req->adapter->scan_work); 210 } 211 212 static void zfcp_fc_incoming_wwpn(struct zfcp_fsf_req *req, u64 wwpn) 213 { 214 unsigned long flags; 215 struct zfcp_adapter *adapter = req->adapter; 216 struct zfcp_port *port; 217 218 read_lock_irqsave(&adapter->port_list_lock, flags); 219 list_for_each_entry(port, &adapter->port_list, list) 220 if (port->wwpn == wwpn) { 221 zfcp_erp_port_forced_reopen(port, 0, "fciwwp1"); 222 break; 223 } 224 read_unlock_irqrestore(&adapter->port_list_lock, flags); 225 } 226 227 static void zfcp_fc_incoming_plogi(struct zfcp_fsf_req *req) 228 { 229 struct fsf_status_read_buffer *status_buffer; 230 struct fc_els_flogi *plogi; 231 232 status_buffer = (struct fsf_status_read_buffer *) req->data; 233 plogi = (struct fc_els_flogi *) status_buffer->payload.data; 234 zfcp_fc_incoming_wwpn(req, plogi->fl_wwpn); 235 } 236 237 static void zfcp_fc_incoming_logo(struct zfcp_fsf_req *req) 238 { 239 struct fsf_status_read_buffer *status_buffer = 240 (struct fsf_status_read_buffer *)req->data; 241 struct fc_els_logo *logo = 242 (struct fc_els_logo *) status_buffer->payload.data; 243 244 zfcp_fc_incoming_wwpn(req, logo->fl_n_port_wwn); 245 } 246 247 /** 248 * zfcp_fc_incoming_els - handle incoming ELS 249 * @fsf_req - request which contains incoming ELS 250 */ 251 void zfcp_fc_incoming_els(struct zfcp_fsf_req *fsf_req) 252 { 253 struct fsf_status_read_buffer *status_buffer = 254 (struct fsf_status_read_buffer *) fsf_req->data; 255 unsigned int els_type = status_buffer->payload.data[0]; 256 257 zfcp_dbf_san_in_els("fciels1", fsf_req); 258 if (els_type == ELS_PLOGI) 259 zfcp_fc_incoming_plogi(fsf_req); 260 else if (els_type == ELS_LOGO) 261 zfcp_fc_incoming_logo(fsf_req); 262 else if (els_type == ELS_RSCN) 263 zfcp_fc_incoming_rscn(fsf_req); 264 } 265 266 static void zfcp_fc_ns_gid_pn_eval(struct zfcp_fc_req *fc_req) 267 { 268 struct zfcp_fsf_ct_els *ct_els = &fc_req->ct_els; 269 struct zfcp_fc_gid_pn_rsp *gid_pn_rsp = &fc_req->u.gid_pn.rsp; 270 271 if (ct_els->status) 272 return; 273 if (gid_pn_rsp->ct_hdr.ct_cmd != FC_FS_ACC) 274 return; 275 276 /* looks like a valid d_id */ 277 ct_els->port->d_id = ntoh24(gid_pn_rsp->gid_pn.fp_fid); 278 } 279 280 static void zfcp_fc_complete(void *data) 281 { 282 complete(data); 283 } 284 285 static void zfcp_fc_ct_ns_init(struct fc_ct_hdr *ct_hdr, u16 cmd, u16 mr_size) 286 { 287 ct_hdr->ct_rev = FC_CT_REV; 288 ct_hdr->ct_fs_type = FC_FST_DIR; 289 ct_hdr->ct_fs_subtype = FC_NS_SUBTYPE; 290 ct_hdr->ct_cmd = cmd; 291 ct_hdr->ct_mr_size = mr_size / 4; 292 } 293 294 static int zfcp_fc_ns_gid_pn_request(struct zfcp_port *port, 295 struct zfcp_fc_req *fc_req) 296 { 297 struct zfcp_adapter *adapter = port->adapter; 298 DECLARE_COMPLETION_ONSTACK(completion); 299 struct zfcp_fc_gid_pn_req *gid_pn_req = &fc_req->u.gid_pn.req; 300 struct zfcp_fc_gid_pn_rsp *gid_pn_rsp = &fc_req->u.gid_pn.rsp; 301 int ret; 302 303 /* setup parameters for send generic command */ 304 fc_req->ct_els.port = port; 305 fc_req->ct_els.handler = zfcp_fc_complete; 306 fc_req->ct_els.handler_data = &completion; 307 fc_req->ct_els.req = &fc_req->sg_req; 308 fc_req->ct_els.resp = &fc_req->sg_rsp; 309 sg_init_one(&fc_req->sg_req, gid_pn_req, sizeof(*gid_pn_req)); 310 sg_init_one(&fc_req->sg_rsp, gid_pn_rsp, sizeof(*gid_pn_rsp)); 311 312 zfcp_fc_ct_ns_init(&gid_pn_req->ct_hdr, 313 FC_NS_GID_PN, ZFCP_FC_CT_SIZE_PAGE); 314 gid_pn_req->gid_pn.fn_wwpn = port->wwpn; 315 316 ret = zfcp_fsf_send_ct(&adapter->gs->ds, &fc_req->ct_els, 317 adapter->pool.gid_pn_req, 318 ZFCP_FC_CTELS_TMO); 319 if (!ret) { 320 wait_for_completion(&completion); 321 zfcp_fc_ns_gid_pn_eval(fc_req); 322 } 323 return ret; 324 } 325 326 /** 327 * zfcp_fc_ns_gid_pn - initiate GID_PN nameserver request 328 * @port: port where GID_PN request is needed 329 * return: -ENOMEM on error, 0 otherwise 330 */ 331 static int zfcp_fc_ns_gid_pn(struct zfcp_port *port) 332 { 333 int ret; 334 struct zfcp_fc_req *fc_req; 335 struct zfcp_adapter *adapter = port->adapter; 336 337 fc_req = mempool_alloc(adapter->pool.gid_pn, GFP_ATOMIC); 338 if (!fc_req) 339 return -ENOMEM; 340 341 memset(fc_req, 0, sizeof(*fc_req)); 342 343 ret = zfcp_fc_wka_port_get(&adapter->gs->ds); 344 if (ret) 345 goto out; 346 347 ret = zfcp_fc_ns_gid_pn_request(port, fc_req); 348 349 zfcp_fc_wka_port_put(&adapter->gs->ds); 350 out: 351 mempool_free(fc_req, adapter->pool.gid_pn); 352 return ret; 353 } 354 355 void zfcp_fc_port_did_lookup(struct work_struct *work) 356 { 357 int ret; 358 struct zfcp_port *port = container_of(work, struct zfcp_port, 359 gid_pn_work); 360 361 ret = zfcp_fc_ns_gid_pn(port); 362 if (ret) { 363 /* could not issue gid_pn for some reason */ 364 zfcp_erp_adapter_reopen(port->adapter, 0, "fcgpn_1"); 365 goto out; 366 } 367 368 if (!port->d_id) { 369 zfcp_erp_set_port_status(port, ZFCP_STATUS_COMMON_ERP_FAILED); 370 goto out; 371 } 372 373 zfcp_erp_port_reopen(port, 0, "fcgpn_3"); 374 out: 375 put_device(&port->dev); 376 } 377 378 /** 379 * zfcp_fc_trigger_did_lookup - trigger the d_id lookup using a GID_PN request 380 * @port: The zfcp_port to lookup the d_id for. 381 */ 382 void zfcp_fc_trigger_did_lookup(struct zfcp_port *port) 383 { 384 get_device(&port->dev); 385 if (!queue_work(port->adapter->work_queue, &port->gid_pn_work)) 386 put_device(&port->dev); 387 } 388 389 /** 390 * zfcp_fc_plogi_evaluate - evaluate PLOGI playload 391 * @port: zfcp_port structure 392 * @plogi: plogi payload 393 * 394 * Evaluate PLOGI playload and copy important fields into zfcp_port structure 395 */ 396 void zfcp_fc_plogi_evaluate(struct zfcp_port *port, struct fc_els_flogi *plogi) 397 { 398 if (plogi->fl_wwpn != port->wwpn) { 399 port->d_id = 0; 400 dev_warn(&port->adapter->ccw_device->dev, 401 "A port opened with WWPN 0x%016Lx returned data that " 402 "identifies it as WWPN 0x%016Lx\n", 403 (unsigned long long) port->wwpn, 404 (unsigned long long) plogi->fl_wwpn); 405 return; 406 } 407 408 port->wwnn = plogi->fl_wwnn; 409 port->maxframe_size = plogi->fl_csp.sp_bb_data; 410 411 if (plogi->fl_cssp[0].cp_class & FC_CPC_VALID) 412 port->supported_classes |= FC_COS_CLASS1; 413 if (plogi->fl_cssp[1].cp_class & FC_CPC_VALID) 414 port->supported_classes |= FC_COS_CLASS2; 415 if (plogi->fl_cssp[2].cp_class & FC_CPC_VALID) 416 port->supported_classes |= FC_COS_CLASS3; 417 if (plogi->fl_cssp[3].cp_class & FC_CPC_VALID) 418 port->supported_classes |= FC_COS_CLASS4; 419 } 420 421 static void zfcp_fc_adisc_handler(void *data) 422 { 423 struct zfcp_fc_req *fc_req = data; 424 struct zfcp_port *port = fc_req->ct_els.port; 425 struct fc_els_adisc *adisc_resp = &fc_req->u.adisc.rsp; 426 427 if (fc_req->ct_els.status) { 428 /* request rejected or timed out */ 429 zfcp_erp_port_forced_reopen(port, ZFCP_STATUS_COMMON_ERP_FAILED, 430 "fcadh_1"); 431 goto out; 432 } 433 434 if (!port->wwnn) 435 port->wwnn = adisc_resp->adisc_wwnn; 436 437 if ((port->wwpn != adisc_resp->adisc_wwpn) || 438 !(atomic_read(&port->status) & ZFCP_STATUS_COMMON_OPEN)) { 439 zfcp_erp_port_reopen(port, ZFCP_STATUS_COMMON_ERP_FAILED, 440 "fcadh_2"); 441 goto out; 442 } 443 444 /* port is good, unblock rport without going through erp */ 445 zfcp_scsi_schedule_rport_register(port); 446 out: 447 atomic_clear_mask(ZFCP_STATUS_PORT_LINK_TEST, &port->status); 448 put_device(&port->dev); 449 kmem_cache_free(zfcp_fc_req_cache, fc_req); 450 } 451 452 static int zfcp_fc_adisc(struct zfcp_port *port) 453 { 454 struct zfcp_fc_req *fc_req; 455 struct zfcp_adapter *adapter = port->adapter; 456 struct Scsi_Host *shost = adapter->scsi_host; 457 int ret; 458 459 fc_req = kmem_cache_zalloc(zfcp_fc_req_cache, GFP_ATOMIC); 460 if (!fc_req) 461 return -ENOMEM; 462 463 fc_req->ct_els.port = port; 464 fc_req->ct_els.req = &fc_req->sg_req; 465 fc_req->ct_els.resp = &fc_req->sg_rsp; 466 sg_init_one(&fc_req->sg_req, &fc_req->u.adisc.req, 467 sizeof(struct fc_els_adisc)); 468 sg_init_one(&fc_req->sg_rsp, &fc_req->u.adisc.rsp, 469 sizeof(struct fc_els_adisc)); 470 471 fc_req->ct_els.handler = zfcp_fc_adisc_handler; 472 fc_req->ct_els.handler_data = fc_req; 473 474 /* acc. to FC-FS, hard_nport_id in ADISC should not be set for ports 475 without FC-AL-2 capability, so we don't set it */ 476 fc_req->u.adisc.req.adisc_wwpn = fc_host_port_name(shost); 477 fc_req->u.adisc.req.adisc_wwnn = fc_host_node_name(shost); 478 fc_req->u.adisc.req.adisc_cmd = ELS_ADISC; 479 hton24(fc_req->u.adisc.req.adisc_port_id, fc_host_port_id(shost)); 480 481 ret = zfcp_fsf_send_els(adapter, port->d_id, &fc_req->ct_els, 482 ZFCP_FC_CTELS_TMO); 483 if (ret) 484 kmem_cache_free(zfcp_fc_req_cache, fc_req); 485 486 return ret; 487 } 488 489 void zfcp_fc_link_test_work(struct work_struct *work) 490 { 491 struct zfcp_port *port = 492 container_of(work, struct zfcp_port, test_link_work); 493 int retval; 494 495 get_device(&port->dev); 496 port->rport_task = RPORT_DEL; 497 zfcp_scsi_rport_work(&port->rport_work); 498 499 /* only issue one test command at one time per port */ 500 if (atomic_read(&port->status) & ZFCP_STATUS_PORT_LINK_TEST) 501 goto out; 502 503 atomic_set_mask(ZFCP_STATUS_PORT_LINK_TEST, &port->status); 504 505 retval = zfcp_fc_adisc(port); 506 if (retval == 0) 507 return; 508 509 /* send of ADISC was not possible */ 510 atomic_clear_mask(ZFCP_STATUS_PORT_LINK_TEST, &port->status); 511 zfcp_erp_port_forced_reopen(port, 0, "fcltwk1"); 512 513 out: 514 put_device(&port->dev); 515 } 516 517 /** 518 * zfcp_fc_test_link - lightweight link test procedure 519 * @port: port to be tested 520 * 521 * Test status of a link to a remote port using the ELS command ADISC. 522 * If there is a problem with the remote port, error recovery steps 523 * will be triggered. 524 */ 525 void zfcp_fc_test_link(struct zfcp_port *port) 526 { 527 get_device(&port->dev); 528 if (!queue_work(port->adapter->work_queue, &port->test_link_work)) 529 put_device(&port->dev); 530 } 531 532 static struct zfcp_fc_req *zfcp_alloc_sg_env(int buf_num) 533 { 534 struct zfcp_fc_req *fc_req; 535 536 fc_req = kmem_cache_zalloc(zfcp_fc_req_cache, GFP_KERNEL); 537 if (!fc_req) 538 return NULL; 539 540 if (zfcp_sg_setup_table(&fc_req->sg_rsp, buf_num)) { 541 kmem_cache_free(zfcp_fc_req_cache, fc_req); 542 return NULL; 543 } 544 545 sg_init_one(&fc_req->sg_req, &fc_req->u.gpn_ft.req, 546 sizeof(struct zfcp_fc_gpn_ft_req)); 547 548 return fc_req; 549 } 550 551 static int zfcp_fc_send_gpn_ft(struct zfcp_fc_req *fc_req, 552 struct zfcp_adapter *adapter, int max_bytes) 553 { 554 struct zfcp_fsf_ct_els *ct_els = &fc_req->ct_els; 555 struct zfcp_fc_gpn_ft_req *req = &fc_req->u.gpn_ft.req; 556 DECLARE_COMPLETION_ONSTACK(completion); 557 int ret; 558 559 zfcp_fc_ct_ns_init(&req->ct_hdr, FC_NS_GPN_FT, max_bytes); 560 req->gpn_ft.fn_fc4_type = FC_TYPE_FCP; 561 562 ct_els->handler = zfcp_fc_complete; 563 ct_els->handler_data = &completion; 564 ct_els->req = &fc_req->sg_req; 565 ct_els->resp = &fc_req->sg_rsp; 566 567 ret = zfcp_fsf_send_ct(&adapter->gs->ds, ct_els, NULL, 568 ZFCP_FC_CTELS_TMO); 569 if (!ret) 570 wait_for_completion(&completion); 571 return ret; 572 } 573 574 static void zfcp_fc_validate_port(struct zfcp_port *port, struct list_head *lh) 575 { 576 if (!(atomic_read(&port->status) & ZFCP_STATUS_COMMON_NOESC)) 577 return; 578 579 atomic_clear_mask(ZFCP_STATUS_COMMON_NOESC, &port->status); 580 581 if ((port->supported_classes != 0) || 582 !list_empty(&port->unit_list)) 583 return; 584 585 list_move_tail(&port->list, lh); 586 } 587 588 static int zfcp_fc_eval_gpn_ft(struct zfcp_fc_req *fc_req, 589 struct zfcp_adapter *adapter, int max_entries) 590 { 591 struct zfcp_fsf_ct_els *ct_els = &fc_req->ct_els; 592 struct scatterlist *sg = &fc_req->sg_rsp; 593 struct fc_ct_hdr *hdr = sg_virt(sg); 594 struct fc_gpn_ft_resp *acc = sg_virt(sg); 595 struct zfcp_port *port, *tmp; 596 unsigned long flags; 597 LIST_HEAD(remove_lh); 598 u32 d_id; 599 int ret = 0, x, last = 0; 600 601 if (ct_els->status) 602 return -EIO; 603 604 if (hdr->ct_cmd != FC_FS_ACC) { 605 if (hdr->ct_reason == FC_BA_RJT_UNABLE) 606 return -EAGAIN; /* might be a temporary condition */ 607 return -EIO; 608 } 609 610 if (hdr->ct_mr_size) { 611 dev_warn(&adapter->ccw_device->dev, 612 "The name server reported %d words residual data\n", 613 hdr->ct_mr_size); 614 return -E2BIG; 615 } 616 617 /* first entry is the header */ 618 for (x = 1; x < max_entries && !last; x++) { 619 if (x % (ZFCP_FC_GPN_FT_ENT_PAGE + 1)) 620 acc++; 621 else 622 acc = sg_virt(++sg); 623 624 last = acc->fp_flags & FC_NS_FID_LAST; 625 d_id = ntoh24(acc->fp_fid); 626 627 /* don't attach ports with a well known address */ 628 if (d_id >= FC_FID_WELL_KNOWN_BASE) 629 continue; 630 /* skip the adapter's port and known remote ports */ 631 if (acc->fp_wwpn == fc_host_port_name(adapter->scsi_host)) 632 continue; 633 634 port = zfcp_port_enqueue(adapter, acc->fp_wwpn, 635 ZFCP_STATUS_COMMON_NOESC, d_id); 636 if (!IS_ERR(port)) 637 zfcp_erp_port_reopen(port, 0, "fcegpf1"); 638 else if (PTR_ERR(port) != -EEXIST) 639 ret = PTR_ERR(port); 640 } 641 642 zfcp_erp_wait(adapter); 643 write_lock_irqsave(&adapter->port_list_lock, flags); 644 list_for_each_entry_safe(port, tmp, &adapter->port_list, list) 645 zfcp_fc_validate_port(port, &remove_lh); 646 write_unlock_irqrestore(&adapter->port_list_lock, flags); 647 648 list_for_each_entry_safe(port, tmp, &remove_lh, list) { 649 zfcp_erp_port_shutdown(port, 0, "fcegpf2"); 650 zfcp_device_unregister(&port->dev, &zfcp_sysfs_port_attrs); 651 } 652 653 return ret; 654 } 655 656 /** 657 * zfcp_fc_scan_ports - scan remote ports and attach new ports 658 * @work: reference to scheduled work 659 */ 660 void zfcp_fc_scan_ports(struct work_struct *work) 661 { 662 struct zfcp_adapter *adapter = container_of(work, struct zfcp_adapter, 663 scan_work); 664 int ret, i; 665 struct zfcp_fc_req *fc_req; 666 int chain, max_entries, buf_num, max_bytes; 667 668 chain = adapter->adapter_features & FSF_FEATURE_ELS_CT_CHAINED_SBALS; 669 buf_num = chain ? ZFCP_FC_GPN_FT_NUM_BUFS : 1; 670 max_entries = chain ? ZFCP_FC_GPN_FT_MAX_ENT : ZFCP_FC_GPN_FT_ENT_PAGE; 671 max_bytes = chain ? ZFCP_FC_GPN_FT_MAX_SIZE : ZFCP_FC_CT_SIZE_PAGE; 672 673 if (fc_host_port_type(adapter->scsi_host) != FC_PORTTYPE_NPORT && 674 fc_host_port_type(adapter->scsi_host) != FC_PORTTYPE_NPIV) 675 return; 676 677 if (zfcp_fc_wka_port_get(&adapter->gs->ds)) 678 return; 679 680 fc_req = zfcp_alloc_sg_env(buf_num); 681 if (!fc_req) 682 goto out; 683 684 for (i = 0; i < 3; i++) { 685 ret = zfcp_fc_send_gpn_ft(fc_req, adapter, max_bytes); 686 if (!ret) { 687 ret = zfcp_fc_eval_gpn_ft(fc_req, adapter, max_entries); 688 if (ret == -EAGAIN) 689 ssleep(1); 690 else 691 break; 692 } 693 } 694 zfcp_sg_free_table(&fc_req->sg_rsp, buf_num); 695 kmem_cache_free(zfcp_fc_req_cache, fc_req); 696 out: 697 zfcp_fc_wka_port_put(&adapter->gs->ds); 698 } 699 700 static int zfcp_fc_gspn(struct zfcp_adapter *adapter, 701 struct zfcp_fc_req *fc_req) 702 { 703 DECLARE_COMPLETION_ONSTACK(completion); 704 char devno[] = "DEVNO:"; 705 struct zfcp_fsf_ct_els *ct_els = &fc_req->ct_els; 706 struct zfcp_fc_gspn_req *gspn_req = &fc_req->u.gspn.req; 707 struct zfcp_fc_gspn_rsp *gspn_rsp = &fc_req->u.gspn.rsp; 708 int ret; 709 710 zfcp_fc_ct_ns_init(&gspn_req->ct_hdr, FC_NS_GSPN_ID, 711 FC_SYMBOLIC_NAME_SIZE); 712 hton24(gspn_req->gspn.fp_fid, fc_host_port_id(adapter->scsi_host)); 713 714 sg_init_one(&fc_req->sg_req, gspn_req, sizeof(*gspn_req)); 715 sg_init_one(&fc_req->sg_rsp, gspn_rsp, sizeof(*gspn_rsp)); 716 717 ct_els->handler = zfcp_fc_complete; 718 ct_els->handler_data = &completion; 719 ct_els->req = &fc_req->sg_req; 720 ct_els->resp = &fc_req->sg_rsp; 721 722 ret = zfcp_fsf_send_ct(&adapter->gs->ds, ct_els, NULL, 723 ZFCP_FC_CTELS_TMO); 724 if (ret) 725 return ret; 726 727 wait_for_completion(&completion); 728 if (ct_els->status) 729 return ct_els->status; 730 731 if (fc_host_port_type(adapter->scsi_host) == FC_PORTTYPE_NPIV && 732 !(strstr(gspn_rsp->gspn.fp_name, devno))) 733 snprintf(fc_host_symbolic_name(adapter->scsi_host), 734 FC_SYMBOLIC_NAME_SIZE, "%s%s %s NAME: %s", 735 gspn_rsp->gspn.fp_name, devno, 736 dev_name(&adapter->ccw_device->dev), 737 init_utsname()->nodename); 738 else 739 strlcpy(fc_host_symbolic_name(adapter->scsi_host), 740 gspn_rsp->gspn.fp_name, FC_SYMBOLIC_NAME_SIZE); 741 742 return 0; 743 } 744 745 static void zfcp_fc_rspn(struct zfcp_adapter *adapter, 746 struct zfcp_fc_req *fc_req) 747 { 748 DECLARE_COMPLETION_ONSTACK(completion); 749 struct Scsi_Host *shost = adapter->scsi_host; 750 struct zfcp_fsf_ct_els *ct_els = &fc_req->ct_els; 751 struct zfcp_fc_rspn_req *rspn_req = &fc_req->u.rspn.req; 752 struct fc_ct_hdr *rspn_rsp = &fc_req->u.rspn.rsp; 753 int ret, len; 754 755 zfcp_fc_ct_ns_init(&rspn_req->ct_hdr, FC_NS_RSPN_ID, 756 FC_SYMBOLIC_NAME_SIZE); 757 hton24(rspn_req->rspn.fr_fid.fp_fid, fc_host_port_id(shost)); 758 len = strlcpy(rspn_req->rspn.fr_name, fc_host_symbolic_name(shost), 759 FC_SYMBOLIC_NAME_SIZE); 760 rspn_req->rspn.fr_name_len = len; 761 762 sg_init_one(&fc_req->sg_req, rspn_req, sizeof(*rspn_req)); 763 sg_init_one(&fc_req->sg_rsp, rspn_rsp, sizeof(*rspn_rsp)); 764 765 ct_els->handler = zfcp_fc_complete; 766 ct_els->handler_data = &completion; 767 ct_els->req = &fc_req->sg_req; 768 ct_els->resp = &fc_req->sg_rsp; 769 770 ret = zfcp_fsf_send_ct(&adapter->gs->ds, ct_els, NULL, 771 ZFCP_FC_CTELS_TMO); 772 if (!ret) 773 wait_for_completion(&completion); 774 } 775 776 /** 777 * zfcp_fc_sym_name_update - Retrieve and update the symbolic port name 778 * @work: ns_up_work of the adapter where to update the symbolic port name 779 * 780 * Retrieve the current symbolic port name that may have been set by 781 * the hardware using the GSPN request and update the fc_host 782 * symbolic_name sysfs attribute. When running in NPIV mode (and hence 783 * the port name is unique for this system), update the symbolic port 784 * name to add Linux specific information and update the FC nameserver 785 * using the RSPN request. 786 */ 787 void zfcp_fc_sym_name_update(struct work_struct *work) 788 { 789 struct zfcp_adapter *adapter = container_of(work, struct zfcp_adapter, 790 ns_up_work); 791 int ret; 792 struct zfcp_fc_req *fc_req; 793 794 if (fc_host_port_type(adapter->scsi_host) != FC_PORTTYPE_NPORT && 795 fc_host_port_type(adapter->scsi_host) != FC_PORTTYPE_NPIV) 796 return; 797 798 fc_req = kmem_cache_zalloc(zfcp_fc_req_cache, GFP_KERNEL); 799 if (!fc_req) 800 return; 801 802 ret = zfcp_fc_wka_port_get(&adapter->gs->ds); 803 if (ret) 804 goto out_free; 805 806 ret = zfcp_fc_gspn(adapter, fc_req); 807 if (ret || fc_host_port_type(adapter->scsi_host) != FC_PORTTYPE_NPIV) 808 goto out_ds_put; 809 810 memset(fc_req, 0, sizeof(*fc_req)); 811 zfcp_fc_rspn(adapter, fc_req); 812 813 out_ds_put: 814 zfcp_fc_wka_port_put(&adapter->gs->ds); 815 out_free: 816 kmem_cache_free(zfcp_fc_req_cache, fc_req); 817 } 818 819 static void zfcp_fc_ct_els_job_handler(void *data) 820 { 821 struct fc_bsg_job *job = data; 822 struct zfcp_fsf_ct_els *zfcp_ct_els = job->dd_data; 823 struct fc_bsg_reply *jr = job->reply; 824 825 jr->reply_payload_rcv_len = job->reply_payload.payload_len; 826 jr->reply_data.ctels_reply.status = FC_CTELS_STATUS_OK; 827 jr->result = zfcp_ct_els->status ? -EIO : 0; 828 job->job_done(job); 829 } 830 831 static struct zfcp_fc_wka_port *zfcp_fc_job_wka_port(struct fc_bsg_job *job) 832 { 833 u32 preamble_word1; 834 u8 gs_type; 835 struct zfcp_adapter *adapter; 836 837 preamble_word1 = job->request->rqst_data.r_ct.preamble_word1; 838 gs_type = (preamble_word1 & 0xff000000) >> 24; 839 840 adapter = (struct zfcp_adapter *) job->shost->hostdata[0]; 841 842 switch (gs_type) { 843 case FC_FST_ALIAS: 844 return &adapter->gs->as; 845 case FC_FST_MGMT: 846 return &adapter->gs->ms; 847 case FC_FST_TIME: 848 return &adapter->gs->ts; 849 break; 850 case FC_FST_DIR: 851 return &adapter->gs->ds; 852 break; 853 default: 854 return NULL; 855 } 856 } 857 858 static void zfcp_fc_ct_job_handler(void *data) 859 { 860 struct fc_bsg_job *job = data; 861 struct zfcp_fc_wka_port *wka_port; 862 863 wka_port = zfcp_fc_job_wka_port(job); 864 zfcp_fc_wka_port_put(wka_port); 865 866 zfcp_fc_ct_els_job_handler(data); 867 } 868 869 static int zfcp_fc_exec_els_job(struct fc_bsg_job *job, 870 struct zfcp_adapter *adapter) 871 { 872 struct zfcp_fsf_ct_els *els = job->dd_data; 873 struct fc_rport *rport = job->rport; 874 struct zfcp_port *port; 875 u32 d_id; 876 877 if (rport) { 878 port = zfcp_get_port_by_wwpn(adapter, rport->port_name); 879 if (!port) 880 return -EINVAL; 881 882 d_id = port->d_id; 883 put_device(&port->dev); 884 } else 885 d_id = ntoh24(job->request->rqst_data.h_els.port_id); 886 887 els->handler = zfcp_fc_ct_els_job_handler; 888 return zfcp_fsf_send_els(adapter, d_id, els, job->req->timeout / HZ); 889 } 890 891 static int zfcp_fc_exec_ct_job(struct fc_bsg_job *job, 892 struct zfcp_adapter *adapter) 893 { 894 int ret; 895 struct zfcp_fsf_ct_els *ct = job->dd_data; 896 struct zfcp_fc_wka_port *wka_port; 897 898 wka_port = zfcp_fc_job_wka_port(job); 899 if (!wka_port) 900 return -EINVAL; 901 902 ret = zfcp_fc_wka_port_get(wka_port); 903 if (ret) 904 return ret; 905 906 ct->handler = zfcp_fc_ct_job_handler; 907 ret = zfcp_fsf_send_ct(wka_port, ct, NULL, job->req->timeout / HZ); 908 if (ret) 909 zfcp_fc_wka_port_put(wka_port); 910 911 return ret; 912 } 913 914 int zfcp_fc_exec_bsg_job(struct fc_bsg_job *job) 915 { 916 struct Scsi_Host *shost; 917 struct zfcp_adapter *adapter; 918 struct zfcp_fsf_ct_els *ct_els = job->dd_data; 919 920 shost = job->rport ? rport_to_shost(job->rport) : job->shost; 921 adapter = (struct zfcp_adapter *)shost->hostdata[0]; 922 923 if (!(atomic_read(&adapter->status) & ZFCP_STATUS_COMMON_OPEN)) 924 return -EINVAL; 925 926 ct_els->req = job->request_payload.sg_list; 927 ct_els->resp = job->reply_payload.sg_list; 928 ct_els->handler_data = job; 929 930 switch (job->request->msgcode) { 931 case FC_BSG_RPT_ELS: 932 case FC_BSG_HST_ELS_NOLOGIN: 933 return zfcp_fc_exec_els_job(job, adapter); 934 case FC_BSG_RPT_CT: 935 case FC_BSG_HST_CT: 936 return zfcp_fc_exec_ct_job(job, adapter); 937 default: 938 return -EINVAL; 939 } 940 } 941 942 int zfcp_fc_timeout_bsg_job(struct fc_bsg_job *job) 943 { 944 /* hardware tracks timeout, reset bsg timeout to not interfere */ 945 return -EAGAIN; 946 } 947 948 int zfcp_fc_gs_setup(struct zfcp_adapter *adapter) 949 { 950 struct zfcp_fc_wka_ports *wka_ports; 951 952 wka_ports = kzalloc(sizeof(struct zfcp_fc_wka_ports), GFP_KERNEL); 953 if (!wka_ports) 954 return -ENOMEM; 955 956 adapter->gs = wka_ports; 957 zfcp_fc_wka_port_init(&wka_ports->ms, FC_FID_MGMT_SERV, adapter); 958 zfcp_fc_wka_port_init(&wka_ports->ts, FC_FID_TIME_SERV, adapter); 959 zfcp_fc_wka_port_init(&wka_ports->ds, FC_FID_DIR_SERV, adapter); 960 zfcp_fc_wka_port_init(&wka_ports->as, FC_FID_ALIASES, adapter); 961 962 return 0; 963 } 964 965 void zfcp_fc_gs_destroy(struct zfcp_adapter *adapter) 966 { 967 kfree(adapter->gs); 968 adapter->gs = NULL; 969 } 970 971