13 files changed, 367 insertions, 30 deletions

diff --git a/include/scsi/iscsi_if.h b/include/scsi/iscsi_if.h
index 16be12f1cbe8..0c9514de5df7 100644
--- a/include/scsi/iscsi_if.h
+++ b/include/scsi/iscsi_if.h
@@ -213,6 +213,8 @@ enum iscsi_err {
         ISCSI_ERR_DATA_DGST             = ISCSI_ERR_BASE + 15,
         ISCSI_ERR_PARAM_NOT_FOUND       = ISCSI_ERR_BASE + 16,
         ISCSI_ERR_NO_SCSI_CMD           = ISCSI_ERR_BASE + 17,
+        ISCSI_ERR_INVALID_HOST          = ISCSI_ERR_BASE + 18,
+        ISCSI_ERR_XMIT_FAILED           = ISCSI_ERR_BASE + 19,
 };
 
 /*
diff --git a/include/scsi/libiscsi.h b/include/scsi/libiscsi.h
index 5e75bb7f311c..61e53f14f7e1 100644
--- a/include/scsi/libiscsi.h
+++ b/include/scsi/libiscsi.h
@@ -287,6 +287,11 @@ struct iscsi_session {
         struct iscsi_pool       cmdpool;        /* PDU's pool */
 };
 
