/*
 * 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 (c) 1996, 2010, Oracle and/or its affiliates. All rights reserved.
 */
#include	<link.h>
#include	<stdlib.h>
#include	<unistd.h>
#include	<sys/types.h>
#include	<sys/stat.h>
#include	<sys/regset.h>
#include	<sys/frame.h>
#include	<sys/lwp.h>
#include	<fcntl.h>
#include	<stdio.h>
#include	<sys/mman.h>
#include	<errno.h>
#include	<signal.h>
#include	<synch.h>
#include	<string.h>

#include	"bindings.h"
#include	"env.h"

static Elist		*bindto_list = NULL;
static Elist		*bindfrom_list = NULL;

static bindhead		*bhp = NULL;
static unsigned int	current_map_len = 0;
static char		*buffer_name;
static const sigset_t	iset = { ~0U, ~0U, ~0U, ~0U };
static lwp_mutex_t	sharedmutex = SHAREDMUTEX;

/*
 * This routine was stolen from libelf.so.1
 */
static unsigned long
ehash(const char *name)
{
	unsigned int		g, h = 0;
	const unsigned char	*nm = (unsigned char *)name;

	while (*nm != '\0') {
		h = (h << 4) + *nm++;
		/* LINTED */
		if ((g = (unsigned int)(h & MASK)) != 0)
			h ^= g >> 24;
		h &= ~MASK;
	}
	return ((unsigned long)h);
}


static void
output_err_message(const char *msg)
{
	int fd;
	if ((fd = open("/tmp/bind_err", O_RDWR | O_CREAT, 0666)) == -1) {
		(void) fprintf(stderr, "bindings.so: unable to open err_log\n");
		perror("open");
	}
	(void) lseek(fd, 0, SEEK_END);
	(void) write(fd, msg, strlen(msg));
	(void) close(fd);
}

/*
 * common mutex locking & unlocking routines for this module.  This is to
 * control the setting of 'lock_held'.
 */
static void
bt_lock(lwp_mutex_t *lock)
{
	if (_lwp_mutex_lock(lock) != 0) {
		output_err_message("bt_lock failed!!\n");
		(void) fprintf(stderr, "bindings.so: unable to obtain lock\n");
		perror("_lwp_mutex_lock");
	}
}

static void
bt_unlock(lwp_mutex_t *lock)
{
	if (_lwp_mutex_unlock(lock) != 0) {
		output_err_message("bt_unlock failed!!\n");
		(void) fprintf(stderr, "bindings.so: unable to unlock lock\n");
		perror("_lwp_mutex_unlock");
	}
}



/*
 * It's always possible that another process sharing our buffer
 * has caused it to grow.  If this is the case we must adjust our
 * mappings to compensate.
 */
static void
remap_buffer(int fd)
{
	void *	new_bhp;
	if ((new_bhp = mmap(0, bhp->bh_size, PROT_READ | PROT_WRITE,
	    MAP_SHARED, fd, 0)) == MAP_FAILED) {
		(void) fprintf(stderr, "bindings: remap: mmap failed\n");
		perror("mmap");

		bt_unlock(&bhp->bh_lock);
		exit(1);
	}
	/*
	 * clean up old mapping
	 */
	(void) munmap((caddr_t)bhp, current_map_len);
	bhp = (bindhead *)new_bhp;
	current_map_len = bhp->bh_size;
}

static void
grow_buffer(void)
{
	int	fd;
	if ((fd = open(buffer_name, O_RDWR)) == -1) {
		(void) fprintf(stderr,
		    "bidings: grow_buffer: open failed: %s\n", buffer_name);
		perror("open");
		bt_unlock(&bhp->bh_lock);
		exit(1);
	}
	if (ftruncate(fd, bhp->bh_size + BLKSIZE) == -1) {
		(void) fprintf(stderr, "grow_buffer failed\n");
		perror("ftruncate");
		bt_unlock(&bhp->bh_lock);
		exit(1);
	}
	bhp->bh_size += BLKSIZE;
	remap_buffer(fd);
	(void) close(fd);
}

