2 * Generic SCSI-3 ALUA SCSI Device Handler
4 * Copyright (C) 2007-2010 Hannes Reinecke, SUSE Linux Products GmbH.
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.
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.
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.
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_proto.h>
28 #include <scsi/scsi_dbg.h>
29 #include <scsi/scsi_eh.h>
30 #include <scsi/scsi_dh.h>
32 #define ALUA_DH_NAME "alua"
33 #define ALUA_DH_VER "2.0"
35 #define TPGS_SUPPORT_NONE 0x00
36 #define TPGS_SUPPORT_OPTIMIZED 0x01
37 #define TPGS_SUPPORT_NONOPTIMIZED 0x02
38 #define TPGS_SUPPORT_STANDBY 0x04
39 #define TPGS_SUPPORT_UNAVAILABLE 0x08
40 #define TPGS_SUPPORT_LBA_DEPENDENT 0x10
41 #define TPGS_SUPPORT_OFFLINE 0x40
42 #define TPGS_SUPPORT_TRANSITION 0x80
44 #define RTPG_FMT_MASK 0x70
45 #define RTPG_FMT_EXT_HDR 0x10
47 #define TPGS_MODE_UNINITIALIZED -1
48 #define TPGS_MODE_NONE 0x0
49 #define TPGS_MODE_IMPLICIT 0x1
50 #define TPGS_MODE_EXPLICIT 0x2
52 #define ALUA_RTPG_SIZE 128
53 #define ALUA_FAILOVER_TIMEOUT 60
54 #define ALUA_FAILOVER_RETRIES 5
55 #define ALUA_RTPG_DELAY_MSECS 5
57 /* device handler flags */
58 #define ALUA_OPTIMIZE_STPG 0x01
59 #define ALUA_RTPG_EXT_HDR_UNSUPP 0x02
60 #define ALUA_SYNC_STPG 0x04
61 /* State machine flags */
62 #define ALUA_PG_RUN_RTPG 0x10
63 #define ALUA_PG_RUN_STPG 0x20
64 #define ALUA_PG_RUNNING 0x40
66 static uint optimize_stpg;
67 module_param(optimize_stpg, uint, S_IRUGO|S_IWUSR);
68 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.");
70 static LIST_HEAD(port_group_list);
71 static DEFINE_SPINLOCK(port_group_lock);
72 static struct workqueue_struct *kaluad_wq;
73 static struct workqueue_struct *kaluad_sync_wq;
75 struct alua_port_group {
78 struct list_head node;
79 struct list_head dh_list;
80 unsigned char device_id_str[256];
86 unsigned flags; /* used for optimizing STPG */
87 unsigned char transition_tmo;
89 unsigned long interval;
90 struct delayed_work rtpg_work;
92 struct list_head rtpg_list;
93 struct scsi_device *rtpg_sdev;
97 struct list_head node;
98 struct alua_port_group *pg;
101 struct scsi_device *sdev;
103 struct mutex init_mutex;
106 struct alua_queue_data {
107 struct list_head entry;
108 activate_complete callback_fn;
112 #define ALUA_POLICY_SWITCH_CURRENT 0
113 #define ALUA_POLICY_SWITCH_ALL 1
115 static void alua_rtpg_work(struct work_struct *work);
116 static void alua_rtpg_queue(struct alua_port_group *pg,
117 struct scsi_device *sdev,
118 struct alua_queue_data *qdata, bool force);
119 static void alua_check(struct scsi_device *sdev, bool force);
121 static void release_port_group(struct kref *kref)
123 struct alua_port_group *pg;
125 pg = container_of(kref, struct alua_port_group, kref);
127 flush_delayed_work(&pg->rtpg_work);
128 spin_lock(&port_group_lock);
130 spin_unlock(&port_group_lock);
135 * submit_rtpg - Issue a REPORT TARGET GROUP STATES command
136 * @sdev: sdev the command should be sent to
138 static int submit_rtpg(struct scsi_device *sdev, unsigned char *buff,
139 int bufflen, struct scsi_sense_hdr *sshdr, int flags)
141 u8 cdb[COMMAND_SIZE(MAINTENANCE_IN)];
142 int req_flags = REQ_FAILFAST_DEV | REQ_FAILFAST_TRANSPORT |
145 /* Prepare the command. */
146 memset(cdb, 0x0, COMMAND_SIZE(MAINTENANCE_IN));
147 cdb[0] = MAINTENANCE_IN;
148 if (!(flags & ALUA_RTPG_EXT_HDR_UNSUPP))
149 cdb[1] = MI_REPORT_TARGET_PGS | MI_EXT_HDR_PARAM_FMT;
151 cdb[1] = MI_REPORT_TARGET_PGS;
152 put_unaligned_be32(bufflen, &cdb[6]);
154 return scsi_execute_req_flags(sdev, cdb, DMA_FROM_DEVICE,
155 buff, bufflen, sshdr,
156 ALUA_FAILOVER_TIMEOUT * HZ,
157 ALUA_FAILOVER_RETRIES, NULL, req_flags);
161 * submit_stpg - Issue a SET TARGET PORT GROUP command
163 * Currently we're only setting the current target port group state
164 * to 'active/optimized' and let the array firmware figure out
165 * the states of the remaining groups.
167 static int submit_stpg(struct scsi_device *sdev, int group_id,
168 struct scsi_sense_hdr *sshdr)
170 u8 cdb[COMMAND_SIZE(MAINTENANCE_OUT)];
171 unsigned char stpg_data[8];
173 int req_flags = REQ_FAILFAST_DEV | REQ_FAILFAST_TRANSPORT |
176 /* Prepare the data buffer */
177 memset(stpg_data, 0, stpg_len);
178 stpg_data[4] = SCSI_ACCESS_STATE_OPTIMAL;
179 put_unaligned_be16(group_id, &stpg_data[6]);
181 /* Prepare the command. */
182 memset(cdb, 0x0, COMMAND_SIZE(MAINTENANCE_OUT));
183 cdb[0] = MAINTENANCE_OUT;
184 cdb[1] = MO_SET_TARGET_PGS;
185 put_unaligned_be32(stpg_len, &cdb[6]);
187 return scsi_execute_req_flags(sdev, cdb, DMA_TO_DEVICE,
189 sshdr, ALUA_FAILOVER_TIMEOUT * HZ,
190 ALUA_FAILOVER_RETRIES, NULL, req_flags);
193 struct alua_port_group *alua_find_get_pg(char *id_str, size_t id_size,
196 struct alua_port_group *pg;
198 list_for_each_entry(pg, &port_group_list, node) {
199 if (pg->group_id != group_id)
201 if (pg->device_id_len != id_size)
203 if (strncmp(pg->device_id_str, id_str, id_size))
205 if (!kref_get_unless_zero(&pg->kref))
214 * alua_alloc_pg - Allocate a new port_group structure
216 * @h: alua device_handler data
217 * @group_id: port group id
219 * Allocate a new port_group structure for a given
222 struct alua_port_group *alua_alloc_pg(struct scsi_device *sdev,
223 int group_id, int tpgs)
225 struct alua_port_group *pg, *tmp_pg;
227 pg = kzalloc(sizeof(struct alua_port_group), GFP_KERNEL);
229 return ERR_PTR(-ENOMEM);
231 pg->device_id_len = scsi_vpd_lun_id(sdev, pg->device_id_str,
232 sizeof(pg->device_id_str));
233 if (pg->device_id_len <= 0) {
235 * Internal error: TPGS supported but no device
236 * identifcation found. Disable ALUA support.
239 sdev_printk(KERN_INFO, sdev,
240 "%s: No device descriptors found\n",
242 return ERR_PTR(-ENXIO);
244 pg->group_id = group_id;
246 pg->state = SCSI_ACCESS_STATE_OPTIMAL;
248 pg->flags |= ALUA_OPTIMIZE_STPG;
249 kref_init(&pg->kref);
250 INIT_DELAYED_WORK(&pg->rtpg_work, alua_rtpg_work);
251 INIT_LIST_HEAD(&pg->rtpg_list);
252 INIT_LIST_HEAD(&pg->node);
253 INIT_LIST_HEAD(&pg->dh_list);
254 spin_lock_init(&pg->lock);
256 spin_lock(&port_group_lock);
257 tmp_pg = alua_find_get_pg(pg->device_id_str, pg->device_id_len,
260 spin_unlock(&port_group_lock);
265 list_add(&pg->node, &port_group_list);
266 spin_unlock(&port_group_lock);
272 * alua_check_tpgs - Evaluate TPGS setting
273 * @sdev: device to be checked
275 * Examine the TPGS setting of the sdev to find out if ALUA
278 static int alua_check_tpgs(struct scsi_device *sdev)
280 int tpgs = TPGS_MODE_NONE;
283 * ALUA support for non-disk devices is fraught with
284 * difficulties, so disable it for now.
286 if (sdev->type != TYPE_DISK) {
287 sdev_printk(KERN_INFO, sdev,
288 "%s: disable for non-disk devices\n",
293 tpgs = scsi_device_tpgs(sdev);
295 case TPGS_MODE_EXPLICIT|TPGS_MODE_IMPLICIT:
296 sdev_printk(KERN_INFO, sdev,
297 "%s: supports implicit and explicit TPGS\n",
300 case TPGS_MODE_EXPLICIT:
301 sdev_printk(KERN_INFO, sdev, "%s: supports explicit TPGS\n",
304 case TPGS_MODE_IMPLICIT:
305 sdev_printk(KERN_INFO, sdev, "%s: supports implicit TPGS\n",
309 sdev_printk(KERN_INFO, sdev, "%s: not supported\n",
313 sdev_printk(KERN_INFO, sdev,
314 "%s: unsupported TPGS setting %d\n",
316 tpgs = TPGS_MODE_NONE;
324 * alua_check_vpd - Evaluate INQUIRY vpd page 0x83
325 * @sdev: device to be checked
327 * Extract the relative target port and the target port group
328 * descriptor from the list of identificators.
330 static int alua_check_vpd(struct scsi_device *sdev, struct alua_dh_data *h,
333 int rel_port = -1, group_id;
334 struct alua_port_group *pg, *old_pg = NULL;
335 bool pg_updated = false;
338 group_id = scsi_vpd_tpg_id(sdev, &rel_port);
341 * Internal error; TPGS supported but required
342 * VPD identification descriptors not present.
343 * Disable ALUA support
345 sdev_printk(KERN_INFO, sdev,
346 "%s: No target port descriptors found\n",
348 return SCSI_DH_DEV_UNSUPP;
351 pg = alua_alloc_pg(sdev, group_id, tpgs);
353 if (PTR_ERR(pg) == -ENOMEM)
354 return SCSI_DH_NOMEM;
355 return SCSI_DH_DEV_UNSUPP;
357 sdev_printk(KERN_INFO, sdev,
358 "%s: device %s port group %x rel port %x\n",
359 ALUA_DH_NAME, pg->device_id_str, group_id, rel_port);
361 /* Check for existing port group references */
362 spin_lock(&h->pg_lock);
365 /* port group has changed. Update to new port group */
367 spin_lock_irqsave(&old_pg->lock, flags);
368 list_del_rcu(&h->node);
369 spin_unlock_irqrestore(&old_pg->lock, flags);
371 rcu_assign_pointer(h->pg, pg);
375 spin_lock_irqsave(&pg->lock, flags);
376 if (sdev->synchronous_alua)
377 pg->flags |= ALUA_SYNC_STPG;
379 list_add_rcu(&h->node, &pg->dh_list);
380 spin_unlock_irqrestore(&pg->lock, flags);
382 alua_rtpg_queue(h->pg, sdev, NULL, true);
383 spin_unlock(&h->pg_lock);
386 kref_put(&old_pg->kref, release_port_group);
391 static char print_alua_state(unsigned char state)
394 case SCSI_ACCESS_STATE_OPTIMAL:
396 case SCSI_ACCESS_STATE_ACTIVE:
398 case SCSI_ACCESS_STATE_STANDBY:
400 case SCSI_ACCESS_STATE_UNAVAILABLE:
402 case SCSI_ACCESS_STATE_LBA:
404 case SCSI_ACCESS_STATE_OFFLINE:
406 case SCSI_ACCESS_STATE_TRANSITIONING:
413 static int alua_check_sense(struct scsi_device *sdev,
414 struct scsi_sense_hdr *sense_hdr)
416 switch (sense_hdr->sense_key) {
418 if (sense_hdr->asc == 0x04 && sense_hdr->ascq == 0x0a) {
420 * LUN Not Accessible - ALUA state transition
422 alua_check(sdev, false);
427 if (sense_hdr->asc == 0x29 && sense_hdr->ascq == 0x00) {
429 * Power On, Reset, or Bus Device Reset.
430 * Might have obscured a state transition,
431 * so schedule a recheck.
433 alua_check(sdev, true);
434 return ADD_TO_MLQUEUE;
436 if (sense_hdr->asc == 0x29 && sense_hdr->ascq == 0x04)
438 * Device internal reset
440 return ADD_TO_MLQUEUE;
441 if (sense_hdr->asc == 0x2a && sense_hdr->ascq == 0x01)
443 * Mode Parameters Changed
445 return ADD_TO_MLQUEUE;
446 if (sense_hdr->asc == 0x2a && sense_hdr->ascq == 0x06) {
450 alua_check(sdev, true);
451 return ADD_TO_MLQUEUE;
453 if (sense_hdr->asc == 0x2a && sense_hdr->ascq == 0x07) {
455 * Implicit ALUA state transition failed
457 alua_check(sdev, true);
458 return ADD_TO_MLQUEUE;
460 if (sense_hdr->asc == 0x3f && sense_hdr->ascq == 0x03)
462 * Inquiry data has changed
464 return ADD_TO_MLQUEUE;
465 if (sense_hdr->asc == 0x3f && sense_hdr->ascq == 0x0e)
467 * REPORTED_LUNS_DATA_HAS_CHANGED is reported
468 * when switching controllers on targets like
469 * Intel Multi-Flex. We can just retry.
471 return ADD_TO_MLQUEUE;
475 return SCSI_RETURN_NOT_HANDLED;
479 * alua_tur - Send a TEST UNIT READY
480 * @sdev: device to which the TEST UNIT READY command should be send
482 * Send a TEST UNIT READY to @sdev to figure out the device state
483 * Returns SCSI_DH_RETRY if the sense code is NOT READY/ALUA TRANSITIONING,
484 * SCSI_DH_OK if no error occurred, and SCSI_DH_IO otherwise.
486 static int alua_tur(struct scsi_device *sdev)
488 struct scsi_sense_hdr sense_hdr;
491 retval = scsi_test_unit_ready(sdev, ALUA_FAILOVER_TIMEOUT * HZ,
492 ALUA_FAILOVER_RETRIES, &sense_hdr);
493 if (sense_hdr.sense_key == NOT_READY &&
494 sense_hdr.asc == 0x04 && sense_hdr.ascq == 0x0a)
495 return SCSI_DH_RETRY;
503 * alua_rtpg - Evaluate REPORT TARGET GROUP STATES
504 * @sdev: the device to be evaluated.
506 * Evaluate the Target Port Group State.
507 * Returns SCSI_DH_DEV_OFFLINED if the path is
508 * found to be unusable.
510 static int alua_rtpg(struct scsi_device *sdev, struct alua_port_group *pg)
512 struct scsi_sense_hdr sense_hdr;
513 struct alua_port_group *tmp_pg;
514 int len, k, off, valid_states = 0, bufflen = ALUA_RTPG_SIZE;
515 unsigned char *desc, *buff;
516 unsigned err, retval;
517 unsigned int tpg_desc_tbl_off;
518 unsigned char orig_transition_tmo;
522 unsigned long transition_tmo = ALUA_FAILOVER_TIMEOUT * HZ;
524 if (pg->transition_tmo)
525 transition_tmo = pg->transition_tmo * HZ;
527 pg->expiry = round_jiffies_up(jiffies + transition_tmo);
530 buff = kzalloc(bufflen, GFP_KERNEL);
532 return SCSI_DH_DEV_TEMP_BUSY;
536 retval = submit_rtpg(sdev, buff, bufflen, &sense_hdr, pg->flags);
539 if (!scsi_sense_valid(&sense_hdr)) {
540 sdev_printk(KERN_INFO, sdev,
541 "%s: rtpg failed, result %d\n",
542 ALUA_DH_NAME, retval);
544 if (driver_byte(retval) == DRIVER_ERROR)
545 return SCSI_DH_DEV_TEMP_BUSY;
550 * submit_rtpg() has failed on existing arrays
551 * when requesting extended header info, and
552 * the array doesn't support extended headers,
553 * even though it shouldn't according to T10.
554 * The retry without rtpg_ext_hdr_req set
557 if (!(pg->flags & ALUA_RTPG_EXT_HDR_UNSUPP) &&
558 sense_hdr.sense_key == ILLEGAL_REQUEST &&
559 sense_hdr.asc == 0x24 && sense_hdr.ascq == 0) {
560 pg->flags |= ALUA_RTPG_EXT_HDR_UNSUPP;
564 * Retry on ALUA state transition or if any
565 * UNIT ATTENTION occurred.
567 if (sense_hdr.sense_key == NOT_READY &&
568 sense_hdr.asc == 0x04 && sense_hdr.ascq == 0x0a)
570 else if (sense_hdr.sense_key == UNIT_ATTENTION)
572 if (err == SCSI_DH_RETRY &&
573 pg->expiry != 0 && time_before(jiffies, pg->expiry)) {
574 sdev_printk(KERN_ERR, sdev, "%s: rtpg retry\n",
576 scsi_print_sense_hdr(sdev, ALUA_DH_NAME, &sense_hdr);
579 sdev_printk(KERN_ERR, sdev, "%s: rtpg failed\n",
581 scsi_print_sense_hdr(sdev, ALUA_DH_NAME, &sense_hdr);
587 len = get_unaligned_be32(&buff[0]) + 4;
590 /* Resubmit with the correct length */
593 buff = kmalloc(bufflen, GFP_KERNEL);
595 sdev_printk(KERN_WARNING, sdev,
596 "%s: kmalloc buffer failed\n",__func__);
597 /* Temporary failure, bypass */
599 return SCSI_DH_DEV_TEMP_BUSY;
604 orig_transition_tmo = pg->transition_tmo;
605 if ((buff[4] & RTPG_FMT_MASK) == RTPG_FMT_EXT_HDR && buff[5] != 0)
606 pg->transition_tmo = buff[5];
608 pg->transition_tmo = ALUA_FAILOVER_TIMEOUT;
610 if (orig_transition_tmo != pg->transition_tmo) {
611 sdev_printk(KERN_INFO, sdev,
612 "%s: transition timeout set to %d seconds\n",
613 ALUA_DH_NAME, pg->transition_tmo);
614 pg->expiry = jiffies + pg->transition_tmo * HZ;
617 if ((buff[4] & RTPG_FMT_MASK) == RTPG_FMT_EXT_HDR)
618 tpg_desc_tbl_off = 8;
620 tpg_desc_tbl_off = 4;
622 for (k = tpg_desc_tbl_off, desc = buff + tpg_desc_tbl_off;
624 k += off, desc += off) {
625 u16 group_id = get_unaligned_be16(&desc[2]);
627 spin_lock_irqsave(&port_group_lock, flags);
628 tmp_pg = alua_find_get_pg(pg->device_id_str, pg->device_id_len,
630 spin_unlock_irqrestore(&port_group_lock, flags);
632 if (spin_trylock_irqsave(&tmp_pg->lock, flags)) {
633 if ((tmp_pg == pg) ||
634 !(tmp_pg->flags & ALUA_PG_RUNNING)) {
635 struct alua_dh_data *h;
637 tmp_pg->state = desc[0] & 0x0f;
638 tmp_pg->pref = desc[0] >> 7;
640 list_for_each_entry_rcu(h,
641 &tmp_pg->dh_list, node) {
642 /* h->sdev should always be valid */
644 h->sdev->access_state = desc[0];
649 valid_states = desc[1];
650 spin_unlock_irqrestore(&tmp_pg->lock, flags);
652 kref_put(&tmp_pg->kref, release_port_group);
654 off = 8 + (desc[7] * 4);
657 spin_lock_irqsave(&pg->lock, flags);
658 sdev_printk(KERN_INFO, sdev,
659 "%s: port group %02x state %c %s supports %c%c%c%c%c%c%c\n",
660 ALUA_DH_NAME, pg->group_id, print_alua_state(pg->state),
661 pg->pref ? "preferred" : "non-preferred",
662 valid_states&TPGS_SUPPORT_TRANSITION?'T':'t',
663 valid_states&TPGS_SUPPORT_OFFLINE?'O':'o',
664 valid_states&TPGS_SUPPORT_LBA_DEPENDENT?'L':'l',
665 valid_states&TPGS_SUPPORT_UNAVAILABLE?'U':'u',
666 valid_states&TPGS_SUPPORT_STANDBY?'S':'s',
667 valid_states&TPGS_SUPPORT_NONOPTIMIZED?'N':'n',
668 valid_states&TPGS_SUPPORT_OPTIMIZED?'A':'a');
671 case SCSI_ACCESS_STATE_TRANSITIONING:
672 if (time_before(jiffies, pg->expiry)) {
673 /* State transition, retry */
677 struct alua_dh_data *h;
679 /* Transitioning time exceeded, set port to standby */
681 pg->state = SCSI_ACCESS_STATE_STANDBY;
684 list_for_each_entry_rcu(h, &pg->dh_list, node) {
686 h->sdev->access_state =
687 (pg->state & SCSI_ACCESS_STATE_MASK);
689 h->sdev->access_state |=
690 SCSI_ACCESS_STATE_PREFERRED;
695 case SCSI_ACCESS_STATE_OFFLINE:
697 err = SCSI_DH_DEV_OFFLINED;
701 /* Useable path if active */
706 spin_unlock_irqrestore(&pg->lock, flags);
712 * alua_stpg - Issue a SET TARGET PORT GROUP command
714 * Issue a SET TARGET PORT GROUP command and evaluate the
715 * response. Returns SCSI_DH_RETRY per default to trigger
716 * a re-evaluation of the target group state or SCSI_DH_OK
717 * if no further action needs to be taken.
719 static unsigned alua_stpg(struct scsi_device *sdev, struct alua_port_group *pg)
722 struct scsi_sense_hdr sense_hdr;
724 if (!(pg->tpgs & TPGS_MODE_EXPLICIT)) {
725 /* Only implicit ALUA supported, retry */
726 return SCSI_DH_RETRY;
729 case SCSI_ACCESS_STATE_OPTIMAL:
731 case SCSI_ACCESS_STATE_ACTIVE:
732 if ((pg->flags & ALUA_OPTIMIZE_STPG) &&
734 (pg->tpgs & TPGS_MODE_IMPLICIT))
737 case SCSI_ACCESS_STATE_STANDBY:
738 case SCSI_ACCESS_STATE_UNAVAILABLE:
740 case SCSI_ACCESS_STATE_OFFLINE:
742 case SCSI_ACCESS_STATE_TRANSITIONING:
745 sdev_printk(KERN_INFO, sdev,
746 "%s: stpg failed, unhandled TPGS state %d",
747 ALUA_DH_NAME, pg->state);
748 return SCSI_DH_NOSYS;
750 retval = submit_stpg(sdev, pg->group_id, &sense_hdr);
753 if (!scsi_sense_valid(&sense_hdr)) {
754 sdev_printk(KERN_INFO, sdev,
755 "%s: stpg failed, result %d",
756 ALUA_DH_NAME, retval);
757 if (driver_byte(retval) == DRIVER_ERROR)
758 return SCSI_DH_DEV_TEMP_BUSY;
760 sdev_printk(KERN_INFO, sdev, "%s: stpg failed\n",
762 scsi_print_sense_hdr(sdev, ALUA_DH_NAME, &sense_hdr);
766 return SCSI_DH_RETRY;
769 static void alua_rtpg_work(struct work_struct *work)
771 struct alua_port_group *pg =
772 container_of(work, struct alua_port_group, rtpg_work.work);
773 struct scsi_device *sdev;
774 LIST_HEAD(qdata_list);
775 int err = SCSI_DH_OK;
776 struct alua_queue_data *qdata, *tmp;
778 struct workqueue_struct *alua_wq = kaluad_wq;
780 spin_lock_irqsave(&pg->lock, flags);
781 sdev = pg->rtpg_sdev;
783 WARN_ON(pg->flags & ALUA_PG_RUN_RTPG);
784 WARN_ON(pg->flags & ALUA_PG_RUN_STPG);
785 spin_unlock_irqrestore(&pg->lock, flags);
788 if (pg->flags & ALUA_SYNC_STPG)
789 alua_wq = kaluad_sync_wq;
790 pg->flags |= ALUA_PG_RUNNING;
791 if (pg->flags & ALUA_PG_RUN_RTPG) {
792 int state = pg->state;
794 pg->flags &= ~ALUA_PG_RUN_RTPG;
795 spin_unlock_irqrestore(&pg->lock, flags);
796 if (state == SCSI_ACCESS_STATE_TRANSITIONING) {
797 if (alua_tur(sdev) == SCSI_DH_RETRY) {
798 spin_lock_irqsave(&pg->lock, flags);
799 pg->flags &= ~ALUA_PG_RUNNING;
800 pg->flags |= ALUA_PG_RUN_RTPG;
801 spin_unlock_irqrestore(&pg->lock, flags);
802 queue_delayed_work(alua_wq, &pg->rtpg_work,
806 /* Send RTPG on failure or if TUR indicates SUCCESS */
808 err = alua_rtpg(sdev, pg);
809 spin_lock_irqsave(&pg->lock, flags);
810 if (err == SCSI_DH_RETRY || pg->flags & ALUA_PG_RUN_RTPG) {
811 pg->flags &= ~ALUA_PG_RUNNING;
812 pg->flags |= ALUA_PG_RUN_RTPG;
813 spin_unlock_irqrestore(&pg->lock, flags);
814 queue_delayed_work(alua_wq, &pg->rtpg_work,
818 if (err != SCSI_DH_OK)
819 pg->flags &= ~ALUA_PG_RUN_STPG;
821 if (pg->flags & ALUA_PG_RUN_STPG) {
822 pg->flags &= ~ALUA_PG_RUN_STPG;
823 spin_unlock_irqrestore(&pg->lock, flags);
824 err = alua_stpg(sdev, pg);
825 spin_lock_irqsave(&pg->lock, flags);
826 if (err == SCSI_DH_RETRY || pg->flags & ALUA_PG_RUN_RTPG) {
827 pg->flags |= ALUA_PG_RUN_RTPG;
829 pg->flags &= ~ALUA_PG_RUNNING;
830 spin_unlock_irqrestore(&pg->lock, flags);
831 queue_delayed_work(alua_wq, &pg->rtpg_work,
837 list_splice_init(&pg->rtpg_list, &qdata_list);
838 pg->rtpg_sdev = NULL;
839 spin_unlock_irqrestore(&pg->lock, flags);
841 list_for_each_entry_safe(qdata, tmp, &qdata_list, entry) {
842 list_del(&qdata->entry);
843 if (qdata->callback_fn)
844 qdata->callback_fn(qdata->callback_data, err);
847 spin_lock_irqsave(&pg->lock, flags);
848 pg->flags &= ~ALUA_PG_RUNNING;
849 spin_unlock_irqrestore(&pg->lock, flags);
850 scsi_device_put(sdev);
851 kref_put(&pg->kref, release_port_group);
854 static void alua_rtpg_queue(struct alua_port_group *pg,
855 struct scsi_device *sdev,
856 struct alua_queue_data *qdata, bool force)
860 struct workqueue_struct *alua_wq = kaluad_wq;
865 spin_lock_irqsave(&pg->lock, flags);
867 list_add_tail(&qdata->entry, &pg->rtpg_list);
868 pg->flags |= ALUA_PG_RUN_STPG;
871 if (pg->rtpg_sdev == NULL) {
873 pg->flags |= ALUA_PG_RUN_RTPG;
875 pg->rtpg_sdev = sdev;
876 scsi_device_get(sdev);
878 } else if (!(pg->flags & ALUA_PG_RUN_RTPG) && force) {
879 pg->flags |= ALUA_PG_RUN_RTPG;
880 /* Do not queue if the worker is already running */
881 if (!(pg->flags & ALUA_PG_RUNNING)) {
887 if (pg->flags & ALUA_SYNC_STPG)
888 alua_wq = kaluad_sync_wq;
889 spin_unlock_irqrestore(&pg->lock, flags);
892 !queue_delayed_work(alua_wq, &pg->rtpg_work,
893 msecs_to_jiffies(ALUA_RTPG_DELAY_MSECS))) {
894 scsi_device_put(sdev);
895 kref_put(&pg->kref, release_port_group);
900 * alua_initialize - Initialize ALUA state
901 * @sdev: the device to be initialized
903 * For the prep_fn to work correctly we have
904 * to initialize the ALUA state for the device.
906 static int alua_initialize(struct scsi_device *sdev, struct alua_dh_data *h)
908 int err = SCSI_DH_DEV_UNSUPP, tpgs;
910 mutex_lock(&h->init_mutex);
911 tpgs = alua_check_tpgs(sdev);
912 if (tpgs != TPGS_MODE_NONE)
913 err = alua_check_vpd(sdev, h, tpgs);
915 mutex_unlock(&h->init_mutex);
919 * alua_set_params - set/unset the optimize flag
920 * @sdev: device on the path to be activated
921 * params - parameters in the following format
922 * "no_of_params\0param1\0param2\0param3\0...\0"
923 * For example, to set the flag pass the following parameters
924 * from multipath.conf
925 * hardware_handler "2 alua 1"
927 static int alua_set_params(struct scsi_device *sdev, const char *params)
929 struct alua_dh_data *h = sdev->handler_data;
930 struct alua_port_group __rcu *pg = NULL;
931 unsigned int optimize = 0, argc;
932 const char *p = params;
933 int result = SCSI_DH_OK;
936 if ((sscanf(params, "%u", &argc) != 1) || (argc != 1))
941 if ((sscanf(p, "%u", &optimize) != 1) || (optimize > 1))
945 pg = rcu_dereference(h->pg);
950 spin_lock_irqsave(&pg->lock, flags);
952 pg->flags |= ALUA_OPTIMIZE_STPG;
954 pg->flags &= ~ALUA_OPTIMIZE_STPG;
955 spin_unlock_irqrestore(&pg->lock, flags);
962 * alua_activate - activate a path
963 * @sdev: device on the path to be activated
965 * We're currently switching the port group to be activated only and
966 * let the array figure out the rest.
967 * There may be other arrays which require us to switch all port groups
968 * based on a certain policy. But until we actually encounter them it
971 static int alua_activate(struct scsi_device *sdev,
972 activate_complete fn, void *data)
974 struct alua_dh_data *h = sdev->handler_data;
975 int err = SCSI_DH_OK;
976 struct alua_queue_data *qdata;
977 struct alua_port_group __rcu *pg;
979 qdata = kzalloc(sizeof(*qdata), GFP_KERNEL);
981 err = SCSI_DH_RES_TEMP_UNAVAIL;
984 qdata->callback_fn = fn;
985 qdata->callback_data = data;
987 mutex_lock(&h->init_mutex);
989 pg = rcu_dereference(h->pg);
990 if (!pg || !kref_get_unless_zero(&pg->kref)) {
994 mutex_unlock(&h->init_mutex);
999 mutex_unlock(&h->init_mutex);
1001 alua_rtpg_queue(pg, sdev, qdata, true);
1002 kref_put(&pg->kref, release_port_group);
1010 * alua_check - check path status
1011 * @sdev: device on the path to be checked
1013 * Check the device status
1015 static void alua_check(struct scsi_device *sdev, bool force)
1017 struct alua_dh_data *h = sdev->handler_data;
1018 struct alua_port_group *pg;
1021 pg = rcu_dereference(h->pg);
1022 if (!pg || !kref_get_unless_zero(&pg->kref)) {
1028 alua_rtpg_queue(pg, sdev, NULL, force);
1029 kref_put(&pg->kref, release_port_group);
1033 * alua_prep_fn - request callback
1035 * Fail I/O to all paths not in state
1036 * active/optimized or active/non-optimized.
1038 static int alua_prep_fn(struct scsi_device *sdev, struct request *req)
1040 struct alua_dh_data *h = sdev->handler_data;
1041 struct alua_port_group __rcu *pg;
1042 unsigned char state = SCSI_ACCESS_STATE_OPTIMAL;
1043 int ret = BLKPREP_OK;
1046 pg = rcu_dereference(h->pg);
1050 if (state == SCSI_ACCESS_STATE_TRANSITIONING)
1051 ret = BLKPREP_DEFER;
1052 else if (state != SCSI_ACCESS_STATE_OPTIMAL &&
1053 state != SCSI_ACCESS_STATE_ACTIVE &&
1054 state != SCSI_ACCESS_STATE_LBA) {
1056 req->cmd_flags |= REQ_QUIET;
1062 static void alua_rescan(struct scsi_device *sdev)
1064 struct alua_dh_data *h = sdev->handler_data;
1066 alua_initialize(sdev, h);
1070 * alua_bus_attach - Attach device handler
1071 * @sdev: device to be attached to
1073 static int alua_bus_attach(struct scsi_device *sdev)
1075 struct alua_dh_data *h;
1076 int err, ret = -EINVAL;
1078 h = kzalloc(sizeof(*h) , GFP_KERNEL);
1081 spin_lock_init(&h->pg_lock);
1082 rcu_assign_pointer(h->pg, NULL);
1083 h->init_error = SCSI_DH_OK;
1085 INIT_LIST_HEAD(&h->node);
1087 mutex_init(&h->init_mutex);
1088 err = alua_initialize(sdev, h);
1089 if (err == SCSI_DH_NOMEM)
1091 if (err != SCSI_DH_OK && err != SCSI_DH_DEV_OFFLINED)
1094 sdev->handler_data = h;
1102 * alua_bus_detach - Detach device handler
1103 * @sdev: device to be detached from
1105 static void alua_bus_detach(struct scsi_device *sdev)
1107 struct alua_dh_data *h = sdev->handler_data;
1108 struct alua_port_group *pg;
1110 spin_lock(&h->pg_lock);
1112 rcu_assign_pointer(h->pg, NULL);
1114 spin_unlock(&h->pg_lock);
1116 spin_lock_irq(&pg->lock);
1117 list_del_rcu(&h->node);
1118 spin_unlock_irq(&pg->lock);
1119 kref_put(&pg->kref, release_port_group);
1121 sdev->handler_data = NULL;
1125 static struct scsi_device_handler alua_dh = {
1126 .name = ALUA_DH_NAME,
1127 .module = THIS_MODULE,
1128 .attach = alua_bus_attach,
1129 .detach = alua_bus_detach,
1130 .prep_fn = alua_prep_fn,
1131 .check_sense = alua_check_sense,
1132 .activate = alua_activate,
1133 .rescan = alua_rescan,
1134 .set_params = alua_set_params,
1137 static int __init alua_init(void)
1141 kaluad_wq = alloc_workqueue("kaluad", WQ_MEM_RECLAIM, 0);
1143 /* Temporary failure, bypass */
1144 return SCSI_DH_DEV_TEMP_BUSY;
1146 kaluad_sync_wq = create_workqueue("kaluad_sync");
1147 if (!kaluad_sync_wq) {
1148 destroy_workqueue(kaluad_wq);
1149 return SCSI_DH_DEV_TEMP_BUSY;
1151 r = scsi_register_device_handler(&alua_dh);
1153 printk(KERN_ERR "%s: Failed to register scsi device handler",
1155 destroy_workqueue(kaluad_sync_wq);
1156 destroy_workqueue(kaluad_wq);
1161 static void __exit alua_exit(void)
1163 scsi_unregister_device_handler(&alua_dh);
1164 destroy_workqueue(kaluad_sync_wq);
1165 destroy_workqueue(kaluad_wq);
1168 module_init(alua_init);
1169 module_exit(alua_exit);
1171 MODULE_DESCRIPTION("DM Multipath ALUA support");
1172 MODULE_AUTHOR("Hannes Reinecke <hare@suse.de>");
1173 MODULE_LICENSE("GPL");
1174 MODULE_VERSION(ALUA_DH_VER);