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