svc/configd/snapshot.c

/*
 * CDDL HEADER START
 *
 * The contents of this file are subject to the terms of the
 * Common Development and Distribution License, Version 1.0 only
 * (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 2004 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 */

#pragma ident	"%Z%%M%	%I%	%E% SMI"

#include <assert.h>
#include <pthread.h>
#include <stdlib.h>
#include <strings.h>
#include "configd.h"
#include "repcache_protocol.h"

typedef struct snapshot_bucket {
	pthread_mutex_t	sb_lock;
	rc_snapshot_t	*sb_head;

	char		sb_pad[64 - sizeof (pthread_mutex_t) -
			    sizeof (rc_snapshot_t *)];
} snapshot_bucket_t;

#define	SN_HASH_SIZE	64
#define	SN_HASH_MASK	(SN_HASH_SIZE - 1)

#pragma align 64(snapshot_hash)
static snapshot_bucket_t snapshot_hash[SN_HASH_SIZE];

#define	SNAPSHOT_BUCKET(h)	(&snapshot_hash[(h) & SN_HASH_MASK])

static rc_snapshot_t *
snapshot_alloc(void)
{
	rc_snapshot_t *sp;
	sp = uu_zalloc(sizeof (*sp));

	(void) pthread_mutex_init(&sp->rs_lock, NULL);
	(void) pthread_cond_init(&sp->rs_cv, NULL);

	sp->rs_refcnt++;
	return (sp);
}

static void
snapshot_free(rc_snapshot_t *sp)
{
	rc_snaplevel_t *lvl, *next;

	assert(sp->rs_refcnt == 0 && sp->rs_childref == 0);

	(void) pthread_mutex_destroy(&sp->rs_lock);
	(void) pthread_cond_destroy(&sp->rs_cv);

	for (lvl = sp->rs_levels; lvl != NULL; lvl = next) {
		next = lvl->rsl_next;

		assert(lvl->rsl_parent == sp);
		lvl->rsl_parent = NULL;

		if (lvl->rsl_service)
			free((char *)lvl->rsl_service);
		if (lvl->rsl_instance)
			free((char *)lvl->rsl_instance);

		uu_free(lvl);
	}
	uu_free(sp);
}

static void
rc_snapshot_hold(rc_snapshot_t *sp)
{
	(void) pthread_mutex_lock(&sp->rs_lock);
	sp->rs_refcnt++;
	assert(sp->rs_refcnt > 0);
	(void) pthread_mutex_unlock(&sp->rs_lock);
}

void
rc_snapshot_rele(rc_snapshot_t *sp)
{
	int done;
	(void) pthread_mutex_lock(&sp->rs_lock);
	assert(sp->rs_refcnt > 0);
	sp->rs_refcnt--;
	done = ((sp->rs_flags & RC_SNAPSHOT_DEAD) &&
	    sp->rs_refcnt == 0 && sp->rs_childref == 0);
	(void) pthread_mutex_unlock(&sp->rs_lock);

	if (done)
		snapshot_free(sp);
}

void
rc_snaplevel_hold(rc_snaplevel_t *lvl)
{
	rc_snapshot_t *sp = lvl->rsl_parent;
	(void) pthread_mutex_lock(&sp->rs_lock);
	sp->rs_childref++;
	assert(sp->rs_childref > 0);
	(void) pthread_mutex_unlock(&sp->rs_lock);
}

void
rc_snaplevel_rele(rc_snaplevel_t *lvl)
{
	int done;
	rc_snapshot_t *sp = lvl->rsl_parent;
	(void) pthread_mutex_lock(&sp->rs_lock);
	assert(sp->rs_childref > 0);
	sp->rs_childref--;
	done = ((sp->rs_flags & RC_SNAPSHOT_DEAD) &&
	    sp->rs_refcnt == 0 && sp->rs_childref == 0);
	(void) pthread_mutex_unlock(&sp->rs_lock);

	if (done)
		snapshot_free(sp);
}

static snapshot_bucket_t *
snapshot_hold_bucket(uint32_t snap_id)
{
	snapshot_bucket_t *bp = SNAPSHOT_BUCKET(snap_id);
	(void) pthread_mutex_lock(&bp->sb_lock);
	return (bp);
}

static void
snapshot_rele_bucket(snapshot_bucket_t *bp)
{
	assert(MUTEX_HELD(&bp->sb_lock));
	(void) pthread_mutex_unlock(&bp->sb_lock);
}

