/* * CDDL HEADER START * * The contents of this file are subject to the terms of the * Common Development and Distribution License, Version 1.0 only * (the "License"). You may not use this file except in compliance * with the License. * * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE * or http://www.opensolaris.org/os/licensing. * See the License for the specific language governing permissions * and limitations under the License. * * When distributing Covered Code, include this CDDL HEADER in each * file and include the License file at usr/src/OPENSOLARIS.LICENSE. * If applicable, add the following below this CDDL HEADER, with the * fields enclosed by brackets "[]" replaced with your own identifying * information: Portions Copyright [yyyy] [name of copyright owner] * * CDDL HEADER END */ /* * Copyright 2004 Sun Microsystems, Inc. All rights reserved. * Use is subject to license terms. */ #pragma ident "%Z%%M% %I% %E% SMI" /* * This module adds support to the RCM framework for mounted filesystems. * * The module provides this functionality: * 1) reports device usage for mounted filesystems * 2) prevents offline operations for mounted resources * 3) prevents suspend operations (unless forced) of those filesystems * deemed critical for the continued operation of the OS * 4) propagates RCM operations from mounted resources to the consumers * of files within the mounted filesystems */ #include #include #include #include #include #include #include #include #include #include #include "rcm_module.h" /* Definitions */ #define HASH_DEFAULT 4 #define HASH_THRESHOLD 256 #define OPT_IGNORE "ignore" #define MSG_HDR_STD gettext("mounted filesystem") #define MSG_HDR_STD_MULTI gettext("mounted filesystems") #define MSG_HDR_CRIT gettext("cannot suspend filesystem") #define MSG_HDR_CRIT_MULTI gettext("cannot suspend filesystems") #define MSG_SEPARATOR gettext(", ") #define MSG_FAIL_USAGE gettext("failed to construct usage string.") #define MSG_FAIL_DEPENDENTS gettext("failed while calling dependents.") #define MSG_FAIL_REMOVE gettext("filesystems cannot be removed.") #define MSG_FAIL_INTERNAL gettext("internal processing failure.") typedef struct hashentry { int n_mounts; char *special; char **mountps; struct hashentry *next; } hashentry_t; typedef struct { time_t timestamp; uint32_t hash_size; hashentry_t **mounts; } cache_t; /* Forward Declarations */ /* module interface routines */ static int mnt_register(rcm_handle_t *); static int mnt_unregister(rcm_handle_t *); static int mnt_getinfo(rcm_handle_t *, char *, id_t, uint_t, char **, char **, nvlist_t *, rcm_info_t **); static int mnt_suspend(rcm_handle_t *, char *, id_t, timespec_t *, uint_t, char **, rcm_info_t **); static int mnt_resume(rcm_handle_t *, char *, id_t, uint_t, char **, rcm_info_t **); static int mnt_offline(rcm_handle_t *, char *, id_t, uint_t, char **, rcm_info_t **); static int mnt_online(rcm_handle_t *, char *, id_t, uint_t, char **, rcm_info_t **); static int mnt_remove(rcm_handle_t *, char *, id_t, uint_t, char **, rcm_info_t **); /* cache functions */ static cache_t *cache_create(); static int cache_insert(cache_t *, struct mnttab *); static int cache_sync(rcm_handle_t *, cache_t **); static hashentry_t *cache_lookup(cache_t *, char *); static void free_cache(cache_t **); static void free_entry(hashentry_t **); static void free_list(char **); /* miscellaneous functions */ static uint32_t hash(uint32_t, char *); static void register_rsrc(rcm_handle_t *, char *); static void unregister_rsrc(rcm_handle_t *, char *); static char *create_message(char *, char *, char **); static int detect_critical_failure(char **, uint_t, char **); static int is_critical(char *); static int use_cache(char *, char **, char ***); static void prune_dependents(char **, char *); static char **create_dependents(hashentry_t *); /* Module-Private data */ static struct rcm_mod_ops mnt_ops = { RCM_MOD_OPS_VERSION, mnt_register, mnt_unregister, mnt_getinfo, mnt_suspend, mnt_resume, mnt_offline, mnt_online, mnt_remove }; static cache_t *mnt_cache; static mutex_t cache_lock; /* Module Interface Routines */ /* * rcm_mod_init() * * Called when module is loaded. Returns the ops vector. */ struct rcm_mod_ops * rcm_mod_init() { return (&mnt_ops); } /* * rcm_mod_info() * * Returns a string identifying this module. */ const char * rcm_mod_info() { return ("File system module %I%"); } /* * rcm_mod_fini() * * Called when module is unloaded. Frees up all used memory. * * Locking: the cache is locked for the duration of this function. */ int rcm_mod_fini() { (void) mutex_lock(&cache_lock); free_cache(&mnt_cache); (void) mutex_unlock(&cache_lock); return (RCM_SUCCESS); } /* * mnt_register() * * Called to synchronize the module's registrations. Results in the * construction of a new cache, destruction of any old cache data, * and a full synchronization of the module's registrations. * * Locking: the cache is locked for the duration of this function. */ int mnt_register(rcm_handle_t *hd) { assert(hd != NULL); rcm_log_message(RCM_TRACE1, "FILESYS: register()\n"); (void) mutex_lock(&cache_lock); /* cache_sync() does all of the necessary work */ if (cache_sync(hd, &mnt_cache) < 0) { rcm_log_message(RCM_ERROR, "FILESYS: failed to synchronize cache (%s).\n", strerror(errno)); (void) mutex_unlock(&cache_lock); return (RCM_FAILURE); } (void) mutex_unlock(&cache_lock); return (RCM_SUCCESS); } /* * mnt_unregister() * * Manually walk through the cache, unregistering all the special * files and mount points. * * Locking: the cache is locked throughout the execution of this * routine because it reads and modifies cache links continuously. */ int mnt_unregister(rcm_handle_t *hd) { uint32_t index; hashentry_t *entry; assert(hd != NULL); rcm_log_message(RCM_TRACE1, "FILESYS: unregister()\n"); (void) mutex_lock(&cache_lock); /* Unregister everything in the cache */ if (mnt_cache) { for (index = 0; index < mnt_cache->hash_size; index++) { for (entry = mnt_cache->mounts[index]; entry != NULL; entry = entry->next) { unregister_rsrc(hd, entry->special); } } } /* Destroy the cache */ free_cache(&mnt_cache); (void) mutex_unlock(&cache_lock); return (RCM_SUCCESS); } /* * mnt_offline() * * Filesystem resources cannot be offlined. Always returns failure. * Since no real action is taken, QUERY or not doesn't matter. */ int mnt_offline(rcm_handle_t *hd, char *rsrc, id_t id, uint_t flags, char **errorp, rcm_info_t **dependent_info) { char **dependents; assert(hd != NULL); assert(rsrc != NULL); assert(id == (id_t)0); assert(errorp != NULL); rcm_log_message(RCM_TRACE1, "FILESYS: offline(%s)\n", rsrc); /* Retrieve necessary info from the cache */ if (use_cache(rsrc, errorp, &dependents) < 0) return (RCM_FAILURE); /* Convert the gathered dependents into an error message */ *errorp = create_message(MSG_HDR_STD, MSG_HDR_STD_MULTI, dependents); if (*errorp == NULL) { rcm_log_message(RCM_ERROR, "FILESYS: failed to construct offline message (%s).\n", strerror(errno)); } free_list(dependents); return (RCM_FAILURE); } /* * mnt_online() * * Filesystem resources aren't offlined, so there's really nothing to do * here. */ int mnt_online(rcm_handle_t *hd, char *rsrc, id_t id, uint_t flag, char **errorp, rcm_info_t **dependent_reason) { assert(hd != NULL); assert(rsrc != NULL); assert(id == (id_t)0); assert(errorp != NULL); rcm_log_message(RCM_TRACE1, "FILESYS: online(%s)\n", rsrc); return (RCM_SUCCESS); } /* * mnt_getinfo() * * Report how a given resource is in use by this module. And also * possibly include dependent consumers of the mounted filesystems. */ int mnt_getinfo(rcm_handle_t *hd, char *rsrc, id_t id, uint_t flag, char **usagep, char **errorp, nvlist_t *props, rcm_info_t **depend_info) { int rv = RCM_SUCCESS; char **dependents; assert(hd != NULL); assert(rsrc != NULL); assert(id == (id_t)0); assert(usagep != NULL); assert(errorp != NULL); assert(props != NULL); rcm_log_message(RCM_TRACE1, "FILESYS: getinfo(%s)\n", rsrc); /* Retrieve necessary info from the cache */ if (use_cache(rsrc, errorp, &dependents) < 0) return (RCM_FAILURE); /* Convert the gathered dependents into a usage message */ *usagep = create_message(MSG_HDR_STD, MSG_HDR_STD_MULTI, dependents); if (*usagep == NULL) { rcm_log_message(RCM_ERROR, "FILESYS: failed to construct usage message (%s).\n", strerror(errno)); *errorp = strdup(MSG_FAIL_USAGE); free_list(dependents); return (RCM_FAILURE); } /* Recurse on dependents if necessary */ if ((flag & RCM_INCLUDE_DEPENDENT) && (dependents != NULL)) { prune_dependents(dependents, rsrc); if (dependents[0] != NULL) { if ((rv = rcm_get_info_list(hd, dependents, flag, depend_info)) != RCM_SUCCESS) { *errorp = strdup(MSG_FAIL_DEPENDENTS); } } } /* Free up info retrieved from the cache */ free_list(dependents); return (rv); } /* * mnt_suspend() * * Notify all dependents that the resource is being suspended. * Since no real action is taken, QUERY or not doesn't matter. */ int mnt_suspend(rcm_handle_t *hd, char *rsrc, id_t id, timespec_t *interval, uint_t flag, char **errorp, rcm_info_t **depend_info) { int rv = RCM_SUCCESS; char **dependents; assert(hd != NULL); assert(rsrc != NULL); assert(id == (id_t)0); assert(interval != NULL); assert(errorp != NULL); rcm_log_message(RCM_TRACE1, "FILESYS: suspend(%s)\n", rsrc); /* Retrieve necessary info from the cache */ if (use_cache(rsrc, errorp, &dependents) < 0) return (RCM_FAILURE); /* Unforced suspensions fail if any of the dependents are critical */ if (detect_critical_failure(errorp, flag, dependents)) { free_list(dependents); return (RCM_FAILURE); } /* Recurse on dependents if necessary */ if ((flag & RCM_INCLUDE_DEPENDENT) && (dependents != NULL)) { prune_dependents(dependents, rsrc); if (dependents[0] != NULL) if ((rv = rcm_request_suspend_list(hd, dependents, flag, interval, depend_info)) != RCM_SUCCESS) { *errorp = strdup(MSG_FAIL_DEPENDENTS); } } free_list(dependents); return (rv); } /* * mnt_resume() * * Resume all the dependents of a suspended filesystem. */ int mnt_resume(rcm_handle_t *hd, char *rsrc, id_t id, uint_t flag, char **errorp, rcm_info_t **depend_info) { int rv = RCM_SUCCESS; char **dependents; assert(hd != NULL); assert(rsrc != NULL); assert(id == (id_t)0); assert(errorp != NULL); rcm_log_message(RCM_TRACE1, "FILESYS: resume(%s)\n", rsrc); /* Retrieve necessary info from the cache */ if (use_cache(rsrc, errorp, &dependents) < 0) return (RCM_FAILURE); /* Recurse on dependents if necessary */ if ((flag & RCM_INCLUDE_DEPENDENT) && (dependents != NULL)) { prune_dependents(dependents, rsrc); if (dependents[0] != NULL) { if ((rv = rcm_notify_resume_list(hd, dependents, flag, depend_info)) != RCM_SUCCESS) { *errorp = strdup(MSG_FAIL_DEPENDENTS); } } } free_list(dependents); return (rv); } /* * mnt_remove() * * Remove should never be called since offline always fails. * * Return failure and log the mistake if a remove is ever received for a * mounted filesystem resource. */ int mnt_remove(rcm_handle_t *hd, char *rsrc, id_t id, uint_t flag, char **errorp, rcm_info_t **depend_info) { assert(hd != NULL); assert(rsrc != NULL); assert(id == (id_t)0); assert(errorp != NULL); rcm_log_message(RCM_TRACE1, "FILESYS: remove(%s)\n", rsrc); /* Log the mistake */ rcm_log_message(RCM_ERROR, "FILESYS: invalid remove of \"%s\"\n", rsrc); *errorp = strdup(MSG_FAIL_REMOVE); return (RCM_FAILURE); } /* * Cache management routines */ /* * cache_create() * * This routine constructs a new cache of the current mnttab file. * * Locking: the cache must be locked prior to calling this function. * * Return Values: NULL with errno set on failure, new cache point on * success. */ static cache_t * cache_create() { FILE *fp; cache_t *cache; int i; uint32_t size; struct stat st; struct mnttab mt; /* * To keep the hash table relatively sparse, default values are * used for smaller mnttab files and these values are scaled up * as a fraction of the total mnttab file size for larger ones. */ if (stat(MNTTAB, &st) < 0) { rcm_log_message(RCM_ERROR, "FILESYS: failed to stat \"%s\" (%s).\n", MNTTAB, strerror(errno)); errno = EBADF; return (NULL); } if (st.st_size > HASH_THRESHOLD) { size = st.st_size / HASH_THRESHOLD; for (i = 0; size > 1; i++, size >>= 1); for (; i > -1; i--, size <<= 1); } else { size = HASH_DEFAULT; } /* Allocate a new empty cache */ if ((cache = (cache_t *)calloc(1, sizeof (cache_t))) == NULL) { rcm_log_message(RCM_ERROR, "FILESYS: failed to allocate cache (%s).\n", strerror(errno)); errno = ENOMEM; return (NULL); } cache->hash_size = size; cache->timestamp = st.st_mtime; /* Allocate an empty hash table for the registered special devices */ cache->mounts = (hashentry_t **)calloc(size, sizeof (hashentry_t *)); if (cache->mounts == NULL) { rcm_log_message(RCM_ERROR, "FILESYS: failed to allocate mount table (%s).\n", strerror(errno)); free_cache(&cache); errno = ENOMEM; return (NULL); } /* Open the mnttab file */ if ((fp = fopen(MNTTAB, "r")) == NULL) { rcm_log_message(RCM_ERROR, "FILESYS: failed to open \"%s\" (%s).\n", MNTTAB, strerror(errno)); free_cache(&cache); errno = EIO; return (NULL); } /* Insert each mnttab entry into the cache */ while (getmntent(fp, &mt) == 0) { /* Well, not each entry... some are meant to be ignored */ if ((mt.mnt_mntopts != NULL) && (hasmntopt(&mt, OPT_IGNORE) != NULL)) continue; if (cache_insert(cache, &mt) < 0) { rcm_log_message(RCM_ERROR, "FILESYS: cache insertion failure (%s).\n", strerror(errno)); free_cache(&cache); (void) fclose(fp); errno = EFAULT; return (NULL); } } /* Close the mnttab file */ (void) fclose(fp); return (cache); } /* * free_cache() * * Free up all the memory associated with a cache. * * Locking: the cache must be locked before calling this function. */ static void free_cache(cache_t **cachep) { uint32_t index; hashentry_t *entry; hashentry_t *entry_tmp; /* Do nothing with empty caches */ if ((cachep == NULL) || (*cachep == NULL)) return; if ((*cachep)->mounts) { /* Walk through the hashtable, emptying it */ for (index = 0; index < (*cachep)->hash_size; index++) { entry = (*cachep)->mounts[index]; while (entry) { entry_tmp = entry->next; free_entry(&entry); entry = entry_tmp; } } free((*cachep)->mounts); } free(*cachep); *cachep = NULL; } /* * free_entry() * * Free up memory associated with a hashtable entry. * * Locking: the cache must be locked before calling this function. */ static void free_entry(hashentry_t **entryp) { if (entryp) { if (*entryp) { if ((*entryp)->special) free((*entryp)->special); free_list((*entryp)->mountps); free(*entryp); } *entryp = NULL; } } /* * free_list() * * Free up memory associated with a null terminated list of names. */ static void free_list(char **list) { int i; if (list) { for (i = 0; list[i] != NULL; i++) free(list[i]); free(list); } } /* * cache_sync() * * Resynchronize the mnttab cache with the mnttab file. * * Locking: the cache must be locked before calling this function. * * Return Values: -1 with errno set on failure, 0 on success. */ static int cache_sync(rcm_handle_t *hd, cache_t **cachep) { uint32_t index; cache_t *new_cache; cache_t *old_cache; hashentry_t *entry; struct stat st; /* Only accept valid arguments */ if ((hd == NULL) || (cachep == NULL)) { rcm_log_message(RCM_ERROR, "FILESYS: invalid arguments to cache_sync().\n"); errno = EINVAL; return (-1); } /* Do nothing if there's already an up-to-date cache */ old_cache = *cachep; if (old_cache) { if (stat(MNTTAB, &st) == 0) { if (old_cache->timestamp >= st.st_mtime) { return (0); } } else { rcm_log_message(RCM_WARNING, "FILESYS: failed to stat \"%s\", cache is stale " "(%s).\n", MNTTAB, strerror(errno)); errno = EIO; return (-1); } } /* Create a new cache based on the new mnttab file. */ if ((new_cache = cache_create()) == NULL) { rcm_log_message(RCM_WARNING, "FILESYS: failed creating cache, cache is stale (%s).\n", strerror(errno)); errno = EIO; return (-1); } /* Register any specials found in the new cache but not the old one */ for (index = 0; index < new_cache->hash_size; index++) { for (entry = new_cache->mounts[index]; entry != NULL; entry = entry->next) { if (cache_lookup(old_cache, entry->special) == NULL) { register_rsrc(hd, entry->special); } } } /* Pass the new cache pointer to the calling function */ *cachep = new_cache; /* If there wasn't an old cache, return successfully now */ if (old_cache == NULL) return (0); /* * If there was an old cache, then unregister whatever specials it * contains that aren't in the new cache. And then destroy the old * cache. */ for (index = 0; index < old_cache->hash_size; index++) { for (entry = old_cache->mounts[index]; entry != NULL; entry = entry->next) { if (cache_lookup(new_cache, entry->special) == NULL) { unregister_rsrc(hd, entry->special); } } } free_cache(&old_cache); return (0); } /* * cache_insert() * * Given a cache and a mnttab entry, this routine inserts that entry in * the cache. The mnttab entry's special device is added to the 'mounts' * hashtable of the cache, and the entry's mountp value is added to the * list of associated mountpoints for the corresponding hashtable entry. * * Locking: the cache must be locked before calling this function. * * Return Values: -1 with errno set on failure, 0 on success. */ static int cache_insert(cache_t *cache, struct mnttab *mt) { uint32_t index; hashentry_t *entry; char **mountps; /* Only accept valid arguments */ if ((cache == NULL) || (cache->mounts == NULL) || (mt == NULL) || (mt->mnt_special == NULL) || (mt->mnt_mountp == NULL)) { errno = EINVAL; return (-1); } /* * Disregard any non-loopback mounts whose special device names * don't begin with "/dev". */ if ((strncmp(mt->mnt_special, "/dev", strlen("/dev")) != 0) && (strcmp(mt->mnt_fstype, "lofs") != 0)) return (0); /* * Find the special device's entry in the mounts hashtable, allocating * a new entry if necessary. */ index = hash(cache->hash_size, mt->mnt_special); for (entry = cache->mounts[index]; entry != NULL; entry = entry->next) { if (strcmp(entry->special, mt->mnt_special) == 0) break; } if (entry == NULL) { entry = (hashentry_t *)calloc(1, sizeof (hashentry_t)); if ((entry == NULL) || ((entry->special = strdup(mt->mnt_special)) == NULL)) { rcm_log_message(RCM_ERROR, "FILESYS: failed to allocate special device name " "(%s).\n", strerror(errno)); free_entry(&entry); errno = ENOMEM; return (-1); } entry->next = cache->mounts[index]; cache->mounts[index] = entry; } /* * Keep entries in the list of mounts unique, so exit early if the * mount is already in the list. */ for (index = 0; index < entry->n_mounts; index++) { if (strcmp(entry->mountps[index], mt->mnt_mountp) == 0) return (0); } /* * Add this mountpoint to the list of mounts associated with the * special device. */ mountps = (char **)realloc(entry->mountps, (entry->n_mounts + 2) * sizeof (char *)); if ((mountps == NULL) || ((mountps[entry->n_mounts] = strdup(mt->mnt_mountp)) == NULL)) { rcm_log_message(RCM_ERROR, "FILESYS: failed to allocate mountpoint name (%s).\n", strerror(errno)); if (entry->n_mounts == 0) { cache->mounts[index] = entry->next; free_entry(&entry); } errno = ENOMEM; return (-1); } mountps[entry->n_mounts + 1] = NULL; entry->n_mounts++; entry->mountps = mountps; return (0); } /* * cache_lookup() * * Searches the cached table of mounts for a special device entry. * * Locking: the cache must be locked before calling this function. * * Return Value: NULL with errno set if failure, pointer to existing * cache entry when successful. */ static hashentry_t * cache_lookup(cache_t *cache, char *rsrc) { uint32_t index; hashentry_t *entry; /* Only accept valid arguments */ if ((cache == NULL) || (cache->mounts == NULL) || (rsrc == NULL)) { errno = EINVAL; return (NULL); } /* Search the cached mounts table for the resource's entry */ index = hash(cache->hash_size, rsrc); if (cache->mounts[index]) { for (entry = cache->mounts[index]; entry != NULL; entry = entry->next) { if (strcmp(entry->special, rsrc) == 0) return (entry); } } errno = ENOENT; return (NULL); } /* * Miscellaneous Functions */ /* * hash() * * A naive hashing function that converts a string 's' to an index in a * hash table of size 'h'. It seems to spread entries around well enough. */ static uint32_t hash(uint32_t h, char *s) { uint32_t sum = 0; unsigned char *byte; if ((byte = (unsigned char *)s) != NULL) { while (*byte) { sum += 0x3F & (uint32_t)*byte; byte++; } } return (sum % h); } /* * register_rsrc() * * Registers for any given resource, unless it's "/". */ static void register_rsrc(rcm_handle_t *hd, char *rsrc) { /* Only accept valid arguments */ if ((hd == NULL) || (rsrc == NULL)) return; /* * Register any resource other than "/" or "/devices" */ if ((strcmp(rsrc, "/") != 0) && (strcmp(rsrc, "/devices") != 0)) { rcm_log_message(RCM_DEBUG, "FILESYS: registering %s\n", rsrc); if (rcm_register_interest(hd, rsrc, 0, NULL) != RCM_SUCCESS) { rcm_log_message(RCM_WARNING, "FILESYS: failed to register %s\n", rsrc); } } } /* * unregister_rsrc() * * Unregister a resource. This does a little filtering since we know * "/" can't be registered, so we never bother unregistering for it. */ static void unregister_rsrc(rcm_handle_t *hd, char *rsrc) { assert(hd != NULL); assert(rsrc != NULL); /* Unregister any resource other than "/" */ if (strcmp(rsrc, "/") != 0) { rcm_log_message(RCM_DEBUG, "FILESYS: unregistering %s\n", rsrc); (void) rcm_unregister_interest(hd, rsrc, 0); } } /* * create_message() * * Given some header strings and a list of dependent names, this * constructs a single string. If there's only one dependent, the * string consists of the first header and the only dependent appended * to the end of the string enclosed in quotemarks. If there are * multiple dependents, then the string uses the second header and the * full list of dependents is appended at the end as a comma separated * list of names enclosed in quotemarks. */ static char * create_message(char *header, char *header_multi, char **dependents) { int i; size_t len; int ndependents; char *msg_buf; char *msg_header; char *separator = MSG_SEPARATOR; assert(header != NULL); assert(header_multi != NULL); assert(dependents != NULL); /* Count the number of dependents */ for (ndependents = 0; dependents[ndependents] != NULL; ndependents++); /* If there are no dependents, fail */ if (ndependents == 0) { errno = ENOENT; return (NULL); } /* Pick the appropriate header to use based on amount of dependents */ if (ndependents == 1) { msg_header = header; } else { msg_header = header_multi; } /* Compute the size required for the message buffer */ len = strlen(msg_header) + 2; /* +2 for the space and a NULL */ for (i = 0; dependents[i] != NULL; i++) len += strlen(dependents[i]) + 2; /* +2 for quotemarks */ len += strlen(separator) * (ndependents - 1); /* Allocate the message buffer */ if ((msg_buf = (char *)calloc(len, sizeof (char))) == NULL) { rcm_log_message(RCM_ERROR, "FILESYS: failed to allocate message buffer (%s).\n", strerror(errno)); errno = ENOMEM; return (NULL); } /* Fill in the message buffer */ (void) snprintf(msg_buf, len, "%s ", msg_header); for (i = 0; dependents[i] != NULL; i++) { (void) strlcat(msg_buf, "\"", len); (void) strlcat(msg_buf, dependents[i], len); (void) strlcat(msg_buf, "\"", len); if ((i + 1) < ndependents) (void) strlcat(msg_buf, separator, len); } return (msg_buf); } /* * create_dependents() * * Creates a copy of the list of dependent mounts associated with a * given hashtable entry from the cache. * * Return Values: NULL with errno set on failure, the resulting list of * dependent resources when successful. */ static char ** create_dependents(hashentry_t *entry) { int i; char **dependents; if (entry == NULL) { errno = EINVAL; return (NULL); } if (entry->n_mounts == 0) { errno = ENOENT; return (NULL); } /* Allocate space for the full dependency list */ dependents = (char **)calloc(entry->n_mounts + 1, sizeof (char *)); if (dependents == NULL) { rcm_log_message(RCM_ERROR, "FILESYS: failed to allocate dependents (%s).\n", strerror(errno)); errno = ENOMEM; return (NULL); } /* Copy all the dependent names into the new list of dependents */ for (i = 0; i < entry->n_mounts; i++) { if ((dependents[i] = strdup(entry->mountps[i])) == NULL) { rcm_log_message(RCM_ERROR, "FILESYS: failed to allocate dependent \"%s\" " "(%s).\n", entry->mountps[i], strerror(errno)); free_list(dependents); errno = ENOMEM; return (NULL); } } return (dependents); } /* * detect_critical_failure() * * Given a list of dependents, a place to store an error message, and * the flags associated with an operation, this function detects whether * or not the operation should fail due to the presence of any critical * filesystem resources. When a failure is detected, an appropriate * error message is constructed and passed back to the caller. This is * called during a suspend request operation. * * Return Values: 0 when a critical resource failure shouldn't prevent * the operation, and 1 when such a failure condition does exist. */ static int detect_critical_failure(char **errorp, uint_t flags, char **dependents) { int i; int n_critical; char *tmp; /* Do nothing if the operation is forced or there are no dependents */ if ((errorp == NULL) || (flags & RCM_FORCE) || (dependents == NULL)) return (0); /* * Count how many of the dependents are critical, and shift the * critical resources to the head of the list. */ if (dependents) { for (i = 0, n_critical = 0; dependents[i] != NULL; i++) { if (is_critical(dependents[i])) { if (n_critical != i) { tmp = dependents[n_critical]; dependents[n_critical] = dependents[i]; dependents[i] = tmp; } n_critical++; } } } /* If no criticals were found, do nothing and return */ if (n_critical == 0) return (0); /* * Criticals were found. Prune the list appropriately and construct * an error message. */ /* Prune non-criticals out of the list */ for (i = n_critical; dependents[i] != NULL; i++) { free(dependents[i]); dependents[i] = NULL; } /* Construct the critical resource error message */ *errorp = create_message(MSG_HDR_CRIT, MSG_HDR_CRIT_MULTI, dependents); return (1); } /* * is_critical() * * Test a resource to determine if it's critical to the system and thus * cannot be suspended. * * Return Values: 1 if the named resource is critical, 0 if not. */ static int is_critical(char *rsrc) { assert(rsrc != NULL); if ((strcmp(rsrc, "/") == 0) || (strcmp(rsrc, "/usr") == 0) || (strcmp(rsrc, "/usr/lib") == 0) || (strcmp(rsrc, "/usr/bin") == 0) || (strcmp(rsrc, "/tmp") == 0) || (strcmp(rsrc, "/var") == 0) || (strcmp(rsrc, "/var/run") == 0) || (strcmp(rsrc, "/etc") == 0) || (strcmp(rsrc, "/etc/mnttab") == 0) || (strcmp(rsrc, "/sbin") == 0)) return (1); return (0); } /* * use_cache() * * This routine handles all the tasks necessary to lookup a resource * in the cache and extract a separate list of dependents for that * entry. If an error occurs while doing this, an appropriate error * message is passed back to the caller. * * Locking: the cache is locked for the whole duration of this function. */ static int use_cache(char *rsrc, char **errorp, char ***dependentsp) { hashentry_t *entry; (void) mutex_lock(&cache_lock); if ((entry = cache_lookup(mnt_cache, rsrc)) == NULL) { rcm_log_message(RCM_ERROR, "FILESYS: failed looking up \"%s\" in cache (%s).\n", rsrc, strerror(errno)); *errorp = strdup(MSG_FAIL_INTERNAL); (void) mutex_unlock(&cache_lock); return (-1); } *dependentsp = create_dependents(entry); (void) mutex_unlock(&cache_lock); return (0); } /* * prune_dependents() * * Before calling back into RCM with a list of dependents, the list * must be cleaned up a little. To avoid infinite recursion, "/" and * the named resource must be pruned out of the list. */ static void prune_dependents(char **dependents, char *rsrc) { int i; int n; if (dependents) { /* Set 'n' to the total length of the list */ for (n = 0; dependents[n] != NULL; n++); /* * Move offending dependents to the tail of the list and * then truncate the list. */ for (i = 0; dependents[i] != NULL; i++) { if ((strcmp(dependents[i], rsrc) == 0) || (strcmp(dependents[i], "/") == 0)) { free(dependents[i]); dependents[i] = dependents[n - 1]; dependents[n] = NULL; i--; n--; } } } }