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