sanchayanmaity/minix
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity
minix/test/kernel/sys_vumap/vumaptest.c
Ben Gras dda632a24f drop the minix_ prefixes for mmap and munmap 
also cleanup of various minix-specific changes, cleanup of
mmap-related testing.

Change-Id: I289a4fc50cf8a13df4a6082038d860853a4bd024
2014-03-03 20:47:03 +01:00

1409 lines
34 KiB
C
Raw Blame History

/* Test for sys_vumap() - by D.C. van Moolenbroek */
#include <minix/drivers.h>
#include <minix/ds.h>
#include <sys/mman.h>
#include <assert.h>
#include "com.h"
struct buf {
int pages;
int flags;
vir_bytes addr;
phys_bytes phys;
};
#define BUF_PREALLOC 0x1 /* if set, immediately allocate the page */
#define BUF_ADJACENT 0x2 /* virtually contiguous with the last buffer */
static unsigned int count = 0, failures = 0;
static int success;
static char *fail_file;
static int fail_line;
static int relay;
static endpoint_t endpt;
static int verbose;
static enum {
GE_NONE, /* no exception */
GE_REVOKED, /* revoked grant */
GE_INVALID /* invalid grant */
} grant_exception = GE_NONE;
static int grant_access = 0;
#define expect(r) expect_f((r), __FILE__, __LINE__)
static void alloc_buf(struct buf *buf, phys_bytes next)
{
void *tmp = NULL;
vir_bytes addr;
size_t len;
int r, prealloc, flags;
/* is_allocated() cannot handle buffers that are not physically
* contiguous, and we cannot guarantee physical contiguity if not
* not preallocating.
*/
assert((buf->flags & BUF_PREALLOC) || buf->pages == 1);
len = buf->pages * PAGE_SIZE;
prealloc = (buf->flags & BUF_PREALLOC);
flags = MAP_ANON | (prealloc ? (MAP_CONTIG | MAP_PREALLOC) : 0);
if (prealloc) {
/* Allocate a same-sized piece of memory elsewhere, to make it
* very unlikely that the actual piece of memory will end up
* being physically contiguous with the last piece.
*/
tmp = mmap((void *) (buf->addr + len + PAGE_SIZE), len,
PROT_READ | PROT_WRITE, MAP_ANON | MAP_PREALLOC |
MAP_CONTIG, -1, 0L);
if (tmp == MAP_FAILED)
panic("unable to allocate temporary buffer");
}
addr = (vir_bytes) mmap((void *) buf->addr, len,
PROT_READ | PROT_WRITE, flags, -1, 0L);
if (addr != buf->addr)
panic("unable to allocate buffer (2)");
if (!prealloc)
return;
if ((r = munmap(tmp, len)) != OK)
panic("unable to unmap buffer (%d)", errno);
if ((r = sys_umap(SELF, VM_D, addr, len, &buf->phys)) < 0)
panic("unable to get physical address of buffer (%d)", r);
if (buf->phys != next)
return;
if (verbose)
printf("WARNING: alloc noncontigous range, second try\n");
/* Can't remap this to elsewhere, so we run the risk of allocating the
* exact same physically contiguous page again. However, now that we've
* unmapped the temporary memory also, there's a small chance we'll end
* up with a different physical page this time. Who knows.
*/
munmap((void *) addr, len);
addr = (vir_bytes) mmap((void *) buf->addr, len,
PROT_READ | PROT_WRITE, flags, -1, 0L);
if (addr != buf->addr)
panic("unable to allocate buffer, second try");
if ((r = sys_umap(SELF, VM_D, addr, len, &buf->phys)) < 0)
panic("unable to get physical address of buffer (%d)", r);
/* Still the same page? Screw it. */
if (buf->phys == next)
panic("unable to allocate noncontiguous range");
}
static void alloc_bufs(struct buf *buf, int count)
{
static vir_bytes base = 0x80000000L;
phys_bytes next;
int i;
/* Allocate the given memory in virtually contiguous blocks whenever
* each next buffer is requested to be adjacent. Insert a virtual gap
* after each such block. Make sure that each two adjacent buffers in a
* block are physically non-contiguous.
*/
for (i = 0; i < count; i++) {
if (i > 0 && (buf[i].flags & BUF_ADJACENT)) {
next = buf[i-1].phys + buf[i-1].pages * PAGE_SIZE;
} else {
base += PAGE_SIZE * 16;
next = 0L;
}
buf[i].addr = base;
alloc_buf(&buf[i], next);
base += buf[i].pages * PAGE_SIZE;
}
#if DEBUG
for (i = 0; i < count; i++)
printf("Buf %d: %d pages, flags %x, vir %08x, phys %08x\n", i,
buf[i].pages, buf[i].flags, buf[i].addr, buf[i].phys);
#endif
}
static void free_bufs(struct buf *buf, int count)
{
int i, j, r;
for (i = 0; i < count; i++) {
for (j = 0; j < buf[i].pages; j++) {
r = munmap((void *) (buf[i].addr + j * PAGE_SIZE),
PAGE_SIZE);
if (r != OK)
panic("unable to unmap range (%d)", errno);
}
}
}
static int is_allocated(vir_bytes addr, size_t bytes, phys_bytes *phys)
{
int r;
/* This will have to do for now. Of course, we could use sys_vumap with
* VUA_READ for this, but that would defeat the point of one test. It
* is still a decent alternative in case sys_umap's behavior ever
* changes, though.
*/
r = sys_umap(SELF, VM_D, addr, bytes, phys);
return r == OK;
}
static int is_buf_allocated(struct buf *buf)
{
return is_allocated(buf->addr, buf->pages * PAGE_SIZE, &buf->phys);
}
static void test_group(char *name)
{
if (verbose)
printf("Test group: %s (%s)\n",
name, relay ? "relay" : "local");
}
static void expect_f(int res, char *file, int line)
{
if (!res && success) {
success = FALSE;
fail_file = file;
fail_line = line;
}
}
static void got_result(char *desc)
{
count++;
if (!success) {
failures++;
printf("#%02d: %-38s\t[FAIL]\n", count, desc);
printf("- failure at %s:%d\n", fail_file, fail_line);
} else {
if (verbose)
printf("#%02d: %-38s\t[PASS]\n", count, desc);
}
}
static int relay_vumap(struct vumap_vir *vvec, int vcount, size_t offset,
int access, struct vumap_phys *pvec, int *pcount)
{
struct vumap_vir gvvec[MAPVEC_NR + 3];
cp_grant_id_t vgrant, pgrant;
message m;
int i, r, gaccess;
assert(vcount > 0 && vcount <= MAPVEC_NR + 3);
assert(*pcount > 0 && *pcount <= MAPVEC_NR + 3);
/* Allow grant access flags to be overridden for testing purposes. */
if (!(gaccess = grant_access)) {
if (access & VUA_READ) gaccess |= CPF_READ;
if (access & VUA_WRITE) gaccess |= CPF_WRITE;
}
for (i = 0; i < vcount; i++) {
gvvec[i].vv_grant = cpf_grant_direct(endpt, vvec[i].vv_addr,
vvec[i].vv_size, gaccess);
assert(gvvec[i].vv_grant != GRANT_INVALID);
gvvec[i].vv_size = vvec[i].vv_size;
}
vgrant = cpf_grant_direct(endpt, (vir_bytes) gvvec,
sizeof(gvvec[0]) * vcount, CPF_READ);
assert(vgrant != GRANT_INVALID);
pgrant = cpf_grant_direct(endpt, (vir_bytes) pvec,
sizeof(pvec[0]) * *pcount, CPF_WRITE);
assert(pgrant != GRANT_INVALID);
/* This must be done after allocating all other grants. */
if (grant_exception != GE_NONE) {
cpf_revoke(gvvec[vcount - 1].vv_grant);
if (grant_exception == GE_INVALID)
gvvec[vcount - 1].vv_grant = GRANT_INVALID;
}
m.m_type = VTR_RELAY;
m.VTR_VGRANT = vgrant;
m.VTR_VCOUNT = vcount;
m.VTR_OFFSET = offset;
m.VTR_ACCESS = access;
m.VTR_PGRANT = pgrant;
m.VTR_PCOUNT = *pcount;
r = ipc_sendrec(endpt, &m);
cpf_revoke(pgrant);
cpf_revoke(vgrant);
for (i = 0; i < vcount - !!grant_exception; i++)
cpf_revoke(gvvec[i].vv_grant);
*pcount = m.VTR_PCOUNT;
return (r != OK) ? r : m.m_type;
}
static int do_vumap(endpoint_t endpt, struct vumap_vir *vvec, int vcount,
size_t offset, int access, struct vumap_phys *pvec, int *pcount)
{
struct vumap_phys pv_backup[MAPVEC_NR + 3];
int r, pc_backup, pv_test = FALSE;
/* Make a copy of pvec and pcount for later. */
pc_backup = *pcount;
/* We cannot compare pvec contents before and after when relaying,
* since the original contents are not transferred.
*/
if (!relay && pvec != NULL && pc_backup >= 1 &&
pc_backup <= MAPVEC_NR + 3) {
pv_test = TRUE;
memcpy(pv_backup, pvec, sizeof(*pvec) * pc_backup);
}
/* Reset the test result. */
success = TRUE;
/* Perform the vumap call, either directly or through a relay. */
if (relay) {
assert(endpt == SELF);
r = relay_vumap(vvec, vcount, offset, access, pvec, pcount);
} else {
r = sys_vumap(endpt, vvec, vcount, offset, access, pvec,
pcount);
}
/* Upon failure, pvec and pcount must be unchanged. */
if (r != OK) {
expect(pc_backup == *pcount);
if (pv_test)
expect(memcmp(pv_backup, pvec,
sizeof(*pvec) * pc_backup) == 0);
}
return r;
}
static void test_basics(void)
{
struct vumap_vir vvec[2];
struct vumap_phys pvec[4];
struct buf buf[4];
int r, pcount;
test_group("basics");
buf[0].pages = 1;
buf[0].flags = BUF_PREALLOC;
buf[1].pages = 2;
buf[1].flags = BUF_PREALLOC;
buf[2].pages = 1;
buf[2].flags = BUF_PREALLOC;
buf[3].pages = 1;
buf[3].flags = BUF_PREALLOC | BUF_ADJACENT;
alloc_bufs(buf, 4);
/* Test single whole page. */
vvec[0].vv_addr = buf[0].addr;
vvec[0].vv_size = PAGE_SIZE;
pcount = 1;
r = do_vumap(SELF, vvec, 1, 0, VUA_READ, pvec, &pcount);
expect(r == OK);
expect(pcount == 1);
expect(pvec[0].vp_addr == buf[0].phys);
expect(pvec[0].vp_size == vvec[0].vv_size);
got_result("single whole page");
/* Test single partial page. */
vvec[0].vv_addr = buf[0].addr + 123;
vvec[0].vv_size = PAGE_SIZE - 456;
pcount = 1;
r = do_vumap(SELF, vvec, 1, 0, VUA_READ, pvec, &pcount);
expect(r == OK);
expect(pcount == 1);
expect(pvec[0].vp_addr == buf[0].phys + 123);
expect(pvec[0].vp_size == vvec[0].vv_size);
got_result("single partial page");
/* Test multiple contiguous whole pages. */
vvec[0].vv_addr = buf[1].addr;
vvec[0].vv_size = PAGE_SIZE * 2;
pcount = 1;
r = do_vumap(SELF, vvec, 1, 0, VUA_READ, pvec, &pcount);
expect(r == OK);
expect(pcount == 1);
expect(pvec[0].vp_addr == buf[1].phys);
expect(pvec[0].vp_size == vvec[0].vv_size);
got_result("multiple contiguous whole pages");
/* Test range in multiple contiguous pages. */
vvec[0].vv_addr = buf[1].addr + 234;
vvec[0].vv_size = PAGE_SIZE * 2 - 234;
pcount = 2;
r = do_vumap(SELF, vvec, 1, 0, VUA_READ, pvec, &pcount);
expect(r == OK);
expect(pcount == 1);
expect(pvec[0].vp_addr == buf[1].phys + 234);
expect(pvec[0].vp_size == vvec[0].vv_size);
got_result("range in multiple contiguous pages");
/* Test multiple noncontiguous whole pages. */
vvec[0].vv_addr = buf[2].addr;
vvec[0].vv_size = PAGE_SIZE * 2;
pcount = 3;
r = do_vumap(SELF, vvec, 1, 0, VUA_READ, pvec, &pcount);
expect(r == OK);
expect(pcount == 2);
expect(pvec[0].vp_addr == buf[2].phys);
expect(pvec[0].vp_size == PAGE_SIZE);
expect(pvec[1].vp_addr == buf[3].phys);
expect(pvec[1].vp_size == PAGE_SIZE);
got_result("multiple noncontiguous whole pages");
/* Test range in multiple noncontiguous pages. */
vvec[0].vv_addr = buf[2].addr + 1;
vvec[0].vv_size = PAGE_SIZE * 2 - 2;
pcount = 2;
r = do_vumap(SELF, vvec, 1, 0, VUA_WRITE, pvec, &pcount);
expect(r == OK);
expect(pcount == 2);
expect(pvec[0].vp_addr == buf[2].phys + 1);
expect(pvec[0].vp_size == PAGE_SIZE - 1);
expect(pvec[1].vp_addr == buf[3].phys);
expect(pvec[1].vp_size == PAGE_SIZE - 1);
got_result("range in multiple noncontiguous pages");
/* Test single-input result truncation. */
vvec[0].vv_addr = buf[2].addr + PAGE_SIZE / 2;
vvec[0].vv_size = PAGE_SIZE;
pvec[1].vp_addr = 0L;
pvec[1].vp_size = 0;
pcount = 1;
r = do_vumap(SELF, vvec, 1, 0, VUA_READ, pvec, &pcount);
expect(r == OK);
expect(pcount == 1);
expect(pvec[0].vp_addr == buf[2].phys + PAGE_SIZE / 2);
expect(pvec[0].vp_size == PAGE_SIZE / 2);
expect(pvec[1].vp_addr == 0L);
expect(pvec[1].vp_size == 0);
got_result("single-input result truncation");
/* Test multiple inputs, contiguous first. */
vvec[0].vv_addr = buf[0].addr;
vvec[0].vv_size = PAGE_SIZE;
vvec[1].vv_addr = buf[2].addr + PAGE_SIZE - 1;
vvec[1].vv_size = 2;
pcount = 3;
r = do_vumap(SELF, vvec, 2, 0, VUA_READ, pvec, &pcount);
expect(r == OK);
expect(pcount == 3);
expect(pvec[0].vp_addr == buf[0].phys);
expect(pvec[0].vp_size == PAGE_SIZE);
expect(pvec[1].vp_addr == buf[2].phys + PAGE_SIZE - 1);
expect(pvec[1].vp_size == 1);
expect(pvec[2].vp_addr == buf[3].phys);
expect(pvec[2].vp_size == 1);
got_result("multiple inputs, contiguous first");
/* Test multiple inputs, contiguous last. */
vvec[0].vv_addr = buf[2].addr + 123;
vvec[0].vv_size = PAGE_SIZE * 2 - 456;
vvec[1].vv_addr = buf[1].addr + 234;
vvec[1].vv_size = PAGE_SIZE * 2 - 345;
pcount = 4;
r = do_vumap(SELF, vvec, 2, 0, VUA_WRITE, pvec, &pcount);
expect(r == OK);
expect(pcount == 3);
expect(pvec[0].vp_addr == buf[2].phys + 123);
expect(pvec[0].vp_size == PAGE_SIZE - 123);
expect(pvec[1].vp_addr == buf[3].phys);
expect(pvec[1].vp_size == PAGE_SIZE - (456 - 123));
expect(pvec[2].vp_addr == buf[1].phys + 234);
expect(pvec[2].vp_size == vvec[1].vv_size);
got_result("multiple inputs, contiguous last");
/* Test multiple-inputs result truncation. */
vvec[0].vv_addr = buf[2].addr + 2;
vvec[0].vv_size = PAGE_SIZE * 2 - 3;
vvec[1].vv_addr = buf[0].addr;
vvec[1].vv_size = 135;
pvec[2].vp_addr = 0xDEADBEEFL;
pvec[2].vp_size = 1234;
pcount = 2;
r = do_vumap(SELF, vvec, 2, 0, VUA_READ, pvec, &pcount);
expect(r == OK);
expect(pcount == 2);
expect(pvec[0].vp_addr == buf[2].phys + 2);
expect(pvec[0].vp_size == PAGE_SIZE - 2);
expect(pvec[1].vp_addr == buf[3].phys);
expect(pvec[1].vp_size == PAGE_SIZE - 1);
expect(pvec[2].vp_addr == 0xDEADBEEFL);
expect(pvec[2].vp_size == 1234);
got_result("multiple-inputs result truncation");
free_bufs(buf, 4);
}
static void test_endpt(void)
{
struct vumap_vir vvec[1];
struct vumap_phys pvec[1];
struct buf buf[1];
int r, pcount;
test_group("endpoint");
buf[0].pages = 1;
buf[0].flags = BUF_PREALLOC;
alloc_bufs(buf, 1);
/* Test NONE endpoint. */
vvec[0].vv_addr = buf[0].addr;
vvec[0].vv_size = PAGE_SIZE;
pcount = 1;
r = do_vumap(NONE, vvec, 1, 0, VUA_READ, pvec, &pcount);
expect(r == EINVAL);
got_result("NONE endpoint");
/* Test ANY endpoint. */
vvec[0].vv_addr = buf[0].addr;
vvec[0].vv_size = PAGE_SIZE;
pcount = 1;
r = do_vumap(ANY, vvec, 1, 0, VUA_READ, pvec, &pcount);
expect(r == EINVAL);
got_result("ANY endpoint");
free_bufs(buf, 1);
}
static void test_vector1(void)
{
struct vumap_vir vvec[2];
struct vumap_phys pvec[3];
struct buf buf[2];
int r, pcount;
test_group("vector, part 1");
buf[0].pages = 2;
buf[0].flags = BUF_PREALLOC;
buf[1].pages = 1;
buf[1].flags = BUF_PREALLOC;
alloc_bufs(buf, 2);
/* Test zero virtual memory size. */
vvec[0].vv_addr = buf[0].addr;
vvec[0].vv_size = PAGE_SIZE * 2;
vvec[1].vv_addr = buf[1].addr;
vvec[1].vv_size = 0;
pcount = 3;
r = do_vumap(SELF, vvec, 2, 0, VUA_READ, pvec, &pcount);
expect(r == EINVAL);
got_result("zero virtual memory size");
/* Test excessive virtual memory size. */
vvec[1].vv_size = (vir_bytes) -1;
r = do_vumap(SELF, vvec, 2, 0, VUA_READ, pvec, &pcount);
expect(r == EFAULT || r == EPERM);
got_result("excessive virtual memory size");
/* Test invalid virtual memory. */
vvec[1].vv_addr = 0L;
vvec[1].vv_size = PAGE_SIZE;
r = do_vumap(SELF, vvec, 2, 0, VUA_READ, pvec, &pcount);
expect(r == EFAULT);
got_result("invalid virtual memory");
/* Test virtual memory overrun. */
vvec[0].vv_size++;
vvec[1].vv_addr = buf[1].addr;
r = do_vumap(SELF, vvec, 2, 0, VUA_READ, pvec, &pcount);
expect(r == EFAULT);
got_result("virtual memory overrun");
free_bufs(buf, 2);
}
static void test_vector2(void)
{
struct vumap_vir vvec[2], *vvecp;
struct vumap_phys pvec[3], *pvecp;
struct buf buf[2];
phys_bytes dummy;
int r, pcount;
test_group("vector, part 2");
buf[0].pages = 2;
buf[0].flags = BUF_PREALLOC;
buf[1].pages = 1;
buf[1].flags = BUF_PREALLOC;
alloc_bufs(buf, 2);
/* Test zero virtual count. */
vvec[0].vv_addr = buf[0].addr;
vvec[0].vv_size = PAGE_SIZE * 2;
vvec[1].vv_addr = buf[1].addr;
vvec[1].vv_size = PAGE_SIZE;
pcount = 3;
r = do_vumap(SELF, vvec, 0, 0, VUA_READ, pvec, &pcount);
expect(r == EINVAL);
got_result("zero virtual count");
/* Test negative virtual count. */
r = do_vumap(SELF, vvec, -1, 0, VUA_WRITE, pvec, &pcount);
expect(r == EINVAL);
got_result("negative virtual count");
/* Test zero physical count. */
pcount = 0;
r = do_vumap(SELF, vvec, 2, 0, VUA_WRITE, pvec, &pcount);
expect(r == EINVAL);
got_result("zero physical count");
/* Test negative physical count. */
pcount = -1;
r = do_vumap(SELF, vvec, 2, 0, VUA_READ, pvec, &pcount);
expect(r == EINVAL);
got_result("negative physical count");
/* Test invalid virtual vector pointer. */
pcount = 2;
r = do_vumap(SELF, NULL, 2, 0, VUA_READ, pvec, &pcount);
expect(r == EFAULT);
got_result("invalid virtual vector pointer");
/* Test unallocated virtual vector. */
vvecp = (struct vumap_vir *) mmap(NULL, PAGE_SIZE,
PROT_READ | PROT_WRITE, MAP_ANON, -1, 0L);
if (vvecp == MAP_FAILED)
panic("unable to allocate virtual vector");
r = do_vumap(SELF, vvecp, 2, 0, VUA_READ, pvec, &pcount);
expect(r == EFAULT);
expect(!is_allocated((vir_bytes) vvecp, PAGE_SIZE, &dummy));
got_result("unallocated virtual vector pointer");
munmap((void *) vvecp, PAGE_SIZE);
/* Test invalid physical vector pointer. */
r = do_vumap(SELF, vvec, 2, 0, VUA_READ, NULL, &pcount);
expect(r == EFAULT);
got_result("invalid physical vector pointer");
/* Test unallocated physical vector. */
pvecp = (struct vumap_phys *) mmap(NULL, PAGE_SIZE,
PROT_READ | PROT_WRITE, MAP_ANON, -1, 0L);
if (pvecp == MAP_FAILED)
panic("unable to allocate physical vector");
r = do_vumap(SELF, vvec, 2, 0, VUA_READ, pvecp, &pcount);
expect(r == OK);
expect(is_allocated((vir_bytes) pvecp, PAGE_SIZE, &dummy));
expect(pcount == 2);
expect(pvecp[0].vp_size == PAGE_SIZE * 2);
expect(pvecp[0].vp_addr == buf[0].phys);
expect(pvecp[1].vp_size == PAGE_SIZE);
expect(pvecp[1].vp_addr == buf[1].phys);
got_result("unallocated physical vector pointer");
munmap((void *) pvecp, PAGE_SIZE);
free_bufs(buf, 2);
}
static void test_grant(void)
{
struct vumap_vir vvec[2];
struct vumap_phys pvec[3];
struct buf buf[2];
int r, pcount;
test_group("grant");
buf[0].pages = 1;
buf[0].flags = BUF_PREALLOC;
buf[1].pages = 2;
buf[1].flags = BUF_PREALLOC;
alloc_bufs(buf, 2);
/* Test write-only access on read-only grant. */
grant_access = CPF_READ; /* override */
vvec[0].vv_addr = buf[0].addr;
vvec[0].vv_size = PAGE_SIZE;
pcount = 1;
r = do_vumap(SELF, vvec, 1, 0, VUA_WRITE, pvec, &pcount);
expect(r == EPERM);
got_result("write-only access on read-only grant");
/* Test read-write access on read-only grant. */
r = do_vumap(SELF, vvec, 1, 0, VUA_READ | VUA_WRITE, pvec, &pcount);
expect(r == EPERM);
got_result("read-write access on read-only grant");
/* Test read-only access on write-only grant. */
grant_access = CPF_WRITE; /* override */
r = do_vumap(SELF, vvec, 1, 0, VUA_READ, pvec, &pcount);
expect(r == EPERM);
got_result("read-only access on write-only grant");
/* Test read-write access on write grant. */
r = do_vumap(SELF, vvec, 1, 0, VUA_READ | VUA_WRITE, pvec, &pcount);
expect(r == EPERM);
got_result("read-write access on write-only grant");
/* Test read-only access on read-write grant. */
grant_access = CPF_READ | CPF_WRITE; /* override */
r = do_vumap(SELF, vvec, 1, 0, VUA_READ, pvec, &pcount);
expect(r == OK);
expect(pcount == 1);
expect(pvec[0].vp_size == PAGE_SIZE);
expect(pvec[0].vp_addr == buf[0].phys);
got_result("read-only access on read-write grant");
grant_access = 0; /* reset */
/* Test invalid grant. */
grant_exception = GE_INVALID;
vvec[0].vv_addr = buf[0].addr;
vvec[0].vv_size = PAGE_SIZE;
vvec[1].vv_addr = buf[1].addr;
vvec[1].vv_size = PAGE_SIZE * 2;
pcount = 3;
r = do_vumap(SELF, vvec, 2, 0, VUA_READ, pvec, &pcount);
expect(r == EINVAL);
got_result("invalid grant");
/* Test revoked grant. */
grant_exception = GE_REVOKED;
r = do_vumap(SELF, vvec, 2, 0, VUA_READ, pvec, &pcount);
expect(r == EPERM);
got_result("revoked grant");
grant_exception = GE_NONE;
free_bufs(buf, 2);
}
static void test_offset(void)
{
struct vumap_vir vvec[2];
struct vumap_phys pvec[3];
struct buf buf[4];
size_t off, off2;
int r, pcount;
test_group("offsets");
buf[0].pages = 1;
buf[0].flags = BUF_PREALLOC;
buf[1].pages = 2;
buf[1].flags = BUF_PREALLOC;
buf[2].pages = 1;
buf[2].flags = BUF_PREALLOC;
buf[3].pages = 1;
buf[3].flags = BUF_PREALLOC | BUF_ADJACENT;
alloc_bufs(buf, 4);
/* Test offset into aligned page. */
off = 123;
vvec[0].vv_addr = buf[0].addr;
vvec[0].vv_size = PAGE_SIZE;
pcount = 2;
r = do_vumap(SELF, vvec, 1, off, VUA_READ, pvec, &pcount);
expect(r == OK);
expect(pcount == 1);
expect(pvec[0].vp_addr == buf[0].phys + off);
expect(pvec[0].vp_size == vvec[0].vv_size - off);
got_result("offset into aligned page");
/* Test offset into unaligned page. */
off2 = 456;
assert(off + off2 < PAGE_SIZE);
vvec[0].vv_addr = buf[0].addr + off;
vvec[0].vv_size = PAGE_SIZE - off;
pcount = 2;
r = do_vumap(SELF, vvec, 1, off2, VUA_READ, pvec, &pcount);
expect(r == OK);
expect(pcount == 1);
expect(pvec[0].vp_addr == buf[0].phys + off + off2);
expect(pvec[0].vp_size == vvec[0].vv_size - off2);
got_result("offset into unaligned page");
/* Test offset into unaligned page set. */
off = 1234;
off2 = 567;
assert(off + off2 < PAGE_SIZE);
vvec[0].vv_addr = buf[1].addr + off;
vvec[0].vv_size = (PAGE_SIZE - off) * 2;
pcount = 3;
r = do_vumap(SELF, vvec, 1, off2, VUA_READ, pvec, &pcount);
expect(r == OK);
expect(pcount == 1);
expect(pvec[0].vp_addr == buf[1].phys + off + off2);
expect(pvec[0].vp_size == vvec[0].vv_size - off2);
got_result("offset into contiguous page set");
/* Test offset into noncontiguous page set. */
vvec[0].vv_addr = buf[2].addr + off;
vvec[0].vv_size = (PAGE_SIZE - off) * 2;
pcount = 3;
r = do_vumap(SELF, vvec, 1, off2, VUA_READ, pvec, &pcount);
expect(r == OK);
expect(pcount == 2);
expect(pvec[0].vp_addr == buf[2].phys + off + off2);
expect(pvec[0].vp_size == PAGE_SIZE - off - off2);
expect(pvec[1].vp_addr == buf[3].phys);
expect(pvec[1].vp_size == PAGE_SIZE - off);
got_result("offset into noncontiguous page set");
/* Test offset to last byte. */
off = PAGE_SIZE - off2 - 1;
vvec[0].vv_addr = buf[0].addr + off2;
vvec[0].vv_size = PAGE_SIZE - off2;
pcount = 2;
r = do_vumap(SELF, vvec, 1, off, VUA_READ, pvec, &pcount);
expect(r == OK);
expect(pcount == 1);
expect(pvec[0].vp_addr == buf[0].phys + off + off2);
expect(pvec[0].vp_size == 1);
got_result("offset to last byte");
/* Test offset at range end. */
off = 234;
vvec[0].vv_addr = buf[1].addr + off;
vvec[0].vv_size = PAGE_SIZE - off * 2;
vvec[1].vv_addr = vvec[0].vv_addr + vvec[0].vv_size;
vvec[1].vv_size = off;
r = do_vumap(SELF, vvec, 2, vvec[0].vv_size, VUA_READ, pvec, &pcount);
expect(r == EINVAL);
got_result("offset at range end");
/* Test offset beyond range end. */
vvec[0].vv_addr = buf[1].addr;
vvec[0].vv_size = PAGE_SIZE;
vvec[1].vv_addr = buf[1].addr + PAGE_SIZE;
vvec[1].vv_size = PAGE_SIZE;
r = do_vumap(SELF, vvec, 2, PAGE_SIZE + off, VUA_READ, pvec, &pcount);
expect(r == EINVAL);
got_result("offset beyond range end");
/* Test negative offset. */
vvec[0].vv_addr = buf[1].addr + off + off2;
vvec[0].vv_size = PAGE_SIZE;
r = do_vumap(SELF, vvec, 1, (size_t) -1, VUA_READ, pvec, &pcount);
expect(r == EINVAL);
got_result("negative offset");
free_bufs(buf, 4);
}
static void test_access(void)
{
struct vumap_vir vvec[3];
struct vumap_phys pvec[4], *pvecp;
struct buf buf[7];
int i, r, pcount, pindex;
test_group("access");
buf[0].pages = 1;
buf[0].flags = 0;
buf[1].pages = 1;
buf[1].flags = BUF_PREALLOC | BUF_ADJACENT;
buf[2].pages = 1;
buf[2].flags = BUF_ADJACENT;
alloc_bufs(buf, 3);
/* Test no access flags. */
vvec[0].vv_addr = buf[0].addr;
vvec[0].vv_size = PAGE_SIZE * 3;
pcount = 4;
r = do_vumap(SELF, vvec, 1, 0, 0, pvec, &pcount);
expect(r == EINVAL);
expect(!is_buf_allocated(&buf[0]));
expect(is_buf_allocated(&buf[1]));
expect(!is_buf_allocated(&buf[2]));
got_result("no access flags");
/* Test read-only access. */
vvec[0].vv_addr = buf[0].addr;
vvec[0].vv_size = PAGE_SIZE * 3;
pcount = 1;
r = do_vumap(SELF, vvec, 1, 0, VUA_READ, pvec, &pcount);
expect(r == EFAULT);
expect(!is_buf_allocated(&buf[0]));
expect(is_buf_allocated(&buf[1]));
expect(!is_buf_allocated(&buf[2]));
got_result("read-only access");
/* Test read-write access. */
vvec[0].vv_addr = buf[0].addr;
vvec[0].vv_size = PAGE_SIZE * 3;
pcount = 4;
r = do_vumap(SELF, vvec, 1, 0, VUA_READ | VUA_WRITE, pvec, &pcount);
expect(r == EFAULT);
expect(!is_buf_allocated(&buf[0]));
expect(is_buf_allocated(&buf[1]));
expect(!is_buf_allocated(&buf[2]));
got_result("read-write access");
/* Test write-only access. */
vvec[0].vv_addr = buf[0].addr;
vvec[0].vv_size = PAGE_SIZE * 3;
pcount = 4;
r = do_vumap(SELF, vvec, 1, 0, VUA_WRITE, pvec, &pcount);
expect(r == OK);
/* We don't control the physical addresses of the faulted-in pages, so
* they may or may not end up being contiguous with their neighbours.
*/
expect(pcount >= 1 && pcount <= 3);
expect(is_buf_allocated(&buf[0]));
expect(is_buf_allocated(&buf[1]));
expect(is_buf_allocated(&buf[2]));
expect(pvec[0].vp_addr == buf[0].phys);
switch (pcount) {
case 1:
expect(pvec[0].vp_size == PAGE_SIZE * 3);
break;
case 2:
expect(pvec[0].vp_size + pvec[1].vp_size == PAGE_SIZE * 3);
if (pvec[0].vp_size > PAGE_SIZE)
expect(pvec[1].vp_addr == buf[2].phys);
else
expect(pvec[1].vp_addr == buf[1].phys);
break;
case 3:
expect(pvec[0].vp_size == PAGE_SIZE);
expect(pvec[1].vp_addr == buf[1].phys);
expect(pvec[1].vp_size == PAGE_SIZE);
expect(pvec[2].vp_addr == buf[2].phys);
expect(pvec[2].vp_size == PAGE_SIZE);
break;
}
got_result("write-only access");
free_bufs(buf, 3);
/* Test page faulting. */
buf[0].pages = 1;
buf[0].flags = 0;
buf[1].pages = 1;
buf[1].flags = BUF_PREALLOC | BUF_ADJACENT;
buf[2].pages = 1;
buf[2].flags = 0;
buf[3].pages = 2;
buf[3].flags = BUF_PREALLOC;
buf[4].pages = 1;
buf[4].flags = BUF_ADJACENT;
buf[5].pages = 1;
buf[5].flags = BUF_ADJACENT;
buf[6].pages = 1;
buf[6].flags = 0;
alloc_bufs(buf, 7);
vvec[0].vv_addr = buf[0].addr + PAGE_SIZE - 1;
vvec[0].vv_size = PAGE_SIZE - 1;
vvec[1].vv_addr = buf[2].addr;
vvec[1].vv_size = PAGE_SIZE;
vvec[2].vv_addr = buf[3].addr + 123;
vvec[2].vv_size = PAGE_SIZE * 4 - 456;
pvecp = (struct vumap_phys *) buf[6].addr;
pcount = 7;
assert(sizeof(struct vumap_phys) * pcount <= PAGE_SIZE);
r = do_vumap(SELF, vvec, 3, 0, VUA_WRITE, pvecp, &pcount);
expect(r == OK);
/* Same story but more possibilities. I hope I got this right. */
expect(pcount >= 3 || pcount <= 6);
for (i = 0; i < 7; i++)
expect(is_buf_allocated(&buf[i]));
expect(pvecp[0].vp_addr = buf[0].phys);
if (pvecp[0].vp_size == 1) {
expect(pvecp[1].vp_addr == buf[1].phys);
expect(pvecp[1].vp_size == PAGE_SIZE - 2);
pindex = 2;
} else {
expect(pvecp[0].vp_size == PAGE_SIZE - 1);
pindex = 1;
}
expect(pvecp[pindex].vp_addr == buf[2].phys);
expect(pvecp[pindex].vp_size == PAGE_SIZE);
pindex++;
expect(pvecp[pindex].vp_addr == buf[3].phys + 123);
switch (pcount - pindex) {
case 1:
expect(pvecp[pindex].vp_size == PAGE_SIZE * 4 - 456);
break;
case 2:
if (pvecp[pindex].vp_size > PAGE_SIZE * 2 - 123) {
expect(pvecp[pindex].vp_size == PAGE_SIZE * 3 - 123);
expect(pvecp[pindex + 1].vp_addr == buf[5].phys);
expect(pvecp[pindex + 1].vp_size ==
PAGE_SIZE - (456 - 123));
} else {
expect(pvecp[pindex].vp_size == PAGE_SIZE * 2 - 123);
expect(pvecp[pindex + 1].vp_addr == buf[4].phys);
expect(pvecp[pindex + 1].vp_size ==
PAGE_SIZE * 2 - (456 - 123));
}
break;
case 3:
expect(pvecp[pindex].vp_size == PAGE_SIZE * 2 - 123);
expect(pvecp[pindex + 1].vp_addr == buf[4].phys);
expect(pvecp[pindex + 1].vp_size == PAGE_SIZE);
expect(pvecp[pindex + 2].vp_addr == buf[5].phys);
expect(pvecp[pindex + 2].vp_size == PAGE_SIZE - (456 - 123));
break;
default:
expect(0);
}
got_result("page faulting");
free_bufs(buf, 7);
/* MISSING: tests to see whether a request with VUA_WRITE or
* (VUA_READ|VUA_WRITE) correctly gets an EFAULT for a read-only page.
* As of writing, support for such protection is missing from the
* system at all.
*/
}
static void phys_limit(struct vumap_vir *vvec, int vcount,
struct vumap_phys *pvec, int pcount, struct buf *buf, char *desc)
{
int i, r;
r = do_vumap(SELF, vvec, vcount, 0, VUA_READ, pvec, &pcount);
expect(r == OK);
expect(pcount == MAPVEC_NR);
for (i = 0; i < MAPVEC_NR; i++) {
expect(pvec[i].vp_addr == buf[i].phys);
expect(pvec[i].vp_size == PAGE_SIZE);
}
got_result(desc);
}
static void test_limits(void)
{
struct vumap_vir vvec[MAPVEC_NR + 3];
struct vumap_phys pvec[MAPVEC_NR + 3];
struct buf buf[MAPVEC_NR + 9];
int i, r, vcount, pcount, nr_bufs;
test_group("limits");
/* Test large contiguous range. */
buf[0].pages = MAPVEC_NR + 2;
buf[0].flags = BUF_PREALLOC;
alloc_bufs(buf, 1);
vvec[0].vv_addr = buf[0].addr;
vvec[0].vv_size = (MAPVEC_NR + 2) * PAGE_SIZE;
pcount = 2;
r = do_vumap(SELF, vvec, 1, 0, VUA_READ, pvec, &pcount);
expect(r == OK);
expect(pcount == 1);
expect(pvec[0].vp_addr == buf[0].phys);
expect(pvec[0].vp_size == vvec[0].vv_size);
got_result("large contiguous range");
free_bufs(buf, 1);
/* I'd like to test MAPVEC_NR contiguous ranges of MAPVEC_NR pages
* each, but chances are we don't have that much contiguous memory
* available at all. In fact, the previous test may already fail
* because of this..
*/
for (i = 0; i < MAPVEC_NR + 2; i++) {
buf[i].pages = 1;
buf[i].flags = BUF_PREALLOC;
}
buf[i].pages = 1;
buf[i].flags = BUF_PREALLOC | BUF_ADJACENT;
alloc_bufs(buf, MAPVEC_NR + 3);
/* Test virtual limit, one below. */
for (i = 0; i < MAPVEC_NR + 2; i++) {
vvec[i].vv_addr = buf[i].addr;
vvec[i].vv_size = PAGE_SIZE;
}
vvec[i - 1].vv_size += PAGE_SIZE;
pcount = MAPVEC_NR + 3;
r = do_vumap(SELF, vvec, MAPVEC_NR - 1, 0, VUA_READ, pvec, &pcount);
expect(r == OK);
expect(pcount == MAPVEC_NR - 1);
for (i = 0; i < MAPVEC_NR - 1; i++) {
expect(pvec[i].vp_addr == buf[i].phys);
expect(pvec[i].vp_size == PAGE_SIZE);
}
got_result("virtual limit, one below");
/* Test virtual limit, exact match. */
pcount = MAPVEC_NR + 3;
r = do_vumap(SELF, vvec, MAPVEC_NR, 0, VUA_WRITE, pvec, &pcount);
expect(r == OK);
expect(pcount == MAPVEC_NR);
for (i = 0; i < MAPVEC_NR; i++) {
expect(pvec[i].vp_addr == buf[i].phys);
expect(pvec[i].vp_size == PAGE_SIZE);
}
got_result("virtual limit, exact match");
/* Test virtual limit, one above. */
pcount = MAPVEC_NR + 3;
r = do_vumap(SELF, vvec, MAPVEC_NR + 1, 0, VUA_READ, pvec, &pcount);
expect(r == OK);
expect(pcount == MAPVEC_NR);
for (i = 0; i < MAPVEC_NR; i++) {
expect(pvec[i].vp_addr == buf[i].phys);
expect(pvec[i].vp_size == PAGE_SIZE);
}
got_result("virtual limit, one above");
/* Test virtual limit, two above. */
pcount = MAPVEC_NR + 3;
r = do_vumap(SELF, vvec, MAPVEC_NR + 2, 0, VUA_WRITE, pvec, &pcount);
expect(r == OK);
expect(pcount == MAPVEC_NR);
for (i = 0; i < MAPVEC_NR; i++) {
expect(pvec[i].vp_addr == buf[i].phys);
expect(pvec[i].vp_size == PAGE_SIZE);
}
got_result("virtual limit, two above");
/* Test physical limit, one below, aligned. */
pcount = MAPVEC_NR - 1;
r = do_vumap(SELF, vvec + 2, MAPVEC_NR, 0, VUA_READ, pvec, &pcount);
expect(r == OK);
expect(pcount == MAPVEC_NR - 1);
for (i = 0; i < MAPVEC_NR - 1; i++) {
expect(pvec[i].vp_addr == buf[i + 2].phys);
expect(pvec[i].vp_size == PAGE_SIZE);
}
got_result("physical limit, one below, aligned");
/* Test physical limit, one below, unaligned. */
pcount = MAPVEC_NR - 1;
r = do_vumap(SELF, vvec + 3, MAPVEC_NR, 0, VUA_READ, pvec, &pcount);
expect(r == OK);
expect(pcount == MAPVEC_NR - 1);
for (i = 0; i < MAPVEC_NR - 1; i++) {
expect(pvec[i].vp_addr == buf[i + 3].phys);
expect(pvec[i].vp_size == PAGE_SIZE);
}
got_result("physical limit, one below, unaligned");
free_bufs(buf, MAPVEC_NR + 3);
nr_bufs = sizeof(buf) / sizeof(buf[0]);
/* This ends up looking in our virtual address space as follows:
* [P] [P] [P] [PPP] [PPP] ...(MAPVEC_NR x [PPP])... [PPP]
* ..where P is a page, and the blocks are virtually contiguous.
*/
for (i = 0; i < nr_bufs; i += 3) {
buf[i].pages = 1;
buf[i].flags = BUF_PREALLOC;
buf[i + 1].pages = 1;
buf[i + 1].flags =
BUF_PREALLOC | ((i >= 3) ? BUF_ADJACENT : 0);
buf[i + 2].pages = 1;
buf[i + 2].flags =
BUF_PREALLOC | ((i >= 3) ? BUF_ADJACENT : 0);
}
alloc_bufs(buf, nr_bufs);
for (i = 0; i < 3; i++) {
vvec[i].vv_addr = buf[i].addr;
vvec[i].vv_size = PAGE_SIZE;
}
for ( ; i < nr_bufs / 3 + 1; i++) {
vvec[i].vv_addr = buf[(i - 2) * 3].addr;
vvec[i].vv_size = PAGE_SIZE * 3;
}
vcount = i;
/* Out of each of the following tests, one will be aligned (that is,
* the last pvec entry will be for the last page in a vvec entry) and
* two will be unaligned.
*/
/* Test physical limit, exact match. */
phys_limit(vvec, vcount, pvec, MAPVEC_NR, buf,
"physical limit, exact match, try 1");
phys_limit(vvec + 1, vcount - 1, pvec, MAPVEC_NR, buf + 1,
"physical limit, exact match, try 2");
phys_limit(vvec + 2, vcount - 2, pvec, MAPVEC_NR, buf + 2,
"physical limit, exact match, try 3");
/* Test physical limit, one above. */
phys_limit(vvec, vcount, pvec, MAPVEC_NR + 1, buf,
"physical limit, one above, try 1");
phys_limit(vvec + 1, vcount - 1, pvec, MAPVEC_NR + 1, buf + 1,
"physical limit, one above, try 2");
phys_limit(vvec + 2, vcount - 2, pvec, MAPVEC_NR + 1, buf + 2,
"physical limit, one above, try 3");
/* Test physical limit, two above. */
phys_limit(vvec, vcount, pvec, MAPVEC_NR + 2, buf,
"physical limit, two above, try 1");
phys_limit(vvec + 1, vcount - 1, pvec, MAPVEC_NR + 2, buf + 1,
"physical limit, two above, try 2");
phys_limit(vvec + 2, vcount - 2, pvec, MAPVEC_NR + 2, buf + 2,
"physical limit, two above, try 3");
free_bufs(buf, nr_bufs);
}
static void do_tests(int use_relay)
{
relay = use_relay;
test_basics();
if (!relay) test_endpt(); /* local only */
test_vector1();
if (!relay) test_vector2(); /* local only */
if (relay) test_grant(); /* remote only */
test_offset();
test_access();
test_limits();
}
static int sef_cb_init_fresh(int UNUSED(type), sef_init_info_t *UNUSED(info))
{
int r;
verbose = (env_argc > 1 && !strcmp(env_argv[1], "-v"));
if (verbose)
printf("Starting sys_vumap test set\n");
do_tests(FALSE /*use_relay*/);
if ((r = ds_retrieve_label_endpt("vumaprelay", &endpt)) != OK)
panic("unable to obtain endpoint for 'vumaprelay' (%d)", r);
do_tests(TRUE /*use_relay*/);
if (verbose)
printf("Completed sys_vumap test set, %u/%u tests failed\n",
failures, count);
/* The returned code will determine the outcome of the RS call, and
* thus the entire test. The actual error code does not matter.
*/
return (failures) ? EINVAL : OK;
}
static void sef_local_startup(void)
{
sef_setcb_init_fresh(sef_cb_init_fresh);
sef_startup();
}
int main(int argc, char **argv)
{
env_setargs(argc, argv);
sef_local_startup();
return 0;
}
Reference in a new issue View git blame Copy permalink