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

#include <elf.h>
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <fcntl.h>
#include <procfs.h>
#include <string.h>
#include <sys/stat.h>

#if defined(__sparcv9) || defined(__amd64)

#define Elf_Ehdr	Elf64_Ehdr
#define Elf_Phdr	Elf64_Phdr
#define Elf_Shdr	Elf64_Shdr
#define Elf_Sym		Elf64_Sym
#define ELF_ST_BIND	ELF64_ST_BIND
#define ELF_ST_TYPE	ELF64_ST_TYPE

#else

#define Elf_Ehdr	Elf32_Ehdr
#define Elf_Phdr	Elf32_Phdr
#define Elf_Shdr	Elf32_Shdr
#define Elf_Sym		Elf32_Sym
#define ELF_ST_BIND	ELF32_ST_BIND
#define ELF_ST_TYPE	ELF32_ST_TYPE

#endif	/* __sparcv9 */

/* semi-permanent data established by __fex_sym_init */
static	prmap_t		*pm = NULL;		/* prmap_t array */
static	int			npm = 0;		/* number of entries in pm */

/* transient data modified by __fex_sym */
static	prmap_t		*lpm = NULL;	/* prmap_t found in last call */
static	Elf_Phdr	*ph = NULL;		/* program header array */
static	int			phsize = 0;		/* size of ph */
static	int			nph;			/* number of entries in ph */
static	char		*stbuf = NULL;	/* symbol and string table buffer */
static	int			stbufsize = 0;	/* size of stbuf */
static	int			stoffset;		/* offset of string table in stbuf */
static	int			nsyms;			/* number of symbols in stbuf */

/* get a current prmap_t list (must call this before each stack trace) */
void
__fex_sym_init()
{
	struct stat	statbuf;
	long		n;
	int			i;

	/* clear out the previous prmap_t list */
	if (pm != NULL)
		free(pm);
	pm = lpm = NULL;
	npm = 0;

	/* get the current prmap_t list */
	if (stat("/proc/self/map", &statbuf) < 0 || statbuf.st_size <= 0 ||
		(pm = (prmap_t*)malloc(statbuf.st_size)) == NULL)
		return;
	if ((i = open("/proc/self/map", O_RDONLY)) < 0)
	{
		free(pm);
		pm = NULL;
		return;
	}
	n = read(i, pm, statbuf.st_size);
	close(i);
	if (n != statbuf.st_size)
	{
		free(pm);
		pm = NULL;
	}
	else
		npm = (int) (n / sizeof(prmap_t));
}

/* read ELF program headers and symbols; return -1 on error, 0 otherwise */
static int
__fex_read_syms(int fd)
{
	Elf_Ehdr	h;
	Elf_Shdr	*sh;
	int			i, size;

	/* read the ELF header */
	if (read(fd, &h, sizeof(h)) != sizeof(h))
		return -1;
	if (h.e_ident[EI_MAG0] != ELFMAG0 ||
		h.e_ident[EI_MAG1] != ELFMAG1 ||
		h.e_ident[EI_MAG2] != ELFMAG2 ||
		h.e_ident[EI_MAG3] != ELFMAG3 ||
		h.e_phentsize != sizeof(Elf_Phdr) ||
		h.e_shentsize != sizeof(Elf_Shdr))
		return -1;

	/* get space for the program headers */
	size = h.e_phnum * h.e_phentsize;
	if (size > phsize)
	{
		if (ph)
			free(ph);
		phsize = nph = 0;
		if ((ph = (Elf_Phdr*)malloc(size)) == NULL)
			return -1;
		phsize = size;
	}

	/* read the program headers */
	if (lseek(fd, h.e_phoff, SEEK_SET) != h.e_phoff ||
		read(fd, ph, size) != (ssize_t)size)
	{
		nph = 0;
		return -1;
	}
	nph = h.e_phnum;

	/* read the section headers */
	size = h.e_shnum * h.e_shentsize;
	if ((sh = (Elf_Shdr*)malloc(size)) == NULL)
		return -1;
	if (lseek(fd, h.e_shoff, SEEK_SET) != h.e_shoff ||
		read(fd, sh, size) != (ssize_t)size)
	{
		free(sh);
		return -1;
	}

	/* find the symtab section header */
	for (i = 0; i < h.e_shnum; i++)
	{
		if (sh[i].sh_type == SHT_SYMTAB)
			break; /* assume there is only one */
	}
	if (i == h.e_shnum || sh[i].sh_size == 0 ||
		sh[i].sh_entsize != sizeof(Elf_Sym) ||
		sh[i].sh_link < 1 || sh[i].sh_link >= h.e_shnum ||
		sh[sh[i].sh_link].sh_type != SHT_STRTAB ||
		sh[sh[i].sh_link].sh_size == 0)
	{
		free(sh);
		return -1;
	}

	/* get space for the symbol and string tables */
	size = (int) (sh[i].sh_size + sh[sh[i].sh_link].sh_size);
	if (size > stbufsize)
	{
		if (stbuf)
			free(stbuf);
		stbufsize = nsyms = 0;
		if ((stbuf = (char*)malloc(size)) == NULL)
		{
			free(sh);
			return -1;
		}
		stbufsize = size;
	}

	/* read the symbol and string tables */
	if (lseek(fd, sh[i].sh_offset, SEEK_SET) != sh[i].sh_offset ||
		read(fd, stbuf, sh[i].sh_size) != sh[i].sh_size ||
		lseek(fd, sh[sh[i].sh_link].sh_offset, SEEK_SET) !=
			sh[sh[i].sh_link].sh_offset ||
		read(fd, stbuf + sh[i].sh_size, sh[sh[i].sh_link].sh_size) !=
			sh[sh[i].sh_link].sh_size)
	{
		free(sh);
		return (-1);
	}
	nsyms = (int) (sh[i].sh_size / sh[i].sh_entsize);
	stoffset = (int) sh[i].sh_size;

	free(sh);
	return (0);
}

