t_mmap.c revision 272343
1272343Sngie/* $NetBSD: t_mmap.c,v 1.7 2012/06/14 17:47:58 bouyer Exp $ */ 2272343Sngie 3272343Sngie/*- 4272343Sngie * Copyright (c) 2011 The NetBSD Foundation, Inc. 5272343Sngie * All rights reserved. 6272343Sngie * 7272343Sngie * This code is derived from software contributed to The NetBSD Foundation 8272343Sngie * by Jukka Ruohonen. 9272343Sngie * 10272343Sngie * Redistribution and use in source and binary forms, with or without 11272343Sngie * modification, are permitted provided that the following conditions 12272343Sngie * are met: 13272343Sngie * 1. Redistributions of source code must retain the above copyright 14272343Sngie * notice, this list of conditions and the following disclaimer. 15272343Sngie * 2. Redistributions in binary form must reproduce the above copyright 16272343Sngie * notice, this list of conditions and the following disclaimer in the 17272343Sngie * documentation and/or other materials provided with the distribution. 18272343Sngie * 19272343Sngie * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS 20272343Sngie * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED 21272343Sngie * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR 22272343Sngie * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS 23272343Sngie * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR 24272343Sngie * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF 25272343Sngie * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS 26272343Sngie * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN 27272343Sngie * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 28272343Sngie * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE 29272343Sngie * POSSIBILITY OF SUCH DAMAGE. 30272343Sngie */ 31272343Sngie 32272343Sngie/*- 33272343Sngie * Copyright (c)2004 YAMAMOTO Takashi, 34272343Sngie * All rights reserved. 35272343Sngie * 36272343Sngie * Redistribution and use in source and binary forms, with or without 37272343Sngie * modification, are permitted provided that the following conditions 38272343Sngie * are met: 39272343Sngie * 1. Redistributions of source code must retain the above copyright 40272343Sngie * notice, this list of conditions and the following disclaimer. 41272343Sngie * 2. Redistributions in binary form must reproduce the above copyright 42272343Sngie * notice, this list of conditions and the following disclaimer in the 43272343Sngie * documentation and/or other materials provided with the distribution. 44272343Sngie * 45272343Sngie * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND 46272343Sngie * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 47272343Sngie * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 48272343Sngie * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE 49272343Sngie * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 50272343Sngie * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 51272343Sngie * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 52272343Sngie * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 53272343Sngie * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 54272343Sngie * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 55272343Sngie * SUCH DAMAGE. 56272343Sngie */ 57272343Sngie#include <sys/cdefs.h> 58272343Sngie__RCSID("$NetBSD: t_mmap.c,v 1.7 2012/06/14 17:47:58 bouyer Exp $"); 59272343Sngie 60272343Sngie#include <sys/param.h> 61272343Sngie#include <sys/mman.h> 62272343Sngie#include <sys/socket.h> 63272343Sngie#include <sys/sysctl.h> 64272343Sngie#include <sys/wait.h> 65272343Sngie 66272343Sngie#include <atf-c.h> 67272343Sngie#include <errno.h> 68272343Sngie#include <fcntl.h> 69272343Sngie#include <signal.h> 70272343Sngie#include <stdio.h> 71272343Sngie#include <stdlib.h> 72272343Sngie#include <string.h> 73272343Sngie#include <unistd.h> 74272343Sngie#include <paths.h> 75272343Sngie#include <machine/disklabel.h> 76272343Sngie 77272343Sngiestatic long page = 0; 78272343Sngiestatic char path[] = "mmap"; 79272343Sngiestatic void map_check(void *, int); 80272343Sngiestatic void map_sighandler(int); 81272343Sngiestatic void testloan(void *, void *, char, int); 82272343Sngie 83272343Sngie#define BUFSIZE (32 * 1024) /* enough size to trigger sosend_loan */ 84272343Sngie 85272343Sngiestatic void 86272343Sngiemap_check(void *map, int flag) 87272343Sngie{ 88272343Sngie 89272343Sngie if (flag != 0) { 90272343Sngie ATF_REQUIRE(map == MAP_FAILED); 91272343Sngie return; 92272343Sngie } 93272343Sngie 94272343Sngie ATF_REQUIRE(map != MAP_FAILED); 95272343Sngie ATF_REQUIRE(munmap(map, page) == 0); 96272343Sngie} 97272343Sngie 98272343Sngievoid 99272343Sngietestloan(void *vp, void *vp2, char pat, int docheck) 100272343Sngie{ 101272343Sngie char buf[BUFSIZE]; 102272343Sngie char backup[BUFSIZE]; 103272343Sngie ssize_t nwritten; 104272343Sngie ssize_t nread; 105272343Sngie int fds[2]; 106272343Sngie int val; 107272343Sngie 108272343Sngie val = BUFSIZE; 109272343Sngie 110272343Sngie if (docheck != 0) 111272343Sngie (void)memcpy(backup, vp, BUFSIZE); 112272343Sngie 113272343Sngie if (socketpair(AF_LOCAL, SOCK_STREAM, PF_UNSPEC, fds) != 0) 114272343Sngie atf_tc_fail("socketpair() failed"); 115272343Sngie 116272343Sngie val = BUFSIZE; 117272343Sngie 118272343Sngie if (setsockopt(fds[1], SOL_SOCKET, SO_RCVBUF, &val, sizeof(val)) != 0) 119272343Sngie atf_tc_fail("setsockopt() failed, SO_RCVBUF"); 120272343Sngie 121272343Sngie val = BUFSIZE; 122272343Sngie 123272343Sngie if (setsockopt(fds[0], SOL_SOCKET, SO_SNDBUF, &val, sizeof(val)) != 0) 124272343Sngie atf_tc_fail("setsockopt() failed, SO_SNDBUF"); 125272343Sngie 126272343Sngie if (fcntl(fds[0], F_SETFL, O_NONBLOCK) != 0) 127272343Sngie atf_tc_fail("fcntl() failed"); 128272343Sngie 129272343Sngie nwritten = write(fds[0], (char *)vp + page, BUFSIZE - page); 130272343Sngie 131272343Sngie if (nwritten == -1) 132272343Sngie atf_tc_fail("write() failed"); 133272343Sngie 134272343Sngie /* Break loan. */ 135272343Sngie (void)memset(vp2, pat, BUFSIZE); 136272343Sngie 137272343Sngie nread = read(fds[1], buf + page, BUFSIZE - page); 138272343Sngie 139272343Sngie if (nread == -1) 140272343Sngie atf_tc_fail("read() failed"); 141272343Sngie 142272343Sngie if (nread != nwritten) 143272343Sngie atf_tc_fail("too short read"); 144272343Sngie 145272343Sngie if (docheck != 0 && memcmp(backup, buf + page, nread) != 0) 146272343Sngie atf_tc_fail("data mismatch"); 147272343Sngie 148272343Sngie ATF_REQUIRE(close(fds[0]) == 0); 149272343Sngie ATF_REQUIRE(close(fds[1]) == 0); 150272343Sngie} 151272343Sngie 152272343Sngiestatic void 153272343Sngiemap_sighandler(int signo) 154272343Sngie{ 155272343Sngie _exit(signo); 156272343Sngie} 157272343Sngie 158272343SngieATF_TC(mmap_block); 159272343SngieATF_TC_HEAD(mmap_block, tc) 160272343Sngie{ 161272343Sngie atf_tc_set_md_var(tc, "descr", "Test mmap(2) with a block device"); 162272343Sngie atf_tc_set_md_var(tc, "require.user", "root"); 163272343Sngie} 164272343Sngie 165272343SngieATF_TC_BODY(mmap_block, tc) 166272343Sngie{ 167272343Sngie static const int mib[] = { CTL_HW, HW_DISKNAMES }; 168272343Sngie static const unsigned int miblen = __arraycount(mib); 169272343Sngie char *map, *dk, *drives, dev[PATH_MAX]; 170272343Sngie size_t len; 171272343Sngie int fd = -1; 172272343Sngie 173272343Sngie atf_tc_skip("The test case causes a panic (PR kern/38889, kern/46592)"); 174272343Sngie 175272343Sngie ATF_REQUIRE(sysctl(mib, miblen, NULL, &len, NULL, 0) == 0); 176272343Sngie drives = malloc(len); 177272343Sngie ATF_REQUIRE(drives != NULL); 178272343Sngie ATF_REQUIRE(sysctl(mib, miblen, drives, &len, NULL, 0) == 0); 179272343Sngie for (dk = strtok(drives, " "); dk != NULL; dk = strtok(NULL, " ")) { 180272343Sngie sprintf(dev, _PATH_DEV "%s%c", dk, 'a'+RAW_PART); 181272343Sngie fprintf(stderr, "trying: %s\n", dev); 182272343Sngie 183272343Sngie if ((fd = open(dev, O_RDONLY)) >= 0) { 184272343Sngie (void)fprintf(stderr, "using %s\n", dev); 185272343Sngie break; 186272343Sngie } 187272343Sngie } 188272343Sngie free(drives); 189272343Sngie 190272343Sngie if (fd < 0) 191272343Sngie atf_tc_skip("failed to find suitable block device"); 192272343Sngie 193272343Sngie map = mmap(NULL, 4096, PROT_READ, MAP_FILE, fd, 0); 194272343Sngie ATF_REQUIRE(map != MAP_FAILED); 195272343Sngie 196272343Sngie (void)fprintf(stderr, "first byte %x\n", *map); 197272343Sngie ATF_REQUIRE(close(fd) == 0); 198272343Sngie (void)fprintf(stderr, "first byte %x\n", *map); 199272343Sngie 200272343Sngie ATF_REQUIRE(munmap(map, 4096) == 0); 201272343Sngie} 202272343Sngie 203272343SngieATF_TC(mmap_err); 204272343SngieATF_TC_HEAD(mmap_err, tc) 205272343Sngie{ 206272343Sngie atf_tc_set_md_var(tc, "descr", "Test error conditions of mmap(2)"); 207272343Sngie} 208272343Sngie 209272343SngieATF_TC_BODY(mmap_err, tc) 210272343Sngie{ 211272343Sngie size_t addr = SIZE_MAX; 212272343Sngie void *map; 213272343Sngie 214272343Sngie errno = 0; 215272343Sngie map = mmap(NULL, 3, PROT_READ, MAP_FILE|MAP_PRIVATE, -1, 0); 216272343Sngie 217272343Sngie ATF_REQUIRE(map == MAP_FAILED); 218272343Sngie ATF_REQUIRE(errno == EBADF); 219272343Sngie 220272343Sngie errno = 0; 221272343Sngie map = mmap(&addr, page, PROT_READ, MAP_FIXED|MAP_PRIVATE, -1, 0); 222272343Sngie 223272343Sngie ATF_REQUIRE(map == MAP_FAILED); 224272343Sngie ATF_REQUIRE(errno == EINVAL); 225272343Sngie 226272343Sngie errno = 0; 227272343Sngie map = mmap(NULL, page, PROT_READ, MAP_ANON|MAP_PRIVATE, INT_MAX, 0); 228272343Sngie 229272343Sngie ATF_REQUIRE(map == MAP_FAILED); 230272343Sngie ATF_REQUIRE(errno == EINVAL); 231272343Sngie} 232272343Sngie 233272343SngieATF_TC_WITH_CLEANUP(mmap_loan); 234272343SngieATF_TC_HEAD(mmap_loan, tc) 235272343Sngie{ 236272343Sngie atf_tc_set_md_var(tc, "descr", "Test uvm page loanout with mmap(2)"); 237272343Sngie} 238272343Sngie 239272343SngieATF_TC_BODY(mmap_loan, tc) 240272343Sngie{ 241272343Sngie char buf[BUFSIZE]; 242272343Sngie char *vp, *vp2; 243272343Sngie int fd; 244272343Sngie 245272343Sngie fd = open(path, O_RDWR | O_CREAT, 0600); 246272343Sngie ATF_REQUIRE(fd >= 0); 247272343Sngie 248272343Sngie (void)memset(buf, 'x', sizeof(buf)); 249272343Sngie (void)write(fd, buf, sizeof(buf)); 250272343Sngie 251272343Sngie vp = mmap(NULL, BUFSIZE, PROT_READ | PROT_WRITE, 252272343Sngie MAP_FILE | MAP_PRIVATE, fd, 0); 253272343Sngie 254272343Sngie ATF_REQUIRE(vp != MAP_FAILED); 255272343Sngie 256272343Sngie vp2 = vp; 257272343Sngie 258272343Sngie testloan(vp, vp2, 'A', 0); 259272343Sngie testloan(vp, vp2, 'B', 1); 260272343Sngie 261272343Sngie ATF_REQUIRE(munmap(vp, BUFSIZE) == 0); 262272343Sngie 263272343Sngie vp = mmap(NULL, BUFSIZE, PROT_READ | PROT_WRITE, 264272343Sngie MAP_FILE | MAP_SHARED, fd, 0); 265272343Sngie 266272343Sngie vp2 = mmap(NULL, BUFSIZE, PROT_READ | PROT_WRITE, 267272343Sngie MAP_FILE | MAP_SHARED, fd, 0); 268272343Sngie 269272343Sngie ATF_REQUIRE(vp != MAP_FAILED); 270272343Sngie ATF_REQUIRE(vp2 != MAP_FAILED); 271272343Sngie 272272343Sngie testloan(vp, vp2, 'E', 1); 273272343Sngie 274272343Sngie ATF_REQUIRE(munmap(vp, BUFSIZE) == 0); 275272343Sngie ATF_REQUIRE(munmap(vp2, BUFSIZE) == 0); 276272343Sngie} 277272343Sngie 278272343SngieATF_TC_CLEANUP(mmap_loan, tc) 279272343Sngie{ 280272343Sngie (void)unlink(path); 281272343Sngie} 282272343Sngie 283272343SngieATF_TC_WITH_CLEANUP(mmap_prot_1); 284272343SngieATF_TC_HEAD(mmap_prot_1, tc) 285272343Sngie{ 286272343Sngie atf_tc_set_md_var(tc, "descr", "Test mmap(2) protections, #1"); 287272343Sngie} 288272343Sngie 289272343SngieATF_TC_BODY(mmap_prot_1, tc) 290272343Sngie{ 291272343Sngie void *map; 292272343Sngie int fd; 293272343Sngie 294272343Sngie /* 295272343Sngie * Open a file write-only and try to 296272343Sngie * map it read-only. This should fail. 297272343Sngie */ 298272343Sngie fd = open(path, O_WRONLY | O_CREAT, 0700); 299272343Sngie 300272343Sngie if (fd < 0) 301272343Sngie return; 302272343Sngie 303272343Sngie ATF_REQUIRE(write(fd, "XXX", 3) == 3); 304272343Sngie 305272343Sngie map = mmap(NULL, 3, PROT_READ, MAP_FILE|MAP_PRIVATE, fd, 0); 306272343Sngie map_check(map, 1); 307272343Sngie 308272343Sngie map = mmap(NULL, 3, PROT_WRITE, MAP_FILE|MAP_PRIVATE, fd, 0); 309272343Sngie map_check(map, 0); 310272343Sngie 311272343Sngie ATF_REQUIRE(close(fd) == 0); 312272343Sngie} 313272343Sngie 314272343SngieATF_TC_CLEANUP(mmap_prot_1, tc) 315272343Sngie{ 316272343Sngie (void)unlink(path); 317272343Sngie} 318272343Sngie 319272343SngieATF_TC(mmap_prot_2); 320272343SngieATF_TC_HEAD(mmap_prot_2, tc) 321272343Sngie{ 322272343Sngie atf_tc_set_md_var(tc, "descr", "Test mmap(2) protections, #2"); 323272343Sngie} 324272343Sngie 325272343SngieATF_TC_BODY(mmap_prot_2, tc) 326272343Sngie{ 327272343Sngie char buf[2]; 328272343Sngie void *map; 329272343Sngie pid_t pid; 330272343Sngie int sta; 331272343Sngie 332272343Sngie /* 333272343Sngie * Make a PROT_NONE mapping and try to access it. 334272343Sngie * If we catch a SIGSEGV, all works as expected. 335272343Sngie */ 336272343Sngie map = mmap(NULL, page, PROT_NONE, MAP_ANON|MAP_PRIVATE, -1, 0); 337272343Sngie ATF_REQUIRE(map != MAP_FAILED); 338272343Sngie 339272343Sngie pid = fork(); 340272343Sngie ATF_REQUIRE(pid >= 0); 341272343Sngie 342272343Sngie if (pid == 0) { 343272343Sngie ATF_REQUIRE(signal(SIGSEGV, map_sighandler) != SIG_ERR); 344272343Sngie ATF_REQUIRE(strlcpy(buf, map, sizeof(buf)) != 0); 345272343Sngie } 346272343Sngie 347272343Sngie (void)wait(&sta); 348272343Sngie 349272343Sngie ATF_REQUIRE(WIFEXITED(sta) != 0); 350272343Sngie ATF_REQUIRE(WEXITSTATUS(sta) == SIGSEGV); 351272343Sngie ATF_REQUIRE(munmap(map, page) == 0); 352272343Sngie} 353272343Sngie 354272343SngieATF_TC_WITH_CLEANUP(mmap_prot_3); 355272343SngieATF_TC_HEAD(mmap_prot_3, tc) 356272343Sngie{ 357272343Sngie atf_tc_set_md_var(tc, "descr", "Test mmap(2) protections, #3"); 358272343Sngie} 359272343Sngie 360272343SngieATF_TC_BODY(mmap_prot_3, tc) 361272343Sngie{ 362272343Sngie char buf[2]; 363272343Sngie int fd, sta; 364272343Sngie void *map; 365272343Sngie pid_t pid; 366272343Sngie 367272343Sngie /* 368272343Sngie * Open a file, change the permissions 369272343Sngie * to read-only, and try to map it as 370272343Sngie * PROT_NONE. This should succeed, but 371272343Sngie * the access should generate SIGSEGV. 372272343Sngie */ 373272343Sngie fd = open(path, O_RDWR | O_CREAT, 0700); 374272343Sngie 375272343Sngie if (fd < 0) 376272343Sngie return; 377272343Sngie 378272343Sngie ATF_REQUIRE(write(fd, "XXX", 3) == 3); 379272343Sngie ATF_REQUIRE(close(fd) == 0); 380272343Sngie ATF_REQUIRE(chmod(path, 0444) == 0); 381272343Sngie 382272343Sngie fd = open(path, O_RDONLY); 383272343Sngie ATF_REQUIRE(fd != -1); 384272343Sngie 385272343Sngie map = mmap(NULL, 3, PROT_NONE, MAP_FILE | MAP_SHARED, fd, 0); 386272343Sngie ATF_REQUIRE(map != MAP_FAILED); 387272343Sngie 388272343Sngie pid = fork(); 389272343Sngie 390272343Sngie ATF_REQUIRE(pid >= 0); 391272343Sngie 392272343Sngie if (pid == 0) { 393272343Sngie ATF_REQUIRE(signal(SIGSEGV, map_sighandler) != SIG_ERR); 394272343Sngie ATF_REQUIRE(strlcpy(buf, map, sizeof(buf)) != 0); 395272343Sngie } 396272343Sngie 397272343Sngie (void)wait(&sta); 398272343Sngie 399272343Sngie ATF_REQUIRE(WIFEXITED(sta) != 0); 400272343Sngie ATF_REQUIRE(WEXITSTATUS(sta) == SIGSEGV); 401272343Sngie ATF_REQUIRE(munmap(map, 3) == 0); 402272343Sngie} 403272343Sngie 404272343SngieATF_TC_CLEANUP(mmap_prot_3, tc) 405272343Sngie{ 406272343Sngie (void)unlink(path); 407272343Sngie} 408272343Sngie 409272343SngieATF_TC_WITH_CLEANUP(mmap_truncate); 410272343SngieATF_TC_HEAD(mmap_truncate, tc) 411272343Sngie{ 412272343Sngie atf_tc_set_md_var(tc, "descr", "Test mmap(2) and ftruncate(2)"); 413272343Sngie} 414272343Sngie 415272343SngieATF_TC_BODY(mmap_truncate, tc) 416272343Sngie{ 417272343Sngie char *map; 418272343Sngie long i; 419272343Sngie int fd; 420272343Sngie 421272343Sngie fd = open(path, O_RDWR | O_CREAT, 0700); 422272343Sngie 423272343Sngie if (fd < 0) 424272343Sngie return; 425272343Sngie 426272343Sngie /* 427272343Sngie * See that ftruncate(2) works 428272343Sngie * while the file is mapped. 429272343Sngie */ 430272343Sngie ATF_REQUIRE(ftruncate(fd, page) == 0); 431272343Sngie 432272343Sngie map = mmap(NULL, page, PROT_READ | PROT_WRITE, MAP_FILE|MAP_PRIVATE, 433272343Sngie fd, 0); 434272343Sngie ATF_REQUIRE(map != MAP_FAILED); 435272343Sngie 436272343Sngie for (i = 0; i < page; i++) 437272343Sngie map[i] = 'x'; 438272343Sngie 439272343Sngie ATF_REQUIRE(ftruncate(fd, 0) == 0); 440272343Sngie ATF_REQUIRE(ftruncate(fd, page / 8) == 0); 441272343Sngie ATF_REQUIRE(ftruncate(fd, page / 4) == 0); 442272343Sngie ATF_REQUIRE(ftruncate(fd, page / 2) == 0); 443272343Sngie ATF_REQUIRE(ftruncate(fd, page / 12) == 0); 444272343Sngie ATF_REQUIRE(ftruncate(fd, page / 64) == 0); 445272343Sngie 446272343Sngie ATF_REQUIRE(close(fd) == 0); 447272343Sngie} 448272343Sngie 449272343SngieATF_TC_CLEANUP(mmap_truncate, tc) 450272343Sngie{ 451272343Sngie (void)unlink(path); 452272343Sngie} 453272343Sngie 454272343SngieATF_TC(mmap_va0); 455272343SngieATF_TC_HEAD(mmap_va0, tc) 456272343Sngie{ 457272343Sngie atf_tc_set_md_var(tc, "descr", "Test mmap(2) and vm.user_va0_disable"); 458272343Sngie} 459272343Sngie 460272343SngieATF_TC_BODY(mmap_va0, tc) 461272343Sngie{ 462272343Sngie int flags = MAP_ANON | MAP_FIXED | MAP_PRIVATE; 463272343Sngie size_t len = sizeof(int); 464272343Sngie void *map; 465272343Sngie int val; 466272343Sngie 467272343Sngie /* 468272343Sngie * Make an anonymous fixed mapping at zero address. If the address 469272343Sngie * is restricted as noted in security(7), the syscall should fail. 470272343Sngie */ 471272343Sngie if (sysctlbyname("vm.user_va0_disable", &val, &len, NULL, 0) != 0) 472272343Sngie atf_tc_fail("failed to read vm.user_va0_disable"); 473272343Sngie 474272343Sngie map = mmap(NULL, page, PROT_EXEC, flags, -1, 0); 475272343Sngie map_check(map, val); 476272343Sngie 477272343Sngie map = mmap(NULL, page, PROT_READ, flags, -1, 0); 478272343Sngie map_check(map, val); 479272343Sngie 480272343Sngie map = mmap(NULL, page, PROT_WRITE, flags, -1, 0); 481272343Sngie map_check(map, val); 482272343Sngie 483272343Sngie map = mmap(NULL, page, PROT_READ|PROT_WRITE, flags, -1, 0); 484272343Sngie map_check(map, val); 485272343Sngie 486272343Sngie map = mmap(NULL, page, PROT_EXEC|PROT_READ|PROT_WRITE, flags, -1, 0); 487272343Sngie map_check(map, val); 488272343Sngie} 489272343Sngie 490272343SngieATF_TP_ADD_TCS(tp) 491272343Sngie{ 492272343Sngie page = sysconf(_SC_PAGESIZE); 493272343Sngie ATF_REQUIRE(page >= 0); 494272343Sngie 495272343Sngie ATF_TP_ADD_TC(tp, mmap_block); 496272343Sngie ATF_TP_ADD_TC(tp, mmap_err); 497272343Sngie ATF_TP_ADD_TC(tp, mmap_loan); 498272343Sngie ATF_TP_ADD_TC(tp, mmap_prot_1); 499272343Sngie ATF_TP_ADD_TC(tp, mmap_prot_2); 500272343Sngie ATF_TP_ADD_TC(tp, mmap_prot_3); 501272343Sngie ATF_TP_ADD_TC(tp, mmap_truncate); 502272343Sngie ATF_TP_ADD_TC(tp, mmap_va0); 503272343Sngie 504272343Sngie return atf_no_error(); 505272343Sngie} 506