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 * Context: may be called from atomic context (alua_check()) only if the caller 986 * holds an sdev reference. 987 */ 988 static bool alua_rtpg_queue(struct alua_port_group *pg, 989 struct scsi_device *sdev, 990 struct alua_queue_data *qdata, bool force) 991 { 992 int start_queue = 0; 993 unsigned long flags; 994 995 if (WARN_ON_ONCE(!pg) || scsi_device_get(sdev)) 996 return false; 997 998 spin_lock_irqsave(&pg->lock, flags); 999 if (qdata) { 1000 list_add_tail(&qdata->entry, &pg->rtpg_list); 1001 pg->flags |= ALUA_PG_RUN_STPG; 1002 force = true; 1003 } 1004 if (pg->rtpg_sdev == NULL) { 1005 struct alua_dh_data *h = sdev->handler_data; 1006 1007 rcu_read_lock(); 1008 if (h && rcu_dereference(h->pg) == pg) { 1009 pg->interval = 0; 1010 pg->flags |= ALUA_PG_RUN_RTPG; 1011 kref_get(&pg->kref); 1012 pg->rtpg_sdev = sdev; 1013 start_queue = 1; 1014 } 1015 rcu_read_unlock(); 1016 } else if (!(pg->flags & ALUA_PG_RUN_RTPG) && force) { 1017 pg->flags |= ALUA_PG_RUN_RTPG; 1018 /* Do not queue if the worker is already running */ 1019 if (!(pg->flags & ALUA_PG_RUNNING)) { 1020 kref_get(&pg->kref); 1021 start_queue = 1; 1022 } 1023 } 1024 1025 spin_unlock_irqrestore(&pg->lock, flags); 1026 1027 if (start_queue) { 1028 if (queue_delayed_work(kaluad_wq, &pg->rtpg_work, 1029 msecs_to_jiffies(ALUA_RTPG_DELAY_MSECS))) 1030 sdev = NULL; 1031 else 1032 kref_put(&pg->kref, release_port_group); 1033 } 1034 if (sdev) 1035 scsi_device_put(sdev); 1036 1037 return true; 1038 } 1039 1040 /* 1041 * alua_initialize - Initialize ALUA state 1042 * @sdev: the device to be initialized 1043 * 1044 * For the prep_fn to work correctly we have 1045 * to initialize the ALUA state for the device. 1046 */ 1047 static int alua_initialize(struct scsi_device *sdev, struct alua_dh_data *h) 1048 { 1049 int err = SCSI_DH_DEV_UNSUPP, tpgs; 1050 1051 mutex_lock(&h->init_mutex); 1052 h->disabled = false; 1053 tpgs = alua_check_tpgs(sdev); 1054 if (tpgs != TPGS_MODE_NONE) 1055 err = alua_check_vpd(sdev, h, tpgs); 1056 h->init_error = err; 1057 mutex_unlock(&h->init_mutex); 1058 return err; 1059 } 1060 /* 1061 * alua_set_params - set/unset the optimize flag 1062 * @sdev: device on the path to be activated 1063 * params - parameters in the following format 1064 * "no_of_params\0param1\0param2\0param3\0...\0" 1065 * For example, to set the flag pass the following parameters 1066 * from multipath.conf 1067 * hardware_handler "2 alua 1" 1068 */ 1069 static int alua_set_params(struct scsi_device *sdev, const char *params) 1070 { 1071 struct alua_dh_data *h = sdev->handler_data; 1072 struct alua_port_group *pg = NULL; 1073 unsigned int optimize = 0, argc; 1074 const char *p = params; 1075 int result = SCSI_DH_OK; 1076 unsigned long flags; 1077 1078 if ((sscanf(params, "%u", &argc) != 1) || (argc != 1)) 1079 return -EINVAL; 1080 1081 while (*p++) 1082 ; 1083 if ((sscanf(p, "%u", &optimize) != 1) || (optimize > 1)) 1084 return -EINVAL; 1085 1086 rcu_read_lock(); 1087 pg = rcu_dereference(h->pg); 1088 if (!pg) { 1089 rcu_read_unlock(); 1090 return -ENXIO; 1091 } 1092 spin_lock_irqsave(&pg->lock, flags); 1093 if (optimize) 1094 pg->flags |= ALUA_OPTIMIZE_STPG; 1095 else 1096 pg->flags &= ~ALUA_OPTIMIZE_STPG; 1097 spin_unlock_irqrestore(&pg->lock, flags); 1098 rcu_read_unlock(); 1099 1100 return result; 1101 } 1102 1103 /* 1104 * alua_activate - activate a path 1105 * @sdev: device on the path to be activated 1106 * 1107 * We're currently switching the port group to be activated only and 1108 * let the array figure out the rest. 1109 * There may be other arrays which require us to switch all port groups 1110 * based on a certain policy. But until we actually encounter them it 1111 * should be okay. 1112 */ 1113 static int alua_activate(struct scsi_device *sdev, 1114 activate_complete fn, void *data) 1115 { 1116 struct alua_dh_data *h = sdev->handler_data; 1117 int err = SCSI_DH_OK; 1118 struct alua_queue_data *qdata; 1119 struct alua_port_group *pg; 1120 1121 qdata = kzalloc(sizeof(*qdata), GFP_KERNEL); 1122 if (!qdata) { 1123 err = SCSI_DH_RES_TEMP_UNAVAIL; 1124 goto out; 1125 } 1126 qdata->callback_fn = fn; 1127 qdata->callback_data = data; 1128 1129 mutex_lock(&h->init_mutex); 1130 rcu_read_lock(); 1131 pg = rcu_dereference(h->pg); 1132 if (!pg || !kref_get_unless_zero(&pg->kref)) { 1133 rcu_read_unlock(); 1134 kfree(qdata); 1135 err = h->init_error; 1136 mutex_unlock(&h->init_mutex); 1137 goto out; 1138 } 1139 rcu_read_unlock(); 1140 mutex_unlock(&h->init_mutex); 1141 1142 if (alua_rtpg_queue(pg, sdev, qdata, true)) 1143 fn = NULL; 1144 else 1145 err = SCSI_DH_DEV_OFFLINED; 1146 kref_put(&pg->kref, release_port_group); 1147 out: 1148 if (fn) 1149 fn(data, err); 1150 return 0; 1151 } 1152 1153 /* 1154 * alua_check - check path status 1155 * @sdev: device on the path to be checked 1156 * 1157 * Check the device status 1158 */ 1159 static void alua_check(struct scsi_device *sdev, bool force) 1160 { 1161 struct alua_dh_data *h = sdev->handler_data; 1162 struct alua_port_group *pg; 1163 1164 rcu_read_lock(); 1165 pg = rcu_dereference(h->pg); 1166 if (!pg || !kref_get_unless_zero(&pg->kref)) { 1167 rcu_read_unlock(); 1168 return; 1169 } 1170 rcu_read_unlock(); 1171 alua_rtpg_queue(pg, sdev, NULL, force); 1172 kref_put(&pg->kref, release_port_group); 1173 } 1174 1175 /* 1176 * alua_prep_fn - request callback 1177 * 1178 * Fail I/O to all paths not in state 1179 * active/optimized or active/non-optimized. 1180 */ 1181 static blk_status_t alua_prep_fn(struct scsi_device *sdev, struct request *req) 1182 { 1183 struct alua_dh_data *h = sdev->handler_data; 1184 struct alua_port_group *pg; 1185 unsigned char state = SCSI_ACCESS_STATE_OPTIMAL; 1186 1187 rcu_read_lock(); 1188 pg = rcu_dereference(h->pg); 1189 if (pg) 1190 state = pg->state; 1191 rcu_read_unlock(); 1192 1193 switch (state) { 1194 case SCSI_ACCESS_STATE_OPTIMAL: 1195 case SCSI_ACCESS_STATE_ACTIVE: 1196 case SCSI_ACCESS_STATE_LBA: 1197 case SCSI_ACCESS_STATE_TRANSITIONING: 1198 return BLK_STS_OK; 1199 default: 1200 req->rq_flags |= RQF_QUIET; 1201 return BLK_STS_IOERR; 1202 } 1203 } 1204 1205 static void alua_rescan(struct scsi_device *sdev) 1206 { 1207 struct alua_dh_data *h = sdev->handler_data; 1208 1209 alua_initialize(sdev, h); 1210 } 1211 1212 /* 1213 * alua_bus_attach - Attach device handler 1214 * @sdev: device to be attached to 1215 */ 1216 static int alua_bus_attach(struct scsi_device *sdev) 1217 { 1218 struct alua_dh_data *h; 1219 int err; 1220 1221 h = kzalloc(sizeof(*h) , GFP_KERNEL); 1222 if (!h) 1223 return SCSI_DH_NOMEM; 1224 spin_lock_init(&h->pg_lock); 1225 rcu_assign_pointer(h->pg, NULL); 1226 h->init_error = SCSI_DH_OK; 1227 h->sdev = sdev; 1228 INIT_LIST_HEAD(&h->node); 1229 1230 mutex_init(&h->init_mutex); 1231 err = alua_initialize(sdev, h); 1232 if (err != SCSI_DH_OK && err != SCSI_DH_DEV_OFFLINED) 1233 goto failed; 1234 1235 sdev->handler_data = h; 1236 return SCSI_DH_OK; 1237 failed: 1238 kfree(h); 1239 return err; 1240 } 1241 1242 /* 1243 * alua_bus_detach - Detach device handler 1244 * @sdev: device to be detached from 1245 */ 1246 static void alua_bus_detach(struct scsi_device *sdev) 1247 { 1248 struct alua_dh_data *h = sdev->handler_data; 1249 struct alua_port_group *pg; 1250 1251 spin_lock(&h->pg_lock); 1252 pg = rcu_dereference_protected(h->pg, lockdep_is_held(&h->pg_lock)); 1253 rcu_assign_pointer(h->pg, NULL); 1254 spin_unlock(&h->pg_lock); 1255 if (pg) { 1256 spin_lock_irq(&pg->lock); 1257 list_del_rcu(&h->node); 1258 spin_unlock_irq(&pg->lock); 1259 kref_put(&pg->kref, release_port_group); 1260 } 1261 sdev->handler_data = NULL; 1262 synchronize_rcu(); 1263 kfree(h); 1264 } 1265 1266 static struct scsi_device_handler alua_dh = { 1267 .name = ALUA_DH_NAME, 1268 .module = THIS_MODULE, 1269 .attach = alua_bus_attach, 1270 .detach = alua_bus_detach, 1271 .prep_fn = alua_prep_fn, 1272 .check_sense = alua_check_sense, 1273 .activate = alua_activate, 1274 .rescan = alua_rescan, 1275 .set_params = alua_set_params, 1276 }; 1277 1278 static int __init alua_init(void) 1279 { 1280 int r; 1281 1282 kaluad_wq = alloc_workqueue("kaluad", WQ_MEM_RECLAIM, 0); 1283 if (!kaluad_wq) 1284 return -ENOMEM; 1285 1286 r = scsi_register_device_handler(&alua_dh); 1287 if (r != 0) { 1288 printk(KERN_ERR "%s: Failed to register scsi device handler", 1289 ALUA_DH_NAME); 1290 destroy_workqueue(kaluad_wq); 1291 } 1292 return r; 1293 } 1294 1295 static void __exit alua_exit(void) 1296 { 1297 scsi_unregister_device_handler(&alua_dh); 1298 destroy_workqueue(kaluad_wq); 1299 } 1300 1301 module_init(alua_init); 1302 module_exit(alua_exit); 1303 1304 MODULE_DESCRIPTION("DM Multipath ALUA support"); 1305 MODULE_AUTHOR("Hannes Reinecke <hare@suse.de>"); 1306 MODULE_LICENSE("GPL"); 1307 MODULE_VERSION(ALUA_DH_VER); 1308