static void
get_new_strbuf(void)
{
	bt_lock(&bhp->bh_lock);
	while (bhp->bh_end + STRBLKSIZE > bhp->bh_size)
		grow_buffer();

	bhp->bh_strcur = bhp->bh_end;
	bhp->bh_end = bhp->bh_strend = bhp->bh_strcur + STRBLKSIZE;
	bt_unlock(&bhp->bh_lock);
}

static unsigned int
save_str(const char *str)
{
	char		*sptr;
	unsigned int	bptr;
	unsigned int	slen;

	bt_lock(&bhp->bh_strlock);
	/* LINTED */
	slen = (unsigned int)strlen(str);

	/*
	 * will string fit into our current string buffer?
	 */
	if ((slen + 1) > (bhp->bh_strend - bhp->bh_strcur))
		get_new_strbuf();
	bptr = bhp->bh_strcur;
	sptr = (char *)bhp + bhp->bh_strcur;
	bhp->bh_strcur += slen + 1;
	(void) strncpy(sptr, str, slen);
	sptr[slen] = '\0';
	bt_unlock(&bhp->bh_strlock);
	return (bptr);
}


static unsigned int
get_new_entry(void)
{
	unsigned int	new_ent;
	bt_lock(&bhp->bh_lock);
	while ((sizeof (binding_entry) + bhp->bh_end) > bhp->bh_size)
		grow_buffer();
	new_ent = bhp->bh_end;
	bhp->bh_end += sizeof (binding_entry);
	bt_unlock(&bhp->bh_lock);
	return (new_ent);
}



static void
init_locks(void)
{
	int i;

	(void) memcpy(&bhp->bh_lock, &sharedmutex, sizeof (lwp_mutex_t));
	for (i = 0; i < DEFBKTS; i++)
		(void) memcpy(&bhp->bh_bkts[i].bb_lock, &sharedmutex,
		    sizeof (lwp_mutex_t));

	(void) memcpy(&bhp->bh_strlock, &sharedmutex, sizeof (lwp_mutex_t));
}

uint_t
la_version(uint_t version)
{
	int	fd;
	sigset_t	omask;

	if (version < LAV_CURRENT) {
		(void) fprintf(stderr,
		    "bindings.so: unexpected link_audit version: %d\n",
		    version);
		return (0);
	}

	build_env_list(&bindto_list, (const char *)"BT_BINDTO");
	build_env_list(&bindfrom_list, (const char *)"BT_BINDFROM");

	if ((buffer_name = getenv(FILEENV)) == NULL)
		buffer_name = DEFFILE;

	(void) sigprocmask(SIG_BLOCK, &iset, &omask);
	if ((fd = open(buffer_name, O_RDWR | O_CREAT | O_EXCL, 0666)) != -1) {
		int	init_size = sizeof (bindhead) + BLKSIZE;

		if (ftruncate(fd, init_size) == -1) {
			perror("ftruncate");
			return (0);
		}

		/* LINTED */
		if ((bhp = (bindhead *)mmap(0, init_size,
		    PROT_READ | PROT_WRITE,
		    MAP_SHARED, fd, 0)) == MAP_FAILED) {
			perror("bindings.so: mmap");
			return (0);
		}

		(void) close(fd);

		init_locks();
		/*
		 * Lock our structure and then initialize the data
		 */
		bt_lock(&bhp->bh_lock);
		bhp->bh_vers = BINDCURVERS;
		current_map_len = bhp->bh_size = init_size;
		bhp->bh_end = sizeof (bindhead);
		bhp->bh_bktcnt = DEFBKTS;
		bt_unlock(&bhp->bh_lock);
		/*
		 * Set up our initial string buffer
		 */
		get_new_strbuf();
	} else if ((fd = open(buffer_name, O_RDWR)) != -1) {
		struct stat	stbuf;
		int		i;
		for (i = 0; i < 4; i++) {
			if (fstat(fd, &stbuf) == -1) {
				(void) sleep(1);
				continue;
			}
			if (stbuf.st_size < sizeof (bindhead)) {
				(void) sleep(1);
				continue;
			}
			/* LINTED */
			if ((bhp = (bindhead *)mmap(0, stbuf.st_size,
			    PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0)) ==
			    MAP_FAILED) {
				(void) fprintf(stderr,
				    "bindings: mmap failed\n");
				perror("mmap");
				return (0);
			}

			/* LINTED */
			current_map_len = (unsigned int)stbuf.st_size;
		}
		if (bhp == NULL) {
			(void) fprintf(stderr,
			    "bindings: buffer mapping timed out\n");
			return (0);
		}
		for (i = 0; i < 4; i++) {
			if (bhp->bh_vers == 0) {
				(void) sleep(1);
				continue;
			}
		}
		if (bhp->bh_vers == 0) {
			(void) fprintf(stderr,
			    "bindings: %s not initialized\n", buffer_name);
			return (0);
		}

		bt_lock(&bhp->bh_lock);

		if (bhp->bh_size != current_map_len)
			remap_buffer(fd);
		(void) close(fd);
	} else {
		(void) fprintf(stderr, "bindings: unable to open %s\n",
		    buffer_name);
		perror("open");
		return (0);
	}

	(void) sigprocmask(SIG_SETMASK, &omask, NULL);
	bt_unlock(&bhp->bh_lock);

	return (LAV_CURRENT);
}

