tools/diskomizer/locks.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	"@(#)locks.c	1.14	09/05/26 SMI"

/*
 *	diskomizer64mpism
 *
 *	Locking routines.
 * 		stderr and stdout locks can be held recursively.
 * 		other locks can not.
 *	Chris.Gerhard (at) uk.sun.com - Computer Systems CTE
 */
#include "diskomizer64mpism.h"
#include "locks.h"
#include <diskomizer/log.h>
#include "args.h"
/*
 * statics
 */
static pthread_mutex_t *stdout_lock;
static pthread_mutex_t *stderr_lock; /* really any FILE != stdout */
static int stdout_count;
static int stderr_count;
struct disko_lock_t {
	pthread_mutex_t lock;
	char pad[64]; /* Padded to get the lock onto the next cache line */
};
typedef struct disko_lock_t disko_lock_t;
static disko_lock_t *locks;

static sigset_t stderr_sigset;
static sigset_t stdout_sigset;
static int stdout_sigprocmask_status;
static int stderr_sigprocmask_status;

static void mutex_enter(off64_t off);
static void mutex_exit(off64_t off);
static void mutex_getnext(off64_t old, off64_t new);
static void grab_all_locks(void);
static void drop_all_locks(void);
static void stdout_enter(void);
static void stdout_exit(void);
static void stderr_enter(void);
static void stderr_exit(void);

static struct lock_funcs lockers = {
	mutex_enter,
	mutex_exit,
	mutex_getnext,
	grab_all_locks,
	drop_all_locks,
	stdout_enter,
	stdout_exit,
	stderr_enter,
	stderr_exit
};
static struct lock_funcs nops = {
	(void (*)(off64_t off)) nop,
	(void (*)(off64_t off)) nop,
	(void (*)(off64_t old, off64_t new)) nop,
	nop,
	nop,
	nop,
	nop,
	nop,
	nop
};
struct lock_funcs *mutex = &nops;


int
init_shared_lock(pthread_mutex_t *lock)
{
	int ret;
	pthread_mutexattr_t attr;

	ret = pthread_mutexattr_init(&attr);
	if (ret != 0x0)
		pperror("pthread_mutexattr_init");
	ret = pthread_mutexattr_setpshared(&attr, PTHREAD_PROCESS_SHARED);
	if (ret != 0)
		pperror("pthread_mutexattr_setpshared");
	plog(LOG_DEBUG, "initializing lock at %#lx\n", (ulong_t)lock);
	ret = pthread_mutex_init(lock, &attr);
	if (ret != 0)
		pperror("pthread_mutex_init");
	if (pthread_mutexattr_destroy(&attr))
		pperror("pthread_mutexattr_destroy");
	return (ret);
}
void
init_locks(void)
{
	if (opts.nprocs > 1) {
		int i, ret;
		plog(LOG_DEBUG, "allocating %d locks\n", opts.nlocks);
		locks = (disko_lock_t *)alloc_mem(opts.nlocks + 2,
		    sizeof (disko_lock_t));
		plog(LOG_DEBUG, "initializing %d locks\n", opts.nlocks);
		for (i = 0; i < opts.nlocks + 2; i++) {
			plog(LOG_DEBUG, "initializing lock %d at %#lx\n", i,
			    (ulong_t)&locks[i].lock);
			ret = init_shared_lock(&locks[i].lock);
			if (ret == 0)
				plog(LOG_DEBUG, "Lock %d initialised\n", i);
		}
		stdout_lock = &((locks++)->lock);
		stderr_lock = &((locks++)->lock);
		plog(LOG_DEBUG, "locks done\n");
		mutex = &lockers;
	} else
		mutex = &nops;
}

