17c478bd9Sstevel@tonic-gate /* 27c478bd9Sstevel@tonic-gate * CDDL HEADER START 37c478bd9Sstevel@tonic-gate * 47c478bd9Sstevel@tonic-gate * The contents of this file are subject to the terms of the 5facf4a8dSllai * Common Development and Distribution License (the "License"). 6facf4a8dSllai * You may not use this file except in compliance with the License. 77c478bd9Sstevel@tonic-gate * 87c478bd9Sstevel@tonic-gate * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE 97c478bd9Sstevel@tonic-gate * or http://www.opensolaris.org/os/licensing. 107c478bd9Sstevel@tonic-gate * See the License for the specific language governing permissions 117c478bd9Sstevel@tonic-gate * and limitations under the License. 127c478bd9Sstevel@tonic-gate * 137c478bd9Sstevel@tonic-gate * When distributing Covered Code, include this CDDL HEADER in each 147c478bd9Sstevel@tonic-gate * file and include the License file at usr/src/OPENSOLARIS.LICENSE. 157c478bd9Sstevel@tonic-gate * If applicable, add the following below this CDDL HEADER, with the 167c478bd9Sstevel@tonic-gate * fields enclosed by brackets "[]" replaced with your own identifying 177c478bd9Sstevel@tonic-gate * information: Portions Copyright [yyyy] [name of copyright owner] 187c478bd9Sstevel@tonic-gate * 197c478bd9Sstevel@tonic-gate * CDDL HEADER END 207c478bd9Sstevel@tonic-gate */ 217c478bd9Sstevel@tonic-gate /* 22*ff2aee48Scth * Copyright 2007 Sun Microsystems, Inc. All rights reserved. 237c478bd9Sstevel@tonic-gate * Use is subject to license terms. 247c478bd9Sstevel@tonic-gate */ 257c478bd9Sstevel@tonic-gate 267c478bd9Sstevel@tonic-gate #pragma ident "%Z%%M% %I% %E% SMI" 277c478bd9Sstevel@tonic-gate 28facf4a8dSllai #include "libdevinfo.h" 297c478bd9Sstevel@tonic-gate #include "devinfo_devlink.h" 30*ff2aee48Scth #include "device_info.h" 317c478bd9Sstevel@tonic-gate 32*ff2aee48Scth #undef DEBUG 33*ff2aee48Scth #ifndef DEBUG 347c478bd9Sstevel@tonic-gate #define NDEBUG 1 357c478bd9Sstevel@tonic-gate #else 367c478bd9Sstevel@tonic-gate #undef NDEBUG 377c478bd9Sstevel@tonic-gate #endif 387c478bd9Sstevel@tonic-gate 397c478bd9Sstevel@tonic-gate #include <assert.h> 407c478bd9Sstevel@tonic-gate 417c478bd9Sstevel@tonic-gate static mutex_t update_mutex = DEFAULTMUTEX; /* Protects update record lock */ 427c478bd9Sstevel@tonic-gate 437c478bd9Sstevel@tonic-gate static const size_t elem_sizes[DB_TYPES] = { 447c478bd9Sstevel@tonic-gate sizeof (struct db_node), 457c478bd9Sstevel@tonic-gate sizeof (struct db_minor), 467c478bd9Sstevel@tonic-gate sizeof (struct db_link), 477c478bd9Sstevel@tonic-gate sizeof (char) 487c478bd9Sstevel@tonic-gate }; 497c478bd9Sstevel@tonic-gate 507c478bd9Sstevel@tonic-gate /* 517c478bd9Sstevel@tonic-gate * List of directories/files skipped while physically walking /dev 527c478bd9Sstevel@tonic-gate * Paths are relative to "<root>/dev/" 537c478bd9Sstevel@tonic-gate */ 547c478bd9Sstevel@tonic-gate static const char *skip_dirs[] = {"fd"}; 557c478bd9Sstevel@tonic-gate static const char *skip_files[] = { 567c478bd9Sstevel@tonic-gate "stdout", 577c478bd9Sstevel@tonic-gate "stdin", 587c478bd9Sstevel@tonic-gate "stderr" 597c478bd9Sstevel@tonic-gate }; 607c478bd9Sstevel@tonic-gate 617c478bd9Sstevel@tonic-gate #define N_SKIP_DIRS (sizeof (skip_dirs) / sizeof (skip_dirs[0])) 627c478bd9Sstevel@tonic-gate #define N_SKIP_FILES (sizeof (skip_files) / sizeof (skip_files[0])) 637c478bd9Sstevel@tonic-gate 647c478bd9Sstevel@tonic-gate /* 657c478bd9Sstevel@tonic-gate * 667c478bd9Sstevel@tonic-gate * This file contains two sets of interfaces which operate on the reverse 677c478bd9Sstevel@tonic-gate * links database. One set (which includes di_devlink_open()/_close()) 687c478bd9Sstevel@tonic-gate * allows link generators like devfsadm(1M) and ucblinks(1B) (writers) to 697c478bd9Sstevel@tonic-gate * populate the database with /devices -> /dev mappings. Another set 707c478bd9Sstevel@tonic-gate * of interfaces (which includes di_devlink_init()/_fini()) allows 717c478bd9Sstevel@tonic-gate * applications (readers) to lookup the database for /dev links corresponding 727c478bd9Sstevel@tonic-gate * to a given minor. 737c478bd9Sstevel@tonic-gate * 747c478bd9Sstevel@tonic-gate * Writers operate on a cached version of the database. The cache is created 757c478bd9Sstevel@tonic-gate * when di_devlink_open() is called. As links in /dev are created and removed, 767c478bd9Sstevel@tonic-gate * the cache is updated to keep it in synch with /dev. When the /dev updates 777c478bd9Sstevel@tonic-gate * are complete, the link generator calls di_devlink_close() which writes 787c478bd9Sstevel@tonic-gate * out the cache to the database. 797c478bd9Sstevel@tonic-gate * 807c478bd9Sstevel@tonic-gate * Applications which need to lookup the database, call di_devlink_init(). 817c478bd9Sstevel@tonic-gate * di_devlink_init() checks the database file (if one exists). If the 827c478bd9Sstevel@tonic-gate * database is valid, it is mapped into the address space of the 837c478bd9Sstevel@tonic-gate * application. The database file consists of several segments. Each 847c478bd9Sstevel@tonic-gate * segment can be mapped in independently and is mapped on demand. 857c478bd9Sstevel@tonic-gate * 867c478bd9Sstevel@tonic-gate * Database Layout 877c478bd9Sstevel@tonic-gate * 887c478bd9Sstevel@tonic-gate * --------------------- 897c478bd9Sstevel@tonic-gate * | Magic # | 907c478bd9Sstevel@tonic-gate * | ----------------- | 917c478bd9Sstevel@tonic-gate * | Version | HEADER 927c478bd9Sstevel@tonic-gate * | ----------------- | 937c478bd9Sstevel@tonic-gate * | ... | 947c478bd9Sstevel@tonic-gate * --------------------- 957c478bd9Sstevel@tonic-gate * | | 967c478bd9Sstevel@tonic-gate * | | NODES 977c478bd9Sstevel@tonic-gate * | | 987c478bd9Sstevel@tonic-gate * | | 997c478bd9Sstevel@tonic-gate * --------------------- 1007c478bd9Sstevel@tonic-gate * | | 1017c478bd9Sstevel@tonic-gate * | | MINORS 1027c478bd9Sstevel@tonic-gate * | | 1037c478bd9Sstevel@tonic-gate * | | 1047c478bd9Sstevel@tonic-gate * --------------------- 1057c478bd9Sstevel@tonic-gate * | | 1067c478bd9Sstevel@tonic-gate * | | LINKS 1077c478bd9Sstevel@tonic-gate * | | 1087c478bd9Sstevel@tonic-gate * | | 1097c478bd9Sstevel@tonic-gate * --------------------- 1107c478bd9Sstevel@tonic-gate * | | 1117c478bd9Sstevel@tonic-gate * | | STRINGS 1127c478bd9Sstevel@tonic-gate * | | 1137c478bd9Sstevel@tonic-gate * | | 1147c478bd9Sstevel@tonic-gate * --------------------- 1157c478bd9Sstevel@tonic-gate * 1167c478bd9Sstevel@tonic-gate * Readers can lookup /dev links for a specific minor or 1177c478bd9Sstevel@tonic-gate * lookup all /dev links. In the latter case, the node 1187c478bd9Sstevel@tonic-gate * and minor segments are not mapped in and the reader 1197c478bd9Sstevel@tonic-gate * walks through every link in the link segment. 1207c478bd9Sstevel@tonic-gate * 1217c478bd9Sstevel@tonic-gate */ 1227c478bd9Sstevel@tonic-gate 1237c478bd9Sstevel@tonic-gate di_devlink_handle_t 1247c478bd9Sstevel@tonic-gate di_devlink_open(const char *root_dir, uint_t flags) 1257c478bd9Sstevel@tonic-gate { 1267c478bd9Sstevel@tonic-gate int err; 1277c478bd9Sstevel@tonic-gate char path[PATH_MAX]; 1287c478bd9Sstevel@tonic-gate struct di_devlink_handle *hdp; 1297c478bd9Sstevel@tonic-gate int retried = 0; 1307c478bd9Sstevel@tonic-gate 1317c478bd9Sstevel@tonic-gate retry: 1327c478bd9Sstevel@tonic-gate /* 1337c478bd9Sstevel@tonic-gate * Allocate a read-write handle but open the DB in readonly 1347c478bd9Sstevel@tonic-gate * mode. We do writes only to a temporary copy of the database. 1357c478bd9Sstevel@tonic-gate */ 1367c478bd9Sstevel@tonic-gate if ((hdp = handle_alloc(root_dir, OPEN_RDWR)) == NULL) { 1377c478bd9Sstevel@tonic-gate return (NULL); 1387c478bd9Sstevel@tonic-gate } 1397c478bd9Sstevel@tonic-gate 1407c478bd9Sstevel@tonic-gate err = open_db(hdp, OPEN_RDONLY); 1417c478bd9Sstevel@tonic-gate 1427c478bd9Sstevel@tonic-gate /* 1437c478bd9Sstevel@tonic-gate * Unlink the database, so that consumers don't get 1447c478bd9Sstevel@tonic-gate * out of date information as the database is being updated. 145*ff2aee48Scth * 146*ff2aee48Scth * NOTE: A typical snapshot consumer will wait until write lock 147*ff2aee48Scth * obtained by handle_alloc above is dropped by handle_free, 148*ff2aee48Scth * at which point the file will have been recreated. 1497c478bd9Sstevel@tonic-gate */ 1507c478bd9Sstevel@tonic-gate get_db_path(hdp, DB_FILE, path, sizeof (path)); 1517c478bd9Sstevel@tonic-gate (void) unlink(path); 1527c478bd9Sstevel@tonic-gate 1537c478bd9Sstevel@tonic-gate /* 1547c478bd9Sstevel@tonic-gate * The flags argument is reserved for future use. 1557c478bd9Sstevel@tonic-gate */ 1567c478bd9Sstevel@tonic-gate if (flags != 0) { 1577c478bd9Sstevel@tonic-gate handle_free(&hdp); /* also closes the DB */ 1587c478bd9Sstevel@tonic-gate errno = EINVAL; 1597c478bd9Sstevel@tonic-gate return (NULL); 1607c478bd9Sstevel@tonic-gate } 1617c478bd9Sstevel@tonic-gate 1627c478bd9Sstevel@tonic-gate if (cache_alloc(hdp) != 0) { 1637c478bd9Sstevel@tonic-gate handle_free(&hdp); 1647c478bd9Sstevel@tonic-gate return (NULL); 1657c478bd9Sstevel@tonic-gate } 1667c478bd9Sstevel@tonic-gate 1677c478bd9Sstevel@tonic-gate if (err) { 1687c478bd9Sstevel@tonic-gate /* 1697c478bd9Sstevel@tonic-gate * Failed to open DB. 1707c478bd9Sstevel@tonic-gate * The most likely cause is that DB file did not exist. 1717c478bd9Sstevel@tonic-gate * Call di_devlink_close() to recreate the DB file and 1727c478bd9Sstevel@tonic-gate * retry di_devlink_open(). 1737c478bd9Sstevel@tonic-gate */ 1747c478bd9Sstevel@tonic-gate if (retried == 0) { 1757c478bd9Sstevel@tonic-gate (void) di_devlink_close(&hdp, 0); 1767c478bd9Sstevel@tonic-gate retried = 1; 1777c478bd9Sstevel@tonic-gate goto retry; 1787c478bd9Sstevel@tonic-gate } 1797c478bd9Sstevel@tonic-gate 1807c478bd9Sstevel@tonic-gate /* 1817c478bd9Sstevel@tonic-gate * DB cannot be opened, just return the 1827c478bd9Sstevel@tonic-gate * handle. We will recreate the DB later. 1837c478bd9Sstevel@tonic-gate */ 1847c478bd9Sstevel@tonic-gate return (hdp); 1857c478bd9Sstevel@tonic-gate } 1867c478bd9Sstevel@tonic-gate 1877c478bd9Sstevel@tonic-gate /* Read the database into the cache */ 1887c478bd9Sstevel@tonic-gate CACHE(hdp)->update_count = DB_HDR(hdp)->update_count; 1897c478bd9Sstevel@tonic-gate (void) read_nodes(hdp, NULL, DB_HDR(hdp)->root_idx); 1907c478bd9Sstevel@tonic-gate (void) read_links(hdp, NULL, DB_HDR(hdp)->dngl_idx); 1917c478bd9Sstevel@tonic-gate 1927c478bd9Sstevel@tonic-gate (void) close_db(hdp); 1937c478bd9Sstevel@tonic-gate 1947c478bd9Sstevel@tonic-gate return (hdp); 1957c478bd9Sstevel@tonic-gate } 1967c478bd9Sstevel@tonic-gate 1977c478bd9Sstevel@tonic-gate static void 1987c478bd9Sstevel@tonic-gate get_db_path( 1997c478bd9Sstevel@tonic-gate struct di_devlink_handle *hdp, 2007c478bd9Sstevel@tonic-gate const char *fname, 2017c478bd9Sstevel@tonic-gate char *buf, 2027c478bd9Sstevel@tonic-gate size_t blen) 2037c478bd9Sstevel@tonic-gate { 2047c478bd9Sstevel@tonic-gate char *dir = NULL; 2057c478bd9Sstevel@tonic-gate 2067c478bd9Sstevel@tonic-gate #ifdef DEBUG 2077c478bd9Sstevel@tonic-gate if (dir = getenv(ALT_DB_DIR)) { 2087c478bd9Sstevel@tonic-gate (void) dprintf(DBG_INFO, "get_db_path: alternate db dir: %s\n", 2097c478bd9Sstevel@tonic-gate dir); 2107c478bd9Sstevel@tonic-gate } 2117c478bd9Sstevel@tonic-gate #endif 2127c478bd9Sstevel@tonic-gate if (dir == NULL) { 213facf4a8dSllai dir = hdp->db_dir; 2147c478bd9Sstevel@tonic-gate } 2157c478bd9Sstevel@tonic-gate 2167c478bd9Sstevel@tonic-gate (void) snprintf(buf, blen, "%s/%s", dir, fname); 2177c478bd9Sstevel@tonic-gate } 2187c478bd9Sstevel@tonic-gate 2197c478bd9Sstevel@tonic-gate static int 2207c478bd9Sstevel@tonic-gate open_db(struct di_devlink_handle *hdp, int flags) 2217c478bd9Sstevel@tonic-gate { 2227c478bd9Sstevel@tonic-gate size_t sz; 2237c478bd9Sstevel@tonic-gate long page_sz; 2247c478bd9Sstevel@tonic-gate int fd, rv, flg; 2257c478bd9Sstevel@tonic-gate struct stat sbuf; 2267c478bd9Sstevel@tonic-gate uint32_t count[DB_TYPES] = {0}; 2277c478bd9Sstevel@tonic-gate char path[PATH_MAX]; 2287c478bd9Sstevel@tonic-gate void *cp; 2297c478bd9Sstevel@tonic-gate 2307c478bd9Sstevel@tonic-gate assert(!DB_OPEN(hdp)); 2317c478bd9Sstevel@tonic-gate 2327c478bd9Sstevel@tonic-gate #ifdef DEBUG 2337c478bd9Sstevel@tonic-gate if (getenv(SKIP_DB)) { 2347c478bd9Sstevel@tonic-gate (void) dprintf(DBG_INFO, "open_db: skipping database\n"); 2357c478bd9Sstevel@tonic-gate return (-1); 2367c478bd9Sstevel@tonic-gate } 2377c478bd9Sstevel@tonic-gate #endif 2387c478bd9Sstevel@tonic-gate if ((page_sz = sysconf(_SC_PAGE_SIZE)) == -1) { 2397c478bd9Sstevel@tonic-gate return (-1); 2407c478bd9Sstevel@tonic-gate } 2417c478bd9Sstevel@tonic-gate 2427c478bd9Sstevel@tonic-gate /* 2437c478bd9Sstevel@tonic-gate * Use O_TRUNC flag for write access, so that the subsequent ftruncate() 2447c478bd9Sstevel@tonic-gate * call will zero-fill the entire file 2457c478bd9Sstevel@tonic-gate */ 2467c478bd9Sstevel@tonic-gate if (IS_RDONLY(flags)) { 2477c478bd9Sstevel@tonic-gate flg = O_RDONLY; 2487c478bd9Sstevel@tonic-gate get_db_path(hdp, DB_FILE, path, sizeof (path)); 2497c478bd9Sstevel@tonic-gate } else { 2507c478bd9Sstevel@tonic-gate flg = O_RDWR|O_CREAT|O_TRUNC; 2517c478bd9Sstevel@tonic-gate get_db_path(hdp, DB_TMP, path, sizeof (path)); 2527c478bd9Sstevel@tonic-gate } 2537c478bd9Sstevel@tonic-gate 254facf4a8dSllai /* 255facf4a8dSllai * Avoid triggering /dev reconfigure for read when not present 256facf4a8dSllai */ 257facf4a8dSllai if (IS_RDONLY(flags) && 258facf4a8dSllai (strncmp(path, "/dev/", 5) == 0) && !device_exists(path)) { 259facf4a8dSllai return (-1); 260facf4a8dSllai } 261facf4a8dSllai 2627c478bd9Sstevel@tonic-gate if ((fd = open(path, flg, DB_PERMS)) == -1) { 2637c478bd9Sstevel@tonic-gate return (-1); 2647c478bd9Sstevel@tonic-gate } 2657c478bd9Sstevel@tonic-gate 2667c478bd9Sstevel@tonic-gate if (IS_RDONLY(flags)) { 2677c478bd9Sstevel@tonic-gate flg = PROT_READ; 2687c478bd9Sstevel@tonic-gate rv = fstat(fd, &sbuf); 2697c478bd9Sstevel@tonic-gate sz = sbuf.st_size; 2707c478bd9Sstevel@tonic-gate } else { 2717c478bd9Sstevel@tonic-gate flg = PROT_READ | PROT_WRITE; 2727c478bd9Sstevel@tonic-gate sz = size_db(hdp, page_sz, count); 2737c478bd9Sstevel@tonic-gate rv = ftruncate(fd, sz); 2747c478bd9Sstevel@tonic-gate } 2757c478bd9Sstevel@tonic-gate 2767c478bd9Sstevel@tonic-gate if (rv == -1 || sz < HDR_LEN) { 2777c478bd9Sstevel@tonic-gate if (rv != -1) 2787c478bd9Sstevel@tonic-gate errno = EINVAL; 2797c478bd9Sstevel@tonic-gate (void) close(fd); 2807c478bd9Sstevel@tonic-gate return (-1); 2817c478bd9Sstevel@tonic-gate } 2827c478bd9Sstevel@tonic-gate 2837c478bd9Sstevel@tonic-gate cp = mmap(0, HDR_LEN, flg, MAP_SHARED, fd, 0); 2847c478bd9Sstevel@tonic-gate if (cp == MAP_FAILED) { 2857c478bd9Sstevel@tonic-gate (void) close(fd); 2867c478bd9Sstevel@tonic-gate return (-1); 2877c478bd9Sstevel@tonic-gate } 2887c478bd9Sstevel@tonic-gate DB(hdp)->hdr = (struct db_hdr *)cp; 2897c478bd9Sstevel@tonic-gate DB(hdp)->db_fd = fd; 2907c478bd9Sstevel@tonic-gate DB(hdp)->flags = flags; 2917c478bd9Sstevel@tonic-gate 2927c478bd9Sstevel@tonic-gate if (IS_RDONLY(flags)) { 2937c478bd9Sstevel@tonic-gate rv = invalid_db(hdp, sz, page_sz); 2947c478bd9Sstevel@tonic-gate } else { 2957c478bd9Sstevel@tonic-gate rv = init_hdr(hdp, page_sz, count); 2967c478bd9Sstevel@tonic-gate } 2977c478bd9Sstevel@tonic-gate 2987c478bd9Sstevel@tonic-gate if (rv) { 2997c478bd9Sstevel@tonic-gate (void) dprintf(DBG_ERR, "open_db: invalid DB(%s)\n", path); 3007c478bd9Sstevel@tonic-gate (void) close_db(hdp); 3017c478bd9Sstevel@tonic-gate return (-1); 3027c478bd9Sstevel@tonic-gate } else { 3037c478bd9Sstevel@tonic-gate (void) dprintf(DBG_STEP, "open_db: DB(%s): opened\n", path); 3047c478bd9Sstevel@tonic-gate return (0); 3057c478bd9Sstevel@tonic-gate } 3067c478bd9Sstevel@tonic-gate } 3077c478bd9Sstevel@tonic-gate 3087c478bd9Sstevel@tonic-gate /* 3097c478bd9Sstevel@tonic-gate * A handle can be allocated for read-only or read-write access 3107c478bd9Sstevel@tonic-gate */ 3117c478bd9Sstevel@tonic-gate static struct di_devlink_handle * 3127c478bd9Sstevel@tonic-gate handle_alloc(const char *root_dir, uint_t flags) 3137c478bd9Sstevel@tonic-gate { 314facf4a8dSllai char dev_dir[PATH_MAX], path[PATH_MAX], db_dir[PATH_MAX]; 3157c478bd9Sstevel@tonic-gate struct di_devlink_handle *hdp, proto = {0}; 3167c478bd9Sstevel@tonic-gate 3177c478bd9Sstevel@tonic-gate assert(flags == OPEN_RDWR || flags == OPEN_RDONLY); 3187c478bd9Sstevel@tonic-gate 3197c478bd9Sstevel@tonic-gate dev_dir[0] = '\0'; 320facf4a8dSllai db_dir[0] = '\0'; 3217c478bd9Sstevel@tonic-gate 3227c478bd9Sstevel@tonic-gate /* 3237c478bd9Sstevel@tonic-gate * NULL and the empty string are equivalent to "/" 3247c478bd9Sstevel@tonic-gate */ 3257c478bd9Sstevel@tonic-gate if (root_dir && root_dir[0] != '\0') { 3267c478bd9Sstevel@tonic-gate 3277c478bd9Sstevel@tonic-gate if (root_dir[0] != '/') { 3287c478bd9Sstevel@tonic-gate errno = EINVAL; 3297c478bd9Sstevel@tonic-gate return (NULL); 3307c478bd9Sstevel@tonic-gate } 3317c478bd9Sstevel@tonic-gate 3327c478bd9Sstevel@tonic-gate #ifdef DEBUG 3337c478bd9Sstevel@tonic-gate /*LINTED*/ 3347c478bd9Sstevel@tonic-gate assert(sizeof (dev_dir) >= PATH_MAX); 3357c478bd9Sstevel@tonic-gate #endif 336facf4a8dSllai if ((realpath(root_dir, dev_dir) == NULL) || 337facf4a8dSllai (realpath(root_dir, db_dir) == NULL)) { 3387c478bd9Sstevel@tonic-gate return (NULL); 3397c478bd9Sstevel@tonic-gate } 3407c478bd9Sstevel@tonic-gate } 3417c478bd9Sstevel@tonic-gate 3427c478bd9Sstevel@tonic-gate if (strcmp(dev_dir, "/") == 0) { 343facf4a8dSllai dev_dir[0] = 0; 344facf4a8dSllai db_dir[0] = 0; 3457c478bd9Sstevel@tonic-gate } else { 346facf4a8dSllai (void) strlcpy(db_dir, dev_dir, sizeof (db_dir)); 3477c478bd9Sstevel@tonic-gate } 3487c478bd9Sstevel@tonic-gate 349facf4a8dSllai (void) strlcat(dev_dir, DEV, sizeof (dev_dir)); 350facf4a8dSllai (void) strlcat(db_dir, ETCDEV, sizeof (db_dir)); 351facf4a8dSllai 3527c478bd9Sstevel@tonic-gate proto.dev_dir = dev_dir; 353facf4a8dSllai proto.db_dir = db_dir; 3547c478bd9Sstevel@tonic-gate proto.flags = flags; 3557c478bd9Sstevel@tonic-gate proto.lock_fd = -1; 3567c478bd9Sstevel@tonic-gate 3577c478bd9Sstevel@tonic-gate /* 3587c478bd9Sstevel@tonic-gate * Lock database if a read-write handle is being allocated. 3597c478bd9Sstevel@tonic-gate * Locks are needed to protect against multiple writers. 360*ff2aee48Scth * Readers lock/unlock in di_devlink_snapshot. 3617c478bd9Sstevel@tonic-gate */ 3627c478bd9Sstevel@tonic-gate if (HDL_RDWR(&proto)) { 363*ff2aee48Scth if (enter_db_lock(&proto, root_dir) != 1) { 3647c478bd9Sstevel@tonic-gate return (NULL); 3657c478bd9Sstevel@tonic-gate } 3667c478bd9Sstevel@tonic-gate } 3677c478bd9Sstevel@tonic-gate 3687c478bd9Sstevel@tonic-gate DB(&proto)->db_fd = -1; 3697c478bd9Sstevel@tonic-gate 3707c478bd9Sstevel@tonic-gate hdp = calloc(1, sizeof (struct di_devlink_handle)); 3717c478bd9Sstevel@tonic-gate if (hdp == NULL) { 3727c478bd9Sstevel@tonic-gate goto error; 3737c478bd9Sstevel@tonic-gate } 3747c478bd9Sstevel@tonic-gate 3757c478bd9Sstevel@tonic-gate *hdp = proto; 3767c478bd9Sstevel@tonic-gate 3777c478bd9Sstevel@tonic-gate /* 3787c478bd9Sstevel@tonic-gate * The handle hdp now contains a pointer to local storage 3797c478bd9Sstevel@tonic-gate * in the dev_dir field (obtained from the proto handle). 3807c478bd9Sstevel@tonic-gate * In the following line, a dynamically allocated version 3817c478bd9Sstevel@tonic-gate * is substituted. 3827c478bd9Sstevel@tonic-gate */ 3837c478bd9Sstevel@tonic-gate 3847c478bd9Sstevel@tonic-gate if ((hdp->dev_dir = strdup(proto.dev_dir)) == NULL) { 3857c478bd9Sstevel@tonic-gate free(hdp); 3867c478bd9Sstevel@tonic-gate goto error; 3877c478bd9Sstevel@tonic-gate } 3887c478bd9Sstevel@tonic-gate 389facf4a8dSllai if ((hdp->db_dir = strdup(proto.db_dir)) == NULL) { 390facf4a8dSllai free(hdp->dev_dir); 391facf4a8dSllai free(hdp); 392facf4a8dSllai goto error; 393facf4a8dSllai } 3947c478bd9Sstevel@tonic-gate 3957c478bd9Sstevel@tonic-gate return (hdp); 3967c478bd9Sstevel@tonic-gate 3977c478bd9Sstevel@tonic-gate error: 3987c478bd9Sstevel@tonic-gate if (HDL_RDWR(&proto)) { 3997c478bd9Sstevel@tonic-gate /* Unlink DB file on error */ 4007c478bd9Sstevel@tonic-gate get_db_path(&proto, DB_FILE, path, sizeof (path)); 4017c478bd9Sstevel@tonic-gate (void) unlink(path); 402*ff2aee48Scth exit_db_lock(&proto); 4037c478bd9Sstevel@tonic-gate } 4047c478bd9Sstevel@tonic-gate return (NULL); 4057c478bd9Sstevel@tonic-gate } 4067c478bd9Sstevel@tonic-gate 4077c478bd9Sstevel@tonic-gate 4087c478bd9Sstevel@tonic-gate static int 4097c478bd9Sstevel@tonic-gate cache_alloc(struct di_devlink_handle *hdp) 4107c478bd9Sstevel@tonic-gate { 4117c478bd9Sstevel@tonic-gate size_t hash_sz = 0; 4127c478bd9Sstevel@tonic-gate 4137c478bd9Sstevel@tonic-gate assert(HDL_RDWR(hdp)); 4147c478bd9Sstevel@tonic-gate 4157c478bd9Sstevel@tonic-gate if (DB_OPEN(hdp)) { 4167c478bd9Sstevel@tonic-gate hash_sz = DB_NUM(hdp, DB_LINK) / AVG_CHAIN_SIZE; 4177c478bd9Sstevel@tonic-gate } 4187c478bd9Sstevel@tonic-gate hash_sz = (hash_sz >= MIN_HASH_SIZE) ? hash_sz : MIN_HASH_SIZE; 4197c478bd9Sstevel@tonic-gate 4207c478bd9Sstevel@tonic-gate CACHE(hdp)->hash = calloc(hash_sz, sizeof (cache_link_t *)); 4217c478bd9Sstevel@tonic-gate if (CACHE(hdp)->hash == NULL) { 4227c478bd9Sstevel@tonic-gate return (-1); 4237c478bd9Sstevel@tonic-gate } 4247c478bd9Sstevel@tonic-gate CACHE(hdp)->hash_sz = hash_sz; 4257c478bd9Sstevel@tonic-gate 4267c478bd9Sstevel@tonic-gate return (0); 4277c478bd9Sstevel@tonic-gate } 4287c478bd9Sstevel@tonic-gate 4297c478bd9Sstevel@tonic-gate 4307c478bd9Sstevel@tonic-gate static int 4317c478bd9Sstevel@tonic-gate invalid_db(struct di_devlink_handle *hdp, size_t fsize, long page_sz) 4327c478bd9Sstevel@tonic-gate { 4337c478bd9Sstevel@tonic-gate int i; 4347c478bd9Sstevel@tonic-gate char *cp; 4357c478bd9Sstevel@tonic-gate size_t sz; 4367c478bd9Sstevel@tonic-gate 4377c478bd9Sstevel@tonic-gate if (DB_HDR(hdp)->magic != DB_MAGIC || DB_HDR(hdp)->vers != DB_VERSION) { 4387c478bd9Sstevel@tonic-gate return (1); 4397c478bd9Sstevel@tonic-gate } 4407c478bd9Sstevel@tonic-gate 4417c478bd9Sstevel@tonic-gate if (DB_HDR(hdp)->page_sz == 0 || DB_HDR(hdp)->page_sz != page_sz) { 4427c478bd9Sstevel@tonic-gate return (1); 4437c478bd9Sstevel@tonic-gate } 4447c478bd9Sstevel@tonic-gate 4457c478bd9Sstevel@tonic-gate sz = seg_size(hdp, DB_HEADER); 4467c478bd9Sstevel@tonic-gate for (i = 0; i < DB_TYPES; i++) { 4477c478bd9Sstevel@tonic-gate (void) dprintf(DBG_INFO, "N[%u] = %u\n", i, DB_NUM(hdp, i)); 4487c478bd9Sstevel@tonic-gate /* There must be at least 1 element of each type */ 4497c478bd9Sstevel@tonic-gate if (DB_NUM(hdp, i) < 1) { 4507c478bd9Sstevel@tonic-gate return (1); 4517c478bd9Sstevel@tonic-gate } 4527c478bd9Sstevel@tonic-gate sz += seg_size(hdp, i); 4537c478bd9Sstevel@tonic-gate assert(sz % page_sz == 0); 4547c478bd9Sstevel@tonic-gate } 4557c478bd9Sstevel@tonic-gate 4567c478bd9Sstevel@tonic-gate if (sz != fsize) { 4577c478bd9Sstevel@tonic-gate return (1); 4587c478bd9Sstevel@tonic-gate } 4597c478bd9Sstevel@tonic-gate 4607c478bd9Sstevel@tonic-gate if (!VALID_INDEX(hdp, DB_NODE, DB_HDR(hdp)->root_idx)) { 4617c478bd9Sstevel@tonic-gate return (1); 4627c478bd9Sstevel@tonic-gate } 4637c478bd9Sstevel@tonic-gate 4647c478bd9Sstevel@tonic-gate if (!VALID_INDEX(hdp, DB_LINK, DB_HDR(hdp)->dngl_idx)) { 4657c478bd9Sstevel@tonic-gate return (1); 4667c478bd9Sstevel@tonic-gate } 4677c478bd9Sstevel@tonic-gate 4687c478bd9Sstevel@tonic-gate if (DB_EMPTY(hdp)) { 4697c478bd9Sstevel@tonic-gate return (1); 4707c478bd9Sstevel@tonic-gate } 4717c478bd9Sstevel@tonic-gate 4727c478bd9Sstevel@tonic-gate /* 4737c478bd9Sstevel@tonic-gate * The last character in the string segment must be a NUL char. 4747c478bd9Sstevel@tonic-gate */ 4757c478bd9Sstevel@tonic-gate cp = get_string(hdp, DB_NUM(hdp, DB_STR) - 1); 4767c478bd9Sstevel@tonic-gate if (cp == NULL || *cp != '\0') { 4777c478bd9Sstevel@tonic-gate return (1); 4787c478bd9Sstevel@tonic-gate } 4797c478bd9Sstevel@tonic-gate 4807c478bd9Sstevel@tonic-gate return (0); 4817c478bd9Sstevel@tonic-gate } 4827c478bd9Sstevel@tonic-gate 4837c478bd9Sstevel@tonic-gate static int 4847c478bd9Sstevel@tonic-gate read_nodes(struct di_devlink_handle *hdp, cache_node_t *pcnp, uint32_t nidx) 4857c478bd9Sstevel@tonic-gate { 4867c478bd9Sstevel@tonic-gate char *path; 4877c478bd9Sstevel@tonic-gate cache_node_t *cnp; 4887c478bd9Sstevel@tonic-gate struct db_node *dnp; 4897c478bd9Sstevel@tonic-gate const char *fcn = "read_nodes"; 4907c478bd9Sstevel@tonic-gate 4917c478bd9Sstevel@tonic-gate assert(HDL_RDWR(hdp)); 4927c478bd9Sstevel@tonic-gate 4937c478bd9Sstevel@tonic-gate /* 4947c478bd9Sstevel@tonic-gate * parent node should be NULL only for the root node 4957c478bd9Sstevel@tonic-gate */ 4967c478bd9Sstevel@tonic-gate if ((pcnp == NULL) ^ (nidx == DB_HDR(hdp)->root_idx)) { 4977c478bd9Sstevel@tonic-gate (void) dprintf(DBG_ERR, "%s: invalid parent or index(%u)\n", 4987c478bd9Sstevel@tonic-gate fcn, nidx); 4997c478bd9Sstevel@tonic-gate SET_DB_ERR(hdp); 5007c478bd9Sstevel@tonic-gate return (-1); 5017c478bd9Sstevel@tonic-gate } 5027c478bd9Sstevel@tonic-gate 5037c478bd9Sstevel@tonic-gate for (; dnp = get_node(hdp, nidx); nidx = dnp->sib) { 5047c478bd9Sstevel@tonic-gate 5057c478bd9Sstevel@tonic-gate path = get_string(hdp, dnp->path); 5067c478bd9Sstevel@tonic-gate 5077c478bd9Sstevel@tonic-gate /* 5087c478bd9Sstevel@tonic-gate * Insert at head of list to recreate original order 5097c478bd9Sstevel@tonic-gate */ 5107c478bd9Sstevel@tonic-gate cnp = node_insert(hdp, pcnp, path, INSERT_HEAD); 5117c478bd9Sstevel@tonic-gate if (cnp == NULL) { 5127c478bd9Sstevel@tonic-gate SET_DB_ERR(hdp); 5137c478bd9Sstevel@tonic-gate break; 5147c478bd9Sstevel@tonic-gate } 5157c478bd9Sstevel@tonic-gate 5167c478bd9Sstevel@tonic-gate assert(strcmp(path, "/") ^ (nidx == DB_HDR(hdp)->root_idx)); 5177c478bd9Sstevel@tonic-gate assert(strcmp(path, "/") != 0 || dnp->sib == DB_NIL); 5187c478bd9Sstevel@tonic-gate 5197c478bd9Sstevel@tonic-gate if (read_minors(hdp, cnp, dnp->minor) != 0 || 5207c478bd9Sstevel@tonic-gate read_nodes(hdp, cnp, dnp->child) != 0) { 5217c478bd9Sstevel@tonic-gate break; 5227c478bd9Sstevel@tonic-gate } 5237c478bd9Sstevel@tonic-gate 5247c478bd9Sstevel@tonic-gate (void) dprintf(DBG_STEP, "%s: node[%u]: %s\n", fcn, nidx, 5257c478bd9Sstevel@tonic-gate cnp->path); 5267c478bd9Sstevel@tonic-gate } 5277c478bd9Sstevel@tonic-gate 5287c478bd9Sstevel@tonic-gate return (dnp ? -1 : 0); 5297c478bd9Sstevel@tonic-gate } 5307c478bd9Sstevel@tonic-gate 5317c478bd9Sstevel@tonic-gate static int 5327c478bd9Sstevel@tonic-gate read_minors(struct di_devlink_handle *hdp, cache_node_t *pcnp, uint32_t nidx) 5337c478bd9Sstevel@tonic-gate { 5347c478bd9Sstevel@tonic-gate cache_minor_t *cmnp; 5357c478bd9Sstevel@tonic-gate struct db_minor *dmp; 5367c478bd9Sstevel@tonic-gate char *name, *nodetype; 5377c478bd9Sstevel@tonic-gate const char *fcn = "read_minors"; 5387c478bd9Sstevel@tonic-gate 5397c478bd9Sstevel@tonic-gate assert(HDL_RDWR(hdp)); 5407c478bd9Sstevel@tonic-gate 5417c478bd9Sstevel@tonic-gate if (pcnp == NULL) { 5427c478bd9Sstevel@tonic-gate (void) dprintf(DBG_ERR, "%s: minor[%u]: orphan minor\n", fcn, 5437c478bd9Sstevel@tonic-gate nidx); 5447c478bd9Sstevel@tonic-gate SET_DB_ERR(hdp); 5457c478bd9Sstevel@tonic-gate return (-1); 5467c478bd9Sstevel@tonic-gate } 5477c478bd9Sstevel@tonic-gate 5487c478bd9Sstevel@tonic-gate for (; dmp = get_minor(hdp, nidx); nidx = dmp->sib) { 5497c478bd9Sstevel@tonic-gate 5507c478bd9Sstevel@tonic-gate name = get_string(hdp, dmp->name); 5517c478bd9Sstevel@tonic-gate nodetype = get_string(hdp, dmp->nodetype); 5527c478bd9Sstevel@tonic-gate 5537c478bd9Sstevel@tonic-gate cmnp = minor_insert(hdp, pcnp, name, nodetype, NULL); 5547c478bd9Sstevel@tonic-gate if (cmnp == NULL) { 5557c478bd9Sstevel@tonic-gate SET_DB_ERR(hdp); 5567c478bd9Sstevel@tonic-gate break; 5577c478bd9Sstevel@tonic-gate } 5587c478bd9Sstevel@tonic-gate 5597c478bd9Sstevel@tonic-gate (void) dprintf(DBG_STEP, "%s: minor[%u]: %s\n", fcn, nidx, 5607c478bd9Sstevel@tonic-gate cmnp->name); 5617c478bd9Sstevel@tonic-gate 5627c478bd9Sstevel@tonic-gate if (read_links(hdp, cmnp, dmp->link) != 0) { 5637c478bd9Sstevel@tonic-gate break; 5647c478bd9Sstevel@tonic-gate } 5657c478bd9Sstevel@tonic-gate } 5667c478bd9Sstevel@tonic-gate 5677c478bd9Sstevel@tonic-gate return (dmp ? -1 : 0); 5687c478bd9Sstevel@tonic-gate } 5697c478bd9Sstevel@tonic-gate 5707c478bd9Sstevel@tonic-gate /* 5717c478bd9Sstevel@tonic-gate * If the link is dangling the corresponding minor will be absent. 5727c478bd9Sstevel@tonic-gate */ 5737c478bd9Sstevel@tonic-gate static int 5747c478bd9Sstevel@tonic-gate read_links(struct di_devlink_handle *hdp, cache_minor_t *pcmp, uint32_t nidx) 5757c478bd9Sstevel@tonic-gate { 5767c478bd9Sstevel@tonic-gate cache_link_t *clp; 5777c478bd9Sstevel@tonic-gate struct db_link *dlp; 5787c478bd9Sstevel@tonic-gate char *path, *content; 5797c478bd9Sstevel@tonic-gate 5807c478bd9Sstevel@tonic-gate assert(HDL_RDWR(hdp)); 5817c478bd9Sstevel@tonic-gate 5827c478bd9Sstevel@tonic-gate if (nidx != DB_NIL && 5837c478bd9Sstevel@tonic-gate ((pcmp == NULL) ^ (nidx == DB_HDR(hdp)->dngl_idx))) { 5847c478bd9Sstevel@tonic-gate (void) dprintf(DBG_ERR, "read_links: invalid minor or" 5857c478bd9Sstevel@tonic-gate " index(%u)\n", nidx); 5867c478bd9Sstevel@tonic-gate SET_DB_ERR(hdp); 5877c478bd9Sstevel@tonic-gate return (-1); 5887c478bd9Sstevel@tonic-gate } 5897c478bd9Sstevel@tonic-gate 5907c478bd9Sstevel@tonic-gate for (; dlp = get_link(hdp, nidx); nidx = dlp->sib) { 5917c478bd9Sstevel@tonic-gate 5927c478bd9Sstevel@tonic-gate path = get_string(hdp, dlp->path); 5937c478bd9Sstevel@tonic-gate content = get_string(hdp, dlp->content); 5947c478bd9Sstevel@tonic-gate 5957c478bd9Sstevel@tonic-gate clp = link_insert(hdp, pcmp, path, content, dlp->attr); 5967c478bd9Sstevel@tonic-gate if (clp == NULL) { 5977c478bd9Sstevel@tonic-gate SET_DB_ERR(hdp); 5987c478bd9Sstevel@tonic-gate break; 5997c478bd9Sstevel@tonic-gate } 6007c478bd9Sstevel@tonic-gate 6017c478bd9Sstevel@tonic-gate (void) dprintf(DBG_STEP, "read_links: link[%u]: %s%s\n", 6027c478bd9Sstevel@tonic-gate nidx, clp->path, pcmp == NULL ? "(DANGLING)" : ""); 6037c478bd9Sstevel@tonic-gate } 6047c478bd9Sstevel@tonic-gate 6057c478bd9Sstevel@tonic-gate return (dlp ? -1 : 0); 6067c478bd9Sstevel@tonic-gate } 6077c478bd9Sstevel@tonic-gate 6087c478bd9Sstevel@tonic-gate int 6097c478bd9Sstevel@tonic-gate di_devlink_close(di_devlink_handle_t *pp, int flag) 6107c478bd9Sstevel@tonic-gate { 6117c478bd9Sstevel@tonic-gate int i, rv; 6127c478bd9Sstevel@tonic-gate char tmp[PATH_MAX]; 6137c478bd9Sstevel@tonic-gate char file[PATH_MAX]; 6147c478bd9Sstevel@tonic-gate uint32_t next[DB_TYPES] = {0}; 6157c478bd9Sstevel@tonic-gate struct di_devlink_handle *hdp; 6167c478bd9Sstevel@tonic-gate 6177c478bd9Sstevel@tonic-gate if (pp == NULL || *pp == NULL || !HDL_RDWR(*pp)) { 6187c478bd9Sstevel@tonic-gate errno = EINVAL; 6197c478bd9Sstevel@tonic-gate return (-1); 6207c478bd9Sstevel@tonic-gate } 6217c478bd9Sstevel@tonic-gate 6227c478bd9Sstevel@tonic-gate hdp = *pp; 6237c478bd9Sstevel@tonic-gate *pp = NULL; 6247c478bd9Sstevel@tonic-gate 6257c478bd9Sstevel@tonic-gate /* 6267c478bd9Sstevel@tonic-gate * The caller encountered some error in their processing. 6277c478bd9Sstevel@tonic-gate * so handle isn't valid. Discard it and return success. 6287c478bd9Sstevel@tonic-gate */ 6297c478bd9Sstevel@tonic-gate if (flag == DI_LINK_ERROR) { 6307c478bd9Sstevel@tonic-gate handle_free(&hdp); 6317c478bd9Sstevel@tonic-gate return (0); 6327c478bd9Sstevel@tonic-gate } 6337c478bd9Sstevel@tonic-gate 6347c478bd9Sstevel@tonic-gate if (DB_ERR(hdp)) { 6357c478bd9Sstevel@tonic-gate handle_free(&hdp); 6367c478bd9Sstevel@tonic-gate errno = EINVAL; 6377c478bd9Sstevel@tonic-gate return (-1); 6387c478bd9Sstevel@tonic-gate } 6397c478bd9Sstevel@tonic-gate 6407c478bd9Sstevel@tonic-gate /* 6417c478bd9Sstevel@tonic-gate * Extract the DB path before the handle is freed. 6427c478bd9Sstevel@tonic-gate */ 6437c478bd9Sstevel@tonic-gate get_db_path(hdp, DB_FILE, file, sizeof (file)); 6447c478bd9Sstevel@tonic-gate get_db_path(hdp, DB_TMP, tmp, sizeof (tmp)); 6457c478bd9Sstevel@tonic-gate 6467c478bd9Sstevel@tonic-gate /* 6477c478bd9Sstevel@tonic-gate * update database with actual contents of /dev 6487c478bd9Sstevel@tonic-gate */ 6497c478bd9Sstevel@tonic-gate (void) dprintf(DBG_INFO, "di_devlink_close: update_count = %u\n", 6507c478bd9Sstevel@tonic-gate CACHE(hdp)->update_count); 6517c478bd9Sstevel@tonic-gate 6527c478bd9Sstevel@tonic-gate /* 6537c478bd9Sstevel@tonic-gate * For performance reasons, synchronization of the database 6547c478bd9Sstevel@tonic-gate * with /dev is turned off by default. However, applications 6557c478bd9Sstevel@tonic-gate * with appropriate permissions can request a "sync" by 6567c478bd9Sstevel@tonic-gate * calling di_devlink_update(). 6577c478bd9Sstevel@tonic-gate */ 6587c478bd9Sstevel@tonic-gate if (CACHE(hdp)->update_count == 0) { 6597c478bd9Sstevel@tonic-gate CACHE(hdp)->update_count = 1; 6607c478bd9Sstevel@tonic-gate (void) dprintf(DBG_INFO, 6617c478bd9Sstevel@tonic-gate "di_devlink_close: synchronizing DB\n"); 6627c478bd9Sstevel@tonic-gate (void) synchronize_db(hdp); 6637c478bd9Sstevel@tonic-gate } 6647c478bd9Sstevel@tonic-gate 6657c478bd9Sstevel@tonic-gate /* 6667c478bd9Sstevel@tonic-gate * Resolve dangling links AFTER synchronizing DB with /dev as the 6677c478bd9Sstevel@tonic-gate * synchronization process may create dangling links. 6687c478bd9Sstevel@tonic-gate */ 6697c478bd9Sstevel@tonic-gate resolve_dangling_links(hdp); 6707c478bd9Sstevel@tonic-gate 6717c478bd9Sstevel@tonic-gate /* 6727c478bd9Sstevel@tonic-gate * All changes to the cache are complete. Write out the cache 6737c478bd9Sstevel@tonic-gate * to the database only if it is not empty. 6747c478bd9Sstevel@tonic-gate */ 6757c478bd9Sstevel@tonic-gate if (CACHE_EMPTY(hdp)) { 6767c478bd9Sstevel@tonic-gate (void) dprintf(DBG_INFO, "di_devlink_close: skipping write\n"); 6777c478bd9Sstevel@tonic-gate (void) unlink(file); 6787c478bd9Sstevel@tonic-gate handle_free(&hdp); 6797c478bd9Sstevel@tonic-gate return (0); 6807c478bd9Sstevel@tonic-gate } 6817c478bd9Sstevel@tonic-gate 6827c478bd9Sstevel@tonic-gate if (open_db(hdp, OPEN_RDWR) != 0) { 6837c478bd9Sstevel@tonic-gate handle_free(&hdp); 6847c478bd9Sstevel@tonic-gate return (-1); 6857c478bd9Sstevel@tonic-gate } 6867c478bd9Sstevel@tonic-gate 6877c478bd9Sstevel@tonic-gate /* 688*ff2aee48Scth * Keep track of array assignments. There is at least 6897c478bd9Sstevel@tonic-gate * 1 element (the "NIL" element) per type. 6907c478bd9Sstevel@tonic-gate */ 6917c478bd9Sstevel@tonic-gate for (i = 0; i < DB_TYPES; i++) { 6927c478bd9Sstevel@tonic-gate next[i] = 1; 6937c478bd9Sstevel@tonic-gate } 6947c478bd9Sstevel@tonic-gate 6957c478bd9Sstevel@tonic-gate (void) write_nodes(hdp, NULL, CACHE_ROOT(hdp), next); 6967c478bd9Sstevel@tonic-gate (void) write_links(hdp, NULL, CACHE(hdp)->dngl, next); 6977c478bd9Sstevel@tonic-gate DB_HDR(hdp)->update_count = CACHE(hdp)->update_count; 6987c478bd9Sstevel@tonic-gate 6997c478bd9Sstevel@tonic-gate rv = close_db(hdp); 7007c478bd9Sstevel@tonic-gate 7017c478bd9Sstevel@tonic-gate if (rv != 0 || DB_ERR(hdp) || rename(tmp, file) != 0) { 7027c478bd9Sstevel@tonic-gate (void) dprintf(DBG_ERR, "di_devlink_close: %s error: %s\n", 7037c478bd9Sstevel@tonic-gate rv ? "close_db" : "DB or rename", strerror(errno)); 7047c478bd9Sstevel@tonic-gate (void) unlink(tmp); 7057c478bd9Sstevel@tonic-gate (void) unlink(file); 7067c478bd9Sstevel@tonic-gate handle_free(&hdp); 7077c478bd9Sstevel@tonic-gate return (-1); 7087c478bd9Sstevel@tonic-gate } 7097c478bd9Sstevel@tonic-gate 7107c478bd9Sstevel@tonic-gate handle_free(&hdp); 7117c478bd9Sstevel@tonic-gate 7127c478bd9Sstevel@tonic-gate (void) dprintf(DBG_INFO, "di_devlink_close: wrote DB(%s)\n", file); 7137c478bd9Sstevel@tonic-gate 7147c478bd9Sstevel@tonic-gate return (0); 7157c478bd9Sstevel@tonic-gate } 7167c478bd9Sstevel@tonic-gate 7177c478bd9Sstevel@tonic-gate /* 7187c478bd9Sstevel@tonic-gate * Inits the database header. 7197c478bd9Sstevel@tonic-gate */ 7207c478bd9Sstevel@tonic-gate static int 7217c478bd9Sstevel@tonic-gate init_hdr(struct di_devlink_handle *hdp, long page_sz, uint32_t *count) 7227c478bd9Sstevel@tonic-gate { 7237c478bd9Sstevel@tonic-gate int i; 7247c478bd9Sstevel@tonic-gate 7257c478bd9Sstevel@tonic-gate DB_HDR(hdp)->magic = DB_MAGIC; 7267c478bd9Sstevel@tonic-gate DB_HDR(hdp)->vers = DB_VERSION; 7277c478bd9Sstevel@tonic-gate DB_HDR(hdp)->root_idx = DB_NIL; 7287c478bd9Sstevel@tonic-gate DB_HDR(hdp)->dngl_idx = DB_NIL; 7297c478bd9Sstevel@tonic-gate DB_HDR(hdp)->page_sz = (uint32_t)page_sz; 7307c478bd9Sstevel@tonic-gate 7317c478bd9Sstevel@tonic-gate for (i = 0; i < DB_TYPES; i++) { 7327c478bd9Sstevel@tonic-gate assert(count[i] >= 1); 7337c478bd9Sstevel@tonic-gate DB_NUM(hdp, i) = count[i]; 7347c478bd9Sstevel@tonic-gate } 7357c478bd9Sstevel@tonic-gate 7367c478bd9Sstevel@tonic-gate return (0); 7377c478bd9Sstevel@tonic-gate } 7387c478bd9Sstevel@tonic-gate 7397c478bd9Sstevel@tonic-gate static int 7407c478bd9Sstevel@tonic-gate write_nodes( 7417c478bd9Sstevel@tonic-gate struct di_devlink_handle *hdp, 7427c478bd9Sstevel@tonic-gate struct db_node *pdnp, 7437c478bd9Sstevel@tonic-gate cache_node_t *cnp, 7447c478bd9Sstevel@tonic-gate uint32_t *next) 7457c478bd9Sstevel@tonic-gate { 7467c478bd9Sstevel@tonic-gate uint32_t idx; 7477c478bd9Sstevel@tonic-gate struct db_node *dnp; 7487c478bd9Sstevel@tonic-gate const char *fcn = "write_nodes"; 7497c478bd9Sstevel@tonic-gate 7507c478bd9Sstevel@tonic-gate assert(HDL_RDWR(hdp)); 7517c478bd9Sstevel@tonic-gate 7527c478bd9Sstevel@tonic-gate for (; cnp != NULL; cnp = cnp->sib) { 7537c478bd9Sstevel@tonic-gate 7547c478bd9Sstevel@tonic-gate assert(cnp->path != NULL); 7557c478bd9Sstevel@tonic-gate 7567c478bd9Sstevel@tonic-gate /* parent node should only be NULL for root node */ 7577c478bd9Sstevel@tonic-gate if ((pdnp == NULL) ^ (cnp == CACHE_ROOT(hdp))) { 7587c478bd9Sstevel@tonic-gate (void) dprintf(DBG_ERR, "%s: invalid parent for: %s\n", 7597c478bd9Sstevel@tonic-gate fcn, cnp->path); 7607c478bd9Sstevel@tonic-gate SET_DB_ERR(hdp); 7617c478bd9Sstevel@tonic-gate break; 7627c478bd9Sstevel@tonic-gate } 7637c478bd9Sstevel@tonic-gate 7647c478bd9Sstevel@tonic-gate assert((strcmp(cnp->path, "/") != 0) ^ 7657c478bd9Sstevel@tonic-gate (cnp == CACHE_ROOT(hdp))); 7667c478bd9Sstevel@tonic-gate 7677c478bd9Sstevel@tonic-gate idx = next[DB_NODE]; 7687c478bd9Sstevel@tonic-gate if ((dnp = set_node(hdp, idx)) == NULL) { 7697c478bd9Sstevel@tonic-gate SET_DB_ERR(hdp); 7707c478bd9Sstevel@tonic-gate break; 7717c478bd9Sstevel@tonic-gate } 7727c478bd9Sstevel@tonic-gate 7737c478bd9Sstevel@tonic-gate dnp->path = write_string(hdp, cnp->path, next); 7747c478bd9Sstevel@tonic-gate if (dnp->path == DB_NIL) { 7757c478bd9Sstevel@tonic-gate SET_DB_ERR(hdp); 7767c478bd9Sstevel@tonic-gate break; 7777c478bd9Sstevel@tonic-gate } 7787c478bd9Sstevel@tonic-gate /* commit write for this node */ 7797c478bd9Sstevel@tonic-gate next[DB_NODE]++; 7807c478bd9Sstevel@tonic-gate 7817c478bd9Sstevel@tonic-gate if (pdnp == NULL) { 7827c478bd9Sstevel@tonic-gate assert(DB_HDR(hdp)->root_idx == DB_NIL); 7837c478bd9Sstevel@tonic-gate DB_HDR(hdp)->root_idx = idx; 7847c478bd9Sstevel@tonic-gate } else { 7857c478bd9Sstevel@tonic-gate dnp->sib = pdnp->child; 7867c478bd9Sstevel@tonic-gate pdnp->child = idx; 7877c478bd9Sstevel@tonic-gate } 7887c478bd9Sstevel@tonic-gate 7897c478bd9Sstevel@tonic-gate (void) dprintf(DBG_STEP, "%s: node[%u]: %s\n", fcn, idx, 7907c478bd9Sstevel@tonic-gate cnp->path); 7917c478bd9Sstevel@tonic-gate 7927c478bd9Sstevel@tonic-gate if (write_minors(hdp, dnp, cnp->minor, next) != 0 || 7937c478bd9Sstevel@tonic-gate write_nodes(hdp, dnp, cnp->child, next) != 0) { 7947c478bd9Sstevel@tonic-gate break; 7957c478bd9Sstevel@tonic-gate } 7967c478bd9Sstevel@tonic-gate } 7977c478bd9Sstevel@tonic-gate 7987c478bd9Sstevel@tonic-gate return (cnp ? -1 : 0); 7997c478bd9Sstevel@tonic-gate } 8007c478bd9Sstevel@tonic-gate 8017c478bd9Sstevel@tonic-gate static int 8027c478bd9Sstevel@tonic-gate write_minors( 8037c478bd9Sstevel@tonic-gate struct di_devlink_handle *hdp, 8047c478bd9Sstevel@tonic-gate struct db_node *pdnp, 8057c478bd9Sstevel@tonic-gate cache_minor_t *cmnp, 8067c478bd9Sstevel@tonic-gate uint32_t *next) 8077c478bd9Sstevel@tonic-gate { 8087c478bd9Sstevel@tonic-gate uint32_t idx; 8097c478bd9Sstevel@tonic-gate struct db_minor *dmp; 8107c478bd9Sstevel@tonic-gate const char *fcn = "write_minors"; 8117c478bd9Sstevel@tonic-gate 8127c478bd9Sstevel@tonic-gate assert(HDL_RDWR(hdp)); 8137c478bd9Sstevel@tonic-gate 8147c478bd9Sstevel@tonic-gate if (pdnp == NULL) { 8157c478bd9Sstevel@tonic-gate (void) dprintf(DBG_ERR, "%s: no node for minor: %s\n", fcn, 8167c478bd9Sstevel@tonic-gate cmnp ? cmnp->name : "<NULL>"); 8177c478bd9Sstevel@tonic-gate SET_DB_ERR(hdp); 8187c478bd9Sstevel@tonic-gate return (-1); 8197c478bd9Sstevel@tonic-gate } 8207c478bd9Sstevel@tonic-gate 8217c478bd9Sstevel@tonic-gate for (; cmnp != NULL; cmnp = cmnp->sib) { 8227c478bd9Sstevel@tonic-gate 8237c478bd9Sstevel@tonic-gate assert(cmnp->name != NULL); 8247c478bd9Sstevel@tonic-gate 8257c478bd9Sstevel@tonic-gate idx = next[DB_MINOR]; 8267c478bd9Sstevel@tonic-gate if ((dmp = set_minor(hdp, idx)) == NULL) { 8277c478bd9Sstevel@tonic-gate SET_DB_ERR(hdp); 8287c478bd9Sstevel@tonic-gate break; 8297c478bd9Sstevel@tonic-gate } 8307c478bd9Sstevel@tonic-gate 8317c478bd9Sstevel@tonic-gate dmp->name = write_string(hdp, cmnp->name, next); 8327c478bd9Sstevel@tonic-gate dmp->nodetype = write_string(hdp, cmnp->nodetype, next); 8337c478bd9Sstevel@tonic-gate if (dmp->name == DB_NIL || dmp->nodetype == DB_NIL) { 8347c478bd9Sstevel@tonic-gate dmp->name = dmp->nodetype = DB_NIL; 8357c478bd9Sstevel@tonic-gate SET_DB_ERR(hdp); 8367c478bd9Sstevel@tonic-gate break; 8377c478bd9Sstevel@tonic-gate } 8387c478bd9Sstevel@tonic-gate 8397c478bd9Sstevel@tonic-gate /* Commit writes to this minor */ 8407c478bd9Sstevel@tonic-gate next[DB_MINOR]++; 8417c478bd9Sstevel@tonic-gate 8427c478bd9Sstevel@tonic-gate dmp->sib = pdnp->minor; 8437c478bd9Sstevel@tonic-gate pdnp->minor = idx; 8447c478bd9Sstevel@tonic-gate 8457c478bd9Sstevel@tonic-gate (void) dprintf(DBG_STEP, "%s: minor[%u]: %s\n", fcn, idx, 8467c478bd9Sstevel@tonic-gate cmnp->name); 8477c478bd9Sstevel@tonic-gate 8487c478bd9Sstevel@tonic-gate if (write_links(hdp, dmp, cmnp->link, next) != 0) { 8497c478bd9Sstevel@tonic-gate break; 8507c478bd9Sstevel@tonic-gate } 8517c478bd9Sstevel@tonic-gate } 8527c478bd9Sstevel@tonic-gate 8537c478bd9Sstevel@tonic-gate return (cmnp ? -1 : 0); 8547c478bd9Sstevel@tonic-gate } 8557c478bd9Sstevel@tonic-gate 8567c478bd9Sstevel@tonic-gate static int 8577c478bd9Sstevel@tonic-gate write_links( 8587c478bd9Sstevel@tonic-gate struct di_devlink_handle *hdp, 8597c478bd9Sstevel@tonic-gate struct db_minor *pdmp, 8607c478bd9Sstevel@tonic-gate cache_link_t *clp, 8617c478bd9Sstevel@tonic-gate uint32_t *next) 8627c478bd9Sstevel@tonic-gate { 8637c478bd9Sstevel@tonic-gate uint32_t idx; 8647c478bd9Sstevel@tonic-gate struct db_link *dlp; 8657c478bd9Sstevel@tonic-gate const char *fcn = "write_links"; 8667c478bd9Sstevel@tonic-gate 8677c478bd9Sstevel@tonic-gate assert(HDL_RDWR(hdp)); 8687c478bd9Sstevel@tonic-gate 8697c478bd9Sstevel@tonic-gate /* A NULL minor if and only if the links are dangling */ 8707c478bd9Sstevel@tonic-gate if (clp != NULL && ((pdmp == NULL) ^ (clp == CACHE(hdp)->dngl))) { 8717c478bd9Sstevel@tonic-gate (void) dprintf(DBG_ERR, "%s: invalid minor for link\n", fcn); 8727c478bd9Sstevel@tonic-gate SET_DB_ERR(hdp); 8737c478bd9Sstevel@tonic-gate return (-1); 8747c478bd9Sstevel@tonic-gate } 8757c478bd9Sstevel@tonic-gate 8767c478bd9Sstevel@tonic-gate for (; clp != NULL; clp = clp->sib) { 8777c478bd9Sstevel@tonic-gate 8787c478bd9Sstevel@tonic-gate assert(clp->path != NULL); 8797c478bd9Sstevel@tonic-gate 8807c478bd9Sstevel@tonic-gate if ((pdmp == NULL) ^ (clp->minor == NULL)) { 8817c478bd9Sstevel@tonic-gate (void) dprintf(DBG_ERR, "%s: invalid minor for link" 8827c478bd9Sstevel@tonic-gate "(%s)\n", fcn, clp->path); 8837c478bd9Sstevel@tonic-gate SET_DB_ERR(hdp); 8847c478bd9Sstevel@tonic-gate break; 8857c478bd9Sstevel@tonic-gate } 8867c478bd9Sstevel@tonic-gate 8877c478bd9Sstevel@tonic-gate idx = next[DB_LINK]; 8887c478bd9Sstevel@tonic-gate if ((dlp = set_link(hdp, idx)) == NULL) { 8897c478bd9Sstevel@tonic-gate SET_DB_ERR(hdp); 8907c478bd9Sstevel@tonic-gate break; 8917c478bd9Sstevel@tonic-gate } 8927c478bd9Sstevel@tonic-gate 8937c478bd9Sstevel@tonic-gate dlp->path = write_string(hdp, clp->path, next); 8947c478bd9Sstevel@tonic-gate dlp->content = write_string(hdp, clp->content, next); 8957c478bd9Sstevel@tonic-gate if (dlp->path == DB_NIL || dlp->content == DB_NIL) { 8967c478bd9Sstevel@tonic-gate dlp->path = dlp->content = DB_NIL; 8977c478bd9Sstevel@tonic-gate SET_DB_ERR(hdp); 8987c478bd9Sstevel@tonic-gate break; 8997c478bd9Sstevel@tonic-gate } 9007c478bd9Sstevel@tonic-gate 9017c478bd9Sstevel@tonic-gate dlp->attr = clp->attr; 9027c478bd9Sstevel@tonic-gate 9037c478bd9Sstevel@tonic-gate /* Commit writes to this link */ 9047c478bd9Sstevel@tonic-gate next[DB_LINK]++; 9057c478bd9Sstevel@tonic-gate 9067c478bd9Sstevel@tonic-gate if (pdmp != NULL) { 9077c478bd9Sstevel@tonic-gate dlp->sib = pdmp->link; 9087c478bd9Sstevel@tonic-gate pdmp->link = idx; 9097c478bd9Sstevel@tonic-gate } else { 9107c478bd9Sstevel@tonic-gate dlp->sib = DB_HDR(hdp)->dngl_idx; 9117c478bd9Sstevel@tonic-gate DB_HDR(hdp)->dngl_idx = idx; 9127c478bd9Sstevel@tonic-gate } 9137c478bd9Sstevel@tonic-gate 9147c478bd9Sstevel@tonic-gate (void) dprintf(DBG_STEP, "%s: link[%u]: %s%s\n", fcn, idx, 9157c478bd9Sstevel@tonic-gate clp->path, pdmp == NULL ? "(DANGLING)" : ""); 9167c478bd9Sstevel@tonic-gate } 9177c478bd9Sstevel@tonic-gate 9187c478bd9Sstevel@tonic-gate return (clp ? -1 : 0); 9197c478bd9Sstevel@tonic-gate } 9207c478bd9Sstevel@tonic-gate 9217c478bd9Sstevel@tonic-gate 9227c478bd9Sstevel@tonic-gate static uint32_t 9237c478bd9Sstevel@tonic-gate write_string(struct di_devlink_handle *hdp, const char *str, uint32_t *next) 9247c478bd9Sstevel@tonic-gate { 9257c478bd9Sstevel@tonic-gate char *dstr; 9267c478bd9Sstevel@tonic-gate uint32_t idx; 9277c478bd9Sstevel@tonic-gate 9287c478bd9Sstevel@tonic-gate assert(HDL_RDWR(hdp)); 9297c478bd9Sstevel@tonic-gate 9307c478bd9Sstevel@tonic-gate if (str == NULL) { 9317c478bd9Sstevel@tonic-gate (void) dprintf(DBG_ERR, "write_string: NULL argument\n"); 9327c478bd9Sstevel@tonic-gate return (DB_NIL); 9337c478bd9Sstevel@tonic-gate } 9347c478bd9Sstevel@tonic-gate 9357c478bd9Sstevel@tonic-gate idx = next[DB_STR]; 9367c478bd9Sstevel@tonic-gate if (!VALID_STR(hdp, idx, str)) { 9377c478bd9Sstevel@tonic-gate (void) dprintf(DBG_ERR, "write_string: invalid index[%u]," 9387c478bd9Sstevel@tonic-gate " string(%s)\n", idx, str); 9397c478bd9Sstevel@tonic-gate return (DB_NIL); 9407c478bd9Sstevel@tonic-gate } 9417c478bd9Sstevel@tonic-gate 9427c478bd9Sstevel@tonic-gate if ((dstr = set_string(hdp, idx)) == NULL) { 9437c478bd9Sstevel@tonic-gate return (DB_NIL); 9447c478bd9Sstevel@tonic-gate } 9457c478bd9Sstevel@tonic-gate 9467c478bd9Sstevel@tonic-gate (void) strcpy(dstr, str); 9477c478bd9Sstevel@tonic-gate 9487c478bd9Sstevel@tonic-gate next[DB_STR] += strlen(dstr) + 1; 9497c478bd9Sstevel@tonic-gate 9507c478bd9Sstevel@tonic-gate return (idx); 9517c478bd9Sstevel@tonic-gate } 9527c478bd9Sstevel@tonic-gate 9537c478bd9Sstevel@tonic-gate static int 9547c478bd9Sstevel@tonic-gate close_db(struct di_devlink_handle *hdp) 9557c478bd9Sstevel@tonic-gate { 9567c478bd9Sstevel@tonic-gate int i, rv = 0; 9577c478bd9Sstevel@tonic-gate size_t sz; 9587c478bd9Sstevel@tonic-gate 9597c478bd9Sstevel@tonic-gate if (!DB_OPEN(hdp)) { 9607c478bd9Sstevel@tonic-gate #ifdef DEBUG 9617c478bd9Sstevel@tonic-gate assert(DB(hdp)->db_fd == -1); 9627c478bd9Sstevel@tonic-gate assert(DB(hdp)->flags == 0); 9637c478bd9Sstevel@tonic-gate for (i = 0; i < DB_TYPES; i++) { 9647c478bd9Sstevel@tonic-gate assert(DB_SEG(hdp, i) == NULL); 9657c478bd9Sstevel@tonic-gate assert(DB_SEG_PROT(hdp, i) == 0); 9667c478bd9Sstevel@tonic-gate } 9677c478bd9Sstevel@tonic-gate #endif 9687c478bd9Sstevel@tonic-gate return (0); 9697c478bd9Sstevel@tonic-gate } 9707c478bd9Sstevel@tonic-gate 9717c478bd9Sstevel@tonic-gate /* Unmap header after unmapping all other mapped segments */ 9727c478bd9Sstevel@tonic-gate for (i = 0; i < DB_TYPES; i++) { 9737c478bd9Sstevel@tonic-gate if (DB_SEG(hdp, i)) { 9747c478bd9Sstevel@tonic-gate sz = seg_size(hdp, i); 9757c478bd9Sstevel@tonic-gate if (DB_RDWR(hdp)) 9767c478bd9Sstevel@tonic-gate rv += msync(DB_SEG(hdp, i), sz, MS_SYNC); 9777c478bd9Sstevel@tonic-gate (void) munmap(DB_SEG(hdp, i), sz); 9787c478bd9Sstevel@tonic-gate DB_SEG(hdp, i) = NULL; 9797c478bd9Sstevel@tonic-gate DB_SEG_PROT(hdp, i) = 0; 9807c478bd9Sstevel@tonic-gate } 9817c478bd9Sstevel@tonic-gate } 9827c478bd9Sstevel@tonic-gate 9837c478bd9Sstevel@tonic-gate if (DB_RDWR(hdp)) 9847c478bd9Sstevel@tonic-gate rv += msync((caddr_t)DB_HDR(hdp), HDR_LEN, MS_SYNC); 9857c478bd9Sstevel@tonic-gate (void) munmap((caddr_t)DB_HDR(hdp), HDR_LEN); 9867c478bd9Sstevel@tonic-gate DB(hdp)->hdr = NULL; 9877c478bd9Sstevel@tonic-gate 9887c478bd9Sstevel@tonic-gate (void) close(DB(hdp)->db_fd); 9897c478bd9Sstevel@tonic-gate DB(hdp)->db_fd = -1; 9907c478bd9Sstevel@tonic-gate DB(hdp)->flags = 0; 9917c478bd9Sstevel@tonic-gate 9927c478bd9Sstevel@tonic-gate return (rv ? -1 : 0); 9937c478bd9Sstevel@tonic-gate } 9947c478bd9Sstevel@tonic-gate 9957c478bd9Sstevel@tonic-gate 9967c478bd9Sstevel@tonic-gate static void 9977c478bd9Sstevel@tonic-gate cache_free(struct di_devlink_handle *hdp) 9987c478bd9Sstevel@tonic-gate { 9997c478bd9Sstevel@tonic-gate cache_link_t *clp; 10007c478bd9Sstevel@tonic-gate 10017c478bd9Sstevel@tonic-gate subtree_free(hdp, &(CACHE_ROOT(hdp))); 10027c478bd9Sstevel@tonic-gate assert(CACHE_LAST(hdp) == NULL); 10037c478bd9Sstevel@tonic-gate 10047c478bd9Sstevel@tonic-gate /* 10057c478bd9Sstevel@tonic-gate * Don't bother removing links from hash table chains, 10067c478bd9Sstevel@tonic-gate * as we are freeing the hash table itself. 10077c478bd9Sstevel@tonic-gate */ 10087c478bd9Sstevel@tonic-gate while (CACHE(hdp)->dngl != NULL) { 10097c478bd9Sstevel@tonic-gate clp = CACHE(hdp)->dngl; 10107c478bd9Sstevel@tonic-gate CACHE(hdp)->dngl = clp->sib; 10117c478bd9Sstevel@tonic-gate assert(clp->minor == NULL); 10127c478bd9Sstevel@tonic-gate link_free(&clp); 10137c478bd9Sstevel@tonic-gate } 10147c478bd9Sstevel@tonic-gate 10157c478bd9Sstevel@tonic-gate assert((CACHE(hdp)->hash == NULL) ^ (CACHE(hdp)->hash_sz != 0)); 10167c478bd9Sstevel@tonic-gate 10177c478bd9Sstevel@tonic-gate free(CACHE(hdp)->hash); 10187c478bd9Sstevel@tonic-gate CACHE(hdp)->hash = NULL; 10197c478bd9Sstevel@tonic-gate CACHE(hdp)->hash_sz = 0; 10207c478bd9Sstevel@tonic-gate } 10217c478bd9Sstevel@tonic-gate 10227c478bd9Sstevel@tonic-gate static void 10237c478bd9Sstevel@tonic-gate handle_free(struct di_devlink_handle **pp) 10247c478bd9Sstevel@tonic-gate { 10257c478bd9Sstevel@tonic-gate struct di_devlink_handle *hdp = *pp; 10267c478bd9Sstevel@tonic-gate 10277c478bd9Sstevel@tonic-gate *pp = NULL; 10287c478bd9Sstevel@tonic-gate 10297c478bd9Sstevel@tonic-gate if (hdp == NULL) 10307c478bd9Sstevel@tonic-gate return; 10317c478bd9Sstevel@tonic-gate 10327c478bd9Sstevel@tonic-gate (void) close_db(hdp); 10337c478bd9Sstevel@tonic-gate cache_free(hdp); 10347c478bd9Sstevel@tonic-gate 10357c478bd9Sstevel@tonic-gate if (HDL_RDWR(hdp)) 1036*ff2aee48Scth exit_db_lock(hdp); 10377c478bd9Sstevel@tonic-gate assert(hdp->lock_fd == -1); 10387c478bd9Sstevel@tonic-gate 10397c478bd9Sstevel@tonic-gate free(hdp->dev_dir); 1040a08731ecScth free(hdp->db_dir); 10417c478bd9Sstevel@tonic-gate free(hdp); 10427c478bd9Sstevel@tonic-gate } 10437c478bd9Sstevel@tonic-gate 10447c478bd9Sstevel@tonic-gate /* 10457c478bd9Sstevel@tonic-gate * Frees the tree rooted at a node. Siblings of the subtree root 10467c478bd9Sstevel@tonic-gate * have to be handled by the caller. 10477c478bd9Sstevel@tonic-gate */ 10487c478bd9Sstevel@tonic-gate static void 10497c478bd9Sstevel@tonic-gate subtree_free(struct di_devlink_handle *hdp, cache_node_t **pp) 10507c478bd9Sstevel@tonic-gate { 10517c478bd9Sstevel@tonic-gate cache_node_t *np; 10527c478bd9Sstevel@tonic-gate cache_link_t *clp; 10537c478bd9Sstevel@tonic-gate cache_minor_t *cmnp; 10547c478bd9Sstevel@tonic-gate 10557c478bd9Sstevel@tonic-gate if (pp == NULL || *pp == NULL) 10567c478bd9Sstevel@tonic-gate return; 10577c478bd9Sstevel@tonic-gate 10587c478bd9Sstevel@tonic-gate while ((*pp)->child != NULL) { 10597c478bd9Sstevel@tonic-gate np = (*pp)->child; 10607c478bd9Sstevel@tonic-gate (*pp)->child = np->sib; 10617c478bd9Sstevel@tonic-gate subtree_free(hdp, &np); 10627c478bd9Sstevel@tonic-gate } 10637c478bd9Sstevel@tonic-gate 10647c478bd9Sstevel@tonic-gate while ((*pp)->minor != NULL) { 10657c478bd9Sstevel@tonic-gate cmnp = (*pp)->minor; 10667c478bd9Sstevel@tonic-gate (*pp)->minor = cmnp->sib; 10677c478bd9Sstevel@tonic-gate 10687c478bd9Sstevel@tonic-gate while (cmnp->link != NULL) { 10697c478bd9Sstevel@tonic-gate clp = cmnp->link; 10707c478bd9Sstevel@tonic-gate cmnp->link = clp->sib; 10717c478bd9Sstevel@tonic-gate rm_link_from_hash(hdp, clp); 10727c478bd9Sstevel@tonic-gate link_free(&clp); 10737c478bd9Sstevel@tonic-gate } 10747c478bd9Sstevel@tonic-gate minor_free(hdp, &cmnp); 10757c478bd9Sstevel@tonic-gate } 10767c478bd9Sstevel@tonic-gate 10777c478bd9Sstevel@tonic-gate node_free(pp); 10787c478bd9Sstevel@tonic-gate } 10797c478bd9Sstevel@tonic-gate 10807c478bd9Sstevel@tonic-gate static void 10817c478bd9Sstevel@tonic-gate rm_link_from_hash(struct di_devlink_handle *hdp, cache_link_t *clp) 10827c478bd9Sstevel@tonic-gate { 10837c478bd9Sstevel@tonic-gate int hval; 10847c478bd9Sstevel@tonic-gate cache_link_t **pp; 10857c478bd9Sstevel@tonic-gate 10867c478bd9Sstevel@tonic-gate if (clp == NULL) 10877c478bd9Sstevel@tonic-gate return; 10887c478bd9Sstevel@tonic-gate 10897c478bd9Sstevel@tonic-gate if (clp->path == NULL) 10907c478bd9Sstevel@tonic-gate return; 10917c478bd9Sstevel@tonic-gate 10927c478bd9Sstevel@tonic-gate hval = hashfn(hdp, clp->path); 10937c478bd9Sstevel@tonic-gate pp = &(CACHE_HASH(hdp, hval)); 10947c478bd9Sstevel@tonic-gate for (; *pp != NULL; pp = &(*pp)->hash) { 10957c478bd9Sstevel@tonic-gate if (*pp == clp) { 10967c478bd9Sstevel@tonic-gate *pp = clp->hash; 10977c478bd9Sstevel@tonic-gate clp->hash = NULL; 10987c478bd9Sstevel@tonic-gate return; 10997c478bd9Sstevel@tonic-gate } 11007c478bd9Sstevel@tonic-gate } 11017c478bd9Sstevel@tonic-gate 11027c478bd9Sstevel@tonic-gate dprintf(DBG_ERR, "rm_link_from_hash: link(%s) not found\n", clp->path); 11037c478bd9Sstevel@tonic-gate } 11047c478bd9Sstevel@tonic-gate 11057c478bd9Sstevel@tonic-gate static cache_link_t * 11067c478bd9Sstevel@tonic-gate link_hash(di_devlink_handle_t hdp, const char *link, uint_t flags) 11077c478bd9Sstevel@tonic-gate { 11087c478bd9Sstevel@tonic-gate int hval; 11097c478bd9Sstevel@tonic-gate cache_link_t **pp, *clp; 11107c478bd9Sstevel@tonic-gate 11117c478bd9Sstevel@tonic-gate if (link == NULL) 11127c478bd9Sstevel@tonic-gate return (NULL); 11137c478bd9Sstevel@tonic-gate 11147c478bd9Sstevel@tonic-gate hval = hashfn(hdp, link); 11157c478bd9Sstevel@tonic-gate pp = &(CACHE_HASH(hdp, hval)); 11167c478bd9Sstevel@tonic-gate for (; (clp = *pp) != NULL; pp = &clp->hash) { 11177c478bd9Sstevel@tonic-gate if (strcmp(clp->path, link) == 0) { 11187c478bd9Sstevel@tonic-gate break; 11197c478bd9Sstevel@tonic-gate } 11207c478bd9Sstevel@tonic-gate } 11217c478bd9Sstevel@tonic-gate 11227c478bd9Sstevel@tonic-gate if (clp == NULL) 11237c478bd9Sstevel@tonic-gate return (NULL); 11247c478bd9Sstevel@tonic-gate 11257c478bd9Sstevel@tonic-gate if ((flags & UNLINK_FROM_HASH) == UNLINK_FROM_HASH) { 11267c478bd9Sstevel@tonic-gate *pp = clp->hash; 11277c478bd9Sstevel@tonic-gate clp->hash = NULL; 11287c478bd9Sstevel@tonic-gate } 11297c478bd9Sstevel@tonic-gate 11307c478bd9Sstevel@tonic-gate return (clp); 11317c478bd9Sstevel@tonic-gate } 11327c478bd9Sstevel@tonic-gate 11337c478bd9Sstevel@tonic-gate static cache_minor_t * 11347c478bd9Sstevel@tonic-gate link2minor(struct di_devlink_handle *hdp, cache_link_t *clp) 11357c478bd9Sstevel@tonic-gate { 11367c478bd9Sstevel@tonic-gate cache_link_t *plp; 11377c478bd9Sstevel@tonic-gate const char *minor_path; 11387c478bd9Sstevel@tonic-gate char *cp, buf[PATH_MAX], link[PATH_MAX]; 1139facf4a8dSllai char abspath[PATH_MAX]; 1140facf4a8dSllai struct stat st; 11417c478bd9Sstevel@tonic-gate 11427c478bd9Sstevel@tonic-gate if (TYPE_PRI(attr2type(clp->attr))) { 11437c478bd9Sstevel@tonic-gate /* 11447c478bd9Sstevel@tonic-gate * For primary link, content should point to a /devices node. 11457c478bd9Sstevel@tonic-gate */ 11467c478bd9Sstevel@tonic-gate if (!is_minor_node(clp->content, &minor_path)) { 11477c478bd9Sstevel@tonic-gate return (NULL); 11487c478bd9Sstevel@tonic-gate } 11497c478bd9Sstevel@tonic-gate 11507c478bd9Sstevel@tonic-gate return (lookup_minor(hdp, minor_path, NULL, 11517c478bd9Sstevel@tonic-gate TYPE_CACHE|CREATE_FLAG)); 11527c478bd9Sstevel@tonic-gate 11537c478bd9Sstevel@tonic-gate } 11547c478bd9Sstevel@tonic-gate 11557c478bd9Sstevel@tonic-gate /* 11567c478bd9Sstevel@tonic-gate * If secondary, the primary link is derived from the secondary 11577c478bd9Sstevel@tonic-gate * link contents. Secondary link contents can have two formats: 1158facf4a8dSllai * audio -> /dev/sound/0 11597c478bd9Sstevel@tonic-gate * fb0 -> fbs/afb0 11607c478bd9Sstevel@tonic-gate */ 11617c478bd9Sstevel@tonic-gate 11627c478bd9Sstevel@tonic-gate buf[0] = '\0'; 11637c478bd9Sstevel@tonic-gate if (strncmp(clp->content, DEV"/", strlen(DEV"/")) == 0) { 11647c478bd9Sstevel@tonic-gate cp = &clp->content[strlen(DEV"/")]; 11657c478bd9Sstevel@tonic-gate } else if (clp->content[0] != '/') { 11667c478bd9Sstevel@tonic-gate if ((cp = strrchr(clp->path, '/')) != NULL) { 11677c478bd9Sstevel@tonic-gate char savechar = *(cp + 1); 11687c478bd9Sstevel@tonic-gate *(cp + 1) = '\0'; 11697c478bd9Sstevel@tonic-gate (void) snprintf(buf, sizeof (buf), "%s", clp->path); 11707c478bd9Sstevel@tonic-gate *(cp + 1) = savechar; 11717c478bd9Sstevel@tonic-gate } 11727c478bd9Sstevel@tonic-gate (void) strlcat(buf, clp->content, sizeof (buf)); 11737c478bd9Sstevel@tonic-gate cp = buf; 11747c478bd9Sstevel@tonic-gate } else { 11757c478bd9Sstevel@tonic-gate goto follow_link; 11767c478bd9Sstevel@tonic-gate } 11777c478bd9Sstevel@tonic-gate 11787c478bd9Sstevel@tonic-gate /* 11797c478bd9Sstevel@tonic-gate * Lookup the primary link if possible and find its minor. 11807c478bd9Sstevel@tonic-gate */ 11817c478bd9Sstevel@tonic-gate if ((plp = link_hash(hdp, cp, 0)) != NULL && plp->minor != NULL) { 11827c478bd9Sstevel@tonic-gate return (plp->minor); 11837c478bd9Sstevel@tonic-gate } 11847c478bd9Sstevel@tonic-gate 11857c478bd9Sstevel@tonic-gate /* realpath() used only as a last resort because it is expensive */ 11867c478bd9Sstevel@tonic-gate follow_link: 11877c478bd9Sstevel@tonic-gate (void) snprintf(link, sizeof (link), "%s/%s", hdp->dev_dir, clp->path); 11887c478bd9Sstevel@tonic-gate 11897c478bd9Sstevel@tonic-gate #ifdef DEBUG 11907c478bd9Sstevel@tonic-gate /*LINTED*/ 11917c478bd9Sstevel@tonic-gate assert(sizeof (buf) >= PATH_MAX); 11927c478bd9Sstevel@tonic-gate #endif 1193facf4a8dSllai 1194facf4a8dSllai /* 1195facf4a8dSllai * A realpath attempt to lookup a dangling link can invoke implicit 1196facf4a8dSllai * reconfig so verify there's an actual device behind the link first. 1197facf4a8dSllai */ 1198facf4a8dSllai if (lstat(link, &st) == -1) 1199facf4a8dSllai return (NULL); 1200facf4a8dSllai if (S_ISLNK(st.st_mode)) { 1201facf4a8dSllai if (s_readlink(link, buf, sizeof (buf)) < 0) 1202facf4a8dSllai return (NULL); 1203facf4a8dSllai if (buf[0] != '/') { 1204facf4a8dSllai char *p; 1205facf4a8dSllai size_t n = sizeof (abspath); 1206facf4a8dSllai if (strlcpy(abspath, link, n) >= n) 1207facf4a8dSllai return (NULL); 1208facf4a8dSllai p = strrchr(abspath, '/') + 1; 1209facf4a8dSllai *p = 0; 1210facf4a8dSllai n = sizeof (abspath) - strlen(p); 1211facf4a8dSllai if (strlcpy(p, buf, n) >= n) 1212facf4a8dSllai return (NULL); 1213facf4a8dSllai } else { 1214facf4a8dSllai if (strlcpy(abspath, buf, sizeof (abspath)) >= 1215facf4a8dSllai sizeof (abspath)) 1216facf4a8dSllai return (NULL); 1217facf4a8dSllai } 1218facf4a8dSllai if (!device_exists(abspath)) 1219facf4a8dSllai return (NULL); 1220facf4a8dSllai } 1221facf4a8dSllai 1222*ff2aee48Scth if (s_realpath(link, buf) == NULL || !is_minor_node(buf, &minor_path)) { 12237c478bd9Sstevel@tonic-gate return (NULL); 12247c478bd9Sstevel@tonic-gate } 12257c478bd9Sstevel@tonic-gate return (lookup_minor(hdp, minor_path, NULL, TYPE_CACHE|CREATE_FLAG)); 12267c478bd9Sstevel@tonic-gate } 12277c478bd9Sstevel@tonic-gate 12287c478bd9Sstevel@tonic-gate 12297c478bd9Sstevel@tonic-gate static void 12307c478bd9Sstevel@tonic-gate resolve_dangling_links(struct di_devlink_handle *hdp) 12317c478bd9Sstevel@tonic-gate { 12327c478bd9Sstevel@tonic-gate cache_minor_t *cmnp; 12337c478bd9Sstevel@tonic-gate cache_link_t *clp, **pp; 12347c478bd9Sstevel@tonic-gate 12357c478bd9Sstevel@tonic-gate for (pp = &(CACHE(hdp)->dngl); *pp != NULL; ) { 12367c478bd9Sstevel@tonic-gate clp = *pp; 12377c478bd9Sstevel@tonic-gate if ((cmnp = link2minor(hdp, clp)) != NULL) { 12387c478bd9Sstevel@tonic-gate *pp = clp->sib; 12397c478bd9Sstevel@tonic-gate clp->sib = cmnp->link; 12407c478bd9Sstevel@tonic-gate cmnp->link = clp; 12417c478bd9Sstevel@tonic-gate assert(clp->minor == NULL); 12427c478bd9Sstevel@tonic-gate clp->minor = cmnp; 12437c478bd9Sstevel@tonic-gate } else { 12447c478bd9Sstevel@tonic-gate dprintf(DBG_INFO, "resolve_dangling_links: link(%s):" 12457c478bd9Sstevel@tonic-gate " unresolved\n", clp->path); 12467c478bd9Sstevel@tonic-gate pp = &clp->sib; 12477c478bd9Sstevel@tonic-gate } 12487c478bd9Sstevel@tonic-gate } 12497c478bd9Sstevel@tonic-gate } 12507c478bd9Sstevel@tonic-gate 12517c478bd9Sstevel@tonic-gate 12527c478bd9Sstevel@tonic-gate /* 12537c478bd9Sstevel@tonic-gate * The elements are assumed to be detached from the cache tree. 12547c478bd9Sstevel@tonic-gate */ 12557c478bd9Sstevel@tonic-gate static void 12567c478bd9Sstevel@tonic-gate node_free(cache_node_t **pp) 12577c478bd9Sstevel@tonic-gate { 12587c478bd9Sstevel@tonic-gate cache_node_t *cnp = *pp; 12597c478bd9Sstevel@tonic-gate 12607c478bd9Sstevel@tonic-gate *pp = NULL; 12617c478bd9Sstevel@tonic-gate 12627c478bd9Sstevel@tonic-gate if (cnp == NULL) 12637c478bd9Sstevel@tonic-gate return; 12647c478bd9Sstevel@tonic-gate 12657c478bd9Sstevel@tonic-gate free(cnp->path); 12667c478bd9Sstevel@tonic-gate free(cnp); 12677c478bd9Sstevel@tonic-gate } 12687c478bd9Sstevel@tonic-gate 12697c478bd9Sstevel@tonic-gate static void 12707c478bd9Sstevel@tonic-gate minor_free(struct di_devlink_handle *hdp, cache_minor_t **pp) 12717c478bd9Sstevel@tonic-gate { 12727c478bd9Sstevel@tonic-gate cache_minor_t *cmnp = *pp; 12737c478bd9Sstevel@tonic-gate 12747c478bd9Sstevel@tonic-gate *pp = NULL; 12757c478bd9Sstevel@tonic-gate 12767c478bd9Sstevel@tonic-gate if (cmnp == NULL) 12777c478bd9Sstevel@tonic-gate return; 12787c478bd9Sstevel@tonic-gate 12797c478bd9Sstevel@tonic-gate if (CACHE_LAST(hdp) == cmnp) { 12807c478bd9Sstevel@tonic-gate dprintf(DBG_STEP, "minor_free: last_minor(%s)\n", cmnp->name); 12817c478bd9Sstevel@tonic-gate CACHE_LAST(hdp) = NULL; 12827c478bd9Sstevel@tonic-gate } 12837c478bd9Sstevel@tonic-gate 12847c478bd9Sstevel@tonic-gate free(cmnp->name); 12857c478bd9Sstevel@tonic-gate free(cmnp->nodetype); 12867c478bd9Sstevel@tonic-gate free(cmnp); 12877c478bd9Sstevel@tonic-gate } 12887c478bd9Sstevel@tonic-gate 12897c478bd9Sstevel@tonic-gate static void 12907c478bd9Sstevel@tonic-gate link_free(cache_link_t **pp) 12917c478bd9Sstevel@tonic-gate { 12927c478bd9Sstevel@tonic-gate cache_link_t *clp = *pp; 12937c478bd9Sstevel@tonic-gate 12947c478bd9Sstevel@tonic-gate *pp = NULL; 12957c478bd9Sstevel@tonic-gate 12967c478bd9Sstevel@tonic-gate if (clp == NULL) 12977c478bd9Sstevel@tonic-gate return; 12987c478bd9Sstevel@tonic-gate 12997c478bd9Sstevel@tonic-gate free(clp->path); 13007c478bd9Sstevel@tonic-gate free(clp->content); 13017c478bd9Sstevel@tonic-gate free(clp); 13027c478bd9Sstevel@tonic-gate } 13037c478bd9Sstevel@tonic-gate 13047c478bd9Sstevel@tonic-gate /* 13057c478bd9Sstevel@tonic-gate * Returns the ':' preceding the minor name 13067c478bd9Sstevel@tonic-gate */ 13077c478bd9Sstevel@tonic-gate static char * 13087c478bd9Sstevel@tonic-gate minor_colon(const char *path) 13097c478bd9Sstevel@tonic-gate { 13107c478bd9Sstevel@tonic-gate char *cp; 13117c478bd9Sstevel@tonic-gate 13127c478bd9Sstevel@tonic-gate if ((cp = strrchr(path, '/')) == NULL) { 13137c478bd9Sstevel@tonic-gate return (NULL); 13147c478bd9Sstevel@tonic-gate } 13157c478bd9Sstevel@tonic-gate 13167c478bd9Sstevel@tonic-gate return (strchr(cp, ':')); 13177c478bd9Sstevel@tonic-gate } 13187c478bd9Sstevel@tonic-gate 13197c478bd9Sstevel@tonic-gate static void * 13207c478bd9Sstevel@tonic-gate lookup_minor( 13217c478bd9Sstevel@tonic-gate struct di_devlink_handle *hdp, 13227c478bd9Sstevel@tonic-gate const char *minor_path, 13237c478bd9Sstevel@tonic-gate const char *nodetype, 13247c478bd9Sstevel@tonic-gate const int flags) 13257c478bd9Sstevel@tonic-gate { 13267c478bd9Sstevel@tonic-gate void *vp; 13277c478bd9Sstevel@tonic-gate char *colon; 13287c478bd9Sstevel@tonic-gate char pdup[PATH_MAX]; 13297c478bd9Sstevel@tonic-gate const char *fcn = "lookup_minor"; 13307c478bd9Sstevel@tonic-gate 13317c478bd9Sstevel@tonic-gate if (minor_path == NULL) { 13327c478bd9Sstevel@tonic-gate errno = EINVAL; 13337c478bd9Sstevel@tonic-gate return (NULL); 13347c478bd9Sstevel@tonic-gate } 13357c478bd9Sstevel@tonic-gate 13367c478bd9Sstevel@tonic-gate (void) snprintf(pdup, sizeof (pdup), "%s", minor_path); 13377c478bd9Sstevel@tonic-gate 13387c478bd9Sstevel@tonic-gate if ((colon = minor_colon(pdup)) == NULL) { 13397c478bd9Sstevel@tonic-gate (void) dprintf(DBG_ERR, "%s: invalid minor path(%s)\n", fcn, 13407c478bd9Sstevel@tonic-gate minor_path); 13417c478bd9Sstevel@tonic-gate errno = EINVAL; 13427c478bd9Sstevel@tonic-gate return (NULL); 13437c478bd9Sstevel@tonic-gate } 13447c478bd9Sstevel@tonic-gate *colon = '\0'; 13457c478bd9Sstevel@tonic-gate 13467c478bd9Sstevel@tonic-gate if ((vp = get_last_minor(hdp, pdup, colon + 1, flags)) != NULL) { 13477c478bd9Sstevel@tonic-gate return (vp); 13487c478bd9Sstevel@tonic-gate } 13497c478bd9Sstevel@tonic-gate 13507c478bd9Sstevel@tonic-gate if ((vp = lookup_node(hdp, pdup, flags)) == NULL) { 13517c478bd9Sstevel@tonic-gate (void) dprintf(DBG_ERR, "%s: node(%s) not found\n", fcn, pdup); 13527c478bd9Sstevel@tonic-gate return (NULL); 13537c478bd9Sstevel@tonic-gate } 13547c478bd9Sstevel@tonic-gate *colon = ':'; 13557c478bd9Sstevel@tonic-gate 13567c478bd9Sstevel@tonic-gate if (LOOKUP_CACHE(flags)) { 13577c478bd9Sstevel@tonic-gate cache_minor_t **pp; 13587c478bd9Sstevel@tonic-gate 13597c478bd9Sstevel@tonic-gate pp = &((cache_node_t *)vp)->minor; 13607c478bd9Sstevel@tonic-gate for (; *pp != NULL; pp = &(*pp)->sib) { 13617c478bd9Sstevel@tonic-gate if (strcmp((*pp)->name, colon + 1) == 0) 13627c478bd9Sstevel@tonic-gate break; 13637c478bd9Sstevel@tonic-gate } 13647c478bd9Sstevel@tonic-gate 13657c478bd9Sstevel@tonic-gate if (*pp == NULL && CREATE_ELEM(flags)) { 13667c478bd9Sstevel@tonic-gate *pp = minor_insert(hdp, vp, colon + 1, nodetype, pp); 13677c478bd9Sstevel@tonic-gate } 13687c478bd9Sstevel@tonic-gate set_last_minor(hdp, *pp, flags); 13697c478bd9Sstevel@tonic-gate 13707c478bd9Sstevel@tonic-gate return (*pp); 13717c478bd9Sstevel@tonic-gate } else { 13727c478bd9Sstevel@tonic-gate char *cp; 13737c478bd9Sstevel@tonic-gate uint32_t nidx; 13747c478bd9Sstevel@tonic-gate struct db_minor *dmp; 13757c478bd9Sstevel@tonic-gate 13767c478bd9Sstevel@tonic-gate nidx = (((struct db_node *)vp)->minor); 13777c478bd9Sstevel@tonic-gate for (; dmp = get_minor(hdp, nidx); nidx = dmp->sib) { 13787c478bd9Sstevel@tonic-gate cp = get_string(hdp, dmp->name); 13797c478bd9Sstevel@tonic-gate if (cp && strcmp(cp, colon + 1) == 0) 13807c478bd9Sstevel@tonic-gate break; 13817c478bd9Sstevel@tonic-gate } 13827c478bd9Sstevel@tonic-gate return (dmp); 13837c478bd9Sstevel@tonic-gate } 13847c478bd9Sstevel@tonic-gate } 13857c478bd9Sstevel@tonic-gate 13867c478bd9Sstevel@tonic-gate static void * 13877c478bd9Sstevel@tonic-gate lookup_node(struct di_devlink_handle *hdp, char *path, const int flags) 13887c478bd9Sstevel@tonic-gate { 13897c478bd9Sstevel@tonic-gate struct tnode tnd = {NULL}; 13907c478bd9Sstevel@tonic-gate 13917c478bd9Sstevel@tonic-gate if (tnd.node = get_last_node(hdp, path, flags)) 13927c478bd9Sstevel@tonic-gate return (tnd.node); 13937c478bd9Sstevel@tonic-gate 13947c478bd9Sstevel@tonic-gate tnd.handle = hdp; 13957c478bd9Sstevel@tonic-gate tnd.flags = flags; 13967c478bd9Sstevel@tonic-gate 13977c478bd9Sstevel@tonic-gate if (walk_tree(path, &tnd, visit_node) != 0) 13987c478bd9Sstevel@tonic-gate return (NULL); 13997c478bd9Sstevel@tonic-gate 14007c478bd9Sstevel@tonic-gate return (tnd.node); 14017c478bd9Sstevel@tonic-gate } 14027c478bd9Sstevel@tonic-gate 14037c478bd9Sstevel@tonic-gate /* 14047c478bd9Sstevel@tonic-gate * last_minor is used for nodes of TYPE_CACHE only. 14057c478bd9Sstevel@tonic-gate */ 14067c478bd9Sstevel@tonic-gate static void * 14077c478bd9Sstevel@tonic-gate get_last_node(struct di_devlink_handle *hdp, const char *path, int flags) 14087c478bd9Sstevel@tonic-gate { 14097c478bd9Sstevel@tonic-gate cache_node_t *cnp; 14107c478bd9Sstevel@tonic-gate 14117c478bd9Sstevel@tonic-gate #ifdef DEBUG 14127c478bd9Sstevel@tonic-gate if (getenv(SKIP_LAST_CACHE)) { 14137c478bd9Sstevel@tonic-gate (void) dprintf(DBG_INFO, "get_last_node: SKIPPING \"last\" " 14147c478bd9Sstevel@tonic-gate "node cache\n"); 14157c478bd9Sstevel@tonic-gate return (NULL); 14167c478bd9Sstevel@tonic-gate } 14177c478bd9Sstevel@tonic-gate #endif 14187c478bd9Sstevel@tonic-gate 14197c478bd9Sstevel@tonic-gate if (!LOOKUP_CACHE(flags) || CACHE_LAST(hdp) == NULL || 14207c478bd9Sstevel@tonic-gate CACHE_LAST(hdp)->node == NULL) { 14217c478bd9Sstevel@tonic-gate return (NULL); 14227c478bd9Sstevel@tonic-gate } 14237c478bd9Sstevel@tonic-gate 14247c478bd9Sstevel@tonic-gate cnp = CACHE_LAST(hdp)->node; 14257c478bd9Sstevel@tonic-gate if (strcmp(cnp->path, path) == 0) { 14267c478bd9Sstevel@tonic-gate return (cnp); 14277c478bd9Sstevel@tonic-gate } 14287c478bd9Sstevel@tonic-gate 14297c478bd9Sstevel@tonic-gate cnp = cnp->sib; 14307c478bd9Sstevel@tonic-gate if (cnp && strcmp(cnp->path, path) == 0) { 14317c478bd9Sstevel@tonic-gate return (cnp); 14327c478bd9Sstevel@tonic-gate } 14337c478bd9Sstevel@tonic-gate 14347c478bd9Sstevel@tonic-gate return (NULL); 14357c478bd9Sstevel@tonic-gate } 14367c478bd9Sstevel@tonic-gate 14377c478bd9Sstevel@tonic-gate static void * 14387c478bd9Sstevel@tonic-gate get_last_minor( 14397c478bd9Sstevel@tonic-gate struct di_devlink_handle *hdp, 14407c478bd9Sstevel@tonic-gate const char *devfs_path, 14417c478bd9Sstevel@tonic-gate const char *minor_name, 14427c478bd9Sstevel@tonic-gate int flags) 14437c478bd9Sstevel@tonic-gate { 14447c478bd9Sstevel@tonic-gate cache_minor_t *cmnp; 14457c478bd9Sstevel@tonic-gate 14467c478bd9Sstevel@tonic-gate #ifdef DEBUG 14477c478bd9Sstevel@tonic-gate if (getenv(SKIP_LAST_CACHE)) { 14487c478bd9Sstevel@tonic-gate (void) dprintf(DBG_INFO, "get_last_minor: SKIPPING \"last\" " 14497c478bd9Sstevel@tonic-gate "minor cache\n"); 14507c478bd9Sstevel@tonic-gate return (NULL); 14517c478bd9Sstevel@tonic-gate } 14527c478bd9Sstevel@tonic-gate #endif 14537c478bd9Sstevel@tonic-gate 14547c478bd9Sstevel@tonic-gate if (!LOOKUP_CACHE(flags) || CACHE_LAST(hdp) == NULL) { 14557c478bd9Sstevel@tonic-gate return (NULL); 14567c478bd9Sstevel@tonic-gate } 14577c478bd9Sstevel@tonic-gate 14587c478bd9Sstevel@tonic-gate cmnp = CACHE_LAST(hdp); 14597c478bd9Sstevel@tonic-gate if (strcmp(cmnp->name, minor_name) == 0 && cmnp->node && 14607c478bd9Sstevel@tonic-gate strcmp(cmnp->node->path, devfs_path) == 0) { 14617c478bd9Sstevel@tonic-gate return (cmnp); 14627c478bd9Sstevel@tonic-gate } 14637c478bd9Sstevel@tonic-gate 14647c478bd9Sstevel@tonic-gate cmnp = cmnp->sib; 14657c478bd9Sstevel@tonic-gate if (cmnp && strcmp(cmnp->name, minor_name) == 0 && cmnp->node && 14667c478bd9Sstevel@tonic-gate strcmp(cmnp->node->path, devfs_path) == 0) { 14677c478bd9Sstevel@tonic-gate set_last_minor(hdp, cmnp, TYPE_CACHE); 14687c478bd9Sstevel@tonic-gate return (cmnp); 14697c478bd9Sstevel@tonic-gate } 14707c478bd9Sstevel@tonic-gate 14717c478bd9Sstevel@tonic-gate return (NULL); 14727c478bd9Sstevel@tonic-gate } 14737c478bd9Sstevel@tonic-gate 14747c478bd9Sstevel@tonic-gate static void 14757c478bd9Sstevel@tonic-gate set_last_minor(struct di_devlink_handle *hdp, cache_minor_t *cmnp, int flags) 14767c478bd9Sstevel@tonic-gate { 14777c478bd9Sstevel@tonic-gate #ifdef DEBUG 14787c478bd9Sstevel@tonic-gate if (getenv(SKIP_LAST_CACHE)) { 14797c478bd9Sstevel@tonic-gate (void) dprintf(DBG_INFO, "set_last_minor: SKIPPING \"last\" " 14807c478bd9Sstevel@tonic-gate "minor cache\n"); 14817c478bd9Sstevel@tonic-gate return; 14827c478bd9Sstevel@tonic-gate } 14837c478bd9Sstevel@tonic-gate #endif 14847c478bd9Sstevel@tonic-gate 14857c478bd9Sstevel@tonic-gate if (LOOKUP_CACHE(flags) && cmnp) { 14867c478bd9Sstevel@tonic-gate CACHE_LAST(hdp) = cmnp; 14877c478bd9Sstevel@tonic-gate } 14887c478bd9Sstevel@tonic-gate } 14897c478bd9Sstevel@tonic-gate 14907c478bd9Sstevel@tonic-gate 14917c478bd9Sstevel@tonic-gate /* 14927c478bd9Sstevel@tonic-gate * Returns 0 if normal return or -1 otherwise. 14937c478bd9Sstevel@tonic-gate */ 14947c478bd9Sstevel@tonic-gate static int 14957c478bd9Sstevel@tonic-gate walk_tree( 14967c478bd9Sstevel@tonic-gate char *cur, 14977c478bd9Sstevel@tonic-gate void *arg, 14987c478bd9Sstevel@tonic-gate int (*node_callback)(const char *path, void *arg)) 14997c478bd9Sstevel@tonic-gate { 15007c478bd9Sstevel@tonic-gate char *slash, buf[PATH_MAX]; 15017c478bd9Sstevel@tonic-gate 15027c478bd9Sstevel@tonic-gate if (cur == NULL || cur[0] != '/' || strlen(cur) > sizeof (buf) - 1) { 15037c478bd9Sstevel@tonic-gate errno = EINVAL; 15047c478bd9Sstevel@tonic-gate return (-1); 15057c478bd9Sstevel@tonic-gate } 15067c478bd9Sstevel@tonic-gate 15077c478bd9Sstevel@tonic-gate (void) strcpy(buf, "/"); 15087c478bd9Sstevel@tonic-gate 15097c478bd9Sstevel@tonic-gate for (;;) { 15107c478bd9Sstevel@tonic-gate 15117c478bd9Sstevel@tonic-gate if (node_callback(buf, arg) != DI_WALK_CONTINUE) 15127c478bd9Sstevel@tonic-gate break; 15137c478bd9Sstevel@tonic-gate 15147c478bd9Sstevel@tonic-gate while (*cur == '/') 15157c478bd9Sstevel@tonic-gate cur++; 15167c478bd9Sstevel@tonic-gate 15177c478bd9Sstevel@tonic-gate if (*cur == '\0') 15187c478bd9Sstevel@tonic-gate break; 15197c478bd9Sstevel@tonic-gate 15207c478bd9Sstevel@tonic-gate /* 15217c478bd9Sstevel@tonic-gate * There is a next component(s). Append a "/" separator for all 15227c478bd9Sstevel@tonic-gate * but the first (root) component. 15237c478bd9Sstevel@tonic-gate */ 15247c478bd9Sstevel@tonic-gate if (buf[1] != '\0') { 15257c478bd9Sstevel@tonic-gate (void) strlcat(buf, "/", sizeof (buf)); 15267c478bd9Sstevel@tonic-gate } 15277c478bd9Sstevel@tonic-gate 15287c478bd9Sstevel@tonic-gate if (slash = strchr(cur, '/')) { 15297c478bd9Sstevel@tonic-gate *slash = '\0'; 15307c478bd9Sstevel@tonic-gate (void) strlcat(buf, cur, sizeof (buf)); 15317c478bd9Sstevel@tonic-gate *slash = '/'; 15327c478bd9Sstevel@tonic-gate cur = slash; 15337c478bd9Sstevel@tonic-gate } else { 15347c478bd9Sstevel@tonic-gate (void) strlcat(buf, cur, sizeof (buf)); 15357c478bd9Sstevel@tonic-gate cur += strlen(cur); 15367c478bd9Sstevel@tonic-gate } 15377c478bd9Sstevel@tonic-gate 15387c478bd9Sstevel@tonic-gate } 15397c478bd9Sstevel@tonic-gate 15407c478bd9Sstevel@tonic-gate return (0); 15417c478bd9Sstevel@tonic-gate } 15427c478bd9Sstevel@tonic-gate 15437c478bd9Sstevel@tonic-gate 15447c478bd9Sstevel@tonic-gate static int 15457c478bd9Sstevel@tonic-gate visit_node(const char *path, void *arg) 15467c478bd9Sstevel@tonic-gate { 15477c478bd9Sstevel@tonic-gate struct tnode *tnp = arg; 15487c478bd9Sstevel@tonic-gate 15497c478bd9Sstevel@tonic-gate if (LOOKUP_CACHE(tnp->flags)) { 15507c478bd9Sstevel@tonic-gate 15517c478bd9Sstevel@tonic-gate cache_node_t *cnp = tnp->node; 15527c478bd9Sstevel@tonic-gate 15537c478bd9Sstevel@tonic-gate cnp = (cnp) ? cnp->child : CACHE_ROOT(tnp->handle); 15547c478bd9Sstevel@tonic-gate 15557c478bd9Sstevel@tonic-gate for (; cnp != NULL; cnp = cnp->sib) { 15567c478bd9Sstevel@tonic-gate if (strcmp(cnp->path, path) == 0) 15577c478bd9Sstevel@tonic-gate break; 15587c478bd9Sstevel@tonic-gate } 15597c478bd9Sstevel@tonic-gate if (cnp == NULL && CREATE_ELEM(tnp->flags)) { 15607c478bd9Sstevel@tonic-gate cnp = node_insert(tnp->handle, tnp->node, path, 15617c478bd9Sstevel@tonic-gate INSERT_TAIL); 15627c478bd9Sstevel@tonic-gate } 15637c478bd9Sstevel@tonic-gate tnp->node = cnp; 15647c478bd9Sstevel@tonic-gate } else { 15657c478bd9Sstevel@tonic-gate char *cp; 15667c478bd9Sstevel@tonic-gate struct db_node *dnp = tnp->node; 15677c478bd9Sstevel@tonic-gate 15687c478bd9Sstevel@tonic-gate dnp = (dnp) ? get_node(tnp->handle, dnp->child) 15697c478bd9Sstevel@tonic-gate : get_node(tnp->handle, DB_HDR(tnp->handle)->root_idx); 15707c478bd9Sstevel@tonic-gate 15717c478bd9Sstevel@tonic-gate for (; dnp != NULL; dnp = get_node(tnp->handle, dnp->sib)) { 15727c478bd9Sstevel@tonic-gate cp = get_string(tnp->handle, dnp->path); 15737c478bd9Sstevel@tonic-gate if (cp && strcmp(cp, path) == 0) { 15747c478bd9Sstevel@tonic-gate break; 15757c478bd9Sstevel@tonic-gate } 15767c478bd9Sstevel@tonic-gate } 15777c478bd9Sstevel@tonic-gate tnp->node = dnp; 15787c478bd9Sstevel@tonic-gate } 15797c478bd9Sstevel@tonic-gate 15807c478bd9Sstevel@tonic-gate /* 15817c478bd9Sstevel@tonic-gate * Terminate walk if node is not found for a path component. 15827c478bd9Sstevel@tonic-gate */ 15837c478bd9Sstevel@tonic-gate return (tnp->node ? DI_WALK_CONTINUE : DI_WALK_TERMINATE); 15847c478bd9Sstevel@tonic-gate } 15857c478bd9Sstevel@tonic-gate 15867c478bd9Sstevel@tonic-gate static void 15877c478bd9Sstevel@tonic-gate minor_delete(di_devlink_handle_t hdp, cache_minor_t *cmnp) 15887c478bd9Sstevel@tonic-gate { 15897c478bd9Sstevel@tonic-gate cache_link_t **lpp; 15907c478bd9Sstevel@tonic-gate cache_minor_t **mpp; 15917c478bd9Sstevel@tonic-gate const char *fcn = "minor_delete"; 15927c478bd9Sstevel@tonic-gate 15937c478bd9Sstevel@tonic-gate (void) dprintf(DBG_STEP, "%s: removing minor: %s\n", fcn, cmnp->name); 15947c478bd9Sstevel@tonic-gate 15957c478bd9Sstevel@tonic-gate /* detach minor from node */ 15967c478bd9Sstevel@tonic-gate if (cmnp->node != NULL) { 15977c478bd9Sstevel@tonic-gate mpp = &cmnp->node->minor; 15987c478bd9Sstevel@tonic-gate for (; *mpp != NULL; mpp = &(*mpp)->sib) { 15997c478bd9Sstevel@tonic-gate if (*mpp == cmnp) 16007c478bd9Sstevel@tonic-gate break; 16017c478bd9Sstevel@tonic-gate } 16027c478bd9Sstevel@tonic-gate 16037c478bd9Sstevel@tonic-gate if (*mpp == NULL) { 16047c478bd9Sstevel@tonic-gate (void) dprintf(DBG_ERR, "%s: dangling minor: %s\n", 16057c478bd9Sstevel@tonic-gate fcn, cmnp->name); 16067c478bd9Sstevel@tonic-gate } else { 16077c478bd9Sstevel@tonic-gate *mpp = cmnp->sib; 16087c478bd9Sstevel@tonic-gate } 16097c478bd9Sstevel@tonic-gate } else { 16107c478bd9Sstevel@tonic-gate (void) dprintf(DBG_ERR, "%s: orphan minor(%s)\n", fcn, 16117c478bd9Sstevel@tonic-gate cmnp->name); 16127c478bd9Sstevel@tonic-gate } 16137c478bd9Sstevel@tonic-gate 16147c478bd9Sstevel@tonic-gate delete_unused_nodes(hdp, cmnp->node); 16157c478bd9Sstevel@tonic-gate 16167c478bd9Sstevel@tonic-gate cmnp->node = NULL; 16177c478bd9Sstevel@tonic-gate cmnp->sib = NULL; 16187c478bd9Sstevel@tonic-gate 16197c478bd9Sstevel@tonic-gate /* Move all remaining links to dangling list */ 16207c478bd9Sstevel@tonic-gate for (lpp = &cmnp->link; *lpp != NULL; lpp = &(*lpp)->sib) { 16217c478bd9Sstevel@tonic-gate (*lpp)->minor = NULL; 16227c478bd9Sstevel@tonic-gate } 16237c478bd9Sstevel@tonic-gate *lpp = CACHE(hdp)->dngl; 16247c478bd9Sstevel@tonic-gate CACHE(hdp)->dngl = cmnp->link; 16257c478bd9Sstevel@tonic-gate cmnp->link = NULL; 16267c478bd9Sstevel@tonic-gate 16277c478bd9Sstevel@tonic-gate minor_free(hdp, &cmnp); 16287c478bd9Sstevel@tonic-gate } 16297c478bd9Sstevel@tonic-gate 16307c478bd9Sstevel@tonic-gate static void 16317c478bd9Sstevel@tonic-gate delete_unused_nodes(di_devlink_handle_t hdp, cache_node_t *cnp) 16327c478bd9Sstevel@tonic-gate { 16337c478bd9Sstevel@tonic-gate cache_node_t **npp; 16347c478bd9Sstevel@tonic-gate const char *fcn = "delete_unused_nodes"; 16357c478bd9Sstevel@tonic-gate 16367c478bd9Sstevel@tonic-gate if (cnp == NULL) 16377c478bd9Sstevel@tonic-gate return; 16387c478bd9Sstevel@tonic-gate 16397c478bd9Sstevel@tonic-gate if (cnp->minor != NULL || cnp->child != NULL) 16407c478bd9Sstevel@tonic-gate return; 16417c478bd9Sstevel@tonic-gate 16427c478bd9Sstevel@tonic-gate (void) dprintf(DBG_INFO, "%s: removing unused node: %s\n", fcn, 16437c478bd9Sstevel@tonic-gate cnp->path); 16447c478bd9Sstevel@tonic-gate 16457c478bd9Sstevel@tonic-gate /* Unlink node from tree */ 16467c478bd9Sstevel@tonic-gate if (cnp->parent != NULL) { 16477c478bd9Sstevel@tonic-gate npp = &cnp->parent->child; 16487c478bd9Sstevel@tonic-gate for (; *npp != NULL; npp = &(*npp)->sib) { 16497c478bd9Sstevel@tonic-gate if (*npp == cnp) 16507c478bd9Sstevel@tonic-gate break; 16517c478bd9Sstevel@tonic-gate } 16527c478bd9Sstevel@tonic-gate 16537c478bd9Sstevel@tonic-gate if (*npp == NULL) { 16547c478bd9Sstevel@tonic-gate (void) dprintf(DBG_ERR, "%s: dangling node: %s\n", fcn, 16557c478bd9Sstevel@tonic-gate cnp->path); 16567c478bd9Sstevel@tonic-gate } else { 16577c478bd9Sstevel@tonic-gate *npp = cnp->sib; 16587c478bd9Sstevel@tonic-gate } 16597c478bd9Sstevel@tonic-gate } else if (cnp == CACHE_ROOT(hdp)) { 16607c478bd9Sstevel@tonic-gate CACHE_ROOT(hdp) = NULL; 16617c478bd9Sstevel@tonic-gate } else { 16627c478bd9Sstevel@tonic-gate (void) dprintf(DBG_ERR, "%s: orphan node (%s)\n", fcn, 16637c478bd9Sstevel@tonic-gate cnp->path); 16647c478bd9Sstevel@tonic-gate } 16657c478bd9Sstevel@tonic-gate 16667c478bd9Sstevel@tonic-gate delete_unused_nodes(hdp, cnp->parent); 16677c478bd9Sstevel@tonic-gate 16687c478bd9Sstevel@tonic-gate cnp->parent = cnp->sib = NULL; 16697c478bd9Sstevel@tonic-gate 16707c478bd9Sstevel@tonic-gate node_free(&cnp); 16717c478bd9Sstevel@tonic-gate } 16727c478bd9Sstevel@tonic-gate 16737c478bd9Sstevel@tonic-gate static int 16747c478bd9Sstevel@tonic-gate rm_link(di_devlink_handle_t hdp, const char *link) 16757c478bd9Sstevel@tonic-gate { 16767c478bd9Sstevel@tonic-gate cache_link_t *clp; 16777c478bd9Sstevel@tonic-gate const char *fcn = "rm_link"; 16787c478bd9Sstevel@tonic-gate 16797c478bd9Sstevel@tonic-gate if (hdp == NULL || DB_ERR(hdp) || link == NULL || link[0] == '/' || 16807c478bd9Sstevel@tonic-gate (!HDL_RDWR(hdp) && !HDL_RDONLY(hdp))) { 16817c478bd9Sstevel@tonic-gate dprintf(DBG_ERR, "%s: %s: invalid args\n", 16827c478bd9Sstevel@tonic-gate fcn, link ? link : "<NULL>"); 16837c478bd9Sstevel@tonic-gate errno = EINVAL; 16847c478bd9Sstevel@tonic-gate return (-1); 16857c478bd9Sstevel@tonic-gate } 16867c478bd9Sstevel@tonic-gate 16877c478bd9Sstevel@tonic-gate dprintf(DBG_STEP, "%s: link(%s)\n", fcn, link); 16887c478bd9Sstevel@tonic-gate 16897c478bd9Sstevel@tonic-gate if ((clp = link_hash(hdp, link, UNLINK_FROM_HASH)) == NULL) { 16907c478bd9Sstevel@tonic-gate return (0); 16917c478bd9Sstevel@tonic-gate } 16927c478bd9Sstevel@tonic-gate 16937c478bd9Sstevel@tonic-gate link_delete(hdp, clp); 16947c478bd9Sstevel@tonic-gate 16957c478bd9Sstevel@tonic-gate return (0); 16967c478bd9Sstevel@tonic-gate } 16977c478bd9Sstevel@tonic-gate 16987c478bd9Sstevel@tonic-gate int 16997c478bd9Sstevel@tonic-gate di_devlink_rm_link(di_devlink_handle_t hdp, const char *link) 17007c478bd9Sstevel@tonic-gate { 17017c478bd9Sstevel@tonic-gate if (hdp == NULL || !HDL_RDWR(hdp)) { 17027c478bd9Sstevel@tonic-gate errno = EINVAL; 17037c478bd9Sstevel@tonic-gate return (-1); 17047c478bd9Sstevel@tonic-gate } 17057c478bd9Sstevel@tonic-gate 17067c478bd9Sstevel@tonic-gate return (rm_link(hdp, link)); 17077c478bd9Sstevel@tonic-gate } 17087c478bd9Sstevel@tonic-gate 17097c478bd9Sstevel@tonic-gate static void 17107c478bd9Sstevel@tonic-gate link_delete(di_devlink_handle_t hdp, cache_link_t *clp) 17117c478bd9Sstevel@tonic-gate { 17127c478bd9Sstevel@tonic-gate cache_link_t **pp; 17137c478bd9Sstevel@tonic-gate const char *fcn = "link_delete"; 17147c478bd9Sstevel@tonic-gate 17157c478bd9Sstevel@tonic-gate (void) dprintf(DBG_STEP, "%s: removing link: %s\n", fcn, clp->path); 17167c478bd9Sstevel@tonic-gate 17177c478bd9Sstevel@tonic-gate if (clp->minor == NULL) 17187c478bd9Sstevel@tonic-gate pp = &(CACHE(hdp)->dngl); 17197c478bd9Sstevel@tonic-gate else 17207c478bd9Sstevel@tonic-gate pp = &clp->minor->link; 17217c478bd9Sstevel@tonic-gate 17227c478bd9Sstevel@tonic-gate for (; *pp != NULL; pp = &(*pp)->sib) { 17237c478bd9Sstevel@tonic-gate if (*pp == clp) 17247c478bd9Sstevel@tonic-gate break; 17257c478bd9Sstevel@tonic-gate } 17267c478bd9Sstevel@tonic-gate 17277c478bd9Sstevel@tonic-gate if (*pp == NULL) { 17287c478bd9Sstevel@tonic-gate (void) dprintf(DBG_ERR, "%s: link(%s) not on list\n", 17297c478bd9Sstevel@tonic-gate fcn, clp->path); 17307c478bd9Sstevel@tonic-gate } else { 17317c478bd9Sstevel@tonic-gate *pp = clp->sib; 17327c478bd9Sstevel@tonic-gate } 17337c478bd9Sstevel@tonic-gate 17347c478bd9Sstevel@tonic-gate delete_unused_minor(hdp, clp->minor); 17357c478bd9Sstevel@tonic-gate 17367c478bd9Sstevel@tonic-gate clp->minor = NULL; 17377c478bd9Sstevel@tonic-gate 17387c478bd9Sstevel@tonic-gate link_free(&clp); 17397c478bd9Sstevel@tonic-gate } 17407c478bd9Sstevel@tonic-gate 17417c478bd9Sstevel@tonic-gate static void 17427c478bd9Sstevel@tonic-gate delete_unused_minor(di_devlink_handle_t hdp, cache_minor_t *cmnp) 17437c478bd9Sstevel@tonic-gate { 17447c478bd9Sstevel@tonic-gate if (cmnp == NULL) 17457c478bd9Sstevel@tonic-gate return; 17467c478bd9Sstevel@tonic-gate 17477c478bd9Sstevel@tonic-gate if (cmnp->link != NULL) 17487c478bd9Sstevel@tonic-gate return; 17497c478bd9Sstevel@tonic-gate 17507c478bd9Sstevel@tonic-gate dprintf(DBG_STEP, "delete_unused_minor: removing minor(%s)\n", 17517c478bd9Sstevel@tonic-gate cmnp->name); 17527c478bd9Sstevel@tonic-gate 17537c478bd9Sstevel@tonic-gate minor_delete(hdp, cmnp); 17547c478bd9Sstevel@tonic-gate } 17557c478bd9Sstevel@tonic-gate 17567c478bd9Sstevel@tonic-gate int 17577c478bd9Sstevel@tonic-gate di_devlink_add_link( 17587c478bd9Sstevel@tonic-gate di_devlink_handle_t hdp, 17597c478bd9Sstevel@tonic-gate const char *link, 17607c478bd9Sstevel@tonic-gate const char *content, 17617c478bd9Sstevel@tonic-gate int flags) 17627c478bd9Sstevel@tonic-gate { 17637c478bd9Sstevel@tonic-gate return (add_link(hdp, link, content, flags) != NULL ? 0 : -1); 17647c478bd9Sstevel@tonic-gate } 17657c478bd9Sstevel@tonic-gate 17667c478bd9Sstevel@tonic-gate static cache_link_t * 17677c478bd9Sstevel@tonic-gate add_link( 17687c478bd9Sstevel@tonic-gate struct di_devlink_handle *hdp, 17697c478bd9Sstevel@tonic-gate const char *link, 17707c478bd9Sstevel@tonic-gate const char *content, 17717c478bd9Sstevel@tonic-gate int flags) 17727c478bd9Sstevel@tonic-gate { 17737c478bd9Sstevel@tonic-gate uint32_t attr; 17747c478bd9Sstevel@tonic-gate cache_link_t *clp; 17757c478bd9Sstevel@tonic-gate cache_minor_t *cmnp; 17767c478bd9Sstevel@tonic-gate const char *fcn = "add_link"; 17777c478bd9Sstevel@tonic-gate 17787c478bd9Sstevel@tonic-gate if (hdp == NULL || DB_ERR(hdp) || link == NULL || 17797c478bd9Sstevel@tonic-gate link[0] == '/' || content == NULL || !link_flag(flags) || 17807c478bd9Sstevel@tonic-gate (!HDL_RDWR(hdp) && !HDL_RDONLY(hdp))) { 17817c478bd9Sstevel@tonic-gate dprintf(DBG_ERR, "%s: %s: invalid args\n", 17827c478bd9Sstevel@tonic-gate fcn, link ? link : "<NULL>"); 17837c478bd9Sstevel@tonic-gate errno = EINVAL; 17847c478bd9Sstevel@tonic-gate return (NULL); 17857c478bd9Sstevel@tonic-gate } 17867c478bd9Sstevel@tonic-gate 17877c478bd9Sstevel@tonic-gate if ((clp = link_hash(hdp, link, 0)) != NULL) { 17887c478bd9Sstevel@tonic-gate if (link_cmp(clp, content, LINK_TYPE(flags)) != 0) { 17897c478bd9Sstevel@tonic-gate (void) rm_link(hdp, link); 17907c478bd9Sstevel@tonic-gate } else { 17917c478bd9Sstevel@tonic-gate return (clp); 17927c478bd9Sstevel@tonic-gate } 17937c478bd9Sstevel@tonic-gate } 17947c478bd9Sstevel@tonic-gate 17957c478bd9Sstevel@tonic-gate if (TYPE_PRI(flags)) { 17967c478bd9Sstevel@tonic-gate const char *minor_path = NULL; 17977c478bd9Sstevel@tonic-gate 17987c478bd9Sstevel@tonic-gate if (!is_minor_node(content, &minor_path)) { 17997c478bd9Sstevel@tonic-gate (void) dprintf(DBG_ERR, "%s: invalid content(%s)" 18007c478bd9Sstevel@tonic-gate " for primary link\n", fcn, content); 18017c478bd9Sstevel@tonic-gate errno = EINVAL; 18027c478bd9Sstevel@tonic-gate return (NULL); 18037c478bd9Sstevel@tonic-gate } 18047c478bd9Sstevel@tonic-gate if ((cmnp = lookup_minor(hdp, minor_path, NULL, 18057c478bd9Sstevel@tonic-gate TYPE_CACHE|CREATE_FLAG)) == NULL) { 18067c478bd9Sstevel@tonic-gate return (NULL); 18077c478bd9Sstevel@tonic-gate } 18087c478bd9Sstevel@tonic-gate attr = A_PRIMARY; 18097c478bd9Sstevel@tonic-gate } else { 18107c478bd9Sstevel@tonic-gate /* 18117c478bd9Sstevel@tonic-gate * Defer resolving a secondary link to a minor until the 18127c478bd9Sstevel@tonic-gate * database is closed. This ensures that the primary link 18137c478bd9Sstevel@tonic-gate * (required for a successful resolve) has also been created. 18147c478bd9Sstevel@tonic-gate */ 18157c478bd9Sstevel@tonic-gate cmnp = NULL; 18167c478bd9Sstevel@tonic-gate attr = A_SECONDARY; 18177c478bd9Sstevel@tonic-gate } 18187c478bd9Sstevel@tonic-gate 18197c478bd9Sstevel@tonic-gate return (link_insert(hdp, cmnp, link, content, attr)); 18207c478bd9Sstevel@tonic-gate } 18217c478bd9Sstevel@tonic-gate 18227c478bd9Sstevel@tonic-gate /* 18237c478bd9Sstevel@tonic-gate * Returns 0 on match or 1 otherwise. 18247c478bd9Sstevel@tonic-gate */ 18257c478bd9Sstevel@tonic-gate static int 18267c478bd9Sstevel@tonic-gate link_cmp(cache_link_t *clp, const char *content, int type) 18277c478bd9Sstevel@tonic-gate { 18287c478bd9Sstevel@tonic-gate if (strcmp(clp->content, content) != 0) 18297c478bd9Sstevel@tonic-gate return (1); 18307c478bd9Sstevel@tonic-gate 18317c478bd9Sstevel@tonic-gate if (attr2type(clp->attr) != type) 18327c478bd9Sstevel@tonic-gate return (1); 18337c478bd9Sstevel@tonic-gate 18347c478bd9Sstevel@tonic-gate return (0); 18357c478bd9Sstevel@tonic-gate } 18367c478bd9Sstevel@tonic-gate 18377c478bd9Sstevel@tonic-gate int 18387c478bd9Sstevel@tonic-gate di_devlink_update(di_devlink_handle_t hdp) 18397c478bd9Sstevel@tonic-gate { 18407c478bd9Sstevel@tonic-gate if (hdp == NULL || !HDL_RDWR(hdp) || DB_ERR(hdp)) { 18417c478bd9Sstevel@tonic-gate errno = EINVAL; 18427c478bd9Sstevel@tonic-gate return (-1); 18437c478bd9Sstevel@tonic-gate } 18447c478bd9Sstevel@tonic-gate 18457c478bd9Sstevel@tonic-gate /* 18467c478bd9Sstevel@tonic-gate * Reset the counter to schedule a synchronization with /dev on the next 18477c478bd9Sstevel@tonic-gate * di_devlink_close(). 18487c478bd9Sstevel@tonic-gate */ 18497c478bd9Sstevel@tonic-gate CACHE(hdp)->update_count = 0; 18507c478bd9Sstevel@tonic-gate 18517c478bd9Sstevel@tonic-gate return (0); 18527c478bd9Sstevel@tonic-gate } 18537c478bd9Sstevel@tonic-gate 18547c478bd9Sstevel@tonic-gate static int 18557c478bd9Sstevel@tonic-gate synchronize_db(di_devlink_handle_t hdp) 18567c478bd9Sstevel@tonic-gate { 18577c478bd9Sstevel@tonic-gate int hval; 18587c478bd9Sstevel@tonic-gate cache_link_t *clp; 18597c478bd9Sstevel@tonic-gate char pdup[PATH_MAX]; 18607c478bd9Sstevel@tonic-gate recurse_t rec = {NULL}; 18617c478bd9Sstevel@tonic-gate const char *fcn = "synchronize_db"; 18627c478bd9Sstevel@tonic-gate 18637c478bd9Sstevel@tonic-gate rec.data = NULL; 18647c478bd9Sstevel@tonic-gate rec.fcn = cache_dev_link; 18657c478bd9Sstevel@tonic-gate 18667c478bd9Sstevel@tonic-gate /* 18677c478bd9Sstevel@tonic-gate * Walk through $ROOT/dev, reading every link and marking the 18687c478bd9Sstevel@tonic-gate * corresponding cached version as valid(adding new links as needed). 18697c478bd9Sstevel@tonic-gate * Then walk through the cache and remove all unmarked links. 18707c478bd9Sstevel@tonic-gate */ 18717c478bd9Sstevel@tonic-gate if (recurse_dev(hdp, &rec) != 0) { 18727c478bd9Sstevel@tonic-gate return (-1); 18737c478bd9Sstevel@tonic-gate } 18747c478bd9Sstevel@tonic-gate 18757c478bd9Sstevel@tonic-gate for (hval = 0; hval < CACHE(hdp)->hash_sz; hval++) { 18767c478bd9Sstevel@tonic-gate for (clp = CACHE_HASH(hdp, hval); clp != NULL; ) { 18777c478bd9Sstevel@tonic-gate if (GET_VALID_ATTR(clp->attr)) { 18787c478bd9Sstevel@tonic-gate CLR_VALID_ATTR(clp->attr); 18797c478bd9Sstevel@tonic-gate clp = clp->hash; 18807c478bd9Sstevel@tonic-gate continue; 18817c478bd9Sstevel@tonic-gate } 18827c478bd9Sstevel@tonic-gate 18837c478bd9Sstevel@tonic-gate /* 18847c478bd9Sstevel@tonic-gate * The link is stale, so remove it. Since the link 18857c478bd9Sstevel@tonic-gate * will be destroyed, use a copy of the link path to 18867c478bd9Sstevel@tonic-gate * invoke the remove function. 18877c478bd9Sstevel@tonic-gate */ 18887c478bd9Sstevel@tonic-gate (void) snprintf(pdup, sizeof (pdup), "%s", clp->path); 18897c478bd9Sstevel@tonic-gate clp = clp->hash; 18907c478bd9Sstevel@tonic-gate (void) dprintf(DBG_STEP, "%s: removing invalid link:" 18917c478bd9Sstevel@tonic-gate " %s\n", fcn, pdup); 18927c478bd9Sstevel@tonic-gate (void) di_devlink_rm_link(hdp, pdup); 18937c478bd9Sstevel@tonic-gate } 18947c478bd9Sstevel@tonic-gate } 18957c478bd9Sstevel@tonic-gate 18967c478bd9Sstevel@tonic-gate (void) dprintf(DBG_STEP, "%s: update completed\n", fcn); 18977c478bd9Sstevel@tonic-gate 18987c478bd9Sstevel@tonic-gate return (0); 18997c478bd9Sstevel@tonic-gate } 19007c478bd9Sstevel@tonic-gate 19017c478bd9Sstevel@tonic-gate static di_devlink_handle_t 19027c478bd9Sstevel@tonic-gate di_devlink_init_impl(const char *root, const char *name, uint_t flags) 19037c478bd9Sstevel@tonic-gate { 19047c478bd9Sstevel@tonic-gate int err = 0; 19057c478bd9Sstevel@tonic-gate 19067c478bd9Sstevel@tonic-gate if ((flags != 0 && flags != DI_MAKE_LINK) || 19077c478bd9Sstevel@tonic-gate (flags == 0 && name != NULL)) { 19087c478bd9Sstevel@tonic-gate errno = EINVAL; 19097c478bd9Sstevel@tonic-gate return (NULL); 19107c478bd9Sstevel@tonic-gate } 19117c478bd9Sstevel@tonic-gate 1912*ff2aee48Scth if ((flags == DI_MAKE_LINK) && 1913*ff2aee48Scth (err = devlink_create(root, name, DCA_DEVLINK_CACHE))) { 19147c478bd9Sstevel@tonic-gate errno = err; 19157c478bd9Sstevel@tonic-gate return (NULL); 19167c478bd9Sstevel@tonic-gate } 19177c478bd9Sstevel@tonic-gate 19187c478bd9Sstevel@tonic-gate (void) dprintf(DBG_INFO, "devlink_init_impl: success\n"); 19197c478bd9Sstevel@tonic-gate 19207c478bd9Sstevel@tonic-gate return (devlink_snapshot(root)); 19217c478bd9Sstevel@tonic-gate } 19227c478bd9Sstevel@tonic-gate 19237c478bd9Sstevel@tonic-gate di_devlink_handle_t 19247c478bd9Sstevel@tonic-gate di_devlink_init(const char *name, uint_t flags) 19257c478bd9Sstevel@tonic-gate { 19267c478bd9Sstevel@tonic-gate return (di_devlink_init_impl("/", name, flags)); 19277c478bd9Sstevel@tonic-gate } 19287c478bd9Sstevel@tonic-gate 19297c478bd9Sstevel@tonic-gate di_devlink_handle_t 19307c478bd9Sstevel@tonic-gate di_devlink_init_root(const char *root, const char *name, uint_t flags) 19317c478bd9Sstevel@tonic-gate { 19327c478bd9Sstevel@tonic-gate return (di_devlink_init_impl(root, name, flags)); 19337c478bd9Sstevel@tonic-gate } 19347c478bd9Sstevel@tonic-gate 19357c478bd9Sstevel@tonic-gate static di_devlink_handle_t 19367c478bd9Sstevel@tonic-gate devlink_snapshot(const char *root_dir) 19377c478bd9Sstevel@tonic-gate { 19387c478bd9Sstevel@tonic-gate struct di_devlink_handle *hdp; 1939*ff2aee48Scth int locked; 1940*ff2aee48Scth int err; 1941*ff2aee48Scth int retried = 0; 19427c478bd9Sstevel@tonic-gate 19437c478bd9Sstevel@tonic-gate if ((hdp = handle_alloc(root_dir, OPEN_RDONLY)) == NULL) { 19447c478bd9Sstevel@tonic-gate return (NULL); 19457c478bd9Sstevel@tonic-gate } 19467c478bd9Sstevel@tonic-gate 19477c478bd9Sstevel@tonic-gate /* 1948*ff2aee48Scth * Enter the DB lock. This will wait for update in progress and 1949*ff2aee48Scth * provide exclusion from new updates while we establish our mmap 1950*ff2aee48Scth * to the database contents. 1951*ff2aee48Scth */ 1952*ff2aee48Scth again: locked = enter_db_lock(hdp, root_dir); 1953*ff2aee48Scth if (locked == -1) { 1954*ff2aee48Scth handle_free(&hdp); 1955*ff2aee48Scth return (NULL); 1956*ff2aee48Scth } else if (locked == 1) { 1957*ff2aee48Scth /* Open the DB and exit the lock. */ 1958*ff2aee48Scth err = open_db(hdp, OPEN_RDONLY); 1959*ff2aee48Scth exit_db_lock(hdp); 1960*ff2aee48Scth } else 1961*ff2aee48Scth return (hdp); /* walk /dev in di_devlink_walk */ 1962*ff2aee48Scth 1963*ff2aee48Scth /* 1964*ff2aee48Scth * If we failed to open DB the most likely cause is that DB file did 1965*ff2aee48Scth * not exist. If we have not done a retry, signal devfsadmd to 1966*ff2aee48Scth * recreate the DB file and retry. 1967*ff2aee48Scth * 1968*ff2aee48Scth * If we fail to open the DB with retry, we will walk /dev 19697c478bd9Sstevel@tonic-gate * in di_devlink_walk. 19707c478bd9Sstevel@tonic-gate */ 1971*ff2aee48Scth if (err && (retried == 0)) { 1972*ff2aee48Scth retried++; 1973*ff2aee48Scth (void) devlink_create(root_dir, NULL, DCA_DEVLINK_SYNC); 1974*ff2aee48Scth goto again; 1975*ff2aee48Scth } 19767c478bd9Sstevel@tonic-gate 19777c478bd9Sstevel@tonic-gate return (hdp); 19787c478bd9Sstevel@tonic-gate } 19797c478bd9Sstevel@tonic-gate 19807c478bd9Sstevel@tonic-gate int 19817c478bd9Sstevel@tonic-gate di_devlink_fini(di_devlink_handle_t *pp) 19827c478bd9Sstevel@tonic-gate { 19837c478bd9Sstevel@tonic-gate if (pp == NULL || *pp == NULL || !HDL_RDONLY(*pp)) { 19847c478bd9Sstevel@tonic-gate errno = EINVAL; 19857c478bd9Sstevel@tonic-gate return (-1); 19867c478bd9Sstevel@tonic-gate } 19877c478bd9Sstevel@tonic-gate 19887c478bd9Sstevel@tonic-gate /* Freeing the handle also closes the DB */ 19897c478bd9Sstevel@tonic-gate handle_free(pp); 19907c478bd9Sstevel@tonic-gate 19917c478bd9Sstevel@tonic-gate return (0); 19927c478bd9Sstevel@tonic-gate } 19937c478bd9Sstevel@tonic-gate 19947c478bd9Sstevel@tonic-gate int 19957c478bd9Sstevel@tonic-gate di_devlink_walk( 19967c478bd9Sstevel@tonic-gate di_devlink_handle_t hdp, 19977c478bd9Sstevel@tonic-gate const char *re, 19987c478bd9Sstevel@tonic-gate const char *minor_path, 19997c478bd9Sstevel@tonic-gate uint_t flags, 20007c478bd9Sstevel@tonic-gate void *arg, 20017c478bd9Sstevel@tonic-gate int (*devlink_callback)(di_devlink_t, void *)) 20027c478bd9Sstevel@tonic-gate { 20037c478bd9Sstevel@tonic-gate int rv; 20047c478bd9Sstevel@tonic-gate regex_t reg; 20057c478bd9Sstevel@tonic-gate link_desc_t linkd = {NULL}; 20067c478bd9Sstevel@tonic-gate 20077c478bd9Sstevel@tonic-gate if (hdp == NULL || !HDL_RDONLY(hdp)) { 20087c478bd9Sstevel@tonic-gate errno = EINVAL; 20097c478bd9Sstevel@tonic-gate return (-1); 20107c478bd9Sstevel@tonic-gate } 20117c478bd9Sstevel@tonic-gate 20127c478bd9Sstevel@tonic-gate linkd.minor_path = minor_path; 20137c478bd9Sstevel@tonic-gate linkd.flags = flags; 20147c478bd9Sstevel@tonic-gate linkd.arg = arg; 20157c478bd9Sstevel@tonic-gate linkd.fcn = devlink_callback; 20167c478bd9Sstevel@tonic-gate 20177c478bd9Sstevel@tonic-gate if (re) { 20187c478bd9Sstevel@tonic-gate if (regcomp(®, re, REG_EXTENDED) != 0) 20197c478bd9Sstevel@tonic-gate return (-1); 20207c478bd9Sstevel@tonic-gate linkd.regp = ® 20217c478bd9Sstevel@tonic-gate } 20227c478bd9Sstevel@tonic-gate 20237c478bd9Sstevel@tonic-gate if (check_args(&linkd)) { 20247c478bd9Sstevel@tonic-gate errno = EINVAL; 20257c478bd9Sstevel@tonic-gate rv = -1; 20267c478bd9Sstevel@tonic-gate goto out; 20277c478bd9Sstevel@tonic-gate } 20287c478bd9Sstevel@tonic-gate 20297c478bd9Sstevel@tonic-gate if (DB_OPEN(hdp)) { 20307c478bd9Sstevel@tonic-gate rv = walk_db(hdp, &linkd); 20317c478bd9Sstevel@tonic-gate } else { 20327c478bd9Sstevel@tonic-gate rv = walk_dev(hdp, &linkd); 20337c478bd9Sstevel@tonic-gate } 20347c478bd9Sstevel@tonic-gate 20357c478bd9Sstevel@tonic-gate out: 20367c478bd9Sstevel@tonic-gate if (re) { 20377c478bd9Sstevel@tonic-gate regfree(®); 20387c478bd9Sstevel@tonic-gate } 20397c478bd9Sstevel@tonic-gate 20407c478bd9Sstevel@tonic-gate return (rv ? -1 : 0); 20417c478bd9Sstevel@tonic-gate } 20427c478bd9Sstevel@tonic-gate 20437c478bd9Sstevel@tonic-gate static int 20447c478bd9Sstevel@tonic-gate link_flag(uint_t flags) 20457c478bd9Sstevel@tonic-gate { 20467c478bd9Sstevel@tonic-gate if (flags != 0 && flags != DI_PRIMARY_LINK && 20477c478bd9Sstevel@tonic-gate flags != DI_SECONDARY_LINK) { 20487c478bd9Sstevel@tonic-gate return (0); 20497c478bd9Sstevel@tonic-gate } 20507c478bd9Sstevel@tonic-gate 20517c478bd9Sstevel@tonic-gate return (1); 20527c478bd9Sstevel@tonic-gate } 20537c478bd9Sstevel@tonic-gate 20547c478bd9Sstevel@tonic-gate /* 20557c478bd9Sstevel@tonic-gate * Currently allowed flags are: 20567c478bd9Sstevel@tonic-gate * DI_PRIMARY_LINK 20577c478bd9Sstevel@tonic-gate * DI_SECONDARY_LINK 20587c478bd9Sstevel@tonic-gate */ 20597c478bd9Sstevel@tonic-gate static int 20607c478bd9Sstevel@tonic-gate check_args(link_desc_t *linkp) 20617c478bd9Sstevel@tonic-gate { 20627c478bd9Sstevel@tonic-gate if (linkp->fcn == NULL) 20637c478bd9Sstevel@tonic-gate return (-1); 20647c478bd9Sstevel@tonic-gate 20657c478bd9Sstevel@tonic-gate if (!link_flag(linkp->flags)) { 20667c478bd9Sstevel@tonic-gate return (-1); 20677c478bd9Sstevel@tonic-gate } 20687c478bd9Sstevel@tonic-gate 20697c478bd9Sstevel@tonic-gate /* 20707c478bd9Sstevel@tonic-gate * Minor path can be NULL. In that case, all links will be 20717c478bd9Sstevel@tonic-gate * selected. 20727c478bd9Sstevel@tonic-gate */ 20737c478bd9Sstevel@tonic-gate if (linkp->minor_path) { 20747c478bd9Sstevel@tonic-gate if (linkp->minor_path[0] != '/' || 20757c478bd9Sstevel@tonic-gate minor_colon(linkp->minor_path) == NULL) { 20767c478bd9Sstevel@tonic-gate return (-1); 20777c478bd9Sstevel@tonic-gate } 20787c478bd9Sstevel@tonic-gate } 20797c478bd9Sstevel@tonic-gate 20807c478bd9Sstevel@tonic-gate return (0); 20817c478bd9Sstevel@tonic-gate } 20827c478bd9Sstevel@tonic-gate 20837c478bd9Sstevel@tonic-gate 20847c478bd9Sstevel@tonic-gate /* 20857c478bd9Sstevel@tonic-gate * Walk all links in database if no minor path is specified. 20867c478bd9Sstevel@tonic-gate */ 20877c478bd9Sstevel@tonic-gate static int 20887c478bd9Sstevel@tonic-gate walk_db(struct di_devlink_handle *hdp, link_desc_t *linkp) 20897c478bd9Sstevel@tonic-gate { 20907c478bd9Sstevel@tonic-gate assert(DB_OPEN(hdp)); 20917c478bd9Sstevel@tonic-gate 20927c478bd9Sstevel@tonic-gate if (linkp->minor_path == NULL) { 20937c478bd9Sstevel@tonic-gate return (walk_all_links(hdp, linkp)); 20947c478bd9Sstevel@tonic-gate } else { 20957c478bd9Sstevel@tonic-gate return (walk_matching_links(hdp, linkp)); 20967c478bd9Sstevel@tonic-gate } 20977c478bd9Sstevel@tonic-gate } 20987c478bd9Sstevel@tonic-gate 20997c478bd9Sstevel@tonic-gate static int 21007c478bd9Sstevel@tonic-gate cache_dev(struct di_devlink_handle *hdp) 21017c478bd9Sstevel@tonic-gate { 21027c478bd9Sstevel@tonic-gate size_t sz; 21037c478bd9Sstevel@tonic-gate recurse_t rec = {NULL}; 21047c478bd9Sstevel@tonic-gate 21057c478bd9Sstevel@tonic-gate assert(hdp); 21067c478bd9Sstevel@tonic-gate assert(HDL_RDONLY(hdp)); 21077c478bd9Sstevel@tonic-gate 21087c478bd9Sstevel@tonic-gate if (hdp == NULL || !HDL_RDONLY(hdp)) { 21097c478bd9Sstevel@tonic-gate dprintf(DBG_ERR, "cache_dev: invalid arg\n"); 21107c478bd9Sstevel@tonic-gate return (-1); 21117c478bd9Sstevel@tonic-gate } 21127c478bd9Sstevel@tonic-gate 21137c478bd9Sstevel@tonic-gate sz = MIN_HASH_SIZE; 21147c478bd9Sstevel@tonic-gate 21157c478bd9Sstevel@tonic-gate CACHE(hdp)->hash = calloc(sz, sizeof (cache_link_t *)); 21167c478bd9Sstevel@tonic-gate if (CACHE(hdp)->hash == NULL) { 21177c478bd9Sstevel@tonic-gate return (-1); 21187c478bd9Sstevel@tonic-gate } 21197c478bd9Sstevel@tonic-gate CACHE(hdp)->hash_sz = sz; 21207c478bd9Sstevel@tonic-gate 21217c478bd9Sstevel@tonic-gate rec.data = NULL; 21227c478bd9Sstevel@tonic-gate rec.fcn = cache_dev_link; 21237c478bd9Sstevel@tonic-gate 21247c478bd9Sstevel@tonic-gate return (recurse_dev(hdp, &rec)); 21257c478bd9Sstevel@tonic-gate } 21267c478bd9Sstevel@tonic-gate 21277c478bd9Sstevel@tonic-gate static int 21287c478bd9Sstevel@tonic-gate walk_dev(struct di_devlink_handle *hdp, link_desc_t *linkp) 21297c478bd9Sstevel@tonic-gate { 21307c478bd9Sstevel@tonic-gate assert(hdp && linkp); 21317c478bd9Sstevel@tonic-gate assert(!DB_OPEN(hdp)); 21327c478bd9Sstevel@tonic-gate assert(HDL_RDONLY(hdp)); 21337c478bd9Sstevel@tonic-gate 21347c478bd9Sstevel@tonic-gate if (hdp == NULL || !HDL_RDONLY(hdp) || DB_OPEN(hdp)) { 21357c478bd9Sstevel@tonic-gate dprintf(DBG_ERR, "walk_dev: invalid args\n"); 21367c478bd9Sstevel@tonic-gate return (-1); 21377c478bd9Sstevel@tonic-gate } 21387c478bd9Sstevel@tonic-gate 21397c478bd9Sstevel@tonic-gate if (CACHE_EMPTY(hdp) && cache_dev(hdp) != 0) { 21407c478bd9Sstevel@tonic-gate dprintf(DBG_ERR, "walk_dev: /dev caching failed\n"); 21417c478bd9Sstevel@tonic-gate return (-1); 21427c478bd9Sstevel@tonic-gate } 21437c478bd9Sstevel@tonic-gate 21447c478bd9Sstevel@tonic-gate if (linkp->minor_path) 21457c478bd9Sstevel@tonic-gate walk_cache_minor(hdp, linkp->minor_path, linkp); 21467c478bd9Sstevel@tonic-gate else 21477c478bd9Sstevel@tonic-gate walk_all_cache(hdp, linkp); 21487c478bd9Sstevel@tonic-gate 21497c478bd9Sstevel@tonic-gate return (linkp->retval); 21507c478bd9Sstevel@tonic-gate } 21517c478bd9Sstevel@tonic-gate 21527c478bd9Sstevel@tonic-gate /* ARGSUSED */ 21537c478bd9Sstevel@tonic-gate static int 21547c478bd9Sstevel@tonic-gate cache_dev_link(struct di_devlink_handle *hdp, void *data, const char *link) 21557c478bd9Sstevel@tonic-gate { 21567c478bd9Sstevel@tonic-gate int flags; 21577c478bd9Sstevel@tonic-gate cache_link_t *clp; 21587c478bd9Sstevel@tonic-gate char content[PATH_MAX]; 21597c478bd9Sstevel@tonic-gate 21607c478bd9Sstevel@tonic-gate assert(HDL_RDWR(hdp) || HDL_RDONLY(hdp)); 21617c478bd9Sstevel@tonic-gate 21627c478bd9Sstevel@tonic-gate if (s_readlink(link, content, sizeof (content)) < 0) { 21637c478bd9Sstevel@tonic-gate return (DI_WALK_CONTINUE); 21647c478bd9Sstevel@tonic-gate } 21657c478bd9Sstevel@tonic-gate 21667c478bd9Sstevel@tonic-gate if (is_minor_node(content, NULL)) { 21677c478bd9Sstevel@tonic-gate flags = DI_PRIMARY_LINK; 21687c478bd9Sstevel@tonic-gate } else { 21697c478bd9Sstevel@tonic-gate flags = DI_SECONDARY_LINK; 21707c478bd9Sstevel@tonic-gate } 21717c478bd9Sstevel@tonic-gate 21727c478bd9Sstevel@tonic-gate assert(strncmp(link, hdp->dev_dir, strlen(hdp->dev_dir)) == 0); 21737c478bd9Sstevel@tonic-gate 21747c478bd9Sstevel@tonic-gate /* 21757c478bd9Sstevel@tonic-gate * Store only the part after <root-dir>/dev/ 21767c478bd9Sstevel@tonic-gate */ 21777c478bd9Sstevel@tonic-gate link += strlen(hdp->dev_dir) + 1; 21787c478bd9Sstevel@tonic-gate 21797c478bd9Sstevel@tonic-gate if ((clp = add_link(hdp, link, content, flags)) != NULL) { 21807c478bd9Sstevel@tonic-gate SET_VALID_ATTR(clp->attr); 21817c478bd9Sstevel@tonic-gate } 21827c478bd9Sstevel@tonic-gate 21837c478bd9Sstevel@tonic-gate return (DI_WALK_CONTINUE); 21847c478bd9Sstevel@tonic-gate } 21857c478bd9Sstevel@tonic-gate 21867c478bd9Sstevel@tonic-gate 21877c478bd9Sstevel@tonic-gate static int 21887c478bd9Sstevel@tonic-gate walk_all_links(struct di_devlink_handle *hdp, link_desc_t *linkp) 21897c478bd9Sstevel@tonic-gate { 21907c478bd9Sstevel@tonic-gate struct db_link *dlp; 21917c478bd9Sstevel@tonic-gate uint32_t nidx, eidx; 21927c478bd9Sstevel@tonic-gate 21937c478bd9Sstevel@tonic-gate assert(DB_NUM(hdp, DB_LINK) >= 1); 21947c478bd9Sstevel@tonic-gate 21957c478bd9Sstevel@tonic-gate eidx = DB_NUM(hdp, DB_LINK); 21967c478bd9Sstevel@tonic-gate 21977c478bd9Sstevel@tonic-gate /* Skip the "NIL" (index == 0) link. */ 21987c478bd9Sstevel@tonic-gate for (nidx = 1; nidx < eidx; nidx++) { 21997c478bd9Sstevel@tonic-gate /* 22007c478bd9Sstevel@tonic-gate * Declare this local to the block with zero 22017c478bd9Sstevel@tonic-gate * initializer so that it gets rezeroed 22027c478bd9Sstevel@tonic-gate * for each iteration. 22037c478bd9Sstevel@tonic-gate */ 22047c478bd9Sstevel@tonic-gate struct di_devlink vlink = {NULL}; 22057c478bd9Sstevel@tonic-gate 22067c478bd9Sstevel@tonic-gate if ((dlp = get_link(hdp, nidx)) == NULL) 22077c478bd9Sstevel@tonic-gate continue; 22087c478bd9Sstevel@tonic-gate 22097c478bd9Sstevel@tonic-gate vlink.rel_path = get_string(hdp, dlp->path); 22107c478bd9Sstevel@tonic-gate vlink.content = get_string(hdp, dlp->content); 22117c478bd9Sstevel@tonic-gate vlink.type = attr2type(dlp->attr); 22127c478bd9Sstevel@tonic-gate 22137c478bd9Sstevel@tonic-gate if (visit_link(hdp, linkp, &vlink) != DI_WALK_CONTINUE) { 22147c478bd9Sstevel@tonic-gate break; 22157c478bd9Sstevel@tonic-gate } 22167c478bd9Sstevel@tonic-gate } 22177c478bd9Sstevel@tonic-gate 22187c478bd9Sstevel@tonic-gate return (linkp->retval); 22197c478bd9Sstevel@tonic-gate } 22207c478bd9Sstevel@tonic-gate 22217c478bd9Sstevel@tonic-gate static int 22227c478bd9Sstevel@tonic-gate walk_matching_links(struct di_devlink_handle *hdp, link_desc_t *linkp) 22237c478bd9Sstevel@tonic-gate { 22247c478bd9Sstevel@tonic-gate uint32_t nidx; 22257c478bd9Sstevel@tonic-gate struct db_link *dlp; 22267c478bd9Sstevel@tonic-gate struct db_minor *dmp; 22277c478bd9Sstevel@tonic-gate 22287c478bd9Sstevel@tonic-gate assert(linkp->minor_path != NULL); 22297c478bd9Sstevel@tonic-gate 22307c478bd9Sstevel@tonic-gate dmp = lookup_minor(hdp, linkp->minor_path, NULL, TYPE_DB); 22317c478bd9Sstevel@tonic-gate 22327c478bd9Sstevel@tonic-gate /* 22337c478bd9Sstevel@tonic-gate * If a minor matching the path exists, walk that minor's devlinks list. 22347c478bd9Sstevel@tonic-gate * Then walk the dangling devlinks list. Non-matching devlinks will be 22357c478bd9Sstevel@tonic-gate * filtered out in visit_link. 22367c478bd9Sstevel@tonic-gate */ 22377c478bd9Sstevel@tonic-gate for (;;) { 22387c478bd9Sstevel@tonic-gate nidx = dmp ? dmp->link : DB_HDR(hdp)->dngl_idx; 22397c478bd9Sstevel@tonic-gate for (; dlp = get_link(hdp, nidx); nidx = dlp->sib) { 22407c478bd9Sstevel@tonic-gate struct di_devlink vlink = {NULL}; 22417c478bd9Sstevel@tonic-gate 22427c478bd9Sstevel@tonic-gate vlink.rel_path = get_string(hdp, dlp->path); 22437c478bd9Sstevel@tonic-gate vlink.content = get_string(hdp, dlp->content); 22447c478bd9Sstevel@tonic-gate vlink.type = attr2type(dlp->attr); 22457c478bd9Sstevel@tonic-gate 22467c478bd9Sstevel@tonic-gate if (visit_link(hdp, linkp, &vlink) != DI_WALK_CONTINUE) 22477c478bd9Sstevel@tonic-gate goto out; 22487c478bd9Sstevel@tonic-gate } 22497c478bd9Sstevel@tonic-gate if (dmp == NULL) { 22507c478bd9Sstevel@tonic-gate break; 22517c478bd9Sstevel@tonic-gate } else { 22527c478bd9Sstevel@tonic-gate dmp = NULL; 22537c478bd9Sstevel@tonic-gate } 22547c478bd9Sstevel@tonic-gate } 22557c478bd9Sstevel@tonic-gate 22567c478bd9Sstevel@tonic-gate out: 22577c478bd9Sstevel@tonic-gate return (linkp->retval); 22587c478bd9Sstevel@tonic-gate } 22597c478bd9Sstevel@tonic-gate 22607c478bd9Sstevel@tonic-gate static int 22617c478bd9Sstevel@tonic-gate visit_link( 22627c478bd9Sstevel@tonic-gate struct di_devlink_handle *hdp, 22637c478bd9Sstevel@tonic-gate link_desc_t *linkp, 22647c478bd9Sstevel@tonic-gate struct di_devlink *vlp) 22657c478bd9Sstevel@tonic-gate { 22667c478bd9Sstevel@tonic-gate struct stat sbuf; 22677c478bd9Sstevel@tonic-gate const char *minor_path = NULL; 22687c478bd9Sstevel@tonic-gate char abs_path[PATH_MAX], cont[PATH_MAX]; 22697c478bd9Sstevel@tonic-gate 22707c478bd9Sstevel@tonic-gate /* 22717c478bd9Sstevel@tonic-gate * It is legal for the link's content and type to be unknown. 22727c478bd9Sstevel@tonic-gate * but one of absolute or relative path must be set. 22737c478bd9Sstevel@tonic-gate */ 22747c478bd9Sstevel@tonic-gate if (vlp->rel_path == NULL && vlp->abs_path == NULL) { 22757c478bd9Sstevel@tonic-gate (void) dprintf(DBG_ERR, "visit_link: invalid arguments\n"); 22767c478bd9Sstevel@tonic-gate return (DI_WALK_CONTINUE); 22777c478bd9Sstevel@tonic-gate } 22787c478bd9Sstevel@tonic-gate 22797c478bd9Sstevel@tonic-gate if (vlp->rel_path == NULL) { 22807c478bd9Sstevel@tonic-gate vlp->rel_path = (char *)rel_path(hdp, vlp->abs_path); 22817c478bd9Sstevel@tonic-gate if (vlp->rel_path == NULL || vlp->rel_path[0] == '\0') 22827c478bd9Sstevel@tonic-gate return (DI_WALK_CONTINUE); 22837c478bd9Sstevel@tonic-gate } 22847c478bd9Sstevel@tonic-gate 22857c478bd9Sstevel@tonic-gate if (linkp->regp) { 22867c478bd9Sstevel@tonic-gate if (regexec(linkp->regp, vlp->rel_path, 0, NULL, 0) != 0) 22877c478bd9Sstevel@tonic-gate return (DI_WALK_CONTINUE); 22887c478bd9Sstevel@tonic-gate } 22897c478bd9Sstevel@tonic-gate 22907c478bd9Sstevel@tonic-gate if (vlp->abs_path == NULL) { 22917c478bd9Sstevel@tonic-gate assert(vlp->rel_path[0] != '/'); 22927c478bd9Sstevel@tonic-gate (void) snprintf(abs_path, sizeof (abs_path), "%s/%s", 22937c478bd9Sstevel@tonic-gate hdp->dev_dir, vlp->rel_path); 22947c478bd9Sstevel@tonic-gate vlp->abs_path = abs_path; 22957c478bd9Sstevel@tonic-gate } 22967c478bd9Sstevel@tonic-gate 22977c478bd9Sstevel@tonic-gate if (vlp->content == NULL) { 22987c478bd9Sstevel@tonic-gate if (s_readlink(vlp->abs_path, cont, sizeof (cont)) < 0) { 22997c478bd9Sstevel@tonic-gate return (DI_WALK_CONTINUE); 23007c478bd9Sstevel@tonic-gate } 23017c478bd9Sstevel@tonic-gate vlp->content = cont; 23027c478bd9Sstevel@tonic-gate } 23037c478bd9Sstevel@tonic-gate 23047c478bd9Sstevel@tonic-gate 23057c478bd9Sstevel@tonic-gate if (vlp->type == 0) { 23067c478bd9Sstevel@tonic-gate if (is_minor_node(vlp->content, &minor_path)) { 23077c478bd9Sstevel@tonic-gate vlp->type = DI_PRIMARY_LINK; 23087c478bd9Sstevel@tonic-gate } else { 23097c478bd9Sstevel@tonic-gate vlp->type = DI_SECONDARY_LINK; 23107c478bd9Sstevel@tonic-gate } 23117c478bd9Sstevel@tonic-gate } 23127c478bd9Sstevel@tonic-gate 23137c478bd9Sstevel@tonic-gate /* 23147c478bd9Sstevel@tonic-gate * Filter based on minor path 23157c478bd9Sstevel@tonic-gate */ 23167c478bd9Sstevel@tonic-gate if (linkp->minor_path) { 23177c478bd9Sstevel@tonic-gate char tmp[PATH_MAX]; 23187c478bd9Sstevel@tonic-gate 23197c478bd9Sstevel@tonic-gate /* 23207c478bd9Sstevel@tonic-gate * derive minor path 23217c478bd9Sstevel@tonic-gate */ 23227c478bd9Sstevel@tonic-gate if (vlp->type == DI_SECONDARY_LINK) { 23237c478bd9Sstevel@tonic-gate 23247c478bd9Sstevel@tonic-gate #ifdef DEBUG 23257c478bd9Sstevel@tonic-gate /*LINTED*/ 23267c478bd9Sstevel@tonic-gate assert(sizeof (tmp) >= PATH_MAX); 23277c478bd9Sstevel@tonic-gate #endif 2328*ff2aee48Scth if (s_realpath(vlp->abs_path, tmp) == NULL) 23297c478bd9Sstevel@tonic-gate return (DI_WALK_CONTINUE); 23307c478bd9Sstevel@tonic-gate 23317c478bd9Sstevel@tonic-gate if (!is_minor_node(tmp, &minor_path)) 23327c478bd9Sstevel@tonic-gate return (DI_WALK_CONTINUE); 23337c478bd9Sstevel@tonic-gate 23347c478bd9Sstevel@tonic-gate } else if (minor_path == NULL) { 23357c478bd9Sstevel@tonic-gate if (!is_minor_node(vlp->content, &minor_path)) 23367c478bd9Sstevel@tonic-gate return (DI_WALK_CONTINUE); 23377c478bd9Sstevel@tonic-gate } 23387c478bd9Sstevel@tonic-gate 23397c478bd9Sstevel@tonic-gate assert(minor_path != NULL); 23407c478bd9Sstevel@tonic-gate 23417c478bd9Sstevel@tonic-gate if (strcmp(linkp->minor_path, minor_path) != 0) 23427c478bd9Sstevel@tonic-gate return (DI_WALK_CONTINUE); 23437c478bd9Sstevel@tonic-gate } 23447c478bd9Sstevel@tonic-gate 23457c478bd9Sstevel@tonic-gate /* 23467c478bd9Sstevel@tonic-gate * Filter based on link type 23477c478bd9Sstevel@tonic-gate */ 23487c478bd9Sstevel@tonic-gate if (!TYPE_NONE(linkp->flags) && LINK_TYPE(linkp->flags) != vlp->type) { 23497c478bd9Sstevel@tonic-gate return (DI_WALK_CONTINUE); 23507c478bd9Sstevel@tonic-gate } 23517c478bd9Sstevel@tonic-gate 23527c478bd9Sstevel@tonic-gate if (lstat(vlp->abs_path, &sbuf) < 0) { 23537c478bd9Sstevel@tonic-gate dprintf(DBG_ERR, "visit_link: %s: lstat failed: %s\n", 23547c478bd9Sstevel@tonic-gate vlp->abs_path, strerror(errno)); 23557c478bd9Sstevel@tonic-gate return (DI_WALK_CONTINUE); 23567c478bd9Sstevel@tonic-gate } 23577c478bd9Sstevel@tonic-gate 23587c478bd9Sstevel@tonic-gate return (linkp->fcn(vlp, linkp->arg)); 23597c478bd9Sstevel@tonic-gate } 23607c478bd9Sstevel@tonic-gate 23617c478bd9Sstevel@tonic-gate static int 23627c478bd9Sstevel@tonic-gate devlink_valid(di_devlink_t devlink) 23637c478bd9Sstevel@tonic-gate { 23647c478bd9Sstevel@tonic-gate if (devlink == NULL || devlink->rel_path == NULL || 23657c478bd9Sstevel@tonic-gate devlink->abs_path == NULL || devlink->content == NULL || 23667c478bd9Sstevel@tonic-gate TYPE_NONE(devlink->type)) { 23677c478bd9Sstevel@tonic-gate return (0); 23687c478bd9Sstevel@tonic-gate } 23697c478bd9Sstevel@tonic-gate 23707c478bd9Sstevel@tonic-gate return (1); 23717c478bd9Sstevel@tonic-gate } 23727c478bd9Sstevel@tonic-gate 23737c478bd9Sstevel@tonic-gate const char * 23747c478bd9Sstevel@tonic-gate di_devlink_path(di_devlink_t devlink) 23757c478bd9Sstevel@tonic-gate { 23767c478bd9Sstevel@tonic-gate if (!devlink_valid(devlink)) { 23777c478bd9Sstevel@tonic-gate errno = EINVAL; 23787c478bd9Sstevel@tonic-gate return (NULL); 23797c478bd9Sstevel@tonic-gate } 23807c478bd9Sstevel@tonic-gate 23817c478bd9Sstevel@tonic-gate return (devlink->abs_path); 23827c478bd9Sstevel@tonic-gate } 23837c478bd9Sstevel@tonic-gate 23847c478bd9Sstevel@tonic-gate const char * 23857c478bd9Sstevel@tonic-gate di_devlink_content(di_devlink_t devlink) 23867c478bd9Sstevel@tonic-gate { 23877c478bd9Sstevel@tonic-gate if (!devlink_valid(devlink)) { 23887c478bd9Sstevel@tonic-gate errno = EINVAL; 23897c478bd9Sstevel@tonic-gate return (NULL); 23907c478bd9Sstevel@tonic-gate } 23917c478bd9Sstevel@tonic-gate 23927c478bd9Sstevel@tonic-gate return (devlink->content); 23937c478bd9Sstevel@tonic-gate } 23947c478bd9Sstevel@tonic-gate 23957c478bd9Sstevel@tonic-gate int 23967c478bd9Sstevel@tonic-gate di_devlink_type(di_devlink_t devlink) 23977c478bd9Sstevel@tonic-gate { 23987c478bd9Sstevel@tonic-gate if (!devlink_valid(devlink)) { 23997c478bd9Sstevel@tonic-gate errno = EINVAL; 24007c478bd9Sstevel@tonic-gate return (-1); 24017c478bd9Sstevel@tonic-gate } 24027c478bd9Sstevel@tonic-gate 24037c478bd9Sstevel@tonic-gate return (devlink->type); 24047c478bd9Sstevel@tonic-gate } 24057c478bd9Sstevel@tonic-gate 24067c478bd9Sstevel@tonic-gate di_devlink_t 24077c478bd9Sstevel@tonic-gate di_devlink_dup(di_devlink_t devlink) 24087c478bd9Sstevel@tonic-gate { 24097c478bd9Sstevel@tonic-gate struct di_devlink *duplink; 24107c478bd9Sstevel@tonic-gate 24117c478bd9Sstevel@tonic-gate if (!devlink_valid(devlink)) { 24127c478bd9Sstevel@tonic-gate errno = EINVAL; 24137c478bd9Sstevel@tonic-gate return (NULL); 24147c478bd9Sstevel@tonic-gate } 24157c478bd9Sstevel@tonic-gate 24167c478bd9Sstevel@tonic-gate if ((duplink = calloc(1, sizeof (struct di_devlink))) == NULL) { 24177c478bd9Sstevel@tonic-gate return (NULL); 24187c478bd9Sstevel@tonic-gate } 24197c478bd9Sstevel@tonic-gate 24207c478bd9Sstevel@tonic-gate duplink->rel_path = strdup(devlink->rel_path); 24217c478bd9Sstevel@tonic-gate duplink->abs_path = strdup(devlink->abs_path); 24227c478bd9Sstevel@tonic-gate duplink->content = strdup(devlink->content); 24237c478bd9Sstevel@tonic-gate duplink->type = devlink->type; 24247c478bd9Sstevel@tonic-gate 24257c478bd9Sstevel@tonic-gate if (!devlink_valid(duplink)) { 24267c478bd9Sstevel@tonic-gate (void) di_devlink_free(duplink); 24277c478bd9Sstevel@tonic-gate errno = ENOMEM; 24287c478bd9Sstevel@tonic-gate return (NULL); 24297c478bd9Sstevel@tonic-gate } 24307c478bd9Sstevel@tonic-gate 24317c478bd9Sstevel@tonic-gate return (duplink); 24327c478bd9Sstevel@tonic-gate } 24337c478bd9Sstevel@tonic-gate 24347c478bd9Sstevel@tonic-gate int 24357c478bd9Sstevel@tonic-gate di_devlink_free(di_devlink_t devlink) 24367c478bd9Sstevel@tonic-gate { 24377c478bd9Sstevel@tonic-gate if (devlink == NULL) { 24387c478bd9Sstevel@tonic-gate errno = EINVAL; 24397c478bd9Sstevel@tonic-gate return (-1); 24407c478bd9Sstevel@tonic-gate } 24417c478bd9Sstevel@tonic-gate 24427c478bd9Sstevel@tonic-gate free(devlink->rel_path); 24437c478bd9Sstevel@tonic-gate free(devlink->abs_path); 24447c478bd9Sstevel@tonic-gate free(devlink->content); 24457c478bd9Sstevel@tonic-gate free(devlink); 24467c478bd9Sstevel@tonic-gate 24477c478bd9Sstevel@tonic-gate return (0); 24487c478bd9Sstevel@tonic-gate } 24497c478bd9Sstevel@tonic-gate 24507c478bd9Sstevel@tonic-gate /* 24517c478bd9Sstevel@tonic-gate * Obtain path relative to dev_dir 24527c478bd9Sstevel@tonic-gate */ 24537c478bd9Sstevel@tonic-gate static const char * 24547c478bd9Sstevel@tonic-gate rel_path(struct di_devlink_handle *hdp, const char *path) 24557c478bd9Sstevel@tonic-gate { 24567c478bd9Sstevel@tonic-gate const size_t len = strlen(hdp->dev_dir); 24577c478bd9Sstevel@tonic-gate 24587c478bd9Sstevel@tonic-gate if (strncmp(path, hdp->dev_dir, len) != 0) 24597c478bd9Sstevel@tonic-gate return (NULL); 24607c478bd9Sstevel@tonic-gate 24617c478bd9Sstevel@tonic-gate if (path[len] == '\0') 24627c478bd9Sstevel@tonic-gate return (&path[len]); 24637c478bd9Sstevel@tonic-gate 24647c478bd9Sstevel@tonic-gate if (path[len] != '/') 24657c478bd9Sstevel@tonic-gate return (NULL); 24667c478bd9Sstevel@tonic-gate 24677c478bd9Sstevel@tonic-gate return (&path[len+1]); 24687c478bd9Sstevel@tonic-gate } 24697c478bd9Sstevel@tonic-gate 24707c478bd9Sstevel@tonic-gate static int 24717c478bd9Sstevel@tonic-gate recurse_dev(struct di_devlink_handle *hdp, recurse_t *rp) 24727c478bd9Sstevel@tonic-gate { 24737c478bd9Sstevel@tonic-gate int ret = 0; 24747c478bd9Sstevel@tonic-gate 24757c478bd9Sstevel@tonic-gate (void) do_recurse(hdp->dev_dir, hdp, rp, &ret); 24767c478bd9Sstevel@tonic-gate 24777c478bd9Sstevel@tonic-gate return (ret); 24787c478bd9Sstevel@tonic-gate } 24797c478bd9Sstevel@tonic-gate 24807c478bd9Sstevel@tonic-gate static int 24817c478bd9Sstevel@tonic-gate do_recurse( 24827c478bd9Sstevel@tonic-gate const char *dir, 24837c478bd9Sstevel@tonic-gate struct di_devlink_handle *hdp, 24847c478bd9Sstevel@tonic-gate recurse_t *rp, 24857c478bd9Sstevel@tonic-gate int *retp) 24867c478bd9Sstevel@tonic-gate { 24877c478bd9Sstevel@tonic-gate size_t len; 24887c478bd9Sstevel@tonic-gate const char *rel; 24897c478bd9Sstevel@tonic-gate struct stat sbuf; 24907c478bd9Sstevel@tonic-gate char cur[PATH_MAX], *cp; 24917c478bd9Sstevel@tonic-gate int i, rv = DI_WALK_CONTINUE; 2492facf4a8dSllai finddevhdl_t handle; 2493facf4a8dSllai char *d_name; 24947c478bd9Sstevel@tonic-gate 24957c478bd9Sstevel@tonic-gate 24967c478bd9Sstevel@tonic-gate if ((rel = rel_path(hdp, dir)) == NULL) 24977c478bd9Sstevel@tonic-gate return (DI_WALK_CONTINUE); 24987c478bd9Sstevel@tonic-gate 24997c478bd9Sstevel@tonic-gate /* 25007c478bd9Sstevel@tonic-gate * Skip directories we are not interested in. 25017c478bd9Sstevel@tonic-gate */ 25027c478bd9Sstevel@tonic-gate for (i = 0; i < N_SKIP_DIRS; i++) { 25037c478bd9Sstevel@tonic-gate if (strcmp(rel, skip_dirs[i]) == 0) { 25047c478bd9Sstevel@tonic-gate (void) dprintf(DBG_STEP, "do_recurse: skipping %s\n", 25057c478bd9Sstevel@tonic-gate dir); 25067c478bd9Sstevel@tonic-gate return (DI_WALK_CONTINUE); 25077c478bd9Sstevel@tonic-gate } 25087c478bd9Sstevel@tonic-gate } 25097c478bd9Sstevel@tonic-gate 25107c478bd9Sstevel@tonic-gate (void) dprintf(DBG_STEP, "do_recurse: dir = %s\n", dir); 25117c478bd9Sstevel@tonic-gate 2512facf4a8dSllai if (finddev_readdir(dir, &handle) != 0) 25137c478bd9Sstevel@tonic-gate return (DI_WALK_CONTINUE); 25147c478bd9Sstevel@tonic-gate 25157c478bd9Sstevel@tonic-gate (void) snprintf(cur, sizeof (cur), "%s/", dir); 25167c478bd9Sstevel@tonic-gate len = strlen(cur); 25177c478bd9Sstevel@tonic-gate cp = cur + len; 25187c478bd9Sstevel@tonic-gate len = sizeof (cur) - len; 25197c478bd9Sstevel@tonic-gate 2520facf4a8dSllai for (;;) { 2521facf4a8dSllai if ((d_name = (char *)finddev_next(handle)) == NULL) 2522facf4a8dSllai break; 25237c478bd9Sstevel@tonic-gate 2524facf4a8dSllai if (strlcpy(cp, d_name, len) >= len) 2525facf4a8dSllai break; 25267c478bd9Sstevel@tonic-gate 25277c478bd9Sstevel@tonic-gate /* 25287c478bd9Sstevel@tonic-gate * Skip files we are not interested in. 25297c478bd9Sstevel@tonic-gate */ 25307c478bd9Sstevel@tonic-gate for (i = 0; i < N_SKIP_FILES; i++) { 25317c478bd9Sstevel@tonic-gate 25327c478bd9Sstevel@tonic-gate rel = rel_path(hdp, cur); 25337c478bd9Sstevel@tonic-gate if (rel == NULL || strcmp(rel, skip_files[i]) == 0) { 25347c478bd9Sstevel@tonic-gate (void) dprintf(DBG_STEP, 25357c478bd9Sstevel@tonic-gate "do_recurse: skipping %s\n", cur); 25367c478bd9Sstevel@tonic-gate goto next_entry; 25377c478bd9Sstevel@tonic-gate } 25387c478bd9Sstevel@tonic-gate } 25397c478bd9Sstevel@tonic-gate 25407c478bd9Sstevel@tonic-gate if (lstat(cur, &sbuf) == 0) { 25417c478bd9Sstevel@tonic-gate if (S_ISDIR(sbuf.st_mode)) { 25427c478bd9Sstevel@tonic-gate rv = do_recurse(cur, hdp, rp, retp); 25437c478bd9Sstevel@tonic-gate } else if (S_ISLNK(sbuf.st_mode)) { 25447c478bd9Sstevel@tonic-gate rv = rp->fcn(hdp, rp->data, cur); 25457c478bd9Sstevel@tonic-gate } else { 25467c478bd9Sstevel@tonic-gate (void) dprintf(DBG_STEP, 25477c478bd9Sstevel@tonic-gate "do_recurse: Skipping entry: %s\n", cur); 25487c478bd9Sstevel@tonic-gate } 25497c478bd9Sstevel@tonic-gate } else { 25507c478bd9Sstevel@tonic-gate (void) dprintf(DBG_ERR, "do_recurse: cur(%s): lstat" 25517c478bd9Sstevel@tonic-gate " failed: %s\n", cur, strerror(errno)); 25527c478bd9Sstevel@tonic-gate } 25537c478bd9Sstevel@tonic-gate 25547c478bd9Sstevel@tonic-gate next_entry: 25557c478bd9Sstevel@tonic-gate *cp = '\0'; 25567c478bd9Sstevel@tonic-gate 25577c478bd9Sstevel@tonic-gate if (rv != DI_WALK_CONTINUE) 25587c478bd9Sstevel@tonic-gate break; 25597c478bd9Sstevel@tonic-gate } 25607c478bd9Sstevel@tonic-gate 2561facf4a8dSllai finddev_close(handle); 25627c478bd9Sstevel@tonic-gate 25637c478bd9Sstevel@tonic-gate return (rv); 25647c478bd9Sstevel@tonic-gate } 25657c478bd9Sstevel@tonic-gate 25667c478bd9Sstevel@tonic-gate 25677c478bd9Sstevel@tonic-gate static int 25687c478bd9Sstevel@tonic-gate check_attr(uint32_t attr) 25697c478bd9Sstevel@tonic-gate { 25707c478bd9Sstevel@tonic-gate switch (attr & A_LINK_TYPES) { 25717c478bd9Sstevel@tonic-gate case A_PRIMARY: 25727c478bd9Sstevel@tonic-gate case A_SECONDARY: 25737c478bd9Sstevel@tonic-gate return (1); 25747c478bd9Sstevel@tonic-gate default: 25757c478bd9Sstevel@tonic-gate dprintf(DBG_ERR, "check_attr: incorrect attr(%u)\n", 25767c478bd9Sstevel@tonic-gate attr); 25777c478bd9Sstevel@tonic-gate return (0); 25787c478bd9Sstevel@tonic-gate } 25797c478bd9Sstevel@tonic-gate } 25807c478bd9Sstevel@tonic-gate 25817c478bd9Sstevel@tonic-gate static int 25827c478bd9Sstevel@tonic-gate attr2type(uint32_t attr) 25837c478bd9Sstevel@tonic-gate { 25847c478bd9Sstevel@tonic-gate switch (attr & A_LINK_TYPES) { 25857c478bd9Sstevel@tonic-gate case A_PRIMARY: 25867c478bd9Sstevel@tonic-gate return (DI_PRIMARY_LINK); 25877c478bd9Sstevel@tonic-gate case A_SECONDARY: 25887c478bd9Sstevel@tonic-gate return (DI_SECONDARY_LINK); 25897c478bd9Sstevel@tonic-gate default: 25907c478bd9Sstevel@tonic-gate dprintf(DBG_ERR, "attr2type: incorrect attr(%u)\n", 25917c478bd9Sstevel@tonic-gate attr); 25927c478bd9Sstevel@tonic-gate return (0); 25937c478bd9Sstevel@tonic-gate } 25947c478bd9Sstevel@tonic-gate } 25957c478bd9Sstevel@tonic-gate 25967c478bd9Sstevel@tonic-gate /* Allocate new node and link it in */ 25977c478bd9Sstevel@tonic-gate static cache_node_t * 25987c478bd9Sstevel@tonic-gate node_insert( 25997c478bd9Sstevel@tonic-gate struct di_devlink_handle *hdp, 26007c478bd9Sstevel@tonic-gate cache_node_t *pcnp, 26017c478bd9Sstevel@tonic-gate const char *path, 26027c478bd9Sstevel@tonic-gate int insert) 26037c478bd9Sstevel@tonic-gate { 26047c478bd9Sstevel@tonic-gate cache_node_t *cnp; 26057c478bd9Sstevel@tonic-gate 26067c478bd9Sstevel@tonic-gate if (path == NULL) { 26077c478bd9Sstevel@tonic-gate errno = EINVAL; 26087c478bd9Sstevel@tonic-gate SET_DB_ERR(hdp); 26097c478bd9Sstevel@tonic-gate return (NULL); 26107c478bd9Sstevel@tonic-gate } 26117c478bd9Sstevel@tonic-gate 26127c478bd9Sstevel@tonic-gate if ((cnp = calloc(1, sizeof (cache_node_t))) == NULL) { 26137c478bd9Sstevel@tonic-gate SET_DB_ERR(hdp); 26147c478bd9Sstevel@tonic-gate return (NULL); 26157c478bd9Sstevel@tonic-gate } 26167c478bd9Sstevel@tonic-gate 26177c478bd9Sstevel@tonic-gate if ((cnp->path = strdup(path)) == NULL) { 26187c478bd9Sstevel@tonic-gate SET_DB_ERR(hdp); 26197c478bd9Sstevel@tonic-gate free(cnp); 26207c478bd9Sstevel@tonic-gate return (NULL); 26217c478bd9Sstevel@tonic-gate } 26227c478bd9Sstevel@tonic-gate 26237c478bd9Sstevel@tonic-gate cnp->parent = pcnp; 26247c478bd9Sstevel@tonic-gate 26257c478bd9Sstevel@tonic-gate if (pcnp == NULL) { 26267c478bd9Sstevel@tonic-gate assert(strcmp(path, "/") == 0); 26277c478bd9Sstevel@tonic-gate assert(CACHE(hdp)->root == NULL); 26287c478bd9Sstevel@tonic-gate CACHE(hdp)->root = cnp; 26297c478bd9Sstevel@tonic-gate } else if (insert == INSERT_HEAD) { 26307c478bd9Sstevel@tonic-gate cnp->sib = pcnp->child; 26317c478bd9Sstevel@tonic-gate pcnp->child = cnp; 26327c478bd9Sstevel@tonic-gate } else if (CACHE_LAST(hdp) && CACHE_LAST(hdp)->node && 26337c478bd9Sstevel@tonic-gate CACHE_LAST(hdp)->node->parent == pcnp && 26347c478bd9Sstevel@tonic-gate CACHE_LAST(hdp)->node->sib == NULL) { 26357c478bd9Sstevel@tonic-gate 26367c478bd9Sstevel@tonic-gate CACHE_LAST(hdp)->node->sib = cnp; 26377c478bd9Sstevel@tonic-gate 26387c478bd9Sstevel@tonic-gate } else { 26397c478bd9Sstevel@tonic-gate cache_node_t **pp; 26407c478bd9Sstevel@tonic-gate 26417c478bd9Sstevel@tonic-gate for (pp = &pcnp->child; *pp != NULL; pp = &(*pp)->sib) 26427c478bd9Sstevel@tonic-gate ; 26437c478bd9Sstevel@tonic-gate *pp = cnp; 26447c478bd9Sstevel@tonic-gate } 26457c478bd9Sstevel@tonic-gate 26467c478bd9Sstevel@tonic-gate return (cnp); 26477c478bd9Sstevel@tonic-gate } 26487c478bd9Sstevel@tonic-gate 26497c478bd9Sstevel@tonic-gate /* 26507c478bd9Sstevel@tonic-gate * Allocate a new minor and link it in either at the tail or head 26517c478bd9Sstevel@tonic-gate * of the minor list depending on the value of "prev". 26527c478bd9Sstevel@tonic-gate */ 26537c478bd9Sstevel@tonic-gate static cache_minor_t * 26547c478bd9Sstevel@tonic-gate minor_insert( 26557c478bd9Sstevel@tonic-gate struct di_devlink_handle *hdp, 26567c478bd9Sstevel@tonic-gate cache_node_t *pcnp, 26577c478bd9Sstevel@tonic-gate const char *name, 26587c478bd9Sstevel@tonic-gate const char *nodetype, 26597c478bd9Sstevel@tonic-gate cache_minor_t **prev) 26607c478bd9Sstevel@tonic-gate { 26617c478bd9Sstevel@tonic-gate cache_minor_t *cmnp; 26627c478bd9Sstevel@tonic-gate 26637c478bd9Sstevel@tonic-gate if (pcnp == NULL || name == NULL) { 26647c478bd9Sstevel@tonic-gate errno = EINVAL; 26657c478bd9Sstevel@tonic-gate SET_DB_ERR(hdp); 26667c478bd9Sstevel@tonic-gate return (NULL); 26677c478bd9Sstevel@tonic-gate } 26687c478bd9Sstevel@tonic-gate 26697c478bd9Sstevel@tonic-gate /* 26707c478bd9Sstevel@tonic-gate * Some pseudo drivers don't specify nodetype. Assume pseudo if 26717c478bd9Sstevel@tonic-gate * nodetype is not specified. 26727c478bd9Sstevel@tonic-gate */ 26737c478bd9Sstevel@tonic-gate if (nodetype == NULL) 26747c478bd9Sstevel@tonic-gate nodetype = DDI_PSEUDO; 26757c478bd9Sstevel@tonic-gate 26767c478bd9Sstevel@tonic-gate if ((cmnp = calloc(1, sizeof (cache_minor_t))) == NULL) { 26777c478bd9Sstevel@tonic-gate SET_DB_ERR(hdp); 26787c478bd9Sstevel@tonic-gate return (NULL); 26797c478bd9Sstevel@tonic-gate } 26807c478bd9Sstevel@tonic-gate 26817c478bd9Sstevel@tonic-gate cmnp->name = strdup(name); 26827c478bd9Sstevel@tonic-gate cmnp->nodetype = strdup(nodetype); 26837c478bd9Sstevel@tonic-gate if (cmnp->name == NULL || cmnp->nodetype == NULL) { 26847c478bd9Sstevel@tonic-gate SET_DB_ERR(hdp); 26857c478bd9Sstevel@tonic-gate free(cmnp->name); 26867c478bd9Sstevel@tonic-gate free(cmnp->nodetype); 26877c478bd9Sstevel@tonic-gate free(cmnp); 26887c478bd9Sstevel@tonic-gate return (NULL); 26897c478bd9Sstevel@tonic-gate } 26907c478bd9Sstevel@tonic-gate 26917c478bd9Sstevel@tonic-gate cmnp->node = pcnp; 26927c478bd9Sstevel@tonic-gate 26937c478bd9Sstevel@tonic-gate /* Add to node's minor list */ 26947c478bd9Sstevel@tonic-gate if (prev == NULL) { 26957c478bd9Sstevel@tonic-gate cmnp->sib = pcnp->minor; 26967c478bd9Sstevel@tonic-gate pcnp->minor = cmnp; 26977c478bd9Sstevel@tonic-gate } else { 26987c478bd9Sstevel@tonic-gate assert(*prev == NULL); 26997c478bd9Sstevel@tonic-gate *prev = cmnp; 27007c478bd9Sstevel@tonic-gate } 27017c478bd9Sstevel@tonic-gate 27027c478bd9Sstevel@tonic-gate return (cmnp); 27037c478bd9Sstevel@tonic-gate } 27047c478bd9Sstevel@tonic-gate 27057c478bd9Sstevel@tonic-gate static cache_link_t * 27067c478bd9Sstevel@tonic-gate link_insert( 27077c478bd9Sstevel@tonic-gate struct di_devlink_handle *hdp, 27087c478bd9Sstevel@tonic-gate cache_minor_t *cmnp, 27097c478bd9Sstevel@tonic-gate const char *path, 27107c478bd9Sstevel@tonic-gate const char *content, 27117c478bd9Sstevel@tonic-gate uint32_t attr) 27127c478bd9Sstevel@tonic-gate { 27137c478bd9Sstevel@tonic-gate cache_link_t *clp; 27147c478bd9Sstevel@tonic-gate 27157c478bd9Sstevel@tonic-gate if (path == NULL || content == NULL || !check_attr(attr)) { 27167c478bd9Sstevel@tonic-gate errno = EINVAL; 27177c478bd9Sstevel@tonic-gate SET_DB_ERR(hdp); 27187c478bd9Sstevel@tonic-gate return (NULL); 27197c478bd9Sstevel@tonic-gate } 27207c478bd9Sstevel@tonic-gate 27217c478bd9Sstevel@tonic-gate if ((clp = calloc(1, sizeof (cache_link_t))) == NULL) { 27227c478bd9Sstevel@tonic-gate SET_DB_ERR(hdp); 27237c478bd9Sstevel@tonic-gate return (NULL); 27247c478bd9Sstevel@tonic-gate } 27257c478bd9Sstevel@tonic-gate 27267c478bd9Sstevel@tonic-gate clp->path = strdup(path); 27277c478bd9Sstevel@tonic-gate clp->content = strdup(content); 27287c478bd9Sstevel@tonic-gate if (clp->path == NULL || clp->content == NULL) { 27297c478bd9Sstevel@tonic-gate SET_DB_ERR(hdp); 27307c478bd9Sstevel@tonic-gate link_free(&clp); 27317c478bd9Sstevel@tonic-gate return (NULL); 27327c478bd9Sstevel@tonic-gate } 27337c478bd9Sstevel@tonic-gate 27347c478bd9Sstevel@tonic-gate clp->attr = attr; 27357c478bd9Sstevel@tonic-gate hash_insert(hdp, clp); 27367c478bd9Sstevel@tonic-gate clp->minor = cmnp; 27377c478bd9Sstevel@tonic-gate 27387c478bd9Sstevel@tonic-gate /* Add to minor's link list */ 27397c478bd9Sstevel@tonic-gate if (cmnp != NULL) { 27407c478bd9Sstevel@tonic-gate clp->sib = cmnp->link; 27417c478bd9Sstevel@tonic-gate cmnp->link = clp; 27427c478bd9Sstevel@tonic-gate } else { 27437c478bd9Sstevel@tonic-gate clp->sib = CACHE(hdp)->dngl; 27447c478bd9Sstevel@tonic-gate CACHE(hdp)->dngl = clp; 27457c478bd9Sstevel@tonic-gate } 27467c478bd9Sstevel@tonic-gate 27477c478bd9Sstevel@tonic-gate return (clp); 27487c478bd9Sstevel@tonic-gate } 27497c478bd9Sstevel@tonic-gate 27507c478bd9Sstevel@tonic-gate static void 27517c478bd9Sstevel@tonic-gate hash_insert(struct di_devlink_handle *hdp, cache_link_t *clp) 27527c478bd9Sstevel@tonic-gate { 27537c478bd9Sstevel@tonic-gate uint_t hval; 27547c478bd9Sstevel@tonic-gate 27557c478bd9Sstevel@tonic-gate hval = hashfn(hdp, clp->path); 27567c478bd9Sstevel@tonic-gate clp->hash = CACHE_HASH(hdp, hval); 27577c478bd9Sstevel@tonic-gate CACHE_HASH(hdp, hval) = clp; 27587c478bd9Sstevel@tonic-gate } 27597c478bd9Sstevel@tonic-gate 27607c478bd9Sstevel@tonic-gate 27617c478bd9Sstevel@tonic-gate static struct db_node * 27627c478bd9Sstevel@tonic-gate get_node(struct di_devlink_handle *hdp, uint32_t idx) 27637c478bd9Sstevel@tonic-gate { 27647c478bd9Sstevel@tonic-gate return (map_seg(hdp, idx, PROT_READ, DB_NODE)); 27657c478bd9Sstevel@tonic-gate } 27667c478bd9Sstevel@tonic-gate 27677c478bd9Sstevel@tonic-gate static struct db_node * 27687c478bd9Sstevel@tonic-gate set_node(struct di_devlink_handle *hdp, uint32_t idx) 27697c478bd9Sstevel@tonic-gate { 27707c478bd9Sstevel@tonic-gate return (map_seg(hdp, idx, PROT_READ | PROT_WRITE, DB_NODE)); 27717c478bd9Sstevel@tonic-gate } 27727c478bd9Sstevel@tonic-gate 27737c478bd9Sstevel@tonic-gate static struct db_minor * 27747c478bd9Sstevel@tonic-gate get_minor(struct di_devlink_handle *hdp, uint32_t idx) 27757c478bd9Sstevel@tonic-gate { 27767c478bd9Sstevel@tonic-gate return (map_seg(hdp, idx, PROT_READ, DB_MINOR)); 27777c478bd9Sstevel@tonic-gate } 27787c478bd9Sstevel@tonic-gate 27797c478bd9Sstevel@tonic-gate static struct db_minor * 27807c478bd9Sstevel@tonic-gate set_minor(struct di_devlink_handle *hdp, uint32_t idx) 27817c478bd9Sstevel@tonic-gate { 27827c478bd9Sstevel@tonic-gate return (map_seg(hdp, idx, PROT_READ | PROT_WRITE, DB_MINOR)); 27837c478bd9Sstevel@tonic-gate } 27847c478bd9Sstevel@tonic-gate 27857c478bd9Sstevel@tonic-gate static struct db_link * 27867c478bd9Sstevel@tonic-gate get_link(struct di_devlink_handle *hdp, uint32_t idx) 27877c478bd9Sstevel@tonic-gate { 27887c478bd9Sstevel@tonic-gate return (map_seg(hdp, idx, PROT_READ, DB_LINK)); 27897c478bd9Sstevel@tonic-gate } 27907c478bd9Sstevel@tonic-gate 27917c478bd9Sstevel@tonic-gate static struct db_link * 27927c478bd9Sstevel@tonic-gate set_link(struct di_devlink_handle *hdp, uint32_t idx) 27937c478bd9Sstevel@tonic-gate { 27947c478bd9Sstevel@tonic-gate return (map_seg(hdp, idx, PROT_READ | PROT_WRITE, DB_LINK)); 27957c478bd9Sstevel@tonic-gate } 27967c478bd9Sstevel@tonic-gate 27977c478bd9Sstevel@tonic-gate static char * 27987c478bd9Sstevel@tonic-gate get_string(struct di_devlink_handle *hdp, uint32_t idx) 27997c478bd9Sstevel@tonic-gate { 28007c478bd9Sstevel@tonic-gate return (map_seg(hdp, idx, PROT_READ, DB_STR)); 28017c478bd9Sstevel@tonic-gate } 28027c478bd9Sstevel@tonic-gate 28037c478bd9Sstevel@tonic-gate static char * 28047c478bd9Sstevel@tonic-gate set_string(struct di_devlink_handle *hdp, uint32_t idx) 28057c478bd9Sstevel@tonic-gate { 28067c478bd9Sstevel@tonic-gate return (map_seg(hdp, idx, PROT_READ | PROT_WRITE, DB_STR)); 28077c478bd9Sstevel@tonic-gate } 28087c478bd9Sstevel@tonic-gate 28097c478bd9Sstevel@tonic-gate 28107c478bd9Sstevel@tonic-gate /* 28117c478bd9Sstevel@tonic-gate * Returns the element corresponding to idx. If the portion of file involved 28127c478bd9Sstevel@tonic-gate * is not yet mapped, does an mmap() as well. Existing mappings are not changed. 28137c478bd9Sstevel@tonic-gate */ 28147c478bd9Sstevel@tonic-gate static void * 28157c478bd9Sstevel@tonic-gate map_seg( 28167c478bd9Sstevel@tonic-gate struct di_devlink_handle *hdp, 28177c478bd9Sstevel@tonic-gate uint32_t idx, 28187c478bd9Sstevel@tonic-gate int prot, 28197c478bd9Sstevel@tonic-gate db_seg_t seg) 28207c478bd9Sstevel@tonic-gate { 28217c478bd9Sstevel@tonic-gate int s; 28227c478bd9Sstevel@tonic-gate off_t off; 28237c478bd9Sstevel@tonic-gate size_t slen; 28247c478bd9Sstevel@tonic-gate caddr_t addr; 28257c478bd9Sstevel@tonic-gate 28267c478bd9Sstevel@tonic-gate if (idx == DB_NIL) { 28277c478bd9Sstevel@tonic-gate return (NULL); 28287c478bd9Sstevel@tonic-gate } 28297c478bd9Sstevel@tonic-gate 28307c478bd9Sstevel@tonic-gate if (!VALID_INDEX(hdp, seg, idx)) { 28317c478bd9Sstevel@tonic-gate (void) dprintf(DBG_ERR, "map_seg: seg(%d): invalid idx(%u)\n", 28327c478bd9Sstevel@tonic-gate seg, idx); 28337c478bd9Sstevel@tonic-gate return (NULL); 28347c478bd9Sstevel@tonic-gate } 28357c478bd9Sstevel@tonic-gate 28367c478bd9Sstevel@tonic-gate /* 28377c478bd9Sstevel@tonic-gate * If the seg is already mapped in, use it if the access type is 28387c478bd9Sstevel@tonic-gate * valid. 28397c478bd9Sstevel@tonic-gate */ 28407c478bd9Sstevel@tonic-gate if (DB_SEG(hdp, seg) != NULL) { 28417c478bd9Sstevel@tonic-gate if (DB_SEG_PROT(hdp, seg) != prot) { 28427c478bd9Sstevel@tonic-gate (void) dprintf(DBG_ERR, "map_seg: illegal access: " 28437c478bd9Sstevel@tonic-gate "seg[%d]: idx=%u, seg_prot=%d, access=%d\n", 28447c478bd9Sstevel@tonic-gate seg, idx, DB_SEG_PROT(hdp, seg), prot); 28457c478bd9Sstevel@tonic-gate return (NULL); 28467c478bd9Sstevel@tonic-gate } 28477c478bd9Sstevel@tonic-gate return (DB_SEG(hdp, seg) + idx * elem_sizes[seg]); 28487c478bd9Sstevel@tonic-gate } 28497c478bd9Sstevel@tonic-gate 28507c478bd9Sstevel@tonic-gate /* 28517c478bd9Sstevel@tonic-gate * Segment is not mapped. Mmap() the segment. 28527c478bd9Sstevel@tonic-gate */ 28537c478bd9Sstevel@tonic-gate off = seg_size(hdp, DB_HEADER); 28547c478bd9Sstevel@tonic-gate for (s = 0; s < seg; s++) { 28557c478bd9Sstevel@tonic-gate off += seg_size(hdp, s); 28567c478bd9Sstevel@tonic-gate } 28577c478bd9Sstevel@tonic-gate slen = seg_size(hdp, seg); 28587c478bd9Sstevel@tonic-gate 28597c478bd9Sstevel@tonic-gate addr = mmap(0, slen, prot, MAP_SHARED, DB(hdp)->db_fd, off); 28607c478bd9Sstevel@tonic-gate if (addr == MAP_FAILED) { 28617c478bd9Sstevel@tonic-gate (void) dprintf(DBG_ERR, "map_seg: seg[%d]: mmap failed: %s\n", 28627c478bd9Sstevel@tonic-gate seg, strerror(errno)); 28637c478bd9Sstevel@tonic-gate (void) dprintf(DBG_ERR, "map_seg: args: len=%lu, prot=%d," 28647c478bd9Sstevel@tonic-gate " fd=%d, off=%ld\n", (ulong_t)slen, prot, DB(hdp)->db_fd, 28657c478bd9Sstevel@tonic-gate off); 28667c478bd9Sstevel@tonic-gate return (NULL); 28677c478bd9Sstevel@tonic-gate } 28687c478bd9Sstevel@tonic-gate 28697c478bd9Sstevel@tonic-gate DB_SEG(hdp, seg) = addr; 28707c478bd9Sstevel@tonic-gate DB_SEG_PROT(hdp, seg) = prot; 28717c478bd9Sstevel@tonic-gate 28727c478bd9Sstevel@tonic-gate (void) dprintf(DBG_STEP, "map_seg: seg[%d]: len=%lu, prot=%d, fd=%d, " 28737c478bd9Sstevel@tonic-gate "off=%ld, seg_base=%p\n", seg, (ulong_t)slen, prot, DB(hdp)->db_fd, 28747c478bd9Sstevel@tonic-gate off, (void *)addr); 28757c478bd9Sstevel@tonic-gate 28767c478bd9Sstevel@tonic-gate return (DB_SEG(hdp, seg) + idx * elem_sizes[seg]); 28777c478bd9Sstevel@tonic-gate } 28787c478bd9Sstevel@tonic-gate 28797c478bd9Sstevel@tonic-gate /* 28807c478bd9Sstevel@tonic-gate * Computes the size of a segment rounded up to the nearest page boundary. 28817c478bd9Sstevel@tonic-gate */ 28827c478bd9Sstevel@tonic-gate static size_t 28837c478bd9Sstevel@tonic-gate seg_size(struct di_devlink_handle *hdp, int seg) 28847c478bd9Sstevel@tonic-gate { 28857c478bd9Sstevel@tonic-gate size_t sz; 28867c478bd9Sstevel@tonic-gate 28877c478bd9Sstevel@tonic-gate assert(DB_HDR(hdp)->page_sz); 28887c478bd9Sstevel@tonic-gate 28897c478bd9Sstevel@tonic-gate if (seg == DB_HEADER) { 28907c478bd9Sstevel@tonic-gate sz = HDR_LEN; 28917c478bd9Sstevel@tonic-gate } else { 28927c478bd9Sstevel@tonic-gate assert(DB_NUM(hdp, seg) >= 1); 28937c478bd9Sstevel@tonic-gate sz = DB_NUM(hdp, seg) * elem_sizes[seg]; 28947c478bd9Sstevel@tonic-gate } 28957c478bd9Sstevel@tonic-gate 28967c478bd9Sstevel@tonic-gate sz = (sz / DB_HDR(hdp)->page_sz) + 1; 28977c478bd9Sstevel@tonic-gate 28987c478bd9Sstevel@tonic-gate sz *= DB_HDR(hdp)->page_sz; 28997c478bd9Sstevel@tonic-gate 29007c478bd9Sstevel@tonic-gate return (sz); 29017c478bd9Sstevel@tonic-gate } 29027c478bd9Sstevel@tonic-gate 29037c478bd9Sstevel@tonic-gate static size_t 29047c478bd9Sstevel@tonic-gate size_db(struct di_devlink_handle *hdp, long page_sz, uint32_t *count) 29057c478bd9Sstevel@tonic-gate { 29067c478bd9Sstevel@tonic-gate int i; 29077c478bd9Sstevel@tonic-gate size_t sz; 29087c478bd9Sstevel@tonic-gate cache_link_t *clp; 29097c478bd9Sstevel@tonic-gate 29107c478bd9Sstevel@tonic-gate assert(page_sz > 0); 29117c478bd9Sstevel@tonic-gate 29127c478bd9Sstevel@tonic-gate /* Take "NIL" element into account */ 29137c478bd9Sstevel@tonic-gate for (i = 0; i < DB_TYPES; i++) { 29147c478bd9Sstevel@tonic-gate count[i] = 1; 29157c478bd9Sstevel@tonic-gate } 29167c478bd9Sstevel@tonic-gate 29177c478bd9Sstevel@tonic-gate count_node(CACHE(hdp)->root, count); 29187c478bd9Sstevel@tonic-gate 29197c478bd9Sstevel@tonic-gate for (clp = CACHE(hdp)->dngl; clp != NULL; clp = clp->sib) { 29207c478bd9Sstevel@tonic-gate count_link(clp, count); 29217c478bd9Sstevel@tonic-gate } 29227c478bd9Sstevel@tonic-gate 29237c478bd9Sstevel@tonic-gate sz = ((HDR_LEN / page_sz) + 1) * page_sz; 29247c478bd9Sstevel@tonic-gate for (i = 0; i < DB_TYPES; i++) { 29257c478bd9Sstevel@tonic-gate assert(count[i] >= 1); 29267c478bd9Sstevel@tonic-gate sz += (((count[i] * elem_sizes[i]) / page_sz) + 1) * page_sz; 29277c478bd9Sstevel@tonic-gate (void) dprintf(DBG_INFO, "N[%u]=%u\n", i, count[i]); 29287c478bd9Sstevel@tonic-gate } 29297c478bd9Sstevel@tonic-gate (void) dprintf(DBG_INFO, "DB size=%lu\n", (ulong_t)sz); 29307c478bd9Sstevel@tonic-gate 29317c478bd9Sstevel@tonic-gate return (sz); 29327c478bd9Sstevel@tonic-gate } 29337c478bd9Sstevel@tonic-gate 29347c478bd9Sstevel@tonic-gate 29357c478bd9Sstevel@tonic-gate static void 29367c478bd9Sstevel@tonic-gate count_node(cache_node_t *cnp, uint32_t *count) 29377c478bd9Sstevel@tonic-gate { 29387c478bd9Sstevel@tonic-gate cache_minor_t *cmnp; 29397c478bd9Sstevel@tonic-gate 29407c478bd9Sstevel@tonic-gate if (cnp == NULL) 29417c478bd9Sstevel@tonic-gate return; 29427c478bd9Sstevel@tonic-gate 29437c478bd9Sstevel@tonic-gate count[DB_NODE]++; 29447c478bd9Sstevel@tonic-gate count_string(cnp->path, count); 29457c478bd9Sstevel@tonic-gate 29467c478bd9Sstevel@tonic-gate for (cmnp = cnp->minor; cmnp != NULL; cmnp = cmnp->sib) { 29477c478bd9Sstevel@tonic-gate count_minor(cmnp, count); 29487c478bd9Sstevel@tonic-gate } 29497c478bd9Sstevel@tonic-gate 29507c478bd9Sstevel@tonic-gate for (cnp = cnp->child; cnp != NULL; cnp = cnp->sib) { 29517c478bd9Sstevel@tonic-gate count_node(cnp, count); 29527c478bd9Sstevel@tonic-gate } 29537c478bd9Sstevel@tonic-gate 29547c478bd9Sstevel@tonic-gate } 29557c478bd9Sstevel@tonic-gate 29567c478bd9Sstevel@tonic-gate static void 29577c478bd9Sstevel@tonic-gate count_minor(cache_minor_t *cmnp, uint32_t *count) 29587c478bd9Sstevel@tonic-gate { 29597c478bd9Sstevel@tonic-gate cache_link_t *clp; 29607c478bd9Sstevel@tonic-gate 29617c478bd9Sstevel@tonic-gate if (cmnp == NULL) 29627c478bd9Sstevel@tonic-gate return; 29637c478bd9Sstevel@tonic-gate 29647c478bd9Sstevel@tonic-gate count[DB_MINOR]++; 29657c478bd9Sstevel@tonic-gate count_string(cmnp->name, count); 29667c478bd9Sstevel@tonic-gate count_string(cmnp->nodetype, count); 29677c478bd9Sstevel@tonic-gate 29687c478bd9Sstevel@tonic-gate for (clp = cmnp->link; clp != NULL; clp = clp->sib) { 29697c478bd9Sstevel@tonic-gate count_link(clp, count); 29707c478bd9Sstevel@tonic-gate } 29717c478bd9Sstevel@tonic-gate } 29727c478bd9Sstevel@tonic-gate 29737c478bd9Sstevel@tonic-gate static void 29747c478bd9Sstevel@tonic-gate count_link(cache_link_t *clp, uint32_t *count) 29757c478bd9Sstevel@tonic-gate { 29767c478bd9Sstevel@tonic-gate if (clp == NULL) 29777c478bd9Sstevel@tonic-gate return; 29787c478bd9Sstevel@tonic-gate 29797c478bd9Sstevel@tonic-gate count[DB_LINK]++; 29807c478bd9Sstevel@tonic-gate count_string(clp->path, count); 29817c478bd9Sstevel@tonic-gate count_string(clp->content, count); 29827c478bd9Sstevel@tonic-gate } 29837c478bd9Sstevel@tonic-gate 29847c478bd9Sstevel@tonic-gate 29857c478bd9Sstevel@tonic-gate static void 29867c478bd9Sstevel@tonic-gate count_string(const char *str, uint32_t *count) 29877c478bd9Sstevel@tonic-gate { 29887c478bd9Sstevel@tonic-gate if (str == NULL) { 29897c478bd9Sstevel@tonic-gate (void) dprintf(DBG_ERR, "count_string: NULL argument\n"); 29907c478bd9Sstevel@tonic-gate return; 29917c478bd9Sstevel@tonic-gate } 29927c478bd9Sstevel@tonic-gate 29937c478bd9Sstevel@tonic-gate count[DB_STR] += strlen(str) + 1; 29947c478bd9Sstevel@tonic-gate } 29957c478bd9Sstevel@tonic-gate 29967c478bd9Sstevel@tonic-gate static uint_t 29977c478bd9Sstevel@tonic-gate hashfn(struct di_devlink_handle *hdp, const char *str) 29987c478bd9Sstevel@tonic-gate { 29997c478bd9Sstevel@tonic-gate const char *cp; 30007c478bd9Sstevel@tonic-gate ulong_t hval = 0; 30017c478bd9Sstevel@tonic-gate 30027c478bd9Sstevel@tonic-gate if (str == NULL) { 30037c478bd9Sstevel@tonic-gate return (0); 30047c478bd9Sstevel@tonic-gate } 30057c478bd9Sstevel@tonic-gate 30067c478bd9Sstevel@tonic-gate assert(CACHE(hdp)->hash_sz >= MIN_HASH_SIZE); 30077c478bd9Sstevel@tonic-gate 30087c478bd9Sstevel@tonic-gate for (cp = str; *cp != '\0'; cp++) { 30097c478bd9Sstevel@tonic-gate hval += *cp; 30107c478bd9Sstevel@tonic-gate } 30117c478bd9Sstevel@tonic-gate 30127c478bd9Sstevel@tonic-gate return (hval % CACHE(hdp)->hash_sz); 30137c478bd9Sstevel@tonic-gate } 30147c478bd9Sstevel@tonic-gate 3015*ff2aee48Scth /* 3016*ff2aee48Scth * enter_db_lock() 3017*ff2aee48Scth * 3018*ff2aee48Scth * If the handle is IS_RDWR then we lock as writer to "update" database, 3019*ff2aee48Scth * if IS_RDONLY then we lock as reader to "snapshot" database. The 3020*ff2aee48Scth * implementation uses advisory file locking. 3021*ff2aee48Scth * 3022*ff2aee48Scth * This function returns: 3023*ff2aee48Scth * == 1 success and grabbed the lock file, we can open the DB. 3024*ff2aee48Scth * == 0 success but did not lock the lock file, reader must walk 3025*ff2aee48Scth * the /dev directory. 3026*ff2aee48Scth * == -1 failure. 3027*ff2aee48Scth */ 30287c478bd9Sstevel@tonic-gate static int 3029*ff2aee48Scth enter_db_lock(struct di_devlink_handle *hdp, const char *root_dir) 30307c478bd9Sstevel@tonic-gate { 3031*ff2aee48Scth int fd; 3032*ff2aee48Scth struct flock lock; 3033*ff2aee48Scth char lockfile[PATH_MAX]; 3034*ff2aee48Scth int rv; 3035*ff2aee48Scth int writer = HDL_RDWR(hdp); 3036*ff2aee48Scth int did_sync = 0; 3037*ff2aee48Scth int eintrs; 30387c478bd9Sstevel@tonic-gate 30397c478bd9Sstevel@tonic-gate assert(hdp->lock_fd < 0); 30407c478bd9Sstevel@tonic-gate 30417c478bd9Sstevel@tonic-gate get_db_path(hdp, DB_LOCK, lockfile, sizeof (lockfile)); 30427c478bd9Sstevel@tonic-gate 3043*ff2aee48Scth dprintf(DBG_LCK, "enter_db_lock: %s BEGIN\n", 3044*ff2aee48Scth writer ? "update" : "snapshot"); 3045*ff2aee48Scth 3046*ff2aee48Scth /* Record locks are per-process. Protect against multiple threads. */ 30477c478bd9Sstevel@tonic-gate (void) mutex_lock(&update_mutex); 30487c478bd9Sstevel@tonic-gate 3049*ff2aee48Scth again: if ((fd = open(lockfile, 3050*ff2aee48Scth (writer ? (O_RDWR|O_CREAT) : O_RDONLY), DB_LOCK_PERMS)) < 0) { 3051*ff2aee48Scth /* 3052*ff2aee48Scth * Typically the lock file and the database go hand in hand. 3053*ff2aee48Scth * If we find that the lock file does not exist (for some 3054*ff2aee48Scth * unknown reason) and we are the reader then we return 3055*ff2aee48Scth * success (after triggering devfsadm to create the file and 3056*ff2aee48Scth * a retry) so that we can still provide service via slow 3057*ff2aee48Scth * /dev walk. If we get a failure as a writer we want the 3058*ff2aee48Scth * error to manifests itself. 3059*ff2aee48Scth */ 3060*ff2aee48Scth if ((errno == ENOENT) && !writer) { 3061*ff2aee48Scth /* If reader, signal once to get files created */ 3062*ff2aee48Scth if (did_sync == 0) { 3063*ff2aee48Scth did_sync = 1; 3064*ff2aee48Scth dprintf(DBG_LCK, "enter_db_lock: %s OSYNC\n", 3065*ff2aee48Scth writer ? "update" : "snapshot"); 3066*ff2aee48Scth 3067*ff2aee48Scth /* signal to get files created */ 3068*ff2aee48Scth (void) devlink_create(root_dir, NULL, 3069*ff2aee48Scth DCA_DEVLINK_SYNC); 3070*ff2aee48Scth goto again; 3071*ff2aee48Scth } 3072*ff2aee48Scth dprintf(DBG_LCK, "enter_db_lock: %s OPENFAILD %s: " 3073*ff2aee48Scth "WALK\n", writer ? "update" : "snapshot", 3074*ff2aee48Scth strerror(errno)); 3075*ff2aee48Scth (void) mutex_unlock(&update_mutex); 3076*ff2aee48Scth return (0); /* success, but not locked */ 3077*ff2aee48Scth } else { 3078*ff2aee48Scth dprintf(DBG_LCK, "enter_db_lock: %s OPENFAILD %s\n", 3079*ff2aee48Scth writer ? "update" : "snapshot", strerror(errno)); 3080*ff2aee48Scth (void) mutex_unlock(&update_mutex); 3081*ff2aee48Scth return (-1); /* failed */ 3082*ff2aee48Scth } 30837c478bd9Sstevel@tonic-gate } 30847c478bd9Sstevel@tonic-gate 3085*ff2aee48Scth lock.l_type = writer ? F_WRLCK : F_RDLCK; 30867c478bd9Sstevel@tonic-gate lock.l_whence = SEEK_SET; 30877c478bd9Sstevel@tonic-gate lock.l_start = 0; 30887c478bd9Sstevel@tonic-gate lock.l_len = 0; 30897c478bd9Sstevel@tonic-gate 3090*ff2aee48Scth /* Enter the lock. */ 3091*ff2aee48Scth for (eintrs = 0; eintrs < MAX_LOCK_RETRY; eintrs++) { 3092*ff2aee48Scth rv = fcntl(fd, F_SETLKW, &lock); 3093*ff2aee48Scth if ((rv != -1) || (errno != EINTR)) 30947c478bd9Sstevel@tonic-gate break; 30957c478bd9Sstevel@tonic-gate } 30967c478bd9Sstevel@tonic-gate 3097*ff2aee48Scth if (rv != -1) { 30987c478bd9Sstevel@tonic-gate hdp->lock_fd = fd; 3099*ff2aee48Scth dprintf(DBG_LCK, "enter_db_lock: %s LOCKED\n", 3100*ff2aee48Scth writer ? "update" : "snapshot"); 3101*ff2aee48Scth return (1); /* success, locked */ 31027c478bd9Sstevel@tonic-gate } 31037c478bd9Sstevel@tonic-gate 3104*ff2aee48Scth (void) close(fd); 3105*ff2aee48Scth dprintf(DBG_ERR, "enter_db_lock: %s FAILED: %s: WALK\n", 3106*ff2aee48Scth writer ? "update" : "snapshot", strerror(errno)); 31077c478bd9Sstevel@tonic-gate (void) mutex_unlock(&update_mutex); 31087c478bd9Sstevel@tonic-gate return (-1); 31097c478bd9Sstevel@tonic-gate } 31107c478bd9Sstevel@tonic-gate 31117c478bd9Sstevel@tonic-gate /* 31127c478bd9Sstevel@tonic-gate * Close and re-open lock file every time so that it is recreated if deleted. 31137c478bd9Sstevel@tonic-gate */ 31147c478bd9Sstevel@tonic-gate static void 3115*ff2aee48Scth exit_db_lock(struct di_devlink_handle *hdp) 31167c478bd9Sstevel@tonic-gate { 3117*ff2aee48Scth struct flock unlock; 3118*ff2aee48Scth int writer = HDL_RDWR(hdp); 31197c478bd9Sstevel@tonic-gate 31207c478bd9Sstevel@tonic-gate if (hdp->lock_fd < 0) { 31217c478bd9Sstevel@tonic-gate return; 31227c478bd9Sstevel@tonic-gate } 31237c478bd9Sstevel@tonic-gate 31247c478bd9Sstevel@tonic-gate unlock.l_type = F_UNLCK; 31257c478bd9Sstevel@tonic-gate unlock.l_whence = SEEK_SET; 31267c478bd9Sstevel@tonic-gate unlock.l_start = 0; 31277c478bd9Sstevel@tonic-gate unlock.l_len = 0; 31287c478bd9Sstevel@tonic-gate 3129*ff2aee48Scth dprintf(DBG_LCK, "exit_db_lock : %s UNLOCKED\n", 3130*ff2aee48Scth writer ? "update" : "snapshot"); 31317c478bd9Sstevel@tonic-gate if (fcntl(hdp->lock_fd, F_SETLK, &unlock) == -1) { 3132*ff2aee48Scth dprintf(DBG_ERR, "exit_db_lock : %s failed: %s\n", 3133*ff2aee48Scth writer ? "update" : "snapshot", strerror(errno)); 31347c478bd9Sstevel@tonic-gate } 31357c478bd9Sstevel@tonic-gate 31367c478bd9Sstevel@tonic-gate (void) close(hdp->lock_fd); 31377c478bd9Sstevel@tonic-gate 31387c478bd9Sstevel@tonic-gate hdp->lock_fd = -1; 31397c478bd9Sstevel@tonic-gate 31407c478bd9Sstevel@tonic-gate (void) mutex_unlock(&update_mutex); 31417c478bd9Sstevel@tonic-gate } 31427c478bd9Sstevel@tonic-gate 31437c478bd9Sstevel@tonic-gate /* 31447c478bd9Sstevel@tonic-gate * returns 1 if contents is a minor node in /devices. 31457c478bd9Sstevel@tonic-gate * If mn_root is not NULL, mn_root is set to: 31467c478bd9Sstevel@tonic-gate * if contents is a /dev node, mn_root = contents 3147facf4a8dSllai * OR 31487c478bd9Sstevel@tonic-gate * if contents is a /devices node, mn_root set to the '/' 31497c478bd9Sstevel@tonic-gate * following /devices. 31507c478bd9Sstevel@tonic-gate */ 31517c478bd9Sstevel@tonic-gate int 31527c478bd9Sstevel@tonic-gate is_minor_node(const char *contents, const char **mn_root) 31537c478bd9Sstevel@tonic-gate { 31547c478bd9Sstevel@tonic-gate char *ptr, *prefix; 31557c478bd9Sstevel@tonic-gate 31567c478bd9Sstevel@tonic-gate prefix = "../devices/"; 31577c478bd9Sstevel@tonic-gate 31587c478bd9Sstevel@tonic-gate if ((ptr = strstr(contents, prefix)) != NULL) { 31597c478bd9Sstevel@tonic-gate 31607c478bd9Sstevel@tonic-gate /* mn_root should point to the / following /devices */ 31617c478bd9Sstevel@tonic-gate if (mn_root != NULL) { 31627c478bd9Sstevel@tonic-gate *mn_root = ptr += strlen(prefix) - 1; 31637c478bd9Sstevel@tonic-gate } 31647c478bd9Sstevel@tonic-gate return (1); 31657c478bd9Sstevel@tonic-gate } 31667c478bd9Sstevel@tonic-gate 31677c478bd9Sstevel@tonic-gate prefix = "/devices/"; 31687c478bd9Sstevel@tonic-gate 31697c478bd9Sstevel@tonic-gate if (strncmp(contents, prefix, strlen(prefix)) == 0) { 31707c478bd9Sstevel@tonic-gate 31717c478bd9Sstevel@tonic-gate /* mn_root should point to the / following /devices/ */ 31727c478bd9Sstevel@tonic-gate if (mn_root != NULL) { 31737c478bd9Sstevel@tonic-gate *mn_root = contents + strlen(prefix) - 1; 31747c478bd9Sstevel@tonic-gate } 31757c478bd9Sstevel@tonic-gate return (1); 31767c478bd9Sstevel@tonic-gate } 31777c478bd9Sstevel@tonic-gate 31787c478bd9Sstevel@tonic-gate if (mn_root != NULL) { 31797c478bd9Sstevel@tonic-gate *mn_root = contents; 31807c478bd9Sstevel@tonic-gate } 31817c478bd9Sstevel@tonic-gate return (0); 31827c478bd9Sstevel@tonic-gate } 31837c478bd9Sstevel@tonic-gate 31847c478bd9Sstevel@tonic-gate static int 31857c478bd9Sstevel@tonic-gate s_readlink(const char *link, char *buf, size_t blen) 31867c478bd9Sstevel@tonic-gate { 31877c478bd9Sstevel@tonic-gate int rv; 31887c478bd9Sstevel@tonic-gate 31897c478bd9Sstevel@tonic-gate if ((rv = readlink(link, buf, blen)) == -1) 31907c478bd9Sstevel@tonic-gate goto bad; 31917c478bd9Sstevel@tonic-gate 31927c478bd9Sstevel@tonic-gate if (rv >= blen && buf[blen - 1] != '\0') { 31937c478bd9Sstevel@tonic-gate errno = ENAMETOOLONG; 31947c478bd9Sstevel@tonic-gate goto bad; 31957c478bd9Sstevel@tonic-gate } else if (rv < blen) { 31967c478bd9Sstevel@tonic-gate buf[rv] = '\0'; 31977c478bd9Sstevel@tonic-gate } 31987c478bd9Sstevel@tonic-gate 31997c478bd9Sstevel@tonic-gate return (0); 32007c478bd9Sstevel@tonic-gate bad: 32017c478bd9Sstevel@tonic-gate dprintf(DBG_ERR, "s_readlink: %s: failed: %s\n", 32027c478bd9Sstevel@tonic-gate link, strerror(errno)); 32037c478bd9Sstevel@tonic-gate return (-1); 32047c478bd9Sstevel@tonic-gate } 32057c478bd9Sstevel@tonic-gate 32067c478bd9Sstevel@tonic-gate /* 32077c478bd9Sstevel@tonic-gate * Synchronous link creation interface routines 32087c478bd9Sstevel@tonic-gate * The scope of the operation is determined by the "name" arg. 32097c478bd9Sstevel@tonic-gate * "name" can be NULL, a driver name or a devfs pathname (without /devices) 32107c478bd9Sstevel@tonic-gate * 32117c478bd9Sstevel@tonic-gate * "name" creates 32127c478bd9Sstevel@tonic-gate * ====== ======= 32137c478bd9Sstevel@tonic-gate * 32147c478bd9Sstevel@tonic-gate * NULL => All devlinks in system 32157c478bd9Sstevel@tonic-gate * <driver> => devlinks for named driver 32167c478bd9Sstevel@tonic-gate * /pci@1 => devlinks for subtree rooted at pci@1 32177c478bd9Sstevel@tonic-gate * /pseudo/foo@0:X => devlinks for minor X 32187c478bd9Sstevel@tonic-gate * 32197c478bd9Sstevel@tonic-gate * devlink_create() returns 0 on success or an errno value on failure 32207c478bd9Sstevel@tonic-gate */ 32217c478bd9Sstevel@tonic-gate 32227c478bd9Sstevel@tonic-gate #define MAX_DAEMON_ATTEMPTS 2 32237c478bd9Sstevel@tonic-gate 32247c478bd9Sstevel@tonic-gate static int 3225*ff2aee48Scth devlink_create(const char *root, const char *name, int dca_devlink_flag) 32267c478bd9Sstevel@tonic-gate { 32277c478bd9Sstevel@tonic-gate int i; 32287c478bd9Sstevel@tonic-gate struct dca_off dca; 32297c478bd9Sstevel@tonic-gate 32307c478bd9Sstevel@tonic-gate assert(root); 32317c478bd9Sstevel@tonic-gate 32327c478bd9Sstevel@tonic-gate /* 32337c478bd9Sstevel@tonic-gate * Convert name into arg for door_call 32347c478bd9Sstevel@tonic-gate */ 3235*ff2aee48Scth if (dca_init(name, &dca, dca_devlink_flag) != 0) 32367c478bd9Sstevel@tonic-gate return (EINVAL); 32377c478bd9Sstevel@tonic-gate 32387c478bd9Sstevel@tonic-gate /* 32397c478bd9Sstevel@tonic-gate * Attempt to use the daemon first 32407c478bd9Sstevel@tonic-gate */ 32417c478bd9Sstevel@tonic-gate i = 0; 32427c478bd9Sstevel@tonic-gate do { 32437c478bd9Sstevel@tonic-gate daemon_call(root, &dca); 32447c478bd9Sstevel@tonic-gate 32457c478bd9Sstevel@tonic-gate dprintf(DBG_INFO, "daemon_call() retval=%d\n", dca.dca_error); 32467c478bd9Sstevel@tonic-gate 32477c478bd9Sstevel@tonic-gate /* 32487c478bd9Sstevel@tonic-gate * Retry only if door server isn't running 32497c478bd9Sstevel@tonic-gate */ 32507c478bd9Sstevel@tonic-gate if (dca.dca_error != ENOENT && dca.dca_error != EBADF) { 32517c478bd9Sstevel@tonic-gate return (dca.dca_error); 32527c478bd9Sstevel@tonic-gate } 32537c478bd9Sstevel@tonic-gate 32547c478bd9Sstevel@tonic-gate dca.dca_error = 0; 32557c478bd9Sstevel@tonic-gate 32567c478bd9Sstevel@tonic-gate /* 32577c478bd9Sstevel@tonic-gate * To improve performance defer this check until the first 32587c478bd9Sstevel@tonic-gate * failure. Safe to defer as door server checks perms. 32597c478bd9Sstevel@tonic-gate */ 32607c478bd9Sstevel@tonic-gate if (geteuid() != 0) 32617c478bd9Sstevel@tonic-gate return (EPERM); 32627c478bd9Sstevel@tonic-gate /* 32637c478bd9Sstevel@tonic-gate * Daemon may not be running. Try to start it. 32647c478bd9Sstevel@tonic-gate */ 32657c478bd9Sstevel@tonic-gate } while ((++i < MAX_DAEMON_ATTEMPTS) && start_daemon(root) == 0); 32667c478bd9Sstevel@tonic-gate 32677c478bd9Sstevel@tonic-gate dprintf(DBG_INFO, "devlink_create: can't start daemon\n"); 32687c478bd9Sstevel@tonic-gate 32697c478bd9Sstevel@tonic-gate assert(dca.dca_error == 0); 32707c478bd9Sstevel@tonic-gate 32717c478bd9Sstevel@tonic-gate /* 32727c478bd9Sstevel@tonic-gate * If the daemon cannot be started execute the devfsadm command. 32737c478bd9Sstevel@tonic-gate */ 32747c478bd9Sstevel@tonic-gate exec_cmd(root, &dca); 32757c478bd9Sstevel@tonic-gate 32767c478bd9Sstevel@tonic-gate return (dca.dca_error); 32777c478bd9Sstevel@tonic-gate } 32787c478bd9Sstevel@tonic-gate 32797c478bd9Sstevel@tonic-gate /* 32807c478bd9Sstevel@tonic-gate * The "name" member of "struct dca" contains data in the following order 32817c478bd9Sstevel@tonic-gate * root'\0'minor'\0'driver'\0' 32827c478bd9Sstevel@tonic-gate * The root component is always present at offset 0 in the "name" field. 32837c478bd9Sstevel@tonic-gate * The driver and minor are optional. If present they have a non-zero 32847c478bd9Sstevel@tonic-gate * offset in the "name" member. 32857c478bd9Sstevel@tonic-gate */ 32867c478bd9Sstevel@tonic-gate static int 3287*ff2aee48Scth dca_init(const char *name, struct dca_off *dcp, int dca_flags) 32887c478bd9Sstevel@tonic-gate { 32897c478bd9Sstevel@tonic-gate char *cp; 32907c478bd9Sstevel@tonic-gate 32917c478bd9Sstevel@tonic-gate dcp->dca_root = 0; 32927c478bd9Sstevel@tonic-gate dcp->dca_minor = 0; 32937c478bd9Sstevel@tonic-gate dcp->dca_driver = 0; 32947c478bd9Sstevel@tonic-gate dcp->dca_error = 0; 3295*ff2aee48Scth dcp->dca_flags = dca_flags; 32967c478bd9Sstevel@tonic-gate dcp->dca_name[0] = '\0'; 32977c478bd9Sstevel@tonic-gate 32987c478bd9Sstevel@tonic-gate name = name ? name : "/"; 32997c478bd9Sstevel@tonic-gate 33007c478bd9Sstevel@tonic-gate /* 33017c478bd9Sstevel@tonic-gate * Check if name is a driver name 33027c478bd9Sstevel@tonic-gate */ 33037c478bd9Sstevel@tonic-gate if (*name != '/') { 33047c478bd9Sstevel@tonic-gate (void) snprintf(dcp->dca_name, sizeof (dcp->dca_name), 33057c478bd9Sstevel@tonic-gate "/ %s", name); 33067c478bd9Sstevel@tonic-gate dcp->dca_root = 0; 33077c478bd9Sstevel@tonic-gate *(dcp->dca_name + 1) = '\0'; 33087c478bd9Sstevel@tonic-gate dcp->dca_driver = 2; 33097c478bd9Sstevel@tonic-gate return (0); 33107c478bd9Sstevel@tonic-gate } 33117c478bd9Sstevel@tonic-gate 33127c478bd9Sstevel@tonic-gate (void) snprintf(dcp->dca_name, sizeof (dcp->dca_name), "%s", name); 33137c478bd9Sstevel@tonic-gate 33147c478bd9Sstevel@tonic-gate /* 33157c478bd9Sstevel@tonic-gate * "/devices" not allowed in devfs pathname 33167c478bd9Sstevel@tonic-gate */ 33177c478bd9Sstevel@tonic-gate if (is_minor_node(name, NULL)) 33187c478bd9Sstevel@tonic-gate return (-1); 33197c478bd9Sstevel@tonic-gate 33207c478bd9Sstevel@tonic-gate dcp->dca_root = 0; 33217c478bd9Sstevel@tonic-gate if (cp = strrchr(dcp->dca_name, ':')) { 33227c478bd9Sstevel@tonic-gate *cp++ = '\0'; 33237c478bd9Sstevel@tonic-gate dcp->dca_minor = cp - dcp->dca_name; 33247c478bd9Sstevel@tonic-gate } 33257c478bd9Sstevel@tonic-gate 33267c478bd9Sstevel@tonic-gate return (0); 33277c478bd9Sstevel@tonic-gate } 33287c478bd9Sstevel@tonic-gate 33297c478bd9Sstevel@tonic-gate 33307c478bd9Sstevel@tonic-gate #define DAEMON_STARTUP_TIME 1 /* 1 second. This may need to be adjusted */ 3331a64c0160Svikram #define DEVNAME_CHECK_FILE "/etc/devname_check_RDONLY" 33327c478bd9Sstevel@tonic-gate 33337c478bd9Sstevel@tonic-gate static void 33347c478bd9Sstevel@tonic-gate daemon_call(const char *root, struct dca_off *dcp) 33357c478bd9Sstevel@tonic-gate { 33367c478bd9Sstevel@tonic-gate door_arg_t arg; 33377c478bd9Sstevel@tonic-gate int fd, door_error; 33387c478bd9Sstevel@tonic-gate sigset_t oset, nset; 33397c478bd9Sstevel@tonic-gate char synch_door[PATH_MAX]; 3340a64c0160Svikram struct stat sb; 3341facf4a8dSllai char *prefix; 3342a64c0160Svikram int rofd; 33437c478bd9Sstevel@tonic-gate 3344facf4a8dSllai /* 3345a64c0160Svikram * If /etc/dev missing and readonly root, assume we are in install. 3346a64c0160Svikram * Don't use statvfs() since it doesn't always report the truth. 3347facf4a8dSllai */ 3348a64c0160Svikram rofd = -1; 3349a64c0160Svikram if (stat("/etc/dev", &sb) == -1 && 3350a64c0160Svikram (rofd = open(DEVNAME_CHECK_FILE, 3351a64c0160Svikram O_WRONLY|O_CREAT|O_TRUNC, 0644)) == -1 && errno == EROFS) 3352a64c0160Svikram prefix = "/tmp"; 3353a64c0160Svikram else { 3354a64c0160Svikram if (rofd != -1) { 3355a64c0160Svikram (void) close(rofd); 3356a64c0160Svikram (void) unlink(DEVNAME_CHECK_FILE); 3357a64c0160Svikram } 3358a64c0160Svikram prefix = (char *)root; 3359a64c0160Svikram } 3360a64c0160Svikram 33617c478bd9Sstevel@tonic-gate (void) snprintf(synch_door, sizeof (synch_door), 3362facf4a8dSllai "%s/etc/dev/%s", prefix, DEVFSADM_SYNCH_DOOR); 33637c478bd9Sstevel@tonic-gate 33647c478bd9Sstevel@tonic-gate if ((fd = open(synch_door, O_RDONLY)) == -1) { 33657c478bd9Sstevel@tonic-gate dcp->dca_error = errno; 33667c478bd9Sstevel@tonic-gate dprintf(DBG_ERR, "open of %s failed: %s\n", 33677c478bd9Sstevel@tonic-gate synch_door, strerror(errno)); 33687c478bd9Sstevel@tonic-gate return; 33697c478bd9Sstevel@tonic-gate } 33707c478bd9Sstevel@tonic-gate 33717c478bd9Sstevel@tonic-gate arg.data_ptr = (char *)dcp; 33727c478bd9Sstevel@tonic-gate arg.data_size = sizeof (*dcp); 33737c478bd9Sstevel@tonic-gate arg.desc_ptr = NULL; 33747c478bd9Sstevel@tonic-gate arg.desc_num = 0; 33757c478bd9Sstevel@tonic-gate arg.rbuf = (char *)dcp; 33767c478bd9Sstevel@tonic-gate arg.rsize = sizeof (*dcp); 33777c478bd9Sstevel@tonic-gate 33787c478bd9Sstevel@tonic-gate /* 33797c478bd9Sstevel@tonic-gate * Block signals to this thread until door call 33807c478bd9Sstevel@tonic-gate * completes. 33817c478bd9Sstevel@tonic-gate */ 33827c478bd9Sstevel@tonic-gate (void) sigfillset(&nset); 33837c478bd9Sstevel@tonic-gate (void) sigemptyset(&oset); 33847c478bd9Sstevel@tonic-gate (void) sigprocmask(SIG_SETMASK, &nset, &oset); 33857c478bd9Sstevel@tonic-gate if (door_call(fd, &arg)) { 33867c478bd9Sstevel@tonic-gate door_error = 1; 33877c478bd9Sstevel@tonic-gate dcp->dca_error = errno; 33887c478bd9Sstevel@tonic-gate } 33897c478bd9Sstevel@tonic-gate (void) sigprocmask(SIG_SETMASK, &oset, NULL); 33907c478bd9Sstevel@tonic-gate 33917c478bd9Sstevel@tonic-gate (void) close(fd); 33927c478bd9Sstevel@tonic-gate 33937c478bd9Sstevel@tonic-gate if (door_error) 33947c478bd9Sstevel@tonic-gate return; 33957c478bd9Sstevel@tonic-gate 33967c478bd9Sstevel@tonic-gate assert(arg.data_ptr); 33977c478bd9Sstevel@tonic-gate 33987c478bd9Sstevel@tonic-gate /*LINTED*/ 33997c478bd9Sstevel@tonic-gate dcp->dca_error = ((struct dca_off *)arg.data_ptr)->dca_error; 34007c478bd9Sstevel@tonic-gate 34017c478bd9Sstevel@tonic-gate /* 34027c478bd9Sstevel@tonic-gate * The doors interface may return data in a different buffer 34037c478bd9Sstevel@tonic-gate * If that happens, deallocate buffer via munmap() 34047c478bd9Sstevel@tonic-gate */ 34057c478bd9Sstevel@tonic-gate if (arg.rbuf != (char *)dcp) 34067c478bd9Sstevel@tonic-gate (void) munmap(arg.rbuf, arg.rsize); 34077c478bd9Sstevel@tonic-gate } 34087c478bd9Sstevel@tonic-gate 34097c478bd9Sstevel@tonic-gate #define DEVFSADM_PATH "/usr/sbin/devfsadm" 34107c478bd9Sstevel@tonic-gate #define DEVFSADM "devfsadm" 34117c478bd9Sstevel@tonic-gate 34127c478bd9Sstevel@tonic-gate #define DEVFSADMD_PATH "/usr/lib/devfsadm/devfsadmd" 34137c478bd9Sstevel@tonic-gate #define DEVFSADM_DAEMON "devfsadmd" 34147c478bd9Sstevel@tonic-gate 34157c478bd9Sstevel@tonic-gate static int 34167c478bd9Sstevel@tonic-gate start_daemon(const char *root) 34177c478bd9Sstevel@tonic-gate { 34187c478bd9Sstevel@tonic-gate int rv, i = 0; 34197c478bd9Sstevel@tonic-gate char *argv[20]; 34207c478bd9Sstevel@tonic-gate 34217c478bd9Sstevel@tonic-gate argv[i++] = DEVFSADM_DAEMON; 34227c478bd9Sstevel@tonic-gate if (strcmp(root, "/")) { 34237c478bd9Sstevel@tonic-gate argv[i++] = "-r"; 34247c478bd9Sstevel@tonic-gate argv[i++] = (char *)root; 34257c478bd9Sstevel@tonic-gate } 34267c478bd9Sstevel@tonic-gate argv[i++] = NULL; 34277c478bd9Sstevel@tonic-gate 34287c478bd9Sstevel@tonic-gate rv = do_exec(DEVFSADMD_PATH, argv); 34297c478bd9Sstevel@tonic-gate 34307c478bd9Sstevel@tonic-gate (void) sleep(DAEMON_STARTUP_TIME); 34317c478bd9Sstevel@tonic-gate 34327c478bd9Sstevel@tonic-gate return (rv); 34337c478bd9Sstevel@tonic-gate } 34347c478bd9Sstevel@tonic-gate 34357c478bd9Sstevel@tonic-gate static void 34367c478bd9Sstevel@tonic-gate exec_cmd(const char *root, struct dca_off *dcp) 34377c478bd9Sstevel@tonic-gate { 34387c478bd9Sstevel@tonic-gate int i; 34397c478bd9Sstevel@tonic-gate char *argv[20]; 34407c478bd9Sstevel@tonic-gate 34417c478bd9Sstevel@tonic-gate i = 0; 34427c478bd9Sstevel@tonic-gate argv[i++] = DEVFSADM; 34437c478bd9Sstevel@tonic-gate 34447c478bd9Sstevel@tonic-gate /* 34457c478bd9Sstevel@tonic-gate * Load drivers only if -i is specified 34467c478bd9Sstevel@tonic-gate */ 34477c478bd9Sstevel@tonic-gate if (dcp->dca_driver) { 34487c478bd9Sstevel@tonic-gate argv[i++] = "-i"; 34497c478bd9Sstevel@tonic-gate argv[i++] = &dcp->dca_name[dcp->dca_driver]; 34507c478bd9Sstevel@tonic-gate } else { 34517c478bd9Sstevel@tonic-gate argv[i++] = "-n"; 34527c478bd9Sstevel@tonic-gate } 34537c478bd9Sstevel@tonic-gate 34547c478bd9Sstevel@tonic-gate if (root != NULL && strcmp(root, "/") != 0) { 34557c478bd9Sstevel@tonic-gate argv[i++] = "-r"; 34567c478bd9Sstevel@tonic-gate argv[i++] = (char *)root; 34577c478bd9Sstevel@tonic-gate } 34587c478bd9Sstevel@tonic-gate 34597c478bd9Sstevel@tonic-gate argv[i] = NULL; 34607c478bd9Sstevel@tonic-gate 34617c478bd9Sstevel@tonic-gate if (do_exec(DEVFSADM_PATH, argv)) 34627c478bd9Sstevel@tonic-gate dcp->dca_error = errno; 34637c478bd9Sstevel@tonic-gate } 34647c478bd9Sstevel@tonic-gate 34657c478bd9Sstevel@tonic-gate static int 34667c478bd9Sstevel@tonic-gate do_exec(const char *path, char *const argv[]) 34677c478bd9Sstevel@tonic-gate { 34687c478bd9Sstevel@tonic-gate int i; 34697c478bd9Sstevel@tonic-gate pid_t cpid; 34707c478bd9Sstevel@tonic-gate 34717c478bd9Sstevel@tonic-gate #ifdef DEBUG 34727c478bd9Sstevel@tonic-gate dprintf(DBG_INFO, "Executing %s\n\tArgument list:", path); 34737c478bd9Sstevel@tonic-gate for (i = 0; argv[i] != NULL; i++) { 34747c478bd9Sstevel@tonic-gate dprintf(DBG_INFO, " %s", argv[i]); 34757c478bd9Sstevel@tonic-gate } 34767c478bd9Sstevel@tonic-gate dprintf(DBG_INFO, "\n"); 34777c478bd9Sstevel@tonic-gate #endif 34787c478bd9Sstevel@tonic-gate 34797c478bd9Sstevel@tonic-gate if ((cpid = fork1()) == -1) { 34807c478bd9Sstevel@tonic-gate dprintf(DBG_ERR, "fork1 failed: %s\n", strerror(errno)); 34817c478bd9Sstevel@tonic-gate return (-1); 34827c478bd9Sstevel@tonic-gate } 34837c478bd9Sstevel@tonic-gate 34847c478bd9Sstevel@tonic-gate if (cpid == 0) { /* child process */ 34857c478bd9Sstevel@tonic-gate int fd; 34867c478bd9Sstevel@tonic-gate 34877c478bd9Sstevel@tonic-gate if ((fd = open("/dev/null", O_RDWR)) >= 0) { 34887c478bd9Sstevel@tonic-gate (void) dup2(fd, fileno(stdout)); 34897c478bd9Sstevel@tonic-gate (void) dup2(fd, fileno(stderr)); 34907c478bd9Sstevel@tonic-gate (void) close(fd); 34917c478bd9Sstevel@tonic-gate 34927c478bd9Sstevel@tonic-gate (void) execv(path, argv); 34937c478bd9Sstevel@tonic-gate } else { 34947c478bd9Sstevel@tonic-gate dprintf(DBG_ERR, "open of /dev/null failed: %s\n", 34957c478bd9Sstevel@tonic-gate strerror(errno)); 34967c478bd9Sstevel@tonic-gate } 34977c478bd9Sstevel@tonic-gate 34987c478bd9Sstevel@tonic-gate _exit(-1); 34997c478bd9Sstevel@tonic-gate } 35007c478bd9Sstevel@tonic-gate 35017c478bd9Sstevel@tonic-gate /* Parent process */ 35027c478bd9Sstevel@tonic-gate if (waitpid(cpid, &i, 0) == cpid) { 35037c478bd9Sstevel@tonic-gate if (WIFEXITED(i)) { 35047c478bd9Sstevel@tonic-gate if (WEXITSTATUS(i) == 0) { 35057c478bd9Sstevel@tonic-gate dprintf(DBG_STEP, 35067c478bd9Sstevel@tonic-gate "do_exec: child exited normally\n"); 35077c478bd9Sstevel@tonic-gate return (0); 35087c478bd9Sstevel@tonic-gate } else 35097c478bd9Sstevel@tonic-gate errno = EINVAL; 35107c478bd9Sstevel@tonic-gate } else { 35117c478bd9Sstevel@tonic-gate /* 35127c478bd9Sstevel@tonic-gate * The child was interrupted by a signal 35137c478bd9Sstevel@tonic-gate */ 35147c478bd9Sstevel@tonic-gate errno = EINTR; 35157c478bd9Sstevel@tonic-gate } 35167c478bd9Sstevel@tonic-gate dprintf(DBG_ERR, "child terminated abnormally: %s\n", 35177c478bd9Sstevel@tonic-gate strerror(errno)); 35187c478bd9Sstevel@tonic-gate } else { 35197c478bd9Sstevel@tonic-gate dprintf(DBG_ERR, "waitpid failed: %s\n", strerror(errno)); 35207c478bd9Sstevel@tonic-gate } 35217c478bd9Sstevel@tonic-gate 35227c478bd9Sstevel@tonic-gate return (-1); 35237c478bd9Sstevel@tonic-gate } 35247c478bd9Sstevel@tonic-gate 35257c478bd9Sstevel@tonic-gate static int 35267c478bd9Sstevel@tonic-gate walk_cache_links(di_devlink_handle_t hdp, cache_link_t *clp, link_desc_t *linkp) 35277c478bd9Sstevel@tonic-gate { 35287c478bd9Sstevel@tonic-gate int i; 35297c478bd9Sstevel@tonic-gate 35307c478bd9Sstevel@tonic-gate assert(HDL_RDWR(hdp) || HDL_RDONLY(hdp)); 35317c478bd9Sstevel@tonic-gate 35327c478bd9Sstevel@tonic-gate dprintf(DBG_INFO, "walk_cache_links: initial link: %s\n", 35337c478bd9Sstevel@tonic-gate clp ? clp->path : "<NULL>"); 35347c478bd9Sstevel@tonic-gate 35357c478bd9Sstevel@tonic-gate /* 35367c478bd9Sstevel@tonic-gate * First search the links under the specified minor. On the 35377c478bd9Sstevel@tonic-gate * 2nd pass, search the dangling list - secondary links may 35387c478bd9Sstevel@tonic-gate * exist on this list since they are not resolved during the 35397c478bd9Sstevel@tonic-gate * /dev walk. 35407c478bd9Sstevel@tonic-gate */ 35417c478bd9Sstevel@tonic-gate for (i = 0; i < 2; i++) { 35427c478bd9Sstevel@tonic-gate for (; clp != NULL; clp = clp->sib) { 35437c478bd9Sstevel@tonic-gate struct di_devlink vlink = {NULL}; 35447c478bd9Sstevel@tonic-gate 35457c478bd9Sstevel@tonic-gate assert(clp->path[0] != '/'); 35467c478bd9Sstevel@tonic-gate 35477c478bd9Sstevel@tonic-gate vlink.rel_path = clp->path; 35487c478bd9Sstevel@tonic-gate vlink.content = clp->content; 35497c478bd9Sstevel@tonic-gate vlink.type = attr2type(clp->attr); 35507c478bd9Sstevel@tonic-gate 35517c478bd9Sstevel@tonic-gate if (visit_link(hdp, linkp, &vlink) 35527c478bd9Sstevel@tonic-gate != DI_WALK_CONTINUE) { 35537c478bd9Sstevel@tonic-gate dprintf(DBG_INFO, "walk_cache_links: " 35547c478bd9Sstevel@tonic-gate "terminating at link: %s\n", clp->path); 35557c478bd9Sstevel@tonic-gate goto out; 35567c478bd9Sstevel@tonic-gate } 35577c478bd9Sstevel@tonic-gate } 35587c478bd9Sstevel@tonic-gate 35597c478bd9Sstevel@tonic-gate clp = CACHE(hdp)->dngl; 35607c478bd9Sstevel@tonic-gate } 35617c478bd9Sstevel@tonic-gate 35627c478bd9Sstevel@tonic-gate out: 35637c478bd9Sstevel@tonic-gate 35647c478bd9Sstevel@tonic-gate /* If i < 2, we terminated the walk prematurely */ 35657c478bd9Sstevel@tonic-gate return (i < 2 ? DI_WALK_TERMINATE : DI_WALK_CONTINUE); 35667c478bd9Sstevel@tonic-gate } 35677c478bd9Sstevel@tonic-gate 35687c478bd9Sstevel@tonic-gate static void 35697c478bd9Sstevel@tonic-gate walk_all_cache(di_devlink_handle_t hdp, link_desc_t *linkp) 35707c478bd9Sstevel@tonic-gate { 35717c478bd9Sstevel@tonic-gate int i; 35727c478bd9Sstevel@tonic-gate cache_link_t *clp; 35737c478bd9Sstevel@tonic-gate 35747c478bd9Sstevel@tonic-gate dprintf(DBG_INFO, "walk_all_cache: entered\n"); 35757c478bd9Sstevel@tonic-gate 35767c478bd9Sstevel@tonic-gate for (i = 0; i < CACHE(hdp)->hash_sz; i++) { 35777c478bd9Sstevel@tonic-gate clp = CACHE_HASH(hdp, i); 35787c478bd9Sstevel@tonic-gate for (; clp; clp = clp->hash) { 35797c478bd9Sstevel@tonic-gate struct di_devlink vlink = {NULL}; 35807c478bd9Sstevel@tonic-gate 35817c478bd9Sstevel@tonic-gate assert(clp->path[0] != '/'); 35827c478bd9Sstevel@tonic-gate 35837c478bd9Sstevel@tonic-gate vlink.rel_path = clp->path; 35847c478bd9Sstevel@tonic-gate vlink.content = clp->content; 35857c478bd9Sstevel@tonic-gate vlink.type = attr2type(clp->attr); 35867c478bd9Sstevel@tonic-gate if (visit_link(hdp, linkp, &vlink) != 35877c478bd9Sstevel@tonic-gate DI_WALK_CONTINUE) { 35887c478bd9Sstevel@tonic-gate dprintf(DBG_INFO, "walk_all_cache: terminating " 35897c478bd9Sstevel@tonic-gate "walk at link: %s\n", clp->path); 35907c478bd9Sstevel@tonic-gate return; 35917c478bd9Sstevel@tonic-gate } 35927c478bd9Sstevel@tonic-gate } 35937c478bd9Sstevel@tonic-gate } 35947c478bd9Sstevel@tonic-gate } 35957c478bd9Sstevel@tonic-gate 35967c478bd9Sstevel@tonic-gate static void 35977c478bd9Sstevel@tonic-gate walk_cache_minor(di_devlink_handle_t hdp, const char *mpath, link_desc_t *linkp) 35987c478bd9Sstevel@tonic-gate { 35997c478bd9Sstevel@tonic-gate cache_minor_t *cmnp; 36007c478bd9Sstevel@tonic-gate 36017c478bd9Sstevel@tonic-gate assert(mpath); 36027c478bd9Sstevel@tonic-gate 36037c478bd9Sstevel@tonic-gate if ((cmnp = lookup_minor(hdp, mpath, NULL, TYPE_CACHE)) != NULL) { 36047c478bd9Sstevel@tonic-gate (void) walk_cache_links(hdp, cmnp->link, linkp); 36057c478bd9Sstevel@tonic-gate } else { 36067c478bd9Sstevel@tonic-gate dprintf(DBG_ERR, "lookup minor failed: %s\n", mpath); 36077c478bd9Sstevel@tonic-gate } 36087c478bd9Sstevel@tonic-gate } 36097c478bd9Sstevel@tonic-gate 36107c478bd9Sstevel@tonic-gate static void 36117c478bd9Sstevel@tonic-gate walk_cache_node(di_devlink_handle_t hdp, const char *path, link_desc_t *linkp) 36127c478bd9Sstevel@tonic-gate { 36137c478bd9Sstevel@tonic-gate cache_minor_t *cmnp; 36147c478bd9Sstevel@tonic-gate cache_node_t *cnp; 36157c478bd9Sstevel@tonic-gate 36167c478bd9Sstevel@tonic-gate assert(path); 36177c478bd9Sstevel@tonic-gate 36187c478bd9Sstevel@tonic-gate if ((cnp = lookup_node(hdp, (char *)path, TYPE_CACHE)) == NULL) { 36197c478bd9Sstevel@tonic-gate dprintf(DBG_ERR, "lookup node failed: %s\n", path); 36207c478bd9Sstevel@tonic-gate return; 36217c478bd9Sstevel@tonic-gate } 36227c478bd9Sstevel@tonic-gate 36237c478bd9Sstevel@tonic-gate for (cmnp = cnp->minor; cmnp != NULL; cmnp = cmnp->sib) { 36247c478bd9Sstevel@tonic-gate if (walk_cache_links(hdp, cmnp->link, linkp) 36257c478bd9Sstevel@tonic-gate == DI_WALK_TERMINATE) 36267c478bd9Sstevel@tonic-gate break; 36277c478bd9Sstevel@tonic-gate } 36287c478bd9Sstevel@tonic-gate } 36297c478bd9Sstevel@tonic-gate 36307c478bd9Sstevel@tonic-gate /* 36317c478bd9Sstevel@tonic-gate * Private function 36327c478bd9Sstevel@tonic-gate * 36337c478bd9Sstevel@tonic-gate * Walk cached links corresponding to the given path. 36347c478bd9Sstevel@tonic-gate * 36357c478bd9Sstevel@tonic-gate * path path to a node or minor node. 36367c478bd9Sstevel@tonic-gate * 36377c478bd9Sstevel@tonic-gate * flags specifies the type of devlinks to be selected. 36387c478bd9Sstevel@tonic-gate * If DI_PRIMARY_LINK is used, only primary links are selected. 36397c478bd9Sstevel@tonic-gate * If DI_SECONDARY_LINK is specified, only secondary links 36407c478bd9Sstevel@tonic-gate * are selected. 36417c478bd9Sstevel@tonic-gate * If neither flag is specified, all devlinks are selected. 36427c478bd9Sstevel@tonic-gate * 36437c478bd9Sstevel@tonic-gate * re An extended regular expression in regex(5) format which 36447c478bd9Sstevel@tonic-gate * selects the /dev links to be returned. The regular 36457c478bd9Sstevel@tonic-gate * expression should use link pathnames relative to 36467c478bd9Sstevel@tonic-gate * /dev. i.e. without the leading "/dev/" prefix. 36477c478bd9Sstevel@tonic-gate * A NULL value matches all devlinks. 36487c478bd9Sstevel@tonic-gate */ 36497c478bd9Sstevel@tonic-gate int 36507c478bd9Sstevel@tonic-gate di_devlink_cache_walk(di_devlink_handle_t hdp, 36517c478bd9Sstevel@tonic-gate const char *re, 36527c478bd9Sstevel@tonic-gate const char *path, 36537c478bd9Sstevel@tonic-gate uint_t flags, 36547c478bd9Sstevel@tonic-gate void *arg, 36557c478bd9Sstevel@tonic-gate int (*devlink_callback)(di_devlink_t, void *)) 36567c478bd9Sstevel@tonic-gate { 36577c478bd9Sstevel@tonic-gate regex_t reg; 36587c478bd9Sstevel@tonic-gate link_desc_t linkd = {NULL}; 36597c478bd9Sstevel@tonic-gate 36607c478bd9Sstevel@tonic-gate if (hdp == NULL || path == NULL || !link_flag(flags) || 36617c478bd9Sstevel@tonic-gate !HDL_RDWR(hdp) || devlink_callback == NULL) { 36627c478bd9Sstevel@tonic-gate errno = EINVAL; 36637c478bd9Sstevel@tonic-gate return (-1); 36647c478bd9Sstevel@tonic-gate } 36657c478bd9Sstevel@tonic-gate 36667c478bd9Sstevel@tonic-gate linkd.flags = flags; 36677c478bd9Sstevel@tonic-gate linkd.arg = arg; 36687c478bd9Sstevel@tonic-gate linkd.fcn = devlink_callback; 36697c478bd9Sstevel@tonic-gate 36707c478bd9Sstevel@tonic-gate if (re) { 36717c478bd9Sstevel@tonic-gate if (regcomp(®, re, REG_EXTENDED) != 0) 36727c478bd9Sstevel@tonic-gate return (-1); 36737c478bd9Sstevel@tonic-gate linkd.regp = ® 36747c478bd9Sstevel@tonic-gate } 36757c478bd9Sstevel@tonic-gate 36767c478bd9Sstevel@tonic-gate if (minor_colon(path) == NULL) { 36777c478bd9Sstevel@tonic-gate walk_cache_node(hdp, path, &linkd); 36787c478bd9Sstevel@tonic-gate } else { 36797c478bd9Sstevel@tonic-gate walk_cache_minor(hdp, path, &linkd); 36807c478bd9Sstevel@tonic-gate } 36817c478bd9Sstevel@tonic-gate 36827c478bd9Sstevel@tonic-gate if (re) 36837c478bd9Sstevel@tonic-gate regfree(®); 36847c478bd9Sstevel@tonic-gate 36857c478bd9Sstevel@tonic-gate return (0); 36867c478bd9Sstevel@tonic-gate } 36877c478bd9Sstevel@tonic-gate 36887c478bd9Sstevel@tonic-gate #define DEBUG_ENV_VAR "_DEVLINK_DEBUG" 36897c478bd9Sstevel@tonic-gate static int _devlink_debug = -1; 36907c478bd9Sstevel@tonic-gate 36917c478bd9Sstevel@tonic-gate /* 36927c478bd9Sstevel@tonic-gate * debug level is initialized to -1. 36937c478bd9Sstevel@tonic-gate * On first call into this routine, debug level is set. 36947c478bd9Sstevel@tonic-gate * If debug level is zero, debugging msgs are disabled. 36957c478bd9Sstevel@tonic-gate */ 36967c478bd9Sstevel@tonic-gate static void 36977c478bd9Sstevel@tonic-gate debug_print(debug_level_t msglevel, const char *fmt, va_list ap) 36987c478bd9Sstevel@tonic-gate { 36997c478bd9Sstevel@tonic-gate char *cp; 37007c478bd9Sstevel@tonic-gate int save; 37017c478bd9Sstevel@tonic-gate 37027c478bd9Sstevel@tonic-gate /* 37037c478bd9Sstevel@tonic-gate * We shouldn't be here if debug is disabled 37047c478bd9Sstevel@tonic-gate */ 37057c478bd9Sstevel@tonic-gate assert(_devlink_debug != 0); 37067c478bd9Sstevel@tonic-gate 37077c478bd9Sstevel@tonic-gate /* 37087c478bd9Sstevel@tonic-gate * Set debug level on first call into this routine 37097c478bd9Sstevel@tonic-gate */ 37107c478bd9Sstevel@tonic-gate if (_devlink_debug < 0) { 37117c478bd9Sstevel@tonic-gate if ((cp = getenv(DEBUG_ENV_VAR)) == NULL) { 37127c478bd9Sstevel@tonic-gate _devlink_debug = 0; 37137c478bd9Sstevel@tonic-gate return; 37147c478bd9Sstevel@tonic-gate } 37157c478bd9Sstevel@tonic-gate 37167c478bd9Sstevel@tonic-gate save = errno; 37177c478bd9Sstevel@tonic-gate errno = 0; 37187c478bd9Sstevel@tonic-gate _devlink_debug = strtol(cp, NULL, 10); 37197c478bd9Sstevel@tonic-gate if (errno != 0 || _devlink_debug < 0) { 37207c478bd9Sstevel@tonic-gate _devlink_debug = 0; 37217c478bd9Sstevel@tonic-gate errno = save; 37227c478bd9Sstevel@tonic-gate return; 37237c478bd9Sstevel@tonic-gate } 37247c478bd9Sstevel@tonic-gate errno = save; 37257c478bd9Sstevel@tonic-gate 37267c478bd9Sstevel@tonic-gate if (!_devlink_debug) 37277c478bd9Sstevel@tonic-gate return; 37287c478bd9Sstevel@tonic-gate } 37297c478bd9Sstevel@tonic-gate 37307c478bd9Sstevel@tonic-gate /* debug msgs are enabled */ 37317c478bd9Sstevel@tonic-gate assert(_devlink_debug > 0); 37327c478bd9Sstevel@tonic-gate 37337c478bd9Sstevel@tonic-gate if (_devlink_debug < msglevel) 37347c478bd9Sstevel@tonic-gate return; 3735*ff2aee48Scth if ((_devlink_debug == DBG_LCK) && (msglevel != _devlink_debug)) 3736*ff2aee48Scth return; 37377c478bd9Sstevel@tonic-gate 37387c478bd9Sstevel@tonic-gate /* Print a distinctive label for error msgs */ 37397c478bd9Sstevel@tonic-gate if (msglevel == DBG_ERR) { 37407c478bd9Sstevel@tonic-gate (void) fprintf(stderr, "[ERROR]: "); 37417c478bd9Sstevel@tonic-gate } 37427c478bd9Sstevel@tonic-gate 37437c478bd9Sstevel@tonic-gate (void) vfprintf(stderr, fmt, ap); 3744*ff2aee48Scth (void) fflush(stderr); 37457c478bd9Sstevel@tonic-gate } 37467c478bd9Sstevel@tonic-gate 37477c478bd9Sstevel@tonic-gate /* ARGSUSED */ 37487c478bd9Sstevel@tonic-gate /* PRINTFLIKE2 */ 37497c478bd9Sstevel@tonic-gate void 37507c478bd9Sstevel@tonic-gate dprintf(debug_level_t msglevel, const char *fmt, ...) 37517c478bd9Sstevel@tonic-gate { 37527c478bd9Sstevel@tonic-gate va_list ap; 37537c478bd9Sstevel@tonic-gate 37547c478bd9Sstevel@tonic-gate assert(msglevel > 0); 37557c478bd9Sstevel@tonic-gate if (!_devlink_debug) 37567c478bd9Sstevel@tonic-gate return; 37577c478bd9Sstevel@tonic-gate 37587c478bd9Sstevel@tonic-gate va_start(ap, fmt); 37597c478bd9Sstevel@tonic-gate debug_print(msglevel, fmt, ap); 37607c478bd9Sstevel@tonic-gate va_end(ap); 37617c478bd9Sstevel@tonic-gate } 3762