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 /* 23 * Copyright (c) 2008, 2010, Oracle and/or its affiliates. All rights reserved. 24 */ 25 26 /* 27 * Functions in this file are shared between the disk and ses enumerators. 28 * 29 * A topo_list_t of all disks is returned by a successful disk_list_gather() 30 * call, and the list is freed by a disk_list_free(). To create a 'disk' topo 31 * node below a specific 'bay' parent node either disk_declare_path() or 32 * disk_declare_addr() are called. The caller determines which 'disk' is 33 * in which 'bay'. A disk's 'label' and 'authority' information come from 34 * its parent 'bay' node. 35 */ 36 37 #include <ctype.h> 38 #include <strings.h> 39 #include <libdevinfo.h> 40 #include <devid.h> 41 #include <sys/libdevid.h> 42 #include <pthread.h> 43 #include <inttypes.h> 44 #include <sys/dkio.h> 45 #include <sys/scsi/scsi_types.h> 46 #include <fm/topo_mod.h> 47 #include <fm/topo_list.h> 48 #include <fm/libdiskstatus.h> 49 #include <sys/fm/protocol.h> 50 #include <sys/scsi/generic/inquiry.h> 51 #include "disk.h" 52 53 /* common callback information for di_walk_node() and di_devlink_walk */ 54 typedef struct disk_cbdata { 55 topo_mod_t *dcb_mod; 56 topo_list_t *dcb_list; 57 58 di_devlink_handle_t dcb_devhdl; 59 dev_di_node_t *dcb_dnode; /* for di_devlink_walk only */ 60 } disk_cbdata_t; 61 62 /* 63 * Given a /devices path for a whole disk, appending this extension gives the 64 * path to a raw device that can be opened. 65 */ 66 #if defined(__i386) || defined(__amd64) 67 #define PHYS_EXTN ":q,raw" 68 #elif defined(__sparc) || defined(__sparcv9) 69 #define PHYS_EXTN ":c,raw" 70 #else 71 #error Unknown architecture 72 #endif 73 74 /* 75 * Methods for disks. This is used by the disk-transport module to 76 * generate ereports based off SCSI disk status. 77 */ 78 static int disk_status(topo_mod_t *, tnode_t *, topo_version_t, 79 nvlist_t *, nvlist_t **); 80 81 static const topo_method_t disk_methods[] = { 82 { TOPO_METH_DISK_STATUS, TOPO_METH_DISK_STATUS_DESC, 83 TOPO_METH_DISK_STATUS_VERSION, TOPO_STABILITY_INTERNAL, 84 disk_status }, 85 { NULL } 86 }; 87 88 static const topo_pgroup_info_t io_pgroup = { 89 TOPO_PGROUP_IO, 90 TOPO_STABILITY_PRIVATE, 91 TOPO_STABILITY_PRIVATE, 92 1 93 }; 94 95 static const topo_pgroup_info_t disk_auth_pgroup = { 96 FM_FMRI_AUTHORITY, 97 TOPO_STABILITY_PRIVATE, 98 TOPO_STABILITY_PRIVATE, 99 1 100 }; 101 102 static const topo_pgroup_info_t storage_pgroup = { 103 TOPO_PGROUP_STORAGE, 104 TOPO_STABILITY_PRIVATE, 105 TOPO_STABILITY_PRIVATE, 106 1 107 }; 108 109 /* 110 * Set the properties of the disk node, from dev_di_node_t data. 111 * Properties include: 112 * group: protocol properties: resource, asru, label, fru 113 * group: authority properties: product-id, chasis-id, server-id 114 * group: io properties: devfs-path, devid 115 * group: storage properties: 116 * - logical-disk, disk-model, disk-manufacturer, serial-number 117 * - firmware-revision, capacity-in-bytes 118 * 119 * NOTE: the io and storage groups won't be present if the dnode passed in is 120 * NULL. This happens when a disk is found through ses, but is not enumerated 121 * in the devinfo tree. 122 */ 123 static int 124 disk_set_props(topo_mod_t *mod, tnode_t *parent, 125 tnode_t *dtn, dev_di_node_t *dnode) 126 { 127 nvlist_t *asru = NULL; 128 char *label = NULL; 129 nvlist_t *fmri = NULL; 130 int err; 131 132 /* pull the label property down from our parent 'bay' node */ 133 if (topo_node_label(parent, &label, &err) != 0) { 134 topo_mod_dprintf(mod, "disk_set_props: " 135 "label error %s\n", topo_strerror(err)); 136 goto error; 137 } 138 if (topo_node_label_set(dtn, label, &err) != 0) { 139 topo_mod_dprintf(mod, "disk_set_props: " 140 "label_set error %s\n", topo_strerror(err)); 141 goto error; 142 } 143 144 /* get the resource fmri, and use it as the fru */ 145 if (topo_node_resource(dtn, &fmri, &err) != 0) { 146 topo_mod_dprintf(mod, "disk_set_props: " 147 "resource error: %s\n", topo_strerror(err)); 148 goto error; 149 } 150 if (topo_node_fru_set(dtn, fmri, 0, &err) != 0) { 151 topo_mod_dprintf(mod, "disk_set_props: " 152 "fru_set error: %s\n", topo_strerror(err)); 153 goto error; 154 } 155 156 /* create/set the authority group */ 157 if ((topo_pgroup_create(dtn, &disk_auth_pgroup, &err) != 0) && 158 (err != ETOPO_PROP_DEFD)) { 159 topo_mod_dprintf(mod, "disk_set_props: " 160 "create disk_auth error %s\n", topo_strerror(err)); 161 goto error; 162 } 163 164 /* create the storage group */ 165 if (topo_pgroup_create(dtn, &storage_pgroup, &err) != 0) { 166 topo_mod_dprintf(mod, "disk_set_props: " 167 "create storage error %s\n", topo_strerror(err)); 168 goto error; 169 } 170 171 /* no dnode was found for this disk - skip the io and storage groups */ 172 if (dnode == NULL) { 173 err = 0; 174 goto out; 175 } 176 177 /* form and set the asru */ 178 if ((asru = topo_mod_devfmri(mod, FM_DEV_SCHEME_VERSION, 179 dnode->ddn_dpath, dnode->ddn_devid)) == NULL) { 180 err = ETOPO_FMRI_UNKNOWN; 181 topo_mod_dprintf(mod, "disk_set_props: " 182 "asru error %s\n", topo_strerror(err)); 183 goto error; 184 } 185 if (topo_node_asru_set(dtn, asru, 0, &err) != 0) { 186 topo_mod_dprintf(mod, "disk_set_props: " 187 "asru_set error %s\n", topo_strerror(err)); 188 goto error; 189 } 190 191 /* create/set the devfs-path and devid in the io group */ 192 if (topo_pgroup_create(dtn, &io_pgroup, &err) != 0) { 193 topo_mod_dprintf(mod, "disk_set_props: " 194 "create io error %s\n", topo_strerror(err)); 195 goto error; 196 } 197 198 if (topo_prop_set_string(dtn, TOPO_PGROUP_IO, TOPO_IO_DEV_PATH, 199 TOPO_PROP_IMMUTABLE, dnode->ddn_dpath, &err) != 0) { 200 topo_mod_dprintf(mod, "disk_set_props: " 201 "set dev error %s\n", topo_strerror(err)); 202 goto error; 203 } 204 205 if (dnode->ddn_devid && topo_prop_set_string(dtn, TOPO_PGROUP_IO, 206 TOPO_IO_DEVID, TOPO_PROP_IMMUTABLE, dnode->ddn_devid, &err) != 0) { 207 topo_mod_dprintf(mod, "disk_set_props: " 208 "set devid error %s\n", topo_strerror(err)); 209 goto error; 210 } 211 212 if (dnode->ddn_ppath_count != 0 && 213 topo_prop_set_string_array(dtn, TOPO_PGROUP_IO, TOPO_IO_PHYS_PATH, 214 TOPO_PROP_IMMUTABLE, (const char **)dnode->ddn_ppath, 215 dnode->ddn_ppath_count, &err) != 0) { 216 topo_mod_dprintf(mod, "disk_set_props: " 217 "set phys-path error %s\n", topo_strerror(err)); 218 goto error; 219 } 220 221 /* set the storage group public /dev name */ 222 if (dnode->ddn_lpath != NULL && 223 topo_prop_set_string(dtn, TOPO_PGROUP_STORAGE, 224 TOPO_STORAGE_LOGICAL_DISK_NAME, TOPO_PROP_IMMUTABLE, 225 dnode->ddn_lpath, &err) != 0) { 226 topo_mod_dprintf(mod, "disk_set_props: " 227 "set disk_name error %s\n", topo_strerror(err)); 228 goto error; 229 } 230 231 /* populate other misc storage group properties */ 232 if (dnode->ddn_mfg && (topo_prop_set_string(dtn, TOPO_PGROUP_STORAGE, 233 TOPO_STORAGE_MANUFACTURER, TOPO_PROP_IMMUTABLE, 234 dnode->ddn_mfg, &err) != 0)) { 235 topo_mod_dprintf(mod, "disk_set_props: " 236 "set mfg error %s\n", topo_strerror(err)); 237 goto error; 238 } 239 if (dnode->ddn_model && (topo_prop_set_string(dtn, TOPO_PGROUP_STORAGE, 240 TOPO_STORAGE_MODEL, TOPO_PROP_IMMUTABLE, 241 dnode->ddn_model, &err) != 0)) { 242 topo_mod_dprintf(mod, "disk_set_props: " 243 "set model error %s\n", topo_strerror(err)); 244 goto error; 245 } 246 if (dnode->ddn_serial && (topo_prop_set_string(dtn, TOPO_PGROUP_STORAGE, 247 TOPO_STORAGE_SERIAL_NUM, TOPO_PROP_IMMUTABLE, 248 dnode->ddn_serial, &err) != 0)) { 249 topo_mod_dprintf(mod, "disk_set_props: " 250 "set serial error %s\n", topo_strerror(err)); 251 goto error; 252 } 253 if (dnode->ddn_firm && (topo_prop_set_string(dtn, TOPO_PGROUP_STORAGE, 254 TOPO_STORAGE_FIRMWARE_REV, TOPO_PROP_IMMUTABLE, 255 dnode->ddn_firm, &err) != 0)) { 256 topo_mod_dprintf(mod, "disk_set_props: " 257 "set firm error %s\n", topo_strerror(err)); 258 goto error; 259 } 260 if (dnode->ddn_cap && (topo_prop_set_string(dtn, TOPO_PGROUP_STORAGE, 261 TOPO_STORAGE_CAPACITY, TOPO_PROP_IMMUTABLE, 262 dnode->ddn_cap, &err) != 0)) { 263 topo_mod_dprintf(mod, "disk_set_props: " 264 "set cap error %s\n", topo_strerror(err)); 265 goto error; 266 } 267 err = 0; 268 269 out: if (fmri) 270 nvlist_free(fmri); 271 if (label) 272 topo_mod_strfree(mod, label); 273 if (asru) 274 nvlist_free(asru); 275 return (err); 276 277 error: err = topo_mod_seterrno(mod, err); 278 goto out; 279 } 280 281 /* 282 * Trim leading and trailing whitespace from the string. 283 */ 284 static char * 285 disk_trim_whitespace(topo_mod_t *mod, const char *begin) 286 { 287 const char *end; 288 char *buf; 289 size_t count; 290 291 if (begin == NULL) 292 return (NULL); 293 294 end = begin + strlen(begin); 295 296 while (begin < end && isspace(*begin)) 297 begin++; 298 while (begin < end && isspace(*(end - 1))) 299 end--; 300 301 count = end - begin; 302 if ((buf = topo_mod_alloc(mod, count + 1)) == NULL) 303 return (NULL); 304 305 (void) strlcpy(buf, begin, count + 1); 306 307 return (buf); 308 } 309 310 /* 311 * Manufacturing strings can contain characters that are invalid for use in hc 312 * authority names. This trims leading and trailing whitespace, and 313 * substitutes any characters known to be bad. 314 */ 315 char * 316 disk_auth_clean(topo_mod_t *mod, const char *str) 317 { 318 char *buf, *p; 319 320 if (str == NULL) 321 return (NULL); 322 323 if ((buf = topo_mod_strdup(mod, str)) == NULL) 324 return (NULL); 325 326 while ((p = strpbrk(buf, " :=")) != NULL) 327 *p = '-'; 328 329 return (buf); 330 } 331 332 /* create the disk topo node */ 333 static int 334 disk_tnode_create(topo_mod_t *mod, tnode_t *parent, 335 dev_di_node_t *dnode, const char *name, topo_instance_t i, tnode_t **rval) 336 { 337 int len; 338 nvlist_t *fmri; 339 tnode_t *dtn; 340 char *part = NULL; 341 nvlist_t *auth; 342 char *mfg, *model, *firm, *serial; 343 344 *rval = NULL; 345 if (dnode != NULL) { 346 mfg = disk_auth_clean(mod, dnode->ddn_mfg); 347 model = disk_auth_clean(mod, dnode->ddn_model); 348 firm = disk_auth_clean(mod, dnode->ddn_firm); 349 serial = disk_auth_clean(mod, dnode->ddn_serial); 350 } else { 351 mfg = model = firm = serial = NULL; 352 } 353 354 /* form 'part=' of fmri as "<mfg>-<model>" */ 355 if (mfg != NULL && model != NULL) { 356 len = strlen(mfg) + 1 + strlen(model) + 1; 357 if ((part = topo_mod_alloc(mod, len)) != NULL) 358 (void) snprintf(part, len, "%s-%s", 359 mfg, model); 360 } 361 362 auth = topo_mod_auth(mod, parent); 363 fmri = topo_mod_hcfmri(mod, parent, FM_HC_SCHEME_VERSION, name, i, NULL, 364 auth, part ? part : model, firm, serial); 365 nvlist_free(auth); 366 367 topo_mod_strfree(mod, part); 368 topo_mod_strfree(mod, mfg); 369 topo_mod_strfree(mod, model); 370 topo_mod_strfree(mod, firm); 371 topo_mod_strfree(mod, serial); 372 373 if (fmri == NULL) { 374 topo_mod_dprintf(mod, "disk_tnode_create: " 375 "hcfmri (%s%d/%s%d) error %s\n", 376 topo_node_name(parent), topo_node_instance(parent), 377 name, i, topo_strerror(topo_mod_errno(mod))); 378 return (-1); 379 } 380 381 if ((dtn = topo_node_bind(mod, parent, name, i, fmri)) == NULL) { 382 if (topo_mod_errno(mod) == EMOD_NODE_BOUND) { 383 /* 384 * if disk 0 is already there then we're done 385 */ 386 nvlist_free(fmri); 387 return (0); 388 } 389 topo_mod_dprintf(mod, "disk_tnode_create: " 390 "bind (%s%d/%s%d) error %s\n", 391 topo_node_name(parent), topo_node_instance(parent), 392 name, i, topo_strerror(topo_mod_errno(mod))); 393 nvlist_free(fmri); 394 return (-1); 395 } 396 nvlist_free(fmri); 397 398 /* add the properties of the disk */ 399 if (disk_set_props(mod, parent, dtn, dnode) != 0) { 400 topo_mod_dprintf(mod, "disk_tnode_create: " 401 "disk_set_props (%s%d/%s%d) error %s\n", 402 topo_node_name(parent), topo_node_instance(parent), 403 name, i, topo_strerror(topo_mod_errno(mod))); 404 topo_node_unbind(dtn); 405 return (-1); 406 } 407 *rval = dtn; 408 return (0); 409 } 410 411 static int 412 disk_declare(topo_mod_t *mod, tnode_t *parent, dev_di_node_t *dnode, 413 tnode_t **childp) 414 { 415 tnode_t *dtn = NULL; 416 int rval; 417 418 rval = disk_tnode_create(mod, parent, dnode, DISK, 0, &dtn); 419 if (dtn == NULL) { 420 if (rval == 0) 421 return (0); 422 topo_mod_dprintf(mod, "disk_declare: " 423 "disk_tnode_create error %s\n", 424 topo_strerror(topo_mod_errno(mod))); 425 return (-1); 426 } 427 428 /* register disk_methods against the disk topo node */ 429 if (topo_method_register(mod, dtn, disk_methods) != 0) { 430 topo_mod_dprintf(mod, "disk_declare: " 431 "topo_method_register error %s\n", 432 topo_strerror(topo_mod_errno(mod))); 433 topo_node_unbind(dtn); 434 return (-1); 435 } 436 if (childp != NULL) 437 *childp = dtn; 438 return (0); 439 } 440 441 int 442 disk_declare_path(topo_mod_t *mod, tnode_t *parent, topo_list_t *listp, 443 const char *path) 444 { 445 dev_di_node_t *dnode; 446 int i; 447 448 /* 449 * Check for match using physical phci (ddn_ppath). Use 450 * di_devfs_path_match so generic.vs.non-generic names match. 451 */ 452 for (dnode = topo_list_next(listp); dnode != NULL; 453 dnode = topo_list_next(dnode)) { 454 if (dnode->ddn_ppath == NULL) 455 continue; 456 457 for (i = 0; i < dnode->ddn_ppath_count; i++) { 458 if (di_devfs_path_match(dnode->ddn_ppath[0], path)) 459 return (disk_declare(mod, parent, dnode, NULL)); 460 } 461 } 462 463 topo_mod_dprintf(mod, "disk_declare_path: " 464 "failed to find disk matching path %s", path); 465 return (0); 466 } 467 468 int 469 disk_declare_addr(topo_mod_t *mod, tnode_t *parent, topo_list_t *listp, 470 const char *addr, tnode_t **childp) 471 { 472 dev_di_node_t *dnode; 473 int i; 474 475 /* Check for match using addr. */ 476 for (dnode = topo_list_next(listp); dnode != NULL; 477 dnode = topo_list_next(dnode)) { 478 if (dnode->ddn_target_port == NULL) 479 continue; 480 481 for (i = 0; i < dnode->ddn_ppath_count; i++) { 482 if ((dnode->ddn_target_port[i] != NULL) && 483 (strncmp(dnode->ddn_target_port[i], addr, 484 strcspn(dnode->ddn_target_port[i], ":"))) == 0) { 485 topo_mod_dprintf(mod, "disk_declare_addr: " 486 "found disk matching addr %s", addr); 487 return (disk_declare(mod, parent, dnode, 488 childp)); 489 } 490 } 491 } 492 493 topo_mod_dprintf(mod, "disk_declare_addr: " 494 "failed to find disk matching addr %s", addr); 495 496 return (1); 497 } 498 499 /* 500 * Used to declare a disk that has been discovered through other means (usually 501 * ses), that is not enumerated in the devinfo tree. 502 */ 503 int 504 disk_declare_non_enumerated(topo_mod_t *mod, tnode_t *parent, tnode_t **childp) 505 { 506 return (disk_declare(mod, parent, NULL, childp)); 507 } 508 509 /* di_devlink callback for dev_di_node_add */ 510 static int 511 disk_devlink_callback(di_devlink_t dl, void *arg) 512 { 513 disk_cbdata_t *cbp = (disk_cbdata_t *)arg; 514 topo_mod_t *mod = cbp->dcb_mod; 515 dev_di_node_t *dnode = cbp->dcb_dnode; 516 const char *devpath; 517 char *ctds, *slice; 518 519 devpath = di_devlink_path(dl); 520 if ((dnode == NULL) || (devpath == NULL)) 521 return (DI_WALK_TERMINATE); 522 523 /* trim the slice off the public name */ 524 if (((ctds = strrchr(devpath, '/')) != NULL) && 525 ((slice = strchr(ctds, 's')) != NULL)) 526 *slice = '\0'; 527 528 /* Establish the public /dev name (no slice) */ 529 dnode->ddn_lpath = topo_mod_strdup(mod, ctds ? ctds + 1 : devpath); 530 531 if (ctds && slice) 532 *slice = 's'; 533 return (DI_WALK_TERMINATE); 534 } 535 536 static void 537 dev_di_node_free(topo_mod_t *mod, dev_di_node_t *dnode) 538 { 539 int i; 540 541 /* free the stuff we point to */ 542 if (dnode->ddn_devid) 543 topo_mod_strfree(mod, dnode->ddn_devid); 544 for (i = 0; i < dnode->ddn_ppath_count; i++) { 545 /* topo_mod_strfree does NULL checking. */ 546 topo_mod_strfree(mod, dnode->ddn_ppath[i]); 547 topo_mod_strfree(mod, dnode->ddn_target_port[i]); 548 topo_mod_strfree(mod, dnode->ddn_attached_port[i]); 549 topo_mod_strfree(mod, dnode->ddn_bridge_port[i]); 550 } 551 topo_mod_free(mod, dnode->ddn_ppath, 552 dnode->ddn_ppath_count * sizeof (char *)); 553 topo_mod_free(mod, dnode->ddn_target_port, 554 dnode->ddn_ppath_count * sizeof (char *)); 555 topo_mod_free(mod, dnode->ddn_attached_port, 556 dnode->ddn_ppath_count * sizeof (char *)); 557 topo_mod_free(mod, dnode->ddn_bridge_port, 558 dnode->ddn_ppath_count * sizeof (char *)); 559 topo_mod_strfree(mod, dnode->ddn_dpath); 560 topo_mod_strfree(mod, dnode->ddn_lpath); 561 562 topo_mod_strfree(mod, dnode->ddn_mfg); 563 topo_mod_strfree(mod, dnode->ddn_model); 564 topo_mod_strfree(mod, dnode->ddn_serial); 565 topo_mod_strfree(mod, dnode->ddn_firm); 566 topo_mod_strfree(mod, dnode->ddn_cap); 567 568 /* free self */ 569 topo_mod_free(mod, dnode, sizeof (dev_di_node_t)); 570 } 571 572 static int 573 dev_di_node_add(di_node_t node, char *devid, disk_cbdata_t *cbp) 574 { 575 topo_mod_t *mod = cbp->dcb_mod; 576 dev_di_node_t *dnode; 577 di_path_t pnode; 578 char *path; 579 int mlen; 580 char *minorpath; 581 char *extn = ":a"; 582 char *s; 583 int64_t *nblocksp; 584 uint64_t nblocks; 585 int *dblksizep; 586 uint_t dblksize; 587 char lentry[MAXPATHLEN]; 588 int pathcount; 589 int *inq_dtype, itype; 590 int i; 591 592 if (devid) { 593 /* 594 * Check for list duplicate using devid search. 595 * Note if there is no devid, then we can end up with duplicates 596 * in the list, but this doesn't do any harm. 597 */ 598 for (dnode = topo_list_next(cbp->dcb_list); 599 dnode != NULL; dnode = topo_list_next(dnode)) { 600 if (dnode->ddn_devid && 601 devid_str_compare(dnode->ddn_devid, devid) == 0) { 602 topo_mod_dprintf(mod, "dev_di_node_add: " 603 "already there %s\n", devid); 604 return (0); 605 } 606 } 607 } 608 609 if ((dnode = topo_mod_zalloc(mod, sizeof (dev_di_node_t))) == NULL) 610 return (-1); 611 612 if (devid) { 613 /* Establish the devid. */ 614 dnode->ddn_devid = topo_mod_strdup(mod, devid); 615 if (dnode->ddn_devid == NULL) 616 goto error; 617 } 618 619 /* Establish the devinfo dpath */ 620 if ((path = di_devfs_path(node)) == NULL) { 621 (void) topo_mod_seterrno(mod, errno); 622 goto error; 623 } 624 625 dnode->ddn_dpath = topo_mod_strdup(mod, path); 626 di_devfs_path_free(path); 627 if (dnode->ddn_dpath == NULL) 628 goto error; 629 630 /* 631 * Establish the physical ppath and target ports. If the device is 632 * non-mpxio then dpath and ppath are the same, and the target port is a 633 * property of the device node. 634 * 635 * If dpath is a client node under scsi_vhci, then iterate over all 636 * paths and get their physical paths and target port properrties. 637 * di_path_client_next_path call below will 638 * return non-NULL, and ppath is set to the physical path to the first 639 * pathinfo node. 640 * 641 * NOTE: It is possible to get a generic.vs.non-generic path 642 * for di_devfs_path.vs.di_path_devfs_path like: 643 * xml: /pci@7b,0/pci1022,7458@11/pci1000,3060@2/sd@2,0 644 * pnode: /pci@7b,0/pci1022,7458@11/pci1000,3060@2/disk@2,0 645 * To resolve this issue disk_declare_path() needs to use the 646 * special di_devfs_path_match() interface. 647 */ 648 pathcount = 0; 649 pnode = NULL; 650 while ((pnode = di_path_client_next_path(node, pnode)) != NULL) { 651 pathcount++; 652 } 653 654 if (pathcount == 0) { 655 if ((dnode->ddn_ppath = 656 topo_mod_zalloc(mod, sizeof (char *))) == NULL) 657 goto error; 658 659 dnode->ddn_ppath_count = 1; 660 if ((dnode->ddn_ppath[0] = topo_mod_strdup(mod, 661 dnode->ddn_dpath)) == NULL) 662 goto error; 663 664 if ((dnode->ddn_target_port = topo_mod_zalloc(mod, 665 sizeof (char *))) == NULL) 666 goto error; 667 668 if ((dnode->ddn_attached_port = topo_mod_zalloc(mod, 669 sizeof (char *))) == NULL) 670 goto error; 671 672 if ((dnode->ddn_bridge_port = topo_mod_zalloc(mod, 673 sizeof (char *))) == NULL) 674 goto error; 675 676 /* There should be only one target port for a devinfo node. */ 677 if ((di_prop_lookup_strings(DDI_DEV_T_ANY, node, 678 SCSI_ADDR_PROP_TARGET_PORT, &s)) == 1) { 679 if ((dnode->ddn_target_port[0] = 680 topo_mod_strdup(mod, 681 scsi_wwnstr_skip_ua_prefix(s))) == 682 NULL) 683 goto error; 684 } 685 686 if ((di_prop_lookup_strings(DDI_DEV_T_ANY, node, 687 SCSI_ADDR_PROP_ATTACHED_PORT, &s)) == 1) { 688 /* There should be one attached port if any. */ 689 if ((dnode->ddn_attached_port[0] = 690 topo_mod_strdup(mod, 691 scsi_wwnstr_skip_ua_prefix(s))) == 692 NULL) 693 goto error; 694 } 695 696 if ((di_prop_lookup_strings(DDI_DEV_T_ANY, node, 697 SCSI_ADDR_PROP_BRIDGE_PORT, &s)) == 1) { 698 /* There should be one bridge port if any. */ 699 if ((dnode->ddn_bridge_port[0] = 700 topo_mod_strdup(mod, 701 scsi_wwnstr_skip_ua_prefix(s))) == 702 NULL) 703 goto error; 704 } 705 706 } else { 707 /* processing a scsi_vhci device. */ 708 if ((dnode->ddn_ppath = topo_mod_zalloc(mod, 709 pathcount * sizeof (char *))) == NULL) 710 goto error; 711 712 dnode->ddn_ppath_count = pathcount; 713 714 if ((dnode->ddn_target_port = topo_mod_zalloc(mod, 715 pathcount * sizeof (char *))) == NULL) 716 goto error; 717 718 if ((dnode->ddn_attached_port = topo_mod_zalloc(mod, 719 pathcount * sizeof (char *))) == NULL) 720 goto error; 721 722 if ((dnode->ddn_bridge_port = topo_mod_zalloc(mod, 723 pathcount * sizeof (char *))) == NULL) 724 goto error; 725 726 pnode = NULL; 727 pathcount = 0; 728 while ((pnode = di_path_client_next_path(node, 729 pnode)) != NULL) { 730 if ((path = di_path_devfs_path(pnode)) == NULL) { 731 (void) topo_mod_seterrno(mod, errno); 732 goto error; 733 } 734 735 dnode->ddn_ppath[pathcount] = 736 topo_mod_strdup(mod, path); 737 di_devfs_path_free(path); 738 if (dnode->ddn_ppath[pathcount] == NULL) 739 goto error; 740 741 if ((di_path_prop_lookup_strings(pnode, 742 SCSI_ADDR_PROP_TARGET_PORT, &s)) == 1) { 743 if ((dnode->ddn_target_port[pathcount] = 744 topo_mod_strdup(mod, 745 scsi_wwnstr_skip_ua_prefix(s))) == 746 NULL) 747 goto error; 748 } 749 750 if ((di_path_prop_lookup_strings(pnode, 751 SCSI_ADDR_PROP_ATTACHED_PORT, &s)) == 1) { 752 if ((dnode->ddn_attached_port[pathcount] = 753 topo_mod_strdup(mod, 754 scsi_wwnstr_skip_ua_prefix(s))) == 755 NULL) 756 goto error; 757 } 758 759 if ((di_path_prop_lookup_strings(pnode, 760 SCSI_ADDR_PROP_BRIDGE_PORT, &s)) == 1) { 761 if ((dnode->ddn_bridge_port[pathcount] = 762 topo_mod_strdup(mod, 763 scsi_wwnstr_skip_ua_prefix(s))) == 764 NULL) 765 goto error; 766 } 767 768 pathcount++; 769 } 770 } 771 772 /* 773 * Find the public /dev name for a disk by adding a minor name and using 774 * di_devlink interface for reverse translation (use devinfo path). 775 */ 776 if (di_prop_lookup_ints(DDI_DEV_T_ANY, node, "inquiry-device-type", 777 &inq_dtype) > 0) { 778 dnode->ddn_dtype = *inq_dtype; 779 itype = (*inq_dtype) & DTYPE_MASK; 780 if (itype == DTYPE_DIRECT) { 781 mlen = strlen(dnode->ddn_dpath) + strlen(extn) + 1; 782 if ((minorpath = topo_mod_alloc(mod, mlen)) == NULL) 783 goto error; 784 (void) snprintf(minorpath, mlen, "%s%s", 785 dnode->ddn_dpath, extn); 786 cbp->dcb_dnode = dnode; 787 (void) di_devlink_walk(cbp->dcb_devhdl, "^dsk/", 788 minorpath, DI_PRIMARY_LINK, cbp, 789 disk_devlink_callback); 790 topo_mod_free(mod, minorpath, mlen); 791 if (dnode->ddn_lpath == NULL) { 792 topo_mod_dprintf(mod, "dev_di_node_add: " 793 "failed to determine logical path"); 794 } 795 } 796 } else { 797 dnode->ddn_dtype = DTYPE_UNKNOWN; 798 } 799 800 /* cache various bits of optional information about the device. */ 801 if (di_prop_lookup_strings(DDI_DEV_T_ANY, node, 802 INQUIRY_VENDOR_ID, &s) > 0) { 803 if ((dnode->ddn_mfg = disk_trim_whitespace(mod, s)) == NULL) 804 goto error; 805 } 806 if (di_prop_lookup_strings(DDI_DEV_T_ANY, node, 807 INQUIRY_PRODUCT_ID, &s) > 0) { 808 if ((dnode->ddn_model = disk_trim_whitespace(mod, s)) == NULL) 809 goto error; 810 } 811 if (di_prop_lookup_strings(DDI_DEV_T_ANY, node, 812 INQUIRY_REVISION_ID, &s) > 0) { 813 if ((dnode->ddn_firm = disk_trim_whitespace(mod, s)) == NULL) 814 goto error; 815 } 816 if (di_prop_lookup_strings(DDI_DEV_T_ANY, node, 817 INQUIRY_SERIAL_NO, &s) > 0) { 818 if ((dnode->ddn_serial = disk_trim_whitespace(mod, s)) == NULL) 819 goto error; 820 } 821 if (di_prop_lookup_int64(DDI_DEV_T_ANY, node, 822 "device-nblocks", &nblocksp) > 0) { 823 nblocks = (uint64_t)*nblocksp; 824 /* 825 * To save kernel memory, the driver may not define 826 * "device-dblksize" when its value is default DEV_BSIZE. 827 */ 828 if (di_prop_lookup_ints(DDI_DEV_T_ANY, node, 829 "device-dblksize", &dblksizep) > 0) 830 dblksize = (uint_t)*dblksizep; 831 else 832 dblksize = DEV_BSIZE; /* default value */ 833 (void) snprintf(lentry, sizeof (lentry), 834 "%" PRIu64, nblocks * dblksize); 835 if ((dnode->ddn_cap = topo_mod_strdup(mod, lentry)) == NULL) 836 goto error; 837 } 838 839 topo_mod_dprintf(mod, "dev_di_node_add: " 840 "adding %s\n", devid ? dnode->ddn_devid : "NULL devid"); 841 topo_mod_dprintf(mod, " " 842 " %s\n", dnode->ddn_dpath); 843 for (i = 0; i < dnode->ddn_ppath_count; i++) { 844 topo_mod_dprintf(mod, " " 845 " %s\n", dnode->ddn_ppath[i]); 846 } 847 topo_list_append(cbp->dcb_list, dnode); 848 return (0); 849 850 error: 851 dev_di_node_free(mod, dnode); 852 return (-1); 853 } 854 855 /* di_walk_node callback for disk_list_gather */ 856 static int 857 dev_walk_di_nodes(di_node_t node, void *arg) 858 { 859 char *devidstr = NULL; 860 char *s; 861 int *val; 862 863 /* 864 * If it's not a scsi_vhci client and doesn't have a target_port 865 * property and doesn't have a target property then it's not a storage 866 * device and we're not interested. 867 */ 868 if (di_path_client_next_path(node, NULL) == NULL && 869 di_prop_lookup_strings(DDI_DEV_T_ANY, node, 870 SCSI_ADDR_PROP_TARGET_PORT, &s) <= 0 && 871 di_prop_lookup_ints(DDI_DEV_T_ANY, node, 872 SCSI_ADDR_PROP_TARGET, &val) <= 0) { 873 return (DI_WALK_CONTINUE); 874 } 875 (void) di_prop_lookup_strings(DDI_DEV_T_ANY, node, 876 DEVID_PROP_NAME, &devidstr); 877 878 /* create/find the devid scsi topology node */ 879 (void) dev_di_node_add(node, devidstr, arg); 880 881 return (DI_WALK_CONTINUE); 882 } 883 884 int 885 dev_list_gather(topo_mod_t *mod, topo_list_t *listp) 886 { 887 di_node_t devtree; 888 di_devlink_handle_t devhdl; 889 disk_cbdata_t dcb; 890 891 if ((devtree = topo_mod_devinfo(mod)) == DI_NODE_NIL) { 892 topo_mod_dprintf(mod, "disk_list_gather: " 893 "topo_mod_devinfo() failed"); 894 return (-1); 895 } 896 897 if ((devhdl = di_devlink_init(NULL, 0)) == DI_NODE_NIL) { 898 topo_mod_dprintf(mod, "disk_list_gather: " 899 "di_devlink_init() failed"); 900 return (-1); 901 } 902 903 dcb.dcb_mod = mod; 904 dcb.dcb_list = listp; 905 dcb.dcb_devhdl = devhdl; 906 907 /* walk the devinfo snapshot looking for disk nodes */ 908 (void) di_walk_node(devtree, DI_WALK_CLDFIRST, &dcb, 909 dev_walk_di_nodes); 910 911 (void) di_devlink_fini(&devhdl); 912 913 return (0); 914 } 915 916 void 917 dev_list_free(topo_mod_t *mod, topo_list_t *listp) 918 { 919 dev_di_node_t *dnode; 920 921 while ((dnode = topo_list_next(listp)) != NULL) { 922 /* order of delete/free is important */ 923 topo_list_delete(listp, dnode); 924 dev_di_node_free(mod, dnode); 925 } 926 } 927 928 /* 929 * Query the current disk status. If successful, the disk status is returned 930 * as an nvlist consisting of at least the following members: 931 * 932 * protocol string Supported protocol (currently "scsi") 933 * 934 * status nvlist Arbitrary protocol-specific information 935 * about the current state of the disk. 936 * 937 * faults nvlist A list of supported faults. Each 938 * element of this list is a boolean value. 939 * An element's existence indicates that 940 * the drive supports detecting this fault, 941 * and the value indicates the current 942 * state of the fault. 943 * 944 * <fault-name> nvlist For each fault named in 'faults', a 945 * nvlist describing protocol-specific 946 * attributes of the fault. 947 * 948 * This method relies on the libdiskstatus library to query this information. 949 */ 950 static int 951 disk_status(topo_mod_t *mod, tnode_t *nodep, topo_version_t vers, 952 nvlist_t *in_nvl, nvlist_t **out_nvl) 953 { 954 disk_status_t *dsp; 955 char *devpath, *fullpath; 956 size_t pathlen; 957 nvlist_t *status; 958 int err; 959 960 *out_nvl = NULL; 961 962 if (vers != TOPO_METH_DISK_STATUS_VERSION) 963 return (topo_mod_seterrno(mod, EMOD_VER_NEW)); 964 965 /* 966 * If the caller specifies the "path" parameter, then this indicates 967 * that we should use this instead of deriving it from the topo node 968 * itself. 969 */ 970 if (nvlist_lookup_string(in_nvl, "path", &fullpath) == 0) { 971 devpath = NULL; 972 } else { 973 /* 974 * Get the /devices path and attempt to open the disk status 975 * handle. 976 */ 977 if (topo_prop_get_string(nodep, TOPO_PGROUP_IO, 978 TOPO_IO_DEV_PATH, &devpath, &err) != 0) 979 return (topo_mod_seterrno(mod, EMOD_METHOD_NOTSUP)); 980 981 /* 982 * Note that sizeof(string) includes the terminating NULL byte 983 */ 984 pathlen = strlen(devpath) + sizeof ("/devices") + 985 sizeof (PHYS_EXTN) - 1; 986 987 if ((fullpath = topo_mod_alloc(mod, pathlen)) == NULL) 988 return (topo_mod_seterrno(mod, EMOD_NOMEM)); 989 990 (void) snprintf(fullpath, pathlen, "/devices%s%s", devpath, 991 PHYS_EXTN); 992 993 topo_mod_strfree(mod, devpath); 994 } 995 996 if ((dsp = disk_status_open(fullpath, &err)) == NULL) { 997 if (devpath) 998 topo_mod_free(mod, fullpath, pathlen); 999 return (topo_mod_seterrno(mod, err == EDS_NOMEM ? 1000 EMOD_NOMEM : EMOD_METHOD_NOTSUP)); 1001 } 1002 1003 if (devpath) 1004 topo_mod_free(mod, fullpath, pathlen); 1005 1006 if ((status = disk_status_get(dsp)) == NULL) { 1007 err = (disk_status_errno(dsp) == EDS_NOMEM ? 1008 EMOD_NOMEM : EMOD_METHOD_NOTSUP); 1009 disk_status_close(dsp); 1010 return (topo_mod_seterrno(mod, err)); 1011 } 1012 1013 *out_nvl = status; 1014 disk_status_close(dsp); 1015 return (0); 1016 } 1017