#define _XOPEN_SOURCE 500
#define _GNU_SOURCE // for MAP_32BIT

#include <stdio.h>
#include <unistd.h>
#include <fcntl.h>
#include <stdlib.h>
#include <string.h>
#include <sys/mman.h>
#include <errno.h>
#include <assert.h>

#include "vx32.h"
#include "vx32impl.h"

extern int vx_elfbigmem;

typedef struct vxmem_chunk vxmem_chunk;

struct vxmem_chunk {
	vxmem mem;
	int fd;
	off_t size;
	uint8_t *perm;
};

static void chunk_free(vxmem *mem)
{
	vxmem_chunk *chunk = (vxmem_chunk*)mem;

	if(mem->mapped){
		vxmem_unmap(mem, mem->mapped);
		mem->mapped = NULL;
	}

	free(chunk->perm);
	close(chunk->fd);
	free(chunk);
}

static int chunk_resize(vxmem *mem, size_t size)
{
	vxmem_chunk *chunk = (vxmem_chunk*)mem;
	uint8_t *perm;
	uint32_t onpage, npage;

	if(size == chunk->size)
		return 0;

	if(mem->mapped){
		assert(!vx_elfbigmem);
		vxmem_unmap(mem, mem->mapped);
		mem->mapped = NULL;
	}

	if(ftruncate(chunk->fd, size) < 0)
		return -1;
	onpage = VXPAGEROUND(chunk->size) / VXPAGESIZE;
	npage = VXPAGEROUND(size) / VXPAGESIZE;
	perm = realloc(chunk->perm, npage);
	if (perm == NULL)
		return -1;
	if(npage > onpage)
		memset(perm + onpage, 0, npage-onpage);
	chunk->perm = perm;
	chunk->size = size;
	return 0;
}	

vxmem *vxmem_chunk_copy(vxmem *mem)
{
	vxmem_chunk *chunk = (vxmem_chunk*)mem;
	uint8_t *perm;
	uint32_t i, npage;

	assert(mem->free == chunk_free);
	vxmem *nmem = vxmem_chunk_new(chunk->size);
	if (nmem == NULL)
		return NULL;
	npage = VXPAGEROUND(chunk->size) / VXPAGESIZE;
	int n = 0;
	vxmem_chunk *nchunk = (vxmem_chunk*)nmem;
	char *buf = malloc(4096);
	memmove(nchunk->perm, chunk->perm, npage);
	for (i=0; i<npage; i++) {
		if (nchunk->perm[i]) {
			vxmem_read(mem, buf, i*VXPAGESIZE, VXPAGESIZE);
			vxmem_write(nmem, buf, i*VXPAGESIZE, VXPAGESIZE);
			n++;
		}
	}
	free(buf);
	return nmem;
}

static ssize_t chunk_read(vxmem *mem, void *data, uint32_t addr, uint32_t len)
{
	vxmem_chunk *chunk = (vxmem_chunk*)mem;
	
	if (addr >= chunk->size)
		return -1;
	if (len > chunk->size - addr)
		len = chunk->size - addr;
	return pread(chunk->fd, data, len, addr);
}

static ssize_t chunk_write(vxmem *mem, const void *data, uint32_t addr, uint32_t len)
{
	vxmem_chunk *chunk = (vxmem_chunk*)mem;
	
	if (addr >= chunk->size)
		return -1;
	if (len > chunk->size - addr)
		len = chunk->size - addr;
	return pwrite(chunk->fd, data, len, addr);
}

static int chunk_checkperm(vxmem *mem, uint32_t addr, uint32_t len, uint32_t perm, uint32_t *out_faultva)
{
	uint32_t pn, pe, cpe, va;
	vxmem_chunk *chunk = (vxmem_chunk*)mem;
	
	if (addr + len < addr)
		return 0;
	if (len == 0)
		return 1;
	pn = addr / VXPAGESIZE;
	pe = VXPAGEROUND(addr + len-1) / VXPAGESIZE;
	cpe = VXPAGEROUND(chunk->size) / VXPAGESIZE;
	for (; pn < pe; pn++) {
		if (pn >= cpe) {
			if (out_faultva)
				*out_faultva = chunk->size;
			return 0;
		}
		if ((chunk->perm[pn] & perm) != perm) {
			if (out_faultva) {
				va = pn * VXPAGESIZE;
				if (va < addr)
					va = addr;
				*out_faultva = va;
			}
			return 0;
		}
	}
	return 1;
}

