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