[linux-2.6-block.git] / include / scsi / scsi_transport_srp.h

#ifndef SCSI_TRANSPORT_SRP_H
#define SCSI_TRANSPORT_SRP_H

#include <linux/transport_class.h>
#include <linux/types.h>
#include <linux/mutex.h>

#define SRP_RPORT_ROLE_INITIATOR 0
#define SRP_RPORT_ROLE_TARGET 1

struct srp_rport_identifiers {
	u8 port_id[16];
	u8 roles;
};

/**
 * enum srp_rport_state - SRP transport layer state
 * @SRP_RPORT_RUNNING:   Transport layer operational.
 * @SRP_RPORT_BLOCKED:   Transport layer not operational; fast I/O fail timer
 *                       is running and I/O has been blocked.
 * @SRP_RPORT_FAIL_FAST: Fast I/O fail timer has expired; fail I/O fast.
 * @SRP_RPORT_LOST:      Device loss timer has expired; port is being removed.
 */
enum srp_rport_state {
	SRP_RPORT_RUNNING,
	SRP_RPORT_BLOCKED,
	SRP_RPORT_FAIL_FAST,
	SRP_RPORT_LOST,
};

/**
 * struct srp_rport
 * @lld_data: LLD private data.
 * @mutex:    Protects against concurrent rport reconnect / fast_io_fail /
 *   dev_loss_tmo activity.
 */
struct srp_rport {
	/* for initiator and target drivers */

	struct device dev;

	u8 port_id[16];
	u8 roles;

	/* for initiator drivers */

	void			*lld_data;

	struct mutex		mutex;
	enum srp_rport_state	state;
	bool			deleted;
	int			reconnect_delay;
	int			failed_reconnects;
	struct delayed_work	reconnect_work;
	int			fast_io_fail_tmo;
	int			dev_loss_tmo;
	struct delayed_work	fast_io_fail_work;
	struct delayed_work	dev_loss_work;
};

/**
 * struct srp_function_template
 * @has_rport_state: Whether or not to create the state, fast_io_fail_tmo and
 *     dev_loss_tmo sysfs attribute for an rport.
 * @reset_timer_if_blocked: Whether or srp_timed_out() should reset the command
 *     timer if the device on which it has been queued is blocked.
 * @reconnect_delay: If not NULL, points to the default reconnect_delay value.
 * @fast_io_fail_tmo: If not NULL, points to the default fast_io_fail_tmo value.
 * @dev_loss_tmo: If not NULL, points to the default dev_loss_tmo value.
 * @reconnect: Callback function for reconnecting to the target. See also
 *     srp_reconnect_rport().
 * @terminate_rport_io: Callback function for terminating all outstanding I/O
 *     requests for an rport.
 */
struct srp_function_template {
	/* for initiator drivers */
	bool has_rport_state;
	bool reset_timer_if_blocked;
	int *reconnect_delay;
	int *fast_io_fail_tmo;
	int *dev_loss_tmo;
	int (*reconnect)(struct srp_rport *rport);
	void (*terminate_rport_io)(struct srp_rport *rport);
	void (*rport_delete)(struct srp_rport *rport);
	/* for target drivers */
	int (* tsk_mgmt_response)(struct Scsi_Host *, u64, u64, int);
	int (* it_nexus_response)(struct Scsi_Host *, u64, int);
};

extern struct scsi_transport_template *
srp_attach_transport(struct srp_function_template *);
extern void srp_release_transport(struct scsi_transport_template *);

extern void srp_rport_get(struct srp_rport *rport);
extern void srp_rport_put(struct srp_rport *rport);
extern struct srp_rport *srp_rport_add(struct Scsi_Host *,
				       struct srp_rport_identifiers *);
extern void srp_rport_del(struct srp_rport *);
extern int srp_tmo_valid(int reconnect_delay, int fast_io_fail_tmo,
			 int dev_loss_tmo);
extern int srp_reconnect_rport(struct srp_rport *rport);
extern void srp_start_tl_fail_timers(struct srp_rport *rport);
extern void srp_remove_host(struct Scsi_Host *);

/**
 * srp_chkready() - evaluate the transport layer state before I/O
 *
 * Returns a SCSI result code that can be returned by the LLD queuecommand()
 * implementation. The role of this function is similar to that of
 * fc_remote_port_chkready().
 */
static inline int srp_chkready(struct srp_rport *rport)
{
	switch (rport->state) {
	case SRP_RPORT_RUNNING:
	case SRP_RPORT_BLOCKED:
	default:
		return 0;
	case SRP_RPORT_FAIL_FAST:
		return DID_TRANSPORT_FAILFAST << 16;
	case SRP_RPORT_LOST:
		return DID_NO_CONNECT << 16;
	}
}

#endif
Commit	Line	Data
09345f65 FT	1	#ifndef SCSI_TRANSPORT_SRP_H
	2	#define SCSI_TRANSPORT_SRP_H
	3
	4	#include <linux/transport_class.h>
	5	#include <linux/types.h>
	6	#include <linux/mutex.h>
	7
aebd5e47 FT	8	#define SRP_RPORT_ROLE_INITIATOR 0
	9	#define SRP_RPORT_ROLE_TARGET 1
	10
