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