Release 4.18 drivers/s390/scsi/zfcp_erp.c

// SPDX-License-Identifier: GPL-2.0
/*
 * zfcp device driver
 *
 * Error Recovery Procedures (ERP).
 *
 * Copyright IBM Corp. 2002, 2016
 */


#define KMSG_COMPONENT "zfcp"

#define pr_fmt(fmt) KMSG_COMPONENT ": " fmt

#include <linux/kthread.h>
#include "zfcp_ext.h"
#include "zfcp_reqlist.h"


#define ZFCP_MAX_ERPS                   3


enum zfcp_erp_act_flags {
	
ZFCP_STATUS_ERP_TIMEDOUT	= 0x10000000,
	
ZFCP_STATUS_ERP_CLOSE_ONLY	= 0x01000000,
	
ZFCP_STATUS_ERP_DISMISSED	= 0x00200000,
	
ZFCP_STATUS_ERP_LOWMEM		= 0x00400000,
	
ZFCP_STATUS_ERP_NO_REF		= 0x00800000,
};


enum zfcp_erp_steps {
	
ZFCP_ERP_STEP_UNINITIALIZED	= 0x0000,
	
ZFCP_ERP_STEP_PHYS_PORT_CLOSING	= 0x0010,
	
ZFCP_ERP_STEP_PORT_CLOSING	= 0x0100,
	
ZFCP_ERP_STEP_PORT_OPENING	= 0x0800,
	
ZFCP_ERP_STEP_LUN_CLOSING	= 0x1000,
	
ZFCP_ERP_STEP_LUN_OPENING	= 0x2000,
};

/**
 * enum zfcp_erp_act_type - Type of ERP action object.
 * @ZFCP_ERP_ACTION_REOPEN_LUN: LUN recovery.
 * @ZFCP_ERP_ACTION_REOPEN_PORT: Port recovery.
 * @ZFCP_ERP_ACTION_REOPEN_PORT_FORCED: Forced port recovery.
 * @ZFCP_ERP_ACTION_REOPEN_ADAPTER: Adapter recovery.
 * @ZFCP_ERP_ACTION_NONE: Eyecatcher pseudo flag to bitwise or-combine with
 *                        either of the first four enum values.
 *                        Used to indicate that an ERP action could not be
 *                        set up despite a detected need for some recovery.
 * @ZFCP_ERP_ACTION_FAILED: Eyecatcher pseudo flag to bitwise or-combine with
 *                          either of the first four enum values.
 *                          Used to indicate that ERP not needed because
 *                          the object has ZFCP_STATUS_COMMON_ERP_FAILED.
 */

enum zfcp_erp_act_type {
	
ZFCP_ERP_ACTION_REOPEN_LUN         = 1,
	
ZFCP_ERP_ACTION_REOPEN_PORT	   = 2,
	
ZFCP_ERP_ACTION_REOPEN_PORT_FORCED = 3,
	
ZFCP_ERP_ACTION_REOPEN_ADAPTER     = 4,
	
ZFCP_ERP_ACTION_NONE		   = 0xc0,
	
ZFCP_ERP_ACTION_FAILED		   = 0xe0,
};


enum zfcp_erp_act_result {
	
ZFCP_ERP_SUCCEEDED = 0,
	
ZFCP_ERP_FAILED    = 1,
	
ZFCP_ERP_CONTINUES = 2,
	
ZFCP_ERP_EXIT      = 3,
	
ZFCP_ERP_DISMISSED = 4,
	
ZFCP_ERP_NOMEM     = 5,
};



