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