/* * 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 }