static int mmperm(int perm)
{
	int m;
	
	if (perm == 0)
		m = PROT_NONE;
	else {
		m = 0;
		if (perm & VXPERM_READ)
			m |= PROT_READ;
		if (perm & VXPERM_WRITE)
			m |= PROT_WRITE;
		if (perm & VXPERM_EXEC)
			m |= PROT_EXEC;
	}
	return m;
}

static int chunk_setperm(vxmem *mem, uint32_t addr, uint32_t len, uint32_t perm)
{
	vxmem_chunk *chunk = (vxmem_chunk*)mem;
	uint32_t a;
	
	if (addr + len < addr || addr + len > chunk->size) {
		errno = EINVAL;
		return -1;
	}

	if (mem->mapped) {
		if (mprotect(mem->mapped->base + addr, len, mmperm(perm)) < 0)
			return -1;
	}

	for (a = addr; a < addr + len; a += VXPAGESIZE)
		chunk->perm[a/VXPAGESIZE] = perm;
	return 0;
}

static vxmmap *chunk_map(vxmem *mem, uint32_t flags)
{
	vxmmap *mm;
	void *v;
	vxmem_chunk *chunk = (vxmem_chunk*)mem;
	
	if (mem->mapped) {
		mem->mapped->ref++;	// XXX get rid of ref?
		return mem->mapped;
	}

	mm = malloc(sizeof *mm);
	if (mm == NULL)
		return NULL;
	if ((v = mmap(0, chunk->size, PROT_NONE, MAP_32BIT | (vx_elfbigmem ? MAP_PRIVATE : MAP_SHARED), chunk->fd, 0)) == (void*)-1) {
		free(mm);
		return NULL;
	}
//	vxprint("chunk_map %p size %08x\n", v, chunk->size);

	// Now set the permissions on all pages that should be accessible.
	unsigned npages = chunk->size / VXPAGESIZE;
	for (unsigned i = 0; i < npages; ) {
		uint8_t pageperm = chunk->perm[i];

		// For efficiency, merge mprotect calls on page ranges.
		unsigned j;
		for (j = i+1; j < npages; j++)
			if (chunk->perm[j] != pageperm)
				break;

		if (pageperm == 0) {
			i = j;		// nothing to do for this range
			continue;
		}

		// Calculate the effective permission to map with in the host.
		int prot = mmperm(pageperm);
		assert(prot >= 0);

		// Set the permissions on this range.
		if (mprotect((char*)v + i*VXPAGESIZE, (j-i)*VXPAGESIZE, prot) < 0) {
			munmap(v, chunk->size);
			free(mm);
			return NULL;
		}

		i = j;
	}

	mm->base = v;
	mm->size = chunk->size;
	mm->ref = 2;	// XXX get rid of ref?
	mem->mapped = mm;
	return mm;
}

static void chunk_unmap(vxmem *mem, vxmmap *mm)
{
	vxmem_chunk *chunk = (vxmem_chunk*)mem;
	
	if(mm == NULL)
		return;
//	if(--mm->ref > 0)	// XXX get rid of ref?
//		return;
	if(mm == mem->mapped)
		mem->mapped = NULL;
//	vxprint("chunk_unmap %p size %08x\n", mm->base, mm->size);
	munmap(mm->base, mm->size);
	free(mm);
}

static vxmem chunk_proto = 
{
	chunk_read,
	chunk_write,
	chunk_map,
	chunk_unmap,
	chunk_checkperm,
	chunk_setperm,
	chunk_resize,
	chunk_free,
};

static vxmem *vxmem_chunk_fromfd(int fd, off_t size)
{
	vxmem_chunk *chunk;
	
	chunk = calloc(sizeof *chunk, 1);
	if (chunk == NULL)
		return NULL;
	chunk->mem = chunk_proto;
	chunk->fd = fd;
	if (chunk_resize((vxmem*)chunk, size) < 0) {
		free(chunk);
		return NULL;
	}
	return (vxmem*)chunk;
}

vxmem *vxmem_chunk_new(int size)
{
	int fd;
	char tmpfn[] = "/var/tmp/vxXXXXXX";
	vxmem *mem;
	
	if ((fd = mkstemp(tmpfn)) < 0)
		return NULL;
	unlink(tmpfn);
	if ((mem = vxmem_chunk_fromfd(fd, size)) == NULL) {
		close(fd);
		return NULL;
	}
	return mem;
}