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 	blk_opf_t 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 	blk_opf_t 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 	kref_get(&pg->kref);
358 
359 	/* Check for existing port group references */
360 	spin_lock(&h->pg_lock);
361 	old_pg = rcu_dereference_protected(h->pg, lockdep_is_held(&h->pg_lock));
362 	if (old_pg != pg) {
363 		/* port group has changed. Update to new port group */
364 		if (h->pg) {
365 			spin_lock_irqsave(&old_pg->lock, flags);
366 			list_del_rcu(&h->node);
367 			spin_unlock_irqrestore(&old_pg->lock, flags);
368 		}
369 		rcu_assign_pointer(h->pg, pg);
370 		pg_updated = true;
371 	}
372 
373 	spin_lock_irqsave(&pg->lock, flags);
374 	if (pg_updated)
375 		list_add_rcu(&h->node, &pg->dh_list);
376 	spin_unlock_irqrestore(&pg->lock, flags);
377 
378 	spin_unlock(&h->pg_lock);
379 
380 	alua_rtpg_queue(pg, sdev, NULL, true);
381 	kref_put(&pg->kref, release_port_group);
382 
383 	if (old_pg)
384 		kref_put(&old_pg->kref, release_port_group);
385 
386 	return SCSI_DH_OK;
387 }
388 
389 static char print_alua_state(unsigned char state)
390 {
391 	switch (state) {
392 	case SCSI_ACCESS_STATE_OPTIMAL:
393 		return 'A';
394 	case SCSI_ACCESS_STATE_ACTIVE:
395 		return 'N';
396 	case SCSI_ACCESS_STATE_STANDBY:
397 		return 'S';
398 	case SCSI_ACCESS_STATE_UNAVAILABLE:
399 		return 'U';
400 	case SCSI_ACCESS_STATE_LBA:
401 		return 'L';
402 	case SCSI_ACCESS_STATE_OFFLINE:
403 		return 'O';
404 	case SCSI_ACCESS_STATE_TRANSITIONING:
405 		return 'T';
406 	default:
407 		return 'X';
408 	}
409 }
410 
411 static enum scsi_disposition alua_check_sense(struct scsi_device *sdev,
412 					      struct scsi_sense_hdr *sense_hdr)
413 {
414 	struct alua_dh_data *h = sdev->handler_data;
415 	struct alua_port_group *pg;
416 
417 	switch (sense_hdr->sense_key) {
418 	case NOT_READY:
419 		if (sense_hdr->asc == 0x04 && sense_hdr->ascq == 0x0a) {
420 			/*
421 			 * LUN Not Accessible - ALUA state transition
422 			 */
423 			rcu_read_lock();
424 			pg = rcu_dereference(h->pg);
425 			if (pg)
426 				pg->state = SCSI_ACCESS_STATE_TRANSITIONING;
427 			rcu_read_unlock();
428 			alua_check(sdev, false);
429 			return NEEDS_RETRY;
430 		}
431 		break;
432 	case UNIT_ATTENTION:
433 		if (sense_hdr->asc == 0x29 && sense_hdr->ascq == 0x00) {
434 			/*
435 			 * Power On, Reset, or Bus Device Reset.
436 			 * Might have obscured a state transition,
437 			 * so schedule a recheck.
438 			 */
439 			alua_check(sdev, true);
440 			return ADD_TO_MLQUEUE;
441 		}
442 		if (sense_hdr->asc == 0x29 && sense_hdr->ascq == 0x04)
443 			/*
444 			 * Device internal reset
445 			 */
446 			return ADD_TO_MLQUEUE;
447 		if (sense_hdr->asc == 0x2a && sense_hdr->ascq == 0x01)
448 			/*
449 			 * Mode Parameters Changed
450 			 */
451 			return ADD_TO_MLQUEUE;
452 		if (sense_hdr->asc == 0x2a && sense_hdr->ascq == 0x06) {
453 			/*
454 			 * ALUA state changed
455 			 */
456 			alua_check(sdev, true);
457 			return ADD_TO_MLQUEUE;
458 		}
459 		if (sense_hdr->asc == 0x2a && sense_hdr->ascq == 0x07) {
460 			/*
461 			 * Implicit ALUA state transition failed
462 			 */
463 			alua_check(sdev, true);
464 			return ADD_TO_MLQUEUE;
465 		}
466 		if (sense_hdr->asc == 0x3f && sense_hdr->ascq == 0x03)
467 			/*
468 			 * Inquiry data has changed
469 			 */
470 			return ADD_TO_MLQUEUE;
471 		if (sense_hdr->asc == 0x3f && sense_hdr->ascq == 0x0e)
472 			/*
473 			 * REPORTED_LUNS_DATA_HAS_CHANGED is reported
474 			 * when switching controllers on targets like
475 			 * Intel Multi-Flex. We can just retry.
476 			 */
477 			return ADD_TO_MLQUEUE;
478 		break;
479 	}
480 
481 	return SCSI_RETURN_NOT_HANDLED;
482 }
483 
484 /*
485  * alua_tur - Send a TEST UNIT READY
486  * @sdev: device to which the TEST UNIT READY command should be send
487  *
488  * Send a TEST UNIT READY to @sdev to figure out the device state
489  * Returns SCSI_DH_RETRY if the sense code is NOT READY/ALUA TRANSITIONING,
490  * SCSI_DH_OK if no error occurred, and SCSI_DH_IO otherwise.
491  */
492 static int alua_tur(struct scsi_device *sdev)
493 {
494 	struct scsi_sense_hdr sense_hdr;
495 	int retval;
496 
497 	retval = scsi_test_unit_ready(sdev, ALUA_FAILOVER_TIMEOUT * HZ,
498 				      ALUA_FAILOVER_RETRIES, &sense_hdr);
499 	if (sense_hdr.sense_key == NOT_READY &&
500 	    sense_hdr.asc == 0x04 && sense_hdr.ascq == 0x0a)
501 		return SCSI_DH_RETRY;
502 	else if (retval)
503 		return SCSI_DH_IO;
504 	else
505 		return SCSI_DH_OK;
506 }
507 
508 /*
509  * alua_rtpg - Evaluate REPORT TARGET GROUP STATES
510  * @sdev: the device to be evaluated.
511  *
512  * Evaluate the Target Port Group State.
513  * Returns SCSI_DH_DEV_OFFLINED if the path is
514  * found to be unusable.
515  */
516 static int alua_rtpg(struct scsi_device *sdev, struct alua_port_group *pg)
517 {
518 	struct scsi_sense_hdr sense_hdr;
519 	struct alua_port_group *tmp_pg;
520 	int len, k, off, bufflen = ALUA_RTPG_SIZE;
521 	int group_id_old, state_old, pref_old, valid_states_old;
522 	unsigned char *desc, *buff;
523 	unsigned err;
524 	int retval;
525 	unsigned int tpg_desc_tbl_off;
526 	unsigned char orig_transition_tmo;
527 	unsigned long flags;
528 	bool transitioning_sense = false;
529 
530 	group_id_old = pg->group_id;
531 	state_old = pg->state;
532 	pref_old = pg->pref;
533 	valid_states_old = pg->valid_states;
534 
535 	if (!pg->expiry) {
536 		unsigned long transition_tmo = ALUA_FAILOVER_TIMEOUT * HZ;
537 
538 		if (pg->transition_tmo)
539 			transition_tmo = pg->transition_tmo * HZ;
540 
541 		pg->expiry = round_jiffies_up(jiffies + transition_tmo);
542 	}
543 
544 	buff = kzalloc(bufflen, GFP_KERNEL);
545 	if (!buff)
546 		return SCSI_DH_DEV_TEMP_BUSY;
547 
548  retry:
549 	err = 0;
550 	retval = submit_rtpg(sdev, buff, bufflen, &sense_hdr, pg->flags);
551 
552 	if (retval) {
553 		/*
554 		 * Some (broken) implementations have a habit of returning
555 		 * an error during things like firmware update etc.
556 		 * But if the target only supports active/optimized there's
557 		 * not much we can do; it's not that we can switch paths
558 		 * or anything.
559 		 * So ignore any errors to avoid spurious failures during
560 		 * path failover.
561 		 */
562 		if ((pg->valid_states & ~TPGS_SUPPORT_OPTIMIZED) == 0) {
563 			sdev_printk(KERN_INFO, sdev,
564 				    "%s: ignoring rtpg result %d\n",
565 				    ALUA_DH_NAME, retval);
566 			kfree(buff);
567 			return SCSI_DH_OK;
568 		}
569 		if (retval < 0 || !scsi_sense_valid(&sense_hdr)) {
570 			sdev_printk(KERN_INFO, sdev,
571 				    "%s: rtpg failed, result %d\n",
572 				    ALUA_DH_NAME, retval);
573 			kfree(buff);
574 			if (retval < 0)
575 				return SCSI_DH_DEV_TEMP_BUSY;
576 			if (host_byte(retval) == DID_NO_CONNECT)
577 				return SCSI_DH_RES_TEMP_UNAVAIL;
578 			return SCSI_DH_IO;
579 		}
580 
581 		/*
582 		 * submit_rtpg() has failed on existing arrays
583 		 * when requesting extended header info, and
584 		 * the array doesn't support extended headers,
585 		 * even though it shouldn't according to T10.
586 		 * The retry without rtpg_ext_hdr_req set
587 		 * handles this.
588 		 * Note:  some arrays return a sense key of ILLEGAL_REQUEST
589 		 * with ASC 00h if they don't support the extended header.
590 		 */
591 		if (!(pg->flags & ALUA_RTPG_EXT_HDR_UNSUPP) &&
592 		    sense_hdr.sense_key == ILLEGAL_REQUEST) {
593 			pg->flags |= ALUA_RTPG_EXT_HDR_UNSUPP;
594 			goto retry;
595 		}
596 		/*
597 		 * If the array returns with 'ALUA state transition'
598 		 * sense code here it cannot return RTPG data during
599 		 * transition. So set the state to 'transitioning' directly.
600 		 */
601 		if (sense_hdr.sense_key == NOT_READY &&
602 		    sense_hdr.asc == 0x04 && sense_hdr.ascq == 0x0a) {
603 			transitioning_sense = true;
604 			goto skip_rtpg;
605 		}
606 		/*
607 		 * Retry on any other UNIT ATTENTION occurred.
608 		 */
609 		if (sense_hdr.sense_key == UNIT_ATTENTION)
610 			err = SCSI_DH_RETRY;
611 		if (err == SCSI_DH_RETRY &&
612 		    pg->expiry != 0 && time_before(jiffies, pg->expiry)) {
613 			sdev_printk(KERN_ERR, sdev, "%s: rtpg retry\n",
614 				    ALUA_DH_NAME);
615 			scsi_print_sense_hdr(sdev, ALUA_DH_NAME, &sense_hdr);
616 			kfree(buff);
617 			return err;
618 		}
619 		sdev_printk(KERN_ERR, sdev, "%s: rtpg failed\n",
620 			    ALUA_DH_NAME);
621 		scsi_print_sense_hdr(sdev, ALUA_DH_NAME, &sense_hdr);
622 		kfree(buff);
623 		pg->expiry = 0;
624 		return SCSI_DH_IO;
625 	}
626 
627 	len = get_unaligned_be32(&buff[0]) + 4;
628 
629 	if (len > bufflen) {
630 		/* Resubmit with the correct length */
631 		kfree(buff);
632 		bufflen = len;
633 		buff = kmalloc(bufflen, GFP_KERNEL);
634 		if (!buff) {
635 			sdev_printk(KERN_WARNING, sdev,
636 				    "%s: kmalloc buffer failed\n",__func__);
637 			/* Temporary failure, bypass */
638 			pg->expiry = 0;
639 			return SCSI_DH_DEV_TEMP_BUSY;
640 		}
641 		goto retry;
642 	}
643 
644 	orig_transition_tmo = pg->transition_tmo;
645 	if ((buff[4] & RTPG_FMT_MASK) == RTPG_FMT_EXT_HDR && buff[5] != 0)
646 		pg->transition_tmo = buff[5];
647 	else
648 		pg->transition_tmo = ALUA_FAILOVER_TIMEOUT;
649 
650 	if (orig_transition_tmo != pg->transition_tmo) {
651 		sdev_printk(KERN_INFO, sdev,
652 			    "%s: transition timeout set to %d seconds\n",
653 			    ALUA_DH_NAME, pg->transition_tmo);
654 		pg->expiry = jiffies + pg->transition_tmo * HZ;
655 	}
656 
657 	if ((buff[4] & RTPG_FMT_MASK) == RTPG_FMT_EXT_HDR)
658 		tpg_desc_tbl_off = 8;
659 	else
660 		tpg_desc_tbl_off = 4;
661 
662 	for (k = tpg_desc_tbl_off, desc = buff + tpg_desc_tbl_off;
663 	     k < len;
664 	     k += off, desc += off) {
665 		u16 group_id = get_unaligned_be16(&desc[2]);
666 
667 		spin_lock_irqsave(&port_group_lock, flags);
668 		tmp_pg = alua_find_get_pg(pg->device_id_str, pg->device_id_len,
669 					  group_id);
670 		spin_unlock_irqrestore(&port_group_lock, flags);
671 		if (tmp_pg) {
672 			if (spin_trylock_irqsave(&tmp_pg->lock, flags)) {
673 				if ((tmp_pg == pg) ||
674 				    !(tmp_pg->flags & ALUA_PG_RUNNING)) {
675 					struct alua_dh_data *h;
676 
677 					tmp_pg->state = desc[0] & 0x0f;
678 					tmp_pg->pref = desc[0] >> 7;
679 					rcu_read_lock();
680 					list_for_each_entry_rcu(h,
681 						&tmp_pg->dh_list, node) {
682 						if (!h->sdev)
683 							continue;
684 						h->sdev->access_state = desc[0];
685 					}
686 					rcu_read_unlock();
687 				}
688 				if (tmp_pg == pg)
689 					tmp_pg->valid_states = desc[1];
690 				spin_unlock_irqrestore(&tmp_pg->lock, flags);
691 			}
692 			kref_put(&tmp_pg->kref, release_port_group);
693 		}
694 		off = 8 + (desc[7] * 4);
695 	}
696 
697  skip_rtpg:
698 	spin_lock_irqsave(&pg->lock, flags);
699 	if (transitioning_sense)
700 		pg->state = SCSI_ACCESS_STATE_TRANSITIONING;
701 
702 	if (group_id_old != pg->group_id || state_old != pg->state ||
703 		pref_old != pg->pref || valid_states_old != pg->valid_states)
704 		sdev_printk(KERN_INFO, sdev,
705 			"%s: port group %02x state %c %s supports %c%c%c%c%c%c%c\n",
706 			ALUA_DH_NAME, pg->group_id, print_alua_state(pg->state),
707 			pg->pref ? "preferred" : "non-preferred",
708 			pg->valid_states&TPGS_SUPPORT_TRANSITION?'T':'t',
709 			pg->valid_states&TPGS_SUPPORT_OFFLINE?'O':'o',
710 			pg->valid_states&TPGS_SUPPORT_LBA_DEPENDENT?'L':'l',
711 			pg->valid_states&TPGS_SUPPORT_UNAVAILABLE?'U':'u',
712 			pg->valid_states&TPGS_SUPPORT_STANDBY?'S':'s',
713 			pg->valid_states&TPGS_SUPPORT_NONOPTIMIZED?'N':'n',
714 			pg->valid_states&TPGS_SUPPORT_OPTIMIZED?'A':'a');
715 
716 	switch (pg->state) {
717 	case SCSI_ACCESS_STATE_TRANSITIONING:
718 		if (time_before(jiffies, pg->expiry)) {
719 			/* State transition, retry */
720 			pg->interval = ALUA_RTPG_RETRY_DELAY;
721 			err = SCSI_DH_RETRY;
722 		} else {
723 			struct alua_dh_data *h;
724 
725 			/* Transitioning time exceeded, set port to standby */
726 			err = SCSI_DH_IO;
727 			pg->state = SCSI_ACCESS_STATE_STANDBY;
728 			pg->expiry = 0;
729 			rcu_read_lock();
730 			list_for_each_entry_rcu(h, &pg->dh_list, node) {
731 				if (!h->sdev)
732 					continue;
733 				h->sdev->access_state =
734 					(pg->state & SCSI_ACCESS_STATE_MASK);
735 				if (pg->pref)
736 					h->sdev->access_state |=
737 						SCSI_ACCESS_STATE_PREFERRED;
738 			}
739 			rcu_read_unlock();
740 		}
741 		break;
742 	case SCSI_ACCESS_STATE_OFFLINE:
743 		/* Path unusable */
744 		err = SCSI_DH_DEV_OFFLINED;
745 		pg->expiry = 0;
746 		break;
747 	default:
748 		/* Useable path if active */
749 		err = SCSI_DH_OK;
750 		pg->expiry = 0;
751 		break;
752 	}
753 	spin_unlock_irqrestore(&pg->lock, flags);
754 	kfree(buff);
755 	return err;
756 }
757 
758 /*
759  * alua_stpg - Issue a SET TARGET PORT GROUP command
760  *
761  * Issue a SET TARGET PORT GROUP command and evaluate the
762  * response. Returns SCSI_DH_RETRY per default to trigger
763  * a re-evaluation of the target group state or SCSI_DH_OK
764  * if no further action needs to be taken.
765  */
766 static unsigned alua_stpg(struct scsi_device *sdev, struct alua_port_group *pg)
767 {
768 	int retval;
769 	struct scsi_sense_hdr sense_hdr;
770 
771 	if (!(pg->tpgs & TPGS_MODE_EXPLICIT)) {
772 		/* Only implicit ALUA supported, retry */
773 		return SCSI_DH_RETRY;
774 	}
775 	switch (pg->state) {
776 	case SCSI_ACCESS_STATE_OPTIMAL:
777 		return SCSI_DH_OK;
778 	case SCSI_ACCESS_STATE_ACTIVE:
779 		if ((pg->flags & ALUA_OPTIMIZE_STPG) &&
780 		    !pg->pref &&
781 		    (pg->tpgs & TPGS_MODE_IMPLICIT))
782 			return SCSI_DH_OK;
783 		break;
784 	case SCSI_ACCESS_STATE_STANDBY:
785 	case SCSI_ACCESS_STATE_UNAVAILABLE:
786 		break;
787 	case SCSI_ACCESS_STATE_OFFLINE:
788 		return SCSI_DH_IO;
789 	case SCSI_ACCESS_STATE_TRANSITIONING:
790 		break;
791 	default:
792 		sdev_printk(KERN_INFO, sdev,
793 			    "%s: stpg failed, unhandled TPGS state %d",
794 			    ALUA_DH_NAME, pg->state);
795 		return SCSI_DH_NOSYS;
796 	}
797 	retval = submit_stpg(sdev, pg->group_id, &sense_hdr);
798 
799 	if (retval) {
800 		if (retval < 0 || !scsi_sense_valid(&sense_hdr)) {
801 			sdev_printk(KERN_INFO, sdev,
802 				    "%s: stpg failed, result %d",
803 				    ALUA_DH_NAME, retval);
804 			if (retval < 0)
805 				return SCSI_DH_DEV_TEMP_BUSY;
806 		} else {
807 			sdev_printk(KERN_INFO, sdev, "%s: stpg failed\n",
808 				    ALUA_DH_NAME);
809 			scsi_print_sense_hdr(sdev, ALUA_DH_NAME, &sense_hdr);
810 		}
811 	}
812 	/* Retry RTPG */
813 	return SCSI_DH_RETRY;
814 }
815 
816 /*
817  * The caller must call scsi_device_put() on the returned pointer if it is not
818  * NULL.
819  */
820 static struct scsi_device * __must_check
821 alua_rtpg_select_sdev(struct alua_port_group *pg)
822 {
823 	struct alua_dh_data *h;
824 	struct scsi_device *sdev = NULL, *prev_sdev;
825 
826 	lockdep_assert_held(&pg->lock);
827 	if (WARN_ON(!pg->rtpg_sdev))
828 		return NULL;
829 
830 	/*
831 	 * RCU protection isn't necessary for dh_list here
832 	 * as we hold pg->lock, but for access to h->pg.
833 	 */
834 	rcu_read_lock();
835 	list_for_each_entry_rcu(h, &pg->dh_list, node) {
836 		if (!h->sdev)
837 			continue;
838 		if (h->sdev == pg->rtpg_sdev) {
839 			h->disabled = true;
840 			continue;
841 		}
842 		if (rcu_dereference(h->pg) == pg &&
843 		    !h->disabled &&
844 		    !scsi_device_get(h->sdev)) {
845 			sdev = h->sdev;
846 			break;
847 		}
848 	}
849 	rcu_read_unlock();
850 
851 	if (!sdev) {
852 		pr_warn("%s: no device found for rtpg\n",
853 			(pg->device_id_len ?
854 			 (char *)pg->device_id_str : "(nameless PG)"));
855 		return NULL;
856 	}
857 
858 	sdev_printk(KERN_INFO, sdev, "rtpg retry on different device\n");
859 
860 	prev_sdev = pg->rtpg_sdev;
861 	pg->rtpg_sdev = sdev;
862 
863 	return prev_sdev;
864 }
865 
866 static void alua_rtpg_work(struct work_struct *work)
867 {
868 	struct alua_port_group *pg =
869 		container_of(work, struct alua_port_group, rtpg_work.work);
870 	struct scsi_device *sdev, *prev_sdev = NULL;
871 	LIST_HEAD(qdata_list);
872 	int err = SCSI_DH_OK;
873 	struct alua_queue_data *qdata, *tmp;
874 	struct alua_dh_data *h;
875 	unsigned long flags;
876 
877 	spin_lock_irqsave(&pg->lock, flags);
878 	sdev = pg->rtpg_sdev;
879 	if (!sdev) {
880 		WARN_ON(pg->flags & ALUA_PG_RUN_RTPG);
881 		WARN_ON(pg->flags & ALUA_PG_RUN_STPG);
882 		spin_unlock_irqrestore(&pg->lock, flags);
883 		kref_put(&pg->kref, release_port_group);
884 		return;
885 	}
886 	pg->flags |= ALUA_PG_RUNNING;
887 	if (pg->flags & ALUA_PG_RUN_RTPG) {
888 		int state = pg->state;
889 
890 		pg->flags &= ~ALUA_PG_RUN_RTPG;
891 		spin_unlock_irqrestore(&pg->lock, flags);
892 		if (state == SCSI_ACCESS_STATE_TRANSITIONING) {
893 			if (alua_tur(sdev) == SCSI_DH_RETRY) {
894 				spin_lock_irqsave(&pg->lock, flags);
895 				pg->flags &= ~ALUA_PG_RUNNING;
896 				pg->flags |= ALUA_PG_RUN_RTPG;
897 				if (!pg->interval)
898 					pg->interval = ALUA_RTPG_RETRY_DELAY;
899 				spin_unlock_irqrestore(&pg->lock, flags);
900 				queue_delayed_work(kaluad_wq, &pg->rtpg_work,
901 						   pg->interval * HZ);
902 				return;
903 			}
904 			/* Send RTPG on failure or if TUR indicates SUCCESS */
905 		}
906 		err = alua_rtpg(sdev, pg);
907 		spin_lock_irqsave(&pg->lock, flags);
908 
909 		/* If RTPG failed on the current device, try using another */
910 		if (err == SCSI_DH_RES_TEMP_UNAVAIL &&
911 		    (prev_sdev = alua_rtpg_select_sdev(pg)))
912 			err = SCSI_DH_IMM_RETRY;
913 
914 		if (err == SCSI_DH_RETRY || err == SCSI_DH_IMM_RETRY ||
915 		    pg->flags & ALUA_PG_RUN_RTPG) {
916 			pg->flags &= ~ALUA_PG_RUNNING;
917 			if (err == SCSI_DH_IMM_RETRY)
918 				pg->interval = 0;
919 			else if (!pg->interval && !(pg->flags & ALUA_PG_RUN_RTPG))
920 				pg->interval = ALUA_RTPG_RETRY_DELAY;
921 			pg->flags |= ALUA_PG_RUN_RTPG;
922 			spin_unlock_irqrestore(&pg->lock, flags);
923 			goto queue_rtpg;
924 		}
925 		if (err != SCSI_DH_OK)
926 			pg->flags &= ~ALUA_PG_RUN_STPG;
927 	}
928 	if (pg->flags & ALUA_PG_RUN_STPG) {
929 		pg->flags &= ~ALUA_PG_RUN_STPG;
930 		spin_unlock_irqrestore(&pg->lock, flags);
931 		err = alua_stpg(sdev, pg);
932 		spin_lock_irqsave(&pg->lock, flags);
933 		if (err == SCSI_DH_RETRY || pg->flags & ALUA_PG_RUN_RTPG) {
934 			pg->flags |= ALUA_PG_RUN_RTPG;
935 			pg->interval = 0;
936 			pg->flags &= ~ALUA_PG_RUNNING;
937 			spin_unlock_irqrestore(&pg->lock, flags);
938 			goto queue_rtpg;
939 		}
940 	}
941 
942 	list_splice_init(&pg->rtpg_list, &qdata_list);
943 	/*
944 	 * We went through an RTPG, for good or bad.
945 	 * Re-enable all devices for the next attempt.
946 	 */
947 	list_for_each_entry(h, &pg->dh_list, node)
948 		h->disabled = false;
949 	pg->rtpg_sdev = NULL;
950 	spin_unlock_irqrestore(&pg->lock, flags);
951 
952 	if (prev_sdev)
953 		scsi_device_put(prev_sdev);
954 
955 	list_for_each_entry_safe(qdata, tmp, &qdata_list, entry) {
956 		list_del(&qdata->entry);
957 		if (qdata->callback_fn)
958 			qdata->callback_fn(qdata->callback_data, err);
959 		kfree(qdata);
960 	}
961 	spin_lock_irqsave(&pg->lock, flags);
962 	pg->flags &= ~ALUA_PG_RUNNING;
963 	spin_unlock_irqrestore(&pg->lock, flags);
964 	scsi_device_put(sdev);
965 	kref_put(&pg->kref, release_port_group);
966 	return;
967 
968 queue_rtpg:
969 	if (prev_sdev)
970 		scsi_device_put(prev_sdev);
971 	queue_delayed_work(kaluad_wq, &pg->rtpg_work, pg->interval * HZ);
972 }
973 
974 /**
975  * alua_rtpg_queue() - cause RTPG to be submitted asynchronously
976  * @pg: ALUA port group associated with @sdev.
977  * @sdev: SCSI device for which to submit an RTPG.
978  * @qdata: Information about the callback to invoke after the RTPG.
979  * @force: Whether or not to submit an RTPG if a work item that will submit an
980  *         RTPG already has been scheduled.
981  *
982  * Returns true if and only if alua_rtpg_work() will be called asynchronously.
983  * That function is responsible for calling @qdata->fn().
984  */
985 static bool alua_rtpg_queue(struct alua_port_group *pg,
986 			    struct scsi_device *sdev,
987 			    struct alua_queue_data *qdata, bool force)
988 {
989 	int start_queue = 0;
990 	unsigned long flags;
991 
992 	might_sleep();
993 
994 	if (WARN_ON_ONCE(!pg) || scsi_device_get(sdev))
995 		return false;
996 
997 	spin_lock_irqsave(&pg->lock, flags);
998 	if (qdata) {
999 		list_add_tail(&qdata->entry, &pg->rtpg_list);
1000 		pg->flags |= ALUA_PG_RUN_STPG;
1001 		force = true;
1002 	}
1003 	if (pg->rtpg_sdev == NULL) {
1004 		struct alua_dh_data *h = sdev->handler_data;
1005 
1006 		rcu_read_lock();
1007 		if (h && rcu_dereference(h->pg) == pg) {
1008 			pg->interval = 0;
1009 			pg->flags |= ALUA_PG_RUN_RTPG;
1010 			kref_get(&pg->kref);
1011 			pg->rtpg_sdev = sdev;
1012 			start_queue = 1;
1013 		}
1014 		rcu_read_unlock();
1015 	} else if (!(pg->flags & ALUA_PG_RUN_RTPG) && force) {
1016 		pg->flags |= ALUA_PG_RUN_RTPG;
1017 		/* Do not queue if the worker is already running */
1018 		if (!(pg->flags & ALUA_PG_RUNNING)) {
1019 			kref_get(&pg->kref);
1020 			start_queue = 1;
1021 		}
1022 	}
1023 
1024 	spin_unlock_irqrestore(&pg->lock, flags);
1025 
1026 	if (start_queue) {
1027 		if (queue_delayed_work(kaluad_wq, &pg->rtpg_work,
1028 				msecs_to_jiffies(ALUA_RTPG_DELAY_MSECS)))
1029 			sdev = NULL;
1030 		else
1031 			kref_put(&pg->kref, release_port_group);
1032 	}
1033 	if (sdev)
1034 		scsi_device_put(sdev);
1035 
1036 	return true;
1037 }
1038 
1039 /*
1040  * alua_initialize - Initialize ALUA state
1041  * @sdev: the device to be initialized
1042  *
1043  * For the prep_fn to work correctly we have
1044  * to initialize the ALUA state for the device.
1045  */
1046 static int alua_initialize(struct scsi_device *sdev, struct alua_dh_data *h)
1047 {
1048 	int err = SCSI_DH_DEV_UNSUPP, tpgs;
1049 
1050 	mutex_lock(&h->init_mutex);
1051 	h->disabled = false;
1052 	tpgs = alua_check_tpgs(sdev);
1053 	if (tpgs != TPGS_MODE_NONE)
1054 		err = alua_check_vpd(sdev, h, tpgs);
1055 	h->init_error = err;
1056 	mutex_unlock(&h->init_mutex);
1057 	return err;
1058 }
1059 /*
1060  * alua_set_params - set/unset the optimize flag
1061  * @sdev: device on the path to be activated
1062  * params - parameters in the following format
1063  *      "no_of_params\0param1\0param2\0param3\0...\0"
1064  * For example, to set the flag pass the following parameters
1065  * from multipath.conf
1066  *     hardware_handler        "2 alua 1"
1067  */
1068 static int alua_set_params(struct scsi_device *sdev, const char *params)
1069 {
1070 	struct alua_dh_data *h = sdev->handler_data;
1071 	struct alua_port_group *pg = NULL;
1072 	unsigned int optimize = 0, argc;
1073 	const char *p = params;
1074 	int result = SCSI_DH_OK;
1075 	unsigned long flags;
1076 
1077 	if ((sscanf(params, "%u", &argc) != 1) || (argc != 1))
1078 		return -EINVAL;
1079 
1080 	while (*p++)
1081 		;
1082 	if ((sscanf(p, "%u", &optimize) != 1) || (optimize > 1))
1083 		return -EINVAL;
1084 
1085 	rcu_read_lock();
1086 	pg = rcu_dereference(h->pg);
1087 	if (!pg) {
1088 		rcu_read_unlock();
1089 		return -ENXIO;
1090 	}
1091 	spin_lock_irqsave(&pg->lock, flags);
1092 	if (optimize)
1093 		pg->flags |= ALUA_OPTIMIZE_STPG;
1094 	else
1095 		pg->flags &= ~ALUA_OPTIMIZE_STPG;
1096 	spin_unlock_irqrestore(&pg->lock, flags);
1097 	rcu_read_unlock();
1098 
1099 	return result;
1100 }
1101 
1102 /*
1103  * alua_activate - activate a path
1104  * @sdev: device on the path to be activated
1105  *
1106  * We're currently switching the port group to be activated only and
1107  * let the array figure out the rest.
1108  * There may be other arrays which require us to switch all port groups
1109  * based on a certain policy. But until we actually encounter them it
1110  * should be okay.
1111  */
1112 static int alua_activate(struct scsi_device *sdev,
1113 			activate_complete fn, void *data)
1114 {
1115 	struct alua_dh_data *h = sdev->handler_data;
1116 	int err = SCSI_DH_OK;
1117 	struct alua_queue_data *qdata;
1118 	struct alua_port_group *pg;
1119 
1120 	qdata = kzalloc(sizeof(*qdata), GFP_KERNEL);
1121 	if (!qdata) {
1122 		err = SCSI_DH_RES_TEMP_UNAVAIL;
1123 		goto out;
1124 	}
1125 	qdata->callback_fn = fn;
1126 	qdata->callback_data = data;
1127 
1128 	mutex_lock(&h->init_mutex);
1129 	rcu_read_lock();
1130 	pg = rcu_dereference(h->pg);
1131 	if (!pg || !kref_get_unless_zero(&pg->kref)) {
1132 		rcu_read_unlock();
1133 		kfree(qdata);
1134 		err = h->init_error;
1135 		mutex_unlock(&h->init_mutex);
1136 		goto out;
1137 	}
1138 	rcu_read_unlock();
1139 	mutex_unlock(&h->init_mutex);
1140 
1141 	if (alua_rtpg_queue(pg, sdev, qdata, true))
1142 		fn = NULL;
1143 	else
1144 		err = SCSI_DH_DEV_OFFLINED;
1145 	kref_put(&pg->kref, release_port_group);
1146 out:
1147 	if (fn)
1148 		fn(data, err);
1149 	return 0;
1150 }
1151 
1152 /*
1153  * alua_check - check path status
1154  * @sdev: device on the path to be checked
1155  *
1156  * Check the device status
1157  */
1158 static void alua_check(struct scsi_device *sdev, bool force)
1159 {
1160 	struct alua_dh_data *h = sdev->handler_data;
1161 	struct alua_port_group *pg;
1162 
1163 	rcu_read_lock();
1164 	pg = rcu_dereference(h->pg);
1165 	if (!pg || !kref_get_unless_zero(&pg->kref)) {
1166 		rcu_read_unlock();
1167 		return;
1168 	}
1169 	rcu_read_unlock();
1170 	alua_rtpg_queue(pg, sdev, NULL, force);
1171 	kref_put(&pg->kref, release_port_group);
1172 }
1173 
1174 /*
1175  * alua_prep_fn - request callback
1176  *
1177  * Fail I/O to all paths not in state
1178  * active/optimized or active/non-optimized.
1179  */
1180 static blk_status_t alua_prep_fn(struct scsi_device *sdev, struct request *req)
1181 {
1182 	struct alua_dh_data *h = sdev->handler_data;
1183 	struct alua_port_group *pg;
1184 	unsigned char state = SCSI_ACCESS_STATE_OPTIMAL;
1185 
1186 	rcu_read_lock();
1187 	pg = rcu_dereference(h->pg);
1188 	if (pg)
1189 		state = pg->state;
1190 	rcu_read_unlock();
1191 
1192 	switch (state) {
1193 	case SCSI_ACCESS_STATE_OPTIMAL:
1194 	case SCSI_ACCESS_STATE_ACTIVE:
1195 	case SCSI_ACCESS_STATE_LBA:
1196 	case SCSI_ACCESS_STATE_TRANSITIONING:
1197 		return BLK_STS_OK;
1198 	default:
1199 		req->rq_flags |= RQF_QUIET;
1200 		return BLK_STS_IOERR;
1201 	}
1202 }
1203 
1204 static void alua_rescan(struct scsi_device *sdev)
1205 {
1206 	struct alua_dh_data *h = sdev->handler_data;
1207 
1208 	alua_initialize(sdev, h);
1209 }
1210 
1211 /*
1212  * alua_bus_attach - Attach device handler
1213  * @sdev: device to be attached to
1214  */
1215 static int alua_bus_attach(struct scsi_device *sdev)
1216 {
1217 	struct alua_dh_data *h;
1218 	int err;
1219 
1220 	h = kzalloc(sizeof(*h) , GFP_KERNEL);
1221 	if (!h)
1222 		return SCSI_DH_NOMEM;
1223 	spin_lock_init(&h->pg_lock);
1224 	rcu_assign_pointer(h->pg, NULL);
1225 	h->init_error = SCSI_DH_OK;
1226 	h->sdev = sdev;
1227 	INIT_LIST_HEAD(&h->node);
1228 
1229 	mutex_init(&h->init_mutex);
1230 	err = alua_initialize(sdev, h);
1231 	if (err != SCSI_DH_OK && err != SCSI_DH_DEV_OFFLINED)
1232 		goto failed;
1233 
1234 	sdev->handler_data = h;
1235 	return SCSI_DH_OK;
1236 failed:
1237 	kfree(h);
1238 	return err;
1239 }
1240 
1241 /*
1242  * alua_bus_detach - Detach device handler
1243  * @sdev: device to be detached from
1244  */
1245 static void alua_bus_detach(struct scsi_device *sdev)
1246 {
1247 	struct alua_dh_data *h = sdev->handler_data;
1248 	struct alua_port_group *pg;
1249 
1250 	spin_lock(&h->pg_lock);
1251 	pg = rcu_dereference_protected(h->pg, lockdep_is_held(&h->pg_lock));
1252 	rcu_assign_pointer(h->pg, NULL);
1253 	spin_unlock(&h->pg_lock);
1254 	if (pg) {
1255 		spin_lock_irq(&pg->lock);
1256 		list_del_rcu(&h->node);
1257 		spin_unlock_irq(&pg->lock);
1258 		kref_put(&pg->kref, release_port_group);
1259 	}
1260 	sdev->handler_data = NULL;
1261 	synchronize_rcu();
1262 	kfree(h);
1263 }
1264 
1265 static struct scsi_device_handler alua_dh = {
1266 	.name = ALUA_DH_NAME,
1267 	.module = THIS_MODULE,
1268 	.attach = alua_bus_attach,
1269 	.detach = alua_bus_detach,
1270 	.prep_fn = alua_prep_fn,
1271 	.check_sense = alua_check_sense,
1272 	.activate = alua_activate,
1273 	.rescan = alua_rescan,
1274 	.set_params = alua_set_params,
1275 };
1276 
1277 static int __init alua_init(void)
1278 {
1279 	int r;
1280 
1281 	kaluad_wq = alloc_workqueue("kaluad", WQ_MEM_RECLAIM, 0);
1282 	if (!kaluad_wq)
1283 		return -ENOMEM;
1284 
1285 	r = scsi_register_device_handler(&alua_dh);
1286 	if (r != 0) {
1287 		printk(KERN_ERR "%s: Failed to register scsi device handler",
1288 			ALUA_DH_NAME);
1289 		destroy_workqueue(kaluad_wq);
1290 	}
1291 	return r;
1292 }
1293 
1294 static void __exit alua_exit(void)
1295 {
1296 	scsi_unregister_device_handler(&alua_dh);
1297 	destroy_workqueue(kaluad_wq);
1298 }
1299 
1300 module_init(alua_init);
1301 module_exit(alua_exit);
1302 
1303 MODULE_DESCRIPTION("DM Multipath ALUA support");
1304 MODULE_AUTHOR("Hannes Reinecke <hare@suse.de>");
1305 MODULE_LICENSE("GPL");
1306 MODULE_VERSION(ALUA_DH_VER);
1307