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