| blob | fb8232979cf5f0fa34a3c67d0ba0606463af3817 |
1 /*
2 * CDDL HEADER START
3 *
4 * The contents of this file are subject to the terms of the
5 * Common Development and Distribution License (the "License").
6 * You may not use this file except in compliance with the License.
7 *
8 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
9 * or http://www.opensolaris.org/os/licensing.
10 * See the License for the specific language governing permissions
11 * and limitations under the License.
12 *
13 * When distributing Covered Code, include this CDDL HEADER in each
14 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
15 * If applicable, add the following below this CDDL HEADER, with the
16 * fields enclosed by brackets "[]" replaced with your own identifying
17 * information: Portions Copyright [yyyy] [name of copyright owner]
18 *
19 * CDDL HEADER END
20 */
22 /*
23 * Copyright 2016 Toomas Soome <tsoome@me.com>
24 * Copyright (c) 1998, 2010, Oracle and/or its affiliates. All rights reserved.
25 */
27 /*
28 * Devfsadm replaces drvconfig, audlinks, disks, tapes, ports, devlinks
29 * as a general purpose device administrative utility. It creates
30 * devices special files in /devices and logical links in /dev, and
31 * coordinates updates to /etc/path_to_instance with the kernel. It
32 * operates in both command line mode to handle user or script invoked
33 * reconfiguration updates, and operates in daemon mode to handle dynamic
34 * reconfiguration for hotplugging support.
35 */
37 #include <string.h>
38 #include <deflt.h>
39 #include <utime.h>
40 #include <sys/param.h>
41 #include <zone.h>
44 /* create or remove nodes or links. unset with -n */
47 /* cleanup mode. Set with -C */
50 /* devlinks -d compatibility */
53 /* load a single driver only. set with -i */
57 /* attempt to load drivers or defer attach nodes */
60 /* reload all driver.conf files */
63 /* set if invoked via /usr/lib/devfsadm/devfsadmd */
66 /* set if event_handler triggered */
69 /* output directed to syslog during daemon mode if set */
72 /* build links in /dev. -x to turn off */
75 /* build nodes in /devices. -y to turn off */
78 /* -z to turn off */
81 /* variables used for path_to_inst flushing */
86 /* variables for minor_fini thread */
93 /* single-threads /dev modification */
96 /* the program we were invoked as; ie argv[0] */
99 /* pointers to create/remove link lists */
103 /* supports the class -c option */
107 /* used with verbose option -v or -V */
114 /* set if -r alternate root given */
117 /* /devices or <rootdir>/devices */
120 /* /dev or <rootdir>/dev */
123 /* /etc/dev or <rootdir>/etc/dev */
126 /*
127 * writable root (for lock files and doors during install).
128 * This is also root dir for /dev attr dir during install.
129 */
132 /* /etc/path_to_inst unless -p used */
135 /* /usr/lib/devfsadm/linkmods unless -l used */
138 /* default uid/gid used if /etc/minor_perm entry not found */
142 /* /etc/devlink.tab unless devlinks -t used */
145 /* File and data structure to reserve enumerate IDs */
149 /* set if /dev link is new. speeds up rm_stale_links */
152 /* variables for devlink.tab compat processing */
156 /* cache head for devfsadm_enumerate*() functions */
159 /* list list of devfsadm modules */
162 /* name_to_major list used in utility function */
165 /* cache of some links used for performance */
168 /* locking variables to prevent multiples writes to /dev */
176 /* last devinfo node/minor processed. used for performance */
181 /* Globals used by the link database */
185 /* Globals used to set logindev perms */
189 /* Global to use devinfo snapshot cache */
192 /* Global for no-further-processing hash */
196 /*
197 * Directories not removed even when empty. They are packaged, or may
198 * be referred to from a non-global zone. The dirs must be listed in
199 * canonical form i.e. without leading "/dev/"
200 */
204 /* Devname globals */
215 /* sysevent queue related globals */
223 int
225 {
228 pid_t pid;
236 prog++;
237 }
242 /*NOTREACHED*/
243 }
248 }
250 /*
251 * Close all files except stdin/stdout/stderr
252 */
260 }
262 /* the default group is sys */
269 }
278 /*
279 * Build /dev and /devices before daemonizing if
280 * reconfig booting and daemon invoked with alternate
281 * root. This is to support install.
282 */
289 }
291 /*
292 * fork before detaching from tty in order to print error
293 * message if unable to acquire file lock. locks not preserved
294 * across forks. Even under debug we want to fork so that
295 * when executed at boot we don't hang.
296 */
299 /*NOTREACHED*/
300 }
302 /* set directory to / so it coredumps there */
305 }
307 /* only one daemon can run at a time */
318 /*NOTREACHED*/
319 }
321 /* start the minor_fini_thread */
330 /*NOTREACHED*/
331 }
334 /*
335 * logindevperms need only be set
336 * in daemon mode and when root dir is "/".
337 */
342 /*NOTREACHED*/
346 /*NOTREACHED*/
347 }
349 /* not a daemon, so just build /dev and /devices */
351 }
353 }
355 static void
357 {
360 major);
361 }
363 static void
365 {
369 }
371 /*
372 * As devfsadm is run early in boot to provide the kernel with
373 * minor_perm info, we might as well check for reconfig at the
374 * same time to avoid running devfsadm twice. This gets invoked
375 * earlier than the env variable RECONFIG_BOOT is set up.
376 */
377 static void
379 {
384 }
385 }
387 static void
389 {
390 /*
391 * Inform /dev that system is available, that
392 * implicit reconfig can now be performed.
393 */
395 }
397 static void
399 {
415 /*NOTREACHED*/
416 }
417 }
420 /*
421 * Parse arguments for all 6 programs handled from devfsadm.
422 */
423 static void
425 {
472 /* prevent driver loading and deferred attach */
478 DEVFSADM_SUCCESS)
480 /*NOTREACHED*/
483 /*
484 * suppress. don't create/remove links/nodes
485 * useful with -v or -V
486 */
491 /* supply a non-default table file */
495 /* documented verbose flag */
499 /* undocumented for extra verbose levels */
505 }
506 }
510 }
527 /*NOTREACHED*/
528 }
534 }
536 num_aliases++;
546 /*
547 * need to keep for compatibility, but
548 * do nothing.
549 */
563 /* prevent driver loading and deferred attach */
567 /* specify alternate path_to_inst file */
571 /*
572 * Private flag for suninstall to populate
573 * device information on the installed root.
574 */
577 DEVFSADM_SUCCESS)
579 /*NOTREACHED*/
584 DEVFSADM_SUCCESS)
586 /*NOTREACHED*/
589 /*
590 * suppress. don't create nodes
591 * useful with -v or -V
592 */
597 /*
598 * Invoked via update_drv(1m) to update
599 * the kernel's driver/alias binding
600 * when removing one or more aliases.
601 */
605 /* documented verbose flag */
609 /* undocumented for extra verbose levels */
617 }
618 }
622 }
628 /*NOTREACHED*/
629 }
641 MODCTL_REMMAJBIND);
642 }
644 /*NOTREACHED*/
645 }
657 }
670 }
679 num_classes++;
694 /* specify an alternate module load path */
698 /* prevent driver loading and deferred attach */
702 /* specify alternate path_to_inst file */
708 /* load minor_perm and device_policy */
712 /*
713 * Private flag for suninstall to populate
714 * device information on the installed root.
715 */
718 /*NOTREACHED*/
724 /*
725 * suppress. don't create/remove links/nodes
726 * useful with -v or -V
727 */
740 /* adding a driver update-only */
746 /* documented verbose flag */
750 /* undocumented: specify verbose lvl */
754 /*
755 * x is the "private switch" option. The
756 * goal is to not suck up all the other
757 * option letters.
758 */
762 /* don't build /dev */
765 /* don't build /devices */
768 /* don't flush path_to_inst */
774 }
779 }
780 }
783 }
785 /*
786 * We're not in zone mode; Check to see if the rootpath
787 * collides with any zonepaths.
788 */
792 /*NOTREACHED*/
793 }
796 /*
797 * Load minor perm before force-loading drivers
798 * so the correct permissions are picked up.
799 */
803 }
809 /*NOTREACHED*/
810 }
811 }
818 num_classes++;
829 /* prevent driver loading or deferred attach */
835 DEVFSADM_SUCCESS)
837 /*NOTREACHED*/
840 /* suppress. don't create/remove links/nodes */
841 /* useful with -v or -V */
846 /* documented verbose flag */
850 /* undocumented for extra verbose levels */
855 }
856 }
859 }
860 }
862 }
864 void
866 {
876 }
879 /*NOTREACHED*/
880 }
882 static void
884 {
887 di_node_t node;
905 }
909 /*
910 * Rapid hotplugging (commonly seen during USB testing),
911 * may remove a device before the create event for it
912 * has been processed. To prevent alarming users with
913 * a superfluous message, we suppress error messages
914 * for ENXIO and hotplug.
915 */
919 }
930 check_minor_type);
936 /*
937 * Finished creating devfs files and dev links.
938 * Log sysevent.
939 */
946 }
948 static void
950 {
958 /*
959 * The list head is not used during the deferred create phase
960 */
972 }
975 }
977 /*
978 * Called in non-daemon mode to take a snap shot of the devinfo tree.
979 * Then it calls the appropriate functions to build /devices and /dev.
980 * It also flushes path_to_inst.
981 * Except in the devfsadm -i (single driver case), the flags used by devfsadm
982 * needs to match DI_CACHE_SNAPSHOT_FLAGS. That will make DINFOCACHE snapshot
983 * updated.
984 */
985 void
987 {
988 uint_t flags;
999 /*
1000 * Update kernel driver.conf cache when devfsadm/drvconfig
1001 * is invoked to build /devices and /dev.
1002 */
1006 }
1009 /*
1010 * load a single driver, but walk the entire devinfo tree
1011 */
1023 /*
1024 * Load and attach all drivers, then walk the entire tree.
1025 * If the cache flag is set, use DINFOCACHE to get cached
1026 * data.
1027 */
1035 /*
1036 * remove dangling entries from /etc/devices
1037 * files.
1038 */
1040 }
1041 }
1043 /*
1044 * For devlinks, disks, ports, tapes and devfsadm -n,
1045 * just need to take a snapshot with active devices.
1046 */
1048 fcn);
1050 }
1055 }
1057 /* handle pre-cleanup operations desired by the modules. */
1064 /*NOTREACHED*/
1065 }
1067 /* handle post-cleanup operations desired by the modules. */
1071 }
1073 /*ARGSUSED*/
1074 static void
1076 {
1080 /*NOTREACHED*/
1081 }
1082 }
1084 static void
1086 {
1091 }
1092 }
1093 }
1095 /*ARGSUSED*/
1096 static void
1098 {
1100 }
1102 /*
1103 * Register with eventd for messages. Create doors for synchronous
1104 * link creation.
1105 */
1106 static void
1108 {
1119 /*NOTREACHED*/
1120 }
1124 /*NOTREACHED*/
1125 }
1133 /*NOTREACHED*/
1134 }
1140 /*NOTREACHED*/
1141 }
1147 /*NOTREACHED*/
1148 }
1157 /*NOTREACHED*/
1158 }
1164 /*NOTREACHED*/
1165 }
1171 /*NOTREACHED*/
1172 }
1180 /*NOTREACHED*/
1181 }
1187 /*NOTREACHED*/
1188 }
1190 /*
1191 * devname_lookup_door
1192 */
1198 /*NOTREACHED*/
1199 }
1205 /*NOTREACHED*/
1206 }
1214 /*NOTREACHED*/
1215 }
1219 retry:
1226 /*NOTREACHED*/
1227 }
1230 /* pass down the door name to kernel for door_ki_open */
1237 }
1238 }
1240 /*ARGSUSED*/
1241 static void
1244 {
1245 door_cred_t dcred;
1249 /*
1250 * Must be root to make this call
1251 * If caller is not root, don't touch its data.
1252 */
1257 }
1264 /*
1265 * Root is always present and is the first component of "name" member
1266 */
1269 /*
1270 * The structure passed in by the door_client uses offsets
1271 * instead of pointers to work across address space boundaries.
1272 * Now copy the data into a structure (dca_impl) which uses
1273 * pointers.
1274 */
1289 else
1293 }
1295 static void
1297 {
1303 /* lockout other threads from /dev */
1305 ;
1307 /*
1308 * Lock out other devfsadm processes from /dev.
1309 * If this wasn't the last process to run,
1310 * clear caches
1311 */
1317 /* send any sysevents that were queued up. */
1319 }
1321 /*
1322 * (re)load the reverse links database if not
1323 * already cached.
1324 */
1328 /*
1329 * If modules were unloaded, reload them. Also use module status
1330 * as an indication that we should check to see if other binding
1331 * files need to be reloaded.
1332 */
1340 }
1351 /*NOTREACHED*/
1352 }
1357 }
1358 }
1359 }
1361 /*
1362 * Unlock the device. If we are processing a CACHE_STATE call, we signal a
1363 * minor_fini_thread delayed SYNC_STATE at the end of the call. If we are
1364 * processing a SYNC_STATE call, we cancel any minor_fini_thread SYNC_STATE
1365 * at both the start and end of the call since we will be doing the SYNC_STATE.
1366 */
1367 static void
1369 {
1374 /* If we are starting a SYNC_STATE, cancel minor_fini_thread SYNC */
1380 }
1387 }
1396 /*
1397 * now that the devlinks db cache has been flushed, it is safe
1398 * to send any sysevents that were queued up.
1399 */
1401 }
1407 /* We did a SYNC_STATE, cancel minor_fini_thread SYNC */
1411 /* We did a CACHE_STATE, start delayed minor_fini_thread SYNC */
1415 }
1419 }
1421 /*
1422 * Check that if -r is set, it is not any part of a zone--- that is, that
1423 * the zonepath is not a substring of the root path.
1424 */
1425 static int
1427 {
1440 /*
1441 * Check if zones is available on this system.
1442 */
1445 }
1449 /*
1450 * In this case the user has done "devfsadm -r" on some path
1451 * which does not yet exist, or we got some other misc. error.
1452 * We punt and don't resolve the path in this case.
1453 */
1455 }
1460 }
1464 /* Skip the global zone */
1468 }
1473 }
1477 /*
1478 * Zone path doesn't exist, or other misc error,
1479 * so we try using the non-resolved pathname.
1480 */
1482 }
1486 }
1488 /*
1489 * Finally, the comparison. If the zone root path is a
1490 * leading substring of the root path, fail.
1491 */
1497 }
1499 }
1503 }
1505 /*
1506 * Called by the daemon when it receives an event from the devfsadm SLM
1507 * to syseventd.
1508 *
1509 * The devfsadm SLM uses a private event channel for communication to
1510 * devfsadmd set-up via private libsysevent interfaces. This handler is
1511 * used to bind to the devfsadmd channel for event delivery.
1512 * The devfsadmd SLM insures single calls to this routine as well as
1513 * synchronized event delivery.
1514 *
1515 */
1516 static void
1518 {
1529 /*
1530 * If this is event-driven, then we cannot trust the static devlist
1531 * to be correct.
1532 */
1541 }
1543 /* Check if event is an instance modification */
1547 }
1551 }
1588 NULL);
1589 }
1596 instance);
1604 NULL);
1605 }
1606 }
1616 /* just log ESC_DEV_BRANCH... event */
1619 else
1629 out:
1633 }
1635 static void
1637 {
1646 }
1648 /*
1649 * Kernel logs a message when a devinfo node is attached. Try to create
1650 * /dev and /devices for each minor node. minorname can be NULL.
1651 */
1652 void
1654 {
1662 /*
1663 * Restrict hotplug link creation if daemon
1664 * started with -i option.
1665 */
1668 }
1670 /*
1671 * We are being invoked in response to a hotplug event.
1672 */
1676 }
1678 static di_node_t
1680 {
1686 }
1688 static int
1690 {
1696 }
1698 }
1700 /*
1701 * Checks the minor type. If it is an alias node, then lookup
1702 * the real node/minor first, then call minor_process() to
1703 * do the real work.
1704 */
1705 static int
1707 {
1708 ddi_minor_type minor_type;
1709 di_node_t clone_node;
1721 /*
1722 * We match driver here instead of in minor_process
1723 * as we want the actual driver name. This check is
1724 * unnecessary during deferred processing.
1725 */
1730 }
1736 }
1750 }
1756 /*
1757 * cache "alias" minor node and free "clone" minor
1758 */
1765 }
1766 }
1769 }
1772 /*
1773 * This is the entry point for each minor node, whether walking
1774 * the entire tree via di_walk_minor() or processing a hotplug event
1775 * for a single devinfo node (via hotplug ndi_devi_online()).
1776 */
1777 /*ARGSUSED*/
1778 static void
1780 {
1791 }
1795 }
1797 /*
1798 * This function will create any nodes for /etc/devlink.tab.
1799 * If devlink.tab handles link creation, we don't call any
1800 * devfsadm modules since that could cause duplicate caching
1801 * in the enumerate functions if different re strings are
1802 * passed that are logically identical. I'm still not
1803 * convinced this would cause any harm, but better to be safe.
1804 *
1805 * Deferred processing is available only for devlinks
1806 * created through devfsadm modules.
1807 */
1810 }
1813 }
1815 /*
1816 * look for relevant link create rules in the modules, and
1817 * invoke the link create callback function to build a link
1818 * if there is a match.
1819 */
1824 DEVFSADM_SUCCESS) {
1826 DEVFSADM_FAILURE) {
1828 }
1830 /*
1831 * If NOT doing the deferred creates (i.e. 1st pass) and
1832 * rule requests deferred processing cache the minor
1833 * data.
1834 *
1835 * If deferred processing (2nd pass), create links
1836 * ONLY if rule requests deferred processing.
1837 */
1839 CREATE_DEFER)) {
1844 CREATE_DEFER)) {
1846 }
1851 }
1852 }
1853 }
1857 }
1860 /*
1861 * Cache node and minor in defer list.
1862 */
1863 static void
1866 di_node_t node,
1867 di_minor_t minor)
1868 {
1879 }
1891 }
1893 }
1895 /*
1896 * Check to see if "create" link creation rule matches this node/minor.
1897 * If it does, return TRUE.
1898 */
1899 static int
1901 {
1914 }
1920 }
1926 }
1928 }
1929 }
1937 }
1943 }
1945 }
1946 }
1949 }
1951 /*
1952 * If no classes were given on the command line, then return DEVFSADM_SUCCESS.
1953 * Otherwise, return DEVFSADM_SUCCESS if the device "class" from the module
1954 * matches one of the device classes given on the command line,
1955 * otherwise, return DEVFSADM_FAILURE.
1956 */
1957 static int
1959 {
1964 }
1969 }
1970 }
1972 }
1974 /*
1975 * call minor_fini on active modules, then unload ALL modules
1976 */
1977 static void
1979 {
1990 }
1993 }
1995 }
2001 }
2008 }
2017 }
2018 }
2020 /*
2021 * Load devfsadm logical link processing modules.
2022 */
2023 static void
2025 {
2036 mdir++;
2037 }
2041 }
2047 }
2057 }
2064 }
2067 }
2069 }
2070 }
2072 static void
2074 {
2090 /* ignore any file which does not end in '.so' */
2094 }
2097 }
2106 }
2108 /* dlsym the _devfsadm_create_reg structure */
2112 _DEVFSADM_CREATE_REG);
2116 }
2118 /* dlsym the _devfsadm_remove_reg structure */
2126 }
2134 /* dlsym other module functions, to be called later */
2139 /*
2140 * put a ptr to each struct devfsadm_create on "create_head"
2141 * list sorted in interpose_lvl.
2142 */
2160 }
2169 }
2180 }
2182 /* precompile regular expression for efficiency */
2185 node_type_comp),
2193 }
2194 }
2200 node_type_comp));
2201 }
2207 }
2214 node_type_comp));
2215 }
2221 }
2223 /* precompile regular expression for efficiency */
2226 drv_name_comp),
2231 node_type_comp));
2232 }
2238 }
2239 }
2242 /* add to list sorted by interpose level */
2248 ;
2251 }
2252 }
2254 /*
2255 * put a ptr to each struct devfsadm_remove on "remove_head"
2256 * list sorted by interpose_lvl.
2257 */
2276 ;
2279 }
2280 }
2284 }
2286 /*
2287 * After we have completed a CACHE_STATE, if a SYNC_STATE does not occur
2288 * within 'timeout' secs the minor_fini_thread needs to do a SYNC_STATE
2289 * so that we still call the minor_fini routines.
2290 */
2291 /*ARGSUSED*/
2292 static void
2294 {
2295 timestruc_t abstime;
2301 /* wait the gather period, or until signaled */
2307 /* if minor_fini was canceled, go wait again */
2311 /* if minor_fini was delayed, go wait again */
2315 }
2317 /* done with cancellations and delays, do the SYNC_STATE */
2325 }
2326 }
2329 /*
2330 * Attempt to initialize module, if a minor_init routine exists. Set
2331 * the active flag if the routine exists and succeeds. If it doesn't
2332 * exist, just set the active flag.
2333 */
2334 static int
2336 {
2341 }
2350 }
2355 }
2362 }
2364 /*
2365 * Creates a symlink 'link' to the physical path of node:minor.
2366 * Construct link contents, then call create_link_common().
2367 */
2368 /*ARGSUSED*/
2369 int
2371 {
2382 /*
2383 * try to use devices path
2384 */
2388 /* use /pseudo/clone@0:<driver> as the phys path */
2397 /*NOTREACHED*/
2398 }
2403 }
2405 /* prepend link with dev_dir contents */
2410 /*
2411 * Calculate # of ../ to add. Account for double '//' in path.
2412 * Ignore all leading slashes.
2413 */
2415 ;
2419 numslashes++;
2421 }
2424 }
2425 }
2426 /* Don't count any trailing '/' */
2428 numslashes--;
2429 }
2441 }
2449 }
2452 /* Link exists or was just created */
2454 DI_PRIMARY_LINK);
2455 }
2458 }
2460 /*
2461 * Creates a symlink link to primary_link. Calculates relative
2462 * directory offsets, then calls link_common().
2463 */
2464 /*ARGSUSED*/
2465 int
2467 {
2475 /* prepend link with dev_dir contents */
2479 /*
2480 * building extra link, so use first link as link contents, but first
2481 * make it relative.
2482 */
2489 }
2491 /* Count directories to go up, if any, and add "../" */
2496 }
2497 fpath++;
2498 }
2500 /*
2501 * Back up to the start of the current path component, in
2502 * case in the middle
2503 */
2505 tpath--;
2506 }
2512 }
2516 /*
2517 * we need to save the ultimate /devices contents, and not the
2518 * secondary link, since hotcleanup only looks at /devices path.
2519 * Since we don't have devices path here, we can try to get it
2520 * by readlink'ing the secondary link. This assumes the primary
2521 * link was created first.
2522 */
2527 }
2529 /*
2530 * If link exists or was just created, add it to the database
2531 */
2534 DI_SECONDARY_LINK);
2535 }
2538 }
2540 /* returns pointer to the devices directory */
2543 {
2545 }
2547 /*
2548 * Does the actual link creation. VERBOSE_MID only used if there is
2549 * a change. CHATTY_MID used otherwise.
2550 */
2551 static int
2553 {
2563 /* Database is not updated when file_mods == FALSE */
2565 /* we want *actual* link contents so no alias redirection */
2576 /* failure only in that the link existed */
2578 }
2582 }
2583 }
2585 /*
2586 * systems calls are expensive, so predict whether to readlink
2587 * or symlink first, based on previous attempt
2588 */
2593 }
2602 contents);
2604 /* link successfully created */
2612 /* dirpath to node doesn't exist */
2626 }
2627 }
2632 /*
2633 * If there is redirection, new phys path
2634 * and old phys path will not match and the
2635 * link will be created with new phys path
2636 * which is what we want. So we want real
2637 * contents.
2638 */
2650 "link exists and is correct:"
2653 /* failure in that the link existed */
2655 }
2659 /* not a symlink, remove and create */
2661 /* FALLTHROUGH */
2663 /* maybe it didn't exist at all */
2666 }
2667 }
2669 }
2670 }
2673 }
2675 static void
2677 {
2685 /*
2686 * We only want logindev perms to be set when a device is
2687 * hotplugged or an application requests synchronous creates.
2688 * So we enable this only in daemon mode. In addition,
2689 * login(1) only fixes the std. /dev dir. So we don't
2690 * change perms if alternate root is set.
2691 * login_dev_enable is TRUE only in these cases.
2692 */
2696 /*
2697 * Normally, /etc/logindevperm has few (8 - 10 entries) which
2698 * may be regular expressions (globs were converted to RE).
2699 * So just do a linear search through the list.
2700 */
2710 }
2711 }
2716 /*
2717 * we have a match, now find the driver associated with this
2718 * minor node using a snapshot on the physical path
2719 */
2721 /*
2722 * We dont need redirection here - the actual link contents
2723 * whether "alias" or "current" are fine
2724 */
2726 di_node_t node;
2731 /* truncate on : so we can take a snapshot */
2737 }
2752 }
2753 }
2754 /* search thru the driver list specified in logindevperm */
2763 }
2765 }
2770 }
2771 }
2776 }
2780 /*
2781 * We have a match. We now attempt to determine the
2782 * owner and group of the console user.
2783 *
2784 * stat() the console device newdev->ldev_console
2785 * which will always exist - it will have the right owner but
2786 * not the right group. Use getpwuid_r() to determine group for this
2787 * uid.
2788 * Note, it is safe to use name service here since if name services
2789 * are not available (during boot or in single-user mode), then
2790 * console owner will be root and its gid can be found in
2791 * local files.
2792 */
2797 }
2806 }
2816 }
2821 }
2822 }
2824 /*
2825 * Reset /devices node with appropriate permissions and
2826 * ownership as specified in /etc/minor_perm.
2827 */
2828 static void
2830 {
2833 mode_t mode;
2834 dev_t dev;
2835 uid_t uid;
2836 gid_t gid;
2840 /* lphy_path starts with / */
2844 /*NOTREACHED*/
2845 }
2872 /*
2873 * compare and set permissions and ownership
2874 *
2875 * Under devfs, a quick insertion and removal of USB devices
2876 * would cause stat of physical path to fail. In this case,
2877 * we emit a verbose message, but don't print errors.
2878 */
2882 }
2884 /*
2885 * If we are here for a new device
2886 * then
2887 * set ownership and permissions as specified in minor_perm
2888 * If we are here for an existing device
2889 * then
2890 * preserve existing/user-modified ownership and
2891 * permissions
2892 *
2893 * devfs indicates a new device by faking access time to be zero.
2894 */
2896 /*
2897 * Leave existing devices as they are.
2898 */
2900 }
2903 /* Nothing more to do if simulating */
2906 }
2912 }
2917 }
2919 /* Report that we actually did something */
2921 }
2923 /*
2924 * Removes logical link and the minor node it refers to. If file is a
2925 * link, we recurse and try to remove the minor node (or link if path is
2926 * a double link) that file's link contents refer to.
2927 */
2928 static void
2930 {
2940 /*
2941 * Note: we don't remove /devices (non-links) entries because they are
2942 * covered by devfs.
2943 */
2946 }
2948 /* split into multiple if's due to excessive indentations */
2953 /*
2954 * we dont care about the content of the symlink, so
2955 * redirection is not needed.
2956 */
2961 /*
2962 * recurse if link points to another link
2963 */
2976 }
2979 }
2980 }
2981 }
2990 }
2991 }
2993 void
2995 {
2997 }
2999 void
3001 {
3003 }
3005 static int
3007 {
3012 /*
3013 * Certain directories are created at install time by packages.
3014 * Some of them (listed in sticky_dirs[]) are required by apps
3015 * and need to be present even when empty.
3016 */
3028 }
3029 }
3030 }
3033 }
3035 /*
3036 * Try to remove any empty directories up the tree. It is assumed that
3037 * pathname is a file that was removed, so start with its parent, and
3038 * work up the tree.
3039 */
3040 static void
3042 {
3050 /*
3051 * ascend up the dir tree, deleting all empty dirs.
3052 * Return immediately if a dir is not empty.
3053 */
3058 }
3063 /* directory is empty */
3071 }
3073 /* some other file is here, so return */
3076 }
3077 }
3078 }
3080 /*
3081 * This function and all the functions it calls below were added to
3082 * handle the unique problem with world wide names (WWN). The problem is
3083 * that if a WWN device is moved to another address on the same controller
3084 * its logical link will change, while the physical node remains the same.
3085 * The result is that two logical links will point to the same physical path
3086 * in /devices, the valid link and a stale link. This function will
3087 * find all the stale nodes, though at a significant performance cost.
3088 *
3089 * Caching is used to increase performance.
3090 * A cache will be built from disk if the cache tag doesn't already exist.
3091 * The cache tag is a regular expression "dir_re", which selects a
3092 * subset of disks to search from typically something like
3093 * "dev/cXt[0-9]+d[0-9]+s[0-9]+". After the cache is built, consistency must
3094 * be maintained, so entries are added as new links are created, and removed
3095 * as old links are deleted. The whole cache is flushed if we are a daemon,
3096 * and another devfsadm process ran in between.
3097 *
3098 * Once the cache is built, this function finds the cache which matches
3099 * dir_re, and then it searches all links in that cache looking for
3100 * any link whose contents match "valid_link_contents" with a corresponding link
3101 * which does not match "valid_link". Any such matches are stale and removed.
3102 *
3103 * This happens outside the context of a "reparenting" so we dont need
3104 * redirection.
3105 */
3106 void
3108 di_minor_t minor)
3109 {
3117 /*
3118 * try to use devices path
3119 */
3126 /*NOTREACHED*/
3127 }
3134 }
3136 /*
3137 * As an optimization, check to make sure the corresponding
3138 * devlink was just created before continuing.
3139 */
3143 }
3150 /*
3151 * See hot_cleanup() for why we do this
3152 */
3160 /*
3161 * Use a copy of the cached link name as the
3162 * cache entry will go away during link removal
3163 */
3167 }
3168 }
3169 }
3171 /*
3172 * Return previously created cache, or create cache.
3173 */
3176 {
3177 recurse_dev_t rd;
3187 }
3188 }
3190 /*
3191 * This tag is not in cache, so add it, along with all its
3192 * matching /dev entries. This is the only time we go to disk.
3193 */
3202 }
3212 /* call build_devlink_list for each directory in the dir_re RE */
3217 }
3220 }
3222 static void
3224 {
3242 /*
3243 * None of the consumers of this function need redirection
3244 * so this readlink gets the "current" contents
3245 */
3248 /*
3249 * The first pass through the do loop we may readlink()
3250 * non-symlink files(EINVAL) from false regexec matches.
3251 * Suppress error messages in those cases or if the link
3252 * content is the empty string.
3253 */
3258 }
3263 /*
3264 * assume that link contents is really a pointer to
3265 * another link, so recurse and read its link contents.
3266 *
3267 * some link contents are absolute:
3268 * /dev/audio -> /dev/sound/0
3269 */
3278 }
3290 }
3294 }
3300 }
3309 /* don't store the '/' after rootdir/dev */
3319 }
3321 /*
3322 * to be consistent, devlink must not begin with / and must be
3323 * relative to /dev/, whereas physpath must contain / and be
3324 * relative to /devices.
3325 */
3326 static void
3328 {
3335 }
3344 added++;
3350 }
3351 }
3355 }
3357 /*
3358 * Remove devlink from cache. Devlink must be relative to /dev/ and not start
3359 * with /.
3360 */
3361 static void
3363 {
3379 /*
3380 * We are removing our caller's
3381 * "next" link. Update the nextlink
3382 * field in the head so that our
3383 * callers accesses the next valid
3384 * link
3385 */
3395 }
3396 }
3397 }
3398 }
3399 }
3401 static void
3403 {
3421 }
3425 }
3427 }
3429 /*
3430 * Called when the kernel has modified the incore path_to_inst data. This
3431 * function will schedule a flush of the data to the filesystem.
3432 */
3433 static void
3435 {
3439 /* signal instance thread */
3441 inst_count++;
3444 }
3446 static void
3448 {
3457 }
3462 /*
3463 * Wait MAX_IDLE_DELAY seconds after getting the last flush
3464 * path_to_inst event before invoking a flush, but never wait
3465 * more than MAX_DELAY seconds after getting the first event.
3466 */
3473 /* shorten the delay if we are idle */
3475 idle++;
3478 }
3481 }
3482 }
3487 }
3488 }
3490 /*
3491 * Helper function for flush_path_to_inst() below; this routine calls the
3492 * inst_sync syscall to flush the path_to_inst database to the given file.
3493 */
3494 static int
3496 {
3524 }
3526 }
3528 /*
3529 * Flush the kernel's path_to_inst database to /etc/path_to_inst. To do so
3530 * safely, the database is flushed to a temporary file, then moved into place.
3531 *
3532 * The following files are used during this process:
3533 * /etc/path_to_inst: The path_to_inst file
3534 * /etc/path_to_inst.<pid>: Contains data flushed from the kernel
3535 * /etc/path_to_inst.old: The backup file
3536 * /etc/path_to_inst.old.<pid>: Temp file for creating backup
3537 *
3538 */
3539 static void
3541 {
3557 }
3570 }
3575 /*NOTREACHED*/
3576 }
3578 /*
3579 * Now we deal with the somewhat tricky updating and renaming
3580 * of this critical piece of kernel state.
3581 */
3583 /*
3584 * Copy the current instance file into a temporary file.
3585 * Then rename the temporary file into the backup (.old)
3586 * file and rename the newly flushed kernel data into
3587 * the instance file.
3588 * Of course if 'inst_file' doesn't exist, there's much
3589 * less for us to do .. tee hee.
3590 */
3592 /*
3593 * No such file. Rename the new onto the old
3594 */
3598 /*NOTREACHED*/
3599 }
3606 }
3609 /*
3610 * Can't open the 'old_inst_file' file for writing.
3611 * This is somewhat strange given that the syscall
3612 * just succeeded to write a file out.. hmm.. maybe
3613 * the fs just filled up or something nasty.
3614 *
3615 * Anyway, abort what we've done so far.
3616 */
3620 /*NOTREACHED*/
3621 }
3623 /*
3624 * Copy current instance file into the temporary file
3625 */
3630 }
3631 }
3637 /* NOTREACHED */
3638 }
3640 /*
3641 * Set permissions to be the same on the backup as
3642 * /etc/path_to_inst.
3643 */
3646 /*
3647 * So far, everything we've done is more or less reversible.
3648 * But now we're going to commit ourselves.
3649 */
3660 }
3662 out:
3666 }
3667 }
3671 }
3676 }
3683 }
3684 }
3686 /*
3687 * detach from tty. For daemon mode.
3688 */
3689 void
3691 {
3695 }
3706 }
3708 /*
3709 * Use an advisory lock to synchronize updates to /dev. If the lock is
3710 * held by another process, block in the fcntl() system call until that
3711 * process drops the lock or exits. The lock file itself is
3712 * DEV_LOCK_FILE. The process id of the current and last process owning
3713 * the lock is kept in the lock file. After acquiring the lock, read the
3714 * process id and return it. It is the process ID which last owned the
3715 * lock, and will be used to determine if caches need to be flushed.
3716 *
3717 * NOTE: if the devlink database is held open by the caller, it may
3718 * be closed by this routine. This is to enforce the following lock ordering:
3719 * 1) /dev lock 2) database open
3720 */
3721 pid_t
3723 {
3726 pid_t pid;
3727 pid_t last_owner_pid;
3731 }
3742 /*NOTREACHED*/
3743 }
3750 /* try for the lock, but don't wait */
3761 /*NOTREACHED*/
3762 }
3763 /*
3764 * wait for the dev lock. If we have the database open,
3765 * close it first - the order of lock acquisition should
3766 * always be: 1) dev_lock 2) database
3767 * This is to prevent deadlocks with any locks the
3768 * database code may hold.
3769 */
3772 /* send any sysevents that were queued up. */
3779 /*NOTREACHED*/
3780 }
3781 }
3782 }
3789 }
3796 /*NOTREACHED*/
3797 }
3803 /*NOTREACHED*/
3804 }
3807 }
3809 /*
3810 * Drop the advisory /dev lock, close lock file. Close and re-open the
3811 * file every time so to ensure a resync if for some reason the lock file
3812 * gets removed.
3813 */
3814 void
3816 {
3821 }
3833 }
3841 /*NOTREACHED*/
3842 }
3843 }
3845 /*
3846 *
3847 * Use an advisory lock to ensure that only one daemon process is active
3848 * in the system at any point in time. If the lock is held by another
3849 * process, do not block but return the pid owner of the lock to the
3850 * caller immediately. The lock is cleared if the holding daemon process
3851 * exits for any reason even if the lock file remains, so the daemon can
3852 * be restarted if necessary. The lock file is DAEMON_LOCK_FILE.
3853 */
3854 pid_t
3856 {
3868 /*NOTREACHED*/
3869 }
3883 /*NOTREACHED*/
3884 }
3886 }
3887 }
3890 }
3892 /*
3893 * Drop the advisory daemon lock, close lock file
3894 */
3895 void
3897 {
3902 }
3914 }
3920 /*NOTREACHED*/
3921 }
3922 }
3924 /*
3925 * Called to removed danging nodes in two different modes: RM_PRE, RM_POST.
3926 * RM_PRE mode is called before processing the entire devinfo tree, and RM_POST
3927 * is called after processing the entire devinfo tree.
3928 */
3929 static void
3931 {
3933 recurse_dev_t rd;
3934 cleanup_data_t cleanup_data;
3944 /*
3945 * the generic function recurse_dev_re is shared among different
3946 * functions, so set the method and data that it should use for
3947 * matches.
3948 */
3959 /*
3960 * If reached this point, RM_PRE or RM_POST cleanup is
3961 * desired. clean_ok() decides whether to clean
3962 * under the given circumstances.
3963 */
3969 }
3970 }
3971 }
3974 }
3976 /*
3977 * clean_ok() determines whether cleanup should be done according
3978 * to the following matrix:
3979 *
3980 * command line arguments RM_PRE RM_POST RM_PRE && RM_POST &&
3981 * RM_ALWAYS RM_ALWAYS
3982 * ---------------------- ------ ----- --------- ----------
3983 *
3984 * <neither -c nor -C> - - pre-clean post-clean
3985 *
3986 * -C pre-clean post-clean pre-clean post-clean
3987 *
3988 * -C -c class pre-clean post-clean pre-clean post-clean
3989 * if class if class if class if class
3990 * matches matches matches matches
3991 *
3992 * -c class - - pre-clean post-clean
3993 * if class if class
3994 * matches matches
3995 *
3996 */
3997 static int
3999 {
4003 /* no cleanup at all when using -i option */
4005 }
4007 /*
4008 * no cleanup if drivers are not loaded. We make an exception
4009 * for the "disks" program however, since disks has a public
4010 * cleanup flag (-C) and disk drivers are usually never
4011 * unloaded.
4012 */
4015 }
4017 /* if the cleanup flag was not specified, return false */
4020 }
4024 }
4026 /*
4027 * if reached this point, check to see if the class in the given
4028 * remove structure matches a class given on the command line
4029 */
4034 }
4035 }
4038 }
4040 /*
4041 * Called to remove dangling nodes after receiving a hotplug event
4042 * containing the physical node pathname to be removed.
4043 */
4044 void
4047 {
4059 /*
4060 * dev links can go away as part of hot cleanup.
4061 * So first build event attributes in order capture dev links.
4062 */
4084 /*
4085 * The remove callback below may remove
4086 * the current and/or any or all of the
4087 * subsequent links in the list.
4088 * Save the next link in the head. If
4089 * the callback removes the next link
4090 * the saved pointer in the head will be
4091 * updated by the callback to point at
4092 * the next valid link.
4093 */
4096 /*
4097 * if devlink is in no-further-process hash,
4098 * skip its remove
4099 */
4105 else
4107 path_len);
4110 DEVFSADM_FAILURE))
4116 /*
4117 * Use a copy of the cached link name
4118 * as the cache entry will go away
4119 * during link removal
4120 */
4131 }
4132 }
4133 }
4134 }
4139 /* now log an event */
4143 }
4144 }
4146 /*
4147 * Open the dir current_dir. For every file which matches the first dir
4148 * component of path_re, recurse. If there are no more *dir* path
4149 * components left in path_re (ie no more /), then call function rd->fcn.
4150 */
4151 static void
4153 {
4154 regex_t re1;
4159 finddevhdl_t fhandle;
4171 }
4179 }
4186 /* match */
4197 /* reached the leaf component of path_re */
4201 }
4202 }
4203 }
4207 out:
4209 }
4211 /*
4212 * Found a devpath which matches a RE in the remove structure.
4213 * Now check to see if it is dangling.
4214 */
4215 static void
4217 {
4224 devpath);
4226 /*
4227 * If the link is in the no-further-process hash
4228 * don't do any remove operation on it.
4229 */
4233 /*
4234 * Dangling check will work whether "alias" or "current"
4235 * so no need to redirect.
4236 */
4239 DEVFSADM_FAILURE) {
4241 }
4253 /*
4254 * We want no further remove processing for
4255 * this link. Add it to the nfp_hash;
4256 */
4258 }
4259 }
4260 }
4261 }
4263 int
4265 {
4271 /* prepend link with dev_dir contents */
4276 /* We *don't* want a stat of the /devices node */
4280 /* redirect if alias to current */
4283 }
4285 }
4287 int
4289 {
4294 /* prepend link with dev_dir contents */
4301 }
4309 }
4311 /*
4312 * resolve alias paths for primary links
4313 */
4318 }
4320 /*
4321 * The link exists. Add it to the database
4322 */
4327 }
4329 /*
4330 * devpath: Absolute path to /dev link
4331 * content_p: Returns malloced string (link content)
4332 * type_p: Returns link type: primary or secondary
4333 * devfs_path: Returns malloced string: /devices path w/out "/devices"
4334 * dangle: if set, check if link is dangling
4335 * Returns:
4336 * TRUE if dangling
4337 * FALSE if not or if caller doesn't care
4338 * Caller is assumed to have initialized pointer contents to NULL
4339 *
4340 */
4341 static int
4344 {
4353 /*
4354 * This routine will return the "raw" contents. It is upto the
4355 * the caller to redirect "alias" to "current" (or vice versa)
4356 */
4363 }
4368 }
4370 /*
4371 * Check to see if this is a link pointing to another link in /dev. The
4372 * cheap way to do this is to look for a lack of ../devices/.
4373 */
4379 }
4381 /*
4382 * assume that linkcontents is really a pointer to another
4383 * link, and if so recurse and read its link contents.
4384 */
4395 }
4401 }
4403 dangle));
4404 }
4406 /* Current link points at a /devices minor node */
4409 }
4422 }
4424 /*
4425 * Returns the substring of interest, given a path.
4426 */
4429 {
4430 uint_t match;
4438 /*
4439 * extract match flags from the flags argument.
4440 */
4446 /*
4447 * MATCH_CALLBACK and MATCH_ALL are the only flags
4448 * which may be used if "path" is a /dev path
4449 */
4455 }
4458 }
4464 }
4466 /*
4467 * The remaining flags make sense only for /devices
4468 * paths
4469 */
4474 }
4477 /* A NULL "match_arg" values implies entire minor */
4482 }
4484 }
4489 }
4496 }
4502 }
4504 }
4506 /* ap can be NULL - Leaf address may not exist or be empty string */
4509 /* minor is no longer of interest */
4517 /*
4518 * The empty string is a valid address. The only MATCH_ADDR
4519 * allowed in this case is against the whole address or
4520 * the first component of the address (match_arg=NULL/"0"/"1")
4521 * Note that in this case, the path won't have an "@"
4522 * As a result ap will be NULL. We fake up an ap = @'\0'
4523 * so that get_component() will work correctly.
4524 */
4527 }
4533 }
4535 }
4540 /*FALLTHRU*/
4541 err:
4544 }
4547 /*
4548 * "str" is expected to be a string with components separated by ','
4549 * The terminating null char is considered a separator.
4550 * get_component() will remove the portion of the string beyond
4551 * the component indicated.
4552 * If comp_str is NULL, the entire "str" is returned.
4553 */
4556 {
4562 }
4566 }
4572 }
4579 comp--;
4582 }
4583 }
4589 }
4592 }
4595 /*
4596 * Enumerate serves as a generic counter as well as a means to determine
4597 * logical unit/controller numbers for such items as disk and tape
4598 * drives.
4599 *
4600 * rules[] is an array of devfsadm_enumerate_t structures which defines
4601 * the enumeration rules to be used for a specified set of links in /dev.
4602 * The set of links is specified through regular expressions (of the flavor
4603 * described in regex(5)). These regular expressions are used to determine
4604 * the set of links in /dev to examine. The last path component in these
4605 * regular expressions MUST contain a parenthesized subexpression surrounding
4606 * the RE which is to be considered the enumerating component. The subexp
4607 * member in a rule is the subexpression number of the enumerating
4608 * component. Subexpressions in the last path component are numbered starting
4609 * from 1.
4610 *
4611 * A cache of current id assignments is built up from existing symlinks and
4612 * new assignments use the lowest unused id. Assignments are based on a
4613 * match of a specified substring of a symlink's contents. If the specified
4614 * component for the devfs_path argument matches the corresponding substring
4615 * for a existing symlink's contents, the cached id is returned. Else, a new
4616 * id is created and returned in *buf. *buf must be freed by the caller.
4617 *
4618 * An id assignment may be governed by a combination of rules, each rule
4619 * applicable to a different subset of links in /dev. For example, controller
4620 * numbers may be determined by a combination of disk symlinks in /dev/[r]dsk
4621 * and controller symlinks in /dev/cfg, with the two sets requiring different
4622 * rules to derive the "substring of interest". In such cases, the rules
4623 * array will have more than one element.
4624 */
4625 int
4628 {
4631 }
4633 int
4636 {
4639 }
4641 /*
4642 * Same as above, but allows a starting value to be specified.
4643 * Private to devfsadm.... used by devlinks.
4644 */
4645 static int
4648 {
4651 }
4653 /*
4654 * devfsadm_enumerate_char serves as a generic counter returning
4655 * a single letter.
4656 */
4657 int
4660 {
4663 }
4665 /*
4666 * Same as above, but allows a starting char to be specified.
4667 * Private to devfsadm - used by ports module (port_link.c)
4668 */
4669 int
4672 {
4675 }
4678 /*
4679 * For a given numeral_set (see get_cached_set for desc of numeral_set),
4680 * search all cached entries looking for matches on a specified substring
4681 * of devfs_path. The substring is derived from devfs_path based on the
4682 * rule specified by "index". If a match is found on a cached entry,
4683 * return the enumerated id in buf. Otherwise, create a new id by calling
4684 * new_id, then cache and return that entry.
4685 */
4686 static int
4690 {
4702 }
4707 }
4713 }
4721 }
4726 }
4730 /*
4731 * Check and see if a matching entry is already cached.
4732 */
4740 else
4742 }
4744 /* if matching entry already cached, return it */
4746 /* should never create a link with a reserved ID */
4752 }
4754 /*
4755 * no cached entry, initialize a numeral struct
4756 * by calling new_id() and cache onto the numeral_set
4757 */
4769 /* insert to head of list for fast lookups */
4775 }
4778 /*
4779 * Looks up the specified cache for a match with a specified string
4780 * Returns:
4781 * -1 : on error.
4782 * 0/1/2 : Number of matches.
4783 * Returns the matching element only if there is a single match.
4784 * If the "uncached" flag is set, derives the "cmp_str" afresh
4785 * for the match instead of using cached values.
4786 */
4787 static int
4790 {
4803 }
4808 }
4810 /*
4811 * Check and see if a matching entry is already cached.
4812 */
4815 /*
4816 * Skip reserved IDs
4817 */
4820 "Cannot Match with reserved ID (%s), "
4826 "Attempting match with numeral ID: %s"
4829 }
4835 }
4848 }
4853 }
4855 }
4856 }
4859 }
4861 #ifdef DEBUG
4862 static void
4864 {
4872 }
4880 }
4881 }
4882 #endif
4884 /*
4885 * For a given set of regular expressions in rules[], this function returns
4886 * either a previously cached struct numeral_set or it will create and
4887 * cache a new struct numeral_set. There is only one struct numeral_set
4888 * for the combination of REs present in rules[]. Each numeral_set contains
4889 * the regular expressions in rules[] used for cache selection AND a linked
4890 * list of struct numerals, ONE FOR EACH *UNIQUE* numeral or character ID
4891 * selected by the grouping parenthesized subexpression found in the last
4892 * path component of each rules[].re. For example, the RE: "rmt/([0-9]+)"
4893 * selects all the logical nodes of the correct form in dev/rmt/.
4894 * Each rmt/X will store a *single* struct numeral... ie 0, 1, 2 each get a
4895 * single struct numeral. There is no need to store more than a single logical
4896 * node matching X since the information desired in the devfspath would be
4897 * identical for the portion of the devfspath of interest. (the part up to,
4898 * but not including the minor name in this example.)
4899 *
4900 * If the given numeral_set is not yet cached, call enumerate_recurse to
4901 * create it.
4902 */
4905 {
4906 /* linked list of numeral sets */
4914 /*
4915 * See if we've already cached this numeral set.
4916 */
4918 /*
4919 * check all regexp's passed in function against
4920 * those in cached set.
4921 */
4924 }
4929 }
4930 }
4934 }
4935 }
4937 /*
4938 * If the MATCH_UNCACHED flag is set, we should not be here.
4939 */
4945 }
4946 }
4948 /*
4949 * Since we made it here, we have not yet cached the given set of
4950 * logical nodes matching the passed re. Create a cached entry
4951 * struct numeral_set and populate it with a minimal set of
4952 * logical nodes from /dev.
4953 */
4959 }
4963 /* put this new cached set on the cached set list */
4967 /*
4968 * For each RE, search the "reserved" list to create numeral IDs that
4969 * are reserved.
4970 */
4982 /*
4983 * We found the reserved ID for this entry.
4984 * We still keep the entry since it is needed
4985 * by the new link bypass code in disks
4986 */
4990 }
4991 }
4992 }
4994 /*
4995 * For each RE, search disk and cache any matches on the
4996 * numeral list.
4997 */
5002 }
5004 #ifdef DEBUG
5006 #endif
5009 }
5012 /*
5013 * This function stats the pathname namebuf. If this is a directory
5014 * entry, we recurse down dname/fname until we find the first symbolic
5015 * link, and then stat and return it. This is valid for the same reason
5016 * that we only need to read a single pathname for multiple matching
5017 * logical ID's... ie, all the logical nodes should contain identical
5018 * physical paths for the parts we are interested.
5019 */
5020 int
5022 {
5024 finddevhdl_t fhandle;
5030 }
5034 }
5036 /*
5037 * If it is a dir, recurse down until we find a link and
5038 * then use the link.
5039 */
5044 }
5046 /*
5047 * Search each dir entry looking for a symlink. Return
5048 * the first symlink found in namebuf. Recurse dirs.
5049 */
5057 }
5061 }
5063 }
5065 }
5067 /* no symlink found, so return error */
5069 }
5071 /*
5072 * An existing matching ID was not found, so this function is called to
5073 * create the next lowest ID. In the INTEGER case, return the next
5074 * lowest unused integer. In the case of LETTER, return the next lowest
5075 * unused letter. Return empty string if all 26 are used.
5076 * Only IDs >= min will be returned.
5077 */
5080 {
5096 }
5100 }
5106 }
5116 }
5117 }
5120 }
5126 }
5130 /* sort list */
5144 }
5146 }
5149 }
5150 }
5152 /* now search sorted list for first hole >= imin */
5155 imin++;
5159 }
5160 }
5162 }
5164 /* free temp list */
5169 }
5173 }
5176 }
5178 static int
5181 {
5198 }
5200 }
5207 /* get rid of any extra '/' in the reserve string */
5209 rsvstr++;
5210 }
5212 /* get rid of any extra '/' in the RE */
5214 path_left++;
5215 }
5219 }
5222 }
5228 }
5230 /*
5231 * Returns true if path_left matches the list entry.
5232 * If it is the last path component, pass subexp
5233 * so that it will return the corresponding ID in
5234 * numeral_id.
5235 */
5240 /* We have a match. */
5242 /* Is last path component */
5247 }
5251 /* Not last path component. Continue parsing */
5259 }
5261 /* No match */
5266 }
5267 }
5269 out:
5281 }
5284 }
5286 /*
5287 * Search current_dir for all files which match the first path component
5288 * of path_left, which is an RE. If a match is found, but there are more
5289 * components of path_left, then recurse, otherwise, if we have reached
5290 * the last component of path_left, call create_cached_numerals for each
5291 * file. At some point, recurse_dev_re() should be rewritten so that this
5292 * function can be eliminated.
5293 */
5294 static void
5297 {
5301 finddevhdl_t fhandle;
5306 }
5308 /* get rid of any extra '/' */
5310 path_left++;
5311 }
5315 }
5319 /*
5320 * Returns true if path_left matches the list entry.
5321 * If it is the last path component, pass subexp
5322 * so that it will return the corresponding ID in
5323 * numeral_id.
5324 */
5344 }
5345 }
5347 }
5348 }
5352 }
5354 }
5357 /*
5358 * Returns true if file matches file_re. If subexp is non-zero, it means
5359 * we are searching the last path component and need to return the
5360 * parenthesized subexpression subexp in id.
5361 *
5362 */
5363 static int
5365 {
5366 regex_t re1;
5373 pmatch =
5378 }
5383 }
5385 }
5389 }
5396 }
5400 }
5403 }
5405 static void
5407 {
5411 numeral_id);
5413 /*
5414 * We found a numeral_id from an entry in the enumerate_reserved file
5415 * which matched the re passed in from devfsadm_enumerate. We only
5416 * need to make sure ONE copy of numeral_id exists on the numeral list.
5417 * We only need to store /dev/dsk/cNtod0s0 and no other entries
5418 * hanging off of controller N.
5419 */
5428 }
5429 }
5431 /* NOT on list, so add it */
5442 }
5444 /*
5445 * This function is called for every file which matched the leaf
5446 * component of the RE. If the "numeral_id" is not already on the
5447 * numeral set's numeral list, add it and its physical path.
5448 */
5449 static void
5452 {
5465 /*
5466 * We found a numeral_id from an entry in /dev which matched
5467 * the re passed in from devfsadm_enumerate. We only need to make sure
5468 * ONE copy of numeral_id exists on the numeral list. We only need
5469 * to store /dev/dsk/cNtod0s0 and no other entries hanging off
5470 * of controller N.
5471 */
5475 /*
5476 * Note that we can't assert that the flags field
5477 * of the numeral is 0, since both reserved and
5478 * unreserved links in /dev come here
5479 */
5486 }
5488 }
5489 }
5491 /* NOT on list, so add it */
5494 /*
5495 * If path is a dir, it is changed to the first symbolic link it find
5496 * if it finds one.
5497 */
5500 }
5502 /* If we get here, we found a symlink */
5508 }
5512 /*
5513 * redirect alias path to current path
5514 * devi_root_node is protected by lock_dev()
5515 */
5518 /*
5519 * the following just points linkptr to the root of the /devices
5520 * node if it is a minor node, otherwise, to the first char of
5521 * linkbuf if it is a link.
5522 */
5529 }
5543 }
5546 /*
5547 * This should be called either before or after granting access to a
5548 * command line version of devfsadm running, since it may have changed
5549 * the state of /dev. It forces future enumerate calls to re-build
5550 * cached information from /dev.
5551 */
5552 void
5554 {
5562 /*
5563 * check all regexp's passed in function against
5564 * those in cached set.
5565 */
5572 }
5583 }
5585 }
5587 }
5589 /*
5590 * Copies over links from /dev to <root>/dev and device special files in
5591 * /devices to <root>/devices, preserving the existing file modes. If
5592 * the link or special file already exists on <root>, skip the copy. (it
5593 * would exist only if a package hard coded it there, so assume package
5594 * knows best?). Use /etc/name_to_major and <root>/etc/name_to_major to
5595 * make translations for major numbers on device special files. No need to
5596 * make a translation on minor_perm since if the file was created in the
5597 * miniroot then it would presumably have the same minor_perm entry in
5598 * <root>/etc/minor_perm. To be used only by install.
5599 */
5600 int
5602 {
5605 /* load the installed root's name_to_major for translations */
5607 NAME_TO_MAJOR);
5610 }
5612 /* Copy /dev to target disk. No need to copy /devices with devfs */
5615 /* Let install handle copying over path_to_inst */
5618 }
5620 /*
5621 * This function copies links, dirs, and device special files.
5622 * Note that it always returns DEVFSADM_SUCCESS, so that nftw doesn't
5623 * abort.
5624 */
5625 /*ARGSUSED*/
5626 static int
5629 {
5631 dev_t newdev;
5642 /* newfile already exists, so no need to continue */
5644 }
5649 DEVFSADM_FAILURE) {
5651 }
5655 }
5660 }
5662 /*
5663 * No need to redirect alias paths. We want a
5664 * true copy. The system on first boot after install
5665 * will redirect paths
5666 */
5670 }
5676 }
5677 }
5681 }
5683 /*
5684 * Given a dev_t from the running kernel, return the new_dev_t
5685 * by translating to the major number found on the installed
5686 * target's root name_to_major file.
5687 */
5688 static int
5690 {
5691 major_t oldmajor;
5692 major_t newmajor;
5693 minor_t oldminor;
5694 minor_t newminor;
5702 }
5705 /* non-clone case */
5707 /* look up major number is target's name2major */
5710 }
5717 }
5720 /*
5721 * The clone is a special case. Look at its minor
5722 * number since it is the major number of the real driver.
5723 */
5726 }
5733 }
5737 }
5745 }
5747 }
5748 }
5750 /*
5751 *
5752 * Find the major number for driver, searching the n2m_list that was
5753 * built in load_n2m_table().
5754 */
5755 static int
5757 {
5764 }
5765 }
5768 }
5770 /*
5771 * Loads a name_to_major table into memory. Used only for suninstall's
5772 * private -R option to devfsadm, to translate major numbers from the
5773 * running to the installed target disk.
5774 */
5775 static int
5777 {
5781 major_t major;
5788 }
5791 ln++;
5792 /* cut off comments starting with '#' */
5795 /* ignore comment or blank lines */
5798 /* sanity-check */
5802 }
5808 }
5811 }
5813 }
5815 /*
5816 * Called at devfsadm startup to read the file /etc/dev/enumerate_reserved
5817 * Creates a linked list of devlinks from which reserved IDs can be derived
5818 */
5819 static void
5821 {
5837 enumerate_file);
5838 }
5845 }
5847 }
5849 /* if already cached, check to see if it is still valid */
5856 }
5867 }
5871 enumerate_file);
5873 }
5880 }
5887 linenum++;
5889 /* remove newline */
5896 /* skip over space and tab */
5898 ;
5903 }
5907 /* delete trailing blanks */
5909 ;
5917 }
5921 }
5922 }
5924 /*
5925 * Called at devfsadm startup to read in the devlink.tab file. Creates
5926 * a linked list of devlinktab_list structures which will be
5927 * searched for every minor node.
5928 */
5929 static void
5931 {
5948 }
5952 /* if already cached, check to see if it is still valid */
5958 }
5970 }
5974 }
5977 }
5984 }
5989 devlinktab_line++;
5997 ;
5999 }
6001 /* cut off comments starting with '#' */
6004 /* ignore comment or blank lines */
6011 /* break each entry into fields. s_link may be NULL */
6020 }
6022 entryp =
6031 }
6039 }
6052 }
6058 }
6060 /* append to end of list */
6065 }
6068 }
6070 }
6072 /*
6073 *
6074 * For a single line entry in devlink.tab, split the line into fields
6075 * selector, p_link, and an optionally s_link. If s_link field is not
6076 * present, then return NULL in s_link (not NULL string).
6077 */
6078 static int
6081 {
6092 }
6097 }
6104 devlinktab_file);
6106 }
6109 }
6112 }
6114 /*
6115 * For a given devfs_spec field, for each element in the field, add it to
6116 * a linked list of devfs_spec structures. Return the linked list in
6117 * devfs_spec_list.
6118 */
6121 {
6128 /* parse_devfs_spec splits the next field into keyword & value */
6153 }
6167 }
6175 }
6181 }
6182 }
6187 /* parse failed. Free any allocated structs */
6190 }
6191 }
6193 /*
6194 * Takes a semicolon separated list of selector elements and breaks up
6195 * into a keyword-value pair. semicolon and equal characters are
6196 * replaced with NULL's. On success, selector is updated to point to the
6197 * terminating NULL character terminating the keyword-value pair, and the
6198 * function returns DEVFSADM_SUCCESS. If there is a syntax error,
6199 * devfs_spec is not modified and function returns DEVFSADM_FAILURE.
6200 */
6201 static int
6203 {
6214 }
6222 }
6224 }
6226 /*
6227 * link is either the second or third field of devlink.tab. Parse link
6228 * into a linked list of devlink structures and return ptr to list. Each
6229 * list element is either a constant string, or one of the following
6230 * escape sequences: \M, \A, \N, or \D. The first three escape sequences
6231 * take a numerical argument.
6232 */
6235 {
6247 }
6254 /* a non-escaped string */
6256 }
6274 error_str =
6280 }
6290 }
6302 }
6303 }
6304 }
6305 /* append link_list struct to end of list */
6308 ;
6310 }
6311 }
6317 error_str);
6320 }
6321 }
6323 /*
6324 * Called for each minor node devfsadm processes; for each minor node,
6325 * look for matches in the devlinktab_list list which was created on
6326 * startup read_devlinktab_file(). If there is a match, call build_links()
6327 * to build a logical devlink and a possible extra devlink.
6328 */
6329 static int
6331 {
6345 }
6347 }
6350 /* don't process devlink.tab if devfsadm invoked with -c <class> */
6353 }
6359 }
6360 }
6362 }
6364 /*
6365 * For a given devlink.tab devlinktab_list entry, see if the selector
6366 * field matches this minor node. If it does, return DEVFSADM_SUCCESS,
6367 * otherwise DEVFSADM_FAILURE.
6368 */
6369 static int
6371 {
6382 }
6389 }
6394 }
6398 }
6403 }
6404 }
6409 }
6413 }
6418 }
6419 }
6423 }
6424 }
6427 }
6429 /*
6430 * For the given minor node and devlinktab_list entry from devlink.tab,
6431 * build a logical dev link and a possible extra devlink.
6432 * Return DEVFSADM_SUCCESS if link is created, otherwise DEVFSADM_FAILURE.
6433 */
6434 static int
6436 {
6445 /*NOTREACHED*/
6446 }
6456 }
6461 }
6466 }
6471 }
6473 /*
6474 * The counter rule for devlink.tab entries is implemented via
6475 * devfsadm_enumerate_int_start(). One of the arguments to this function
6476 * is a path, where each path component is treated as a regular expression.
6477 * For devlink.tab entries, this path regular expression is derived from
6478 * the devlink spec. get_anchored_re() accepts path regular expressions derived
6479 * from devlink.tab entries and inserts the anchors '^' and '$' at the beginning
6480 * and end respectively of each path component. This is done to prevent
6481 * false matches. For example, without anchors, "a/([0-9]+)" will match "ab/c9"
6482 * and incorrect links will be generated.
6483 */
6484 static int
6486 {
6490 }
6496 link++;
6501 }
6506 }
6507 }
6508 }
6512 }
6514 static int
6517 {
6544 }
6554 }
6563 }
6564 }
6567 /*
6568 * copy anything appended after "([0-9]+)" into
6569 * templink
6570 */
6577 }
6584 }
6589 }
6591 }
6593 /*
6594 * Compares "field" number of the comma separated list "full_name" with
6595 * field_item. Returns DEVFSADM_SUCCESS for match,
6596 * DEVFSADM_FAILURE for no match.
6597 */
6598 static int
6600 {
6604 field--;
6605 }
6606 }
6610 }
6616 }
6617 }
6621 }
6627 }
6629 /*
6630 * strcat() field # "field" of comma separated list "name" to "link".
6631 * Field 0 is the entire name.
6632 * Return DEVFSADM_SUCCESS or DEVFSADM_FAILURE.
6633 */
6634 static int
6636 {
6640 }
6645 }
6648 link++;
6649 }
6655 }
6656 }
6660 }
6664 }
6668 }
6670 static void
6672 {
6680 }
6681 }
6683 static void
6685 {
6693 }
6695 }
6696 }
6698 /*
6699 * Prints only if level matches one of the debug levels
6700 * given on command line. INFO_MID is always printed.
6701 *
6702 * See devfsadm.h for a listing of globally defined levels and
6703 * meanings. Modules should prefix the level with their
6704 * module name to prevent collisions.
6705 */
6706 /*PRINTFLIKE2*/
6707 void
6709 {
6718 }
6721 }
6722 }
6725 }
6726 }
6735 }
6746 }
6748 }
6749 }
6755 }
6757 }
6759 /*
6760 * print error messages to the terminal or to syslog
6761 */
6762 /*PRINTFLIKE1*/
6763 void
6765 {
6775 }
6777 }
6779 /*
6780 * return noupdate state (-s)
6781 */
6782 int
6784 {
6786 }
6788 /*
6789 * return current root update path (-r)
6790 */
6793 {
6798 }
6799 }
6801 void
6803 {
6809 }
6811 /*
6812 * Return all devlinks corresponding to phys_path as an array of strings.
6813 * The number of entries in the array is returned through lenp.
6814 * devfsadm_free_dev_names() is used to free the returned array.
6815 * NULL is returned on failure or when there are no matching devlinks.
6816 *
6817 * re is an extended regular expression in regex(5) format used to further
6818 * match devlinks pointing to phys_path; it may be NULL to match all
6819 */
6822 {
6846 }
6847 }
6850 out:
6853 }
6855 /* common exit function which ensures releasing locks */
6856 static void
6858 {
6861 }
6868 }
6871 /*NOTREACHED*/
6872 }
6874 /*
6875 * set root_dir, devices_dir, dev_dir using optarg.
6876 */
6877 static void
6879 {
6889 }
6891 /*
6892 * Removes quotes.
6893 */
6896 {
6908 }
6910 }
6912 /*
6913 * For a given physical device pathname and spectype, return the
6914 * ownership and permissions attributes by looking in data from
6915 * /etc/minor_perm. If currently in installation mode, check for
6916 * possible major number translations from the miniroot to the installed
6917 * root's name_to_major table. Note that there can be multiple matches,
6918 * but the last match takes effect. pts seems to rely on this
6919 * implementation behavior.
6920 */
6921 static void
6924 {
6935 major_t major_no;
6938 /*
6939 * Get the driver name based on the major number since the name
6940 * in /devices may be generic. Could be running with more major
6941 * numbers than are in /etc/name_to_major, so get it from the kernel
6942 */
6946 /* return default values */
6948 }
6953 /* component */
6957 }
6965 }
6972 }
6975 /*
6976 * mp->mp_drvname = device name from minor_perm
6977 * mp->mp_minorname = minor part of device name from
6978 * minor_perm
6979 * drvname = name of driver for this device
6980 */
6984 mp_drvname_matches_node_name =
6986 mp_drvname_matches_minor_name =
6988 mp_drvname_is_clone =
6990 mp_drvname_matches_drvname =
6993 /*
6994 * If one of the following cases is true, then we try to change
6995 * the permissions if a "shell global pattern match" of
6996 * mp_>mp_minorname matches minor_name.
6997 *
6998 * 1. mp->mp_drvname matches driver.
6999 *
7000 * OR
7001 *
7002 * 2. mp->mp_drvname matches node_name and this
7003 * name is an alias of the driver name
7004 *
7005 * OR
7006 *
7007 * 3. /devices entry is the clone device and either
7008 * minor_perm entry is the clone device or matches
7009 * the minor part of the clone device.
7010 */
7018 /*
7019 * Check that the minor part of the
7020 * device name from the minor_perm
7021 * entry matches and if so, set the
7022 * permissions.
7023 *
7024 * Under real devfs, clone minor name is changed
7025 * to match the driver name, but minor_perm may
7026 * not match. We reconcile it here.
7027 */
7036 }
7037 }
7038 }
7042 }
7044 use_defaults:
7045 /* not found in minor_perm, so just use default values */
7049 }
7051 /*
7052 * Called by devfs_read_minor_perm() to report errors
7053 * key is:
7054 * line number: ignoring line number error
7055 * errno: open/close errors
7056 * size: alloc errors
7057 */
7058 static void
7060 {
7083 }
7084 }
7086 static void
7088 {
7095 /* If already cached, check to see if it is still valid */
7101 }
7106 }
7113 }
7115 static void
7117 {
7121 }
7125 {
7138 }
7140 }
7149 }
7151 static void
7153 {
7165 /* Read logindevperm only when enabled */
7174 }
7188 }
7190 }
7193 }
7200 }
7205 /* Not fatal to devfsadm */
7209 }
7213 ln++;
7215 /* Remove comments */
7225 }
7227 /*
7228 * permstr is string in octal format. Convert to int
7229 */
7236 }
7241 }
7251 /*
7252 * the logical device name may contain '*' which
7253 * we convert to a regular expression
7254 */
7263 }
7267 }
7279 /*
7280 * create a linked list of driver
7281 * names
7282 */
7292 }
7293 }
7294 }
7295 }
7297 }
7299 /*
7300 * Tokens are separated by ' ', '\t', ':', '=', '&', '|', ';', '\n', or '\0'
7301 *
7302 * Returns DEVFSADM_SUCCESS if token found, DEVFSADM_FAILURE otherwise.
7303 */
7304 static int
7306 {
7314 }
7320 }
7321 /*
7322 * If terminating character is a space or tab, look ahead to see if
7323 * there's another terminator that's not a space or a tab.
7324 * (This code handles trailing spaces.)
7325 */
7329 ;
7334 }
7335 }
7340 }
7341 }
7346 }
7349 }
7351 /*
7352 * read or reread the driver aliases file
7353 */
7354 static void
7356 {
7373 /* If already cached, check to see if it is still valid */
7379 }
7388 }
7391 }
7400 /*NOTREACHED*/
7401 }
7404 ln++;
7405 /* cut off comments starting with '#' */
7408 /* ignore comment or blank lines */
7415 }
7419 }
7428 }
7432 p++;
7433 }
7434 }
7442 }
7443 }
7446 }
7447 }
7449 /*
7450 * return TRUE if alias_name is an alias for driver_name, otherwise
7451 * return FALSE.
7452 */
7453 static int
7455 {
7458 /*
7459 * check for a match
7460 */
7465 }
7466 }
7468 }
7470 /*
7471 * convenience functions
7472 */
7473 static int
7475 {
7477 retry:
7481 }
7483 }
7487 {
7494 /*NOTREACHED*/
7495 }
7497 }
7499 /*
7500 * convenience functions
7501 */
7504 {
7509 /*NOTREACHED*/
7510 }
7512 }
7516 {
7523 /*NOTREACHED*/
7524 }
7526 }
7530 {
7537 /*NOTREACHED*/
7538 }
7540 }
7542 static void
7544 {
7545 retry:
7550 }
7551 }
7553 static void
7555 {
7560 }
7561 }
7562 }
7564 static void
7566 {
7567 retry:
7573 }
7574 }
7575 }
7577 static void
7579 {
7580 num_verbose++;
7583 }
7585 /*
7586 * returns DEVFSADM_TRUE if contents is a minor node in /devices.
7587 * If mn_root is not NULL, mn_root is set to:
7588 * if contents is a /dev node, mn_root = contents
7589 * OR
7590 * if contents is a /devices node, mn_root set to the '/'
7591 * following /devices.
7592 */
7593 static int
7595 {
7603 /* mn_root should point to the / following /devices */
7605 }
7607 }
7613 /* mn_root should point to the / following /devices */
7615 }
7617 }
7621 }
7623 }
7625 /*
7626 * Add the specified property to nvl.
7627 * Returns:
7628 * 0 successfully added
7629 * -1 an error occurred
7630 * 1 could not add the property for reasons not due to errors.
7631 */
7632 static int
7634 {
7710 }
7717 }
7726 }
7731 out:
7734 }
7736 static void
7738 {
7744 }
7745 }
7747 /* callback function for di_devlink_cache_walk */
7748 static int
7750 {
7763 }
7771 out:
7775 }
7777 /*
7778 * Lookup dev name corresponding to the phys_path.
7779 * phys_path is path to a node or minor node.
7780 * Returns:
7781 * 0 with *dev_name set to the dev name
7782 * Lookup succeeded and dev_name found
7783 * 0 with *dev_name set to NULL
7784 * Lookup encountered no errors but dev name not found
7785 * -1
7786 * Lookup failed
7787 */
7788 static int
7790 {
7808 }
7811 }
7815 {
7833 /* first try lookup based on /dev/rdsk name */
7839 }
7840 }
7843 /* now try lookup based on a minor name ending with ",raw" */
7852 }
7853 }
7854 }
7863 }
7865 /* if the name contains slice or partition number strip it */
7869 p--;
7872 }
7875 }
7879 {
7893 /* lookup based on a minor name ending with ",raw" */
7902 }
7903 }
7912 }
7915 }
7919 {
7927 /* dlpi style-2 only interface */
7933 }
7936 }
7940 {
7955 /* first try lookup based on /dev/printers name */
7961 }
7962 }
7964 /* fallback to the first name */
7971 }
7973 /*
7974 * Build an nvlist containing all attributes for devfs events.
7975 * Returns nvlist pointer on success, NULL on failure.
7976 */
7980 {
7983 di_prop_t prop;
7993 }
8009 /*
8010 * While we're removing labeled lofi device, we will receive
8011 * event for every registered minor device and lastly,
8012 * an event with minor set to NULL, as in following example:
8013 * class: EC_dev_remove subclass: disk
8014 * node_path: /pseudo/lofi@1 driver: lofi minor: u,raw
8015 * class: EC_dev_remove subclass: disk
8016 * node_path: /pseudo/lofi@1 driver: lofi minor: NULL
8017 *
8018 * When we receive this last event with minor set to NULL,
8019 * all lofi minor devices are already removed and the call to
8020 * lookup_disk_dev_name() would result in error.
8021 * To prevent name lookup error messages for this case, we
8022 * need to filter out that last event.
8023 */
8028 }
8032 }
8038 }
8043 }
8045 /*
8046 * The raw minor node is created or removed after the block
8047 * node. Lofi devfs events are dependent on this behavior.
8048 * Generate the sysevent only for the raw minor node.
8049 *
8050 * If the lofi mapping is created, we will receive the following
8051 * event: class: EC_dev_add subclass: lofi minor: NULL
8052 *
8053 * As in case of EC_dev_add, the minor is NULL pointer,
8054 * to get device links created, we will need to provide the
8055 * type of minor node for lookup_lofi_dev_name()
8056 *
8057 * If the lofi device is unmapped, we will receive following
8058 * events:
8059 * class: EC_dev_remove subclass: lofi minor: disk
8060 * class: EC_dev_remove subclass: lofi minor: disk,raw
8061 * class: EC_dev_remove subclass: lofi minor: NULL
8062 */
8070 }
8072 NULL) {
8075 }
8076 }
8083 }
8092 /* add properties */
8102 count++;
8108 }
8109 }
8110 }
8114 out:
8120 /*
8121 * If a lofi mount fails, the /devices node may well have
8122 * disappeared by the time we run, so let's not complain.
8123 */
8128 }
8130 }
8132 static void
8134 {
8135 sysevent_id_t eid;
8140 }
8141 }
8143 /*
8144 * When devfsadmd needs to generate sysevents, they are queued for later
8145 * delivery this allows them to be delivered after the devlinks db cache has
8146 * been flushed guaranteeing that applications consuming these events have
8147 * access to an accurate devlinks db. The queue is a FIFO, sysevents to be
8148 * inserted in the front of the queue and consumed off the back.
8149 */
8150 static void
8152 {
8165 else
8169 }
8171 static void
8173 {
8190 }
8192 }
8194 static void
8197 {
8206 else
8212 }
8213 }
8215 /*
8216 * is_blank() returns 1 (true) if a line specified is composed of
8217 * whitespace characters only. otherwise, it returns 0 (false).
8218 *
8219 * Note. the argument (line) must be null-terminated.
8220 */
8221 static int
8223 {
8228 }
8230 /*
8231 * Functions to deal with the no-further-processing hash
8232 */
8234 static void
8236 {
8239 }
8241 static int
8243 {
8249 }
8252 }
8256 {
8267 }
8270 }
8272 static void
8274 {
8287 }
8289 static void
8291 {
8296 /*LINTED*/
8301 }
8302 }
8306 }
8308 static int
8310 {
8320 }
8325 }
8327 }
8329 /* ARGSUSED */
8330 static void
8333 {
8335 door_cred_t dcred;
8338 sdev_door_res_t res;
8345 }
8352 }
8360 /*
8361 * run "devfsadm"
8362 */
8386 }
8389 }
8392 /* log an error here? */
8395 }
8397 done:
8402 }
8405 di_devlink_handle_t
8407 {
8409 }
8411 int
8413 {
8422 /*
8423 * Check the <RE, subexp> array passed in and compile it.
8424 */
8430 }
8436 }
8440 }
8448 }
8454 /* No match */
8456 }
8470 }
8472 }
8473 }
8479 }
8493 }
8494 }
8498 bad_re:
8503 }
8505 }
8507 /*
8508 * Return 1 if we have reserved links.
8509 */
8510 int
8512 {
8514 }
8516 /*
8517 * This functions errs on the side of caution. If there is any error
8518 * we assume that the devlink is *not* reserved
8519 */
8520 int
8522 {
8536 }
8541 }
8553 }
8557 }