2 * LSI/Engenio/NetApp E-Series RDAC SCSI Device Handler
4 * Copyright (C) 2005 Mike Christie. All rights reserved.
5 * Copyright (C) Chandra Seetharaman, IBM Corp. 2007
7 * This program is free software; you can redistribute it and/or modify
8 * it under the terms of the GNU General Public License as published by
9 * the Free Software Foundation; either version 2 of the License, or
10 * (at your option) any later version.
12 * This program is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 * GNU General Public License for more details.
17 * You should have received a copy of the GNU General Public License
18 * along with this program; if not, write to the Free Software
19 * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
22 #include <scsi/scsi.h>
23 #include <scsi/scsi_eh.h>
24 #include <scsi/scsi_dh.h>
25 #include <linux/workqueue.h>
26 #include <linux/slab.h>
27 #include <linux/module.h>
29 #define RDAC_NAME "rdac"
30 #define RDAC_RETRY_COUNT 5
35 * These struct definitions and the forming of the
36 * mode page were taken from the LSI RDAC 2.4 GPL'd
37 * driver, and then converted to Linux conventions.
39 #define RDAC_QUIESCENCE_TIME 20
43 #define RDAC_PAGE_CODE_REDUNDANT_CONTROLLER 0x2c
46 * Controller modes definitions
48 #define RDAC_MODE_TRANSFER_SPECIFIED_LUNS 0x02
53 #define RDAC_FORCED_QUIESENCE 0x02
55 #define RDAC_TIMEOUT (60 * HZ)
56 #define RDAC_RETRIES 3
58 struct rdac_mode_6_hdr
{
65 struct rdac_mode_10_hdr
{
73 struct rdac_mode_common
{
74 u8 controller_serial
[16];
75 u8 alt_controller_serial
[16];
78 u8 quiescence_timeout
;
82 struct rdac_pg_legacy
{
83 struct rdac_mode_6_hdr hdr
;
86 struct rdac_mode_common common
;
87 #define MODE6_MAX_LUN 32
88 u8 lun_table
[MODE6_MAX_LUN
];
94 struct rdac_pg_expanded
{
95 struct rdac_mode_10_hdr hdr
;
99 struct rdac_mode_common common
;
107 u8 page_code
; /* 0xC9 */
110 u8 page_id
[4]; /* "vace" */
116 #define SUBSYS_ID_LEN 16
117 #define SLOT_ID_LEN 2
118 #define ARRAY_LABEL_LEN 31
122 u8 page_code
; /* 0xC4 */
125 u8 page_id
[4]; /* "subs" */
126 u8 subsys_id
[SUBSYS_ID_LEN
];
128 u8 slot_id
[SLOT_ID_LEN
];
132 #define UNIQUE_ID_LEN 16
135 u8 page_code
; /* 0xC8 */
138 u8 page_id
[4]; /* "edid" */
142 u8 vol_user_label_len
;
143 u8 vol_user_label
[60];
144 u8 array_uniq_id_len
;
145 u8 array_unique_id
[UNIQUE_ID_LEN
];
146 u8 array_user_label_len
;
147 u8 array_user_label
[60];
151 struct rdac_controller
{
152 u8 array_id
[UNIQUE_ID_LEN
];
155 struct list_head node
; /* list of all controllers */
157 struct rdac_pg_legacy legacy
;
158 struct rdac_pg_expanded expanded
;
161 u8 array_name
[ARRAY_LABEL_LEN
];
162 struct Scsi_Host
*host
;
165 struct work_struct ms_work
;
166 struct scsi_device
*ms_sdev
;
167 struct list_head ms_head
;
168 struct list_head dh_list
;
173 u8 page_code
; /* 0xC2 */
176 u8 page_id
[4]; /* "swr4" */
180 u8 max_lun_supported
;
181 u8 partitions
[239]; /* Total allocation length should be 0xFF */
184 struct rdac_dh_data
{
185 struct list_head node
;
186 struct rdac_controller
*ctlr
;
187 struct scsi_device
*sdev
;
188 #define UNINITIALIZED_LUN (1 << 8)
192 #define RDAC_MODE_AVT 1
193 #define RDAC_MODE_IOSHIP 2
196 #define RDAC_STATE_ACTIVE 0
197 #define RDAC_STATE_PASSIVE 1
200 #define RDAC_LUN_UNOWNED 0
201 #define RDAC_LUN_OWNED 1
204 #define RDAC_PREFERRED 0
205 #define RDAC_NON_PREFERRED 1
209 struct c2_inquiry c2
;
210 struct c4_inquiry c4
;
211 struct c8_inquiry c8
;
212 struct c9_inquiry c9
;
216 static const char *mode
[] = {
221 static const char *lun_state
[] =
227 struct rdac_queue_data
{
228 struct list_head entry
;
229 struct rdac_dh_data
*h
;
230 activate_complete callback_fn
;
234 static LIST_HEAD(ctlr_list
);
235 static DEFINE_SPINLOCK(list_lock
);
236 static struct workqueue_struct
*kmpath_rdacd
;
237 static void send_mode_select(struct work_struct
*work
);
240 * module parameter to enable rdac debug logging.
241 * 2 bits for each type of logging, only two types defined for now
242 * Can be enhanced if required at later point
244 static int rdac_logging
= 1;
245 module_param(rdac_logging
, int, S_IRUGO
|S_IWUSR
);
246 MODULE_PARM_DESC(rdac_logging
, "A bit mask of rdac logging levels, "
247 "Default is 1 - failover logging enabled, "
248 "set it to 0xF to enable all the logs");
250 #define RDAC_LOG_FAILOVER 0
251 #define RDAC_LOG_SENSE 2
253 #define RDAC_LOG_BITS 2
255 #define RDAC_LOG_LEVEL(SHIFT) \
256 ((rdac_logging >> (SHIFT)) & ((1 << (RDAC_LOG_BITS)) - 1))
258 #define RDAC_LOG(SHIFT, sdev, f, arg...) \
260 if (unlikely(RDAC_LOG_LEVEL(SHIFT))) \
261 sdev_printk(KERN_INFO, sdev, RDAC_NAME ": " f "\n", ## arg); \
264 static unsigned int rdac_failover_get(struct rdac_controller
*ctlr
,
265 struct list_head
*list
,
268 struct rdac_mode_common
*common
;
270 struct rdac_queue_data
*qdata
;
273 if (ctlr
->use_ms10
) {
274 struct rdac_pg_expanded
*rdac_pg
;
276 data_size
= sizeof(struct rdac_pg_expanded
);
277 rdac_pg
= &ctlr
->mode_select
.expanded
;
278 memset(rdac_pg
, 0, data_size
);
279 common
= &rdac_pg
->common
;
280 rdac_pg
->page_code
= RDAC_PAGE_CODE_REDUNDANT_CONTROLLER
+ 0x40;
281 rdac_pg
->subpage_code
= 0x1;
282 rdac_pg
->page_len
[0] = 0x01;
283 rdac_pg
->page_len
[1] = 0x28;
284 lun_table
= rdac_pg
->lun_table
;
286 struct rdac_pg_legacy
*rdac_pg
;
288 data_size
= sizeof(struct rdac_pg_legacy
);
289 rdac_pg
= &ctlr
->mode_select
.legacy
;
290 memset(rdac_pg
, 0, data_size
);
291 common
= &rdac_pg
->common
;
292 rdac_pg
->page_code
= RDAC_PAGE_CODE_REDUNDANT_CONTROLLER
;
293 rdac_pg
->page_len
= 0x68;
294 lun_table
= rdac_pg
->lun_table
;
296 common
->rdac_mode
[1] = RDAC_MODE_TRANSFER_SPECIFIED_LUNS
;
297 common
->quiescence_timeout
= RDAC_QUIESCENCE_TIME
;
298 common
->rdac_options
= RDAC_FORCED_QUIESENCE
;
300 list_for_each_entry(qdata
, list
, entry
) {
301 lun_table
[qdata
->h
->lun
] = 0x81;
304 /* Prepare the command. */
305 if (ctlr
->use_ms10
) {
306 cdb
[0] = MODE_SELECT_10
;
307 cdb
[7] = data_size
>> 8;
308 cdb
[8] = data_size
& 0xff;
310 cdb
[0] = MODE_SELECT
;
317 static void release_controller(struct kref
*kref
)
319 struct rdac_controller
*ctlr
;
320 ctlr
= container_of(kref
, struct rdac_controller
, kref
);
322 list_del(&ctlr
->node
);
326 static struct rdac_controller
*get_controller(int index
, char *array_name
,
327 u8
*array_id
, struct scsi_device
*sdev
)
329 struct rdac_controller
*ctlr
, *tmp
;
331 list_for_each_entry(tmp
, &ctlr_list
, node
) {
332 if ((memcmp(tmp
->array_id
, array_id
, UNIQUE_ID_LEN
) == 0) &&
333 (tmp
->index
== index
) &&
334 (tmp
->host
== sdev
->host
)) {
335 kref_get(&tmp
->kref
);
339 ctlr
= kmalloc(sizeof(*ctlr
), GFP_ATOMIC
);
343 /* initialize fields of controller */
344 memcpy(ctlr
->array_id
, array_id
, UNIQUE_ID_LEN
);
346 ctlr
->host
= sdev
->host
;
347 memcpy(ctlr
->array_name
, array_name
, ARRAY_LABEL_LEN
);
349 kref_init(&ctlr
->kref
);
352 ctlr
->ms_sdev
= NULL
;
353 spin_lock_init(&ctlr
->ms_lock
);
354 INIT_WORK(&ctlr
->ms_work
, send_mode_select
);
355 INIT_LIST_HEAD(&ctlr
->ms_head
);
356 list_add(&ctlr
->node
, &ctlr_list
);
357 INIT_LIST_HEAD(&ctlr
->dh_list
);
362 static int get_lun_info(struct scsi_device
*sdev
, struct rdac_dh_data
*h
,
363 char *array_name
, u8
*array_id
)
365 int err
= SCSI_DH_IO
, i
;
366 struct c8_inquiry
*inqp
= &h
->inq
.c8
;
368 if (!scsi_get_vpd_page(sdev
, 0xC8, (unsigned char *)inqp
,
369 sizeof(struct c8_inquiry
))) {
370 if (inqp
->page_code
!= 0xc8)
371 return SCSI_DH_NOSYS
;
372 if (inqp
->page_id
[0] != 'e' || inqp
->page_id
[1] != 'd' ||
373 inqp
->page_id
[2] != 'i' || inqp
->page_id
[3] != 'd')
374 return SCSI_DH_NOSYS
;
375 h
->lun
= inqp
->lun
[7]; /* Uses only the last byte */
377 for(i
=0; i
<ARRAY_LABEL_LEN
-1; ++i
)
378 *(array_name
+i
) = inqp
->array_user_label
[(2*i
)+1];
380 *(array_name
+ARRAY_LABEL_LEN
-1) = '\0';
381 memset(array_id
, 0, UNIQUE_ID_LEN
);
382 memcpy(array_id
, inqp
->array_unique_id
, inqp
->array_uniq_id_len
);
388 static int check_ownership(struct scsi_device
*sdev
, struct rdac_dh_data
*h
)
390 int err
= SCSI_DH_IO
, access_state
;
391 struct rdac_dh_data
*tmp
;
392 struct c9_inquiry
*inqp
= &h
->inq
.c9
;
394 h
->state
= RDAC_STATE_ACTIVE
;
395 if (!scsi_get_vpd_page(sdev
, 0xC9, (unsigned char *)inqp
,
396 sizeof(struct c9_inquiry
))) {
397 /* detect the operating mode */
398 if ((inqp
->avte_cvp
>> 5) & 0x1)
399 h
->mode
= RDAC_MODE_IOSHIP
; /* LUN in IOSHIP mode */
400 else if (inqp
->avte_cvp
>> 7)
401 h
->mode
= RDAC_MODE_AVT
; /* LUN in AVT mode */
403 h
->mode
= RDAC_MODE
; /* LUN in RDAC mode */
405 /* Update ownership */
406 if (inqp
->avte_cvp
& 0x1) {
407 h
->lun_state
= RDAC_LUN_OWNED
;
408 access_state
= SCSI_ACCESS_STATE_OPTIMAL
;
410 h
->lun_state
= RDAC_LUN_UNOWNED
;
411 if (h
->mode
== RDAC_MODE
) {
412 h
->state
= RDAC_STATE_PASSIVE
;
413 access_state
= SCSI_ACCESS_STATE_STANDBY
;
415 access_state
= SCSI_ACCESS_STATE_ACTIVE
;
418 /* Update path prio*/
419 if (inqp
->path_prio
& 0x1) {
420 h
->preferred
= RDAC_PREFERRED
;
421 access_state
|= SCSI_ACCESS_STATE_PREFERRED
;
423 h
->preferred
= RDAC_NON_PREFERRED
;
425 list_for_each_entry_rcu(tmp
, &h
->ctlr
->dh_list
, node
) {
426 /* h->sdev should always be valid */
428 tmp
->sdev
->access_state
= access_state
;
437 static int initialize_controller(struct scsi_device
*sdev
,
438 struct rdac_dh_data
*h
, char *array_name
, u8
*array_id
)
440 int err
= SCSI_DH_IO
, index
;
441 struct c4_inquiry
*inqp
= &h
->inq
.c4
;
443 if (!scsi_get_vpd_page(sdev
, 0xC4, (unsigned char *)inqp
,
444 sizeof(struct c4_inquiry
))) {
445 /* get the controller index */
446 if (inqp
->slot_id
[1] == 0x31)
451 spin_lock(&list_lock
);
452 h
->ctlr
= get_controller(index
, array_name
, array_id
, sdev
);
454 err
= SCSI_DH_RES_TEMP_UNAVAIL
;
456 list_add_rcu(&h
->node
, &h
->ctlr
->dh_list
);
459 spin_unlock(&list_lock
);
465 static int set_mode_select(struct scsi_device
*sdev
, struct rdac_dh_data
*h
)
467 int err
= SCSI_DH_IO
;
468 struct c2_inquiry
*inqp
= &h
->inq
.c2
;
470 if (!scsi_get_vpd_page(sdev
, 0xC2, (unsigned char *)inqp
,
471 sizeof(struct c2_inquiry
))) {
473 * If more than MODE6_MAX_LUN luns are supported, use
476 if (inqp
->max_lun_supported
>= MODE6_MAX_LUN
)
477 h
->ctlr
->use_ms10
= 1;
479 h
->ctlr
->use_ms10
= 0;
485 static int mode_select_handle_sense(struct scsi_device
*sdev
,
486 struct scsi_sense_hdr
*sense_hdr
)
488 int err
= SCSI_DH_IO
;
489 struct rdac_dh_data
*h
= sdev
->handler_data
;
491 if (!scsi_sense_valid(sense_hdr
))
494 switch (sense_hdr
->sense_key
) {
496 case ABORTED_COMMAND
:
501 if (sense_hdr
->asc
== 0x04 && sense_hdr
->ascq
== 0x01)
502 /* LUN Not Ready and is in the Process of Becoming
507 case ILLEGAL_REQUEST
:
508 if (sense_hdr
->asc
== 0x91 && sense_hdr
->ascq
== 0x36)
510 * Command Lock contention
512 err
= SCSI_DH_IMM_RETRY
;
518 RDAC_LOG(RDAC_LOG_FAILOVER
, sdev
, "array %s, ctlr %d, "
519 "MODE_SELECT returned with sense %02x/%02x/%02x",
520 (char *) h
->ctlr
->array_name
, h
->ctlr
->index
,
521 sense_hdr
->sense_key
, sense_hdr
->asc
, sense_hdr
->ascq
);
527 static void send_mode_select(struct work_struct
*work
)
529 struct rdac_controller
*ctlr
=
530 container_of(work
, struct rdac_controller
, ms_work
);
531 struct scsi_device
*sdev
= ctlr
->ms_sdev
;
532 struct rdac_dh_data
*h
= sdev
->handler_data
;
533 int err
= SCSI_DH_OK
, retry_cnt
= RDAC_RETRY_COUNT
;
534 struct rdac_queue_data
*tmp
, *qdata
;
536 unsigned char cdb
[COMMAND_SIZE(MODE_SELECT_10
)];
537 struct scsi_sense_hdr sshdr
;
538 unsigned int data_size
;
539 u64 req_flags
= REQ_FAILFAST_DEV
| REQ_FAILFAST_TRANSPORT
|
542 spin_lock(&ctlr
->ms_lock
);
543 list_splice_init(&ctlr
->ms_head
, &list
);
545 ctlr
->ms_sdev
= NULL
;
546 spin_unlock(&ctlr
->ms_lock
);
549 data_size
= rdac_failover_get(ctlr
, &list
, cdb
);
551 RDAC_LOG(RDAC_LOG_FAILOVER
, sdev
, "array %s, ctlr %d, "
552 "%s MODE_SELECT command",
553 (char *) h
->ctlr
->array_name
, h
->ctlr
->index
,
554 (retry_cnt
== RDAC_RETRY_COUNT
) ? "queueing" : "retrying");
556 if (scsi_execute(sdev
, cdb
, DMA_TO_DEVICE
, &h
->ctlr
->mode_select
,
557 data_size
, NULL
, &sshdr
, RDAC_TIMEOUT
* HZ
,
558 RDAC_RETRIES
, req_flags
, 0, NULL
)) {
559 err
= mode_select_handle_sense(sdev
, &sshdr
);
560 if (err
== SCSI_DH_RETRY
&& retry_cnt
--)
562 if (err
== SCSI_DH_IMM_RETRY
)
565 if (err
== SCSI_DH_OK
) {
566 h
->state
= RDAC_STATE_ACTIVE
;
567 RDAC_LOG(RDAC_LOG_FAILOVER
, sdev
, "array %s, ctlr %d, "
568 "MODE_SELECT completed",
569 (char *) h
->ctlr
->array_name
, h
->ctlr
->index
);
572 list_for_each_entry_safe(qdata
, tmp
, &list
, entry
) {
573 list_del(&qdata
->entry
);
574 if (err
== SCSI_DH_OK
)
575 qdata
->h
->state
= RDAC_STATE_ACTIVE
;
576 if (qdata
->callback_fn
)
577 qdata
->callback_fn(qdata
->callback_data
, err
);
583 static int queue_mode_select(struct scsi_device
*sdev
,
584 activate_complete fn
, void *data
)
586 struct rdac_queue_data
*qdata
;
587 struct rdac_controller
*ctlr
;
589 qdata
= kzalloc(sizeof(*qdata
), GFP_KERNEL
);
591 return SCSI_DH_RETRY
;
593 qdata
->h
= sdev
->handler_data
;
594 qdata
->callback_fn
= fn
;
595 qdata
->callback_data
= data
;
597 ctlr
= qdata
->h
->ctlr
;
598 spin_lock(&ctlr
->ms_lock
);
599 list_add_tail(&qdata
->entry
, &ctlr
->ms_head
);
600 if (!ctlr
->ms_queued
) {
602 ctlr
->ms_sdev
= sdev
;
603 queue_work(kmpath_rdacd
, &ctlr
->ms_work
);
605 spin_unlock(&ctlr
->ms_lock
);
609 static int rdac_activate(struct scsi_device
*sdev
,
610 activate_complete fn
, void *data
)
612 struct rdac_dh_data
*h
= sdev
->handler_data
;
613 int err
= SCSI_DH_OK
;
616 err
= check_ownership(sdev
, h
);
617 if (err
!= SCSI_DH_OK
)
622 if (h
->lun_state
== RDAC_LUN_UNOWNED
)
625 case RDAC_MODE_IOSHIP
:
626 if ((h
->lun_state
== RDAC_LUN_UNOWNED
) &&
627 (h
->preferred
== RDAC_PREFERRED
))
635 err
= queue_mode_select(sdev
, fn
, data
);
636 if (err
== SCSI_DH_OK
)
645 static int rdac_prep_fn(struct scsi_device
*sdev
, struct request
*req
)
647 struct rdac_dh_data
*h
= sdev
->handler_data
;
648 int ret
= BLKPREP_OK
;
650 if (h
->state
!= RDAC_STATE_ACTIVE
) {
652 req
->rq_flags
|= RQF_QUIET
;
658 static int rdac_check_sense(struct scsi_device
*sdev
,
659 struct scsi_sense_hdr
*sense_hdr
)
661 struct rdac_dh_data
*h
= sdev
->handler_data
;
663 RDAC_LOG(RDAC_LOG_SENSE
, sdev
, "array %s, ctlr %d, "
664 "I/O returned with sense %02x/%02x/%02x",
665 (char *) h
->ctlr
->array_name
, h
->ctlr
->index
,
666 sense_hdr
->sense_key
, sense_hdr
->asc
, sense_hdr
->ascq
);
668 switch (sense_hdr
->sense_key
) {
670 if (sense_hdr
->asc
== 0x04 && sense_hdr
->ascq
== 0x01)
671 /* LUN Not Ready - Logical Unit Not Ready and is in
672 * the process of becoming ready
675 return ADD_TO_MLQUEUE
;
676 if (sense_hdr
->asc
== 0x04 && sense_hdr
->ascq
== 0x81)
677 /* LUN Not Ready - Storage firmware incompatible
678 * Manual code synchonisation required.
680 * Nothing we can do here. Try to bypass the path.
683 if (sense_hdr
->asc
== 0x04 && sense_hdr
->ascq
== 0xA1)
684 /* LUN Not Ready - Quiescense in progress
686 * Just retry and wait.
688 return ADD_TO_MLQUEUE
;
689 if (sense_hdr
->asc
== 0xA1 && sense_hdr
->ascq
== 0x02)
690 /* LUN Not Ready - Quiescense in progress
691 * or has been achieved
694 return ADD_TO_MLQUEUE
;
696 case ILLEGAL_REQUEST
:
697 if (sense_hdr
->asc
== 0x94 && sense_hdr
->ascq
== 0x01) {
698 /* Invalid Request - Current Logical Unit Ownership.
699 * Controller is not the current owner of the LUN,
700 * Fail the path, so that the other path be used.
702 h
->state
= RDAC_STATE_PASSIVE
;
707 if (sense_hdr
->asc
== 0x29 && sense_hdr
->ascq
== 0x00)
709 * Power On, Reset, or Bus Device Reset, just retry.
711 return ADD_TO_MLQUEUE
;
712 if (sense_hdr
->asc
== 0x8b && sense_hdr
->ascq
== 0x02)
714 * Quiescence in progress , just retry.
716 return ADD_TO_MLQUEUE
;
719 /* success just means we do not care what scsi-ml does */
720 return SCSI_RETURN_NOT_HANDLED
;
723 static int rdac_bus_attach(struct scsi_device
*sdev
)
725 struct rdac_dh_data
*h
;
727 char array_name
[ARRAY_LABEL_LEN
];
728 char array_id
[UNIQUE_ID_LEN
];
730 h
= kzalloc(sizeof(*h
) , GFP_KERNEL
);
733 h
->lun
= UNINITIALIZED_LUN
;
734 h
->state
= RDAC_STATE_ACTIVE
;
736 err
= get_lun_info(sdev
, h
, array_name
, array_id
);
737 if (err
!= SCSI_DH_OK
)
740 err
= initialize_controller(sdev
, h
, array_name
, array_id
);
741 if (err
!= SCSI_DH_OK
)
744 err
= check_ownership(sdev
, h
);
745 if (err
!= SCSI_DH_OK
)
748 err
= set_mode_select(sdev
, h
);
749 if (err
!= SCSI_DH_OK
)
752 sdev_printk(KERN_NOTICE
, sdev
,
753 "%s: LUN %d (%s) (%s)\n",
754 RDAC_NAME
, h
->lun
, mode
[(int)h
->mode
],
755 lun_state
[(int)h
->lun_state
]);
757 sdev
->handler_data
= h
;
761 spin_lock(&list_lock
);
762 kref_put(&h
->ctlr
->kref
, release_controller
);
763 spin_unlock(&list_lock
);
770 static void rdac_bus_detach( struct scsi_device
*sdev
)
772 struct rdac_dh_data
*h
= sdev
->handler_data
;
774 if (h
->ctlr
&& h
->ctlr
->ms_queued
)
775 flush_workqueue(kmpath_rdacd
);
777 spin_lock(&list_lock
);
779 list_del_rcu(&h
->node
);
781 kref_put(&h
->ctlr
->kref
, release_controller
);
783 spin_unlock(&list_lock
);
784 sdev
->handler_data
= NULL
;
788 static struct scsi_device_handler rdac_dh
= {
790 .module
= THIS_MODULE
,
791 .prep_fn
= rdac_prep_fn
,
792 .check_sense
= rdac_check_sense
,
793 .attach
= rdac_bus_attach
,
794 .detach
= rdac_bus_detach
,
795 .activate
= rdac_activate
,
798 static int __init
rdac_init(void)
802 r
= scsi_register_device_handler(&rdac_dh
);
804 printk(KERN_ERR
"Failed to register scsi device handler.");
809 * Create workqueue to handle mode selects for rdac
811 kmpath_rdacd
= create_singlethread_workqueue("kmpath_rdacd");
813 scsi_unregister_device_handler(&rdac_dh
);
814 printk(KERN_ERR
"kmpath_rdacd creation failed.\n");
822 static void __exit
rdac_exit(void)
824 destroy_workqueue(kmpath_rdacd
);
825 scsi_unregister_device_handler(&rdac_dh
);
828 module_init(rdac_init
);
829 module_exit(rdac_exit
);
831 MODULE_DESCRIPTION("Multipath LSI/Engenio/NetApp E-Series RDAC driver");
832 MODULE_AUTHOR("Mike Christie, Chandra Seetharaman");
833 MODULE_VERSION("01.00.0000.0000");
834 MODULE_LICENSE("GPL");