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