1 /* 2 * Copyright (c) 2007, 2010, Oracle and/or its affiliates. All rights reserved. 3 */ 4 5 /* 6 * BSD 3 Clause License 7 * 8 * Copyright (c) 2007, The Storage Networking Industry Association. 9 * 10 * Redistribution and use in source and binary forms, with or without 11 * modification, are permitted provided that the following conditions 12 * are met: 13 * - Redistributions of source code must retain the above copyright 14 * notice, this list of conditions and the following disclaimer. 15 * 16 * - Redistributions in binary form must reproduce the above copyright 17 * notice, this list of conditions and the following disclaimer in 18 * the documentation and/or other materials provided with the 19 * distribution. 20 * 21 * - Neither the name of The Storage Networking Industry Association (SNIA) 22 * nor the names of its contributors may be used to endorse or promote 23 * products derived from this software without specific prior written 24 * permission. 25 * 26 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" 27 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 28 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 29 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE 30 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR 31 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF 32 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS 33 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN 34 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 35 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE 36 * POSSIBILITY OF SUCH DAMAGE. 37 */ 38 #include <sys/errno.h> 39 #include <sys/types.h> 40 #include <stdlib.h> 41 #include <unistd.h> 42 #include <ctype.h> 43 #include <sys/byteorder.h> 44 #include <sys/scsi/impl/uscsi.h> 45 #include <sys/scsi/scsi.h> 46 #include <tlm.h> 47 #include <pthread.h> 48 #include "tlm_proto.h" 49 50 /* 51 * generic routine to read a SCSI page 52 */ 53 int 54 read_scsi_page(scsi_link_t *slink, union scsi_cdb *cdb, 55 int command_size, caddr_t data, int size) 56 { 57 struct uscsi_cmd uscsi_cmd; 58 char *dname; 59 int dev; 60 61 if (slink == 0 || slink->sl_sa == 0) 62 return (EINVAL); 63 64 (void) memset(&uscsi_cmd, 0, sizeof (uscsi_cmd)); 65 66 /* Lun is in the 5th bit */ 67 cdb->scc_lun = slink->sl_lun; 68 uscsi_cmd.uscsi_flags |= USCSI_READ | USCSI_ISOLATE; 69 uscsi_cmd.uscsi_bufaddr = data; 70 uscsi_cmd.uscsi_buflen = size; 71 uscsi_cmd.uscsi_timeout = 1000; 72 uscsi_cmd.uscsi_cdb = (char *)cdb; 73 74 if (cdb->scc_cmd == SCMD_READ_ELEMENT_STATUS) { 75 uscsi_cmd.uscsi_flags |= USCSI_RQENABLE; 76 uscsi_cmd.uscsi_rqbuf = data; 77 uscsi_cmd.uscsi_rqlen = size; 78 } 79 uscsi_cmd.uscsi_cdblen = command_size; 80 81 dname = sasd_slink_name(slink); 82 dev = open(dname, O_RDWR | O_NDELAY); 83 if (dev == -1) { 84 NDMP_LOG(LOG_DEBUG, "Open failed for %s err=%d", 85 dname, errno); 86 return (errno); 87 } 88 if (tlm_ioctl(dev, USCSICMD, &uscsi_cmd) < 0) { 89 NDMP_LOG(LOG_DEBUG, "SCSI cmd %d failed for %s err=%d", 90 cdb->scc_cmd, dname, errno); 91 (void) close(dev); 92 return (errno); 93 } 94 (void) close(dev); 95 return (uscsi_cmd.uscsi_status); 96 } 97 98 /* 99 * Read the Inquiry Page. 100 */ 101 static int 102 read_inquiry_page(scsi_link_t *slink, struct scsi_inquiry *inq) 103 { 104 union scsi_cdb cdb; 105 106 (void) memset(&cdb, 0, sizeof (union scsi_cdb)); 107 cdb.scc_cmd = SCMD_INQUIRY; 108 cdb.g0_count0 = sizeof (struct scsi_inquiry); 109 110 return (read_scsi_page(slink, &cdb, CDB_GROUP0, 111 (caddr_t)inq, sizeof (*inq)) ? -1 : 0); 112 } 113 114 /* 115 * Read the Product Data Page. 116 */ 117 static int 118 read_data_page(scsi_link_t *slink, int pcode, char *snum, int size) 119 { 120 char cmd[CDB_GROUP0]; 121 122 (void) memset(cmd, 0, sizeof (cmd)); 123 124 cmd[0] = SCMD_INQUIRY; 125 cmd[1] = pcode ? 0x01 : 0x00; 126 cmd[2] = pcode; 127 cmd[4] = size; 128 129 /* LINTED improper alignment */ 130 return (read_scsi_page(slink, (union scsi_cdb *)&cmd, CDB_GROUP0, 131 (caddr_t)snum, size) == -1 ? -1 : 0); 132 } 133 134 135 /* 136 * Read the Serial Number Page. 137 */ 138 static int 139 read_serial_num_page(scsi_link_t *slink, char *snum, int size) 140 { 141 scsi_serial_t serial; 142 int rv; 143 144 (void) memset(&serial, 0, sizeof (scsi_serial_t)); 145 rv = read_data_page(slink, SCSI_SERIAL_PAGE, (caddr_t)&serial, 146 sizeof (scsi_serial_t)); 147 (void) strlcpy(snum, serial.sr_num, size); 148 149 return (rv == -1 ? -1 : 0); 150 } 151 152 153 /* 154 * Read the Device Name Page. 155 */ 156 static int 157 read_dev_name_page(scsi_link_t *slink, device_ident_header_t *devp, int len) 158 { 159 (void) memset(devp, 0, len); 160 161 if (read_data_page(slink, SCSI_DEVICE_IDENT_PAGE, (caddr_t)devp, 162 len) == -1) 163 return (-1); 164 165 if (devp->di_page_code != SCSI_DEVICE_IDENT_PAGE) 166 return (-1); 167 168 return (0); 169 } 170 171 /* 172 * Formatted print of WWN 173 */ 174 static void 175 snprintf_wwn(char *buf, int size, uint8_t *wwn) 176 { 177 if (wwn == NULL || buf == NULL) 178 return; 179 180 (void) snprintf(buf, size, "0x%2.2X%2.2X%2.2X%2.2X%2.2X%2.2X%2.2X%2.2X", 181 wwn[0], wwn[1], wwn[2], wwn[3], wwn[4], wwn[5], wwn[6], wwn[7]); 182 } 183 184 185 /* 186 * Extract and print the world wide name (WWN) 187 */ 188 int 189 read_device_wwn(scsi_link_t *slink, char *wwnp, int wsize) 190 { 191 device_ident_header_t *header; 192 name_ident_t *ident; 193 uint16_t page_len = sizeof (device_ident_header_t); 194 uint16_t act_len; 195 int accessed; 196 uint8_t *designator_data; 197 198 (void) memset(wwnp, 0, wsize); 199 resize: 200 header = malloc(page_len); 201 if (header == NULL) 202 return (-1); 203 204 if (read_dev_name_page(slink, header, page_len) == -1) { 205 free(header); 206 return (-1); 207 } 208 209 act_len = BE_16(header->di_page_length); 210 if (act_len > page_len) { 211 free(header); 212 page_len = act_len; 213 goto resize; 214 } 215 216 ident = (name_ident_t *)&header[1]; 217 accessed = sizeof (device_ident_header_t); 218 219 while (accessed < act_len) { 220 221 accessed += sizeof (name_ident_t); 222 accessed += ident->ni_ident_length; 223 designator_data = (uint8_t *)&ident[1]; 224 /* 225 * Looking for code set 1 (Binary) ident type NAA 64 bit 226 * address that is associated with the node (0). 227 */ 228 if ((ident->ni_code_set == 1) && 229 (ident->ni_ident_type == 3)) { 230 snprintf_wwn(wwnp, wsize, designator_data); 231 /* 232 * If assc is zero (Node) this is the one we want. 233 * If we find that we're done. 234 */ 235 if (ident->ni_asso == 0) 236 break; 237 } 238 /* 239 * If we find a EUI-64 we can use that also. 240 */ 241 if ((ident->ni_code_set == 2) && 242 (ident->ni_ident_type == 1) && 243 (ident->ni_asso == 0) && 244 (isprint(wwnp[0] == 0))) { /* Don't overwrite */ 245 /* 246 * This isn't our first choice but we'll print it 247 * in case there is nothing else to use. 248 */ 249 (void) snprintf(wwnp, wsize, "%.*s", 250 ident->ni_ident_length, designator_data); 251 } 252 ident = 253 (name_ident_t *)&designator_data[ident->ni_ident_length]; 254 } 255 free(header); 256 /* 257 * See if we found something. 258 * Memset above would leave wwnp not printable. 259 */ 260 if (isprint(wwnp[0])) 261 return (0); 262 return (-1); 263 } 264 265 /* 266 * Add the tape library call back function (used while scanning the bus) 267 */ 268 static int 269 add_lib(scsi_link_t *slink, struct scsi_inquiry *sd, void *arg) 270 { 271 int l; 272 int *nlp; /* pointer to library counter */ 273 sasd_drive_t *ssd; 274 275 if (!slink || !sd) { 276 NDMP_LOG(LOG_DEBUG, "Invalid argument %x %x %x", 277 slink, sd, arg); 278 return (-TLM_INVALID); 279 } 280 281 if (sd->inq_dtype == DTYPE_CHANGER) { 282 /* This is a robot, which means this is also a library */ 283 nlp = (int *)arg; 284 (*nlp)++; 285 l = tlm_insert_new_library(slink); 286 tlm_enable_barcode(l); 287 288 NDMP_LOG(LOG_DEBUG, "lib %d sid %d lun %d", 289 l, slink->sl_sid, slink->sl_lun); 290 291 if ((ssd = sasd_slink_drive(slink)) != NULL) { 292 (void) strlcpy(ssd->sd_vendor, sd->inq_vid, 293 sizeof (ssd->sd_vendor)); 294 (void) strlcpy(ssd->sd_id, sd->inq_pid, 295 sizeof (ssd->sd_id)); 296 (void) strlcpy(ssd->sd_rev, sd->inq_revision, 297 sizeof (ssd->sd_rev)); 298 (void) read_serial_num_page(slink, ssd->sd_serial, 299 sizeof (ssd->sd_serial)); 300 (void) read_device_wwn(slink, ssd->sd_wwn, 301 sizeof (ssd->sd_wwn)); 302 } 303 } 304 305 return (TLM_NO_ERRORS); 306 } 307 308 /* 309 * Create some virutal slots 310 */ 311 static int 312 make_virtual_slot(int l, tlm_drive_t *dp) 313 { 314 int s; 315 tlm_slot_t *sp; 316 317 if (l <= 0 || !dp) { 318 NDMP_LOG(LOG_DEBUG, "Invalid argument %d, %x", l, dp); 319 return (-TLM_INVALID); 320 } 321 322 if ((s = tlm_insert_new_slot(l)) <= 0) 323 return (-TLM_NO_MEMORY); 324 325 if (!(sp = tlm_slot(l, s))) { 326 NDMP_LOG(LOG_DEBUG, "Internal error: slot not found %d", s); 327 return (-TLM_ERROR_INTERNAL); 328 } 329 /* 330 * For virtual slots element number is 0 and they are always full. 331 */ 332 sp->ts_element = 0; 333 sp->ts_status_full = TRUE; 334 return (TLM_NO_ERRORS); 335 } 336 337 /* 338 * Make the tape drive not part of a tape library (stand alone) 339 */ 340 static int 341 make_stand_alone_drive(scsi_link_t *slink, int l) 342 { 343 int d; 344 tlm_drive_t *dp; 345 346 if (!slink || l <= 0) { 347 NDMP_LOG(LOG_DEBUG, "Invalid argument %x %d", slink, l); 348 return (-TLM_INVALID); 349 } 350 351 d = tlm_insert_new_drive(l); 352 if (!(dp = tlm_drive(l, d))) { 353 NDMP_LOG(LOG_DEBUG, "Internal error: drive not found %d", d); 354 return (-TLM_ERROR_INTERNAL); 355 } 356 357 /* For stand-alone drives, the element number is the drive number. */ 358 dp->td_element = d; 359 dp->td_slink = slink; 360 dp->td_scsi_id = slink->sl_sid; 361 dp->td_lun = slink->sl_lun; 362 dp->td_exists = TRUE; 363 364 /* 365 * Note: There is no way to remove library elements. We cannot clean 366 * up if make_virtual_slot() fails. 367 */ 368 (void) make_virtual_slot(l, dp); 369 return (d); 370 } 371 372 /* 373 * Find the LIBRARY structure that has control of this DRIVE. 374 */ 375 static int 376 new_drive(scsi_link_t *slink, int *lib) 377 { 378 int d; 379 tlm_drive_t *dp; 380 tlm_library_t *lp; 381 382 /* Walk through all libraries. */ 383 for (*lib = 1; *lib <= tlm_library_count(); (*lib)++) { 384 if (!(lp = tlm_library(*lib))) 385 continue; 386 /* Walk through drives that are already found. */ 387 for (d = 1; d <= lp->tl_drive_count; d++) { 388 if (!(dp = tlm_drive(*lib, d))) 389 continue; 390 if (dp->td_scsi_id == slink->sl_sid && 391 dp->td_lun == slink->sl_lun) 392 return (d); 393 } 394 } 395 396 /* Not part of any library, this is a newly found tape drive. */ 397 return (0); 398 } 399 400 401 /* 402 * Add the tape library call back function (used while scanning the bus) 403 */ 404 static int 405 add_drv(scsi_link_t *slink, struct scsi_inquiry *sd, void *arg) 406 { 407 int l, d; 408 int *vlp; /* pointer to virtual library number */ 409 sasd_drive_t *ssd; 410 tlm_library_t *library; 411 tlm_drive_t *drive; 412 413 if (!slink || !sd) { 414 NDMP_LOG(LOG_DEBUG, "Invalid argument %x %x %x", 415 slink, sd, arg); 416 return (-TLM_INVALID); 417 } 418 419 if (sd->inq_dtype == DTYPE_SEQUENTIAL) { 420 vlp = (int *)arg; 421 d = new_drive(slink, &l); 422 if (d == 0) { 423 /* This tape drive was not found inside any robot. */ 424 if (*vlp == 0) { 425 /* 426 * First, create a virtual library if it's not 427 * done yet. 428 */ 429 *vlp = tlm_insert_new_library(slink); 430 if ((library = tlm_library(*vlp)) != NULL) 431 library->tl_capability_robot = FALSE; 432 } 433 if ((d = make_stand_alone_drive(slink, *vlp)) < 0) { 434 /* sorry, we can not clean up the vlib now * */ 435 return (-TLM_INVALID); 436 } 437 l = *vlp; 438 NDMP_LOG(LOG_DEBUG, "vlib(%d, %d) sid %d lun %d", 439 l, d, slink->sl_sid, slink->sl_lun); 440 } else 441 NDMP_LOG(LOG_DEBUG, "(%d, %d) sid %d lun %d", 442 l, d, slink->sl_sid, slink->sl_lun); 443 444 if ((drive = tlm_drive(l, d)) != NULL) { 445 drive->td_exists = TRUE; 446 drive->td_slink = slink; 447 } 448 if ((ssd = sasd_slink_drive(slink)) != NULL) { 449 (void) strlcpy(ssd->sd_vendor, 450 sd->inq_vid, sizeof (ssd->sd_vendor)); 451 (void) strlcpy(ssd->sd_id, sd->inq_pid, 452 sizeof (ssd->sd_id)); 453 (void) strlcpy(ssd->sd_rev, sd->inq_revision, 454 sizeof (ssd->sd_rev)); 455 (void) read_serial_num_page(slink, ssd->sd_serial, 456 sizeof (ssd->sd_serial)); 457 (void) read_device_wwn(slink, ssd->sd_wwn, 458 sizeof (ssd->sd_wwn)); 459 } 460 } 461 462 return (TLM_NO_ERRORS); 463 } 464 465 /* 466 * Scan the specified bus and call the handler function. 467 */ 468 static int 469 scan_bus(scsi_adapter_t *sa, int(*hndlr)(), void *args) 470 { 471 int nerr; 472 scsi_link_t *slink; 473 struct scsi_inquiry scsi_data; 474 475 nerr = 0; 476 slink = sa->sa_link_head.sl_next; 477 for (; slink != &sa->sa_link_head; slink = slink->sl_next) { 478 (void) memset(&scsi_data, 0, sizeof (struct scsi_inquiry)); 479 if (read_inquiry_page(slink, &scsi_data) == -1) 480 nerr++; 481 else 482 if ((*hndlr)(slink, &scsi_data, args) != TLM_NO_ERRORS) 483 nerr++; 484 } 485 486 return (nerr); 487 } 488 489 /* 490 * Marks the library/slots inaccessible if there are not enough drives 491 * available on the library 492 */ 493 static void 494 inaccbl_drv_warn(int start, int max) 495 { 496 char *dname; 497 int l, d; 498 tlm_library_t *lp; 499 500 for (l = start; l < max; l++) { 501 if (!(lp = tlm_library(l))) 502 continue; 503 if (lp->tl_drive_count <= 0) 504 continue; 505 506 NDMP_LOG(LOG_DEBUG, 507 "Warning: The following drives are not accessible:"); 508 for (d = 1; d <= lp->tl_drive_count; d++) 509 if (!(dname = tlm_get_tape_name(l, d))) { 510 NDMP_LOG(LOG_DEBUG, 511 "Error getting drive(%d, %d)", l, d); 512 } else 513 NDMP_LOG(LOG_DEBUG, "%s", dname); 514 515 /* 516 * Note: Make the slots inaccessible to prevent running 517 * discovery on these libraries. The better idea is 518 * removing these libraries, but we don't have that 519 * feature available now. 520 */ 521 lp->tl_slot_count = 0; 522 } 523 } 524 525 /* 526 * Initialize the tape library data structure, asks the libraries what 527 * equipments they have. 528 */ 529 int 530 tlm_init(void) 531 { 532 static int nlibs; /* number of found libraries */ 533 int i, nsa; 534 int l, vlibs, d; 535 int rv; 536 scsi_adapter_t *sa; 537 tlm_library_t *lp; 538 tlm_drive_t *dp; 539 540 /* Search through all SCSI adapters, look for tape robots. */ 541 nlibs = 0; 542 543 /* 544 * We probe both changers and tape drives here 545 * but later on this needs to be removed as the 546 * probe will happen somewhere else. 547 */ 548 if (probe_scsi() < 0) 549 return (-1); 550 551 nsa = scsi_get_adapter_count(); 552 for (i = 0; i < nsa; i++) 553 if ((sa = scsi_get_adapter(i))) 554 (void) scan_bus(sa, add_lib, (void *)&nlibs); 555 556 NDMP_LOG(LOG_DEBUG, "nlibs %d", nlibs); 557 558 /* Search through all SCSI adapters, look for tape drives. */ 559 vlibs = 0; 560 for (i = 0; i < nsa; i++) 561 if ((sa = scsi_get_adapter(i))) 562 (void) scan_bus(sa, add_drv, (void *)&vlibs); 563 564 NDMP_LOG(LOG_DEBUG, "vlibs %d", vlibs); 565 566 if (nlibs > 0 && vlibs > 0) 567 inaccbl_drv_warn(nlibs + 1, vlibs + nlibs + 1); 568 569 for (l = 1; l <= tlm_library_count(); l++) { 570 if (!(lp = tlm_library(l))) { 571 NDMP_LOG(LOG_DEBUG, "can't find lib %d", l); 572 continue; 573 } 574 575 /* 576 * Make sure all libraries have tape drives. 577 */ 578 if (lp->tl_drive_count == 0) 579 continue; 580 581 /* 582 * Make sure all tape drives exist. A drive that is not 583 * linked into the SCSI chain will be seen by the library 584 * but we cannot talk to it. 585 */ 586 for (d = 1; d <= lp->tl_drive_count; d++) { 587 dp = tlm_drive(l, d); 588 if (dp && !dp->td_exists) { 589 NDMP_LOG(LOG_DEBUG, "Ghost drive found %d.%d", 590 l, d); 591 lp->tl_ghost_drives = TRUE; 592 continue; 593 } 594 } 595 } 596 597 if (nlibs > 0) 598 rv = (vlibs > 0) ? 0 : nlibs; 599 else 600 rv = vlibs; 601 602 return (rv); 603 } 604