1 /* 2 * zfcp device driver 3 * 4 * Error Recovery Procedures (ERP). 5 * 6 * Copyright IBM Corp. 2002, 2015 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 static void zfcp_erp_action_cleanup(struct zfcp_erp_action *act, int result) 1208 { 1209 struct zfcp_adapter *adapter = act->adapter; 1210 struct zfcp_port *port = act->port; 1211 struct scsi_device *sdev = act->sdev; 1212 1213 switch (act->action) { 1214 case ZFCP_ERP_ACTION_REOPEN_LUN: 1215 if (!(act->status & ZFCP_STATUS_ERP_NO_REF)) 1216 scsi_device_put(sdev); 1217 break; 1218 1219 case ZFCP_ERP_ACTION_REOPEN_PORT: 1220 /* This switch case might also happen after a forced reopen 1221 * was successfully done and thus overwritten with a new 1222 * non-forced reopen at `ersfs_2'. In this case, we must not 1223 * do the clean-up of the non-forced version. 1224 */ 1225 if (act->step != ZFCP_ERP_STEP_UNINITIALIZED) 1226 if (result == ZFCP_ERP_SUCCEEDED) 1227 zfcp_scsi_schedule_rport_register(port); 1228 /* fall through */ 1229 case ZFCP_ERP_ACTION_REOPEN_PORT_FORCED: 1230 put_device(&port->dev); 1231 break; 1232 1233 case ZFCP_ERP_ACTION_REOPEN_ADAPTER: 1234 if (result == ZFCP_ERP_SUCCEEDED) { 1235 register_service_level(&adapter->service_level); 1236 zfcp_fc_conditional_port_scan(adapter); 1237 queue_work(adapter->work_queue, &adapter->ns_up_work); 1238 } else 1239 unregister_service_level(&adapter->service_level); 1240 1241 kref_put(&adapter->ref, zfcp_adapter_release); 1242 break; 1243 } 1244 } 1245 1246 static int zfcp_erp_strategy_do_action(struct zfcp_erp_action *erp_action) 1247 { 1248 switch (erp_action->action) { 1249 case ZFCP_ERP_ACTION_REOPEN_ADAPTER: 1250 return zfcp_erp_adapter_strategy(erp_action); 1251 case ZFCP_ERP_ACTION_REOPEN_PORT_FORCED: 1252 return zfcp_erp_port_forced_strategy(erp_action); 1253 case ZFCP_ERP_ACTION_REOPEN_PORT: 1254 return zfcp_erp_port_strategy(erp_action); 1255 case ZFCP_ERP_ACTION_REOPEN_LUN: 1256 return zfcp_erp_lun_strategy(erp_action); 1257 } 1258 return ZFCP_ERP_FAILED; 1259 } 1260 1261 static int zfcp_erp_strategy(struct zfcp_erp_action *erp_action) 1262 { 1263 int retval; 1264 unsigned long flags; 1265 struct zfcp_adapter *adapter = erp_action->adapter; 1266 1267 kref_get(&adapter->ref); 1268 1269 write_lock_irqsave(&adapter->erp_lock, flags); 1270 zfcp_erp_strategy_check_fsfreq(erp_action); 1271 1272 if (erp_action->status & ZFCP_STATUS_ERP_DISMISSED) { 1273 zfcp_erp_action_dequeue(erp_action); 1274 retval = ZFCP_ERP_DISMISSED; 1275 goto unlock; 1276 } 1277 1278 if (erp_action->status & ZFCP_STATUS_ERP_TIMEDOUT) { 1279 retval = ZFCP_ERP_FAILED; 1280 goto check_target; 1281 } 1282 1283 zfcp_erp_action_to_running(erp_action); 1284 1285 /* no lock to allow for blocking operations */ 1286 write_unlock_irqrestore(&adapter->erp_lock, flags); 1287 retval = zfcp_erp_strategy_do_action(erp_action); 1288 write_lock_irqsave(&adapter->erp_lock, flags); 1289 1290 if (erp_action->status & ZFCP_STATUS_ERP_DISMISSED) 1291 retval = ZFCP_ERP_CONTINUES; 1292 1293 switch (retval) { 1294 case ZFCP_ERP_NOMEM: 1295 if (!(erp_action->status & ZFCP_STATUS_ERP_LOWMEM)) { 1296 ++adapter->erp_low_mem_count; 1297 erp_action->status |= ZFCP_STATUS_ERP_LOWMEM; 1298 } 1299 if (adapter->erp_total_count == adapter->erp_low_mem_count) 1300 _zfcp_erp_adapter_reopen(adapter, 0, "erstgy1"); 1301 else { 1302 zfcp_erp_strategy_memwait(erp_action); 1303 retval = ZFCP_ERP_CONTINUES; 1304 } 1305 goto unlock; 1306 1307 case ZFCP_ERP_CONTINUES: 1308 if (erp_action->status & ZFCP_STATUS_ERP_LOWMEM) { 1309 --adapter->erp_low_mem_count; 1310 erp_action->status &= ~ZFCP_STATUS_ERP_LOWMEM; 1311 } 1312 goto unlock; 1313 } 1314 1315 check_target: 1316 retval = zfcp_erp_strategy_check_target(erp_action, retval); 1317 zfcp_erp_action_dequeue(erp_action); 1318 retval = zfcp_erp_strategy_statechange(erp_action, retval); 1319 if (retval == ZFCP_ERP_EXIT) 1320 goto unlock; 1321 if (retval == ZFCP_ERP_SUCCEEDED) 1322 zfcp_erp_strategy_followup_success(erp_action); 1323 if (retval == ZFCP_ERP_FAILED) 1324 zfcp_erp_strategy_followup_failed(erp_action); 1325 1326 unlock: 1327 write_unlock_irqrestore(&adapter->erp_lock, flags); 1328 1329 if (retval != ZFCP_ERP_CONTINUES) 1330 zfcp_erp_action_cleanup(erp_action, retval); 1331 1332 kref_put(&adapter->ref, zfcp_adapter_release); 1333 return retval; 1334 } 1335 1336 static int zfcp_erp_thread(void *data) 1337 { 1338 struct zfcp_adapter *adapter = (struct zfcp_adapter *) data; 1339 struct list_head *next; 1340 struct zfcp_erp_action *act; 1341 unsigned long flags; 1342 1343 for (;;) { 1344 wait_event_interruptible(adapter->erp_ready_wq, 1345 !list_empty(&adapter->erp_ready_head) || 1346 kthread_should_stop()); 1347 1348 if (kthread_should_stop()) 1349 break; 1350 1351 write_lock_irqsave(&adapter->erp_lock, flags); 1352 next = adapter->erp_ready_head.next; 1353 write_unlock_irqrestore(&adapter->erp_lock, flags); 1354 1355 if (next != &adapter->erp_ready_head) { 1356 act = list_entry(next, struct zfcp_erp_action, list); 1357 1358 /* there is more to come after dismission, no notify */ 1359 if (zfcp_erp_strategy(act) != ZFCP_ERP_DISMISSED) 1360 zfcp_erp_wakeup(adapter); 1361 } 1362 } 1363 1364 return 0; 1365 } 1366 1367 /** 1368 * zfcp_erp_thread_setup - Start ERP thread for adapter 1369 * @adapter: Adapter to start the ERP thread for 1370 * 1371 * Returns 0 on success or error code from kernel_thread() 1372 */ 1373 int zfcp_erp_thread_setup(struct zfcp_adapter *adapter) 1374 { 1375 struct task_struct *thread; 1376 1377 thread = kthread_run(zfcp_erp_thread, adapter, "zfcperp%s", 1378 dev_name(&adapter->ccw_device->dev)); 1379 if (IS_ERR(thread)) { 1380 dev_err(&adapter->ccw_device->dev, 1381 "Creating an ERP thread for the FCP device failed.\n"); 1382 return PTR_ERR(thread); 1383 } 1384 1385 adapter->erp_thread = thread; 1386 return 0; 1387 } 1388 1389 /** 1390 * zfcp_erp_thread_kill - Stop ERP thread. 1391 * @adapter: Adapter where the ERP thread should be stopped. 1392 * 1393 * The caller of this routine ensures that the specified adapter has 1394 * been shut down and that this operation has been completed. Thus, 1395 * there are no pending erp_actions which would need to be handled 1396 * here. 1397 */ 1398 void zfcp_erp_thread_kill(struct zfcp_adapter *adapter) 1399 { 1400 kthread_stop(adapter->erp_thread); 1401 adapter->erp_thread = NULL; 1402 WARN_ON(!list_empty(&adapter->erp_ready_head)); 1403 WARN_ON(!list_empty(&adapter->erp_running_head)); 1404 } 1405 1406 /** 1407 * zfcp_erp_wait - wait for completion of error recovery on an adapter 1408 * @adapter: adapter for which to wait for completion of its error recovery 1409 */ 1410 void zfcp_erp_wait(struct zfcp_adapter *adapter) 1411 { 1412 wait_event(adapter->erp_done_wqh, 1413 !(atomic_read(&adapter->status) & 1414 ZFCP_STATUS_ADAPTER_ERP_PENDING)); 1415 } 1416 1417 /** 1418 * zfcp_erp_set_adapter_status - set adapter status bits 1419 * @adapter: adapter to change the status 1420 * @mask: status bits to change 1421 * 1422 * Changes in common status bits are propagated to attached ports and LUNs. 1423 */ 1424 void zfcp_erp_set_adapter_status(struct zfcp_adapter *adapter, u32 mask) 1425 { 1426 struct zfcp_port *port; 1427 struct scsi_device *sdev; 1428 unsigned long flags; 1429 u32 common_mask = mask & ZFCP_COMMON_FLAGS; 1430 1431 atomic_or(mask, &adapter->status); 1432 1433 if (!common_mask) 1434 return; 1435 1436 read_lock_irqsave(&adapter->port_list_lock, flags); 1437 list_for_each_entry(port, &adapter->port_list, list) 1438 atomic_or(common_mask, &port->status); 1439 read_unlock_irqrestore(&adapter->port_list_lock, flags); 1440 1441 spin_lock_irqsave(adapter->scsi_host->host_lock, flags); 1442 __shost_for_each_device(sdev, adapter->scsi_host) 1443 atomic_or(common_mask, &sdev_to_zfcp(sdev)->status); 1444 spin_unlock_irqrestore(adapter->scsi_host->host_lock, flags); 1445 } 1446 1447 /** 1448 * zfcp_erp_clear_adapter_status - clear adapter status bits 1449 * @adapter: adapter to change the status 1450 * @mask: status bits to change 1451 * 1452 * Changes in common status bits are propagated to attached ports and LUNs. 1453 */ 1454 void zfcp_erp_clear_adapter_status(struct zfcp_adapter *adapter, u32 mask) 1455 { 1456 struct zfcp_port *port; 1457 struct scsi_device *sdev; 1458 unsigned long flags; 1459 u32 common_mask = mask & ZFCP_COMMON_FLAGS; 1460 u32 clear_counter = mask & ZFCP_STATUS_COMMON_ERP_FAILED; 1461 1462 atomic_andnot(mask, &adapter->status); 1463 1464 if (!common_mask) 1465 return; 1466 1467 if (clear_counter) 1468 atomic_set(&adapter->erp_counter, 0); 1469 1470 read_lock_irqsave(&adapter->port_list_lock, flags); 1471 list_for_each_entry(port, &adapter->port_list, list) { 1472 atomic_andnot(common_mask, &port->status); 1473 if (clear_counter) 1474 atomic_set(&port->erp_counter, 0); 1475 } 1476 read_unlock_irqrestore(&adapter->port_list_lock, flags); 1477 1478 spin_lock_irqsave(adapter->scsi_host->host_lock, flags); 1479 __shost_for_each_device(sdev, adapter->scsi_host) { 1480 atomic_andnot(common_mask, &sdev_to_zfcp(sdev)->status); 1481 if (clear_counter) 1482 atomic_set(&sdev_to_zfcp(sdev)->erp_counter, 0); 1483 } 1484 spin_unlock_irqrestore(adapter->scsi_host->host_lock, flags); 1485 } 1486 1487 /** 1488 * zfcp_erp_set_port_status - set port status bits 1489 * @port: port to change the status 1490 * @mask: status bits to change 1491 * 1492 * Changes in common status bits are propagated to attached LUNs. 1493 */ 1494 void zfcp_erp_set_port_status(struct zfcp_port *port, u32 mask) 1495 { 1496 struct scsi_device *sdev; 1497 u32 common_mask = mask & ZFCP_COMMON_FLAGS; 1498 unsigned long flags; 1499 1500 atomic_or(mask, &port->status); 1501 1502 if (!common_mask) 1503 return; 1504 1505 spin_lock_irqsave(port->adapter->scsi_host->host_lock, flags); 1506 __shost_for_each_device(sdev, port->adapter->scsi_host) 1507 if (sdev_to_zfcp(sdev)->port == port) 1508 atomic_or(common_mask, 1509 &sdev_to_zfcp(sdev)->status); 1510 spin_unlock_irqrestore(port->adapter->scsi_host->host_lock, flags); 1511 } 1512 1513 /** 1514 * zfcp_erp_clear_port_status - clear port status bits 1515 * @port: adapter to change the status 1516 * @mask: status bits to change 1517 * 1518 * Changes in common status bits are propagated to attached LUNs. 1519 */ 1520 void zfcp_erp_clear_port_status(struct zfcp_port *port, u32 mask) 1521 { 1522 struct scsi_device *sdev; 1523 u32 common_mask = mask & ZFCP_COMMON_FLAGS; 1524 u32 clear_counter = mask & ZFCP_STATUS_COMMON_ERP_FAILED; 1525 unsigned long flags; 1526 1527 atomic_andnot(mask, &port->status); 1528 1529 if (!common_mask) 1530 return; 1531 1532 if (clear_counter) 1533 atomic_set(&port->erp_counter, 0); 1534 1535 spin_lock_irqsave(port->adapter->scsi_host->host_lock, flags); 1536 __shost_for_each_device(sdev, port->adapter->scsi_host) 1537 if (sdev_to_zfcp(sdev)->port == port) { 1538 atomic_andnot(common_mask, 1539 &sdev_to_zfcp(sdev)->status); 1540 if (clear_counter) 1541 atomic_set(&sdev_to_zfcp(sdev)->erp_counter, 0); 1542 } 1543 spin_unlock_irqrestore(port->adapter->scsi_host->host_lock, flags); 1544 } 1545 1546 /** 1547 * zfcp_erp_set_lun_status - set lun status bits 1548 * @sdev: SCSI device / lun to set the status bits 1549 * @mask: status bits to change 1550 */ 1551 void zfcp_erp_set_lun_status(struct scsi_device *sdev, u32 mask) 1552 { 1553 struct zfcp_scsi_dev *zfcp_sdev = sdev_to_zfcp(sdev); 1554 1555 atomic_or(mask, &zfcp_sdev->status); 1556 } 1557 1558 /** 1559 * zfcp_erp_clear_lun_status - clear lun status bits 1560 * @sdev: SCSi device / lun to clear the status bits 1561 * @mask: status bits to change 1562 */ 1563 void zfcp_erp_clear_lun_status(struct scsi_device *sdev, u32 mask) 1564 { 1565 struct zfcp_scsi_dev *zfcp_sdev = sdev_to_zfcp(sdev); 1566 1567 atomic_andnot(mask, &zfcp_sdev->status); 1568 1569 if (mask & ZFCP_STATUS_COMMON_ERP_FAILED) 1570 atomic_set(&zfcp_sdev->erp_counter, 0); 1571 } 1572 1573