14fdc3d75SEnji Cooper /*- 24fdc3d75SEnji Cooper * Copyright (c) 2006 Robert N. M. Watson 34fdc3d75SEnji Cooper * All rights reserved. 44fdc3d75SEnji Cooper * 5454bc887SKa Ho Ng * Copyright (c) 2021 The FreeBSD Foundation 6454bc887SKa Ho Ng * 7454bc887SKa Ho Ng * Portions of this software were developed by Ka Ho Ng 8454bc887SKa Ho Ng * under sponsorship from the FreeBSD Foundation. 9454bc887SKa Ho Ng * 104fdc3d75SEnji Cooper * Redistribution and use in source and binary forms, with or without 114fdc3d75SEnji Cooper * modification, are permitted provided that the following conditions 124fdc3d75SEnji Cooper * are met: 134fdc3d75SEnji Cooper * 1. Redistributions of source code must retain the above copyright 144fdc3d75SEnji Cooper * notice, this list of conditions and the following disclaimer. 154fdc3d75SEnji Cooper * 2. Redistributions in binary form must reproduce the above copyright 164fdc3d75SEnji Cooper * notice, this list of conditions and the following disclaimer in the 174fdc3d75SEnji Cooper * documentation and/or other materials provided with the distribution. 184fdc3d75SEnji Cooper * 194fdc3d75SEnji Cooper * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND 204fdc3d75SEnji Cooper * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 214fdc3d75SEnji Cooper * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 224fdc3d75SEnji Cooper * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE 234fdc3d75SEnji Cooper * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 244fdc3d75SEnji Cooper * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 254fdc3d75SEnji Cooper * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 264fdc3d75SEnji Cooper * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 274fdc3d75SEnji Cooper * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 284fdc3d75SEnji Cooper * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 294fdc3d75SEnji Cooper * SUCH DAMAGE. 304fdc3d75SEnji Cooper */ 314fdc3d75SEnji Cooper 324fdc3d75SEnji Cooper #include <sys/cdefs.h> 334fdc3d75SEnji Cooper __FBSDID("$FreeBSD$"); 344fdc3d75SEnji Cooper 354fdc3d75SEnji Cooper #include <sys/param.h> 3677ceadeeSMark Johnston #include <sys/ioctl.h> 374fdc3d75SEnji Cooper #include <sys/mman.h> 384fdc3d75SEnji Cooper #include <sys/resource.h> 394fdc3d75SEnji Cooper #include <sys/stat.h> 404fdc3d75SEnji Cooper #include <sys/syscall.h> 4177ceadeeSMark Johnston #include <sys/sysctl.h> 424fdc3d75SEnji Cooper #include <sys/wait.h> 434fdc3d75SEnji Cooper 449afb12baSDavid Bright #include <ctype.h> 454fdc3d75SEnji Cooper #include <errno.h> 464fdc3d75SEnji Cooper #include <fcntl.h> 474fdc3d75SEnji Cooper #include <signal.h> 484fdc3d75SEnji Cooper #include <stdio.h> 494fdc3d75SEnji Cooper #include <stdlib.h> 504fdc3d75SEnji Cooper #include <string.h> 514fdc3d75SEnji Cooper #include <unistd.h> 524fdc3d75SEnji Cooper 534fdc3d75SEnji Cooper #include <atf-c.h> 544fdc3d75SEnji Cooper 554fdc3d75SEnji Cooper #define TEST_PATH_LEN 256 564fdc3d75SEnji Cooper static char test_path[TEST_PATH_LEN]; 579afb12baSDavid Bright static char test_path2[TEST_PATH_LEN]; 589afb12baSDavid Bright static unsigned int test_path_idx = 0; 599afb12baSDavid Bright 609afb12baSDavid Bright static void 619afb12baSDavid Bright gen_a_test_path(char *path) 629afb12baSDavid Bright { 632d5603feSDavid Bright snprintf(path, TEST_PATH_LEN, "/%s/tmp.XXXXXX%d", 649afb12baSDavid Bright getenv("TMPDIR") == NULL ? "/tmp" : getenv("TMPDIR"), 659afb12baSDavid Bright test_path_idx); 669afb12baSDavid Bright 679afb12baSDavid Bright test_path_idx++; 689afb12baSDavid Bright 699afb12baSDavid Bright ATF_REQUIRE_MSG(mkstemp(path) != -1, 709afb12baSDavid Bright "mkstemp failed; errno=%d", errno); 719afb12baSDavid Bright ATF_REQUIRE_MSG(unlink(path) == 0, 729afb12baSDavid Bright "unlink failed; errno=%d", errno); 739afb12baSDavid Bright } 744fdc3d75SEnji Cooper 754fdc3d75SEnji Cooper static void 764fdc3d75SEnji Cooper gen_test_path(void) 774fdc3d75SEnji Cooper { 789afb12baSDavid Bright gen_a_test_path(test_path); 799afb12baSDavid Bright } 804fdc3d75SEnji Cooper 819afb12baSDavid Bright static void 829afb12baSDavid Bright gen_test_path2(void) 839afb12baSDavid Bright { 849afb12baSDavid Bright gen_a_test_path(test_path2); 854fdc3d75SEnji Cooper } 864fdc3d75SEnji Cooper 874fdc3d75SEnji Cooper /* 884fdc3d75SEnji Cooper * Attempt a shm_open() that should fail with an expected error of 'error'. 894fdc3d75SEnji Cooper */ 904fdc3d75SEnji Cooper static void 914fdc3d75SEnji Cooper shm_open_should_fail(const char *path, int flags, mode_t mode, int error) 924fdc3d75SEnji Cooper { 934fdc3d75SEnji Cooper int fd; 944fdc3d75SEnji Cooper 954fdc3d75SEnji Cooper fd = shm_open(path, flags, mode); 964fdc3d75SEnji Cooper ATF_CHECK_MSG(fd == -1, "shm_open didn't fail"); 974fdc3d75SEnji Cooper ATF_CHECK_MSG(error == errno, 984fdc3d75SEnji Cooper "shm_open didn't fail with expected errno; errno=%d; expected " 994fdc3d75SEnji Cooper "errno=%d", errno, error); 1004fdc3d75SEnji Cooper } 1014fdc3d75SEnji Cooper 1024fdc3d75SEnji Cooper /* 1034fdc3d75SEnji Cooper * Attempt a shm_unlink() that should fail with an expected error of 'error'. 1044fdc3d75SEnji Cooper */ 1054fdc3d75SEnji Cooper static void 1064fdc3d75SEnji Cooper shm_unlink_should_fail(const char *path, int error) 1074fdc3d75SEnji Cooper { 1084fdc3d75SEnji Cooper 1094fdc3d75SEnji Cooper ATF_CHECK_MSG(shm_unlink(path) == -1, "shm_unlink didn't fail"); 1104fdc3d75SEnji Cooper ATF_CHECK_MSG(error == errno, 1114fdc3d75SEnji Cooper "shm_unlink didn't fail with expected errno; errno=%d; expected " 1124fdc3d75SEnji Cooper "errno=%d", errno, error); 1134fdc3d75SEnji Cooper } 1144fdc3d75SEnji Cooper 1154fdc3d75SEnji Cooper /* 1169afb12baSDavid Bright * Open the test object and write a value to the first byte. Returns valid fd 1174fdc3d75SEnji Cooper * on success and -1 on failure. 1184fdc3d75SEnji Cooper */ 1194fdc3d75SEnji Cooper static int 1209afb12baSDavid Bright scribble_object(const char *path, char value) 1214fdc3d75SEnji Cooper { 1224fdc3d75SEnji Cooper char *page; 12394ebd6f5SEnji Cooper int fd, pagesize; 1244fdc3d75SEnji Cooper 12594ebd6f5SEnji Cooper ATF_REQUIRE(0 < (pagesize = getpagesize())); 12694ebd6f5SEnji Cooper 1279afb12baSDavid Bright fd = shm_open(path, O_CREAT|O_EXCL|O_RDWR, 0777); 1284fdc3d75SEnji Cooper if (fd < 0 && errno == EEXIST) { 1294fdc3d75SEnji Cooper if (shm_unlink(test_path) < 0) 1304fdc3d75SEnji Cooper atf_tc_fail("shm_unlink"); 1314fdc3d75SEnji Cooper fd = shm_open(test_path, O_CREAT | O_EXCL | O_RDWR, 0777); 1324fdc3d75SEnji Cooper } 1334fdc3d75SEnji Cooper if (fd < 0) 1344fdc3d75SEnji Cooper atf_tc_fail("shm_open failed; errno=%d", errno); 13594ebd6f5SEnji Cooper if (ftruncate(fd, pagesize) < 0) 1364fdc3d75SEnji Cooper atf_tc_fail("ftruncate failed; errno=%d", errno); 1374fdc3d75SEnji Cooper 13894ebd6f5SEnji Cooper page = mmap(0, pagesize, PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0); 1394fdc3d75SEnji Cooper if (page == MAP_FAILED) 1404fdc3d75SEnji Cooper atf_tc_fail("mmap failed; errno=%d", errno); 1414fdc3d75SEnji Cooper 1429afb12baSDavid Bright page[0] = value; 14394ebd6f5SEnji Cooper ATF_REQUIRE_MSG(munmap(page, pagesize) == 0, "munmap failed; errno=%d", 14494ebd6f5SEnji Cooper errno); 1454fdc3d75SEnji Cooper 1464fdc3d75SEnji Cooper return (fd); 1474fdc3d75SEnji Cooper } 1484fdc3d75SEnji Cooper 1499afb12baSDavid Bright /* 1509afb12baSDavid Bright * Fail the test case if the 'path' does not refer to an shm whose first byte 1519afb12baSDavid Bright * is equal to expected_value 1529afb12baSDavid Bright */ 1539afb12baSDavid Bright static void 1549afb12baSDavid Bright verify_object(const char *path, char expected_value) 1559afb12baSDavid Bright { 1569afb12baSDavid Bright int fd; 1579afb12baSDavid Bright int pagesize; 1589afb12baSDavid Bright char *page; 1599afb12baSDavid Bright 1609afb12baSDavid Bright ATF_REQUIRE(0 < (pagesize = getpagesize())); 1619afb12baSDavid Bright 1629afb12baSDavid Bright fd = shm_open(path, O_RDONLY, 0777); 1639afb12baSDavid Bright if (fd < 0) 1649afb12baSDavid Bright atf_tc_fail("shm_open failed in verify_object; errno=%d, path=%s", 1659afb12baSDavid Bright errno, path); 1669afb12baSDavid Bright 1679afb12baSDavid Bright page = mmap(0, pagesize, PROT_READ, MAP_SHARED, fd, 0); 1689afb12baSDavid Bright if (page == MAP_FAILED) 1699afb12baSDavid Bright atf_tc_fail("mmap(1)"); 1709afb12baSDavid Bright if (page[0] != expected_value) 1719afb12baSDavid Bright atf_tc_fail("Renamed object has incorrect value; has" 1729afb12baSDavid Bright "%d (0x%x, '%c'), expected %d (0x%x, '%c')\n", 1739afb12baSDavid Bright page[0], page[0], isprint(page[0]) ? page[0] : ' ', 1749afb12baSDavid Bright expected_value, expected_value, 1759afb12baSDavid Bright isprint(expected_value) ? expected_value : ' '); 1769afb12baSDavid Bright ATF_REQUIRE_MSG(munmap(page, pagesize) == 0, "munmap failed; errno=%d", 1779afb12baSDavid Bright errno); 1789afb12baSDavid Bright close(fd); 1799afb12baSDavid Bright } 1809afb12baSDavid Bright 181454bc887SKa Ho Ng static off_t shm_max_pages = 32; 182454bc887SKa Ho Ng static const char byte_to_fill = 0x5f; 183454bc887SKa Ho Ng 184454bc887SKa Ho Ng static int 185454bc887SKa Ho Ng shm_fill(int fd, off_t offset, off_t len) 186454bc887SKa Ho Ng { 187454bc887SKa Ho Ng int error; 188454bc887SKa Ho Ng size_t blen; 189454bc887SKa Ho Ng char *buf; 190454bc887SKa Ho Ng error = 0; 191454bc887SKa Ho Ng buf = malloc(PAGE_SIZE); 192454bc887SKa Ho Ng if (buf == NULL) 193454bc887SKa Ho Ng return (1); 194454bc887SKa Ho Ng 195454bc887SKa Ho Ng while (len > 0) { 196454bc887SKa Ho Ng blen = len < (off_t)PAGE_SIZE ? len : PAGE_SIZE; 197454bc887SKa Ho Ng memset(buf, byte_to_fill, blen); 198454bc887SKa Ho Ng if (pwrite(fd, buf, blen, offset) != (ssize_t)blen) { 199454bc887SKa Ho Ng error = 1; 200454bc887SKa Ho Ng break; 201454bc887SKa Ho Ng } 202454bc887SKa Ho Ng len -= blen; 203454bc887SKa Ho Ng offset += blen; 204454bc887SKa Ho Ng } 205454bc887SKa Ho Ng 206454bc887SKa Ho Ng free(buf); 207454bc887SKa Ho Ng return (error); 208454bc887SKa Ho Ng } 209454bc887SKa Ho Ng 210454bc887SKa Ho Ng static int 211454bc887SKa Ho Ng check_content_dealloc(int fd, off_t hole_start, off_t hole_len, off_t shm_sz) 212454bc887SKa Ho Ng { 213454bc887SKa Ho Ng int error; 214454bc887SKa Ho Ng size_t blen; 215454bc887SKa Ho Ng off_t offset, resid; 216454bc887SKa Ho Ng struct stat statbuf; 217454bc887SKa Ho Ng char *buf, *sblk; 218454bc887SKa Ho Ng 219454bc887SKa Ho Ng error = 0; 220454bc887SKa Ho Ng buf = malloc(PAGE_SIZE * 2); 221454bc887SKa Ho Ng if (buf == NULL) 222454bc887SKa Ho Ng return (1); 223454bc887SKa Ho Ng sblk = buf + PAGE_SIZE; 224454bc887SKa Ho Ng 225454bc887SKa Ho Ng memset(sblk, 0, PAGE_SIZE); 226454bc887SKa Ho Ng 227454bc887SKa Ho Ng if ((uint64_t)hole_start + hole_len > (uint64_t)shm_sz) 228454bc887SKa Ho Ng hole_len = shm_sz - hole_start; 229454bc887SKa Ho Ng 230454bc887SKa Ho Ng /* 231454bc887SKa Ho Ng * Check hole is zeroed. 232454bc887SKa Ho Ng */ 233454bc887SKa Ho Ng offset = hole_start; 234454bc887SKa Ho Ng resid = hole_len; 235454bc887SKa Ho Ng while (resid > 0) { 236454bc887SKa Ho Ng blen = resid < (off_t)PAGE_SIZE ? resid : PAGE_SIZE; 237454bc887SKa Ho Ng if (pread(fd, buf, blen, offset) != (ssize_t)blen) { 238454bc887SKa Ho Ng error = 1; 239454bc887SKa Ho Ng break; 240454bc887SKa Ho Ng } 241454bc887SKa Ho Ng if (memcmp(buf, sblk, blen) != 0) { 242454bc887SKa Ho Ng error = 1; 243454bc887SKa Ho Ng break; 244454bc887SKa Ho Ng } 245454bc887SKa Ho Ng resid -= blen; 246454bc887SKa Ho Ng offset += blen; 247454bc887SKa Ho Ng } 248454bc887SKa Ho Ng 249454bc887SKa Ho Ng memset(sblk, byte_to_fill, PAGE_SIZE); 250454bc887SKa Ho Ng 251454bc887SKa Ho Ng /* 252454bc887SKa Ho Ng * Check file region before hole is zeroed. 253454bc887SKa Ho Ng */ 254454bc887SKa Ho Ng offset = 0; 255454bc887SKa Ho Ng resid = hole_start; 256454bc887SKa Ho Ng while (resid > 0) { 257454bc887SKa Ho Ng blen = resid < (off_t)PAGE_SIZE ? resid : PAGE_SIZE; 258454bc887SKa Ho Ng if (pread(fd, buf, blen, offset) != (ssize_t)blen) { 259454bc887SKa Ho Ng error = 1; 260454bc887SKa Ho Ng break; 261454bc887SKa Ho Ng } 262454bc887SKa Ho Ng if (memcmp(buf, sblk, blen) != 0) { 263454bc887SKa Ho Ng error = 1; 264454bc887SKa Ho Ng break; 265454bc887SKa Ho Ng } 266454bc887SKa Ho Ng resid -= blen; 267454bc887SKa Ho Ng offset += blen; 268454bc887SKa Ho Ng } 269454bc887SKa Ho Ng 270454bc887SKa Ho Ng /* 271454bc887SKa Ho Ng * Check file region after hole is zeroed. 272454bc887SKa Ho Ng */ 273454bc887SKa Ho Ng offset = hole_start + hole_len; 274454bc887SKa Ho Ng resid = shm_sz - offset; 275454bc887SKa Ho Ng while (resid > 0) { 276454bc887SKa Ho Ng blen = resid < (off_t)PAGE_SIZE ? resid : PAGE_SIZE; 277454bc887SKa Ho Ng if (pread(fd, buf, blen, offset) != (ssize_t)blen) { 278454bc887SKa Ho Ng error = 1; 279454bc887SKa Ho Ng break; 280454bc887SKa Ho Ng } 281454bc887SKa Ho Ng if (memcmp(buf, sblk, blen) != 0) { 282454bc887SKa Ho Ng error = 1; 283454bc887SKa Ho Ng break; 284454bc887SKa Ho Ng } 285454bc887SKa Ho Ng resid -= blen; 286454bc887SKa Ho Ng offset += blen; 287454bc887SKa Ho Ng } 288454bc887SKa Ho Ng 289454bc887SKa Ho Ng /* 290454bc887SKa Ho Ng * Check file size matches with expected file size. 291454bc887SKa Ho Ng */ 292454bc887SKa Ho Ng if (fstat(fd, &statbuf) == -1) 293454bc887SKa Ho Ng error = -1; 294454bc887SKa Ho Ng if (statbuf.st_size != shm_sz) 295454bc887SKa Ho Ng error = -1; 296454bc887SKa Ho Ng 297454bc887SKa Ho Ng free(buf); 298454bc887SKa Ho Ng return (error); 299454bc887SKa Ho Ng } 300454bc887SKa Ho Ng 3014fdc3d75SEnji Cooper ATF_TC_WITHOUT_HEAD(remap_object); 3024fdc3d75SEnji Cooper ATF_TC_BODY(remap_object, tc) 3034fdc3d75SEnji Cooper { 3044fdc3d75SEnji Cooper char *page; 30594ebd6f5SEnji Cooper int fd, pagesize; 30694ebd6f5SEnji Cooper 30794ebd6f5SEnji Cooper ATF_REQUIRE(0 < (pagesize = getpagesize())); 3084fdc3d75SEnji Cooper 3099afb12baSDavid Bright gen_test_path(); 3109afb12baSDavid Bright fd = scribble_object(test_path, '1'); 3114fdc3d75SEnji Cooper 31294ebd6f5SEnji Cooper page = mmap(0, pagesize, PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0); 3134fdc3d75SEnji Cooper if (page == MAP_FAILED) 3144fdc3d75SEnji Cooper atf_tc_fail("mmap(2) failed; errno=%d", errno); 3154fdc3d75SEnji Cooper 3164fdc3d75SEnji Cooper if (page[0] != '1') 3174fdc3d75SEnji Cooper atf_tc_fail("missing data ('%c' != '1')", page[0]); 3184fdc3d75SEnji Cooper 3194fdc3d75SEnji Cooper close(fd); 32094ebd6f5SEnji Cooper ATF_REQUIRE_MSG(munmap(page, pagesize) == 0, "munmap failed; errno=%d", 32194ebd6f5SEnji Cooper errno); 3224fdc3d75SEnji Cooper 3234fdc3d75SEnji Cooper ATF_REQUIRE_MSG(shm_unlink(test_path) != -1, 3244fdc3d75SEnji Cooper "shm_unlink failed; errno=%d", errno); 3254fdc3d75SEnji Cooper } 3264fdc3d75SEnji Cooper 3279afb12baSDavid Bright ATF_TC_WITHOUT_HEAD(rename_from_anon); 3289afb12baSDavid Bright ATF_TC_BODY(rename_from_anon, tc) 3299afb12baSDavid Bright { 3309afb12baSDavid Bright int rc; 3319afb12baSDavid Bright 3329afb12baSDavid Bright gen_test_path(); 3339afb12baSDavid Bright rc = shm_rename(SHM_ANON, test_path, 0); 3349afb12baSDavid Bright if (rc != -1) 3359afb12baSDavid Bright atf_tc_fail("shm_rename from SHM_ANON succeeded unexpectedly"); 3369afb12baSDavid Bright } 3379afb12baSDavid Bright 3389afb12baSDavid Bright ATF_TC_WITHOUT_HEAD(rename_bad_path_pointer); 3399afb12baSDavid Bright ATF_TC_BODY(rename_bad_path_pointer, tc) 3409afb12baSDavid Bright { 3419afb12baSDavid Bright const char *bad_path; 3429afb12baSDavid Bright int rc; 3439afb12baSDavid Bright 3449afb12baSDavid Bright bad_path = (const char *)0x1; 3459afb12baSDavid Bright 3469afb12baSDavid Bright gen_test_path(); 3479afb12baSDavid Bright rc = shm_rename(test_path, bad_path, 0); 3489afb12baSDavid Bright if (rc != -1) 3499afb12baSDavid Bright atf_tc_fail("shm_rename of nonexisting shm succeeded unexpectedly"); 3509afb12baSDavid Bright 3519afb12baSDavid Bright rc = shm_rename(bad_path, test_path, 0); 3529afb12baSDavid Bright if (rc != -1) 3539afb12baSDavid Bright atf_tc_fail("shm_rename of nonexisting shm succeeded unexpectedly"); 3549afb12baSDavid Bright } 3559afb12baSDavid Bright 3569afb12baSDavid Bright ATF_TC_WITHOUT_HEAD(rename_from_nonexisting); 3579afb12baSDavid Bright ATF_TC_BODY(rename_from_nonexisting, tc) 3589afb12baSDavid Bright { 3599afb12baSDavid Bright int rc; 3609afb12baSDavid Bright 3619afb12baSDavid Bright gen_test_path(); 3622d5603feSDavid Bright gen_test_path2(); 3639afb12baSDavid Bright rc = shm_rename(test_path, test_path2, 0); 3649afb12baSDavid Bright if (rc != -1) 3659afb12baSDavid Bright atf_tc_fail("shm_rename of nonexisting shm succeeded unexpectedly"); 3669afb12baSDavid Bright 3679afb12baSDavid Bright if (errno != ENOENT) 3682d5603feSDavid Bright atf_tc_fail("Expected ENOENT to rename of nonexistent shm; got %d", 3692d5603feSDavid Bright errno); 3709afb12baSDavid Bright } 3719afb12baSDavid Bright 3729afb12baSDavid Bright ATF_TC_WITHOUT_HEAD(rename_to_anon); 3739afb12baSDavid Bright ATF_TC_BODY(rename_to_anon, tc) 3749afb12baSDavid Bright { 3759afb12baSDavid Bright int rc; 3769afb12baSDavid Bright 3779afb12baSDavid Bright gen_test_path(); 3789afb12baSDavid Bright rc = shm_rename(test_path, SHM_ANON, 0); 3799afb12baSDavid Bright if (rc != -1) 3809afb12baSDavid Bright atf_tc_fail("shm_rename to SHM_ANON succeeded unexpectedly"); 3819afb12baSDavid Bright } 3829afb12baSDavid Bright 3839afb12baSDavid Bright ATF_TC_WITHOUT_HEAD(rename_to_replace); 3849afb12baSDavid Bright ATF_TC_BODY(rename_to_replace, tc) 3859afb12baSDavid Bright { 3869afb12baSDavid Bright char expected_value; 3879afb12baSDavid Bright int fd; 3889afb12baSDavid Bright int fd2; 3899afb12baSDavid Bright 3909afb12baSDavid Bright // Some contents we can verify later 3919afb12baSDavid Bright expected_value = 'g'; 3929afb12baSDavid Bright 3939afb12baSDavid Bright gen_test_path(); 3949afb12baSDavid Bright fd = scribble_object(test_path, expected_value); 3959afb12baSDavid Bright close(fd); 3969afb12baSDavid Bright 3979afb12baSDavid Bright // Give the other some different value so we can detect success 3989afb12baSDavid Bright gen_test_path2(); 3999afb12baSDavid Bright fd2 = scribble_object(test_path2, 'h'); 4009afb12baSDavid Bright close(fd2); 4019afb12baSDavid Bright 4029afb12baSDavid Bright ATF_REQUIRE_MSG(shm_rename(test_path, test_path2, 0) == 0, 4039afb12baSDavid Bright "shm_rename failed; errno=%d", errno); 4049afb12baSDavid Bright 4059afb12baSDavid Bright // Read back renamed; verify contents 4069afb12baSDavid Bright verify_object(test_path2, expected_value); 4079afb12baSDavid Bright } 4089afb12baSDavid Bright 4099afb12baSDavid Bright ATF_TC_WITHOUT_HEAD(rename_to_noreplace); 4109afb12baSDavid Bright ATF_TC_BODY(rename_to_noreplace, tc) 4119afb12baSDavid Bright { 4129afb12baSDavid Bright char expected_value_from; 4139afb12baSDavid Bright char expected_value_to; 4149afb12baSDavid Bright int fd_from; 4159afb12baSDavid Bright int fd_to; 4169afb12baSDavid Bright int rc; 4179afb12baSDavid Bright 4189afb12baSDavid Bright // Some contents we can verify later 4199afb12baSDavid Bright expected_value_from = 'g'; 4209afb12baSDavid Bright gen_test_path(); 4219afb12baSDavid Bright fd_from = scribble_object(test_path, expected_value_from); 4229afb12baSDavid Bright close(fd_from); 4239afb12baSDavid Bright 4249afb12baSDavid Bright // Give the other some different value so we can detect success 4259afb12baSDavid Bright expected_value_to = 'h'; 4269afb12baSDavid Bright gen_test_path2(); 4279afb12baSDavid Bright fd_to = scribble_object(test_path2, expected_value_to); 4289afb12baSDavid Bright close(fd_to); 4299afb12baSDavid Bright 4309afb12baSDavid Bright rc = shm_rename(test_path, test_path2, SHM_RENAME_NOREPLACE); 4319afb12baSDavid Bright ATF_REQUIRE_MSG((rc == -1) && (errno == EEXIST), 4329afb12baSDavid Bright "shm_rename didn't fail as expected; errno: %d; return: %d", errno, 4339afb12baSDavid Bright rc); 4349afb12baSDavid Bright 4359afb12baSDavid Bright // Read back renamed; verify contents 4369afb12baSDavid Bright verify_object(test_path2, expected_value_to); 4379afb12baSDavid Bright } 4389afb12baSDavid Bright 4399afb12baSDavid Bright ATF_TC_WITHOUT_HEAD(rename_to_exchange); 4409afb12baSDavid Bright ATF_TC_BODY(rename_to_exchange, tc) 4419afb12baSDavid Bright { 4429afb12baSDavid Bright char expected_value_from; 4439afb12baSDavid Bright char expected_value_to; 4449afb12baSDavid Bright int fd_from; 4459afb12baSDavid Bright int fd_to; 4469afb12baSDavid Bright 4479afb12baSDavid Bright // Some contents we can verify later 4489afb12baSDavid Bright expected_value_from = 'g'; 4499afb12baSDavid Bright gen_test_path(); 4509afb12baSDavid Bright fd_from = scribble_object(test_path, expected_value_from); 4519afb12baSDavid Bright close(fd_from); 4529afb12baSDavid Bright 4539afb12baSDavid Bright // Give the other some different value so we can detect success 4549afb12baSDavid Bright expected_value_to = 'h'; 4559afb12baSDavid Bright gen_test_path2(); 4569afb12baSDavid Bright fd_to = scribble_object(test_path2, expected_value_to); 4579afb12baSDavid Bright close(fd_to); 4589afb12baSDavid Bright 4599afb12baSDavid Bright ATF_REQUIRE_MSG(shm_rename(test_path, test_path2, 4609afb12baSDavid Bright SHM_RENAME_EXCHANGE) == 0, 4619afb12baSDavid Bright "shm_rename failed; errno=%d", errno); 4629afb12baSDavid Bright 4639afb12baSDavid Bright // Read back renamed; verify contents 4649afb12baSDavid Bright verify_object(test_path, expected_value_to); 4659afb12baSDavid Bright verify_object(test_path2, expected_value_from); 4669afb12baSDavid Bright } 4679afb12baSDavid Bright 4689afb12baSDavid Bright ATF_TC_WITHOUT_HEAD(rename_to_exchange_nonexisting); 4699afb12baSDavid Bright ATF_TC_BODY(rename_to_exchange_nonexisting, tc) 4709afb12baSDavid Bright { 4719afb12baSDavid Bright char expected_value_from; 4729afb12baSDavid Bright int fd_from; 4739afb12baSDavid Bright 4749afb12baSDavid Bright // Some contents we can verify later 4759afb12baSDavid Bright expected_value_from = 'g'; 4769afb12baSDavid Bright gen_test_path(); 4779afb12baSDavid Bright fd_from = scribble_object(test_path, expected_value_from); 4789afb12baSDavid Bright close(fd_from); 4799afb12baSDavid Bright 4809afb12baSDavid Bright gen_test_path2(); 4819afb12baSDavid Bright 4829afb12baSDavid Bright ATF_REQUIRE_MSG(shm_rename(test_path, test_path2, 4839afb12baSDavid Bright SHM_RENAME_EXCHANGE) == 0, 4849afb12baSDavid Bright "shm_rename failed; errno=%d", errno); 4859afb12baSDavid Bright 4869afb12baSDavid Bright // Read back renamed; verify contents 4879afb12baSDavid Bright verify_object(test_path2, expected_value_from); 4889afb12baSDavid Bright } 4899afb12baSDavid Bright 4909afb12baSDavid Bright ATF_TC_WITHOUT_HEAD(rename_to_self); 4919afb12baSDavid Bright ATF_TC_BODY(rename_to_self, tc) 4929afb12baSDavid Bright { 4939afb12baSDavid Bright int fd; 4949afb12baSDavid Bright char expected_value; 4959afb12baSDavid Bright 4969afb12baSDavid Bright expected_value = 't'; 4979afb12baSDavid Bright 4989afb12baSDavid Bright gen_test_path(); 4999afb12baSDavid Bright fd = scribble_object(test_path, expected_value); 5009afb12baSDavid Bright close(fd); 5019afb12baSDavid Bright 5029afb12baSDavid Bright ATF_REQUIRE_MSG(shm_rename(test_path, test_path, 0) == 0, 5039afb12baSDavid Bright "shm_rename failed; errno=%d", errno); 5049afb12baSDavid Bright 5059afb12baSDavid Bright verify_object(test_path, expected_value); 5069afb12baSDavid Bright } 5079afb12baSDavid Bright 5089afb12baSDavid Bright ATF_TC_WITHOUT_HEAD(rename_bad_flag); 5099afb12baSDavid Bright ATF_TC_BODY(rename_bad_flag, tc) 5109afb12baSDavid Bright { 5119afb12baSDavid Bright int fd; 5129afb12baSDavid Bright int rc; 5139afb12baSDavid Bright 5149afb12baSDavid Bright /* Make sure we don't fail out due to ENOENT */ 5159afb12baSDavid Bright gen_test_path(); 5169afb12baSDavid Bright gen_test_path2(); 5179afb12baSDavid Bright fd = scribble_object(test_path, 'd'); 5189afb12baSDavid Bright close(fd); 5199afb12baSDavid Bright fd = scribble_object(test_path2, 'd'); 5209afb12baSDavid Bright close(fd); 5219afb12baSDavid Bright 5229afb12baSDavid Bright /* 5239afb12baSDavid Bright * Note: if we end up with enough flags that we use all the bits, 5249afb12baSDavid Bright * then remove this test completely. 5259afb12baSDavid Bright */ 5269afb12baSDavid Bright rc = shm_rename(test_path, test_path2, INT_MIN); 5279afb12baSDavid Bright ATF_REQUIRE_MSG((rc == -1) && (errno == EINVAL), 5289afb12baSDavid Bright "shm_rename should have failed with EINVAL; got: return=%d, " 5299afb12baSDavid Bright "errno=%d", rc, errno); 5309afb12baSDavid Bright } 5319afb12baSDavid Bright 5324fdc3d75SEnji Cooper ATF_TC_WITHOUT_HEAD(reopen_object); 5334fdc3d75SEnji Cooper ATF_TC_BODY(reopen_object, tc) 5344fdc3d75SEnji Cooper { 5354fdc3d75SEnji Cooper char *page; 53694ebd6f5SEnji Cooper int fd, pagesize; 53794ebd6f5SEnji Cooper 53894ebd6f5SEnji Cooper ATF_REQUIRE(0 < (pagesize = getpagesize())); 5394fdc3d75SEnji Cooper 5409afb12baSDavid Bright gen_test_path(); 5419afb12baSDavid Bright fd = scribble_object(test_path, '1'); 5424fdc3d75SEnji Cooper close(fd); 5434fdc3d75SEnji Cooper 5444fdc3d75SEnji Cooper fd = shm_open(test_path, O_RDONLY, 0777); 5454fdc3d75SEnji Cooper if (fd < 0) 5464fdc3d75SEnji Cooper atf_tc_fail("shm_open(2) failed; errno=%d", errno); 5474fdc3d75SEnji Cooper 54894ebd6f5SEnji Cooper page = mmap(0, pagesize, PROT_READ, MAP_SHARED, fd, 0); 5494fdc3d75SEnji Cooper if (page == MAP_FAILED) 5504fdc3d75SEnji Cooper atf_tc_fail("mmap(2) failed; errno=%d", errno); 5514fdc3d75SEnji Cooper 5524fdc3d75SEnji Cooper if (page[0] != '1') 5534fdc3d75SEnji Cooper atf_tc_fail("missing data ('%c' != '1')", page[0]); 5544fdc3d75SEnji Cooper 55594ebd6f5SEnji Cooper ATF_REQUIRE_MSG(munmap(page, pagesize) == 0, "munmap failed; errno=%d", 55694ebd6f5SEnji Cooper errno); 5574fdc3d75SEnji Cooper close(fd); 5584fdc3d75SEnji Cooper ATF_REQUIRE_MSG(shm_unlink(test_path) != -1, 5594fdc3d75SEnji Cooper "shm_unlink failed; errno=%d", errno); 5604fdc3d75SEnji Cooper } 5614fdc3d75SEnji Cooper 5624fdc3d75SEnji Cooper ATF_TC_WITHOUT_HEAD(readonly_mmap_write); 5634fdc3d75SEnji Cooper ATF_TC_BODY(readonly_mmap_write, tc) 5644fdc3d75SEnji Cooper { 5654fdc3d75SEnji Cooper char *page; 56694ebd6f5SEnji Cooper int fd, pagesize; 56794ebd6f5SEnji Cooper 56894ebd6f5SEnji Cooper ATF_REQUIRE(0 < (pagesize = getpagesize())); 5694fdc3d75SEnji Cooper 5704fdc3d75SEnji Cooper gen_test_path(); 5714fdc3d75SEnji Cooper 5724fdc3d75SEnji Cooper fd = shm_open(test_path, O_RDONLY | O_CREAT, 0777); 5734fdc3d75SEnji Cooper ATF_REQUIRE_MSG(fd >= 0, "shm_open failed; errno=%d", errno); 5744fdc3d75SEnji Cooper 5754fdc3d75SEnji Cooper /* PROT_WRITE should fail with EACCES. */ 57694ebd6f5SEnji Cooper page = mmap(0, pagesize, PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0); 5774fdc3d75SEnji Cooper if (page != MAP_FAILED) 5784fdc3d75SEnji Cooper atf_tc_fail("mmap(PROT_WRITE) succeeded unexpectedly"); 5794fdc3d75SEnji Cooper 5804fdc3d75SEnji Cooper if (errno != EACCES) 5814fdc3d75SEnji Cooper atf_tc_fail("mmap(PROT_WRITE) didn't fail with EACCES; " 5824fdc3d75SEnji Cooper "errno=%d", errno); 5834fdc3d75SEnji Cooper 5844fdc3d75SEnji Cooper close(fd); 5854fdc3d75SEnji Cooper ATF_REQUIRE_MSG(shm_unlink(test_path) != -1, 5864fdc3d75SEnji Cooper "shm_unlink failed; errno=%d", errno); 5874fdc3d75SEnji Cooper } 5884fdc3d75SEnji Cooper 5894fdc3d75SEnji Cooper ATF_TC_WITHOUT_HEAD(open_after_link); 5904fdc3d75SEnji Cooper ATF_TC_BODY(open_after_link, tc) 5914fdc3d75SEnji Cooper { 5924fdc3d75SEnji Cooper int fd; 5934fdc3d75SEnji Cooper 5944fdc3d75SEnji Cooper gen_test_path(); 5954fdc3d75SEnji Cooper 5964fdc3d75SEnji Cooper fd = shm_open(test_path, O_RDONLY | O_CREAT, 0777); 5974fdc3d75SEnji Cooper ATF_REQUIRE_MSG(fd >= 0, "shm_open(1) failed; errno=%d", errno); 5984fdc3d75SEnji Cooper close(fd); 5994fdc3d75SEnji Cooper 6004fdc3d75SEnji Cooper ATF_REQUIRE_MSG(shm_unlink(test_path) != -1, "shm_unlink failed: %d", 6014fdc3d75SEnji Cooper errno); 6024fdc3d75SEnji Cooper 6034fdc3d75SEnji Cooper shm_open_should_fail(test_path, O_RDONLY, 0777, ENOENT); 6044fdc3d75SEnji Cooper } 6054fdc3d75SEnji Cooper 6064fdc3d75SEnji Cooper ATF_TC_WITHOUT_HEAD(open_invalid_path); 6074fdc3d75SEnji Cooper ATF_TC_BODY(open_invalid_path, tc) 6084fdc3d75SEnji Cooper { 6094fdc3d75SEnji Cooper 6104fdc3d75SEnji Cooper shm_open_should_fail("blah", O_RDONLY, 0777, EINVAL); 6114fdc3d75SEnji Cooper } 6124fdc3d75SEnji Cooper 6134fdc3d75SEnji Cooper ATF_TC_WITHOUT_HEAD(open_write_only); 6144fdc3d75SEnji Cooper ATF_TC_BODY(open_write_only, tc) 6154fdc3d75SEnji Cooper { 6164fdc3d75SEnji Cooper 6174fdc3d75SEnji Cooper gen_test_path(); 6184fdc3d75SEnji Cooper 6194fdc3d75SEnji Cooper shm_open_should_fail(test_path, O_WRONLY, 0777, EINVAL); 6204fdc3d75SEnji Cooper } 6214fdc3d75SEnji Cooper 6224fdc3d75SEnji Cooper ATF_TC_WITHOUT_HEAD(open_extra_flags); 6234fdc3d75SEnji Cooper ATF_TC_BODY(open_extra_flags, tc) 6244fdc3d75SEnji Cooper { 6254fdc3d75SEnji Cooper 6264fdc3d75SEnji Cooper gen_test_path(); 6274fdc3d75SEnji Cooper 6284fdc3d75SEnji Cooper shm_open_should_fail(test_path, O_RDONLY | O_DIRECT, 0777, EINVAL); 6294fdc3d75SEnji Cooper } 6304fdc3d75SEnji Cooper 6314fdc3d75SEnji Cooper ATF_TC_WITHOUT_HEAD(open_anon); 6324fdc3d75SEnji Cooper ATF_TC_BODY(open_anon, tc) 6334fdc3d75SEnji Cooper { 6344fdc3d75SEnji Cooper int fd; 6354fdc3d75SEnji Cooper 6364fdc3d75SEnji Cooper fd = shm_open(SHM_ANON, O_RDWR, 0777); 6374fdc3d75SEnji Cooper ATF_REQUIRE_MSG(fd >= 0, "shm_open failed; errno=%d", errno); 6384fdc3d75SEnji Cooper close(fd); 6394fdc3d75SEnji Cooper } 6404fdc3d75SEnji Cooper 6414fdc3d75SEnji Cooper ATF_TC_WITHOUT_HEAD(open_anon_readonly); 6424fdc3d75SEnji Cooper ATF_TC_BODY(open_anon_readonly, tc) 6434fdc3d75SEnji Cooper { 6444fdc3d75SEnji Cooper 6454fdc3d75SEnji Cooper shm_open_should_fail(SHM_ANON, O_RDONLY, 0777, EINVAL); 6464fdc3d75SEnji Cooper } 6474fdc3d75SEnji Cooper 6484fdc3d75SEnji Cooper ATF_TC_WITHOUT_HEAD(open_bad_path_pointer); 6494fdc3d75SEnji Cooper ATF_TC_BODY(open_bad_path_pointer, tc) 6504fdc3d75SEnji Cooper { 6514fdc3d75SEnji Cooper 6524fdc3d75SEnji Cooper shm_open_should_fail((char *)1024, O_RDONLY, 0777, EFAULT); 6534fdc3d75SEnji Cooper } 6544fdc3d75SEnji Cooper 6554fdc3d75SEnji Cooper ATF_TC_WITHOUT_HEAD(open_path_too_long); 6564fdc3d75SEnji Cooper ATF_TC_BODY(open_path_too_long, tc) 6574fdc3d75SEnji Cooper { 6584fdc3d75SEnji Cooper char *page; 6594fdc3d75SEnji Cooper 6604fdc3d75SEnji Cooper page = malloc(MAXPATHLEN + 1); 6614fdc3d75SEnji Cooper memset(page, 'a', MAXPATHLEN); 6624fdc3d75SEnji Cooper page[MAXPATHLEN] = '\0'; 6634fdc3d75SEnji Cooper shm_open_should_fail(page, O_RDONLY, 0777, ENAMETOOLONG); 6644fdc3d75SEnji Cooper free(page); 6654fdc3d75SEnji Cooper } 6664fdc3d75SEnji Cooper 6674fdc3d75SEnji Cooper ATF_TC_WITHOUT_HEAD(open_nonexisting_object); 6684fdc3d75SEnji Cooper ATF_TC_BODY(open_nonexisting_object, tc) 6694fdc3d75SEnji Cooper { 6704fdc3d75SEnji Cooper 6714fdc3d75SEnji Cooper shm_open_should_fail("/notreallythere", O_RDONLY, 0777, ENOENT); 6724fdc3d75SEnji Cooper } 6734fdc3d75SEnji Cooper 6744fdc3d75SEnji Cooper ATF_TC_WITHOUT_HEAD(open_create_existing_object); 6754fdc3d75SEnji Cooper ATF_TC_BODY(open_create_existing_object, tc) 6764fdc3d75SEnji Cooper { 6774fdc3d75SEnji Cooper int fd; 6784fdc3d75SEnji Cooper 6794fdc3d75SEnji Cooper gen_test_path(); 6804fdc3d75SEnji Cooper 6814fdc3d75SEnji Cooper fd = shm_open(test_path, O_RDONLY|O_CREAT, 0777); 6824fdc3d75SEnji Cooper ATF_REQUIRE_MSG(fd >= 0, "shm_open failed; errno=%d", errno); 6834fdc3d75SEnji Cooper close(fd); 6844fdc3d75SEnji Cooper 6854fdc3d75SEnji Cooper shm_open_should_fail(test_path, O_RDONLY|O_CREAT|O_EXCL, 6864fdc3d75SEnji Cooper 0777, EEXIST); 6874fdc3d75SEnji Cooper 6884fdc3d75SEnji Cooper ATF_REQUIRE_MSG(shm_unlink(test_path) != -1, 6894fdc3d75SEnji Cooper "shm_unlink failed; errno=%d", errno); 6904fdc3d75SEnji Cooper } 6914fdc3d75SEnji Cooper 6924fdc3d75SEnji Cooper ATF_TC_WITHOUT_HEAD(trunc_resets_object); 6934fdc3d75SEnji Cooper ATF_TC_BODY(trunc_resets_object, tc) 6944fdc3d75SEnji Cooper { 6954fdc3d75SEnji Cooper struct stat sb; 6964fdc3d75SEnji Cooper int fd; 6974fdc3d75SEnji Cooper 6984fdc3d75SEnji Cooper gen_test_path(); 6994fdc3d75SEnji Cooper 7004fdc3d75SEnji Cooper /* Create object and set size to 1024. */ 7014fdc3d75SEnji Cooper fd = shm_open(test_path, O_RDWR | O_CREAT, 0777); 7024fdc3d75SEnji Cooper ATF_REQUIRE_MSG(fd >= 0, "shm_open(1) failed; errno=%d", errno); 7034fdc3d75SEnji Cooper ATF_REQUIRE_MSG(ftruncate(fd, 1024) != -1, 7044fdc3d75SEnji Cooper "ftruncate failed; errno=%d", errno); 7054fdc3d75SEnji Cooper ATF_REQUIRE_MSG(fstat(fd, &sb) != -1, 7064fdc3d75SEnji Cooper "fstat(1) failed; errno=%d", errno); 7074fdc3d75SEnji Cooper ATF_REQUIRE_MSG(sb.st_size == 1024, "size %d != 1024", (int)sb.st_size); 7084fdc3d75SEnji Cooper close(fd); 7094fdc3d75SEnji Cooper 7104fdc3d75SEnji Cooper /* Open with O_TRUNC which should reset size to 0. */ 7114fdc3d75SEnji Cooper fd = shm_open(test_path, O_RDWR | O_TRUNC, 0777); 7124fdc3d75SEnji Cooper ATF_REQUIRE_MSG(fd >= 0, "shm_open(2) failed; errno=%d", errno); 7134fdc3d75SEnji Cooper ATF_REQUIRE_MSG(fstat(fd, &sb) != -1, 7144fdc3d75SEnji Cooper "fstat(2) failed; errno=%d", errno); 7154fdc3d75SEnji Cooper ATF_REQUIRE_MSG(sb.st_size == 0, 7164fdc3d75SEnji Cooper "size was not 0 after truncation: %d", (int)sb.st_size); 7174fdc3d75SEnji Cooper close(fd); 7184fdc3d75SEnji Cooper ATF_REQUIRE_MSG(shm_unlink(test_path) != -1, 7194fdc3d75SEnji Cooper "shm_unlink failed; errno=%d", errno); 7204fdc3d75SEnji Cooper } 7214fdc3d75SEnji Cooper 7224fdc3d75SEnji Cooper ATF_TC_WITHOUT_HEAD(unlink_bad_path_pointer); 7234fdc3d75SEnji Cooper ATF_TC_BODY(unlink_bad_path_pointer, tc) 7244fdc3d75SEnji Cooper { 7254fdc3d75SEnji Cooper 7264fdc3d75SEnji Cooper shm_unlink_should_fail((char *)1024, EFAULT); 7274fdc3d75SEnji Cooper } 7284fdc3d75SEnji Cooper 7294fdc3d75SEnji Cooper ATF_TC_WITHOUT_HEAD(unlink_path_too_long); 7304fdc3d75SEnji Cooper ATF_TC_BODY(unlink_path_too_long, tc) 7314fdc3d75SEnji Cooper { 7324fdc3d75SEnji Cooper char *page; 7334fdc3d75SEnji Cooper 7344fdc3d75SEnji Cooper page = malloc(MAXPATHLEN + 1); 7354fdc3d75SEnji Cooper memset(page, 'a', MAXPATHLEN); 7364fdc3d75SEnji Cooper page[MAXPATHLEN] = '\0'; 7374fdc3d75SEnji Cooper shm_unlink_should_fail(page, ENAMETOOLONG); 7384fdc3d75SEnji Cooper free(page); 7394fdc3d75SEnji Cooper } 7404fdc3d75SEnji Cooper 7414fdc3d75SEnji Cooper ATF_TC_WITHOUT_HEAD(object_resize); 7424fdc3d75SEnji Cooper ATF_TC_BODY(object_resize, tc) 7434fdc3d75SEnji Cooper { 7444fdc3d75SEnji Cooper pid_t pid; 7454fdc3d75SEnji Cooper struct stat sb; 74694ebd6f5SEnji Cooper char *page; 74794ebd6f5SEnji Cooper int fd, pagesize, status; 74894ebd6f5SEnji Cooper 74994ebd6f5SEnji Cooper ATF_REQUIRE(0 < (pagesize = getpagesize())); 7504fdc3d75SEnji Cooper 7514fdc3d75SEnji Cooper /* Start off with a size of a single page. */ 7524fdc3d75SEnji Cooper fd = shm_open(SHM_ANON, O_CREAT|O_RDWR, 0777); 7534fdc3d75SEnji Cooper if (fd < 0) 7544fdc3d75SEnji Cooper atf_tc_fail("shm_open failed; errno=%d", errno); 7554fdc3d75SEnji Cooper 75694ebd6f5SEnji Cooper if (ftruncate(fd, pagesize) < 0) 7574fdc3d75SEnji Cooper atf_tc_fail("ftruncate(1) failed; errno=%d", errno); 7584fdc3d75SEnji Cooper 7594fdc3d75SEnji Cooper if (fstat(fd, &sb) < 0) 7604fdc3d75SEnji Cooper atf_tc_fail("fstat(1) failed; errno=%d", errno); 7614fdc3d75SEnji Cooper 76294ebd6f5SEnji Cooper if (sb.st_size != pagesize) 7634fdc3d75SEnji Cooper atf_tc_fail("first resize failed (%d != %d)", 76494ebd6f5SEnji Cooper (int)sb.st_size, pagesize); 7654fdc3d75SEnji Cooper 7664fdc3d75SEnji Cooper /* Write a '1' to the first byte. */ 76794ebd6f5SEnji Cooper page = mmap(0, pagesize, PROT_READ|PROT_WRITE, MAP_SHARED, fd, 0); 7684fdc3d75SEnji Cooper if (page == MAP_FAILED) 7694fdc3d75SEnji Cooper atf_tc_fail("mmap(1)"); 7704fdc3d75SEnji Cooper 7714fdc3d75SEnji Cooper page[0] = '1'; 7724fdc3d75SEnji Cooper 77394ebd6f5SEnji Cooper ATF_REQUIRE_MSG(munmap(page, pagesize) == 0, "munmap failed; errno=%d", 77494ebd6f5SEnji Cooper errno); 7754fdc3d75SEnji Cooper 7764fdc3d75SEnji Cooper /* Grow the object to 2 pages. */ 77794ebd6f5SEnji Cooper if (ftruncate(fd, pagesize * 2) < 0) 7784fdc3d75SEnji Cooper atf_tc_fail("ftruncate(2) failed; errno=%d", errno); 7794fdc3d75SEnji Cooper 7804fdc3d75SEnji Cooper if (fstat(fd, &sb) < 0) 7814fdc3d75SEnji Cooper atf_tc_fail("fstat(2) failed; errno=%d", errno); 7824fdc3d75SEnji Cooper 78394ebd6f5SEnji Cooper if (sb.st_size != pagesize * 2) 7844fdc3d75SEnji Cooper atf_tc_fail("second resize failed (%d != %d)", 78594ebd6f5SEnji Cooper (int)sb.st_size, pagesize * 2); 7864fdc3d75SEnji Cooper 7874fdc3d75SEnji Cooper /* Check for '1' at the first byte. */ 78894ebd6f5SEnji Cooper page = mmap(0, pagesize * 2, PROT_READ|PROT_WRITE, MAP_SHARED, fd, 0); 7894fdc3d75SEnji Cooper if (page == MAP_FAILED) 7904fdc3d75SEnji Cooper atf_tc_fail("mmap(2) failed; errno=%d", errno); 7914fdc3d75SEnji Cooper 7924fdc3d75SEnji Cooper if (page[0] != '1') 7934fdc3d75SEnji Cooper atf_tc_fail("'%c' != '1'", page[0]); 7944fdc3d75SEnji Cooper 7954fdc3d75SEnji Cooper /* Write a '2' at the start of the second page. */ 79694ebd6f5SEnji Cooper page[pagesize] = '2'; 7974fdc3d75SEnji Cooper 7984fdc3d75SEnji Cooper /* Shrink the object back to 1 page. */ 79994ebd6f5SEnji Cooper if (ftruncate(fd, pagesize) < 0) 8004fdc3d75SEnji Cooper atf_tc_fail("ftruncate(3) failed; errno=%d", errno); 8014fdc3d75SEnji Cooper 8024fdc3d75SEnji Cooper if (fstat(fd, &sb) < 0) 8034fdc3d75SEnji Cooper atf_tc_fail("fstat(3) failed; errno=%d", errno); 8044fdc3d75SEnji Cooper 80594ebd6f5SEnji Cooper if (sb.st_size != pagesize) 8064fdc3d75SEnji Cooper atf_tc_fail("third resize failed (%d != %d)", 80794ebd6f5SEnji Cooper (int)sb.st_size, pagesize); 8084fdc3d75SEnji Cooper 8094fdc3d75SEnji Cooper /* 8104fdc3d75SEnji Cooper * Fork a child process to make sure the second page is no 8114fdc3d75SEnji Cooper * longer valid. 8124fdc3d75SEnji Cooper */ 8134fdc3d75SEnji Cooper pid = fork(); 8144fdc3d75SEnji Cooper if (pid == -1) 8154fdc3d75SEnji Cooper atf_tc_fail("fork failed; errno=%d", errno); 8164fdc3d75SEnji Cooper 8174fdc3d75SEnji Cooper if (pid == 0) { 8184fdc3d75SEnji Cooper struct rlimit lim; 8194fdc3d75SEnji Cooper char c; 8204fdc3d75SEnji Cooper 8214fdc3d75SEnji Cooper /* Don't generate a core dump. */ 82294ebd6f5SEnji Cooper ATF_REQUIRE(getrlimit(RLIMIT_CORE, &lim) == 0); 8234fdc3d75SEnji Cooper lim.rlim_cur = 0; 82494ebd6f5SEnji Cooper ATF_REQUIRE(setrlimit(RLIMIT_CORE, &lim) == 0); 8254fdc3d75SEnji Cooper 8264fdc3d75SEnji Cooper /* 8274fdc3d75SEnji Cooper * The previous ftruncate(2) shrunk the backing object 8284fdc3d75SEnji Cooper * so that this address is no longer valid, so reading 8294f775512SJilles Tjoelker * from it should trigger a SIGBUS. 8304fdc3d75SEnji Cooper */ 83194ebd6f5SEnji Cooper c = page[pagesize]; 8324fdc3d75SEnji Cooper fprintf(stderr, "child: page 1: '%c'\n", c); 8334fdc3d75SEnji Cooper exit(0); 8344fdc3d75SEnji Cooper } 8354fdc3d75SEnji Cooper 8364fdc3d75SEnji Cooper if (wait(&status) < 0) 8374fdc3d75SEnji Cooper atf_tc_fail("wait failed; errno=%d", errno); 8384fdc3d75SEnji Cooper 8394f775512SJilles Tjoelker if (!WIFSIGNALED(status) || WTERMSIG(status) != SIGBUS) 8404fdc3d75SEnji Cooper atf_tc_fail("child terminated with status %x", status); 8414fdc3d75SEnji Cooper 8424fdc3d75SEnji Cooper /* Grow the object back to 2 pages. */ 84394ebd6f5SEnji Cooper if (ftruncate(fd, pagesize * 2) < 0) 8444fdc3d75SEnji Cooper atf_tc_fail("ftruncate(2) failed; errno=%d", errno); 8454fdc3d75SEnji Cooper 8464fdc3d75SEnji Cooper if (fstat(fd, &sb) < 0) 8474fdc3d75SEnji Cooper atf_tc_fail("fstat(2) failed; errno=%d", errno); 8484fdc3d75SEnji Cooper 84994ebd6f5SEnji Cooper if (sb.st_size != pagesize * 2) 8504fdc3d75SEnji Cooper atf_tc_fail("fourth resize failed (%d != %d)", 85194ebd6f5SEnji Cooper (int)sb.st_size, pagesize); 8524fdc3d75SEnji Cooper 8534fdc3d75SEnji Cooper /* 8544fdc3d75SEnji Cooper * Note that the mapping at 'page' for the second page is 8554fdc3d75SEnji Cooper * still valid, and now that the shm object has been grown 8564fdc3d75SEnji Cooper * back up to 2 pages, there is now memory backing this page 8574fdc3d75SEnji Cooper * so the read will work. However, the data should be zero 8584fdc3d75SEnji Cooper * rather than '2' as the old data was thrown away when the 8594fdc3d75SEnji Cooper * object was shrunk and the new pages when an object are 8604fdc3d75SEnji Cooper * grown are zero-filled. 8614fdc3d75SEnji Cooper */ 86294ebd6f5SEnji Cooper if (page[pagesize] != 0) 8634fdc3d75SEnji Cooper atf_tc_fail("invalid data at %d: %x != 0", 86494ebd6f5SEnji Cooper pagesize, (int)page[pagesize]); 8654fdc3d75SEnji Cooper 8664fdc3d75SEnji Cooper close(fd); 8674fdc3d75SEnji Cooper } 8684fdc3d75SEnji Cooper 8694fdc3d75SEnji Cooper /* Signal handler which does nothing. */ 8704fdc3d75SEnji Cooper static void 8714fdc3d75SEnji Cooper ignoreit(int sig __unused) 8724fdc3d75SEnji Cooper { 8734fdc3d75SEnji Cooper ; 8744fdc3d75SEnji Cooper } 8754fdc3d75SEnji Cooper 8764fdc3d75SEnji Cooper ATF_TC_WITHOUT_HEAD(shm_functionality_across_fork); 8774fdc3d75SEnji Cooper ATF_TC_BODY(shm_functionality_across_fork, tc) 8784fdc3d75SEnji Cooper { 8794fdc3d75SEnji Cooper char *cp, c; 8804fdc3d75SEnji Cooper int error, desc, rv; 8814fdc3d75SEnji Cooper long scval; 8824fdc3d75SEnji Cooper sigset_t ss; 8834fdc3d75SEnji Cooper struct sigaction sa; 8844fdc3d75SEnji Cooper void *region; 8854fdc3d75SEnji Cooper size_t i, psize; 8864fdc3d75SEnji Cooper 8874fdc3d75SEnji Cooper #ifndef _POSIX_SHARED_MEMORY_OBJECTS 8884fdc3d75SEnji Cooper printf("_POSIX_SHARED_MEMORY_OBJECTS is undefined\n"); 8894fdc3d75SEnji Cooper #else 8904fdc3d75SEnji Cooper printf("_POSIX_SHARED_MEMORY_OBJECTS is defined as %ld\n", 8914fdc3d75SEnji Cooper (long)_POSIX_SHARED_MEMORY_OBJECTS - 0); 8924fdc3d75SEnji Cooper if (_POSIX_SHARED_MEMORY_OBJECTS - 0 == -1) 8934fdc3d75SEnji Cooper printf("***Indicates this feature may be unsupported!\n"); 8944fdc3d75SEnji Cooper #endif 8954fdc3d75SEnji Cooper errno = 0; 8964fdc3d75SEnji Cooper scval = sysconf(_SC_SHARED_MEMORY_OBJECTS); 8974fdc3d75SEnji Cooper if (scval == -1 && errno != 0) { 8984fdc3d75SEnji Cooper atf_tc_fail("sysconf(_SC_SHARED_MEMORY_OBJECTS) failed; " 8994fdc3d75SEnji Cooper "errno=%d", errno); 9004fdc3d75SEnji Cooper } else { 9014fdc3d75SEnji Cooper printf("sysconf(_SC_SHARED_MEMORY_OBJECTS) returns %ld\n", 9024fdc3d75SEnji Cooper scval); 9034fdc3d75SEnji Cooper if (scval == -1) 9044fdc3d75SEnji Cooper printf("***Indicates this feature is unsupported!\n"); 9054fdc3d75SEnji Cooper } 9064fdc3d75SEnji Cooper 9074fdc3d75SEnji Cooper errno = 0; 9084fdc3d75SEnji Cooper scval = sysconf(_SC_PAGESIZE); 9094fdc3d75SEnji Cooper if (scval == -1 && errno != 0) { 9104fdc3d75SEnji Cooper atf_tc_fail("sysconf(_SC_PAGESIZE) failed; errno=%d", errno); 91194ebd6f5SEnji Cooper } else if (scval <= 0) { 9124fdc3d75SEnji Cooper fprintf(stderr, "bogus return from sysconf(_SC_PAGESIZE): %ld", 9134fdc3d75SEnji Cooper scval); 9144fdc3d75SEnji Cooper psize = 4096; 9154fdc3d75SEnji Cooper } else { 9164fdc3d75SEnji Cooper printf("sysconf(_SC_PAGESIZE) returns %ld\n", scval); 9174fdc3d75SEnji Cooper psize = scval; 9184fdc3d75SEnji Cooper } 9194fdc3d75SEnji Cooper 9204fdc3d75SEnji Cooper gen_test_path(); 9214fdc3d75SEnji Cooper desc = shm_open(test_path, O_EXCL | O_CREAT | O_RDWR, 0600); 9224fdc3d75SEnji Cooper 9234fdc3d75SEnji Cooper ATF_REQUIRE_MSG(desc >= 0, "shm_open failed; errno=%d", errno); 9244fdc3d75SEnji Cooper ATF_REQUIRE_MSG(shm_unlink(test_path) == 0, 9254fdc3d75SEnji Cooper "shm_unlink failed; errno=%d", errno); 9264fdc3d75SEnji Cooper ATF_REQUIRE_MSG(ftruncate(desc, (off_t)psize) != -1, 9274fdc3d75SEnji Cooper "ftruncate failed; errno=%d", errno); 9284fdc3d75SEnji Cooper 92994ebd6f5SEnji Cooper region = mmap(NULL, psize, PROT_READ | PROT_WRITE, MAP_SHARED, desc, 0); 9304fdc3d75SEnji Cooper ATF_REQUIRE_MSG(region != MAP_FAILED, "mmap failed; errno=%d", errno); 9314fdc3d75SEnji Cooper memset(region, '\377', psize); 9324fdc3d75SEnji Cooper 9334fdc3d75SEnji Cooper sa.sa_flags = 0; 9344fdc3d75SEnji Cooper sa.sa_handler = ignoreit; 9354fdc3d75SEnji Cooper sigemptyset(&sa.sa_mask); 9364fdc3d75SEnji Cooper ATF_REQUIRE_MSG(sigaction(SIGUSR1, &sa, (struct sigaction *)0) == 0, 9374fdc3d75SEnji Cooper "sigaction failed; errno=%d", errno); 9384fdc3d75SEnji Cooper 9394fdc3d75SEnji Cooper sigemptyset(&ss); 9404fdc3d75SEnji Cooper sigaddset(&ss, SIGUSR1); 9414fdc3d75SEnji Cooper ATF_REQUIRE_MSG(sigprocmask(SIG_BLOCK, &ss, (sigset_t *)0) == 0, 9424fdc3d75SEnji Cooper "sigprocmask failed; errno=%d", errno); 9434fdc3d75SEnji Cooper 9444fdc3d75SEnji Cooper rv = fork(); 9454fdc3d75SEnji Cooper ATF_REQUIRE_MSG(rv != -1, "fork failed; errno=%d", errno); 9464fdc3d75SEnji Cooper if (rv == 0) { 9474fdc3d75SEnji Cooper sigemptyset(&ss); 9484fdc3d75SEnji Cooper sigsuspend(&ss); 9494fdc3d75SEnji Cooper 9504fdc3d75SEnji Cooper for (cp = region; cp < (char *)region + psize; cp++) { 9514fdc3d75SEnji Cooper if (*cp != '\151') 9524fdc3d75SEnji Cooper _exit(1); 9534fdc3d75SEnji Cooper } 9544fdc3d75SEnji Cooper if (lseek(desc, 0, SEEK_SET) == -1) 9554fdc3d75SEnji Cooper _exit(1); 9564fdc3d75SEnji Cooper for (i = 0; i < psize; i++) { 9574fdc3d75SEnji Cooper error = read(desc, &c, 1); 9584fdc3d75SEnji Cooper if (c != '\151') 9594fdc3d75SEnji Cooper _exit(1); 9604fdc3d75SEnji Cooper } 9614fdc3d75SEnji Cooper _exit(0); 9624fdc3d75SEnji Cooper } else { 9634fdc3d75SEnji Cooper int status; 9644fdc3d75SEnji Cooper 9654fdc3d75SEnji Cooper memset(region, '\151', psize - 2); 9664fdc3d75SEnji Cooper error = pwrite(desc, region, 2, psize - 2); 9674fdc3d75SEnji Cooper if (error != 2) { 9684fdc3d75SEnji Cooper if (error >= 0) 9694fdc3d75SEnji Cooper atf_tc_fail("short write; %d bytes written", 9704fdc3d75SEnji Cooper error); 9714fdc3d75SEnji Cooper else 9724fdc3d75SEnji Cooper atf_tc_fail("shmfd write"); 9734fdc3d75SEnji Cooper } 9744fdc3d75SEnji Cooper kill(rv, SIGUSR1); 9754fdc3d75SEnji Cooper waitpid(rv, &status, 0); 9764fdc3d75SEnji Cooper 9774fdc3d75SEnji Cooper if (WIFEXITED(status) && WEXITSTATUS(status) == 0) { 9784fdc3d75SEnji Cooper printf("Functionality test successful\n"); 9794fdc3d75SEnji Cooper } else if (WIFEXITED(status)) { 9804fdc3d75SEnji Cooper atf_tc_fail("Child process exited with status %d", 9814fdc3d75SEnji Cooper WEXITSTATUS(status)); 9824fdc3d75SEnji Cooper } else { 9834fdc3d75SEnji Cooper atf_tc_fail("Child process terminated with %s", 9844fdc3d75SEnji Cooper strsignal(WTERMSIG(status))); 9854fdc3d75SEnji Cooper } 9864fdc3d75SEnji Cooper } 98794ebd6f5SEnji Cooper 98894ebd6f5SEnji Cooper ATF_REQUIRE_MSG(munmap(region, psize) == 0, "munmap failed; errno=%d", 98994ebd6f5SEnji Cooper errno); 99094ebd6f5SEnji Cooper shm_unlink(test_path); 9914fdc3d75SEnji Cooper } 9924fdc3d75SEnji Cooper 99395aa96f3SKyle Evans ATF_TC_WITHOUT_HEAD(cloexec); 99495aa96f3SKyle Evans ATF_TC_BODY(cloexec, tc) 99595aa96f3SKyle Evans { 99695aa96f3SKyle Evans int fd; 99795aa96f3SKyle Evans 99895aa96f3SKyle Evans gen_test_path(); 99995aa96f3SKyle Evans 100095aa96f3SKyle Evans /* shm_open(2) is required to set FD_CLOEXEC */ 100195aa96f3SKyle Evans fd = shm_open(SHM_ANON, O_RDWR, 0777); 100295aa96f3SKyle Evans ATF_REQUIRE_MSG(fd >= 0, "shm_open failed; errno=%d", errno); 100395aa96f3SKyle Evans ATF_REQUIRE((fcntl(fd, F_GETFD) & FD_CLOEXEC) != 0); 100495aa96f3SKyle Evans close(fd); 100595aa96f3SKyle Evans 100695aa96f3SKyle Evans /* Also make sure that named shm is correct */ 100795aa96f3SKyle Evans fd = shm_open(test_path, O_CREAT | O_RDWR, 0600); 100895aa96f3SKyle Evans ATF_REQUIRE_MSG(fd >= 0, "shm_open failed; errno=%d", errno); 100995aa96f3SKyle Evans ATF_REQUIRE((fcntl(fd, F_GETFD) & FD_CLOEXEC) != 0); 101095aa96f3SKyle Evans close(fd); 101195aa96f3SKyle Evans } 101295aa96f3SKyle Evans 10135a391b57SKyle Evans ATF_TC_WITHOUT_HEAD(mode); 10145a391b57SKyle Evans ATF_TC_BODY(mode, tc) 10155a391b57SKyle Evans { 10165a391b57SKyle Evans struct stat st; 10175a391b57SKyle Evans int fd; 10185a391b57SKyle Evans mode_t restore_mask; 10195a391b57SKyle Evans 10205a391b57SKyle Evans gen_test_path(); 10215a391b57SKyle Evans 10225a391b57SKyle Evans /* Remove inhibitions from umask */ 10235a391b57SKyle Evans restore_mask = umask(0); 10245a391b57SKyle Evans fd = shm_open(test_path, O_CREAT | O_RDWR, 0600); 10255a391b57SKyle Evans ATF_REQUIRE_MSG(fd >= 0, "shm_open failed; errno=%d", errno); 10265a391b57SKyle Evans ATF_REQUIRE(fstat(fd, &st) == 0); 10275a391b57SKyle Evans ATF_REQUIRE((st.st_mode & ACCESSPERMS) == 0600); 10285a391b57SKyle Evans close(fd); 10295a391b57SKyle Evans ATF_REQUIRE(shm_unlink(test_path) == 0); 10305a391b57SKyle Evans 10315a391b57SKyle Evans fd = shm_open(test_path, O_CREAT | O_RDWR, 0660); 10325a391b57SKyle Evans ATF_REQUIRE_MSG(fd >= 0, "shm_open failed; errno=%d", errno); 10335a391b57SKyle Evans ATF_REQUIRE(fstat(fd, &st) == 0); 10345a391b57SKyle Evans ATF_REQUIRE((st.st_mode & ACCESSPERMS) == 0660); 10355a391b57SKyle Evans close(fd); 10365a391b57SKyle Evans ATF_REQUIRE(shm_unlink(test_path) == 0); 10375a391b57SKyle Evans 10385a391b57SKyle Evans fd = shm_open(test_path, O_CREAT | O_RDWR, 0666); 10395a391b57SKyle Evans ATF_REQUIRE_MSG(fd >= 0, "shm_open failed; errno=%d", errno); 10405a391b57SKyle Evans ATF_REQUIRE(fstat(fd, &st) == 0); 10415a391b57SKyle Evans ATF_REQUIRE((st.st_mode & ACCESSPERMS) == 0666); 10425a391b57SKyle Evans close(fd); 10435a391b57SKyle Evans ATF_REQUIRE(shm_unlink(test_path) == 0); 10445a391b57SKyle Evans 10455a391b57SKyle Evans umask(restore_mask); 10465a391b57SKyle Evans } 104795aa96f3SKyle Evans 1048f1040532SKyle Evans ATF_TC_WITHOUT_HEAD(fallocate); 1049f1040532SKyle Evans ATF_TC_BODY(fallocate, tc) 1050f1040532SKyle Evans { 1051f1040532SKyle Evans struct stat st; 1052f1040532SKyle Evans int error, fd, sz; 1053f1040532SKyle Evans 1054f1040532SKyle Evans /* 1055f1040532SKyle Evans * Primitive test case for posix_fallocate with shmd. Effectively 1056f1040532SKyle Evans * expected to work like a smarter ftruncate that will grow the region 1057f1040532SKyle Evans * as needed in a race-free way. 1058f1040532SKyle Evans */ 1059f1040532SKyle Evans fd = shm_open(SHM_ANON, O_RDWR, 0666); 1060f1040532SKyle Evans ATF_REQUIRE_MSG(fd >= 0, "shm_open failed; errno=%d", errno); 1061f1040532SKyle Evans /* Set the initial size. */ 1062f1040532SKyle Evans sz = 32; 1063f1040532SKyle Evans ATF_REQUIRE(ftruncate(fd, sz) == 0); 1064f1040532SKyle Evans 1065f1040532SKyle Evans /* Now grow it. */ 1066f1040532SKyle Evans error = 0; 1067f1040532SKyle Evans sz *= 2; 1068f1040532SKyle Evans ATF_REQUIRE_MSG((error = posix_fallocate(fd, 0, sz)) == 0, 1069f1040532SKyle Evans "posix_fallocate failed; error=%d", error); 1070f1040532SKyle Evans ATF_REQUIRE(fstat(fd, &st) == 0); 1071f1040532SKyle Evans ATF_REQUIRE(st.st_size == sz); 1072f1040532SKyle Evans /* Attempt to shrink it; should succeed, but not change the size. */ 1073f1040532SKyle Evans ATF_REQUIRE_MSG((error = posix_fallocate(fd, 0, sz / 2)) == 0, 1074f1040532SKyle Evans "posix_fallocate failed; error=%d", error); 1075f1040532SKyle Evans ATF_REQUIRE(fstat(fd, &st) == 0); 1076f1040532SKyle Evans ATF_REQUIRE(st.st_size == sz); 1077f1040532SKyle Evans /* Grow it using an offset of sz and len of sz. */ 1078f1040532SKyle Evans ATF_REQUIRE_MSG((error = posix_fallocate(fd, sz, sz)) == 0, 1079f1040532SKyle Evans "posix_fallocate failed; error=%d", error); 1080f1040532SKyle Evans ATF_REQUIRE(fstat(fd, &st) == 0); 1081f1040532SKyle Evans ATF_REQUIRE(st.st_size == (sz * 2)); 1082f1040532SKyle Evans 1083f1040532SKyle Evans close(fd); 1084f1040532SKyle Evans } 1085f1040532SKyle Evans 1086454bc887SKa Ho Ng ATF_TC_WITHOUT_HEAD(fspacectl); 1087454bc887SKa Ho Ng ATF_TC_BODY(fspacectl, tc) 1088454bc887SKa Ho Ng { 1089454bc887SKa Ho Ng struct spacectl_range range; 1090454bc887SKa Ho Ng off_t offset, length, shm_sz; 1091454bc887SKa Ho Ng int fd, error; 1092454bc887SKa Ho Ng 1093454bc887SKa Ho Ng shm_sz = shm_max_pages << PAGE_SHIFT; 1094454bc887SKa Ho Ng 1095454bc887SKa Ho Ng fd = shm_open("/testtest", O_RDWR|O_CREAT, 0666); 1096454bc887SKa Ho Ng ATF_REQUIRE_MSG(fd >= 0, "shm_open failed; errno:%d", errno); 1097454bc887SKa Ho Ng ATF_REQUIRE_MSG((error = posix_fallocate(fd, 0, shm_sz)) == 0, 1098454bc887SKa Ho Ng "posix_fallocate failed; error=%d", error); 1099454bc887SKa Ho Ng 1100454bc887SKa Ho Ng /* Aligned fspacectl(fd, SPACECTL_DEALLOC, ...) */ 1101454bc887SKa Ho Ng ATF_REQUIRE(shm_fill(fd, 0, shm_sz) == 0); 1102454bc887SKa Ho Ng range.r_offset = offset = PAGE_SIZE; 1103454bc887SKa Ho Ng range.r_len = length = ((shm_max_pages - 1) << PAGE_SHIFT) - 1104454bc887SKa Ho Ng range.r_offset; 1105454bc887SKa Ho Ng ATF_CHECK_MSG(fspacectl(fd, SPACECTL_DEALLOC, &range, 0, &range) == 0, 1106454bc887SKa Ho Ng "Aligned fspacectl failed; errno=%d", errno); 1107454bc887SKa Ho Ng ATF_CHECK_MSG(check_content_dealloc(fd, offset, length, shm_sz) == 0, 1108cd16a848SJohn Baldwin "Aligned fspacectl content checking failed"); 1109454bc887SKa Ho Ng 1110454bc887SKa Ho Ng /* Unaligned fspacectl(fd, SPACECTL_DEALLOC, ...) */ 1111454bc887SKa Ho Ng ATF_REQUIRE(shm_fill(fd, 0, shm_sz) == 0); 1112454bc887SKa Ho Ng range.r_offset = offset = 1 << (PAGE_SHIFT - 1); 1113454bc887SKa Ho Ng range.r_len = length = ((shm_max_pages - 1) << PAGE_SHIFT) + 1114454bc887SKa Ho Ng (1 << (PAGE_SHIFT - 1)) - offset; 1115454bc887SKa Ho Ng ATF_CHECK_MSG(fspacectl(fd, SPACECTL_DEALLOC, &range, 0, &range) == 0, 1116454bc887SKa Ho Ng "Unaligned fspacectl failed; errno=%d", errno); 1117454bc887SKa Ho Ng ATF_CHECK_MSG(check_content_dealloc(fd, offset, length, shm_sz) == 0, 1118cd16a848SJohn Baldwin "Unaligned fspacectl content checking failed"); 1119454bc887SKa Ho Ng 1120454bc887SKa Ho Ng /* Aligned fspacectl(fd, SPACECTL_DEALLOC, ...) to OFF_MAX */ 1121454bc887SKa Ho Ng ATF_REQUIRE(shm_fill(fd, 0, shm_sz) == 0); 1122454bc887SKa Ho Ng range.r_offset = offset = PAGE_SHIFT; 1123454bc887SKa Ho Ng range.r_len = length = OFF_MAX - offset; 1124454bc887SKa Ho Ng ATF_CHECK_MSG(fspacectl(fd, SPACECTL_DEALLOC, &range, 0, &range) == 0, 1125454bc887SKa Ho Ng "Aligned fspacectl to OFF_MAX failed; errno=%d", errno); 1126454bc887SKa Ho Ng ATF_CHECK_MSG(check_content_dealloc(fd, offset, length, shm_sz) == 0, 1127cd16a848SJohn Baldwin "Aligned fspacectl to OFF_MAX content checking failed"); 1128454bc887SKa Ho Ng 1129454bc887SKa Ho Ng /* Unaligned fspacectl(fd, SPACECTL_DEALLOC, ...) to OFF_MAX */ 1130454bc887SKa Ho Ng ATF_REQUIRE(shm_fill(fd, 0, shm_sz) == 0); 1131454bc887SKa Ho Ng range.r_offset = offset = 1 << (PAGE_SHIFT - 1); 1132454bc887SKa Ho Ng range.r_len = length = OFF_MAX - offset; 1133454bc887SKa Ho Ng ATF_CHECK_MSG(fspacectl(fd, SPACECTL_DEALLOC, &range, 0, &range) == 0, 1134454bc887SKa Ho Ng "Unaligned fspacectl to OFF_MAX failed; errno=%d", errno); 1135454bc887SKa Ho Ng ATF_CHECK_MSG(check_content_dealloc(fd, offset, length, shm_sz) == 0, 1136cd16a848SJohn Baldwin "Unaligned fspacectl to OFF_MAX content checking failed"); 1137454bc887SKa Ho Ng 1138454bc887SKa Ho Ng /* Aligned fspacectl(fd, SPACECTL_DEALLOC, ...) past shm_sz */ 1139454bc887SKa Ho Ng ATF_REQUIRE(shm_fill(fd, 0, shm_sz) == 0); 1140454bc887SKa Ho Ng range.r_offset = offset = PAGE_SIZE; 1141454bc887SKa Ho Ng range.r_len = length = ((shm_max_pages + 1) << PAGE_SHIFT) - offset; 1142454bc887SKa Ho Ng ATF_CHECK_MSG(fspacectl(fd, SPACECTL_DEALLOC, &range, 0, &range) == 0, 1143454bc887SKa Ho Ng "Aligned fspacectl past shm_sz failed; errno=%d", errno); 1144454bc887SKa Ho Ng ATF_CHECK_MSG(check_content_dealloc(fd, offset, length, shm_sz) == 0, 1145cd16a848SJohn Baldwin "Aligned fspacectl past shm_sz content checking failed"); 1146454bc887SKa Ho Ng 1147454bc887SKa Ho Ng /* Unaligned fspacectl(fd, SPACECTL_DEALLOC, ...) past shm_sz */ 1148454bc887SKa Ho Ng ATF_REQUIRE(shm_fill(fd, 0, shm_sz) == 0); 1149454bc887SKa Ho Ng range.r_offset = offset = 1 << (PAGE_SHIFT - 1); 1150454bc887SKa Ho Ng range.r_len = length = ((shm_max_pages + 1) << PAGE_SHIFT) - offset; 1151454bc887SKa Ho Ng ATF_CHECK_MSG(fspacectl(fd, SPACECTL_DEALLOC, &range, 0, &range) == 0, 1152454bc887SKa Ho Ng "Unaligned fspacectl past shm_sz failed; errno=%d", errno); 1153454bc887SKa Ho Ng ATF_CHECK_MSG(check_content_dealloc(fd, offset, length, shm_sz) == 0, 1154cd16a848SJohn Baldwin "Unaligned fspacectl past shm_sz content checking failed"); 1155454bc887SKa Ho Ng 1156454bc887SKa Ho Ng ATF_REQUIRE(close(fd) == 0); 1157454bc887SKa Ho Ng } 1158454bc887SKa Ho Ng 115977ceadeeSMark Johnston static int 116077ceadeeSMark Johnston shm_open_large(int psind, int policy, size_t sz) 116177ceadeeSMark Johnston { 116277ceadeeSMark Johnston int error, fd; 116377ceadeeSMark Johnston 116477ceadeeSMark Johnston fd = shm_create_largepage(SHM_ANON, O_CREAT | O_RDWR, psind, policy, 0); 116577ceadeeSMark Johnston if (fd < 0 && errno == ENOTTY) 116677ceadeeSMark Johnston atf_tc_skip("no large page support"); 116777ceadeeSMark Johnston ATF_REQUIRE_MSG(fd >= 0, "shm_create_largepage failed; errno=%d", errno); 116877ceadeeSMark Johnston 116977ceadeeSMark Johnston error = ftruncate(fd, sz); 117077ceadeeSMark Johnston if (error != 0 && errno == ENOMEM) 117177ceadeeSMark Johnston /* 117277ceadeeSMark Johnston * The test system might not have enough memory to accommodate 117377ceadeeSMark Johnston * the request. 117477ceadeeSMark Johnston */ 117577ceadeeSMark Johnston atf_tc_skip("failed to allocate %zu-byte superpage", sz); 117677ceadeeSMark Johnston ATF_REQUIRE_MSG(error == 0, "ftruncate failed; errno=%d", errno); 117777ceadeeSMark Johnston 117877ceadeeSMark Johnston return (fd); 117977ceadeeSMark Johnston } 118077ceadeeSMark Johnston 118177ceadeeSMark Johnston static int 118277ceadeeSMark Johnston pagesizes(size_t ps[MAXPAGESIZES]) 118377ceadeeSMark Johnston { 118477ceadeeSMark Johnston int pscnt; 118577ceadeeSMark Johnston 118677ceadeeSMark Johnston pscnt = getpagesizes(ps, MAXPAGESIZES); 118777ceadeeSMark Johnston ATF_REQUIRE_MSG(pscnt != -1, "getpagesizes failed; errno=%d", errno); 118877ceadeeSMark Johnston ATF_REQUIRE_MSG(ps[0] == PAGE_SIZE, "psind 0 is %zu", ps[0]); 118977ceadeeSMark Johnston ATF_REQUIRE_MSG(pscnt <= MAXPAGESIZES, "invalid pscnt %d", pscnt); 119077ceadeeSMark Johnston if (pscnt == 1) 119177ceadeeSMark Johnston atf_tc_skip("no large page support"); 119277ceadeeSMark Johnston return (pscnt); 119377ceadeeSMark Johnston } 119477ceadeeSMark Johnston 119577ceadeeSMark Johnston ATF_TC_WITHOUT_HEAD(largepage_basic); 119677ceadeeSMark Johnston ATF_TC_BODY(largepage_basic, tc) 119777ceadeeSMark Johnston { 119877ceadeeSMark Johnston char zeroes[PAGE_SIZE]; 119977ceadeeSMark Johnston char *addr, *vec; 120077ceadeeSMark Johnston size_t ps[MAXPAGESIZES]; 120177ceadeeSMark Johnston int error, fd, pscnt; 120277ceadeeSMark Johnston 120377ceadeeSMark Johnston memset(zeroes, 0, PAGE_SIZE); 120477ceadeeSMark Johnston 120577ceadeeSMark Johnston pscnt = pagesizes(ps); 120677ceadeeSMark Johnston for (int i = 1; i < pscnt; i++) { 120777ceadeeSMark Johnston fd = shm_open_large(i, SHM_LARGEPAGE_ALLOC_DEFAULT, ps[i]); 120877ceadeeSMark Johnston 120977ceadeeSMark Johnston addr = mmap(NULL, ps[i], PROT_READ | PROT_WRITE, MAP_SHARED, fd, 121077ceadeeSMark Johnston 0); 121177ceadeeSMark Johnston ATF_REQUIRE_MSG(addr != MAP_FAILED, 121277ceadeeSMark Johnston "mmap(%zu bytes) failed; errno=%d", ps[i], errno); 121377ceadeeSMark Johnston ATF_REQUIRE_MSG(((uintptr_t)addr & (ps[i] - 1)) == 0, 121477ceadeeSMark Johnston "mmap(%zu bytes) returned unaligned mapping; addr=%p", 121577ceadeeSMark Johnston ps[i], addr); 121677ceadeeSMark Johnston 121777ceadeeSMark Johnston /* Force a page fault. */ 121877ceadeeSMark Johnston *(volatile char *)addr = 0; 121977ceadeeSMark Johnston 122077ceadeeSMark Johnston vec = malloc(ps[i] / PAGE_SIZE); 122177ceadeeSMark Johnston ATF_REQUIRE(vec != NULL); 122277ceadeeSMark Johnston error = mincore(addr, ps[i], vec); 122377ceadeeSMark Johnston ATF_REQUIRE_MSG(error == 0, "mincore failed; errno=%d", errno); 122477ceadeeSMark Johnston 122577ceadeeSMark Johnston /* Verify that all pages in the run are mapped. */ 122677ceadeeSMark Johnston for (size_t p = 0; p < ps[i] / PAGE_SIZE; p++) { 122777ceadeeSMark Johnston ATF_REQUIRE_MSG((vec[p] & MINCORE_INCORE) != 0, 122877ceadeeSMark Johnston "page %zu is not mapped", p); 122977ceadeeSMark Johnston ATF_REQUIRE_MSG((vec[p] & MINCORE_PSIND(i)) != 0, 123077ceadeeSMark Johnston "page %zu is not in a %zu-byte superpage", 123177ceadeeSMark Johnston p, ps[i]); 123277ceadeeSMark Johnston } 123377ceadeeSMark Johnston 123477ceadeeSMark Johnston /* Validate zeroing. */ 123577ceadeeSMark Johnston for (size_t p = 0; p < ps[i] / PAGE_SIZE; p++) { 123677ceadeeSMark Johnston ATF_REQUIRE_MSG(memcmp(addr + p * PAGE_SIZE, zeroes, 123777ceadeeSMark Johnston PAGE_SIZE) == 0, "page %zu miscompare", p); 123877ceadeeSMark Johnston } 123977ceadeeSMark Johnston 124077ceadeeSMark Johnston free(vec); 124177ceadeeSMark Johnston ATF_REQUIRE(munmap(addr, ps[i]) == 0); 124277ceadeeSMark Johnston ATF_REQUIRE(close(fd) == 0); 124377ceadeeSMark Johnston } 124477ceadeeSMark Johnston } 124577ceadeeSMark Johnston 124677ceadeeSMark Johnston extern int __sys_shm_open2(const char *, int, mode_t, int, const char *); 124777ceadeeSMark Johnston 124877ceadeeSMark Johnston ATF_TC_WITHOUT_HEAD(largepage_config); 124977ceadeeSMark Johnston ATF_TC_BODY(largepage_config, tc) 125077ceadeeSMark Johnston { 125177ceadeeSMark Johnston struct shm_largepage_conf lpc; 125277ceadeeSMark Johnston char *addr, *buf; 125377ceadeeSMark Johnston size_t ps[MAXPAGESIZES + 1]; /* silence warnings if MAXPAGESIZES == 1 */ 1254cd16a848SJohn Baldwin int error, fd; 125577ceadeeSMark Johnston 125605d17358SAndrew Turner (void)pagesizes(ps); 125705d17358SAndrew Turner 125877ceadeeSMark Johnston fd = shm_open(SHM_ANON, O_CREAT | O_RDWR, 0); 125977ceadeeSMark Johnston ATF_REQUIRE_MSG(fd >= 0, "shm_open failed; error=%d", errno); 126077ceadeeSMark Johnston 126177ceadeeSMark Johnston /* 126277ceadeeSMark Johnston * Configure a large page policy for an object created without 126377ceadeeSMark Johnston * SHM_LARGEPAGE. 126477ceadeeSMark Johnston */ 126577ceadeeSMark Johnston lpc.psind = 1; 126677ceadeeSMark Johnston lpc.alloc_policy = SHM_LARGEPAGE_ALLOC_DEFAULT; 126777ceadeeSMark Johnston error = ioctl(fd, FIOSSHMLPGCNF, &lpc); 126877ceadeeSMark Johnston ATF_REQUIRE(error != 0); 126977ceadeeSMark Johnston ATF_REQUIRE_MSG(errno == ENOTTY, "ioctl(FIOSSHMLPGCNF) returned %d", 127077ceadeeSMark Johnston errno); 127177ceadeeSMark Johnston ATF_REQUIRE(close(fd) == 0); 127277ceadeeSMark Johnston 127377ceadeeSMark Johnston /* 127477ceadeeSMark Johnston * Create a largepage object and try to use it without actually 127577ceadeeSMark Johnston * configuring anything. 127677ceadeeSMark Johnston */ 127777ceadeeSMark Johnston fd = __sys_shm_open2(SHM_ANON, O_CREAT | O_RDWR, 0, SHM_LARGEPAGE, 127877ceadeeSMark Johnston NULL); 127977ceadeeSMark Johnston if (fd < 0 && errno == ENOTTY) 128077ceadeeSMark Johnston atf_tc_skip("no large page support"); 128177ceadeeSMark Johnston ATF_REQUIRE_MSG(fd >= 0, "shm_open2 failed; error=%d", errno); 128277ceadeeSMark Johnston 128377ceadeeSMark Johnston error = ftruncate(fd, ps[1]); 128477ceadeeSMark Johnston ATF_REQUIRE(error != 0); 128577ceadeeSMark Johnston ATF_REQUIRE_MSG(errno == EINVAL, "ftruncate returned %d", errno); 128677ceadeeSMark Johnston 128777ceadeeSMark Johnston addr = mmap(NULL, ps[1], PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0); 128877ceadeeSMark Johnston ATF_REQUIRE(addr == MAP_FAILED); 128977ceadeeSMark Johnston ATF_REQUIRE_MSG(errno == EINVAL, "mmap returned %d", errno); 129077ceadeeSMark Johnston addr = mmap(NULL, 0, PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0); 129177ceadeeSMark Johnston ATF_REQUIRE(addr == MAP_FAILED); 129277ceadeeSMark Johnston ATF_REQUIRE_MSG(errno == EINVAL, "mmap returned %d", errno); 129377ceadeeSMark Johnston 129477ceadeeSMark Johnston buf = calloc(1, PAGE_SIZE); 129577ceadeeSMark Johnston ATF_REQUIRE(buf != NULL); 129677ceadeeSMark Johnston ATF_REQUIRE(write(fd, buf, PAGE_SIZE) == -1); 129777ceadeeSMark Johnston ATF_REQUIRE_MSG(errno == EINVAL, "write returned %d", errno); 129877ceadeeSMark Johnston free(buf); 129977ceadeeSMark Johnston buf = calloc(1, ps[1]); 130077ceadeeSMark Johnston ATF_REQUIRE(buf != NULL); 130177ceadeeSMark Johnston ATF_REQUIRE(write(fd, buf, ps[1]) == -1); 130277ceadeeSMark Johnston ATF_REQUIRE_MSG(errno == EINVAL, "write returned %d", errno); 130377ceadeeSMark Johnston free(buf); 130477ceadeeSMark Johnston 130577ceadeeSMark Johnston error = posix_fallocate(fd, 0, PAGE_SIZE); 130677ceadeeSMark Johnston ATF_REQUIRE_MSG(error == EINVAL, "posix_fallocate returned %d", error); 130777ceadeeSMark Johnston 130877ceadeeSMark Johnston ATF_REQUIRE(close(fd) == 0); 130977ceadeeSMark Johnston } 131077ceadeeSMark Johnston 131177ceadeeSMark Johnston ATF_TC_WITHOUT_HEAD(largepage_mmap); 131277ceadeeSMark Johnston ATF_TC_BODY(largepage_mmap, tc) 131377ceadeeSMark Johnston { 131477ceadeeSMark Johnston char *addr, *addr1, *vec; 131577ceadeeSMark Johnston size_t ps[MAXPAGESIZES]; 131677ceadeeSMark Johnston int fd, pscnt; 131777ceadeeSMark Johnston 131877ceadeeSMark Johnston pscnt = pagesizes(ps); 131977ceadeeSMark Johnston for (int i = 1; i < pscnt; i++) { 132077ceadeeSMark Johnston fd = shm_open_large(i, SHM_LARGEPAGE_ALLOC_DEFAULT, ps[i]); 132177ceadeeSMark Johnston 132277ceadeeSMark Johnston /* For mincore(). */ 132377ceadeeSMark Johnston vec = malloc(ps[i]); 132477ceadeeSMark Johnston ATF_REQUIRE(vec != NULL); 132577ceadeeSMark Johnston 132677ceadeeSMark Johnston /* 132777ceadeeSMark Johnston * Wrong mapping size. 132877ceadeeSMark Johnston */ 132977ceadeeSMark Johnston addr = mmap(NULL, ps[i - 1], PROT_READ | PROT_WRITE, MAP_SHARED, 133077ceadeeSMark Johnston fd, 0); 133177ceadeeSMark Johnston ATF_REQUIRE_MSG(addr == MAP_FAILED, 133277ceadeeSMark Johnston "mmap(%zu bytes) succeeded", ps[i - 1]); 133377ceadeeSMark Johnston ATF_REQUIRE_MSG(errno == EINVAL, 133477ceadeeSMark Johnston "mmap(%zu bytes) failed; error=%d", ps[i - 1], errno); 133577ceadeeSMark Johnston 133677ceadeeSMark Johnston /* 133777ceadeeSMark Johnston * Fixed mappings. 133877ceadeeSMark Johnston */ 133977ceadeeSMark Johnston addr = mmap(NULL, ps[i], PROT_READ | PROT_WRITE, MAP_SHARED, fd, 134077ceadeeSMark Johnston 0); 134177ceadeeSMark Johnston ATF_REQUIRE_MSG(addr != MAP_FAILED, 134277ceadeeSMark Johnston "mmap(%zu bytes) failed; errno=%d", ps[i], errno); 134377ceadeeSMark Johnston ATF_REQUIRE_MSG(((uintptr_t)addr & (ps[i] - 1)) == 0, 134477ceadeeSMark Johnston "mmap(%zu bytes) returned unaligned mapping; addr=%p", 134577ceadeeSMark Johnston ps[i], addr); 134677ceadeeSMark Johnston 134777ceadeeSMark Johnston /* Try mapping a small page with anonymous memory. */ 134877ceadeeSMark Johnston addr1 = mmap(addr, ps[i - 1], PROT_READ | PROT_WRITE, 134977ceadeeSMark Johnston MAP_PRIVATE | MAP_ANON | MAP_FIXED, -1, 0); 135077ceadeeSMark Johnston ATF_REQUIRE_MSG(addr1 == MAP_FAILED, 135177ceadeeSMark Johnston "anon mmap(%zu bytes) succeeded", ps[i - 1]); 135277ceadeeSMark Johnston ATF_REQUIRE_MSG(errno == EINVAL, "mmap returned %d", errno); 135377ceadeeSMark Johnston 135477ceadeeSMark Johnston /* Check MAP_EXCL when creating a second largepage mapping. */ 135577ceadeeSMark Johnston addr1 = mmap(addr, ps[i], PROT_READ | PROT_WRITE, 135677ceadeeSMark Johnston MAP_SHARED | MAP_FIXED | MAP_EXCL, fd, 0); 135777ceadeeSMark Johnston ATF_REQUIRE_MSG(addr1 == MAP_FAILED, 135877ceadeeSMark Johnston "mmap(%zu bytes) succeeded", ps[i]); 135977ceadeeSMark Johnston /* XXX wrong errno */ 136077ceadeeSMark Johnston ATF_REQUIRE_MSG(errno == ENOSPC, "mmap returned %d", errno); 136177ceadeeSMark Johnston 136277ceadeeSMark Johnston /* Overwrite a largepage mapping with a lagepage mapping. */ 136377ceadeeSMark Johnston addr1 = mmap(addr, ps[i], PROT_READ | PROT_WRITE, 136477ceadeeSMark Johnston MAP_SHARED | MAP_FIXED, fd, 0); 136577ceadeeSMark Johnston ATF_REQUIRE_MSG(addr1 != MAP_FAILED, 136677ceadeeSMark Johnston "mmap(%zu bytes) failed; errno=%d", ps[i], errno); 136777ceadeeSMark Johnston ATF_REQUIRE_MSG(addr == addr1, 136877ceadeeSMark Johnston "mmap(%zu bytes) moved from %p to %p", ps[i], addr, addr1); 136977ceadeeSMark Johnston 137077ceadeeSMark Johnston ATF_REQUIRE(munmap(addr, ps[i] == 0)); 137177ceadeeSMark Johnston 137277ceadeeSMark Johnston /* Clobber an anonymous mapping with a superpage. */ 137377ceadeeSMark Johnston addr1 = mmap(NULL, PAGE_SIZE, PROT_READ | PROT_WRITE, 137477ceadeeSMark Johnston MAP_ANON | MAP_PRIVATE | MAP_ALIGNED(ffsl(ps[i]) - 1), -1, 137577ceadeeSMark Johnston 0); 137677ceadeeSMark Johnston ATF_REQUIRE_MSG(addr1 != MAP_FAILED, 137777ceadeeSMark Johnston "mmap failed; error=%d", errno); 137877ceadeeSMark Johnston *(volatile char *)addr1 = '\0'; 137977ceadeeSMark Johnston addr = mmap(addr1, ps[i], PROT_READ | PROT_WRITE, 138077ceadeeSMark Johnston MAP_SHARED | MAP_FIXED, fd, 0); 138177ceadeeSMark Johnston ATF_REQUIRE_MSG(addr != MAP_FAILED, 138277ceadeeSMark Johnston "mmap failed; error=%d", errno); 138377ceadeeSMark Johnston ATF_REQUIRE_MSG(addr == addr1, 138477ceadeeSMark Johnston "mmap disobeyed MAP_FIXED, %p %p", addr, addr1); 138577ceadeeSMark Johnston *(volatile char *)addr = 0; /* fault */ 138677ceadeeSMark Johnston ATF_REQUIRE(mincore(addr, ps[i], vec) == 0); 138777ceadeeSMark Johnston for (size_t p = 0; p < ps[i] / PAGE_SIZE; p++) { 138877ceadeeSMark Johnston ATF_REQUIRE_MSG((vec[p] & MINCORE_INCORE) != 0, 138977ceadeeSMark Johnston "page %zu is not resident", p); 139077ceadeeSMark Johnston ATF_REQUIRE_MSG((vec[p] & MINCORE_PSIND(i)) != 0, 139177ceadeeSMark Johnston "page %zu is not resident", p); 139277ceadeeSMark Johnston } 139377ceadeeSMark Johnston 139477ceadeeSMark Johnston /* 139577ceadeeSMark Johnston * Copy-on-write mappings are not permitted. 139677ceadeeSMark Johnston */ 139777ceadeeSMark Johnston addr = mmap(NULL, ps[i], PROT_READ | PROT_WRITE, MAP_PRIVATE, 139877ceadeeSMark Johnston fd, 0); 139977ceadeeSMark Johnston ATF_REQUIRE_MSG(addr == MAP_FAILED, 140077ceadeeSMark Johnston "mmap(%zu bytes) succeeded", ps[i]); 140177ceadeeSMark Johnston 140277ceadeeSMark Johnston ATF_REQUIRE(close(fd) == 0); 140377ceadeeSMark Johnston } 140477ceadeeSMark Johnston } 140577ceadeeSMark Johnston 140677ceadeeSMark Johnston ATF_TC_WITHOUT_HEAD(largepage_munmap); 140777ceadeeSMark Johnston ATF_TC_BODY(largepage_munmap, tc) 140877ceadeeSMark Johnston { 140977ceadeeSMark Johnston char *addr; 141077ceadeeSMark Johnston size_t ps[MAXPAGESIZES], ps1; 141177ceadeeSMark Johnston int fd, pscnt; 141277ceadeeSMark Johnston 141377ceadeeSMark Johnston pscnt = pagesizes(ps); 141477ceadeeSMark Johnston for (int i = 1; i < pscnt; i++) { 141577ceadeeSMark Johnston fd = shm_open_large(i, SHM_LARGEPAGE_ALLOC_DEFAULT, ps[i]); 141677ceadeeSMark Johnston ps1 = ps[i - 1]; 141777ceadeeSMark Johnston 141877ceadeeSMark Johnston addr = mmap(NULL, ps[i], PROT_READ | PROT_WRITE, MAP_SHARED, fd, 141977ceadeeSMark Johnston 0); 142077ceadeeSMark Johnston ATF_REQUIRE_MSG(addr != MAP_FAILED, 142177ceadeeSMark Johnston "mmap(%zu bytes) failed; errno=%d", ps[i], errno); 142277ceadeeSMark Johnston 142377ceadeeSMark Johnston /* Try several unaligned munmap() requests. */ 142477ceadeeSMark Johnston ATF_REQUIRE(munmap(addr, ps1) != 0); 142577ceadeeSMark Johnston ATF_REQUIRE_MSG(errno == EINVAL, 142677ceadeeSMark Johnston "unexpected error %d from munmap", errno); 142777ceadeeSMark Johnston ATF_REQUIRE(munmap(addr, ps[i] - ps1)); 142877ceadeeSMark Johnston ATF_REQUIRE_MSG(errno == EINVAL, 142977ceadeeSMark Johnston "unexpected error %d from munmap", errno); 143077ceadeeSMark Johnston ATF_REQUIRE(munmap(addr + ps1, ps1) != 0); 143177ceadeeSMark Johnston ATF_REQUIRE_MSG(errno == EINVAL, 143277ceadeeSMark Johnston "unexpected error %d from munmap", errno); 143377ceadeeSMark Johnston ATF_REQUIRE(munmap(addr, 0)); 143477ceadeeSMark Johnston ATF_REQUIRE_MSG(errno == EINVAL, 143577ceadeeSMark Johnston "unexpected error %d from munmap", errno); 143677ceadeeSMark Johnston 143777ceadeeSMark Johnston ATF_REQUIRE(munmap(addr, ps[i]) == 0); 143877ceadeeSMark Johnston ATF_REQUIRE(close(fd) == 0); 143977ceadeeSMark Johnston } 144077ceadeeSMark Johnston } 144177ceadeeSMark Johnston 144277ceadeeSMark Johnston static void 144377ceadeeSMark Johnston largepage_madvise(char *addr, size_t sz, int advice, int error) 144477ceadeeSMark Johnston { 144577ceadeeSMark Johnston if (error == 0) { 144677ceadeeSMark Johnston ATF_REQUIRE_MSG(madvise(addr, sz, advice) == 0, 144777ceadeeSMark Johnston "madvise(%zu, %d) failed; error=%d", sz, advice, errno); 144877ceadeeSMark Johnston } else { 144977ceadeeSMark Johnston ATF_REQUIRE_MSG(madvise(addr, sz, advice) != 0, 145077ceadeeSMark Johnston "madvise(%zu, %d) succeeded", sz, advice); 145177ceadeeSMark Johnston ATF_REQUIRE_MSG(errno == error, 145277ceadeeSMark Johnston "unexpected error %d from madvise(%zu, %d)", 145377ceadeeSMark Johnston errno, sz, advice); 145477ceadeeSMark Johnston } 145577ceadeeSMark Johnston } 145677ceadeeSMark Johnston 145777ceadeeSMark Johnston ATF_TC_WITHOUT_HEAD(largepage_madvise); 145877ceadeeSMark Johnston ATF_TC_BODY(largepage_madvise, tc) 145977ceadeeSMark Johnston { 146077ceadeeSMark Johnston char *addr; 146177ceadeeSMark Johnston size_t ps[MAXPAGESIZES]; 146277ceadeeSMark Johnston int fd, pscnt; 146377ceadeeSMark Johnston 146477ceadeeSMark Johnston pscnt = pagesizes(ps); 146577ceadeeSMark Johnston for (int i = 1; i < pscnt; i++) { 146677ceadeeSMark Johnston fd = shm_open_large(i, SHM_LARGEPAGE_ALLOC_DEFAULT, ps[i]); 146777ceadeeSMark Johnston addr = mmap(NULL, ps[i], PROT_READ | PROT_WRITE, MAP_SHARED, fd, 146877ceadeeSMark Johnston 0); 146977ceadeeSMark Johnston ATF_REQUIRE_MSG(addr != MAP_FAILED, 147077ceadeeSMark Johnston "mmap(%zu bytes) failed; error=%d", ps[i], errno); 147177ceadeeSMark Johnston 147277ceadeeSMark Johnston /* Advice that requires clipping. */ 147377ceadeeSMark Johnston largepage_madvise(addr, PAGE_SIZE, MADV_NORMAL, EINVAL); 147477ceadeeSMark Johnston largepage_madvise(addr, ps[i], MADV_NORMAL, 0); 147577ceadeeSMark Johnston largepage_madvise(addr, PAGE_SIZE, MADV_RANDOM, EINVAL); 147677ceadeeSMark Johnston largepage_madvise(addr, ps[i], MADV_RANDOM, 0); 147777ceadeeSMark Johnston largepage_madvise(addr, PAGE_SIZE, MADV_SEQUENTIAL, EINVAL); 147877ceadeeSMark Johnston largepage_madvise(addr, ps[i], MADV_SEQUENTIAL, 0); 147977ceadeeSMark Johnston largepage_madvise(addr, PAGE_SIZE, MADV_NOSYNC, EINVAL); 148077ceadeeSMark Johnston largepage_madvise(addr, ps[i], MADV_NOSYNC, 0); 148177ceadeeSMark Johnston largepage_madvise(addr, PAGE_SIZE, MADV_AUTOSYNC, EINVAL); 148277ceadeeSMark Johnston largepage_madvise(addr, ps[i], MADV_AUTOSYNC, 0); 148377ceadeeSMark Johnston largepage_madvise(addr, PAGE_SIZE, MADV_CORE, EINVAL); 148477ceadeeSMark Johnston largepage_madvise(addr, ps[i], MADV_CORE, 0); 148577ceadeeSMark Johnston largepage_madvise(addr, PAGE_SIZE, MADV_NOCORE, EINVAL); 148677ceadeeSMark Johnston largepage_madvise(addr, ps[i], MADV_NOCORE, 0); 148777ceadeeSMark Johnston 148877ceadeeSMark Johnston /* Advice that does not result in clipping. */ 148977ceadeeSMark Johnston largepage_madvise(addr, PAGE_SIZE, MADV_DONTNEED, 0); 149077ceadeeSMark Johnston largepage_madvise(addr, ps[i], MADV_DONTNEED, 0); 149177ceadeeSMark Johnston largepage_madvise(addr, PAGE_SIZE, MADV_WILLNEED, 0); 149277ceadeeSMark Johnston largepage_madvise(addr, ps[i], MADV_WILLNEED, 0); 149377ceadeeSMark Johnston largepage_madvise(addr, PAGE_SIZE, MADV_FREE, 0); 149477ceadeeSMark Johnston largepage_madvise(addr, ps[i], MADV_FREE, 0); 149577ceadeeSMark Johnston 149677ceadeeSMark Johnston ATF_REQUIRE(munmap(addr, ps[i]) == 0); 149777ceadeeSMark Johnston ATF_REQUIRE(close(fd) == 0); 149877ceadeeSMark Johnston } 149977ceadeeSMark Johnston } 150077ceadeeSMark Johnston 150177ceadeeSMark Johnston ATF_TC(largepage_mlock); 150277ceadeeSMark Johnston ATF_TC_HEAD(largepage_mlock, tc) 150377ceadeeSMark Johnston { 150477ceadeeSMark Johnston /* Needed to set rlimit. */ 150577ceadeeSMark Johnston atf_tc_set_md_var(tc, "require.user", "root"); 150677ceadeeSMark Johnston } 150777ceadeeSMark Johnston ATF_TC_BODY(largepage_mlock, tc) 150877ceadeeSMark Johnston { 150977ceadeeSMark Johnston struct rlimit rl; 151077ceadeeSMark Johnston char *addr; 151177ceadeeSMark Johnston size_t ps[MAXPAGESIZES], sz; 151277ceadeeSMark Johnston u_long max_wired, wired; 151377ceadeeSMark Johnston int fd, error, pscnt; 151477ceadeeSMark Johnston 151577ceadeeSMark Johnston rl.rlim_cur = rl.rlim_max = RLIM_INFINITY; 151677ceadeeSMark Johnston ATF_REQUIRE_MSG(setrlimit(RLIMIT_MEMLOCK, &rl) == 0, 151777ceadeeSMark Johnston "setrlimit failed; error=%d", errno); 151877ceadeeSMark Johnston 151977ceadeeSMark Johnston sz = sizeof(max_wired); 152077ceadeeSMark Johnston error = sysctlbyname("vm.max_user_wired", &max_wired, &sz, NULL, 0); 152177ceadeeSMark Johnston ATF_REQUIRE_MSG(error == 0, 152277ceadeeSMark Johnston "sysctlbyname(vm.max_user_wired) failed; error=%d", errno); 152377ceadeeSMark Johnston 152477ceadeeSMark Johnston sz = sizeof(wired); 152577ceadeeSMark Johnston error = sysctlbyname("vm.stats.vm.v_user_wire_count", &wired, &sz, NULL, 152677ceadeeSMark Johnston 0); 152777ceadeeSMark Johnston ATF_REQUIRE_MSG(error == 0, 152877ceadeeSMark Johnston "sysctlbyname(vm.stats.vm.v_user_wire_count) failed; error=%d", 152977ceadeeSMark Johnston errno); 153077ceadeeSMark Johnston 153177ceadeeSMark Johnston pscnt = pagesizes(ps); 153277ceadeeSMark Johnston for (int i = 1; i < pscnt; i++) { 153377ceadeeSMark Johnston if (ps[i] / PAGE_SIZE > max_wired - wired) { 153477ceadeeSMark Johnston /* Cannot wire past the limit. */ 153577ceadeeSMark Johnston atf_tc_skip("test would exceed wiring limit"); 153677ceadeeSMark Johnston } 153777ceadeeSMark Johnston 153877ceadeeSMark Johnston fd = shm_open_large(i, SHM_LARGEPAGE_ALLOC_DEFAULT, ps[i]); 153977ceadeeSMark Johnston addr = mmap(NULL, ps[i], PROT_READ | PROT_WRITE, MAP_SHARED, fd, 154077ceadeeSMark Johnston 0); 154177ceadeeSMark Johnston ATF_REQUIRE_MSG(addr != MAP_FAILED, 154277ceadeeSMark Johnston "mmap(%zu bytes) failed; error=%d", ps[i], errno); 154377ceadeeSMark Johnston 154477ceadeeSMark Johnston ATF_REQUIRE(mlock(addr, PAGE_SIZE) != 0); 154577ceadeeSMark Johnston ATF_REQUIRE_MSG(errno == EINVAL, 154677ceadeeSMark Johnston "unexpected error %d from mlock(%zu bytes)", errno, ps[i]); 154777ceadeeSMark Johnston ATF_REQUIRE(mlock(addr, ps[i] - PAGE_SIZE) != 0); 154877ceadeeSMark Johnston ATF_REQUIRE_MSG(errno == EINVAL, 154977ceadeeSMark Johnston "unexpected error %d from mlock(%zu bytes)", errno, ps[i]); 155077ceadeeSMark Johnston 155177ceadeeSMark Johnston ATF_REQUIRE_MSG(mlock(addr, ps[i]) == 0, 155277ceadeeSMark Johnston "mlock failed; error=%d", errno); 155377ceadeeSMark Johnston 155477ceadeeSMark Johnston ATF_REQUIRE(munmap(addr, ps[i]) == 0); 155577ceadeeSMark Johnston 155677ceadeeSMark Johnston ATF_REQUIRE(mlockall(MCL_FUTURE) == 0); 155777ceadeeSMark Johnston addr = mmap(NULL, ps[i], PROT_READ | PROT_WRITE, MAP_SHARED, fd, 155877ceadeeSMark Johnston 0); 155977ceadeeSMark Johnston ATF_REQUIRE_MSG(addr != MAP_FAILED, 156077ceadeeSMark Johnston "mmap(%zu bytes) failed; error=%d", ps[i], errno); 156177ceadeeSMark Johnston 156277ceadeeSMark Johnston ATF_REQUIRE(munmap(addr, ps[i]) == 0); 156377ceadeeSMark Johnston ATF_REQUIRE(close(fd) == 0); 156477ceadeeSMark Johnston } 156577ceadeeSMark Johnston } 156677ceadeeSMark Johnston 156777ceadeeSMark Johnston ATF_TC_WITHOUT_HEAD(largepage_msync); 156877ceadeeSMark Johnston ATF_TC_BODY(largepage_msync, tc) 156977ceadeeSMark Johnston { 157077ceadeeSMark Johnston char *addr; 157177ceadeeSMark Johnston size_t ps[MAXPAGESIZES]; 157277ceadeeSMark Johnston int fd, pscnt; 157377ceadeeSMark Johnston 157477ceadeeSMark Johnston pscnt = pagesizes(ps); 157577ceadeeSMark Johnston for (int i = 1; i < pscnt; i++) { 157677ceadeeSMark Johnston fd = shm_open_large(i, SHM_LARGEPAGE_ALLOC_DEFAULT, ps[i]); 157777ceadeeSMark Johnston addr = mmap(NULL, ps[i], PROT_READ | PROT_WRITE, MAP_SHARED, fd, 157877ceadeeSMark Johnston 0); 157977ceadeeSMark Johnston ATF_REQUIRE_MSG(addr != MAP_FAILED, 158077ceadeeSMark Johnston "mmap(%zu bytes) failed; error=%d", ps[i], errno); 158177ceadeeSMark Johnston 158277ceadeeSMark Johnston memset(addr, 0, ps[i]); 158377ceadeeSMark Johnston 158477ceadeeSMark Johnston /* 158577ceadeeSMark Johnston * "Sync" requests are no-ops for SHM objects, so small 158677ceadeeSMark Johnston * PAGE_SIZE-sized requests succeed. 158777ceadeeSMark Johnston */ 158877ceadeeSMark Johnston ATF_REQUIRE_MSG(msync(addr, PAGE_SIZE, MS_ASYNC) == 0, 158977ceadeeSMark Johnston "msync(MS_ASYNC) failed; error=%d", errno); 159077ceadeeSMark Johnston ATF_REQUIRE_MSG(msync(addr, ps[i], MS_ASYNC) == 0, 159177ceadeeSMark Johnston "msync(MS_ASYNC) failed; error=%d", errno); 159277ceadeeSMark Johnston ATF_REQUIRE_MSG(msync(addr, PAGE_SIZE, MS_SYNC) == 0, 159377ceadeeSMark Johnston "msync(MS_SYNC) failed; error=%d", errno); 159477ceadeeSMark Johnston ATF_REQUIRE_MSG(msync(addr, ps[i], MS_SYNC) == 0, 159577ceadeeSMark Johnston "msync(MS_SYNC) failed; error=%d", errno); 159677ceadeeSMark Johnston 159777ceadeeSMark Johnston ATF_REQUIRE_MSG(msync(addr, PAGE_SIZE, MS_INVALIDATE) != 0, 159877ceadeeSMark Johnston "msync(MS_INVALIDATE) succeeded"); 159977ceadeeSMark Johnston /* XXX wrong errno */ 160077ceadeeSMark Johnston ATF_REQUIRE_MSG(errno == EBUSY, 160177ceadeeSMark Johnston "unexpected error %d from msync(MS_INVALIDATE)", errno); 160277ceadeeSMark Johnston ATF_REQUIRE_MSG(msync(addr, ps[i], MS_INVALIDATE) == 0, 160377ceadeeSMark Johnston "msync(MS_INVALIDATE) failed; error=%d", errno); 160477ceadeeSMark Johnston memset(addr, 0, ps[i]); 160577ceadeeSMark Johnston 160677ceadeeSMark Johnston ATF_REQUIRE(munmap(addr, ps[i]) == 0); 160777ceadeeSMark Johnston ATF_REQUIRE(close(fd) == 0); 160877ceadeeSMark Johnston } 160977ceadeeSMark Johnston } 161077ceadeeSMark Johnston 161177ceadeeSMark Johnston static void 161277ceadeeSMark Johnston largepage_protect(char *addr, size_t sz, int prot, int error) 161377ceadeeSMark Johnston { 161477ceadeeSMark Johnston if (error == 0) { 161577ceadeeSMark Johnston ATF_REQUIRE_MSG(mprotect(addr, sz, prot) == 0, 161677ceadeeSMark Johnston "mprotect(%zu, %x) failed; error=%d", sz, prot, errno); 161777ceadeeSMark Johnston } else { 161877ceadeeSMark Johnston ATF_REQUIRE_MSG(mprotect(addr, sz, prot) != 0, 161977ceadeeSMark Johnston "mprotect(%zu, %x) succeeded", sz, prot); 162077ceadeeSMark Johnston ATF_REQUIRE_MSG(errno == error, 162177ceadeeSMark Johnston "unexpected error %d from mprotect(%zu, %x)", 162277ceadeeSMark Johnston errno, sz, prot); 162377ceadeeSMark Johnston } 162477ceadeeSMark Johnston } 162577ceadeeSMark Johnston 162677ceadeeSMark Johnston ATF_TC_WITHOUT_HEAD(largepage_mprotect); 162777ceadeeSMark Johnston ATF_TC_BODY(largepage_mprotect, tc) 162877ceadeeSMark Johnston { 162977ceadeeSMark Johnston char *addr, *addr1; 163077ceadeeSMark Johnston size_t ps[MAXPAGESIZES]; 163177ceadeeSMark Johnston int fd, pscnt; 163277ceadeeSMark Johnston 163377ceadeeSMark Johnston pscnt = pagesizes(ps); 163477ceadeeSMark Johnston for (int i = 1; i < pscnt; i++) { 1635321e586eSMark Johnston /* 1636321e586eSMark Johnston * Reserve a contiguous region in the address space to avoid 1637321e586eSMark Johnston * spurious failures in the face of ASLR. 1638321e586eSMark Johnston */ 1639321e586eSMark Johnston addr = mmap(NULL, ps[i] * 2, PROT_NONE, 1640321e586eSMark Johnston MAP_ANON | MAP_ALIGNED(ffsl(ps[i]) - 1), -1, 0); 1641321e586eSMark Johnston ATF_REQUIRE_MSG(addr != MAP_FAILED, 1642321e586eSMark Johnston "mmap(%zu bytes) failed; error=%d", ps[i], errno); 1643321e586eSMark Johnston ATF_REQUIRE(munmap(addr, ps[i] * 2) == 0); 1644321e586eSMark Johnston 164577ceadeeSMark Johnston fd = shm_open_large(i, SHM_LARGEPAGE_ALLOC_DEFAULT, ps[i]); 1646321e586eSMark Johnston addr = mmap(addr, ps[i], PROT_READ | PROT_WRITE, 1647321e586eSMark Johnston MAP_SHARED | MAP_FIXED, fd, 0); 164877ceadeeSMark Johnston ATF_REQUIRE_MSG(addr != MAP_FAILED, 164977ceadeeSMark Johnston "mmap(%zu bytes) failed; error=%d", ps[i], errno); 165077ceadeeSMark Johnston 165177ceadeeSMark Johnston /* 165277ceadeeSMark Johnston * These should be no-ops from the pmap perspective since the 165377ceadeeSMark Johnston * page is not yet entered into the pmap. 165477ceadeeSMark Johnston */ 165577ceadeeSMark Johnston largepage_protect(addr, PAGE_SIZE, PROT_READ, EINVAL); 165677ceadeeSMark Johnston largepage_protect(addr, ps[i], PROT_READ, 0); 165777ceadeeSMark Johnston largepage_protect(addr, PAGE_SIZE, PROT_NONE, EINVAL); 165877ceadeeSMark Johnston largepage_protect(addr, ps[i], PROT_NONE, 0); 165977ceadeeSMark Johnston largepage_protect(addr, PAGE_SIZE, 166077ceadeeSMark Johnston PROT_READ | PROT_WRITE | PROT_EXEC, EINVAL); 166177ceadeeSMark Johnston largepage_protect(addr, ps[i], 166277ceadeeSMark Johnston PROT_READ | PROT_WRITE | PROT_EXEC, 0); 166377ceadeeSMark Johnston 166477ceadeeSMark Johnston /* Trigger creation of a mapping and try again. */ 166577ceadeeSMark Johnston *(volatile char *)addr = 0; 166677ceadeeSMark Johnston largepage_protect(addr, PAGE_SIZE, PROT_READ, EINVAL); 166777ceadeeSMark Johnston largepage_protect(addr, ps[i], PROT_READ, 0); 166877ceadeeSMark Johnston largepage_protect(addr, PAGE_SIZE, PROT_NONE, EINVAL); 166977ceadeeSMark Johnston largepage_protect(addr, ps[i], PROT_NONE, 0); 167077ceadeeSMark Johnston largepage_protect(addr, PAGE_SIZE, 167177ceadeeSMark Johnston PROT_READ | PROT_WRITE | PROT_EXEC, EINVAL); 167277ceadeeSMark Johnston largepage_protect(addr, ps[i], 167377ceadeeSMark Johnston PROT_READ | PROT_WRITE | PROT_EXEC, 0); 167477ceadeeSMark Johnston 167577ceadeeSMark Johnston memset(addr, 0, ps[i]); 167677ceadeeSMark Johnston 167777ceadeeSMark Johnston /* Map two contiguous large pages and merge map entries. */ 167877ceadeeSMark Johnston addr1 = mmap(addr + ps[i], ps[i], PROT_READ | PROT_WRITE, 167977ceadeeSMark Johnston MAP_SHARED | MAP_FIXED | MAP_EXCL, fd, 0); 168077ceadeeSMark Johnston ATF_REQUIRE_MSG(addr1 != MAP_FAILED, 168177ceadeeSMark Johnston "mmap(%zu bytes) failed; error=%d", ps[i], errno); 168277ceadeeSMark Johnston 168377ceadeeSMark Johnston largepage_protect(addr1 - PAGE_SIZE, PAGE_SIZE * 2, 168477ceadeeSMark Johnston PROT_READ | PROT_WRITE, EINVAL); 168577ceadeeSMark Johnston largepage_protect(addr, ps[i] * 2, PROT_READ | PROT_WRITE, 0); 168677ceadeeSMark Johnston 168777ceadeeSMark Johnston memset(addr, 0, ps[i] * 2); 168877ceadeeSMark Johnston 168977ceadeeSMark Johnston ATF_REQUIRE(munmap(addr, ps[i]) == 0); 169077ceadeeSMark Johnston ATF_REQUIRE(munmap(addr1, ps[i]) == 0); 169177ceadeeSMark Johnston ATF_REQUIRE(close(fd) == 0); 169277ceadeeSMark Johnston } 169377ceadeeSMark Johnston } 169477ceadeeSMark Johnston 169577ceadeeSMark Johnston ATF_TC_WITHOUT_HEAD(largepage_minherit); 169677ceadeeSMark Johnston ATF_TC_BODY(largepage_minherit, tc) 169777ceadeeSMark Johnston { 169877ceadeeSMark Johnston char *addr; 169977ceadeeSMark Johnston size_t ps[MAXPAGESIZES]; 170077ceadeeSMark Johnston pid_t child; 170177ceadeeSMark Johnston int fd, pscnt, status; 170277ceadeeSMark Johnston 170377ceadeeSMark Johnston pscnt = pagesizes(ps); 170477ceadeeSMark Johnston for (int i = 1; i < pscnt; i++) { 170577ceadeeSMark Johnston fd = shm_open_large(i, SHM_LARGEPAGE_ALLOC_DEFAULT, ps[i]); 170677ceadeeSMark Johnston addr = mmap(NULL, ps[i], PROT_READ | PROT_WRITE, MAP_SHARED, fd, 170777ceadeeSMark Johnston 0); 170877ceadeeSMark Johnston ATF_REQUIRE_MSG(addr != MAP_FAILED, 170977ceadeeSMark Johnston "mmap(%zu bytes) failed; error=%d", ps[i], errno); 171077ceadeeSMark Johnston 171177ceadeeSMark Johnston ATF_REQUIRE(minherit(addr, PAGE_SIZE, INHERIT_SHARE) != 0); 171277ceadeeSMark Johnston 171377ceadeeSMark Johnston ATF_REQUIRE_MSG(minherit(addr, ps[i], INHERIT_SHARE) == 0, 171477ceadeeSMark Johnston "minherit(%zu bytes) failed; error=%d", ps[i], errno); 171577ceadeeSMark Johnston child = fork(); 171677ceadeeSMark Johnston ATF_REQUIRE_MSG(child != -1, "fork failed; error=%d", errno); 171777ceadeeSMark Johnston if (child == 0) { 171877ceadeeSMark Johnston char v; 171977ceadeeSMark Johnston 172077ceadeeSMark Johnston *(volatile char *)addr = 0; 172177ceadeeSMark Johnston if (mincore(addr, PAGE_SIZE, &v) != 0) 172277ceadeeSMark Johnston _exit(1); 172377ceadeeSMark Johnston if ((v & MINCORE_PSIND(i)) == 0) 172477ceadeeSMark Johnston _exit(2); 172577ceadeeSMark Johnston _exit(0); 172677ceadeeSMark Johnston } 172777ceadeeSMark Johnston ATF_REQUIRE_MSG(waitpid(child, &status, 0) == child, 172877ceadeeSMark Johnston "waitpid failed; error=%d", errno); 172977ceadeeSMark Johnston ATF_REQUIRE_MSG(WIFEXITED(status), 173077ceadeeSMark Johnston "child was killed by signal %d", WTERMSIG(status)); 173177ceadeeSMark Johnston ATF_REQUIRE_MSG(WEXITSTATUS(status) == 0, 173277ceadeeSMark Johnston "child exited with status %d", WEXITSTATUS(status)); 173377ceadeeSMark Johnston 173477ceadeeSMark Johnston ATF_REQUIRE_MSG(minherit(addr, ps[i], INHERIT_NONE) == 0, 173577ceadeeSMark Johnston "minherit(%zu bytes) failed; error=%d", ps[i], errno); 173677ceadeeSMark Johnston child = fork(); 173777ceadeeSMark Johnston ATF_REQUIRE_MSG(child != -1, "fork failed; error=%d", errno); 173877ceadeeSMark Johnston if (child == 0) { 173977ceadeeSMark Johnston char v; 174077ceadeeSMark Johnston 174177ceadeeSMark Johnston if (mincore(addr, PAGE_SIZE, &v) == 0) 174277ceadeeSMark Johnston _exit(1); 174377ceadeeSMark Johnston _exit(0); 174477ceadeeSMark Johnston } 174577ceadeeSMark Johnston ATF_REQUIRE_MSG(waitpid(child, &status, 0) == child, 174677ceadeeSMark Johnston "waitpid failed; error=%d", errno); 174777ceadeeSMark Johnston ATF_REQUIRE_MSG(WIFEXITED(status), 174877ceadeeSMark Johnston "child was killed by signal %d", WTERMSIG(status)); 174977ceadeeSMark Johnston ATF_REQUIRE_MSG(WEXITSTATUS(status) == 0, 175077ceadeeSMark Johnston "child exited with status %d", WEXITSTATUS(status)); 175177ceadeeSMark Johnston 175277ceadeeSMark Johnston /* Copy-on-write is not supported for static large pages. */ 175377ceadeeSMark Johnston ATF_REQUIRE_MSG(minherit(addr, ps[i], INHERIT_COPY) != 0, 175477ceadeeSMark Johnston "minherit(%zu bytes) succeeded", ps[i]); 175577ceadeeSMark Johnston 175677ceadeeSMark Johnston ATF_REQUIRE_MSG(minherit(addr, ps[i], INHERIT_ZERO) == 0, 175777ceadeeSMark Johnston "minherit(%zu bytes) failed; error=%d", ps[i], errno); 175877ceadeeSMark Johnston child = fork(); 175977ceadeeSMark Johnston ATF_REQUIRE_MSG(child != -1, "fork failed; error=%d", errno); 176077ceadeeSMark Johnston if (child == 0) { 176177ceadeeSMark Johnston char v; 176277ceadeeSMark Johnston 176377ceadeeSMark Johnston *(volatile char *)addr = 0; 176477ceadeeSMark Johnston if (mincore(addr, PAGE_SIZE, &v) != 0) 176577ceadeeSMark Johnston _exit(1); 176677ceadeeSMark Johnston if ((v & MINCORE_SUPER) != 0) 176777ceadeeSMark Johnston _exit(2); 176877ceadeeSMark Johnston _exit(0); 176977ceadeeSMark Johnston } 177077ceadeeSMark Johnston ATF_REQUIRE_MSG(waitpid(child, &status, 0) == child, 177177ceadeeSMark Johnston "waitpid failed; error=%d", errno); 177277ceadeeSMark Johnston ATF_REQUIRE_MSG(WIFEXITED(status), 177377ceadeeSMark Johnston "child was killed by signal %d", WTERMSIG(status)); 177477ceadeeSMark Johnston ATF_REQUIRE_MSG(WEXITSTATUS(status) == 0, 177577ceadeeSMark Johnston "child exited with status %d", WEXITSTATUS(status)); 177677ceadeeSMark Johnston 177777ceadeeSMark Johnston ATF_REQUIRE(munmap(addr, ps[i]) == 0); 177877ceadeeSMark Johnston ATF_REQUIRE(close(fd) == 0); 177977ceadeeSMark Johnston } 178077ceadeeSMark Johnston } 178177ceadeeSMark Johnston 178277ceadeeSMark Johnston ATF_TC_WITHOUT_HEAD(largepage_pipe); 178377ceadeeSMark Johnston ATF_TC_BODY(largepage_pipe, tc) 178477ceadeeSMark Johnston { 178577ceadeeSMark Johnston size_t ps[MAXPAGESIZES]; 178677ceadeeSMark Johnston char *addr; 178777ceadeeSMark Johnston ssize_t len; 178877ceadeeSMark Johnston int fd, pfd[2], pscnt, status; 178977ceadeeSMark Johnston pid_t child; 179077ceadeeSMark Johnston 179177ceadeeSMark Johnston pscnt = pagesizes(ps); 179277ceadeeSMark Johnston 179377ceadeeSMark Johnston for (int i = 1; i < pscnt; i++) { 179477ceadeeSMark Johnston fd = shm_open_large(i, SHM_LARGEPAGE_ALLOC_DEFAULT, ps[i]); 179577ceadeeSMark Johnston addr = mmap(NULL, ps[i], PROT_READ | PROT_WRITE, MAP_SHARED, fd, 179677ceadeeSMark Johnston 0); 179777ceadeeSMark Johnston ATF_REQUIRE_MSG(addr != MAP_FAILED, 179877ceadeeSMark Johnston "mmap(%zu bytes) failed; error=%d", ps[i], errno); 179977ceadeeSMark Johnston 180077ceadeeSMark Johnston /* Trigger creation of a mapping. */ 180177ceadeeSMark Johnston *(volatile char *)addr = '\0'; 180277ceadeeSMark Johnston 180377ceadeeSMark Johnston ATF_REQUIRE(pipe(pfd) == 0); 180477ceadeeSMark Johnston child = fork(); 180577ceadeeSMark Johnston ATF_REQUIRE_MSG(child != -1, "fork() failed; error=%d", errno); 180677ceadeeSMark Johnston if (child == 0) { 180777ceadeeSMark Johnston char buf[BUFSIZ]; 180877ceadeeSMark Johnston ssize_t resid; 180977ceadeeSMark Johnston 181077ceadeeSMark Johnston (void)close(pfd[0]); 181177ceadeeSMark Johnston for (resid = (size_t)ps[i]; resid > 0; resid -= len) { 181277ceadeeSMark Johnston len = read(pfd[1], buf, sizeof(buf)); 181377ceadeeSMark Johnston if (len < 0) 181477ceadeeSMark Johnston _exit(1); 181577ceadeeSMark Johnston } 181677ceadeeSMark Johnston _exit(0); 181777ceadeeSMark Johnston } 181877ceadeeSMark Johnston ATF_REQUIRE(close(pfd[1]) == 0); 181977ceadeeSMark Johnston len = write(pfd[0], addr, ps[i]); 182077ceadeeSMark Johnston ATF_REQUIRE_MSG(len >= 0, "write() failed; error=%d", errno); 182177ceadeeSMark Johnston ATF_REQUIRE_MSG(len == (ssize_t)ps[i], 182277ceadeeSMark Johnston "short write; len=%zd", len); 182377ceadeeSMark Johnston ATF_REQUIRE(close(pfd[0]) == 0); 182477ceadeeSMark Johnston 182577ceadeeSMark Johnston ATF_REQUIRE_MSG(waitpid(child, &status, 0) == child, 182677ceadeeSMark Johnston "waitpid() failed; error=%d", errno); 182777ceadeeSMark Johnston ATF_REQUIRE_MSG(WIFEXITED(status), 182877ceadeeSMark Johnston "child was killed by signal %d", WTERMSIG(status)); 182977ceadeeSMark Johnston ATF_REQUIRE_MSG(WEXITSTATUS(status) == 0, 183077ceadeeSMark Johnston "child exited with status %d", WEXITSTATUS(status)); 183177ceadeeSMark Johnston 183277ceadeeSMark Johnston ATF_REQUIRE(munmap(addr, ps[i]) == 0); 183377ceadeeSMark Johnston ATF_REQUIRE(close(fd) == 0); 183477ceadeeSMark Johnston } 183577ceadeeSMark Johnston } 183677ceadeeSMark Johnston 183777ceadeeSMark Johnston ATF_TC_WITHOUT_HEAD(largepage_reopen); 183877ceadeeSMark Johnston ATF_TC_BODY(largepage_reopen, tc) 183977ceadeeSMark Johnston { 184077ceadeeSMark Johnston char *addr, *vec; 184177ceadeeSMark Johnston size_t ps[MAXPAGESIZES]; 184277ceadeeSMark Johnston int fd, psind; 184377ceadeeSMark Johnston 184477ceadeeSMark Johnston (void)pagesizes(ps); 184577ceadeeSMark Johnston psind = 1; 184677ceadeeSMark Johnston 184777ceadeeSMark Johnston gen_test_path(); 184877ceadeeSMark Johnston fd = shm_create_largepage(test_path, O_CREAT | O_RDWR, psind, 184977ceadeeSMark Johnston SHM_LARGEPAGE_ALLOC_DEFAULT, 0600); 185077ceadeeSMark Johnston if (fd < 0 && errno == ENOTTY) 185177ceadeeSMark Johnston atf_tc_skip("no large page support"); 185277ceadeeSMark Johnston ATF_REQUIRE_MSG(fd >= 0, "shm_create_largepage failed; error=%d", errno); 185377ceadeeSMark Johnston 185477ceadeeSMark Johnston ATF_REQUIRE_MSG(ftruncate(fd, ps[psind]) == 0, 185577ceadeeSMark Johnston "ftruncate failed; error=%d", errno); 185677ceadeeSMark Johnston 185777ceadeeSMark Johnston ATF_REQUIRE_MSG(close(fd) == 0, "close failed; error=%d", errno); 185877ceadeeSMark Johnston 185977ceadeeSMark Johnston fd = shm_open(test_path, O_RDWR, 0); 186077ceadeeSMark Johnston ATF_REQUIRE_MSG(fd >= 0, "shm_open failed; error=%d", errno); 186177ceadeeSMark Johnston 186277ceadeeSMark Johnston addr = mmap(NULL, ps[psind], PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0); 186377ceadeeSMark Johnston ATF_REQUIRE_MSG(addr != MAP_FAILED, "mmap failed; error=%d", errno); 186477ceadeeSMark Johnston 186577ceadeeSMark Johnston /* Trigger a fault and mapping creation. */ 186677ceadeeSMark Johnston *(volatile char *)addr = 0; 186777ceadeeSMark Johnston 186877ceadeeSMark Johnston vec = malloc(ps[psind] / PAGE_SIZE); 186977ceadeeSMark Johnston ATF_REQUIRE(vec != NULL); 187077ceadeeSMark Johnston ATF_REQUIRE_MSG(mincore(addr, ps[psind], vec) == 0, 187177ceadeeSMark Johnston "mincore failed; error=%d", errno); 187277ceadeeSMark Johnston ATF_REQUIRE_MSG((vec[0] & MINCORE_PSIND(psind)) != 0, 187377ceadeeSMark Johnston "page not mapped into a %zu-byte superpage", ps[psind]); 187477ceadeeSMark Johnston 187577ceadeeSMark Johnston ATF_REQUIRE_MSG(shm_unlink(test_path) == 0, 187677ceadeeSMark Johnston "shm_unlink failed; errno=%d", errno); 187777ceadeeSMark Johnston ATF_REQUIRE_MSG(close(fd) == 0, 187877ceadeeSMark Johnston "close failed; errno=%d", errno); 187977ceadeeSMark Johnston } 188077ceadeeSMark Johnston 18814fdc3d75SEnji Cooper ATF_TP_ADD_TCS(tp) 18824fdc3d75SEnji Cooper { 18834fdc3d75SEnji Cooper 18844fdc3d75SEnji Cooper ATF_TP_ADD_TC(tp, remap_object); 18859afb12baSDavid Bright ATF_TP_ADD_TC(tp, rename_from_anon); 18869afb12baSDavid Bright ATF_TP_ADD_TC(tp, rename_bad_path_pointer); 18879afb12baSDavid Bright ATF_TP_ADD_TC(tp, rename_from_nonexisting); 18889afb12baSDavid Bright ATF_TP_ADD_TC(tp, rename_to_anon); 18899afb12baSDavid Bright ATF_TP_ADD_TC(tp, rename_to_replace); 18909afb12baSDavid Bright ATF_TP_ADD_TC(tp, rename_to_noreplace); 18919afb12baSDavid Bright ATF_TP_ADD_TC(tp, rename_to_exchange); 18929afb12baSDavid Bright ATF_TP_ADD_TC(tp, rename_to_exchange_nonexisting); 18939afb12baSDavid Bright ATF_TP_ADD_TC(tp, rename_to_self); 18949afb12baSDavid Bright ATF_TP_ADD_TC(tp, rename_bad_flag); 18954fdc3d75SEnji Cooper ATF_TP_ADD_TC(tp, reopen_object); 18964fdc3d75SEnji Cooper ATF_TP_ADD_TC(tp, readonly_mmap_write); 18974fdc3d75SEnji Cooper ATF_TP_ADD_TC(tp, open_after_link); 18984fdc3d75SEnji Cooper ATF_TP_ADD_TC(tp, open_invalid_path); 18994fdc3d75SEnji Cooper ATF_TP_ADD_TC(tp, open_write_only); 19004fdc3d75SEnji Cooper ATF_TP_ADD_TC(tp, open_extra_flags); 19014fdc3d75SEnji Cooper ATF_TP_ADD_TC(tp, open_anon); 19024fdc3d75SEnji Cooper ATF_TP_ADD_TC(tp, open_anon_readonly); 19034fdc3d75SEnji Cooper ATF_TP_ADD_TC(tp, open_bad_path_pointer); 19044fdc3d75SEnji Cooper ATF_TP_ADD_TC(tp, open_path_too_long); 19054fdc3d75SEnji Cooper ATF_TP_ADD_TC(tp, open_nonexisting_object); 19064fdc3d75SEnji Cooper ATF_TP_ADD_TC(tp, open_create_existing_object); 19074fdc3d75SEnji Cooper ATF_TP_ADD_TC(tp, shm_functionality_across_fork); 19084fdc3d75SEnji Cooper ATF_TP_ADD_TC(tp, trunc_resets_object); 19094fdc3d75SEnji Cooper ATF_TP_ADD_TC(tp, unlink_bad_path_pointer); 19104fdc3d75SEnji Cooper ATF_TP_ADD_TC(tp, unlink_path_too_long); 19114fdc3d75SEnji Cooper ATF_TP_ADD_TC(tp, object_resize); 191295aa96f3SKyle Evans ATF_TP_ADD_TC(tp, cloexec); 19135a391b57SKyle Evans ATF_TP_ADD_TC(tp, mode); 1914f1040532SKyle Evans ATF_TP_ADD_TC(tp, fallocate); 1915454bc887SKa Ho Ng ATF_TP_ADD_TC(tp, fspacectl); 191677ceadeeSMark Johnston ATF_TP_ADD_TC(tp, largepage_basic); 191777ceadeeSMark Johnston ATF_TP_ADD_TC(tp, largepage_config); 191877ceadeeSMark Johnston ATF_TP_ADD_TC(tp, largepage_mmap); 191977ceadeeSMark Johnston ATF_TP_ADD_TC(tp, largepage_munmap); 192077ceadeeSMark Johnston ATF_TP_ADD_TC(tp, largepage_madvise); 192177ceadeeSMark Johnston ATF_TP_ADD_TC(tp, largepage_mlock); 192277ceadeeSMark Johnston ATF_TP_ADD_TC(tp, largepage_msync); 192377ceadeeSMark Johnston ATF_TP_ADD_TC(tp, largepage_mprotect); 192477ceadeeSMark Johnston ATF_TP_ADD_TC(tp, largepage_minherit); 192577ceadeeSMark Johnston ATF_TP_ADD_TC(tp, largepage_pipe); 192677ceadeeSMark Johnston ATF_TP_ADD_TC(tp, largepage_reopen); 19274fdc3d75SEnji Cooper 19284fdc3d75SEnji Cooper return (atf_no_error()); 19294fdc3d75SEnji Cooper } 1930