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