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