static void zfcp_erp_adapter_block(struct zfcp_adapter *adapter, int mask)
{
	zfcp_erp_clear_adapter_status(adapter,
				       ZFCP_STATUS_COMMON_UNBLOCKED | mask);
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Christof Schmitt
14
60.87%
1
33.33%
Martin Schwidefsky
8
34.78%
1
33.33%
Swen Schillig
1
4.35%
1
33.33%
Total
23
100.00%
3
100.00%



static bool zfcp_erp_action_is_running(struct zfcp_erp_action *act)
{
	struct zfcp_erp_action *curr_act;

	list_for_each_entry(curr_act, &act->adapter->erp_running_head, list)
		if (act == curr_act)
			return true;
	return false;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Christof Schmitt
25
69.44%
1
25.00%
Martin Schwidefsky
5
13.89%
1
25.00%
Steffen Maier
4
11.11%
1
25.00%
Martin Peschke
2
5.56%
1
25.00%
Total
36
100.00%
4
100.00%



static void zfcp_erp_action_ready(struct zfcp_erp_action *act)
{
	struct zfcp_adapter *adapter = act->adapter;

	list_move(&act->list, &act->adapter->erp_ready_head);
	zfcp_dbf_rec_run("erardy1", act);
	wake_up(&adapter->erp_ready_wq);
	zfcp_dbf_rec_run("erardy2", act);
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Christof Schmitt
44
77.19%
2
33.33%
Martin Schwidefsky
7
12.28%
1
16.67%
Swen Schillig
5
8.77%
2
33.33%
Martin Peschke
1
1.75%
1
16.67%
Total
57
100.00%
6
100.00%



static void zfcp_erp_action_dismiss(struct zfcp_erp_action *act)
{
	act->status |= ZFCP_STATUS_ERP_DISMISSED;
	if (zfcp_erp_action_is_running(act))
		zfcp_erp_action_ready(act);
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Christof Schmitt
23
79.31%
1
25.00%
Martin Schwidefsky
4
13.79%
1
25.00%
Martin Peschke
1
3.45%
1
25.00%
Steffen Maier
1
3.45%
1
25.00%
Total
29
100.00%
4
100.00%



static void zfcp_erp_action_dismiss_lun(struct scsi_device *sdev)
{
	struct zfcp_scsi_dev *zfcp_sdev = sdev_to_zfcp(sdev);

	if (atomic_read(&zfcp_sdev->status) & ZFCP_STATUS_COMMON_ERP_INUSE)
		zfcp_erp_action_dismiss(&zfcp_sdev->erp_action);
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Christof Schmitt
35
85.37%
2
66.67%
Martin Schwidefsky
6
14.63%
1
33.33%
Total
41
100.00%
3
100.00%



static void zfcp_erp_action_dismiss_port(struct zfcp_port *port)
{
	struct scsi_device *sdev;

	if (atomic_read(&port->status) & ZFCP_STATUS_COMMON_ERP_INUSE)
		zfcp_erp_action_dismiss(&port->erp_action);
	else {
		spin_lock(port->adapter->scsi_host->host_lock);
		__shost_for_each_device(sdev, port->adapter->scsi_host)
			if (sdev_to_zfcp(sdev)->port == port)
				zfcp_erp_action_dismiss_lun(sdev);
		spin_unlock(port->adapter->scsi_host->host_lock);
	}
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Christof Schmitt
44
53.01%
2
40.00%
Martin Peschke
25
30.12%
1
20.00%
Martin Schwidefsky
9
10.84%
1
20.00%
Swen Schillig
5
6.02%
1
20.00%
Total
83
100.00%
5
100.00%



static void zfcp_erp_action_dismiss_adapter(struct zfcp_adapter *adapter)
{
	struct zfcp_port *port;

	if (atomic_read(&adapter->status) & ZFCP_STATUS_COMMON_ERP_INUSE)
		zfcp_erp_action_dismiss(&adapter->erp_action);
	else {
		read_lock(&adapter->port_list_lock);
		list_for_each_entry(port, &adapter->port_list, list)
		    zfcp_erp_action_dismiss_port(port);
		read_unlock(&adapter->port_list_lock);
	}
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Christof Schmitt
40
58.82%
1
33.33%
Swen Schillig
19
27.94%
1
33.33%
Martin Schwidefsky
9
13.24%
1
33.33%
Total
68
100.00%
3
100.00%



static int zfcp_erp_handle_failed(int want, struct zfcp_adapter *adapter,
				  struct zfcp_port *port,
				  struct scsi_device *sdev)
{
	int need = want;
	struct zfcp_scsi_dev *zsdev;

	switch (want) {
	case ZFCP_ERP_ACTION_REOPEN_LUN:
		zsdev = sdev_to_zfcp(sdev);
		if (atomic_read(&zsdev->status) & ZFCP_STATUS_COMMON_ERP_FAILED)
			need = 0;
		break;
	case ZFCP_ERP_ACTION_REOPEN_PORT_FORCED:
		if (atomic_read(&port->status) & ZFCP_STATUS_COMMON_ERP_FAILED)
			need = 0;
		break;
	case ZFCP_ERP_ACTION_REOPEN_PORT:
		if (atomic_read(&port->status) &
		    ZFCP_STATUS_COMMON_ERP_FAILED) {
			need = 0;
			/* ensure propagation of failed status to new devices */
			zfcp_erp_set_port_status(
				port, ZFCP_STATUS_COMMON_ERP_FAILED);
		}
		break;
	case ZFCP_ERP_ACTION_REOPEN_ADAPTER:
		if (atomic_read(&adapter->status) &
		    ZFCP_STATUS_COMMON_ERP_FAILED) {
			need = 0;
			/* ensure propagation of failed status to new devices */
			zfcp_erp_set_adapter_status(
				adapter, ZFCP_STATUS_COMMON_ERP_FAILED);
		}
		break;
	default:
		need = 0;
		break;
	}

	return need;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Steffen Maier
156
100.00%
1
100.00%
Total
156
100.00%
1
100.00%



static int zfcp_erp_required_act(int want, struct zfcp_adapter *adapter,
				 struct zfcp_port *port,
				 struct scsi_device *sdev)
{
	int need = want;
	int l_status, p_status, a_status;
	struct zfcp_scsi_dev *zfcp_sdev;

	switch (want) {
	case ZFCP_ERP_ACTION_REOPEN_LUN:
		zfcp_sdev = sdev_to_zfcp(sdev);
		l_status = atomic_read(&zfcp_sdev->status);
		if (l_status & ZFCP_STATUS_COMMON_ERP_INUSE)
			return 0;
		p_status = atomic_read(&port->status);
		if (!(p_status & ZFCP_STATUS_COMMON_RUNNING) ||
		      p_status & ZFCP_STATUS_COMMON_ERP_FAILED)
			return 0;
		if (!(p_status & ZFCP_STATUS_COMMON_UNBLOCKED))
			need = ZFCP_ERP_ACTION_REOPEN_PORT;
		/* fall through */
	case ZFCP_ERP_ACTION_REOPEN_PORT_FORCED:
		p_status = atomic_read(&port->status);
		if (!(p_status & ZFCP_STATUS_COMMON_OPEN))
			need = ZFCP_ERP_ACTION_REOPEN_PORT;
		/* fall through */
	case ZFCP_ERP_ACTION_REOPEN_PORT:
		p_status = atomic_read(&port->status);
		if (p_status & ZFCP_STATUS_COMMON_ERP_INUSE)
			return 0;
		a_status = atomic_read(&adapter->status);
		if (!(a_status & ZFCP_STATUS_COMMON_RUNNING) ||
		      a_status & ZFCP_STATUS_COMMON_ERP_FAILED)
			return 0;
		if (p_status & ZFCP_STATUS_COMMON_NOESC)
			return need;
		if (!(a_status & ZFCP_STATUS_COMMON_UNBLOCKED))
			need = ZFCP_ERP_ACTION_REOPEN_ADAPTER;
		/* fall through */
	case ZFCP_ERP_ACTION_REOPEN_ADAPTER:
		a_status = atomic_read(&adapter->status);
		if (a_status & ZFCP_STATUS_COMMON_ERP_INUSE)
			return 0;
		if (!(a_status & ZFCP_STATUS_COMMON_RUNNING) &&
		    !(a_status & ZFCP_STATUS_COMMON_OPEN))
			return 0; /* shutdown requested for closed adapter */
	}

	return need;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Christof Schmitt
191
73.75%
4
57.14%
Martin Schwidefsky
55
21.24%
1
14.29%
Swen Schillig
9
3.47%
1
14.29%
Andrew Morton
4
1.54%
1
14.29%
Total
259
100.00%
7
100.00%



static struct zfcp_erp_action *zfcp_erp_setup_act(int need, u32 act_status,
						  struct zfcp_adapter *adapter,
						  struct zfcp_port *port,
						  struct scsi_device *sdev)
{
	struct zfcp_erp_action *erp_action;
	struct zfcp_scsi_dev *zfcp_sdev;

	switch (need) {
	case ZFCP_ERP_ACTION_REOPEN_LUN:
		zfcp_sdev = sdev_to_zfcp(sdev);
		if (!(act_status & ZFCP_STATUS_ERP_NO_REF))
			if (scsi_device_get(sdev))
				return NULL;
		atomic_or(ZFCP_STATUS_COMMON_ERP_INUSE,
				&zfcp_sdev->status);
		erp_action = &zfcp_sdev->erp_action;
		WARN_ON_ONCE(erp_action->port != port);
		WARN_ON_ONCE(erp_action->sdev != sdev);
		if (!(atomic_read(&zfcp_sdev->status) &
		      ZFCP_STATUS_COMMON_RUNNING))
			act_status |= ZFCP_STATUS_ERP_CLOSE_ONLY;
		break;

	case ZFCP_ERP_ACTION_REOPEN_PORT:
	case ZFCP_ERP_ACTION_REOPEN_PORT_FORCED:
		if (!get_device(&port->dev))
			return NULL;
		zfcp_erp_action_dismiss_port(port);
		atomic_or(ZFCP_STATUS_COMMON_ERP_INUSE, &port->status);
		erp_action = &port->erp_action;
		WARN_ON_ONCE(erp_action->port != port);
		WARN_ON_ONCE(erp_action->sdev != NULL);
		if (!(atomic_read(&port->status) & ZFCP_STATUS_COMMON_RUNNING))
			act_status |= ZFCP_STATUS_ERP_CLOSE_ONLY;
		break;

	case ZFCP_ERP_ACTION_REOPEN_ADAPTER:
		kref_get(&adapter->ref);
		zfcp_erp_action_dismiss_adapter(adapter);
		atomic_or(ZFCP_STATUS_COMMON_ERP_INUSE, &adapter->status);
		erp_action = &adapter->erp_action;
		WARN_ON_ONCE(erp_action->port != NULL);
		WARN_ON_ONCE(erp_action->sdev != NULL);
		if (!(atomic_read(&adapter->status) &
		      ZFCP_STATUS_COMMON_RUNNING))
			act_status |= ZFCP_STATUS_ERP_CLOSE_ONLY;
		break;

	default:
		return NULL;
	}

	WARN_ON_ONCE(erp_action->adapter != adapter);
	memset(&erp_action->list, 0, sizeof(erp_action->list));
	memset(&erp_action->timer, 0, sizeof(erp_action->timer));
	erp_action->step = ZFCP_ERP_STEP_UNINITIALIZED;
	erp_action->fsf_req_id = 0;
	erp_action->action = need;
	erp_action->status = act_status;

	return erp_action;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Christof Schmitt
164
46.33%
4
36.36%
Steffen Maier
81
22.88%
1
9.09%
Martin Schwidefsky
61
17.23%
1
9.09%
Swen Schillig
44
12.43%
3
27.27%
Peter Zijlstra
3
0.85%
1
9.09%
Martin Peschke
1
0.28%
1
9.09%
Total
354
100.00%
11
100.00%



static void zfcp_erp_action_enqueue(int want, struct zfcp_adapter *adapter,
				    struct zfcp_port *port,
				    struct scsi_device *sdev,
				    char *id, u32 act_status)
{
	int need;
	struct zfcp_erp_action *act;

	need = zfcp_erp_handle_failed(want, adapter, port, sdev);
	if (!need) {
		need = ZFCP_ERP_ACTION_FAILED; /* marker for trace */
		goto out;
	}

	if (!adapter->erp_thread) {
		need = ZFCP_ERP_ACTION_NONE; /* marker for trace */
		goto out;
	}

	need = zfcp_erp_required_act(want, adapter, port, sdev);
	if (!need)
		goto out;

	act = zfcp_erp_setup_act(need, act_status, adapter, port, sdev);
	if (!act) {
		need |= ZFCP_ERP_ACTION_NONE; /* marker for trace */
		goto out;
	}
	atomic_or(ZFCP_STATUS_ADAPTER_ERP_PENDING, &adapter->status);
	++adapter->erp_total_count;
	list_add_tail(&act->list, &adapter->erp_ready_head);
	wake_up(&adapter->erp_ready_wq);
 out:
	zfcp_dbf_rec_trig(id, adapter, port, sdev, want, need);
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Christof Schmitt
98
52.13%
4
30.77%
Steffen Maier
46
24.47%
4
30.77%
Martin Schwidefsky
32
17.02%
1
7.69%
Swen Schillig
7
3.72%
2
15.38%
Martin Peschke
4
2.13%
1
7.69%
Peter Zijlstra
1
0.53%
1
7.69%
Total
188
100.00%
13
100.00%



void zfcp_erp_port_forced_no_port_dbf(char *id, struct zfcp_adapter *adapter,
				      u64 port_name, u32 port_id)
{
	unsigned long flags;
	static /* don't waste stack */ struct zfcp_port tmpport;

	write_lock_irqsave(&adapter->erp_lock, flags);
	/* Stand-in zfcp port with fields just good enough for
         * zfcp_dbf_rec_trig() and zfcp_dbf_set_common().
         * Under lock because tmpport is static.
         */
	atomic_set(&tmpport.status, -1); /* unknown */
	tmpport.wwpn = port_name;
	tmpport.d_id = port_id;
	zfcp_dbf_rec_trig(id, adapter, &tmpport, NULL,
			  ZFCP_ERP_ACTION_REOPEN_PORT_FORCED,
			  ZFCP_ERP_ACTION_NONE);
	write_unlock_irqrestore(&adapter->erp_lock, flags);
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Steffen Maier
91
100.00%
1
100.00%
Total
91
100.00%
1
100.00%



static void _zfcp_erp_adapter_reopen(struct zfcp_adapter *adapter,
				    int clear_mask, char *id)
{
	zfcp_erp_adapter_block(adapter, clear_mask);
	zfcp_scsi_schedule_rports_block(adapter);

	zfcp_erp_action_enqueue(ZFCP_ERP_ACTION_REOPEN_ADAPTER,
				adapter, NULL, NULL, id, 0);
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Christof Schmitt
20
44.44%
3
42.86%
Martin Schwidefsky
17
37.78%
1
14.29%
Martin Peschke
4
8.89%
1
14.29%
Swen Schillig
2
4.44%
1
14.29%
Steffen Maier
2
4.44%
1
14.29%
Total
45
100.00%
7
100.00%

/**
 * zfcp_erp_adapter_reopen - Reopen adapter.
 * @adapter: Adapter to reopen.
 * @clear: Status flags to clear.
 * @id: Id for debug trace event.
 */


void zfcp_erp_adapter_reopen(struct zfcp_adapter *adapter, int clear, char *id)
{
	unsigned long flags;

	zfcp_erp_adapter_block(adapter, clear);
	zfcp_scsi_schedule_rports_block(adapter);

	write_lock_irqsave(&adapter->erp_lock, flags);
	zfcp_erp_action_enqueue(ZFCP_ERP_ACTION_REOPEN_ADAPTER, adapter,
				NULL, NULL, id, 0);
	write_unlock_irqrestore(&adapter->erp_lock, flags);
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Christof Schmitt
27
39.71%
2
33.33%
Swen Schillig
25
36.76%
2
33.33%
Martin Schwidefsky
11
16.18%
1
16.67%
Martin Peschke
5
7.35%
1
16.67%
Total
68
100.00%
6
100.00%

/**
 * zfcp_erp_adapter_shutdown - Shutdown adapter.
 * @adapter: Adapter to shut down.
 * @clear: Status flags to clear.
 * @id: Id for debug trace event.
 */


void zfcp_erp_adapter_shutdown(struct zfcp_adapter *adapter, int clear,
			       char *id)
{
	int flags = ZFCP_STATUS_COMMON_RUNNING | ZFCP_STATUS_COMMON_ERP_FAILED;
	zfcp_erp_adapter_reopen(adapter, clear | flags, id);
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Christof Schmitt
18
51.43%
1
25.00%
Martin Schwidefsky
14
40.00%
1
25.00%
Swen Schillig
2
5.71%
1
25.00%
Martin Peschke
1
2.86%
1
25.00%
Total
35
100.00%
4
100.00%

/**
 * zfcp_erp_port_shutdown - Shutdown port
 * @port: Port to shut down.
 * @clear: Status flags to clear.
 * @id: Id for debug trace event.
 */


void zfcp_erp_port_shutdown(struct zfcp_port *port, int clear, char *id)
{
	int flags = ZFCP_STATUS_COMMON_RUNNING | ZFCP_STATUS_COMMON_ERP_FAILED;
	zfcp_erp_port_reopen(port, clear | flags, id);
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Christof Schmitt
18
51.43%
1
25.00%
Martin Schwidefsky
12
34.29%
1
25.00%
Martin Peschke
3
8.57%
1
25.00%
Swen Schillig
2
5.71%
1
25.00%
Total
35
100.00%
4
100.00%



static void zfcp_erp_port_block(struct zfcp_port *port, int clear)
{
	zfcp_erp_clear_port_status(port,
				    ZFCP_STATUS_COMMON_UNBLOCKED | clear);
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Martin Schwidefsky
10
43.48%
1
25.00%
Christof Schmitt
10
43.48%
1
25.00%
Martin Peschke
2
8.70%
1
25.00%
Swen Schillig
1
4.35%
1
25.00%
Total
23
100.00%
4
100.00%



static void _zfcp_erp_port_forced_reopen(struct zfcp_port *port, int clear,
					 char *id)
{
	zfcp_erp_port_block(port, clear);
	zfcp_scsi_schedule_rport_block(port);

	zfcp_erp_action_enqueue(ZFCP_ERP_ACTION_REOPEN_PORT_FORCED,
				port->adapter, port, NULL, id, 0);
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Christof Schmitt
29
61.70%
3
60.00%
Martin Schwidefsky
16
34.04%
1
20.00%
Swen Schillig
2
4.26%
1
20.00%
Total
47
100.00%
5
100.00%

/**
 * zfcp_erp_port_forced_reopen - Forced close of port and open again
 * @port: Port to force close and to reopen.
 * @clear: Status flags to clear.
 * @id: Id for debug trace event.
 */


void zfcp_erp_port_forced_reopen(struct zfcp_port *port, int clear, char *id)
{
	unsigned long flags;
	struct zfcp_adapter *adapter = port->adapter;

	write_lock_irqsave(&adapter->erp_lock, flags);
	_zfcp_erp_port_forced_reopen(port, clear, id);
	write_unlock_irqrestore(&adapter->erp_lock, flags);
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Christof Schmitt
24
40.68%
1
14.29%
Martin Schwidefsky
20
33.90%
1
14.29%
Swen Schillig
7
11.86%
3
42.86%
Martin Peschke
5
8.47%
1
14.29%
Volker Sameske
3
5.08%
1
14.29%
Total
59
100.00%
7
100.00%



static void _zfcp_erp_port_reopen(struct zfcp_port *port, int clear, char *id)
{
	zfcp_erp_port_block(port, clear);
	zfcp_scsi_schedule_rport_block(port);

	zfcp_erp_action_enqueue(ZFCP_ERP_ACTION_REOPEN_PORT,
				port->adapter, port, NULL, id, 0);
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Christof Schmitt
35
74.47%
3
42.86%
Martin Schwidefsky
7
14.89%
1
14.29%
Steffen Maier
2
4.26%
1
14.29%
Swen Schillig
2
4.26%
1
14.29%
Andreas Herrmann
1
2.13%
1
14.29%
Total
47
100.00%
7
100.00%

/**
 * zfcp_erp_port_reopen - trigger remote port recovery
 * @port: port to recover
 * @clear_mask: flags in port status to be cleared
 * @id: Id for debug trace event.
 */


void zfcp_erp_port_reopen(struct zfcp_port *port, int clear, char *id)
{
	unsigned long flags;
	struct zfcp_adapter *adapter = port->adapter;

	write_lock_irqsave(&adapter->erp_lock, flags);
	_zfcp_erp_port_reopen(port, clear, id);
	write_unlock_irqrestore(&adapter->erp_lock, flags);
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Martin Schwidefsky
34
57.63%
1
20.00%
Christof Schmitt
18
30.51%
1
20.00%
Swen Schillig
6
10.17%
2
40.00%
Steffen Maier
1
1.69%
1
20.00%
Total
59
100.00%
5
100.00%



static void zfcp_erp_lun_block(struct scsi_device *sdev, int clear_mask)
{
	zfcp_erp_clear_lun_status(sdev,
				  ZFCP_STATUS_COMMON_UNBLOCKED | clear_mask);
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Christof Schmitt
12
52.17%
2
33.33%
Martin Schwidefsky
8
34.78%
1
16.67%
Heiko Carstens
1
4.35%
1
16.67%
Andreas Herrmann
1
4.35%
1
16.67%
Swen Schillig
1
4.35%
1
16.67%
Total
23
100.00%
6
100.00%



static void _zfcp_erp_lun_reopen(struct scsi_device *sdev, int clear, char *id,
				 u32 act_status)
{
	struct zfcp_scsi_dev *zfcp_sdev = sdev_to_zfcp(sdev);
	struct zfcp_adapter *adapter = zfcp_sdev->port->adapter;

	zfcp_erp_lun_block(sdev, clear);

	zfcp_erp_action_enqueue(ZFCP_ERP_ACTION_REOPEN_LUN, adapter,
				zfcp_sdev->port, sdev, id, act_status);
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Christof Schmitt
39
59.09%
3
50.00%
Martin Schwidefsky
23
34.85%
1
16.67%
Swen Schillig
2
3.03%
1
16.67%
Andreas Herrmann
2
3.03%
1
16.67%
Total
66
100.00%
6
100.00%

/**
 * zfcp_erp_lun_reopen - initiate reopen of a LUN
 * @sdev: SCSI device / LUN to be reopened
 * @clear_mask: specifies flags in LUN status to be cleared
 * @id: Id for debug trace event.
 *
 * Return: 0 on success, < 0 on error
 */


void zfcp_erp_lun_reopen(struct scsi_device *sdev, int clear, char *id)
{
	unsigned long flags;
	struct zfcp_scsi_dev *zfcp_sdev = sdev_to_zfcp(sdev);
	struct zfcp_port *port = zfcp_sdev->port;
	struct zfcp_adapter *adapter = port->adapter;

	write_lock_irqsave(&adapter->erp_lock, flags);
	_zfcp_erp_lun_reopen(sdev, clear, id, 0);
	write_unlock_irqrestore(&adapter->erp_lock, flags);
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Christof Schmitt
58
72.50%
3
42.86%
Martin Schwidefsky
15
18.75%
1
14.29%
Swen Schillig
5
6.25%
2
28.57%
Martin Peschke
2
2.50%
1
14.29%
Total
80
100.00%
7
100.00%

/**
 * zfcp_erp_lun_shutdown - Shutdown LUN
 * @sdev: SCSI device / LUN to shut down.
 * @clear: Status flags to clear.
 * @id: Id for debug trace event.
 */


void zfcp_erp_lun_shutdown(struct scsi_device *sdev, int clear, char *id)
{
	int flags = ZFCP_STATUS_COMMON_RUNNING | ZFCP_STATUS_COMMON_ERP_FAILED;
	zfcp_erp_lun_reopen(sdev, clear | flags, id);
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Christof Schmitt
35
100.00%
2
100.00%
Total
35
100.00%
2
100.00%

/**
 * zfcp_erp_lun_shutdown_wait - Shutdown LUN and wait for erp completion
 * @sdev: SCSI device / LUN to shut down.
 * @id: Id for debug trace event.
 *
 * Do not acquire a reference for the LUN when creating the ERP
 * action. It is safe, because this function waits for the ERP to
 * complete first. This allows to shutdown the LUN, even when the SCSI
 * device is in the state SDEV_DEL when scsi_device_get will fail.
 */


void zfcp_erp_lun_shutdown_wait(struct scsi_device *sdev, char *id)
{
	unsigned long flags;
	struct zfcp_scsi_dev *zfcp_sdev = sdev_to_zfcp(sdev);
	struct zfcp_port *port = zfcp_sdev->port;
	struct zfcp_adapter *adapter = port->adapter;
	int clear = ZFCP_STATUS_COMMON_RUNNING | ZFCP_STATUS_COMMON_ERP_FAILED;

	write_lock_irqsave(&adapter->erp_lock, flags);
	_zfcp_erp_lun_reopen(sdev, clear, id, ZFCP_STATUS_ERP_NO_REF);
	write_unlock_irqrestore(&adapter->erp_lock, flags);

	zfcp_erp_wait(adapter);
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Christof Schmitt
79
88.76%
3
50.00%
Martin Schwidefsky
7
7.87%
1
16.67%
Martin Peschke
2
2.25%
1
16.67%
Swen Schillig
1
1.12%
1
16.67%
Total
89
100.00%
6
100.00%



static int zfcp_erp_status_change_set(unsigned long mask, atomic_t *status)
{
	return (atomic_read(status) ^ mask) & mask;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Christof Schmitt
15
57.69%
1
33.33%
Martin Schwidefsky
10
38.46%
1
33.33%
Steffen Maier
1
3.85%
1
33.33%
Total
26
100.00%
3
100.00%



static void zfcp_erp_adapter_unblock(struct zfcp_adapter *adapter)
{
	if (zfcp_erp_status_change_set(ZFCP_STATUS_COMMON_UNBLOCKED,
				       &adapter->status))
		zfcp_dbf_rec_run("eraubl1", &adapter->erp_action);
	atomic_or(ZFCP_STATUS_COMMON_UNBLOCKED, &adapter->status);
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Martin Schwidefsky
20
46.51%
1
14.29%
Christof Schmitt
16
37.21%
1
14.29%
Swen Schillig
5
11.63%
3
42.86%
Peter Zijlstra
1
2.33%
1
14.29%
Steffen Maier
1
2.33%
1
14.29%
Total
43
100.00%
7
100.00%



static void zfcp_erp_port_unblock(struct zfcp_port *port)
{
	if (zfcp_erp_status_change_set(ZFCP_STATUS_COMMON_UNBLOCKED,
				       &port->status))
		zfcp_dbf_rec_run("erpubl1", &port->erp_action);
	atomic_or(ZFCP_STATUS_COMMON_UNBLOCKED, &port->status);
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Christof Schmitt
19
44.19%
1
14.29%
Martin Schwidefsky
11
25.58%
1
14.29%
Martin Peschke
6
13.95%
1
14.29%
Swen Schillig
5
11.63%
2
28.57%
Peter Zijlstra
1
2.33%
1
14.29%
Steffen Maier
1
2.33%
1
14.29%
Total
43
100.00%
7
100.00%



static void zfcp_erp_lun_unblock(struct scsi_device *sdev)
{
	struct zfcp_scsi_dev *zfcp_sdev = sdev_to_zfcp(sdev);

	if (zfcp_erp_status_change_set(ZFCP_STATUS_COMMON_UNBLOCKED,
				       &zfcp_sdev->status))
		zfcp_dbf_rec_run("erlubl1", &sdev_to_zfcp(sdev)->erp_action);
	atomic_or(ZFCP_STATUS_COMMON_UNBLOCKED, &zfcp_sdev->status);
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Christof Schmitt
29
51.79%
2
33.33%
Martin Schwidefsky
18
32.14%
1
16.67%
Swen Schillig
7
12.50%
1
16.67%
Steffen Maier
1
1.79%
1
16.67%
Peter Zijlstra
1
1.79%
1
16.67%
Total
56
100.00%
6
100.00%



static void zfcp_erp_action_to_running(struct zfcp_erp_action *erp_action)
{
	list_move(&erp_action->list, &erp_action->adapter->erp_running_head);
	zfcp_dbf_rec_run("erator1", erp_action);
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Christof Schmitt
20
60.61%
1
20.00%
Andrew Morton
7
21.21%
1
20.00%
Martin Schwidefsky
4
12.12%
1
20.00%
Swen Schillig
2
6.06%
2
40.00%
Total
33
100.00%
5
100.00%



static void zfcp_erp_strategy_check_fsfreq(struct zfcp_erp_action *act)
{
	struct zfcp_adapter *adapter = act->adapter;
	struct zfcp_fsf_req *req;

	if (!act->fsf_req_id)
		return;

	spin_lock(&adapter->req_list->lock);
	req = _zfcp_reqlist_find(adapter->req_list, act->fsf_req_id);
	if (req && req->erp_action == act) {
		if (act->status & (ZFCP_STATUS_ERP_DISMISSED |
				   ZFCP_STATUS_ERP_TIMEDOUT)) {
			req->status |= ZFCP_STATUS_FSFREQ_DISMISSED;
			zfcp_dbf_rec_run("erscf_1", act);
			req->erp_action = NULL;
		}
		if (act->status & ZFCP_STATUS_ERP_TIMEDOUT)
			zfcp_dbf_rec_run("erscf_2", act);
		if (req->status & ZFCP_STATUS_FSFREQ_DISMISSED)
			act->fsf_req_id = 0;
	} else
		act->fsf_req_id = 0;
	spin_unlock(&adapter->req_list->lock);
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Christof Schmitt
94
63.95%
3
33.33%
Andrew Morton
22
14.97%
2
22.22%
Martin Schwidefsky
22
14.97%
1
11.11%
Martin Petermann
5
3.40%
1
11.11%
Swen Schillig
4
2.72%
2
22.22%
Total
147
100.00%
9
100.00%

/**
 * zfcp_erp_notify - Trigger ERP action.
 * @erp_action: ERP action to continue.
 * @set_mask: ERP action status flags to set.
 */


void zfcp_erp_notify(struct zfcp_erp_action *erp_action, unsigned long set_mask)
{
	struct zfcp_adapter *adapter = erp_action->adapter;
	unsigned long flags;

	write_lock_irqsave(&adapter->erp_lock, flags);
	if (zfcp_erp_action_is_running(erp_action)) {
		erp_action->status |= set_mask;
		zfcp_erp_action_ready(erp_action);
	}
	write_unlock_irqrestore(&adapter->erp_lock, flags);
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Christof Schmitt
44
65.67%
1
33.33%
Martin Schwidefsky
22
32.84%
1
33.33%
Steffen Maier
1
1.49%
1
33.33%
Total
67
100.00%
3
100.00%

/**
 * zfcp_erp_timeout_handler - Trigger ERP action from timed out ERP request
 * @data: ERP action (from timer data)
 */


void zfcp_erp_timeout_handler(struct timer_list *t)
{
	struct zfcp_fsf_req *fsf_req = from_timer(fsf_req, t, timer);
	struct zfcp_erp_action *act = fsf_req->erp_action;

	zfcp_erp_notify(act, ZFCP_STATUS_ERP_TIMEDOUT);
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Kees Cook
21
52.50%
1
33.33%
Christof Schmitt
10
25.00%
1
33.33%
Martin Schwidefsky
9
22.50%
1
33.33%
Total
40
100.00%
3
100.00%



static void zfcp_erp_memwait_handler(struct timer_list *t)
{
	struct zfcp_erp_action *act = from_timer(act, t, timer);

	zfcp_erp_notify(act, 0);
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Kees Cook
19
59.38%
1
33.33%
Christof Schmitt
9
28.12%
1
33.33%
Martin Schwidefsky
4
12.50%
1
33.33%
Total
32
100.00%
3
100.00%



static void zfcp_erp_strategy_memwait(struct zfcp_erp_action *erp_action)
{
	timer_setup(&erp_action->timer, zfcp_erp_memwait_handler, 0);
	erp_action->timer.expires = jiffies + HZ;
	add_timer(&erp_action->timer);
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Christof Schmitt
17
41.46%
2
50.00%
Martin Schwidefsky
12
29.27%
1
25.00%
Steffen Maier
12
29.27%
1
25.00%
Total
41
100.00%
4
100.00%



static void _zfcp_erp_port_reopen_all(struct zfcp_adapter *adapter,
				      int clear, char *id)
{
	struct zfcp_port *port;

	read_lock(&adapter->port_list_lock);
	list_for_each_entry(port, &adapter->port_list, list)
		_zfcp_erp_port_reopen(port, clear, id);
	read_unlock(&adapter->port_list_lock);
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Christof Schmitt
19
33.93%
2
28.57%
Swen Schillig
19
33.93%
2
28.57%
Martin Schwidefsky
16
28.57%
2
28.57%
Martin Peschke
2
3.57%
1
14.29%
Total
56
100.00%
7
100.00%



static void _zfcp_erp_lun_reopen_all(struct zfcp_port *port, int clear,
				     char *id)
{
	struct scsi_device *sdev;

	spin_lock(port->adapter->scsi_host->host_lock);
	__shost_for_each_device(sdev, port->adapter->scsi_host)
		if (sdev_to_zfcp(sdev)->port == port)
			_zfcp_erp_lun_reopen(sdev, clear, id, 0);
	spin_unlock(port->adapter->scsi_host->host_lock);
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Christof Schmitt
28
38.36%
3
37.50%
Martin Peschke
25
34.25%
2
25.00%
Martin Schwidefsky
16
21.92%
1
12.50%
Swen Schillig
4
5.48%
2
25.00%
Total
73
100.00%
8
100.00%



static void zfcp_erp_strategy_followup_failed(struct zfcp_erp_action *act)
{
	switch (act->action) {
	case ZFCP_ERP_ACTION_REOPEN_ADAPTER:
		_zfcp_erp_adapter_reopen(act->adapter, 0, "ersff_1");
		break;
	case ZFCP_ERP_ACTION_REOPEN_PORT_FORCED:
		_zfcp_erp_port_forced_reopen(act->port, 0, "ersff_2");
		break;
	case ZFCP_ERP_ACTION_REOPEN_PORT:
		_zfcp_erp_port_reopen(act->port, 0, "ersff_3");
		break;
	case ZFCP_ERP_ACTION_REOPEN_LUN:
		_zfcp_erp_lun_reopen(act->sdev, 0, "ersff_4", 0);
		break;
	}
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Christof Schmitt
52
64.20%
4
66.67%
Martin Schwidefsky
27
33.33%
1
16.67%
Martin Peschke
2
2.47%
1
16.67%
Total
81
100.00%
6
100.00%



static void zfcp_erp_strategy_followup_success(struct zfcp_erp_action *act)
{
	switch (act->action) {
	case ZFCP_ERP_ACTION_REOPEN_ADAPTER:
		_zfcp_erp_port_reopen_all(act->adapter, 0, "ersfs_1");
		break;
	case ZFCP_ERP_ACTION_REOPEN_PORT_FORCED:
		_zfcp_erp_port_reopen(act->port, 0, "ersfs_2");
		break;
	case ZFCP_ERP_ACTION_REOPEN_PORT:
		_zfcp_erp_lun_reopen_all(act->port, 0, "ersfs_3");
		break;
	}
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Christof Schmitt
43
67.19%
3
42.86%
Martin Schwidefsky
13
20.31%
1
14.29%
Andrew Morton
6
9.38%
1
14.29%
Martin Peschke
2
3.12%
2
28.57%
Total
64
100.00%
7
100.00%



static void zfcp_erp_wakeup(struct zfcp_adapter *adapter)
{
	unsigned long flags;

	read_lock_irqsave(&adapter->erp_lock, flags);
	if (list_empty(&adapter->erp_ready_head) &&
	    list_empty(&adapter->erp_running_head)) {
			atomic_andnot(ZFCP_STATUS_ADAPTER_ERP_PENDING,
					  &adapter->status);
			wake_up(&adapter->erp_done_wqh);
	}
	read_unlock_irqrestore(&adapter->erp_lock, flags);
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Christof Schmitt
32
43.84%
1
14.29%
Martin Schwidefsky
20
27.40%
1
14.29%
Swen Schillig
13
17.81%
2
28.57%
Andrew Morton
7
9.59%
2
28.57%
Peter Zijlstra
1
1.37%
1
14.29%
Total
73
100.00%
7
100.00%



static void zfcp_erp_enqueue_ptp_port(struct zfcp_adapter *adapter)
{
	struct zfcp_port *port;
	port = zfcp_port_enqueue(adapter, adapter->peer_wwpn, 0,
				 adapter->peer_d_id);
	if (IS_ERR(port)) /* error or port already attached */
		return;
	_zfcp_erp_port_reopen(port, 0, "ereptp1");
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Christof Schmitt
33
64.71%
1
20.00%
Andrew Morton
10
19.61%
1
20.00%
Martin Schwidefsky
5
9.80%
1
20.00%
Martin Peschke
2
3.92%
1
20.00%
Swen Schillig
1
1.96%
1
20.00%
Total
51
100.00%
5
100.00%



static int zfcp_erp_adapter_strat_fsf_xconf(struct zfcp_erp_action *erp_action)
{
	int retries;
	int sleep = 1;
	struct zfcp_adapter *adapter = erp_action->adapter;

	atomic_andnot(ZFCP_STATUS_ADAPTER_XCONFIG_OK, &adapter->status);

	for (retries = 7; retries; retries--) {
		atomic_andnot(ZFCP_STATUS_ADAPTER_HOST_CON_INIT,
				  &adapter->status);
		write_lock_irq(&adapter->erp_lock);
		zfcp_erp_action_to_running(erp_action);
		write_unlock_irq(&adapter->erp_lock);
		if (zfcp_fsf_exchange_config_data(erp_action)) {
			atomic_andnot(ZFCP_STATUS_ADAPTER_HOST_CON_INIT,
					  &adapter->status);
			return ZFCP_ERP_FAILED;
		}

		wait_event(adapter->erp_ready_wq,
			   !list_empty(&adapter->erp_ready_head));
		if (erp_action->status & ZFCP_STATUS_ERP_TIMEDOUT)
			break;

		if (!(atomic_read(&adapter->status) &
		      ZFCP_STATUS_ADAPTER_HOST_CON_INIT))
			break;

		ssleep(sleep);
		sleep *= 2;
	}

	atomic_andnot(ZFCP_STATUS_ADAPTER_HOST_CON_INIT,
			  &adapter->status);

	if (!(atomic_read(&adapter->status) & ZFCP_STATUS_ADAPTER_XCONFIG_OK))
		return ZFCP_ERP_FAILED;

	if (fc_host_port_type(adapter->scsi_host) == FC_PORTTYPE_PTP)
		zfcp_erp_enqueue_ptp_port(adapter);

	return ZFCP_ERP_SUCCEEDED;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Christof Schmitt
197
98.01%
4
80.00%
Peter Zijlstra
4
1.99%
1
20.00%
Total
201
100.00%
5
100.00%



static int zfcp_erp_adapter_strategy_open_fsf_xport(struct zfcp_erp_action *act)
{
	int ret;
	struct zfcp_adapter *adapter = act->adapter;

	write_lock_irq(&adapter->erp_lock);
	zfcp_erp_action_to_running(act);
	write_unlock_irq(&adapter->erp_lock);

	ret = zfcp_fsf_exchange_port_data(act);
	if (ret == -EOPNOTSUPP)
		return ZFCP_ERP_SUCCEEDED;
	if (ret)
		return ZFCP_ERP_FAILED;

	zfcp_dbf_rec_run("erasox1", act);
	wait_event(adapter->erp_ready_wq,
		   !list_empty(&adapter->erp_ready_head));
	zfcp_dbf_rec_run("erasox2", act);
	if (act->status & ZFCP_STATUS_ERP_TIMEDOUT)
		return ZFCP_ERP_FAILED;

	return ZFCP_ERP_SUCCEEDED;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Christof Schmitt
72
64.29%
2
33.33%
Martin Schwidefsky
33
29.46%
1
16.67%
Swen Schillig
6
5.36%
2
33.33%
Martin Peschke
1
0.89%
1
16.67%
Total
112
100.00%
6
100.00%



static int zfcp_erp_adapter_strategy_open_fsf(struct zfcp_erp_action *act)
{
	if (zfcp_erp_adapter_strat_fsf_xconf(act) == ZFCP_ERP_FAILED)
		return ZFCP_ERP_FAILED;

	if (zfcp_erp_adapter_strategy_open_fsf_xport(act) == ZFCP_ERP_FAILED)
		return ZFCP_ERP_FAILED;

	if (mempool_resize(act->adapter->pool.sr_data,
			   act->adapter->stat_read_buf_num))
		return ZFCP_ERP_FAILED;

	if (mempool_resize(act->adapter->pool.status_read_req,
			   act->adapter->stat_read_buf_num))
		return ZFCP_ERP_FAILED;

	atomic_set(&act->adapter->stat_miss, act->adapter->stat_read_buf_num);
	if (zfcp_status_read_refill(act->adapter))
		return ZFCP_ERP_FAILED;

	return ZFCP_ERP_SUCCEEDED;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Christof Schmitt
95
86.36%
4
66.67%
Martin Schwidefsky
14
12.73%
1
16.67%
Martin Peschke
1
0.91%
1
16.67%
Total
110
100.00%
6
100.00%



static void zfcp_erp_adapter_strategy_close(struct zfcp_erp_action *act)
{
	struct zfcp_adapter *adapter = act->adapter;

	/* close queues to ensure that buffers are not accessed by adapter */
	zfcp_qdio_close(adapter->qdio);
	zfcp_fsf_req_dismiss_all(adapter);
	adapter->fsf_req_seq_no = 0;
	zfcp_fc_wka_ports_force_offline(adapter->gs);
	/* all ports and LUNs are closed */
	zfcp_erp_clear_adapter_status(adapter, ZFCP_STATUS_COMMON_OPEN);

	atomic_andnot(ZFCP_STATUS_ADAPTER_XCONFIG_OK |
			  ZFCP_STATUS_ADAPTER_LINK_UNPLUGGED, &adapter->status);
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Christof Schmitt
26
39.39%
3
30.00%
Martin Schwidefsky
22
33.33%
1
10.00%
Swen Schillig
16
24.24%
4
40.00%
Sven Schuetz
1
1.52%
1
10.00%
Peter Zijlstra
1
1.52%
1
10.00%
Total
66
100.00%
10
100.00%



static int zfcp_erp_adapter_strategy_open(struct zfcp_erp_action *act)
{
	struct zfcp_adapter *adapter = act->adapter;

	if (zfcp_qdio_open(adapter->qdio)) {
		atomic_andnot(ZFCP_STATUS_ADAPTER_XCONFIG_OK |
				  ZFCP_STATUS_ADAPTER_LINK_UNPLUGGED,
				  &adapter->status);
		return ZFCP_ERP_FAILED;
	}

	if (zfcp_erp_adapter_strategy_open_fsf(act)) {
		zfcp_erp_adapter_strategy_close(act);
		return ZFCP_ERP_FAILED;
	}

	atomic_or(ZFCP_STATUS_COMMON_OPEN, &adapter->status);

	return ZFCP_ERP_SUCCEEDED;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Swen Schillig
60
78.95%
1
20.00%
Martin Schwidefsky
8
10.53%
1
20.00%
Christof Schmitt
6
7.89%
2
40.00%
Peter Zijlstra
2
2.63%
1
20.00%
Total
76
100.00%
5
100.00%



static int zfcp_erp_adapter_strategy(struct zfcp_erp_action *act)
{
	struct zfcp_adapter *adapter = act->adapter;

	if (atomic_read(&adapter->status) & ZFCP_STATUS_COMMON_OPEN) {
		zfcp_erp_adapter_strategy_close(act);
		if (act->status & ZFCP_STATUS_ERP_CLOSE_ONLY)
			return ZFCP_ERP_EXIT;
	}

	if (zfcp_erp_adapter_strategy_open(act)) {
		ssleep(8);
		return ZFCP_ERP_FAILED;
	}

	return ZFCP_ERP_SUCCEEDED;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Swen Schillig
32
45.71%
1
25.00%
Christof Schmitt
21
30.00%
1
25.00%
Martin Schwidefsky
16
22.86%
1
25.00%
Martin Peschke
1
1.43%
1
25.00%
Total
70
100.00%
4
100.00%



static int zfcp_erp_port_forced_strategy_close(struct zfcp_erp_action *act)
{
	int retval;

	retval = zfcp_fsf_close_physical_port(act);
	if (retval == -ENOMEM)
		return ZFCP_ERP_NOMEM;
	act->step = ZFCP_ERP_STEP_PHYS_PORT_CLOSING;
	if (retval)
		return ZFCP_ERP_FAILED;

	return ZFCP_ERP_CONTINUES;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Christof Schmitt
36
76.60%
1
25.00%
Martin Schwidefsky
9
19.15%
1
25.00%
Martin Peschke
2
4.26%
2
50.00%
Total
47
100.00%
4
100.00%



static int zfcp_erp_port_forced_strategy(struct zfcp_erp_action *erp_action)
{
	struct zfcp_port *port = erp_action->port;
	int status = atomic_read(&port->status);

	switch (erp_action->step) {
	case ZFCP_ERP_STEP_UNINITIALIZED:
		if ((status & ZFCP_STATUS_PORT_PHYS_OPEN) &&
		    (status & ZFCP_STATUS_COMMON_OPEN))
			return zfcp_erp_port_forced_strategy_close(erp_action);
		else
			return ZFCP_ERP_FAILED;

	case ZFCP_ERP_STEP_PHYS_PORT_CLOSING:
		if (!(status & ZFCP_STATUS_PORT_PHYS_OPEN))
			return ZFCP_ERP_SUCCEEDED;
	}
	return ZFCP_ERP_FAILED;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Christof Schmitt
66
78.57%
2
50.00%
Martin Schwidefsky
13
15.48%
1
25.00%
Martin Peschke
5
5.95%
1
25.00%
Total
84
100.00%
4
100.00%



static int zfcp_erp_port_strategy_close(struct zfcp_erp_action *erp_action)
{
	int retval;

	retval = zfcp_fsf_close_port(erp_action);
	if (retval == -ENOMEM)
		return ZFCP_ERP_NOMEM;
	erp_action->step = ZFCP_ERP_STEP_PORT_CLOSING;
	if (retval)
		return ZFCP_ERP_FAILED;
	return ZFCP_ERP_CONTINUES;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Christof Schmitt
28
59.57%
1
25.00%
Martin Schwidefsky
13
27.66%
1
25.00%
Martin Peschke
6
12.77%
2
50.00%
Total
47
100.00%
4
100.00%



static int zfcp_erp_port_strategy_open_port(struct zfcp_erp_action *erp_action)
{
	int retval;

	retval = zfcp_fsf_open_port(erp_action);
	if (retval == -ENOMEM)
		return ZFCP_ERP_NOMEM;
	erp_action->step = ZFCP_ERP_STEP_PORT_OPENING;
	if (retval)
		return ZFCP_ERP_FAILED;
	return ZFCP_ERP_CONTINUES;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Christof Schmitt
28
59.57%
1
33.33%
Martin Schwidefsky
18
38.30%
1
33.33%
Martin Peschke
1
2.13%
1
33.33%
Total
47
100.00%
3
100.00%



static int zfcp_erp_open_ptp_port(struct zfcp_erp_action *act)
{
	struct zfcp_adapter *adapter = act->adapter;
	struct zfcp_port *port = act->port;

	if (port->wwpn != adapter->peer_wwpn) {
		zfcp_erp_set_port_status(port, ZFCP_STATUS_COMMON_ERP_FAILED);
		return ZFCP_ERP_FAILED;
	}
	port->d_id = adapter->peer_d_id;
	return zfcp_erp_port_strategy_open_port(act);
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Swen Schillig
26
40.00%
2
33.33%
Martin Schwidefsky
19
29.23%
1
16.67%
Christof Schmitt
18
27.69%
1
16.67%
Martin Peschke
1
1.54%
1
16.67%
Nishanth Aravamudan
1
1.54%
1
16.67%
Total
65
100.00%
6
100.00%



static int zfcp_erp_port_strategy_open_common(struct zfcp_erp_action *act)
{
	struct zfcp_adapter *adapter = act->adapter;
	struct zfcp_port *port = act->port;
	int p_status = atomic_read(&port->status);

	switch (act->step) {
	case ZFCP_ERP_STEP_UNINITIALIZED:
	case ZFCP_ERP_STEP_PHYS_PORT_CLOSING:
	case ZFCP_ERP_STEP_PORT_CLOSING:
		if (fc_host_port_type(adapter->scsi_host) == FC_PORTTYPE_PTP)
			return zfcp_erp_open_ptp_port(act);
		if (!port->d_id) {
			zfcp_fc_trigger_did_lookup(port);
			return ZFCP_ERP_EXIT;
		}
		return zfcp_erp_port_strategy_open_port(act);

	case ZFCP_ERP_STEP_PORT_OPENING:
		/* D_ID might have changed during open */
		if (p_status & ZFCP_STATUS_COMMON_OPEN) {
			if (!port->d_id) {
				zfcp_fc_trigger_did_lookup(port);
				return ZFCP_ERP_EXIT;
			}
			return ZFCP_ERP_SUCCEEDED;
		}
		if (port->d_id && !(p_status & ZFCP_STATUS_COMMON_NOESC)) {
			port->d_id = 0;
			return ZFCP_ERP_FAILED;
		}
		/* fall through otherwise */
	}
	return ZFCP_ERP_FAILED;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Christof Schmitt
87
55.41%
5
55.56%
Swen Schillig
50
31.85%
3
33.33%
Martin Schwidefsky
20
12.74%
1
11.11%
Total
157
100.00%
9
100.00%



static int zfcp_erp_port_strategy(struct zfcp_erp_action *erp_action)
{
	struct zfcp_port *port = erp_action->port;
	int p_status = atomic_read(&port->status);

	if ((p_status & ZFCP_STATUS_COMMON_NOESC) &&
	    !(p_status & ZFCP_STATUS_COMMON_OPEN))
		goto close_init_done;

	switch (erp_action->step) {
	case ZFCP_ERP_STEP_UNINITIALIZED:
		if (p_status & ZFCP_STATUS_COMMON_OPEN)
			return zfcp_erp_port_strategy_close(erp_action);
		break;

	case ZFCP_ERP_STEP_PORT_CLOSING:
		if (p_status & ZFCP_STATUS_COMMON_OPEN)
			return ZFCP_ERP_FAILED;
		break;
	}

close_init_done:
	if (erp_action->status & ZFCP_STATUS_ERP_CLOSE_ONLY)
		return ZFCP_ERP_EXIT;

	return zfcp_erp_port_strategy_open_common(erp_action);
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Christof Schmitt
68
64.76%
2
28.57%
Swen Schillig
18
17.14%
2
28.57%
Martin Schwidefsky
16
15.24%
1
14.29%
Andreas Herrmann
2
1.90%
1
14.29%
Heiko Carstens
1
0.95%
1
14.29%
Total
105
100.00%
7
100.00%



static void zfcp_erp_lun_strategy_clearstati(struct scsi_device *sdev)
{
	struct zfcp_scsi_dev *zfcp_sdev = sdev_to_zfcp(sdev);

	atomic_andnot(ZFCP_STATUS_COMMON_ACCESS_DENIED,
			  &zfcp_sdev->status);
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Christof Schmitt
23
74.19%
2
40.00%
Andreas Herrmann
6
19.35%
1
20.00%
Martin Schwidefsky
1
3.23%
1
20.00%
Peter Zijlstra
1
3.23%
1
20.00%
Total
31
100.00%
5
100.00%



static int zfcp_erp_lun_strategy_close(struct zfcp_erp_action *erp_action)
{
	int retval = zfcp_fsf_close_lun(erp_action);
	if (retval == -ENOMEM)
		return ZFCP_ERP_NOMEM;
	erp_action->step = ZFCP_ERP_STEP_LUN_CLOSING;
	if (retval)
		return ZFCP_ERP_FAILED;
	return ZFCP_ERP_CONTINUES;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Martin Schwidefsky
20
44.44%
1
20.00%
Christof Schmitt
12
26.67%
2
40.00%
Andreas Herrmann
9
20.00%
1
20.00%
Maxim Shchetynin
4
8.89%
1
20.00%
Total
45
100.00%
5
100.00%



static int zfcp_erp_lun_strategy_open(struct zfcp_erp_action *erp_action)
{
	int retval = zfcp_fsf_open_lun(erp_action);
	if (retval == -ENOMEM)
		return ZFCP_ERP_NOMEM;
	erp_action->step = ZFCP_ERP_STEP_LUN_OPENING;
	if (retval)
		return  ZFCP_ERP_FAILED;
	return ZFCP_ERP_CONTINUES;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Christof Schmitt
32
71.11%
2
66.67%
Swen Schillig
13
28.89%
1
33.33%
Total
45
100.00%
3
100.00%



static int zfcp_erp_lun_strategy(struct zfcp_erp_action *erp_action)
{
	struct scsi_device *sdev = erp_action->sdev;
	struct zfcp_scsi_dev *zfcp_sdev = sdev_to_zfcp(sdev);

	switch (erp_action->step) {
	case ZFCP_ERP_STEP_UNINITIALIZED:
		zfcp_erp_lun_strategy_clearstati(sdev);
		if (atomic_read(&zfcp_sdev->status) & ZFCP_STATUS_COMMON_OPEN)
			return zfcp_erp_lun_strategy_close(erp_action);
		/* already closed, fall through */
	case ZFCP_ERP_STEP_LUN_CLOSING:
		if (atomic_read(&zfcp_sdev->status) & ZFCP_STATUS_COMMON_OPEN)
			return ZFCP_ERP_FAILED;
		if (erp_action->status & ZFCP_STATUS_ERP_CLOSE_ONLY)
			return ZFCP_ERP_EXIT;
		return zfcp_erp_lun_strategy_open(erp_action);

	case ZFCP_ERP_STEP_LUN_OPENING:
		if (atomic_read(&zfcp_sdev->status) & ZFCP_STATUS_COMMON_OPEN)
			return ZFCP_ERP_SUCCEEDED;
	}
	return ZFCP_ERP_FAILED;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Christof Schmitt
69
57.02%
2
33.33%
Martin Schwidefsky
37
30.58%
1
16.67%
Swen Schillig
8
6.61%
1
16.67%
Andreas Herrmann
4
3.31%
1
16.67%
Andrew Morton
3
2.48%
1
16.67%
Total
121
100.00%
6
100.00%



static int zfcp_erp_strategy_check_lun(struct scsi_device *sdev, int result)
{
	struct zfcp_scsi_dev *zfcp_sdev = sdev_to_zfcp(sdev);

	switch (result) {
	case ZFCP_ERP_SUCCEEDED :
		atomic_set(&zfcp_sdev->erp_counter, 0);
		zfcp_erp_lun_unblock(sdev);
		break;
	case ZFCP_ERP_FAILED :
		atomic_inc(&zfcp_sdev->erp_counter);
		if (atomic_read(&zfcp_sdev->erp_counter) > ZFCP_MAX_ERPS) {
			dev_err(&zfcp_sdev->port->adapter->ccw_device->dev,
				"ERP failed for LUN 0x%016Lx on "
				"port 0x%016Lx\n",
				(unsigned long long)zfcp_scsi_dev_lun(sdev),
				(unsigned long long)zfcp_sdev->port->wwpn);
			zfcp_erp_set_lun_status(sdev,
						ZFCP_STATUS_COMMON_ERP_FAILED);
		}
		break;
	}

	if (atomic_read(&zfcp_sdev->status) & ZFCP_STATUS_COMMON_ERP_FAILED) {
		zfcp_erp_lun_block(sdev, 0);
		result = ZFCP_ERP_EXIT;
	}
	return result;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Christof Schmitt
108
72.97%
3
33.33%
Swen Schillig
20
13.51%
3
33.33%
Martin Schwidefsky
14
9.46%
1
11.11%
Volker Sameske
5
3.38%
1
11.11%
Andreas Herrmann
1
0.68%
1
11.11%
Total
148
100.00%
9
100.00%



static int zfcp_erp_strategy_check_port(struct zfcp_port *port, int result)
{
	switch (result) {
	case ZFCP_ERP_SUCCEEDED :
		atomic_set(&port->erp_counter, 0);
		zfcp_erp_port_unblock(port);
		break;

	case ZFCP_ERP_FAILED :
		if (atomic_read(&port->status) & ZFCP_STATUS_COMMON_NOESC) {
			zfcp_erp_port_block(port, 0);
			result = ZFCP_ERP_EXIT;
		}
		atomic_inc(&port->erp_counter);
		if (atomic_read(&port->erp_counter) > ZFCP_MAX_ERPS) {
			dev_err(&port->adapter->ccw_device->dev,
				"ERP failed for remote port 0x%016Lx\n",
				(unsigned long long)port->wwpn);
			zfcp_erp_set_port_status(port,
					 ZFCP_STATUS_COMMON_ERP_FAILED);
		}
		break;
	}

	if (atomic_read(&port->status) & ZFCP_STATUS_COMMON_ERP_FAILED) {
		zfcp_erp_port_block(port, 0);
		result = ZFCP_ERP_EXIT;
	}
	return result;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Christof Schmitt
95
64.19%
2
25.00%
Maxim Shchetynin
28
18.92%
1
12.50%
Andreas Herrmann
11
7.43%
2
25.00%
Swen Schillig
7
4.73%
2
25.00%
Martin Peschke
7
4.73%
1
12.50%
Total
148
100.00%
8
100.00%



static int zfcp_erp_strategy_check_adapter(struct zfcp_adapter *adapter,
					   int result)
{
	switch (result) {
	case ZFCP_ERP_SUCCEEDED :
		atomic_set(&adapter->erp_counter, 0);
		zfcp_erp_adapter_unblock(adapter);
		break;

	case ZFCP_ERP_FAILED :
		atomic_inc(&adapter->erp_counter);
		if (atomic_read(&adapter->erp_counter) > ZFCP_MAX_ERPS) {
			dev_err(&adapter->ccw_device->dev,
				"ERP cannot recover an error "
				"on the FCP device\n");
			zfcp_erp_set_adapter_status(adapter,
					    ZFCP_STATUS_COMMON_ERP_FAILED);
		}
		break;
	}

	if (atomic_read(&adapter->status) & ZFCP_STATUS_COMMON_ERP_FAILED) {
		zfcp_erp_adapter_block(adapter, 0);
		result = ZFCP_ERP_EXIT;
	}
	return result;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Christof Schmitt
64
56.64%
2
40.00%
Martin Schwidefsky
44
38.94%
1
20.00%
Swen Schillig
5
4.42%
2
40.00%
Total
113
100.00%
5
100.00%



static int zfcp_erp_strategy_check_target(struct zfcp_erp_action *erp_action,
					  int result)
{
	struct zfcp_adapter *adapter = erp_action->adapter;
	struct zfcp_port *port = erp_action->port;
	struct scsi_device *sdev = erp_action->sdev;

	switch (erp_action->action) {

	case ZFCP_ERP_ACTION_REOPEN_LUN:
		result = zfcp_erp_strategy_check_lun(sdev, result);
		break;

	case ZFCP_ERP_ACTION_REOPEN_PORT_FORCED:
	case ZFCP_ERP_ACTION_REOPEN_PORT:
		result = zfcp_erp_strategy_check_port(port, result);
		break;

	case ZFCP_ERP_ACTION_REOPEN_ADAPTER:
		result = zfcp_erp_strategy_check_adapter(adapter, result);
		break;
	}
	return result;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Christof Schmitt
47
50.00%
2
66.67%
Martin Schwidefsky
47
50.00%
1
33.33%
Total
94
100.00%
3
100.00%



static int zfcp_erp_strat_change_det(atomic_t *target_status, u32 erp_status)
{
	int status = atomic_read(target_status);

	if ((status & ZFCP_STATUS_COMMON_RUNNING) &&
	    (erp_status & ZFCP_STATUS_ERP_CLOSE_ONLY))
		return 1; /* take it online */

	if (!(status & ZFCP_STATUS_COMMON_RUNNING) &&
	    !(erp_status & ZFCP_STATUS_ERP_CLOSE_ONLY))
		return 1; /* take it offline */

	return 0;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Christof Schmitt
47
75.81%
1
50.00%
Martin Schwidefsky
15
24.19%
1
50.00%
Total
62
100.00%
2
100.00%



static int zfcp_erp_strategy_statechange(struct zfcp_erp_action *act, int ret)
{
	int action = act->action;
	struct zfcp_adapter *adapter = act->adapter;
	struct zfcp_port *port = act->port;
	struct scsi_device *sdev = act->sdev;
	struct zfcp_scsi_dev *zfcp_sdev;
	u32 erp_status = act->status;

	switch (action) {
	case ZFCP_ERP_ACTION_REOPEN_ADAPTER:
		if (zfcp_erp_strat_change_det(&adapter->status, erp_status)) {
			_zfcp_erp_adapter_reopen(adapter,
						 ZFCP_STATUS_COMMON_ERP_FAILED,
						 "ersscg1");
			return ZFCP_ERP_EXIT;
		}
		break;

	case ZFCP_ERP_ACTION_REOPEN_PORT_FORCED:
	case ZFCP_ERP_ACTION_REOPEN_PORT:
		if (zfcp_erp_strat_change_det(&port->status, erp_status)) {
			_zfcp_erp_port_reopen(port,
					      ZFCP_STATUS_COMMON_ERP_FAILED,
					      "ersscg2");
			return ZFCP_ERP_EXIT;
		}
		break;

	case ZFCP_ERP_ACTION_REOPEN_LUN:
		zfcp_sdev = sdev_to_zfcp(sdev);
		if (zfcp_erp_strat_change_det(&zfcp_sdev->status, erp_status)) {
			_zfcp_erp_lun_reopen(sdev,
					     ZFCP_STATUS_COMMON_ERP_FAILED,
					     "ersscg3", 0);
			return ZFCP_ERP_EXIT;
		}
		break;
	}
	return ret;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Christof Schmitt
93
54.39%
3
50.00%
Martin Schwidefsky
74
43.27%
1
16.67%
Swen Schillig
3
1.75%
1
16.67%
Martin Peschke
1
0.58%
1
16.67%
Total
171
100.00%
6
100.00%



static void zfcp_erp_action_dequeue(struct zfcp_erp_action *erp_action)
{
	struct zfcp_adapter *adapter = erp_action->adapter;
	struct zfcp_scsi_dev *zfcp_sdev;

	adapter->erp_total_count--;
	if (erp_action->status & ZFCP_STATUS_ERP_LOWMEM) {
		adapter->erp_low_mem_count--;
		erp_action->status &= ~ZFCP_STATUS_ERP_LOWMEM;
	}

	list_del(&erp_action->list);
	zfcp_dbf_rec_run("eractd1", erp_action);

	switch (erp_action->action) {
	case ZFCP_ERP_ACTION_REOPEN_LUN:
		zfcp_sdev = sdev_to_zfcp(erp_action->sdev);
		atomic_andnot(ZFCP_STATUS_COMMON_ERP_INUSE,
				  &zfcp_sdev->status);
		break;

	case ZFCP_ERP_ACTION_REOPEN_PORT_FORCED:
	case ZFCP_ERP_ACTION_REOPEN_PORT:
		atomic_andnot(ZFCP_STATUS_COMMON_ERP_INUSE,
				  &erp_action->port->status);
		break;

	case ZFCP_ERP_ACTION_REOPEN_ADAPTER:
		atomic_andnot(ZFCP_STATUS_COMMON_ERP_INUSE,
				  &erp_action->adapter->status);
		break;
	}
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Christof Schmitt
85
63.91%
2
33.33%
Martin Schwidefsky
43
32.33%
1
16.67%
Peter Zijlstra
3
2.26%
1
16.67%
Swen Schillig
2
1.50%
2
33.33%
Total
133
100.00%
6
100.00%

/**
 * zfcp_erp_try_rport_unblock - unblock rport if no more/new recovery
 * @port: zfcp_port whose fc_rport we should try to unblock
 */


static void zfcp_erp_try_rport_unblock(struct zfcp_port *port)
{
	unsigned long flags;
	struct zfcp_adapter *adapter = port->adapter;
	int port_status;
	struct Scsi_Host *shost = adapter->scsi_host;
	struct scsi_device *sdev;

	write_lock_irqsave(&adapter->erp_lock, flags);
	port_status = atomic_read(&port->status);
	if ((port_status & ZFCP_STATUS_COMMON_UNBLOCKED)    == 0 ||
	    (port_status & (ZFCP_STATUS_COMMON_ERP_INUSE |
			    ZFCP_STATUS_COMMON_ERP_FAILED)) != 0) {
		/* new ERP of severity >= port triggered elsewhere meanwhile or
                 * local link down (adapter erp_failed but not clear unblock)
                 */
		zfcp_dbf_rec_run_lvl(4, "ertru_p", &port->erp_action);
		write_unlock_irqrestore(&adapter->erp_lock, flags);
		return;
	}
	spin_lock(shost->host_lock);
	__shost_for_each_device(sdev, shost) {
		struct zfcp_scsi_dev *zsdev = sdev_to_zfcp(sdev);
		int lun_status;

		if (zsdev->port != port)
			continue;
		/* LUN under port of interest */
		lun_status = atomic_read(&zsdev->status);
		if ((lun_status & ZFCP_STATUS_COMMON_ERP_FAILED) != 0)
			continue; /* unblock rport despite failed LUNs */
		/* LUN recovery not given up yet [maybe follow-up pending] */
		if ((lun_status & ZFCP_STATUS_COMMON_UNBLOCKED) == 0 ||
		    (lun_status & ZFCP_STATUS_COMMON_ERP_INUSE) != 0) {
			/* LUN blocked:
                         * not yet unblocked [LUN recovery pending]
                         * or meanwhile blocked [new LUN recovery triggered]
                         */
			zfcp_dbf_rec_run_lvl(4, "ertru_l", &zsdev->erp_action);
			spin_unlock(shost->host_lock);
			write_unlock_irqrestore(&adapter->erp_lock, flags);
			return;
		}
	}
	/* now port has no child or all children have completed recovery,
         * and no ERP of severity >= port was meanwhile triggered elsewhere
         */
	zfcp_scsi_schedule_rport_register(port);
	spin_unlock(shost->host_lock);
	write_unlock_irqrestore(&adapter->erp_lock, flags);
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Steffen Maier
244
100.00%
1
100.00%
Total
244
100.00%
1
100.00%



static void zfcp_erp_action_cleanup(struct zfcp_erp_action *act, int result)
{
	struct zfcp_adapter *adapter = act->adapter;
	struct zfcp_port *port = act->port;
	struct scsi_device *sdev = act->sdev;

	switch (act->action) {
	case ZFCP_ERP_ACTION_REOPEN_LUN:
		if (!(act->status & ZFCP_STATUS_ERP_NO_REF))
			scsi_device_put(sdev);
		zfcp_erp_try_rport_unblock(port);
		break;

	case ZFCP_ERP_ACTION_REOPEN_PORT:
		/* This switch case might also happen after a forced reopen
                 * was successfully done and thus overwritten with a new
                 * non-forced reopen at `ersfs_2'. In this case, we must not
                 * do the clean-up of the non-forced version.
                 */
		if (act->step != ZFCP_ERP_STEP_UNINITIALIZED)
			if (result == ZFCP_ERP_SUCCEEDED)
				zfcp_erp_try_rport_unblock(port);
		/* fall through */
	case ZFCP_ERP_ACTION_REOPEN_PORT_FORCED:
		put_device(&port->dev);
		break;

	case ZFCP_ERP_ACTION_REOPEN_ADAPTER:
		if (result == ZFCP_ERP_SUCCEEDED) {
			register_service_level(&adapter->service_level);
			zfcp_fc_conditional_port_scan(adapter);
			queue_work(adapter->work_queue, &adapter->ns_up_work);
		} else
			unregister_service_level(&adapter->service_level);

		kref_put(&adapter->ref, zfcp_adapter_release);
		break;
	}
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Christof Schmitt
100
60.24%
8
53.33%
Martin Schwidefsky
39
23.49%
1
6.67%
Steffen Maier
16
9.64%
3
20.00%
Swen Schillig
11
6.63%
3
20.00%
Total
166
100.00%
15
100.00%



static int zfcp_erp_strategy_do_action(struct zfcp_erp_action *erp_action)
{
	switch (erp_action->action) {
	case ZFCP_ERP_ACTION_REOPEN_ADAPTER:
		return zfcp_erp_adapter_strategy(erp_action);
	case ZFCP_ERP_ACTION_REOPEN_PORT_FORCED:
		return zfcp_erp_port_forced_strategy(erp_action);
	case ZFCP_ERP_ACTION_REOPEN_PORT:
		return zfcp_erp_port_strategy(erp_action);
	case ZFCP_ERP_ACTION_REOPEN_LUN:
		return zfcp_erp_lun_strategy(erp_action);
	}
	return ZFCP_ERP_FAILED;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Christof Schmitt
35
60.34%
2
50.00%
Martin Schwidefsky
20
34.48%
1
25.00%
Andreas Herrmann
3
5.17%
1
25.00%
Total
58
100.00%
4
100.00%



static int zfcp_erp_strategy(struct zfcp_erp_action *erp_action)
{
	int retval;
	unsigned long flags;
	struct zfcp_adapter *adapter = erp_action->adapter;

	kref_get(&adapter->ref);

	write_lock_irqsave(&adapter->erp_lock, flags);
	zfcp_erp_strategy_check_fsfreq(erp_action);

	if (erp_action->status & ZFCP_STATUS_ERP_DISMISSED) {
		zfcp_erp_action_dequeue(erp_action);
		retval = ZFCP_ERP_DISMISSED;
		goto unlock;
	}

	if (erp_action->status & ZFCP_STATUS_ERP_TIMEDOUT) {
		retval = ZFCP_ERP_FAILED;
		goto check_target;
	}

	zfcp_erp_action_to_running(erp_action);

	/* no lock to allow for blocking operations */
	write_unlock_irqrestore(&adapter->erp_lock, flags);
	retval = zfcp_erp_strategy_do_action(erp_action);
	write_lock_irqsave(&adapter->erp_lock, flags);

	if (erp_action->status & ZFCP_STATUS_ERP_DISMISSED)
		retval = ZFCP_ERP_CONTINUES;

	switch (retval) {
	case ZFCP_ERP_NOMEM:
		if (!(erp_action->status & ZFCP_STATUS_ERP_LOWMEM)) {
			++adapter->erp_low_mem_count;
			erp_action->status |= ZFCP_STATUS_ERP_LOWMEM;
		}
		if (adapter->erp_total_count == adapter->erp_low_mem_count)
			_zfcp_erp_adapter_reopen(adapter, 0, "erstgy1");
		else {
			zfcp_erp_strategy_memwait(erp_action);
			retval = ZFCP_ERP_CONTINUES;
		}
		goto unlock;

	case ZFCP_ERP_CONTINUES:
		if (erp_action->status & ZFCP_STATUS_ERP_LOWMEM) {
			--adapter->erp_low_mem_count;
			erp_action->status &= ~ZFCP_STATUS_ERP_LOWMEM;
		}
		goto unlock;
	}

check_target:
	retval = zfcp_erp_strategy_check_target(erp_action, retval);
	zfcp_erp_action_dequeue(erp_action);
	retval = zfcp_erp_strategy_statechange(erp_action, retval);
	if (retval == ZFCP_ERP_EXIT)
		goto unlock;
	if (retval == ZFCP_ERP_SUCCEEDED)
		zfcp_erp_strategy_followup_success(erp_action);
	if (retval == ZFCP_ERP_FAILED)
		zfcp_erp_strategy_followup_failed(erp_action);

 unlock:
	write_unlock_irqrestore(&adapter->erp_lock, flags);

	if (retval != ZFCP_ERP_CONTINUES)
		zfcp_erp_action_cleanup(erp_action, retval);

	kref_put(&adapter->ref, zfcp_adapter_release);
	return retval;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Christof Schmitt
193
59.75%
3
27.27%
Martin Schwidefsky
80
24.77%
1
9.09%
Swen Schillig
31
9.60%
3
27.27%
Andrew Morton
17
5.26%
2
18.18%
Andreas Herrmann
1
0.31%
1
9.09%
Martin Peschke
1
0.31%
1
9.09%
Total
323
100.00%
11
100.00%



static int zfcp_erp_thread(void *data)
{
	struct zfcp_adapter *adapter = (struct zfcp_adapter *) data;
	struct list_head *next;
	struct zfcp_erp_action *act;
	unsigned long flags;

	for (;;) {
		wait_event_interruptible(adapter->erp_ready_wq,
			   !list_empty(&adapter->erp_ready_head) ||
			   kthread_should_stop());

		if (kthread_should_stop())
			break;

		write_lock_irqsave(&adapter->erp_lock, flags);
		next = adapter->erp_ready_head.next;
		write_unlock_irqrestore(&adapter->erp_lock, flags);

		if (next != &adapter->erp_ready_head) {
			act = list_entry(next, struct zfcp_erp_action, list);

			/* there is more to come after dismission, no notify */
			if (zfcp_erp_strategy(act) != ZFCP_ERP_DISMISSED)
				zfcp_erp_wakeup(adapter);
		}
	}

	return 0;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Christof Schmitt
106
77.37%
2
40.00%
Martin Schwidefsky
25
18.25%
1
20.00%
Andrew Morton
3
2.19%
1
20.00%
Swen Schillig
3
2.19%
1
20.00%
Total
137
100.00%
5
100.00%

/**
 * zfcp_erp_thread_setup - Start ERP thread for adapter
 * @adapter: Adapter to start the ERP thread for
 *
 * Returns 0 on success or error code from kernel_thread()
 */


int zfcp_erp_thread_setup(struct zfcp_adapter *adapter)
{
	struct task_struct *thread;

	thread = kthread_run(zfcp_erp_thread, adapter, "zfcperp%s",
			     dev_name(&adapter->ccw_device->dev));
	if (IS_ERR(thread)) {
		dev_err(&adapter->ccw_device->dev,
			"Creating an ERP thread for the FCP device failed.\n");
		return PTR_ERR(thread);
	}

	adapter->erp_thread = thread;
	return 0;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Christof Schmitt
52
72.22%
3
50.00%
Andrew Morton
10
13.89%
1
16.67%
Martin Schwidefsky
9
12.50%
1
16.67%
Martin Peschke
1
1.39%
1
16.67%
Total
72
100.00%
6
100.00%

/**
 * zfcp_erp_thread_kill - Stop ERP thread.
 * @adapter: Adapter where the ERP thread should be stopped.
 *
 * The caller of this routine ensures that the specified adapter has
 * been shut down and that this operation has been completed. Thus,
 * there are no pending erp_actions which would need to be handled
 * here.
 */


void zfcp_erp_thread_kill(struct zfcp_adapter *adapter)
{
	kthread_stop(adapter->erp_thread);
	adapter->erp_thread = NULL;
	WARN_ON(!list_empty(&adapter->erp_ready_head));
	WARN_ON(!list_empty(&adapter->erp_running_head));
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Christof Schmitt
40
85.11%
3
60.00%
Martin Schwidefsky
6
12.77%
1
20.00%
Andrew Morton
1
2.13%
1
20.00%
Total
47
100.00%
5
100.00%

/**
 * zfcp_erp_wait - wait for completion of error recovery on an adapter
 * @adapter: adapter for which to wait for completion of its error recovery
 */


void zfcp_erp_wait(struct zfcp_adapter *adapter)
{
	wait_event(adapter->erp_done_wqh,
		   !(atomic_read(&adapter->status) &
			ZFCP_STATUS_ADAPTER_ERP_PENDING));
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Christof Schmitt
21
70.00%
1
25.00%
Andreas Herrmann
7
23.33%
2
50.00%
Ralph Wuerthner
2
6.67%
1
25.00%
Total
30
100.00%
4
100.00%

/**
 * zfcp_erp_set_adapter_status - set adapter status bits
 * @adapter: adapter to change the status
 * @mask: status bits to change
 *
 * Changes in common status bits are propagated to attached ports and LUNs.
 */


void zfcp_erp_set_adapter_status(struct zfcp_adapter *adapter, u32 mask)
{
	struct zfcp_port *port;
	struct scsi_device *sdev;
	unsigned long flags;
	u32 common_mask = mask & ZFCP_COMMON_FLAGS;

	atomic_or(mask, &adapter->status);

	if (!common_mask)
		return;

	read_lock_irqsave(&adapter->port_list_lock, flags);
	list_for_each_entry(port, &adapter->port_list, list)
		atomic_or(common_mask, &port->status);
	read_unlock_irqrestore(&adapter->port_list_lock, flags);

	spin_lock_irqsave(adapter->scsi_host->host_lock, flags);
	__shost_for_each_device(sdev, adapter->scsi_host)
		atomic_or(common_mask, &sdev_to_zfcp(sdev)->status);
	spin_unlock_irqrestore(adapter->scsi_host->host_lock, flags);
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Swen Schillig
45
34.88%
3
33.33%
Christof Schmitt
38
29.46%
1
11.11%
Martin Peschke
23
17.83%
1
11.11%
Andreas Herrmann
10
7.75%
1
11.11%
Martin Schwidefsky
9
6.98%
1
11.11%
Peter Zijlstra
3
2.33%
1
11.11%
Andrew Morton
1
0.78%
1
11.11%
Total
129
100.00%
9
100.00%

/**
 * zfcp_erp_clear_adapter_status - clear adapter status bits
 * @adapter: adapter to change the status
 * @mask: status bits to change
 *
 * Changes in common status bits are propagated to attached ports and LUNs.
 */


void zfcp_erp_clear_adapter_status(struct zfcp_adapter *adapter, u32 mask)
{
	struct zfcp_port *port;
	struct scsi_device *sdev;
	unsigned long flags;
	u32 common_mask = mask & ZFCP_COMMON_FLAGS;
	u32 clear_counter = mask & ZFCP_STATUS_COMMON_ERP_FAILED;

	atomic_andnot(mask, &adapter->status);

	if (!common_mask)
		return;

	if (clear_counter)
		atomic_set(&adapter->erp_counter, 0);

	read_lock_irqsave(&adapter->port_list_lock, flags);
	list_for_each_entry(port, &adapter->port_list, list) {
		atomic_andnot(common_mask, &port->status);
		if (clear_counter)
			atomic_set(&port->erp_counter, 0);
	}
	read_unlock_irqrestore(&adapter->port_list_lock, flags);

	spin_lock_irqsave(adapter->scsi_host->host_lock, flags);
	__shost_for_each_device(sdev, adapter->scsi_host) {
		atomic_andnot(common_mask, &sdev_to_zfcp(sdev)->status);
		if (clear_counter)
			atomic_set(&sdev_to_zfcp(sdev)->erp_counter, 0);
	}
	spin_unlock_irqrestore(adapter->scsi_host->host_lock, flags);
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Swen Schillig
136
73.51%
2
33.33%
Martin Peschke
23
12.43%
1
16.67%
Martin Schwidefsky
17
9.19%
1
16.67%
Christof Schmitt
6
3.24%
1
16.67%
Peter Zijlstra
3
1.62%
1
16.67%
Total
185
100.00%
6
100.00%

/**
 * zfcp_erp_set_port_status - set port status bits
 * @port: port to change the status
 * @mask: status bits to change
 *
 * Changes in common status bits are propagated to attached LUNs.
 */


void zfcp_erp_set_port_status(struct zfcp_port *port, u32 mask)
{
	struct scsi_device *sdev;
	u32 common_mask = mask & ZFCP_COMMON_FLAGS;
	unsigned long flags;

	atomic_or(mask, &port->status);

	if (!common_mask)
		return;

	spin_lock_irqsave(port->adapter->scsi_host->host_lock, flags);
	__shost_for_each_device(sdev, port->adapter->scsi_host)
		if (sdev_to_zfcp(sdev)->port == port)
			atomic_or(common_mask,
					&sdev_to_zfcp(sdev)->status);
	spin_unlock_irqrestore(port->adapter->scsi_host->host_lock, flags);
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Christof Schmitt
32
31.68%
2
25.00%
Martin Peschke
31
30.69%
1
12.50%
Martin Schwidefsky
21
20.79%
1
12.50%
Swen Schillig
14
13.86%
2
25.00%
Peter Zijlstra
2
1.98%
1
12.50%
Andreas Herrmann
1
0.99%
1
12.50%
Total
101
100.00%
8
100.00%

/**
 * zfcp_erp_clear_port_status - clear port status bits
 * @port: adapter to change the status
 * @mask: status bits to change
 *
 * Changes in common status bits are propagated to attached LUNs.
 */


void zfcp_erp_clear_port_status(struct zfcp_port *port, u32 mask)
{
	struct scsi_device *sdev;
	u32 common_mask = mask & ZFCP_COMMON_FLAGS;
	u32 clear_counter = mask & ZFCP_STATUS_COMMON_ERP_FAILED;
	unsigned long flags;

	atomic_andnot(mask, &port->status);

	if (!common_mask)
		return;

	if (clear_counter)
		atomic_set(&port->erp_counter, 0);

	spin_lock_irqsave(port->adapter->scsi_host->host_lock, flags);
	__shost_for_each_device(sdev, port->adapter->scsi_host)
		if (sdev_to_zfcp(sdev)->port == port) {
			atomic_andnot(common_mask,
					  &sdev_to_zfcp(sdev)->status);
			if (clear_counter)
				atomic_set(&sdev_to_zfcp(sdev)->erp_counter, 0);
		}
	spin_unlock_irqrestore(port->adapter->scsi_host->host_lock, flags);
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Swen Schillig
54
38.30%
1
11.11%
Martin Peschke
36
25.53%
3
33.33%
Christof Schmitt
28
19.86%
2
22.22%
Martin Schwidefsky
20
14.18%
1
11.11%
Peter Zijlstra
2
1.42%
1
11.11%
Andreas Herrmann
1
0.71%
1
11.11%
Total
141
100.00%
9
100.00%

/**
 * zfcp_erp_set_lun_status - set lun status bits
 * @sdev: SCSI device / lun to set the status bits
 * @mask: status bits to change
 */


void zfcp_erp_set_lun_status(struct scsi_device *sdev, u32 mask)
{
	struct zfcp_scsi_dev *zfcp_sdev = sdev_to_zfcp(sdev);

	atomic_or(mask, &zfcp_sdev->status);
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Swen Schillig
19
57.58%
2
33.33%
Andreas Herrmann
11
33.33%
1
16.67%
Martin Peschke
2
6.06%
2
33.33%
Peter Zijlstra
1
3.03%
1
16.67%
Total
33
100.00%
6
100.00%

/**
 * zfcp_erp_clear_lun_status - clear lun status bits
 * @sdev: SCSi device / lun to clear the status bits
 * @mask: status bits to change
 */


void zfcp_erp_clear_lun_status(struct scsi_device *sdev, u32 mask)
{
	struct zfcp_scsi_dev *zfcp_sdev = sdev_to_zfcp(sdev);

	atomic_andnot(mask, &zfcp_sdev->status);

	if (mask & ZFCP_STATUS_COMMON_ERP_FAILED)
		atomic_set(&zfcp_sdev->erp_counter, 0);
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Swen Schillig
29
59.18%
1
16.67%
Andreas Herrmann
14
28.57%
1
16.67%
Christof Schmitt
3
6.12%
1
16.67%
Martin Peschke
2
4.08%
2
33.33%
Peter Zijlstra
1
2.04%
1
16.67%
Total
49
100.00%
6
100.00%

/**
 * zfcp_erp_adapter_reset_sync() - Really reopen adapter and wait.
 * @adapter: Pointer to zfcp_adapter to reopen.
 * @id: Trace tag string of length %ZFCP_DBF_TAG_LEN.
 */


void zfcp_erp_adapter_reset_sync(struct zfcp_adapter *adapter, char *id)
{
	zfcp_erp_set_adapter_status(adapter, ZFCP_STATUS_COMMON_RUNNING);
	zfcp_erp_adapter_reopen(adapter, ZFCP_STATUS_COMMON_ERP_FAILED, id);
	zfcp_erp_wait(adapter);
}
Contributors
Person
Tokens
Prop
Commits
CommitProp
Steffen Maier
35
100.00%
1
100.00%
Total
35
100.00%
1
100.00%

Overall Contributors
Person
Tokens
Prop
Commits
CommitProp
Christof Schmitt
3784
52.37%
29
29.00%
Martin Schwidefsky
1364
18.88%
2
2.00%
Swen Schillig
828
11.46%
24
24.00%
Steffen Maier
709
9.81%
14
14.00%
Martin Peschke
242
3.35%
7
7.00%
Andrew Morton
91
1.26%
4
4.00%
Andreas Herrmann
85
1.18%
9
9.00%
Kees Cook
40
0.55%
1
1.00%
Maxim Shchetynin
32
0.44%
1
1.00%
Peter Zijlstra
31
0.43%
1
1.00%
Volker Sameske
8
0.11%
2
2.00%
Martin Petermann
5
0.07%
1
1.00%
Ralph Wuerthner
2
0.03%
1
1.00%
Heiko Carstens
2
0.03%
1
1.00%
Nishanth Aravamudan
1
0.01%
1
1.00%
Greg Kroah-Hartman
1
0.01%
1
1.00%
Sven Schuetz
1
0.01%
1
1.00%
Total
7226
100.00%
100
100.00%
Directory: drivers/s390/scsi

Information contained on this website is for historical information purposes only and does not indicate or represent copyright ownership.