tools/diskomizer/shared_device_info.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
 */

/*
 * Copyright 2009 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 */

#pragma ident	"@(#)shared_device_info.c	1.9	09/05/26 SMI"

/*
 *	Routines for storing shared information about devices. Used for
 *	errors and statistics.
 *
 *	Update routines are non blocking. On error the caller is expected to
 *	keep the data and resubmit it later when the lock or memory can
 *	be accessed.
 *
 *	Chris.Gerhard (at) uk.sun.com - CS CTE
 *
 *	Still to do:
 *		Shared statistics.
 *		on_error stop routine.
 *		re implement the device control to use these routines,
 *			this will save memory.
 */
#ifndef	_LARGEFILE64_SOURCE
#define	_LARGEFILE64_SOURCE
#endif
#include <sys/types.h>
#include <string.h>
#include <libintl.h>
#include "locks.h"
#include "shm_ops.h"
#include <diskomizer/log.h>
#include "shared_device_info.h"
#define	ZERO_OBJ(X) (void) memset(&X, NULL, sizeof (X))
#define	CACHE_LINE 64
struct fast_locks {
	union {
		pthread_mutex_t lock;
		char pad[CACHE_LINE];
	} u;
};
static int nprocs;
/*
 * Private data structure that is used to store the shared information.
 */
struct shared_device_info {
	pthread_mutex_t error_lock;
	uint_t errors;
	/* To update you have to hold all the locks in array */
	uint_t stop_flag:1;
	/* Must be the last element in the structure */
	struct fast_locks locks[1];
};
void *
init_shared_device_info(int nproc)
{
	shm_flags flag;
	void *handle;
	struct shared_device_info *info;
	int i;

	nprocs = nproc;

	ZERO_OBJ(flag);

	flag.allow_detach = 1;

	handle = shm_ops->init(1, sizeof (struct shared_device_info) +
	    sizeof (struct fast_locks) * (nproc - 1), flag);

	if (handle == NULL)
		return (NULL);
	info = (struct shared_device_info *)shm_ops->attach(handle);
	if (info == NULL) {
		shm_ops->destroy(handle);
		return (NULL);
	}
	if (init_shared_lock(&info->error_lock)) {
		shm_ops->detach(handle);
		shm_ops->destroy(handle);
		return (NULL);
	}
	info->errors = 0;
	for (i = 0; i < nprocs; i++) {
		if (init_shared_lock(&info->locks[i].u.lock)) {
			shm_ops->detach(handle);
			shm_ops->destroy(handle);
			return (NULL);
		}
	}

	if (shm_ops->detach(handle) == SHM_DETACH_ERR) {
		pperror(gettext("Unable to detach %s shared memory segment\n"),
		    shm_ops->name(handle));
	}
	return (handle);
}
/*
 * Increment the error counter by count.  Return the previous error count.
 * on error return -1.
 *
 * The caller has to cope with the error.
 */
int
incr_shared_device_error(void *handle, int count)
{
	struct shared_device_info *info;
	int old;
	/*
	 * I the count is zero then, this is just alook up which will block
	 * lookups are only done as the whole thing exits.
	 */
	int (*lock)(pthread_mutex_t *mutex) = count ? pthread_mutex_trylock :
	    pthread_mutex_lock;

	if (handle == NULL)
		return (-1);

	info = (struct shared_device_info *)shm_ops->attach(handle);
	if (info == NULL) {
		return (-1);
	}
	if (lock(&info->error_lock)) {
		shm_ops->detach(handle);
		return (-1);
	}
	old = info->errors;
	info->errors += count;
	pthread_mutex_unlock(&info->error_lock);
	shm_ops->detach(handle);
	return (old);
}
int
get_shared_device_error(void *handle)
{
	return (incr_shared_device_error(handle, 0));
}
int
get_shared_stop_flag(void *handle, int proc)
{
	struct shared_device_info *info;
	int x;
	if (handle == NULL)
		return (-1);
	info = (struct shared_device_info *)shm_ops->attach(handle);
	if (info == NULL) {
		return (-1);
	}
	if (pthread_mutex_trylock(&info->locks[proc].u.lock)) {
		shm_ops->detach(handle);
		return (-1);
	}
	x = info->stop_flag;
	pthread_mutex_unlock(&info->locks[proc].u.lock);
	shm_ops->detach(handle);
	return (x);
}
int
set_shared_stop_flag(void *handle)
{
	struct shared_device_info *info;
	int i;

	if (handle == NULL)
		return (-1);

	info = (struct shared_device_info *)shm_ops->attach(handle);
	if (info == NULL) {
		return (-1);
	}
	for (i = 0; i < nprocs; i++) {
		if (pthread_mutex_trylock(&info->locks[i].u.lock)) {
			while ((--i) >= 0) {
				pthread_mutex_unlock(&info->locks[i].u.lock);
			}
			shm_ops->detach(handle);
			return (-1);
		}
	}
	info->stop_flag = 1;

	while ((--i) >= 0) {
		pthread_mutex_unlock(&info->locks[i].u.lock);
	}
	shm_ops->detach(handle);
	return (1);
}