tools/diskomizer/device_control.c

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

#pragma ident	"@(#)device_control.c	1.17	09/05/26 SMI"

/*
 * Copyright 2009 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 */
/*
 *	Device controls
 *
 *	This is state machine implemations.  THere are 5 states
 *	DEV_NOT_READY
 *	DEV_RUNNING
 *	DEV_STOPPING
 *	DEV_STOPPED
 *	DEV_STARTING
 *
 *	From DEV_NOT_READY you can only go to DEV_STOPPED.
 * 	From DEV_STOPPED you can only go to DEV_STARTING.
 *	From DEV_STARTING you can only go to DEV_RUNNING.
 *	From DEV_RUNNING you can only go to DEV_STOPPING.
 *	From DEV_STOPPING you can only go to DEV_STOPPED.
 *
 *	The complication is that to prevent the device state that
 *	is held in shared memory and protected by a lock from becoming
 *	"hot", the device states are cached in each processes and the
 *	shared state only checked when the time to live expires.
 *
 *	So it is possible for the local state in a process to be
 *	one state but the shared state to be another.  For example
 *	when moving from DEV_STOPPED to DEV_STARTING, the first process
 *	to change it's state will change it's state and the shared
 *	state.  When moving to DEV_STARTING to DEV_RUNNING it is
 *	the last process to change state that changes the shared state.
 *
 */
#include "diskomizer64mpism.h"
#include "device_control.h"
#include "args.h"
#include "timeval.h"
#include <diskomizer/log.h>
#include "list_ops.h"
#include "locks.h"

static void
do_restart_stopped_devices(off64_t start, struct device *device,
	struct timeval *now);

restart_stopped_devices_t restart_stopped_devices =
	do_restart_stopped_devices;

static int not_running_devices;

struct set_dev_args {
	struct timeval *now;
	dev_state newstate;
	dev_state oldstate;
};

int
all_running(void)
{
	return (not_running_devices == 0 ? 1 : 0);
}

static long long
my_llrand(void)
{
	union {
		long long ll;
		ulong_t l[sizeof (long long)/sizeof (ulong_t)];
	} u;
	int i;
	for (i = 0; i < (sizeof (long long)/sizeof (ulong_t)); i++)
		u.l[i] = my_lrand();

	return (u.ll);
}
static long long
ll_mod(long long a, long long b)
{
	long long x = a % b;

	assert(x < b);
	return (x);
#ifdef _NEVER
	long long tmp = b;

	while (tmp < a/2)
		tmp *= 2;
	while (tmp != b) {
		if (a > tmp)
			a -= tmp;
		tmp = tmp / 2;
	}
	return (a);
#endif
}
struct timeval
set_ttl(struct timeval tv, long long max, long long min)
{
	long long diff = max - min;
	long long rand = my_llrand();

	if (diff <= 0)
		return (timeval_llong_add(&tv, min));
	else
		return (timeval_llong_add(&tv, min + ll_mod(rand, diff)));
}

void
init_device_control(struct device *devices)
{
	int ndevices = how_many_devices(devices);
	struct device_control *control;

	control = (struct device_control *)alloc_mem(ndevices,
	    sizeof (struct device_control));

	while (devices != NULL) {
		(void) init_shared_lock(&control->lock);
		devices->state = control->state = DEV_STOPPED;
		control->processes_stopped = opts.nprocs;
		devices->control = control++;
		not_running_devices++;
		devices->control->state_ttl = devices->state_ttl;
		devices = devices->next;
	}
}

