5 files changed, 177 insertions, 149 deletions

diff --git a/drivers/scsi/device_handler/scsi_dh.c b/drivers/scsi/device_handler/scsi_dh.c
index 6fae3d285ae7..0119b8147797 100644
--- a/drivers/scsi/device_handler/scsi_dh.c
+++ b/drivers/scsi/device_handler/scsi_dh.c
@@ -25,16 +25,9 @@
 #include <scsi/scsi_dh.h>
 #include "../scsi_priv.h"
 
-struct scsi_dh_devinfo_list {
-        struct list_head node;
-        char vendor[9];
-        char model[17];
-        struct scsi_device_handler *handler;
-};
-
 static DEFINE_SPINLOCK(list_lock);
 static LIST_HEAD(scsi_dh_list);
-static LIST_HEAD(scsi_dh_dev_list);
+static int scsi_dh_list_idx = 1;
 
 static struct scsi_device_handler *get_device_handler(const char *name)
 {
@@ -51,40 +44,18 @@ static struct scsi_device_handler *get_device_handler(const char *name)
         return found;
 }
 
-
-static struct scsi_device_handler *
-scsi_dh_cache_lookup(struct scsi_device *sdev)
+static struct scsi_device_handler *get_device_handler_by_idx(int idx)
 {
-        struct scsi_dh_devinfo_list *tmp;
-        struct scsi_device_handler *found_dh = NULL;
+        struct scsi_device_handler *tmp, *found = NULL;
 
         spin_lock(&list_lock);
-        list_for_each_entry(tmp, &scsi_dh_dev_list, node) {
-                if (!strncmp(sdev->vendor, tmp->vendor, strlen(tmp->vendor)) &&
-                    !strncmp(sdev->model, tmp->model, strlen(tmp->model))) {
-                        found_dh = tmp->handler;
+        list_for_each_entry(tmp, &scsi_dh_list, list) {
+                if (tmp->idx == idx) {
+                        found = tmp;
                         break;
                 }
         }
         spin_unlock(&list_lock);
-
-        return found_dh;
-}
-
-static int scsi_dh_handler_lookup(struct scsi_device_handler *scsi_dh,
-                                  struct scsi_device *sdev)
-{
-        int i, found = 0;
-
-        for(i = 0; scsi_dh->devlist[i].vendor; i++) {
-                if (!strncmp(sdev->vendor, scsi_dh->devlist[i].vendor,
-                             strlen(scsi_dh->devlist[i].vendor)) &&
-                    !strncmp(sdev->model, scsi_dh->devlist[i].model,
-                             strlen(scsi_dh->devlist[i].model))) {
-                        found = 1;
-                        break;
-                }
-        }
         return found;
 }
 
@@ -102,41 +73,14 @@ device_handler_match(struct scsi_device_handler *scsi_dh,
                      struct scsi_device *sdev)
 {
         struct scsi_device_handler *found_dh = NULL;
-        struct scsi_dh_devinfo_list *tmp;
+        int idx;
 
-        found_dh = scsi_dh_cache_lookup(sdev);
-        if (found_dh)
-                return found_dh;
+        idx = scsi_get_device_flags_keyed(sdev, sdev->vendor, sdev->model,
+                                          SCSI_DEVINFO_DH);
+        found_dh = get_device_handler_by_idx(idx);
 
-        if (scsi_dh) {
-                if (scsi_dh_handler_lookup(scsi_dh, sdev))
-                        found_dh = scsi_dh;
-        } else {
-                struct scsi_device_handler *tmp_dh;
-
-                spin_lock(&list_lock);
-                list_for_each_entry(tmp_dh, &scsi_dh_list, list) {
-                        if (scsi_dh_handler_lookup(tmp_dh, sdev))
-                                found_dh = tmp_dh;
-                }
-                spin_unlock(&list_lock);
-        }
-
-        if (found_dh) { /* If device is found, add it to the cache */
-                tmp = kmalloc(sizeof(*tmp), GFP_KERNEL);
-                if (tmp) {
-                        strncpy(tmp->vendor, sdev->vendor, 8);
-                        strncpy(tmp->model, sdev->model, 16);
-                        tmp->vendor[8] = '\0';
-                        tmp->model[16] = '\0';
-                        tmp->handler = found_dh;
-                        spin_lock(&list_lock);
-                        list_add(&tmp->node, &scsi_dh_dev_list);
-                        spin_unlock(&list_lock);
-                } else {
-                        found_dh = NULL;
-                }
-        }
+        if (scsi_dh && found_dh != scsi_dh)
+                found_dh = NULL;
 
         return found_dh;
 }
@@ -373,12 +317,25 @@ static int scsi_dh_notifier_remove(struct device *dev, void *data)
  */
 int scsi_register_device_handler(struct scsi_device_handler *scsi_dh)
 {
+        int i;
+
         if (get_device_handler(scsi_dh->name))
                 return -EBUSY;
 
         spin_lock(&list_lock);
+        scsi_dh->idx = scsi_dh_list_idx++;
         list_add(&scsi_dh->list, &scsi_dh_list);
         spin_unlock(&list_lock);
+
+        for (i = 0; scsi_dh->devlist[i].vendor; i++) {
+                scsi_dev_info_list_add_keyed(0,
+                                        scsi_dh->devlist[i].vendor,
+                                        scsi_dh->devlist[i].model,
+                                        NULL,
+                                        scsi_dh->idx,
+                                        SCSI_DEVINFO_DH);
+        }
+
         bus_for_each_dev(&scsi_bus_type, NULL, scsi_dh, scsi_dh_notifier_add);
         printk(KERN_INFO "%s: device handler registered\n", scsi_dh->name);
 
@@ -395,7 +352,7 @@ EXPORT_SYMBOL_GPL(scsi_register_device_handler);
  */
 int scsi_unregister_device_handler(struct scsi_device_handler *scsi_dh)
 {
-        struct scsi_dh_devinfo_list *tmp, *pos;
+        int i;
 
         if (!get_device_handler(scsi_dh->name))
                 return -ENODEV;
@@ -403,14 +360,14 @@ int scsi_unregister_device_handler(struct scsi_device_handler *scsi_dh)
         bus_for_each_dev(&scsi_bus_type, NULL, scsi_dh,
                          scsi_dh_notifier_remove);
 
+        for (i = 0; scsi_dh->devlist[i].vendor; i++) {
+                scsi_dev_info_list_del_keyed(scsi_dh->devlist[i].vendor,
+                                             scsi_dh->devlist[i].model,
+                                             SCSI_DEVINFO_DH);
+        }
+
         spin_lock(&list_lock);
         list_del(&scsi_dh->list);
-        list_for_each_entry_safe(pos, tmp, &scsi_dh_dev_list, node) {
-                if (pos->handler == scsi_dh) {
-                        list_del(&pos->node);
-                        kfree(pos);
-                }
-        }
         spin_unlock(&list_lock);
         printk(KERN_INFO "%s: device handler unregistered\n", scsi_dh->name);
 
@@ -437,21 +394,31 @@ int scsi_dh_activate(struct request_queue *q, activate_complete fn, void *data)
         unsigned long flags;
         struct scsi_device *sdev;
         struct scsi_device_handler *scsi_dh = NULL;
+        struct device *dev = NULL;
 
         spin_lock_irqsave(q->queue_lock, flags);
         sdev = q->queuedata;
         if (sdev && sdev->scsi_dh_data)
                 scsi_dh = sdev->scsi_dh_data->scsi_dh;
-        if (!scsi_dh || !get_device(&sdev->sdev_gendev))
+        dev = get_device(&sdev->sdev_gendev);
+        if (!scsi_dh || !dev ||
+            sdev->sdev_state == SDEV_CANCEL ||
+            sdev->sdev_state == SDEV_DEL)
                 err = SCSI_DH_NOSYS;
+        if (sdev->sdev_state == SDEV_OFFLINE)
+                err = SCSI_DH_DEV_OFFLINED;
         spin_unlock_irqrestore(q->queue_lock, flags);
 
-        if (err)
-                return err;
+        if (err) {
+                if (fn)
+                        fn(data, err);
+                goto out;
+        }
 
         if (scsi_dh->activate)
                 err = scsi_dh->activate(sdev, fn, data);
-        put_device(&sdev->sdev_gendev);
+out:
+        put_device(dev);
         return err;
 }
 EXPORT_SYMBOL_GPL(scsi_dh_activate);
@@ -569,6 +536,10 @@ static int __init scsi_dh_init(void)
 {
         int r;
 
+        r = scsi_dev_info_add_list(SCSI_DEVINFO_DH, "SCSI Device Handler");
+        if (r)
+                return r;
+
         r = bus_register_notifier(&scsi_bus_type, &scsi_dh_nb);
 
         if (!r)
@@ -583,6 +554,7 @@ static void __exit scsi_dh_exit(void)
         bus_for_each_dev(&scsi_bus_type, NULL, NULL,
                          scsi_dh_sysfs_attr_remove);
         bus_unregister_notifier(&scsi_bus_type, &scsi_dh_nb);
+        scsi_dev_info_remove_list(SCSI_DEVINFO_DH);
 }
 
 module_init(scsi_dh_init);
diff --git a/drivers/scsi/device_handler/scsi_dh_alua.c b/drivers/scsi/device_handler/scsi_dh_alua.c
index 1a970a76b1b9..6fec9fe5dc39 100644
--- a/drivers/scsi/device_handler/scsi_dh_alua.c
+++ b/drivers/scsi/device_handler/scsi_dh_alua.c
@@ -1,7 +1,7 @@
 /*
  * Generic SCSI-3 ALUA SCSI Device Handler
  *
- * Copyright (C) 2007, 2008 Hannes Reinecke, SUSE Linux Products GmbH.
+ * Copyright (C) 2007-2010 Hannes Reinecke, SUSE Linux Products GmbH.
  * All rights reserved.
  *
  * This program is free software; you can redistribute it and/or modify
@@ -20,17 +20,19 @@
  *
  */
 #include <linux/slab.h>
+#include <linux/delay.h>
 #include <scsi/scsi.h>
 #include <scsi/scsi_eh.h>
 #include <scsi/scsi_dh.h>
 
 #define ALUA_DH_NAME "alua"
-#define ALUA_DH_VER "1.2"
+#define ALUA_DH_VER "1.3"
 
 #define TPGS_STATE_OPTIMIZED            0x0
 #define TPGS_STATE_NONOPTIMIZED         0x1
 #define TPGS_STATE_STANDBY              0x2
 #define TPGS_STATE_UNAVAILABLE          0x3
+#define TPGS_STATE_LBA_DEPENDENT        0x4
 #define TPGS_STATE_OFFLINE              0xe
 #define TPGS_STATE_TRANSITIONING        0xf
 
@@ -39,6 +41,7 @@
 #define TPGS_SUPPORT_NONOPTIMIZED       0x02
 #define TPGS_SUPPORT_STANDBY            0x04
 #define TPGS_SUPPORT_UNAVAILABLE        0x08
+#define TPGS_SUPPORT_LBA_DEPENDENT      0x10
 #define TPGS_SUPPORT_OFFLINE            0x40
 #define TPGS_SUPPORT_TRANSITION         0x80
 
@@ -250,13 +253,15 @@ static void stpg_endio(struct request *req, int error)
 {
         struct alua_dh_data *h = req->end_io_data;
         struct scsi_sense_hdr sense_hdr;
-        unsigned err = SCSI_DH_IO;
+        unsigned err = SCSI_DH_OK;
 
         if (error || host_byte(req->errors) != DID_OK ||
-                        msg_byte(req->errors) != COMMAND_COMPLETE)
+                        msg_byte(req->errors) != COMMAND_COMPLETE) {
+                err = SCSI_DH_IO;
                 goto done;
+        }
 
-        if (err == SCSI_DH_IO && h->senselen > 0) {
+        if (h->senselen > 0) {
                 err = scsi_normalize_sense(h->sense, SCSI_SENSE_BUFFERSIZE,
                                            &sense_hdr);
                 if (!err) {
@@ -282,7 +287,8 @@ static void stpg_endio(struct request *req, int error)
                             print_alua_state(h->state));
         }
 done:
-        blk_put_request(req);
+        req->end_io_data = NULL;
+        __blk_put_request(req->q, req);
         if (h->callback_fn) {
                 h->callback_fn(h->callback_data, err);
                 h->callback_fn = h->callback_data = NULL;
@@ -300,7 +306,6 @@ done:
 static unsigned submit_stpg(struct alua_dh_data *h)
 {
         struct request *rq;
-        int err = SCSI_DH_RES_TEMP_UNAVAIL;
         int stpg_len = 8;
         struct scsi_device *sdev = h->sdev;
 
@@ -329,7 +334,7 @@ static unsigned submit_stpg(struct alua_dh_data *h)
         rq->end_io_data = h;
 
         blk_execute_rq_nowait(rq->q, NULL, rq, 1, stpg_endio);
-        return err;
+        return SCSI_DH_OK;
 }
 
 /*
@@ -460,6 +465,8 @@ static char print_alua_state(int state)
                 return 'S';
         case TPGS_STATE_UNAVAILABLE:
                 return 'U';
+        case TPGS_STATE_LBA_DEPENDENT:
+                return 'L';
         case TPGS_STATE_OFFLINE:
                 return 'O';
         case TPGS_STATE_TRANSITIONING:
@@ -534,7 +541,7 @@ static int alua_check_sense(struct scsi_device *sdev,
  *
  * Evaluate the Target Port Group State.
  * Returns SCSI_DH_DEV_OFFLINED if the path is
- * found to be unuseable.
+ * found to be unusable.
  */
 static int alua_rtpg(struct scsi_device *sdev, struct alua_dh_data *h)
 {
@@ -542,7 +549,9 @@ static int alua_rtpg(struct scsi_device *sdev, struct alua_dh_data *h)
         int len, k, off, valid_states = 0;
         char *ucp;
         unsigned err;
+        unsigned long expiry, interval = 10;
 
+        expiry = round_jiffies_up(jiffies + ALUA_FAILOVER_TIMEOUT);
  retry:
         err = submit_rtpg(sdev, h);
 
@@ -553,7 +562,7 @@ static int alua_rtpg(struct scsi_device *sdev, struct alua_dh_data *h)
                         return SCSI_DH_IO;
 
                 err = alua_check_sense(sdev, &sense_hdr);
-                if (err == ADD_TO_MLQUEUE)
+                if (err == ADD_TO_MLQUEUE && time_before(jiffies, expiry))
                         goto retry;
                 sdev_printk(KERN_INFO, sdev,
                             "%s: rtpg sense code %02x/%02x/%02x\n",
@@ -587,38 +596,37 @@ static int alua_rtpg(struct scsi_device *sdev, struct alua_dh_data *h)
         }
 
         sdev_printk(KERN_INFO, sdev,
-                    "%s: port group %02x state %c supports %c%c%c%c%c%c\n",
+                    "%s: port group %02x state %c supports %c%c%c%c%c%c%c\n",
                     ALUA_DH_NAME, h->group_id, print_alua_state(h->state),
                     valid_states&TPGS_SUPPORT_TRANSITION?'T':'t',
                     valid_states&TPGS_SUPPORT_OFFLINE?'O':'o',
+                    valid_states&TPGS_SUPPORT_LBA_DEPENDENT?'L':'l',
                     valid_states&TPGS_SUPPORT_UNAVAILABLE?'U':'u',
                     valid_states&TPGS_SUPPORT_STANDBY?'S':'s',
                     valid_states&TPGS_SUPPORT_NONOPTIMIZED?'N':'n',
                     valid_states&TPGS_SUPPORT_OPTIMIZED?'A':'a');
 
-        if (h->tpgs & TPGS_MODE_EXPLICIT) {
-                switch (h->state) {
-                case TPGS_STATE_TRANSITIONING:
+        switch (h->state) {
+        case TPGS_STATE_TRANSITIONING:
+                if (time_before(jiffies, expiry)) {
                         /* State transition, retry */
+                        interval *= 10;
+                        msleep(interval);
                         goto retry;
-                        break;
-                case TPGS_STATE_OFFLINE:
-                        /* Path is offline, fail */
-                        err = SCSI_DH_DEV_OFFLINED;
-                        break;
-                default:
-                        break;
                 }
-        } else {
-                /* Only Implicit ALUA support */
-                if (h->state == TPGS_STATE_OPTIMIZED ||
-                    h->state == TPGS_STATE_NONOPTIMIZED ||
-                    h->state == TPGS_STATE_STANDBY)
-                        /* Useable path if active */
-                        err = SCSI_DH_OK;
-                else
-                        /* Path unuseable for unavailable/offline */
-                        err = SCSI_DH_DEV_OFFLINED;
+                /* Transitioning time exceeded, set port to standby */
+                err = SCSI_DH_RETRY;
+                h->state = TPGS_STATE_STANDBY;
+                break;
+        case TPGS_STATE_OFFLINE:
+        case TPGS_STATE_UNAVAILABLE:
+                /* Path unusable for unavailable/offline */
+                err = SCSI_DH_DEV_OFFLINED;
+                break;
+        default:
+                /* Useable path if active */
+                err = SCSI_DH_OK;
+                break;
         }
         return err;
 }
@@ -672,7 +680,9 @@ static int alua_activate(struct scsi_device *sdev,
                         goto out;
         }
 
-        if (h->tpgs & TPGS_MODE_EXPLICIT && h->state != TPGS_STATE_OPTIMIZED) {
+        if (h->tpgs & TPGS_MODE_EXPLICIT &&
+            h->state != TPGS_STATE_OPTIMIZED &&
+            h->state != TPGS_STATE_LBA_DEPENDENT) {
                 h->callback_fn = fn;
                 h->callback_data = data;
                 err = submit_stpg(h);
@@ -698,8 +708,11 @@ static int alua_prep_fn(struct scsi_device *sdev, struct request *req)
         struct alua_dh_data *h = get_alua_data(sdev);
         int ret = BLKPREP_OK;
 
-        if (h->state != TPGS_STATE_OPTIMIZED &&
-            h->state != TPGS_STATE_NONOPTIMIZED) {
+        if (h->state == TPGS_STATE_TRANSITIONING)
+                ret = BLKPREP_DEFER;
+        else if (h->state != TPGS_STATE_OPTIMIZED &&
+                 h->state != TPGS_STATE_NONOPTIMIZED &&
+                 h->state != TPGS_STATE_LBA_DEPENDENT) {
                 ret = BLKPREP_KILL;
                 req->cmd_flags |= REQ_QUIET;
         }
@@ -719,7 +732,9 @@ static const struct scsi_dh_devlist alua_dev_list[] = {
         {"Pillar", "Axiom" },
         {"Intel", "Multi-Flex"},
         {"NETAPP", "LUN"},
+        {"NETAPP", "LUN C-Mode"},
         {"AIX", "NVDISK"},
+        {"Promise", "VTrak"},
         {NULL, NULL}
 };
 
@@ -748,7 +763,7 @@ static int alua_bus_attach(struct scsi_device *sdev)
         unsigned long flags;
         int err = SCSI_DH_OK;
 
-        scsi_dh_data = kzalloc(sizeof(struct scsi_device_handler *)
+        scsi_dh_data = kzalloc(sizeof(*scsi_dh_data)
                                + sizeof(*h) , GFP_KERNEL);
         if (!scsi_dh_data) {
                 sdev_printk(KERN_ERR, sdev, "%s: Attach failed\n",
@@ -767,7 +782,7 @@ static int alua_bus_attach(struct scsi_device *sdev)
         h->sdev = sdev;
 
         err = alua_initialize(sdev, h);
-        if (err != SCSI_DH_OK)
+        if ((err != SCSI_DH_OK) && (err != SCSI_DH_DEV_OFFLINED))
                 goto failed;
 
         if (!try_module_get(THIS_MODULE))
diff --git a/drivers/scsi/device_handler/scsi_dh_emc.c b/drivers/scsi/device_handler/scsi_dh_emc.c
index 6faf472f7537..48441f6908a4 100644
--- a/drivers/scsi/device_handler/scsi_dh_emc.c
+++ b/drivers/scsi/device_handler/scsi_dh_emc.c
@@ -650,7 +650,7 @@ static int clariion_bus_attach(struct scsi_device *sdev)
         unsigned long flags;
         int err;
 
-        scsi_dh_data = kzalloc(sizeof(struct scsi_device_handler *)
+        scsi_dh_data = kzalloc(sizeof(*scsi_dh_data)
                                + sizeof(*h) , GFP_KERNEL);
         if (!scsi_dh_data) {
                 sdev_printk(KERN_ERR, sdev, "%s: Attach failed\n",
diff --git a/drivers/scsi/device_handler/scsi_dh_hp_sw.c b/drivers/scsi/device_handler/scsi_dh_hp_sw.c
index e3916641e627..b479f1eef968 100644
--- a/drivers/scsi/device_handler/scsi_dh_hp_sw.c
+++ b/drivers/scsi/device_handler/scsi_dh_hp_sw.c
@@ -225,7 +225,8 @@ static void start_stop_endio(struct request *req, int error)
                 }
         }
 done:
-        blk_put_request(req);
+        req->end_io_data = NULL;
+        __blk_put_request(req->q, req);
         if (h->callback_fn) {
                 h->callback_fn(h->callback_data, err);
                 h->callback_fn = h->callback_data = NULL;
@@ -338,8 +339,8 @@ static int hp_sw_bus_attach(struct scsi_device *sdev)
         unsigned long flags;
         int ret;
 
-        scsi_dh_data = kzalloc(sizeof(struct scsi_device_handler *)
-                               + sizeof(struct hp_sw_dh_data) , GFP_KERNEL);
+        scsi_dh_data = kzalloc(sizeof(*scsi_dh_data)
+                               + sizeof(*h) , GFP_KERNEL);
         if (!scsi_dh_data) {
                 sdev_printk(KERN_ERR, sdev, "%s: Attach Failed\n",
                             HP_SW_NAME);
diff --git a/drivers/scsi/device_handler/scsi_dh_rdac.c b/drivers/scsi/device_handler/scsi_dh_rdac.c
index b9bcfa4c7d26..e7fc70d6b478 100644
--- a/drivers/scsi/device_handler/scsi_dh_rdac.c
+++ b/drivers/scsi/device_handler/scsi_dh_rdac.c
@@ -182,14 +182,24 @@ struct rdac_dh_data {
         struct rdac_controller  *ctlr;
 #define UNINITIALIZED_LUN       (1 << 8)
         unsigned                lun;
+
+#define RDAC_MODE               0
+#define RDAC_MODE_AVT           1
+#define RDAC_MODE_IOSHIP        2
+        unsigned char           mode;
+
 #define RDAC_STATE_ACTIVE       0
 #define RDAC_STATE_PASSIVE      1
         unsigned char           state;
 
 #define RDAC_LUN_UNOWNED        0
 #define RDAC_LUN_OWNED          1
-#define RDAC_LUN_AVT            2
         char                    lun_state;
+
+#define RDAC_PREFERRED          0
+#define RDAC_NON_PREFERRED      1
+        char                    preferred;
+
         unsigned char           sense[SCSI_SENSE_BUFFERSIZE];
         union                   {
                 struct c2_inquiry c2;
@@ -199,11 +209,15 @@ struct rdac_dh_data {
         } inq;
 };
 
+static const char *mode[] = {
+        "RDAC",
+        "AVT",
+        "IOSHIP",
+};
 static const char *lun_state[] =
 {
         "unowned",
         "owned",
-        "owned (AVT mode)",
 };
 
 struct rdac_queue_data {
@@ -281,11 +295,13 @@ static struct request *get_rdac_req(struct scsi_device *sdev,
 }
 
 static struct request *rdac_failover_get(struct scsi_device *sdev,
-                                         struct rdac_dh_data *h)
+                        struct rdac_dh_data *h, struct list_head *list)
 {
         struct request *rq;
         struct rdac_mode_common *common;
         unsigned data_size;
+        struct rdac_queue_data *qdata;
+        u8 *lun_table;
 
         if (h->ctlr->use_ms10) {
                 struct rdac_pg_expanded *rdac_pg;
@@ -298,6 +314,7 @@ static struct request *rdac_failover_get(struct scsi_device *sdev,
                 rdac_pg->subpage_code = 0x1;
                 rdac_pg->page_len[0] = 0x01;
                 rdac_pg->page_len[1] = 0x28;
+                lun_table = rdac_pg->lun_table;
         } else {
                 struct rdac_pg_legacy *rdac_pg;
 
@@ -307,11 +324,16 @@ static struct request *rdac_failover_get(struct scsi_device *sdev,
                 common = &rdac_pg->common;
                 rdac_pg->page_code = RDAC_PAGE_CODE_REDUNDANT_CONTROLLER;
                 rdac_pg->page_len = 0x68;
+                lun_table = rdac_pg->lun_table;
         }
         common->rdac_mode[1] = RDAC_MODE_TRANSFER_SPECIFIED_LUNS;
         common->quiescence_timeout = RDAC_QUIESCENCE_TIME;
         common->rdac_options = RDAC_FORCED_QUIESENCE;
 
+        list_for_each_entry(qdata, list, entry) {
+                lun_table[qdata->h->lun] = 0x81;
+        }
+
         /* get request for block layer packet command */
         rq = get_rdac_req(sdev, &h->ctlr->mode_select, data_size, WRITE);
         if (!rq)
@@ -450,25 +472,33 @@ static int check_ownership(struct scsi_device *sdev, struct rdac_dh_data *h)
         int err;
         struct c9_inquiry *inqp;
 
-        h->lun_state = RDAC_LUN_UNOWNED;
         h->state = RDAC_STATE_ACTIVE;
         err = submit_inquiry(sdev, 0xC9, sizeof(struct c9_inquiry), h);
         if (err == SCSI_DH_OK) {
                 inqp = &h->inq.c9;
-                if ((inqp->avte_cvp >> 7) == 0x1) {
-                        /* LUN in AVT mode */
-                        sdev_printk(KERN_NOTICE, sdev,
-                                    "%s: AVT mode detected\n",
-                                    RDAC_NAME);
-                        h->lun_state = RDAC_LUN_AVT;
-                } else if ((inqp->avte_cvp & 0x1) != 0) {
-                        /* LUN was owned by the controller */
+                /* detect the operating mode */
+                if ((inqp->avte_cvp >> 5) & 0x1)
+                        h->mode = RDAC_MODE_IOSHIP; /* LUN in IOSHIP mode */
+                else if (inqp->avte_cvp >> 7)
+                        h->mode = RDAC_MODE_AVT; /* LUN in AVT mode */
+                else
+                        h->mode = RDAC_MODE; /* LUN in RDAC mode */
+
+                /* Update ownership */
+                if (inqp->avte_cvp & 0x1)
                         h->lun_state = RDAC_LUN_OWNED;
+                else {
+                        h->lun_state = RDAC_LUN_UNOWNED;
+                        if (h->mode == RDAC_MODE)
+                                h->state = RDAC_STATE_PASSIVE;
                 }
-        }
 
-        if (h->lun_state == RDAC_LUN_UNOWNED)
-                h->state = RDAC_STATE_PASSIVE;
+                /* Update path prio*/
+                if (inqp->path_prio & 0x1)
+                        h->preferred = RDAC_PREFERRED;
+                else
+                        h->preferred = RDAC_NON_PREFERRED;
+        }
 
         return err;
 }
@@ -565,7 +595,6 @@ static void send_mode_select(struct work_struct *work)
         int err, retry_cnt = RDAC_RETRY_COUNT;
         struct rdac_queue_data *tmp, *qdata;
         LIST_HEAD(list);
-        u8 *lun_table;
 
         spin_lock(&ctlr->ms_lock);
         list_splice_init(&ctlr->ms_head, &list);
@@ -573,21 +602,12 @@ static void send_mode_select(struct work_struct *work)
         ctlr->ms_sdev = NULL;
         spin_unlock(&ctlr->ms_lock);
 
-        if (ctlr->use_ms10)
-                lun_table = ctlr->mode_select.expanded.lun_table;
-        else
-                lun_table = ctlr->mode_select.legacy.lun_table;
-
 retry:
         err = SCSI_DH_RES_TEMP_UNAVAIL;
-        rq = rdac_failover_get(sdev, h);
+        rq = rdac_failover_get(sdev, h, &list);
         if (!rq)
                 goto done;
 
-        list_for_each_entry(qdata, &list, entry) {
-                lun_table[qdata->h->lun] = 0x81;
-        }
-
         RDAC_LOG(RDAC_LOG_FAILOVER, sdev, "array %s, ctlr %d, "
                 "%s MODE_SELECT command",
                 (char *) h->ctlr->array_name, h->ctlr->index,
@@ -650,12 +670,27 @@ static int rdac_activate(struct scsi_device *sdev,
 {
         struct rdac_dh_data *h = get_rdac_data(sdev);
         int err = SCSI_DH_OK;
+        int act = 0;
 
         err = check_ownership(sdev, h);
         if (err != SCSI_DH_OK)
                 goto done;
 
-        if (h->lun_state == RDAC_LUN_UNOWNED) {
+        switch (h->mode) {
+        case RDAC_MODE:
+                if (h->lun_state == RDAC_LUN_UNOWNED)
+                        act = 1;
+                break;
+        case RDAC_MODE_IOSHIP:
+                if ((h->lun_state == RDAC_LUN_UNOWNED) &&
+                    (h->preferred == RDAC_PREFERRED))
+                        act = 1;
+                break;
+        default:
+                break;
+        }
+
+        if (act) {
                 err = queue_mode_select(sdev, fn, data);
                 if (err == SCSI_DH_OK)
                         return 0;
@@ -769,10 +804,13 @@ static const struct scsi_dh_devlist rdac_dev_list[] = {
         {"DELL", "MD32xx"},
         {"DELL", "MD32xxi"},
         {"DELL", "MD36xxi"},
+        {"DELL", "MD36xxf"},
         {"LSI", "INF-01-00"},
         {"ENGENIO", "INF-01-00"},
         {"STK", "FLEXLINE 380"},
         {"SUN", "CSM100_R_FC"},
+        {"SUN", "STK6580_6780"},
+        {"SUN", "SUN_6180"},
         {NULL, NULL},
 };
 
@@ -798,7 +836,7 @@ static int rdac_bus_attach(struct scsi_device *sdev)
         int err;
         char array_name[ARRAY_LABEL_LEN];
 
-        scsi_dh_data = kzalloc(sizeof(struct scsi_device_handler *)
+        scsi_dh_data = kzalloc(sizeof(*scsi_dh_data)
                                + sizeof(*h) , GFP_KERNEL);
         if (!scsi_dh_data) {
                 sdev_printk(KERN_ERR, sdev, "%s: Attach failed\n",
@@ -835,8 +873,9 @@ static int rdac_bus_attach(struct scsi_device *sdev)
         spin_unlock_irqrestore(sdev->request_queue->queue_lock, flags);
 
         sdev_printk(KERN_NOTICE, sdev,
-                    "%s: LUN %d (%s)\n",
-                    RDAC_NAME, h->lun, lun_state[(int)h->lun_state]);
+                    "%s: LUN %d (%s) (%s)\n",
+                    RDAC_NAME, h->lun, mode[(int)h->mode],
+                    lun_state[(int)h->lun_state]);
 
         return 0;
 
@@ -904,4 +943,5 @@ module_exit(rdac_exit);
 
 MODULE_DESCRIPTION("Multipath LSI/Engenio RDAC driver");
 MODULE_AUTHOR("Mike Christie, Chandra Seetharaman");
+MODULE_VERSION("01.00.0000.0000");
 MODULE_LICENSE("GPL");