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