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