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 list_head *next;
1611	struct zfcp_erp_action *act;
1612	unsigned long flags;
1613
1614	for (;;) {
1615		wait_event_interruptible(adapter->erp_ready_wq,
1616			   !list_empty(&adapter->erp_ready_head) ||
1617			   kthread_should_stop());
1618
1619		if (kthread_should_stop())
1620			break;
1621
1622		write_lock_irqsave(&adapter->erp_lock, flags);
1623		next = adapter->erp_ready_head.next;
1624		write_unlock_irqrestore(&adapter->erp_lock, flags);
1625
1626		if (next != &adapter->erp_ready_head) {
1627			act = list_entry(next, struct zfcp_erp_action, list);
1628
1629			/* there is more to come after dismission, no notify */
1630			if (zfcp_erp_strategy(act) != ZFCP_ERP_DISMISSED)
1631				zfcp_erp_wakeup(adapter);
1632		}
1633	}
1634
1635	return 0;
1636}
1637
1638/**
1639 * zfcp_erp_thread_setup - Start ERP thread for adapter
1640 * @adapter: Adapter to start the ERP thread for
1641 *
1642 * Return: 0 on success, or error code from kthread_run().
1643 */
1644int zfcp_erp_thread_setup(struct zfcp_adapter *adapter)
1645{
1646	struct task_struct *thread;
1647
1648	thread = kthread_run(zfcp_erp_thread, adapter, "zfcperp%s",
1649			     dev_name(&adapter->ccw_device->dev));
1650	if (IS_ERR(thread)) {
1651		dev_err(&adapter->ccw_device->dev,
1652			"Creating an ERP thread for the FCP device failed.\n");
1653		return PTR_ERR(thread);
1654	}
1655
1656	adapter->erp_thread = thread;
1657	return 0;
1658}
1659
1660/**
1661 * zfcp_erp_thread_kill - Stop ERP thread.
1662 * @adapter: Adapter where the ERP thread should be stopped.
1663 *
1664 * The caller of this routine ensures that the specified adapter has
1665 * been shut down and that this operation has been completed. Thus,
1666 * there are no pending erp_actions which would need to be handled
1667 * here.
1668 */
1669void zfcp_erp_thread_kill(struct zfcp_adapter *adapter)
1670{
1671	kthread_stop(adapter->erp_thread);
1672	adapter->erp_thread = NULL;
1673	WARN_ON(!list_empty(&adapter->erp_ready_head));
1674	WARN_ON(!list_empty(&adapter->erp_running_head));
1675}
1676
1677/**
1678 * zfcp_erp_wait - wait for completion of error recovery on an adapter
1679 * @adapter: adapter for which to wait for completion of its error recovery
1680 */
1681void zfcp_erp_wait(struct zfcp_adapter *adapter)
1682{
1683	wait_event(adapter->erp_done_wqh,
1684		   !(atomic_read(&adapter->status) &
1685			ZFCP_STATUS_ADAPTER_ERP_PENDING));
1686}
1687
1688/**
1689 * zfcp_erp_set_adapter_status - set adapter status bits
1690 * @adapter: adapter to change the status
1691 * @mask: status bits to change
1692 *
1693 * Changes in common status bits are propagated to attached ports and LUNs.
1694 */
1695void zfcp_erp_set_adapter_status(struct zfcp_adapter *adapter, u32 mask)
1696{
1697	struct zfcp_port *port;
1698	struct scsi_device *sdev;
1699	unsigned long flags;
1700	u32 common_mask = mask & ZFCP_COMMON_FLAGS;
1701
1702	atomic_or(mask, &adapter->status);
1703
1704	if (!common_mask)
1705		return;
1706
1707	read_lock_irqsave(&adapter->port_list_lock, flags);
1708	list_for_each_entry(port, &adapter->port_list, list)
1709		atomic_or(common_mask, &port->status);
1710	read_unlock_irqrestore(&adapter->port_list_lock, flags);
1711
1712	/*
1713	 * if `scsi_host` is missing, xconfig/xport data has never completed
1714	 * yet, so we can't access it, but there are also no SDEVs yet
1715	 */
1716	if (adapter->scsi_host == NULL)
1717		return;
1718
1719	spin_lock_irqsave(adapter->scsi_host->host_lock, flags);
1720	__shost_for_each_device(sdev, adapter->scsi_host)
1721		atomic_or(common_mask, &sdev_to_zfcp(sdev)->status);
1722	spin_unlock_irqrestore(adapter->scsi_host->host_lock, flags);
1723}
1724
1725/**
1726 * zfcp_erp_clear_adapter_status - clear adapter status bits
1727 * @adapter: adapter to change the status
1728 * @mask: status bits to change
1729 *
1730 * Changes in common status bits are propagated to attached ports and LUNs.
1731 */
1732void zfcp_erp_clear_adapter_status(struct zfcp_adapter *adapter, u32 mask)
1733{
1734	struct zfcp_port *port;
1735	struct scsi_device *sdev;
1736	unsigned long flags;
1737	u32 common_mask = mask & ZFCP_COMMON_FLAGS;
1738	u32 clear_counter = mask & ZFCP_STATUS_COMMON_ERP_FAILED;
1739
1740	atomic_andnot(mask, &adapter->status);
1741
1742	if (!common_mask)
1743		return;
1744
1745	if (clear_counter)
1746		atomic_set(&adapter->erp_counter, 0);
1747
1748	read_lock_irqsave(&adapter->port_list_lock, flags);
1749	list_for_each_entry(port, &adapter->port_list, list) {
1750		atomic_andnot(common_mask, &port->status);
1751		if (clear_counter)
1752			atomic_set(&port->erp_counter, 0);
1753	}
1754	read_unlock_irqrestore(&adapter->port_list_lock, flags);
1755
1756	/*
1757	 * if `scsi_host` is missing, xconfig/xport data has never completed
1758	 * yet, so we can't access it, but there are also no SDEVs yet
1759	 */
1760	if (adapter->scsi_host == NULL)
1761		return;
1762
1763	spin_lock_irqsave(adapter->scsi_host->host_lock, flags);
1764	__shost_for_each_device(sdev, adapter->scsi_host) {
1765		atomic_andnot(common_mask, &sdev_to_zfcp(sdev)->status);
1766		if (clear_counter)
1767			atomic_set(&sdev_to_zfcp(sdev)->erp_counter, 0);
1768	}
1769	spin_unlock_irqrestore(adapter->scsi_host->host_lock, flags);
1770}
1771
1772/**
1773 * zfcp_erp_set_port_status - set port status bits
1774 * @port: port to change the status
1775 * @mask: status bits to change
1776 *
1777 * Changes in common status bits are propagated to attached LUNs.
1778 */
1779void zfcp_erp_set_port_status(struct zfcp_port *port, u32 mask)
1780{
1781	struct scsi_device *sdev;
1782	u32 common_mask = mask & ZFCP_COMMON_FLAGS;
1783	unsigned long flags;
1784
1785	atomic_or(mask, &port->status);
1786
1787	if (!common_mask)
1788		return;
1789
1790	spin_lock_irqsave(port->adapter->scsi_host->host_lock, flags);
1791	__shost_for_each_device(sdev, port->adapter->scsi_host)
1792		if (sdev_to_zfcp(sdev)->port == port)
1793			atomic_or(common_mask,
1794					&sdev_to_zfcp(sdev)->status);
1795	spin_unlock_irqrestore(port->adapter->scsi_host->host_lock, flags);
1796}
1797
1798/**
1799 * zfcp_erp_clear_port_status - clear port status bits
1800 * @port: adapter to change the status
1801 * @mask: status bits to change
1802 *
1803 * Changes in common status bits are propagated to attached LUNs.
1804 */
1805void zfcp_erp_clear_port_status(struct zfcp_port *port, u32 mask)
1806{
1807	struct scsi_device *sdev;
1808	u32 common_mask = mask & ZFCP_COMMON_FLAGS;
1809	u32 clear_counter = mask & ZFCP_STATUS_COMMON_ERP_FAILED;
1810	unsigned long flags;
1811
1812	atomic_andnot(mask, &port->status);
1813
1814	if (!common_mask)
1815		return;
1816
1817	if (clear_counter)
1818		atomic_set(&port->erp_counter, 0);
1819
1820	spin_lock_irqsave(port->adapter->scsi_host->host_lock, flags);
1821	__shost_for_each_device(sdev, port->adapter->scsi_host)
1822		if (sdev_to_zfcp(sdev)->port == port) {
1823			atomic_andnot(common_mask,
1824					  &sdev_to_zfcp(sdev)->status);
1825			if (clear_counter)
1826				atomic_set(&sdev_to_zfcp(sdev)->erp_counter, 0);
1827		}
1828	spin_unlock_irqrestore(port->adapter->scsi_host->host_lock, flags);
1829}
1830
1831/**
1832 * zfcp_erp_set_lun_status - set lun status bits
1833 * @sdev: SCSI device / lun to set the status bits
1834 * @mask: status bits to change
1835 */
1836void zfcp_erp_set_lun_status(struct scsi_device *sdev, u32 mask)
1837{
1838	struct zfcp_scsi_dev *zfcp_sdev = sdev_to_zfcp(sdev);
1839
1840	atomic_or(mask, &zfcp_sdev->status);
1841}
1842
1843/**
1844 * zfcp_erp_clear_lun_status - clear lun status bits
1845 * @sdev: SCSi device / lun to clear the status bits
1846 * @mask: status bits to change
1847 */
1848void zfcp_erp_clear_lun_status(struct scsi_device *sdev, u32 mask)
1849{
1850	struct zfcp_scsi_dev *zfcp_sdev = sdev_to_zfcp(sdev);
1851
1852	atomic_andnot(mask, &zfcp_sdev->status);
1853
1854	if (mask & ZFCP_STATUS_COMMON_ERP_FAILED)
1855		atomic_set(&zfcp_sdev->erp_counter, 0);
1856}
1857
1858/**
1859 * zfcp_erp_adapter_reset_sync() - Really reopen adapter and wait.
1860 * @adapter: Pointer to zfcp_adapter to reopen.
1861 * @dbftag: Trace tag string of length %ZFCP_DBF_TAG_LEN.
1862 */
1863void zfcp_erp_adapter_reset_sync(struct zfcp_adapter *adapter, char *dbftag)
1864{
1865	zfcp_erp_set_adapter_status(adapter, ZFCP_STATUS_COMMON_RUNNING);
1866	zfcp_erp_adapter_reopen(adapter, ZFCP_STATUS_COMMON_ERP_FAILED, dbftag);
1867	zfcp_erp_wait(adapter);
1868}