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