1 /* 2 * 3 * linux/drivers/s390/scsi/zfcp_erp.c 4 * 5 * FCP adapter driver for IBM eServer zSeries 6 * 7 * (C) Copyright IBM Corp. 2002, 2004 8 * 9 * Author(s): Martin Peschke <mpeschke@de.ibm.com> 10 * Raimund Schroeder <raimund.schroeder@de.ibm.com> 11 * Aron Zeh 12 * Wolfgang Taphorn 13 * Stefan Bader <stefan.bader@de.ibm.com> 14 * Heiko Carstens <heiko.carstens@de.ibm.com> 15 * Andreas Herrmann <aherrman@de.ibm.com> 16 * 17 * This program is free software; you can redistribute it and/or modify 18 * it under the terms of the GNU General Public License as published by 19 * the Free Software Foundation; either version 2, or (at your option) 20 * any later version. 21 * 22 * This program is distributed in the hope that it will be useful, 23 * but WITHOUT ANY WARRANTY; without even the implied warranty of 24 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 25 * GNU General Public License for more details. 26 * 27 * You should have received a copy of the GNU General Public License 28 * along with this program; if not, write to the Free Software 29 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. 30 */ 31 32 #define ZFCP_LOG_AREA ZFCP_LOG_AREA_ERP 33 34 #include "zfcp_ext.h" 35 36 static int zfcp_erp_adisc(struct zfcp_port *); 37 static void zfcp_erp_adisc_handler(unsigned long); 38 39 static int zfcp_erp_adapter_reopen_internal(struct zfcp_adapter *, int); 40 static int zfcp_erp_port_forced_reopen_internal(struct zfcp_port *, int); 41 static int zfcp_erp_port_reopen_internal(struct zfcp_port *, int); 42 static int zfcp_erp_unit_reopen_internal(struct zfcp_unit *, int); 43 44 static int zfcp_erp_port_reopen_all_internal(struct zfcp_adapter *, int); 45 static int zfcp_erp_unit_reopen_all_internal(struct zfcp_port *, int); 46 47 static void zfcp_erp_adapter_block(struct zfcp_adapter *, int); 48 static void zfcp_erp_adapter_unblock(struct zfcp_adapter *); 49 static void zfcp_erp_port_block(struct zfcp_port *, int); 50 static void zfcp_erp_port_unblock(struct zfcp_port *); 51 static void zfcp_erp_unit_block(struct zfcp_unit *, int); 52 static void zfcp_erp_unit_unblock(struct zfcp_unit *); 53 54 static int zfcp_erp_thread(void *); 55 56 static int zfcp_erp_strategy(struct zfcp_erp_action *); 57 58 static int zfcp_erp_strategy_do_action(struct zfcp_erp_action *); 59 static int zfcp_erp_strategy_memwait(struct zfcp_erp_action *); 60 static int zfcp_erp_strategy_check_target(struct zfcp_erp_action *, int); 61 static int zfcp_erp_strategy_check_unit(struct zfcp_unit *, int); 62 static int zfcp_erp_strategy_check_port(struct zfcp_port *, int); 63 static int zfcp_erp_strategy_check_adapter(struct zfcp_adapter *, int); 64 static int zfcp_erp_strategy_statechange(int, u32, struct zfcp_adapter *, 65 struct zfcp_port *, 66 struct zfcp_unit *, int); 67 static inline int zfcp_erp_strategy_statechange_detected(atomic_t *, u32); 68 static int zfcp_erp_strategy_followup_actions(int, struct zfcp_adapter *, 69 struct zfcp_port *, 70 struct zfcp_unit *, int); 71 static int zfcp_erp_strategy_check_queues(struct zfcp_adapter *); 72 static int zfcp_erp_strategy_check_action(struct zfcp_erp_action *, int); 73 74 static int zfcp_erp_adapter_strategy(struct zfcp_erp_action *); 75 static int zfcp_erp_adapter_strategy_generic(struct zfcp_erp_action *, int); 76 static int zfcp_erp_adapter_strategy_close(struct zfcp_erp_action *); 77 static int zfcp_erp_adapter_strategy_close_qdio(struct zfcp_erp_action *); 78 static int zfcp_erp_adapter_strategy_close_fsf(struct zfcp_erp_action *); 79 static int zfcp_erp_adapter_strategy_open(struct zfcp_erp_action *); 80 static int zfcp_erp_adapter_strategy_open_qdio(struct zfcp_erp_action *); 81 static int zfcp_erp_adapter_strategy_open_fsf(struct zfcp_erp_action *); 82 static int zfcp_erp_adapter_strategy_open_fsf_xconfig(struct zfcp_erp_action *); 83 static int zfcp_erp_adapter_strategy_open_fsf_xport(struct zfcp_erp_action *); 84 static int zfcp_erp_adapter_strategy_open_fsf_statusread( 85 struct zfcp_erp_action *); 86 87 static int zfcp_erp_port_forced_strategy(struct zfcp_erp_action *); 88 static int zfcp_erp_port_forced_strategy_close(struct zfcp_erp_action *); 89 90 static int zfcp_erp_port_strategy(struct zfcp_erp_action *); 91 static int zfcp_erp_port_strategy_clearstati(struct zfcp_port *); 92 static int zfcp_erp_port_strategy_close(struct zfcp_erp_action *); 93 static int zfcp_erp_port_strategy_open(struct zfcp_erp_action *); 94 static int zfcp_erp_port_strategy_open_nameserver(struct zfcp_erp_action *); 95 static int zfcp_erp_port_strategy_open_nameserver_wakeup( 96 struct zfcp_erp_action *); 97 static int zfcp_erp_port_strategy_open_common(struct zfcp_erp_action *); 98 static int zfcp_erp_port_strategy_open_common_lookup(struct zfcp_erp_action *); 99 static int zfcp_erp_port_strategy_open_port(struct zfcp_erp_action *); 100 101 static int zfcp_erp_unit_strategy(struct zfcp_erp_action *); 102 static int zfcp_erp_unit_strategy_clearstati(struct zfcp_unit *); 103 static int zfcp_erp_unit_strategy_close(struct zfcp_erp_action *); 104 static int zfcp_erp_unit_strategy_open(struct zfcp_erp_action *); 105 106 static int zfcp_erp_action_dismiss_adapter(struct zfcp_adapter *); 107 static int zfcp_erp_action_dismiss_port(struct zfcp_port *); 108 static int zfcp_erp_action_dismiss_unit(struct zfcp_unit *); 109 static int zfcp_erp_action_dismiss(struct zfcp_erp_action *); 110 111 static int zfcp_erp_action_enqueue(int, struct zfcp_adapter *, 112 struct zfcp_port *, struct zfcp_unit *); 113 static int zfcp_erp_action_dequeue(struct zfcp_erp_action *); 114 static void zfcp_erp_action_cleanup(int, struct zfcp_adapter *, 115 struct zfcp_port *, struct zfcp_unit *, 116 int); 117 118 static void zfcp_erp_action_ready(struct zfcp_erp_action *); 119 static int zfcp_erp_action_exists(struct zfcp_erp_action *); 120 121 static inline void zfcp_erp_action_to_ready(struct zfcp_erp_action *); 122 static inline void zfcp_erp_action_to_running(struct zfcp_erp_action *); 123 124 static void zfcp_erp_memwait_handler(unsigned long); 125 static void zfcp_erp_timeout_handler(unsigned long); 126 static inline void zfcp_erp_timeout_init(struct zfcp_erp_action *); 127 128 /** 129 * zfcp_fsf_request_timeout_handler - called if a request timed out 130 * @data: pointer to adapter for handler function 131 * 132 * This function needs to be called if requests (ELS, Generic Service, 133 * or SCSI commands) exceed a certain time limit. The assumption is 134 * that after the time limit the adapter get stuck. So we trigger a reopen of 135 * the adapter. This should not be used for error recovery, SCSI abort 136 * commands and SCSI requests from SCSI mid-layer. 137 */ 138 void 139 zfcp_fsf_request_timeout_handler(unsigned long data) 140 { 141 struct zfcp_adapter *adapter; 142 143 adapter = (struct zfcp_adapter *) data; 144 145 zfcp_erp_adapter_reopen(adapter, 0); 146 } 147 148 /* 149 * function: zfcp_fsf_scsi_er_timeout_handler 150 * 151 * purpose: This function needs to be called whenever a SCSI error recovery 152 * action (abort/reset) does not return. 153 * Re-opening the adapter means that the command can be returned 154 * by zfcp (it is guarranteed that it does not return via the 155 * adapter anymore). The buffer can then be used again. 156 * 157 * returns: sod all 158 */ 159 void 160 zfcp_fsf_scsi_er_timeout_handler(unsigned long data) 161 { 162 struct zfcp_adapter *adapter = (struct zfcp_adapter *) data; 163 164 ZFCP_LOG_NORMAL("warning: SCSI error recovery timed out. " 165 "Restarting all operations on the adapter %s\n", 166 zfcp_get_busid_by_adapter(adapter)); 167 debug_text_event(adapter->erp_dbf, 1, "eh_lmem_tout"); 168 zfcp_erp_adapter_reopen(adapter, 0); 169 170 return; 171 } 172 173 /* 174 * function: 175 * 176 * purpose: called if an adapter failed, 177 * initiates adapter recovery which is done 178 * asynchronously 179 * 180 * returns: 0 - initiated action succesfully 181 * <0 - failed to initiate action 182 */ 183 int 184 zfcp_erp_adapter_reopen_internal(struct zfcp_adapter *adapter, int clear_mask) 185 { 186 int retval; 187 188 debug_text_event(adapter->erp_dbf, 5, "a_ro"); 189 ZFCP_LOG_DEBUG("reopen adapter %s\n", 190 zfcp_get_busid_by_adapter(adapter)); 191 192 zfcp_erp_adapter_block(adapter, clear_mask); 193 194 if (atomic_test_mask(ZFCP_STATUS_COMMON_ERP_FAILED, &adapter->status)) { 195 ZFCP_LOG_DEBUG("skipped reopen of failed adapter %s\n", 196 zfcp_get_busid_by_adapter(adapter)); 197 debug_text_event(adapter->erp_dbf, 5, "a_ro_f"); 198 /* ensure propagation of failed status to new devices */ 199 zfcp_erp_adapter_failed(adapter); 200 retval = -EIO; 201 goto out; 202 } 203 retval = zfcp_erp_action_enqueue(ZFCP_ERP_ACTION_REOPEN_ADAPTER, 204 adapter, NULL, NULL); 205 206 out: 207 return retval; 208 } 209 210 /* 211 * function: 212 * 213 * purpose: Wrappper for zfcp_erp_adapter_reopen_internal 214 * used to ensure the correct locking 215 * 216 * returns: 0 - initiated action succesfully 217 * <0 - failed to initiate action 218 */ 219 int 220 zfcp_erp_adapter_reopen(struct zfcp_adapter *adapter, int clear_mask) 221 { 222 int retval; 223 unsigned long flags; 224 225 read_lock_irqsave(&zfcp_data.config_lock, flags); 226 write_lock(&adapter->erp_lock); 227 retval = zfcp_erp_adapter_reopen_internal(adapter, clear_mask); 228 write_unlock(&adapter->erp_lock); 229 read_unlock_irqrestore(&zfcp_data.config_lock, flags); 230 231 return retval; 232 } 233 234 /* 235 * function: 236 * 237 * purpose: 238 * 239 * returns: 240 */ 241 int 242 zfcp_erp_adapter_shutdown(struct zfcp_adapter *adapter, int clear_mask) 243 { 244 int retval; 245 246 retval = zfcp_erp_adapter_reopen(adapter, 247 ZFCP_STATUS_COMMON_RUNNING | 248 ZFCP_STATUS_COMMON_ERP_FAILED | 249 clear_mask); 250 251 return retval; 252 } 253 254 /* 255 * function: 256 * 257 * purpose: 258 * 259 * returns: 260 */ 261 int 262 zfcp_erp_port_shutdown(struct zfcp_port *port, int clear_mask) 263 { 264 int retval; 265 266 retval = zfcp_erp_port_reopen(port, 267 ZFCP_STATUS_COMMON_RUNNING | 268 ZFCP_STATUS_COMMON_ERP_FAILED | 269 clear_mask); 270 271 return retval; 272 } 273 274 /* 275 * function: 276 * 277 * purpose: 278 * 279 * returns: 280 */ 281 int 282 zfcp_erp_unit_shutdown(struct zfcp_unit *unit, int clear_mask) 283 { 284 int retval; 285 286 retval = zfcp_erp_unit_reopen(unit, 287 ZFCP_STATUS_COMMON_RUNNING | 288 ZFCP_STATUS_COMMON_ERP_FAILED | 289 clear_mask); 290 291 return retval; 292 } 293 294 295 /** 296 * zfcp_erp_adisc - send ADISC ELS command 297 * @port: port structure 298 */ 299 int 300 zfcp_erp_adisc(struct zfcp_port *port) 301 { 302 struct zfcp_adapter *adapter = port->adapter; 303 struct zfcp_send_els *send_els; 304 struct zfcp_ls_adisc *adisc; 305 void *address = NULL; 306 int retval = 0; 307 struct timer_list *timer; 308 309 send_els = kmalloc(sizeof(struct zfcp_send_els), GFP_ATOMIC); 310 if (send_els == NULL) 311 goto nomem; 312 memset(send_els, 0, sizeof(*send_els)); 313 314 send_els->req = kmalloc(sizeof(struct scatterlist), GFP_ATOMIC); 315 if (send_els->req == NULL) 316 goto nomem; 317 memset(send_els->req, 0, sizeof(*send_els->req)); 318 319 send_els->resp = kmalloc(sizeof(struct scatterlist), GFP_ATOMIC); 320 if (send_els->resp == NULL) 321 goto nomem; 322 memset(send_els->resp, 0, sizeof(*send_els->resp)); 323 324 address = (void *) get_zeroed_page(GFP_ATOMIC); 325 if (address == NULL) 326 goto nomem; 327 328 zfcp_address_to_sg(address, send_els->req); 329 address += PAGE_SIZE >> 1; 330 zfcp_address_to_sg(address, send_els->resp); 331 send_els->req_count = send_els->resp_count = 1; 332 333 send_els->adapter = adapter; 334 send_els->port = port; 335 send_els->d_id = port->d_id; 336 send_els->handler = zfcp_erp_adisc_handler; 337 send_els->handler_data = (unsigned long) send_els; 338 339 adisc = zfcp_sg_to_address(send_els->req); 340 send_els->ls_code = adisc->code = ZFCP_LS_ADISC; 341 342 send_els->req->length = sizeof(struct zfcp_ls_adisc); 343 send_els->resp->length = sizeof(struct zfcp_ls_adisc_acc); 344 345 /* acc. to FC-FS, hard_nport_id in ADISC should not be set for ports 346 without FC-AL-2 capability, so we don't set it */ 347 adisc->wwpn = fc_host_port_name(adapter->scsi_host); 348 adisc->wwnn = fc_host_node_name(adapter->scsi_host); 349 adisc->nport_id = fc_host_port_id(adapter->scsi_host); 350 ZFCP_LOG_INFO("ADISC request from s_id 0x%08x to d_id 0x%08x " 351 "(wwpn=0x%016Lx, wwnn=0x%016Lx, " 352 "hard_nport_id=0x%08x, nport_id=0x%08x)\n", 353 adisc->nport_id, send_els->d_id, (wwn_t) adisc->wwpn, 354 (wwn_t) adisc->wwnn, adisc->hard_nport_id, 355 adisc->nport_id); 356 357 timer = kmalloc(sizeof(struct timer_list), GFP_ATOMIC); 358 if (!timer) 359 goto nomem; 360 361 init_timer(timer); 362 timer->function = zfcp_fsf_request_timeout_handler; 363 timer->data = (unsigned long) adapter; 364 timer->expires = ZFCP_FSF_REQUEST_TIMEOUT; 365 send_els->timer = timer; 366 367 retval = zfcp_fsf_send_els(send_els); 368 if (retval != 0) { 369 ZFCP_LOG_NORMAL("error: initiation of Send ELS failed for port " 370 "0x%08x on adapter %s\n", send_els->d_id, 371 zfcp_get_busid_by_adapter(adapter)); 372 del_timer(send_els->timer); 373 goto freemem; 374 } 375 376 goto out; 377 378 nomem: 379 retval = -ENOMEM; 380 freemem: 381 if (address != NULL) 382 __free_pages(send_els->req->page, 0); 383 if (send_els != NULL) { 384 kfree(send_els->timer); 385 kfree(send_els->req); 386 kfree(send_els->resp); 387 kfree(send_els); 388 } 389 out: 390 return retval; 391 } 392 393 394 /** 395 * zfcp_erp_adisc_handler - handler for ADISC ELS command 396 * @data: pointer to struct zfcp_send_els 397 * 398 * If ADISC failed (LS_RJT or timed out) forced reopen of the port is triggered. 399 */ 400 void 401 zfcp_erp_adisc_handler(unsigned long data) 402 { 403 struct zfcp_send_els *send_els; 404 struct zfcp_port *port; 405 struct zfcp_adapter *adapter; 406 u32 d_id; 407 struct zfcp_ls_adisc_acc *adisc; 408 409 send_els = (struct zfcp_send_els *) data; 410 411 del_timer(send_els->timer); 412 413 adapter = send_els->adapter; 414 port = send_els->port; 415 d_id = send_els->d_id; 416 417 /* request rejected or timed out */ 418 if (send_els->status != 0) { 419 ZFCP_LOG_NORMAL("ELS request rejected/timed out, " 420 "force physical port reopen " 421 "(adapter %s, port d_id=0x%08x)\n", 422 zfcp_get_busid_by_adapter(adapter), d_id); 423 debug_text_event(adapter->erp_dbf, 3, "forcreop"); 424 if (zfcp_erp_port_forced_reopen(port, 0)) 425 ZFCP_LOG_NORMAL("failed reopen of port " 426 "(adapter %s, wwpn=0x%016Lx)\n", 427 zfcp_get_busid_by_port(port), 428 port->wwpn); 429 goto out; 430 } 431 432 adisc = zfcp_sg_to_address(send_els->resp); 433 434 ZFCP_LOG_INFO("ADISC response from d_id 0x%08x to s_id " 435 "0x%08x (wwpn=0x%016Lx, wwnn=0x%016Lx, " 436 "hard_nport_id=0x%08x, nport_id=0x%08x)\n", 437 d_id, fc_host_port_id(adapter->scsi_host), 438 (wwn_t) adisc->wwpn, (wwn_t) adisc->wwnn, 439 adisc->hard_nport_id, adisc->nport_id); 440 441 /* set wwnn for port */ 442 if (port->wwnn == 0) 443 port->wwnn = adisc->wwnn; 444 445 if (port->wwpn != adisc->wwpn) { 446 ZFCP_LOG_NORMAL("d_id assignment changed, reopening " 447 "port (adapter %s, wwpn=0x%016Lx, " 448 "adisc_resp_wwpn=0x%016Lx)\n", 449 zfcp_get_busid_by_port(port), 450 port->wwpn, (wwn_t) adisc->wwpn); 451 if (zfcp_erp_port_reopen(port, 0)) 452 ZFCP_LOG_NORMAL("failed reopen of port " 453 "(adapter %s, wwpn=0x%016Lx)\n", 454 zfcp_get_busid_by_port(port), 455 port->wwpn); 456 } 457 458 out: 459 zfcp_port_put(port); 460 __free_pages(send_els->req->page, 0); 461 kfree(send_els->timer); 462 kfree(send_els->req); 463 kfree(send_els->resp); 464 kfree(send_els); 465 } 466 467 468 /** 469 * zfcp_test_link - lightweight link test procedure 470 * @port: port to be tested 471 * 472 * Test status of a link to a remote port using the ELS command ADISC. 473 */ 474 int 475 zfcp_test_link(struct zfcp_port *port) 476 { 477 int retval; 478 479 zfcp_port_get(port); 480 retval = zfcp_erp_adisc(port); 481 if (retval != 0) { 482 zfcp_port_put(port); 483 ZFCP_LOG_NORMAL("reopen needed for port 0x%016Lx " 484 "on adapter %s\n ", port->wwpn, 485 zfcp_get_busid_by_port(port)); 486 retval = zfcp_erp_port_forced_reopen(port, 0); 487 if (retval != 0) { 488 ZFCP_LOG_NORMAL("reopen of remote port 0x%016Lx " 489 "on adapter %s failed\n", port->wwpn, 490 zfcp_get_busid_by_port(port)); 491 retval = -EPERM; 492 } 493 } 494 495 return retval; 496 } 497 498 499 /* 500 * function: 501 * 502 * purpose: called if a port failed to be opened normally 503 * initiates Forced Reopen recovery which is done 504 * asynchronously 505 * 506 * returns: 0 - initiated action succesfully 507 * <0 - failed to initiate action 508 */ 509 static int 510 zfcp_erp_port_forced_reopen_internal(struct zfcp_port *port, int clear_mask) 511 { 512 int retval; 513 struct zfcp_adapter *adapter = port->adapter; 514 515 debug_text_event(adapter->erp_dbf, 5, "pf_ro"); 516 debug_event(adapter->erp_dbf, 5, &port->wwpn, sizeof (wwn_t)); 517 518 ZFCP_LOG_DEBUG("forced reopen of port 0x%016Lx on adapter %s\n", 519 port->wwpn, zfcp_get_busid_by_port(port)); 520 521 zfcp_erp_port_block(port, clear_mask); 522 523 if (atomic_test_mask(ZFCP_STATUS_COMMON_ERP_FAILED, &port->status)) { 524 ZFCP_LOG_DEBUG("skipped forced reopen of failed port 0x%016Lx " 525 "on adapter %s\n", port->wwpn, 526 zfcp_get_busid_by_port(port)); 527 debug_text_event(adapter->erp_dbf, 5, "pf_ro_f"); 528 debug_event(adapter->erp_dbf, 5, &port->wwpn, sizeof (wwn_t)); 529 retval = -EIO; 530 goto out; 531 } 532 533 retval = zfcp_erp_action_enqueue(ZFCP_ERP_ACTION_REOPEN_PORT_FORCED, 534 port->adapter, port, NULL); 535 536 out: 537 return retval; 538 } 539 540 /* 541 * function: 542 * 543 * purpose: Wrappper for zfcp_erp_port_forced_reopen_internal 544 * used to ensure the correct locking 545 * 546 * returns: 0 - initiated action succesfully 547 * <0 - failed to initiate action 548 */ 549 int 550 zfcp_erp_port_forced_reopen(struct zfcp_port *port, int clear_mask) 551 { 552 int retval; 553 unsigned long flags; 554 struct zfcp_adapter *adapter; 555 556 adapter = port->adapter; 557 read_lock_irqsave(&zfcp_data.config_lock, flags); 558 write_lock(&adapter->erp_lock); 559 retval = zfcp_erp_port_forced_reopen_internal(port, clear_mask); 560 write_unlock(&adapter->erp_lock); 561 read_unlock_irqrestore(&zfcp_data.config_lock, flags); 562 563 return retval; 564 } 565 566 /* 567 * function: 568 * 569 * purpose: called if a port is to be opened 570 * initiates Reopen recovery which is done 571 * asynchronously 572 * 573 * returns: 0 - initiated action succesfully 574 * <0 - failed to initiate action 575 */ 576 static int 577 zfcp_erp_port_reopen_internal(struct zfcp_port *port, int clear_mask) 578 { 579 int retval; 580 struct zfcp_adapter *adapter = port->adapter; 581 582 debug_text_event(adapter->erp_dbf, 5, "p_ro"); 583 debug_event(adapter->erp_dbf, 5, &port->wwpn, sizeof (wwn_t)); 584 585 ZFCP_LOG_DEBUG("reopen of port 0x%016Lx on adapter %s\n", 586 port->wwpn, zfcp_get_busid_by_port(port)); 587 588 zfcp_erp_port_block(port, clear_mask); 589 590 if (atomic_test_mask(ZFCP_STATUS_COMMON_ERP_FAILED, &port->status)) { 591 ZFCP_LOG_DEBUG("skipped reopen of failed port 0x%016Lx " 592 "on adapter %s\n", port->wwpn, 593 zfcp_get_busid_by_port(port)); 594 debug_text_event(adapter->erp_dbf, 5, "p_ro_f"); 595 debug_event(adapter->erp_dbf, 5, &port->wwpn, sizeof (wwn_t)); 596 /* ensure propagation of failed status to new devices */ 597 zfcp_erp_port_failed(port); 598 retval = -EIO; 599 goto out; 600 } 601 602 retval = zfcp_erp_action_enqueue(ZFCP_ERP_ACTION_REOPEN_PORT, 603 port->adapter, port, NULL); 604 605 out: 606 return retval; 607 } 608 609 /** 610 * zfcp_erp_port_reopen - initiate reopen of a remote port 611 * @port: port to be reopened 612 * @clear_mask: specifies flags in port status to be cleared 613 * Return: 0 on success, < 0 on error 614 * 615 * This is a wrappper function for zfcp_erp_port_reopen_internal. It ensures 616 * correct locking. An error recovery task is initiated to do the reopen. 617 * To wait for the completion of the reopen zfcp_erp_wait should be used. 618 */ 619 int 620 zfcp_erp_port_reopen(struct zfcp_port *port, int clear_mask) 621 { 622 int retval; 623 unsigned long flags; 624 struct zfcp_adapter *adapter = port->adapter; 625 626 read_lock_irqsave(&zfcp_data.config_lock, flags); 627 write_lock(&adapter->erp_lock); 628 retval = zfcp_erp_port_reopen_internal(port, clear_mask); 629 write_unlock(&adapter->erp_lock); 630 read_unlock_irqrestore(&zfcp_data.config_lock, flags); 631 632 return retval; 633 } 634 635 /* 636 * function: 637 * 638 * purpose: called if a unit is to be opened 639 * initiates Reopen recovery which is done 640 * asynchronously 641 * 642 * returns: 0 - initiated action succesfully 643 * <0 - failed to initiate action 644 */ 645 static int 646 zfcp_erp_unit_reopen_internal(struct zfcp_unit *unit, int clear_mask) 647 { 648 int retval; 649 struct zfcp_adapter *adapter = unit->port->adapter; 650 651 debug_text_event(adapter->erp_dbf, 5, "u_ro"); 652 debug_event(adapter->erp_dbf, 5, &unit->fcp_lun, sizeof (fcp_lun_t)); 653 ZFCP_LOG_DEBUG("reopen of unit 0x%016Lx on port 0x%016Lx " 654 "on adapter %s\n", unit->fcp_lun, 655 unit->port->wwpn, zfcp_get_busid_by_unit(unit)); 656 657 zfcp_erp_unit_block(unit, clear_mask); 658 659 if (atomic_test_mask(ZFCP_STATUS_COMMON_ERP_FAILED, &unit->status)) { 660 ZFCP_LOG_DEBUG("skipped reopen of failed unit 0x%016Lx " 661 "on port 0x%016Lx on adapter %s\n", 662 unit->fcp_lun, unit->port->wwpn, 663 zfcp_get_busid_by_unit(unit)); 664 debug_text_event(adapter->erp_dbf, 5, "u_ro_f"); 665 debug_event(adapter->erp_dbf, 5, &unit->fcp_lun, 666 sizeof (fcp_lun_t)); 667 retval = -EIO; 668 goto out; 669 } 670 671 retval = zfcp_erp_action_enqueue(ZFCP_ERP_ACTION_REOPEN_UNIT, 672 unit->port->adapter, unit->port, unit); 673 out: 674 return retval; 675 } 676 677 /** 678 * zfcp_erp_unit_reopen - initiate reopen of a unit 679 * @unit: unit to be reopened 680 * @clear_mask: specifies flags in unit status to be cleared 681 * Return: 0 on success, < 0 on error 682 * 683 * This is a wrappper for zfcp_erp_unit_reopen_internal. It ensures correct 684 * locking. An error recovery task is initiated to do the reopen. 685 * To wait for the completion of the reopen zfcp_erp_wait should be used. 686 */ 687 int 688 zfcp_erp_unit_reopen(struct zfcp_unit *unit, int clear_mask) 689 { 690 int retval; 691 unsigned long flags; 692 struct zfcp_adapter *adapter; 693 struct zfcp_port *port; 694 695 port = unit->port; 696 adapter = port->adapter; 697 698 read_lock_irqsave(&zfcp_data.config_lock, flags); 699 write_lock(&adapter->erp_lock); 700 retval = zfcp_erp_unit_reopen_internal(unit, clear_mask); 701 write_unlock(&adapter->erp_lock); 702 read_unlock_irqrestore(&zfcp_data.config_lock, flags); 703 704 return retval; 705 } 706 707 /* 708 * function: 709 * 710 * purpose: disable I/O, 711 * return any open requests and clean them up, 712 * aim: no pending and incoming I/O 713 * 714 * returns: 715 */ 716 static void 717 zfcp_erp_adapter_block(struct zfcp_adapter *adapter, int clear_mask) 718 { 719 debug_text_event(adapter->erp_dbf, 6, "a_bl"); 720 zfcp_erp_modify_adapter_status(adapter, 721 ZFCP_STATUS_COMMON_UNBLOCKED | 722 clear_mask, ZFCP_CLEAR); 723 } 724 725 /* 726 * function: 727 * 728 * purpose: enable I/O 729 * 730 * returns: 731 */ 732 static void 733 zfcp_erp_adapter_unblock(struct zfcp_adapter *adapter) 734 { 735 debug_text_event(adapter->erp_dbf, 6, "a_ubl"); 736 atomic_set_mask(ZFCP_STATUS_COMMON_UNBLOCKED, &adapter->status); 737 } 738 739 /* 740 * function: 741 * 742 * purpose: disable I/O, 743 * return any open requests and clean them up, 744 * aim: no pending and incoming I/O 745 * 746 * returns: 747 */ 748 static void 749 zfcp_erp_port_block(struct zfcp_port *port, int clear_mask) 750 { 751 struct zfcp_adapter *adapter = port->adapter; 752 753 debug_text_event(adapter->erp_dbf, 6, "p_bl"); 754 debug_event(adapter->erp_dbf, 6, &port->wwpn, sizeof (wwn_t)); 755 zfcp_erp_modify_port_status(port, 756 ZFCP_STATUS_COMMON_UNBLOCKED | clear_mask, 757 ZFCP_CLEAR); 758 } 759 760 /* 761 * function: 762 * 763 * purpose: enable I/O 764 * 765 * returns: 766 */ 767 static void 768 zfcp_erp_port_unblock(struct zfcp_port *port) 769 { 770 struct zfcp_adapter *adapter = port->adapter; 771 772 debug_text_event(adapter->erp_dbf, 6, "p_ubl"); 773 debug_event(adapter->erp_dbf, 6, &port->wwpn, sizeof (wwn_t)); 774 atomic_set_mask(ZFCP_STATUS_COMMON_UNBLOCKED, &port->status); 775 } 776 777 /* 778 * function: 779 * 780 * purpose: disable I/O, 781 * return any open requests and clean them up, 782 * aim: no pending and incoming I/O 783 * 784 * returns: 785 */ 786 static void 787 zfcp_erp_unit_block(struct zfcp_unit *unit, int clear_mask) 788 { 789 struct zfcp_adapter *adapter = unit->port->adapter; 790 791 debug_text_event(adapter->erp_dbf, 6, "u_bl"); 792 debug_event(adapter->erp_dbf, 6, &unit->fcp_lun, sizeof (fcp_lun_t)); 793 zfcp_erp_modify_unit_status(unit, 794 ZFCP_STATUS_COMMON_UNBLOCKED | clear_mask, 795 ZFCP_CLEAR); 796 } 797 798 /* 799 * function: 800 * 801 * purpose: enable I/O 802 * 803 * returns: 804 */ 805 static void 806 zfcp_erp_unit_unblock(struct zfcp_unit *unit) 807 { 808 struct zfcp_adapter *adapter = unit->port->adapter; 809 810 debug_text_event(adapter->erp_dbf, 6, "u_ubl"); 811 debug_event(adapter->erp_dbf, 6, &unit->fcp_lun, sizeof (fcp_lun_t)); 812 atomic_set_mask(ZFCP_STATUS_COMMON_UNBLOCKED, &unit->status); 813 } 814 815 /* 816 * function: 817 * 818 * purpose: 819 * 820 * returns: 821 */ 822 static void 823 zfcp_erp_action_ready(struct zfcp_erp_action *erp_action) 824 { 825 struct zfcp_adapter *adapter = erp_action->adapter; 826 827 debug_text_event(adapter->erp_dbf, 4, "a_ar"); 828 debug_event(adapter->erp_dbf, 4, &erp_action->action, sizeof (int)); 829 830 zfcp_erp_action_to_ready(erp_action); 831 up(&adapter->erp_ready_sem); 832 } 833 834 /* 835 * function: 836 * 837 * purpose: 838 * 839 * returns: <0 erp_action not found in any list 840 * ZFCP_ERP_ACTION_READY erp_action is in ready list 841 * ZFCP_ERP_ACTION_RUNNING erp_action is in running list 842 * 843 * locks: erp_lock must be held 844 */ 845 static int 846 zfcp_erp_action_exists(struct zfcp_erp_action *erp_action) 847 { 848 int retval = -EINVAL; 849 struct list_head *entry; 850 struct zfcp_erp_action *entry_erp_action; 851 struct zfcp_adapter *adapter = erp_action->adapter; 852 853 /* search in running list */ 854 list_for_each(entry, &adapter->erp_running_head) { 855 entry_erp_action = 856 list_entry(entry, struct zfcp_erp_action, list); 857 if (entry_erp_action == erp_action) { 858 retval = ZFCP_ERP_ACTION_RUNNING; 859 goto out; 860 } 861 } 862 /* search in ready list */ 863 list_for_each(entry, &adapter->erp_ready_head) { 864 entry_erp_action = 865 list_entry(entry, struct zfcp_erp_action, list); 866 if (entry_erp_action == erp_action) { 867 retval = ZFCP_ERP_ACTION_READY; 868 goto out; 869 } 870 } 871 872 out: 873 return retval; 874 } 875 876 /* 877 * purpose: checks current status of action (timed out, dismissed, ...) 878 * and does appropriate preparations (dismiss fsf request, ...) 879 * 880 * locks: called under erp_lock (disabled interrupts) 881 * 882 * returns: 0 883 */ 884 static int 885 zfcp_erp_strategy_check_fsfreq(struct zfcp_erp_action *erp_action) 886 { 887 int retval = 0; 888 struct zfcp_fsf_req *fsf_req = NULL; 889 struct zfcp_adapter *adapter = erp_action->adapter; 890 891 if (erp_action->fsf_req) { 892 /* take lock to ensure that request is not being deleted meanwhile */ 893 spin_lock(&adapter->fsf_req_list_lock); 894 /* check whether fsf req does still exist */ 895 list_for_each_entry(fsf_req, &adapter->fsf_req_list_head, list) 896 if (fsf_req == erp_action->fsf_req) 897 break; 898 if (fsf_req && (fsf_req->erp_action == erp_action)) { 899 /* fsf_req still exists */ 900 debug_text_event(adapter->erp_dbf, 3, "a_ca_req"); 901 debug_event(adapter->erp_dbf, 3, &fsf_req, 902 sizeof (unsigned long)); 903 /* dismiss fsf_req of timed out or dismissed erp_action */ 904 if (erp_action->status & (ZFCP_STATUS_ERP_DISMISSED | 905 ZFCP_STATUS_ERP_TIMEDOUT)) { 906 debug_text_event(adapter->erp_dbf, 3, 907 "a_ca_disreq"); 908 fsf_req->status |= ZFCP_STATUS_FSFREQ_DISMISSED; 909 } 910 if (erp_action->status & ZFCP_STATUS_ERP_TIMEDOUT) { 911 ZFCP_LOG_NORMAL("error: erp step timed out " 912 "(action=%d, fsf_req=%p)\n ", 913 erp_action->action, 914 erp_action->fsf_req); 915 } 916 /* 917 * If fsf_req is neither dismissed nor completed 918 * then keep it running asynchronously and don't mess 919 * with the association of erp_action and fsf_req. 920 */ 921 if (fsf_req->status & (ZFCP_STATUS_FSFREQ_COMPLETED | 922 ZFCP_STATUS_FSFREQ_DISMISSED)) { 923 /* forget about association between fsf_req 924 and erp_action */ 925 fsf_req->erp_action = NULL; 926 erp_action->fsf_req = NULL; 927 } 928 } else { 929 debug_text_event(adapter->erp_dbf, 3, "a_ca_gonereq"); 930 /* 931 * even if this fsf_req has gone, forget about 932 * association between erp_action and fsf_req 933 */ 934 erp_action->fsf_req = NULL; 935 } 936 spin_unlock(&adapter->fsf_req_list_lock); 937 } else 938 debug_text_event(adapter->erp_dbf, 3, "a_ca_noreq"); 939 940 return retval; 941 } 942 943 /* 944 * purpose: generic handler for asynchronous events related to erp_action events 945 * (normal completion, time-out, dismissing, retry after 946 * low memory condition) 947 * 948 * note: deletion of timer is not required (e.g. in case of a time-out), 949 * but a second try does no harm, 950 * we leave it in here to allow for greater simplification 951 * 952 * returns: 0 - there was an action to handle 953 * !0 - otherwise 954 */ 955 static int 956 zfcp_erp_async_handler_nolock(struct zfcp_erp_action *erp_action, 957 unsigned long set_mask) 958 { 959 int retval; 960 struct zfcp_adapter *adapter = erp_action->adapter; 961 962 if (zfcp_erp_action_exists(erp_action) == ZFCP_ERP_ACTION_RUNNING) { 963 debug_text_event(adapter->erp_dbf, 2, "a_asyh_ex"); 964 debug_event(adapter->erp_dbf, 2, &erp_action->action, 965 sizeof (int)); 966 if (!(set_mask & ZFCP_STATUS_ERP_TIMEDOUT)) 967 del_timer(&erp_action->timer); 968 erp_action->status |= set_mask; 969 zfcp_erp_action_ready(erp_action); 970 retval = 0; 971 } else { 972 /* action is ready or gone - nothing to do */ 973 debug_text_event(adapter->erp_dbf, 3, "a_asyh_gone"); 974 debug_event(adapter->erp_dbf, 3, &erp_action->action, 975 sizeof (int)); 976 retval = 1; 977 } 978 979 return retval; 980 } 981 982 /* 983 * purpose: generic handler for asynchronous events related to erp_action 984 * events (normal completion, time-out, dismissing, retry after 985 * low memory condition) 986 * 987 * note: deletion of timer is not required (e.g. in case of a time-out), 988 * but a second try does no harm, 989 * we leave it in here to allow for greater simplification 990 * 991 * returns: 0 - there was an action to handle 992 * !0 - otherwise 993 */ 994 int 995 zfcp_erp_async_handler(struct zfcp_erp_action *erp_action, 996 unsigned long set_mask) 997 { 998 struct zfcp_adapter *adapter = erp_action->adapter; 999 unsigned long flags; 1000 int retval; 1001 1002 write_lock_irqsave(&adapter->erp_lock, flags); 1003 retval = zfcp_erp_async_handler_nolock(erp_action, set_mask); 1004 write_unlock_irqrestore(&adapter->erp_lock, flags); 1005 1006 return retval; 1007 } 1008 1009 /* 1010 * purpose: is called for erp_action which was slept waiting for 1011 * memory becoming avaliable, 1012 * will trigger that this action will be continued 1013 */ 1014 static void 1015 zfcp_erp_memwait_handler(unsigned long data) 1016 { 1017 struct zfcp_erp_action *erp_action = (struct zfcp_erp_action *) data; 1018 struct zfcp_adapter *adapter = erp_action->adapter; 1019 1020 debug_text_event(adapter->erp_dbf, 2, "a_mwh"); 1021 debug_event(adapter->erp_dbf, 2, &erp_action->action, sizeof (int)); 1022 1023 zfcp_erp_async_handler(erp_action, 0); 1024 } 1025 1026 /* 1027 * purpose: is called if an asynchronous erp step timed out, 1028 * action gets an appropriate flag and will be processed 1029 * accordingly 1030 */ 1031 static void 1032 zfcp_erp_timeout_handler(unsigned long data) 1033 { 1034 struct zfcp_erp_action *erp_action = (struct zfcp_erp_action *) data; 1035 struct zfcp_adapter *adapter = erp_action->adapter; 1036 1037 debug_text_event(adapter->erp_dbf, 2, "a_th"); 1038 debug_event(adapter->erp_dbf, 2, &erp_action->action, sizeof (int)); 1039 1040 zfcp_erp_async_handler(erp_action, ZFCP_STATUS_ERP_TIMEDOUT); 1041 } 1042 1043 /* 1044 * purpose: is called for an erp_action which needs to be ended 1045 * though not being done, 1046 * this is usually required if an higher is generated, 1047 * action gets an appropriate flag and will be processed 1048 * accordingly 1049 * 1050 * locks: erp_lock held (thus we need to call another handler variant) 1051 */ 1052 static int 1053 zfcp_erp_action_dismiss(struct zfcp_erp_action *erp_action) 1054 { 1055 struct zfcp_adapter *adapter = erp_action->adapter; 1056 1057 debug_text_event(adapter->erp_dbf, 2, "a_adis"); 1058 debug_event(adapter->erp_dbf, 2, &erp_action->action, sizeof (int)); 1059 1060 zfcp_erp_async_handler_nolock(erp_action, ZFCP_STATUS_ERP_DISMISSED); 1061 1062 return 0; 1063 } 1064 1065 int 1066 zfcp_erp_thread_setup(struct zfcp_adapter *adapter) 1067 { 1068 int retval = 0; 1069 1070 atomic_clear_mask(ZFCP_STATUS_ADAPTER_ERP_THREAD_UP, &adapter->status); 1071 1072 retval = kernel_thread(zfcp_erp_thread, adapter, SIGCHLD); 1073 if (retval < 0) { 1074 ZFCP_LOG_NORMAL("error: creation of erp thread failed for " 1075 "adapter %s\n", 1076 zfcp_get_busid_by_adapter(adapter)); 1077 debug_text_event(adapter->erp_dbf, 5, "a_thset_fail"); 1078 } else { 1079 wait_event(adapter->erp_thread_wqh, 1080 atomic_test_mask(ZFCP_STATUS_ADAPTER_ERP_THREAD_UP, 1081 &adapter->status)); 1082 debug_text_event(adapter->erp_dbf, 5, "a_thset_ok"); 1083 } 1084 1085 return (retval < 0); 1086 } 1087 1088 /* 1089 * function: 1090 * 1091 * purpose: 1092 * 1093 * returns: 1094 * 1095 * context: process (i.e. proc-fs or rmmod/insmod) 1096 * 1097 * note: The caller of this routine ensures that the specified 1098 * adapter has been shut down and that this operation 1099 * has been completed. Thus, there are no pending erp_actions 1100 * which would need to be handled here. 1101 */ 1102 int 1103 zfcp_erp_thread_kill(struct zfcp_adapter *adapter) 1104 { 1105 int retval = 0; 1106 1107 atomic_set_mask(ZFCP_STATUS_ADAPTER_ERP_THREAD_KILL, &adapter->status); 1108 up(&adapter->erp_ready_sem); 1109 1110 wait_event(adapter->erp_thread_wqh, 1111 !atomic_test_mask(ZFCP_STATUS_ADAPTER_ERP_THREAD_UP, 1112 &adapter->status)); 1113 1114 atomic_clear_mask(ZFCP_STATUS_ADAPTER_ERP_THREAD_KILL, 1115 &adapter->status); 1116 1117 debug_text_event(adapter->erp_dbf, 5, "a_thki_ok"); 1118 1119 return retval; 1120 } 1121 1122 /* 1123 * purpose: is run as a kernel thread, 1124 * goes through list of error recovery actions of associated adapter 1125 * and delegates single action to execution 1126 * 1127 * returns: 0 1128 */ 1129 static int 1130 zfcp_erp_thread(void *data) 1131 { 1132 struct zfcp_adapter *adapter = (struct zfcp_adapter *) data; 1133 struct list_head *next; 1134 struct zfcp_erp_action *erp_action; 1135 unsigned long flags; 1136 1137 daemonize("zfcperp%s", zfcp_get_busid_by_adapter(adapter)); 1138 /* Block all signals */ 1139 siginitsetinv(¤t->blocked, 0); 1140 atomic_set_mask(ZFCP_STATUS_ADAPTER_ERP_THREAD_UP, &adapter->status); 1141 debug_text_event(adapter->erp_dbf, 5, "a_th_run"); 1142 wake_up(&adapter->erp_thread_wqh); 1143 1144 while (!atomic_test_mask(ZFCP_STATUS_ADAPTER_ERP_THREAD_KILL, 1145 &adapter->status)) { 1146 1147 write_lock_irqsave(&adapter->erp_lock, flags); 1148 next = adapter->erp_ready_head.prev; 1149 write_unlock_irqrestore(&adapter->erp_lock, flags); 1150 1151 if (next != &adapter->erp_ready_head) { 1152 erp_action = 1153 list_entry(next, struct zfcp_erp_action, list); 1154 /* 1155 * process action (incl. [re]moving it 1156 * from 'ready' queue) 1157 */ 1158 zfcp_erp_strategy(erp_action); 1159 } 1160 1161 /* 1162 * sleep as long as there is nothing to do, i.e. 1163 * no action in 'ready' queue to be processed and 1164 * thread is not to be killed 1165 */ 1166 down_interruptible(&adapter->erp_ready_sem); 1167 debug_text_event(adapter->erp_dbf, 5, "a_th_woken"); 1168 } 1169 1170 atomic_clear_mask(ZFCP_STATUS_ADAPTER_ERP_THREAD_UP, &adapter->status); 1171 debug_text_event(adapter->erp_dbf, 5, "a_th_stop"); 1172 wake_up(&adapter->erp_thread_wqh); 1173 1174 return 0; 1175 } 1176 1177 /* 1178 * function: 1179 * 1180 * purpose: drives single error recovery action and schedules higher and 1181 * subordinate actions, if necessary 1182 * 1183 * returns: ZFCP_ERP_CONTINUES - action continues (asynchronously) 1184 * ZFCP_ERP_SUCCEEDED - action finished successfully (deqd) 1185 * ZFCP_ERP_FAILED - action finished unsuccessfully (deqd) 1186 * ZFCP_ERP_EXIT - action finished (dequeued), offline 1187 * ZFCP_ERP_DISMISSED - action canceled (dequeued) 1188 */ 1189 static int 1190 zfcp_erp_strategy(struct zfcp_erp_action *erp_action) 1191 { 1192 int retval = 0; 1193 struct zfcp_adapter *adapter = erp_action->adapter; 1194 struct zfcp_port *port = erp_action->port; 1195 struct zfcp_unit *unit = erp_action->unit; 1196 int action = erp_action->action; 1197 u32 status = erp_action->status; 1198 unsigned long flags; 1199 1200 /* serialise dismissing, timing out, moving, enqueueing */ 1201 read_lock_irqsave(&zfcp_data.config_lock, flags); 1202 write_lock(&adapter->erp_lock); 1203 1204 /* dequeue dismissed action and leave, if required */ 1205 retval = zfcp_erp_strategy_check_action(erp_action, retval); 1206 if (retval == ZFCP_ERP_DISMISSED) { 1207 debug_text_event(adapter->erp_dbf, 4, "a_st_dis1"); 1208 goto unlock; 1209 } 1210 1211 /* 1212 * move action to 'running' queue before processing it 1213 * (to avoid a race condition regarding moving the 1214 * action to the 'running' queue and back) 1215 */ 1216 zfcp_erp_action_to_running(erp_action); 1217 1218 /* 1219 * try to process action as far as possible, 1220 * no lock to allow for blocking operations (kmalloc, qdio, ...), 1221 * afterwards the lock is required again for the following reasons: 1222 * - dequeueing of finished action and enqueueing of 1223 * follow-up actions must be atomic so that any other 1224 * reopen-routine does not believe there is nothing to do 1225 * and that it is safe to enqueue something else, 1226 * - we want to force any control thread which is dismissing 1227 * actions to finish this before we decide about 1228 * necessary steps to be taken here further 1229 */ 1230 write_unlock(&adapter->erp_lock); 1231 read_unlock_irqrestore(&zfcp_data.config_lock, flags); 1232 retval = zfcp_erp_strategy_do_action(erp_action); 1233 read_lock_irqsave(&zfcp_data.config_lock, flags); 1234 write_lock(&adapter->erp_lock); 1235 1236 /* 1237 * check for dismissed status again to avoid follow-up actions, 1238 * failing of targets and so on for dismissed actions 1239 */ 1240 retval = zfcp_erp_strategy_check_action(erp_action, retval); 1241 1242 switch (retval) { 1243 case ZFCP_ERP_DISMISSED: 1244 /* leave since this action has ridden to its ancestors */ 1245 debug_text_event(adapter->erp_dbf, 6, "a_st_dis2"); 1246 goto unlock; 1247 case ZFCP_ERP_NOMEM: 1248 /* no memory to continue immediately, let it sleep */ 1249 if (!(erp_action->status & ZFCP_STATUS_ERP_LOWMEM)) { 1250 ++adapter->erp_low_mem_count; 1251 erp_action->status |= ZFCP_STATUS_ERP_LOWMEM; 1252 } 1253 /* This condition is true if there is no memory available 1254 for any erp_action on this adapter. This implies that there 1255 are no elements in the memory pool(s) left for erp_actions. 1256 This might happen if an erp_action that used a memory pool 1257 element was timed out. 1258 */ 1259 if (adapter->erp_total_count == adapter->erp_low_mem_count) { 1260 debug_text_event(adapter->erp_dbf, 3, "a_st_lowmem"); 1261 ZFCP_LOG_NORMAL("error: no mempool elements available, " 1262 "restarting I/O on adapter %s " 1263 "to free mempool\n", 1264 zfcp_get_busid_by_adapter(adapter)); 1265 zfcp_erp_adapter_reopen_internal(adapter, 0); 1266 } else { 1267 debug_text_event(adapter->erp_dbf, 2, "a_st_memw"); 1268 retval = zfcp_erp_strategy_memwait(erp_action); 1269 } 1270 goto unlock; 1271 case ZFCP_ERP_CONTINUES: 1272 /* leave since this action runs asynchronously */ 1273 debug_text_event(adapter->erp_dbf, 6, "a_st_cont"); 1274 if (erp_action->status & ZFCP_STATUS_ERP_LOWMEM) { 1275 --adapter->erp_low_mem_count; 1276 erp_action->status &= ~ZFCP_STATUS_ERP_LOWMEM; 1277 } 1278 goto unlock; 1279 } 1280 /* ok, finished action (whatever its result is) */ 1281 1282 /* check for unrecoverable targets */ 1283 retval = zfcp_erp_strategy_check_target(erp_action, retval); 1284 1285 /* action must be dequeued (here to allow for further ones) */ 1286 zfcp_erp_action_dequeue(erp_action); 1287 1288 /* 1289 * put this target through the erp mill again if someone has 1290 * requested to change the status of a target being online 1291 * to offline or the other way around 1292 * (old retval is preserved if nothing has to be done here) 1293 */ 1294 retval = zfcp_erp_strategy_statechange(action, status, adapter, 1295 port, unit, retval); 1296 1297 /* 1298 * leave if target is in permanent error state or if 1299 * action is repeated in order to process state change 1300 */ 1301 if (retval == ZFCP_ERP_EXIT) { 1302 debug_text_event(adapter->erp_dbf, 2, "a_st_exit"); 1303 goto unlock; 1304 } 1305 1306 /* trigger follow up actions */ 1307 zfcp_erp_strategy_followup_actions(action, adapter, port, unit, retval); 1308 1309 unlock: 1310 write_unlock(&adapter->erp_lock); 1311 read_unlock_irqrestore(&zfcp_data.config_lock, flags); 1312 1313 if (retval != ZFCP_ERP_CONTINUES) 1314 zfcp_erp_action_cleanup(action, adapter, port, unit, retval); 1315 1316 /* 1317 * a few tasks remain when the erp queues are empty 1318 * (don't do that if the last action evaluated was dismissed 1319 * since this clearly indicates that there is more to come) : 1320 * - close the name server port if it is open yet 1321 * (enqueues another [probably] final action) 1322 * - otherwise, wake up whoever wants to be woken when we are 1323 * done with erp 1324 */ 1325 if (retval != ZFCP_ERP_DISMISSED) 1326 zfcp_erp_strategy_check_queues(adapter); 1327 1328 debug_text_event(adapter->erp_dbf, 6, "a_st_done"); 1329 1330 return retval; 1331 } 1332 1333 /* 1334 * function: 1335 * 1336 * purpose: 1337 * 1338 * returns: ZFCP_ERP_DISMISSED - if action has been dismissed 1339 * retval - otherwise 1340 */ 1341 static int 1342 zfcp_erp_strategy_check_action(struct zfcp_erp_action *erp_action, int retval) 1343 { 1344 struct zfcp_adapter *adapter = erp_action->adapter; 1345 1346 zfcp_erp_strategy_check_fsfreq(erp_action); 1347 1348 debug_event(adapter->erp_dbf, 5, &erp_action->action, sizeof (int)); 1349 if (erp_action->status & ZFCP_STATUS_ERP_DISMISSED) { 1350 debug_text_event(adapter->erp_dbf, 3, "a_stcd_dis"); 1351 zfcp_erp_action_dequeue(erp_action); 1352 retval = ZFCP_ERP_DISMISSED; 1353 } else 1354 debug_text_event(adapter->erp_dbf, 5, "a_stcd_nodis"); 1355 1356 return retval; 1357 } 1358 1359 /* 1360 * function: 1361 * 1362 * purpose: 1363 * 1364 * returns: 1365 */ 1366 static int 1367 zfcp_erp_strategy_do_action(struct zfcp_erp_action *erp_action) 1368 { 1369 int retval = ZFCP_ERP_FAILED; 1370 struct zfcp_adapter *adapter = erp_action->adapter; 1371 1372 /* 1373 * try to execute/continue action as far as possible, 1374 * note: no lock in subsequent strategy routines 1375 * (this allows these routine to call schedule, e.g. 1376 * kmalloc with such flags or qdio_initialize & friends) 1377 * Note: in case of timeout, the seperate strategies will fail 1378 * anyhow. No need for a special action. Even worse, a nameserver 1379 * failure would not wake up waiting ports without the call. 1380 */ 1381 switch (erp_action->action) { 1382 1383 case ZFCP_ERP_ACTION_REOPEN_ADAPTER: 1384 retval = zfcp_erp_adapter_strategy(erp_action); 1385 break; 1386 1387 case ZFCP_ERP_ACTION_REOPEN_PORT_FORCED: 1388 retval = zfcp_erp_port_forced_strategy(erp_action); 1389 break; 1390 1391 case ZFCP_ERP_ACTION_REOPEN_PORT: 1392 retval = zfcp_erp_port_strategy(erp_action); 1393 break; 1394 1395 case ZFCP_ERP_ACTION_REOPEN_UNIT: 1396 retval = zfcp_erp_unit_strategy(erp_action); 1397 break; 1398 1399 default: 1400 debug_text_exception(adapter->erp_dbf, 1, "a_stda_bug"); 1401 debug_event(adapter->erp_dbf, 1, &erp_action->action, 1402 sizeof (int)); 1403 ZFCP_LOG_NORMAL("bug: unknown erp action requested on " 1404 "adapter %s (action=%d)\n", 1405 zfcp_get_busid_by_adapter(erp_action->adapter), 1406 erp_action->action); 1407 } 1408 1409 return retval; 1410 } 1411 1412 /* 1413 * function: 1414 * 1415 * purpose: triggers retry of this action after a certain amount of time 1416 * by means of timer provided by erp_action 1417 * 1418 * returns: ZFCP_ERP_CONTINUES - erp_action sleeps in erp running queue 1419 */ 1420 static int 1421 zfcp_erp_strategy_memwait(struct zfcp_erp_action *erp_action) 1422 { 1423 int retval = ZFCP_ERP_CONTINUES; 1424 struct zfcp_adapter *adapter = erp_action->adapter; 1425 1426 debug_text_event(adapter->erp_dbf, 6, "a_mwinit"); 1427 debug_event(adapter->erp_dbf, 6, &erp_action->action, sizeof (int)); 1428 init_timer(&erp_action->timer); 1429 erp_action->timer.function = zfcp_erp_memwait_handler; 1430 erp_action->timer.data = (unsigned long) erp_action; 1431 erp_action->timer.expires = jiffies + ZFCP_ERP_MEMWAIT_TIMEOUT; 1432 add_timer(&erp_action->timer); 1433 1434 return retval; 1435 } 1436 1437 /* 1438 * function: zfcp_erp_adapter_failed 1439 * 1440 * purpose: sets the adapter and all underlying devices to ERP_FAILED 1441 * 1442 */ 1443 void 1444 zfcp_erp_adapter_failed(struct zfcp_adapter *adapter) 1445 { 1446 zfcp_erp_modify_adapter_status(adapter, 1447 ZFCP_STATUS_COMMON_ERP_FAILED, ZFCP_SET); 1448 ZFCP_LOG_NORMAL("adapter erp failed on adapter %s\n", 1449 zfcp_get_busid_by_adapter(adapter)); 1450 debug_text_event(adapter->erp_dbf, 2, "a_afail"); 1451 } 1452 1453 /* 1454 * function: zfcp_erp_port_failed 1455 * 1456 * purpose: sets the port and all underlying devices to ERP_FAILED 1457 * 1458 */ 1459 void 1460 zfcp_erp_port_failed(struct zfcp_port *port) 1461 { 1462 zfcp_erp_modify_port_status(port, 1463 ZFCP_STATUS_COMMON_ERP_FAILED, ZFCP_SET); 1464 1465 if (atomic_test_mask(ZFCP_STATUS_PORT_WKA, &port->status)) 1466 ZFCP_LOG_NORMAL("port erp failed (adapter %s, " 1467 "port d_id=0x%08x)\n", 1468 zfcp_get_busid_by_port(port), port->d_id); 1469 else 1470 ZFCP_LOG_NORMAL("port erp failed (adapter %s, wwpn=0x%016Lx)\n", 1471 zfcp_get_busid_by_port(port), port->wwpn); 1472 1473 debug_text_event(port->adapter->erp_dbf, 2, "p_pfail"); 1474 debug_event(port->adapter->erp_dbf, 2, &port->wwpn, sizeof (wwn_t)); 1475 } 1476 1477 /* 1478 * function: zfcp_erp_unit_failed 1479 * 1480 * purpose: sets the unit to ERP_FAILED 1481 * 1482 */ 1483 void 1484 zfcp_erp_unit_failed(struct zfcp_unit *unit) 1485 { 1486 zfcp_erp_modify_unit_status(unit, 1487 ZFCP_STATUS_COMMON_ERP_FAILED, ZFCP_SET); 1488 1489 ZFCP_LOG_NORMAL("unit erp failed on unit 0x%016Lx on port 0x%016Lx " 1490 " on adapter %s\n", unit->fcp_lun, 1491 unit->port->wwpn, zfcp_get_busid_by_unit(unit)); 1492 debug_text_event(unit->port->adapter->erp_dbf, 2, "u_ufail"); 1493 debug_event(unit->port->adapter->erp_dbf, 2, 1494 &unit->fcp_lun, sizeof (fcp_lun_t)); 1495 } 1496 1497 /* 1498 * function: zfcp_erp_strategy_check_target 1499 * 1500 * purpose: increments the erp action count on the device currently in 1501 * recovery if the action failed or resets the count in case of 1502 * success. If a maximum count is exceeded the device is marked 1503 * as ERP_FAILED. 1504 * The 'blocked' state of a target which has been recovered 1505 * successfully is reset. 1506 * 1507 * returns: ZFCP_ERP_CONTINUES - action continues (not considered) 1508 * ZFCP_ERP_SUCCEEDED - action finished successfully 1509 * ZFCP_ERP_EXIT - action failed and will not continue 1510 */ 1511 static int 1512 zfcp_erp_strategy_check_target(struct zfcp_erp_action *erp_action, int result) 1513 { 1514 struct zfcp_adapter *adapter = erp_action->adapter; 1515 struct zfcp_port *port = erp_action->port; 1516 struct zfcp_unit *unit = erp_action->unit; 1517 1518 debug_text_event(adapter->erp_dbf, 5, "a_stct_norm"); 1519 debug_event(adapter->erp_dbf, 5, &erp_action->action, sizeof (int)); 1520 debug_event(adapter->erp_dbf, 5, &result, sizeof (int)); 1521 1522 switch (erp_action->action) { 1523 1524 case ZFCP_ERP_ACTION_REOPEN_UNIT: 1525 result = zfcp_erp_strategy_check_unit(unit, result); 1526 break; 1527 1528 case ZFCP_ERP_ACTION_REOPEN_PORT_FORCED: 1529 case ZFCP_ERP_ACTION_REOPEN_PORT: 1530 result = zfcp_erp_strategy_check_port(port, result); 1531 break; 1532 1533 case ZFCP_ERP_ACTION_REOPEN_ADAPTER: 1534 result = zfcp_erp_strategy_check_adapter(adapter, result); 1535 break; 1536 } 1537 1538 return result; 1539 } 1540 1541 /* 1542 * function: 1543 * 1544 * purpose: 1545 * 1546 * returns: 1547 */ 1548 static int 1549 zfcp_erp_strategy_statechange(int action, 1550 u32 status, 1551 struct zfcp_adapter *adapter, 1552 struct zfcp_port *port, 1553 struct zfcp_unit *unit, int retval) 1554 { 1555 debug_text_event(adapter->erp_dbf, 3, "a_stsc"); 1556 debug_event(adapter->erp_dbf, 3, &action, sizeof (int)); 1557 1558 switch (action) { 1559 1560 case ZFCP_ERP_ACTION_REOPEN_ADAPTER: 1561 if (zfcp_erp_strategy_statechange_detected(&adapter->status, 1562 status)) { 1563 zfcp_erp_adapter_reopen_internal(adapter, ZFCP_STATUS_COMMON_ERP_FAILED); 1564 retval = ZFCP_ERP_EXIT; 1565 } 1566 break; 1567 1568 case ZFCP_ERP_ACTION_REOPEN_PORT_FORCED: 1569 case ZFCP_ERP_ACTION_REOPEN_PORT: 1570 if (zfcp_erp_strategy_statechange_detected(&port->status, 1571 status)) { 1572 zfcp_erp_port_reopen_internal(port, ZFCP_STATUS_COMMON_ERP_FAILED); 1573 retval = ZFCP_ERP_EXIT; 1574 } 1575 break; 1576 1577 case ZFCP_ERP_ACTION_REOPEN_UNIT: 1578 if (zfcp_erp_strategy_statechange_detected(&unit->status, 1579 status)) { 1580 zfcp_erp_unit_reopen_internal(unit, ZFCP_STATUS_COMMON_ERP_FAILED); 1581 retval = ZFCP_ERP_EXIT; 1582 } 1583 break; 1584 } 1585 1586 return retval; 1587 } 1588 1589 /* 1590 * function: 1591 * 1592 * purpose: 1593 * 1594 * returns: 1595 */ 1596 static inline int 1597 zfcp_erp_strategy_statechange_detected(atomic_t * target_status, u32 erp_status) 1598 { 1599 return 1600 /* take it online */ 1601 (atomic_test_mask(ZFCP_STATUS_COMMON_RUNNING, target_status) && 1602 (ZFCP_STATUS_ERP_CLOSE_ONLY & erp_status)) || 1603 /* take it offline */ 1604 (!atomic_test_mask(ZFCP_STATUS_COMMON_RUNNING, target_status) && 1605 !(ZFCP_STATUS_ERP_CLOSE_ONLY & erp_status)); 1606 } 1607 1608 /* 1609 * function: 1610 * 1611 * purpose: 1612 * 1613 * returns: 1614 */ 1615 static int 1616 zfcp_erp_strategy_check_unit(struct zfcp_unit *unit, int result) 1617 { 1618 debug_text_event(unit->port->adapter->erp_dbf, 5, "u_stct"); 1619 debug_event(unit->port->adapter->erp_dbf, 5, &unit->fcp_lun, 1620 sizeof (fcp_lun_t)); 1621 1622 switch (result) { 1623 case ZFCP_ERP_SUCCEEDED : 1624 atomic_set(&unit->erp_counter, 0); 1625 zfcp_erp_unit_unblock(unit); 1626 break; 1627 case ZFCP_ERP_FAILED : 1628 atomic_inc(&unit->erp_counter); 1629 if (atomic_read(&unit->erp_counter) > ZFCP_MAX_ERPS) 1630 zfcp_erp_unit_failed(unit); 1631 break; 1632 case ZFCP_ERP_EXIT : 1633 /* nothing */ 1634 break; 1635 } 1636 1637 if (atomic_test_mask(ZFCP_STATUS_COMMON_ERP_FAILED, &unit->status)) { 1638 zfcp_erp_unit_block(unit, 0); /* for ZFCP_ERP_SUCCEEDED */ 1639 result = ZFCP_ERP_EXIT; 1640 } 1641 1642 return result; 1643 } 1644 1645 /* 1646 * function: 1647 * 1648 * purpose: 1649 * 1650 * returns: 1651 */ 1652 static int 1653 zfcp_erp_strategy_check_port(struct zfcp_port *port, int result) 1654 { 1655 debug_text_event(port->adapter->erp_dbf, 5, "p_stct"); 1656 debug_event(port->adapter->erp_dbf, 5, &port->wwpn, sizeof (wwn_t)); 1657 1658 switch (result) { 1659 case ZFCP_ERP_SUCCEEDED : 1660 atomic_set(&port->erp_counter, 0); 1661 zfcp_erp_port_unblock(port); 1662 break; 1663 case ZFCP_ERP_FAILED : 1664 atomic_inc(&port->erp_counter); 1665 if (atomic_read(&port->erp_counter) > ZFCP_MAX_ERPS) 1666 zfcp_erp_port_failed(port); 1667 break; 1668 case ZFCP_ERP_EXIT : 1669 /* nothing */ 1670 break; 1671 } 1672 1673 if (atomic_test_mask(ZFCP_STATUS_COMMON_ERP_FAILED, &port->status)) { 1674 zfcp_erp_port_block(port, 0); /* for ZFCP_ERP_SUCCEEDED */ 1675 result = ZFCP_ERP_EXIT; 1676 } 1677 1678 return result; 1679 } 1680 1681 /* 1682 * function: 1683 * 1684 * purpose: 1685 * 1686 * returns: 1687 */ 1688 static int 1689 zfcp_erp_strategy_check_adapter(struct zfcp_adapter *adapter, int result) 1690 { 1691 debug_text_event(adapter->erp_dbf, 5, "a_stct"); 1692 1693 switch (result) { 1694 case ZFCP_ERP_SUCCEEDED : 1695 atomic_set(&adapter->erp_counter, 0); 1696 zfcp_erp_adapter_unblock(adapter); 1697 break; 1698 case ZFCP_ERP_FAILED : 1699 atomic_inc(&adapter->erp_counter); 1700 if (atomic_read(&adapter->erp_counter) > ZFCP_MAX_ERPS) 1701 zfcp_erp_adapter_failed(adapter); 1702 break; 1703 case ZFCP_ERP_EXIT : 1704 /* nothing */ 1705 break; 1706 } 1707 1708 if (atomic_test_mask(ZFCP_STATUS_COMMON_ERP_FAILED, &adapter->status)) { 1709 zfcp_erp_adapter_block(adapter, 0); /* for ZFCP_ERP_SUCCEEDED */ 1710 result = ZFCP_ERP_EXIT; 1711 } 1712 1713 return result; 1714 } 1715 1716 /* 1717 * function: 1718 * 1719 * purpose: remaining things in good cases, 1720 * escalation in bad cases 1721 * 1722 * returns: 1723 */ 1724 static int 1725 zfcp_erp_strategy_followup_actions(int action, 1726 struct zfcp_adapter *adapter, 1727 struct zfcp_port *port, 1728 struct zfcp_unit *unit, int status) 1729 { 1730 debug_text_event(adapter->erp_dbf, 5, "a_stfol"); 1731 debug_event(adapter->erp_dbf, 5, &action, sizeof (int)); 1732 1733 /* initiate follow-up actions depending on success of finished action */ 1734 switch (action) { 1735 1736 case ZFCP_ERP_ACTION_REOPEN_ADAPTER: 1737 if (status == ZFCP_ERP_SUCCEEDED) 1738 zfcp_erp_port_reopen_all_internal(adapter, 0); 1739 else 1740 zfcp_erp_adapter_reopen_internal(adapter, 0); 1741 break; 1742 1743 case ZFCP_ERP_ACTION_REOPEN_PORT_FORCED: 1744 if (status == ZFCP_ERP_SUCCEEDED) 1745 zfcp_erp_port_reopen_internal(port, 0); 1746 else 1747 zfcp_erp_adapter_reopen_internal(adapter, 0); 1748 break; 1749 1750 case ZFCP_ERP_ACTION_REOPEN_PORT: 1751 if (status == ZFCP_ERP_SUCCEEDED) 1752 zfcp_erp_unit_reopen_all_internal(port, 0); 1753 else 1754 zfcp_erp_port_forced_reopen_internal(port, 0); 1755 break; 1756 1757 case ZFCP_ERP_ACTION_REOPEN_UNIT: 1758 if (status == ZFCP_ERP_SUCCEEDED) ; /* no further action */ 1759 else 1760 zfcp_erp_port_reopen_internal(unit->port, 0); 1761 break; 1762 } 1763 1764 return 0; 1765 } 1766 1767 /* 1768 * function: 1769 * 1770 * purpose: 1771 * 1772 * returns: 1773 */ 1774 static int 1775 zfcp_erp_strategy_check_queues(struct zfcp_adapter *adapter) 1776 { 1777 unsigned long flags; 1778 1779 read_lock_irqsave(&zfcp_data.config_lock, flags); 1780 read_lock(&adapter->erp_lock); 1781 if (list_empty(&adapter->erp_ready_head) && 1782 list_empty(&adapter->erp_running_head)) { 1783 debug_text_event(adapter->erp_dbf, 4, "a_cq_wake"); 1784 atomic_clear_mask(ZFCP_STATUS_ADAPTER_ERP_PENDING, 1785 &adapter->status); 1786 wake_up(&adapter->erp_done_wqh); 1787 } else 1788 debug_text_event(adapter->erp_dbf, 5, "a_cq_notempty"); 1789 read_unlock(&adapter->erp_lock); 1790 read_unlock_irqrestore(&zfcp_data.config_lock, flags); 1791 1792 return 0; 1793 } 1794 1795 /** 1796 * zfcp_erp_wait - wait for completion of error recovery on an adapter 1797 * @adapter: adapter for which to wait for completion of its error recovery 1798 * Return: 0 1799 */ 1800 int 1801 zfcp_erp_wait(struct zfcp_adapter *adapter) 1802 { 1803 int retval = 0; 1804 1805 wait_event(adapter->erp_done_wqh, 1806 !atomic_test_mask(ZFCP_STATUS_ADAPTER_ERP_PENDING, 1807 &adapter->status)); 1808 1809 return retval; 1810 } 1811 1812 /* 1813 * function: zfcp_erp_modify_adapter_status 1814 * 1815 * purpose: 1816 * 1817 */ 1818 void 1819 zfcp_erp_modify_adapter_status(struct zfcp_adapter *adapter, 1820 u32 mask, int set_or_clear) 1821 { 1822 struct zfcp_port *port; 1823 u32 common_mask = mask & ZFCP_COMMON_FLAGS; 1824 1825 if (set_or_clear == ZFCP_SET) { 1826 atomic_set_mask(mask, &adapter->status); 1827 debug_text_event(adapter->erp_dbf, 3, "a_mod_as_s"); 1828 } else { 1829 atomic_clear_mask(mask, &adapter->status); 1830 if (mask & ZFCP_STATUS_COMMON_ERP_FAILED) 1831 atomic_set(&adapter->erp_counter, 0); 1832 debug_text_event(adapter->erp_dbf, 3, "a_mod_as_c"); 1833 } 1834 debug_event(adapter->erp_dbf, 3, &mask, sizeof (u32)); 1835 1836 /* Deal with all underlying devices, only pass common_mask */ 1837 if (common_mask) 1838 list_for_each_entry(port, &adapter->port_list_head, list) 1839 zfcp_erp_modify_port_status(port, common_mask, 1840 set_or_clear); 1841 } 1842 1843 /* 1844 * function: zfcp_erp_modify_port_status 1845 * 1846 * purpose: sets the port and all underlying devices to ERP_FAILED 1847 * 1848 */ 1849 void 1850 zfcp_erp_modify_port_status(struct zfcp_port *port, u32 mask, int set_or_clear) 1851 { 1852 struct zfcp_unit *unit; 1853 u32 common_mask = mask & ZFCP_COMMON_FLAGS; 1854 1855 if (set_or_clear == ZFCP_SET) { 1856 atomic_set_mask(mask, &port->status); 1857 debug_text_event(port->adapter->erp_dbf, 3, "p_mod_ps_s"); 1858 } else { 1859 atomic_clear_mask(mask, &port->status); 1860 if (mask & ZFCP_STATUS_COMMON_ERP_FAILED) 1861 atomic_set(&port->erp_counter, 0); 1862 debug_text_event(port->adapter->erp_dbf, 3, "p_mod_ps_c"); 1863 } 1864 debug_event(port->adapter->erp_dbf, 3, &port->wwpn, sizeof (wwn_t)); 1865 debug_event(port->adapter->erp_dbf, 3, &mask, sizeof (u32)); 1866 1867 /* Modify status of all underlying devices, only pass common mask */ 1868 if (common_mask) 1869 list_for_each_entry(unit, &port->unit_list_head, list) 1870 zfcp_erp_modify_unit_status(unit, common_mask, 1871 set_or_clear); 1872 } 1873 1874 /* 1875 * function: zfcp_erp_modify_unit_status 1876 * 1877 * purpose: sets the unit to ERP_FAILED 1878 * 1879 */ 1880 void 1881 zfcp_erp_modify_unit_status(struct zfcp_unit *unit, u32 mask, int set_or_clear) 1882 { 1883 if (set_or_clear == ZFCP_SET) { 1884 atomic_set_mask(mask, &unit->status); 1885 debug_text_event(unit->port->adapter->erp_dbf, 3, "u_mod_us_s"); 1886 } else { 1887 atomic_clear_mask(mask, &unit->status); 1888 if (mask & ZFCP_STATUS_COMMON_ERP_FAILED) { 1889 atomic_set(&unit->erp_counter, 0); 1890 } 1891 debug_text_event(unit->port->adapter->erp_dbf, 3, "u_mod_us_c"); 1892 } 1893 debug_event(unit->port->adapter->erp_dbf, 3, &unit->fcp_lun, 1894 sizeof (fcp_lun_t)); 1895 debug_event(unit->port->adapter->erp_dbf, 3, &mask, sizeof (u32)); 1896 } 1897 1898 /* 1899 * function: 1900 * 1901 * purpose: Wrappper for zfcp_erp_port_reopen_all_internal 1902 * used to ensure the correct locking 1903 * 1904 * returns: 0 - initiated action succesfully 1905 * <0 - failed to initiate action 1906 */ 1907 int 1908 zfcp_erp_port_reopen_all(struct zfcp_adapter *adapter, int clear_mask) 1909 { 1910 int retval; 1911 unsigned long flags; 1912 1913 read_lock_irqsave(&zfcp_data.config_lock, flags); 1914 write_lock(&adapter->erp_lock); 1915 retval = zfcp_erp_port_reopen_all_internal(adapter, clear_mask); 1916 write_unlock(&adapter->erp_lock); 1917 read_unlock_irqrestore(&zfcp_data.config_lock, flags); 1918 1919 return retval; 1920 } 1921 1922 /* 1923 * function: 1924 * 1925 * purpose: 1926 * 1927 * returns: FIXME 1928 */ 1929 static int 1930 zfcp_erp_port_reopen_all_internal(struct zfcp_adapter *adapter, int clear_mask) 1931 { 1932 int retval = 0; 1933 struct zfcp_port *port; 1934 1935 list_for_each_entry(port, &adapter->port_list_head, list) 1936 if (!atomic_test_mask(ZFCP_STATUS_PORT_WKA, &port->status)) 1937 zfcp_erp_port_reopen_internal(port, clear_mask); 1938 1939 return retval; 1940 } 1941 1942 /* 1943 * function: 1944 * 1945 * purpose: 1946 * 1947 * returns: FIXME 1948 */ 1949 static int 1950 zfcp_erp_unit_reopen_all_internal(struct zfcp_port *port, int clear_mask) 1951 { 1952 int retval = 0; 1953 struct zfcp_unit *unit; 1954 1955 list_for_each_entry(unit, &port->unit_list_head, list) 1956 zfcp_erp_unit_reopen_internal(unit, clear_mask); 1957 1958 return retval; 1959 } 1960 1961 /* 1962 * function: 1963 * 1964 * purpose: this routine executes the 'Reopen Adapter' action 1965 * (the entire action is processed synchronously, since 1966 * there are no actions which might be run concurrently 1967 * per definition) 1968 * 1969 * returns: ZFCP_ERP_SUCCEEDED - action finished successfully 1970 * ZFCP_ERP_FAILED - action finished unsuccessfully 1971 */ 1972 static int 1973 zfcp_erp_adapter_strategy(struct zfcp_erp_action *erp_action) 1974 { 1975 int retval; 1976 struct zfcp_adapter *adapter = erp_action->adapter; 1977 1978 retval = zfcp_erp_adapter_strategy_close(erp_action); 1979 if (erp_action->status & ZFCP_STATUS_ERP_CLOSE_ONLY) 1980 retval = ZFCP_ERP_EXIT; 1981 else 1982 retval = zfcp_erp_adapter_strategy_open(erp_action); 1983 1984 debug_text_event(adapter->erp_dbf, 3, "a_ast/ret"); 1985 debug_event(adapter->erp_dbf, 3, &erp_action->action, sizeof (int)); 1986 debug_event(adapter->erp_dbf, 3, &retval, sizeof (int)); 1987 1988 if (retval == ZFCP_ERP_FAILED) { 1989 ZFCP_LOG_INFO("Waiting to allow the adapter %s " 1990 "to recover itself\n", 1991 zfcp_get_busid_by_adapter(adapter)); 1992 msleep(jiffies_to_msecs(ZFCP_TYPE2_RECOVERY_TIME)); 1993 } 1994 1995 return retval; 1996 } 1997 1998 /* 1999 * function: 2000 * 2001 * purpose: 2002 * 2003 * returns: ZFCP_ERP_SUCCEEDED - action finished successfully 2004 * ZFCP_ERP_FAILED - action finished unsuccessfully 2005 */ 2006 static int 2007 zfcp_erp_adapter_strategy_close(struct zfcp_erp_action *erp_action) 2008 { 2009 int retval; 2010 2011 atomic_set_mask(ZFCP_STATUS_COMMON_CLOSING, 2012 &erp_action->adapter->status); 2013 retval = zfcp_erp_adapter_strategy_generic(erp_action, 1); 2014 atomic_clear_mask(ZFCP_STATUS_COMMON_CLOSING, 2015 &erp_action->adapter->status); 2016 2017 return retval; 2018 } 2019 2020 /* 2021 * function: 2022 * 2023 * purpose: 2024 * 2025 * returns: ZFCP_ERP_SUCCEEDED - action finished successfully 2026 * ZFCP_ERP_FAILED - action finished unsuccessfully 2027 */ 2028 static int 2029 zfcp_erp_adapter_strategy_open(struct zfcp_erp_action *erp_action) 2030 { 2031 int retval; 2032 2033 atomic_set_mask(ZFCP_STATUS_COMMON_OPENING, 2034 &erp_action->adapter->status); 2035 retval = zfcp_erp_adapter_strategy_generic(erp_action, 0); 2036 atomic_clear_mask(ZFCP_STATUS_COMMON_OPENING, 2037 &erp_action->adapter->status); 2038 2039 return retval; 2040 } 2041 2042 /* 2043 * function: zfcp_register_adapter 2044 * 2045 * purpose: allocate the irq associated with this devno and register 2046 * the FSF adapter with the SCSI stack 2047 * 2048 * returns: 2049 */ 2050 static int 2051 zfcp_erp_adapter_strategy_generic(struct zfcp_erp_action *erp_action, int close) 2052 { 2053 int retval = ZFCP_ERP_SUCCEEDED; 2054 2055 if (close) 2056 goto close_only; 2057 2058 retval = zfcp_erp_adapter_strategy_open_qdio(erp_action); 2059 if (retval != ZFCP_ERP_SUCCEEDED) 2060 goto failed_qdio; 2061 2062 retval = zfcp_erp_adapter_strategy_open_fsf(erp_action); 2063 if (retval != ZFCP_ERP_SUCCEEDED) 2064 goto failed_openfcp; 2065 2066 atomic_set_mask(ZFCP_STATUS_COMMON_OPEN, &erp_action->adapter->status); 2067 goto out; 2068 2069 close_only: 2070 atomic_clear_mask(ZFCP_STATUS_COMMON_OPEN, 2071 &erp_action->adapter->status); 2072 2073 failed_openfcp: 2074 zfcp_erp_adapter_strategy_close_qdio(erp_action); 2075 zfcp_erp_adapter_strategy_close_fsf(erp_action); 2076 failed_qdio: 2077 out: 2078 return retval; 2079 } 2080 2081 /* 2082 * function: zfcp_qdio_init 2083 * 2084 * purpose: setup QDIO operation for specified adapter 2085 * 2086 * returns: 0 - successful setup 2087 * !0 - failed setup 2088 */ 2089 int 2090 zfcp_erp_adapter_strategy_open_qdio(struct zfcp_erp_action *erp_action) 2091 { 2092 int retval; 2093 int i; 2094 volatile struct qdio_buffer_element *sbale; 2095 struct zfcp_adapter *adapter = erp_action->adapter; 2096 2097 if (atomic_test_mask(ZFCP_STATUS_ADAPTER_QDIOUP, &adapter->status)) { 2098 ZFCP_LOG_NORMAL("bug: second attempt to set up QDIO on " 2099 "adapter %s\n", 2100 zfcp_get_busid_by_adapter(adapter)); 2101 goto failed_sanity; 2102 } 2103 2104 if (qdio_establish(&adapter->qdio_init_data) != 0) { 2105 ZFCP_LOG_INFO("error: establishment of QDIO queues failed " 2106 "on adapter %s\n", 2107 zfcp_get_busid_by_adapter(adapter)); 2108 goto failed_qdio_establish; 2109 } 2110 debug_text_event(adapter->erp_dbf, 3, "qdio_est"); 2111 2112 if (qdio_activate(adapter->ccw_device, 0) != 0) { 2113 ZFCP_LOG_INFO("error: activation of QDIO queues failed " 2114 "on adapter %s\n", 2115 zfcp_get_busid_by_adapter(adapter)); 2116 goto failed_qdio_activate; 2117 } 2118 debug_text_event(adapter->erp_dbf, 3, "qdio_act"); 2119 2120 /* 2121 * put buffers into response queue, 2122 */ 2123 for (i = 0; i < QDIO_MAX_BUFFERS_PER_Q; i++) { 2124 sbale = &(adapter->response_queue.buffer[i]->element[0]); 2125 sbale->length = 0; 2126 sbale->flags = SBAL_FLAGS_LAST_ENTRY; 2127 sbale->addr = 0; 2128 } 2129 2130 ZFCP_LOG_TRACE("calling do_QDIO on adapter %s (flags=0x%x, " 2131 "queue_no=%i, index_in_queue=%i, count=%i)\n", 2132 zfcp_get_busid_by_adapter(adapter), 2133 QDIO_FLAG_SYNC_INPUT, 0, 0, QDIO_MAX_BUFFERS_PER_Q); 2134 2135 retval = do_QDIO(adapter->ccw_device, 2136 QDIO_FLAG_SYNC_INPUT, 2137 0, 0, QDIO_MAX_BUFFERS_PER_Q, NULL); 2138 2139 if (retval) { 2140 ZFCP_LOG_NORMAL("bug: setup of QDIO failed (retval=%d)\n", 2141 retval); 2142 goto failed_do_qdio; 2143 } else { 2144 adapter->response_queue.free_index = 0; 2145 atomic_set(&adapter->response_queue.free_count, 0); 2146 ZFCP_LOG_DEBUG("%i buffers successfully enqueued to " 2147 "response queue\n", QDIO_MAX_BUFFERS_PER_Q); 2148 } 2149 /* set index of first avalable SBALS / number of available SBALS */ 2150 adapter->request_queue.free_index = 0; 2151 atomic_set(&adapter->request_queue.free_count, QDIO_MAX_BUFFERS_PER_Q); 2152 adapter->request_queue.distance_from_int = 0; 2153 2154 /* initialize waitqueue used to wait for free SBALs in requests queue */ 2155 init_waitqueue_head(&adapter->request_wq); 2156 2157 /* ok, we did it - skip all cleanups for different failures */ 2158 atomic_set_mask(ZFCP_STATUS_ADAPTER_QDIOUP, &adapter->status); 2159 retval = ZFCP_ERP_SUCCEEDED; 2160 goto out; 2161 2162 failed_do_qdio: 2163 /* NOP */ 2164 2165 failed_qdio_activate: 2166 debug_text_event(adapter->erp_dbf, 3, "qdio_down1a"); 2167 while (qdio_shutdown(adapter->ccw_device, 2168 QDIO_FLAG_CLEANUP_USING_CLEAR) == -EINPROGRESS) 2169 msleep(1000); 2170 debug_text_event(adapter->erp_dbf, 3, "qdio_down1b"); 2171 2172 failed_qdio_establish: 2173 failed_sanity: 2174 retval = ZFCP_ERP_FAILED; 2175 2176 out: 2177 return retval; 2178 } 2179 2180 /* 2181 * function: zfcp_qdio_cleanup 2182 * 2183 * purpose: cleans up QDIO operation for the specified adapter 2184 * 2185 * returns: 0 - successful cleanup 2186 * !0 - failed cleanup 2187 */ 2188 int 2189 zfcp_erp_adapter_strategy_close_qdio(struct zfcp_erp_action *erp_action) 2190 { 2191 int retval = ZFCP_ERP_SUCCEEDED; 2192 int first_used; 2193 int used_count; 2194 struct zfcp_adapter *adapter = erp_action->adapter; 2195 2196 if (!atomic_test_mask(ZFCP_STATUS_ADAPTER_QDIOUP, &adapter->status)) { 2197 ZFCP_LOG_DEBUG("error: attempt to shut down inactive QDIO " 2198 "queues on adapter %s\n", 2199 zfcp_get_busid_by_adapter(adapter)); 2200 retval = ZFCP_ERP_FAILED; 2201 goto out; 2202 } 2203 2204 /* 2205 * Get queue_lock and clear QDIOUP flag. Thus it's guaranteed that 2206 * do_QDIO won't be called while qdio_shutdown is in progress. 2207 */ 2208 2209 write_lock_irq(&adapter->request_queue.queue_lock); 2210 atomic_clear_mask(ZFCP_STATUS_ADAPTER_QDIOUP, &adapter->status); 2211 write_unlock_irq(&adapter->request_queue.queue_lock); 2212 2213 debug_text_event(adapter->erp_dbf, 3, "qdio_down2a"); 2214 while (qdio_shutdown(adapter->ccw_device, 2215 QDIO_FLAG_CLEANUP_USING_CLEAR) == -EINPROGRESS) 2216 msleep(1000); 2217 debug_text_event(adapter->erp_dbf, 3, "qdio_down2b"); 2218 2219 /* 2220 * First we had to stop QDIO operation. 2221 * Now it is safe to take the following actions. 2222 */ 2223 2224 /* Cleanup only necessary when there are unacknowledged buffers */ 2225 if (atomic_read(&adapter->request_queue.free_count) 2226 < QDIO_MAX_BUFFERS_PER_Q) { 2227 first_used = (adapter->request_queue.free_index + 2228 atomic_read(&adapter->request_queue.free_count)) 2229 % QDIO_MAX_BUFFERS_PER_Q; 2230 used_count = QDIO_MAX_BUFFERS_PER_Q - 2231 atomic_read(&adapter->request_queue.free_count); 2232 zfcp_qdio_zero_sbals(adapter->request_queue.buffer, 2233 first_used, used_count); 2234 } 2235 adapter->response_queue.free_index = 0; 2236 atomic_set(&adapter->response_queue.free_count, 0); 2237 adapter->request_queue.free_index = 0; 2238 atomic_set(&adapter->request_queue.free_count, 0); 2239 adapter->request_queue.distance_from_int = 0; 2240 out: 2241 return retval; 2242 } 2243 2244 static int 2245 zfcp_erp_adapter_strategy_open_fsf(struct zfcp_erp_action *erp_action) 2246 { 2247 int retval; 2248 2249 retval = zfcp_erp_adapter_strategy_open_fsf_xconfig(erp_action); 2250 if (retval == ZFCP_ERP_FAILED) 2251 return ZFCP_ERP_FAILED; 2252 2253 retval = zfcp_erp_adapter_strategy_open_fsf_xport(erp_action); 2254 if (retval == ZFCP_ERP_FAILED) 2255 return ZFCP_ERP_FAILED; 2256 2257 return zfcp_erp_adapter_strategy_open_fsf_statusread(erp_action); 2258 } 2259 2260 static int 2261 zfcp_erp_adapter_strategy_open_fsf_xconfig(struct zfcp_erp_action *erp_action) 2262 { 2263 int retval = ZFCP_ERP_SUCCEEDED; 2264 int retries; 2265 int sleep = ZFCP_EXCHANGE_CONFIG_DATA_FIRST_SLEEP; 2266 struct zfcp_adapter *adapter = erp_action->adapter; 2267 2268 atomic_clear_mask(ZFCP_STATUS_ADAPTER_XCONFIG_OK, &adapter->status); 2269 2270 for (retries = ZFCP_EXCHANGE_CONFIG_DATA_RETRIES; retries; retries--) { 2271 atomic_clear_mask(ZFCP_STATUS_ADAPTER_HOST_CON_INIT, 2272 &adapter->status); 2273 ZFCP_LOG_DEBUG("Doing exchange config data\n"); 2274 write_lock(&adapter->erp_lock); 2275 zfcp_erp_action_to_running(erp_action); 2276 write_unlock(&adapter->erp_lock); 2277 zfcp_erp_timeout_init(erp_action); 2278 if (zfcp_fsf_exchange_config_data(erp_action)) { 2279 retval = ZFCP_ERP_FAILED; 2280 debug_text_event(adapter->erp_dbf, 5, "a_fstx_xf"); 2281 ZFCP_LOG_INFO("error: initiation of exchange of " 2282 "configuration data failed for " 2283 "adapter %s\n", 2284 zfcp_get_busid_by_adapter(adapter)); 2285 break; 2286 } 2287 debug_text_event(adapter->erp_dbf, 6, "a_fstx_xok"); 2288 ZFCP_LOG_DEBUG("Xchange underway\n"); 2289 2290 /* 2291 * Why this works: 2292 * Both the normal completion handler as well as the timeout 2293 * handler will do an 'up' when the 'exchange config data' 2294 * request completes or times out. Thus, the signal to go on 2295 * won't be lost utilizing this semaphore. 2296 * Furthermore, this 'adapter_reopen' action is 2297 * guaranteed to be the only action being there (highest action 2298 * which prevents other actions from being created). 2299 * Resulting from that, the wake signal recognized here 2300 * _must_ be the one belonging to the 'exchange config 2301 * data' request. 2302 */ 2303 down(&adapter->erp_ready_sem); 2304 if (erp_action->status & ZFCP_STATUS_ERP_TIMEDOUT) { 2305 ZFCP_LOG_INFO("error: exchange of configuration data " 2306 "for adapter %s timed out\n", 2307 zfcp_get_busid_by_adapter(adapter)); 2308 break; 2309 } 2310 2311 if (!atomic_test_mask(ZFCP_STATUS_ADAPTER_HOST_CON_INIT, 2312 &adapter->status)) 2313 break; 2314 2315 ZFCP_LOG_DEBUG("host connection still initialising... " 2316 "waiting and retrying...\n"); 2317 /* sleep a little bit before retry */ 2318 msleep(jiffies_to_msecs(sleep)); 2319 sleep *= 2; 2320 } 2321 2322 if (!atomic_test_mask(ZFCP_STATUS_ADAPTER_XCONFIG_OK, 2323 &adapter->status)) { 2324 ZFCP_LOG_INFO("error: exchange of configuration data for " 2325 "adapter %s failed\n", 2326 zfcp_get_busid_by_adapter(adapter)); 2327 retval = ZFCP_ERP_FAILED; 2328 } 2329 2330 return retval; 2331 } 2332 2333 static int 2334 zfcp_erp_adapter_strategy_open_fsf_xport(struct zfcp_erp_action *erp_action) 2335 { 2336 int ret; 2337 struct zfcp_adapter *adapter; 2338 2339 adapter = erp_action->adapter; 2340 atomic_clear_mask(ZFCP_STATUS_ADAPTER_XPORT_OK, &adapter->status); 2341 2342 write_lock(&adapter->erp_lock); 2343 zfcp_erp_action_to_running(erp_action); 2344 write_unlock(&adapter->erp_lock); 2345 2346 zfcp_erp_timeout_init(erp_action); 2347 ret = zfcp_fsf_exchange_port_data(erp_action, adapter, NULL); 2348 if (ret == -EOPNOTSUPP) { 2349 debug_text_event(adapter->erp_dbf, 3, "a_xport_notsupp"); 2350 return ZFCP_ERP_SUCCEEDED; 2351 } else if (ret) { 2352 debug_text_event(adapter->erp_dbf, 3, "a_xport_failed"); 2353 return ZFCP_ERP_FAILED; 2354 } 2355 debug_text_event(adapter->erp_dbf, 6, "a_xport_ok"); 2356 2357 ret = ZFCP_ERP_SUCCEEDED; 2358 down(&adapter->erp_ready_sem); 2359 if (erp_action->status & ZFCP_STATUS_ERP_TIMEDOUT) { 2360 ZFCP_LOG_INFO("error: exchange port data timed out (adapter " 2361 "%s)\n", zfcp_get_busid_by_adapter(adapter)); 2362 ret = ZFCP_ERP_FAILED; 2363 } 2364 if (!atomic_test_mask(ZFCP_STATUS_ADAPTER_XPORT_OK, &adapter->status)) { 2365 ZFCP_LOG_INFO("error: exchange port data failed (adapter " 2366 "%s\n", zfcp_get_busid_by_adapter(adapter)); 2367 ret = ZFCP_ERP_FAILED; 2368 } 2369 2370 return ret; 2371 } 2372 2373 /* 2374 * function: 2375 * 2376 * purpose: 2377 * 2378 * returns: 2379 */ 2380 static int 2381 zfcp_erp_adapter_strategy_open_fsf_statusread(struct zfcp_erp_action 2382 *erp_action) 2383 { 2384 int retval = ZFCP_ERP_SUCCEEDED; 2385 int temp_ret; 2386 struct zfcp_adapter *adapter = erp_action->adapter; 2387 int i; 2388 2389 adapter->status_read_failed = 0; 2390 for (i = 0; i < ZFCP_STATUS_READS_RECOM; i++) { 2391 temp_ret = zfcp_fsf_status_read(adapter, ZFCP_WAIT_FOR_SBAL); 2392 if (temp_ret < 0) { 2393 ZFCP_LOG_INFO("error: set-up of unsolicited status " 2394 "notification failed on adapter %s\n", 2395 zfcp_get_busid_by_adapter(adapter)); 2396 retval = ZFCP_ERP_FAILED; 2397 i--; 2398 break; 2399 } 2400 } 2401 2402 return retval; 2403 } 2404 2405 /* 2406 * function: zfcp_fsf_cleanup 2407 * 2408 * purpose: cleanup FSF operation for specified adapter 2409 * 2410 * returns: 0 - FSF operation successfully cleaned up 2411 * !0 - failed to cleanup FSF operation for this adapter 2412 */ 2413 static int 2414 zfcp_erp_adapter_strategy_close_fsf(struct zfcp_erp_action *erp_action) 2415 { 2416 int retval = ZFCP_ERP_SUCCEEDED; 2417 struct zfcp_adapter *adapter = erp_action->adapter; 2418 2419 /* 2420 * wake waiting initiators of requests, 2421 * return SCSI commands (with error status), 2422 * clean up all requests (synchronously) 2423 */ 2424 zfcp_fsf_req_dismiss_all(adapter); 2425 /* reset FSF request sequence number */ 2426 adapter->fsf_req_seq_no = 0; 2427 /* all ports and units are closed */ 2428 zfcp_erp_modify_adapter_status(adapter, 2429 ZFCP_STATUS_COMMON_OPEN, ZFCP_CLEAR); 2430 2431 return retval; 2432 } 2433 2434 /* 2435 * function: 2436 * 2437 * purpose: this routine executes the 'Reopen Physical Port' action 2438 * 2439 * returns: ZFCP_ERP_CONTINUES - action continues (asynchronously) 2440 * ZFCP_ERP_SUCCEEDED - action finished successfully 2441 * ZFCP_ERP_FAILED - action finished unsuccessfully 2442 */ 2443 static int 2444 zfcp_erp_port_forced_strategy(struct zfcp_erp_action *erp_action) 2445 { 2446 int retval = ZFCP_ERP_FAILED; 2447 struct zfcp_port *port = erp_action->port; 2448 struct zfcp_adapter *adapter = erp_action->adapter; 2449 2450 switch (erp_action->step) { 2451 2452 /* 2453 * FIXME: 2454 * the ULP spec. begs for waiting for oustanding commands 2455 */ 2456 case ZFCP_ERP_STEP_UNINITIALIZED: 2457 zfcp_erp_port_strategy_clearstati(port); 2458 /* 2459 * it would be sufficient to test only the normal open flag 2460 * since the phys. open flag cannot be set if the normal 2461 * open flag is unset - however, this is for readabilty ... 2462 */ 2463 if (atomic_test_mask((ZFCP_STATUS_PORT_PHYS_OPEN | 2464 ZFCP_STATUS_COMMON_OPEN), 2465 &port->status)) { 2466 ZFCP_LOG_DEBUG("port 0x%016Lx is open -> trying " 2467 "close physical\n", port->wwpn); 2468 retval = 2469 zfcp_erp_port_forced_strategy_close(erp_action); 2470 } else 2471 retval = ZFCP_ERP_FAILED; 2472 break; 2473 2474 case ZFCP_ERP_STEP_PHYS_PORT_CLOSING: 2475 if (atomic_test_mask(ZFCP_STATUS_PORT_PHYS_OPEN, 2476 &port->status)) { 2477 ZFCP_LOG_DEBUG("close physical failed for port " 2478 "0x%016Lx\n", port->wwpn); 2479 retval = ZFCP_ERP_FAILED; 2480 } else 2481 retval = ZFCP_ERP_SUCCEEDED; 2482 break; 2483 } 2484 2485 debug_text_event(adapter->erp_dbf, 3, "p_pfst/ret"); 2486 debug_event(adapter->erp_dbf, 3, &port->wwpn, sizeof (wwn_t)); 2487 debug_event(adapter->erp_dbf, 3, &erp_action->action, sizeof (int)); 2488 debug_event(adapter->erp_dbf, 3, &retval, sizeof (int)); 2489 2490 return retval; 2491 } 2492 2493 /* 2494 * function: 2495 * 2496 * purpose: this routine executes the 'Reopen Port' action 2497 * 2498 * returns: ZFCP_ERP_CONTINUES - action continues (asynchronously) 2499 * ZFCP_ERP_SUCCEEDED - action finished successfully 2500 * ZFCP_ERP_FAILED - action finished unsuccessfully 2501 */ 2502 static int 2503 zfcp_erp_port_strategy(struct zfcp_erp_action *erp_action) 2504 { 2505 int retval = ZFCP_ERP_FAILED; 2506 struct zfcp_port *port = erp_action->port; 2507 struct zfcp_adapter *adapter = erp_action->adapter; 2508 2509 switch (erp_action->step) { 2510 2511 /* 2512 * FIXME: 2513 * the ULP spec. begs for waiting for oustanding commands 2514 */ 2515 case ZFCP_ERP_STEP_UNINITIALIZED: 2516 zfcp_erp_port_strategy_clearstati(port); 2517 if (atomic_test_mask(ZFCP_STATUS_COMMON_OPEN, &port->status)) { 2518 ZFCP_LOG_DEBUG("port 0x%016Lx is open -> trying " 2519 "close\n", port->wwpn); 2520 retval = zfcp_erp_port_strategy_close(erp_action); 2521 goto out; 2522 } /* else it's already closed, open it */ 2523 break; 2524 2525 case ZFCP_ERP_STEP_PORT_CLOSING: 2526 if (atomic_test_mask(ZFCP_STATUS_COMMON_OPEN, &port->status)) { 2527 ZFCP_LOG_DEBUG("close failed for port 0x%016Lx\n", 2528 port->wwpn); 2529 retval = ZFCP_ERP_FAILED; 2530 goto out; 2531 } /* else it's closed now, open it */ 2532 break; 2533 } 2534 if (erp_action->status & ZFCP_STATUS_ERP_CLOSE_ONLY) 2535 retval = ZFCP_ERP_EXIT; 2536 else 2537 retval = zfcp_erp_port_strategy_open(erp_action); 2538 2539 out: 2540 debug_text_event(adapter->erp_dbf, 3, "p_pst/ret"); 2541 debug_event(adapter->erp_dbf, 3, &port->wwpn, sizeof (wwn_t)); 2542 debug_event(adapter->erp_dbf, 3, &erp_action->action, sizeof (int)); 2543 debug_event(adapter->erp_dbf, 3, &retval, sizeof (int)); 2544 2545 return retval; 2546 } 2547 2548 /* 2549 * function: 2550 * 2551 * purpose: 2552 * 2553 * returns: 2554 */ 2555 static int 2556 zfcp_erp_port_strategy_open(struct zfcp_erp_action *erp_action) 2557 { 2558 int retval; 2559 2560 if (atomic_test_mask(ZFCP_STATUS_PORT_WKA, 2561 &erp_action->port->status)) 2562 retval = zfcp_erp_port_strategy_open_nameserver(erp_action); 2563 else 2564 retval = zfcp_erp_port_strategy_open_common(erp_action); 2565 2566 return retval; 2567 } 2568 2569 /* 2570 * function: 2571 * 2572 * purpose: 2573 * 2574 * returns: 2575 * 2576 * FIXME(design): currently only prepared for fabric (nameserver!) 2577 */ 2578 static int 2579 zfcp_erp_port_strategy_open_common(struct zfcp_erp_action *erp_action) 2580 { 2581 int retval = 0; 2582 struct zfcp_adapter *adapter = erp_action->adapter; 2583 struct zfcp_port *port = erp_action->port; 2584 2585 switch (erp_action->step) { 2586 2587 case ZFCP_ERP_STEP_UNINITIALIZED: 2588 case ZFCP_ERP_STEP_PHYS_PORT_CLOSING: 2589 case ZFCP_ERP_STEP_PORT_CLOSING: 2590 if (fc_host_port_type(adapter->scsi_host) == FC_PORTTYPE_PTP) { 2591 if (port->wwpn != adapter->peer_wwpn) { 2592 ZFCP_LOG_NORMAL("Failed to open port 0x%016Lx " 2593 "on adapter %s.\nPeer WWPN " 2594 "0x%016Lx does not match\n", 2595 port->wwpn, 2596 zfcp_get_busid_by_adapter(adapter), 2597 adapter->peer_wwpn); 2598 zfcp_erp_port_failed(port); 2599 retval = ZFCP_ERP_FAILED; 2600 break; 2601 } 2602 port->d_id = adapter->peer_d_id; 2603 atomic_set_mask(ZFCP_STATUS_PORT_DID_DID, &port->status); 2604 retval = zfcp_erp_port_strategy_open_port(erp_action); 2605 break; 2606 } 2607 if (!(adapter->nameserver_port)) { 2608 retval = zfcp_nameserver_enqueue(adapter); 2609 if (retval != 0) { 2610 ZFCP_LOG_NORMAL("error: nameserver port " 2611 "unavailable for adapter %s\n", 2612 zfcp_get_busid_by_adapter(adapter)); 2613 retval = ZFCP_ERP_FAILED; 2614 break; 2615 } 2616 } 2617 if (!atomic_test_mask(ZFCP_STATUS_COMMON_UNBLOCKED, 2618 &adapter->nameserver_port->status)) { 2619 ZFCP_LOG_DEBUG("nameserver port is not open -> open " 2620 "nameserver port\n"); 2621 /* nameserver port may live again */ 2622 atomic_set_mask(ZFCP_STATUS_COMMON_RUNNING, 2623 &adapter->nameserver_port->status); 2624 if (zfcp_erp_port_reopen(adapter->nameserver_port, 0) 2625 >= 0) { 2626 erp_action->step = 2627 ZFCP_ERP_STEP_NAMESERVER_OPEN; 2628 retval = ZFCP_ERP_CONTINUES; 2629 } else 2630 retval = ZFCP_ERP_FAILED; 2631 break; 2632 } 2633 /* else nameserver port is already open, fall through */ 2634 case ZFCP_ERP_STEP_NAMESERVER_OPEN: 2635 if (!atomic_test_mask(ZFCP_STATUS_COMMON_OPEN, 2636 &adapter->nameserver_port->status)) { 2637 ZFCP_LOG_DEBUG("open failed for nameserver port\n"); 2638 retval = ZFCP_ERP_FAILED; 2639 } else { 2640 ZFCP_LOG_DEBUG("nameserver port is open -> " 2641 "nameserver look-up for port 0x%016Lx\n", 2642 port->wwpn); 2643 retval = zfcp_erp_port_strategy_open_common_lookup 2644 (erp_action); 2645 } 2646 break; 2647 2648 case ZFCP_ERP_STEP_NAMESERVER_LOOKUP: 2649 if (!atomic_test_mask(ZFCP_STATUS_PORT_DID_DID, &port->status)) { 2650 if (atomic_test_mask 2651 (ZFCP_STATUS_PORT_INVALID_WWPN, &port->status)) { 2652 ZFCP_LOG_DEBUG("nameserver look-up failed " 2653 "for port 0x%016Lx " 2654 "(misconfigured WWPN?)\n", 2655 port->wwpn); 2656 zfcp_erp_port_failed(port); 2657 retval = ZFCP_ERP_EXIT; 2658 } else { 2659 ZFCP_LOG_DEBUG("nameserver look-up failed for " 2660 "port 0x%016Lx\n", port->wwpn); 2661 retval = ZFCP_ERP_FAILED; 2662 } 2663 } else { 2664 ZFCP_LOG_DEBUG("port 0x%016Lx has d_id=0x%08x -> " 2665 "trying open\n", port->wwpn, port->d_id); 2666 retval = zfcp_erp_port_strategy_open_port(erp_action); 2667 } 2668 break; 2669 2670 case ZFCP_ERP_STEP_PORT_OPENING: 2671 /* D_ID might have changed during open */ 2672 if (atomic_test_mask((ZFCP_STATUS_COMMON_OPEN | 2673 ZFCP_STATUS_PORT_DID_DID), 2674 &port->status)) { 2675 ZFCP_LOG_DEBUG("port 0x%016Lx is open\n", port->wwpn); 2676 retval = ZFCP_ERP_SUCCEEDED; 2677 } else { 2678 ZFCP_LOG_DEBUG("open failed for port 0x%016Lx\n", 2679 port->wwpn); 2680 retval = ZFCP_ERP_FAILED; 2681 } 2682 break; 2683 2684 default: 2685 ZFCP_LOG_NORMAL("bug: unknown erp step 0x%08x\n", 2686 erp_action->step); 2687 retval = ZFCP_ERP_FAILED; 2688 } 2689 2690 return retval; 2691 } 2692 2693 /* 2694 * function: 2695 * 2696 * purpose: 2697 * 2698 * returns: 2699 */ 2700 static int 2701 zfcp_erp_port_strategy_open_nameserver(struct zfcp_erp_action *erp_action) 2702 { 2703 int retval; 2704 struct zfcp_port *port = erp_action->port; 2705 2706 switch (erp_action->step) { 2707 2708 case ZFCP_ERP_STEP_UNINITIALIZED: 2709 case ZFCP_ERP_STEP_PHYS_PORT_CLOSING: 2710 case ZFCP_ERP_STEP_PORT_CLOSING: 2711 ZFCP_LOG_DEBUG("port 0x%016Lx has d_id=0x%08x -> trying open\n", 2712 port->wwpn, port->d_id); 2713 retval = zfcp_erp_port_strategy_open_port(erp_action); 2714 break; 2715 2716 case ZFCP_ERP_STEP_PORT_OPENING: 2717 if (atomic_test_mask(ZFCP_STATUS_COMMON_OPEN, &port->status)) { 2718 ZFCP_LOG_DEBUG("WKA port is open\n"); 2719 retval = ZFCP_ERP_SUCCEEDED; 2720 } else { 2721 ZFCP_LOG_DEBUG("open failed for WKA port\n"); 2722 retval = ZFCP_ERP_FAILED; 2723 } 2724 /* this is needed anyway (dont care for retval of wakeup) */ 2725 ZFCP_LOG_DEBUG("continue other open port operations\n"); 2726 zfcp_erp_port_strategy_open_nameserver_wakeup(erp_action); 2727 break; 2728 2729 default: 2730 ZFCP_LOG_NORMAL("bug: unknown erp step 0x%08x\n", 2731 erp_action->step); 2732 retval = ZFCP_ERP_FAILED; 2733 } 2734 2735 return retval; 2736 } 2737 2738 /* 2739 * function: 2740 * 2741 * purpose: makes the erp thread continue with reopen (physical) port 2742 * actions which have been paused until the name server port 2743 * is opened (or failed) 2744 * 2745 * returns: 0 (a kind of void retval, its not used) 2746 */ 2747 static int 2748 zfcp_erp_port_strategy_open_nameserver_wakeup(struct zfcp_erp_action 2749 *ns_erp_action) 2750 { 2751 int retval = 0; 2752 unsigned long flags; 2753 struct zfcp_adapter *adapter = ns_erp_action->adapter; 2754 struct zfcp_erp_action *erp_action, *tmp; 2755 2756 read_lock_irqsave(&adapter->erp_lock, flags); 2757 list_for_each_entry_safe(erp_action, tmp, &adapter->erp_running_head, 2758 list) { 2759 debug_text_event(adapter->erp_dbf, 4, "p_pstnsw_n"); 2760 debug_event(adapter->erp_dbf, 4, &erp_action->port->wwpn, 2761 sizeof (wwn_t)); 2762 if (erp_action->step == ZFCP_ERP_STEP_NAMESERVER_OPEN) { 2763 debug_text_event(adapter->erp_dbf, 3, "p_pstnsw_w"); 2764 debug_event(adapter->erp_dbf, 3, 2765 &erp_action->port->wwpn, sizeof (wwn_t)); 2766 if (atomic_test_mask( 2767 ZFCP_STATUS_COMMON_ERP_FAILED, 2768 &adapter->nameserver_port->status)) 2769 zfcp_erp_port_failed(erp_action->port); 2770 zfcp_erp_action_ready(erp_action); 2771 } 2772 } 2773 read_unlock_irqrestore(&adapter->erp_lock, flags); 2774 2775 return retval; 2776 } 2777 2778 /* 2779 * function: 2780 * 2781 * purpose: 2782 * 2783 * returns: ZFCP_ERP_CONTINUES - action continues (asynchronously) 2784 * ZFCP_ERP_FAILED - action finished unsuccessfully 2785 */ 2786 static int 2787 zfcp_erp_port_forced_strategy_close(struct zfcp_erp_action *erp_action) 2788 { 2789 int retval; 2790 struct zfcp_adapter *adapter = erp_action->adapter; 2791 struct zfcp_port *port = erp_action->port; 2792 2793 zfcp_erp_timeout_init(erp_action); 2794 retval = zfcp_fsf_close_physical_port(erp_action); 2795 if (retval == -ENOMEM) { 2796 debug_text_event(adapter->erp_dbf, 5, "o_pfstc_nomem"); 2797 debug_event(adapter->erp_dbf, 5, &port->wwpn, sizeof (wwn_t)); 2798 retval = ZFCP_ERP_NOMEM; 2799 goto out; 2800 } 2801 erp_action->step = ZFCP_ERP_STEP_PHYS_PORT_CLOSING; 2802 if (retval != 0) { 2803 debug_text_event(adapter->erp_dbf, 5, "o_pfstc_cpf"); 2804 debug_event(adapter->erp_dbf, 5, &port->wwpn, sizeof (wwn_t)); 2805 /* could not send 'open', fail */ 2806 retval = ZFCP_ERP_FAILED; 2807 goto out; 2808 } 2809 debug_text_event(adapter->erp_dbf, 6, "o_pfstc_cpok"); 2810 debug_event(adapter->erp_dbf, 6, &port->wwpn, sizeof (wwn_t)); 2811 retval = ZFCP_ERP_CONTINUES; 2812 out: 2813 return retval; 2814 } 2815 2816 /* 2817 * function: 2818 * 2819 * purpose: 2820 * 2821 * returns: 2822 */ 2823 static int 2824 zfcp_erp_port_strategy_clearstati(struct zfcp_port *port) 2825 { 2826 int retval = 0; 2827 struct zfcp_adapter *adapter = port->adapter; 2828 2829 debug_text_event(adapter->erp_dbf, 5, "p_pstclst"); 2830 debug_event(adapter->erp_dbf, 5, &port->wwpn, sizeof (wwn_t)); 2831 2832 atomic_clear_mask(ZFCP_STATUS_COMMON_OPENING | 2833 ZFCP_STATUS_COMMON_CLOSING | 2834 ZFCP_STATUS_COMMON_ACCESS_DENIED | 2835 ZFCP_STATUS_PORT_DID_DID | 2836 ZFCP_STATUS_PORT_PHYS_CLOSING | 2837 ZFCP_STATUS_PORT_INVALID_WWPN, 2838 &port->status); 2839 return retval; 2840 } 2841 2842 /* 2843 * function: 2844 * 2845 * purpose: 2846 * 2847 * returns: ZFCP_ERP_CONTINUES - action continues (asynchronously) 2848 * ZFCP_ERP_FAILED - action finished unsuccessfully 2849 */ 2850 static int 2851 zfcp_erp_port_strategy_close(struct zfcp_erp_action *erp_action) 2852 { 2853 int retval; 2854 struct zfcp_adapter *adapter = erp_action->adapter; 2855 struct zfcp_port *port = erp_action->port; 2856 2857 zfcp_erp_timeout_init(erp_action); 2858 retval = zfcp_fsf_close_port(erp_action); 2859 if (retval == -ENOMEM) { 2860 debug_text_event(adapter->erp_dbf, 5, "p_pstc_nomem"); 2861 debug_event(adapter->erp_dbf, 5, &port->wwpn, sizeof (wwn_t)); 2862 retval = ZFCP_ERP_NOMEM; 2863 goto out; 2864 } 2865 erp_action->step = ZFCP_ERP_STEP_PORT_CLOSING; 2866 if (retval != 0) { 2867 debug_text_event(adapter->erp_dbf, 5, "p_pstc_cpf"); 2868 debug_event(adapter->erp_dbf, 5, &port->wwpn, sizeof (wwn_t)); 2869 /* could not send 'close', fail */ 2870 retval = ZFCP_ERP_FAILED; 2871 goto out; 2872 } 2873 debug_text_event(adapter->erp_dbf, 6, "p_pstc_cpok"); 2874 debug_event(adapter->erp_dbf, 6, &port->wwpn, sizeof (wwn_t)); 2875 retval = ZFCP_ERP_CONTINUES; 2876 out: 2877 return retval; 2878 } 2879 2880 /* 2881 * function: 2882 * 2883 * purpose: 2884 * 2885 * returns: ZFCP_ERP_CONTINUES - action continues (asynchronously) 2886 * ZFCP_ERP_FAILED - action finished unsuccessfully 2887 */ 2888 static int 2889 zfcp_erp_port_strategy_open_port(struct zfcp_erp_action *erp_action) 2890 { 2891 int retval; 2892 struct zfcp_adapter *adapter = erp_action->adapter; 2893 struct zfcp_port *port = erp_action->port; 2894 2895 zfcp_erp_timeout_init(erp_action); 2896 retval = zfcp_fsf_open_port(erp_action); 2897 if (retval == -ENOMEM) { 2898 debug_text_event(adapter->erp_dbf, 5, "p_psto_nomem"); 2899 debug_event(adapter->erp_dbf, 5, &port->wwpn, sizeof (wwn_t)); 2900 retval = ZFCP_ERP_NOMEM; 2901 goto out; 2902 } 2903 erp_action->step = ZFCP_ERP_STEP_PORT_OPENING; 2904 if (retval != 0) { 2905 debug_text_event(adapter->erp_dbf, 5, "p_psto_opf"); 2906 debug_event(adapter->erp_dbf, 5, &port->wwpn, sizeof (wwn_t)); 2907 /* could not send 'open', fail */ 2908 retval = ZFCP_ERP_FAILED; 2909 goto out; 2910 } 2911 debug_text_event(adapter->erp_dbf, 6, "p_psto_opok"); 2912 debug_event(adapter->erp_dbf, 6, &port->wwpn, sizeof (wwn_t)); 2913 retval = ZFCP_ERP_CONTINUES; 2914 out: 2915 return retval; 2916 } 2917 2918 /* 2919 * function: 2920 * 2921 * purpose: 2922 * 2923 * returns: ZFCP_ERP_CONTINUES - action continues (asynchronously) 2924 * ZFCP_ERP_FAILED - action finished unsuccessfully 2925 */ 2926 static int 2927 zfcp_erp_port_strategy_open_common_lookup(struct zfcp_erp_action *erp_action) 2928 { 2929 int retval; 2930 struct zfcp_adapter *adapter = erp_action->adapter; 2931 struct zfcp_port *port = erp_action->port; 2932 2933 zfcp_erp_timeout_init(erp_action); 2934 retval = zfcp_ns_gid_pn_request(erp_action); 2935 if (retval == -ENOMEM) { 2936 debug_text_event(adapter->erp_dbf, 5, "p_pstn_nomem"); 2937 debug_event(adapter->erp_dbf, 5, &port->wwpn, sizeof (wwn_t)); 2938 retval = ZFCP_ERP_NOMEM; 2939 goto out; 2940 } 2941 erp_action->step = ZFCP_ERP_STEP_NAMESERVER_LOOKUP; 2942 if (retval != 0) { 2943 debug_text_event(adapter->erp_dbf, 5, "p_pstn_ref"); 2944 debug_event(adapter->erp_dbf, 5, &port->wwpn, sizeof (wwn_t)); 2945 /* could not send nameserver request, fail */ 2946 retval = ZFCP_ERP_FAILED; 2947 goto out; 2948 } 2949 debug_text_event(adapter->erp_dbf, 6, "p_pstn_reok"); 2950 debug_event(adapter->erp_dbf, 6, &port->wwpn, sizeof (wwn_t)); 2951 retval = ZFCP_ERP_CONTINUES; 2952 out: 2953 return retval; 2954 } 2955 2956 /* 2957 * function: 2958 * 2959 * purpose: this routine executes the 'Reopen Unit' action 2960 * currently no retries 2961 * 2962 * returns: ZFCP_ERP_CONTINUES - action continues (asynchronously) 2963 * ZFCP_ERP_SUCCEEDED - action finished successfully 2964 * ZFCP_ERP_FAILED - action finished unsuccessfully 2965 */ 2966 static int 2967 zfcp_erp_unit_strategy(struct zfcp_erp_action *erp_action) 2968 { 2969 int retval = ZFCP_ERP_FAILED; 2970 struct zfcp_unit *unit = erp_action->unit; 2971 struct zfcp_adapter *adapter = erp_action->adapter; 2972 2973 switch (erp_action->step) { 2974 2975 /* 2976 * FIXME: 2977 * the ULP spec. begs for waiting for oustanding commands 2978 */ 2979 case ZFCP_ERP_STEP_UNINITIALIZED: 2980 zfcp_erp_unit_strategy_clearstati(unit); 2981 if (atomic_test_mask(ZFCP_STATUS_COMMON_OPEN, &unit->status)) { 2982 ZFCP_LOG_DEBUG("unit 0x%016Lx is open -> " 2983 "trying close\n", unit->fcp_lun); 2984 retval = zfcp_erp_unit_strategy_close(erp_action); 2985 break; 2986 } 2987 /* else it's already closed, fall through */ 2988 case ZFCP_ERP_STEP_UNIT_CLOSING: 2989 if (atomic_test_mask(ZFCP_STATUS_COMMON_OPEN, &unit->status)) { 2990 ZFCP_LOG_DEBUG("close failed for unit 0x%016Lx\n", 2991 unit->fcp_lun); 2992 retval = ZFCP_ERP_FAILED; 2993 } else { 2994 if (erp_action->status & ZFCP_STATUS_ERP_CLOSE_ONLY) 2995 retval = ZFCP_ERP_EXIT; 2996 else { 2997 ZFCP_LOG_DEBUG("unit 0x%016Lx is not open -> " 2998 "trying open\n", unit->fcp_lun); 2999 retval = 3000 zfcp_erp_unit_strategy_open(erp_action); 3001 } 3002 } 3003 break; 3004 3005 case ZFCP_ERP_STEP_UNIT_OPENING: 3006 if (atomic_test_mask(ZFCP_STATUS_COMMON_OPEN, &unit->status)) { 3007 ZFCP_LOG_DEBUG("unit 0x%016Lx is open\n", 3008 unit->fcp_lun); 3009 retval = ZFCP_ERP_SUCCEEDED; 3010 } else { 3011 ZFCP_LOG_DEBUG("open failed for unit 0x%016Lx\n", 3012 unit->fcp_lun); 3013 retval = ZFCP_ERP_FAILED; 3014 } 3015 break; 3016 } 3017 3018 debug_text_event(adapter->erp_dbf, 3, "u_ust/ret"); 3019 debug_event(adapter->erp_dbf, 3, &unit->fcp_lun, sizeof (fcp_lun_t)); 3020 debug_event(adapter->erp_dbf, 3, &erp_action->action, sizeof (int)); 3021 debug_event(adapter->erp_dbf, 3, &retval, sizeof (int)); 3022 return retval; 3023 } 3024 3025 /* 3026 * function: 3027 * 3028 * purpose: 3029 * 3030 * returns: 3031 */ 3032 static int 3033 zfcp_erp_unit_strategy_clearstati(struct zfcp_unit *unit) 3034 { 3035 int retval = 0; 3036 struct zfcp_adapter *adapter = unit->port->adapter; 3037 3038 debug_text_event(adapter->erp_dbf, 5, "u_ustclst"); 3039 debug_event(adapter->erp_dbf, 5, &unit->fcp_lun, sizeof (fcp_lun_t)); 3040 3041 atomic_clear_mask(ZFCP_STATUS_COMMON_OPENING | 3042 ZFCP_STATUS_COMMON_CLOSING | 3043 ZFCP_STATUS_COMMON_ACCESS_DENIED | 3044 ZFCP_STATUS_UNIT_SHARED | 3045 ZFCP_STATUS_UNIT_READONLY, 3046 &unit->status); 3047 3048 return retval; 3049 } 3050 3051 /* 3052 * function: 3053 * 3054 * purpose: 3055 * 3056 * returns: ZFCP_ERP_CONTINUES - action continues (asynchronously) 3057 * ZFCP_ERP_FAILED - action finished unsuccessfully 3058 */ 3059 static int 3060 zfcp_erp_unit_strategy_close(struct zfcp_erp_action *erp_action) 3061 { 3062 int retval; 3063 struct zfcp_adapter *adapter = erp_action->adapter; 3064 struct zfcp_unit *unit = erp_action->unit; 3065 3066 zfcp_erp_timeout_init(erp_action); 3067 retval = zfcp_fsf_close_unit(erp_action); 3068 if (retval == -ENOMEM) { 3069 debug_text_event(adapter->erp_dbf, 5, "u_ustc_nomem"); 3070 debug_event(adapter->erp_dbf, 5, &unit->fcp_lun, 3071 sizeof (fcp_lun_t)); 3072 retval = ZFCP_ERP_NOMEM; 3073 goto out; 3074 } 3075 erp_action->step = ZFCP_ERP_STEP_UNIT_CLOSING; 3076 if (retval != 0) { 3077 debug_text_event(adapter->erp_dbf, 5, "u_ustc_cuf"); 3078 debug_event(adapter->erp_dbf, 5, &unit->fcp_lun, 3079 sizeof (fcp_lun_t)); 3080 /* could not send 'close', fail */ 3081 retval = ZFCP_ERP_FAILED; 3082 goto out; 3083 } 3084 debug_text_event(adapter->erp_dbf, 6, "u_ustc_cuok"); 3085 debug_event(adapter->erp_dbf, 6, &unit->fcp_lun, sizeof (fcp_lun_t)); 3086 retval = ZFCP_ERP_CONTINUES; 3087 3088 out: 3089 return retval; 3090 } 3091 3092 /* 3093 * function: 3094 * 3095 * purpose: 3096 * 3097 * returns: ZFCP_ERP_CONTINUES - action continues (asynchronously) 3098 * ZFCP_ERP_FAILED - action finished unsuccessfully 3099 */ 3100 static int 3101 zfcp_erp_unit_strategy_open(struct zfcp_erp_action *erp_action) 3102 { 3103 int retval; 3104 struct zfcp_adapter *adapter = erp_action->adapter; 3105 struct zfcp_unit *unit = erp_action->unit; 3106 3107 zfcp_erp_timeout_init(erp_action); 3108 retval = zfcp_fsf_open_unit(erp_action); 3109 if (retval == -ENOMEM) { 3110 debug_text_event(adapter->erp_dbf, 5, "u_usto_nomem"); 3111 debug_event(adapter->erp_dbf, 5, &unit->fcp_lun, 3112 sizeof (fcp_lun_t)); 3113 retval = ZFCP_ERP_NOMEM; 3114 goto out; 3115 } 3116 erp_action->step = ZFCP_ERP_STEP_UNIT_OPENING; 3117 if (retval != 0) { 3118 debug_text_event(adapter->erp_dbf, 5, "u_usto_ouf"); 3119 debug_event(adapter->erp_dbf, 5, &unit->fcp_lun, 3120 sizeof (fcp_lun_t)); 3121 /* could not send 'open', fail */ 3122 retval = ZFCP_ERP_FAILED; 3123 goto out; 3124 } 3125 debug_text_event(adapter->erp_dbf, 6, "u_usto_ouok"); 3126 debug_event(adapter->erp_dbf, 6, &unit->fcp_lun, sizeof (fcp_lun_t)); 3127 retval = ZFCP_ERP_CONTINUES; 3128 out: 3129 return retval; 3130 } 3131 3132 /* 3133 * function: 3134 * 3135 * purpose: 3136 * 3137 * returns: 3138 */ 3139 static inline void 3140 zfcp_erp_timeout_init(struct zfcp_erp_action *erp_action) 3141 { 3142 init_timer(&erp_action->timer); 3143 erp_action->timer.function = zfcp_erp_timeout_handler; 3144 erp_action->timer.data = (unsigned long) erp_action; 3145 /* jiffies will be added in zfcp_fsf_req_send */ 3146 erp_action->timer.expires = ZFCP_ERP_FSFREQ_TIMEOUT; 3147 } 3148 3149 /* 3150 * function: 3151 * 3152 * purpose: enqueue the specified error recovery action, if needed 3153 * 3154 * returns: 3155 */ 3156 static int 3157 zfcp_erp_action_enqueue(int action, 3158 struct zfcp_adapter *adapter, 3159 struct zfcp_port *port, struct zfcp_unit *unit) 3160 { 3161 int retval = 1; 3162 struct zfcp_erp_action *erp_action = NULL; 3163 int stronger_action = 0; 3164 u32 status = 0; 3165 3166 /* 3167 * We need some rules here which check whether we really need 3168 * this action or whether we should just drop it. 3169 * E.g. if there is a unfinished 'Reopen Port' request then we drop a 3170 * 'Reopen Unit' request for an associated unit since we can't 3171 * satisfy this request now. A 'Reopen Port' action will trigger 3172 * 'Reopen Unit' actions when it completes. 3173 * Thus, there are only actions in the queue which can immediately be 3174 * executed. This makes the processing of the action queue more 3175 * efficient. 3176 */ 3177 3178 if (!atomic_test_mask(ZFCP_STATUS_ADAPTER_ERP_THREAD_UP, 3179 &adapter->status)) 3180 return -EIO; 3181 3182 debug_event(adapter->erp_dbf, 4, &action, sizeof (int)); 3183 /* check whether we really need this */ 3184 switch (action) { 3185 case ZFCP_ERP_ACTION_REOPEN_UNIT: 3186 if (atomic_test_mask 3187 (ZFCP_STATUS_COMMON_ERP_INUSE, &unit->status)) { 3188 debug_text_event(adapter->erp_dbf, 4, "u_actenq_drp"); 3189 debug_event(adapter->erp_dbf, 4, &port->wwpn, 3190 sizeof (wwn_t)); 3191 debug_event(adapter->erp_dbf, 4, &unit->fcp_lun, 3192 sizeof (fcp_lun_t)); 3193 goto out; 3194 } 3195 if (!atomic_test_mask 3196 (ZFCP_STATUS_COMMON_RUNNING, &port->status) || 3197 atomic_test_mask 3198 (ZFCP_STATUS_COMMON_ERP_FAILED, &port->status)) { 3199 goto out; 3200 } 3201 if (!atomic_test_mask 3202 (ZFCP_STATUS_COMMON_UNBLOCKED, &port->status)) { 3203 stronger_action = ZFCP_ERP_ACTION_REOPEN_PORT; 3204 unit = NULL; 3205 } 3206 /* fall through !!! */ 3207 3208 case ZFCP_ERP_ACTION_REOPEN_PORT: 3209 if (atomic_test_mask 3210 (ZFCP_STATUS_COMMON_ERP_INUSE, &port->status)) { 3211 debug_text_event(adapter->erp_dbf, 4, "p_actenq_drp"); 3212 debug_event(adapter->erp_dbf, 4, &port->wwpn, 3213 sizeof (wwn_t)); 3214 goto out; 3215 } 3216 /* fall through !!! */ 3217 3218 case ZFCP_ERP_ACTION_REOPEN_PORT_FORCED: 3219 if (atomic_test_mask(ZFCP_STATUS_COMMON_ERP_INUSE, 3220 &port->status)) { 3221 if (port->erp_action.action != 3222 ZFCP_ERP_ACTION_REOPEN_PORT_FORCED) { 3223 ZFCP_LOG_INFO("dropped erp action %i (port " 3224 "0x%016Lx, action in use: %i)\n", 3225 action, port->wwpn, 3226 port->erp_action.action); 3227 debug_text_event(adapter->erp_dbf, 4, 3228 "pf_actenq_drp"); 3229 } else 3230 debug_text_event(adapter->erp_dbf, 4, 3231 "pf_actenq_drpcp"); 3232 debug_event(adapter->erp_dbf, 4, &port->wwpn, 3233 sizeof (wwn_t)); 3234 goto out; 3235 } 3236 if (!atomic_test_mask 3237 (ZFCP_STATUS_COMMON_RUNNING, &adapter->status) || 3238 atomic_test_mask 3239 (ZFCP_STATUS_COMMON_ERP_FAILED, &adapter->status)) { 3240 goto out; 3241 } 3242 if (!atomic_test_mask 3243 (ZFCP_STATUS_COMMON_UNBLOCKED, &adapter->status)) { 3244 stronger_action = ZFCP_ERP_ACTION_REOPEN_ADAPTER; 3245 port = NULL; 3246 } 3247 /* fall through !!! */ 3248 3249 case ZFCP_ERP_ACTION_REOPEN_ADAPTER: 3250 if (atomic_test_mask 3251 (ZFCP_STATUS_COMMON_ERP_INUSE, &adapter->status)) { 3252 debug_text_event(adapter->erp_dbf, 4, "a_actenq_drp"); 3253 goto out; 3254 } 3255 break; 3256 3257 default: 3258 debug_text_exception(adapter->erp_dbf, 1, "a_actenq_bug"); 3259 debug_event(adapter->erp_dbf, 1, &action, sizeof (int)); 3260 ZFCP_LOG_NORMAL("bug: unknown erp action requested " 3261 "on adapter %s (action=%d)\n", 3262 zfcp_get_busid_by_adapter(adapter), action); 3263 goto out; 3264 } 3265 3266 /* check whether we need something stronger first */ 3267 if (stronger_action) { 3268 debug_text_event(adapter->erp_dbf, 4, "a_actenq_str"); 3269 debug_event(adapter->erp_dbf, 4, &stronger_action, 3270 sizeof (int)); 3271 ZFCP_LOG_DEBUG("stronger erp action %d needed before " 3272 "erp action %d on adapter %s\n", 3273 stronger_action, action, 3274 zfcp_get_busid_by_adapter(adapter)); 3275 action = stronger_action; 3276 } 3277 3278 /* mark adapter to have some error recovery pending */ 3279 atomic_set_mask(ZFCP_STATUS_ADAPTER_ERP_PENDING, &adapter->status); 3280 3281 /* setup error recovery action */ 3282 switch (action) { 3283 3284 case ZFCP_ERP_ACTION_REOPEN_UNIT: 3285 zfcp_unit_get(unit); 3286 atomic_set_mask(ZFCP_STATUS_COMMON_ERP_INUSE, &unit->status); 3287 erp_action = &unit->erp_action; 3288 if (!atomic_test_mask 3289 (ZFCP_STATUS_COMMON_RUNNING, &unit->status)) 3290 status = ZFCP_STATUS_ERP_CLOSE_ONLY; 3291 break; 3292 3293 case ZFCP_ERP_ACTION_REOPEN_PORT: 3294 case ZFCP_ERP_ACTION_REOPEN_PORT_FORCED: 3295 zfcp_port_get(port); 3296 zfcp_erp_action_dismiss_port(port); 3297 atomic_set_mask(ZFCP_STATUS_COMMON_ERP_INUSE, &port->status); 3298 erp_action = &port->erp_action; 3299 if (!atomic_test_mask 3300 (ZFCP_STATUS_COMMON_RUNNING, &port->status)) 3301 status = ZFCP_STATUS_ERP_CLOSE_ONLY; 3302 break; 3303 3304 case ZFCP_ERP_ACTION_REOPEN_ADAPTER: 3305 zfcp_adapter_get(adapter); 3306 zfcp_erp_action_dismiss_adapter(adapter); 3307 atomic_set_mask(ZFCP_STATUS_COMMON_ERP_INUSE, &adapter->status); 3308 erp_action = &adapter->erp_action; 3309 if (!atomic_test_mask 3310 (ZFCP_STATUS_COMMON_RUNNING, &adapter->status)) 3311 status = ZFCP_STATUS_ERP_CLOSE_ONLY; 3312 break; 3313 } 3314 3315 debug_text_event(adapter->erp_dbf, 4, "a_actenq"); 3316 3317 memset(erp_action, 0, sizeof (struct zfcp_erp_action)); 3318 erp_action->adapter = adapter; 3319 erp_action->port = port; 3320 erp_action->unit = unit; 3321 erp_action->action = action; 3322 erp_action->status = status; 3323 3324 ++adapter->erp_total_count; 3325 3326 /* finally put it into 'ready' queue and kick erp thread */ 3327 list_add(&erp_action->list, &adapter->erp_ready_head); 3328 up(&adapter->erp_ready_sem); 3329 retval = 0; 3330 out: 3331 return retval; 3332 } 3333 3334 /* 3335 * function: 3336 * 3337 * purpose: 3338 * 3339 * returns: 3340 */ 3341 static int 3342 zfcp_erp_action_dequeue(struct zfcp_erp_action *erp_action) 3343 { 3344 int retval = 0; 3345 struct zfcp_adapter *adapter = erp_action->adapter; 3346 3347 --adapter->erp_total_count; 3348 if (erp_action->status & ZFCP_STATUS_ERP_LOWMEM) { 3349 --adapter->erp_low_mem_count; 3350 erp_action->status &= ~ZFCP_STATUS_ERP_LOWMEM; 3351 } 3352 3353 debug_text_event(adapter->erp_dbf, 4, "a_actdeq"); 3354 debug_event(adapter->erp_dbf, 4, &erp_action->action, sizeof (int)); 3355 list_del(&erp_action->list); 3356 switch (erp_action->action) { 3357 case ZFCP_ERP_ACTION_REOPEN_UNIT: 3358 atomic_clear_mask(ZFCP_STATUS_COMMON_ERP_INUSE, 3359 &erp_action->unit->status); 3360 break; 3361 case ZFCP_ERP_ACTION_REOPEN_PORT_FORCED: 3362 case ZFCP_ERP_ACTION_REOPEN_PORT: 3363 atomic_clear_mask(ZFCP_STATUS_COMMON_ERP_INUSE, 3364 &erp_action->port->status); 3365 break; 3366 case ZFCP_ERP_ACTION_REOPEN_ADAPTER: 3367 atomic_clear_mask(ZFCP_STATUS_COMMON_ERP_INUSE, 3368 &erp_action->adapter->status); 3369 break; 3370 default: 3371 /* bug */ 3372 break; 3373 } 3374 return retval; 3375 } 3376 3377 /** 3378 * zfcp_erp_action_cleanup 3379 * 3380 * Register unit with scsi stack if appropriate and fix reference counts. 3381 * Note: Temporary units are not registered with scsi stack. 3382 */ 3383 static void 3384 zfcp_erp_action_cleanup(int action, struct zfcp_adapter *adapter, 3385 struct zfcp_port *port, struct zfcp_unit *unit, 3386 int result) 3387 { 3388 switch (action) { 3389 case ZFCP_ERP_ACTION_REOPEN_UNIT: 3390 if ((result == ZFCP_ERP_SUCCEEDED) 3391 && (!atomic_test_mask(ZFCP_STATUS_UNIT_TEMPORARY, 3392 &unit->status)) 3393 && !unit->device 3394 && port->rport) { 3395 atomic_set_mask(ZFCP_STATUS_UNIT_REGISTERED, 3396 &unit->status); 3397 scsi_scan_target(&port->rport->dev, 0, 3398 port->rport->scsi_target_id, 3399 unit->scsi_lun, 0); 3400 } 3401 zfcp_unit_put(unit); 3402 break; 3403 case ZFCP_ERP_ACTION_REOPEN_PORT_FORCED: 3404 case ZFCP_ERP_ACTION_REOPEN_PORT: 3405 if ((result == ZFCP_ERP_SUCCEEDED) 3406 && !atomic_test_mask(ZFCP_STATUS_PORT_NO_WWPN, 3407 &port->status) 3408 && !port->rport) { 3409 struct fc_rport_identifiers ids; 3410 ids.node_name = port->wwnn; 3411 ids.port_name = port->wwpn; 3412 ids.port_id = port->d_id; 3413 ids.roles = FC_RPORT_ROLE_FCP_TARGET; 3414 port->rport = 3415 fc_remote_port_add(adapter->scsi_host, 0, &ids); 3416 if (!port->rport) 3417 ZFCP_LOG_NORMAL("failed registration of rport" 3418 "(adapter %s, wwpn=0x%016Lx)\n", 3419 zfcp_get_busid_by_port(port), 3420 port->wwpn); 3421 else 3422 scsi_flush_work(adapter->scsi_host); 3423 } 3424 zfcp_port_put(port); 3425 break; 3426 case ZFCP_ERP_ACTION_REOPEN_ADAPTER: 3427 zfcp_adapter_put(adapter); 3428 break; 3429 default: 3430 break; 3431 } 3432 } 3433 3434 3435 /* 3436 * function: 3437 * 3438 * purpose: 3439 * 3440 * returns: FIXME 3441 */ 3442 static int 3443 zfcp_erp_action_dismiss_adapter(struct zfcp_adapter *adapter) 3444 { 3445 int retval = 0; 3446 struct zfcp_port *port; 3447 3448 debug_text_event(adapter->erp_dbf, 5, "a_actab"); 3449 if (atomic_test_mask(ZFCP_STATUS_COMMON_ERP_INUSE, &adapter->status)) 3450 zfcp_erp_action_dismiss(&adapter->erp_action); 3451 else 3452 list_for_each_entry(port, &adapter->port_list_head, list) 3453 zfcp_erp_action_dismiss_port(port); 3454 3455 return retval; 3456 } 3457 3458 /* 3459 * function: 3460 * 3461 * purpose: 3462 * 3463 * returns: FIXME 3464 */ 3465 static int 3466 zfcp_erp_action_dismiss_port(struct zfcp_port *port) 3467 { 3468 int retval = 0; 3469 struct zfcp_unit *unit; 3470 struct zfcp_adapter *adapter = port->adapter; 3471 3472 debug_text_event(adapter->erp_dbf, 5, "p_actab"); 3473 debug_event(adapter->erp_dbf, 5, &port->wwpn, sizeof (wwn_t)); 3474 if (atomic_test_mask(ZFCP_STATUS_COMMON_ERP_INUSE, &port->status)) 3475 zfcp_erp_action_dismiss(&port->erp_action); 3476 else 3477 list_for_each_entry(unit, &port->unit_list_head, list) 3478 zfcp_erp_action_dismiss_unit(unit); 3479 3480 return retval; 3481 } 3482 3483 /* 3484 * function: 3485 * 3486 * purpose: 3487 * 3488 * returns: FIXME 3489 */ 3490 static int 3491 zfcp_erp_action_dismiss_unit(struct zfcp_unit *unit) 3492 { 3493 int retval = 0; 3494 struct zfcp_adapter *adapter = unit->port->adapter; 3495 3496 debug_text_event(adapter->erp_dbf, 5, "u_actab"); 3497 debug_event(adapter->erp_dbf, 5, &unit->fcp_lun, sizeof (fcp_lun_t)); 3498 if (atomic_test_mask(ZFCP_STATUS_COMMON_ERP_INUSE, &unit->status)) 3499 zfcp_erp_action_dismiss(&unit->erp_action); 3500 3501 return retval; 3502 } 3503 3504 /* 3505 * function: 3506 * 3507 * purpose: moves erp_action to 'erp running list' 3508 * 3509 * returns: 3510 */ 3511 static inline void 3512 zfcp_erp_action_to_running(struct zfcp_erp_action *erp_action) 3513 { 3514 struct zfcp_adapter *adapter = erp_action->adapter; 3515 3516 debug_text_event(adapter->erp_dbf, 6, "a_toru"); 3517 debug_event(adapter->erp_dbf, 6, &erp_action->action, sizeof (int)); 3518 list_move(&erp_action->list, &erp_action->adapter->erp_running_head); 3519 } 3520 3521 /* 3522 * function: 3523 * 3524 * purpose: moves erp_action to 'erp ready list' 3525 * 3526 * returns: 3527 */ 3528 static inline void 3529 zfcp_erp_action_to_ready(struct zfcp_erp_action *erp_action) 3530 { 3531 struct zfcp_adapter *adapter = erp_action->adapter; 3532 3533 debug_text_event(adapter->erp_dbf, 6, "a_tore"); 3534 debug_event(adapter->erp_dbf, 6, &erp_action->action, sizeof (int)); 3535 list_move(&erp_action->list, &erp_action->adapter->erp_ready_head); 3536 } 3537 3538 /* 3539 * function: zfcp_erp_port_boxed 3540 * 3541 * purpose: 3542 */ 3543 void 3544 zfcp_erp_port_boxed(struct zfcp_port *port) 3545 { 3546 struct zfcp_adapter *adapter = port->adapter; 3547 unsigned long flags; 3548 3549 debug_text_event(adapter->erp_dbf, 3, "p_access_boxed"); 3550 debug_event(adapter->erp_dbf, 3, &port->wwpn, sizeof(wwn_t)); 3551 read_lock_irqsave(&zfcp_data.config_lock, flags); 3552 zfcp_erp_modify_port_status(port, 3553 ZFCP_STATUS_COMMON_ACCESS_BOXED, 3554 ZFCP_SET); 3555 read_unlock_irqrestore(&zfcp_data.config_lock, flags); 3556 zfcp_erp_port_reopen(port, ZFCP_STATUS_COMMON_ERP_FAILED); 3557 } 3558 3559 /* 3560 * function: zfcp_erp_unit_boxed 3561 * 3562 * purpose: 3563 */ 3564 void 3565 zfcp_erp_unit_boxed(struct zfcp_unit *unit) 3566 { 3567 struct zfcp_adapter *adapter = unit->port->adapter; 3568 3569 debug_text_event(adapter->erp_dbf, 3, "u_access_boxed"); 3570 debug_event(adapter->erp_dbf, 3, &unit->fcp_lun, sizeof(fcp_lun_t)); 3571 zfcp_erp_modify_unit_status(unit, 3572 ZFCP_STATUS_COMMON_ACCESS_BOXED, 3573 ZFCP_SET); 3574 zfcp_erp_unit_reopen(unit, ZFCP_STATUS_COMMON_ERP_FAILED); 3575 } 3576 3577 /* 3578 * function: zfcp_erp_port_access_denied 3579 * 3580 * purpose: 3581 */ 3582 void 3583 zfcp_erp_port_access_denied(struct zfcp_port *port) 3584 { 3585 struct zfcp_adapter *adapter = port->adapter; 3586 unsigned long flags; 3587 3588 debug_text_event(adapter->erp_dbf, 3, "p_access_denied"); 3589 debug_event(adapter->erp_dbf, 3, &port->wwpn, sizeof(wwn_t)); 3590 read_lock_irqsave(&zfcp_data.config_lock, flags); 3591 zfcp_erp_modify_port_status(port, 3592 ZFCP_STATUS_COMMON_ERP_FAILED | 3593 ZFCP_STATUS_COMMON_ACCESS_DENIED, 3594 ZFCP_SET); 3595 read_unlock_irqrestore(&zfcp_data.config_lock, flags); 3596 } 3597 3598 /* 3599 * function: zfcp_erp_unit_access_denied 3600 * 3601 * purpose: 3602 */ 3603 void 3604 zfcp_erp_unit_access_denied(struct zfcp_unit *unit) 3605 { 3606 struct zfcp_adapter *adapter = unit->port->adapter; 3607 3608 debug_text_event(adapter->erp_dbf, 3, "u_access_denied"); 3609 debug_event(adapter->erp_dbf, 3, &unit->fcp_lun, sizeof(fcp_lun_t)); 3610 zfcp_erp_modify_unit_status(unit, 3611 ZFCP_STATUS_COMMON_ERP_FAILED | 3612 ZFCP_STATUS_COMMON_ACCESS_DENIED, 3613 ZFCP_SET); 3614 } 3615 3616 /* 3617 * function: zfcp_erp_adapter_access_changed 3618 * 3619 * purpose: 3620 */ 3621 void 3622 zfcp_erp_adapter_access_changed(struct zfcp_adapter *adapter) 3623 { 3624 struct zfcp_port *port; 3625 unsigned long flags; 3626 3627 if (adapter->connection_features & FSF_FEATURE_NPIV_MODE) 3628 return; 3629 3630 debug_text_event(adapter->erp_dbf, 3, "a_access_recover"); 3631 debug_event(adapter->erp_dbf, 3, &adapter->name, 8); 3632 3633 read_lock_irqsave(&zfcp_data.config_lock, flags); 3634 if (adapter->nameserver_port) 3635 zfcp_erp_port_access_changed(adapter->nameserver_port); 3636 list_for_each_entry(port, &adapter->port_list_head, list) 3637 if (port != adapter->nameserver_port) 3638 zfcp_erp_port_access_changed(port); 3639 read_unlock_irqrestore(&zfcp_data.config_lock, flags); 3640 } 3641 3642 /* 3643 * function: zfcp_erp_port_access_changed 3644 * 3645 * purpose: 3646 */ 3647 void 3648 zfcp_erp_port_access_changed(struct zfcp_port *port) 3649 { 3650 struct zfcp_adapter *adapter = port->adapter; 3651 struct zfcp_unit *unit; 3652 3653 debug_text_event(adapter->erp_dbf, 3, "p_access_recover"); 3654 debug_event(adapter->erp_dbf, 3, &port->wwpn, sizeof(wwn_t)); 3655 3656 if (!atomic_test_mask(ZFCP_STATUS_COMMON_ACCESS_DENIED, 3657 &port->status) && 3658 !atomic_test_mask(ZFCP_STATUS_COMMON_ACCESS_BOXED, 3659 &port->status)) { 3660 if (!atomic_test_mask(ZFCP_STATUS_PORT_WKA, &port->status)) 3661 list_for_each_entry(unit, &port->unit_list_head, list) 3662 zfcp_erp_unit_access_changed(unit); 3663 return; 3664 } 3665 3666 ZFCP_LOG_NORMAL("reopen of port 0x%016Lx on adapter %s " 3667 "(due to ACT update)\n", 3668 port->wwpn, zfcp_get_busid_by_adapter(adapter)); 3669 if (zfcp_erp_port_reopen(port, ZFCP_STATUS_COMMON_ERP_FAILED) != 0) 3670 ZFCP_LOG_NORMAL("failed reopen of port" 3671 "(adapter %s, wwpn=0x%016Lx)\n", 3672 zfcp_get_busid_by_adapter(adapter), port->wwpn); 3673 } 3674 3675 /* 3676 * function: zfcp_erp_unit_access_changed 3677 * 3678 * purpose: 3679 */ 3680 void 3681 zfcp_erp_unit_access_changed(struct zfcp_unit *unit) 3682 { 3683 struct zfcp_adapter *adapter = unit->port->adapter; 3684 3685 debug_text_event(adapter->erp_dbf, 3, "u_access_recover"); 3686 debug_event(adapter->erp_dbf, 3, &unit->fcp_lun, sizeof(fcp_lun_t)); 3687 3688 if (!atomic_test_mask(ZFCP_STATUS_COMMON_ACCESS_DENIED, 3689 &unit->status) && 3690 !atomic_test_mask(ZFCP_STATUS_COMMON_ACCESS_BOXED, 3691 &unit->status)) 3692 return; 3693 3694 ZFCP_LOG_NORMAL("reopen of unit 0x%016Lx on port 0x%016Lx " 3695 " on adapter %s (due to ACT update)\n", 3696 unit->fcp_lun, unit->port->wwpn, 3697 zfcp_get_busid_by_adapter(adapter)); 3698 if (zfcp_erp_unit_reopen(unit, ZFCP_STATUS_COMMON_ERP_FAILED) != 0) 3699 ZFCP_LOG_NORMAL("failed reopen of unit (adapter %s, " 3700 "wwpn=0x%016Lx, fcp_lun=0x%016Lx)\n", 3701 zfcp_get_busid_by_adapter(adapter), 3702 unit->port->wwpn, unit->fcp_lun); 3703 } 3704 3705 #undef ZFCP_LOG_AREA 3706