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; 188d3aabde9SAndrew Turner size_t blen, page_size; 189454bc887SKa Ho Ng char *buf; 190d3aabde9SAndrew Turner 191454bc887SKa Ho Ng error = 0; 192d3aabde9SAndrew Turner page_size = getpagesize(); 193d3aabde9SAndrew Turner buf = malloc(page_size); 194454bc887SKa Ho Ng if (buf == NULL) 195454bc887SKa Ho Ng return (1); 196454bc887SKa Ho Ng 197454bc887SKa Ho Ng while (len > 0) { 1988dd8d56dSJohn Baldwin blen = len < (off_t)page_size ? (size_t)len : page_size; 199454bc887SKa Ho Ng memset(buf, byte_to_fill, blen); 200454bc887SKa Ho Ng if (pwrite(fd, buf, blen, offset) != (ssize_t)blen) { 201454bc887SKa Ho Ng error = 1; 202454bc887SKa Ho Ng break; 203454bc887SKa Ho Ng } 204454bc887SKa Ho Ng len -= blen; 205454bc887SKa Ho Ng offset += blen; 206454bc887SKa Ho Ng } 207454bc887SKa Ho Ng 208454bc887SKa Ho Ng free(buf); 209454bc887SKa Ho Ng return (error); 210454bc887SKa Ho Ng } 211454bc887SKa Ho Ng 212454bc887SKa Ho Ng static int 213454bc887SKa Ho Ng check_content_dealloc(int fd, off_t hole_start, off_t hole_len, off_t shm_sz) 214454bc887SKa Ho Ng { 215454bc887SKa Ho Ng int error; 216d3aabde9SAndrew Turner size_t blen, page_size; 217454bc887SKa Ho Ng off_t offset, resid; 218454bc887SKa Ho Ng struct stat statbuf; 219454bc887SKa Ho Ng char *buf, *sblk; 220454bc887SKa Ho Ng 221454bc887SKa Ho Ng error = 0; 222d3aabde9SAndrew Turner page_size = getpagesize(); 223d3aabde9SAndrew Turner buf = malloc(page_size * 2); 224454bc887SKa Ho Ng if (buf == NULL) 225454bc887SKa Ho Ng return (1); 226d3aabde9SAndrew Turner sblk = buf + page_size; 227454bc887SKa Ho Ng 228d3aabde9SAndrew Turner memset(sblk, 0, page_size); 229454bc887SKa Ho Ng 230454bc887SKa Ho Ng if ((uint64_t)hole_start + hole_len > (uint64_t)shm_sz) 231454bc887SKa Ho Ng hole_len = shm_sz - hole_start; 232454bc887SKa Ho Ng 233454bc887SKa Ho Ng /* 234454bc887SKa Ho Ng * Check hole is zeroed. 235454bc887SKa Ho Ng */ 236454bc887SKa Ho Ng offset = hole_start; 237454bc887SKa Ho Ng resid = hole_len; 238454bc887SKa Ho Ng while (resid > 0) { 2398dd8d56dSJohn Baldwin blen = resid < (off_t)page_size ? (size_t)resid : page_size; 240454bc887SKa Ho Ng if (pread(fd, buf, blen, offset) != (ssize_t)blen) { 241454bc887SKa Ho Ng error = 1; 242454bc887SKa Ho Ng break; 243454bc887SKa Ho Ng } 244454bc887SKa Ho Ng if (memcmp(buf, sblk, blen) != 0) { 245454bc887SKa Ho Ng error = 1; 246454bc887SKa Ho Ng break; 247454bc887SKa Ho Ng } 248454bc887SKa Ho Ng resid -= blen; 249454bc887SKa Ho Ng offset += blen; 250454bc887SKa Ho Ng } 251454bc887SKa Ho Ng 252d3aabde9SAndrew Turner memset(sblk, byte_to_fill, page_size); 253454bc887SKa Ho Ng 254454bc887SKa Ho Ng /* 255454bc887SKa Ho Ng * Check file region before hole is zeroed. 256454bc887SKa Ho Ng */ 257454bc887SKa Ho Ng offset = 0; 258454bc887SKa Ho Ng resid = hole_start; 259454bc887SKa Ho Ng while (resid > 0) { 2608dd8d56dSJohn Baldwin blen = resid < (off_t)page_size ? (size_t)resid : page_size; 261454bc887SKa Ho Ng if (pread(fd, buf, blen, offset) != (ssize_t)blen) { 262454bc887SKa Ho Ng error = 1; 263454bc887SKa Ho Ng break; 264454bc887SKa Ho Ng } 265454bc887SKa Ho Ng if (memcmp(buf, sblk, blen) != 0) { 266454bc887SKa Ho Ng error = 1; 267454bc887SKa Ho Ng break; 268454bc887SKa Ho Ng } 269454bc887SKa Ho Ng resid -= blen; 270454bc887SKa Ho Ng offset += blen; 271454bc887SKa Ho Ng } 272454bc887SKa Ho Ng 273454bc887SKa Ho Ng /* 274454bc887SKa Ho Ng * Check file region after hole is zeroed. 275454bc887SKa Ho Ng */ 276454bc887SKa Ho Ng offset = hole_start + hole_len; 277454bc887SKa Ho Ng resid = shm_sz - offset; 278454bc887SKa Ho Ng while (resid > 0) { 2798dd8d56dSJohn Baldwin blen = resid < (off_t)page_size ? (size_t)resid : page_size; 280454bc887SKa Ho Ng if (pread(fd, buf, blen, offset) != (ssize_t)blen) { 281454bc887SKa Ho Ng error = 1; 282454bc887SKa Ho Ng break; 283454bc887SKa Ho Ng } 284454bc887SKa Ho Ng if (memcmp(buf, sblk, blen) != 0) { 285454bc887SKa Ho Ng error = 1; 286454bc887SKa Ho Ng break; 287454bc887SKa Ho Ng } 288454bc887SKa Ho Ng resid -= blen; 289454bc887SKa Ho Ng offset += blen; 290454bc887SKa Ho Ng } 291454bc887SKa Ho Ng 292454bc887SKa Ho Ng /* 293454bc887SKa Ho Ng * Check file size matches with expected file size. 294454bc887SKa Ho Ng */ 295454bc887SKa Ho Ng if (fstat(fd, &statbuf) == -1) 296454bc887SKa Ho Ng error = -1; 297454bc887SKa Ho Ng if (statbuf.st_size != shm_sz) 298454bc887SKa Ho Ng error = -1; 299454bc887SKa Ho Ng 300454bc887SKa Ho Ng free(buf); 301454bc887SKa Ho Ng return (error); 302454bc887SKa Ho Ng } 303454bc887SKa Ho Ng 3044fdc3d75SEnji Cooper ATF_TC_WITHOUT_HEAD(remap_object); 3054fdc3d75SEnji Cooper ATF_TC_BODY(remap_object, tc) 3064fdc3d75SEnji Cooper { 3074fdc3d75SEnji Cooper char *page; 30894ebd6f5SEnji Cooper int fd, pagesize; 30994ebd6f5SEnji Cooper 31094ebd6f5SEnji Cooper ATF_REQUIRE(0 < (pagesize = getpagesize())); 3114fdc3d75SEnji Cooper 3129afb12baSDavid Bright gen_test_path(); 3139afb12baSDavid Bright fd = scribble_object(test_path, '1'); 3144fdc3d75SEnji Cooper 31594ebd6f5SEnji Cooper page = mmap(0, pagesize, PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0); 3164fdc3d75SEnji Cooper if (page == MAP_FAILED) 3174fdc3d75SEnji Cooper atf_tc_fail("mmap(2) failed; errno=%d", errno); 3184fdc3d75SEnji Cooper 3194fdc3d75SEnji Cooper if (page[0] != '1') 3204fdc3d75SEnji Cooper atf_tc_fail("missing data ('%c' != '1')", page[0]); 3214fdc3d75SEnji Cooper 3224fdc3d75SEnji Cooper close(fd); 32394ebd6f5SEnji Cooper ATF_REQUIRE_MSG(munmap(page, pagesize) == 0, "munmap failed; errno=%d", 32494ebd6f5SEnji Cooper errno); 3254fdc3d75SEnji Cooper 3264fdc3d75SEnji Cooper ATF_REQUIRE_MSG(shm_unlink(test_path) != -1, 3274fdc3d75SEnji Cooper "shm_unlink failed; errno=%d", errno); 3284fdc3d75SEnji Cooper } 3294fdc3d75SEnji Cooper 3309afb12baSDavid Bright ATF_TC_WITHOUT_HEAD(rename_from_anon); 3319afb12baSDavid Bright ATF_TC_BODY(rename_from_anon, tc) 3329afb12baSDavid Bright { 3339afb12baSDavid Bright int rc; 3349afb12baSDavid Bright 3359afb12baSDavid Bright gen_test_path(); 3369afb12baSDavid Bright rc = shm_rename(SHM_ANON, test_path, 0); 3379afb12baSDavid Bright if (rc != -1) 3389afb12baSDavid Bright atf_tc_fail("shm_rename from SHM_ANON succeeded unexpectedly"); 3399afb12baSDavid Bright } 3409afb12baSDavid Bright 3419afb12baSDavid Bright ATF_TC_WITHOUT_HEAD(rename_bad_path_pointer); 3429afb12baSDavid Bright ATF_TC_BODY(rename_bad_path_pointer, tc) 3439afb12baSDavid Bright { 3449afb12baSDavid Bright const char *bad_path; 3459afb12baSDavid Bright int rc; 3469afb12baSDavid Bright 3479afb12baSDavid Bright bad_path = (const char *)0x1; 3489afb12baSDavid Bright 3499afb12baSDavid Bright gen_test_path(); 3509afb12baSDavid Bright rc = shm_rename(test_path, bad_path, 0); 3519afb12baSDavid Bright if (rc != -1) 3529afb12baSDavid Bright atf_tc_fail("shm_rename of nonexisting shm succeeded unexpectedly"); 3539afb12baSDavid Bright 3549afb12baSDavid Bright rc = shm_rename(bad_path, test_path, 0); 3559afb12baSDavid Bright if (rc != -1) 3569afb12baSDavid Bright atf_tc_fail("shm_rename of nonexisting shm succeeded unexpectedly"); 3579afb12baSDavid Bright } 3589afb12baSDavid Bright 3599afb12baSDavid Bright ATF_TC_WITHOUT_HEAD(rename_from_nonexisting); 3609afb12baSDavid Bright ATF_TC_BODY(rename_from_nonexisting, tc) 3619afb12baSDavid Bright { 3629afb12baSDavid Bright int rc; 3639afb12baSDavid Bright 3649afb12baSDavid Bright gen_test_path(); 3652d5603feSDavid Bright gen_test_path2(); 3669afb12baSDavid Bright rc = shm_rename(test_path, test_path2, 0); 3679afb12baSDavid Bright if (rc != -1) 3689afb12baSDavid Bright atf_tc_fail("shm_rename of nonexisting shm succeeded unexpectedly"); 3699afb12baSDavid Bright 3709afb12baSDavid Bright if (errno != ENOENT) 3712d5603feSDavid Bright atf_tc_fail("Expected ENOENT to rename of nonexistent shm; got %d", 3722d5603feSDavid Bright errno); 3739afb12baSDavid Bright } 3749afb12baSDavid Bright 3759afb12baSDavid Bright ATF_TC_WITHOUT_HEAD(rename_to_anon); 3769afb12baSDavid Bright ATF_TC_BODY(rename_to_anon, tc) 3779afb12baSDavid Bright { 3789afb12baSDavid Bright int rc; 3799afb12baSDavid Bright 3809afb12baSDavid Bright gen_test_path(); 3819afb12baSDavid Bright rc = shm_rename(test_path, SHM_ANON, 0); 3829afb12baSDavid Bright if (rc != -1) 3839afb12baSDavid Bright atf_tc_fail("shm_rename to SHM_ANON succeeded unexpectedly"); 3849afb12baSDavid Bright } 3859afb12baSDavid Bright 3869afb12baSDavid Bright ATF_TC_WITHOUT_HEAD(rename_to_replace); 3879afb12baSDavid Bright ATF_TC_BODY(rename_to_replace, tc) 3889afb12baSDavid Bright { 3899afb12baSDavid Bright char expected_value; 3909afb12baSDavid Bright int fd; 3919afb12baSDavid Bright int fd2; 3929afb12baSDavid Bright 3939afb12baSDavid Bright // Some contents we can verify later 3949afb12baSDavid Bright expected_value = 'g'; 3959afb12baSDavid Bright 3969afb12baSDavid Bright gen_test_path(); 3979afb12baSDavid Bright fd = scribble_object(test_path, expected_value); 3989afb12baSDavid Bright close(fd); 3999afb12baSDavid Bright 4009afb12baSDavid Bright // Give the other some different value so we can detect success 4019afb12baSDavid Bright gen_test_path2(); 4029afb12baSDavid Bright fd2 = scribble_object(test_path2, 'h'); 4039afb12baSDavid Bright close(fd2); 4049afb12baSDavid Bright 4059afb12baSDavid Bright ATF_REQUIRE_MSG(shm_rename(test_path, test_path2, 0) == 0, 4069afb12baSDavid Bright "shm_rename failed; errno=%d", errno); 4079afb12baSDavid Bright 4089afb12baSDavid Bright // Read back renamed; verify contents 4099afb12baSDavid Bright verify_object(test_path2, expected_value); 4109afb12baSDavid Bright } 4119afb12baSDavid Bright 4129afb12baSDavid Bright ATF_TC_WITHOUT_HEAD(rename_to_noreplace); 4139afb12baSDavid Bright ATF_TC_BODY(rename_to_noreplace, tc) 4149afb12baSDavid Bright { 4159afb12baSDavid Bright char expected_value_from; 4169afb12baSDavid Bright char expected_value_to; 4179afb12baSDavid Bright int fd_from; 4189afb12baSDavid Bright int fd_to; 4199afb12baSDavid Bright int rc; 4209afb12baSDavid Bright 4219afb12baSDavid Bright // Some contents we can verify later 4229afb12baSDavid Bright expected_value_from = 'g'; 4239afb12baSDavid Bright gen_test_path(); 4249afb12baSDavid Bright fd_from = scribble_object(test_path, expected_value_from); 4259afb12baSDavid Bright close(fd_from); 4269afb12baSDavid Bright 4279afb12baSDavid Bright // Give the other some different value so we can detect success 4289afb12baSDavid Bright expected_value_to = 'h'; 4299afb12baSDavid Bright gen_test_path2(); 4309afb12baSDavid Bright fd_to = scribble_object(test_path2, expected_value_to); 4319afb12baSDavid Bright close(fd_to); 4329afb12baSDavid Bright 4339afb12baSDavid Bright rc = shm_rename(test_path, test_path2, SHM_RENAME_NOREPLACE); 4349afb12baSDavid Bright ATF_REQUIRE_MSG((rc == -1) && (errno == EEXIST), 4359afb12baSDavid Bright "shm_rename didn't fail as expected; errno: %d; return: %d", errno, 4369afb12baSDavid Bright rc); 4379afb12baSDavid Bright 4389afb12baSDavid Bright // Read back renamed; verify contents 4399afb12baSDavid Bright verify_object(test_path2, expected_value_to); 4409afb12baSDavid Bright } 4419afb12baSDavid Bright 4429afb12baSDavid Bright ATF_TC_WITHOUT_HEAD(rename_to_exchange); 4439afb12baSDavid Bright ATF_TC_BODY(rename_to_exchange, tc) 4449afb12baSDavid Bright { 4459afb12baSDavid Bright char expected_value_from; 4469afb12baSDavid Bright char expected_value_to; 4479afb12baSDavid Bright int fd_from; 4489afb12baSDavid Bright int fd_to; 4499afb12baSDavid Bright 4509afb12baSDavid Bright // Some contents we can verify later 4519afb12baSDavid Bright expected_value_from = 'g'; 4529afb12baSDavid Bright gen_test_path(); 4539afb12baSDavid Bright fd_from = scribble_object(test_path, expected_value_from); 4549afb12baSDavid Bright close(fd_from); 4559afb12baSDavid Bright 4569afb12baSDavid Bright // Give the other some different value so we can detect success 4579afb12baSDavid Bright expected_value_to = 'h'; 4589afb12baSDavid Bright gen_test_path2(); 4599afb12baSDavid Bright fd_to = scribble_object(test_path2, expected_value_to); 4609afb12baSDavid Bright close(fd_to); 4619afb12baSDavid Bright 4629afb12baSDavid Bright ATF_REQUIRE_MSG(shm_rename(test_path, test_path2, 4639afb12baSDavid Bright SHM_RENAME_EXCHANGE) == 0, 4649afb12baSDavid Bright "shm_rename failed; errno=%d", errno); 4659afb12baSDavid Bright 4669afb12baSDavid Bright // Read back renamed; verify contents 4679afb12baSDavid Bright verify_object(test_path, expected_value_to); 4689afb12baSDavid Bright verify_object(test_path2, expected_value_from); 4699afb12baSDavid Bright } 4709afb12baSDavid Bright 4719afb12baSDavid Bright ATF_TC_WITHOUT_HEAD(rename_to_exchange_nonexisting); 4729afb12baSDavid Bright ATF_TC_BODY(rename_to_exchange_nonexisting, tc) 4739afb12baSDavid Bright { 4749afb12baSDavid Bright char expected_value_from; 4759afb12baSDavid Bright int fd_from; 4769afb12baSDavid Bright 4779afb12baSDavid Bright // Some contents we can verify later 4789afb12baSDavid Bright expected_value_from = 'g'; 4799afb12baSDavid Bright gen_test_path(); 4809afb12baSDavid Bright fd_from = scribble_object(test_path, expected_value_from); 4819afb12baSDavid Bright close(fd_from); 4829afb12baSDavid Bright 4839afb12baSDavid Bright gen_test_path2(); 4849afb12baSDavid Bright 4859afb12baSDavid Bright ATF_REQUIRE_MSG(shm_rename(test_path, test_path2, 4869afb12baSDavid Bright SHM_RENAME_EXCHANGE) == 0, 4879afb12baSDavid Bright "shm_rename failed; errno=%d", errno); 4889afb12baSDavid Bright 4899afb12baSDavid Bright // Read back renamed; verify contents 4909afb12baSDavid Bright verify_object(test_path2, expected_value_from); 4919afb12baSDavid Bright } 4929afb12baSDavid Bright 4939afb12baSDavid Bright ATF_TC_WITHOUT_HEAD(rename_to_self); 4949afb12baSDavid Bright ATF_TC_BODY(rename_to_self, tc) 4959afb12baSDavid Bright { 4969afb12baSDavid Bright int fd; 4979afb12baSDavid Bright char expected_value; 4989afb12baSDavid Bright 4999afb12baSDavid Bright expected_value = 't'; 5009afb12baSDavid Bright 5019afb12baSDavid Bright gen_test_path(); 5029afb12baSDavid Bright fd = scribble_object(test_path, expected_value); 5039afb12baSDavid Bright close(fd); 5049afb12baSDavid Bright 5059afb12baSDavid Bright ATF_REQUIRE_MSG(shm_rename(test_path, test_path, 0) == 0, 5069afb12baSDavid Bright "shm_rename failed; errno=%d", errno); 5079afb12baSDavid Bright 5089afb12baSDavid Bright verify_object(test_path, expected_value); 5099afb12baSDavid Bright } 5109afb12baSDavid Bright 5119afb12baSDavid Bright ATF_TC_WITHOUT_HEAD(rename_bad_flag); 5129afb12baSDavid Bright ATF_TC_BODY(rename_bad_flag, tc) 5139afb12baSDavid Bright { 5149afb12baSDavid Bright int fd; 5159afb12baSDavid Bright int rc; 5169afb12baSDavid Bright 5179afb12baSDavid Bright /* Make sure we don't fail out due to ENOENT */ 5189afb12baSDavid Bright gen_test_path(); 5199afb12baSDavid Bright gen_test_path2(); 5209afb12baSDavid Bright fd = scribble_object(test_path, 'd'); 5219afb12baSDavid Bright close(fd); 5229afb12baSDavid Bright fd = scribble_object(test_path2, 'd'); 5239afb12baSDavid Bright close(fd); 5249afb12baSDavid Bright 5259afb12baSDavid Bright /* 5269afb12baSDavid Bright * Note: if we end up with enough flags that we use all the bits, 5279afb12baSDavid Bright * then remove this test completely. 5289afb12baSDavid Bright */ 5299afb12baSDavid Bright rc = shm_rename(test_path, test_path2, INT_MIN); 5309afb12baSDavid Bright ATF_REQUIRE_MSG((rc == -1) && (errno == EINVAL), 5319afb12baSDavid Bright "shm_rename should have failed with EINVAL; got: return=%d, " 5329afb12baSDavid Bright "errno=%d", rc, errno); 5339afb12baSDavid Bright } 5349afb12baSDavid Bright 5354fdc3d75SEnji Cooper ATF_TC_WITHOUT_HEAD(reopen_object); 5364fdc3d75SEnji Cooper ATF_TC_BODY(reopen_object, tc) 5374fdc3d75SEnji Cooper { 5384fdc3d75SEnji Cooper char *page; 53994ebd6f5SEnji Cooper int fd, pagesize; 54094ebd6f5SEnji Cooper 54194ebd6f5SEnji Cooper ATF_REQUIRE(0 < (pagesize = getpagesize())); 5424fdc3d75SEnji Cooper 5439afb12baSDavid Bright gen_test_path(); 5449afb12baSDavid Bright fd = scribble_object(test_path, '1'); 5454fdc3d75SEnji Cooper close(fd); 5464fdc3d75SEnji Cooper 5474fdc3d75SEnji Cooper fd = shm_open(test_path, O_RDONLY, 0777); 5484fdc3d75SEnji Cooper if (fd < 0) 5494fdc3d75SEnji Cooper atf_tc_fail("shm_open(2) failed; errno=%d", errno); 5504fdc3d75SEnji Cooper 55194ebd6f5SEnji Cooper page = mmap(0, pagesize, PROT_READ, MAP_SHARED, fd, 0); 5524fdc3d75SEnji Cooper if (page == MAP_FAILED) 5534fdc3d75SEnji Cooper atf_tc_fail("mmap(2) failed; errno=%d", errno); 5544fdc3d75SEnji Cooper 5554fdc3d75SEnji Cooper if (page[0] != '1') 5564fdc3d75SEnji Cooper atf_tc_fail("missing data ('%c' != '1')", page[0]); 5574fdc3d75SEnji Cooper 55894ebd6f5SEnji Cooper ATF_REQUIRE_MSG(munmap(page, pagesize) == 0, "munmap failed; errno=%d", 55994ebd6f5SEnji Cooper errno); 5604fdc3d75SEnji Cooper close(fd); 5614fdc3d75SEnji Cooper ATF_REQUIRE_MSG(shm_unlink(test_path) != -1, 5624fdc3d75SEnji Cooper "shm_unlink failed; errno=%d", errno); 5634fdc3d75SEnji Cooper } 5644fdc3d75SEnji Cooper 5654fdc3d75SEnji Cooper ATF_TC_WITHOUT_HEAD(readonly_mmap_write); 5664fdc3d75SEnji Cooper ATF_TC_BODY(readonly_mmap_write, tc) 5674fdc3d75SEnji Cooper { 5684fdc3d75SEnji Cooper char *page; 56994ebd6f5SEnji Cooper int fd, pagesize; 57094ebd6f5SEnji Cooper 57194ebd6f5SEnji Cooper ATF_REQUIRE(0 < (pagesize = getpagesize())); 5724fdc3d75SEnji Cooper 5734fdc3d75SEnji Cooper gen_test_path(); 5744fdc3d75SEnji Cooper 5754fdc3d75SEnji Cooper fd = shm_open(test_path, O_RDONLY | O_CREAT, 0777); 5764fdc3d75SEnji Cooper ATF_REQUIRE_MSG(fd >= 0, "shm_open failed; errno=%d", errno); 5774fdc3d75SEnji Cooper 5784fdc3d75SEnji Cooper /* PROT_WRITE should fail with EACCES. */ 57994ebd6f5SEnji Cooper page = mmap(0, pagesize, PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0); 5804fdc3d75SEnji Cooper if (page != MAP_FAILED) 5814fdc3d75SEnji Cooper atf_tc_fail("mmap(PROT_WRITE) succeeded unexpectedly"); 5824fdc3d75SEnji Cooper 5834fdc3d75SEnji Cooper if (errno != EACCES) 5844fdc3d75SEnji Cooper atf_tc_fail("mmap(PROT_WRITE) didn't fail with EACCES; " 5854fdc3d75SEnji Cooper "errno=%d", errno); 5864fdc3d75SEnji Cooper 5874fdc3d75SEnji Cooper close(fd); 5884fdc3d75SEnji Cooper ATF_REQUIRE_MSG(shm_unlink(test_path) != -1, 5894fdc3d75SEnji Cooper "shm_unlink failed; errno=%d", errno); 5904fdc3d75SEnji Cooper } 5914fdc3d75SEnji Cooper 5924fdc3d75SEnji Cooper ATF_TC_WITHOUT_HEAD(open_after_link); 5934fdc3d75SEnji Cooper ATF_TC_BODY(open_after_link, tc) 5944fdc3d75SEnji Cooper { 5954fdc3d75SEnji Cooper int fd; 5964fdc3d75SEnji Cooper 5974fdc3d75SEnji Cooper gen_test_path(); 5984fdc3d75SEnji Cooper 5994fdc3d75SEnji Cooper fd = shm_open(test_path, O_RDONLY | O_CREAT, 0777); 6004fdc3d75SEnji Cooper ATF_REQUIRE_MSG(fd >= 0, "shm_open(1) failed; errno=%d", errno); 6014fdc3d75SEnji Cooper close(fd); 6024fdc3d75SEnji Cooper 6034fdc3d75SEnji Cooper ATF_REQUIRE_MSG(shm_unlink(test_path) != -1, "shm_unlink failed: %d", 6044fdc3d75SEnji Cooper errno); 6054fdc3d75SEnji Cooper 6064fdc3d75SEnji Cooper shm_open_should_fail(test_path, O_RDONLY, 0777, ENOENT); 6074fdc3d75SEnji Cooper } 6084fdc3d75SEnji Cooper 6094fdc3d75SEnji Cooper ATF_TC_WITHOUT_HEAD(open_invalid_path); 6104fdc3d75SEnji Cooper ATF_TC_BODY(open_invalid_path, tc) 6114fdc3d75SEnji Cooper { 6124fdc3d75SEnji Cooper 6134fdc3d75SEnji Cooper shm_open_should_fail("blah", O_RDONLY, 0777, EINVAL); 6144fdc3d75SEnji Cooper } 6154fdc3d75SEnji Cooper 6164fdc3d75SEnji Cooper ATF_TC_WITHOUT_HEAD(open_write_only); 6174fdc3d75SEnji Cooper ATF_TC_BODY(open_write_only, tc) 6184fdc3d75SEnji Cooper { 6194fdc3d75SEnji Cooper 6204fdc3d75SEnji Cooper gen_test_path(); 6214fdc3d75SEnji Cooper 6224fdc3d75SEnji Cooper shm_open_should_fail(test_path, O_WRONLY, 0777, EINVAL); 6234fdc3d75SEnji Cooper } 6244fdc3d75SEnji Cooper 6254fdc3d75SEnji Cooper ATF_TC_WITHOUT_HEAD(open_extra_flags); 6264fdc3d75SEnji Cooper ATF_TC_BODY(open_extra_flags, tc) 6274fdc3d75SEnji Cooper { 6284fdc3d75SEnji Cooper 6294fdc3d75SEnji Cooper gen_test_path(); 6304fdc3d75SEnji Cooper 6314fdc3d75SEnji Cooper shm_open_should_fail(test_path, O_RDONLY | O_DIRECT, 0777, EINVAL); 6324fdc3d75SEnji Cooper } 6334fdc3d75SEnji Cooper 6344fdc3d75SEnji Cooper ATF_TC_WITHOUT_HEAD(open_anon); 6354fdc3d75SEnji Cooper ATF_TC_BODY(open_anon, tc) 6364fdc3d75SEnji Cooper { 6374fdc3d75SEnji Cooper int fd; 6384fdc3d75SEnji Cooper 6394fdc3d75SEnji Cooper fd = shm_open(SHM_ANON, O_RDWR, 0777); 6404fdc3d75SEnji Cooper ATF_REQUIRE_MSG(fd >= 0, "shm_open failed; errno=%d", errno); 6414fdc3d75SEnji Cooper close(fd); 6424fdc3d75SEnji Cooper } 6434fdc3d75SEnji Cooper 6444fdc3d75SEnji Cooper ATF_TC_WITHOUT_HEAD(open_anon_readonly); 6454fdc3d75SEnji Cooper ATF_TC_BODY(open_anon_readonly, tc) 6464fdc3d75SEnji Cooper { 6474fdc3d75SEnji Cooper 6484fdc3d75SEnji Cooper shm_open_should_fail(SHM_ANON, O_RDONLY, 0777, EINVAL); 6494fdc3d75SEnji Cooper } 6504fdc3d75SEnji Cooper 6514fdc3d75SEnji Cooper ATF_TC_WITHOUT_HEAD(open_bad_path_pointer); 6524fdc3d75SEnji Cooper ATF_TC_BODY(open_bad_path_pointer, tc) 6534fdc3d75SEnji Cooper { 6544fdc3d75SEnji Cooper 6554fdc3d75SEnji Cooper shm_open_should_fail((char *)1024, O_RDONLY, 0777, EFAULT); 6564fdc3d75SEnji Cooper } 6574fdc3d75SEnji Cooper 6584fdc3d75SEnji Cooper ATF_TC_WITHOUT_HEAD(open_path_too_long); 6594fdc3d75SEnji Cooper ATF_TC_BODY(open_path_too_long, tc) 6604fdc3d75SEnji Cooper { 6614fdc3d75SEnji Cooper char *page; 6624fdc3d75SEnji Cooper 6634fdc3d75SEnji Cooper page = malloc(MAXPATHLEN + 1); 6644fdc3d75SEnji Cooper memset(page, 'a', MAXPATHLEN); 6654fdc3d75SEnji Cooper page[MAXPATHLEN] = '\0'; 6664fdc3d75SEnji Cooper shm_open_should_fail(page, O_RDONLY, 0777, ENAMETOOLONG); 6674fdc3d75SEnji Cooper free(page); 6684fdc3d75SEnji Cooper } 6694fdc3d75SEnji Cooper 6704fdc3d75SEnji Cooper ATF_TC_WITHOUT_HEAD(open_nonexisting_object); 6714fdc3d75SEnji Cooper ATF_TC_BODY(open_nonexisting_object, tc) 6724fdc3d75SEnji Cooper { 6734fdc3d75SEnji Cooper 6744fdc3d75SEnji Cooper shm_open_should_fail("/notreallythere", O_RDONLY, 0777, ENOENT); 6754fdc3d75SEnji Cooper } 6764fdc3d75SEnji Cooper 6774fdc3d75SEnji Cooper ATF_TC_WITHOUT_HEAD(open_create_existing_object); 6784fdc3d75SEnji Cooper ATF_TC_BODY(open_create_existing_object, tc) 6794fdc3d75SEnji Cooper { 6804fdc3d75SEnji Cooper int fd; 6814fdc3d75SEnji Cooper 6824fdc3d75SEnji Cooper gen_test_path(); 6834fdc3d75SEnji Cooper 6844fdc3d75SEnji Cooper fd = shm_open(test_path, O_RDONLY|O_CREAT, 0777); 6854fdc3d75SEnji Cooper ATF_REQUIRE_MSG(fd >= 0, "shm_open failed; errno=%d", errno); 6864fdc3d75SEnji Cooper close(fd); 6874fdc3d75SEnji Cooper 6884fdc3d75SEnji Cooper shm_open_should_fail(test_path, O_RDONLY|O_CREAT|O_EXCL, 6894fdc3d75SEnji Cooper 0777, EEXIST); 6904fdc3d75SEnji Cooper 6914fdc3d75SEnji Cooper ATF_REQUIRE_MSG(shm_unlink(test_path) != -1, 6924fdc3d75SEnji Cooper "shm_unlink failed; errno=%d", errno); 6934fdc3d75SEnji Cooper } 6944fdc3d75SEnji Cooper 6954fdc3d75SEnji Cooper ATF_TC_WITHOUT_HEAD(trunc_resets_object); 6964fdc3d75SEnji Cooper ATF_TC_BODY(trunc_resets_object, tc) 6974fdc3d75SEnji Cooper { 6984fdc3d75SEnji Cooper struct stat sb; 6994fdc3d75SEnji Cooper int fd; 7004fdc3d75SEnji Cooper 7014fdc3d75SEnji Cooper gen_test_path(); 7024fdc3d75SEnji Cooper 7034fdc3d75SEnji Cooper /* Create object and set size to 1024. */ 7044fdc3d75SEnji Cooper fd = shm_open(test_path, O_RDWR | O_CREAT, 0777); 7054fdc3d75SEnji Cooper ATF_REQUIRE_MSG(fd >= 0, "shm_open(1) failed; errno=%d", errno); 7064fdc3d75SEnji Cooper ATF_REQUIRE_MSG(ftruncate(fd, 1024) != -1, 7074fdc3d75SEnji Cooper "ftruncate failed; errno=%d", errno); 7084fdc3d75SEnji Cooper ATF_REQUIRE_MSG(fstat(fd, &sb) != -1, 7094fdc3d75SEnji Cooper "fstat(1) failed; errno=%d", errno); 7104fdc3d75SEnji Cooper ATF_REQUIRE_MSG(sb.st_size == 1024, "size %d != 1024", (int)sb.st_size); 7114fdc3d75SEnji Cooper close(fd); 7124fdc3d75SEnji Cooper 7134fdc3d75SEnji Cooper /* Open with O_TRUNC which should reset size to 0. */ 7144fdc3d75SEnji Cooper fd = shm_open(test_path, O_RDWR | O_TRUNC, 0777); 7154fdc3d75SEnji Cooper ATF_REQUIRE_MSG(fd >= 0, "shm_open(2) failed; errno=%d", errno); 7164fdc3d75SEnji Cooper ATF_REQUIRE_MSG(fstat(fd, &sb) != -1, 7174fdc3d75SEnji Cooper "fstat(2) failed; errno=%d", errno); 7184fdc3d75SEnji Cooper ATF_REQUIRE_MSG(sb.st_size == 0, 7194fdc3d75SEnji Cooper "size was not 0 after truncation: %d", (int)sb.st_size); 7204fdc3d75SEnji Cooper close(fd); 7214fdc3d75SEnji Cooper ATF_REQUIRE_MSG(shm_unlink(test_path) != -1, 7224fdc3d75SEnji Cooper "shm_unlink failed; errno=%d", errno); 7234fdc3d75SEnji Cooper } 7244fdc3d75SEnji Cooper 7254fdc3d75SEnji Cooper ATF_TC_WITHOUT_HEAD(unlink_bad_path_pointer); 7264fdc3d75SEnji Cooper ATF_TC_BODY(unlink_bad_path_pointer, tc) 7274fdc3d75SEnji Cooper { 7284fdc3d75SEnji Cooper 7294fdc3d75SEnji Cooper shm_unlink_should_fail((char *)1024, EFAULT); 7304fdc3d75SEnji Cooper } 7314fdc3d75SEnji Cooper 7324fdc3d75SEnji Cooper ATF_TC_WITHOUT_HEAD(unlink_path_too_long); 7334fdc3d75SEnji Cooper ATF_TC_BODY(unlink_path_too_long, tc) 7344fdc3d75SEnji Cooper { 7354fdc3d75SEnji Cooper char *page; 7364fdc3d75SEnji Cooper 7374fdc3d75SEnji Cooper page = malloc(MAXPATHLEN + 1); 7384fdc3d75SEnji Cooper memset(page, 'a', MAXPATHLEN); 7394fdc3d75SEnji Cooper page[MAXPATHLEN] = '\0'; 7404fdc3d75SEnji Cooper shm_unlink_should_fail(page, ENAMETOOLONG); 7414fdc3d75SEnji Cooper free(page); 7424fdc3d75SEnji Cooper } 7434fdc3d75SEnji Cooper 7444fdc3d75SEnji Cooper ATF_TC_WITHOUT_HEAD(object_resize); 7454fdc3d75SEnji Cooper ATF_TC_BODY(object_resize, tc) 7464fdc3d75SEnji Cooper { 7474fdc3d75SEnji Cooper pid_t pid; 7484fdc3d75SEnji Cooper struct stat sb; 74994ebd6f5SEnji Cooper char *page; 75094ebd6f5SEnji Cooper int fd, pagesize, status; 75194ebd6f5SEnji Cooper 75294ebd6f5SEnji Cooper ATF_REQUIRE(0 < (pagesize = getpagesize())); 7534fdc3d75SEnji Cooper 7544fdc3d75SEnji Cooper /* Start off with a size of a single page. */ 7554fdc3d75SEnji Cooper fd = shm_open(SHM_ANON, O_CREAT|O_RDWR, 0777); 7564fdc3d75SEnji Cooper if (fd < 0) 7574fdc3d75SEnji Cooper atf_tc_fail("shm_open failed; errno=%d", errno); 7584fdc3d75SEnji Cooper 75994ebd6f5SEnji Cooper if (ftruncate(fd, pagesize) < 0) 7604fdc3d75SEnji Cooper atf_tc_fail("ftruncate(1) failed; errno=%d", errno); 7614fdc3d75SEnji Cooper 7624fdc3d75SEnji Cooper if (fstat(fd, &sb) < 0) 7634fdc3d75SEnji Cooper atf_tc_fail("fstat(1) failed; errno=%d", errno); 7644fdc3d75SEnji Cooper 76594ebd6f5SEnji Cooper if (sb.st_size != pagesize) 7664fdc3d75SEnji Cooper atf_tc_fail("first resize failed (%d != %d)", 76794ebd6f5SEnji Cooper (int)sb.st_size, pagesize); 7684fdc3d75SEnji Cooper 7694fdc3d75SEnji Cooper /* Write a '1' to the first byte. */ 77094ebd6f5SEnji Cooper page = mmap(0, pagesize, PROT_READ|PROT_WRITE, MAP_SHARED, fd, 0); 7714fdc3d75SEnji Cooper if (page == MAP_FAILED) 7724fdc3d75SEnji Cooper atf_tc_fail("mmap(1)"); 7734fdc3d75SEnji Cooper 7744fdc3d75SEnji Cooper page[0] = '1'; 7754fdc3d75SEnji Cooper 77694ebd6f5SEnji Cooper ATF_REQUIRE_MSG(munmap(page, pagesize) == 0, "munmap failed; errno=%d", 77794ebd6f5SEnji Cooper errno); 7784fdc3d75SEnji Cooper 7794fdc3d75SEnji Cooper /* Grow the object to 2 pages. */ 78094ebd6f5SEnji Cooper if (ftruncate(fd, pagesize * 2) < 0) 7814fdc3d75SEnji Cooper atf_tc_fail("ftruncate(2) failed; errno=%d", errno); 7824fdc3d75SEnji Cooper 7834fdc3d75SEnji Cooper if (fstat(fd, &sb) < 0) 7844fdc3d75SEnji Cooper atf_tc_fail("fstat(2) failed; errno=%d", errno); 7854fdc3d75SEnji Cooper 78694ebd6f5SEnji Cooper if (sb.st_size != pagesize * 2) 7874fdc3d75SEnji Cooper atf_tc_fail("second resize failed (%d != %d)", 78894ebd6f5SEnji Cooper (int)sb.st_size, pagesize * 2); 7894fdc3d75SEnji Cooper 7904fdc3d75SEnji Cooper /* Check for '1' at the first byte. */ 79194ebd6f5SEnji Cooper page = mmap(0, pagesize * 2, PROT_READ|PROT_WRITE, MAP_SHARED, fd, 0); 7924fdc3d75SEnji Cooper if (page == MAP_FAILED) 7934fdc3d75SEnji Cooper atf_tc_fail("mmap(2) failed; errno=%d", errno); 7944fdc3d75SEnji Cooper 7954fdc3d75SEnji Cooper if (page[0] != '1') 7964fdc3d75SEnji Cooper atf_tc_fail("'%c' != '1'", page[0]); 7974fdc3d75SEnji Cooper 7984fdc3d75SEnji Cooper /* Write a '2' at the start of the second page. */ 79994ebd6f5SEnji Cooper page[pagesize] = '2'; 8004fdc3d75SEnji Cooper 8014fdc3d75SEnji Cooper /* Shrink the object back to 1 page. */ 80294ebd6f5SEnji Cooper if (ftruncate(fd, pagesize) < 0) 8034fdc3d75SEnji Cooper atf_tc_fail("ftruncate(3) failed; errno=%d", errno); 8044fdc3d75SEnji Cooper 8054fdc3d75SEnji Cooper if (fstat(fd, &sb) < 0) 8064fdc3d75SEnji Cooper atf_tc_fail("fstat(3) failed; errno=%d", errno); 8074fdc3d75SEnji Cooper 80894ebd6f5SEnji Cooper if (sb.st_size != pagesize) 8094fdc3d75SEnji Cooper atf_tc_fail("third resize failed (%d != %d)", 81094ebd6f5SEnji Cooper (int)sb.st_size, pagesize); 8114fdc3d75SEnji Cooper 8124fdc3d75SEnji Cooper /* 8134fdc3d75SEnji Cooper * Fork a child process to make sure the second page is no 8144fdc3d75SEnji Cooper * longer valid. 8154fdc3d75SEnji Cooper */ 8164fdc3d75SEnji Cooper pid = fork(); 8174fdc3d75SEnji Cooper if (pid == -1) 8184fdc3d75SEnji Cooper atf_tc_fail("fork failed; errno=%d", errno); 8194fdc3d75SEnji Cooper 8204fdc3d75SEnji Cooper if (pid == 0) { 8214fdc3d75SEnji Cooper struct rlimit lim; 8224fdc3d75SEnji Cooper char c; 8234fdc3d75SEnji Cooper 8244fdc3d75SEnji Cooper /* Don't generate a core dump. */ 82594ebd6f5SEnji Cooper ATF_REQUIRE(getrlimit(RLIMIT_CORE, &lim) == 0); 8264fdc3d75SEnji Cooper lim.rlim_cur = 0; 82794ebd6f5SEnji Cooper ATF_REQUIRE(setrlimit(RLIMIT_CORE, &lim) == 0); 8284fdc3d75SEnji Cooper 8294fdc3d75SEnji Cooper /* 8304fdc3d75SEnji Cooper * The previous ftruncate(2) shrunk the backing object 8314fdc3d75SEnji Cooper * so that this address is no longer valid, so reading 8324f775512SJilles Tjoelker * from it should trigger a SIGBUS. 8334fdc3d75SEnji Cooper */ 83494ebd6f5SEnji Cooper c = page[pagesize]; 8354fdc3d75SEnji Cooper fprintf(stderr, "child: page 1: '%c'\n", c); 8364fdc3d75SEnji Cooper exit(0); 8374fdc3d75SEnji Cooper } 8384fdc3d75SEnji Cooper 8394fdc3d75SEnji Cooper if (wait(&status) < 0) 8404fdc3d75SEnji Cooper atf_tc_fail("wait failed; errno=%d", errno); 8414fdc3d75SEnji Cooper 8424f775512SJilles Tjoelker if (!WIFSIGNALED(status) || WTERMSIG(status) != SIGBUS) 8434fdc3d75SEnji Cooper atf_tc_fail("child terminated with status %x", status); 8444fdc3d75SEnji Cooper 8454fdc3d75SEnji Cooper /* Grow the object back to 2 pages. */ 84694ebd6f5SEnji Cooper if (ftruncate(fd, pagesize * 2) < 0) 8474fdc3d75SEnji Cooper atf_tc_fail("ftruncate(2) failed; errno=%d", errno); 8484fdc3d75SEnji Cooper 8494fdc3d75SEnji Cooper if (fstat(fd, &sb) < 0) 8504fdc3d75SEnji Cooper atf_tc_fail("fstat(2) failed; errno=%d", errno); 8514fdc3d75SEnji Cooper 85294ebd6f5SEnji Cooper if (sb.st_size != pagesize * 2) 8534fdc3d75SEnji Cooper atf_tc_fail("fourth resize failed (%d != %d)", 85494ebd6f5SEnji Cooper (int)sb.st_size, pagesize); 8554fdc3d75SEnji Cooper 8564fdc3d75SEnji Cooper /* 8574fdc3d75SEnji Cooper * Note that the mapping at 'page' for the second page is 8584fdc3d75SEnji Cooper * still valid, and now that the shm object has been grown 8594fdc3d75SEnji Cooper * back up to 2 pages, there is now memory backing this page 8604fdc3d75SEnji Cooper * so the read will work. However, the data should be zero 8614fdc3d75SEnji Cooper * rather than '2' as the old data was thrown away when the 8624fdc3d75SEnji Cooper * object was shrunk and the new pages when an object are 8634fdc3d75SEnji Cooper * grown are zero-filled. 8644fdc3d75SEnji Cooper */ 86594ebd6f5SEnji Cooper if (page[pagesize] != 0) 8664fdc3d75SEnji Cooper atf_tc_fail("invalid data at %d: %x != 0", 86794ebd6f5SEnji Cooper pagesize, (int)page[pagesize]); 8684fdc3d75SEnji Cooper 8694fdc3d75SEnji Cooper close(fd); 8704fdc3d75SEnji Cooper } 8714fdc3d75SEnji Cooper 8724fdc3d75SEnji Cooper /* Signal handler which does nothing. */ 8734fdc3d75SEnji Cooper static void 8744fdc3d75SEnji Cooper ignoreit(int sig __unused) 8754fdc3d75SEnji Cooper { 8764fdc3d75SEnji Cooper ; 8774fdc3d75SEnji Cooper } 8784fdc3d75SEnji Cooper 8794fdc3d75SEnji Cooper ATF_TC_WITHOUT_HEAD(shm_functionality_across_fork); 8804fdc3d75SEnji Cooper ATF_TC_BODY(shm_functionality_across_fork, tc) 8814fdc3d75SEnji Cooper { 8824fdc3d75SEnji Cooper char *cp, c; 8834fdc3d75SEnji Cooper int error, desc, rv; 8844fdc3d75SEnji Cooper long scval; 8854fdc3d75SEnji Cooper sigset_t ss; 8864fdc3d75SEnji Cooper struct sigaction sa; 8874fdc3d75SEnji Cooper void *region; 8884fdc3d75SEnji Cooper size_t i, psize; 8894fdc3d75SEnji Cooper 8904fdc3d75SEnji Cooper #ifndef _POSIX_SHARED_MEMORY_OBJECTS 8914fdc3d75SEnji Cooper printf("_POSIX_SHARED_MEMORY_OBJECTS is undefined\n"); 8924fdc3d75SEnji Cooper #else 8934fdc3d75SEnji Cooper printf("_POSIX_SHARED_MEMORY_OBJECTS is defined as %ld\n", 8944fdc3d75SEnji Cooper (long)_POSIX_SHARED_MEMORY_OBJECTS - 0); 8954fdc3d75SEnji Cooper if (_POSIX_SHARED_MEMORY_OBJECTS - 0 == -1) 8964fdc3d75SEnji Cooper printf("***Indicates this feature may be unsupported!\n"); 8974fdc3d75SEnji Cooper #endif 8984fdc3d75SEnji Cooper errno = 0; 8994fdc3d75SEnji Cooper scval = sysconf(_SC_SHARED_MEMORY_OBJECTS); 9004fdc3d75SEnji Cooper if (scval == -1 && errno != 0) { 9014fdc3d75SEnji Cooper atf_tc_fail("sysconf(_SC_SHARED_MEMORY_OBJECTS) failed; " 9024fdc3d75SEnji Cooper "errno=%d", errno); 9034fdc3d75SEnji Cooper } else { 9044fdc3d75SEnji Cooper printf("sysconf(_SC_SHARED_MEMORY_OBJECTS) returns %ld\n", 9054fdc3d75SEnji Cooper scval); 9064fdc3d75SEnji Cooper if (scval == -1) 9074fdc3d75SEnji Cooper printf("***Indicates this feature is unsupported!\n"); 9084fdc3d75SEnji Cooper } 9094fdc3d75SEnji Cooper 9104fdc3d75SEnji Cooper errno = 0; 9114fdc3d75SEnji Cooper scval = sysconf(_SC_PAGESIZE); 9124fdc3d75SEnji Cooper if (scval == -1 && errno != 0) { 9134fdc3d75SEnji Cooper atf_tc_fail("sysconf(_SC_PAGESIZE) failed; errno=%d", errno); 91494ebd6f5SEnji Cooper } else if (scval <= 0) { 9154fdc3d75SEnji Cooper fprintf(stderr, "bogus return from sysconf(_SC_PAGESIZE): %ld", 9164fdc3d75SEnji Cooper scval); 9174fdc3d75SEnji Cooper psize = 4096; 9184fdc3d75SEnji Cooper } else { 9194fdc3d75SEnji Cooper printf("sysconf(_SC_PAGESIZE) returns %ld\n", scval); 9204fdc3d75SEnji Cooper psize = scval; 9214fdc3d75SEnji Cooper } 9224fdc3d75SEnji Cooper 9234fdc3d75SEnji Cooper gen_test_path(); 9244fdc3d75SEnji Cooper desc = shm_open(test_path, O_EXCL | O_CREAT | O_RDWR, 0600); 9254fdc3d75SEnji Cooper 9264fdc3d75SEnji Cooper ATF_REQUIRE_MSG(desc >= 0, "shm_open failed; errno=%d", errno); 9274fdc3d75SEnji Cooper ATF_REQUIRE_MSG(shm_unlink(test_path) == 0, 9284fdc3d75SEnji Cooper "shm_unlink failed; errno=%d", errno); 9294fdc3d75SEnji Cooper ATF_REQUIRE_MSG(ftruncate(desc, (off_t)psize) != -1, 9304fdc3d75SEnji Cooper "ftruncate failed; errno=%d", errno); 9314fdc3d75SEnji Cooper 93294ebd6f5SEnji Cooper region = mmap(NULL, psize, PROT_READ | PROT_WRITE, MAP_SHARED, desc, 0); 9334fdc3d75SEnji Cooper ATF_REQUIRE_MSG(region != MAP_FAILED, "mmap failed; errno=%d", errno); 9344fdc3d75SEnji Cooper memset(region, '\377', psize); 9354fdc3d75SEnji Cooper 9364fdc3d75SEnji Cooper sa.sa_flags = 0; 9374fdc3d75SEnji Cooper sa.sa_handler = ignoreit; 9384fdc3d75SEnji Cooper sigemptyset(&sa.sa_mask); 9394fdc3d75SEnji Cooper ATF_REQUIRE_MSG(sigaction(SIGUSR1, &sa, (struct sigaction *)0) == 0, 9404fdc3d75SEnji Cooper "sigaction failed; errno=%d", errno); 9414fdc3d75SEnji Cooper 9424fdc3d75SEnji Cooper sigemptyset(&ss); 9434fdc3d75SEnji Cooper sigaddset(&ss, SIGUSR1); 9444fdc3d75SEnji Cooper ATF_REQUIRE_MSG(sigprocmask(SIG_BLOCK, &ss, (sigset_t *)0) == 0, 9454fdc3d75SEnji Cooper "sigprocmask failed; errno=%d", errno); 9464fdc3d75SEnji Cooper 9474fdc3d75SEnji Cooper rv = fork(); 9484fdc3d75SEnji Cooper ATF_REQUIRE_MSG(rv != -1, "fork failed; errno=%d", errno); 9494fdc3d75SEnji Cooper if (rv == 0) { 9504fdc3d75SEnji Cooper sigemptyset(&ss); 9514fdc3d75SEnji Cooper sigsuspend(&ss); 9524fdc3d75SEnji Cooper 9534fdc3d75SEnji Cooper for (cp = region; cp < (char *)region + psize; cp++) { 9544fdc3d75SEnji Cooper if (*cp != '\151') 9554fdc3d75SEnji Cooper _exit(1); 9564fdc3d75SEnji Cooper } 9574fdc3d75SEnji Cooper if (lseek(desc, 0, SEEK_SET) == -1) 9584fdc3d75SEnji Cooper _exit(1); 9594fdc3d75SEnji Cooper for (i = 0; i < psize; i++) { 9604fdc3d75SEnji Cooper error = read(desc, &c, 1); 9614fdc3d75SEnji Cooper if (c != '\151') 9624fdc3d75SEnji Cooper _exit(1); 9634fdc3d75SEnji Cooper } 9644fdc3d75SEnji Cooper _exit(0); 9654fdc3d75SEnji Cooper } else { 9664fdc3d75SEnji Cooper int status; 9674fdc3d75SEnji Cooper 9684fdc3d75SEnji Cooper memset(region, '\151', psize - 2); 9694fdc3d75SEnji Cooper error = pwrite(desc, region, 2, psize - 2); 9704fdc3d75SEnji Cooper if (error != 2) { 9714fdc3d75SEnji Cooper if (error >= 0) 9724fdc3d75SEnji Cooper atf_tc_fail("short write; %d bytes written", 9734fdc3d75SEnji Cooper error); 9744fdc3d75SEnji Cooper else 9754fdc3d75SEnji Cooper atf_tc_fail("shmfd write"); 9764fdc3d75SEnji Cooper } 9774fdc3d75SEnji Cooper kill(rv, SIGUSR1); 9784fdc3d75SEnji Cooper waitpid(rv, &status, 0); 9794fdc3d75SEnji Cooper 9804fdc3d75SEnji Cooper if (WIFEXITED(status) && WEXITSTATUS(status) == 0) { 9814fdc3d75SEnji Cooper printf("Functionality test successful\n"); 9824fdc3d75SEnji Cooper } else if (WIFEXITED(status)) { 9834fdc3d75SEnji Cooper atf_tc_fail("Child process exited with status %d", 9844fdc3d75SEnji Cooper WEXITSTATUS(status)); 9854fdc3d75SEnji Cooper } else { 9864fdc3d75SEnji Cooper atf_tc_fail("Child process terminated with %s", 9874fdc3d75SEnji Cooper strsignal(WTERMSIG(status))); 9884fdc3d75SEnji Cooper } 9894fdc3d75SEnji Cooper } 99094ebd6f5SEnji Cooper 99194ebd6f5SEnji Cooper ATF_REQUIRE_MSG(munmap(region, psize) == 0, "munmap failed; errno=%d", 99294ebd6f5SEnji Cooper errno); 99394ebd6f5SEnji Cooper shm_unlink(test_path); 9944fdc3d75SEnji Cooper } 9954fdc3d75SEnji Cooper 99695aa96f3SKyle Evans ATF_TC_WITHOUT_HEAD(cloexec); 99795aa96f3SKyle Evans ATF_TC_BODY(cloexec, tc) 99895aa96f3SKyle Evans { 99995aa96f3SKyle Evans int fd; 100095aa96f3SKyle Evans 100195aa96f3SKyle Evans gen_test_path(); 100295aa96f3SKyle Evans 100395aa96f3SKyle Evans /* shm_open(2) is required to set FD_CLOEXEC */ 100495aa96f3SKyle Evans fd = shm_open(SHM_ANON, O_RDWR, 0777); 100595aa96f3SKyle Evans ATF_REQUIRE_MSG(fd >= 0, "shm_open failed; errno=%d", errno); 100695aa96f3SKyle Evans ATF_REQUIRE((fcntl(fd, F_GETFD) & FD_CLOEXEC) != 0); 100795aa96f3SKyle Evans close(fd); 100895aa96f3SKyle Evans 100995aa96f3SKyle Evans /* Also make sure that named shm is correct */ 101095aa96f3SKyle Evans fd = shm_open(test_path, O_CREAT | O_RDWR, 0600); 101195aa96f3SKyle Evans ATF_REQUIRE_MSG(fd >= 0, "shm_open failed; errno=%d", errno); 101295aa96f3SKyle Evans ATF_REQUIRE((fcntl(fd, F_GETFD) & FD_CLOEXEC) != 0); 101395aa96f3SKyle Evans close(fd); 101495aa96f3SKyle Evans } 101595aa96f3SKyle Evans 10165a391b57SKyle Evans ATF_TC_WITHOUT_HEAD(mode); 10175a391b57SKyle Evans ATF_TC_BODY(mode, tc) 10185a391b57SKyle Evans { 10195a391b57SKyle Evans struct stat st; 10205a391b57SKyle Evans int fd; 10215a391b57SKyle Evans mode_t restore_mask; 10225a391b57SKyle Evans 10235a391b57SKyle Evans gen_test_path(); 10245a391b57SKyle Evans 10255a391b57SKyle Evans /* Remove inhibitions from umask */ 10265a391b57SKyle Evans restore_mask = umask(0); 10275a391b57SKyle Evans fd = shm_open(test_path, O_CREAT | O_RDWR, 0600); 10285a391b57SKyle Evans ATF_REQUIRE_MSG(fd >= 0, "shm_open failed; errno=%d", errno); 10295a391b57SKyle Evans ATF_REQUIRE(fstat(fd, &st) == 0); 10305a391b57SKyle Evans ATF_REQUIRE((st.st_mode & ACCESSPERMS) == 0600); 10315a391b57SKyle Evans close(fd); 10325a391b57SKyle Evans ATF_REQUIRE(shm_unlink(test_path) == 0); 10335a391b57SKyle Evans 10345a391b57SKyle Evans fd = shm_open(test_path, O_CREAT | O_RDWR, 0660); 10355a391b57SKyle Evans ATF_REQUIRE_MSG(fd >= 0, "shm_open failed; errno=%d", errno); 10365a391b57SKyle Evans ATF_REQUIRE(fstat(fd, &st) == 0); 10375a391b57SKyle Evans ATF_REQUIRE((st.st_mode & ACCESSPERMS) == 0660); 10385a391b57SKyle Evans close(fd); 10395a391b57SKyle Evans ATF_REQUIRE(shm_unlink(test_path) == 0); 10405a391b57SKyle Evans 10415a391b57SKyle Evans fd = shm_open(test_path, O_CREAT | O_RDWR, 0666); 10425a391b57SKyle Evans ATF_REQUIRE_MSG(fd >= 0, "shm_open failed; errno=%d", errno); 10435a391b57SKyle Evans ATF_REQUIRE(fstat(fd, &st) == 0); 10445a391b57SKyle Evans ATF_REQUIRE((st.st_mode & ACCESSPERMS) == 0666); 10455a391b57SKyle Evans close(fd); 10465a391b57SKyle Evans ATF_REQUIRE(shm_unlink(test_path) == 0); 10475a391b57SKyle Evans 10485a391b57SKyle Evans umask(restore_mask); 10495a391b57SKyle Evans } 105095aa96f3SKyle Evans 1051f1040532SKyle Evans ATF_TC_WITHOUT_HEAD(fallocate); 1052f1040532SKyle Evans ATF_TC_BODY(fallocate, tc) 1053f1040532SKyle Evans { 1054f1040532SKyle Evans struct stat st; 1055f1040532SKyle Evans int error, fd, sz; 1056f1040532SKyle Evans 1057f1040532SKyle Evans /* 1058f1040532SKyle Evans * Primitive test case for posix_fallocate with shmd. Effectively 1059f1040532SKyle Evans * expected to work like a smarter ftruncate that will grow the region 1060f1040532SKyle Evans * as needed in a race-free way. 1061f1040532SKyle Evans */ 1062f1040532SKyle Evans fd = shm_open(SHM_ANON, O_RDWR, 0666); 1063f1040532SKyle Evans ATF_REQUIRE_MSG(fd >= 0, "shm_open failed; errno=%d", errno); 1064f1040532SKyle Evans /* Set the initial size. */ 1065f1040532SKyle Evans sz = 32; 1066f1040532SKyle Evans ATF_REQUIRE(ftruncate(fd, sz) == 0); 1067f1040532SKyle Evans 1068f1040532SKyle Evans /* Now grow it. */ 1069f1040532SKyle Evans error = 0; 1070f1040532SKyle Evans sz *= 2; 1071f1040532SKyle Evans ATF_REQUIRE_MSG((error = posix_fallocate(fd, 0, sz)) == 0, 1072f1040532SKyle Evans "posix_fallocate failed; error=%d", error); 1073f1040532SKyle Evans ATF_REQUIRE(fstat(fd, &st) == 0); 1074f1040532SKyle Evans ATF_REQUIRE(st.st_size == sz); 1075f1040532SKyle Evans /* Attempt to shrink it; should succeed, but not change the size. */ 1076f1040532SKyle Evans ATF_REQUIRE_MSG((error = posix_fallocate(fd, 0, sz / 2)) == 0, 1077f1040532SKyle Evans "posix_fallocate failed; error=%d", error); 1078f1040532SKyle Evans ATF_REQUIRE(fstat(fd, &st) == 0); 1079f1040532SKyle Evans ATF_REQUIRE(st.st_size == sz); 1080f1040532SKyle Evans /* Grow it using an offset of sz and len of sz. */ 1081f1040532SKyle Evans ATF_REQUIRE_MSG((error = posix_fallocate(fd, sz, sz)) == 0, 1082f1040532SKyle Evans "posix_fallocate failed; error=%d", error); 1083f1040532SKyle Evans ATF_REQUIRE(fstat(fd, &st) == 0); 1084f1f03024SKonstantin Belousov ATF_REQUIRE(st.st_size == sz * 2); 1085f1040532SKyle Evans 1086f1040532SKyle Evans close(fd); 1087f1040532SKyle Evans } 1088f1040532SKyle Evans 1089454bc887SKa Ho Ng ATF_TC_WITHOUT_HEAD(fspacectl); 1090454bc887SKa Ho Ng ATF_TC_BODY(fspacectl, tc) 1091454bc887SKa Ho Ng { 1092454bc887SKa Ho Ng struct spacectl_range range; 1093454bc887SKa Ho Ng off_t offset, length, shm_sz; 1094d3aabde9SAndrew Turner size_t page_size; 1095454bc887SKa Ho Ng int fd, error; 1096454bc887SKa Ho Ng 1097d3aabde9SAndrew Turner page_size = getpagesize(); 1098d3aabde9SAndrew Turner shm_sz = shm_max_pages * page_size; 1099454bc887SKa Ho Ng 1100454bc887SKa Ho Ng fd = shm_open("/testtest", O_RDWR | O_CREAT, 0666); 1101454bc887SKa Ho Ng ATF_REQUIRE_MSG(fd >= 0, "shm_open failed; errno:%d", errno); 1102454bc887SKa Ho Ng ATF_REQUIRE_MSG((error = posix_fallocate(fd, 0, shm_sz)) == 0, 1103454bc887SKa Ho Ng "posix_fallocate failed; error=%d", error); 1104454bc887SKa Ho Ng 1105454bc887SKa Ho Ng /* Aligned fspacectl(fd, SPACECTL_DEALLOC, ...) */ 1106454bc887SKa Ho Ng ATF_REQUIRE(shm_fill(fd, 0, shm_sz) == 0); 1107d3aabde9SAndrew Turner range.r_offset = offset = page_size; 1108d3aabde9SAndrew Turner range.r_len = length = ((shm_max_pages - 1) * page_size) - 1109454bc887SKa Ho Ng range.r_offset; 1110454bc887SKa Ho Ng ATF_CHECK_MSG(fspacectl(fd, SPACECTL_DEALLOC, &range, 0, &range) == 0, 1111454bc887SKa Ho Ng "Aligned fspacectl failed; errno=%d", errno); 1112454bc887SKa Ho Ng ATF_CHECK_MSG(check_content_dealloc(fd, offset, length, shm_sz) == 0, 1113cd16a848SJohn Baldwin "Aligned fspacectl content checking failed"); 1114454bc887SKa Ho Ng 1115454bc887SKa Ho Ng /* Unaligned fspacectl(fd, SPACECTL_DEALLOC, ...) */ 1116454bc887SKa Ho Ng ATF_REQUIRE(shm_fill(fd, 0, shm_sz) == 0); 1117d3aabde9SAndrew Turner range.r_offset = offset = page_size / 2; 1118f1f03024SKonstantin Belousov range.r_len = length = (shm_max_pages - 1) * page_size + 1119d3aabde9SAndrew Turner (page_size / 2) - offset; 1120454bc887SKa Ho Ng ATF_CHECK_MSG(fspacectl(fd, SPACECTL_DEALLOC, &range, 0, &range) == 0, 1121454bc887SKa Ho Ng "Unaligned fspacectl failed; errno=%d", errno); 1122454bc887SKa Ho Ng ATF_CHECK_MSG(check_content_dealloc(fd, offset, length, shm_sz) == 0, 1123cd16a848SJohn Baldwin "Unaligned fspacectl content checking failed"); 1124454bc887SKa Ho Ng 1125454bc887SKa Ho Ng /* Aligned fspacectl(fd, SPACECTL_DEALLOC, ...) to OFF_MAX */ 1126454bc887SKa Ho Ng ATF_REQUIRE(shm_fill(fd, 0, shm_sz) == 0); 1127d3aabde9SAndrew Turner range.r_offset = offset = page_size; 1128454bc887SKa Ho Ng range.r_len = length = OFF_MAX - offset; 1129454bc887SKa Ho Ng ATF_CHECK_MSG(fspacectl(fd, SPACECTL_DEALLOC, &range, 0, &range) == 0, 1130454bc887SKa Ho Ng "Aligned fspacectl to OFF_MAX failed; errno=%d", errno); 1131454bc887SKa Ho Ng ATF_CHECK_MSG(check_content_dealloc(fd, offset, length, shm_sz) == 0, 1132cd16a848SJohn Baldwin "Aligned fspacectl to OFF_MAX content checking failed"); 1133454bc887SKa Ho Ng 1134454bc887SKa Ho Ng /* Unaligned fspacectl(fd, SPACECTL_DEALLOC, ...) to OFF_MAX */ 1135454bc887SKa Ho Ng ATF_REQUIRE(shm_fill(fd, 0, shm_sz) == 0); 1136d3aabde9SAndrew Turner range.r_offset = offset = page_size / 2; 1137454bc887SKa Ho Ng range.r_len = length = OFF_MAX - offset; 1138454bc887SKa Ho Ng ATF_CHECK_MSG(fspacectl(fd, SPACECTL_DEALLOC, &range, 0, &range) == 0, 1139454bc887SKa Ho Ng "Unaligned fspacectl to OFF_MAX failed; errno=%d", errno); 1140454bc887SKa Ho Ng ATF_CHECK_MSG(check_content_dealloc(fd, offset, length, shm_sz) == 0, 1141cd16a848SJohn Baldwin "Unaligned fspacectl to OFF_MAX content checking failed"); 1142454bc887SKa Ho Ng 1143454bc887SKa Ho Ng /* Aligned fspacectl(fd, SPACECTL_DEALLOC, ...) past shm_sz */ 1144454bc887SKa Ho Ng ATF_REQUIRE(shm_fill(fd, 0, shm_sz) == 0); 1145d3aabde9SAndrew Turner range.r_offset = offset = page_size; 1146f1f03024SKonstantin Belousov range.r_len = length = (shm_max_pages + 1) * page_size - offset; 1147454bc887SKa Ho Ng ATF_CHECK_MSG(fspacectl(fd, SPACECTL_DEALLOC, &range, 0, &range) == 0, 1148454bc887SKa Ho Ng "Aligned fspacectl past shm_sz failed; errno=%d", errno); 1149454bc887SKa Ho Ng ATF_CHECK_MSG(check_content_dealloc(fd, offset, length, shm_sz) == 0, 1150cd16a848SJohn Baldwin "Aligned fspacectl past shm_sz content checking failed"); 1151454bc887SKa Ho Ng 1152454bc887SKa Ho Ng /* Unaligned fspacectl(fd, SPACECTL_DEALLOC, ...) past shm_sz */ 1153454bc887SKa Ho Ng ATF_REQUIRE(shm_fill(fd, 0, shm_sz) == 0); 1154d3aabde9SAndrew Turner range.r_offset = offset = page_size / 2; 1155f1f03024SKonstantin Belousov range.r_len = length = (shm_max_pages + 1) * page_size - offset; 1156454bc887SKa Ho Ng ATF_CHECK_MSG(fspacectl(fd, SPACECTL_DEALLOC, &range, 0, &range) == 0, 1157454bc887SKa Ho Ng "Unaligned fspacectl past shm_sz failed; errno=%d", errno); 1158454bc887SKa Ho Ng ATF_CHECK_MSG(check_content_dealloc(fd, offset, length, shm_sz) == 0, 1159cd16a848SJohn Baldwin "Unaligned fspacectl past shm_sz content checking failed"); 1160454bc887SKa Ho Ng 1161454bc887SKa Ho Ng ATF_REQUIRE(close(fd) == 0); 1162454bc887SKa Ho Ng } 1163454bc887SKa Ho Ng 116491ddfd35SKonstantin Belousov ATF_TC_WITHOUT_HEAD(accounting); 116591ddfd35SKonstantin Belousov ATF_TC_BODY(accounting, tc) 116691ddfd35SKonstantin Belousov { 116791ddfd35SKonstantin Belousov struct spacectl_range range; 116891ddfd35SKonstantin Belousov struct stat st; 116991ddfd35SKonstantin Belousov off_t shm_sz, len; 117091ddfd35SKonstantin Belousov size_t page_size; 117191ddfd35SKonstantin Belousov int fd, error; 117291ddfd35SKonstantin Belousov 117391ddfd35SKonstantin Belousov page_size = getpagesize(); 117491ddfd35SKonstantin Belousov shm_sz = shm_max_pages * page_size; 117591ddfd35SKonstantin Belousov 117691ddfd35SKonstantin Belousov fd = shm_open("/testtest1", O_RDWR | O_CREAT, 0666); 117791ddfd35SKonstantin Belousov ATF_REQUIRE_MSG(fd >= 0, "shm_open failed; errno:%d", errno); 117891ddfd35SKonstantin Belousov ATF_REQUIRE_MSG((error = posix_fallocate(fd, 0, shm_sz)) == 0, 117991ddfd35SKonstantin Belousov "posix_fallocate failed; error=%d", error); 118091ddfd35SKonstantin Belousov 118191ddfd35SKonstantin Belousov ATF_REQUIRE(shm_fill(fd, 0, shm_sz) == 0); 118291ddfd35SKonstantin Belousov ATF_REQUIRE(fstat(fd, &st) == 0); 118391ddfd35SKonstantin Belousov ATF_REQUIRE(st.st_blksize * st.st_blocks == (blkcnt_t)shm_sz); 118491ddfd35SKonstantin Belousov 118591ddfd35SKonstantin Belousov range.r_offset = page_size; 118691ddfd35SKonstantin Belousov range.r_len = len = (shm_max_pages - 1) * page_size - 118791ddfd35SKonstantin Belousov range.r_offset; 118891ddfd35SKonstantin Belousov ATF_CHECK_MSG(fspacectl(fd, SPACECTL_DEALLOC, &range, 0, &range) == 0, 118991ddfd35SKonstantin Belousov "SPACECTL_DEALLOC failed; errno=%d", errno); 119091ddfd35SKonstantin Belousov ATF_REQUIRE(fstat(fd, &st) == 0); 119191ddfd35SKonstantin Belousov ATF_REQUIRE(st.st_blksize * st.st_blocks == (blkcnt_t)(shm_sz - len)); 119291ddfd35SKonstantin Belousov 119391ddfd35SKonstantin Belousov ATF_REQUIRE(close(fd) == 0); 119491ddfd35SKonstantin Belousov } 119591ddfd35SKonstantin Belousov 119677ceadeeSMark Johnston static int 119777ceadeeSMark Johnston shm_open_large(int psind, int policy, size_t sz) 119877ceadeeSMark Johnston { 119977ceadeeSMark Johnston int error, fd; 120077ceadeeSMark Johnston 120177ceadeeSMark Johnston fd = shm_create_largepage(SHM_ANON, O_CREAT | O_RDWR, psind, policy, 0); 120277ceadeeSMark Johnston if (fd < 0 && errno == ENOTTY) 120377ceadeeSMark Johnston atf_tc_skip("no large page support"); 120477ceadeeSMark Johnston ATF_REQUIRE_MSG(fd >= 0, "shm_create_largepage failed; errno=%d", errno); 120577ceadeeSMark Johnston 120677ceadeeSMark Johnston error = ftruncate(fd, sz); 120777ceadeeSMark Johnston if (error != 0 && errno == ENOMEM) 120877ceadeeSMark Johnston /* 120977ceadeeSMark Johnston * The test system might not have enough memory to accommodate 121077ceadeeSMark Johnston * the request. 121177ceadeeSMark Johnston */ 121277ceadeeSMark Johnston atf_tc_skip("failed to allocate %zu-byte superpage", sz); 121377ceadeeSMark Johnston ATF_REQUIRE_MSG(error == 0, "ftruncate failed; errno=%d", errno); 121477ceadeeSMark Johnston 121577ceadeeSMark Johnston return (fd); 121677ceadeeSMark Johnston } 121777ceadeeSMark Johnston 121877ceadeeSMark Johnston static int 121977ceadeeSMark Johnston pagesizes(size_t ps[MAXPAGESIZES]) 122077ceadeeSMark Johnston { 122177ceadeeSMark Johnston int pscnt; 122277ceadeeSMark Johnston 122377ceadeeSMark Johnston pscnt = getpagesizes(ps, MAXPAGESIZES); 122477ceadeeSMark Johnston ATF_REQUIRE_MSG(pscnt != -1, "getpagesizes failed; errno=%d", errno); 1225d3aabde9SAndrew Turner ATF_REQUIRE_MSG(ps[0] != 0, "psind 0 is %zu", ps[0]); 122677ceadeeSMark Johnston ATF_REQUIRE_MSG(pscnt <= MAXPAGESIZES, "invalid pscnt %d", pscnt); 122777ceadeeSMark Johnston if (pscnt == 1) 122877ceadeeSMark Johnston atf_tc_skip("no large page support"); 122977ceadeeSMark Johnston return (pscnt); 123077ceadeeSMark Johnston } 123177ceadeeSMark Johnston 123277ceadeeSMark Johnston ATF_TC_WITHOUT_HEAD(largepage_basic); 123377ceadeeSMark Johnston ATF_TC_BODY(largepage_basic, tc) 123477ceadeeSMark Johnston { 1235d3aabde9SAndrew Turner char *zeroes; 123677ceadeeSMark Johnston char *addr, *vec; 123777ceadeeSMark Johnston size_t ps[MAXPAGESIZES]; 123877ceadeeSMark Johnston int error, fd, pscnt; 123977ceadeeSMark Johnston 124077ceadeeSMark Johnston pscnt = pagesizes(ps); 1241d3aabde9SAndrew Turner zeroes = calloc(1, ps[0]); 1242d3aabde9SAndrew Turner ATF_REQUIRE(zeroes != NULL); 124377ceadeeSMark Johnston for (int i = 1; i < pscnt; i++) { 124477ceadeeSMark Johnston fd = shm_open_large(i, SHM_LARGEPAGE_ALLOC_DEFAULT, ps[i]); 124577ceadeeSMark Johnston 124677ceadeeSMark Johnston addr = mmap(NULL, ps[i], PROT_READ | PROT_WRITE, MAP_SHARED, fd, 124777ceadeeSMark Johnston 0); 124877ceadeeSMark Johnston ATF_REQUIRE_MSG(addr != MAP_FAILED, 124977ceadeeSMark Johnston "mmap(%zu bytes) failed; errno=%d", ps[i], errno); 125077ceadeeSMark Johnston ATF_REQUIRE_MSG(((uintptr_t)addr & (ps[i] - 1)) == 0, 125177ceadeeSMark Johnston "mmap(%zu bytes) returned unaligned mapping; addr=%p", 125277ceadeeSMark Johnston ps[i], addr); 125377ceadeeSMark Johnston 125477ceadeeSMark Johnston /* Force a page fault. */ 125577ceadeeSMark Johnston *(volatile char *)addr = 0; 125677ceadeeSMark Johnston 1257d3aabde9SAndrew Turner vec = malloc(ps[i] / ps[0]); 125877ceadeeSMark Johnston ATF_REQUIRE(vec != NULL); 125977ceadeeSMark Johnston error = mincore(addr, ps[i], vec); 126077ceadeeSMark Johnston ATF_REQUIRE_MSG(error == 0, "mincore failed; errno=%d", errno); 126177ceadeeSMark Johnston 126277ceadeeSMark Johnston /* Verify that all pages in the run are mapped. */ 1263d3aabde9SAndrew Turner for (size_t p = 0; p < ps[i] / ps[0]; p++) { 126477ceadeeSMark Johnston ATF_REQUIRE_MSG((vec[p] & MINCORE_INCORE) != 0, 126577ceadeeSMark Johnston "page %zu is not mapped", p); 1266560f9cd5SMark Johnston ATF_REQUIRE_MSG((vec[p] & MINCORE_SUPER) == 1267560f9cd5SMark Johnston MINCORE_PSIND(i), 126877ceadeeSMark Johnston "page %zu is not in a %zu-byte superpage", 126977ceadeeSMark Johnston p, ps[i]); 127077ceadeeSMark Johnston } 127177ceadeeSMark Johnston 127277ceadeeSMark Johnston /* Validate zeroing. */ 1273d3aabde9SAndrew Turner for (size_t p = 0; p < ps[i] / ps[0]; p++) { 1274d3aabde9SAndrew Turner ATF_REQUIRE_MSG(memcmp(addr + p * ps[0], zeroes, 1275d3aabde9SAndrew Turner ps[0]) == 0, "page %zu miscompare", p); 127677ceadeeSMark Johnston } 127777ceadeeSMark Johnston 127877ceadeeSMark Johnston free(vec); 127977ceadeeSMark Johnston ATF_REQUIRE(munmap(addr, ps[i]) == 0); 128077ceadeeSMark Johnston ATF_REQUIRE(close(fd) == 0); 128177ceadeeSMark Johnston } 1282d3aabde9SAndrew Turner 1283d3aabde9SAndrew Turner free(zeroes); 128477ceadeeSMark Johnston } 128577ceadeeSMark Johnston 128677ceadeeSMark Johnston extern int __sys_shm_open2(const char *, int, mode_t, int, const char *); 128777ceadeeSMark Johnston 128877ceadeeSMark Johnston ATF_TC_WITHOUT_HEAD(largepage_config); 128977ceadeeSMark Johnston ATF_TC_BODY(largepage_config, tc) 129077ceadeeSMark Johnston { 129177ceadeeSMark Johnston struct shm_largepage_conf lpc; 129277ceadeeSMark Johnston char *addr, *buf; 129377ceadeeSMark Johnston size_t ps[MAXPAGESIZES + 1]; /* silence warnings if MAXPAGESIZES == 1 */ 1294cd16a848SJohn Baldwin int error, fd; 129577ceadeeSMark Johnston 129605d17358SAndrew Turner (void)pagesizes(ps); 129705d17358SAndrew Turner 129877ceadeeSMark Johnston fd = shm_open(SHM_ANON, O_CREAT | O_RDWR, 0); 129977ceadeeSMark Johnston ATF_REQUIRE_MSG(fd >= 0, "shm_open failed; error=%d", errno); 130077ceadeeSMark Johnston 130177ceadeeSMark Johnston /* 130277ceadeeSMark Johnston * Configure a large page policy for an object created without 130377ceadeeSMark Johnston * SHM_LARGEPAGE. 130477ceadeeSMark Johnston */ 130577ceadeeSMark Johnston lpc.psind = 1; 130677ceadeeSMark Johnston lpc.alloc_policy = SHM_LARGEPAGE_ALLOC_DEFAULT; 130777ceadeeSMark Johnston error = ioctl(fd, FIOSSHMLPGCNF, &lpc); 130877ceadeeSMark Johnston ATF_REQUIRE(error != 0); 130977ceadeeSMark Johnston ATF_REQUIRE_MSG(errno == ENOTTY, "ioctl(FIOSSHMLPGCNF) returned %d", 131077ceadeeSMark Johnston errno); 131177ceadeeSMark Johnston ATF_REQUIRE(close(fd) == 0); 131277ceadeeSMark Johnston 131377ceadeeSMark Johnston /* 131477ceadeeSMark Johnston * Create a largepage object and try to use it without actually 131577ceadeeSMark Johnston * configuring anything. 131677ceadeeSMark Johnston */ 131777ceadeeSMark Johnston fd = __sys_shm_open2(SHM_ANON, O_CREAT | O_RDWR, 0, SHM_LARGEPAGE, 131877ceadeeSMark Johnston NULL); 131977ceadeeSMark Johnston if (fd < 0 && errno == ENOTTY) 132077ceadeeSMark Johnston atf_tc_skip("no large page support"); 132177ceadeeSMark Johnston ATF_REQUIRE_MSG(fd >= 0, "shm_open2 failed; error=%d", errno); 132277ceadeeSMark Johnston 132377ceadeeSMark Johnston error = ftruncate(fd, ps[1]); 132477ceadeeSMark Johnston ATF_REQUIRE(error != 0); 132577ceadeeSMark Johnston ATF_REQUIRE_MSG(errno == EINVAL, "ftruncate returned %d", errno); 132677ceadeeSMark Johnston 132777ceadeeSMark Johnston addr = mmap(NULL, ps[1], PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0); 132877ceadeeSMark Johnston ATF_REQUIRE(addr == MAP_FAILED); 132977ceadeeSMark Johnston ATF_REQUIRE_MSG(errno == EINVAL, "mmap returned %d", errno); 133077ceadeeSMark Johnston addr = mmap(NULL, 0, PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0); 133177ceadeeSMark Johnston ATF_REQUIRE(addr == MAP_FAILED); 133277ceadeeSMark Johnston ATF_REQUIRE_MSG(errno == EINVAL, "mmap returned %d", errno); 133377ceadeeSMark Johnston 1334d3aabde9SAndrew Turner buf = calloc(1, ps[0]); 133577ceadeeSMark Johnston ATF_REQUIRE(buf != NULL); 1336d3aabde9SAndrew Turner ATF_REQUIRE(write(fd, buf, ps[0]) == -1); 133777ceadeeSMark Johnston ATF_REQUIRE_MSG(errno == EINVAL, "write returned %d", errno); 133877ceadeeSMark Johnston free(buf); 133977ceadeeSMark Johnston buf = calloc(1, ps[1]); 134077ceadeeSMark Johnston ATF_REQUIRE(buf != NULL); 134177ceadeeSMark Johnston ATF_REQUIRE(write(fd, buf, ps[1]) == -1); 134277ceadeeSMark Johnston ATF_REQUIRE_MSG(errno == EINVAL, "write returned %d", errno); 134377ceadeeSMark Johnston free(buf); 134477ceadeeSMark Johnston 1345d3aabde9SAndrew Turner error = posix_fallocate(fd, 0, ps[0]); 134677ceadeeSMark Johnston ATF_REQUIRE_MSG(error == EINVAL, "posix_fallocate returned %d", error); 134777ceadeeSMark Johnston 134877ceadeeSMark Johnston ATF_REQUIRE(close(fd) == 0); 134977ceadeeSMark Johnston } 135077ceadeeSMark Johnston 135177ceadeeSMark Johnston ATF_TC_WITHOUT_HEAD(largepage_mmap); 135277ceadeeSMark Johnston ATF_TC_BODY(largepage_mmap, tc) 135377ceadeeSMark Johnston { 135477ceadeeSMark Johnston char *addr, *addr1, *vec; 135577ceadeeSMark Johnston size_t ps[MAXPAGESIZES]; 135677ceadeeSMark Johnston int fd, pscnt; 135777ceadeeSMark Johnston 135877ceadeeSMark Johnston pscnt = pagesizes(ps); 135977ceadeeSMark Johnston for (int i = 1; i < pscnt; i++) { 136077ceadeeSMark Johnston fd = shm_open_large(i, SHM_LARGEPAGE_ALLOC_DEFAULT, ps[i]); 136177ceadeeSMark Johnston 136277ceadeeSMark Johnston /* For mincore(). */ 136377ceadeeSMark Johnston vec = malloc(ps[i]); 136477ceadeeSMark Johnston ATF_REQUIRE(vec != NULL); 136577ceadeeSMark Johnston 136677ceadeeSMark Johnston /* 136777ceadeeSMark Johnston * Wrong mapping size. 136877ceadeeSMark Johnston */ 136977ceadeeSMark Johnston addr = mmap(NULL, ps[i - 1], PROT_READ | PROT_WRITE, MAP_SHARED, 137077ceadeeSMark Johnston fd, 0); 137177ceadeeSMark Johnston ATF_REQUIRE_MSG(addr == MAP_FAILED, 137277ceadeeSMark Johnston "mmap(%zu bytes) succeeded", ps[i - 1]); 137377ceadeeSMark Johnston ATF_REQUIRE_MSG(errno == EINVAL, 137477ceadeeSMark Johnston "mmap(%zu bytes) failed; error=%d", ps[i - 1], errno); 137577ceadeeSMark Johnston 137677ceadeeSMark Johnston /* 137777ceadeeSMark Johnston * Fixed mappings. 137877ceadeeSMark Johnston */ 137977ceadeeSMark Johnston addr = mmap(NULL, ps[i], PROT_READ | PROT_WRITE, MAP_SHARED, fd, 138077ceadeeSMark Johnston 0); 138177ceadeeSMark Johnston ATF_REQUIRE_MSG(addr != MAP_FAILED, 138277ceadeeSMark Johnston "mmap(%zu bytes) failed; errno=%d", ps[i], errno); 138377ceadeeSMark Johnston ATF_REQUIRE_MSG(((uintptr_t)addr & (ps[i] - 1)) == 0, 138477ceadeeSMark Johnston "mmap(%zu bytes) returned unaligned mapping; addr=%p", 138577ceadeeSMark Johnston ps[i], addr); 138677ceadeeSMark Johnston 138777ceadeeSMark Johnston /* Try mapping a small page with anonymous memory. */ 138877ceadeeSMark Johnston addr1 = mmap(addr, ps[i - 1], PROT_READ | PROT_WRITE, 138977ceadeeSMark Johnston MAP_PRIVATE | MAP_ANON | MAP_FIXED, -1, 0); 139077ceadeeSMark Johnston ATF_REQUIRE_MSG(addr1 == MAP_FAILED, 139177ceadeeSMark Johnston "anon mmap(%zu bytes) succeeded", ps[i - 1]); 139277ceadeeSMark Johnston ATF_REQUIRE_MSG(errno == EINVAL, "mmap returned %d", errno); 139377ceadeeSMark Johnston 139477ceadeeSMark Johnston /* Check MAP_EXCL when creating a second largepage mapping. */ 139577ceadeeSMark Johnston addr1 = mmap(addr, ps[i], PROT_READ | PROT_WRITE, 139677ceadeeSMark Johnston MAP_SHARED | MAP_FIXED | MAP_EXCL, fd, 0); 139777ceadeeSMark Johnston ATF_REQUIRE_MSG(addr1 == MAP_FAILED, 139877ceadeeSMark Johnston "mmap(%zu bytes) succeeded", ps[i]); 139977ceadeeSMark Johnston /* XXX wrong errno */ 140077ceadeeSMark Johnston ATF_REQUIRE_MSG(errno == ENOSPC, "mmap returned %d", errno); 140177ceadeeSMark Johnston 140277ceadeeSMark Johnston /* Overwrite a largepage mapping with a lagepage mapping. */ 140377ceadeeSMark Johnston addr1 = mmap(addr, ps[i], PROT_READ | PROT_WRITE, 140477ceadeeSMark Johnston MAP_SHARED | MAP_FIXED, fd, 0); 140577ceadeeSMark Johnston ATF_REQUIRE_MSG(addr1 != MAP_FAILED, 140677ceadeeSMark Johnston "mmap(%zu bytes) failed; errno=%d", ps[i], errno); 140777ceadeeSMark Johnston ATF_REQUIRE_MSG(addr == addr1, 140877ceadeeSMark Johnston "mmap(%zu bytes) moved from %p to %p", ps[i], addr, addr1); 140977ceadeeSMark Johnston 141077ceadeeSMark Johnston ATF_REQUIRE(munmap(addr, ps[i] == 0)); 141177ceadeeSMark Johnston 141277ceadeeSMark Johnston /* Clobber an anonymous mapping with a superpage. */ 1413d3aabde9SAndrew Turner addr1 = mmap(NULL, ps[0], PROT_READ | PROT_WRITE, 141477ceadeeSMark Johnston MAP_ANON | MAP_PRIVATE | MAP_ALIGNED(ffsl(ps[i]) - 1), -1, 141577ceadeeSMark Johnston 0); 141677ceadeeSMark Johnston ATF_REQUIRE_MSG(addr1 != MAP_FAILED, 141777ceadeeSMark Johnston "mmap failed; error=%d", errno); 141877ceadeeSMark Johnston *(volatile char *)addr1 = '\0'; 141977ceadeeSMark Johnston addr = mmap(addr1, ps[i], PROT_READ | PROT_WRITE, 142077ceadeeSMark Johnston MAP_SHARED | MAP_FIXED, fd, 0); 142177ceadeeSMark Johnston ATF_REQUIRE_MSG(addr != MAP_FAILED, 142277ceadeeSMark Johnston "mmap failed; error=%d", errno); 142377ceadeeSMark Johnston ATF_REQUIRE_MSG(addr == addr1, 142477ceadeeSMark Johnston "mmap disobeyed MAP_FIXED, %p %p", addr, addr1); 142577ceadeeSMark Johnston *(volatile char *)addr = 0; /* fault */ 142677ceadeeSMark Johnston ATF_REQUIRE(mincore(addr, ps[i], vec) == 0); 1427d3aabde9SAndrew Turner for (size_t p = 0; p < ps[i] / ps[0]; p++) { 142877ceadeeSMark Johnston ATF_REQUIRE_MSG((vec[p] & MINCORE_INCORE) != 0, 142977ceadeeSMark Johnston "page %zu is not resident", p); 1430560f9cd5SMark Johnston ATF_REQUIRE_MSG((vec[p] & MINCORE_SUPER) == 1431560f9cd5SMark Johnston MINCORE_PSIND(i), 143277ceadeeSMark Johnston "page %zu is not resident", p); 143377ceadeeSMark Johnston } 143477ceadeeSMark Johnston 143577ceadeeSMark Johnston /* 143677ceadeeSMark Johnston * Copy-on-write mappings are not permitted. 143777ceadeeSMark Johnston */ 143877ceadeeSMark Johnston addr = mmap(NULL, ps[i], PROT_READ | PROT_WRITE, MAP_PRIVATE, 143977ceadeeSMark Johnston fd, 0); 144077ceadeeSMark Johnston ATF_REQUIRE_MSG(addr == MAP_FAILED, 144177ceadeeSMark Johnston "mmap(%zu bytes) succeeded", ps[i]); 144277ceadeeSMark Johnston 144377ceadeeSMark Johnston ATF_REQUIRE(close(fd) == 0); 144477ceadeeSMark Johnston } 144577ceadeeSMark Johnston } 144677ceadeeSMark Johnston 144777ceadeeSMark Johnston ATF_TC_WITHOUT_HEAD(largepage_munmap); 144877ceadeeSMark Johnston ATF_TC_BODY(largepage_munmap, tc) 144977ceadeeSMark Johnston { 145077ceadeeSMark Johnston char *addr; 145177ceadeeSMark Johnston size_t ps[MAXPAGESIZES], ps1; 145277ceadeeSMark Johnston int fd, pscnt; 145377ceadeeSMark Johnston 145477ceadeeSMark Johnston pscnt = pagesizes(ps); 145577ceadeeSMark Johnston for (int i = 1; i < pscnt; i++) { 145677ceadeeSMark Johnston fd = shm_open_large(i, SHM_LARGEPAGE_ALLOC_DEFAULT, ps[i]); 145777ceadeeSMark Johnston ps1 = ps[i - 1]; 145877ceadeeSMark Johnston 145977ceadeeSMark Johnston addr = mmap(NULL, ps[i], PROT_READ | PROT_WRITE, MAP_SHARED, fd, 146077ceadeeSMark Johnston 0); 146177ceadeeSMark Johnston ATF_REQUIRE_MSG(addr != MAP_FAILED, 146277ceadeeSMark Johnston "mmap(%zu bytes) failed; errno=%d", ps[i], errno); 146377ceadeeSMark Johnston 146477ceadeeSMark Johnston /* Try several unaligned munmap() requests. */ 146577ceadeeSMark Johnston ATF_REQUIRE(munmap(addr, ps1) != 0); 146677ceadeeSMark Johnston ATF_REQUIRE_MSG(errno == EINVAL, 146777ceadeeSMark Johnston "unexpected error %d from munmap", errno); 146877ceadeeSMark Johnston ATF_REQUIRE(munmap(addr, ps[i] - ps1)); 146977ceadeeSMark Johnston ATF_REQUIRE_MSG(errno == EINVAL, 147077ceadeeSMark Johnston "unexpected error %d from munmap", errno); 147177ceadeeSMark Johnston ATF_REQUIRE(munmap(addr + ps1, ps1) != 0); 147277ceadeeSMark Johnston ATF_REQUIRE_MSG(errno == EINVAL, 147377ceadeeSMark Johnston "unexpected error %d from munmap", errno); 147477ceadeeSMark Johnston ATF_REQUIRE(munmap(addr, 0)); 147577ceadeeSMark Johnston ATF_REQUIRE_MSG(errno == EINVAL, 147677ceadeeSMark Johnston "unexpected error %d from munmap", errno); 147777ceadeeSMark Johnston 147877ceadeeSMark Johnston ATF_REQUIRE(munmap(addr, ps[i]) == 0); 147977ceadeeSMark Johnston ATF_REQUIRE(close(fd) == 0); 148077ceadeeSMark Johnston } 148177ceadeeSMark Johnston } 148277ceadeeSMark Johnston 148377ceadeeSMark Johnston static void 148477ceadeeSMark Johnston largepage_madvise(char *addr, size_t sz, int advice, int error) 148577ceadeeSMark Johnston { 148677ceadeeSMark Johnston if (error == 0) { 148777ceadeeSMark Johnston ATF_REQUIRE_MSG(madvise(addr, sz, advice) == 0, 148877ceadeeSMark Johnston "madvise(%zu, %d) failed; error=%d", sz, advice, errno); 148977ceadeeSMark Johnston } else { 149077ceadeeSMark Johnston ATF_REQUIRE_MSG(madvise(addr, sz, advice) != 0, 149177ceadeeSMark Johnston "madvise(%zu, %d) succeeded", sz, advice); 149277ceadeeSMark Johnston ATF_REQUIRE_MSG(errno == error, 149377ceadeeSMark Johnston "unexpected error %d from madvise(%zu, %d)", 149477ceadeeSMark Johnston errno, sz, advice); 149577ceadeeSMark Johnston } 149677ceadeeSMark Johnston } 149777ceadeeSMark Johnston 149877ceadeeSMark Johnston ATF_TC_WITHOUT_HEAD(largepage_madvise); 149977ceadeeSMark Johnston ATF_TC_BODY(largepage_madvise, tc) 150077ceadeeSMark Johnston { 150177ceadeeSMark Johnston char *addr; 150277ceadeeSMark Johnston size_t ps[MAXPAGESIZES]; 150377ceadeeSMark Johnston int fd, pscnt; 150477ceadeeSMark Johnston 150577ceadeeSMark Johnston pscnt = pagesizes(ps); 150677ceadeeSMark Johnston for (int i = 1; i < pscnt; i++) { 150777ceadeeSMark Johnston fd = shm_open_large(i, SHM_LARGEPAGE_ALLOC_DEFAULT, ps[i]); 150877ceadeeSMark Johnston addr = mmap(NULL, ps[i], PROT_READ | PROT_WRITE, MAP_SHARED, fd, 150977ceadeeSMark Johnston 0); 151077ceadeeSMark Johnston ATF_REQUIRE_MSG(addr != MAP_FAILED, 151177ceadeeSMark Johnston "mmap(%zu bytes) failed; error=%d", ps[i], errno); 151277ceadeeSMark Johnston 1513e4eedf8cSMark Johnston memset(addr, 0, ps[i]); 1514e4eedf8cSMark Johnston 151577ceadeeSMark Johnston /* Advice that requires clipping. */ 1516d3aabde9SAndrew Turner largepage_madvise(addr, ps[0], MADV_NORMAL, EINVAL); 151777ceadeeSMark Johnston largepage_madvise(addr, ps[i], MADV_NORMAL, 0); 1518d3aabde9SAndrew Turner largepage_madvise(addr, ps[0], MADV_RANDOM, EINVAL); 151977ceadeeSMark Johnston largepage_madvise(addr, ps[i], MADV_RANDOM, 0); 1520d3aabde9SAndrew Turner largepage_madvise(addr, ps[0], MADV_SEQUENTIAL, EINVAL); 152177ceadeeSMark Johnston largepage_madvise(addr, ps[i], MADV_SEQUENTIAL, 0); 1522d3aabde9SAndrew Turner largepage_madvise(addr, ps[0], MADV_NOSYNC, EINVAL); 152377ceadeeSMark Johnston largepage_madvise(addr, ps[i], MADV_NOSYNC, 0); 1524d3aabde9SAndrew Turner largepage_madvise(addr, ps[0], MADV_AUTOSYNC, EINVAL); 152577ceadeeSMark Johnston largepage_madvise(addr, ps[i], MADV_AUTOSYNC, 0); 1526d3aabde9SAndrew Turner largepage_madvise(addr, ps[0], MADV_CORE, EINVAL); 152777ceadeeSMark Johnston largepage_madvise(addr, ps[i], MADV_CORE, 0); 1528d3aabde9SAndrew Turner largepage_madvise(addr, ps[0], MADV_NOCORE, EINVAL); 152977ceadeeSMark Johnston largepage_madvise(addr, ps[i], MADV_NOCORE, 0); 153077ceadeeSMark Johnston 153177ceadeeSMark Johnston /* Advice that does not result in clipping. */ 1532d3aabde9SAndrew Turner largepage_madvise(addr, ps[0], MADV_DONTNEED, 0); 153377ceadeeSMark Johnston largepage_madvise(addr, ps[i], MADV_DONTNEED, 0); 1534d3aabde9SAndrew Turner largepage_madvise(addr, ps[0], MADV_WILLNEED, 0); 153577ceadeeSMark Johnston largepage_madvise(addr, ps[i], MADV_WILLNEED, 0); 1536d3aabde9SAndrew Turner largepage_madvise(addr, ps[0], MADV_FREE, 0); 153777ceadeeSMark Johnston largepage_madvise(addr, ps[i], MADV_FREE, 0); 153877ceadeeSMark Johnston 153977ceadeeSMark Johnston ATF_REQUIRE(munmap(addr, ps[i]) == 0); 154077ceadeeSMark Johnston ATF_REQUIRE(close(fd) == 0); 154177ceadeeSMark Johnston } 154277ceadeeSMark Johnston } 154377ceadeeSMark Johnston 154477ceadeeSMark Johnston ATF_TC(largepage_mlock); 154577ceadeeSMark Johnston ATF_TC_HEAD(largepage_mlock, tc) 154677ceadeeSMark Johnston { 154777ceadeeSMark Johnston /* Needed to set rlimit. */ 154877ceadeeSMark Johnston atf_tc_set_md_var(tc, "require.user", "root"); 154977ceadeeSMark Johnston } 155077ceadeeSMark Johnston ATF_TC_BODY(largepage_mlock, tc) 155177ceadeeSMark Johnston { 155277ceadeeSMark Johnston struct rlimit rl; 155377ceadeeSMark Johnston char *addr; 155477ceadeeSMark Johnston size_t ps[MAXPAGESIZES], sz; 155577ceadeeSMark Johnston u_long max_wired, wired; 155677ceadeeSMark Johnston int fd, error, pscnt; 155777ceadeeSMark Johnston 155877ceadeeSMark Johnston rl.rlim_cur = rl.rlim_max = RLIM_INFINITY; 155977ceadeeSMark Johnston ATF_REQUIRE_MSG(setrlimit(RLIMIT_MEMLOCK, &rl) == 0, 156077ceadeeSMark Johnston "setrlimit failed; error=%d", errno); 156177ceadeeSMark Johnston 156277ceadeeSMark Johnston sz = sizeof(max_wired); 156377ceadeeSMark Johnston error = sysctlbyname("vm.max_user_wired", &max_wired, &sz, NULL, 0); 156477ceadeeSMark Johnston ATF_REQUIRE_MSG(error == 0, 156577ceadeeSMark Johnston "sysctlbyname(vm.max_user_wired) failed; error=%d", errno); 156677ceadeeSMark Johnston 156777ceadeeSMark Johnston sz = sizeof(wired); 156877ceadeeSMark Johnston error = sysctlbyname("vm.stats.vm.v_user_wire_count", &wired, &sz, NULL, 156977ceadeeSMark Johnston 0); 157077ceadeeSMark Johnston ATF_REQUIRE_MSG(error == 0, 157177ceadeeSMark Johnston "sysctlbyname(vm.stats.vm.v_user_wire_count) failed; error=%d", 157277ceadeeSMark Johnston errno); 157377ceadeeSMark Johnston 157477ceadeeSMark Johnston pscnt = pagesizes(ps); 157577ceadeeSMark Johnston for (int i = 1; i < pscnt; i++) { 1576d3aabde9SAndrew Turner if (ps[i] / ps[0] > max_wired - wired) { 157777ceadeeSMark Johnston /* Cannot wire past the limit. */ 157877ceadeeSMark Johnston atf_tc_skip("test would exceed wiring limit"); 157977ceadeeSMark Johnston } 158077ceadeeSMark Johnston 158177ceadeeSMark Johnston fd = shm_open_large(i, SHM_LARGEPAGE_ALLOC_DEFAULT, ps[i]); 158277ceadeeSMark Johnston addr = mmap(NULL, ps[i], PROT_READ | PROT_WRITE, MAP_SHARED, fd, 158377ceadeeSMark Johnston 0); 158477ceadeeSMark Johnston ATF_REQUIRE_MSG(addr != MAP_FAILED, 158577ceadeeSMark Johnston "mmap(%zu bytes) failed; error=%d", ps[i], errno); 158677ceadeeSMark Johnston 1587d3aabde9SAndrew Turner ATF_REQUIRE(mlock(addr, ps[0]) != 0); 158877ceadeeSMark Johnston ATF_REQUIRE_MSG(errno == EINVAL, 158977ceadeeSMark Johnston "unexpected error %d from mlock(%zu bytes)", errno, ps[i]); 1590d3aabde9SAndrew Turner ATF_REQUIRE(mlock(addr, ps[i] - ps[0]) != 0); 159177ceadeeSMark Johnston ATF_REQUIRE_MSG(errno == EINVAL, 159277ceadeeSMark Johnston "unexpected error %d from mlock(%zu bytes)", errno, ps[i]); 159377ceadeeSMark Johnston 159477ceadeeSMark Johnston ATF_REQUIRE_MSG(mlock(addr, ps[i]) == 0, 159577ceadeeSMark Johnston "mlock failed; error=%d", errno); 159677ceadeeSMark Johnston 159777ceadeeSMark Johnston ATF_REQUIRE(munmap(addr, ps[i]) == 0); 159877ceadeeSMark Johnston 159977ceadeeSMark Johnston ATF_REQUIRE(mlockall(MCL_FUTURE) == 0); 160077ceadeeSMark Johnston addr = mmap(NULL, ps[i], PROT_READ | PROT_WRITE, MAP_SHARED, fd, 160177ceadeeSMark Johnston 0); 160277ceadeeSMark Johnston ATF_REQUIRE_MSG(addr != MAP_FAILED, 160377ceadeeSMark Johnston "mmap(%zu bytes) failed; error=%d", ps[i], errno); 160477ceadeeSMark Johnston 160577ceadeeSMark Johnston ATF_REQUIRE(munmap(addr, ps[i]) == 0); 160677ceadeeSMark Johnston ATF_REQUIRE(close(fd) == 0); 160777ceadeeSMark Johnston } 160877ceadeeSMark Johnston } 160977ceadeeSMark Johnston 161077ceadeeSMark Johnston ATF_TC_WITHOUT_HEAD(largepage_msync); 161177ceadeeSMark Johnston ATF_TC_BODY(largepage_msync, tc) 161277ceadeeSMark Johnston { 161377ceadeeSMark Johnston char *addr; 161477ceadeeSMark Johnston size_t ps[MAXPAGESIZES]; 161577ceadeeSMark Johnston int fd, pscnt; 161677ceadeeSMark Johnston 161777ceadeeSMark Johnston pscnt = pagesizes(ps); 161877ceadeeSMark Johnston for (int i = 1; i < pscnt; i++) { 161977ceadeeSMark Johnston fd = shm_open_large(i, SHM_LARGEPAGE_ALLOC_DEFAULT, ps[i]); 162077ceadeeSMark Johnston addr = mmap(NULL, ps[i], PROT_READ | PROT_WRITE, MAP_SHARED, fd, 162177ceadeeSMark Johnston 0); 162277ceadeeSMark Johnston ATF_REQUIRE_MSG(addr != MAP_FAILED, 162377ceadeeSMark Johnston "mmap(%zu bytes) failed; error=%d", ps[i], errno); 162477ceadeeSMark Johnston 162577ceadeeSMark Johnston memset(addr, 0, ps[i]); 162677ceadeeSMark Johnston 162777ceadeeSMark Johnston /* 162877ceadeeSMark Johnston * "Sync" requests are no-ops for SHM objects, so small 162977ceadeeSMark Johnston * PAGE_SIZE-sized requests succeed. 163077ceadeeSMark Johnston */ 1631d3aabde9SAndrew Turner ATF_REQUIRE_MSG(msync(addr, ps[0], MS_ASYNC) == 0, 163277ceadeeSMark Johnston "msync(MS_ASYNC) failed; error=%d", errno); 163377ceadeeSMark Johnston ATF_REQUIRE_MSG(msync(addr, ps[i], MS_ASYNC) == 0, 163477ceadeeSMark Johnston "msync(MS_ASYNC) failed; error=%d", errno); 1635d3aabde9SAndrew Turner ATF_REQUIRE_MSG(msync(addr, ps[0], MS_SYNC) == 0, 163677ceadeeSMark Johnston "msync(MS_SYNC) failed; error=%d", errno); 163777ceadeeSMark Johnston ATF_REQUIRE_MSG(msync(addr, ps[i], MS_SYNC) == 0, 163877ceadeeSMark Johnston "msync(MS_SYNC) failed; error=%d", errno); 163977ceadeeSMark Johnston 1640d3aabde9SAndrew Turner ATF_REQUIRE_MSG(msync(addr, ps[0], MS_INVALIDATE) != 0, 164177ceadeeSMark Johnston "msync(MS_INVALIDATE) succeeded"); 164277ceadeeSMark Johnston /* XXX wrong errno */ 164377ceadeeSMark Johnston ATF_REQUIRE_MSG(errno == EBUSY, 164477ceadeeSMark Johnston "unexpected error %d from msync(MS_INVALIDATE)", errno); 164577ceadeeSMark Johnston ATF_REQUIRE_MSG(msync(addr, ps[i], MS_INVALIDATE) == 0, 164677ceadeeSMark Johnston "msync(MS_INVALIDATE) failed; error=%d", errno); 164777ceadeeSMark Johnston memset(addr, 0, ps[i]); 164877ceadeeSMark Johnston 164977ceadeeSMark Johnston ATF_REQUIRE(munmap(addr, ps[i]) == 0); 165077ceadeeSMark Johnston ATF_REQUIRE(close(fd) == 0); 165177ceadeeSMark Johnston } 165277ceadeeSMark Johnston } 165377ceadeeSMark Johnston 165477ceadeeSMark Johnston static void 165577ceadeeSMark Johnston largepage_protect(char *addr, size_t sz, int prot, int error) 165677ceadeeSMark Johnston { 165777ceadeeSMark Johnston if (error == 0) { 165877ceadeeSMark Johnston ATF_REQUIRE_MSG(mprotect(addr, sz, prot) == 0, 165977ceadeeSMark Johnston "mprotect(%zu, %x) failed; error=%d", sz, prot, errno); 166077ceadeeSMark Johnston } else { 166177ceadeeSMark Johnston ATF_REQUIRE_MSG(mprotect(addr, sz, prot) != 0, 166277ceadeeSMark Johnston "mprotect(%zu, %x) succeeded", sz, prot); 166377ceadeeSMark Johnston ATF_REQUIRE_MSG(errno == error, 166477ceadeeSMark Johnston "unexpected error %d from mprotect(%zu, %x)", 166577ceadeeSMark Johnston errno, sz, prot); 166677ceadeeSMark Johnston } 166777ceadeeSMark Johnston } 166877ceadeeSMark Johnston 166977ceadeeSMark Johnston ATF_TC_WITHOUT_HEAD(largepage_mprotect); 167077ceadeeSMark Johnston ATF_TC_BODY(largepage_mprotect, tc) 167177ceadeeSMark Johnston { 167277ceadeeSMark Johnston char *addr, *addr1; 167377ceadeeSMark Johnston size_t ps[MAXPAGESIZES]; 167477ceadeeSMark Johnston int fd, pscnt; 167577ceadeeSMark Johnston 167677ceadeeSMark Johnston pscnt = pagesizes(ps); 167777ceadeeSMark Johnston for (int i = 1; i < pscnt; i++) { 1678321e586eSMark Johnston /* 1679321e586eSMark Johnston * Reserve a contiguous region in the address space to avoid 1680321e586eSMark Johnston * spurious failures in the face of ASLR. 1681321e586eSMark Johnston */ 1682321e586eSMark Johnston addr = mmap(NULL, ps[i] * 2, PROT_NONE, 1683321e586eSMark Johnston MAP_ANON | MAP_ALIGNED(ffsl(ps[i]) - 1), -1, 0); 1684321e586eSMark Johnston ATF_REQUIRE_MSG(addr != MAP_FAILED, 1685321e586eSMark Johnston "mmap(%zu bytes) failed; error=%d", ps[i], errno); 1686321e586eSMark Johnston ATF_REQUIRE(munmap(addr, ps[i] * 2) == 0); 1687321e586eSMark Johnston 168877ceadeeSMark Johnston fd = shm_open_large(i, SHM_LARGEPAGE_ALLOC_DEFAULT, ps[i]); 1689321e586eSMark Johnston addr = mmap(addr, ps[i], PROT_READ | PROT_WRITE, 1690321e586eSMark Johnston MAP_SHARED | MAP_FIXED, fd, 0); 169177ceadeeSMark Johnston ATF_REQUIRE_MSG(addr != MAP_FAILED, 169277ceadeeSMark Johnston "mmap(%zu bytes) failed; error=%d", ps[i], errno); 169377ceadeeSMark Johnston 169477ceadeeSMark Johnston /* 169577ceadeeSMark Johnston * These should be no-ops from the pmap perspective since the 169677ceadeeSMark Johnston * page is not yet entered into the pmap. 169777ceadeeSMark Johnston */ 1698d3aabde9SAndrew Turner largepage_protect(addr, ps[0], PROT_READ, EINVAL); 169977ceadeeSMark Johnston largepage_protect(addr, ps[i], PROT_READ, 0); 1700d3aabde9SAndrew Turner largepage_protect(addr, ps[0], PROT_NONE, EINVAL); 170177ceadeeSMark Johnston largepage_protect(addr, ps[i], PROT_NONE, 0); 1702d3aabde9SAndrew Turner largepage_protect(addr, ps[0], 170377ceadeeSMark Johnston PROT_READ | PROT_WRITE | PROT_EXEC, EINVAL); 170477ceadeeSMark Johnston largepage_protect(addr, ps[i], 170577ceadeeSMark Johnston PROT_READ | PROT_WRITE | PROT_EXEC, 0); 170677ceadeeSMark Johnston 170777ceadeeSMark Johnston /* Trigger creation of a mapping and try again. */ 170877ceadeeSMark Johnston *(volatile char *)addr = 0; 1709d3aabde9SAndrew Turner largepage_protect(addr, ps[0], PROT_READ, EINVAL); 171077ceadeeSMark Johnston largepage_protect(addr, ps[i], PROT_READ, 0); 1711d3aabde9SAndrew Turner largepage_protect(addr, ps[0], PROT_NONE, EINVAL); 171277ceadeeSMark Johnston largepage_protect(addr, ps[i], PROT_NONE, 0); 1713d3aabde9SAndrew Turner largepage_protect(addr, ps[0], 171477ceadeeSMark Johnston PROT_READ | PROT_WRITE | PROT_EXEC, EINVAL); 171577ceadeeSMark Johnston largepage_protect(addr, ps[i], 171677ceadeeSMark Johnston PROT_READ | PROT_WRITE | PROT_EXEC, 0); 171777ceadeeSMark Johnston 171877ceadeeSMark Johnston memset(addr, 0, ps[i]); 171977ceadeeSMark Johnston 172077ceadeeSMark Johnston /* Map two contiguous large pages and merge map entries. */ 172177ceadeeSMark Johnston addr1 = mmap(addr + ps[i], ps[i], PROT_READ | PROT_WRITE, 172277ceadeeSMark Johnston MAP_SHARED | MAP_FIXED | MAP_EXCL, fd, 0); 172377ceadeeSMark Johnston ATF_REQUIRE_MSG(addr1 != MAP_FAILED, 172477ceadeeSMark Johnston "mmap(%zu bytes) failed; error=%d", ps[i], errno); 172577ceadeeSMark Johnston 1726d3aabde9SAndrew Turner largepage_protect(addr1 - ps[0], ps[0] * 2, 172777ceadeeSMark Johnston PROT_READ | PROT_WRITE, EINVAL); 172877ceadeeSMark Johnston largepage_protect(addr, ps[i] * 2, PROT_READ | PROT_WRITE, 0); 172977ceadeeSMark Johnston 173077ceadeeSMark Johnston memset(addr, 0, ps[i] * 2); 173177ceadeeSMark Johnston 173277ceadeeSMark Johnston ATF_REQUIRE(munmap(addr, ps[i]) == 0); 173377ceadeeSMark Johnston ATF_REQUIRE(munmap(addr1, ps[i]) == 0); 173477ceadeeSMark Johnston ATF_REQUIRE(close(fd) == 0); 173577ceadeeSMark Johnston } 173677ceadeeSMark Johnston } 173777ceadeeSMark Johnston 173877ceadeeSMark Johnston ATF_TC_WITHOUT_HEAD(largepage_minherit); 173977ceadeeSMark Johnston ATF_TC_BODY(largepage_minherit, tc) 174077ceadeeSMark Johnston { 174177ceadeeSMark Johnston char *addr; 174277ceadeeSMark Johnston size_t ps[MAXPAGESIZES]; 174377ceadeeSMark Johnston pid_t child; 174477ceadeeSMark Johnston int fd, pscnt, status; 174577ceadeeSMark Johnston 174677ceadeeSMark Johnston pscnt = pagesizes(ps); 174777ceadeeSMark Johnston for (int i = 1; i < pscnt; i++) { 174877ceadeeSMark Johnston fd = shm_open_large(i, SHM_LARGEPAGE_ALLOC_DEFAULT, ps[i]); 174977ceadeeSMark Johnston addr = mmap(NULL, ps[i], PROT_READ | PROT_WRITE, MAP_SHARED, fd, 175077ceadeeSMark Johnston 0); 175177ceadeeSMark Johnston ATF_REQUIRE_MSG(addr != MAP_FAILED, 175277ceadeeSMark Johnston "mmap(%zu bytes) failed; error=%d", ps[i], errno); 175377ceadeeSMark Johnston 1754d3aabde9SAndrew Turner ATF_REQUIRE(minherit(addr, ps[0], INHERIT_SHARE) != 0); 175577ceadeeSMark Johnston 175677ceadeeSMark Johnston ATF_REQUIRE_MSG(minherit(addr, ps[i], INHERIT_SHARE) == 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; 1764d3aabde9SAndrew Turner if (mincore(addr, ps[0], &v) != 0) 176577ceadeeSMark Johnston _exit(1); 1766560f9cd5SMark 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_MSG(minherit(addr, ps[i], INHERIT_NONE) == 0, 177877ceadeeSMark Johnston "minherit(%zu bytes) failed; error=%d", ps[i], errno); 177977ceadeeSMark Johnston child = fork(); 178077ceadeeSMark Johnston ATF_REQUIRE_MSG(child != -1, "fork failed; error=%d", errno); 178177ceadeeSMark Johnston if (child == 0) { 178277ceadeeSMark Johnston char v; 178377ceadeeSMark Johnston 1784d3aabde9SAndrew Turner if (mincore(addr, ps[0], &v) == 0) 178577ceadeeSMark Johnston _exit(1); 178677ceadeeSMark Johnston _exit(0); 178777ceadeeSMark Johnston } 178877ceadeeSMark Johnston ATF_REQUIRE_MSG(waitpid(child, &status, 0) == child, 178977ceadeeSMark Johnston "waitpid failed; error=%d", errno); 179077ceadeeSMark Johnston ATF_REQUIRE_MSG(WIFEXITED(status), 179177ceadeeSMark Johnston "child was killed by signal %d", WTERMSIG(status)); 179277ceadeeSMark Johnston ATF_REQUIRE_MSG(WEXITSTATUS(status) == 0, 179377ceadeeSMark Johnston "child exited with status %d", WEXITSTATUS(status)); 179477ceadeeSMark Johnston 179577ceadeeSMark Johnston /* Copy-on-write is not supported for static large pages. */ 179677ceadeeSMark Johnston ATF_REQUIRE_MSG(minherit(addr, ps[i], INHERIT_COPY) != 0, 179777ceadeeSMark Johnston "minherit(%zu bytes) succeeded", ps[i]); 179877ceadeeSMark Johnston 179977ceadeeSMark Johnston ATF_REQUIRE_MSG(minherit(addr, ps[i], INHERIT_ZERO) == 0, 180077ceadeeSMark Johnston "minherit(%zu bytes) failed; error=%d", ps[i], errno); 180177ceadeeSMark Johnston child = fork(); 180277ceadeeSMark Johnston ATF_REQUIRE_MSG(child != -1, "fork failed; error=%d", errno); 180377ceadeeSMark Johnston if (child == 0) { 180477ceadeeSMark Johnston char v; 180577ceadeeSMark Johnston 180677ceadeeSMark Johnston *(volatile char *)addr = 0; 1807d3aabde9SAndrew Turner if (mincore(addr, ps[0], &v) != 0) 180877ceadeeSMark Johnston _exit(1); 180977ceadeeSMark Johnston if ((v & MINCORE_SUPER) != 0) 181077ceadeeSMark Johnston _exit(2); 181177ceadeeSMark Johnston _exit(0); 181277ceadeeSMark Johnston } 181377ceadeeSMark Johnston ATF_REQUIRE_MSG(waitpid(child, &status, 0) == child, 181477ceadeeSMark Johnston "waitpid failed; error=%d", errno); 181577ceadeeSMark Johnston ATF_REQUIRE_MSG(WIFEXITED(status), 181677ceadeeSMark Johnston "child was killed by signal %d", WTERMSIG(status)); 181777ceadeeSMark Johnston ATF_REQUIRE_MSG(WEXITSTATUS(status) == 0, 181877ceadeeSMark Johnston "child exited with status %d", WEXITSTATUS(status)); 181977ceadeeSMark Johnston 182077ceadeeSMark Johnston ATF_REQUIRE(munmap(addr, ps[i]) == 0); 182177ceadeeSMark Johnston ATF_REQUIRE(close(fd) == 0); 182277ceadeeSMark Johnston } 182377ceadeeSMark Johnston } 182477ceadeeSMark Johnston 182577ceadeeSMark Johnston ATF_TC_WITHOUT_HEAD(largepage_pipe); 182677ceadeeSMark Johnston ATF_TC_BODY(largepage_pipe, tc) 182777ceadeeSMark Johnston { 182877ceadeeSMark Johnston size_t ps[MAXPAGESIZES]; 182977ceadeeSMark Johnston char *addr; 183077ceadeeSMark Johnston ssize_t len; 183177ceadeeSMark Johnston int fd, pfd[2], pscnt, status; 183277ceadeeSMark Johnston pid_t child; 183377ceadeeSMark Johnston 183477ceadeeSMark Johnston pscnt = pagesizes(ps); 183577ceadeeSMark Johnston 183677ceadeeSMark Johnston for (int i = 1; i < pscnt; i++) { 183777ceadeeSMark Johnston fd = shm_open_large(i, SHM_LARGEPAGE_ALLOC_DEFAULT, ps[i]); 183877ceadeeSMark Johnston addr = mmap(NULL, ps[i], PROT_READ | PROT_WRITE, MAP_SHARED, fd, 183977ceadeeSMark Johnston 0); 184077ceadeeSMark Johnston ATF_REQUIRE_MSG(addr != MAP_FAILED, 184177ceadeeSMark Johnston "mmap(%zu bytes) failed; error=%d", ps[i], errno); 184277ceadeeSMark Johnston 184377ceadeeSMark Johnston /* Trigger creation of a mapping. */ 184477ceadeeSMark Johnston *(volatile char *)addr = '\0'; 184577ceadeeSMark Johnston 184677ceadeeSMark Johnston ATF_REQUIRE(pipe(pfd) == 0); 184777ceadeeSMark Johnston child = fork(); 184877ceadeeSMark Johnston ATF_REQUIRE_MSG(child != -1, "fork() failed; error=%d", errno); 184977ceadeeSMark Johnston if (child == 0) { 185077ceadeeSMark Johnston char buf[BUFSIZ]; 185177ceadeeSMark Johnston ssize_t resid; 185277ceadeeSMark Johnston 185377ceadeeSMark Johnston (void)close(pfd[0]); 185477ceadeeSMark Johnston for (resid = (size_t)ps[i]; resid > 0; resid -= len) { 185577ceadeeSMark Johnston len = read(pfd[1], buf, sizeof(buf)); 185677ceadeeSMark Johnston if (len < 0) 185777ceadeeSMark Johnston _exit(1); 185877ceadeeSMark Johnston } 185977ceadeeSMark Johnston _exit(0); 186077ceadeeSMark Johnston } 186177ceadeeSMark Johnston ATF_REQUIRE(close(pfd[1]) == 0); 186277ceadeeSMark Johnston len = write(pfd[0], addr, ps[i]); 186377ceadeeSMark Johnston ATF_REQUIRE_MSG(len >= 0, "write() failed; error=%d", errno); 186477ceadeeSMark Johnston ATF_REQUIRE_MSG(len == (ssize_t)ps[i], 186577ceadeeSMark Johnston "short write; len=%zd", len); 186677ceadeeSMark Johnston ATF_REQUIRE(close(pfd[0]) == 0); 186777ceadeeSMark Johnston 186877ceadeeSMark Johnston ATF_REQUIRE_MSG(waitpid(child, &status, 0) == child, 186977ceadeeSMark Johnston "waitpid() failed; error=%d", errno); 187077ceadeeSMark Johnston ATF_REQUIRE_MSG(WIFEXITED(status), 187177ceadeeSMark Johnston "child was killed by signal %d", WTERMSIG(status)); 187277ceadeeSMark Johnston ATF_REQUIRE_MSG(WEXITSTATUS(status) == 0, 187377ceadeeSMark Johnston "child exited with status %d", WEXITSTATUS(status)); 187477ceadeeSMark Johnston 187577ceadeeSMark Johnston ATF_REQUIRE(munmap(addr, ps[i]) == 0); 187677ceadeeSMark Johnston ATF_REQUIRE(close(fd) == 0); 187777ceadeeSMark Johnston } 187877ceadeeSMark Johnston } 187977ceadeeSMark Johnston 188077ceadeeSMark Johnston ATF_TC_WITHOUT_HEAD(largepage_reopen); 188177ceadeeSMark Johnston ATF_TC_BODY(largepage_reopen, tc) 188277ceadeeSMark Johnston { 188377ceadeeSMark Johnston char *addr, *vec; 188477ceadeeSMark Johnston size_t ps[MAXPAGESIZES]; 188577ceadeeSMark Johnston int fd, psind; 188677ceadeeSMark Johnston 188777ceadeeSMark Johnston (void)pagesizes(ps); 188877ceadeeSMark Johnston psind = 1; 188977ceadeeSMark Johnston 189077ceadeeSMark Johnston gen_test_path(); 189177ceadeeSMark Johnston fd = shm_create_largepage(test_path, O_CREAT | O_RDWR, psind, 189277ceadeeSMark Johnston SHM_LARGEPAGE_ALLOC_DEFAULT, 0600); 189377ceadeeSMark Johnston if (fd < 0 && errno == ENOTTY) 189477ceadeeSMark Johnston atf_tc_skip("no large page support"); 189577ceadeeSMark Johnston ATF_REQUIRE_MSG(fd >= 0, "shm_create_largepage failed; error=%d", errno); 189677ceadeeSMark Johnston 189777ceadeeSMark Johnston ATF_REQUIRE_MSG(ftruncate(fd, ps[psind]) == 0, 189877ceadeeSMark Johnston "ftruncate failed; error=%d", errno); 189977ceadeeSMark Johnston 190077ceadeeSMark Johnston ATF_REQUIRE_MSG(close(fd) == 0, "close failed; error=%d", errno); 190177ceadeeSMark Johnston 190277ceadeeSMark Johnston fd = shm_open(test_path, O_RDWR, 0); 190377ceadeeSMark Johnston ATF_REQUIRE_MSG(fd >= 0, "shm_open failed; error=%d", errno); 190477ceadeeSMark Johnston 190577ceadeeSMark Johnston addr = mmap(NULL, ps[psind], PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0); 190677ceadeeSMark Johnston ATF_REQUIRE_MSG(addr != MAP_FAILED, "mmap failed; error=%d", errno); 190777ceadeeSMark Johnston 190877ceadeeSMark Johnston /* Trigger a fault and mapping creation. */ 190977ceadeeSMark Johnston *(volatile char *)addr = 0; 191077ceadeeSMark Johnston 1911d3aabde9SAndrew Turner vec = malloc(ps[psind] / ps[0]); 191277ceadeeSMark Johnston ATF_REQUIRE(vec != NULL); 191377ceadeeSMark Johnston ATF_REQUIRE_MSG(mincore(addr, ps[psind], vec) == 0, 191477ceadeeSMark Johnston "mincore failed; error=%d", errno); 1915560f9cd5SMark Johnston ATF_REQUIRE_MSG((vec[0] & MINCORE_SUPER) == MINCORE_PSIND(psind), 191677ceadeeSMark Johnston "page not mapped into a %zu-byte superpage", ps[psind]); 191777ceadeeSMark Johnston 191877ceadeeSMark Johnston ATF_REQUIRE_MSG(shm_unlink(test_path) == 0, 191977ceadeeSMark Johnston "shm_unlink failed; errno=%d", errno); 192077ceadeeSMark Johnston ATF_REQUIRE_MSG(close(fd) == 0, 192177ceadeeSMark Johnston "close failed; errno=%d", errno); 192277ceadeeSMark Johnston } 192377ceadeeSMark Johnston 19244fdc3d75SEnji Cooper ATF_TP_ADD_TCS(tp) 19254fdc3d75SEnji Cooper { 19264fdc3d75SEnji Cooper 19274fdc3d75SEnji Cooper ATF_TP_ADD_TC(tp, remap_object); 19289afb12baSDavid Bright ATF_TP_ADD_TC(tp, rename_from_anon); 19299afb12baSDavid Bright ATF_TP_ADD_TC(tp, rename_bad_path_pointer); 19309afb12baSDavid Bright ATF_TP_ADD_TC(tp, rename_from_nonexisting); 19319afb12baSDavid Bright ATF_TP_ADD_TC(tp, rename_to_anon); 19329afb12baSDavid Bright ATF_TP_ADD_TC(tp, rename_to_replace); 19339afb12baSDavid Bright ATF_TP_ADD_TC(tp, rename_to_noreplace); 19349afb12baSDavid Bright ATF_TP_ADD_TC(tp, rename_to_exchange); 19359afb12baSDavid Bright ATF_TP_ADD_TC(tp, rename_to_exchange_nonexisting); 19369afb12baSDavid Bright ATF_TP_ADD_TC(tp, rename_to_self); 19379afb12baSDavid Bright ATF_TP_ADD_TC(tp, rename_bad_flag); 19384fdc3d75SEnji Cooper ATF_TP_ADD_TC(tp, reopen_object); 19394fdc3d75SEnji Cooper ATF_TP_ADD_TC(tp, readonly_mmap_write); 19404fdc3d75SEnji Cooper ATF_TP_ADD_TC(tp, open_after_link); 19414fdc3d75SEnji Cooper ATF_TP_ADD_TC(tp, open_invalid_path); 19424fdc3d75SEnji Cooper ATF_TP_ADD_TC(tp, open_write_only); 19434fdc3d75SEnji Cooper ATF_TP_ADD_TC(tp, open_extra_flags); 19444fdc3d75SEnji Cooper ATF_TP_ADD_TC(tp, open_anon); 19454fdc3d75SEnji Cooper ATF_TP_ADD_TC(tp, open_anon_readonly); 19464fdc3d75SEnji Cooper ATF_TP_ADD_TC(tp, open_bad_path_pointer); 19474fdc3d75SEnji Cooper ATF_TP_ADD_TC(tp, open_path_too_long); 19484fdc3d75SEnji Cooper ATF_TP_ADD_TC(tp, open_nonexisting_object); 19494fdc3d75SEnji Cooper ATF_TP_ADD_TC(tp, open_create_existing_object); 19504fdc3d75SEnji Cooper ATF_TP_ADD_TC(tp, shm_functionality_across_fork); 19514fdc3d75SEnji Cooper ATF_TP_ADD_TC(tp, trunc_resets_object); 19524fdc3d75SEnji Cooper ATF_TP_ADD_TC(tp, unlink_bad_path_pointer); 19534fdc3d75SEnji Cooper ATF_TP_ADD_TC(tp, unlink_path_too_long); 19544fdc3d75SEnji Cooper ATF_TP_ADD_TC(tp, object_resize); 195595aa96f3SKyle Evans ATF_TP_ADD_TC(tp, cloexec); 19565a391b57SKyle Evans ATF_TP_ADD_TC(tp, mode); 1957f1040532SKyle Evans ATF_TP_ADD_TC(tp, fallocate); 1958454bc887SKa Ho Ng ATF_TP_ADD_TC(tp, fspacectl); 195991ddfd35SKonstantin Belousov ATF_TP_ADD_TC(tp, accounting); 196077ceadeeSMark Johnston ATF_TP_ADD_TC(tp, largepage_basic); 196177ceadeeSMark Johnston ATF_TP_ADD_TC(tp, largepage_config); 196277ceadeeSMark Johnston ATF_TP_ADD_TC(tp, largepage_mmap); 196377ceadeeSMark Johnston ATF_TP_ADD_TC(tp, largepage_munmap); 196477ceadeeSMark Johnston ATF_TP_ADD_TC(tp, largepage_madvise); 196577ceadeeSMark Johnston ATF_TP_ADD_TC(tp, largepage_mlock); 196677ceadeeSMark Johnston ATF_TP_ADD_TC(tp, largepage_msync); 196777ceadeeSMark Johnston ATF_TP_ADD_TC(tp, largepage_mprotect); 196877ceadeeSMark Johnston ATF_TP_ADD_TC(tp, largepage_minherit); 196977ceadeeSMark Johnston ATF_TP_ADD_TC(tp, largepage_pipe); 197077ceadeeSMark Johnston ATF_TP_ADD_TC(tp, largepage_reopen); 19714fdc3d75SEnji Cooper 19724fdc3d75SEnji Cooper return (atf_no_error()); 19734fdc3d75SEnji Cooper } 1974