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