static void *
do_dev_control(struct device *device, void *(*func)(struct device *, void *),
	void *arg)
{
	void *res;
	if (device->control == NULL)
		return (NULL);
	pthread_mutex_lock(&device->control->lock);
	res = func(device, arg);
	pthread_mutex_unlock(&device->control->lock);
	return (res);
}
#ifdef NOT_USED
static void *
get_state(struct device *device, void *x)
{
	return ((void*)device->control->state);
}
#endif
static void *
set_state(struct device *device, void *arg)
{
	struct set_dev_args *dap = (struct set_dev_args *)arg;
	char buf[128];

	dev_state state = dap->newstate;
	if (dap->oldstate != device->control->state) {
		if (device->control->state == dap->newstate)
			device->state = state;
		return ((void *) device->control->state);
	}
	device->state = state;
	switch (state) {
	case DEV_RUNNING:
		assert(device->control->state != DEV_STOPPED);
		assert(device->control->state != DEV_STOPPING);
		assert(device->control->state != DEV_NOT_READY);
		if ((--device->control->processes_stopped) == 0) {
			device->control->state = DEV_RUNNING;
			device->state_ttl = device->control->state_ttl =
			    set_ttl(*dap->now, opts.expert_max_active_time,
			    opts.expert_min_active_time);
			if (would_stop_before(
			    device->control->state_ttl.tv_sec)) {
				plog(LOG_NOTICE,
				    "%-*s DEV_RUNNING\n",
				    longest_logical_name(),
				    device->logicalname);
			} else {
				(void) strftime(buf, 128, TIME_FORMAT,
				    localtime(
				    &device->control->state_ttl.tv_sec));
				plog(LOG_NOTICE,
				    "%-*s DEV_RUNNING  stop at  %s\n",
				    longest_logical_name(),
				    device->logicalname, buf);
			}
		}
		if (--not_running_devices == 0) {
			restart_stopped_devices =
			    (restart_stopped_devices_t)nop;
		}
		break;
	case DEV_STARTING:
		assert(device->control->state != DEV_RUNNING);
		assert(device->control->state != DEV_STOPPING);
		assert(device->control->state != DEV_NOT_READY);
		(void) strftime(buf, 128, TIME_FORMAT,
		    localtime(&dap->now->tv_sec));
		plog(LOG_NOTICE, "%-*s DEV_STARTING time now %s\n",
		    longest_logical_name(), device->logicalname, buf);
		device->control->state = state;
		break;
	case DEV_STOPPED:
		assert(device->control->state != DEV_RUNNING);
		assert(device->control->state != DEV_STARTING);
		/*
		 * The order of the controls in this if is important.
		 * the ++device->control->processes_stopped must be last
		 * so it only gets incremented when the other two are not
		 * true.
		 */
		if (device->control->state == DEV_STOPPED ||
		    device->control->state == DEV_NOT_READY ||
		    (++device->control->processes_stopped) == opts.nprocs) {
			device->state_ttl = device->control->state_ttl =
			    set_ttl(*dap->now, opts.expert_max_idle_time,
			    opts.expert_min_idle_time);
			(void) strftime(buf, 128, TIME_FORMAT,
			    localtime(&device->state_ttl.tv_sec));
			device->control->state = DEV_STOPPED;
			plog(LOG_NOTICE, "%-*s DEV_STOPPED  start at %s\n",
			    longest_logical_name(),
			    device->logicalname, buf);
		} else {
			device->state_ttl.tv_sec = -1;
		}
		break;
	case DEV_STOPPING:
		assert(device->control->state != DEV_STOPPED);
		assert(device->control->state != DEV_STARTING);
		assert(device->control->state != DEV_NOT_READY);
		(void) strftime(buf, 128, TIME_FORMAT,
		    localtime(&dap->now->tv_sec));
		plog(LOG_NOTICE, "%-*s DEV_STOPPING time now %s\n",
		    longest_logical_name(), device->logicalname, buf);
		device->control->state = state;
		if (not_running_devices++ == 0) {
			restart_stopped_devices = do_restart_stopped_devices;
		}
		break;
	default:
		abort(); /* This should NEVER happen */
	}
	return ((void *) device->control->state);
}
/*
 * check_ttl
 *
 * Check if the local time to live on the device has expired if we are
 * currently in the global state given.
 *
 *	return 1 if it has and 0 if it has not or we are not in that
 *	global state.
 */
