1 // SPDX-License-Identifier: GPL-2.0-or-later
2 /*
3  * Generic SCSI-3 ALUA SCSI Device Handler
4  *
5  * Copyright (C) 2007-2010 Hannes Reinecke, SUSE Linux Products GmbH.
6  * All rights reserved.
7  */
8 #include <linux/slab.h>
9 #include <linux/delay.h>
10 #include <linux/module.h>
11 #include <asm/unaligned.h>
12 #include <scsi/scsi.h>
13 #include <scsi/scsi_proto.h>
14 #include <scsi/scsi_dbg.h>
15 #include <scsi/scsi_eh.h>
16 #include <scsi/scsi_dh.h>
17 
18 #define ALUA_DH_NAME "alua"
19 #define ALUA_DH_VER "2.0"
20 
21 #define TPGS_SUPPORT_NONE		0x00
22 #define TPGS_SUPPORT_OPTIMIZED		0x01
23 #define TPGS_SUPPORT_NONOPTIMIZED	0x02
24 #define TPGS_SUPPORT_STANDBY		0x04
25 #define TPGS_SUPPORT_UNAVAILABLE	0x08
26 #define TPGS_SUPPORT_LBA_DEPENDENT	0x10
27 #define TPGS_SUPPORT_OFFLINE		0x40
28 #define TPGS_SUPPORT_TRANSITION		0x80
29 #define TPGS_SUPPORT_ALL		0xdf
30 
31 #define RTPG_FMT_MASK			0x70
32 #define RTPG_FMT_EXT_HDR		0x10
33 
34 #define TPGS_MODE_UNINITIALIZED		 -1
35 #define TPGS_MODE_NONE			0x0
36 #define TPGS_MODE_IMPLICIT		0x1
37 #define TPGS_MODE_EXPLICIT		0x2
38 
39 #define ALUA_RTPG_SIZE			128
40 #define ALUA_FAILOVER_TIMEOUT		60
41 #define ALUA_FAILOVER_RETRIES		5
42 #define ALUA_RTPG_DELAY_MSECS		5
43 #define ALUA_RTPG_RETRY_DELAY		2
44 
45 /* device handler flags */
46 #define ALUA_OPTIMIZE_STPG		0x01
47 #define ALUA_RTPG_EXT_HDR_UNSUPP	0x02
48 /* State machine flags */
49 #define ALUA_PG_RUN_RTPG		0x10
50 #define ALUA_PG_RUN_STPG		0x20
51 #define ALUA_PG_RUNNING			0x40
52 
53 static uint optimize_stpg;
54 module_param(optimize_stpg, uint, S_IRUGO|S_IWUSR);
55 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.");
56 
57 static LIST_HEAD(port_group_list);
58 static DEFINE_SPINLOCK(port_group_lock);
59 static struct workqueue_struct *kaluad_wq;
60 
61 struct alua_port_group {
62 	struct kref		kref;
63 	struct rcu_head		rcu;
64 	struct list_head	node;
65 	struct list_head	dh_list;
66 	unsigned char		device_id_str[256];
67 	int			device_id_len;
68 	int			group_id;
69 	int			tpgs;
70 	int			state;
71 	int			pref;
72 	int			valid_states;
73 	unsigned		flags; /* used for optimizing STPG */
74 	unsigned char		transition_tmo;
75 	unsigned long		expiry;
76 	unsigned long		interval;
77 	struct delayed_work	rtpg_work;
78 	spinlock_t		lock;
79 	struct list_head	rtpg_list;
80 	struct scsi_device	*rtpg_sdev;
81 };
82 
83 struct alua_dh_data {
84 	struct list_head	node;
85 	struct alua_port_group __rcu *pg;
86 	int			group_id;
87 	spinlock_t		pg_lock;
88 	struct scsi_device	*sdev;
89 	int			init_error;
90 	struct mutex		init_mutex;
91 	bool			disabled;
92 };
93 
94 struct alua_queue_data {
95 	struct list_head	entry;
96 	activate_complete	callback_fn;
97 	void			*callback_data;
98 };
99 
100 #define ALUA_POLICY_SWITCH_CURRENT	0
101 #define ALUA_POLICY_SWITCH_ALL		1
102 
103 static void alua_rtpg_work(struct work_struct *work);
104 static bool alua_rtpg_queue(struct alua_port_group *pg,
105 			    struct scsi_device *sdev,
106 			    struct alua_queue_data *qdata, bool force);
107 static void alua_check(struct scsi_device *sdev, bool force);
108 
109 static void release_port_group(struct kref *kref)
110 {
111 	struct alua_port_group *pg;
112 
113 	pg = container_of(kref, struct alua_port_group, kref);
114 	if (pg->rtpg_sdev)
115 		flush_delayed_work(&pg->rtpg_work);
116 	spin_lock(&port_group_lock);
117 	list_del(&pg->node);
118 	spin_unlock(&port_group_lock);
119 	kfree_rcu(pg, rcu);
120 }
121 
122 /*
123  * submit_rtpg - Issue a REPORT TARGET GROUP STATES command
124  * @sdev: sdev the command should be sent to
125  */
126 static int submit_rtpg(struct scsi_device *sdev, unsigned char *buff,
127 		       int bufflen, struct scsi_sense_hdr *sshdr, int flags)
128 {
129 	u8 cdb[MAX_COMMAND_SIZE];
130 	int req_flags = REQ_FAILFAST_DEV | REQ_FAILFAST_TRANSPORT |
131 		REQ_FAILFAST_DRIVER;
132 
133 	/* Prepare the command. */
134 	memset(cdb, 0x0, MAX_COMMAND_SIZE);
135 	cdb[0] = MAINTENANCE_IN;
136 	if (!(flags & ALUA_RTPG_EXT_HDR_UNSUPP))
137 		cdb[1] = MI_REPORT_TARGET_PGS | MI_EXT_HDR_PARAM_FMT;
138 	else
139 		cdb[1] = MI_REPORT_TARGET_PGS;
140 	put_unaligned_be32(bufflen, &cdb[6]);
141 
142 	return scsi_execute(sdev, cdb, DMA_FROM_DEVICE, buff, bufflen, NULL,
143 			sshdr, ALUA_FAILOVER_TIMEOUT * HZ,
144 			ALUA_FAILOVER_RETRIES, req_flags, 0, NULL);
145 }
146 
147 /*
148  * submit_stpg - Issue a SET TARGET PORT GROUP command
149  *
150  * Currently we're only setting the current target port group state
151  * to 'active/optimized' and let the array firmware figure out
152  * the states of the remaining groups.
153  */
154 static int submit_stpg(struct scsi_device *sdev, int group_id,
155 		       struct scsi_sense_hdr *sshdr)
156 {
157 	u8 cdb[MAX_COMMAND_SIZE];
158 	unsigned char stpg_data[8];
159 	int stpg_len = 8;
160 	int req_flags = REQ_FAILFAST_DEV | REQ_FAILFAST_TRANSPORT |
161 		REQ_FAILFAST_DRIVER;
162 
163 	/* Prepare the data buffer */
164 	memset(stpg_data, 0, stpg_len);
165 	stpg_data[4] = SCSI_ACCESS_STATE_OPTIMAL;
166 	put_unaligned_be16(group_id, &stpg_data[6]);
167 
168 	/* Prepare the command. */
169 	memset(cdb, 0x0, MAX_COMMAND_SIZE);
170 	cdb[0] = MAINTENANCE_OUT;
171 	cdb[1] = MO_SET_TARGET_PGS;
172 	put_unaligned_be32(stpg_len, &cdb[6]);
173 
174 	return scsi_execute(sdev, cdb, DMA_TO_DEVICE, stpg_data, stpg_len, NULL,
175 			sshdr, ALUA_FAILOVER_TIMEOUT * HZ,
176 			ALUA_FAILOVER_RETRIES, req_flags, 0, NULL);
177 }
178 
179 static struct alua_port_group *alua_find_get_pg(char *id_str, size_t id_size,
180 						int group_id)
181 {
182 	struct alua_port_group *pg;
183 
184 	if (!id_str || !id_size || !strlen(id_str))
185 		return NULL;
186 
187 	list_for_each_entry(pg, &port_group_list, node) {
188 		if (pg->group_id != group_id)
189 			continue;
190 		if (!pg->device_id_len || pg->device_id_len != id_size)
191 			continue;
192 		if (strncmp(pg->device_id_str, id_str, id_size))
193 			continue;
194 		if (!kref_get_unless_zero(&pg->kref))
195 			continue;
196 		return pg;
197 	}
198 
199 	return NULL;
200 }
201 
202 /*
203  * alua_alloc_pg - Allocate a new port_group structure
204  * @sdev: scsi device
205  * @group_id: port group id
206  * @tpgs: target port group settings
207  *
208  * Allocate a new port_group structure for a given
209  * device.
210  */
211 static struct alua_port_group *alua_alloc_pg(struct scsi_device *sdev,
212 					     int group_id, int tpgs)
213 {
214 	struct alua_port_group *pg, *tmp_pg;
215 
216 	pg = kzalloc(sizeof(struct alua_port_group), GFP_KERNEL);
217 	if (!pg)
218 		return ERR_PTR(-ENOMEM);
219 
220 	pg->device_id_len = scsi_vpd_lun_id(sdev, pg->device_id_str,
221 					    sizeof(pg->device_id_str));
222 	if (pg->device_id_len <= 0) {
223 		/*
224 		 * TPGS supported but no device identification found.
225 		 * Generate private device identification.
226 		 */
227 		sdev_printk(KERN_INFO, sdev,
228 			    "%s: No device descriptors found\n",
229 			    ALUA_DH_NAME);
230 		pg->device_id_str[0] = '\0';
231 		pg->device_id_len = 0;
232 	}
233 	pg->group_id = group_id;
234 	pg->tpgs = tpgs;
235 	pg->state = SCSI_ACCESS_STATE_OPTIMAL;
236 	pg->valid_states = TPGS_SUPPORT_ALL;
237 	if (optimize_stpg)
238 		pg->flags |= ALUA_OPTIMIZE_STPG;
239 	kref_init(&pg->kref);
240 	INIT_DELAYED_WORK(&pg->rtpg_work, alua_rtpg_work);
241 	INIT_LIST_HEAD(&pg->rtpg_list);
242 	INIT_LIST_HEAD(&pg->node);
243 	INIT_LIST_HEAD(&pg->dh_list);
244 	spin_lock_init(&pg->lock);
245 
246 	spin_lock(&port_group_lock);
247 	tmp_pg = alua_find_get_pg(pg->device_id_str, pg->device_id_len,
248 				  group_id);
249 	if (tmp_pg) {
250 		spin_unlock(&port_group_lock);
251 		kfree(pg);
252 		return tmp_pg;
253 	}
254 
255 	list_add(&pg->node, &port_group_list);
256 	spin_unlock(&port_group_lock);
257 
258 	return pg;
259 }
260 
261 /*
262  * alua_check_tpgs - Evaluate TPGS setting
263  * @sdev: device to be checked
264  *
265  * Examine the TPGS setting of the sdev to find out if ALUA
266  * is supported.
267  */
268 static int alua_check_tpgs(struct scsi_device *sdev)
269 {
270 	int tpgs = TPGS_MODE_NONE;
271 
272 	/*
273 	 * ALUA support for non-disk devices is fraught with
274 	 * difficulties, so disable it for now.
275 	 */
276 	if (sdev->type != TYPE_DISK) {
277 		sdev_printk(KERN_INFO, sdev,
278 			    "%s: disable for non-disk devices\n",
279 			    ALUA_DH_NAME);
280 		return tpgs;
281 	}
282 
283 	tpgs = scsi_device_tpgs(sdev);
284 	switch (tpgs) {
285 	case TPGS_MODE_EXPLICIT|TPGS_MODE_IMPLICIT:
286 		sdev_printk(KERN_INFO, sdev,
287 			    "%s: supports implicit and explicit TPGS\n",
288 			    ALUA_DH_NAME);
289 		break;
290 	case TPGS_MODE_EXPLICIT:
291 		sdev_printk(KERN_INFO, sdev, "%s: supports explicit TPGS\n",
292 			    ALUA_DH_NAME);
293 		break;
294 	case TPGS_MODE_IMPLICIT:
295 		sdev_printk(KERN_INFO, sdev, "%s: supports implicit TPGS\n",
296 			    ALUA_DH_NAME);
297 		break;
298 	case TPGS_MODE_NONE:
299 		sdev_printk(KERN_INFO, sdev, "%s: not supported\n",
300 			    ALUA_DH_NAME);
301 		break;
302 	default:
303 		sdev_printk(KERN_INFO, sdev,
304 			    "%s: unsupported TPGS setting %d\n",
305 			    ALUA_DH_NAME, tpgs);
306 		tpgs = TPGS_MODE_NONE;
307 		break;
308 	}
309 
310 	return tpgs;
311 }
312 
313 /*
314  * alua_check_vpd - Evaluate INQUIRY vpd page 0x83
315  * @sdev: device to be checked
316  *
317  * Extract the relative target port and the target port group
318  * descriptor from the list of identificators.
319  */
320 static int alua_check_vpd(struct scsi_device *sdev, struct alua_dh_data *h,
321 			  int tpgs)
322 {
323 	int rel_port = -1, group_id;
324 	struct alua_port_group *pg, *old_pg = NULL;
325 	bool pg_updated = false;
326 	unsigned long flags;
327 
328 	group_id = scsi_vpd_tpg_id(sdev, &rel_port);
329 	if (group_id < 0) {
330 		/*
331 		 * Internal error; TPGS supported but required
332 		 * VPD identification descriptors not present.
333 		 * Disable ALUA support
334 		 */
335 		sdev_printk(KERN_INFO, sdev,
336 			    "%s: No target port descriptors found\n",
337 			    ALUA_DH_NAME);
338 		return SCSI_DH_DEV_UNSUPP;
339 	}
340 
341 	pg = alua_alloc_pg(sdev, group_id, tpgs);
342 	if (IS_ERR(pg)) {
343 		if (PTR_ERR(pg) == -ENOMEM)
344 			return SCSI_DH_NOMEM;
345 		return SCSI_DH_DEV_UNSUPP;
346 	}
347 	if (pg->device_id_len)
348 		sdev_printk(KERN_INFO, sdev,
349 			    "%s: device %s port group %x rel port %x\n",
350 			    ALUA_DH_NAME, pg->device_id_str,
351 			    group_id, rel_port);
352 	else
353 		sdev_printk(KERN_INFO, sdev,
354 			    "%s: port group %x rel port %x\n",
355 			    ALUA_DH_NAME, group_id, rel_port);
356 
357 	/* Check for existing port group references */
358 	spin_lock(&h->pg_lock);
359 	old_pg = rcu_dereference_protected(h->pg, lockdep_is_held(&h->pg_lock));
360 	if (old_pg != pg) {
361 		/* port group has changed. Update to new port group */
362 		if (h->pg) {
363 			spin_lock_irqsave(&old_pg->lock, flags);
364 			list_del_rcu(&h->node);
365 			spin_unlock_irqrestore(&old_pg->lock, flags);
366 		}
367 		rcu_assign_pointer(h->pg, pg);
368 		pg_updated = true;
369 	}
370 
371 	spin_lock_irqsave(&pg->lock, flags);
372 	if (pg_updated)
373 		list_add_rcu(&h->node, &pg->dh_list);
374 	spin_unlock_irqrestore(&pg->lock, flags);
375 
376 	alua_rtpg_queue(rcu_dereference_protected(h->pg,
377 						  lockdep_is_held(&h->pg_lock)),
378 			sdev, NULL, true);
379 	spin_unlock(&h->pg_lock);
380 
381 	if (old_pg)
382 		kref_put(&old_pg->kref, release_port_group);
383 
384 	return SCSI_DH_OK;
385 }
386 
387 static char print_alua_state(unsigned char state)
388 {
389 	switch (state) {
390 	case SCSI_ACCESS_STATE_OPTIMAL:
391 		return 'A';
392 	case SCSI_ACCESS_STATE_ACTIVE:
393 		return 'N';
394 	case SCSI_ACCESS_STATE_STANDBY:
395 		return 'S';
396 	case SCSI_ACCESS_STATE_UNAVAILABLE:
397 		return 'U';
398 	case SCSI_ACCESS_STATE_LBA:
399 		return 'L';
400 	case SCSI_ACCESS_STATE_OFFLINE:
401 		return 'O';
402 	case SCSI_ACCESS_STATE_TRANSITIONING:
403 		return 'T';
404 	default:
405 		return 'X';
406 	}
407 }
408 
409 static enum scsi_disposition alua_check_sense(struct scsi_device *sdev,
410 					      struct scsi_sense_hdr *sense_hdr)
411 {
412 	struct alua_dh_data *h = sdev->handler_data;
413 	struct alua_port_group *pg;
414 
415 	switch (sense_hdr->sense_key) {
416 	case NOT_READY:
417 		if (sense_hdr->asc == 0x04 && sense_hdr->ascq == 0x0a) {
418 			/*
419 			 * LUN Not Accessible - ALUA state transition
420 			 */
421 			rcu_read_lock();
422 			pg = rcu_dereference(h->pg);
423 			if (pg)
424 				pg->state = SCSI_ACCESS_STATE_TRANSITIONING;
425 			rcu_read_unlock();
426 			alua_check(sdev, false);
427 			return NEEDS_RETRY;
428 		}
429 		break;
430 	case UNIT_ATTENTION:
431 		if (sense_hdr->asc == 0x29 && sense_hdr->ascq == 0x00) {
432 			/*
433 			 * Power On, Reset, or Bus Device Reset.
434 			 * Might have obscured a state transition,
435 			 * so schedule a recheck.
436 			 */
437 			alua_check(sdev, true);
438 			return ADD_TO_MLQUEUE;
439 		}
440 		if (sense_hdr->asc == 0x29 && sense_hdr->ascq == 0x04)
441 			/*
442 			 * Device internal reset
443 			 */
444 			return ADD_TO_MLQUEUE;
445 		if (sense_hdr->asc == 0x2a && sense_hdr->ascq == 0x01)
446 			/*
447 			 * Mode Parameters Changed
448 			 */
449 			return ADD_TO_MLQUEUE;
450 		if (sense_hdr->asc == 0x2a && sense_hdr->ascq == 0x06) {
451 			/*
452 			 * ALUA state changed
453 			 */
454 			alua_check(sdev, true);
455 			return ADD_TO_MLQUEUE;
456 		}
457 		if (sense_hdr->asc == 0x2a && sense_hdr->ascq == 0x07) {
458 			/*
459 			 * Implicit ALUA state transition failed
460 			 */
461 			alua_check(sdev, true);
462 			return ADD_TO_MLQUEUE;
463 		}
464 		if (sense_hdr->asc == 0x3f && sense_hdr->ascq == 0x03)
465 			/*
466 			 * Inquiry data has changed
467 			 */
468 			return ADD_TO_MLQUEUE;
469 		if (sense_hdr->asc == 0x3f && sense_hdr->ascq == 0x0e)
470 			/*
471 			 * REPORTED_LUNS_DATA_HAS_CHANGED is reported
472 			 * when switching controllers on targets like
473 			 * Intel Multi-Flex. We can just retry.
474 			 */
475 			return ADD_TO_MLQUEUE;
476 		break;
477 	}
478 
479 	return SCSI_RETURN_NOT_HANDLED;
480 }
481 
482 /*
483  * alua_tur - Send a TEST UNIT READY
484  * @sdev: device to which the TEST UNIT READY command should be send
485  *
486  * Send a TEST UNIT READY to @sdev to figure out the device state
487  * Returns SCSI_DH_RETRY if the sense code is NOT READY/ALUA TRANSITIONING,
488  * SCSI_DH_OK if no error occurred, and SCSI_DH_IO otherwise.
489  */
490 static int alua_tur(struct scsi_device *sdev)
491 {
492 	struct scsi_sense_hdr sense_hdr;
493 	int retval;
494 
495 	retval = scsi_test_unit_ready(sdev, ALUA_FAILOVER_TIMEOUT * HZ,
496 				      ALUA_FAILOVER_RETRIES, &sense_hdr);
497 	if (sense_hdr.sense_key == NOT_READY &&
498 	    sense_hdr.asc == 0x04 && sense_hdr.ascq == 0x0a)
499 		return SCSI_DH_RETRY;
500 	else if (retval)
501 		return SCSI_DH_IO;
502 	else
503 		return SCSI_DH_OK;
504 }
505 
506 /*
507  * alua_rtpg - Evaluate REPORT TARGET GROUP STATES
508  * @sdev: the device to be evaluated.
509  *
510  * Evaluate the Target Port Group State.
511  * Returns SCSI_DH_DEV_OFFLINED if the path is
512  * found to be unusable.
513  */
514 static int alua_rtpg(struct scsi_device *sdev, struct alua_port_group *pg)
515 {
516 	struct scsi_sense_hdr sense_hdr;
517 	struct alua_port_group *tmp_pg;
518 	int len, k, off, bufflen = ALUA_RTPG_SIZE;
519 	int group_id_old, state_old, pref_old, valid_states_old;
520 	unsigned char *desc, *buff;
521 	unsigned err;
522 	int retval;
523 	unsigned int tpg_desc_tbl_off;
524 	unsigned char orig_transition_tmo;
525 	unsigned long flags;
526 	bool transitioning_sense = false;
527 
528 	group_id_old = pg->group_id;
529 	state_old = pg->state;
530 	pref_old = pg->pref;
531 	valid_states_old = pg->valid_states;
532 
533 	if (!pg->expiry) {
534 		unsigned long transition_tmo = ALUA_FAILOVER_TIMEOUT * HZ;
535 
536 		if (pg->transition_tmo)
537 			transition_tmo = pg->transition_tmo * HZ;
538 
539 		pg->expiry = round_jiffies_up(jiffies + transition_tmo);
540 	}
541 
542 	buff = kzalloc(bufflen, GFP_KERNEL);
543 	if (!buff)
544 		return SCSI_DH_DEV_TEMP_BUSY;
545 
546  retry:
547 	err = 0;
548 	retval = submit_rtpg(sdev, buff, bufflen, &sense_hdr, pg->flags);
549 
550 	if (retval) {
551 		/*
552 		 * Some (broken) implementations have a habit of returning
553 		 * an error during things like firmware update etc.
554 		 * But if the target only supports active/optimized there's
555 		 * not much we can do; it's not that we can switch paths
556 		 * or anything.
557 		 * So ignore any errors to avoid spurious failures during
558 		 * path failover.
559 		 */
560 		if ((pg->valid_states & ~TPGS_SUPPORT_OPTIMIZED) == 0) {
561 			sdev_printk(KERN_INFO, sdev,
562 				    "%s: ignoring rtpg result %d\n",
563 				    ALUA_DH_NAME, retval);
564 			kfree(buff);
565 			return SCSI_DH_OK;
566 		}
567 		if (retval < 0 || !scsi_sense_valid(&sense_hdr)) {
568 			sdev_printk(KERN_INFO, sdev,
569 				    "%s: rtpg failed, result %d\n",
570 				    ALUA_DH_NAME, retval);
571 			kfree(buff);
572 			if (retval < 0)
573 				return SCSI_DH_DEV_TEMP_BUSY;
574 			if (host_byte(retval) == DID_NO_CONNECT)
575 				return SCSI_DH_RES_TEMP_UNAVAIL;
576 			return SCSI_DH_IO;
577 		}
578 
579 		/*
580 		 * submit_rtpg() has failed on existing arrays
581 		 * when requesting extended header info, and
582 		 * the array doesn't support extended headers,
583 		 * even though it shouldn't according to T10.
584 		 * The retry without rtpg_ext_hdr_req set
585 		 * handles this.
586 		 * Note:  some arrays return a sense key of ILLEGAL_REQUEST
587 		 * with ASC 00h if they don't support the extended header.
588 		 */
589 		if (!(pg->flags & ALUA_RTPG_EXT_HDR_UNSUPP) &&
590 		    sense_hdr.sense_key == ILLEGAL_REQUEST) {
591 			pg->flags |= ALUA_RTPG_EXT_HDR_UNSUPP;
592 			goto retry;
593 		}
594 		/*
595 		 * If the array returns with 'ALUA state transition'
596 		 * sense code here it cannot return RTPG data during
597 		 * transition. So set the state to 'transitioning' directly.
598 		 */
599 		if (sense_hdr.sense_key == NOT_READY &&
600 		    sense_hdr.asc == 0x04 && sense_hdr.ascq == 0x0a) {
601 			transitioning_sense = true;
602 			goto skip_rtpg;
603 		}
604 		/*
605 		 * Retry on any other UNIT ATTENTION occurred.
606 		 */
607 		if (sense_hdr.sense_key == UNIT_ATTENTION)
608 			err = SCSI_DH_RETRY;
609 		if (err == SCSI_DH_RETRY &&
610 		    pg->expiry != 0 && time_before(jiffies, pg->expiry)) {
611 			sdev_printk(KERN_ERR, sdev, "%s: rtpg retry\n",
612 				    ALUA_DH_NAME);
613 			scsi_print_sense_hdr(sdev, ALUA_DH_NAME, &sense_hdr);
614 			kfree(buff);
615 			return err;
616 		}
617 		sdev_printk(KERN_ERR, sdev, "%s: rtpg failed\n",
618 			    ALUA_DH_NAME);
619 		scsi_print_sense_hdr(sdev, ALUA_DH_NAME, &sense_hdr);
620 		kfree(buff);
621 		pg->expiry = 0;
622 		return SCSI_DH_IO;
623 	}
624 
625 	len = get_unaligned_be32(&buff[0]) + 4;
626 
627 	if (len > bufflen) {
628 		/* Resubmit with the correct length */
629 		kfree(buff);
630 		bufflen = len;
631 		buff = kmalloc(bufflen, GFP_KERNEL);
632 		if (!buff) {
633 			sdev_printk(KERN_WARNING, sdev,
634 				    "%s: kmalloc buffer failed\n",__func__);
635 			/* Temporary failure, bypass */
636 			pg->expiry = 0;
637 			return SCSI_DH_DEV_TEMP_BUSY;
638 		}
639 		goto retry;
640 	}
641 
642 	orig_transition_tmo = pg->transition_tmo;
643 	if ((buff[4] & RTPG_FMT_MASK) == RTPG_FMT_EXT_HDR && buff[5] != 0)
644 		pg->transition_tmo = buff[5];
645 	else
646 		pg->transition_tmo = ALUA_FAILOVER_TIMEOUT;
647 
648 	if (orig_transition_tmo != pg->transition_tmo) {
649 		sdev_printk(KERN_INFO, sdev,
650 			    "%s: transition timeout set to %d seconds\n",
651 			    ALUA_DH_NAME, pg->transition_tmo);
652 		pg->expiry = jiffies + pg->transition_tmo * HZ;
653 	}
654 
655 	if ((buff[4] & RTPG_FMT_MASK) == RTPG_FMT_EXT_HDR)
656 		tpg_desc_tbl_off = 8;
657 	else
658 		tpg_desc_tbl_off = 4;
659 
660 	for (k = tpg_desc_tbl_off, desc = buff + tpg_desc_tbl_off;
661 	     k < len;
662 	     k += off, desc += off) {
663 		u16 group_id = get_unaligned_be16(&desc[2]);
664 
665 		spin_lock_irqsave(&port_group_lock, flags);
666 		tmp_pg = alua_find_get_pg(pg->device_id_str, pg->device_id_len,
667 					  group_id);
668 		spin_unlock_irqrestore(&port_group_lock, flags);
669 		if (tmp_pg) {
670 			if (spin_trylock_irqsave(&tmp_pg->lock, flags)) {
671 				if ((tmp_pg == pg) ||
672 				    !(tmp_pg->flags & ALUA_PG_RUNNING)) {
673 					struct alua_dh_data *h;
674 
675 					tmp_pg->state = desc[0] & 0x0f;
676 					tmp_pg->pref = desc[0] >> 7;
677 					rcu_read_lock();
678 					list_for_each_entry_rcu(h,
679 						&tmp_pg->dh_list, node) {
680 						if (!h->sdev)
681 							continue;
682 						h->sdev->access_state = desc[0];
683 					}
684 					rcu_read_unlock();
685 				}
686 				if (tmp_pg == pg)
687 					tmp_pg->valid_states = desc[1];
688 				spin_unlock_irqrestore(&tmp_pg->lock, flags);
689 			}
690 			kref_put(&tmp_pg->kref, release_port_group);
691 		}
692 		off = 8 + (desc[7] * 4);
693 	}
694 
695  skip_rtpg:
696 	spin_lock_irqsave(&pg->lock, flags);
697 	if (transitioning_sense)
698 		pg->state = SCSI_ACCESS_STATE_TRANSITIONING;
699 
700 	if (group_id_old != pg->group_id || state_old != pg->state ||
701 		pref_old != pg->pref || valid_states_old != pg->valid_states)
702 		sdev_printk(KERN_INFO, sdev,
703 			"%s: port group %02x state %c %s supports %c%c%c%c%c%c%c\n",
704 			ALUA_DH_NAME, pg->group_id, print_alua_state(pg->state),
705 			pg->pref ? "preferred" : "non-preferred",
706 			pg->valid_states&TPGS_SUPPORT_TRANSITION?'T':'t',
707 			pg->valid_states&TPGS_SUPPORT_OFFLINE?'O':'o',
708 			pg->valid_states&TPGS_SUPPORT_LBA_DEPENDENT?'L':'l',
709 			pg->valid_states&TPGS_SUPPORT_UNAVAILABLE?'U':'u',
710 			pg->valid_states&TPGS_SUPPORT_STANDBY?'S':'s',
711 			pg->valid_states&TPGS_SUPPORT_NONOPTIMIZED?'N':'n',
712 			pg->valid_states&TPGS_SUPPORT_OPTIMIZED?'A':'a');
713 
714 	switch (pg->state) {
715 	case SCSI_ACCESS_STATE_TRANSITIONING:
716 		if (time_before(jiffies, pg->expiry)) {
717 			/* State transition, retry */
718 			pg->interval = ALUA_RTPG_RETRY_DELAY;
719 			err = SCSI_DH_RETRY;
720 		} else {
721 			struct alua_dh_data *h;
722 
723 			/* Transitioning time exceeded, set port to standby */
724 			err = SCSI_DH_IO;
725 			pg->state = SCSI_ACCESS_STATE_STANDBY;
726 			pg->expiry = 0;
727 			rcu_read_lock();
728 			list_for_each_entry_rcu(h, &pg->dh_list, node) {
729 				if (!h->sdev)
730 					continue;
731 				h->sdev->access_state =
732 					(pg->state & SCSI_ACCESS_STATE_MASK);
733 				if (pg->pref)
734 					h->sdev->access_state |=
735 						SCSI_ACCESS_STATE_PREFERRED;
736 			}
737 			rcu_read_unlock();
738 		}
739 		break;
740 	case SCSI_ACCESS_STATE_OFFLINE:
741 		/* Path unusable */
742 		err = SCSI_DH_DEV_OFFLINED;
743 		pg->expiry = 0;
744 		break;
745 	default:
746 		/* Useable path if active */
747 		err = SCSI_DH_OK;
748 		pg->expiry = 0;
749 		break;
750 	}
751 	spin_unlock_irqrestore(&pg->lock, flags);
752 	kfree(buff);
753 	return err;
754 }
755 
756 /*
757  * alua_stpg - Issue a SET TARGET PORT GROUP command
758  *
759  * Issue a SET TARGET PORT GROUP command and evaluate the
760  * response. Returns SCSI_DH_RETRY per default to trigger
761  * a re-evaluation of the target group state or SCSI_DH_OK
762  * if no further action needs to be taken.
763  */
764 static unsigned alua_stpg(struct scsi_device *sdev, struct alua_port_group *pg)
765 {
766 	int retval;
767 	struct scsi_sense_hdr sense_hdr;
768 
769 	if (!(pg->tpgs & TPGS_MODE_EXPLICIT)) {
770 		/* Only implicit ALUA supported, retry */
771 		return SCSI_DH_RETRY;
772 	}
773 	switch (pg->state) {
774 	case SCSI_ACCESS_STATE_OPTIMAL:
775 		return SCSI_DH_OK;
776 	case SCSI_ACCESS_STATE_ACTIVE:
777 		if ((pg->flags & ALUA_OPTIMIZE_STPG) &&
778 		    !pg->pref &&
779 		    (pg->tpgs & TPGS_MODE_IMPLICIT))
780 			return SCSI_DH_OK;
781 		break;
782 	case SCSI_ACCESS_STATE_STANDBY:
783 	case SCSI_ACCESS_STATE_UNAVAILABLE:
784 		break;
785 	case SCSI_ACCESS_STATE_OFFLINE:
786 		return SCSI_DH_IO;
787 	case SCSI_ACCESS_STATE_TRANSITIONING:
788 		break;
789 	default:
790 		sdev_printk(KERN_INFO, sdev,
791 			    "%s: stpg failed, unhandled TPGS state %d",
792 			    ALUA_DH_NAME, pg->state);
793 		return SCSI_DH_NOSYS;
794 	}
795 	retval = submit_stpg(sdev, pg->group_id, &sense_hdr);
796 
797 	if (retval) {
798 		if (retval < 0 || !scsi_sense_valid(&sense_hdr)) {
799 			sdev_printk(KERN_INFO, sdev,
800 				    "%s: stpg failed, result %d",
801 				    ALUA_DH_NAME, retval);
802 			if (retval < 0)
803 				return SCSI_DH_DEV_TEMP_BUSY;
804 		} else {
805 			sdev_printk(KERN_INFO, sdev, "%s: stpg failed\n",
806 				    ALUA_DH_NAME);
807 			scsi_print_sense_hdr(sdev, ALUA_DH_NAME, &sense_hdr);
808 		}
809 	}
810 	/* Retry RTPG */
811 	return SCSI_DH_RETRY;
812 }
813 
814 static bool alua_rtpg_select_sdev(struct alua_port_group *pg)
815 {
816 	struct alua_dh_data *h;
817 	struct scsi_device *sdev = NULL;
818 
819 	lockdep_assert_held(&pg->lock);
820 	if (WARN_ON(!pg->rtpg_sdev))
821 		return false;
822 
823 	/*
824 	 * RCU protection isn't necessary for dh_list here
825 	 * as we hold pg->lock, but for access to h->pg.
826 	 */
827 	rcu_read_lock();
828 	list_for_each_entry_rcu(h, &pg->dh_list, node) {
829 		if (!h->sdev)
830 			continue;
831 		if (h->sdev == pg->rtpg_sdev) {
832 			h->disabled = true;
833 			continue;
834 		}
835 		if (rcu_dereference(h->pg) == pg &&
836 		    !h->disabled &&
837 		    !scsi_device_get(h->sdev)) {
838 			sdev = h->sdev;
839 			break;
840 		}
841 	}
842 	rcu_read_unlock();
843 
844 	if (!sdev) {
845 		pr_warn("%s: no device found for rtpg\n",
846 			(pg->device_id_len ?
847 			 (char *)pg->device_id_str : "(nameless PG)"));
848 		return false;
849 	}
850 
851 	sdev_printk(KERN_INFO, sdev, "rtpg retry on different device\n");
852 
853 	scsi_device_put(pg->rtpg_sdev);
854 	pg->rtpg_sdev = sdev;
855 
856 	return true;
857 }
858 
859 static void alua_rtpg_work(struct work_struct *work)
860 {
861 	struct alua_port_group *pg =
862 		container_of(work, struct alua_port_group, rtpg_work.work);
863 	struct scsi_device *sdev;
864 	LIST_HEAD(qdata_list);
865 	int err = SCSI_DH_OK;
866 	struct alua_queue_data *qdata, *tmp;
867 	struct alua_dh_data *h;
868 	unsigned long flags;
869 
870 	spin_lock_irqsave(&pg->lock, flags);
871 	sdev = pg->rtpg_sdev;
872 	if (!sdev) {
873 		WARN_ON(pg->flags & ALUA_PG_RUN_RTPG);
874 		WARN_ON(pg->flags & ALUA_PG_RUN_STPG);
875 		spin_unlock_irqrestore(&pg->lock, flags);
876 		kref_put(&pg->kref, release_port_group);
877 		return;
878 	}
879 	pg->flags |= ALUA_PG_RUNNING;
880 	if (pg->flags & ALUA_PG_RUN_RTPG) {
881 		int state = pg->state;
882 
883 		pg->flags &= ~ALUA_PG_RUN_RTPG;
884 		spin_unlock_irqrestore(&pg->lock, flags);
885 		if (state == SCSI_ACCESS_STATE_TRANSITIONING) {
886 			if (alua_tur(sdev) == SCSI_DH_RETRY) {
887 				spin_lock_irqsave(&pg->lock, flags);
888 				pg->flags &= ~ALUA_PG_RUNNING;
889 				pg->flags |= ALUA_PG_RUN_RTPG;
890 				if (!pg->interval)
891 					pg->interval = ALUA_RTPG_RETRY_DELAY;
892 				spin_unlock_irqrestore(&pg->lock, flags);
893 				queue_delayed_work(kaluad_wq, &pg->rtpg_work,
894 						   pg->interval * HZ);
895 				return;
896 			}
897 			/* Send RTPG on failure or if TUR indicates SUCCESS */
898 		}
899 		err = alua_rtpg(sdev, pg);
900 		spin_lock_irqsave(&pg->lock, flags);
901 
902 		/* If RTPG failed on the current device, try using another */
903 		if (err == SCSI_DH_RES_TEMP_UNAVAIL &&
904 		    alua_rtpg_select_sdev(pg))
905 			err = SCSI_DH_IMM_RETRY;
906 
907 		if (err == SCSI_DH_RETRY || err == SCSI_DH_IMM_RETRY ||
908 		    pg->flags & ALUA_PG_RUN_RTPG) {
909 			pg->flags &= ~ALUA_PG_RUNNING;
910 			if (err == SCSI_DH_IMM_RETRY)
911 				pg->interval = 0;
912 			else if (!pg->interval && !(pg->flags & ALUA_PG_RUN_RTPG))
913 				pg->interval = ALUA_RTPG_RETRY_DELAY;
914 			pg->flags |= ALUA_PG_RUN_RTPG;
915 			spin_unlock_irqrestore(&pg->lock, flags);
916 			queue_delayed_work(kaluad_wq, &pg->rtpg_work,
917 					   pg->interval * HZ);
918 			return;
919 		}
920 		if (err != SCSI_DH_OK)
921 			pg->flags &= ~ALUA_PG_RUN_STPG;
922 	}
923 	if (pg->flags & ALUA_PG_RUN_STPG) {
924 		pg->flags &= ~ALUA_PG_RUN_STPG;
925 		spin_unlock_irqrestore(&pg->lock, flags);
926 		err = alua_stpg(sdev, pg);
927 		spin_lock_irqsave(&pg->lock, flags);
928 		if (err == SCSI_DH_RETRY || pg->flags & ALUA_PG_RUN_RTPG) {
929 			pg->flags |= ALUA_PG_RUN_RTPG;
930 			pg->interval = 0;
931 			pg->flags &= ~ALUA_PG_RUNNING;
932 			spin_unlock_irqrestore(&pg->lock, flags);
933 			queue_delayed_work(kaluad_wq, &pg->rtpg_work,
934 					   pg->interval * HZ);
935 			return;
936 		}
937 	}
938 
939 	list_splice_init(&pg->rtpg_list, &qdata_list);
940 	/*
941 	 * We went through an RTPG, for good or bad.
942 	 * Re-enable all devices for the next attempt.
943 	 */
944 	list_for_each_entry(h, &pg->dh_list, node)
945 		h->disabled = false;
946 	pg->rtpg_sdev = NULL;
947 	spin_unlock_irqrestore(&pg->lock, flags);
948 
949 	list_for_each_entry_safe(qdata, tmp, &qdata_list, entry) {
950 		list_del(&qdata->entry);
951 		if (qdata->callback_fn)
952 			qdata->callback_fn(qdata->callback_data, err);
953 		kfree(qdata);
954 	}
955 	spin_lock_irqsave(&pg->lock, flags);
956 	pg->flags &= ~ALUA_PG_RUNNING;
957 	spin_unlock_irqrestore(&pg->lock, flags);
958 	scsi_device_put(sdev);
959 	kref_put(&pg->kref, release_port_group);
960 }
961 
962 /**
963  * alua_rtpg_queue() - cause RTPG to be submitted asynchronously
964  * @pg: ALUA port group associated with @sdev.
965  * @sdev: SCSI device for which to submit an RTPG.
966  * @qdata: Information about the callback to invoke after the RTPG.
967  * @force: Whether or not to submit an RTPG if a work item that will submit an
968  *         RTPG already has been scheduled.
969  *
970  * Returns true if and only if alua_rtpg_work() will be called asynchronously.
971  * That function is responsible for calling @qdata->fn().
972  */
973 static bool alua_rtpg_queue(struct alua_port_group *pg,
974 			    struct scsi_device *sdev,
975 			    struct alua_queue_data *qdata, bool force)
976 {
977 	int start_queue = 0;
978 	unsigned long flags;
979 	if (WARN_ON_ONCE(!pg) || scsi_device_get(sdev))
980 		return false;
981 
982 	spin_lock_irqsave(&pg->lock, flags);
983 	if (qdata) {
984 		list_add_tail(&qdata->entry, &pg->rtpg_list);
985 		pg->flags |= ALUA_PG_RUN_STPG;
986 		force = true;
987 	}
988 	if (pg->rtpg_sdev == NULL) {
989 		pg->interval = 0;
990 		pg->flags |= ALUA_PG_RUN_RTPG;
991 		kref_get(&pg->kref);
992 		pg->rtpg_sdev = sdev;
993 		start_queue = 1;
994 	} else if (!(pg->flags & ALUA_PG_RUN_RTPG) && force) {
995 		pg->flags |= ALUA_PG_RUN_RTPG;
996 		/* Do not queue if the worker is already running */
997 		if (!(pg->flags & ALUA_PG_RUNNING)) {
998 			kref_get(&pg->kref);
999 			start_queue = 1;
1000 		}
1001 	}
1002 
1003 	spin_unlock_irqrestore(&pg->lock, flags);
1004 
1005 	if (start_queue) {
1006 		if (queue_delayed_work(kaluad_wq, &pg->rtpg_work,
1007 				msecs_to_jiffies(ALUA_RTPG_DELAY_MSECS)))
1008 			sdev = NULL;
1009 		else
1010 			kref_put(&pg->kref, release_port_group);
1011 	}
1012 	if (sdev)
1013 		scsi_device_put(sdev);
1014 
1015 	return true;
1016 }
1017 
1018 /*
1019  * alua_initialize - Initialize ALUA state
1020  * @sdev: the device to be initialized
1021  *
1022  * For the prep_fn to work correctly we have
1023  * to initialize the ALUA state for the device.
1024  */
1025 static int alua_initialize(struct scsi_device *sdev, struct alua_dh_data *h)
1026 {
1027 	int err = SCSI_DH_DEV_UNSUPP, tpgs;
1028 
1029 	mutex_lock(&h->init_mutex);
1030 	h->disabled = false;
1031 	tpgs = alua_check_tpgs(sdev);
1032 	if (tpgs != TPGS_MODE_NONE)
1033 		err = alua_check_vpd(sdev, h, tpgs);
1034 	h->init_error = err;
1035 	mutex_unlock(&h->init_mutex);
1036 	return err;
1037 }
1038 /*
1039  * alua_set_params - set/unset the optimize flag
1040  * @sdev: device on the path to be activated
1041  * params - parameters in the following format
1042  *      "no_of_params\0param1\0param2\0param3\0...\0"
1043  * For example, to set the flag pass the following parameters
1044  * from multipath.conf
1045  *     hardware_handler        "2 alua 1"
1046  */
1047 static int alua_set_params(struct scsi_device *sdev, const char *params)
1048 {
1049 	struct alua_dh_data *h = sdev->handler_data;
1050 	struct alua_port_group *pg = NULL;
1051 	unsigned int optimize = 0, argc;
1052 	const char *p = params;
1053 	int result = SCSI_DH_OK;
1054 	unsigned long flags;
1055 
1056 	if ((sscanf(params, "%u", &argc) != 1) || (argc != 1))
1057 		return -EINVAL;
1058 
1059 	while (*p++)
1060 		;
1061 	if ((sscanf(p, "%u", &optimize) != 1) || (optimize > 1))
1062 		return -EINVAL;
1063 
1064 	rcu_read_lock();
1065 	pg = rcu_dereference(h->pg);
1066 	if (!pg) {
1067 		rcu_read_unlock();
1068 		return -ENXIO;
1069 	}
1070 	spin_lock_irqsave(&pg->lock, flags);
1071 	if (optimize)
1072 		pg->flags |= ALUA_OPTIMIZE_STPG;
1073 	else
1074 		pg->flags &= ~ALUA_OPTIMIZE_STPG;
1075 	spin_unlock_irqrestore(&pg->lock, flags);
1076 	rcu_read_unlock();
1077 
1078 	return result;
1079 }
1080 
1081 /*
1082  * alua_activate - activate a path
1083  * @sdev: device on the path to be activated
1084  *
1085  * We're currently switching the port group to be activated only and
1086  * let the array figure out the rest.
1087  * There may be other arrays which require us to switch all port groups
1088  * based on a certain policy. But until we actually encounter them it
1089  * should be okay.
1090  */
1091 static int alua_activate(struct scsi_device *sdev,
1092 			activate_complete fn, void *data)
1093 {
1094 	struct alua_dh_data *h = sdev->handler_data;
1095 	int err = SCSI_DH_OK;
1096 	struct alua_queue_data *qdata;
1097 	struct alua_port_group *pg;
1098 
1099 	qdata = kzalloc(sizeof(*qdata), GFP_KERNEL);
1100 	if (!qdata) {
1101 		err = SCSI_DH_RES_TEMP_UNAVAIL;
1102 		goto out;
1103 	}
1104 	qdata->callback_fn = fn;
1105 	qdata->callback_data = data;
1106 
1107 	mutex_lock(&h->init_mutex);
1108 	rcu_read_lock();
1109 	pg = rcu_dereference(h->pg);
1110 	if (!pg || !kref_get_unless_zero(&pg->kref)) {
1111 		rcu_read_unlock();
1112 		kfree(qdata);
1113 		err = h->init_error;
1114 		mutex_unlock(&h->init_mutex);
1115 		goto out;
1116 	}
1117 	rcu_read_unlock();
1118 	mutex_unlock(&h->init_mutex);
1119 
1120 	if (alua_rtpg_queue(pg, sdev, qdata, true))
1121 		fn = NULL;
1122 	else
1123 		err = SCSI_DH_DEV_OFFLINED;
1124 	kref_put(&pg->kref, release_port_group);
1125 out:
1126 	if (fn)
1127 		fn(data, err);
1128 	return 0;
1129 }
1130 
1131 /*
1132  * alua_check - check path status
1133  * @sdev: device on the path to be checked
1134  *
1135  * Check the device status
1136  */
1137 static void alua_check(struct scsi_device *sdev, bool force)
1138 {
1139 	struct alua_dh_data *h = sdev->handler_data;
1140 	struct alua_port_group *pg;
1141 
1142 	rcu_read_lock();
1143 	pg = rcu_dereference(h->pg);
1144 	if (!pg || !kref_get_unless_zero(&pg->kref)) {
1145 		rcu_read_unlock();
1146 		return;
1147 	}
1148 	rcu_read_unlock();
1149 	alua_rtpg_queue(pg, sdev, NULL, force);
1150 	kref_put(&pg->kref, release_port_group);
1151 }
1152 
1153 /*
1154  * alua_prep_fn - request callback
1155  *
1156  * Fail I/O to all paths not in state
1157  * active/optimized or active/non-optimized.
1158  */
1159 static blk_status_t alua_prep_fn(struct scsi_device *sdev, struct request *req)
1160 {
1161 	struct alua_dh_data *h = sdev->handler_data;
1162 	struct alua_port_group *pg;
1163 	unsigned char state = SCSI_ACCESS_STATE_OPTIMAL;
1164 
1165 	rcu_read_lock();
1166 	pg = rcu_dereference(h->pg);
1167 	if (pg)
1168 		state = pg->state;
1169 	rcu_read_unlock();
1170 
1171 	switch (state) {
1172 	case SCSI_ACCESS_STATE_OPTIMAL:
1173 	case SCSI_ACCESS_STATE_ACTIVE:
1174 	case SCSI_ACCESS_STATE_LBA:
1175 		return BLK_STS_OK;
1176 	case SCSI_ACCESS_STATE_TRANSITIONING:
1177 		return BLK_STS_AGAIN;
1178 	default:
1179 		req->rq_flags |= RQF_QUIET;
1180 		return BLK_STS_IOERR;
1181 	}
1182 }
1183 
1184 static void alua_rescan(struct scsi_device *sdev)
1185 {
1186 	struct alua_dh_data *h = sdev->handler_data;
1187 
1188 	alua_initialize(sdev, h);
1189 }
1190 
1191 /*
1192  * alua_bus_attach - Attach device handler
1193  * @sdev: device to be attached to
1194  */
1195 static int alua_bus_attach(struct scsi_device *sdev)
1196 {
1197 	struct alua_dh_data *h;
1198 	int err;
1199 
1200 	h = kzalloc(sizeof(*h) , GFP_KERNEL);
1201 	if (!h)
1202 		return SCSI_DH_NOMEM;
1203 	spin_lock_init(&h->pg_lock);
1204 	rcu_assign_pointer(h->pg, NULL);
1205 	h->init_error = SCSI_DH_OK;
1206 	h->sdev = sdev;
1207 	INIT_LIST_HEAD(&h->node);
1208 
1209 	mutex_init(&h->init_mutex);
1210 	err = alua_initialize(sdev, h);
1211 	if (err != SCSI_DH_OK && err != SCSI_DH_DEV_OFFLINED)
1212 		goto failed;
1213 
1214 	sdev->handler_data = h;
1215 	return SCSI_DH_OK;
1216 failed:
1217 	kfree(h);
1218 	return err;
1219 }
1220 
1221 /*
1222  * alua_bus_detach - Detach device handler
1223  * @sdev: device to be detached from
1224  */
1225 static void alua_bus_detach(struct scsi_device *sdev)
1226 {
1227 	struct alua_dh_data *h = sdev->handler_data;
1228 	struct alua_port_group *pg;
1229 
1230 	spin_lock(&h->pg_lock);
1231 	pg = rcu_dereference_protected(h->pg, lockdep_is_held(&h->pg_lock));
1232 	rcu_assign_pointer(h->pg, NULL);
1233 	spin_unlock(&h->pg_lock);
1234 	if (pg) {
1235 		spin_lock_irq(&pg->lock);
1236 		list_del_rcu(&h->node);
1237 		spin_unlock_irq(&pg->lock);
1238 		kref_put(&pg->kref, release_port_group);
1239 	}
1240 	sdev->handler_data = NULL;
1241 	synchronize_rcu();
1242 	kfree(h);
1243 }
1244 
1245 static struct scsi_device_handler alua_dh = {
1246 	.name = ALUA_DH_NAME,
1247 	.module = THIS_MODULE,
1248 	.attach = alua_bus_attach,
1249 	.detach = alua_bus_detach,
1250 	.prep_fn = alua_prep_fn,
1251 	.check_sense = alua_check_sense,
1252 	.activate = alua_activate,
1253 	.rescan = alua_rescan,
1254 	.set_params = alua_set_params,
1255 };
1256 
1257 static int __init alua_init(void)
1258 {
1259 	int r;
1260 
1261 	kaluad_wq = alloc_workqueue("kaluad", WQ_MEM_RECLAIM, 0);
1262 	if (!kaluad_wq)
1263 		return -ENOMEM;
1264 
1265 	r = scsi_register_device_handler(&alua_dh);
1266 	if (r != 0) {
1267 		printk(KERN_ERR "%s: Failed to register scsi device handler",
1268 			ALUA_DH_NAME);
1269 		destroy_workqueue(kaluad_wq);
1270 	}
1271 	return r;
1272 }
1273 
1274 static void __exit alua_exit(void)
1275 {
1276 	scsi_unregister_device_handler(&alua_dh);
1277 	destroy_workqueue(kaluad_wq);
1278 }
1279 
1280 module_init(alua_init);
1281 module_exit(alua_exit);
1282 
1283 MODULE_DESCRIPTION("DM Multipath ALUA support");
1284 MODULE_AUTHOR("Hannes Reinecke <hare@suse.de>");
1285 MODULE_LICENSE("GPL");
1286 MODULE_VERSION(ALUA_DH_VER);
1287