/* ARGSUSED 0 */
uint_t
la_objopen(Link_map *lmp, Lmid_t lmid, uintptr_t *cookie)
{
	uint_t	flags;

	if ((bindto_list == NULL) ||
	    (check_list(bindto_list, lmp->l_name)))
		flags = LA_FLG_BINDTO;
	else
		flags = 0;

	if ((bindfrom_list == NULL) ||
	    (check_list(bindfrom_list, lmp->l_name)))
		flags |= LA_FLG_BINDFROM;

	return (flags);
}


/* ARGSUSED 1 */
#if	defined(__sparcv9)
uintptr_t
la_sparcv9_pltenter(Elf64_Sym *symp, uint_t symndx, uintptr_t *refcooke,
	uintptr_t *defcook, La_sparcv9_regs *regset, uint_t *sb_flags,
	const char *sym_name)
#elif	defined(__sparc)
uintptr_t
la_sparcv8_pltenter(Elf32_Sym *symp, uint_t symndx, uintptr_t *refcooke,
	uintptr_t *defcook, La_sparcv8_regs *regset, uint_t *sb_flags)
#elif	defined(__amd64)
uintptr_t
la_amd64_pltenter(Elf64_Sym *symp, uint_t symndx, uintptr_t *refcooke,
	uintptr_t *defcook, La_amd64_regs *regset, uint_t *sb_flags,
	const char *sym_name)
#elif	defined(__i386)
uintptr_t
la_i86_pltenter(Elf32_Sym *symp, uint_t symndx, uintptr_t *refcooke,
	uintptr_t *defcook, La_i86_regs *regset, uint_t *sb_flags)
