1 /* 2 * CDDL HEADER START 3 * 4 * The contents of this file are subject to the terms of the 5 * Common Development and Distribution License (the "License"). 6 * You may not use this file except in compliance with the License. 7 * 8 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE 9 * or http://www.opensolaris.org/os/licensing. 10 * See the License for the specific language governing permissions 11 * and limitations under the License. 12 * 13 * When distributing Covered Code, include this CDDL HEADER in each 14 * file and include the License file at usr/src/OPENSOLARIS.LICENSE. 15 * If applicable, add the following below this CDDL HEADER, with the 16 * fields enclosed by brackets "[]" replaced with your own identifying 17 * information: Portions Copyright [yyyy] [name of copyright owner] 18 * 19 * CDDL HEADER END 20 */ 21 /* 22 * Copyright 2006 Sun Microsystems, Inc. All rights reserved. 23 * Use is subject to license terms. 24 */ 25 26 #pragma ident "%Z%%M% %I% %E% SMI" 27 28 #include <stdio.h> 29 #include <string.h> 30 #include <stdlib.h> 31 #include <unistd.h> 32 #include <sys/param.h> 33 #include <errno.h> 34 #include <sys/types.h> 35 #include <dirent.h> 36 #include <libdevinfo.h> 37 #include <fcntl.h> 38 #include <sys/types.h> 39 #include <sys/stat.h> 40 #include <sys/pci.h> 41 #include <sys/biosdisk.h> 42 43 44 /* 45 * structure used for searching device tree for a node matching 46 * pci bus/dev/fn 47 */ 48 typedef struct pcibdf { 49 int busnum; 50 int devnum; 51 int funcnum; 52 di_node_t di_node; 53 } pcibdf_t; 54 55 /* 56 * structure used for searching device tree for a node matching 57 * USB serial number. 58 */ 59 typedef struct { 60 uint64_t serialno; 61 di_node_t node; 62 } usbser_t; 63 64 /* 65 * structure for holding the mapping info 66 */ 67 typedef struct { 68 int disklist_index; /* index to disk_list of the mapped path */ 69 int matchcount; /* number of matches per this device number */ 70 } mapinfo_t; 71 72 #define DEVFS_PREFIX "/devices" 73 #define DISKS_LIST_INCR 20 /* increment for resizing disk_list */ 74 75 #define BIOSPROPNAME_TMPL "biosdev-0x%x" 76 #define BIOSPROPNAME_TMPL_LEN 13 77 #define BIOSDEV_NUM 8 78 #define STARTING_DRVNUM 0x80 79 80 /* 81 * array to hold mappings. Element at index X corresponds to BIOS device 82 * number 0x80 + X 83 */ 84 static mapinfo_t mapinfo[BIOSDEV_NUM]; 85 86 /* 87 * Cache copy of kernel device tree snapshot root handle, includes devices 88 * that are detached 89 */ 90 static di_node_t root_node = DI_NODE_NIL; 91 92 /* 93 * kernel device tree snapshot with currently attached devices. Detached 94 * devices are not included. 95 */ 96 static di_node_t root_allnode = DI_NODE_NIL; 97 98 /* 99 * handle to retrieve prom properties 100 */ 101 102 static di_prom_handle_t prom_hdl = DI_PROM_HANDLE_NIL; 103 104 static char **disk_list = NULL; /* array of physical device pathnames */ 105 static int disk_list_len = 0; /* length of disk_list */ 106 static int disk_list_valid = 0; /* number of valid entries in disk_list */ 107 108 static int debug = 0; /* used for enabling debug output */ 109 110 111 /* Local function prototypes */ 112 static void new_disk_list_entry(di_node_t node); 113 static int i_disktype(di_node_t node, di_minor_t minor, void *arg); 114 static void build_disk_list(); 115 static int search_disklist_match_path(char *path); 116 static void free_disks(); 117 static void cleanup_and_exit(int); 118 119 static int match_edd(biosdev_data_t *bd); 120 static int match_first_block(biosdev_data_t *bd); 121 122 static di_node_t search_tree_match_pcibdf(di_node_t node, int bus, int dev, 123 int fn); 124 static int i_match_pcibdf(di_node_t node, void *arg); 125 126 static di_node_t search_tree_match_usbserialno(di_node_t node, 127 uint64_t serialno); 128 static int i_match_usbserialno(di_node_t node, void *arg); 129 130 static di_node_t search_children_match_busaddr(di_node_t node, 131 char *matchbusaddr); 132 133 134 135 static void 136 new_disk_list_entry(di_node_t node) 137 { 138 size_t newsize; 139 char **newlist; 140 int newlen; 141 char *devfspath; 142 143 if (disk_list_valid >= disk_list_len) { 144 /* valid should never really be larger than len */ 145 /* if they are equal we need to init or realloc */ 146 newlen = disk_list_len + DISKS_LIST_INCR; 147 newsize = newlen * sizeof (*disk_list); 148 149 newlist = (char **)realloc(disk_list, newsize); 150 if (newlist == NULL) { 151 (void) printf("realloc failed to resize disk table\n"); 152 cleanup_and_exit(1); 153 } 154 disk_list = newlist; 155 disk_list_len = newlen; 156 } 157 158 devfspath = di_devfs_path(node); 159 disk_list[disk_list_valid] = devfspath; 160 if (debug) 161 (void) printf("adding %s\n", devfspath); 162 disk_list_valid++; 163 } 164 165 /* ARGSUSED */ 166 static int 167 i_disktype(di_node_t node, di_minor_t minor, void *arg) 168 { 169 char *minortype; 170 171 if (di_minor_spectype(minor) == S_IFCHR) { 172 minortype = di_minor_nodetype(minor); 173 174 /* exclude CD's */ 175 if (strncmp(minortype, DDI_NT_CD, sizeof (DDI_NT_CD) - 1) != 0) 176 /* only take p0 raw device */ 177 if (strcmp(di_minor_name(minor), "q,raw") == 0) 178 new_disk_list_entry(node); 179 } 180 return (DI_WALK_CONTINUE); 181 } 182 183 static void 184 build_disk_list() 185 { 186 int ret; 187 ret = di_walk_minor(root_node, DDI_NT_BLOCK, 0, NULL, 188 i_disktype); 189 if (ret != 0) { 190 (void) fprintf(stderr, "di_walk_minor failed errno %d\n", 191 errno); 192 cleanup_and_exit(1); 193 } 194 } 195 196 static void 197 free_disks() 198 { 199 int i; 200 201 if (disk_list) { 202 for (i = 0; i < disk_list_valid; i++) 203 di_devfs_path_free(disk_list[i]); 204 205 free(disk_list); 206 } 207 } 208 209 static int 210 i_match_pcibdf(di_node_t node, void *arg) 211 { 212 pcibdf_t *pbp; 213 int len; 214 uint32_t regval; 215 uint32_t busnum, funcnum, devicenum; 216 char *devtype; 217 uint32_t *regbuf = NULL; 218 di_node_t parentnode; 219 220 pbp = (pcibdf_t *)arg; 221 222 parentnode = di_parent_node(node); 223 224 len = di_prop_lookup_strings(DDI_DEV_T_ANY, parentnode, 225 "device_type", (char **)&devtype); 226 227 if ((len <= 0) || 228 ((strcmp(devtype, "pci") != 0) && (strcmp(devtype, "pciex") != 0))) 229 return (DI_WALK_CONTINUE); 230 231 len = di_prop_lookup_ints(DDI_DEV_T_ANY, node, "reg", 232 (int **)®buf); 233 234 if (len <= 0) { 235 /* Try PROM property */ 236 len = di_prom_prop_lookup_ints(prom_hdl, node, "reg", 237 (int **)®buf); 238 } 239 240 241 if (len > 0) { 242 regval = regbuf[0]; 243 244 busnum = PCI_REG_BUS_G(regval); 245 devicenum = PCI_REG_DEV_G(regval); 246 funcnum = PCI_REG_FUNC_G(regval); 247 248 if ((busnum == pbp->busnum) && 249 (devicenum == pbp->devnum) && 250 (funcnum == pbp->funcnum)) { 251 /* found it */ 252 pbp->di_node = node; 253 return (DI_WALK_TERMINATE); 254 } 255 } 256 257 return (DI_WALK_CONTINUE); 258 } 259 260 static di_node_t 261 search_tree_match_pcibdf(di_node_t node, int bus, int dev, int fn) 262 { 263 pcibdf_t pb; 264 pb.busnum = bus; 265 pb.devnum = dev; 266 pb.funcnum = fn; 267 pb.di_node = DI_NODE_NIL; 268 269 (void) di_walk_node(node, DI_WALK_CLDFIRST, &pb, i_match_pcibdf); 270 return (pb.di_node); 271 272 } 273 274 static int 275 i_match_usbserialno(di_node_t node, void *arg) 276 { 277 int len; 278 char *serialp; 279 usbser_t *usbsp; 280 281 usbsp = (usbser_t *)arg; 282 283 len = di_prop_lookup_bytes(DDI_DEV_T_ANY, node, "usb-serialno", 284 (uchar_t **)&serialp); 285 286 if ((len > 0) && (strncmp((char *)&usbsp->serialno, serialp, 287 sizeof (uint64_t)) == 0)) { 288 usbsp->node = node; 289 return (DI_WALK_TERMINATE); 290 } 291 return (DI_WALK_CONTINUE); 292 } 293 294 static di_node_t 295 search_tree_match_usbserialno(di_node_t node, uint64_t serialno) 296 { 297 298 usbser_t usbs; 299 300 usbs.serialno = serialno; 301 usbs.node = DI_NODE_NIL; 302 303 (void) di_walk_node(node, DI_WALK_CLDFIRST, &usbs, i_match_usbserialno); 304 return (usbs.node); 305 } 306 307 /* 308 * returns the index to the disklist to the disk with matching path 309 */ 310 static int 311 search_disklist_match_path(char *path) 312 { 313 int i; 314 for (i = 0; i < disk_list_valid; i++) 315 if (strcmp(disk_list[i], path) == 0) { 316 return (i); 317 } 318 return (-1); 319 } 320 321 /* 322 * Find first child of 'node' whose unit address is 'matchbusaddr' 323 */ 324 static di_node_t 325 search_children_match_busaddr(di_node_t node, char *matchbusaddr) 326 { 327 di_node_t cnode; 328 char *busaddr; 329 330 if (matchbusaddr == NULL) 331 return (DI_NODE_NIL); 332 333 334 for (cnode = di_child_node(node); cnode != DI_NODE_NIL; 335 cnode = di_sibling_node(cnode)) { 336 busaddr = di_bus_addr(cnode); 337 if (busaddr == NULL) 338 continue; 339 if (strncmp(busaddr, matchbusaddr, MAXNAMELEN) == 0) 340 break; 341 } 342 return (cnode); 343 } 344 345 /* 346 * Construct a physical device pathname from EDD and verify the 347 * path exists. Return the index of in disk_list for the mapped 348 * path on success, -1 on failure. 349 */ 350 static int 351 match_edd(biosdev_data_t *bdata) 352 { 353 di_node_t node, cnode = DI_NODE_NIL; 354 char *devfspath = NULL; 355 fn48_t *bd; 356 int index; 357 char busaddrbuf[MAXNAMELEN]; 358 359 if (!bdata->edd_valid) { 360 if (debug) 361 (void) printf("edd not valid\n"); 362 return (-1); 363 } 364 365 bd = &bdata->fn48_dev_params; 366 367 if (bd->magic != 0xBEDD || bd->pathinfo_len == 0) { 368 /* EDD extensions for devicepath not present */ 369 if (debug) 370 (void) printf("magic not valid %x pathinfolen %d\n", 371 bd->magic, bd->pathinfo_len); 372 return (-1); 373 } 374 375 /* we handle only PCI scsi, ata or sata for now */ 376 if (strncmp(bd->bustype, "PCI", 3) != 0) { 377 if (debug) 378 (void) printf("was not pci %s\n", bd->bustype); 379 return (-1); 380 } 381 if (debug) 382 (void) printf("match_edd bdf %d %d %d\n", 383 bd->interfacepath.pci.bus, 384 bd->interfacepath.pci.device, 385 bd->interfacepath.pci.function); 386 387 /* look into devinfo tree and find a node with matching pci b/d/f */ 388 node = search_tree_match_pcibdf(root_node, bd->interfacepath.pci.bus, 389 bd->interfacepath.pci.device, bd->interfacepath.pci.function); 390 391 if (node == DI_NODE_NIL) { 392 if (debug) 393 (void) printf(" could not find a node in tree " 394 "matching bdf\n"); 395 return (-1); 396 } 397 398 if (debug) 399 (void) printf("interface type %s pci channel %x target %x\n", 400 bd->interface_type, bd->interfacepath.pci.channel, 401 bd->devicepath.scsi.target); 402 403 if (strncmp(bd->interface_type, "SCSI", 4) == 0) { 404 405 (void) snprintf(busaddrbuf, MAXNAMELEN, "%x,%x", 406 bd->devicepath.scsi.target, bd->devicepath.scsi.lun_lo); 407 408 cnode = search_children_match_busaddr(node, busaddrbuf); 409 410 } else if ((strncmp(bd->interface_type, "ATAPI", 5) == 0) || 411 (strncmp(bd->interface_type, "ATA", 3) == 0) || 412 (strncmp(bd->interface_type, "SATA", 4) == 0)) { 413 414 if (strncmp(di_node_name(node), "pci-ide", 7) == 0) { 415 /* 416 * Legacy using pci-ide 417 * the child should be ide@<x>, where x is 418 * the channel number 419 */ 420 (void) snprintf(busaddrbuf, MAXNAMELEN, "%d", 421 bd->interfacepath.pci.channel); 422 423 if ((cnode = search_children_match_busaddr(node, 424 busaddrbuf)) != DI_NODE_NIL) { 425 426 (void) snprintf(busaddrbuf, MAXNAMELEN, "%x,0", 427 bd->devicepath.ata.chan); 428 cnode = search_children_match_busaddr(cnode, 429 busaddrbuf); 430 431 if (cnode == DI_NODE_NIL) 432 if (debug) 433 (void) printf("Interface %s " 434 "using pci-ide no " 435 "grandchild at %s\n", 436 bd->interface_type, 437 busaddrbuf); 438 } else { 439 if (debug) 440 (void) printf("Interface %s using " 441 "pci-ide, with no child at %s\n", 442 bd->interface_type, busaddrbuf); 443 } 444 } else { 445 if (strncmp(bd->interface_type, "SATA", 4) == 0) { 446 /* 447 * The current EDD (EDD-2) spec does not 448 * address port number. This is work in 449 * progress. 450 * Interprete the first field of device path 451 * as port number. Needs to be revisited 452 * with port multiplier support. 453 */ 454 (void) snprintf(busaddrbuf, MAXNAMELEN, "%x,0", 455 bd->devicepath.ata.chan); 456 457 cnode = search_children_match_busaddr(node, 458 busaddrbuf); 459 } else { 460 if (debug) 461 (void) printf("Interface %s, not using" 462 " pci-ide\n", bd->interface_type); 463 } 464 } 465 466 } else if (strncmp(bd->interface_type, "USB", 3) == 0) { 467 cnode = search_tree_match_usbserialno(node, 468 bd->devicepath.usb.usb_serial_id); 469 } else { 470 if (debug) 471 (void) printf("sorry not supported interface %s\n", 472 bd->interface_type); 473 } 474 475 if (cnode != DI_NODE_NIL) { 476 devfspath = di_devfs_path(cnode); 477 index = search_disklist_match_path(devfspath); 478 di_devfs_path_free(devfspath); 479 if (index >= 0) 480 return (index); 481 } 482 483 return (-1); 484 } 485 486 /* 487 * For each disk in list of disks, compare the first block with the 488 * one from bdd. On the first match, return the index of path in 489 * disk_list. If none matched return -1. 490 */ 491 static int 492 match_first_block(biosdev_data_t *bd) 493 { 494 495 char diskpath[MAXPATHLEN]; 496 int fd; 497 char buf[512]; 498 ssize_t num_read; 499 int i; 500 501 if (!bd->first_block_valid) 502 return (-1); 503 504 for (i = 0; i < disk_list_valid; i++) { 505 (void) snprintf(diskpath, MAXPATHLEN, "%s/%s:q,raw", 506 DEVFS_PREFIX, disk_list[i]); 507 fd = open(diskpath, O_RDONLY); 508 if (fd < 0) { 509 (void) fprintf(stderr, "opening %s failed errno %d\n", 510 diskpath, errno); 511 continue; 512 } 513 num_read = read(fd, buf, 512); 514 if (num_read != 512) { 515 (void) printf("read only %d bytes from %s\n", num_read, 516 diskpath); 517 continue; 518 } 519 520 if (memcmp(buf, bd->first_block, 512) == 0) { 521 /* found it */ 522 return (i); 523 } 524 } 525 return (-1); 526 } 527 528 529 static void 530 cleanup_and_exit(int exitcode) 531 { 532 533 free_disks(); 534 535 if (root_node != DI_NODE_NIL) 536 di_fini(root_node); 537 538 if (root_allnode != DI_NODE_NIL) 539 di_fini(root_allnode); 540 541 if (prom_hdl != DI_PROM_HANDLE_NIL) 542 di_prom_fini(prom_hdl); 543 exit(exitcode); 544 545 } 546 547 548 int 549 main(int argc, char *argv[]) 550 { 551 biosdev_data_t *biosdata; 552 int len, i, c, j; 553 int matchedindex = -1; 554 char biospropname[BIOSPROPNAME_TMPL_LEN]; 555 int totalmatches = 0; 556 557 558 while ((c = getopt(argc, argv, "d")) != -1) { 559 switch (c) { 560 case 'd': 561 debug = 1; 562 break; 563 default: 564 (void) printf("unknown option %c\n", c); 565 exit(1); 566 } 567 } 568 569 if ((prom_hdl = di_prom_init()) == DI_PROM_HANDLE_NIL) { 570 (void) fprintf(stderr, "di_prom_init failed\n"); 571 cleanup_and_exit(1); 572 } 573 574 if ((root_node = di_init("/", DINFOCACHE)) == DI_NODE_NIL) { 575 (void) fprintf(stderr, "di_init failed\n"); 576 cleanup_and_exit(1); 577 } 578 579 if ((root_allnode = di_init("/", DINFOCPYALL)) == DI_NODE_NIL) { 580 (void) fprintf(stderr, "di_init failed\n"); 581 cleanup_and_exit(1); 582 } 583 584 (void) memset(mapinfo, 0, sizeof (mapinfo)); 585 586 /* get a list of all disks in the system */ 587 build_disk_list(); 588 589 /* for each property try to match with a disk */ 590 for (i = 0; i < BIOSDEV_NUM; i++) { 591 592 (void) snprintf((char *)biospropname, BIOSPROPNAME_TMPL_LEN, 593 BIOSPROPNAME_TMPL, i + STARTING_DRVNUM); 594 595 len = di_prop_lookup_bytes(DDI_DEV_T_ANY, root_allnode, 596 biospropname, (uchar_t **)&biosdata); 597 598 if (len <= 0) { 599 continue; 600 } 601 602 if (debug) 603 (void) printf("matching %s\n", biospropname); 604 605 matchedindex = match_edd(biosdata); 606 607 if (matchedindex == -1) { 608 matchedindex = match_first_block(biosdata); 609 if (debug && matchedindex != -1) 610 (void) printf("matched first block\n"); 611 } else if (debug) 612 (void) printf("matched thru edd\n"); 613 614 if (matchedindex != -1) { 615 mapinfo[i].disklist_index = matchedindex; 616 mapinfo[i].matchcount++; 617 if (debug) 618 (void) printf("0x%x %s\n", i + STARTING_DRVNUM, 619 disk_list[matchedindex]); 620 for (j = 0; j < i; j++) { 621 if (mapinfo[j].matchcount > 0 && 622 mapinfo[j].disklist_index == matchedindex) { 623 mapinfo[j].matchcount++; 624 mapinfo[i].matchcount++; 625 } 626 } 627 628 } else if (debug) 629 (void) fprintf(stderr, "Could not match %s\n", 630 biospropname); 631 } 632 633 for (i = 0; i < BIOSDEV_NUM; i++) { 634 if (mapinfo[i].matchcount == 1) { 635 (void) printf("0x%x %s\n", i + STARTING_DRVNUM, 636 disk_list[mapinfo[i].disklist_index]); 637 totalmatches++; 638 } else if (debug && mapinfo[i].matchcount > 1) { 639 (void) printf("0x%x %s matchcount %d\n", 640 i + STARTING_DRVNUM, 641 disk_list[mapinfo[i].disklist_index], 642 mapinfo[i].matchcount); 643 } 644 } 645 646 if (totalmatches == 0) { 647 (void) fprintf(stderr, "biosdev: Could not match any!!\n"); 648 cleanup_and_exit(1); 649 } 650 651 cleanup_and_exit(0); 652 /* NOTREACHED */ 653 return (0); 654 } 655