[SCSI] zfcp: remove union zfcp_req_data, use unit refcount for FCP commands (059c97d0) · Commits · 戴 / test

drivers/s390/scsi/zfcp_aux.c

+3 −5

Original line number	Diff line number	Diff line
		@@ -141,7 +141,7 @@ zfcp_cmd_dbf_event_fsf(const char text, struct zfcp_fsf_req fsf_req,

		spin_lock_irqsave(&adapter->dbf_lock, flags);
		if (zfcp_fsf_req_is_scsi_cmnd(fsf_req)) {
		scsi_cmnd = fsf_req->data.send_fcp_command_task.scsi_cmnd;
		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,
		@@ -167,14 +167,12 @@ void
		zfcp_cmd_dbf_event_scsi(const char text, struct scsi_cmnd scsi_cmnd)
		{
		struct zfcp_adapter *adapter;
		union zfcp_req_data *req_data;
		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];
		req_data = (union zfcp_req_data *) scsi_cmnd->host_scribble;
		fsf_req = (req_data ? req_data->send_fcp_command_task.fsf_req : NULL);
		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);
		@@ -1609,7 +1607,7 @@ zfcp_fsf_incoming_els(struct zfcp_fsf_req *fsf_req)
		u32 els_type;
		struct zfcp_adapter *adapter;

		status_buffer = fsf_req->data.status_read.buffer;
		status_buffer = (struct fsf_status_read_buffer *) fsf_req->data;
		els_type = (u32 ) (status_buffer->payload);
		adapter = fsf_req->adapter;

drivers/s390/scsi/zfcp_def.h

+2 −67

Original line number	Diff line number	Diff line
		@@ -635,45 +635,6 @@ struct zfcp_adapter_mempool {
		mempool_t *data_gid_pn;
		};

		struct zfcp_exchange_config_data{
		};

		struct zfcp_open_port {
		struct zfcp_port *port;
		};

		struct zfcp_close_port {
		struct zfcp_port *port;
		};

		struct zfcp_open_unit {
		struct zfcp_unit *unit;
		};

		struct zfcp_close_unit {
		struct zfcp_unit *unit;
		};

		struct zfcp_close_physical_port {
		struct zfcp_port *port;
		};

		struct zfcp_send_fcp_command_task {
		struct zfcp_fsf_req *fsf_req;
		struct zfcp_unit *unit;
		struct scsi_cmnd *scsi_cmnd;
		unsigned long start_jiffies;
		};

		struct zfcp_send_fcp_command_task_management {
		struct zfcp_unit *unit;
		};

		struct zfcp_abort_fcp_command {
		struct zfcp_fsf_req *fsf_req;
		struct zfcp_unit *unit;
		};

		/*
		* header for CT_IU
		*/
		@@ -781,33 +742,6 @@ struct zfcp_send_els {
		int status;
		};

		struct zfcp_status_read {
		struct fsf_status_read_buffer *buffer;
		};

		struct zfcp_fsf_done {
		struct completion *complete;
		int status;
		};

		/* request specific data */
		union zfcp_req_data {
		struct zfcp_exchange_config_data exchange_config_data;
		struct zfcp_open_port open_port;
		struct zfcp_close_port close_port;
		struct zfcp_open_unit open_unit;
		struct zfcp_close_unit close_unit;
		struct zfcp_close_physical_port close_physical_port;
		struct zfcp_send_fcp_command_task send_fcp_command_task;
		struct zfcp_send_fcp_command_task_management
		send_fcp_command_task_management;
		struct zfcp_abort_fcp_command abort_fcp_command;
		struct zfcp_send_ct *send_ct;
		struct zfcp_send_els *send_els;
		struct zfcp_status_read status_read;
		struct fsf_qtcb_bottom_port *port_data;
		};

		struct zfcp_qdio_queue {
		struct qdio_buffer buffer[QDIO_MAX_BUFFERS_PER_Q]; / SBALs */
		u8 free_index; /* index of next free bfr
		@@ -963,11 +897,12 @@ struct zfcp_fsf_req {
		u32 fsf_command; /* FSF Command copy */
		struct fsf_qtcb qtcb; / address of associated QTCB */
		u32 seq_no; /* Sequence number of request */
		union zfcp_req_data data; /* Info fields of request */
		unsigned long data; /* private data of request */
		struct zfcp_erp_action erp_action; / used if this request is
		issued on behalf of erp */
		mempool_t pool; / used if request was alloacted
		from emergency pool */
		struct zfcp_unit *unit;
		};

		typedef void zfcp_fsf_req_handler_t(struct zfcp_fsf_req*);

drivers/s390/scsi/zfcp_fsf.c

+50 −51

Original line number	Diff line number	Diff line
		@@ -821,7 +821,7 @@ zfcp_fsf_status_read(struct zfcp_adapter *adapter, int req_flags)
		goto failed_buf;
		}
		memset(status_buffer, 0, sizeof (struct fsf_status_read_buffer));
		fsf_req->data.status_read.buffer = status_buffer;
		fsf_req->data = (unsigned long) status_buffer;

		/* insert pointer to respective buffer */
		sbale = zfcp_qdio_sbale_curr(fsf_req);
		@@ -859,7 +859,7 @@ zfcp_fsf_status_read_port_closed(struct zfcp_fsf_req *fsf_req)
		struct zfcp_port *port;
		unsigned long flags;

		status_buffer = fsf_req->data.status_read.buffer;
		status_buffer = (struct fsf_status_read_buffer *) fsf_req->data;
		adapter = fsf_req->adapter;

		read_lock_irqsave(&zfcp_data.config_lock, flags);
		@@ -918,7 +918,7 @@ zfcp_fsf_status_read_handler(struct zfcp_fsf_req *fsf_req)
		int retval = 0;
		struct zfcp_adapter *adapter = fsf_req->adapter;
		struct fsf_status_read_buffer *status_buffer =
		fsf_req->data.status_read.buffer;
		(struct fsf_status_read_buffer *) fsf_req->data;

		if (fsf_req->status & ZFCP_STATUS_FSFREQ_DISMISSED) {
		mempool_free(status_buffer, adapter->pool.data_status_read);
		@@ -1093,7 +1093,7 @@ zfcp_fsf_abort_fcp_command(unsigned long old_req_id,
		sbale[0].flags \|= SBAL_FLAGS0_TYPE_READ;
		sbale[1].flags \|= SBAL_FLAGS_LAST_ENTRY;

		fsf_req->data.abort_fcp_command.unit = unit;
		fsf_req->data = (unsigned long) unit;

		/* set handles of unit and its parent port in QTCB */
		fsf_req->qtcb->header.lun_handle = unit->handle;
		@@ -1139,7 +1139,7 @@ static int
		zfcp_fsf_abort_fcp_command_handler(struct zfcp_fsf_req *new_fsf_req)
		{
		int retval = -EINVAL;
		struct zfcp_unit *unit = new_fsf_req->data.abort_fcp_command.unit;
		struct zfcp_unit *unit;
		unsigned char status_qual =
		new_fsf_req->qtcb->header.fsf_status_qual.word[0];

		@@ -1150,6 +1150,8 @@ zfcp_fsf_abort_fcp_command_handler(struct zfcp_fsf_req *new_fsf_req)
		goto skip_fsfstatus;
		}

		unit = (struct zfcp_unit *) new_fsf_req->data;

		/* evaluate FSF status in QTCB */
		switch (new_fsf_req->qtcb->header.fsf_status) {

		@@ -1414,7 +1416,7 @@ zfcp_fsf_send_ct(struct zfcp_send_ct ct, mempool_t pool,
		fsf_req->qtcb->header.port_handle = port->handle;
		fsf_req->qtcb->bottom.support.service_class = adapter->fc_service_class;
		fsf_req->qtcb->bottom.support.timeout = ct->timeout;
		fsf_req->data.send_ct = ct;
		fsf_req->data = (unsigned long) ct;

		/* start QDIO request for this FSF request */
		ret = zfcp_fsf_req_send(fsf_req, ct->timer);
		@@ -1445,10 +1447,10 @@ zfcp_fsf_send_ct(struct zfcp_send_ct ct, mempool_t pool,
		* zfcp_fsf_send_ct_handler - handler for Generic Service requests
		* @fsf_req: pointer to struct zfcp_fsf_req
		*
		* Data specific for the Generic Service request is passed by
		* fsf_req->data.send_ct
		* Usually a specific handler for the request is called via
		* fsf_req->data.send_ct->handler at end of this function.
		* Data specific for the Generic Service request is passed using
		* fsf_req->data. There we find the pointer to struct zfcp_send_ct.
		* Usually a specific handler for the CT request is called which is
		* found in this structure.
		*/
		static int
		zfcp_fsf_send_ct_handler(struct zfcp_fsf_req *fsf_req)
		@@ -1462,7 +1464,7 @@ zfcp_fsf_send_ct_handler(struct zfcp_fsf_req *fsf_req)
		u16 subtable, rule, counter;

		adapter = fsf_req->adapter;
		send_ct = fsf_req->data.send_ct;
		send_ct = (struct zfcp_send_ct *) fsf_req->data;
		port = send_ct->port;
		header = &fsf_req->qtcb->header;
		bottom = &fsf_req->qtcb->bottom.support;
		@@ -1714,7 +1716,7 @@ zfcp_fsf_send_els(struct zfcp_send_els *els)
		fsf_req->qtcb->bottom.support.d_id = d_id;
		fsf_req->qtcb->bottom.support.service_class = adapter->fc_service_class;
		fsf_req->qtcb->bottom.support.timeout = ZFCP_ELS_TIMEOUT;
		fsf_req->data.send_els = els;
		fsf_req->data = (unsigned long) els;

		sbale = zfcp_qdio_sbale_req(fsf_req, fsf_req->sbal_curr, 0);

		@@ -1746,10 +1748,10 @@ zfcp_fsf_send_els(struct zfcp_send_els *els)
		* zfcp_fsf_send_els_handler - handler for ELS commands
		* @fsf_req: pointer to struct zfcp_fsf_req
		*
		* Data specific for the ELS command is passed by
		* fsf_req->data.send_els
		* Usually a specific handler for the command is called via
		* fsf_req->data.send_els->handler at end of this function.
		* Data specific for the ELS command is passed using
		* fsf_req->data. There we find the pointer to struct zfcp_send_els.
		* Usually a specific handler for the ELS command is called which is
		* found in this structure.
		*/
		static int zfcp_fsf_send_els_handler(struct zfcp_fsf_req *fsf_req)
		{
		@@ -1762,7 +1764,7 @@ static int zfcp_fsf_send_els_handler(struct zfcp_fsf_req *fsf_req)
		int retval = -EINVAL;
		u16 subtable, rule, counter;

		send_els = fsf_req->data.send_els;
		send_els = (struct zfcp_send_els *) fsf_req->data;
		adapter = send_els->adapter;
		port = send_els->port;
		d_id = send_els->d_id;
		@@ -2211,12 +2213,12 @@ zfcp_fsf_exchange_port_data(struct zfcp_adapter *adapter,
		goto out;
		}

		fsf_req->data = (unsigned long) data;

		sbale = zfcp_qdio_sbale_req(fsf_req, fsf_req->sbal_curr, 0);
		sbale[0].flags \|= SBAL_FLAGS0_TYPE_READ;
		sbale[1].flags \|= SBAL_FLAGS_LAST_ENTRY;

		fsf_req->data.port_data = data;

		init_timer(timer);
		timer->function = zfcp_fsf_request_timeout_handler;
		timer->data = (unsigned long) adapter;
		@@ -2257,7 +2259,9 @@ static void
		zfcp_fsf_exchange_port_data_handler(struct zfcp_fsf_req *fsf_req)
		{
		struct fsf_qtcb_bottom_port *bottom;
		struct fsf_qtcb_bottom_port *data = fsf_req->data.port_data;
		struct fsf_qtcb_bottom_port *data;

		data = (struct fsf_qtcb_bottom_port*) fsf_req->data;

		if (fsf_req->status & ZFCP_STATUS_FSFREQ_ERROR)
		return;
		@@ -2312,7 +2316,7 @@ zfcp_fsf_open_port(struct zfcp_erp_action *erp_action)

		erp_action->fsf_req->qtcb->bottom.support.d_id = erp_action->port->d_id;
		atomic_set_mask(ZFCP_STATUS_COMMON_OPENING, &erp_action->port->status);
		erp_action->fsf_req->data.open_port.port = erp_action->port;
		erp_action->fsf_req->data = (unsigned long) erp_action->port;
		erp_action->fsf_req->erp_action = erp_action;

		/* start QDIO request for this FSF request */
		@@ -2353,7 +2357,7 @@ zfcp_fsf_open_port_handler(struct zfcp_fsf_req *fsf_req)
		struct fsf_qtcb_header *header;
		u16 subtable, rule, counter;

		port = fsf_req->data.open_port.port;
		port = (struct zfcp_port *) fsf_req->data;
		header = &fsf_req->qtcb->header;

		if (fsf_req->status & ZFCP_STATUS_FSFREQ_ERROR) {
		@@ -2566,7 +2570,7 @@ zfcp_fsf_close_port(struct zfcp_erp_action *erp_action)
		sbale[1].flags \|= SBAL_FLAGS_LAST_ENTRY;

		atomic_set_mask(ZFCP_STATUS_COMMON_CLOSING, &erp_action->port->status);
		erp_action->fsf_req->data.close_port.port = erp_action->port;
		erp_action->fsf_req->data = (unsigned long) erp_action->port;
		erp_action->fsf_req->erp_action = erp_action;
		erp_action->fsf_req->qtcb->header.port_handle =
		erp_action->port->handle;
		@@ -2606,7 +2610,7 @@ zfcp_fsf_close_port_handler(struct zfcp_fsf_req *fsf_req)
		int retval = -EINVAL;
		struct zfcp_port *port;

		port = fsf_req->data.close_port.port;
		port = (struct zfcp_port *) fsf_req->data;

		if (fsf_req->status & ZFCP_STATUS_FSFREQ_ERROR) {
		/* don't change port status in our bookkeeping */
		@@ -2703,7 +2707,7 @@ zfcp_fsf_close_physical_port(struct zfcp_erp_action *erp_action)
		atomic_set_mask(ZFCP_STATUS_PORT_PHYS_CLOSING,
		&erp_action->port->status);
		/* save a pointer to this port */
		erp_action->fsf_req->data.close_physical_port.port = erp_action->port;
		erp_action->fsf_req->data = (unsigned long) erp_action->port;
		/* port to be closeed */
		erp_action->fsf_req->qtcb->header.port_handle =
		erp_action->port->handle;
		@@ -2747,7 +2751,7 @@ zfcp_fsf_close_physical_port_handler(struct zfcp_fsf_req *fsf_req)
		struct fsf_qtcb_header *header;
		u16 subtable, rule, counter;

		port = fsf_req->data.close_physical_port.port;
		port = (struct zfcp_port *) fsf_req->data;
		header = &fsf_req->qtcb->header;

		if (fsf_req->status & ZFCP_STATUS_FSFREQ_ERROR) {
		@@ -2911,7 +2915,7 @@ zfcp_fsf_open_unit(struct zfcp_erp_action *erp_action)
		erp_action->fsf_req->qtcb->bottom.support.option =
		FSF_OPEN_LUN_SUPPRESS_BOXING;
		atomic_set_mask(ZFCP_STATUS_COMMON_OPENING, &erp_action->unit->status);
		erp_action->fsf_req->data.open_unit.unit = erp_action->unit;
		erp_action->fsf_req->data = (unsigned long) erp_action->unit;
		erp_action->fsf_req->erp_action = erp_action;

		/* start QDIO request for this FSF request */
		@@ -2957,7 +2961,7 @@ zfcp_fsf_open_unit_handler(struct zfcp_fsf_req *fsf_req)
		u16 subtable, rule, counter;
		u32 allowed, exclusive, readwrite;

		unit = fsf_req->data.open_unit.unit;
		unit = (struct zfcp_unit *) fsf_req->data;

		if (fsf_req->status & ZFCP_STATUS_FSFREQ_ERROR) {
		/* don't change unit status in our bookkeeping */
		@@ -3242,7 +3246,7 @@ zfcp_fsf_close_unit(struct zfcp_erp_action *erp_action)
		erp_action->port->handle;
		erp_action->fsf_req->qtcb->header.lun_handle = erp_action->unit->handle;
		atomic_set_mask(ZFCP_STATUS_COMMON_CLOSING, &erp_action->unit->status);
		erp_action->fsf_req->data.close_unit.unit = erp_action->unit;
		erp_action->fsf_req->data = (unsigned long) erp_action->unit;
		erp_action->fsf_req->erp_action = erp_action;

		/* start QDIO request for this FSF request */
		@@ -3281,7 +3285,7 @@ zfcp_fsf_close_unit_handler(struct zfcp_fsf_req *fsf_req)
		int retval = -EINVAL;
		struct zfcp_unit *unit;

		unit = fsf_req->data.close_unit.unit; /* restore unit */
		unit = (struct zfcp_unit *) fsf_req->data;

		if (fsf_req->status & ZFCP_STATUS_FSFREQ_ERROR) {
		/* don't change unit status in our bookkeeping */
		@@ -3436,21 +3440,14 @@ zfcp_fsf_send_fcp_command_task(struct zfcp_adapter *adapter,
		goto failed_req_create;
		}

		/*
		* associate FSF request with SCSI request
		* (need this for look up on abort)
		*/
		fsf_req->data.send_fcp_command_task.fsf_req = fsf_req;
		scsi_cmnd->host_scribble = (char *) &(fsf_req->data);
		zfcp_unit_get(unit);
		fsf_req->unit = unit;

		/*
		* associate SCSI command with FSF request
		* (need this for look up on normal command completion)
		*/
		fsf_req->data.send_fcp_command_task.scsi_cmnd = scsi_cmnd;
		fsf_req->data.send_fcp_command_task.start_jiffies = jiffies;
		fsf_req->data.send_fcp_command_task.unit = unit;
		ZFCP_LOG_DEBUG("unit=%p, fcp_lun=0x%016Lx\n", unit, unit->fcp_lun);
		/* associate FSF request with SCSI request (for look up on abort) */
		scsi_cmnd->host_scribble = (char *) fsf_req;

		/* associate SCSI command with FSF request */
		fsf_req->data = (unsigned long) scsi_cmnd;

		/* set handles of unit and its parent port in QTCB */
		fsf_req->qtcb->header.lun_handle = unit->handle;
		@@ -3584,6 +3581,7 @@ zfcp_fsf_send_fcp_command_task(struct zfcp_adapter *adapter,
		send_failed:
		no_fit:
		failed_scsi_cmnd:
		zfcp_unit_put(unit);
		zfcp_fsf_req_free(fsf_req);
		fsf_req = NULL;
		scsi_cmnd->host_scribble = NULL;
		@@ -3640,7 +3638,7 @@ zfcp_fsf_send_fcp_command_task_management(struct zfcp_adapter *adapter,
		* hold a pointer to the unit being target of this
		* task management request
		*/
		fsf_req->data.send_fcp_command_task_management.unit = unit;
		fsf_req->data = (unsigned long) unit;

		/* set FSF related fields in QTCB */
		fsf_req->qtcb->header.lun_handle = unit->handle;
		@@ -3706,9 +3704,9 @@ zfcp_fsf_send_fcp_command_handler(struct zfcp_fsf_req *fsf_req)
		header = &fsf_req->qtcb->header;

		if (unlikely(fsf_req->status & ZFCP_STATUS_FSFREQ_TASK_MANAGEMENT))
		unit = fsf_req->data.send_fcp_command_task_management.unit;
		unit = (struct zfcp_unit *) fsf_req->data;
		else
		unit = fsf_req->data.send_fcp_command_task.unit;
		unit = fsf_req->unit;

		if (unlikely(fsf_req->status & ZFCP_STATUS_FSFREQ_ERROR)) {
		/* go directly to calls of special handlers */
		@@ -3947,6 +3945,8 @@ zfcp_fsf_send_fcp_command_handler(struct zfcp_fsf_req *fsf_req)
		zfcp_fsf_send_fcp_command_task_management_handler(fsf_req);
		} else {
		retval = zfcp_fsf_send_fcp_command_task_handler(fsf_req);
		fsf_req->unit = NULL;
		zfcp_unit_put(unit);
		}
		return retval;
		}
		@@ -3970,10 +3970,10 @@ zfcp_fsf_send_fcp_command_task_handler(struct zfcp_fsf_req *fsf_req)
		u32 sns_len;
		char *fcp_rsp_info = zfcp_get_fcp_rsp_info_ptr(fcp_rsp_iu);
		unsigned long flags;
		struct zfcp_unit *unit = fsf_req->data.send_fcp_command_task.unit;
		struct zfcp_unit *unit = fsf_req->unit;

		read_lock_irqsave(&fsf_req->adapter->abort_lock, flags);
		scpnt = fsf_req->data.send_fcp_command_task.scsi_cmnd;
		scpnt = (struct scsi_cmnd *) fsf_req->data;
		if (unlikely(!scpnt)) {
		ZFCP_LOG_DEBUG
		("Command with fsf_req %p is not associated to "
		@@ -4198,8 +4198,7 @@ zfcp_fsf_send_fcp_command_task_management_handler(struct zfcp_fsf_req *fsf_req)
		struct fcp_rsp_iu fcp_rsp_iu = (struct fcp_rsp_iu )
		&(fsf_req->qtcb->bottom.io.fcp_rsp);
		char *fcp_rsp_info = zfcp_get_fcp_rsp_info_ptr(fcp_rsp_iu);
		struct zfcp_unit *unit =
		fsf_req->data.send_fcp_command_task_management.unit;
		struct zfcp_unit unit = (struct zfcp_unit ) fsf_req->data;

		del_timer(&fsf_req->adapter->scsi_er_timer);
		if (fsf_req->status & ZFCP_STATUS_FSFREQ_ERROR) {

drivers/s390/scsi/zfcp_scsi.c

+26 −152

Original line number	Diff line number	Diff line
		@@ -414,67 +414,37 @@ zfcp_port_lookup(struct zfcp_adapter *adapter, int channel, scsi_id_t id)
		return (struct zfcp_port *) NULL;
		}

		/*
		* function: zfcp_scsi_eh_abort_handler
		*
		* purpose: tries to abort the specified (timed out) SCSI command
		*
		* note: We do not need to care for a SCSI command which completes
		* normally but late during this abort routine runs.
		* We are allowed to return late commands to the SCSI stack.
		* It tracks the state of commands and will handle late commands.
		* (Usually, the normal completion of late commands is ignored with
		* respect to the running abort operation. Grep for 'done_late'
		* in the SCSI stacks sources.)
		*
		* returns: SUCCESS - command has been aborted and cleaned up in internal
		* bookkeeping,
		* SCSI stack won't be called for aborted command
		/**
		* zfcp_scsi_eh_abort_handler - abort the specified SCSI command
		* @scpnt: pointer to scsi_cmnd to be aborted
		* Return: SUCCESS - command has been aborted and cleaned up in internal
		* bookkeeping, SCSI stack won't be called for aborted command
		* FAILED - otherwise
		*
		* We do not need to care for a SCSI command which completes normally
		* but late during this abort routine runs. We are allowed to return
		* late commands to the SCSI stack. It tracks the state of commands and
		* will handle late commands. (Usually, the normal completion of late
		* commands is ignored with respect to the running abort operation.)
		*/
		int
		__zfcp_scsi_eh_abort_handler(struct scsi_cmnd *scpnt)
		zfcp_scsi_eh_abort_handler(struct scsi_cmnd *scpnt)
		{
		struct Scsi_Host *scsi_host;
		struct zfcp_adapter *adapter;
		struct zfcp_unit *unit;
		int retval = SUCCESS;
		struct zfcp_fsf_req new_fsf_req, old_fsf_req;
		struct zfcp_adapter adapter = (struct zfcp_adapter ) scpnt->device->host->hostdata[0];
		struct zfcp_unit unit = (struct zfcp_unit ) scpnt->device->hostdata;
		struct zfcp_port *port = unit->port;
		struct Scsi_Host *scsi_host = scpnt->device->host;
		union zfcp_req_data *req_data = NULL;
		unsigned long flags;
		u32 status = 0;

		/* the components of a abort_dbf record (fixed size record) */
		u64 dbf_scsi_cmnd = (unsigned long) scpnt;
		char dbf_opcode[ZFCP_ABORT_DBF_LENGTH];
		wwn_t dbf_wwn = port->wwpn;
		fcp_lun_t dbf_fcp_lun = unit->fcp_lun;
		u64 dbf_retries = scpnt->retries;
		u64 dbf_allowed = scpnt->allowed;
		u64 dbf_timeout = 0;
		u64 dbf_fsf_req = 0;
		u64 dbf_fsf_status = 0;
		u64 dbf_fsf_qual[2] = { 0, 0 };
		char dbf_result[ZFCP_ABORT_DBF_LENGTH] = "##undef";

		memset(dbf_opcode, 0, ZFCP_ABORT_DBF_LENGTH);
		memcpy(dbf_opcode,
		scpnt->cmnd,
		min(scpnt->cmd_len, (unsigned char) ZFCP_ABORT_DBF_LENGTH));

		scsi_host = scpnt->device->host;
		adapter = (struct zfcp_adapter *) scsi_host->hostdata[0];
		unit = (struct zfcp_unit *) scpnt->device->hostdata;

		ZFCP_LOG_INFO("aborting scsi_cmnd=%p on adapter %s\n",
		scpnt, zfcp_get_busid_by_adapter(adapter));

		spin_unlock_irq(scsi_host->host_lock);

		/*
		* Race condition between normal (late) completion and abort has
		* to be avoided.
		* The entirity of all accesses to scsi_req have to be atomic.
		* scsi_req is usually part of the fsf_req and thus we block the
		* release of fsf_req as long as we need to access scsi_req.
		*/
		/* avoid race condition between late normal completion and abort */
		write_lock_irqsave(&adapter->abort_lock, flags);

		/*
		@@ -484,144 +454,48 @@ __zfcp_scsi_eh_abort_handler(struct scsi_cmnd *scpnt)
		* this routine returns. (scpnt is parameter passed to this routine
		* and must not disappear during abort even on late completion.)
		*/
		req_data = (union zfcp_req_data *) scpnt->host_scribble;
		/* DEBUG */
		ZFCP_LOG_DEBUG("req_data=%p\n", req_data);
		if (!req_data) {
		ZFCP_LOG_DEBUG("late command completion overtook abort\n");
		/*
		* That's it.
		* Do not initiate abort but return SUCCESS.
		*/
		write_unlock_irqrestore(&adapter->abort_lock, flags);
		retval = SUCCESS;
		strncpy(dbf_result, "##late1", ZFCP_ABORT_DBF_LENGTH);
		goto out;
		}

		/* Figure out which fsf_req needs to be aborted. */
		old_fsf_req = req_data->send_fcp_command_task.fsf_req;

		dbf_fsf_req = (unsigned long) old_fsf_req;
		dbf_timeout =
		(jiffies - req_data->send_fcp_command_task.start_jiffies) / HZ;

		ZFCP_LOG_DEBUG("old_fsf_req=%p\n", old_fsf_req);
		old_fsf_req = (struct zfcp_fsf_req *) scpnt->host_scribble;
		if (!old_fsf_req) {
		write_unlock_irqrestore(&adapter->abort_lock, flags);
		ZFCP_LOG_NORMAL("bug: no old fsf request found\n");
		ZFCP_LOG_NORMAL("req_data:\n");
		ZFCP_HEX_DUMP(ZFCP_LOG_LEVEL_NORMAL,
		(char *) req_data, sizeof (union zfcp_req_data));
		ZFCP_LOG_NORMAL("scsi_cmnd:\n");
		ZFCP_HEX_DUMP(ZFCP_LOG_LEVEL_NORMAL,
		(char *) scpnt, sizeof (struct scsi_cmnd));
		retval = FAILED;
		strncpy(dbf_result, "##bug:r", ZFCP_ABORT_DBF_LENGTH);
		goto out;
		}
		old_fsf_req->data.send_fcp_command_task.scsi_cmnd = NULL;
		/* mark old request as being aborted */
		old_fsf_req->data = 0;
		old_fsf_req->status \|= ZFCP_STATUS_FSFREQ_ABORTING;
		/*
		* We have to collect all information (e.g. unit) needed by
		* zfcp_fsf_abort_fcp_command before calling that routine
		* since that routine is not allowed to access
		* fsf_req which it is going to abort.
		* This is because of we need to release fsf_req_list_lock
		* before calling zfcp_fsf_abort_fcp_command.
		* Since this lock will not be held, fsf_req may complete
		* late and may be released meanwhile.
		*/
		ZFCP_LOG_DEBUG("unit 0x%016Lx (%p)\n", unit->fcp_lun, unit);

		/*
		* We block (call schedule)
		* That's why we must release the lock and enable the
		* interrupts before.
		* On the other hand we do not need the lock anymore since
		* all critical accesses to scsi_req are done.
		*/
		/* don't access old_fsf_req after releasing the abort_lock */
		write_unlock_irqrestore(&adapter->abort_lock, flags);
		/* call FSF routine which does the abort */
		new_fsf_req = zfcp_fsf_abort_fcp_command((unsigned long) old_fsf_req,
		adapter, unit, 0);
		ZFCP_LOG_DEBUG("new_fsf_req=%p\n", new_fsf_req);
		if (!new_fsf_req) {
		retval = FAILED;
		ZFCP_LOG_NORMAL("error: initiation of Abort FCP Cmnd "
		"failed\n");
		strncpy(dbf_result, "##nores", ZFCP_ABORT_DBF_LENGTH);
		goto out;
		}

		/* wait for completion of abort */
		ZFCP_LOG_DEBUG("waiting for cleanup...\n");
		#if 1
		/*
		* FIXME:
		* copying zfcp_fsf_req_wait_and_cleanup code is not really nice
		*/
		__wait_event(new_fsf_req->completion_wq,
		new_fsf_req->status & ZFCP_STATUS_FSFREQ_COMPLETED);
		status = new_fsf_req->status;
		dbf_fsf_status = new_fsf_req->qtcb->header.fsf_status;
		/*
		* Ralphs special debug load provides timestamps in the FSF
		* status qualifier. This might be specified later if being
		* useful for debugging aborts.
		*/
		dbf_fsf_qual[0] =
		(u64 ) & new_fsf_req->qtcb->header.fsf_status_qual.word[0];
		dbf_fsf_qual[1] =
		(u64 ) & new_fsf_req->qtcb->header.fsf_status_qual.word[2];
		zfcp_fsf_req_free(new_fsf_req);
		#else
		retval = zfcp_fsf_req_wait_and_cleanup(new_fsf_req,
		ZFCP_UNINTERRUPTIBLE, &status);
		#endif
		ZFCP_LOG_DEBUG("Waiting for cleanup complete, status=0x%x\n", status);

		/* status should be valid since signals were not permitted */
		if (status & ZFCP_STATUS_FSFREQ_ABORTSUCCEEDED) {
		if (new_fsf_req->status & ZFCP_STATUS_FSFREQ_ABORTSUCCEEDED) {
		retval = SUCCESS;
		strncpy(dbf_result, "##succ", ZFCP_ABORT_DBF_LENGTH);
		} else if (status & ZFCP_STATUS_FSFREQ_ABORTNOTNEEDED) {
		} else if (new_fsf_req->status & ZFCP_STATUS_FSFREQ_ABORTNOTNEEDED) {
		retval = SUCCESS;
		strncpy(dbf_result, "##late2", ZFCP_ABORT_DBF_LENGTH);
		} else {
		retval = FAILED;
		strncpy(dbf_result, "##fail", ZFCP_ABORT_DBF_LENGTH);
		}

		out:
		debug_event(adapter->abort_dbf, 1, &dbf_scsi_cmnd, sizeof (u64));
		debug_event(adapter->abort_dbf, 1, &dbf_opcode, ZFCP_ABORT_DBF_LENGTH);
		debug_event(adapter->abort_dbf, 1, &dbf_wwn, sizeof (wwn_t));
		debug_event(adapter->abort_dbf, 1, &dbf_fcp_lun, sizeof (fcp_lun_t));
		debug_event(adapter->abort_dbf, 1, &dbf_retries, sizeof (u64));
		debug_event(adapter->abort_dbf, 1, &dbf_allowed, sizeof (u64));
		debug_event(adapter->abort_dbf, 1, &dbf_timeout, sizeof (u64));
		debug_event(adapter->abort_dbf, 1, &dbf_fsf_req, sizeof (u64));
		debug_event(adapter->abort_dbf, 1, &dbf_fsf_status, sizeof (u64));
		debug_event(adapter->abort_dbf, 1, &dbf_fsf_qual[0], sizeof (u64));
		debug_event(adapter->abort_dbf, 1, &dbf_fsf_qual[1], sizeof (u64));
		debug_text_event(adapter->abort_dbf, 1, dbf_result);

		spin_lock_irq(scsi_host->host_lock);
		return retval;
		}

		int
		zfcp_scsi_eh_abort_handler(struct scsi_cmnd *scpnt)
		{
		int rc;
		struct Scsi_Host *scsi_host = scpnt->device->host;
		spin_lock_irq(scsi_host->host_lock);
		rc = __zfcp_scsi_eh_abort_handler(scpnt);
		spin_unlock_irq(scsi_host->host_lock);
		return rc;
		}

		/*
		* function: zfcp_scsi_eh_device_reset_handler
		*

Admin message