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