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 2009 Sun Microsystems, Inc. All rights reserved. 23 * Use is subject to license terms. 24 */ 25 26 #include <sys/note.h> 27 #include <sys/t_lock.h> 28 #include <sys/cmn_err.h> 29 #include <sys/instance.h> 30 #include <sys/conf.h> 31 #include <sys/stat.h> 32 #include <sys/ddi.h> 33 #include <sys/hwconf.h> 34 #include <sys/sunddi.h> 35 #include <sys/sunndi.h> 36 #include <sys/ddi_impldefs.h> 37 #include <sys/ndi_impldefs.h> 38 #include <sys/modctl.h> 39 #include <sys/contract/device_impl.h> 40 #include <sys/dacf.h> 41 #include <sys/promif.h> 42 #include <sys/pci.h> 43 #include <sys/cpuvar.h> 44 #include <sys/pathname.h> 45 #include <sys/taskq.h> 46 #include <sys/sysevent.h> 47 #include <sys/sunmdi.h> 48 #include <sys/stream.h> 49 #include <sys/strsubr.h> 50 #include <sys/fs/snode.h> 51 #include <sys/fs/dv_node.h> 52 #include <sys/reboot.h> 53 #include <sys/sysmacros.h> 54 #include <sys/systm.h> 55 #include <sys/fs/sdev_impl.h> 56 #include <sys/sunldi.h> 57 #include <sys/sunldi_impl.h> 58 59 #if defined(__i386) || defined(__amd64) 60 #if !defined(__xpv) 61 #include <sys/iommulib.h> 62 #endif 63 #endif 64 65 #ifdef DEBUG 66 int ddidebug = DDI_AUDIT; 67 #else 68 int ddidebug = 0; 69 #endif 70 71 #define MT_CONFIG_OP 0 72 #define MT_UNCONFIG_OP 1 73 74 /* Multi-threaded configuration */ 75 struct mt_config_handle { 76 kmutex_t mtc_lock; 77 kcondvar_t mtc_cv; 78 int mtc_thr_count; 79 dev_info_t *mtc_pdip; /* parent dip for mt_config_children */ 80 dev_info_t **mtc_fdip; /* "a" dip where unconfigure failed */ 81 major_t mtc_parmajor; /* parent major for mt_config_driver */ 82 major_t mtc_major; 83 int mtc_flags; 84 int mtc_op; /* config or unconfig */ 85 int mtc_error; /* operation error */ 86 struct brevq_node **mtc_brevqp; /* outstanding branch events queue */ 87 #ifdef DEBUG 88 int total_time; 89 timestruc_t start_time; 90 #endif /* DEBUG */ 91 }; 92 93 struct devi_nodeid { 94 pnode_t nodeid; 95 dev_info_t *dip; 96 struct devi_nodeid *next; 97 }; 98 99 struct devi_nodeid_list { 100 kmutex_t dno_lock; /* Protects other fields */ 101 struct devi_nodeid *dno_head; /* list of devi nodeid elements */ 102 struct devi_nodeid *dno_free; /* Free list */ 103 uint_t dno_list_length; /* number of dips in list */ 104 }; 105 106 /* used to keep track of branch remove events to be generated */ 107 struct brevq_node { 108 char *brn_deviname; 109 struct brevq_node *brn_sibling; 110 struct brevq_node *brn_child; 111 }; 112 113 static struct devi_nodeid_list devi_nodeid_list; 114 static struct devi_nodeid_list *devimap = &devi_nodeid_list; 115 116 /* 117 * Well known nodes which are attached first at boot time. 118 */ 119 dev_info_t *top_devinfo; /* root of device tree */ 120 dev_info_t *options_dip; 121 dev_info_t *pseudo_dip; 122 dev_info_t *clone_dip; 123 dev_info_t *scsi_vhci_dip; /* MPXIO dip */ 124 major_t clone_major; 125 126 /* 127 * A non-global zone's /dev is derived from the device tree. 128 * This generation number serves to indicate when a zone's 129 * /dev may need to be updated. 130 */ 131 volatile ulong_t devtree_gen; /* generation number */ 132 133 /* block all future dev_info state changes */ 134 hrtime_t volatile devinfo_freeze = 0; 135 136 /* number of dev_info attaches/detaches currently in progress */ 137 static ulong_t devinfo_attach_detach = 0; 138 139 extern int sys_shutdown; 140 extern kmutex_t global_vhci_lock; 141 142 /* bitset of DS_SYSAVAIL & DS_RECONFIG - no races, no lock */ 143 static int devname_state = 0; 144 145 /* 146 * The devinfo snapshot cache and related variables. 147 * The only field in the di_cache structure that needs initialization 148 * is the mutex (cache_lock). However, since this is an adaptive mutex 149 * (MUTEX_DEFAULT) - it is automatically initialized by being allocated 150 * in zeroed memory (static storage class). Therefore no explicit 151 * initialization of the di_cache structure is needed. 152 */ 153 struct di_cache di_cache = {1}; 154 int di_cache_debug = 0; 155 156 /* For ddvis, which needs pseudo children under PCI */ 157 int pci_allow_pseudo_children = 0; 158 159 /* Allow path-oriented alias driver binding on driver.conf enumerated nodes */ 160 int driver_conf_allow_path_alias = 1; 161 162 /* 163 * The following switch is for service people, in case a 164 * 3rd party driver depends on identify(9e) being called. 165 */ 166 int identify_9e = 0; 167 168 int mtc_off; /* turn off mt config */ 169 170 int quiesce_debug = 0; 171 172 static kmem_cache_t *ddi_node_cache; /* devinfo node cache */ 173 static devinfo_log_header_t *devinfo_audit_log; /* devinfo log */ 174 static int devinfo_log_size; /* size in pages */ 175 176 static int lookup_compatible(dev_info_t *, uint_t); 177 static char *encode_composite_string(char **, uint_t, size_t *, uint_t); 178 static void link_to_driver_list(dev_info_t *); 179 static void unlink_from_driver_list(dev_info_t *); 180 static void add_to_dn_list(struct devnames *, dev_info_t *); 181 static void remove_from_dn_list(struct devnames *, dev_info_t *); 182 static dev_info_t *find_child_by_callback(dev_info_t *, char *, char *, 183 int (*)(dev_info_t *, char *, int)); 184 static dev_info_t *find_duplicate_child(); 185 static void add_global_props(dev_info_t *); 186 static void remove_global_props(dev_info_t *); 187 static int uninit_node(dev_info_t *); 188 static void da_log_init(void); 189 static void da_log_enter(dev_info_t *); 190 static int walk_devs(dev_info_t *, int (*f)(dev_info_t *, void *), void *, int); 191 static int reset_nexus_flags(dev_info_t *, void *); 192 static void ddi_optimize_dtree(dev_info_t *); 193 static int is_leaf_node(dev_info_t *); 194 static struct mt_config_handle *mt_config_init(dev_info_t *, dev_info_t **, 195 int, major_t, int, struct brevq_node **); 196 static void mt_config_children(struct mt_config_handle *); 197 static void mt_config_driver(struct mt_config_handle *); 198 static int mt_config_fini(struct mt_config_handle *); 199 static int devi_unconfig_common(dev_info_t *, dev_info_t **, int, major_t, 200 struct brevq_node **); 201 static int 202 ndi_devi_config_obp_args(dev_info_t *parent, char *devnm, 203 dev_info_t **childp, int flags); 204 static void i_link_vhci_node(dev_info_t *); 205 static void ndi_devi_exit_and_wait(dev_info_t *dip, 206 int circular, clock_t end_time); 207 static int ndi_devi_unbind_driver(dev_info_t *dip); 208 209 static void i_ddi_check_retire(dev_info_t *dip); 210 211 static void quiesce_one_device(dev_info_t *, void *); 212 213 /* 214 * dev_info cache and node management 215 */ 216 217 /* initialize dev_info node cache */ 218 void 219 i_ddi_node_cache_init() 220 { 221 ASSERT(ddi_node_cache == NULL); 222 ddi_node_cache = kmem_cache_create("dev_info_node_cache", 223 sizeof (struct dev_info), 0, NULL, NULL, NULL, NULL, NULL, 0); 224 225 if (ddidebug & DDI_AUDIT) 226 da_log_init(); 227 } 228 229 /* 230 * Allocating a dev_info node, callable from interrupt context with KM_NOSLEEP 231 * The allocated node has a reference count of 0. 232 */ 233 dev_info_t * 234 i_ddi_alloc_node(dev_info_t *pdip, char *node_name, pnode_t nodeid, 235 int instance, ddi_prop_t *sys_prop, int flag) 236 { 237 struct dev_info *devi; 238 struct devi_nodeid *elem; 239 static char failed[] = "i_ddi_alloc_node: out of memory"; 240 241 ASSERT(node_name != NULL); 242 243 if ((devi = kmem_cache_alloc(ddi_node_cache, flag)) == NULL) { 244 cmn_err(CE_NOTE, failed); 245 return (NULL); 246 } 247 248 bzero(devi, sizeof (struct dev_info)); 249 250 if (devinfo_audit_log) { 251 devi->devi_audit = kmem_zalloc(sizeof (devinfo_audit_t), flag); 252 if (devi->devi_audit == NULL) 253 goto fail; 254 } 255 256 if ((devi->devi_node_name = i_ddi_strdup(node_name, flag)) == NULL) 257 goto fail; 258 259 /* default binding name is node name */ 260 devi->devi_binding_name = devi->devi_node_name; 261 devi->devi_major = DDI_MAJOR_T_NONE; /* unbound by default */ 262 263 /* 264 * Make a copy of system property 265 */ 266 if (sys_prop && 267 (devi->devi_sys_prop_ptr = i_ddi_prop_list_dup(sys_prop, flag)) 268 == NULL) 269 goto fail; 270 271 /* 272 * Assign devi_nodeid, devi_node_class, devi_node_attributes 273 * according to the following algorithm: 274 * 275 * nodeid arg node class node attributes 276 * 277 * DEVI_PSEUDO_NODEID DDI_NC_PSEUDO A 278 * DEVI_SID_NODEID DDI_NC_PSEUDO A,P 279 * DEVI_SID_HIDDEN_NODEID DDI_NC_PSEUDO A,P,H 280 * other DDI_NC_PROM P 281 * 282 * Where A = DDI_AUTO_ASSIGNED_NODEID (auto-assign a nodeid) 283 * and P = DDI_PERSISTENT 284 * and H = DDI_HIDDEN_NODE 285 * 286 * auto-assigned nodeids are also auto-freed. 287 */ 288 devi->devi_node_attributes = 0; 289 switch (nodeid) { 290 case DEVI_SID_HIDDEN_NODEID: 291 devi->devi_node_attributes |= DDI_HIDDEN_NODE; 292 /*FALLTHROUGH*/ 293 case DEVI_SID_NODEID: 294 devi->devi_node_attributes |= DDI_PERSISTENT; 295 if ((elem = kmem_zalloc(sizeof (*elem), flag)) == NULL) 296 goto fail; 297 /*FALLTHROUGH*/ 298 case DEVI_PSEUDO_NODEID: 299 devi->devi_node_attributes |= DDI_AUTO_ASSIGNED_NODEID; 300 devi->devi_node_class = DDI_NC_PSEUDO; 301 if (impl_ddi_alloc_nodeid(&devi->devi_nodeid)) { 302 panic("i_ddi_alloc_node: out of nodeids"); 303 /*NOTREACHED*/ 304 } 305 break; 306 default: 307 if ((elem = kmem_zalloc(sizeof (*elem), flag)) == NULL) 308 goto fail; 309 /* 310 * the nodetype is 'prom', try to 'take' the nodeid now. 311 * This requires memory allocation, so check for failure. 312 */ 313 if (impl_ddi_take_nodeid(nodeid, flag) != 0) { 314 kmem_free(elem, sizeof (*elem)); 315 goto fail; 316 } 317 318 devi->devi_nodeid = nodeid; 319 devi->devi_node_class = DDI_NC_PROM; 320 devi->devi_node_attributes = DDI_PERSISTENT; 321 322 } 323 324 if (ndi_dev_is_persistent_node((dev_info_t *)devi)) { 325 mutex_enter(&devimap->dno_lock); 326 elem->next = devimap->dno_free; 327 devimap->dno_free = elem; 328 mutex_exit(&devimap->dno_lock); 329 } 330 331 /* 332 * Instance is normally initialized to -1. In a few special 333 * cases, the caller may specify an instance (e.g. CPU nodes). 334 */ 335 devi->devi_instance = instance; 336 337 /* 338 * set parent and bus_ctl parent 339 */ 340 devi->devi_parent = DEVI(pdip); 341 devi->devi_bus_ctl = DEVI(pdip); 342 343 NDI_CONFIG_DEBUG((CE_CONT, 344 "i_ddi_alloc_node: name=%s id=%d\n", node_name, devi->devi_nodeid)); 345 346 cv_init(&(devi->devi_cv), NULL, CV_DEFAULT, NULL); 347 mutex_init(&(devi->devi_lock), NULL, MUTEX_DEFAULT, NULL); 348 mutex_init(&(devi->devi_pm_lock), NULL, MUTEX_DEFAULT, NULL); 349 mutex_init(&(devi->devi_pm_busy_lock), NULL, MUTEX_DEFAULT, NULL); 350 351 RIO_TRACE((CE_NOTE, "i_ddi_alloc_node: Initing contract fields: " 352 "dip=%p, name=%s", (void *)devi, node_name)); 353 354 mutex_init(&(devi->devi_ct_lock), NULL, MUTEX_DEFAULT, NULL); 355 cv_init(&(devi->devi_ct_cv), NULL, CV_DEFAULT, NULL); 356 devi->devi_ct_count = -1; /* counter not in use if -1 */ 357 list_create(&(devi->devi_ct), sizeof (cont_device_t), 358 offsetof(cont_device_t, cond_next)); 359 360 i_ddi_set_node_state((dev_info_t *)devi, DS_PROTO); 361 da_log_enter((dev_info_t *)devi); 362 return ((dev_info_t *)devi); 363 364 fail: 365 if (devi->devi_sys_prop_ptr) 366 i_ddi_prop_list_delete(devi->devi_sys_prop_ptr); 367 if (devi->devi_node_name) 368 kmem_free(devi->devi_node_name, strlen(node_name) + 1); 369 if (devi->devi_audit) 370 kmem_free(devi->devi_audit, sizeof (devinfo_audit_t)); 371 kmem_cache_free(ddi_node_cache, devi); 372 cmn_err(CE_NOTE, failed); 373 return (NULL); 374 } 375 376 /* 377 * free a dev_info structure. 378 * NB. Not callable from interrupt since impl_ddi_free_nodeid may block. 379 */ 380 void 381 i_ddi_free_node(dev_info_t *dip) 382 { 383 struct dev_info *devi = DEVI(dip); 384 struct devi_nodeid *elem; 385 386 ASSERT(devi->devi_ref == 0); 387 ASSERT(devi->devi_addr == NULL); 388 ASSERT(devi->devi_node_state == DS_PROTO); 389 ASSERT(devi->devi_child == NULL); 390 391 /* free devi_addr_buf allocated by ddi_set_name_addr() */ 392 if (devi->devi_addr_buf) 393 kmem_free(devi->devi_addr_buf, 2 * MAXNAMELEN); 394 395 if (i_ndi_dev_is_auto_assigned_node(dip)) 396 impl_ddi_free_nodeid(DEVI(dip)->devi_nodeid); 397 398 if (ndi_dev_is_persistent_node(dip)) { 399 mutex_enter(&devimap->dno_lock); 400 ASSERT(devimap->dno_free); 401 elem = devimap->dno_free; 402 devimap->dno_free = elem->next; 403 mutex_exit(&devimap->dno_lock); 404 kmem_free(elem, sizeof (*elem)); 405 } 406 407 if (DEVI(dip)->devi_compat_names) 408 kmem_free(DEVI(dip)->devi_compat_names, 409 DEVI(dip)->devi_compat_length); 410 if (DEVI(dip)->devi_rebinding_name) 411 kmem_free(DEVI(dip)->devi_rebinding_name, 412 strlen(DEVI(dip)->devi_rebinding_name) + 1); 413 414 ddi_prop_remove_all(dip); /* remove driver properties */ 415 if (devi->devi_sys_prop_ptr) 416 i_ddi_prop_list_delete(devi->devi_sys_prop_ptr); 417 if (devi->devi_hw_prop_ptr) 418 i_ddi_prop_list_delete(devi->devi_hw_prop_ptr); 419 420 if (DEVI(dip)->devi_devid_str) 421 ddi_devid_str_free(DEVI(dip)->devi_devid_str); 422 423 i_ddi_set_node_state(dip, DS_INVAL); 424 da_log_enter(dip); 425 if (devi->devi_audit) { 426 kmem_free(devi->devi_audit, sizeof (devinfo_audit_t)); 427 } 428 if (devi->devi_device_class) 429 kmem_free(devi->devi_device_class, 430 strlen(devi->devi_device_class) + 1); 431 cv_destroy(&(devi->devi_cv)); 432 mutex_destroy(&(devi->devi_lock)); 433 mutex_destroy(&(devi->devi_pm_lock)); 434 mutex_destroy(&(devi->devi_pm_busy_lock)); 435 436 RIO_TRACE((CE_NOTE, "i_ddi_free_node: destroying contract fields: " 437 "dip=%p", (void *)dip)); 438 contract_device_remove_dip(dip); 439 ASSERT(devi->devi_ct_count == -1); 440 ASSERT(list_is_empty(&(devi->devi_ct))); 441 cv_destroy(&(devi->devi_ct_cv)); 442 list_destroy(&(devi->devi_ct)); 443 /* free this last since contract_device_remove_dip() uses it */ 444 mutex_destroy(&(devi->devi_ct_lock)); 445 RIO_TRACE((CE_NOTE, "i_ddi_free_node: destroyed all contract fields: " 446 "dip=%p, name=%s", (void *)dip, devi->devi_node_name)); 447 448 kmem_free(devi->devi_node_name, strlen(devi->devi_node_name) + 1); 449 450 kmem_cache_free(ddi_node_cache, devi); 451 } 452 453 454 /* 455 * Node state transitions 456 */ 457 458 /* 459 * Change the node name 460 */ 461 int 462 ndi_devi_set_nodename(dev_info_t *dip, char *name, int flags) 463 { 464 _NOTE(ARGUNUSED(flags)) 465 char *nname, *oname; 466 467 ASSERT(dip && name); 468 469 oname = DEVI(dip)->devi_node_name; 470 if (strcmp(oname, name) == 0) 471 return (DDI_SUCCESS); 472 473 /* 474 * pcicfg_fix_ethernet requires a name change after node 475 * is linked into the tree. When pcicfg is fixed, we 476 * should only allow name change in DS_PROTO state. 477 */ 478 if (i_ddi_node_state(dip) >= DS_BOUND) { 479 /* 480 * Don't allow name change once node is bound 481 */ 482 cmn_err(CE_NOTE, 483 "ndi_devi_set_nodename: node already bound dip = %p," 484 " %s -> %s", (void *)dip, ddi_node_name(dip), name); 485 return (NDI_FAILURE); 486 } 487 488 nname = i_ddi_strdup(name, KM_SLEEP); 489 DEVI(dip)->devi_node_name = nname; 490 i_ddi_set_binding_name(dip, nname); 491 kmem_free(oname, strlen(oname) + 1); 492 493 da_log_enter(dip); 494 return (NDI_SUCCESS); 495 } 496 497 void 498 i_ddi_add_devimap(dev_info_t *dip) 499 { 500 struct devi_nodeid *elem; 501 502 ASSERT(dip); 503 504 if (!ndi_dev_is_persistent_node(dip)) 505 return; 506 507 ASSERT(ddi_get_parent(dip) == NULL || (DEVI_VHCI_NODE(dip)) || 508 DEVI_BUSY_OWNED(ddi_get_parent(dip))); 509 510 mutex_enter(&devimap->dno_lock); 511 512 ASSERT(devimap->dno_free); 513 514 elem = devimap->dno_free; 515 devimap->dno_free = elem->next; 516 517 elem->nodeid = ddi_get_nodeid(dip); 518 elem->dip = dip; 519 elem->next = devimap->dno_head; 520 devimap->dno_head = elem; 521 522 devimap->dno_list_length++; 523 524 mutex_exit(&devimap->dno_lock); 525 } 526 527 static int 528 i_ddi_remove_devimap(dev_info_t *dip) 529 { 530 struct devi_nodeid *prev, *elem; 531 static const char *fcn = "i_ddi_remove_devimap"; 532 533 ASSERT(dip); 534 535 if (!ndi_dev_is_persistent_node(dip)) 536 return (DDI_SUCCESS); 537 538 mutex_enter(&devimap->dno_lock); 539 540 /* 541 * The following check is done with dno_lock held 542 * to prevent race between dip removal and 543 * e_ddi_prom_node_to_dip() 544 */ 545 if (e_ddi_devi_holdcnt(dip)) { 546 mutex_exit(&devimap->dno_lock); 547 return (DDI_FAILURE); 548 } 549 550 ASSERT(devimap->dno_head); 551 ASSERT(devimap->dno_list_length > 0); 552 553 prev = NULL; 554 for (elem = devimap->dno_head; elem; elem = elem->next) { 555 if (elem->dip == dip) { 556 ASSERT(elem->nodeid == ddi_get_nodeid(dip)); 557 break; 558 } 559 prev = elem; 560 } 561 562 if (elem && prev) 563 prev->next = elem->next; 564 else if (elem) 565 devimap->dno_head = elem->next; 566 else 567 panic("%s: devinfo node(%p) not found", 568 fcn, (void *)dip); 569 570 devimap->dno_list_length--; 571 572 elem->nodeid = 0; 573 elem->dip = NULL; 574 575 elem->next = devimap->dno_free; 576 devimap->dno_free = elem; 577 578 mutex_exit(&devimap->dno_lock); 579 580 return (DDI_SUCCESS); 581 } 582 583 /* 584 * Link this node into the devinfo tree and add to orphan list 585 * Not callable from interrupt context 586 */ 587 static void 588 link_node(dev_info_t *dip) 589 { 590 struct dev_info *devi = DEVI(dip); 591 struct dev_info *parent = devi->devi_parent; 592 dev_info_t **dipp; 593 594 ASSERT(parent); /* never called for root node */ 595 596 NDI_CONFIG_DEBUG((CE_CONT, "link_node: parent = %s child = %s\n", 597 parent->devi_node_name, devi->devi_node_name)); 598 599 /* 600 * Hold the global_vhci_lock before linking any direct 601 * children of rootnex driver. This special lock protects 602 * linking and unlinking for rootnext direct children. 603 */ 604 if ((dev_info_t *)parent == ddi_root_node()) 605 mutex_enter(&global_vhci_lock); 606 607 /* 608 * attach the node to end of the list unless the node is already there 609 */ 610 dipp = (dev_info_t **)(&DEVI(parent)->devi_child); 611 while (*dipp && (*dipp != dip)) { 612 dipp = (dev_info_t **)(&DEVI(*dipp)->devi_sibling); 613 } 614 ASSERT(*dipp == NULL); /* node is not linked */ 615 616 /* 617 * Now that we are in the tree, update the devi-nodeid map. 618 */ 619 i_ddi_add_devimap(dip); 620 621 /* 622 * This is a temporary workaround for Bug 4618861. 623 * We keep the scsi_vhci nexus node on the left side of the devinfo 624 * tree (under the root nexus driver), so that virtual nodes under 625 * scsi_vhci will be SUSPENDed first and RESUMEd last. This ensures 626 * that the pHCI nodes are active during times when their clients 627 * may be depending on them. This workaround embodies the knowledge 628 * that system PM and CPR both traverse the tree left-to-right during 629 * SUSPEND and right-to-left during RESUME. 630 * Extending the workaround to IB Nexus/VHCI 631 * driver also. 632 */ 633 if (strcmp(devi->devi_binding_name, "scsi_vhci") == 0) { 634 /* Add scsi_vhci to beginning of list */ 635 ASSERT((dev_info_t *)parent == top_devinfo); 636 /* scsi_vhci under rootnex */ 637 devi->devi_sibling = parent->devi_child; 638 parent->devi_child = devi; 639 } else if (strcmp(devi->devi_binding_name, "ib") == 0) { 640 i_link_vhci_node(dip); 641 } else { 642 /* Add to end of list */ 643 *dipp = dip; 644 DEVI(dip)->devi_sibling = NULL; 645 } 646 647 /* 648 * Release the global_vhci_lock before linking any direct 649 * children of rootnex driver. 650 */ 651 if ((dev_info_t *)parent == ddi_root_node()) 652 mutex_exit(&global_vhci_lock); 653 654 /* persistent nodes go on orphan list */ 655 if (ndi_dev_is_persistent_node(dip)) 656 add_to_dn_list(&orphanlist, dip); 657 } 658 659 /* 660 * Unlink this node from the devinfo tree 661 */ 662 static int 663 unlink_node(dev_info_t *dip) 664 { 665 struct dev_info *devi = DEVI(dip); 666 struct dev_info *parent = devi->devi_parent; 667 dev_info_t **dipp; 668 669 ASSERT(parent != NULL); 670 ASSERT(devi->devi_node_state == DS_LINKED); 671 672 NDI_CONFIG_DEBUG((CE_CONT, "unlink_node: name = %s\n", 673 ddi_node_name(dip))); 674 675 /* check references */ 676 if (devi->devi_ref || i_ddi_remove_devimap(dip) != DDI_SUCCESS) 677 return (DDI_FAILURE); 678 679 /* 680 * Hold the global_vhci_lock before linking any direct 681 * children of rootnex driver. 682 */ 683 if ((dev_info_t *)parent == ddi_root_node()) 684 mutex_enter(&global_vhci_lock); 685 686 dipp = (dev_info_t **)(&DEVI(parent)->devi_child); 687 while (*dipp && (*dipp != dip)) { 688 dipp = (dev_info_t **)(&DEVI(*dipp)->devi_sibling); 689 } 690 if (*dipp) { 691 *dipp = (dev_info_t *)(devi->devi_sibling); 692 devi->devi_sibling = NULL; 693 } else { 694 NDI_CONFIG_DEBUG((CE_NOTE, "unlink_node: %s not linked", 695 devi->devi_node_name)); 696 } 697 698 /* 699 * Release the global_vhci_lock before linking any direct 700 * children of rootnex driver. 701 */ 702 if ((dev_info_t *)parent == ddi_root_node()) 703 mutex_exit(&global_vhci_lock); 704 705 /* Remove node from orphan list */ 706 if (ndi_dev_is_persistent_node(dip)) { 707 remove_from_dn_list(&orphanlist, dip); 708 } 709 710 return (DDI_SUCCESS); 711 } 712 713 /* 714 * Bind this devinfo node to a driver. If compat is NON-NULL, try that first. 715 * Else, use the node-name. 716 * 717 * NOTE: IEEE1275 specifies that nodename should be tried before compatible. 718 * Solaris implementation binds nodename after compatible. 719 * 720 * If we find a binding, 721 * - set the binding name to the string, 722 * - set major number to driver major 723 * 724 * If we don't find a binding, 725 * - return failure 726 */ 727 static int 728 bind_node(dev_info_t *dip) 729 { 730 char *p = NULL; 731 major_t major = DDI_MAJOR_T_NONE; 732 struct dev_info *devi = DEVI(dip); 733 dev_info_t *parent = ddi_get_parent(dip); 734 735 ASSERT(devi->devi_node_state == DS_LINKED); 736 737 NDI_CONFIG_DEBUG((CE_CONT, "bind_node: 0x%p(name = %s)\n", 738 (void *)dip, ddi_node_name(dip))); 739 740 mutex_enter(&DEVI(dip)->devi_lock); 741 if (DEVI(dip)->devi_flags & DEVI_NO_BIND) { 742 mutex_exit(&DEVI(dip)->devi_lock); 743 return (DDI_FAILURE); 744 } 745 mutex_exit(&DEVI(dip)->devi_lock); 746 747 /* find the driver with most specific binding using compatible */ 748 major = ddi_compatible_driver_major(dip, &p); 749 if (major == DDI_MAJOR_T_NONE) 750 return (DDI_FAILURE); 751 752 devi->devi_major = major; 753 if (p != NULL) { 754 i_ddi_set_binding_name(dip, p); 755 NDI_CONFIG_DEBUG((CE_CONT, "bind_node: %s bound to %s\n", 756 devi->devi_node_name, p)); 757 } 758 759 /* Link node to per-driver list */ 760 link_to_driver_list(dip); 761 762 /* 763 * reset parent flag so that nexus will merge .conf props 764 */ 765 if (ndi_dev_is_persistent_node(dip)) { 766 mutex_enter(&DEVI(parent)->devi_lock); 767 DEVI(parent)->devi_flags &= 768 ~(DEVI_ATTACHED_CHILDREN|DEVI_MADE_CHILDREN); 769 mutex_exit(&DEVI(parent)->devi_lock); 770 } 771 return (DDI_SUCCESS); 772 } 773 774 /* 775 * Unbind this devinfo node 776 * Called before the node is destroyed or driver is removed from system 777 */ 778 static int 779 unbind_node(dev_info_t *dip) 780 { 781 ASSERT(DEVI(dip)->devi_node_state == DS_BOUND); 782 ASSERT(DEVI(dip)->devi_major != DDI_MAJOR_T_NONE); 783 784 /* check references */ 785 if (DEVI(dip)->devi_ref) 786 return (DDI_FAILURE); 787 788 NDI_CONFIG_DEBUG((CE_CONT, "unbind_node: 0x%p(name = %s)\n", 789 (void *)dip, ddi_node_name(dip))); 790 791 unlink_from_driver_list(dip); 792 793 DEVI(dip)->devi_major = DDI_MAJOR_T_NONE; 794 DEVI(dip)->devi_binding_name = DEVI(dip)->devi_node_name; 795 return (DDI_SUCCESS); 796 } 797 798 /* 799 * Initialize a node: calls the parent nexus' bus_ctl ops to do the operation. 800 * Must hold parent and per-driver list while calling this function. 801 * A successful init_node() returns with an active ndi_hold_devi() hold on 802 * the parent. 803 */ 804 static int 805 init_node(dev_info_t *dip) 806 { 807 int error; 808 dev_info_t *pdip = ddi_get_parent(dip); 809 int (*f)(dev_info_t *, dev_info_t *, ddi_ctl_enum_t, void *, void *); 810 char *path; 811 major_t major; 812 813 ASSERT(i_ddi_node_state(dip) == DS_BOUND); 814 815 /* should be DS_READY except for pcmcia ... */ 816 ASSERT(i_ddi_node_state(pdip) >= DS_PROBED); 817 818 path = kmem_alloc(MAXPATHLEN, KM_SLEEP); 819 (void) ddi_pathname(dip, path); 820 NDI_CONFIG_DEBUG((CE_CONT, "init_node: entry: path %s 0x%p\n", 821 path, (void *)dip)); 822 823 /* 824 * The parent must have a bus_ctl operation. 825 */ 826 if ((DEVI(pdip)->devi_ops->devo_bus_ops == NULL) || 827 (f = DEVI(pdip)->devi_ops->devo_bus_ops->bus_ctl) == NULL) { 828 error = DDI_FAILURE; 829 goto out; 830 } 831 832 add_global_props(dip); 833 834 /* 835 * Invoke the parent's bus_ctl operation with the DDI_CTLOPS_INITCHILD 836 * command to transform the child to canonical form 1. If there 837 * is an error, ddi_remove_child should be called, to clean up. 838 */ 839 error = (*f)(pdip, pdip, DDI_CTLOPS_INITCHILD, dip, NULL); 840 if (error != DDI_SUCCESS) { 841 NDI_CONFIG_DEBUG((CE_CONT, "init_node: %s 0x%p failed\n", 842 path, (void *)dip)); 843 remove_global_props(dip); 844 /* in case nexus driver didn't clear this field */ 845 ddi_set_name_addr(dip, NULL); 846 error = DDI_FAILURE; 847 goto out; 848 } 849 850 ndi_hold_devi(pdip); /* initial hold of parent */ 851 852 /* recompute path after initchild for @addr information */ 853 (void) ddi_pathname(dip, path); 854 855 /* Check for duplicate nodes */ 856 if (find_duplicate_child(pdip, dip) != NULL) { 857 /* 858 * uninit_node() the duplicate - a successful uninit_node() 859 * will release inital hold of parent using ndi_rele_devi(). 860 */ 861 if ((error = uninit_node(dip)) != DDI_SUCCESS) { 862 ndi_rele_devi(pdip); /* release initial hold */ 863 cmn_err(CE_WARN, "init_node: uninit of duplicate " 864 "node %s failed", path); 865 } 866 NDI_CONFIG_DEBUG((CE_CONT, "init_node: duplicate uninit " 867 "%s 0x%p%s\n", path, (void *)dip, 868 (error == DDI_SUCCESS) ? "" : " failed")); 869 error = DDI_FAILURE; 870 goto out; 871 } 872 873 /* 874 * Check to see if we have a path-oriented driver alias that overrides 875 * the current driver binding. If so, we need to rebind. This check 876 * needs to be delayed until after a successful DDI_CTLOPS_INITCHILD, 877 * so the unit-address is established on the last component of the path. 878 * 879 * NOTE: Allowing a path-oriented alias to change the driver binding 880 * of a driver.conf node results in non-intuitive property behavior. 881 * We provide a tunable (driver_conf_allow_path_alias) to control 882 * this behavior. See uninit_node() for more details. 883 * 884 * NOTE: If you are adding a path-oriented alias for the boot device, 885 * and there is mismatch between OBP and the kernel in regard to 886 * generic name use, like "disk" .vs. "ssd", then you will need 887 * to add a path-oriented alias for both paths. 888 */ 889 major = ddi_name_to_major(path); 890 if ((major != DDI_MAJOR_T_NONE) && 891 !(devnamesp[major].dn_flags & DN_DRIVER_REMOVED) && 892 (major != DEVI(dip)->devi_major) && 893 (ndi_dev_is_persistent_node(dip) || driver_conf_allow_path_alias)) { 894 895 /* Mark node for rebind processing. */ 896 mutex_enter(&DEVI(dip)->devi_lock); 897 DEVI(dip)->devi_flags |= DEVI_REBIND; 898 mutex_exit(&DEVI(dip)->devi_lock); 899 900 /* 901 * Add an extra hold on the parent to prevent it from ever 902 * having a zero devi_ref during the child rebind process. 903 * This is necessary to ensure that the parent will never 904 * detach(9E) during the rebind. 905 */ 906 ndi_hold_devi(pdip); /* extra hold of parent */ 907 908 /* 909 * uninit_node() current binding - a successful uninit_node() 910 * will release extra hold of parent using ndi_rele_devi(). 911 */ 912 if ((error = uninit_node(dip)) != DDI_SUCCESS) { 913 ndi_rele_devi(pdip); /* release extra hold */ 914 ndi_rele_devi(pdip); /* release initial hold */ 915 cmn_err(CE_WARN, "init_node: uninit for rebind " 916 "of node %s failed", path); 917 goto out; 918 } 919 920 /* Unbind: demote the node back to DS_LINKED. */ 921 if ((error = ndi_devi_unbind_driver(dip)) != DDI_SUCCESS) { 922 ndi_rele_devi(pdip); /* release initial hold */ 923 cmn_err(CE_WARN, "init_node: unbind for rebind " 924 "of node %s failed", path); 925 goto out; 926 } 927 928 /* establish rebinding name */ 929 if (DEVI(dip)->devi_rebinding_name == NULL) 930 DEVI(dip)->devi_rebinding_name = 931 i_ddi_strdup(path, KM_SLEEP); 932 933 /* 934 * Now that we are demoted and marked for rebind, repromote. 935 * We need to do this in steps, instead of just calling 936 * ddi_initchild, so that we can redo the merge operation 937 * after we are rebound to the path-bound driver. 938 * 939 * Start by rebinding node to the path-bound driver. 940 */ 941 if ((error = ndi_devi_bind_driver(dip, 0)) != DDI_SUCCESS) { 942 ndi_rele_devi(pdip); /* release initial hold */ 943 cmn_err(CE_WARN, "init_node: rebind " 944 "of node %s failed", path); 945 goto out; 946 } 947 948 /* 949 * If the node is not a driver.conf node then merge 950 * driver.conf properties from new path-bound driver.conf. 951 */ 952 if (ndi_dev_is_persistent_node(dip)) 953 (void) i_ndi_make_spec_children(pdip, 0); 954 955 /* 956 * Now that we have taken care of merge, repromote back 957 * to DS_INITIALIZED. 958 */ 959 error = ddi_initchild(pdip, dip); 960 NDI_CONFIG_DEBUG((CE_CONT, "init_node: rebind " 961 "%s 0x%p\n", path, (void *)dip)); 962 963 /* 964 * Release our initial hold. If ddi_initchild() was 965 * successful then it will return with the active hold. 966 */ 967 ndi_rele_devi(pdip); 968 goto out; 969 } 970 971 /* 972 * Apply multi-parent/deep-nexus optimization to the new node 973 */ 974 DEVI(dip)->devi_instance = e_ddi_assign_instance(dip); 975 ddi_optimize_dtree(dip); 976 error = DDI_SUCCESS; /* return with active hold */ 977 978 out: if (error != DDI_SUCCESS) { 979 /* On failure ensure that DEVI_REBIND is cleared */ 980 mutex_enter(&DEVI(dip)->devi_lock); 981 DEVI(dip)->devi_flags &= ~DEVI_REBIND; 982 mutex_exit(&DEVI(dip)->devi_lock); 983 } 984 kmem_free(path, MAXPATHLEN); 985 return (error); 986 } 987 988 /* 989 * Uninitialize node 990 * The per-driver list must be held busy during the call. 991 * A successful uninit_node() releases the init_node() hold on 992 * the parent by calling ndi_rele_devi(). 993 */ 994 static int 995 uninit_node(dev_info_t *dip) 996 { 997 int node_state_entry; 998 dev_info_t *pdip; 999 struct dev_ops *ops; 1000 int (*f)(); 1001 int error; 1002 char *addr; 1003 1004 /* 1005 * Don't check for references here or else a ref-counted 1006 * dip cannot be downgraded by the framework. 1007 */ 1008 node_state_entry = i_ddi_node_state(dip); 1009 ASSERT((node_state_entry == DS_BOUND) || 1010 (node_state_entry == DS_INITIALIZED)); 1011 pdip = ddi_get_parent(dip); 1012 ASSERT(pdip); 1013 1014 NDI_CONFIG_DEBUG((CE_CONT, "uninit_node: 0x%p(%s%d)\n", 1015 (void *)dip, ddi_driver_name(dip), ddi_get_instance(dip))); 1016 1017 if (((ops = ddi_get_driver(pdip)) == NULL) || 1018 (ops->devo_bus_ops == NULL) || 1019 ((f = ops->devo_bus_ops->bus_ctl) == NULL)) { 1020 return (DDI_FAILURE); 1021 } 1022 1023 /* 1024 * save the @addr prior to DDI_CTLOPS_UNINITCHILD for use in 1025 * freeing the instance if it succeeds. 1026 */ 1027 if (node_state_entry == DS_INITIALIZED) { 1028 addr = ddi_get_name_addr(dip); 1029 if (addr) 1030 addr = i_ddi_strdup(addr, KM_SLEEP); 1031 } else { 1032 addr = NULL; 1033 } 1034 1035 error = (*f)(pdip, pdip, DDI_CTLOPS_UNINITCHILD, dip, (void *)NULL); 1036 if (error == DDI_SUCCESS) { 1037 /* ensure that devids are unregistered */ 1038 if (DEVI(dip)->devi_flags & DEVI_REGISTERED_DEVID) { 1039 DEVI(dip)->devi_flags &= ~DEVI_REGISTERED_DEVID; 1040 ddi_devid_unregister(dip); 1041 } 1042 1043 /* if uninitchild forgot to set devi_addr to NULL do it now */ 1044 ddi_set_name_addr(dip, NULL); 1045 1046 /* 1047 * Free instance number. This is a no-op if instance has 1048 * been kept by probe_node(). Avoid free when we are called 1049 * from init_node (DS_BOUND) because the instance has not yet 1050 * been assigned. 1051 */ 1052 if (node_state_entry == DS_INITIALIZED) { 1053 e_ddi_free_instance(dip, addr); 1054 DEVI(dip)->devi_instance = -1; 1055 } 1056 1057 /* release the init_node hold */ 1058 ndi_rele_devi(pdip); 1059 1060 remove_global_props(dip); 1061 1062 /* 1063 * NOTE: The decision on whether to allow a path-oriented 1064 * rebind of a driver.conf enumerated node is made by 1065 * init_node() based on driver_conf_allow_path_alias. The 1066 * rebind code below prevents deletion of system properties 1067 * on driver.conf nodes. 1068 * 1069 * When driver_conf_allow_path_alias is set, property behavior 1070 * on rebound driver.conf file is non-intuitive. For a 1071 * driver.conf node, the unit-address properties come from 1072 * the driver.conf file as system properties. Removing system 1073 * properties from a driver.conf node makes the node 1074 * useless (we get node without unit-address properties) - so 1075 * we leave system properties in place. The result is a node 1076 * where system properties come from the node being rebound, 1077 * and global properties come from the driver.conf file 1078 * of the driver we are rebinding to. If we could determine 1079 * that the path-oriented alias driver.conf file defined a 1080 * node at the same unit address, it would be best to use 1081 * that node and avoid the non-intuitive property behavior. 1082 * Unfortunately, the current "merge" code does not support 1083 * this, so we live with the non-intuitive property behavior. 1084 */ 1085 if (!((ndi_dev_is_persistent_node(dip) == 0) && 1086 (DEVI(dip)->devi_flags & DEVI_REBIND))) 1087 e_ddi_prop_remove_all(dip); 1088 } else { 1089 NDI_CONFIG_DEBUG((CE_CONT, "uninit_node failed: 0x%p(%s%d)\n", 1090 (void *)dip, ddi_driver_name(dip), ddi_get_instance(dip))); 1091 } 1092 1093 if (addr) 1094 kmem_free(addr, strlen(addr) + 1); 1095 return (error); 1096 } 1097 1098 /* 1099 * Invoke driver's probe entry point to probe for existence of hardware. 1100 * Keep instance permanent for successful probe and leaf nodes. 1101 * 1102 * Per-driver list must be held busy while calling this function. 1103 */ 1104 static int 1105 probe_node(dev_info_t *dip) 1106 { 1107 int rv; 1108 1109 ASSERT(i_ddi_node_state(dip) == DS_INITIALIZED); 1110 1111 NDI_CONFIG_DEBUG((CE_CONT, "probe_node: 0x%p(%s%d)\n", 1112 (void *)dip, ddi_driver_name(dip), ddi_get_instance(dip))); 1113 1114 /* temporarily hold the driver while we probe */ 1115 DEVI(dip)->devi_ops = ndi_hold_driver(dip); 1116 if (DEVI(dip)->devi_ops == NULL) { 1117 NDI_CONFIG_DEBUG((CE_CONT, 1118 "probe_node: 0x%p(%s%d) cannot load driver\n", 1119 (void *)dip, ddi_driver_name(dip), ddi_get_instance(dip))); 1120 return (DDI_FAILURE); 1121 } 1122 1123 if (identify_9e != 0) 1124 (void) devi_identify(dip); 1125 1126 rv = devi_probe(dip); 1127 1128 /* release the driver now that probe is complete */ 1129 ndi_rele_driver(dip); 1130 DEVI(dip)->devi_ops = NULL; 1131 1132 switch (rv) { 1133 case DDI_PROBE_SUCCESS: /* found */ 1134 case DDI_PROBE_DONTCARE: /* ddi_dev_is_sid */ 1135 e_ddi_keep_instance(dip); /* persist instance */ 1136 rv = DDI_SUCCESS; 1137 break; 1138 1139 case DDI_PROBE_PARTIAL: /* maybe later */ 1140 case DDI_PROBE_FAILURE: /* not found */ 1141 NDI_CONFIG_DEBUG((CE_CONT, 1142 "probe_node: 0x%p(%s%d) no hardware found%s\n", 1143 (void *)dip, ddi_driver_name(dip), ddi_get_instance(dip), 1144 (rv == DDI_PROBE_PARTIAL) ? " yet" : "")); 1145 rv = DDI_FAILURE; 1146 break; 1147 1148 default: 1149 #ifdef DEBUG 1150 cmn_err(CE_WARN, "probe_node: %s%d: illegal probe(9E) value", 1151 ddi_driver_name(dip), ddi_get_instance(dip)); 1152 #endif /* DEBUG */ 1153 rv = DDI_FAILURE; 1154 break; 1155 } 1156 return (rv); 1157 } 1158 1159 /* 1160 * Unprobe a node. Simply reset the node state. 1161 * Per-driver list must be held busy while calling this function. 1162 */ 1163 static int 1164 unprobe_node(dev_info_t *dip) 1165 { 1166 ASSERT(i_ddi_node_state(dip) == DS_PROBED); 1167 1168 /* 1169 * Don't check for references here or else a ref-counted 1170 * dip cannot be downgraded by the framework. 1171 */ 1172 1173 NDI_CONFIG_DEBUG((CE_CONT, "unprobe_node: 0x%p(name = %s)\n", 1174 (void *)dip, ddi_node_name(dip))); 1175 return (DDI_SUCCESS); 1176 } 1177 1178 /* 1179 * Attach devinfo node. 1180 * Per-driver list must be held busy. 1181 */ 1182 static int 1183 attach_node(dev_info_t *dip) 1184 { 1185 int rv; 1186 1187 ASSERT(DEVI_BUSY_OWNED(ddi_get_parent(dip))); 1188 ASSERT(i_ddi_node_state(dip) == DS_PROBED); 1189 1190 NDI_CONFIG_DEBUG((CE_CONT, "attach_node: 0x%p(%s%d)\n", 1191 (void *)dip, ddi_driver_name(dip), ddi_get_instance(dip))); 1192 1193 /* 1194 * Tell mpxio framework that a node is about to online. 1195 */ 1196 if ((rv = mdi_devi_online(dip, 0)) != NDI_SUCCESS) { 1197 return (DDI_FAILURE); 1198 } 1199 1200 /* no recursive attachment */ 1201 ASSERT(DEVI(dip)->devi_ops == NULL); 1202 1203 /* 1204 * Hold driver the node is bound to. 1205 */ 1206 DEVI(dip)->devi_ops = ndi_hold_driver(dip); 1207 if (DEVI(dip)->devi_ops == NULL) { 1208 /* 1209 * We were able to load driver for probing, so we should 1210 * not get here unless something really bad happened. 1211 */ 1212 cmn_err(CE_WARN, "attach_node: no driver for major %d", 1213 DEVI(dip)->devi_major); 1214 return (DDI_FAILURE); 1215 } 1216 1217 if (NEXUS_DRV(DEVI(dip)->devi_ops)) 1218 DEVI(dip)->devi_taskq = ddi_taskq_create(dip, 1219 "nexus_enum_tq", 1, 1220 TASKQ_DEFAULTPRI, 0); 1221 1222 mutex_enter(&(DEVI(dip)->devi_lock)); 1223 DEVI_SET_ATTACHING(dip); 1224 DEVI_SET_NEED_RESET(dip); 1225 mutex_exit(&(DEVI(dip)->devi_lock)); 1226 1227 rv = devi_attach(dip, DDI_ATTACH); 1228 1229 mutex_enter(&(DEVI(dip)->devi_lock)); 1230 DEVI_CLR_ATTACHING(dip); 1231 1232 if (rv != DDI_SUCCESS) { 1233 DEVI_CLR_NEED_RESET(dip); 1234 mutex_exit(&DEVI(dip)->devi_lock); 1235 1236 /* 1237 * Cleanup dacf reservations 1238 */ 1239 mutex_enter(&dacf_lock); 1240 dacf_clr_rsrvs(dip, DACF_OPID_POSTATTACH); 1241 dacf_clr_rsrvs(dip, DACF_OPID_PREDETACH); 1242 mutex_exit(&dacf_lock); 1243 if (DEVI(dip)->devi_taskq) 1244 ddi_taskq_destroy(DEVI(dip)->devi_taskq); 1245 ddi_remove_minor_node(dip, NULL); 1246 1247 /* release the driver if attach failed */ 1248 ndi_rele_driver(dip); 1249 DEVI(dip)->devi_ops = NULL; 1250 NDI_CONFIG_DEBUG((CE_CONT, "attach_node: 0x%p(%s%d) failed\n", 1251 (void *)dip, ddi_driver_name(dip), ddi_get_instance(dip))); 1252 return (DDI_FAILURE); 1253 } else 1254 mutex_exit(&DEVI(dip)->devi_lock); 1255 1256 /* successful attach, return with driver held */ 1257 1258 return (DDI_SUCCESS); 1259 } 1260 1261 /* 1262 * Detach devinfo node. 1263 * Per-driver list must be held busy. 1264 */ 1265 static int 1266 detach_node(dev_info_t *dip, uint_t flag) 1267 { 1268 struct devnames *dnp; 1269 int rv; 1270 1271 ASSERT(DEVI_BUSY_OWNED(ddi_get_parent(dip))); 1272 ASSERT(i_ddi_node_state(dip) == DS_ATTACHED); 1273 1274 /* check references */ 1275 if (DEVI(dip)->devi_ref) 1276 return (DDI_FAILURE); 1277 1278 NDI_CONFIG_DEBUG((CE_CONT, "detach_node: 0x%p(%s%d)\n", 1279 (void *)dip, ddi_driver_name(dip), ddi_get_instance(dip))); 1280 1281 /* 1282 * NOTE: If we are processing a pHCI node then the calling code 1283 * must detect this and ndi_devi_enter() in (vHCI, parent(pHCI)) 1284 * order unless pHCI and vHCI are siblings. Code paths leading 1285 * here that must ensure this ordering include: 1286 * unconfig_immediate_children(), devi_unconfig_one(), 1287 * ndi_devi_unconfig_one(), ndi_devi_offline(). 1288 */ 1289 ASSERT(!MDI_PHCI(dip) || 1290 (ddi_get_parent(mdi_devi_get_vdip(dip)) == ddi_get_parent(dip)) || 1291 DEVI_BUSY_OWNED(mdi_devi_get_vdip(dip))); 1292 1293 /* Offline the device node with the mpxio framework. */ 1294 if (mdi_devi_offline(dip, flag) != NDI_SUCCESS) { 1295 return (DDI_FAILURE); 1296 } 1297 1298 /* drain the taskq */ 1299 if (DEVI(dip)->devi_taskq) 1300 ddi_taskq_wait(DEVI(dip)->devi_taskq); 1301 1302 rv = devi_detach(dip, DDI_DETACH); 1303 1304 if (rv != DDI_SUCCESS) { 1305 NDI_CONFIG_DEBUG((CE_CONT, 1306 "detach_node: 0x%p(%s%d) failed\n", 1307 (void *)dip, ddi_driver_name(dip), ddi_get_instance(dip))); 1308 return (DDI_FAILURE); 1309 } 1310 1311 mutex_enter(&(DEVI(dip)->devi_lock)); 1312 DEVI_CLR_NEED_RESET(dip); 1313 mutex_exit(&(DEVI(dip)->devi_lock)); 1314 1315 #if defined(__i386) || defined(__amd64) 1316 #if !defined(__xpv) 1317 /* 1318 * Close any iommulib mediated linkage to an IOMMU 1319 */ 1320 iommulib_nex_close(dip); 1321 #endif 1322 #endif 1323 1324 /* destroy the taskq */ 1325 if (DEVI(dip)->devi_taskq) { 1326 ddi_taskq_destroy(DEVI(dip)->devi_taskq); 1327 DEVI(dip)->devi_taskq = NULL; 1328 } 1329 1330 /* Cleanup dacf reservations */ 1331 mutex_enter(&dacf_lock); 1332 dacf_clr_rsrvs(dip, DACF_OPID_POSTATTACH); 1333 dacf_clr_rsrvs(dip, DACF_OPID_PREDETACH); 1334 mutex_exit(&dacf_lock); 1335 1336 /* remove any additional flavors that were added */ 1337 if (DEVI(dip)->devi_flavorv_n > 1 && DEVI(dip)->devi_flavorv != NULL) { 1338 kmem_free(DEVI(dip)->devi_flavorv, 1339 (DEVI(dip)->devi_flavorv_n - 1) * sizeof (void *)); 1340 DEVI(dip)->devi_flavorv = NULL; 1341 } 1342 1343 /* Remove properties and minor nodes in case driver forgots */ 1344 ddi_remove_minor_node(dip, NULL); 1345 ddi_prop_remove_all(dip); 1346 1347 /* a detached node can't have attached or .conf children */ 1348 mutex_enter(&DEVI(dip)->devi_lock); 1349 DEVI(dip)->devi_flags &= ~(DEVI_MADE_CHILDREN|DEVI_ATTACHED_CHILDREN); 1350 mutex_exit(&DEVI(dip)->devi_lock); 1351 1352 /* 1353 * If the instance has successfully detached in detach_driver() context, 1354 * clear DN_DRIVER_HELD for correct ddi_hold_installed_driver() 1355 * behavior. Consumers like qassociate() depend on this (via clnopen()). 1356 */ 1357 if (flag & NDI_DETACH_DRIVER) { 1358 dnp = &(devnamesp[DEVI(dip)->devi_major]); 1359 LOCK_DEV_OPS(&dnp->dn_lock); 1360 dnp->dn_flags &= ~DN_DRIVER_HELD; 1361 UNLOCK_DEV_OPS(&dnp->dn_lock); 1362 } 1363 1364 /* successful detach, release the driver */ 1365 ndi_rele_driver(dip); 1366 DEVI(dip)->devi_ops = NULL; 1367 return (DDI_SUCCESS); 1368 } 1369 1370 /* 1371 * Run dacf post_attach routines 1372 */ 1373 static int 1374 postattach_node(dev_info_t *dip) 1375 { 1376 int rval; 1377 1378 /* 1379 * For hotplug busses like USB, it's possible that devices 1380 * are removed but dip is still around. We don't want to 1381 * run dacf routines as part of detach failure recovery. 1382 * 1383 * Pretend success until we figure out how to prevent 1384 * access to such devinfo nodes. 1385 */ 1386 if (DEVI_IS_DEVICE_REMOVED(dip)) 1387 return (DDI_SUCCESS); 1388 1389 /* 1390 * if dacf_postattach failed, report it to the framework 1391 * so that it can be retried later at the open time. 1392 */ 1393 mutex_enter(&dacf_lock); 1394 rval = dacfc_postattach(dip); 1395 mutex_exit(&dacf_lock); 1396 1397 /* 1398 * Plumbing during postattach may fail because of the 1399 * underlying device is not ready. This will fail ndi_devi_config() 1400 * in dv_filldir() and a warning message is issued. The message 1401 * from here will explain what happened 1402 */ 1403 if (rval != DACF_SUCCESS) { 1404 cmn_err(CE_WARN, "Postattach failed for %s%d\n", 1405 ddi_driver_name(dip), ddi_get_instance(dip)); 1406 return (DDI_FAILURE); 1407 } 1408 1409 return (DDI_SUCCESS); 1410 } 1411 1412 /* 1413 * Run dacf pre-detach routines 1414 */ 1415 static int 1416 predetach_node(dev_info_t *dip, uint_t flag) 1417 { 1418 int ret; 1419 1420 /* 1421 * Don't auto-detach if DDI_FORCEATTACH or DDI_NO_AUTODETACH 1422 * properties are set. 1423 */ 1424 if (flag & NDI_AUTODETACH) { 1425 struct devnames *dnp; 1426 int pflag = DDI_PROP_NOTPROM | DDI_PROP_DONTPASS; 1427 1428 if ((ddi_prop_get_int(DDI_DEV_T_ANY, dip, 1429 pflag, DDI_FORCEATTACH, 0) == 1) || 1430 (ddi_prop_get_int(DDI_DEV_T_ANY, dip, 1431 pflag, DDI_NO_AUTODETACH, 0) == 1)) 1432 return (DDI_FAILURE); 1433 1434 /* check for driver global version of DDI_NO_AUTODETACH */ 1435 dnp = &devnamesp[DEVI(dip)->devi_major]; 1436 LOCK_DEV_OPS(&dnp->dn_lock); 1437 if (dnp->dn_flags & DN_NO_AUTODETACH) { 1438 UNLOCK_DEV_OPS(&dnp->dn_lock); 1439 return (DDI_FAILURE); 1440 } 1441 UNLOCK_DEV_OPS(&dnp->dn_lock); 1442 } 1443 1444 mutex_enter(&dacf_lock); 1445 ret = dacfc_predetach(dip); 1446 mutex_exit(&dacf_lock); 1447 1448 return (ret); 1449 } 1450 1451 /* 1452 * Wrapper for making multiple state transitions 1453 */ 1454 1455 /* 1456 * i_ndi_config_node: upgrade dev_info node into a specified state. 1457 * It is a bit tricky because the locking protocol changes before and 1458 * after a node is bound to a driver. All locks are held external to 1459 * this function. 1460 */ 1461 int 1462 i_ndi_config_node(dev_info_t *dip, ddi_node_state_t state, uint_t flag) 1463 { 1464 _NOTE(ARGUNUSED(flag)) 1465 int rv = DDI_SUCCESS; 1466 1467 ASSERT(DEVI_BUSY_OWNED(ddi_get_parent(dip))); 1468 1469 while ((i_ddi_node_state(dip) < state) && (rv == DDI_SUCCESS)) { 1470 1471 /* don't allow any more changes to the device tree */ 1472 if (devinfo_freeze) { 1473 rv = DDI_FAILURE; 1474 break; 1475 } 1476 1477 switch (i_ddi_node_state(dip)) { 1478 case DS_PROTO: 1479 /* 1480 * only caller can reference this node, no external 1481 * locking needed. 1482 */ 1483 link_node(dip); 1484 i_ddi_set_node_state(dip, DS_LINKED); 1485 break; 1486 case DS_LINKED: 1487 /* 1488 * Three code path may attempt to bind a node: 1489 * - boot code 1490 * - add_drv 1491 * - hotplug thread 1492 * Boot code is single threaded, add_drv synchronize 1493 * on a userland lock, and hotplug synchronize on 1494 * hotplug_lk. There could be a race between add_drv 1495 * and hotplug thread. We'll live with this until the 1496 * conversion to top-down loading. 1497 */ 1498 if ((rv = bind_node(dip)) == DDI_SUCCESS) 1499 i_ddi_set_node_state(dip, DS_BOUND); 1500 1501 break; 1502 case DS_BOUND: 1503 /* 1504 * The following transitions synchronizes on the 1505 * per-driver busy changing flag, since we already 1506 * have a driver. 1507 */ 1508 if ((rv = init_node(dip)) == DDI_SUCCESS) 1509 i_ddi_set_node_state(dip, DS_INITIALIZED); 1510 break; 1511 case DS_INITIALIZED: 1512 if ((rv = probe_node(dip)) == DDI_SUCCESS) 1513 i_ddi_set_node_state(dip, DS_PROBED); 1514 break; 1515 case DS_PROBED: 1516 i_ddi_check_retire(dip); 1517 atomic_add_long(&devinfo_attach_detach, 1); 1518 if ((rv = attach_node(dip)) == DDI_SUCCESS) 1519 i_ddi_set_node_state(dip, DS_ATTACHED); 1520 atomic_add_long(&devinfo_attach_detach, -1); 1521 break; 1522 case DS_ATTACHED: 1523 if ((rv = postattach_node(dip)) == DDI_SUCCESS) 1524 i_ddi_set_node_state(dip, DS_READY); 1525 break; 1526 case DS_READY: 1527 break; 1528 default: 1529 /* should never reach here */ 1530 ASSERT("unknown devinfo state"); 1531 } 1532 } 1533 1534 if (ddidebug & DDI_AUDIT) 1535 da_log_enter(dip); 1536 return (rv); 1537 } 1538 1539 /* 1540 * i_ndi_unconfig_node: downgrade dev_info node into a specified state. 1541 */ 1542 int 1543 i_ndi_unconfig_node(dev_info_t *dip, ddi_node_state_t state, uint_t flag) 1544 { 1545 int rv = DDI_SUCCESS; 1546 1547 ASSERT(DEVI_BUSY_OWNED(ddi_get_parent(dip))); 1548 1549 while ((i_ddi_node_state(dip) > state) && (rv == DDI_SUCCESS)) { 1550 1551 /* don't allow any more changes to the device tree */ 1552 if (devinfo_freeze) { 1553 rv = DDI_FAILURE; 1554 break; 1555 } 1556 1557 switch (i_ddi_node_state(dip)) { 1558 case DS_PROTO: 1559 break; 1560 case DS_LINKED: 1561 /* 1562 * Persistent nodes are only removed by hotplug code 1563 * .conf nodes synchronizes on per-driver list. 1564 */ 1565 if ((rv = unlink_node(dip)) == DDI_SUCCESS) 1566 i_ddi_set_node_state(dip, DS_PROTO); 1567 break; 1568 case DS_BOUND: 1569 /* 1570 * The following transitions synchronizes on the 1571 * per-driver busy changing flag, since we already 1572 * have a driver. 1573 */ 1574 if ((rv = unbind_node(dip)) == DDI_SUCCESS) 1575 i_ddi_set_node_state(dip, DS_LINKED); 1576 break; 1577 case DS_INITIALIZED: 1578 if ((rv = uninit_node(dip)) == DDI_SUCCESS) 1579 i_ddi_set_node_state(dip, DS_BOUND); 1580 break; 1581 case DS_PROBED: 1582 if ((rv = unprobe_node(dip)) == DDI_SUCCESS) 1583 i_ddi_set_node_state(dip, DS_INITIALIZED); 1584 break; 1585 case DS_ATTACHED: 1586 atomic_add_long(&devinfo_attach_detach, 1); 1587 1588 mutex_enter(&(DEVI(dip)->devi_lock)); 1589 DEVI_SET_DETACHING(dip); 1590 mutex_exit(&(DEVI(dip)->devi_lock)); 1591 1592 membar_enter(); /* ensure visibility for hold_devi */ 1593 1594 if ((rv = detach_node(dip, flag)) == DDI_SUCCESS) 1595 i_ddi_set_node_state(dip, DS_PROBED); 1596 1597 mutex_enter(&(DEVI(dip)->devi_lock)); 1598 DEVI_CLR_DETACHING(dip); 1599 mutex_exit(&(DEVI(dip)->devi_lock)); 1600 1601 atomic_add_long(&devinfo_attach_detach, -1); 1602 break; 1603 case DS_READY: 1604 if ((rv = predetach_node(dip, flag)) == DDI_SUCCESS) 1605 i_ddi_set_node_state(dip, DS_ATTACHED); 1606 break; 1607 default: 1608 ASSERT("unknown devinfo state"); 1609 } 1610 } 1611 da_log_enter(dip); 1612 return (rv); 1613 } 1614 1615 /* 1616 * ddi_initchild: transform node to DS_INITIALIZED state 1617 */ 1618 int 1619 ddi_initchild(dev_info_t *parent, dev_info_t *proto) 1620 { 1621 int ret, circ; 1622 1623 ndi_devi_enter(parent, &circ); 1624 ret = i_ndi_config_node(proto, DS_INITIALIZED, 0); 1625 ndi_devi_exit(parent, circ); 1626 1627 return (ret); 1628 } 1629 1630 /* 1631 * ddi_uninitchild: transform node down to DS_BOUND state 1632 */ 1633 int 1634 ddi_uninitchild(dev_info_t *dip) 1635 { 1636 int ret, circ; 1637 dev_info_t *parent = ddi_get_parent(dip); 1638 ASSERT(parent); 1639 1640 ndi_devi_enter(parent, &circ); 1641 ret = i_ndi_unconfig_node(dip, DS_BOUND, 0); 1642 ndi_devi_exit(parent, circ); 1643 1644 return (ret); 1645 } 1646 1647 /* 1648 * i_ddi_attachchild: transform node to DS_READY/i_ddi_devi_attached() state 1649 */ 1650 static int 1651 i_ddi_attachchild(dev_info_t *dip) 1652 { 1653 dev_info_t *parent = ddi_get_parent(dip); 1654 int ret; 1655 1656 ASSERT(parent && DEVI_BUSY_OWNED(parent)); 1657 1658 if ((i_ddi_node_state(dip) < DS_BOUND) || DEVI_IS_DEVICE_OFFLINE(dip)) 1659 return (DDI_FAILURE); 1660 1661 ret = i_ndi_config_node(dip, DS_READY, 0); 1662 if (ret == NDI_SUCCESS) { 1663 ret = DDI_SUCCESS; 1664 } else { 1665 /* 1666 * Take it down to DS_INITIALIZED so pm_pre_probe is run 1667 * on the next attach 1668 */ 1669 (void) i_ndi_unconfig_node(dip, DS_INITIALIZED, 0); 1670 ret = DDI_FAILURE; 1671 } 1672 1673 return (ret); 1674 } 1675 1676 /* 1677 * i_ddi_detachchild: transform node down to DS_PROBED state 1678 * If it fails, put it back to DS_READY state. 1679 * NOTE: A node that fails detach may be at DS_ATTACHED instead 1680 * of DS_READY for a small amount of time - this is the source of 1681 * transient DS_READY->DS_ATTACHED->DS_READY state changes. 1682 */ 1683 static int 1684 i_ddi_detachchild(dev_info_t *dip, uint_t flags) 1685 { 1686 dev_info_t *parent = ddi_get_parent(dip); 1687 int ret; 1688 1689 ASSERT(parent && DEVI_BUSY_OWNED(parent)); 1690 1691 ret = i_ndi_unconfig_node(dip, DS_PROBED, flags); 1692 if (ret != DDI_SUCCESS) 1693 (void) i_ndi_config_node(dip, DS_READY, 0); 1694 else 1695 /* allow pm_pre_probe to reestablish pm state */ 1696 (void) i_ndi_unconfig_node(dip, DS_INITIALIZED, 0); 1697 return (ret); 1698 } 1699 1700 /* 1701 * Add a child and bind to driver 1702 */ 1703 dev_info_t * 1704 ddi_add_child(dev_info_t *pdip, char *name, uint_t nodeid, uint_t unit) 1705 { 1706 int circ; 1707 dev_info_t *dip; 1708 1709 /* allocate a new node */ 1710 dip = i_ddi_alloc_node(pdip, name, nodeid, (int)unit, NULL, KM_SLEEP); 1711 1712 ndi_devi_enter(pdip, &circ); 1713 (void) i_ndi_config_node(dip, DS_BOUND, 0); 1714 ndi_devi_exit(pdip, circ); 1715 return (dip); 1716 } 1717 1718 /* 1719 * ddi_remove_child: remove the dip. The parent must be attached and held 1720 */ 1721 int 1722 ddi_remove_child(dev_info_t *dip, int dummy) 1723 { 1724 _NOTE(ARGUNUSED(dummy)) 1725 int circ, ret; 1726 dev_info_t *parent = ddi_get_parent(dip); 1727 ASSERT(parent); 1728 1729 ndi_devi_enter(parent, &circ); 1730 1731 /* 1732 * If we still have children, for example SID nodes marked 1733 * as persistent but not attached, attempt to remove them. 1734 */ 1735 if (DEVI(dip)->devi_child) { 1736 ret = ndi_devi_unconfig(dip, NDI_DEVI_REMOVE); 1737 if (ret != NDI_SUCCESS) { 1738 ndi_devi_exit(parent, circ); 1739 return (DDI_FAILURE); 1740 } 1741 ASSERT(DEVI(dip)->devi_child == NULL); 1742 } 1743 1744 ret = i_ndi_unconfig_node(dip, DS_PROTO, 0); 1745 ndi_devi_exit(parent, circ); 1746 1747 if (ret != DDI_SUCCESS) 1748 return (ret); 1749 1750 ASSERT(i_ddi_node_state(dip) == DS_PROTO); 1751 i_ddi_free_node(dip); 1752 return (DDI_SUCCESS); 1753 } 1754 1755 /* 1756 * NDI wrappers for ref counting, node allocation, and transitions 1757 */ 1758 1759 /* 1760 * Hold/release the devinfo node itself. 1761 * Caller is assumed to prevent the devi from detaching during this call 1762 */ 1763 void 1764 ndi_hold_devi(dev_info_t *dip) 1765 { 1766 mutex_enter(&DEVI(dip)->devi_lock); 1767 ASSERT(DEVI(dip)->devi_ref >= 0); 1768 DEVI(dip)->devi_ref++; 1769 membar_enter(); /* make sure stores are flushed */ 1770 mutex_exit(&DEVI(dip)->devi_lock); 1771 } 1772 1773 void 1774 ndi_rele_devi(dev_info_t *dip) 1775 { 1776 ASSERT(DEVI(dip)->devi_ref > 0); 1777 1778 mutex_enter(&DEVI(dip)->devi_lock); 1779 DEVI(dip)->devi_ref--; 1780 membar_enter(); /* make sure stores are flushed */ 1781 mutex_exit(&DEVI(dip)->devi_lock); 1782 } 1783 1784 int 1785 e_ddi_devi_holdcnt(dev_info_t *dip) 1786 { 1787 return (DEVI(dip)->devi_ref); 1788 } 1789 1790 /* 1791 * Hold/release the driver the devinfo node is bound to. 1792 */ 1793 struct dev_ops * 1794 ndi_hold_driver(dev_info_t *dip) 1795 { 1796 if (i_ddi_node_state(dip) < DS_BOUND) 1797 return (NULL); 1798 1799 ASSERT(DEVI(dip)->devi_major != -1); 1800 return (mod_hold_dev_by_major(DEVI(dip)->devi_major)); 1801 } 1802 1803 void 1804 ndi_rele_driver(dev_info_t *dip) 1805 { 1806 ASSERT(i_ddi_node_state(dip) >= DS_BOUND); 1807 mod_rele_dev_by_major(DEVI(dip)->devi_major); 1808 } 1809 1810 /* 1811 * Single thread entry into devinfo node for modifying its children (devinfo, 1812 * pathinfo, and minor). To verify in ASSERTS use DEVI_BUSY_OWNED macro. 1813 */ 1814 void 1815 ndi_devi_enter(dev_info_t *dip, int *circular) 1816 { 1817 struct dev_info *devi = DEVI(dip); 1818 ASSERT(dip != NULL); 1819 1820 /* for vHCI, enforce (vHCI, pHCI) ndi_deve_enter() order */ 1821 ASSERT(!MDI_VHCI(dip) || (mdi_devi_pdip_entered(dip) == 0) || 1822 DEVI_BUSY_OWNED(dip)); 1823 1824 mutex_enter(&devi->devi_lock); 1825 if (devi->devi_busy_thread == curthread) { 1826 devi->devi_circular++; 1827 } else { 1828 while (DEVI_BUSY_CHANGING(devi) && !panicstr) 1829 cv_wait(&(devi->devi_cv), &(devi->devi_lock)); 1830 if (panicstr) { 1831 mutex_exit(&devi->devi_lock); 1832 return; 1833 } 1834 devi->devi_flags |= DEVI_BUSY; 1835 devi->devi_busy_thread = curthread; 1836 } 1837 *circular = devi->devi_circular; 1838 mutex_exit(&devi->devi_lock); 1839 } 1840 1841 /* 1842 * Release ndi_devi_enter or successful ndi_devi_tryenter. 1843 */ 1844 void 1845 ndi_devi_exit(dev_info_t *dip, int circular) 1846 { 1847 struct dev_info *devi = DEVI(dip); 1848 struct dev_info *vdevi; 1849 ASSERT(dip != NULL); 1850 1851 if (panicstr) 1852 return; 1853 1854 mutex_enter(&(devi->devi_lock)); 1855 if (circular != 0) { 1856 devi->devi_circular--; 1857 } else { 1858 devi->devi_flags &= ~DEVI_BUSY; 1859 ASSERT(devi->devi_busy_thread == curthread); 1860 devi->devi_busy_thread = NULL; 1861 cv_broadcast(&(devi->devi_cv)); 1862 } 1863 mutex_exit(&(devi->devi_lock)); 1864 1865 /* 1866 * For pHCI exit we issue a broadcast to vHCI for ndi_devi_config_one() 1867 * doing cv_wait on vHCI. 1868 */ 1869 if (MDI_PHCI(dip)) { 1870 vdevi = DEVI(mdi_devi_get_vdip(dip)); 1871 if (vdevi) { 1872 mutex_enter(&(vdevi->devi_lock)); 1873 if (vdevi->devi_flags & DEVI_PHCI_SIGNALS_VHCI) { 1874 vdevi->devi_flags &= ~DEVI_PHCI_SIGNALS_VHCI; 1875 cv_broadcast(&(vdevi->devi_cv)); 1876 } 1877 mutex_exit(&(vdevi->devi_lock)); 1878 } 1879 } 1880 } 1881 1882 /* 1883 * Release ndi_devi_enter and wait for possibility of new children, avoiding 1884 * possibility of missing broadcast before getting to cv_timedwait(). 1885 */ 1886 static void 1887 ndi_devi_exit_and_wait(dev_info_t *dip, int circular, clock_t end_time) 1888 { 1889 struct dev_info *devi = DEVI(dip); 1890 ASSERT(dip != NULL); 1891 1892 if (panicstr) 1893 return; 1894 1895 /* 1896 * We are called to wait for of a new child, and new child can 1897 * only be added if circular is zero. 1898 */ 1899 ASSERT(circular == 0); 1900 1901 /* like ndi_devi_exit with circular of zero */ 1902 mutex_enter(&(devi->devi_lock)); 1903 devi->devi_flags &= ~DEVI_BUSY; 1904 ASSERT(devi->devi_busy_thread == curthread); 1905 devi->devi_busy_thread = NULL; 1906 cv_broadcast(&(devi->devi_cv)); 1907 1908 /* now wait for new children while still holding devi_lock */ 1909 (void) cv_timedwait(&devi->devi_cv, &(devi->devi_lock), end_time); 1910 mutex_exit(&(devi->devi_lock)); 1911 } 1912 1913 /* 1914 * Attempt to single thread entry into devinfo node for modifying its children. 1915 */ 1916 int 1917 ndi_devi_tryenter(dev_info_t *dip, int *circular) 1918 { 1919 int rval = 1; /* assume we enter */ 1920 struct dev_info *devi = DEVI(dip); 1921 ASSERT(dip != NULL); 1922 1923 mutex_enter(&devi->devi_lock); 1924 if (devi->devi_busy_thread == (void *)curthread) { 1925 devi->devi_circular++; 1926 } else { 1927 if (!DEVI_BUSY_CHANGING(devi)) { 1928 devi->devi_flags |= DEVI_BUSY; 1929 devi->devi_busy_thread = (void *)curthread; 1930 } else { 1931 rval = 0; /* devi is busy */ 1932 } 1933 } 1934 *circular = devi->devi_circular; 1935 mutex_exit(&devi->devi_lock); 1936 return (rval); 1937 } 1938 1939 /* 1940 * Allocate and initialize a new dev_info structure. 1941 * 1942 * This routine may be called at interrupt time by a nexus in 1943 * response to a hotplug event, therefore memory allocations are 1944 * not allowed to sleep. 1945 */ 1946 int 1947 ndi_devi_alloc(dev_info_t *parent, char *node_name, pnode_t nodeid, 1948 dev_info_t **ret_dip) 1949 { 1950 ASSERT(node_name != NULL); 1951 ASSERT(ret_dip != NULL); 1952 1953 *ret_dip = i_ddi_alloc_node(parent, node_name, nodeid, -1, NULL, 1954 KM_NOSLEEP); 1955 if (*ret_dip == NULL) { 1956 return (NDI_NOMEM); 1957 } 1958 1959 return (NDI_SUCCESS); 1960 } 1961 1962 /* 1963 * Allocate and initialize a new dev_info structure 1964 * This routine may sleep and should not be called at interrupt time 1965 */ 1966 void 1967 ndi_devi_alloc_sleep(dev_info_t *parent, char *node_name, pnode_t nodeid, 1968 dev_info_t **ret_dip) 1969 { 1970 ASSERT(node_name != NULL); 1971 ASSERT(ret_dip != NULL); 1972 1973 *ret_dip = i_ddi_alloc_node(parent, node_name, nodeid, -1, NULL, 1974 KM_SLEEP); 1975 ASSERT(*ret_dip); 1976 } 1977 1978 /* 1979 * Remove an initialized (but not yet attached) dev_info 1980 * node from it's parent. 1981 */ 1982 int 1983 ndi_devi_free(dev_info_t *dip) 1984 { 1985 ASSERT(dip != NULL); 1986 1987 if (i_ddi_node_state(dip) >= DS_INITIALIZED) 1988 return (DDI_FAILURE); 1989 1990 NDI_CONFIG_DEBUG((CE_CONT, "ndi_devi_free: %s%d (%p)\n", 1991 ddi_driver_name(dip), ddi_get_instance(dip), (void *)dip)); 1992 1993 (void) ddi_remove_child(dip, 0); 1994 1995 return (NDI_SUCCESS); 1996 } 1997 1998 /* 1999 * ndi_devi_bind_driver() binds a driver to a given device. If it fails 2000 * to bind the driver, it returns an appropriate error back. Some drivers 2001 * may want to know if the actually failed to bind. 2002 */ 2003 int 2004 ndi_devi_bind_driver(dev_info_t *dip, uint_t flags) 2005 { 2006 int ret = NDI_FAILURE; 2007 int circ; 2008 dev_info_t *pdip = ddi_get_parent(dip); 2009 ASSERT(pdip); 2010 2011 NDI_CONFIG_DEBUG((CE_CONT, 2012 "ndi_devi_bind_driver: %s%d (%p) flags: %x\n", 2013 ddi_driver_name(dip), ddi_get_instance(dip), (void *)dip, flags)); 2014 2015 ndi_devi_enter(pdip, &circ); 2016 if (i_ndi_config_node(dip, DS_BOUND, flags) == DDI_SUCCESS) 2017 ret = NDI_SUCCESS; 2018 ndi_devi_exit(pdip, circ); 2019 2020 return (ret); 2021 } 2022 2023 /* 2024 * ndi_devi_unbind_driver: unbind the dip 2025 */ 2026 static int 2027 ndi_devi_unbind_driver(dev_info_t *dip) 2028 { 2029 ASSERT(DEVI_BUSY_OWNED(ddi_get_parent(dip))); 2030 2031 return (i_ndi_unconfig_node(dip, DS_LINKED, 0)); 2032 } 2033 2034 /* 2035 * Misc. help routines called by framework only 2036 */ 2037 2038 /* 2039 * Get the state of node 2040 */ 2041 ddi_node_state_t 2042 i_ddi_node_state(dev_info_t *dip) 2043 { 2044 return (DEVI(dip)->devi_node_state); 2045 } 2046 2047 /* 2048 * Set the state of node 2049 */ 2050 void 2051 i_ddi_set_node_state(dev_info_t *dip, ddi_node_state_t state) 2052 { 2053 DEVI(dip)->devi_node_state = state; 2054 membar_enter(); /* make sure stores are flushed */ 2055 } 2056 2057 /* 2058 * Determine if node is attached. The implementation accommodates transient 2059 * DS_READY->DS_ATTACHED->DS_READY state changes. Outside this file, this 2060 * function should be instead of i_ddi_node_state() DS_ATTACHED/DS_READY 2061 * state checks. 2062 */ 2063 int 2064 i_ddi_devi_attached(dev_info_t *dip) 2065 { 2066 return (DEVI(dip)->devi_node_state >= DS_ATTACHED); 2067 } 2068 2069 /* 2070 * Common function for finding a node in a sibling list given name and addr. 2071 * 2072 * By default, name is matched with devi_node_name. The following 2073 * alternative match strategies are supported: 2074 * 2075 * FIND_NODE_BY_NODENAME: Match on node name - typical use. 2076 * 2077 * FIND_NODE_BY_DRIVER: A match on driver name bound to node is conducted. 2078 * This support is used for support of OBP generic names and 2079 * for the conversion from driver names to generic names. When 2080 * more consistency in the generic name environment is achieved 2081 * (and not needed for upgrade) this support can be removed. 2082 * 2083 * FIND_NODE_BY_ADDR: Match on just the addr. 2084 * This support is only used/needed during boot to match 2085 * a node bound via a path-based driver alias. 2086 * 2087 * If a child is not named (dev_addr == NULL), there are three 2088 * possible actions: 2089 * 2090 * (1) skip it 2091 * (2) FIND_ADDR_BY_INIT: bring child to DS_INITIALIZED state 2092 * (3) FIND_ADDR_BY_CALLBACK: use a caller-supplied callback function 2093 */ 2094 #define FIND_NODE_BY_NODENAME 0x01 2095 #define FIND_NODE_BY_DRIVER 0x02 2096 #define FIND_NODE_BY_ADDR 0x04 2097 #define FIND_ADDR_BY_INIT 0x10 2098 #define FIND_ADDR_BY_CALLBACK 0x20 2099 2100 static dev_info_t * 2101 find_sibling(dev_info_t *head, char *cname, char *caddr, uint_t flag, 2102 int (*callback)(dev_info_t *, char *, int)) 2103 { 2104 dev_info_t *dip; 2105 char *addr, *buf; 2106 major_t major; 2107 uint_t by; 2108 2109 /* only one way to find a node */ 2110 by = flag & 2111 (FIND_NODE_BY_DRIVER | FIND_NODE_BY_NODENAME | FIND_NODE_BY_ADDR); 2112 ASSERT(by && BIT_ONLYONESET(by)); 2113 2114 /* only one way to name a node */ 2115 ASSERT(((flag & FIND_ADDR_BY_INIT) == 0) || 2116 ((flag & FIND_ADDR_BY_CALLBACK) == 0)); 2117 2118 if (by == FIND_NODE_BY_DRIVER) { 2119 major = ddi_name_to_major(cname); 2120 if (major == DDI_MAJOR_T_NONE) 2121 return (NULL); 2122 } 2123 2124 /* preallocate buffer of naming node by callback */ 2125 if (flag & FIND_ADDR_BY_CALLBACK) 2126 buf = kmem_alloc(MAXNAMELEN, KM_SLEEP); 2127 2128 /* 2129 * Walk the child list to find a match 2130 */ 2131 2132 for (dip = head; dip; dip = ddi_get_next_sibling(dip)) { 2133 if (by == FIND_NODE_BY_NODENAME) { 2134 /* match node name */ 2135 if (strcmp(cname, DEVI(dip)->devi_node_name) != 0) 2136 continue; 2137 } else if (by == FIND_NODE_BY_DRIVER) { 2138 /* match driver major */ 2139 if (DEVI(dip)->devi_major != major) 2140 continue; 2141 } 2142 2143 if ((addr = DEVI(dip)->devi_addr) == NULL) { 2144 /* name the child based on the flag */ 2145 if (flag & FIND_ADDR_BY_INIT) { 2146 if (ddi_initchild(ddi_get_parent(dip), dip) 2147 != DDI_SUCCESS) 2148 continue; 2149 addr = DEVI(dip)->devi_addr; 2150 } else if (flag & FIND_ADDR_BY_CALLBACK) { 2151 if ((callback == NULL) || (callback( 2152 dip, buf, MAXNAMELEN) != DDI_SUCCESS)) 2153 continue; 2154 addr = buf; 2155 } else { 2156 continue; /* skip */ 2157 } 2158 } 2159 2160 /* match addr */ 2161 ASSERT(addr != NULL); 2162 if (strcmp(caddr, addr) == 0) 2163 break; /* node found */ 2164 2165 } 2166 if (flag & FIND_ADDR_BY_CALLBACK) 2167 kmem_free(buf, MAXNAMELEN); 2168 return (dip); 2169 } 2170 2171 /* 2172 * Find child of pdip with name: cname@caddr 2173 * Called by init_node() to look for duplicate nodes 2174 */ 2175 static dev_info_t * 2176 find_duplicate_child(dev_info_t *pdip, dev_info_t *dip) 2177 { 2178 dev_info_t *dup; 2179 char *cname = DEVI(dip)->devi_node_name; 2180 char *caddr = DEVI(dip)->devi_addr; 2181 2182 /* search nodes before dip */ 2183 dup = find_sibling(ddi_get_child(pdip), cname, caddr, 2184 FIND_NODE_BY_NODENAME, NULL); 2185 if (dup != dip) 2186 return (dup); 2187 2188 /* 2189 * search nodes after dip; normally this is not needed, 2190 */ 2191 return (find_sibling(ddi_get_next_sibling(dip), cname, caddr, 2192 FIND_NODE_BY_NODENAME, NULL)); 2193 } 2194 2195 /* 2196 * Find a child of a given name and address, using a callback to name 2197 * unnamed children. cname is the binding name. 2198 */ 2199 static dev_info_t * 2200 find_child_by_callback(dev_info_t *pdip, char *cname, char *caddr, 2201 int (*name_node)(dev_info_t *, char *, int)) 2202 { 2203 return (find_sibling(ddi_get_child(pdip), cname, caddr, 2204 FIND_NODE_BY_DRIVER|FIND_ADDR_BY_CALLBACK, name_node)); 2205 } 2206 2207 /* 2208 * Find a child of a given name and address, invoking initchild to name 2209 * unnamed children. cname is the node name. 2210 */ 2211 static dev_info_t * 2212 find_child_by_name(dev_info_t *pdip, char *cname, char *caddr) 2213 { 2214 dev_info_t *dip; 2215 2216 /* attempt search without changing state of preceding siblings */ 2217 dip = find_sibling(ddi_get_child(pdip), cname, caddr, 2218 FIND_NODE_BY_NODENAME, NULL); 2219 if (dip) 2220 return (dip); 2221 2222 return (find_sibling(ddi_get_child(pdip), cname, caddr, 2223 FIND_NODE_BY_NODENAME|FIND_ADDR_BY_INIT, NULL)); 2224 } 2225 2226 /* 2227 * Find a child of a given name and address, invoking initchild to name 2228 * unnamed children. cname is the node name. 2229 */ 2230 static dev_info_t * 2231 find_child_by_driver(dev_info_t *pdip, char *cname, char *caddr) 2232 { 2233 dev_info_t *dip; 2234 2235 /* attempt search without changing state of preceding siblings */ 2236 dip = find_sibling(ddi_get_child(pdip), cname, caddr, 2237 FIND_NODE_BY_DRIVER, NULL); 2238 if (dip) 2239 return (dip); 2240 2241 return (find_sibling(ddi_get_child(pdip), cname, caddr, 2242 FIND_NODE_BY_DRIVER|FIND_ADDR_BY_INIT, NULL)); 2243 } 2244 2245 /* 2246 * Find a child of a given address, invoking initchild to name 2247 * unnamed children. cname is the node name. 2248 * 2249 * NOTE: This function is only used during boot. One would hope that 2250 * unique sibling unit-addresses on hardware branches of the tree would 2251 * be a requirement to avoid two drivers trying to control the same 2252 * piece of hardware. Unfortunately there are some cases where this 2253 * situation exists (/ssm@0,0/pci@1c,700000 /ssm@0,0/sghsc@1c,700000). 2254 * Until unit-address uniqueness of siblings is guaranteed, use of this 2255 * interface for purposes other than boot should be avoided. 2256 */ 2257 static dev_info_t * 2258 find_child_by_addr(dev_info_t *pdip, char *caddr) 2259 { 2260 dev_info_t *dip; 2261 2262 /* return NULL if called without a unit-address */ 2263 if ((caddr == NULL) || (*caddr == '\0')) 2264 return (NULL); 2265 2266 /* attempt search without changing state of preceding siblings */ 2267 dip = find_sibling(ddi_get_child(pdip), NULL, caddr, 2268 FIND_NODE_BY_ADDR, NULL); 2269 if (dip) 2270 return (dip); 2271 2272 return (find_sibling(ddi_get_child(pdip), NULL, caddr, 2273 FIND_NODE_BY_ADDR|FIND_ADDR_BY_INIT, NULL)); 2274 } 2275 2276 /* 2277 * Deleting a property list. Take care, since some property structures 2278 * may not be fully built. 2279 */ 2280 void 2281 i_ddi_prop_list_delete(ddi_prop_t *prop) 2282 { 2283 while (prop) { 2284 ddi_prop_t *next = prop->prop_next; 2285 if (prop->prop_name) 2286 kmem_free(prop->prop_name, strlen(prop->prop_name) + 1); 2287 if ((prop->prop_len != 0) && prop->prop_val) 2288 kmem_free(prop->prop_val, prop->prop_len); 2289 kmem_free(prop, sizeof (struct ddi_prop)); 2290 prop = next; 2291 } 2292 } 2293 2294 /* 2295 * Duplicate property list 2296 */ 2297 ddi_prop_t * 2298 i_ddi_prop_list_dup(ddi_prop_t *prop, uint_t flag) 2299 { 2300 ddi_prop_t *result, *prev, *copy; 2301 2302 if (prop == NULL) 2303 return (NULL); 2304 2305 result = prev = NULL; 2306 for (; prop != NULL; prop = prop->prop_next) { 2307 ASSERT(prop->prop_name != NULL); 2308 copy = kmem_zalloc(sizeof (struct ddi_prop), flag); 2309 if (copy == NULL) 2310 goto fail; 2311 2312 copy->prop_dev = prop->prop_dev; 2313 copy->prop_flags = prop->prop_flags; 2314 copy->prop_name = i_ddi_strdup(prop->prop_name, flag); 2315 if (copy->prop_name == NULL) 2316 goto fail; 2317 2318 if ((copy->prop_len = prop->prop_len) != 0) { 2319 copy->prop_val = kmem_zalloc(prop->prop_len, flag); 2320 if (copy->prop_val == NULL) 2321 goto fail; 2322 2323 bcopy(prop->prop_val, copy->prop_val, prop->prop_len); 2324 } 2325 2326 if (prev == NULL) 2327 result = prev = copy; 2328 else 2329 prev->prop_next = copy; 2330 prev = copy; 2331 } 2332 return (result); 2333 2334 fail: 2335 i_ddi_prop_list_delete(result); 2336 return (NULL); 2337 } 2338 2339 /* 2340 * Create a reference property list, currently used only for 2341 * driver global properties. Created with ref count of 1. 2342 */ 2343 ddi_prop_list_t * 2344 i_ddi_prop_list_create(ddi_prop_t *props) 2345 { 2346 ddi_prop_list_t *list = kmem_alloc(sizeof (*list), KM_SLEEP); 2347 list->prop_list = props; 2348 list->prop_ref = 1; 2349 return (list); 2350 } 2351 2352 /* 2353 * Increment/decrement reference count. The reference is 2354 * protected by dn_lock. The only interfaces modifying 2355 * dn_global_prop_ptr is in impl_make[free]_parlist(). 2356 */ 2357 void 2358 i_ddi_prop_list_hold(ddi_prop_list_t *prop_list, struct devnames *dnp) 2359 { 2360 ASSERT(prop_list->prop_ref >= 0); 2361 ASSERT(mutex_owned(&dnp->dn_lock)); 2362 prop_list->prop_ref++; 2363 } 2364 2365 void 2366 i_ddi_prop_list_rele(ddi_prop_list_t *prop_list, struct devnames *dnp) 2367 { 2368 ASSERT(prop_list->prop_ref > 0); 2369 ASSERT(mutex_owned(&dnp->dn_lock)); 2370 prop_list->prop_ref--; 2371 2372 if (prop_list->prop_ref == 0) { 2373 i_ddi_prop_list_delete(prop_list->prop_list); 2374 kmem_free(prop_list, sizeof (*prop_list)); 2375 } 2376 } 2377 2378 /* 2379 * Free table of classes by drivers 2380 */ 2381 void 2382 i_ddi_free_exported_classes(char **classes, int n) 2383 { 2384 if ((n == 0) || (classes == NULL)) 2385 return; 2386 2387 kmem_free(classes, n * sizeof (char *)); 2388 } 2389 2390 /* 2391 * Get all classes exported by dip 2392 */ 2393 int 2394 i_ddi_get_exported_classes(dev_info_t *dip, char ***classes) 2395 { 2396 extern void lock_hw_class_list(); 2397 extern void unlock_hw_class_list(); 2398 extern int get_class(const char *, char **); 2399 2400 static char *rootclass = "root"; 2401 int n = 0, nclass = 0; 2402 char **buf; 2403 2404 ASSERT(i_ddi_node_state(dip) >= DS_BOUND); 2405 2406 if (dip == ddi_root_node()) /* rootnode exports class "root" */ 2407 nclass = 1; 2408 lock_hw_class_list(); 2409 nclass += get_class(ddi_driver_name(dip), NULL); 2410 if (nclass == 0) { 2411 unlock_hw_class_list(); 2412 return (0); /* no class exported */ 2413 } 2414 2415 *classes = buf = kmem_alloc(nclass * sizeof (char *), KM_SLEEP); 2416 if (dip == ddi_root_node()) { 2417 *buf++ = rootclass; 2418 n = 1; 2419 } 2420 n += get_class(ddi_driver_name(dip), buf); 2421 unlock_hw_class_list(); 2422 2423 ASSERT(n == nclass); /* make sure buf wasn't overrun */ 2424 return (nclass); 2425 } 2426 2427 /* 2428 * Helper functions, returns NULL if no memory. 2429 */ 2430 char * 2431 i_ddi_strdup(char *str, uint_t flag) 2432 { 2433 char *copy; 2434 2435 if (str == NULL) 2436 return (NULL); 2437 2438 copy = kmem_alloc(strlen(str) + 1, flag); 2439 if (copy == NULL) 2440 return (NULL); 2441 2442 (void) strcpy(copy, str); 2443 return (copy); 2444 } 2445 2446 /* 2447 * Load driver.conf file for major. Load all if major == -1. 2448 * 2449 * This is called 2450 * - early in boot after devnames array is initialized 2451 * - from vfs code when certain file systems are mounted 2452 * - from add_drv when a new driver is added 2453 */ 2454 int 2455 i_ddi_load_drvconf(major_t major) 2456 { 2457 extern int modrootloaded; 2458 2459 major_t low, high, m; 2460 2461 if (major == DDI_MAJOR_T_NONE) { 2462 low = 0; 2463 high = devcnt - 1; 2464 } else { 2465 if (major >= devcnt) 2466 return (EINVAL); 2467 low = high = major; 2468 } 2469 2470 for (m = low; m <= high; m++) { 2471 struct devnames *dnp = &devnamesp[m]; 2472 LOCK_DEV_OPS(&dnp->dn_lock); 2473 dnp->dn_flags &= ~DN_DRIVER_HELD; 2474 (void) impl_make_parlist(m); 2475 UNLOCK_DEV_OPS(&dnp->dn_lock); 2476 } 2477 2478 if (modrootloaded) { 2479 ddi_walk_devs(ddi_root_node(), reset_nexus_flags, 2480 (void *)(uintptr_t)major); 2481 } 2482 2483 /* build dn_list from old entries in path_to_inst */ 2484 e_ddi_unorphan_instance_nos(); 2485 return (0); 2486 } 2487 2488 /* 2489 * Unload a specific driver.conf. 2490 * Don't support unload all because it doesn't make any sense 2491 */ 2492 int 2493 i_ddi_unload_drvconf(major_t major) 2494 { 2495 int error; 2496 struct devnames *dnp; 2497 2498 if (major >= devcnt) 2499 return (EINVAL); 2500 2501 /* 2502 * Take the per-driver lock while unloading driver.conf 2503 */ 2504 dnp = &devnamesp[major]; 2505 LOCK_DEV_OPS(&dnp->dn_lock); 2506 error = impl_free_parlist(major); 2507 UNLOCK_DEV_OPS(&dnp->dn_lock); 2508 return (error); 2509 } 2510 2511 /* 2512 * Merge a .conf node. This is called by nexus drivers to augment 2513 * hw node with properties specified in driver.conf file. This function 2514 * takes a callback routine to name nexus children. 2515 * The parent node must be held busy. 2516 * 2517 * It returns DDI_SUCCESS if the node is merged and DDI_FAILURE otherwise. 2518 */ 2519 int 2520 ndi_merge_node(dev_info_t *dip, int (*name_node)(dev_info_t *, char *, int)) 2521 { 2522 dev_info_t *hwdip; 2523 2524 ASSERT(ndi_dev_is_persistent_node(dip) == 0); 2525 ASSERT(ddi_get_name_addr(dip) != NULL); 2526 2527 hwdip = find_child_by_callback(ddi_get_parent(dip), 2528 ddi_binding_name(dip), ddi_get_name_addr(dip), name_node); 2529 2530 /* 2531 * Look for the hardware node that is the target of the merge; 2532 * return failure if not found. 2533 */ 2534 if ((hwdip == NULL) || (hwdip == dip)) { 2535 char *buf = kmem_alloc(MAXNAMELEN, KM_SLEEP); 2536 NDI_CONFIG_DEBUG((CE_WARN, "No HW node to merge conf node %s", 2537 ddi_deviname(dip, buf))); 2538 kmem_free(buf, MAXNAMELEN); 2539 return (DDI_FAILURE); 2540 } 2541 2542 /* 2543 * Make sure the hardware node is uninitialized and has no property. 2544 * This may not be the case if new .conf files are load after some 2545 * hardware nodes have already been initialized and attached. 2546 * 2547 * N.B. We return success here because the node was *intended* 2548 * to be a merge node because there is a hw node with the name. 2549 */ 2550 mutex_enter(&DEVI(hwdip)->devi_lock); 2551 if (ndi_dev_is_persistent_node(hwdip) == 0) { 2552 char *buf; 2553 mutex_exit(&DEVI(hwdip)->devi_lock); 2554 2555 buf = kmem_alloc(MAXNAMELEN, KM_SLEEP); 2556 NDI_CONFIG_DEBUG((CE_NOTE, "Duplicate .conf node %s", 2557 ddi_deviname(dip, buf))); 2558 kmem_free(buf, MAXNAMELEN); 2559 return (DDI_SUCCESS); 2560 } 2561 2562 /* 2563 * If it is possible that the hardware has already been touched 2564 * then don't merge. 2565 */ 2566 if (i_ddi_node_state(hwdip) >= DS_INITIALIZED || 2567 (DEVI(hwdip)->devi_sys_prop_ptr != NULL) || 2568 (DEVI(hwdip)->devi_drv_prop_ptr != NULL)) { 2569 char *buf; 2570 mutex_exit(&DEVI(hwdip)->devi_lock); 2571 2572 buf = kmem_alloc(MAXNAMELEN, KM_SLEEP); 2573 NDI_CONFIG_DEBUG((CE_NOTE, 2574 "!Cannot merge .conf node %s with hw node %p " 2575 "-- not in proper state", 2576 ddi_deviname(dip, buf), (void *)hwdip)); 2577 kmem_free(buf, MAXNAMELEN); 2578 return (DDI_SUCCESS); 2579 } 2580 2581 mutex_enter(&DEVI(dip)->devi_lock); 2582 DEVI(hwdip)->devi_sys_prop_ptr = DEVI(dip)->devi_sys_prop_ptr; 2583 DEVI(hwdip)->devi_drv_prop_ptr = DEVI(dip)->devi_drv_prop_ptr; 2584 DEVI(dip)->devi_sys_prop_ptr = NULL; 2585 DEVI(dip)->devi_drv_prop_ptr = NULL; 2586 mutex_exit(&DEVI(dip)->devi_lock); 2587 mutex_exit(&DEVI(hwdip)->devi_lock); 2588 2589 return (DDI_SUCCESS); 2590 } 2591 2592 /* 2593 * Merge a "wildcard" .conf node. This is called by nexus drivers to 2594 * augment a set of hw node with properties specified in driver.conf file. 2595 * The parent node must be held busy. 2596 * 2597 * There is no failure mode, since the nexus may or may not have child 2598 * node bound the driver specified by the wildcard node. 2599 */ 2600 void 2601 ndi_merge_wildcard_node(dev_info_t *dip) 2602 { 2603 dev_info_t *hwdip; 2604 dev_info_t *pdip = ddi_get_parent(dip); 2605 major_t major = ddi_driver_major(dip); 2606 2607 /* never attempt to merge a hw node */ 2608 ASSERT(ndi_dev_is_persistent_node(dip) == 0); 2609 /* must be bound to a driver major number */ 2610 ASSERT(major != DDI_MAJOR_T_NONE); 2611 2612 /* 2613 * Walk the child list to find all nodes bound to major 2614 * and copy properties. 2615 */ 2616 mutex_enter(&DEVI(dip)->devi_lock); 2617 ASSERT(DEVI_BUSY_OWNED(pdip)); 2618 for (hwdip = ddi_get_child(pdip); hwdip; 2619 hwdip = ddi_get_next_sibling(hwdip)) { 2620 /* 2621 * Skip nodes not bound to same driver 2622 */ 2623 if (ddi_driver_major(hwdip) != major) 2624 continue; 2625 2626 /* 2627 * Skip .conf nodes 2628 */ 2629 if (ndi_dev_is_persistent_node(hwdip) == 0) 2630 continue; 2631 2632 /* 2633 * Make sure the node is uninitialized and has no property. 2634 */ 2635 mutex_enter(&DEVI(hwdip)->devi_lock); 2636 if (i_ddi_node_state(hwdip) >= DS_INITIALIZED || 2637 (DEVI(hwdip)->devi_sys_prop_ptr != NULL) || 2638 (DEVI(hwdip)->devi_drv_prop_ptr != NULL)) { 2639 mutex_exit(&DEVI(hwdip)->devi_lock); 2640 NDI_CONFIG_DEBUG((CE_NOTE, "HW node %p state not " 2641 "suitable for merging wildcard conf node %s", 2642 (void *)hwdip, ddi_node_name(dip))); 2643 continue; 2644 } 2645 2646 DEVI(hwdip)->devi_sys_prop_ptr = 2647 i_ddi_prop_list_dup(DEVI(dip)->devi_sys_prop_ptr, KM_SLEEP); 2648 DEVI(hwdip)->devi_drv_prop_ptr = 2649 i_ddi_prop_list_dup(DEVI(dip)->devi_drv_prop_ptr, KM_SLEEP); 2650 mutex_exit(&DEVI(hwdip)->devi_lock); 2651 } 2652 mutex_exit(&DEVI(dip)->devi_lock); 2653 } 2654 2655 /* 2656 * Return the major number based on the compatible property. This interface 2657 * may be used in situations where we are trying to detect if a better driver 2658 * now exists for a device, so it must use the 'compatible' property. If 2659 * a non-NULL formp is specified and the binding was based on compatible then 2660 * return the pointer to the form used in *formp. 2661 */ 2662 major_t 2663 ddi_compatible_driver_major(dev_info_t *dip, char **formp) 2664 { 2665 struct dev_info *devi = DEVI(dip); 2666 void *compat; 2667 size_t len; 2668 char *p = NULL; 2669 major_t major = DDI_MAJOR_T_NONE; 2670 2671 if (formp) 2672 *formp = NULL; 2673 2674 /* 2675 * Highest precedence binding is a path-oriented alias. Since this 2676 * requires a 'path', this type of binding occurs via more obtuse 2677 * 'rebind'. The need for a path-oriented alias 'rebind' is detected 2678 * after a successful DDI_CTLOPS_INITCHILD to another driver: this is 2679 * is the first point at which the unit-address (or instance) of the 2680 * last component of the path is available (even though the path is 2681 * bound to the wrong driver at this point). 2682 */ 2683 if (devi->devi_flags & DEVI_REBIND) { 2684 p = devi->devi_rebinding_name; 2685 major = ddi_name_to_major(p); 2686 if ((major != DDI_MAJOR_T_NONE) && 2687 !(devnamesp[major].dn_flags & DN_DRIVER_REMOVED)) { 2688 if (formp) 2689 *formp = p; 2690 return (major); 2691 } 2692 2693 /* 2694 * If for some reason devi_rebinding_name no longer resolves 2695 * to a proper driver then clear DEVI_REBIND. 2696 */ 2697 mutex_enter(&devi->devi_lock); 2698 devi->devi_flags &= ~DEVI_REBIND; 2699 mutex_exit(&devi->devi_lock); 2700 } 2701 2702 /* look up compatible property */ 2703 (void) lookup_compatible(dip, KM_SLEEP); 2704 compat = (void *)(devi->devi_compat_names); 2705 len = devi->devi_compat_length; 2706 2707 /* find the highest precedence compatible form with a driver binding */ 2708 while ((p = prom_decode_composite_string(compat, len, p)) != NULL) { 2709 major = ddi_name_to_major(p); 2710 if ((major != DDI_MAJOR_T_NONE) && 2711 !(devnamesp[major].dn_flags & DN_DRIVER_REMOVED)) { 2712 if (formp) 2713 *formp = p; 2714 return (major); 2715 } 2716 } 2717 2718 /* 2719 * none of the compatible forms have a driver binding, see if 2720 * the node name has a driver binding. 2721 */ 2722 major = ddi_name_to_major(ddi_node_name(dip)); 2723 if ((major != DDI_MAJOR_T_NONE) && 2724 !(devnamesp[major].dn_flags & DN_DRIVER_REMOVED)) 2725 return (major); 2726 2727 /* no driver */ 2728 return (DDI_MAJOR_T_NONE); 2729 } 2730 2731 /* 2732 * Static help functions 2733 */ 2734 2735 /* 2736 * lookup the "compatible" property and cache it's contents in the 2737 * device node. 2738 */ 2739 static int 2740 lookup_compatible(dev_info_t *dip, uint_t flag) 2741 { 2742 int rv; 2743 int prop_flags; 2744 uint_t ncompatstrs; 2745 char **compatstrpp; 2746 char *di_compat_strp; 2747 size_t di_compat_strlen; 2748 2749 if (DEVI(dip)->devi_compat_names) { 2750 return (DDI_SUCCESS); 2751 } 2752 2753 prop_flags = DDI_PROP_TYPE_STRING | DDI_PROP_DONTPASS; 2754 2755 if (flag & KM_NOSLEEP) { 2756 prop_flags |= DDI_PROP_DONTSLEEP; 2757 } 2758 2759 if (ndi_dev_is_prom_node(dip) == 0) { 2760 prop_flags |= DDI_PROP_NOTPROM; 2761 } 2762 2763 rv = ddi_prop_lookup_common(DDI_DEV_T_ANY, dip, prop_flags, 2764 "compatible", &compatstrpp, &ncompatstrs, 2765 ddi_prop_fm_decode_strings); 2766 2767 if (rv == DDI_PROP_NOT_FOUND) { 2768 return (DDI_SUCCESS); 2769 } 2770 2771 if (rv != DDI_PROP_SUCCESS) { 2772 return (DDI_FAILURE); 2773 } 2774 2775 /* 2776 * encode the compatible property data in the dev_info node 2777 */ 2778 rv = DDI_SUCCESS; 2779 if (ncompatstrs != 0) { 2780 di_compat_strp = encode_composite_string(compatstrpp, 2781 ncompatstrs, &di_compat_strlen, flag); 2782 if (di_compat_strp != NULL) { 2783 DEVI(dip)->devi_compat_names = di_compat_strp; 2784 DEVI(dip)->devi_compat_length = di_compat_strlen; 2785 } else { 2786 rv = DDI_FAILURE; 2787 } 2788 } 2789 ddi_prop_free(compatstrpp); 2790 return (rv); 2791 } 2792 2793 /* 2794 * Create a composite string from a list of strings. 2795 * 2796 * A composite string consists of a single buffer containing one 2797 * or more NULL terminated strings. 2798 */ 2799 static char * 2800 encode_composite_string(char **strings, uint_t nstrings, size_t *retsz, 2801 uint_t flag) 2802 { 2803 uint_t index; 2804 char **strpp; 2805 uint_t slen; 2806 size_t cbuf_sz = 0; 2807 char *cbuf_p; 2808 char *cbuf_ip; 2809 2810 if (strings == NULL || nstrings == 0 || retsz == NULL) { 2811 return (NULL); 2812 } 2813 2814 for (index = 0, strpp = strings; index < nstrings; index++) 2815 cbuf_sz += strlen(*(strpp++)) + 1; 2816 2817 if ((cbuf_p = kmem_alloc(cbuf_sz, flag)) == NULL) { 2818 cmn_err(CE_NOTE, 2819 "?failed to allocate device node compatstr"); 2820 return (NULL); 2821 } 2822 2823 cbuf_ip = cbuf_p; 2824 for (index = 0, strpp = strings; index < nstrings; index++) { 2825 slen = strlen(*strpp); 2826 bcopy(*(strpp++), cbuf_ip, slen); 2827 cbuf_ip += slen; 2828 *(cbuf_ip++) = '\0'; 2829 } 2830 2831 *retsz = cbuf_sz; 2832 return (cbuf_p); 2833 } 2834 2835 static void 2836 link_to_driver_list(dev_info_t *dip) 2837 { 2838 major_t major = DEVI(dip)->devi_major; 2839 struct devnames *dnp; 2840 2841 ASSERT(major != DDI_MAJOR_T_NONE); 2842 2843 /* 2844 * Remove from orphan list 2845 */ 2846 if (ndi_dev_is_persistent_node(dip)) { 2847 dnp = &orphanlist; 2848 remove_from_dn_list(dnp, dip); 2849 } 2850 2851 /* 2852 * Add to per driver list 2853 */ 2854 dnp = &devnamesp[major]; 2855 add_to_dn_list(dnp, dip); 2856 } 2857 2858 static void 2859 unlink_from_driver_list(dev_info_t *dip) 2860 { 2861 major_t major = DEVI(dip)->devi_major; 2862 struct devnames *dnp; 2863 2864 ASSERT(major != DDI_MAJOR_T_NONE); 2865 2866 /* 2867 * Remove from per-driver list 2868 */ 2869 dnp = &devnamesp[major]; 2870 remove_from_dn_list(dnp, dip); 2871 2872 /* 2873 * Add to orphan list 2874 */ 2875 if (ndi_dev_is_persistent_node(dip)) { 2876 dnp = &orphanlist; 2877 add_to_dn_list(dnp, dip); 2878 } 2879 } 2880 2881 /* 2882 * scan the per-driver list looking for dev_info "dip" 2883 */ 2884 static dev_info_t * 2885 in_dn_list(struct devnames *dnp, dev_info_t *dip) 2886 { 2887 struct dev_info *idevi; 2888 2889 if ((idevi = DEVI(dnp->dn_head)) == NULL) 2890 return (NULL); 2891 2892 while (idevi) { 2893 if (idevi == DEVI(dip)) 2894 return (dip); 2895 idevi = idevi->devi_next; 2896 } 2897 return (NULL); 2898 } 2899 2900 /* 2901 * insert devinfo node 'dip' into the per-driver instance list 2902 * headed by 'dnp' 2903 * 2904 * Nodes on the per-driver list are ordered: HW - SID - PSEUDO. The order is 2905 * required for merging of .conf file data to work properly. 2906 */ 2907 static void 2908 add_to_ordered_dn_list(struct devnames *dnp, dev_info_t *dip) 2909 { 2910 dev_info_t **dipp; 2911 2912 ASSERT(mutex_owned(&(dnp->dn_lock))); 2913 2914 dipp = &dnp->dn_head; 2915 if (ndi_dev_is_prom_node(dip)) { 2916 /* 2917 * Find the first non-prom node or end of list 2918 */ 2919 while (*dipp && (ndi_dev_is_prom_node(*dipp) != 0)) { 2920 dipp = (dev_info_t **)&DEVI(*dipp)->devi_next; 2921 } 2922 } else if (ndi_dev_is_persistent_node(dip)) { 2923 /* 2924 * Find the first non-persistent node 2925 */ 2926 while (*dipp && (ndi_dev_is_persistent_node(*dipp) != 0)) { 2927 dipp = (dev_info_t **)&DEVI(*dipp)->devi_next; 2928 } 2929 } else { 2930 /* 2931 * Find the end of the list 2932 */ 2933 while (*dipp) { 2934 dipp = (dev_info_t **)&DEVI(*dipp)->devi_next; 2935 } 2936 } 2937 2938 DEVI(dip)->devi_next = DEVI(*dipp); 2939 *dipp = dip; 2940 } 2941 2942 /* 2943 * add a list of device nodes to the device node list in the 2944 * devnames structure 2945 */ 2946 static void 2947 add_to_dn_list(struct devnames *dnp, dev_info_t *dip) 2948 { 2949 /* 2950 * Look to see if node already exists 2951 */ 2952 LOCK_DEV_OPS(&(dnp->dn_lock)); 2953 if (in_dn_list(dnp, dip)) { 2954 cmn_err(CE_NOTE, "add_to_dn_list: node %s already in list", 2955 DEVI(dip)->devi_node_name); 2956 } else { 2957 add_to_ordered_dn_list(dnp, dip); 2958 } 2959 UNLOCK_DEV_OPS(&(dnp->dn_lock)); 2960 } 2961 2962 static void 2963 remove_from_dn_list(struct devnames *dnp, dev_info_t *dip) 2964 { 2965 dev_info_t **plist; 2966 2967 LOCK_DEV_OPS(&(dnp->dn_lock)); 2968 2969 plist = (dev_info_t **)&dnp->dn_head; 2970 while (*plist && (*plist != dip)) { 2971 plist = (dev_info_t **)&DEVI(*plist)->devi_next; 2972 } 2973 2974 if (*plist != NULL) { 2975 ASSERT(*plist == dip); 2976 *plist = (dev_info_t *)(DEVI(dip)->devi_next); 2977 DEVI(dip)->devi_next = NULL; 2978 } else { 2979 NDI_CONFIG_DEBUG((CE_NOTE, 2980 "remove_from_dn_list: node %s not found in list", 2981 DEVI(dip)->devi_node_name)); 2982 } 2983 2984 UNLOCK_DEV_OPS(&(dnp->dn_lock)); 2985 } 2986 2987 /* 2988 * Add and remove reference driver global property list 2989 */ 2990 static void 2991 add_global_props(dev_info_t *dip) 2992 { 2993 struct devnames *dnp; 2994 ddi_prop_list_t *plist; 2995 2996 ASSERT(DEVI(dip)->devi_global_prop_list == NULL); 2997 ASSERT(DEVI(dip)->devi_major != DDI_MAJOR_T_NONE); 2998 2999 dnp = &devnamesp[DEVI(dip)->devi_major]; 3000 LOCK_DEV_OPS(&dnp->dn_lock); 3001 plist = dnp->dn_global_prop_ptr; 3002 if (plist == NULL) { 3003 UNLOCK_DEV_OPS(&dnp->dn_lock); 3004 return; 3005 } 3006 i_ddi_prop_list_hold(plist, dnp); 3007 UNLOCK_DEV_OPS(&dnp->dn_lock); 3008 3009 mutex_enter(&DEVI(dip)->devi_lock); 3010 DEVI(dip)->devi_global_prop_list = plist; 3011 mutex_exit(&DEVI(dip)->devi_lock); 3012 } 3013 3014 static void 3015 remove_global_props(dev_info_t *dip) 3016 { 3017 ddi_prop_list_t *proplist; 3018 3019 mutex_enter(&DEVI(dip)->devi_lock); 3020 proplist = DEVI(dip)->devi_global_prop_list; 3021 DEVI(dip)->devi_global_prop_list = NULL; 3022 mutex_exit(&DEVI(dip)->devi_lock); 3023 3024 if (proplist) { 3025 major_t major; 3026 struct devnames *dnp; 3027 3028 major = ddi_driver_major(dip); 3029 ASSERT(major != DDI_MAJOR_T_NONE); 3030 dnp = &devnamesp[major]; 3031 LOCK_DEV_OPS(&dnp->dn_lock); 3032 i_ddi_prop_list_rele(proplist, dnp); 3033 UNLOCK_DEV_OPS(&dnp->dn_lock); 3034 } 3035 } 3036 3037 #ifdef DEBUG 3038 /* 3039 * Set this variable to '0' to disable the optimization, 3040 * and to 2 to print debug message. 3041 */ 3042 static int optimize_dtree = 1; 3043 3044 static void 3045 debug_dtree(dev_info_t *devi, struct dev_info *adevi, char *service) 3046 { 3047 char *adeviname, *buf; 3048 3049 /* 3050 * Don't print unless optimize dtree is set to 2+ 3051 */ 3052 if (optimize_dtree <= 1) 3053 return; 3054 3055 buf = kmem_alloc(MAXNAMELEN, KM_SLEEP); 3056 adeviname = ddi_deviname((dev_info_t *)adevi, buf); 3057 if (*adeviname == '\0') 3058 adeviname = "root"; 3059 3060 cmn_err(CE_CONT, "%s %s -> %s\n", 3061 ddi_deviname(devi, buf), service, adeviname); 3062 3063 kmem_free(buf, MAXNAMELEN); 3064 } 3065 #else /* DEBUG */ 3066 #define debug_dtree(a1, a2, a3) /* nothing */ 3067 #endif /* DEBUG */ 3068 3069 static void 3070 ddi_optimize_dtree(dev_info_t *devi) 3071 { 3072 struct dev_info *pdevi; 3073 struct bus_ops *b; 3074 3075 pdevi = DEVI(devi)->devi_parent; 3076 ASSERT(pdevi); 3077 3078 /* 3079 * Set the unoptimized values 3080 */ 3081 DEVI(devi)->devi_bus_map_fault = pdevi; 3082 DEVI(devi)->devi_bus_dma_map = pdevi; 3083 DEVI(devi)->devi_bus_dma_allochdl = pdevi; 3084 DEVI(devi)->devi_bus_dma_freehdl = pdevi; 3085 DEVI(devi)->devi_bus_dma_bindhdl = pdevi; 3086 DEVI(devi)->devi_bus_dma_bindfunc = 3087 pdevi->devi_ops->devo_bus_ops->bus_dma_bindhdl; 3088 DEVI(devi)->devi_bus_dma_unbindhdl = pdevi; 3089 DEVI(devi)->devi_bus_dma_unbindfunc = 3090 pdevi->devi_ops->devo_bus_ops->bus_dma_unbindhdl; 3091 DEVI(devi)->devi_bus_dma_flush = pdevi; 3092 DEVI(devi)->devi_bus_dma_win = pdevi; 3093 DEVI(devi)->devi_bus_dma_ctl = pdevi; 3094 DEVI(devi)->devi_bus_ctl = pdevi; 3095 3096 #ifdef DEBUG 3097 if (optimize_dtree == 0) 3098 return; 3099 #endif /* DEBUG */ 3100 3101 b = pdevi->devi_ops->devo_bus_ops; 3102 3103 if (i_ddi_map_fault == b->bus_map_fault) { 3104 DEVI(devi)->devi_bus_map_fault = pdevi->devi_bus_map_fault; 3105 debug_dtree(devi, DEVI(devi)->devi_bus_map_fault, 3106 "bus_map_fault"); 3107 } 3108 3109 if (ddi_dma_map == b->bus_dma_map) { 3110 DEVI(devi)->devi_bus_dma_map = pdevi->devi_bus_dma_map; 3111 debug_dtree(devi, DEVI(devi)->devi_bus_dma_map, "bus_dma_map"); 3112 } 3113 3114 if (ddi_dma_allochdl == b->bus_dma_allochdl) { 3115 DEVI(devi)->devi_bus_dma_allochdl = 3116 pdevi->devi_bus_dma_allochdl; 3117 debug_dtree(devi, DEVI(devi)->devi_bus_dma_allochdl, 3118 "bus_dma_allochdl"); 3119 } 3120 3121 if (ddi_dma_freehdl == b->bus_dma_freehdl) { 3122 DEVI(devi)->devi_bus_dma_freehdl = pdevi->devi_bus_dma_freehdl; 3123 debug_dtree(devi, DEVI(devi)->devi_bus_dma_freehdl, 3124 "bus_dma_freehdl"); 3125 } 3126 3127 if (ddi_dma_bindhdl == b->bus_dma_bindhdl) { 3128 DEVI(devi)->devi_bus_dma_bindhdl = pdevi->devi_bus_dma_bindhdl; 3129 DEVI(devi)->devi_bus_dma_bindfunc = 3130 pdevi->devi_bus_dma_bindhdl->devi_ops-> 3131 devo_bus_ops->bus_dma_bindhdl; 3132 debug_dtree(devi, DEVI(devi)->devi_bus_dma_bindhdl, 3133 "bus_dma_bindhdl"); 3134 } 3135 3136 if (ddi_dma_unbindhdl == b->bus_dma_unbindhdl) { 3137 DEVI(devi)->devi_bus_dma_unbindhdl = 3138 pdevi->devi_bus_dma_unbindhdl; 3139 DEVI(devi)->devi_bus_dma_unbindfunc = 3140 pdevi->devi_bus_dma_unbindhdl->devi_ops-> 3141 devo_bus_ops->bus_dma_unbindhdl; 3142 debug_dtree(devi, DEVI(devi)->devi_bus_dma_unbindhdl, 3143 "bus_dma_unbindhdl"); 3144 } 3145 3146 if (ddi_dma_flush == b->bus_dma_flush) { 3147 DEVI(devi)->devi_bus_dma_flush = pdevi->devi_bus_dma_flush; 3148 debug_dtree(devi, DEVI(devi)->devi_bus_dma_flush, 3149 "bus_dma_flush"); 3150 } 3151 3152 if (ddi_dma_win == b->bus_dma_win) { 3153 DEVI(devi)->devi_bus_dma_win = pdevi->devi_bus_dma_win; 3154 debug_dtree(devi, DEVI(devi)->devi_bus_dma_win, 3155 "bus_dma_win"); 3156 } 3157 3158 if (ddi_dma_mctl == b->bus_dma_ctl) { 3159 DEVI(devi)->devi_bus_dma_ctl = pdevi->devi_bus_dma_ctl; 3160 debug_dtree(devi, DEVI(devi)->devi_bus_dma_ctl, "bus_dma_ctl"); 3161 } 3162 3163 if (ddi_ctlops == b->bus_ctl) { 3164 DEVI(devi)->devi_bus_ctl = pdevi->devi_bus_ctl; 3165 debug_dtree(devi, DEVI(devi)->devi_bus_ctl, "bus_ctl"); 3166 } 3167 } 3168 3169 #define MIN_DEVINFO_LOG_SIZE max_ncpus 3170 #define MAX_DEVINFO_LOG_SIZE max_ncpus * 10 3171 3172 static void 3173 da_log_init() 3174 { 3175 devinfo_log_header_t *dh; 3176 int logsize = devinfo_log_size; 3177 3178 if (logsize == 0) 3179 logsize = MIN_DEVINFO_LOG_SIZE; 3180 else if (logsize > MAX_DEVINFO_LOG_SIZE) 3181 logsize = MAX_DEVINFO_LOG_SIZE; 3182 3183 dh = kmem_alloc(logsize * PAGESIZE, KM_SLEEP); 3184 mutex_init(&dh->dh_lock, NULL, MUTEX_DEFAULT, NULL); 3185 dh->dh_max = ((logsize * PAGESIZE) - sizeof (*dh)) / 3186 sizeof (devinfo_audit_t) + 1; 3187 dh->dh_curr = -1; 3188 dh->dh_hits = 0; 3189 3190 devinfo_audit_log = dh; 3191 } 3192 3193 /* 3194 * Log the stack trace in per-devinfo audit structure and also enter 3195 * it into a system wide log for recording the time history. 3196 */ 3197 static void 3198 da_log_enter(dev_info_t *dip) 3199 { 3200 devinfo_audit_t *da_log, *da = DEVI(dip)->devi_audit; 3201 devinfo_log_header_t *dh = devinfo_audit_log; 3202 3203 if (devinfo_audit_log == NULL) 3204 return; 3205 3206 ASSERT(da != NULL); 3207 3208 da->da_devinfo = dip; 3209 da->da_timestamp = gethrtime(); 3210 da->da_thread = curthread; 3211 da->da_node_state = DEVI(dip)->devi_node_state; 3212 da->da_device_state = DEVI(dip)->devi_state; 3213 da->da_depth = getpcstack(da->da_stack, DDI_STACK_DEPTH); 3214 3215 /* 3216 * Copy into common log and note the location for tracing history 3217 */ 3218 mutex_enter(&dh->dh_lock); 3219 dh->dh_hits++; 3220 dh->dh_curr++; 3221 if (dh->dh_curr >= dh->dh_max) 3222 dh->dh_curr -= dh->dh_max; 3223 da_log = &dh->dh_entry[dh->dh_curr]; 3224 mutex_exit(&dh->dh_lock); 3225 3226 bcopy(da, da_log, sizeof (devinfo_audit_t)); 3227 da->da_lastlog = da_log; 3228 } 3229 3230 static void 3231 attach_drivers() 3232 { 3233 int i; 3234 for (i = 0; i < devcnt; i++) { 3235 struct devnames *dnp = &devnamesp[i]; 3236 if ((dnp->dn_flags & DN_FORCE_ATTACH) && 3237 (ddi_hold_installed_driver((major_t)i) != NULL)) 3238 ddi_rele_driver((major_t)i); 3239 } 3240 } 3241 3242 /* 3243 * Launch a thread to force attach drivers. This avoids penalty on boot time. 3244 */ 3245 void 3246 i_ddi_forceattach_drivers() 3247 { 3248 /* 3249 * On i386, the USB drivers need to load and take over from the 3250 * SMM BIOS drivers ASAP after consconfig(), so make sure they 3251 * get loaded right here rather than letting the thread do it. 3252 * 3253 * The order here is important. EHCI must be loaded first, as 3254 * we have observed many systems on which hangs occur if the 3255 * {U,O}HCI companion controllers take over control from the BIOS 3256 * before EHCI does. These hangs are also caused by BIOSes leaving 3257 * interrupt-on-port-change enabled in the ehci controller, so that 3258 * when uhci/ohci reset themselves, it induces a port change on 3259 * the ehci companion controller. Since there's no interrupt handler 3260 * installed at the time, the moment that interrupt is unmasked, an 3261 * interrupt storm will occur. All this is averted when ehci is 3262 * loaded first. And now you know..... the REST of the story. 3263 * 3264 * Regardless of platform, ehci needs to initialize first to avoid 3265 * unnecessary connects and disconnects on the companion controller 3266 * when ehci sets up the routing. 3267 */ 3268 (void) ddi_hold_installed_driver(ddi_name_to_major("ehci")); 3269 (void) ddi_hold_installed_driver(ddi_name_to_major("uhci")); 3270 (void) ddi_hold_installed_driver(ddi_name_to_major("ohci")); 3271 3272 /* 3273 * Attach IB VHCI driver before the force-attach thread attaches the 3274 * IB HCA driver. IB HCA driver will fail if IB Nexus has not yet 3275 * been attached. 3276 */ 3277 (void) ddi_hold_installed_driver(ddi_name_to_major("ib")); 3278 3279 (void) thread_create(NULL, 0, (void (*)())attach_drivers, NULL, 0, &p0, 3280 TS_RUN, minclsyspri); 3281 } 3282 3283 /* 3284 * This is a private DDI interface for optimizing boot performance. 3285 * I/O subsystem initialization is considered complete when devfsadm 3286 * is executed. 3287 * 3288 * NOTE: The start of syseventd happens to be a convenient indicator 3289 * of the completion of I/O initialization during boot. 3290 * The implementation should be replaced by something more robust. 3291 */ 3292 int 3293 i_ddi_io_initialized() 3294 { 3295 extern int sysevent_daemon_init; 3296 return (sysevent_daemon_init); 3297 } 3298 3299 /* 3300 * May be used to determine system boot state 3301 * "Available" means the system is for the most part up 3302 * and initialized, with all system services either up or 3303 * capable of being started. This state is set by devfsadm 3304 * during the boot process. The /dev filesystem infers 3305 * from this when implicit reconfig can be performed, 3306 * ie, devfsadm can be invoked. Please avoid making 3307 * further use of this unless it's really necessary. 3308 */ 3309 int 3310 i_ddi_sysavail() 3311 { 3312 return (devname_state & DS_SYSAVAIL); 3313 } 3314 3315 /* 3316 * May be used to determine if boot is a reconfigure boot. 3317 */ 3318 int 3319 i_ddi_reconfig() 3320 { 3321 return (devname_state & DS_RECONFIG); 3322 } 3323 3324 /* 3325 * Note system services are up, inform /dev. 3326 */ 3327 void 3328 i_ddi_set_sysavail() 3329 { 3330 if ((devname_state & DS_SYSAVAIL) == 0) { 3331 devname_state |= DS_SYSAVAIL; 3332 sdev_devstate_change(); 3333 } 3334 } 3335 3336 /* 3337 * Note reconfiguration boot, inform /dev. 3338 */ 3339 void 3340 i_ddi_set_reconfig() 3341 { 3342 if ((devname_state & DS_RECONFIG) == 0) { 3343 devname_state |= DS_RECONFIG; 3344 sdev_devstate_change(); 3345 } 3346 } 3347 3348 3349 /* 3350 * device tree walking 3351 */ 3352 3353 struct walk_elem { 3354 struct walk_elem *next; 3355 dev_info_t *dip; 3356 }; 3357 3358 static void 3359 free_list(struct walk_elem *list) 3360 { 3361 while (list) { 3362 struct walk_elem *next = list->next; 3363 kmem_free(list, sizeof (*list)); 3364 list = next; 3365 } 3366 } 3367 3368 static void 3369 append_node(struct walk_elem **list, dev_info_t *dip) 3370 { 3371 struct walk_elem *tail; 3372 struct walk_elem *elem = kmem_alloc(sizeof (*elem), KM_SLEEP); 3373 3374 elem->next = NULL; 3375 elem->dip = dip; 3376 3377 if (*list == NULL) { 3378 *list = elem; 3379 return; 3380 } 3381 3382 tail = *list; 3383 while (tail->next) 3384 tail = tail->next; 3385 3386 tail->next = elem; 3387 } 3388 3389 /* 3390 * The implementation of ddi_walk_devs(). 3391 */ 3392 static int 3393 walk_devs(dev_info_t *dip, int (*f)(dev_info_t *, void *), void *arg, 3394 int do_locking) 3395 { 3396 struct walk_elem *head = NULL; 3397 3398 /* 3399 * Do it in two passes. First pass invoke callback on each 3400 * dip on the sibling list. Second pass invoke callback on 3401 * children of each dip. 3402 */ 3403 while (dip) { 3404 switch ((*f)(dip, arg)) { 3405 case DDI_WALK_TERMINATE: 3406 free_list(head); 3407 return (DDI_WALK_TERMINATE); 3408 3409 case DDI_WALK_PRUNESIB: 3410 /* ignore sibling by setting dip to NULL */ 3411 append_node(&head, dip); 3412 dip = NULL; 3413 break; 3414 3415 case DDI_WALK_PRUNECHILD: 3416 /* don't worry about children */ 3417 dip = ddi_get_next_sibling(dip); 3418 break; 3419 3420 case DDI_WALK_CONTINUE: 3421 default: 3422 append_node(&head, dip); 3423 dip = ddi_get_next_sibling(dip); 3424 break; 3425 } 3426 3427 } 3428 3429 /* second pass */ 3430 while (head) { 3431 int circ; 3432 struct walk_elem *next = head->next; 3433 3434 if (do_locking) 3435 ndi_devi_enter(head->dip, &circ); 3436 if (walk_devs(ddi_get_child(head->dip), f, arg, do_locking) == 3437 DDI_WALK_TERMINATE) { 3438 if (do_locking) 3439 ndi_devi_exit(head->dip, circ); 3440 free_list(head); 3441 return (DDI_WALK_TERMINATE); 3442 } 3443 if (do_locking) 3444 ndi_devi_exit(head->dip, circ); 3445 kmem_free(head, sizeof (*head)); 3446 head = next; 3447 } 3448 3449 return (DDI_WALK_CONTINUE); 3450 } 3451 3452 /* 3453 * This general-purpose routine traverses the tree of dev_info nodes, 3454 * starting from the given node, and calls the given function for each 3455 * node that it finds with the current node and the pointer arg (which 3456 * can point to a structure of information that the function 3457 * needs) as arguments. 3458 * 3459 * It does the walk a layer at a time, not depth-first. The given function 3460 * must return one of the following values: 3461 * DDI_WALK_CONTINUE 3462 * DDI_WALK_PRUNESIB 3463 * DDI_WALK_PRUNECHILD 3464 * DDI_WALK_TERMINATE 3465 * 3466 * N.B. Since we walk the sibling list, the caller must ensure that 3467 * the parent of dip is held against changes, unless the parent 3468 * is rootnode. ndi_devi_enter() on the parent is sufficient. 3469 * 3470 * To avoid deadlock situations, caller must not attempt to 3471 * configure/unconfigure/remove device node in (*f)(), nor should 3472 * it attempt to recurse on other nodes in the system. Any 3473 * ndi_devi_enter() done by (*f)() must occur 'at-or-below' the 3474 * node entered prior to ddi_walk_devs(). Furthermore, if (*f)() 3475 * does any multi-threading (in framework *or* in driver) then the 3476 * ndi_devi_enter() calls done by dependent threads must be 3477 * 'strictly-below'. 3478 * 3479 * This is not callable from device autoconfiguration routines. 3480 * They include, but not limited to, _init(9e), _fini(9e), probe(9e), 3481 * attach(9e), and detach(9e). 3482 */ 3483 3484 void 3485 ddi_walk_devs(dev_info_t *dip, int (*f)(dev_info_t *, void *), void *arg) 3486 { 3487 3488 ASSERT(dip == NULL || ddi_get_parent(dip) == NULL || 3489 DEVI_BUSY_OWNED(ddi_get_parent(dip))); 3490 3491 (void) walk_devs(dip, f, arg, 1); 3492 } 3493 3494 /* 3495 * This is a general-purpose routine traverses the per-driver list 3496 * and calls the given function for each node. must return one of 3497 * the following values: 3498 * DDI_WALK_CONTINUE 3499 * DDI_WALK_TERMINATE 3500 * 3501 * N.B. The same restrictions from ddi_walk_devs() apply. 3502 */ 3503 3504 void 3505 e_ddi_walk_driver(char *drv, int (*f)(dev_info_t *, void *), void *arg) 3506 { 3507 major_t major; 3508 struct devnames *dnp; 3509 dev_info_t *dip; 3510 3511 major = ddi_name_to_major(drv); 3512 if (major == DDI_MAJOR_T_NONE) 3513 return; 3514 3515 dnp = &devnamesp[major]; 3516 LOCK_DEV_OPS(&dnp->dn_lock); 3517 dip = dnp->dn_head; 3518 while (dip) { 3519 ndi_hold_devi(dip); 3520 UNLOCK_DEV_OPS(&dnp->dn_lock); 3521 if ((*f)(dip, arg) == DDI_WALK_TERMINATE) { 3522 ndi_rele_devi(dip); 3523 return; 3524 } 3525 LOCK_DEV_OPS(&dnp->dn_lock); 3526 ndi_rele_devi(dip); 3527 dip = ddi_get_next(dip); 3528 } 3529 UNLOCK_DEV_OPS(&dnp->dn_lock); 3530 } 3531 3532 /* 3533 * argument to i_find_devi, a devinfo node search callback function. 3534 */ 3535 struct match_info { 3536 dev_info_t *dip; /* result */ 3537 char *nodename; /* if non-null, nodename must match */ 3538 int instance; /* if != -1, instance must match */ 3539 int attached; /* if != 0, i_ddi_devi_attached() */ 3540 }; 3541 3542 static int 3543 i_find_devi(dev_info_t *dip, void *arg) 3544 { 3545 struct match_info *info = (struct match_info *)arg; 3546 3547 if (((info->nodename == NULL) || 3548 (strcmp(ddi_node_name(dip), info->nodename) == 0)) && 3549 ((info->instance == -1) || 3550 (ddi_get_instance(dip) == info->instance)) && 3551 ((info->attached == 0) || i_ddi_devi_attached(dip))) { 3552 info->dip = dip; 3553 ndi_hold_devi(dip); 3554 return (DDI_WALK_TERMINATE); 3555 } 3556 3557 return (DDI_WALK_CONTINUE); 3558 } 3559 3560 /* 3561 * Find dip with a known node name and instance and return with it held 3562 */ 3563 dev_info_t * 3564 ddi_find_devinfo(char *nodename, int instance, int attached) 3565 { 3566 struct match_info info; 3567 3568 info.nodename = nodename; 3569 info.instance = instance; 3570 info.attached = attached; 3571 info.dip = NULL; 3572 3573 ddi_walk_devs(ddi_root_node(), i_find_devi, &info); 3574 return (info.dip); 3575 } 3576 3577 /* 3578 * Parse for name, addr, and minor names. Some args may be NULL. 3579 */ 3580 void 3581 i_ddi_parse_name(char *name, char **nodename, char **addrname, char **minorname) 3582 { 3583 char *cp; 3584 static char nulladdrname[] = ""; 3585 3586 /* default values */ 3587 if (nodename) 3588 *nodename = name; 3589 if (addrname) 3590 *addrname = nulladdrname; 3591 if (minorname) 3592 *minorname = NULL; 3593 3594 cp = name; 3595 while (*cp != '\0') { 3596 if (addrname && *cp == '@') { 3597 *addrname = cp + 1; 3598 *cp = '\0'; 3599 } else if (minorname && *cp == ':') { 3600 *minorname = cp + 1; 3601 *cp = '\0'; 3602 } 3603 ++cp; 3604 } 3605 } 3606 3607 static char * 3608 child_path_to_driver(dev_info_t *parent, char *child_name, char *unit_address) 3609 { 3610 char *p, *drvname = NULL; 3611 major_t maj; 3612 3613 /* 3614 * Construct the pathname and ask the implementation 3615 * if it can do a driver = f(pathname) for us, if not 3616 * we'll just default to using the node-name that 3617 * was given to us. We want to do this first to 3618 * allow the platform to use 'generic' names for 3619 * legacy device drivers. 3620 */ 3621 p = kmem_zalloc(MAXPATHLEN, KM_SLEEP); 3622 (void) ddi_pathname(parent, p); 3623 (void) strcat(p, "/"); 3624 (void) strcat(p, child_name); 3625 if (unit_address && *unit_address) { 3626 (void) strcat(p, "@"); 3627 (void) strcat(p, unit_address); 3628 } 3629 3630 /* 3631 * Get the binding. If there is none, return the child_name 3632 * and let the caller deal with it. 3633 */ 3634 maj = path_to_major(p); 3635 3636 kmem_free(p, MAXPATHLEN); 3637 3638 if (maj != DDI_MAJOR_T_NONE) 3639 drvname = ddi_major_to_name(maj); 3640 if (drvname == NULL) 3641 drvname = child_name; 3642 3643 return (drvname); 3644 } 3645 3646 3647 #define PCI_EX_CLASS "pciexclass" 3648 #define PCI_EX "pciex" 3649 #define PCI_CLASS "pciclass" 3650 #define PCI "pci" 3651 3652 int 3653 ddi_is_pci_dip(dev_info_t *dip) 3654 { 3655 char *prop = NULL; 3656 3657 if (ddi_prop_lookup_string(DDI_DEV_T_ANY, dip, DDI_PROP_DONTPASS, 3658 "compatible", &prop) == DDI_PROP_SUCCESS) { 3659 ASSERT(prop); 3660 if (strncmp(prop, PCI_EX_CLASS, sizeof (PCI_EX_CLASS) - 1) 3661 == 0 || 3662 strncmp(prop, PCI_EX, sizeof (PCI_EX)- 1) 3663 == 0 || 3664 strncmp(prop, PCI_CLASS, sizeof (PCI_CLASS) - 1) 3665 == 0 || 3666 strncmp(prop, PCI, sizeof (PCI) - 1) 3667 == 0) { 3668 ddi_prop_free(prop); 3669 return (1); 3670 } 3671 } 3672 3673 if (prop != NULL) { 3674 ddi_prop_free(prop); 3675 } 3676 3677 return (0); 3678 } 3679 3680 /* 3681 * Given the pathname of a device, fill in the dev_info_t value and/or the 3682 * dev_t value and/or the spectype, depending on which parameters are non-NULL. 3683 * If there is an error, this function returns -1. 3684 * 3685 * NOTE: If this function returns the dev_info_t structure, then it 3686 * does so with a hold on the devi. Caller should ensure that they get 3687 * decremented via ddi_release_devi() or ndi_rele_devi(); 3688 * 3689 * This function can be invoked in the boot case for a pathname without 3690 * device argument (:xxxx), traditionally treated as a minor name. 3691 * In this case, we do the following 3692 * (1) search the minor node of type DDM_DEFAULT. 3693 * (2) if no DDM_DEFAULT minor exists, then the first non-alias minor is chosen. 3694 * (3) if neither exists, a dev_t is faked with minor number = instance. 3695 * As of S9 FCS, no instance of #1 exists. #2 is used by several platforms 3696 * to default the boot partition to :a possibly by other OBP definitions. 3697 * #3 is used for booting off network interfaces, most SPARC network 3698 * drivers support Style-2 only, so only DDM_ALIAS minor exists. 3699 * 3700 * It is possible for OBP to present device args at the end of the path as 3701 * well as in the middle. For example, with IB the following strings are 3702 * valid boot paths. 3703 * a /pci@8,700000/ib@1,2:port=1,pkey=ff,dhcp,... 3704 * b /pci@8,700000/ib@1,1:port=1/ioc@xxxxxx,yyyyyyy:dhcp 3705 * Case (a), we first look for minor node "port=1,pkey...". 3706 * Failing that, we will pass "port=1,pkey..." to the bus_config 3707 * entry point of ib (HCA) driver. 3708 * Case (b), configure ib@1,1 as usual. Then invoke ib's bus_config 3709 * with argument "ioc@xxxxxxx,yyyyyyy:port=1". After configuring 3710 * the ioc, look for minor node dhcp. If not found, pass ":dhcp" 3711 * to ioc's bus_config entry point. 3712 */ 3713 int 3714 resolve_pathname(char *pathname, 3715 dev_info_t **dipp, dev_t *devtp, int *spectypep) 3716 { 3717 int error; 3718 dev_info_t *parent, *child; 3719 struct pathname pn; 3720 char *component, *config_name; 3721 char *minorname = NULL; 3722 char *prev_minor = NULL; 3723 dev_t devt = NODEV; 3724 int spectype; 3725 struct ddi_minor_data *dmn; 3726 int circ; 3727 3728 if (*pathname != '/') 3729 return (EINVAL); 3730 parent = ddi_root_node(); /* Begin at the top of the tree */ 3731 3732 if (error = pn_get(pathname, UIO_SYSSPACE, &pn)) 3733 return (error); 3734 pn_skipslash(&pn); 3735 3736 ASSERT(i_ddi_devi_attached(parent)); 3737 ndi_hold_devi(parent); 3738 3739 component = kmem_alloc(MAXNAMELEN, KM_SLEEP); 3740 config_name = kmem_alloc(MAXNAMELEN, KM_SLEEP); 3741 3742 while (pn_pathleft(&pn)) { 3743 /* remember prev minor (:xxx) in the middle of path */ 3744 if (minorname) 3745 prev_minor = i_ddi_strdup(minorname, KM_SLEEP); 3746 3747 /* Get component and chop off minorname */ 3748 (void) pn_getcomponent(&pn, component); 3749 i_ddi_parse_name(component, NULL, NULL, &minorname); 3750 3751 if (prev_minor == NULL) { 3752 (void) snprintf(config_name, MAXNAMELEN, "%s", 3753 component); 3754 } else { 3755 (void) snprintf(config_name, MAXNAMELEN, "%s:%s", 3756 component, prev_minor); 3757 kmem_free(prev_minor, strlen(prev_minor) + 1); 3758 prev_minor = NULL; 3759 } 3760 3761 /* 3762 * Find and configure the child 3763 */ 3764 if (ndi_devi_config_one(parent, config_name, &child, 3765 NDI_PROMNAME | NDI_NO_EVENT) != NDI_SUCCESS) { 3766 ndi_rele_devi(parent); 3767 pn_free(&pn); 3768 kmem_free(component, MAXNAMELEN); 3769 kmem_free(config_name, MAXNAMELEN); 3770 return (-1); 3771 } 3772 3773 ASSERT(i_ddi_devi_attached(child)); 3774 ndi_rele_devi(parent); 3775 parent = child; 3776 pn_skipslash(&pn); 3777 } 3778 3779 /* 3780 * First look for a minor node matching minorname. 3781 * Failing that, try to pass minorname to bus_config(). 3782 */ 3783 if (minorname && i_ddi_minorname_to_devtspectype(parent, 3784 minorname, &devt, &spectype) == DDI_FAILURE) { 3785 (void) snprintf(config_name, MAXNAMELEN, "%s", minorname); 3786 if (ndi_devi_config_obp_args(parent, 3787 config_name, &child, 0) != NDI_SUCCESS) { 3788 ndi_rele_devi(parent); 3789 pn_free(&pn); 3790 kmem_free(component, MAXNAMELEN); 3791 kmem_free(config_name, MAXNAMELEN); 3792 NDI_CONFIG_DEBUG((CE_NOTE, 3793 "%s: minor node not found\n", pathname)); 3794 return (-1); 3795 } 3796 minorname = NULL; /* look for default minor */ 3797 ASSERT(i_ddi_devi_attached(child)); 3798 ndi_rele_devi(parent); 3799 parent = child; 3800 } 3801 3802 if (devtp || spectypep) { 3803 if (minorname == NULL) { 3804 /* 3805 * Search for a default entry with an active 3806 * ndi_devi_enter to protect the devi_minor list. 3807 */ 3808 ndi_devi_enter(parent, &circ); 3809 for (dmn = DEVI(parent)->devi_minor; dmn; 3810 dmn = dmn->next) { 3811 if (dmn->type == DDM_DEFAULT) { 3812 devt = dmn->ddm_dev; 3813 spectype = dmn->ddm_spec_type; 3814 break; 3815 } 3816 } 3817 3818 if (devt == NODEV) { 3819 /* 3820 * No default minor node, try the first one; 3821 * else, assume 1-1 instance-minor mapping 3822 */ 3823 dmn = DEVI(parent)->devi_minor; 3824 if (dmn && ((dmn->type == DDM_MINOR) || 3825 (dmn->type == DDM_INTERNAL_PATH))) { 3826 devt = dmn->ddm_dev; 3827 spectype = dmn->ddm_spec_type; 3828 } else { 3829 devt = makedevice( 3830 DEVI(parent)->devi_major, 3831 ddi_get_instance(parent)); 3832 spectype = S_IFCHR; 3833 } 3834 } 3835 ndi_devi_exit(parent, circ); 3836 } 3837 if (devtp) 3838 *devtp = devt; 3839 if (spectypep) 3840 *spectypep = spectype; 3841 } 3842 3843 pn_free(&pn); 3844 kmem_free(component, MAXNAMELEN); 3845 kmem_free(config_name, MAXNAMELEN); 3846 3847 /* 3848 * If there is no error, return the appropriate parameters 3849 */ 3850 if (dipp != NULL) 3851 *dipp = parent; 3852 else { 3853 /* 3854 * We should really keep the ref count to keep the node from 3855 * detaching but ddi_pathname_to_dev_t() specifies a NULL dipp, 3856 * so we have no way of passing back the held dip. Not holding 3857 * the dip allows detaches to occur - which can cause problems 3858 * for subsystems which call ddi_pathname_to_dev_t (console). 3859 * 3860 * Instead of holding the dip, we place a ddi-no-autodetach 3861 * property on the node to prevent auto detaching. 3862 * 3863 * The right fix is to remove ddi_pathname_to_dev_t and replace 3864 * it, and all references, with a call that specifies a dipp. 3865 * In addition, the callers of this new interfaces would then 3866 * need to call ndi_rele_devi when the reference is complete. 3867 * 3868 */ 3869 (void) ddi_prop_update_int(DDI_DEV_T_NONE, parent, 3870 DDI_NO_AUTODETACH, 1); 3871 ndi_rele_devi(parent); 3872 } 3873 3874 return (0); 3875 } 3876 3877 /* 3878 * Given the pathname of a device, return the dev_t of the corresponding 3879 * device. Returns NODEV on failure. 3880 * 3881 * Note that this call sets the DDI_NO_AUTODETACH property on the devinfo node. 3882 */ 3883 dev_t 3884 ddi_pathname_to_dev_t(char *pathname) 3885 { 3886 dev_t devt; 3887 int error; 3888 3889 error = resolve_pathname(pathname, NULL, &devt, NULL); 3890 3891 return (error ? NODEV : devt); 3892 } 3893 3894 /* 3895 * Translate a prom pathname to kernel devfs pathname. 3896 * Caller is assumed to allocate devfspath memory of 3897 * size at least MAXPATHLEN 3898 * 3899 * The prom pathname may not include minor name, but 3900 * devfs pathname has a minor name portion. 3901 */ 3902 int 3903 i_ddi_prompath_to_devfspath(char *prompath, char *devfspath) 3904 { 3905 dev_t devt = (dev_t)NODEV; 3906 dev_info_t *dip = NULL; 3907 char *minor_name = NULL; 3908 int spectype; 3909 int error; 3910 int circ; 3911 3912 error = resolve_pathname(prompath, &dip, &devt, &spectype); 3913 if (error) 3914 return (DDI_FAILURE); 3915 ASSERT(dip && devt != NODEV); 3916 3917 /* 3918 * Get in-kernel devfs pathname 3919 */ 3920 (void) ddi_pathname(dip, devfspath); 3921 3922 ndi_devi_enter(dip, &circ); 3923 minor_name = i_ddi_devtspectype_to_minorname(dip, devt, spectype); 3924 if (minor_name) { 3925 (void) strcat(devfspath, ":"); 3926 (void) strcat(devfspath, minor_name); 3927 } else { 3928 /* 3929 * If minor_name is NULL, we have an alias minor node. 3930 * So manufacture a path to the corresponding clone minor. 3931 */ 3932 (void) snprintf(devfspath, MAXPATHLEN, "%s:%s", 3933 CLONE_PATH, ddi_driver_name(dip)); 3934 } 3935 ndi_devi_exit(dip, circ); 3936 3937 /* release hold from resolve_pathname() */ 3938 ndi_rele_devi(dip); 3939 return (0); 3940 } 3941 3942 /* 3943 * This function is intended to identify drivers that must quiesce for fast 3944 * reboot to succeed. It does not claim to have more knowledge about the device 3945 * than its driver. If a driver has implemented quiesce(), it will be invoked; 3946 * if a so identified driver does not manage any device that needs to be 3947 * quiesced, it must explicitly set its devo_quiesce dev_op to 3948 * ddi_quiesce_not_needed. 3949 */ 3950 static int skip_pseudo = 1; /* Skip pseudo devices */ 3951 static int skip_non_hw = 1; /* Skip devices with no hardware property */ 3952 static int 3953 should_implement_quiesce(dev_info_t *dip) 3954 { 3955 struct dev_info *devi = DEVI(dip); 3956 dev_info_t *pdip; 3957 3958 /* 3959 * If dip is pseudo and skip_pseudo is set, driver doesn't have to 3960 * implement quiesce(). 3961 */ 3962 if (skip_pseudo && 3963 strncmp(ddi_binding_name(dip), "pseudo", sizeof ("pseudo")) == 0) 3964 return (0); 3965 3966 /* 3967 * If parent dip is pseudo and skip_pseudo is set, driver doesn't have 3968 * to implement quiesce(). 3969 */ 3970 if (skip_pseudo && (pdip = ddi_get_parent(dip)) != NULL && 3971 strncmp(ddi_binding_name(pdip), "pseudo", sizeof ("pseudo")) == 0) 3972 return (0); 3973 3974 /* 3975 * If not attached, driver doesn't have to implement quiesce(). 3976 */ 3977 if (!i_ddi_devi_attached(dip)) 3978 return (0); 3979 3980 /* 3981 * If dip has no hardware property and skip_non_hw is set, 3982 * driver doesn't have to implement quiesce(). 3983 */ 3984 if (skip_non_hw && devi->devi_hw_prop_ptr == NULL) 3985 return (0); 3986 3987 return (1); 3988 } 3989 3990 static int 3991 driver_has_quiesce(struct dev_ops *ops) 3992 { 3993 if ((ops->devo_rev >= 4) && (ops->devo_quiesce != nodev) && 3994 (ops->devo_quiesce != NULL) && (ops->devo_quiesce != nulldev) && 3995 (ops->devo_quiesce != ddi_quiesce_not_supported)) 3996 return (1); 3997 else 3998 return (0); 3999 } 4000 4001 /* 4002 * Check to see if a driver has implemented the quiesce() DDI function. 4003 */ 4004 int 4005 check_driver_quiesce(dev_info_t *dip, void *arg) 4006 { 4007 struct dev_ops *ops; 4008 4009 if (!should_implement_quiesce(dip)) 4010 return (DDI_WALK_CONTINUE); 4011 4012 if ((ops = ddi_get_driver(dip)) == NULL) 4013 return (DDI_WALK_CONTINUE); 4014 4015 if (driver_has_quiesce(ops)) { 4016 if ((quiesce_debug & 0x2) == 0x2) { 4017 if (ops->devo_quiesce == ddi_quiesce_not_needed) 4018 cmn_err(CE_CONT, "%s does not need to be " 4019 "quiesced", ddi_driver_name(dip)); 4020 else 4021 cmn_err(CE_CONT, "%s has quiesce routine", 4022 ddi_driver_name(dip)); 4023 } 4024 } else { 4025 if (arg != NULL) 4026 *((int *)arg) = -1; 4027 cmn_err(CE_WARN, "%s has no quiesce()", ddi_driver_name(dip)); 4028 } 4029 4030 return (DDI_WALK_CONTINUE); 4031 } 4032 4033 /* 4034 * Quiesce device. 4035 */ 4036 static void 4037 quiesce_one_device(dev_info_t *dip, void *arg) 4038 { 4039 struct dev_ops *ops; 4040 int should_quiesce = 0; 4041 4042 /* 4043 * If the device is not attached it doesn't need to be quiesced. 4044 */ 4045 if (!i_ddi_devi_attached(dip)) 4046 return; 4047 4048 if ((ops = ddi_get_driver(dip)) == NULL) 4049 return; 4050 4051 should_quiesce = should_implement_quiesce(dip); 4052 4053 /* 4054 * If there's an implementation of quiesce(), always call it even if 4055 * some of the drivers don't have quiesce() or quiesce() have failed 4056 * so we can do force fast reboot. The implementation of quiesce() 4057 * should not negatively affect a regular reboot. 4058 */ 4059 if (driver_has_quiesce(ops)) { 4060 int rc = DDI_SUCCESS; 4061 4062 if (ops->devo_quiesce == ddi_quiesce_not_needed) 4063 return; 4064 4065 rc = devi_quiesce(dip); 4066 4067 /* quiesce() should never fail */ 4068 ASSERT(rc == DDI_SUCCESS); 4069 4070 if (rc != DDI_SUCCESS && should_quiesce) { 4071 4072 if (arg != NULL) 4073 *((int *)arg) = -1; 4074 } 4075 } else if (should_quiesce && arg != NULL) { 4076 *((int *)arg) = -1; 4077 } 4078 } 4079 4080 /* 4081 * Traverse the dev info tree in a breadth-first manner so that we quiesce 4082 * children first. All subtrees under the parent of dip will be quiesced. 4083 */ 4084 void 4085 quiesce_devices(dev_info_t *dip, void *arg) 4086 { 4087 /* 4088 * if we're reached here, the device tree better not be changing. 4089 * so either devinfo_freeze better be set or we better be panicing. 4090 */ 4091 ASSERT(devinfo_freeze || panicstr); 4092 4093 for (; dip != NULL; dip = ddi_get_next_sibling(dip)) { 4094 quiesce_devices(ddi_get_child(dip), arg); 4095 4096 quiesce_one_device(dip, arg); 4097 } 4098 } 4099 4100 /* 4101 * Reset all the pure leaf drivers on the system at halt time 4102 */ 4103 static int 4104 reset_leaf_device(dev_info_t *dip, void *arg) 4105 { 4106 _NOTE(ARGUNUSED(arg)) 4107 struct dev_ops *ops; 4108 4109 /* if the device doesn't need to be reset then there's nothing to do */ 4110 if (!DEVI_NEED_RESET(dip)) 4111 return (DDI_WALK_CONTINUE); 4112 4113 /* 4114 * if the device isn't a char/block device or doesn't have a 4115 * reset entry point then there's nothing to do. 4116 */ 4117 ops = ddi_get_driver(dip); 4118 if ((ops == NULL) || (ops->devo_cb_ops == NULL) || 4119 (ops->devo_reset == nodev) || (ops->devo_reset == nulldev) || 4120 (ops->devo_reset == NULL)) 4121 return (DDI_WALK_CONTINUE); 4122 4123 if (DEVI_IS_ATTACHING(dip) || DEVI_IS_DETACHING(dip)) { 4124 static char path[MAXPATHLEN]; 4125 4126 /* 4127 * bad news, this device has blocked in it's attach or 4128 * detach routine, which means it not safe to call it's 4129 * devo_reset() entry point. 4130 */ 4131 cmn_err(CE_WARN, "unable to reset device: %s", 4132 ddi_pathname(dip, path)); 4133 return (DDI_WALK_CONTINUE); 4134 } 4135 4136 NDI_CONFIG_DEBUG((CE_NOTE, "resetting %s%d\n", 4137 ddi_driver_name(dip), ddi_get_instance(dip))); 4138 4139 (void) devi_reset(dip, DDI_RESET_FORCE); 4140 return (DDI_WALK_CONTINUE); 4141 } 4142 4143 void 4144 reset_leaves(void) 4145 { 4146 /* 4147 * if we're reached here, the device tree better not be changing. 4148 * so either devinfo_freeze better be set or we better be panicing. 4149 */ 4150 ASSERT(devinfo_freeze || panicstr); 4151 4152 (void) walk_devs(top_devinfo, reset_leaf_device, NULL, 0); 4153 } 4154 4155 4156 /* 4157 * devtree_freeze() must be called before quiesce_devices() and reset_leaves() 4158 * during a normal system shutdown. It attempts to ensure that there are no 4159 * outstanding attach or detach operations in progress when quiesce_devices() or 4160 * reset_leaves()is invoked. It must be called before the system becomes 4161 * single-threaded because device attach and detach are multi-threaded 4162 * operations. (note that during system shutdown the system doesn't actually 4163 * become single-thread since other threads still exist, but the shutdown thread 4164 * will disable preemption for itself, raise it's pil, and stop all the other 4165 * cpus in the system there by effectively making the system single-threaded.) 4166 */ 4167 void 4168 devtree_freeze(void) 4169 { 4170 int delayed = 0; 4171 4172 /* if we're panicing then the device tree isn't going to be changing */ 4173 if (panicstr) 4174 return; 4175 4176 /* stop all dev_info state changes in the device tree */ 4177 devinfo_freeze = gethrtime(); 4178 4179 /* 4180 * if we're not panicing and there are on-going attach or detach 4181 * operations, wait for up to 3 seconds for them to finish. This 4182 * is a randomly chosen interval but this should be ok because: 4183 * - 3 seconds is very small relative to the deadman timer. 4184 * - normal attach and detach operations should be very quick. 4185 * - attach and detach operations are fairly rare. 4186 */ 4187 while (!panicstr && atomic_add_long_nv(&devinfo_attach_detach, 0) && 4188 (delayed < 3)) { 4189 delayed += 1; 4190 4191 /* do a sleeping wait for one second */ 4192 ASSERT(!servicing_interrupt()); 4193 delay(drv_usectohz(MICROSEC)); 4194 } 4195 } 4196 4197 static int 4198 bind_dip(dev_info_t *dip, void *arg) 4199 { 4200 _NOTE(ARGUNUSED(arg)) 4201 char *path; 4202 major_t major, pmajor; 4203 4204 /* 4205 * If the node is currently bound to the wrong driver, try to unbind 4206 * so that we can rebind to the correct driver. 4207 */ 4208 if (i_ddi_node_state(dip) >= DS_BOUND) { 4209 major = ddi_compatible_driver_major(dip, NULL); 4210 if ((DEVI(dip)->devi_major == major) && 4211 (i_ddi_node_state(dip) >= DS_INITIALIZED)) { 4212 /* 4213 * Check for a path-oriented driver alias that 4214 * takes precedence over current driver binding. 4215 */ 4216 path = kmem_alloc(MAXPATHLEN, KM_SLEEP); 4217 (void) ddi_pathname(dip, path); 4218 pmajor = ddi_name_to_major(path); 4219 if ((pmajor != DDI_MAJOR_T_NONE) && 4220 !(devnamesp[pmajor].dn_flags & DN_DRIVER_REMOVED)) 4221 major = pmajor; 4222 kmem_free(path, MAXPATHLEN); 4223 } 4224 4225 /* attempt unbind if current driver is incorrect */ 4226 if ((major != DDI_MAJOR_T_NONE) && 4227 !(devnamesp[major].dn_flags & DN_DRIVER_REMOVED) && 4228 (major != DEVI(dip)->devi_major)) 4229 (void) ndi_devi_unbind_driver(dip); 4230 } 4231 4232 /* If unbound, try to bind to a driver */ 4233 if (i_ddi_node_state(dip) < DS_BOUND) 4234 (void) ndi_devi_bind_driver(dip, 0); 4235 4236 return (DDI_WALK_CONTINUE); 4237 } 4238 4239 void 4240 i_ddi_bind_devs(void) 4241 { 4242 /* flush devfs so that ndi_devi_unbind_driver will work when possible */ 4243 (void) devfs_clean(top_devinfo, NULL, 0); 4244 4245 ddi_walk_devs(top_devinfo, bind_dip, (void *)NULL); 4246 } 4247 4248 /* callback data for unbind_children_by_alias() */ 4249 typedef struct unbind_data { 4250 major_t drv_major; 4251 char *drv_alias; 4252 int ndevs_bound; 4253 int unbind_errors; 4254 } unbind_data_t; 4255 4256 /* 4257 * A utility function provided for testing and support convenience 4258 * Called for each device during an upgrade_drv -d bound to the alias 4259 * that cannot be unbound due to device in use. 4260 */ 4261 static void 4262 unbind_alias_dev_in_use(dev_info_t *dip, char *alias) 4263 { 4264 if (moddebug & MODDEBUG_BINDING) { 4265 cmn_err(CE_CONT, "%s%d: state %d: bound to %s\n", 4266 ddi_driver_name(dip), ddi_get_instance(dip), 4267 i_ddi_node_state(dip), alias); 4268 } 4269 } 4270 4271 /* 4272 * walkdevs callback for unbind devices bound to specific driver 4273 * and alias. Invoked within the context of update_drv -d <alias>. 4274 */ 4275 static int 4276 unbind_children_by_alias(dev_info_t *dip, void *arg) 4277 { 4278 int circ; 4279 dev_info_t *cdip; 4280 dev_info_t *next; 4281 unbind_data_t *ub = (unbind_data_t *)(uintptr_t)arg; 4282 int rv; 4283 4284 /* 4285 * We are called from update_drv to try to unbind a specific 4286 * set of aliases for a driver. Unbind what persistent nodes 4287 * we can, and return the number of nodes which cannot be unbound. 4288 * If not all nodes can be unbound, update_drv leaves the 4289 * state of the driver binding files unchanged, except in 4290 * the case of -f. 4291 */ 4292 ndi_devi_enter(dip, &circ); 4293 for (cdip = ddi_get_child(dip); cdip; cdip = next) { 4294 next = ddi_get_next_sibling(cdip); 4295 if ((ddi_driver_major(cdip) != ub->drv_major) || 4296 (strcmp(DEVI(cdip)->devi_node_name, ub->drv_alias) != 0)) 4297 continue; 4298 if (i_ddi_node_state(cdip) >= DS_BOUND) { 4299 rv = ndi_devi_unbind_driver(cdip); 4300 if (rv != DDI_SUCCESS || 4301 (i_ddi_node_state(cdip) >= DS_BOUND)) { 4302 unbind_alias_dev_in_use(cdip, ub->drv_alias); 4303 ub->ndevs_bound++; 4304 continue; 4305 } 4306 if (ndi_dev_is_persistent_node(cdip) == 0) 4307 (void) ddi_remove_child(cdip, 0); 4308 } 4309 } 4310 ndi_devi_exit(dip, circ); 4311 4312 return (DDI_WALK_CONTINUE); 4313 } 4314 4315 /* 4316 * Unbind devices by driver & alias 4317 * Context: update_drv [-f] -d -i <alias> <driver> 4318 */ 4319 int 4320 i_ddi_unbind_devs_by_alias(major_t major, char *alias) 4321 { 4322 unbind_data_t *ub; 4323 int rv; 4324 4325 ub = kmem_zalloc(sizeof (*ub), KM_SLEEP); 4326 ub->drv_major = major; 4327 ub->drv_alias = alias; 4328 ub->ndevs_bound = 0; 4329 ub->unbind_errors = 0; 4330 4331 /* flush devfs so that ndi_devi_unbind_driver will work when possible */ 4332 devfs_clean(top_devinfo, NULL, 0); 4333 ddi_walk_devs(top_devinfo, unbind_children_by_alias, 4334 (void *)(uintptr_t)ub); 4335 4336 /* return the number of devices remaining bound to the alias */ 4337 rv = ub->ndevs_bound + ub->unbind_errors; 4338 kmem_free(ub, sizeof (*ub)); 4339 return (rv); 4340 } 4341 4342 /* 4343 * walkdevs callback for unbind devices by driver 4344 */ 4345 static int 4346 unbind_children_by_driver(dev_info_t *dip, void *arg) 4347 { 4348 int circ; 4349 dev_info_t *cdip; 4350 dev_info_t *next; 4351 major_t major = (major_t)(uintptr_t)arg; 4352 int rv; 4353 4354 /* 4355 * We are called either from rem_drv or update_drv when reloading 4356 * a driver.conf file. In either case, we unbind persistent nodes 4357 * and destroy .conf nodes. In the case of rem_drv, this will be 4358 * the final state. In the case of update_drv, i_ddi_bind_devs() 4359 * may be invoked later to re-enumerate (new) driver.conf rebind 4360 * persistent nodes. 4361 */ 4362 ndi_devi_enter(dip, &circ); 4363 for (cdip = ddi_get_child(dip); cdip; cdip = next) { 4364 next = ddi_get_next_sibling(cdip); 4365 if (ddi_driver_major(cdip) != major) 4366 continue; 4367 if (i_ddi_node_state(cdip) >= DS_BOUND) { 4368 rv = ndi_devi_unbind_driver(cdip); 4369 if (rv == DDI_FAILURE || 4370 (i_ddi_node_state(cdip) >= DS_BOUND)) 4371 continue; 4372 if (ndi_dev_is_persistent_node(cdip) == 0) 4373 (void) ddi_remove_child(cdip, 0); 4374 } 4375 } 4376 ndi_devi_exit(dip, circ); 4377 4378 return (DDI_WALK_CONTINUE); 4379 } 4380 4381 /* 4382 * Unbind devices by driver 4383 * Context: rem_drv or unload driver.conf 4384 */ 4385 void 4386 i_ddi_unbind_devs(major_t major) 4387 { 4388 /* flush devfs so that ndi_devi_unbind_driver will work when possible */ 4389 devfs_clean(top_devinfo, NULL, 0); 4390 ddi_walk_devs(top_devinfo, unbind_children_by_driver, 4391 (void *)(uintptr_t)major); 4392 } 4393 4394 /* 4395 * I/O Hotplug control 4396 */ 4397 4398 /* 4399 * create and attach a dev_info node from a .conf file spec 4400 */ 4401 static void 4402 init_spec_child(dev_info_t *pdip, struct hwc_spec *specp, uint_t flags) 4403 { 4404 _NOTE(ARGUNUSED(flags)) 4405 dev_info_t *dip; 4406 char *node_name; 4407 4408 if (((node_name = specp->hwc_devi_name) == NULL) || 4409 (ddi_name_to_major(node_name) == DDI_MAJOR_T_NONE)) { 4410 char *tmp = node_name; 4411 if (tmp == NULL) 4412 tmp = "<none>"; 4413 cmn_err(CE_CONT, 4414 "init_spec_child: parent=%s, bad spec (%s)\n", 4415 ddi_node_name(pdip), tmp); 4416 return; 4417 } 4418 4419 dip = i_ddi_alloc_node(pdip, node_name, (pnode_t)DEVI_PSEUDO_NODEID, 4420 -1, specp->hwc_devi_sys_prop_ptr, KM_SLEEP); 4421 4422 if (dip == NULL) 4423 return; 4424 4425 if (ddi_initchild(pdip, dip) != DDI_SUCCESS) 4426 (void) ddi_remove_child(dip, 0); 4427 } 4428 4429 /* 4430 * Lookup hwc specs from hash tables and make children from the spec 4431 * Because some .conf children are "merge" nodes, we also initialize 4432 * .conf children to merge properties onto hardware nodes. 4433 * 4434 * The pdip must be held busy. 4435 */ 4436 int 4437 i_ndi_make_spec_children(dev_info_t *pdip, uint_t flags) 4438 { 4439 extern struct hwc_spec *hwc_get_child_spec(dev_info_t *, major_t); 4440 int circ; 4441 struct hwc_spec *list, *spec; 4442 4443 ndi_devi_enter(pdip, &circ); 4444 if (DEVI(pdip)->devi_flags & DEVI_MADE_CHILDREN) { 4445 ndi_devi_exit(pdip, circ); 4446 return (DDI_SUCCESS); 4447 } 4448 4449 list = hwc_get_child_spec(pdip, DDI_MAJOR_T_NONE); 4450 for (spec = list; spec != NULL; spec = spec->hwc_next) { 4451 init_spec_child(pdip, spec, flags); 4452 } 4453 hwc_free_spec_list(list); 4454 4455 mutex_enter(&DEVI(pdip)->devi_lock); 4456 DEVI(pdip)->devi_flags |= DEVI_MADE_CHILDREN; 4457 mutex_exit(&DEVI(pdip)->devi_lock); 4458 ndi_devi_exit(pdip, circ); 4459 return (DDI_SUCCESS); 4460 } 4461 4462 /* 4463 * Run initchild on all child nodes such that instance assignment 4464 * for multiport network cards are contiguous. 4465 * 4466 * The pdip must be held busy. 4467 */ 4468 static void 4469 i_ndi_init_hw_children(dev_info_t *pdip, uint_t flags) 4470 { 4471 dev_info_t *dip; 4472 4473 ASSERT(DEVI(pdip)->devi_flags & DEVI_MADE_CHILDREN); 4474 4475 /* contiguous instance assignment */ 4476 e_ddi_enter_instance(); 4477 dip = ddi_get_child(pdip); 4478 while (dip) { 4479 if (ndi_dev_is_persistent_node(dip)) 4480 (void) i_ndi_config_node(dip, DS_INITIALIZED, flags); 4481 dip = ddi_get_next_sibling(dip); 4482 } 4483 e_ddi_exit_instance(); 4484 } 4485 4486 /* 4487 * report device status 4488 */ 4489 static void 4490 i_ndi_devi_report_status_change(dev_info_t *dip, char *path) 4491 { 4492 char *status; 4493 4494 if (!DEVI_NEED_REPORT(dip) || 4495 (i_ddi_node_state(dip) < DS_INITIALIZED)) { 4496 return; 4497 } 4498 4499 if (DEVI_IS_DEVICE_OFFLINE(dip)) { 4500 status = "offline"; 4501 } else if (DEVI_IS_DEVICE_DOWN(dip)) { 4502 status = "down"; 4503 } else if (DEVI_IS_BUS_QUIESCED(dip)) { 4504 status = "quiesced"; 4505 } else if (DEVI_IS_BUS_DOWN(dip)) { 4506 status = "down"; 4507 } else if (i_ddi_devi_attached(dip)) { 4508 status = "online"; 4509 } else { 4510 status = "unknown"; 4511 } 4512 4513 if (path == NULL) { 4514 path = kmem_alloc(MAXPATHLEN, KM_SLEEP); 4515 cmn_err(CE_CONT, "?%s (%s%d) %s\n", 4516 ddi_pathname(dip, path), ddi_driver_name(dip), 4517 ddi_get_instance(dip), status); 4518 kmem_free(path, MAXPATHLEN); 4519 } else { 4520 cmn_err(CE_CONT, "?%s (%s%d) %s\n", 4521 path, ddi_driver_name(dip), 4522 ddi_get_instance(dip), status); 4523 } 4524 4525 mutex_enter(&(DEVI(dip)->devi_lock)); 4526 DEVI_REPORT_DONE(dip); 4527 mutex_exit(&(DEVI(dip)->devi_lock)); 4528 } 4529 4530 /* 4531 * log a notification that a dev_info node has been configured. 4532 */ 4533 static int 4534 i_log_devfs_add_devinfo(dev_info_t *dip, uint_t flags) 4535 { 4536 int se_err; 4537 char *pathname; 4538 sysevent_t *ev; 4539 sysevent_id_t eid; 4540 sysevent_value_t se_val; 4541 sysevent_attr_list_t *ev_attr_list = NULL; 4542 char *class_name; 4543 int no_transport = 0; 4544 4545 ASSERT(dip); 4546 4547 /* 4548 * Invalidate the devinfo snapshot cache 4549 */ 4550 i_ddi_di_cache_invalidate(KM_SLEEP); 4551 4552 /* do not generate ESC_DEVFS_DEVI_ADD event during boot */ 4553 if (!i_ddi_io_initialized()) 4554 return (DDI_SUCCESS); 4555 4556 ev = sysevent_alloc(EC_DEVFS, ESC_DEVFS_DEVI_ADD, EP_DDI, SE_SLEEP); 4557 4558 pathname = kmem_alloc(MAXPATHLEN, KM_SLEEP); 4559 4560 (void) ddi_pathname(dip, pathname); 4561 ASSERT(strlen(pathname)); 4562 4563 se_val.value_type = SE_DATA_TYPE_STRING; 4564 se_val.value.sv_string = pathname; 4565 if (sysevent_add_attr(&ev_attr_list, DEVFS_PATHNAME, 4566 &se_val, SE_SLEEP) != 0) { 4567 goto fail; 4568 } 4569 4570 /* add the device class attribute */ 4571 if ((class_name = i_ddi_devi_class(dip)) != NULL) { 4572 se_val.value_type = SE_DATA_TYPE_STRING; 4573 se_val.value.sv_string = class_name; 4574 4575 if (sysevent_add_attr(&ev_attr_list, 4576 DEVFS_DEVI_CLASS, &se_val, SE_SLEEP) != 0) { 4577 sysevent_free_attr(ev_attr_list); 4578 goto fail; 4579 } 4580 } 4581 4582 /* 4583 * must log a branch event too unless NDI_BRANCH_EVENT_OP is set, 4584 * in which case the branch event will be logged by the caller 4585 * after the entire branch has been configured. 4586 */ 4587 if ((flags & NDI_BRANCH_EVENT_OP) == 0) { 4588 /* 4589 * Instead of logging a separate branch event just add 4590 * DEVFS_BRANCH_EVENT attribute. It indicates devfsadmd to 4591 * generate a EC_DEV_BRANCH event. 4592 */ 4593 se_val.value_type = SE_DATA_TYPE_INT32; 4594 se_val.value.sv_int32 = 1; 4595 if (sysevent_add_attr(&ev_attr_list, 4596 DEVFS_BRANCH_EVENT, &se_val, SE_SLEEP) != 0) { 4597 sysevent_free_attr(ev_attr_list); 4598 goto fail; 4599 } 4600 } 4601 4602 if (sysevent_attach_attributes(ev, ev_attr_list) != 0) { 4603 sysevent_free_attr(ev_attr_list); 4604 goto fail; 4605 } 4606 4607 if ((se_err = log_sysevent(ev, SE_SLEEP, &eid)) != 0) { 4608 if (se_err == SE_NO_TRANSPORT) 4609 no_transport = 1; 4610 goto fail; 4611 } 4612 4613 sysevent_free(ev); 4614 kmem_free(pathname, MAXPATHLEN); 4615 4616 return (DDI_SUCCESS); 4617 4618 fail: 4619 cmn_err(CE_WARN, "failed to log ESC_DEVFS_DEVI_ADD event for %s%s", 4620 pathname, (no_transport) ? " (syseventd not responding)" : ""); 4621 4622 cmn_err(CE_WARN, "/dev may not be current for driver %s. " 4623 "Run devfsadm -i %s", 4624 ddi_driver_name(dip), ddi_driver_name(dip)); 4625 4626 sysevent_free(ev); 4627 kmem_free(pathname, MAXPATHLEN); 4628 return (DDI_SUCCESS); 4629 } 4630 4631 /* 4632 * log a notification that a dev_info node has been unconfigured. 4633 */ 4634 static int 4635 i_log_devfs_remove_devinfo(char *pathname, char *class_name, char *driver_name, 4636 int instance, uint_t flags) 4637 { 4638 sysevent_t *ev; 4639 sysevent_id_t eid; 4640 sysevent_value_t se_val; 4641 sysevent_attr_list_t *ev_attr_list = NULL; 4642 int se_err; 4643 int no_transport = 0; 4644 4645 i_ddi_di_cache_invalidate(KM_SLEEP); 4646 4647 if (!i_ddi_io_initialized()) 4648 return (DDI_SUCCESS); 4649 4650 ev = sysevent_alloc(EC_DEVFS, ESC_DEVFS_DEVI_REMOVE, EP_DDI, SE_SLEEP); 4651 4652 se_val.value_type = SE_DATA_TYPE_STRING; 4653 se_val.value.sv_string = pathname; 4654 if (sysevent_add_attr(&ev_attr_list, DEVFS_PATHNAME, 4655 &se_val, SE_SLEEP) != 0) { 4656 goto fail; 4657 } 4658 4659 if (class_name) { 4660 /* add the device class, driver name and instance attributes */ 4661 4662 se_val.value_type = SE_DATA_TYPE_STRING; 4663 se_val.value.sv_string = class_name; 4664 if (sysevent_add_attr(&ev_attr_list, 4665 DEVFS_DEVI_CLASS, &se_val, SE_SLEEP) != 0) { 4666 sysevent_free_attr(ev_attr_list); 4667 goto fail; 4668 } 4669 4670 se_val.value_type = SE_DATA_TYPE_STRING; 4671 se_val.value.sv_string = driver_name; 4672 if (sysevent_add_attr(&ev_attr_list, 4673 DEVFS_DRIVER_NAME, &se_val, SE_SLEEP) != 0) { 4674 sysevent_free_attr(ev_attr_list); 4675 goto fail; 4676 } 4677 4678 se_val.value_type = SE_DATA_TYPE_INT32; 4679 se_val.value.sv_int32 = instance; 4680 if (sysevent_add_attr(&ev_attr_list, 4681 DEVFS_INSTANCE, &se_val, SE_SLEEP) != 0) { 4682 sysevent_free_attr(ev_attr_list); 4683 goto fail; 4684 } 4685 } 4686 4687 /* 4688 * must log a branch event too unless NDI_BRANCH_EVENT_OP is set, 4689 * in which case the branch event will be logged by the caller 4690 * after the entire branch has been unconfigured. 4691 */ 4692 if ((flags & NDI_BRANCH_EVENT_OP) == 0) { 4693 /* 4694 * Instead of logging a separate branch event just add 4695 * DEVFS_BRANCH_EVENT attribute. It indicates devfsadmd to 4696 * generate a EC_DEV_BRANCH event. 4697 */ 4698 se_val.value_type = SE_DATA_TYPE_INT32; 4699 se_val.value.sv_int32 = 1; 4700 if (sysevent_add_attr(&ev_attr_list, 4701 DEVFS_BRANCH_EVENT, &se_val, SE_SLEEP) != 0) { 4702 sysevent_free_attr(ev_attr_list); 4703 goto fail; 4704 } 4705 } 4706 4707 if (sysevent_attach_attributes(ev, ev_attr_list) != 0) { 4708 sysevent_free_attr(ev_attr_list); 4709 goto fail; 4710 } 4711 4712 if ((se_err = log_sysevent(ev, SE_SLEEP, &eid)) != 0) { 4713 if (se_err == SE_NO_TRANSPORT) 4714 no_transport = 1; 4715 goto fail; 4716 } 4717 4718 sysevent_free(ev); 4719 return (DDI_SUCCESS); 4720 4721 fail: 4722 sysevent_free(ev); 4723 cmn_err(CE_WARN, "failed to log ESC_DEVFS_DEVI_REMOVE event for %s%s", 4724 pathname, (no_transport) ? " (syseventd not responding)" : ""); 4725 return (DDI_SUCCESS); 4726 } 4727 4728 /* 4729 * log an event that a dev_info branch has been configured or unconfigured. 4730 */ 4731 static int 4732 i_log_devfs_branch(char *node_path, char *subclass) 4733 { 4734 int se_err; 4735 sysevent_t *ev; 4736 sysevent_id_t eid; 4737 sysevent_value_t se_val; 4738 sysevent_attr_list_t *ev_attr_list = NULL; 4739 int no_transport = 0; 4740 4741 /* do not generate the event during boot */ 4742 if (!i_ddi_io_initialized()) 4743 return (DDI_SUCCESS); 4744 4745 ev = sysevent_alloc(EC_DEVFS, subclass, EP_DDI, SE_SLEEP); 4746 4747 se_val.value_type = SE_DATA_TYPE_STRING; 4748 se_val.value.sv_string = node_path; 4749 4750 if (sysevent_add_attr(&ev_attr_list, DEVFS_PATHNAME, 4751 &se_val, SE_SLEEP) != 0) { 4752 goto fail; 4753 } 4754 4755 if (sysevent_attach_attributes(ev, ev_attr_list) != 0) { 4756 sysevent_free_attr(ev_attr_list); 4757 goto fail; 4758 } 4759 4760 if ((se_err = log_sysevent(ev, SE_SLEEP, &eid)) != 0) { 4761 if (se_err == SE_NO_TRANSPORT) 4762 no_transport = 1; 4763 goto fail; 4764 } 4765 4766 sysevent_free(ev); 4767 return (DDI_SUCCESS); 4768 4769 fail: 4770 cmn_err(CE_WARN, "failed to log %s branch event for %s%s", 4771 subclass, node_path, 4772 (no_transport) ? " (syseventd not responding)" : ""); 4773 4774 sysevent_free(ev); 4775 return (DDI_FAILURE); 4776 } 4777 4778 /* 4779 * log an event that a dev_info tree branch has been configured. 4780 */ 4781 static int 4782 i_log_devfs_branch_add(dev_info_t *dip) 4783 { 4784 char *node_path; 4785 int rv; 4786 4787 node_path = kmem_alloc(MAXPATHLEN, KM_SLEEP); 4788 (void) ddi_pathname(dip, node_path); 4789 rv = i_log_devfs_branch(node_path, ESC_DEVFS_BRANCH_ADD); 4790 kmem_free(node_path, MAXPATHLEN); 4791 4792 return (rv); 4793 } 4794 4795 /* 4796 * log an event that a dev_info tree branch has been unconfigured. 4797 */ 4798 static int 4799 i_log_devfs_branch_remove(char *node_path) 4800 { 4801 return (i_log_devfs_branch(node_path, ESC_DEVFS_BRANCH_REMOVE)); 4802 } 4803 4804 /* 4805 * enqueue the dip's deviname on the branch event queue. 4806 */ 4807 static struct brevq_node * 4808 brevq_enqueue(struct brevq_node **brevqp, dev_info_t *dip, 4809 struct brevq_node *child) 4810 { 4811 struct brevq_node *brn; 4812 char *deviname; 4813 4814 deviname = kmem_alloc(MAXNAMELEN, KM_SLEEP); 4815 (void) ddi_deviname(dip, deviname); 4816 4817 brn = kmem_zalloc(sizeof (*brn), KM_SLEEP); 4818 brn->brn_deviname = i_ddi_strdup(deviname, KM_SLEEP); 4819 kmem_free(deviname, MAXNAMELEN); 4820 brn->brn_child = child; 4821 brn->brn_sibling = *brevqp; 4822 *brevqp = brn; 4823 4824 return (brn); 4825 } 4826 4827 /* 4828 * free the memory allocated for the elements on the branch event queue. 4829 */ 4830 static void 4831 free_brevq(struct brevq_node *brevq) 4832 { 4833 struct brevq_node *brn, *next_brn; 4834 4835 for (brn = brevq; brn != NULL; brn = next_brn) { 4836 next_brn = brn->brn_sibling; 4837 ASSERT(brn->brn_child == NULL); 4838 kmem_free(brn->brn_deviname, strlen(brn->brn_deviname) + 1); 4839 kmem_free(brn, sizeof (*brn)); 4840 } 4841 } 4842 4843 /* 4844 * log the events queued up on the branch event queue and free the 4845 * associated memory. 4846 * 4847 * node_path must have been allocated with at least MAXPATHLEN bytes. 4848 */ 4849 static void 4850 log_and_free_brevq(char *node_path, struct brevq_node *brevq) 4851 { 4852 struct brevq_node *brn; 4853 char *p; 4854 4855 p = node_path + strlen(node_path); 4856 for (brn = brevq; brn != NULL; brn = brn->brn_sibling) { 4857 (void) strcpy(p, brn->brn_deviname); 4858 (void) i_log_devfs_branch_remove(node_path); 4859 } 4860 *p = '\0'; 4861 4862 free_brevq(brevq); 4863 } 4864 4865 /* 4866 * log the events queued up on the branch event queue and free the 4867 * associated memory. Same as the previous function but operates on dip. 4868 */ 4869 static void 4870 log_and_free_brevq_dip(dev_info_t *dip, struct brevq_node *brevq) 4871 { 4872 char *path; 4873 4874 path = kmem_alloc(MAXPATHLEN, KM_SLEEP); 4875 (void) ddi_pathname(dip, path); 4876 log_and_free_brevq(path, brevq); 4877 kmem_free(path, MAXPATHLEN); 4878 } 4879 4880 /* 4881 * log the outstanding branch remove events for the grand children of the dip 4882 * and free the associated memory. 4883 */ 4884 static void 4885 log_and_free_br_events_on_grand_children(dev_info_t *dip, 4886 struct brevq_node *brevq) 4887 { 4888 struct brevq_node *brn; 4889 char *path; 4890 char *p; 4891 4892 path = kmem_alloc(MAXPATHLEN, KM_SLEEP); 4893 (void) ddi_pathname(dip, path); 4894 p = path + strlen(path); 4895 for (brn = brevq; brn != NULL; brn = brn->brn_sibling) { 4896 if (brn->brn_child) { 4897 (void) strcpy(p, brn->brn_deviname); 4898 /* now path contains the node path to the dip's child */ 4899 log_and_free_brevq(path, brn->brn_child); 4900 brn->brn_child = NULL; 4901 } 4902 } 4903 kmem_free(path, MAXPATHLEN); 4904 } 4905 4906 /* 4907 * log and cleanup branch remove events for the grand children of the dip. 4908 */ 4909 static void 4910 cleanup_br_events_on_grand_children(dev_info_t *dip, struct brevq_node **brevqp) 4911 { 4912 dev_info_t *child; 4913 struct brevq_node *brevq, *brn, *prev_brn, *next_brn; 4914 char *path; 4915 int circ; 4916 4917 path = kmem_alloc(MAXPATHLEN, KM_SLEEP); 4918 prev_brn = NULL; 4919 brevq = *brevqp; 4920 4921 ndi_devi_enter(dip, &circ); 4922 for (brn = brevq; brn != NULL; brn = next_brn) { 4923 next_brn = brn->brn_sibling; 4924 for (child = ddi_get_child(dip); child != NULL; 4925 child = ddi_get_next_sibling(child)) { 4926 if (i_ddi_node_state(child) >= DS_INITIALIZED) { 4927 (void) ddi_deviname(child, path); 4928 if (strcmp(path, brn->brn_deviname) == 0) 4929 break; 4930 } 4931 } 4932 4933 if (child != NULL && !(DEVI_EVREMOVE(child))) { 4934 /* 4935 * Event state is not REMOVE. So branch remove event 4936 * is not going be generated on brn->brn_child. 4937 * If any branch remove events were queued up on 4938 * brn->brn_child log them and remove the brn 4939 * from the queue. 4940 */ 4941 if (brn->brn_child) { 4942 (void) ddi_pathname(dip, path); 4943 (void) strcat(path, brn->brn_deviname); 4944 log_and_free_brevq(path, brn->brn_child); 4945 } 4946 4947 if (prev_brn) 4948 prev_brn->brn_sibling = next_brn; 4949 else 4950 *brevqp = next_brn; 4951 4952 kmem_free(brn->brn_deviname, 4953 strlen(brn->brn_deviname) + 1); 4954 kmem_free(brn, sizeof (*brn)); 4955 } else { 4956 /* 4957 * Free up the outstanding branch remove events 4958 * queued on brn->brn_child since brn->brn_child 4959 * itself is eligible for branch remove event. 4960 */ 4961 if (brn->brn_child) { 4962 free_brevq(brn->brn_child); 4963 brn->brn_child = NULL; 4964 } 4965 prev_brn = brn; 4966 } 4967 } 4968 4969 ndi_devi_exit(dip, circ); 4970 kmem_free(path, MAXPATHLEN); 4971 } 4972 4973 static int 4974 need_remove_event(dev_info_t *dip, int flags) 4975 { 4976 if ((flags & (NDI_NO_EVENT | NDI_AUTODETACH)) == 0 && 4977 (flags & (NDI_DEVI_OFFLINE | NDI_UNCONFIG | NDI_DEVI_REMOVE)) && 4978 !(DEVI_EVREMOVE(dip))) 4979 return (1); 4980 else 4981 return (0); 4982 } 4983 4984 /* 4985 * Unconfigure children/descendants of the dip. 4986 * 4987 * If the operation involves a branch event NDI_BRANCH_EVENT_OP is set 4988 * through out the unconfiguration. On successful return *brevqp is set to 4989 * a queue of dip's child devinames for which branch remove events need 4990 * to be generated. 4991 */ 4992 static int 4993 devi_unconfig_branch(dev_info_t *dip, dev_info_t **dipp, int flags, 4994 struct brevq_node **brevqp) 4995 { 4996 int rval; 4997 4998 *brevqp = NULL; 4999 5000 if ((!(flags & NDI_BRANCH_EVENT_OP)) && need_remove_event(dip, flags)) 5001 flags |= NDI_BRANCH_EVENT_OP; 5002 5003 if (flags & NDI_BRANCH_EVENT_OP) { 5004 rval = devi_unconfig_common(dip, dipp, flags, DDI_MAJOR_T_NONE, 5005 brevqp); 5006 5007 if (rval != NDI_SUCCESS && (*brevqp)) { 5008 log_and_free_brevq_dip(dip, *brevqp); 5009 *brevqp = NULL; 5010 } 5011 } else 5012 rval = devi_unconfig_common(dip, dipp, flags, DDI_MAJOR_T_NONE, 5013 NULL); 5014 5015 return (rval); 5016 } 5017 5018 /* 5019 * If the dip is already bound to a driver transition to DS_INITIALIZED 5020 * in order to generate an event in the case where the node was left in 5021 * DS_BOUND state since boot (never got attached) and the node is now 5022 * being offlined. 5023 */ 5024 static void 5025 init_bound_node_ev(dev_info_t *pdip, dev_info_t *dip, int flags) 5026 { 5027 if (need_remove_event(dip, flags) && 5028 i_ddi_node_state(dip) == DS_BOUND && 5029 i_ddi_devi_attached(pdip) && !DEVI_IS_DEVICE_OFFLINE(dip)) 5030 (void) ddi_initchild(pdip, dip); 5031 } 5032 5033 /* 5034 * attach a node/branch with parent already held busy 5035 */ 5036 static int 5037 devi_attach_node(dev_info_t *dip, uint_t flags) 5038 { 5039 dev_info_t *pdip = ddi_get_parent(dip); 5040 5041 ASSERT(pdip && DEVI_BUSY_OWNED(pdip)); 5042 5043 mutex_enter(&(DEVI(dip)->devi_lock)); 5044 if (flags & NDI_DEVI_ONLINE) { 5045 if (!i_ddi_devi_attached(dip)) 5046 DEVI_SET_REPORT(dip); 5047 DEVI_SET_DEVICE_ONLINE(dip); 5048 } 5049 if (DEVI_IS_DEVICE_OFFLINE(dip)) { 5050 mutex_exit(&(DEVI(dip)->devi_lock)); 5051 return (NDI_FAILURE); 5052 } 5053 mutex_exit(&(DEVI(dip)->devi_lock)); 5054 5055 if (i_ddi_attachchild(dip) != DDI_SUCCESS) { 5056 mutex_enter(&(DEVI(dip)->devi_lock)); 5057 DEVI_SET_EVUNINIT(dip); 5058 mutex_exit(&(DEVI(dip)->devi_lock)); 5059 5060 if (ndi_dev_is_persistent_node(dip)) 5061 (void) ddi_uninitchild(dip); 5062 else { 5063 /* 5064 * Delete .conf nodes and nodes that are not 5065 * well formed. 5066 */ 5067 (void) ddi_remove_child(dip, 0); 5068 } 5069 return (NDI_FAILURE); 5070 } 5071 5072 i_ndi_devi_report_status_change(dip, NULL); 5073 5074 /* 5075 * log an event, but not during devfs lookups in which case 5076 * NDI_NO_EVENT is set. 5077 */ 5078 if ((flags & NDI_NO_EVENT) == 0 && !(DEVI_EVADD(dip))) { 5079 (void) i_log_devfs_add_devinfo(dip, flags); 5080 5081 mutex_enter(&(DEVI(dip)->devi_lock)); 5082 DEVI_SET_EVADD(dip); 5083 mutex_exit(&(DEVI(dip)->devi_lock)); 5084 } else if (!(flags & NDI_NO_EVENT_STATE_CHNG)) { 5085 mutex_enter(&(DEVI(dip)->devi_lock)); 5086 DEVI_SET_EVADD(dip); 5087 mutex_exit(&(DEVI(dip)->devi_lock)); 5088 } 5089 5090 return (NDI_SUCCESS); 5091 } 5092 5093 /* internal function to config immediate children */ 5094 static int 5095 config_immediate_children(dev_info_t *pdip, uint_t flags, major_t major) 5096 { 5097 dev_info_t *child, *next; 5098 int circ; 5099 5100 ASSERT(i_ddi_devi_attached(pdip)); 5101 5102 if (!NEXUS_DRV(ddi_get_driver(pdip))) 5103 return (NDI_SUCCESS); 5104 5105 NDI_CONFIG_DEBUG((CE_CONT, 5106 "config_immediate_children: %s%d (%p), flags=%x\n", 5107 ddi_driver_name(pdip), ddi_get_instance(pdip), 5108 (void *)pdip, flags)); 5109 5110 ndi_devi_enter(pdip, &circ); 5111 5112 if (flags & NDI_CONFIG_REPROBE) { 5113 mutex_enter(&DEVI(pdip)->devi_lock); 5114 DEVI(pdip)->devi_flags &= ~DEVI_MADE_CHILDREN; 5115 mutex_exit(&DEVI(pdip)->devi_lock); 5116 } 5117 (void) i_ndi_make_spec_children(pdip, flags); 5118 i_ndi_init_hw_children(pdip, flags); 5119 5120 child = ddi_get_child(pdip); 5121 while (child) { 5122 /* NOTE: devi_attach_node() may remove the dip */ 5123 next = ddi_get_next_sibling(child); 5124 5125 /* 5126 * Configure all nexus nodes or leaf nodes with 5127 * matching driver major 5128 */ 5129 if ((major == DDI_MAJOR_T_NONE) || 5130 (major == ddi_driver_major(child)) || 5131 ((flags & NDI_CONFIG) && (is_leaf_node(child) == 0))) 5132 (void) devi_attach_node(child, flags); 5133 child = next; 5134 } 5135 5136 ndi_devi_exit(pdip, circ); 5137 5138 return (NDI_SUCCESS); 5139 } 5140 5141 /* internal function to config grand children */ 5142 static int 5143 config_grand_children(dev_info_t *pdip, uint_t flags, major_t major) 5144 { 5145 struct mt_config_handle *hdl; 5146 5147 /* multi-threaded configuration of child nexus */ 5148 hdl = mt_config_init(pdip, NULL, flags, major, MT_CONFIG_OP, NULL); 5149 mt_config_children(hdl); 5150 5151 return (mt_config_fini(hdl)); /* wait for threads to exit */ 5152 } 5153 5154 /* 5155 * Common function for device tree configuration, 5156 * either BUS_CONFIG_ALL or BUS_CONFIG_DRIVER. 5157 * The NDI_CONFIG flag causes recursive configuration of 5158 * grandchildren, devfs usage should not recurse. 5159 */ 5160 static int 5161 devi_config_common(dev_info_t *dip, int flags, major_t major) 5162 { 5163 int error; 5164 int (*f)(); 5165 5166 if (!i_ddi_devi_attached(dip)) 5167 return (NDI_FAILURE); 5168 5169 if (pm_pre_config(dip, NULL) != DDI_SUCCESS) 5170 return (NDI_FAILURE); 5171 5172 if ((DEVI(dip)->devi_ops->devo_bus_ops == NULL) || 5173 (DEVI(dip)->devi_ops->devo_bus_ops->busops_rev < BUSO_REV_5) || 5174 (f = DEVI(dip)->devi_ops->devo_bus_ops->bus_config) == NULL) { 5175 error = config_immediate_children(dip, flags, major); 5176 } else { 5177 /* call bus_config entry point */ 5178 ddi_bus_config_op_t bus_op = (major == DDI_MAJOR_T_NONE) ? 5179 BUS_CONFIG_ALL : BUS_CONFIG_DRIVER; 5180 error = (*f)(dip, 5181 flags, bus_op, (void *)(uintptr_t)major, NULL, 0); 5182 } 5183 5184 if (error) { 5185 pm_post_config(dip, NULL); 5186 return (error); 5187 } 5188 5189 /* 5190 * Some callers, notably SCSI, need to mark the devfs cache 5191 * to be rebuilt together with the config operation. 5192 */ 5193 if (flags & NDI_DEVFS_CLEAN) 5194 (void) devfs_clean(dip, NULL, 0); 5195 5196 if (flags & NDI_CONFIG) 5197 (void) config_grand_children(dip, flags, major); 5198 5199 pm_post_config(dip, NULL); 5200 5201 return (NDI_SUCCESS); 5202 } 5203 5204 /* 5205 * Framework entry point for BUS_CONFIG_ALL 5206 */ 5207 int 5208 ndi_devi_config(dev_info_t *dip, int flags) 5209 { 5210 NDI_CONFIG_DEBUG((CE_CONT, 5211 "ndi_devi_config: par = %s%d (%p), flags = 0x%x\n", 5212 ddi_driver_name(dip), ddi_get_instance(dip), (void *)dip, flags)); 5213 5214 return (devi_config_common(dip, flags, DDI_MAJOR_T_NONE)); 5215 } 5216 5217 /* 5218 * Framework entry point for BUS_CONFIG_DRIVER, bound to major 5219 */ 5220 int 5221 ndi_devi_config_driver(dev_info_t *dip, int flags, major_t major) 5222 { 5223 /* don't abuse this function */ 5224 ASSERT(major != DDI_MAJOR_T_NONE); 5225 5226 NDI_CONFIG_DEBUG((CE_CONT, 5227 "ndi_devi_config_driver: par = %s%d (%p), flags = 0x%x\n", 5228 ddi_driver_name(dip), ddi_get_instance(dip), (void *)dip, flags)); 5229 5230 return (devi_config_common(dip, flags, major)); 5231 } 5232 5233 /* 5234 * Called by nexus drivers to configure its children. 5235 */ 5236 static int 5237 devi_config_one(dev_info_t *pdip, char *devnm, dev_info_t **cdipp, 5238 uint_t flags, clock_t timeout) 5239 { 5240 dev_info_t *vdip = NULL; 5241 char *drivername = NULL; 5242 int find_by_addr = 0; 5243 char *name, *addr; 5244 int v_circ, p_circ; 5245 clock_t end_time; /* 60 sec */ 5246 int probed; 5247 dev_info_t *cdip; 5248 mdi_pathinfo_t *cpip; 5249 5250 *cdipp = NULL; 5251 5252 if (!NEXUS_DRV(ddi_get_driver(pdip))) 5253 return (NDI_FAILURE); 5254 5255 /* split name into "name@addr" parts */ 5256 i_ddi_parse_name(devnm, &name, &addr, NULL); 5257 5258 /* 5259 * If the nexus is a pHCI and we are not processing a pHCI from 5260 * mdi bus_config code then we need to know the vHCI. 5261 */ 5262 if (MDI_PHCI(pdip)) 5263 vdip = mdi_devi_get_vdip(pdip); 5264 5265 /* 5266 * We may have a genericname on a system that creates drivername 5267 * nodes (from .conf files). Find the drivername by nodeid. If we 5268 * can't find a node with devnm as the node name then we search by 5269 * drivername. This allows an implementation to supply a genericly 5270 * named boot path (disk) and locate drivename nodes (sd). The 5271 * NDI_PROMNAME flag does not apply to /devices/pseudo paths. 5272 */ 5273 if ((flags & NDI_PROMNAME) && (pdip != pseudo_dip)) { 5274 drivername = child_path_to_driver(pdip, name, addr); 5275 find_by_addr = 1; 5276 } 5277 5278 /* 5279 * Determine end_time: This routine should *not* be called with a 5280 * constant non-zero timeout argument, the caller should be adjusting 5281 * the timeout argument relative to when it *started* its asynchronous 5282 * enumeration. 5283 */ 5284 if (timeout > 0) 5285 end_time = ddi_get_lbolt() + timeout; 5286 5287 for (;;) { 5288 /* 5289 * For pHCI, enter (vHCI, pHCI) and search for pathinfo/client 5290 * child - break out of for(;;) loop if child found. 5291 * NOTE: Lock order for ndi_devi_enter is (vHCI, pHCI). 5292 */ 5293 if (vdip) { 5294 /* use mdi_devi_enter ordering */ 5295 ndi_devi_enter(vdip, &v_circ); 5296 ndi_devi_enter(pdip, &p_circ); 5297 cpip = mdi_pi_find(pdip, NULL, addr); 5298 cdip = mdi_pi_get_client(cpip); 5299 if (cdip) 5300 break; 5301 } else 5302 ndi_devi_enter(pdip, &p_circ); 5303 5304 /* 5305 * When not a vHCI or not all pHCI devices are required to 5306 * enumerated under the vHCI (NDI_MDI_FALLBACK) search for 5307 * devinfo child. 5308 */ 5309 if ((vdip == NULL) || (flags & NDI_MDI_FALLBACK)) { 5310 /* determine if .conf nodes already built */ 5311 probed = (DEVI(pdip)->devi_flags & DEVI_MADE_CHILDREN); 5312 5313 /* 5314 * Search for child by name, if not found then search 5315 * for a node bound to the drivername driver with the 5316 * specified "@addr". Break out of for(;;) loop if 5317 * child found. To support path-oriented aliases 5318 * binding on boot-device, we do a search_by_addr too. 5319 */ 5320 again: (void) i_ndi_make_spec_children(pdip, flags); 5321 cdip = find_child_by_name(pdip, name, addr); 5322 if ((cdip == NULL) && drivername) 5323 cdip = find_child_by_driver(pdip, 5324 drivername, addr); 5325 if ((cdip == NULL) && find_by_addr) 5326 cdip = find_child_by_addr(pdip, addr); 5327 if (cdip) 5328 break; 5329 5330 /* 5331 * determine if we should reenumerate .conf nodes 5332 * and look for child again. 5333 */ 5334 if (probed && 5335 i_ddi_io_initialized() && 5336 (flags & NDI_CONFIG_REPROBE) && 5337 ((timeout <= 0) || (ddi_get_lbolt() >= end_time))) { 5338 probed = 0; 5339 mutex_enter(&DEVI(pdip)->devi_lock); 5340 DEVI(pdip)->devi_flags &= ~DEVI_MADE_CHILDREN; 5341 mutex_exit(&DEVI(pdip)->devi_lock); 5342 goto again; 5343 } 5344 } 5345 5346 /* break out of for(;;) if time expired */ 5347 if ((timeout <= 0) || (ddi_get_lbolt() >= end_time)) 5348 break; 5349 5350 /* 5351 * Child not found, exit and wait for asynchronous enumeration 5352 * to add child (or timeout). The addition of a new child (vhci 5353 * or phci) requires the asynchronous enumeration thread to 5354 * ndi_devi_enter/ndi_devi_exit. This exit will signal devi_cv 5355 * and cause us to return from ndi_devi_exit_and_wait, after 5356 * which we loop and search for the requested child again. 5357 */ 5358 NDI_DEBUG(flags, (CE_CONT, 5359 "%s%d: waiting for child %s@%s, timeout %ld", 5360 ddi_driver_name(pdip), ddi_get_instance(pdip), 5361 name, addr, timeout)); 5362 if (vdip) { 5363 /* 5364 * Mark vHCI for pHCI ndi_devi_exit broadcast. 5365 */ 5366 mutex_enter(&DEVI(vdip)->devi_lock); 5367 DEVI(vdip)->devi_flags |= 5368 DEVI_PHCI_SIGNALS_VHCI; 5369 mutex_exit(&DEVI(vdip)->devi_lock); 5370 ndi_devi_exit(pdip, p_circ); 5371 5372 /* 5373 * NB: There is a small race window from above 5374 * ndi_devi_exit() of pdip to cv_wait() in 5375 * ndi_devi_exit_and_wait() which can result in 5376 * not immediately finding a new pHCI child 5377 * of a pHCI that uses NDI_MDI_FAILBACK. 5378 */ 5379 ndi_devi_exit_and_wait(vdip, v_circ, end_time); 5380 } else { 5381 ndi_devi_exit_and_wait(pdip, p_circ, end_time); 5382 } 5383 } 5384 5385 /* done with paddr, fixup i_ddi_parse_name '@'->'\0' change */ 5386 if (addr && *addr != '\0') 5387 *(addr - 1) = '@'; 5388 5389 /* attach and hold the child, returning pointer to child */ 5390 if (cdip && (devi_attach_node(cdip, flags) == NDI_SUCCESS)) { 5391 ndi_hold_devi(cdip); 5392 *cdipp = cdip; 5393 } 5394 5395 ndi_devi_exit(pdip, p_circ); 5396 if (vdip) 5397 ndi_devi_exit(vdip, v_circ); 5398 return (*cdipp ? NDI_SUCCESS : NDI_FAILURE); 5399 } 5400 5401 /* 5402 * Enumerate and attach a child specified by name 'devnm'. 5403 * Called by devfs lookup and DR to perform a BUS_CONFIG_ONE. 5404 * Note: devfs does not make use of NDI_CONFIG to configure 5405 * an entire branch. 5406 */ 5407 int 5408 ndi_devi_config_one(dev_info_t *dip, char *devnm, dev_info_t **dipp, int flags) 5409 { 5410 int error; 5411 int (*f)(); 5412 int branch_event = 0; 5413 5414 ASSERT(dipp); 5415 ASSERT(i_ddi_devi_attached(dip)); 5416 5417 NDI_CONFIG_DEBUG((CE_CONT, 5418 "ndi_devi_config_one: par = %s%d (%p), child = %s\n", 5419 ddi_driver_name(dip), ddi_get_instance(dip), (void *)dip, devnm)); 5420 5421 if (pm_pre_config(dip, devnm) != DDI_SUCCESS) 5422 return (NDI_FAILURE); 5423 5424 if ((flags & (NDI_NO_EVENT | NDI_BRANCH_EVENT_OP)) == 0 && 5425 (flags & NDI_CONFIG)) { 5426 flags |= NDI_BRANCH_EVENT_OP; 5427 branch_event = 1; 5428 } 5429 5430 if ((DEVI(dip)->devi_ops->devo_bus_ops == NULL) || 5431 (DEVI(dip)->devi_ops->devo_bus_ops->busops_rev < BUSO_REV_5) || 5432 (f = DEVI(dip)->devi_ops->devo_bus_ops->bus_config) == NULL) { 5433 error = devi_config_one(dip, devnm, dipp, flags, 0); 5434 } else { 5435 /* call bus_config entry point */ 5436 error = (*f)(dip, flags, BUS_CONFIG_ONE, (void *)devnm, dipp); 5437 } 5438 5439 if (error || (flags & NDI_CONFIG) == 0) { 5440 pm_post_config(dip, devnm); 5441 return (error); 5442 } 5443 5444 /* 5445 * DR usage (i.e. call with NDI_CONFIG) recursively configures 5446 * grandchildren, performing a BUS_CONFIG_ALL from the node attached 5447 * by the BUS_CONFIG_ONE. 5448 */ 5449 ASSERT(*dipp); 5450 5451 error = devi_config_common(*dipp, flags, DDI_MAJOR_T_NONE); 5452 5453 pm_post_config(dip, devnm); 5454 5455 if (branch_event) 5456 (void) i_log_devfs_branch_add(*dipp); 5457 5458 return (error); 5459 } 5460 5461 5462 /* 5463 * Enumerate and attach a child specified by name 'devnm'. 5464 * Called during configure the OBP options. This configures 5465 * only one node. 5466 */ 5467 static int 5468 ndi_devi_config_obp_args(dev_info_t *parent, char *devnm, 5469 dev_info_t **childp, int flags) 5470 { 5471 int error; 5472 int (*f)(); 5473 5474 ASSERT(childp); 5475 ASSERT(i_ddi_devi_attached(parent)); 5476 5477 NDI_CONFIG_DEBUG((CE_CONT, "ndi_devi_config_obp_args: " 5478 "par = %s%d (%p), child = %s\n", ddi_driver_name(parent), 5479 ddi_get_instance(parent), (void *)parent, devnm)); 5480 5481 if ((DEVI(parent)->devi_ops->devo_bus_ops == NULL) || 5482 (DEVI(parent)->devi_ops->devo_bus_ops->busops_rev < BUSO_REV_5) || 5483 (f = DEVI(parent)->devi_ops->devo_bus_ops->bus_config) == NULL) { 5484 error = NDI_FAILURE; 5485 } else { 5486 /* call bus_config entry point */ 5487 error = (*f)(parent, flags, 5488 BUS_CONFIG_OBP_ARGS, (void *)devnm, childp); 5489 } 5490 return (error); 5491 } 5492 5493 /* 5494 * Pay attention, the following is a bit tricky: 5495 * There are three possible cases when constraints are applied 5496 * 5497 * - A constraint is applied and the offline is disallowed. 5498 * Simply return failure and block the offline 5499 * 5500 * - A constraint is applied and the offline is allowed. 5501 * Mark the dip as having passed the constraint and allow 5502 * offline to proceed. 5503 * 5504 * - A constraint is not applied. Allow the offline to proceed for now. 5505 * 5506 * In the latter two cases we allow the offline to proceed. If the 5507 * offline succeeds (no users) everything is fine. It is ok for an unused 5508 * device to be offlined even if no constraints were imposed on the offline. 5509 * If the offline fails because there are users, we look at the constraint 5510 * flag on the dip. If the constraint flag is set (implying that it passed 5511 * a constraint) we allow the dip to be retired. If not, we don't allow 5512 * the retire. This ensures that we don't allow unconstrained retire. 5513 */ 5514 int 5515 e_ddi_offline_notify(dev_info_t *dip) 5516 { 5517 int retval; 5518 int constraint; 5519 int failure; 5520 5521 RIO_VERBOSE((CE_NOTE, "e_ddi_offline_notify(): entered: dip=%p", 5522 (void *) dip)); 5523 5524 constraint = 0; 5525 failure = 0; 5526 5527 /* 5528 * Start with userland constraints first - applied via device contracts 5529 */ 5530 retval = contract_device_offline(dip, DDI_DEV_T_ANY, 0); 5531 switch (retval) { 5532 case CT_NACK: 5533 RIO_DEBUG((CE_NOTE, "Received NACK for dip=%p", (void *)dip)); 5534 failure = 1; 5535 goto out; 5536 case CT_ACK: 5537 constraint = 1; 5538 RIO_DEBUG((CE_NOTE, "Received ACK for dip=%p", (void *)dip)); 5539 break; 5540 case CT_NONE: 5541 /* no contracts */ 5542 RIO_DEBUG((CE_NOTE, "No contracts on dip=%p", (void *)dip)); 5543 break; 5544 default: 5545 ASSERT(retval == CT_NONE); 5546 } 5547 5548 /* 5549 * Next, use LDI to impose kernel constraints 5550 */ 5551 retval = ldi_invoke_notify(dip, DDI_DEV_T_ANY, 0, LDI_EV_OFFLINE, NULL); 5552 switch (retval) { 5553 case LDI_EV_FAILURE: 5554 contract_device_negend(dip, DDI_DEV_T_ANY, 0, CT_EV_FAILURE); 5555 RIO_DEBUG((CE_NOTE, "LDI callback failed on dip=%p", 5556 (void *)dip)); 5557 failure = 1; 5558 goto out; 5559 case LDI_EV_SUCCESS: 5560 constraint = 1; 5561 RIO_DEBUG((CE_NOTE, "LDI callback success on dip=%p", 5562 (void *)dip)); 5563 break; 5564 case LDI_EV_NONE: 5565 /* no matching LDI callbacks */ 5566 RIO_DEBUG((CE_NOTE, "No LDI callbacks for dip=%p", 5567 (void *)dip)); 5568 break; 5569 default: 5570 ASSERT(retval == LDI_EV_NONE); 5571 } 5572 5573 out: 5574 mutex_enter(&(DEVI(dip)->devi_lock)); 5575 if ((DEVI(dip)->devi_flags & DEVI_RETIRING) && failure) { 5576 RIO_VERBOSE((CE_NOTE, "e_ddi_offline_notify(): setting " 5577 "BLOCKED flag. dip=%p", (void *)dip)); 5578 DEVI(dip)->devi_flags |= DEVI_R_BLOCKED; 5579 if (DEVI(dip)->devi_flags & DEVI_R_CONSTRAINT) { 5580 RIO_VERBOSE((CE_NOTE, "e_ddi_offline_notify(): " 5581 "blocked. clearing RCM CONSTRAINT flag. dip=%p", 5582 (void *)dip)); 5583 DEVI(dip)->devi_flags &= ~DEVI_R_CONSTRAINT; 5584 } 5585 } else if ((DEVI(dip)->devi_flags & DEVI_RETIRING) && constraint) { 5586 RIO_VERBOSE((CE_NOTE, "e_ddi_offline_notify(): setting " 5587 "CONSTRAINT flag. dip=%p", (void *)dip)); 5588 DEVI(dip)->devi_flags |= DEVI_R_CONSTRAINT; 5589 } else if ((DEVI(dip)->devi_flags & DEVI_RETIRING) && 5590 DEVI(dip)->devi_ref == 0) { 5591 /* also allow retire if device is not in use */ 5592 RIO_VERBOSE((CE_NOTE, "e_ddi_offline_notify(): device not in " 5593 "use. Setting CONSTRAINT flag. dip=%p", (void *)dip)); 5594 DEVI(dip)->devi_flags |= DEVI_R_CONSTRAINT; 5595 } else { 5596 /* 5597 * Note: We cannot ASSERT here that DEVI_R_CONSTRAINT is 5598 * not set, since other sources (such as RCM) may have 5599 * set the flag. 5600 */ 5601 RIO_VERBOSE((CE_NOTE, "e_ddi_offline_notify(): not setting " 5602 "constraint flag. dip=%p", (void *)dip)); 5603 } 5604 mutex_exit(&(DEVI(dip)->devi_lock)); 5605 5606 5607 RIO_VERBOSE((CE_NOTE, "e_ddi_offline_notify(): exit: dip=%p", 5608 (void *) dip)); 5609 5610 return (failure ? DDI_FAILURE : DDI_SUCCESS); 5611 } 5612 5613 void 5614 e_ddi_offline_finalize(dev_info_t *dip, int result) 5615 { 5616 RIO_DEBUG((CE_NOTE, "e_ddi_offline_finalize(): entry: result=%s, " 5617 "dip=%p", result == DDI_SUCCESS ? "SUCCESS" : "FAILURE", 5618 (void *)dip)); 5619 5620 contract_device_negend(dip, DDI_DEV_T_ANY, 0, result == DDI_SUCCESS ? 5621 CT_EV_SUCCESS : CT_EV_FAILURE); 5622 5623 ldi_invoke_finalize(dip, DDI_DEV_T_ANY, 0, 5624 LDI_EV_OFFLINE, result == DDI_SUCCESS ? 5625 LDI_EV_SUCCESS : LDI_EV_FAILURE, NULL); 5626 5627 RIO_VERBOSE((CE_NOTE, "e_ddi_offline_finalize(): exit: dip=%p", 5628 (void *)dip)); 5629 } 5630 5631 void 5632 e_ddi_degrade_finalize(dev_info_t *dip) 5633 { 5634 RIO_DEBUG((CE_NOTE, "e_ddi_degrade_finalize(): entry: " 5635 "result always = DDI_SUCCESS, dip=%p", (void *)dip)); 5636 5637 contract_device_degrade(dip, DDI_DEV_T_ANY, 0); 5638 contract_device_negend(dip, DDI_DEV_T_ANY, 0, CT_EV_SUCCESS); 5639 5640 ldi_invoke_finalize(dip, DDI_DEV_T_ANY, 0, LDI_EV_DEGRADE, 5641 LDI_EV_SUCCESS, NULL); 5642 5643 RIO_VERBOSE((CE_NOTE, "e_ddi_degrade_finalize(): exit: dip=%p", 5644 (void *)dip)); 5645 } 5646 5647 void 5648 e_ddi_undegrade_finalize(dev_info_t *dip) 5649 { 5650 RIO_DEBUG((CE_NOTE, "e_ddi_undegrade_finalize(): entry: " 5651 "result always = DDI_SUCCESS, dip=%p", (void *)dip)); 5652 5653 contract_device_undegrade(dip, DDI_DEV_T_ANY, 0); 5654 contract_device_negend(dip, DDI_DEV_T_ANY, 0, CT_EV_SUCCESS); 5655 5656 RIO_VERBOSE((CE_NOTE, "e_ddi_undegrade_finalize(): exit: dip=%p", 5657 (void *)dip)); 5658 } 5659 5660 /* 5661 * detach a node with parent already held busy 5662 */ 5663 static int 5664 devi_detach_node(dev_info_t *dip, uint_t flags) 5665 { 5666 dev_info_t *pdip = ddi_get_parent(dip); 5667 int ret = NDI_SUCCESS; 5668 ddi_eventcookie_t cookie; 5669 char *path = NULL; 5670 char *class = NULL; 5671 char *driver = NULL; 5672 int instance = -1; 5673 int post_event = 0; 5674 5675 ASSERT(pdip && DEVI_BUSY_OWNED(pdip)); 5676 5677 /* 5678 * Invoke notify if offlining 5679 */ 5680 if (flags & NDI_DEVI_OFFLINE) { 5681 RIO_DEBUG((CE_NOTE, "devi_detach_node: offlining dip=%p", 5682 (void *)dip)); 5683 if (e_ddi_offline_notify(dip) != DDI_SUCCESS) { 5684 RIO_DEBUG((CE_NOTE, "devi_detach_node: offline NACKed" 5685 "dip=%p", (void *)dip)); 5686 return (NDI_FAILURE); 5687 } 5688 } 5689 5690 if (flags & NDI_POST_EVENT) { 5691 if (i_ddi_devi_attached(pdip)) { 5692 if (ddi_get_eventcookie(dip, DDI_DEVI_REMOVE_EVENT, 5693 &cookie) == NDI_SUCCESS) 5694 (void) ndi_post_event(dip, dip, cookie, NULL); 5695 } 5696 } 5697 5698 if (i_ddi_detachchild(dip, flags) != DDI_SUCCESS) { 5699 if (flags & NDI_DEVI_OFFLINE) { 5700 RIO_DEBUG((CE_NOTE, "devi_detach_node: offline failed." 5701 " Calling e_ddi_offline_finalize with result=%d. " 5702 "dip=%p", DDI_FAILURE, (void *)dip)); 5703 e_ddi_offline_finalize(dip, DDI_FAILURE); 5704 } 5705 return (NDI_FAILURE); 5706 } 5707 5708 if (flags & NDI_DEVI_OFFLINE) { 5709 RIO_DEBUG((CE_NOTE, "devi_detach_node: offline succeeded." 5710 " Calling e_ddi_offline_finalize with result=%d, " 5711 "dip=%p", DDI_SUCCESS, (void *)dip)); 5712 e_ddi_offline_finalize(dip, DDI_SUCCESS); 5713 } 5714 5715 if (flags & NDI_AUTODETACH) 5716 return (NDI_SUCCESS); 5717 5718 /* 5719 * For DR, even bound nodes may need to have offline 5720 * flag set. 5721 */ 5722 if (flags & NDI_DEVI_OFFLINE) { 5723 mutex_enter(&(DEVI(dip)->devi_lock)); 5724 DEVI_SET_DEVICE_OFFLINE(dip); 5725 mutex_exit(&(DEVI(dip)->devi_lock)); 5726 } 5727 5728 if (i_ddi_node_state(dip) == DS_INITIALIZED) { 5729 path = kmem_alloc(MAXPATHLEN, KM_SLEEP); 5730 (void) ddi_pathname(dip, path); 5731 if (flags & NDI_DEVI_OFFLINE) 5732 i_ndi_devi_report_status_change(dip, path); 5733 5734 if (need_remove_event(dip, flags)) { 5735 post_event = 1; 5736 class = i_ddi_strdup(i_ddi_devi_class(dip), KM_SLEEP); 5737 driver = i_ddi_strdup((char *)ddi_driver_name(dip), 5738 KM_SLEEP); 5739 instance = ddi_get_instance(dip); 5740 5741 mutex_enter(&(DEVI(dip)->devi_lock)); 5742 DEVI_SET_EVREMOVE(dip); 5743 mutex_exit(&(DEVI(dip)->devi_lock)); 5744 } 5745 } 5746 5747 if (flags & (NDI_UNCONFIG | NDI_DEVI_REMOVE)) { 5748 ret = ddi_uninitchild(dip); 5749 if (ret == NDI_SUCCESS) { 5750 /* 5751 * Remove uninitialized pseudo nodes because 5752 * system props are lost and the node cannot be 5753 * reattached. 5754 */ 5755 if (!ndi_dev_is_persistent_node(dip)) 5756 flags |= NDI_DEVI_REMOVE; 5757 5758 if (flags & NDI_DEVI_REMOVE) { 5759 ret = ddi_remove_child(dip, 0); 5760 if (post_event && ret == NDI_SUCCESS) { 5761 (void) i_log_devfs_remove_devinfo(path, 5762 class, driver, instance, flags); 5763 } 5764 } 5765 5766 } 5767 } 5768 5769 if (path) 5770 kmem_free(path, MAXPATHLEN); 5771 if (class) 5772 kmem_free(class, strlen(class) + 1); 5773 if (driver) 5774 kmem_free(driver, strlen(driver) + 1); 5775 5776 return (ret); 5777 } 5778 5779 /* 5780 * unconfigure immediate children of bus nexus device 5781 */ 5782 static int 5783 unconfig_immediate_children( 5784 dev_info_t *dip, 5785 dev_info_t **dipp, 5786 int flags, 5787 major_t major) 5788 { 5789 int rv = NDI_SUCCESS; 5790 int circ, vcirc; 5791 dev_info_t *child; 5792 dev_info_t *vdip = NULL; 5793 dev_info_t *next; 5794 5795 ASSERT(dipp == NULL || *dipp == NULL); 5796 5797 /* 5798 * Scan forward to see if we will be processing a pHCI child. If we 5799 * have a child that is a pHCI and vHCI and pHCI are not siblings then 5800 * enter vHCI before parent(pHCI) to prevent deadlock with mpxio 5801 * Client power management operations. 5802 */ 5803 ndi_devi_enter(dip, &circ); 5804 for (child = ddi_get_child(dip); child; 5805 child = ddi_get_next_sibling(child)) { 5806 /* skip same nodes we skip below */ 5807 if (((major != DDI_MAJOR_T_NONE) && 5808 (major != ddi_driver_major(child))) || 5809 ((flags & NDI_AUTODETACH) && !is_leaf_node(child))) 5810 continue; 5811 5812 if (MDI_PHCI(child)) { 5813 vdip = mdi_devi_get_vdip(child); 5814 /* 5815 * If vHCI and vHCI is not a sibling of pHCI 5816 * then enter in (vHCI, parent(pHCI)) order. 5817 */ 5818 if (vdip && (ddi_get_parent(vdip) != dip)) { 5819 ndi_devi_exit(dip, circ); 5820 5821 /* use mdi_devi_enter ordering */ 5822 ndi_devi_enter(vdip, &vcirc); 5823 ndi_devi_enter(dip, &circ); 5824 break; 5825 } else 5826 vdip = NULL; 5827 } 5828 } 5829 5830 child = ddi_get_child(dip); 5831 while (child) { 5832 next = ddi_get_next_sibling(child); 5833 5834 if ((major != DDI_MAJOR_T_NONE) && 5835 (major != ddi_driver_major(child))) { 5836 child = next; 5837 continue; 5838 } 5839 5840 /* skip nexus nodes during autodetach */ 5841 if ((flags & NDI_AUTODETACH) && !is_leaf_node(child)) { 5842 child = next; 5843 continue; 5844 } 5845 5846 if (devi_detach_node(child, flags) != NDI_SUCCESS) { 5847 if (dipp && *dipp == NULL) { 5848 ndi_hold_devi(child); 5849 *dipp = child; 5850 } 5851 rv = NDI_FAILURE; 5852 } 5853 5854 /* 5855 * Continue upon failure--best effort algorithm 5856 */ 5857 child = next; 5858 } 5859 5860 ndi_devi_exit(dip, circ); 5861 if (vdip) 5862 ndi_devi_exit(vdip, vcirc); 5863 5864 return (rv); 5865 } 5866 5867 /* 5868 * unconfigure grand children of bus nexus device 5869 */ 5870 static int 5871 unconfig_grand_children( 5872 dev_info_t *dip, 5873 dev_info_t **dipp, 5874 int flags, 5875 major_t major, 5876 struct brevq_node **brevqp) 5877 { 5878 struct mt_config_handle *hdl; 5879 5880 if (brevqp) 5881 *brevqp = NULL; 5882 5883 /* multi-threaded configuration of child nexus */ 5884 hdl = mt_config_init(dip, dipp, flags, major, MT_UNCONFIG_OP, brevqp); 5885 mt_config_children(hdl); 5886 5887 return (mt_config_fini(hdl)); /* wait for threads to exit */ 5888 } 5889 5890 /* 5891 * Unconfigure children/descendants of the dip. 5892 * 5893 * If brevqp is not NULL, on return *brevqp is set to a queue of dip's 5894 * child devinames for which branch remove events need to be generated. 5895 */ 5896 static int 5897 devi_unconfig_common( 5898 dev_info_t *dip, 5899 dev_info_t **dipp, 5900 int flags, 5901 major_t major, 5902 struct brevq_node **brevqp) 5903 { 5904 int rv; 5905 int pm_cookie; 5906 int (*f)(); 5907 ddi_bus_config_op_t bus_op; 5908 5909 if (dipp) 5910 *dipp = NULL; 5911 if (brevqp) 5912 *brevqp = NULL; 5913 5914 /* 5915 * Power up the dip if it is powered off. If the flag bit 5916 * NDI_AUTODETACH is set and the dip is not at its full power, 5917 * skip the rest of the branch. 5918 */ 5919 if (pm_pre_unconfig(dip, flags, &pm_cookie, NULL) != DDI_SUCCESS) 5920 return ((flags & NDI_AUTODETACH) ? NDI_SUCCESS : 5921 NDI_FAILURE); 5922 5923 /* 5924 * Some callers, notably SCSI, need to clear out the devfs 5925 * cache together with the unconfig to prevent stale entries. 5926 */ 5927 if (flags & NDI_DEVFS_CLEAN) 5928 (void) devfs_clean(dip, NULL, 0); 5929 5930 rv = unconfig_grand_children(dip, dipp, flags, major, brevqp); 5931 5932 if ((rv != NDI_SUCCESS) && ((flags & NDI_AUTODETACH) == 0)) { 5933 if (brevqp && *brevqp) { 5934 log_and_free_br_events_on_grand_children(dip, *brevqp); 5935 free_brevq(*brevqp); 5936 *brevqp = NULL; 5937 } 5938 pm_post_unconfig(dip, pm_cookie, NULL); 5939 return (rv); 5940 } 5941 5942 if (dipp && *dipp) { 5943 ndi_rele_devi(*dipp); 5944 *dipp = NULL; 5945 } 5946 5947 /* 5948 * It is possible to have a detached nexus with children 5949 * and grandchildren (for example: a branch consisting 5950 * entirely of bound nodes.) Since the nexus is detached 5951 * the bus_unconfig entry point cannot be used to remove 5952 * or unconfigure the descendants. 5953 */ 5954 if (!i_ddi_devi_attached(dip) || 5955 (DEVI(dip)->devi_ops->devo_bus_ops == NULL) || 5956 (DEVI(dip)->devi_ops->devo_bus_ops->busops_rev < BUSO_REV_5) || 5957 (f = DEVI(dip)->devi_ops->devo_bus_ops->bus_unconfig) == NULL) { 5958 rv = unconfig_immediate_children(dip, dipp, flags, major); 5959 } else { 5960 /* 5961 * call bus_unconfig entry point 5962 * It should reset nexus flags if unconfigure succeeds. 5963 */ 5964 bus_op = (major == DDI_MAJOR_T_NONE) ? 5965 BUS_UNCONFIG_ALL : BUS_UNCONFIG_DRIVER; 5966 rv = (*f)(dip, flags, bus_op, (void *)(uintptr_t)major); 5967 } 5968 5969 pm_post_unconfig(dip, pm_cookie, NULL); 5970 5971 if (brevqp && *brevqp) 5972 cleanup_br_events_on_grand_children(dip, brevqp); 5973 5974 return (rv); 5975 } 5976 5977 /* 5978 * called by devfs/framework to unconfigure children bound to major 5979 * If NDI_AUTODETACH is specified, this is invoked by either the 5980 * moduninstall daemon or the modunload -i 0 command. 5981 */ 5982 int 5983 ndi_devi_unconfig_driver(dev_info_t *dip, int flags, major_t major) 5984 { 5985 NDI_CONFIG_DEBUG((CE_CONT, 5986 "ndi_devi_unconfig_driver: par = %s%d (%p), flags = 0x%x\n", 5987 ddi_driver_name(dip), ddi_get_instance(dip), (void *)dip, flags)); 5988 5989 return (devi_unconfig_common(dip, NULL, flags, major, NULL)); 5990 } 5991 5992 int 5993 ndi_devi_unconfig(dev_info_t *dip, int flags) 5994 { 5995 NDI_CONFIG_DEBUG((CE_CONT, 5996 "ndi_devi_unconfig: par = %s%d (%p), flags = 0x%x\n", 5997 ddi_driver_name(dip), ddi_get_instance(dip), (void *)dip, flags)); 5998 5999 return (devi_unconfig_common(dip, NULL, flags, DDI_MAJOR_T_NONE, NULL)); 6000 } 6001 6002 int 6003 e_ddi_devi_unconfig(dev_info_t *dip, dev_info_t **dipp, int flags) 6004 { 6005 NDI_CONFIG_DEBUG((CE_CONT, 6006 "e_ddi_devi_unconfig: par = %s%d (%p), flags = 0x%x\n", 6007 ddi_driver_name(dip), ddi_get_instance(dip), (void *)dip, flags)); 6008 6009 return (devi_unconfig_common(dip, dipp, flags, DDI_MAJOR_T_NONE, NULL)); 6010 } 6011 6012 /* 6013 * Unconfigure child by name 6014 */ 6015 static int 6016 devi_unconfig_one(dev_info_t *pdip, char *devnm, int flags) 6017 { 6018 int rv, circ; 6019 dev_info_t *child; 6020 dev_info_t *vdip = NULL; 6021 int v_circ; 6022 6023 ndi_devi_enter(pdip, &circ); 6024 child = ndi_devi_findchild(pdip, devnm); 6025 6026 /* 6027 * If child is pHCI and vHCI and pHCI are not siblings then enter vHCI 6028 * before parent(pHCI) to avoid deadlock with mpxio Client power 6029 * management operations. 6030 */ 6031 if (child && MDI_PHCI(child)) { 6032 vdip = mdi_devi_get_vdip(child); 6033 if (vdip && (ddi_get_parent(vdip) != pdip)) { 6034 ndi_devi_exit(pdip, circ); 6035 6036 /* use mdi_devi_enter ordering */ 6037 ndi_devi_enter(vdip, &v_circ); 6038 ndi_devi_enter(pdip, &circ); 6039 child = ndi_devi_findchild(pdip, devnm); 6040 } else 6041 vdip = NULL; 6042 } 6043 6044 if (child) { 6045 rv = devi_detach_node(child, flags); 6046 } else { 6047 NDI_CONFIG_DEBUG((CE_CONT, 6048 "devi_unconfig_one: %s not found\n", devnm)); 6049 rv = NDI_SUCCESS; 6050 } 6051 6052 ndi_devi_exit(pdip, circ); 6053 if (vdip) 6054 ndi_devi_exit(vdip, v_circ); 6055 6056 return (rv); 6057 } 6058 6059 int 6060 ndi_devi_unconfig_one( 6061 dev_info_t *pdip, 6062 char *devnm, 6063 dev_info_t **dipp, 6064 int flags) 6065 { 6066 int (*f)(); 6067 int circ, rv; 6068 int pm_cookie; 6069 dev_info_t *child; 6070 dev_info_t *vdip = NULL; 6071 int v_circ; 6072 struct brevq_node *brevq = NULL; 6073 6074 ASSERT(i_ddi_devi_attached(pdip)); 6075 6076 NDI_CONFIG_DEBUG((CE_CONT, 6077 "ndi_devi_unconfig_one: par = %s%d (%p), child = %s\n", 6078 ddi_driver_name(pdip), ddi_get_instance(pdip), 6079 (void *)pdip, devnm)); 6080 6081 if (pm_pre_unconfig(pdip, flags, &pm_cookie, devnm) != DDI_SUCCESS) 6082 return (NDI_FAILURE); 6083 6084 if (dipp) 6085 *dipp = NULL; 6086 6087 ndi_devi_enter(pdip, &circ); 6088 child = ndi_devi_findchild(pdip, devnm); 6089 6090 /* 6091 * If child is pHCI and vHCI and pHCI are not siblings then enter vHCI 6092 * before parent(pHCI) to avoid deadlock with mpxio Client power 6093 * management operations. 6094 */ 6095 if (child && MDI_PHCI(child)) { 6096 vdip = mdi_devi_get_vdip(child); 6097 if (vdip && (ddi_get_parent(vdip) != pdip)) { 6098 ndi_devi_exit(pdip, circ); 6099 6100 /* use mdi_devi_enter ordering */ 6101 ndi_devi_enter(vdip, &v_circ); 6102 ndi_devi_enter(pdip, &circ); 6103 child = ndi_devi_findchild(pdip, devnm); 6104 } else 6105 vdip = NULL; 6106 } 6107 6108 if (child == NULL) { 6109 NDI_CONFIG_DEBUG((CE_CONT, "ndi_devi_unconfig_one: %s" 6110 " not found\n", devnm)); 6111 rv = NDI_SUCCESS; 6112 goto out; 6113 } 6114 6115 /* 6116 * Unconfigure children/descendants of named child 6117 */ 6118 rv = devi_unconfig_branch(child, dipp, flags | NDI_UNCONFIG, &brevq); 6119 if (rv != NDI_SUCCESS) 6120 goto out; 6121 6122 init_bound_node_ev(pdip, child, flags); 6123 6124 if ((DEVI(pdip)->devi_ops->devo_bus_ops == NULL) || 6125 (DEVI(pdip)->devi_ops->devo_bus_ops->busops_rev < BUSO_REV_5) || 6126 (f = DEVI(pdip)->devi_ops->devo_bus_ops->bus_unconfig) == NULL) { 6127 rv = devi_detach_node(child, flags); 6128 } else { 6129 /* call bus_config entry point */ 6130 rv = (*f)(pdip, flags, BUS_UNCONFIG_ONE, (void *)devnm); 6131 } 6132 6133 if (brevq) { 6134 if (rv != NDI_SUCCESS) 6135 log_and_free_brevq_dip(child, brevq); 6136 else 6137 free_brevq(brevq); 6138 } 6139 6140 if (dipp && rv != NDI_SUCCESS) { 6141 ndi_hold_devi(child); 6142 ASSERT(*dipp == NULL); 6143 *dipp = child; 6144 } 6145 6146 out: 6147 ndi_devi_exit(pdip, circ); 6148 if (vdip) 6149 ndi_devi_exit(vdip, v_circ); 6150 6151 pm_post_unconfig(pdip, pm_cookie, devnm); 6152 6153 return (rv); 6154 } 6155 6156 struct async_arg { 6157 dev_info_t *dip; 6158 uint_t flags; 6159 }; 6160 6161 /* 6162 * Common async handler for: 6163 * ndi_devi_bind_driver_async 6164 * ndi_devi_online_async 6165 */ 6166 static int 6167 i_ndi_devi_async_common(dev_info_t *dip, uint_t flags, void (*func)()) 6168 { 6169 int tqflag; 6170 int kmflag; 6171 struct async_arg *arg; 6172 dev_info_t *pdip = ddi_get_parent(dip); 6173 6174 ASSERT(pdip); 6175 ASSERT(DEVI(pdip)->devi_taskq); 6176 ASSERT(ndi_dev_is_persistent_node(dip)); 6177 6178 if (flags & NDI_NOSLEEP) { 6179 kmflag = KM_NOSLEEP; 6180 tqflag = TQ_NOSLEEP; 6181 } else { 6182 kmflag = KM_SLEEP; 6183 tqflag = TQ_SLEEP; 6184 } 6185 6186 arg = kmem_alloc(sizeof (*arg), kmflag); 6187 if (arg == NULL) 6188 goto fail; 6189 6190 arg->flags = flags; 6191 arg->dip = dip; 6192 if (ddi_taskq_dispatch(DEVI(pdip)->devi_taskq, func, arg, tqflag) == 6193 DDI_SUCCESS) { 6194 return (NDI_SUCCESS); 6195 } 6196 6197 fail: 6198 NDI_CONFIG_DEBUG((CE_CONT, "%s%d: ddi_taskq_dispatch failed", 6199 ddi_driver_name(pdip), ddi_get_instance(pdip))); 6200 6201 if (arg) 6202 kmem_free(arg, sizeof (*arg)); 6203 return (NDI_FAILURE); 6204 } 6205 6206 static void 6207 i_ndi_devi_bind_driver_cb(struct async_arg *arg) 6208 { 6209 (void) ndi_devi_bind_driver(arg->dip, arg->flags); 6210 kmem_free(arg, sizeof (*arg)); 6211 } 6212 6213 int 6214 ndi_devi_bind_driver_async(dev_info_t *dip, uint_t flags) 6215 { 6216 return (i_ndi_devi_async_common(dip, flags, 6217 (void (*)())i_ndi_devi_bind_driver_cb)); 6218 } 6219 6220 /* 6221 * place the devinfo in the ONLINE state. 6222 */ 6223 int 6224 ndi_devi_online(dev_info_t *dip, uint_t flags) 6225 { 6226 int circ, rv; 6227 dev_info_t *pdip = ddi_get_parent(dip); 6228 int branch_event = 0; 6229 6230 ASSERT(pdip); 6231 6232 NDI_CONFIG_DEBUG((CE_CONT, "ndi_devi_online: %s%d (%p)\n", 6233 ddi_driver_name(dip), ddi_get_instance(dip), (void *)dip)); 6234 6235 ndi_devi_enter(pdip, &circ); 6236 /* bind child before merging .conf nodes */ 6237 rv = i_ndi_config_node(dip, DS_BOUND, flags); 6238 if (rv != NDI_SUCCESS) { 6239 ndi_devi_exit(pdip, circ); 6240 return (rv); 6241 } 6242 6243 /* merge .conf properties */ 6244 (void) i_ndi_make_spec_children(pdip, flags); 6245 6246 flags |= (NDI_DEVI_ONLINE | NDI_CONFIG); 6247 6248 if (flags & NDI_NO_EVENT) { 6249 /* 6250 * Caller is specifically asking for not to generate an event. 6251 * Set the following flag so that devi_attach_node() don't 6252 * change the event state. 6253 */ 6254 flags |= NDI_NO_EVENT_STATE_CHNG; 6255 } 6256 6257 if ((flags & (NDI_NO_EVENT | NDI_BRANCH_EVENT_OP)) == 0 && 6258 ((flags & NDI_CONFIG) || DEVI_NEED_NDI_CONFIG(dip))) { 6259 flags |= NDI_BRANCH_EVENT_OP; 6260 branch_event = 1; 6261 } 6262 6263 /* 6264 * devi_attach_node() may remove dip on failure 6265 */ 6266 if ((rv = devi_attach_node(dip, flags)) == NDI_SUCCESS) { 6267 if ((flags & NDI_CONFIG) || DEVI_NEED_NDI_CONFIG(dip)) { 6268 (void) ndi_devi_config(dip, flags); 6269 } 6270 6271 if (branch_event) 6272 (void) i_log_devfs_branch_add(dip); 6273 } 6274 6275 ndi_devi_exit(pdip, circ); 6276 6277 /* 6278 * Notify devfs that we have a new node. Devfs needs to invalidate 6279 * cached directory contents. 6280 * 6281 * For PCMCIA devices, it is possible the pdip is not fully 6282 * attached. In this case, calling back into devfs will 6283 * result in a loop or assertion error. Hence, the check 6284 * on node state. 6285 * 6286 * If we own parent lock, this is part of a branch operation. 6287 * We skip the devfs_clean() step because the cache invalidation 6288 * is done higher up in the device tree. 6289 */ 6290 if (rv == NDI_SUCCESS && i_ddi_devi_attached(pdip) && 6291 !DEVI_BUSY_OWNED(pdip)) 6292 (void) devfs_clean(pdip, NULL, 0); 6293 return (rv); 6294 } 6295 6296 static void 6297 i_ndi_devi_online_cb(struct async_arg *arg) 6298 { 6299 (void) ndi_devi_online(arg->dip, arg->flags); 6300 kmem_free(arg, sizeof (*arg)); 6301 } 6302 6303 int 6304 ndi_devi_online_async(dev_info_t *dip, uint_t flags) 6305 { 6306 /* mark child as need config if requested. */ 6307 if (flags & NDI_CONFIG) { 6308 mutex_enter(&(DEVI(dip)->devi_lock)); 6309 DEVI_SET_NDI_CONFIG(dip); 6310 mutex_exit(&(DEVI(dip)->devi_lock)); 6311 } 6312 6313 return (i_ndi_devi_async_common(dip, flags, 6314 (void (*)())i_ndi_devi_online_cb)); 6315 } 6316 6317 /* 6318 * Take a device node Offline 6319 * To take a device Offline means to detach the device instance from 6320 * the driver and prevent devfs requests from re-attaching the device 6321 * instance. 6322 * 6323 * The flag NDI_DEVI_REMOVE causes removes the device node from 6324 * the driver list and the device tree. In this case, the device 6325 * is assumed to be removed from the system. 6326 */ 6327 int 6328 ndi_devi_offline(dev_info_t *dip, uint_t flags) 6329 { 6330 int circ, rval = 0; 6331 dev_info_t *pdip = ddi_get_parent(dip); 6332 dev_info_t *vdip = NULL; 6333 int v_circ; 6334 struct brevq_node *brevq = NULL; 6335 6336 ASSERT(pdip); 6337 6338 flags |= NDI_DEVI_OFFLINE; 6339 6340 /* 6341 * If child is pHCI and vHCI and pHCI are not siblings then enter vHCI 6342 * before parent(pHCI) to avoid deadlock with mpxio Client power 6343 * management operations. 6344 */ 6345 if (MDI_PHCI(dip)) { 6346 vdip = mdi_devi_get_vdip(dip); 6347 if (vdip && (ddi_get_parent(vdip) != pdip)) 6348 ndi_devi_enter(vdip, &v_circ); 6349 else 6350 vdip = NULL; 6351 } 6352 ndi_devi_enter(pdip, &circ); 6353 6354 if (i_ddi_node_state(dip) == DS_READY) { 6355 /* 6356 * If dip is in DS_READY state, there may be cached dv_nodes 6357 * referencing this dip, so we invoke devfs code path. 6358 * Note that we must release busy changing on pdip to 6359 * avoid deadlock against devfs. 6360 */ 6361 char *devname = kmem_alloc(MAXNAMELEN + 1, KM_SLEEP); 6362 (void) ddi_deviname(dip, devname); 6363 6364 ndi_devi_exit(pdip, circ); 6365 if (vdip) 6366 ndi_devi_exit(vdip, v_circ); 6367 6368 /* 6369 * If we own parent lock, this is part of a branch 6370 * operation. We skip the devfs_clean() step. 6371 */ 6372 if (!DEVI_BUSY_OWNED(pdip)) 6373 (void) devfs_clean(pdip, devname + 1, DV_CLEAN_FORCE); 6374 kmem_free(devname, MAXNAMELEN + 1); 6375 6376 rval = devi_unconfig_branch(dip, NULL, flags|NDI_UNCONFIG, 6377 &brevq); 6378 6379 if (rval) 6380 return (NDI_FAILURE); 6381 6382 if (vdip) 6383 ndi_devi_enter(vdip, &v_circ); 6384 ndi_devi_enter(pdip, &circ); 6385 } 6386 6387 init_bound_node_ev(pdip, dip, flags); 6388 6389 rval = devi_detach_node(dip, flags); 6390 if (brevq) { 6391 if (rval != NDI_SUCCESS) 6392 log_and_free_brevq_dip(dip, brevq); 6393 else 6394 free_brevq(brevq); 6395 } 6396 6397 ndi_devi_exit(pdip, circ); 6398 if (vdip) 6399 ndi_devi_exit(vdip, v_circ); 6400 6401 return (rval); 6402 } 6403 6404 /* 6405 * Find the child dev_info node of parent nexus 'p' whose name 6406 * matches "cname@caddr". Recommend use of ndi_devi_findchild() instead. 6407 */ 6408 dev_info_t * 6409 ndi_devi_find(dev_info_t *pdip, char *cname, char *caddr) 6410 { 6411 dev_info_t *child; 6412 int circ; 6413 6414 if (pdip == NULL || cname == NULL || caddr == NULL) 6415 return ((dev_info_t *)NULL); 6416 6417 ndi_devi_enter(pdip, &circ); 6418 child = find_sibling(ddi_get_child(pdip), cname, caddr, 6419 FIND_NODE_BY_NODENAME, NULL); 6420 ndi_devi_exit(pdip, circ); 6421 return (child); 6422 } 6423 6424 /* 6425 * Find the child dev_info node of parent nexus 'p' whose name 6426 * matches devname "name@addr". Permits caller to hold the parent. 6427 */ 6428 dev_info_t * 6429 ndi_devi_findchild(dev_info_t *pdip, char *devname) 6430 { 6431 dev_info_t *child; 6432 char *cname, *caddr; 6433 char *devstr; 6434 6435 ASSERT(DEVI_BUSY_OWNED(pdip)); 6436 6437 devstr = i_ddi_strdup(devname, KM_SLEEP); 6438 i_ddi_parse_name(devstr, &cname, &caddr, NULL); 6439 6440 if (cname == NULL || caddr == NULL) { 6441 kmem_free(devstr, strlen(devname)+1); 6442 return ((dev_info_t *)NULL); 6443 } 6444 6445 child = find_sibling(ddi_get_child(pdip), cname, caddr, 6446 FIND_NODE_BY_NODENAME, NULL); 6447 kmem_free(devstr, strlen(devname)+1); 6448 return (child); 6449 } 6450 6451 /* 6452 * Misc. routines called by framework only 6453 */ 6454 6455 /* 6456 * Clear the DEVI_MADE_CHILDREN/DEVI_ATTACHED_CHILDREN flags 6457 * if new child spec has been added. 6458 */ 6459 static int 6460 reset_nexus_flags(dev_info_t *dip, void *arg) 6461 { 6462 struct hwc_spec *list; 6463 int circ; 6464 6465 if (((DEVI(dip)->devi_flags & DEVI_MADE_CHILDREN) == 0) || 6466 ((list = hwc_get_child_spec(dip, (major_t)(uintptr_t)arg)) == NULL)) 6467 return (DDI_WALK_CONTINUE); 6468 6469 hwc_free_spec_list(list); 6470 6471 /* coordinate child state update */ 6472 ndi_devi_enter(dip, &circ); 6473 mutex_enter(&DEVI(dip)->devi_lock); 6474 DEVI(dip)->devi_flags &= ~(DEVI_MADE_CHILDREN | DEVI_ATTACHED_CHILDREN); 6475 mutex_exit(&DEVI(dip)->devi_lock); 6476 ndi_devi_exit(dip, circ); 6477 6478 return (DDI_WALK_CONTINUE); 6479 } 6480 6481 /* 6482 * Helper functions, returns NULL if no memory. 6483 */ 6484 6485 /* 6486 * path_to_major: 6487 * 6488 * Return an alternate driver name binding for the leaf device 6489 * of the given pathname, if there is one. The purpose of this 6490 * function is to deal with generic pathnames. The default action 6491 * for platforms that can't do this (ie: x86 or any platform that 6492 * does not have prom_finddevice functionality, which matches 6493 * nodenames and unit-addresses without the drivers participation) 6494 * is to return DDI_MAJOR_T_NONE. 6495 * 6496 * Used in loadrootmodules() in the swapgeneric module to 6497 * associate a given pathname with a given leaf driver. 6498 * 6499 */ 6500 major_t 6501 path_to_major(char *path) 6502 { 6503 dev_info_t *dip; 6504 char *p, *q; 6505 pnode_t nodeid; 6506 major_t major; 6507 6508 /* check for path-oriented alias */ 6509 major = ddi_name_to_major(path); 6510 if ((major != DDI_MAJOR_T_NONE) && 6511 !(devnamesp[major].dn_flags & DN_DRIVER_REMOVED)) { 6512 NDI_CONFIG_DEBUG((CE_NOTE, "path_to_major: %s path bound %s\n", 6513 path, ddi_major_to_name(major))); 6514 return (major); 6515 } 6516 6517 /* 6518 * Get the nodeid of the given pathname, if such a mapping exists. 6519 */ 6520 dip = NULL; 6521 nodeid = prom_finddevice(path); 6522 if (nodeid != OBP_BADNODE) { 6523 /* 6524 * Find the nodeid in our copy of the device tree and return 6525 * whatever name we used to bind this node to a driver. 6526 */ 6527 dip = e_ddi_nodeid_to_dip(nodeid); 6528 } 6529 6530 if (dip == NULL) { 6531 NDI_CONFIG_DEBUG((CE_WARN, 6532 "path_to_major: can't bind <%s>\n", path)); 6533 return (DDI_MAJOR_T_NONE); 6534 } 6535 6536 /* 6537 * If we're bound to something other than the nodename, 6538 * note that in the message buffer and system log. 6539 */ 6540 p = ddi_binding_name(dip); 6541 q = ddi_node_name(dip); 6542 if (p && q && (strcmp(p, q) != 0)) 6543 NDI_CONFIG_DEBUG((CE_NOTE, "path_to_major: %s bound to %s\n", 6544 path, p)); 6545 6546 major = ddi_name_to_major(p); 6547 6548 ndi_rele_devi(dip); /* release e_ddi_nodeid_to_dip hold */ 6549 6550 return (major); 6551 } 6552 6553 /* 6554 * Return the held dip for the specified major and instance, attempting to do 6555 * an attach if specified. Return NULL if the devi can't be found or put in 6556 * the proper state. The caller must release the hold via ddi_release_devi if 6557 * a non-NULL value is returned. 6558 * 6559 * Some callers expect to be able to perform a hold_devi() while in a context 6560 * where using ndi_devi_enter() to ensure the hold might cause deadlock (see 6561 * open-from-attach code in consconfig_dacf.c). Such special-case callers 6562 * must ensure that an ndi_devi_enter(parent)/ndi_devi_hold() from a safe 6563 * context is already active. The hold_devi() implementation must accommodate 6564 * these callers. 6565 */ 6566 static dev_info_t * 6567 hold_devi(major_t major, int instance, int flags) 6568 { 6569 struct devnames *dnp; 6570 dev_info_t *dip; 6571 char *path; 6572 char *vpath; 6573 6574 if ((major >= devcnt) || (instance == -1)) 6575 return (NULL); 6576 6577 /* try to find the instance in the per driver list */ 6578 dnp = &(devnamesp[major]); 6579 LOCK_DEV_OPS(&(dnp->dn_lock)); 6580 for (dip = dnp->dn_head; dip; 6581 dip = (dev_info_t *)DEVI(dip)->devi_next) { 6582 /* skip node if instance field is not valid */ 6583 if (i_ddi_node_state(dip) < DS_INITIALIZED) 6584 continue; 6585 6586 /* look for instance match */ 6587 if (DEVI(dip)->devi_instance == instance) { 6588 /* 6589 * To accommodate callers that can't block in 6590 * ndi_devi_enter() we do an ndi_devi_hold(), and 6591 * afterwards check that the node is in a state where 6592 * the hold prevents detach(). If we did not manage to 6593 * prevent detach then we ndi_rele_devi() and perform 6594 * the slow path below (which can result in a blocking 6595 * ndi_devi_enter() while driving attach top-down). 6596 * This code depends on the ordering of 6597 * DEVI_SET_DETACHING and the devi_ref check in the 6598 * detach_node() code path. 6599 */ 6600 ndi_hold_devi(dip); 6601 if (i_ddi_devi_attached(dip) && 6602 !DEVI_IS_DETACHING(dip)) { 6603 UNLOCK_DEV_OPS(&(dnp->dn_lock)); 6604 return (dip); /* fast-path with devi held */ 6605 } 6606 ndi_rele_devi(dip); 6607 6608 /* try slow-path */ 6609 dip = NULL; 6610 break; 6611 } 6612 } 6613 ASSERT(dip == NULL); 6614 UNLOCK_DEV_OPS(&(dnp->dn_lock)); 6615 6616 if (flags & E_DDI_HOLD_DEVI_NOATTACH) 6617 return (NULL); /* told not to drive attach */ 6618 6619 /* slow-path may block, so it should not occur from interrupt */ 6620 ASSERT(!servicing_interrupt()); 6621 if (servicing_interrupt()) 6622 return (NULL); 6623 6624 /* reconstruct the path and drive attach by path through devfs. */ 6625 path = kmem_alloc(MAXPATHLEN, KM_SLEEP); 6626 if (e_ddi_majorinstance_to_path(major, instance, path) == 0) { 6627 dip = e_ddi_hold_devi_by_path(path, flags); 6628 6629 /* 6630 * Verify that we got the correct device - a path_to_inst file 6631 * with a bogus/corrupt path (or a nexus that changes its 6632 * unit-address format) could result in an incorrect answer 6633 * 6634 * Verify major, instance, and path. 6635 */ 6636 vpath = kmem_alloc(MAXPATHLEN, KM_SLEEP); 6637 if (dip && 6638 ((DEVI(dip)->devi_major != major) || 6639 ((DEVI(dip)->devi_instance != instance)) || 6640 (strcmp(path, ddi_pathname(dip, vpath)) != 0))) { 6641 ndi_rele_devi(dip); 6642 dip = NULL; /* no answer better than wrong answer */ 6643 } 6644 kmem_free(vpath, MAXPATHLEN); 6645 } 6646 kmem_free(path, MAXPATHLEN); 6647 return (dip); /* with devi held */ 6648 } 6649 6650 /* 6651 * The {e_}ddi_hold_devi{_by_{instance|dev|path}} hold the devinfo node 6652 * associated with the specified arguments. This hold should be released 6653 * by calling ddi_release_devi. 6654 * 6655 * The E_DDI_HOLD_DEVI_NOATTACH flag argument allows the caller to to specify 6656 * a failure return if the node is not already attached. 6657 * 6658 * NOTE: by the time we make e_ddi_hold_devi public, we should be able to reuse 6659 * ddi_hold_devi again. 6660 */ 6661 dev_info_t * 6662 ddi_hold_devi_by_instance(major_t major, int instance, int flags) 6663 { 6664 return (hold_devi(major, instance, flags)); 6665 } 6666 6667 dev_info_t * 6668 e_ddi_hold_devi_by_dev(dev_t dev, int flags) 6669 { 6670 major_t major = getmajor(dev); 6671 dev_info_t *dip; 6672 struct dev_ops *ops; 6673 dev_info_t *ddip = NULL; 6674 6675 dip = hold_devi(major, dev_to_instance(dev), flags); 6676 6677 /* 6678 * The rest of this routine is legacy support for drivers that 6679 * have broken DDI_INFO_DEVT2INSTANCE implementations but may have 6680 * functional DDI_INFO_DEVT2DEVINFO implementations. This code will 6681 * diagnose inconsistency and, for maximum compatibility with legacy 6682 * drivers, give preference to the drivers DDI_INFO_DEVT2DEVINFO 6683 * implementation over the above derived dip based the driver's 6684 * DDI_INFO_DEVT2INSTANCE implementation. This legacy support should 6685 * be removed when DDI_INFO_DEVT2DEVINFO is deprecated. 6686 * 6687 * NOTE: The following code has a race condition. DEVT2DEVINFO 6688 * returns a dip which is not held. By the time we ref ddip, 6689 * it could have been freed. The saving grace is that for 6690 * most drivers, the dip returned from hold_devi() is the 6691 * same one as the one returned by DEVT2DEVINFO, so we are 6692 * safe for drivers with the correct getinfo(9e) impl. 6693 */ 6694 if (((ops = ddi_hold_driver(major)) != NULL) && 6695 CB_DRV_INSTALLED(ops) && ops->devo_getinfo) { 6696 if ((*ops->devo_getinfo)(NULL, DDI_INFO_DEVT2DEVINFO, 6697 (void *)dev, (void **)&ddip) != DDI_SUCCESS) 6698 ddip = NULL; 6699 } 6700 6701 /* give preference to the driver returned DEVT2DEVINFO dip */ 6702 if (ddip && (dip != ddip)) { 6703 #ifdef DEBUG 6704 cmn_err(CE_WARN, "%s: inconsistent getinfo(9E) implementation", 6705 ddi_driver_name(ddip)); 6706 #endif /* DEBUG */ 6707 ndi_hold_devi(ddip); 6708 if (dip) 6709 ndi_rele_devi(dip); 6710 dip = ddip; 6711 } 6712 6713 if (ops) 6714 ddi_rele_driver(major); 6715 6716 return (dip); 6717 } 6718 6719 /* 6720 * For compatibility only. Do not call this function! 6721 */ 6722 dev_info_t * 6723 e_ddi_get_dev_info(dev_t dev, vtype_t type) 6724 { 6725 dev_info_t *dip = NULL; 6726 if (getmajor(dev) >= devcnt) 6727 return (NULL); 6728 6729 switch (type) { 6730 case VCHR: 6731 case VBLK: 6732 dip = e_ddi_hold_devi_by_dev(dev, 0); 6733 default: 6734 break; 6735 } 6736 6737 /* 6738 * For compatibility reasons, we can only return the dip with 6739 * the driver ref count held. This is not a safe thing to do. 6740 * For certain broken third-party software, we are willing 6741 * to venture into unknown territory. 6742 */ 6743 if (dip) { 6744 (void) ndi_hold_driver(dip); 6745 ndi_rele_devi(dip); 6746 } 6747 return (dip); 6748 } 6749 6750 dev_info_t * 6751 e_ddi_hold_devi_by_path(char *path, int flags) 6752 { 6753 dev_info_t *dip; 6754 6755 /* can't specify NOATTACH by path */ 6756 ASSERT(!(flags & E_DDI_HOLD_DEVI_NOATTACH)); 6757 6758 return (resolve_pathname(path, &dip, NULL, NULL) ? NULL : dip); 6759 } 6760 6761 void 6762 e_ddi_hold_devi(dev_info_t *dip) 6763 { 6764 ndi_hold_devi(dip); 6765 } 6766 6767 void 6768 ddi_release_devi(dev_info_t *dip) 6769 { 6770 ndi_rele_devi(dip); 6771 } 6772 6773 /* 6774 * Associate a streams queue with a devinfo node 6775 * NOTE: This function is called by STREAM driver's put procedure. 6776 * It cannot block. 6777 */ 6778 void 6779 ddi_assoc_queue_with_devi(queue_t *q, dev_info_t *dip) 6780 { 6781 queue_t *rq = _RD(q); 6782 struct stdata *stp; 6783 vnode_t *vp; 6784 6785 /* set flag indicating that ddi_assoc_queue_with_devi was called */ 6786 mutex_enter(QLOCK(rq)); 6787 rq->q_flag |= _QASSOCIATED; 6788 mutex_exit(QLOCK(rq)); 6789 6790 /* get the vnode associated with the queue */ 6791 stp = STREAM(rq); 6792 vp = stp->sd_vnode; 6793 ASSERT(vp); 6794 6795 /* change the hardware association of the vnode */ 6796 spec_assoc_vp_with_devi(vp, dip); 6797 } 6798 6799 /* 6800 * ddi_install_driver(name) 6801 * 6802 * Driver installation is currently a byproduct of driver loading. This 6803 * may change. 6804 */ 6805 int 6806 ddi_install_driver(char *name) 6807 { 6808 major_t major = ddi_name_to_major(name); 6809 6810 if ((major == DDI_MAJOR_T_NONE) || 6811 (ddi_hold_installed_driver(major) == NULL)) { 6812 return (DDI_FAILURE); 6813 } 6814 ddi_rele_driver(major); 6815 return (DDI_SUCCESS); 6816 } 6817 6818 struct dev_ops * 6819 ddi_hold_driver(major_t major) 6820 { 6821 return (mod_hold_dev_by_major(major)); 6822 } 6823 6824 6825 void 6826 ddi_rele_driver(major_t major) 6827 { 6828 mod_rele_dev_by_major(major); 6829 } 6830 6831 6832 /* 6833 * This is called during boot to force attachment order of special dips 6834 * dip must be referenced via ndi_hold_devi() 6835 */ 6836 int 6837 i_ddi_attach_node_hierarchy(dev_info_t *dip) 6838 { 6839 dev_info_t *parent; 6840 int ret, circ; 6841 6842 /* 6843 * Recurse up until attached parent is found. 6844 */ 6845 if (i_ddi_devi_attached(dip)) 6846 return (DDI_SUCCESS); 6847 parent = ddi_get_parent(dip); 6848 if (i_ddi_attach_node_hierarchy(parent) != DDI_SUCCESS) 6849 return (DDI_FAILURE); 6850 6851 /* 6852 * Come top-down, expanding .conf nodes under this parent 6853 * and driving attach. 6854 */ 6855 ndi_devi_enter(parent, &circ); 6856 (void) i_ndi_make_spec_children(parent, 0); 6857 ret = i_ddi_attachchild(dip); 6858 ndi_devi_exit(parent, circ); 6859 6860 return (ret); 6861 } 6862 6863 /* keep this function static */ 6864 static int 6865 attach_driver_nodes(major_t major) 6866 { 6867 struct devnames *dnp; 6868 dev_info_t *dip; 6869 int error = DDI_FAILURE; 6870 int circ; 6871 6872 dnp = &devnamesp[major]; 6873 LOCK_DEV_OPS(&dnp->dn_lock); 6874 dip = dnp->dn_head; 6875 while (dip) { 6876 ndi_hold_devi(dip); 6877 UNLOCK_DEV_OPS(&dnp->dn_lock); 6878 if (i_ddi_attach_node_hierarchy(dip) == DDI_SUCCESS) 6879 error = DDI_SUCCESS; 6880 /* 6881 * Set the 'ddi-config-driver-node' property on a nexus 6882 * node to cause attach_driver_nodes() to configure all 6883 * immediate children of the nexus. This property should 6884 * be set on nodes with immediate children that bind to 6885 * the same driver as parent. 6886 */ 6887 if ((error == DDI_SUCCESS) && (ddi_prop_exists(DDI_DEV_T_ANY, 6888 dip, DDI_PROP_DONTPASS, "ddi-config-driver-node"))) { 6889 ndi_devi_enter(dip, &circ); 6890 (void) ndi_devi_config(dip, NDI_NO_EVENT); 6891 ndi_devi_exit(dip, circ); 6892 } 6893 LOCK_DEV_OPS(&dnp->dn_lock); 6894 ndi_rele_devi(dip); 6895 dip = ddi_get_next(dip); 6896 } 6897 if (error == DDI_SUCCESS) 6898 dnp->dn_flags |= DN_NO_AUTODETACH; 6899 UNLOCK_DEV_OPS(&dnp->dn_lock); 6900 6901 6902 return (error); 6903 } 6904 6905 /* 6906 * i_ddi_attach_hw_nodes configures and attaches all hw nodes 6907 * bound to a specific driver. This function replaces calls to 6908 * ddi_hold_installed_driver() for drivers with no .conf 6909 * enumerated nodes. 6910 * 6911 * This facility is typically called at boot time to attach 6912 * platform-specific hardware nodes, such as ppm nodes on xcal 6913 * and grover and keyswitch nodes on cherrystone. It does not 6914 * deal with .conf enumerated node. Calling it beyond the boot 6915 * process is strongly discouraged. 6916 */ 6917 int 6918 i_ddi_attach_hw_nodes(char *driver) 6919 { 6920 major_t major; 6921 6922 major = ddi_name_to_major(driver); 6923 if (major == DDI_MAJOR_T_NONE) 6924 return (DDI_FAILURE); 6925 6926 return (attach_driver_nodes(major)); 6927 } 6928 6929 /* 6930 * i_ddi_attach_pseudo_node configures pseudo drivers which 6931 * has a single node. The .conf nodes must be enumerated 6932 * before calling this interface. The dip is held attached 6933 * upon returning. 6934 * 6935 * This facility should only be called only at boot time 6936 * by the I/O framework. 6937 */ 6938 dev_info_t * 6939 i_ddi_attach_pseudo_node(char *driver) 6940 { 6941 major_t major; 6942 dev_info_t *dip; 6943 6944 major = ddi_name_to_major(driver); 6945 if (major == DDI_MAJOR_T_NONE) 6946 return (NULL); 6947 6948 if (attach_driver_nodes(major) != DDI_SUCCESS) 6949 return (NULL); 6950 6951 dip = devnamesp[major].dn_head; 6952 ASSERT(dip && ddi_get_next(dip) == NULL); 6953 ndi_hold_devi(dip); 6954 return (dip); 6955 } 6956 6957 static void 6958 diplist_to_parent_major(dev_info_t *head, char parents[]) 6959 { 6960 major_t major; 6961 dev_info_t *dip, *pdip; 6962 6963 for (dip = head; dip != NULL; dip = ddi_get_next(dip)) { 6964 pdip = ddi_get_parent(dip); 6965 ASSERT(pdip); /* disallow rootnex.conf nodes */ 6966 major = ddi_driver_major(pdip); 6967 if ((major != DDI_MAJOR_T_NONE) && parents[major] == 0) 6968 parents[major] = 1; 6969 } 6970 } 6971 6972 /* 6973 * Call ddi_hold_installed_driver() on each parent major 6974 * and invoke mt_config_driver() to attach child major. 6975 * This is part of the implementation of ddi_hold_installed_driver. 6976 */ 6977 static int 6978 attach_driver_by_parent(major_t child_major, char parents[]) 6979 { 6980 major_t par_major; 6981 struct mt_config_handle *hdl; 6982 int flags = NDI_DEVI_PERSIST | NDI_NO_EVENT; 6983 6984 hdl = mt_config_init(NULL, NULL, flags, child_major, MT_CONFIG_OP, 6985 NULL); 6986 for (par_major = 0; par_major < devcnt; par_major++) { 6987 /* disallow recursion on the same driver */ 6988 if (parents[par_major] == 0 || par_major == child_major) 6989 continue; 6990 if (ddi_hold_installed_driver(par_major) == NULL) 6991 continue; 6992 hdl->mtc_parmajor = par_major; 6993 mt_config_driver(hdl); 6994 ddi_rele_driver(par_major); 6995 } 6996 (void) mt_config_fini(hdl); 6997 6998 return (i_ddi_devs_attached(child_major)); 6999 } 7000 7001 int 7002 i_ddi_devs_attached(major_t major) 7003 { 7004 dev_info_t *dip; 7005 struct devnames *dnp; 7006 int error = DDI_FAILURE; 7007 7008 /* check for attached instances */ 7009 dnp = &devnamesp[major]; 7010 LOCK_DEV_OPS(&dnp->dn_lock); 7011 for (dip = dnp->dn_head; dip != NULL; dip = ddi_get_next(dip)) { 7012 if (i_ddi_devi_attached(dip)) { 7013 error = DDI_SUCCESS; 7014 break; 7015 } 7016 } 7017 UNLOCK_DEV_OPS(&dnp->dn_lock); 7018 7019 return (error); 7020 } 7021 7022 int 7023 i_ddi_minor_node_count(dev_info_t *ddip, const char *node_type) 7024 { 7025 int circ; 7026 struct ddi_minor_data *dp; 7027 int count = 0; 7028 7029 ndi_devi_enter(ddip, &circ); 7030 for (dp = DEVI(ddip)->devi_minor; dp != NULL; dp = dp->next) { 7031 if (strcmp(dp->ddm_node_type, node_type) == 0) 7032 count++; 7033 } 7034 ndi_devi_exit(ddip, circ); 7035 return (count); 7036 } 7037 7038 /* 7039 * ddi_hold_installed_driver configures and attaches all 7040 * instances of the specified driver. To accomplish this 7041 * it configures and attaches all possible parents of 7042 * the driver, enumerated both in h/w nodes and in the 7043 * driver's .conf file. 7044 * 7045 * NOTE: This facility is for compatibility purposes only and will 7046 * eventually go away. Its usage is strongly discouraged. 7047 */ 7048 static void 7049 enter_driver(struct devnames *dnp) 7050 { 7051 mutex_enter(&dnp->dn_lock); 7052 ASSERT(dnp->dn_busy_thread != curthread); 7053 while (dnp->dn_flags & DN_DRIVER_BUSY) 7054 cv_wait(&dnp->dn_wait, &dnp->dn_lock); 7055 dnp->dn_flags |= DN_DRIVER_BUSY; 7056 dnp->dn_busy_thread = curthread; 7057 mutex_exit(&dnp->dn_lock); 7058 } 7059 7060 static void 7061 exit_driver(struct devnames *dnp) 7062 { 7063 mutex_enter(&dnp->dn_lock); 7064 ASSERT(dnp->dn_busy_thread == curthread); 7065 dnp->dn_flags &= ~DN_DRIVER_BUSY; 7066 dnp->dn_busy_thread = NULL; 7067 cv_broadcast(&dnp->dn_wait); 7068 mutex_exit(&dnp->dn_lock); 7069 } 7070 7071 struct dev_ops * 7072 ddi_hold_installed_driver(major_t major) 7073 { 7074 struct dev_ops *ops; 7075 struct devnames *dnp; 7076 char *parents; 7077 int error; 7078 7079 ops = ddi_hold_driver(major); 7080 if (ops == NULL) 7081 return (NULL); 7082 7083 /* 7084 * Return immediately if all the attach operations associated 7085 * with a ddi_hold_installed_driver() call have already been done. 7086 */ 7087 dnp = &devnamesp[major]; 7088 enter_driver(dnp); 7089 if (dnp->dn_flags & DN_DRIVER_HELD) { 7090 exit_driver(dnp); 7091 if (i_ddi_devs_attached(major) == DDI_SUCCESS) 7092 return (ops); 7093 ddi_rele_driver(major); 7094 return (NULL); 7095 } 7096 7097 LOCK_DEV_OPS(&dnp->dn_lock); 7098 dnp->dn_flags |= (DN_DRIVER_HELD | DN_NO_AUTODETACH); 7099 UNLOCK_DEV_OPS(&dnp->dn_lock); 7100 7101 DCOMPATPRINTF((CE_CONT, 7102 "ddi_hold_installed_driver: %s\n", dnp->dn_name)); 7103 7104 /* 7105 * When the driver has no .conf children, it is sufficient 7106 * to attach existing nodes in the device tree. Nodes not 7107 * enumerated by the OBP are not attached. 7108 */ 7109 if (dnp->dn_pl == NULL) { 7110 if (attach_driver_nodes(major) == DDI_SUCCESS) { 7111 exit_driver(dnp); 7112 return (ops); 7113 } 7114 exit_driver(dnp); 7115 ddi_rele_driver(major); 7116 return (NULL); 7117 } 7118 7119 /* 7120 * Driver has .conf nodes. We find all possible parents 7121 * and recursively all ddi_hold_installed_driver on the 7122 * parent driver; then we invoke ndi_config_driver() 7123 * on all possible parent node in parallel to speed up 7124 * performance. 7125 */ 7126 parents = kmem_zalloc(devcnt * sizeof (char), KM_SLEEP); 7127 7128 LOCK_DEV_OPS(&dnp->dn_lock); 7129 /* find .conf parents */ 7130 (void) impl_parlist_to_major(dnp->dn_pl, parents); 7131 /* find hw node parents */ 7132 diplist_to_parent_major(dnp->dn_head, parents); 7133 UNLOCK_DEV_OPS(&dnp->dn_lock); 7134 7135 error = attach_driver_by_parent(major, parents); 7136 kmem_free(parents, devcnt * sizeof (char)); 7137 if (error == DDI_SUCCESS) { 7138 exit_driver(dnp); 7139 return (ops); 7140 } 7141 7142 exit_driver(dnp); 7143 ddi_rele_driver(major); 7144 return (NULL); 7145 } 7146 7147 /* 7148 * Default bus_config entry point for nexus drivers 7149 */ 7150 int 7151 ndi_busop_bus_config(dev_info_t *pdip, uint_t flags, ddi_bus_config_op_t op, 7152 void *arg, dev_info_t **child, clock_t timeout) 7153 { 7154 major_t major; 7155 7156 /* 7157 * A timeout of 30 minutes or more is probably a mistake 7158 * This is intended to catch uses where timeout is in 7159 * the wrong units. timeout must be in units of ticks. 7160 */ 7161 ASSERT(timeout < SEC_TO_TICK(1800)); 7162 7163 major = DDI_MAJOR_T_NONE; 7164 switch (op) { 7165 case BUS_CONFIG_ONE: 7166 NDI_DEBUG(flags, (CE_CONT, "%s%d: bus config %s timeout=%ld\n", 7167 ddi_driver_name(pdip), ddi_get_instance(pdip), 7168 (char *)arg, timeout)); 7169 return (devi_config_one(pdip, (char *)arg, child, flags, 7170 timeout)); 7171 7172 case BUS_CONFIG_DRIVER: 7173 major = (major_t)(uintptr_t)arg; 7174 /*FALLTHROUGH*/ 7175 case BUS_CONFIG_ALL: 7176 NDI_DEBUG(flags, (CE_CONT, "%s%d: bus config timeout=%ld\n", 7177 ddi_driver_name(pdip), ddi_get_instance(pdip), 7178 timeout)); 7179 if (timeout > 0) { 7180 NDI_DEBUG(flags, (CE_CONT, 7181 "%s%d: bus config all timeout=%ld\n", 7182 ddi_driver_name(pdip), ddi_get_instance(pdip), 7183 timeout)); 7184 delay(timeout); 7185 } 7186 return (config_immediate_children(pdip, flags, major)); 7187 7188 default: 7189 return (NDI_FAILURE); 7190 } 7191 /*NOTREACHED*/ 7192 } 7193 7194 /* 7195 * Default busop bus_unconfig handler for nexus drivers 7196 */ 7197 int 7198 ndi_busop_bus_unconfig(dev_info_t *pdip, uint_t flags, ddi_bus_config_op_t op, 7199 void *arg) 7200 { 7201 major_t major; 7202 7203 major = DDI_MAJOR_T_NONE; 7204 switch (op) { 7205 case BUS_UNCONFIG_ONE: 7206 NDI_DEBUG(flags, (CE_CONT, "%s%d: bus unconfig %s\n", 7207 ddi_driver_name(pdip), ddi_get_instance(pdip), 7208 (char *)arg)); 7209 return (devi_unconfig_one(pdip, (char *)arg, flags)); 7210 7211 case BUS_UNCONFIG_DRIVER: 7212 major = (major_t)(uintptr_t)arg; 7213 /*FALLTHROUGH*/ 7214 case BUS_UNCONFIG_ALL: 7215 NDI_DEBUG(flags, (CE_CONT, "%s%d: bus unconfig all\n", 7216 ddi_driver_name(pdip), ddi_get_instance(pdip))); 7217 return (unconfig_immediate_children(pdip, NULL, flags, major)); 7218 7219 default: 7220 return (NDI_FAILURE); 7221 } 7222 /*NOTREACHED*/ 7223 } 7224 7225 /* 7226 * dummy functions to be removed 7227 */ 7228 void 7229 impl_rem_dev_props(dev_info_t *dip) 7230 { 7231 _NOTE(ARGUNUSED(dip)) 7232 /* do nothing */ 7233 } 7234 7235 /* 7236 * Determine if a node is a leaf node. If not sure, return false (0). 7237 */ 7238 static int 7239 is_leaf_node(dev_info_t *dip) 7240 { 7241 major_t major = ddi_driver_major(dip); 7242 7243 if (major == DDI_MAJOR_T_NONE) 7244 return (0); 7245 7246 return (devnamesp[major].dn_flags & DN_LEAF_DRIVER); 7247 } 7248 7249 /* 7250 * Multithreaded [un]configuration 7251 */ 7252 static struct mt_config_handle * 7253 mt_config_init(dev_info_t *pdip, dev_info_t **dipp, int flags, 7254 major_t major, int op, struct brevq_node **brevqp) 7255 { 7256 struct mt_config_handle *hdl = kmem_alloc(sizeof (*hdl), KM_SLEEP); 7257 7258 mutex_init(&hdl->mtc_lock, NULL, MUTEX_DEFAULT, NULL); 7259 cv_init(&hdl->mtc_cv, NULL, CV_DEFAULT, NULL); 7260 hdl->mtc_pdip = pdip; 7261 hdl->mtc_fdip = dipp; 7262 hdl->mtc_parmajor = DDI_MAJOR_T_NONE; 7263 hdl->mtc_flags = flags; 7264 hdl->mtc_major = major; 7265 hdl->mtc_thr_count = 0; 7266 hdl->mtc_op = op; 7267 hdl->mtc_error = 0; 7268 hdl->mtc_brevqp = brevqp; 7269 7270 #ifdef DEBUG 7271 gethrestime(&hdl->start_time); 7272 hdl->total_time = 0; 7273 #endif /* DEBUG */ 7274 7275 return (hdl); 7276 } 7277 7278 #ifdef DEBUG 7279 static int 7280 time_diff_in_msec(timestruc_t start, timestruc_t end) 7281 { 7282 int nsec, sec; 7283 7284 sec = end.tv_sec - start.tv_sec; 7285 nsec = end.tv_nsec - start.tv_nsec; 7286 if (nsec < 0) { 7287 nsec += NANOSEC; 7288 sec -= 1; 7289 } 7290 7291 return (sec * (NANOSEC >> 20) + (nsec >> 20)); 7292 } 7293 7294 #endif /* DEBUG */ 7295 7296 static int 7297 mt_config_fini(struct mt_config_handle *hdl) 7298 { 7299 int rv; 7300 #ifdef DEBUG 7301 int real_time; 7302 timestruc_t end_time; 7303 #endif /* DEBUG */ 7304 7305 mutex_enter(&hdl->mtc_lock); 7306 while (hdl->mtc_thr_count > 0) 7307 cv_wait(&hdl->mtc_cv, &hdl->mtc_lock); 7308 rv = hdl->mtc_error; 7309 mutex_exit(&hdl->mtc_lock); 7310 7311 #ifdef DEBUG 7312 gethrestime(&end_time); 7313 real_time = time_diff_in_msec(hdl->start_time, end_time); 7314 if ((ddidebug & DDI_MTCONFIG) && hdl->mtc_pdip) 7315 cmn_err(CE_NOTE, 7316 "config %s%d: total time %d msec, real time %d msec", 7317 ddi_driver_name(hdl->mtc_pdip), 7318 ddi_get_instance(hdl->mtc_pdip), 7319 hdl->total_time, real_time); 7320 #endif /* DEBUG */ 7321 7322 cv_destroy(&hdl->mtc_cv); 7323 mutex_destroy(&hdl->mtc_lock); 7324 kmem_free(hdl, sizeof (*hdl)); 7325 7326 return (rv); 7327 } 7328 7329 struct mt_config_data { 7330 struct mt_config_handle *mtc_hdl; 7331 dev_info_t *mtc_dip; 7332 major_t mtc_major; 7333 int mtc_flags; 7334 struct brevq_node *mtc_brn; 7335 struct mt_config_data *mtc_next; 7336 }; 7337 7338 static void 7339 mt_config_thread(void *arg) 7340 { 7341 struct mt_config_data *mcd = (struct mt_config_data *)arg; 7342 struct mt_config_handle *hdl = mcd->mtc_hdl; 7343 dev_info_t *dip = mcd->mtc_dip; 7344 dev_info_t *rdip, **dipp; 7345 major_t major = mcd->mtc_major; 7346 int flags = mcd->mtc_flags; 7347 int rv = 0; 7348 7349 #ifdef DEBUG 7350 timestruc_t start_time, end_time; 7351 gethrestime(&start_time); 7352 #endif /* DEBUG */ 7353 7354 rdip = NULL; 7355 dipp = hdl->mtc_fdip ? &rdip : NULL; 7356 7357 switch (hdl->mtc_op) { 7358 case MT_CONFIG_OP: 7359 rv = devi_config_common(dip, flags, major); 7360 break; 7361 case MT_UNCONFIG_OP: 7362 if (mcd->mtc_brn) { 7363 struct brevq_node *brevq = NULL; 7364 rv = devi_unconfig_common(dip, dipp, flags, major, 7365 &brevq); 7366 mcd->mtc_brn->brn_child = brevq; 7367 } else 7368 rv = devi_unconfig_common(dip, dipp, flags, major, 7369 NULL); 7370 break; 7371 } 7372 7373 mutex_enter(&hdl->mtc_lock); 7374 #ifdef DEBUG 7375 gethrestime(&end_time); 7376 hdl->total_time += time_diff_in_msec(start_time, end_time); 7377 #endif /* DEBUG */ 7378 7379 if ((rv != NDI_SUCCESS) && (hdl->mtc_error == 0)) { 7380 hdl->mtc_error = rv; 7381 #ifdef DEBUG 7382 if ((ddidebug & DDI_DEBUG) && (major != DDI_MAJOR_T_NONE)) { 7383 char *path = kmem_alloc(MAXPATHLEN, KM_SLEEP); 7384 7385 (void) ddi_pathname(dip, path); 7386 cmn_err(CE_NOTE, "mt_config_thread: " 7387 "op %d.%d.%x at %s failed %d", 7388 hdl->mtc_op, major, flags, path, rv); 7389 kmem_free(path, MAXPATHLEN); 7390 } 7391 #endif /* DEBUG */ 7392 } 7393 7394 if (hdl->mtc_fdip && *hdl->mtc_fdip == NULL) { 7395 *hdl->mtc_fdip = rdip; 7396 rdip = NULL; 7397 } 7398 7399 if (rdip) { 7400 ASSERT(rv != NDI_SUCCESS); 7401 ndi_rele_devi(rdip); 7402 } 7403 7404 ndi_rele_devi(dip); 7405 7406 if (--hdl->mtc_thr_count == 0) 7407 cv_broadcast(&hdl->mtc_cv); 7408 mutex_exit(&hdl->mtc_lock); 7409 kmem_free(mcd, sizeof (*mcd)); 7410 } 7411 7412 /* 7413 * Multi-threaded config/unconfig of child nexus 7414 */ 7415 static void 7416 mt_config_children(struct mt_config_handle *hdl) 7417 { 7418 dev_info_t *pdip = hdl->mtc_pdip; 7419 major_t major = hdl->mtc_major; 7420 dev_info_t *dip; 7421 int circ; 7422 struct brevq_node *brn; 7423 struct mt_config_data *mcd_head = NULL; 7424 struct mt_config_data *mcd_tail = NULL; 7425 struct mt_config_data *mcd; 7426 #ifdef DEBUG 7427 timestruc_t end_time; 7428 7429 /* Update total_time in handle */ 7430 gethrestime(&end_time); 7431 hdl->total_time += time_diff_in_msec(hdl->start_time, end_time); 7432 #endif 7433 7434 ndi_devi_enter(pdip, &circ); 7435 dip = ddi_get_child(pdip); 7436 while (dip) { 7437 if (hdl->mtc_op == MT_UNCONFIG_OP && hdl->mtc_brevqp && 7438 !(DEVI_EVREMOVE(dip)) && 7439 i_ddi_node_state(dip) >= DS_INITIALIZED) { 7440 /* 7441 * Enqueue this dip's deviname. 7442 * No need to hold a lock while enqueuing since this 7443 * is the only thread doing the enqueue and no one 7444 * walks the queue while we are in multithreaded 7445 * unconfiguration. 7446 */ 7447 brn = brevq_enqueue(hdl->mtc_brevqp, dip, NULL); 7448 } else 7449 brn = NULL; 7450 7451 /* 7452 * Hold the child that we are processing so he does not get 7453 * removed. The corrisponding ndi_rele_devi() for children 7454 * that are not being skipped is done at the end of 7455 * mt_config_thread(). 7456 */ 7457 ndi_hold_devi(dip); 7458 7459 /* 7460 * skip leaf nodes and (for configure) nodes not 7461 * fully attached. 7462 */ 7463 if (is_leaf_node(dip) || 7464 (hdl->mtc_op == MT_CONFIG_OP && 7465 i_ddi_node_state(dip) < DS_READY)) { 7466 ndi_rele_devi(dip); 7467 dip = ddi_get_next_sibling(dip); 7468 continue; 7469 } 7470 7471 mcd = kmem_alloc(sizeof (*mcd), KM_SLEEP); 7472 mcd->mtc_dip = dip; 7473 mcd->mtc_hdl = hdl; 7474 mcd->mtc_brn = brn; 7475 7476 /* 7477 * Switch a 'driver' operation to an 'all' operation below a 7478 * node bound to the driver. 7479 */ 7480 if ((major == DDI_MAJOR_T_NONE) || 7481 (major == ddi_driver_major(dip))) 7482 mcd->mtc_major = DDI_MAJOR_T_NONE; 7483 else 7484 mcd->mtc_major = major; 7485 7486 /* 7487 * The unconfig-driver to unconfig-all conversion above 7488 * constitutes an autodetach for NDI_DETACH_DRIVER calls, 7489 * set NDI_AUTODETACH. 7490 */ 7491 mcd->mtc_flags = hdl->mtc_flags; 7492 if ((mcd->mtc_flags & NDI_DETACH_DRIVER) && 7493 (hdl->mtc_op == MT_UNCONFIG_OP) && 7494 (major == ddi_driver_major(pdip))) 7495 mcd->mtc_flags |= NDI_AUTODETACH; 7496 7497 mutex_enter(&hdl->mtc_lock); 7498 hdl->mtc_thr_count++; 7499 mutex_exit(&hdl->mtc_lock); 7500 7501 /* 7502 * Add to end of list to process after ndi_devi_exit to avoid 7503 * locking differences depending on value of mtc_off. 7504 */ 7505 mcd->mtc_next = NULL; 7506 if (mcd_head == NULL) 7507 mcd_head = mcd; 7508 else 7509 mcd_tail->mtc_next = mcd; 7510 mcd_tail = mcd; 7511 7512 dip = ddi_get_next_sibling(dip); 7513 } 7514 ndi_devi_exit(pdip, circ); 7515 7516 /* go through the list of held children */ 7517 for (mcd = mcd_head; mcd; mcd = mcd_head) { 7518 mcd_head = mcd->mtc_next; 7519 if (mtc_off || (mcd->mtc_flags & NDI_MTC_OFF)) 7520 mt_config_thread(mcd); 7521 else 7522 (void) thread_create(NULL, 0, mt_config_thread, mcd, 7523 0, &p0, TS_RUN, minclsyspri); 7524 } 7525 } 7526 7527 static void 7528 mt_config_driver(struct mt_config_handle *hdl) 7529 { 7530 major_t par_major = hdl->mtc_parmajor; 7531 major_t major = hdl->mtc_major; 7532 struct devnames *dnp = &devnamesp[par_major]; 7533 dev_info_t *dip; 7534 struct mt_config_data *mcd_head = NULL; 7535 struct mt_config_data *mcd_tail = NULL; 7536 struct mt_config_data *mcd; 7537 #ifdef DEBUG 7538 timestruc_t end_time; 7539 7540 /* Update total_time in handle */ 7541 gethrestime(&end_time); 7542 hdl->total_time += time_diff_in_msec(hdl->start_time, end_time); 7543 #endif 7544 ASSERT(par_major != DDI_MAJOR_T_NONE); 7545 ASSERT(major != DDI_MAJOR_T_NONE); 7546 7547 LOCK_DEV_OPS(&dnp->dn_lock); 7548 dip = devnamesp[par_major].dn_head; 7549 while (dip) { 7550 /* 7551 * Hold the child that we are processing so he does not get 7552 * removed. The corrisponding ndi_rele_devi() for children 7553 * that are not being skipped is done at the end of 7554 * mt_config_thread(). 7555 */ 7556 ndi_hold_devi(dip); 7557 7558 /* skip leaf nodes and nodes not fully attached */ 7559 if (!i_ddi_devi_attached(dip) || is_leaf_node(dip)) { 7560 ndi_rele_devi(dip); 7561 dip = ddi_get_next(dip); 7562 continue; 7563 } 7564 7565 mcd = kmem_alloc(sizeof (*mcd), KM_SLEEP); 7566 mcd->mtc_dip = dip; 7567 mcd->mtc_hdl = hdl; 7568 mcd->mtc_major = major; 7569 mcd->mtc_flags = hdl->mtc_flags; 7570 7571 mutex_enter(&hdl->mtc_lock); 7572 hdl->mtc_thr_count++; 7573 mutex_exit(&hdl->mtc_lock); 7574 7575 /* 7576 * Add to end of list to process after UNLOCK_DEV_OPS to avoid 7577 * locking differences depending on value of mtc_off. 7578 */ 7579 mcd->mtc_next = NULL; 7580 if (mcd_head == NULL) 7581 mcd_head = mcd; 7582 else 7583 mcd_tail->mtc_next = mcd; 7584 mcd_tail = mcd; 7585 7586 dip = ddi_get_next(dip); 7587 } 7588 UNLOCK_DEV_OPS(&dnp->dn_lock); 7589 7590 /* go through the list of held children */ 7591 for (mcd = mcd_head; mcd; mcd = mcd_head) { 7592 mcd_head = mcd->mtc_next; 7593 if (mtc_off || (mcd->mtc_flags & NDI_MTC_OFF)) 7594 mt_config_thread(mcd); 7595 else 7596 (void) thread_create(NULL, 0, mt_config_thread, mcd, 7597 0, &p0, TS_RUN, minclsyspri); 7598 } 7599 } 7600 7601 /* 7602 * Given the nodeid for a persistent (PROM or SID) node, return 7603 * the corresponding devinfo node 7604 * NOTE: This function will return NULL for .conf nodeids. 7605 */ 7606 dev_info_t * 7607 e_ddi_nodeid_to_dip(pnode_t nodeid) 7608 { 7609 dev_info_t *dip = NULL; 7610 struct devi_nodeid *prev, *elem; 7611 7612 mutex_enter(&devimap->dno_lock); 7613 7614 prev = NULL; 7615 for (elem = devimap->dno_head; elem; elem = elem->next) { 7616 if (elem->nodeid == nodeid) { 7617 ndi_hold_devi(elem->dip); 7618 dip = elem->dip; 7619 break; 7620 } 7621 prev = elem; 7622 } 7623 7624 /* 7625 * Move to head for faster lookup next time 7626 */ 7627 if (elem && prev) { 7628 prev->next = elem->next; 7629 elem->next = devimap->dno_head; 7630 devimap->dno_head = elem; 7631 } 7632 7633 mutex_exit(&devimap->dno_lock); 7634 return (dip); 7635 } 7636 7637 static void 7638 free_cache_task(void *arg) 7639 { 7640 ASSERT(arg == NULL); 7641 7642 mutex_enter(&di_cache.cache_lock); 7643 7644 /* 7645 * The cache can be invalidated without holding the lock 7646 * but it can be made valid again only while the lock is held. 7647 * So if the cache is invalid when the lock is held, it will 7648 * stay invalid until lock is released. 7649 */ 7650 if (!di_cache.cache_valid) 7651 i_ddi_di_cache_free(&di_cache); 7652 7653 mutex_exit(&di_cache.cache_lock); 7654 7655 if (di_cache_debug) 7656 cmn_err(CE_NOTE, "system_taskq: di_cache freed"); 7657 } 7658 7659 extern int modrootloaded; 7660 7661 void 7662 i_ddi_di_cache_free(struct di_cache *cache) 7663 { 7664 int error; 7665 extern int sys_shutdown; 7666 7667 ASSERT(mutex_owned(&cache->cache_lock)); 7668 7669 if (cache->cache_size) { 7670 ASSERT(cache->cache_size > 0); 7671 ASSERT(cache->cache_data); 7672 7673 kmem_free(cache->cache_data, cache->cache_size); 7674 cache->cache_data = NULL; 7675 cache->cache_size = 0; 7676 7677 if (di_cache_debug) 7678 cmn_err(CE_NOTE, "i_ddi_di_cache_free: freed cachemem"); 7679 } else { 7680 ASSERT(cache->cache_data == NULL); 7681 if (di_cache_debug) 7682 cmn_err(CE_NOTE, "i_ddi_di_cache_free: NULL cache"); 7683 } 7684 7685 if (!modrootloaded || rootvp == NULL || 7686 vn_is_readonly(rootvp) || sys_shutdown) { 7687 if (di_cache_debug) { 7688 cmn_err(CE_WARN, "/ not mounted/RDONLY. Skip unlink"); 7689 } 7690 return; 7691 } 7692 7693 error = vn_remove(DI_CACHE_FILE, UIO_SYSSPACE, RMFILE); 7694 if (di_cache_debug && error && error != ENOENT) { 7695 cmn_err(CE_WARN, "%s: unlink failed: %d", DI_CACHE_FILE, error); 7696 } else if (di_cache_debug && !error) { 7697 cmn_err(CE_NOTE, "i_ddi_di_cache_free: unlinked cache file"); 7698 } 7699 } 7700 7701 void 7702 i_ddi_di_cache_invalidate(int kmflag) 7703 { 7704 int cache_valid; 7705 7706 if (!modrootloaded || !i_ddi_io_initialized()) { 7707 if (di_cache_debug) 7708 cmn_err(CE_NOTE, "I/O not inited. Skipping invalidate"); 7709 return; 7710 } 7711 7712 /* Increment devtree generation number. */ 7713 atomic_inc_ulong(&devtree_gen); 7714 7715 /* Invalidate the in-core cache and dispatch free on valid->invalid */ 7716 cache_valid = atomic_swap_uint(&di_cache.cache_valid, 0); 7717 if (cache_valid) { 7718 (void) taskq_dispatch(system_taskq, free_cache_task, NULL, 7719 (kmflag == KM_SLEEP) ? TQ_SLEEP : TQ_NOSLEEP); 7720 } 7721 7722 if (di_cache_debug) { 7723 cmn_err(CE_NOTE, "invalidation with km_flag: %s", 7724 kmflag == KM_SLEEP ? "KM_SLEEP" : "KM_NOSLEEP"); 7725 } 7726 } 7727 7728 7729 static void 7730 i_bind_vhci_node(dev_info_t *dip) 7731 { 7732 DEVI(dip)->devi_major = ddi_name_to_major(ddi_node_name(dip)); 7733 i_ddi_set_node_state(dip, DS_BOUND); 7734 } 7735 7736 static char vhci_node_addr[2]; 7737 7738 static int 7739 i_init_vhci_node(dev_info_t *dip) 7740 { 7741 add_global_props(dip); 7742 DEVI(dip)->devi_ops = ndi_hold_driver(dip); 7743 if (DEVI(dip)->devi_ops == NULL) 7744 return (-1); 7745 7746 DEVI(dip)->devi_instance = e_ddi_assign_instance(dip); 7747 e_ddi_keep_instance(dip); 7748 vhci_node_addr[0] = '\0'; 7749 ddi_set_name_addr(dip, vhci_node_addr); 7750 i_ddi_set_node_state(dip, DS_INITIALIZED); 7751 return (0); 7752 } 7753 7754 static void 7755 i_link_vhci_node(dev_info_t *dip) 7756 { 7757 ASSERT(MUTEX_HELD(&global_vhci_lock)); 7758 7759 /* 7760 * scsi_vhci should be kept left most of the device tree. 7761 */ 7762 if (scsi_vhci_dip) { 7763 DEVI(dip)->devi_sibling = DEVI(scsi_vhci_dip)->devi_sibling; 7764 DEVI(scsi_vhci_dip)->devi_sibling = DEVI(dip); 7765 } else { 7766 DEVI(dip)->devi_sibling = DEVI(top_devinfo)->devi_child; 7767 DEVI(top_devinfo)->devi_child = DEVI(dip); 7768 } 7769 } 7770 7771 7772 /* 7773 * This a special routine to enumerate vhci node (child of rootnex 7774 * node) without holding the ndi_devi_enter() lock. The device node 7775 * is allocated, initialized and brought into DS_READY state before 7776 * inserting into the device tree. The VHCI node is handcrafted 7777 * here to bring the node to DS_READY, similar to rootnex node. 7778 * 7779 * The global_vhci_lock protects linking the node into the device 7780 * as same lock is held before linking/unlinking any direct child 7781 * of rootnex children. 7782 * 7783 * This routine is a workaround to handle a possible deadlock 7784 * that occurs while trying to enumerate node in a different sub-tree 7785 * during _init/_attach entry points. 7786 */ 7787 /*ARGSUSED*/ 7788 dev_info_t * 7789 ndi_devi_config_vhci(char *drvname, int flags) 7790 { 7791 struct devnames *dnp; 7792 dev_info_t *dip; 7793 major_t major = ddi_name_to_major(drvname); 7794 7795 if (major == -1) 7796 return (NULL); 7797 7798 /* Make sure we create the VHCI node only once */ 7799 dnp = &devnamesp[major]; 7800 LOCK_DEV_OPS(&dnp->dn_lock); 7801 if (dnp->dn_head) { 7802 dip = dnp->dn_head; 7803 UNLOCK_DEV_OPS(&dnp->dn_lock); 7804 return (dip); 7805 } 7806 UNLOCK_DEV_OPS(&dnp->dn_lock); 7807 7808 /* Allocate the VHCI node */ 7809 ndi_devi_alloc_sleep(top_devinfo, drvname, DEVI_SID_NODEID, &dip); 7810 ndi_hold_devi(dip); 7811 7812 /* Mark the node as VHCI */ 7813 DEVI(dip)->devi_node_attributes |= DDI_VHCI_NODE; 7814 7815 i_ddi_add_devimap(dip); 7816 i_bind_vhci_node(dip); 7817 if (i_init_vhci_node(dip) == -1) { 7818 ndi_rele_devi(dip); 7819 (void) ndi_devi_free(dip); 7820 return (NULL); 7821 } 7822 7823 mutex_enter(&(DEVI(dip)->devi_lock)); 7824 DEVI_SET_ATTACHING(dip); 7825 mutex_exit(&(DEVI(dip)->devi_lock)); 7826 7827 if (devi_attach(dip, DDI_ATTACH) != DDI_SUCCESS) { 7828 cmn_err(CE_CONT, "Could not attach %s driver", drvname); 7829 e_ddi_free_instance(dip, vhci_node_addr); 7830 ndi_rele_devi(dip); 7831 (void) ndi_devi_free(dip); 7832 return (NULL); 7833 } 7834 mutex_enter(&(DEVI(dip)->devi_lock)); 7835 DEVI_CLR_ATTACHING(dip); 7836 mutex_exit(&(DEVI(dip)->devi_lock)); 7837 7838 mutex_enter(&global_vhci_lock); 7839 i_link_vhci_node(dip); 7840 mutex_exit(&global_vhci_lock); 7841 i_ddi_set_node_state(dip, DS_READY); 7842 7843 LOCK_DEV_OPS(&dnp->dn_lock); 7844 dnp->dn_flags |= DN_DRIVER_HELD; 7845 dnp->dn_head = dip; 7846 UNLOCK_DEV_OPS(&dnp->dn_lock); 7847 7848 i_ndi_devi_report_status_change(dip, NULL); 7849 7850 return (dip); 7851 } 7852 7853 /* 7854 * ibt_hw_is_present() returns 0 when there is no IB hardware actively 7855 * running. This is primarily useful for modules like rpcmod which 7856 * needs a quick check to decide whether or not it should try to use 7857 * InfiniBand 7858 */ 7859 int ib_hw_status = 0; 7860 int 7861 ibt_hw_is_present() 7862 { 7863 return (ib_hw_status); 7864 } 7865 7866 /* 7867 * ASSERT that constraint flag is not set and then set the "retire attempt" 7868 * flag. 7869 */ 7870 int 7871 e_ddi_mark_retiring(dev_info_t *dip, void *arg) 7872 { 7873 char **cons_array = (char **)arg; 7874 char *path; 7875 int constraint; 7876 int i; 7877 7878 constraint = 0; 7879 if (cons_array) { 7880 path = kmem_alloc(MAXPATHLEN, KM_SLEEP); 7881 (void) ddi_pathname(dip, path); 7882 for (i = 0; cons_array[i] != NULL; i++) { 7883 if (strcmp(path, cons_array[i]) == 0) { 7884 constraint = 1; 7885 break; 7886 } 7887 } 7888 kmem_free(path, MAXPATHLEN); 7889 } 7890 7891 mutex_enter(&DEVI(dip)->devi_lock); 7892 ASSERT(!(DEVI(dip)->devi_flags & DEVI_R_CONSTRAINT)); 7893 DEVI(dip)->devi_flags |= DEVI_RETIRING; 7894 if (constraint) 7895 DEVI(dip)->devi_flags |= DEVI_R_CONSTRAINT; 7896 mutex_exit(&DEVI(dip)->devi_lock); 7897 7898 RIO_VERBOSE((CE_NOTE, "marked dip as undergoing retire process dip=%p", 7899 (void *)dip)); 7900 7901 if (constraint) 7902 RIO_DEBUG((CE_NOTE, "marked dip as constrained, dip=%p", 7903 (void *)dip)); 7904 7905 if (MDI_PHCI(dip)) 7906 mdi_phci_mark_retiring(dip, cons_array); 7907 7908 return (DDI_WALK_CONTINUE); 7909 } 7910 7911 static void 7912 free_array(char **cons_array) 7913 { 7914 int i; 7915 7916 if (cons_array == NULL) 7917 return; 7918 7919 for (i = 0; cons_array[i] != NULL; i++) { 7920 kmem_free(cons_array[i], strlen(cons_array[i]) + 1); 7921 } 7922 kmem_free(cons_array, (i+1) * sizeof (char *)); 7923 } 7924 7925 /* 7926 * Walk *every* node in subtree and check if it blocks, allows or has no 7927 * comment on a proposed retire. 7928 */ 7929 int 7930 e_ddi_retire_notify(dev_info_t *dip, void *arg) 7931 { 7932 int *constraint = (int *)arg; 7933 7934 RIO_DEBUG((CE_NOTE, "retire notify: dip = %p", (void *)dip)); 7935 7936 (void) e_ddi_offline_notify(dip); 7937 7938 mutex_enter(&(DEVI(dip)->devi_lock)); 7939 if (!(DEVI(dip)->devi_flags & DEVI_RETIRING)) { 7940 RIO_DEBUG((CE_WARN, "retire notify: dip in retire " 7941 "subtree is not marked: dip = %p", (void *)dip)); 7942 *constraint = 0; 7943 } else if (DEVI(dip)->devi_flags & DEVI_R_BLOCKED) { 7944 ASSERT(!(DEVI(dip)->devi_flags & DEVI_R_CONSTRAINT)); 7945 RIO_DEBUG((CE_NOTE, "retire notify: BLOCKED: dip = %p", 7946 (void *)dip)); 7947 *constraint = 0; 7948 } else if (!(DEVI(dip)->devi_flags & DEVI_R_CONSTRAINT)) { 7949 RIO_DEBUG((CE_NOTE, "retire notify: NO CONSTRAINT: " 7950 "dip = %p", (void *)dip)); 7951 *constraint = 0; 7952 } else { 7953 RIO_DEBUG((CE_NOTE, "retire notify: CONSTRAINT set: " 7954 "dip = %p", (void *)dip)); 7955 } 7956 mutex_exit(&DEVI(dip)->devi_lock); 7957 7958 if (MDI_PHCI(dip)) 7959 mdi_phci_retire_notify(dip, constraint); 7960 7961 return (DDI_WALK_CONTINUE); 7962 } 7963 7964 int 7965 e_ddi_retire_finalize(dev_info_t *dip, void *arg) 7966 { 7967 int constraint = *(int *)arg; 7968 int finalize; 7969 int phci_only; 7970 7971 ASSERT(DEVI_BUSY_OWNED(ddi_get_parent(dip))); 7972 7973 mutex_enter(&DEVI(dip)->devi_lock); 7974 if (!(DEVI(dip)->devi_flags & DEVI_RETIRING)) { 7975 RIO_DEBUG((CE_WARN, 7976 "retire: unmarked dip(%p) in retire subtree", 7977 (void *)dip)); 7978 ASSERT(!(DEVI(dip)->devi_flags & DEVI_RETIRED)); 7979 ASSERT(!(DEVI(dip)->devi_flags & DEVI_R_CONSTRAINT)); 7980 ASSERT(!(DEVI(dip)->devi_flags & DEVI_R_BLOCKED)); 7981 mutex_exit(&DEVI(dip)->devi_lock); 7982 return (DDI_WALK_CONTINUE); 7983 } 7984 7985 /* 7986 * retire the device if constraints have been applied 7987 * or if the device is not in use 7988 */ 7989 finalize = 0; 7990 if (constraint) { 7991 ASSERT(DEVI(dip)->devi_flags & DEVI_R_CONSTRAINT); 7992 ASSERT(!(DEVI(dip)->devi_flags & DEVI_R_BLOCKED)); 7993 DEVI(dip)->devi_flags &= ~DEVI_R_CONSTRAINT; 7994 DEVI(dip)->devi_flags &= ~DEVI_RETIRING; 7995 DEVI(dip)->devi_flags |= DEVI_RETIRED; 7996 mutex_exit(&DEVI(dip)->devi_lock); 7997 (void) spec_fence_snode(dip, NULL); 7998 RIO_DEBUG((CE_NOTE, "Fenced off: dip = %p", (void *)dip)); 7999 e_ddi_offline_finalize(dip, DDI_SUCCESS); 8000 } else { 8001 if (DEVI(dip)->devi_flags & DEVI_R_BLOCKED) { 8002 ASSERT(!(DEVI(dip)->devi_flags & DEVI_R_CONSTRAINT)); 8003 DEVI(dip)->devi_flags &= ~DEVI_R_BLOCKED; 8004 DEVI(dip)->devi_flags &= ~DEVI_RETIRING; 8005 /* we have already finalized during notify */ 8006 } else if (DEVI(dip)->devi_flags & DEVI_R_CONSTRAINT) { 8007 DEVI(dip)->devi_flags &= ~DEVI_R_CONSTRAINT; 8008 DEVI(dip)->devi_flags &= ~DEVI_RETIRING; 8009 finalize = 1; 8010 } else { 8011 DEVI(dip)->devi_flags &= ~DEVI_RETIRING; 8012 /* 8013 * even if no contracts, need to call finalize 8014 * to clear the contract barrier on the dip 8015 */ 8016 finalize = 1; 8017 } 8018 mutex_exit(&DEVI(dip)->devi_lock); 8019 RIO_DEBUG((CE_NOTE, "finalize: NOT retired: dip = %p", 8020 (void *)dip)); 8021 if (finalize) 8022 e_ddi_offline_finalize(dip, DDI_FAILURE); 8023 } 8024 8025 /* 8026 * phci_only variable indicates no client checking, just 8027 * offline the PHCI. We set that to 0 to enable client 8028 * checking 8029 */ 8030 phci_only = 0; 8031 if (MDI_PHCI(dip)) 8032 mdi_phci_retire_finalize(dip, phci_only); 8033 8034 return (DDI_WALK_CONTINUE); 8035 } 8036 8037 /* 8038 * Returns 8039 * DDI_SUCCESS if constraints allow retire 8040 * DDI_FAILURE if constraints don't allow retire. 8041 * cons_array is a NULL terminated array of node paths for 8042 * which constraints have already been applied. 8043 */ 8044 int 8045 e_ddi_retire_device(char *path, char **cons_array) 8046 { 8047 dev_info_t *dip; 8048 dev_info_t *pdip; 8049 int circ; 8050 int circ2; 8051 int constraint; 8052 char *devnm; 8053 8054 /* 8055 * First, lookup the device 8056 */ 8057 dip = e_ddi_hold_devi_by_path(path, 0); 8058 if (dip == NULL) { 8059 /* 8060 * device does not exist. This device cannot be 8061 * a critical device since it is not in use. Thus 8062 * this device is always retireable. Return DDI_SUCCESS 8063 * to indicate this. If this device is ever 8064 * instantiated, I/O framework will consult the 8065 * the persistent retire store, mark it as 8066 * retired and fence it off. 8067 */ 8068 RIO_DEBUG((CE_NOTE, "Retire device: device doesn't exist." 8069 " NOP. Just returning SUCCESS. path=%s", path)); 8070 free_array(cons_array); 8071 return (DDI_SUCCESS); 8072 } 8073 8074 RIO_DEBUG((CE_NOTE, "Retire device: found dip = %p.", (void *)dip)); 8075 8076 pdip = ddi_get_parent(dip); 8077 ndi_hold_devi(pdip); 8078 8079 /* 8080 * Run devfs_clean() in case dip has no constraints and is 8081 * not in use, so is retireable but there are dv_nodes holding 8082 * ref-count on the dip. Note that devfs_clean() always returns 8083 * success. 8084 */ 8085 devnm = kmem_alloc(MAXNAMELEN + 1, KM_SLEEP); 8086 (void) ddi_deviname(dip, devnm); 8087 (void) devfs_clean(pdip, devnm + 1, DV_CLEAN_FORCE); 8088 kmem_free(devnm, MAXNAMELEN + 1); 8089 8090 ndi_devi_enter(pdip, &circ); 8091 8092 /* release hold from e_ddi_hold_devi_by_path */ 8093 ndi_rele_devi(dip); 8094 8095 /* 8096 * If it cannot make a determination, is_leaf_node() assumes 8097 * dip is a nexus. 8098 */ 8099 (void) e_ddi_mark_retiring(dip, cons_array); 8100 if (!is_leaf_node(dip)) { 8101 ndi_devi_enter(dip, &circ2); 8102 ddi_walk_devs(ddi_get_child(dip), e_ddi_mark_retiring, 8103 cons_array); 8104 ndi_devi_exit(dip, circ2); 8105 } 8106 free_array(cons_array); 8107 8108 /* 8109 * apply constraints 8110 */ 8111 RIO_DEBUG((CE_NOTE, "retire: subtree retire notify: path = %s", path)); 8112 8113 constraint = 1; /* assume constraints allow retire */ 8114 (void) e_ddi_retire_notify(dip, &constraint); 8115 if (!is_leaf_node(dip)) { 8116 ndi_devi_enter(dip, &circ2); 8117 ddi_walk_devs(ddi_get_child(dip), e_ddi_retire_notify, 8118 &constraint); 8119 ndi_devi_exit(dip, circ2); 8120 } 8121 8122 /* 8123 * Now finalize the retire 8124 */ 8125 (void) e_ddi_retire_finalize(dip, &constraint); 8126 if (!is_leaf_node(dip)) { 8127 ndi_devi_enter(dip, &circ2); 8128 ddi_walk_devs(ddi_get_child(dip), e_ddi_retire_finalize, 8129 &constraint); 8130 ndi_devi_exit(dip, circ2); 8131 } 8132 8133 if (!constraint) { 8134 RIO_DEBUG((CE_WARN, "retire failed: path = %s", path)); 8135 } else { 8136 RIO_DEBUG((CE_NOTE, "retire succeeded: path = %s", path)); 8137 } 8138 8139 ndi_devi_exit(pdip, circ); 8140 ndi_rele_devi(pdip); 8141 return (constraint ? DDI_SUCCESS : DDI_FAILURE); 8142 } 8143 8144 static int 8145 unmark_and_unfence(dev_info_t *dip, void *arg) 8146 { 8147 char *path = (char *)arg; 8148 8149 ASSERT(path); 8150 8151 (void) ddi_pathname(dip, path); 8152 8153 mutex_enter(&DEVI(dip)->devi_lock); 8154 DEVI(dip)->devi_flags &= ~DEVI_RETIRED; 8155 DEVI_SET_DEVICE_ONLINE(dip); 8156 mutex_exit(&DEVI(dip)->devi_lock); 8157 8158 RIO_VERBOSE((CE_NOTE, "Cleared RETIRED flag: dip=%p, path=%s", 8159 (void *)dip, path)); 8160 8161 (void) spec_unfence_snode(dip); 8162 RIO_DEBUG((CE_NOTE, "Unfenced device: %s", path)); 8163 8164 if (MDI_PHCI(dip)) 8165 mdi_phci_unretire(dip); 8166 8167 return (DDI_WALK_CONTINUE); 8168 } 8169 8170 struct find_dip { 8171 char *fd_buf; 8172 char *fd_path; 8173 dev_info_t *fd_dip; 8174 }; 8175 8176 static int 8177 find_dip_fcn(dev_info_t *dip, void *arg) 8178 { 8179 struct find_dip *findp = (struct find_dip *)arg; 8180 8181 (void) ddi_pathname(dip, findp->fd_buf); 8182 8183 if (strcmp(findp->fd_path, findp->fd_buf) != 0) 8184 return (DDI_WALK_CONTINUE); 8185 8186 ndi_hold_devi(dip); 8187 findp->fd_dip = dip; 8188 8189 return (DDI_WALK_TERMINATE); 8190 } 8191 8192 int 8193 e_ddi_unretire_device(char *path) 8194 { 8195 int circ; 8196 int circ2; 8197 char *path2; 8198 dev_info_t *pdip; 8199 dev_info_t *dip; 8200 struct find_dip find_dip; 8201 8202 ASSERT(path); 8203 ASSERT(*path == '/'); 8204 8205 if (strcmp(path, "/") == 0) { 8206 cmn_err(CE_WARN, "Root node cannot be retired. Skipping " 8207 "device unretire: %s", path); 8208 return (0); 8209 } 8210 8211 /* 8212 * We can't lookup the dip (corresponding to path) via 8213 * e_ddi_hold_devi_by_path() because the dip may be offline 8214 * and may not attach. Use ddi_walk_devs() instead; 8215 */ 8216 find_dip.fd_buf = kmem_alloc(MAXPATHLEN, KM_SLEEP); 8217 find_dip.fd_path = path; 8218 find_dip.fd_dip = NULL; 8219 8220 pdip = ddi_root_node(); 8221 8222 ndi_devi_enter(pdip, &circ); 8223 ddi_walk_devs(ddi_get_child(pdip), find_dip_fcn, &find_dip); 8224 ndi_devi_exit(pdip, circ); 8225 8226 kmem_free(find_dip.fd_buf, MAXPATHLEN); 8227 8228 if (find_dip.fd_dip == NULL) { 8229 cmn_err(CE_WARN, "Device not found in device tree. Skipping " 8230 "device unretire: %s", path); 8231 return (0); 8232 } 8233 8234 dip = find_dip.fd_dip; 8235 8236 pdip = ddi_get_parent(dip); 8237 8238 ndi_hold_devi(pdip); 8239 8240 ndi_devi_enter(pdip, &circ); 8241 8242 path2 = kmem_alloc(MAXPATHLEN, KM_SLEEP); 8243 8244 (void) unmark_and_unfence(dip, path2); 8245 if (!is_leaf_node(dip)) { 8246 ndi_devi_enter(dip, &circ2); 8247 ddi_walk_devs(ddi_get_child(dip), unmark_and_unfence, path2); 8248 ndi_devi_exit(dip, circ2); 8249 } 8250 8251 kmem_free(path2, MAXPATHLEN); 8252 8253 /* release hold from find_dip_fcn() */ 8254 ndi_rele_devi(dip); 8255 8256 ndi_devi_exit(pdip, circ); 8257 8258 ndi_rele_devi(pdip); 8259 8260 return (0); 8261 } 8262 8263 /* 8264 * Called before attach on a dip that has been retired. 8265 */ 8266 static int 8267 mark_and_fence(dev_info_t *dip, void *arg) 8268 { 8269 char *fencepath = (char *)arg; 8270 8271 /* 8272 * We have already decided to retire this device. The various 8273 * constraint checking should not be set. 8274 * NOTE that the retire flag may already be set due to 8275 * fenced -> detach -> fenced transitions. 8276 */ 8277 mutex_enter(&DEVI(dip)->devi_lock); 8278 ASSERT(!(DEVI(dip)->devi_flags & DEVI_R_CONSTRAINT)); 8279 ASSERT(!(DEVI(dip)->devi_flags & DEVI_R_BLOCKED)); 8280 ASSERT(!(DEVI(dip)->devi_flags & DEVI_RETIRING)); 8281 DEVI(dip)->devi_flags |= DEVI_RETIRED; 8282 mutex_exit(&DEVI(dip)->devi_lock); 8283 RIO_VERBOSE((CE_NOTE, "marked as RETIRED dip=%p", (void *)dip)); 8284 8285 if (fencepath) { 8286 (void) spec_fence_snode(dip, NULL); 8287 RIO_DEBUG((CE_NOTE, "Fenced: %s", 8288 ddi_pathname(dip, fencepath))); 8289 } 8290 8291 return (DDI_WALK_CONTINUE); 8292 } 8293 8294 /* 8295 * Checks the retire database and: 8296 * 8297 * - if device is present in the retire database, marks the device retired 8298 * and fences it off. 8299 * - if device is not in retire database, allows the device to attach normally 8300 * 8301 * To be called only by framework attach code on first attach attempt. 8302 * 8303 */ 8304 static void 8305 i_ddi_check_retire(dev_info_t *dip) 8306 { 8307 char *path; 8308 dev_info_t *pdip; 8309 int circ; 8310 int phci_only; 8311 8312 pdip = ddi_get_parent(dip); 8313 8314 /* 8315 * Root dip is treated special and doesn't take this code path. 8316 * Also root can never be retired. 8317 */ 8318 ASSERT(pdip); 8319 ASSERT(DEVI_BUSY_OWNED(pdip)); 8320 ASSERT(i_ddi_node_state(dip) < DS_ATTACHED); 8321 8322 path = kmem_alloc(MAXPATHLEN, KM_SLEEP); 8323 8324 (void) ddi_pathname(dip, path); 8325 8326 RIO_VERBOSE((CE_NOTE, "Checking if dip should attach: dip=%p, path=%s", 8327 (void *)dip, path)); 8328 8329 /* 8330 * Check if this device is in the "retired" store i.e. should 8331 * be retired. If not, we have nothing to do. 8332 */ 8333 if (e_ddi_device_retired(path) == 0) { 8334 RIO_VERBOSE((CE_NOTE, "device is NOT retired: path=%s", path)); 8335 kmem_free(path, MAXPATHLEN); 8336 return; 8337 } 8338 8339 RIO_DEBUG((CE_NOTE, "attach: device is retired: path=%s", path)); 8340 8341 /* 8342 * Mark dips and fence off snodes (if any) 8343 */ 8344 RIO_DEBUG((CE_NOTE, "attach: Mark and fence subtree: path=%s", path)); 8345 (void) mark_and_fence(dip, path); 8346 if (!is_leaf_node(dip)) { 8347 ndi_devi_enter(dip, &circ); 8348 ddi_walk_devs(ddi_get_child(dip), mark_and_fence, path); 8349 ndi_devi_exit(dip, circ); 8350 } 8351 8352 kmem_free(path, MAXPATHLEN); 8353 8354 /* 8355 * We don't want to check the client. We just want to 8356 * offline the PHCI 8357 */ 8358 phci_only = 1; 8359 if (MDI_PHCI(dip)) 8360 mdi_phci_retire_finalize(dip, phci_only); 8361 } 8362