xref: /illumos-gate/usr/src/cmd/rcm_daemon/common/dump_rcm.c (revision bbf215553c7233fbab8a0afdf1fac74c44781867)

/*
 * 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.
 */

/*
 * 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(8)
 * 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(8).
 *
 * 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);
	}
}