drivers/scsi/device_handler/scsi_dh_alua.c

   1 /*
   2  * Generic SCSI-3 ALUA SCSI Device Handler
   3  *
   4  * Copyright (C) 2007-2010 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 <linux/delay.h>
  24 #include <linux/module.h>
  25 #include <asm/unaligned.h>
  26 #include <scsi/scsi.h>
  27 #include <scsi/scsi_dbg.h>
  28 #include <scsi/scsi_eh.h>
  29 #include <scsi/scsi_dh.h>
  30
  31 #define ALUA_DH_NAME "alua"
  32 #define ALUA_DH_VER "1.3"
  33
  34 #define TPGS_STATE_OPTIMIZED            0x0
  35 #define TPGS_STATE_NONOPTIMIZED         0x1
  36 #define TPGS_STATE_STANDBY              0x2
  37 #define TPGS_STATE_UNAVAILABLE          0x3
  38 #define TPGS_STATE_LBA_DEPENDENT        0x4
  39 #define TPGS_STATE_OFFLINE              0xe
  40 #define TPGS_STATE_TRANSITIONING        0xf
  41
  42 #define TPGS_SUPPORT_NONE               0x00
  43 #define TPGS_SUPPORT_OPTIMIZED          0x01
  44 #define TPGS_SUPPORT_NONOPTIMIZED       0x02
  45 #define TPGS_SUPPORT_STANDBY            0x04
  46 #define TPGS_SUPPORT_UNAVAILABLE        0x08
  47 #define TPGS_SUPPORT_LBA_DEPENDENT      0x10
  48 #define TPGS_SUPPORT_OFFLINE            0x40
  49 #define TPGS_SUPPORT_TRANSITION         0x80
  50
  51 #define RTPG_FMT_MASK                   0x70
  52 #define RTPG_FMT_EXT_HDR                0x10
  53
  54 #define TPGS_MODE_UNINITIALIZED          -1
  55 #define TPGS_MODE_NONE                  0x0
  56 #define TPGS_MODE_IMPLICIT              0x1
  57 #define TPGS_MODE_EXPLICIT              0x2
  58
  59 #define ALUA_RTPG_SIZE                  128
  60 #define ALUA_FAILOVER_TIMEOUT           60
  61 #define ALUA_FAILOVER_RETRIES           5
  62
  63 /* device handler flags */
  64 #define ALUA_OPTIMIZE_STPG              1
  65 #define ALUA_RTPG_EXT_HDR_UNSUPP        2
  66
  67 static LIST_HEAD(port_group_list);
  68 static DEFINE_SPINLOCK(port_group_lock);
  69
  70 struct alua_port_group {
  71         struct kref             kref;
  72         struct list_head        node;
  73         unsigned char           device_id_str[256];
  74         int                     device_id_len;
  75         int                     group_id;
  76         int                     tpgs;
  77         int                     state;
  78         int                     pref;
  79         unsigned                flags; /* used for optimizing STPG */
  80         unsigned char           transition_tmo;
  81 };
  82
  83 struct alua_dh_data {
  84         struct alua_port_group  *pg;
  85         int                     group_id;
  86         int                     rel_port;
  87         struct scsi_device      *sdev;
  88         activate_complete       callback_fn;
  89         void                    *callback_data;
  90 };
  91
  92 #define ALUA_POLICY_SWITCH_CURRENT      0
  93 #define ALUA_POLICY_SWITCH_ALL          1
  94
  95 static int alua_rtpg(struct scsi_device *, struct alua_port_group *);
  96 static char print_alua_state(int);
  97
  98 static void release_port_group(struct kref *kref)
  99 {
 100         struct alua_port_group *pg;
 101
 102         pg = container_of(kref, struct alua_port_group, kref);
 103         spin_lock(&port_group_lock);
 104         list_del(&pg->node);
 105         spin_unlock(&port_group_lock);
 106         kfree(pg);
 107 }
 108
 109 /*
 110  * submit_rtpg - Issue a REPORT TARGET GROUP STATES command
 111  * @sdev: sdev the command should be sent to
 112  */
 113 static int submit_rtpg(struct scsi_device *sdev, unsigned char *buff,
 114                        int bufflen, struct scsi_sense_hdr *sshdr, int flags)
 115 {
 116         u8 cdb[COMMAND_SIZE(MAINTENANCE_IN)];
 117         int req_flags = REQ_FAILFAST_DEV | REQ_FAILFAST_TRANSPORT |
 118                 REQ_FAILFAST_DRIVER;
 119
 120         /* Prepare the command. */
 121         memset(cdb, 0x0, COMMAND_SIZE(MAINTENANCE_IN));
 122         cdb[0] = MAINTENANCE_IN;
 123         if (!(flags & ALUA_RTPG_EXT_HDR_UNSUPP))
 124                 cdb[1] = MI_REPORT_TARGET_PGS | MI_EXT_HDR_PARAM_FMT;
 125         else
 126                 cdb[1] = MI_REPORT_TARGET_PGS;
 127         put_unaligned_be32(bufflen, &cdb[6]);
 128
 129         return scsi_execute_req_flags(sdev, cdb, DMA_FROM_DEVICE,
 130                                       buff, bufflen, sshdr,
 131                                       ALUA_FAILOVER_TIMEOUT * HZ,
 132                                       ALUA_FAILOVER_RETRIES, NULL, req_flags);
 133 }
 134
 135 /*
 136  * submit_stpg - Issue a SET TARGET PORT GROUP command
 137  *
 138  * Currently we're only setting the current target port group state
 139  * to 'active/optimized' and let the array firmware figure out
 140  * the states of the remaining groups.
 141  */
 142 static int submit_stpg(struct scsi_device *sdev, int group_id,
 143                        struct scsi_sense_hdr *sshdr)
 144 {
 145         u8 cdb[COMMAND_SIZE(MAINTENANCE_OUT)];
 146         unsigned char stpg_data[8];
 147         int stpg_len = 8;
 148         int req_flags = REQ_FAILFAST_DEV | REQ_FAILFAST_TRANSPORT |
 149                 REQ_FAILFAST_DRIVER;
 150
 151         /* Prepare the data buffer */
 152         memset(stpg_data, 0, stpg_len);
 153         stpg_data[4] = TPGS_STATE_OPTIMIZED & 0x0f;
 154         put_unaligned_be16(group_id, &stpg_data[6]);
 155
 156         /* Prepare the command. */
 157         memset(cdb, 0x0, COMMAND_SIZE(MAINTENANCE_OUT));
 158         cdb[0] = MAINTENANCE_OUT;
 159         cdb[1] = MO_SET_TARGET_PGS;
 160         put_unaligned_be32(stpg_len, &cdb[6]);
 161
 162         return scsi_execute_req_flags(sdev, cdb, DMA_TO_DEVICE,
 163                                       stpg_data, stpg_len,
 164                                       sshdr, ALUA_FAILOVER_TIMEOUT * HZ,
 165                                       ALUA_FAILOVER_RETRIES, NULL, req_flags);
 166 }
 167
 168 struct alua_port_group *alua_find_get_pg(char *id_str, size_t id_size,
 169                                          int group_id)
 170 {
 171         struct alua_port_group *pg;
 172
 173         list_for_each_entry(pg, &port_group_list, node) {
 174                 if (pg->group_id != group_id)
 175                         continue;
 176                 if (pg->device_id_len != id_size)
 177                         continue;
 178                 if (strncmp(pg->device_id_str, id_str, id_size))
 179                         continue;
 180                 if (!kref_get_unless_zero(&pg->kref))
 181                         continue;
 182                 return pg;
 183         }
 184
 185         return NULL;
 186 }
 187
 188 /*
 189  * alua_alloc_pg - Allocate a new port_group structure
 190  * @sdev: scsi device
 191  * @h: alua device_handler data
 192  * @group_id: port group id
 193  *
 194  * Allocate a new port_group structure for a given
 195  * device.
 196  */
 197 struct alua_port_group *alua_alloc_pg(struct scsi_device *sdev,
 198                                       int group_id, int tpgs)
 199 {
 200         struct alua_port_group *pg, *tmp_pg;
 201
 202         pg = kzalloc(sizeof(struct alua_port_group), GFP_KERNEL);
 203         if (!pg)
 204                 return ERR_PTR(-ENOMEM);
 205
 206         pg->device_id_len = scsi_vpd_lun_id(sdev, pg->device_id_str,
 207                                             sizeof(pg->device_id_str));
 208         if (pg->device_id_len <= 0) {
 209                 /*
 210                  * Internal error: TPGS supported but no device
 211                  * identifcation found. Disable ALUA support.
 212                  */
 213                 kfree(pg);
 214                 sdev_printk(KERN_INFO, sdev,
 215                             "%s: No device descriptors found\n",
 216                             ALUA_DH_NAME);
 217                 return ERR_PTR(-ENXIO);
 218         }
 219         pg->group_id = group_id;
 220         pg->tpgs = tpgs;
 221         pg->state = TPGS_STATE_OPTIMIZED;
 222         kref_init(&pg->kref);
 223
 224         spin_lock(&port_group_lock);
 225         tmp_pg = alua_find_get_pg(pg->device_id_str, pg->device_id_len,
 226                                   group_id);
 227         if (tmp_pg) {
 228                 spin_unlock(&port_group_lock);
 229                 kfree(pg);
 230                 return tmp_pg;
 231         }
 232
 233         list_add(&pg->node, &port_group_list);
 234         spin_unlock(&port_group_lock);
 235
 236         return pg;
 237 }
 238
 239 /*
 240  * alua_check_tpgs - Evaluate TPGS setting
 241  * @sdev: device to be checked
 242  *
 243  * Examine the TPGS setting of the sdev to find out if ALUA
 244  * is supported.
 245  */
 246 static int alua_check_tpgs(struct scsi_device *sdev)
 247 {
 248         int tpgs = TPGS_MODE_NONE;
 249
 250         /*
 251          * ALUA support for non-disk devices is fraught with
 252          * difficulties, so disable it for now.
 253          */
 254         if (sdev->type != TYPE_DISK) {
 255                 sdev_printk(KERN_INFO, sdev,
 256                             "%s: disable for non-disk devices\n",
 257                             ALUA_DH_NAME);
 258                 return tpgs;
 259         }
 260
 261         tpgs = scsi_device_tpgs(sdev);
 262         switch (tpgs) {
 263         case TPGS_MODE_EXPLICIT|TPGS_MODE_IMPLICIT:
 264                 sdev_printk(KERN_INFO, sdev,
 265                             "%s: supports implicit and explicit TPGS\n",
 266                             ALUA_DH_NAME);
 267                 break;
 268         case TPGS_MODE_EXPLICIT:
 269                 sdev_printk(KERN_INFO, sdev, "%s: supports explicit TPGS\n",
 270                             ALUA_DH_NAME);
 271                 break;
 272         case TPGS_MODE_IMPLICIT:
 273                 sdev_printk(KERN_INFO, sdev, "%s: supports implicit TPGS\n",
 274                             ALUA_DH_NAME);
 275                 break;
 276         case TPGS_MODE_NONE:
 277                 sdev_printk(KERN_INFO, sdev, "%s: not supported\n",
 278                             ALUA_DH_NAME);
 279                 break;
 280         default:
 281                 sdev_printk(KERN_INFO, sdev,
 282                             "%s: unsupported TPGS setting %d\n",
 283                             ALUA_DH_NAME, tpgs);
 284                 tpgs = TPGS_MODE_NONE;
 285                 break;
 286         }
 287
 288         return tpgs;
 289 }
 290
 291 /*
 292  * alua_check_vpd - Evaluate INQUIRY vpd page 0x83
 293  * @sdev: device to be checked
 294  *
 295  * Extract the relative target port and the target port group
 296  * descriptor from the list of identificators.
 297  */
 298 static int alua_check_vpd(struct scsi_device *sdev, struct alua_dh_data *h,
 299                           int tpgs)
 300 {
 301         int rel_port = -1, group_id;
 302
 303         group_id = scsi_vpd_tpg_id(sdev, &rel_port);
 304         if (group_id < 0) {
 305                 /*
 306                  * Internal error; TPGS supported but required
 307                  * VPD identification descriptors not present.
 308                  * Disable ALUA support
 309                  */
 310                 sdev_printk(KERN_INFO, sdev,
 311                             "%s: No target port descriptors found\n",
 312                             ALUA_DH_NAME);
 313                 return SCSI_DH_DEV_UNSUPP;
 314         }
 315
 316         h->pg = alua_alloc_pg(sdev, group_id, tpgs);
 317         if (IS_ERR(h->pg)) {
 318                 if (PTR_ERR(h->pg) == -ENOMEM)
 319                         return SCSI_DH_NOMEM;
 320                 return SCSI_DH_DEV_UNSUPP;
 321         }
 322         h->rel_port = rel_port;
 323
 324         sdev_printk(KERN_INFO, sdev,
 325                     "%s: device %s port group %x rel port %x\n",
 326                     ALUA_DH_NAME, h->pg->device_id_str,
 327                     h->group_id, h->rel_port);
 328
 329         return alua_rtpg(sdev, h->pg);
 330 }
 331
 332 static char print_alua_state(int state)
 333 {
 334         switch (state) {
 335         case TPGS_STATE_OPTIMIZED:
 336                 return 'A';
 337         case TPGS_STATE_NONOPTIMIZED:
 338                 return 'N';
 339         case TPGS_STATE_STANDBY:
 340                 return 'S';
 341         case TPGS_STATE_UNAVAILABLE:
 342                 return 'U';
 343         case TPGS_STATE_LBA_DEPENDENT:
 344                 return 'L';
 345         case TPGS_STATE_OFFLINE:
 346                 return 'O';
 347         case TPGS_STATE_TRANSITIONING:
 348                 return 'T';
 349         default:
 350                 return 'X';
 351         }
 352 }
 353
 354 static int alua_check_sense(struct scsi_device *sdev,
 355                             struct scsi_sense_hdr *sense_hdr)
 356 {
 357         switch (sense_hdr->sense_key) {
 358         case NOT_READY:
 359                 if (sense_hdr->asc == 0x04 && sense_hdr->ascq == 0x0a)
 360                         /*
 361                          * LUN Not Accessible - ALUA state transition
 362                          */
 363                         return ADD_TO_MLQUEUE;
 364                 break;
 365         case UNIT_ATTENTION:
 366                 if (sense_hdr->asc == 0x29 && sense_hdr->ascq == 0x00)
 367                         /*
 368                          * Power On, Reset, or Bus Device Reset, just retry.
 369                          */
 370                         return ADD_TO_MLQUEUE;
 371                 if (sense_hdr->asc == 0x29 && sense_hdr->ascq == 0x04)
 372                         /*
 373                          * Device internal reset
 374                          */
 375                         return ADD_TO_MLQUEUE;
 376                 if (sense_hdr->asc == 0x2a && sense_hdr->ascq == 0x01)
 377                         /*
 378                          * Mode Parameters Changed
 379                          */
 380                         return ADD_TO_MLQUEUE;
 381                 if (sense_hdr->asc == 0x2a && sense_hdr->ascq == 0x06)
 382                         /*
 383                          * ALUA state changed
 384                          */
 385                         return ADD_TO_MLQUEUE;
 386                 if (sense_hdr->asc == 0x2a && sense_hdr->ascq == 0x07)
 387                         /*
 388                          * Implicit ALUA state transition failed
 389                          */
 390                         return ADD_TO_MLQUEUE;
 391                 if (sense_hdr->asc == 0x3f && sense_hdr->ascq == 0x03)
 392                         /*
 393                          * Inquiry data has changed
 394                          */
 395                         return ADD_TO_MLQUEUE;
 396                 if (sense_hdr->asc == 0x3f && sense_hdr->ascq == 0x0e)
 397                         /*
 398                          * REPORTED_LUNS_DATA_HAS_CHANGED is reported
 399                          * when switching controllers on targets like
 400                          * Intel Multi-Flex. We can just retry.
 401                          */
 402                         return ADD_TO_MLQUEUE;
 403                 break;
 404         }
 405
 406         return SCSI_RETURN_NOT_HANDLED;
 407 }
 408
 409 /*
 410  * alua_rtpg - Evaluate REPORT TARGET GROUP STATES
 411  * @sdev: the device to be evaluated.
 412  *
 413  * Evaluate the Target Port Group State.
 414  * Returns SCSI_DH_DEV_OFFLINED if the path is
 415  * found to be unusable.
 416  */
 417 static int alua_rtpg(struct scsi_device *sdev, struct alua_port_group *pg)
 418 {
 419         struct scsi_sense_hdr sense_hdr;
 420         int len, k, off, valid_states = 0, bufflen = ALUA_RTPG_SIZE;
 421         unsigned char *ucp, *buff;
 422         unsigned err, retval;
 423         unsigned long expiry, interval = 0;
 424         unsigned int tpg_desc_tbl_off;
 425         unsigned char orig_transition_tmo;
 426
 427         if (!pg->transition_tmo)
 428                 expiry = round_jiffies_up(jiffies + ALUA_FAILOVER_TIMEOUT * HZ);
 429         else
 430                 expiry = round_jiffies_up(jiffies + pg->transition_tmo * HZ);
 431
 432         buff = kzalloc(bufflen, GFP_KERNEL);
 433         if (!buff)
 434                 return SCSI_DH_DEV_TEMP_BUSY;
 435
 436  retry:
 437         retval = submit_rtpg(sdev, buff, bufflen, &sense_hdr, pg->flags);
 438
 439         if (retval) {
 440                 if (!scsi_sense_valid(&sense_hdr)) {
 441                         sdev_printk(KERN_INFO, sdev,
 442                                     "%s: rtpg failed, result %d\n",
 443                                     ALUA_DH_NAME, retval);
 444                         kfree(buff);
 445                         if (driver_byte(retval) == DRIVER_ERROR)
 446                                 return SCSI_DH_DEV_TEMP_BUSY;
 447                         return SCSI_DH_IO;
 448                 }
 449
 450                 /*
 451                  * submit_rtpg() has failed on existing arrays
 452                  * when requesting extended header info, and
 453                  * the array doesn't support extended headers,
 454                  * even though it shouldn't according to T10.
 455                  * The retry without rtpg_ext_hdr_req set
 456                  * handles this.
 457                  */
 458                 if (!(pg->flags & ALUA_RTPG_EXT_HDR_UNSUPP) &&
 459                     sense_hdr.sense_key == ILLEGAL_REQUEST &&
 460                     sense_hdr.asc == 0x24 && sense_hdr.ascq == 0) {
 461                         pg->flags |= ALUA_RTPG_EXT_HDR_UNSUPP;
 462                         goto retry;
 463                 }
 464                 /*
 465                  * Retry on ALUA state transition or if any
 466                  * UNIT ATTENTION occurred.
 467                  */
 468                 if (sense_hdr.sense_key == NOT_READY &&
 469                     sense_hdr.asc == 0x04 && sense_hdr.ascq == 0x0a)
 470                         err = SCSI_DH_RETRY;
 471                 else if (sense_hdr.sense_key == UNIT_ATTENTION)
 472                         err = SCSI_DH_RETRY;
 473                 if (err == SCSI_DH_RETRY && time_before(jiffies, expiry)) {
 474                         sdev_printk(KERN_ERR, sdev, "%s: rtpg retry\n",
 475                                     ALUA_DH_NAME);
 476                         scsi_print_sense_hdr(sdev, ALUA_DH_NAME, &sense_hdr);
 477                         goto retry;
 478                 }
 479                 sdev_printk(KERN_ERR, sdev, "%s: rtpg failed\n",
 480                             ALUA_DH_NAME);
 481                 scsi_print_sense_hdr(sdev, ALUA_DH_NAME, &sense_hdr);
 482                 kfree(buff);
 483                 return SCSI_DH_IO;
 484         }
 485
 486         len = get_unaligned_be32(&buff[0]) + 4;
 487
 488         if (len > bufflen) {
 489                 /* Resubmit with the correct length */
 490                 kfree(buff);
 491                 bufflen = len;
 492                 buff = kmalloc(bufflen, GFP_KERNEL);
 493                 if (!buff) {
 494                         sdev_printk(KERN_WARNING, sdev,
 495                                     "%s: kmalloc buffer failed\n",__func__);
 496                         /* Temporary failure, bypass */
 497                         return SCSI_DH_DEV_TEMP_BUSY;
 498                 }
 499                 goto retry;
 500         }
 501
 502         orig_transition_tmo = pg->transition_tmo;
 503         if ((buff[4] & RTPG_FMT_MASK) == RTPG_FMT_EXT_HDR && buff[5] != 0)
 504                 pg->transition_tmo = buff[5];
 505         else
 506                 pg->transition_tmo = ALUA_FAILOVER_TIMEOUT;
 507
 508         if (orig_transition_tmo != pg->transition_tmo) {
 509                 sdev_printk(KERN_INFO, sdev,
 510                             "%s: transition timeout set to %d seconds\n",
 511                             ALUA_DH_NAME, pg->transition_tmo);
 512                 expiry = jiffies + pg->transition_tmo * HZ;
 513         }
 514
 515         if ((buff[4] & RTPG_FMT_MASK) == RTPG_FMT_EXT_HDR)
 516                 tpg_desc_tbl_off = 8;
 517         else
 518                 tpg_desc_tbl_off = 4;
 519
 520         for (k = tpg_desc_tbl_off, ucp = buff + tpg_desc_tbl_off;
 521              k < len;
 522              k += off, ucp += off) {
 523
 524                 if (pg->group_id == get_unaligned_be16(&ucp[2])) {
 525                         pg->state = ucp[0] & 0x0f;
 526                         pg->pref = ucp[0] >> 7;
 527                         valid_states = ucp[1];
 528                 }
 529                 off = 8 + (ucp[7] * 4);
 530         }
 531
 532         sdev_printk(KERN_INFO, sdev,
 533                     "%s: port group %02x state %c %s supports %c%c%c%c%c%c%c\n",
 534                     ALUA_DH_NAME, pg->group_id, print_alua_state(pg->state),
 535                     pg->pref ? "preferred" : "non-preferred",
 536                     valid_states&TPGS_SUPPORT_TRANSITION?'T':'t',
 537                     valid_states&TPGS_SUPPORT_OFFLINE?'O':'o',
 538                     valid_states&TPGS_SUPPORT_LBA_DEPENDENT?'L':'l',
 539                     valid_states&TPGS_SUPPORT_UNAVAILABLE?'U':'u',
 540                     valid_states&TPGS_SUPPORT_STANDBY?'S':'s',
 541                     valid_states&TPGS_SUPPORT_NONOPTIMIZED?'N':'n',
 542                     valid_states&TPGS_SUPPORT_OPTIMIZED?'A':'a');
 543
 544         switch (pg->state) {
 545         case TPGS_STATE_TRANSITIONING:
 546                 if (time_before(jiffies, expiry)) {
 547                         /* State transition, retry */
 548                         interval += 2000;
 549                         msleep(interval);
 550                         goto retry;
 551                 }
 552                 /* Transitioning time exceeded, set port to standby */
 553                 err = SCSI_DH_RETRY;
 554                 pg->state = TPGS_STATE_STANDBY;
 555                 break;
 556         case TPGS_STATE_OFFLINE:
 557                 /* Path unusable */
 558                 err = SCSI_DH_DEV_OFFLINED;
 559                 break;
 560         default:
 561                 /* Useable path if active */
 562                 err = SCSI_DH_OK;
 563                 break;
 564         }
 565         kfree(buff);
 566         return err;
 567 }
 568
 569 /*
 570  * alua_stpg - Issue a SET TARGET PORT GROUP command
 571  *
 572  * Issue a SET TARGET PORT GROUP command and evaluate the
 573  * response. Returns SCSI_DH_RETRY per default to trigger
 574  * a re-evaluation of the target group state or SCSI_DH_OK
 575  * if no further action needs to be taken.
 576  */
 577 static unsigned alua_stpg(struct scsi_device *sdev, struct alua_port_group *pg)
 578 {
 579         int retval;
 580         struct scsi_sense_hdr sense_hdr;
 581
 582         if (!(pg->tpgs & TPGS_MODE_EXPLICIT)) {
 583                 /* Only implicit ALUA supported, retry */
 584                 return SCSI_DH_RETRY;
 585         }
 586         switch (pg->state) {
 587         case TPGS_STATE_OPTIMIZED:
 588                 return SCSI_DH_OK;
 589         case TPGS_STATE_NONOPTIMIZED:
 590                 if ((pg->flags & ALUA_OPTIMIZE_STPG) &&
 591                     !pg->pref &&
 592                     (pg->tpgs & TPGS_MODE_IMPLICIT))
 593                         return SCSI_DH_OK;
 594                 break;
 595         case TPGS_STATE_STANDBY:
 596         case TPGS_STATE_UNAVAILABLE:
 597                 break;
 598         case TPGS_STATE_OFFLINE:
 599                 return SCSI_DH_IO;
 600         case TPGS_STATE_TRANSITIONING:
 601                 break;
 602         default:
 603                 sdev_printk(KERN_INFO, sdev,
 604                             "%s: stpg failed, unhandled TPGS state %d",
 605                             ALUA_DH_NAME, pg->state);
 606                 return SCSI_DH_NOSYS;
 607         }
 608         retval = submit_stpg(sdev, pg->group_id, &sense_hdr);
 609
 610         if (retval) {
 611                 if (!scsi_sense_valid(&sense_hdr)) {
 612                         sdev_printk(KERN_INFO, sdev,
 613                                     "%s: stpg failed, result %d",
 614                                     ALUA_DH_NAME, retval);
 615                         if (driver_byte(retval) == DRIVER_ERROR)
 616                                 return SCSI_DH_DEV_TEMP_BUSY;
 617                 } else {
 618                         sdev_printk(KERN_INFO, sdev, "%s: stpg failed\n",
 619                                     ALUA_DH_NAME);
 620                         scsi_print_sense_hdr(sdev, ALUA_DH_NAME, &sense_hdr);
 621                 }
 622         }
 623         /* Retry RTPG */
 624         return SCSI_DH_RETRY;
 625 }
 626
 627 /*
 628  * alua_initialize - Initialize ALUA state
 629  * @sdev: the device to be initialized
 630  *
 631  * For the prep_fn to work correctly we have
 632  * to initialize the ALUA state for the device.
 633  */
 634 static int alua_initialize(struct scsi_device *sdev, struct alua_dh_data *h)
 635 {
 636         int err = SCSI_DH_DEV_UNSUPP, tpgs;
 637
 638         tpgs = alua_check_tpgs(sdev);
 639         if (tpgs != TPGS_MODE_NONE)
 640                 err = alua_check_vpd(sdev, h, tpgs);
 641
 642         return err;
 643 }
 644 /*
 645  * alua_set_params - set/unset the optimize flag
 646  * @sdev: device on the path to be activated
 647  * params - parameters in the following format
 648  *      "no_of_params\0param1\0param2\0param3\0...\0"
 649  * For example, to set the flag pass the following parameters
 650  * from multipath.conf
 651  *     hardware_handler        "2 alua 1"
 652  */
 653 static int alua_set_params(struct scsi_device *sdev, const char *params)
 654 {
 655         struct alua_dh_data *h = sdev->handler_data;
 656         struct alua_port_group *pg = NULL;
 657         unsigned int optimize = 0, argc;
 658         const char *p = params;
 659         int result = SCSI_DH_OK;
 660
 661         if ((sscanf(params, "%u", &argc) != 1) || (argc != 1))
 662                 return -EINVAL;
 663
 664         while (*p++)
 665                 ;
 666         if ((sscanf(p, "%u", &optimize) != 1) || (optimize > 1))
 667                 return -EINVAL;
 668
 669         pg = h->pg;
 670         if (!pg)
 671                 return -ENXIO;
 672
 673         if (optimize)
 674                 pg->flags |= ALUA_OPTIMIZE_STPG;
 675         else
 676                 pg->flags &= ~ALUA_OPTIMIZE_STPG;
 677
 678         return result;
 679 }
 680
 681 static uint optimize_stpg;
 682 module_param(optimize_stpg, uint, S_IRUGO|S_IWUSR);
 683 MODULE_PARM_DESC(optimize_stpg, "Allow use of a non-optimized path, rather than sending a STPG, when implicit TPGS is supported (0=No,1=Yes). Default is 0.");
 684
 685 /*
 686  * alua_activate - activate a path
 687  * @sdev: device on the path to be activated
 688  *
 689  * We're currently switching the port group to be activated only and
 690  * let the array figure out the rest.
 691  * There may be other arrays which require us to switch all port groups
 692  * based on a certain policy. But until we actually encounter them it
 693  * should be okay.
 694  */
 695 static int alua_activate(struct scsi_device *sdev,
 696                         activate_complete fn, void *data)
 697 {
 698         struct alua_dh_data *h = sdev->handler_data;
 699         int err = SCSI_DH_OK;
 700
 701         if (!h->pg)
 702                 goto out;
 703
 704         kref_get(&h->pg->kref);
 705
 706         if (optimize_stpg)
 707                 h->pg->flags |= ALUA_OPTIMIZE_STPG;
 708
 709         err = alua_rtpg(sdev, h->pg);
 710         if (err != SCSI_DH_OK) {
 711                 kref_put(&h->pg->kref, release_port_group);
 712                 goto out;
 713         }
 714         err = alua_stpg(sdev, h->pg);
 715         if (err == SCSI_DH_RETRY)
 716                 err = alua_rtpg(sdev, h->pg);
 717         kref_put(&h->pg->kref, release_port_group);
 718 out:
 719         if (fn)
 720                 fn(data, err);
 721         return 0;
 722 }
 723
 724 /*
 725  * alua_prep_fn - request callback
 726  *
 727  * Fail I/O to all paths not in state
 728  * active/optimized or active/non-optimized.
 729  */
 730 static int alua_prep_fn(struct scsi_device *sdev, struct request *req)
 731 {
 732         struct alua_dh_data *h = sdev->handler_data;
 733         int state;
 734         int ret = BLKPREP_OK;
 735
 736         if (!h->pg)
 737                 return ret;
 738         kref_get(&h->pg->kref);
 739         state = h->pg->state;
 740         kref_put(&h->pg->kref, release_port_group);
 741         if (state == TPGS_STATE_TRANSITIONING)
 742                 ret = BLKPREP_DEFER;
 743         else if (state != TPGS_STATE_OPTIMIZED &&
 744                  state != TPGS_STATE_NONOPTIMIZED &&
 745                  state != TPGS_STATE_LBA_DEPENDENT) {
 746                 ret = BLKPREP_KILL;
 747                 req->cmd_flags |= REQ_QUIET;
 748         }
 749         return ret;
 750
 751 }
 752
 753 /*
 754  * alua_bus_attach - Attach device handler
 755  * @sdev: device to be attached to
 756  */
 757 static int alua_bus_attach(struct scsi_device *sdev)
 758 {
 759         struct alua_dh_data *h;
 760         int err, ret = -EINVAL;
 761
 762         h = kzalloc(sizeof(*h) , GFP_KERNEL);
 763         if (!h)
 764                 return -ENOMEM;
 765         h->pg = NULL;
 766         h->rel_port = -1;
 767         h->sdev = sdev;
 768
 769         err = alua_initialize(sdev, h);
 770         if (err == SCSI_DH_NOMEM)
 771                 ret = -ENOMEM;
 772         if (err != SCSI_DH_OK && err != SCSI_DH_DEV_OFFLINED)
 773                 goto failed;
 774
 775         sdev->handler_data = h;
 776         return 0;
 777 failed:
 778         kfree(h);
 779         return ret;
 780 }
 781
 782 /*
 783  * alua_bus_detach - Detach device handler
 784  * @sdev: device to be detached from
 785  */
 786 static void alua_bus_detach(struct scsi_device *sdev)
 787 {
 788         struct alua_dh_data *h = sdev->handler_data;
 789
 790         if (h->pg) {
 791                 kref_put(&h->pg->kref, release_port_group);
 792                 h->pg = NULL;
 793         }
 794         sdev->handler_data = NULL;
 795         kfree(h);
 796 }
 797
 798 static struct scsi_device_handler alua_dh = {
 799         .name = ALUA_DH_NAME,
 800         .module = THIS_MODULE,
 801         .attach = alua_bus_attach,
 802         .detach = alua_bus_detach,
 803         .prep_fn = alua_prep_fn,
 804         .check_sense = alua_check_sense,
 805         .activate = alua_activate,
 806         .set_params = alua_set_params,
 807 };
 808
 809 static int __init alua_init(void)
 810 {
 811         int r;
 812
 813         r = scsi_register_device_handler(&alua_dh);
 814         if (r != 0)
 815                 printk(KERN_ERR "%s: Failed to register scsi device handler",
 816                         ALUA_DH_NAME);
 817         return r;
 818 }
 819
 820 static void __exit alua_exit(void)
 821 {
 822         scsi_unregister_device_handler(&alua_dh);
 823 }
 824
 825 module_init(alua_init);
 826 module_exit(alua_exit);
 827
 828 MODULE_DESCRIPTION("DM Multipath ALUA support");
 829 MODULE_AUTHOR("Hannes Reinecke <hare@suse.de>");
 830 MODULE_LICENSE("GPL");
 831 MODULE_VERSION(ALUA_DH_VER);