+enum {
+        ISCSI_HOST_SETUP,
+        ISCSI_HOST_REMOVED,
+};
+
 struct iscsi_host {
         char                    *initiatorname;
         /* hw address or netdev iscsi connection is bound to */
@@ -295,6 +300,12 @@ struct iscsi_host {
         /* local address */
         int                     local_port;
         char                    local_address[ISCSI_ADDRESS_BUF_LEN];
+
+        wait_queue_head_t       session_removal_wq;
+        /* protects sessions and state */
+        spinlock_t              lock;
+        int                     num_sessions;
+        int                     state;
 };
 
 /*
@@ -302,7 +313,7 @@ struct iscsi_host {
  */
 extern int iscsi_change_queue_depth(struct scsi_device *sdev, int depth);
 extern int iscsi_eh_abort(struct scsi_cmnd *sc);
-extern int iscsi_eh_host_reset(struct scsi_cmnd *sc);
+extern int iscsi_eh_target_reset(struct scsi_cmnd *sc);
 extern int iscsi_eh_device_reset(struct scsi_cmnd *sc);
 extern int iscsi_queuecommand(struct scsi_cmnd *sc,
                               void (*done)(struct scsi_cmnd *));
@@ -351,6 +362,8 @@ extern void iscsi_conn_stop(struct iscsi_cls_conn *, int);
 extern int iscsi_conn_bind(struct iscsi_cls_session *, struct iscsi_cls_conn *,
                            int);
 extern void iscsi_conn_failure(struct iscsi_conn *conn, enum iscsi_err err);
+extern void iscsi_session_failure(struct iscsi_cls_session *cls_session,
+                                  enum iscsi_err err);
 extern int iscsi_conn_get_param(struct iscsi_cls_conn *cls_conn,
                                 enum iscsi_param param, char *buf);
 extern void iscsi_suspend_tx(struct iscsi_conn *conn);
diff --git a/include/scsi/scsi.h b/include/scsi/scsi.h
index 00137a7769ee..a109165714d6 100644
--- a/include/scsi/scsi.h
+++ b/include/scsi/scsi.h
@@ -106,6 +106,7 @@
 #define VARIABLE_LENGTH_CMD   0x7f
 #define REPORT_LUNS           0xa0
 #define MAINTENANCE_IN        0xa3
+#define MAINTENANCE_OUT       0xa4
 #define MOVE_MEDIUM           0xa5
 #define EXCHANGE_MEDIUM       0xa6
 #define READ_12               0xa8
@@ -125,6 +126,8 @@
 #define SAI_READ_CAPACITY_16  0x10
 /* values for maintenance in */
 #define MI_REPORT_TARGET_PGS  0x0a
+/* values for maintenance out */
+#define MO_SET_TARGET_PGS     0x0a
 
 /* Values for T10/04-262r7 */
 #define ATA_16                0x85      /* 16-byte pass-thru */
@@ -306,6 +309,20 @@ struct scsi_lun {
 };
 
 /*
+ * The Well Known LUNS (SAM-3) in our int representation of a LUN
+ */
+#define SCSI_W_LUN_BASE 0xc100
+#define SCSI_W_LUN_REPORT_LUNS (SCSI_W_LUN_BASE + 1)
+#define SCSI_W_LUN_ACCESS_CONTROL (SCSI_W_LUN_BASE + 2)
+#define SCSI_W_LUN_TARGET_LOG_PAGE (SCSI_W_LUN_BASE + 3)
+
+static inline int scsi_is_wlun(unsigned int lun)
+{
+        return (lun & 0xff00) == SCSI_W_LUN_BASE;
+}
+
+
+/*
  *  MESSAGE CODES
  */
 
@@ -364,6 +381,11 @@ struct scsi_lun {
 #define DID_IMM_RETRY   0x0c    /* Retry without decrementing retry count  */
 #define DID_REQUEUE     0x0d    /* Requeue command (no immediate retry) also
                                  * without decrementing the retry count    */
+#define DID_TRANSPORT_DISRUPTED 0x0e /* Transport error disrupted execution
+                                      * and the driver blocked the port to
+                                      * recover the link. Transport class will
+                                      * retry or fail IO */
+#define DID_TRANSPORT_FAILFAST  0x0f /* Transport class fastfailed the io */
 #define DRIVER_OK       0x00    /* Driver status                           */
 
 /*
@@ -409,6 +431,7 @@ struct scsi_lun {
 #define SCSI_MLQUEUE_HOST_BUSY   0x1055
 #define SCSI_MLQUEUE_DEVICE_BUSY 0x1056
 #define SCSI_MLQUEUE_EH_RETRY    0x1057
+#define SCSI_MLQUEUE_TARGET_BUSY 0x1058
 
 /*
  *  Use these to separate status msg and our bytes
diff --git a/include/scsi/scsi_cmnd.h b/include/scsi/scsi_cmnd.h
index 66c944849d6b..855bf95963e7 100644
--- a/include/scsi/scsi_cmnd.h
+++ b/include/scsi/scsi_cmnd.h
@@ -75,7 +75,9 @@ struct scsi_cmnd {
 
         int retries;
         int allowed;
-        int timeout_per_command;
+
+        unsigned char prot_op;
+        unsigned char prot_type;
 
         unsigned short cmd_len;
         enum dma_data_direction sc_data_direction;
@@ -83,10 +85,11 @@ struct scsi_cmnd {
         /* These elements define the operation we are about to perform */
         unsigned char *cmnd;
 
-        struct timer_list eh_timeout;   /* Used to time out the command. */
 
         /* These elements define the operation we ultimately want to perform */
         struct scsi_data_buffer sdb;
+        struct scsi_data_buffer *prot_sdb;
+
         unsigned underflow;     /* Return error if less than
                                    this amount is transferred */
 
@@ -134,7 +137,6 @@ extern void scsi_put_command(struct scsi_cmnd *);
 extern void __scsi_put_command(struct Scsi_Host *, struct scsi_cmnd *,
                                struct device *);
 extern void scsi_finish_command(struct scsi_cmnd *cmd);
-extern void scsi_req_abort_cmd(struct scsi_cmnd *cmd);
 
 extern void *scsi_kmap_atomic_sg(struct scatterlist *sg, int sg_count,
                                  size_t *offset, size_t *len);
@@ -208,4 +210,85 @@ static inline int scsi_sg_copy_to_buffer(struct scsi_cmnd *cmd,
                                  buf, buflen);
 }
 
+/*
+ * The operations below are hints that tell the controller driver how
+ * to handle I/Os with DIF or similar types of protection information.
+ */
+enum scsi_prot_operations {
+        /* Normal I/O */
+        SCSI_PROT_NORMAL = 0,
+
+        /* OS-HBA: Protected, HBA-Target: Unprotected */
+        SCSI_PROT_READ_INSERT,
+        SCSI_PROT_WRITE_STRIP,
+
+        /* OS-HBA: Unprotected, HBA-Target: Protected */
+        SCSI_PROT_READ_STRIP,
+        SCSI_PROT_WRITE_INSERT,
+
+        /* OS-HBA: Protected, HBA-Target: Protected */
+        SCSI_PROT_READ_PASS,
+        SCSI_PROT_WRITE_PASS,
+
+        /* OS-HBA: Protected, HBA-Target: Protected, checksum conversion */
+        SCSI_PROT_READ_CONVERT,
+        SCSI_PROT_WRITE_CONVERT,
+};
+
+static inline void scsi_set_prot_op(struct scsi_cmnd *scmd, unsigned char op)
+{
+        scmd->prot_op = op;
+}
+
+static inline unsigned char scsi_get_prot_op(struct scsi_cmnd *scmd)
+{
+        return scmd->prot_op;
+}
+
+/*
+ * The controller usually does not know anything about the target it
+ * is communicating with.  However, when DIX is enabled the controller
+ * must be know target type so it can verify the protection
+ * information passed along with the I/O.
+ */
+enum scsi_prot_target_type {
+        SCSI_PROT_DIF_TYPE0 = 0,
+        SCSI_PROT_DIF_TYPE1,
+        SCSI_PROT_DIF_TYPE2,
+        SCSI_PROT_DIF_TYPE3,
+};
+
+static inline void scsi_set_prot_type(struct scsi_cmnd *scmd, unsigned char type)
+{
+        scmd->prot_type = type;
+}
+
+static inline unsigned char scsi_get_prot_type(struct scsi_cmnd *scmd)
+{
+        return scmd->prot_type;
+}
+
+static inline sector_t scsi_get_lba(struct scsi_cmnd *scmd)
+{
+        return scmd->request->sector;
+}
+
+static inline unsigned scsi_prot_sg_count(struct scsi_cmnd *cmd)
+{
+        return cmd->prot_sdb ? cmd->prot_sdb->table.nents : 0;
+}
+
+static inline struct scatterlist *scsi_prot_sglist(struct scsi_cmnd *cmd)
+{
+        return cmd->prot_sdb ? cmd->prot_sdb->table.sgl : NULL;
+}
+
+static inline struct scsi_data_buffer *scsi_prot(struct scsi_cmnd *cmd)
+{
+        return cmd->prot_sdb;
+}
+
+#define scsi_for_each_prot_sg(cmd, sg, nseg, __i)               \
+        for_each_sg(scsi_prot_sglist(cmd), sg, nseg, __i)
+
 #endif /* _SCSI_SCSI_CMND_H */
diff --git a/include/scsi/scsi_device.h b/include/scsi/scsi_device.h
index 6467f78b191f..a37a8148a310 100644
--- a/include/scsi/scsi_device.h
+++ b/include/scsi/scsi_device.h
@@ -6,6 +6,7 @@
 #include <linux/spinlock.h>
 #include <linux/workqueue.h>
 #include <linux/blkdev.h>
+#include <scsi/scsi.h>
 #include <asm/atomic.h>
 
 struct request_queue;
@@ -41,9 +42,11 @@ enum scsi_device_state {
                                  * originate in the mid-layer) */
         SDEV_OFFLINE,           /* Device offlined (by error handling or
                                  * user request */
-        SDEV_BLOCK,             /* Device blocked by scsi lld.  No scsi 
-                                 * commands from user or midlayer should be issued
-                                 * to the scsi lld. */
+        SDEV_BLOCK,             /* Device blocked by scsi lld.  No
+                                 * scsi commands from user or midlayer
+                                 * should be issued to the scsi
+                                 * lld. */
+        SDEV_CREATED_BLOCK,     /* same as above but for created devices */
 };
 
 enum scsi_device_event {
@@ -140,7 +143,8 @@ struct scsi_device {
         unsigned fix_capacity:1;        /* READ_CAPACITY is too high by 1 */
         unsigned guess_capacity:1;      /* READ_CAPACITY might be too high by 1 */
         unsigned retry_hwerror:1;       /* Retry HARDWARE_ERROR */
-        unsigned last_sector_bug:1;     /* Always read last sector in a 1 sector read */
+        unsigned last_sector_bug:1;     /* do not use multisector accesses on
+                                           SD_LAST_BUGGY_SECTORS */
 
         DECLARE_BITMAP(supported_events, SDEV_EVT_MAXBITS); /* supported events */
         struct list_head event_list;    /* asserted events */
@@ -167,15 +171,22 @@ struct scsi_device {
         unsigned long           sdev_data[0];
 } __attribute__((aligned(sizeof(unsigned long))));
 
+struct scsi_dh_devlist {
+        char *vendor;
+        char *model;
+};
+
 struct scsi_device_handler {
         /* Used by the infrastructure */
         struct list_head list; /* list of scsi_device_handlers */
-        struct notifier_block nb;
 
         /* Filled by the hardware handler */
         struct module *module;
         const char *name;
+        const struct scsi_dh_devlist *devlist;
         int (*check_sense)(struct scsi_device *, struct scsi_sense_hdr *);
+        int (*attach)(struct scsi_device *);
+        void (*detach)(struct scsi_device *);
         int (*activate)(struct scsi_device *);
         int (*prep_fn)(struct scsi_device *, struct request *);
 };
@@ -227,6 +238,16 @@ struct scsi_target {
                                                  * for the device at a time. */
         unsigned int            pdt_1f_for_no_lun;      /* PDT = 0x1f */
                                                 /* means no lun present */
+        /* commands actually active on LLD. protected by host lock. */
+        unsigned int            target_busy;
+        /*
+         * LLDs should set this in the slave_alloc host template callout.
+         * If set to zero then there is not limit.
+         */
+        unsigned int            can_queue;
+        unsigned int            target_blocked;
+        unsigned int            max_target_blocked;
+#define SCSI_DEFAULT_TARGET_BLOCKED     3
 
         char                    scsi_level;
         struct execute_work     ew;
@@ -375,10 +396,23 @@ static inline unsigned int sdev_id(struct scsi_device *sdev)
 #define scmd_id(scmd) sdev_id((scmd)->device)
 #define scmd_channel(scmd) sdev_channel((scmd)->device)
 
+/*
+ * checks for positions of the SCSI state machine
+ */
 static inline int scsi_device_online(struct scsi_device *sdev)
 {
         return sdev->sdev_state != SDEV_OFFLINE;
 }
+static inline int scsi_device_blocked(struct scsi_device *sdev)
+{
+        return sdev->sdev_state == SDEV_BLOCK ||
+                sdev->sdev_state == SDEV_CREATED_BLOCK;
+}
+static inline int scsi_device_created(struct scsi_device *sdev)
+{
+        return sdev->sdev_state == SDEV_CREATED ||
+                sdev->sdev_state == SDEV_CREATED_BLOCK;
+}
 
 /* accessor functions for the SCSI parameters */
 static inline int scsi_device_sync(struct scsi_device *sdev)
@@ -416,6 +450,11 @@ static inline int scsi_device_enclosure(struct scsi_device *sdev)
         return sdev->inquiry[6] & (1<<6);
 }
 
+static inline int scsi_device_protection(struct scsi_device *sdev)
+{
+        return sdev->scsi_level > SCSI_2 && sdev->inquiry[5] & (1<<0);
+}
+
 #define MODULE_ALIAS_SCSI_DEVICE(type) \
         MODULE_ALIAS("scsi:t-" __stringify(type) "*")
 #define SCSI_DEVICE_MODALIAS_FMT "scsi:t-0x%02x"
diff --git a/include/scsi/scsi_dh.h b/include/scsi/scsi_dh.h
index 3ad2303d1a16..33efce20c26c 100644
--- a/include/scsi/scsi_dh.h
+++ b/include/scsi/scsi_dh.h
@@ -32,6 +32,7 @@ enum {
          */
         SCSI_DH_DEV_FAILED,     /* generic device error */
         SCSI_DH_DEV_TEMP_BUSY,
+        SCSI_DH_DEV_UNSUPP,     /* device handler not supported */
         SCSI_DH_DEVICE_MAX,     /* max device blkerr definition */
 
         /*
@@ -57,6 +58,8 @@ enum {
 #if defined(CONFIG_SCSI_DH) || defined(CONFIG_SCSI_DH_MODULE)
 extern int scsi_dh_activate(struct request_queue *);
 extern int scsi_dh_handler_exist(const char *);
+extern int scsi_dh_attach(struct request_queue *, const char *);
+extern void scsi_dh_detach(struct request_queue *);
 #else
 static inline int scsi_dh_activate(struct request_queue *req)
 {
@@ -66,4 +69,12 @@ static inline int scsi_dh_handler_exist(const char *name)
 {
         return 0;
 }
+static inline int scsi_dh_attach(struct request_queue *req, const char *name)
+{
+        return SCSI_DH_NOSYS;
+}
+static inline void scsi_dh_detach(struct request_queue *q)
+{
+        return;
+}
 #endif
diff --git a/include/scsi/scsi_eh.h b/include/scsi/scsi_eh.h
index 2a9add21267d..06a8790893ef 100644
--- a/include/scsi/scsi_eh.h
+++ b/include/scsi/scsi_eh.h
@@ -74,7 +74,9 @@ struct scsi_eh_save {
         /* saved state */
         int result;
         enum dma_data_direction data_direction;
+        unsigned underflow;
         unsigned char cmd_len;
+        unsigned char prot_op;
         unsigned char *cmnd;
         struct scsi_data_buffer sdb;
         struct request *next_rq;
diff --git a/include/scsi/scsi_host.h b/include/scsi/scsi_host.h
index 1834fdfe82a7..d123ca84e732 100644
--- a/include/scsi/scsi_host.h
+++ b/include/scsi/scsi_host.h
@@ -43,13 +43,6 @@ struct blk_queue_tags;
 #define DISABLE_CLUSTERING 0
 #define ENABLE_CLUSTERING 1
 
-enum scsi_eh_timer_return {
-        EH_NOT_HANDLED,
-        EH_HANDLED,
-        EH_RESET_TIMER,
-};
-
-
 struct scsi_host_template {
         struct module *module;
         const char *name;
@@ -347,7 +340,7 @@ struct scsi_host_template {
          *
          * Status: OPTIONAL
          */
-        enum scsi_eh_timer_return (* eh_timed_out)(struct scsi_cmnd *);
+        enum blk_eh_timer_return (*eh_timed_out)(struct scsi_cmnd *);
 
         /*
          * Name of proc directory
@@ -547,7 +540,7 @@ struct Scsi_Host {
         unsigned int host_failed;          /* commands that failed. */
         unsigned int host_eh_scheduled;    /* EH scheduled without command */
     
-        unsigned short host_no;  /* Used for IOCTL_GET_IDLUN, /proc/scsi et al. */
+        unsigned int host_no;  /* Used for IOCTL_GET_IDLUN, /proc/scsi et al. */
         int resetting; /* if set, it means that last_reset is a valid value */
         unsigned long last_reset;
 
@@ -623,7 +616,7 @@ struct Scsi_Host {
         /*
          * Optional work queue to be utilized by the transport
          */
-        char work_q_name[KOBJ_NAME_LEN];
+        char work_q_name[20];
         struct workqueue_struct *work_q;
 
         /*
@@ -636,6 +629,10 @@ struct Scsi_Host {
          */
         unsigned int max_host_blocked;
 
+        /* Protection Information */
+        unsigned int prot_capabilities;
+        unsigned char prot_guard_type;
+
         /*
          * q used for scsi_tgt msgs, async events or any other requests that
          * need to be processed in userspace
@@ -756,6 +753,86 @@ extern struct request_queue *__scsi_alloc_queue(struct Scsi_Host *shost,
 extern void scsi_free_host_dev(struct scsi_device *);
 extern struct scsi_device *scsi_get_host_dev(struct Scsi_Host *);
 
+/*
+ * DIF defines the exchange of protection information between
+ * initiator and SBC block device.
+ *
+ * DIX defines the exchange of protection information between OS and
+ * initiator.
+ */
+enum scsi_host_prot_capabilities {
+        SHOST_DIF_TYPE1_PROTECTION = 1 << 0, /* T10 DIF Type 1 */
+        SHOST_DIF_TYPE2_PROTECTION = 1 << 1, /* T10 DIF Type 2 */
+        SHOST_DIF_TYPE3_PROTECTION = 1 << 2, /* T10 DIF Type 3 */
+
+        SHOST_DIX_TYPE0_PROTECTION = 1 << 3, /* DIX between OS and HBA only */
+        SHOST_DIX_TYPE1_PROTECTION = 1 << 4, /* DIX with DIF Type 1 */
+        SHOST_DIX_TYPE2_PROTECTION = 1 << 5, /* DIX with DIF Type 2 */
+        SHOST_DIX_TYPE3_PROTECTION = 1 << 6, /* DIX with DIF Type 3 */
+};
+
+/*
+ * SCSI hosts which support the Data Integrity Extensions must
+ * indicate their capabilities by setting the prot_capabilities using
+ * this call.
+ */
+static inline void scsi_host_set_prot(struct Scsi_Host *shost, unsigned int mask)
+{
+        shost->prot_capabilities = mask;
+}
+
+static inline unsigned int scsi_host_get_prot(struct Scsi_Host *shost)
+{
+        return shost->prot_capabilities;
+}
+
+static inline unsigned int scsi_host_dif_capable(struct Scsi_Host *shost, unsigned int target_type)
+{
+        switch (target_type) {
+        case 1: return shost->prot_capabilities & SHOST_DIF_TYPE1_PROTECTION;
+        case 2: return shost->prot_capabilities & SHOST_DIF_TYPE2_PROTECTION;
+        case 3: return shost->prot_capabilities & SHOST_DIF_TYPE3_PROTECTION;
+        }
+
+        return 0;
+}
+
+static inline unsigned int scsi_host_dix_capable(struct Scsi_Host *shost, unsigned int target_type)
+{
+        switch (target_type) {
+        case 0: return shost->prot_capabilities & SHOST_DIX_TYPE0_PROTECTION;
+        case 1: return shost->prot_capabilities & SHOST_DIX_TYPE1_PROTECTION;
+        case 2: return shost->prot_capabilities & SHOST_DIX_TYPE2_PROTECTION;
+        case 3: return shost->prot_capabilities & SHOST_DIX_TYPE3_PROTECTION;
+        }
+
+        return 0;
+}
+
+/*
+ * All DIX-capable initiators must support the T10-mandated CRC
+ * checksum.  Controllers can optionally implement the IP checksum
+ * scheme which has much lower impact on system performance.  Note
+ * that the main rationale for the checksum is to match integrity
+ * metadata with data.  Detecting bit errors are a job for ECC memory
+ * and buses.
+ */
+
+enum scsi_host_guard_type {
+        SHOST_DIX_GUARD_CRC = 1 << 0,
+        SHOST_DIX_GUARD_IP  = 1 << 1,
+};
+
+static inline void scsi_host_set_guard(struct Scsi_Host *shost, unsigned char type)
+{
+        shost->prot_guard_type = type;
+}
+
+static inline unsigned char scsi_host_get_guard(struct Scsi_Host *shost)
+{
+        return shost->prot_guard_type;
+}
+
 /* legacy interfaces */
 extern struct Scsi_Host *scsi_register(struct scsi_host_template *, int);
 extern void scsi_unregister(struct Scsi_Host *);
diff --git a/include/scsi/scsi_ioctl.h b/include/scsi/scsi_ioctl.h
index edb9525386da..b9006848b813 100644
--- a/include/scsi/scsi_ioctl.h
+++ b/include/scsi/scsi_ioctl.h
@@ -42,7 +42,7 @@ typedef struct scsi_fctargaddress {
 
 extern int scsi_ioctl(struct scsi_device *, int, void __user *);
 extern int scsi_nonblockable_ioctl(struct scsi_device *sdev, int cmd,
-                                   void __user *arg, struct file *filp);
+                                   void __user *arg, int ndelay);
 
 #endif /* __KERNEL__ */
 #endif /* _SCSI_IOCTL_H */
diff --git a/include/scsi/scsi_netlink.h b/include/scsi/scsi_netlink.h
index 8c1470cc8209..536752c40d41 100644
--- a/include/scsi/scsi_netlink.h
+++ b/include/scsi/scsi_netlink.h
@@ -22,6 +22,9 @@
 #ifndef SCSI_NETLINK_H
 #define SCSI_NETLINK_H
 
+#include <linux/netlink.h>
+
+
 /*
  * This file intended to be included by both kernel and user space
  */
@@ -55,7 +58,41 @@ struct scsi_nl_hdr {
 #define SCSI_NL_TRANSPORT_FC                    1
 #define SCSI_NL_MAX_TRANSPORTS                  2
 
-/* scsi_nl_hdr->msgtype values are defined in each transport */
+/* Transport-based scsi_nl_hdr->msgtype values are defined in each transport */
+
+/*
+ * GENERIC SCSI scsi_nl_hdr->msgtype Values
+ */
+        /* kernel -> user */
+#define SCSI_NL_SHOST_VENDOR                    0x0001
+        /* user -> kernel */
+/* SCSI_NL_SHOST_VENDOR msgtype is kernel->user and user->kernel */
+
+
+/*
+ * Message Structures :
+ */
+
+/* macro to round up message lengths to 8byte boundary */
+#define SCSI_NL_MSGALIGN(len)           (((len) + 7) & ~7)
+
+
+/*
+ * SCSI HOST Vendor Unique messages :
+ *   SCSI_NL_SHOST_VENDOR
+ *
+ * Note: The Vendor Unique message payload will begin directly after
+ *       this structure, with the length of the payload per vmsg_datalen.
+ *
+ * Note: When specifying vendor_id, be sure to read the Vendor Type and ID
+ *   formatting requirements specified below
+ */
+struct scsi_nl_host_vendor_msg {
+        struct scsi_nl_hdr snlh;                /* must be 1st element ! */
+        uint64_t vendor_id;
+        uint16_t host_no;
+        uint16_t vmsg_datalen;
+} __attribute__((aligned(sizeof(uint64_t))));
 
 
 /*
@@ -83,5 +120,28 @@ struct scsi_nl_hdr {
         }
 
 
+#ifdef __KERNEL__
+
+#include <scsi/scsi_host.h>
+
+/* Exported Kernel Interfaces */
+int scsi_nl_add_transport(u8 tport,
+         int (*msg_handler)(struct sk_buff *),
+        void (*event_handler)(struct notifier_block *, unsigned long, void *));
+void scsi_nl_remove_transport(u8 tport);
+
+int scsi_nl_add_driver(u64 vendor_id, struct scsi_host_template *hostt,
+        int (*nlmsg_handler)(struct Scsi_Host *shost, void *payload,
+                                 u32 len, u32 pid),
+        void (*nlevt_handler)(struct notifier_block *nb,
+                                 unsigned long event, void *notify_ptr));
+void scsi_nl_remove_driver(u64 vendor_id);
+
+void scsi_nl_send_transport_msg(u32 pid, struct scsi_nl_hdr *hdr);
+int scsi_nl_send_vendor_msg(u32 pid, unsigned short host_no, u64 vendor_id,
+                         char *data_buf, u32 data_len);
+
+#endif /* __KERNEL__ */
+
 #endif /* SCSI_NETLINK_H */
 
diff --git a/include/scsi/scsi_transport.h b/include/scsi/scsi_transport.h
index 490bd13a634c..0de32cd4e8a7 100644
--- a/include/scsi/scsi_transport.h
+++ b/include/scsi/scsi_transport.h
@@ -21,6 +21,7 @@
 #define SCSI_TRANSPORT_H
 
 #include <linux/transport_class.h>
+#include <linux/blkdev.h>
 #include <scsi/scsi_host.h>
 #include <scsi/scsi_device.h>
 
@@ -64,7 +65,7 @@ struct scsi_transport_template {
          *                      begin counting again
          * EH_NOT_HANDLED       Begin normal error recovery
          */
-        enum scsi_eh_timer_return (* eh_timed_out)(struct scsi_cmnd *);
+        enum blk_eh_timer_return (*eh_timed_out)(struct scsi_cmnd *);
 
         /*
          * Used as callback for the completion of i_t_nexus request
diff --git a/include/scsi/scsi_transport_fc.h b/include/scsi/scsi_transport_fc.h
index 06f72bab9df0..49d8913c4f86 100644
--- a/include/scsi/scsi_transport_fc.h
+++ b/include/scsi/scsi_transport_fc.h
@@ -167,6 +167,26 @@ enum fc_tgtid_binding_type  {
 struct device_attribute dev_attr_vport_##_name =        \
         __ATTR(_name,_mode,_show,_store)
 
+/*
+ * fc_vport_identifiers: This set of data contains all elements
+ * to uniquely identify and instantiate a FC virtual port.
+ *
+ * Notes:
+ *   symbolic_name: The driver is to append the symbolic_name string data
+ *      to the symbolic_node_name data that it generates by default.
+ *      the resulting combination should then be registered with the switch.
+ *      It is expected that things like Xen may stuff a VM title into
+ *      this field.
+ */
+#define FC_VPORT_SYMBOLIC_NAMELEN               64
+struct fc_vport_identifiers {
+        u64 node_name;
+        u64 port_name;
+        u32 roles;
+        bool disable;
+        enum fc_port_type vport_type;   /* only FC_PORTTYPE_NPIV allowed */
+        char symbolic_name[FC_VPORT_SYMBOLIC_NAMELEN];
+};
 
 /*
  * FC Virtual Port Attributes
@@ -197,7 +217,6 @@ struct device_attribute dev_attr_vport_##_name = 	\
  * managed by the transport w/o driver interaction.
  */
 
-#define FC_VPORT_SYMBOLIC_NAMELEN               64
 struct fc_vport {
         /* Fixed Attributes */
 
@@ -338,6 +357,7 @@ struct fc_rport {	/* aka fc_starget_attrs */
 /* bit field values for struct fc_rport "flags" field: */
 #define FC_RPORT_DEVLOSS_PENDING        0x01
 #define FC_RPORT_SCAN_PENDING           0x02
+#define FC_RPORT_FAST_FAIL_TIMEDOUT     0x03
 
 #define dev_to_rport(d)                         \
         container_of(d, struct fc_rport, dev)
@@ -489,9 +509,9 @@ struct fc_host_attrs {
         u16 npiv_vports_inuse;
 
         /* work queues for rport state manipulation */
-        char work_q_name[KOBJ_NAME_LEN];
+        char work_q_name[20];
         struct workqueue_struct *work_q;
-        char devloss_work_q_name[KOBJ_NAME_LEN];
+        char devloss_work_q_name[20];
         struct workqueue_struct *devloss_work_q;
 };
 
@@ -659,12 +679,15 @@ fc_remote_port_chkready(struct fc_rport *rport)
                 if (rport->roles & FC_PORT_ROLE_FCP_TARGET)
                         result = 0;
                 else if (rport->flags & FC_RPORT_DEVLOSS_PENDING)
-                        result = DID_IMM_RETRY << 16;
+                        result = DID_TRANSPORT_DISRUPTED << 16;
                 else
                         result = DID_NO_CONNECT << 16;
                 break;
         case FC_PORTSTATE_BLOCKED:
-                result = DID_IMM_RETRY << 16;
+                if (rport->flags & FC_RPORT_FAST_FAIL_TIMEDOUT)
+                        result = DID_TRANSPORT_FAILFAST << 16;
+                else
+                        result = DID_TRANSPORT_DISRUPTED << 16;
                 break;
         default:
                 result = DID_NO_CONNECT << 16;
@@ -732,6 +755,8 @@ void fc_host_post_vendor_event(struct Scsi_Host *shost, u32 event_number,
          *   be sure to read the Vendor Type and ID formatting requirements
          *   specified in scsi_netlink.h
          */
+struct fc_vport *fc_vport_create(struct Scsi_Host *shost, int channel,
+                struct fc_vport_identifiers *);
 int fc_vport_terminate(struct fc_vport *vport);
 
 #endif /* SCSI_TRANSPORT_FC_H */
diff --git a/include/scsi/scsi_transport_iscsi.h b/include/scsi/scsi_transport_iscsi.h
index f5444e033cc9..c667cc396545 100644
--- a/include/scsi/scsi_transport_iscsi.h
+++ b/include/scsi/scsi_transport_iscsi.h
@@ -135,7 +135,8 @@ extern int iscsi_unregister_transport(struct iscsi_transport *tt);
 /*
  * control plane upcalls
  */
-extern void iscsi_conn_error(struct iscsi_cls_conn *conn, enum iscsi_err error);
+extern void iscsi_conn_error_event(struct iscsi_cls_conn *conn,
+                                   enum iscsi_err error);
 extern int iscsi_recv_pdu(struct iscsi_cls_conn *conn, struct iscsi_hdr *hdr,
                           char *data, uint32_t data_size);
 
@@ -198,7 +199,7 @@ struct iscsi_cls_host {
         atomic_t nr_scans;
         struct mutex mutex;
         struct workqueue_struct *scan_workq;
-        char scan_workq_name[KOBJ_NAME_LEN];
+        char scan_workq_name[20];
 };
 
 extern void iscsi_host_for_each_session(struct Scsi_Host *shost,
@@ -207,7 +208,7 @@ extern void iscsi_host_for_each_session(struct Scsi_Host *shost,
 struct iscsi_endpoint {
         void *dd_data;                  /* LLD private data */
         struct device dev;
-        unsigned int id;
+        uint64_t id;
 };
 
 /*