static int
check_ttl(struct device *device, struct timeval *now, dev_state state)
{
	char ret_zero;
	if (timeval_gt(device->state_ttl, *now))
		return (0);
	pthread_mutex_lock(&device->control->lock);
	device->state_ttl = device->control->state_ttl;
	ret_zero = (device->control->state == state ? 0 : 1);
	pthread_mutex_unlock(&device->control->lock);
	return (ret_zero == 1 ? 0 : timeval_lt(device->state_ttl, *now));
}
static void
update_device_ttl(struct device *device, dev_state state)
{
	pthread_mutex_lock(&device->control->lock);

	if (device->control->state != state)
		device->state_ttl = device->control->state_ttl;

	pthread_mutex_unlock(&device->control->lock);
}

dev_state
get_dev_state(struct device *device, struct timeval *now)
{
	if (device->state == DEV_NOT_READY) {
		pthread_mutex_lock(&device->control->lock);
		device->state = device->control->state;
		pthread_mutex_unlock(&device->control->lock);
	}
	if (device->state == DEV_RUNNING && device->state_ttl.tv_sec != 0 &&
	    check_ttl(device, now, DEV_RUNNING)) {
		dev_state x;
		pthread_mutex_lock(&device->control->lock);
		x = device->control->state;
		if (x == DEV_RUNNING || x == DEV_STOPPING) {
			struct set_dev_args da;
			da.now = now;
			da.oldstate = DEV_RUNNING;
			da.newstate = DEV_STOPPING;
			x = (dev_state) set_state(device, (void *)&da);
			if (x == DEV_STOPPING)
				device->state = DEV_STOPPING;
		}
		pthread_mutex_unlock(&device->control->lock);
	} else if (device->state == DEV_STOPPED &&
	    device->state_ttl.tv_sec == -1) {
		update_device_ttl(device, DEV_STOPPING);
	}

	return (device->state);
}
dev_state
set_dev_state(struct device *device, dev_state oldstate,
	dev_state newstate, struct timeval *now)
{
	struct set_dev_args da;
	da.now = now;
	da.oldstate = oldstate;
	da.newstate = newstate;
	return ((dev_state) do_dev_control(device, set_state, (void *)&da));
}
static void
start_io(off64_t start, struct device *device, struct timeval *now)
{
	struct aio_str *aio_resp;

	/* NEED TO SET BOTH states to STARTING */
	aio_resp = pop_from_aio_list(&device->stopped_ios);
	if (aio_resp != NULL) {
		if (set_dev_state(device, DEV_STOPPED, DEV_STARTING, now) !=
		    DEV_STARTING)
			abort();
		if (aio_resp->fd != NULL)
			add_to_aio_list(&aio_resp->fd->all_aios, aio_resp);
		(void) aio_resp->handler(aio_resp, start);
	}
	if (device->stopped_ios.head == NULL) {
		assert(device->state == DEV_STARTING);
		(void) set_dev_state(device, DEV_STARTING, DEV_RUNNING, now);
	}
}

static void
do_restart_stopped_devices(off64_t start, struct device *device,
	struct timeval *now)
{
	while (device != NULL) {
		check_exit_flag();

		if (device->state == DEV_NOT_READY) {
			(void) get_dev_state(device, now);
		}
		if (device->state == DEV_STOPPED) {
			if (device->state_ttl.tv_sec == -1) {
				update_device_ttl(device, DEV_STOPPING);
			}
			if (device->state_ttl.tv_sec != -1 &&
			    check_ttl(device, now, DEV_STOPPED)) {
				(void) set_dev_state(device, DEV_STOPPED,
				    DEV_STARTING, now);
			}
		}
		if (device->state == DEV_STARTING)
			start_io(start, device, now);
		device = device->next;
	}
}