#endif
{
	unsigned long	bktno;
	Link_map	*dlmp = (Link_map *)*defcook;
	const char	*lib_name;
	sigset_t	omask;
#if	!defined(_LP64)
	const char	*sym_name = (const char *)symp->st_name;
#endif


	lib_name = dlmp->l_name;

	(void) sigprocmask(SIG_BLOCK, &iset, &omask);
	if (sym_name == NULL) {
		output_err_message("null symname\n");
		return (symp->st_value);
	}

	bktno = ehash(sym_name) % bhp->bh_bktcnt;

	bt_lock(&bhp->bh_bkts[bktno].bb_lock);

	/*
	 * The buffer has been grown (by another process) and
	 * we need to remap it into memory.
	 */
	if (bhp->bh_size != current_map_len) {
		int fd;
		if ((fd = open(buffer_name, O_RDWR)) == -1) {
			(void) fprintf(stderr,
				"bidings: plt_enter: open failed: %s\n",
				buffer_name);
			perror("open");
			bt_unlock(&bhp->bh_lock);
			exit(1);
		}
		bt_lock(&bhp->bh_lock);
		remap_buffer(fd);
		bt_unlock(&bhp->bh_lock);
		(void) close(fd);
	}

	if (bhp->bh_bkts[bktno].bb_head == NULL) {
		binding_entry *	bep;
		unsigned int	be_off;
		unsigned int	sym_off;
		unsigned int	lib_off;

		be_off = get_new_entry();
		sym_off = save_str(sym_name);
		lib_off = save_str(lib_name);
		/* LINTED */
		bep = (binding_entry *)((char *)bhp + be_off);
		bep->be_next = 0;
		bep->be_sym_name = sym_off;
		bep->be_lib_name = lib_off;
		bep->be_count = 1;
		bhp->bh_bkts[bktno].bb_head = be_off;
	} else {
		int		strcmp_res;
		unsigned int	prev_off = 0;
		binding_entry	*prev_bep = NULL;
		unsigned int	cur_off;
		binding_entry	*cur_bep;
		unsigned int	lib_off = 0;

		/*
		 * Once we get to the bucket, we do a two tiered
		 * search.  First we search for a library match, then
		 * we search for a symbol match.
		 */
		cur_off = bhp->bh_bkts[bktno].bb_head;
		/* LINTED */
		cur_bep = (binding_entry *)((char *)bhp +
			cur_off);
		while (cur_off && (strcmp_res = strcmp((char *)bhp +
		    cur_bep->be_lib_name, lib_name)) < 0) {
			prev_off = cur_off;
			cur_off = cur_bep->be_next;
			/* LINTED */
			cur_bep = (binding_entry *)((char *)bhp +
				cur_off);
		}
		if (cur_off && (strcmp_res == 0)) {
			/*
			 * This is a small optimization.  For
			 * each bucket we will only record a library
			 * name once.  Once it has been recorded in
			 * a bucket we will just re-use the same
			 * string.
			 */
			lib_off = cur_bep->be_lib_name;
			while (cur_off && (strcmp_res = strcmp((char *)bhp +
			    cur_bep->be_sym_name, sym_name)) < 0) {
				prev_off = cur_off;
				cur_off = cur_bep->be_next;
				/* LINTED */
				cur_bep = (binding_entry *)((char *)bhp +
					cur_off);
			}
		}
		if (strcmp_res == 0) {
			/*
			 * We've got a match
			 */
			cur_bep->be_count++;
		} else {
			unsigned int	new_off;
			binding_entry *	new_bep;
			unsigned int	sym_off;

			new_off = get_new_entry();
			if (lib_off == 0)
				lib_off = save_str(lib_name);
			sym_off = save_str(sym_name);

			/* LINTED */
			new_bep = (binding_entry *)((char *)bhp +
				new_off);
			new_bep->be_sym_name = sym_off;
			new_bep->be_lib_name = lib_off;
			new_bep->be_count = 1;
			new_bep->be_next = cur_off;
			if (prev_off) {
				/* LINTED */
				prev_bep = (binding_entry *)((char *)bhp +
					prev_off);
				prev_bep->be_next = new_off;
			} else
				/*
				 * Insert at head of list.
				 */
				bhp->bh_bkts[bktno].bb_head = new_off;

		}
	}
	bt_unlock(&bhp->bh_bkts[bktno].bb_lock);
	(void) sigprocmask(SIG_SETMASK, &omask, NULL);
	return (symp->st_value);
}