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