Linux-2.6.12-rc2
Initial git repository build. I'm not bothering with the full history,
even though we have it. We can create a separate "historical" git
archive of that later if we want to, and in the meantime it's about
3.2GB when imported into git - space that would just make the early
git days unnecessarily complicated, when we don't have a lot of good
infrastructure for it.
Let it rip!
diff --git a/drivers/s390/scsi/Makefile b/drivers/s390/scsi/Makefile
new file mode 100644
index 0000000..fc14530
--- /dev/null
+++ b/drivers/s390/scsi/Makefile
@@ -0,0 +1,9 @@
+#
+# Makefile for the S/390 specific device drivers
+#
+
+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_sysfs_unit.o zfcp_sysfs_driver.o
+
+obj-$(CONFIG_ZFCP) += zfcp.o
diff --git a/drivers/s390/scsi/zfcp_aux.c b/drivers/s390/scsi/zfcp_aux.c
new file mode 100644
index 0000000..6a43322
--- /dev/null
+++ b/drivers/s390/scsi/zfcp_aux.c
@@ -0,0 +1,1977 @@
+/*
+ *
+ * linux/drivers/s390/scsi/zfcp_aux.c
+ *
+ * FCP adapter driver for IBM eServer zSeries
+ *
+ * (C) Copyright IBM Corp. 2002, 2004
+ *
+ * Author(s): Martin Peschke <mpeschke@de.ibm.com>
+ * Raimund Schroeder <raimund.schroeder@de.ibm.com>
+ * Aron Zeh
+ * Wolfgang Taphorn
+ * Stefan Bader <stefan.bader@de.ibm.com>
+ * Heiko Carstens <heiko.carstens@de.ibm.com>
+ * Andreas Herrmann <aherrman@de.ibm.com>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2, or (at your option)
+ * any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#define ZFCP_AUX_REVISION "$Revision: 1.145 $"
+
+#include "zfcp_ext.h"
+
+/* accumulated log level (module parameter) */
+static u32 loglevel = ZFCP_LOG_LEVEL_DEFAULTS;
+static char *device;
+/*********************** FUNCTION PROTOTYPES *********************************/
+
+/* written against the module interface */
+static int __init zfcp_module_init(void);
+
+/* FCP related */
+static void zfcp_ns_gid_pn_handler(unsigned long);
+
+/* miscellaneous */
+static inline int zfcp_sg_list_alloc(struct zfcp_sg_list *, size_t);
+static inline void zfcp_sg_list_free(struct zfcp_sg_list *);
+static inline int zfcp_sg_list_copy_from_user(struct zfcp_sg_list *,
+ void __user *, size_t);
+static inline int zfcp_sg_list_copy_to_user(void __user *,
+ struct zfcp_sg_list *, size_t);
+
+static int zfcp_cfdc_dev_ioctl(struct inode *, struct file *,
+ unsigned int, unsigned long);
+
+#define ZFCP_CFDC_IOC_MAGIC 0xDD
+#define ZFCP_CFDC_IOC \
+ _IOWR(ZFCP_CFDC_IOC_MAGIC, 0, struct zfcp_cfdc_sense_data)
+
+#ifdef CONFIG_COMPAT
+static struct ioctl_trans zfcp_ioctl_trans = {ZFCP_CFDC_IOC, (void*) sys_ioctl};
+#endif
+
+static struct file_operations zfcp_cfdc_fops = {
+ .ioctl = zfcp_cfdc_dev_ioctl
+};
+
+static struct miscdevice zfcp_cfdc_misc = {
+ .minor = ZFCP_CFDC_DEV_MINOR,
+ .name = ZFCP_CFDC_DEV_NAME,
+ .fops = &zfcp_cfdc_fops
+};
+
+/*********************** KERNEL/MODULE PARAMETERS ***************************/
+
+/* declare driver module init/cleanup functions */
+module_init(zfcp_module_init);
+
+MODULE_AUTHOR("Heiko Carstens <heiko.carstens@de.ibm.com>, "
+ "Andreas Herrman <aherrman@de.ibm.com>, "
+ "Martin Peschke <mpeschke@de.ibm.com>, "
+ "Raimund Schroeder <raimund.schroeder@de.ibm.com>, "
+ "Wolfgang Taphorn <taphorn@de.ibm.com>, "
+ "Aron Zeh <arzeh@de.ibm.com>, "
+ "IBM Deutschland Entwicklung GmbH");
+MODULE_DESCRIPTION
+ ("FCP (SCSI over Fibre Channel) HBA driver for IBM eServer zSeries");
+MODULE_LICENSE("GPL");
+
+module_param(device, charp, 0);
+MODULE_PARM_DESC(device, "specify initial device");
+
+module_param(loglevel, uint, 0);
+MODULE_PARM_DESC(loglevel,
+ "log levels, 8 nibbles: "
+ "FC ERP QDIO CIO Config FSF SCSI Other, "
+ "levels: 0=none 1=normal 2=devel 3=trace");
+
+#ifdef ZFCP_PRINT_FLAGS
+u32 flags_dump = 0;
+module_param(flags_dump, uint, 0);
+#endif
+
+/****************************************************************/
+/************** Functions without logging ***********************/
+/****************************************************************/
+
+void
+_zfcp_hex_dump(char *addr, int count)
+{
+ int i;
+ for (i = 0; i < count; i++) {
+ printk("%02x", addr[i]);
+ if ((i % 4) == 3)
+ printk(" ");
+ if ((i % 32) == 31)
+ printk("\n");
+ }
+ if (((i-1) % 32) != 31)
+ printk("\n");
+}
+
+/****************************************************************/
+/************** Uncategorised Functions *************************/
+/****************************************************************/
+
+#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 = fsf_req->data.send_fcp_command_task.scsi_cmnd;
+ 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;
+ 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);
+ 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
+ *
+ * Parse "device=..." parameter string.
+ */
+static int __init
+zfcp_device_setup(char *str)
+{
+ char *tmp;
+
+ if (!str)
+ return 0;
+
+ tmp = strchr(str, ',');
+ if (!tmp)
+ goto err_out;
+ *tmp++ = '\0';
+ strncpy(zfcp_data.init_busid, str, BUS_ID_SIZE);
+ zfcp_data.init_busid[BUS_ID_SIZE-1] = '\0';
+
+ zfcp_data.init_wwpn = simple_strtoull(tmp, &tmp, 0);
+ if (*tmp++ != ',')
+ goto err_out;
+ if (*tmp == '\0')
+ goto err_out;
+
+ zfcp_data.init_fcp_lun = simple_strtoull(tmp, &tmp, 0);
+ if (*tmp != '\0')
+ goto err_out;
+ return 1;
+
+ err_out:
+ ZFCP_LOG_NORMAL("Parse error for device parameter string %s\n", str);
+ return 0;
+}
+
+static void __init
+zfcp_init_device_configure(void)
+{
+ struct zfcp_adapter *adapter;
+ struct zfcp_port *port;
+ struct zfcp_unit *unit;
+
+ down(&zfcp_data.config_sema);
+ read_lock_irq(&zfcp_data.config_lock);
+ adapter = zfcp_get_adapter_by_busid(zfcp_data.init_busid);
+ if (adapter)
+ zfcp_adapter_get(adapter);
+ read_unlock_irq(&zfcp_data.config_lock);
+
+ if (adapter == NULL)
+ goto out_adapter;
+ port = zfcp_port_enqueue(adapter, zfcp_data.init_wwpn, 0, 0);
+ if (!port)
+ goto out_port;
+ unit = zfcp_unit_enqueue(port, zfcp_data.init_fcp_lun);
+ if (!unit)
+ goto out_unit;
+ up(&zfcp_data.config_sema);
+ ccw_device_set_online(adapter->ccw_device);
+ zfcp_erp_wait(adapter);
+ down(&zfcp_data.config_sema);
+ zfcp_unit_put(unit);
+ out_unit:
+ zfcp_port_put(port);
+ out_port:
+ zfcp_adapter_put(adapter);
+ out_adapter:
+ up(&zfcp_data.config_sema);
+ return;
+}
+
+static int __init
+zfcp_module_init(void)
+{
+
+ int retval = 0;
+
+ atomic_set(&zfcp_data.loglevel, loglevel);
+
+ /* initialize adapter list */
+ INIT_LIST_HEAD(&zfcp_data.adapter_list_head);
+
+ /* initialize adapters to be removed list head */
+ INIT_LIST_HEAD(&zfcp_data.adapter_remove_lh);
+
+ zfcp_transport_template = fc_attach_transport(&zfcp_transport_functions);
+ if (!zfcp_transport_template)
+ return -ENODEV;
+
+ retval = register_ioctl32_conversion(zfcp_ioctl_trans.cmd,
+ zfcp_ioctl_trans.handler);
+ if (retval != 0) {
+ ZFCP_LOG_INFO("registration of ioctl32 conversion failed\n");
+ goto out;
+ }
+
+ retval = misc_register(&zfcp_cfdc_misc);
+ if (retval != 0) {
+ ZFCP_LOG_INFO("registration of misc device "
+ "zfcp_cfdc failed\n");
+ goto out_misc_register;
+ } else {
+ ZFCP_LOG_TRACE("major/minor for zfcp_cfdc: %d/%d\n",
+ ZFCP_CFDC_DEV_MAJOR, zfcp_cfdc_misc.minor);
+ }
+
+ /* Initialise proc semaphores */
+ sema_init(&zfcp_data.config_sema, 1);
+
+ /* initialise configuration rw lock */
+ rwlock_init(&zfcp_data.config_lock);
+
+ /* save address of data structure managing the driver module */
+ zfcp_data.scsi_host_template.module = THIS_MODULE;
+
+ /* setup dynamic I/O */
+ retval = zfcp_ccw_register();
+ if (retval) {
+ ZFCP_LOG_NORMAL("registration with common I/O layer failed\n");
+ goto out_ccw_register;
+ }
+
+ if (zfcp_device_setup(device))
+ zfcp_init_device_configure();
+
+ goto out;
+
+ out_ccw_register:
+ misc_deregister(&zfcp_cfdc_misc);
+ out_misc_register:
+ unregister_ioctl32_conversion(zfcp_ioctl_trans.cmd);
+ out:
+ return retval;
+}
+
+/*
+ * function: zfcp_cfdc_dev_ioctl
+ *
+ * purpose: Handle control file upload/download transaction via IOCTL
+ * interface
+ *
+ * returns: 0 - Operation completed successfuly
+ * -ENOTTY - Unknown IOCTL command
+ * -EINVAL - Invalid sense data record
+ * -ENXIO - The FCP adapter is not available
+ * -EOPNOTSUPP - The FCP adapter does not have CFDC support
+ * -ENOMEM - Insufficient memory
+ * -EFAULT - User space memory I/O operation fault
+ * -EPERM - Cannot create or queue FSF request or create SBALs
+ * -ERESTARTSYS- Received signal (is mapped to EAGAIN by VFS)
+ */
+static int
+zfcp_cfdc_dev_ioctl(struct inode *inode, struct file *file,
+ unsigned int command, unsigned long buffer)
+{
+ struct zfcp_cfdc_sense_data *sense_data, __user *sense_data_user;
+ struct zfcp_adapter *adapter = NULL;
+ struct zfcp_fsf_req *fsf_req = NULL;
+ struct zfcp_sg_list *sg_list = NULL;
+ u32 fsf_command, option;
+ char *bus_id = NULL;
+ int retval = 0;
+
+ sense_data = kmalloc(sizeof(struct zfcp_cfdc_sense_data), GFP_KERNEL);
+ if (sense_data == NULL) {
+ retval = -ENOMEM;
+ goto out;
+ }
+
+ sg_list = kmalloc(sizeof(struct zfcp_sg_list), GFP_KERNEL);
+ if (sg_list == NULL) {
+ retval = -ENOMEM;
+ goto out;
+ }
+ memset(sg_list, 0, sizeof(*sg_list));
+
+ if (command != ZFCP_CFDC_IOC) {
+ ZFCP_LOG_INFO("IOC request code 0x%x invalid\n", command);
+ retval = -ENOTTY;
+ goto out;
+ }
+
+ if ((sense_data_user = (void __user *) buffer) == NULL) {
+ ZFCP_LOG_INFO("sense data record is required\n");
+ retval = -EINVAL;
+ goto out;
+ }
+
+ retval = copy_from_user(sense_data, sense_data_user,
+ sizeof(struct zfcp_cfdc_sense_data));
+ if (retval) {
+ retval = -EFAULT;
+ goto out;
+ }
+
+ if (sense_data->signature != ZFCP_CFDC_SIGNATURE) {
+ ZFCP_LOG_INFO("invalid sense data request signature 0x%08x\n",
+ ZFCP_CFDC_SIGNATURE);
+ retval = -EINVAL;
+ goto out;
+ }
+
+ switch (sense_data->command) {
+
+ case ZFCP_CFDC_CMND_DOWNLOAD_NORMAL:
+ fsf_command = FSF_QTCB_DOWNLOAD_CONTROL_FILE;
+ option = FSF_CFDC_OPTION_NORMAL_MODE;
+ break;
+
+ case ZFCP_CFDC_CMND_DOWNLOAD_FORCE:
+ fsf_command = FSF_QTCB_DOWNLOAD_CONTROL_FILE;
+ option = FSF_CFDC_OPTION_FORCE;
+ break;
+
+ case ZFCP_CFDC_CMND_FULL_ACCESS:
+ fsf_command = FSF_QTCB_DOWNLOAD_CONTROL_FILE;
+ option = FSF_CFDC_OPTION_FULL_ACCESS;
+ break;
+
+ case ZFCP_CFDC_CMND_RESTRICTED_ACCESS:
+ fsf_command = FSF_QTCB_DOWNLOAD_CONTROL_FILE;
+ option = FSF_CFDC_OPTION_RESTRICTED_ACCESS;
+ break;
+
+ case ZFCP_CFDC_CMND_UPLOAD:
+ fsf_command = FSF_QTCB_UPLOAD_CONTROL_FILE;
+ option = 0;
+ break;
+
+ default:
+ ZFCP_LOG_INFO("invalid command code 0x%08x\n",
+ sense_data->command);
+ retval = -EINVAL;
+ goto out;
+ }
+
+ bus_id = kmalloc(BUS_ID_SIZE, GFP_KERNEL);
+ if (bus_id == NULL) {
+ retval = -ENOMEM;
+ goto out;
+ }
+ snprintf(bus_id, BUS_ID_SIZE, "%d.%d.%04x",
+ (sense_data->devno >> 24),
+ (sense_data->devno >> 16) & 0xFF,
+ (sense_data->devno & 0xFFFF));
+
+ read_lock_irq(&zfcp_data.config_lock);
+ adapter = zfcp_get_adapter_by_busid(bus_id);
+ if (adapter)
+ zfcp_adapter_get(adapter);
+ read_unlock_irq(&zfcp_data.config_lock);
+
+ kfree(bus_id);
+
+ if (adapter == NULL) {
+ ZFCP_LOG_INFO("invalid adapter\n");
+ retval = -ENXIO;
+ goto out;
+ }
+
+ if (sense_data->command & ZFCP_CFDC_WITH_CONTROL_FILE) {
+ retval = zfcp_sg_list_alloc(sg_list,
+ ZFCP_CFDC_MAX_CONTROL_FILE_SIZE);
+ if (retval) {
+ retval = -ENOMEM;
+ goto out;
+ }
+ }
+
+ if ((sense_data->command & ZFCP_CFDC_DOWNLOAD) &&
+ (sense_data->command & ZFCP_CFDC_WITH_CONTROL_FILE)) {
+ retval = zfcp_sg_list_copy_from_user(
+ sg_list, &sense_data_user->control_file,
+ ZFCP_CFDC_MAX_CONTROL_FILE_SIZE);
+ if (retval) {
+ retval = -EFAULT;
+ goto out;
+ }
+ }
+
+ retval = zfcp_fsf_control_file(adapter, &fsf_req, fsf_command,
+ option, sg_list);
+ if (retval)
+ goto out;
+
+ if ((fsf_req->qtcb->prefix.prot_status != FSF_PROT_GOOD) &&
+ (fsf_req->qtcb->prefix.prot_status != FSF_PROT_FSF_STATUS_PRESENTED)) {
+ retval = -ENXIO;
+ goto out;
+ }
+
+ sense_data->fsf_status = fsf_req->qtcb->header.fsf_status;
+ memcpy(&sense_data->fsf_status_qual,
+ &fsf_req->qtcb->header.fsf_status_qual,
+ sizeof(union fsf_status_qual));
+ memcpy(&sense_data->payloads, &fsf_req->qtcb->bottom.support.els, 256);
+
+ retval = copy_to_user(sense_data_user, sense_data,
+ sizeof(struct zfcp_cfdc_sense_data));
+ if (retval) {
+ retval = -EFAULT;
+ goto out;
+ }
+
+ if (sense_data->command & ZFCP_CFDC_UPLOAD) {
+ retval = zfcp_sg_list_copy_to_user(
+ &sense_data_user->control_file, sg_list,
+ ZFCP_CFDC_MAX_CONTROL_FILE_SIZE);
+ if (retval) {
+ retval = -EFAULT;
+ goto out;
+ }
+ }
+
+ out:
+ if (fsf_req != NULL)
+ zfcp_fsf_req_cleanup(fsf_req);
+
+ if ((adapter != NULL) && (retval != -ENXIO))
+ zfcp_adapter_put(adapter);
+
+ if (sg_list != NULL) {
+ zfcp_sg_list_free(sg_list);
+ kfree(sg_list);
+ }
+
+ if (sense_data != NULL)
+ kfree(sense_data);
+
+ return retval;
+}
+
+
+/**
+ * zfcp_sg_list_alloc - create a scatter-gather list of the specified size
+ * @sg_list: structure describing a scatter gather list
+ * @size: size of scatter-gather list
+ * Return: 0 on success, else -ENOMEM
+ *
+ * In sg_list->sg a pointer to the created scatter-gather list is returned,
+ * or NULL if we run out of memory. sg_list->count specifies the number of
+ * elements of the scatter-gather list. The maximum size of a single element
+ * in the scatter-gather list is PAGE_SIZE.
+ */
+static inline int
+zfcp_sg_list_alloc(struct zfcp_sg_list *sg_list, size_t size)
+{
+ struct scatterlist *sg;
+ unsigned int i;
+ int retval = 0;
+ void *address;
+
+ BUG_ON(sg_list == NULL);
+
+ sg_list->count = size >> PAGE_SHIFT;
+ if (size & ~PAGE_MASK)
+ sg_list->count++;
+ sg_list->sg = kmalloc(sg_list->count * sizeof(struct scatterlist),
+ GFP_KERNEL);
+ if (sg_list->sg == NULL) {
+ sg_list->count = 0;
+ retval = -ENOMEM;
+ goto out;
+ }
+ memset(sg_list->sg, 0, sg_list->count * sizeof(struct scatterlist));
+
+ for (i = 0, sg = sg_list->sg; i < sg_list->count; i++, sg++) {
+ sg->length = min(size, PAGE_SIZE);
+ sg->offset = 0;
+ address = (void *) get_zeroed_page(GFP_KERNEL);
+ if (address == NULL) {
+ sg_list->count = i;
+ zfcp_sg_list_free(sg_list);
+ retval = -ENOMEM;
+ goto out;
+ }
+ zfcp_address_to_sg(address, sg);
+ size -= sg->length;
+ }
+
+ out:
+ return retval;
+}
+
+
+/**
+ * zfcp_sg_list_free - free memory of a scatter-gather list
+ * @sg_list: structure describing a scatter-gather list
+ *
+ * Memory for each element in the scatter-gather list is freed.
+ * Finally sg_list->sg is freed itself and sg_list->count is reset.
+ */
+static inline void
+zfcp_sg_list_free(struct zfcp_sg_list *sg_list)
+{
+ struct scatterlist *sg;
+ unsigned int i;
+
+ BUG_ON(sg_list == NULL);
+
+ for (i = 0, sg = sg_list->sg; i < sg_list->count; i++, sg++)
+ free_page((unsigned long) zfcp_sg_to_address(sg));
+
+ sg_list->count = 0;
+ kfree(sg_list->sg);
+}
+
+/**
+ * zfcp_sg_size - determine size of a scatter-gather list
+ * @sg: array of (struct scatterlist)
+ * @sg_count: elements in array
+ * Return: size of entire scatter-gather list
+ */
+size_t
+zfcp_sg_size(struct scatterlist *sg, unsigned int sg_count)
+{
+ unsigned int i;
+ struct scatterlist *p;
+ size_t size;
+
+ size = 0;
+ for (i = 0, p = sg; i < sg_count; i++, p++) {
+ BUG_ON(p == NULL);
+ size += p->length;
+ }
+
+ return size;
+}
+
+
+/**
+ * zfcp_sg_list_copy_from_user -copy data from user space to scatter-gather list
+ * @sg_list: structure describing a scatter-gather list
+ * @user_buffer: pointer to buffer in user space
+ * @size: number of bytes to be copied
+ * Return: 0 on success, -EFAULT if copy_from_user fails.
+ */
+static inline int
+zfcp_sg_list_copy_from_user(struct zfcp_sg_list *sg_list,
+ void __user *user_buffer,
+ size_t size)
+{
+ struct scatterlist *sg;
+ unsigned int length;
+ void *zfcp_buffer;
+ int retval = 0;
+
+ BUG_ON(sg_list == NULL);
+
+ if (zfcp_sg_size(sg_list->sg, sg_list->count) < size)
+ return -EFAULT;
+
+ for (sg = sg_list->sg; size > 0; sg++) {
+ length = min((unsigned int)size, sg->length);
+ zfcp_buffer = zfcp_sg_to_address(sg);
+ if (copy_from_user(zfcp_buffer, user_buffer, length)) {
+ retval = -EFAULT;
+ goto out;
+ }
+ user_buffer += length;
+ size -= length;
+ }
+
+ out:
+ return retval;
+}
+
+
+/**
+ * zfcp_sg_list_copy_to_user - copy data from scatter-gather list to user space
+ * @user_buffer: pointer to buffer in user space
+ * @sg_list: structure describing a scatter-gather list
+ * @size: number of bytes to be copied
+ * Return: 0 on success, -EFAULT if copy_to_user fails
+ */
+static inline int
+zfcp_sg_list_copy_to_user(void __user *user_buffer,
+ struct zfcp_sg_list *sg_list,
+ size_t size)
+{
+ struct scatterlist *sg;
+ unsigned int length;
+ void *zfcp_buffer;
+ int retval = 0;
+
+ BUG_ON(sg_list == NULL);
+
+ if (zfcp_sg_size(sg_list->sg, sg_list->count) < size)
+ return -EFAULT;
+
+ for (sg = sg_list->sg; size > 0; sg++) {
+ length = min((unsigned int) size, sg->length);
+ zfcp_buffer = zfcp_sg_to_address(sg);
+ if (copy_to_user(user_buffer, zfcp_buffer, length)) {
+ retval = -EFAULT;
+ goto out;
+ }
+ user_buffer += length;
+ size -= length;
+ }
+
+ out:
+ return retval;
+}
+
+
+#undef ZFCP_LOG_AREA
+
+/****************************************************************/
+/****** Functions for configuration/set-up of structures ********/
+/****************************************************************/
+
+#define ZFCP_LOG_AREA ZFCP_LOG_AREA_CONFIG
+
+/**
+ * zfcp_get_unit_by_lun - find unit in unit list of port by FCP LUN
+ * @port: pointer to port to search for unit
+ * @fcp_lun: FCP LUN to search for
+ * Traverse list of all units of a port and return pointer to a unit
+ * with the given FCP LUN.
+ */
+struct zfcp_unit *
+zfcp_get_unit_by_lun(struct zfcp_port *port, fcp_lun_t fcp_lun)
+{
+ struct zfcp_unit *unit;
+ int found = 0;
+
+ list_for_each_entry(unit, &port->unit_list_head, list) {
+ if ((unit->fcp_lun == fcp_lun) &&
+ !atomic_test_mask(ZFCP_STATUS_COMMON_REMOVE, &unit->status))
+ {
+ found = 1;
+ break;
+ }
+ }
+ return found ? unit : NULL;
+}
+
+/**
+ * zfcp_get_port_by_wwpn - find port in port list of adapter by wwpn
+ * @adapter: pointer to adapter to search for port
+ * @wwpn: wwpn to search for
+ * Traverse list of all ports of an adapter and return pointer to a port
+ * with the given wwpn.
+ */
+struct zfcp_port *
+zfcp_get_port_by_wwpn(struct zfcp_adapter *adapter, wwn_t wwpn)
+{
+ struct zfcp_port *port;
+ int found = 0;
+
+ list_for_each_entry(port, &adapter->port_list_head, list) {
+ if ((port->wwpn == wwpn) &&
+ !(atomic_read(&port->status) &
+ (ZFCP_STATUS_PORT_NO_WWPN | ZFCP_STATUS_COMMON_REMOVE))) {
+ found = 1;
+ break;
+ }
+ }
+ return found ? port : NULL;
+}
+
+/**
+ * zfcp_get_port_by_did - find port in port list of adapter by d_id
+ * @adapter: pointer to adapter to search for port
+ * @d_id: d_id to search for
+ * Traverse list of all ports of an adapter and return pointer to a port
+ * with the given d_id.
+ */
+struct zfcp_port *
+zfcp_get_port_by_did(struct zfcp_adapter *adapter, u32 d_id)
+{
+ struct zfcp_port *port;
+ int found = 0;
+
+ list_for_each_entry(port, &adapter->port_list_head, list) {
+ if ((port->d_id == d_id) &&
+ !atomic_test_mask(ZFCP_STATUS_COMMON_REMOVE, &port->status))
+ {
+ found = 1;
+ break;
+ }
+ }
+ return found ? port : NULL;
+}
+
+/**
+ * zfcp_get_adapter_by_busid - find adpater in adapter list by bus_id
+ * @bus_id: bus_id to search for
+ * Traverse list of all adapters and return pointer to an adapter
+ * with the given bus_id.
+ */
+struct zfcp_adapter *
+zfcp_get_adapter_by_busid(char *bus_id)
+{
+ struct zfcp_adapter *adapter;
+ int found = 0;
+
+ list_for_each_entry(adapter, &zfcp_data.adapter_list_head, list) {
+ if ((strncmp(bus_id, zfcp_get_busid_by_adapter(adapter),
+ BUS_ID_SIZE) == 0) &&
+ !atomic_test_mask(ZFCP_STATUS_COMMON_REMOVE,
+ &adapter->status)){
+ found = 1;
+ break;
+ }
+ }
+ return found ? adapter : NULL;
+}
+
+/**
+ * zfcp_unit_enqueue - enqueue unit to unit list of a port.
+ * @port: pointer to port where unit is added
+ * @fcp_lun: FCP LUN of unit to be enqueued
+ * Return: pointer to enqueued unit on success, NULL on error
+ * Locks: config_sema must be held to serialize changes to the unit list
+ *
+ * Sets up some unit internal structures and creates sysfs entry.
+ */
+struct zfcp_unit *
+zfcp_unit_enqueue(struct zfcp_port *port, fcp_lun_t fcp_lun)
+{
+ struct zfcp_unit *unit, *tmp_unit;
+ scsi_lun_t scsi_lun;
+ int found;
+
+ /*
+ * check that there is no unit with this FCP_LUN already in list
+ * and enqueue it.
+ * Note: Unlike for the adapter and the port, this is an error
+ */
+ read_lock_irq(&zfcp_data.config_lock);
+ unit = zfcp_get_unit_by_lun(port, fcp_lun);
+ read_unlock_irq(&zfcp_data.config_lock);
+ if (unit)
+ return NULL;
+
+ unit = kmalloc(sizeof (struct zfcp_unit), GFP_KERNEL);
+ if (!unit)
+ return NULL;
+ memset(unit, 0, sizeof (struct zfcp_unit));
+
+ /* initialise reference count stuff */
+ atomic_set(&unit->refcount, 0);
+ init_waitqueue_head(&unit->remove_wq);
+
+ unit->port = port;
+ unit->fcp_lun = fcp_lun;
+
+ /* setup for sysfs registration */
+ snprintf(unit->sysfs_device.bus_id, BUS_ID_SIZE, "0x%016llx", fcp_lun);
+ unit->sysfs_device.parent = &port->sysfs_device;
+ unit->sysfs_device.release = zfcp_sysfs_unit_release;
+ dev_set_drvdata(&unit->sysfs_device, unit);
+
+ /* mark unit unusable as long as sysfs registration is not complete */
+ atomic_set_mask(ZFCP_STATUS_COMMON_REMOVE, &unit->status);
+
+ if (device_register(&unit->sysfs_device)) {
+ kfree(unit);
+ return NULL;
+ }
+
+ if (zfcp_sysfs_unit_create_files(&unit->sysfs_device)) {
+ device_unregister(&unit->sysfs_device);
+ return NULL;
+ }
+
+ zfcp_unit_get(unit);
+
+ scsi_lun = 0;
+ found = 0;
+ write_lock_irq(&zfcp_data.config_lock);
+ list_for_each_entry(tmp_unit, &port->unit_list_head, list) {
+ if (tmp_unit->scsi_lun != scsi_lun) {
+ found = 1;
+ break;
+ }
+ scsi_lun++;
+ }
+ unit->scsi_lun = scsi_lun;
+ if (found)
+ list_add_tail(&unit->list, &tmp_unit->list);
+ else
+ list_add_tail(&unit->list, &port->unit_list_head);
+ atomic_clear_mask(ZFCP_STATUS_COMMON_REMOVE, &unit->status);
+ atomic_set_mask(ZFCP_STATUS_COMMON_RUNNING, &unit->status);
+ write_unlock_irq(&zfcp_data.config_lock);
+
+ port->units++;
+ zfcp_port_get(port);
+
+ return unit;
+}
+
+void
+zfcp_unit_dequeue(struct zfcp_unit *unit)
+{
+ zfcp_unit_wait(unit);
+ write_lock_irq(&zfcp_data.config_lock);
+ list_del(&unit->list);
+ write_unlock_irq(&zfcp_data.config_lock);
+ unit->port->units--;
+ zfcp_port_put(unit->port);
+ zfcp_sysfs_unit_remove_files(&unit->sysfs_device);
+ device_unregister(&unit->sysfs_device);
+}
+
+static void *
+zfcp_mempool_alloc(unsigned int __nocast gfp_mask, void *size)
+{
+ return kmalloc((size_t) size, gfp_mask);
+}
+
+static void
+zfcp_mempool_free(void *element, void *size)
+{
+ kfree(element);
+}
+
+/*
+ * Allocates a combined QTCB/fsf_req buffer for erp actions and fcp/SCSI
+ * commands.
+ * It also genrates fcp-nameserver request/response buffer and unsolicited
+ * status read fsf_req buffers.
+ *
+ * locks: must only be called with zfcp_data.config_sema taken
+ */
+static int
+zfcp_allocate_low_mem_buffers(struct zfcp_adapter *adapter)
+{
+ adapter->pool.fsf_req_erp =
+ mempool_create(ZFCP_POOL_FSF_REQ_ERP_NR,
+ zfcp_mempool_alloc, zfcp_mempool_free, (void *)
+ sizeof(struct zfcp_fsf_req_pool_element));
+
+ if (NULL == adapter->pool.fsf_req_erp)
+ return -ENOMEM;
+
+ adapter->pool.fsf_req_scsi =
+ mempool_create(ZFCP_POOL_FSF_REQ_SCSI_NR,
+ zfcp_mempool_alloc, zfcp_mempool_free, (void *)
+ sizeof(struct zfcp_fsf_req_pool_element));
+
+ if (NULL == adapter->pool.fsf_req_scsi)
+ return -ENOMEM;
+
+ adapter->pool.fsf_req_abort =
+ mempool_create(ZFCP_POOL_FSF_REQ_ABORT_NR,
+ zfcp_mempool_alloc, zfcp_mempool_free, (void *)
+ sizeof(struct zfcp_fsf_req_pool_element));
+
+ if (NULL == adapter->pool.fsf_req_abort)
+ return -ENOMEM;
+
+ adapter->pool.fsf_req_status_read =
+ mempool_create(ZFCP_POOL_STATUS_READ_NR,
+ zfcp_mempool_alloc, zfcp_mempool_free,
+ (void *) sizeof(struct zfcp_fsf_req));
+
+ if (NULL == adapter->pool.fsf_req_status_read)
+ return -ENOMEM;
+
+ adapter->pool.data_status_read =
+ mempool_create(ZFCP_POOL_STATUS_READ_NR,
+ zfcp_mempool_alloc, zfcp_mempool_free,
+ (void *) sizeof(struct fsf_status_read_buffer));
+
+ if (NULL == adapter->pool.data_status_read)
+ return -ENOMEM;
+
+ adapter->pool.data_gid_pn =
+ mempool_create(ZFCP_POOL_DATA_GID_PN_NR,
+ zfcp_mempool_alloc, zfcp_mempool_free, (void *)
+ sizeof(struct zfcp_gid_pn_data));
+
+ if (NULL == adapter->pool.data_gid_pn)
+ return -ENOMEM;
+
+ return 0;
+}
+
+/**
+ * zfcp_free_low_mem_buffers - free memory pools of an adapter
+ * @adapter: pointer to zfcp_adapter for which memory pools should be freed
+ * locking: zfcp_data.config_sema must be held
+ */
+static void
+zfcp_free_low_mem_buffers(struct zfcp_adapter *adapter)
+{
+ if (adapter->pool.fsf_req_erp)
+ mempool_destroy(adapter->pool.fsf_req_erp);
+ if (adapter->pool.fsf_req_scsi)
+ mempool_destroy(adapter->pool.fsf_req_scsi);
+ if (adapter->pool.fsf_req_abort)
+ mempool_destroy(adapter->pool.fsf_req_abort);
+ if (adapter->pool.fsf_req_status_read)
+ mempool_destroy(adapter->pool.fsf_req_status_read);
+ if (adapter->pool.data_status_read)
+ mempool_destroy(adapter->pool.data_status_read);
+ if (adapter->pool.data_gid_pn)
+ 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)
+{
+ return;
+}
+
+/*
+ * Enqueues an adapter at the end of the adapter list in the driver data.
+ * All adapter internal structures are set up.
+ * Proc-fs entries are also created.
+ *
+ * returns: 0 if a new adapter was successfully enqueued
+ * ZFCP_KNOWN if an adapter with this devno was already present
+ * -ENOMEM if alloc failed
+ * locks: config_sema must be held to serialise changes to the adapter list
+ */
+struct zfcp_adapter *
+zfcp_adapter_enqueue(struct ccw_device *ccw_device)
+{
+ int retval = 0;
+ struct zfcp_adapter *adapter;
+
+ /*
+ * Note: It is safe to release the list_lock, as any list changes
+ * are protected by the config_sema, which must be held to get here
+ */
+
+ /* try to allocate new adapter data structure (zeroed) */
+ adapter = kmalloc(sizeof (struct zfcp_adapter), GFP_KERNEL);
+ if (!adapter) {
+ ZFCP_LOG_INFO("error: allocation of base adapter "
+ "structure failed\n");
+ goto out;
+ }
+ memset(adapter, 0, sizeof (struct zfcp_adapter));
+
+ ccw_device->handler = NULL;
+
+ /* save ccw_device pointer */
+ adapter->ccw_device = ccw_device;
+
+ retval = zfcp_qdio_allocate_queues(adapter);
+ if (retval)
+ goto queues_alloc_failed;
+
+ retval = zfcp_qdio_allocate(adapter);
+ if (retval)
+ goto qdio_allocate_failed;
+
+ retval = zfcp_allocate_low_mem_buffers(adapter);
+ if (retval) {
+ ZFCP_LOG_INFO("error: pool allocation failed\n");
+ goto failed_low_mem_buffers;
+ }
+
+ /* initialise reference count stuff */
+ atomic_set(&adapter->refcount, 0);
+ init_waitqueue_head(&adapter->remove_wq);
+
+ /* initialise list of ports */
+ INIT_LIST_HEAD(&adapter->port_list_head);
+
+ /* initialise list of ports to be removed */
+ INIT_LIST_HEAD(&adapter->port_remove_lh);
+
+ /* initialize list of fsf requests */
+ rwlock_init(&adapter->fsf_req_list_lock);
+ INIT_LIST_HEAD(&adapter->fsf_req_list_head);
+
+ /* initialize abort lock */
+ rwlock_init(&adapter->abort_lock);
+
+ /* initialise some erp stuff */
+ init_waitqueue_head(&adapter->erp_thread_wqh);
+ init_waitqueue_head(&adapter->erp_done_wqh);
+
+ /* initialize lock of associated request queue */
+ rwlock_init(&adapter->request_queue.queue_lock);
+
+ /* intitialise SCSI ER timer */
+ init_timer(&adapter->scsi_er_timer);
+
+ /* set FC service class used per default */
+ adapter->fc_service_class = ZFCP_FC_SERVICE_CLASS_DEFAULT;
+
+ sprintf(adapter->name, "%s", zfcp_get_busid_by_adapter(adapter));
+ ASCEBC(adapter->name, strlen(adapter->name));
+
+ /* mark adapter unusable as long as sysfs registration is not complete */
+ atomic_set_mask(ZFCP_STATUS_COMMON_REMOVE, &adapter->status);
+
+ adapter->ccw_device = ccw_device;
+ dev_set_drvdata(&ccw_device->dev, adapter);
+
+ if (zfcp_sysfs_adapter_create_files(&ccw_device->dev))
+ goto sysfs_failed;
+
+ adapter->generic_services.parent = &adapter->ccw_device->dev;
+ adapter->generic_services.release = zfcp_dummy_release;
+ snprintf(adapter->generic_services.bus_id, BUS_ID_SIZE,
+ "generic_services");
+
+ if (device_register(&adapter->generic_services))
+ goto generic_services_failed;
+
+ /* put allocated adapter at list tail */
+ write_lock_irq(&zfcp_data.config_lock);
+ atomic_clear_mask(ZFCP_STATUS_COMMON_REMOVE, &adapter->status);
+ list_add_tail(&adapter->list, &zfcp_data.adapter_list_head);
+ write_unlock_irq(&zfcp_data.config_lock);
+
+ zfcp_data.adapters++;
+
+ goto out;
+
+ generic_services_failed:
+ zfcp_sysfs_adapter_remove_files(&adapter->ccw_device->dev);
+ sysfs_failed:
+ dev_set_drvdata(&ccw_device->dev, NULL);
+ failed_low_mem_buffers:
+ zfcp_free_low_mem_buffers(adapter);
+ if (qdio_free(ccw_device) != 0)
+ ZFCP_LOG_NORMAL("bug: qdio_free for adapter %s failed\n",
+ zfcp_get_busid_by_adapter(adapter));
+ qdio_allocate_failed:
+ zfcp_qdio_free_queues(adapter);
+ queues_alloc_failed:
+ kfree(adapter);
+ adapter = NULL;
+ out:
+ return adapter;
+}
+
+/*
+ * returns: 0 - struct zfcp_adapter data structure successfully removed
+ * !0 - struct zfcp_adapter data structure could not be removed
+ * (e.g. still used)
+ * locks: adapter list write lock is assumed to be held by caller
+ * adapter->fsf_req_list_lock is taken and released within this
+ * function and must not be held on entry
+ */
+void
+zfcp_adapter_dequeue(struct zfcp_adapter *adapter)
+{
+ int retval = 0;
+ unsigned long flags;
+
+ device_unregister(&adapter->generic_services);
+ zfcp_sysfs_adapter_remove_files(&adapter->ccw_device->dev);
+ dev_set_drvdata(&adapter->ccw_device->dev, NULL);
+ /* sanity check: no pending FSF requests */
+ read_lock_irqsave(&adapter->fsf_req_list_lock, flags);
+ retval = !list_empty(&adapter->fsf_req_list_head);
+ read_unlock_irqrestore(&adapter->fsf_req_list_lock, flags);
+ if (retval) {
+ ZFCP_LOG_NORMAL("bug: adapter %s (%p) still in use, "
+ "%i requests outstanding\n",
+ zfcp_get_busid_by_adapter(adapter), adapter,
+ atomic_read(&adapter->fsf_reqs_active));
+ retval = -EBUSY;
+ goto out;
+ }
+
+ /* remove specified adapter data structure from list */
+ write_lock_irq(&zfcp_data.config_lock);
+ list_del(&adapter->list);
+ write_unlock_irq(&zfcp_data.config_lock);
+
+ /* decrease number of adapters in list */
+ zfcp_data.adapters--;
+
+ ZFCP_LOG_TRACE("adapter %s (%p) removed from list, "
+ "%i adapters still in list\n",
+ zfcp_get_busid_by_adapter(adapter),
+ adapter, zfcp_data.adapters);
+
+ retval = qdio_free(adapter->ccw_device);
+ if (retval)
+ ZFCP_LOG_NORMAL("bug: qdio_free for adapter %s failed\n",
+ zfcp_get_busid_by_adapter(adapter));
+
+ zfcp_free_low_mem_buffers(adapter);
+ /* free memory of adapter data structure and queues */
+ zfcp_qdio_free_queues(adapter);
+ ZFCP_LOG_TRACE("freeing adapter structure\n");
+ kfree(adapter);
+ out:
+ return;
+}
+
+/**
+ * zfcp_port_enqueue - enqueue port to port list of adapter
+ * @adapter: adapter where remote port is added
+ * @wwpn: WWPN of the remote port to be enqueued
+ * @status: initial status for the port
+ * @d_id: destination id of the remote port to be enqueued
+ * Return: pointer to enqueued port on success, NULL on error
+ * Locks: config_sema must be held to serialize changes to the port list
+ *
+ * All port internal structures are set up and the sysfs entry is generated.
+ * d_id is used to enqueue ports with a well known address like the Directory
+ * Service for nameserver lookup.
+ */
+struct zfcp_port *
+zfcp_port_enqueue(struct zfcp_adapter *adapter, wwn_t wwpn, u32 status,
+ u32 d_id)
+{
+ struct zfcp_port *port, *tmp_port;
+ int check_wwpn;
+ scsi_id_t scsi_id;
+ int found;
+
+ check_wwpn = !(status & ZFCP_STATUS_PORT_NO_WWPN);
+
+ /*
+ * check that there is no port with this WWPN already in list
+ */
+ if (check_wwpn) {
+ read_lock_irq(&zfcp_data.config_lock);
+ port = zfcp_get_port_by_wwpn(adapter, wwpn);
+ read_unlock_irq(&zfcp_data.config_lock);
+ if (port)
+ return NULL;
+ }
+
+ port = kmalloc(sizeof (struct zfcp_port), GFP_KERNEL);
+ if (!port)
+ return NULL;
+ memset(port, 0, sizeof (struct zfcp_port));
+
+ /* initialise reference count stuff */
+ atomic_set(&port->refcount, 0);
+ init_waitqueue_head(&port->remove_wq);
+
+ INIT_LIST_HEAD(&port->unit_list_head);
+ INIT_LIST_HEAD(&port->unit_remove_lh);
+
+ port->adapter = adapter;
+
+ if (check_wwpn)
+ port->wwpn = wwpn;
+
+ atomic_set_mask(status, &port->status);
+
+ /* setup for sysfs registration */
+ if (status & ZFCP_STATUS_PORT_WKA) {
+ switch (d_id) {
+ case ZFCP_DID_DIRECTORY_SERVICE:
+ snprintf(port->sysfs_device.bus_id, BUS_ID_SIZE,
+ "directory");
+ break;
+ case ZFCP_DID_MANAGEMENT_SERVICE:
+ snprintf(port->sysfs_device.bus_id, BUS_ID_SIZE,
+ "management");
+ break;
+ case ZFCP_DID_KEY_DISTRIBUTION_SERVICE:
+ snprintf(port->sysfs_device.bus_id, BUS_ID_SIZE,
+ "key_distribution");
+ break;
+ case ZFCP_DID_ALIAS_SERVICE:
+ snprintf(port->sysfs_device.bus_id, BUS_ID_SIZE,
+ "alias");
+ break;
+ case ZFCP_DID_TIME_SERVICE:
+ snprintf(port->sysfs_device.bus_id, BUS_ID_SIZE,
+ "time");
+ break;
+ default:
+ kfree(port);
+ return NULL;
+ }
+ port->d_id = d_id;
+ port->sysfs_device.parent = &adapter->generic_services;
+ } else {
+ snprintf(port->sysfs_device.bus_id,
+ BUS_ID_SIZE, "0x%016llx", wwpn);
+ port->sysfs_device.parent = &adapter->ccw_device->dev;
+ }
+ port->sysfs_device.release = zfcp_sysfs_port_release;
+ dev_set_drvdata(&port->sysfs_device, port);
+
+ /* mark port unusable as long as sysfs registration is not complete */
+ atomic_set_mask(ZFCP_STATUS_COMMON_REMOVE, &port->status);
+
+ if (device_register(&port->sysfs_device)) {
+ kfree(port);
+ return NULL;
+ }
+
+ if (zfcp_sysfs_port_create_files(&port->sysfs_device, status)) {
+ device_unregister(&port->sysfs_device);
+ return NULL;
+ }
+
+ zfcp_port_get(port);
+
+ scsi_id = 1;
+ found = 0;
+ write_lock_irq(&zfcp_data.config_lock);
+ list_for_each_entry(tmp_port, &adapter->port_list_head, list) {
+ if (atomic_test_mask(ZFCP_STATUS_PORT_NO_SCSI_ID,
+ &tmp_port->status))
+ continue;
+ if (tmp_port->scsi_id != scsi_id) {
+ found = 1;
+ break;
+ }
+ scsi_id++;
+ }
+ port->scsi_id = scsi_id;
+ if (found)
+ list_add_tail(&port->list, &tmp_port->list);
+ else
+ list_add_tail(&port->list, &adapter->port_list_head);
+ atomic_clear_mask(ZFCP_STATUS_COMMON_REMOVE, &port->status);
+ atomic_set_mask(ZFCP_STATUS_COMMON_RUNNING, &port->status);
+ if (d_id == ZFCP_DID_DIRECTORY_SERVICE)
+ if (!adapter->nameserver_port)
+ adapter->nameserver_port = port;
+ adapter->ports++;
+ write_unlock_irq(&zfcp_data.config_lock);
+
+ zfcp_adapter_get(adapter);
+
+ return port;
+}
+
+void
+zfcp_port_dequeue(struct zfcp_port *port)
+{
+ zfcp_port_wait(port);
+ write_lock_irq(&zfcp_data.config_lock);
+ list_del(&port->list);
+ port->adapter->ports--;
+ write_unlock_irq(&zfcp_data.config_lock);
+ zfcp_adapter_put(port->adapter);
+ zfcp_sysfs_port_remove_files(&port->sysfs_device,
+ atomic_read(&port->status));
+ device_unregister(&port->sysfs_device);
+}
+
+/* Enqueues a nameserver port */
+int
+zfcp_nameserver_enqueue(struct zfcp_adapter *adapter)
+{
+ struct zfcp_port *port;
+
+ port = zfcp_port_enqueue(adapter, 0, ZFCP_STATUS_PORT_WKA,
+ ZFCP_DID_DIRECTORY_SERVICE);
+ if (!port) {
+ ZFCP_LOG_INFO("error: enqueue of nameserver port for "
+ "adapter %s failed\n",
+ zfcp_get_busid_by_adapter(adapter));
+ return -ENXIO;
+ }
+ zfcp_port_put(port);
+
+ return 0;
+}
+
+#undef ZFCP_LOG_AREA
+
+/****************************************************************/
+/******* Fibre Channel Standard related Functions **************/
+/****************************************************************/
+
+#define ZFCP_LOG_AREA ZFCP_LOG_AREA_FC
+
+void
+zfcp_fsf_incoming_els_rscn(struct zfcp_adapter *adapter,
+ struct fsf_status_read_buffer *status_buffer)
+{
+ struct fcp_rscn_head *fcp_rscn_head;
+ struct fcp_rscn_element *fcp_rscn_element;
+ struct zfcp_port *port;
+ u16 i;
+ u16 no_entries;
+ u32 range_mask;
+ unsigned long flags;
+
+ fcp_rscn_head = (struct fcp_rscn_head *) status_buffer->payload;
+ fcp_rscn_element = (struct fcp_rscn_element *) status_buffer->payload;
+
+ /* 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++;
+ switch (fcp_rscn_element->addr_format) {
+ case ZFCP_PORT_ADDRESS:
+ ZFCP_LOG_FLAGS(1, "ZFCP_PORT_ADDRESS\n");
+ range_mask = ZFCP_PORTS_RANGE_PORT;
+ break;
+ case ZFCP_AREA_ADDRESS:
+ ZFCP_LOG_FLAGS(1, "ZFCP_AREA_ADDRESS\n");
+ range_mask = ZFCP_PORTS_RANGE_AREA;
+ break;
+ case ZFCP_DOMAIN_ADDRESS:
+ ZFCP_LOG_FLAGS(1, "ZFCP_DOMAIN_ADDRESS\n");
+ range_mask = ZFCP_PORTS_RANGE_DOMAIN;
+ break;
+ case ZFCP_FABRIC_ADDRESS:
+ ZFCP_LOG_FLAGS(1, "ZFCP_FABRIC_ADDRESS\n");
+ range_mask = ZFCP_PORTS_RANGE_FABRIC;
+ break;
+ default:
+ ZFCP_LOG_INFO("incoming RSCN with unknown "
+ "address format\n");
+ continue;
+ }
+ read_lock_irqsave(&zfcp_data.config_lock, flags);
+ list_for_each_entry(port, &adapter->port_list_head, list) {
+ if (atomic_test_mask
+ (ZFCP_STATUS_PORT_WKA, &port->status))
+ continue;
+ /* Do we know this port? If not skip it. */
+ if (!atomic_test_mask
+ (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;
+ }
+
+ /*
+ * FIXME: race: d_id might being invalidated
+ * (...DID_DID reset)
+ */
+ if ((port->d_id & range_mask)
+ == (fcp_rscn_element->nport_did & range_mask)) {
+ ZFCP_LOG_TRACE("reopen did 0x%08x\n",
+ fcp_rscn_element->nport_did);
+ /*
+ * Unfortunately, an RSCN does not specify the
+ * type of change a target underwent. We assume
+ * that it makes sense to reopen the link.
+ * FIXME: Shall we try to find out more about
+ * the target and link state before closing it?
+ * How to accomplish this? (nameserver?)
+ * Where would such code be put in?
+ * (inside or outside erp)
+ */
+ 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);
+ }
+ }
+ read_unlock_irqrestore(&zfcp_data.config_lock, flags);
+ }
+}
+
+static void
+zfcp_fsf_incoming_els_plogi(struct zfcp_adapter *adapter,
+ struct fsf_status_read_buffer *status_buffer)
+{
+ logi *els_logi = (logi *) status_buffer->payload;
+ 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))
+ break;
+ }
+ read_unlock_irqrestore(&zfcp_data.config_lock, flags);
+
+ if (!port || (port->wwpn != (*(wwn_t *) & els_logi->nport_wwn))) {
+ ZFCP_LOG_DEBUG("ignored incoming PLOGI for nonexisting port "
+ "with d_id 0x%08x on adapter %s\n",
+ 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);
+ }
+}
+
+static void
+zfcp_fsf_incoming_els_logo(struct zfcp_adapter *adapter,
+ struct fsf_status_read_buffer *status_buffer)
+{
+ struct fcp_logo *els_logo = (struct fcp_logo *) status_buffer->payload;
+ 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)
+ break;
+ }
+ read_unlock_irqrestore(&zfcp_data.config_lock, flags);
+
+ if (!port || (port->wwpn != els_logo->nport_wwpn)) {
+ ZFCP_LOG_DEBUG("ignored incoming LOGO for nonexisting port "
+ "with d_id 0x%08x on adapter %s\n",
+ 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);
+ }
+}
+
+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));
+
+}
+
+void
+zfcp_fsf_incoming_els(struct zfcp_fsf_req *fsf_req)
+{
+ struct fsf_status_read_buffer *status_buffer;
+ u32 els_type;
+ struct zfcp_adapter *adapter;
+
+ status_buffer = fsf_req->data.status_read.buffer;
+ els_type = *(u32 *) (status_buffer->payload);
+ adapter = fsf_req->adapter;
+
+ if (els_type == LS_PLOGI)
+ zfcp_fsf_incoming_els_plogi(adapter, status_buffer);
+ else if (els_type == LS_LOGO)
+ zfcp_fsf_incoming_els_logo(adapter, status_buffer);
+ else if ((els_type & 0xffff0000) == LS_RSCN)
+ /* we are only concerned with the command, not the length */
+ zfcp_fsf_incoming_els_rscn(adapter, status_buffer);
+ else
+ zfcp_fsf_incoming_els_unknown(adapter, status_buffer);
+}
+
+
+/**
+ * zfcp_gid_pn_buffers_alloc - allocate buffers for GID_PN nameserver request
+ * @gid_pn: pointer to return pointer to struct zfcp_gid_pn_data
+ * @pool: pointer to mempool_t if non-null memory pool is used for allocation
+ */
+static int
+zfcp_gid_pn_buffers_alloc(struct zfcp_gid_pn_data **gid_pn, mempool_t *pool)
+{
+ struct zfcp_gid_pn_data *data;
+
+ if (pool != NULL) {
+ data = mempool_alloc(pool, GFP_ATOMIC);
+ if (likely(data != NULL)) {
+ data->ct.pool = pool;
+ }
+ } else {
+ data = kmalloc(sizeof(struct zfcp_gid_pn_data), GFP_ATOMIC);
+ }
+
+ if (NULL == data)
+ return -ENOMEM;
+
+ memset(data, 0, sizeof(*data));
+ data->ct.req = &data->req;
+ data->ct.resp = &data->resp;
+ data->ct.req_count = data->ct.resp_count = 1;
+ zfcp_address_to_sg(&data->ct_iu_req, &data->req);
+ zfcp_address_to_sg(&data->ct_iu_resp, &data->resp);
+ data->req.length = sizeof(struct ct_iu_gid_pn_req);
+ data->resp.length = sizeof(struct ct_iu_gid_pn_resp);
+
+ *gid_pn = data;
+ return 0;
+}
+
+/**
+ * zfcp_gid_pn_buffers_free - free buffers for GID_PN nameserver request
+ * @gid_pn: pointer to struct zfcp_gid_pn_data which has to be freed
+ */
+static void
+zfcp_gid_pn_buffers_free(struct zfcp_gid_pn_data *gid_pn)
+{
+ if ((gid_pn->ct.pool != 0))
+ mempool_free(gid_pn, gid_pn->ct.pool);
+ else
+ kfree(gid_pn);
+
+ return;
+}
+
+/**
+ * zfcp_ns_gid_pn_request - initiate GID_PN nameserver request
+ * @erp_action: pointer to zfcp_erp_action where GID_PN request is needed
+ */
+int
+zfcp_ns_gid_pn_request(struct zfcp_erp_action *erp_action)
+{
+ int ret;
+ struct ct_iu_gid_pn_req *ct_iu_req;
+ struct zfcp_gid_pn_data *gid_pn;
+ struct zfcp_adapter *adapter = erp_action->adapter;
+
+ ret = zfcp_gid_pn_buffers_alloc(&gid_pn, adapter->pool.data_gid_pn);
+ if (ret < 0) {
+ ZFCP_LOG_INFO("error: buffer allocation for gid_pn nameserver "
+ "request failed for adapter %s\n",
+ zfcp_get_busid_by_adapter(adapter));
+ goto out;
+ }
+
+ /* setup nameserver request */
+ ct_iu_req = zfcp_sg_to_address(gid_pn->ct.req);
+ ct_iu_req->header.revision = ZFCP_CT_REVISION;
+ ct_iu_req->header.gs_type = ZFCP_CT_DIRECTORY_SERVICE;
+ ct_iu_req->header.gs_subtype = ZFCP_CT_NAME_SERVER;
+ ct_iu_req->header.options = ZFCP_CT_SYNCHRONOUS;
+ ct_iu_req->header.cmd_rsp_code = ZFCP_CT_GID_PN;
+ ct_iu_req->header.max_res_size = ZFCP_CT_MAX_SIZE;
+ ct_iu_req->wwpn = erp_action->port->wwpn;
+
+ /* setup parameters for send generic command */
+ gid_pn->ct.port = adapter->nameserver_port;
+ gid_pn->ct.handler = zfcp_ns_gid_pn_handler;
+ gid_pn->ct.handler_data = (unsigned long) gid_pn;
+ gid_pn->ct.timeout = ZFCP_NS_GID_PN_TIMEOUT;
+ gid_pn->ct.timer = &erp_action->timer;
+ gid_pn->port = erp_action->port;
+
+ ret = zfcp_fsf_send_ct(&gid_pn->ct, adapter->pool.fsf_req_erp,
+ erp_action);
+ if (ret) {
+ ZFCP_LOG_INFO("error: initiation of gid_pn nameserver request "
+ "failed for adapter %s\n",
+ zfcp_get_busid_by_adapter(adapter));
+
+ zfcp_gid_pn_buffers_free(gid_pn);
+ }
+
+ out:
+ return ret;
+}
+
+/**
+ * zfcp_ns_gid_pn_handler - handler for GID_PN nameserver request
+ * @data: unsigned long, contains pointer to struct zfcp_gid_pn_data
+ */
+static void zfcp_ns_gid_pn_handler(unsigned long data)
+{
+ struct zfcp_port *port;
+ struct zfcp_send_ct *ct;
+ struct ct_iu_gid_pn_req *ct_iu_req;
+ struct ct_iu_gid_pn_resp *ct_iu_resp;
+ struct zfcp_gid_pn_data *gid_pn;
+
+
+ gid_pn = (struct zfcp_gid_pn_data *) data;
+ port = gid_pn->port;
+ ct = &gid_pn->ct;
+ ct_iu_req = zfcp_sg_to_address(ct->req);
+ ct_iu_resp = zfcp_sg_to_address(ct->resp);
+
+ if ((ct->status != 0) || zfcp_check_ct_response(&ct_iu_resp->header)) {
+ /* FIXME: do we need some specific erp entry points */
+ atomic_set_mask(ZFCP_STATUS_PORT_INVALID_WWPN, &port->status);
+ goto failed;
+ }
+ /* paranoia */
+ if (ct_iu_req->wwpn != port->wwpn) {
+ ZFCP_LOG_NORMAL("bug: wwpn 0x%016Lx returned by nameserver "
+ "lookup does not match expected wwpn 0x%016Lx "
+ "for adapter %s\n", ct_iu_req->wwpn, port->wwpn,
+ zfcp_get_busid_by_port(port));
+ goto mismatch;
+ }
+
+ /* looks like a valid d_id */
+ port->d_id = ct_iu_resp->d_id & ZFCP_DID_MASK;
+ atomic_set_mask(ZFCP_STATUS_PORT_DID_DID, &port->status);
+ ZFCP_LOG_DEBUG("adapter %s: wwpn=0x%016Lx ---> d_id=0x%08x\n",
+ zfcp_get_busid_by_port(port), port->wwpn, port->d_id);
+ goto out;
+
+ mismatch:
+ ZFCP_LOG_DEBUG("CT IUs do not match:\n");
+ ZFCP_HEX_DUMP(ZFCP_LOG_LEVEL_DEBUG, (char *) ct_iu_req,
+ sizeof(struct ct_iu_gid_pn_req));
+ ZFCP_HEX_DUMP(ZFCP_LOG_LEVEL_DEBUG, (char *) ct_iu_resp,
+ sizeof(struct ct_iu_gid_pn_resp));
+
+ failed:
+ ZFCP_LOG_NORMAL("warning: failed gid_pn nameserver request for wwpn "
+ "0x%016Lx for adapter %s\n",
+ port->wwpn, zfcp_get_busid_by_port(port));
+ out:
+ zfcp_gid_pn_buffers_free(gid_pn);
+ return;
+}
+
+/* reject CT_IU reason codes acc. to FC-GS-4 */
+static const struct zfcp_rc_entry zfcp_ct_rc[] = {
+ {0x01, "invalid command code"},
+ {0x02, "invalid version level"},
+ {0x03, "logical error"},
+ {0x04, "invalid CT_IU size"},
+ {0x05, "logical busy"},
+ {0x07, "protocol error"},
+ {0x09, "unable to perform command request"},
+ {0x0b, "command not supported"},
+ {0x0d, "server not available"},
+ {0x0e, "session could not be established"},
+ {0xff, "vendor specific error"},
+ {0, NULL},
+};
+
+/* LS_RJT reason codes acc. to FC-FS */
+static const struct zfcp_rc_entry zfcp_ls_rjt_rc[] = {
+ {0x01, "invalid LS_Command code"},
+ {0x03, "logical error"},
+ {0x05, "logical busy"},
+ {0x07, "protocol error"},
+ {0x09, "unable to perform command request"},
+ {0x0b, "command not supported"},
+ {0x0e, "command already in progress"},
+ {0xff, "vendor specific error"},
+ {0, NULL},
+};
+
+/* reject reason codes according to FC-PH/FC-FS */
+static const struct zfcp_rc_entry zfcp_p_rjt_rc[] = {
+ {0x01, "invalid D_ID"},
+ {0x02, "invalid S_ID"},
+ {0x03, "Nx_Port not available, temporary"},
+ {0x04, "Nx_Port not available, permament"},
+ {0x05, "class not supported"},
+ {0x06, "delimiter usage error"},
+ {0x07, "TYPE not supported"},
+ {0x08, "invalid Link_Control"},
+ {0x09, "invalid R_CTL field"},
+ {0x0a, "invalid F_CTL field"},
+ {0x0b, "invalid OX_ID"},
+ {0x0c, "invalid RX_ID"},
+ {0x0d, "invalid SEQ_ID"},
+ {0x0e, "invalid DF_CTL"},
+ {0x0f, "invalid SEQ_CNT"},
+ {0x10, "invalid parameter field"},
+ {0x11, "exchange error"},
+ {0x12, "protocol error"},
+ {0x13, "incorrect length"},
+ {0x14, "unsupported ACK"},
+ {0x15, "class of service not supported by entity at FFFFFE"},
+ {0x16, "login required"},
+ {0x17, "excessive sequences attempted"},
+ {0x18, "unable to establish exchange"},
+ {0x1a, "fabric path not available"},
+ {0x1b, "invalid VC_ID (class 4)"},
+ {0x1c, "invalid CS_CTL field"},
+ {0x1d, "insufficient resources for VC (class 4)"},
+ {0x1f, "invalid class of service"},
+ {0x20, "preemption request rejected"},
+ {0x21, "preemption not enabled"},
+ {0x22, "multicast error"},
+ {0x23, "multicast error terminate"},
+ {0x24, "process login required"},
+ {0xff, "vendor specific reject"},
+ {0, NULL},
+};
+
+/**
+ * zfcp_rc_description - return description for given reaon code
+ * @code: reason code
+ * @rc_table: table of reason codes and descriptions
+ */
+static inline const char *
+zfcp_rc_description(u8 code, const struct zfcp_rc_entry *rc_table)
+{
+ const char *descr = "unknown reason code";
+
+ do {
+ if (code == rc_table->code) {
+ descr = rc_table->description;
+ break;
+ }
+ rc_table++;
+ } while (rc_table->code && rc_table->description);
+
+ return descr;
+}
+
+/**
+ * zfcp_check_ct_response - evaluate reason code for CT_IU
+ * @rjt: response payload to an CT_IU request
+ * Return: 0 for accept CT_IU, 1 for reject CT_IU or invlid response code
+ */
+int
+zfcp_check_ct_response(struct ct_hdr *rjt)
+{
+ if (rjt->cmd_rsp_code == ZFCP_CT_ACCEPT)
+ return 0;
+
+ if (rjt->cmd_rsp_code != ZFCP_CT_REJECT) {
+ ZFCP_LOG_NORMAL("error: invalid Generic Service command/"
+ "response code (0x%04hx)\n",
+ rjt->cmd_rsp_code);
+ return 1;
+ }
+
+ ZFCP_LOG_INFO("Generic Service command rejected\n");
+ ZFCP_LOG_INFO("%s (0x%02x, 0x%02x, 0x%02x)\n",
+ zfcp_rc_description(rjt->reason_code, zfcp_ct_rc),
+ (u32) rjt->reason_code, (u32) rjt->reason_code_expl,
+ (u32) rjt->vendor_unique);
+
+ return 1;
+}
+
+/**
+ * zfcp_print_els_rjt - print reject parameter and description for ELS reject
+ * @rjt_par: reject parameter acc. to FC-PH/FC-FS
+ * @rc_table: table of reason codes and descriptions
+ */
+static inline void
+zfcp_print_els_rjt(struct zfcp_ls_rjt_par *rjt_par,
+ const struct zfcp_rc_entry *rc_table)
+{
+ ZFCP_LOG_INFO("%s (%02x %02x %02x %02x)\n",
+ zfcp_rc_description(rjt_par->reason_code, rc_table),
+ (u32) rjt_par->action, (u32) rjt_par->reason_code,
+ (u32) rjt_par->reason_expl, (u32) rjt_par->vendor_unique);
+}
+
+/**
+ * zfcp_fsf_handle_els_rjt - evaluate status qualifier/reason code on ELS reject
+ * @sq: status qualifier word
+ * @rjt_par: reject parameter as described in FC-PH and FC-FS
+ * Return: -EROMTEIO for LS_RJT, -EREMCHG for invalid D_ID, -EIO else
+ */
+int
+zfcp_handle_els_rjt(u32 sq, struct zfcp_ls_rjt_par *rjt_par)
+{
+ int ret = -EIO;
+
+ if (sq == FSF_IOSTAT_NPORT_RJT) {
+ ZFCP_LOG_INFO("ELS rejected (P_RJT)\n");
+ zfcp_print_els_rjt(rjt_par, zfcp_p_rjt_rc);
+ /* invalid d_id */
+ if (rjt_par->reason_code == 0x01)
+ ret = -EREMCHG;
+ } else if (sq == FSF_IOSTAT_FABRIC_RJT) {
+ ZFCP_LOG_INFO("ELS rejected (F_RJT)\n");
+ zfcp_print_els_rjt(rjt_par, zfcp_p_rjt_rc);
+ /* invalid d_id */
+ if (rjt_par->reason_code == 0x01)
+ ret = -EREMCHG;
+ } else if (sq == FSF_IOSTAT_LS_RJT) {
+ ZFCP_LOG_INFO("ELS rejected (LS_RJT)\n");
+ zfcp_print_els_rjt(rjt_par, zfcp_ls_rjt_rc);
+ ret = -EREMOTEIO;
+ } else
+ ZFCP_LOG_INFO("unexpected SQ: 0x%02x\n", sq);
+
+ return ret;
+}
+
+#undef ZFCP_LOG_AREA
diff --git a/drivers/s390/scsi/zfcp_ccw.c b/drivers/s390/scsi/zfcp_ccw.c
new file mode 100644
index 0000000..0fc4638
--- /dev/null
+++ b/drivers/s390/scsi/zfcp_ccw.c
@@ -0,0 +1,312 @@
+/*
+ * linux/drivers/s390/scsi/zfcp_ccw.c
+ *
+ * FCP adapter driver for IBM eServer zSeries
+ *
+ * CCW driver related routines
+ *
+ * (C) Copyright IBM Corp. 2003, 2004
+ *
+ * Authors:
+ * Martin Peschke <mpeschke@de.ibm.com>
+ * Heiko Carstens <heiko.carstens@de.ibm.com>
+ * Andreas Herrmann <aherrman@de.ibm.com>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2, or (at your option)
+ * any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#define ZFCP_CCW_C_REVISION "$Revision: 1.58 $"
+
+#include "zfcp_ext.h"
+
+#define ZFCP_LOG_AREA ZFCP_LOG_AREA_CONFIG
+
+static int zfcp_ccw_probe(struct ccw_device *);
+static void zfcp_ccw_remove(struct ccw_device *);
+static int zfcp_ccw_set_online(struct ccw_device *);
+static int zfcp_ccw_set_offline(struct ccw_device *);
+static int zfcp_ccw_notify(struct ccw_device *, int);
+static void zfcp_ccw_shutdown(struct device *);
+
+static struct ccw_device_id zfcp_ccw_device_id[] = {
+ {CCW_DEVICE_DEVTYPE(ZFCP_CONTROL_UNIT_TYPE,
+ ZFCP_CONTROL_UNIT_MODEL,
+ ZFCP_DEVICE_TYPE,
+ ZFCP_DEVICE_MODEL)},
+ {CCW_DEVICE_DEVTYPE(ZFCP_CONTROL_UNIT_TYPE,
+ ZFCP_CONTROL_UNIT_MODEL,
+ ZFCP_DEVICE_TYPE,
+ ZFCP_DEVICE_MODEL_PRIV)},
+ {},
+};
+
+static struct ccw_driver zfcp_ccw_driver = {
+ .owner = THIS_MODULE,
+ .name = ZFCP_NAME,
+ .ids = zfcp_ccw_device_id,
+ .probe = zfcp_ccw_probe,
+ .remove = zfcp_ccw_remove,
+ .set_online = zfcp_ccw_set_online,
+ .set_offline = zfcp_ccw_set_offline,
+ .notify = zfcp_ccw_notify,
+ .driver = {
+ .shutdown = zfcp_ccw_shutdown,
+ },
+};
+
+MODULE_DEVICE_TABLE(ccw, zfcp_ccw_device_id);
+
+/**
+ * zfcp_ccw_probe - probe function of zfcp driver
+ * @ccw_device: pointer to belonging ccw device
+ *
+ * This function gets called by the common i/o layer and sets up the initial
+ * data structures for each fcp adapter, which was detected by the system.
+ * Also the sysfs files for this adapter will be created by this function.
+ * In addition the nameserver port will be added to the ports of the adapter
+ * and its sysfs representation will be created too.
+ */
+static int
+zfcp_ccw_probe(struct ccw_device *ccw_device)
+{
+ struct zfcp_adapter *adapter;
+ int retval = 0;
+
+ down(&zfcp_data.config_sema);
+ adapter = zfcp_adapter_enqueue(ccw_device);
+ if (!adapter)
+ retval = -EINVAL;
+ else
+ ZFCP_LOG_DEBUG("Probed adapter %s\n",
+ zfcp_get_busid_by_adapter(adapter));
+ up(&zfcp_data.config_sema);
+ return retval;
+}
+
+/**
+ * zfcp_ccw_remove - remove function of zfcp driver
+ * @ccw_device: pointer to belonging ccw device
+ *
+ * This function gets called by the common i/o layer and removes an adapter
+ * from the system. Task of this function is to get rid of all units and
+ * ports that belong to this adapter. And in addition all resources of this
+ * adapter will be freed too.
+ */
+static void
+zfcp_ccw_remove(struct ccw_device *ccw_device)
+{
+ struct zfcp_adapter *adapter;
+ struct zfcp_port *port, *p;
+ struct zfcp_unit *unit, *u;
+
+ ccw_device_set_offline(ccw_device);
+ down(&zfcp_data.config_sema);
+ adapter = dev_get_drvdata(&ccw_device->dev);
+
+ ZFCP_LOG_DEBUG("Removing adapter %s\n",
+ zfcp_get_busid_by_adapter(adapter));
+ write_lock_irq(&zfcp_data.config_lock);
+ list_for_each_entry_safe(port, p, &adapter->port_list_head, list) {
+ list_for_each_entry_safe(unit, u, &port->unit_list_head, list) {
+ list_move(&unit->list, &port->unit_remove_lh);
+ atomic_set_mask(ZFCP_STATUS_COMMON_REMOVE,
+ &unit->status);
+ }
+ list_move(&port->list, &adapter->port_remove_lh);
+ atomic_set_mask(ZFCP_STATUS_COMMON_REMOVE, &port->status);
+ }
+ atomic_set_mask(ZFCP_STATUS_COMMON_REMOVE, &adapter->status);
+ write_unlock_irq(&zfcp_data.config_lock);
+
+ list_for_each_entry_safe(port, p, &adapter->port_remove_lh, list) {
+ list_for_each_entry_safe(unit, u, &port->unit_remove_lh, list) {
+ zfcp_unit_dequeue(unit);
+ }
+ zfcp_port_dequeue(port);
+ }
+ zfcp_adapter_wait(adapter);
+ zfcp_adapter_dequeue(adapter);
+
+ up(&zfcp_data.config_sema);
+}
+
+/**
+ * zfcp_ccw_set_online - set_online function of zfcp driver
+ * @ccw_device: pointer to belonging ccw device
+ *
+ * This function gets called by the common i/o layer and sets an adapter
+ * into state online. Setting an fcp device online means that it will be
+ * registered with the SCSI stack, that the QDIO queues will be set up
+ * and that the adapter will be opened (asynchronously).
+ */
+static int
+zfcp_ccw_set_online(struct ccw_device *ccw_device)
+{
+ struct zfcp_adapter *adapter;
+ int retval;
+
+ down(&zfcp_data.config_sema);
+ adapter = dev_get_drvdata(&ccw_device->dev);
+
+ retval = zfcp_adapter_debug_register(adapter);
+ if (retval)
+ goto out;
+ retval = zfcp_erp_thread_setup(adapter);
+ if (retval) {
+ ZFCP_LOG_INFO("error: start of error recovery thread for "
+ "adapter %s failed\n",
+ zfcp_get_busid_by_adapter(adapter));
+ goto out_erp_thread;
+ }
+
+ retval = zfcp_adapter_scsi_register(adapter);
+ if (retval)
+ goto out_scsi_register;
+ zfcp_erp_modify_adapter_status(adapter, ZFCP_STATUS_COMMON_RUNNING,
+ ZFCP_SET);
+ zfcp_erp_adapter_reopen(adapter, ZFCP_STATUS_COMMON_ERP_FAILED);
+ zfcp_erp_wait(adapter);
+ goto out;
+
+ out_scsi_register:
+ zfcp_erp_thread_kill(adapter);
+ out_erp_thread:
+ zfcp_adapter_debug_unregister(adapter);
+ out:
+ up(&zfcp_data.config_sema);
+ return retval;
+}
+
+/**
+ * zfcp_ccw_set_offline - set_offline function of zfcp driver
+ * @ccw_device: pointer to belonging ccw device
+ *
+ * This function gets called by the common i/o layer and sets an adapter
+ * into state offline. Setting an fcp device offline means that it will be
+ * unregistered from the SCSI stack and that the adapter will be shut down
+ * asynchronously.
+ */
+static int
+zfcp_ccw_set_offline(struct ccw_device *ccw_device)
+{
+ struct zfcp_adapter *adapter;
+
+ down(&zfcp_data.config_sema);
+ adapter = dev_get_drvdata(&ccw_device->dev);
+ zfcp_erp_adapter_shutdown(adapter, 0);
+ zfcp_erp_wait(adapter);
+ zfcp_adapter_scsi_unregister(adapter);
+ zfcp_erp_thread_kill(adapter);
+ zfcp_adapter_debug_unregister(adapter);
+ up(&zfcp_data.config_sema);
+ return 0;
+}
+
+/**
+ * zfcp_ccw_notify
+ * @ccw_device: pointer to belonging ccw device
+ * @event: indicates if adapter was detached or attached
+ *
+ * This function gets called by the common i/o layer if an adapter has gone
+ * or reappeared.
+ */
+static int
+zfcp_ccw_notify(struct ccw_device *ccw_device, int event)
+{
+ struct zfcp_adapter *adapter;
+
+ down(&zfcp_data.config_sema);
+ adapter = dev_get_drvdata(&ccw_device->dev);
+ switch (event) {
+ case CIO_GONE:
+ ZFCP_LOG_NORMAL("adapter %s: device gone\n",
+ zfcp_get_busid_by_adapter(adapter));
+ debug_text_event(adapter->erp_dbf,1,"dev_gone");
+ zfcp_erp_adapter_shutdown(adapter, 0);
+ break;
+ case CIO_NO_PATH:
+ ZFCP_LOG_NORMAL("adapter %s: no path\n",
+ zfcp_get_busid_by_adapter(adapter));
+ debug_text_event(adapter->erp_dbf,1,"no_path");
+ zfcp_erp_adapter_shutdown(adapter, 0);
+ break;
+ case CIO_OPER:
+ ZFCP_LOG_NORMAL("adapter %s: operational again\n",
+ zfcp_get_busid_by_adapter(adapter));
+ debug_text_event(adapter->erp_dbf,1,"dev_oper");
+ zfcp_erp_modify_adapter_status(adapter,
+ ZFCP_STATUS_COMMON_RUNNING,
+ ZFCP_SET);
+ zfcp_erp_adapter_reopen(adapter,
+ ZFCP_STATUS_COMMON_ERP_FAILED);
+ break;
+ }
+ zfcp_erp_wait(adapter);
+ up(&zfcp_data.config_sema);
+ return 1;
+}
+
+/**
+ * zfcp_ccw_register - ccw register function
+ *
+ * Registers the driver at the common i/o layer. This function will be called
+ * at module load time/system start.
+ */
+int __init
+zfcp_ccw_register(void)
+{
+ int retval;
+
+ retval = ccw_driver_register(&zfcp_ccw_driver);
+ if (retval)
+ goto out;
+ retval = zfcp_sysfs_driver_create_files(&zfcp_ccw_driver.driver);
+ if (retval)
+ ccw_driver_unregister(&zfcp_ccw_driver);
+ out:
+ return retval;
+}
+
+/**
+ * zfcp_ccw_unregister - ccw unregister function
+ *
+ * Unregisters the driver from common i/o layer. Function will be called at
+ * module unload/system shutdown.
+ */
+void __exit
+zfcp_ccw_unregister(void)
+{
+ zfcp_sysfs_driver_remove_files(&zfcp_ccw_driver.driver);
+ ccw_driver_unregister(&zfcp_ccw_driver);
+}
+
+/**
+ * zfcp_ccw_shutdown - gets called on reboot/shutdown
+ *
+ * Makes sure that QDIO queues are down when the system gets stopped.
+ */
+static void
+zfcp_ccw_shutdown(struct device *dev)
+{
+ struct zfcp_adapter *adapter;
+
+ down(&zfcp_data.config_sema);
+ adapter = dev_get_drvdata(dev);
+ zfcp_erp_adapter_shutdown(adapter, 0);
+ zfcp_erp_wait(adapter);
+ up(&zfcp_data.config_sema);
+}
+
+#undef ZFCP_LOG_AREA
diff --git a/drivers/s390/scsi/zfcp_def.h b/drivers/s390/scsi/zfcp_def.h
new file mode 100644
index 0000000..53fcccb
--- /dev/null
+++ b/drivers/s390/scsi/zfcp_def.h
@@ -0,0 +1,1121 @@
+/*
+ *
+ * linux/drivers/s390/scsi/zfcp_def.h
+ *
+ * FCP adapter driver for IBM eServer zSeries
+ *
+ * (C) Copyright IBM Corp. 2002, 2004
+ *
+ * Author(s): Martin Peschke <mpeschke@de.ibm.com>
+ * Raimund Schroeder <raimund.schroeder@de.ibm.com>
+ * Aron Zeh
+ * Wolfgang Taphorn
+ * Stefan Bader <stefan.bader@de.ibm.com>
+ * Heiko Carstens <heiko.carstens@de.ibm.com>
+ * Andreas Herrmann <aherrman@de.ibm.com>
+ * Volker Sameske <sameske@de.ibm.com>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2, or (at your option)
+ * any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+
+#ifndef ZFCP_DEF_H
+#define ZFCP_DEF_H
+
+#define ZFCP_DEF_REVISION "$Revision: 1.111 $"
+
+/*************************** INCLUDES *****************************************/
+
+#include <linux/init.h>
+#include <linux/moduleparam.h>
+#include <linux/miscdevice.h>
+#include <linux/major.h>
+#include <linux/blkdev.h>
+#include <linux/delay.h>
+#include <linux/timer.h>
+#include <scsi/scsi.h>
+#include <scsi/scsi_tcq.h>
+#include <scsi/scsi_cmnd.h>
+#include <scsi/scsi_device.h>
+#include <scsi/scsi_host.h>
+#include <scsi/scsi_transport.h>
+#include <scsi/scsi_transport_fc.h>
+#include "../../fc4/fc.h"
+#include "zfcp_fsf.h"
+#include <asm/ccwdev.h>
+#include <asm/qdio.h>
+#include <asm/debug.h>
+#include <asm/ebcdic.h>
+#include <linux/mempool.h>
+#include <linux/syscalls.h>
+#include <linux/ioctl.h>
+#include <linux/ioctl32.h>
+
+/************************ DEBUG FLAGS *****************************************/
+
+#define ZFCP_PRINT_FLAGS
+
+/********************* GENERAL DEFINES *********************************/
+
+/* zfcp version number, it consists of major, minor, and patch-level number */
+#define ZFCP_VERSION "4.2.0"
+
+/**
+ * zfcp_sg_to_address - determine kernel address from struct scatterlist
+ * @list: struct scatterlist
+ * Return: kernel address
+ */
+static inline void *
+zfcp_sg_to_address(struct scatterlist *list)
+{
+ return (void *) (page_address(list->page) + list->offset);
+}
+
+/**
+ * zfcp_address_to_sg - set up struct scatterlist from kernel address
+ * @address: kernel address
+ * @list: struct scatterlist
+ */
+static inline void
+zfcp_address_to_sg(void *address, struct scatterlist *list)
+{
+ list->page = virt_to_page(address);
+ list->offset = ((unsigned long) address) & (PAGE_SIZE - 1);
+}
+
+/********************* SCSI SPECIFIC DEFINES *********************************/
+
+/* 32 bit for SCSI ID and LUN as long as the SCSI stack uses this type */
+typedef u32 scsi_id_t;
+typedef u32 scsi_lun_t;
+
+#define ZFCP_ERP_SCSI_LOW_MEM_TIMEOUT (100*HZ)
+#define ZFCP_SCSI_ER_TIMEOUT (100*HZ)
+
+/********************* CIO/QDIO SPECIFIC DEFINES *****************************/
+
+/* Adapter Identification Parameters */
+#define ZFCP_CONTROL_UNIT_TYPE 0x1731
+#define ZFCP_CONTROL_UNIT_MODEL 0x03
+#define ZFCP_DEVICE_TYPE 0x1732
+#define ZFCP_DEVICE_MODEL 0x03
+#define ZFCP_DEVICE_MODEL_PRIV 0x04
+
+/* allow as many chained SBALs as are supported by hardware */
+#define ZFCP_MAX_SBALS_PER_REQ FSF_MAX_SBALS_PER_REQ
+#define ZFCP_MAX_SBALS_PER_CT_REQ FSF_MAX_SBALS_PER_REQ
+#define ZFCP_MAX_SBALS_PER_ELS_REQ FSF_MAX_SBALS_PER_ELS_REQ
+
+/* DMQ bug workaround: don't use last SBALE */
+#define ZFCP_MAX_SBALES_PER_SBAL (QDIO_MAX_ELEMENTS_PER_BUFFER - 1)
+
+/* index of last SBALE (with respect to DMQ bug workaround) */
+#define ZFCP_LAST_SBALE_PER_SBAL (ZFCP_MAX_SBALES_PER_SBAL - 1)
+
+/* max. number of (data buffer) SBALEs in largest SBAL chain */
+#define ZFCP_MAX_SBALES_PER_REQ \
+ (ZFCP_MAX_SBALS_PER_REQ * ZFCP_MAX_SBALES_PER_SBAL - 2)
+ /* request ID + QTCB in SBALE 0 + 1 of first SBAL in chain */
+
+/* FIXME(tune): free space should be one max. SBAL chain plus what? */
+#define ZFCP_QDIO_PCI_INTERVAL (QDIO_MAX_BUFFERS_PER_Q \
+ - (ZFCP_MAX_SBALS_PER_REQ + 4))
+
+#define ZFCP_SBAL_TIMEOUT (5*HZ)
+
+#define ZFCP_TYPE2_RECOVERY_TIME (8*HZ)
+
+/* queue polling (values in microseconds) */
+#define ZFCP_MAX_INPUT_THRESHOLD 5000 /* FIXME: tune */
+#define ZFCP_MAX_OUTPUT_THRESHOLD 1000 /* FIXME: tune */
+#define ZFCP_MIN_INPUT_THRESHOLD 1 /* ignored by QDIO layer */
+#define ZFCP_MIN_OUTPUT_THRESHOLD 1 /* ignored by QDIO layer */
+
+#define QDIO_SCSI_QFMT 1 /* 1 for FSF */
+
+/********************* FSF SPECIFIC DEFINES *********************************/
+
+#define ZFCP_ULP_INFO_VERSION 26
+#define ZFCP_QTCB_VERSION FSF_QTCB_CURRENT_VERSION
+/* ATTENTION: value must not be used by hardware */
+#define FSF_QTCB_UNSOLICITED_STATUS 0x6305
+#define ZFCP_STATUS_READ_FAILED_THRESHOLD 3
+#define ZFCP_STATUS_READS_RECOM FSF_STATUS_READS_RECOM
+#define ZFCP_EXCHANGE_CONFIG_DATA_RETRIES 6
+#define ZFCP_EXCHANGE_CONFIG_DATA_SLEEP 50
+
+/* timeout value for "default timer" for fsf requests */
+#define ZFCP_FSF_REQUEST_TIMEOUT (60*HZ);
+
+/*************** FIBRE CHANNEL PROTOCOL SPECIFIC DEFINES ********************/
+
+typedef unsigned long long wwn_t;
+typedef unsigned int fc_id_t;
+typedef unsigned long long fcp_lun_t;
+/* data length field may be at variable position in FCP-2 FCP_CMND IU */
+typedef unsigned int fcp_dl_t;
+
+#define ZFCP_FC_SERVICE_CLASS_DEFAULT FSF_CLASS_3
+
+/* timeout for name-server lookup (in seconds) */
+#define ZFCP_NS_GID_PN_TIMEOUT 10
+
+/* largest SCSI command we can process */
+/* FCP-2 (FCP_CMND IU) allows up to (255-3+16) */
+#define ZFCP_MAX_SCSI_CMND_LENGTH 255
+/* maximum number of commands in LUN queue (tagged queueing) */
+#define ZFCP_CMND_PER_LUN 32
+
+/* task attribute values in FCP-2 FCP_CMND IU */
+#define SIMPLE_Q 0
+#define HEAD_OF_Q 1
+#define ORDERED_Q 2
+#define ACA_Q 4
+#define UNTAGGED 5
+
+/* task management flags in FCP-2 FCP_CMND IU */
+#define FCP_CLEAR_ACA 0x40
+#define FCP_TARGET_RESET 0x20
+#define FCP_LOGICAL_UNIT_RESET 0x10
+#define FCP_CLEAR_TASK_SET 0x04
+#define FCP_ABORT_TASK_SET 0x02
+
+#define FCP_CDB_LENGTH 16
+
+#define ZFCP_DID_MASK 0x00FFFFFF
+
+/* FCP(-2) FCP_CMND IU */
+struct fcp_cmnd_iu {
+ fcp_lun_t fcp_lun; /* FCP logical unit number */
+ u8 crn; /* command reference number */
+ u8 reserved0:5; /* reserved */
+ u8 task_attribute:3; /* task attribute */
+ u8 task_management_flags; /* task management flags */
+ u8 add_fcp_cdb_length:6; /* additional FCP_CDB length */
+ u8 rddata:1; /* read data */
+ u8 wddata:1; /* write data */
+ u8 fcp_cdb[FCP_CDB_LENGTH];
+} __attribute__((packed));
+
+/* FCP(-2) FCP_RSP IU */
+struct fcp_rsp_iu {
+ u8 reserved0[10];
+ union {
+ struct {
+ u8 reserved1:3;
+ u8 fcp_conf_req:1;
+ u8 fcp_resid_under:1;
+ u8 fcp_resid_over:1;
+ u8 fcp_sns_len_valid:1;
+ u8 fcp_rsp_len_valid:1;
+ } bits;
+ u8 value;
+ } validity;
+ u8 scsi_status;
+ u32 fcp_resid;
+ u32 fcp_sns_len;
+ u32 fcp_rsp_len;
+} __attribute__((packed));
+
+
+#define RSP_CODE_GOOD 0
+#define RSP_CODE_LENGTH_MISMATCH 1
+#define RSP_CODE_FIELD_INVALID 2
+#define RSP_CODE_RO_MISMATCH 3
+#define RSP_CODE_TASKMAN_UNSUPP 4
+#define RSP_CODE_TASKMAN_FAILED 5
+
+/* see fc-fs */
+#define LS_FAN 0x60000000
+#define LS_RSCN 0x61040000
+
+struct fcp_rscn_head {
+ u8 command;
+ u8 page_length; /* always 0x04 */
+ u16 payload_len;
+} __attribute__((packed));
+
+struct fcp_rscn_element {
+ u8 reserved:2;
+ u8 event_qual:4;
+ u8 addr_format:2;
+ u32 nport_did:24;
+} __attribute__((packed));
+
+#define ZFCP_PORT_ADDRESS 0x0
+#define ZFCP_AREA_ADDRESS 0x1
+#define ZFCP_DOMAIN_ADDRESS 0x2
+#define ZFCP_FABRIC_ADDRESS 0x3
+
+#define ZFCP_PORTS_RANGE_PORT 0xFFFFFF
+#define ZFCP_PORTS_RANGE_AREA 0xFFFF00
+#define ZFCP_PORTS_RANGE_DOMAIN 0xFF0000
+#define ZFCP_PORTS_RANGE_FABRIC 0x000000
+
+#define ZFCP_NO_PORTS_PER_AREA 0x100
+#define ZFCP_NO_PORTS_PER_DOMAIN 0x10000
+#define ZFCP_NO_PORTS_PER_FABRIC 0x1000000
+
+struct fcp_fan {
+ u32 command;
+ u32 fport_did;
+ wwn_t fport_wwpn;
+ wwn_t fport_wwname;
+} __attribute__((packed));
+
+/* see fc-ph */
+struct fcp_logo {
+ u32 command;
+ u32 nport_did;
+ wwn_t nport_wwpn;
+} __attribute__((packed));
+
+/*
+ * FC-FS stuff
+ */
+#define R_A_TOV 10 /* seconds */
+#define ZFCP_ELS_TIMEOUT (2 * R_A_TOV)
+
+#define ZFCP_LS_RLS 0x0f
+#define ZFCP_LS_ADISC 0x52
+#define ZFCP_LS_RPS 0x56
+#define ZFCP_LS_RSCN 0x61
+#define ZFCP_LS_RNID 0x78
+
+struct zfcp_ls_rjt_par {
+ u8 action;
+ u8 reason_code;
+ u8 reason_expl;
+ u8 vendor_unique;
+} __attribute__ ((packed));
+
+struct zfcp_ls_adisc {
+ u8 code;
+ u8 field[3];
+ u32 hard_nport_id;
+ u64 wwpn;
+ u64 wwnn;
+ u32 nport_id;
+} __attribute__ ((packed));
+
+struct zfcp_ls_adisc_acc {
+ u8 code;
+ u8 field[3];
+ u32 hard_nport_id;
+ u64 wwpn;
+ u64 wwnn;
+ u32 nport_id;
+} __attribute__ ((packed));
+
+struct zfcp_rc_entry {
+ u8 code;
+ const char *description;
+};
+
+/*
+ * FC-GS-2 stuff
+ */
+#define ZFCP_CT_REVISION 0x01
+#define ZFCP_CT_DIRECTORY_SERVICE 0xFC
+#define ZFCP_CT_NAME_SERVER 0x02
+#define ZFCP_CT_SYNCHRONOUS 0x00
+#define ZFCP_CT_GID_PN 0x0121
+#define ZFCP_CT_MAX_SIZE 0x1020
+#define ZFCP_CT_ACCEPT 0x8002
+#define ZFCP_CT_REJECT 0x8001
+
+/*
+ * FC-GS-4 stuff
+ */
+#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 *****************************/
+
+/*
+ * Logging may be applied on certain kinds of driver operations
+ * independently. Additionally, different log-levels are supported for
+ * each of these areas.
+ */
+
+#define ZFCP_NAME "zfcp"
+
+/* read-only LUN sharing switch initial value */
+#define ZFCP_RO_LUN_SHARING_DEFAULTS 0
+
+/* independent log areas */
+#define ZFCP_LOG_AREA_OTHER 0
+#define ZFCP_LOG_AREA_SCSI 1
+#define ZFCP_LOG_AREA_FSF 2
+#define ZFCP_LOG_AREA_CONFIG 3
+#define ZFCP_LOG_AREA_CIO 4
+#define ZFCP_LOG_AREA_QDIO 5
+#define ZFCP_LOG_AREA_ERP 6
+#define ZFCP_LOG_AREA_FC 7
+
+/* log level values*/
+#define ZFCP_LOG_LEVEL_NORMAL 0
+#define ZFCP_LOG_LEVEL_INFO 1
+#define ZFCP_LOG_LEVEL_DEBUG 2
+#define ZFCP_LOG_LEVEL_TRACE 3
+
+/*
+ * this allows removal of logging code by the preprocessor
+ * (the most detailed log level still to be compiled in is specified,
+ * higher log levels are removed)
+ */
+#define ZFCP_LOG_LEVEL_LIMIT ZFCP_LOG_LEVEL_TRACE
+
+/* get "loglevel" nibble assignment */
+#define ZFCP_GET_LOG_VALUE(zfcp_lognibble) \
+ ((atomic_read(&zfcp_data.loglevel) >> (zfcp_lognibble<<2)) & 0xF)
+
+/* set "loglevel" nibble */
+#define ZFCP_SET_LOG_NIBBLE(value, zfcp_lognibble) \
+ (value << (zfcp_lognibble << 2))
+
+/* all log-level defaults are combined to generate initial log-level */
+#define ZFCP_LOG_LEVEL_DEFAULTS \
+ (ZFCP_SET_LOG_NIBBLE(ZFCP_LOG_LEVEL_NORMAL, ZFCP_LOG_AREA_OTHER) | \
+ ZFCP_SET_LOG_NIBBLE(ZFCP_LOG_LEVEL_NORMAL, ZFCP_LOG_AREA_SCSI) | \
+ ZFCP_SET_LOG_NIBBLE(ZFCP_LOG_LEVEL_NORMAL, ZFCP_LOG_AREA_FSF) | \
+ ZFCP_SET_LOG_NIBBLE(ZFCP_LOG_LEVEL_NORMAL, ZFCP_LOG_AREA_CONFIG) | \
+ ZFCP_SET_LOG_NIBBLE(ZFCP_LOG_LEVEL_NORMAL, ZFCP_LOG_AREA_CIO) | \
+ ZFCP_SET_LOG_NIBBLE(ZFCP_LOG_LEVEL_NORMAL, ZFCP_LOG_AREA_QDIO) | \
+ ZFCP_SET_LOG_NIBBLE(ZFCP_LOG_LEVEL_NORMAL, ZFCP_LOG_AREA_ERP) | \
+ ZFCP_SET_LOG_NIBBLE(ZFCP_LOG_LEVEL_NORMAL, ZFCP_LOG_AREA_FC))
+
+/* check whether we have the right level for logging */
+#define ZFCP_LOG_CHECK(level) \
+ ((ZFCP_GET_LOG_VALUE(ZFCP_LOG_AREA)) >= level)
+
+/* logging routine for zfcp */
+#define _ZFCP_LOG(fmt, args...) \
+ printk(KERN_ERR ZFCP_NAME": %s(%d): " fmt, __FUNCTION__, \
+ __LINE__ , ##args)
+
+#define ZFCP_LOG(level, fmt, args...) \
+do { \
+ if (ZFCP_LOG_CHECK(level)) \
+ _ZFCP_LOG(fmt, ##args); \
+} while (0)
+
+#if ZFCP_LOG_LEVEL_LIMIT < ZFCP_LOG_LEVEL_NORMAL
+# define ZFCP_LOG_NORMAL(fmt, args...)
+#else
+# define ZFCP_LOG_NORMAL(fmt, args...) \
+do { \
+ if (ZFCP_LOG_CHECK(ZFCP_LOG_LEVEL_NORMAL)) \
+ printk(KERN_ERR ZFCP_NAME": " fmt, ##args); \
+} while (0)
+#endif
+
+#if ZFCP_LOG_LEVEL_LIMIT < ZFCP_LOG_LEVEL_INFO
+# define ZFCP_LOG_INFO(fmt, args...)
+#else
+# define ZFCP_LOG_INFO(fmt, args...) \
+do { \
+ if (ZFCP_LOG_CHECK(ZFCP_LOG_LEVEL_INFO)) \
+ printk(KERN_ERR ZFCP_NAME": " fmt, ##args); \
+} while (0)
+#endif
+
+#if ZFCP_LOG_LEVEL_LIMIT < ZFCP_LOG_LEVEL_DEBUG
+# define ZFCP_LOG_DEBUG(fmt, args...)
+#else
+# define ZFCP_LOG_DEBUG(fmt, args...) \
+ ZFCP_LOG(ZFCP_LOG_LEVEL_DEBUG, fmt , ##args)
+#endif
+
+#if ZFCP_LOG_LEVEL_LIMIT < ZFCP_LOG_LEVEL_TRACE
+# define ZFCP_LOG_TRACE(fmt, args...)
+#else
+# define ZFCP_LOG_TRACE(fmt, args...) \
+ ZFCP_LOG(ZFCP_LOG_LEVEL_TRACE, fmt , ##args)
+#endif
+
+#ifndef ZFCP_PRINT_FLAGS
+# define ZFCP_LOG_FLAGS(level, fmt, args...)
+#else
+extern u32 flags_dump;
+# define ZFCP_LOG_FLAGS(level, fmt, args...) \
+do { \
+ if (level <= flags_dump) \
+ _ZFCP_LOG(fmt, ##args); \
+} while (0)
+#endif
+
+/*************** ADAPTER/PORT/UNIT AND FSF_REQ STATUS FLAGS ******************/
+
+/*
+ * Note, the leftmost status byte is common among adapter, port
+ * and unit
+ */
+#define ZFCP_COMMON_FLAGS 0xfff00000
+#define ZFCP_SPECIFIC_FLAGS 0x000fffff
+
+/* common status bits */
+#define ZFCP_STATUS_COMMON_REMOVE 0x80000000
+#define ZFCP_STATUS_COMMON_RUNNING 0x40000000
+#define ZFCP_STATUS_COMMON_ERP_FAILED 0x20000000
+#define ZFCP_STATUS_COMMON_UNBLOCKED 0x10000000
+#define ZFCP_STATUS_COMMON_OPENING 0x08000000
+#define ZFCP_STATUS_COMMON_OPEN 0x04000000
+#define ZFCP_STATUS_COMMON_CLOSING 0x02000000
+#define ZFCP_STATUS_COMMON_ERP_INUSE 0x01000000
+#define ZFCP_STATUS_COMMON_ACCESS_DENIED 0x00800000
+
+/* adapter status */
+#define ZFCP_STATUS_ADAPTER_QDIOUP 0x00000002
+#define ZFCP_STATUS_ADAPTER_REGISTERED 0x00000004
+#define ZFCP_STATUS_ADAPTER_XCONFIG_OK 0x00000008
+#define ZFCP_STATUS_ADAPTER_HOST_CON_INIT 0x00000010
+#define ZFCP_STATUS_ADAPTER_ERP_THREAD_UP 0x00000020
+#define ZFCP_STATUS_ADAPTER_ERP_THREAD_KILL 0x00000080
+#define ZFCP_STATUS_ADAPTER_ERP_PENDING 0x00000100
+#define ZFCP_STATUS_ADAPTER_LINK_UNPLUGGED 0x00000200
+
+#define ZFCP_STATUS_ADAPTER_SCSI_UP \
+ (ZFCP_STATUS_COMMON_UNBLOCKED | \
+ ZFCP_STATUS_ADAPTER_REGISTERED)
+
+
+/* FC-PH/FC-GS well-known address identifiers for generic services */
+#define ZFCP_DID_MANAGEMENT_SERVICE 0xFFFFFA
+#define ZFCP_DID_TIME_SERVICE 0xFFFFFB
+#define ZFCP_DID_DIRECTORY_SERVICE 0xFFFFFC
+#define ZFCP_DID_ALIAS_SERVICE 0xFFFFF8
+#define ZFCP_DID_KEY_DISTRIBUTION_SERVICE 0xFFFFF7
+
+/* remote port status */
+#define ZFCP_STATUS_PORT_PHYS_OPEN 0x00000001
+#define ZFCP_STATUS_PORT_DID_DID 0x00000002
+#define ZFCP_STATUS_PORT_PHYS_CLOSING 0x00000004
+#define ZFCP_STATUS_PORT_NO_WWPN 0x00000008
+#define ZFCP_STATUS_PORT_NO_SCSI_ID 0x00000010
+#define ZFCP_STATUS_PORT_INVALID_WWPN 0x00000020
+#define ZFCP_STATUS_PORT_ACCESS_DENIED 0x00000040
+
+/* for ports with well known addresses */
+#define ZFCP_STATUS_PORT_WKA \
+ (ZFCP_STATUS_PORT_NO_WWPN | \
+ ZFCP_STATUS_PORT_NO_SCSI_ID)
+
+/* logical unit status */
+#define ZFCP_STATUS_UNIT_NOTSUPPUNITRESET 0x00000001
+#define ZFCP_STATUS_UNIT_TEMPORARY 0x00000002
+#define ZFCP_STATUS_UNIT_SHARED 0x00000004
+#define ZFCP_STATUS_UNIT_READONLY 0x00000008
+
+/* FSF request status (this does not have a common part) */
+#define ZFCP_STATUS_FSFREQ_NOT_INIT 0x00000000
+#define ZFCP_STATUS_FSFREQ_POOL 0x00000001
+#define ZFCP_STATUS_FSFREQ_TASK_MANAGEMENT 0x00000002
+#define ZFCP_STATUS_FSFREQ_COMPLETED 0x00000004
+#define ZFCP_STATUS_FSFREQ_ERROR 0x00000008
+#define ZFCP_STATUS_FSFREQ_CLEANUP 0x00000010
+#define ZFCP_STATUS_FSFREQ_ABORTING 0x00000020
+#define ZFCP_STATUS_FSFREQ_ABORTSUCCEEDED 0x00000040
+#define ZFCP_STATUS_FSFREQ_ABORTNOTNEEDED 0x00000080
+#define ZFCP_STATUS_FSFREQ_ABORTED 0x00000100
+#define ZFCP_STATUS_FSFREQ_TMFUNCFAILED 0x00000200
+#define ZFCP_STATUS_FSFREQ_TMFUNCNOTSUPP 0x00000400
+#define ZFCP_STATUS_FSFREQ_RETRY 0x00000800
+#define ZFCP_STATUS_FSFREQ_DISMISSED 0x00001000
+
+/*********************** ERROR RECOVERY PROCEDURE DEFINES ********************/
+
+#define ZFCP_MAX_ERPS 3
+
+#define ZFCP_ERP_FSFREQ_TIMEOUT (30 * HZ)
+#define ZFCP_ERP_MEMWAIT_TIMEOUT HZ
+
+#define ZFCP_STATUS_ERP_TIMEDOUT 0x10000000
+#define ZFCP_STATUS_ERP_CLOSE_ONLY 0x01000000
+#define ZFCP_STATUS_ERP_DISMISSING 0x00100000
+#define ZFCP_STATUS_ERP_DISMISSED 0x00200000
+#define ZFCP_STATUS_ERP_LOWMEM 0x00400000
+
+#define ZFCP_ERP_STEP_UNINITIALIZED 0x00000000
+#define ZFCP_ERP_STEP_FSF_XCONFIG 0x00000001
+#define ZFCP_ERP_STEP_PHYS_PORT_CLOSING 0x00000010
+#define ZFCP_ERP_STEP_PORT_CLOSING 0x00000100
+#define ZFCP_ERP_STEP_NAMESERVER_OPEN 0x00000200
+#define ZFCP_ERP_STEP_NAMESERVER_LOOKUP 0x00000400
+#define ZFCP_ERP_STEP_PORT_OPENING 0x00000800
+#define ZFCP_ERP_STEP_UNIT_CLOSING 0x00001000
+#define ZFCP_ERP_STEP_UNIT_OPENING 0x00002000
+
+/* Ordered by escalation level (necessary for proper erp-code operation) */
+#define ZFCP_ERP_ACTION_REOPEN_ADAPTER 0x4
+#define ZFCP_ERP_ACTION_REOPEN_PORT_FORCED 0x3
+#define ZFCP_ERP_ACTION_REOPEN_PORT 0x2
+#define ZFCP_ERP_ACTION_REOPEN_UNIT 0x1
+
+#define ZFCP_ERP_ACTION_RUNNING 0x1
+#define ZFCP_ERP_ACTION_READY 0x2
+
+#define ZFCP_ERP_SUCCEEDED 0x0
+#define ZFCP_ERP_FAILED 0x1
+#define ZFCP_ERP_CONTINUES 0x2
+#define ZFCP_ERP_EXIT 0x3
+#define ZFCP_ERP_DISMISSED 0x4
+#define ZFCP_ERP_NOMEM 0x5
+
+
+/******************** CFDC SPECIFIC STUFF *****************************/
+
+/* Firewall data channel sense data record */
+struct zfcp_cfdc_sense_data {
+ u32 signature; /* Request signature */
+ u32 devno; /* FCP adapter device number */
+ u32 command; /* Command code */
+ u32 fsf_status; /* FSF request status and status qualifier */
+ u8 fsf_status_qual[FSF_STATUS_QUALIFIER_SIZE];
+ u8 payloads[256]; /* Access conflicts list */
+ u8 control_file[0]; /* Access control table */
+};
+
+#define ZFCP_CFDC_SIGNATURE 0xCFDCACDF
+
+#define ZFCP_CFDC_CMND_DOWNLOAD_NORMAL 0x00010001
+#define ZFCP_CFDC_CMND_DOWNLOAD_FORCE 0x00010101
+#define ZFCP_CFDC_CMND_FULL_ACCESS 0x00000201
+#define ZFCP_CFDC_CMND_RESTRICTED_ACCESS 0x00000401
+#define ZFCP_CFDC_CMND_UPLOAD 0x00010002
+
+#define ZFCP_CFDC_DOWNLOAD 0x00000001
+#define ZFCP_CFDC_UPLOAD 0x00000002
+#define ZFCP_CFDC_WITH_CONTROL_FILE 0x00010000
+
+#define ZFCP_CFDC_DEV_NAME "zfcp_cfdc"
+#define ZFCP_CFDC_DEV_MAJOR MISC_MAJOR
+#define ZFCP_CFDC_DEV_MINOR MISC_DYNAMIC_MINOR
+
+#define ZFCP_CFDC_MAX_CONTROL_FILE_SIZE 127 * 1024
+
+/************************* STRUCTURE DEFINITIONS *****************************/
+
+struct zfcp_fsf_req;
+
+/* holds various memory pools of an adapter */
+struct zfcp_adapter_mempool {
+ mempool_t *fsf_req_erp;
+ mempool_t *fsf_req_scsi;
+ mempool_t *fsf_req_abort;
+ mempool_t *fsf_req_status_read;
+ mempool_t *data_status_read;
+ 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
+ */
+struct ct_hdr {
+ u8 revision; // 0x01
+ u8 in_id[3]; // 0x00
+ u8 gs_type; // 0xFC Directory Service
+ u8 gs_subtype; // 0x02 Name Server
+ u8 options; // 0x00 single bidirectional exchange
+ u8 reserved0;
+ u16 cmd_rsp_code; // 0x0121 GID_PN, or 0x0100 GA_NXT
+ u16 max_res_size; // <= (4096 - 16) / 4
+ u8 reserved1;
+ u8 reason_code;
+ u8 reason_code_expl;
+ u8 vendor_unique;
+} __attribute__ ((packed));
+
+/* nameserver request CT_IU -- for requests where
+ * a port name is required */
+struct ct_iu_gid_pn_req {
+ struct ct_hdr header;
+ wwn_t wwpn;
+} __attribute__ ((packed));
+
+/* FS_ACC IU and data unit for GID_PN nameserver request */
+struct ct_iu_gid_pn_resp {
+ struct ct_hdr header;
+ fc_id_t d_id;
+} __attribute__ ((packed));
+
+typedef void (*zfcp_send_ct_handler_t)(unsigned long);
+
+/**
+ * struct zfcp_send_ct - used to pass parameters to function zfcp_fsf_send_ct
+ * @port: port where the request is sent to
+ * @req: scatter-gather list for request
+ * @resp: scatter-gather list for response
+ * @req_count: number of elements in request scatter-gather list
+ * @resp_count: number of elements in response scatter-gather list
+ * @handler: handler function (called for response to the request)
+ * @handler_data: data passed to handler function
+ * @pool: pointer to memory pool for ct request structure
+ * @timeout: FSF timeout for this request
+ * @timer: timer (e.g. for request initiated by erp)
+ * @completion: completion for synchronization purposes
+ * @status: used to pass error status to calling function
+ */
+struct zfcp_send_ct {
+ struct zfcp_port *port;
+ struct scatterlist *req;
+ struct scatterlist *resp;
+ unsigned int req_count;
+ unsigned int resp_count;
+ zfcp_send_ct_handler_t handler;
+ unsigned long handler_data;
+ mempool_t *pool;
+ int timeout;
+ struct timer_list *timer;
+ struct completion *completion;
+ int status;
+};
+
+/* used for name server requests in error recovery */
+struct zfcp_gid_pn_data {
+ struct zfcp_send_ct ct;
+ struct scatterlist req;
+ struct scatterlist resp;
+ struct ct_iu_gid_pn_req ct_iu_req;
+ struct ct_iu_gid_pn_resp ct_iu_resp;
+ struct zfcp_port *port;
+};
+
+typedef void (*zfcp_send_els_handler_t)(unsigned long);
+
+/**
+ * struct zfcp_send_els - used to pass parameters to function zfcp_fsf_send_els
+ * @adapter: adapter where request is sent from
+ * @d_id: destiniation id of port where request is sent to
+ * @req: scatter-gather list for request
+ * @resp: scatter-gather list for response
+ * @req_count: number of elements in request scatter-gather list
+ * @resp_count: number of elements in response scatter-gather list
+ * @handler: handler function (called for response to the request)
+ * @handler_data: data passed to handler function
+ * @timer: timer (e.g. for request initiated by erp)
+ * @completion: completion for synchronization purposes
+ * @ls_code: hex code of ELS command
+ * @status: used to pass error status to calling function
+ */
+struct zfcp_send_els {
+ struct zfcp_adapter *adapter;
+ fc_id_t d_id;
+ struct scatterlist *req;
+ struct scatterlist *resp;
+ unsigned int req_count;
+ unsigned int resp_count;
+ zfcp_send_els_handler_t handler;
+ unsigned long handler_data;
+ struct timer_list *timer;
+ struct completion *completion;
+ int ls_code;
+ 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
+ in queue (free_count>0) */
+ atomic_t free_count; /* number of free buffers
+ in queue */
+ rwlock_t queue_lock; /* lock for operations on queue */
+ int distance_from_int; /* SBALs used since PCI indication
+ was last set */
+};
+
+struct zfcp_erp_action {
+ struct list_head list;
+ int action; /* requested action code */
+ struct zfcp_adapter *adapter; /* device which should be recovered */
+ struct zfcp_port *port;
+ struct zfcp_unit *unit;
+ volatile u32 status; /* recovery status */
+ u32 step; /* active step of this erp action */
+ struct zfcp_fsf_req *fsf_req; /* fsf request currently pending
+ for this action */
+ struct timer_list timer;
+};
+
+
+struct zfcp_adapter {
+ struct list_head list; /* list of adapters */
+ atomic_t refcount; /* reference count */
+ wait_queue_head_t remove_wq; /* can be used to wait for
+ refcount drop to zero */
+ wwn_t wwnn; /* WWNN */
+ wwn_t wwpn; /* WWPN */
+ fc_id_t s_id; /* N_Port ID */
+ struct ccw_device *ccw_device; /* S/390 ccw device */
+ u8 fc_service_class;
+ u32 fc_topology; /* FC topology */
+ u32 fc_link_speed; /* FC interface speed */
+ u32 hydra_version; /* Hydra version */
+ u32 fsf_lic_version;
+ u32 supported_features;/* of FCP channel */
+ u32 hardware_version; /* of FCP channel */
+ u8 serial_number[32]; /* of hardware */
+ struct Scsi_Host *scsi_host; /* Pointer to mid-layer */
+ unsigned short scsi_host_no; /* Assigned host number */
+ unsigned char name[9];
+ struct list_head port_list_head; /* remote port list */
+ struct list_head port_remove_lh; /* head of ports to be
+ removed */
+ u32 ports; /* number of remote ports */
+ struct timer_list scsi_er_timer; /* SCSI err recovery watch */
+ struct list_head fsf_req_list_head; /* head of FSF req list */
+ rwlock_t fsf_req_list_lock; /* lock for ops on list of
+ FSF requests */
+ atomic_t fsf_reqs_active; /* # active FSF reqs */
+ struct zfcp_qdio_queue request_queue; /* request queue */
+ u32 fsf_req_seq_no; /* FSF cmnd seq number */
+ wait_queue_head_t request_wq; /* can be used to wait for
+ more avaliable SBALs */
+ struct zfcp_qdio_queue response_queue; /* response queue */
+ rwlock_t abort_lock; /* Protects against SCSI
+ stack abort/command
+ completion races */
+ u16 status_read_failed; /* # failed status reads */
+ atomic_t status; /* status of this adapter */
+ struct list_head erp_ready_head; /* error recovery for this
+ adapter/devices */
+ struct list_head erp_running_head;
+ rwlock_t erp_lock;
+ struct semaphore erp_ready_sem;
+ wait_queue_head_t erp_thread_wqh;
+ wait_queue_head_t erp_done_wqh;
+ struct zfcp_erp_action erp_action; /* pending error recovery */
+ atomic_t erp_counter;
+ u32 erp_total_count; /* total nr of enqueued erp
+ actions */
+ 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;
+ 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 */
+};
+
+/*
+ * the struct device sysfs_device must be at the beginning of this structure.
+ * pointer to struct device is used to free port structure in release function
+ * of the device. don't change!
+ */
+struct zfcp_port {
+ struct device sysfs_device; /* sysfs device */
+ struct list_head list; /* list of remote ports */
+ atomic_t refcount; /* reference count */
+ wait_queue_head_t remove_wq; /* can be used to wait for
+ refcount drop to zero */
+ struct zfcp_adapter *adapter; /* adapter used to access port */
+ struct list_head unit_list_head; /* head of logical unit list */
+ struct list_head unit_remove_lh; /* head of luns to be removed
+ list */
+ u32 units; /* # of logical units in list */
+ atomic_t status; /* status of this remote port */
+ scsi_id_t scsi_id; /* own SCSI ID */
+ wwn_t wwnn; /* WWNN if known */
+ wwn_t wwpn; /* WWPN */
+ fc_id_t d_id; /* D_ID */
+ u32 handle; /* handle assigned by FSF */
+ struct zfcp_erp_action erp_action; /* pending error recovery */
+ atomic_t erp_counter;
+};
+
+/* the struct device sysfs_device must be at the beginning of this structure.
+ * pointer to struct device is used to free unit structure in release function
+ * of the device. don't change!
+ */
+struct zfcp_unit {
+ struct device sysfs_device; /* sysfs device */
+ struct list_head list; /* list of logical units */
+ atomic_t refcount; /* reference count */
+ wait_queue_head_t remove_wq; /* can be used to wait for
+ refcount drop to zero */
+ struct zfcp_port *port; /* remote port of unit */
+ atomic_t status; /* status of this logical unit */
+ scsi_lun_t scsi_lun; /* own SCSI LUN */
+ fcp_lun_t fcp_lun; /* own FCP_LUN */
+ u32 handle; /* handle assigned by FSF */
+ struct scsi_device *device; /* scsi device struct pointer */
+ struct zfcp_erp_action erp_action; /* pending error recovery */
+ atomic_t erp_counter;
+};
+
+/* FSF request */
+struct zfcp_fsf_req {
+ struct list_head list; /* list of FSF requests */
+ struct zfcp_adapter *adapter; /* adapter request belongs to */
+ u8 sbal_number; /* nr of SBALs free for use */
+ u8 sbal_first; /* first SBAL for this request */
+ u8 sbal_last; /* last possible SBAL for
+ this reuest */
+ u8 sbal_curr; /* current SBAL during creation
+ of request */
+ u8 sbale_curr; /* current SBALE during creation
+ of request */
+ wait_queue_head_t completion_wq; /* can be used by a routine
+ to wait for completion */
+ volatile u32 status; /* status of this request */
+ 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 */
+ 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 */
+};
+
+typedef void zfcp_fsf_req_handler_t(struct zfcp_fsf_req*);
+
+/* driver data */
+struct zfcp_data {
+ struct scsi_host_template scsi_host_template;
+ atomic_t status; /* Module status flags */
+ struct list_head adapter_list_head; /* head of adapter list */
+ struct list_head adapter_remove_lh; /* head of adapters to be
+ removed */
+ rwlock_t status_read_lock; /* for status read thread */
+ struct list_head status_read_receive_head;
+ struct list_head status_read_send_head;
+ struct semaphore status_read_sema;
+ wait_queue_head_t status_read_thread_wqh;
+ u32 adapters; /* # of adapters in list */
+ rwlock_t config_lock; /* serialises changes
+ to adapter/port/unit
+ lists */
+ struct semaphore config_sema; /* serialises configuration
+ changes */
+ atomic_t loglevel; /* current loglevel */
+ char init_busid[BUS_ID_SIZE];
+ wwn_t init_wwpn;
+ fcp_lun_t init_fcp_lun;
+ char *driver_version;
+};
+
+/**
+ * struct zfcp_sg_list - struct describing a scatter-gather list
+ * @sg: pointer to array of (struct scatterlist)
+ * @count: number of elements in scatter-gather list
+ */
+struct zfcp_sg_list {
+ struct scatterlist *sg;
+ unsigned int count;
+};
+
+/* number of elements for various memory pools */
+#define ZFCP_POOL_FSF_REQ_ERP_NR 1
+#define ZFCP_POOL_FSF_REQ_SCSI_NR 1
+#define ZFCP_POOL_FSF_REQ_ABORT_NR 1
+#define ZFCP_POOL_STATUS_READ_NR ZFCP_STATUS_READS_RECOM
+#define ZFCP_POOL_DATA_GID_PN_NR 1
+
+/* struct used by memory pools for fsf_requests */
+struct zfcp_fsf_req_pool_element {
+ struct zfcp_fsf_req fsf_req;
+ struct fsf_qtcb qtcb;
+};
+
+/********************** ZFCP SPECIFIC DEFINES ********************************/
+
+#define ZFCP_FSFREQ_CLEANUP_TIMEOUT HZ/10
+
+#define ZFCP_KNOWN 0x00000001
+#define ZFCP_REQ_AUTO_CLEANUP 0x00000002
+#define ZFCP_WAIT_FOR_SBAL 0x00000004
+#define ZFCP_REQ_NO_QTCB 0x00000008
+
+#define ZFCP_SET 0x00000100
+#define ZFCP_CLEAR 0x00000200
+
+#define ZFCP_INTERRUPTIBLE 1
+#define ZFCP_UNINTERRUPTIBLE 0
+
+#ifndef atomic_test_mask
+#define atomic_test_mask(mask, target) \
+ ((atomic_read(target) & mask) == mask)
+#endif
+
+extern void _zfcp_hex_dump(char *, int);
+#define ZFCP_HEX_DUMP(level, addr, count) \
+ if (ZFCP_LOG_CHECK(level)) { \
+ _zfcp_hex_dump(addr, count); \
+ }
+
+#define zfcp_get_busid_by_adapter(adapter) (adapter->ccw_device->dev.bus_id)
+#define zfcp_get_busid_by_port(port) (zfcp_get_busid_by_adapter(port->adapter))
+#define zfcp_get_busid_by_unit(unit) (zfcp_get_busid_by_port(unit->port))
+
+/*
+ * functions needed for reference/usage counting
+ */
+
+static inline void
+zfcp_unit_get(struct zfcp_unit *unit)
+{
+ atomic_inc(&unit->refcount);
+}
+
+static inline void
+zfcp_unit_put(struct zfcp_unit *unit)
+{
+ if (atomic_dec_return(&unit->refcount) == 0)
+ wake_up(&unit->remove_wq);
+}
+
+static inline void
+zfcp_unit_wait(struct zfcp_unit *unit)
+{
+ wait_event(unit->remove_wq, atomic_read(&unit->refcount) == 0);
+}
+
+static inline void
+zfcp_port_get(struct zfcp_port *port)
+{
+ atomic_inc(&port->refcount);
+}
+
+static inline void
+zfcp_port_put(struct zfcp_port *port)
+{
+ if (atomic_dec_return(&port->refcount) == 0)
+ wake_up(&port->remove_wq);
+}
+
+static inline void
+zfcp_port_wait(struct zfcp_port *port)
+{
+ wait_event(port->remove_wq, atomic_read(&port->refcount) == 0);
+}
+
+static inline void
+zfcp_adapter_get(struct zfcp_adapter *adapter)
+{
+ atomic_inc(&adapter->refcount);
+}
+
+static inline void
+zfcp_adapter_put(struct zfcp_adapter *adapter)
+{
+ if (atomic_dec_return(&adapter->refcount) == 0)
+ wake_up(&adapter->remove_wq);
+}
+
+static inline void
+zfcp_adapter_wait(struct zfcp_adapter *adapter)
+{
+ wait_event(adapter->remove_wq, atomic_read(&adapter->refcount) == 0);
+}
+
+#endif /* ZFCP_DEF_H */
diff --git a/drivers/s390/scsi/zfcp_erp.c b/drivers/s390/scsi/zfcp_erp.c
new file mode 100644
index 0000000..cfc0d8c
--- /dev/null
+++ b/drivers/s390/scsi/zfcp_erp.c
@@ -0,0 +1,3585 @@
+/*
+ *
+ * linux/drivers/s390/scsi/zfcp_erp.c
+ *
+ * FCP adapter driver for IBM eServer zSeries
+ *
+ * (C) Copyright IBM Corp. 2002, 2004
+ *
+ * Author(s): Martin Peschke <mpeschke@de.ibm.com>
+ * Raimund Schroeder <raimund.schroeder@de.ibm.com>
+ * Aron Zeh
+ * Wolfgang Taphorn
+ * Stefan Bader <stefan.bader@de.ibm.com>
+ * Heiko Carstens <heiko.carstens@de.ibm.com>
+ * Andreas Herrmann <aherrman@de.ibm.com>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2, or (at your option)
+ * any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#define ZFCP_LOG_AREA ZFCP_LOG_AREA_ERP
+
+#define ZFCP_ERP_REVISION "$Revision: 1.86 $"
+
+#include "zfcp_ext.h"
+
+static int zfcp_erp_adisc(struct zfcp_adapter *, fc_id_t);
+static void zfcp_erp_adisc_handler(unsigned long);
+
+static int zfcp_erp_adapter_reopen_internal(struct zfcp_adapter *, int);
+static int zfcp_erp_port_forced_reopen_internal(struct zfcp_port *, int);
+static int zfcp_erp_port_reopen_internal(struct zfcp_port *, int);
+static int zfcp_erp_unit_reopen_internal(struct zfcp_unit *, int);
+
+static int zfcp_erp_port_reopen_all_internal(struct zfcp_adapter *, int);
+static int zfcp_erp_unit_reopen_all_internal(struct zfcp_port *, int);
+
+static void zfcp_erp_adapter_block(struct zfcp_adapter *, int);
+static void zfcp_erp_adapter_unblock(struct zfcp_adapter *);
+static void zfcp_erp_port_block(struct zfcp_port *, int);
+static void zfcp_erp_port_unblock(struct zfcp_port *);
+static void zfcp_erp_unit_block(struct zfcp_unit *, int);
+static void zfcp_erp_unit_unblock(struct zfcp_unit *);
+
+static int zfcp_erp_thread(void *);
+
+static int zfcp_erp_strategy(struct zfcp_erp_action *);
+
+static int zfcp_erp_strategy_do_action(struct zfcp_erp_action *);
+static int zfcp_erp_strategy_memwait(struct zfcp_erp_action *);
+static int zfcp_erp_strategy_check_target(struct zfcp_erp_action *, int);
+static int zfcp_erp_strategy_check_unit(struct zfcp_unit *, int);
+static int zfcp_erp_strategy_check_port(struct zfcp_port *, int);
+static int zfcp_erp_strategy_check_adapter(struct zfcp_adapter *, int);
+static int zfcp_erp_strategy_statechange(int, u32, struct zfcp_adapter *,
+ struct zfcp_port *,
+ struct zfcp_unit *, int);
+static inline int zfcp_erp_strategy_statechange_detected(atomic_t *, u32);
+static int zfcp_erp_strategy_followup_actions(int, struct zfcp_adapter *,
+ struct zfcp_port *,
+ struct zfcp_unit *, int);
+static int zfcp_erp_strategy_check_queues(struct zfcp_adapter *);
+static int zfcp_erp_strategy_check_action(struct zfcp_erp_action *, int);
+
+static int zfcp_erp_adapter_strategy(struct zfcp_erp_action *);
+static int zfcp_erp_adapter_strategy_generic(struct zfcp_erp_action *, int);
+static int zfcp_erp_adapter_strategy_close(struct zfcp_erp_action *);
+static int zfcp_erp_adapter_strategy_close_qdio(struct zfcp_erp_action *);
+static int zfcp_erp_adapter_strategy_close_fsf(struct zfcp_erp_action *);
+static int zfcp_erp_adapter_strategy_open(struct zfcp_erp_action *);
+static int zfcp_erp_adapter_strategy_open_qdio(struct zfcp_erp_action *);
+static int zfcp_erp_adapter_strategy_open_fsf(struct zfcp_erp_action *);
+static int zfcp_erp_adapter_strategy_open_fsf_xconfig(struct zfcp_erp_action *);
+static int zfcp_erp_adapter_strategy_open_fsf_statusread(
+ struct zfcp_erp_action *);
+
+static int zfcp_erp_port_forced_strategy(struct zfcp_erp_action *);
+static int zfcp_erp_port_forced_strategy_close(struct zfcp_erp_action *);
+
+static int zfcp_erp_port_strategy(struct zfcp_erp_action *);
+static int zfcp_erp_port_strategy_clearstati(struct zfcp_port *);
+static int zfcp_erp_port_strategy_close(struct zfcp_erp_action *);
+static int zfcp_erp_port_strategy_open(struct zfcp_erp_action *);
+static int zfcp_erp_port_strategy_open_nameserver(struct zfcp_erp_action *);
+static int zfcp_erp_port_strategy_open_nameserver_wakeup(
+ struct zfcp_erp_action *);
+static int zfcp_erp_port_strategy_open_common(struct zfcp_erp_action *);
+static int zfcp_erp_port_strategy_open_common_lookup(struct zfcp_erp_action *);
+static int zfcp_erp_port_strategy_open_port(struct zfcp_erp_action *);
+
+static int zfcp_erp_unit_strategy(struct zfcp_erp_action *);
+static int zfcp_erp_unit_strategy_clearstati(struct zfcp_unit *);
+static int zfcp_erp_unit_strategy_close(struct zfcp_erp_action *);
+static int zfcp_erp_unit_strategy_open(struct zfcp_erp_action *);
+
+static int zfcp_erp_action_dismiss_adapter(struct zfcp_adapter *);
+static int zfcp_erp_action_dismiss_port(struct zfcp_port *);
+static int zfcp_erp_action_dismiss_unit(struct zfcp_unit *);
+static int zfcp_erp_action_dismiss(struct zfcp_erp_action *);
+
+static int zfcp_erp_action_enqueue(int, struct zfcp_adapter *,
+ struct zfcp_port *, struct zfcp_unit *);
+static int zfcp_erp_action_dequeue(struct zfcp_erp_action *);
+static void zfcp_erp_action_cleanup(int, struct zfcp_adapter *,
+ struct zfcp_port *, struct zfcp_unit *,
+ int);
+
+static void zfcp_erp_action_ready(struct zfcp_erp_action *);
+static int zfcp_erp_action_exists(struct zfcp_erp_action *);
+
+static inline void zfcp_erp_action_to_ready(struct zfcp_erp_action *);
+static inline void zfcp_erp_action_to_running(struct zfcp_erp_action *);
+
+static void zfcp_erp_memwait_handler(unsigned long);
+static void zfcp_erp_timeout_handler(unsigned long);
+static inline void zfcp_erp_timeout_init(struct zfcp_erp_action *);
+
+/**
+ * zfcp_fsf_request_timeout_handler - called if a request timed out
+ * @data: pointer to adapter for handler function
+ *
+ * This function needs to be called if requests (ELS, Generic Service,
+ * or SCSI commands) exceed a certain time limit. The assumption is
+ * that after the time limit the adapter get stuck. So we trigger a reopen of
+ * the adapter. This should not be used for error recovery, SCSI abort
+ * commands and SCSI requests from SCSI mid-layer.
+ */
+void
+zfcp_fsf_request_timeout_handler(unsigned long data)
+{
+ struct zfcp_adapter *adapter;
+
+ adapter = (struct zfcp_adapter *) data;
+
+ zfcp_erp_adapter_reopen(adapter, 0);
+}
+
+/*
+ * function: zfcp_fsf_scsi_er_timeout_handler
+ *
+ * purpose: This function needs to be called whenever a SCSI error recovery
+ * action (abort/reset) does not return.
+ * Re-opening the adapter means that the command can be returned
+ * by zfcp (it is guarranteed that it does not return via the
+ * adapter anymore). The buffer can then be used again.
+ *
+ * returns: sod all
+ */
+void
+zfcp_fsf_scsi_er_timeout_handler(unsigned long data)
+{
+ struct zfcp_adapter *adapter = (struct zfcp_adapter *) data;
+
+ ZFCP_LOG_NORMAL("warning: SCSI error recovery timed out. "
+ "Restarting all operations on the adapter %s\n",
+ zfcp_get_busid_by_adapter(adapter));
+ debug_text_event(adapter->erp_dbf, 1, "eh_lmem_tout");
+ zfcp_erp_adapter_reopen(adapter, 0);
+
+ return;
+}
+
+/*
+ * function:
+ *
+ * purpose: called if an adapter failed,
+ * initiates adapter recovery which is done
+ * asynchronously
+ *
+ * returns: 0 - initiated action succesfully
+ * <0 - failed to initiate action
+ */
+int
+zfcp_erp_adapter_reopen_internal(struct zfcp_adapter *adapter, int clear_mask)
+{
+ int retval;
+
+ debug_text_event(adapter->erp_dbf, 5, "a_ro");
+ ZFCP_LOG_DEBUG("reopen adapter %s\n",
+ zfcp_get_busid_by_adapter(adapter));
+
+ zfcp_erp_adapter_block(adapter, clear_mask);
+
+ if (atomic_test_mask(ZFCP_STATUS_COMMON_ERP_FAILED, &adapter->status)) {
+ ZFCP_LOG_DEBUG("skipped reopen of failed adapter %s\n",
+ zfcp_get_busid_by_adapter(adapter));
+ debug_text_event(adapter->erp_dbf, 5, "a_ro_f");
+ /* ensure propagation of failed status to new devices */
+ zfcp_erp_adapter_failed(adapter);
+ retval = -EIO;
+ goto out;
+ }
+ retval = zfcp_erp_action_enqueue(ZFCP_ERP_ACTION_REOPEN_ADAPTER,
+ adapter, NULL, NULL);
+
+ out:
+ return retval;
+}
+
+/*
+ * function:
+ *
+ * purpose: Wrappper for zfcp_erp_adapter_reopen_internal
+ * used to ensure the correct locking
+ *
+ * returns: 0 - initiated action succesfully
+ * <0 - failed to initiate action
+ */
+int
+zfcp_erp_adapter_reopen(struct zfcp_adapter *adapter, int clear_mask)
+{
+ int retval;
+ unsigned long flags;
+
+ read_lock_irqsave(&zfcp_data.config_lock, flags);
+ write_lock(&adapter->erp_lock);
+ retval = zfcp_erp_adapter_reopen_internal(adapter, clear_mask);
+ write_unlock(&adapter->erp_lock);
+ read_unlock_irqrestore(&zfcp_data.config_lock, flags);
+
+ return retval;
+}
+
+/*
+ * function:
+ *
+ * purpose:
+ *
+ * returns:
+ */
+int
+zfcp_erp_adapter_shutdown(struct zfcp_adapter *adapter, int clear_mask)
+{
+ int retval;
+
+ retval = zfcp_erp_adapter_reopen(adapter,
+ ZFCP_STATUS_COMMON_RUNNING |
+ ZFCP_STATUS_COMMON_ERP_FAILED |
+ clear_mask);
+
+ return retval;
+}
+
+/*
+ * function:
+ *
+ * purpose:
+ *
+ * returns:
+ */
+int
+zfcp_erp_port_shutdown(struct zfcp_port *port, int clear_mask)
+{
+ int retval;
+
+ retval = zfcp_erp_port_reopen(port,
+ ZFCP_STATUS_COMMON_RUNNING |
+ ZFCP_STATUS_COMMON_ERP_FAILED |
+ clear_mask);
+
+ return retval;
+}
+
+/*
+ * function:
+ *
+ * purpose:
+ *
+ * returns:
+ */
+int
+zfcp_erp_unit_shutdown(struct zfcp_unit *unit, int clear_mask)
+{
+ int retval;
+
+ retval = zfcp_erp_unit_reopen(unit,
+ ZFCP_STATUS_COMMON_RUNNING |
+ ZFCP_STATUS_COMMON_ERP_FAILED |
+ clear_mask);
+
+ return retval;
+}
+
+
+/**
+ * zfcp_erp_adisc - send ADISC ELS command
+ * @adapter: adapter structure
+ * @d_id: d_id of port where ADISC is sent to
+ */
+int
+zfcp_erp_adisc(struct zfcp_adapter *adapter, fc_id_t d_id)
+{
+ struct zfcp_send_els *send_els;
+ struct zfcp_ls_adisc *adisc;
+ void *address = NULL;
+ int retval = 0;
+ struct timer_list *timer;
+
+ send_els = kmalloc(sizeof(struct zfcp_send_els), GFP_ATOMIC);
+ if (send_els == NULL)
+ goto nomem;
+ memset(send_els, 0, sizeof(*send_els));
+
+ send_els->req = kmalloc(sizeof(struct scatterlist), GFP_ATOMIC);
+ if (send_els->req == NULL)
+ goto nomem;
+ memset(send_els->req, 0, sizeof(*send_els->req));
+
+ send_els->resp = kmalloc(sizeof(struct scatterlist), GFP_ATOMIC);
+ if (send_els->resp == NULL)
+ goto nomem;
+ memset(send_els->resp, 0, sizeof(*send_els->resp));
+
+ address = (void *) get_zeroed_page(GFP_ATOMIC);
+ if (address == NULL)
+ goto nomem;
+
+ zfcp_address_to_sg(address, send_els->req);
+ address += PAGE_SIZE >> 1;
+ zfcp_address_to_sg(address, send_els->resp);
+ send_els->req_count = send_els->resp_count = 1;
+
+ send_els->adapter = adapter;
+ send_els->d_id = d_id;
+ send_els->handler = zfcp_erp_adisc_handler;
+ send_els->handler_data = (unsigned long) send_els;
+
+ adisc = zfcp_sg_to_address(send_els->req);
+ send_els->ls_code = adisc->code = ZFCP_LS_ADISC;
+
+ send_els->req->length = sizeof(struct zfcp_ls_adisc);
+ send_els->resp->length = sizeof(struct zfcp_ls_adisc_acc);
+
+ /* acc. to FC-FS, hard_nport_id in ADISC should not be set for ports
+ without FC-AL-2 capability, so we don't set it */
+ adisc->wwpn = adapter->wwpn;
+ adisc->wwnn = adapter->wwnn;
+ adisc->nport_id = adapter->s_id;
+ ZFCP_LOG_INFO("ADISC request from s_id 0x%08x to d_id 0x%08x "
+ "(wwpn=0x%016Lx, wwnn=0x%016Lx, "
+ "hard_nport_id=0x%08x, nport_id=0x%08x)\n",
+ adapter->s_id, d_id, (wwn_t) adisc->wwpn,
+ (wwn_t) adisc->wwnn, adisc->hard_nport_id,
+ adisc->nport_id);
+
+ timer = kmalloc(sizeof(struct timer_list), GFP_ATOMIC);
+ if (!timer)
+ goto nomem;
+
+ init_timer(timer);
+ timer->function = zfcp_fsf_request_timeout_handler;
+ timer->data = (unsigned long) adapter;
+ timer->expires = ZFCP_FSF_REQUEST_TIMEOUT;
+ send_els->timer = timer;
+
+ retval = zfcp_fsf_send_els(send_els);
+ if (retval != 0) {
+ ZFCP_LOG_NORMAL("error: initiation of Send ELS failed for port "
+ "0x%08x on adapter %s\n", d_id,
+ zfcp_get_busid_by_adapter(adapter));
+ del_timer(send_els->timer);
+ goto freemem;
+ }
+
+ goto out;
+
+ nomem:
+ retval = -ENOMEM;
+ freemem:
+ if (address != NULL)
+ __free_pages(send_els->req->page, 0);
+ if (send_els != NULL) {
+ kfree(send_els->timer);
+ kfree(send_els->req);
+ kfree(send_els->resp);
+ kfree(send_els);
+ }
+ out:
+ return retval;
+}
+
+
+/**
+ * zfcp_erp_adisc_handler - handler for ADISC ELS command
+ * @data: pointer to struct zfcp_send_els
+ *
+ * If ADISC failed (LS_RJT or timed out) forced reopen of the port is triggered.
+ */
+void
+zfcp_erp_adisc_handler(unsigned long data)
+{
+ struct zfcp_send_els *send_els;
+ struct zfcp_port *port;
+ struct zfcp_adapter *adapter;
+ fc_id_t d_id;
+ struct zfcp_ls_adisc_acc *adisc;
+
+ send_els = (struct zfcp_send_els *) data;
+
+ del_timer(send_els->timer);
+
+ adapter = send_els->adapter;
+ d_id = send_els->d_id;
+
+ read_lock(&zfcp_data.config_lock);
+ port = zfcp_get_port_by_did(send_els->adapter, send_els->d_id);
+ read_unlock(&zfcp_data.config_lock);
+
+ BUG_ON(port == NULL);
+
+ /* request rejected or timed out */
+ if (send_els->status != 0) {
+ ZFCP_LOG_NORMAL("ELS request rejected/timed out, "
+ "force physical port reopen "
+ "(adapter %s, port d_id=0x%08x)\n",
+ zfcp_get_busid_by_adapter(adapter), d_id);
+ debug_text_event(adapter->erp_dbf, 3, "forcreop");
+ if (zfcp_erp_port_forced_reopen(port, 0))
+ ZFCP_LOG_NORMAL("failed reopen of port "
+ "(adapter %s, wwpn=0x%016Lx)\n",
+ zfcp_get_busid_by_port(port),
+ port->wwpn);
+ goto out;
+ }
+
+ adisc = zfcp_sg_to_address(send_els->resp);
+
+ ZFCP_LOG_INFO("ADISC response from d_id 0x%08x to s_id "
+ "0x%08x (wwpn=0x%016Lx, wwnn=0x%016Lx, "
+ "hard_nport_id=0x%08x, nport_id=0x%08x)\n",
+ d_id, adapter->s_id, (wwn_t) adisc->wwpn,
+ (wwn_t) adisc->wwnn, adisc->hard_nport_id,
+ adisc->nport_id);
+
+ /* set wwnn for port */
+ if (port->wwnn == 0)
+ port->wwnn = adisc->wwnn;
+
+ if (port->wwpn != adisc->wwpn) {
+ ZFCP_LOG_NORMAL("d_id assignment changed, reopening "
+ "port (adapter %s, wwpn=0x%016Lx, "
+ "adisc_resp_wwpn=0x%016Lx)\n",
+ zfcp_get_busid_by_port(port),
+ port->wwpn, (wwn_t) adisc->wwpn);
+ if (zfcp_erp_port_reopen(port, 0))
+ ZFCP_LOG_NORMAL("failed reopen of port "
+ "(adapter %s, wwpn=0x%016Lx)\n",
+ zfcp_get_busid_by_port(port),
+ port->wwpn);
+ }
+
+ out:
+ zfcp_port_put(port);
+ __free_pages(send_els->req->page, 0);
+ kfree(send_els->timer);
+ kfree(send_els->req);
+ kfree(send_els->resp);
+ kfree(send_els);
+}
+
+
+/**
+ * zfcp_test_link - lightweight link test procedure
+ * @port: port to be tested
+ *
+ * Test status of a link to a remote port using the ELS command ADISC.
+ */
+int
+zfcp_test_link(struct zfcp_port *port)
+{
+ int retval;
+
+ zfcp_port_get(port);
+ retval = zfcp_erp_adisc(port->adapter, port->d_id);
+ if (retval != 0) {
+ zfcp_port_put(port);
+ ZFCP_LOG_NORMAL("reopen needed for port 0x%016Lx "
+ "on adapter %s\n ", port->wwpn,
+ zfcp_get_busid_by_port(port));
+ retval = zfcp_erp_port_forced_reopen(port, 0);
+ if (retval != 0) {
+ ZFCP_LOG_NORMAL("reopen of remote port 0x%016Lx "
+ "on adapter %s failed\n", port->wwpn,
+ zfcp_get_busid_by_port(port));
+ retval = -EPERM;
+ }
+ }
+
+ return retval;
+}
+
+
+/*
+ * function:
+ *
+ * purpose: called if a port failed to be opened normally
+ * initiates Forced Reopen recovery which is done
+ * asynchronously
+ *
+ * returns: 0 - initiated action succesfully
+ * <0 - failed to initiate action
+ */
+static int
+zfcp_erp_port_forced_reopen_internal(struct zfcp_port *port, int clear_mask)
+{
+ int retval;
+ struct zfcp_adapter *adapter = port->adapter;
+
+ debug_text_event(adapter->erp_dbf, 5, "pf_ro");
+ debug_event(adapter->erp_dbf, 5, &port->wwpn, sizeof (wwn_t));
+
+ ZFCP_LOG_DEBUG("forced reopen of port 0x%016Lx on adapter %s\n",
+ port->wwpn, zfcp_get_busid_by_port(port));
+
+ zfcp_erp_port_block(port, clear_mask);
+
+ if (atomic_test_mask(ZFCP_STATUS_COMMON_ERP_FAILED, &port->status)) {
+ ZFCP_LOG_DEBUG("skipped forced reopen of failed port 0x%016Lx "
+ "on adapter %s\n", port->wwpn,
+ zfcp_get_busid_by_port(port));
+ debug_text_event(adapter->erp_dbf, 5, "pf_ro_f");
+ debug_event(adapter->erp_dbf, 5, &port->wwpn, sizeof (wwn_t));
+ retval = -EIO;
+ goto out;
+ }
+
+ retval = zfcp_erp_action_enqueue(ZFCP_ERP_ACTION_REOPEN_PORT_FORCED,
+ port->adapter, port, NULL);
+
+ out:
+ return retval;
+}
+
+/*
+ * function:
+ *
+ * purpose: Wrappper for zfcp_erp_port_forced_reopen_internal
+ * used to ensure the correct locking
+ *
+ * returns: 0 - initiated action succesfully
+ * <0 - failed to initiate action
+ */
+int
+zfcp_erp_port_forced_reopen(struct zfcp_port *port, int clear_mask)
+{
+ int retval;
+ unsigned long flags;
+ struct zfcp_adapter *adapter;
+
+ adapter = port->adapter;
+ read_lock_irqsave(&zfcp_data.config_lock, flags);
+ write_lock(&adapter->erp_lock);
+ retval = zfcp_erp_port_forced_reopen_internal(port, clear_mask);
+ write_unlock(&adapter->erp_lock);
+ read_unlock_irqrestore(&zfcp_data.config_lock, flags);
+
+ return retval;
+}
+
+/*
+ * function:
+ *
+ * purpose: called if a port is to be opened
+ * initiates Reopen recovery which is done
+ * asynchronously
+ *
+ * returns: 0 - initiated action succesfully
+ * <0 - failed to initiate action
+ */
+static int
+zfcp_erp_port_reopen_internal(struct zfcp_port *port, int clear_mask)
+{
+ int retval;
+ struct zfcp_adapter *adapter = port->adapter;
+
+ debug_text_event(adapter->erp_dbf, 5, "p_ro");
+ debug_event(adapter->erp_dbf, 5, &port->wwpn, sizeof (wwn_t));
+
+ ZFCP_LOG_DEBUG("reopen of port 0x%016Lx on adapter %s\n",
+ port->wwpn, zfcp_get_busid_by_port(port));
+
+ zfcp_erp_port_block(port, clear_mask);
+
+ if (atomic_test_mask(ZFCP_STATUS_COMMON_ERP_FAILED, &port->status)) {
+ ZFCP_LOG_DEBUG("skipped reopen of failed port 0x%016Lx "
+ "on adapter %s\n", port->wwpn,
+ zfcp_get_busid_by_port(port));
+ debug_text_event(adapter->erp_dbf, 5, "p_ro_f");
+ debug_event(adapter->erp_dbf, 5, &port->wwpn, sizeof (wwn_t));
+ /* ensure propagation of failed status to new devices */
+ zfcp_erp_port_failed(port);
+ retval = -EIO;
+ goto out;
+ }
+
+ retval = zfcp_erp_action_enqueue(ZFCP_ERP_ACTION_REOPEN_PORT,
+ port->adapter, port, NULL);
+
+ out:
+ return retval;
+}
+
+/**
+ * zfcp_erp_port_reopen - initiate reopen of a remote port
+ * @port: port to be reopened
+ * @clear_mask: specifies flags in port status to be cleared
+ * Return: 0 on success, < 0 on error
+ *
+ * This is a wrappper function for zfcp_erp_port_reopen_internal. It ensures
+ * correct locking. An error recovery task is initiated to do the reopen.
+ * To wait for the completion of the reopen zfcp_erp_wait should be used.
+ */
+int
+zfcp_erp_port_reopen(struct zfcp_port *port, int clear_mask)
+{
+ int retval;
+ unsigned long flags;
+ struct zfcp_adapter *adapter = port->adapter;
+
+ read_lock_irqsave(&zfcp_data.config_lock, flags);
+ write_lock(&adapter->erp_lock);
+ retval = zfcp_erp_port_reopen_internal(port, clear_mask);
+ write_unlock(&adapter->erp_lock);
+ read_unlock_irqrestore(&zfcp_data.config_lock, flags);
+
+ return retval;
+}
+
+/*
+ * function:
+ *
+ * purpose: called if a unit is to be opened
+ * initiates Reopen recovery which is done
+ * asynchronously
+ *
+ * returns: 0 - initiated action succesfully
+ * <0 - failed to initiate action
+ */
+static int
+zfcp_erp_unit_reopen_internal(struct zfcp_unit *unit, int clear_mask)
+{
+ int retval;
+ struct zfcp_adapter *adapter = unit->port->adapter;
+
+ debug_text_event(adapter->erp_dbf, 5, "u_ro");
+ debug_event(adapter->erp_dbf, 5, &unit->fcp_lun, sizeof (fcp_lun_t));
+ ZFCP_LOG_DEBUG("reopen of unit 0x%016Lx on port 0x%016Lx "
+ "on adapter %s\n", unit->fcp_lun,
+ unit->port->wwpn, zfcp_get_busid_by_unit(unit));
+
+ zfcp_erp_unit_block(unit, clear_mask);
+
+ if (atomic_test_mask(ZFCP_STATUS_COMMON_ERP_FAILED, &unit->status)) {
+ ZFCP_LOG_DEBUG("skipped reopen of failed unit 0x%016Lx "
+ "on port 0x%016Lx on adapter %s\n",
+ unit->fcp_lun, unit->port->wwpn,
+ zfcp_get_busid_by_unit(unit));
+ debug_text_event(adapter->erp_dbf, 5, "u_ro_f");
+ debug_event(adapter->erp_dbf, 5, &unit->fcp_lun,
+ sizeof (fcp_lun_t));
+ retval = -EIO;
+ goto out;
+ }
+
+ retval = zfcp_erp_action_enqueue(ZFCP_ERP_ACTION_REOPEN_UNIT,
+ unit->port->adapter, unit->port, unit);
+ out:
+ return retval;
+}
+
+/**
+ * zfcp_erp_unit_reopen - initiate reopen of a unit
+ * @unit: unit to be reopened
+ * @clear_mask: specifies flags in unit status to be cleared
+ * Return: 0 on success, < 0 on error
+ *
+ * This is a wrappper for zfcp_erp_unit_reopen_internal. It ensures correct
+ * locking. An error recovery task is initiated to do the reopen.
+ * To wait for the completion of the reopen zfcp_erp_wait should be used.
+ */
+int
+zfcp_erp_unit_reopen(struct zfcp_unit *unit, int clear_mask)
+{
+ int retval;
+ unsigned long flags;
+ struct zfcp_adapter *adapter;
+ struct zfcp_port *port;
+
+ port = unit->port;
+ adapter = port->adapter;
+
+ read_lock_irqsave(&zfcp_data.config_lock, flags);
+ write_lock(&adapter->erp_lock);
+ retval = zfcp_erp_unit_reopen_internal(unit, clear_mask);
+ write_unlock(&adapter->erp_lock);
+ read_unlock_irqrestore(&zfcp_data.config_lock, flags);
+
+ return retval;
+}
+
+/*
+ * function:
+ *
+ * purpose: disable I/O,
+ * return any open requests and clean them up,
+ * aim: no pending and incoming I/O
+ *
+ * returns:
+ */
+static void
+zfcp_erp_adapter_block(struct zfcp_adapter *adapter, int clear_mask)
+{
+ debug_text_event(adapter->erp_dbf, 6, "a_bl");
+ zfcp_erp_modify_adapter_status(adapter,
+ ZFCP_STATUS_COMMON_UNBLOCKED |
+ clear_mask, ZFCP_CLEAR);
+}
+
+/*
+ * function:
+ *
+ * purpose: enable I/O
+ *
+ * returns:
+ */
+static void
+zfcp_erp_adapter_unblock(struct zfcp_adapter *adapter)
+{
+ debug_text_event(adapter->erp_dbf, 6, "a_ubl");
+ atomic_set_mask(ZFCP_STATUS_COMMON_UNBLOCKED, &adapter->status);
+}
+
+/*
+ * function:
+ *
+ * purpose: disable I/O,
+ * return any open requests and clean them up,
+ * aim: no pending and incoming I/O
+ *
+ * returns:
+ */
+static void
+zfcp_erp_port_block(struct zfcp_port *port, int clear_mask)
+{
+ struct zfcp_adapter *adapter = port->adapter;
+
+ debug_text_event(adapter->erp_dbf, 6, "p_bl");
+ debug_event(adapter->erp_dbf, 6, &port->wwpn, sizeof (wwn_t));
+ zfcp_erp_modify_port_status(port,
+ ZFCP_STATUS_COMMON_UNBLOCKED | clear_mask,
+ ZFCP_CLEAR);
+}
+
+/*
+ * function:
+ *
+ * purpose: enable I/O
+ *
+ * returns:
+ */
+static void
+zfcp_erp_port_unblock(struct zfcp_port *port)
+{
+ struct zfcp_adapter *adapter = port->adapter;
+
+ debug_text_event(adapter->erp_dbf, 6, "p_ubl");
+ debug_event(adapter->erp_dbf, 6, &port->wwpn, sizeof (wwn_t));
+ atomic_set_mask(ZFCP_STATUS_COMMON_UNBLOCKED, &port->status);
+}
+
+/*
+ * function:
+ *
+ * purpose: disable I/O,
+ * return any open requests and clean them up,
+ * aim: no pending and incoming I/O
+ *
+ * returns:
+ */
+static void
+zfcp_erp_unit_block(struct zfcp_unit *unit, int clear_mask)
+{
+ struct zfcp_adapter *adapter = unit->port->adapter;
+
+ debug_text_event(adapter->erp_dbf, 6, "u_bl");
+ debug_event(adapter->erp_dbf, 6, &unit->fcp_lun, sizeof (fcp_lun_t));
+ zfcp_erp_modify_unit_status(unit,
+ ZFCP_STATUS_COMMON_UNBLOCKED | clear_mask,
+ ZFCP_CLEAR);
+}
+
+/*
+ * function:
+ *
+ * purpose: enable I/O
+ *
+ * returns:
+ */
+static void
+zfcp_erp_unit_unblock(struct zfcp_unit *unit)
+{
+ struct zfcp_adapter *adapter = unit->port->adapter;
+
+ debug_text_event(adapter->erp_dbf, 6, "u_ubl");
+ debug_event(adapter->erp_dbf, 6, &unit->fcp_lun, sizeof (fcp_lun_t));
+ atomic_set_mask(ZFCP_STATUS_COMMON_UNBLOCKED, &unit->status);
+}
+
+/*
+ * function:
+ *
+ * purpose:
+ *
+ * returns:
+ */
+static void
+zfcp_erp_action_ready(struct zfcp_erp_action *erp_action)
+{
+ struct zfcp_adapter *adapter = erp_action->adapter;
+
+ debug_text_event(adapter->erp_dbf, 4, "a_ar");
+ debug_event(adapter->erp_dbf, 4, &erp_action->action, sizeof (int));
+
+ zfcp_erp_action_to_ready(erp_action);
+ up(&adapter->erp_ready_sem);
+}
+
+/*
+ * function:
+ *
+ * purpose:
+ *
+ * returns: <0 erp_action not found in any list
+ * ZFCP_ERP_ACTION_READY erp_action is in ready list
+ * ZFCP_ERP_ACTION_RUNNING erp_action is in running list
+ *
+ * locks: erp_lock must be held
+ */
+static int
+zfcp_erp_action_exists(struct zfcp_erp_action *erp_action)
+{
+ int retval = -EINVAL;
+ struct list_head *entry;
+ struct zfcp_erp_action *entry_erp_action;
+ struct zfcp_adapter *adapter = erp_action->adapter;
+
+ /* search in running list */
+ list_for_each(entry, &adapter->erp_running_head) {
+ entry_erp_action =
+ list_entry(entry, struct zfcp_erp_action, list);
+ if (entry_erp_action == erp_action) {
+ retval = ZFCP_ERP_ACTION_RUNNING;
+ goto out;
+ }
+ }
+ /* search in ready list */
+ list_for_each(entry, &adapter->erp_ready_head) {
+ entry_erp_action =
+ list_entry(entry, struct zfcp_erp_action, list);
+ if (entry_erp_action == erp_action) {
+ retval = ZFCP_ERP_ACTION_READY;
+ goto out;
+ }
+ }
+
+ out:
+ return retval;
+}
+
+/*
+ * purpose: checks current status of action (timed out, dismissed, ...)
+ * and does appropriate preparations (dismiss fsf request, ...)
+ *
+ * locks: called under erp_lock (disabled interrupts)
+ *
+ * returns: 0
+ */
+static int
+zfcp_erp_strategy_check_fsfreq(struct zfcp_erp_action *erp_action)
+{
+ int retval = 0;
+ struct zfcp_fsf_req *fsf_req;
+ struct zfcp_adapter *adapter = erp_action->adapter;
+
+ if (erp_action->fsf_req) {
+ /* take lock to ensure that request is not being deleted meanwhile */
+ write_lock(&adapter->fsf_req_list_lock);
+ /* check whether fsf req does still exist */
+ list_for_each_entry(fsf_req, &adapter->fsf_req_list_head, list)
+ if (fsf_req == erp_action->fsf_req)
+ break;
+ if (fsf_req == erp_action->fsf_req) {
+ /* fsf_req still exists */
+ debug_text_event(adapter->erp_dbf, 3, "a_ca_req");
+ debug_event(adapter->erp_dbf, 3, &fsf_req,
+ sizeof (unsigned long));
+ /* dismiss fsf_req of timed out or dismissed erp_action */
+ if (erp_action->status & (ZFCP_STATUS_ERP_DISMISSED |
+ ZFCP_STATUS_ERP_TIMEDOUT)) {
+ debug_text_event(adapter->erp_dbf, 3,
+ "a_ca_disreq");
+ fsf_req->status |= ZFCP_STATUS_FSFREQ_DISMISSED;
+ }
+ if (erp_action->status & ZFCP_STATUS_ERP_TIMEDOUT) {
+ ZFCP_LOG_NORMAL("error: erp step timed out "
+ "(action=%d, fsf_req=%p)\n ",
+ erp_action->action,
+ erp_action->fsf_req);
+ }
+ /*
+ * If fsf_req is neither dismissed nor completed
+ * then keep it running asynchronously and don't mess
+ * with the association of erp_action and fsf_req.
+ */
+ if (fsf_req->status & (ZFCP_STATUS_FSFREQ_COMPLETED |
+ ZFCP_STATUS_FSFREQ_DISMISSED)) {
+ /* forget about association between fsf_req
+ and erp_action */
+ fsf_req->erp_action = NULL;
+ erp_action->fsf_req = NULL;
+ }
+ } else {
+ debug_text_event(adapter->erp_dbf, 3, "a_ca_gonereq");
+ /*
+ * even if this fsf_req has gone, forget about
+ * association between erp_action and fsf_req
+ */
+ erp_action->fsf_req = NULL;
+ }
+ write_unlock(&adapter->fsf_req_list_lock);
+ } else
+ debug_text_event(adapter->erp_dbf, 3, "a_ca_noreq");
+
+ return retval;
+}
+
+/*
+ * purpose: generic handler for asynchronous events related to erp_action events
+ * (normal completion, time-out, dismissing, retry after
+ * low memory condition)
+ *
+ * note: deletion of timer is not required (e.g. in case of a time-out),
+ * but a second try does no harm,
+ * we leave it in here to allow for greater simplification
+ *
+ * returns: 0 - there was an action to handle
+ * !0 - otherwise
+ */
+static int
+zfcp_erp_async_handler_nolock(struct zfcp_erp_action *erp_action,
+ unsigned long set_mask)
+{
+ int retval;
+ struct zfcp_adapter *adapter = erp_action->adapter;
+
+ if (zfcp_erp_action_exists(erp_action) == ZFCP_ERP_ACTION_RUNNING) {
+ debug_text_event(adapter->erp_dbf, 2, "a_asyh_ex");
+ debug_event(adapter->erp_dbf, 2, &erp_action->action,
+ sizeof (int));
+ if (!(set_mask & ZFCP_STATUS_ERP_TIMEDOUT))
+ del_timer(&erp_action->timer);
+ erp_action->status |= set_mask;
+ zfcp_erp_action_ready(erp_action);
+ retval = 0;
+ } else {
+ /* action is ready or gone - nothing to do */
+ debug_text_event(adapter->erp_dbf, 3, "a_asyh_gone");
+ debug_event(adapter->erp_dbf, 3, &erp_action->action,
+ sizeof (int));
+ retval = 1;
+ }
+
+ return retval;
+}
+
+/*
+ * purpose: generic handler for asynchronous events related to erp_action
+ * events (normal completion, time-out, dismissing, retry after
+ * low memory condition)
+ *
+ * note: deletion of timer is not required (e.g. in case of a time-out),
+ * but a second try does no harm,
+ * we leave it in here to allow for greater simplification
+ *
+ * returns: 0 - there was an action to handle
+ * !0 - otherwise
+ */
+int
+zfcp_erp_async_handler(struct zfcp_erp_action *erp_action,
+ unsigned long set_mask)
+{
+ struct zfcp_adapter *adapter = erp_action->adapter;
+ unsigned long flags;
+ int retval;
+
+ write_lock_irqsave(&adapter->erp_lock, flags);
+ retval = zfcp_erp_async_handler_nolock(erp_action, set_mask);
+ write_unlock_irqrestore(&adapter->erp_lock, flags);
+
+ return retval;
+}
+
+/*
+ * purpose: is called for erp_action which was slept waiting for
+ * memory becoming avaliable,
+ * will trigger that this action will be continued
+ */
+static void
+zfcp_erp_memwait_handler(unsigned long data)
+{
+ struct zfcp_erp_action *erp_action = (struct zfcp_erp_action *) data;
+ struct zfcp_adapter *adapter = erp_action->adapter;
+
+ debug_text_event(adapter->erp_dbf, 2, "a_mwh");
+ debug_event(adapter->erp_dbf, 2, &erp_action->action, sizeof (int));
+
+ zfcp_erp_async_handler(erp_action, 0);
+}
+
+/*
+ * purpose: is called if an asynchronous erp step timed out,
+ * action gets an appropriate flag and will be processed
+ * accordingly
+ */
+static void
+zfcp_erp_timeout_handler(unsigned long data)
+{
+ struct zfcp_erp_action *erp_action = (struct zfcp_erp_action *) data;
+ struct zfcp_adapter *adapter = erp_action->adapter;
+
+ debug_text_event(adapter->erp_dbf, 2, "a_th");
+ debug_event(adapter->erp_dbf, 2, &erp_action->action, sizeof (int));
+
+ zfcp_erp_async_handler(erp_action, ZFCP_STATUS_ERP_TIMEDOUT);
+}
+
+/*
+ * purpose: is called for an erp_action which needs to be ended
+ * though not being done,
+ * this is usually required if an higher is generated,
+ * action gets an appropriate flag and will be processed
+ * accordingly
+ *
+ * locks: erp_lock held (thus we need to call another handler variant)
+ */
+static int
+zfcp_erp_action_dismiss(struct zfcp_erp_action *erp_action)
+{
+ struct zfcp_adapter *adapter = erp_action->adapter;
+
+ debug_text_event(adapter->erp_dbf, 2, "a_adis");
+ debug_event(adapter->erp_dbf, 2, &erp_action->action, sizeof (int));
+
+ zfcp_erp_async_handler_nolock(erp_action, ZFCP_STATUS_ERP_DISMISSED);
+
+ return 0;
+}
+
+int
+zfcp_erp_thread_setup(struct zfcp_adapter *adapter)
+{
+ int retval = 0;
+
+ atomic_clear_mask(ZFCP_STATUS_ADAPTER_ERP_THREAD_UP, &adapter->status);
+
+ rwlock_init(&adapter->erp_lock);
+ INIT_LIST_HEAD(&adapter->erp_ready_head);
+ INIT_LIST_HEAD(&adapter->erp_running_head);
+ sema_init(&adapter->erp_ready_sem, 0);
+
+ retval = kernel_thread(zfcp_erp_thread, adapter, SIGCHLD);
+ if (retval < 0) {
+ ZFCP_LOG_NORMAL("error: creation of erp thread failed for "
+ "adapter %s\n",
+ zfcp_get_busid_by_adapter(adapter));
+ debug_text_event(adapter->erp_dbf, 5, "a_thset_fail");
+ } else {
+ wait_event(adapter->erp_thread_wqh,
+ atomic_test_mask(ZFCP_STATUS_ADAPTER_ERP_THREAD_UP,
+ &adapter->status));
+ debug_text_event(adapter->erp_dbf, 5, "a_thset_ok");
+ }
+
+ return (retval < 0);
+}
+
+/*
+ * function:
+ *
+ * purpose:
+ *
+ * returns:
+ *
+ * context: process (i.e. proc-fs or rmmod/insmod)
+ *
+ * note: 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.
+ */
+int
+zfcp_erp_thread_kill(struct zfcp_adapter *adapter)
+{
+ int retval = 0;
+
+ atomic_set_mask(ZFCP_STATUS_ADAPTER_ERP_THREAD_KILL, &adapter->status);
+ up(&adapter->erp_ready_sem);
+
+ wait_event(adapter->erp_thread_wqh,
+ !atomic_test_mask(ZFCP_STATUS_ADAPTER_ERP_THREAD_UP,
+ &adapter->status));
+
+ atomic_clear_mask(ZFCP_STATUS_ADAPTER_ERP_THREAD_KILL,
+ &adapter->status);
+
+ debug_text_event(adapter->erp_dbf, 5, "a_thki_ok");
+
+ return retval;
+}
+
+/*
+ * purpose: is run as a kernel thread,
+ * goes through list of error recovery actions of associated adapter
+ * and delegates single action to execution
+ *
+ * returns: 0
+ */
+static int
+zfcp_erp_thread(void *data)
+{
+ struct zfcp_adapter *adapter = (struct zfcp_adapter *) data;
+ struct list_head *next;
+ struct zfcp_erp_action *erp_action;
+ unsigned long flags;
+
+ daemonize("zfcperp%s", zfcp_get_busid_by_adapter(adapter));
+ /* Block all signals */
+ siginitsetinv(¤t->blocked, 0);
+ atomic_set_mask(ZFCP_STATUS_ADAPTER_ERP_THREAD_UP, &adapter->status);
+ debug_text_event(adapter->erp_dbf, 5, "a_th_run");
+ wake_up(&adapter->erp_thread_wqh);
+
+ while (!atomic_test_mask(ZFCP_STATUS_ADAPTER_ERP_THREAD_KILL,
+ &adapter->status)) {
+
+ write_lock_irqsave(&adapter->erp_lock, flags);
+ next = adapter->erp_ready_head.prev;
+ write_unlock_irqrestore(&adapter->erp_lock, flags);
+
+ if (next != &adapter->erp_ready_head) {
+ erp_action =
+ list_entry(next, struct zfcp_erp_action, list);
+ /*
+ * process action (incl. [re]moving it
+ * from 'ready' queue)
+ */
+ zfcp_erp_strategy(erp_action);
+ }
+
+ /*
+ * sleep as long as there is nothing to do, i.e.
+ * no action in 'ready' queue to be processed and
+ * thread is not to be killed
+ */
+ down_interruptible(&adapter->erp_ready_sem);
+ debug_text_event(adapter->erp_dbf, 5, "a_th_woken");
+ }
+
+ atomic_clear_mask(ZFCP_STATUS_ADAPTER_ERP_THREAD_UP, &adapter->status);
+ debug_text_event(adapter->erp_dbf, 5, "a_th_stop");
+ wake_up(&adapter->erp_thread_wqh);
+
+ return 0;
+}
+
+/*
+ * function:
+ *
+ * purpose: drives single error recovery action and schedules higher and
+ * subordinate actions, if necessary
+ *
+ * returns: ZFCP_ERP_CONTINUES - action continues (asynchronously)
+ * ZFCP_ERP_SUCCEEDED - action finished successfully (deqd)
+ * ZFCP_ERP_FAILED - action finished unsuccessfully (deqd)
+ * ZFCP_ERP_EXIT - action finished (dequeued), offline
+ * ZFCP_ERP_DISMISSED - action canceled (dequeued)
+ */
+static int
+zfcp_erp_strategy(struct zfcp_erp_action *erp_action)
+{
+ int retval = 0;
+ struct zfcp_adapter *adapter = erp_action->adapter;
+ struct zfcp_port *port = erp_action->port;
+ struct zfcp_unit *unit = erp_action->unit;
+ int action = erp_action->action;
+ u32 status = erp_action->status;
+ unsigned long flags;
+
+ /* serialise dismissing, timing out, moving, enqueueing */
+ read_lock_irqsave(&zfcp_data.config_lock, flags);
+ write_lock(&adapter->erp_lock);
+
+ /* dequeue dismissed action and leave, if required */
+ retval = zfcp_erp_strategy_check_action(erp_action, retval);
+ if (retval == ZFCP_ERP_DISMISSED) {
+ debug_text_event(adapter->erp_dbf, 4, "a_st_dis1");
+ goto unlock;
+ }
+
+ /*
+ * move action to 'running' queue before processing it
+ * (to avoid a race condition regarding moving the
+ * action to the 'running' queue and back)
+ */
+ zfcp_erp_action_to_running(erp_action);
+
+ /*
+ * try to process action as far as possible,
+ * no lock to allow for blocking operations (kmalloc, qdio, ...),
+ * afterwards the lock is required again for the following reasons:
+ * - dequeueing of finished action and enqueueing of
+ * follow-up actions must be atomic so that any other
+ * reopen-routine does not believe there is nothing to do
+ * and that it is safe to enqueue something else,
+ * - we want to force any control thread which is dismissing
+ * actions to finish this before we decide about
+ * necessary steps to be taken here further
+ */
+ write_unlock(&adapter->erp_lock);
+ read_unlock_irqrestore(&zfcp_data.config_lock, flags);
+ retval = zfcp_erp_strategy_do_action(erp_action);
+ read_lock_irqsave(&zfcp_data.config_lock, flags);
+ write_lock(&adapter->erp_lock);
+
+ /*
+ * check for dismissed status again to avoid follow-up actions,
+ * failing of targets and so on for dismissed actions
+ */
+ retval = zfcp_erp_strategy_check_action(erp_action, retval);
+
+ switch (retval) {
+ case ZFCP_ERP_DISMISSED:
+ /* leave since this action has ridden to its ancestors */
+ debug_text_event(adapter->erp_dbf, 6, "a_st_dis2");
+ goto unlock;
+ case ZFCP_ERP_NOMEM:
+ /* no memory to continue immediately, let it sleep */
+ if (!(erp_action->status & ZFCP_STATUS_ERP_LOWMEM)) {
+ ++adapter->erp_low_mem_count;
+ erp_action->status |= ZFCP_STATUS_ERP_LOWMEM;
+ }
+ /* This condition is true if there is no memory available
+ for any erp_action on this adapter. This implies that there
+ are no elements in the memory pool(s) left for erp_actions.
+ This might happen if an erp_action that used a memory pool
+ element was timed out.
+ */
+ if (adapter->erp_total_count == adapter->erp_low_mem_count) {
+ debug_text_event(adapter->erp_dbf, 3, "a_st_lowmem");
+ ZFCP_LOG_NORMAL("error: no mempool elements available, "
+ "restarting I/O on adapter %s "
+ "to free mempool\n",
+ zfcp_get_busid_by_adapter(adapter));
+ zfcp_erp_adapter_reopen_internal(adapter, 0);
+ } else {
+ debug_text_event(adapter->erp_dbf, 2, "a_st_memw");
+ retval = zfcp_erp_strategy_memwait(erp_action);
+ }
+ goto unlock;
+ case ZFCP_ERP_CONTINUES:
+ /* leave since this action runs asynchronously */
+ debug_text_event(adapter->erp_dbf, 6, "a_st_cont");
+ if (erp_action->status & ZFCP_STATUS_ERP_LOWMEM) {
+ --adapter->erp_low_mem_count;
+ erp_action->status &= ~ZFCP_STATUS_ERP_LOWMEM;
+ }
+ goto unlock;
+ }
+ /* ok, finished action (whatever its result is) */
+
+ /* check for unrecoverable targets */
+ retval = zfcp_erp_strategy_check_target(erp_action, retval);
+
+ /* action must be dequeued (here to allow for further ones) */
+ zfcp_erp_action_dequeue(erp_action);
+
+ /*
+ * put this target through the erp mill again if someone has
+ * requested to change the status of a target being online
+ * to offline or the other way around
+ * (old retval is preserved if nothing has to be done here)
+ */
+ retval = zfcp_erp_strategy_statechange(action, status, adapter,
+ port, unit, retval);
+
+ /*
+ * leave if target is in permanent error state or if
+ * action is repeated in order to process state change
+ */
+ if (retval == ZFCP_ERP_EXIT) {
+ debug_text_event(adapter->erp_dbf, 2, "a_st_exit");
+ goto unlock;
+ }
+
+ /* trigger follow up actions */
+ zfcp_erp_strategy_followup_actions(action, adapter, port, unit, retval);
+
+ unlock:
+ write_unlock(&adapter->erp_lock);
+ read_unlock_irqrestore(&zfcp_data.config_lock, flags);
+
+ if (retval != ZFCP_ERP_CONTINUES)
+ zfcp_erp_action_cleanup(action, adapter, port, unit, retval);
+
+ /*
+ * a few tasks remain when the erp queues are empty
+ * (don't do that if the last action evaluated was dismissed
+ * since this clearly indicates that there is more to come) :
+ * - close the name server port if it is open yet
+ * (enqueues another [probably] final action)
+ * - otherwise, wake up whoever wants to be woken when we are
+ * done with erp
+ */
+ if (retval != ZFCP_ERP_DISMISSED)
+ zfcp_erp_strategy_check_queues(adapter);
+
+ debug_text_event(adapter->erp_dbf, 6, "a_st_done");
+
+ return retval;
+}
+
+/*
+ * function:
+ *
+ * purpose:
+ *
+ * returns: ZFCP_ERP_DISMISSED - if action has been dismissed
+ * retval - otherwise
+ */
+static int
+zfcp_erp_strategy_check_action(struct zfcp_erp_action *erp_action, int retval)
+{
+ struct zfcp_adapter *adapter = erp_action->adapter;
+
+ zfcp_erp_strategy_check_fsfreq(erp_action);
+
+ debug_event(adapter->erp_dbf, 5, &erp_action->action, sizeof (int));
+ if (erp_action->status & ZFCP_STATUS_ERP_DISMISSED) {
+ debug_text_event(adapter->erp_dbf, 3, "a_stcd_dis");
+ zfcp_erp_action_dequeue(erp_action);
+ retval = ZFCP_ERP_DISMISSED;
+ } else
+ debug_text_event(adapter->erp_dbf, 5, "a_stcd_nodis");
+
+ return retval;
+}
+
+/*
+ * function:
+ *
+ * purpose:
+ *
+ * returns:
+ */
+static int
+zfcp_erp_strategy_do_action(struct zfcp_erp_action *erp_action)
+{
+ int retval = ZFCP_ERP_FAILED;
+ struct zfcp_adapter *adapter = erp_action->adapter;
+
+ /*
+ * try to execute/continue action as far as possible,
+ * note: no lock in subsequent strategy routines
+ * (this allows these routine to call schedule, e.g.
+ * kmalloc with such flags or qdio_initialize & friends)
+ * Note: in case of timeout, the seperate strategies will fail
+ * anyhow. No need for a special action. Even worse, a nameserver
+ * failure would not wake up waiting ports without the call.
+ */
+ switch (erp_action->action) {
+
+ case ZFCP_ERP_ACTION_REOPEN_ADAPTER:
+ retval = zfcp_erp_adapter_strategy(erp_action);
+ break;
+
+ case ZFCP_ERP_ACTION_REOPEN_PORT_FORCED:
+ retval = zfcp_erp_port_forced_strategy(erp_action);
+ break;
+
+ case ZFCP_ERP_ACTION_REOPEN_PORT:
+ retval = zfcp_erp_port_strategy(erp_action);
+ break;
+
+ case ZFCP_ERP_ACTION_REOPEN_UNIT:
+ retval = zfcp_erp_unit_strategy(erp_action);
+ break;
+
+ default:
+ debug_text_exception(adapter->erp_dbf, 1, "a_stda_bug");
+ debug_event(adapter->erp_dbf, 1, &erp_action->action,
+ sizeof (int));
+ ZFCP_LOG_NORMAL("bug: unknown erp action requested on "
+ "adapter %s (action=%d)\n",
+ zfcp_get_busid_by_adapter(erp_action->adapter),
+ erp_action->action);
+ }
+
+ return retval;
+}
+
+/*
+ * function:
+ *
+ * purpose: triggers retry of this action after a certain amount of time
+ * by means of timer provided by erp_action
+ *
+ * returns: ZFCP_ERP_CONTINUES - erp_action sleeps in erp running queue
+ */
+static int
+zfcp_erp_strategy_memwait(struct zfcp_erp_action *erp_action)
+{
+ int retval = ZFCP_ERP_CONTINUES;
+ struct zfcp_adapter *adapter = erp_action->adapter;
+
+ debug_text_event(adapter->erp_dbf, 6, "a_mwinit");
+ debug_event(adapter->erp_dbf, 6, &erp_action->action, sizeof (int));
+ init_timer(&erp_action->timer);
+ erp_action->timer.function = zfcp_erp_memwait_handler;
+ erp_action->timer.data = (unsigned long) erp_action;
+ erp_action->timer.expires = jiffies + ZFCP_ERP_MEMWAIT_TIMEOUT;
+ add_timer(&erp_action->timer);
+
+ return retval;
+}
+
+/*
+ * function: zfcp_erp_adapter_failed
+ *
+ * purpose: sets the adapter and all underlying devices to ERP_FAILED
+ *
+ */
+void
+zfcp_erp_adapter_failed(struct zfcp_adapter *adapter)
+{
+ zfcp_erp_modify_adapter_status(adapter,
+ ZFCP_STATUS_COMMON_ERP_FAILED, ZFCP_SET);
+ ZFCP_LOG_NORMAL("adapter erp failed on adapter %s\n",
+ zfcp_get_busid_by_adapter(adapter));
+ debug_text_event(adapter->erp_dbf, 2, "a_afail");
+}
+
+/*
+ * function: zfcp_erp_port_failed
+ *
+ * purpose: sets the port and all underlying devices to ERP_FAILED
+ *
+ */
+void
+zfcp_erp_port_failed(struct zfcp_port *port)
+{
+ zfcp_erp_modify_port_status(port,
+ ZFCP_STATUS_COMMON_ERP_FAILED, ZFCP_SET);
+
+ if (atomic_test_mask(ZFCP_STATUS_PORT_WKA, &port->status))
+ ZFCP_LOG_NORMAL("port erp failed (adapter %s, "
+ "port d_id=0x%08x)\n",
+ zfcp_get_busid_by_port(port), port->d_id);
+ else
+ ZFCP_LOG_NORMAL("port erp failed (adapter %s, wwpn=0x%016Lx)\n",
+ zfcp_get_busid_by_port(port), port->wwpn);
+
+ debug_text_event(port->adapter->erp_dbf, 2, "p_pfail");
+ debug_event(port->adapter->erp_dbf, 2, &port->wwpn, sizeof (wwn_t));
+}
+
+/*
+ * function: zfcp_erp_unit_failed
+ *
+ * purpose: sets the unit to ERP_FAILED
+ *
+ */
+void
+zfcp_erp_unit_failed(struct zfcp_unit *unit)
+{
+ zfcp_erp_modify_unit_status(unit,
+ ZFCP_STATUS_COMMON_ERP_FAILED, ZFCP_SET);
+
+ ZFCP_LOG_NORMAL("unit erp failed on unit 0x%016Lx on port 0x%016Lx "
+ " on adapter %s\n", unit->fcp_lun,
+ unit->port->wwpn, zfcp_get_busid_by_unit(unit));
+ debug_text_event(unit->port->adapter->erp_dbf, 2, "u_ufail");
+ debug_event(unit->port->adapter->erp_dbf, 2,
+ &unit->fcp_lun, sizeof (fcp_lun_t));
+}
+
+/*
+ * function: zfcp_erp_strategy_check_target
+ *
+ * purpose: increments the erp action count on the device currently in
+ * recovery if the action failed or resets the count in case of
+ * success. If a maximum count is exceeded the device is marked
+ * as ERP_FAILED.
+ * The 'blocked' state of a target which has been recovered
+ * successfully is reset.
+ *
+ * returns: ZFCP_ERP_CONTINUES - action continues (not considered)
+ * ZFCP_ERP_SUCCEEDED - action finished successfully
+ * ZFCP_ERP_EXIT - action failed and will not continue
+ */
+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 zfcp_unit *unit = erp_action->unit;
+
+ debug_text_event(adapter->erp_dbf, 5, "a_stct_norm");
+ debug_event(adapter->erp_dbf, 5, &erp_action->action, sizeof (int));
+ debug_event(adapter->erp_dbf, 5, &result, sizeof (int));
+
+ switch (erp_action->action) {
+
+ case ZFCP_ERP_ACTION_REOPEN_UNIT:
+ result = zfcp_erp_strategy_check_unit(unit, 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;
+}
+
+/*
+ * function:
+ *
+ * purpose:
+ *
+ * returns:
+ */
+static int
+zfcp_erp_strategy_statechange(int action,
+ u32 status,
+ struct zfcp_adapter *adapter,
+ struct zfcp_port *port,
+ struct zfcp_unit *unit, int retval)
+{
+ debug_text_event(adapter->erp_dbf, 3, "a_stsc");
+ debug_event(adapter->erp_dbf, 3, &action, sizeof (int));
+
+ switch (action) {
+
+ case ZFCP_ERP_ACTION_REOPEN_ADAPTER:
+ if (zfcp_erp_strategy_statechange_detected(&adapter->status,
+ status)) {
+ zfcp_erp_adapter_reopen_internal(adapter, ZFCP_STATUS_COMMON_ERP_FAILED);
+ retval = ZFCP_ERP_EXIT;
+ }
+ break;
+
+ case ZFCP_ERP_ACTION_REOPEN_PORT_FORCED:
+ case ZFCP_ERP_ACTION_REOPEN_PORT:
+ if (zfcp_erp_strategy_statechange_detected(&port->status,
+ status)) {
+ zfcp_erp_port_reopen_internal(port, ZFCP_STATUS_COMMON_ERP_FAILED);
+ retval = ZFCP_ERP_EXIT;
+ }
+ break;
+
+ case ZFCP_ERP_ACTION_REOPEN_UNIT:
+ if (zfcp_erp_strategy_statechange_detected(&unit->status,
+ status)) {
+ zfcp_erp_unit_reopen_internal(unit, ZFCP_STATUS_COMMON_ERP_FAILED);
+ retval = ZFCP_ERP_EXIT;
+ }
+ break;
+ }
+
+ return retval;
+}
+
+/*
+ * function:
+ *
+ * purpose:
+ *
+ * returns:
+ */
+static inline int
+zfcp_erp_strategy_statechange_detected(atomic_t * target_status, u32 erp_status)
+{
+ return
+ /* take it online */
+ (atomic_test_mask(ZFCP_STATUS_COMMON_RUNNING, target_status) &&
+ (ZFCP_STATUS_ERP_CLOSE_ONLY & erp_status)) ||
+ /* take it offline */
+ (!atomic_test_mask(ZFCP_STATUS_COMMON_RUNNING, target_status) &&
+ !(ZFCP_STATUS_ERP_CLOSE_ONLY & erp_status));
+}
+
+/*
+ * function:
+ *
+ * purpose:
+ *
+ * returns:
+ */
+static int
+zfcp_erp_strategy_check_unit(struct zfcp_unit *unit, int result)
+{
+ debug_text_event(unit->port->adapter->erp_dbf, 5, "u_stct");
+ debug_event(unit->port->adapter->erp_dbf, 5, &unit->fcp_lun,
+ sizeof (fcp_lun_t));
+
+ switch (result) {
+ case ZFCP_ERP_SUCCEEDED :
+ atomic_set(&unit->erp_counter, 0);
+ zfcp_erp_unit_unblock(unit);
+ break;
+ case ZFCP_ERP_FAILED :
+ atomic_inc(&unit->erp_counter);
+ if (atomic_read(&unit->erp_counter) > ZFCP_MAX_ERPS)
+ zfcp_erp_unit_failed(unit);
+ break;
+ case ZFCP_ERP_EXIT :
+ /* nothing */
+ break;
+ }
+
+ if (atomic_test_mask(ZFCP_STATUS_COMMON_ERP_FAILED, &unit->status)) {
+ zfcp_erp_unit_block(unit, 0); /* for ZFCP_ERP_SUCCEEDED */
+ result = ZFCP_ERP_EXIT;
+ }
+
+ return result;
+}
+
+/*
+ * function:
+ *
+ * purpose:
+ *
+ * returns:
+ */
+static int
+zfcp_erp_strategy_check_port(struct zfcp_port *port, int result)
+{
+ debug_text_event(port->adapter->erp_dbf, 5, "p_stct");
+ debug_event(port->adapter->erp_dbf, 5, &port->wwpn, sizeof (wwn_t));
+
+ switch (result) {
+ case ZFCP_ERP_SUCCEEDED :
+ atomic_set(&port->erp_counter, 0);
+ zfcp_erp_port_unblock(port);
+ break;
+ case ZFCP_ERP_FAILED :
+ atomic_inc(&port->erp_counter);
+ if (atomic_read(&port->erp_counter) > ZFCP_MAX_ERPS)
+ zfcp_erp_port_failed(port);
+ break;
+ case ZFCP_ERP_EXIT :
+ /* nothing */
+ break;
+ }
+
+ if (atomic_test_mask(ZFCP_STATUS_COMMON_ERP_FAILED, &port->status)) {
+ zfcp_erp_port_block(port, 0); /* for ZFCP_ERP_SUCCEEDED */
+ result = ZFCP_ERP_EXIT;
+ }
+
+ return result;
+}
+
+/*
+ * function:
+ *
+ * purpose:
+ *
+ * returns:
+ */
+static int
+zfcp_erp_strategy_check_adapter(struct zfcp_adapter *adapter, int result)
+{
+ debug_text_event(adapter->erp_dbf, 5, "a_stct");
+
+ 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)
+ zfcp_erp_adapter_failed(adapter);
+ break;
+ case ZFCP_ERP_EXIT :
+ /* nothing */
+ break;
+ }
+
+ if (atomic_test_mask(ZFCP_STATUS_COMMON_ERP_FAILED, &adapter->status)) {
+ zfcp_erp_adapter_block(adapter, 0); /* for ZFCP_ERP_SUCCEEDED */
+ result = ZFCP_ERP_EXIT;
+ }
+
+ return result;
+}
+
+/*
+ * function:
+ *
+ * purpose: remaining things in good cases,
+ * escalation in bad cases
+ *
+ * returns:
+ */
+static int
+zfcp_erp_strategy_followup_actions(int action,
+ struct zfcp_adapter *adapter,
+ struct zfcp_port *port,
+ struct zfcp_unit *unit, int status)
+{
+ debug_text_event(adapter->erp_dbf, 5, "a_stfol");
+ debug_event(adapter->erp_dbf, 5, &action, sizeof (int));
+
+ /* initiate follow-up actions depending on success of finished action */
+ switch (action) {
+
+ case ZFCP_ERP_ACTION_REOPEN_ADAPTER:
+ if (status == ZFCP_ERP_SUCCEEDED)
+ zfcp_erp_port_reopen_all_internal(adapter, 0);
+ else
+ zfcp_erp_adapter_reopen_internal(adapter, 0);
+ break;
+
+ case ZFCP_ERP_ACTION_REOPEN_PORT_FORCED:
+ if (status == ZFCP_ERP_SUCCEEDED)
+ zfcp_erp_port_reopen_internal(port, 0);
+ else
+ zfcp_erp_adapter_reopen_internal(adapter, 0);
+ break;
+
+ case ZFCP_ERP_ACTION_REOPEN_PORT:
+ if (status == ZFCP_ERP_SUCCEEDED)
+ zfcp_erp_unit_reopen_all_internal(port, 0);
+ else
+ zfcp_erp_port_forced_reopen_internal(port, 0);
+ break;
+
+ case ZFCP_ERP_ACTION_REOPEN_UNIT:
+ if (status == ZFCP_ERP_SUCCEEDED) ; /* no further action */
+ else
+ zfcp_erp_port_reopen_internal(unit->port, 0);
+ break;
+ }
+
+ return 0;
+}
+
+/*
+ * function:
+ *
+ * purpose:
+ *
+ * returns:
+ */
+static int
+zfcp_erp_strategy_check_queues(struct zfcp_adapter *adapter)
+{
+ unsigned long flags;
+
+ read_lock_irqsave(&zfcp_data.config_lock, flags);
+ read_lock(&adapter->erp_lock);
+ if (list_empty(&adapter->erp_ready_head) &&
+ list_empty(&adapter->erp_running_head)) {
+ debug_text_event(adapter->erp_dbf, 4, "a_cq_wake");
+ atomic_clear_mask(ZFCP_STATUS_ADAPTER_ERP_PENDING,
+ &adapter->status);
+ wake_up(&adapter->erp_done_wqh);
+ } else
+ debug_text_event(adapter->erp_dbf, 5, "a_cq_notempty");
+ read_unlock(&adapter->erp_lock);
+ read_unlock_irqrestore(&zfcp_data.config_lock, flags);
+
+ return 0;
+}
+
+/**
+ * zfcp_erp_wait - wait for completion of error recovery on an adapter
+ * @adapter: adapter for which to wait for completion of its error recovery
+ * Return: 0
+ */
+int
+zfcp_erp_wait(struct zfcp_adapter *adapter)
+{
+ int retval = 0;
+
+ wait_event(adapter->erp_done_wqh,
+ !atomic_test_mask(ZFCP_STATUS_ADAPTER_ERP_PENDING,
+ &adapter->status));
+
+ return retval;
+}
+
+/*
+ * function: zfcp_erp_modify_adapter_status
+ *
+ * purpose:
+ *
+ */
+void
+zfcp_erp_modify_adapter_status(struct zfcp_adapter *adapter,
+ u32 mask, int set_or_clear)
+{
+ struct zfcp_port *port;
+ u32 common_mask = mask & ZFCP_COMMON_FLAGS;
+
+ if (set_or_clear == ZFCP_SET) {
+ atomic_set_mask(mask, &adapter->status);
+ debug_text_event(adapter->erp_dbf, 3, "a_mod_as_s");
+ } else {
+ atomic_clear_mask(mask, &adapter->status);
+ if (mask & ZFCP_STATUS_COMMON_ERP_FAILED)
+ atomic_set(&adapter->erp_counter, 0);
+ debug_text_event(adapter->erp_dbf, 3, "a_mod_as_c");
+ }
+ debug_event(adapter->erp_dbf, 3, &mask, sizeof (u32));
+
+ /* Deal with all underlying devices, only pass common_mask */
+ if (common_mask)
+ list_for_each_entry(port, &adapter->port_list_head, list)
+ zfcp_erp_modify_port_status(port, common_mask,
+ set_or_clear);
+}
+
+/*
+ * function: zfcp_erp_modify_port_status
+ *
+ * purpose: sets the port and all underlying devices to ERP_FAILED
+ *
+ */
+void
+zfcp_erp_modify_port_status(struct zfcp_port *port, u32 mask, int set_or_clear)
+{
+ struct zfcp_unit *unit;
+ u32 common_mask = mask & ZFCP_COMMON_FLAGS;
+
+ if (set_or_clear == ZFCP_SET) {
+ atomic_set_mask(mask, &port->status);
+ debug_text_event(port->adapter->erp_dbf, 3, "p_mod_ps_s");
+ } else {
+ atomic_clear_mask(mask, &port->status);
+ if (mask & ZFCP_STATUS_COMMON_ERP_FAILED)
+ atomic_set(&port->erp_counter, 0);
+ debug_text_event(port->adapter->erp_dbf, 3, "p_mod_ps_c");
+ }
+ debug_event(port->adapter->erp_dbf, 3, &port->wwpn, sizeof (wwn_t));
+ debug_event(port->adapter->erp_dbf, 3, &mask, sizeof (u32));
+
+ /* Modify status of all underlying devices, only pass common mask */
+ if (common_mask)
+ list_for_each_entry(unit, &port->unit_list_head, list)
+ zfcp_erp_modify_unit_status(unit, common_mask,
+ set_or_clear);
+}
+
+/*
+ * function: zfcp_erp_modify_unit_status
+ *
+ * purpose: sets the unit to ERP_FAILED
+ *
+ */
+void
+zfcp_erp_modify_unit_status(struct zfcp_unit *unit, u32 mask, int set_or_clear)
+{
+ if (set_or_clear == ZFCP_SET) {
+ atomic_set_mask(mask, &unit->status);
+ debug_text_event(unit->port->adapter->erp_dbf, 3, "u_mod_us_s");
+ } else {
+ atomic_clear_mask(mask, &unit->status);
+ if (mask & ZFCP_STATUS_COMMON_ERP_FAILED) {
+ atomic_set(&unit->erp_counter, 0);
+ }
+ debug_text_event(unit->port->adapter->erp_dbf, 3, "u_mod_us_c");
+ }
+ debug_event(unit->port->adapter->erp_dbf, 3, &unit->fcp_lun,
+ sizeof (fcp_lun_t));
+ debug_event(unit->port->adapter->erp_dbf, 3, &mask, sizeof (u32));
+}
+
+/*
+ * function:
+ *
+ * purpose: Wrappper for zfcp_erp_port_reopen_all_internal
+ * used to ensure the correct locking
+ *
+ * returns: 0 - initiated action succesfully
+ * <0 - failed to initiate action
+ */
+int
+zfcp_erp_port_reopen_all(struct zfcp_adapter *adapter, int clear_mask)
+{
+ int retval;
+ unsigned long flags;
+
+ read_lock_irqsave(&zfcp_data.config_lock, flags);
+ write_lock(&adapter->erp_lock);
+ retval = zfcp_erp_port_reopen_all_internal(adapter, clear_mask);
+ write_unlock(&adapter->erp_lock);
+ read_unlock_irqrestore(&zfcp_data.config_lock, flags);
+
+ return retval;
+}
+
+/*
+ * function:
+ *
+ * purpose:
+ *
+ * returns: FIXME
+ */
+static int
+zfcp_erp_port_reopen_all_internal(struct zfcp_adapter *adapter, int clear_mask)
+{
+ int retval = 0;
+ struct zfcp_port *port;
+
+ list_for_each_entry(port, &adapter->port_list_head, list)
+ if (!atomic_test_mask(ZFCP_STATUS_PORT_WKA, &port->status))
+ zfcp_erp_port_reopen_internal(port, clear_mask);
+
+ return retval;
+}
+
+/*
+ * function:
+ *
+ * purpose:
+ *
+ * returns: FIXME
+ */
+static int
+zfcp_erp_unit_reopen_all_internal(struct zfcp_port *port, int clear_mask)
+{
+ int retval = 0;
+ struct zfcp_unit *unit;
+
+ list_for_each_entry(unit, &port->unit_list_head, list)
+ zfcp_erp_unit_reopen_internal(unit, clear_mask);
+
+ return retval;
+}
+
+/*
+ * function:
+ *
+ * purpose: this routine executes the 'Reopen Adapter' action
+ * (the entire action is processed synchronously, since
+ * there are no actions which might be run concurrently
+ * per definition)
+ *
+ * returns: ZFCP_ERP_SUCCEEDED - action finished successfully
+ * ZFCP_ERP_FAILED - action finished unsuccessfully
+ */
+static int
+zfcp_erp_adapter_strategy(struct zfcp_erp_action *erp_action)
+{
+ int retval;
+ struct zfcp_adapter *adapter = erp_action->adapter;
+
+ retval = zfcp_erp_adapter_strategy_close(erp_action);
+ if (erp_action->status & ZFCP_STATUS_ERP_CLOSE_ONLY)
+ retval = ZFCP_ERP_EXIT;
+ else
+ retval = zfcp_erp_adapter_strategy_open(erp_action);
+
+ debug_text_event(adapter->erp_dbf, 3, "a_ast/ret");
+ debug_event(adapter->erp_dbf, 3, &erp_action->action, sizeof (int));
+ debug_event(adapter->erp_dbf, 3, &retval, sizeof (int));
+
+ if (retval == ZFCP_ERP_FAILED) {
+ ZFCP_LOG_INFO("Waiting to allow the adapter %s "
+ "to recover itself\n",
+ zfcp_get_busid_by_adapter(adapter));
+ msleep(jiffies_to_msecs(ZFCP_TYPE2_RECOVERY_TIME));
+ }
+
+ return retval;
+}
+
+/*
+ * function:
+ *
+ * purpose:
+ *
+ * returns: ZFCP_ERP_SUCCEEDED - action finished successfully
+ * ZFCP_ERP_FAILED - action finished unsuccessfully
+ */
+static int
+zfcp_erp_adapter_strategy_close(struct zfcp_erp_action *erp_action)
+{
+ int retval;
+
+ atomic_set_mask(ZFCP_STATUS_COMMON_CLOSING,
+ &erp_action->adapter->status);
+ retval = zfcp_erp_adapter_strategy_generic(erp_action, 1);
+ atomic_clear_mask(ZFCP_STATUS_COMMON_CLOSING,
+ &erp_action->adapter->status);
+
+ return retval;
+}
+
+/*
+ * function:
+ *
+ * purpose:
+ *
+ * returns: ZFCP_ERP_SUCCEEDED - action finished successfully
+ * ZFCP_ERP_FAILED - action finished unsuccessfully
+ */
+static int
+zfcp_erp_adapter_strategy_open(struct zfcp_erp_action *erp_action)
+{
+ int retval;
+
+ atomic_set_mask(ZFCP_STATUS_COMMON_OPENING,
+ &erp_action->adapter->status);
+ retval = zfcp_erp_adapter_strategy_generic(erp_action, 0);
+ atomic_clear_mask(ZFCP_STATUS_COMMON_OPENING,
+ &erp_action->adapter->status);
+
+ return retval;
+}
+
+/*
+ * function: zfcp_register_adapter
+ *
+ * purpose: allocate the irq associated with this devno and register
+ * the FSF adapter with the SCSI stack
+ *
+ * returns:
+ */
+static int
+zfcp_erp_adapter_strategy_generic(struct zfcp_erp_action *erp_action, int close)
+{
+ int retval = ZFCP_ERP_SUCCEEDED;
+
+ if (close)
+ goto close_only;
+
+ retval = zfcp_erp_adapter_strategy_open_qdio(erp_action);
+ if (retval != ZFCP_ERP_SUCCEEDED)
+ goto failed_qdio;
+
+ retval = zfcp_erp_adapter_strategy_open_fsf(erp_action);
+ if (retval != ZFCP_ERP_SUCCEEDED)
+ goto failed_openfcp;
+
+ atomic_set_mask(ZFCP_STATUS_COMMON_OPEN, &erp_action->adapter->status);
+ goto out;
+
+ close_only:
+ atomic_clear_mask(ZFCP_STATUS_COMMON_OPEN,
+ &erp_action->adapter->status);
+
+ failed_openfcp:
+ zfcp_erp_adapter_strategy_close_qdio(erp_action);
+ zfcp_erp_adapter_strategy_close_fsf(erp_action);
+ failed_qdio:
+ out:
+ return retval;
+}
+
+/*
+ * function: zfcp_qdio_init
+ *
+ * purpose: setup QDIO operation for specified adapter
+ *
+ * returns: 0 - successful setup
+ * !0 - failed setup
+ */
+int
+zfcp_erp_adapter_strategy_open_qdio(struct zfcp_erp_action *erp_action)
+{
+ int retval;
+ int i;
+ volatile struct qdio_buffer_element *sbale;
+ struct zfcp_adapter *adapter = erp_action->adapter;
+
+ if (atomic_test_mask(ZFCP_STATUS_ADAPTER_QDIOUP, &adapter->status)) {
+ ZFCP_LOG_NORMAL("bug: second attempt to set up QDIO on "
+ "adapter %s\n",
+ zfcp_get_busid_by_adapter(adapter));
+ goto failed_sanity;
+ }
+
+ if (qdio_establish(&adapter->qdio_init_data) != 0) {
+ ZFCP_LOG_INFO("error: establishment of QDIO queues failed "
+ "on adapter %s\n",
+ zfcp_get_busid_by_adapter(adapter));
+ goto failed_qdio_establish;
+ }
+ debug_text_event(adapter->erp_dbf, 3, "qdio_est");
+
+ if (qdio_activate(adapter->ccw_device, 0) != 0) {
+ ZFCP_LOG_INFO("error: activation of QDIO queues failed "
+ "on adapter %s\n",
+ zfcp_get_busid_by_adapter(adapter));
+ goto failed_qdio_activate;
+ }
+ debug_text_event(adapter->erp_dbf, 3, "qdio_act");
+
+ /*
+ * put buffers into response queue,
+ */
+ for (i = 0; i < QDIO_MAX_BUFFERS_PER_Q; i++) {
+ sbale = &(adapter->response_queue.buffer[i]->element[0]);
+ sbale->length = 0;
+ sbale->flags = SBAL_FLAGS_LAST_ENTRY;
+ sbale->addr = 0;
+ }
+
+ ZFCP_LOG_TRACE("calling do_QDIO on adapter %s (flags=0x%x, "
+ "queue_no=%i, index_in_queue=%i, count=%i)\n",
+ zfcp_get_busid_by_adapter(adapter),
+ QDIO_FLAG_SYNC_INPUT, 0, 0, QDIO_MAX_BUFFERS_PER_Q);
+
+ retval = do_QDIO(adapter->ccw_device,
+ QDIO_FLAG_SYNC_INPUT,
+ 0, 0, QDIO_MAX_BUFFERS_PER_Q, NULL);
+
+ if (retval) {
+ ZFCP_LOG_NORMAL("bug: setup of QDIO failed (retval=%d)\n",
+ retval);
+ goto failed_do_qdio;
+ } else {
+ adapter->response_queue.free_index = 0;
+ atomic_set(&adapter->response_queue.free_count, 0);
+ ZFCP_LOG_DEBUG("%i buffers successfully enqueued to "
+ "response queue\n", QDIO_MAX_BUFFERS_PER_Q);
+ }
+ /* set index of first avalable SBALS / number of available SBALS */
+ adapter->request_queue.free_index = 0;
+ atomic_set(&adapter->request_queue.free_count, QDIO_MAX_BUFFERS_PER_Q);
+ adapter->request_queue.distance_from_int = 0;
+
+ /* initialize waitqueue used to wait for free SBALs in requests queue */
+ init_waitqueue_head(&adapter->request_wq);
+
+ /* ok, we did it - skip all cleanups for different failures */
+ atomic_set_mask(ZFCP_STATUS_ADAPTER_QDIOUP, &adapter->status);
+ retval = ZFCP_ERP_SUCCEEDED;
+ goto out;
+
+ failed_do_qdio:
+ /* NOP */
+
+ failed_qdio_activate:
+ debug_text_event(adapter->erp_dbf, 3, "qdio_down1a");
+ while (qdio_shutdown(adapter->ccw_device,
+ QDIO_FLAG_CLEANUP_USING_CLEAR) == -EINPROGRESS)
+ msleep(1000);
+ debug_text_event(adapter->erp_dbf, 3, "qdio_down1b");
+
+ failed_qdio_establish:
+ failed_sanity:
+ retval = ZFCP_ERP_FAILED;
+
+ out:
+ return retval;
+}
+
+/*
+ * function: zfcp_qdio_cleanup
+ *
+ * purpose: cleans up QDIO operation for the specified adapter
+ *
+ * returns: 0 - successful cleanup
+ * !0 - failed cleanup
+ */
+int
+zfcp_erp_adapter_strategy_close_qdio(struct zfcp_erp_action *erp_action)
+{
+ int retval = ZFCP_ERP_SUCCEEDED;
+ int first_used;
+ int used_count;
+ struct zfcp_adapter *adapter = erp_action->adapter;
+
+ if (!atomic_test_mask(ZFCP_STATUS_ADAPTER_QDIOUP, &adapter->status)) {
+ ZFCP_LOG_DEBUG("error: attempt to shut down inactive QDIO "
+ "queues on adapter %s\n",
+ zfcp_get_busid_by_adapter(adapter));
+ retval = ZFCP_ERP_FAILED;
+ goto out;
+ }
+
+ /*
+ * Get queue_lock and clear QDIOUP flag. Thus it's guaranteed that
+ * do_QDIO won't be called while qdio_shutdown is in progress.
+ */
+
+ write_lock_irq(&adapter->request_queue.queue_lock);
+ atomic_clear_mask(ZFCP_STATUS_ADAPTER_QDIOUP, &adapter->status);
+ write_unlock_irq(&adapter->request_queue.queue_lock);
+
+ debug_text_event(adapter->erp_dbf, 3, "qdio_down2a");
+ while (qdio_shutdown(adapter->ccw_device,
+ QDIO_FLAG_CLEANUP_USING_CLEAR) == -EINPROGRESS)
+ msleep(1000);
+ debug_text_event(adapter->erp_dbf, 3, "qdio_down2b");
+
+ /*
+ * First we had to stop QDIO operation.
+ * Now it is safe to take the following actions.
+ */
+
+ /* Cleanup only necessary when there are unacknowledged buffers */
+ if (atomic_read(&adapter->request_queue.free_count)
+ < QDIO_MAX_BUFFERS_PER_Q) {
+ first_used = (adapter->request_queue.free_index +
+ atomic_read(&adapter->request_queue.free_count))
+ % QDIO_MAX_BUFFERS_PER_Q;
+ used_count = QDIO_MAX_BUFFERS_PER_Q -
+ atomic_read(&adapter->request_queue.free_count);
+ zfcp_qdio_zero_sbals(adapter->request_queue.buffer,
+ first_used, used_count);
+ }
+ adapter->response_queue.free_index = 0;
+ atomic_set(&adapter->response_queue.free_count, 0);
+ adapter->request_queue.free_index = 0;
+ atomic_set(&adapter->request_queue.free_count, 0);
+ adapter->request_queue.distance_from_int = 0;
+ out:
+ return retval;
+}
+
+/*
+ * function: zfcp_fsf_init
+ *
+ * purpose: initializes FSF operation for the specified adapter
+ *
+ * returns: 0 - succesful initialization of FSF operation
+ * !0 - failed to initialize FSF operation
+ */
+static int
+zfcp_erp_adapter_strategy_open_fsf(struct zfcp_erp_action *erp_action)
+{
+ int retval;
+
+ /* do 'exchange configuration data' */
+ retval = zfcp_erp_adapter_strategy_open_fsf_xconfig(erp_action);
+ if (retval == ZFCP_ERP_FAILED)
+ return retval;
+
+ /* start the desired number of Status Reads */
+ retval = zfcp_erp_adapter_strategy_open_fsf_statusread(erp_action);
+ return retval;
+}
+
+/*
+ * function:
+ *
+ * purpose:
+ *
+ * returns:
+ */
+static int
+zfcp_erp_adapter_strategy_open_fsf_xconfig(struct zfcp_erp_action *erp_action)
+{
+ int retval = ZFCP_ERP_SUCCEEDED;
+ int retries;
+ struct zfcp_adapter *adapter = erp_action->adapter;
+
+ atomic_clear_mask(ZFCP_STATUS_ADAPTER_XCONFIG_OK, &adapter->status);
+ retries = ZFCP_EXCHANGE_CONFIG_DATA_RETRIES;
+
+ do {
+ atomic_clear_mask(ZFCP_STATUS_ADAPTER_HOST_CON_INIT,
+ &adapter->status);
+ ZFCP_LOG_DEBUG("Doing exchange config data\n");
+ zfcp_erp_action_to_running(erp_action);
+ zfcp_erp_timeout_init(erp_action);
+ if (zfcp_fsf_exchange_config_data(erp_action)) {
+ retval = ZFCP_ERP_FAILED;
+ debug_text_event(adapter->erp_dbf, 5, "a_fstx_xf");
+ ZFCP_LOG_INFO("error: initiation of exchange of "
+ "configuration data failed for "
+ "adapter %s\n",
+ zfcp_get_busid_by_adapter(adapter));
+ break;
+ }
+ debug_text_event(adapter->erp_dbf, 6, "a_fstx_xok");
+ ZFCP_LOG_DEBUG("Xchange underway\n");
+
+ /*
+ * Why this works:
+ * Both the normal completion handler as well as the timeout
+ * handler will do an 'up' when the 'exchange config data'
+ * request completes or times out. Thus, the signal to go on
+ * won't be lost utilizing this semaphore.
+ * Furthermore, this 'adapter_reopen' action is
+ * guaranteed to be the only action being there (highest action
+ * which prevents other actions from being created).
+ * Resulting from that, the wake signal recognized here
+ * _must_ be the one belonging to the 'exchange config
+ * data' request.
+ */
+ down(&adapter->erp_ready_sem);
+ if (erp_action->status & ZFCP_STATUS_ERP_TIMEDOUT) {
+ ZFCP_LOG_INFO("error: exchange of configuration data "
+ "for adapter %s timed out\n",
+ zfcp_get_busid_by_adapter(adapter));
+ break;
+ }
+ if (atomic_test_mask(ZFCP_STATUS_ADAPTER_HOST_CON_INIT,
+ &adapter->status)) {
+ ZFCP_LOG_DEBUG("host connection still initialising... "
+ "waiting and retrying...\n");
+ /* sleep a little bit before retry */
+ msleep(jiffies_to_msecs(ZFCP_EXCHANGE_CONFIG_DATA_SLEEP));
+ }
+ } while ((retries--) &&
+ atomic_test_mask(ZFCP_STATUS_ADAPTER_HOST_CON_INIT,
+ &adapter->status));
+
+ if (!atomic_test_mask(ZFCP_STATUS_ADAPTER_XCONFIG_OK,
+ &adapter->status)) {
+ ZFCP_LOG_INFO("error: exchange of configuration data for "
+ "adapter %s failed\n",
+ zfcp_get_busid_by_adapter(adapter));
+ retval = ZFCP_ERP_FAILED;
+ }
+
+ return retval;
+}
+
+/*
+ * function:
+ *
+ * purpose:
+ *
+ * returns:
+ */
+static int
+zfcp_erp_adapter_strategy_open_fsf_statusread(struct zfcp_erp_action
+ *erp_action)
+{
+ int retval = ZFCP_ERP_SUCCEEDED;
+ int temp_ret;
+ struct zfcp_adapter *adapter = erp_action->adapter;
+ int i;
+
+ adapter->status_read_failed = 0;
+ for (i = 0; i < ZFCP_STATUS_READS_RECOM; i++) {
+ temp_ret = zfcp_fsf_status_read(adapter, ZFCP_WAIT_FOR_SBAL);
+ if (temp_ret < 0) {
+ ZFCP_LOG_INFO("error: set-up of unsolicited status "
+ "notification failed on adapter %s\n",
+ zfcp_get_busid_by_adapter(adapter));
+ retval = ZFCP_ERP_FAILED;
+ i--;
+ break;
+ }
+ }
+
+ return retval;
+}
+
+/*
+ * function: zfcp_fsf_cleanup
+ *
+ * purpose: cleanup FSF operation for specified adapter
+ *
+ * returns: 0 - FSF operation successfully cleaned up
+ * !0 - failed to cleanup FSF operation for this adapter
+ */
+static int
+zfcp_erp_adapter_strategy_close_fsf(struct zfcp_erp_action *erp_action)
+{
+ int retval = ZFCP_ERP_SUCCEEDED;
+ struct zfcp_adapter *adapter = erp_action->adapter;
+
+ /*
+ * wake waiting initiators of requests,
+ * return SCSI commands (with error status),
+ * clean up all requests (synchronously)
+ */
+ zfcp_fsf_req_dismiss_all(adapter);
+ /* reset FSF request sequence number */
+ adapter->fsf_req_seq_no = 0;
+ /* all ports and units are closed */
+ zfcp_erp_modify_adapter_status(adapter,
+ ZFCP_STATUS_COMMON_OPEN, ZFCP_CLEAR);
+
+ return retval;
+}
+
+/*
+ * function:
+ *
+ * purpose: this routine executes the 'Reopen Physical Port' action
+ *
+ * returns: ZFCP_ERP_CONTINUES - action continues (asynchronously)
+ * ZFCP_ERP_SUCCEEDED - action finished successfully
+ * ZFCP_ERP_FAILED - action finished unsuccessfully
+ */
+static int
+zfcp_erp_port_forced_strategy(struct zfcp_erp_action *erp_action)
+{
+ int retval = ZFCP_ERP_FAILED;
+ struct zfcp_port *port = erp_action->port;
+ struct zfcp_adapter *adapter = erp_action->adapter;
+
+ switch (erp_action->step) {
+
+ /*
+ * FIXME:
+ * the ULP spec. begs for waiting for oustanding commands
+ */
+ case ZFCP_ERP_STEP_UNINITIALIZED:
+ zfcp_erp_port_strategy_clearstati(port);
+ /*
+ * it would be sufficient to test only the normal open flag
+ * since the phys. open flag cannot be set if the normal
+ * open flag is unset - however, this is for readabilty ...
+ */
+ if (atomic_test_mask((ZFCP_STATUS_PORT_PHYS_OPEN |
+ ZFCP_STATUS_COMMON_OPEN),
+ &port->status)) {
+ ZFCP_LOG_DEBUG("port 0x%016Lx is open -> trying "
+ "close physical\n", port->wwpn);
+ retval =
+ zfcp_erp_port_forced_strategy_close(erp_action);
+ } else
+ retval = ZFCP_ERP_FAILED;
+ break;
+
+ case ZFCP_ERP_STEP_PHYS_PORT_CLOSING:
+ if (atomic_test_mask(ZFCP_STATUS_PORT_PHYS_OPEN,
+ &port->status)) {
+ ZFCP_LOG_DEBUG("close physical failed for port "
+ "0x%016Lx\n", port->wwpn);
+ retval = ZFCP_ERP_FAILED;
+ } else
+ retval = ZFCP_ERP_SUCCEEDED;
+ break;
+ }
+
+ debug_text_event(adapter->erp_dbf, 3, "p_pfst/ret");
+ debug_event(adapter->erp_dbf, 3, &port->wwpn, sizeof (wwn_t));
+ debug_event(adapter->erp_dbf, 3, &erp_action->action, sizeof (int));
+ debug_event(adapter->erp_dbf, 3, &retval, sizeof (int));
+
+ return retval;
+}
+
+/*
+ * function:
+ *
+ * purpose: this routine executes the 'Reopen Port' action
+ *
+ * returns: ZFCP_ERP_CONTINUES - action continues (asynchronously)
+ * ZFCP_ERP_SUCCEEDED - action finished successfully
+ * ZFCP_ERP_FAILED - action finished unsuccessfully
+ */
+static int
+zfcp_erp_port_strategy(struct zfcp_erp_action *erp_action)
+{
+ int retval = ZFCP_ERP_FAILED;
+ struct zfcp_port *port = erp_action->port;
+ struct zfcp_adapter *adapter = erp_action->adapter;
+
+ switch (erp_action->step) {
+
+ /*
+ * FIXME:
+ * the ULP spec. begs for waiting for oustanding commands
+ */
+ case ZFCP_ERP_STEP_UNINITIALIZED:
+ zfcp_erp_port_strategy_clearstati(port);
+ if (atomic_test_mask(ZFCP_STATUS_COMMON_OPEN, &port->status)) {
+ ZFCP_LOG_DEBUG("port 0x%016Lx is open -> trying "
+ "close\n", port->wwpn);
+ retval = zfcp_erp_port_strategy_close(erp_action);
+ goto out;
+ } /* else it's already closed, open it */
+ break;
+
+ case ZFCP_ERP_STEP_PORT_CLOSING:
+ if (atomic_test_mask(ZFCP_STATUS_COMMON_OPEN, &port->status)) {
+ ZFCP_LOG_DEBUG("close failed for port 0x%016Lx\n",
+ port->wwpn);
+ retval = ZFCP_ERP_FAILED;
+ goto out;
+ } /* else it's closed now, open it */
+ break;
+ }
+ if (erp_action->status & ZFCP_STATUS_ERP_CLOSE_ONLY)
+ retval = ZFCP_ERP_EXIT;
+ else
+ retval = zfcp_erp_port_strategy_open(erp_action);
+
+ out:
+ debug_text_event(adapter->erp_dbf, 3, "p_pst/ret");
+ debug_event(adapter->erp_dbf, 3, &port->wwpn, sizeof (wwn_t));
+ debug_event(adapter->erp_dbf, 3, &erp_action->action, sizeof (int));
+ debug_event(adapter->erp_dbf, 3, &retval, sizeof (int));
+
+ return retval;
+}
+
+/*
+ * function:
+ *
+ * purpose:
+ *
+ * returns:
+ */
+static int
+zfcp_erp_port_strategy_open(struct zfcp_erp_action *erp_action)
+{
+ int retval;
+
+ if (atomic_test_mask(ZFCP_STATUS_PORT_WKA,
+ &erp_action->port->status))
+ retval = zfcp_erp_port_strategy_open_nameserver(erp_action);
+ else
+ retval = zfcp_erp_port_strategy_open_common(erp_action);
+
+ return retval;
+}
+
+/*
+ * function:
+ *
+ * purpose:
+ *
+ * returns:
+ *
+ * FIXME(design): currently only prepared for fabric (nameserver!)
+ */
+static int
+zfcp_erp_port_strategy_open_common(struct zfcp_erp_action *erp_action)
+{
+ int retval = 0;
+ struct zfcp_adapter *adapter = erp_action->adapter;
+ struct zfcp_port *port = erp_action->port;
+
+ switch (erp_action->step) {
+
+ case ZFCP_ERP_STEP_UNINITIALIZED:
+ case ZFCP_ERP_STEP_PHYS_PORT_CLOSING:
+ case ZFCP_ERP_STEP_PORT_CLOSING:
+ if (!(adapter->nameserver_port)) {
+ retval = zfcp_nameserver_enqueue(adapter);
+ if (retval != 0) {
+ ZFCP_LOG_NORMAL("error: nameserver port "
+ "unavailable for adapter %s\n",
+ zfcp_get_busid_by_adapter(adapter));
+ retval = ZFCP_ERP_FAILED;
+ break;
+ }
+ }
+ if (!atomic_test_mask(ZFCP_STATUS_COMMON_UNBLOCKED,
+ &adapter->nameserver_port->status)) {
+ ZFCP_LOG_DEBUG("nameserver port is not open -> open "
+ "nameserver port\n");
+ /* nameserver port may live again */
+ atomic_set_mask(ZFCP_STATUS_COMMON_RUNNING,
+ &adapter->nameserver_port->status);
+ if (zfcp_erp_port_reopen(adapter->nameserver_port, 0)
+ >= 0) {
+ erp_action->step =
+ ZFCP_ERP_STEP_NAMESERVER_OPEN;
+ retval = ZFCP_ERP_CONTINUES;
+ } else
+ retval = ZFCP_ERP_FAILED;
+ break;
+ }
+ /* else nameserver port is already open, fall through */
+ case ZFCP_ERP_STEP_NAMESERVER_OPEN:
+ if (!atomic_test_mask(ZFCP_STATUS_COMMON_OPEN,
+ &adapter->nameserver_port->status)) {
+ ZFCP_LOG_DEBUG("open failed for nameserver port\n");
+ retval = ZFCP_ERP_FAILED;
+ } else {
+ ZFCP_LOG_DEBUG("nameserver port is open -> "
+ "nameserver look-up for port 0x%016Lx\n",
+ port->wwpn);
+ retval = zfcp_erp_port_strategy_open_common_lookup
+ (erp_action);
+ }
+ break;
+
+ case ZFCP_ERP_STEP_NAMESERVER_LOOKUP:
+ if (!atomic_test_mask(ZFCP_STATUS_PORT_DID_DID, &port->status)) {
+ if (atomic_test_mask
+ (ZFCP_STATUS_PORT_INVALID_WWPN, &port->status)) {
+ ZFCP_LOG_DEBUG("nameserver look-up failed "
+ "for port 0x%016Lx "
+ "(misconfigured WWPN?)\n",
+ port->wwpn);
+ zfcp_erp_port_failed(port);
+ retval = ZFCP_ERP_EXIT;
+ } else {
+ ZFCP_LOG_DEBUG("nameserver look-up failed for "
+ "port 0x%016Lx\n", port->wwpn);
+ retval = ZFCP_ERP_FAILED;
+ }
+ } else {
+ ZFCP_LOG_DEBUG("port 0x%016Lx has d_id=0x%08x -> "
+ "trying open\n", port->wwpn, port->d_id);
+ retval = zfcp_erp_port_strategy_open_port(erp_action);
+ }
+ break;
+
+ case ZFCP_ERP_STEP_PORT_OPENING:
+ /* D_ID might have changed during open */
+ if (atomic_test_mask((ZFCP_STATUS_COMMON_OPEN |
+ ZFCP_STATUS_PORT_DID_DID),
+ &port->status)) {
+ ZFCP_LOG_DEBUG("port 0x%016Lx is open\n", port->wwpn);
+ retval = ZFCP_ERP_SUCCEEDED;
+ } else {
+ ZFCP_LOG_DEBUG("open failed for port 0x%016Lx\n",
+ port->wwpn);
+ retval = ZFCP_ERP_FAILED;
+ }
+ break;
+
+ default:
+ ZFCP_LOG_NORMAL("bug: unknown erp step 0x%08x\n",
+ erp_action->step);
+ retval = ZFCP_ERP_FAILED;
+ }
+
+ return retval;
+}
+
+/*
+ * function:
+ *
+ * purpose:
+ *
+ * returns:
+ */
+static int
+zfcp_erp_port_strategy_open_nameserver(struct zfcp_erp_action *erp_action)
+{
+ int retval;
+ struct zfcp_port *port = erp_action->port;
+
+ switch (erp_action->step) {
+
+ case ZFCP_ERP_STEP_UNINITIALIZED:
+ case ZFCP_ERP_STEP_PHYS_PORT_CLOSING:
+ case ZFCP_ERP_STEP_PORT_CLOSING:
+ ZFCP_LOG_DEBUG("port 0x%016Lx has d_id=0x%08x -> trying open\n",
+ port->wwpn, port->d_id);
+ retval = zfcp_erp_port_strategy_open_port(erp_action);
+ break;
+
+ case ZFCP_ERP_STEP_PORT_OPENING:
+ if (atomic_test_mask(ZFCP_STATUS_COMMON_OPEN, &port->status)) {
+ ZFCP_LOG_DEBUG("WKA port is open\n");
+ retval = ZFCP_ERP_SUCCEEDED;
+ } else {
+ ZFCP_LOG_DEBUG("open failed for WKA port\n");
+ retval = ZFCP_ERP_FAILED;
+ }
+ /* this is needed anyway (dont care for retval of wakeup) */
+ ZFCP_LOG_DEBUG("continue other open port operations\n");
+ zfcp_erp_port_strategy_open_nameserver_wakeup(erp_action);
+ break;
+
+ default:
+ ZFCP_LOG_NORMAL("bug: unknown erp step 0x%08x\n",
+ erp_action->step);
+ retval = ZFCP_ERP_FAILED;
+ }
+
+ return retval;
+}
+
+/*
+ * function:
+ *
+ * purpose: makes the erp thread continue with reopen (physical) port
+ * actions which have been paused until the name server port
+ * is opened (or failed)
+ *
+ * returns: 0 (a kind of void retval, its not used)
+ */
+static int
+zfcp_erp_port_strategy_open_nameserver_wakeup(struct zfcp_erp_action
+ *ns_erp_action)
+{
+ int retval = 0;
+ unsigned long flags;
+ struct zfcp_adapter *adapter = ns_erp_action->adapter;
+ struct zfcp_erp_action *erp_action, *tmp;
+
+ read_lock_irqsave(&adapter->erp_lock, flags);
+ list_for_each_entry_safe(erp_action, tmp, &adapter->erp_running_head,
+ list) {
+ debug_text_event(adapter->erp_dbf, 4, "p_pstnsw_n");
+ debug_event(adapter->erp_dbf, 4, &erp_action->port->wwpn,
+ sizeof (wwn_t));
+ if (erp_action->step == ZFCP_ERP_STEP_NAMESERVER_OPEN) {
+ debug_text_event(adapter->erp_dbf, 3, "p_pstnsw_w");
+ debug_event(adapter->erp_dbf, 3,
+ &erp_action->port->wwpn, sizeof (wwn_t));
+ if (atomic_test_mask(
+ ZFCP_STATUS_COMMON_ERP_FAILED,
+ &adapter->nameserver_port->status))
+ zfcp_erp_port_failed(erp_action->port);
+ zfcp_erp_action_ready(erp_action);
+ }
+ }
+ read_unlock_irqrestore(&adapter->erp_lock, flags);
+
+ return retval;
+}
+
+/*
+ * function:
+ *
+ * purpose:
+ *
+ * returns: ZFCP_ERP_CONTINUES - action continues (asynchronously)
+ * ZFCP_ERP_FAILED - action finished unsuccessfully
+ */
+static int
+zfcp_erp_port_forced_strategy_close(struct zfcp_erp_action *erp_action)
+{
+ int retval;
+ struct zfcp_adapter *adapter = erp_action->adapter;
+ struct zfcp_port *port = erp_action->port;
+
+ zfcp_erp_timeout_init(erp_action);
+ retval = zfcp_fsf_close_physical_port(erp_action);
+ if (retval == -ENOMEM) {
+ debug_text_event(adapter->erp_dbf, 5, "o_pfstc_nomem");
+ debug_event(adapter->erp_dbf, 5, &port->wwpn, sizeof (wwn_t));
+ retval = ZFCP_ERP_NOMEM;
+ goto out;
+ }
+ erp_action->step = ZFCP_ERP_STEP_PHYS_PORT_CLOSING;
+ if (retval != 0) {
+ debug_text_event(adapter->erp_dbf, 5, "o_pfstc_cpf");
+ debug_event(adapter->erp_dbf, 5, &port->wwpn, sizeof (wwn_t));
+ /* could not send 'open', fail */
+ retval = ZFCP_ERP_FAILED;
+ goto out;
+ }
+ debug_text_event(adapter->erp_dbf, 6, "o_pfstc_cpok");
+ debug_event(adapter->erp_dbf, 6, &port->wwpn, sizeof (wwn_t));
+ retval = ZFCP_ERP_CONTINUES;
+ out:
+ return retval;
+}
+
+/*
+ * function:
+ *
+ * purpose:
+ *
+ * returns:
+ */
+static int
+zfcp_erp_port_strategy_clearstati(struct zfcp_port *port)
+{
+ int retval = 0;
+ struct zfcp_adapter *adapter = port->adapter;
+
+ debug_text_event(adapter->erp_dbf, 5, "p_pstclst");
+ debug_event(adapter->erp_dbf, 5, &port->wwpn, sizeof (wwn_t));
+
+ atomic_clear_mask(ZFCP_STATUS_COMMON_OPENING |
+ ZFCP_STATUS_COMMON_CLOSING |
+ ZFCP_STATUS_COMMON_ACCESS_DENIED |
+ ZFCP_STATUS_PORT_DID_DID |
+ ZFCP_STATUS_PORT_PHYS_CLOSING |
+ ZFCP_STATUS_PORT_INVALID_WWPN,
+ &port->status);
+ return retval;
+}
+
+/*
+ * function:
+ *
+ * purpose:
+ *
+ * returns: ZFCP_ERP_CONTINUES - action continues (asynchronously)
+ * ZFCP_ERP_FAILED - action finished unsuccessfully
+ */
+static int
+zfcp_erp_port_strategy_close(struct zfcp_erp_action *erp_action)
+{
+ int retval;
+ struct zfcp_adapter *adapter = erp_action->adapter;
+ struct zfcp_port *port = erp_action->port;
+
+ zfcp_erp_timeout_init(erp_action);
+ retval = zfcp_fsf_close_port(erp_action);
+ if (retval == -ENOMEM) {
+ debug_text_event(adapter->erp_dbf, 5, "p_pstc_nomem");
+ debug_event(adapter->erp_dbf, 5, &port->wwpn, sizeof (wwn_t));
+ retval = ZFCP_ERP_NOMEM;
+ goto out;
+ }
+ erp_action->step = ZFCP_ERP_STEP_PORT_CLOSING;
+ if (retval != 0) {
+ debug_text_event(adapter->erp_dbf, 5, "p_pstc_cpf");
+ debug_event(adapter->erp_dbf, 5, &port->wwpn, sizeof (wwn_t));
+ /* could not send 'close', fail */
+ retval = ZFCP_ERP_FAILED;
+ goto out;
+ }
+ debug_text_event(adapter->erp_dbf, 6, "p_pstc_cpok");
+ debug_event(adapter->erp_dbf, 6, &port->wwpn, sizeof (wwn_t));
+ retval = ZFCP_ERP_CONTINUES;
+ out:
+ return retval;
+}
+
+/*
+ * function:
+ *
+ * purpose:
+ *
+ * returns: ZFCP_ERP_CONTINUES - action continues (asynchronously)
+ * ZFCP_ERP_FAILED - action finished unsuccessfully
+ */
+static int
+zfcp_erp_port_strategy_open_port(struct zfcp_erp_action *erp_action)
+{
+ int retval;
+ struct zfcp_adapter *adapter = erp_action->adapter;
+ struct zfcp_port *port = erp_action->port;
+
+ zfcp_erp_timeout_init(erp_action);
+ retval = zfcp_fsf_open_port(erp_action);
+ if (retval == -ENOMEM) {
+ debug_text_event(adapter->erp_dbf, 5, "p_psto_nomem");
+ debug_event(adapter->erp_dbf, 5, &port->wwpn, sizeof (wwn_t));
+ retval = ZFCP_ERP_NOMEM;
+ goto out;
+ }
+ erp_action->step = ZFCP_ERP_STEP_PORT_OPENING;
+ if (retval != 0) {
+ debug_text_event(adapter->erp_dbf, 5, "p_psto_opf");
+ debug_event(adapter->erp_dbf, 5, &port->wwpn, sizeof (wwn_t));
+ /* could not send 'open', fail */
+ retval = ZFCP_ERP_FAILED;
+ goto out;
+ }
+ debug_text_event(adapter->erp_dbf, 6, "p_psto_opok");
+ debug_event(adapter->erp_dbf, 6, &port->wwpn, sizeof (wwn_t));
+ retval = ZFCP_ERP_CONTINUES;
+ out:
+ return retval;
+}
+
+/*
+ * function:
+ *
+ * purpose:
+ *
+ * returns: ZFCP_ERP_CONTINUES - action continues (asynchronously)
+ * ZFCP_ERP_FAILED - action finished unsuccessfully
+ */
+static int
+zfcp_erp_port_strategy_open_common_lookup(struct zfcp_erp_action *erp_action)
+{
+ int retval;
+ struct zfcp_adapter *adapter = erp_action->adapter;
+ struct zfcp_port *port = erp_action->port;
+
+ zfcp_erp_timeout_init(erp_action);
+ retval = zfcp_ns_gid_pn_request(erp_action);
+ if (retval == -ENOMEM) {
+ debug_text_event(adapter->erp_dbf, 5, "p_pstn_nomem");
+ debug_event(adapter->erp_dbf, 5, &port->wwpn, sizeof (wwn_t));
+ retval = ZFCP_ERP_NOMEM;
+ goto out;
+ }
+ erp_action->step = ZFCP_ERP_STEP_NAMESERVER_LOOKUP;
+ if (retval != 0) {
+ debug_text_event(adapter->erp_dbf, 5, "p_pstn_ref");
+ debug_event(adapter->erp_dbf, 5, &port->wwpn, sizeof (wwn_t));
+ /* could not send nameserver request, fail */
+ retval = ZFCP_ERP_FAILED;
+ goto out;
+ }
+ debug_text_event(adapter->erp_dbf, 6, "p_pstn_reok");
+ debug_event(adapter->erp_dbf, 6, &port->wwpn, sizeof (wwn_t));
+ retval = ZFCP_ERP_CONTINUES;
+ out:
+ return retval;
+}
+
+/*
+ * function:
+ *
+ * purpose: this routine executes the 'Reopen Unit' action
+ * currently no retries
+ *
+ * returns: ZFCP_ERP_CONTINUES - action continues (asynchronously)
+ * ZFCP_ERP_SUCCEEDED - action finished successfully
+ * ZFCP_ERP_FAILED - action finished unsuccessfully
+ */
+static int
+zfcp_erp_unit_strategy(struct zfcp_erp_action *erp_action)
+{
+ int retval = ZFCP_ERP_FAILED;
+ struct zfcp_unit *unit = erp_action->unit;
+ struct zfcp_adapter *adapter = erp_action->adapter;
+
+ switch (erp_action->step) {
+
+ /*
+ * FIXME:
+ * the ULP spec. begs for waiting for oustanding commands
+ */
+ case ZFCP_ERP_STEP_UNINITIALIZED:
+ zfcp_erp_unit_strategy_clearstati(unit);
+ if (atomic_test_mask(ZFCP_STATUS_COMMON_OPEN, &unit->status)) {
+ ZFCP_LOG_DEBUG("unit 0x%016Lx is open -> "
+ "trying close\n", unit->fcp_lun);
+ retval = zfcp_erp_unit_strategy_close(erp_action);
+ break;
+ }
+ /* else it's already closed, fall through */
+ case ZFCP_ERP_STEP_UNIT_CLOSING:
+ if (atomic_test_mask(ZFCP_STATUS_COMMON_OPEN, &unit->status)) {
+ ZFCP_LOG_DEBUG("close failed for unit 0x%016Lx\n",
+ unit->fcp_lun);
+ retval = ZFCP_ERP_FAILED;
+ } else {
+ if (erp_action->status & ZFCP_STATUS_ERP_CLOSE_ONLY)
+ retval = ZFCP_ERP_EXIT;
+ else {
+ ZFCP_LOG_DEBUG("unit 0x%016Lx is not open -> "
+ "trying open\n", unit->fcp_lun);
+ retval =
+ zfcp_erp_unit_strategy_open(erp_action);
+ }
+ }
+ break;
+
+ case ZFCP_ERP_STEP_UNIT_OPENING:
+ if (atomic_test_mask(ZFCP_STATUS_COMMON_OPEN, &unit->status)) {
+ ZFCP_LOG_DEBUG("unit 0x%016Lx is open\n",
+ unit->fcp_lun);
+ retval = ZFCP_ERP_SUCCEEDED;
+ } else {
+ ZFCP_LOG_DEBUG("open failed for unit 0x%016Lx\n",
+ unit->fcp_lun);
+ retval = ZFCP_ERP_FAILED;
+ }
+ break;
+ }
+
+ debug_text_event(adapter->erp_dbf, 3, "u_ust/ret");
+ debug_event(adapter->erp_dbf, 3, &unit->fcp_lun, sizeof (fcp_lun_t));
+ debug_event(adapter->erp_dbf, 3, &erp_action->action, sizeof (int));
+ debug_event(adapter->erp_dbf, 3, &retval, sizeof (int));
+ return retval;
+}
+
+/*
+ * function:
+ *
+ * purpose:
+ *
+ * returns:
+ */
+static int
+zfcp_erp_unit_strategy_clearstati(struct zfcp_unit *unit)
+{
+ int retval = 0;
+ struct zfcp_adapter *adapter = unit->port->adapter;
+
+ debug_text_event(adapter->erp_dbf, 5, "u_ustclst");
+ debug_event(adapter->erp_dbf, 5, &unit->fcp_lun, sizeof (fcp_lun_t));
+
+ atomic_clear_mask(ZFCP_STATUS_COMMON_OPENING |
+ ZFCP_STATUS_COMMON_CLOSING |
+ ZFCP_STATUS_COMMON_ACCESS_DENIED |
+ ZFCP_STATUS_UNIT_SHARED |
+ ZFCP_STATUS_UNIT_READONLY,
+ &unit->status);
+
+ return retval;
+}
+
+/*
+ * function:
+ *
+ * purpose:
+ *
+ * returns: ZFCP_ERP_CONTINUES - action continues (asynchronously)
+ * ZFCP_ERP_FAILED - action finished unsuccessfully
+ */
+static int
+zfcp_erp_unit_strategy_close(struct zfcp_erp_action *erp_action)
+{
+ int retval;
+ struct zfcp_adapter *adapter = erp_action->adapter;
+ struct zfcp_unit *unit = erp_action->unit;
+
+ zfcp_erp_timeout_init(erp_action);
+ retval = zfcp_fsf_close_unit(erp_action);
+ if (retval == -ENOMEM) {
+ debug_text_event(adapter->erp_dbf, 5, "u_ustc_nomem");
+ debug_event(adapter->erp_dbf, 5, &unit->fcp_lun,
+ sizeof (fcp_lun_t));
+ retval = ZFCP_ERP_NOMEM;
+ goto out;
+ }
+ erp_action->step = ZFCP_ERP_STEP_UNIT_CLOSING;
+ if (retval != 0) {
+ debug_text_event(adapter->erp_dbf, 5, "u_ustc_cuf");
+ debug_event(adapter->erp_dbf, 5, &unit->fcp_lun,
+ sizeof (fcp_lun_t));
+ /* could not send 'close', fail */
+ retval = ZFCP_ERP_FAILED;
+ goto out;
+ }
+ debug_text_event(adapter->erp_dbf, 6, "u_ustc_cuok");
+ debug_event(adapter->erp_dbf, 6, &unit->fcp_lun, sizeof (fcp_lun_t));
+ retval = ZFCP_ERP_CONTINUES;
+
+ out:
+ return retval;
+}
+
+/*
+ * function:
+ *
+ * purpose:
+ *
+ * returns: ZFCP_ERP_CONTINUES - action continues (asynchronously)
+ * ZFCP_ERP_FAILED - action finished unsuccessfully
+ */
+static int
+zfcp_erp_unit_strategy_open(struct zfcp_erp_action *erp_action)
+{
+ int retval;
+ struct zfcp_adapter *adapter = erp_action->adapter;
+ struct zfcp_unit *unit = erp_action->unit;
+
+ zfcp_erp_timeout_init(erp_action);
+ retval = zfcp_fsf_open_unit(erp_action);
+ if (retval == -ENOMEM) {
+ debug_text_event(adapter->erp_dbf, 5, "u_usto_nomem");
+ debug_event(adapter->erp_dbf, 5, &unit->fcp_lun,
+ sizeof (fcp_lun_t));
+ retval = ZFCP_ERP_NOMEM;
+ goto out;
+ }
+ erp_action->step = ZFCP_ERP_STEP_UNIT_OPENING;
+ if (retval != 0) {
+ debug_text_event(adapter->erp_dbf, 5, "u_usto_ouf");
+ debug_event(adapter->erp_dbf, 5, &unit->fcp_lun,
+ sizeof (fcp_lun_t));
+ /* could not send 'open', fail */
+ retval = ZFCP_ERP_FAILED;
+ goto out;
+ }
+ debug_text_event(adapter->erp_dbf, 6, "u_usto_ouok");
+ debug_event(adapter->erp_dbf, 6, &unit->fcp_lun, sizeof (fcp_lun_t));
+ retval = ZFCP_ERP_CONTINUES;
+ out:
+ return retval;
+}
+
+/*
+ * function:
+ *
+ * purpose:
+ *
+ * returns:
+ */
+static inline void
+zfcp_erp_timeout_init(struct zfcp_erp_action *erp_action)
+{
+ init_timer(&erp_action->timer);
+ erp_action->timer.function = zfcp_erp_timeout_handler;
+ erp_action->timer.data = (unsigned long) erp_action;
+ /* jiffies will be added in zfcp_fsf_req_send */
+ erp_action->timer.expires = ZFCP_ERP_FSFREQ_TIMEOUT;
+}
+
+/*
+ * function:
+ *
+ * purpose: enqueue the specified error recovery action, if needed
+ *
+ * returns:
+ */
+static int
+zfcp_erp_action_enqueue(int action,
+ struct zfcp_adapter *adapter,
+ struct zfcp_port *port, struct zfcp_unit *unit)
+{
+ int retval = 1;
+ struct zfcp_erp_action *erp_action = NULL;
+ int stronger_action = 0;
+ u32 status = 0;
+
+ /*
+ * We need some rules here which check whether we really need
+ * this action or whether we should just drop it.
+ * E.g. if there is a unfinished 'Reopen Port' request then we drop a
+ * 'Reopen Unit' request for an associated unit since we can't
+ * satisfy this request now. A 'Reopen Port' action will trigger
+ * 'Reopen Unit' actions when it completes.
+ * Thus, there are only actions in the queue which can immediately be
+ * executed. This makes the processing of the action queue more
+ * efficient.
+ */
+
+ if (!atomic_test_mask(ZFCP_STATUS_ADAPTER_ERP_THREAD_UP,
+ &adapter->status))
+ return -EIO;
+
+ debug_event(adapter->erp_dbf, 4, &action, sizeof (int));
+ /* check whether we really need this */
+ switch (action) {
+ case ZFCP_ERP_ACTION_REOPEN_UNIT:
+ if (atomic_test_mask
+ (ZFCP_STATUS_COMMON_ERP_INUSE, &unit->status)) {
+ debug_text_event(adapter->erp_dbf, 4, "u_actenq_drp");
+ debug_event(adapter->erp_dbf, 4, &port->wwpn,
+ sizeof (wwn_t));
+ debug_event(adapter->erp_dbf, 4, &unit->fcp_lun,
+ sizeof (fcp_lun_t));
+ goto out;
+ }
+ if (!atomic_test_mask
+ (ZFCP_STATUS_COMMON_RUNNING, &port->status) ||
+ atomic_test_mask
+ (ZFCP_STATUS_COMMON_ERP_FAILED, &port->status)) {
+ goto out;
+ }
+ if (!atomic_test_mask
+ (ZFCP_STATUS_COMMON_UNBLOCKED, &port->status)) {
+ stronger_action = ZFCP_ERP_ACTION_REOPEN_PORT;
+ unit = NULL;
+ }
+ /* fall through !!! */
+
+ case ZFCP_ERP_ACTION_REOPEN_PORT:
+ if (atomic_test_mask
+ (ZFCP_STATUS_COMMON_ERP_INUSE, &port->status)) {
+ debug_text_event(adapter->erp_dbf, 4, "p_actenq_drp");
+ debug_event(adapter->erp_dbf, 4, &port->wwpn,
+ sizeof (wwn_t));
+ goto out;
+ }
+ /* fall through !!! */
+
+ case ZFCP_ERP_ACTION_REOPEN_PORT_FORCED:
+ if (atomic_test_mask
+ (ZFCP_STATUS_COMMON_ERP_INUSE, &port->status)
+ && port->erp_action.action ==
+ ZFCP_ERP_ACTION_REOPEN_PORT_FORCED) {
+ debug_text_event(adapter->erp_dbf, 4, "pf_actenq_drp");
+ debug_event(adapter->erp_dbf, 4, &port->wwpn,
+ sizeof (wwn_t));
+ goto out;
+ }
+ if (!atomic_test_mask
+ (ZFCP_STATUS_COMMON_RUNNING, &adapter->status) ||
+ atomic_test_mask
+ (ZFCP_STATUS_COMMON_ERP_FAILED, &adapter->status)) {
+ goto out;
+ }
+ if (!atomic_test_mask
+ (ZFCP_STATUS_COMMON_UNBLOCKED, &adapter->status)) {
+ stronger_action = ZFCP_ERP_ACTION_REOPEN_ADAPTER;
+ port = NULL;
+ }
+ /* fall through !!! */
+
+ case ZFCP_ERP_ACTION_REOPEN_ADAPTER:
+ if (atomic_test_mask
+ (ZFCP_STATUS_COMMON_ERP_INUSE, &adapter->status)) {
+ debug_text_event(adapter->erp_dbf, 4, "a_actenq_drp");
+ goto out;
+ }
+ break;
+
+ default:
+ debug_text_exception(adapter->erp_dbf, 1, "a_actenq_bug");
+ debug_event(adapter->erp_dbf, 1, &action, sizeof (int));
+ ZFCP_LOG_NORMAL("bug: unknown erp action requested "
+ "on adapter %s (action=%d)\n",
+ zfcp_get_busid_by_adapter(adapter), action);
+ goto out;
+ }
+
+ /* check whether we need something stronger first */
+ if (stronger_action) {
+ debug_text_event(adapter->erp_dbf, 4, "a_actenq_str");
+ debug_event(adapter->erp_dbf, 4, &stronger_action,
+ sizeof (int));
+ ZFCP_LOG_DEBUG("stronger erp action %d needed before "
+ "erp action %d on adapter %s\n",
+ stronger_action, action,
+ zfcp_get_busid_by_adapter(adapter));
+ action = stronger_action;
+ }
+
+ /* mark adapter to have some error recovery pending */
+ atomic_set_mask(ZFCP_STATUS_ADAPTER_ERP_PENDING, &adapter->status);
+
+ /* setup error recovery action */
+ switch (action) {
+
+ case ZFCP_ERP_ACTION_REOPEN_UNIT:
+ zfcp_unit_get(unit);
+ atomic_set_mask(ZFCP_STATUS_COMMON_ERP_INUSE, &unit->status);
+ erp_action = &unit->erp_action;
+ if (!atomic_test_mask
+ (ZFCP_STATUS_COMMON_RUNNING, &unit->status))
+ status = ZFCP_STATUS_ERP_CLOSE_ONLY;
+ break;
+
+ case ZFCP_ERP_ACTION_REOPEN_PORT:
+ case ZFCP_ERP_ACTION_REOPEN_PORT_FORCED:
+ zfcp_port_get(port);
+ zfcp_erp_action_dismiss_port(port);
+ atomic_set_mask(ZFCP_STATUS_COMMON_ERP_INUSE, &port->status);
+ erp_action = &port->erp_action;
+ if (!atomic_test_mask
+ (ZFCP_STATUS_COMMON_RUNNING, &port->status))
+ status = ZFCP_STATUS_ERP_CLOSE_ONLY;
+ break;
+
+ case ZFCP_ERP_ACTION_REOPEN_ADAPTER:
+ zfcp_adapter_get(adapter);
+ zfcp_erp_action_dismiss_adapter(adapter);
+ atomic_set_mask(ZFCP_STATUS_COMMON_ERP_INUSE, &adapter->status);
+ erp_action = &adapter->erp_action;
+ if (!atomic_test_mask
+ (ZFCP_STATUS_COMMON_RUNNING, &adapter->status))
+ status = ZFCP_STATUS_ERP_CLOSE_ONLY;
+ break;
+ }
+
+ debug_text_event(adapter->erp_dbf, 4, "a_actenq");
+
+ memset(erp_action, 0, sizeof (struct zfcp_erp_action));
+ erp_action->adapter = adapter;
+ erp_action->port = port;
+ erp_action->unit = unit;
+ erp_action->action = action;
+ erp_action->status = status;
+
+ ++adapter->erp_total_count;
+
+ /* finally put it into 'ready' queue and kick erp thread */
+ list_add(&erp_action->list, &adapter->erp_ready_head);
+ up(&adapter->erp_ready_sem);
+ retval = 0;
+ out:
+ return retval;
+}
+
+/*
+ * function:
+ *
+ * purpose:
+ *
+ * returns:
+ */
+static int
+zfcp_erp_action_dequeue(struct zfcp_erp_action *erp_action)
+{
+ int retval = 0;
+ struct zfcp_adapter *adapter = erp_action->adapter;
+
+ --adapter->erp_total_count;
+ if (erp_action->status & ZFCP_STATUS_ERP_LOWMEM) {
+ --adapter->erp_low_mem_count;
+ erp_action->status &= ~ZFCP_STATUS_ERP_LOWMEM;
+ }
+
+ debug_text_event(adapter->erp_dbf, 4, "a_actdeq");
+ debug_event(adapter->erp_dbf, 4, &erp_action->action, sizeof (int));
+ list_del(&erp_action->list);
+ switch (erp_action->action) {
+ case ZFCP_ERP_ACTION_REOPEN_UNIT:
+ atomic_clear_mask(ZFCP_STATUS_COMMON_ERP_INUSE,
+ &erp_action->unit->status);
+ break;
+ case ZFCP_ERP_ACTION_REOPEN_PORT_FORCED:
+ case ZFCP_ERP_ACTION_REOPEN_PORT:
+ atomic_clear_mask(ZFCP_STATUS_COMMON_ERP_INUSE,
+ &erp_action->port->status);
+ break;
+ case ZFCP_ERP_ACTION_REOPEN_ADAPTER:
+ atomic_clear_mask(ZFCP_STATUS_COMMON_ERP_INUSE,
+ &erp_action->adapter->status);
+ break;
+ default:
+ /* bug */
+ break;
+ }
+ return retval;
+}
+
+/**
+ * zfcp_erp_action_cleanup
+ *
+ * Register unit with scsi stack if appropiate and fix reference counts.
+ * Note: Temporary units are not registered with scsi stack.
+ */
+static void
+zfcp_erp_action_cleanup(int action, struct zfcp_adapter *adapter,
+ struct zfcp_port *port, struct zfcp_unit *unit,
+ int result)
+{
+ switch (action) {
+ case ZFCP_ERP_ACTION_REOPEN_UNIT:
+ if ((result == ZFCP_ERP_SUCCEEDED)
+ && (!atomic_test_mask(ZFCP_STATUS_UNIT_TEMPORARY,
+ &unit->status))
+ && (!unit->device))
+ scsi_add_device(unit->port->adapter->scsi_host, 0,
+ unit->port->scsi_id, unit->scsi_lun);
+ zfcp_unit_put(unit);
+ break;
+ case ZFCP_ERP_ACTION_REOPEN_PORT_FORCED:
+ case ZFCP_ERP_ACTION_REOPEN_PORT:
+ zfcp_port_put(port);
+ break;
+ case ZFCP_ERP_ACTION_REOPEN_ADAPTER:
+ zfcp_adapter_put(adapter);
+ break;
+ default:
+ break;
+ }
+}
+
+
+/*
+ * function:
+ *
+ * purpose:
+ *
+ * returns: FIXME
+ */
+static int
+zfcp_erp_action_dismiss_adapter(struct zfcp_adapter *adapter)
+{
+ int retval = 0;
+ struct zfcp_port *port;
+
+ debug_text_event(adapter->erp_dbf, 5, "a_actab");
+ if (atomic_test_mask(ZFCP_STATUS_COMMON_ERP_INUSE, &adapter->status))
+ zfcp_erp_action_dismiss(&adapter->erp_action);
+ else
+ list_for_each_entry(port, &adapter->port_list_head, list)
+ zfcp_erp_action_dismiss_port(port);
+
+ return retval;
+}
+
+/*
+ * function:
+ *
+ * purpose:
+ *
+ * returns: FIXME
+ */
+static int
+zfcp_erp_action_dismiss_port(struct zfcp_port *port)
+{
+ int retval = 0;
+ struct zfcp_unit *unit;
+ struct zfcp_adapter *adapter = port->adapter;
+
+ debug_text_event(adapter->erp_dbf, 5, "p_actab");
+ debug_event(adapter->erp_dbf, 5, &port->wwpn, sizeof (wwn_t));
+ if (atomic_test_mask(ZFCP_STATUS_COMMON_ERP_INUSE, &port->status))
+ zfcp_erp_action_dismiss(&port->erp_action);
+ else
+ list_for_each_entry(unit, &port->unit_list_head, list)
+ zfcp_erp_action_dismiss_unit(unit);
+
+ return retval;
+}
+
+/*
+ * function:
+ *
+ * purpose:
+ *
+ * returns: FIXME
+ */
+static int
+zfcp_erp_action_dismiss_unit(struct zfcp_unit *unit)
+{
+ int retval = 0;
+ struct zfcp_adapter *adapter = unit->port->adapter;
+
+ debug_text_event(adapter->erp_dbf, 5, "u_actab");
+ debug_event(adapter->erp_dbf, 5, &unit->fcp_lun, sizeof (fcp_lun_t));
+ if (atomic_test_mask(ZFCP_STATUS_COMMON_ERP_INUSE, &unit->status))
+ zfcp_erp_action_dismiss(&unit->erp_action);
+
+ return retval;
+}
+
+/*
+ * function:
+ *
+ * purpose: moves erp_action to 'erp running list'
+ *
+ * returns:
+ */
+static inline void
+zfcp_erp_action_to_running(struct zfcp_erp_action *erp_action)
+{
+ struct zfcp_adapter *adapter = erp_action->adapter;
+
+ debug_text_event(adapter->erp_dbf, 6, "a_toru");
+ debug_event(adapter->erp_dbf, 6, &erp_action->action, sizeof (int));
+ list_move(&erp_action->list, &erp_action->adapter->erp_running_head);
+}
+
+/*
+ * function:
+ *
+ * purpose: moves erp_action to 'erp ready list'
+ *
+ * returns:
+ */
+static inline void
+zfcp_erp_action_to_ready(struct zfcp_erp_action *erp_action)
+{
+ struct zfcp_adapter *adapter = erp_action->adapter;
+
+ debug_text_event(adapter->erp_dbf, 6, "a_tore");
+ debug_event(adapter->erp_dbf, 6, &erp_action->action, sizeof (int));
+ list_move(&erp_action->list, &erp_action->adapter->erp_ready_head);
+}
+
+/*
+ * function: zfcp_erp_port_access_denied
+ *
+ * purpose:
+ */
+void
+zfcp_erp_port_access_denied(struct zfcp_port *port)
+{
+ struct zfcp_adapter *adapter = port->adapter;
+ unsigned long flags;
+
+ debug_text_event(adapter->erp_dbf, 3, "p_access_block");
+ debug_event(adapter->erp_dbf, 3, &port->wwpn, sizeof(wwn_t));
+ read_lock_irqsave(&zfcp_data.config_lock, flags);
+ zfcp_erp_modify_port_status(port, ZFCP_STATUS_COMMON_ERP_FAILED |
+ ZFCP_STATUS_COMMON_ACCESS_DENIED, ZFCP_SET);
+ read_unlock_irqrestore(&zfcp_data.config_lock, flags);
+}
+
+/*
+ * function: zfcp_erp_unit_access_denied
+ *
+ * purpose:
+ */
+void
+zfcp_erp_unit_access_denied(struct zfcp_unit *unit)
+{
+ struct zfcp_adapter *adapter = unit->port->adapter;
+
+ debug_text_event(adapter->erp_dbf, 3, "u_access_block");
+ debug_event(adapter->erp_dbf, 3, &unit->fcp_lun, sizeof(fcp_lun_t));
+ zfcp_erp_modify_unit_status(unit, ZFCP_STATUS_COMMON_ERP_FAILED |
+ ZFCP_STATUS_COMMON_ACCESS_DENIED, ZFCP_SET);
+}
+
+/*
+ * function: zfcp_erp_adapter_access_changed
+ *
+ * purpose:
+ */
+void
+zfcp_erp_adapter_access_changed(struct zfcp_adapter *adapter)
+{
+ struct zfcp_port *port;
+ unsigned long flags;
+
+ debug_text_event(adapter->erp_dbf, 3, "a_access_unblock");
+ debug_event(adapter->erp_dbf, 3, &adapter->name, 8);
+
+ zfcp_erp_port_access_changed(adapter->nameserver_port);
+ read_lock_irqsave(&zfcp_data.config_lock, flags);
+ list_for_each_entry(port, &adapter->port_list_head, list)
+ if (port != adapter->nameserver_port)
+ zfcp_erp_port_access_changed(port);
+ read_unlock_irqrestore(&zfcp_data.config_lock, flags);
+}
+
+/*
+ * function: zfcp_erp_port_access_changed
+ *
+ * purpose:
+ */
+void
+zfcp_erp_port_access_changed(struct zfcp_port *port)
+{
+ struct zfcp_adapter *adapter = port->adapter;
+ struct zfcp_unit *unit;
+
+ debug_text_event(adapter->erp_dbf, 3, "p_access_unblock");
+ debug_event(adapter->erp_dbf, 3, &port->wwpn, sizeof(wwn_t));
+
+ if (!atomic_test_mask(ZFCP_STATUS_COMMON_ACCESS_DENIED,
+ &port->status)) {
+ if (!atomic_test_mask(ZFCP_STATUS_PORT_WKA, &port->status))
+ list_for_each_entry(unit, &port->unit_list_head, list)
+ zfcp_erp_unit_access_changed(unit);
+ return;
+ }
+
+ ZFCP_LOG_NORMAL("reopen of port 0x%016Lx on adapter %s "
+ "(due to ACT update)\n",
+ port->wwpn, zfcp_get_busid_by_adapter(adapter));
+ if (zfcp_erp_port_reopen(port, ZFCP_STATUS_COMMON_ERP_FAILED) != 0)
+ ZFCP_LOG_NORMAL("failed reopen of port"
+ "(adapter %s, wwpn=0x%016Lx)\n",
+ zfcp_get_busid_by_adapter(adapter), port->wwpn);
+}
+
+/*
+ * function: zfcp_erp_unit_access_changed
+ *
+ * purpose:
+ */
+void
+zfcp_erp_unit_access_changed(struct zfcp_unit *unit)
+{
+ struct zfcp_adapter *adapter = unit->port->adapter;
+
+ debug_text_event(adapter->erp_dbf, 3, "u_access_unblock");
+ debug_event(adapter->erp_dbf, 3, &unit->fcp_lun, sizeof(fcp_lun_t));
+
+ if (!atomic_test_mask(ZFCP_STATUS_COMMON_ACCESS_DENIED, &unit->status))
+ return;
+
+ ZFCP_LOG_NORMAL("reopen of unit 0x%016Lx on port 0x%016Lx "
+ " on adapter %s (due to ACT update)\n",
+ unit->fcp_lun, unit->port->wwpn,
+ zfcp_get_busid_by_adapter(adapter));
+ if (zfcp_erp_unit_reopen(unit, ZFCP_STATUS_COMMON_ERP_FAILED) != 0)
+ ZFCP_LOG_NORMAL("failed reopen of unit (adapter %s, "
+ "wwpn=0x%016Lx, fcp_lun=0x%016Lx)\n",
+ zfcp_get_busid_by_adapter(adapter),
+ unit->port->wwpn, unit->fcp_lun);
+}
+
+#undef ZFCP_LOG_AREA
diff --git a/drivers/s390/scsi/zfcp_ext.h b/drivers/s390/scsi/zfcp_ext.h
new file mode 100644
index 0000000..d5fd433
--- /dev/null
+++ b/drivers/s390/scsi/zfcp_ext.h
@@ -0,0 +1,186 @@
+/*
+ *
+ * linux/drivers/s390/scsi/zfcp_ext.h
+ *
+ * FCP adapter driver for IBM eServer zSeries
+ *
+ * (C) Copyright IBM Corp. 2002, 2004
+ *
+ * Author(s): Martin Peschke <mpeschke@de.ibm.com>
+ * Raimund Schroeder <raimund.schroeder@de.ibm.com>
+ * Aron Zeh
+ * Wolfgang Taphorn
+ * Stefan Bader <stefan.bader@de.ibm.com>
+ * Heiko Carstens <heiko.carstens@de.ibm.com>
+ * Andreas Herrmann <aherrman@de.ibm.com>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2, or (at your option)
+ * any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#ifndef ZFCP_EXT_H
+#define ZFCP_EXT_H
+
+#define ZFCP_EXT_REVISION "$Revision: 1.62 $"
+
+#include "zfcp_def.h"
+
+extern struct zfcp_data zfcp_data;
+
+/******************************** SYSFS *************************************/
+extern int zfcp_sysfs_driver_create_files(struct device_driver *);
+extern void zfcp_sysfs_driver_remove_files(struct device_driver *);
+extern int zfcp_sysfs_adapter_create_files(struct device *);
+extern void zfcp_sysfs_adapter_remove_files(struct device *);
+extern int zfcp_sysfs_port_create_files(struct device *, u32);
+extern void zfcp_sysfs_port_remove_files(struct device *, u32);
+extern int zfcp_sysfs_unit_create_files(struct device *);
+extern void zfcp_sysfs_unit_remove_files(struct device *);
+extern void zfcp_sysfs_port_release(struct device *);
+extern void zfcp_sysfs_unit_release(struct device *);
+
+/**************************** CONFIGURATION *********************************/
+extern struct zfcp_unit *zfcp_get_unit_by_lun(struct zfcp_port *, fcp_lun_t);
+extern struct zfcp_port *zfcp_get_port_by_wwpn(struct zfcp_adapter *, wwn_t);
+extern struct zfcp_port *zfcp_get_port_by_did(struct zfcp_adapter *, u32);
+struct zfcp_adapter *zfcp_get_adapter_by_busid(char *);
+extern struct zfcp_adapter *zfcp_adapter_enqueue(struct ccw_device *);
+extern int zfcp_adapter_debug_register(struct zfcp_adapter *);
+extern void zfcp_adapter_dequeue(struct zfcp_adapter *);
+extern void zfcp_adapter_debug_unregister(struct zfcp_adapter *);
+extern struct zfcp_port *zfcp_port_enqueue(struct zfcp_adapter *, wwn_t,
+ u32, u32);
+extern void zfcp_port_dequeue(struct zfcp_port *);
+extern struct zfcp_unit *zfcp_unit_enqueue(struct zfcp_port *, fcp_lun_t);
+extern void zfcp_unit_dequeue(struct zfcp_unit *);
+
+/******************************* S/390 IO ************************************/
+extern int zfcp_ccw_register(void);
+extern void zfcp_ccw_unregister(void);
+
+extern void zfcp_qdio_zero_sbals(struct qdio_buffer **, int, int);
+extern int zfcp_qdio_allocate(struct zfcp_adapter *);
+extern int zfcp_qdio_allocate_queues(struct zfcp_adapter *);
+extern void zfcp_qdio_free_queues(struct zfcp_adapter *);
+extern int zfcp_qdio_determine_pci(struct zfcp_qdio_queue *,
+ struct zfcp_fsf_req *);
+extern int zfcp_qdio_reqid_check(struct zfcp_adapter *, void *);
+
+extern volatile struct qdio_buffer_element *zfcp_qdio_sbale_req
+ (struct zfcp_fsf_req *, int, int);
+extern volatile struct qdio_buffer_element *zfcp_qdio_sbale_curr
+ (struct zfcp_fsf_req *);
+extern int zfcp_qdio_sbals_from_sg
+ (struct zfcp_fsf_req *, unsigned long, struct scatterlist *, int, int);
+extern int zfcp_qdio_sbals_from_scsicmnd
+ (struct zfcp_fsf_req *, unsigned long, struct scsi_cmnd *);
+
+
+/******************************** FSF ****************************************/
+extern int zfcp_fsf_open_port(struct zfcp_erp_action *);
+extern int zfcp_fsf_close_port(struct zfcp_erp_action *);
+extern int zfcp_fsf_close_physical_port(struct zfcp_erp_action *);
+
+extern int zfcp_fsf_open_unit(struct zfcp_erp_action *);
+extern int zfcp_fsf_close_unit(struct zfcp_erp_action *);
+
+extern int zfcp_fsf_exchange_config_data(struct zfcp_erp_action *);
+extern int zfcp_fsf_exchange_port_data(struct zfcp_adapter *,
+ struct fsf_qtcb_bottom_port *);
+extern int zfcp_fsf_control_file(struct zfcp_adapter *, struct zfcp_fsf_req **,
+ u32, u32, struct zfcp_sg_list *);
+extern void zfcp_fsf_request_timeout_handler(unsigned long);
+extern void zfcp_fsf_scsi_er_timeout_handler(unsigned long);
+extern int zfcp_fsf_req_dismiss_all(struct zfcp_adapter *);
+extern int zfcp_fsf_status_read(struct zfcp_adapter *, int);
+extern int zfcp_fsf_req_create(struct zfcp_adapter *, u32, int, mempool_t *,
+ unsigned long *, struct zfcp_fsf_req **);
+extern int zfcp_fsf_send_ct(struct zfcp_send_ct *, mempool_t *,
+ struct zfcp_erp_action *);
+extern int zfcp_fsf_send_els(struct zfcp_send_els *);
+extern int zfcp_fsf_req_wait_and_cleanup(struct zfcp_fsf_req *, int, u32 *);
+extern int zfcp_fsf_send_fcp_command_task(struct zfcp_adapter *,
+ struct zfcp_unit *,
+ struct scsi_cmnd *,
+ struct timer_list*, int);
+extern int zfcp_fsf_req_complete(struct zfcp_fsf_req *);
+extern void zfcp_fsf_incoming_els(struct zfcp_fsf_req *);
+extern void zfcp_fsf_req_cleanup(struct zfcp_fsf_req *);
+extern struct zfcp_fsf_req *zfcp_fsf_send_fcp_command_task_management(
+ struct zfcp_adapter *, struct zfcp_unit *, u8, int);
+extern struct zfcp_fsf_req *zfcp_fsf_abort_fcp_command(
+ unsigned long, struct zfcp_adapter *, struct zfcp_unit *, int);
+
+/******************************* FC/FCP **************************************/
+extern int zfcp_nameserver_enqueue(struct zfcp_adapter *);
+extern int zfcp_ns_gid_pn_request(struct zfcp_erp_action *);
+extern int zfcp_check_ct_response(struct ct_hdr *);
+extern int zfcp_handle_els_rjt(u32, struct zfcp_ls_rjt_par *);
+
+/******************************* SCSI ****************************************/
+extern int zfcp_adapter_scsi_register(struct zfcp_adapter *);
+extern void zfcp_adapter_scsi_unregister(struct zfcp_adapter *);
+extern void zfcp_set_fcp_dl(struct fcp_cmnd_iu *, fcp_dl_t);
+extern char *zfcp_get_fcp_rsp_info_ptr(struct fcp_rsp_iu *);
+extern void set_host_byte(u32 *, char);
+extern void set_driver_byte(u32 *, char);
+extern char *zfcp_get_fcp_sns_info_ptr(struct fcp_rsp_iu *);
+extern void zfcp_fsf_start_scsi_er_timer(struct zfcp_adapter *);
+extern fcp_dl_t zfcp_get_fcp_dl(struct fcp_cmnd_iu *);
+
+extern int zfcp_scsi_command_async(struct zfcp_adapter *,struct zfcp_unit *,
+ struct scsi_cmnd *, struct timer_list *);
+extern int zfcp_scsi_command_sync(struct zfcp_unit *, struct scsi_cmnd *,
+ struct timer_list *);
+extern struct scsi_transport_template *zfcp_transport_template;
+extern struct fc_function_template zfcp_transport_functions;
+
+/******************************** ERP ****************************************/
+extern void zfcp_erp_modify_adapter_status(struct zfcp_adapter *, u32, int);
+extern int zfcp_erp_adapter_reopen(struct zfcp_adapter *, int);
+extern int zfcp_erp_adapter_shutdown(struct zfcp_adapter *, int);
+extern void zfcp_erp_adapter_failed(struct zfcp_adapter *);
+
+extern void zfcp_erp_modify_port_status(struct zfcp_port *, u32, int);
+extern int zfcp_erp_port_reopen(struct zfcp_port *, int);
+extern int zfcp_erp_port_shutdown(struct zfcp_port *, int);
+extern int zfcp_erp_port_forced_reopen(struct zfcp_port *, int);
+extern void zfcp_erp_port_failed(struct zfcp_port *);
+extern int zfcp_erp_port_reopen_all(struct zfcp_adapter *, int);
+
+extern void zfcp_erp_modify_unit_status(struct zfcp_unit *, u32, int);
+extern int zfcp_erp_unit_reopen(struct zfcp_unit *, int);
+extern int zfcp_erp_unit_shutdown(struct zfcp_unit *, int);
+extern void zfcp_erp_unit_failed(struct zfcp_unit *);
+
+extern int zfcp_erp_thread_setup(struct zfcp_adapter *);
+extern int zfcp_erp_thread_kill(struct zfcp_adapter *);
+extern int zfcp_erp_wait(struct zfcp_adapter *);
+extern int zfcp_erp_async_handler(struct zfcp_erp_action *, unsigned long);
+
+extern int zfcp_test_link(struct zfcp_port *);
+
+extern void zfcp_erp_port_access_denied(struct zfcp_port *);
+extern void zfcp_erp_unit_access_denied(struct zfcp_unit *);
+extern void zfcp_erp_adapter_access_changed(struct zfcp_adapter *);
+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);
+#endif /* ZFCP_EXT_H */
diff --git a/drivers/s390/scsi/zfcp_fsf.c b/drivers/s390/scsi/zfcp_fsf.c
new file mode 100644
index 0000000..578b9fb
--- /dev/null
+++ b/drivers/s390/scsi/zfcp_fsf.c
@@ -0,0 +1,5087 @@
+/*
+ *
+ * linux/drivers/s390/scsi/zfcp_fsf.c
+ *
+ * FCP adapter driver for IBM eServer zSeries
+ *
+ * (C) Copyright IBM Corp. 2002, 2004
+ *
+ * Author(s): Martin Peschke <mpeschke@de.ibm.com>
+ * Raimund Schroeder <raimund.schroeder@de.ibm.com>
+ * Aron Zeh
+ * Wolfgang Taphorn
+ * Stefan Bader <stefan.bader@de.ibm.com>
+ * Heiko Carstens <heiko.carstens@de.ibm.com>
+ * Andreas Herrmann <aherrman@de.ibm.com>
+ * Volker Sameske <sameske@de.ibm.com>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2, or (at your option)
+ * any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#define ZFCP_FSF_C_REVISION "$Revision: 1.92 $"
+
+#include "zfcp_ext.h"
+
+static int zfcp_fsf_exchange_config_data_handler(struct zfcp_fsf_req *);
+static void zfcp_fsf_exchange_port_data_handler(struct zfcp_fsf_req *);
+static int zfcp_fsf_open_port_handler(struct zfcp_fsf_req *);
+static int zfcp_fsf_close_port_handler(struct zfcp_fsf_req *);
+static int zfcp_fsf_close_physical_port_handler(struct zfcp_fsf_req *);
+static int zfcp_fsf_open_unit_handler(struct zfcp_fsf_req *);
+static int zfcp_fsf_close_unit_handler(struct zfcp_fsf_req *);
+static int zfcp_fsf_send_fcp_command_handler(struct zfcp_fsf_req *);
+static int zfcp_fsf_send_fcp_command_task_handler(struct zfcp_fsf_req *);
+static int zfcp_fsf_send_fcp_command_task_management_handler(
+ struct zfcp_fsf_req *);
+static int zfcp_fsf_abort_fcp_command_handler(struct zfcp_fsf_req *);
+static int zfcp_fsf_status_read_handler(struct zfcp_fsf_req *);
+static int zfcp_fsf_send_ct_handler(struct zfcp_fsf_req *);
+static int zfcp_fsf_send_els_handler(struct zfcp_fsf_req *);
+static int zfcp_fsf_control_file_handler(struct zfcp_fsf_req *);
+static inline int zfcp_fsf_req_sbal_check(
+ unsigned long *, struct zfcp_qdio_queue *, int);
+static inline int zfcp_use_one_sbal(
+ struct scatterlist *, int, struct scatterlist *, int);
+static struct zfcp_fsf_req *zfcp_fsf_req_alloc(mempool_t *, int);
+static int zfcp_fsf_req_send(struct zfcp_fsf_req *, struct timer_list *);
+static int zfcp_fsf_protstatus_eval(struct zfcp_fsf_req *);
+static int zfcp_fsf_fsfstatus_eval(struct zfcp_fsf_req *);
+static int zfcp_fsf_fsfstatus_qual_eval(struct zfcp_fsf_req *);
+static int zfcp_fsf_req_dispatch(struct zfcp_fsf_req *);
+static void zfcp_fsf_req_dismiss(struct zfcp_fsf_req *);
+static void zfcp_fsf_req_free(struct zfcp_fsf_req *);
+
+/* association between FSF command and FSF QTCB type */
+static u32 fsf_qtcb_type[] = {
+ [FSF_QTCB_FCP_CMND] = FSF_IO_COMMAND,
+ [FSF_QTCB_ABORT_FCP_CMND] = FSF_SUPPORT_COMMAND,
+ [FSF_QTCB_OPEN_PORT_WITH_DID] = FSF_SUPPORT_COMMAND,
+ [FSF_QTCB_OPEN_LUN] = FSF_SUPPORT_COMMAND,
+ [FSF_QTCB_CLOSE_LUN] = FSF_SUPPORT_COMMAND,
+ [FSF_QTCB_CLOSE_PORT] = FSF_SUPPORT_COMMAND,
+ [FSF_QTCB_CLOSE_PHYSICAL_PORT] = FSF_SUPPORT_COMMAND,
+ [FSF_QTCB_SEND_ELS] = FSF_SUPPORT_COMMAND,
+ [FSF_QTCB_SEND_GENERIC] = FSF_SUPPORT_COMMAND,
+ [FSF_QTCB_EXCHANGE_CONFIG_DATA] = FSF_CONFIG_COMMAND,
+ [FSF_QTCB_EXCHANGE_PORT_DATA] = FSF_PORT_COMMAND,
+ [FSF_QTCB_DOWNLOAD_CONTROL_FILE] = FSF_SUPPORT_COMMAND,
+ [FSF_QTCB_UPLOAD_CONTROL_FILE] = FSF_SUPPORT_COMMAND
+};
+
+static const char zfcp_act_subtable_type[5][8] = {
+ "unknown", "OS", "WWPN", "DID", "LUN"
+};
+
+/****************************************************************/
+/*************** FSF related Functions *************************/
+/****************************************************************/
+
+#define ZFCP_LOG_AREA ZFCP_LOG_AREA_FSF
+
+/*
+ * function: zfcp_fsf_req_alloc
+ *
+ * purpose: Obtains an fsf_req and potentially a qtcb (for all but
+ * unsolicited requests) via helper functions
+ * Does some initial fsf request set-up.
+ *
+ * returns: pointer to allocated fsf_req if successfull
+ * NULL otherwise
+ *
+ * locks: none
+ *
+ */
+static struct zfcp_fsf_req *
+zfcp_fsf_req_alloc(mempool_t *pool, int req_flags)
+{
+ size_t size;
+ void *ptr;
+ struct zfcp_fsf_req *fsf_req = NULL;
+
+ if (req_flags & ZFCP_REQ_NO_QTCB)
+ size = sizeof(struct zfcp_fsf_req);
+ else
+ size = sizeof(struct zfcp_fsf_req_pool_element);
+
+ if (likely(pool != NULL))
+ ptr = mempool_alloc(pool, GFP_ATOMIC);
+ else
+ ptr = kmalloc(size, GFP_ATOMIC);
+
+ if (unlikely(NULL == ptr))
+ goto out;
+
+ memset(ptr, 0, size);
+
+ if (req_flags & ZFCP_REQ_NO_QTCB) {
+ fsf_req = (struct zfcp_fsf_req *) ptr;
+ } else {
+ fsf_req = &((struct zfcp_fsf_req_pool_element *) ptr)->fsf_req;
+ fsf_req->qtcb =
+ &((struct zfcp_fsf_req_pool_element *) ptr)->qtcb;
+ }
+
+ fsf_req->pool = pool;
+
+ out:
+ return fsf_req;
+}
+
+/*
+ * function: zfcp_fsf_req_free
+ *
+ * purpose: Frees the memory of an fsf_req (and potentially a qtcb) or
+ * returns it into the pool via helper functions.
+ *
+ * returns: sod all
+ *
+ * locks: none
+ */
+static void
+zfcp_fsf_req_free(struct zfcp_fsf_req *fsf_req)
+{
+ if (likely(fsf_req->pool != NULL))
+ mempool_free(fsf_req, fsf_req->pool);
+ else
+ kfree(fsf_req);
+}
+
+/*
+ * function:
+ *
+ * purpose:
+ *
+ * returns:
+ *
+ * note: qdio queues shall be down (no ongoing inbound processing)
+ */
+int
+zfcp_fsf_req_dismiss_all(struct zfcp_adapter *adapter)
+{
+ int retval = 0;
+ struct zfcp_fsf_req *fsf_req, *tmp;
+
+ list_for_each_entry_safe(fsf_req, tmp, &adapter->fsf_req_list_head,
+ list)
+ zfcp_fsf_req_dismiss(fsf_req);
+ /* wait_event_timeout? */
+ while (!list_empty(&adapter->fsf_req_list_head)) {
+ ZFCP_LOG_DEBUG("fsf req list of adapter %s not yet empty\n",
+ zfcp_get_busid_by_adapter(adapter));
+ /* wait for woken intiators to clean up their requests */
+ msleep(jiffies_to_msecs(ZFCP_FSFREQ_CLEANUP_TIMEOUT));
+ }
+
+ /* consistency check */
+ if (atomic_read(&adapter->fsf_reqs_active)) {
+ ZFCP_LOG_NORMAL("bug: There are still %d FSF requests pending "
+ "on adapter %s after cleanup.\n",
+ atomic_read(&adapter->fsf_reqs_active),
+ zfcp_get_busid_by_adapter(adapter));
+ atomic_set(&adapter->fsf_reqs_active, 0);
+ }
+
+ return retval;
+}
+
+/*
+ * function:
+ *
+ * purpose:
+ *
+ * returns:
+ */
+static void
+zfcp_fsf_req_dismiss(struct zfcp_fsf_req *fsf_req)
+{
+ fsf_req->status |= ZFCP_STATUS_FSFREQ_DISMISSED;
+ zfcp_fsf_req_complete(fsf_req);
+}
+
+/*
+ * function: zfcp_fsf_req_complete
+ *
+ * purpose: Updates active counts and timers for openfcp-reqs
+ * May cleanup request after req_eval returns
+ *
+ * returns: 0 - success
+ * !0 - failure
+ *
+ * context:
+ */
+int
+zfcp_fsf_req_complete(struct zfcp_fsf_req *fsf_req)
+{
+ int retval = 0;
+ int cleanup;
+ struct zfcp_adapter *adapter = fsf_req->adapter;
+
+ /* do some statistics */
+ atomic_dec(&adapter->fsf_reqs_active);
+
+ if (unlikely(fsf_req->fsf_command == FSF_QTCB_UNSOLICITED_STATUS)) {
+ ZFCP_LOG_DEBUG("Status read response received\n");
+ /*
+ * Note: all cleanup handling is done in the callchain of
+ * the function call-chain below.
+ */
+ zfcp_fsf_status_read_handler(fsf_req);
+ goto out;
+ } else
+ zfcp_fsf_protstatus_eval(fsf_req);
+
+ /*
+ * fsf_req may be deleted due to waking up functions, so
+ * cleanup is saved here and used later
+ */
+ if (likely(fsf_req->status & ZFCP_STATUS_FSFREQ_CLEANUP))
+ cleanup = 1;
+ else
+ cleanup = 0;
+
+ fsf_req->status |= ZFCP_STATUS_FSFREQ_COMPLETED;
+
+ /* cleanup request if requested by initiator */
+ if (likely(cleanup)) {
+ ZFCP_LOG_TRACE("removing FSF request %p\n", fsf_req);
+ /*
+ * lock must not be held here since it will be
+ * grabed by the called routine, too
+ */
+ zfcp_fsf_req_cleanup(fsf_req);
+ } else {
+ /* notify initiator waiting for the requests completion */
+ ZFCP_LOG_TRACE("waking initiator of FSF request %p\n",fsf_req);
+ /*
+ * FIXME: Race! We must not access fsf_req here as it might have been
+ * cleaned up already due to the set ZFCP_STATUS_FSFREQ_COMPLETED
+ * flag. It's an improbable case. But, we have the same paranoia for
+ * the cleanup flag already.
+ * Might better be handled using complete()?
+ * (setting the flag and doing wakeup ought to be atomic
+ * with regard to checking the flag as long as waitqueue is
+ * part of the to be released structure)
+ */
+ wake_up(&fsf_req->completion_wq);
+ }
+
+ out:
+ return retval;
+}
+
+/*
+ * function: zfcp_fsf_protstatus_eval
+ *
+ * purpose: evaluates the QTCB of the finished FSF request
+ * and initiates appropriate actions
+ * (usually calling FSF command specific handlers)
+ *
+ * returns:
+ *
+ * context:
+ *
+ * locks:
+ */
+static int
+zfcp_fsf_protstatus_eval(struct zfcp_fsf_req *fsf_req)
+{
+ int retval = 0;
+ struct zfcp_adapter *adapter = fsf_req->adapter;
+
+ ZFCP_LOG_DEBUG("QTCB is at %p\n", fsf_req->qtcb);
+
+ if (fsf_req->status & ZFCP_STATUS_FSFREQ_DISMISSED) {
+ ZFCP_LOG_DEBUG("fsf_req 0x%lx has been dismissed\n",
+ (unsigned long) fsf_req);
+ fsf_req->status |= ZFCP_STATUS_FSFREQ_ERROR |
+ ZFCP_STATUS_FSFREQ_RETRY; /* only for SCSI cmnds. */
+ zfcp_cmd_dbf_event_fsf("dismiss", fsf_req, NULL, 0);
+ goto skip_protstatus;
+ }
+
+ /* log additional information provided by FSF (if any) */
+ if (unlikely(fsf_req->qtcb->header.log_length)) {
+ /* do not trust them ;-) */
+ if (fsf_req->qtcb->header.log_start > sizeof(struct fsf_qtcb)) {
+ ZFCP_LOG_NORMAL
+ ("bug: ULP (FSF logging) log data starts "
+ "beyond end of packet header. Ignored. "
+ "(start=%i, size=%li)\n",
+ fsf_req->qtcb->header.log_start,
+ sizeof(struct fsf_qtcb));
+ goto forget_log;
+ }
+ if ((size_t) (fsf_req->qtcb->header.log_start +
+ fsf_req->qtcb->header.log_length)
+ > sizeof(struct fsf_qtcb)) {
+ ZFCP_LOG_NORMAL("bug: ULP (FSF logging) log data ends "
+ "beyond end of packet header. Ignored. "
+ "(start=%i, length=%i, size=%li)\n",
+ fsf_req->qtcb->header.log_start,
+ fsf_req->qtcb->header.log_length,
+ sizeof(struct fsf_qtcb));
+ goto forget_log;
+ }
+ ZFCP_LOG_TRACE("ULP log data: \n");
+ ZFCP_HEX_DUMP(ZFCP_LOG_LEVEL_TRACE,
+ (char *) fsf_req->qtcb +
+ fsf_req->qtcb->header.log_start,
+ fsf_req->qtcb->header.log_length);
+ }
+ forget_log:
+
+ /* evaluate FSF Protocol Status */
+ switch (fsf_req->qtcb->prefix.prot_status) {
+
+ case FSF_PROT_GOOD:
+ ZFCP_LOG_TRACE("FSF_PROT_GOOD\n");
+ break;
+
+ case FSF_PROT_FSF_STATUS_PRESENTED:
+ ZFCP_LOG_TRACE("FSF_PROT_FSF_STATUS_PRESENTED\n");
+ break;
+
+ case FSF_PROT_QTCB_VERSION_ERROR:
+ ZFCP_LOG_FLAGS(0, "FSF_PROT_QTCB_VERSION_ERROR\n");
+ ZFCP_LOG_NORMAL("error: The adapter %s contains "
+ "microcode of version 0x%x, the device driver "
+ "only supports 0x%x. Aborting.\n",
+ zfcp_get_busid_by_adapter(adapter),
+ fsf_req->qtcb->prefix.prot_status_qual.
+ version_error.fsf_version, ZFCP_QTCB_VERSION);
+ /* stop operation for this adapter */
+ debug_text_exception(adapter->erp_dbf, 0, "prot_ver_err");
+ zfcp_erp_adapter_shutdown(adapter, 0);
+ zfcp_cmd_dbf_event_fsf("qverserr", fsf_req,
+ &fsf_req->qtcb->prefix.prot_status_qual,
+ sizeof (union fsf_prot_status_qual));
+ fsf_req->status |= ZFCP_STATUS_FSFREQ_ERROR;
+ break;
+
+ case FSF_PROT_SEQ_NUMB_ERROR:
+ ZFCP_LOG_FLAGS(0, "FSF_PROT_SEQ_NUMB_ERROR\n");
+ ZFCP_LOG_NORMAL("bug: Sequence number mismatch between "
+ "driver (0x%x) and adapter %s (0x%x). "
+ "Restarting all operations on this adapter.\n",
+ fsf_req->qtcb->prefix.req_seq_no,
+ zfcp_get_busid_by_adapter(adapter),
+ fsf_req->qtcb->prefix.prot_status_qual.
+ sequence_error.exp_req_seq_no);
+ debug_text_exception(adapter->erp_dbf, 0, "prot_seq_err");
+ /* restart operation on this adapter */
+ zfcp_erp_adapter_reopen(adapter, 0);
+ zfcp_cmd_dbf_event_fsf("seqnoerr", fsf_req,
+ &fsf_req->qtcb->prefix.prot_status_qual,
+ sizeof (union fsf_prot_status_qual));
+ fsf_req->status |= ZFCP_STATUS_FSFREQ_RETRY;
+ fsf_req->status |= ZFCP_STATUS_FSFREQ_ERROR;
+ break;
+
+ case FSF_PROT_UNSUPP_QTCB_TYPE:
+ ZFCP_LOG_FLAGS(0, "FSF_PROT_UNSUP_QTCB_TYPE\n");
+ ZFCP_LOG_NORMAL("error: Packet header type used by the "
+ "device driver is incompatible with "
+ "that used on adapter %s. "
+ "Stopping all operations on this adapter.\n",
+ zfcp_get_busid_by_adapter(adapter));
+ debug_text_exception(adapter->erp_dbf, 0, "prot_unsup_qtcb");
+ zfcp_erp_adapter_shutdown(adapter, 0);
+ zfcp_cmd_dbf_event_fsf("unsqtcbt", fsf_req,
+ &fsf_req->qtcb->prefix.prot_status_qual,
+ sizeof (union fsf_prot_status_qual));
+ fsf_req->status |= ZFCP_STATUS_FSFREQ_ERROR;
+ break;
+
+ case FSF_PROT_HOST_CONNECTION_INITIALIZING:
+ ZFCP_LOG_FLAGS(1, "FSF_PROT_HOST_CONNECTION_INITIALIZING\n");
+ zfcp_cmd_dbf_event_fsf("hconinit", fsf_req,
+ &fsf_req->qtcb->prefix.prot_status_qual,
+ sizeof (union fsf_prot_status_qual));
+ fsf_req->status |= ZFCP_STATUS_FSFREQ_ERROR;
+ atomic_set_mask(ZFCP_STATUS_ADAPTER_HOST_CON_INIT,
+ &(adapter->status));
+ debug_text_event(adapter->erp_dbf, 3, "prot_con_init");
+ break;
+
+ case FSF_PROT_DUPLICATE_REQUEST_ID:
+ ZFCP_LOG_FLAGS(0, "FSF_PROT_DUPLICATE_REQUEST_IDS\n");
+ if (fsf_req->qtcb) {
+ ZFCP_LOG_NORMAL("bug: The request identifier 0x%Lx "
+ "to the adapter %s is ambiguous. "
+ "Stopping all operations on this "
+ "adapter.\n",
+ *(unsigned long long *)
+ (&fsf_req->qtcb->bottom.support.
+ req_handle),
+ zfcp_get_busid_by_adapter(adapter));
+ } else {
+ ZFCP_LOG_NORMAL("bug: The request identifier %p "
+ "to the adapter %s is ambiguous. "
+ "Stopping all operations on this "
+ "adapter. "
+ "(bug: got this for an unsolicited "
+ "status read request)\n",
+ fsf_req,
+ zfcp_get_busid_by_adapter(adapter));
+ }
+ debug_text_exception(adapter->erp_dbf, 0, "prot_dup_id");
+ zfcp_erp_adapter_shutdown(adapter, 0);
+ zfcp_cmd_dbf_event_fsf("dupreqid", fsf_req,
+ &fsf_req->qtcb->prefix.prot_status_qual,
+ sizeof (union fsf_prot_status_qual));
+ fsf_req->status |= ZFCP_STATUS_FSFREQ_ERROR;
+ break;
+
+ case FSF_PROT_LINK_DOWN:
+ ZFCP_LOG_FLAGS(1, "FSF_PROT_LINK_DOWN\n");
+ /*
+ * 'test and set' is not atomic here -
+ * it's ok as long as calls to our response queue handler
+ * (and thus execution of this code here) are serialized
+ * by the qdio module
+ */
+ if (!atomic_test_mask(ZFCP_STATUS_ADAPTER_LINK_UNPLUGGED,
+ &adapter->status)) {
+ switch (fsf_req->qtcb->prefix.prot_status_qual.
+ locallink_error.code) {
+ case FSF_PSQ_LINK_NOLIGHT:
+ ZFCP_LOG_INFO("The local link to adapter %s "
+ "is down (no light detected).\n",
+ zfcp_get_busid_by_adapter(
+ adapter));
+ break;
+ case FSF_PSQ_LINK_WRAPPLUG:
+ ZFCP_LOG_INFO("The local link to adapter %s "
+ "is down (wrap plug detected).\n",
+ zfcp_get_busid_by_adapter(
+ adapter));
+ break;
+ case FSF_PSQ_LINK_NOFCP:
+ ZFCP_LOG_INFO("The local link to adapter %s "
+ "is down (adjacent node on "
+ "link does not support FCP).\n",
+ zfcp_get_busid_by_adapter(
+ adapter));
+ break;
+ default:
+ ZFCP_LOG_INFO("The local link to adapter %s "
+ "is down "
+ "(warning: unknown reason "
+ "code).\n",
+ zfcp_get_busid_by_adapter(
+ adapter));
+ break;
+
+ }
+ /*
+ * Due to the 'erp failed' flag the adapter won't
+ * be recovered but will be just set to 'blocked'
+ * state. All subordinary devices will have state
+ * 'blocked' and 'erp failed', too.
+ * Thus the adapter is still able to provide
+ * 'link up' status without being flooded with
+ * requests.
+ * (note: even 'close port' is not permitted)
+ */
+ ZFCP_LOG_INFO("Stopping all operations for adapter "
+ "%s.\n",
+ zfcp_get_busid_by_adapter(adapter));
+ atomic_set_mask(ZFCP_STATUS_ADAPTER_LINK_UNPLUGGED |
+ ZFCP_STATUS_COMMON_ERP_FAILED,
+ &adapter->status);
+ zfcp_erp_adapter_reopen(adapter, 0);
+ debug_text_event(adapter->erp_dbf, 1, "prot_link_down");
+ }
+ fsf_req->status |= ZFCP_STATUS_FSFREQ_ERROR;
+ break;
+
+ case FSF_PROT_REEST_QUEUE:
+ ZFCP_LOG_FLAGS(1, "FSF_PROT_REEST_QUEUE\n");
+ debug_text_event(adapter->erp_dbf, 1, "prot_reest_queue");
+ ZFCP_LOG_INFO("The local link to adapter with "
+ "%s was re-plugged. "
+ "Re-starting operations on this adapter.\n",
+ zfcp_get_busid_by_adapter(adapter));
+ /* All ports should be marked as ready to run again */
+ zfcp_erp_modify_adapter_status(adapter,
+ ZFCP_STATUS_COMMON_RUNNING,
+ ZFCP_SET);
+ zfcp_erp_adapter_reopen(adapter,
+ ZFCP_STATUS_ADAPTER_LINK_UNPLUGGED
+ | ZFCP_STATUS_COMMON_ERP_FAILED);
+ zfcp_cmd_dbf_event_fsf("reestque", fsf_req,
+ &fsf_req->qtcb->prefix.prot_status_qual,
+ sizeof (union fsf_prot_status_qual));
+ fsf_req->status |= ZFCP_STATUS_FSFREQ_ERROR;
+ break;
+
+ case FSF_PROT_ERROR_STATE:
+ ZFCP_LOG_FLAGS(0, "FSF_PROT_ERROR_STATE\n");
+ ZFCP_LOG_NORMAL("error: The adapter %s "
+ "has entered the error state. "
+ "Restarting all operations on this "
+ "adapter.\n",
+ zfcp_get_busid_by_adapter(adapter));
+ debug_text_event(adapter->erp_dbf, 0, "prot_err_sta");
+ /* restart operation on this adapter */
+ zfcp_erp_adapter_reopen(adapter, 0);
+ zfcp_cmd_dbf_event_fsf("proterrs", fsf_req,
+ &fsf_req->qtcb->prefix.prot_status_qual,
+ sizeof (union fsf_prot_status_qual));
+ fsf_req->status |= ZFCP_STATUS_FSFREQ_RETRY;
+ fsf_req->status |= ZFCP_STATUS_FSFREQ_ERROR;
+ break;
+
+ default:
+ ZFCP_LOG_NORMAL("bug: Transfer protocol status information "
+ "provided by the adapter %s "
+ "is not compatible with the device driver. "
+ "Stopping all operations on this adapter. "
+ "(debug info 0x%x).\n",
+ zfcp_get_busid_by_adapter(adapter),
+ fsf_req->qtcb->prefix.prot_status);
+ debug_text_event(adapter->erp_dbf, 0, "prot_inval:");
+ debug_exception(adapter->erp_dbf, 0,
+ &fsf_req->qtcb->prefix.prot_status,
+ sizeof (u32));
+ zfcp_erp_adapter_shutdown(adapter, 0);
+ fsf_req->status |= ZFCP_STATUS_FSFREQ_ERROR;
+ }
+
+ skip_protstatus:
+ /*
+ * always call specific handlers to give them a chance to do
+ * something meaningful even in error cases
+ */
+ zfcp_fsf_fsfstatus_eval(fsf_req);
+ return retval;
+}
+
+/*
+ * function: zfcp_fsf_fsfstatus_eval
+ *
+ * purpose: evaluates FSF status of completed FSF request
+ * and acts accordingly
+ *
+ * returns:
+ */
+static int
+zfcp_fsf_fsfstatus_eval(struct zfcp_fsf_req *fsf_req)
+{
+ int retval = 0;
+
+ if (unlikely(fsf_req->status & ZFCP_STATUS_FSFREQ_ERROR)) {
+ goto skip_fsfstatus;
+ }
+
+ /* evaluate FSF Status */
+ switch (fsf_req->qtcb->header.fsf_status) {
+ case FSF_UNKNOWN_COMMAND:
+ ZFCP_LOG_FLAGS(0, "FSF_UNKNOWN_COMMAND\n");
+ ZFCP_LOG_NORMAL("bug: Command issued by the device driver is "
+ "not known by the adapter %s "
+ "Stopping all operations on this adapter. "
+ "(debug info 0x%x).\n",
+ zfcp_get_busid_by_adapter(fsf_req->adapter),
+ fsf_req->qtcb->header.fsf_command);
+ debug_text_exception(fsf_req->adapter->erp_dbf, 0,
+ "fsf_s_unknown");
+ zfcp_erp_adapter_shutdown(fsf_req->adapter, 0);
+ zfcp_cmd_dbf_event_fsf("unknownc", fsf_req,
+ &fsf_req->qtcb->header.fsf_status_qual,
+ sizeof (union fsf_status_qual));
+ fsf_req->status |= ZFCP_STATUS_FSFREQ_ERROR;
+ break;
+
+ case FSF_FCP_RSP_AVAILABLE:
+ ZFCP_LOG_FLAGS(2, "FSF_FCP_RSP_AVAILABLE\n");
+ ZFCP_LOG_DEBUG("FCP Sense data will be presented to the "
+ "SCSI stack.\n");
+ debug_text_event(fsf_req->adapter->erp_dbf, 3, "fsf_s_rsp");
+ break;
+
+ case FSF_ADAPTER_STATUS_AVAILABLE:
+ ZFCP_LOG_FLAGS(2, "FSF_ADAPTER_STATUS_AVAILABLE\n");
+ debug_text_event(fsf_req->adapter->erp_dbf, 2, "fsf_s_astatus");
+ zfcp_fsf_fsfstatus_qual_eval(fsf_req);
+ break;
+
+ default:
+ break;
+ }
+
+ skip_fsfstatus:
+ /*
+ * always call specific handlers to give them a chance to do
+ * something meaningful even in error cases
+ */
+ zfcp_fsf_req_dispatch(fsf_req);
+
+ return retval;
+}
+
+/*
+ * function: zfcp_fsf_fsfstatus_qual_eval
+ *
+ * purpose: evaluates FSF status-qualifier of completed FSF request
+ * and acts accordingly
+ *
+ * returns:
+ */
+static int
+zfcp_fsf_fsfstatus_qual_eval(struct zfcp_fsf_req *fsf_req)
+{
+ int retval = 0;
+
+ switch (fsf_req->qtcb->header.fsf_status_qual.word[0]) {
+ case FSF_SQ_FCP_RSP_AVAILABLE:
+ ZFCP_LOG_FLAGS(2, "FSF_SQ_FCP_RSP_AVAILABLE\n");
+ debug_text_event(fsf_req->adapter->erp_dbf, 4, "fsf_sq_rsp");
+ break;
+ case FSF_SQ_RETRY_IF_POSSIBLE:
+ ZFCP_LOG_FLAGS(2, "FSF_SQ_RETRY_IF_POSSIBLE\n");
+ /* The SCSI-stack may now issue retries or escalate */
+ debug_text_event(fsf_req->adapter->erp_dbf, 2, "fsf_sq_retry");
+ zfcp_cmd_dbf_event_fsf("sqretry", fsf_req,
+ &fsf_req->qtcb->header.fsf_status_qual,
+ sizeof (union fsf_status_qual));
+ fsf_req->status |= ZFCP_STATUS_FSFREQ_ERROR;
+ break;
+ case FSF_SQ_COMMAND_ABORTED:
+ ZFCP_LOG_FLAGS(2, "FSF_SQ_COMMAND_ABORTED\n");
+ /* Carry the aborted state on to upper layer */
+ debug_text_event(fsf_req->adapter->erp_dbf, 2, "fsf_sq_abort");
+ zfcp_cmd_dbf_event_fsf("sqabort", fsf_req,
+ &fsf_req->qtcb->header.fsf_status_qual,
+ sizeof (union fsf_status_qual));
+ fsf_req->status |= ZFCP_STATUS_FSFREQ_ABORTED;
+ fsf_req->status |= ZFCP_STATUS_FSFREQ_ERROR;
+ break;
+ case FSF_SQ_NO_RECOM:
+ ZFCP_LOG_FLAGS(0, "FSF_SQ_NO_RECOM\n");
+ debug_text_exception(fsf_req->adapter->erp_dbf, 0,
+ "fsf_sq_no_rec");
+ ZFCP_LOG_NORMAL("bug: No recommendation could be given for a"
+ "problem on the adapter %s "
+ "Stopping all operations on this adapter. ",
+ zfcp_get_busid_by_adapter(fsf_req->adapter));
+ zfcp_erp_adapter_shutdown(fsf_req->adapter, 0);
+ zfcp_cmd_dbf_event_fsf("sqnrecom", fsf_req,
+ &fsf_req->qtcb->header.fsf_status_qual,
+ sizeof (union fsf_status_qual));
+ fsf_req->status |= ZFCP_STATUS_FSFREQ_ERROR;
+ break;
+ case FSF_SQ_ULP_PROGRAMMING_ERROR:
+ ZFCP_LOG_FLAGS(0, "FSF_SQ_ULP_PROGRAMMING_ERROR\n");
+ ZFCP_LOG_NORMAL("error: not enough SBALs for data transfer "
+ "(adapter %s)\n",
+ zfcp_get_busid_by_adapter(fsf_req->adapter));
+ debug_text_exception(fsf_req->adapter->erp_dbf, 0,
+ "fsf_sq_ulp_err");
+ fsf_req->status |= ZFCP_STATUS_FSFREQ_ERROR;
+ break;
+ case FSF_SQ_INVOKE_LINK_TEST_PROCEDURE:
+ case FSF_SQ_NO_RETRY_POSSIBLE:
+ case FSF_SQ_ULP_DEPENDENT_ERP_REQUIRED:
+ /* dealt with in the respective functions */
+ break;
+ default:
+ ZFCP_LOG_NORMAL("bug: Additional status info could "
+ "not be interpreted properly.\n");
+ ZFCP_HEX_DUMP(ZFCP_LOG_LEVEL_NORMAL,
+ (char *) &fsf_req->qtcb->header.fsf_status_qual,
+ sizeof (union fsf_status_qual));
+ debug_text_event(fsf_req->adapter->erp_dbf, 0, "fsf_sq_inval:");
+ debug_exception(fsf_req->adapter->erp_dbf, 0,
+ &fsf_req->qtcb->header.fsf_status_qual.word[0],
+ sizeof (u32));
+ zfcp_cmd_dbf_event_fsf("squndef", fsf_req,
+ &fsf_req->qtcb->header.fsf_status_qual,
+ sizeof (union fsf_status_qual));
+ fsf_req->status |= ZFCP_STATUS_FSFREQ_ERROR;
+ break;
+ }
+
+ return retval;
+}
+
+/*
+ * function: zfcp_fsf_req_dispatch
+ *
+ * purpose: calls the appropriate command specific handler
+ *
+ * returns:
+ */
+static int
+zfcp_fsf_req_dispatch(struct zfcp_fsf_req *fsf_req)
+{
+ struct zfcp_erp_action *erp_action = fsf_req->erp_action;
+ struct zfcp_adapter *adapter = fsf_req->adapter;
+ int retval = 0;
+
+ if (unlikely(fsf_req->status & ZFCP_STATUS_FSFREQ_ERROR)) {
+ ZFCP_LOG_TRACE("fsf_req=%p, QTCB=%p\n", fsf_req, fsf_req->qtcb);
+ ZFCP_HEX_DUMP(ZFCP_LOG_LEVEL_TRACE,
+ (char *) fsf_req->qtcb, sizeof(struct fsf_qtcb));
+ }
+
+ switch (fsf_req->fsf_command) {
+
+ case FSF_QTCB_FCP_CMND:
+ ZFCP_LOG_FLAGS(3, "FSF_QTCB_FCP_CMND\n");
+ zfcp_fsf_send_fcp_command_handler(fsf_req);
+ break;
+
+ case FSF_QTCB_ABORT_FCP_CMND:
+ ZFCP_LOG_FLAGS(2, "FSF_QTCB_ABORT_FCP_CMND\n");
+ zfcp_fsf_abort_fcp_command_handler(fsf_req);
+ break;
+
+ case FSF_QTCB_SEND_GENERIC:
+ ZFCP_LOG_FLAGS(2, "FSF_QTCB_SEND_GENERIC\n");
+ zfcp_fsf_send_ct_handler(fsf_req);
+ break;
+
+ case FSF_QTCB_OPEN_PORT_WITH_DID:
+ ZFCP_LOG_FLAGS(2, "FSF_QTCB_OPEN_PORT_WITH_DID\n");
+ zfcp_fsf_open_port_handler(fsf_req);
+ break;
+
+ case FSF_QTCB_OPEN_LUN:
+ ZFCP_LOG_FLAGS(2, "FSF_QTCB_OPEN_LUN\n");
+ zfcp_fsf_open_unit_handler(fsf_req);
+ break;
+
+ case FSF_QTCB_CLOSE_LUN:
+ ZFCP_LOG_FLAGS(2, "FSF_QTCB_CLOSE_LUN\n");
+ zfcp_fsf_close_unit_handler(fsf_req);
+ break;
+
+ case FSF_QTCB_CLOSE_PORT:
+ ZFCP_LOG_FLAGS(2, "FSF_QTCB_CLOSE_PORT\n");
+ zfcp_fsf_close_port_handler(fsf_req);
+ break;
+
+ case FSF_QTCB_CLOSE_PHYSICAL_PORT:
+ ZFCP_LOG_FLAGS(2, "FSF_QTCB_CLOSE_PHYSICAL_PORT\n");
+ zfcp_fsf_close_physical_port_handler(fsf_req);
+ break;
+
+ case FSF_QTCB_EXCHANGE_CONFIG_DATA:
+ ZFCP_LOG_FLAGS(2, "FSF_QTCB_EXCHANGE_CONFIG_DATA\n");
+ zfcp_fsf_exchange_config_data_handler(fsf_req);
+ break;
+
+ case FSF_QTCB_EXCHANGE_PORT_DATA:
+ ZFCP_LOG_FLAGS(2, "FSF_QTCB_EXCHANGE_PORT_DATA\n");
+ zfcp_fsf_exchange_port_data_handler(fsf_req);
+ break;
+
+ case FSF_QTCB_SEND_ELS:
+ ZFCP_LOG_FLAGS(2, "FSF_QTCB_SEND_ELS\n");
+ zfcp_fsf_send_els_handler(fsf_req);
+ break;
+
+ case FSF_QTCB_DOWNLOAD_CONTROL_FILE:
+ ZFCP_LOG_FLAGS(2, "FSF_QTCB_DOWNLOAD_CONTROL_FILE\n");
+ zfcp_fsf_control_file_handler(fsf_req);
+ break;
+
+ case FSF_QTCB_UPLOAD_CONTROL_FILE:
+ ZFCP_LOG_FLAGS(2, "FSF_QTCB_UPLOAD_CONTROL_FILE\n");
+ zfcp_fsf_control_file_handler(fsf_req);
+ break;
+
+ default:
+ ZFCP_LOG_FLAGS(2, "FSF_QTCB_UNKNOWN\n");
+ fsf_req->status |= ZFCP_STATUS_FSFREQ_ERROR;
+ ZFCP_LOG_NORMAL("bug: Command issued by the device driver is "
+ "not supported by the adapter %s\n",
+ zfcp_get_busid_by_adapter(fsf_req->adapter));
+ if (fsf_req->fsf_command != fsf_req->qtcb->header.fsf_command)
+ ZFCP_LOG_NORMAL
+ ("bug: Command issued by the device driver differs "
+ "from the command returned by the adapter %s "
+ "(debug info 0x%x, 0x%x).\n",
+ zfcp_get_busid_by_adapter(fsf_req->adapter),
+ fsf_req->fsf_command,
+ fsf_req->qtcb->header.fsf_command);
+ }
+
+ if (!erp_action)
+ return retval;
+
+ debug_text_event(adapter->erp_dbf, 3, "a_frh");
+ debug_event(adapter->erp_dbf, 3, &erp_action->action, sizeof (int));
+ zfcp_erp_async_handler(erp_action, 0);
+
+ return retval;
+}
+
+/*
+ * function: zfcp_fsf_status_read
+ *
+ * purpose: initiates a Status Read command at the specified adapter
+ *
+ * returns:
+ */
+int
+zfcp_fsf_status_read(struct zfcp_adapter *adapter, int req_flags)
+{
+ struct zfcp_fsf_req *fsf_req;
+ struct fsf_status_read_buffer *status_buffer;
+ unsigned long lock_flags;
+ volatile struct qdio_buffer_element *sbale;
+ int retval = 0;
+
+ /* setup new FSF request */
+ retval = zfcp_fsf_req_create(adapter, FSF_QTCB_UNSOLICITED_STATUS,
+ req_flags | ZFCP_REQ_NO_QTCB,
+ adapter->pool.fsf_req_status_read,
+ &lock_flags, &fsf_req);
+ if (retval < 0) {
+ ZFCP_LOG_INFO("error: Could not create unsolicited status "
+ "buffer for adapter %s.\n",
+ zfcp_get_busid_by_adapter(adapter));
+ goto failed_req_create;
+ }
+
+ sbale = zfcp_qdio_sbale_req(fsf_req, fsf_req->sbal_curr, 0);
+ sbale[0].flags |= SBAL_FLAGS0_TYPE_STATUS;
+ sbale[2].flags |= SBAL_FLAGS_LAST_ENTRY;
+ fsf_req->sbale_curr = 2;
+
+ status_buffer =
+ mempool_alloc(adapter->pool.data_status_read, GFP_ATOMIC);
+ if (!status_buffer) {
+ ZFCP_LOG_NORMAL("bug: could not get some buffer\n");
+ goto failed_buf;
+ }
+ memset(status_buffer, 0, sizeof (struct fsf_status_read_buffer));
+ fsf_req->data.status_read.buffer = status_buffer;
+
+ /* insert pointer to respective buffer */
+ sbale = zfcp_qdio_sbale_curr(fsf_req);
+ sbale->addr = (void *) status_buffer;
+ sbale->length = sizeof(struct fsf_status_read_buffer);
+
+ /* start QDIO request for this FSF request */
+ retval = zfcp_fsf_req_send(fsf_req, NULL);
+ if (retval) {
+ ZFCP_LOG_DEBUG("error: Could not set-up unsolicited status "
+ "environment.\n");
+ goto failed_req_send;
+ }
+
+ ZFCP_LOG_TRACE("Status Read request initiated (adapter%s)\n",
+ zfcp_get_busid_by_adapter(adapter));
+ goto out;
+
+ failed_req_send:
+ mempool_free(status_buffer, adapter->pool.data_status_read);
+
+ failed_buf:
+ zfcp_fsf_req_free(fsf_req);
+ failed_req_create:
+ out:
+ write_unlock_irqrestore(&adapter->request_queue.queue_lock, lock_flags);
+ return retval;
+}
+
+static int
+zfcp_fsf_status_read_port_closed(struct zfcp_fsf_req *fsf_req)
+{
+ struct fsf_status_read_buffer *status_buffer;
+ struct zfcp_adapter *adapter;
+ struct zfcp_port *port;
+ unsigned long flags;
+
+ status_buffer = fsf_req->data.status_read.buffer;
+ adapter = fsf_req->adapter;
+
+ read_lock_irqsave(&zfcp_data.config_lock, flags);
+ list_for_each_entry(port, &adapter->port_list_head, list)
+ if (port->d_id == (status_buffer->d_id & ZFCP_DID_MASK))
+ break;
+ read_unlock_irqrestore(&zfcp_data.config_lock, flags);
+
+ if (!port || (port->d_id != (status_buffer->d_id & ZFCP_DID_MASK))) {
+ ZFCP_LOG_NORMAL("bug: Reopen port indication received for"
+ "nonexisting port with d_id 0x%08x on "
+ "adapter %s. Ignored.\n",
+ status_buffer->d_id & ZFCP_DID_MASK,
+ zfcp_get_busid_by_adapter(adapter));
+ goto out;
+ }
+
+ switch (status_buffer->status_subtype) {
+
+ case FSF_STATUS_READ_SUB_CLOSE_PHYS_PORT:
+ ZFCP_LOG_FLAGS(2, "FSF_STATUS_READ_SUB_CLOSE_PHYS_PORT\n");
+ debug_text_event(adapter->erp_dbf, 3, "unsol_pc_phys:");
+ zfcp_erp_port_reopen(port, 0);
+ break;
+
+ case FSF_STATUS_READ_SUB_ERROR_PORT:
+ ZFCP_LOG_FLAGS(1, "FSF_STATUS_READ_SUB_ERROR_PORT\n");
+ debug_text_event(adapter->erp_dbf, 1, "unsol_pc_err:");
+ zfcp_erp_port_shutdown(port, 0);
+ break;
+
+ default:
+ debug_text_event(adapter->erp_dbf, 0, "unsol_unk_sub:");
+ debug_exception(adapter->erp_dbf, 0,
+ &status_buffer->status_subtype, sizeof (u32));
+ ZFCP_LOG_NORMAL("bug: Undefined status subtype received "
+ "for a reopen indication on port with "
+ "d_id 0x%08x on the adapter %s. "
+ "Ignored. (debug info 0x%x)\n",
+ status_buffer->d_id,
+ zfcp_get_busid_by_adapter(adapter),
+ status_buffer->status_subtype);
+ }
+ out:
+ return 0;
+}
+
+/*
+ * function: zfcp_fsf_status_read_handler
+ *
+ * purpose: is called for finished Open Port command
+ *
+ * returns:
+ */
+static int
+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;
+
+ if (fsf_req->status & ZFCP_STATUS_FSFREQ_DISMISSED) {
+ mempool_free(status_buffer, adapter->pool.data_status_read);
+ zfcp_fsf_req_cleanup(fsf_req);
+ goto out;
+ }
+
+ switch (status_buffer->status_type) {
+
+ case FSF_STATUS_READ_PORT_CLOSED:
+ ZFCP_LOG_FLAGS(1, "FSF_STATUS_READ_PORT_CLOSED\n");
+ debug_text_event(adapter->erp_dbf, 3, "unsol_pclosed:");
+ debug_event(adapter->erp_dbf, 3,
+ &status_buffer->d_id, sizeof (u32));
+ zfcp_fsf_status_read_port_closed(fsf_req);
+ break;
+
+ case FSF_STATUS_READ_INCOMING_ELS:
+ ZFCP_LOG_FLAGS(1, "FSF_STATUS_READ_INCOMING_ELS\n");
+ debug_text_event(adapter->erp_dbf, 3, "unsol_els:");
+ zfcp_fsf_incoming_els(fsf_req);
+ break;
+
+ case FSF_STATUS_READ_SENSE_DATA_AVAIL:
+ ZFCP_LOG_FLAGS(1, "FSF_STATUS_READ_SENSE_DATA_AVAIL\n");
+ debug_text_event(adapter->erp_dbf, 3, "unsol_sense:");
+ ZFCP_LOG_INFO("unsolicited sense data received (adapter %s)\n",
+ zfcp_get_busid_by_adapter(adapter));
+ ZFCP_HEX_DUMP(ZFCP_LOG_LEVEL_NORMAL, (char *) status_buffer,
+ sizeof(struct fsf_status_read_buffer));
+ break;
+
+ case FSF_STATUS_READ_BIT_ERROR_THRESHOLD:
+ ZFCP_LOG_FLAGS(1, "FSF_STATUS_READ_BIT_ERROR_THRESHOLD\n");
+ debug_text_event(adapter->erp_dbf, 3, "unsol_bit_err:");
+ ZFCP_LOG_NORMAL("Bit error threshold data received:\n");
+ ZFCP_HEX_DUMP(ZFCP_LOG_LEVEL_NORMAL,
+ (char *) status_buffer,
+ sizeof (struct fsf_status_read_buffer));
+ break;
+
+ case FSF_STATUS_READ_LINK_DOWN:
+ ZFCP_LOG_FLAGS(1, "FSF_STATUS_READ_LINK_DOWN\n");
+ debug_text_event(adapter->erp_dbf, 0, "unsol_link_down:");
+ ZFCP_LOG_INFO("Local link to adapter %s is down\n",
+ zfcp_get_busid_by_adapter(adapter));
+ atomic_set_mask(ZFCP_STATUS_ADAPTER_LINK_UNPLUGGED,
+ &adapter->status);
+ zfcp_erp_adapter_failed(adapter);
+ break;
+
+ case FSF_STATUS_READ_LINK_UP:
+ ZFCP_LOG_FLAGS(1, "FSF_STATUS_READ_LINK_UP\n");
+ debug_text_event(adapter->erp_dbf, 2, "unsol_link_up:");
+ ZFCP_LOG_INFO("Local link to adapter %s was replugged. "
+ "Restarting operations on this adapter\n",
+ zfcp_get_busid_by_adapter(adapter));
+ /* All ports should be marked as ready to run again */
+ zfcp_erp_modify_adapter_status(adapter,
+ ZFCP_STATUS_COMMON_RUNNING,
+ ZFCP_SET);
+ zfcp_erp_adapter_reopen(adapter,
+ ZFCP_STATUS_ADAPTER_LINK_UNPLUGGED
+ | ZFCP_STATUS_COMMON_ERP_FAILED);
+ break;
+
+ case FSF_STATUS_READ_CFDC_UPDATED:
+ ZFCP_LOG_FLAGS(1, "FSF_STATUS_READ_CFDC_UPDATED\n");
+ debug_text_event(adapter->erp_dbf, 2, "unsol_cfdc_update:");
+ ZFCP_LOG_INFO("CFDC has been updated on the adapter %s\n",
+ zfcp_get_busid_by_adapter(adapter));
+ zfcp_erp_adapter_access_changed(adapter);
+ break;
+
+ case FSF_STATUS_READ_CFDC_HARDENED:
+ ZFCP_LOG_FLAGS(1, "FSF_STATUS_READ_CFDC_HARDENED\n");
+ debug_text_event(adapter->erp_dbf, 2, "unsol_cfdc_harden:");
+ switch (status_buffer->status_subtype) {
+ case FSF_STATUS_READ_SUB_CFDC_HARDENED_ON_SE:
+ ZFCP_LOG_INFO("CFDC of adapter %s saved on SE\n",
+ zfcp_get_busid_by_adapter(adapter));
+ break;
+ case FSF_STATUS_READ_SUB_CFDC_HARDENED_ON_SE2:
+ ZFCP_LOG_INFO("CFDC of adapter %s has been copied "
+ "to the secondary SE\n",
+ zfcp_get_busid_by_adapter(adapter));
+ break;
+ default:
+ ZFCP_LOG_INFO("CFDC of adapter %s has been hardened\n",
+ zfcp_get_busid_by_adapter(adapter));
+ }
+ break;
+
+ default:
+ debug_text_event(adapter->erp_dbf, 0, "unsol_unknown:");
+ debug_exception(adapter->erp_dbf, 0,
+ &status_buffer->status_type, sizeof (u32));
+ ZFCP_LOG_NORMAL("bug: An unsolicited status packet of unknown "
+ "type was received (debug info 0x%x)\n",
+ status_buffer->status_type);
+ ZFCP_LOG_DEBUG("Dump of status_read_buffer %p:\n",
+ status_buffer);
+ ZFCP_HEX_DUMP(ZFCP_LOG_LEVEL_DEBUG,
+ (char *) status_buffer,
+ sizeof (struct fsf_status_read_buffer));
+ break;
+ }
+ mempool_free(status_buffer, adapter->pool.data_status_read);
+ zfcp_fsf_req_cleanup(fsf_req);
+ /*
+ * recycle buffer and start new request repeat until outbound
+ * queue is empty or adapter shutdown is requested
+ */
+ /*
+ * FIXME(qdio):
+ * we may wait in the req_create for 5s during shutdown, so
+ * qdio_cleanup will have to wait at least that long before returning
+ * with failure to allow us a proper cleanup under all circumstances
+ */
+ /*
+ * FIXME:
+ * allocation failure possible? (Is this code needed?)
+ */
+ retval = zfcp_fsf_status_read(adapter, 0);
+ if (retval < 0) {
+ ZFCP_LOG_INFO("Failed to create unsolicited status read "
+ "request for the adapter %s.\n",
+ zfcp_get_busid_by_adapter(adapter));
+ /* temporary fix to avoid status read buffer shortage */
+ adapter->status_read_failed++;
+ if ((ZFCP_STATUS_READS_RECOM - adapter->status_read_failed)
+ < ZFCP_STATUS_READ_FAILED_THRESHOLD) {
+ ZFCP_LOG_INFO("restart adapter %s due to status read "
+ "buffer shortage\n",
+ zfcp_get_busid_by_adapter(adapter));
+ zfcp_erp_adapter_reopen(adapter, 0);
+ }
+ }
+ out:
+ return retval;
+}
+
+/*
+ * function: zfcp_fsf_abort_fcp_command
+ *
+ * purpose: tells FSF to abort a running SCSI command
+ *
+ * returns: address of initiated FSF request
+ * NULL - request could not be initiated
+ *
+ * FIXME(design): should be watched by a timeout !!!
+ * FIXME(design) shouldn't this be modified to return an int
+ * also...don't know how though
+ */
+struct zfcp_fsf_req *
+zfcp_fsf_abort_fcp_command(unsigned long old_req_id,
+ struct zfcp_adapter *adapter,
+ struct zfcp_unit *unit, int req_flags)
+{
+ volatile struct qdio_buffer_element *sbale;
+ unsigned long lock_flags;
+ struct zfcp_fsf_req *fsf_req = NULL;
+ int retval = 0;
+
+ /* setup new FSF request */
+ retval = zfcp_fsf_req_create(adapter, FSF_QTCB_ABORT_FCP_CMND,
+ req_flags, adapter->pool.fsf_req_abort,
+ &lock_flags, &fsf_req);
+ if (retval < 0) {
+ ZFCP_LOG_INFO("error: Failed to create an abort command "
+ "request for lun 0x%016Lx on port 0x%016Lx "
+ "on adapter %s.\n",
+ unit->fcp_lun,
+ unit->port->wwpn,
+ zfcp_get_busid_by_adapter(adapter));
+ goto out;
+ }
+
+ 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.abort_fcp_command.unit = unit;
+
+ /* set handles of unit and its parent port in QTCB */
+ fsf_req->qtcb->header.lun_handle = unit->handle;
+ fsf_req->qtcb->header.port_handle = unit->port->handle;
+
+ /* set handle of request which should be aborted */
+ fsf_req->qtcb->bottom.support.req_handle = (u64) old_req_id;
+
+ /* start QDIO request for this FSF request */
+
+ zfcp_fsf_start_scsi_er_timer(adapter);
+ retval = zfcp_fsf_req_send(fsf_req, NULL);
+ if (retval) {
+ del_timer(&adapter->scsi_er_timer);
+ ZFCP_LOG_INFO("error: Failed to send abort command request "
+ "on adapter %s, port 0x%016Lx, unit 0x%016Lx\n",
+ zfcp_get_busid_by_adapter(adapter),
+ unit->port->wwpn, unit->fcp_lun);
+ zfcp_fsf_req_free(fsf_req);
+ fsf_req = NULL;
+ goto out;
+ }
+
+ ZFCP_LOG_DEBUG("Abort FCP Command request initiated "
+ "(adapter%s, port d_id=0x%08x, "
+ "unit x%016Lx, old_req_id=0x%lx)\n",
+ zfcp_get_busid_by_adapter(adapter),
+ unit->port->d_id,
+ unit->fcp_lun, old_req_id);
+ out:
+ write_unlock_irqrestore(&adapter->request_queue.queue_lock, lock_flags);
+ return fsf_req;
+}
+
+/*
+ * function: zfcp_fsf_abort_fcp_command_handler
+ *
+ * purpose: is called for finished Abort FCP Command request
+ *
+ * returns:
+ */
+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;
+ unsigned char status_qual =
+ new_fsf_req->qtcb->header.fsf_status_qual.word[0];
+
+ del_timer(&new_fsf_req->adapter->scsi_er_timer);
+
+ if (new_fsf_req->status & ZFCP_STATUS_FSFREQ_ERROR) {
+ /* do not set ZFCP_STATUS_FSFREQ_ABORTSUCCEEDED */
+ goto skip_fsfstatus;
+ }
+
+ /* evaluate FSF status in QTCB */
+ switch (new_fsf_req->qtcb->header.fsf_status) {
+
+ case FSF_PORT_HANDLE_NOT_VALID:
+ if (status_qual >> 4 != status_qual % 0xf) {
+ ZFCP_LOG_FLAGS(2, "FSF_PORT_HANDLE_NOT_VALID\n");
+ debug_text_event(new_fsf_req->adapter->erp_dbf, 3,
+ "fsf_s_phand_nv0");
+ /*
+ * In this case a command that was sent prior to a port
+ * reopen was aborted (handles are different). This is
+ * fine.
+ */
+ } else {
+ ZFCP_LOG_FLAGS(1, "FSF_PORT_HANDLE_NOT_VALID\n");
+ ZFCP_LOG_INFO("Temporary port identifier 0x%x for "
+ "port 0x%016Lx on adapter %s invalid. "
+ "This may happen occasionally.\n",
+ unit->port->handle,
+ unit->port->wwpn,
+ zfcp_get_busid_by_unit(unit));
+ ZFCP_LOG_INFO("status qualifier:\n");
+ ZFCP_HEX_DUMP(ZFCP_LOG_LEVEL_INFO,
+ (char *) &new_fsf_req->qtcb->header.
+ fsf_status_qual,
+ sizeof (union fsf_status_qual));
+ /* Let's hope this sorts out the mess */
+ debug_text_event(new_fsf_req->adapter->erp_dbf, 1,
+ "fsf_s_phand_nv1");
+ zfcp_erp_adapter_reopen(unit->port->adapter, 0);
+ new_fsf_req->status |= ZFCP_STATUS_FSFREQ_ERROR;
+ }
+ break;
+
+ case FSF_LUN_HANDLE_NOT_VALID:
+ if (status_qual >> 4 != status_qual % 0xf) {
+ /* 2 */
+ ZFCP_LOG_FLAGS(0, "FSF_LUN_HANDLE_NOT_VALID\n");
+ debug_text_event(new_fsf_req->adapter->erp_dbf, 3,
+ "fsf_s_lhand_nv0");
+ /*
+ * In this case a command that was sent prior to a unit
+ * reopen was aborted (handles are different).
+ * This is fine.
+ */
+ } else {
+ ZFCP_LOG_FLAGS(1, "FSF_LUN_HANDLE_NOT_VALID\n");
+ ZFCP_LOG_INFO
+ ("Warning: Temporary LUN identifier 0x%x of LUN "
+ "0x%016Lx on port 0x%016Lx on adapter %s is "
+ "invalid. This may happen in rare cases. "
+ "Trying to re-establish link.\n",
+ unit->handle,
+ unit->fcp_lun,
+ unit->port->wwpn,
+ zfcp_get_busid_by_unit(unit));
+ ZFCP_LOG_DEBUG("Status qualifier data:\n");
+ ZFCP_HEX_DUMP(ZFCP_LOG_LEVEL_DEBUG,
+ (char *) &new_fsf_req->qtcb->header.
+ fsf_status_qual,
+ sizeof (union fsf_status_qual));
+ /* Let's hope this sorts out the mess */
+ debug_text_event(new_fsf_req->adapter->erp_dbf, 1,
+ "fsf_s_lhand_nv1");
+ zfcp_erp_port_reopen(unit->port, 0);
+ new_fsf_req->status |= ZFCP_STATUS_FSFREQ_ERROR;
+ }
+ break;
+
+ case FSF_FCP_COMMAND_DOES_NOT_EXIST:
+ ZFCP_LOG_FLAGS(2, "FSF_FCP_COMMAND_DOES_NOT_EXIST\n");
+ retval = 0;
+ debug_text_event(new_fsf_req->adapter->erp_dbf, 3,
+ "fsf_s_no_exist");
+ new_fsf_req->status |= ZFCP_STATUS_FSFREQ_ABORTNOTNEEDED;
+ break;
+
+ case FSF_PORT_BOXED:
+ /* 2 */
+ ZFCP_LOG_FLAGS(0, "FSF_PORT_BOXED\n");
+ ZFCP_LOG_INFO("Remote port 0x%016Lx on adapter %s needs to "
+ "be reopened\n", unit->port->wwpn,
+ zfcp_get_busid_by_unit(unit));
+ debug_text_event(new_fsf_req->adapter->erp_dbf, 2,
+ "fsf_s_pboxed");
+ zfcp_erp_port_reopen(unit->port, 0);
+ new_fsf_req->status |= ZFCP_STATUS_FSFREQ_ERROR
+ | ZFCP_STATUS_FSFREQ_RETRY;
+ break;
+
+ case FSF_LUN_BOXED:
+ ZFCP_LOG_FLAGS(0, "FSF_LUN_BOXED\n");
+ ZFCP_LOG_INFO(
+ "unit 0x%016Lx on port 0x%016Lx on adapter %s needs "
+ "to be reopened\n",
+ unit->fcp_lun, unit->port->wwpn,
+ zfcp_get_busid_by_unit(unit));
+ debug_text_event(new_fsf_req->adapter->erp_dbf, 1, "fsf_s_lboxed");
+ zfcp_erp_unit_reopen(unit, 0);
+ zfcp_cmd_dbf_event_fsf("unitbox", new_fsf_req,
+ &new_fsf_req->qtcb->header.fsf_status_qual,
+ sizeof(union fsf_status_qual));
+ new_fsf_req->status |= ZFCP_STATUS_FSFREQ_ERROR
+ | ZFCP_STATUS_FSFREQ_RETRY;
+ break;
+
+ case FSF_ADAPTER_STATUS_AVAILABLE:
+ /* 2 */
+ ZFCP_LOG_FLAGS(0, "FSF_ADAPTER_STATUS_AVAILABLE\n");
+ switch (new_fsf_req->qtcb->header.fsf_status_qual.word[0]) {
+ case FSF_SQ_INVOKE_LINK_TEST_PROCEDURE:
+ ZFCP_LOG_FLAGS(2,
+ "FSF_SQ_INVOKE_LINK_TEST_PROCEDURE\n");
+ debug_text_event(new_fsf_req->adapter->erp_dbf, 1,
+ "fsf_sq_ltest");
+ /* reopening link to port */
+ zfcp_erp_port_reopen(unit->port, 0);
+ new_fsf_req->status |= ZFCP_STATUS_FSFREQ_ERROR;
+ break;
+ case FSF_SQ_ULP_DEPENDENT_ERP_REQUIRED:
+ ZFCP_LOG_FLAGS(2,
+ "FSF_SQ_ULP_DEPENDENT_ERP_REQUIRED\n");
+ /* SCSI stack will escalate */
+ debug_text_event(new_fsf_req->adapter->erp_dbf, 1,
+ "fsf_sq_ulp");
+ new_fsf_req->status |= ZFCP_STATUS_FSFREQ_ERROR;
+ break;
+ default:
+ ZFCP_LOG_NORMAL
+ ("bug: Wrong status qualifier 0x%x arrived.\n",
+ new_fsf_req->qtcb->header.fsf_status_qual.word[0]);
+ debug_text_event(new_fsf_req->adapter->erp_dbf, 0,
+ "fsf_sq_inval:");
+ debug_exception(new_fsf_req->adapter->erp_dbf, 0,
+ &new_fsf_req->qtcb->header.
+ fsf_status_qual.word[0], sizeof (u32));
+ break;
+ }
+ break;
+
+ case FSF_GOOD:
+ /* 3 */
+ ZFCP_LOG_FLAGS(0, "FSF_GOOD\n");
+ retval = 0;
+ new_fsf_req->status |= ZFCP_STATUS_FSFREQ_ABORTSUCCEEDED;
+ break;
+
+ default:
+ ZFCP_LOG_NORMAL("bug: An unknown FSF Status was presented "
+ "(debug info 0x%x)\n",
+ new_fsf_req->qtcb->header.fsf_status);
+ debug_text_event(new_fsf_req->adapter->erp_dbf, 0,
+ "fsf_s_inval:");
+ debug_exception(new_fsf_req->adapter->erp_dbf, 0,
+ &new_fsf_req->qtcb->header.fsf_status,
+ sizeof (u32));
+ break;
+ }
+ skip_fsfstatus:
+ return retval;
+}
+
+/**
+ * zfcp_use_one_sbal - checks whether req buffer and resp bother each fit into
+ * one SBALE
+ * Two scatter-gather lists are passed, one for the reqeust and one for the
+ * response.
+ */
+static inline int
+zfcp_use_one_sbal(struct scatterlist *req, int req_count,
+ struct scatterlist *resp, int resp_count)
+{
+ return ((req_count == 1) &&
+ (resp_count == 1) &&
+ (((unsigned long) zfcp_sg_to_address(&req[0]) &
+ PAGE_MASK) ==
+ ((unsigned long) (zfcp_sg_to_address(&req[0]) +
+ req[0].length - 1) & PAGE_MASK)) &&
+ (((unsigned long) zfcp_sg_to_address(&resp[0]) &
+ PAGE_MASK) ==
+ ((unsigned long) (zfcp_sg_to_address(&resp[0]) +
+ resp[0].length - 1) & PAGE_MASK)));
+}
+
+/**
+ * zfcp_fsf_send_ct - initiate a Generic Service request (FC-GS)
+ * @ct: pointer to struct zfcp_send_ct which conatins all needed data for
+ * the request
+ * @pool: pointer to memory pool, if non-null this pool is used to allocate
+ * a struct zfcp_fsf_req
+ * @erp_action: pointer to erp_action, if non-null the Generic Service request
+ * is sent within error recovery
+ */
+int
+zfcp_fsf_send_ct(struct zfcp_send_ct *ct, mempool_t *pool,
+ struct zfcp_erp_action *erp_action)
+{
+ volatile struct qdio_buffer_element *sbale;
+ struct zfcp_port *port;
+ struct zfcp_adapter *adapter;
+ struct zfcp_fsf_req *fsf_req;
+ unsigned long lock_flags;
+ int bytes;
+ int ret = 0;
+
+ port = ct->port;
+ adapter = port->adapter;
+
+ ret = zfcp_fsf_req_create(adapter, FSF_QTCB_SEND_GENERIC,
+ ZFCP_WAIT_FOR_SBAL | ZFCP_REQ_AUTO_CLEANUP,
+ pool, &lock_flags, &fsf_req);
+ if (ret < 0) {
+ ZFCP_LOG_INFO("error: Could not create CT request (FC-GS) for "
+ "adapter: %s\n",
+ zfcp_get_busid_by_adapter(adapter));
+ goto failed_req;
+ }
+
+ if (erp_action != NULL) {
+ erp_action->fsf_req = fsf_req;
+ fsf_req->erp_action = erp_action;
+ }
+
+ sbale = zfcp_qdio_sbale_req(fsf_req, fsf_req->sbal_curr, 0);
+ if (zfcp_use_one_sbal(ct->req, ct->req_count,
+ ct->resp, ct->resp_count)){
+ /* both request buffer and response buffer
+ fit into one sbale each */
+ sbale[0].flags |= SBAL_FLAGS0_TYPE_WRITE_READ;
+ sbale[2].addr = zfcp_sg_to_address(&ct->req[0]);
+ sbale[2].length = ct->req[0].length;
+ sbale[3].addr = zfcp_sg_to_address(&ct->resp[0]);
+ sbale[3].length = ct->resp[0].length;
+ sbale[3].flags |= SBAL_FLAGS_LAST_ENTRY;
+ } else if (adapter->supported_features &
+ FSF_FEATURE_ELS_CT_CHAINED_SBALS) {
+ /* try to use chained SBALs */
+ bytes = zfcp_qdio_sbals_from_sg(fsf_req,
+ SBAL_FLAGS0_TYPE_WRITE_READ,
+ ct->req, ct->req_count,
+ ZFCP_MAX_SBALS_PER_CT_REQ);
+ if (bytes <= 0) {
+ ZFCP_LOG_INFO("error: creation of CT request failed "
+ "on adapter %s\n",
+ zfcp_get_busid_by_adapter(adapter));
+ if (bytes == 0)
+ ret = -ENOMEM;
+ else
+ ret = bytes;
+
+ goto failed_send;
+ }
+ fsf_req->qtcb->bottom.support.req_buf_length = bytes;
+ fsf_req->sbale_curr = ZFCP_LAST_SBALE_PER_SBAL;
+ bytes = zfcp_qdio_sbals_from_sg(fsf_req,
+ SBAL_FLAGS0_TYPE_WRITE_READ,
+ ct->resp, ct->resp_count,
+ ZFCP_MAX_SBALS_PER_CT_REQ);
+ if (bytes <= 0) {
+ ZFCP_LOG_INFO("error: creation of CT request failed "
+ "on adapter %s\n",
+ zfcp_get_busid_by_adapter(adapter));
+ if (bytes == 0)
+ ret = -ENOMEM;
+ else
+ ret = bytes;
+
+ goto failed_send;
+ }
+ fsf_req->qtcb->bottom.support.resp_buf_length = bytes;
+ } else {
+ /* reject send generic request */
+ ZFCP_LOG_INFO(
+ "error: microcode does not support chained SBALs,"
+ "CT request too big (adapter %s)\n",
+ zfcp_get_busid_by_adapter(adapter));
+ ret = -EOPNOTSUPP;
+ goto failed_send;
+ }
+
+ /* settings in QTCB */
+ 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;
+
+ /* start QDIO request for this FSF request */
+ ret = zfcp_fsf_req_send(fsf_req, ct->timer);
+ if (ret) {
+ ZFCP_LOG_DEBUG("error: initiation of CT request failed "
+ "(adapter %s, port 0x%016Lx)\n",
+ zfcp_get_busid_by_adapter(adapter), port->wwpn);
+ goto failed_send;
+ }
+
+ ZFCP_LOG_DEBUG("CT request initiated (adapter %s, port 0x%016Lx)\n",
+ zfcp_get_busid_by_adapter(adapter), port->wwpn);
+ goto out;
+
+ failed_send:
+ zfcp_fsf_req_free(fsf_req);
+ if (erp_action != NULL) {
+ erp_action->fsf_req = NULL;
+ }
+ failed_req:
+ out:
+ write_unlock_irqrestore(&adapter->request_queue.queue_lock,
+ lock_flags);
+ return ret;
+}
+
+/**
+ * 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.
+ */
+static int
+zfcp_fsf_send_ct_handler(struct zfcp_fsf_req *fsf_req)
+{
+ struct zfcp_port *port;
+ struct zfcp_adapter *adapter;
+ struct zfcp_send_ct *send_ct;
+ struct fsf_qtcb_header *header;
+ struct fsf_qtcb_bottom_support *bottom;
+ int retval = -EINVAL;
+ u16 subtable, rule, counter;
+
+ adapter = fsf_req->adapter;
+ send_ct = fsf_req->data.send_ct;
+ port = send_ct->port;
+ header = &fsf_req->qtcb->header;
+ bottom = &fsf_req->qtcb->bottom.support;
+
+ if (fsf_req->status & ZFCP_STATUS_FSFREQ_ERROR)
+ goto skip_fsfstatus;
+
+ /* evaluate FSF status in QTCB */
+ switch (header->fsf_status) {
+
+ case FSF_GOOD:
+ ZFCP_LOG_FLAGS(2,"FSF_GOOD\n");
+ retval = 0;
+ break;
+
+ case FSF_SERVICE_CLASS_NOT_SUPPORTED:
+ ZFCP_LOG_FLAGS(2, "FSF_SERVICE_CLASS_NOT_SUPPORTED\n");
+ if (adapter->fc_service_class <= 3) {
+ ZFCP_LOG_INFO("error: adapter %s does not support fc "
+ "class %d.\n",
+ zfcp_get_busid_by_port(port),
+ adapter->fc_service_class);
+ } else {
+ ZFCP_LOG_INFO("bug: The fibre channel class at the "
+ "adapter %s is invalid. "
+ "(debug info %d)\n",
+ zfcp_get_busid_by_port(port),
+ adapter->fc_service_class);
+ }
+ /* stop operation for this adapter */
+ debug_text_exception(adapter->erp_dbf, 0, "fsf_s_class_nsup");
+ zfcp_erp_adapter_shutdown(adapter, 0);
+ fsf_req->status |= ZFCP_STATUS_FSFREQ_ERROR;
+ break;
+
+ case FSF_ADAPTER_STATUS_AVAILABLE:
+ ZFCP_LOG_FLAGS(2, "FSF_ADAPTER_STATUS_AVAILABLE\n");
+ switch (header->fsf_status_qual.word[0]){
+ case FSF_SQ_INVOKE_LINK_TEST_PROCEDURE:
+ ZFCP_LOG_FLAGS(2,"FSF_SQ_INVOKE_LINK_TEST_PROCEDURE\n");
+ /* reopening link to port */
+ debug_text_event(adapter->erp_dbf, 1, "fsf_sq_ltest");
+ zfcp_test_link(port);
+ fsf_req->status |= ZFCP_STATUS_FSFREQ_ERROR;
+ break;
+ case FSF_SQ_ULP_DEPENDENT_ERP_REQUIRED:
+ ZFCP_LOG_FLAGS(2,"FSF_SQ_ULP_DEPENDENT_ERP_REQUIRED\n");
+ /* ERP strategy will escalate */
+ debug_text_event(adapter->erp_dbf, 1, "fsf_sq_ulp");
+ fsf_req->status |= ZFCP_STATUS_FSFREQ_ERROR;
+ break;
+ default:
+ ZFCP_LOG_INFO("bug: Wrong status qualifier 0x%x "
+ "arrived.\n",
+ header->fsf_status_qual.word[0]);
+ break;
+ }
+ break;
+
+ case FSF_ACCESS_DENIED:
+ ZFCP_LOG_FLAGS(2, "FSF_ACCESS_DENIED\n");
+ ZFCP_LOG_NORMAL("access denied, cannot send generic service "
+ "command (adapter %s, port d_id=0x%08x)\n",
+ zfcp_get_busid_by_port(port), port->d_id);
+ for (counter = 0; counter < 2; counter++) {
+ subtable = header->fsf_status_qual.halfword[counter * 2];
+ rule = header->fsf_status_qual.halfword[counter * 2 + 1];
+ switch (subtable) {
+ case FSF_SQ_CFDC_SUBTABLE_OS:
+ case FSF_SQ_CFDC_SUBTABLE_PORT_WWPN:
+ case FSF_SQ_CFDC_SUBTABLE_PORT_DID:
+ case FSF_SQ_CFDC_SUBTABLE_LUN:
+ ZFCP_LOG_INFO("Access denied (%s rule %d)\n",
+ zfcp_act_subtable_type[subtable], rule);
+ break;
+ }
+ }
+ debug_text_event(adapter->erp_dbf, 1, "fsf_s_access");
+ zfcp_erp_port_access_denied(port);
+ fsf_req->status |= ZFCP_STATUS_FSFREQ_ERROR;
+ break;
+
+ case FSF_GENERIC_COMMAND_REJECTED:
+ ZFCP_LOG_FLAGS(2, "FSF_GENERIC_COMMAND_REJECTED\n");
+ ZFCP_LOG_INFO("generic service command rejected "
+ "(adapter %s, port d_id=0x%08x)\n",
+ zfcp_get_busid_by_port(port), port->d_id);
+ ZFCP_LOG_INFO("status qualifier:\n");
+ ZFCP_HEX_DUMP(ZFCP_LOG_LEVEL_INFO,
+ (char *) &header->fsf_status_qual,
+ sizeof (union fsf_status_qual));
+ debug_text_event(adapter->erp_dbf, 1, "fsf_s_gcom_rej");
+ fsf_req->status |= ZFCP_STATUS_FSFREQ_ERROR;
+ break;
+
+ case FSF_PORT_HANDLE_NOT_VALID:
+ ZFCP_LOG_FLAGS(2, "FSF_PORT_HANDLE_NOT_VALID\n");
+ ZFCP_LOG_DEBUG("Temporary port identifier 0x%x for port "
+ "0x%016Lx on adapter %s invalid. This may "
+ "happen occasionally.\n", port->handle,
+ port->wwpn, zfcp_get_busid_by_port(port));
+ ZFCP_LOG_INFO("status qualifier:\n");
+ ZFCP_HEX_DUMP(ZFCP_LOG_LEVEL_INFO,
+ (char *) &header->fsf_status_qual,
+ sizeof (union fsf_status_qual));
+ debug_text_event(adapter->erp_dbf, 1, "fsf_s_phandle_nv");
+ zfcp_erp_adapter_reopen(adapter, 0);
+ fsf_req->status |= ZFCP_STATUS_FSFREQ_ERROR;
+ break;
+
+ case FSF_PORT_BOXED:
+ ZFCP_LOG_FLAGS(2, "FSF_PORT_BOXED\n");
+ ZFCP_LOG_INFO("port needs to be reopened "
+ "(adapter %s, port d_id=0x%08x)\n",
+ zfcp_get_busid_by_port(port), port->d_id);
+ debug_text_event(adapter->erp_dbf, 2, "fsf_s_pboxed");
+ zfcp_erp_port_reopen(port, 0);
+ fsf_req->status |= ZFCP_STATUS_FSFREQ_ERROR
+ | ZFCP_STATUS_FSFREQ_RETRY;
+ break;
+
+ /* following states should never occure, all cases avoided
+ in zfcp_fsf_send_ct - but who knows ... */
+ case FSF_PAYLOAD_SIZE_MISMATCH:
+ ZFCP_LOG_FLAGS(2, "FSF_PAYLOAD_SIZE_MISMATCH\n");
+ ZFCP_LOG_INFO("payload size mismatch (adapter: %s, "
+ "req_buf_length=%d, resp_buf_length=%d)\n",
+ zfcp_get_busid_by_adapter(adapter),
+ bottom->req_buf_length, bottom->resp_buf_length);
+ fsf_req->status |= ZFCP_STATUS_FSFREQ_ERROR;
+ break;
+ case FSF_REQUEST_SIZE_TOO_LARGE:
+ ZFCP_LOG_FLAGS(2, "FSF_REQUEST_SIZE_TOO_LARGE\n");
+ ZFCP_LOG_INFO("request size too large (adapter: %s, "
+ "req_buf_length=%d)\n",
+ zfcp_get_busid_by_adapter(adapter),
+ bottom->req_buf_length);
+ fsf_req->status |= ZFCP_STATUS_FSFREQ_ERROR;
+ break;
+ case FSF_RESPONSE_SIZE_TOO_LARGE:
+ ZFCP_LOG_FLAGS(2, "FSF_RESPONSE_SIZE_TOO_LARGE\n");
+ ZFCP_LOG_INFO("response size too large (adapter: %s, "
+ "resp_buf_length=%d)\n",
+ zfcp_get_busid_by_adapter(adapter),
+ bottom->resp_buf_length);
+ fsf_req->status |= ZFCP_STATUS_FSFREQ_ERROR;
+ break;
+ case FSF_SBAL_MISMATCH:
+ ZFCP_LOG_FLAGS(2, "FSF_SBAL_MISMATCH\n");
+ ZFCP_LOG_INFO("SBAL mismatch (adapter: %s, req_buf_length=%d, "
+ "resp_buf_length=%d)\n",
+ zfcp_get_busid_by_adapter(adapter),
+ bottom->req_buf_length, bottom->resp_buf_length);
+ fsf_req->status |= ZFCP_STATUS_FSFREQ_ERROR;
+ break;
+
+ default:
+ ZFCP_LOG_NORMAL("bug: An unknown FSF Status was presented "
+ "(debug info 0x%x)\n", header->fsf_status);
+ debug_text_event(adapter->erp_dbf, 0, "fsf_sq_inval:");
+ debug_exception(adapter->erp_dbf, 0,
+ &header->fsf_status_qual.word[0], sizeof (u32));
+ break;
+ }
+
+skip_fsfstatus:
+ send_ct->status = retval;
+
+ if (send_ct->handler != NULL)
+ send_ct->handler(send_ct->handler_data);
+
+ return retval;
+}
+
+/**
+ * zfcp_fsf_send_els - initiate an ELS command (FC-FS)
+ * @els: pointer to struct zfcp_send_els which contains all needed data for
+ * the command.
+ */
+int
+zfcp_fsf_send_els(struct zfcp_send_els *els)
+{
+ volatile struct qdio_buffer_element *sbale;
+ struct zfcp_fsf_req *fsf_req;
+ fc_id_t d_id;
+ struct zfcp_adapter *adapter;
+ unsigned long lock_flags;
+ int bytes;
+ int ret = 0;
+
+ d_id = els->d_id;
+ adapter = els->adapter;
+
+ ret = zfcp_fsf_req_create(adapter, FSF_QTCB_SEND_ELS,
+ ZFCP_REQ_AUTO_CLEANUP,
+ NULL, &lock_flags, &fsf_req);
+ if (ret < 0) {
+ ZFCP_LOG_INFO("error: creation of ELS request failed "
+ "(adapter %s, port d_id: 0x%08x)\n",
+ zfcp_get_busid_by_adapter(adapter), d_id);
+ goto failed_req;
+ }
+
+ sbale = zfcp_qdio_sbale_req(fsf_req, fsf_req->sbal_curr, 0);
+ if (zfcp_use_one_sbal(els->req, els->req_count,
+ els->resp, els->resp_count)){
+ /* both request buffer and response buffer
+ fit into one sbale each */
+ sbale[0].flags |= SBAL_FLAGS0_TYPE_WRITE_READ;
+ sbale[2].addr = zfcp_sg_to_address(&els->req[0]);
+ sbale[2].length = els->req[0].length;
+ sbale[3].addr = zfcp_sg_to_address(&els->resp[0]);
+ sbale[3].length = els->resp[0].length;
+ sbale[3].flags |= SBAL_FLAGS_LAST_ENTRY;
+ } else if (adapter->supported_features &
+ FSF_FEATURE_ELS_CT_CHAINED_SBALS) {
+ /* try to use chained SBALs */
+ bytes = zfcp_qdio_sbals_from_sg(fsf_req,
+ SBAL_FLAGS0_TYPE_WRITE_READ,
+ els->req, els->req_count,
+ ZFCP_MAX_SBALS_PER_ELS_REQ);
+ if (bytes <= 0) {
+ ZFCP_LOG_INFO("error: creation of ELS request failed "
+ "(adapter %s, port d_id: 0x%08x)\n",
+ zfcp_get_busid_by_adapter(adapter), d_id);
+ if (bytes == 0) {
+ ret = -ENOMEM;
+ } else {
+ ret = bytes;
+ }
+ goto failed_send;
+ }
+ fsf_req->qtcb->bottom.support.req_buf_length = bytes;
+ fsf_req->sbale_curr = ZFCP_LAST_SBALE_PER_SBAL;
+ bytes = zfcp_qdio_sbals_from_sg(fsf_req,
+ SBAL_FLAGS0_TYPE_WRITE_READ,
+ els->resp, els->resp_count,
+ ZFCP_MAX_SBALS_PER_ELS_REQ);
+ if (bytes <= 0) {
+ ZFCP_LOG_INFO("error: creation of ELS request failed "
+ "(adapter %s, port d_id: 0x%08x)\n",
+ zfcp_get_busid_by_adapter(adapter), d_id);
+ if (bytes == 0) {
+ ret = -ENOMEM;
+ } else {
+ ret = bytes;
+ }
+ goto failed_send;
+ }
+ fsf_req->qtcb->bottom.support.resp_buf_length = bytes;
+ } else {
+ /* reject request */
+ ZFCP_LOG_INFO("error: microcode does not support chained SBALs"
+ ", ELS request too big (adapter %s, "
+ "port d_id: 0x%08x)\n",
+ zfcp_get_busid_by_adapter(adapter), d_id);
+ ret = -EOPNOTSUPP;
+ goto failed_send;
+ }
+
+ /* settings in QTCB */
+ 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;
+
+ sbale = zfcp_qdio_sbale_req(fsf_req, fsf_req->sbal_curr, 0);
+
+ /* start QDIO request for this FSF request */
+ ret = zfcp_fsf_req_send(fsf_req, els->timer);
+ if (ret) {
+ ZFCP_LOG_DEBUG("error: initiation of ELS request failed "
+ "(adapter %s, port d_id: 0x%08x)\n",
+ zfcp_get_busid_by_adapter(adapter), d_id);
+ goto failed_send;
+ }
+
+ ZFCP_LOG_DEBUG("ELS request initiated (adapter %s, port d_id: "
+ "0x%08x)\n", zfcp_get_busid_by_adapter(adapter), d_id);
+ goto out;
+
+ failed_send:
+ zfcp_fsf_req_free(fsf_req);
+
+ failed_req:
+ out:
+ write_unlock_irqrestore(&adapter->request_queue.queue_lock,
+ lock_flags);
+
+ return ret;
+}
+
+/**
+ * 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.
+ */
+static int zfcp_fsf_send_els_handler(struct zfcp_fsf_req *fsf_req)
+{
+ struct zfcp_adapter *adapter;
+ fc_id_t d_id;
+ struct zfcp_port *port;
+ struct fsf_qtcb_header *header;
+ struct fsf_qtcb_bottom_support *bottom;
+ struct zfcp_send_els *send_els;
+ int retval = -EINVAL;
+ u16 subtable, rule, counter;
+
+ send_els = fsf_req->data.send_els;
+ adapter = send_els->adapter;
+ d_id = send_els->d_id;
+ header = &fsf_req->qtcb->header;
+ bottom = &fsf_req->qtcb->bottom.support;
+
+ if (fsf_req->status & ZFCP_STATUS_FSFREQ_ERROR)
+ goto skip_fsfstatus;
+
+ switch (header->fsf_status) {
+
+ case FSF_GOOD:
+ ZFCP_LOG_FLAGS(2, "FSF_GOOD\n");
+ retval = 0;
+ break;
+
+ case FSF_SERVICE_CLASS_NOT_SUPPORTED:
+ ZFCP_LOG_FLAGS(2, "FSF_SERVICE_CLASS_NOT_SUPPORTED\n");
+ if (adapter->fc_service_class <= 3) {
+ ZFCP_LOG_INFO("error: adapter %s does "
+ "not support fibrechannel class %d.\n",
+ zfcp_get_busid_by_adapter(adapter),
+ adapter->fc_service_class);
+ } else {
+ ZFCP_LOG_INFO("bug: The fibrechannel class at "
+ "adapter %s is invalid. "
+ "(debug info %d)\n",
+ zfcp_get_busid_by_adapter(adapter),
+ adapter->fc_service_class);
+ }
+ /* stop operation for this adapter */
+ debug_text_exception(adapter->erp_dbf, 0, "fsf_s_class_nsup");
+ zfcp_erp_adapter_shutdown(adapter, 0);
+ fsf_req->status |= ZFCP_STATUS_FSFREQ_ERROR;
+ break;
+
+ case FSF_ADAPTER_STATUS_AVAILABLE:
+ ZFCP_LOG_FLAGS(2, "FSF_ADAPTER_STATUS_AVAILABLE\n");
+ switch (header->fsf_status_qual.word[0]){
+ case FSF_SQ_INVOKE_LINK_TEST_PROCEDURE:
+ ZFCP_LOG_FLAGS(2,"FSF_SQ_INVOKE_LINK_TEST_PROCEDURE\n");
+ debug_text_event(adapter->erp_dbf, 1, "fsf_sq_ltest");
+ if (send_els->ls_code != ZFCP_LS_ADISC) {
+ read_lock(&zfcp_data.config_lock);
+ port = zfcp_get_port_by_did(adapter, d_id);
+ if (port)
+ zfcp_test_link(port);
+ read_unlock(&zfcp_data.config_lock);
+ }
+ fsf_req->status |= ZFCP_STATUS_FSFREQ_ERROR;
+ break;
+ case FSF_SQ_ULP_DEPENDENT_ERP_REQUIRED:
+ ZFCP_LOG_FLAGS(2,"FSF_SQ_ULP_DEPENDENT_ERP_REQUIRED\n");
+ debug_text_event(adapter->erp_dbf, 1, "fsf_sq_ulp");
+ fsf_req->status |= ZFCP_STATUS_FSFREQ_ERROR;
+ retval =
+ zfcp_handle_els_rjt(header->fsf_status_qual.word[1],
+ (struct zfcp_ls_rjt_par *)
+ &header->fsf_status_qual.word[2]);
+ break;
+ case FSF_SQ_RETRY_IF_POSSIBLE:
+ ZFCP_LOG_FLAGS(2, "FSF_SQ_RETRY_IF_POSSIBLE\n");
+ debug_text_event(adapter->erp_dbf, 1, "fsf_sq_retry");
+ fsf_req->status |= ZFCP_STATUS_FSFREQ_ERROR;
+ break;
+ default:
+ ZFCP_LOG_INFO("bug: Wrong status qualifier 0x%x\n",
+ header->fsf_status_qual.word[0]);
+ ZFCP_HEX_DUMP(ZFCP_LOG_LEVEL_INFO,
+ (char*)header->fsf_status_qual.word, 16);
+ }
+ break;
+
+ case FSF_ELS_COMMAND_REJECTED:
+ ZFCP_LOG_FLAGS(2, "FSF_ELS_COMMAND_REJECTED\n");
+ ZFCP_LOG_INFO("ELS has been rejected because command filter "
+ "prohibited sending "
+ "(adapter: %s, port d_id: 0x%08x)\n",
+ zfcp_get_busid_by_adapter(adapter), d_id);
+
+ break;
+
+ case FSF_PAYLOAD_SIZE_MISMATCH:
+ ZFCP_LOG_FLAGS(2, "FSF_PAYLOAD_SIZE_MISMATCH\n");
+ ZFCP_LOG_INFO(
+ "ELS request size and ELS response size must be either "
+ "both 0, or both greater than 0 "
+ "(adapter: %s, req_buf_length=%d resp_buf_length=%d)\n",
+ zfcp_get_busid_by_adapter(adapter),
+ bottom->req_buf_length,
+ bottom->resp_buf_length);
+ break;
+
+ case FSF_REQUEST_SIZE_TOO_LARGE:
+ ZFCP_LOG_FLAGS(2, "FSF_REQUEST_SIZE_TOO_LARGE\n");
+ ZFCP_LOG_INFO(
+ "Length of the ELS request buffer, "
+ "specified in QTCB bottom, "
+ "exceeds the size of the buffers "
+ "that have been allocated for ELS request data "
+ "(adapter: %s, req_buf_length=%d)\n",
+ zfcp_get_busid_by_adapter(adapter),
+ bottom->req_buf_length);
+ break;
+
+ case FSF_RESPONSE_SIZE_TOO_LARGE:
+ ZFCP_LOG_FLAGS(2, "FSF_RESPONSE_SIZE_TOO_LARGE\n");
+ ZFCP_LOG_INFO(
+ "Length of the ELS response buffer, "
+ "specified in QTCB bottom, "
+ "exceeds the size of the buffers "
+ "that have been allocated for ELS response data "
+ "(adapter: %s, resp_buf_length=%d)\n",
+ zfcp_get_busid_by_adapter(adapter),
+ bottom->resp_buf_length);
+ break;
+
+ case FSF_SBAL_MISMATCH:
+ /* should never occure, avoided in zfcp_fsf_send_els */
+ ZFCP_LOG_FLAGS(2, "FSF_SBAL_MISMATCH\n");
+ ZFCP_LOG_INFO("SBAL mismatch (adapter: %s, req_buf_length=%d, "
+ "resp_buf_length=%d)\n",
+ zfcp_get_busid_by_adapter(adapter),
+ bottom->req_buf_length, bottom->resp_buf_length);
+ fsf_req->status |= ZFCP_STATUS_FSFREQ_ERROR;
+ break;
+
+ case FSF_ACCESS_DENIED:
+ ZFCP_LOG_FLAGS(2, "FSF_ACCESS_DENIED\n");
+ ZFCP_LOG_NORMAL("access denied, cannot send ELS command "
+ "(adapter %s, port d_id=0x%08x)\n",
+ zfcp_get_busid_by_adapter(adapter), d_id);
+ for (counter = 0; counter < 2; counter++) {
+ subtable = header->fsf_status_qual.halfword[counter * 2];
+ rule = header->fsf_status_qual.halfword[counter * 2 + 1];
+ switch (subtable) {
+ case FSF_SQ_CFDC_SUBTABLE_OS:
+ case FSF_SQ_CFDC_SUBTABLE_PORT_WWPN:
+ case FSF_SQ_CFDC_SUBTABLE_PORT_DID:
+ case FSF_SQ_CFDC_SUBTABLE_LUN:
+ ZFCP_LOG_INFO("Access denied (%s rule %d)\n",
+ zfcp_act_subtable_type[subtable], rule);
+ break;
+ }
+ }
+ debug_text_event(adapter->erp_dbf, 1, "fsf_s_access");
+ read_lock(&zfcp_data.config_lock);
+ port = zfcp_get_port_by_did(adapter, d_id);
+ if (port != NULL)
+ zfcp_erp_port_access_denied(port);
+ read_unlock(&zfcp_data.config_lock);
+ fsf_req->status |= ZFCP_STATUS_FSFREQ_ERROR;
+ break;
+
+ default:
+ ZFCP_LOG_NORMAL(
+ "bug: An unknown FSF Status was presented "
+ "(adapter: %s, fsf_status=0x%08x)\n",
+ zfcp_get_busid_by_adapter(adapter),
+ header->fsf_status);
+ debug_text_event(adapter->erp_dbf, 0, "fsf_sq_inval");
+ debug_exception(adapter->erp_dbf, 0,
+ &header->fsf_status_qual.word[0], sizeof(u32));
+ fsf_req->status |= ZFCP_STATUS_FSFREQ_ERROR;
+ break;
+ }
+
+skip_fsfstatus:
+ send_els->status = retval;
+
+ if (send_els->handler != 0)
+ send_els->handler(send_els->handler_data);
+
+ return retval;
+}
+
+/*
+ * function:
+ *
+ * purpose:
+ *
+ * returns: address of initiated FSF request
+ * NULL - request could not be initiated
+ */
+int
+zfcp_fsf_exchange_config_data(struct zfcp_erp_action *erp_action)
+{
+ volatile struct qdio_buffer_element *sbale;
+ unsigned long lock_flags;
+ int retval = 0;
+
+ /* setup new FSF request */
+ retval = zfcp_fsf_req_create(erp_action->adapter,
+ FSF_QTCB_EXCHANGE_CONFIG_DATA,
+ ZFCP_REQ_AUTO_CLEANUP,
+ erp_action->adapter->pool.fsf_req_erp,
+ &lock_flags, &(erp_action->fsf_req));
+ if (retval < 0) {
+ ZFCP_LOG_INFO("error: Could not create exchange configuration "
+ "data request for adapter %s.\n",
+ zfcp_get_busid_by_adapter(erp_action->adapter));
+ goto out;
+ }
+
+ sbale = zfcp_qdio_sbale_req(erp_action->fsf_req,
+ erp_action->fsf_req->sbal_curr, 0);
+ sbale[0].flags |= SBAL_FLAGS0_TYPE_READ;
+ sbale[1].flags |= SBAL_FLAGS_LAST_ENTRY;
+
+ erp_action->fsf_req->erp_action = erp_action;
+ erp_action->fsf_req->qtcb->bottom.config.feature_selection =
+ (FSF_FEATURE_CFDC | FSF_FEATURE_LUN_SHARING);
+
+ /* start QDIO request for this FSF request */
+ retval = zfcp_fsf_req_send(erp_action->fsf_req, &erp_action->timer);
+ if (retval) {
+ ZFCP_LOG_INFO
+ ("error: Could not send exchange configuration data "
+ "command on the adapter %s\n",
+ zfcp_get_busid_by_adapter(erp_action->adapter));
+ zfcp_fsf_req_free(erp_action->fsf_req);
+ erp_action->fsf_req = NULL;
+ goto out;
+ }
+
+ ZFCP_LOG_DEBUG("exchange configuration data request initiated "
+ "(adapter %s)\n",
+ zfcp_get_busid_by_adapter(erp_action->adapter));
+
+ out:
+ write_unlock_irqrestore(&erp_action->adapter->request_queue.queue_lock,
+ lock_flags);
+ return retval;
+}
+
+/**
+ * zfcp_fsf_exchange_config_evaluate
+ * @fsf_req: fsf_req which belongs to xchg config data request
+ * @xchg_ok: specifies if xchg config data was incomplete or complete (0/1)
+ *
+ * returns: -EIO on error, 0 otherwise
+ */
+static int
+zfcp_fsf_exchange_config_evaluate(struct zfcp_fsf_req *fsf_req, int xchg_ok)
+{
+ struct fsf_qtcb_bottom_config *bottom;
+ struct zfcp_adapter *adapter = fsf_req->adapter;
+
+ bottom = &fsf_req->qtcb->bottom.config;
+ ZFCP_LOG_DEBUG("low/high QTCB version 0x%x/0x%x of FSF\n",
+ bottom->low_qtcb_version, bottom->high_qtcb_version);
+ adapter->fsf_lic_version = bottom->lic_version;
+ adapter->supported_features = bottom->supported_features;
+
+ if (xchg_ok) {
+ adapter->wwnn = bottom->nport_serv_param.wwnn;
+ adapter->wwpn = bottom->nport_serv_param.wwpn;
+ adapter->s_id = bottom->s_id & ZFCP_DID_MASK;
+ adapter->fc_topology = bottom->fc_topology;
+ adapter->fc_link_speed = bottom->fc_link_speed;
+ adapter->hydra_version = bottom->adapter_type;
+ } else {
+ adapter->wwnn = 0;
+ adapter->wwpn = 0;
+ adapter->s_id = 0;
+ adapter->fc_topology = 0;
+ adapter->fc_link_speed = 0;
+ adapter->hydra_version = 0;
+ }
+
+ if(adapter->supported_features & FSF_FEATURE_HBAAPI_MANAGEMENT){
+ adapter->hardware_version = bottom->hardware_version;
+ memcpy(adapter->serial_number, bottom->serial_number, 17);
+ EBCASC(adapter->serial_number, sizeof(adapter->serial_number));
+ }
+
+ ZFCP_LOG_INFO("The adapter %s reported the following characteristics:\n"
+ "WWNN 0x%016Lx, "
+ "WWPN 0x%016Lx, "
+ "S_ID 0x%08x,\n"
+ "adapter version 0x%x, "
+ "LIC version 0x%x, "
+ "FC link speed %d Gb/s\n",
+ zfcp_get_busid_by_adapter(adapter),
+ adapter->wwnn,
+ adapter->wwpn,
+ (unsigned int) adapter->s_id,
+ adapter->hydra_version,
+ adapter->fsf_lic_version,
+ adapter->fc_link_speed);
+ if (ZFCP_QTCB_VERSION < bottom->low_qtcb_version) {
+ ZFCP_LOG_NORMAL("error: the adapter %s "
+ "only supports newer control block "
+ "versions in comparison to this device "
+ "driver (try updated device driver)\n",
+ zfcp_get_busid_by_adapter(adapter));
+ debug_text_event(adapter->erp_dbf, 0, "low_qtcb_ver");
+ zfcp_erp_adapter_shutdown(adapter, 0);
+ return -EIO;
+ }
+ if (ZFCP_QTCB_VERSION > bottom->high_qtcb_version) {
+ ZFCP_LOG_NORMAL("error: the adapter %s "
+ "only supports older control block "
+ "versions than this device driver uses"
+ "(consider a microcode upgrade)\n",
+ zfcp_get_busid_by_adapter(adapter));
+ debug_text_event(adapter->erp_dbf, 0, "high_qtcb_ver");
+ zfcp_erp_adapter_shutdown(adapter, 0);
+ return -EIO;
+ }
+ return 0;
+}
+
+/*
+ * function: zfcp_fsf_exchange_config_data_handler
+ *
+ * purpose: is called for finished Exchange Configuration Data command
+ *
+ * returns:
+ */
+static int
+zfcp_fsf_exchange_config_data_handler(struct zfcp_fsf_req *fsf_req)
+{
+ struct fsf_qtcb_bottom_config *bottom;
+ struct zfcp_adapter *adapter = fsf_req->adapter;
+
+ if (fsf_req->status & ZFCP_STATUS_FSFREQ_ERROR)
+ return -EIO;
+
+ switch (fsf_req->qtcb->header.fsf_status) {
+
+ case FSF_GOOD:
+ ZFCP_LOG_FLAGS(2, "FSF_GOOD\n");
+
+ if (zfcp_fsf_exchange_config_evaluate(fsf_req, 1))
+ return -EIO;
+
+ switch (adapter->fc_topology) {
+ case FSF_TOPO_P2P:
+ ZFCP_LOG_FLAGS(1, "FSF_TOPO_P2P\n");
+ ZFCP_LOG_NORMAL("error: Point-to-point fibrechannel "
+ "configuration detected at adapter %s "
+ "unsupported, shutting down adapter\n",
+ zfcp_get_busid_by_adapter(adapter));
+ debug_text_event(fsf_req->adapter->erp_dbf, 0,
+ "top-p-to-p");
+ zfcp_erp_adapter_shutdown(adapter, 0);
+ return -EIO;
+ case FSF_TOPO_AL:
+ ZFCP_LOG_FLAGS(1, "FSF_TOPO_AL\n");
+ ZFCP_LOG_NORMAL("error: Arbitrated loop fibrechannel "
+ "topology detected at adapter %s "
+ "unsupported, shutting down adapter\n",
+ zfcp_get_busid_by_adapter(adapter));
+ debug_text_event(fsf_req->adapter->erp_dbf, 0,
+ "top-al");
+ zfcp_erp_adapter_shutdown(adapter, 0);
+ return -EIO;
+ case FSF_TOPO_FABRIC:
+ ZFCP_LOG_FLAGS(1, "FSF_TOPO_FABRIC\n");
+ ZFCP_LOG_INFO("Switched fabric fibrechannel "
+ "network detected at adapter %s.\n",
+ zfcp_get_busid_by_adapter(adapter));
+ break;
+ default:
+ ZFCP_LOG_NORMAL("bug: The fibrechannel topology "
+ "reported by the exchange "
+ "configuration command for "
+ "the adapter %s is not "
+ "of a type known to the zfcp "
+ "driver, shutting down adapter\n",
+ zfcp_get_busid_by_adapter(adapter));
+ debug_text_exception(fsf_req->adapter->erp_dbf, 0,
+ "unknown-topo");
+ zfcp_erp_adapter_shutdown(adapter, 0);
+ return -EIO;
+ }
+ bottom = &fsf_req->qtcb->bottom.config;
+ if (bottom->max_qtcb_size < sizeof(struct fsf_qtcb)) {
+ ZFCP_LOG_NORMAL("bug: Maximum QTCB size (%d bytes) "
+ "allowed by the adapter %s "
+ "is lower than the minimum "
+ "required by the driver (%ld bytes).\n",
+ bottom->max_qtcb_size,
+ zfcp_get_busid_by_adapter(adapter),
+ sizeof(struct fsf_qtcb));
+ debug_text_event(fsf_req->adapter->erp_dbf, 0,
+ "qtcb-size");
+ debug_event(fsf_req->adapter->erp_dbf, 0,
+ &bottom->max_qtcb_size, sizeof (u32));
+ zfcp_erp_adapter_shutdown(adapter, 0);
+ return -EIO;
+ }
+ atomic_set_mask(ZFCP_STATUS_ADAPTER_XCONFIG_OK,
+ &adapter->status);
+ break;
+ case FSF_EXCHANGE_CONFIG_DATA_INCOMPLETE:
+ debug_text_event(adapter->erp_dbf, 0, "xchg-inco");
+
+ if (zfcp_fsf_exchange_config_evaluate(fsf_req, 0))
+ return -EIO;
+
+ ZFCP_LOG_INFO("Local link to adapter %s is down\n",
+ zfcp_get_busid_by_adapter(adapter));
+ atomic_set_mask(ZFCP_STATUS_ADAPTER_XCONFIG_OK |
+ ZFCP_STATUS_ADAPTER_LINK_UNPLUGGED,
+ &adapter->status);
+ zfcp_erp_adapter_failed(adapter);
+ break;
+ default:
+ debug_text_event(fsf_req->adapter->erp_dbf, 0, "fsf-stat-ng");
+ debug_event(fsf_req->adapter->erp_dbf, 0,
+ &fsf_req->qtcb->header.fsf_status, sizeof (u32));
+ zfcp_erp_adapter_shutdown(adapter, 0);
+ return -EIO;
+ }
+ return 0;
+}
+
+/**
+ * zfcp_fsf_exchange_port_data - request information about local port
+ * @adapter: for which port data is requested
+ * @data: response to exchange port data request
+ */
+int
+zfcp_fsf_exchange_port_data(struct zfcp_adapter *adapter,
+ struct fsf_qtcb_bottom_port *data)
+{
+ volatile struct qdio_buffer_element *sbale;
+ int retval = 0;
+ unsigned long lock_flags;
+ struct zfcp_fsf_req *fsf_req;
+ struct timer_list *timer;
+
+ if(!(adapter->supported_features & FSF_FEATURE_HBAAPI_MANAGEMENT)){
+ ZFCP_LOG_INFO("error: exchange port data "
+ "command not supported by adapter %s\n",
+ zfcp_get_busid_by_adapter(adapter));
+ return -EOPNOTSUPP;
+ }
+
+ timer = kmalloc(sizeof(struct timer_list), GFP_KERNEL);
+ if (!timer)
+ return -ENOMEM;
+
+ /* setup new FSF request */
+ retval = zfcp_fsf_req_create(adapter, FSF_QTCB_EXCHANGE_PORT_DATA,
+ 0, 0, &lock_flags, &fsf_req);
+ if (retval < 0) {
+ ZFCP_LOG_INFO("error: Out of resources. Could not create an "
+ "exchange port data request for"
+ "the adapter %s.\n",
+ zfcp_get_busid_by_adapter(adapter));
+ write_unlock_irqrestore(&adapter->request_queue.queue_lock,
+ lock_flags);
+ goto out;
+ }
+
+ 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;
+ timer->expires = ZFCP_FSF_REQUEST_TIMEOUT;
+
+ retval = zfcp_fsf_req_send(fsf_req, timer);
+ if (retval) {
+ ZFCP_LOG_INFO("error: Could not send an exchange port data "
+ "command on the adapter %s\n",
+ zfcp_get_busid_by_adapter(adapter));
+ zfcp_fsf_req_free(fsf_req);
+ write_unlock_irqrestore(&adapter->request_queue.queue_lock,
+ lock_flags);
+ goto out;
+ }
+
+ ZFCP_LOG_DEBUG("Exchange Port Data request initiated (adapter %s)\n",
+ zfcp_get_busid_by_adapter(adapter));
+
+ write_unlock_irqrestore(&adapter->request_queue.queue_lock,
+ lock_flags);
+
+ wait_event(fsf_req->completion_wq,
+ fsf_req->status & ZFCP_STATUS_FSFREQ_COMPLETED);
+ del_timer_sync(timer);
+ zfcp_fsf_req_cleanup(fsf_req);
+ out:
+ kfree(timer);
+ return retval;
+}
+
+
+/**
+ * zfcp_fsf_exchange_port_data_handler - handler for exchange_port_data request
+ * @fsf_req: pointer to struct zfcp_fsf_req
+ */
+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;
+
+ if (fsf_req->status & ZFCP_STATUS_FSFREQ_ERROR)
+ return;
+
+ switch (fsf_req->qtcb->header.fsf_status) {
+ case FSF_GOOD:
+ ZFCP_LOG_FLAGS(2,"FSF_GOOD\n");
+ bottom = &fsf_req->qtcb->bottom.port;
+ memcpy(data, bottom, sizeof(*data));
+ break;
+
+ default:
+ debug_text_event(fsf_req->adapter->erp_dbf, 0, "xchg-port-ng");
+ debug_event(fsf_req->adapter->erp_dbf, 0,
+ &fsf_req->qtcb->header.fsf_status, sizeof(u32));
+ }
+}
+
+
+/*
+ * function: zfcp_fsf_open_port
+ *
+ * purpose:
+ *
+ * returns: address of initiated FSF request
+ * NULL - request could not be initiated
+ */
+int
+zfcp_fsf_open_port(struct zfcp_erp_action *erp_action)
+{
+ volatile struct qdio_buffer_element *sbale;
+ unsigned long lock_flags;
+ int retval = 0;
+
+ /* setup new FSF request */
+ retval = zfcp_fsf_req_create(erp_action->adapter,
+ FSF_QTCB_OPEN_PORT_WITH_DID,
+ ZFCP_WAIT_FOR_SBAL | ZFCP_REQ_AUTO_CLEANUP,
+ erp_action->adapter->pool.fsf_req_erp,
+ &lock_flags, &(erp_action->fsf_req));
+ if (retval < 0) {
+ ZFCP_LOG_INFO("error: Could not create open port request "
+ "for port 0x%016Lx on adapter %s.\n",
+ erp_action->port->wwpn,
+ zfcp_get_busid_by_adapter(erp_action->adapter));
+ goto out;
+ }
+
+ sbale = zfcp_qdio_sbale_req(erp_action->fsf_req,
+ erp_action->fsf_req->sbal_curr, 0);
+ sbale[0].flags |= SBAL_FLAGS0_TYPE_READ;
+ sbale[1].flags |= SBAL_FLAGS_LAST_ENTRY;
+
+ 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->erp_action = erp_action;
+
+ /* start QDIO request for this FSF request */
+ retval = zfcp_fsf_req_send(erp_action->fsf_req, &erp_action->timer);
+ if (retval) {
+ ZFCP_LOG_INFO("error: Could not send open port request for "
+ "port 0x%016Lx on adapter %s.\n",
+ erp_action->port->wwpn,
+ zfcp_get_busid_by_adapter(erp_action->adapter));
+ zfcp_fsf_req_free(erp_action->fsf_req);
+ erp_action->fsf_req = NULL;
+ goto out;
+ }
+
+ ZFCP_LOG_DEBUG("open port request initiated "
+ "(adapter %s, port 0x%016Lx)\n",
+ zfcp_get_busid_by_adapter(erp_action->adapter),
+ erp_action->port->wwpn);
+ out:
+ write_unlock_irqrestore(&erp_action->adapter->request_queue.queue_lock,
+ lock_flags);
+ return retval;
+}
+
+/*
+ * function: zfcp_fsf_open_port_handler
+ *
+ * purpose: is called for finished Open Port command
+ *
+ * returns:
+ */
+static int
+zfcp_fsf_open_port_handler(struct zfcp_fsf_req *fsf_req)
+{
+ int retval = -EINVAL;
+ struct zfcp_port *port;
+ struct fsf_plogi *plogi;
+ struct fsf_qtcb_header *header;
+ u16 subtable, rule, counter;
+
+ port = fsf_req->data.open_port.port;
+ header = &fsf_req->qtcb->header;
+
+ if (fsf_req->status & ZFCP_STATUS_FSFREQ_ERROR) {
+ /* don't change port status in our bookkeeping */
+ goto skip_fsfstatus;
+ }
+
+ /* evaluate FSF status in QTCB */
+ switch (header->fsf_status) {
+
+ case FSF_PORT_ALREADY_OPEN:
+ ZFCP_LOG_FLAGS(0, "FSF_PORT_ALREADY_OPEN\n");
+ ZFCP_LOG_NORMAL("bug: remote port 0x%016Lx on adapter %s "
+ "is already open.\n",
+ port->wwpn, zfcp_get_busid_by_port(port));
+ debug_text_exception(fsf_req->adapter->erp_dbf, 0,
+ "fsf_s_popen");
+ /*
+ * This is a bug, however operation should continue normally
+ * if it is simply ignored
+ */
+ break;
+
+ case FSF_ACCESS_DENIED:
+ ZFCP_LOG_FLAGS(2, "FSF_ACCESS_DENIED\n");
+ ZFCP_LOG_NORMAL("Access denied, cannot open port 0x%016Lx "
+ "on adapter %s\n",
+ port->wwpn, zfcp_get_busid_by_port(port));
+ for (counter = 0; counter < 2; counter++) {
+ subtable = header->fsf_status_qual.halfword[counter * 2];
+ rule = header->fsf_status_qual.halfword[counter * 2 + 1];
+ switch (subtable) {
+ case FSF_SQ_CFDC_SUBTABLE_OS:
+ case FSF_SQ_CFDC_SUBTABLE_PORT_WWPN:
+ case FSF_SQ_CFDC_SUBTABLE_PORT_DID:
+ case FSF_SQ_CFDC_SUBTABLE_LUN:
+ ZFCP_LOG_INFO("Access denied (%s rule %d)\n",
+ zfcp_act_subtable_type[subtable], rule);
+ break;
+ }
+ }
+ debug_text_event(fsf_req->adapter->erp_dbf, 1, "fsf_s_access");
+ zfcp_erp_port_access_denied(port);
+ fsf_req->status |= ZFCP_STATUS_FSFREQ_ERROR;
+ break;
+
+ case FSF_MAXIMUM_NUMBER_OF_PORTS_EXCEEDED:
+ ZFCP_LOG_FLAGS(1, "FSF_MAXIMUM_NUMBER_OF_PORTS_EXCEEDED\n");
+ ZFCP_LOG_INFO("error: The FSF adapter is out of resources. "
+ "The remote port 0x%016Lx on adapter %s "
+ "could not be opened. Disabling it.\n",
+ port->wwpn, zfcp_get_busid_by_port(port));
+ debug_text_event(fsf_req->adapter->erp_dbf, 1,
+ "fsf_s_max_ports");
+ zfcp_erp_port_failed(port);
+ fsf_req->status |= ZFCP_STATUS_FSFREQ_ERROR;
+ break;
+
+ case FSF_ADAPTER_STATUS_AVAILABLE:
+ ZFCP_LOG_FLAGS(2, "FSF_ADAPTER_STATUS_AVAILABLE\n");
+ switch (header->fsf_status_qual.word[0]) {
+ case FSF_SQ_INVOKE_LINK_TEST_PROCEDURE:
+ ZFCP_LOG_FLAGS(2,
+ "FSF_SQ_INVOKE_LINK_TEST_PROCEDURE\n");
+ debug_text_event(fsf_req->adapter->erp_dbf, 1,
+ "fsf_sq_ltest");
+ /* ERP strategy will escalate */
+ fsf_req->status |= ZFCP_STATUS_FSFREQ_ERROR;
+ break;
+ case FSF_SQ_ULP_DEPENDENT_ERP_REQUIRED:
+ /* ERP strategy will escalate */
+ debug_text_event(fsf_req->adapter->erp_dbf, 1,
+ "fsf_sq_ulp");
+ fsf_req->status |= ZFCP_STATUS_FSFREQ_ERROR;
+ break;
+ case FSF_SQ_NO_RETRY_POSSIBLE:
+ ZFCP_LOG_FLAGS(0, "FSF_SQ_NO_RETRY_POSSIBLE\n");
+ ZFCP_LOG_NORMAL("The remote port 0x%016Lx on "
+ "adapter %s could not be opened. "
+ "Disabling it.\n",
+ port->wwpn,
+ zfcp_get_busid_by_port(port));
+ debug_text_exception(fsf_req->adapter->erp_dbf, 0,
+ "fsf_sq_no_retry");
+ zfcp_erp_port_failed(port);
+ fsf_req->status |= ZFCP_STATUS_FSFREQ_ERROR;
+ break;
+ default:
+ ZFCP_LOG_NORMAL
+ ("bug: Wrong status qualifier 0x%x arrived.\n",
+ header->fsf_status_qual.word[0]);
+ debug_text_event(fsf_req->adapter->erp_dbf, 0,
+ "fsf_sq_inval:");
+ debug_exception(
+ fsf_req->adapter->erp_dbf, 0,
+ &header->fsf_status_qual.word[0],
+ sizeof (u32));
+ break;
+ }
+ break;
+
+ case FSF_GOOD:
+ ZFCP_LOG_FLAGS(3, "FSF_GOOD\n");
+ /* save port handle assigned by FSF */
+ port->handle = header->port_handle;
+ ZFCP_LOG_INFO("The remote port 0x%016Lx via adapter %s "
+ "was opened, it's port handle is 0x%x\n",
+ port->wwpn, zfcp_get_busid_by_port(port),
+ port->handle);
+ /* mark port as open */
+ atomic_set_mask(ZFCP_STATUS_COMMON_OPEN |
+ ZFCP_STATUS_PORT_PHYS_OPEN, &port->status);
+ retval = 0;
+ /* check whether D_ID has changed during open */
+ /*
+ * FIXME: This check is not airtight, as the FCP channel does
+ * not monitor closures of target port connections caused on
+ * the remote side. Thus, they might miss out on invalidating
+ * locally cached WWPNs (and other N_Port parameters) of gone
+ * target ports. So, our heroic attempt to make things safe
+ * could be undermined by 'open port' response data tagged with
+ * obsolete WWPNs. Another reason to monitor potential
+ * connection closures ourself at least (by interpreting
+ * incoming ELS' and unsolicited status). It just crosses my
+ * mind that one should be able to cross-check by means of
+ * another GID_PN straight after a port has been opened.
+ * Alternately, an ADISC/PDISC ELS should suffice, as well.
+ */
+ plogi = (struct fsf_plogi *) fsf_req->qtcb->bottom.support.els;
+ if (!atomic_test_mask(ZFCP_STATUS_PORT_NO_WWPN, &port->status))
+ {
+ if (fsf_req->qtcb->bottom.support.els1_length <
+ ((((unsigned long) &plogi->serv_param.wwpn) -
+ ((unsigned long) plogi)) + sizeof (u64))) {
+ ZFCP_LOG_INFO(
+ "warning: insufficient length of "
+ "PLOGI payload (%i)\n",
+ fsf_req->qtcb->bottom.support.els1_length);
+ debug_text_event(fsf_req->adapter->erp_dbf, 0,
+ "fsf_s_short_plogi:");
+ /* skip sanity check and assume wwpn is ok */
+ } else {
+ if (plogi->serv_param.wwpn != port->wwpn) {
+ ZFCP_LOG_INFO("warning: d_id of port "
+ "0x%016Lx changed during "
+ "open\n", port->wwpn);
+ debug_text_event(
+ fsf_req->adapter->erp_dbf, 0,
+ "fsf_s_did_change:");
+ atomic_clear_mask(
+ ZFCP_STATUS_PORT_DID_DID,
+ &port->status);
+ } else
+ port->wwnn = plogi->serv_param.wwnn;
+ }
+ }
+ break;
+
+ case FSF_UNKNOWN_OP_SUBTYPE:
+ /* should never occure, subtype not set in zfcp_fsf_open_port */
+ ZFCP_LOG_FLAGS(2, "FSF_UNKNOWN_OP_SUBTYPE\n");
+ ZFCP_LOG_INFO("unknown operation subtype (adapter: %s, "
+ "op_subtype=0x%x)\n",
+ zfcp_get_busid_by_port(port),
+ fsf_req->qtcb->bottom.support.operation_subtype);
+ fsf_req->status |= ZFCP_STATUS_FSFREQ_ERROR;
+ break;
+
+ default:
+ ZFCP_LOG_NORMAL("bug: An unknown FSF Status was presented "
+ "(debug info 0x%x)\n",
+ header->fsf_status);
+ debug_text_event(fsf_req->adapter->erp_dbf, 0, "fsf_s_inval:");
+ debug_exception(fsf_req->adapter->erp_dbf, 0,
+ &header->fsf_status, sizeof (u32));
+ break;
+ }
+
+ skip_fsfstatus:
+ atomic_clear_mask(ZFCP_STATUS_COMMON_OPENING, &port->status);
+ return retval;
+}
+
+/*
+ * function: zfcp_fsf_close_port
+ *
+ * purpose: submit FSF command "close port"
+ *
+ * returns: address of initiated FSF request
+ * NULL - request could not be initiated
+ */
+int
+zfcp_fsf_close_port(struct zfcp_erp_action *erp_action)
+{
+ volatile struct qdio_buffer_element *sbale;
+ unsigned long lock_flags;
+ int retval = 0;
+
+ /* setup new FSF request */
+ retval = zfcp_fsf_req_create(erp_action->adapter,
+ FSF_QTCB_CLOSE_PORT,
+ ZFCP_WAIT_FOR_SBAL | ZFCP_REQ_AUTO_CLEANUP,
+ erp_action->adapter->pool.fsf_req_erp,
+ &lock_flags, &(erp_action->fsf_req));
+ if (retval < 0) {
+ ZFCP_LOG_INFO("error: Could not create a close port request "
+ "for port 0x%016Lx on adapter %s.\n",
+ erp_action->port->wwpn,
+ zfcp_get_busid_by_adapter(erp_action->adapter));
+ goto out;
+ }
+
+ sbale = zfcp_qdio_sbale_req(erp_action->fsf_req,
+ erp_action->fsf_req->sbal_curr, 0);
+ sbale[0].flags |= SBAL_FLAGS0_TYPE_READ;
+ 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->erp_action = erp_action;
+ erp_action->fsf_req->qtcb->header.port_handle =
+ erp_action->port->handle;
+
+ /* start QDIO request for this FSF request */
+ retval = zfcp_fsf_req_send(erp_action->fsf_req, &erp_action->timer);
+ if (retval) {
+ ZFCP_LOG_INFO("error: Could not send a close port request for "
+ "port 0x%016Lx on adapter %s.\n",
+ erp_action->port->wwpn,
+ zfcp_get_busid_by_adapter(erp_action->adapter));
+ zfcp_fsf_req_free(erp_action->fsf_req);
+ erp_action->fsf_req = NULL;
+ goto out;
+ }
+
+ ZFCP_LOG_TRACE("close port request initiated "
+ "(adapter %s, port 0x%016Lx)\n",
+ zfcp_get_busid_by_adapter(erp_action->adapter),
+ erp_action->port->wwpn);
+ out:
+ write_unlock_irqrestore(&erp_action->adapter->request_queue.queue_lock,
+ lock_flags);
+ return retval;
+}
+
+/*
+ * function: zfcp_fsf_close_port_handler
+ *
+ * purpose: is called for finished Close Port FSF command
+ *
+ * returns:
+ */
+static int
+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;
+
+ if (fsf_req->status & ZFCP_STATUS_FSFREQ_ERROR) {
+ /* don't change port status in our bookkeeping */
+ goto skip_fsfstatus;
+ }
+
+ /* evaluate FSF status in QTCB */
+ switch (fsf_req->qtcb->header.fsf_status) {
+
+ case FSF_PORT_HANDLE_NOT_VALID:
+ ZFCP_LOG_FLAGS(1, "FSF_PORT_HANDLE_NOT_VALID\n");
+ ZFCP_LOG_INFO("Temporary port identifier 0x%x for port "
+ "0x%016Lx on adapter %s invalid. This may happen "
+ "occasionally.\n", port->handle,
+ port->wwpn, zfcp_get_busid_by_port(port));
+ ZFCP_LOG_DEBUG("status qualifier:\n");
+ ZFCP_HEX_DUMP(ZFCP_LOG_LEVEL_DEBUG,
+ (char *) &fsf_req->qtcb->header.fsf_status_qual,
+ sizeof (union fsf_status_qual));
+ debug_text_event(fsf_req->adapter->erp_dbf, 1,
+ "fsf_s_phand_nv");
+ zfcp_erp_adapter_reopen(port->adapter, 0);
+ fsf_req->status |= ZFCP_STATUS_FSFREQ_ERROR;
+ break;
+
+ case FSF_ADAPTER_STATUS_AVAILABLE:
+ ZFCP_LOG_FLAGS(2, "FSF_ADAPTER_STATUS_AVAILABLE\n");
+ /* Note: FSF has actually closed the port in this case.
+ * The status code is just daft. Fingers crossed for a change
+ */
+ retval = 0;
+ break;
+
+ case FSF_GOOD:
+ ZFCP_LOG_FLAGS(3, "FSF_GOOD\n");
+ ZFCP_LOG_TRACE("remote port 0x016%Lx on adapter %s closed, "
+ "port handle 0x%x\n", port->wwpn,
+ zfcp_get_busid_by_port(port), port->handle);
+ zfcp_erp_modify_port_status(port,
+ ZFCP_STATUS_COMMON_OPEN,
+ ZFCP_CLEAR);
+ retval = 0;
+ break;
+
+ default:
+ ZFCP_LOG_NORMAL("bug: An unknown FSF Status was presented "
+ "(debug info 0x%x)\n",
+ fsf_req->qtcb->header.fsf_status);
+ debug_text_event(fsf_req->adapter->erp_dbf, 0, "fsf_s_inval:");
+ debug_exception(fsf_req->adapter->erp_dbf, 0,
+ &fsf_req->qtcb->header.fsf_status,
+ sizeof (u32));
+ break;
+ }
+
+ skip_fsfstatus:
+ atomic_clear_mask(ZFCP_STATUS_COMMON_CLOSING, &port->status);
+ return retval;
+}
+
+/*
+ * function: zfcp_fsf_close_physical_port
+ *
+ * purpose: submit FSF command "close physical port"
+ *
+ * returns: address of initiated FSF request
+ * NULL - request could not be initiated
+ */
+int
+zfcp_fsf_close_physical_port(struct zfcp_erp_action *erp_action)
+{
+ int retval = 0;
+ unsigned long lock_flags;
+ volatile struct qdio_buffer_element *sbale;
+
+ /* setup new FSF request */
+ retval = zfcp_fsf_req_create(erp_action->adapter,
+ FSF_QTCB_CLOSE_PHYSICAL_PORT,
+ ZFCP_WAIT_FOR_SBAL | ZFCP_REQ_AUTO_CLEANUP,
+ erp_action->adapter->pool.fsf_req_erp,
+ &lock_flags, &erp_action->fsf_req);
+ if (retval < 0) {
+ ZFCP_LOG_INFO("error: Could not create close physical port "
+ "request (adapter %s, port 0x%016Lx)\n",
+ zfcp_get_busid_by_adapter(erp_action->adapter),
+ erp_action->port->wwpn);
+
+ goto out;
+ }
+
+ sbale = zfcp_qdio_sbale_req(erp_action->fsf_req,
+ erp_action->fsf_req->sbal_curr, 0);
+ sbale[0].flags |= SBAL_FLAGS0_TYPE_READ;
+ sbale[1].flags |= SBAL_FLAGS_LAST_ENTRY;
+
+ /* mark port as being closed */
+ 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;
+ /* port to be closeed */
+ erp_action->fsf_req->qtcb->header.port_handle =
+ erp_action->port->handle;
+ erp_action->fsf_req->erp_action = erp_action;
+
+ /* start QDIO request for this FSF request */
+ retval = zfcp_fsf_req_send(erp_action->fsf_req, &erp_action->timer);
+ if (retval) {
+ ZFCP_LOG_INFO("error: Could not send close physical port "
+ "request (adapter %s, port 0x%016Lx)\n",
+ zfcp_get_busid_by_adapter(erp_action->adapter),
+ erp_action->port->wwpn);
+ zfcp_fsf_req_free(erp_action->fsf_req);
+ erp_action->fsf_req = NULL;
+ goto out;
+ }
+
+ ZFCP_LOG_TRACE("close physical port request initiated "
+ "(adapter %s, port 0x%016Lx)\n",
+ zfcp_get_busid_by_adapter(erp_action->adapter),
+ erp_action->port->wwpn);
+ out:
+ write_unlock_irqrestore(&erp_action->adapter->request_queue.queue_lock,
+ lock_flags);
+ return retval;
+}
+
+/*
+ * function: zfcp_fsf_close_physical_port_handler
+ *
+ * purpose: is called for finished Close Physical Port FSF command
+ *
+ * returns:
+ */
+static int
+zfcp_fsf_close_physical_port_handler(struct zfcp_fsf_req *fsf_req)
+{
+ int retval = -EINVAL;
+ struct zfcp_port *port;
+ struct zfcp_unit *unit;
+ struct fsf_qtcb_header *header;
+ u16 subtable, rule, counter;
+
+ port = fsf_req->data.close_physical_port.port;
+ header = &fsf_req->qtcb->header;
+
+ if (fsf_req->status & ZFCP_STATUS_FSFREQ_ERROR) {
+ /* don't change port status in our bookkeeping */
+ goto skip_fsfstatus;
+ }
+
+ /* evaluate FSF status in QTCB */
+ switch (header->fsf_status) {
+
+ case FSF_PORT_HANDLE_NOT_VALID:
+ ZFCP_LOG_FLAGS(1, "FSF_PORT_HANDLE_NOT_VALID\n");
+ ZFCP_LOG_INFO("Temporary port identifier 0x%x invalid"
+ "(adapter %s, port 0x%016Lx). "
+ "This may happen occasionally.\n",
+ port->handle,
+ zfcp_get_busid_by_port(port),
+ port->wwpn);
+ ZFCP_LOG_DEBUG("status qualifier:\n");
+ ZFCP_HEX_DUMP(ZFCP_LOG_LEVEL_DEBUG,
+ (char *) &header->fsf_status_qual,
+ sizeof (union fsf_status_qual));
+ debug_text_event(fsf_req->adapter->erp_dbf, 1,
+ "fsf_s_phand_nv");
+ zfcp_erp_adapter_reopen(port->adapter, 0);
+ fsf_req->status |= ZFCP_STATUS_FSFREQ_ERROR;
+ break;
+
+ case FSF_ACCESS_DENIED:
+ ZFCP_LOG_FLAGS(2, "FSF_ACCESS_DENIED\n");
+ ZFCP_LOG_NORMAL("Access denied, cannot close "
+ "physical port 0x%016Lx on adapter %s\n",
+ port->wwpn, zfcp_get_busid_by_port(port));
+ for (counter = 0; counter < 2; counter++) {
+ subtable = header->fsf_status_qual.halfword[counter * 2];
+ rule = header->fsf_status_qual.halfword[counter * 2 + 1];
+ switch (subtable) {
+ case FSF_SQ_CFDC_SUBTABLE_OS:
+ case FSF_SQ_CFDC_SUBTABLE_PORT_WWPN:
+ case FSF_SQ_CFDC_SUBTABLE_PORT_DID:
+ case FSF_SQ_CFDC_SUBTABLE_LUN:
+ ZFCP_LOG_INFO("Access denied (%s rule %d)\n",
+ zfcp_act_subtable_type[subtable], rule);
+ break;
+ }
+ }
+ debug_text_event(fsf_req->adapter->erp_dbf, 1, "fsf_s_access");
+ zfcp_erp_port_access_denied(port);
+ fsf_req->status |= ZFCP_STATUS_FSFREQ_ERROR;
+ break;
+
+ case FSF_PORT_BOXED:
+ ZFCP_LOG_FLAGS(2, "FSF_PORT_BOXED\n");
+ ZFCP_LOG_DEBUG("The remote port 0x%016Lx on adapter "
+ "%s needs to be reopened but it was attempted "
+ "to close it physically.\n",
+ port->wwpn,
+ zfcp_get_busid_by_port(port));
+ debug_text_event(fsf_req->adapter->erp_dbf, 1, "fsf_s_pboxed");
+ zfcp_erp_port_reopen(port, 0);
+ fsf_req->status |= ZFCP_STATUS_FSFREQ_ERROR |
+ ZFCP_STATUS_FSFREQ_RETRY;
+ break;
+
+ case FSF_ADAPTER_STATUS_AVAILABLE:
+ ZFCP_LOG_FLAGS(2, "FSF_ADAPTER_STATUS_AVAILABLE\n");
+ switch (header->fsf_status_qual.word[0]) {
+ case FSF_SQ_INVOKE_LINK_TEST_PROCEDURE:
+ ZFCP_LOG_FLAGS(2,
+ "FSF_SQ_INVOKE_LINK_TEST_PROCEDURE\n");
+ debug_text_event(fsf_req->adapter->erp_dbf, 1,
+ "fsf_sq_ltest");
+ /* This will now be escalated by ERP */
+ fsf_req->status |= ZFCP_STATUS_FSFREQ_ERROR;
+ break;
+ case FSF_SQ_ULP_DEPENDENT_ERP_REQUIRED:
+ ZFCP_LOG_FLAGS(2,
+ "FSF_SQ_ULP_DEPENDENT_ERP_REQUIRED\n");
+ /* ERP strategy will escalate */
+ debug_text_event(fsf_req->adapter->erp_dbf, 1,
+ "fsf_sq_ulp");
+ fsf_req->status |= ZFCP_STATUS_FSFREQ_ERROR;
+ break;
+ default:
+ ZFCP_LOG_NORMAL
+ ("bug: Wrong status qualifier 0x%x arrived.\n",
+ header->fsf_status_qual.word[0]);
+ debug_text_event(fsf_req->adapter->erp_dbf, 0,
+ "fsf_sq_inval:");
+ debug_exception(
+ fsf_req->adapter->erp_dbf, 0,
+ &header->fsf_status_qual.word[0], sizeof (u32));
+ break;
+ }
+ break;
+
+ case FSF_GOOD:
+ ZFCP_LOG_FLAGS(3, "FSF_GOOD\n");
+ ZFCP_LOG_DEBUG("Remote port 0x%016Lx via adapter %s "
+ "physically closed, port handle 0x%x\n",
+ port->wwpn,
+ zfcp_get_busid_by_port(port), port->handle);
+ /* can't use generic zfcp_erp_modify_port_status because
+ * ZFCP_STATUS_COMMON_OPEN must not be reset for the port
+ */
+ atomic_clear_mask(ZFCP_STATUS_PORT_PHYS_OPEN, &port->status);
+ list_for_each_entry(unit, &port->unit_list_head, list)
+ atomic_clear_mask(ZFCP_STATUS_COMMON_OPEN, &unit->status);
+ retval = 0;
+ break;
+
+ default:
+ ZFCP_LOG_NORMAL("bug: An unknown FSF Status was presented "
+ "(debug info 0x%x)\n",
+ header->fsf_status);
+ debug_text_event(fsf_req->adapter->erp_dbf, 0, "fsf_s_inval:");
+ debug_exception(fsf_req->adapter->erp_dbf, 0,
+ &header->fsf_status, sizeof (u32));
+ break;
+ }
+
+ skip_fsfstatus:
+ atomic_clear_mask(ZFCP_STATUS_PORT_PHYS_CLOSING, &port->status);
+ return retval;
+}
+
+/*
+ * function: zfcp_fsf_open_unit
+ *
+ * purpose:
+ *
+ * returns:
+ *
+ * assumptions: This routine does not check whether the associated
+ * remote port has already been opened. This should be
+ * done by calling routines. Otherwise some status
+ * may be presented by FSF
+ */
+int
+zfcp_fsf_open_unit(struct zfcp_erp_action *erp_action)
+{
+ volatile struct qdio_buffer_element *sbale;
+ unsigned long lock_flags;
+ int retval = 0;
+
+ /* setup new FSF request */
+ retval = zfcp_fsf_req_create(erp_action->adapter,
+ FSF_QTCB_OPEN_LUN,
+ ZFCP_WAIT_FOR_SBAL | ZFCP_REQ_AUTO_CLEANUP,
+ erp_action->adapter->pool.fsf_req_erp,
+ &lock_flags, &(erp_action->fsf_req));
+ if (retval < 0) {
+ ZFCP_LOG_INFO("error: Could not create open unit request for "
+ "unit 0x%016Lx on port 0x%016Lx on adapter %s.\n",
+ erp_action->unit->fcp_lun,
+ erp_action->unit->port->wwpn,
+ zfcp_get_busid_by_adapter(erp_action->adapter));
+ goto out;
+ }
+
+ sbale = zfcp_qdio_sbale_req(erp_action->fsf_req,
+ erp_action->fsf_req->sbal_curr, 0);
+ sbale[0].flags |= SBAL_FLAGS0_TYPE_READ;
+ sbale[1].flags |= SBAL_FLAGS_LAST_ENTRY;
+
+ erp_action->fsf_req->qtcb->header.port_handle =
+ erp_action->port->handle;
+ erp_action->fsf_req->qtcb->bottom.support.fcp_lun =
+ erp_action->unit->fcp_lun;
+ 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->erp_action = erp_action;
+
+ /* start QDIO request for this FSF request */
+ retval = zfcp_fsf_req_send(erp_action->fsf_req, &erp_action->timer);
+ if (retval) {
+ ZFCP_LOG_INFO("error: Could not send an open unit request "
+ "on the adapter %s, port 0x%016Lx for "
+ "unit 0x%016Lx\n",
+ zfcp_get_busid_by_adapter(erp_action->adapter),
+ erp_action->port->wwpn,
+ erp_action->unit->fcp_lun);
+ zfcp_fsf_req_free(erp_action->fsf_req);
+ erp_action->fsf_req = NULL;
+ goto out;
+ }
+
+ ZFCP_LOG_TRACE("Open LUN request initiated (adapter %s, "
+ "port 0x%016Lx, unit 0x%016Lx)\n",
+ zfcp_get_busid_by_adapter(erp_action->adapter),
+ erp_action->port->wwpn, erp_action->unit->fcp_lun);
+ out:
+ write_unlock_irqrestore(&erp_action->adapter->request_queue.queue_lock,
+ lock_flags);
+ return retval;
+}
+
+/*
+ * function: zfcp_fsf_open_unit_handler
+ *
+ * purpose: is called for finished Open LUN command
+ *
+ * returns:
+ */
+static int
+zfcp_fsf_open_unit_handler(struct zfcp_fsf_req *fsf_req)
+{
+ int retval = -EINVAL;
+ struct zfcp_adapter *adapter;
+ struct zfcp_unit *unit;
+ struct fsf_qtcb_header *header;
+ struct fsf_qtcb_bottom_support *bottom;
+ struct fsf_queue_designator *queue_designator;
+ u16 subtable, rule, counter;
+ u32 allowed, exclusive, readwrite;
+
+ unit = fsf_req->data.open_unit.unit;
+
+ if (fsf_req->status & ZFCP_STATUS_FSFREQ_ERROR) {
+ /* don't change unit status in our bookkeeping */
+ goto skip_fsfstatus;
+ }
+
+ adapter = fsf_req->adapter;
+ header = &fsf_req->qtcb->header;
+ bottom = &fsf_req->qtcb->bottom.support;
+ queue_designator = &header->fsf_status_qual.fsf_queue_designator;
+
+ allowed = bottom->lun_access_info & FSF_UNIT_ACCESS_OPEN_LUN_ALLOWED;
+ exclusive = bottom->lun_access_info & FSF_UNIT_ACCESS_EXCLUSIVE;
+ readwrite = bottom->lun_access_info & FSF_UNIT_ACCESS_OUTBOUND_TRANSFER;
+
+ atomic_clear_mask(ZFCP_STATUS_COMMON_ACCESS_DENIED |
+ ZFCP_STATUS_UNIT_SHARED |
+ ZFCP_STATUS_UNIT_READONLY,
+ &unit->status);
+
+ /* evaluate FSF status in QTCB */
+ switch (header->fsf_status) {
+
+ case FSF_PORT_HANDLE_NOT_VALID:
+ ZFCP_LOG_FLAGS(1, "FSF_PORT_HANDLE_NOT_VALID\n");
+ ZFCP_LOG_INFO("Temporary port identifier 0x%x "
+ "for port 0x%016Lx on adapter %s invalid "
+ "This may happen occasionally\n",
+ unit->port->handle,
+ unit->port->wwpn, zfcp_get_busid_by_unit(unit));
+ ZFCP_LOG_DEBUG("status qualifier:\n");
+ ZFCP_HEX_DUMP(ZFCP_LOG_LEVEL_DEBUG,
+ (char *) &header->fsf_status_qual,
+ sizeof (union fsf_status_qual));
+ debug_text_event(adapter->erp_dbf, 1, "fsf_s_ph_nv");
+ zfcp_erp_adapter_reopen(unit->port->adapter, 0);
+ fsf_req->status |= ZFCP_STATUS_FSFREQ_ERROR;
+ break;
+
+ case FSF_LUN_ALREADY_OPEN:
+ ZFCP_LOG_FLAGS(0, "FSF_LUN_ALREADY_OPEN\n");
+ ZFCP_LOG_NORMAL("bug: Attempted to open unit 0x%016Lx on "
+ "remote port 0x%016Lx on adapter %s twice.\n",
+ unit->fcp_lun,
+ unit->port->wwpn, zfcp_get_busid_by_unit(unit));
+ debug_text_exception(adapter->erp_dbf, 0,
+ "fsf_s_uopen");
+ fsf_req->status |= ZFCP_STATUS_FSFREQ_ERROR;
+ break;
+
+ case FSF_ACCESS_DENIED:
+ ZFCP_LOG_FLAGS(2, "FSF_ACCESS_DENIED\n");
+ ZFCP_LOG_NORMAL("Access denied, cannot open unit 0x%016Lx on "
+ "remote port 0x%016Lx on adapter %s\n",
+ unit->fcp_lun, unit->port->wwpn,
+ zfcp_get_busid_by_unit(unit));
+ for (counter = 0; counter < 2; counter++) {
+ subtable = header->fsf_status_qual.halfword[counter * 2];
+ rule = header->fsf_status_qual.halfword[counter * 2 + 1];
+ switch (subtable) {
+ case FSF_SQ_CFDC_SUBTABLE_OS:
+ case FSF_SQ_CFDC_SUBTABLE_PORT_WWPN:
+ case FSF_SQ_CFDC_SUBTABLE_PORT_DID:
+ case FSF_SQ_CFDC_SUBTABLE_LUN:
+ ZFCP_LOG_INFO("Access denied (%s rule %d)\n",
+ zfcp_act_subtable_type[subtable], rule);
+ break;
+ }
+ }
+ debug_text_event(adapter->erp_dbf, 1, "fsf_s_access");
+ zfcp_erp_unit_access_denied(unit);
+ atomic_clear_mask(ZFCP_STATUS_UNIT_SHARED, &unit->status);
+ atomic_clear_mask(ZFCP_STATUS_UNIT_READONLY, &unit->status);
+ fsf_req->status |= ZFCP_STATUS_FSFREQ_ERROR;
+ break;
+
+ case FSF_PORT_BOXED:
+ ZFCP_LOG_FLAGS(2, "FSF_PORT_BOXED\n");
+ ZFCP_LOG_DEBUG("The remote port 0x%016Lx on adapter %s "
+ "needs to be reopened\n",
+ unit->port->wwpn, zfcp_get_busid_by_unit(unit));
+ debug_text_event(adapter->erp_dbf, 2, "fsf_s_pboxed");
+ zfcp_erp_port_reopen(unit->port, 0);
+ fsf_req->status |= ZFCP_STATUS_FSFREQ_ERROR |
+ ZFCP_STATUS_FSFREQ_RETRY;
+ break;
+
+ case FSF_LUN_SHARING_VIOLATION:
+ ZFCP_LOG_FLAGS(2, "FSF_LUN_SHARING_VIOLATION\n");
+ if (header->fsf_status_qual.word[0] != 0) {
+ ZFCP_LOG_NORMAL("FCP-LUN 0x%Lx at the remote port "
+ "with WWPN 0x%Lx "
+ "connected to the adapter %s "
+ "is already in use in LPAR%d, CSS%d\n",
+ unit->fcp_lun,
+ unit->port->wwpn,
+ zfcp_get_busid_by_unit(unit),
+ queue_designator->hla,
+ queue_designator->cssid);
+ } else {
+ subtable = header->fsf_status_qual.halfword[4];
+ rule = header->fsf_status_qual.halfword[5];
+ switch (subtable) {
+ case FSF_SQ_CFDC_SUBTABLE_OS:
+ case FSF_SQ_CFDC_SUBTABLE_PORT_WWPN:
+ case FSF_SQ_CFDC_SUBTABLE_PORT_DID:
+ case FSF_SQ_CFDC_SUBTABLE_LUN:
+ ZFCP_LOG_NORMAL("Access to FCP-LUN 0x%Lx at the "
+ "remote port with WWPN 0x%Lx "
+ "connected to the adapter %s "
+ "is denied (%s rule %d)\n",
+ unit->fcp_lun,
+ unit->port->wwpn,
+ zfcp_get_busid_by_unit(unit),
+ zfcp_act_subtable_type[subtable],
+ rule);
+ break;
+ }
+ }
+ ZFCP_LOG_DEBUG("status qualifier:\n");
+ ZFCP_HEX_DUMP(ZFCP_LOG_LEVEL_DEBUG,
+ (char *) &header->fsf_status_qual,
+ sizeof (union fsf_status_qual));
+ debug_text_event(adapter->erp_dbf, 2,
+ "fsf_s_l_sh_vio");
+ zfcp_erp_unit_access_denied(unit);
+ atomic_clear_mask(ZFCP_STATUS_UNIT_SHARED, &unit->status);
+ atomic_clear_mask(ZFCP_STATUS_UNIT_READONLY, &unit->status);
+ fsf_req->status |= ZFCP_STATUS_FSFREQ_ERROR;
+ break;
+
+ case FSF_MAXIMUM_NUMBER_OF_LUNS_EXCEEDED:
+ ZFCP_LOG_FLAGS(1, "FSF_MAXIMUM_NUMBER_OF_LUNS_EXCEEDED\n");
+ ZFCP_LOG_INFO("error: The adapter ran out of resources. "
+ "There is no handle (temporary port identifier) "
+ "available for unit 0x%016Lx on port 0x%016Lx "
+ "on adapter %s\n",
+ unit->fcp_lun,
+ unit->port->wwpn,
+ zfcp_get_busid_by_unit(unit));
+ debug_text_event(adapter->erp_dbf, 1,
+ "fsf_s_max_units");
+ zfcp_erp_unit_failed(unit);
+ fsf_req->status |= ZFCP_STATUS_FSFREQ_ERROR;
+ break;
+
+ case FSF_ADAPTER_STATUS_AVAILABLE:
+ ZFCP_LOG_FLAGS(2, "FSF_ADAPTER_STATUS_AVAILABLE\n");
+ switch (header->fsf_status_qual.word[0]) {
+ case FSF_SQ_INVOKE_LINK_TEST_PROCEDURE:
+ ZFCP_LOG_FLAGS(2,
+ "FSF_SQ_INVOKE_LINK_TEST_PROCEDURE\n");
+ /* Re-establish link to port */
+ debug_text_event(adapter->erp_dbf, 1,
+ "fsf_sq_ltest");
+ zfcp_erp_port_reopen(unit->port, 0);
+ fsf_req->status |= ZFCP_STATUS_FSFREQ_ERROR;
+ break;
+ case FSF_SQ_ULP_DEPENDENT_ERP_REQUIRED:
+ ZFCP_LOG_FLAGS(2,
+ "FSF_SQ_ULP_DEPENDENT_ERP_REQUIRED\n");
+ /* ERP strategy will escalate */
+ debug_text_event(adapter->erp_dbf, 1,
+ "fsf_sq_ulp");
+ fsf_req->status |= ZFCP_STATUS_FSFREQ_ERROR;
+ break;
+ default:
+ ZFCP_LOG_NORMAL
+ ("bug: Wrong status qualifier 0x%x arrived.\n",
+ header->fsf_status_qual.word[0]);
+ debug_text_event(adapter->erp_dbf, 0,
+ "fsf_sq_inval:");
+ debug_exception(adapter->erp_dbf, 0,
+ &header->fsf_status_qual.word[0],
+ sizeof (u32));
+ }
+ break;
+
+ case FSF_INVALID_COMMAND_OPTION:
+ ZFCP_LOG_FLAGS(2, "FSF_INVALID_COMMAND_OPTION\n");
+ ZFCP_LOG_NORMAL(
+ "Invalid option 0x%x has been specified "
+ "in QTCB bottom sent to the adapter %s\n",
+ bottom->option,
+ zfcp_get_busid_by_adapter(adapter));
+ fsf_req->status |= ZFCP_STATUS_FSFREQ_ERROR;
+ retval = -EINVAL;
+ break;
+
+ case FSF_GOOD:
+ ZFCP_LOG_FLAGS(3, "FSF_GOOD\n");
+ /* save LUN handle assigned by FSF */
+ unit->handle = header->lun_handle;
+ ZFCP_LOG_TRACE("unit 0x%016Lx on remote port 0x%016Lx on "
+ "adapter %s opened, port handle 0x%x\n",
+ unit->fcp_lun,
+ unit->port->wwpn,
+ zfcp_get_busid_by_unit(unit),
+ unit->handle);
+ /* mark unit as open */
+ atomic_set_mask(ZFCP_STATUS_COMMON_OPEN, &unit->status);
+
+ if (adapter->supported_features & FSF_FEATURE_LUN_SHARING){
+ if (!exclusive)
+ atomic_set_mask(ZFCP_STATUS_UNIT_SHARED,
+ &unit->status);
+
+ if (!readwrite) {
+ atomic_set_mask(ZFCP_STATUS_UNIT_READONLY,
+ &unit->status);
+ ZFCP_LOG_NORMAL("read-only access for unit "
+ "(adapter %s, wwpn=0x%016Lx, "
+ "fcp_lun=0x%016Lx)\n",
+ zfcp_get_busid_by_unit(unit),
+ unit->port->wwpn,
+ unit->fcp_lun);
+ }
+
+ if (exclusive && !readwrite) {
+ ZFCP_LOG_NORMAL("exclusive access of read-only "
+ "unit not supported\n");
+ zfcp_erp_unit_failed(unit);
+ fsf_req->status |= ZFCP_STATUS_FSFREQ_ERROR;
+ zfcp_erp_unit_shutdown(unit, 0);
+ } else if (!exclusive && readwrite) {
+ ZFCP_LOG_NORMAL("shared access of read-write "
+ "unit not supported\n");
+ zfcp_erp_unit_failed(unit);
+ fsf_req->status |= ZFCP_STATUS_FSFREQ_ERROR;
+ zfcp_erp_unit_shutdown(unit, 0);
+ }
+ }
+
+ retval = 0;
+ break;
+
+ default:
+ ZFCP_LOG_NORMAL("bug: An unknown FSF Status was presented "
+ "(debug info 0x%x)\n",
+ header->fsf_status);
+ debug_text_event(adapter->erp_dbf, 0, "fsf_s_inval:");
+ debug_exception(adapter->erp_dbf, 0,
+ &header->fsf_status, sizeof (u32));
+ break;
+ }
+
+ skip_fsfstatus:
+ atomic_clear_mask(ZFCP_STATUS_COMMON_OPENING, &unit->status);
+ return retval;
+}
+
+/*
+ * function: zfcp_fsf_close_unit
+ *
+ * purpose:
+ *
+ * returns: address of fsf_req - request successfully initiated
+ * NULL -
+ *
+ * assumptions: This routine does not check whether the associated
+ * remote port/lun has already been opened. This should be
+ * done by calling routines. Otherwise some status
+ * may be presented by FSF
+ */
+int
+zfcp_fsf_close_unit(struct zfcp_erp_action *erp_action)
+{
+ volatile struct qdio_buffer_element *sbale;
+ unsigned long lock_flags;
+ int retval = 0;
+
+ /* setup new FSF request */
+ retval = zfcp_fsf_req_create(erp_action->adapter,
+ FSF_QTCB_CLOSE_LUN,
+ ZFCP_WAIT_FOR_SBAL | ZFCP_REQ_AUTO_CLEANUP,
+ erp_action->adapter->pool.fsf_req_erp,
+ &lock_flags, &(erp_action->fsf_req));
+ if (retval < 0) {
+ ZFCP_LOG_INFO("error: Could not create close unit request for "
+ "unit 0x%016Lx on port 0x%016Lx on adapter %s.\n",
+ erp_action->unit->fcp_lun,
+ erp_action->port->wwpn,
+ zfcp_get_busid_by_adapter(erp_action->adapter));
+ goto out;
+ }
+
+ sbale = zfcp_qdio_sbale_req(erp_action->fsf_req,
+ erp_action->fsf_req->sbal_curr, 0);
+ sbale[0].flags |= SBAL_FLAGS0_TYPE_READ;
+ sbale[1].flags |= SBAL_FLAGS_LAST_ENTRY;
+
+ erp_action->fsf_req->qtcb->header.port_handle =
+ 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->erp_action = erp_action;
+
+ /* start QDIO request for this FSF request */
+ retval = zfcp_fsf_req_send(erp_action->fsf_req, &erp_action->timer);
+ if (retval) {
+ ZFCP_LOG_INFO("error: Could not send a close unit request for "
+ "unit 0x%016Lx on port 0x%016Lx onadapter %s.\n",
+ erp_action->unit->fcp_lun,
+ erp_action->port->wwpn,
+ zfcp_get_busid_by_adapter(erp_action->adapter));
+ zfcp_fsf_req_free(erp_action->fsf_req);
+ erp_action->fsf_req = NULL;
+ goto out;
+ }
+
+ ZFCP_LOG_TRACE("Close LUN request initiated (adapter %s, "
+ "port 0x%016Lx, unit 0x%016Lx)\n",
+ zfcp_get_busid_by_adapter(erp_action->adapter),
+ erp_action->port->wwpn, erp_action->unit->fcp_lun);
+ out:
+ write_unlock_irqrestore(&erp_action->adapter->request_queue.queue_lock,
+ lock_flags);
+ return retval;
+}
+
+/*
+ * function: zfcp_fsf_close_unit_handler
+ *
+ * purpose: is called for finished Close LUN FSF command
+ *
+ * returns:
+ */
+static int
+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 */
+
+ if (fsf_req->status & ZFCP_STATUS_FSFREQ_ERROR) {
+ /* don't change unit status in our bookkeeping */
+ goto skip_fsfstatus;
+ }
+
+ /* evaluate FSF status in QTCB */
+ switch (fsf_req->qtcb->header.fsf_status) {
+
+ case FSF_PORT_HANDLE_NOT_VALID:
+ ZFCP_LOG_FLAGS(1, "FSF_PORT_HANDLE_NOT_VALID\n");
+ ZFCP_LOG_INFO("Temporary port identifier 0x%x for port "
+ "0x%016Lx on adapter %s invalid. This may "
+ "happen in rare circumstances\n",
+ unit->port->handle,
+ unit->port->wwpn,
+ zfcp_get_busid_by_unit(unit));
+ ZFCP_LOG_DEBUG("status qualifier:\n");
+ ZFCP_HEX_DUMP(ZFCP_LOG_LEVEL_DEBUG,
+ (char *) &fsf_req->qtcb->header.fsf_status_qual,
+ sizeof (union fsf_status_qual));
+ debug_text_event(fsf_req->adapter->erp_dbf, 1,
+ "fsf_s_phand_nv");
+ zfcp_erp_adapter_reopen(unit->port->adapter, 0);
+ zfcp_cmd_dbf_event_fsf("porthinv", fsf_req,
+ &fsf_req->qtcb->header.fsf_status_qual,
+ sizeof (union fsf_status_qual));
+ fsf_req->status |= ZFCP_STATUS_FSFREQ_ERROR;
+ break;
+
+ case FSF_LUN_HANDLE_NOT_VALID:
+ ZFCP_LOG_FLAGS(1, "FSF_LUN_HANDLE_NOT_VALID\n");
+ ZFCP_LOG_INFO("Temporary LUN identifier 0x%x of unit "
+ "0x%016Lx on port 0x%016Lx on adapter %s is "
+ "invalid. This may happen occasionally.\n",
+ unit->handle,
+ unit->fcp_lun,
+ unit->port->wwpn,
+ zfcp_get_busid_by_unit(unit));
+ ZFCP_LOG_DEBUG("Status qualifier data:\n");
+ ZFCP_HEX_DUMP(ZFCP_LOG_LEVEL_DEBUG,
+ (char *) &fsf_req->qtcb->header.fsf_status_qual,
+ sizeof (union fsf_status_qual));
+ debug_text_event(fsf_req->adapter->erp_dbf, 1,
+ "fsf_s_lhand_nv");
+ zfcp_erp_port_reopen(unit->port, 0);
+ zfcp_cmd_dbf_event_fsf("lunhinv", fsf_req,
+ &fsf_req->qtcb->header.fsf_status_qual,
+ sizeof (union fsf_status_qual));
+ fsf_req->status |= ZFCP_STATUS_FSFREQ_ERROR;
+ break;
+
+ case FSF_PORT_BOXED:
+ ZFCP_LOG_FLAGS(2, "FSF_PORT_BOXED\n");
+ ZFCP_LOG_DEBUG("The remote port 0x%016Lx on adapter %s "
+ "needs to be reopened\n",
+ unit->port->wwpn,
+ zfcp_get_busid_by_unit(unit));
+ debug_text_event(fsf_req->adapter->erp_dbf, 2, "fsf_s_pboxed");
+ zfcp_erp_port_reopen(unit->port, 0);
+ fsf_req->status |= ZFCP_STATUS_FSFREQ_ERROR |
+ ZFCP_STATUS_FSFREQ_RETRY;
+ break;
+
+ case FSF_ADAPTER_STATUS_AVAILABLE:
+ ZFCP_LOG_FLAGS(2, "FSF_ADAPTER_STATUS_AVAILABLE\n");
+ switch (fsf_req->qtcb->header.fsf_status_qual.word[0]) {
+ case FSF_SQ_INVOKE_LINK_TEST_PROCEDURE:
+ ZFCP_LOG_FLAGS(2,
+ "FSF_SQ_INVOKE_LINK_TEST_PROCEDURE\n");
+ /* re-establish link to port */
+ debug_text_event(fsf_req->adapter->erp_dbf, 1,
+ "fsf_sq_ltest");
+ zfcp_erp_port_reopen(unit->port, 0);
+ fsf_req->status |= ZFCP_STATUS_FSFREQ_ERROR;
+ break;
+ case FSF_SQ_ULP_DEPENDENT_ERP_REQUIRED:
+ ZFCP_LOG_FLAGS(2,
+ "FSF_SQ_ULP_DEPENDENT_ERP_REQUIRED\n");
+ /* ERP strategy will escalate */
+ debug_text_event(fsf_req->adapter->erp_dbf, 1,
+ "fsf_sq_ulp");
+ fsf_req->status |= ZFCP_STATUS_FSFREQ_ERROR;
+ break;
+ default:
+ ZFCP_LOG_NORMAL
+ ("bug: Wrong status qualifier 0x%x arrived.\n",
+ fsf_req->qtcb->header.fsf_status_qual.word[0]);
+ debug_text_event(fsf_req->adapter->erp_dbf, 0,
+ "fsf_sq_inval:");
+ debug_exception(
+ fsf_req->adapter->erp_dbf, 0,
+ &fsf_req->qtcb->header.fsf_status_qual.word[0],
+ sizeof (u32));
+ break;
+ }
+ break;
+
+ case FSF_GOOD:
+ ZFCP_LOG_FLAGS(3, "FSF_GOOD\n");
+ ZFCP_LOG_TRACE("unit 0x%016Lx on port 0x%016Lx on adapter %s "
+ "closed, port handle 0x%x\n",
+ unit->fcp_lun,
+ unit->port->wwpn,
+ zfcp_get_busid_by_unit(unit),
+ unit->handle);
+ /* mark unit as closed */
+ atomic_clear_mask(ZFCP_STATUS_COMMON_OPEN, &unit->status);
+ retval = 0;
+ break;
+
+ default:
+ ZFCP_LOG_NORMAL("bug: An unknown FSF Status was presented "
+ "(debug info 0x%x)\n",
+ fsf_req->qtcb->header.fsf_status);
+ debug_text_event(fsf_req->adapter->erp_dbf, 0, "fsf_s_inval:");
+ debug_exception(fsf_req->adapter->erp_dbf, 0,
+ &fsf_req->qtcb->header.fsf_status,
+ sizeof (u32));
+ break;
+ }
+
+ skip_fsfstatus:
+ atomic_clear_mask(ZFCP_STATUS_COMMON_CLOSING, &unit->status);
+ return retval;
+}
+
+/**
+ * zfcp_fsf_send_fcp_command_task - initiate an FCP command (for a SCSI command)
+ * @adapter: adapter where scsi command is issued
+ * @unit: unit where command is sent to
+ * @scsi_cmnd: scsi command to be sent
+ * @timer: timer to be started when request is initiated
+ * @req_flags: flags for fsf_request
+ */
+int
+zfcp_fsf_send_fcp_command_task(struct zfcp_adapter *adapter,
+ struct zfcp_unit *unit,
+ struct scsi_cmnd * scsi_cmnd,
+ struct timer_list *timer, int req_flags)
+{
+ struct zfcp_fsf_req *fsf_req = NULL;
+ struct fcp_cmnd_iu *fcp_cmnd_iu;
+ unsigned int sbtype;
+ unsigned long lock_flags;
+ int real_bytes = 0;
+ int retval = 0;
+ int mask;
+
+ /* setup new FSF request */
+ retval = zfcp_fsf_req_create(adapter, FSF_QTCB_FCP_CMND, req_flags,
+ adapter->pool.fsf_req_scsi,
+ &lock_flags, &fsf_req);
+ if (unlikely(retval < 0)) {
+ ZFCP_LOG_DEBUG("error: Could not create FCP command request "
+ "for unit 0x%016Lx on port 0x%016Lx on "
+ "adapter %s\n",
+ unit->fcp_lun,
+ unit->port->wwpn,
+ zfcp_get_busid_by_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);
+
+ /*
+ * 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);
+
+ /* set handles of unit and its parent port in QTCB */
+ fsf_req->qtcb->header.lun_handle = unit->handle;
+ fsf_req->qtcb->header.port_handle = unit->port->handle;
+
+ /* FSF does not define the structure of the FCP_CMND IU */
+ fcp_cmnd_iu = (struct fcp_cmnd_iu *)
+ &(fsf_req->qtcb->bottom.io.fcp_cmnd);
+
+ /*
+ * set depending on data direction:
+ * data direction bits in SBALE (SB Type)
+ * data direction bits in QTCB
+ * data direction bits in FCP_CMND IU
+ */
+ switch (scsi_cmnd->sc_data_direction) {
+ case DMA_NONE:
+ ZFCP_LOG_FLAGS(3, "DMA_NONE\n");
+ fsf_req->qtcb->bottom.io.data_direction = FSF_DATADIR_CMND;
+ /*
+ * FIXME(qdio):
+ * what is the correct type for commands
+ * without 'real' data buffers?
+ */
+ sbtype = SBAL_FLAGS0_TYPE_READ;
+ break;
+ case DMA_FROM_DEVICE:
+ ZFCP_LOG_FLAGS(3, "DMA_FROM_DEVICE\n");
+ fsf_req->qtcb->bottom.io.data_direction = FSF_DATADIR_READ;
+ sbtype = SBAL_FLAGS0_TYPE_READ;
+ fcp_cmnd_iu->rddata = 1;
+ break;
+ case DMA_TO_DEVICE:
+ ZFCP_LOG_FLAGS(3, "DMA_TO_DEVICE\n");
+ fsf_req->qtcb->bottom.io.data_direction = FSF_DATADIR_WRITE;
+ sbtype = SBAL_FLAGS0_TYPE_WRITE;
+ fcp_cmnd_iu->wddata = 1;
+ break;
+ case DMA_BIDIRECTIONAL:
+ ZFCP_LOG_FLAGS(0, "DMA_BIDIRECTIONAL not supported\n");
+ default:
+ /*
+ * dummy, catch this condition earlier
+ * in zfcp_scsi_queuecommand
+ */
+ goto failed_scsi_cmnd;
+ }
+
+ /* set FC service class in QTCB (3 per default) */
+ fsf_req->qtcb->bottom.io.service_class = adapter->fc_service_class;
+
+ /* set FCP_LUN in FCP_CMND IU in QTCB */
+ fcp_cmnd_iu->fcp_lun = unit->fcp_lun;
+
+ mask = ZFCP_STATUS_UNIT_READONLY | ZFCP_STATUS_UNIT_SHARED;
+
+ /* set task attributes in FCP_CMND IU in QTCB */
+ if (likely((scsi_cmnd->device->simple_tags) ||
+ (atomic_test_mask(mask, &unit->status))))
+ fcp_cmnd_iu->task_attribute = SIMPLE_Q;
+ else
+ fcp_cmnd_iu->task_attribute = UNTAGGED;
+
+ /* set additional length of FCP_CDB in FCP_CMND IU in QTCB, if needed */
+ if (unlikely(scsi_cmnd->cmd_len > FCP_CDB_LENGTH)) {
+ fcp_cmnd_iu->add_fcp_cdb_length
+ = (scsi_cmnd->cmd_len - FCP_CDB_LENGTH) >> 2;
+ ZFCP_LOG_TRACE("SCSI CDB length is 0x%x, "
+ "additional FCP_CDB length is 0x%x "
+ "(shifted right 2 bits)\n",
+ scsi_cmnd->cmd_len,
+ fcp_cmnd_iu->add_fcp_cdb_length);
+ }
+ /*
+ * copy SCSI CDB (including additional length, if any) to
+ * FCP_CDB in FCP_CMND IU in QTCB
+ */
+ memcpy(fcp_cmnd_iu->fcp_cdb, scsi_cmnd->cmnd, scsi_cmnd->cmd_len);
+
+ /* FCP CMND IU length in QTCB */
+ fsf_req->qtcb->bottom.io.fcp_cmnd_length =
+ sizeof (struct fcp_cmnd_iu) +
+ fcp_cmnd_iu->add_fcp_cdb_length + sizeof (fcp_dl_t);
+
+ /* generate SBALEs from data buffer */
+ real_bytes = zfcp_qdio_sbals_from_scsicmnd(fsf_req, sbtype, scsi_cmnd);
+ if (unlikely(real_bytes < 0)) {
+ if (fsf_req->sbal_number < ZFCP_MAX_SBALS_PER_REQ) {
+ ZFCP_LOG_DEBUG(
+ "Data did not fit into available buffer(s), "
+ "waiting for more...\n");
+ retval = -EIO;
+ } else {
+ ZFCP_LOG_NORMAL("error: No truncation implemented but "
+ "required. Shutting down unit "
+ "(adapter %s, port 0x%016Lx, "
+ "unit 0x%016Lx)\n",
+ zfcp_get_busid_by_unit(unit),
+ unit->port->wwpn,
+ unit->fcp_lun);
+ zfcp_erp_unit_shutdown(unit, 0);
+ retval = -EINVAL;
+ }
+ goto no_fit;
+ }
+
+ /* set length of FCP data length in FCP_CMND IU in QTCB */
+ zfcp_set_fcp_dl(fcp_cmnd_iu, real_bytes);
+
+ ZFCP_LOG_DEBUG("Sending SCSI command:\n");
+ ZFCP_HEX_DUMP(ZFCP_LOG_LEVEL_DEBUG,
+ (char *) scsi_cmnd->cmnd, scsi_cmnd->cmd_len);
+
+ /*
+ * start QDIO request for this FSF request
+ * covered by an SBALE)
+ */
+ retval = zfcp_fsf_req_send(fsf_req, timer);
+ if (unlikely(retval < 0)) {
+ ZFCP_LOG_INFO("error: Could not send FCP command request "
+ "on adapter %s, port 0x%016Lx, unit 0x%016Lx\n",
+ zfcp_get_busid_by_adapter(adapter),
+ unit->port->wwpn,
+ unit->fcp_lun);
+ goto send_failed;
+ }
+
+ ZFCP_LOG_TRACE("Send FCP Command initiated (adapter %s, "
+ "port 0x%016Lx, unit 0x%016Lx)\n",
+ zfcp_get_busid_by_adapter(adapter),
+ unit->port->wwpn,
+ unit->fcp_lun);
+ goto success;
+
+ send_failed:
+ no_fit:
+ failed_scsi_cmnd:
+ zfcp_fsf_req_free(fsf_req);
+ fsf_req = NULL;
+ scsi_cmnd->host_scribble = NULL;
+ success:
+ failed_req_create:
+ write_unlock_irqrestore(&adapter->request_queue.queue_lock, lock_flags);
+ return retval;
+}
+
+/*
+ * function: zfcp_fsf_send_fcp_command_task_management
+ *
+ * purpose:
+ *
+ * returns:
+ *
+ * FIXME(design): should be watched by a timeout!!!
+ * FIXME(design) shouldn't this be modified to return an int
+ * also...don't know how though
+ *
+ */
+struct zfcp_fsf_req *
+zfcp_fsf_send_fcp_command_task_management(struct zfcp_adapter *adapter,
+ struct zfcp_unit *unit,
+ u8 tm_flags, int req_flags)
+{
+ struct zfcp_fsf_req *fsf_req = NULL;
+ int retval = 0;
+ struct fcp_cmnd_iu *fcp_cmnd_iu;
+ unsigned long lock_flags;
+ volatile struct qdio_buffer_element *sbale;
+
+ /* setup new FSF request */
+ retval = zfcp_fsf_req_create(adapter, FSF_QTCB_FCP_CMND, req_flags,
+ adapter->pool.fsf_req_scsi,
+ &lock_flags, &fsf_req);
+ if (retval < 0) {
+ ZFCP_LOG_INFO("error: Could not create FCP command (task "
+ "management) request for adapter %s, port "
+ " 0x%016Lx, unit 0x%016Lx.\n",
+ zfcp_get_busid_by_adapter(adapter),
+ unit->port->wwpn, unit->fcp_lun);
+ goto out;
+ }
+
+ /*
+ * Used to decide on proper handler in the return path,
+ * could be either zfcp_fsf_send_fcp_command_task_handler or
+ * zfcp_fsf_send_fcp_command_task_management_handler */
+
+ fsf_req->status |= ZFCP_STATUS_FSFREQ_TASK_MANAGEMENT;
+
+ /*
+ * hold a pointer to the unit being target of this
+ * task management request
+ */
+ fsf_req->data.send_fcp_command_task_management.unit = unit;
+
+ /* set FSF related fields in QTCB */
+ fsf_req->qtcb->header.lun_handle = unit->handle;
+ fsf_req->qtcb->header.port_handle = unit->port->handle;
+ fsf_req->qtcb->bottom.io.data_direction = FSF_DATADIR_CMND;
+ fsf_req->qtcb->bottom.io.service_class = adapter->fc_service_class;
+ fsf_req->qtcb->bottom.io.fcp_cmnd_length =
+ sizeof (struct fcp_cmnd_iu) + sizeof (fcp_dl_t);
+
+ sbale = zfcp_qdio_sbale_req(fsf_req, fsf_req->sbal_curr, 0);
+ sbale[0].flags |= SBAL_FLAGS0_TYPE_WRITE;
+ sbale[1].flags |= SBAL_FLAGS_LAST_ENTRY;
+
+ /* set FCP related fields in FCP_CMND IU in QTCB */
+ fcp_cmnd_iu = (struct fcp_cmnd_iu *)
+ &(fsf_req->qtcb->bottom.io.fcp_cmnd);
+ fcp_cmnd_iu->fcp_lun = unit->fcp_lun;
+ fcp_cmnd_iu->task_management_flags = tm_flags;
+
+ /* start QDIO request for this FSF request */
+ zfcp_fsf_start_scsi_er_timer(adapter);
+ retval = zfcp_fsf_req_send(fsf_req, NULL);
+ if (retval) {
+ del_timer(&adapter->scsi_er_timer);
+ ZFCP_LOG_INFO("error: Could not send an FCP-command (task "
+ "management) on adapter %s, port 0x%016Lx for "
+ "unit LUN 0x%016Lx\n",
+ zfcp_get_busid_by_adapter(adapter),
+ unit->port->wwpn,
+ unit->fcp_lun);
+ zfcp_fsf_req_free(fsf_req);
+ fsf_req = NULL;
+ goto out;
+ }
+
+ ZFCP_LOG_TRACE("Send FCP Command (task management function) initiated "
+ "(adapter %s, port 0x%016Lx, unit 0x%016Lx, "
+ "tm_flags=0x%x)\n",
+ zfcp_get_busid_by_adapter(adapter),
+ unit->port->wwpn,
+ unit->fcp_lun,
+ tm_flags);
+ out:
+ write_unlock_irqrestore(&adapter->request_queue.queue_lock, lock_flags);
+ return fsf_req;
+}
+
+/*
+ * function: zfcp_fsf_send_fcp_command_handler
+ *
+ * purpose: is called for finished Send FCP Command
+ *
+ * returns:
+ */
+static int
+zfcp_fsf_send_fcp_command_handler(struct zfcp_fsf_req *fsf_req)
+{
+ int retval = -EINVAL;
+ struct zfcp_unit *unit;
+ struct fsf_qtcb_header *header;
+ u16 subtable, rule, counter;
+
+ 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;
+ else
+ unit = fsf_req->data.send_fcp_command_task.unit;
+
+ if (unlikely(fsf_req->status & ZFCP_STATUS_FSFREQ_ERROR)) {
+ /* go directly to calls of special handlers */
+ goto skip_fsfstatus;
+ }
+
+ /* evaluate FSF status in QTCB */
+ switch (header->fsf_status) {
+
+ case FSF_PORT_HANDLE_NOT_VALID:
+ ZFCP_LOG_FLAGS(1, "FSF_PORT_HANDLE_NOT_VALID\n");
+ ZFCP_LOG_INFO("Temporary port identifier 0x%x for port "
+ "0x%016Lx on adapter %s invalid\n",
+ unit->port->handle,
+ unit->port->wwpn, zfcp_get_busid_by_unit(unit));
+ ZFCP_HEX_DUMP(ZFCP_LOG_LEVEL_DEBUG,
+ (char *) &header->fsf_status_qual,
+ sizeof (union fsf_status_qual));
+ debug_text_event(fsf_req->adapter->erp_dbf, 1,
+ "fsf_s_phand_nv");
+ zfcp_erp_adapter_reopen(unit->port->adapter, 0);
+ fsf_req->status |= ZFCP_STATUS_FSFREQ_ERROR;
+ break;
+
+ case FSF_LUN_HANDLE_NOT_VALID:
+ ZFCP_LOG_FLAGS(1, "FSF_LUN_HANDLE_NOT_VALID\n");
+ ZFCP_LOG_INFO("Temporary LUN identifier 0x%x for unit "
+ "0x%016Lx on port 0x%016Lx on adapter %s is "
+ "invalid. This may happen occasionally.\n",
+ unit->handle,
+ unit->fcp_lun,
+ unit->port->wwpn,
+ zfcp_get_busid_by_unit(unit));
+ ZFCP_LOG_NORMAL("Status qualifier data:\n");
+ ZFCP_HEX_DUMP(ZFCP_LOG_LEVEL_NORMAL,
+ (char *) &header->fsf_status_qual,
+ sizeof (union fsf_status_qual));
+ debug_text_event(fsf_req->adapter->erp_dbf, 1,
+ "fsf_s_uhand_nv");
+ zfcp_erp_port_reopen(unit->port, 0);
+ fsf_req->status |= ZFCP_STATUS_FSFREQ_ERROR;
+ break;
+
+ case FSF_HANDLE_MISMATCH:
+ ZFCP_LOG_FLAGS(0, "FSF_HANDLE_MISMATCH\n");
+ ZFCP_LOG_NORMAL("bug: The port handle 0x%x has changed "
+ "unexpectedly. (adapter %s, port 0x%016Lx, "
+ "unit 0x%016Lx)\n",
+ unit->port->handle,
+ zfcp_get_busid_by_unit(unit),
+ unit->port->wwpn,
+ unit->fcp_lun);
+ ZFCP_LOG_NORMAL("status qualifier:\n");
+ ZFCP_HEX_DUMP(ZFCP_LOG_LEVEL_NORMAL,
+ (char *) &header->fsf_status_qual,
+ sizeof (union fsf_status_qual));
+ debug_text_event(fsf_req->adapter->erp_dbf, 1,
+ "fsf_s_hand_mis");
+ zfcp_erp_adapter_reopen(unit->port->adapter, 0);
+ zfcp_cmd_dbf_event_fsf("handmism",
+ fsf_req,
+ &header->fsf_status_qual,
+ sizeof (union fsf_status_qual));
+ fsf_req->status |= ZFCP_STATUS_FSFREQ_ERROR;
+ break;
+
+ case FSF_SERVICE_CLASS_NOT_SUPPORTED:
+ ZFCP_LOG_FLAGS(0, "FSF_SERVICE_CLASS_NOT_SUPPORTED\n");
+ if (fsf_req->adapter->fc_service_class <= 3) {
+ ZFCP_LOG_NORMAL("error: The adapter %s does "
+ "not support fibrechannel class %d.\n",
+ zfcp_get_busid_by_unit(unit),
+ fsf_req->adapter->fc_service_class);
+ } else {
+ ZFCP_LOG_NORMAL("bug: The fibrechannel class at "
+ "adapter %s is invalid. "
+ "(debug info %d)\n",
+ zfcp_get_busid_by_unit(unit),
+ fsf_req->adapter->fc_service_class);
+ }
+ /* stop operation for this adapter */
+ debug_text_exception(fsf_req->adapter->erp_dbf, 0,
+ "fsf_s_class_nsup");
+ zfcp_erp_adapter_shutdown(unit->port->adapter, 0);
+ zfcp_cmd_dbf_event_fsf("unsclass",
+ fsf_req,
+ &header->fsf_status_qual,
+ sizeof (union fsf_status_qual));
+ fsf_req->status |= ZFCP_STATUS_FSFREQ_ERROR;
+ break;
+
+ case FSF_FCPLUN_NOT_VALID:
+ ZFCP_LOG_FLAGS(0, "FSF_FCPLUN_NOT_VALID\n");
+ ZFCP_LOG_NORMAL("bug: unit 0x%016Lx on port 0x%016Lx on "
+ "adapter %s does not have correct unit "
+ "handle 0x%x\n",
+ unit->fcp_lun,
+ unit->port->wwpn,
+ zfcp_get_busid_by_unit(unit),
+ unit->handle);
+ ZFCP_LOG_DEBUG("status qualifier:\n");
+ ZFCP_HEX_DUMP(ZFCP_LOG_LEVEL_DEBUG,
+ (char *) &header->fsf_status_qual,
+ sizeof (union fsf_status_qual));
+ debug_text_event(fsf_req->adapter->erp_dbf, 1,
+ "fsf_s_fcp_lun_nv");
+ zfcp_erp_port_reopen(unit->port, 0);
+ zfcp_cmd_dbf_event_fsf("fluninv",
+ fsf_req,
+ &header->fsf_status_qual,
+ sizeof (union fsf_status_qual));
+ fsf_req->status |= ZFCP_STATUS_FSFREQ_ERROR;
+ break;
+
+ case FSF_ACCESS_DENIED:
+ ZFCP_LOG_FLAGS(2, "FSF_ACCESS_DENIED\n");
+ ZFCP_LOG_NORMAL("Access denied, cannot send FCP command to "
+ "unit 0x%016Lx on port 0x%016Lx on "
+ "adapter %s\n", unit->fcp_lun, unit->port->wwpn,
+ zfcp_get_busid_by_unit(unit));
+ for (counter = 0; counter < 2; counter++) {
+ subtable = header->fsf_status_qual.halfword[counter * 2];
+ rule = header->fsf_status_qual.halfword[counter * 2 + 1];
+ switch (subtable) {
+ case FSF_SQ_CFDC_SUBTABLE_OS:
+ case FSF_SQ_CFDC_SUBTABLE_PORT_WWPN:
+ case FSF_SQ_CFDC_SUBTABLE_PORT_DID:
+ case FSF_SQ_CFDC_SUBTABLE_LUN:
+ ZFCP_LOG_INFO("Access denied (%s rule %d)\n",
+ zfcp_act_subtable_type[subtable], rule);
+ break;
+ }
+ }
+ debug_text_event(fsf_req->adapter->erp_dbf, 1, "fsf_s_access");
+ zfcp_erp_unit_access_denied(unit);
+ fsf_req->status |= ZFCP_STATUS_FSFREQ_ERROR;
+ break;
+
+ case FSF_DIRECTION_INDICATOR_NOT_VALID:
+ ZFCP_LOG_FLAGS(0, "FSF_DIRECTION_INDICATOR_NOT_VALID\n");
+ ZFCP_LOG_INFO("bug: Invalid data direction given for unit "
+ "0x%016Lx on port 0x%016Lx on adapter %s "
+ "(debug info %d)\n",
+ unit->fcp_lun,
+ unit->port->wwpn,
+ zfcp_get_busid_by_unit(unit),
+ fsf_req->qtcb->bottom.io.data_direction);
+ /* stop operation for this adapter */
+ debug_text_event(fsf_req->adapter->erp_dbf, 0,
+ "fsf_s_dir_ind_nv");
+ zfcp_erp_adapter_shutdown(unit->port->adapter, 0);
+ zfcp_cmd_dbf_event_fsf("dirinv",
+ fsf_req,
+ &header->fsf_status_qual,
+ sizeof (union fsf_status_qual));
+ fsf_req->status |= ZFCP_STATUS_FSFREQ_ERROR;
+ break;
+
+ case FSF_CMND_LENGTH_NOT_VALID:
+ ZFCP_LOG_FLAGS(0, "FSF_CMND_LENGTH_NOT_VALID\n");
+ ZFCP_LOG_NORMAL
+ ("bug: An invalid control-data-block length field "
+ "was found in a command for unit 0x%016Lx on port "
+ "0x%016Lx on adapter %s " "(debug info %d)\n",
+ unit->fcp_lun, unit->port->wwpn,
+ zfcp_get_busid_by_unit(unit),
+ fsf_req->qtcb->bottom.io.fcp_cmnd_length);
+ /* stop operation for this adapter */
+ debug_text_event(fsf_req->adapter->erp_dbf, 0,
+ "fsf_s_cmd_len_nv");
+ zfcp_erp_adapter_shutdown(unit->port->adapter, 0);
+ zfcp_cmd_dbf_event_fsf("cleninv",
+ fsf_req,
+ &header->fsf_status_qual,
+ sizeof (union fsf_status_qual));
+ fsf_req->status |= ZFCP_STATUS_FSFREQ_ERROR;
+ break;
+
+ case FSF_PORT_BOXED:
+ ZFCP_LOG_FLAGS(2, "FSF_PORT_BOXED\n");
+ ZFCP_LOG_DEBUG("The remote port 0x%016Lx on adapter %s "
+ "needs to be reopened\n",
+ unit->port->wwpn, zfcp_get_busid_by_unit(unit));
+ debug_text_event(fsf_req->adapter->erp_dbf, 2, "fsf_s_pboxed");
+ zfcp_erp_port_reopen(unit->port, 0);
+ zfcp_cmd_dbf_event_fsf("portbox", fsf_req,
+ &header->fsf_status_qual,
+ sizeof (union fsf_status_qual));
+ fsf_req->status |= ZFCP_STATUS_FSFREQ_ERROR |
+ ZFCP_STATUS_FSFREQ_RETRY;
+ break;
+
+ case FSF_LUN_BOXED:
+ ZFCP_LOG_FLAGS(0, "FSF_LUN_BOXED\n");
+ ZFCP_LOG_NORMAL("unit needs to be reopened (adapter %s, "
+ "wwpn=0x%016Lx, fcp_lun=0x%016Lx)\n",
+ zfcp_get_busid_by_unit(unit),
+ unit->port->wwpn, unit->fcp_lun);
+ debug_text_event(fsf_req->adapter->erp_dbf, 1, "fsf_s_lboxed");
+ zfcp_erp_unit_reopen(unit, 0);
+ zfcp_cmd_dbf_event_fsf("unitbox", fsf_req,
+ &header->fsf_status_qual,
+ sizeof(union fsf_status_qual));
+ fsf_req->status |= ZFCP_STATUS_FSFREQ_ERROR
+ | ZFCP_STATUS_FSFREQ_RETRY;
+ break;
+
+ case FSF_ADAPTER_STATUS_AVAILABLE:
+ ZFCP_LOG_FLAGS(2, "FSF_ADAPTER_STATUS_AVAILABLE\n");
+ switch (header->fsf_status_qual.word[0]) {
+ case FSF_SQ_INVOKE_LINK_TEST_PROCEDURE:
+ ZFCP_LOG_FLAGS(2,
+ "FSF_SQ_INVOKE_LINK_TEST_PROCEDURE\n");
+ /* re-establish link to port */
+ debug_text_event(fsf_req->adapter->erp_dbf, 1,
+ "fsf_sq_ltest");
+ zfcp_erp_port_reopen(unit->port, 0);
+ zfcp_cmd_dbf_event_fsf(
+ "sqltest",
+ fsf_req,
+ &header->fsf_status_qual,
+ sizeof (union fsf_status_qual));
+ fsf_req->status |= ZFCP_STATUS_FSFREQ_ERROR;
+ break;
+ case FSF_SQ_ULP_DEPENDENT_ERP_REQUIRED:
+ ZFCP_LOG_FLAGS(3,
+ "FSF_SQ_ULP_DEPENDENT_ERP_REQUIRED\n");
+ /* FIXME(hw) need proper specs for proper action */
+ /* let scsi stack deal with retries and escalation */
+ debug_text_event(fsf_req->adapter->erp_dbf, 1,
+ "fsf_sq_ulp");
+ zfcp_cmd_dbf_event_fsf(
+ "sqdeperp",
+ fsf_req,
+ &header->fsf_status_qual,
+ sizeof (union fsf_status_qual));
+ fsf_req->status |= ZFCP_STATUS_FSFREQ_ERROR;
+ break;
+ default:
+ /* FIXME: shall we consider this a successful transfer? */
+ ZFCP_LOG_NORMAL
+ ("bug: Wrong status qualifier 0x%x arrived.\n",
+ header->fsf_status_qual.word[0]);
+ debug_text_event(fsf_req->adapter->erp_dbf, 0,
+ "fsf_sq_inval:");
+ debug_exception(fsf_req->adapter->erp_dbf, 0,
+ &header->fsf_status_qual.word[0],
+ sizeof(u32));
+ break;
+ }
+ break;
+
+ case FSF_GOOD:
+ ZFCP_LOG_FLAGS(3, "FSF_GOOD\n");
+ break;
+
+ case FSF_FCP_RSP_AVAILABLE:
+ ZFCP_LOG_FLAGS(2, "FSF_FCP_RSP_AVAILABLE\n");
+ break;
+
+ default:
+ debug_text_event(fsf_req->adapter->erp_dbf, 0, "fsf_s_inval:");
+ debug_exception(fsf_req->adapter->erp_dbf, 0,
+ &header->fsf_status, sizeof(u32));
+ break;
+ }
+
+ skip_fsfstatus:
+ if (fsf_req->status & ZFCP_STATUS_FSFREQ_TASK_MANAGEMENT) {
+ retval =
+ zfcp_fsf_send_fcp_command_task_management_handler(fsf_req);
+ } else {
+ retval = zfcp_fsf_send_fcp_command_task_handler(fsf_req);
+ }
+ return retval;
+}
+
+/*
+ * function: zfcp_fsf_send_fcp_command_task_handler
+ *
+ * purpose: evaluates FCP_RSP IU
+ *
+ * returns:
+ */
+static int
+zfcp_fsf_send_fcp_command_task_handler(struct zfcp_fsf_req *fsf_req)
+{
+ int retval = 0;
+ struct scsi_cmnd *scpnt;
+ struct fcp_rsp_iu *fcp_rsp_iu = (struct fcp_rsp_iu *)
+ &(fsf_req->qtcb->bottom.io.fcp_rsp);
+ struct fcp_cmnd_iu *fcp_cmnd_iu = (struct fcp_cmnd_iu *)
+ &(fsf_req->qtcb->bottom.io.fcp_cmnd);
+ 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;
+
+ read_lock_irqsave(&fsf_req->adapter->abort_lock, flags);
+ scpnt = fsf_req->data.send_fcp_command_task.scsi_cmnd;
+ if (unlikely(!scpnt)) {
+ ZFCP_LOG_DEBUG
+ ("Command with fsf_req %p is not associated to "
+ "a scsi command anymore. Aborted?\n", fsf_req);
+ goto out;
+ }
+ if (unlikely(fsf_req->status & ZFCP_STATUS_FSFREQ_ABORTED)) {
+ /* FIXME: (design) mid-layer should handle DID_ABORT like
+ * DID_SOFT_ERROR by retrying the request for devices
+ * that allow retries.
+ */
+ ZFCP_LOG_DEBUG("Setting DID_SOFT_ERROR and SUGGEST_RETRY\n");
+ set_host_byte(&scpnt->result, DID_SOFT_ERROR);
+ set_driver_byte(&scpnt->result, SUGGEST_RETRY);
+ goto skip_fsfstatus;
+ }
+
+ if (unlikely(fsf_req->status & ZFCP_STATUS_FSFREQ_ERROR)) {
+ ZFCP_LOG_DEBUG("Setting DID_ERROR\n");
+ set_host_byte(&scpnt->result, DID_ERROR);
+ goto skip_fsfstatus;
+ }
+
+ /* set message byte of result in SCSI command */
+ scpnt->result |= COMMAND_COMPLETE << 8;
+
+ /*
+ * copy SCSI status code of FCP_STATUS of FCP_RSP IU to status byte
+ * of result in SCSI command
+ */
+ scpnt->result |= fcp_rsp_iu->scsi_status;
+ if (unlikely(fcp_rsp_iu->scsi_status)) {
+ /* DEBUG */
+ ZFCP_LOG_DEBUG("status for SCSI Command:\n");
+ ZFCP_HEX_DUMP(ZFCP_LOG_LEVEL_DEBUG,
+ scpnt->cmnd, scpnt->cmd_len);
+ ZFCP_LOG_DEBUG("SCSI status code 0x%x\n",
+ fcp_rsp_iu->scsi_status);
+ ZFCP_HEX_DUMP(ZFCP_LOG_LEVEL_DEBUG,
+ (void *) fcp_rsp_iu, sizeof (struct fcp_rsp_iu));
+ ZFCP_HEX_DUMP(ZFCP_LOG_LEVEL_DEBUG,
+ zfcp_get_fcp_sns_info_ptr(fcp_rsp_iu),
+ fcp_rsp_iu->fcp_sns_len);
+ }
+
+ /* check FCP_RSP_INFO */
+ if (unlikely(fcp_rsp_iu->validity.bits.fcp_rsp_len_valid)) {
+ ZFCP_LOG_DEBUG("rsp_len is valid\n");
+ switch (fcp_rsp_info[3]) {
+ case RSP_CODE_GOOD:
+ ZFCP_LOG_FLAGS(3, "RSP_CODE_GOOD\n");
+ /* ok, continue */
+ ZFCP_LOG_TRACE("no failure or Task Management "
+ "Function complete\n");
+ set_host_byte(&scpnt->result, DID_OK);
+ break;
+ case RSP_CODE_LENGTH_MISMATCH:
+ ZFCP_LOG_FLAGS(0, "RSP_CODE_LENGTH_MISMATCH\n");
+ /* hardware bug */
+ ZFCP_LOG_NORMAL("bug: FCP response code indictates "
+ "that the fibrechannel protocol data "
+ "length differs from the burst length. "
+ "The problem occured on unit 0x%016Lx "
+ "on port 0x%016Lx on adapter %s",
+ unit->fcp_lun,
+ unit->port->wwpn,
+ zfcp_get_busid_by_unit(unit));
+ /* dump SCSI CDB as prepared by zfcp */
+ ZFCP_HEX_DUMP(ZFCP_LOG_LEVEL_DEBUG,
+ (char *) &fsf_req->qtcb->
+ bottom.io.fcp_cmnd, FSF_FCP_CMND_SIZE);
+ zfcp_cmd_dbf_event_fsf("clenmis", fsf_req, NULL, 0);
+ set_host_byte(&scpnt->result, DID_ERROR);
+ goto skip_fsfstatus;
+ case RSP_CODE_FIELD_INVALID:
+ ZFCP_LOG_FLAGS(0, "RSP_CODE_FIELD_INVALID\n");
+ /* driver or hardware bug */
+ ZFCP_LOG_NORMAL("bug: FCP response code indictates "
+ "that the fibrechannel protocol data "
+ "fields were incorrectly set up. "
+ "The problem occured on the unit "
+ "0x%016Lx on port 0x%016Lx on "
+ "adapter %s",
+ unit->fcp_lun,
+ unit->port->wwpn,
+ zfcp_get_busid_by_unit(unit));
+ /* dump SCSI CDB as prepared by zfcp */
+ ZFCP_HEX_DUMP(ZFCP_LOG_LEVEL_DEBUG,
+ (char *) &fsf_req->qtcb->
+ bottom.io.fcp_cmnd, FSF_FCP_CMND_SIZE);
+ set_host_byte(&scpnt->result, DID_ERROR);
+ zfcp_cmd_dbf_event_fsf("codeinv", fsf_req, NULL, 0);
+ goto skip_fsfstatus;
+ case RSP_CODE_RO_MISMATCH:
+ ZFCP_LOG_FLAGS(0, "RSP_CODE_RO_MISMATCH\n");
+ /* hardware bug */
+ ZFCP_LOG_NORMAL("bug: The FCP response code indicates "
+ "that conflicting values for the "
+ "fibrechannel payload offset from the "
+ "header were found. "
+ "The problem occured on unit 0x%016Lx "
+ "on port 0x%016Lx on adapter %s.\n",
+ unit->fcp_lun,
+ unit->port->wwpn,
+ zfcp_get_busid_by_unit(unit));
+ /* dump SCSI CDB as prepared by zfcp */
+ ZFCP_HEX_DUMP(ZFCP_LOG_LEVEL_DEBUG,
+ (char *) &fsf_req->qtcb->
+ bottom.io.fcp_cmnd, FSF_FCP_CMND_SIZE);
+ zfcp_cmd_dbf_event_fsf("codemism", fsf_req, NULL, 0);
+ set_host_byte(&scpnt->result, DID_ERROR);
+ goto skip_fsfstatus;
+ default:
+ ZFCP_LOG_NORMAL("bug: An invalid FCP response "
+ "code was detected for a command. "
+ "The problem occured on the unit "
+ "0x%016Lx on port 0x%016Lx on "
+ "adapter %s (debug info 0x%x)\n",
+ unit->fcp_lun,
+ unit->port->wwpn,
+ zfcp_get_busid_by_unit(unit),
+ fcp_rsp_info[3]);
+ /* dump SCSI CDB as prepared by zfcp */
+ ZFCP_HEX_DUMP(ZFCP_LOG_LEVEL_DEBUG,
+ (char *) &fsf_req->qtcb->
+ bottom.io.fcp_cmnd, FSF_FCP_CMND_SIZE);
+ zfcp_cmd_dbf_event_fsf("undeffcp", fsf_req, NULL, 0);
+ set_host_byte(&scpnt->result, DID_ERROR);
+ }
+ }
+
+ /* check for sense data */
+ if (unlikely(fcp_rsp_iu->validity.bits.fcp_sns_len_valid)) {
+ sns_len = FSF_FCP_RSP_SIZE -
+ sizeof (struct fcp_rsp_iu) + fcp_rsp_iu->fcp_rsp_len;
+ ZFCP_LOG_TRACE("room for %i bytes sense data in QTCB\n",
+ sns_len);
+ sns_len = min(sns_len, (u32) SCSI_SENSE_BUFFERSIZE);
+ ZFCP_LOG_TRACE("room for %i bytes sense data in SCSI command\n",
+ SCSI_SENSE_BUFFERSIZE);
+ sns_len = min(sns_len, fcp_rsp_iu->fcp_sns_len);
+ ZFCP_LOG_TRACE("scpnt->result =0x%x, command was:\n",
+ scpnt->result);
+ ZFCP_HEX_DUMP(ZFCP_LOG_LEVEL_TRACE,
+ (void *) &scpnt->cmnd, scpnt->cmd_len);
+
+ ZFCP_LOG_TRACE("%i bytes sense data provided by FCP\n",
+ fcp_rsp_iu->fcp_sns_len);
+ memcpy(&scpnt->sense_buffer,
+ zfcp_get_fcp_sns_info_ptr(fcp_rsp_iu), sns_len);
+ ZFCP_HEX_DUMP(ZFCP_LOG_LEVEL_TRACE,
+ (void *) &scpnt->sense_buffer, sns_len);
+ }
+
+ /* check for overrun */
+ if (unlikely(fcp_rsp_iu->validity.bits.fcp_resid_over)) {
+ ZFCP_LOG_INFO("A data overrun was detected for a command. "
+ "unit 0x%016Lx, port 0x%016Lx, adapter %s. "
+ "The response data length is "
+ "%d, the original length was %d.\n",
+ unit->fcp_lun,
+ unit->port->wwpn,
+ zfcp_get_busid_by_unit(unit),
+ fcp_rsp_iu->fcp_resid,
+ (int) zfcp_get_fcp_dl(fcp_cmnd_iu));
+ }
+
+ /* check for underrun */
+ if (unlikely(fcp_rsp_iu->validity.bits.fcp_resid_under)) {
+ ZFCP_LOG_INFO("A data underrun was detected for a command. "
+ "unit 0x%016Lx, port 0x%016Lx, adapter %s. "
+ "The response data length is "
+ "%d, the original length was %d.\n",
+ unit->fcp_lun,
+ unit->port->wwpn,
+ zfcp_get_busid_by_unit(unit),
+ fcp_rsp_iu->fcp_resid,
+ (int) zfcp_get_fcp_dl(fcp_cmnd_iu));
+
+ scpnt->resid = fcp_rsp_iu->fcp_resid;
+ if (scpnt->request_bufflen - scpnt->resid < scpnt->underflow)
+ scpnt->result |= DID_ERROR << 16;
+ }
+
+ skip_fsfstatus:
+ ZFCP_LOG_DEBUG("scpnt->result =0x%x\n", scpnt->result);
+
+ zfcp_cmd_dbf_event_scsi("response", scpnt);
+
+ /* cleanup pointer (need this especially for abort) */
+ scpnt->host_scribble = NULL;
+
+ /*
+ * NOTE:
+ * according to the outcome of a discussion on linux-scsi we
+ * don't need to grab the io_request_lock here since we use
+ * the new eh
+ */
+ /* always call back */
+
+ (scpnt->scsi_done) (scpnt);
+
+ /*
+ * We must hold this lock until scsi_done has been called.
+ * Otherwise we may call scsi_done after abort regarding this
+ * command has completed.
+ * Note: scsi_done must not block!
+ */
+ out:
+ read_unlock_irqrestore(&fsf_req->adapter->abort_lock, flags);
+ return retval;
+}
+
+/*
+ * function: zfcp_fsf_send_fcp_command_task_management_handler
+ *
+ * purpose: evaluates FCP_RSP IU
+ *
+ * returns:
+ */
+static int
+zfcp_fsf_send_fcp_command_task_management_handler(struct zfcp_fsf_req *fsf_req)
+{
+ int retval = 0;
+ 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;
+
+ del_timer(&fsf_req->adapter->scsi_er_timer);
+ if (fsf_req->status & ZFCP_STATUS_FSFREQ_ERROR) {
+ fsf_req->status |= ZFCP_STATUS_FSFREQ_TMFUNCFAILED;
+ goto skip_fsfstatus;
+ }
+
+ /* check FCP_RSP_INFO */
+ switch (fcp_rsp_info[3]) {
+ case RSP_CODE_GOOD:
+ ZFCP_LOG_FLAGS(3, "RSP_CODE_GOOD\n");
+ /* ok, continue */
+ ZFCP_LOG_DEBUG("no failure or Task Management "
+ "Function complete\n");
+ break;
+ case RSP_CODE_TASKMAN_UNSUPP:
+ ZFCP_LOG_FLAGS(0, "RSP_CODE_TASKMAN_UNSUPP\n");
+ ZFCP_LOG_NORMAL("bug: A reuested task management function "
+ "is not supported on the target device "
+ "unit 0x%016Lx, port 0x%016Lx, adapter %s\n ",
+ unit->fcp_lun,
+ unit->port->wwpn,
+ zfcp_get_busid_by_unit(unit));
+ fsf_req->status |= ZFCP_STATUS_FSFREQ_TMFUNCNOTSUPP;
+ break;
+ case RSP_CODE_TASKMAN_FAILED:
+ ZFCP_LOG_FLAGS(0, "RSP_CODE_TASKMAN_FAILED\n");
+ ZFCP_LOG_NORMAL("bug: A reuested task management function "
+ "failed to complete successfully. "
+ "unit 0x%016Lx, port 0x%016Lx, adapter %s.\n",
+ unit->fcp_lun,
+ unit->port->wwpn,
+ zfcp_get_busid_by_unit(unit));
+ fsf_req->status |= ZFCP_STATUS_FSFREQ_TMFUNCFAILED;
+ break;
+ default:
+ ZFCP_LOG_NORMAL("bug: An invalid FCP response "
+ "code was detected for a command. "
+ "unit 0x%016Lx, port 0x%016Lx, adapter %s "
+ "(debug info 0x%x)\n",
+ unit->fcp_lun,
+ unit->port->wwpn,
+ zfcp_get_busid_by_unit(unit),
+ fcp_rsp_info[3]);
+ fsf_req->status |= ZFCP_STATUS_FSFREQ_TMFUNCFAILED;
+ }
+
+ skip_fsfstatus:
+ return retval;
+}
+
+
+/*
+ * function: zfcp_fsf_control_file
+ *
+ * purpose: Initiator of the control file upload/download FSF requests
+ *
+ * returns: 0 - FSF request is successfuly created and queued
+ * -EOPNOTSUPP - The FCP adapter does not have Control File support
+ * -EINVAL - Invalid direction specified
+ * -ENOMEM - Insufficient memory
+ * -EPERM - Cannot create FSF request or place it in QDIO queue
+ */
+int
+zfcp_fsf_control_file(struct zfcp_adapter *adapter,
+ struct zfcp_fsf_req **fsf_req_ptr,
+ u32 fsf_command,
+ u32 option,
+ struct zfcp_sg_list *sg_list)
+{
+ struct zfcp_fsf_req *fsf_req;
+ struct fsf_qtcb_bottom_support *bottom;
+ volatile struct qdio_buffer_element *sbale;
+ struct timer_list *timer;
+ unsigned long lock_flags;
+ int req_flags = 0;
+ int direction;
+ int retval = 0;
+
+ if (!(adapter->supported_features & FSF_FEATURE_CFDC)) {
+ ZFCP_LOG_INFO("cfdc not supported (adapter %s)\n",
+ zfcp_get_busid_by_adapter(adapter));
+ retval = -EOPNOTSUPP;
+ goto out;
+ }
+
+ switch (fsf_command) {
+
+ case FSF_QTCB_DOWNLOAD_CONTROL_FILE:
+ direction = SBAL_FLAGS0_TYPE_WRITE;
+ if ((option != FSF_CFDC_OPTION_FULL_ACCESS) &&
+ (option != FSF_CFDC_OPTION_RESTRICTED_ACCESS))
+ req_flags = ZFCP_WAIT_FOR_SBAL;
+ break;
+
+ case FSF_QTCB_UPLOAD_CONTROL_FILE:
+ direction = SBAL_FLAGS0_TYPE_READ;
+ break;
+
+ default:
+ ZFCP_LOG_INFO("Invalid FSF command code 0x%08x\n", fsf_command);
+ retval = -EINVAL;
+ goto out;
+ }
+
+ timer = kmalloc(sizeof(struct timer_list), GFP_KERNEL);
+ if (!timer) {
+ retval = -ENOMEM;
+ goto out;
+ }
+
+ retval = zfcp_fsf_req_create(adapter, fsf_command, req_flags,
+ NULL, &lock_flags, &fsf_req);
+ if (retval < 0) {
+ ZFCP_LOG_INFO("error: Could not create FSF request for the "
+ "adapter %s\n",
+ zfcp_get_busid_by_adapter(adapter));
+ retval = -EPERM;
+ goto unlock_queue_lock;
+ }
+
+ sbale = zfcp_qdio_sbale_req(fsf_req, fsf_req->sbal_curr, 0);
+ sbale[0].flags |= direction;
+
+ bottom = &fsf_req->qtcb->bottom.support;
+ bottom->operation_subtype = FSF_CFDC_OPERATION_SUBTYPE;
+ bottom->option = option;
+
+ if (sg_list->count > 0) {
+ int bytes;
+
+ bytes = zfcp_qdio_sbals_from_sg(fsf_req, direction,
+ sg_list->sg, sg_list->count,
+ ZFCP_MAX_SBALS_PER_REQ);
+ if (bytes != ZFCP_CFDC_MAX_CONTROL_FILE_SIZE) {
+ ZFCP_LOG_INFO(
+ "error: Could not create sufficient number of "
+ "SBALS for an FSF request to the adapter %s\n",
+ zfcp_get_busid_by_adapter(adapter));
+ retval = -ENOMEM;
+ goto free_fsf_req;
+ }
+ } else
+ sbale[1].flags |= SBAL_FLAGS_LAST_ENTRY;
+
+ init_timer(timer);
+ timer->function = zfcp_fsf_request_timeout_handler;
+ timer->data = (unsigned long) adapter;
+ timer->expires = ZFCP_FSF_REQUEST_TIMEOUT;
+
+ retval = zfcp_fsf_req_send(fsf_req, timer);
+ if (retval < 0) {
+ ZFCP_LOG_INFO("initiation of cfdc up/download failed"
+ "(adapter %s)\n",
+ zfcp_get_busid_by_adapter(adapter));
+ retval = -EPERM;
+ goto free_fsf_req;
+ }
+ write_unlock_irqrestore(&adapter->request_queue.queue_lock, lock_flags);
+
+ ZFCP_LOG_NORMAL("Control file %s FSF request has been sent to the "
+ "adapter %s\n",
+ fsf_command == FSF_QTCB_DOWNLOAD_CONTROL_FILE ?
+ "download" : "upload",
+ zfcp_get_busid_by_adapter(adapter));
+
+ wait_event(fsf_req->completion_wq,
+ fsf_req->status & ZFCP_STATUS_FSFREQ_COMPLETED);
+
+ *fsf_req_ptr = fsf_req;
+ del_timer_sync(timer);
+ goto free_timer;
+
+ free_fsf_req:
+ zfcp_fsf_req_free(fsf_req);
+ unlock_queue_lock:
+ write_unlock_irqrestore(&adapter->request_queue.queue_lock, lock_flags);
+ free_timer:
+ kfree(timer);
+ out:
+ return retval;
+}
+
+
+/*
+ * function: zfcp_fsf_control_file_handler
+ *
+ * purpose: Handler of the control file upload/download FSF requests
+ *
+ * returns: 0 - FSF request successfuly processed
+ * -EAGAIN - Operation has to be repeated because of a temporary problem
+ * -EACCES - There is no permission to execute an operation
+ * -EPERM - The control file is not in a right format
+ * -EIO - There is a problem with the FCP adapter
+ * -EINVAL - Invalid operation
+ * -EFAULT - User space memory I/O operation fault
+ */
+static int
+zfcp_fsf_control_file_handler(struct zfcp_fsf_req *fsf_req)
+{
+ struct zfcp_adapter *adapter = fsf_req->adapter;
+ struct fsf_qtcb_header *header = &fsf_req->qtcb->header;
+ struct fsf_qtcb_bottom_support *bottom = &fsf_req->qtcb->bottom.support;
+ int retval = 0;
+
+ if (fsf_req->status & ZFCP_STATUS_FSFREQ_ERROR) {
+ retval = -EINVAL;
+ goto skip_fsfstatus;
+ }
+
+ switch (header->fsf_status) {
+
+ case FSF_GOOD:
+ ZFCP_LOG_FLAGS(2, "FSF_GOOD\n");
+ ZFCP_LOG_NORMAL(
+ "The FSF request has been successfully completed "
+ "on the adapter %s\n",
+ zfcp_get_busid_by_adapter(adapter));
+ break;
+
+ case FSF_OPERATION_PARTIALLY_SUCCESSFUL:
+ ZFCP_LOG_FLAGS(2, "FSF_OPERATION_PARTIALLY_SUCCESSFUL\n");
+ if (bottom->operation_subtype == FSF_CFDC_OPERATION_SUBTYPE) {
+ switch (header->fsf_status_qual.word[0]) {
+
+ case FSF_SQ_CFDC_COULD_NOT_HARDEN_ON_SE:
+ ZFCP_LOG_NORMAL(
+ "CFDC of the adapter %s could not "
+ "be saved on the SE\n",
+ zfcp_get_busid_by_adapter(adapter));
+ break;
+
+ case FSF_SQ_CFDC_COULD_NOT_HARDEN_ON_SE2:
+ ZFCP_LOG_NORMAL(
+ "CFDC of the adapter %s could not "
+ "be copied to the secondary SE\n",
+ zfcp_get_busid_by_adapter(adapter));
+ break;
+
+ default:
+ ZFCP_LOG_NORMAL(
+ "CFDC could not be hardened "
+ "on the adapter %s\n",
+ zfcp_get_busid_by_adapter(adapter));
+ }
+ }
+ fsf_req->status |= ZFCP_STATUS_FSFREQ_ERROR;
+ retval = -EAGAIN;
+ break;
+
+ case FSF_AUTHORIZATION_FAILURE:
+ ZFCP_LOG_FLAGS(2, "FSF_AUTHORIZATION_FAILURE\n");
+ ZFCP_LOG_NORMAL(
+ "Adapter %s does not accept privileged commands\n",
+ zfcp_get_busid_by_adapter(adapter));
+ fsf_req->status |= ZFCP_STATUS_FSFREQ_ERROR;
+ retval = -EACCES;
+ break;
+
+ case FSF_CFDC_ERROR_DETECTED:
+ ZFCP_LOG_FLAGS(2, "FSF_CFDC_ERROR_DETECTED\n");
+ ZFCP_LOG_NORMAL(
+ "Error at position %d in the CFDC, "
+ "CFDC is discarded by the adapter %s\n",
+ header->fsf_status_qual.word[0],
+ zfcp_get_busid_by_adapter(adapter));
+ fsf_req->status |= ZFCP_STATUS_FSFREQ_ERROR;
+ retval = -EPERM;
+ break;
+
+ case FSF_CONTROL_FILE_UPDATE_ERROR:
+ ZFCP_LOG_FLAGS(2, "FSF_CONTROL_FILE_UPDATE_ERROR\n");
+ ZFCP_LOG_NORMAL(
+ "Adapter %s cannot harden the control file, "
+ "file is discarded\n",
+ zfcp_get_busid_by_adapter(adapter));
+ fsf_req->status |= ZFCP_STATUS_FSFREQ_ERROR;
+ retval = -EIO;
+ break;
+
+ case FSF_CONTROL_FILE_TOO_LARGE:
+ ZFCP_LOG_FLAGS(2, "FSF_CONTROL_FILE_TOO_LARGE\n");
+ ZFCP_LOG_NORMAL(
+ "Control file is too large, file is discarded "
+ "by the adapter %s\n",
+ zfcp_get_busid_by_adapter(adapter));
+ fsf_req->status |= ZFCP_STATUS_FSFREQ_ERROR;
+ retval = -EIO;
+ break;
+
+ case FSF_ACCESS_CONFLICT_DETECTED:
+ ZFCP_LOG_FLAGS(2, "FSF_ACCESS_CONFLICT_DETECTED\n");
+ if (bottom->operation_subtype == FSF_CFDC_OPERATION_SUBTYPE)
+ ZFCP_LOG_NORMAL(
+ "CFDC has been discarded by the adapter %s, "
+ "because activation would impact "
+ "%d active connection(s)\n",
+ zfcp_get_busid_by_adapter(adapter),
+ header->fsf_status_qual.word[0]);
+ fsf_req->status |= ZFCP_STATUS_FSFREQ_ERROR;
+ retval = -EIO;
+ break;
+
+ case FSF_CONFLICTS_OVERRULED:
+ ZFCP_LOG_FLAGS(2, "FSF_CONFLICTS_OVERRULED\n");
+ if (bottom->operation_subtype == FSF_CFDC_OPERATION_SUBTYPE)
+ ZFCP_LOG_NORMAL(
+ "CFDC has been activated on the adapter %s, "
+ "but activation has impacted "
+ "%d active connection(s)\n",
+ zfcp_get_busid_by_adapter(adapter),
+ header->fsf_status_qual.word[0]);
+ fsf_req->status |= ZFCP_STATUS_FSFREQ_ERROR;
+ retval = -EIO;
+ break;
+
+ case FSF_UNKNOWN_OP_SUBTYPE:
+ ZFCP_LOG_FLAGS(2, "FSF_UNKNOWN_OP_SUBTYPE\n");
+ ZFCP_LOG_NORMAL("unknown operation subtype (adapter: %s, "
+ "op_subtype=0x%x)\n",
+ zfcp_get_busid_by_adapter(adapter),
+ bottom->operation_subtype);
+ fsf_req->status |= ZFCP_STATUS_FSFREQ_ERROR;
+ retval = -EINVAL;
+ break;
+
+ case FSF_INVALID_COMMAND_OPTION:
+ ZFCP_LOG_FLAGS(2, "FSF_INVALID_COMMAND_OPTION\n");
+ ZFCP_LOG_NORMAL(
+ "Invalid option 0x%x has been specified "
+ "in QTCB bottom sent to the adapter %s\n",
+ bottom->option,
+ zfcp_get_busid_by_adapter(adapter));
+ fsf_req->status |= ZFCP_STATUS_FSFREQ_ERROR;
+ retval = -EINVAL;
+ break;
+
+ default:
+ ZFCP_LOG_NORMAL(
+ "bug: An unknown/unexpected FSF status 0x%08x "
+ "was presented on the adapter %s\n",
+ header->fsf_status,
+ zfcp_get_busid_by_adapter(adapter));
+ debug_text_event(fsf_req->adapter->erp_dbf, 0, "fsf_sq_inval");
+ debug_exception(fsf_req->adapter->erp_dbf, 0,
+ &header->fsf_status_qual.word[0], sizeof(u32));
+ fsf_req->status |= ZFCP_STATUS_FSFREQ_ERROR;
+ retval = -EINVAL;
+ break;
+ }
+
+skip_fsfstatus:
+ return retval;
+}
+
+
+/*
+ * function: zfcp_fsf_req_wait_and_cleanup
+ *
+ * purpose:
+ *
+ * FIXME(design): signal seems to be <0 !!!
+ * returns: 0 - request completed (*status is valid), cleanup succ.
+ * <0 - request completed (*status is valid), cleanup failed
+ * >0 - signal which interrupted waiting (*status invalid),
+ * request not completed, no cleanup
+ *
+ * *status is a copy of status of completed fsf_req
+ */
+int
+zfcp_fsf_req_wait_and_cleanup(struct zfcp_fsf_req *fsf_req,
+ int interruptible, u32 * status)
+{
+ int retval = 0;
+ int signal = 0;
+
+ if (interruptible) {
+ __wait_event_interruptible(fsf_req->completion_wq,
+ fsf_req->status &
+ ZFCP_STATUS_FSFREQ_COMPLETED,
+ signal);
+ if (signal) {
+ ZFCP_LOG_DEBUG("Caught signal %i while waiting for the "
+ "completion of the request at %p\n",
+ signal, fsf_req);
+ retval = signal;
+ goto out;
+ }
+ } else {
+ __wait_event(fsf_req->completion_wq,
+ fsf_req->status & ZFCP_STATUS_FSFREQ_COMPLETED);
+ }
+
+ *status = fsf_req->status;
+
+ /* cleanup request */
+ zfcp_fsf_req_cleanup(fsf_req);
+ out:
+ return retval;
+}
+
+static inline int
+zfcp_fsf_req_sbal_check(unsigned long *flags,
+ struct zfcp_qdio_queue *queue, int needed)
+{
+ write_lock_irqsave(&queue->queue_lock, *flags);
+ if (likely(atomic_read(&queue->free_count) >= needed))
+ return 1;
+ write_unlock_irqrestore(&queue->queue_lock, *flags);
+ return 0;
+}
+
+/*
+ * set qtcb pointer in fsf_req and initialize QTCB
+ */
+static inline void
+zfcp_fsf_req_qtcb_init(struct zfcp_fsf_req *fsf_req, u32 fsf_cmd)
+{
+ if (likely(fsf_req->qtcb != NULL)) {
+ fsf_req->qtcb->prefix.req_id = (unsigned long)fsf_req;
+ fsf_req->qtcb->prefix.ulp_info = ZFCP_ULP_INFO_VERSION;
+ fsf_req->qtcb->prefix.qtcb_type = fsf_qtcb_type[fsf_cmd];
+ fsf_req->qtcb->prefix.qtcb_version = ZFCP_QTCB_VERSION;
+ fsf_req->qtcb->header.req_handle = (unsigned long)fsf_req;
+ fsf_req->qtcb->header.fsf_command = fsf_cmd;
+ }
+}
+
+/**
+ * zfcp_fsf_req_sbal_get - try to get one SBAL in the request queue
+ * @adapter: adapter for which request queue is examined
+ * @req_flags: flags indicating whether to wait for needed SBAL or not
+ * @lock_flags: lock_flags if queue_lock is taken
+ * Return: 0 on success, otherwise -EIO, or -ERESTARTSYS
+ * Locks: lock adapter->request_queue->queue_lock on success
+ */
+static int
+zfcp_fsf_req_sbal_get(struct zfcp_adapter *adapter, int req_flags,
+ unsigned long *lock_flags)
+{
+ long ret;
+ struct zfcp_qdio_queue *req_queue = &adapter->request_queue;
+
+ if (unlikely(req_flags & ZFCP_WAIT_FOR_SBAL)) {
+ ret = wait_event_interruptible_timeout(adapter->request_wq,
+ zfcp_fsf_req_sbal_check(lock_flags, req_queue, 1),
+ ZFCP_SBAL_TIMEOUT);
+ if (ret < 0)
+ return ret;
+ if (!ret)
+ return -EIO;
+ } else if (!zfcp_fsf_req_sbal_check(lock_flags, req_queue, 1))
+ return -EIO;
+
+ return 0;
+}
+
+/*
+ * function: zfcp_fsf_req_create
+ *
+ * purpose: create an FSF request at the specified adapter and
+ * setup common fields
+ *
+ * returns: -ENOMEM if there was insufficient memory for a request
+ * -EIO if no qdio buffers could be allocate to the request
+ * -EINVAL/-EPERM on bug conditions in req_dequeue
+ * 0 in success
+ *
+ * note: The created request is returned by reference.
+ *
+ * locks: lock of concerned request queue must not be held,
+ * but is held on completion (write, irqsave)
+ */
+int
+zfcp_fsf_req_create(struct zfcp_adapter *adapter, u32 fsf_cmd, int req_flags,
+ mempool_t *pool, unsigned long *lock_flags,
+ struct zfcp_fsf_req **fsf_req_p)
+{
+ volatile struct qdio_buffer_element *sbale;
+ struct zfcp_fsf_req *fsf_req = NULL;
+ int ret = 0;
+ struct zfcp_qdio_queue *req_queue = &adapter->request_queue;
+
+ /* allocate new FSF request */
+ fsf_req = zfcp_fsf_req_alloc(pool, req_flags);
+ if (unlikely(NULL == fsf_req)) {
+ ZFCP_LOG_DEBUG("error: Could not put an FSF request into"
+ "the outbound (send) queue.\n");
+ ret = -ENOMEM;
+ goto failed_fsf_req;
+ }
+
+ zfcp_fsf_req_qtcb_init(fsf_req, fsf_cmd);
+
+ /* initialize waitqueue which may be used to wait on
+ this request completion */
+ init_waitqueue_head(&fsf_req->completion_wq);
+
+ ret = zfcp_fsf_req_sbal_get(adapter, req_flags, lock_flags);
+ if(ret < 0) {
+ goto failed_sbals;
+ }
+
+ /*
+ * We hold queue_lock here. Check if QDIOUP is set and let request fail
+ * if it is not set (see also *_open_qdio and *_close_qdio).
+ */
+
+ if (!atomic_test_mask(ZFCP_STATUS_ADAPTER_QDIOUP, &adapter->status)) {
+ write_unlock_irqrestore(&req_queue->queue_lock, *lock_flags);
+ ret = -EIO;
+ goto failed_sbals;
+ }
+
+ fsf_req->adapter = adapter; /* pointer to "parent" adapter */
+ fsf_req->fsf_command = fsf_cmd;
+ fsf_req->sbal_number = 1;
+ fsf_req->sbal_first = req_queue->free_index;
+ fsf_req->sbal_curr = req_queue->free_index;
+ fsf_req->sbale_curr = 1;
+
+ if (likely(req_flags & ZFCP_REQ_AUTO_CLEANUP)) {
+ fsf_req->status |= ZFCP_STATUS_FSFREQ_CLEANUP;
+ }
+
+ sbale = zfcp_qdio_sbale_req(fsf_req, fsf_req->sbal_curr, 0);
+
+ /* setup common SBALE fields */
+ sbale[0].addr = fsf_req;
+ sbale[0].flags |= SBAL_FLAGS0_COMMAND;
+ if (likely(fsf_req->qtcb != NULL)) {
+ sbale[1].addr = (void *) fsf_req->qtcb;
+ sbale[1].length = sizeof(struct fsf_qtcb);
+ }
+
+ ZFCP_LOG_TRACE("got %i free BUFFERs starting at index %i\n",
+ fsf_req->sbal_number, fsf_req->sbal_first);
+
+ goto success;
+
+ failed_sbals:
+/* dequeue new FSF request previously enqueued */
+ zfcp_fsf_req_free(fsf_req);
+ fsf_req = NULL;
+
+ failed_fsf_req:
+ write_lock_irqsave(&req_queue->queue_lock, *lock_flags);
+ success:
+ *fsf_req_p = fsf_req;
+ return ret;
+}
+
+/*
+ * function: zfcp_fsf_req_send
+ *
+ * purpose: start transfer of FSF request via QDIO
+ *
+ * returns: 0 - request transfer succesfully started
+ * !0 - start of request transfer failed
+ */
+static int
+zfcp_fsf_req_send(struct zfcp_fsf_req *fsf_req, struct timer_list *timer)
+{
+ struct zfcp_adapter *adapter;
+ struct zfcp_qdio_queue *req_queue;
+ volatile struct qdio_buffer_element *sbale;
+ int new_distance_from_int;
+ unsigned long flags;
+ int inc_seq_no = 1;
+ int retval = 0;
+
+ adapter = fsf_req->adapter;
+ req_queue = &adapter->request_queue,
+
+
+ /* FIXME(debug): remove it later */
+ sbale = zfcp_qdio_sbale_req(fsf_req, fsf_req->sbal_first, 0);
+ ZFCP_LOG_DEBUG("SBALE0 flags=0x%x\n", sbale[0].flags);
+ ZFCP_LOG_TRACE("HEX DUMP OF SBALE1 PAYLOAD:\n");
+ ZFCP_HEX_DUMP(ZFCP_LOG_LEVEL_TRACE, (char *) sbale[1].addr,
+ sbale[1].length);
+
+ /* set sequence counter in QTCB */
+ if (likely(fsf_req->qtcb)) {
+ fsf_req->qtcb->prefix.req_seq_no = adapter->fsf_req_seq_no;
+ fsf_req->seq_no = adapter->fsf_req_seq_no;
+ ZFCP_LOG_TRACE("FSF request %p of adapter %s gets "
+ "FSF sequence counter value of %i\n",
+ fsf_req,
+ zfcp_get_busid_by_adapter(adapter),
+ fsf_req->qtcb->prefix.req_seq_no);
+ } else
+ inc_seq_no = 0;
+
+ /* put allocated FSF request at list tail */
+ write_lock_irqsave(&adapter->fsf_req_list_lock, flags);
+ list_add_tail(&fsf_req->list, &adapter->fsf_req_list_head);
+ write_unlock_irqrestore(&adapter->fsf_req_list_lock, flags);
+
+ /* figure out expiration time of timeout and start timeout */
+ if (unlikely(timer)) {
+ timer->expires += jiffies;
+ add_timer(timer);
+ }
+
+ ZFCP_LOG_TRACE("request queue of adapter %s: "
+ "next free SBAL is %i, %i free SBALs\n",
+ zfcp_get_busid_by_adapter(adapter),
+ req_queue->free_index,
+ atomic_read(&req_queue->free_count));
+
+ ZFCP_LOG_DEBUG("calling do_QDIO adapter %s, flags=0x%x, queue_no=%i, "
+ "index_in_queue=%i, count=%i, buffers=%p\n",
+ zfcp_get_busid_by_adapter(adapter),
+ QDIO_FLAG_SYNC_OUTPUT,
+ 0, fsf_req->sbal_first, fsf_req->sbal_number,
+ &req_queue->buffer[fsf_req->sbal_first]);
+
+ /*
+ * adjust the number of free SBALs in request queue as well as
+ * position of first one
+ */
+ atomic_sub(fsf_req->sbal_number, &req_queue->free_count);
+ ZFCP_LOG_TRACE("free_count=%d\n", atomic_read(&req_queue->free_count));
+ req_queue->free_index += fsf_req->sbal_number; /* increase */
+ req_queue->free_index %= QDIO_MAX_BUFFERS_PER_Q; /* wrap if needed */
+ new_distance_from_int = zfcp_qdio_determine_pci(req_queue, fsf_req);
+
+ retval = do_QDIO(adapter->ccw_device,
+ QDIO_FLAG_SYNC_OUTPUT,
+ 0, fsf_req->sbal_first, fsf_req->sbal_number, NULL);
+
+ if (unlikely(retval)) {
+ /* Queues are down..... */
+ retval = -EIO;
+ /*
+ * FIXME(potential race):
+ * timer might be expired (absolutely unlikely)
+ */
+ if (timer)
+ del_timer(timer);
+ write_lock_irqsave(&adapter->fsf_req_list_lock, flags);
+ list_del(&fsf_req->list);
+ write_unlock_irqrestore(&adapter->fsf_req_list_lock, flags);
+ /*
+ * adjust the number of free SBALs in request queue as well as
+ * position of first one
+ */
+ zfcp_qdio_zero_sbals(req_queue->buffer,
+ fsf_req->sbal_first, fsf_req->sbal_number);
+ atomic_add(fsf_req->sbal_number, &req_queue->free_count);
+ req_queue->free_index -= fsf_req->sbal_number; /* increase */
+ req_queue->free_index += QDIO_MAX_BUFFERS_PER_Q;
+ req_queue->free_index %= QDIO_MAX_BUFFERS_PER_Q; /* wrap */
+ ZFCP_LOG_DEBUG
+ ("error: do_QDIO failed. Buffers could not be enqueued "
+ "to request queue.\n");
+ } else {
+ req_queue->distance_from_int = new_distance_from_int;
+ /*
+ * increase FSF sequence counter -
+ * this must only be done for request successfully enqueued to
+ * QDIO this rejected requests may be cleaned up by calling
+ * routines resulting in missing sequence counter values
+ * otherwise,
+ */
+ /* Don't increase for unsolicited status */
+ if (likely(inc_seq_no)) {
+ adapter->fsf_req_seq_no++;
+ ZFCP_LOG_TRACE
+ ("FSF sequence counter value of adapter %s "
+ "increased to %i\n",
+ zfcp_get_busid_by_adapter(adapter),
+ adapter->fsf_req_seq_no);
+ }
+ /* count FSF requests pending */
+ atomic_inc(&adapter->fsf_reqs_active);
+ }
+ return retval;
+}
+
+/*
+ * function: zfcp_fsf_req_cleanup
+ *
+ * purpose: cleans up an FSF request and removes it from the specified list
+ *
+ * returns:
+ *
+ * assumption: no pending SB in SBALEs other than QTCB
+ */
+void
+zfcp_fsf_req_cleanup(struct zfcp_fsf_req *fsf_req)
+{
+ struct zfcp_adapter *adapter = fsf_req->adapter;
+ unsigned long flags;
+
+ write_lock_irqsave(&adapter->fsf_req_list_lock, flags);
+ list_del(&fsf_req->list);
+ write_unlock_irqrestore(&adapter->fsf_req_list_lock, flags);
+ zfcp_fsf_req_free(fsf_req);
+}
+
+#undef ZFCP_LOG_AREA
diff --git a/drivers/s390/scsi/zfcp_fsf.h b/drivers/s390/scsi/zfcp_fsf.h
new file mode 100644
index 0000000..5889956
--- /dev/null
+++ b/drivers/s390/scsi/zfcp_fsf.h
@@ -0,0 +1,472 @@
+/*
+ *
+ * linux/drivers/s390/scsi/zfcp_fsf.h
+ *
+ * FCP adapter driver for IBM eServer zSeries
+ *
+ * (C) Copyright IBM Corp. 2002, 2004
+ *
+ * Author(s): Martin Peschke <mpeschke@de.ibm.com>
+ * Raimund Schroeder <raimund.schroeder@de.ibm.com>
+ * Aron Zeh
+ * Wolfgang Taphorn
+ * Stefan Bader <stefan.bader@de.ibm.com>
+ * Heiko Carstens <heiko.carstens@de.ibm.com>
+ * Andreas Herrmann <aherrman@de.ibm.com>
+ * Volker Sameske <sameske@de.ibm.com>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2, or (at your option)
+ * any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#ifndef FSF_H
+#define FSF_H
+
+#define FSF_QTCB_VERSION1 0x00000001
+#define FSF_QTCB_CURRENT_VERSION FSF_QTCB_VERSION1
+
+/* FSF commands */
+#define FSF_QTCB_FCP_CMND 0x00000001
+#define FSF_QTCB_ABORT_FCP_CMND 0x00000002
+#define FSF_QTCB_OPEN_PORT_WITH_DID 0x00000005
+#define FSF_QTCB_OPEN_LUN 0x00000006
+#define FSF_QTCB_CLOSE_LUN 0x00000007
+#define FSF_QTCB_CLOSE_PORT 0x00000008
+#define FSF_QTCB_CLOSE_PHYSICAL_PORT 0x00000009
+#define FSF_QTCB_SEND_ELS 0x0000000B
+#define FSF_QTCB_SEND_GENERIC 0x0000000C
+#define FSF_QTCB_EXCHANGE_CONFIG_DATA 0x0000000D
+#define FSF_QTCB_EXCHANGE_PORT_DATA 0x0000000E
+#define FSF_QTCB_DOWNLOAD_CONTROL_FILE 0x00000012
+#define FSF_QTCB_UPLOAD_CONTROL_FILE 0x00000013
+
+/* FSF QTCB types */
+#define FSF_IO_COMMAND 0x00000001
+#define FSF_SUPPORT_COMMAND 0x00000002
+#define FSF_CONFIG_COMMAND 0x00000003
+#define FSF_PORT_COMMAND 0x00000004
+
+/* FSF control file upload/download operations' subtype and options */
+#define FSF_CFDC_OPERATION_SUBTYPE 0x00020001
+#define FSF_CFDC_OPTION_NORMAL_MODE 0x00000000
+#define FSF_CFDC_OPTION_FORCE 0x00000001
+#define FSF_CFDC_OPTION_FULL_ACCESS 0x00000002
+#define FSF_CFDC_OPTION_RESTRICTED_ACCESS 0x00000004
+
+/* FSF protocol stati */
+#define FSF_PROT_GOOD 0x00000001
+#define FSF_PROT_QTCB_VERSION_ERROR 0x00000010
+#define FSF_PROT_SEQ_NUMB_ERROR 0x00000020
+#define FSF_PROT_UNSUPP_QTCB_TYPE 0x00000040
+#define FSF_PROT_HOST_CONNECTION_INITIALIZING 0x00000080
+#define FSF_PROT_FSF_STATUS_PRESENTED 0x00000100
+#define FSF_PROT_DUPLICATE_REQUEST_ID 0x00000200
+#define FSF_PROT_LINK_DOWN 0x00000400
+#define FSF_PROT_REEST_QUEUE 0x00000800
+#define FSF_PROT_ERROR_STATE 0x01000000
+
+/* FSF stati */
+#define FSF_GOOD 0x00000000
+#define FSF_PORT_ALREADY_OPEN 0x00000001
+#define FSF_LUN_ALREADY_OPEN 0x00000002
+#define FSF_PORT_HANDLE_NOT_VALID 0x00000003
+#define FSF_LUN_HANDLE_NOT_VALID 0x00000004
+#define FSF_HANDLE_MISMATCH 0x00000005
+#define FSF_SERVICE_CLASS_NOT_SUPPORTED 0x00000006
+#define FSF_FCPLUN_NOT_VALID 0x00000009
+#define FSF_ACCESS_DENIED 0x00000010
+#define FSF_LUN_SHARING_VIOLATION 0x00000012
+#define FSF_FCP_COMMAND_DOES_NOT_EXIST 0x00000022
+#define FSF_DIRECTION_INDICATOR_NOT_VALID 0x00000030
+#define FSF_CMND_LENGTH_NOT_VALID 0x00000033
+#define FSF_MAXIMUM_NUMBER_OF_PORTS_EXCEEDED 0x00000040
+#define FSF_MAXIMUM_NUMBER_OF_LUNS_EXCEEDED 0x00000041
+#define FSF_ELS_COMMAND_REJECTED 0x00000050
+#define FSF_GENERIC_COMMAND_REJECTED 0x00000051
+#define FSF_OPERATION_PARTIALLY_SUCCESSFUL 0x00000052
+#define FSF_AUTHORIZATION_FAILURE 0x00000053
+#define FSF_CFDC_ERROR_DETECTED 0x00000054
+#define FSF_CONTROL_FILE_UPDATE_ERROR 0x00000055
+#define FSF_CONTROL_FILE_TOO_LARGE 0x00000056
+#define FSF_ACCESS_CONFLICT_DETECTED 0x00000057
+#define FSF_CONFLICTS_OVERRULED 0x00000058
+#define FSF_PORT_BOXED 0x00000059
+#define FSF_LUN_BOXED 0x0000005A
+#define FSF_EXCHANGE_CONFIG_DATA_INCOMPLETE 0x0000005B
+#define FSF_PAYLOAD_SIZE_MISMATCH 0x00000060
+#define FSF_REQUEST_SIZE_TOO_LARGE 0x00000061
+#define FSF_RESPONSE_SIZE_TOO_LARGE 0x00000062
+#define FSF_SBAL_MISMATCH 0x00000063
+#define FSF_OPEN_PORT_WITHOUT_PRLI 0x00000064
+#define FSF_ADAPTER_STATUS_AVAILABLE 0x000000AD
+#define FSF_FCP_RSP_AVAILABLE 0x000000AF
+#define FSF_UNKNOWN_COMMAND 0x000000E2
+#define FSF_UNKNOWN_OP_SUBTYPE 0x000000E3
+#define FSF_INVALID_COMMAND_OPTION 0x000000E5
+/* #define FSF_ERROR 0x000000FF */
+
+#define FSF_STATUS_QUALIFIER_SIZE 16
+
+/* FSF status qualifier, recommendations */
+#define FSF_SQ_NO_RECOM 0x00
+#define FSF_SQ_FCP_RSP_AVAILABLE 0x01
+#define FSF_SQ_RETRY_IF_POSSIBLE 0x02
+#define FSF_SQ_ULP_DEPENDENT_ERP_REQUIRED 0x03
+#define FSF_SQ_INVOKE_LINK_TEST_PROCEDURE 0x04
+#define FSF_SQ_ULP_PROGRAMMING_ERROR 0x05
+#define FSF_SQ_COMMAND_ABORTED 0x06
+#define FSF_SQ_NO_RETRY_POSSIBLE 0x07
+
+/* FSF status qualifier for CFDC commands */
+#define FSF_SQ_CFDC_COULD_NOT_HARDEN_ON_SE 0x00000001
+#define FSF_SQ_CFDC_COULD_NOT_HARDEN_ON_SE2 0x00000002
+/* CFDC subtable codes */
+#define FSF_SQ_CFDC_SUBTABLE_OS 0x0001
+#define FSF_SQ_CFDC_SUBTABLE_PORT_WWPN 0x0002
+#define FSF_SQ_CFDC_SUBTABLE_PORT_DID 0x0003
+#define FSF_SQ_CFDC_SUBTABLE_LUN 0x0004
+
+/* FSF status qualifier (most significant 4 bytes), local link down */
+#define FSF_PSQ_LINK_NOLIGHT 0x00000004
+#define FSF_PSQ_LINK_WRAPPLUG 0x00000008
+#define FSF_PSQ_LINK_NOFCP 0x00000010
+
+/* payload size in status read buffer */
+#define FSF_STATUS_READ_PAYLOAD_SIZE 4032
+
+/* number of status read buffers that should be sent by ULP */
+#define FSF_STATUS_READS_RECOM 16
+
+/* status types in status read buffer */
+#define FSF_STATUS_READ_PORT_CLOSED 0x00000001
+#define FSF_STATUS_READ_INCOMING_ELS 0x00000002
+#define FSF_STATUS_READ_SENSE_DATA_AVAIL 0x00000003
+#define FSF_STATUS_READ_BIT_ERROR_THRESHOLD 0x00000004
+#define FSF_STATUS_READ_LINK_DOWN 0x00000005 /* FIXME: really? */
+#define FSF_STATUS_READ_LINK_UP 0x00000006
+#define FSF_STATUS_READ_CFDC_UPDATED 0x0000000A
+#define FSF_STATUS_READ_CFDC_HARDENED 0x0000000B
+
+/* status subtypes in status read buffer */
+#define FSF_STATUS_READ_SUB_CLOSE_PHYS_PORT 0x00000001
+#define FSF_STATUS_READ_SUB_ERROR_PORT 0x00000002
+
+/* status subtypes for CFDC */
+#define FSF_STATUS_READ_SUB_CFDC_HARDENED_ON_SE 0x00000002
+#define FSF_STATUS_READ_SUB_CFDC_HARDENED_ON_SE2 0x0000000F
+
+/* topologie that is detected by the adapter */
+#define FSF_TOPO_ERROR 0x00000000
+#define FSF_TOPO_P2P 0x00000001
+#define FSF_TOPO_FABRIC 0x00000002
+#define FSF_TOPO_AL 0x00000003
+#define FSF_TOPO_FABRIC_VIRT 0x00000004
+
+/* data direction for FCP commands */
+#define FSF_DATADIR_WRITE 0x00000001
+#define FSF_DATADIR_READ 0x00000002
+#define FSF_DATADIR_READ_WRITE 0x00000003
+#define FSF_DATADIR_CMND 0x00000004
+
+/* fc service class */
+#define FSF_CLASS_1 0x00000001
+#define FSF_CLASS_2 0x00000002
+#define FSF_CLASS_3 0x00000003
+
+/* SBAL chaining */
+#define FSF_MAX_SBALS_PER_REQ 36
+#define FSF_MAX_SBALS_PER_ELS_REQ 2
+
+/* logging space behind QTCB */
+#define FSF_QTCB_LOG_SIZE 1024
+
+/* channel features */
+#define FSF_FEATURE_QTCB_SUPPRESSION 0x00000001
+#define FSF_FEATURE_CFDC 0x00000002
+#define FSF_FEATURE_LUN_SHARING 0x00000004
+#define FSF_FEATURE_HBAAPI_MANAGEMENT 0x00000010
+#define FSF_FEATURE_ELS_CT_CHAINED_SBALS 0x00000020
+
+/* option */
+#define FSF_OPEN_LUN_SUPPRESS_BOXING 0x00000001
+#define FSF_OPEN_LUN_REPLICATE_SENSE 0x00000002
+
+/* adapter types */
+#define FSF_ADAPTER_TYPE_FICON 0x00000001
+#define FSF_ADAPTER_TYPE_FICON_EXPRESS 0x00000002
+
+/* port types */
+#define FSF_HBA_PORTTYPE_UNKNOWN 0x00000001
+#define FSF_HBA_PORTTYPE_NOTPRESENT 0x00000003
+#define FSF_HBA_PORTTYPE_NPORT 0x00000005
+#define FSF_HBA_PORTTYPE_PTP 0x00000021
+/* following are not defined and used by FSF Spec
+ but are additionally defined by FC-HBA */
+#define FSF_HBA_PORTTYPE_OTHER 0x00000002
+#define FSF_HBA_PORTTYPE_NOTPRESENT 0x00000003
+#define FSF_HBA_PORTTYPE_NLPORT 0x00000006
+#define FSF_HBA_PORTTYPE_FLPORT 0x00000007
+#define FSF_HBA_PORTTYPE_FPORT 0x00000008
+#define FSF_HBA_PORTTYPE_LPORT 0x00000020
+
+/* port states */
+#define FSF_HBA_PORTSTATE_UNKNOWN 0x00000001
+#define FSF_HBA_PORTSTATE_ONLINE 0x00000002
+#define FSF_HBA_PORTSTATE_OFFLINE 0x00000003
+#define FSF_HBA_PORTSTATE_LINKDOWN 0x00000006
+#define FSF_HBA_PORTSTATE_ERROR 0x00000007
+
+/* IO states of adapter */
+#define FSF_IOSTAT_NPORT_RJT 0x00000004
+#define FSF_IOSTAT_FABRIC_RJT 0x00000005
+#define FSF_IOSTAT_LS_RJT 0x00000009
+
+/* open LUN access flags*/
+#define FSF_UNIT_ACCESS_OPEN_LUN_ALLOWED 0x01000000
+#define FSF_UNIT_ACCESS_EXCLUSIVE 0x02000000
+#define FSF_UNIT_ACCESS_OUTBOUND_TRANSFER 0x10000000
+
+struct fsf_queue_designator;
+struct fsf_status_read_buffer;
+struct fsf_port_closed_payload;
+struct fsf_bit_error_payload;
+union fsf_prot_status_qual;
+struct fsf_qual_version_error;
+struct fsf_qual_sequence_error;
+struct fsf_qtcb_prefix;
+struct fsf_qtcb_header;
+struct fsf_qtcb_bottom_config;
+struct fsf_qtcb_bottom_support;
+struct fsf_qtcb_bottom_io;
+union fsf_qtcb_bottom;
+
+struct fsf_queue_designator {
+ u8 cssid;
+ u8 chpid;
+ u8 hla;
+ u8 ua;
+ u32 res1;
+} __attribute__ ((packed));
+
+struct fsf_port_closed_payload {
+ struct fsf_queue_designator queue_designator;
+ u32 port_handle;
+} __attribute__ ((packed));
+
+struct fsf_bit_error_payload {
+ u32 res1;
+ u32 link_failure_error_count;
+ u32 loss_of_sync_error_count;
+ u32 loss_of_signal_error_count;
+ u32 primitive_sequence_error_count;
+ u32 invalid_transmission_word_error_count;
+ u32 crc_error_count;
+ u32 primitive_sequence_event_timeout_count;
+ u32 elastic_buffer_overrun_error_count;
+ u32 fcal_arbitration_timeout_count;
+ u32 advertised_receive_b2b_credit;
+ u32 current_receive_b2b_credit;
+ u32 advertised_transmit_b2b_credit;
+ u32 current_transmit_b2b_credit;
+} __attribute__ ((packed));
+
+struct fsf_status_read_buffer {
+ u32 status_type;
+ u32 status_subtype;
+ u32 length;
+ u32 res1;
+ struct fsf_queue_designator queue_designator;
+ u32 d_id;
+ u32 class;
+ u64 fcp_lun;
+ u8 res3[24];
+ u8 payload[FSF_STATUS_READ_PAYLOAD_SIZE];
+} __attribute__ ((packed));
+
+struct fsf_qual_version_error {
+ u32 fsf_version;
+ u32 res1[3];
+} __attribute__ ((packed));
+
+struct fsf_qual_sequence_error {
+ u32 exp_req_seq_no;
+ u32 res1[3];
+} __attribute__ ((packed));
+
+struct fsf_qual_locallink_error {
+ u32 code;
+ u32 res1[3];
+} __attribute__ ((packed));
+
+union fsf_prot_status_qual {
+ struct fsf_qual_version_error version_error;
+ struct fsf_qual_sequence_error sequence_error;
+ struct fsf_qual_locallink_error locallink_error;
+} __attribute__ ((packed));
+
+struct fsf_qtcb_prefix {
+ u64 req_id;
+ u32 qtcb_version;
+ u32 ulp_info;
+ u32 qtcb_type;
+ u32 req_seq_no;
+ u32 prot_status;
+ union fsf_prot_status_qual prot_status_qual;
+ u8 res1[20];
+} __attribute__ ((packed));
+
+union fsf_status_qual {
+ u8 byte[FSF_STATUS_QUALIFIER_SIZE];
+ u16 halfword[FSF_STATUS_QUALIFIER_SIZE / sizeof (u16)];
+ u32 word[FSF_STATUS_QUALIFIER_SIZE / sizeof (u32)];
+ struct fsf_queue_designator fsf_queue_designator;
+} __attribute__ ((packed));
+
+struct fsf_qtcb_header {
+ u64 req_handle;
+ u32 fsf_command;
+ u32 res1;
+ u32 port_handle;
+ u32 lun_handle;
+ u32 res2;
+ u32 fsf_status;
+ union fsf_status_qual fsf_status_qual;
+ u8 res3[28];
+ u16 log_start;
+ u16 log_length;
+ u8 res4[16];
+} __attribute__ ((packed));
+
+struct fsf_nport_serv_param {
+ u8 common_serv_param[16];
+ u64 wwpn;
+ u64 wwnn;
+ u8 class1_serv_param[16];
+ u8 class2_serv_param[16];
+ u8 class3_serv_param[16];
+ u8 class4_serv_param[16];
+ u8 vendor_version_level[16];
+ u8 res1[16];
+} __attribute__ ((packed));
+
+struct fsf_plogi {
+ u32 code;
+ struct fsf_nport_serv_param serv_param;
+} __attribute__ ((packed));
+
+#define FSF_FCP_CMND_SIZE 288
+#define FSF_FCP_RSP_SIZE 128
+
+struct fsf_qtcb_bottom_io {
+ u32 data_direction;
+ u32 service_class;
+ u8 res1[8];
+ u32 fcp_cmnd_length;
+ u8 res2[12];
+ u8 fcp_cmnd[FSF_FCP_CMND_SIZE];
+ u8 fcp_rsp[FSF_FCP_RSP_SIZE];
+ u8 res3[64];
+} __attribute__ ((packed));
+
+struct fsf_qtcb_bottom_support {
+ u32 operation_subtype;
+ u8 res1[12];
+ u32 d_id;
+ u32 option;
+ u64 fcp_lun;
+ u64 res2;
+ u64 req_handle;
+ u32 service_class;
+ u8 res3[3];
+ u8 timeout;
+ u32 lun_access_info;
+ u8 res4[180];
+ u32 els1_length;
+ u32 els2_length;
+ u32 req_buf_length;
+ u32 resp_buf_length;
+ u8 els[256];
+} __attribute__ ((packed));
+
+struct fsf_qtcb_bottom_config {
+ u32 lic_version;
+ u32 feature_selection;
+ u32 high_qtcb_version;
+ u32 low_qtcb_version;
+ u32 max_qtcb_size;
+ u32 max_data_transfer_size;
+ u32 supported_features;
+ u8 res1[4];
+ u32 fc_topology;
+ u32 fc_link_speed;
+ u32 adapter_type;
+ u32 peer_d_id;
+ u8 res2[12];
+ u32 s_id;
+ struct fsf_nport_serv_param nport_serv_param;
+ u8 res3[8];
+ u32 adapter_ports;
+ u32 hardware_version;
+ u8 serial_number[32];
+ u8 res4[272];
+} __attribute__ ((packed));
+
+struct fsf_qtcb_bottom_port {
+ u8 res1[8];
+ u32 fc_port_id;
+ u32 port_type;
+ u32 port_state;
+ u32 class_of_service; /* should be 0x00000006 for class 2 and 3 */
+ u8 supported_fc4_types[32]; /* should be 0x00000100 for scsi fcp */
+ u8 active_fc4_types[32];
+ u32 supported_speed; /* 0x0001 for 1 GBit/s or 0x0002 for 2 GBit/s */
+ u32 maximum_frame_size; /* fixed value of 2112 */
+ u64 seconds_since_last_reset;
+ u64 tx_frames;
+ u64 tx_words;
+ u64 rx_frames;
+ u64 rx_words;
+ u64 lip; /* 0 */
+ u64 nos; /* currently 0 */
+ u64 error_frames; /* currently 0 */
+ u64 dumped_frames; /* currently 0 */
+ u64 link_failure;
+ u64 loss_of_sync;
+ u64 loss_of_signal;
+ u64 psp_error_counts;
+ u64 invalid_tx_words;
+ u64 invalid_crcs;
+ u64 input_requests;
+ u64 output_requests;
+ u64 control_requests;
+ u64 input_mb; /* where 1 MByte == 1.000.000 Bytes */
+ u64 output_mb; /* where 1 MByte == 1.000.000 Bytes */
+ u8 res2[256];
+} __attribute__ ((packed));
+
+union fsf_qtcb_bottom {
+ struct fsf_qtcb_bottom_io io;
+ struct fsf_qtcb_bottom_support support;
+ struct fsf_qtcb_bottom_config config;
+ struct fsf_qtcb_bottom_port port;
+};
+
+struct fsf_qtcb {
+ struct fsf_qtcb_prefix prefix;
+ struct fsf_qtcb_header header;
+ union fsf_qtcb_bottom bottom;
+ u8 log[FSF_QTCB_LOG_SIZE];
+} __attribute__ ((packed));
+
+#endif /* FSF_H */
diff --git a/drivers/s390/scsi/zfcp_qdio.c b/drivers/s390/scsi/zfcp_qdio.c
new file mode 100644
index 0000000..06e862d
--- /dev/null
+++ b/drivers/s390/scsi/zfcp_qdio.c
@@ -0,0 +1,868 @@
+/*
+ * linux/drivers/s390/scsi/zfcp_qdio.c
+ *
+ * FCP adapter driver for IBM eServer zSeries
+ *
+ * QDIO related routines
+ *
+ * (C) Copyright IBM Corp. 2002, 2004
+ *
+ * Authors:
+ * Martin Peschke <mpeschke@de.ibm.com>
+ * Raimund Schroeder <raimund.schroeder@de.ibm.com>
+ * Wolfgang Taphorn
+ * Heiko Carstens <heiko.carstens@de.ibm.com>
+ * Andreas Herrmann <aherrman@de.ibm.com>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2, or (at your option)
+ * any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#define ZFCP_QDIO_C_REVISION "$Revision: 1.20 $"
+
+#include "zfcp_ext.h"
+
+static inline void zfcp_qdio_sbal_limit(struct zfcp_fsf_req *, int);
+static inline volatile struct qdio_buffer_element *zfcp_qdio_sbale_get
+ (struct zfcp_qdio_queue *, int, int);
+static inline volatile struct qdio_buffer_element *zfcp_qdio_sbale_resp
+ (struct zfcp_fsf_req *, int, int);
+static inline volatile struct qdio_buffer_element *zfcp_qdio_sbal_chain
+ (struct zfcp_fsf_req *, unsigned long);
+static inline volatile struct qdio_buffer_element *zfcp_qdio_sbale_next
+ (struct zfcp_fsf_req *, unsigned long);
+static inline int zfcp_qdio_sbals_zero(struct zfcp_qdio_queue *, int, int);
+static inline int zfcp_qdio_sbals_wipe(struct zfcp_fsf_req *);
+static inline void zfcp_qdio_sbale_fill
+ (struct zfcp_fsf_req *, unsigned long, void *, int);
+static inline int zfcp_qdio_sbals_from_segment
+ (struct zfcp_fsf_req *, unsigned long, void *, unsigned long);
+static inline int zfcp_qdio_sbals_from_buffer
+ (struct zfcp_fsf_req *, unsigned long, void *, unsigned long, int);
+
+static qdio_handler_t zfcp_qdio_request_handler;
+static qdio_handler_t zfcp_qdio_response_handler;
+static int zfcp_qdio_handler_error_check(struct zfcp_adapter *,
+ unsigned int,
+ unsigned int, unsigned int);
+
+#define ZFCP_LOG_AREA ZFCP_LOG_AREA_QDIO
+
+/*
+ * Allocates BUFFER memory to each of the pointers of the qdio_buffer_t
+ * array in the adapter struct.
+ * Cur_buf is the pointer array and count can be any number of required
+ * buffers, the page-fitting arithmetic is done entirely within this funciton.
+ *
+ * returns: number of buffers allocated
+ * locks: must only be called with zfcp_data.config_sema taken
+ */
+static int
+zfcp_qdio_buffers_enqueue(struct qdio_buffer **cur_buf, int count)
+{
+ int buf_pos;
+ int qdio_buffers_per_page;
+ int page_pos = 0;
+ struct qdio_buffer *first_in_page = NULL;
+
+ qdio_buffers_per_page = PAGE_SIZE / sizeof (struct qdio_buffer);
+ ZFCP_LOG_TRACE("buffers_per_page=%d\n", qdio_buffers_per_page);
+
+ for (buf_pos = 0; buf_pos < count; buf_pos++) {
+ if (page_pos == 0) {
+ cur_buf[buf_pos] = (struct qdio_buffer *)
+ get_zeroed_page(GFP_KERNEL);
+ if (cur_buf[buf_pos] == NULL) {
+ ZFCP_LOG_INFO("error: allocation of "
+ "QDIO buffer failed \n");
+ goto out;
+ }
+ first_in_page = cur_buf[buf_pos];
+ } else {
+ cur_buf[buf_pos] = first_in_page + page_pos;
+
+ }
+ /* was initialised to zero */
+ page_pos++;
+ page_pos %= qdio_buffers_per_page;
+ }
+ out:
+ return buf_pos;
+}
+
+/*
+ * Frees BUFFER memory for each of the pointers of the struct qdio_buffer array
+ * in the adapter struct cur_buf is the pointer array and count can be any
+ * number of buffers in the array that should be freed starting from buffer 0
+ *
+ * locks: must only be called with zfcp_data.config_sema taken
+ */
+static void
+zfcp_qdio_buffers_dequeue(struct qdio_buffer **cur_buf, int count)
+{
+ int buf_pos;
+ int qdio_buffers_per_page;
+
+ qdio_buffers_per_page = PAGE_SIZE / sizeof (struct qdio_buffer);
+ ZFCP_LOG_TRACE("buffers_per_page=%d\n", qdio_buffers_per_page);
+
+ for (buf_pos = 0; buf_pos < count; buf_pos += qdio_buffers_per_page)
+ free_page((unsigned long) cur_buf[buf_pos]);
+ return;
+}
+
+/* locks: must only be called with zfcp_data.config_sema taken */
+int
+zfcp_qdio_allocate_queues(struct zfcp_adapter *adapter)
+{
+ int buffer_count;
+ int retval = 0;
+
+ buffer_count =
+ zfcp_qdio_buffers_enqueue(&(adapter->request_queue.buffer[0]),
+ QDIO_MAX_BUFFERS_PER_Q);
+ if (buffer_count < QDIO_MAX_BUFFERS_PER_Q) {
+ ZFCP_LOG_DEBUG("only %d QDIO buffers allocated for request "
+ "queue\n", buffer_count);
+ zfcp_qdio_buffers_dequeue(&(adapter->request_queue.buffer[0]),
+ buffer_count);
+ retval = -ENOMEM;
+ goto out;
+ }
+
+ buffer_count =
+ zfcp_qdio_buffers_enqueue(&(adapter->response_queue.buffer[0]),
+ QDIO_MAX_BUFFERS_PER_Q);
+ if (buffer_count < QDIO_MAX_BUFFERS_PER_Q) {
+ ZFCP_LOG_DEBUG("only %d QDIO buffers allocated for response "
+ "queue", buffer_count);
+ zfcp_qdio_buffers_dequeue(&(adapter->response_queue.buffer[0]),
+ buffer_count);
+ ZFCP_LOG_TRACE("freeing request_queue buffers\n");
+ zfcp_qdio_buffers_dequeue(&(adapter->request_queue.buffer[0]),
+ QDIO_MAX_BUFFERS_PER_Q);
+ retval = -ENOMEM;
+ goto out;
+ }
+ out:
+ return retval;
+}
+
+/* locks: must only be called with zfcp_data.config_sema taken */
+void
+zfcp_qdio_free_queues(struct zfcp_adapter *adapter)
+{
+ ZFCP_LOG_TRACE("freeing request_queue buffers\n");
+ zfcp_qdio_buffers_dequeue(&(adapter->request_queue.buffer[0]),
+ QDIO_MAX_BUFFERS_PER_Q);
+
+ ZFCP_LOG_TRACE("freeing response_queue buffers\n");
+ zfcp_qdio_buffers_dequeue(&(adapter->response_queue.buffer[0]),
+ QDIO_MAX_BUFFERS_PER_Q);
+}
+
+int
+zfcp_qdio_allocate(struct zfcp_adapter *adapter)
+{
+ struct qdio_initialize *init_data;
+
+ init_data = &adapter->qdio_init_data;
+
+ init_data->cdev = adapter->ccw_device;
+ init_data->q_format = QDIO_SCSI_QFMT;
+ memcpy(init_data->adapter_name, &adapter->name, 8);
+ init_data->qib_param_field_format = 0;
+ init_data->qib_param_field = NULL;
+ init_data->input_slib_elements = NULL;
+ init_data->output_slib_elements = NULL;
+ init_data->min_input_threshold = ZFCP_MIN_INPUT_THRESHOLD;
+ init_data->max_input_threshold = ZFCP_MAX_INPUT_THRESHOLD;
+ init_data->min_output_threshold = ZFCP_MIN_OUTPUT_THRESHOLD;
+ init_data->max_output_threshold = ZFCP_MAX_OUTPUT_THRESHOLD;
+ init_data->no_input_qs = 1;
+ init_data->no_output_qs = 1;
+ init_data->input_handler = zfcp_qdio_response_handler;
+ init_data->output_handler = zfcp_qdio_request_handler;
+ init_data->int_parm = (unsigned long) adapter;
+ init_data->flags = QDIO_INBOUND_0COPY_SBALS |
+ QDIO_OUTBOUND_0COPY_SBALS | QDIO_USE_OUTBOUND_PCIS;
+ init_data->input_sbal_addr_array =
+ (void **) (adapter->response_queue.buffer);
+ init_data->output_sbal_addr_array =
+ (void **) (adapter->request_queue.buffer);
+
+ return qdio_allocate(init_data);
+}
+
+/*
+ * function: zfcp_qdio_handler_error_check
+ *
+ * purpose: called by the response handler to determine error condition
+ *
+ * returns: error flag
+ *
+ */
+static inline int
+zfcp_qdio_handler_error_check(struct zfcp_adapter *adapter,
+ unsigned int status,
+ unsigned int qdio_error, unsigned int siga_error)
+{
+ int retval = 0;
+
+ if (ZFCP_LOG_CHECK(ZFCP_LOG_LEVEL_TRACE)) {
+ if (status & QDIO_STATUS_INBOUND_INT) {
+ ZFCP_LOG_TRACE("status is"
+ " QDIO_STATUS_INBOUND_INT \n");
+ }
+ if (status & QDIO_STATUS_OUTBOUND_INT) {
+ ZFCP_LOG_TRACE("status is"
+ " QDIO_STATUS_OUTBOUND_INT \n");
+ }
+ } // if (ZFCP_LOG_CHECK(ZFCP_LOG_LEVEL_TRACE))
+ if (unlikely(status & QDIO_STATUS_LOOK_FOR_ERROR)) {
+ retval = -EIO;
+
+ ZFCP_LOG_FLAGS(1, "QDIO_STATUS_LOOK_FOR_ERROR \n");
+
+ ZFCP_LOG_INFO("QDIO problem occurred (status=0x%x, "
+ "qdio_error=0x%x, siga_error=0x%x)\n",
+ status, qdio_error, siga_error);
+
+ if (status & QDIO_STATUS_ACTIVATE_CHECK_CONDITION) {
+ ZFCP_LOG_FLAGS(2,
+ "QDIO_STATUS_ACTIVATE_CHECK_CONDITION\n");
+ }
+ if (status & QDIO_STATUS_MORE_THAN_ONE_QDIO_ERROR) {
+ ZFCP_LOG_FLAGS(2,
+ "QDIO_STATUS_MORE_THAN_ONE_QDIO_ERROR\n");
+ }
+ if (status & QDIO_STATUS_MORE_THAN_ONE_SIGA_ERROR) {
+ ZFCP_LOG_FLAGS(2,
+ "QDIO_STATUS_MORE_THAN_ONE_SIGA_ERROR\n");
+ }
+
+ if (siga_error & QDIO_SIGA_ERROR_ACCESS_EXCEPTION) {
+ ZFCP_LOG_FLAGS(2, "QDIO_SIGA_ERROR_ACCESS_EXCEPTION\n");
+ }
+
+ if (siga_error & QDIO_SIGA_ERROR_B_BIT_SET) {
+ ZFCP_LOG_FLAGS(2, "QDIO_SIGA_ERROR_B_BIT_SET\n");
+ }
+
+ switch (qdio_error) {
+ case 0:
+ ZFCP_LOG_FLAGS(3, "QDIO_OK");
+ break;
+ case SLSB_P_INPUT_ERROR:
+ ZFCP_LOG_FLAGS(1, "SLSB_P_INPUT_ERROR\n");
+ break;
+ case SLSB_P_OUTPUT_ERROR:
+ ZFCP_LOG_FLAGS(1, "SLSB_P_OUTPUT_ERROR\n");
+ break;
+ default:
+ ZFCP_LOG_NORMAL("bug: unknown QDIO error 0x%x\n",
+ qdio_error);
+ break;
+ }
+ /* Restarting IO on the failed adapter from scratch */
+ debug_text_event(adapter->erp_dbf, 1, "qdio_err");
+ /*
+ * Since we have been using this adapter, it is save to assume
+ * that it is not failed but recoverable. The card seems to
+ * report link-up events by self-initiated queue shutdown.
+ * That is why we need to clear the the link-down flag
+ * which is set again in case we have missed by a mile.
+ */
+ zfcp_erp_adapter_reopen(
+ adapter,
+ ZFCP_STATUS_ADAPTER_LINK_UNPLUGGED |
+ ZFCP_STATUS_COMMON_ERP_FAILED);
+ }
+ return retval;
+}
+
+/*
+ * function: zfcp_qdio_request_handler
+ *
+ * purpose: is called by QDIO layer for completed SBALs in request queue
+ *
+ * returns: (void)
+ */
+static void
+zfcp_qdio_request_handler(struct ccw_device *ccw_device,
+ unsigned int status,
+ unsigned int qdio_error,
+ unsigned int siga_error,
+ unsigned int queue_number,
+ int first_element,
+ int elements_processed,
+ unsigned long int_parm)
+{
+ struct zfcp_adapter *adapter;
+ struct zfcp_qdio_queue *queue;
+
+ adapter = (struct zfcp_adapter *) int_parm;
+ queue = &adapter->request_queue;
+
+ ZFCP_LOG_DEBUG("adapter %s, first=%d, elements_processed=%d\n",
+ zfcp_get_busid_by_adapter(adapter),
+ first_element, elements_processed);
+
+ if (unlikely(zfcp_qdio_handler_error_check(adapter, status, qdio_error,
+ siga_error)))
+ goto out;
+ /*
+ * we stored address of struct zfcp_adapter data structure
+ * associated with irq in int_parm
+ */
+
+ /* cleanup all SBALs being program-owned now */
+ zfcp_qdio_zero_sbals(queue->buffer, first_element, elements_processed);
+
+ /* increase free space in outbound queue */
+ atomic_add(elements_processed, &queue->free_count);
+ ZFCP_LOG_DEBUG("free_count=%d\n", atomic_read(&queue->free_count));
+ wake_up(&adapter->request_wq);
+ ZFCP_LOG_DEBUG("elements_processed=%d, free count=%d\n",
+ elements_processed, atomic_read(&queue->free_count));
+ out:
+ return;
+}
+
+/*
+ * function: zfcp_qdio_response_handler
+ *
+ * purpose: is called by QDIO layer for completed SBALs in response queue
+ *
+ * returns: (void)
+ */
+static void
+zfcp_qdio_response_handler(struct ccw_device *ccw_device,
+ unsigned int status,
+ unsigned int qdio_error,
+ unsigned int siga_error,
+ unsigned int queue_number,
+ int first_element,
+ int elements_processed,
+ unsigned long int_parm)
+{
+ struct zfcp_adapter *adapter;
+ struct zfcp_qdio_queue *queue;
+ int buffer_index;
+ int i;
+ struct qdio_buffer *buffer;
+ int retval = 0;
+ u8 count;
+ u8 start;
+ volatile struct qdio_buffer_element *buffere = NULL;
+ int buffere_index;
+
+ adapter = (struct zfcp_adapter *) int_parm;
+ queue = &adapter->response_queue;
+
+ if (unlikely(zfcp_qdio_handler_error_check(adapter, status, qdio_error,
+ siga_error)))
+ goto out;
+
+ /*
+ * we stored address of struct zfcp_adapter data structure
+ * associated with irq in int_parm
+ */
+
+ buffere = &(queue->buffer[first_element]->element[0]);
+ ZFCP_LOG_DEBUG("first BUFFERE flags=0x%x\n", buffere->flags);
+ /*
+ * go through all SBALs from input queue currently
+ * returned by QDIO layer
+ */
+
+ for (i = 0; i < elements_processed; i++) {
+
+ buffer_index = first_element + i;
+ buffer_index %= QDIO_MAX_BUFFERS_PER_Q;
+ buffer = queue->buffer[buffer_index];
+
+ /* go through all SBALEs of SBAL */
+ for (buffere_index = 0;
+ buffere_index < QDIO_MAX_ELEMENTS_PER_BUFFER;
+ buffere_index++) {
+
+ /* look for QDIO request identifiers in SB */
+ buffere = &buffer->element[buffere_index];
+ retval = zfcp_qdio_reqid_check(adapter,
+ (void *) buffere->addr);
+
+ if (retval) {
+ ZFCP_LOG_NORMAL("bug: unexpected inbound "
+ "packet on adapter %s "
+ "(reqid=0x%lx, "
+ "first_element=%d, "
+ "elements_processed=%d)\n",
+ zfcp_get_busid_by_adapter(adapter),
+ (unsigned long) buffere->addr,
+ first_element,
+ elements_processed);
+ ZFCP_LOG_NORMAL("hex dump of inbound buffer "
+ "at address %p "
+ "(buffer_index=%d, "
+ "buffere_index=%d)\n", buffer,
+ buffer_index, buffere_index);
+ ZFCP_HEX_DUMP(ZFCP_LOG_LEVEL_NORMAL,
+ (char *) buffer, SBAL_SIZE);
+ }
+ /*
+ * A single used SBALE per inbound SBALE has been
+ * implemented by QDIO so far. Hope they will
+ * do some optimisation. Will need to change to
+ * unlikely() then.
+ */
+ if (likely(buffere->flags & SBAL_FLAGS_LAST_ENTRY))
+ break;
+ };
+
+ if (unlikely(!(buffere->flags & SBAL_FLAGS_LAST_ENTRY))) {
+ ZFCP_LOG_NORMAL("bug: End of inbound data "
+ "not marked!\n");
+ }
+ }
+
+ /*
+ * put range of SBALs back to response queue
+ * (including SBALs which have already been free before)
+ */
+ count = atomic_read(&queue->free_count) + elements_processed;
+ start = queue->free_index;
+
+ ZFCP_LOG_TRACE("calling do_QDIO on adapter %s (flags=0x%x, "
+ "queue_no=%i, index_in_queue=%i, count=%i, "
+ "buffers=0x%lx\n",
+ zfcp_get_busid_by_adapter(adapter),
+ QDIO_FLAG_SYNC_INPUT | QDIO_FLAG_UNDER_INTERRUPT,
+ 0, start, count, (unsigned long) &queue->buffer[start]);
+
+ retval = do_QDIO(ccw_device,
+ QDIO_FLAG_SYNC_INPUT | QDIO_FLAG_UNDER_INTERRUPT,
+ 0, start, count, NULL);
+
+ if (unlikely(retval)) {
+ atomic_set(&queue->free_count, count);
+ ZFCP_LOG_DEBUG("clearing of inbound data regions failed, "
+ "queues may be down "
+ "(count=%d, start=%d, retval=%d)\n",
+ count, start, retval);
+ } else {
+ queue->free_index += count;
+ queue->free_index %= QDIO_MAX_BUFFERS_PER_Q;
+ atomic_set(&queue->free_count, 0);
+ ZFCP_LOG_TRACE("%i buffers enqueued to response "
+ "queue at position %i\n", count, start);
+ }
+ out:
+ return;
+}
+
+/*
+ * function: zfcp_qdio_reqid_check
+ *
+ * purpose: checks for valid reqids or unsolicited status
+ *
+ * returns: 0 - valid request id or unsolicited status
+ * !0 - otherwise
+ */
+int
+zfcp_qdio_reqid_check(struct zfcp_adapter *adapter, void *sbale_addr)
+{
+ struct zfcp_fsf_req *fsf_req;
+ int retval = 0;
+
+ /* invalid (per convention used in this driver) */
+ if (unlikely(!sbale_addr)) {
+ ZFCP_LOG_NORMAL("bug: invalid reqid\n");
+ retval = -EINVAL;
+ goto out;
+ }
+
+ /* valid request id and thus (hopefully :) valid fsf_req address */
+ fsf_req = (struct zfcp_fsf_req *) sbale_addr;
+
+ if (unlikely(adapter != fsf_req->adapter)) {
+ ZFCP_LOG_NORMAL("bug: invalid reqid (fsf_req=%p, "
+ "fsf_req->adapter=%p, adapter=%p)\n",
+ fsf_req, fsf_req->adapter, adapter);
+ retval = -EINVAL;
+ goto out;
+ }
+
+ ZFCP_LOG_TRACE("fsf_req at %p, QTCB at %p\n", fsf_req, fsf_req->qtcb);
+ if (likely(fsf_req->qtcb)) {
+ ZFCP_LOG_TRACE("hex dump of QTCB:\n");
+ ZFCP_HEX_DUMP(ZFCP_LOG_LEVEL_TRACE, (char *) fsf_req->qtcb,
+ sizeof(struct fsf_qtcb));
+ }
+
+ /* finish the FSF request */
+ zfcp_fsf_req_complete(fsf_req);
+ out:
+ return retval;
+}
+
+/**
+ * zfcp_qdio_sbale_get - return pointer to SBALE of qdio_queue
+ * @queue: queue from which SBALE should be returned
+ * @sbal: specifies number of SBAL in queue
+ * @sbale: specifes number of SBALE in SBAL
+ */
+static inline volatile struct qdio_buffer_element *
+zfcp_qdio_sbale_get(struct zfcp_qdio_queue *queue, int sbal, int sbale)
+{
+ return &queue->buffer[sbal]->element[sbale];
+}
+
+/**
+ * zfcp_qdio_sbale_req - return pointer to SBALE of request_queue for
+ * a struct zfcp_fsf_req
+ */
+inline volatile struct qdio_buffer_element *
+zfcp_qdio_sbale_req(struct zfcp_fsf_req *fsf_req, int sbal, int sbale)
+{
+ return zfcp_qdio_sbale_get(&fsf_req->adapter->request_queue,
+ sbal, sbale);
+}
+
+/**
+ * zfcp_qdio_sbale_resp - return pointer to SBALE of response_queue for
+ * a struct zfcp_fsf_req
+ */
+static inline volatile struct qdio_buffer_element *
+zfcp_qdio_sbale_resp(struct zfcp_fsf_req *fsf_req, int sbal, int sbale)
+{
+ return zfcp_qdio_sbale_get(&fsf_req->adapter->response_queue,
+ sbal, sbale);
+}
+
+/**
+ * zfcp_qdio_sbale_curr - return current SBALE on request_queue for
+ * a struct zfcp_fsf_req
+ */
+inline volatile struct qdio_buffer_element *
+zfcp_qdio_sbale_curr(struct zfcp_fsf_req *fsf_req)
+{
+ return zfcp_qdio_sbale_req(fsf_req, fsf_req->sbal_curr,
+ fsf_req->sbale_curr);
+}
+
+/**
+ * zfcp_qdio_sbal_limit - determine maximum number of SBALs that can be used
+ * on the request_queue for a struct zfcp_fsf_req
+ * @fsf_req: the number of the last SBAL that can be used is stored herein
+ * @max_sbals: used to pass an upper limit for the number of SBALs
+ *
+ * Note: We can assume at least one free SBAL in the request_queue when called.
+ */
+static inline void
+zfcp_qdio_sbal_limit(struct zfcp_fsf_req *fsf_req, int max_sbals)
+{
+ int count = atomic_read(&fsf_req->adapter->request_queue.free_count);
+ count = min(count, max_sbals);
+ fsf_req->sbal_last = fsf_req->sbal_first;
+ fsf_req->sbal_last += (count - 1);
+ fsf_req->sbal_last %= QDIO_MAX_BUFFERS_PER_Q;
+}
+
+/**
+ * zfcp_qdio_sbal_chain - chain SBALs if more than one SBAL is needed for a
+ * request
+ * @fsf_req: zfcp_fsf_req to be processed
+ * @sbtype: SBAL flags which have to be set in first SBALE of new SBAL
+ *
+ * This function changes sbal_curr, sbale_curr, sbal_number of fsf_req.
+ */
+static inline volatile struct qdio_buffer_element *
+zfcp_qdio_sbal_chain(struct zfcp_fsf_req *fsf_req, unsigned long sbtype)
+{
+ volatile struct qdio_buffer_element *sbale;
+
+ /* set last entry flag in current SBALE of current SBAL */
+ sbale = zfcp_qdio_sbale_curr(fsf_req);
+ sbale->flags |= SBAL_FLAGS_LAST_ENTRY;
+
+ /* don't exceed last allowed SBAL */
+ if (fsf_req->sbal_curr == fsf_req->sbal_last)
+ return NULL;
+
+ /* set chaining flag in first SBALE of current SBAL */
+ sbale = zfcp_qdio_sbale_req(fsf_req, fsf_req->sbal_curr, 0);
+ sbale->flags |= SBAL_FLAGS0_MORE_SBALS;
+
+ /* calculate index of next SBAL */
+ fsf_req->sbal_curr++;
+ fsf_req->sbal_curr %= QDIO_MAX_BUFFERS_PER_Q;
+
+ /* keep this requests number of SBALs up-to-date */
+ fsf_req->sbal_number++;
+
+ /* start at first SBALE of new SBAL */
+ fsf_req->sbale_curr = 0;
+
+ /* set storage-block type for new SBAL */
+ sbale = zfcp_qdio_sbale_curr(fsf_req);
+ sbale->flags |= sbtype;
+
+ return sbale;
+}
+
+/**
+ * zfcp_qdio_sbale_next - switch to next SBALE, chain SBALs if needed
+ */
+static inline volatile struct qdio_buffer_element *
+zfcp_qdio_sbale_next(struct zfcp_fsf_req *fsf_req, unsigned long sbtype)
+{
+ if (fsf_req->sbale_curr == ZFCP_LAST_SBALE_PER_SBAL)
+ return zfcp_qdio_sbal_chain(fsf_req, sbtype);
+
+ fsf_req->sbale_curr++;
+
+ return zfcp_qdio_sbale_curr(fsf_req);
+}
+
+/**
+ * zfcp_qdio_sbals_zero - initialize SBALs between first and last in queue
+ * with zero from
+ */
+static inline int
+zfcp_qdio_sbals_zero(struct zfcp_qdio_queue *queue, int first, int last)
+{
+ struct qdio_buffer **buf = queue->buffer;
+ int curr = first;
+ int count = 0;
+
+ for(;;) {
+ curr %= QDIO_MAX_BUFFERS_PER_Q;
+ count++;
+ memset(buf[curr], 0, sizeof(struct qdio_buffer));
+ if (curr == last)
+ break;
+ curr++;
+ }
+ return count;
+}
+
+
+/**
+ * zfcp_qdio_sbals_wipe - reset all changes in SBALs for an fsf_req
+ */
+static inline int
+zfcp_qdio_sbals_wipe(struct zfcp_fsf_req *fsf_req)
+{
+ return zfcp_qdio_sbals_zero(&fsf_req->adapter->request_queue,
+ fsf_req->sbal_first, fsf_req->sbal_curr);
+}
+
+
+/**
+ * zfcp_qdio_sbale_fill - set address and lenght in current SBALE
+ * on request_queue
+ */
+static inline void
+zfcp_qdio_sbale_fill(struct zfcp_fsf_req *fsf_req, unsigned long sbtype,
+ void *addr, int length)
+{
+ volatile struct qdio_buffer_element *sbale;
+
+ sbale = zfcp_qdio_sbale_curr(fsf_req);
+ sbale->addr = addr;
+ sbale->length = length;
+}
+
+/**
+ * zfcp_qdio_sbals_from_segment - map memory segment to SBALE(s)
+ * @fsf_req: request to be processed
+ * @sbtype: SBALE flags
+ * @start_addr: address of memory segment
+ * @total_length: length of memory segment
+ *
+ * Alignment and length of the segment determine how many SBALEs are needed
+ * for the memory segment.
+ */
+static inline int
+zfcp_qdio_sbals_from_segment(struct zfcp_fsf_req *fsf_req, unsigned long sbtype,
+ void *start_addr, unsigned long total_length)
+{
+ unsigned long remaining, length;
+ void *addr;
+
+ /* split segment up heeding page boundaries */
+ for (addr = start_addr, remaining = total_length; remaining > 0;
+ addr += length, remaining -= length) {
+ /* get next free SBALE for new piece */
+ if (NULL == zfcp_qdio_sbale_next(fsf_req, sbtype)) {
+ /* no SBALE left, clean up and leave */
+ zfcp_qdio_sbals_wipe(fsf_req);
+ return -EINVAL;
+ }
+ /* calculate length of new piece */
+ length = min(remaining,
+ (PAGE_SIZE - ((unsigned long) addr &
+ (PAGE_SIZE - 1))));
+ /* fill current SBALE with calculated piece */
+ zfcp_qdio_sbale_fill(fsf_req, sbtype, addr, length);
+ }
+ return total_length;
+}
+
+
+/**
+ * zfcp_qdio_sbals_from_sg - fill SBALs from scatter-gather list
+ * @fsf_req: request to be processed
+ * @sbtype: SBALE flags
+ * @sg: scatter-gather list
+ * @sg_count: number of elements in scatter-gather list
+ * @max_sbals: upper bound for number of SBALs to be used
+ */
+inline int
+zfcp_qdio_sbals_from_sg(struct zfcp_fsf_req *fsf_req, unsigned long sbtype,
+ struct scatterlist *sg, int sg_count, int max_sbals)
+{
+ int sg_index;
+ struct scatterlist *sg_segment;
+ int retval;
+ volatile struct qdio_buffer_element *sbale;
+ int bytes = 0;
+
+ /* figure out last allowed SBAL */
+ zfcp_qdio_sbal_limit(fsf_req, max_sbals);
+
+ /* set storage-block type for current SBAL */
+ sbale = zfcp_qdio_sbale_req(fsf_req, fsf_req->sbal_curr, 0);
+ sbale->flags |= sbtype;
+
+ /* process all segements of scatter-gather list */
+ for (sg_index = 0, sg_segment = sg, bytes = 0;
+ sg_index < sg_count;
+ sg_index++, sg_segment++) {
+ retval = zfcp_qdio_sbals_from_segment(
+ fsf_req,
+ sbtype,
+ zfcp_sg_to_address(sg_segment),
+ sg_segment->length);
+ if (retval < 0) {
+ bytes = retval;
+ goto out;
+ } else
+ bytes += retval;
+ }
+ /* assume that no other SBALEs are to follow in the same SBAL */
+ sbale = zfcp_qdio_sbale_curr(fsf_req);
+ sbale->flags |= SBAL_FLAGS_LAST_ENTRY;
+out:
+ return bytes;
+}
+
+
+/**
+ * zfcp_qdio_sbals_from_buffer - fill SBALs from buffer
+ * @fsf_req: request to be processed
+ * @sbtype: SBALE flags
+ * @buffer: data buffer
+ * @length: length of buffer
+ * @max_sbals: upper bound for number of SBALs to be used
+ */
+static inline int
+zfcp_qdio_sbals_from_buffer(struct zfcp_fsf_req *fsf_req, unsigned long sbtype,
+ void *buffer, unsigned long length, int max_sbals)
+{
+ struct scatterlist sg_segment;
+
+ zfcp_address_to_sg(buffer, &sg_segment);
+ sg_segment.length = length;
+
+ return zfcp_qdio_sbals_from_sg(fsf_req, sbtype, &sg_segment, 1,
+ max_sbals);
+}
+
+
+/**
+ * zfcp_qdio_sbals_from_scsicmnd - fill SBALs from scsi command
+ * @fsf_req: request to be processed
+ * @sbtype: SBALE flags
+ * @scsi_cmnd: either scatter-gather list or buffer contained herein is used
+ * to fill SBALs
+ */
+inline int
+zfcp_qdio_sbals_from_scsicmnd(struct zfcp_fsf_req *fsf_req,
+ unsigned long sbtype, struct scsi_cmnd *scsi_cmnd)
+{
+ if (scsi_cmnd->use_sg) {
+ return zfcp_qdio_sbals_from_sg(fsf_req, sbtype,
+ (struct scatterlist *)
+ scsi_cmnd->request_buffer,
+ scsi_cmnd->use_sg,
+ ZFCP_MAX_SBALS_PER_REQ);
+ } else {
+ return zfcp_qdio_sbals_from_buffer(fsf_req, sbtype,
+ scsi_cmnd->request_buffer,
+ scsi_cmnd->request_bufflen,
+ ZFCP_MAX_SBALS_PER_REQ);
+ }
+}
+
+/**
+ * zfcp_qdio_determine_pci - set PCI flag in first SBALE on qdio queue if needed
+ */
+int
+zfcp_qdio_determine_pci(struct zfcp_qdio_queue *req_queue,
+ struct zfcp_fsf_req *fsf_req)
+{
+ int new_distance_from_int;
+ int pci_pos;
+ volatile struct qdio_buffer_element *sbale;
+
+ new_distance_from_int = req_queue->distance_from_int +
+ fsf_req->sbal_number;
+
+ if (unlikely(new_distance_from_int >= ZFCP_QDIO_PCI_INTERVAL)) {
+ new_distance_from_int %= ZFCP_QDIO_PCI_INTERVAL;
+ pci_pos = fsf_req->sbal_first;
+ pci_pos += fsf_req->sbal_number;
+ pci_pos -= new_distance_from_int;
+ pci_pos -= 1;
+ pci_pos %= QDIO_MAX_BUFFERS_PER_Q;
+ sbale = zfcp_qdio_sbale_req(fsf_req, pci_pos, 0);
+ sbale->flags |= SBAL_FLAGS0_PCI;
+ }
+ return new_distance_from_int;
+}
+
+/*
+ * function: zfcp_zero_sbals
+ *
+ * purpose: zeros specified range of SBALs
+ *
+ * returns:
+ */
+void
+zfcp_qdio_zero_sbals(struct qdio_buffer *buf[], int first, int clean_count)
+{
+ int cur_pos;
+ int index;
+
+ for (cur_pos = first; cur_pos < (first + clean_count); cur_pos++) {
+ index = cur_pos % QDIO_MAX_BUFFERS_PER_Q;
+ memset(buf[index], 0, sizeof (struct qdio_buffer));
+ ZFCP_LOG_TRACE("zeroing BUFFER %d at address %p\n",
+ index, buf[index]);
+ }
+}
+
+#undef ZFCP_LOG_AREA
diff --git a/drivers/s390/scsi/zfcp_scsi.c b/drivers/s390/scsi/zfcp_scsi.c
new file mode 100644
index 0000000..e21b547
--- /dev/null
+++ b/drivers/s390/scsi/zfcp_scsi.c
@@ -0,0 +1,949 @@
+/*
+ *
+ * linux/drivers/s390/scsi/zfcp_scsi.c
+ *
+ * FCP adapter driver for IBM eServer zSeries
+ *
+ * (C) Copyright IBM Corp. 2002, 2004
+ *
+ * Author(s): Martin Peschke <mpeschke@de.ibm.com>
+ * Raimund Schroeder <raimund.schroeder@de.ibm.com>
+ * Aron Zeh
+ * Wolfgang Taphorn
+ * Stefan Bader <stefan.bader@de.ibm.com>
+ * Heiko Carstens <heiko.carstens@de.ibm.com>
+ * Andreas Herrmann <aherrman@de.ibm.com>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2, or (at your option)
+ * any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#define ZFCP_LOG_AREA ZFCP_LOG_AREA_SCSI
+
+#define ZFCP_SCSI_REVISION "$Revision: 1.74 $"
+
+#include "zfcp_ext.h"
+
+static void zfcp_scsi_slave_destroy(struct scsi_device *sdp);
+static int zfcp_scsi_slave_alloc(struct scsi_device *sdp);
+static int zfcp_scsi_slave_configure(struct scsi_device *sdp);
+static int zfcp_scsi_queuecommand(struct scsi_cmnd *,
+ void (*done) (struct scsi_cmnd *));
+static int zfcp_scsi_eh_abort_handler(struct scsi_cmnd *);
+static int zfcp_scsi_eh_device_reset_handler(struct scsi_cmnd *);
+static int zfcp_scsi_eh_bus_reset_handler(struct scsi_cmnd *);
+static int zfcp_scsi_eh_host_reset_handler(struct scsi_cmnd *);
+static int zfcp_task_management_function(struct zfcp_unit *, u8);
+
+static struct zfcp_unit *zfcp_unit_lookup(struct zfcp_adapter *, int, scsi_id_t,
+ scsi_lun_t);
+static struct zfcp_port *zfcp_port_lookup(struct zfcp_adapter *, int,
+ scsi_id_t);
+
+static struct device_attribute *zfcp_sysfs_sdev_attrs[];
+
+struct scsi_transport_template *zfcp_transport_template;
+
+struct zfcp_data zfcp_data = {
+ .scsi_host_template = {
+ name: ZFCP_NAME,
+ proc_name: "zfcp",
+ proc_info: NULL,
+ detect: NULL,
+ slave_alloc: zfcp_scsi_slave_alloc,
+ slave_configure: zfcp_scsi_slave_configure,
+ slave_destroy: zfcp_scsi_slave_destroy,
+ queuecommand: zfcp_scsi_queuecommand,
+ eh_abort_handler: zfcp_scsi_eh_abort_handler,
+ eh_device_reset_handler: zfcp_scsi_eh_device_reset_handler,
+ eh_bus_reset_handler: zfcp_scsi_eh_bus_reset_handler,
+ eh_host_reset_handler: zfcp_scsi_eh_host_reset_handler,
+ /* FIXME(openfcp): Tune */
+ can_queue: 4096,
+ this_id: 0,
+ /*
+ * FIXME:
+ * one less? can zfcp_create_sbale cope with it?
+ */
+ sg_tablesize: ZFCP_MAX_SBALES_PER_REQ,
+ cmd_per_lun: 1,
+ unchecked_isa_dma: 0,
+ use_clustering: 1,
+ sdev_attrs: zfcp_sysfs_sdev_attrs,
+ },
+ .driver_version = ZFCP_VERSION,
+ /* rest initialised with zeros */
+};
+
+/* Find start of Response Information in FCP response unit*/
+char *
+zfcp_get_fcp_rsp_info_ptr(struct fcp_rsp_iu *fcp_rsp_iu)
+{
+ char *fcp_rsp_info_ptr;
+
+ fcp_rsp_info_ptr =
+ (unsigned char *) fcp_rsp_iu + (sizeof (struct fcp_rsp_iu));
+
+ return fcp_rsp_info_ptr;
+}
+
+/* Find start of Sense Information in FCP response unit*/
+char *
+zfcp_get_fcp_sns_info_ptr(struct fcp_rsp_iu *fcp_rsp_iu)
+{
+ char *fcp_sns_info_ptr;
+
+ fcp_sns_info_ptr =
+ (unsigned char *) fcp_rsp_iu + (sizeof (struct fcp_rsp_iu));
+ if (fcp_rsp_iu->validity.bits.fcp_rsp_len_valid)
+ fcp_sns_info_ptr = (char *) fcp_sns_info_ptr +
+ fcp_rsp_iu->fcp_rsp_len;
+
+ return fcp_sns_info_ptr;
+}
+
+fcp_dl_t *
+zfcp_get_fcp_dl_ptr(struct fcp_cmnd_iu * fcp_cmd)
+{
+ int additional_length = fcp_cmd->add_fcp_cdb_length << 2;
+ fcp_dl_t *fcp_dl_addr;
+
+ fcp_dl_addr = (fcp_dl_t *)
+ ((unsigned char *) fcp_cmd +
+ sizeof (struct fcp_cmnd_iu) + additional_length);
+ /*
+ * fcp_dl_addr = start address of fcp_cmnd structure +
+ * size of fixed part + size of dynamically sized add_dcp_cdb field
+ * SEE FCP-2 documentation
+ */
+ return fcp_dl_addr;
+}
+
+fcp_dl_t
+zfcp_get_fcp_dl(struct fcp_cmnd_iu * fcp_cmd)
+{
+ return *zfcp_get_fcp_dl_ptr(fcp_cmd);
+}
+
+void
+zfcp_set_fcp_dl(struct fcp_cmnd_iu *fcp_cmd, fcp_dl_t fcp_dl)
+{
+ *zfcp_get_fcp_dl_ptr(fcp_cmd) = fcp_dl;
+}
+
+/*
+ * note: it's a bit-or operation not an assignment
+ * regarding the specified byte
+ */
+static inline void
+set_byte(u32 * result, char status, char pos)
+{
+ *result |= status << (pos * 8);
+}
+
+void
+set_host_byte(u32 * result, char status)
+{
+ set_byte(result, status, 2);
+}
+
+void
+set_driver_byte(u32 * result, char status)
+{
+ set_byte(result, status, 3);
+}
+
+/*
+ * function: zfcp_scsi_slave_alloc
+ *
+ * purpose:
+ *
+ * returns:
+ */
+
+static int
+zfcp_scsi_slave_alloc(struct scsi_device *sdp)
+{
+ struct zfcp_adapter *adapter;
+ struct zfcp_unit *unit;
+ unsigned long flags;
+ int retval = -ENODEV;
+
+ adapter = (struct zfcp_adapter *) sdp->host->hostdata[0];
+ if (!adapter)
+ goto out;
+
+ read_lock_irqsave(&zfcp_data.config_lock, flags);
+ unit = zfcp_unit_lookup(adapter, sdp->channel, sdp->id, sdp->lun);
+ if (unit) {
+ sdp->hostdata = unit;
+ unit->device = sdp;
+ zfcp_unit_get(unit);
+ retval = 0;
+ }
+ read_unlock_irqrestore(&zfcp_data.config_lock, flags);
+ out:
+ return retval;
+}
+
+/*
+ * function: zfcp_scsi_slave_destroy
+ *
+ * purpose:
+ *
+ * returns:
+ */
+
+static void
+zfcp_scsi_slave_destroy(struct scsi_device *sdpnt)
+{
+ struct zfcp_unit *unit = (struct zfcp_unit *) sdpnt->hostdata;
+
+ if (unit) {
+ sdpnt->hostdata = NULL;
+ unit->device = NULL;
+ zfcp_unit_put(unit);
+ } else {
+ ZFCP_LOG_NORMAL("bug: no unit associated with SCSI device at "
+ "address %p\n", sdpnt);
+ }
+}
+
+/*
+ * called from scsi midlayer to allow finetuning of a device.
+ */
+static int
+zfcp_scsi_slave_configure(struct scsi_device *sdp)
+{
+ if (sdp->tagged_supported)
+ scsi_adjust_queue_depth(sdp, MSG_SIMPLE_TAG, ZFCP_CMND_PER_LUN);
+ else
+ scsi_adjust_queue_depth(sdp, 0, 1);
+ return 0;
+}
+
+/**
+ * zfcp_scsi_command_fail - set result in scsi_cmnd and call scsi_done function
+ * @scpnt: pointer to struct scsi_cmnd where result is set
+ * @result: result to be set in scpnt (e.g. DID_ERROR)
+ */
+static void
+zfcp_scsi_command_fail(struct scsi_cmnd *scpnt, int result)
+{
+ set_host_byte(&scpnt->result, result);
+ zfcp_cmd_dbf_event_scsi("failing", scpnt);
+ /* return directly */
+ scpnt->scsi_done(scpnt);
+}
+
+/**
+ * zfcp_scsi_command_async - worker for zfcp_scsi_queuecommand and
+ * zfcp_scsi_command_sync
+ * @adapter: adapter where scsi command is issued
+ * @unit: unit to which scsi command is sent
+ * @scpnt: scsi command to be sent
+ * @timer: timer to be started if request is successfully initiated
+ *
+ * Note: In scsi_done function must be set in scpnt.
+ */
+int
+zfcp_scsi_command_async(struct zfcp_adapter *adapter, struct zfcp_unit *unit,
+ struct scsi_cmnd *scpnt, struct timer_list *timer)
+{
+ int tmp;
+ int retval;
+
+ retval = 0;
+
+ BUG_ON((adapter == NULL) || (adapter != unit->port->adapter));
+ BUG_ON(scpnt->scsi_done == NULL);
+
+ if (unlikely(NULL == unit)) {
+ zfcp_scsi_command_fail(scpnt, DID_NO_CONNECT);
+ goto out;
+ }
+
+ if (unlikely(
+ atomic_test_mask(ZFCP_STATUS_COMMON_ERP_FAILED, &unit->status) ||
+ !atomic_test_mask(ZFCP_STATUS_COMMON_RUNNING, &unit->status))) {
+ ZFCP_LOG_DEBUG("stopping SCSI I/O on unit 0x%016Lx on port "
+ "0x%016Lx on adapter %s\n",
+ unit->fcp_lun, unit->port->wwpn,
+ zfcp_get_busid_by_adapter(adapter));
+ zfcp_scsi_command_fail(scpnt, DID_ERROR);
+ goto out;
+ }
+
+ if (unlikely(
+ !atomic_test_mask(ZFCP_STATUS_COMMON_UNBLOCKED, &unit->status))) {
+ ZFCP_LOG_DEBUG("adapter %s not ready or unit 0x%016Lx "
+ "on port 0x%016Lx in recovery\n",
+ zfcp_get_busid_by_unit(unit),
+ unit->fcp_lun, unit->port->wwpn);
+ retval = SCSI_MLQUEUE_DEVICE_BUSY;
+ goto out;
+ }
+
+ tmp = zfcp_fsf_send_fcp_command_task(adapter, unit, scpnt, timer,
+ ZFCP_REQ_AUTO_CLEANUP);
+
+ if (unlikely(tmp < 0)) {
+ ZFCP_LOG_DEBUG("error: initiation of Send FCP Cmnd failed\n");
+ retval = SCSI_MLQUEUE_HOST_BUSY;
+ }
+
+out:
+ return retval;
+}
+
+void
+zfcp_scsi_command_sync_handler(struct scsi_cmnd *scpnt)
+{
+ struct completion *wait = (struct completion *) scpnt->SCp.ptr;
+ complete(wait);
+}
+
+
+/**
+ * zfcp_scsi_command_sync - send a SCSI command and wait for completion
+ * @unit: unit where command is sent to
+ * @scpnt: scsi command to be sent
+ * @timer: timer to be started if request is successfully initiated
+ * Return: 0
+ *
+ * Errors are indicated in scpnt->result
+ */
+int
+zfcp_scsi_command_sync(struct zfcp_unit *unit, struct scsi_cmnd *scpnt,
+ struct timer_list *timer)
+{
+ int ret;
+ DECLARE_COMPLETION(wait);
+
+ scpnt->SCp.ptr = (void *) &wait; /* silent re-use */
+ scpnt->scsi_done = zfcp_scsi_command_sync_handler;
+ ret = zfcp_scsi_command_async(unit->port->adapter, unit, scpnt, timer);
+ if (ret == 0)
+ wait_for_completion(&wait);
+
+ scpnt->SCp.ptr = NULL;
+
+ return 0;
+}
+
+/*
+ * function: zfcp_scsi_queuecommand
+ *
+ * purpose: enqueues a SCSI command to the specified target device
+ *
+ * returns: 0 - success, SCSI command enqueued
+ * !0 - failure
+ */
+int
+zfcp_scsi_queuecommand(struct scsi_cmnd *scpnt,
+ void (*done) (struct scsi_cmnd *))
+{
+ struct zfcp_unit *unit;
+ struct zfcp_adapter *adapter;
+
+ /* reset the status for this request */
+ scpnt->result = 0;
+ scpnt->host_scribble = NULL;
+ scpnt->scsi_done = done;
+
+ /*
+ * figure out adapter and target device
+ * (stored there by zfcp_scsi_slave_alloc)
+ */
+ adapter = (struct zfcp_adapter *) scpnt->device->host->hostdata[0];
+ unit = (struct zfcp_unit *) scpnt->device->hostdata;
+
+ return zfcp_scsi_command_async(adapter, unit, scpnt, NULL);
+}
+
+/*
+ * function: zfcp_unit_lookup
+ *
+ * purpose:
+ *
+ * returns:
+ *
+ * context:
+ */
+static struct zfcp_unit *
+zfcp_unit_lookup(struct zfcp_adapter *adapter, int channel, scsi_id_t id,
+ scsi_lun_t lun)
+{
+ struct zfcp_port *port;
+ struct zfcp_unit *unit, *retval = NULL;
+
+ list_for_each_entry(port, &adapter->port_list_head, list) {
+ if (id != port->scsi_id)
+ continue;
+ list_for_each_entry(unit, &port->unit_list_head, list) {
+ if (lun == unit->scsi_lun) {
+ retval = unit;
+ goto out;
+ }
+ }
+ }
+ out:
+ return retval;
+}
+
+static struct zfcp_port *
+zfcp_port_lookup(struct zfcp_adapter *adapter, int channel, scsi_id_t id)
+{
+ struct zfcp_port *port;
+
+ list_for_each_entry(port, &adapter->port_list_head, list) {
+ if (id == port->scsi_id)
+ return port;
+ }
+ 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
+ * FAILED - otherwise
+ */
+int
+zfcp_scsi_eh_abort_handler(struct scsi_cmnd *scpnt)
+{
+ 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));
+
+ 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.
+ */
+ write_lock_irqsave(&adapter->abort_lock, flags);
+
+ /*
+ * Check whether command has just completed and can not be aborted.
+ * Even if the command has just been completed late, we can access
+ * scpnt since the SCSI stack does not release it at least until
+ * 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);
+ 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->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.
+ */
+ 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_cleanup(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) {
+ retval = SUCCESS;
+ strncpy(dbf_result, "##succ", ZFCP_ABORT_DBF_LENGTH);
+ } else if (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;
+}
+
+/*
+ * function: zfcp_scsi_eh_device_reset_handler
+ *
+ * purpose:
+ *
+ * returns:
+ */
+int
+zfcp_scsi_eh_device_reset_handler(struct scsi_cmnd *scpnt)
+{
+ int retval;
+ struct zfcp_unit *unit = (struct zfcp_unit *) scpnt->device->hostdata;
+ struct Scsi_Host *scsi_host = scpnt->device->host;
+
+ spin_unlock_irq(scsi_host->host_lock);
+
+ if (!unit) {
+ ZFCP_LOG_NORMAL("bug: Tried reset for nonexistent unit\n");
+ retval = SUCCESS;
+ goto out;
+ }
+ ZFCP_LOG_NORMAL("resetting unit 0x%016Lx\n", unit->fcp_lun);
+
+ /*
+ * If we do not know whether the unit supports 'logical unit reset'
+ * then try 'logical unit reset' and proceed with 'target reset'
+ * if 'logical unit reset' fails.
+ * If the unit is known not to support 'logical unit reset' then
+ * skip 'logical unit reset' and try 'target reset' immediately.
+ */
+ if (!atomic_test_mask(ZFCP_STATUS_UNIT_NOTSUPPUNITRESET,
+ &unit->status)) {
+ retval =
+ zfcp_task_management_function(unit, FCP_LOGICAL_UNIT_RESET);
+ if (retval) {
+ ZFCP_LOG_DEBUG("unit reset failed (unit=%p)\n", unit);
+ if (retval == -ENOTSUPP)
+ atomic_set_mask
+ (ZFCP_STATUS_UNIT_NOTSUPPUNITRESET,
+ &unit->status);
+ /* fall through and try 'target reset' next */
+ } else {
+ ZFCP_LOG_DEBUG("unit reset succeeded (unit=%p)\n",
+ unit);
+ /* avoid 'target reset' */
+ retval = SUCCESS;
+ goto out;
+ }
+ }
+ retval = zfcp_task_management_function(unit, FCP_TARGET_RESET);
+ if (retval) {
+ ZFCP_LOG_DEBUG("target reset failed (unit=%p)\n", unit);
+ retval = FAILED;
+ } else {
+ ZFCP_LOG_DEBUG("target reset succeeded (unit=%p)\n", unit);
+ retval = SUCCESS;
+ }
+ out:
+ spin_lock_irq(scsi_host->host_lock);
+ return retval;
+}
+
+static int
+zfcp_task_management_function(struct zfcp_unit *unit, u8 tm_flags)
+{
+ struct zfcp_adapter *adapter = unit->port->adapter;
+ int retval;
+ int status;
+ struct zfcp_fsf_req *fsf_req;
+
+ /* issue task management function */
+ fsf_req = zfcp_fsf_send_fcp_command_task_management
+ (adapter, unit, tm_flags, 0);
+ if (!fsf_req) {
+ ZFCP_LOG_INFO("error: creation of task management request "
+ "failed for unit 0x%016Lx on port 0x%016Lx on "
+ "adapter %s\n", unit->fcp_lun, unit->port->wwpn,
+ zfcp_get_busid_by_adapter(adapter));
+ retval = -ENOMEM;
+ goto out;
+ }
+
+ retval = zfcp_fsf_req_wait_and_cleanup(fsf_req,
+ ZFCP_UNINTERRUPTIBLE, &status);
+ /*
+ * check completion status of task management function
+ * (status should always be valid since no signals permitted)
+ */
+ if (status & ZFCP_STATUS_FSFREQ_TMFUNCFAILED)
+ retval = -EIO;
+ else if (status & ZFCP_STATUS_FSFREQ_TMFUNCNOTSUPP)
+ retval = -ENOTSUPP;
+ else
+ retval = 0;
+ out:
+ return retval;
+}
+
+/*
+ * function: zfcp_scsi_eh_bus_reset_handler
+ *
+ * purpose:
+ *
+ * returns:
+ */
+int
+zfcp_scsi_eh_bus_reset_handler(struct scsi_cmnd *scpnt)
+{
+ int retval = 0;
+ struct zfcp_unit *unit;
+ struct Scsi_Host *scsi_host = scpnt->device->host;
+
+ spin_unlock_irq(scsi_host->host_lock);
+
+ unit = (struct zfcp_unit *) scpnt->device->hostdata;
+ ZFCP_LOG_NORMAL("bus reset because of problems with "
+ "unit 0x%016Lx\n", unit->fcp_lun);
+ zfcp_erp_adapter_reopen(unit->port->adapter, 0);
+ zfcp_erp_wait(unit->port->adapter);
+ retval = SUCCESS;
+
+ spin_lock_irq(scsi_host->host_lock);
+ return retval;
+}
+
+/*
+ * function: zfcp_scsi_eh_host_reset_handler
+ *
+ * purpose:
+ *
+ * returns:
+ */
+int
+zfcp_scsi_eh_host_reset_handler(struct scsi_cmnd *scpnt)
+{
+ int retval = 0;
+ struct zfcp_unit *unit;
+ struct Scsi_Host *scsi_host = scpnt->device->host;
+
+ spin_unlock_irq(scsi_host->host_lock);
+
+ unit = (struct zfcp_unit *) scpnt->device->hostdata;
+ ZFCP_LOG_NORMAL("host reset because of problems with "
+ "unit 0x%016Lx\n", unit->fcp_lun);
+ zfcp_erp_adapter_reopen(unit->port->adapter, 0);
+ zfcp_erp_wait(unit->port->adapter);
+ retval = SUCCESS;
+
+ spin_lock_irq(scsi_host->host_lock);
+ return retval;
+}
+
+/*
+ * function:
+ *
+ * purpose:
+ *
+ * returns:
+ */
+int
+zfcp_adapter_scsi_register(struct zfcp_adapter *adapter)
+{
+ int retval = 0;
+ static unsigned int unique_id = 0;
+
+ /* register adapter as SCSI host with mid layer of SCSI stack */
+ adapter->scsi_host = scsi_host_alloc(&zfcp_data.scsi_host_template,
+ sizeof (struct zfcp_adapter *));
+ if (!adapter->scsi_host) {
+ ZFCP_LOG_NORMAL("error: registration with SCSI stack failed "
+ "for adapter %s ",
+ zfcp_get_busid_by_adapter(adapter));
+ retval = -EIO;
+ goto out;
+ }
+ ZFCP_LOG_DEBUG("host registered, scsi_host=%p\n", adapter->scsi_host);
+
+ /* tell the SCSI stack some characteristics of this adapter */
+ adapter->scsi_host->max_id = 1;
+ adapter->scsi_host->max_lun = 1;
+ adapter->scsi_host->max_channel = 0;
+ adapter->scsi_host->unique_id = unique_id++; /* FIXME */
+ adapter->scsi_host->max_cmd_len = ZFCP_MAX_SCSI_CMND_LENGTH;
+ adapter->scsi_host->transportt = zfcp_transport_template;
+ /*
+ * Reverse mapping of the host number to avoid race condition
+ */
+ adapter->scsi_host_no = adapter->scsi_host->host_no;
+
+ /*
+ * save a pointer to our own adapter data structure within
+ * hostdata field of SCSI host data structure
+ */
+ adapter->scsi_host->hostdata[0] = (unsigned long) adapter;
+
+ if (scsi_add_host(adapter->scsi_host, &adapter->ccw_device->dev)) {
+ scsi_host_put(adapter->scsi_host);
+ retval = -EIO;
+ goto out;
+ }
+ atomic_set_mask(ZFCP_STATUS_ADAPTER_REGISTERED, &adapter->status);
+ out:
+ return retval;
+}
+
+/*
+ * function:
+ *
+ * purpose:
+ *
+ * returns:
+ */
+void
+zfcp_adapter_scsi_unregister(struct zfcp_adapter *adapter)
+{
+ struct Scsi_Host *shost;
+
+ shost = adapter->scsi_host;
+ if (!shost)
+ return;
+ scsi_remove_host(shost);
+ scsi_host_put(shost);
+ adapter->scsi_host = NULL;
+ adapter->scsi_host_no = 0;
+ atomic_clear_mask(ZFCP_STATUS_ADAPTER_REGISTERED, &adapter->status);
+
+ return;
+}
+
+
+void
+zfcp_fsf_start_scsi_er_timer(struct zfcp_adapter *adapter)
+{
+ adapter->scsi_er_timer.function = zfcp_fsf_scsi_er_timeout_handler;
+ adapter->scsi_er_timer.data = (unsigned long) adapter;
+ adapter->scsi_er_timer.expires = jiffies + ZFCP_SCSI_ER_TIMEOUT;
+ add_timer(&adapter->scsi_er_timer);
+}
+
+/*
+ * Support functions for FC transport class
+ */
+static void
+zfcp_get_port_id(struct scsi_target *starget)
+{
+ struct Scsi_Host *shost = dev_to_shost(starget->dev.parent);
+ struct zfcp_adapter *adapter = (struct zfcp_adapter *)shost->hostdata[0];
+ struct zfcp_port *port;
+ unsigned long flags;
+
+ read_lock_irqsave(&zfcp_data.config_lock, flags);
+ port = zfcp_port_lookup(adapter, starget->channel, starget->id);
+ if (port)
+ fc_starget_port_id(starget) = port->d_id;
+ else
+ fc_starget_port_id(starget) = -1;
+ read_unlock_irqrestore(&zfcp_data.config_lock, flags);
+}
+
+static void
+zfcp_get_port_name(struct scsi_target *starget)
+{
+ struct Scsi_Host *shost = dev_to_shost(starget->dev.parent);
+ struct zfcp_adapter *adapter = (struct zfcp_adapter *)shost->hostdata[0];
+ struct zfcp_port *port;
+ unsigned long flags;
+
+ read_lock_irqsave(&zfcp_data.config_lock, flags);
+ port = zfcp_port_lookup(adapter, starget->channel, starget->id);
+ if (port)
+ fc_starget_port_name(starget) = port->wwpn;
+ else
+ fc_starget_port_name(starget) = -1;
+ read_unlock_irqrestore(&zfcp_data.config_lock, flags);
+}
+
+static void
+zfcp_get_node_name(struct scsi_target *starget)
+{
+ struct Scsi_Host *shost = dev_to_shost(starget->dev.parent);
+ struct zfcp_adapter *adapter = (struct zfcp_adapter *)shost->hostdata[0];
+ struct zfcp_port *port;
+ unsigned long flags;
+
+ read_lock_irqsave(&zfcp_data.config_lock, flags);
+ port = zfcp_port_lookup(adapter, starget->channel, starget->id);
+ if (port)
+ fc_starget_node_name(starget) = port->wwnn;
+ else
+ fc_starget_node_name(starget) = -1;
+ read_unlock_irqrestore(&zfcp_data.config_lock, flags);
+}
+
+struct fc_function_template zfcp_transport_functions = {
+ .get_starget_port_id = zfcp_get_port_id,
+ .get_starget_port_name = zfcp_get_port_name,
+ .get_starget_node_name = zfcp_get_node_name,
+ .show_starget_port_id = 1,
+ .show_starget_port_name = 1,
+ .show_starget_node_name = 1,
+};
+
+/**
+ * ZFCP_DEFINE_SCSI_ATTR
+ * @_name: name of show attribute
+ * @_format: format string
+ * @_value: value to print
+ *
+ * Generates attribute for a unit.
+ */
+#define ZFCP_DEFINE_SCSI_ATTR(_name, _format, _value) \
+static ssize_t zfcp_sysfs_scsi_##_name##_show(struct device *dev, \
+ char *buf) \
+{ \
+ struct scsi_device *sdev; \
+ struct zfcp_unit *unit; \
+ \
+ sdev = to_scsi_device(dev); \
+ unit = sdev->hostdata; \
+ return sprintf(buf, _format, _value); \
+} \
+ \
+static DEVICE_ATTR(_name, S_IRUGO, zfcp_sysfs_scsi_##_name##_show, NULL);
+
+ZFCP_DEFINE_SCSI_ATTR(hba_id, "%s\n", zfcp_get_busid_by_unit(unit));
+ZFCP_DEFINE_SCSI_ATTR(wwpn, "0x%016llx\n", unit->port->wwpn);
+ZFCP_DEFINE_SCSI_ATTR(fcp_lun, "0x%016llx\n", unit->fcp_lun);
+
+static struct device_attribute *zfcp_sysfs_sdev_attrs[] = {
+ &dev_attr_fcp_lun,
+ &dev_attr_wwpn,
+ &dev_attr_hba_id,
+ NULL
+};
+
+#undef ZFCP_LOG_AREA
diff --git a/drivers/s390/scsi/zfcp_sysfs_adapter.c b/drivers/s390/scsi/zfcp_sysfs_adapter.c
new file mode 100644
index 0000000..ff28ade
--- /dev/null
+++ b/drivers/s390/scsi/zfcp_sysfs_adapter.c
@@ -0,0 +1,298 @@
+/*
+ * linux/drivers/s390/scsi/zfcp_sysfs_adapter.c
+ *
+ * FCP adapter driver for IBM eServer zSeries
+ *
+ * sysfs adapter related routines
+ *
+ * (C) Copyright IBM Corp. 2003, 2004
+ *
+ * Authors:
+ * Martin Peschke <mpeschke@de.ibm.com>
+ * Heiko Carstens <heiko.carstens@de.ibm.com>
+ * Andreas Herrmann <aherrman@de.ibm.com>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2, or (at your option)
+ * any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#define ZFCP_SYSFS_ADAPTER_C_REVISION "$Revision: 1.38 $"
+
+#include "zfcp_ext.h"
+
+#define ZFCP_LOG_AREA ZFCP_LOG_AREA_CONFIG
+
+static const char fc_topologies[5][25] = {
+ "<error>",
+ "point-to-point",
+ "fabric",
+ "arbitrated loop",
+ "fabric (virt. adapter)"
+};
+
+/**
+ * ZFCP_DEFINE_ADAPTER_ATTR
+ * @_name: name of show attribute
+ * @_format: format string
+ * @_value: value to print
+ *
+ * Generates attributes for an adapter.
+ */
+#define ZFCP_DEFINE_ADAPTER_ATTR(_name, _format, _value) \
+static ssize_t zfcp_sysfs_adapter_##_name##_show(struct device *dev, \
+ char *buf) \
+{ \
+ struct zfcp_adapter *adapter; \
+ \
+ adapter = dev_get_drvdata(dev); \
+ return sprintf(buf, _format, _value); \
+} \
+ \
+static DEVICE_ATTR(_name, S_IRUGO, zfcp_sysfs_adapter_##_name##_show, NULL);
+
+ZFCP_DEFINE_ADAPTER_ATTR(status, "0x%08x\n", atomic_read(&adapter->status));
+ZFCP_DEFINE_ADAPTER_ATTR(wwnn, "0x%016llx\n", adapter->wwnn);
+ZFCP_DEFINE_ADAPTER_ATTR(wwpn, "0x%016llx\n", adapter->wwpn);
+ZFCP_DEFINE_ADAPTER_ATTR(s_id, "0x%06x\n", adapter->s_id);
+ZFCP_DEFINE_ADAPTER_ATTR(card_version, "0x%04x\n", adapter->hydra_version);
+ZFCP_DEFINE_ADAPTER_ATTR(lic_version, "0x%08x\n", adapter->fsf_lic_version);
+ZFCP_DEFINE_ADAPTER_ATTR(fc_link_speed, "%d Gb/s\n", adapter->fc_link_speed);
+ZFCP_DEFINE_ADAPTER_ATTR(fc_service_class, "%d\n", adapter->fc_service_class);
+ZFCP_DEFINE_ADAPTER_ATTR(fc_topology, "%s\n",
+ fc_topologies[adapter->fc_topology]);
+ZFCP_DEFINE_ADAPTER_ATTR(hardware_version, "0x%08x\n",
+ adapter->hardware_version);
+ZFCP_DEFINE_ADAPTER_ATTR(serial_number, "%17s\n", adapter->serial_number);
+ZFCP_DEFINE_ADAPTER_ATTR(scsi_host_no, "0x%x\n", adapter->scsi_host_no);
+ZFCP_DEFINE_ADAPTER_ATTR(in_recovery, "%d\n", atomic_test_mask
+ (ZFCP_STATUS_COMMON_ERP_INUSE, &adapter->status));
+
+/**
+ * zfcp_sysfs_port_add_store - add a port to sysfs tree
+ * @dev: pointer to belonging device
+ * @buf: pointer to input buffer
+ * @count: number of bytes in buffer
+ *
+ * Store function of the "port_add" attribute of an adapter.
+ */
+static ssize_t
+zfcp_sysfs_port_add_store(struct device *dev, const char *buf, size_t count)
+{
+ wwn_t wwpn;
+ char *endp;
+ struct zfcp_adapter *adapter;
+ struct zfcp_port *port;
+ int retval = -EINVAL;
+
+ down(&zfcp_data.config_sema);
+
+ adapter = dev_get_drvdata(dev);
+ if (atomic_test_mask(ZFCP_STATUS_COMMON_REMOVE, &adapter->status)) {
+ retval = -EBUSY;
+ goto out;
+ }
+
+ wwpn = simple_strtoull(buf, &endp, 0);
+ if ((endp + 1) < (buf + count))
+ goto out;
+
+ port = zfcp_port_enqueue(adapter, wwpn, 0, 0);
+ if (!port)
+ goto out;
+
+ retval = 0;
+
+ zfcp_erp_port_reopen(port, 0);
+ zfcp_erp_wait(port->adapter);
+ zfcp_port_put(port);
+ out:
+ up(&zfcp_data.config_sema);
+ return retval ? retval : (ssize_t) count;
+}
+
+static DEVICE_ATTR(port_add, S_IWUSR, NULL, zfcp_sysfs_port_add_store);
+
+/**
+ * zfcp_sysfs_port_remove_store - remove a port from sysfs tree
+ * @dev: pointer to belonging device
+ * @buf: pointer to input buffer
+ * @count: number of bytes in buffer
+ *
+ * Store function of the "port_remove" attribute of an adapter.
+ */
+static ssize_t
+zfcp_sysfs_port_remove_store(struct device *dev, const char *buf, size_t count)
+{
+ struct zfcp_adapter *adapter;
+ struct zfcp_port *port;
+ wwn_t wwpn;
+ char *endp;
+ int retval = 0;
+
+ down(&zfcp_data.config_sema);
+
+ adapter = dev_get_drvdata(dev);
+ if (atomic_test_mask(ZFCP_STATUS_COMMON_REMOVE, &adapter->status)) {
+ retval = -EBUSY;
+ goto out;
+ }
+
+ wwpn = simple_strtoull(buf, &endp, 0);
+ if ((endp + 1) < (buf + count)) {
+ retval = -EINVAL;
+ goto out;
+ }
+
+ write_lock_irq(&zfcp_data.config_lock);
+ port = zfcp_get_port_by_wwpn(adapter, wwpn);
+ if (port && (atomic_read(&port->refcount) == 0)) {
+ zfcp_port_get(port);
+ atomic_set_mask(ZFCP_STATUS_COMMON_REMOVE, &port->status);
+ list_move(&port->list, &adapter->port_remove_lh);
+ }
+ else {
+ port = NULL;
+ }
+ write_unlock_irq(&zfcp_data.config_lock);
+
+ if (!port) {
+ retval = -ENXIO;
+ goto out;
+ }
+
+ zfcp_erp_port_shutdown(port, 0);
+ zfcp_erp_wait(adapter);
+ zfcp_port_put(port);
+ zfcp_port_dequeue(port);
+ out:
+ up(&zfcp_data.config_sema);
+ return retval ? retval : (ssize_t) count;
+}
+
+static DEVICE_ATTR(port_remove, S_IWUSR, NULL, zfcp_sysfs_port_remove_store);
+
+/**
+ * zfcp_sysfs_adapter_failed_store - failed state of adapter
+ * @dev: pointer to belonging device
+ * @buf: pointer to input buffer
+ * @count: number of bytes in buffer
+ *
+ * Store function of the "failed" attribute of an adapter.
+ * If a "0" gets written to "failed", error recovery will be
+ * started for the belonging adapter.
+ */
+static ssize_t
+zfcp_sysfs_adapter_failed_store(struct device *dev,
+ const char *buf, size_t count)
+{
+ struct zfcp_adapter *adapter;
+ unsigned int val;
+ char *endp;
+ int retval = 0;
+
+ down(&zfcp_data.config_sema);
+
+ adapter = dev_get_drvdata(dev);
+ if (atomic_test_mask(ZFCP_STATUS_COMMON_REMOVE, &adapter->status)) {
+ retval = -EBUSY;
+ goto out;
+ }
+
+ val = simple_strtoul(buf, &endp, 0);
+ if (((endp + 1) < (buf + count)) || (val != 0)) {
+ retval = -EINVAL;
+ goto out;
+ }
+
+ zfcp_erp_modify_adapter_status(adapter, ZFCP_STATUS_COMMON_RUNNING,
+ ZFCP_SET);
+ zfcp_erp_adapter_reopen(adapter, ZFCP_STATUS_COMMON_ERP_FAILED);
+ zfcp_erp_wait(adapter);
+ out:
+ up(&zfcp_data.config_sema);
+ return retval ? retval : (ssize_t) count;
+}
+
+/**
+ * zfcp_sysfs_adapter_failed_show - failed state of adapter
+ * @dev: pointer to belonging device
+ * @buf: pointer to input buffer
+ *
+ * Show function of "failed" attribute of adapter. Will be
+ * "0" if adapter is working, otherwise "1".
+ */
+static ssize_t
+zfcp_sysfs_adapter_failed_show(struct device *dev, char *buf)
+{
+ struct zfcp_adapter *adapter;
+
+ adapter = dev_get_drvdata(dev);
+ if (atomic_test_mask(ZFCP_STATUS_COMMON_ERP_FAILED, &adapter->status))
+ return sprintf(buf, "1\n");
+ else
+ return sprintf(buf, "0\n");
+}
+
+static DEVICE_ATTR(failed, S_IWUSR | S_IRUGO, zfcp_sysfs_adapter_failed_show,
+ zfcp_sysfs_adapter_failed_store);
+
+static struct attribute *zfcp_adapter_attrs[] = {
+ &dev_attr_failed.attr,
+ &dev_attr_in_recovery.attr,
+ &dev_attr_port_remove.attr,
+ &dev_attr_port_add.attr,
+ &dev_attr_wwnn.attr,
+ &dev_attr_wwpn.attr,
+ &dev_attr_s_id.attr,
+ &dev_attr_card_version.attr,
+ &dev_attr_lic_version.attr,
+ &dev_attr_fc_link_speed.attr,
+ &dev_attr_fc_service_class.attr,
+ &dev_attr_fc_topology.attr,
+ &dev_attr_scsi_host_no.attr,
+ &dev_attr_status.attr,
+ &dev_attr_hardware_version.attr,
+ &dev_attr_serial_number.attr,
+ NULL
+};
+
+static struct attribute_group zfcp_adapter_attr_group = {
+ .attrs = zfcp_adapter_attrs,
+};
+
+/**
+ * zfcp_sysfs_create_adapter_files - create sysfs adapter files
+ * @dev: pointer to belonging device
+ *
+ * Create all attributes of the sysfs representation of an adapter.
+ */
+int
+zfcp_sysfs_adapter_create_files(struct device *dev)
+{
+ return sysfs_create_group(&dev->kobj, &zfcp_adapter_attr_group);
+}
+
+/**
+ * zfcp_sysfs_remove_adapter_files - remove sysfs adapter files
+ * @dev: pointer to belonging device
+ *
+ * Remove all attributes of the sysfs representation of an adapter.
+ */
+void
+zfcp_sysfs_adapter_remove_files(struct device *dev)
+{
+ sysfs_remove_group(&dev->kobj, &zfcp_adapter_attr_group);
+}
+
+#undef ZFCP_LOG_AREA
diff --git a/drivers/s390/scsi/zfcp_sysfs_driver.c b/drivers/s390/scsi/zfcp_sysfs_driver.c
new file mode 100644
index 0000000..77a5e2d
--- /dev/null
+++ b/drivers/s390/scsi/zfcp_sysfs_driver.c
@@ -0,0 +1,135 @@
+/*
+ * linux/drivers/s390/scsi/zfcp_sysfs_driver.c
+ *
+ * FCP adapter driver for IBM eServer zSeries
+ *
+ * sysfs driver related routines
+ *
+ * (C) Copyright IBM Corp. 2003, 2004
+ *
+ * Authors:
+ * Martin Peschke <mpeschke@de.ibm.com>
+ * Heiko Carstens <heiko.carstens@de.ibm.com>
+ * Andreas Herrmann <aherrman@de.ibm.com>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2, or (at your option)
+ * any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#define ZFCP_SYSFS_DRIVER_C_REVISION "$Revision: 1.17 $"
+
+#include "zfcp_ext.h"
+
+#define ZFCP_LOG_AREA ZFCP_LOG_AREA_CONFIG
+
+/**
+ * ZFCP_DEFINE_DRIVER_ATTR - define for all loglevels sysfs attributes
+ * @_name: name of attribute
+ * @_define: name of ZFCP loglevel define
+ *
+ * Generates store function for a sysfs loglevel attribute of zfcp driver.
+ */
+#define ZFCP_DEFINE_DRIVER_ATTR(_name, _define) \
+static ssize_t zfcp_sysfs_loglevel_##_name##_store(struct device_driver *drv, \
+ const char *buf, \
+ size_t count) \
+{ \
+ unsigned int loglevel; \
+ unsigned int new_loglevel; \
+ char *endp; \
+ \
+ new_loglevel = simple_strtoul(buf, &endp, 0); \
+ if ((endp + 1) < (buf + count)) \
+ return -EINVAL; \
+ if (new_loglevel > 3) \
+ return -EINVAL; \
+ down(&zfcp_data.config_sema); \
+ loglevel = atomic_read(&zfcp_data.loglevel); \
+ loglevel &= ~((unsigned int) 0xf << (ZFCP_LOG_AREA_##_define << 2)); \
+ loglevel |= new_loglevel << (ZFCP_LOG_AREA_##_define << 2); \
+ atomic_set(&zfcp_data.loglevel, loglevel); \
+ up(&zfcp_data.config_sema); \
+ return count; \
+} \
+ \
+static ssize_t zfcp_sysfs_loglevel_##_name##_show(struct device_driver *dev, \
+ char *buf) \
+{ \
+ return sprintf(buf,"%d\n", (unsigned int) \
+ ZFCP_GET_LOG_VALUE(ZFCP_LOG_AREA_##_define)); \
+} \
+ \
+static DRIVER_ATTR(loglevel_##_name, S_IWUSR | S_IRUGO, \
+ zfcp_sysfs_loglevel_##_name##_show, \
+ zfcp_sysfs_loglevel_##_name##_store);
+
+ZFCP_DEFINE_DRIVER_ATTR(other, OTHER);
+ZFCP_DEFINE_DRIVER_ATTR(scsi, SCSI);
+ZFCP_DEFINE_DRIVER_ATTR(fsf, FSF);
+ZFCP_DEFINE_DRIVER_ATTR(config, CONFIG);
+ZFCP_DEFINE_DRIVER_ATTR(cio, CIO);
+ZFCP_DEFINE_DRIVER_ATTR(qdio, QDIO);
+ZFCP_DEFINE_DRIVER_ATTR(erp, ERP);
+ZFCP_DEFINE_DRIVER_ATTR(fc, FC);
+
+static ssize_t zfcp_sysfs_version_show(struct device_driver *dev,
+ char *buf)
+{
+ return sprintf(buf, "%s\n", zfcp_data.driver_version);
+}
+
+static DRIVER_ATTR(version, S_IRUGO, zfcp_sysfs_version_show, NULL);
+
+static struct attribute *zfcp_driver_attrs[] = {
+ &driver_attr_loglevel_other.attr,
+ &driver_attr_loglevel_scsi.attr,
+ &driver_attr_loglevel_fsf.attr,
+ &driver_attr_loglevel_config.attr,
+ &driver_attr_loglevel_cio.attr,
+ &driver_attr_loglevel_qdio.attr,
+ &driver_attr_loglevel_erp.attr,
+ &driver_attr_loglevel_fc.attr,
+ &driver_attr_version.attr,
+ NULL
+};
+
+static struct attribute_group zfcp_driver_attr_group = {
+ .attrs = zfcp_driver_attrs,
+};
+
+/**
+ * zfcp_sysfs_create_driver_files - create sysfs driver files
+ * @dev: pointer to belonging device
+ *
+ * Create all sysfs attributes of the zfcp device driver
+ */
+int
+zfcp_sysfs_driver_create_files(struct device_driver *drv)
+{
+ return sysfs_create_group(&drv->kobj, &zfcp_driver_attr_group);
+}
+
+/**
+ * zfcp_sysfs_remove_driver_files - remove sysfs driver files
+ * @dev: pointer to belonging device
+ *
+ * Remove all sysfs attributes of the zfcp device driver
+ */
+void
+zfcp_sysfs_driver_remove_files(struct device_driver *drv)
+{
+ sysfs_remove_group(&drv->kobj, &zfcp_driver_attr_group);
+}
+
+#undef ZFCP_LOG_AREA
diff --git a/drivers/s390/scsi/zfcp_sysfs_port.c b/drivers/s390/scsi/zfcp_sysfs_port.c
new file mode 100644
index 0000000..6aafb2a
--- /dev/null
+++ b/drivers/s390/scsi/zfcp_sysfs_port.c
@@ -0,0 +1,311 @@
+/*
+ * linux/drivers/s390/scsi/zfcp_sysfs_port.c
+ *
+ * FCP adapter driver for IBM eServer zSeries
+ *
+ * sysfs port related routines
+ *
+ * (C) Copyright IBM Corp. 2003, 2004
+ *
+ * Authors:
+ * Martin Peschke <mpeschke@de.ibm.com>
+ * Heiko Carstens <heiko.carstens@de.ibm.com>
+ * Andreas Herrmann <aherrman@de.ibm.com>
+ * Volker Sameske <sameske@de.ibm.com>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2, or (at your option)
+ * any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#define ZFCP_SYSFS_PORT_C_REVISION "$Revision: 1.47 $"
+
+#include "zfcp_ext.h"
+
+#define ZFCP_LOG_AREA ZFCP_LOG_AREA_CONFIG
+
+/**
+ * zfcp_sysfs_port_release - gets called when a struct device port is released
+ * @dev: pointer to belonging device
+ */
+void
+zfcp_sysfs_port_release(struct device *dev)
+{
+ kfree(dev);
+}
+
+/**
+ * ZFCP_DEFINE_PORT_ATTR
+ * @_name: name of show attribute
+ * @_format: format string
+ * @_value: value to print
+ *
+ * Generates attributes for a port.
+ */
+#define ZFCP_DEFINE_PORT_ATTR(_name, _format, _value) \
+static ssize_t zfcp_sysfs_port_##_name##_show(struct device *dev, \
+ char *buf) \
+{ \
+ struct zfcp_port *port; \
+ \
+ port = dev_get_drvdata(dev); \
+ return sprintf(buf, _format, _value); \
+} \
+ \
+static DEVICE_ATTR(_name, S_IRUGO, zfcp_sysfs_port_##_name##_show, NULL);
+
+ZFCP_DEFINE_PORT_ATTR(status, "0x%08x\n", atomic_read(&port->status));
+ZFCP_DEFINE_PORT_ATTR(wwnn, "0x%016llx\n", port->wwnn);
+ZFCP_DEFINE_PORT_ATTR(d_id, "0x%06x\n", port->d_id);
+ZFCP_DEFINE_PORT_ATTR(scsi_id, "0x%x\n", port->scsi_id);
+ZFCP_DEFINE_PORT_ATTR(in_recovery, "%d\n", atomic_test_mask
+ (ZFCP_STATUS_COMMON_ERP_INUSE, &port->status));
+ZFCP_DEFINE_PORT_ATTR(access_denied, "%d\n", atomic_test_mask
+ (ZFCP_STATUS_COMMON_ACCESS_DENIED, &port->status));
+
+/**
+ * zfcp_sysfs_unit_add_store - add a unit to sysfs tree
+ * @dev: pointer to belonging device
+ * @buf: pointer to input buffer
+ * @count: number of bytes in buffer
+ *
+ * Store function of the "unit_add" attribute of a port.
+ */
+static ssize_t
+zfcp_sysfs_unit_add_store(struct device *dev, const char *buf, size_t count)
+{
+ fcp_lun_t fcp_lun;
+ char *endp;
+ struct zfcp_port *port;
+ struct zfcp_unit *unit;
+ int retval = -EINVAL;
+
+ down(&zfcp_data.config_sema);
+
+ port = dev_get_drvdata(dev);
+ if (atomic_test_mask(ZFCP_STATUS_COMMON_REMOVE, &port->status)) {
+ retval = -EBUSY;
+ goto out;
+ }
+
+ fcp_lun = simple_strtoull(buf, &endp, 0);
+ if ((endp + 1) < (buf + count))
+ goto out;
+
+ unit = zfcp_unit_enqueue(port, fcp_lun);
+ if (!unit)
+ goto out;
+
+ retval = 0;
+
+ zfcp_erp_unit_reopen(unit, 0);
+ zfcp_erp_wait(unit->port->adapter);
+ zfcp_unit_put(unit);
+ out:
+ up(&zfcp_data.config_sema);
+ return retval ? retval : (ssize_t) count;
+}
+
+static DEVICE_ATTR(unit_add, S_IWUSR, NULL, zfcp_sysfs_unit_add_store);
+
+/**
+ * zfcp_sysfs_unit_remove_store - remove a unit from sysfs tree
+ * @dev: pointer to belonging device
+ * @buf: pointer to input buffer
+ * @count: number of bytes in buffer
+ */
+static ssize_t
+zfcp_sysfs_unit_remove_store(struct device *dev, const char *buf, size_t count)
+{
+ struct zfcp_port *port;
+ struct zfcp_unit *unit;
+ fcp_lun_t fcp_lun;
+ char *endp;
+ int retval = 0;
+
+ down(&zfcp_data.config_sema);
+
+ port = dev_get_drvdata(dev);
+ if (atomic_test_mask(ZFCP_STATUS_COMMON_REMOVE, &port->status)) {
+ retval = -EBUSY;
+ goto out;
+ }
+
+ fcp_lun = simple_strtoull(buf, &endp, 0);
+ if ((endp + 1) < (buf + count)) {
+ retval = -EINVAL;
+ goto out;
+ }
+
+ write_lock_irq(&zfcp_data.config_lock);
+ unit = zfcp_get_unit_by_lun(port, fcp_lun);
+ if (unit && (atomic_read(&unit->refcount) == 0)) {
+ zfcp_unit_get(unit);
+ atomic_set_mask(ZFCP_STATUS_COMMON_REMOVE, &unit->status);
+ list_move(&unit->list, &port->unit_remove_lh);
+ }
+ else {
+ unit = NULL;
+ }
+ write_unlock_irq(&zfcp_data.config_lock);
+
+ if (!unit) {
+ retval = -ENXIO;
+ goto out;
+ }
+
+ zfcp_erp_unit_shutdown(unit, 0);
+ zfcp_erp_wait(unit->port->adapter);
+ zfcp_unit_put(unit);
+ zfcp_unit_dequeue(unit);
+ out:
+ up(&zfcp_data.config_sema);
+ return retval ? retval : (ssize_t) count;
+}
+
+static DEVICE_ATTR(unit_remove, S_IWUSR, NULL, zfcp_sysfs_unit_remove_store);
+
+/**
+ * zfcp_sysfs_port_failed_store - failed state of port
+ * @dev: pointer to belonging device
+ * @buf: pointer to input buffer
+ * @count: number of bytes in buffer
+ *
+ * Store function of the "failed" attribute of a port.
+ * If a "0" gets written to "failed", error recovery will be
+ * started for the belonging port.
+ */
+static ssize_t
+zfcp_sysfs_port_failed_store(struct device *dev, const char *buf, size_t count)
+{
+ struct zfcp_port *port;
+ unsigned int val;
+ char *endp;
+ int retval = 0;
+
+ down(&zfcp_data.config_sema);
+
+ port = dev_get_drvdata(dev);
+ if (atomic_test_mask(ZFCP_STATUS_COMMON_REMOVE, &port->status)) {
+ retval = -EBUSY;
+ goto out;
+ }
+
+ val = simple_strtoul(buf, &endp, 0);
+ if (((endp + 1) < (buf + count)) || (val != 0)) {
+ retval = -EINVAL;
+ goto out;
+ }
+
+ zfcp_erp_modify_port_status(port, ZFCP_STATUS_COMMON_RUNNING, ZFCP_SET);
+ zfcp_erp_port_reopen(port, ZFCP_STATUS_COMMON_ERP_FAILED);
+ zfcp_erp_wait(port->adapter);
+ out:
+ up(&zfcp_data.config_sema);
+ return retval ? retval : (ssize_t) count;
+}
+
+/**
+ * zfcp_sysfs_port_failed_show - failed state of port
+ * @dev: pointer to belonging device
+ * @buf: pointer to input buffer
+ *
+ * Show function of "failed" attribute of port. Will be
+ * "0" if port is working, otherwise "1".
+ */
+static ssize_t
+zfcp_sysfs_port_failed_show(struct device *dev, char *buf)
+{
+ struct zfcp_port *port;
+
+ port = dev_get_drvdata(dev);
+ if (atomic_test_mask(ZFCP_STATUS_COMMON_ERP_FAILED, &port->status))
+ return sprintf(buf, "1\n");
+ else
+ return sprintf(buf, "0\n");
+}
+
+static DEVICE_ATTR(failed, S_IWUSR | S_IRUGO, zfcp_sysfs_port_failed_show,
+ zfcp_sysfs_port_failed_store);
+
+/**
+ * zfcp_port_common_attrs
+ * sysfs attributes that are common for all kind of fc ports.
+ */
+static struct attribute *zfcp_port_common_attrs[] = {
+ &dev_attr_failed.attr,
+ &dev_attr_in_recovery.attr,
+ &dev_attr_status.attr,
+ &dev_attr_wwnn.attr,
+ &dev_attr_d_id.attr,
+ &dev_attr_access_denied.attr,
+ NULL
+};
+
+static struct attribute_group zfcp_port_common_attr_group = {
+ .attrs = zfcp_port_common_attrs,
+};
+
+/**
+ * zfcp_port_no_ns_attrs
+ * sysfs attributes not to be used for nameserver ports.
+ */
+static struct attribute *zfcp_port_no_ns_attrs[] = {
+ &dev_attr_unit_add.attr,
+ &dev_attr_unit_remove.attr,
+ &dev_attr_scsi_id.attr,
+ NULL
+};
+
+static struct attribute_group zfcp_port_no_ns_attr_group = {
+ .attrs = zfcp_port_no_ns_attrs,
+};
+
+/**
+ * zfcp_sysfs_port_create_files - create sysfs port files
+ * @dev: pointer to belonging device
+ *
+ * Create all attributes of the sysfs representation of a port.
+ */
+int
+zfcp_sysfs_port_create_files(struct device *dev, u32 flags)
+{
+ int retval;
+
+ retval = sysfs_create_group(&dev->kobj, &zfcp_port_common_attr_group);
+
+ if ((flags & ZFCP_STATUS_PORT_WKA) || retval)
+ return retval;
+
+ retval = sysfs_create_group(&dev->kobj, &zfcp_port_no_ns_attr_group);
+ if (retval)
+ sysfs_remove_group(&dev->kobj, &zfcp_port_common_attr_group);
+
+ return retval;
+}
+
+/**
+ * zfcp_sysfs_port_remove_files - remove sysfs port files
+ * @dev: pointer to belonging device
+ *
+ * Remove all attributes of the sysfs representation of a port.
+ */
+void
+zfcp_sysfs_port_remove_files(struct device *dev, u32 flags)
+{
+ sysfs_remove_group(&dev->kobj, &zfcp_port_common_attr_group);
+ if (!(flags & ZFCP_STATUS_PORT_WKA))
+ sysfs_remove_group(&dev->kobj, &zfcp_port_no_ns_attr_group);
+}
+
+#undef ZFCP_LOG_AREA
diff --git a/drivers/s390/scsi/zfcp_sysfs_unit.c b/drivers/s390/scsi/zfcp_sysfs_unit.c
new file mode 100644
index 0000000..87c0b461
--- /dev/null
+++ b/drivers/s390/scsi/zfcp_sysfs_unit.c
@@ -0,0 +1,179 @@
+/*
+ * linux/drivers/s390/scsi/zfcp_sysfs_unit.c
+ *
+ * FCP adapter driver for IBM eServer zSeries
+ *
+ * sysfs unit related routines
+ *
+ * (C) Copyright IBM Corp. 2003, 2004
+ *
+ * Authors:
+ * Martin Peschke <mpeschke@de.ibm.com>
+ * Heiko Carstens <heiko.carstens@de.ibm.com>
+ * Andreas Herrmann <aherrman@de.ibm.com>
+ * Volker Sameske <sameske@de.ibm.com>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2, or (at your option)
+ * any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#define ZFCP_SYSFS_UNIT_C_REVISION "$Revision: 1.30 $"
+
+#include "zfcp_ext.h"
+
+#define ZFCP_LOG_AREA ZFCP_LOG_AREA_CONFIG
+
+/**
+ * zfcp_sysfs_unit_release - gets called when a struct device unit is released
+ * @dev: pointer to belonging device
+ */
+void
+zfcp_sysfs_unit_release(struct device *dev)
+{
+ kfree(dev);
+}
+
+/**
+ * ZFCP_DEFINE_UNIT_ATTR
+ * @_name: name of show attribute
+ * @_format: format string
+ * @_value: value to print
+ *
+ * Generates attribute for a unit.
+ */
+#define ZFCP_DEFINE_UNIT_ATTR(_name, _format, _value) \
+static ssize_t zfcp_sysfs_unit_##_name##_show(struct device *dev, \
+ char *buf) \
+{ \
+ struct zfcp_unit *unit; \
+ \
+ unit = dev_get_drvdata(dev); \
+ return sprintf(buf, _format, _value); \
+} \
+ \
+static DEVICE_ATTR(_name, S_IRUGO, zfcp_sysfs_unit_##_name##_show, NULL);
+
+ZFCP_DEFINE_UNIT_ATTR(status, "0x%08x\n", atomic_read(&unit->status));
+ZFCP_DEFINE_UNIT_ATTR(scsi_lun, "0x%x\n", unit->scsi_lun);
+ZFCP_DEFINE_UNIT_ATTR(in_recovery, "%d\n", atomic_test_mask
+ (ZFCP_STATUS_COMMON_ERP_INUSE, &unit->status));
+ZFCP_DEFINE_UNIT_ATTR(access_denied, "%d\n", atomic_test_mask
+ (ZFCP_STATUS_COMMON_ACCESS_DENIED, &unit->status));
+ZFCP_DEFINE_UNIT_ATTR(access_shared, "%d\n", atomic_test_mask
+ (ZFCP_STATUS_UNIT_SHARED, &unit->status));
+ZFCP_DEFINE_UNIT_ATTR(access_readonly, "%d\n", atomic_test_mask
+ (ZFCP_STATUS_UNIT_READONLY, &unit->status));
+
+/**
+ * zfcp_sysfs_unit_failed_store - failed state of unit
+ * @dev: pointer to belonging device
+ * @buf: pointer to input buffer
+ * @count: number of bytes in buffer
+ *
+ * Store function of the "failed" attribute of a unit.
+ * If a "0" gets written to "failed", error recovery will be
+ * started for the belonging unit.
+ */
+static ssize_t
+zfcp_sysfs_unit_failed_store(struct device *dev, const char *buf, size_t count)
+{
+ struct zfcp_unit *unit;
+ unsigned int val;
+ char *endp;
+ int retval = 0;
+
+ down(&zfcp_data.config_sema);
+ unit = dev_get_drvdata(dev);
+ if (atomic_test_mask(ZFCP_STATUS_COMMON_REMOVE, &unit->status)) {
+ retval = -EBUSY;
+ goto out;
+ }
+
+ val = simple_strtoul(buf, &endp, 0);
+ if (((endp + 1) < (buf + count)) || (val != 0)) {
+ retval = -EINVAL;
+ goto out;
+ }
+
+ zfcp_erp_modify_unit_status(unit, ZFCP_STATUS_COMMON_RUNNING, ZFCP_SET);
+ zfcp_erp_unit_reopen(unit, ZFCP_STATUS_COMMON_ERP_FAILED);
+ zfcp_erp_wait(unit->port->adapter);
+ out:
+ up(&zfcp_data.config_sema);
+ return retval ? retval : (ssize_t) count;
+}
+
+/**
+ * zfcp_sysfs_unit_failed_show - failed state of unit
+ * @dev: pointer to belonging device
+ * @buf: pointer to input buffer
+ *
+ * Show function of "failed" attribute of unit. Will be
+ * "0" if unit is working, otherwise "1".
+ */
+static ssize_t
+zfcp_sysfs_unit_failed_show(struct device *dev, char *buf)
+{
+ struct zfcp_unit *unit;
+
+ unit = dev_get_drvdata(dev);
+ if (atomic_test_mask(ZFCP_STATUS_COMMON_ERP_FAILED, &unit->status))
+ return sprintf(buf, "1\n");
+ else
+ return sprintf(buf, "0\n");
+}
+
+static DEVICE_ATTR(failed, S_IWUSR | S_IRUGO, zfcp_sysfs_unit_failed_show,
+ zfcp_sysfs_unit_failed_store);
+
+static struct attribute *zfcp_unit_attrs[] = {
+ &dev_attr_scsi_lun.attr,
+ &dev_attr_failed.attr,
+ &dev_attr_in_recovery.attr,
+ &dev_attr_status.attr,
+ &dev_attr_access_denied.attr,
+ &dev_attr_access_shared.attr,
+ &dev_attr_access_readonly.attr,
+ NULL
+};
+
+static struct attribute_group zfcp_unit_attr_group = {
+ .attrs = zfcp_unit_attrs,
+};
+
+/**
+ * zfcp_sysfs_create_unit_files - create sysfs unit files
+ * @dev: pointer to belonging device
+ *
+ * Create all attributes of the sysfs representation of a unit.
+ */
+int
+zfcp_sysfs_unit_create_files(struct device *dev)
+{
+ return sysfs_create_group(&dev->kobj, &zfcp_unit_attr_group);
+}
+
+/**
+ * zfcp_sysfs_remove_unit_files - remove sysfs unit files
+ * @dev: pointer to belonging device
+ *
+ * Remove all attributes of the sysfs representation of a unit.
+ */
+void
+zfcp_sysfs_unit_remove_files(struct device *dev)
+{
+ sysfs_remove_group(&dev->kobj, &zfcp_unit_attr_group);
+}
+
+#undef ZFCP_LOG_AREA