[SCSI] zfcp: enhancement of zfcp debug features (8a36e453) · Commits · 戴 / test

drivers/s390/scsi/Makefile

+1 −1

Original line number	Diff line number	Diff line
		@@ -3,7 +3,7 @@
		#

		zfcp-objs := zfcp_aux.o zfcp_ccw.o zfcp_scsi.o zfcp_erp.o zfcp_qdio.o \
		zfcp_fsf.o zfcp_sysfs_adapter.o zfcp_sysfs_port.o \
		zfcp_fsf.o zfcp_dbf.o zfcp_sysfs_adapter.o zfcp_sysfs_port.o \
		zfcp_sysfs_unit.o zfcp_sysfs_driver.o

		obj-$(CONFIG_ZFCP) += zfcp.o

drivers/s390/scsi/zfcp_aux.c

+1 −179

Original line number	Diff line number	Diff line
		@@ -122,93 +122,6 @@ _zfcp_hex_dump(char *addr, int count)

		#define ZFCP_LOG_AREA ZFCP_LOG_AREA_OTHER

		static inline int
		zfcp_fsf_req_is_scsi_cmnd(struct zfcp_fsf_req *fsf_req)
		{
		return ((fsf_req->fsf_command == FSF_QTCB_FCP_CMND) &&
		!(fsf_req->status & ZFCP_STATUS_FSFREQ_TASK_MANAGEMENT));
		}

		void
		zfcp_cmd_dbf_event_fsf(const char text, struct zfcp_fsf_req fsf_req,
		void *add_data, int add_length)
		{
		struct zfcp_adapter *adapter = fsf_req->adapter;
		struct scsi_cmnd *scsi_cmnd;
		int level = 3;
		int i;
		unsigned long flags;

		spin_lock_irqsave(&adapter->dbf_lock, flags);
		if (zfcp_fsf_req_is_scsi_cmnd(fsf_req)) {
		scsi_cmnd = (struct scsi_cmnd*) fsf_req->data;
		debug_text_event(adapter->cmd_dbf, level, "fsferror");
		debug_text_event(adapter->cmd_dbf, level, text);
		debug_event(adapter->cmd_dbf, level, &fsf_req,
		sizeof (unsigned long));
		debug_event(adapter->cmd_dbf, level, &fsf_req->seq_no,
		sizeof (u32));
		debug_event(adapter->cmd_dbf, level, &scsi_cmnd,
		sizeof (unsigned long));
		debug_event(adapter->cmd_dbf, level, &scsi_cmnd->cmnd,
		min(ZFCP_CMD_DBF_LENGTH, (int)scsi_cmnd->cmd_len));
		for (i = 0; i < add_length; i += ZFCP_CMD_DBF_LENGTH)
		debug_event(adapter->cmd_dbf,
		level,
		(char *) add_data + i,
		min(ZFCP_CMD_DBF_LENGTH, add_length - i));
		}
		spin_unlock_irqrestore(&adapter->dbf_lock, flags);
		}

		/* XXX additionally log unit if available */
		/* ---> introduce new parameter for unit, see 2.4 code */
		void
		zfcp_cmd_dbf_event_scsi(const char text, struct scsi_cmnd scsi_cmnd)
		{
		struct zfcp_adapter *adapter;
		struct zfcp_fsf_req *fsf_req;
		int level = ((host_byte(scsi_cmnd->result) != 0) ? 1 : 5);
		unsigned long flags;

		adapter = (struct zfcp_adapter *) scsi_cmnd->device->host->hostdata[0];
		fsf_req = (struct zfcp_fsf_req *) scsi_cmnd->host_scribble;
		spin_lock_irqsave(&adapter->dbf_lock, flags);
		debug_text_event(adapter->cmd_dbf, level, "hostbyte");
		debug_text_event(adapter->cmd_dbf, level, text);
		debug_event(adapter->cmd_dbf, level, &scsi_cmnd->result, sizeof (u32));
		debug_event(adapter->cmd_dbf, level, &scsi_cmnd,
		sizeof (unsigned long));
		debug_event(adapter->cmd_dbf, level, &scsi_cmnd->cmnd,
		min(ZFCP_CMD_DBF_LENGTH, (int)scsi_cmnd->cmd_len));
		if (likely(fsf_req)) {
		debug_event(adapter->cmd_dbf, level, &fsf_req,
		sizeof (unsigned long));
		debug_event(adapter->cmd_dbf, level, &fsf_req->seq_no,
		sizeof (u32));
		} else {
		debug_text_event(adapter->cmd_dbf, level, "");
		debug_text_event(adapter->cmd_dbf, level, "");
		}
		spin_unlock_irqrestore(&adapter->dbf_lock, flags);
		}

		void
		zfcp_in_els_dbf_event(struct zfcp_adapter adapter, const char text,
		struct fsf_status_read_buffer *status_buffer, int length)
		{
		int level = 1;
		int i;

		debug_text_event(adapter->in_els_dbf, level, text);
		debug_event(adapter->in_els_dbf, level, &status_buffer->d_id, 8);
		for (i = 0; i < length; i += ZFCP_IN_ELS_DBF_LENGTH)
		debug_event(adapter->in_els_dbf,
		level,
		(char *) status_buffer->payload + i,
		min(ZFCP_IN_ELS_DBF_LENGTH, length - i));
		}

		/**
		* zfcp_device_setup - setup function
		* @str: pointer to parameter string
		@@ -1015,81 +928,6 @@ zfcp_free_low_mem_buffers(struct zfcp_adapter *adapter)
		mempool_destroy(adapter->pool.data_gid_pn);
		}

		/**
		* zfcp_adapter_debug_register - registers debug feature for an adapter
		* @adapter: pointer to adapter for which debug features should be registered
		* return: -ENOMEM on error, 0 otherwise
		*/
		int
		zfcp_adapter_debug_register(struct zfcp_adapter *adapter)
		{
		char dbf_name[20];

		/* debug feature area which records SCSI command failures (hostbyte) */
		spin_lock_init(&adapter->dbf_lock);

		sprintf(dbf_name, ZFCP_CMD_DBF_NAME "%s",
		zfcp_get_busid_by_adapter(adapter));
		adapter->cmd_dbf = debug_register(dbf_name, ZFCP_CMD_DBF_INDEX,
		ZFCP_CMD_DBF_AREAS,
		ZFCP_CMD_DBF_LENGTH);
		debug_register_view(adapter->cmd_dbf, &debug_hex_ascii_view);
		debug_set_level(adapter->cmd_dbf, ZFCP_CMD_DBF_LEVEL);

		/* debug feature area which records SCSI command aborts */
		sprintf(dbf_name, ZFCP_ABORT_DBF_NAME "%s",
		zfcp_get_busid_by_adapter(adapter));
		adapter->abort_dbf = debug_register(dbf_name, ZFCP_ABORT_DBF_INDEX,
		ZFCP_ABORT_DBF_AREAS,
		ZFCP_ABORT_DBF_LENGTH);
		debug_register_view(adapter->abort_dbf, &debug_hex_ascii_view);
		debug_set_level(adapter->abort_dbf, ZFCP_ABORT_DBF_LEVEL);

		/* debug feature area which records incoming ELS commands */
		sprintf(dbf_name, ZFCP_IN_ELS_DBF_NAME "%s",
		zfcp_get_busid_by_adapter(adapter));
		adapter->in_els_dbf = debug_register(dbf_name, ZFCP_IN_ELS_DBF_INDEX,
		ZFCP_IN_ELS_DBF_AREAS,
		ZFCP_IN_ELS_DBF_LENGTH);
		debug_register_view(adapter->in_els_dbf, &debug_hex_ascii_view);
		debug_set_level(adapter->in_els_dbf, ZFCP_IN_ELS_DBF_LEVEL);

		/* debug feature area which records erp events */
		sprintf(dbf_name, ZFCP_ERP_DBF_NAME "%s",
		zfcp_get_busid_by_adapter(adapter));
		adapter->erp_dbf = debug_register(dbf_name, ZFCP_ERP_DBF_INDEX,
		ZFCP_ERP_DBF_AREAS,
		ZFCP_ERP_DBF_LENGTH);
		debug_register_view(adapter->erp_dbf, &debug_hex_ascii_view);
		debug_set_level(adapter->erp_dbf, ZFCP_ERP_DBF_LEVEL);

		if (!(adapter->cmd_dbf && adapter->abort_dbf &&
		adapter->in_els_dbf && adapter->erp_dbf)) {
		zfcp_adapter_debug_unregister(adapter);
		return -ENOMEM;
		}

		return 0;

		}

		/**
		* zfcp_adapter_debug_unregister - unregisters debug feature for an adapter
		* @adapter: pointer to adapter for which debug features should be unregistered
		*/
		void
		zfcp_adapter_debug_unregister(struct zfcp_adapter *adapter)
		{
		debug_unregister(adapter->abort_dbf);
		debug_unregister(adapter->cmd_dbf);
		debug_unregister(adapter->erp_dbf);
		debug_unregister(adapter->in_els_dbf);
		adapter->abort_dbf = NULL;
		adapter->cmd_dbf = NULL;
		adapter->erp_dbf = NULL;
		adapter->in_els_dbf = NULL;
		}

		void
		zfcp_dummy_release(struct device *dev)
		{
		@@ -1460,10 +1298,6 @@ zfcp_fsf_incoming_els_rscn(struct zfcp_adapter *adapter,
		/* see FC-FS */
		no_entries = (fcp_rscn_head->payload_len / 4);

		zfcp_in_els_dbf_event(adapter, "##rscn", status_buffer,
		fcp_rscn_head->payload_len);

		debug_text_event(adapter->erp_dbf, 1, "unsol_els_rscn:");
		for (i = 1; i < no_entries; i++) {
		/* skip head and start with 1st element */
		fcp_rscn_element++;
		@@ -1495,8 +1329,6 @@ zfcp_fsf_incoming_els_rscn(struct zfcp_adapter *adapter,
		(ZFCP_STATUS_PORT_DID_DID, &port->status)) {
		ZFCP_LOG_INFO("incoming RSCN, trying to open "
		"port 0x%016Lx\n", port->wwpn);
		debug_text_event(adapter->erp_dbf, 1,
		"unsol_els_rscnu:");
		zfcp_erp_port_reopen(port,
		ZFCP_STATUS_COMMON_ERP_FAILED);
		continue;
		@@ -1522,8 +1354,6 @@ zfcp_fsf_incoming_els_rscn(struct zfcp_adapter *adapter,
		*/
		ZFCP_LOG_INFO("incoming RSCN, trying to open "
		"port 0x%016Lx\n", port->wwpn);
		debug_text_event(adapter->erp_dbf, 1,
		"unsol_els_rscnk:");
		zfcp_test_link(port);
		}
		}
		@@ -1539,8 +1369,6 @@ zfcp_fsf_incoming_els_plogi(struct zfcp_adapter *adapter,
		struct zfcp_port *port;
		unsigned long flags;

		zfcp_in_els_dbf_event(adapter, "##plogi", status_buffer, 28);

		read_lock_irqsave(&zfcp_data.config_lock, flags);
		list_for_each_entry(port, &adapter->port_list_head, list) {
		if (port->wwpn == ((wwn_t ) & els_logi->nport_wwn))
		@@ -1554,8 +1382,6 @@ zfcp_fsf_incoming_els_plogi(struct zfcp_adapter *adapter,
		status_buffer->d_id,
		zfcp_get_busid_by_adapter(adapter));
		} else {
		debug_text_event(adapter->erp_dbf, 1, "unsol_els_plogi:");
		debug_event(adapter->erp_dbf, 1, &els_logi->nport_wwn, 8);
		zfcp_erp_port_forced_reopen(port, 0);
		}
		}
		@@ -1568,8 +1394,6 @@ zfcp_fsf_incoming_els_logo(struct zfcp_adapter *adapter,
		struct zfcp_port *port;
		unsigned long flags;

		zfcp_in_els_dbf_event(adapter, "##logo", status_buffer, 16);

		read_lock_irqsave(&zfcp_data.config_lock, flags);
		list_for_each_entry(port, &adapter->port_list_head, list) {
		if (port->wwpn == els_logo->nport_wwpn)
		@@ -1583,8 +1407,6 @@ zfcp_fsf_incoming_els_logo(struct zfcp_adapter *adapter,
		status_buffer->d_id,
		zfcp_get_busid_by_adapter(adapter));
		} else {
		debug_text_event(adapter->erp_dbf, 1, "unsol_els_logo:");
		debug_event(adapter->erp_dbf, 1, &els_logo->nport_wwpn, 8);
		zfcp_erp_port_forced_reopen(port, 0);
		}
		}
		@@ -1593,7 +1415,6 @@ static void
		zfcp_fsf_incoming_els_unknown(struct zfcp_adapter *adapter,
		struct fsf_status_read_buffer *status_buffer)
		{
		zfcp_in_els_dbf_event(adapter, "##undef", status_buffer, 24);
		ZFCP_LOG_NORMAL("warning: unknown incoming ELS 0x%08x "
		"for adapter %s\n", (u32 ) (status_buffer->payload),
		zfcp_get_busid_by_adapter(adapter));
		@@ -1611,6 +1432,7 @@ zfcp_fsf_incoming_els(struct zfcp_fsf_req *fsf_req)
		els_type = (u32 ) (status_buffer->payload);
		adapter = fsf_req->adapter;

		zfcp_san_dbf_event_incoming_els(fsf_req);
		if (els_type == LS_PLOGI)
		zfcp_fsf_incoming_els_plogi(adapter, status_buffer);
		else if (els_type == LS_LOGO)

drivers/s390/scsi/zfcp_dbf.c

0 → 100644

+988 −0

File added.

Preview size limit exceeded, changes collapsed.

drivers/s390/scsi/zfcp_def.h

+179 −34

Original line number	Diff line number	Diff line
		@@ -66,7 +66,7 @@
		/******************* GENERAL DEFINES *******************************/

		/* zfcp version number, it consists of major, minor, and patch-level number */
		#define ZFCP_VERSION "4.3.0"
		#define ZFCP_VERSION "4.4.0"

		/**
		* zfcp_sg_to_address - determine kernel address from struct scatterlist
		@@ -280,6 +280,171 @@ struct fcp_logo {
		wwn_t nport_wwpn;
		} __attribute__((packed));

		/*
		* DBF stuff
		*/
		#define ZFCP_DBF_TAG_SIZE 4

		struct zfcp_dbf_dump {
		u8 tag[ZFCP_DBF_TAG_SIZE];
		u32 total_size; /* size of total dump data */
		u32 offset; /* how much data has being already dumped */
		u32 size; /* how much data comes with this record */
		u8 data[]; /* dump data */
		} __attribute__ ((packed));

		/* FIXME: to be inflated when reworking the erp dbf */
		struct zfcp_erp_dbf_record {
		u8 dummy[16];
		} __attribute__ ((packed));

		struct zfcp_hba_dbf_record_response {
		u32 fsf_command;
		u64 fsf_reqid;
		u32 fsf_seqno;
		u64 fsf_issued;
		u32 fsf_prot_status;
		u32 fsf_status;
		u8 fsf_prot_status_qual[FSF_PROT_STATUS_QUAL_SIZE];
		u8 fsf_status_qual[FSF_STATUS_QUALIFIER_SIZE];
		u32 fsf_req_status;
		u8 sbal_first;
		u8 sbal_curr;
		u8 sbal_last;
		u8 pool;
		u64 erp_action;
		union {
		struct {
		u64 scsi_cmnd;
		u64 scsi_serial;
		} send_fcp;
		struct {
		u64 wwpn;
		u32 d_id;
		u32 port_handle;
		} port;
		struct {
		u64 wwpn;
		u64 fcp_lun;
		u32 port_handle;
		u32 lun_handle;
		} unit;
		struct {
		u32 d_id;
		u8 ls_code;
		} send_els;
		} data;
		} __attribute__ ((packed));

		struct zfcp_hba_dbf_record_status {
		u8 failed;
		u32 status_type;
		u32 status_subtype;
		struct fsf_queue_designator
		queue_designator;
		u32 payload_size;
		#define ZFCP_DBF_UNSOL_PAYLOAD 80
		#define ZFCP_DBF_UNSOL_PAYLOAD_SENSE_DATA_AVAIL 32
		#define ZFCP_DBF_UNSOL_PAYLOAD_BIT_ERROR_THRESHOLD 56
		#define ZFCP_DBF_UNSOL_PAYLOAD_FEATURE_UPDATE_ALERT 2 * sizeof(u32)
		u8 payload[ZFCP_DBF_UNSOL_PAYLOAD];
		} __attribute__ ((packed));

		struct zfcp_hba_dbf_record_qdio {
		u32 status;
		u32 qdio_error;
		u32 siga_error;
		u8 sbal_index;
		u8 sbal_count;
		} __attribute__ ((packed));

		struct zfcp_hba_dbf_record {
		u8 tag[ZFCP_DBF_TAG_SIZE];
		u8 tag2[ZFCP_DBF_TAG_SIZE];
		union {
		struct zfcp_hba_dbf_record_response response;
		struct zfcp_hba_dbf_record_status status;
		struct zfcp_hba_dbf_record_qdio qdio;
		} type;
		} __attribute__ ((packed));

		struct zfcp_san_dbf_record_ct {
		union {
		struct {
		u16 cmd_req_code;
		u8 revision;
		u8 gs_type;
		u8 gs_subtype;
		u8 options;
		u16 max_res_size;
		} request;
		struct {
		u16 cmd_rsp_code;
		u8 revision;
		u8 reason_code;
		u8 reason_code_expl;
		u8 vendor_unique;
		} response;
		} type;
		u32 payload_size;
		#define ZFCP_DBF_CT_PAYLOAD 24
		u8 payload[ZFCP_DBF_CT_PAYLOAD];
		} __attribute__ ((packed));

		struct zfcp_san_dbf_record_els {
		u8 ls_code;
		u32 payload_size;
		#define ZFCP_DBF_ELS_PAYLOAD 32
		#define ZFCP_DBF_ELS_MAX_PAYLOAD 1024
		u8 payload[ZFCP_DBF_ELS_PAYLOAD];
		} __attribute__ ((packed));

		struct zfcp_san_dbf_record {
		u8 tag[ZFCP_DBF_TAG_SIZE];
		u64 fsf_reqid;
		u32 fsf_seqno;
		u32 s_id;
		u32 d_id;
		union {
		struct zfcp_san_dbf_record_ct ct;
		struct zfcp_san_dbf_record_els els;
		} type;
		} __attribute__ ((packed));

		struct zfcp_scsi_dbf_record {
		u8 tag[ZFCP_DBF_TAG_SIZE];
		u8 tag2[ZFCP_DBF_TAG_SIZE];
		u32 scsi_id;
		u32 scsi_lun;
		u32 scsi_result;
		u64 scsi_cmnd;
		u64 scsi_serial;
		#define ZFCP_DBF_SCSI_OPCODE 16
		u8 scsi_opcode[ZFCP_DBF_SCSI_OPCODE];
		u8 scsi_retries;
		u8 scsi_allowed;
		u64 fsf_reqid;
		u32 fsf_seqno;
		u64 fsf_issued;
		union {
		struct {
		u64 fsf_reqid;
		u32 fsf_seqno;
		u64 fsf_issued;
		} new_fsf_req;
		struct {
		u8 rsp_validity;
		u8 rsp_scsi_status;
		u32 rsp_resid;
		u8 rsp_code;
		#define ZFCP_DBF_SCSI_FCP_SNS_INFO 16
		#define ZFCP_DBF_SCSI_MAX_FCP_SNS_INFO 256
		u32 sns_info_len;
		u8 sns_info[ZFCP_DBF_SCSI_FCP_SNS_INFO];
		} fcp;
		} type;
		} __attribute__ ((packed));

		/*
		* FC-FS stuff
		*/
		@@ -339,34 +504,6 @@ struct zfcp_rc_entry {
		*/
		#define ZFCP_CT_TIMEOUT (3 * R_A_TOV)


		/*************** S390 DEBUG FEATURE SPECIFIC DEFINES *********************/

		/* debug feature entries per adapter */
		#define ZFCP_ERP_DBF_INDEX 1
		#define ZFCP_ERP_DBF_AREAS 2
		#define ZFCP_ERP_DBF_LENGTH 16
		#define ZFCP_ERP_DBF_LEVEL 3
		#define ZFCP_ERP_DBF_NAME "zfcperp"

		#define ZFCP_CMD_DBF_INDEX 2
		#define ZFCP_CMD_DBF_AREAS 1
		#define ZFCP_CMD_DBF_LENGTH 8
		#define ZFCP_CMD_DBF_LEVEL 3
		#define ZFCP_CMD_DBF_NAME "zfcpcmd"

		#define ZFCP_ABORT_DBF_INDEX 2
		#define ZFCP_ABORT_DBF_AREAS 1
		#define ZFCP_ABORT_DBF_LENGTH 8
		#define ZFCP_ABORT_DBF_LEVEL 6
		#define ZFCP_ABORT_DBF_NAME "zfcpabt"

		#define ZFCP_IN_ELS_DBF_INDEX 2
		#define ZFCP_IN_ELS_DBF_AREAS 1
		#define ZFCP_IN_ELS_DBF_LENGTH 8
		#define ZFCP_IN_ELS_DBF_LEVEL 6
		#define ZFCP_IN_ELS_DBF_NAME "zfcpels"

		/****************** LOGGING MACROS AND DEFINES ***************************/

		/*
		@@ -823,11 +960,18 @@ struct zfcp_adapter {
		u32 erp_low_mem_count; /* nr of erp actions waiting
		for memory */
		struct zfcp_port nameserver_port; / adapter's nameserver */
		debug_info_t erp_dbf; / S/390 debug features */
		debug_info_t *abort_dbf;
		debug_info_t *in_els_dbf;
		debug_info_t *cmd_dbf;
		spinlock_t dbf_lock;
		debug_info_t *erp_dbf;
		debug_info_t *hba_dbf;
		debug_info_t san_dbf; / debug feature areas */
		debug_info_t *scsi_dbf;
		spinlock_t erp_dbf_lock;
		spinlock_t hba_dbf_lock;
		spinlock_t san_dbf_lock;
		spinlock_t scsi_dbf_lock;
		struct zfcp_erp_dbf_record erp_dbf_buf;
		struct zfcp_hba_dbf_record hba_dbf_buf;
		struct zfcp_san_dbf_record san_dbf_buf;
		struct zfcp_scsi_dbf_record scsi_dbf_buf;
		struct zfcp_adapter_mempool pool; /* Adapter memory pools */
		struct qdio_initialize qdio_init_data; /* for qdio_establish */
		struct device generic_services; /* directory for WKA ports */
		@@ -902,6 +1046,7 @@ struct zfcp_fsf_req {
		issued on behalf of erp */
		mempool_t pool; / used if request was alloacted
		from emergency pool */
		unsigned long long issued; /* request sent time (STCK) */
		struct zfcp_unit *unit;
		};

drivers/s390/scsi/zfcp_ext.h

+21 −5

Original line number	Diff line number	Diff line
		@@ -181,9 +181,25 @@ extern void zfcp_erp_port_access_changed(struct zfcp_port *);
		extern void zfcp_erp_unit_access_changed(struct zfcp_unit *);

		/****************************** AUX **************************************/
		extern void zfcp_cmd_dbf_event_fsf(const char , struct zfcp_fsf_req ,
		void *, int);
		extern void zfcp_cmd_dbf_event_scsi(const char , struct scsi_cmnd );
		extern void zfcp_in_els_dbf_event(struct zfcp_adapter , const char ,
		struct fsf_status_read_buffer *, int);
		extern void zfcp_hba_dbf_event_fsf_response(struct zfcp_fsf_req *);
		extern void zfcp_hba_dbf_event_fsf_unsol(const char , struct zfcp_adapter ,
		struct fsf_status_read_buffer *);
		extern void zfcp_hba_dbf_event_qdio(struct zfcp_adapter *,
		unsigned int, unsigned int, unsigned int,
		int, int);

		extern void zfcp_san_dbf_event_ct_request(struct zfcp_fsf_req *);
		extern void zfcp_san_dbf_event_ct_response(struct zfcp_fsf_req *);
		extern void zfcp_san_dbf_event_els_request(struct zfcp_fsf_req *);
		extern void zfcp_san_dbf_event_els_response(struct zfcp_fsf_req *);
		extern void zfcp_san_dbf_event_incoming_els(struct zfcp_fsf_req *);

		extern void zfcp_scsi_dbf_event_result(const char , int, struct zfcp_adapter ,
		struct scsi_cmnd *);
		extern void zfcp_scsi_dbf_event_abort(const char , struct zfcp_adapter ,
		struct scsi_cmnd *,
		struct zfcp_fsf_req *);
		extern void zfcp_scsi_dbf_event_devreset(const char , u8, struct zfcp_unit ,
		struct scsi_cmnd *);

		#endif /* ZFCP_EXT_H */

Admin message