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