static rc_snapshot_t *
snapshot_lookup_unlocked(snapshot_bucket_t *bp, uint32_t snap_id)
{
	rc_snapshot_t *sp;

	assert(MUTEX_HELD(&bp->sb_lock));
	assert(bp == SNAPSHOT_BUCKET(snap_id));

	for (sp = bp->sb_head; sp != NULL; sp = sp->rs_hash_next) {
		if (sp->rs_snap_id == snap_id) {
			rc_snapshot_hold(sp);
			return (sp);
		}
	}
	return (NULL);
}

static void
snapshot_insert_unlocked(snapshot_bucket_t *bp, rc_snapshot_t *sp)
{
	assert(MUTEX_HELD(&bp->sb_lock));
	assert(bp == SNAPSHOT_BUCKET(sp->rs_snap_id));

	assert(sp->rs_hash_next == NULL);

	sp->rs_hash_next = bp->sb_head;
	bp->sb_head = sp;
}

static void
snapshot_remove_unlocked(snapshot_bucket_t *bp, rc_snapshot_t *sp)
{
	rc_snapshot_t **spp;

	assert(MUTEX_HELD(&bp->sb_lock));
	assert(bp == SNAPSHOT_BUCKET(sp->rs_snap_id));

	assert(sp->rs_hash_next == NULL);

	for (spp = &bp->sb_head; *spp != NULL; spp = &(*spp)->rs_hash_next)
		if (*spp == sp)
			break;

	assert(*spp == sp);
	*spp = sp->rs_hash_next;
	sp->rs_hash_next = NULL;
}

/*
 * Look up the snapshot with id snap_id in the hash table, or create it
 * & populate it with its snaplevels if it's not in the hash table yet.
 *
 * Fails with
 *   _NO_RESOURCES
 */
int
rc_snapshot_get(uint32_t snap_id, rc_snapshot_t **snpp)
{
	snapshot_bucket_t *bp;
	rc_snapshot_t *sp;
	int r;

	bp = snapshot_hold_bucket(snap_id);
	sp = snapshot_lookup_unlocked(bp, snap_id);
	if (sp != NULL) {
		snapshot_rele_bucket(bp);
		(void) pthread_mutex_lock(&sp->rs_lock);
		while (sp->rs_flags & RC_SNAPSHOT_FILLING)
			(void) pthread_cond_wait(&sp->rs_cv, &sp->rs_lock);

		if (sp->rs_flags & RC_SNAPSHOT_DEAD) {
			(void) pthread_mutex_unlock(&sp->rs_lock);
			rc_snapshot_rele(sp);
			return (REP_PROTOCOL_FAIL_NO_RESOURCES);
		}
		assert(sp->rs_flags & RC_SNAPSHOT_READY);
		(void) pthread_mutex_unlock(&sp->rs_lock);
		*snpp = sp;
		return (REP_PROTOCOL_SUCCESS);
	}
	sp = snapshot_alloc();
	sp->rs_snap_id = snap_id;
	sp->rs_flags |= RC_SNAPSHOT_FILLING;
	snapshot_insert_unlocked(bp, sp);
	snapshot_rele_bucket(bp);

	/*
	 * Now fill in the snapshot tree
	 */
	r = object_fill_snapshot(sp);
	if (r != REP_PROTOCOL_SUCCESS) {
		assert(r == REP_PROTOCOL_FAIL_NO_RESOURCES);

		/*
		 * failed -- first remove it from the hash table, then kill it
		 */
		bp = snapshot_hold_bucket(snap_id);
		snapshot_remove_unlocked(bp, sp);
		snapshot_rele_bucket(bp);

		(void) pthread_mutex_lock(&sp->rs_lock);
		sp->rs_flags &= ~RC_SNAPSHOT_FILLING;
		sp->rs_flags |= RC_SNAPSHOT_DEAD;
		(void) pthread_cond_broadcast(&sp->rs_cv);
		(void) pthread_mutex_unlock(&sp->rs_lock);
		rc_snapshot_rele(sp);		/* may free sp */
		return (r);
	}
	(void) pthread_mutex_lock(&sp->rs_lock);
	sp->rs_flags &= ~RC_SNAPSHOT_FILLING;
	sp->rs_flags |= RC_SNAPSHOT_READY;
	(void) pthread_cond_broadcast(&sp->rs_cv);
	(void) pthread_mutex_unlock(&sp->rs_lock);
	*snpp = sp;
	return (REP_PROTOCOL_SUCCESS);		/* pass on creation reference */
}