/*
* test_mmap_prot_anon -- test R/W protection on anonymous mappings
*/
static void
test_mmap_prot_anon(void)
{
char *ptr1;
/* read/write */
ptr1 = mmap(NULL, FILE_SIZE, PROT_READ|PROT_WRITE,
MAP_SHARED|MAP_ANON, -1, 0);
UT_ASSERTne(ptr1, MAP_FAILED);
check_mapping(-1, ptr1, FILE_SIZE, PROT_READ|PROT_WRITE, 0, 0);
/* read-only */
ptr1 = mmap(NULL, FILE_SIZE, PROT_READ, MAP_SHARED|MAP_ANON, -1, 0);
UT_ASSERTne(ptr1, MAP_FAILED);
check_mapping(-1, ptr1, FILE_SIZE, PROT_READ, 0, 0);
/* no access */
ptr1 = mmap(NULL, FILE_SIZE, PROT_NONE, MAP_SHARED|MAP_ANON, -1, 0);
#ifndef _WIN32
UT_ASSERTne(ptr1, MAP_FAILED);
check_mapping(-1, ptr1, FILE_SIZE, PROT_NONE, 0, 0);
#else
/* XXX - PROT_NONE not supported yet */
UT_ASSERTeq(ptr1, MAP_FAILED);
#endif
}
/*
* test_mmap_fixed -- test MAP_FIXED flag
*/
static void
test_mmap_fixed(int fd)
{
char *ptr1;
char *ptr2;
/* map entire file first to get unused address */
ptr1 = mmap(NULL, FILE_SIZE, PROT_READ|PROT_WRITE,
MAP_PRIVATE, fd, 0);
UT_ASSERTne(ptr1, MAP_FAILED);
check_mapping(fd, ptr1, FILE_SIZE, PROT_READ|PROT_WRITE, CHECK_PRIV, 0);
/* now try to map a part of it at specified address */
ptr2 = mmap(ptr1 + MMAP_ALIGN, MMAP_SIZE, PROT_READ|PROT_WRITE,
MAP_PRIVATE|MAP_FIXED, fd, 0);
UT_ASSERTeq(ptr2, ptr1 + MMAP_ALIGN);
check_mapping(fd, ptr2, MMAP_SIZE, PROT_READ|PROT_WRITE, CHECK_PRIV, 0);
/* non-aligned hint address - should fail */
ptr2 = mmap(ptr1 + 100, MMAP_SIZE, PROT_READ|PROT_WRITE,
MAP_PRIVATE|MAP_FIXED, fd, 0);
UT_ASSERTeq(ptr2, MAP_FAILED);
/* hint address is busy */
ptr1 = mmap(NULL, MMAP_SIZE * 2, PROT_READ|PROT_WRITE,
MAP_PRIVATE, fd, 0);
UT_ASSERTne(ptr1, MAP_FAILED);
ptr2 = mmap(ptr1 + MMAP_SIZE, MMAP_SIZE, PROT_READ|PROT_WRITE,
MAP_PRIVATE|MAP_FIXED, fd, 0);
UT_ASSERTne(ptr2, MAP_FAILED);
UT_ASSERTeq(ptr2, ptr1 + MMAP_SIZE);
check_mapping(fd, ptr1, MMAP_SIZE, PROT_READ|PROT_WRITE, CHECK_PRIV, 0);
check_mapping(fd, ptr2, MMAP_SIZE, PROT_READ|PROT_WRITE, CHECK_PRIV, 0);
}
static int
is_directed_automorphism(struct saucy *s)
{
int i, j;
for (i = 0; i < s->ndiffs; ++i) {
j = s->unsupp[i];
if (!check_mapping(s, s->adj, s->edg, j)) return 0;
if (!check_mapping(s, s->dadj, s->dedg, j)) return 0;
}
return 1;
}
static void
is_directed_automorphism(void)
{
int i;
/* Iterate through the vertices */
for (i = 0, flag = 1; flag && (i < n); ++i) {
if (i == gamma[i]) continue;
check_mapping(aout, eout, i);
if (!flag) break;
check_mapping(ain, ein, i);
}
}
/*
* test_mmap_prot -- test R/W protection
*/
static void
test_mmap_prot(int fd, int fd_ro)
{
char *ptr1;
/* read/write */
ptr1 = mmap(NULL, FILE_SIZE, PROT_READ|PROT_WRITE, MAP_SHARED, fd, 0);
UT_ASSERTne(ptr1, MAP_FAILED);
check_mapping(fd, ptr1, FILE_SIZE, PROT_READ|PROT_WRITE, 0, 0);
/* read/write on file opened in read-only mode - should fail */
errno = 0;
ptr1 = mmap(NULL, FILE_SIZE, PROT_READ|PROT_WRITE,
MAP_SHARED, fd_ro, 0);
UT_ASSERTeq(ptr1, MAP_FAILED);
UT_ASSERTeq(errno, EACCES);
/* read-only */
ptr1 = mmap(NULL, FILE_SIZE, PROT_READ, MAP_SHARED, fd, 0);
UT_ASSERTne(ptr1, MAP_FAILED);
check_mapping(fd, ptr1, FILE_SIZE, PROT_READ, 0, 0);
/* read-only on file opened in read-only mode - should succeed */
ptr1 = mmap(NULL, FILE_SIZE, PROT_READ, MAP_SHARED, fd_ro, 0);
UT_ASSERTne(ptr1, MAP_FAILED);
check_mapping(fd_ro, ptr1, FILE_SIZE, PROT_READ, CHECK_RO, 0);
/* no access */
ptr1 = mmap(NULL, FILE_SIZE, PROT_NONE, MAP_SHARED, fd, 0);
#ifndef _WIN32
UT_ASSERTne(ptr1, MAP_FAILED);
check_mapping(fd, ptr1, FILE_SIZE, PROT_NONE, 0, 0);
#else
/* XXX - PROT_NONE not supported yet */
UT_ASSERTeq(ptr1, MAP_FAILED);
#endif
/* no access on read-only file */
ptr1 = mmap(NULL, FILE_SIZE, PROT_NONE, MAP_SHARED, fd_ro, 0);
#ifndef _WIN32
UT_ASSERTne(ptr1, MAP_FAILED);
check_mapping(fd_ro, ptr1, FILE_SIZE, PROT_NONE, CHECK_RO, 0);
#else
/* XXX - PROT_NONE not supported yet */
UT_ASSERTeq(ptr1, MAP_FAILED);
#endif
}
/*
* test_mmap_shared -- test shared mappings
*/
static void
test_mmap_shared(int fd)
{
char *ptr1;
ptr1 = mmap(NULL, FILE_SIZE, PROT_READ|PROT_WRITE, MAP_SHARED, fd, 0);
UT_ASSERTne(ptr1, MAP_FAILED);
check_mapping(fd, ptr1, FILE_SIZE, PROT_READ|PROT_WRITE, 0, 0);
}
bool TestSuite::testParityBinaryImageWrite()
{
try {
utils::Task::ArgumentVector arguments;
utils::Path cfile = utils::Path::getTemporary(".parity.testsuite.link.XXXXXX.c");
utils::Path ofile = utils::Path::getTemporary(".parity.testsuite.link.XXXXXX.exe");
std::ofstream ofs(cfile.get().c_str());
ofs << dataCFile;
ofs.close();
utils::Context::getContext().getTemporaryFiles().push_back(cfile);
utils::Context::getContext().getTemporaryFiles().push_back(ofile);
arguments.push_back(cfile.get());
arguments.push_back("-o");
arguments.push_back(ofile.get());
if(!executeParity(arguments, false))
throw utils::Exception("cannot execute parity for test suite!");
if(!ofile.exists())
throw utils::Exception("missing executable file from compile!");
utils::Log::verbose("doing parsed copy of %s...\n", ofile.get().c_str());
utils::MappedFile mapping(ofile, utils::ModeRead);
//utils::MappedFile mapping(utils::Path("test.exe"), utils::ModeRead);
binary::Image img(&mapping);
utils::Log::verbose("testing original file:\n");
testFileHeader(img.getHeader());
utils::Path temp = utils::Path::getTemporary(".parity.testsuite.image.XXXXXX.exe");
utils::Context::getContext().getTemporaryFiles().push_back(temp);
utils::MemoryFile file;
img.update(file);
file.save(temp);
utils::MappedFile check_mapping(temp, utils::ModeRead);
binary::Image check_img(&check_mapping);
utils::Log::verbose("testing parsed copy of executable:\n");
testFileHeader(check_img.getHeader());
return true;
} catch(const utils::Exception& e)
{
utils::Log::warning("catched: %s\n", e.what());
}
return false;
}
int main(int argc, char *argv[]) {
size_t num_bytes = sysconf(_SC_PAGESIZE);
int fd = open(DUMMY_FILE, O_CREAT | O_EXCL | O_RDWR, 0600);
int* wpage;
int* rpage;
int* old_wpage;
test_assert(fd >= 0);
overwrite_file(DUMMY_FILE, 2 * num_bytes);
wpage = mmap(NULL, num_bytes, PROT_READ | PROT_WRITE,
MAP_SHARED, fd, 0);
rpage = mmap(NULL, num_bytes, PROT_READ,
MAP_SHARED, fd, 0);
atomic_printf("wpage:%p rpage:%p\n", wpage, rpage);
test_assert(wpage != (void*)-1 && rpage != (void*)-1
&& rpage != wpage);
/* NB: this is a bad test in that it assumes
* ADDR_COMPAT_LAYOUT address-space allocation semantics. If
* this test is run "normally", it will most likely fail this
* assertion. To fix this we'd need to dyanmically determine
* which page is mapped just before the other and then remap
* that page. */
test_assert((byte*)rpage - (byte*)wpage == num_bytes);
check_mapping(rpage, wpage, num_bytes / sizeof(*wpage));
overwrite_file(DUMMY_FILE, 2 * num_bytes);
old_wpage = wpage;
wpage = mremap(old_wpage, num_bytes, 2 * num_bytes, MREMAP_MAYMOVE);
atomic_printf("remapped wpage:%p\n", wpage);
test_assert(wpage != (void*)-1 && wpage != old_wpage);
check_mapping(rpage, wpage, num_bytes / sizeof(*wpage));
atomic_puts(" done");
return 0;
}
static void
is_undirected_automorphism(void)
{
int i;
/* Iterate through the vertices */
for (i = 0, flag = 1; flag && (i < n); ++i) {
if (i == gamma[i]) continue;
check_mapping(adj, edg, i);
}
}
void checkLookUp(void* physbase, void* physfree,uint64_t cr3_content){
uint64_t start = (uint64_t) physbase;
uint64_t end = (uint64_t)physfree;
uint64_t i = 0;
start = start + VIRTUAL_BASE_ADDRESS;
end = end + VIRTUAL_BASE_ADDRESS;
int matched = 0;
while(start <= end){
if(check_mapping(start,cr3_content)==1)
matched+=1;
start = start + PAGE_SIZE;
i+=1;
}
// ////print("----Matched = %d---",matched);
// ////print("----Total pages = %d--",i);
uint64_t video_memory_base = VIRTUAL_BASE_ADDRESS + video_memory;
uint64_t value_returned = check_mapping(video_memory_base,cr3_content);
if((value_returned+VIRTUAL_BASE_ADDRESS) == video_memory_base){
// ////print("------Video Mmeory Mapped-----");
}
}
void validate_mapping_table(const char *testbed, unsigned int num_members, const char *uids[], unsigned int num_uids)
{
unsigned int member;
unsigned int uid;
osync_trace(TRACE_ENTRY, "%s(%s, %i, %p, %i)", __func__, testbed, num_members, uids, num_uids);
char *path = g_strdup_printf("%s/configs/group/archive.db", testbed);
OSyncMappingTable *maptable = mappingtable_load(path, "mockobjtype1", num_uids);
g_free(path);
/* check we have num_members mapping entries for each uid */
for (uid = 0; uid < num_uids; uid++) {
for (member = 1; member <= num_members; member++) {
check_mapping(maptable, member, -1, num_members, uids[uid]);
}
}
osync_mapping_table_close(maptable);
osync_mapping_table_unref(maptable);
osync_trace(TRACE_EXIT, "%s", __func__);
}
int main(void) {
size_t num_bytes = sysconf(_SC_PAGESIZE);
char file_name[] = "/tmp/rr-test-mremap-XXXXXX";
int fd = mkstemp(file_name);
int* rpage;
test_assert(fd >= 0);
int magic = 0x5a5a5a5a;
size_t i;
for (i = 0; i < 3 * num_bytes / sizeof(magic); ++i) {
pwrite64(fd, &magic, sizeof(magic), i * sizeof(magic));
}
rpage = mmap(NULL, num_bytes, PROT_READ, MAP_SHARED, fd, 0);
atomic_printf("rpage:%p\n", rpage);
test_assert(rpage != (void*)-1);
magic = 0xa5a5a5a5;
for (i = 0; i < num_bytes / sizeof(magic); ++i) {
pwrite64(fd, &magic, sizeof(magic), i * sizeof(magic));
}
check_mapping(rpage, 0xa5a5a5a5, num_bytes / sizeof(*rpage));
magic = 0x5a5a5a5a;
for (i = 0; i < num_bytes / sizeof(magic); ++i) {
pwrite64(fd, &magic, sizeof(magic), i * sizeof(magic));
}
check_mapping(rpage, 0x5a5a5a5a, num_bytes / sizeof(*rpage));
magic = 0xa5a5a5a5;
for (i = 0; i < num_bytes / sizeof(magic); ++i) {
pwrite64(fd, &magic, sizeof(magic), num_bytes + i * sizeof(magic));
}
check_mapping(rpage, 0x5a5a5a5a, num_bytes / sizeof(*rpage));
magic = 0xdeadbeef;
pwrite64(fd, &magic, sizeof(magic), num_bytes / 2);
test_assert(rpage[num_bytes / (sizeof(magic) * 2)] == magic);
test_assert(rpage[0] != magic);
pwrite64(fd, &magic, sizeof(magic), num_bytes - 2);
test_assert(rpage[num_bytes / sizeof(magic) - 1] == (int)0xbeef5a5a);
rpage = mremap(rpage, num_bytes, 5 * num_bytes, MREMAP_MAYMOVE);
for (i = 3 * num_bytes / sizeof(magic); i < 5 * num_bytes / sizeof(magic);
++i) {
pwrite64(fd, &magic, sizeof(magic), i * sizeof(magic));
}
check_mapping(&rpage[(3 * num_bytes) / sizeof(magic)], 0xdeadbeef,
2 * num_bytes / sizeof(*rpage));
munmap(rpage, 5 * num_bytes);
// The case when all pages have been unmapped is special in the
// implementation - make sure it gets sufficient coverage
write(fd, &magic, sizeof(magic));
write(fd, &magic, sizeof(magic));
rpage = mmap(NULL, num_bytes, PROT_READ, MAP_SHARED, fd, 0);
atomic_printf("rpage:%p\n", rpage);
test_assert(rpage != (void*)-1);
// This tests both that the monitor gets activated again if the page is
// remapped and that `write` works on a monitored page.
lseek(fd, 0, SEEK_SET);
magic = 0xb6b6b6b6;
for (i = 0; i < num_bytes / sizeof(magic); ++i) {
write(fd, &magic, sizeof(magic));
}
check_mapping(rpage, magic, num_bytes / sizeof(*rpage));
atomic_puts("EXIT-SUCCESS");
return 0;
}
/*
* test_munmap -- test mapping deletion
*/
static void
test_munmap(int fd)
{
char *ptr1;
char *ptr2;
ptr1 = mmap(NULL, FILE_SIZE, PROT_READ|PROT_WRITE, MAP_SHARED, fd, 0);
UT_ASSERTne(ptr1, MAP_FAILED);
/* unaligned address - should fail */
errno = 0;
UT_ASSERTeq(munmap(ptr1 + 100, FILE_SIZE), -1);
UT_ASSERTeq(errno, EINVAL);
check_mapping(fd, ptr1, FILE_SIZE, PROT_READ|PROT_WRITE, 0, 0);
/* unaligned length - should succeed */
UT_ASSERTeq(munmap(ptr1, FILE_SIZE - 100), 0);
check_mapping(fd, ptr1, FILE_SIZE, PROT_NONE, 0, 0);
check_mapping(fd, ptr1 + FILE_SIZE - 100, 100, PROT_NONE, 0, 0);
ptr1 = mmap(NULL, FILE_SIZE, PROT_READ|PROT_WRITE, MAP_SHARED, fd, 0);
UT_ASSERTne(ptr1, MAP_FAILED);
/* len == 0 - should fail */
errno = 0;
UT_ASSERTne(munmap(ptr1, 0), 0);
UT_ASSERTeq(errno, EINVAL);
check_mapping(fd, ptr1, FILE_SIZE, PROT_READ|PROT_WRITE, 0, 0);
ptr1 = mmap(NULL, FILE_SIZE, PROT_READ|PROT_WRITE, MAP_SHARED, fd, 0);
UT_ASSERTne(ptr1, MAP_FAILED);
/* delete entire mapping (len > file_size) */
UT_ASSERTeq(munmap(ptr1, FILE_SIZE + MMAP_SIZE), 0);
check_mapping(fd, ptr1, FILE_SIZE, PROT_NONE, 0, 0);
/* delete non existing mapping - should succeed */
UT_ASSERTeq(munmap(ptr1, FILE_SIZE), 0);
ptr1 = mmap(NULL, FILE_SIZE, PROT_READ|PROT_WRITE, MAP_SHARED, fd, 0);
UT_ASSERTne(ptr1, MAP_FAILED);
/* partial unmap */
UT_ASSERTeq(munmap(ptr1, MMAP_SIZE), 0);
check_mapping(fd, ptr1, MMAP_SIZE, PROT_NONE, 0, 0);
check_mapping(fd, ptr1 + MMAP_SIZE, FILE_SIZE - MMAP_SIZE,
PROT_READ|PROT_WRITE, 0, MMAP_SIZE);
/* unmap pages from two adjacent mappings */
ptr1 = mmap(ptr1, MMAP_SIZE * 2, PROT_READ|PROT_WRITE,
MAP_SHARED, fd, 0);
UT_ASSERTne(ptr1, MAP_FAILED);
ptr2 = mmap(ptr1 + MMAP_SIZE * 2, MMAP_SIZE * 2, PROT_READ|PROT_WRITE,
MAP_SHARED, fd, MMAP_SIZE * 2);
UT_ASSERTeq(ptr2, ptr1 + MMAP_SIZE * 2);
UT_ASSERTeq(munmap(ptr1 + MMAP_SIZE, MMAP_SIZE * 2), 0);
check_mapping(fd, ptr1, MMAP_SIZE, PROT_READ|PROT_WRITE, 0, 0);
check_mapping(fd, ptr1 + MMAP_SIZE, MMAP_SIZE * 2,
PROT_NONE, 0, MMAP_SIZE);
check_mapping(fd, ptr1 + MMAP_SIZE * 3, MMAP_SIZE,
PROT_READ|PROT_WRITE, 0, MMAP_SIZE * 3);
}
/*
* test_mmap_anon -- test anonymous mappings
*/
static void
test_mmap_anon(int fd)
{
char *ptr1;
char *ptr2;
/* fd == -1, but no MAP_ANON - should fail */
ptr1 = mmap(NULL, FILE_SIZE, PROT_READ|PROT_WRITE,
MAP_SHARED, -1, 0);
UT_ASSERTeq(ptr1, MAP_FAILED);
/* fd should be ignored */
ptr1 = mmap(NULL, FILE_SIZE, PROT_READ|PROT_WRITE,
MAP_ANON|MAP_SHARED, fd, 0);
UT_ASSERTne(ptr1, MAP_FAILED);
check_mapping(-1, ptr1, FILE_SIZE, PROT_READ|PROT_WRITE, 0, 0);
/* offset should be ignored */
ptr1 = mmap(NULL, FILE_SIZE, PROT_READ|PROT_WRITE,
MAP_ANON|MAP_SHARED, -1, MMAP_ALIGN);
UT_ASSERTne(ptr1, MAP_FAILED);
check_mapping(-1, ptr1, FILE_SIZE, PROT_READ|PROT_WRITE, 0, 0);
/* now try to map a part of it at specified address */
ptr2 = mmap(ptr1 + MMAP_ALIGN, MMAP_SIZE, PROT_READ|PROT_WRITE,
MAP_ANON|MAP_SHARED, -1, 0);
UT_ASSERTeq(ptr2, ptr1 + MMAP_ALIGN);
check_mapping(-1, ptr2, MMAP_SIZE, PROT_READ|PROT_WRITE, 0, 0);
/* non-aligned hint address - should be ignored */
ptr2 = mmap(ptr1 + 100, MMAP_SIZE, PROT_READ|PROT_WRITE,
MAP_ANON|MAP_SHARED, -1, 0);
UT_ASSERTne(ptr2, MAP_FAILED);
UT_ASSERTne(ptr2, ptr1 + 100);
check_mapping(-1, ptr2, MMAP_SIZE, PROT_READ|PROT_WRITE, 0, 0);
/* non-aligned hint address + MAP_FIXED - should fail */
ptr2 = mmap(ptr1 + 100, MMAP_SIZE, PROT_READ|PROT_WRITE,
MAP_ANON|MAP_SHARED|MAP_FIXED, -1, 0);
UT_ASSERTeq(ptr2, MAP_FAILED);
/* hint address is busy */
ptr1 = mmap(NULL, FILE_SIZE / 2, PROT_READ|PROT_WRITE,
MAP_ANON|MAP_SHARED, -1, 0);
UT_ASSERTne(ptr1, MAP_FAILED);
ptr2 = mmap(ptr1 + MMAP_SIZE, MMAP_SIZE, PROT_READ|PROT_WRITE,
MAP_ANON|MAP_SHARED, -1, 0);
UT_ASSERTne(ptr2, MAP_FAILED);
UT_ASSERT(ptr2 < ptr1 || ptr2 >= ptr1 + FILE_SIZE / 2);
munmap(ptr1, FILE_SIZE / 2);
check_mapping(-1, ptr2, MMAP_SIZE, PROT_READ|PROT_WRITE, 0, 0);
/* hint address is busy + MAP_FIXED */
ptr1 = mmap(NULL, MMAP_SIZE * 2, PROT_READ|PROT_WRITE,
MAP_ANON|MAP_SHARED, -1, 0);
UT_ASSERTne(ptr1, MAP_FAILED);
ptr2 = mmap(ptr1 + MMAP_SIZE, MMAP_SIZE, PROT_READ|PROT_WRITE,
MAP_ANON|MAP_SHARED|MAP_FIXED, -1, 0);
UT_ASSERTne(ptr2, MAP_FAILED);
UT_ASSERTeq(ptr2, ptr1 + MMAP_SIZE);
check_mapping(-1, ptr1, MMAP_SIZE, PROT_READ|PROT_WRITE, 0, 0);
check_mapping(-1, ptr2, MMAP_SIZE, PROT_READ|PROT_WRITE, 0, 0);
}
/*
* test_mmap_len -- test various lengths and offsets
*/
static void
test_mmap_len(int fd)
{
char *ptr;
/* len == 0 */
ptr = mmap(NULL, 0, PROT_READ|PROT_WRITE,
MAP_PRIVATE, fd, 0);
UT_ASSERTeq(ptr, MAP_FAILED);
/* len > file_size */
ptr = mmap(NULL, FILE_SIZE + MMAP_SIZE, PROT_READ|PROT_WRITE,
MAP_PRIVATE, fd, 0);
UT_ASSERTne(ptr, MAP_FAILED);
check_mapping(fd, ptr, FILE_SIZE, PROT_READ|PROT_WRITE, CHECK_PRIV, 0);
UT_ASSERTeq(munmap(ptr + FILE_SIZE, MMAP_SIZE), 0);
/* offset == 0 */
ptr = mmap(NULL, MMAP_SIZE, PROT_READ|PROT_WRITE,
MAP_SHARED, fd, 0);
UT_ASSERTne(ptr, MAP_FAILED);
check_mapping(fd, ptr, MMAP_SIZE, PROT_READ|PROT_WRITE, 0, 0);
/* offset == PAGE_SIZE */
ptr = mmap(NULL, MMAP_SIZE, PROT_READ|PROT_WRITE,
MAP_SHARED, fd, PAGE_SIZE);
#ifndef _WIN32
UT_ASSERTne(ptr, MAP_FAILED);
check_mapping(fd, ptr, MMAP_SIZE, PROT_READ|PROT_WRITE, 0, PAGE_SIZE);
#else
/* XXX - on Windows, offset must be aligned to allocation granularity */
UT_ASSERTeq(ptr, MAP_FAILED);
#endif
/* offset == MMAP_ALIGN */
ptr = mmap(NULL, MMAP_SIZE, PROT_READ|PROT_WRITE,
MAP_SHARED, fd, MMAP_ALIGN);
UT_ASSERTne(ptr, MAP_FAILED);
check_mapping(fd, ptr, MMAP_SIZE, PROT_READ|PROT_WRITE, 0, MMAP_ALIGN);
/* unaligned offset */
ptr = mmap(NULL, MMAP_SIZE, PROT_READ|PROT_WRITE, MAP_SHARED, fd, 100);
UT_ASSERTeq(ptr, MAP_FAILED);
/* offset + len > file_size */
ptr = mmap(NULL, FILE_SIZE, PROT_READ|PROT_WRITE,
MAP_PRIVATE, fd, MMAP_SIZE);
UT_ASSERTne(ptr, MAP_FAILED);
check_mapping(fd, ptr, FILE_SIZE - MMAP_SIZE, PROT_READ|PROT_WRITE,
CHECK_PRIV, MMAP_SIZE);
UT_ASSERTeq(munmap(ptr + FILE_SIZE - MMAP_SIZE, MMAP_SIZE), 0);
/* offset beyond file_size */
ptr = mmap(NULL, MMAP_SIZE, PROT_READ, MAP_SHARED, fd,
FILE_SIZE + MMAP_SIZE);
#ifndef _WIN32
UT_ASSERTne(ptr, MAP_FAILED);
check_mapping(fd, ptr, MMAP_SIZE, PROT_READ, CHECK_PRIV,
FILE_SIZE + MMAP_SIZE);
#else
UT_ASSERTeq(ptr, MAP_FAILED);
#endif
}
