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