Res VMMap(VM vm, Addr base, Addr limit)
{
Size size;
void *addr;
AVERT(VM, vm);
AVER(base < limit);
AVER(base >= vm->base);
AVER(limit <= vm->limit);
AVER(AddrIsAligned(base, vm->align));
AVER(AddrIsAligned(limit, vm->align));
/* Map /dev/zero onto the area with a copy-on-write policy. This */
/* effectively populates the area with zeroed memory. */
size = AddrOffset(base, limit);
/* Check it won't lose any bits. */
AVER(size <= (Size)(size_t)-1);
addr = mmap((void *)base, (size_t)size,
PROT_READ | PROT_WRITE | PROT_EXEC,
MAP_PRIVATE | MAP_FIXED,
vm->zero_fd, (off_t)0);
if(addr == MAP_FAILED) {
AVER(errno == ENOMEM || errno == EAGAIN); /* .assume.mmap.err */
return ResMEMORY;
}
AVER(addr == (void *)base);
vm->mapped += size;
EVENT_PAA(VMMap, vm, base, limit);
return ResOK;
}
void VMUnmap(VM vm, Addr base, Addr limit)
{
Size size;
void *addr;
AVERT(VM, vm);
AVER(base < limit);
AVER(base >= vm->base);
AVER(limit <= vm->limit);
AVER(AddrIsAligned(base, vm->align));
AVER(AddrIsAligned(limit, vm->align));
/* .unmap.reserve: Map /dev/zero onto the area, allowing no access. */
/* This effectively depopulates the area from memory, but keeps */
/* it "busy" as far as the OS is concerned, so that it will not */
/* be re-used by other calls to mmap which do not specify */
/* MAP_FIXED. See also .map.reserve. */
/* The OS doesn't merge this mapping with any neighbours, but it */
/* can keep track of at least 16K mappings, so it's good enough. */
size = AddrOffset(base, limit);
/* Check it won't lose any bits. */
AVER(size <= (Size)(size_t)-1);
addr = mmap((void *)base, (size_t)size,
PROT_NONE, MAP_SHARED | MAP_FIXED | MAP_AUTORESRV,
vm->zero_fd, (off_t)AddrOffset(vm->base, base));
AVER(addr == (void *)base);
vm->mapped -= size;
EVENT_PAA(VMUnmap, vm, base, limit);
}
Res VMMap(VM vm, Addr base, Addr limit)
{
Size size;
AVERT(VM, vm);
AVER(sizeof(int) == sizeof(Addr));
AVER(base < limit);
AVER(base >= vm->base);
AVER(limit <= vm->limit);
AVER(AddrOffset(base, limit) <= INT_MAX);
AVER(AddrIsAligned(base, vm->align));
AVER(AddrIsAligned(limit, vm->align));
/* Map /dev/zero onto the area with a copy-on-write policy. This */
/* effectively populates the area with zeroed memory. */
size = AddrOffset(base, limit);
if (mmap((caddr_t)base, (int)size,
PROT_READ | PROT_WRITE | PROT_EXEC,
MAP_PRIVATE | MAP_FIXED,
vm->zero_fd, (off_t)0)
== (caddr_t)-1) {
AVER(errno == ENOMEM); /* .assume.mmap.err */
return ResMEMORY;
}
vm->mapped += size;
EVENT_PAA(VMMap, vm, base, limit);
return ResOK;
}
void VMUnmap(VM vm, Addr base, Addr limit)
{
Size size;
caddr_t addr;
AVERT(VM, vm);
AVER(sizeof(int) == sizeof(Addr));
AVER(base < limit);
AVER(base >= vm->base);
AVER(limit <= vm->limit);
AVER(AddrIsAligned(base, vm->align));
AVER(AddrIsAligned(limit, vm->align));
/* Map /etc/passwd onto the area, allowing no access. This */
/* effectively depopulates the area from memory, but keeps */
/* it "busy" as far as the OS is concerned, so that it will not */
/* be re-used by other calls to mmap which do not specify */
/* MAP_FIXED. The offset is specified to mmap so that */
/* the OS merges this mapping with .map.reserve. */
size = AddrOffset(base, limit);
addr = mmap((caddr_t)base, (int)size,
PROT_NONE, MAP_SHARED | MAP_FIXED,
vm->none_fd, (off_t)AddrOffset(vm->base, base));
AVER(addr == (caddr_t)base);
vm->mapped -= size;
EVENT_PAA(VMUnmap, vm, base, limit);
}
void VMUnmap(VM vm, Addr base, Addr limit)
{
Size size;
void *addr;
AVERT(VM, vm);
AVER(base < limit);
AVER(base >= vm->base);
AVER(limit <= vm->limit);
AVER(AddrIsAligned(base, vm->align));
AVER(AddrIsAligned(limit, vm->align));
AVER(sizeof(off_t) == sizeof(Size)); /* .assume.off_t */
size = AddrOffset(base, limit);
/* see <design/vmo1/#fun.unmap.offset> */
addr = mmap((void *)base, (size_t)size,
PROT_NONE, MAP_FILE | MAP_SHARED | MAP_FIXED,
vm->none_fd, (off_t)AddrOffset(vm->base, base));
AVER(addr == (void *)base);
vm->mapped -= size;
EVENT_PAA(VMUnmap, vm, base, limit);
}
Res VMMap(VM vm, Addr base, Addr limit)
{
Size size;
AVERT(VM, vm);
AVER(sizeof(void *) == sizeof(Addr));
AVER(base < limit);
AVER(base >= vm->base);
AVER(limit <= vm->limit);
AVER(AddrIsAligned(base, vm->align));
AVER(AddrIsAligned(limit, vm->align));
size = AddrOffset(base, limit);
if (mmap((void *)base, (size_t)size,
PROT_READ | PROT_WRITE | PROT_EXEC,
MAP_ANONYMOUS | MAP_PRIVATE | MAP_FIXED,
-1, 0)
== (void *)-1) {
AVER(errno == ENOMEM); /* .assume.mmap.err */
return ResMEMORY;
}
vm->mapped += size;
EVENT_PAA(VMMap, vm, base, limit);
return ResOK;
}
Res VMCreate(VM *vmReturn, Size size)
{
void *addr;
Align align;
int zero_fd;
VM vm;
Res res;
AVER(vmReturn != NULL);
align = (Align)sysconf(_SC_PAGESIZE);
AVER(SizeIsP2(align));
size = SizeAlignUp(size, align);
if((size == 0) || (size > (Size)(size_t)-1))
return ResRESOURCE;
zero_fd = open("/dev/zero", O_RDONLY);
if(zero_fd == -1)
return ResFAIL;
/* Map in a page to store the descriptor on. */
addr = mmap((void *)0, (size_t)SizeAlignUp(sizeof(VMStruct), align),
PROT_READ | PROT_WRITE, MAP_PRIVATE,
zero_fd, (off_t)0);
if(addr == MAP_FAILED) {
AVER(errno == ENOMEM || errno == EAGAIN); /* .assume.mmap.err */
res = (errno == ENOMEM || errno == EAGAIN) ? ResMEMORY : ResFAIL;
goto failVMMap;
}
vm = (VM)addr;
vm->zero_fd = zero_fd;
vm->align = align;
/* .map.reserve: MAP_AUTORESRV is necessary to avoid reserving swap. */
addr = mmap((void *)0, (size_t)size, PROT_NONE, MAP_SHARED | MAP_AUTORESRV,
zero_fd, (off_t)0);
if(addr == MAP_FAILED) {
AVER(errno == ENOMEM); /* .assume.mmap.err */
res = (errno == ENOMEM) ? ResRESOURCE : ResFAIL;
goto failReserve;
}
vm->base = (Addr)addr;
vm->limit = AddrAdd(vm->base, size);
vm->reserved = size;
vm->mapped = (Size)0;
vm->sig = VMSig;
AVERT(VM, vm);
EVENT_PAA(VMCreate, vm, vm->base, vm->limit);
*vmReturn = vm;
return ResOK;
failReserve:
(void)munmap((void *)vm, (size_t)SizeAlignUp(sizeof(VMStruct), align));
failVMMap:
(void)close(zero_fd);
return res;
}
Res VMCreate(VM *vmReturn, Size size)
{
caddr_t addr;
Align align;
int zero_fd;
int none_fd;
VM vm;
Res res;
AVER(vmReturn != NULL);
align = (Align)getpagesize();
AVER(SizeIsP2(align));
size = SizeAlignUp(size, align);
if ((size == 0) || (size > (Size)INT_MAX)) /* see .assume.size */
return ResRESOURCE;
zero_fd = open("/dev/zero", O_RDONLY);
if (zero_fd == -1)
return ResFAIL;
none_fd = open("/etc/passwd", O_RDONLY);
if (none_fd == -1) {
res = ResFAIL;
goto failNoneOpen;
}
/* Map in a page to store the descriptor on. */
addr = mmap((caddr_t)0, SizeAlignUp(sizeof(VMStruct), align),
PROT_READ | PROT_WRITE, MAP_PRIVATE,
zero_fd, (off_t)0);
if (addr == (caddr_t)-1) {
int e = errno;
AVER(e == ENOMEM); /* .assume.mmap.err */
res = (e == ENOMEM) ? ResMEMORY : ResFAIL;
goto failVMMap;
}
vm = (VM)addr;
vm->zero_fd = zero_fd;
vm->none_fd = none_fd;
vm->align = align;
/* .map.reserve: See .assume.not-last. */
addr = mmap((caddr_t)0, size, PROT_NONE, MAP_SHARED, none_fd,
(off_t)0);
if (addr == (caddr_t)-1) {
int e = errno;
AVER(e == ENOMEM); /* .assume.mmap.err */
res = (e == ENOMEM) ? ResRESOURCE : ResFAIL;
goto failReserve;
}
vm->base = (Addr)addr;
vm->limit = AddrAdd(vm->base, size);
vm->reserved = size;
vm->mapped = (Size)0;
vm->sig = VMSig;
AVERT(VM, vm);
EVENT_PAA(VMCreate, vm, vm->base, vm->limit);
*vmReturn = vm;
return ResOK;
failReserve:
(void)munmap((caddr_t)vm, (size_t)SizeAlignUp(sizeof(VMStruct), align));
failVMMap:
(void)close(none_fd); /* see .close.fail */
failNoneOpen:
(void)close(zero_fd);
return res;
}
Res VMCreate(VM *vmReturn, Size size)
{
void *addr;
Align align;
int none_fd;
VM vm;
Res res;
AVER(vmReturn != NULL);
align = (Align)getpagesize();
AVER(SizeIsP2(align));
size = SizeAlignUp(size, align);
if ((size == 0) || (size > (Size)(size_t)-1))
return ResRESOURCE;
none_fd = open("/etc/passwd", O_RDONLY);
if (none_fd == -1) {
return ResFAIL;
}
/* Map in a page to store the descriptor on. */
addr = mmap(0, (size_t)SizeAlignUp(sizeof(VMStruct), align),
PROT_READ | PROT_WRITE,
MAP_ANONYMOUS | MAP_PRIVATE | MAP_VARIABLE,
-1, 0);
if (addr == (void *)-1) {
int e = errno;
AVER(e == ENOMEM); /* .assume.mmap.err */
res = (e == ENOMEM) ? ResMEMORY : ResFAIL;
goto failVMMap;
}
vm = (VM)addr;
vm->none_fd = none_fd;
vm->align = align;
/* See .assume.not-last. */
addr = mmap(0, (size_t)size,
PROT_NONE, MAP_FILE | MAP_SHARED | MAP_VARIABLE,
none_fd, 0);
if (addr == (void *)-1) {
int e = errno;
AVER(e == ENOMEM); /* .assume.mmap.err */
res = (e == ENOMEM) ? ResRESOURCE : ResFAIL;
goto failReserve;
}
vm->base = (Addr)addr;
vm->limit = AddrAdd(vm->base, size);
vm->reserved = size;
vm->mapped = (Size)0;
vm->sig = VMSig;
AVERT(VM, vm);
EVENT_PAA(VMCreate, vm, vm->base, vm->limit);
*vmReturn = vm;
return ResOK;
failReserve:
(void)munmap((void *)vm, (size_t)SizeAlignUp(sizeof(VMStruct), align));
failVMMap:
(void)close(none_fd); /* see .close.fail */
return res;
}
Res VMCreate(VM *vmReturn, Size size)
{
void *addr;
Align align;
int zero_fd;
int none_fd;
VM vm;
long pagesize;
Res res;
AVER(vmReturn != NULL);
/* Find out the page size from the OS */
pagesize = sysconf(_SC_PAGESIZE);
/* check the actual returned pagesize will fit in an object of */
/* type Align. */
AVER(pagesize > 0);
AVER((unsigned long)pagesize <= (unsigned long)(Align)-1);
/* Note implicit conversion from "long" to "Align". */
align = pagesize;
AVER(SizeIsP2(align));
size = SizeAlignUp(size, align);
if((size == 0) || (size > (Size)(size_t)-1))
return ResRESOURCE;
zero_fd = open("/dev/zero", O_RDONLY);
if(zero_fd == -1)
return ResFAIL;
none_fd = open("/etc/passwd", O_RDONLY);
if(none_fd == -1) {
res = ResFAIL;
goto failNoneOpen;
}
/* Map in a page to store the descriptor on. */
addr = mmap((void *)0, (size_t)SizeAlignUp(sizeof(VMStruct), align),
PROT_READ | PROT_WRITE, MAP_PRIVATE,
zero_fd, (off_t)0);
if(addr == MAP_FAILED) {
AVER(errno == EAGAIN); /* .assume.mmap.err */
res = ResMEMORY;
goto failVMMap;
}
vm = (VM)addr;
vm->zero_fd = zero_fd;
vm->none_fd = none_fd;
vm->align = align;
/* .map.reserve: See .assume.not-last. */
addr = mmap((void *)0, (size_t)size, PROT_NONE, MAP_SHARED,
none_fd, (off_t)0);
if(addr == MAP_FAILED) {
AVER(errno == ENOMEM); /* .assume.mmap.err */
res = (errno == ENOMEM) ? ResRESOURCE : ResFAIL;
goto failReserve;
}
vm->base = (Addr)addr;
vm->limit = AddrAdd(vm->base, size);
vm->reserved = size;
vm->mapped = (Size)0;
vm->sig = VMSig;
AVERT(VM, vm);
EVENT_PAA(VMCreate, vm, vm->base, vm->limit);
*vmReturn = vm;
return ResOK;
failReserve:
(void)munmap((void *)vm, (size_t)SizeAlignUp(sizeof(VMStruct), align));
failVMMap:
(void)close(none_fd); /* see .close.fail */
failNoneOpen:
(void)close(zero_fd);
return res;
}