/* find the symbol corresponding to the given text address;
   return NULL on error, symbol address otherwise */
char *
__fex_sym(char *a, char **name)
{
	Elf_Sym			*s;
	unsigned long	fo, va, value;
	int				fd, i, j, nm;
	char			fname[PRMAPSZ+20];

	/* see if the last prmap_t found contains the indicated address */
	if (lpm)
	{
		if (a >= (char*)lpm->pr_vaddr && a < (char*)lpm->pr_vaddr +
			lpm->pr_size)
			goto cont;
	}

	/* look for a prmap_t that contains the indicated address */
	for (i = 0; i < npm; i++)
	{
		if (a >= (char*)pm[i].pr_vaddr && a < (char*)pm[i].pr_vaddr +
			pm[i].pr_size)
			break;
	}
	if (i == npm)
		return NULL;

	/* get an open file descriptor for the mapped object */
	if (pm[i].pr_mapname[0] == '\0')
		return NULL;
	strcpy(fname, "/proc/self/object/");
	strncat(fname, pm[i].pr_mapname, PRMAPSZ);
	fd = open(fname, O_RDONLY);
	if (fd < 0)
		return NULL;

	/* read the program headers and symbols */
	lpm = NULL;
	j = __fex_read_syms(fd);
	close(fd);
	if (j < 0)
		return NULL;
	lpm = &pm[i];

cont:
	/* compute the file offset corresponding to the mapped address */
	fo = (a - (char*)lpm->pr_vaddr) + lpm->pr_offset;

	/* find the program header containing the file offset */
	for (i = 0; i < nph; i++)
	{
		if (ph[i].p_type == PT_LOAD && fo >= ph[i].p_offset &&
			fo < ph[i].p_offset + ph[i].p_filesz)
			break;
	}
	if (i == nph)
		return NULL;

	/* compute the virtual address corresponding to the file offset */
	va = (fo - ph[i].p_offset) + ph[i].p_vaddr;

	/* find the symbol in this segment with the highest value
	   less than or equal to the virtual address */
	s = (Elf_Sym*)stbuf;
	value = nm = 0;
	for (j = 0; j < nsyms; j++)
	{
		if (s[j].st_name == 0 || s[j].st_shndx == SHN_UNDEF ||
			(ELF_ST_BIND(s[j].st_info) != STB_LOCAL &&
			ELF_ST_BIND(s[j].st_info) != STB_GLOBAL &&
			ELF_ST_BIND(s[j].st_info) != STB_WEAK) ||
			(ELF_ST_TYPE(s[j].st_info) != STT_NOTYPE &&
			ELF_ST_TYPE(s[j].st_info) != STT_OBJECT &&
			ELF_ST_TYPE(s[j].st_info) != STT_FUNC))
		{
			continue;
		}

		if (s[j].st_value < ph[i].p_vaddr || s[j].st_value >= ph[i].p_vaddr
			+ ph[i].p_memsz)
		{
			continue;
		}

		if (s[j].st_value < value || s[j].st_value > va)
			continue;

		value = s[j].st_value;
		nm = s[j].st_name;
	}
	if (nm == 0)
		return NULL;

	/* pass back the name and return the mapped address of the symbol */
	*name = stbuf + stoffset + nm;
	fo = (value - ph[i].p_vaddr) + ph[i].p_offset;
	return (char*)lpm->pr_vaddr + (fo - lpm->pr_offset);
}