1 /* 2 * zfcp device driver 3 * 4 * Error Recovery Procedures (ERP). 5 * 6 * Copyright IBM Corporation 2002, 2008 7 */ 8 9 #include "zfcp_ext.h" 10 11 #define ZFCP_MAX_ERPS 3 12 13 enum zfcp_erp_act_flags { 14 ZFCP_STATUS_ERP_TIMEDOUT = 0x10000000, 15 ZFCP_STATUS_ERP_CLOSE_ONLY = 0x01000000, 16 ZFCP_STATUS_ERP_DISMISSING = 0x00100000, 17 ZFCP_STATUS_ERP_DISMISSED = 0x00200000, 18 ZFCP_STATUS_ERP_LOWMEM = 0x00400000, 19 }; 20 21 enum zfcp_erp_steps { 22 ZFCP_ERP_STEP_UNINITIALIZED = 0x0000, 23 ZFCP_ERP_STEP_FSF_XCONFIG = 0x0001, 24 ZFCP_ERP_STEP_PHYS_PORT_CLOSING = 0x0010, 25 ZFCP_ERP_STEP_PORT_CLOSING = 0x0100, 26 ZFCP_ERP_STEP_NAMESERVER_LOOKUP = 0x0400, 27 ZFCP_ERP_STEP_PORT_OPENING = 0x0800, 28 ZFCP_ERP_STEP_UNIT_CLOSING = 0x1000, 29 ZFCP_ERP_STEP_UNIT_OPENING = 0x2000, 30 }; 31 32 enum zfcp_erp_act_type { 33 ZFCP_ERP_ACTION_REOPEN_UNIT = 1, 34 ZFCP_ERP_ACTION_REOPEN_PORT = 2, 35 ZFCP_ERP_ACTION_REOPEN_PORT_FORCED = 3, 36 ZFCP_ERP_ACTION_REOPEN_ADAPTER = 4, 37 }; 38 39 enum zfcp_erp_act_state { 40 ZFCP_ERP_ACTION_RUNNING = 1, 41 ZFCP_ERP_ACTION_READY = 2, 42 }; 43 44 enum zfcp_erp_act_result { 45 ZFCP_ERP_SUCCEEDED = 0, 46 ZFCP_ERP_FAILED = 1, 47 ZFCP_ERP_CONTINUES = 2, 48 ZFCP_ERP_EXIT = 3, 49 ZFCP_ERP_DISMISSED = 4, 50 ZFCP_ERP_NOMEM = 5, 51 }; 52 53 static void zfcp_erp_adapter_block(struct zfcp_adapter *adapter, int mask) 54 { 55 zfcp_erp_modify_adapter_status(adapter, 15, NULL, 56 ZFCP_STATUS_COMMON_UNBLOCKED | mask, 57 ZFCP_CLEAR); 58 } 59 60 static int zfcp_erp_action_exists(struct zfcp_erp_action *act) 61 { 62 struct zfcp_erp_action *curr_act; 63 64 list_for_each_entry(curr_act, &act->adapter->erp_running_head, list) 65 if (act == curr_act) 66 return ZFCP_ERP_ACTION_RUNNING; 67 return 0; 68 } 69 70 static void zfcp_erp_action_ready(struct zfcp_erp_action *act) 71 { 72 struct zfcp_adapter *adapter = act->adapter; 73 74 list_move(&act->list, &act->adapter->erp_ready_head); 75 zfcp_rec_dbf_event_action(146, act); 76 up(&adapter->erp_ready_sem); 77 zfcp_rec_dbf_event_thread(2, adapter); 78 } 79 80 static void zfcp_erp_action_dismiss(struct zfcp_erp_action *act) 81 { 82 act->status |= ZFCP_STATUS_ERP_DISMISSED; 83 if (zfcp_erp_action_exists(act) == ZFCP_ERP_ACTION_RUNNING) 84 zfcp_erp_action_ready(act); 85 } 86 87 static void zfcp_erp_action_dismiss_unit(struct zfcp_unit *unit) 88 { 89 if (atomic_read(&unit->status) & ZFCP_STATUS_COMMON_ERP_INUSE) 90 zfcp_erp_action_dismiss(&unit->erp_action); 91 } 92 93 static void zfcp_erp_action_dismiss_port(struct zfcp_port *port) 94 { 95 struct zfcp_unit *unit; 96 97 if (atomic_read(&port->status) & ZFCP_STATUS_COMMON_ERP_INUSE) 98 zfcp_erp_action_dismiss(&port->erp_action); 99 else 100 list_for_each_entry(unit, &port->unit_list_head, list) 101 zfcp_erp_action_dismiss_unit(unit); 102 } 103 104 static void zfcp_erp_action_dismiss_adapter(struct zfcp_adapter *adapter) 105 { 106 struct zfcp_port *port; 107 108 if (atomic_read(&adapter->status) & ZFCP_STATUS_COMMON_ERP_INUSE) 109 zfcp_erp_action_dismiss(&adapter->erp_action); 110 else 111 list_for_each_entry(port, &adapter->port_list_head, list) 112 zfcp_erp_action_dismiss_port(port); 113 } 114 115 static int zfcp_erp_required_act(int want, struct zfcp_adapter *adapter, 116 struct zfcp_port *port, 117 struct zfcp_unit *unit) 118 { 119 int need = want; 120 int u_status, p_status, a_status; 121 122 switch (want) { 123 case ZFCP_ERP_ACTION_REOPEN_UNIT: 124 u_status = atomic_read(&unit->status); 125 if (u_status & ZFCP_STATUS_COMMON_ERP_INUSE) 126 return 0; 127 p_status = atomic_read(&port->status); 128 if (!(p_status & ZFCP_STATUS_COMMON_RUNNING) || 129 p_status & ZFCP_STATUS_COMMON_ERP_FAILED) 130 return 0; 131 if (!(p_status & ZFCP_STATUS_COMMON_UNBLOCKED)) 132 need = ZFCP_ERP_ACTION_REOPEN_PORT; 133 /* fall through */ 134 case ZFCP_ERP_ACTION_REOPEN_PORT: 135 case ZFCP_ERP_ACTION_REOPEN_PORT_FORCED: 136 p_status = atomic_read(&port->status); 137 if (p_status & ZFCP_STATUS_COMMON_ERP_INUSE) 138 return 0; 139 a_status = atomic_read(&adapter->status); 140 if (!(a_status & ZFCP_STATUS_COMMON_RUNNING) || 141 a_status & ZFCP_STATUS_COMMON_ERP_FAILED) 142 return 0; 143 if (!(a_status & ZFCP_STATUS_COMMON_UNBLOCKED)) 144 need = ZFCP_ERP_ACTION_REOPEN_ADAPTER; 145 /* fall through */ 146 case ZFCP_ERP_ACTION_REOPEN_ADAPTER: 147 a_status = atomic_read(&adapter->status); 148 if (a_status & ZFCP_STATUS_COMMON_ERP_INUSE) 149 return 0; 150 } 151 152 return need; 153 } 154 155 static struct zfcp_erp_action *zfcp_erp_setup_act(int need, 156 struct zfcp_adapter *adapter, 157 struct zfcp_port *port, 158 struct zfcp_unit *unit) 159 { 160 struct zfcp_erp_action *erp_action; 161 u32 status = 0; 162 163 switch (need) { 164 case ZFCP_ERP_ACTION_REOPEN_UNIT: 165 zfcp_unit_get(unit); 166 atomic_set_mask(ZFCP_STATUS_COMMON_ERP_INUSE, &unit->status); 167 erp_action = &unit->erp_action; 168 if (!(atomic_read(&unit->status) & ZFCP_STATUS_COMMON_RUNNING)) 169 status = ZFCP_STATUS_ERP_CLOSE_ONLY; 170 break; 171 172 case ZFCP_ERP_ACTION_REOPEN_PORT: 173 case ZFCP_ERP_ACTION_REOPEN_PORT_FORCED: 174 zfcp_port_get(port); 175 zfcp_erp_action_dismiss_port(port); 176 atomic_set_mask(ZFCP_STATUS_COMMON_ERP_INUSE, &port->status); 177 erp_action = &port->erp_action; 178 if (!(atomic_read(&port->status) & ZFCP_STATUS_COMMON_RUNNING)) 179 status = ZFCP_STATUS_ERP_CLOSE_ONLY; 180 break; 181 182 case ZFCP_ERP_ACTION_REOPEN_ADAPTER: 183 zfcp_adapter_get(adapter); 184 zfcp_erp_action_dismiss_adapter(adapter); 185 atomic_set_mask(ZFCP_STATUS_COMMON_ERP_INUSE, &adapter->status); 186 erp_action = &adapter->erp_action; 187 if (!(atomic_read(&adapter->status) & 188 ZFCP_STATUS_COMMON_RUNNING)) 189 status = ZFCP_STATUS_ERP_CLOSE_ONLY; 190 break; 191 192 default: 193 return NULL; 194 } 195 196 memset(erp_action, 0, sizeof(struct zfcp_erp_action)); 197 erp_action->adapter = adapter; 198 erp_action->port = port; 199 erp_action->unit = unit; 200 erp_action->action = need; 201 erp_action->status = status; 202 203 return erp_action; 204 } 205 206 static int zfcp_erp_action_enqueue(int want, struct zfcp_adapter *adapter, 207 struct zfcp_port *port, 208 struct zfcp_unit *unit, u8 id, void *ref) 209 { 210 int retval = 1, need; 211 struct zfcp_erp_action *act = NULL; 212 213 if (!(atomic_read(&adapter->status) & 214 ZFCP_STATUS_ADAPTER_ERP_THREAD_UP)) 215 return -EIO; 216 217 need = zfcp_erp_required_act(want, adapter, port, unit); 218 if (!need) 219 goto out; 220 221 atomic_set_mask(ZFCP_STATUS_ADAPTER_ERP_PENDING, &adapter->status); 222 act = zfcp_erp_setup_act(need, adapter, port, unit); 223 if (!act) 224 goto out; 225 ++adapter->erp_total_count; 226 list_add_tail(&act->list, &adapter->erp_ready_head); 227 up(&adapter->erp_ready_sem); 228 zfcp_rec_dbf_event_thread(1, adapter); 229 retval = 0; 230 out: 231 zfcp_rec_dbf_event_trigger(id, ref, want, need, act, 232 adapter, port, unit); 233 return retval; 234 } 235 236 static int _zfcp_erp_adapter_reopen(struct zfcp_adapter *adapter, 237 int clear_mask, u8 id, void *ref) 238 { 239 zfcp_erp_adapter_block(adapter, clear_mask); 240 241 /* ensure propagation of failed status to new devices */ 242 if (atomic_read(&adapter->status) & ZFCP_STATUS_COMMON_ERP_FAILED) { 243 zfcp_erp_adapter_failed(adapter, 13, NULL); 244 return -EIO; 245 } 246 return zfcp_erp_action_enqueue(ZFCP_ERP_ACTION_REOPEN_ADAPTER, 247 adapter, NULL, NULL, id, ref); 248 } 249 250 /** 251 * zfcp_erp_adapter_reopen - Reopen adapter. 252 * @adapter: Adapter to reopen. 253 * @clear: Status flags to clear. 254 * @id: Id for debug trace event. 255 * @ref: Reference for debug trace event. 256 */ 257 void zfcp_erp_adapter_reopen(struct zfcp_adapter *adapter, int clear, 258 u8 id, void *ref) 259 { 260 unsigned long flags; 261 262 read_lock_irqsave(&zfcp_data.config_lock, flags); 263 write_lock(&adapter->erp_lock); 264 _zfcp_erp_adapter_reopen(adapter, clear, id, ref); 265 write_unlock(&adapter->erp_lock); 266 read_unlock_irqrestore(&zfcp_data.config_lock, flags); 267 } 268 269 /** 270 * zfcp_erp_adapter_shutdown - Shutdown adapter. 271 * @adapter: Adapter to shut down. 272 * @clear: Status flags to clear. 273 * @id: Id for debug trace event. 274 * @ref: Reference for debug trace event. 275 */ 276 void zfcp_erp_adapter_shutdown(struct zfcp_adapter *adapter, int clear, 277 u8 id, void *ref) 278 { 279 int flags = ZFCP_STATUS_COMMON_RUNNING | ZFCP_STATUS_COMMON_ERP_FAILED; 280 zfcp_erp_adapter_reopen(adapter, clear | flags, id, ref); 281 } 282 283 /** 284 * zfcp_erp_port_shutdown - Shutdown port 285 * @port: Port to shut down. 286 * @clear: Status flags to clear. 287 * @id: Id for debug trace event. 288 * @ref: Reference for debug trace event. 289 */ 290 void zfcp_erp_port_shutdown(struct zfcp_port *port, int clear, u8 id, void *ref) 291 { 292 int flags = ZFCP_STATUS_COMMON_RUNNING | ZFCP_STATUS_COMMON_ERP_FAILED; 293 zfcp_erp_port_reopen(port, clear | flags, id, ref); 294 } 295 296 /** 297 * zfcp_erp_unit_shutdown - Shutdown unit 298 * @unit: Unit to shut down. 299 * @clear: Status flags to clear. 300 * @id: Id for debug trace event. 301 * @ref: Reference for debug trace event. 302 */ 303 void zfcp_erp_unit_shutdown(struct zfcp_unit *unit, int clear, u8 id, void *ref) 304 { 305 int flags = ZFCP_STATUS_COMMON_RUNNING | ZFCP_STATUS_COMMON_ERP_FAILED; 306 zfcp_erp_unit_reopen(unit, clear | flags, id, ref); 307 } 308 309 static void zfcp_erp_port_block(struct zfcp_port *port, int clear) 310 { 311 zfcp_erp_modify_port_status(port, 17, NULL, 312 ZFCP_STATUS_COMMON_UNBLOCKED | clear, 313 ZFCP_CLEAR); 314 } 315 316 static void _zfcp_erp_port_forced_reopen(struct zfcp_port *port, 317 int clear, u8 id, void *ref) 318 { 319 zfcp_erp_port_block(port, clear); 320 321 if (atomic_read(&port->status) & ZFCP_STATUS_COMMON_ERP_FAILED) 322 return; 323 324 zfcp_erp_action_enqueue(ZFCP_ERP_ACTION_REOPEN_PORT_FORCED, 325 port->adapter, port, NULL, id, ref); 326 } 327 328 /** 329 * zfcp_erp_port_forced_reopen - Forced close of port and open again 330 * @port: Port to force close and to reopen. 331 * @id: Id for debug trace event. 332 * @ref: Reference for debug trace event. 333 */ 334 void zfcp_erp_port_forced_reopen(struct zfcp_port *port, int clear, u8 id, 335 void *ref) 336 { 337 unsigned long flags; 338 struct zfcp_adapter *adapter = port->adapter; 339 340 read_lock_irqsave(&zfcp_data.config_lock, flags); 341 write_lock(&adapter->erp_lock); 342 _zfcp_erp_port_forced_reopen(port, clear, id, ref); 343 write_unlock(&adapter->erp_lock); 344 read_unlock_irqrestore(&zfcp_data.config_lock, flags); 345 } 346 347 static int _zfcp_erp_port_reopen(struct zfcp_port *port, int clear, u8 id, 348 void *ref) 349 { 350 zfcp_erp_port_block(port, clear); 351 352 if (atomic_read(&port->status) & ZFCP_STATUS_COMMON_ERP_FAILED) { 353 /* ensure propagation of failed status to new devices */ 354 zfcp_erp_port_failed(port, 14, NULL); 355 return -EIO; 356 } 357 358 return zfcp_erp_action_enqueue(ZFCP_ERP_ACTION_REOPEN_PORT, 359 port->adapter, port, NULL, id, ref); 360 } 361 362 /** 363 * zfcp_erp_port_reopen - trigger remote port recovery 364 * @port: port to recover 365 * @clear_mask: flags in port status to be cleared 366 * 367 * Returns 0 if recovery has been triggered, < 0 if not. 368 */ 369 int zfcp_erp_port_reopen(struct zfcp_port *port, int clear, u8 id, void *ref) 370 { 371 unsigned long flags; 372 int retval; 373 struct zfcp_adapter *adapter = port->adapter; 374 375 read_lock_irqsave(&zfcp_data.config_lock, flags); 376 write_lock(&adapter->erp_lock); 377 retval = _zfcp_erp_port_reopen(port, clear, id, ref); 378 write_unlock(&adapter->erp_lock); 379 read_unlock_irqrestore(&zfcp_data.config_lock, flags); 380 381 return retval; 382 } 383 384 static void zfcp_erp_unit_block(struct zfcp_unit *unit, int clear_mask) 385 { 386 zfcp_erp_modify_unit_status(unit, 19, NULL, 387 ZFCP_STATUS_COMMON_UNBLOCKED | clear_mask, 388 ZFCP_CLEAR); 389 } 390 391 static void _zfcp_erp_unit_reopen(struct zfcp_unit *unit, int clear, u8 id, 392 void *ref) 393 { 394 struct zfcp_adapter *adapter = unit->port->adapter; 395 396 zfcp_erp_unit_block(unit, clear); 397 398 if (atomic_read(&unit->status) & ZFCP_STATUS_COMMON_ERP_FAILED) 399 return; 400 401 zfcp_erp_action_enqueue(ZFCP_ERP_ACTION_REOPEN_UNIT, 402 adapter, unit->port, unit, id, ref); 403 } 404 405 /** 406 * zfcp_erp_unit_reopen - initiate reopen of a unit 407 * @unit: unit to be reopened 408 * @clear_mask: specifies flags in unit status to be cleared 409 * Return: 0 on success, < 0 on error 410 */ 411 void zfcp_erp_unit_reopen(struct zfcp_unit *unit, int clear, u8 id, void *ref) 412 { 413 unsigned long flags; 414 struct zfcp_port *port = unit->port; 415 struct zfcp_adapter *adapter = port->adapter; 416 417 read_lock_irqsave(&zfcp_data.config_lock, flags); 418 write_lock(&adapter->erp_lock); 419 _zfcp_erp_unit_reopen(unit, clear, id, ref); 420 write_unlock(&adapter->erp_lock); 421 read_unlock_irqrestore(&zfcp_data.config_lock, flags); 422 } 423 424 static int status_change_set(unsigned long mask, atomic_t *status) 425 { 426 return (atomic_read(status) ^ mask) & mask; 427 } 428 429 static int status_change_clear(unsigned long mask, atomic_t *status) 430 { 431 return atomic_read(status) & mask; 432 } 433 434 static void zfcp_erp_adapter_unblock(struct zfcp_adapter *adapter) 435 { 436 if (status_change_set(ZFCP_STATUS_COMMON_UNBLOCKED, &adapter->status)) 437 zfcp_rec_dbf_event_adapter(16, NULL, adapter); 438 atomic_set_mask(ZFCP_STATUS_COMMON_UNBLOCKED, &adapter->status); 439 } 440 441 static void zfcp_erp_port_unblock(struct zfcp_port *port) 442 { 443 if (status_change_set(ZFCP_STATUS_COMMON_UNBLOCKED, &port->status)) 444 zfcp_rec_dbf_event_port(18, NULL, port); 445 atomic_set_mask(ZFCP_STATUS_COMMON_UNBLOCKED, &port->status); 446 } 447 448 static void zfcp_erp_unit_unblock(struct zfcp_unit *unit) 449 { 450 if (status_change_set(ZFCP_STATUS_COMMON_UNBLOCKED, &unit->status)) 451 zfcp_rec_dbf_event_unit(20, NULL, unit); 452 atomic_set_mask(ZFCP_STATUS_COMMON_UNBLOCKED, &unit->status); 453 } 454 455 static void zfcp_erp_action_to_running(struct zfcp_erp_action *erp_action) 456 { 457 list_move(&erp_action->list, &erp_action->adapter->erp_running_head); 458 zfcp_rec_dbf_event_action(145, erp_action); 459 } 460 461 static void zfcp_erp_strategy_check_fsfreq(struct zfcp_erp_action *act) 462 { 463 struct zfcp_adapter *adapter = act->adapter; 464 465 if (!act->fsf_req) 466 return; 467 468 spin_lock(&adapter->req_list_lock); 469 if (zfcp_reqlist_find_safe(adapter, act->fsf_req) && 470 act->fsf_req->erp_action == act) { 471 if (act->status & (ZFCP_STATUS_ERP_DISMISSED | 472 ZFCP_STATUS_ERP_TIMEDOUT)) { 473 act->fsf_req->status |= ZFCP_STATUS_FSFREQ_DISMISSED; 474 zfcp_rec_dbf_event_action(142, act); 475 } 476 if (act->status & ZFCP_STATUS_ERP_TIMEDOUT) 477 zfcp_rec_dbf_event_action(143, act); 478 if (act->fsf_req->status & (ZFCP_STATUS_FSFREQ_COMPLETED | 479 ZFCP_STATUS_FSFREQ_DISMISSED)) 480 act->fsf_req = NULL; 481 } else 482 act->fsf_req = NULL; 483 spin_unlock(&adapter->req_list_lock); 484 } 485 486 /** 487 * zfcp_erp_notify - Trigger ERP action. 488 * @erp_action: ERP action to continue. 489 * @set_mask: ERP action status flags to set. 490 */ 491 void zfcp_erp_notify(struct zfcp_erp_action *erp_action, unsigned long set_mask) 492 { 493 struct zfcp_adapter *adapter = erp_action->adapter; 494 unsigned long flags; 495 496 write_lock_irqsave(&adapter->erp_lock, flags); 497 if (zfcp_erp_action_exists(erp_action) == ZFCP_ERP_ACTION_RUNNING) { 498 erp_action->status |= set_mask; 499 zfcp_erp_action_ready(erp_action); 500 } 501 write_unlock_irqrestore(&adapter->erp_lock, flags); 502 } 503 504 /** 505 * zfcp_erp_timeout_handler - Trigger ERP action from timed out ERP request 506 * @data: ERP action (from timer data) 507 */ 508 void zfcp_erp_timeout_handler(unsigned long data) 509 { 510 struct zfcp_erp_action *act = (struct zfcp_erp_action *) data; 511 zfcp_erp_notify(act, ZFCP_STATUS_ERP_TIMEDOUT); 512 } 513 514 static void zfcp_erp_memwait_handler(unsigned long data) 515 { 516 zfcp_erp_notify((struct zfcp_erp_action *)data, 0); 517 } 518 519 static void zfcp_erp_strategy_memwait(struct zfcp_erp_action *erp_action) 520 { 521 init_timer(&erp_action->timer); 522 erp_action->timer.function = zfcp_erp_memwait_handler; 523 erp_action->timer.data = (unsigned long) erp_action; 524 erp_action->timer.expires = jiffies + HZ; 525 add_timer(&erp_action->timer); 526 } 527 528 static void _zfcp_erp_port_reopen_all(struct zfcp_adapter *adapter, 529 int clear, u8 id, void *ref) 530 { 531 struct zfcp_port *port; 532 533 list_for_each_entry(port, &adapter->port_list_head, list) 534 _zfcp_erp_port_reopen(port, clear, id, ref); 535 } 536 537 static void _zfcp_erp_unit_reopen_all(struct zfcp_port *port, int clear, u8 id, 538 void *ref) 539 { 540 struct zfcp_unit *unit; 541 542 list_for_each_entry(unit, &port->unit_list_head, list) 543 _zfcp_erp_unit_reopen(unit, clear, id, ref); 544 } 545 546 static void zfcp_erp_strategy_followup_actions(struct zfcp_erp_action *act) 547 { 548 struct zfcp_adapter *adapter = act->adapter; 549 struct zfcp_port *port = act->port; 550 struct zfcp_unit *unit = act->unit; 551 u32 status = act->status; 552 553 /* initiate follow-up actions depending on success of finished action */ 554 switch (act->action) { 555 556 case ZFCP_ERP_ACTION_REOPEN_ADAPTER: 557 if (status == ZFCP_ERP_SUCCEEDED) 558 _zfcp_erp_port_reopen_all(adapter, 0, 70, NULL); 559 else 560 _zfcp_erp_adapter_reopen(adapter, 0, 71, NULL); 561 break; 562 563 case ZFCP_ERP_ACTION_REOPEN_PORT_FORCED: 564 if (status == ZFCP_ERP_SUCCEEDED) 565 _zfcp_erp_port_reopen(port, 0, 72, NULL); 566 else 567 _zfcp_erp_adapter_reopen(adapter, 0, 73, NULL); 568 break; 569 570 case ZFCP_ERP_ACTION_REOPEN_PORT: 571 if (status == ZFCP_ERP_SUCCEEDED) 572 _zfcp_erp_unit_reopen_all(port, 0, 74, NULL); 573 else 574 _zfcp_erp_port_forced_reopen(port, 0, 75, NULL); 575 break; 576 577 case ZFCP_ERP_ACTION_REOPEN_UNIT: 578 if (status != ZFCP_ERP_SUCCEEDED) 579 _zfcp_erp_port_reopen(unit->port, 0, 76, NULL); 580 break; 581 } 582 } 583 584 static void zfcp_erp_wakeup(struct zfcp_adapter *adapter) 585 { 586 unsigned long flags; 587 588 read_lock_irqsave(&zfcp_data.config_lock, flags); 589 read_lock(&adapter->erp_lock); 590 if (list_empty(&adapter->erp_ready_head) && 591 list_empty(&adapter->erp_running_head)) { 592 atomic_clear_mask(ZFCP_STATUS_ADAPTER_ERP_PENDING, 593 &adapter->status); 594 wake_up(&adapter->erp_done_wqh); 595 } 596 read_unlock(&adapter->erp_lock); 597 read_unlock_irqrestore(&zfcp_data.config_lock, flags); 598 } 599 600 static int zfcp_erp_adapter_strategy_open_qdio(struct zfcp_erp_action *act) 601 { 602 if (zfcp_qdio_open(act->adapter)) 603 return ZFCP_ERP_FAILED; 604 init_waitqueue_head(&act->adapter->request_wq); 605 atomic_set_mask(ZFCP_STATUS_ADAPTER_QDIOUP, &act->adapter->status); 606 return ZFCP_ERP_SUCCEEDED; 607 } 608 609 static void zfcp_erp_enqueue_ptp_port(struct zfcp_adapter *adapter) 610 { 611 struct zfcp_port *port; 612 port = zfcp_port_enqueue(adapter, adapter->peer_wwpn, 0, 613 adapter->peer_d_id); 614 if (IS_ERR(port)) /* error or port already attached */ 615 return; 616 _zfcp_erp_port_reopen(port, 0, 150, NULL); 617 } 618 619 static int zfcp_erp_adapter_strat_fsf_xconf(struct zfcp_erp_action *erp_action) 620 { 621 int retries; 622 int sleep = 1; 623 struct zfcp_adapter *adapter = erp_action->adapter; 624 625 atomic_clear_mask(ZFCP_STATUS_ADAPTER_XCONFIG_OK, &adapter->status); 626 627 for (retries = 7; retries; retries--) { 628 atomic_clear_mask(ZFCP_STATUS_ADAPTER_HOST_CON_INIT, 629 &adapter->status); 630 write_lock_irq(&adapter->erp_lock); 631 zfcp_erp_action_to_running(erp_action); 632 write_unlock_irq(&adapter->erp_lock); 633 if (zfcp_fsf_exchange_config_data(erp_action)) { 634 atomic_clear_mask(ZFCP_STATUS_ADAPTER_HOST_CON_INIT, 635 &adapter->status); 636 return ZFCP_ERP_FAILED; 637 } 638 639 zfcp_rec_dbf_event_thread_lock(6, adapter); 640 down(&adapter->erp_ready_sem); 641 zfcp_rec_dbf_event_thread_lock(7, adapter); 642 if (erp_action->status & ZFCP_STATUS_ERP_TIMEDOUT) 643 break; 644 645 if (!(atomic_read(&adapter->status) & 646 ZFCP_STATUS_ADAPTER_HOST_CON_INIT)) 647 break; 648 649 ssleep(sleep); 650 sleep *= 2; 651 } 652 653 atomic_clear_mask(ZFCP_STATUS_ADAPTER_HOST_CON_INIT, 654 &adapter->status); 655 656 if (!(atomic_read(&adapter->status) & ZFCP_STATUS_ADAPTER_XCONFIG_OK)) 657 return ZFCP_ERP_FAILED; 658 659 if (fc_host_port_type(adapter->scsi_host) == FC_PORTTYPE_PTP) 660 zfcp_erp_enqueue_ptp_port(adapter); 661 662 return ZFCP_ERP_SUCCEEDED; 663 } 664 665 static int zfcp_erp_adapter_strategy_open_fsf_xport(struct zfcp_erp_action *act) 666 { 667 int ret; 668 struct zfcp_adapter *adapter = act->adapter; 669 670 write_lock_irq(&adapter->erp_lock); 671 zfcp_erp_action_to_running(act); 672 write_unlock_irq(&adapter->erp_lock); 673 674 ret = zfcp_fsf_exchange_port_data(act); 675 if (ret == -EOPNOTSUPP) 676 return ZFCP_ERP_SUCCEEDED; 677 if (ret) 678 return ZFCP_ERP_FAILED; 679 680 zfcp_rec_dbf_event_thread_lock(8, adapter); 681 down(&adapter->erp_ready_sem); 682 zfcp_rec_dbf_event_thread_lock(9, adapter); 683 if (act->status & ZFCP_STATUS_ERP_TIMEDOUT) 684 return ZFCP_ERP_FAILED; 685 686 return ZFCP_ERP_SUCCEEDED; 687 } 688 689 static int zfcp_erp_adapter_strategy_open_fsf(struct zfcp_erp_action *act) 690 { 691 if (zfcp_erp_adapter_strat_fsf_xconf(act) == ZFCP_ERP_FAILED) 692 return ZFCP_ERP_FAILED; 693 694 if (zfcp_erp_adapter_strategy_open_fsf_xport(act) == ZFCP_ERP_FAILED) 695 return ZFCP_ERP_FAILED; 696 697 atomic_set(&act->adapter->stat_miss, 16); 698 if (zfcp_status_read_refill(act->adapter)) 699 return ZFCP_ERP_FAILED; 700 701 return ZFCP_ERP_SUCCEEDED; 702 } 703 704 static int zfcp_erp_adapter_strategy_generic(struct zfcp_erp_action *act, 705 int close) 706 { 707 int retval = ZFCP_ERP_SUCCEEDED; 708 struct zfcp_adapter *adapter = act->adapter; 709 710 if (close) 711 goto close_only; 712 713 retval = zfcp_erp_adapter_strategy_open_qdio(act); 714 if (retval != ZFCP_ERP_SUCCEEDED) 715 goto failed_qdio; 716 717 retval = zfcp_erp_adapter_strategy_open_fsf(act); 718 if (retval != ZFCP_ERP_SUCCEEDED) 719 goto failed_openfcp; 720 721 atomic_set_mask(ZFCP_STATUS_COMMON_OPEN, &act->adapter->status); 722 schedule_work(&act->adapter->scan_work); 723 724 return ZFCP_ERP_SUCCEEDED; 725 726 close_only: 727 atomic_clear_mask(ZFCP_STATUS_COMMON_OPEN, 728 &act->adapter->status); 729 730 failed_openfcp: 731 /* close queues to ensure that buffers are not accessed by adapter */ 732 zfcp_qdio_close(adapter); 733 zfcp_fsf_req_dismiss_all(adapter); 734 adapter->fsf_req_seq_no = 0; 735 /* all ports and units are closed */ 736 zfcp_erp_modify_adapter_status(adapter, 24, NULL, 737 ZFCP_STATUS_COMMON_OPEN, ZFCP_CLEAR); 738 failed_qdio: 739 atomic_clear_mask(ZFCP_STATUS_ADAPTER_XCONFIG_OK | 740 ZFCP_STATUS_ADAPTER_LINK_UNPLUGGED, 741 &act->adapter->status); 742 return retval; 743 } 744 745 static int zfcp_erp_adapter_strategy(struct zfcp_erp_action *act) 746 { 747 int retval; 748 749 zfcp_erp_adapter_strategy_generic(act, 1); /* close */ 750 if (act->status & ZFCP_STATUS_ERP_CLOSE_ONLY) 751 return ZFCP_ERP_EXIT; 752 753 retval = zfcp_erp_adapter_strategy_generic(act, 0); /* open */ 754 755 if (retval == ZFCP_ERP_FAILED) 756 ssleep(8); 757 758 return retval; 759 } 760 761 static int zfcp_erp_port_forced_strategy_close(struct zfcp_erp_action *act) 762 { 763 int retval; 764 765 retval = zfcp_fsf_close_physical_port(act); 766 if (retval == -ENOMEM) 767 return ZFCP_ERP_NOMEM; 768 act->step = ZFCP_ERP_STEP_PHYS_PORT_CLOSING; 769 if (retval) 770 return ZFCP_ERP_FAILED; 771 772 return ZFCP_ERP_CONTINUES; 773 } 774 775 static void zfcp_erp_port_strategy_clearstati(struct zfcp_port *port) 776 { 777 atomic_clear_mask(ZFCP_STATUS_COMMON_ACCESS_DENIED | 778 ZFCP_STATUS_PORT_PHYS_CLOSING | 779 ZFCP_STATUS_PORT_INVALID_WWPN, 780 &port->status); 781 } 782 783 static int zfcp_erp_port_forced_strategy(struct zfcp_erp_action *erp_action) 784 { 785 struct zfcp_port *port = erp_action->port; 786 int status = atomic_read(&port->status); 787 788 switch (erp_action->step) { 789 case ZFCP_ERP_STEP_UNINITIALIZED: 790 zfcp_erp_port_strategy_clearstati(port); 791 if ((status & ZFCP_STATUS_PORT_PHYS_OPEN) && 792 (status & ZFCP_STATUS_COMMON_OPEN)) 793 return zfcp_erp_port_forced_strategy_close(erp_action); 794 else 795 return ZFCP_ERP_FAILED; 796 797 case ZFCP_ERP_STEP_PHYS_PORT_CLOSING: 798 if (status & ZFCP_STATUS_PORT_PHYS_OPEN) 799 return ZFCP_ERP_SUCCEEDED; 800 } 801 return ZFCP_ERP_FAILED; 802 } 803 804 static int zfcp_erp_port_strategy_close(struct zfcp_erp_action *erp_action) 805 { 806 int retval; 807 808 retval = zfcp_fsf_close_port(erp_action); 809 if (retval == -ENOMEM) 810 return ZFCP_ERP_NOMEM; 811 erp_action->step = ZFCP_ERP_STEP_PORT_CLOSING; 812 if (retval) 813 return ZFCP_ERP_FAILED; 814 return ZFCP_ERP_CONTINUES; 815 } 816 817 static int zfcp_erp_port_strategy_open_port(struct zfcp_erp_action *erp_action) 818 { 819 int retval; 820 821 retval = zfcp_fsf_open_port(erp_action); 822 if (retval == -ENOMEM) 823 return ZFCP_ERP_NOMEM; 824 erp_action->step = ZFCP_ERP_STEP_PORT_OPENING; 825 if (retval) 826 return ZFCP_ERP_FAILED; 827 return ZFCP_ERP_CONTINUES; 828 } 829 830 static int zfcp_erp_open_ptp_port(struct zfcp_erp_action *act) 831 { 832 struct zfcp_adapter *adapter = act->adapter; 833 struct zfcp_port *port = act->port; 834 835 if (port->wwpn != adapter->peer_wwpn) { 836 zfcp_erp_port_failed(port, 25, NULL); 837 return ZFCP_ERP_FAILED; 838 } 839 port->d_id = adapter->peer_d_id; 840 atomic_set_mask(ZFCP_STATUS_PORT_DID_DID, &port->status); 841 return zfcp_erp_port_strategy_open_port(act); 842 } 843 844 void zfcp_erp_port_strategy_open_lookup(struct work_struct *work) 845 { 846 int retval; 847 struct zfcp_port *port = container_of(work, struct zfcp_port, 848 gid_pn_work); 849 850 retval = zfcp_fc_ns_gid_pn(&port->erp_action); 851 if (retval == -ENOMEM) 852 zfcp_erp_notify(&port->erp_action, ZFCP_ERP_NOMEM); 853 port->erp_action.step = ZFCP_ERP_STEP_NAMESERVER_LOOKUP; 854 if (retval) 855 zfcp_erp_notify(&port->erp_action, ZFCP_ERP_FAILED); 856 857 } 858 859 static int zfcp_erp_port_strategy_open_common(struct zfcp_erp_action *act) 860 { 861 struct zfcp_adapter *adapter = act->adapter; 862 struct zfcp_port *port = act->port; 863 int p_status = atomic_read(&port->status); 864 865 switch (act->step) { 866 case ZFCP_ERP_STEP_UNINITIALIZED: 867 case ZFCP_ERP_STEP_PHYS_PORT_CLOSING: 868 case ZFCP_ERP_STEP_PORT_CLOSING: 869 if (fc_host_port_type(adapter->scsi_host) == FC_PORTTYPE_PTP) 870 return zfcp_erp_open_ptp_port(act); 871 if (!(p_status & ZFCP_STATUS_PORT_DID_DID)) { 872 queue_work(zfcp_data.work_queue, &port->gid_pn_work); 873 return ZFCP_ERP_CONTINUES; 874 } 875 case ZFCP_ERP_STEP_NAMESERVER_LOOKUP: 876 if (!(p_status & ZFCP_STATUS_PORT_DID_DID)) { 877 if (p_status & (ZFCP_STATUS_PORT_INVALID_WWPN)) { 878 zfcp_erp_port_failed(port, 26, NULL); 879 return ZFCP_ERP_EXIT; 880 } 881 return ZFCP_ERP_FAILED; 882 } 883 return zfcp_erp_port_strategy_open_port(act); 884 885 case ZFCP_ERP_STEP_PORT_OPENING: 886 /* D_ID might have changed during open */ 887 if (p_status & ZFCP_STATUS_COMMON_OPEN) { 888 if (p_status & ZFCP_STATUS_PORT_DID_DID) 889 return ZFCP_ERP_SUCCEEDED; 890 else { 891 act->step = ZFCP_ERP_STEP_PORT_CLOSING; 892 return ZFCP_ERP_CONTINUES; 893 } 894 /* fall through otherwise */ 895 } 896 } 897 return ZFCP_ERP_FAILED; 898 } 899 900 static int zfcp_erp_port_strategy(struct zfcp_erp_action *erp_action) 901 { 902 struct zfcp_port *port = erp_action->port; 903 904 if (atomic_read(&port->status) & ZFCP_STATUS_COMMON_NOESC) 905 goto close_init_done; 906 907 switch (erp_action->step) { 908 case ZFCP_ERP_STEP_UNINITIALIZED: 909 zfcp_erp_port_strategy_clearstati(port); 910 if (atomic_read(&port->status) & ZFCP_STATUS_COMMON_OPEN) 911 return zfcp_erp_port_strategy_close(erp_action); 912 break; 913 914 case ZFCP_ERP_STEP_PORT_CLOSING: 915 if (atomic_read(&port->status) & ZFCP_STATUS_COMMON_OPEN) 916 return ZFCP_ERP_FAILED; 917 break; 918 } 919 920 close_init_done: 921 if (erp_action->status & ZFCP_STATUS_ERP_CLOSE_ONLY) 922 return ZFCP_ERP_EXIT; 923 924 return zfcp_erp_port_strategy_open_common(erp_action); 925 } 926 927 static void zfcp_erp_unit_strategy_clearstati(struct zfcp_unit *unit) 928 { 929 atomic_clear_mask(ZFCP_STATUS_COMMON_ACCESS_DENIED | 930 ZFCP_STATUS_UNIT_SHARED | 931 ZFCP_STATUS_UNIT_READONLY, 932 &unit->status); 933 } 934 935 static int zfcp_erp_unit_strategy_close(struct zfcp_erp_action *erp_action) 936 { 937 int retval = zfcp_fsf_close_unit(erp_action); 938 if (retval == -ENOMEM) 939 return ZFCP_ERP_NOMEM; 940 erp_action->step = ZFCP_ERP_STEP_UNIT_CLOSING; 941 if (retval) 942 return ZFCP_ERP_FAILED; 943 return ZFCP_ERP_CONTINUES; 944 } 945 946 static int zfcp_erp_unit_strategy_open(struct zfcp_erp_action *erp_action) 947 { 948 int retval = zfcp_fsf_open_unit(erp_action); 949 if (retval == -ENOMEM) 950 return ZFCP_ERP_NOMEM; 951 erp_action->step = ZFCP_ERP_STEP_UNIT_OPENING; 952 if (retval) 953 return ZFCP_ERP_FAILED; 954 return ZFCP_ERP_CONTINUES; 955 } 956 957 static int zfcp_erp_unit_strategy(struct zfcp_erp_action *erp_action) 958 { 959 struct zfcp_unit *unit = erp_action->unit; 960 961 switch (erp_action->step) { 962 case ZFCP_ERP_STEP_UNINITIALIZED: 963 zfcp_erp_unit_strategy_clearstati(unit); 964 if (atomic_read(&unit->status) & ZFCP_STATUS_COMMON_OPEN) 965 return zfcp_erp_unit_strategy_close(erp_action); 966 /* already closed, fall through */ 967 case ZFCP_ERP_STEP_UNIT_CLOSING: 968 if (atomic_read(&unit->status) & ZFCP_STATUS_COMMON_OPEN) 969 return ZFCP_ERP_FAILED; 970 if (erp_action->status & ZFCP_STATUS_ERP_CLOSE_ONLY) 971 return ZFCP_ERP_EXIT; 972 return zfcp_erp_unit_strategy_open(erp_action); 973 974 case ZFCP_ERP_STEP_UNIT_OPENING: 975 if (atomic_read(&unit->status) & ZFCP_STATUS_COMMON_OPEN) 976 return ZFCP_ERP_SUCCEEDED; 977 } 978 return ZFCP_ERP_FAILED; 979 } 980 981 static int zfcp_erp_strategy_check_unit(struct zfcp_unit *unit, int result) 982 { 983 switch (result) { 984 case ZFCP_ERP_SUCCEEDED : 985 atomic_set(&unit->erp_counter, 0); 986 zfcp_erp_unit_unblock(unit); 987 break; 988 case ZFCP_ERP_FAILED : 989 atomic_inc(&unit->erp_counter); 990 if (atomic_read(&unit->erp_counter) > ZFCP_MAX_ERPS) { 991 dev_err(&unit->port->adapter->ccw_device->dev, 992 "ERP failed for unit 0x%016Lx on " 993 "port 0x%016Lx\n", 994 (unsigned long long)unit->fcp_lun, 995 (unsigned long long)unit->port->wwpn); 996 zfcp_erp_unit_failed(unit, 21, NULL); 997 } 998 break; 999 } 1000 1001 if (atomic_read(&unit->status) & ZFCP_STATUS_COMMON_ERP_FAILED) { 1002 zfcp_erp_unit_block(unit, 0); 1003 result = ZFCP_ERP_EXIT; 1004 } 1005 return result; 1006 } 1007 1008 static int zfcp_erp_strategy_check_port(struct zfcp_port *port, int result) 1009 { 1010 switch (result) { 1011 case ZFCP_ERP_SUCCEEDED : 1012 atomic_set(&port->erp_counter, 0); 1013 zfcp_erp_port_unblock(port); 1014 break; 1015 1016 case ZFCP_ERP_FAILED : 1017 if (atomic_read(&port->status) & ZFCP_STATUS_COMMON_NOESC) { 1018 zfcp_erp_port_block(port, 0); 1019 result = ZFCP_ERP_EXIT; 1020 } 1021 atomic_inc(&port->erp_counter); 1022 if (atomic_read(&port->erp_counter) > ZFCP_MAX_ERPS) { 1023 dev_err(&port->adapter->ccw_device->dev, 1024 "ERP failed for remote port 0x%016Lx\n", 1025 (unsigned long long)port->wwpn); 1026 zfcp_erp_port_failed(port, 22, NULL); 1027 } 1028 break; 1029 } 1030 1031 if (atomic_read(&port->status) & ZFCP_STATUS_COMMON_ERP_FAILED) { 1032 zfcp_erp_port_block(port, 0); 1033 result = ZFCP_ERP_EXIT; 1034 } 1035 return result; 1036 } 1037 1038 static int zfcp_erp_strategy_check_adapter(struct zfcp_adapter *adapter, 1039 int result) 1040 { 1041 switch (result) { 1042 case ZFCP_ERP_SUCCEEDED : 1043 atomic_set(&adapter->erp_counter, 0); 1044 zfcp_erp_adapter_unblock(adapter); 1045 break; 1046 1047 case ZFCP_ERP_FAILED : 1048 atomic_inc(&adapter->erp_counter); 1049 if (atomic_read(&adapter->erp_counter) > ZFCP_MAX_ERPS) { 1050 dev_err(&adapter->ccw_device->dev, 1051 "ERP cannot recover an error " 1052 "on the FCP device\n"); 1053 zfcp_erp_adapter_failed(adapter, 23, NULL); 1054 } 1055 break; 1056 } 1057 1058 if (atomic_read(&adapter->status) & ZFCP_STATUS_COMMON_ERP_FAILED) { 1059 zfcp_erp_adapter_block(adapter, 0); 1060 result = ZFCP_ERP_EXIT; 1061 } 1062 return result; 1063 } 1064 1065 static int zfcp_erp_strategy_check_target(struct zfcp_erp_action *erp_action, 1066 int result) 1067 { 1068 struct zfcp_adapter *adapter = erp_action->adapter; 1069 struct zfcp_port *port = erp_action->port; 1070 struct zfcp_unit *unit = erp_action->unit; 1071 1072 switch (erp_action->action) { 1073 1074 case ZFCP_ERP_ACTION_REOPEN_UNIT: 1075 result = zfcp_erp_strategy_check_unit(unit, result); 1076 break; 1077 1078 case ZFCP_ERP_ACTION_REOPEN_PORT_FORCED: 1079 case ZFCP_ERP_ACTION_REOPEN_PORT: 1080 result = zfcp_erp_strategy_check_port(port, result); 1081 break; 1082 1083 case ZFCP_ERP_ACTION_REOPEN_ADAPTER: 1084 result = zfcp_erp_strategy_check_adapter(adapter, result); 1085 break; 1086 } 1087 return result; 1088 } 1089 1090 static int zfcp_erp_strat_change_det(atomic_t *target_status, u32 erp_status) 1091 { 1092 int status = atomic_read(target_status); 1093 1094 if ((status & ZFCP_STATUS_COMMON_RUNNING) && 1095 (erp_status & ZFCP_STATUS_ERP_CLOSE_ONLY)) 1096 return 1; /* take it online */ 1097 1098 if (!(status & ZFCP_STATUS_COMMON_RUNNING) && 1099 !(erp_status & ZFCP_STATUS_ERP_CLOSE_ONLY)) 1100 return 1; /* take it offline */ 1101 1102 return 0; 1103 } 1104 1105 static int zfcp_erp_strategy_statechange(struct zfcp_erp_action *act, int ret) 1106 { 1107 int action = act->action; 1108 struct zfcp_adapter *adapter = act->adapter; 1109 struct zfcp_port *port = act->port; 1110 struct zfcp_unit *unit = act->unit; 1111 u32 erp_status = act->status; 1112 1113 switch (action) { 1114 case ZFCP_ERP_ACTION_REOPEN_ADAPTER: 1115 if (zfcp_erp_strat_change_det(&adapter->status, erp_status)) { 1116 _zfcp_erp_adapter_reopen(adapter, 1117 ZFCP_STATUS_COMMON_ERP_FAILED, 1118 67, NULL); 1119 return ZFCP_ERP_EXIT; 1120 } 1121 break; 1122 1123 case ZFCP_ERP_ACTION_REOPEN_PORT_FORCED: 1124 case ZFCP_ERP_ACTION_REOPEN_PORT: 1125 if (zfcp_erp_strat_change_det(&port->status, erp_status)) { 1126 _zfcp_erp_port_reopen(port, 1127 ZFCP_STATUS_COMMON_ERP_FAILED, 1128 68, NULL); 1129 return ZFCP_ERP_EXIT; 1130 } 1131 break; 1132 1133 case ZFCP_ERP_ACTION_REOPEN_UNIT: 1134 if (zfcp_erp_strat_change_det(&unit->status, erp_status)) { 1135 _zfcp_erp_unit_reopen(unit, 1136 ZFCP_STATUS_COMMON_ERP_FAILED, 1137 69, NULL); 1138 return ZFCP_ERP_EXIT; 1139 } 1140 break; 1141 } 1142 return ret; 1143 } 1144 1145 static void zfcp_erp_action_dequeue(struct zfcp_erp_action *erp_action) 1146 { 1147 struct zfcp_adapter *adapter = erp_action->adapter; 1148 1149 adapter->erp_total_count--; 1150 if (erp_action->status & ZFCP_STATUS_ERP_LOWMEM) { 1151 adapter->erp_low_mem_count--; 1152 erp_action->status &= ~ZFCP_STATUS_ERP_LOWMEM; 1153 } 1154 1155 list_del(&erp_action->list); 1156 zfcp_rec_dbf_event_action(144, erp_action); 1157 1158 switch (erp_action->action) { 1159 case ZFCP_ERP_ACTION_REOPEN_UNIT: 1160 atomic_clear_mask(ZFCP_STATUS_COMMON_ERP_INUSE, 1161 &erp_action->unit->status); 1162 break; 1163 1164 case ZFCP_ERP_ACTION_REOPEN_PORT_FORCED: 1165 case ZFCP_ERP_ACTION_REOPEN_PORT: 1166 atomic_clear_mask(ZFCP_STATUS_COMMON_ERP_INUSE, 1167 &erp_action->port->status); 1168 break; 1169 1170 case ZFCP_ERP_ACTION_REOPEN_ADAPTER: 1171 atomic_clear_mask(ZFCP_STATUS_COMMON_ERP_INUSE, 1172 &erp_action->adapter->status); 1173 break; 1174 } 1175 } 1176 1177 struct zfcp_erp_add_work { 1178 struct zfcp_unit *unit; 1179 struct work_struct work; 1180 }; 1181 1182 static void zfcp_erp_scsi_scan(struct work_struct *work) 1183 { 1184 struct zfcp_erp_add_work *p = 1185 container_of(work, struct zfcp_erp_add_work, work); 1186 struct zfcp_unit *unit = p->unit; 1187 struct fc_rport *rport = unit->port->rport; 1188 scsi_scan_target(&rport->dev, 0, rport->scsi_target_id, 1189 scsilun_to_int((struct scsi_lun *)&unit->fcp_lun), 0); 1190 atomic_clear_mask(ZFCP_STATUS_UNIT_SCSI_WORK_PENDING, &unit->status); 1191 zfcp_unit_put(unit); 1192 wake_up(&unit->port->adapter->erp_done_wqh); 1193 kfree(p); 1194 } 1195 1196 static void zfcp_erp_schedule_work(struct zfcp_unit *unit) 1197 { 1198 struct zfcp_erp_add_work *p; 1199 1200 p = kzalloc(sizeof(*p), GFP_KERNEL); 1201 if (!p) { 1202 dev_err(&unit->port->adapter->ccw_device->dev, 1203 "Registering unit 0x%016Lx on port 0x%016Lx failed\n", 1204 (unsigned long long)unit->fcp_lun, 1205 (unsigned long long)unit->port->wwpn); 1206 return; 1207 } 1208 1209 zfcp_unit_get(unit); 1210 atomic_set_mask(ZFCP_STATUS_UNIT_SCSI_WORK_PENDING, &unit->status); 1211 INIT_WORK(&p->work, zfcp_erp_scsi_scan); 1212 p->unit = unit; 1213 queue_work(zfcp_data.work_queue, &p->work); 1214 } 1215 1216 static void zfcp_erp_rport_register(struct zfcp_port *port) 1217 { 1218 struct fc_rport_identifiers ids; 1219 ids.node_name = port->wwnn; 1220 ids.port_name = port->wwpn; 1221 ids.port_id = port->d_id; 1222 ids.roles = FC_RPORT_ROLE_FCP_TARGET; 1223 port->rport = fc_remote_port_add(port->adapter->scsi_host, 0, &ids); 1224 if (!port->rport) { 1225 dev_err(&port->adapter->ccw_device->dev, 1226 "Registering port 0x%016Lx failed\n", 1227 (unsigned long long)port->wwpn); 1228 return; 1229 } 1230 1231 scsi_target_unblock(&port->rport->dev); 1232 port->rport->maxframe_size = port->maxframe_size; 1233 port->rport->supported_classes = port->supported_classes; 1234 } 1235 1236 static void zfcp_erp_rports_del(struct zfcp_adapter *adapter) 1237 { 1238 struct zfcp_port *port; 1239 list_for_each_entry(port, &adapter->port_list_head, list) { 1240 if (!port->rport) 1241 continue; 1242 fc_remote_port_delete(port->rport); 1243 port->rport = NULL; 1244 } 1245 } 1246 1247 static void zfcp_erp_action_cleanup(struct zfcp_erp_action *act, int result) 1248 { 1249 struct zfcp_adapter *adapter = act->adapter; 1250 struct zfcp_port *port = act->port; 1251 struct zfcp_unit *unit = act->unit; 1252 1253 switch (act->action) { 1254 case ZFCP_ERP_ACTION_REOPEN_UNIT: 1255 if ((result == ZFCP_ERP_SUCCEEDED) && 1256 !unit->device && port->rport) { 1257 atomic_set_mask(ZFCP_STATUS_UNIT_REGISTERED, 1258 &unit->status); 1259 if (!(atomic_read(&unit->status) & 1260 ZFCP_STATUS_UNIT_SCSI_WORK_PENDING)) 1261 zfcp_erp_schedule_work(unit); 1262 } 1263 zfcp_unit_put(unit); 1264 break; 1265 1266 case ZFCP_ERP_ACTION_REOPEN_PORT_FORCED: 1267 case ZFCP_ERP_ACTION_REOPEN_PORT: 1268 if (atomic_read(&port->status) & ZFCP_STATUS_PORT_NO_WWPN) { 1269 zfcp_port_put(port); 1270 return; 1271 } 1272 if ((result == ZFCP_ERP_SUCCEEDED) && !port->rport) 1273 zfcp_erp_rport_register(port); 1274 if ((result != ZFCP_ERP_SUCCEEDED) && port->rport) { 1275 fc_remote_port_delete(port->rport); 1276 port->rport = NULL; 1277 } 1278 zfcp_port_put(port); 1279 break; 1280 1281 case ZFCP_ERP_ACTION_REOPEN_ADAPTER: 1282 if (result != ZFCP_ERP_SUCCEEDED) 1283 zfcp_erp_rports_del(adapter); 1284 zfcp_adapter_put(adapter); 1285 break; 1286 } 1287 } 1288 1289 static int zfcp_erp_strategy_do_action(struct zfcp_erp_action *erp_action) 1290 { 1291 switch (erp_action->action) { 1292 case ZFCP_ERP_ACTION_REOPEN_ADAPTER: 1293 return zfcp_erp_adapter_strategy(erp_action); 1294 case ZFCP_ERP_ACTION_REOPEN_PORT_FORCED: 1295 return zfcp_erp_port_forced_strategy(erp_action); 1296 case ZFCP_ERP_ACTION_REOPEN_PORT: 1297 return zfcp_erp_port_strategy(erp_action); 1298 case ZFCP_ERP_ACTION_REOPEN_UNIT: 1299 return zfcp_erp_unit_strategy(erp_action); 1300 } 1301 return ZFCP_ERP_FAILED; 1302 } 1303 1304 static int zfcp_erp_strategy(struct zfcp_erp_action *erp_action) 1305 { 1306 int retval; 1307 struct zfcp_adapter *adapter = erp_action->adapter; 1308 unsigned long flags; 1309 1310 read_lock_irqsave(&zfcp_data.config_lock, flags); 1311 write_lock(&adapter->erp_lock); 1312 1313 zfcp_erp_strategy_check_fsfreq(erp_action); 1314 1315 if (erp_action->status & ZFCP_STATUS_ERP_DISMISSED) { 1316 zfcp_erp_action_dequeue(erp_action); 1317 retval = ZFCP_ERP_DISMISSED; 1318 goto unlock; 1319 } 1320 1321 zfcp_erp_action_to_running(erp_action); 1322 1323 /* no lock to allow for blocking operations */ 1324 write_unlock(&adapter->erp_lock); 1325 read_unlock_irqrestore(&zfcp_data.config_lock, flags); 1326 retval = zfcp_erp_strategy_do_action(erp_action); 1327 read_lock_irqsave(&zfcp_data.config_lock, flags); 1328 write_lock(&adapter->erp_lock); 1329 1330 if (erp_action->status & ZFCP_STATUS_ERP_DISMISSED) 1331 retval = ZFCP_ERP_CONTINUES; 1332 1333 switch (retval) { 1334 case ZFCP_ERP_NOMEM: 1335 if (!(erp_action->status & ZFCP_STATUS_ERP_LOWMEM)) { 1336 ++adapter->erp_low_mem_count; 1337 erp_action->status |= ZFCP_STATUS_ERP_LOWMEM; 1338 } 1339 if (adapter->erp_total_count == adapter->erp_low_mem_count) 1340 _zfcp_erp_adapter_reopen(adapter, 0, 66, NULL); 1341 else { 1342 zfcp_erp_strategy_memwait(erp_action); 1343 retval = ZFCP_ERP_CONTINUES; 1344 } 1345 goto unlock; 1346 1347 case ZFCP_ERP_CONTINUES: 1348 if (erp_action->status & ZFCP_STATUS_ERP_LOWMEM) { 1349 --adapter->erp_low_mem_count; 1350 erp_action->status &= ~ZFCP_STATUS_ERP_LOWMEM; 1351 } 1352 goto unlock; 1353 } 1354 1355 retval = zfcp_erp_strategy_check_target(erp_action, retval); 1356 zfcp_erp_action_dequeue(erp_action); 1357 retval = zfcp_erp_strategy_statechange(erp_action, retval); 1358 if (retval == ZFCP_ERP_EXIT) 1359 goto unlock; 1360 zfcp_erp_strategy_followup_actions(erp_action); 1361 1362 unlock: 1363 write_unlock(&adapter->erp_lock); 1364 read_unlock_irqrestore(&zfcp_data.config_lock, flags); 1365 1366 if (retval != ZFCP_ERP_CONTINUES) 1367 zfcp_erp_action_cleanup(erp_action, retval); 1368 1369 return retval; 1370 } 1371 1372 static int zfcp_erp_thread(void *data) 1373 { 1374 struct zfcp_adapter *adapter = (struct zfcp_adapter *) data; 1375 struct list_head *next; 1376 struct zfcp_erp_action *act; 1377 unsigned long flags; 1378 1379 daemonize("zfcperp%s", dev_name(&adapter->ccw_device->dev)); 1380 /* Block all signals */ 1381 siginitsetinv(¤t->blocked, 0); 1382 atomic_set_mask(ZFCP_STATUS_ADAPTER_ERP_THREAD_UP, &adapter->status); 1383 wake_up(&adapter->erp_thread_wqh); 1384 1385 while (!(atomic_read(&adapter->status) & 1386 ZFCP_STATUS_ADAPTER_ERP_THREAD_KILL)) { 1387 write_lock_irqsave(&adapter->erp_lock, flags); 1388 next = adapter->erp_ready_head.next; 1389 write_unlock_irqrestore(&adapter->erp_lock, flags); 1390 1391 if (next != &adapter->erp_ready_head) { 1392 act = list_entry(next, struct zfcp_erp_action, list); 1393 1394 /* there is more to come after dismission, no notify */ 1395 if (zfcp_erp_strategy(act) != ZFCP_ERP_DISMISSED) 1396 zfcp_erp_wakeup(adapter); 1397 } 1398 1399 zfcp_rec_dbf_event_thread_lock(4, adapter); 1400 down_interruptible(&adapter->erp_ready_sem); 1401 zfcp_rec_dbf_event_thread_lock(5, adapter); 1402 } 1403 1404 atomic_clear_mask(ZFCP_STATUS_ADAPTER_ERP_THREAD_UP, &adapter->status); 1405 wake_up(&adapter->erp_thread_wqh); 1406 1407 return 0; 1408 } 1409 1410 /** 1411 * zfcp_erp_thread_setup - Start ERP thread for adapter 1412 * @adapter: Adapter to start the ERP thread for 1413 * 1414 * Returns 0 on success or error code from kernel_thread() 1415 */ 1416 int zfcp_erp_thread_setup(struct zfcp_adapter *adapter) 1417 { 1418 int retval; 1419 1420 atomic_clear_mask(ZFCP_STATUS_ADAPTER_ERP_THREAD_UP, &adapter->status); 1421 retval = kernel_thread(zfcp_erp_thread, adapter, SIGCHLD); 1422 if (retval < 0) { 1423 dev_err(&adapter->ccw_device->dev, 1424 "Creating an ERP thread for the FCP device failed.\n"); 1425 return retval; 1426 } 1427 wait_event(adapter->erp_thread_wqh, 1428 atomic_read(&adapter->status) & 1429 ZFCP_STATUS_ADAPTER_ERP_THREAD_UP); 1430 return 0; 1431 } 1432 1433 /** 1434 * zfcp_erp_thread_kill - Stop ERP thread. 1435 * @adapter: Adapter where the ERP thread should be stopped. 1436 * 1437 * The caller of this routine ensures that the specified adapter has 1438 * been shut down and that this operation has been completed. Thus, 1439 * there are no pending erp_actions which would need to be handled 1440 * here. 1441 */ 1442 void zfcp_erp_thread_kill(struct zfcp_adapter *adapter) 1443 { 1444 atomic_set_mask(ZFCP_STATUS_ADAPTER_ERP_THREAD_KILL, &adapter->status); 1445 up(&adapter->erp_ready_sem); 1446 zfcp_rec_dbf_event_thread_lock(3, adapter); 1447 1448 wait_event(adapter->erp_thread_wqh, 1449 !(atomic_read(&adapter->status) & 1450 ZFCP_STATUS_ADAPTER_ERP_THREAD_UP)); 1451 1452 atomic_clear_mask(ZFCP_STATUS_ADAPTER_ERP_THREAD_KILL, 1453 &adapter->status); 1454 } 1455 1456 /** 1457 * zfcp_erp_adapter_failed - Set adapter status to failed. 1458 * @adapter: Failed adapter. 1459 * @id: Event id for debug trace. 1460 * @ref: Reference for debug trace. 1461 */ 1462 void zfcp_erp_adapter_failed(struct zfcp_adapter *adapter, u8 id, void *ref) 1463 { 1464 zfcp_erp_modify_adapter_status(adapter, id, ref, 1465 ZFCP_STATUS_COMMON_ERP_FAILED, ZFCP_SET); 1466 } 1467 1468 /** 1469 * zfcp_erp_port_failed - Set port status to failed. 1470 * @port: Failed port. 1471 * @id: Event id for debug trace. 1472 * @ref: Reference for debug trace. 1473 */ 1474 void zfcp_erp_port_failed(struct zfcp_port *port, u8 id, void *ref) 1475 { 1476 zfcp_erp_modify_port_status(port, id, ref, 1477 ZFCP_STATUS_COMMON_ERP_FAILED, ZFCP_SET); 1478 } 1479 1480 /** 1481 * zfcp_erp_unit_failed - Set unit status to failed. 1482 * @unit: Failed unit. 1483 * @id: Event id for debug trace. 1484 * @ref: Reference for debug trace. 1485 */ 1486 void zfcp_erp_unit_failed(struct zfcp_unit *unit, u8 id, void *ref) 1487 { 1488 zfcp_erp_modify_unit_status(unit, id, ref, 1489 ZFCP_STATUS_COMMON_ERP_FAILED, ZFCP_SET); 1490 } 1491 1492 /** 1493 * zfcp_erp_wait - wait for completion of error recovery on an adapter 1494 * @adapter: adapter for which to wait for completion of its error recovery 1495 */ 1496 void zfcp_erp_wait(struct zfcp_adapter *adapter) 1497 { 1498 wait_event(adapter->erp_done_wqh, 1499 !(atomic_read(&adapter->status) & 1500 ZFCP_STATUS_ADAPTER_ERP_PENDING)); 1501 } 1502 1503 /** 1504 * zfcp_erp_modify_adapter_status - change adapter status bits 1505 * @adapter: adapter to change the status 1506 * @id: id for the debug trace 1507 * @ref: reference for the debug trace 1508 * @mask: status bits to change 1509 * @set_or_clear: ZFCP_SET or ZFCP_CLEAR 1510 * 1511 * Changes in common status bits are propagated to attached ports and units. 1512 */ 1513 void zfcp_erp_modify_adapter_status(struct zfcp_adapter *adapter, u8 id, 1514 void *ref, u32 mask, int set_or_clear) 1515 { 1516 struct zfcp_port *port; 1517 u32 common_mask = mask & ZFCP_COMMON_FLAGS; 1518 1519 if (set_or_clear == ZFCP_SET) { 1520 if (status_change_set(mask, &adapter->status)) 1521 zfcp_rec_dbf_event_adapter(id, ref, adapter); 1522 atomic_set_mask(mask, &adapter->status); 1523 } else { 1524 if (status_change_clear(mask, &adapter->status)) 1525 zfcp_rec_dbf_event_adapter(id, ref, adapter); 1526 atomic_clear_mask(mask, &adapter->status); 1527 if (mask & ZFCP_STATUS_COMMON_ERP_FAILED) 1528 atomic_set(&adapter->erp_counter, 0); 1529 } 1530 1531 if (common_mask) 1532 list_for_each_entry(port, &adapter->port_list_head, list) 1533 zfcp_erp_modify_port_status(port, id, ref, common_mask, 1534 set_or_clear); 1535 } 1536 1537 /** 1538 * zfcp_erp_modify_port_status - change port status bits 1539 * @port: port to change the status bits 1540 * @id: id for the debug trace 1541 * @ref: reference for the debug trace 1542 * @mask: status bits to change 1543 * @set_or_clear: ZFCP_SET or ZFCP_CLEAR 1544 * 1545 * Changes in common status bits are propagated to attached units. 1546 */ 1547 void zfcp_erp_modify_port_status(struct zfcp_port *port, u8 id, void *ref, 1548 u32 mask, int set_or_clear) 1549 { 1550 struct zfcp_unit *unit; 1551 u32 common_mask = mask & ZFCP_COMMON_FLAGS; 1552 1553 if (set_or_clear == ZFCP_SET) { 1554 if (status_change_set(mask, &port->status)) 1555 zfcp_rec_dbf_event_port(id, ref, port); 1556 atomic_set_mask(mask, &port->status); 1557 } else { 1558 if (status_change_clear(mask, &port->status)) 1559 zfcp_rec_dbf_event_port(id, ref, port); 1560 atomic_clear_mask(mask, &port->status); 1561 if (mask & ZFCP_STATUS_COMMON_ERP_FAILED) 1562 atomic_set(&port->erp_counter, 0); 1563 } 1564 1565 if (common_mask) 1566 list_for_each_entry(unit, &port->unit_list_head, list) 1567 zfcp_erp_modify_unit_status(unit, id, ref, common_mask, 1568 set_or_clear); 1569 } 1570 1571 /** 1572 * zfcp_erp_modify_unit_status - change unit status bits 1573 * @unit: unit to change the status bits 1574 * @id: id for the debug trace 1575 * @ref: reference for the debug trace 1576 * @mask: status bits to change 1577 * @set_or_clear: ZFCP_SET or ZFCP_CLEAR 1578 */ 1579 void zfcp_erp_modify_unit_status(struct zfcp_unit *unit, u8 id, void *ref, 1580 u32 mask, int set_or_clear) 1581 { 1582 if (set_or_clear == ZFCP_SET) { 1583 if (status_change_set(mask, &unit->status)) 1584 zfcp_rec_dbf_event_unit(id, ref, unit); 1585 atomic_set_mask(mask, &unit->status); 1586 } else { 1587 if (status_change_clear(mask, &unit->status)) 1588 zfcp_rec_dbf_event_unit(id, ref, unit); 1589 atomic_clear_mask(mask, &unit->status); 1590 if (mask & ZFCP_STATUS_COMMON_ERP_FAILED) { 1591 atomic_set(&unit->erp_counter, 0); 1592 } 1593 } 1594 } 1595 1596 /** 1597 * zfcp_erp_port_boxed - Mark port as "boxed" and start ERP 1598 * @port: The "boxed" port. 1599 * @id: The debug trace id. 1600 * @id: Reference for the debug trace. 1601 */ 1602 void zfcp_erp_port_boxed(struct zfcp_port *port, u8 id, void *ref) 1603 { 1604 unsigned long flags; 1605 1606 read_lock_irqsave(&zfcp_data.config_lock, flags); 1607 zfcp_erp_modify_port_status(port, id, ref, 1608 ZFCP_STATUS_COMMON_ACCESS_BOXED, ZFCP_SET); 1609 read_unlock_irqrestore(&zfcp_data.config_lock, flags); 1610 zfcp_erp_port_reopen(port, ZFCP_STATUS_COMMON_ERP_FAILED, id, ref); 1611 } 1612 1613 /** 1614 * zfcp_erp_unit_boxed - Mark unit as "boxed" and start ERP 1615 * @port: The "boxed" unit. 1616 * @id: The debug trace id. 1617 * @id: Reference for the debug trace. 1618 */ 1619 void zfcp_erp_unit_boxed(struct zfcp_unit *unit, u8 id, void *ref) 1620 { 1621 zfcp_erp_modify_unit_status(unit, id, ref, 1622 ZFCP_STATUS_COMMON_ACCESS_BOXED, ZFCP_SET); 1623 zfcp_erp_unit_reopen(unit, ZFCP_STATUS_COMMON_ERP_FAILED, id, ref); 1624 } 1625 1626 /** 1627 * zfcp_erp_port_access_denied - Adapter denied access to port. 1628 * @port: port where access has been denied 1629 * @id: id for debug trace 1630 * @ref: reference for debug trace 1631 * 1632 * Since the adapter has denied access, stop using the port and the 1633 * attached units. 1634 */ 1635 void zfcp_erp_port_access_denied(struct zfcp_port *port, u8 id, void *ref) 1636 { 1637 unsigned long flags; 1638 1639 read_lock_irqsave(&zfcp_data.config_lock, flags); 1640 zfcp_erp_modify_port_status(port, id, ref, 1641 ZFCP_STATUS_COMMON_ERP_FAILED | 1642 ZFCP_STATUS_COMMON_ACCESS_DENIED, ZFCP_SET); 1643 read_unlock_irqrestore(&zfcp_data.config_lock, flags); 1644 } 1645 1646 /** 1647 * zfcp_erp_unit_access_denied - Adapter denied access to unit. 1648 * @unit: unit where access has been denied 1649 * @id: id for debug trace 1650 * @ref: reference for debug trace 1651 * 1652 * Since the adapter has denied access, stop using the unit. 1653 */ 1654 void zfcp_erp_unit_access_denied(struct zfcp_unit *unit, u8 id, void *ref) 1655 { 1656 zfcp_erp_modify_unit_status(unit, id, ref, 1657 ZFCP_STATUS_COMMON_ERP_FAILED | 1658 ZFCP_STATUS_COMMON_ACCESS_DENIED, ZFCP_SET); 1659 } 1660 1661 static void zfcp_erp_unit_access_changed(struct zfcp_unit *unit, u8 id, 1662 void *ref) 1663 { 1664 int status = atomic_read(&unit->status); 1665 if (!(status & (ZFCP_STATUS_COMMON_ACCESS_DENIED | 1666 ZFCP_STATUS_COMMON_ACCESS_BOXED))) 1667 return; 1668 1669 zfcp_erp_unit_reopen(unit, ZFCP_STATUS_COMMON_ERP_FAILED, id, ref); 1670 } 1671 1672 static void zfcp_erp_port_access_changed(struct zfcp_port *port, u8 id, 1673 void *ref) 1674 { 1675 struct zfcp_unit *unit; 1676 int status = atomic_read(&port->status); 1677 1678 if (!(status & (ZFCP_STATUS_COMMON_ACCESS_DENIED | 1679 ZFCP_STATUS_COMMON_ACCESS_BOXED))) { 1680 list_for_each_entry(unit, &port->unit_list_head, list) 1681 zfcp_erp_unit_access_changed(unit, id, ref); 1682 return; 1683 } 1684 1685 zfcp_erp_port_reopen(port, ZFCP_STATUS_COMMON_ERP_FAILED, id, ref); 1686 } 1687 1688 /** 1689 * zfcp_erp_adapter_access_changed - Process change in adapter ACT 1690 * @adapter: Adapter where the Access Control Table (ACT) changed 1691 * @id: Id for debug trace 1692 * @ref: Reference for debug trace 1693 */ 1694 void zfcp_erp_adapter_access_changed(struct zfcp_adapter *adapter, u8 id, 1695 void *ref) 1696 { 1697 struct zfcp_port *port; 1698 unsigned long flags; 1699 1700 if (adapter->connection_features & FSF_FEATURE_NPIV_MODE) 1701 return; 1702 1703 read_lock_irqsave(&zfcp_data.config_lock, flags); 1704 list_for_each_entry(port, &adapter->port_list_head, list) 1705 zfcp_erp_port_access_changed(port, id, ref); 1706 read_unlock_irqrestore(&zfcp_data.config_lock, flags); 1707 } 1708