Back to home page

OSCL-LXR
 
 

     

0001 /*
0002  * LSI/Engenio/NetApp E-Series RDAC SCSI Device Handler
0003  *
0004  * Copyright (C) 2005 Mike Christie. All rights reserved.
0005  * Copyright (C) Chandra Seetharaman, IBM Corp. 2007
0006  *
0007  * This program is free software; you can redistribute it and/or modify
0008  * it under the terms of the GNU General Public License as published by
0009  * the Free Software Foundation; either version 2 of the License, or
0010  * (at your option) any later version.
0011  *
0012  * This program is distributed in the hope that it will be useful,
0013  * but WITHOUT ANY WARRANTY; without even the implied warranty of
0014  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
0015  * GNU General Public License for more details.
0016  *
0017  * You should have received a copy of the GNU General Public License
0018  * along with this program; if not, write to the Free Software
0019  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
0020  *
0021  */
0022 #include <scsi/scsi.h>
0023 #include <scsi/scsi_eh.h>
0024 #include <scsi/scsi_dh.h>
0025 #include <linux/workqueue.h>
0026 #include <linux/slab.h>
0027 #include <linux/module.h>
0028 
0029 #define RDAC_NAME "rdac"
0030 #define RDAC_RETRY_COUNT 5
0031 
0032 /*
0033  * LSI mode page stuff
0034  *
0035  * These struct definitions and the forming of the
0036  * mode page were taken from the LSI RDAC 2.4 GPL'd
0037  * driver, and then converted to Linux conventions.
0038  */
0039 #define RDAC_QUIESCENCE_TIME 20
0040 /*
0041  * Page Codes
0042  */
0043 #define RDAC_PAGE_CODE_REDUNDANT_CONTROLLER 0x2c
0044 
0045 /*
0046  * Controller modes definitions
0047  */
0048 #define RDAC_MODE_TRANSFER_SPECIFIED_LUNS   0x02
0049 
0050 /*
0051  * RDAC Options field
0052  */
0053 #define RDAC_FORCED_QUIESENCE 0x02
0054 
0055 #define RDAC_TIMEOUT    (60 * HZ)
0056 #define RDAC_RETRIES    3
0057 
0058 struct rdac_mode_6_hdr {
0059     u8  data_len;
0060     u8  medium_type;
0061     u8  device_params;
0062     u8  block_desc_len;
0063 };
0064 
0065 struct rdac_mode_10_hdr {
0066     u16 data_len;
0067     u8  medium_type;
0068     u8  device_params;
0069     u16 reserved;
0070     u16 block_desc_len;
0071 };
0072 
0073 struct rdac_mode_common {
0074     u8  controller_serial[16];
0075     u8  alt_controller_serial[16];
0076     u8  rdac_mode[2];
0077     u8  alt_rdac_mode[2];
0078     u8  quiescence_timeout;
0079     u8  rdac_options;
0080 };
0081 
0082 struct rdac_pg_legacy {
0083     struct rdac_mode_6_hdr hdr;
0084     u8  page_code;
0085     u8  page_len;
0086     struct rdac_mode_common common;
0087 #define MODE6_MAX_LUN   32
0088     u8  lun_table[MODE6_MAX_LUN];
0089     u8  reserved2[32];
0090     u8  reserved3;
0091     u8  reserved4;
0092 };
0093 
0094 struct rdac_pg_expanded {
0095     struct rdac_mode_10_hdr hdr;
0096     u8  page_code;
0097     u8  subpage_code;
0098     u8  page_len[2];
0099     struct rdac_mode_common common;
0100     u8  lun_table[256];
0101     u8  reserved3;
0102     u8  reserved4;
0103 };
0104 
0105 struct c9_inquiry {
0106     u8  peripheral_info;
0107     u8  page_code;  /* 0xC9 */
0108     u8  reserved1;
0109     u8  page_len;
0110     u8  page_id[4]; /* "vace" */
0111     u8  avte_cvp;
0112     u8  path_prio;
0113     u8  reserved2[38];
0114 };
0115 
0116 #define SUBSYS_ID_LEN   16
0117 #define SLOT_ID_LEN 2
0118 #define ARRAY_LABEL_LEN 31
0119 
0120 struct c4_inquiry {
0121     u8  peripheral_info;
0122     u8  page_code;  /* 0xC4 */
0123     u8  reserved1;
0124     u8  page_len;
0125     u8  page_id[4]; /* "subs" */
0126     u8  subsys_id[SUBSYS_ID_LEN];
0127     u8  revision[4];
0128     u8  slot_id[SLOT_ID_LEN];
0129     u8  reserved[2];
0130 };
0131 
0132 #define UNIQUE_ID_LEN 16
0133 struct c8_inquiry {
0134     u8  peripheral_info;
0135     u8  page_code; /* 0xC8 */
0136     u8  reserved1;
0137     u8  page_len;
0138     u8  page_id[4]; /* "edid" */
0139     u8  reserved2[3];
0140     u8  vol_uniq_id_len;
0141     u8  vol_uniq_id[16];
0142     u8  vol_user_label_len;
0143     u8  vol_user_label[60];
0144     u8  array_uniq_id_len;
0145     u8  array_unique_id[UNIQUE_ID_LEN];
0146     u8  array_user_label_len;
0147     u8  array_user_label[60];
0148     u8  lun[8];
0149 };
0150 
0151 struct rdac_controller {
0152     u8          array_id[UNIQUE_ID_LEN];
0153     int         use_ms10;
0154     struct kref     kref;
0155     struct list_head    node; /* list of all controllers */
0156     union           {
0157         struct rdac_pg_legacy legacy;
0158         struct rdac_pg_expanded expanded;
0159     } mode_select;
0160     u8  index;
0161     u8  array_name[ARRAY_LABEL_LEN];
0162     struct Scsi_Host    *host;
0163     spinlock_t      ms_lock;
0164     int         ms_queued;
0165     struct work_struct  ms_work;
0166     struct scsi_device  *ms_sdev;
0167     struct list_head    ms_head;
0168     struct list_head    dh_list;
0169 };
0170 
0171 struct c2_inquiry {
0172     u8  peripheral_info;
0173     u8  page_code;  /* 0xC2 */
0174     u8  reserved1;
0175     u8  page_len;
0176     u8  page_id[4]; /* "swr4" */
0177     u8  sw_version[3];
0178     u8  sw_date[3];
0179     u8  features_enabled;
0180     u8  max_lun_supported;
0181     u8  partitions[239]; /* Total allocation length should be 0xFF */
0182 };
0183 
0184 struct rdac_dh_data {
0185     struct list_head    node;
0186     struct rdac_controller  *ctlr;
0187     struct scsi_device  *sdev;
0188 #define UNINITIALIZED_LUN   (1 << 8)
0189     unsigned        lun;
0190 
0191 #define RDAC_MODE       0
0192 #define RDAC_MODE_AVT       1
0193 #define RDAC_MODE_IOSHIP    2
0194     unsigned char       mode;
0195 
0196 #define RDAC_STATE_ACTIVE   0
0197 #define RDAC_STATE_PASSIVE  1
0198     unsigned char       state;
0199 
0200 #define RDAC_LUN_UNOWNED    0
0201 #define RDAC_LUN_OWNED      1
0202     char            lun_state;
0203 
0204 #define RDAC_PREFERRED      0
0205 #define RDAC_NON_PREFERRED  1
0206     char            preferred;
0207 
0208     union           {
0209         struct c2_inquiry c2;
0210         struct c4_inquiry c4;
0211         struct c8_inquiry c8;
0212         struct c9_inquiry c9;
0213     } inq;
0214 };
0215 
0216 static const char *mode[] = {
0217     "RDAC",
0218     "AVT",
0219     "IOSHIP",
0220 };
0221 static const char *lun_state[] =
0222 {
0223     "unowned",
0224     "owned",
0225 };
0226 
0227 struct rdac_queue_data {
0228     struct list_head    entry;
0229     struct rdac_dh_data *h;
0230     activate_complete   callback_fn;
0231     void            *callback_data;
0232 };
0233 
0234 static LIST_HEAD(ctlr_list);
0235 static DEFINE_SPINLOCK(list_lock);
0236 static struct workqueue_struct *kmpath_rdacd;
0237 static void send_mode_select(struct work_struct *work);
0238 
0239 /*
0240  * module parameter to enable rdac debug logging.
0241  * 2 bits for each type of logging, only two types defined for now
0242  * Can be enhanced if required at later point
0243  */
0244 static int rdac_logging = 1;
0245 module_param(rdac_logging, int, S_IRUGO|S_IWUSR);
0246 MODULE_PARM_DESC(rdac_logging, "A bit mask of rdac logging levels, "
0247         "Default is 1 - failover logging enabled, "
0248         "set it to 0xF to enable all the logs");
0249 
0250 #define RDAC_LOG_FAILOVER   0
0251 #define RDAC_LOG_SENSE      2
0252 
0253 #define RDAC_LOG_BITS       2
0254 
0255 #define RDAC_LOG_LEVEL(SHIFT)  \
0256     ((rdac_logging >> (SHIFT)) & ((1 << (RDAC_LOG_BITS)) - 1))
0257 
0258 #define RDAC_LOG(SHIFT, sdev, f, arg...) \
0259 do { \
0260     if (unlikely(RDAC_LOG_LEVEL(SHIFT))) \
0261         sdev_printk(KERN_INFO, sdev, RDAC_NAME ": " f "\n", ## arg); \
0262 } while (0);
0263 
0264 static unsigned int rdac_failover_get(struct rdac_controller *ctlr,
0265                       struct list_head *list,
0266                       unsigned char *cdb)
0267 {
0268     struct rdac_mode_common *common;
0269     unsigned data_size;
0270     struct rdac_queue_data *qdata;
0271     u8 *lun_table;
0272 
0273     if (ctlr->use_ms10) {
0274         struct rdac_pg_expanded *rdac_pg;
0275 
0276         data_size = sizeof(struct rdac_pg_expanded);
0277         rdac_pg = &ctlr->mode_select.expanded;
0278         memset(rdac_pg, 0, data_size);
0279         common = &rdac_pg->common;
0280         rdac_pg->page_code = RDAC_PAGE_CODE_REDUNDANT_CONTROLLER + 0x40;
0281         rdac_pg->subpage_code = 0x1;
0282         rdac_pg->page_len[0] = 0x01;
0283         rdac_pg->page_len[1] = 0x28;
0284         lun_table = rdac_pg->lun_table;
0285     } else {
0286         struct rdac_pg_legacy *rdac_pg;
0287 
0288         data_size = sizeof(struct rdac_pg_legacy);
0289         rdac_pg = &ctlr->mode_select.legacy;
0290         memset(rdac_pg, 0, data_size);
0291         common = &rdac_pg->common;
0292         rdac_pg->page_code = RDAC_PAGE_CODE_REDUNDANT_CONTROLLER;
0293         rdac_pg->page_len = 0x68;
0294         lun_table = rdac_pg->lun_table;
0295     }
0296     common->rdac_mode[1] = RDAC_MODE_TRANSFER_SPECIFIED_LUNS;
0297     common->quiescence_timeout = RDAC_QUIESCENCE_TIME;
0298     common->rdac_options = RDAC_FORCED_QUIESENCE;
0299 
0300     list_for_each_entry(qdata, list, entry) {
0301         lun_table[qdata->h->lun] = 0x81;
0302     }
0303 
0304     /* Prepare the command. */
0305     if (ctlr->use_ms10) {
0306         cdb[0] = MODE_SELECT_10;
0307         cdb[7] = data_size >> 8;
0308         cdb[8] = data_size & 0xff;
0309     } else {
0310         cdb[0] = MODE_SELECT;
0311         cdb[4] = data_size;
0312     }
0313 
0314     return data_size;
0315 }
0316 
0317 static void release_controller(struct kref *kref)
0318 {
0319     struct rdac_controller *ctlr;
0320     ctlr = container_of(kref, struct rdac_controller, kref);
0321 
0322     list_del(&ctlr->node);
0323     kfree(ctlr);
0324 }
0325 
0326 static struct rdac_controller *get_controller(int index, char *array_name,
0327             u8 *array_id, struct scsi_device *sdev)
0328 {
0329     struct rdac_controller *ctlr, *tmp;
0330 
0331     list_for_each_entry(tmp, &ctlr_list, node) {
0332         if ((memcmp(tmp->array_id, array_id, UNIQUE_ID_LEN) == 0) &&
0333               (tmp->index == index) &&
0334               (tmp->host == sdev->host)) {
0335             kref_get(&tmp->kref);
0336             return tmp;
0337         }
0338     }
0339     ctlr = kmalloc(sizeof(*ctlr), GFP_ATOMIC);
0340     if (!ctlr)
0341         return NULL;
0342 
0343     /* initialize fields of controller */
0344     memcpy(ctlr->array_id, array_id, UNIQUE_ID_LEN);
0345     ctlr->index = index;
0346     ctlr->host = sdev->host;
0347     memcpy(ctlr->array_name, array_name, ARRAY_LABEL_LEN);
0348 
0349     kref_init(&ctlr->kref);
0350     ctlr->use_ms10 = -1;
0351     ctlr->ms_queued = 0;
0352     ctlr->ms_sdev = NULL;
0353     spin_lock_init(&ctlr->ms_lock);
0354     INIT_WORK(&ctlr->ms_work, send_mode_select);
0355     INIT_LIST_HEAD(&ctlr->ms_head);
0356     list_add(&ctlr->node, &ctlr_list);
0357     INIT_LIST_HEAD(&ctlr->dh_list);
0358 
0359     return ctlr;
0360 }
0361 
0362 static int get_lun_info(struct scsi_device *sdev, struct rdac_dh_data *h,
0363             char *array_name, u8 *array_id)
0364 {
0365     int err = SCSI_DH_IO, i;
0366     struct c8_inquiry *inqp = &h->inq.c8;
0367 
0368     if (!scsi_get_vpd_page(sdev, 0xC8, (unsigned char *)inqp,
0369                    sizeof(struct c8_inquiry))) {
0370         if (inqp->page_code != 0xc8)
0371             return SCSI_DH_NOSYS;
0372         if (inqp->page_id[0] != 'e' || inqp->page_id[1] != 'd' ||
0373             inqp->page_id[2] != 'i' || inqp->page_id[3] != 'd')
0374             return SCSI_DH_NOSYS;
0375         h->lun = inqp->lun[7]; /* Uses only the last byte */
0376 
0377         for(i=0; i<ARRAY_LABEL_LEN-1; ++i)
0378             *(array_name+i) = inqp->array_user_label[(2*i)+1];
0379 
0380         *(array_name+ARRAY_LABEL_LEN-1) = '\0';
0381         memset(array_id, 0, UNIQUE_ID_LEN);
0382         memcpy(array_id, inqp->array_unique_id, inqp->array_uniq_id_len);
0383         err = SCSI_DH_OK;
0384     }
0385     return err;
0386 }
0387 
0388 static int check_ownership(struct scsi_device *sdev, struct rdac_dh_data *h)
0389 {
0390     int err = SCSI_DH_IO, access_state;
0391     struct rdac_dh_data *tmp;
0392     struct c9_inquiry *inqp = &h->inq.c9;
0393 
0394     h->state = RDAC_STATE_ACTIVE;
0395     if (!scsi_get_vpd_page(sdev, 0xC9, (unsigned char *)inqp,
0396                    sizeof(struct c9_inquiry))) {
0397         /* detect the operating mode */
0398         if ((inqp->avte_cvp >> 5) & 0x1)
0399             h->mode = RDAC_MODE_IOSHIP; /* LUN in IOSHIP mode */
0400         else if (inqp->avte_cvp >> 7)
0401             h->mode = RDAC_MODE_AVT; /* LUN in AVT mode */
0402         else
0403             h->mode = RDAC_MODE; /* LUN in RDAC mode */
0404 
0405         /* Update ownership */
0406         if (inqp->avte_cvp & 0x1) {
0407             h->lun_state = RDAC_LUN_OWNED;
0408             access_state = SCSI_ACCESS_STATE_OPTIMAL;
0409         } else {
0410             h->lun_state = RDAC_LUN_UNOWNED;
0411             if (h->mode == RDAC_MODE) {
0412                 h->state = RDAC_STATE_PASSIVE;
0413                 access_state = SCSI_ACCESS_STATE_STANDBY;
0414             } else
0415                 access_state = SCSI_ACCESS_STATE_ACTIVE;
0416         }
0417 
0418         /* Update path prio*/
0419         if (inqp->path_prio & 0x1) {
0420             h->preferred = RDAC_PREFERRED;
0421             access_state |= SCSI_ACCESS_STATE_PREFERRED;
0422         } else
0423             h->preferred = RDAC_NON_PREFERRED;
0424         rcu_read_lock();
0425         list_for_each_entry_rcu(tmp, &h->ctlr->dh_list, node) {
0426             /* h->sdev should always be valid */
0427             BUG_ON(!tmp->sdev);
0428             tmp->sdev->access_state = access_state;
0429         }
0430         rcu_read_unlock();
0431         err = SCSI_DH_OK;
0432     }
0433 
0434     return err;
0435 }
0436 
0437 static int initialize_controller(struct scsi_device *sdev,
0438         struct rdac_dh_data *h, char *array_name, u8 *array_id)
0439 {
0440     int err = SCSI_DH_IO, index;
0441     struct c4_inquiry *inqp = &h->inq.c4;
0442 
0443     if (!scsi_get_vpd_page(sdev, 0xC4, (unsigned char *)inqp,
0444                    sizeof(struct c4_inquiry))) {
0445         /* get the controller index */
0446         if (inqp->slot_id[1] == 0x31)
0447             index = 0;
0448         else
0449             index = 1;
0450 
0451         spin_lock(&list_lock);
0452         h->ctlr = get_controller(index, array_name, array_id, sdev);
0453         if (!h->ctlr)
0454             err = SCSI_DH_RES_TEMP_UNAVAIL;
0455         else {
0456             h->sdev = sdev;
0457             list_add_rcu(&h->node, &h->ctlr->dh_list);
0458         }
0459         spin_unlock(&list_lock);
0460         err = SCSI_DH_OK;
0461     }
0462     return err;
0463 }
0464 
0465 static int set_mode_select(struct scsi_device *sdev, struct rdac_dh_data *h)
0466 {
0467     int err = SCSI_DH_IO;
0468     struct c2_inquiry *inqp = &h->inq.c2;
0469 
0470     if (!scsi_get_vpd_page(sdev, 0xC2, (unsigned char *)inqp,
0471                    sizeof(struct c2_inquiry))) {
0472         /*
0473          * If more than MODE6_MAX_LUN luns are supported, use
0474          * mode select 10
0475          */
0476         if (inqp->max_lun_supported >= MODE6_MAX_LUN)
0477             h->ctlr->use_ms10 = 1;
0478         else
0479             h->ctlr->use_ms10 = 0;
0480         err = SCSI_DH_OK;
0481     }
0482     return err;
0483 }
0484 
0485 static int mode_select_handle_sense(struct scsi_device *sdev,
0486                     struct scsi_sense_hdr *sense_hdr)
0487 {
0488     int err = SCSI_DH_IO;
0489     struct rdac_dh_data *h = sdev->handler_data;
0490 
0491     if (!scsi_sense_valid(sense_hdr))
0492         goto done;
0493 
0494     switch (sense_hdr->sense_key) {
0495     case NO_SENSE:
0496     case ABORTED_COMMAND:
0497     case UNIT_ATTENTION:
0498         err = SCSI_DH_RETRY;
0499         break;
0500     case NOT_READY:
0501         if (sense_hdr->asc == 0x04 && sense_hdr->ascq == 0x01)
0502             /* LUN Not Ready and is in the Process of Becoming
0503              * Ready
0504              */
0505             err = SCSI_DH_RETRY;
0506         break;
0507     case ILLEGAL_REQUEST:
0508         if (sense_hdr->asc == 0x91 && sense_hdr->ascq == 0x36)
0509             /*
0510              * Command Lock contention
0511              */
0512             err = SCSI_DH_IMM_RETRY;
0513         break;
0514     default:
0515         break;
0516     }
0517 
0518     RDAC_LOG(RDAC_LOG_FAILOVER, sdev, "array %s, ctlr %d, "
0519         "MODE_SELECT returned with sense %02x/%02x/%02x",
0520         (char *) h->ctlr->array_name, h->ctlr->index,
0521         sense_hdr->sense_key, sense_hdr->asc, sense_hdr->ascq);
0522 
0523 done:
0524     return err;
0525 }
0526 
0527 static void send_mode_select(struct work_struct *work)
0528 {
0529     struct rdac_controller *ctlr =
0530         container_of(work, struct rdac_controller, ms_work);
0531     struct scsi_device *sdev = ctlr->ms_sdev;
0532     struct rdac_dh_data *h = sdev->handler_data;
0533     int err = SCSI_DH_OK, retry_cnt = RDAC_RETRY_COUNT;
0534     struct rdac_queue_data *tmp, *qdata;
0535     LIST_HEAD(list);
0536     unsigned char cdb[MAX_COMMAND_SIZE];
0537     struct scsi_sense_hdr sshdr;
0538     unsigned int data_size;
0539     blk_opf_t req_flags = REQ_FAILFAST_DEV | REQ_FAILFAST_TRANSPORT |
0540         REQ_FAILFAST_DRIVER;
0541 
0542     spin_lock(&ctlr->ms_lock);
0543     list_splice_init(&ctlr->ms_head, &list);
0544     ctlr->ms_queued = 0;
0545     ctlr->ms_sdev = NULL;
0546     spin_unlock(&ctlr->ms_lock);
0547 
0548  retry:
0549     memset(cdb, 0, sizeof(cdb));
0550 
0551     data_size = rdac_failover_get(ctlr, &list, cdb);
0552 
0553     RDAC_LOG(RDAC_LOG_FAILOVER, sdev, "array %s, ctlr %d, "
0554         "%s MODE_SELECT command",
0555         (char *) h->ctlr->array_name, h->ctlr->index,
0556         (retry_cnt == RDAC_RETRY_COUNT) ? "queueing" : "retrying");
0557 
0558     if (scsi_execute(sdev, cdb, DMA_TO_DEVICE, &h->ctlr->mode_select,
0559             data_size, NULL, &sshdr, RDAC_TIMEOUT * HZ,
0560             RDAC_RETRIES, req_flags, 0, NULL)) {
0561         err = mode_select_handle_sense(sdev, &sshdr);
0562         if (err == SCSI_DH_RETRY && retry_cnt--)
0563             goto retry;
0564         if (err == SCSI_DH_IMM_RETRY)
0565             goto retry;
0566     }
0567     if (err == SCSI_DH_OK) {
0568         h->state = RDAC_STATE_ACTIVE;
0569         RDAC_LOG(RDAC_LOG_FAILOVER, sdev, "array %s, ctlr %d, "
0570                 "MODE_SELECT completed",
0571                 (char *) h->ctlr->array_name, h->ctlr->index);
0572     }
0573 
0574     list_for_each_entry_safe(qdata, tmp, &list, entry) {
0575         list_del(&qdata->entry);
0576         if (err == SCSI_DH_OK)
0577             qdata->h->state = RDAC_STATE_ACTIVE;
0578         if (qdata->callback_fn)
0579             qdata->callback_fn(qdata->callback_data, err);
0580         kfree(qdata);
0581     }
0582     return;
0583 }
0584 
0585 static int queue_mode_select(struct scsi_device *sdev,
0586                 activate_complete fn, void *data)
0587 {
0588     struct rdac_queue_data *qdata;
0589     struct rdac_controller *ctlr;
0590 
0591     qdata = kzalloc(sizeof(*qdata), GFP_KERNEL);
0592     if (!qdata)
0593         return SCSI_DH_RETRY;
0594 
0595     qdata->h = sdev->handler_data;
0596     qdata->callback_fn = fn;
0597     qdata->callback_data = data;
0598 
0599     ctlr = qdata->h->ctlr;
0600     spin_lock(&ctlr->ms_lock);
0601     list_add_tail(&qdata->entry, &ctlr->ms_head);
0602     if (!ctlr->ms_queued) {
0603         ctlr->ms_queued = 1;
0604         ctlr->ms_sdev = sdev;
0605         queue_work(kmpath_rdacd, &ctlr->ms_work);
0606     }
0607     spin_unlock(&ctlr->ms_lock);
0608     return SCSI_DH_OK;
0609 }
0610 
0611 static int rdac_activate(struct scsi_device *sdev,
0612             activate_complete fn, void *data)
0613 {
0614     struct rdac_dh_data *h = sdev->handler_data;
0615     int err = SCSI_DH_OK;
0616     int act = 0;
0617 
0618     err = check_ownership(sdev, h);
0619     if (err != SCSI_DH_OK)
0620         goto done;
0621 
0622     switch (h->mode) {
0623     case RDAC_MODE:
0624         if (h->lun_state == RDAC_LUN_UNOWNED)
0625             act = 1;
0626         break;
0627     case RDAC_MODE_IOSHIP:
0628         if ((h->lun_state == RDAC_LUN_UNOWNED) &&
0629             (h->preferred == RDAC_PREFERRED))
0630             act = 1;
0631         break;
0632     default:
0633         break;
0634     }
0635 
0636     if (act) {
0637         err = queue_mode_select(sdev, fn, data);
0638         if (err == SCSI_DH_OK)
0639             return 0;
0640     }
0641 done:
0642     if (fn)
0643         fn(data, err);
0644     return 0;
0645 }
0646 
0647 static blk_status_t rdac_prep_fn(struct scsi_device *sdev, struct request *req)
0648 {
0649     struct rdac_dh_data *h = sdev->handler_data;
0650 
0651     if (h->state != RDAC_STATE_ACTIVE) {
0652         req->rq_flags |= RQF_QUIET;
0653         return BLK_STS_IOERR;
0654     }
0655 
0656     return BLK_STS_OK;
0657 }
0658 
0659 static enum scsi_disposition rdac_check_sense(struct scsi_device *sdev,
0660                           struct scsi_sense_hdr *sense_hdr)
0661 {
0662     struct rdac_dh_data *h = sdev->handler_data;
0663 
0664     RDAC_LOG(RDAC_LOG_SENSE, sdev, "array %s, ctlr %d, "
0665             "I/O returned with sense %02x/%02x/%02x",
0666             (char *) h->ctlr->array_name, h->ctlr->index,
0667             sense_hdr->sense_key, sense_hdr->asc, sense_hdr->ascq);
0668 
0669     switch (sense_hdr->sense_key) {
0670     case NOT_READY:
0671         if (sense_hdr->asc == 0x04 && sense_hdr->ascq == 0x01)
0672             /* LUN Not Ready - Logical Unit Not Ready and is in
0673             * the process of becoming ready
0674             * Just retry.
0675             */
0676             return ADD_TO_MLQUEUE;
0677         if (sense_hdr->asc == 0x04 && sense_hdr->ascq == 0x81)
0678             /* LUN Not Ready - Storage firmware incompatible
0679              * Manual code synchonisation required.
0680              *
0681              * Nothing we can do here. Try to bypass the path.
0682              */
0683             return SUCCESS;
0684         if (sense_hdr->asc == 0x04 && sense_hdr->ascq == 0xA1)
0685             /* LUN Not Ready - Quiescense in progress
0686              *
0687              * Just retry and wait.
0688              */
0689             return ADD_TO_MLQUEUE;
0690         if (sense_hdr->asc == 0xA1  && sense_hdr->ascq == 0x02)
0691             /* LUN Not Ready - Quiescense in progress
0692              * or has been achieved
0693              * Just retry.
0694              */
0695             return ADD_TO_MLQUEUE;
0696         break;
0697     case ILLEGAL_REQUEST:
0698         if (sense_hdr->asc == 0x94 && sense_hdr->ascq == 0x01) {
0699             /* Invalid Request - Current Logical Unit Ownership.
0700              * Controller is not the current owner of the LUN,
0701              * Fail the path, so that the other path be used.
0702              */
0703             h->state = RDAC_STATE_PASSIVE;
0704             return SUCCESS;
0705         }
0706         break;
0707     case UNIT_ATTENTION:
0708         if (sense_hdr->asc == 0x29 && sense_hdr->ascq == 0x00)
0709             /*
0710              * Power On, Reset, or Bus Device Reset, just retry.
0711              */
0712             return ADD_TO_MLQUEUE;
0713         if (sense_hdr->asc == 0x8b && sense_hdr->ascq == 0x02)
0714             /*
0715              * Quiescence in progress , just retry.
0716              */
0717             return ADD_TO_MLQUEUE;
0718         break;
0719     }
0720     /* success just means we do not care what scsi-ml does */
0721     return SCSI_RETURN_NOT_HANDLED;
0722 }
0723 
0724 static int rdac_bus_attach(struct scsi_device *sdev)
0725 {
0726     struct rdac_dh_data *h;
0727     int err;
0728     char array_name[ARRAY_LABEL_LEN];
0729     char array_id[UNIQUE_ID_LEN];
0730 
0731     h = kzalloc(sizeof(*h) , GFP_KERNEL);
0732     if (!h)
0733         return SCSI_DH_NOMEM;
0734     h->lun = UNINITIALIZED_LUN;
0735     h->state = RDAC_STATE_ACTIVE;
0736 
0737     err = get_lun_info(sdev, h, array_name, array_id);
0738     if (err != SCSI_DH_OK)
0739         goto failed;
0740 
0741     err = initialize_controller(sdev, h, array_name, array_id);
0742     if (err != SCSI_DH_OK)
0743         goto failed;
0744 
0745     err = check_ownership(sdev, h);
0746     if (err != SCSI_DH_OK)
0747         goto clean_ctlr;
0748 
0749     err = set_mode_select(sdev, h);
0750     if (err != SCSI_DH_OK)
0751         goto clean_ctlr;
0752 
0753     sdev_printk(KERN_NOTICE, sdev,
0754             "%s: LUN %d (%s) (%s)\n",
0755             RDAC_NAME, h->lun, mode[(int)h->mode],
0756             lun_state[(int)h->lun_state]);
0757 
0758     sdev->handler_data = h;
0759     return SCSI_DH_OK;
0760 
0761 clean_ctlr:
0762     spin_lock(&list_lock);
0763     kref_put(&h->ctlr->kref, release_controller);
0764     spin_unlock(&list_lock);
0765 
0766 failed:
0767     kfree(h);
0768     return err;
0769 }
0770 
0771 static void rdac_bus_detach( struct scsi_device *sdev )
0772 {
0773     struct rdac_dh_data *h = sdev->handler_data;
0774 
0775     if (h->ctlr && h->ctlr->ms_queued)
0776         flush_workqueue(kmpath_rdacd);
0777 
0778     spin_lock(&list_lock);
0779     if (h->ctlr) {
0780         list_del_rcu(&h->node);
0781         kref_put(&h->ctlr->kref, release_controller);
0782     }
0783     spin_unlock(&list_lock);
0784     sdev->handler_data = NULL;
0785     synchronize_rcu();
0786     kfree(h);
0787 }
0788 
0789 static struct scsi_device_handler rdac_dh = {
0790     .name = RDAC_NAME,
0791     .module = THIS_MODULE,
0792     .prep_fn = rdac_prep_fn,
0793     .check_sense = rdac_check_sense,
0794     .attach = rdac_bus_attach,
0795     .detach = rdac_bus_detach,
0796     .activate = rdac_activate,
0797 };
0798 
0799 static int __init rdac_init(void)
0800 {
0801     int r;
0802 
0803     r = scsi_register_device_handler(&rdac_dh);
0804     if (r != 0) {
0805         printk(KERN_ERR "Failed to register scsi device handler.");
0806         goto done;
0807     }
0808 
0809     /*
0810      * Create workqueue to handle mode selects for rdac
0811      */
0812     kmpath_rdacd = create_singlethread_workqueue("kmpath_rdacd");
0813     if (!kmpath_rdacd) {
0814         scsi_unregister_device_handler(&rdac_dh);
0815         printk(KERN_ERR "kmpath_rdacd creation failed.\n");
0816 
0817         r = -EINVAL;
0818     }
0819 done:
0820     return r;
0821 }
0822 
0823 static void __exit rdac_exit(void)
0824 {
0825     destroy_workqueue(kmpath_rdacd);
0826     scsi_unregister_device_handler(&rdac_dh);
0827 }
0828 
0829 module_init(rdac_init);
0830 module_exit(rdac_exit);
0831 
0832 MODULE_DESCRIPTION("Multipath LSI/Engenio/NetApp E-Series RDAC driver");
0833 MODULE_AUTHOR("Mike Christie, Chandra Seetharaman");
0834 MODULE_VERSION("01.00.0000.0000");
0835 MODULE_LICENSE("GPL");
[ Source navigation ] [ Diff markup ] [ Identifier search ] [ general search ]

This page was automatically generated by the 2.1.0 LXR engine.

The LXR team
Valid CSS 2.1! Valid HTML 4.01!