#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;}