1 /* 2 * Generic SCSI-3 ALUA SCSI Device Handler 3 * 4 * Copyright (C) 2007, 2008 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 <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 53 struct 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 68 static 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 75 static 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 90 static 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 * submit_std_inquiry - Issue a standard INQUIRY command 122 * @sdev: sdev the command should be send to 123 */ 124 static 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 /* Prepare the command. */ 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); 153 done: 154 return err; 155 } 156 157 /* 158 * submit_vpd_inquiry - Issue an INQUIRY VPD page 0x83 command 159 * @sdev: sdev the command should be sent to 160 */ 161 static 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 /* Prepare the command. */ 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); 190 done: 191 return err; 192 } 193 194 /* 195 * submit_rtpg - Issue a REPORT TARGET GROUP STATES command 196 * @sdev: sdev the command should be sent to 197 */ 198 static 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 /* Prepare the command. */ 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); 229 done: 230 return err; 231 } 232 233 /* 234 * submit_stpg - Issue a SET TARGET GROUP STATES command 235 * @sdev: sdev the command should be sent to 236 * 237 * Currently we're only setting the current target port group state 238 * to 'active/optimized' and let the array firmware figure out 239 * the states of the remaining groups. 240 */ 241 static 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 /* Prepare the data buffer */ 248 memset(h->buff, 0, stpg_len); 249 h->buff[4] = TPGS_STATE_OPTIMIZED & 0x0f; 250 h->buff[6] = (h->group_id >> 8) & 0x0f; 251 h->buff[7] = h->group_id & 0x0f; 252 253 rq = get_alua_req(sdev, h->buff, stpg_len, WRITE); 254 if (!rq) 255 goto done; 256 257 /* Prepare the command. */ 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); 279 done: 280 return err; 281 } 282 283 /* 284 * alua_std_inquiry - Evaluate standard INQUIRY command 285 * @sdev: device to be checked 286 * 287 * Just extract the TPGS setting to find out if ALUA 288 * is supported. 289 */ 290 static 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 /* Check TPGS setting */ 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 * alua_vpd_inquiry - Evaluate INQUIRY vpd page 0x83 328 * @sdev: device to be checked 329 * 330 * Extract the relative target port and the target port group 331 * descriptor from the list of identificators. 332 */ 333 static 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 /* Check if vpd page exceeds initial buffer */ 346 len = (h->buff[2] << 8) + h->buff[3] + 4; 347 if (len > h->bufflen) { 348 /* Resubmit with the correct length */ 349 if (realloc_buffer(h, len)) { 350 sdev_printk(KERN_WARNING, sdev, 351 "%s: kmalloc buffer failed\n", 352 ALUA_DH_NAME); 353 /* Temporary failure, bypass */ 354 return SCSI_DH_DEV_TEMP_BUSY; 355 } 356 goto retry; 357 } 358 359 /* 360 * Now look for the correct descriptor. 361 */ 362 d = h->buff + 4; 363 while (d < h->buff + len) { 364 switch (d[1] & 0xf) { 365 case 0x4: 366 /* Relative target port */ 367 h->rel_port = (d[6] << 8) + d[7]; 368 break; 369 case 0x5: 370 /* Target port group */ 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 * Internal error; TPGS supported but required 382 * VPD identification descriptors not present. 383 * Disable ALUA support 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 400 static 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 420 static 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 * LUN Not Accessible - ALUA state transition 428 */ 429 return ADD_TO_MLQUEUE; 430 if (sense_hdr->asc == 0x04 && sense_hdr->ascq == 0x0b) 431 /* 432 * LUN Not Accessible -- Target port in standby state 433 */ 434 return SUCCESS; 435 if (sense_hdr->asc == 0x04 && sense_hdr->ascq == 0x0c) 436 /* 437 * LUN Not Accessible -- Target port in unavailable state 438 */ 439 return SUCCESS; 440 if (sense_hdr->asc == 0x04 && sense_hdr->ascq == 0x12) 441 /* 442 * LUN Not Ready -- Offline 443 */ 444 return SUCCESS; 445 break; 446 case UNIT_ATTENTION: 447 if (sense_hdr->asc == 0x29 && sense_hdr->ascq == 0x00) 448 /* 449 * Power On, Reset, or Bus Device Reset, just retry. 450 */ 451 return ADD_TO_MLQUEUE; 452 if (sense_hdr->asc == 0x2a && sense_hdr->ascq == 0x06) { 453 /* 454 * ALUA state changed 455 */ 456 return ADD_TO_MLQUEUE; 457 } 458 if (sense_hdr->asc == 0x2a && sense_hdr->ascq == 0x07) { 459 /* 460 * Implicit ALUA state transition failed 461 */ 462 return ADD_TO_MLQUEUE; 463 } 464 break; 465 } 466 467 return SCSI_RETURN_NOT_HANDLED; 468 } 469 470 /* 471 * alua_stpg - Evaluate SET TARGET GROUP STATES 472 * @sdev: the device to be evaluated 473 * @state: the new target group state 474 * 475 * Send a SET TARGET GROUP STATES command to the device. 476 * We only have to test here if we should resubmit the command; 477 * any other error is assumed as a failure. 478 */ 479 static int alua_stpg(struct scsi_device *sdev, int state, 480 struct alua_dh_data *h) 481 { 482 struct scsi_sense_hdr sense_hdr; 483 unsigned err; 484 int retry = ALUA_FAILOVER_RETRIES; 485 486 retry: 487 err = submit_stpg(sdev, h); 488 if (err == SCSI_DH_IO && h->senselen > 0) { 489 err = scsi_normalize_sense(h->sense, SCSI_SENSE_BUFFERSIZE, 490 &sense_hdr); 491 if (!err) 492 return SCSI_DH_IO; 493 err = alua_check_sense(sdev, &sense_hdr); 494 if (retry > 0 && err == ADD_TO_MLQUEUE) { 495 retry--; 496 goto retry; 497 } 498 sdev_printk(KERN_INFO, sdev, 499 "%s: stpg sense code: %02x/%02x/%02x\n", 500 ALUA_DH_NAME, sense_hdr.sense_key, 501 sense_hdr.asc, sense_hdr.ascq); 502 err = SCSI_DH_IO; 503 } 504 if (err == SCSI_DH_OK) { 505 h->state = state; 506 sdev_printk(KERN_INFO, sdev, 507 "%s: port group %02x switched to state %c\n", 508 ALUA_DH_NAME, h->group_id, 509 print_alua_state(h->state) ); 510 } 511 return err; 512 } 513 514 /* 515 * alua_rtpg - Evaluate REPORT TARGET GROUP STATES 516 * @sdev: the device to be evaluated. 517 * 518 * Evaluate the Target Port Group State. 519 * Returns SCSI_DH_DEV_OFFLINED if the path is 520 * found to be unuseable. 521 */ 522 static int alua_rtpg(struct scsi_device *sdev, struct alua_dh_data *h) 523 { 524 struct scsi_sense_hdr sense_hdr; 525 int len, k, off, valid_states = 0; 526 char *ucp; 527 unsigned err; 528 529 retry: 530 err = submit_rtpg(sdev, h); 531 532 if (err == SCSI_DH_IO && h->senselen > 0) { 533 err = scsi_normalize_sense(h->sense, SCSI_SENSE_BUFFERSIZE, 534 &sense_hdr); 535 if (!err) 536 return SCSI_DH_IO; 537 538 err = alua_check_sense(sdev, &sense_hdr); 539 if (err == ADD_TO_MLQUEUE) 540 goto retry; 541 sdev_printk(KERN_INFO, sdev, 542 "%s: rtpg sense code %02x/%02x/%02x\n", 543 ALUA_DH_NAME, sense_hdr.sense_key, 544 sense_hdr.asc, sense_hdr.ascq); 545 err = SCSI_DH_IO; 546 } 547 if (err != SCSI_DH_OK) 548 return err; 549 550 len = (h->buff[0] << 24) + (h->buff[1] << 16) + 551 (h->buff[2] << 8) + h->buff[3] + 4; 552 553 if (len > h->bufflen) { 554 /* Resubmit with the correct length */ 555 if (realloc_buffer(h, len)) { 556 sdev_printk(KERN_WARNING, sdev, 557 "%s: kmalloc buffer failed\n",__func__); 558 /* Temporary failure, bypass */ 559 return SCSI_DH_DEV_TEMP_BUSY; 560 } 561 goto retry; 562 } 563 564 for (k = 4, ucp = h->buff + 4; k < len; k += off, ucp += off) { 565 if (h->group_id == (ucp[2] << 8) + ucp[3]) { 566 h->state = ucp[0] & 0x0f; 567 valid_states = ucp[1]; 568 } 569 off = 8 + (ucp[7] * 4); 570 } 571 572 sdev_printk(KERN_INFO, sdev, 573 "%s: port group %02x state %c supports %c%c%c%c%c%c\n", 574 ALUA_DH_NAME, h->group_id, print_alua_state(h->state), 575 valid_states&TPGS_SUPPORT_TRANSITION?'T':'t', 576 valid_states&TPGS_SUPPORT_OFFLINE?'O':'o', 577 valid_states&TPGS_SUPPORT_UNAVAILABLE?'U':'u', 578 valid_states&TPGS_SUPPORT_STANDBY?'S':'s', 579 valid_states&TPGS_SUPPORT_NONOPTIMIZED?'N':'n', 580 valid_states&TPGS_SUPPORT_OPTIMIZED?'A':'a'); 581 582 if (h->tpgs & TPGS_MODE_EXPLICIT) { 583 switch (h->state) { 584 case TPGS_STATE_TRANSITIONING: 585 /* State transition, retry */ 586 goto retry; 587 break; 588 case TPGS_STATE_OFFLINE: 589 /* Path is offline, fail */ 590 err = SCSI_DH_DEV_OFFLINED; 591 break; 592 default: 593 break; 594 } 595 } else { 596 /* Only Implicit ALUA support */ 597 if (h->state == TPGS_STATE_OPTIMIZED || 598 h->state == TPGS_STATE_NONOPTIMIZED || 599 h->state == TPGS_STATE_STANDBY) 600 /* Useable path if active */ 601 err = SCSI_DH_OK; 602 else 603 /* Path unuseable for unavailable/offline */ 604 err = SCSI_DH_DEV_OFFLINED; 605 } 606 return err; 607 } 608 609 /* 610 * alua_initialize - Initialize ALUA state 611 * @sdev: the device to be initialized 612 * 613 * For the prep_fn to work correctly we have 614 * to initialize the ALUA state for the device. 615 */ 616 static int alua_initialize(struct scsi_device *sdev, struct alua_dh_data *h) 617 { 618 int err; 619 620 err = alua_std_inquiry(sdev, h); 621 if (err != SCSI_DH_OK) 622 goto out; 623 624 err = alua_vpd_inquiry(sdev, h); 625 if (err != SCSI_DH_OK) 626 goto out; 627 628 err = alua_rtpg(sdev, h); 629 if (err != SCSI_DH_OK) 630 goto out; 631 632 out: 633 return err; 634 } 635 636 /* 637 * alua_activate - activate a path 638 * @sdev: device on the path to be activated 639 * 640 * We're currently switching the port group to be activated only and 641 * let the array figure out the rest. 642 * There may be other arrays which require us to switch all port groups 643 * based on a certain policy. But until we actually encounter them it 644 * should be okay. 645 */ 646 static int alua_activate(struct scsi_device *sdev) 647 { 648 struct alua_dh_data *h = get_alua_data(sdev); 649 int err = SCSI_DH_OK; 650 651 if (h->group_id != -1) { 652 err = alua_rtpg(sdev, h); 653 if (err != SCSI_DH_OK) 654 goto out; 655 } 656 657 if (h->tpgs == TPGS_MODE_EXPLICIT && h->state != TPGS_STATE_OPTIMIZED) 658 err = alua_stpg(sdev, TPGS_STATE_OPTIMIZED, h); 659 660 out: 661 return err; 662 } 663 664 /* 665 * alua_prep_fn - request callback 666 * 667 * Fail I/O to all paths not in state 668 * active/optimized or active/non-optimized. 669 */ 670 static int alua_prep_fn(struct scsi_device *sdev, struct request *req) 671 { 672 struct alua_dh_data *h = get_alua_data(sdev); 673 int ret = BLKPREP_OK; 674 675 if (h->state != TPGS_STATE_OPTIMIZED && 676 h->state != TPGS_STATE_NONOPTIMIZED) { 677 ret = BLKPREP_KILL; 678 req->cmd_flags |= REQ_QUIET; 679 } 680 return ret; 681 682 } 683 684 static const struct scsi_dh_devlist alua_dev_list[] = { 685 {"HP", "MSA VOLUME" }, 686 {"HP", "HSV101" }, 687 {"HP", "HSV111" }, 688 {"HP", "HSV200" }, 689 {"HP", "HSV210" }, 690 {"HP", "HSV300" }, 691 {"IBM", "2107900" }, 692 {"IBM", "2145" }, 693 {"Pillar", "Axiom" }, 694 {NULL, NULL} 695 }; 696 697 static int alua_bus_attach(struct scsi_device *sdev); 698 static void alua_bus_detach(struct scsi_device *sdev); 699 700 static struct scsi_device_handler alua_dh = { 701 .name = ALUA_DH_NAME, 702 .module = THIS_MODULE, 703 .devlist = alua_dev_list, 704 .attach = alua_bus_attach, 705 .detach = alua_bus_detach, 706 .prep_fn = alua_prep_fn, 707 .check_sense = alua_check_sense, 708 .activate = alua_activate, 709 }; 710 711 /* 712 * alua_bus_attach - Attach device handler 713 * @sdev: device to be attached to 714 */ 715 static int alua_bus_attach(struct scsi_device *sdev) 716 { 717 struct scsi_dh_data *scsi_dh_data; 718 struct alua_dh_data *h; 719 unsigned long flags; 720 int err = SCSI_DH_OK; 721 722 scsi_dh_data = kzalloc(sizeof(struct scsi_device_handler *) 723 + sizeof(*h) , GFP_KERNEL); 724 if (!scsi_dh_data) { 725 sdev_printk(KERN_ERR, sdev, "%s: Attach failed\n", 726 ALUA_DH_NAME); 727 return -ENOMEM; 728 } 729 730 scsi_dh_data->scsi_dh = &alua_dh; 731 h = (struct alua_dh_data *) scsi_dh_data->buf; 732 h->tpgs = TPGS_MODE_UNINITIALIZED; 733 h->state = TPGS_STATE_OPTIMIZED; 734 h->group_id = -1; 735 h->rel_port = -1; 736 h->buff = h->inq; 737 h->bufflen = ALUA_INQUIRY_SIZE; 738 739 err = alua_initialize(sdev, h); 740 if (err != SCSI_DH_OK) 741 goto failed; 742 743 if (!try_module_get(THIS_MODULE)) 744 goto failed; 745 746 spin_lock_irqsave(sdev->request_queue->queue_lock, flags); 747 sdev->scsi_dh_data = scsi_dh_data; 748 spin_unlock_irqrestore(sdev->request_queue->queue_lock, flags); 749 750 return 0; 751 752 failed: 753 kfree(scsi_dh_data); 754 sdev_printk(KERN_ERR, sdev, "%s: not attached\n", ALUA_DH_NAME); 755 return -EINVAL; 756 } 757 758 /* 759 * alua_bus_detach - Detach device handler 760 * @sdev: device to be detached from 761 */ 762 static void alua_bus_detach(struct scsi_device *sdev) 763 { 764 struct scsi_dh_data *scsi_dh_data; 765 struct alua_dh_data *h; 766 unsigned long flags; 767 768 spin_lock_irqsave(sdev->request_queue->queue_lock, flags); 769 scsi_dh_data = sdev->scsi_dh_data; 770 sdev->scsi_dh_data = NULL; 771 spin_unlock_irqrestore(sdev->request_queue->queue_lock, flags); 772 773 h = (struct alua_dh_data *) scsi_dh_data->buf; 774 if (h->buff && h->inq != h->buff) 775 kfree(h->buff); 776 kfree(scsi_dh_data); 777 module_put(THIS_MODULE); 778 sdev_printk(KERN_NOTICE, sdev, "%s: Detached\n", ALUA_DH_NAME); 779 } 780 781 static int __init alua_init(void) 782 { 783 int r; 784 785 r = scsi_register_device_handler(&alua_dh); 786 if (r != 0) 787 printk(KERN_ERR "%s: Failed to register scsi device handler", 788 ALUA_DH_NAME); 789 return r; 790 } 791 792 static void __exit alua_exit(void) 793 { 794 scsi_unregister_device_handler(&alua_dh); 795 } 796 797 module_init(alua_init); 798 module_exit(alua_exit); 799 800 MODULE_DESCRIPTION("DM Multipath ALUA support"); 801 MODULE_AUTHOR("Hannes Reinecke <hare@suse.de>"); 802 MODULE_LICENSE("GPL"); 803 MODULE_VERSION(ALUA_DH_VER); 804