| 1 |
/* COVERAGE: mmap mmap2 mmap_pgoff munmap msync */ |
| 2 |
/* COVERAGE: mlock mlock2 mlockall munlock munlockall */ |
| 3 |
/* COVERAGE: mprotect mremap */ |
| 4 |
#include <sys/types.h> |
| 5 |
#include <sys/stat.h> |
| 6 |
#define __USE_GNU |
| 7 |
#include <sys/mman.h> |
| 8 |
#include <fcntl.h> |
| 9 |
#include <unistd.h> |
| 10 |
#include <sys/syscall.h> |
| 11 |
#include <sys/mman.h> |
| 12 |
|
| 13 |
#ifdef __NR_mlock2 |
| 14 |
|
| 15 |
#ifndef MLOCK_ONFAULT |
| 16 |
#define MLOCK_ONFAULT 0x01 |
| 17 |
#endif |
| 18 |
|
| 19 |
static inline int __mlock2(const void *start, size_t len, int flags) |
| 20 |
{ |
| 21 |
return syscall(__NR_mlock2, start, len, flags); |
| 22 |
} |
| 23 |
#endif |
| 24 |
|
| 25 |
int main() |
| 26 |
{ |
| 27 |
mlockall(MCL_CURRENT); |
| 28 |
|
| 29 |
int fd, ret; |
| 30 |
struct stat fs; |
| 31 |
void * r; |
| 32 |
|
| 33 |
/* create a file with something in it */ |
| 34 |
fd = open("foobar",O_WRONLY|O_CREAT|O_TRUNC, 0600); |
| 35 |
//staptest// [[[[open (!!!!openat (AT_FDCWD, ]]]]"foobar", O_WRONLY|O_CREAT[[[[.O_LARGEFILE]]]]?|O_TRUNC, 0600) = NNNN |
| 36 |
|
| 37 |
// Why 64k? ppc64 has 64K pages. ia64 has 16k |
| 38 |
// pages. x86_64/i686 has 4k pages. When we specify an offset |
| 39 |
// to mmap(), it must be a multiple of the page size, so we |
| 40 |
// use the biggest. |
| 41 |
lseek(fd, 65536, SEEK_SET); |
| 42 |
write(fd, "abcdef", 6); |
| 43 |
close(fd); |
| 44 |
//staptest// close (NNNN) = 0 |
| 45 |
|
| 46 |
fd = open("foobar", O_RDONLY); |
| 47 |
//staptest// [[[[open (!!!!openat (AT_FDCWD, ]]]]"foobar", O_RDONLY[[[[.O_LARGEFILE]]]]?) = NNNN |
| 48 |
|
| 49 |
/* stat for file size */ |
| 50 |
ret = fstat(fd, &fs); |
| 51 |
//staptest// [[[[[[[[fstat (NNNN, XXXX)!!!!fstatat (3, "", XXXX, AT_EMPTY_PATH)]]]]!!!!statx (3, "", AT_NO_AUTOMOUNT|AT_EMPTY_PATH, XXXX, XXXX)]]]] = 0 |
| 52 |
|
| 53 |
r = mmap(NULL, 4096, PROT_READ, MAP_SHARED, fd, 0); |
| 54 |
//staptest// mmap[2]* (0x0, 4096, PROT_READ, MAP_SHARED, NNNN, 0) = XXXX |
| 55 |
|
| 56 |
mlock(r, 4096); |
| 57 |
//staptest// mlock (XXXX, 4096) = 0 |
| 58 |
|
| 59 |
mlock((void *)-1, 4096); |
| 60 |
//staptest// mlock (0x[f]+, 4096) = NNNN |
| 61 |
|
| 62 |
mlock(0, -1); |
| 63 |
#if __WORDSIZE == 64 |
| 64 |
//staptest// mlock (0x[0]+, 18446744073709551615) = NNNN |
| 65 |
#else |
| 66 |
//staptest// mlock (0x[0]+, 4294967295) = NNNN |
| 67 |
#endif |
| 68 |
|
| 69 |
#ifdef __NR_mlock2 |
| 70 |
{ |
| 71 |
void *r2 = mmap(NULL, 12288, PROT_READ|PROT_WRITE, |
| 72 |
MAP_PRIVATE|MAP_ANONYMOUS, -1, 0); |
| 73 |
//staptest// mmap[2]* (0x0, 12288, PROT_READ|PROT_WRITE, MAP_PRIVATE|MAP_ANONYMOUS, -1, 0) = XXXX |
| 74 |
|
| 75 |
__mlock2(r2, 4096, MLOCK_ONFAULT); |
| 76 |
//staptest// mlock2 (XXXX, 4096, MLOCK_ONFAULT) = 0 |
| 77 |
|
| 78 |
__mlock2((void *)-1, 4096, 0); |
| 79 |
//staptest// mlock2 (0x[f]+, 4096, 0x0) = NNNN |
| 80 |
|
| 81 |
__mlock2(0, -1, 0); |
| 82 |
#if __WORDSIZE == 64 |
| 83 |
//staptest// mlock2 (0x[0]+, 18446744073709551615, 0x0) = NNNN |
| 84 |
#else |
| 85 |
//staptest// mlock2 (0x[0]+, 4294967295, 0x0) = NNNN |
| 86 |
#endif |
| 87 |
|
| 88 |
__mlock2(0, 4096, -1); |
| 89 |
//staptest// mlock2 (0x[0]+, 4096, MLOCK_ONFAULT|XXXX) = NNNN |
| 90 |
|
| 91 |
munlock(r2, 4096); |
| 92 |
//staptest// munlock (XXXX, 4096) = 0 |
| 93 |
} |
| 94 |
#endif |
| 95 |
|
| 96 |
msync(r, 4096, MS_SYNC); |
| 97 |
//staptest// msync (XXXX, 4096, MS_SYNC) = 0 |
| 98 |
|
| 99 |
msync((void *)-1, 4096, MS_SYNC); |
| 100 |
//staptest// msync (0x[f]+, 4096, MS_SYNC) = NNNN |
| 101 |
|
| 102 |
msync(r, -1, MS_SYNC); |
| 103 |
#if __WORDSIZE == 64 |
| 104 |
//staptest// msync (XXXX, 18446744073709551615, MS_SYNC) = NNNN |
| 105 |
#else |
| 106 |
//staptest// msync (XXXX, 4294967295, MS_SYNC) = NNNN |
| 107 |
#endif |
| 108 |
|
| 109 |
msync(r, 4096, -1); |
| 110 |
//staptest// msync (XXXX, 4096, MS_[^ ]+|XXXX) = NNNN |
| 111 |
|
| 112 |
munlock(r, 4096); |
| 113 |
//staptest// munlock (XXXX, 4096) = 0 |
| 114 |
|
| 115 |
mlockall(MCL_CURRENT); |
| 116 |
//staptest// mlockall (MCL_CURRENT) = |
| 117 |
|
| 118 |
mlockall(-1); |
| 119 |
//staptest// mlockall (MCL_[^ ]+|XXXX) = NNNN |
| 120 |
|
| 121 |
munlockall(); |
| 122 |
//staptest// munlockall () = 0 |
| 123 |
|
| 124 |
munmap(r, 4096); |
| 125 |
//staptest// munmap (XXXX, 4096) = 0 |
| 126 |
|
| 127 |
// Ensure the 6th argument is handled correctly.. |
| 128 |
r = mmap(NULL, 6, PROT_READ, MAP_PRIVATE, fd, 65536); |
| 129 |
//staptest// mmap[2]* (0x0, 6, PROT_READ, MAP_PRIVATE, NNNN, 65536) = XXXX |
| 130 |
|
| 131 |
munmap(r, 6); |
| 132 |
//staptest// munmap (XXXX, 6) = 0 |
| 133 |
|
| 134 |
close(fd); |
| 135 |
|
| 136 |
r = mmap(NULL, 12288, PROT_READ|PROT_WRITE, MAP_PRIVATE|MAP_ANONYMOUS, -1, 0); |
| 137 |
//staptest// mmap[2]* (0x0, 12288, PROT_READ|PROT_WRITE, MAP_PRIVATE|MAP_ANONYMOUS, -1, 0) = XXXX |
| 138 |
|
| 139 |
mprotect(r, 4096, PROT_READ|PROT_EXEC); |
| 140 |
//staptest// mprotect (XXXX, 4096, PROT_READ|PROT_EXEC) = 0 |
| 141 |
|
| 142 |
mprotect(r, 4096, PROT_GROWSDOWN|PROT_GROWSUP); |
| 143 |
//staptest// mprotect (XXXX, 4096, PROT_GROWSDOWN|PROT_GROWSUP) = -XXXX (EINVAL) |
| 144 |
|
| 145 |
#ifdef PROT_SAO |
| 146 |
mprotect(r, 4096, PROT_SAO); |
| 147 |
//staptest// mprotect (XXXX, 4096, PROT_SAO) = |
| 148 |
#endif |
| 149 |
|
| 150 |
munmap(r, 12288); |
| 151 |
//staptest// munmap (XXXX, 12288) = 0 |
| 152 |
|
| 153 |
r = mmap(NULL, 8192, PROT_READ|PROT_WRITE, MAP_PRIVATE|MAP_ANONYMOUS, -1, 0); |
| 154 |
//staptest// mmap[2]* (0x0, 8192, PROT_READ|PROT_WRITE, MAP_PRIVATE|MAP_ANONYMOUS, -1, 0) = XXXX |
| 155 |
|
| 156 |
r = mremap(r, 8192, 4096, 0); |
| 157 |
//staptest// mremap (XXXX, 8192, 4096, 0x0, XXXX) = XXXX |
| 158 |
|
| 159 |
munmap(r, 4096); |
| 160 |
//staptest// munmap (XXXX, 4096) = 0 |
| 161 |
|
| 162 |
// powerpc64's glibc rejects this one. On ia64, the call |
| 163 |
// fails, while on most other architectures it works. So, |
| 164 |
// ignore the return values. |
| 165 |
#ifndef __powerpc64__ |
| 166 |
r = mmap((void *)-1, 8192, PROT_READ|PROT_WRITE, MAP_PRIVATE|MAP_ANONYMOUS, -1, 0); |
| 167 |
//staptest// mmap[2]* (0x[f]+, 8192, PROT_READ|PROT_WRITE, MAP_PRIVATE|MAP_ANONYMOUS, -1, 0) = |
| 168 |
|
| 169 |
munmap(r, 8192); |
| 170 |
//staptest// munmap (XXXX, 8192) = |
| 171 |
#endif |
| 172 |
|
| 173 |
r = mmap(NULL, -1, PROT_READ|PROT_WRITE, MAP_PRIVATE|MAP_ANONYMOUS, -1, 0); |
| 174 |
#if __WORDSIZE == 64 |
| 175 |
//staptest// mmap[2]* (0x0, 18446744073709551615, PROT_READ|PROT_WRITE, MAP_PRIVATE|MAP_ANONYMOUS, -1, 0) = -XXXX (ENOMEM) |
| 176 |
#else |
| 177 |
//staptest// mmap[2]* (0x0, 4294967295, PROT_READ|PROT_WRITE, MAP_PRIVATE|MAP_ANONYMOUS, -1, 0) = -XXXX (ENOMEM) |
| 178 |
#endif |
| 179 |
|
| 180 |
// powerpc's glibc (both 32-bit and 64-bit) rejects this one. |
| 181 |
#ifndef __powerpc__ |
| 182 |
r = mmap(NULL, 8192, -1, MAP_PRIVATE|MAP_ANONYMOUS, -1, 0); |
| 183 |
//staptest// mmap[2]* (0x0, 8192, PROT_[^ ]+|XXXX, MAP_PRIVATE|MAP_ANONYMOUS, -1, 0) = XXXX |
| 184 |
|
| 185 |
munmap(r, 8192); |
| 186 |
//staptest// munmap (XXXX, 8192) = 0 |
| 187 |
#endif |
| 188 |
|
| 189 |
r = mmap(NULL, 8192, PROT_READ|PROT_WRITE, -1, -1, 0); |
| 190 |
//staptest// mmap[2]* (0x0, 8192, PROT_READ|PROT_WRITE, MAP_[^ ]+|XXXX, -1, 0) = -XXXX |
| 191 |
|
| 192 |
// Unfortunately, glibc and/or the syscall wrappers will |
| 193 |
// reject a -1 offset, especially on a 32-bit exe on a 64-bit |
| 194 |
// OS. So, we can't really test this one. |
| 195 |
// |
| 196 |
// r = mmap(NULL, 8192, PROT_READ|PROT_WRITE, MAP_PRIVATE|MAP_ANONYMOUS, -1, -1); |
| 197 |
|
| 198 |
munmap((void *)-1, 8192); |
| 199 |
//staptest// munmap (0x[f]+, 8192) = NNNN |
| 200 |
|
| 201 |
munmap(r, -1); |
| 202 |
#if __WORDSIZE == 64 |
| 203 |
//staptest// munmap (XXXX, 18446744073709551615) = NNNN |
| 204 |
#else |
| 205 |
//staptest// munmap (XXXX, 4294967295) = NNNN |
| 206 |
#endif |
| 207 |
|
| 208 |
#ifdef MAP_STACK |
| 209 |
r = mmap(NULL, 0, PROT_READ|PROT_WRITE, MAP_PRIVATE|MAP_ANONYMOUS|MAP_STACK, -1, 0); |
| 210 |
//staptest// mmap[2]* (0x0, 0, PROT_READ|PROT_WRITE, MAP_PRIVATE|MAP_ANONYMOUS|MAP_STACK, -1, 0) = -XXXX |
| 211 |
#endif |
| 212 |
|
| 213 |
#ifdef MAP_HUGETLB |
| 214 |
r = mmap(NULL, 0, PROT_READ|PROT_WRITE, MAP_PRIVATE|MAP_ANONYMOUS|MAP_HUGETLB, -1, 0); |
| 215 |
//staptest// mmap[2]* (0x0, 0, PROT_READ|PROT_WRITE, MAP_PRIVATE|MAP_ANONYMOUS|MAP_HUGETLB, -1, 0) = -XXXX |
| 216 |
|
| 217 |
#ifdef MAP_HUGE_SHIFT |
| 218 |
r = mmap(NULL, 0, PROT_READ|PROT_WRITE, MAP_PRIVATE|MAP_ANONYMOUS|MAP_HUGETLB|(21 << MAP_HUGE_SHIFT), -1, 0); |
| 219 |
//staptest// mmap[2]* (0x0, 0, PROT_READ|PROT_WRITE, MAP_HUGE_2MB|MAP_PRIVATE|MAP_ANONYMOUS|MAP_HUGETLB, -1, 0) = -XXXX |
| 220 |
#endif |
| 221 |
#endif |
| 222 |
|
| 223 |
#ifdef MAP_UNINITIALIZED |
| 224 |
r = mmap(NULL, 0, PROT_READ|PROT_WRITE, MAP_PRIVATE|MAP_ANONYMOUS|MAP_UNINITIALIZED, -1, 0); |
| 225 |
//staptest// mmap[2]* (0x0, 0, PROT_READ|PROT_WRITE, MAP_PRIVATE|MAP_ANONYMOUS|MAP_UNINITIALIZED, -1, 0) = -XXXX |
| 226 |
#endif |
| 227 |
|
| 228 |
#ifdef MAP_32BIT |
| 229 |
r = mmap(NULL, 0, PROT_READ|PROT_WRITE, MAP_PRIVATE|MAP_ANONYMOUS|MAP_32BIT, -1, 0); |
| 230 |
//staptest// mmap[2]* (0x0, 0, PROT_READ|PROT_WRITE, MAP_PRIVATE|MAP_ANONYMOUS|MAP_32BIT, -1, 0) = -XXXX |
| 231 |
#endif |
| 232 |
|
| 233 |
return 0; |
| 234 |
} |