09345f65 FT	11	struct srp_rport_identifiers {
09345f65 FT	12	u8 port_id[16];
aebd5e47	13	u8 roles;
09345f65 FT	14	};
09345f65 FT	15
29c17324 BVA	16	/**
	17	* enum srp_rport_state - SRP transport layer state
	18	* @SRP_RPORT_RUNNING: Transport layer operational.
	19	* @SRP_RPORT_BLOCKED: Transport layer not operational; fast I/O fail timer
	20	* is running and I/O has been blocked.
	21	* @SRP_RPORT_FAIL_FAST: Fast I/O fail timer has expired; fail I/O fast.
	22	* @SRP_RPORT_LOST: Device loss timer has expired; port is being removed.
	23	*/
	24	enum srp_rport_state {
	25	SRP_RPORT_RUNNING,
	26	SRP_RPORT_BLOCKED,
	27	SRP_RPORT_FAIL_FAST,
	28	SRP_RPORT_LOST,
	29	};
	30
	31	/**
	32	* struct srp_rport
	33	* @lld_data: LLD private data.
8c64e453 BVA	34	* @mutex: Protects against concurrent rport reconnect / fast_io_fail /
8c64e453 BVA	35	* dev_loss_tmo activity.
29c17324	36	*/
09345f65	37	struct srp_rport {
dc1bdbd9 BVA	38	/* for initiator and target drivers */
dc1bdbd9 BVA	39
09345f65 FT	40	struct device dev;
	41
	42	u8 port_id[16];
aebd5e47	43	u8 roles;
dc1bdbd9 BVA	44
	45	/* for initiator drivers */
	46
29c17324 BVA	47	void *lld_data;
	48
	49	struct mutex mutex;
	50	enum srp_rport_state state;
	51	bool deleted;
8c64e453 BVA	52	int reconnect_delay;
	53	int failed_reconnects;
	54	struct delayed_work reconnect_work;
29c17324 BVA	55	int fast_io_fail_tmo;
	56	int dev_loss_tmo;
	57	struct delayed_work fast_io_fail_work;
	58	struct delayed_work dev_loss_work;
09345f65 FT	59	};
09345f65 FT	60
29c17324 BVA	61	/**
	62	* struct srp_function_template
	63	* @has_rport_state: Whether or not to create the state, fast_io_fail_tmo and
	64	* dev_loss_tmo sysfs attribute for an rport.
	65	* @reset_timer_if_blocked: Whether or srp_timed_out() should reset the command
	66	* timer if the device on which it has been queued is blocked.
8c64e453	67	* @reconnect_delay: If not NULL, points to the default reconnect_delay value.
29c17324 BVA	68	* @fast_io_fail_tmo: If not NULL, points to the default fast_io_fail_tmo value.
	69	* @dev_loss_tmo: If not NULL, points to the default dev_loss_tmo value.
	70	* @reconnect: Callback function for reconnecting to the target. See also
	71	* srp_reconnect_rport().
	72	* @terminate_rport_io: Callback function for terminating all outstanding I/O
	73	* requests for an rport.
	74	*/
09345f65	75	struct srp_function_template {
dc1bdbd9	76	/* for initiator drivers */
29c17324 BVA	77	bool has_rport_state;
29c17324 BVA	78	bool reset_timer_if_blocked;
8c64e453	79	int *reconnect_delay;
29c17324 BVA	80	int *fast_io_fail_tmo;
	81	int *dev_loss_tmo;
	82	int (reconnect)(struct srp_rport rport);
	83	void (terminate_rport_io)(struct srp_rport rport);
dc1bdbd9	84	void (rport_delete)(struct srp_rport rport);
62fe8826	85	/* for target drivers */
bfb74374	86	int (* tsk_mgmt_response)(struct Scsi_Host *, u64, u64, int);
62fe8826	87	int (* it_nexus_response)(struct Scsi_Host *, u64, int);
09345f65 FT	88	};
	89
	90	extern struct scsi_transport_template *
	91	srp_attach_transport(struct srp_function_template *);
	92	extern void srp_release_transport(struct scsi_transport_template *);
	93
9dd69a60 BVA	94	extern void srp_rport_get(struct srp_rport *rport);
9dd69a60 BVA	95	extern void srp_rport_put(struct srp_rport *rport);
09345f65 FT	96	extern struct srp_rport srp_rport_add(struct Scsi_Host ,
	97	struct srp_rport_identifiers *);
	98	extern void srp_rport_del(struct srp_rport *);
8c64e453 BVA	99	extern int srp_tmo_valid(int reconnect_delay, int fast_io_fail_tmo,
8c64e453 BVA	100	int dev_loss_tmo);
29c17324 BVA	101	extern int srp_reconnect_rport(struct srp_rport *rport);
29c17324 BVA	102	extern void srp_start_tl_fail_timers(struct srp_rport *rport);
09345f65 FT	103	extern void srp_remove_host(struct Scsi_Host *);
09345f65 FT	104
29c17324 BVA	105	/**
	106	* srp_chkready() - evaluate the transport layer state before I/O
	107	*
	108	* Returns a SCSI result code that can be returned by the LLD queuecommand()
	109	* implementation. The role of this function is similar to that of
	110	* fc_remote_port_chkready().
	111	*/
	112	static inline int srp_chkready(struct srp_rport *rport)
	113	{
	114	switch (rport->state) {
	115	case SRP_RPORT_RUNNING:
	116	case SRP_RPORT_BLOCKED:
	117	default:
	118	return 0;
	119	case SRP_RPORT_FAIL_FAST:
	120	return DID_TRANSPORT_FAILFAST << 16;
	121	case SRP_RPORT_LOST:
	122	return DID_NO_CONNECT << 16;
	123	}
	124	}
	125
09345f65	126	#endif