/*
* CDDL HEADER START
*
* The contents of this file are subject to the terms of the
* Common Development and Distribution License (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 2008 Sun Microsystems, Inc. All rights reserved.
* Use is subject to license terms.
*/
#pragma ident "%Z%%M% %I% %E% SMI"
/*
* RCM module for managing dump device during dynamic
* reconfiguration.
*/
#include <stdlib.h>
#include <unistd.h>
#include <fcntl.h>
#include <string.h>
#include <thread.h>
#include <synch.h>
#include <assert.h>
#include <errno.h>
#include <libintl.h>
#include <sys/dumpadm.h>
#include <sys/param.h>
#include <sys/wait.h>
#include <sys/types.h>
#include <sys/stat.h>
#include "rcm_module.h"
/* cache flags */
#define DUMP_CACHE_NEW 0x01
#define DUMP_CACHE_STALE 0x02
#define DUMP_CACHE_OFFLINED 0x04
#define DUMPADM "/usr/sbin/dumpadm -d "
#define DUMPADM_SWAP DUMPADM"swap"
typedef struct dump_conf {
char device[MAXPATHLEN];
int conf_flags; /* defs in <sys/dumpadm.h> */
int cache_flags;
struct dump_conf *next;
struct dump_conf *prev;
} dump_conf_t;
/*
* Registration cache.
*
* N.B. Although we currently only support a single
* dump device, the cache is multi-entry since there
* may be multiple outstanding registrations.
*/
static dump_conf_t *cache;
static mutex_t cache_lock;
static int dump_register(rcm_handle_t *);
static int dump_unregister(rcm_handle_t *);
static int dump_getinfo(rcm_handle_t *, char *, id_t, uint_t,
char **, char **, nvlist_t *, rcm_info_t **);
static int dump_suspend(rcm_handle_t *, char *, id_t, timespec_t *,
uint_t, char **, rcm_info_t **);
static int dump_resume(rcm_handle_t *, char *, id_t, uint_t,
char **, rcm_info_t **);
static int dump_offline(rcm_handle_t *, char *, id_t, uint_t,
char **, rcm_info_t **);
static int dump_online(rcm_handle_t *, char *, id_t, uint_t,
char **, rcm_info_t **);
static int dump_remove(rcm_handle_t *, char *, id_t, uint_t,
char **, rcm_info_t **);
static int alloc_usage(char **, int);
static void cache_insert(dump_conf_t *);
static dump_conf_t *cache_lookup(char *);
static void cache_remove(dump_conf_t *);
static dump_conf_t *dump_conf_alloc(void);
static int dump_configure(dump_conf_t *, char **);
static int dump_relocate(dump_conf_t *, char **);
static void free_cache(void);
static void log_cmd_status(int);
static int update_cache(rcm_handle_t *);
static struct rcm_mod_ops dump_ops =
{
RCM_MOD_OPS_VERSION,
dump_register,
dump_unregister,
dump_getinfo,
dump_suspend,
dump_resume,
dump_offline,
dump_online,
dump_remove,
NULL,
NULL,
NULL
};
struct rcm_mod_ops *
rcm_mod_init()
{
return (&dump_ops);
}
const char *
rcm_mod_info()
{
return ("RCM Dump module 1.3");
}
int
rcm_mod_fini()
{
free_cache();
(void) mutex_destroy(&cache_lock);
return (RCM_SUCCESS);
}
static int
dump_register(rcm_handle_t *hdl)
{
return (update_cache(hdl));
}
static int
dump_unregister(rcm_handle_t *hdl)
{
dump_conf_t *dc;
(void) mutex_lock(&cache_lock);
while ((dc = cache) != NULL) {
cache = cache->next;
(void) rcm_unregister_interest(hdl, dc->device, 0);
free(dc);
}
(void) mutex_unlock(&cache_lock);
return (RCM_SUCCESS);
}
/*ARGSUSED*/
static int
dump_getinfo(rcm_handle_t *hdl, char *rsrcname, id_t id, uint_t flags,
char **infostr, char **errstr, nvlist_t *props, rcm_info_t **dependent)
{
dump_conf_t *dc;
int conf_flags;
assert(rsrcname != NULL && infostr != NULL);
(void) mutex_lock(&cache_lock);
if ((dc = cache_lookup(rsrcname)) == NULL) {
(void) mutex_unlock(&cache_lock);
rcm_log_message(RCM_ERROR, "unknown resource: %s\n",
rsrcname);
return (RCM_FAILURE);
}
conf_flags = dc->conf_flags;
(void) mutex_unlock(&cache_lock);
return ((alloc_usage(infostr, conf_flags) == 0) ?
RCM_SUCCESS : RCM_FAILURE);
}
/*
* Relocate dump device to maintain availability during suspension.
* Fail request if unable to relocate.
*/
/*ARGSUSED*/
static int
dump_suspend(rcm_handle_t *hdl, char *rsrcname, id_t id, timespec_t *interval,
uint_t flags, char **errstr, rcm_info_t **dependent)
{
dump_conf_t *dc;
int rv;
assert(rsrcname != NULL && errstr != NULL);
if (flags & RCM_QUERY)
return (RCM_SUCCESS);
(void) mutex_lock(&cache_lock);
if ((dc = cache_lookup(rsrcname)) == NULL) {
(void) mutex_unlock(&cache_lock);
return (RCM_SUCCESS);
}
rv = dump_relocate(dc, errstr);
(void) mutex_unlock(&cache_lock);
return (rv);
}
/*ARGSUSED*/
static int
dump_resume(rcm_handle_t *hdl, char *rsrcname, id_t id, uint_t flags,
char **errstr, rcm_info_t **dependent)
{
dump_conf_t *dc;
int rv;
assert(rsrcname != NULL && errstr != NULL);
(void) mutex_lock(&cache_lock);
if ((dc = cache_lookup(rsrcname)) == NULL) {
(void) mutex_unlock(&cache_lock);
return (RCM_SUCCESS);
}
rv = dump_configure(dc, errstr);
(void) mutex_unlock(&cache_lock);
return (rv);
}
/*
* By default, reject offline. If offline request is
* forced, attempt to relocate the dump device.
*/
/*ARGSUSED*/
static int
dump_offline(rcm_handle_t *hdl, char *rsrcname, id_t id, uint_t flags,
char **errstr, rcm_info_t **dependent)
{
dump_conf_t *dc;
int conf_flags;
int rv;
assert(rsrcname != NULL && errstr != NULL);
if ((flags & RCM_FORCE) && (flags & RCM_QUERY))
return (RCM_SUCCESS);
(void) mutex_lock(&cache_lock);
if ((dc = cache_lookup(rsrcname)) == NULL) {
(void) mutex_unlock(&cache_lock);
return (RCM_SUCCESS);
}
if (flags & RCM_FORCE) {
rv = dump_relocate(dc, errstr);
(void) mutex_unlock(&cache_lock);
return (rv);
}
/* default */
conf_flags = dc->conf_flags;
(void) mutex_unlock(&cache_lock);
(void) alloc_usage(errstr, conf_flags);
return (RCM_FAILURE);
}
/*ARGSUSED*/
static int
dump_online(rcm_handle_t *hdl, char *rsrcname, id_t id, uint_t flags,
char **errstr, rcm_info_t **dependent)
{
dump_conf_t *dc;
int rv;
assert(rsrcname != NULL && errstr != NULL);
(void) mutex_lock(&cache_lock);
if ((dc = cache_lookup(rsrcname)) == NULL) {
(void) mutex_unlock(&cache_lock);
return (RCM_SUCCESS);
}
rv = dump_configure(dc, errstr);
(void) mutex_unlock(&cache_lock);
return (rv);
}
/*ARGSUSED*/
static int
dump_remove(rcm_handle_t *hdl, char *rsrcname, id_t id, uint_t flags,
char **errstr, rcm_info_t **dependent)
{
dump_conf_t *dc;
assert(rsrcname != NULL && errstr != NULL);
(void) mutex_lock(&cache_lock);
if ((dc = cache_lookup(rsrcname)) == NULL) {
(void) mutex_unlock(&cache_lock);
return (RCM_SUCCESS);
}
cache_remove(dc);
free(dc);
(void) mutex_unlock(&cache_lock);
return (RCM_SUCCESS);
}
/*
* For dedicated dump devices, invoke dumpadm(1M)
* to relocate dump to swap. For dump device on
* swap, this is a no-op as the RCM swap module
* will relocate by invoking swap(1M).
*
* Call with cache_lock held.
*/
static int
dump_relocate(dump_conf_t *dc, char **errstr)
{
int stat;
/*
* This state may get out of sync for a dump device on swap,
* since we will will not know if the swap module succeeds.
* Worst case is we end up invoking dumpadm to configure
* the same device during a rollback.
*/
dc->cache_flags |= DUMP_CACHE_OFFLINED;
/* RCM swap module will handle non-dedicated */
if (!(dc->conf_flags & DUMP_EXCL))
return (RCM_SUCCESS);
rcm_log_message(RCM_TRACE1, "%s\n", DUMPADM_SWAP);
if ((stat = rcm_exec_cmd(DUMPADM_SWAP)) != 0) {
log_cmd_status(stat);
*errstr = strdup(gettext("unable to relocate dump device"));
dc->cache_flags &= ~DUMP_CACHE_OFFLINED;
return (RCM_FAILURE);
}
return (RCM_SUCCESS);
}
/*
* (Re)Configure dump device.
* Call with cache_lock held.
*/
static int
dump_configure(dump_conf_t *dc, char **errstr)
{
char cmd[sizeof (DUMPADM) + MAXPATHLEN];
int stat;
assert(dc != NULL && dc->device != NULL);
/* minor optimization */
if (!(dc->cache_flags & DUMP_CACHE_OFFLINED))
return (RCM_SUCCESS);
(void) snprintf(cmd, sizeof (cmd), "%s%s", DUMPADM, dc->device);
rcm_log_message(RCM_TRACE1, "%s\n", cmd);
if ((stat = rcm_exec_cmd(cmd)) != 0) {
log_cmd_status(stat);
*errstr = strdup(gettext("unable to configure dump device"));
return (RCM_FAILURE);
}
dc->cache_flags &= ~DUMP_CACHE_OFFLINED;
return (RCM_SUCCESS);
}
/*
* Returns current dump configuration
*/
static dump_conf_t *
dump_conf_alloc(void)
{
dump_conf_t *dc;
struct stat sbuf;
int fd;
char *err;
if ((dc = calloc(1, sizeof (*dc))) == NULL) {
rcm_log_message(RCM_ERROR, "calloc failure\n");
return (NULL);
}
if ((fd = open("/dev/dump", O_RDONLY)) == -1) {
/*
* Suppress reporting if no logical link.
*/
if (stat("/dev/dump", &sbuf) == 0 &&
(fd = open("/dev/dump", O_RDONLY)) == -1) {
rcm_log_message(RCM_ERROR,
"failed to open /dev/dump: %s\n",
((err = strerror(errno)) == NULL) ? "" : err);
}
if (fd == -1) {
free(dc);
return (NULL);
}
}
if (ioctl(fd, DIOCGETDEV, dc->device) == -1) {
if (errno == ENODEV) {
dc->device[0] = '\0';
} else {
rcm_log_message(RCM_ERROR, "ioctl: %s\n",
((err = strerror(errno)) == NULL) ? "" : err);
(void) close(fd);
free(dc);
return (NULL);
}
}
if (dc->device[0] != '\0') {
if ((dc->conf_flags = ioctl(fd, DIOCGETCONF, 0)) == -1) {
rcm_log_message(RCM_ERROR, "ioctl: %s\n",
((err = strerror(errno)) == NULL) ? "" : err);
(void) close(fd);
free(dc);
return (NULL);
}
}
(void) close(fd);
return (dc);
}
static int
update_cache(rcm_handle_t *hdl)
{
dump_conf_t *ent, *curr_dump, *tmp;
int rv = RCM_SUCCESS;
if ((curr_dump = dump_conf_alloc()) == NULL)
return (RCM_FAILURE);
(void) mutex_lock(&cache_lock);
/*
* pass 1 - mark all current registrations stale
*/
for (ent = cache; ent != NULL; ent = ent->next) {
ent->cache_flags |= DUMP_CACHE_STALE;
}
/*
* update current dump conf
*/
if (curr_dump->device[0] == '\0') {
free(curr_dump);
} else if ((ent = cache_lookup(curr_dump->device)) != NULL) {
ent->cache_flags &= ~DUMP_CACHE_STALE;
ent->conf_flags = curr_dump->conf_flags;
free(curr_dump);
} else {
curr_dump->cache_flags |= DUMP_CACHE_NEW;
cache_insert(curr_dump);
}
/*
* pass 2 - register, unregister, or no-op based on cache flags
*/
ent = cache;
while (ent != NULL) {
if (ent->cache_flags & DUMP_CACHE_OFFLINED) {
ent = ent->next;
continue;
}
if (ent->cache_flags & DUMP_CACHE_STALE) {
if (rcm_unregister_interest(hdl, ent->device, 0) !=
RCM_SUCCESS) {
rcm_log_message(RCM_ERROR, "failed to "
"unregister %s\n", ent->device);
}
tmp = ent;
ent = ent->next;
cache_remove(tmp);
free(tmp);
continue;
}
if (!(ent->cache_flags & DUMP_CACHE_NEW)) {
ent = ent->next;
continue;
}
if (rcm_register_interest(hdl, ent->device, 0, NULL) !=
RCM_SUCCESS) {
rcm_log_message(RCM_ERROR, "failed to register "
"%s\n", ent->device);
rv = RCM_FAILURE;
} else {
rcm_log_message(RCM_DEBUG, "registered %s\n",
ent->device);
ent->cache_flags &= ~DUMP_CACHE_NEW;
}
ent = ent->next;
}
(void) mutex_unlock(&cache_lock);
return (rv);
}
/*
* Call with cache_lock held.
*/
static dump_conf_t *
cache_lookup(char *rsrc)
{
dump_conf_t *dc;
for (dc = cache; dc != NULL; dc = dc->next) {
if (strcmp(rsrc, dc->device) == 0) {
return (dc);
}
}
return (NULL);
}
/*
* Link to front of list.
* Call with cache_lock held.
*/
static void
cache_insert(dump_conf_t *ent)
{
ent->next = cache;
if (ent->next)
ent->next->prev = ent;
ent->prev = NULL;
cache = ent;
}
/*
* Call with cache_lock held.
*/
static void
cache_remove(dump_conf_t *ent)
{
if (ent->next != NULL) {
ent->next->prev = ent->prev;
}
if (ent->prev != NULL) {
ent->prev->next = ent->next;
} else {
cache = ent->next;
}
ent->next = NULL;
ent->prev = NULL;
}
static void
free_cache(void)
{
dump_conf_t *dc;
(void) mutex_lock(&cache_lock);
while ((dc = cache) != NULL) {
cache = cache->next;
free(dc);
}
(void) mutex_unlock(&cache_lock);
}
static int
alloc_usage(char **cpp, int conf_flags)
{
/* simplifies message translation */
if (conf_flags & DUMP_EXCL) {
*cpp = strdup(gettext("dump device (dedicated)"));
} else {
*cpp = strdup(gettext("dump device (swap)"));
}
if (*cpp == NULL) {
rcm_log_message(RCM_ERROR, "strdup failure\n");
return (-1);
}
return (0);
}
static void
log_cmd_status(int stat)
{
char *err;
if (stat == -1) {
rcm_log_message(RCM_ERROR, "wait: %s\n",
((err = strerror(errno)) == NULL) ? "" : err);
} else if (WIFEXITED(stat)) {
rcm_log_message(RCM_ERROR, "exit status: %d\n",
WEXITSTATUS(stat));
} else {
rcm_log_message(RCM_ERROR, "wait status: %d\n", stat);
}
}