Print this page
6659 nvlist_free(NULL) is a no-op
Split |
Close |
Expand all |
Collapse all |
--- old/usr/src/uts/common/os/devid_cache.c
+++ new/usr/src/uts/common/os/devid_cache.c
1 1 /*
2 2 * CDDL HEADER START
3 3 *
4 4 * The contents of this file are subject to the terms of the
5 5 * Common Development and Distribution License (the "License").
6 6 * You may not use this file except in compliance with the License.
7 7 *
8 8 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
9 9 * or http://www.opensolaris.org/os/licensing.
10 10 * See the License for the specific language governing permissions
11 11 * and limitations under the License.
12 12 *
13 13 * When distributing Covered Code, include this CDDL HEADER in each
14 14 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
15 15 * If applicable, add the following below this CDDL HEADER, with the
16 16 * fields enclosed by brackets "[]" replaced with your own identifying
17 17 * information: Portions Copyright [yyyy] [name of copyright owner]
18 18 *
19 19 * CDDL HEADER END
20 20 */
21 21 /*
22 22 * Copyright (c) 2006, 2010, Oracle and/or its affiliates. All rights reserved.
23 23 */
24 24
25 25 #include <sys/note.h>
26 26 #include <sys/t_lock.h>
27 27 #include <sys/cmn_err.h>
28 28 #include <sys/instance.h>
29 29 #include <sys/conf.h>
30 30 #include <sys/stat.h>
31 31 #include <sys/ddi.h>
32 32 #include <sys/hwconf.h>
33 33 #include <sys/sunddi.h>
34 34 #include <sys/sunndi.h>
35 35 #include <sys/sunmdi.h>
36 36 #include <sys/ddi_impldefs.h>
37 37 #include <sys/ndi_impldefs.h>
38 38 #include <sys/kobj.h>
39 39 #include <sys/devcache.h>
40 40 #include <sys/devid_cache.h>
41 41 #include <sys/sysmacros.h>
42 42
43 43 /*
44 44 * Discovery refers to the heroic effort made to discover a device which
45 45 * cannot be accessed at the physical path where it once resided. Discovery
46 46 * involves walking the entire device tree attaching all possible disk
47 47 * instances, to search for the device referenced by a devid. Obviously,
48 48 * full device discovery is something to be avoided where possible.
49 49 * Note that simply invoking devfsadm(1M) is equivalent to running full
50 50 * discovery at the devid cache level.
51 51 *
52 52 * Reasons why a disk may not be accessible:
53 53 * disk powered off
54 54 * disk removed or cable disconnected
55 55 * disk or adapter broken
56 56 *
57 57 * Note that discovery is not needed and cannot succeed in any of these
58 58 * cases.
59 59 *
60 60 * When discovery may succeed:
61 61 * Discovery will result in success when a device has been moved
62 62 * to a different address. Note that it's recommended that
63 63 * devfsadm(1M) be invoked (no arguments required) whenever a system's
64 64 * h/w configuration has been updated. Alternatively, a
65 65 * reconfiguration boot can be used to accomplish the same result.
66 66 *
67 67 * Note that discovery is not necessary to be able to correct an access
68 68 * failure for a device which was powered off. Assuming the cache has an
69 69 * entry for such a device, simply powering it on should permit the system
70 70 * to access it. If problems persist after powering it on, invoke
71 71 * devfsadm(1M).
72 72 *
73 73 * Discovery prior to mounting root is only of interest when booting
74 74 * from a filesystem which accesses devices by device id, which of
75 75 * not all do.
76 76 *
77 77 * Tunables
78 78 *
79 79 * devid_discovery_boot (default 1)
80 80 * Number of times discovery will be attempted prior to mounting root.
81 81 * Must be done at least once to recover from corrupted or missing
82 82 * devid cache backing store. Probably there's no reason to ever
83 83 * set this to greater than one as a missing device will remain
84 84 * unavailable no matter how often the system searches for it.
85 85 *
86 86 * devid_discovery_postboot (default 1)
87 87 * Number of times discovery will be attempted after mounting root.
88 88 * This must be performed at least once to discover any devices
89 89 * needed after root is mounted which may have been powered
90 90 * off and moved before booting.
91 91 * Setting this to a larger positive number will introduce
92 92 * some inconsistency in system operation. Searching for a device
93 93 * will take an indeterminate amount of time, sometimes slower,
94 94 * sometimes faster. In addition, the system will sometimes
95 95 * discover a newly powered on device, sometimes it won't.
96 96 * Use of this option is not therefore recommended.
97 97 *
98 98 * devid_discovery_postboot_always (default 0)
99 99 * Set to 1, the system will always attempt full discovery.
100 100 *
101 101 * devid_discovery_secs (default 0)
102 102 * Set to a positive value, the system will attempt full discovery
103 103 * but with a minimum delay between attempts. A device search
104 104 * within the period of time specified will result in failure.
105 105 *
106 106 * devid_cache_read_disable (default 0)
107 107 * Set to 1 to disable reading /etc/devices/devid_cache.
108 108 * Devid cache will continue to operate normally but
109 109 * at least one discovery attempt will be required.
110 110 *
111 111 * devid_cache_write_disable (default 0)
112 112 * Set to 1 to disable updates to /etc/devices/devid_cache.
113 113 * Any updates to the devid cache will not be preserved across a reboot.
114 114 *
115 115 * devid_report_error (default 0)
116 116 * Set to 1 to enable some error messages related to devid
117 117 * cache failures.
118 118 *
119 119 * The devid is packed in the cache file as a byte array. For
120 120 * portability, this could be done in the encoded string format.
121 121 */
122 122
123 123
124 124 int devid_discovery_boot = 1;
125 125 int devid_discovery_postboot = 1;
126 126 int devid_discovery_postboot_always = 0;
127 127 int devid_discovery_secs = 0;
128 128
129 129 int devid_cache_read_disable = 0;
130 130 int devid_cache_write_disable = 0;
131 131
132 132 int devid_report_error = 0;
133 133
134 134
135 135 /*
136 136 * State to manage discovery of devices providing a devid
137 137 */
138 138 static int devid_discovery_busy = 0;
139 139 static kmutex_t devid_discovery_mutex;
140 140 static kcondvar_t devid_discovery_cv;
141 141 static clock_t devid_last_discovery = 0;
142 142
143 143
144 144 #ifdef DEBUG
145 145 int nvp_devid_debug = 0;
146 146 int devid_debug = 0;
147 147 int devid_log_registers = 0;
148 148 int devid_log_finds = 0;
149 149 int devid_log_lookups = 0;
150 150 int devid_log_discovery = 0;
151 151 int devid_log_matches = 0;
152 152 int devid_log_paths = 0;
153 153 int devid_log_failures = 0;
154 154 int devid_log_hold = 0;
155 155 int devid_log_unregisters = 0;
156 156 int devid_log_removes = 0;
157 157 int devid_register_debug = 0;
158 158 int devid_log_stale = 0;
159 159 int devid_log_detaches = 0;
160 160 #endif /* DEBUG */
161 161
162 162 /*
163 163 * devid cache file registration for cache reads and updates
164 164 */
165 165 static nvf_ops_t devid_cache_ops = {
166 166 "/etc/devices/devid_cache", /* path to cache */
167 167 devid_cache_unpack_nvlist, /* read: nvlist to nvp */
168 168 devid_cache_pack_list, /* write: nvp to nvlist */
169 169 devid_list_free, /* free data list */
170 170 NULL /* write complete callback */
171 171 };
172 172
173 173 /*
174 174 * handle to registered devid cache handlers
175 175 */
176 176 nvf_handle_t dcfd_handle;
177 177
178 178
179 179 /*
180 180 * Initialize devid cache file management
181 181 */
182 182 void
183 183 devid_cache_init(void)
184 184 {
185 185 dcfd_handle = nvf_register_file(&devid_cache_ops);
186 186 ASSERT(dcfd_handle);
187 187
188 188 list_create(nvf_list(dcfd_handle), sizeof (nvp_devid_t),
189 189 offsetof(nvp_devid_t, nvp_link));
190 190
191 191 mutex_init(&devid_discovery_mutex, NULL, MUTEX_DEFAULT, NULL);
192 192 cv_init(&devid_discovery_cv, NULL, CV_DRIVER, NULL);
193 193 }
194 194
195 195 /*
196 196 * Read and initialize the devid cache from the persistent store
197 197 */
198 198 void
199 199 devid_cache_read(void)
200 200 {
201 201 if (!devid_cache_read_disable) {
202 202 rw_enter(nvf_lock(dcfd_handle), RW_WRITER);
203 203 ASSERT(list_head(nvf_list(dcfd_handle)) == NULL);
204 204 (void) nvf_read_file(dcfd_handle);
205 205 rw_exit(nvf_lock(dcfd_handle));
206 206 }
207 207 }
208 208
209 209 static void
210 210 devid_nvp_free(nvp_devid_t *dp)
211 211 {
212 212 if (dp->nvp_devpath)
213 213 kmem_free(dp->nvp_devpath, strlen(dp->nvp_devpath)+1);
214 214 if (dp->nvp_devid)
215 215 kmem_free(dp->nvp_devid, ddi_devid_sizeof(dp->nvp_devid));
216 216
217 217 kmem_free(dp, sizeof (nvp_devid_t));
218 218 }
219 219
220 220 static void
221 221 devid_list_free(nvf_handle_t fd)
222 222 {
223 223 list_t *listp;
224 224 nvp_devid_t *np;
225 225
226 226 ASSERT(RW_WRITE_HELD(nvf_lock(dcfd_handle)));
227 227
228 228 listp = nvf_list(fd);
229 229 while (np = list_head(listp)) {
230 230 list_remove(listp, np);
231 231 devid_nvp_free(np);
232 232 }
233 233 }
234 234
235 235 /*
236 236 * Free an nvp element in a list
237 237 */
238 238 static void
239 239 devid_nvp_unlink_and_free(nvf_handle_t fd, nvp_devid_t *np)
240 240 {
241 241 list_remove(nvf_list(fd), np);
242 242 devid_nvp_free(np);
243 243 }
244 244
245 245 /*
246 246 * Unpack a device path/nvlist pair to the list of devid cache elements.
247 247 * Used to parse the nvlist format when reading
248 248 * /etc/devices/devid_cache
249 249 */
250 250 static int
251 251 devid_cache_unpack_nvlist(nvf_handle_t fd, nvlist_t *nvl, char *name)
252 252 {
253 253 nvp_devid_t *np;
254 254 ddi_devid_t devidp;
255 255 int rval;
256 256 uint_t n;
257 257
258 258 NVP_DEVID_DEBUG_PATH((name));
259 259 ASSERT(RW_WRITE_HELD(nvf_lock(dcfd_handle)));
260 260
261 261 /*
262 262 * check path for a devid
263 263 */
264 264 rval = nvlist_lookup_byte_array(nvl,
265 265 DP_DEVID_ID, (uchar_t **)&devidp, &n);
266 266 if (rval == 0) {
267 267 if (ddi_devid_valid(devidp) == DDI_SUCCESS) {
268 268 ASSERT(n == ddi_devid_sizeof(devidp));
269 269 np = kmem_zalloc(sizeof (nvp_devid_t), KM_SLEEP);
270 270 np->nvp_devpath = i_ddi_strdup(name, KM_SLEEP);
271 271 np->nvp_devid = kmem_alloc(n, KM_SLEEP);
272 272 (void) bcopy(devidp, np->nvp_devid, n);
273 273 list_insert_tail(nvf_list(fd), np);
274 274 NVP_DEVID_DEBUG_DEVID((np->nvp_devid));
275 275 } else {
276 276 DEVIDERR((CE_CONT,
277 277 "%s: invalid devid\n", name));
278 278 }
279 279 } else {
280 280 DEVIDERR((CE_CONT,
281 281 "%s: devid not available\n", name));
282 282 }
283 283
284 284 return (0);
285 285 }
286 286
287 287 /*
288 288 * Pack the list of devid cache elements into a single nvlist
289 289 * Used when writing the nvlist file.
290 290 */
291 291 static int
292 292 devid_cache_pack_list(nvf_handle_t fd, nvlist_t **ret_nvl)
293 293 {
294 294 nvlist_t *nvl, *sub_nvl;
295 295 nvp_devid_t *np;
296 296 int rval;
297 297 list_t *listp;
298 298
299 299 ASSERT(RW_WRITE_HELD(nvf_lock(dcfd_handle)));
300 300
301 301 rval = nvlist_alloc(&nvl, NV_UNIQUE_NAME, KM_SLEEP);
302 302 if (rval != 0) {
303 303 nvf_error("%s: nvlist alloc error %d\n",
304 304 nvf_cache_name(fd), rval);
305 305 return (DDI_FAILURE);
306 306 }
307 307
308 308 listp = nvf_list(fd);
309 309 for (np = list_head(listp); np; np = list_next(listp, np)) {
310 310 if (np->nvp_devid == NULL)
311 311 continue;
312 312 NVP_DEVID_DEBUG_PATH(np->nvp_devpath);
313 313 rval = nvlist_alloc(&sub_nvl, NV_UNIQUE_NAME, KM_SLEEP);
314 314 if (rval != 0) {
315 315 nvf_error("%s: nvlist alloc error %d\n",
316 316 nvf_cache_name(fd), rval);
317 317 sub_nvl = NULL;
318 318 goto err;
319 319 }
320 320
321 321 rval = nvlist_add_byte_array(sub_nvl, DP_DEVID_ID,
322 322 (uchar_t *)np->nvp_devid,
323 323 ddi_devid_sizeof(np->nvp_devid));
324 324 if (rval == 0) {
325 325 NVP_DEVID_DEBUG_DEVID(np->nvp_devid);
326 326 } else {
327 327 nvf_error(
328 328 "%s: nvlist add error %d (devid)\n",
329 329 nvf_cache_name(fd), rval);
330 330 goto err;
331 331 }
332 332
333 333 rval = nvlist_add_nvlist(nvl, np->nvp_devpath, sub_nvl);
334 334 if (rval != 0) {
335 335 nvf_error("%s: nvlist add error %d (sublist)\n",
↓ open down ↓ |
335 lines elided |
↑ open up ↑ |
336 336 nvf_cache_name(fd), rval);
337 337 goto err;
338 338 }
339 339 nvlist_free(sub_nvl);
340 340 }
341 341
342 342 *ret_nvl = nvl;
343 343 return (DDI_SUCCESS);
344 344
345 345 err:
346 - if (sub_nvl)
347 - nvlist_free(sub_nvl);
346 + nvlist_free(sub_nvl);
348 347 nvlist_free(nvl);
349 348 *ret_nvl = NULL;
350 349 return (DDI_FAILURE);
351 350 }
352 351
353 352 static int
354 353 e_devid_do_discovery(void)
355 354 {
356 355 ASSERT(mutex_owned(&devid_discovery_mutex));
357 356
358 357 if (i_ddi_io_initialized() == 0) {
359 358 if (devid_discovery_boot > 0) {
360 359 devid_discovery_boot--;
361 360 return (1);
362 361 }
363 362 } else {
364 363 if (devid_discovery_postboot_always > 0)
365 364 return (1);
366 365 if (devid_discovery_postboot > 0) {
367 366 devid_discovery_postboot--;
368 367 return (1);
369 368 }
370 369 if (devid_discovery_secs > 0) {
371 370 if ((ddi_get_lbolt() - devid_last_discovery) >
372 371 drv_usectohz(devid_discovery_secs * MICROSEC)) {
373 372 return (1);
374 373 }
375 374 }
376 375 }
377 376
378 377 DEVID_LOG_DISC((CE_CONT, "devid_discovery: no discovery\n"));
379 378 return (0);
380 379 }
381 380
382 381 static void
383 382 e_ddi_devid_hold_by_major(major_t major)
384 383 {
385 384 DEVID_LOG_DISC((CE_CONT,
386 385 "devid_discovery: ddi_hold_installed_driver %d\n", major));
387 386
388 387 if (ddi_hold_installed_driver(major) == NULL)
389 388 return;
390 389
391 390 ddi_rele_driver(major);
392 391 }
393 392
394 393 /* legacy support - see below */
395 394 static char *e_ddi_devid_hold_driver_list[] = { "sd", "ssd" };
396 395
397 396 #define N_DRIVERS_TO_HOLD \
398 397 (sizeof (e_ddi_devid_hold_driver_list) / sizeof (char *))
399 398
400 399 static void
401 400 e_ddi_devid_hold_installed_driver(ddi_devid_t devid)
402 401 {
403 402 impl_devid_t *id = (impl_devid_t *)devid;
404 403 major_t major, hint_major;
405 404 char hint[DEVID_HINT_SIZE + 1];
406 405 struct devnames *dnp;
407 406 char **drvp;
408 407 int i;
409 408
410 409 /* Count non-null bytes */
411 410 for (i = 0; i < DEVID_HINT_SIZE; i++)
412 411 if (id->did_driver[i] == '\0')
413 412 break;
414 413
415 414 /* Make a copy of the driver hint */
416 415 bcopy(id->did_driver, hint, i);
417 416 hint[i] = '\0';
418 417
419 418 /* search for the devid using the hint driver */
420 419 hint_major = ddi_name_to_major(hint);
421 420 if (hint_major != DDI_MAJOR_T_NONE) {
422 421 e_ddi_devid_hold_by_major(hint_major);
423 422 }
424 423
425 424 /*
426 425 * search for the devid with each driver declaring
427 426 * itself as a devid registrant.
428 427 */
429 428 for (major = 0; major < devcnt; major++) {
430 429 if (major == hint_major)
431 430 continue;
432 431 dnp = &devnamesp[major];
433 432 if (dnp->dn_flags & DN_DEVID_REGISTRANT) {
434 433 e_ddi_devid_hold_by_major(major);
435 434 }
436 435 }
437 436
438 437 /*
439 438 * Legacy support: may be removed once an upgrade mechanism
440 439 * for driver conf files is available.
441 440 */
442 441 drvp = e_ddi_devid_hold_driver_list;
443 442 for (i = 0; i < N_DRIVERS_TO_HOLD; i++, drvp++) {
444 443 major = ddi_name_to_major(*drvp);
445 444 if (major != DDI_MAJOR_T_NONE && major != hint_major) {
446 445 e_ddi_devid_hold_by_major(major);
447 446 }
448 447 }
449 448 }
450 449
451 450 /*
452 451 * Return success if discovery was attempted, to indicate
453 452 * that the desired device may now be available.
454 453 */
455 454 int
456 455 e_ddi_devid_discovery(ddi_devid_t devid)
457 456 {
458 457 int flags;
459 458 int rval = DDI_SUCCESS;
460 459
461 460 mutex_enter(&devid_discovery_mutex);
462 461
463 462 if (devid_discovery_busy) {
464 463 DEVID_LOG_DISC((CE_CONT, "devid_discovery: busy\n"));
465 464 while (devid_discovery_busy) {
466 465 cv_wait(&devid_discovery_cv, &devid_discovery_mutex);
467 466 }
468 467 } else if (e_devid_do_discovery()) {
469 468 devid_discovery_busy = 1;
470 469 mutex_exit(&devid_discovery_mutex);
471 470
472 471 if (i_ddi_io_initialized() == 0) {
473 472 e_ddi_devid_hold_installed_driver(devid);
474 473 } else {
475 474 DEVID_LOG_DISC((CE_CONT,
476 475 "devid_discovery: ndi_devi_config\n"));
477 476 flags = NDI_DEVI_PERSIST | NDI_CONFIG | NDI_NO_EVENT;
478 477 if (i_ddi_io_initialized())
479 478 flags |= NDI_DRV_CONF_REPROBE;
480 479 (void) ndi_devi_config(ddi_root_node(), flags);
481 480 }
482 481
483 482 mutex_enter(&devid_discovery_mutex);
484 483 devid_discovery_busy = 0;
485 484 cv_broadcast(&devid_discovery_cv);
486 485 if (devid_discovery_secs > 0)
487 486 devid_last_discovery = ddi_get_lbolt();
488 487 DEVID_LOG_DISC((CE_CONT, "devid_discovery: done\n"));
489 488 } else {
490 489 rval = DDI_FAILURE;
491 490 DEVID_LOG_DISC((CE_CONT, "no devid discovery\n"));
492 491 }
493 492
494 493 mutex_exit(&devid_discovery_mutex);
495 494
496 495 return (rval);
497 496 }
498 497
499 498 /*
500 499 * As part of registering a devid for a device,
501 500 * update the devid cache with this device/devid pair
502 501 * or note that this combination has registered.
503 502 *
504 503 * If a devpath is provided it will be used as the path to register the
505 504 * devid against, otherwise we use ddi_pathname(dip). In both cases
506 505 * we duplicate the path string so that it can be cached/freed indepdently
507 506 * of the original owner.
508 507 */
509 508 static int
510 509 e_devid_cache_register_cmn(dev_info_t *dip, ddi_devid_t devid, char *devpath)
511 510 {
512 511 nvp_devid_t *np;
513 512 nvp_devid_t *new_nvp;
514 513 ddi_devid_t new_devid;
515 514 int new_devid_size;
516 515 char *path, *fullpath;
517 516 ddi_devid_t free_devid = NULL;
518 517 int pathlen;
519 518 list_t *listp;
520 519 int is_dirty = 0;
521 520
522 521
523 522 ASSERT(ddi_devid_valid(devid) == DDI_SUCCESS);
524 523
525 524 if (devpath) {
526 525 pathlen = strlen(devpath) + 1;
527 526 path = kmem_alloc(pathlen, KM_SLEEP);
528 527 bcopy(devpath, path, pathlen);
529 528 } else {
530 529 /*
531 530 * We are willing to accept DS_BOUND nodes if we can form a full
532 531 * ddi_pathname (i.e. the node is part way to becomming
533 532 * DS_INITIALIZED and devi_addr/ddi_get_name_addr are non-NULL).
534 533 */
535 534 if (ddi_get_name_addr(dip) == NULL)
536 535 return (DDI_FAILURE);
537 536
538 537 fullpath = kmem_alloc(MAXPATHLEN, KM_SLEEP);
539 538 (void) ddi_pathname(dip, fullpath);
540 539 pathlen = strlen(fullpath) + 1;
541 540 path = kmem_alloc(pathlen, KM_SLEEP);
542 541 bcopy(fullpath, path, pathlen);
543 542 kmem_free(fullpath, MAXPATHLEN);
544 543 }
545 544
546 545 DEVID_LOG_REG(("register", devid, path));
547 546
548 547 new_nvp = kmem_zalloc(sizeof (nvp_devid_t), KM_SLEEP);
549 548 new_devid_size = ddi_devid_sizeof(devid);
550 549 new_devid = kmem_alloc(new_devid_size, KM_SLEEP);
551 550 (void) bcopy(devid, new_devid, new_devid_size);
552 551
553 552 rw_enter(nvf_lock(dcfd_handle), RW_WRITER);
554 553
555 554 listp = nvf_list(dcfd_handle);
556 555 for (np = list_head(listp); np; np = list_next(listp, np)) {
557 556 if (strcmp(path, np->nvp_devpath) == 0) {
558 557 DEVID_DEBUG2((CE_CONT,
559 558 "register: %s path match\n", path));
560 559 if (np->nvp_devid == NULL) {
561 560 replace: np->nvp_devid = new_devid;
562 561 np->nvp_flags |=
563 562 NVP_DEVID_DIP | NVP_DEVID_REGISTERED;
564 563 np->nvp_dip = dip;
565 564 if (!devid_cache_write_disable) {
566 565 nvf_mark_dirty(dcfd_handle);
567 566 is_dirty = 1;
568 567 }
569 568 rw_exit(nvf_lock(dcfd_handle));
570 569 kmem_free(new_nvp, sizeof (nvp_devid_t));
571 570 kmem_free(path, pathlen);
572 571 goto exit;
573 572 }
574 573 if (ddi_devid_valid(np->nvp_devid) != DDI_SUCCESS) {
575 574 /* replace invalid devid */
576 575 free_devid = np->nvp_devid;
577 576 goto replace;
578 577 }
579 578 /*
580 579 * We're registering an already-cached path
581 580 * Does the device's devid match the cache?
582 581 */
583 582 if (ddi_devid_compare(devid, np->nvp_devid) != 0) {
584 583 DEVID_DEBUG((CE_CONT, "devid register: "
585 584 "devid %s does not match\n", path));
586 585 /*
587 586 * Replace cached devid for this path
588 587 * with newly registered devid. A devid
589 588 * may map to multiple paths but one path
590 589 * should only map to one devid.
591 590 */
592 591 devid_nvp_unlink_and_free(dcfd_handle, np);
593 592 np = NULL;
594 593 break;
595 594 } else {
596 595 DEVID_DEBUG2((CE_CONT,
597 596 "devid register: %s devid match\n", path));
598 597 np->nvp_flags |=
599 598 NVP_DEVID_DIP | NVP_DEVID_REGISTERED;
600 599 np->nvp_dip = dip;
601 600 rw_exit(nvf_lock(dcfd_handle));
602 601 kmem_free(new_nvp, sizeof (nvp_devid_t));
603 602 kmem_free(path, pathlen);
604 603 kmem_free(new_devid, new_devid_size);
605 604 return (DDI_SUCCESS);
606 605 }
607 606 }
608 607 }
609 608
610 609 /*
611 610 * Add newly registered devid to the cache
612 611 */
613 612 ASSERT(np == NULL);
614 613
615 614 new_nvp->nvp_devpath = path;
616 615 new_nvp->nvp_flags = NVP_DEVID_DIP | NVP_DEVID_REGISTERED;
617 616 new_nvp->nvp_dip = dip;
618 617 new_nvp->nvp_devid = new_devid;
619 618
620 619 if (!devid_cache_write_disable) {
621 620 is_dirty = 1;
622 621 nvf_mark_dirty(dcfd_handle);
623 622 }
624 623 list_insert_tail(nvf_list(dcfd_handle), new_nvp);
625 624
626 625 rw_exit(nvf_lock(dcfd_handle));
627 626
628 627 exit:
629 628 if (free_devid)
630 629 kmem_free(free_devid, ddi_devid_sizeof(free_devid));
631 630
632 631 if (is_dirty)
633 632 nvf_wake_daemon();
634 633
635 634 return (DDI_SUCCESS);
636 635 }
637 636
638 637 int
639 638 e_devid_cache_register(dev_info_t *dip, ddi_devid_t devid)
640 639 {
641 640 return (e_devid_cache_register_cmn(dip, devid, NULL));
642 641 }
643 642
644 643 /*
645 644 * Unregister a device's devid; the devinfo may hit on multiple entries
646 645 * arising from both pHCI and vHCI paths.
647 646 * Called as an instance detachs.
648 647 * Invalidate the devid's devinfo reference.
649 648 * Devid-path remains in the cache.
650 649 */
651 650
652 651 void
653 652 e_devid_cache_unregister(dev_info_t *dip)
654 653 {
655 654 nvp_devid_t *np;
656 655 list_t *listp;
657 656
658 657 rw_enter(nvf_lock(dcfd_handle), RW_WRITER);
659 658
660 659 listp = nvf_list(dcfd_handle);
661 660 for (np = list_head(listp); np; np = list_next(listp, np)) {
662 661 if (np->nvp_devid == NULL)
663 662 continue;
664 663 if ((np->nvp_flags & NVP_DEVID_DIP) && np->nvp_dip == dip) {
665 664 DEVID_LOG_UNREG((CE_CONT,
666 665 "unregister: %s\n", np->nvp_devpath));
667 666 np->nvp_flags &= ~NVP_DEVID_DIP;
668 667 np->nvp_dip = NULL;
669 668 }
670 669 }
671 670
672 671 rw_exit(nvf_lock(dcfd_handle));
673 672 }
674 673
675 674 int
676 675 e_devid_cache_pathinfo(mdi_pathinfo_t *pip, ddi_devid_t devid)
677 676 {
678 677 char *path = mdi_pi_pathname(pip);
679 678
680 679 return (e_devid_cache_register_cmn(mdi_pi_get_client(pip), devid,
681 680 path));
682 681 }
683 682
684 683 /*
685 684 * Purge devid cache of stale devids
686 685 */
687 686 void
688 687 devid_cache_cleanup(void)
689 688 {
690 689 nvp_devid_t *np, *next;
691 690 list_t *listp;
692 691 int is_dirty = 0;
693 692
694 693 rw_enter(nvf_lock(dcfd_handle), RW_WRITER);
695 694
696 695 listp = nvf_list(dcfd_handle);
697 696 for (np = list_head(listp); np; np = next) {
698 697 next = list_next(listp, np);
699 698 if (np->nvp_devid == NULL)
700 699 continue;
701 700 if ((np->nvp_flags & NVP_DEVID_REGISTERED) == 0) {
702 701 DEVID_LOG_REMOVE((CE_CONT,
703 702 "cleanup: %s\n", np->nvp_devpath));
704 703 if (!devid_cache_write_disable) {
705 704 nvf_mark_dirty(dcfd_handle);
706 705 is_dirty = 0;
707 706 }
708 707 devid_nvp_unlink_and_free(dcfd_handle, np);
709 708 }
710 709 }
711 710
712 711 rw_exit(nvf_lock(dcfd_handle));
713 712
714 713 if (is_dirty)
715 714 nvf_wake_daemon();
716 715 }
717 716
718 717
719 718 /*
720 719 * Build a list of dev_t's for a device/devid
721 720 *
722 721 * The effect of this function is cumulative, adding dev_t's
723 722 * for the device to the list of all dev_t's for a given
724 723 * devid.
725 724 */
726 725 static void
727 726 e_devid_minor_to_devlist(
728 727 dev_info_t *dip,
729 728 char *minor_name,
730 729 int ndevts_alloced,
731 730 int *devtcntp,
732 731 dev_t *devtsp)
733 732 {
734 733 int circ;
735 734 struct ddi_minor_data *dmdp;
736 735 int minor_all = 0;
737 736 int ndevts = *devtcntp;
738 737
739 738 ASSERT(i_ddi_devi_attached(dip));
740 739
741 740 /* are we looking for a set of minor nodes? */
742 741 if ((minor_name == DEVID_MINOR_NAME_ALL) ||
743 742 (minor_name == DEVID_MINOR_NAME_ALL_CHR) ||
744 743 (minor_name == DEVID_MINOR_NAME_ALL_BLK))
745 744 minor_all = 1;
746 745
747 746 /* Find matching minor names */
748 747 ndi_devi_enter(dip, &circ);
749 748 for (dmdp = DEVI(dip)->devi_minor; dmdp; dmdp = dmdp->next) {
750 749
751 750 /* Skip non-minors, and non matching minor names */
752 751 if ((dmdp->type != DDM_MINOR) || ((minor_all == 0) &&
753 752 strcmp(dmdp->ddm_name, minor_name)))
754 753 continue;
755 754
756 755 /* filter out minor_all mismatches */
757 756 if (minor_all &&
758 757 (((minor_name == DEVID_MINOR_NAME_ALL_CHR) &&
759 758 (dmdp->ddm_spec_type != S_IFCHR)) ||
760 759 ((minor_name == DEVID_MINOR_NAME_ALL_BLK) &&
761 760 (dmdp->ddm_spec_type != S_IFBLK))))
762 761 continue;
763 762
764 763 if (ndevts < ndevts_alloced)
765 764 devtsp[ndevts] = dmdp->ddm_dev;
766 765 ndevts++;
767 766 }
768 767 ndi_devi_exit(dip, circ);
769 768
770 769 *devtcntp = ndevts;
771 770 }
772 771
773 772 /*
774 773 * Search for cached entries matching a devid
775 774 * Return two lists:
776 775 * a list of dev_info nodes, for those devices in the attached state
777 776 * a list of pathnames whose instances registered the given devid
778 777 * If the lists passed in are not sufficient to return the matching
779 778 * references, return the size of lists required.
780 779 * The dev_info nodes are returned with a hold that the caller must release.
781 780 */
782 781 static int
783 782 e_devid_cache_devi_path_lists(ddi_devid_t devid, int retmax,
784 783 int *retndevis, dev_info_t **retdevis, int *retnpaths, char **retpaths)
785 784 {
786 785 nvp_devid_t *np;
787 786 int ndevis, npaths;
788 787 dev_info_t *dip, *pdip;
789 788 int circ;
790 789 int maxdevis = 0;
791 790 int maxpaths = 0;
792 791 list_t *listp;
793 792
794 793 ndevis = 0;
795 794 npaths = 0;
796 795 listp = nvf_list(dcfd_handle);
797 796 for (np = list_head(listp); np; np = list_next(listp, np)) {
798 797 if (np->nvp_devid == NULL)
799 798 continue;
800 799 if (ddi_devid_valid(np->nvp_devid) != DDI_SUCCESS) {
801 800 DEVIDERR((CE_CONT,
802 801 "find: invalid devid %s\n",
803 802 np->nvp_devpath));
804 803 continue;
805 804 }
806 805 if (ddi_devid_compare(devid, np->nvp_devid) == 0) {
807 806 DEVID_DEBUG2((CE_CONT,
808 807 "find: devid match: %s 0x%x\n",
809 808 np->nvp_devpath, np->nvp_flags));
810 809 DEVID_LOG_MATCH(("find", devid, np->nvp_devpath));
811 810 DEVID_LOG_PATHS((CE_CONT, "%s\n", np->nvp_devpath));
812 811
813 812 /*
814 813 * Check if we have a cached devinfo reference for this
815 814 * devid. Place a hold on it to prevent detach
816 815 * Otherwise, use the path instead.
817 816 * Note: returns with a hold on each dev_info
818 817 * node in the list.
819 818 */
820 819 dip = NULL;
821 820 if (np->nvp_flags & NVP_DEVID_DIP) {
822 821 pdip = ddi_get_parent(np->nvp_dip);
823 822 if (ndi_devi_tryenter(pdip, &circ)) {
824 823 dip = np->nvp_dip;
825 824 ndi_hold_devi(dip);
826 825 ndi_devi_exit(pdip, circ);
827 826 ASSERT(!DEVI_IS_ATTACHING(dip));
828 827 ASSERT(!DEVI_IS_DETACHING(dip));
829 828 } else {
830 829 DEVID_LOG_DETACH((CE_CONT,
831 830 "may be detaching: %s\n",
832 831 np->nvp_devpath));
833 832 }
834 833 }
835 834
836 835 if (dip) {
837 836 if (ndevis < retmax) {
838 837 retdevis[ndevis++] = dip;
839 838 } else {
840 839 ndi_rele_devi(dip);
841 840 }
842 841 maxdevis++;
843 842 } else {
844 843 if (npaths < retmax)
845 844 retpaths[npaths++] = np->nvp_devpath;
846 845 maxpaths++;
847 846 }
848 847 }
849 848 }
850 849
851 850 *retndevis = ndevis;
852 851 *retnpaths = npaths;
853 852 return (maxdevis > maxpaths ? maxdevis : maxpaths);
854 853 }
855 854
856 855
857 856 /*
858 857 * Search the devid cache, returning dev_t list for all
859 858 * device paths mapping to the device identified by the
860 859 * given devid.
861 860 *
862 861 * Primary interface used by ddi_lyr_devid_to_devlist()
863 862 */
864 863 int
865 864 e_devid_cache_to_devt_list(ddi_devid_t devid, char *minor_name,
866 865 int *retndevts, dev_t **retdevts)
867 866 {
868 867 char *path, **paths;
869 868 int i, j, n;
870 869 dev_t *devts, *udevts;
871 870 dev_t tdevt;
872 871 int ndevts, undevts, ndevts_alloced;
873 872 dev_info_t *devi, **devis;
874 873 int ndevis, npaths, nalloced;
875 874 ddi_devid_t match_devid;
876 875
877 876 DEVID_LOG_FIND(("find", devid, NULL));
878 877
879 878 ASSERT(ddi_devid_valid(devid) == DDI_SUCCESS);
880 879 if (ddi_devid_valid(devid) != DDI_SUCCESS) {
881 880 DEVID_LOG_ERR(("invalid devid", devid, NULL));
882 881 return (DDI_FAILURE);
883 882 }
884 883
885 884 nalloced = 128;
886 885
887 886 for (;;) {
888 887 paths = kmem_zalloc(nalloced * sizeof (char *), KM_SLEEP);
889 888 devis = kmem_zalloc(nalloced * sizeof (dev_info_t *), KM_SLEEP);
890 889
891 890 rw_enter(nvf_lock(dcfd_handle), RW_READER);
892 891 n = e_devid_cache_devi_path_lists(devid, nalloced,
893 892 &ndevis, devis, &npaths, paths);
894 893 if (n <= nalloced)
895 894 break;
896 895 rw_exit(nvf_lock(dcfd_handle));
897 896 for (i = 0; i < ndevis; i++)
898 897 ndi_rele_devi(devis[i]);
899 898 kmem_free(paths, nalloced * sizeof (char *));
900 899 kmem_free(devis, nalloced * sizeof (dev_info_t *));
901 900 nalloced = n + 128;
902 901 }
903 902
904 903 for (i = 0; i < npaths; i++) {
905 904 path = i_ddi_strdup(paths[i], KM_SLEEP);
906 905 paths[i] = path;
907 906 }
908 907 rw_exit(nvf_lock(dcfd_handle));
909 908
910 909 if (ndevis == 0 && npaths == 0) {
911 910 DEVID_LOG_ERR(("no devid found", devid, NULL));
912 911 kmem_free(paths, nalloced * sizeof (char *));
913 912 kmem_free(devis, nalloced * sizeof (dev_info_t *));
914 913 return (DDI_FAILURE);
915 914 }
916 915
917 916 ndevts_alloced = 128;
918 917 restart:
919 918 ndevts = 0;
920 919 devts = kmem_alloc(ndevts_alloced * sizeof (dev_t), KM_SLEEP);
921 920 for (i = 0; i < ndevis; i++) {
922 921 ASSERT(!DEVI_IS_ATTACHING(devis[i]));
923 922 ASSERT(!DEVI_IS_DETACHING(devis[i]));
924 923 e_devid_minor_to_devlist(devis[i], minor_name,
925 924 ndevts_alloced, &ndevts, devts);
926 925 if (ndevts > ndevts_alloced) {
927 926 kmem_free(devts, ndevts_alloced * sizeof (dev_t));
928 927 ndevts_alloced += 128;
929 928 goto restart;
930 929 }
931 930 }
932 931 for (i = 0; i < npaths; i++) {
933 932 DEVID_LOG_LOOKUP((CE_CONT, "lookup %s\n", paths[i]));
934 933 devi = e_ddi_hold_devi_by_path(paths[i], 0);
935 934 if (devi == NULL) {
936 935 DEVID_LOG_STALE(("stale device reference",
937 936 devid, paths[i]));
938 937 continue;
939 938 }
940 939 /*
941 940 * Verify the newly attached device registered a matching devid
942 941 */
943 942 if (i_ddi_devi_get_devid(DDI_DEV_T_ANY, devi,
944 943 &match_devid) != DDI_SUCCESS) {
945 944 DEVIDERR((CE_CONT,
946 945 "%s: no devid registered on attach\n",
947 946 paths[i]));
948 947 ddi_release_devi(devi);
949 948 continue;
950 949 }
951 950
952 951 if (ddi_devid_compare(devid, match_devid) != 0) {
953 952 DEVID_LOG_STALE(("new devid registered",
954 953 devid, paths[i]));
955 954 ddi_release_devi(devi);
956 955 ddi_devid_free(match_devid);
957 956 continue;
958 957 }
959 958 ddi_devid_free(match_devid);
960 959
961 960 e_devid_minor_to_devlist(devi, minor_name,
962 961 ndevts_alloced, &ndevts, devts);
963 962 ddi_release_devi(devi);
964 963 if (ndevts > ndevts_alloced) {
965 964 kmem_free(devts,
966 965 ndevts_alloced * sizeof (dev_t));
967 966 ndevts_alloced += 128;
968 967 goto restart;
969 968 }
970 969 }
971 970
972 971 /* drop hold from e_devid_cache_devi_path_lists */
973 972 for (i = 0; i < ndevis; i++) {
974 973 ndi_rele_devi(devis[i]);
975 974 }
976 975 for (i = 0; i < npaths; i++) {
977 976 kmem_free(paths[i], strlen(paths[i]) + 1);
978 977 }
979 978 kmem_free(paths, nalloced * sizeof (char *));
980 979 kmem_free(devis, nalloced * sizeof (dev_info_t *));
981 980
982 981 if (ndevts == 0) {
983 982 DEVID_LOG_ERR(("no devid found", devid, NULL));
984 983 kmem_free(devts, ndevts_alloced * sizeof (dev_t));
985 984 return (DDI_FAILURE);
986 985 }
987 986
988 987 /*
989 988 * Build the final list of sorted dev_t's with duplicates collapsed so
990 989 * returned results are consistent. This prevents implementation
991 990 * artifacts from causing unnecessary changes in SVM namespace.
992 991 */
993 992 /* bubble sort */
994 993 for (i = 0; i < (ndevts - 1); i++) {
995 994 for (j = 0; j < ((ndevts - 1) - i); j++) {
996 995 if (devts[j + 1] < devts[j]) {
997 996 tdevt = devts[j];
998 997 devts[j] = devts[j + 1];
999 998 devts[j + 1] = tdevt;
1000 999 }
1001 1000 }
1002 1001 }
1003 1002
1004 1003 /* determine number of unique values */
1005 1004 for (undevts = ndevts, i = 1; i < ndevts; i++) {
1006 1005 if (devts[i - 1] == devts[i])
1007 1006 undevts--;
1008 1007 }
1009 1008
1010 1009 /* allocate unique */
1011 1010 udevts = kmem_alloc(undevts * sizeof (dev_t), KM_SLEEP);
1012 1011
1013 1012 /* copy unique */
1014 1013 udevts[0] = devts[0];
1015 1014 for (i = 1, j = 1; i < ndevts; i++) {
1016 1015 if (devts[i - 1] != devts[i])
1017 1016 udevts[j++] = devts[i];
1018 1017 }
1019 1018 ASSERT(j == undevts);
1020 1019
1021 1020 kmem_free(devts, ndevts_alloced * sizeof (dev_t));
1022 1021
1023 1022 *retndevts = undevts;
1024 1023 *retdevts = udevts;
1025 1024
1026 1025 return (DDI_SUCCESS);
1027 1026 }
1028 1027
1029 1028 void
1030 1029 e_devid_cache_free_devt_list(int ndevts, dev_t *devt_list)
1031 1030 {
1032 1031 kmem_free(devt_list, ndevts * sizeof (dev_t *));
1033 1032 }
1034 1033
1035 1034 /*
1036 1035 * If given a full path and NULL ua, search for a cache entry
1037 1036 * whose path matches the full path. On a cache hit duplicate the
1038 1037 * devid of the matched entry into the given devid (caller
1039 1038 * must free); nodenamebuf is not touched for this usage.
1040 1039 *
1041 1040 * Given a path and a non-NULL unit address, search the cache for any entry
1042 1041 * matching "<path>/%@<unit-address>" where '%' is a wildcard meaning
1043 1042 * any node name. The path should not end a '/'. On a cache hit
1044 1043 * duplicate the devid as before (caller must free) and copy into
1045 1044 * the caller-provided nodenamebuf (if not NULL) the nodename of the
1046 1045 * matched entry.
1047 1046 *
1048 1047 * We must not make use of nvp_dip since that may be NULL for cached
1049 1048 * entries that are not present in the current tree.
1050 1049 */
1051 1050 int
1052 1051 e_devid_cache_path_to_devid(char *path, char *ua,
1053 1052 char *nodenamebuf, ddi_devid_t *devidp)
1054 1053 {
1055 1054 size_t pathlen, ualen;
1056 1055 int rv = DDI_FAILURE;
1057 1056 nvp_devid_t *np;
1058 1057 list_t *listp;
1059 1058 char *cand;
1060 1059
1061 1060 if (path == NULL || *path == '\0' || (ua && *ua == '\0') ||
1062 1061 devidp == NULL)
1063 1062 return (DDI_FAILURE);
1064 1063
1065 1064 *devidp = NULL;
1066 1065
1067 1066 if (ua) {
1068 1067 pathlen = strlen(path);
1069 1068 ualen = strlen(ua);
1070 1069 }
1071 1070
1072 1071 rw_enter(nvf_lock(dcfd_handle), RW_READER);
1073 1072
1074 1073 listp = nvf_list(dcfd_handle);
1075 1074 for (np = list_head(listp); np; np = list_next(listp, np)) {
1076 1075 size_t nodelen, candlen, n;
1077 1076 ddi_devid_t devid_dup;
1078 1077 char *uasep, *node;
1079 1078
1080 1079 if (np->nvp_devid == NULL)
1081 1080 continue;
1082 1081
1083 1082 if (ddi_devid_valid(np->nvp_devid) != DDI_SUCCESS) {
1084 1083 DEVIDERR((CE_CONT,
1085 1084 "pathsearch: invalid devid %s\n",
1086 1085 np->nvp_devpath));
1087 1086 continue;
1088 1087 }
1089 1088
1090 1089 cand = np->nvp_devpath; /* candidate path */
1091 1090
1092 1091 /* If a full pathname was provided the compare is easy */
1093 1092 if (ua == NULL) {
1094 1093 if (strcmp(cand, path) == 0)
1095 1094 goto match;
1096 1095 else
1097 1096 continue;
1098 1097 }
1099 1098
1100 1099 /*
1101 1100 * The compare for initial path plus ua and unknown nodename
1102 1101 * is trickier.
1103 1102 *
1104 1103 * Does the initial path component match 'path'?
1105 1104 */
1106 1105 if (strncmp(path, cand, pathlen) != 0)
1107 1106 continue;
1108 1107
1109 1108 candlen = strlen(cand);
1110 1109
1111 1110 /*
1112 1111 * The next character must be a '/' and there must be no
1113 1112 * further '/' thereafter. Begin by checking that the
1114 1113 * candidate is long enough to include at mininum a
1115 1114 * "/<nodename>@<ua>" after the initial portion already
1116 1115 * matched assuming a nodename length of 1.
1117 1116 */
1118 1117 if (candlen < pathlen + 1 + 1 + 1 + ualen ||
1119 1118 cand[pathlen] != '/' ||
1120 1119 strchr(cand + pathlen + 1, '/') != NULL)
1121 1120 continue;
1122 1121
1123 1122 node = cand + pathlen + 1; /* <node>@<ua> string */
1124 1123
1125 1124 /*
1126 1125 * Find the '@' before the unit address. Check for
1127 1126 * unit address match.
1128 1127 */
1129 1128 if ((uasep = strchr(node, '@')) == NULL)
1130 1129 continue;
1131 1130
1132 1131 /*
1133 1132 * Check we still have enough length and that ua matches
1134 1133 */
1135 1134 nodelen = (uintptr_t)uasep - (uintptr_t)node;
1136 1135 if (candlen < pathlen + 1 + nodelen + 1 + ualen ||
1137 1136 strncmp(ua, uasep + 1, ualen) != 0)
1138 1137 continue;
1139 1138 match:
1140 1139 n = ddi_devid_sizeof(np->nvp_devid);
1141 1140 devid_dup = kmem_alloc(n, KM_SLEEP); /* caller must free */
1142 1141 (void) bcopy(np->nvp_devid, devid_dup, n);
1143 1142 *devidp = devid_dup;
1144 1143
1145 1144 if (ua && nodenamebuf) {
1146 1145 (void) strncpy(nodenamebuf, node, nodelen);
1147 1146 nodenamebuf[nodelen] = '\0';
1148 1147 }
1149 1148
1150 1149 rv = DDI_SUCCESS;
1151 1150 break;
1152 1151 }
1153 1152
1154 1153 rw_exit(nvf_lock(dcfd_handle));
1155 1154
1156 1155 return (rv);
1157 1156 }
1158 1157
1159 1158 #ifdef DEBUG
1160 1159 static void
1161 1160 devid_log(char *fmt, ddi_devid_t devid, char *path)
1162 1161 {
1163 1162 char *devidstr = ddi_devid_str_encode(devid, NULL);
1164 1163 if (path) {
1165 1164 cmn_err(CE_CONT, "%s: %s %s\n", fmt, path, devidstr);
1166 1165 } else {
1167 1166 cmn_err(CE_CONT, "%s: %s\n", fmt, devidstr);
1168 1167 }
1169 1168 ddi_devid_str_free(devidstr);
1170 1169 }
1171 1170 #endif /* DEBUG */
↓ open down ↓ |
814 lines elided |
↑ open up ↑ |
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX