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(struct timer_list *t) 568 { 569 struct zfcp_fsf_req *fsf_req = from_timer(fsf_req, t, timer); 570 struct zfcp_erp_action *act = fsf_req->erp_action; 571 572 zfcp_erp_notify(act, ZFCP_STATUS_ERP_TIMEDOUT); 573 } 574 575 static void zfcp_erp_memwait_handler(struct timer_list *t) 576 { 577 struct zfcp_erp_action *act = from_timer(act, t, timer); 578 579 zfcp_erp_notify(act, 0); 580 } 581 582 static void zfcp_erp_strategy_memwait(struct zfcp_erp_action *erp_action) 583 { 584 timer_setup(&erp_action->timer, zfcp_erp_memwait_handler, 0); 585 erp_action->timer.expires = jiffies + HZ; 586 add_timer(&erp_action->timer); 587 } 588 589 static void _zfcp_erp_port_reopen_all(struct zfcp_adapter *adapter, 590 int clear, char *id) 591 { 592 struct zfcp_port *port; 593 594 read_lock(&adapter->port_list_lock); 595 list_for_each_entry(port, &adapter->port_list, list) 596 _zfcp_erp_port_reopen(port, clear, id); 597 read_unlock(&adapter->port_list_lock); 598 } 599 600 static void _zfcp_erp_lun_reopen_all(struct zfcp_port *port, int clear, 601 char *id) 602 { 603 struct scsi_device *sdev; 604 605 spin_lock(port->adapter->scsi_host->host_lock); 606 __shost_for_each_device(sdev, port->adapter->scsi_host) 607 if (sdev_to_zfcp(sdev)->port == port) 608 _zfcp_erp_lun_reopen(sdev, clear, id, 0); 609 spin_unlock(port->adapter->scsi_host->host_lock); 610 } 611 612 static void zfcp_erp_strategy_followup_failed(struct zfcp_erp_action *act) 613 { 614 switch (act->action) { 615 case ZFCP_ERP_ACTION_REOPEN_ADAPTER: 616 _zfcp_erp_adapter_reopen(act->adapter, 0, "ersff_1"); 617 break; 618 case ZFCP_ERP_ACTION_REOPEN_PORT_FORCED: 619 _zfcp_erp_port_forced_reopen(act->port, 0, "ersff_2"); 620 break; 621 case ZFCP_ERP_ACTION_REOPEN_PORT: 622 _zfcp_erp_port_reopen(act->port, 0, "ersff_3"); 623 break; 624 case ZFCP_ERP_ACTION_REOPEN_LUN: 625 _zfcp_erp_lun_reopen(act->sdev, 0, "ersff_4", 0); 626 break; 627 } 628 } 629 630 static void zfcp_erp_strategy_followup_success(struct zfcp_erp_action *act) 631 { 632 switch (act->action) { 633 case ZFCP_ERP_ACTION_REOPEN_ADAPTER: 634 _zfcp_erp_port_reopen_all(act->adapter, 0, "ersfs_1"); 635 break; 636 case ZFCP_ERP_ACTION_REOPEN_PORT_FORCED: 637 _zfcp_erp_port_reopen(act->port, 0, "ersfs_2"); 638 break; 639 case ZFCP_ERP_ACTION_REOPEN_PORT: 640 _zfcp_erp_lun_reopen_all(act->port, 0, "ersfs_3"); 641 break; 642 } 643 } 644 645 static void zfcp_erp_wakeup(struct zfcp_adapter *adapter) 646 { 647 unsigned long flags; 648 649 read_lock_irqsave(&adapter->erp_lock, flags); 650 if (list_empty(&adapter->erp_ready_head) && 651 list_empty(&adapter->erp_running_head)) { 652 atomic_andnot(ZFCP_STATUS_ADAPTER_ERP_PENDING, 653 &adapter->status); 654 wake_up(&adapter->erp_done_wqh); 655 } 656 read_unlock_irqrestore(&adapter->erp_lock, flags); 657 } 658 659 static void zfcp_erp_enqueue_ptp_port(struct zfcp_adapter *adapter) 660 { 661 struct zfcp_port *port; 662 port = zfcp_port_enqueue(adapter, adapter->peer_wwpn, 0, 663 adapter->peer_d_id); 664 if (IS_ERR(port)) /* error or port already attached */ 665 return; 666 _zfcp_erp_port_reopen(port, 0, "ereptp1"); 667 } 668 669 static int zfcp_erp_adapter_strat_fsf_xconf(struct zfcp_erp_action *erp_action) 670 { 671 int retries; 672 int sleep = 1; 673 struct zfcp_adapter *adapter = erp_action->adapter; 674 675 atomic_andnot(ZFCP_STATUS_ADAPTER_XCONFIG_OK, &adapter->status); 676 677 for (retries = 7; retries; retries--) { 678 atomic_andnot(ZFCP_STATUS_ADAPTER_HOST_CON_INIT, 679 &adapter->status); 680 write_lock_irq(&adapter->erp_lock); 681 zfcp_erp_action_to_running(erp_action); 682 write_unlock_irq(&adapter->erp_lock); 683 if (zfcp_fsf_exchange_config_data(erp_action)) { 684 atomic_andnot(ZFCP_STATUS_ADAPTER_HOST_CON_INIT, 685 &adapter->status); 686 return ZFCP_ERP_FAILED; 687 } 688 689 wait_event(adapter->erp_ready_wq, 690 !list_empty(&adapter->erp_ready_head)); 691 if (erp_action->status & ZFCP_STATUS_ERP_TIMEDOUT) 692 break; 693 694 if (!(atomic_read(&adapter->status) & 695 ZFCP_STATUS_ADAPTER_HOST_CON_INIT)) 696 break; 697 698 ssleep(sleep); 699 sleep *= 2; 700 } 701 702 atomic_andnot(ZFCP_STATUS_ADAPTER_HOST_CON_INIT, 703 &adapter->status); 704 705 if (!(atomic_read(&adapter->status) & ZFCP_STATUS_ADAPTER_XCONFIG_OK)) 706 return ZFCP_ERP_FAILED; 707 708 if (fc_host_port_type(adapter->scsi_host) == FC_PORTTYPE_PTP) 709 zfcp_erp_enqueue_ptp_port(adapter); 710 711 return ZFCP_ERP_SUCCEEDED; 712 } 713 714 static int zfcp_erp_adapter_strategy_open_fsf_xport(struct zfcp_erp_action *act) 715 { 716 int ret; 717 struct zfcp_adapter *adapter = act->adapter; 718 719 write_lock_irq(&adapter->erp_lock); 720 zfcp_erp_action_to_running(act); 721 write_unlock_irq(&adapter->erp_lock); 722 723 ret = zfcp_fsf_exchange_port_data(act); 724 if (ret == -EOPNOTSUPP) 725 return ZFCP_ERP_SUCCEEDED; 726 if (ret) 727 return ZFCP_ERP_FAILED; 728 729 zfcp_dbf_rec_run("erasox1", act); 730 wait_event(adapter->erp_ready_wq, 731 !list_empty(&adapter->erp_ready_head)); 732 zfcp_dbf_rec_run("erasox2", act); 733 if (act->status & ZFCP_STATUS_ERP_TIMEDOUT) 734 return ZFCP_ERP_FAILED; 735 736 return ZFCP_ERP_SUCCEEDED; 737 } 738 739 static int zfcp_erp_adapter_strategy_open_fsf(struct zfcp_erp_action *act) 740 { 741 if (zfcp_erp_adapter_strat_fsf_xconf(act) == ZFCP_ERP_FAILED) 742 return ZFCP_ERP_FAILED; 743 744 if (zfcp_erp_adapter_strategy_open_fsf_xport(act) == ZFCP_ERP_FAILED) 745 return ZFCP_ERP_FAILED; 746 747 if (mempool_resize(act->adapter->pool.sr_data, 748 act->adapter->stat_read_buf_num)) 749 return ZFCP_ERP_FAILED; 750 751 if (mempool_resize(act->adapter->pool.status_read_req, 752 act->adapter->stat_read_buf_num)) 753 return ZFCP_ERP_FAILED; 754 755 atomic_set(&act->adapter->stat_miss, act->adapter->stat_read_buf_num); 756 if (zfcp_status_read_refill(act->adapter)) 757 return ZFCP_ERP_FAILED; 758 759 return ZFCP_ERP_SUCCEEDED; 760 } 761 762 static void zfcp_erp_adapter_strategy_close(struct zfcp_erp_action *act) 763 { 764 struct zfcp_adapter *adapter = act->adapter; 765 766 /* close queues to ensure that buffers are not accessed by adapter */ 767 zfcp_qdio_close(adapter->qdio); 768 zfcp_fsf_req_dismiss_all(adapter); 769 adapter->fsf_req_seq_no = 0; 770 zfcp_fc_wka_ports_force_offline(adapter->gs); 771 /* all ports and LUNs are closed */ 772 zfcp_erp_clear_adapter_status(adapter, ZFCP_STATUS_COMMON_OPEN); 773 774 atomic_andnot(ZFCP_STATUS_ADAPTER_XCONFIG_OK | 775 ZFCP_STATUS_ADAPTER_LINK_UNPLUGGED, &adapter->status); 776 } 777 778 static int zfcp_erp_adapter_strategy_open(struct zfcp_erp_action *act) 779 { 780 struct zfcp_adapter *adapter = act->adapter; 781 782 if (zfcp_qdio_open(adapter->qdio)) { 783 atomic_andnot(ZFCP_STATUS_ADAPTER_XCONFIG_OK | 784 ZFCP_STATUS_ADAPTER_LINK_UNPLUGGED, 785 &adapter->status); 786 return ZFCP_ERP_FAILED; 787 } 788 789 if (zfcp_erp_adapter_strategy_open_fsf(act)) { 790 zfcp_erp_adapter_strategy_close(act); 791 return ZFCP_ERP_FAILED; 792 } 793 794 atomic_or(ZFCP_STATUS_COMMON_OPEN, &adapter->status); 795 796 return ZFCP_ERP_SUCCEEDED; 797 } 798 799 static int zfcp_erp_adapter_strategy(struct zfcp_erp_action *act) 800 { 801 struct zfcp_adapter *adapter = act->adapter; 802 803 if (atomic_read(&adapter->status) & ZFCP_STATUS_COMMON_OPEN) { 804 zfcp_erp_adapter_strategy_close(act); 805 if (act->status & ZFCP_STATUS_ERP_CLOSE_ONLY) 806 return ZFCP_ERP_EXIT; 807 } 808 809 if (zfcp_erp_adapter_strategy_open(act)) { 810 ssleep(8); 811 return ZFCP_ERP_FAILED; 812 } 813 814 return ZFCP_ERP_SUCCEEDED; 815 } 816 817 static int zfcp_erp_port_forced_strategy_close(struct zfcp_erp_action *act) 818 { 819 int retval; 820 821 retval = zfcp_fsf_close_physical_port(act); 822 if (retval == -ENOMEM) 823 return ZFCP_ERP_NOMEM; 824 act->step = ZFCP_ERP_STEP_PHYS_PORT_CLOSING; 825 if (retval) 826 return ZFCP_ERP_FAILED; 827 828 return ZFCP_ERP_CONTINUES; 829 } 830 831 static int zfcp_erp_port_forced_strategy(struct zfcp_erp_action *erp_action) 832 { 833 struct zfcp_port *port = erp_action->port; 834 int status = atomic_read(&port->status); 835 836 switch (erp_action->step) { 837 case ZFCP_ERP_STEP_UNINITIALIZED: 838 if ((status & ZFCP_STATUS_PORT_PHYS_OPEN) && 839 (status & ZFCP_STATUS_COMMON_OPEN)) 840 return zfcp_erp_port_forced_strategy_close(erp_action); 841 else 842 return ZFCP_ERP_FAILED; 843 844 case ZFCP_ERP_STEP_PHYS_PORT_CLOSING: 845 if (!(status & ZFCP_STATUS_PORT_PHYS_OPEN)) 846 return ZFCP_ERP_SUCCEEDED; 847 } 848 return ZFCP_ERP_FAILED; 849 } 850 851 static int zfcp_erp_port_strategy_close(struct zfcp_erp_action *erp_action) 852 { 853 int retval; 854 855 retval = zfcp_fsf_close_port(erp_action); 856 if (retval == -ENOMEM) 857 return ZFCP_ERP_NOMEM; 858 erp_action->step = ZFCP_ERP_STEP_PORT_CLOSING; 859 if (retval) 860 return ZFCP_ERP_FAILED; 861 return ZFCP_ERP_CONTINUES; 862 } 863 864 static int zfcp_erp_port_strategy_open_port(struct zfcp_erp_action *erp_action) 865 { 866 int retval; 867 868 retval = zfcp_fsf_open_port(erp_action); 869 if (retval == -ENOMEM) 870 return ZFCP_ERP_NOMEM; 871 erp_action->step = ZFCP_ERP_STEP_PORT_OPENING; 872 if (retval) 873 return ZFCP_ERP_FAILED; 874 return ZFCP_ERP_CONTINUES; 875 } 876 877 static int zfcp_erp_open_ptp_port(struct zfcp_erp_action *act) 878 { 879 struct zfcp_adapter *adapter = act->adapter; 880 struct zfcp_port *port = act->port; 881 882 if (port->wwpn != adapter->peer_wwpn) { 883 zfcp_erp_set_port_status(port, ZFCP_STATUS_COMMON_ERP_FAILED); 884 return ZFCP_ERP_FAILED; 885 } 886 port->d_id = adapter->peer_d_id; 887 return zfcp_erp_port_strategy_open_port(act); 888 } 889 890 static int zfcp_erp_port_strategy_open_common(struct zfcp_erp_action *act) 891 { 892 struct zfcp_adapter *adapter = act->adapter; 893 struct zfcp_port *port = act->port; 894 int p_status = atomic_read(&port->status); 895 896 switch (act->step) { 897 case ZFCP_ERP_STEP_UNINITIALIZED: 898 case ZFCP_ERP_STEP_PHYS_PORT_CLOSING: 899 case ZFCP_ERP_STEP_PORT_CLOSING: 900 if (fc_host_port_type(adapter->scsi_host) == FC_PORTTYPE_PTP) 901 return zfcp_erp_open_ptp_port(act); 902 if (!port->d_id) { 903 zfcp_fc_trigger_did_lookup(port); 904 return ZFCP_ERP_EXIT; 905 } 906 return zfcp_erp_port_strategy_open_port(act); 907 908 case ZFCP_ERP_STEP_PORT_OPENING: 909 /* D_ID might have changed during open */ 910 if (p_status & ZFCP_STATUS_COMMON_OPEN) { 911 if (!port->d_id) { 912 zfcp_fc_trigger_did_lookup(port); 913 return ZFCP_ERP_EXIT; 914 } 915 return ZFCP_ERP_SUCCEEDED; 916 } 917 if (port->d_id && !(p_status & ZFCP_STATUS_COMMON_NOESC)) { 918 port->d_id = 0; 919 return ZFCP_ERP_FAILED; 920 } 921 /* fall through otherwise */ 922 } 923 return ZFCP_ERP_FAILED; 924 } 925 926 static int zfcp_erp_port_strategy(struct zfcp_erp_action *erp_action) 927 { 928 struct zfcp_port *port = erp_action->port; 929 int p_status = atomic_read(&port->status); 930 931 if ((p_status & ZFCP_STATUS_COMMON_NOESC) && 932 !(p_status & ZFCP_STATUS_COMMON_OPEN)) 933 goto close_init_done; 934 935 switch (erp_action->step) { 936 case ZFCP_ERP_STEP_UNINITIALIZED: 937 if (p_status & ZFCP_STATUS_COMMON_OPEN) 938 return zfcp_erp_port_strategy_close(erp_action); 939 break; 940 941 case ZFCP_ERP_STEP_PORT_CLOSING: 942 if (p_status & ZFCP_STATUS_COMMON_OPEN) 943 return ZFCP_ERP_FAILED; 944 break; 945 } 946 947 close_init_done: 948 if (erp_action->status & ZFCP_STATUS_ERP_CLOSE_ONLY) 949 return ZFCP_ERP_EXIT; 950 951 return zfcp_erp_port_strategy_open_common(erp_action); 952 } 953 954 static void zfcp_erp_lun_strategy_clearstati(struct scsi_device *sdev) 955 { 956 struct zfcp_scsi_dev *zfcp_sdev = sdev_to_zfcp(sdev); 957 958 atomic_andnot(ZFCP_STATUS_COMMON_ACCESS_DENIED, 959 &zfcp_sdev->status); 960 } 961 962 static int zfcp_erp_lun_strategy_close(struct zfcp_erp_action *erp_action) 963 { 964 int retval = zfcp_fsf_close_lun(erp_action); 965 if (retval == -ENOMEM) 966 return ZFCP_ERP_NOMEM; 967 erp_action->step = ZFCP_ERP_STEP_LUN_CLOSING; 968 if (retval) 969 return ZFCP_ERP_FAILED; 970 return ZFCP_ERP_CONTINUES; 971 } 972 973 static int zfcp_erp_lun_strategy_open(struct zfcp_erp_action *erp_action) 974 { 975 int retval = zfcp_fsf_open_lun(erp_action); 976 if (retval == -ENOMEM) 977 return ZFCP_ERP_NOMEM; 978 erp_action->step = ZFCP_ERP_STEP_LUN_OPENING; 979 if (retval) 980 return ZFCP_ERP_FAILED; 981 return ZFCP_ERP_CONTINUES; 982 } 983 984 static int zfcp_erp_lun_strategy(struct zfcp_erp_action *erp_action) 985 { 986 struct scsi_device *sdev = erp_action->sdev; 987 struct zfcp_scsi_dev *zfcp_sdev = sdev_to_zfcp(sdev); 988 989 switch (erp_action->step) { 990 case ZFCP_ERP_STEP_UNINITIALIZED: 991 zfcp_erp_lun_strategy_clearstati(sdev); 992 if (atomic_read(&zfcp_sdev->status) & ZFCP_STATUS_COMMON_OPEN) 993 return zfcp_erp_lun_strategy_close(erp_action); 994 /* already closed, fall through */ 995 case ZFCP_ERP_STEP_LUN_CLOSING: 996 if (atomic_read(&zfcp_sdev->status) & ZFCP_STATUS_COMMON_OPEN) 997 return ZFCP_ERP_FAILED; 998 if (erp_action->status & ZFCP_STATUS_ERP_CLOSE_ONLY) 999 return ZFCP_ERP_EXIT; 1000 return zfcp_erp_lun_strategy_open(erp_action); 1001 1002 case ZFCP_ERP_STEP_LUN_OPENING: 1003 if (atomic_read(&zfcp_sdev->status) & ZFCP_STATUS_COMMON_OPEN) 1004 return ZFCP_ERP_SUCCEEDED; 1005 } 1006 return ZFCP_ERP_FAILED; 1007 } 1008 1009 static int zfcp_erp_strategy_check_lun(struct scsi_device *sdev, int result) 1010 { 1011 struct zfcp_scsi_dev *zfcp_sdev = sdev_to_zfcp(sdev); 1012 1013 switch (result) { 1014 case ZFCP_ERP_SUCCEEDED : 1015 atomic_set(&zfcp_sdev->erp_counter, 0); 1016 zfcp_erp_lun_unblock(sdev); 1017 break; 1018 case ZFCP_ERP_FAILED : 1019 atomic_inc(&zfcp_sdev->erp_counter); 1020 if (atomic_read(&zfcp_sdev->erp_counter) > ZFCP_MAX_ERPS) { 1021 dev_err(&zfcp_sdev->port->adapter->ccw_device->dev, 1022 "ERP failed for LUN 0x%016Lx on " 1023 "port 0x%016Lx\n", 1024 (unsigned long long)zfcp_scsi_dev_lun(sdev), 1025 (unsigned long long)zfcp_sdev->port->wwpn); 1026 zfcp_erp_set_lun_status(sdev, 1027 ZFCP_STATUS_COMMON_ERP_FAILED); 1028 } 1029 break; 1030 } 1031 1032 if (atomic_read(&zfcp_sdev->status) & ZFCP_STATUS_COMMON_ERP_FAILED) { 1033 zfcp_erp_lun_block(sdev, 0); 1034 result = ZFCP_ERP_EXIT; 1035 } 1036 return result; 1037 } 1038 1039 static int zfcp_erp_strategy_check_port(struct zfcp_port *port, int result) 1040 { 1041 switch (result) { 1042 case ZFCP_ERP_SUCCEEDED : 1043 atomic_set(&port->erp_counter, 0); 1044 zfcp_erp_port_unblock(port); 1045 break; 1046 1047 case ZFCP_ERP_FAILED : 1048 if (atomic_read(&port->status) & ZFCP_STATUS_COMMON_NOESC) { 1049 zfcp_erp_port_block(port, 0); 1050 result = ZFCP_ERP_EXIT; 1051 } 1052 atomic_inc(&port->erp_counter); 1053 if (atomic_read(&port->erp_counter) > ZFCP_MAX_ERPS) { 1054 dev_err(&port->adapter->ccw_device->dev, 1055 "ERP failed for remote port 0x%016Lx\n", 1056 (unsigned long long)port->wwpn); 1057 zfcp_erp_set_port_status(port, 1058 ZFCP_STATUS_COMMON_ERP_FAILED); 1059 } 1060 break; 1061 } 1062 1063 if (atomic_read(&port->status) & ZFCP_STATUS_COMMON_ERP_FAILED) { 1064 zfcp_erp_port_block(port, 0); 1065 result = ZFCP_ERP_EXIT; 1066 } 1067 return result; 1068 } 1069 1070 static int zfcp_erp_strategy_check_adapter(struct zfcp_adapter *adapter, 1071 int result) 1072 { 1073 switch (result) { 1074 case ZFCP_ERP_SUCCEEDED : 1075 atomic_set(&adapter->erp_counter, 0); 1076 zfcp_erp_adapter_unblock(adapter); 1077 break; 1078 1079 case ZFCP_ERP_FAILED : 1080 atomic_inc(&adapter->erp_counter); 1081 if (atomic_read(&adapter->erp_counter) > ZFCP_MAX_ERPS) { 1082 dev_err(&adapter->ccw_device->dev, 1083 "ERP cannot recover an error " 1084 "on the FCP device\n"); 1085 zfcp_erp_set_adapter_status(adapter, 1086 ZFCP_STATUS_COMMON_ERP_FAILED); 1087 } 1088 break; 1089 } 1090 1091 if (atomic_read(&adapter->status) & ZFCP_STATUS_COMMON_ERP_FAILED) { 1092 zfcp_erp_adapter_block(adapter, 0); 1093 result = ZFCP_ERP_EXIT; 1094 } 1095 return result; 1096 } 1097 1098 static int zfcp_erp_strategy_check_target(struct zfcp_erp_action *erp_action, 1099 int result) 1100 { 1101 struct zfcp_adapter *adapter = erp_action->adapter; 1102 struct zfcp_port *port = erp_action->port; 1103 struct scsi_device *sdev = erp_action->sdev; 1104 1105 switch (erp_action->action) { 1106 1107 case ZFCP_ERP_ACTION_REOPEN_LUN: 1108 result = zfcp_erp_strategy_check_lun(sdev, result); 1109 break; 1110 1111 case ZFCP_ERP_ACTION_REOPEN_PORT_FORCED: 1112 case ZFCP_ERP_ACTION_REOPEN_PORT: 1113 result = zfcp_erp_strategy_check_port(port, result); 1114 break; 1115 1116 case ZFCP_ERP_ACTION_REOPEN_ADAPTER: 1117 result = zfcp_erp_strategy_check_adapter(adapter, result); 1118 break; 1119 } 1120 return result; 1121 } 1122 1123 static int zfcp_erp_strat_change_det(atomic_t *target_status, u32 erp_status) 1124 { 1125 int status = atomic_read(target_status); 1126 1127 if ((status & ZFCP_STATUS_COMMON_RUNNING) && 1128 (erp_status & ZFCP_STATUS_ERP_CLOSE_ONLY)) 1129 return 1; /* take it online */ 1130 1131 if (!(status & ZFCP_STATUS_COMMON_RUNNING) && 1132 !(erp_status & ZFCP_STATUS_ERP_CLOSE_ONLY)) 1133 return 1; /* take it offline */ 1134 1135 return 0; 1136 } 1137 1138 static int zfcp_erp_strategy_statechange(struct zfcp_erp_action *act, int ret) 1139 { 1140 int action = act->action; 1141 struct zfcp_adapter *adapter = act->adapter; 1142 struct zfcp_port *port = act->port; 1143 struct scsi_device *sdev = act->sdev; 1144 struct zfcp_scsi_dev *zfcp_sdev; 1145 u32 erp_status = act->status; 1146 1147 switch (action) { 1148 case ZFCP_ERP_ACTION_REOPEN_ADAPTER: 1149 if (zfcp_erp_strat_change_det(&adapter->status, erp_status)) { 1150 _zfcp_erp_adapter_reopen(adapter, 1151 ZFCP_STATUS_COMMON_ERP_FAILED, 1152 "ersscg1"); 1153 return ZFCP_ERP_EXIT; 1154 } 1155 break; 1156 1157 case ZFCP_ERP_ACTION_REOPEN_PORT_FORCED: 1158 case ZFCP_ERP_ACTION_REOPEN_PORT: 1159 if (zfcp_erp_strat_change_det(&port->status, erp_status)) { 1160 _zfcp_erp_port_reopen(port, 1161 ZFCP_STATUS_COMMON_ERP_FAILED, 1162 "ersscg2"); 1163 return ZFCP_ERP_EXIT; 1164 } 1165 break; 1166 1167 case ZFCP_ERP_ACTION_REOPEN_LUN: 1168 zfcp_sdev = sdev_to_zfcp(sdev); 1169 if (zfcp_erp_strat_change_det(&zfcp_sdev->status, erp_status)) { 1170 _zfcp_erp_lun_reopen(sdev, 1171 ZFCP_STATUS_COMMON_ERP_FAILED, 1172 "ersscg3", 0); 1173 return ZFCP_ERP_EXIT; 1174 } 1175 break; 1176 } 1177 return ret; 1178 } 1179 1180 static void zfcp_erp_action_dequeue(struct zfcp_erp_action *erp_action) 1181 { 1182 struct zfcp_adapter *adapter = erp_action->adapter; 1183 struct zfcp_scsi_dev *zfcp_sdev; 1184 1185 adapter->erp_total_count--; 1186 if (erp_action->status & ZFCP_STATUS_ERP_LOWMEM) { 1187 adapter->erp_low_mem_count--; 1188 erp_action->status &= ~ZFCP_STATUS_ERP_LOWMEM; 1189 } 1190 1191 list_del(&erp_action->list); 1192 zfcp_dbf_rec_run("eractd1", erp_action); 1193 1194 switch (erp_action->action) { 1195 case ZFCP_ERP_ACTION_REOPEN_LUN: 1196 zfcp_sdev = sdev_to_zfcp(erp_action->sdev); 1197 atomic_andnot(ZFCP_STATUS_COMMON_ERP_INUSE, 1198 &zfcp_sdev->status); 1199 break; 1200 1201 case ZFCP_ERP_ACTION_REOPEN_PORT_FORCED: 1202 case ZFCP_ERP_ACTION_REOPEN_PORT: 1203 atomic_andnot(ZFCP_STATUS_COMMON_ERP_INUSE, 1204 &erp_action->port->status); 1205 break; 1206 1207 case ZFCP_ERP_ACTION_REOPEN_ADAPTER: 1208 atomic_andnot(ZFCP_STATUS_COMMON_ERP_INUSE, 1209 &erp_action->adapter->status); 1210 break; 1211 } 1212 } 1213 1214 /** 1215 * zfcp_erp_try_rport_unblock - unblock rport if no more/new recovery 1216 * @port: zfcp_port whose fc_rport we should try to unblock 1217 */ 1218 static void zfcp_erp_try_rport_unblock(struct zfcp_port *port) 1219 { 1220 unsigned long flags; 1221 struct zfcp_adapter *adapter = port->adapter; 1222 int port_status; 1223 struct Scsi_Host *shost = adapter->scsi_host; 1224 struct scsi_device *sdev; 1225 1226 write_lock_irqsave(&adapter->erp_lock, flags); 1227 port_status = atomic_read(&port->status); 1228 if ((port_status & ZFCP_STATUS_COMMON_UNBLOCKED) == 0 || 1229 (port_status & (ZFCP_STATUS_COMMON_ERP_INUSE | 1230 ZFCP_STATUS_COMMON_ERP_FAILED)) != 0) { 1231 /* new ERP of severity >= port triggered elsewhere meanwhile or 1232 * local link down (adapter erp_failed but not clear unblock) 1233 */ 1234 zfcp_dbf_rec_run_lvl(4, "ertru_p", &port->erp_action); 1235 write_unlock_irqrestore(&adapter->erp_lock, flags); 1236 return; 1237 } 1238 spin_lock(shost->host_lock); 1239 __shost_for_each_device(sdev, shost) { 1240 struct zfcp_scsi_dev *zsdev = sdev_to_zfcp(sdev); 1241 int lun_status; 1242 1243 if (zsdev->port != port) 1244 continue; 1245 /* LUN under port of interest */ 1246 lun_status = atomic_read(&zsdev->status); 1247 if ((lun_status & ZFCP_STATUS_COMMON_ERP_FAILED) != 0) 1248 continue; /* unblock rport despite failed LUNs */ 1249 /* LUN recovery not given up yet [maybe follow-up pending] */ 1250 if ((lun_status & ZFCP_STATUS_COMMON_UNBLOCKED) == 0 || 1251 (lun_status & ZFCP_STATUS_COMMON_ERP_INUSE) != 0) { 1252 /* LUN blocked: 1253 * not yet unblocked [LUN recovery pending] 1254 * or meanwhile blocked [new LUN recovery triggered] 1255 */ 1256 zfcp_dbf_rec_run_lvl(4, "ertru_l", &zsdev->erp_action); 1257 spin_unlock(shost->host_lock); 1258 write_unlock_irqrestore(&adapter->erp_lock, flags); 1259 return; 1260 } 1261 } 1262 /* now port has no child or all children have completed recovery, 1263 * and no ERP of severity >= port was meanwhile triggered elsewhere 1264 */ 1265 zfcp_scsi_schedule_rport_register(port); 1266 spin_unlock(shost->host_lock); 1267 write_unlock_irqrestore(&adapter->erp_lock, flags); 1268 } 1269 1270 static void zfcp_erp_action_cleanup(struct zfcp_erp_action *act, int result) 1271 { 1272 struct zfcp_adapter *adapter = act->adapter; 1273 struct zfcp_port *port = act->port; 1274 struct scsi_device *sdev = act->sdev; 1275 1276 switch (act->action) { 1277 case ZFCP_ERP_ACTION_REOPEN_LUN: 1278 if (!(act->status & ZFCP_STATUS_ERP_NO_REF)) 1279 scsi_device_put(sdev); 1280 zfcp_erp_try_rport_unblock(port); 1281 break; 1282 1283 case ZFCP_ERP_ACTION_REOPEN_PORT: 1284 /* This switch case might also happen after a forced reopen 1285 * was successfully done and thus overwritten with a new 1286 * non-forced reopen at `ersfs_2'. In this case, we must not 1287 * do the clean-up of the non-forced version. 1288 */ 1289 if (act->step != ZFCP_ERP_STEP_UNINITIALIZED) 1290 if (result == ZFCP_ERP_SUCCEEDED) 1291 zfcp_erp_try_rport_unblock(port); 1292 /* fall through */ 1293 case ZFCP_ERP_ACTION_REOPEN_PORT_FORCED: 1294 put_device(&port->dev); 1295 break; 1296 1297 case ZFCP_ERP_ACTION_REOPEN_ADAPTER: 1298 if (result == ZFCP_ERP_SUCCEEDED) { 1299 register_service_level(&adapter->service_level); 1300 zfcp_fc_conditional_port_scan(adapter); 1301 queue_work(adapter->work_queue, &adapter->ns_up_work); 1302 } else 1303 unregister_service_level(&adapter->service_level); 1304 1305 kref_put(&adapter->ref, zfcp_adapter_release); 1306 break; 1307 } 1308 } 1309 1310 static int zfcp_erp_strategy_do_action(struct zfcp_erp_action *erp_action) 1311 { 1312 switch (erp_action->action) { 1313 case ZFCP_ERP_ACTION_REOPEN_ADAPTER: 1314 return zfcp_erp_adapter_strategy(erp_action); 1315 case ZFCP_ERP_ACTION_REOPEN_PORT_FORCED: 1316 return zfcp_erp_port_forced_strategy(erp_action); 1317 case ZFCP_ERP_ACTION_REOPEN_PORT: 1318 return zfcp_erp_port_strategy(erp_action); 1319 case ZFCP_ERP_ACTION_REOPEN_LUN: 1320 return zfcp_erp_lun_strategy(erp_action); 1321 } 1322 return ZFCP_ERP_FAILED; 1323 } 1324 1325 static int zfcp_erp_strategy(struct zfcp_erp_action *erp_action) 1326 { 1327 int retval; 1328 unsigned long flags; 1329 struct zfcp_adapter *adapter = erp_action->adapter; 1330 1331 kref_get(&adapter->ref); 1332 1333 write_lock_irqsave(&adapter->erp_lock, flags); 1334 zfcp_erp_strategy_check_fsfreq(erp_action); 1335 1336 if (erp_action->status & ZFCP_STATUS_ERP_DISMISSED) { 1337 zfcp_erp_action_dequeue(erp_action); 1338 retval = ZFCP_ERP_DISMISSED; 1339 goto unlock; 1340 } 1341 1342 if (erp_action->status & ZFCP_STATUS_ERP_TIMEDOUT) { 1343 retval = ZFCP_ERP_FAILED; 1344 goto check_target; 1345 } 1346 1347 zfcp_erp_action_to_running(erp_action); 1348 1349 /* no lock to allow for blocking operations */ 1350 write_unlock_irqrestore(&adapter->erp_lock, flags); 1351 retval = zfcp_erp_strategy_do_action(erp_action); 1352 write_lock_irqsave(&adapter->erp_lock, flags); 1353 1354 if (erp_action->status & ZFCP_STATUS_ERP_DISMISSED) 1355 retval = ZFCP_ERP_CONTINUES; 1356 1357 switch (retval) { 1358 case ZFCP_ERP_NOMEM: 1359 if (!(erp_action->status & ZFCP_STATUS_ERP_LOWMEM)) { 1360 ++adapter->erp_low_mem_count; 1361 erp_action->status |= ZFCP_STATUS_ERP_LOWMEM; 1362 } 1363 if (adapter->erp_total_count == adapter->erp_low_mem_count) 1364 _zfcp_erp_adapter_reopen(adapter, 0, "erstgy1"); 1365 else { 1366 zfcp_erp_strategy_memwait(erp_action); 1367 retval = ZFCP_ERP_CONTINUES; 1368 } 1369 goto unlock; 1370 1371 case ZFCP_ERP_CONTINUES: 1372 if (erp_action->status & ZFCP_STATUS_ERP_LOWMEM) { 1373 --adapter->erp_low_mem_count; 1374 erp_action->status &= ~ZFCP_STATUS_ERP_LOWMEM; 1375 } 1376 goto unlock; 1377 } 1378 1379 check_target: 1380 retval = zfcp_erp_strategy_check_target(erp_action, retval); 1381 zfcp_erp_action_dequeue(erp_action); 1382 retval = zfcp_erp_strategy_statechange(erp_action, retval); 1383 if (retval == ZFCP_ERP_EXIT) 1384 goto unlock; 1385 if (retval == ZFCP_ERP_SUCCEEDED) 1386 zfcp_erp_strategy_followup_success(erp_action); 1387 if (retval == ZFCP_ERP_FAILED) 1388 zfcp_erp_strategy_followup_failed(erp_action); 1389 1390 unlock: 1391 write_unlock_irqrestore(&adapter->erp_lock, flags); 1392 1393 if (retval != ZFCP_ERP_CONTINUES) 1394 zfcp_erp_action_cleanup(erp_action, retval); 1395 1396 kref_put(&adapter->ref, zfcp_adapter_release); 1397 return retval; 1398 } 1399 1400 static int zfcp_erp_thread(void *data) 1401 { 1402 struct zfcp_adapter *adapter = (struct zfcp_adapter *) data; 1403 struct list_head *next; 1404 struct zfcp_erp_action *act; 1405 unsigned long flags; 1406 1407 for (;;) { 1408 wait_event_interruptible(adapter->erp_ready_wq, 1409 !list_empty(&adapter->erp_ready_head) || 1410 kthread_should_stop()); 1411 1412 if (kthread_should_stop()) 1413 break; 1414 1415 write_lock_irqsave(&adapter->erp_lock, flags); 1416 next = adapter->erp_ready_head.next; 1417 write_unlock_irqrestore(&adapter->erp_lock, flags); 1418 1419 if (next != &adapter->erp_ready_head) { 1420 act = list_entry(next, struct zfcp_erp_action, list); 1421 1422 /* there is more to come after dismission, no notify */ 1423 if (zfcp_erp_strategy(act) != ZFCP_ERP_DISMISSED) 1424 zfcp_erp_wakeup(adapter); 1425 } 1426 } 1427 1428 return 0; 1429 } 1430 1431 /** 1432 * zfcp_erp_thread_setup - Start ERP thread for adapter 1433 * @adapter: Adapter to start the ERP thread for 1434 * 1435 * Returns 0 on success or error code from kernel_thread() 1436 */ 1437 int zfcp_erp_thread_setup(struct zfcp_adapter *adapter) 1438 { 1439 struct task_struct *thread; 1440 1441 thread = kthread_run(zfcp_erp_thread, adapter, "zfcperp%s", 1442 dev_name(&adapter->ccw_device->dev)); 1443 if (IS_ERR(thread)) { 1444 dev_err(&adapter->ccw_device->dev, 1445 "Creating an ERP thread for the FCP device failed.\n"); 1446 return PTR_ERR(thread); 1447 } 1448 1449 adapter->erp_thread = thread; 1450 return 0; 1451 } 1452 1453 /** 1454 * zfcp_erp_thread_kill - Stop ERP thread. 1455 * @adapter: Adapter where the ERP thread should be stopped. 1456 * 1457 * The caller of this routine ensures that the specified adapter has 1458 * been shut down and that this operation has been completed. Thus, 1459 * there are no pending erp_actions which would need to be handled 1460 * here. 1461 */ 1462 void zfcp_erp_thread_kill(struct zfcp_adapter *adapter) 1463 { 1464 kthread_stop(adapter->erp_thread); 1465 adapter->erp_thread = NULL; 1466 WARN_ON(!list_empty(&adapter->erp_ready_head)); 1467 WARN_ON(!list_empty(&adapter->erp_running_head)); 1468 } 1469 1470 /** 1471 * zfcp_erp_wait - wait for completion of error recovery on an adapter 1472 * @adapter: adapter for which to wait for completion of its error recovery 1473 */ 1474 void zfcp_erp_wait(struct zfcp_adapter *adapter) 1475 { 1476 wait_event(adapter->erp_done_wqh, 1477 !(atomic_read(&adapter->status) & 1478 ZFCP_STATUS_ADAPTER_ERP_PENDING)); 1479 } 1480 1481 /** 1482 * zfcp_erp_set_adapter_status - set adapter status bits 1483 * @adapter: adapter to change the status 1484 * @mask: status bits to change 1485 * 1486 * Changes in common status bits are propagated to attached ports and LUNs. 1487 */ 1488 void zfcp_erp_set_adapter_status(struct zfcp_adapter *adapter, u32 mask) 1489 { 1490 struct zfcp_port *port; 1491 struct scsi_device *sdev; 1492 unsigned long flags; 1493 u32 common_mask = mask & ZFCP_COMMON_FLAGS; 1494 1495 atomic_or(mask, &adapter->status); 1496 1497 if (!common_mask) 1498 return; 1499 1500 read_lock_irqsave(&adapter->port_list_lock, flags); 1501 list_for_each_entry(port, &adapter->port_list, list) 1502 atomic_or(common_mask, &port->status); 1503 read_unlock_irqrestore(&adapter->port_list_lock, flags); 1504 1505 spin_lock_irqsave(adapter->scsi_host->host_lock, flags); 1506 __shost_for_each_device(sdev, adapter->scsi_host) 1507 atomic_or(common_mask, &sdev_to_zfcp(sdev)->status); 1508 spin_unlock_irqrestore(adapter->scsi_host->host_lock, flags); 1509 } 1510 1511 /** 1512 * zfcp_erp_clear_adapter_status - clear adapter status bits 1513 * @adapter: adapter to change the status 1514 * @mask: status bits to change 1515 * 1516 * Changes in common status bits are propagated to attached ports and LUNs. 1517 */ 1518 void zfcp_erp_clear_adapter_status(struct zfcp_adapter *adapter, u32 mask) 1519 { 1520 struct zfcp_port *port; 1521 struct scsi_device *sdev; 1522 unsigned long flags; 1523 u32 common_mask = mask & ZFCP_COMMON_FLAGS; 1524 u32 clear_counter = mask & ZFCP_STATUS_COMMON_ERP_FAILED; 1525 1526 atomic_andnot(mask, &adapter->status); 1527 1528 if (!common_mask) 1529 return; 1530 1531 if (clear_counter) 1532 atomic_set(&adapter->erp_counter, 0); 1533 1534 read_lock_irqsave(&adapter->port_list_lock, flags); 1535 list_for_each_entry(port, &adapter->port_list, list) { 1536 atomic_andnot(common_mask, &port->status); 1537 if (clear_counter) 1538 atomic_set(&port->erp_counter, 0); 1539 } 1540 read_unlock_irqrestore(&adapter->port_list_lock, flags); 1541 1542 spin_lock_irqsave(adapter->scsi_host->host_lock, flags); 1543 __shost_for_each_device(sdev, adapter->scsi_host) { 1544 atomic_andnot(common_mask, &sdev_to_zfcp(sdev)->status); 1545 if (clear_counter) 1546 atomic_set(&sdev_to_zfcp(sdev)->erp_counter, 0); 1547 } 1548 spin_unlock_irqrestore(adapter->scsi_host->host_lock, flags); 1549 } 1550 1551 /** 1552 * zfcp_erp_set_port_status - set port status bits 1553 * @port: port to change the status 1554 * @mask: status bits to change 1555 * 1556 * Changes in common status bits are propagated to attached LUNs. 1557 */ 1558 void zfcp_erp_set_port_status(struct zfcp_port *port, u32 mask) 1559 { 1560 struct scsi_device *sdev; 1561 u32 common_mask = mask & ZFCP_COMMON_FLAGS; 1562 unsigned long flags; 1563 1564 atomic_or(mask, &port->status); 1565 1566 if (!common_mask) 1567 return; 1568 1569 spin_lock_irqsave(port->adapter->scsi_host->host_lock, flags); 1570 __shost_for_each_device(sdev, port->adapter->scsi_host) 1571 if (sdev_to_zfcp(sdev)->port == port) 1572 atomic_or(common_mask, 1573 &sdev_to_zfcp(sdev)->status); 1574 spin_unlock_irqrestore(port->adapter->scsi_host->host_lock, flags); 1575 } 1576 1577 /** 1578 * zfcp_erp_clear_port_status - clear port status bits 1579 * @port: adapter to change the status 1580 * @mask: status bits to change 1581 * 1582 * Changes in common status bits are propagated to attached LUNs. 1583 */ 1584 void zfcp_erp_clear_port_status(struct zfcp_port *port, u32 mask) 1585 { 1586 struct scsi_device *sdev; 1587 u32 common_mask = mask & ZFCP_COMMON_FLAGS; 1588 u32 clear_counter = mask & ZFCP_STATUS_COMMON_ERP_FAILED; 1589 unsigned long flags; 1590 1591 atomic_andnot(mask, &port->status); 1592 1593 if (!common_mask) 1594 return; 1595 1596 if (clear_counter) 1597 atomic_set(&port->erp_counter, 0); 1598 1599 spin_lock_irqsave(port->adapter->scsi_host->host_lock, flags); 1600 __shost_for_each_device(sdev, port->adapter->scsi_host) 1601 if (sdev_to_zfcp(sdev)->port == port) { 1602 atomic_andnot(common_mask, 1603 &sdev_to_zfcp(sdev)->status); 1604 if (clear_counter) 1605 atomic_set(&sdev_to_zfcp(sdev)->erp_counter, 0); 1606 } 1607 spin_unlock_irqrestore(port->adapter->scsi_host->host_lock, flags); 1608 } 1609 1610 /** 1611 * zfcp_erp_set_lun_status - set lun status bits 1612 * @sdev: SCSI device / lun to set the status bits 1613 * @mask: status bits to change 1614 */ 1615 void zfcp_erp_set_lun_status(struct scsi_device *sdev, u32 mask) 1616 { 1617 struct zfcp_scsi_dev *zfcp_sdev = sdev_to_zfcp(sdev); 1618 1619 atomic_or(mask, &zfcp_sdev->status); 1620 } 1621 1622 /** 1623 * zfcp_erp_clear_lun_status - clear lun status bits 1624 * @sdev: SCSi device / lun to clear the status bits 1625 * @mask: status bits to change 1626 */ 1627 void zfcp_erp_clear_lun_status(struct scsi_device *sdev, u32 mask) 1628 { 1629 struct zfcp_scsi_dev *zfcp_sdev = sdev_to_zfcp(sdev); 1630 1631 atomic_andnot(mask, &zfcp_sdev->status); 1632 1633 if (mask & ZFCP_STATUS_COMMON_ERP_FAILED) 1634 atomic_set(&zfcp_sdev->erp_counter, 0); 1635 } 1636 1637