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