1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22#include <scsi/scsi.h>
23#include <scsi/scsi_eh.h>
24#include <scsi/scsi_dh.h>
25
26#define ALUA_DH_NAME "alua"
27#define ALUA_DH_VER "1.2"
28
29#define TPGS_STATE_OPTIMIZED 0x0
30#define TPGS_STATE_NONOPTIMIZED 0x1
31#define TPGS_STATE_STANDBY 0x2
32#define TPGS_STATE_UNAVAILABLE 0x3
33#define TPGS_STATE_OFFLINE 0xe
34#define TPGS_STATE_TRANSITIONING 0xf
35
36#define TPGS_SUPPORT_NONE 0x00
37#define TPGS_SUPPORT_OPTIMIZED 0x01
38#define TPGS_SUPPORT_NONOPTIMIZED 0x02
39#define TPGS_SUPPORT_STANDBY 0x04
40#define TPGS_SUPPORT_UNAVAILABLE 0x08
41#define TPGS_SUPPORT_OFFLINE 0x40
42#define TPGS_SUPPORT_TRANSITION 0x80
43
44#define TPGS_MODE_UNINITIALIZED -1
45#define TPGS_MODE_NONE 0x0
46#define TPGS_MODE_IMPLICIT 0x1
47#define TPGS_MODE_EXPLICIT 0x2
48
49#define ALUA_INQUIRY_SIZE 36
50#define ALUA_FAILOVER_TIMEOUT (60 * HZ)
51#define ALUA_FAILOVER_RETRIES 5
52
53struct alua_dh_data {
54 int group_id;
55 int rel_port;
56 int tpgs;
57 int state;
58 unsigned char inq[ALUA_INQUIRY_SIZE];
59 unsigned char *buff;
60 int bufflen;
61 unsigned char sense[SCSI_SENSE_BUFFERSIZE];
62 int senselen;
63};
64
65#define ALUA_POLICY_SWITCH_CURRENT 0
66#define ALUA_POLICY_SWITCH_ALL 1
67
68static inline struct alua_dh_data *get_alua_data(struct scsi_device *sdev)
69{
70 struct scsi_dh_data *scsi_dh_data = sdev->scsi_dh_data;
71 BUG_ON(scsi_dh_data == NULL);
72 return ((struct alua_dh_data *) scsi_dh_data->buf);
73}
74
75static int realloc_buffer(struct alua_dh_data *h, unsigned len)
76{
77 if (h->buff && h->buff != h->inq)
78 kfree(h->buff);
79
80 h->buff = kmalloc(len, GFP_NOIO);
81 if (!h->buff) {
82 h->buff = h->inq;
83 h->bufflen = ALUA_INQUIRY_SIZE;
84 return 1;
85 }
86 h->bufflen = len;
87 return 0;
88}
89
90static struct request *get_alua_req(struct scsi_device *sdev,
91 void *buffer, unsigned buflen, int rw)
92{
93 struct request *rq;
94 struct request_queue *q = sdev->request_queue;
95
96 rq = blk_get_request(q, rw, GFP_NOIO);
97
98 if (!rq) {
99 sdev_printk(KERN_INFO, sdev,
100 "%s: blk_get_request failed\n", __func__);
101 return NULL;
102 }
103
104 if (buflen && blk_rq_map_kern(q, rq, buffer, buflen, GFP_NOIO)) {
105 blk_put_request(rq);
106 sdev_printk(KERN_INFO, sdev,
107 "%s: blk_rq_map_kern failed\n", __func__);
108 return NULL;
109 }
110
111 rq->cmd_type = REQ_TYPE_BLOCK_PC;
112 rq->cmd_flags |= REQ_FAILFAST_DEV | REQ_FAILFAST_TRANSPORT |
113 REQ_FAILFAST_DRIVER;
114 rq->retries = ALUA_FAILOVER_RETRIES;
115 rq->timeout = ALUA_FAILOVER_TIMEOUT;
116
117 return rq;
118}
119
120
121
122
123
124static int submit_std_inquiry(struct scsi_device *sdev, struct alua_dh_data *h)
125{
126 struct request *rq;
127 int err = SCSI_DH_RES_TEMP_UNAVAIL;
128
129 rq = get_alua_req(sdev, h->inq, ALUA_INQUIRY_SIZE, READ);
130 if (!rq)
131 goto done;
132
133
134 rq->cmd[0] = INQUIRY;
135 rq->cmd[1] = 0;
136 rq->cmd[2] = 0;
137 rq->cmd[4] = ALUA_INQUIRY_SIZE;
138 rq->cmd_len = COMMAND_SIZE(INQUIRY);
139
140 rq->sense = h->sense;
141 memset(rq->sense, 0, SCSI_SENSE_BUFFERSIZE);
142 rq->sense_len = h->senselen = 0;
143
144 err = blk_execute_rq(rq->q, NULL, rq, 1);
145 if (err == -EIO) {
146 sdev_printk(KERN_INFO, sdev,
147 "%s: std inquiry failed with %x\n",
148 ALUA_DH_NAME, rq->errors);
149 h->senselen = rq->sense_len;
150 err = SCSI_DH_IO;
151 }
152 blk_put_request(rq);
153done:
154 return err;
155}
156
157
158
159
160
161static int submit_vpd_inquiry(struct scsi_device *sdev, struct alua_dh_data *h)
162{
163 struct request *rq;
164 int err = SCSI_DH_RES_TEMP_UNAVAIL;
165
166 rq = get_alua_req(sdev, h->buff, h->bufflen, READ);
167 if (!rq)
168 goto done;
169
170
171 rq->cmd[0] = INQUIRY;
172 rq->cmd[1] = 1;
173 rq->cmd[2] = 0x83;
174 rq->cmd[4] = h->bufflen;
175 rq->cmd_len = COMMAND_SIZE(INQUIRY);
176
177 rq->sense = h->sense;
178 memset(rq->sense, 0, SCSI_SENSE_BUFFERSIZE);
179 rq->sense_len = h->senselen = 0;
180
181 err = blk_execute_rq(rq->q, NULL, rq, 1);
182 if (err == -EIO) {
183 sdev_printk(KERN_INFO, sdev,
184 "%s: evpd inquiry failed with %x\n",
185 ALUA_DH_NAME, rq->errors);
186 h->senselen = rq->sense_len;
187 err = SCSI_DH_IO;
188 }
189 blk_put_request(rq);
190done:
191 return err;
192}
193
194
195
196
197
198static unsigned submit_rtpg(struct scsi_device *sdev, struct alua_dh_data *h)
199{
200 struct request *rq;
201 int err = SCSI_DH_RES_TEMP_UNAVAIL;
202
203 rq = get_alua_req(sdev, h->buff, h->bufflen, READ);
204 if (!rq)
205 goto done;
206
207
208 rq->cmd[0] = MAINTENANCE_IN;
209 rq->cmd[1] = MI_REPORT_TARGET_PGS;
210 rq->cmd[6] = (h->bufflen >> 24) & 0xff;
211 rq->cmd[7] = (h->bufflen >> 16) & 0xff;
212 rq->cmd[8] = (h->bufflen >> 8) & 0xff;
213 rq->cmd[9] = h->bufflen & 0xff;
214 rq->cmd_len = COMMAND_SIZE(MAINTENANCE_IN);
215
216 rq->sense = h->sense;
217 memset(rq->sense, 0, SCSI_SENSE_BUFFERSIZE);
218 rq->sense_len = h->senselen = 0;
219
220 err = blk_execute_rq(rq->q, NULL, rq, 1);
221 if (err == -EIO) {
222 sdev_printk(KERN_INFO, sdev,
223 "%s: rtpg failed with %x\n",
224 ALUA_DH_NAME, rq->errors);
225 h->senselen = rq->sense_len;
226 err = SCSI_DH_IO;
227 }
228 blk_put_request(rq);
229done:
230 return err;
231}
232
233
234
235
236
237
238
239
240
241static unsigned submit_stpg(struct scsi_device *sdev, struct alua_dh_data *h)
242{
243 struct request *rq;
244 int err = SCSI_DH_RES_TEMP_UNAVAIL;
245 int stpg_len = 8;
246
247
248 memset(h->buff, 0, stpg_len);
249 h->buff[4] = TPGS_STATE_OPTIMIZED & 0x0f;
250 h->buff[6] = (h->group_id >> 8) & 0xff;
251 h->buff[7] = h->group_id & 0xff;
252
253 rq = get_alua_req(sdev, h->buff, stpg_len, WRITE);
254 if (!rq)
255 goto done;
256
257
258 rq->cmd[0] = MAINTENANCE_OUT;
259 rq->cmd[1] = MO_SET_TARGET_PGS;
260 rq->cmd[6] = (stpg_len >> 24) & 0xff;
261 rq->cmd[7] = (stpg_len >> 16) & 0xff;
262 rq->cmd[8] = (stpg_len >> 8) & 0xff;
263 rq->cmd[9] = stpg_len & 0xff;
264 rq->cmd_len = COMMAND_SIZE(MAINTENANCE_OUT);
265
266 rq->sense = h->sense;
267 memset(rq->sense, 0, SCSI_SENSE_BUFFERSIZE);
268 rq->sense_len = h->senselen = 0;
269
270 err = blk_execute_rq(rq->q, NULL, rq, 1);
271 if (err == -EIO) {
272 sdev_printk(KERN_INFO, sdev,
273 "%s: stpg failed with %x\n",
274 ALUA_DH_NAME, rq->errors);
275 h->senselen = rq->sense_len;
276 err = SCSI_DH_IO;
277 }
278 blk_put_request(rq);
279done:
280 return err;
281}
282
283
284
285
286
287
288
289
290static int alua_std_inquiry(struct scsi_device *sdev, struct alua_dh_data *h)
291{
292 int err;
293
294 err = submit_std_inquiry(sdev, h);
295
296 if (err != SCSI_DH_OK)
297 return err;
298
299
300 h->tpgs = (h->inq[5] >> 4) & 0x3;
301 switch (h->tpgs) {
302 case TPGS_MODE_EXPLICIT|TPGS_MODE_IMPLICIT:
303 sdev_printk(KERN_INFO, sdev,
304 "%s: supports implicit and explicit TPGS\n",
305 ALUA_DH_NAME);
306 break;
307 case TPGS_MODE_EXPLICIT:
308 sdev_printk(KERN_INFO, sdev, "%s: supports explicit TPGS\n",
309 ALUA_DH_NAME);
310 break;
311 case TPGS_MODE_IMPLICIT:
312 sdev_printk(KERN_INFO, sdev, "%s: supports implicit TPGS\n",
313 ALUA_DH_NAME);
314 break;
315 default:
316 h->tpgs = TPGS_MODE_NONE;
317 sdev_printk(KERN_INFO, sdev, "%s: not supported\n",
318 ALUA_DH_NAME);
319 err = SCSI_DH_DEV_UNSUPP;
320 break;
321 }
322
323 return err;
324}
325
326
327
328
329
330
331
332
333static int alua_vpd_inquiry(struct scsi_device *sdev, struct alua_dh_data *h)
334{
335 int len;
336 unsigned err;
337 unsigned char *d;
338
339 retry:
340 err = submit_vpd_inquiry(sdev, h);
341
342 if (err != SCSI_DH_OK)
343 return err;
344
345
346 len = (h->buff[2] << 8) + h->buff[3] + 4;
347 if (len > h->bufflen) {
348
349 if (realloc_buffer(h, len)) {
350 sdev_printk(KERN_WARNING, sdev,
351 "%s: kmalloc buffer failed\n",
352 ALUA_DH_NAME);
353
354 return SCSI_DH_DEV_TEMP_BUSY;
355 }
356 goto retry;
357 }
358
359
360
361
362 d = h->buff + 4;
363 while (d < h->buff + len) {
364 switch (d[1] & 0xf) {
365 case 0x4:
366
367 h->rel_port = (d[6] << 8) + d[7];
368 break;
369 case 0x5:
370
371 h->group_id = (d[6] << 8) + d[7];
372 break;
373 default:
374 break;
375 }
376 d += d[3] + 4;
377 }
378
379 if (h->group_id == -1) {
380
381
382
383
384
385 sdev_printk(KERN_INFO, sdev,
386 "%s: No target port descriptors found\n",
387 ALUA_DH_NAME);
388 h->state = TPGS_STATE_OPTIMIZED;
389 h->tpgs = TPGS_MODE_NONE;
390 err = SCSI_DH_DEV_UNSUPP;
391 } else {
392 sdev_printk(KERN_INFO, sdev,
393 "%s: port group %02x rel port %02x\n",
394 ALUA_DH_NAME, h->group_id, h->rel_port);
395 }
396
397 return err;
398}
399
400static char print_alua_state(int state)
401{
402 switch (state) {
403 case TPGS_STATE_OPTIMIZED:
404 return 'A';
405 case TPGS_STATE_NONOPTIMIZED:
406 return 'N';
407 case TPGS_STATE_STANDBY:
408 return 'S';
409 case TPGS_STATE_UNAVAILABLE:
410 return 'U';
411 case TPGS_STATE_OFFLINE:
412 return 'O';
413 case TPGS_STATE_TRANSITIONING:
414 return 'T';
415 default:
416 return 'X';
417 }
418}
419
420static int alua_check_sense(struct scsi_device *sdev,
421 struct scsi_sense_hdr *sense_hdr)
422{
423 switch (sense_hdr->sense_key) {
424 case NOT_READY:
425 if (sense_hdr->asc == 0x04 && sense_hdr->ascq == 0x0a)
426
427
428
429 return ADD_TO_MLQUEUE;
430 if (sense_hdr->asc == 0x04 && sense_hdr->ascq == 0x0b)
431
432
433
434 return SUCCESS;
435 if (sense_hdr->asc == 0x04 && sense_hdr->ascq == 0x0c)
436
437
438
439 return SUCCESS;
440 if (sense_hdr->asc == 0x04 && sense_hdr->ascq == 0x12)
441
442
443
444 return SUCCESS;
445 break;
446 case UNIT_ATTENTION:
447 if (sense_hdr->asc == 0x29 && sense_hdr->ascq == 0x00)
448
449
450
451 return ADD_TO_MLQUEUE;
452 if (sense_hdr->asc == 0x2a && sense_hdr->ascq == 0x06) {
453
454
455
456 return ADD_TO_MLQUEUE;
457 }
458 if (sense_hdr->asc == 0x2a && sense_hdr->ascq == 0x07) {
459
460
461
462 return ADD_TO_MLQUEUE;
463 }
464 if (sense_hdr->asc == 0x3f && sense_hdr->ascq == 0x0e) {
465
466
467
468
469
470 return ADD_TO_MLQUEUE;
471 }
472
473 break;
474 }
475
476 return SCSI_RETURN_NOT_HANDLED;
477}
478
479
480
481
482
483
484
485
486
487
488static int alua_stpg(struct scsi_device *sdev, int state,
489 struct alua_dh_data *h)
490{
491 struct scsi_sense_hdr sense_hdr;
492 unsigned err;
493 int retry = ALUA_FAILOVER_RETRIES;
494
495 retry:
496 err = submit_stpg(sdev, h);
497 if (err == SCSI_DH_IO && h->senselen > 0) {
498 err = scsi_normalize_sense(h->sense, SCSI_SENSE_BUFFERSIZE,
499 &sense_hdr);
500 if (!err)
501 return SCSI_DH_IO;
502 err = alua_check_sense(sdev, &sense_hdr);
503 if (retry > 0 && err == ADD_TO_MLQUEUE) {
504 retry--;
505 goto retry;
506 }
507 sdev_printk(KERN_INFO, sdev,
508 "%s: stpg sense code: %02x/%02x/%02x\n",
509 ALUA_DH_NAME, sense_hdr.sense_key,
510 sense_hdr.asc, sense_hdr.ascq);
511 err = SCSI_DH_IO;
512 }
513 if (err == SCSI_DH_OK) {
514 h->state = state;
515 sdev_printk(KERN_INFO, sdev,
516 "%s: port group %02x switched to state %c\n",
517 ALUA_DH_NAME, h->group_id,
518 print_alua_state(h->state) );
519 }
520 return err;
521}
522
523
524
525
526
527
528
529
530
531static int alua_rtpg(struct scsi_device *sdev, struct alua_dh_data *h)
532{
533 struct scsi_sense_hdr sense_hdr;
534 int len, k, off, valid_states = 0;
535 char *ucp;
536 unsigned err;
537
538 retry:
539 err = submit_rtpg(sdev, h);
540
541 if (err == SCSI_DH_IO && h->senselen > 0) {
542 err = scsi_normalize_sense(h->sense, SCSI_SENSE_BUFFERSIZE,
543 &sense_hdr);
544 if (!err)
545 return SCSI_DH_IO;
546
547 err = alua_check_sense(sdev, &sense_hdr);
548 if (err == ADD_TO_MLQUEUE)
549 goto retry;
550 sdev_printk(KERN_INFO, sdev,
551 "%s: rtpg sense code %02x/%02x/%02x\n",
552 ALUA_DH_NAME, sense_hdr.sense_key,
553 sense_hdr.asc, sense_hdr.ascq);
554 err = SCSI_DH_IO;
555 }
556 if (err != SCSI_DH_OK)
557 return err;
558
559 len = (h->buff[0] << 24) + (h->buff[1] << 16) +
560 (h->buff[2] << 8) + h->buff[3] + 4;
561
562 if (len > h->bufflen) {
563
564 if (realloc_buffer(h, len)) {
565 sdev_printk(KERN_WARNING, sdev,
566 "%s: kmalloc buffer failed\n",__func__);
567
568 return SCSI_DH_DEV_TEMP_BUSY;
569 }
570 goto retry;
571 }
572
573 for (k = 4, ucp = h->buff + 4; k < len; k += off, ucp += off) {
574 if (h->group_id == (ucp[2] << 8) + ucp[3]) {
575 h->state = ucp[0] & 0x0f;
576 valid_states = ucp[1];
577 }
578 off = 8 + (ucp[7] * 4);
579 }
580
581 sdev_printk(KERN_INFO, sdev,
582 "%s: port group %02x state %c supports %c%c%c%c%c%c\n",
583 ALUA_DH_NAME, h->group_id, print_alua_state(h->state),
584 valid_states&TPGS_SUPPORT_TRANSITION?'T':'t',
585 valid_states&TPGS_SUPPORT_OFFLINE?'O':'o',
586 valid_states&TPGS_SUPPORT_UNAVAILABLE?'U':'u',
587 valid_states&TPGS_SUPPORT_STANDBY?'S':'s',
588 valid_states&TPGS_SUPPORT_NONOPTIMIZED?'N':'n',
589 valid_states&TPGS_SUPPORT_OPTIMIZED?'A':'a');
590
591 if (h->tpgs & TPGS_MODE_EXPLICIT) {
592 switch (h->state) {
593 case TPGS_STATE_TRANSITIONING:
594
595 goto retry;
596 break;
597 case TPGS_STATE_OFFLINE:
598
599 err = SCSI_DH_DEV_OFFLINED;
600 break;
601 default:
602 break;
603 }
604 } else {
605
606 if (h->state == TPGS_STATE_OPTIMIZED ||
607 h->state == TPGS_STATE_NONOPTIMIZED ||
608 h->state == TPGS_STATE_STANDBY)
609
610 err = SCSI_DH_OK;
611 else
612
613 err = SCSI_DH_DEV_OFFLINED;
614 }
615 return err;
616}
617
618
619
620
621
622
623
624
625static int alua_initialize(struct scsi_device *sdev, struct alua_dh_data *h)
626{
627 int err;
628
629 err = alua_std_inquiry(sdev, h);
630 if (err != SCSI_DH_OK)
631 goto out;
632
633 err = alua_vpd_inquiry(sdev, h);
634 if (err != SCSI_DH_OK)
635 goto out;
636
637 err = alua_rtpg(sdev, h);
638 if (err != SCSI_DH_OK)
639 goto out;
640
641out:
642 return err;
643}
644
645
646
647
648
649
650
651
652
653
654
655static int alua_activate(struct scsi_device *sdev)
656{
657 struct alua_dh_data *h = get_alua_data(sdev);
658 int err = SCSI_DH_OK;
659
660 if (h->group_id != -1) {
661 err = alua_rtpg(sdev, h);
662 if (err != SCSI_DH_OK)
663 goto out;
664 }
665
666 if (h->tpgs & TPGS_MODE_EXPLICIT && h->state != TPGS_STATE_OPTIMIZED)
667 err = alua_stpg(sdev, TPGS_STATE_OPTIMIZED, h);
668
669out:
670 return err;
671}
672
673
674
675
676
677
678
679static int alua_prep_fn(struct scsi_device *sdev, struct request *req)
680{
681 struct alua_dh_data *h = get_alua_data(sdev);
682 int ret = BLKPREP_OK;
683
684 if (h->state != TPGS_STATE_OPTIMIZED &&
685 h->state != TPGS_STATE_NONOPTIMIZED) {
686 ret = BLKPREP_KILL;
687 req->cmd_flags |= REQ_QUIET;
688 }
689 return ret;
690
691}
692
693static const struct scsi_dh_devlist alua_dev_list[] = {
694 {"HP", "MSA VOLUME" },
695 {"HP", "HSV101" },
696 {"HP", "HSV111" },
697 {"HP", "HSV200" },
698 {"HP", "HSV210" },
699 {"HP", "HSV300" },
700 {"IBM", "2107900" },
701 {"IBM", "2145" },
702 {"Pillar", "Axiom" },
703 {"Intel", "Multi-Flex"},
704 {NULL, NULL}
705};
706
707static int alua_bus_attach(struct scsi_device *sdev);
708static void alua_bus_detach(struct scsi_device *sdev);
709
710static struct scsi_device_handler alua_dh = {
711 .name = ALUA_DH_NAME,
712 .module = THIS_MODULE,
713 .devlist = alua_dev_list,
714 .attach = alua_bus_attach,
715 .detach = alua_bus_detach,
716 .prep_fn = alua_prep_fn,
717 .check_sense = alua_check_sense,
718 .activate = alua_activate,
719};
720
721
722
723
724
725static int alua_bus_attach(struct scsi_device *sdev)
726{
727 struct scsi_dh_data *scsi_dh_data;
728 struct alua_dh_data *h;
729 unsigned long flags;
730 int err = SCSI_DH_OK;
731
732 scsi_dh_data = kzalloc(sizeof(struct scsi_device_handler *)
733 + sizeof(*h) , GFP_KERNEL);
734 if (!scsi_dh_data) {
735 sdev_printk(KERN_ERR, sdev, "%s: Attach failed\n",
736 ALUA_DH_NAME);
737 return -ENOMEM;
738 }
739
740 scsi_dh_data->scsi_dh = &alua_dh;
741 h = (struct alua_dh_data *) scsi_dh_data->buf;
742 h->tpgs = TPGS_MODE_UNINITIALIZED;
743 h->state = TPGS_STATE_OPTIMIZED;
744 h->group_id = -1;
745 h->rel_port = -1;
746 h->buff = h->inq;
747 h->bufflen = ALUA_INQUIRY_SIZE;
748
749 err = alua_initialize(sdev, h);
750 if (err != SCSI_DH_OK)
751 goto failed;
752
753 if (!try_module_get(THIS_MODULE))
754 goto failed;
755
756 spin_lock_irqsave(sdev->request_queue->queue_lock, flags);
757 sdev->scsi_dh_data = scsi_dh_data;
758 spin_unlock_irqrestore(sdev->request_queue->queue_lock, flags);
759
760 return 0;
761
762failed:
763 kfree(scsi_dh_data);
764 sdev_printk(KERN_ERR, sdev, "%s: not attached\n", ALUA_DH_NAME);
765 return -EINVAL;
766}
767
768
769
770
771
772static void alua_bus_detach(struct scsi_device *sdev)
773{
774 struct scsi_dh_data *scsi_dh_data;
775 struct alua_dh_data *h;
776 unsigned long flags;
777
778 spin_lock_irqsave(sdev->request_queue->queue_lock, flags);
779 scsi_dh_data = sdev->scsi_dh_data;
780 sdev->scsi_dh_data = NULL;
781 spin_unlock_irqrestore(sdev->request_queue->queue_lock, flags);
782
783 h = (struct alua_dh_data *) scsi_dh_data->buf;
784 if (h->buff && h->inq != h->buff)
785 kfree(h->buff);
786 kfree(scsi_dh_data);
787 module_put(THIS_MODULE);
788 sdev_printk(KERN_NOTICE, sdev, "%s: Detached\n", ALUA_DH_NAME);
789}
790
791static int __init alua_init(void)
792{
793 int r;
794
795 r = scsi_register_device_handler(&alua_dh);
796 if (r != 0)
797 printk(KERN_ERR "%s: Failed to register scsi device handler",
798 ALUA_DH_NAME);
799 return r;
800}
801
802static void __exit alua_exit(void)
803{
804 scsi_unregister_device_handler(&alua_dh);
805}
806
807module_init(alua_init);
808module_exit(alua_exit);
809
810MODULE_DESCRIPTION("DM Multipath ALUA support");
811MODULE_AUTHOR("Hannes Reinecke <hare@suse.de>");
812MODULE_LICENSE("GPL");
813MODULE_VERSION(ALUA_DH_VER);
814