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