354 lines
11 KiB
C
354 lines
11 KiB
C
/*
|
|
* vlibc — sys/mman.h test (task 33).
|
|
*
|
|
* Exercises the mmap family end to end over the raw syscall wrappers:
|
|
*
|
|
* 1. Anonymous mmap of one page → readable/writable, write + read-back
|
|
* round-trip, munmap releases it.
|
|
* 2. mmap PROT_NONE succeeds; mprotect to PROT_READ|PROT_WRITE makes the
|
|
* page writable (the write succeeds and reads back).
|
|
* 3. msync MS_SYNC on a MAP_SHARED file mapping flushes the pointer
|
|
* writes to the backing file: a read() of the same fd afterwards sees
|
|
* the data written through the mapping.
|
|
* 4. mlock/munlock of an anonymous page, and mlockall/munlockall,
|
|
* return 0.
|
|
* 5. posix_madvise (POSIX_MADV_DONTNEED) returns 0.
|
|
* 6. MAP_SHARED file mapping round-trip is proven by scenario 3 (write
|
|
* via the mapping, read back through the fd).
|
|
*
|
|
* Level-2 gated section: madvise(MADV_DONTNEED) returns 0, and POSIX
|
|
* shared memory round-trips: shm_open creates a /dev/shm object, a write
|
|
* survives close, a second shm_open (no O_CREAT) re-opens the same object
|
|
* and reads the data back (proving the real-file backing), and shm_unlink
|
|
* removes it.
|
|
*
|
|
* The -f mode runs the failure scenarios — mmap MAP_FIXED at an unaligned
|
|
* address → MAP_FAILED, munmap of that address → -1, shm_open of a name
|
|
* containing '/' → -1. These make the LIBRARY write errno (syscall_ret),
|
|
* which under a host-linked binary targets glibc's private dtv slot at
|
|
* %fs:0+8; the process therefore exits via raw SYS_exit_group without
|
|
* running host cleanup (house pattern, tests/test_unistd_file.c). In the
|
|
* default mode every exercised call succeeds, so no library errno write
|
|
* happens; the one host-TCB slot-1 save/restore at main brackets the whole
|
|
* run anyway (task 13 technique), keeping host state intact for the return
|
|
* through __libc_start_main. The test NEVER reads errno; every negative is
|
|
* asserted on the return value only.
|
|
*
|
|
* All diagnostics go through raw SYS_write (no stdio): under -Iinclude the
|
|
* vlibc public headers shadow GCC's internal ones, so a host header would
|
|
* not compile. Not part of the library proper; compiled manually for this
|
|
* todo (the tests/ + make check wiring is owned by a later todo).
|
|
*/
|
|
|
|
#include "../include/fcntl.h"
|
|
#include "../include/sys/mman.h"
|
|
#include "../include/unistd.h"
|
|
|
|
#include "../src/internal/syscall.h"
|
|
|
|
static int failures;
|
|
|
|
/* Write a NUL-terminated string to fd via the raw syscall layer. The
|
|
* optimize attribute keeps GCC from lowering the length loop into a
|
|
* strlen call, which would leave a vlibc-owned symbol undefined in this
|
|
* host-linked standalone binary (house idiom, see src/string). */
|
|
static __attribute__((optimize("no-tree-loop-distribute-patterns"))) void
|
|
say(int fd, const char *s)
|
|
{
|
|
long n = 0;
|
|
|
|
while (s[n] != '\0')
|
|
{
|
|
n++;
|
|
}
|
|
__syscall3(SYS_write, fd, (long)s, n);
|
|
}
|
|
|
|
static void
|
|
check(int cond, const char *what)
|
|
{
|
|
if (cond)
|
|
{
|
|
say(1, "PASS: ");
|
|
say(1, what);
|
|
say(1, "\n");
|
|
}
|
|
else
|
|
{
|
|
say(2, "FAIL: ");
|
|
say(2, what);
|
|
say(2, "\n");
|
|
failures++;
|
|
}
|
|
}
|
|
|
|
/*
|
|
* Host-TCB slot-1 bracket: the library's errno write on a negative path
|
|
* lands at %fs:0+8, glibc's dtv pointer. Save and restore it around the
|
|
* whole default-mode run; only vlibc/raw-syscall code runs in between
|
|
* (task 13 technique).
|
|
*/
|
|
static unsigned long
|
|
tcb_slot1(void)
|
|
{
|
|
return *(unsigned long *)((char *)__builtin_thread_pointer() + 8);
|
|
}
|
|
|
|
static void
|
|
tcb_slot1_set(unsigned long value)
|
|
{
|
|
*(unsigned long *)((char *)__builtin_thread_pointer() + 8) = value;
|
|
}
|
|
|
|
/* Fill buf with the repeating pattern i * 7 + 1 (unsigned char). */
|
|
static void
|
|
fill_pattern(unsigned char *buf, unsigned long n)
|
|
{
|
|
unsigned long i;
|
|
|
|
for (i = 0; i < n; i++)
|
|
{
|
|
buf[i] = (unsigned char)(i * 7 + 1);
|
|
}
|
|
}
|
|
|
|
/* 1+2: anonymous mappings, protection change. */
|
|
static void
|
|
anon_scenarios(void)
|
|
{
|
|
static unsigned char pattern[4096];
|
|
unsigned char *p;
|
|
unsigned long i;
|
|
int ok = 1;
|
|
|
|
fill_pattern(pattern, sizeof(pattern));
|
|
p = mmap(NULL, 4096, PROT_READ | PROT_WRITE, MAP_PRIVATE | MAP_ANON, -1, 0);
|
|
check(p != MAP_FAILED && p != NULL, "mmap 4096 anonymous returns a mapping");
|
|
if (p != MAP_FAILED && p != NULL)
|
|
{
|
|
for (i = 0; i < 4096; i++)
|
|
{
|
|
p[i] = pattern[i];
|
|
}
|
|
for (i = 0; i < 4096; i++)
|
|
{
|
|
if (p[i] != pattern[i])
|
|
{
|
|
ok = 0;
|
|
}
|
|
}
|
|
check(ok, "write + read-back round-trips on the anonymous mapping");
|
|
check(munmap(p, 4096) == 0, "munmap of the anonymous mapping returns 0");
|
|
}
|
|
|
|
p = mmap(NULL, 4096, PROT_NONE, MAP_PRIVATE | MAP_ANON, -1, 0);
|
|
check(p != MAP_FAILED && p != NULL, "mmap 4096 PROT_NONE anonymous returns a mapping");
|
|
if (p != MAP_FAILED && p != NULL)
|
|
{
|
|
check(mprotect(p, 4096, PROT_READ | PROT_WRITE) == 0,
|
|
"mprotect(PROT_NONE -> PROT_READ|PROT_WRITE) returns 0");
|
|
p[0] = 'P';
|
|
p[1] = 'W';
|
|
check(p[0] == 'P' && p[1] == 'W', "the page is writable after mprotect");
|
|
check(munmap(p, 4096) == 0, "munmap of the mprotect page returns 0");
|
|
}
|
|
}
|
|
|
|
/* 3+6: msync + MAP_SHARED file visibility, plus the mlock family (4+5). */
|
|
static void
|
|
file_and_lock_scenarios(const char *path)
|
|
{
|
|
static unsigned char pattern[4096];
|
|
unsigned char *p;
|
|
unsigned char rbuf[16];
|
|
int fd;
|
|
|
|
fill_pattern(pattern, sizeof(pattern));
|
|
fd = open(path, O_RDWR | O_CREAT | O_TRUNC, 0600);
|
|
check(fd >= 0, "open creates the msync backing file");
|
|
if (fd < 0)
|
|
{
|
|
return;
|
|
}
|
|
check(write(fd, pattern, sizeof(pattern)) == (ssize_t)sizeof(pattern),
|
|
"write of 4096 bytes to the backing file returns 4096");
|
|
p = mmap(NULL, 4096, PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0);
|
|
check(p != MAP_FAILED && p != NULL, "mmap MAP_SHARED of the file returns a mapping");
|
|
if (p != MAP_FAILED && p != NULL)
|
|
{
|
|
p[0] = 'M';
|
|
p[1] = 'S';
|
|
p[2] = 'Y';
|
|
p[3] = 'N';
|
|
p[4] = 'C';
|
|
p[5] = '!';
|
|
check(msync(p, 4096, MS_SYNC) == 0, "msync MS_SYNC returns 0");
|
|
check(lseek(fd, 0, SEEK_SET) == 0, "lseek back to offset 0 returns 0");
|
|
check(read(fd, rbuf, sizeof(rbuf)) == (ssize_t)sizeof(rbuf),
|
|
"read of the backing file returns 16 bytes");
|
|
check(rbuf[0] == 'M' && rbuf[1] == 'S' && rbuf[2] == 'Y' && rbuf[3] == 'N' &&
|
|
rbuf[4] == 'C' && rbuf[5] == '!',
|
|
"the msync'd mapping writes are visible through the fd");
|
|
check(munmap(p, 4096) == 0, "munmap of the shared mapping returns 0");
|
|
}
|
|
check(close(fd) == 0, "close of the backing file returns 0");
|
|
|
|
{
|
|
unsigned char *q;
|
|
|
|
q = mmap(NULL, 4096, PROT_READ | PROT_WRITE, MAP_PRIVATE | MAP_ANON, -1, 0);
|
|
check(q != MAP_FAILED && q != NULL, "mmap a page for the mlock family");
|
|
if (q != MAP_FAILED && q != NULL)
|
|
{
|
|
q[0] = 'L';
|
|
check(mlock(q, 4096) == 0, "mlock of the page returns 0");
|
|
check(munlock(q, 4096) == 0, "munlock of the page returns 0");
|
|
check(munmap(q, 4096) == 0, "munmap of the mlock page returns 0");
|
|
}
|
|
}
|
|
check(mlockall(MCL_CURRENT | MCL_FUTURE) == 0, "mlockall(MCL_CURRENT|MCL_FUTURE) returns 0");
|
|
check(munlockall() == 0, "munlockall returns 0");
|
|
|
|
{
|
|
unsigned char *r;
|
|
|
|
r = mmap(NULL, 4096, PROT_READ | PROT_WRITE, MAP_PRIVATE | MAP_ANON, -1, 0);
|
|
check(r != MAP_FAILED && r != NULL, "mmap a page for posix_madvise");
|
|
if (r != MAP_FAILED && r != NULL)
|
|
{
|
|
check(posix_madvise(r, 4096, POSIX_MADV_DONTNEED) == 0,
|
|
"posix_madvise(POSIX_MADV_DONTNEED) returns 0");
|
|
check(munmap(r, 4096) == 0, "munmap of the posix_madvise page returns 0");
|
|
}
|
|
}
|
|
}
|
|
|
|
#if VLIBC_LEVEL_GE(2)
|
|
|
|
/* Level 2: madvise and POSIX shared memory (real /dev/shm objects). */
|
|
static void
|
|
level2_scenarios(void)
|
|
{
|
|
const char *name = "vlibc-t33-shm";
|
|
unsigned char *p;
|
|
char rbuf[16];
|
|
int fd;
|
|
int fd2;
|
|
|
|
p = mmap(NULL, 4096, PROT_READ | PROT_WRITE, MAP_PRIVATE | MAP_ANON, -1, 0);
|
|
check(p != MAP_FAILED && p != NULL, "mmap a page for madvise");
|
|
if (p != MAP_FAILED && p != NULL)
|
|
{
|
|
p[0] = 'D';
|
|
check(madvise(p, 4096, MADV_DONTNEED) == 0, "madvise(MADV_DONTNEED) returns 0");
|
|
check(munmap(p, 4096) == 0, "munmap of the madvise page returns 0");
|
|
}
|
|
|
|
fd = shm_open(name, O_RDWR | O_CREAT, 0600);
|
|
check(fd >= 0, "shm_open creates the shared memory object");
|
|
if (fd < 0)
|
|
{
|
|
return;
|
|
}
|
|
check(write(fd, "shmdata", 7) == 7, "write to the shm object returns 7");
|
|
check(close(fd) == 0, "close of the shm object returns 0");
|
|
fd2 = shm_open(name, O_RDWR, 0);
|
|
check(fd2 >= 0, "shm_open re-opens the object without O_CREAT");
|
|
if (fd2 >= 0)
|
|
{
|
|
check(read(fd2, rbuf, sizeof(rbuf)) == 7, "read of the re-opened object returns 7");
|
|
check(rbuf[0] == 's' && rbuf[1] == 'h' && rbuf[2] == 'm' && rbuf[3] == 'd' &&
|
|
rbuf[4] == 'a' && rbuf[5] == 't' && rbuf[6] == 'a',
|
|
"the re-opened object holds the earlier write (file-backed)");
|
|
check(close(fd2) == 0, "close of the re-opened object returns 0");
|
|
}
|
|
check(shm_unlink(name) == 0, "shm_unlink removes the object");
|
|
}
|
|
|
|
#endif /* VLIBC_LEVEL_GE(2) */
|
|
|
|
/*
|
|
* Failure scenarios (-f): every assertion is on the return value only, and
|
|
* the process exits through raw SYS_exit_group because the library writes
|
|
* errno on these paths (host-TCB hazard).
|
|
*/
|
|
static int
|
|
failure_scenarios(void)
|
|
{
|
|
int rc = 0;
|
|
|
|
if (mmap((void *)0x1, 4096, PROT_READ | PROT_WRITE, MAP_PRIVATE | MAP_ANON | MAP_FIXED, -1,
|
|
0) != MAP_FAILED)
|
|
{
|
|
say(2, "FAIL: mmap MAP_FIXED at an unaligned address did not return MAP_FAILED\n");
|
|
rc = 1;
|
|
}
|
|
else
|
|
{
|
|
say(1, "PASS: mmap MAP_FIXED at 0x1 -> MAP_FAILED\n");
|
|
}
|
|
if (munmap((void *)0x1, 4096) != -1)
|
|
{
|
|
say(2, "FAIL: munmap of an unaligned address did not return -1\n");
|
|
rc = 1;
|
|
}
|
|
else
|
|
{
|
|
say(1, "PASS: munmap((void *)0x1, 4096) -> -1\n");
|
|
}
|
|
#if VLIBC_LEVEL_GE(2)
|
|
if (shm_open("bad/name", O_RDWR | O_CREAT, 0600) != -1)
|
|
{
|
|
say(2, "FAIL: shm_open of a name containing '/' did not return -1\n");
|
|
rc = 1;
|
|
}
|
|
else
|
|
{
|
|
say(1, "PASS: shm_open(\"bad/name\") -> -1\n");
|
|
}
|
|
#endif
|
|
return rc;
|
|
}
|
|
|
|
int
|
|
main(int argc, char **argv)
|
|
{
|
|
const char *path = "/tmp/vlibc-t33-shmfile";
|
|
unsigned long saved;
|
|
int rc;
|
|
|
|
if (argc == 2 && argv[1][0] == '-' && argv[1][1] == 'f')
|
|
{
|
|
/*
|
|
* The failure scenarios write errno inside the library; under the
|
|
* host libc that slot is glibc's private TLS state, so leave via
|
|
* the raw syscall without running host cleanup.
|
|
*/
|
|
rc = failure_scenarios();
|
|
__syscall1(SYS_exit_group, rc);
|
|
return rc; /* not reached */
|
|
}
|
|
|
|
/* Bracket the whole default-mode run against the host-TCB hazard. */
|
|
saved = tcb_slot1();
|
|
anon_scenarios();
|
|
file_and_lock_scenarios(path);
|
|
#if VLIBC_LEVEL_GE(2)
|
|
level2_scenarios();
|
|
#endif
|
|
__syscall3(SYS_unlinkat, AT_FDCWD, (long)path, 0);
|
|
|
|
if (failures > 0)
|
|
{
|
|
say(2, "FAILED: one or more mman checks failed\n");
|
|
rc = 1;
|
|
}
|
|
else
|
|
{
|
|
say(1, "all mman tests passed\n");
|
|
rc = 0;
|
|
}
|
|
tcb_slot1_set(saved);
|
|
return rc;
|
|
}
|