drivers/scsi/device_handler/scsi_dh_alua.c

   1 /*
   2  * Generic SCSI-3 ALUA SCSI Device Handler
   3  *
   4  * Copyright (C) 2007, 2008 Hannes Reinecke, SUSE Linux Products GmbH.
   5  * All rights reserved.
   6  *
   7  * This program is free software; you can redistribute it and/or modify
   8  * it under the terms of the GNU General Public License as published by
   9  * the Free Software Foundation; either version 2 of the License, or
  10  * (at your option) any later version.
  11  *
  12  * This program is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15  * GNU General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU General Public License
  18  * along with this program; if not, write to the Free Software
  19  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
  20  *
  21  */
  22 #include <linux/slab.h>
  23 #include <scsi/scsi.h>
  24 #include <scsi/scsi_eh.h>
  25 #include <scsi/scsi_dh.h>
  26
  27 #define ALUA_DH_NAME "alua"
  28 #define ALUA_DH_VER "1.2"
  29
  30 #define TPGS_STATE_OPTIMIZED            0x0
  31 #define TPGS_STATE_NONOPTIMIZED         0x1
  32 #define TPGS_STATE_STANDBY              0x2
  33 #define TPGS_STATE_UNAVAILABLE          0x3
  34 #define TPGS_STATE_OFFLINE              0xe
  35 #define TPGS_STATE_TRANSITIONING        0xf
  36
  37 #define TPGS_SUPPORT_NONE               0x00
  38 #define TPGS_SUPPORT_OPTIMIZED          0x01
  39 #define TPGS_SUPPORT_NONOPTIMIZED       0x02
  40 #define TPGS_SUPPORT_STANDBY            0x04
  41 #define TPGS_SUPPORT_UNAVAILABLE        0x08
  42 #define TPGS_SUPPORT_OFFLINE            0x40
  43 #define TPGS_SUPPORT_TRANSITION         0x80
  44
  45 #define TPGS_MODE_UNINITIALIZED          -1
  46 #define TPGS_MODE_NONE                  0x0
  47 #define TPGS_MODE_IMPLICIT              0x1
  48 #define TPGS_MODE_EXPLICIT              0x2
  49
  50 #define ALUA_INQUIRY_SIZE               36
  51 #define ALUA_FAILOVER_TIMEOUT           (60 * HZ)
  52 #define ALUA_FAILOVER_RETRIES           5
  53
  54 struct alua_dh_data {
  55         int                     group_id;
  56         int                     rel_port;
  57         int                     tpgs;
  58         int                     state;
  59         unsigned char           inq[ALUA_INQUIRY_SIZE];
  60         unsigned char           *buff;
  61         int                     bufflen;
  62         unsigned char           sense[SCSI_SENSE_BUFFERSIZE];
  63         int                     senselen;
  64         struct scsi_device      *sdev;
  65         activate_complete       callback_fn;
  66         void                    *callback_data;
  67 };
  68
  69 #define ALUA_POLICY_SWITCH_CURRENT      0
  70 #define ALUA_POLICY_SWITCH_ALL          1
  71
  72 static char print_alua_state(int);
  73 static int alua_check_sense(struct scsi_device *, struct scsi_sense_hdr *);
  74
  75 static inline struct alua_dh_data *get_alua_data(struct scsi_device *sdev)
  76 {
  77         struct scsi_dh_data *scsi_dh_data = sdev->scsi_dh_data;
  78         BUG_ON(scsi_dh_data == NULL);
  79         return ((struct alua_dh_data *) scsi_dh_data->buf);
  80 }
  81
  82 static int realloc_buffer(struct alua_dh_data *h, unsigned len)
  83 {
  84         if (h->buff && h->buff != h->inq)
  85                 kfree(h->buff);
  86
  87         h->buff = kmalloc(len, GFP_NOIO);
  88         if (!h->buff) {
  89                 h->buff = h->inq;
  90                 h->bufflen = ALUA_INQUIRY_SIZE;
  91                 return 1;
  92         }
  93         h->bufflen = len;
  94         return 0;
  95 }
  96
  97 static struct request *get_alua_req(struct scsi_device *sdev,
  98                                     void *buffer, unsigned buflen, int rw)
  99 {
 100         struct request *rq;
 101         struct request_queue *q = sdev->request_queue;
 102
 103         rq = blk_get_request(q, rw, GFP_NOIO);
 104
 105         if (!rq) {
 106                 sdev_printk(KERN_INFO, sdev,
 107                             "%s: blk_get_request failed\n", __func__);
 108                 return NULL;
 109         }
 110
 111         if (buflen && blk_rq_map_kern(q, rq, buffer, buflen, GFP_NOIO)) {
 112                 blk_put_request(rq);
 113                 sdev_printk(KERN_INFO, sdev,
 114                             "%s: blk_rq_map_kern failed\n", __func__);
 115                 return NULL;
 116         }
 117
 118         rq->cmd_type = REQ_TYPE_BLOCK_PC;
 119         rq->cmd_flags |= REQ_FAILFAST_DEV | REQ_FAILFAST_TRANSPORT |
 120                          REQ_FAILFAST_DRIVER;
 121         rq->retries = ALUA_FAILOVER_RETRIES;
 122         rq->timeout = ALUA_FAILOVER_TIMEOUT;
 123
 124         return rq;
 125 }
 126
 127 /*
 128  * submit_std_inquiry - Issue a standard INQUIRY command
 129  * @sdev: sdev the command should be send to
 130  */
 131 static int submit_std_inquiry(struct scsi_device *sdev, struct alua_dh_data *h)
 132 {
 133         struct request *rq;
 134         int err = SCSI_DH_RES_TEMP_UNAVAIL;
 135
 136         rq = get_alua_req(sdev, h->inq, ALUA_INQUIRY_SIZE, READ);
 137         if (!rq)
 138                 goto done;
 139
 140         /* Prepare the command. */
 141         rq->cmd[0] = INQUIRY;
 142         rq->cmd[1] = 0;
 143         rq->cmd[2] = 0;
 144         rq->cmd[4] = ALUA_INQUIRY_SIZE;
 145         rq->cmd_len = COMMAND_SIZE(INQUIRY);
 146
 147         rq->sense = h->sense;
 148         memset(rq->sense, 0, SCSI_SENSE_BUFFERSIZE);
 149         rq->sense_len = h->senselen = 0;
 150
 151         err = blk_execute_rq(rq->q, NULL, rq, 1);
 152         if (err == -EIO) {
 153                 sdev_printk(KERN_INFO, sdev,
 154                             "%s: std inquiry failed with %x\n",
 155                             ALUA_DH_NAME, rq->errors);
 156                 h->senselen = rq->sense_len;
 157                 err = SCSI_DH_IO;
 158         }
 159         blk_put_request(rq);
 160 done:
 161         return err;
 162 }
 163
 164 /*
 165  * submit_vpd_inquiry - Issue an INQUIRY VPD page 0x83 command
 166  * @sdev: sdev the command should be sent to
 167  */
 168 static int submit_vpd_inquiry(struct scsi_device *sdev, struct alua_dh_data *h)
 169 {
 170         struct request *rq;
 171         int err = SCSI_DH_RES_TEMP_UNAVAIL;
 172
 173         rq = get_alua_req(sdev, h->buff, h->bufflen, READ);
 174         if (!rq)
 175                 goto done;
 176
 177         /* Prepare the command. */
 178         rq->cmd[0] = INQUIRY;
 179         rq->cmd[1] = 1;
 180         rq->cmd[2] = 0x83;
 181         rq->cmd[4] = h->bufflen;
 182         rq->cmd_len = COMMAND_SIZE(INQUIRY);
 183
 184         rq->sense = h->sense;
 185         memset(rq->sense, 0, SCSI_SENSE_BUFFERSIZE);
 186         rq->sense_len = h->senselen = 0;
 187
 188         err = blk_execute_rq(rq->q, NULL, rq, 1);
 189         if (err == -EIO) {
 190                 sdev_printk(KERN_INFO, sdev,
 191                             "%s: evpd inquiry failed with %x\n",
 192                             ALUA_DH_NAME, rq->errors);
 193                 h->senselen = rq->sense_len;
 194                 err = SCSI_DH_IO;
 195         }
 196         blk_put_request(rq);
 197 done:
 198         return err;
 199 }
 200
 201 /*
 202  * submit_rtpg - Issue a REPORT TARGET GROUP STATES command
 203  * @sdev: sdev the command should be sent to
 204  */
 205 static unsigned submit_rtpg(struct scsi_device *sdev, struct alua_dh_data *h)
 206 {
 207         struct request *rq;
 208         int err = SCSI_DH_RES_TEMP_UNAVAIL;
 209
 210         rq = get_alua_req(sdev, h->buff, h->bufflen, READ);
 211         if (!rq)
 212                 goto done;
 213
 214         /* Prepare the command. */
 215         rq->cmd[0] = MAINTENANCE_IN;
 216         rq->cmd[1] = MI_REPORT_TARGET_PGS;
 217         rq->cmd[6] = (h->bufflen >> 24) & 0xff;
 218         rq->cmd[7] = (h->bufflen >> 16) & 0xff;
 219         rq->cmd[8] = (h->bufflen >>  8) & 0xff;
 220         rq->cmd[9] = h->bufflen & 0xff;
 221         rq->cmd_len = COMMAND_SIZE(MAINTENANCE_IN);
 222
 223         rq->sense = h->sense;
 224         memset(rq->sense, 0, SCSI_SENSE_BUFFERSIZE);
 225         rq->sense_len = h->senselen = 0;
 226
 227         err = blk_execute_rq(rq->q, NULL, rq, 1);
 228         if (err == -EIO) {
 229                 sdev_printk(KERN_INFO, sdev,
 230                             "%s: rtpg failed with %x\n",
 231                             ALUA_DH_NAME, rq->errors);
 232                 h->senselen = rq->sense_len;
 233                 err = SCSI_DH_IO;
 234         }
 235         blk_put_request(rq);
 236 done:
 237         return err;
 238 }
 239
 240 /*
 241  * alua_stpg - Evaluate SET TARGET GROUP STATES
 242  * @sdev: the device to be evaluated
 243  * @state: the new target group state
 244  *
 245  * Send a SET TARGET GROUP STATES command to the device.
 246  * We only have to test here if we should resubmit the command;
 247  * any other error is assumed as a failure.
 248  */
 249 static void stpg_endio(struct request *req, int error)
 250 {
 251         struct alua_dh_data *h = req->end_io_data;
 252         struct scsi_sense_hdr sense_hdr;
 253         unsigned err = SCSI_DH_IO;
 254
 255         if (error || host_byte(req->errors) != DID_OK ||
 256                         msg_byte(req->errors) != COMMAND_COMPLETE)
 257                 goto done;
 258
 259         if (err == SCSI_DH_IO && h->senselen > 0) {
 260                 err = scsi_normalize_sense(h->sense, SCSI_SENSE_BUFFERSIZE,
 261                                            &sense_hdr);
 262                 if (!err) {
 263                         err = SCSI_DH_IO;
 264                         goto done;
 265                 }
 266                 err = alua_check_sense(h->sdev, &sense_hdr);
 267                 if (err == ADD_TO_MLQUEUE) {
 268                         err = SCSI_DH_RETRY;
 269                         goto done;
 270                 }
 271                 sdev_printk(KERN_INFO, h->sdev,
 272                             "%s: stpg sense code: %02x/%02x/%02x\n",
 273                             ALUA_DH_NAME, sense_hdr.sense_key,
 274                             sense_hdr.asc, sense_hdr.ascq);
 275                 err = SCSI_DH_IO;
 276         }
 277         if (err == SCSI_DH_OK) {
 278                 h->state = TPGS_STATE_OPTIMIZED;
 279                 sdev_printk(KERN_INFO, h->sdev,
 280                             "%s: port group %02x switched to state %c\n",
 281                             ALUA_DH_NAME, h->group_id,
 282                             print_alua_state(h->state));
 283         }
 284 done:
 285         blk_put_request(req);
 286         if (h->callback_fn) {
 287                 h->callback_fn(h->callback_data, err);
 288                 h->callback_fn = h->callback_data = NULL;
 289         }
 290         return;
 291 }
 292
 293 /*
 294  * submit_stpg - Issue a SET TARGET GROUP STATES command
 295  *
 296  * Currently we're only setting the current target port group state
 297  * to 'active/optimized' and let the array firmware figure out
 298  * the states of the remaining groups.
 299  */
 300 static unsigned submit_stpg(struct alua_dh_data *h)
 301 {
 302         struct request *rq;
 303         int err = SCSI_DH_RES_TEMP_UNAVAIL;
 304         int stpg_len = 8;
 305         struct scsi_device *sdev = h->sdev;
 306
 307         /* Prepare the data buffer */
 308         memset(h->buff, 0, stpg_len);
 309         h->buff[4] = TPGS_STATE_OPTIMIZED & 0x0f;
 310         h->buff[6] = (h->group_id >> 8) & 0xff;
 311         h->buff[7] = h->group_id & 0xff;
 312
 313         rq = get_alua_req(sdev, h->buff, stpg_len, WRITE);
 314         if (!rq)
 315                 return SCSI_DH_RES_TEMP_UNAVAIL;
 316
 317         /* Prepare the command. */
 318         rq->cmd[0] = MAINTENANCE_OUT;
 319         rq->cmd[1] = MO_SET_TARGET_PGS;
 320         rq->cmd[6] = (stpg_len >> 24) & 0xff;
 321         rq->cmd[7] = (stpg_len >> 16) & 0xff;
 322         rq->cmd[8] = (stpg_len >>  8) & 0xff;
 323         rq->cmd[9] = stpg_len & 0xff;
 324         rq->cmd_len = COMMAND_SIZE(MAINTENANCE_OUT);
 325
 326         rq->sense = h->sense;
 327         memset(rq->sense, 0, SCSI_SENSE_BUFFERSIZE);
 328         rq->sense_len = h->senselen = 0;
 329         rq->end_io_data = h;
 330
 331         blk_execute_rq_nowait(rq->q, NULL, rq, 1, stpg_endio);
 332         return err;
 333 }
 334
 335 /*
 336  * alua_std_inquiry - Evaluate standard INQUIRY command
 337  * @sdev: device to be checked
 338  *
 339  * Just extract the TPGS setting to find out if ALUA
 340  * is supported.
 341  */
 342 static int alua_std_inquiry(struct scsi_device *sdev, struct alua_dh_data *h)
 343 {
 344         int err;
 345
 346         err = submit_std_inquiry(sdev, h);
 347
 348         if (err != SCSI_DH_OK)
 349                 return err;
 350
 351         /* Check TPGS setting */
 352         h->tpgs = (h->inq[5] >> 4) & 0x3;
 353         switch (h->tpgs) {
 354         case TPGS_MODE_EXPLICIT|TPGS_MODE_IMPLICIT:
 355                 sdev_printk(KERN_INFO, sdev,
 356                             "%s: supports implicit and explicit TPGS\n",
 357                             ALUA_DH_NAME);
 358                 break;
 359         case TPGS_MODE_EXPLICIT:
 360                 sdev_printk(KERN_INFO, sdev, "%s: supports explicit TPGS\n",
 361                             ALUA_DH_NAME);
 362                 break;
 363         case TPGS_MODE_IMPLICIT:
 364                 sdev_printk(KERN_INFO, sdev, "%s: supports implicit TPGS\n",
 365                             ALUA_DH_NAME);
 366                 break;
 367         default:
 368                 h->tpgs = TPGS_MODE_NONE;
 369                 sdev_printk(KERN_INFO, sdev, "%s: not supported\n",
 370                             ALUA_DH_NAME);
 371                 err = SCSI_DH_DEV_UNSUPP;
 372                 break;
 373         }
 374
 375         return err;
 376 }
 377
 378 /*
 379  * alua_vpd_inquiry - Evaluate INQUIRY vpd page 0x83
 380  * @sdev: device to be checked
 381  *
 382  * Extract the relative target port and the target port group
 383  * descriptor from the list of identificators.
 384  */
 385 static int alua_vpd_inquiry(struct scsi_device *sdev, struct alua_dh_data *h)
 386 {
 387         int len;
 388         unsigned err;
 389         unsigned char *d;
 390
 391  retry:
 392         err = submit_vpd_inquiry(sdev, h);
 393
 394         if (err != SCSI_DH_OK)
 395                 return err;
 396
 397         /* Check if vpd page exceeds initial buffer */
 398         len = (h->buff[2] << 8) + h->buff[3] + 4;
 399         if (len > h->bufflen) {
 400                 /* Resubmit with the correct length */
 401                 if (realloc_buffer(h, len)) {
 402                         sdev_printk(KERN_WARNING, sdev,
 403                                     "%s: kmalloc buffer failed\n",
 404                                     ALUA_DH_NAME);
 405                         /* Temporary failure, bypass */
 406                         return SCSI_DH_DEV_TEMP_BUSY;
 407                 }
 408                 goto retry;
 409         }
 410
 411         /*
 412          * Now look for the correct descriptor.
 413          */
 414         d = h->buff + 4;
 415         while (d < h->buff + len) {
 416                 switch (d[1] & 0xf) {
 417                 case 0x4:
 418                         /* Relative target port */
 419                         h->rel_port = (d[6] << 8) + d[7];
 420                         break;
 421                 case 0x5:
 422                         /* Target port group */
 423                         h->group_id = (d[6] << 8) + d[7];
 424                         break;
 425                 default:
 426                         break;
 427                 }
 428                 d += d[3] + 4;
 429         }
 430
 431         if (h->group_id == -1) {
 432                 /*
 433                  * Internal error; TPGS supported but required
 434                  * VPD identification descriptors not present.
 435                  * Disable ALUA support
 436                  */
 437                 sdev_printk(KERN_INFO, sdev,
 438                             "%s: No target port descriptors found\n",
 439                             ALUA_DH_NAME);
 440                 h->state = TPGS_STATE_OPTIMIZED;
 441                 h->tpgs = TPGS_MODE_NONE;
 442                 err = SCSI_DH_DEV_UNSUPP;
 443         } else {
 444                 sdev_printk(KERN_INFO, sdev,
 445                             "%s: port group %02x rel port %02x\n",
 446                             ALUA_DH_NAME, h->group_id, h->rel_port);
 447         }
 448
 449         return err;
 450 }
 451
 452 static char print_alua_state(int state)
 453 {
 454         switch (state) {
 455         case TPGS_STATE_OPTIMIZED:
 456                 return 'A';
 457         case TPGS_STATE_NONOPTIMIZED:
 458                 return 'N';
 459         case TPGS_STATE_STANDBY:
 460                 return 'S';
 461         case TPGS_STATE_UNAVAILABLE:
 462                 return 'U';
 463         case TPGS_STATE_OFFLINE:
 464                 return 'O';
 465         case TPGS_STATE_TRANSITIONING:
 466                 return 'T';
 467         default:
 468                 return 'X';
 469         }
 470 }
 471
 472 static int alua_check_sense(struct scsi_device *sdev,
 473                             struct scsi_sense_hdr *sense_hdr)
 474 {
 475         switch (sense_hdr->sense_key) {
 476         case NOT_READY:
 477                 if (sense_hdr->asc == 0x04 && sense_hdr->ascq == 0x0a)
 478                         /*
 479                          * LUN Not Accessible - ALUA state transition
 480                          */
 481                         return ADD_TO_MLQUEUE;
 482                 if (sense_hdr->asc == 0x04 && sense_hdr->ascq == 0x0b)
 483                         /*
 484                          * LUN Not Accessible -- Target port in standby state
 485                          */
 486                         return SUCCESS;
 487                 if (sense_hdr->asc == 0x04 && sense_hdr->ascq == 0x0c)
 488                         /*
 489                          * LUN Not Accessible -- Target port in unavailable state
 490                          */
 491                         return SUCCESS;
 492                 if (sense_hdr->asc == 0x04 && sense_hdr->ascq == 0x12)
 493                         /*
 494                          * LUN Not Ready -- Offline
 495                          */
 496                         return SUCCESS;
 497                 break;
 498         case UNIT_ATTENTION:
 499                 if (sense_hdr->asc == 0x29 && sense_hdr->ascq == 0x00)
 500                         /*
 501                          * Power On, Reset, or Bus Device Reset, just retry.
 502                          */
 503                         return ADD_TO_MLQUEUE;
 504                 if (sense_hdr->asc == 0x2a && sense_hdr->ascq == 0x06) {
 505                         /*
 506                          * ALUA state changed
 507                          */
 508                         return ADD_TO_MLQUEUE;
 509                 }
 510                 if (sense_hdr->asc == 0x2a && sense_hdr->ascq == 0x07) {
 511                         /*
 512                          * Implicit ALUA state transition failed
 513                          */
 514                         return ADD_TO_MLQUEUE;
 515                 }
 516                 if (sense_hdr->asc == 0x3f && sense_hdr->ascq == 0x0e) {
 517                         /*
 518                          * REPORTED_LUNS_DATA_HAS_CHANGED is reported
 519                          * when switching controllers on targets like
 520                          * Intel Multi-Flex. We can just retry.
 521                          */
 522                         return ADD_TO_MLQUEUE;
 523                 }
 524
 525                 break;
 526         }
 527
 528         return SCSI_RETURN_NOT_HANDLED;
 529 }
 530
 531 /*
 532  * alua_rtpg - Evaluate REPORT TARGET GROUP STATES
 533  * @sdev: the device to be evaluated.
 534  *
 535  * Evaluate the Target Port Group State.
 536  * Returns SCSI_DH_DEV_OFFLINED if the path is
 537  * found to be unuseable.
 538  */
 539 static int alua_rtpg(struct scsi_device *sdev, struct alua_dh_data *h)
 540 {
 541         struct scsi_sense_hdr sense_hdr;
 542         int len, k, off, valid_states = 0;
 543         char *ucp;
 544         unsigned err;
 545
 546  retry:
 547         err = submit_rtpg(sdev, h);
 548
 549         if (err == SCSI_DH_IO && h->senselen > 0) {
 550                 err = scsi_normalize_sense(h->sense, SCSI_SENSE_BUFFERSIZE,
 551                                            &sense_hdr);
 552                 if (!err)
 553                         return SCSI_DH_IO;
 554
 555                 err = alua_check_sense(sdev, &sense_hdr);
 556                 if (err == ADD_TO_MLQUEUE)
 557                         goto retry;
 558                 sdev_printk(KERN_INFO, sdev,
 559                             "%s: rtpg sense code %02x/%02x/%02x\n",
 560                             ALUA_DH_NAME, sense_hdr.sense_key,
 561                             sense_hdr.asc, sense_hdr.ascq);
 562                 err = SCSI_DH_IO;
 563         }
 564         if (err != SCSI_DH_OK)
 565                 return err;
 566
 567         len = (h->buff[0] << 24) + (h->buff[1] << 16) +
 568                 (h->buff[2] << 8) + h->buff[3] + 4;
 569
 570         if (len > h->bufflen) {
 571                 /* Resubmit with the correct length */
 572                 if (realloc_buffer(h, len)) {
 573                         sdev_printk(KERN_WARNING, sdev,
 574                                     "%s: kmalloc buffer failed\n",__func__);
 575                         /* Temporary failure, bypass */
 576                         return SCSI_DH_DEV_TEMP_BUSY;
 577                 }
 578                 goto retry;
 579         }
 580
 581         for (k = 4, ucp = h->buff + 4; k < len; k += off, ucp += off) {
 582                 if (h->group_id == (ucp[2] << 8) + ucp[3]) {
 583                         h->state = ucp[0] & 0x0f;
 584                         valid_states = ucp[1];
 585                 }
 586                 off = 8 + (ucp[7] * 4);
 587         }
 588
 589         sdev_printk(KERN_INFO, sdev,
 590                     "%s: port group %02x state %c supports %c%c%c%c%c%c\n",
 591                     ALUA_DH_NAME, h->group_id, print_alua_state(h->state),
 592                     valid_states&TPGS_SUPPORT_TRANSITION?'T':'t',
 593                     valid_states&TPGS_SUPPORT_OFFLINE?'O':'o',
 594                     valid_states&TPGS_SUPPORT_UNAVAILABLE?'U':'u',
 595                     valid_states&TPGS_SUPPORT_STANDBY?'S':'s',
 596                     valid_states&TPGS_SUPPORT_NONOPTIMIZED?'N':'n',
 597                     valid_states&TPGS_SUPPORT_OPTIMIZED?'A':'a');
 598
 599         if (h->tpgs & TPGS_MODE_EXPLICIT) {
 600                 switch (h->state) {
 601                 case TPGS_STATE_TRANSITIONING:
 602                         /* State transition, retry */
 603                         goto retry;
 604                         break;
 605                 case TPGS_STATE_OFFLINE:
 606                         /* Path is offline, fail */
 607                         err = SCSI_DH_DEV_OFFLINED;
 608                         break;
 609                 default:
 610                         break;
 611                 }
 612         } else {
 613                 /* Only Implicit ALUA support */
 614                 if (h->state == TPGS_STATE_OPTIMIZED ||
 615                     h->state == TPGS_STATE_NONOPTIMIZED ||
 616                     h->state == TPGS_STATE_STANDBY)
 617                         /* Useable path if active */
 618                         err = SCSI_DH_OK;
 619                 else
 620                         /* Path unuseable for unavailable/offline */
 621                         err = SCSI_DH_DEV_OFFLINED;
 622         }
 623         return err;
 624 }
 625
 626 /*
 627  * alua_initialize - Initialize ALUA state
 628  * @sdev: the device to be initialized
 629  *
 630  * For the prep_fn to work correctly we have
 631  * to initialize the ALUA state for the device.
 632  */
 633 static int alua_initialize(struct scsi_device *sdev, struct alua_dh_data *h)
 634 {
 635         int err;
 636
 637         err = alua_std_inquiry(sdev, h);
 638         if (err != SCSI_DH_OK)
 639                 goto out;
 640
 641         err = alua_vpd_inquiry(sdev, h);
 642         if (err != SCSI_DH_OK)
 643                 goto out;
 644
 645         err = alua_rtpg(sdev, h);
 646         if (err != SCSI_DH_OK)
 647                 goto out;
 648
 649 out:
 650         return err;
 651 }
 652
 653 /*
 654  * alua_activate - activate a path
 655  * @sdev: device on the path to be activated
 656  *
 657  * We're currently switching the port group to be activated only and
 658  * let the array figure out the rest.
 659  * There may be other arrays which require us to switch all port groups
 660  * based on a certain policy. But until we actually encounter them it
 661  * should be okay.
 662  */
 663 static int alua_activate(struct scsi_device *sdev,
 664                         activate_complete fn, void *data)
 665 {
 666         struct alua_dh_data *h = get_alua_data(sdev);
 667         int err = SCSI_DH_OK;
 668
 669         if (h->group_id != -1) {
 670                 err = alua_rtpg(sdev, h);
 671                 if (err != SCSI_DH_OK)
 672                         goto out;
 673         }
 674
 675         if (h->tpgs & TPGS_MODE_EXPLICIT && h->state != TPGS_STATE_OPTIMIZED) {
 676                 h->callback_fn = fn;
 677                 h->callback_data = data;
 678                 err = submit_stpg(h);
 679                 if (err == SCSI_DH_OK)
 680                         return 0;
 681                 h->callback_fn = h->callback_data = NULL;
 682         }
 683
 684 out:
 685         if (fn)
 686                 fn(data, err);
 687         return 0;
 688 }
 689
 690 /*
 691  * alua_prep_fn - request callback
 692  *
 693  * Fail I/O to all paths not in state
 694  * active/optimized or active/non-optimized.
 695  */
 696 static int alua_prep_fn(struct scsi_device *sdev, struct request *req)
 697 {
 698         struct alua_dh_data *h = get_alua_data(sdev);
 699         int ret = BLKPREP_OK;
 700
 701         if (h->state != TPGS_STATE_OPTIMIZED &&
 702             h->state != TPGS_STATE_NONOPTIMIZED) {
 703                 ret = BLKPREP_KILL;
 704                 req->cmd_flags |= REQ_QUIET;
 705         }
 706         return ret;
 707
 708 }
 709
 710 static const struct scsi_dh_devlist alua_dev_list[] = {
 711         {"HP", "MSA VOLUME" },
 712         {"HP", "HSV101" },
 713         {"HP", "HSV111" },
 714         {"HP", "HSV200" },
 715         {"HP", "HSV210" },
 716         {"HP", "HSV300" },
 717         {"IBM", "2107900" },
 718         {"IBM", "2145" },
 719         {"Pillar", "Axiom" },
 720         {"Intel", "Multi-Flex"},
 721         {"NETAPP", "LUN"},
 722         {"AIX", "NVDISK"},
 723         {NULL, NULL}
 724 };
 725
 726 static int alua_bus_attach(struct scsi_device *sdev);
 727 static void alua_bus_detach(struct scsi_device *sdev);
 728
 729 static struct scsi_device_handler alua_dh = {
 730         .name = ALUA_DH_NAME,
 731         .module = THIS_MODULE,
 732         .devlist = alua_dev_list,
 733         .attach = alua_bus_attach,
 734         .detach = alua_bus_detach,
 735         .prep_fn = alua_prep_fn,
 736         .check_sense = alua_check_sense,
 737         .activate = alua_activate,
 738 };
 739
 740 /*
 741  * alua_bus_attach - Attach device handler
 742  * @sdev: device to be attached to
 743  */
 744 static int alua_bus_attach(struct scsi_device *sdev)
 745 {
 746         struct scsi_dh_data *scsi_dh_data;
 747         struct alua_dh_data *h;
 748         unsigned long flags;
 749         int err = SCSI_DH_OK;
 750
 751         scsi_dh_data = kzalloc(sizeof(struct scsi_device_handler *)
 752                                + sizeof(*h) , GFP_KERNEL);
 753         if (!scsi_dh_data) {
 754                 sdev_printk(KERN_ERR, sdev, "%s: Attach failed\n",
 755                             ALUA_DH_NAME);
 756                 return -ENOMEM;
 757         }
 758
 759         scsi_dh_data->scsi_dh = &alua_dh;
 760         h = (struct alua_dh_data *) scsi_dh_data->buf;
 761         h->tpgs = TPGS_MODE_UNINITIALIZED;
 762         h->state = TPGS_STATE_OPTIMIZED;
 763         h->group_id = -1;
 764         h->rel_port = -1;
 765         h->buff = h->inq;
 766         h->bufflen = ALUA_INQUIRY_SIZE;
 767         h->sdev = sdev;
 768
 769         err = alua_initialize(sdev, h);
 770         if (err != SCSI_DH_OK)
 771                 goto failed;
 772
 773         if (!try_module_get(THIS_MODULE))
 774                 goto failed;
 775
 776         spin_lock_irqsave(sdev->request_queue->queue_lock, flags);
 777         sdev->scsi_dh_data = scsi_dh_data;
 778         spin_unlock_irqrestore(sdev->request_queue->queue_lock, flags);
 779
 780         return 0;
 781
 782 failed:
 783         kfree(scsi_dh_data);
 784         sdev_printk(KERN_ERR, sdev, "%s: not attached\n", ALUA_DH_NAME);
 785         return -EINVAL;
 786 }
 787
 788 /*
 789  * alua_bus_detach - Detach device handler
 790  * @sdev: device to be detached from
 791  */
 792 static void alua_bus_detach(struct scsi_device *sdev)
 793 {
 794         struct scsi_dh_data *scsi_dh_data;
 795         struct alua_dh_data *h;
 796         unsigned long flags;
 797
 798         spin_lock_irqsave(sdev->request_queue->queue_lock, flags);
 799         scsi_dh_data = sdev->scsi_dh_data;
 800         sdev->scsi_dh_data = NULL;
 801         spin_unlock_irqrestore(sdev->request_queue->queue_lock, flags);
 802
 803         h = (struct alua_dh_data *) scsi_dh_data->buf;
 804         if (h->buff && h->inq != h->buff)
 805                 kfree(h->buff);
 806         kfree(scsi_dh_data);
 807         module_put(THIS_MODULE);
 808         sdev_printk(KERN_NOTICE, sdev, "%s: Detached\n", ALUA_DH_NAME);
 809 }
 810
 811 static int __init alua_init(void)
 812 {
 813         int r;
 814
 815         r = scsi_register_device_handler(&alua_dh);
 816         if (r != 0)
 817                 printk(KERN_ERR "%s: Failed to register scsi device handler",
 818                         ALUA_DH_NAME);
 819         return r;
 820 }
 821
 822 static void __exit alua_exit(void)
 823 {
 824         scsi_unregister_device_handler(&alua_dh);
 825 }
 826
 827 module_init(alua_init);
 828 module_exit(alua_exit);
 829
 830 MODULE_DESCRIPTION("DM Multipath ALUA support");
 831 MODULE_AUTHOR("Hannes Reinecke <hare@suse.de>");
 832 MODULE_LICENSE("GPL");
 833 MODULE_VERSION(ALUA_DH_VER);