/*
 * 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 2006 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 */

#include <stdlib.h>
#include <stdio.h>
#include "nscd_db.h"
#include "nscd_log.h"

static rwlock_t		addrDB_rwlock = DEFAULTRWLOCK;
static nscd_db_t	*addrDB = NULL;

/*
 * internal structure representing a nscd internal address
 */
typedef struct nscd_int_addr {
	int		to_delete;	/* no longer valid */
	int		type;
	void		*ptr;
	nscd_seq_num_t	seq_num;
	rwlock_t	rwlock;		/* used to serialize get and destroy */
} nscd_int_addr_t;

/*
 * FUNCTION: _nscd_create_int_addrDB
 *
 * Create the internal address database to keep track of the
 * memory allocated by _nscd_alloc.
 */
void *
_nscd_create_int_addrDB()
{

	nscd_db_t	*ret;
	char		*me = "_nscd_create_int_addrDB";

	_NSCD_LOG(NSCD_LOG_INT_ADDR | NSCD_LOG_CONFIG, NSCD_LOG_LEVEL_DEBUG)
	(me, "initializing the internal address database\n");

	(void) rw_wrlock(&addrDB_rwlock);

	if (addrDB != NULL) {
		(void) rw_unlock(&addrDB_rwlock);
		return (addrDB);
	}

	ret = _nscd_alloc_db(NSCD_DB_SIZE_LARGE);

	if (ret != NULL)
		addrDB = ret;

	(void) rw_unlock(&addrDB_rwlock);

	return (ret);
}

/*
 * FUNCTION: _nscd_add_int_addr
 *
 * Add an address of 'type' to the internal address database.
 */
nscd_rc_t
_nscd_add_int_addr(
	void		*ptr,
	int		type,
	nscd_seq_num_t	seq_num)
{
	int		size;
	char		buf[2 * sizeof (ptr) + 1];
	nscd_db_entry_t	*db_entry;
	nscd_int_addr_t	*int_addr;

	if (ptr == NULL)
		return (NSCD_INVALID_ARGUMENT);

	(void) snprintf(buf, sizeof (buf), "%p", ptr);

	size = sizeof (*int_addr);

	db_entry = _nscd_alloc_db_entry(NSCD_DATA_ADDR,
			(const char *)buf, size, 1, 1);
	if (db_entry == NULL)
		return (NSCD_NO_MEMORY);

	int_addr = (nscd_int_addr_t *)*(db_entry->data_array);
	int_addr->ptr = ptr;
	int_addr->type = type;
	int_addr->seq_num = seq_num;
	(void) rwlock_init(&int_addr->rwlock, USYNC_THREAD, NULL);

	(void) rw_wrlock(&addrDB_rwlock);
	(void) _nscd_add_db_entry(addrDB, buf, db_entry,
		NSCD_ADD_DB_ENTRY_FIRST);
	(void) rw_unlock(&addrDB_rwlock);

	return (NSCD_SUCCESS);
}

/*
 * FUNCTION: _nscd_is_int_addr
 *
 * Check to see if an address can be found in the internal
 * address database, if so, obtain a reader lock on the
 * associated rw_lock. The caller needs to unlock it when
 * done using the data.
 */
rwlock_t *
_nscd_is_int_addr(
	void			*ptr,
	nscd_seq_num_t		seq_num)
{
	char			*me = "_nscd_is_int_addr";
	char			ptrstr[1 + 2 * sizeof (ptr)];
	rwlock_t		*addr_rwlock;
	const nscd_db_entry_t	*db_entry;

	if (ptr == NULL)
		return (NULL);

	(void) snprintf(ptrstr, sizeof (ptrstr), "%p", ptr);

	(void) rw_rdlock(&addrDB_rwlock);

	db_entry = _nscd_get_db_entry(addrDB, NSCD_DATA_ADDR,
		(const char *)ptrstr, NSCD_GET_FIRST_DB_ENTRY, 0);

	if (db_entry != NULL) {
		nscd_int_addr_t *int_addr;

		int_addr = (nscd_int_addr_t *)*(db_entry->data_array);
		addr_rwlock = &int_addr->rwlock;
		(void) rw_rdlock(addr_rwlock);

		/*
		 * If the data is marked as to be deleted
		 * or the sequence number does not match,
		 * return NULL.
		 */
		if (int_addr->to_delete == 1 ||
			int_addr->seq_num != seq_num) {
			(void) rw_unlock(addr_rwlock);
			addr_rwlock = NULL;
		}

		_NSCD_LOG(NSCD_LOG_INT_ADDR, NSCD_LOG_LEVEL_DEBUG)
		(me, "found %p, seq# = %lld\n", ptr, int_addr->seq_num);
	} else
		addr_rwlock = NULL;

	(void) rw_unlock(&addrDB_rwlock);

	return (addr_rwlock);
}

/*
 * FUNCTION: _nscd_del_int_addr
 *
 * Delete an address from the internal address database.
 */
void
_nscd_del_int_addr(
	void		*ptr,
	nscd_seq_num_t	seq_num)
{
	char			*me = "_nscd_del_int_addr";
	char			ptrstr[1 + 2 * sizeof (ptr)];
	rwlock_t		*addr_rwlock;
	nscd_int_addr_t		*int_addr;
	const nscd_db_entry_t	*db_entry;

	if (ptr == NULL)
		return;

	_NSCD_LOG(NSCD_LOG_INT_ADDR, NSCD_LOG_LEVEL_DEBUG)
	(me, "deleting int addr %p (%d)\n", ptr, seq_num);
	(void) snprintf(ptrstr, sizeof (ptrstr), "%p", ptr);

	(void) rw_rdlock(&addrDB_rwlock);
	/*
	 * first find the db entry and make sure that
	 * no one is currently locking it. i.e.,
	 * no one is waiting to use the same address.
	 * If it is locked, rw_wrlock() will not return
	 * until it is unlocked.
	 */
	db_entry = _nscd_get_db_entry(addrDB,
		NSCD_DATA_ADDR,
		(const char *)ptrstr,
		NSCD_GET_FIRST_DB_ENTRY, 0);
	if (db_entry != NULL) {
		int_addr = (nscd_int_addr_t *)*(db_entry->data_array);
		addr_rwlock = &int_addr->rwlock;
		(void) rw_wrlock(addr_rwlock);
	} else {
		(void) rw_unlock(&addrDB_rwlock);
		return;
	}
	(void) rw_unlock(&addrDB_rwlock);

	/*
	 * delete the db entry if the sequence numbers match
	 */
	if (int_addr->seq_num == seq_num) {
		(void) rw_wrlock(&addrDB_rwlock);
		(void) _nscd_delete_db_entry(addrDB,
			NSCD_DATA_ADDR,
			(const char *)ptrstr,
			NSCD_DEL_FIRST_DB_ENTRY, 0);
		(void) rw_unlock(&addrDB_rwlock);
	}
}

/*
 * FUNCTION: _nscd_destroy_int_addrDB
 *
 * Destroy the internal address database.
 */
void
_nscd_destroy_int_addrDB()
{
	(void) rw_wrlock(&addrDB_rwlock);
	_nscd_free_db(addrDB);
	addrDB = NULL;
	(void) rw_unlock(&addrDB_rwlock);
}