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 rwlock_init(&adapter->erp_lock); 1075 INIT_LIST_HEAD(&adapter->erp_ready_head); 1076 INIT_LIST_HEAD(&adapter->erp_running_head); 1077 sema_init(&adapter->erp_ready_sem, 0); 1078 1079 retval = kernel_thread(zfcp_erp_thread, adapter, SIGCHLD); 1080 if (retval < 0) { 1081 ZFCP_LOG_NORMAL("error: creation of erp thread failed for " 1082 "adapter %s\n", 1083 zfcp_get_busid_by_adapter(adapter)); 1084 debug_text_event(adapter->erp_dbf, 5, "a_thset_fail"); 1085 } else { 1086 wait_event(adapter->erp_thread_wqh, 1087 atomic_test_mask(ZFCP_STATUS_ADAPTER_ERP_THREAD_UP, 1088 &adapter->status)); 1089 debug_text_event(adapter->erp_dbf, 5, "a_thset_ok"); 1090 } 1091 1092 return (retval < 0); 1093 } 1094 1095 /* 1096 * function: 1097 * 1098 * purpose: 1099 * 1100 * returns: 1101 * 1102 * context: process (i.e. proc-fs or rmmod/insmod) 1103 * 1104 * note: The caller of this routine ensures that the specified 1105 * adapter has been shut down and that this operation 1106 * has been completed. Thus, there are no pending erp_actions 1107 * which would need to be handled here. 1108 */ 1109 int 1110 zfcp_erp_thread_kill(struct zfcp_adapter *adapter) 1111 { 1112 int retval = 0; 1113 1114 atomic_set_mask(ZFCP_STATUS_ADAPTER_ERP_THREAD_KILL, &adapter->status); 1115 up(&adapter->erp_ready_sem); 1116 1117 wait_event(adapter->erp_thread_wqh, 1118 !atomic_test_mask(ZFCP_STATUS_ADAPTER_ERP_THREAD_UP, 1119 &adapter->status)); 1120 1121 atomic_clear_mask(ZFCP_STATUS_ADAPTER_ERP_THREAD_KILL, 1122 &adapter->status); 1123 1124 debug_text_event(adapter->erp_dbf, 5, "a_thki_ok"); 1125 1126 return retval; 1127 } 1128 1129 /* 1130 * purpose: is run as a kernel thread, 1131 * goes through list of error recovery actions of associated adapter 1132 * and delegates single action to execution 1133 * 1134 * returns: 0 1135 */ 1136 static int 1137 zfcp_erp_thread(void *data) 1138 { 1139 struct zfcp_adapter *adapter = (struct zfcp_adapter *) data; 1140 struct list_head *next; 1141 struct zfcp_erp_action *erp_action; 1142 unsigned long flags; 1143 1144 daemonize("zfcperp%s", zfcp_get_busid_by_adapter(adapter)); 1145 /* Block all signals */ 1146 siginitsetinv(¤t->blocked, 0); 1147 atomic_set_mask(ZFCP_STATUS_ADAPTER_ERP_THREAD_UP, &adapter->status); 1148 debug_text_event(adapter->erp_dbf, 5, "a_th_run"); 1149 wake_up(&adapter->erp_thread_wqh); 1150 1151 while (!atomic_test_mask(ZFCP_STATUS_ADAPTER_ERP_THREAD_KILL, 1152 &adapter->status)) { 1153 1154 write_lock_irqsave(&adapter->erp_lock, flags); 1155 next = adapter->erp_ready_head.prev; 1156 write_unlock_irqrestore(&adapter->erp_lock, flags); 1157 1158 if (next != &adapter->erp_ready_head) { 1159 erp_action = 1160 list_entry(next, struct zfcp_erp_action, list); 1161 /* 1162 * process action (incl. [re]moving it 1163 * from 'ready' queue) 1164 */ 1165 zfcp_erp_strategy(erp_action); 1166 } 1167 1168 /* 1169 * sleep as long as there is nothing to do, i.e. 1170 * no action in 'ready' queue to be processed and 1171 * thread is not to be killed 1172 */ 1173 down_interruptible(&adapter->erp_ready_sem); 1174 debug_text_event(adapter->erp_dbf, 5, "a_th_woken"); 1175 } 1176 1177 atomic_clear_mask(ZFCP_STATUS_ADAPTER_ERP_THREAD_UP, &adapter->status); 1178 debug_text_event(adapter->erp_dbf, 5, "a_th_stop"); 1179 wake_up(&adapter->erp_thread_wqh); 1180 1181 return 0; 1182 } 1183 1184 /* 1185 * function: 1186 * 1187 * purpose: drives single error recovery action and schedules higher and 1188 * subordinate actions, if necessary 1189 * 1190 * returns: ZFCP_ERP_CONTINUES - action continues (asynchronously) 1191 * ZFCP_ERP_SUCCEEDED - action finished successfully (deqd) 1192 * ZFCP_ERP_FAILED - action finished unsuccessfully (deqd) 1193 * ZFCP_ERP_EXIT - action finished (dequeued), offline 1194 * ZFCP_ERP_DISMISSED - action canceled (dequeued) 1195 */ 1196 static int 1197 zfcp_erp_strategy(struct zfcp_erp_action *erp_action) 1198 { 1199 int retval = 0; 1200 struct zfcp_adapter *adapter = erp_action->adapter; 1201 struct zfcp_port *port = erp_action->port; 1202 struct zfcp_unit *unit = erp_action->unit; 1203 int action = erp_action->action; 1204 u32 status = erp_action->status; 1205 unsigned long flags; 1206 1207 /* serialise dismissing, timing out, moving, enqueueing */ 1208 read_lock_irqsave(&zfcp_data.config_lock, flags); 1209 write_lock(&adapter->erp_lock); 1210 1211 /* dequeue dismissed action and leave, if required */ 1212 retval = zfcp_erp_strategy_check_action(erp_action, retval); 1213 if (retval == ZFCP_ERP_DISMISSED) { 1214 debug_text_event(adapter->erp_dbf, 4, "a_st_dis1"); 1215 goto unlock; 1216 } 1217 1218 /* 1219 * move action to 'running' queue before processing it 1220 * (to avoid a race condition regarding moving the 1221 * action to the 'running' queue and back) 1222 */ 1223 zfcp_erp_action_to_running(erp_action); 1224 1225 /* 1226 * try to process action as far as possible, 1227 * no lock to allow for blocking operations (kmalloc, qdio, ...), 1228 * afterwards the lock is required again for the following reasons: 1229 * - dequeueing of finished action and enqueueing of 1230 * follow-up actions must be atomic so that any other 1231 * reopen-routine does not believe there is nothing to do 1232 * and that it is safe to enqueue something else, 1233 * - we want to force any control thread which is dismissing 1234 * actions to finish this before we decide about 1235 * necessary steps to be taken here further 1236 */ 1237 write_unlock(&adapter->erp_lock); 1238 read_unlock_irqrestore(&zfcp_data.config_lock, flags); 1239 retval = zfcp_erp_strategy_do_action(erp_action); 1240 read_lock_irqsave(&zfcp_data.config_lock, flags); 1241 write_lock(&adapter->erp_lock); 1242 1243 /* 1244 * check for dismissed status again to avoid follow-up actions, 1245 * failing of targets and so on for dismissed actions 1246 */ 1247 retval = zfcp_erp_strategy_check_action(erp_action, retval); 1248 1249 switch (retval) { 1250 case ZFCP_ERP_DISMISSED: 1251 /* leave since this action has ridden to its ancestors */ 1252 debug_text_event(adapter->erp_dbf, 6, "a_st_dis2"); 1253 goto unlock; 1254 case ZFCP_ERP_NOMEM: 1255 /* no memory to continue immediately, let it sleep */ 1256 if (!(erp_action->status & ZFCP_STATUS_ERP_LOWMEM)) { 1257 ++adapter->erp_low_mem_count; 1258 erp_action->status |= ZFCP_STATUS_ERP_LOWMEM; 1259 } 1260 /* This condition is true if there is no memory available 1261 for any erp_action on this adapter. This implies that there 1262 are no elements in the memory pool(s) left for erp_actions. 1263 This might happen if an erp_action that used a memory pool 1264 element was timed out. 1265 */ 1266 if (adapter->erp_total_count == adapter->erp_low_mem_count) { 1267 debug_text_event(adapter->erp_dbf, 3, "a_st_lowmem"); 1268 ZFCP_LOG_NORMAL("error: no mempool elements available, " 1269 "restarting I/O on adapter %s " 1270 "to free mempool\n", 1271 zfcp_get_busid_by_adapter(adapter)); 1272 zfcp_erp_adapter_reopen_internal(adapter, 0); 1273 } else { 1274 debug_text_event(adapter->erp_dbf, 2, "a_st_memw"); 1275 retval = zfcp_erp_strategy_memwait(erp_action); 1276 } 1277 goto unlock; 1278 case ZFCP_ERP_CONTINUES: 1279 /* leave since this action runs asynchronously */ 1280 debug_text_event(adapter->erp_dbf, 6, "a_st_cont"); 1281 if (erp_action->status & ZFCP_STATUS_ERP_LOWMEM) { 1282 --adapter->erp_low_mem_count; 1283 erp_action->status &= ~ZFCP_STATUS_ERP_LOWMEM; 1284 } 1285 goto unlock; 1286 } 1287 /* ok, finished action (whatever its result is) */ 1288 1289 /* check for unrecoverable targets */ 1290 retval = zfcp_erp_strategy_check_target(erp_action, retval); 1291 1292 /* action must be dequeued (here to allow for further ones) */ 1293 zfcp_erp_action_dequeue(erp_action); 1294 1295 /* 1296 * put this target through the erp mill again if someone has 1297 * requested to change the status of a target being online 1298 * to offline or the other way around 1299 * (old retval is preserved if nothing has to be done here) 1300 */ 1301 retval = zfcp_erp_strategy_statechange(action, status, adapter, 1302 port, unit, retval); 1303 1304 /* 1305 * leave if target is in permanent error state or if 1306 * action is repeated in order to process state change 1307 */ 1308 if (retval == ZFCP_ERP_EXIT) { 1309 debug_text_event(adapter->erp_dbf, 2, "a_st_exit"); 1310 goto unlock; 1311 } 1312 1313 /* trigger follow up actions */ 1314 zfcp_erp_strategy_followup_actions(action, adapter, port, unit, retval); 1315 1316 unlock: 1317 write_unlock(&adapter->erp_lock); 1318 read_unlock_irqrestore(&zfcp_data.config_lock, flags); 1319 1320 if (retval != ZFCP_ERP_CONTINUES) 1321 zfcp_erp_action_cleanup(action, adapter, port, unit, retval); 1322 1323 /* 1324 * a few tasks remain when the erp queues are empty 1325 * (don't do that if the last action evaluated was dismissed 1326 * since this clearly indicates that there is more to come) : 1327 * - close the name server port if it is open yet 1328 * (enqueues another [probably] final action) 1329 * - otherwise, wake up whoever wants to be woken when we are 1330 * done with erp 1331 */ 1332 if (retval != ZFCP_ERP_DISMISSED) 1333 zfcp_erp_strategy_check_queues(adapter); 1334 1335 debug_text_event(adapter->erp_dbf, 6, "a_st_done"); 1336 1337 return retval; 1338 } 1339 1340 /* 1341 * function: 1342 * 1343 * purpose: 1344 * 1345 * returns: ZFCP_ERP_DISMISSED - if action has been dismissed 1346 * retval - otherwise 1347 */ 1348 static int 1349 zfcp_erp_strategy_check_action(struct zfcp_erp_action *erp_action, int retval) 1350 { 1351 struct zfcp_adapter *adapter = erp_action->adapter; 1352 1353 zfcp_erp_strategy_check_fsfreq(erp_action); 1354 1355 debug_event(adapter->erp_dbf, 5, &erp_action->action, sizeof (int)); 1356 if (erp_action->status & ZFCP_STATUS_ERP_DISMISSED) { 1357 debug_text_event(adapter->erp_dbf, 3, "a_stcd_dis"); 1358 zfcp_erp_action_dequeue(erp_action); 1359 retval = ZFCP_ERP_DISMISSED; 1360 } else 1361 debug_text_event(adapter->erp_dbf, 5, "a_stcd_nodis"); 1362 1363 return retval; 1364 } 1365 1366 /* 1367 * function: 1368 * 1369 * purpose: 1370 * 1371 * returns: 1372 */ 1373 static int 1374 zfcp_erp_strategy_do_action(struct zfcp_erp_action *erp_action) 1375 { 1376 int retval = ZFCP_ERP_FAILED; 1377 struct zfcp_adapter *adapter = erp_action->adapter; 1378 1379 /* 1380 * try to execute/continue action as far as possible, 1381 * note: no lock in subsequent strategy routines 1382 * (this allows these routine to call schedule, e.g. 1383 * kmalloc with such flags or qdio_initialize & friends) 1384 * Note: in case of timeout, the seperate strategies will fail 1385 * anyhow. No need for a special action. Even worse, a nameserver 1386 * failure would not wake up waiting ports without the call. 1387 */ 1388 switch (erp_action->action) { 1389 1390 case ZFCP_ERP_ACTION_REOPEN_ADAPTER: 1391 retval = zfcp_erp_adapter_strategy(erp_action); 1392 break; 1393 1394 case ZFCP_ERP_ACTION_REOPEN_PORT_FORCED: 1395 retval = zfcp_erp_port_forced_strategy(erp_action); 1396 break; 1397 1398 case ZFCP_ERP_ACTION_REOPEN_PORT: 1399 retval = zfcp_erp_port_strategy(erp_action); 1400 break; 1401 1402 case ZFCP_ERP_ACTION_REOPEN_UNIT: 1403 retval = zfcp_erp_unit_strategy(erp_action); 1404 break; 1405 1406 default: 1407 debug_text_exception(adapter->erp_dbf, 1, "a_stda_bug"); 1408 debug_event(adapter->erp_dbf, 1, &erp_action->action, 1409 sizeof (int)); 1410 ZFCP_LOG_NORMAL("bug: unknown erp action requested on " 1411 "adapter %s (action=%d)\n", 1412 zfcp_get_busid_by_adapter(erp_action->adapter), 1413 erp_action->action); 1414 } 1415 1416 return retval; 1417 } 1418 1419 /* 1420 * function: 1421 * 1422 * purpose: triggers retry of this action after a certain amount of time 1423 * by means of timer provided by erp_action 1424 * 1425 * returns: ZFCP_ERP_CONTINUES - erp_action sleeps in erp running queue 1426 */ 1427 static int 1428 zfcp_erp_strategy_memwait(struct zfcp_erp_action *erp_action) 1429 { 1430 int retval = ZFCP_ERP_CONTINUES; 1431 struct zfcp_adapter *adapter = erp_action->adapter; 1432 1433 debug_text_event(adapter->erp_dbf, 6, "a_mwinit"); 1434 debug_event(adapter->erp_dbf, 6, &erp_action->action, sizeof (int)); 1435 init_timer(&erp_action->timer); 1436 erp_action->timer.function = zfcp_erp_memwait_handler; 1437 erp_action->timer.data = (unsigned long) erp_action; 1438 erp_action->timer.expires = jiffies + ZFCP_ERP_MEMWAIT_TIMEOUT; 1439 add_timer(&erp_action->timer); 1440 1441 return retval; 1442 } 1443 1444 /* 1445 * function: zfcp_erp_adapter_failed 1446 * 1447 * purpose: sets the adapter and all underlying devices to ERP_FAILED 1448 * 1449 */ 1450 void 1451 zfcp_erp_adapter_failed(struct zfcp_adapter *adapter) 1452 { 1453 zfcp_erp_modify_adapter_status(adapter, 1454 ZFCP_STATUS_COMMON_ERP_FAILED, ZFCP_SET); 1455 ZFCP_LOG_NORMAL("adapter erp failed on adapter %s\n", 1456 zfcp_get_busid_by_adapter(adapter)); 1457 debug_text_event(adapter->erp_dbf, 2, "a_afail"); 1458 } 1459 1460 /* 1461 * function: zfcp_erp_port_failed 1462 * 1463 * purpose: sets the port and all underlying devices to ERP_FAILED 1464 * 1465 */ 1466 void 1467 zfcp_erp_port_failed(struct zfcp_port *port) 1468 { 1469 zfcp_erp_modify_port_status(port, 1470 ZFCP_STATUS_COMMON_ERP_FAILED, ZFCP_SET); 1471 1472 if (atomic_test_mask(ZFCP_STATUS_PORT_WKA, &port->status)) 1473 ZFCP_LOG_NORMAL("port erp failed (adapter %s, " 1474 "port d_id=0x%08x)\n", 1475 zfcp_get_busid_by_port(port), port->d_id); 1476 else 1477 ZFCP_LOG_NORMAL("port erp failed (adapter %s, wwpn=0x%016Lx)\n", 1478 zfcp_get_busid_by_port(port), port->wwpn); 1479 1480 debug_text_event(port->adapter->erp_dbf, 2, "p_pfail"); 1481 debug_event(port->adapter->erp_dbf, 2, &port->wwpn, sizeof (wwn_t)); 1482 } 1483 1484 /* 1485 * function: zfcp_erp_unit_failed 1486 * 1487 * purpose: sets the unit to ERP_FAILED 1488 * 1489 */ 1490 void 1491 zfcp_erp_unit_failed(struct zfcp_unit *unit) 1492 { 1493 zfcp_erp_modify_unit_status(unit, 1494 ZFCP_STATUS_COMMON_ERP_FAILED, ZFCP_SET); 1495 1496 ZFCP_LOG_NORMAL("unit erp failed on unit 0x%016Lx on port 0x%016Lx " 1497 " on adapter %s\n", unit->fcp_lun, 1498 unit->port->wwpn, zfcp_get_busid_by_unit(unit)); 1499 debug_text_event(unit->port->adapter->erp_dbf, 2, "u_ufail"); 1500 debug_event(unit->port->adapter->erp_dbf, 2, 1501 &unit->fcp_lun, sizeof (fcp_lun_t)); 1502 } 1503 1504 /* 1505 * function: zfcp_erp_strategy_check_target 1506 * 1507 * purpose: increments the erp action count on the device currently in 1508 * recovery if the action failed or resets the count in case of 1509 * success. If a maximum count is exceeded the device is marked 1510 * as ERP_FAILED. 1511 * The 'blocked' state of a target which has been recovered 1512 * successfully is reset. 1513 * 1514 * returns: ZFCP_ERP_CONTINUES - action continues (not considered) 1515 * ZFCP_ERP_SUCCEEDED - action finished successfully 1516 * ZFCP_ERP_EXIT - action failed and will not continue 1517 */ 1518 static int 1519 zfcp_erp_strategy_check_target(struct zfcp_erp_action *erp_action, int result) 1520 { 1521 struct zfcp_adapter *adapter = erp_action->adapter; 1522 struct zfcp_port *port = erp_action->port; 1523 struct zfcp_unit *unit = erp_action->unit; 1524 1525 debug_text_event(adapter->erp_dbf, 5, "a_stct_norm"); 1526 debug_event(adapter->erp_dbf, 5, &erp_action->action, sizeof (int)); 1527 debug_event(adapter->erp_dbf, 5, &result, sizeof (int)); 1528 1529 switch (erp_action->action) { 1530 1531 case ZFCP_ERP_ACTION_REOPEN_UNIT: 1532 result = zfcp_erp_strategy_check_unit(unit, result); 1533 break; 1534 1535 case ZFCP_ERP_ACTION_REOPEN_PORT_FORCED: 1536 case ZFCP_ERP_ACTION_REOPEN_PORT: 1537 result = zfcp_erp_strategy_check_port(port, result); 1538 break; 1539 1540 case ZFCP_ERP_ACTION_REOPEN_ADAPTER: 1541 result = zfcp_erp_strategy_check_adapter(adapter, result); 1542 break; 1543 } 1544 1545 return result; 1546 } 1547 1548 /* 1549 * function: 1550 * 1551 * purpose: 1552 * 1553 * returns: 1554 */ 1555 static int 1556 zfcp_erp_strategy_statechange(int action, 1557 u32 status, 1558 struct zfcp_adapter *adapter, 1559 struct zfcp_port *port, 1560 struct zfcp_unit *unit, int retval) 1561 { 1562 debug_text_event(adapter->erp_dbf, 3, "a_stsc"); 1563 debug_event(adapter->erp_dbf, 3, &action, sizeof (int)); 1564 1565 switch (action) { 1566 1567 case ZFCP_ERP_ACTION_REOPEN_ADAPTER: 1568 if (zfcp_erp_strategy_statechange_detected(&adapter->status, 1569 status)) { 1570 zfcp_erp_adapter_reopen_internal(adapter, ZFCP_STATUS_COMMON_ERP_FAILED); 1571 retval = ZFCP_ERP_EXIT; 1572 } 1573 break; 1574 1575 case ZFCP_ERP_ACTION_REOPEN_PORT_FORCED: 1576 case ZFCP_ERP_ACTION_REOPEN_PORT: 1577 if (zfcp_erp_strategy_statechange_detected(&port->status, 1578 status)) { 1579 zfcp_erp_port_reopen_internal(port, ZFCP_STATUS_COMMON_ERP_FAILED); 1580 retval = ZFCP_ERP_EXIT; 1581 } 1582 break; 1583 1584 case ZFCP_ERP_ACTION_REOPEN_UNIT: 1585 if (zfcp_erp_strategy_statechange_detected(&unit->status, 1586 status)) { 1587 zfcp_erp_unit_reopen_internal(unit, ZFCP_STATUS_COMMON_ERP_FAILED); 1588 retval = ZFCP_ERP_EXIT; 1589 } 1590 break; 1591 } 1592 1593 return retval; 1594 } 1595 1596 /* 1597 * function: 1598 * 1599 * purpose: 1600 * 1601 * returns: 1602 */ 1603 static inline int 1604 zfcp_erp_strategy_statechange_detected(atomic_t * target_status, u32 erp_status) 1605 { 1606 return 1607 /* take it online */ 1608 (atomic_test_mask(ZFCP_STATUS_COMMON_RUNNING, target_status) && 1609 (ZFCP_STATUS_ERP_CLOSE_ONLY & erp_status)) || 1610 /* take it offline */ 1611 (!atomic_test_mask(ZFCP_STATUS_COMMON_RUNNING, target_status) && 1612 !(ZFCP_STATUS_ERP_CLOSE_ONLY & erp_status)); 1613 } 1614 1615 /* 1616 * function: 1617 * 1618 * purpose: 1619 * 1620 * returns: 1621 */ 1622 static int 1623 zfcp_erp_strategy_check_unit(struct zfcp_unit *unit, int result) 1624 { 1625 debug_text_event(unit->port->adapter->erp_dbf, 5, "u_stct"); 1626 debug_event(unit->port->adapter->erp_dbf, 5, &unit->fcp_lun, 1627 sizeof (fcp_lun_t)); 1628 1629 switch (result) { 1630 case ZFCP_ERP_SUCCEEDED : 1631 atomic_set(&unit->erp_counter, 0); 1632 zfcp_erp_unit_unblock(unit); 1633 break; 1634 case ZFCP_ERP_FAILED : 1635 atomic_inc(&unit->erp_counter); 1636 if (atomic_read(&unit->erp_counter) > ZFCP_MAX_ERPS) 1637 zfcp_erp_unit_failed(unit); 1638 break; 1639 case ZFCP_ERP_EXIT : 1640 /* nothing */ 1641 break; 1642 } 1643 1644 if (atomic_test_mask(ZFCP_STATUS_COMMON_ERP_FAILED, &unit->status)) { 1645 zfcp_erp_unit_block(unit, 0); /* for ZFCP_ERP_SUCCEEDED */ 1646 result = ZFCP_ERP_EXIT; 1647 } 1648 1649 return result; 1650 } 1651 1652 /* 1653 * function: 1654 * 1655 * purpose: 1656 * 1657 * returns: 1658 */ 1659 static int 1660 zfcp_erp_strategy_check_port(struct zfcp_port *port, int result) 1661 { 1662 debug_text_event(port->adapter->erp_dbf, 5, "p_stct"); 1663 debug_event(port->adapter->erp_dbf, 5, &port->wwpn, sizeof (wwn_t)); 1664 1665 switch (result) { 1666 case ZFCP_ERP_SUCCEEDED : 1667 atomic_set(&port->erp_counter, 0); 1668 zfcp_erp_port_unblock(port); 1669 break; 1670 case ZFCP_ERP_FAILED : 1671 atomic_inc(&port->erp_counter); 1672 if (atomic_read(&port->erp_counter) > ZFCP_MAX_ERPS) 1673 zfcp_erp_port_failed(port); 1674 break; 1675 case ZFCP_ERP_EXIT : 1676 /* nothing */ 1677 break; 1678 } 1679 1680 if (atomic_test_mask(ZFCP_STATUS_COMMON_ERP_FAILED, &port->status)) { 1681 zfcp_erp_port_block(port, 0); /* for ZFCP_ERP_SUCCEEDED */ 1682 result = ZFCP_ERP_EXIT; 1683 } 1684 1685 return result; 1686 } 1687 1688 /* 1689 * function: 1690 * 1691 * purpose: 1692 * 1693 * returns: 1694 */ 1695 static int 1696 zfcp_erp_strategy_check_adapter(struct zfcp_adapter *adapter, int result) 1697 { 1698 debug_text_event(adapter->erp_dbf, 5, "a_stct"); 1699 1700 switch (result) { 1701 case ZFCP_ERP_SUCCEEDED : 1702 atomic_set(&adapter->erp_counter, 0); 1703 zfcp_erp_adapter_unblock(adapter); 1704 break; 1705 case ZFCP_ERP_FAILED : 1706 atomic_inc(&adapter->erp_counter); 1707 if (atomic_read(&adapter->erp_counter) > ZFCP_MAX_ERPS) 1708 zfcp_erp_adapter_failed(adapter); 1709 break; 1710 case ZFCP_ERP_EXIT : 1711 /* nothing */ 1712 break; 1713 } 1714 1715 if (atomic_test_mask(ZFCP_STATUS_COMMON_ERP_FAILED, &adapter->status)) { 1716 zfcp_erp_adapter_block(adapter, 0); /* for ZFCP_ERP_SUCCEEDED */ 1717 result = ZFCP_ERP_EXIT; 1718 } 1719 1720 return result; 1721 } 1722 1723 /* 1724 * function: 1725 * 1726 * purpose: remaining things in good cases, 1727 * escalation in bad cases 1728 * 1729 * returns: 1730 */ 1731 static int 1732 zfcp_erp_strategy_followup_actions(int action, 1733 struct zfcp_adapter *adapter, 1734 struct zfcp_port *port, 1735 struct zfcp_unit *unit, int status) 1736 { 1737 debug_text_event(adapter->erp_dbf, 5, "a_stfol"); 1738 debug_event(adapter->erp_dbf, 5, &action, sizeof (int)); 1739 1740 /* initiate follow-up actions depending on success of finished action */ 1741 switch (action) { 1742 1743 case ZFCP_ERP_ACTION_REOPEN_ADAPTER: 1744 if (status == ZFCP_ERP_SUCCEEDED) 1745 zfcp_erp_port_reopen_all_internal(adapter, 0); 1746 else 1747 zfcp_erp_adapter_reopen_internal(adapter, 0); 1748 break; 1749 1750 case ZFCP_ERP_ACTION_REOPEN_PORT_FORCED: 1751 if (status == ZFCP_ERP_SUCCEEDED) 1752 zfcp_erp_port_reopen_internal(port, 0); 1753 else 1754 zfcp_erp_adapter_reopen_internal(adapter, 0); 1755 break; 1756 1757 case ZFCP_ERP_ACTION_REOPEN_PORT: 1758 if (status == ZFCP_ERP_SUCCEEDED) 1759 zfcp_erp_unit_reopen_all_internal(port, 0); 1760 else 1761 zfcp_erp_port_forced_reopen_internal(port, 0); 1762 break; 1763 1764 case ZFCP_ERP_ACTION_REOPEN_UNIT: 1765 if (status == ZFCP_ERP_SUCCEEDED) ; /* no further action */ 1766 else 1767 zfcp_erp_port_reopen_internal(unit->port, 0); 1768 break; 1769 } 1770 1771 return 0; 1772 } 1773 1774 /* 1775 * function: 1776 * 1777 * purpose: 1778 * 1779 * returns: 1780 */ 1781 static int 1782 zfcp_erp_strategy_check_queues(struct zfcp_adapter *adapter) 1783 { 1784 unsigned long flags; 1785 1786 read_lock_irqsave(&zfcp_data.config_lock, flags); 1787 read_lock(&adapter->erp_lock); 1788 if (list_empty(&adapter->erp_ready_head) && 1789 list_empty(&adapter->erp_running_head)) { 1790 debug_text_event(adapter->erp_dbf, 4, "a_cq_wake"); 1791 atomic_clear_mask(ZFCP_STATUS_ADAPTER_ERP_PENDING, 1792 &adapter->status); 1793 wake_up(&adapter->erp_done_wqh); 1794 } else 1795 debug_text_event(adapter->erp_dbf, 5, "a_cq_notempty"); 1796 read_unlock(&adapter->erp_lock); 1797 read_unlock_irqrestore(&zfcp_data.config_lock, flags); 1798 1799 return 0; 1800 } 1801 1802 /** 1803 * zfcp_erp_wait - wait for completion of error recovery on an adapter 1804 * @adapter: adapter for which to wait for completion of its error recovery 1805 * Return: 0 1806 */ 1807 int 1808 zfcp_erp_wait(struct zfcp_adapter *adapter) 1809 { 1810 int retval = 0; 1811 1812 wait_event(adapter->erp_done_wqh, 1813 !atomic_test_mask(ZFCP_STATUS_ADAPTER_ERP_PENDING, 1814 &adapter->status)); 1815 1816 return retval; 1817 } 1818 1819 /* 1820 * function: zfcp_erp_modify_adapter_status 1821 * 1822 * purpose: 1823 * 1824 */ 1825 void 1826 zfcp_erp_modify_adapter_status(struct zfcp_adapter *adapter, 1827 u32 mask, int set_or_clear) 1828 { 1829 struct zfcp_port *port; 1830 u32 common_mask = mask & ZFCP_COMMON_FLAGS; 1831 1832 if (set_or_clear == ZFCP_SET) { 1833 atomic_set_mask(mask, &adapter->status); 1834 debug_text_event(adapter->erp_dbf, 3, "a_mod_as_s"); 1835 } else { 1836 atomic_clear_mask(mask, &adapter->status); 1837 if (mask & ZFCP_STATUS_COMMON_ERP_FAILED) 1838 atomic_set(&adapter->erp_counter, 0); 1839 debug_text_event(adapter->erp_dbf, 3, "a_mod_as_c"); 1840 } 1841 debug_event(adapter->erp_dbf, 3, &mask, sizeof (u32)); 1842 1843 /* Deal with all underlying devices, only pass common_mask */ 1844 if (common_mask) 1845 list_for_each_entry(port, &adapter->port_list_head, list) 1846 zfcp_erp_modify_port_status(port, common_mask, 1847 set_or_clear); 1848 } 1849 1850 /* 1851 * function: zfcp_erp_modify_port_status 1852 * 1853 * purpose: sets the port and all underlying devices to ERP_FAILED 1854 * 1855 */ 1856 void 1857 zfcp_erp_modify_port_status(struct zfcp_port *port, u32 mask, int set_or_clear) 1858 { 1859 struct zfcp_unit *unit; 1860 u32 common_mask = mask & ZFCP_COMMON_FLAGS; 1861 1862 if (set_or_clear == ZFCP_SET) { 1863 atomic_set_mask(mask, &port->status); 1864 debug_text_event(port->adapter->erp_dbf, 3, "p_mod_ps_s"); 1865 } else { 1866 atomic_clear_mask(mask, &port->status); 1867 if (mask & ZFCP_STATUS_COMMON_ERP_FAILED) 1868 atomic_set(&port->erp_counter, 0); 1869 debug_text_event(port->adapter->erp_dbf, 3, "p_mod_ps_c"); 1870 } 1871 debug_event(port->adapter->erp_dbf, 3, &port->wwpn, sizeof (wwn_t)); 1872 debug_event(port->adapter->erp_dbf, 3, &mask, sizeof (u32)); 1873 1874 /* Modify status of all underlying devices, only pass common mask */ 1875 if (common_mask) 1876 list_for_each_entry(unit, &port->unit_list_head, list) 1877 zfcp_erp_modify_unit_status(unit, common_mask, 1878 set_or_clear); 1879 } 1880 1881 /* 1882 * function: zfcp_erp_modify_unit_status 1883 * 1884 * purpose: sets the unit to ERP_FAILED 1885 * 1886 */ 1887 void 1888 zfcp_erp_modify_unit_status(struct zfcp_unit *unit, u32 mask, int set_or_clear) 1889 { 1890 if (set_or_clear == ZFCP_SET) { 1891 atomic_set_mask(mask, &unit->status); 1892 debug_text_event(unit->port->adapter->erp_dbf, 3, "u_mod_us_s"); 1893 } else { 1894 atomic_clear_mask(mask, &unit->status); 1895 if (mask & ZFCP_STATUS_COMMON_ERP_FAILED) { 1896 atomic_set(&unit->erp_counter, 0); 1897 } 1898 debug_text_event(unit->port->adapter->erp_dbf, 3, "u_mod_us_c"); 1899 } 1900 debug_event(unit->port->adapter->erp_dbf, 3, &unit->fcp_lun, 1901 sizeof (fcp_lun_t)); 1902 debug_event(unit->port->adapter->erp_dbf, 3, &mask, sizeof (u32)); 1903 } 1904 1905 /* 1906 * function: 1907 * 1908 * purpose: Wrappper for zfcp_erp_port_reopen_all_internal 1909 * used to ensure the correct locking 1910 * 1911 * returns: 0 - initiated action succesfully 1912 * <0 - failed to initiate action 1913 */ 1914 int 1915 zfcp_erp_port_reopen_all(struct zfcp_adapter *adapter, int clear_mask) 1916 { 1917 int retval; 1918 unsigned long flags; 1919 1920 read_lock_irqsave(&zfcp_data.config_lock, flags); 1921 write_lock(&adapter->erp_lock); 1922 retval = zfcp_erp_port_reopen_all_internal(adapter, clear_mask); 1923 write_unlock(&adapter->erp_lock); 1924 read_unlock_irqrestore(&zfcp_data.config_lock, flags); 1925 1926 return retval; 1927 } 1928 1929 /* 1930 * function: 1931 * 1932 * purpose: 1933 * 1934 * returns: FIXME 1935 */ 1936 static int 1937 zfcp_erp_port_reopen_all_internal(struct zfcp_adapter *adapter, int clear_mask) 1938 { 1939 int retval = 0; 1940 struct zfcp_port *port; 1941 1942 list_for_each_entry(port, &adapter->port_list_head, list) 1943 if (!atomic_test_mask(ZFCP_STATUS_PORT_WKA, &port->status)) 1944 zfcp_erp_port_reopen_internal(port, clear_mask); 1945 1946 return retval; 1947 } 1948 1949 /* 1950 * function: 1951 * 1952 * purpose: 1953 * 1954 * returns: FIXME 1955 */ 1956 static int 1957 zfcp_erp_unit_reopen_all_internal(struct zfcp_port *port, int clear_mask) 1958 { 1959 int retval = 0; 1960 struct zfcp_unit *unit; 1961 1962 list_for_each_entry(unit, &port->unit_list_head, list) 1963 zfcp_erp_unit_reopen_internal(unit, clear_mask); 1964 1965 return retval; 1966 } 1967 1968 /* 1969 * function: 1970 * 1971 * purpose: this routine executes the 'Reopen Adapter' action 1972 * (the entire action is processed synchronously, since 1973 * there are no actions which might be run concurrently 1974 * per definition) 1975 * 1976 * returns: ZFCP_ERP_SUCCEEDED - action finished successfully 1977 * ZFCP_ERP_FAILED - action finished unsuccessfully 1978 */ 1979 static int 1980 zfcp_erp_adapter_strategy(struct zfcp_erp_action *erp_action) 1981 { 1982 int retval; 1983 struct zfcp_adapter *adapter = erp_action->adapter; 1984 1985 retval = zfcp_erp_adapter_strategy_close(erp_action); 1986 if (erp_action->status & ZFCP_STATUS_ERP_CLOSE_ONLY) 1987 retval = ZFCP_ERP_EXIT; 1988 else 1989 retval = zfcp_erp_adapter_strategy_open(erp_action); 1990 1991 debug_text_event(adapter->erp_dbf, 3, "a_ast/ret"); 1992 debug_event(adapter->erp_dbf, 3, &erp_action->action, sizeof (int)); 1993 debug_event(adapter->erp_dbf, 3, &retval, sizeof (int)); 1994 1995 if (retval == ZFCP_ERP_FAILED) { 1996 ZFCP_LOG_INFO("Waiting to allow the adapter %s " 1997 "to recover itself\n", 1998 zfcp_get_busid_by_adapter(adapter)); 1999 msleep(jiffies_to_msecs(ZFCP_TYPE2_RECOVERY_TIME)); 2000 } 2001 2002 return retval; 2003 } 2004 2005 /* 2006 * function: 2007 * 2008 * purpose: 2009 * 2010 * returns: ZFCP_ERP_SUCCEEDED - action finished successfully 2011 * ZFCP_ERP_FAILED - action finished unsuccessfully 2012 */ 2013 static int 2014 zfcp_erp_adapter_strategy_close(struct zfcp_erp_action *erp_action) 2015 { 2016 int retval; 2017 2018 atomic_set_mask(ZFCP_STATUS_COMMON_CLOSING, 2019 &erp_action->adapter->status); 2020 retval = zfcp_erp_adapter_strategy_generic(erp_action, 1); 2021 atomic_clear_mask(ZFCP_STATUS_COMMON_CLOSING, 2022 &erp_action->adapter->status); 2023 2024 return retval; 2025 } 2026 2027 /* 2028 * function: 2029 * 2030 * purpose: 2031 * 2032 * returns: ZFCP_ERP_SUCCEEDED - action finished successfully 2033 * ZFCP_ERP_FAILED - action finished unsuccessfully 2034 */ 2035 static int 2036 zfcp_erp_adapter_strategy_open(struct zfcp_erp_action *erp_action) 2037 { 2038 int retval; 2039 2040 atomic_set_mask(ZFCP_STATUS_COMMON_OPENING, 2041 &erp_action->adapter->status); 2042 retval = zfcp_erp_adapter_strategy_generic(erp_action, 0); 2043 atomic_clear_mask(ZFCP_STATUS_COMMON_OPENING, 2044 &erp_action->adapter->status); 2045 2046 return retval; 2047 } 2048 2049 /* 2050 * function: zfcp_register_adapter 2051 * 2052 * purpose: allocate the irq associated with this devno and register 2053 * the FSF adapter with the SCSI stack 2054 * 2055 * returns: 2056 */ 2057 static int 2058 zfcp_erp_adapter_strategy_generic(struct zfcp_erp_action *erp_action, int close) 2059 { 2060 int retval = ZFCP_ERP_SUCCEEDED; 2061 2062 if (close) 2063 goto close_only; 2064 2065 retval = zfcp_erp_adapter_strategy_open_qdio(erp_action); 2066 if (retval != ZFCP_ERP_SUCCEEDED) 2067 goto failed_qdio; 2068 2069 retval = zfcp_erp_adapter_strategy_open_fsf(erp_action); 2070 if (retval != ZFCP_ERP_SUCCEEDED) 2071 goto failed_openfcp; 2072 2073 atomic_set_mask(ZFCP_STATUS_COMMON_OPEN, &erp_action->adapter->status); 2074 goto out; 2075 2076 close_only: 2077 atomic_clear_mask(ZFCP_STATUS_COMMON_OPEN, 2078 &erp_action->adapter->status); 2079 2080 failed_openfcp: 2081 zfcp_erp_adapter_strategy_close_qdio(erp_action); 2082 zfcp_erp_adapter_strategy_close_fsf(erp_action); 2083 failed_qdio: 2084 out: 2085 return retval; 2086 } 2087 2088 /* 2089 * function: zfcp_qdio_init 2090 * 2091 * purpose: setup QDIO operation for specified adapter 2092 * 2093 * returns: 0 - successful setup 2094 * !0 - failed setup 2095 */ 2096 int 2097 zfcp_erp_adapter_strategy_open_qdio(struct zfcp_erp_action *erp_action) 2098 { 2099 int retval; 2100 int i; 2101 volatile struct qdio_buffer_element *sbale; 2102 struct zfcp_adapter *adapter = erp_action->adapter; 2103 2104 if (atomic_test_mask(ZFCP_STATUS_ADAPTER_QDIOUP, &adapter->status)) { 2105 ZFCP_LOG_NORMAL("bug: second attempt to set up QDIO on " 2106 "adapter %s\n", 2107 zfcp_get_busid_by_adapter(adapter)); 2108 goto failed_sanity; 2109 } 2110 2111 if (qdio_establish(&adapter->qdio_init_data) != 0) { 2112 ZFCP_LOG_INFO("error: establishment of QDIO queues failed " 2113 "on adapter %s\n", 2114 zfcp_get_busid_by_adapter(adapter)); 2115 goto failed_qdio_establish; 2116 } 2117 debug_text_event(adapter->erp_dbf, 3, "qdio_est"); 2118 2119 if (qdio_activate(adapter->ccw_device, 0) != 0) { 2120 ZFCP_LOG_INFO("error: activation of QDIO queues failed " 2121 "on adapter %s\n", 2122 zfcp_get_busid_by_adapter(adapter)); 2123 goto failed_qdio_activate; 2124 } 2125 debug_text_event(adapter->erp_dbf, 3, "qdio_act"); 2126 2127 /* 2128 * put buffers into response queue, 2129 */ 2130 for (i = 0; i < QDIO_MAX_BUFFERS_PER_Q; i++) { 2131 sbale = &(adapter->response_queue.buffer[i]->element[0]); 2132 sbale->length = 0; 2133 sbale->flags = SBAL_FLAGS_LAST_ENTRY; 2134 sbale->addr = 0; 2135 } 2136 2137 ZFCP_LOG_TRACE("calling do_QDIO on adapter %s (flags=0x%x, " 2138 "queue_no=%i, index_in_queue=%i, count=%i)\n", 2139 zfcp_get_busid_by_adapter(adapter), 2140 QDIO_FLAG_SYNC_INPUT, 0, 0, QDIO_MAX_BUFFERS_PER_Q); 2141 2142 retval = do_QDIO(adapter->ccw_device, 2143 QDIO_FLAG_SYNC_INPUT, 2144 0, 0, QDIO_MAX_BUFFERS_PER_Q, NULL); 2145 2146 if (retval) { 2147 ZFCP_LOG_NORMAL("bug: setup of QDIO failed (retval=%d)\n", 2148 retval); 2149 goto failed_do_qdio; 2150 } else { 2151 adapter->response_queue.free_index = 0; 2152 atomic_set(&adapter->response_queue.free_count, 0); 2153 ZFCP_LOG_DEBUG("%i buffers successfully enqueued to " 2154 "response queue\n", QDIO_MAX_BUFFERS_PER_Q); 2155 } 2156 /* set index of first avalable SBALS / number of available SBALS */ 2157 adapter->request_queue.free_index = 0; 2158 atomic_set(&adapter->request_queue.free_count, QDIO_MAX_BUFFERS_PER_Q); 2159 adapter->request_queue.distance_from_int = 0; 2160 2161 /* initialize waitqueue used to wait for free SBALs in requests queue */ 2162 init_waitqueue_head(&adapter->request_wq); 2163 2164 /* ok, we did it - skip all cleanups for different failures */ 2165 atomic_set_mask(ZFCP_STATUS_ADAPTER_QDIOUP, &adapter->status); 2166 retval = ZFCP_ERP_SUCCEEDED; 2167 goto out; 2168 2169 failed_do_qdio: 2170 /* NOP */ 2171 2172 failed_qdio_activate: 2173 debug_text_event(adapter->erp_dbf, 3, "qdio_down1a"); 2174 while (qdio_shutdown(adapter->ccw_device, 2175 QDIO_FLAG_CLEANUP_USING_CLEAR) == -EINPROGRESS) 2176 msleep(1000); 2177 debug_text_event(adapter->erp_dbf, 3, "qdio_down1b"); 2178 2179 failed_qdio_establish: 2180 failed_sanity: 2181 retval = ZFCP_ERP_FAILED; 2182 2183 out: 2184 return retval; 2185 } 2186 2187 /* 2188 * function: zfcp_qdio_cleanup 2189 * 2190 * purpose: cleans up QDIO operation for the specified adapter 2191 * 2192 * returns: 0 - successful cleanup 2193 * !0 - failed cleanup 2194 */ 2195 int 2196 zfcp_erp_adapter_strategy_close_qdio(struct zfcp_erp_action *erp_action) 2197 { 2198 int retval = ZFCP_ERP_SUCCEEDED; 2199 int first_used; 2200 int used_count; 2201 struct zfcp_adapter *adapter = erp_action->adapter; 2202 2203 if (!atomic_test_mask(ZFCP_STATUS_ADAPTER_QDIOUP, &adapter->status)) { 2204 ZFCP_LOG_DEBUG("error: attempt to shut down inactive QDIO " 2205 "queues on adapter %s\n", 2206 zfcp_get_busid_by_adapter(adapter)); 2207 retval = ZFCP_ERP_FAILED; 2208 goto out; 2209 } 2210 2211 /* 2212 * Get queue_lock and clear QDIOUP flag. Thus it's guaranteed that 2213 * do_QDIO won't be called while qdio_shutdown is in progress. 2214 */ 2215 2216 write_lock_irq(&adapter->request_queue.queue_lock); 2217 atomic_clear_mask(ZFCP_STATUS_ADAPTER_QDIOUP, &adapter->status); 2218 write_unlock_irq(&adapter->request_queue.queue_lock); 2219 2220 debug_text_event(adapter->erp_dbf, 3, "qdio_down2a"); 2221 while (qdio_shutdown(adapter->ccw_device, 2222 QDIO_FLAG_CLEANUP_USING_CLEAR) == -EINPROGRESS) 2223 msleep(1000); 2224 debug_text_event(adapter->erp_dbf, 3, "qdio_down2b"); 2225 2226 /* 2227 * First we had to stop QDIO operation. 2228 * Now it is safe to take the following actions. 2229 */ 2230 2231 /* Cleanup only necessary when there are unacknowledged buffers */ 2232 if (atomic_read(&adapter->request_queue.free_count) 2233 < QDIO_MAX_BUFFERS_PER_Q) { 2234 first_used = (adapter->request_queue.free_index + 2235 atomic_read(&adapter->request_queue.free_count)) 2236 % QDIO_MAX_BUFFERS_PER_Q; 2237 used_count = QDIO_MAX_BUFFERS_PER_Q - 2238 atomic_read(&adapter->request_queue.free_count); 2239 zfcp_qdio_zero_sbals(adapter->request_queue.buffer, 2240 first_used, used_count); 2241 } 2242 adapter->response_queue.free_index = 0; 2243 atomic_set(&adapter->response_queue.free_count, 0); 2244 adapter->request_queue.free_index = 0; 2245 atomic_set(&adapter->request_queue.free_count, 0); 2246 adapter->request_queue.distance_from_int = 0; 2247 out: 2248 return retval; 2249 } 2250 2251 /* 2252 * function: zfcp_fsf_init 2253 * 2254 * purpose: initializes FSF operation for the specified adapter 2255 * 2256 * returns: 0 - succesful initialization of FSF operation 2257 * !0 - failed to initialize FSF operation 2258 */ 2259 static int 2260 zfcp_erp_adapter_strategy_open_fsf(struct zfcp_erp_action *erp_action) 2261 { 2262 int xconfig, xport; 2263 2264 if (atomic_test_mask(ZFCP_STATUS_ADAPTER_LINK_UNPLUGGED, 2265 &erp_action->adapter->status)) { 2266 zfcp_erp_adapter_strategy_open_fsf_xport(erp_action); 2267 atomic_set(&erp_action->adapter->erp_counter, 0); 2268 return ZFCP_ERP_FAILED; 2269 } 2270 2271 xconfig = zfcp_erp_adapter_strategy_open_fsf_xconfig(erp_action); 2272 xport = zfcp_erp_adapter_strategy_open_fsf_xport(erp_action); 2273 if ((xconfig == ZFCP_ERP_FAILED) || (xport == ZFCP_ERP_FAILED)) 2274 return ZFCP_ERP_FAILED; 2275 2276 return zfcp_erp_adapter_strategy_open_fsf_statusread(erp_action); 2277 } 2278 2279 /* 2280 * function: 2281 * 2282 * purpose: 2283 * 2284 * returns: 2285 */ 2286 static int 2287 zfcp_erp_adapter_strategy_open_fsf_xconfig(struct zfcp_erp_action *erp_action) 2288 { 2289 int retval = ZFCP_ERP_SUCCEEDED; 2290 int retries; 2291 int sleep = ZFCP_EXCHANGE_CONFIG_DATA_FIRST_SLEEP; 2292 struct zfcp_adapter *adapter = erp_action->adapter; 2293 2294 atomic_clear_mask(ZFCP_STATUS_ADAPTER_XCONFIG_OK, &adapter->status); 2295 2296 for (retries = ZFCP_EXCHANGE_CONFIG_DATA_RETRIES; retries; retries--) { 2297 atomic_clear_mask(ZFCP_STATUS_ADAPTER_HOST_CON_INIT, 2298 &adapter->status); 2299 ZFCP_LOG_DEBUG("Doing exchange config data\n"); 2300 write_lock(&adapter->erp_lock); 2301 zfcp_erp_action_to_running(erp_action); 2302 write_unlock(&adapter->erp_lock); 2303 zfcp_erp_timeout_init(erp_action); 2304 if (zfcp_fsf_exchange_config_data(erp_action)) { 2305 retval = ZFCP_ERP_FAILED; 2306 debug_text_event(adapter->erp_dbf, 5, "a_fstx_xf"); 2307 ZFCP_LOG_INFO("error: initiation of exchange of " 2308 "configuration data failed for " 2309 "adapter %s\n", 2310 zfcp_get_busid_by_adapter(adapter)); 2311 break; 2312 } 2313 debug_text_event(adapter->erp_dbf, 6, "a_fstx_xok"); 2314 ZFCP_LOG_DEBUG("Xchange underway\n"); 2315 2316 /* 2317 * Why this works: 2318 * Both the normal completion handler as well as the timeout 2319 * handler will do an 'up' when the 'exchange config data' 2320 * request completes or times out. Thus, the signal to go on 2321 * won't be lost utilizing this semaphore. 2322 * Furthermore, this 'adapter_reopen' action is 2323 * guaranteed to be the only action being there (highest action 2324 * which prevents other actions from being created). 2325 * Resulting from that, the wake signal recognized here 2326 * _must_ be the one belonging to the 'exchange config 2327 * data' request. 2328 */ 2329 down(&adapter->erp_ready_sem); 2330 if (erp_action->status & ZFCP_STATUS_ERP_TIMEDOUT) { 2331 ZFCP_LOG_INFO("error: exchange of configuration data " 2332 "for adapter %s timed out\n", 2333 zfcp_get_busid_by_adapter(adapter)); 2334 break; 2335 } 2336 2337 if (!atomic_test_mask(ZFCP_STATUS_ADAPTER_HOST_CON_INIT, 2338 &adapter->status)) 2339 break; 2340 2341 ZFCP_LOG_DEBUG("host connection still initialising... " 2342 "waiting and retrying...\n"); 2343 /* sleep a little bit before retry */ 2344 msleep(jiffies_to_msecs(sleep)); 2345 sleep *= 2; 2346 } 2347 2348 if (!atomic_test_mask(ZFCP_STATUS_ADAPTER_XCONFIG_OK, 2349 &adapter->status)) { 2350 ZFCP_LOG_INFO("error: exchange of configuration data for " 2351 "adapter %s failed\n", 2352 zfcp_get_busid_by_adapter(adapter)); 2353 retval = ZFCP_ERP_FAILED; 2354 } 2355 2356 return retval; 2357 } 2358 2359 static int 2360 zfcp_erp_adapter_strategy_open_fsf_xport(struct zfcp_erp_action *erp_action) 2361 { 2362 int retval = ZFCP_ERP_SUCCEEDED; 2363 int retries; 2364 int sleep; 2365 struct zfcp_adapter *adapter = erp_action->adapter; 2366 2367 atomic_clear_mask(ZFCP_STATUS_ADAPTER_XPORT_OK, &adapter->status); 2368 2369 for (retries = 0; ; retries++) { 2370 ZFCP_LOG_DEBUG("Doing exchange port data\n"); 2371 zfcp_erp_action_to_running(erp_action); 2372 zfcp_erp_timeout_init(erp_action); 2373 if (zfcp_fsf_exchange_port_data(erp_action, adapter, NULL)) { 2374 retval = ZFCP_ERP_FAILED; 2375 debug_text_event(adapter->erp_dbf, 5, "a_fstx_xf"); 2376 ZFCP_LOG_INFO("error: initiation of exchange of " 2377 "port data failed for adapter %s\n", 2378 zfcp_get_busid_by_adapter(adapter)); 2379 break; 2380 } 2381 debug_text_event(adapter->erp_dbf, 6, "a_fstx_xok"); 2382 ZFCP_LOG_DEBUG("Xchange underway\n"); 2383 2384 /* 2385 * Why this works: 2386 * Both the normal completion handler as well as the timeout 2387 * handler will do an 'up' when the 'exchange port data' 2388 * request completes or times out. Thus, the signal to go on 2389 * won't be lost utilizing this semaphore. 2390 * Furthermore, this 'adapter_reopen' action is 2391 * guaranteed to be the only action being there (highest action 2392 * which prevents other actions from being created). 2393 * Resulting from that, the wake signal recognized here 2394 * _must_ be the one belonging to the 'exchange port 2395 * data' request. 2396 */ 2397 down(&adapter->erp_ready_sem); 2398 if (erp_action->status & ZFCP_STATUS_ERP_TIMEDOUT) { 2399 ZFCP_LOG_INFO("error: exchange of port data " 2400 "for adapter %s timed out\n", 2401 zfcp_get_busid_by_adapter(adapter)); 2402 break; 2403 } 2404 2405 if (!atomic_test_mask(ZFCP_STATUS_ADAPTER_LINK_UNPLUGGED, 2406 &adapter->status)) 2407 break; 2408 2409 ZFCP_LOG_DEBUG("host connection still initialising... " 2410 "waiting and retrying...\n"); 2411 /* sleep a little bit before retry */ 2412 sleep = retries < ZFCP_EXCHANGE_PORT_DATA_SHORT_RETRIES ? 2413 ZFCP_EXCHANGE_PORT_DATA_SHORT_SLEEP : 2414 ZFCP_EXCHANGE_PORT_DATA_LONG_SLEEP; 2415 msleep(jiffies_to_msecs(sleep)); 2416 } 2417 2418 if (atomic_test_mask(ZFCP_STATUS_ADAPTER_LINK_UNPLUGGED, 2419 &adapter->status)) { 2420 ZFCP_LOG_INFO("error: exchange of port data for " 2421 "adapter %s failed\n", 2422 zfcp_get_busid_by_adapter(adapter)); 2423 retval = ZFCP_ERP_FAILED; 2424 } 2425 2426 return retval; 2427 } 2428 2429 /* 2430 * function: 2431 * 2432 * purpose: 2433 * 2434 * returns: 2435 */ 2436 static int 2437 zfcp_erp_adapter_strategy_open_fsf_statusread(struct zfcp_erp_action 2438 *erp_action) 2439 { 2440 int retval = ZFCP_ERP_SUCCEEDED; 2441 int temp_ret; 2442 struct zfcp_adapter *adapter = erp_action->adapter; 2443 int i; 2444 2445 adapter->status_read_failed = 0; 2446 for (i = 0; i < ZFCP_STATUS_READS_RECOM; i++) { 2447 temp_ret = zfcp_fsf_status_read(adapter, ZFCP_WAIT_FOR_SBAL); 2448 if (temp_ret < 0) { 2449 ZFCP_LOG_INFO("error: set-up of unsolicited status " 2450 "notification failed on adapter %s\n", 2451 zfcp_get_busid_by_adapter(adapter)); 2452 retval = ZFCP_ERP_FAILED; 2453 i--; 2454 break; 2455 } 2456 } 2457 2458 return retval; 2459 } 2460 2461 /* 2462 * function: zfcp_fsf_cleanup 2463 * 2464 * purpose: cleanup FSF operation for specified adapter 2465 * 2466 * returns: 0 - FSF operation successfully cleaned up 2467 * !0 - failed to cleanup FSF operation for this adapter 2468 */ 2469 static int 2470 zfcp_erp_adapter_strategy_close_fsf(struct zfcp_erp_action *erp_action) 2471 { 2472 int retval = ZFCP_ERP_SUCCEEDED; 2473 struct zfcp_adapter *adapter = erp_action->adapter; 2474 2475 /* 2476 * wake waiting initiators of requests, 2477 * return SCSI commands (with error status), 2478 * clean up all requests (synchronously) 2479 */ 2480 zfcp_fsf_req_dismiss_all(adapter); 2481 /* reset FSF request sequence number */ 2482 adapter->fsf_req_seq_no = 0; 2483 /* all ports and units are closed */ 2484 zfcp_erp_modify_adapter_status(adapter, 2485 ZFCP_STATUS_COMMON_OPEN, ZFCP_CLEAR); 2486 2487 return retval; 2488 } 2489 2490 /* 2491 * function: 2492 * 2493 * purpose: this routine executes the 'Reopen Physical Port' action 2494 * 2495 * returns: ZFCP_ERP_CONTINUES - action continues (asynchronously) 2496 * ZFCP_ERP_SUCCEEDED - action finished successfully 2497 * ZFCP_ERP_FAILED - action finished unsuccessfully 2498 */ 2499 static int 2500 zfcp_erp_port_forced_strategy(struct zfcp_erp_action *erp_action) 2501 { 2502 int retval = ZFCP_ERP_FAILED; 2503 struct zfcp_port *port = erp_action->port; 2504 struct zfcp_adapter *adapter = erp_action->adapter; 2505 2506 switch (erp_action->step) { 2507 2508 /* 2509 * FIXME: 2510 * the ULP spec. begs for waiting for oustanding commands 2511 */ 2512 case ZFCP_ERP_STEP_UNINITIALIZED: 2513 zfcp_erp_port_strategy_clearstati(port); 2514 /* 2515 * it would be sufficient to test only the normal open flag 2516 * since the phys. open flag cannot be set if the normal 2517 * open flag is unset - however, this is for readabilty ... 2518 */ 2519 if (atomic_test_mask((ZFCP_STATUS_PORT_PHYS_OPEN | 2520 ZFCP_STATUS_COMMON_OPEN), 2521 &port->status)) { 2522 ZFCP_LOG_DEBUG("port 0x%016Lx is open -> trying " 2523 "close physical\n", port->wwpn); 2524 retval = 2525 zfcp_erp_port_forced_strategy_close(erp_action); 2526 } else 2527 retval = ZFCP_ERP_FAILED; 2528 break; 2529 2530 case ZFCP_ERP_STEP_PHYS_PORT_CLOSING: 2531 if (atomic_test_mask(ZFCP_STATUS_PORT_PHYS_OPEN, 2532 &port->status)) { 2533 ZFCP_LOG_DEBUG("close physical failed for port " 2534 "0x%016Lx\n", port->wwpn); 2535 retval = ZFCP_ERP_FAILED; 2536 } else 2537 retval = ZFCP_ERP_SUCCEEDED; 2538 break; 2539 } 2540 2541 debug_text_event(adapter->erp_dbf, 3, "p_pfst/ret"); 2542 debug_event(adapter->erp_dbf, 3, &port->wwpn, sizeof (wwn_t)); 2543 debug_event(adapter->erp_dbf, 3, &erp_action->action, sizeof (int)); 2544 debug_event(adapter->erp_dbf, 3, &retval, sizeof (int)); 2545 2546 return retval; 2547 } 2548 2549 /* 2550 * function: 2551 * 2552 * purpose: this routine executes the 'Reopen Port' action 2553 * 2554 * returns: ZFCP_ERP_CONTINUES - action continues (asynchronously) 2555 * ZFCP_ERP_SUCCEEDED - action finished successfully 2556 * ZFCP_ERP_FAILED - action finished unsuccessfully 2557 */ 2558 static int 2559 zfcp_erp_port_strategy(struct zfcp_erp_action *erp_action) 2560 { 2561 int retval = ZFCP_ERP_FAILED; 2562 struct zfcp_port *port = erp_action->port; 2563 struct zfcp_adapter *adapter = erp_action->adapter; 2564 2565 switch (erp_action->step) { 2566 2567 /* 2568 * FIXME: 2569 * the ULP spec. begs for waiting for oustanding commands 2570 */ 2571 case ZFCP_ERP_STEP_UNINITIALIZED: 2572 zfcp_erp_port_strategy_clearstati(port); 2573 if (atomic_test_mask(ZFCP_STATUS_COMMON_OPEN, &port->status)) { 2574 ZFCP_LOG_DEBUG("port 0x%016Lx is open -> trying " 2575 "close\n", port->wwpn); 2576 retval = zfcp_erp_port_strategy_close(erp_action); 2577 goto out; 2578 } /* else it's already closed, open it */ 2579 break; 2580 2581 case ZFCP_ERP_STEP_PORT_CLOSING: 2582 if (atomic_test_mask(ZFCP_STATUS_COMMON_OPEN, &port->status)) { 2583 ZFCP_LOG_DEBUG("close failed for port 0x%016Lx\n", 2584 port->wwpn); 2585 retval = ZFCP_ERP_FAILED; 2586 goto out; 2587 } /* else it's closed now, open it */ 2588 break; 2589 } 2590 if (erp_action->status & ZFCP_STATUS_ERP_CLOSE_ONLY) 2591 retval = ZFCP_ERP_EXIT; 2592 else 2593 retval = zfcp_erp_port_strategy_open(erp_action); 2594 2595 out: 2596 debug_text_event(adapter->erp_dbf, 3, "p_pst/ret"); 2597 debug_event(adapter->erp_dbf, 3, &port->wwpn, sizeof (wwn_t)); 2598 debug_event(adapter->erp_dbf, 3, &erp_action->action, sizeof (int)); 2599 debug_event(adapter->erp_dbf, 3, &retval, sizeof (int)); 2600 2601 return retval; 2602 } 2603 2604 /* 2605 * function: 2606 * 2607 * purpose: 2608 * 2609 * returns: 2610 */ 2611 static int 2612 zfcp_erp_port_strategy_open(struct zfcp_erp_action *erp_action) 2613 { 2614 int retval; 2615 2616 if (atomic_test_mask(ZFCP_STATUS_PORT_WKA, 2617 &erp_action->port->status)) 2618 retval = zfcp_erp_port_strategy_open_nameserver(erp_action); 2619 else 2620 retval = zfcp_erp_port_strategy_open_common(erp_action); 2621 2622 return retval; 2623 } 2624 2625 /* 2626 * function: 2627 * 2628 * purpose: 2629 * 2630 * returns: 2631 * 2632 * FIXME(design): currently only prepared for fabric (nameserver!) 2633 */ 2634 static int 2635 zfcp_erp_port_strategy_open_common(struct zfcp_erp_action *erp_action) 2636 { 2637 int retval = 0; 2638 struct zfcp_adapter *adapter = erp_action->adapter; 2639 struct zfcp_port *port = erp_action->port; 2640 2641 switch (erp_action->step) { 2642 2643 case ZFCP_ERP_STEP_UNINITIALIZED: 2644 case ZFCP_ERP_STEP_PHYS_PORT_CLOSING: 2645 case ZFCP_ERP_STEP_PORT_CLOSING: 2646 if (adapter->fc_topology == FSF_TOPO_P2P) { 2647 if (port->wwpn != adapter->peer_wwpn) { 2648 ZFCP_LOG_NORMAL("Failed to open port 0x%016Lx " 2649 "on adapter %s.\nPeer WWPN " 2650 "0x%016Lx does not match\n", 2651 port->wwpn, 2652 zfcp_get_busid_by_adapter(adapter), 2653 adapter->peer_wwpn); 2654 zfcp_erp_port_failed(port); 2655 retval = ZFCP_ERP_FAILED; 2656 break; 2657 } 2658 port->d_id = adapter->peer_d_id; 2659 atomic_set_mask(ZFCP_STATUS_PORT_DID_DID, &port->status); 2660 retval = zfcp_erp_port_strategy_open_port(erp_action); 2661 break; 2662 } 2663 if (!(adapter->nameserver_port)) { 2664 retval = zfcp_nameserver_enqueue(adapter); 2665 if (retval != 0) { 2666 ZFCP_LOG_NORMAL("error: nameserver port " 2667 "unavailable for adapter %s\n", 2668 zfcp_get_busid_by_adapter(adapter)); 2669 retval = ZFCP_ERP_FAILED; 2670 break; 2671 } 2672 } 2673 if (!atomic_test_mask(ZFCP_STATUS_COMMON_UNBLOCKED, 2674 &adapter->nameserver_port->status)) { 2675 ZFCP_LOG_DEBUG("nameserver port is not open -> open " 2676 "nameserver port\n"); 2677 /* nameserver port may live again */ 2678 atomic_set_mask(ZFCP_STATUS_COMMON_RUNNING, 2679 &adapter->nameserver_port->status); 2680 if (zfcp_erp_port_reopen(adapter->nameserver_port, 0) 2681 >= 0) { 2682 erp_action->step = 2683 ZFCP_ERP_STEP_NAMESERVER_OPEN; 2684 retval = ZFCP_ERP_CONTINUES; 2685 } else 2686 retval = ZFCP_ERP_FAILED; 2687 break; 2688 } 2689 /* else nameserver port is already open, fall through */ 2690 case ZFCP_ERP_STEP_NAMESERVER_OPEN: 2691 if (!atomic_test_mask(ZFCP_STATUS_COMMON_OPEN, 2692 &adapter->nameserver_port->status)) { 2693 ZFCP_LOG_DEBUG("open failed for nameserver port\n"); 2694 retval = ZFCP_ERP_FAILED; 2695 } else { 2696 ZFCP_LOG_DEBUG("nameserver port is open -> " 2697 "nameserver look-up for port 0x%016Lx\n", 2698 port->wwpn); 2699 retval = zfcp_erp_port_strategy_open_common_lookup 2700 (erp_action); 2701 } 2702 break; 2703 2704 case ZFCP_ERP_STEP_NAMESERVER_LOOKUP: 2705 if (!atomic_test_mask(ZFCP_STATUS_PORT_DID_DID, &port->status)) { 2706 if (atomic_test_mask 2707 (ZFCP_STATUS_PORT_INVALID_WWPN, &port->status)) { 2708 ZFCP_LOG_DEBUG("nameserver look-up failed " 2709 "for port 0x%016Lx " 2710 "(misconfigured WWPN?)\n", 2711 port->wwpn); 2712 zfcp_erp_port_failed(port); 2713 retval = ZFCP_ERP_EXIT; 2714 } else { 2715 ZFCP_LOG_DEBUG("nameserver look-up failed for " 2716 "port 0x%016Lx\n", port->wwpn); 2717 retval = ZFCP_ERP_FAILED; 2718 } 2719 } else { 2720 ZFCP_LOG_DEBUG("port 0x%016Lx has d_id=0x%08x -> " 2721 "trying open\n", port->wwpn, port->d_id); 2722 retval = zfcp_erp_port_strategy_open_port(erp_action); 2723 } 2724 break; 2725 2726 case ZFCP_ERP_STEP_PORT_OPENING: 2727 /* D_ID might have changed during open */ 2728 if (atomic_test_mask((ZFCP_STATUS_COMMON_OPEN | 2729 ZFCP_STATUS_PORT_DID_DID), 2730 &port->status)) { 2731 ZFCP_LOG_DEBUG("port 0x%016Lx is open\n", port->wwpn); 2732 retval = ZFCP_ERP_SUCCEEDED; 2733 } else { 2734 ZFCP_LOG_DEBUG("open failed for port 0x%016Lx\n", 2735 port->wwpn); 2736 retval = ZFCP_ERP_FAILED; 2737 } 2738 break; 2739 2740 default: 2741 ZFCP_LOG_NORMAL("bug: unknown erp step 0x%08x\n", 2742 erp_action->step); 2743 retval = ZFCP_ERP_FAILED; 2744 } 2745 2746 return retval; 2747 } 2748 2749 /* 2750 * function: 2751 * 2752 * purpose: 2753 * 2754 * returns: 2755 */ 2756 static int 2757 zfcp_erp_port_strategy_open_nameserver(struct zfcp_erp_action *erp_action) 2758 { 2759 int retval; 2760 struct zfcp_port *port = erp_action->port; 2761 2762 switch (erp_action->step) { 2763 2764 case ZFCP_ERP_STEP_UNINITIALIZED: 2765 case ZFCP_ERP_STEP_PHYS_PORT_CLOSING: 2766 case ZFCP_ERP_STEP_PORT_CLOSING: 2767 ZFCP_LOG_DEBUG("port 0x%016Lx has d_id=0x%08x -> trying open\n", 2768 port->wwpn, port->d_id); 2769 retval = zfcp_erp_port_strategy_open_port(erp_action); 2770 break; 2771 2772 case ZFCP_ERP_STEP_PORT_OPENING: 2773 if (atomic_test_mask(ZFCP_STATUS_COMMON_OPEN, &port->status)) { 2774 ZFCP_LOG_DEBUG("WKA port is open\n"); 2775 retval = ZFCP_ERP_SUCCEEDED; 2776 } else { 2777 ZFCP_LOG_DEBUG("open failed for WKA port\n"); 2778 retval = ZFCP_ERP_FAILED; 2779 } 2780 /* this is needed anyway (dont care for retval of wakeup) */ 2781 ZFCP_LOG_DEBUG("continue other open port operations\n"); 2782 zfcp_erp_port_strategy_open_nameserver_wakeup(erp_action); 2783 break; 2784 2785 default: 2786 ZFCP_LOG_NORMAL("bug: unknown erp step 0x%08x\n", 2787 erp_action->step); 2788 retval = ZFCP_ERP_FAILED; 2789 } 2790 2791 return retval; 2792 } 2793 2794 /* 2795 * function: 2796 * 2797 * purpose: makes the erp thread continue with reopen (physical) port 2798 * actions which have been paused until the name server port 2799 * is opened (or failed) 2800 * 2801 * returns: 0 (a kind of void retval, its not used) 2802 */ 2803 static int 2804 zfcp_erp_port_strategy_open_nameserver_wakeup(struct zfcp_erp_action 2805 *ns_erp_action) 2806 { 2807 int retval = 0; 2808 unsigned long flags; 2809 struct zfcp_adapter *adapter = ns_erp_action->adapter; 2810 struct zfcp_erp_action *erp_action, *tmp; 2811 2812 read_lock_irqsave(&adapter->erp_lock, flags); 2813 list_for_each_entry_safe(erp_action, tmp, &adapter->erp_running_head, 2814 list) { 2815 debug_text_event(adapter->erp_dbf, 4, "p_pstnsw_n"); 2816 debug_event(adapter->erp_dbf, 4, &erp_action->port->wwpn, 2817 sizeof (wwn_t)); 2818 if (erp_action->step == ZFCP_ERP_STEP_NAMESERVER_OPEN) { 2819 debug_text_event(adapter->erp_dbf, 3, "p_pstnsw_w"); 2820 debug_event(adapter->erp_dbf, 3, 2821 &erp_action->port->wwpn, sizeof (wwn_t)); 2822 if (atomic_test_mask( 2823 ZFCP_STATUS_COMMON_ERP_FAILED, 2824 &adapter->nameserver_port->status)) 2825 zfcp_erp_port_failed(erp_action->port); 2826 zfcp_erp_action_ready(erp_action); 2827 } 2828 } 2829 read_unlock_irqrestore(&adapter->erp_lock, flags); 2830 2831 return retval; 2832 } 2833 2834 /* 2835 * function: 2836 * 2837 * purpose: 2838 * 2839 * returns: ZFCP_ERP_CONTINUES - action continues (asynchronously) 2840 * ZFCP_ERP_FAILED - action finished unsuccessfully 2841 */ 2842 static int 2843 zfcp_erp_port_forced_strategy_close(struct zfcp_erp_action *erp_action) 2844 { 2845 int retval; 2846 struct zfcp_adapter *adapter = erp_action->adapter; 2847 struct zfcp_port *port = erp_action->port; 2848 2849 zfcp_erp_timeout_init(erp_action); 2850 retval = zfcp_fsf_close_physical_port(erp_action); 2851 if (retval == -ENOMEM) { 2852 debug_text_event(adapter->erp_dbf, 5, "o_pfstc_nomem"); 2853 debug_event(adapter->erp_dbf, 5, &port->wwpn, sizeof (wwn_t)); 2854 retval = ZFCP_ERP_NOMEM; 2855 goto out; 2856 } 2857 erp_action->step = ZFCP_ERP_STEP_PHYS_PORT_CLOSING; 2858 if (retval != 0) { 2859 debug_text_event(adapter->erp_dbf, 5, "o_pfstc_cpf"); 2860 debug_event(adapter->erp_dbf, 5, &port->wwpn, sizeof (wwn_t)); 2861 /* could not send 'open', fail */ 2862 retval = ZFCP_ERP_FAILED; 2863 goto out; 2864 } 2865 debug_text_event(adapter->erp_dbf, 6, "o_pfstc_cpok"); 2866 debug_event(adapter->erp_dbf, 6, &port->wwpn, sizeof (wwn_t)); 2867 retval = ZFCP_ERP_CONTINUES; 2868 out: 2869 return retval; 2870 } 2871 2872 /* 2873 * function: 2874 * 2875 * purpose: 2876 * 2877 * returns: 2878 */ 2879 static int 2880 zfcp_erp_port_strategy_clearstati(struct zfcp_port *port) 2881 { 2882 int retval = 0; 2883 struct zfcp_adapter *adapter = port->adapter; 2884 2885 debug_text_event(adapter->erp_dbf, 5, "p_pstclst"); 2886 debug_event(adapter->erp_dbf, 5, &port->wwpn, sizeof (wwn_t)); 2887 2888 atomic_clear_mask(ZFCP_STATUS_COMMON_OPENING | 2889 ZFCP_STATUS_COMMON_CLOSING | 2890 ZFCP_STATUS_COMMON_ACCESS_DENIED | 2891 ZFCP_STATUS_PORT_DID_DID | 2892 ZFCP_STATUS_PORT_PHYS_CLOSING | 2893 ZFCP_STATUS_PORT_INVALID_WWPN, 2894 &port->status); 2895 return retval; 2896 } 2897 2898 /* 2899 * function: 2900 * 2901 * purpose: 2902 * 2903 * returns: ZFCP_ERP_CONTINUES - action continues (asynchronously) 2904 * ZFCP_ERP_FAILED - action finished unsuccessfully 2905 */ 2906 static int 2907 zfcp_erp_port_strategy_close(struct zfcp_erp_action *erp_action) 2908 { 2909 int retval; 2910 struct zfcp_adapter *adapter = erp_action->adapter; 2911 struct zfcp_port *port = erp_action->port; 2912 2913 zfcp_erp_timeout_init(erp_action); 2914 retval = zfcp_fsf_close_port(erp_action); 2915 if (retval == -ENOMEM) { 2916 debug_text_event(adapter->erp_dbf, 5, "p_pstc_nomem"); 2917 debug_event(adapter->erp_dbf, 5, &port->wwpn, sizeof (wwn_t)); 2918 retval = ZFCP_ERP_NOMEM; 2919 goto out; 2920 } 2921 erp_action->step = ZFCP_ERP_STEP_PORT_CLOSING; 2922 if (retval != 0) { 2923 debug_text_event(adapter->erp_dbf, 5, "p_pstc_cpf"); 2924 debug_event(adapter->erp_dbf, 5, &port->wwpn, sizeof (wwn_t)); 2925 /* could not send 'close', fail */ 2926 retval = ZFCP_ERP_FAILED; 2927 goto out; 2928 } 2929 debug_text_event(adapter->erp_dbf, 6, "p_pstc_cpok"); 2930 debug_event(adapter->erp_dbf, 6, &port->wwpn, sizeof (wwn_t)); 2931 retval = ZFCP_ERP_CONTINUES; 2932 out: 2933 return retval; 2934 } 2935 2936 /* 2937 * function: 2938 * 2939 * purpose: 2940 * 2941 * returns: ZFCP_ERP_CONTINUES - action continues (asynchronously) 2942 * ZFCP_ERP_FAILED - action finished unsuccessfully 2943 */ 2944 static int 2945 zfcp_erp_port_strategy_open_port(struct zfcp_erp_action *erp_action) 2946 { 2947 int retval; 2948 struct zfcp_adapter *adapter = erp_action->adapter; 2949 struct zfcp_port *port = erp_action->port; 2950 2951 zfcp_erp_timeout_init(erp_action); 2952 retval = zfcp_fsf_open_port(erp_action); 2953 if (retval == -ENOMEM) { 2954 debug_text_event(adapter->erp_dbf, 5, "p_psto_nomem"); 2955 debug_event(adapter->erp_dbf, 5, &port->wwpn, sizeof (wwn_t)); 2956 retval = ZFCP_ERP_NOMEM; 2957 goto out; 2958 } 2959 erp_action->step = ZFCP_ERP_STEP_PORT_OPENING; 2960 if (retval != 0) { 2961 debug_text_event(adapter->erp_dbf, 5, "p_psto_opf"); 2962 debug_event(adapter->erp_dbf, 5, &port->wwpn, sizeof (wwn_t)); 2963 /* could not send 'open', fail */ 2964 retval = ZFCP_ERP_FAILED; 2965 goto out; 2966 } 2967 debug_text_event(adapter->erp_dbf, 6, "p_psto_opok"); 2968 debug_event(adapter->erp_dbf, 6, &port->wwpn, sizeof (wwn_t)); 2969 retval = ZFCP_ERP_CONTINUES; 2970 out: 2971 return retval; 2972 } 2973 2974 /* 2975 * function: 2976 * 2977 * purpose: 2978 * 2979 * returns: ZFCP_ERP_CONTINUES - action continues (asynchronously) 2980 * ZFCP_ERP_FAILED - action finished unsuccessfully 2981 */ 2982 static int 2983 zfcp_erp_port_strategy_open_common_lookup(struct zfcp_erp_action *erp_action) 2984 { 2985 int retval; 2986 struct zfcp_adapter *adapter = erp_action->adapter; 2987 struct zfcp_port *port = erp_action->port; 2988 2989 zfcp_erp_timeout_init(erp_action); 2990 retval = zfcp_ns_gid_pn_request(erp_action); 2991 if (retval == -ENOMEM) { 2992 debug_text_event(adapter->erp_dbf, 5, "p_pstn_nomem"); 2993 debug_event(adapter->erp_dbf, 5, &port->wwpn, sizeof (wwn_t)); 2994 retval = ZFCP_ERP_NOMEM; 2995 goto out; 2996 } 2997 erp_action->step = ZFCP_ERP_STEP_NAMESERVER_LOOKUP; 2998 if (retval != 0) { 2999 debug_text_event(adapter->erp_dbf, 5, "p_pstn_ref"); 3000 debug_event(adapter->erp_dbf, 5, &port->wwpn, sizeof (wwn_t)); 3001 /* could not send nameserver request, fail */ 3002 retval = ZFCP_ERP_FAILED; 3003 goto out; 3004 } 3005 debug_text_event(adapter->erp_dbf, 6, "p_pstn_reok"); 3006 debug_event(adapter->erp_dbf, 6, &port->wwpn, sizeof (wwn_t)); 3007 retval = ZFCP_ERP_CONTINUES; 3008 out: 3009 return retval; 3010 } 3011 3012 /* 3013 * function: 3014 * 3015 * purpose: this routine executes the 'Reopen Unit' action 3016 * currently no retries 3017 * 3018 * returns: ZFCP_ERP_CONTINUES - action continues (asynchronously) 3019 * ZFCP_ERP_SUCCEEDED - action finished successfully 3020 * ZFCP_ERP_FAILED - action finished unsuccessfully 3021 */ 3022 static int 3023 zfcp_erp_unit_strategy(struct zfcp_erp_action *erp_action) 3024 { 3025 int retval = ZFCP_ERP_FAILED; 3026 struct zfcp_unit *unit = erp_action->unit; 3027 struct zfcp_adapter *adapter = erp_action->adapter; 3028 3029 switch (erp_action->step) { 3030 3031 /* 3032 * FIXME: 3033 * the ULP spec. begs for waiting for oustanding commands 3034 */ 3035 case ZFCP_ERP_STEP_UNINITIALIZED: 3036 zfcp_erp_unit_strategy_clearstati(unit); 3037 if (atomic_test_mask(ZFCP_STATUS_COMMON_OPEN, &unit->status)) { 3038 ZFCP_LOG_DEBUG("unit 0x%016Lx is open -> " 3039 "trying close\n", unit->fcp_lun); 3040 retval = zfcp_erp_unit_strategy_close(erp_action); 3041 break; 3042 } 3043 /* else it's already closed, fall through */ 3044 case ZFCP_ERP_STEP_UNIT_CLOSING: 3045 if (atomic_test_mask(ZFCP_STATUS_COMMON_OPEN, &unit->status)) { 3046 ZFCP_LOG_DEBUG("close failed for unit 0x%016Lx\n", 3047 unit->fcp_lun); 3048 retval = ZFCP_ERP_FAILED; 3049 } else { 3050 if (erp_action->status & ZFCP_STATUS_ERP_CLOSE_ONLY) 3051 retval = ZFCP_ERP_EXIT; 3052 else { 3053 ZFCP_LOG_DEBUG("unit 0x%016Lx is not open -> " 3054 "trying open\n", unit->fcp_lun); 3055 retval = 3056 zfcp_erp_unit_strategy_open(erp_action); 3057 } 3058 } 3059 break; 3060 3061 case ZFCP_ERP_STEP_UNIT_OPENING: 3062 if (atomic_test_mask(ZFCP_STATUS_COMMON_OPEN, &unit->status)) { 3063 ZFCP_LOG_DEBUG("unit 0x%016Lx is open\n", 3064 unit->fcp_lun); 3065 retval = ZFCP_ERP_SUCCEEDED; 3066 } else { 3067 ZFCP_LOG_DEBUG("open failed for unit 0x%016Lx\n", 3068 unit->fcp_lun); 3069 retval = ZFCP_ERP_FAILED; 3070 } 3071 break; 3072 } 3073 3074 debug_text_event(adapter->erp_dbf, 3, "u_ust/ret"); 3075 debug_event(adapter->erp_dbf, 3, &unit->fcp_lun, sizeof (fcp_lun_t)); 3076 debug_event(adapter->erp_dbf, 3, &erp_action->action, sizeof (int)); 3077 debug_event(adapter->erp_dbf, 3, &retval, sizeof (int)); 3078 return retval; 3079 } 3080 3081 /* 3082 * function: 3083 * 3084 * purpose: 3085 * 3086 * returns: 3087 */ 3088 static int 3089 zfcp_erp_unit_strategy_clearstati(struct zfcp_unit *unit) 3090 { 3091 int retval = 0; 3092 struct zfcp_adapter *adapter = unit->port->adapter; 3093 3094 debug_text_event(adapter->erp_dbf, 5, "u_ustclst"); 3095 debug_event(adapter->erp_dbf, 5, &unit->fcp_lun, sizeof (fcp_lun_t)); 3096 3097 atomic_clear_mask(ZFCP_STATUS_COMMON_OPENING | 3098 ZFCP_STATUS_COMMON_CLOSING | 3099 ZFCP_STATUS_COMMON_ACCESS_DENIED | 3100 ZFCP_STATUS_UNIT_SHARED | 3101 ZFCP_STATUS_UNIT_READONLY, 3102 &unit->status); 3103 3104 return retval; 3105 } 3106 3107 /* 3108 * function: 3109 * 3110 * purpose: 3111 * 3112 * returns: ZFCP_ERP_CONTINUES - action continues (asynchronously) 3113 * ZFCP_ERP_FAILED - action finished unsuccessfully 3114 */ 3115 static int 3116 zfcp_erp_unit_strategy_close(struct zfcp_erp_action *erp_action) 3117 { 3118 int retval; 3119 struct zfcp_adapter *adapter = erp_action->adapter; 3120 struct zfcp_unit *unit = erp_action->unit; 3121 3122 zfcp_erp_timeout_init(erp_action); 3123 retval = zfcp_fsf_close_unit(erp_action); 3124 if (retval == -ENOMEM) { 3125 debug_text_event(adapter->erp_dbf, 5, "u_ustc_nomem"); 3126 debug_event(adapter->erp_dbf, 5, &unit->fcp_lun, 3127 sizeof (fcp_lun_t)); 3128 retval = ZFCP_ERP_NOMEM; 3129 goto out; 3130 } 3131 erp_action->step = ZFCP_ERP_STEP_UNIT_CLOSING; 3132 if (retval != 0) { 3133 debug_text_event(adapter->erp_dbf, 5, "u_ustc_cuf"); 3134 debug_event(adapter->erp_dbf, 5, &unit->fcp_lun, 3135 sizeof (fcp_lun_t)); 3136 /* could not send 'close', fail */ 3137 retval = ZFCP_ERP_FAILED; 3138 goto out; 3139 } 3140 debug_text_event(adapter->erp_dbf, 6, "u_ustc_cuok"); 3141 debug_event(adapter->erp_dbf, 6, &unit->fcp_lun, sizeof (fcp_lun_t)); 3142 retval = ZFCP_ERP_CONTINUES; 3143 3144 out: 3145 return retval; 3146 } 3147 3148 /* 3149 * function: 3150 * 3151 * purpose: 3152 * 3153 * returns: ZFCP_ERP_CONTINUES - action continues (asynchronously) 3154 * ZFCP_ERP_FAILED - action finished unsuccessfully 3155 */ 3156 static int 3157 zfcp_erp_unit_strategy_open(struct zfcp_erp_action *erp_action) 3158 { 3159 int retval; 3160 struct zfcp_adapter *adapter = erp_action->adapter; 3161 struct zfcp_unit *unit = erp_action->unit; 3162 3163 zfcp_erp_timeout_init(erp_action); 3164 retval = zfcp_fsf_open_unit(erp_action); 3165 if (retval == -ENOMEM) { 3166 debug_text_event(adapter->erp_dbf, 5, "u_usto_nomem"); 3167 debug_event(adapter->erp_dbf, 5, &unit->fcp_lun, 3168 sizeof (fcp_lun_t)); 3169 retval = ZFCP_ERP_NOMEM; 3170 goto out; 3171 } 3172 erp_action->step = ZFCP_ERP_STEP_UNIT_OPENING; 3173 if (retval != 0) { 3174 debug_text_event(adapter->erp_dbf, 5, "u_usto_ouf"); 3175 debug_event(adapter->erp_dbf, 5, &unit->fcp_lun, 3176 sizeof (fcp_lun_t)); 3177 /* could not send 'open', fail */ 3178 retval = ZFCP_ERP_FAILED; 3179 goto out; 3180 } 3181 debug_text_event(adapter->erp_dbf, 6, "u_usto_ouok"); 3182 debug_event(adapter->erp_dbf, 6, &unit->fcp_lun, sizeof (fcp_lun_t)); 3183 retval = ZFCP_ERP_CONTINUES; 3184 out: 3185 return retval; 3186 } 3187 3188 /* 3189 * function: 3190 * 3191 * purpose: 3192 * 3193 * returns: 3194 */ 3195 static inline void 3196 zfcp_erp_timeout_init(struct zfcp_erp_action *erp_action) 3197 { 3198 init_timer(&erp_action->timer); 3199 erp_action->timer.function = zfcp_erp_timeout_handler; 3200 erp_action->timer.data = (unsigned long) erp_action; 3201 /* jiffies will be added in zfcp_fsf_req_send */ 3202 erp_action->timer.expires = ZFCP_ERP_FSFREQ_TIMEOUT; 3203 } 3204 3205 /* 3206 * function: 3207 * 3208 * purpose: enqueue the specified error recovery action, if needed 3209 * 3210 * returns: 3211 */ 3212 static int 3213 zfcp_erp_action_enqueue(int action, 3214 struct zfcp_adapter *adapter, 3215 struct zfcp_port *port, struct zfcp_unit *unit) 3216 { 3217 int retval = 1; 3218 struct zfcp_erp_action *erp_action = NULL; 3219 int stronger_action = 0; 3220 u32 status = 0; 3221 3222 /* 3223 * We need some rules here which check whether we really need 3224 * this action or whether we should just drop it. 3225 * E.g. if there is a unfinished 'Reopen Port' request then we drop a 3226 * 'Reopen Unit' request for an associated unit since we can't 3227 * satisfy this request now. A 'Reopen Port' action will trigger 3228 * 'Reopen Unit' actions when it completes. 3229 * Thus, there are only actions in the queue which can immediately be 3230 * executed. This makes the processing of the action queue more 3231 * efficient. 3232 */ 3233 3234 if (!atomic_test_mask(ZFCP_STATUS_ADAPTER_ERP_THREAD_UP, 3235 &adapter->status)) 3236 return -EIO; 3237 3238 debug_event(adapter->erp_dbf, 4, &action, sizeof (int)); 3239 /* check whether we really need this */ 3240 switch (action) { 3241 case ZFCP_ERP_ACTION_REOPEN_UNIT: 3242 if (atomic_test_mask 3243 (ZFCP_STATUS_COMMON_ERP_INUSE, &unit->status)) { 3244 debug_text_event(adapter->erp_dbf, 4, "u_actenq_drp"); 3245 debug_event(adapter->erp_dbf, 4, &port->wwpn, 3246 sizeof (wwn_t)); 3247 debug_event(adapter->erp_dbf, 4, &unit->fcp_lun, 3248 sizeof (fcp_lun_t)); 3249 goto out; 3250 } 3251 if (!atomic_test_mask 3252 (ZFCP_STATUS_COMMON_RUNNING, &port->status) || 3253 atomic_test_mask 3254 (ZFCP_STATUS_COMMON_ERP_FAILED, &port->status)) { 3255 goto out; 3256 } 3257 if (!atomic_test_mask 3258 (ZFCP_STATUS_COMMON_UNBLOCKED, &port->status)) { 3259 stronger_action = ZFCP_ERP_ACTION_REOPEN_PORT; 3260 unit = NULL; 3261 } 3262 /* fall through !!! */ 3263 3264 case ZFCP_ERP_ACTION_REOPEN_PORT: 3265 if (atomic_test_mask 3266 (ZFCP_STATUS_COMMON_ERP_INUSE, &port->status)) { 3267 debug_text_event(adapter->erp_dbf, 4, "p_actenq_drp"); 3268 debug_event(adapter->erp_dbf, 4, &port->wwpn, 3269 sizeof (wwn_t)); 3270 goto out; 3271 } 3272 /* fall through !!! */ 3273 3274 case ZFCP_ERP_ACTION_REOPEN_PORT_FORCED: 3275 if (atomic_test_mask(ZFCP_STATUS_COMMON_ERP_INUSE, 3276 &port->status)) { 3277 if (port->erp_action.action != 3278 ZFCP_ERP_ACTION_REOPEN_PORT_FORCED) { 3279 ZFCP_LOG_INFO("dropped erp action %i (port " 3280 "0x%016Lx, action in use: %i)\n", 3281 action, port->wwpn, 3282 port->erp_action.action); 3283 debug_text_event(adapter->erp_dbf, 4, 3284 "pf_actenq_drp"); 3285 } else 3286 debug_text_event(adapter->erp_dbf, 4, 3287 "pf_actenq_drpcp"); 3288 debug_event(adapter->erp_dbf, 4, &port->wwpn, 3289 sizeof (wwn_t)); 3290 goto out; 3291 } 3292 if (!atomic_test_mask 3293 (ZFCP_STATUS_COMMON_RUNNING, &adapter->status) || 3294 atomic_test_mask 3295 (ZFCP_STATUS_COMMON_ERP_FAILED, &adapter->status)) { 3296 goto out; 3297 } 3298 if (!atomic_test_mask 3299 (ZFCP_STATUS_COMMON_UNBLOCKED, &adapter->status)) { 3300 stronger_action = ZFCP_ERP_ACTION_REOPEN_ADAPTER; 3301 port = NULL; 3302 } 3303 /* fall through !!! */ 3304 3305 case ZFCP_ERP_ACTION_REOPEN_ADAPTER: 3306 if (atomic_test_mask 3307 (ZFCP_STATUS_COMMON_ERP_INUSE, &adapter->status)) { 3308 debug_text_event(adapter->erp_dbf, 4, "a_actenq_drp"); 3309 goto out; 3310 } 3311 break; 3312 3313 default: 3314 debug_text_exception(adapter->erp_dbf, 1, "a_actenq_bug"); 3315 debug_event(adapter->erp_dbf, 1, &action, sizeof (int)); 3316 ZFCP_LOG_NORMAL("bug: unknown erp action requested " 3317 "on adapter %s (action=%d)\n", 3318 zfcp_get_busid_by_adapter(adapter), action); 3319 goto out; 3320 } 3321 3322 /* check whether we need something stronger first */ 3323 if (stronger_action) { 3324 debug_text_event(adapter->erp_dbf, 4, "a_actenq_str"); 3325 debug_event(adapter->erp_dbf, 4, &stronger_action, 3326 sizeof (int)); 3327 ZFCP_LOG_DEBUG("stronger erp action %d needed before " 3328 "erp action %d on adapter %s\n", 3329 stronger_action, action, 3330 zfcp_get_busid_by_adapter(adapter)); 3331 action = stronger_action; 3332 } 3333 3334 /* mark adapter to have some error recovery pending */ 3335 atomic_set_mask(ZFCP_STATUS_ADAPTER_ERP_PENDING, &adapter->status); 3336 3337 /* setup error recovery action */ 3338 switch (action) { 3339 3340 case ZFCP_ERP_ACTION_REOPEN_UNIT: 3341 zfcp_unit_get(unit); 3342 atomic_set_mask(ZFCP_STATUS_COMMON_ERP_INUSE, &unit->status); 3343 erp_action = &unit->erp_action; 3344 if (!atomic_test_mask 3345 (ZFCP_STATUS_COMMON_RUNNING, &unit->status)) 3346 status = ZFCP_STATUS_ERP_CLOSE_ONLY; 3347 break; 3348 3349 case ZFCP_ERP_ACTION_REOPEN_PORT: 3350 case ZFCP_ERP_ACTION_REOPEN_PORT_FORCED: 3351 zfcp_port_get(port); 3352 zfcp_erp_action_dismiss_port(port); 3353 atomic_set_mask(ZFCP_STATUS_COMMON_ERP_INUSE, &port->status); 3354 erp_action = &port->erp_action; 3355 if (!atomic_test_mask 3356 (ZFCP_STATUS_COMMON_RUNNING, &port->status)) 3357 status = ZFCP_STATUS_ERP_CLOSE_ONLY; 3358 break; 3359 3360 case ZFCP_ERP_ACTION_REOPEN_ADAPTER: 3361 zfcp_adapter_get(adapter); 3362 zfcp_erp_action_dismiss_adapter(adapter); 3363 atomic_set_mask(ZFCP_STATUS_COMMON_ERP_INUSE, &adapter->status); 3364 erp_action = &adapter->erp_action; 3365 if (!atomic_test_mask 3366 (ZFCP_STATUS_COMMON_RUNNING, &adapter->status)) 3367 status = ZFCP_STATUS_ERP_CLOSE_ONLY; 3368 break; 3369 } 3370 3371 debug_text_event(adapter->erp_dbf, 4, "a_actenq"); 3372 3373 memset(erp_action, 0, sizeof (struct zfcp_erp_action)); 3374 erp_action->adapter = adapter; 3375 erp_action->port = port; 3376 erp_action->unit = unit; 3377 erp_action->action = action; 3378 erp_action->status = status; 3379 3380 ++adapter->erp_total_count; 3381 3382 /* finally put it into 'ready' queue and kick erp thread */ 3383 list_add(&erp_action->list, &adapter->erp_ready_head); 3384 up(&adapter->erp_ready_sem); 3385 retval = 0; 3386 out: 3387 return retval; 3388 } 3389 3390 /* 3391 * function: 3392 * 3393 * purpose: 3394 * 3395 * returns: 3396 */ 3397 static int 3398 zfcp_erp_action_dequeue(struct zfcp_erp_action *erp_action) 3399 { 3400 int retval = 0; 3401 struct zfcp_adapter *adapter = erp_action->adapter; 3402 3403 --adapter->erp_total_count; 3404 if (erp_action->status & ZFCP_STATUS_ERP_LOWMEM) { 3405 --adapter->erp_low_mem_count; 3406 erp_action->status &= ~ZFCP_STATUS_ERP_LOWMEM; 3407 } 3408 3409 debug_text_event(adapter->erp_dbf, 4, "a_actdeq"); 3410 debug_event(adapter->erp_dbf, 4, &erp_action->action, sizeof (int)); 3411 list_del(&erp_action->list); 3412 switch (erp_action->action) { 3413 case ZFCP_ERP_ACTION_REOPEN_UNIT: 3414 atomic_clear_mask(ZFCP_STATUS_COMMON_ERP_INUSE, 3415 &erp_action->unit->status); 3416 break; 3417 case ZFCP_ERP_ACTION_REOPEN_PORT_FORCED: 3418 case ZFCP_ERP_ACTION_REOPEN_PORT: 3419 atomic_clear_mask(ZFCP_STATUS_COMMON_ERP_INUSE, 3420 &erp_action->port->status); 3421 break; 3422 case ZFCP_ERP_ACTION_REOPEN_ADAPTER: 3423 atomic_clear_mask(ZFCP_STATUS_COMMON_ERP_INUSE, 3424 &erp_action->adapter->status); 3425 break; 3426 default: 3427 /* bug */ 3428 break; 3429 } 3430 return retval; 3431 } 3432 3433 /** 3434 * zfcp_erp_action_cleanup 3435 * 3436 * Register unit with scsi stack if appropiate and fix reference counts. 3437 * Note: Temporary units are not registered with scsi stack. 3438 */ 3439 static void 3440 zfcp_erp_action_cleanup(int action, struct zfcp_adapter *adapter, 3441 struct zfcp_port *port, struct zfcp_unit *unit, 3442 int result) 3443 { 3444 switch (action) { 3445 case ZFCP_ERP_ACTION_REOPEN_UNIT: 3446 if ((result == ZFCP_ERP_SUCCEEDED) 3447 && (!atomic_test_mask(ZFCP_STATUS_UNIT_TEMPORARY, 3448 &unit->status)) 3449 && !unit->device 3450 && port->rport) 3451 scsi_add_device(port->adapter->scsi_host, 0, 3452 port->rport->scsi_target_id, 3453 unit->scsi_lun); 3454 zfcp_unit_put(unit); 3455 break; 3456 case ZFCP_ERP_ACTION_REOPEN_PORT_FORCED: 3457 case ZFCP_ERP_ACTION_REOPEN_PORT: 3458 if ((result == ZFCP_ERP_SUCCEEDED) 3459 && !atomic_test_mask(ZFCP_STATUS_PORT_NO_WWPN, 3460 &port->status) 3461 && !port->rport) { 3462 struct fc_rport_identifiers ids; 3463 ids.node_name = port->wwnn; 3464 ids.port_name = port->wwpn; 3465 ids.port_id = port->d_id; 3466 ids.roles = FC_RPORT_ROLE_FCP_TARGET; 3467 port->rport = 3468 fc_remote_port_add(adapter->scsi_host, 0, &ids); 3469 if (!port->rport) 3470 ZFCP_LOG_NORMAL("failed registration of rport" 3471 "(adapter %s, wwpn=0x%016Lx)\n", 3472 zfcp_get_busid_by_port(port), 3473 port->wwpn); 3474 } 3475 zfcp_port_put(port); 3476 break; 3477 case ZFCP_ERP_ACTION_REOPEN_ADAPTER: 3478 zfcp_adapter_put(adapter); 3479 break; 3480 default: 3481 break; 3482 } 3483 } 3484 3485 3486 /* 3487 * function: 3488 * 3489 * purpose: 3490 * 3491 * returns: FIXME 3492 */ 3493 static int 3494 zfcp_erp_action_dismiss_adapter(struct zfcp_adapter *adapter) 3495 { 3496 int retval = 0; 3497 struct zfcp_port *port; 3498 3499 debug_text_event(adapter->erp_dbf, 5, "a_actab"); 3500 if (atomic_test_mask(ZFCP_STATUS_COMMON_ERP_INUSE, &adapter->status)) 3501 zfcp_erp_action_dismiss(&adapter->erp_action); 3502 else 3503 list_for_each_entry(port, &adapter->port_list_head, list) 3504 zfcp_erp_action_dismiss_port(port); 3505 3506 return retval; 3507 } 3508 3509 /* 3510 * function: 3511 * 3512 * purpose: 3513 * 3514 * returns: FIXME 3515 */ 3516 static int 3517 zfcp_erp_action_dismiss_port(struct zfcp_port *port) 3518 { 3519 int retval = 0; 3520 struct zfcp_unit *unit; 3521 struct zfcp_adapter *adapter = port->adapter; 3522 3523 debug_text_event(adapter->erp_dbf, 5, "p_actab"); 3524 debug_event(adapter->erp_dbf, 5, &port->wwpn, sizeof (wwn_t)); 3525 if (atomic_test_mask(ZFCP_STATUS_COMMON_ERP_INUSE, &port->status)) 3526 zfcp_erp_action_dismiss(&port->erp_action); 3527 else 3528 list_for_each_entry(unit, &port->unit_list_head, list) 3529 zfcp_erp_action_dismiss_unit(unit); 3530 3531 return retval; 3532 } 3533 3534 /* 3535 * function: 3536 * 3537 * purpose: 3538 * 3539 * returns: FIXME 3540 */ 3541 static int 3542 zfcp_erp_action_dismiss_unit(struct zfcp_unit *unit) 3543 { 3544 int retval = 0; 3545 struct zfcp_adapter *adapter = unit->port->adapter; 3546 3547 debug_text_event(adapter->erp_dbf, 5, "u_actab"); 3548 debug_event(adapter->erp_dbf, 5, &unit->fcp_lun, sizeof (fcp_lun_t)); 3549 if (atomic_test_mask(ZFCP_STATUS_COMMON_ERP_INUSE, &unit->status)) 3550 zfcp_erp_action_dismiss(&unit->erp_action); 3551 3552 return retval; 3553 } 3554 3555 /* 3556 * function: 3557 * 3558 * purpose: moves erp_action to 'erp running list' 3559 * 3560 * returns: 3561 */ 3562 static inline void 3563 zfcp_erp_action_to_running(struct zfcp_erp_action *erp_action) 3564 { 3565 struct zfcp_adapter *adapter = erp_action->adapter; 3566 3567 debug_text_event(adapter->erp_dbf, 6, "a_toru"); 3568 debug_event(adapter->erp_dbf, 6, &erp_action->action, sizeof (int)); 3569 list_move(&erp_action->list, &erp_action->adapter->erp_running_head); 3570 } 3571 3572 /* 3573 * function: 3574 * 3575 * purpose: moves erp_action to 'erp ready list' 3576 * 3577 * returns: 3578 */ 3579 static inline void 3580 zfcp_erp_action_to_ready(struct zfcp_erp_action *erp_action) 3581 { 3582 struct zfcp_adapter *adapter = erp_action->adapter; 3583 3584 debug_text_event(adapter->erp_dbf, 6, "a_tore"); 3585 debug_event(adapter->erp_dbf, 6, &erp_action->action, sizeof (int)); 3586 list_move(&erp_action->list, &erp_action->adapter->erp_ready_head); 3587 } 3588 3589 /* 3590 * function: zfcp_erp_port_boxed 3591 * 3592 * purpose: 3593 */ 3594 void 3595 zfcp_erp_port_boxed(struct zfcp_port *port) 3596 { 3597 struct zfcp_adapter *adapter = port->adapter; 3598 unsigned long flags; 3599 3600 debug_text_event(adapter->erp_dbf, 3, "p_access_boxed"); 3601 debug_event(adapter->erp_dbf, 3, &port->wwpn, sizeof(wwn_t)); 3602 read_lock_irqsave(&zfcp_data.config_lock, flags); 3603 zfcp_erp_modify_port_status(port, 3604 ZFCP_STATUS_COMMON_ACCESS_BOXED, 3605 ZFCP_SET); 3606 read_unlock_irqrestore(&zfcp_data.config_lock, flags); 3607 zfcp_erp_port_reopen(port, ZFCP_STATUS_COMMON_ERP_FAILED); 3608 } 3609 3610 /* 3611 * function: zfcp_erp_unit_boxed 3612 * 3613 * purpose: 3614 */ 3615 void 3616 zfcp_erp_unit_boxed(struct zfcp_unit *unit) 3617 { 3618 struct zfcp_adapter *adapter = unit->port->adapter; 3619 3620 debug_text_event(adapter->erp_dbf, 3, "u_access_boxed"); 3621 debug_event(adapter->erp_dbf, 3, &unit->fcp_lun, sizeof(fcp_lun_t)); 3622 zfcp_erp_modify_unit_status(unit, 3623 ZFCP_STATUS_COMMON_ACCESS_BOXED, 3624 ZFCP_SET); 3625 zfcp_erp_unit_reopen(unit, ZFCP_STATUS_COMMON_ERP_FAILED); 3626 } 3627 3628 /* 3629 * function: zfcp_erp_port_access_denied 3630 * 3631 * purpose: 3632 */ 3633 void 3634 zfcp_erp_port_access_denied(struct zfcp_port *port) 3635 { 3636 struct zfcp_adapter *adapter = port->adapter; 3637 unsigned long flags; 3638 3639 debug_text_event(adapter->erp_dbf, 3, "p_access_denied"); 3640 debug_event(adapter->erp_dbf, 3, &port->wwpn, sizeof(wwn_t)); 3641 read_lock_irqsave(&zfcp_data.config_lock, flags); 3642 zfcp_erp_modify_port_status(port, 3643 ZFCP_STATUS_COMMON_ERP_FAILED | 3644 ZFCP_STATUS_COMMON_ACCESS_DENIED, 3645 ZFCP_SET); 3646 read_unlock_irqrestore(&zfcp_data.config_lock, flags); 3647 } 3648 3649 /* 3650 * function: zfcp_erp_unit_access_denied 3651 * 3652 * purpose: 3653 */ 3654 void 3655 zfcp_erp_unit_access_denied(struct zfcp_unit *unit) 3656 { 3657 struct zfcp_adapter *adapter = unit->port->adapter; 3658 3659 debug_text_event(adapter->erp_dbf, 3, "u_access_denied"); 3660 debug_event(adapter->erp_dbf, 3, &unit->fcp_lun, sizeof(fcp_lun_t)); 3661 zfcp_erp_modify_unit_status(unit, 3662 ZFCP_STATUS_COMMON_ERP_FAILED | 3663 ZFCP_STATUS_COMMON_ACCESS_DENIED, 3664 ZFCP_SET); 3665 } 3666 3667 /* 3668 * function: zfcp_erp_adapter_access_changed 3669 * 3670 * purpose: 3671 */ 3672 void 3673 zfcp_erp_adapter_access_changed(struct zfcp_adapter *adapter) 3674 { 3675 struct zfcp_port *port; 3676 unsigned long flags; 3677 3678 if (adapter->connection_features & FSF_FEATURE_NPIV_MODE) 3679 return; 3680 3681 debug_text_event(adapter->erp_dbf, 3, "a_access_recover"); 3682 debug_event(adapter->erp_dbf, 3, &adapter->name, 8); 3683 3684 read_lock_irqsave(&zfcp_data.config_lock, flags); 3685 if (adapter->nameserver_port) 3686 zfcp_erp_port_access_changed(adapter->nameserver_port); 3687 list_for_each_entry(port, &adapter->port_list_head, list) 3688 if (port != adapter->nameserver_port) 3689 zfcp_erp_port_access_changed(port); 3690 read_unlock_irqrestore(&zfcp_data.config_lock, flags); 3691 } 3692 3693 /* 3694 * function: zfcp_erp_port_access_changed 3695 * 3696 * purpose: 3697 */ 3698 void 3699 zfcp_erp_port_access_changed(struct zfcp_port *port) 3700 { 3701 struct zfcp_adapter *adapter = port->adapter; 3702 struct zfcp_unit *unit; 3703 3704 debug_text_event(adapter->erp_dbf, 3, "p_access_recover"); 3705 debug_event(adapter->erp_dbf, 3, &port->wwpn, sizeof(wwn_t)); 3706 3707 if (!atomic_test_mask(ZFCP_STATUS_COMMON_ACCESS_DENIED, 3708 &port->status) && 3709 !atomic_test_mask(ZFCP_STATUS_COMMON_ACCESS_BOXED, 3710 &port->status)) { 3711 if (!atomic_test_mask(ZFCP_STATUS_PORT_WKA, &port->status)) 3712 list_for_each_entry(unit, &port->unit_list_head, list) 3713 zfcp_erp_unit_access_changed(unit); 3714 return; 3715 } 3716 3717 ZFCP_LOG_NORMAL("reopen of port 0x%016Lx on adapter %s " 3718 "(due to ACT update)\n", 3719 port->wwpn, zfcp_get_busid_by_adapter(adapter)); 3720 if (zfcp_erp_port_reopen(port, ZFCP_STATUS_COMMON_ERP_FAILED) != 0) 3721 ZFCP_LOG_NORMAL("failed reopen of port" 3722 "(adapter %s, wwpn=0x%016Lx)\n", 3723 zfcp_get_busid_by_adapter(adapter), port->wwpn); 3724 } 3725 3726 /* 3727 * function: zfcp_erp_unit_access_changed 3728 * 3729 * purpose: 3730 */ 3731 void 3732 zfcp_erp_unit_access_changed(struct zfcp_unit *unit) 3733 { 3734 struct zfcp_adapter *adapter = unit->port->adapter; 3735 3736 debug_text_event(adapter->erp_dbf, 3, "u_access_recover"); 3737 debug_event(adapter->erp_dbf, 3, &unit->fcp_lun, sizeof(fcp_lun_t)); 3738 3739 if (!atomic_test_mask(ZFCP_STATUS_COMMON_ACCESS_DENIED, 3740 &unit->status) && 3741 !atomic_test_mask(ZFCP_STATUS_COMMON_ACCESS_BOXED, 3742 &unit->status)) 3743 return; 3744 3745 ZFCP_LOG_NORMAL("reopen of unit 0x%016Lx on port 0x%016Lx " 3746 " on adapter %s (due to ACT update)\n", 3747 unit->fcp_lun, unit->port->wwpn, 3748 zfcp_get_busid_by_adapter(adapter)); 3749 if (zfcp_erp_unit_reopen(unit, ZFCP_STATUS_COMMON_ERP_FAILED) != 0) 3750 ZFCP_LOG_NORMAL("failed reopen of unit (adapter %s, " 3751 "wwpn=0x%016Lx, fcp_lun=0x%016Lx)\n", 3752 zfcp_get_busid_by_adapter(adapter), 3753 unit->port->wwpn, unit->fcp_lun); 3754 } 3755 3756 #undef ZFCP_LOG_AREA 3757