static void
stdout_enter(void)
{
	NOTE(MUTEX_ACQUIRED_AS_SIDE_EFFECT(stdout_lock))
	sigset_t nset; /* new set */
	sigset_t oset; /* old set */
	int sigprocmask_status;

	if (stdout_count == 0) {
		(void) sigemptyset(&nset);
		(void) sigaddset(&nset, SIGINT);
		(void) sigaddset(&nset, SIGTERM);
		sigprocmask_status = sigprocmask(SIG_BLOCK, &nset, &oset);
		pthread_mutex_lock(stdout_lock);
		stdout_sigprocmask_status = sigprocmask_status;
		stdout_sigset = oset;
	}
	stdout_count++;
}
static void
stderr_enter(void)
{
	NOTE(MUTEX_ACQUIRED_AS_SIDE_EFFECT(stderr_lock))
	sigset_t nset; /* new set */
	sigset_t oset; /* old set */
	int sigprocmask_status;

	if (stderr_count == 0) {
		(void) sigemptyset(&nset);
		(void) sigaddset(&nset, SIGINT);
		(void) sigaddset(&nset, SIGTERM);
		sigprocmask_status = sigprocmask(SIG_BLOCK, &nset, &oset);
		pthread_mutex_lock(stderr_lock);
		stderr_sigprocmask_status = sigprocmask_status;
		stderr_sigset = oset;
	}
	stderr_count++;

}
static void
stderr_exit(void)
{
	NOTE(LOCK_RELEASED_AS_SIDE_EFFECT(stderr_lock))
	if (--stderr_count == 0) {
		pthread_mutex_unlock(stderr_lock);
		if (stderr_sigprocmask_status == 0)
			(void) sigprocmask(SIG_SETMASK, &stderr_sigset, NULL);
	}
}
static void
stdout_exit(void)
{
	NOTE(LOCK_RELEASED_AS_SIDE_EFFECT(stdout_lock))
	if (--stdout_count == 0) {
		pthread_mutex_unlock(stdout_lock);
		if (stdout_sigprocmask_status == 0)
			(void) sigprocmask(SIG_SETMASK, &stdout_sigset, NULL);
	}
}
static void
mutex_enter(off64_t off)
{
	NOTE(MUTEX_ACQUIRED_AS_SIDE_EFFECT(&locks[
				GET_OFF(off) % opts.nlocks].lock))
	int ret;

	ret = pthread_mutex_lock(&locks[GET_OFF(off) % opts.nlocks].lock);
	if (ret != 0)
		pperror("pthread_mutex_lock");

}
/*
 *	While holding a lock for offset old get a lock for offset new
 * 	and loose the lock for old.
 */
static void
mutex_getnext(off64_t old, off64_t new)
{
	ulong_t oldlock;
	ulong_t newlock;
	int ret;

	oldlock = (GET_OFF(old) % opts.nlocks);
	newlock = (GET_OFF(new) % opts.nlocks);

	if (oldlock == newlock)
		return;

	ret = pthread_mutex_unlock(&locks[oldlock].lock);
	if (ret != 0)
		pperror("pthread_mutex_unlock");
	ret = pthread_mutex_lock(&locks[newlock].lock);
	if (ret != 0)
		pperror("pthread_mutex_lock");
}
static void
mutex_exit(off64_t off)
{
	int ret;

	ret = pthread_mutex_unlock(&locks[GET_OFF(off) % opts.nlocks].lock);
	if (ret != 0)
		pperror("pthread_mutex_unlock");
}
/*
 * grab_all_locks grabs all the locks used for choosing blocks. This
 * has the effect of stopping any new io requests from being queued.
 * Used in error paths to stop the state of the buffers from being
 * changed more than can't be avioded.
 */
static void
grab_all_locks(void)
{
	int i;

	for (i = 0; i < opts.nlocks; i++) {
		if (pthread_mutex_lock(&locks[i].lock) != 0)
			perror("pthread_mutex_lock");
	}
}
static void
drop_all_locks(void)
{
	int i;

	for (i = 0; i < opts.nlocks; i++) {
		if (pthread_mutex_unlock(&locks[i].lock) != 0)
			perror("pthread_mutex_unlock");
	}
}