1 /* Test 74 - mmap functionality & regression test. 2 * 3 * This test tests some basic functionality of mmap, and also some 4 * cases that are quite complex for the system to handle. 5 * 6 * Memory pages are generally made available on demand. Memory copying 7 * is done by the kernel. As the kernel may encounter pagefaults in 8 * legitimate memory ranges (e.g. pages that aren't mapped; pages that 9 * are mapped RO as they are COW), it cooperates with VM to make the 10 * mappings and let the copy succeed transparently. 11 * 12 * With file-mapped ranges this can result in a deadlock, if care is 13 * not taken, as the copy might be request by VFS or an FS. This test 14 * triggers as many of these states as possible to ensure they are 15 * successful or (where appropriate) fail gracefully, i.e. without 16 * deadlock. 17 * 18 * To do this, system calls are done with source or target buffers with 19 * missing or readonly mappings, both anonymous and file-mapped. The 20 * cache is flushed before mmap() so that we know the mappings should 21 * not be present on mmap() time. Then e.g. a read() or write() is 22 * executed with that buffer as target. This triggers a FS copying 23 * to or from a missing range that it itself is needed to map in first. 24 * VFS detects this, requests VM to map in the pages, which does so with 25 * the help of another VFS thread and the FS, and then re-issues the 26 * request to the FS. 27 * 28 * Another case is the VFS itself does such a copy. This is actually 29 * unusual as filenames are already faulted in by the requesting process 30 * in libc by strlen(). select() allows such a case, however, so this 31 * is tested too. We are satisfied if the call completes. 32 */ 33 34 #include <sys/types.h> 35 #include <sys/mman.h> 36 #include <sys/ioctl.h> 37 #include <sys/ioc_memory.h> 38 #include <sys/param.h> 39 #include <stdio.h> 40 #include <assert.h> 41 #include <string.h> 42 #include <stdlib.h> 43 #include <unistd.h> 44 #include <fcntl.h> 45 #include <dirent.h> 46 47 #include "common.h" 48 #include "testcache.h" 49 50 int max_error = 0; /* make all e()'s fatal */ 51 52 int 53 dowriteblock(int b, int blocksize, u32_t seed, char *data) 54 { 55 u64_t offset; 56 int fd; 57 58 get_fd_offset(b, blocksize, &offset, &fd); 59 60 if(pwrite(fd, data, blocksize, offset) < blocksize) { 61 perror("pwrite"); 62 return -1; 63 } 64 65 return blocksize; 66 } 67 68 int 69 readblock(int b, int blocksize, u32_t seed, char *data) 70 { 71 u64_t offset; 72 int fd; 73 char *mmapdata; 74 int pread_first = random() % 2; 75 76 get_fd_offset(b, blocksize, &offset, &fd); 77 78 if(pread_first) { 79 if(pread(fd, data, blocksize, offset) < blocksize) { 80 perror("pread"); 81 return -1; 82 } 83 } 84 85 if((mmapdata = mmap(NULL, blocksize, PROT_READ, MAP_PRIVATE | MAP_FILE, 86 fd, offset)) == MAP_FAILED) { 87 perror("mmap"); 88 return -1; 89 } 90 91 if(!pread_first) { 92 if(pread(fd, data, blocksize, offset) < blocksize) { 93 perror("pread"); 94 return -1; 95 } 96 } 97 98 if(memcmp(mmapdata, data, blocksize)) { 99 fprintf(stderr, "readblock: mmap, pread mismatch\n"); 100 return -1; 101 } 102 103 if(munmap(mmapdata, blocksize) < 0) { 104 perror("munmap"); 105 return -1; 106 } 107 108 return blocksize; 109 } 110 111 void testend(void) { } 112 113 static void do_read(void *buf, int fd, int writable) 114 { 115 ssize_t ret; 116 size_t n = PAGE_SIZE; 117 struct stat sb; 118 if(fstat(fd, &sb) < 0) e(1); 119 if(S_ISDIR(sb.st_mode)) return; 120 ret = read(fd, buf, n); 121 122 /* if the buffer is writable, it should succeed */ 123 if(writable) { if(ret != n) e(3); return; } 124 125 /* if the buffer is not writable, it should fail with EFAULT */ 126 if(ret >= 0) e(4); 127 if(errno != EFAULT) e(5); 128 } 129 130 static void do_write(void *buf, int fd, int writable) 131 { 132 size_t n = PAGE_SIZE; 133 struct stat sb; 134 if(fstat(fd, &sb) < 0) e(1); 135 if(S_ISDIR(sb.st_mode)) return; 136 if(write(fd, buf, n) != n) e(3); 137 } 138 139 static void do_stat(void *buf, int fd, int writable) 140 { 141 int r; 142 struct stat sb; 143 r = fstat(fd, (struct stat *) buf); 144 145 /* should succeed if buf is writable */ 146 if(writable) { if(r < 0) e(3); return; } 147 148 /* should fail with EFAULT if buf is not */ 149 if(r >= 0) e(4); 150 if(errno != EFAULT) e(5); 151 } 152 153 static void do_getdents(void *buf, int fd, int writable) 154 { 155 struct stat sb; 156 int r; 157 if(fstat(fd, &sb) < 0) e(1); 158 if(!S_ISDIR(sb.st_mode)) return; /* OK */ 159 r = getdents(fd, buf, PAGE_SIZE); 160 if(writable) { if(r < 0) e(3); return; } 161 162 /* should fail with EFAULT if buf is not */ 163 if(r >= 0) e(4); 164 if(errno != EFAULT) e(5); 165 } 166 167 static void do_readlink1(void *buf, int fd, int writable) 168 { 169 char target[200]; 170 /* the system call just has to fail gracefully */ 171 readlink(buf, target, sizeof(target)); 172 } 173 174 #define NODENAME "a" 175 #define TARGETNAME "b" 176 177 static void do_readlink2(void *buf, int fd, int writable) 178 { 179 ssize_t rl; 180 unlink(NODENAME); 181 if(symlink(TARGETNAME, NODENAME) < 0) e(1); 182 rl=readlink(NODENAME, buf, sizeof(buf)); 183 184 /* if buf is writable, it should succeed, with a certain result */ 185 if(writable) { 186 if(rl < 0) e(2); 187 ((char *) buf)[rl] = '\0'; 188 if(strcmp(buf, TARGETNAME)) { 189 fprintf(stderr, "readlink: expected %s, got %s\n", 190 TARGETNAME, buf); 191 e(3); 192 } 193 return; 194 } 195 196 /* if buf is not writable, it should fail with EFAULT */ 197 if(rl >= 0) e(4); 198 199 if(errno != EFAULT) e(5); 200 } 201 202 static void do_symlink1(void *buf, int fd, int writable) 203 { 204 int r; 205 /* the system call just has to fail gracefully */ 206 r = symlink(buf, NODENAME); 207 } 208 209 static void do_symlink2(void *buf, int fd, int writable) 210 { 211 int r; 212 /* the system call just has to fail gracefully */ 213 r = symlink(NODENAME, buf); 214 } 215 216 static void do_open(void *buf, int fd, int writable) 217 { 218 int r; 219 /* the system call just has to fail gracefully */ 220 r = open(buf, O_RDONLY); 221 if(r >= 0) close(r); 222 } 223 224 static void do_select1(void *buf, int fd, int writable) 225 { 226 int r; 227 struct timeval timeout = { 0, 200000 }; /* 0.2 sec */ 228 /* the system call just has to fail gracefully */ 229 r = select(1, buf, NULL, NULL, &timeout); 230 } 231 232 static void do_select2(void *buf, int fd, int writable) 233 { 234 int r; 235 struct timeval timeout = { 0, 200000 }; /* 1 sec */ 236 /* the system call just has to fail gracefully */ 237 r = select(1, NULL, buf, NULL, &timeout); 238 } 239 240 static void do_select3(void *buf, int fd, int writable) 241 { 242 int r; 243 struct timeval timeout = { 0, 200000 }; /* 1 sec */ 244 /* the system call just has to fail gracefully */ 245 r = select(1, NULL, NULL, buf, &timeout); 246 } 247 248 static void fillfile(int fd, int size) 249 { 250 char *buf = malloc(size); 251 252 if(size < 1 || size % PAGE_SIZE || !buf) { e(1); } 253 memset(buf, 'A', size); 254 buf[50] = '\0'; /* so it can be used as a filename arg */ 255 buf[size-1] = '\0'; 256 if(write(fd, buf, size) != size) { e(2); } 257 if(lseek(fd, SEEK_SET, 0) < 0) { e(3); } 258 free(buf); 259 } 260 261 static void make_buffers(int size, 262 int *ret_fd_rw, int *ret_fd_ro, 263 void **filebuf_rw, void **filebuf_ro, void **anonbuf) 264 { 265 char fn_rw[] = "testfile_rw.XXXXXX", fn_ro[] = "testfile_ro.XXXXXX"; 266 *ret_fd_rw = mkstemp(fn_rw); 267 *ret_fd_ro = mkstemp(fn_ro); 268 269 if(size < 1 || size % PAGE_SIZE) { e(2); } 270 if(*ret_fd_rw < 0) { e(1); } 271 if(*ret_fd_ro < 0) { e(1); } 272 fillfile(*ret_fd_rw, size); 273 fillfile(*ret_fd_ro, size); 274 if(fcntl(*ret_fd_rw, F_FLUSH_FS_CACHE) < 0) { e(4); } 275 if(fcntl(*ret_fd_ro, F_FLUSH_FS_CACHE) < 0) { e(4); } 276 277 if((*filebuf_rw = mmap(0, size, PROT_READ | PROT_WRITE, 278 MAP_PRIVATE | MAP_FILE, *ret_fd_rw, 0)) == MAP_FAILED) { 279 e(5); 280 quit(); 281 } 282 283 if((*filebuf_ro = mmap(0, size, PROT_READ, 284 MAP_PRIVATE | MAP_FILE, *ret_fd_ro, 0)) == MAP_FAILED) { 285 e(5); 286 quit(); 287 } 288 289 if((*anonbuf = mmap(0, size, PROT_READ | PROT_WRITE, 290 MAP_PRIVATE | MAP_ANON, -1, 0)) == MAP_FAILED) { 291 e(6); 292 quit(); 293 } 294 295 if(unlink(fn_rw) < 0) { e(12); } 296 if(unlink(fn_ro) < 0) { e(12); } 297 } 298 299 static void forget_buffers(void *buf1, void *buf2, void *buf3, int fd1, int fd2, int size) 300 { 301 if(munmap(buf1, size) < 0) { e(1); } 302 if(munmap(buf2, size) < 0) { e(2); } 303 if(munmap(buf3, size) < 0) { e(2); } 304 if(fcntl(fd1, F_FLUSH_FS_CACHE) < 0) { e(3); } 305 if(fcntl(fd2, F_FLUSH_FS_CACHE) < 0) { e(3); } 306 if(close(fd1) < 0) { e(4); } 307 if(close(fd2) < 0) { e(4); } 308 } 309 310 #define NEXPERIMENTS 12 311 struct { 312 void (*do_operation)(void * buf, int fd, int writable); 313 } experiments[NEXPERIMENTS] = { 314 { do_read }, 315 { do_write }, 316 { do_stat }, 317 { do_getdents }, 318 { do_readlink1 }, 319 { do_readlink2 }, 320 { do_symlink1 }, 321 { do_symlink2 }, 322 { do_open, }, 323 { do_select1 }, 324 { do_select2 }, 325 { do_select3 }, 326 }; 327 328 void test_memory_types_vs_operations(void) 329 { 330 #define NFDS 4 331 #define BUFSIZE (10 * PAGE_SIZE) 332 int exp, fds[NFDS]; 333 int f = 0, size = BUFSIZE; 334 335 /* open some test fd's */ 336 #define OPEN(fn, mode) { assert(f >= 0 && f < NFDS); \ 337 fds[f] = open(fn, mode); if(fds[f] < 0) { e(2); } f++; } 338 OPEN("regular", O_RDWR | O_CREAT); 339 OPEN(".", O_RDONLY); 340 OPEN("/dev/ram", O_RDWR); 341 OPEN("/dev/zero", O_RDWR); 342 343 /* make sure the regular file has plenty of size to play with */ 344 fillfile(fds[0], BUFSIZE); 345 346 /* and the ramdisk too */ 347 if(ioctl(fds[2], MIOCRAMSIZE, &size) < 0) { e(3); } 348 349 for(exp = 0; exp < NEXPERIMENTS; exp++) { 350 for(f = 0; f < NFDS; f++) { 351 void *anonmem, *filemem_rw, *filemem_ro; 352 int buffd_rw, buffd_ro; 353 354 make_buffers(BUFSIZE, &buffd_rw, &buffd_ro, 355 &filemem_rw, &filemem_ro, &anonmem); 356 357 if(lseek(fds[f], 0, SEEK_SET) != 0) { e(10); } 358 experiments[exp].do_operation(anonmem, fds[f], 1); 359 360 if(lseek(fds[f], 0, SEEK_SET) != 0) { e(11); } 361 experiments[exp].do_operation(filemem_rw, fds[f], 1); 362 363 if(lseek(fds[f], 0, SEEK_SET) != 0) { e(12); } 364 experiments[exp].do_operation(filemem_ro, fds[f], 0); 365 366 forget_buffers(filemem_rw, filemem_ro, anonmem, buffd_rw, buffd_ro, BUFSIZE); 367 } 368 } 369 } 370 371 void basic_regression(void) 372 { 373 int fd, fd1, fd2; 374 ssize_t rb, wr; 375 char buf[PAGE_SIZE*2]; 376 void *block, *block1, *block2; 377 #define BLOCKSIZE (PAGE_SIZE*10) 378 block = mmap(0, BLOCKSIZE, PROT_READ | PROT_WRITE, 379 MAP_PRIVATE | MAP_ANON, -1, 0); 380 381 if(block == MAP_FAILED) { e(1); } 382 383 memset(block, 0, BLOCKSIZE); 384 385 /* shrink from bottom */ 386 munmap(block, PAGE_SIZE); 387 388 /* Next test: use a system call write() to access a block of 389 * unavailable file-mapped memory. 390 * 391 * This is a thorny corner case to make succeed transparently 392 * because 393 * (1) it is a filesystem that is doing the memory access 394 * (copy from the constblock1 range in this process to the 395 * FS) but is also the FS needed to satisfy the range if it 396 * isn't in the cache. 397 * (2) there are two separate memory regions involved, requiring 398 * separate VFS requests from VM to properly satisfy, requiring 399 * some complex state to be kept. 400 */ 401 402 fd1 = open("../testsh1", O_RDONLY); 403 fd2 = open("../testsh2", O_RDONLY); 404 if(fd1 < 0 || fd2 < 0) { e(2); } 405 406 /* just check that we can't mmap() a file writable */ 407 if(mmap(NULL, PAGE_SIZE, PROT_READ | PROT_WRITE, MAP_SHARED | MAP_FILE, fd1, 0) != MAP_FAILED) { 408 e(1); 409 } 410 411 /* check that we can mmap() a file MAP_SHARED readonly */ 412 if(mmap(NULL, PAGE_SIZE, PROT_READ, MAP_SHARED | MAP_FILE, fd1, 0) == MAP_FAILED) { 413 e(1); 414 } 415 416 /* clear cache of files before mmap so pages won't be present already */ 417 if(fcntl(fd1, F_FLUSH_FS_CACHE) < 0) { e(1); } 418 if(fcntl(fd2, F_FLUSH_FS_CACHE) < 0) { e(1); } 419 420 #define LOCATION1 (void *) 0x90000000 421 #define LOCATION2 (LOCATION1 + PAGE_SIZE) 422 block1 = mmap(LOCATION1, PAGE_SIZE, PROT_READ, MAP_PRIVATE | MAP_FILE, fd1, 0); 423 if(block1 == MAP_FAILED) { e(4); } 424 if(block1 != LOCATION1) { e(5); } 425 426 block2 = mmap(LOCATION2, PAGE_SIZE, PROT_READ, MAP_PRIVATE | MAP_FILE, fd2, 0); 427 if(block2 == MAP_FAILED) { e(10); } 428 if(block2 != LOCATION2) { e(11); } 429 430 unlink("testfile"); 431 fd = open("testfile", O_CREAT | O_RDWR); 432 if(fd < 0) { e(15); } 433 434 /* write() using the mmap()ped memory as buffer */ 435 436 if((wr=write(fd, LOCATION1, sizeof(buf))) != sizeof(buf)) { 437 fprintf(stderr, "wrote %zd bytes instead of %zd\n", 438 wr, sizeof(buf)); 439 e(20); 440 quit(); 441 } 442 443 /* verify written contents */ 444 445 if((rb=pread(fd, buf, sizeof(buf), 0)) != sizeof(buf)) { 446 if(rb < 0) perror("pread"); 447 fprintf(stderr, "wrote %zd bytes\n", wr); 448 fprintf(stderr, "read %zd bytes instead of %zd\n", 449 rb, sizeof(buf)); 450 e(21); 451 quit(); 452 } 453 454 if(memcmp(buf, LOCATION1, sizeof(buf))) { 455 e(22); 456 quit(); 457 } 458 459 close(fd); 460 close(fd1); 461 close(fd2); 462 463 } 464 465 int 466 main(int argc, char *argv[]) 467 { 468 int iter = 2; 469 470 start(74); 471 472 basic_regression(); 473 474 test_memory_types_vs_operations(); 475 476 makefiles(MAXFILES); 477 478 cachequiet(!bigflag); 479 if(bigflag) iter = 3; 480 481 /* Try various combinations working set sizes 482 * and block sizes in order to specifically 483 * target the primary cache, then primary+secondary 484 * cache, then primary+secondary cache+secondary 485 * cache eviction. 486 */ 487 488 if(dotest(PAGE_SIZE, 100, iter)) e(5); 489 if(dotest(PAGE_SIZE*2, 100, iter)) e(2); 490 if(dotest(PAGE_SIZE*3, 100, iter)) e(3); 491 if(dotest(PAGE_SIZE, 20000, iter)) e(5); 492 493 if(bigflag) { 494 u32_t totalmem, freemem, cachedmem; 495 if(dotest(PAGE_SIZE, 150000, iter)) e(5); 496 getmem(&totalmem, &freemem, &cachedmem); 497 if(dotest(PAGE_SIZE, totalmem*1.5, iter)) e(6); 498 } 499 500 quit(); 501 502 return 0; 503 } 504 505