tests/sys/posixshm/posixshm_test.c

   1 /*-
   2  * Copyright (c) 2006 Robert N. M. Watson
   3  * All rights reserved.
   4  *
   5  * Copyright (c) 2021 The FreeBSD Foundation
   6  *
   7  * Portions of this software were developed by Ka Ho Ng
   8  * under sponsorship from the FreeBSD Foundation.
   9  *
  10  * Redistribution and use in source and binary forms, with or without
  11  * modification, are permitted provided that the following conditions
  12  * are met:
  13  * 1. Redistributions of source code must retain the above copyright
  14  *    notice, this list of conditions and the following disclaimer.
  15  * 2. Redistributions in binary form must reproduce the above copyright
  16  *    notice, this list of conditions and the following disclaimer in the
  17  *    documentation and/or other materials provided with the distribution.
  18  *
  19  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
  20  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  21  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  22  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
  23  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  24  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  25  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  26  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  27  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  28  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  29  * SUCH DAMAGE.
  30  */
  31
  32 #include <sys/cdefs.h>
  33 #include <sys/param.h>
  34 #include <sys/ioctl.h>
  35 #include <sys/mman.h>
  36 #include <sys/resource.h>
  37 #include <sys/stat.h>
  38 #include <sys/syscall.h>
  39 #include <sys/sysctl.h>
  40 #include <sys/wait.h>
  41
  42 #include <ctype.h>
  43 #include <errno.h>
  44 #include <fcntl.h>
  45 #include <signal.h>
  46 #include <stdio.h>
  47 #include <stdlib.h>
  48 #include <string.h>
  49 #include <unistd.h>
  50
  51 #include <atf-c.h>
  52
  53 #define TEST_PATH_LEN   256
  54 static char test_path[TEST_PATH_LEN];
  55 static char test_path2[TEST_PATH_LEN];
  56 static unsigned int test_path_idx = 0;
  57
  58 static void
  59 gen_a_test_path(char *path)
  60 {
  61         snprintf(path, TEST_PATH_LEN, "/%s/tmp.XXXXXX%d",
  62             getenv("TMPDIR") == NULL ? "/tmp" : getenv("TMPDIR"),
  63             test_path_idx);
  64
  65         test_path_idx++;
  66
  67         ATF_REQUIRE_MSG(mkstemp(path) != -1,
  68             "mkstemp failed; errno=%d", errno);
  69         ATF_REQUIRE_MSG(unlink(path) == 0,
  70             "unlink failed; errno=%d", errno);
  71 }
  72
  73 static void
  74 gen_test_path(void)
  75 {
  76         gen_a_test_path(test_path);
  77 }
  78
  79 static void
  80 gen_test_path2(void)
  81 {
  82         gen_a_test_path(test_path2);
  83 }
  84
  85 /*
  86  * Attempt a shm_open() that should fail with an expected error of 'error'.
  87  */
  88 static void
  89 shm_open_should_fail(const char *path, int flags, mode_t mode, int error)
  90 {
  91         int fd;
  92
  93         fd = shm_open(path, flags, mode);
  94         ATF_CHECK_MSG(fd == -1, "shm_open didn't fail");
  95         ATF_CHECK_MSG(error == errno,
  96             "shm_open didn't fail with expected errno; errno=%d; expected "
  97             "errno=%d", errno, error);
  98 }
  99
 100 /*
 101  * Attempt a shm_unlink() that should fail with an expected error of 'error'.
 102  */
 103 static void
 104 shm_unlink_should_fail(const char *path, int error)
 105 {
 106
 107         ATF_CHECK_MSG(shm_unlink(path) == -1, "shm_unlink didn't fail");
 108         ATF_CHECK_MSG(error == errno,
 109             "shm_unlink didn't fail with expected errno; errno=%d; expected "
 110             "errno=%d", errno, error);
 111 }
 112
 113 /*
 114  * Open the test object and write a value to the first byte.  Returns valid fd
 115  * on success and -1 on failure.
 116  */
 117 static int
 118 scribble_object(const char *path, char value)
 119 {
 120         char *page;
 121         int fd, pagesize;
 122
 123         ATF_REQUIRE(0 < (pagesize = getpagesize()));
 124
 125         fd = shm_open(path, O_CREAT|O_EXCL|O_RDWR, 0777);
 126         if (fd < 0 && errno == EEXIST) {
 127                 if (shm_unlink(test_path) < 0)
 128                         atf_tc_fail("shm_unlink");
 129                 fd = shm_open(test_path, O_CREAT | O_EXCL | O_RDWR, 0777);
 130         }
 131         if (fd < 0)
 132                 atf_tc_fail("shm_open failed; errno=%d", errno);
 133         if (ftruncate(fd, pagesize) < 0)
 134                 atf_tc_fail("ftruncate failed; errno=%d", errno);
 135
 136         page = mmap(0, pagesize, PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0);
 137         if (page == MAP_FAILED)
 138                 atf_tc_fail("mmap failed; errno=%d", errno);
 139
 140         page[0] = value;
 141         ATF_REQUIRE_MSG(munmap(page, pagesize) == 0, "munmap failed; errno=%d",
 142             errno);
 143
 144         return (fd);
 145 }
 146
 147 /*
 148  * Fail the test case if the 'path' does not refer to an shm whose first byte
 149  * is equal to expected_value
 150  */
 151 static void
 152 verify_object(const char *path, char expected_value)
 153 {
 154         int fd;
 155         int pagesize;
 156         char *page;
 157
 158         ATF_REQUIRE(0 < (pagesize = getpagesize()));
 159
 160         fd = shm_open(path, O_RDONLY, 0777);
 161         if (fd < 0)
 162                 atf_tc_fail("shm_open failed in verify_object; errno=%d, path=%s",
 163                     errno, path);
 164
 165         page = mmap(0, pagesize, PROT_READ, MAP_SHARED, fd, 0);
 166         if (page == MAP_FAILED)
 167                 atf_tc_fail("mmap(1)");
 168         if (page[0] != expected_value)
 169                 atf_tc_fail("Renamed object has incorrect value; has"
 170                     "%d (0x%x, '%c'), expected %d (0x%x, '%c')\n",
 171                     page[0], page[0], isprint(page[0]) ? page[0] : ' ',
 172                     expected_value, expected_value,
 173                     isprint(expected_value) ? expected_value : ' ');
 174         ATF_REQUIRE_MSG(munmap(page, pagesize) == 0, "munmap failed; errno=%d",
 175             errno);
 176         close(fd);
 177 }
 178
 179 static off_t shm_max_pages = 32;
 180 static const char byte_to_fill = 0x5f;
 181
 182 static int
 183 shm_fill(int fd, off_t offset, off_t len)
 184 {
 185         int error;
 186         size_t blen, page_size;
 187         char *buf;
 188
 189         error = 0;
 190         page_size = getpagesize();
 191         buf = malloc(page_size);
 192         if (buf == NULL)
 193                 return (1);
 194
 195         while (len > 0) {
 196                 blen = len < (off_t)page_size ? (size_t)len : page_size;
 197                 memset(buf, byte_to_fill, blen);
 198                 if (pwrite(fd, buf, blen, offset) != (ssize_t)blen) {
 199                         error = 1;
 200                         break;
 201                 }
 202                 len -= blen;
 203                 offset += blen;
 204         }
 205
 206         free(buf);
 207         return (error);
 208 }
 209
 210 static int
 211 check_content_dealloc(int fd, off_t hole_start, off_t hole_len, off_t shm_sz)
 212 {
 213         int error;
 214         size_t blen, page_size;
 215         off_t offset, resid;
 216         struct stat statbuf;
 217         char *buf, *sblk;
 218
 219         error = 0;
 220         page_size = getpagesize();
 221         buf = malloc(page_size * 2);
 222         if (buf == NULL)
 223                 return (1);
 224         sblk = buf + page_size;
 225
 226         memset(sblk, 0, page_size);
 227
 228         if ((uint64_t)hole_start + hole_len > (uint64_t)shm_sz)
 229                 hole_len = shm_sz - hole_start;
 230
 231         /*
 232          * Check hole is zeroed.
 233          */
 234         offset = hole_start;
 235         resid = hole_len;
 236         while (resid > 0) {
 237                 blen = resid < (off_t)page_size ? (size_t)resid : page_size;
 238                 if (pread(fd, buf, blen, offset) != (ssize_t)blen) {
 239                         error = 1;
 240                         break;
 241                 }
 242                 if (memcmp(buf, sblk, blen) != 0) {
 243                         error = 1;
 244                         break;
 245                 }
 246                 resid -= blen;
 247                 offset += blen;
 248         }
 249
 250         memset(sblk, byte_to_fill, page_size);
 251
 252         /*
 253          * Check file region before hole is zeroed.
 254          */
 255         offset = 0;
 256         resid = hole_start;
 257         while (resid > 0) {
 258                 blen = resid < (off_t)page_size ? (size_t)resid : page_size;
 259                 if (pread(fd, buf, blen, offset) != (ssize_t)blen) {
 260                         error = 1;
 261                         break;
 262                 }
 263                 if (memcmp(buf, sblk, blen) != 0) {
 264                         error = 1;
 265                         break;
 266                 }
 267                 resid -= blen;
 268                 offset += blen;
 269         }
 270
 271         /*
 272          * Check file region after hole is zeroed.
 273          */
 274         offset = hole_start + hole_len;
 275         resid = shm_sz - offset;
 276         while (resid > 0) {
 277                 blen = resid < (off_t)page_size ? (size_t)resid : page_size;
 278                 if (pread(fd, buf, blen, offset) != (ssize_t)blen) {
 279                         error = 1;
 280                         break;
 281                 }
 282                 if (memcmp(buf, sblk, blen) != 0) {
 283                         error = 1;
 284                         break;
 285                 }
 286                 resid -= blen;
 287                 offset += blen;
 288         }
 289
 290         /*
 291          * Check file size matches with expected file size.
 292          */
 293         if (fstat(fd, &statbuf) == -1)
 294                 error = -1;
 295         if (statbuf.st_size != shm_sz)
 296                 error = -1;
 297
 298         free(buf);
 299         return (error);
 300 }
 301
 302 ATF_TC_WITHOUT_HEAD(remap_object);
 303 ATF_TC_BODY(remap_object, tc)
 304 {
 305         char *page;
 306         int fd, pagesize;
 307
 308         ATF_REQUIRE(0 < (pagesize = getpagesize()));
 309
 310         gen_test_path();
 311         fd = scribble_object(test_path, '1');
 312
 313         page = mmap(0, pagesize, PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0);
 314         if (page == MAP_FAILED)
 315                 atf_tc_fail("mmap(2) failed; errno=%d", errno);
 316
 317         if (page[0] != '1')
 318                 atf_tc_fail("missing data ('%c' != '1')", page[0]);
 319
 320         close(fd);
 321         ATF_REQUIRE_MSG(munmap(page, pagesize) == 0, "munmap failed; errno=%d",
 322             errno);
 323
 324         ATF_REQUIRE_MSG(shm_unlink(test_path) != -1,
 325             "shm_unlink failed; errno=%d", errno);
 326 }
 327
 328 ATF_TC_WITHOUT_HEAD(rename_from_anon);
 329 ATF_TC_BODY(rename_from_anon, tc)
 330 {
 331         int rc;
 332
 333         gen_test_path();
 334         rc = shm_rename(SHM_ANON, test_path, 0);
 335         if (rc != -1)
 336                 atf_tc_fail("shm_rename from SHM_ANON succeeded unexpectedly");
 337 }
 338
 339 ATF_TC_WITHOUT_HEAD(rename_bad_path_pointer);
 340 ATF_TC_BODY(rename_bad_path_pointer, tc)
 341 {
 342         const char *bad_path;
 343         int rc;
 344
 345         bad_path = (const char *)0x1;
 346
 347         gen_test_path();
 348         rc = shm_rename(test_path, bad_path, 0);
 349         if (rc != -1)
 350                 atf_tc_fail("shm_rename of nonexisting shm succeeded unexpectedly");
 351
 352         rc = shm_rename(bad_path, test_path, 0);
 353         if (rc != -1)
 354                 atf_tc_fail("shm_rename of nonexisting shm succeeded unexpectedly");
 355 }
 356
 357 ATF_TC_WITHOUT_HEAD(rename_from_nonexisting);
 358 ATF_TC_BODY(rename_from_nonexisting, tc)
 359 {
 360         int rc;
 361
 362         gen_test_path();
 363         gen_test_path2();
 364         rc = shm_rename(test_path, test_path2, 0);
 365         if (rc != -1)
 366                 atf_tc_fail("shm_rename of nonexisting shm succeeded unexpectedly");
 367
 368         if (errno != ENOENT)
 369                 atf_tc_fail("Expected ENOENT to rename of nonexistent shm; got %d",
 370                     errno);
 371 }
 372
 373 ATF_TC_WITHOUT_HEAD(rename_to_anon);
 374 ATF_TC_BODY(rename_to_anon, tc)
 375 {
 376         int rc;
 377
 378         gen_test_path();
 379         rc = shm_rename(test_path, SHM_ANON, 0);
 380         if (rc != -1)
 381                 atf_tc_fail("shm_rename to SHM_ANON succeeded unexpectedly");
 382 }
 383
 384 ATF_TC_WITHOUT_HEAD(rename_to_replace);
 385 ATF_TC_BODY(rename_to_replace, tc)
 386 {
 387         char expected_value;
 388         int fd;
 389         int fd2;
 390
 391         // Some contents we can verify later
 392         expected_value = 'g';
 393
 394         gen_test_path();
 395         fd = scribble_object(test_path, expected_value);
 396         close(fd);
 397
 398         // Give the other some different value so we can detect success
 399         gen_test_path2();
 400         fd2 = scribble_object(test_path2, 'h');
 401         close(fd2);
 402
 403         ATF_REQUIRE_MSG(shm_rename(test_path, test_path2, 0) == 0,
 404             "shm_rename failed; errno=%d", errno);
 405
 406         // Read back renamed; verify contents
 407         verify_object(test_path2, expected_value);
 408 }
 409
 410 ATF_TC_WITHOUT_HEAD(rename_to_noreplace);
 411 ATF_TC_BODY(rename_to_noreplace, tc)
 412 {
 413         char expected_value_from;
 414         char expected_value_to;
 415         int fd_from;
 416         int fd_to;
 417         int rc;
 418
 419         // Some contents we can verify later
 420         expected_value_from = 'g';
 421         gen_test_path();
 422         fd_from = scribble_object(test_path, expected_value_from);
 423         close(fd_from);
 424
 425         // Give the other some different value so we can detect success
 426         expected_value_to = 'h';
 427         gen_test_path2();
 428         fd_to = scribble_object(test_path2, expected_value_to);
 429         close(fd_to);
 430
 431         rc = shm_rename(test_path, test_path2, SHM_RENAME_NOREPLACE);
 432         ATF_REQUIRE_MSG((rc == -1) && (errno == EEXIST),
 433             "shm_rename didn't fail as expected; errno: %d; return: %d", errno,
 434             rc);
 435
 436         // Read back renamed; verify contents
 437         verify_object(test_path2, expected_value_to);
 438 }
 439
 440 ATF_TC_WITHOUT_HEAD(rename_to_exchange);
 441 ATF_TC_BODY(rename_to_exchange, tc)
 442 {
 443         char expected_value_from;
 444         char expected_value_to;
 445         int fd_from;
 446         int fd_to;
 447
 448         // Some contents we can verify later
 449         expected_value_from = 'g';
 450         gen_test_path();
 451         fd_from = scribble_object(test_path, expected_value_from);
 452         close(fd_from);
 453
 454         // Give the other some different value so we can detect success
 455         expected_value_to = 'h';
 456         gen_test_path2();
 457         fd_to = scribble_object(test_path2, expected_value_to);
 458         close(fd_to);
 459
 460         ATF_REQUIRE_MSG(shm_rename(test_path, test_path2,
 461             SHM_RENAME_EXCHANGE) == 0,
 462             "shm_rename failed; errno=%d", errno);
 463
 464         // Read back renamed; verify contents
 465         verify_object(test_path, expected_value_to);
 466         verify_object(test_path2, expected_value_from);
 467 }
 468
 469 ATF_TC_WITHOUT_HEAD(rename_to_exchange_nonexisting);
 470 ATF_TC_BODY(rename_to_exchange_nonexisting, tc)
 471 {
 472         char expected_value_from;
 473         int fd_from;
 474
 475         // Some contents we can verify later
 476         expected_value_from = 'g';
 477         gen_test_path();
 478         fd_from = scribble_object(test_path, expected_value_from);
 479         close(fd_from);
 480
 481         gen_test_path2();
 482
 483         ATF_REQUIRE_MSG(shm_rename(test_path, test_path2,
 484             SHM_RENAME_EXCHANGE) == 0,
 485             "shm_rename failed; errno=%d", errno);
 486
 487         // Read back renamed; verify contents
 488         verify_object(test_path2, expected_value_from);
 489 }
 490
 491 ATF_TC_WITHOUT_HEAD(rename_to_self);
 492 ATF_TC_BODY(rename_to_self, tc)
 493 {
 494         int fd;
 495         char expected_value;
 496
 497         expected_value = 't';
 498
 499         gen_test_path();
 500         fd = scribble_object(test_path, expected_value);
 501         close(fd);
 502
 503         ATF_REQUIRE_MSG(shm_rename(test_path, test_path, 0) == 0,
 504             "shm_rename failed; errno=%d", errno);
 505
 506         verify_object(test_path, expected_value);
 507 }
 508
 509 ATF_TC_WITHOUT_HEAD(rename_bad_flag);
 510 ATF_TC_BODY(rename_bad_flag, tc)
 511 {
 512         int fd;
 513         int rc;
 514
 515         /* Make sure we don't fail out due to ENOENT */
 516         gen_test_path();
 517         gen_test_path2();
 518         fd = scribble_object(test_path, 'd');
 519         close(fd);
 520         fd = scribble_object(test_path2, 'd');
 521         close(fd);
 522
 523         /*
 524          * Note: if we end up with enough flags that we use all the bits,
 525          * then remove this test completely.
 526          */
 527         rc = shm_rename(test_path, test_path2, INT_MIN);
 528         ATF_REQUIRE_MSG((rc == -1) && (errno == EINVAL),
 529             "shm_rename should have failed with EINVAL; got: return=%d, "
 530             "errno=%d", rc, errno);
 531 }
 532
 533 ATF_TC_WITHOUT_HEAD(reopen_object);
 534 ATF_TC_BODY(reopen_object, tc)
 535 {
 536         char *page;
 537         int fd, pagesize;
 538
 539         ATF_REQUIRE(0 < (pagesize = getpagesize()));
 540
 541         gen_test_path();
 542         fd = scribble_object(test_path, '1');
 543         close(fd);
 544
 545         fd = shm_open(test_path, O_RDONLY, 0777);
 546         if (fd < 0)
 547                 atf_tc_fail("shm_open(2) failed; errno=%d", errno);
 548
 549         page = mmap(0, pagesize, PROT_READ, MAP_SHARED, fd, 0);
 550         if (page == MAP_FAILED)
 551                 atf_tc_fail("mmap(2) failed; errno=%d", errno);
 552
 553         if (page[0] != '1')
 554                 atf_tc_fail("missing data ('%c' != '1')", page[0]);
 555
 556         ATF_REQUIRE_MSG(munmap(page, pagesize) == 0, "munmap failed; errno=%d",
 557             errno);
 558         close(fd);
 559         ATF_REQUIRE_MSG(shm_unlink(test_path) != -1,
 560             "shm_unlink failed; errno=%d", errno);
 561 }
 562
 563 ATF_TC_WITHOUT_HEAD(readonly_mmap_write);
 564 ATF_TC_BODY(readonly_mmap_write, tc)
 565 {
 566         char *page;
 567         int fd, pagesize;
 568
 569         ATF_REQUIRE(0 < (pagesize = getpagesize()));
 570
 571         gen_test_path();
 572
 573         fd = shm_open(test_path, O_RDONLY | O_CREAT, 0777);
 574         ATF_REQUIRE_MSG(fd >= 0, "shm_open failed; errno=%d", errno);
 575
 576         /* PROT_WRITE should fail with EACCES. */
 577         page = mmap(0, pagesize, PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0);
 578         if (page != MAP_FAILED)
 579                 atf_tc_fail("mmap(PROT_WRITE) succeeded unexpectedly");
 580
 581         if (errno != EACCES)
 582                 atf_tc_fail("mmap(PROT_WRITE) didn't fail with EACCES; "
 583                     "errno=%d", errno);
 584
 585         close(fd);
 586         ATF_REQUIRE_MSG(shm_unlink(test_path) != -1,
 587             "shm_unlink failed; errno=%d", errno);
 588 }
 589
 590 ATF_TC_WITHOUT_HEAD(open_after_link);
 591 ATF_TC_BODY(open_after_link, tc)
 592 {
 593         int fd;
 594
 595         gen_test_path();
 596
 597         fd = shm_open(test_path, O_RDONLY | O_CREAT, 0777);
 598         ATF_REQUIRE_MSG(fd >= 0, "shm_open(1) failed; errno=%d", errno);
 599         close(fd);
 600
 601         ATF_REQUIRE_MSG(shm_unlink(test_path) != -1, "shm_unlink failed: %d",
 602             errno);
 603
 604         shm_open_should_fail(test_path, O_RDONLY, 0777, ENOENT);
 605 }
 606
 607 ATF_TC_WITHOUT_HEAD(open_invalid_path);
 608 ATF_TC_BODY(open_invalid_path, tc)
 609 {
 610
 611         shm_open_should_fail("blah", O_RDONLY, 0777, EINVAL);
 612 }
 613
 614 ATF_TC_WITHOUT_HEAD(open_write_only);
 615 ATF_TC_BODY(open_write_only, tc)
 616 {
 617
 618         gen_test_path();
 619
 620         shm_open_should_fail(test_path, O_WRONLY, 0777, EINVAL);
 621 }
 622
 623 ATF_TC_WITHOUT_HEAD(open_extra_flags);
 624 ATF_TC_BODY(open_extra_flags, tc)
 625 {
 626
 627         gen_test_path();
 628
 629         shm_open_should_fail(test_path, O_RDONLY | O_DIRECT, 0777, EINVAL);
 630 }
 631
 632 ATF_TC_WITHOUT_HEAD(open_anon);
 633 ATF_TC_BODY(open_anon, tc)
 634 {
 635         int fd;
 636
 637         fd = shm_open(SHM_ANON, O_RDWR, 0777);
 638         ATF_REQUIRE_MSG(fd >= 0, "shm_open failed; errno=%d", errno);
 639         close(fd);
 640 }
 641
 642 ATF_TC_WITHOUT_HEAD(open_anon_readonly);
 643 ATF_TC_BODY(open_anon_readonly, tc)
 644 {
 645
 646         shm_open_should_fail(SHM_ANON, O_RDONLY, 0777, EINVAL);
 647 }
 648
 649 ATF_TC_WITHOUT_HEAD(open_bad_path_pointer);
 650 ATF_TC_BODY(open_bad_path_pointer, tc)
 651 {
 652
 653         shm_open_should_fail((char *)1024, O_RDONLY, 0777, EFAULT);
 654 }
 655
 656 ATF_TC_WITHOUT_HEAD(open_path_too_long);
 657 ATF_TC_BODY(open_path_too_long, tc)
 658 {
 659         char *page;
 660
 661         page = malloc(MAXPATHLEN + 1);
 662         memset(page, 'a', MAXPATHLEN);
 663         page[MAXPATHLEN] = '\0';
 664         shm_open_should_fail(page, O_RDONLY, 0777, ENAMETOOLONG);
 665         free(page);
 666 }
 667
 668 ATF_TC_WITHOUT_HEAD(open_nonexisting_object);
 669 ATF_TC_BODY(open_nonexisting_object, tc)
 670 {
 671
 672         shm_open_should_fail("/notreallythere", O_RDONLY, 0777, ENOENT);
 673 }
 674
 675 ATF_TC_WITHOUT_HEAD(open_create_existing_object);
 676 ATF_TC_BODY(open_create_existing_object, tc)
 677 {
 678         int fd;
 679
 680         gen_test_path();
 681
 682         fd = shm_open(test_path, O_RDONLY|O_CREAT, 0777);
 683         ATF_REQUIRE_MSG(fd >= 0, "shm_open failed; errno=%d", errno);
 684         close(fd);
 685
 686         shm_open_should_fail(test_path, O_RDONLY|O_CREAT|O_EXCL,
 687             0777, EEXIST);
 688
 689         ATF_REQUIRE_MSG(shm_unlink(test_path) != -1,
 690             "shm_unlink failed; errno=%d", errno);
 691 }
 692
 693 ATF_TC_WITHOUT_HEAD(trunc_resets_object);
 694 ATF_TC_BODY(trunc_resets_object, tc)
 695 {
 696         struct stat sb;
 697         int fd;
 698
 699         gen_test_path();
 700
 701         /* Create object and set size to 1024. */
 702         fd = shm_open(test_path, O_RDWR | O_CREAT, 0777);
 703         ATF_REQUIRE_MSG(fd >= 0, "shm_open(1) failed; errno=%d", errno);
 704         ATF_REQUIRE_MSG(ftruncate(fd, 1024) != -1,
 705             "ftruncate failed; errno=%d", errno);
 706         ATF_REQUIRE_MSG(fstat(fd, &sb) != -1,
 707             "fstat(1) failed; errno=%d", errno);
 708         ATF_REQUIRE_MSG(sb.st_size == 1024, "size %d != 1024", (int)sb.st_size);
 709         close(fd);
 710
 711         /* Open with O_TRUNC which should reset size to 0. */
 712         fd = shm_open(test_path, O_RDWR | O_TRUNC, 0777);
 713         ATF_REQUIRE_MSG(fd >= 0, "shm_open(2) failed; errno=%d", errno);
 714         ATF_REQUIRE_MSG(fstat(fd, &sb) != -1,
 715             "fstat(2) failed; errno=%d", errno);
 716         ATF_REQUIRE_MSG(sb.st_size == 0,
 717             "size was not 0 after truncation: %d", (int)sb.st_size);
 718         close(fd);
 719         ATF_REQUIRE_MSG(shm_unlink(test_path) != -1,
 720             "shm_unlink failed; errno=%d", errno);
 721 }
 722
 723 ATF_TC_WITHOUT_HEAD(unlink_bad_path_pointer);
 724 ATF_TC_BODY(unlink_bad_path_pointer, tc)
 725 {
 726
 727         shm_unlink_should_fail((char *)1024, EFAULT);
 728 }
 729
 730 ATF_TC_WITHOUT_HEAD(unlink_path_too_long);
 731 ATF_TC_BODY(unlink_path_too_long, tc)
 732 {
 733         char *page;
 734
 735         page = malloc(MAXPATHLEN + 1);
 736         memset(page, 'a', MAXPATHLEN);
 737         page[MAXPATHLEN] = '\0';
 738         shm_unlink_should_fail(page, ENAMETOOLONG);
 739         free(page);
 740 }
 741
 742 ATF_TC_WITHOUT_HEAD(object_resize);
 743 ATF_TC_BODY(object_resize, tc)
 744 {
 745         pid_t pid;
 746         struct stat sb;
 747         char *page;
 748         int fd, pagesize, status;
 749
 750         ATF_REQUIRE(0 < (pagesize = getpagesize()));
 751
 752         /* Start off with a size of a single page. */
 753         fd = shm_open(SHM_ANON, O_CREAT|O_RDWR, 0777);
 754         if (fd < 0)
 755                 atf_tc_fail("shm_open failed; errno=%d", errno);
 756
 757         if (ftruncate(fd, pagesize) < 0)
 758                 atf_tc_fail("ftruncate(1) failed; errno=%d", errno);
 759
 760         if (fstat(fd, &sb) < 0)
 761                 atf_tc_fail("fstat(1) failed; errno=%d", errno);
 762
 763         if (sb.st_size != pagesize)
 764                 atf_tc_fail("first resize failed (%d != %d)",
 765                     (int)sb.st_size, pagesize);
 766
 767         /* Write a '1' to the first byte. */
 768         page = mmap(0, pagesize, PROT_READ|PROT_WRITE, MAP_SHARED, fd, 0);
 769         if (page == MAP_FAILED)
 770                 atf_tc_fail("mmap(1)");
 771
 772         page[0] = '1';
 773
 774         ATF_REQUIRE_MSG(munmap(page, pagesize) == 0, "munmap failed; errno=%d",
 775             errno);
 776
 777         /* Grow the object to 2 pages. */
 778         if (ftruncate(fd, pagesize * 2) < 0)
 779                 atf_tc_fail("ftruncate(2) failed; errno=%d", errno);
 780
 781         if (fstat(fd, &sb) < 0)
 782                 atf_tc_fail("fstat(2) failed; errno=%d", errno);
 783
 784         if (sb.st_size != pagesize * 2)
 785                 atf_tc_fail("second resize failed (%d != %d)",
 786                     (int)sb.st_size, pagesize * 2);
 787
 788         /* Check for '1' at the first byte. */
 789         page = mmap(0, pagesize * 2, PROT_READ|PROT_WRITE, MAP_SHARED, fd, 0);
 790         if (page == MAP_FAILED)
 791                 atf_tc_fail("mmap(2) failed; errno=%d", errno);
 792
 793         if (page[0] != '1')
 794                 atf_tc_fail("'%c' != '1'", page[0]);
 795
 796         /* Write a '2' at the start of the second page. */
 797         page[pagesize] = '2';
 798
 799         /* Shrink the object back to 1 page. */
 800         if (ftruncate(fd, pagesize) < 0)
 801                 atf_tc_fail("ftruncate(3) failed; errno=%d", errno);
 802
 803         if (fstat(fd, &sb) < 0)
 804                 atf_tc_fail("fstat(3) failed; errno=%d", errno);
 805
 806         if (sb.st_size != pagesize)
 807                 atf_tc_fail("third resize failed (%d != %d)",
 808                     (int)sb.st_size, pagesize);
 809
 810         /*
 811          * Fork a child process to make sure the second page is no
 812          * longer valid.
 813          */
 814         pid = fork();
 815         if (pid == -1)
 816                 atf_tc_fail("fork failed; errno=%d", errno);
 817
 818         if (pid == 0) {
 819                 struct rlimit lim;
 820                 char c;
 821
 822                 /* Don't generate a core dump. */
 823                 ATF_REQUIRE(getrlimit(RLIMIT_CORE, &lim) == 0);
 824                 lim.rlim_cur = 0;
 825                 ATF_REQUIRE(setrlimit(RLIMIT_CORE, &lim) == 0);
 826
 827                 /*
 828                  * The previous ftruncate(2) shrunk the backing object
 829                  * so that this address is no longer valid, so reading
 830                  * from it should trigger a SIGBUS.
 831                  */
 832                 c = page[pagesize];
 833                 fprintf(stderr, "child: page 1: '%c'\n", c);
 834                 exit(0);
 835         }
 836
 837         if (wait(&status) < 0)
 838                 atf_tc_fail("wait failed; errno=%d", errno);
 839
 840         if (!WIFSIGNALED(status) || WTERMSIG(status) != SIGBUS)
 841                 atf_tc_fail("child terminated with status %x", status);
 842
 843         /* Grow the object back to 2 pages. */
 844         if (ftruncate(fd, pagesize * 2) < 0)
 845                 atf_tc_fail("ftruncate(2) failed; errno=%d", errno);
 846
 847         if (fstat(fd, &sb) < 0)
 848                 atf_tc_fail("fstat(2) failed; errno=%d", errno);
 849
 850         if (sb.st_size != pagesize * 2)
 851                 atf_tc_fail("fourth resize failed (%d != %d)",
 852                     (int)sb.st_size, pagesize);
 853
 854         /*
 855          * Note that the mapping at 'page' for the second page is
 856          * still valid, and now that the shm object has been grown
 857          * back up to 2 pages, there is now memory backing this page
 858          * so the read will work.  However, the data should be zero
 859          * rather than '2' as the old data was thrown away when the
 860          * object was shrunk and the new pages when an object are
 861          * grown are zero-filled.
 862          */
 863         if (page[pagesize] != 0)
 864                 atf_tc_fail("invalid data at %d: %x != 0",
 865                     pagesize, (int)page[pagesize]);
 866
 867         close(fd);
 868 }
 869
 870 /* Signal handler which does nothing. */
 871 static void
 872 ignoreit(int sig __unused)
 873 {
 874         ;
 875 }
 876
 877 ATF_TC_WITHOUT_HEAD(shm_functionality_across_fork);
 878 ATF_TC_BODY(shm_functionality_across_fork, tc)
 879 {
 880         char *cp, c;
 881         int error, desc, rv;
 882         long scval;
 883         sigset_t ss;
 884         struct sigaction sa;
 885         void *region;
 886         size_t i, psize;
 887
 888 #ifndef _POSIX_SHARED_MEMORY_OBJECTS
 889         printf("_POSIX_SHARED_MEMORY_OBJECTS is undefined\n");
 890 #else
 891         printf("_POSIX_SHARED_MEMORY_OBJECTS is defined as %ld\n",
 892                (long)_POSIX_SHARED_MEMORY_OBJECTS - 0);
 893         if (_POSIX_SHARED_MEMORY_OBJECTS - 0 == -1)
 894                 printf("***Indicates this feature may be unsupported!\n");
 895 #endif
 896         errno = 0;
 897         scval = sysconf(_SC_SHARED_MEMORY_OBJECTS);
 898         if (scval == -1 && errno != 0) {
 899                 atf_tc_fail("sysconf(_SC_SHARED_MEMORY_OBJECTS) failed; "
 900                     "errno=%d", errno);
 901         } else {
 902                 printf("sysconf(_SC_SHARED_MEMORY_OBJECTS) returns %ld\n",
 903                        scval);
 904                 if (scval == -1)
 905                         printf("***Indicates this feature is unsupported!\n");
 906         }
 907
 908         errno = 0;
 909         scval = sysconf(_SC_PAGESIZE);
 910         if (scval == -1 && errno != 0) {
 911                 atf_tc_fail("sysconf(_SC_PAGESIZE) failed; errno=%d", errno);
 912         } else if (scval <= 0) {
 913                 fprintf(stderr, "bogus return from sysconf(_SC_PAGESIZE): %ld",
 914                     scval);
 915                 psize = 4096;
 916         } else {
 917                 printf("sysconf(_SC_PAGESIZE) returns %ld\n", scval);
 918                 psize = scval;
 919         }
 920
 921         gen_test_path();
 922         desc = shm_open(test_path, O_EXCL | O_CREAT | O_RDWR, 0600);
 923
 924         ATF_REQUIRE_MSG(desc >= 0, "shm_open failed; errno=%d", errno);
 925         ATF_REQUIRE_MSG(shm_unlink(test_path) == 0,
 926             "shm_unlink failed; errno=%d", errno);
 927         ATF_REQUIRE_MSG(ftruncate(desc, (off_t)psize) != -1,
 928             "ftruncate failed; errno=%d", errno);
 929
 930         region = mmap(NULL, psize, PROT_READ | PROT_WRITE, MAP_SHARED, desc, 0);
 931         ATF_REQUIRE_MSG(region != MAP_FAILED, "mmap failed; errno=%d", errno);
 932         memset(region, '\377', psize);
 933
 934         sa.sa_flags = 0;
 935         sa.sa_handler = ignoreit;
 936         sigemptyset(&sa.sa_mask);
 937         ATF_REQUIRE_MSG(sigaction(SIGUSR1, &sa, (struct sigaction *)0) == 0,
 938             "sigaction failed; errno=%d", errno);
 939
 940         sigemptyset(&ss);
 941         sigaddset(&ss, SIGUSR1);
 942         ATF_REQUIRE_MSG(sigprocmask(SIG_BLOCK, &ss, (sigset_t *)0) == 0,
 943             "sigprocmask failed; errno=%d", errno);
 944
 945         rv = fork();
 946         ATF_REQUIRE_MSG(rv != -1, "fork failed; errno=%d", errno);
 947         if (rv == 0) {
 948                 sigemptyset(&ss);
 949                 sigsuspend(&ss);
 950
 951                 for (cp = region; cp < (char *)region + psize; cp++) {
 952                         if (*cp != '\151')
 953                                 _exit(1);
 954                 }
 955                 if (lseek(desc, 0, SEEK_SET) == -1)
 956                         _exit(1);
 957                 for (i = 0; i < psize; i++) {
 958                         error = read(desc, &c, 1);
 959                         if (c != '\151')
 960                                 _exit(1);
 961                 }
 962                 _exit(0);
 963         } else {
 964                 int status;
 965
 966                 memset(region, '\151', psize - 2);
 967                 error = pwrite(desc, region, 2, psize - 2);
 968                 if (error != 2) {
 969                         if (error >= 0)
 970                                 atf_tc_fail("short write; %d bytes written",
 971                                     error);
 972                         else
 973                                 atf_tc_fail("shmfd write");
 974                 }
 975                 kill(rv, SIGUSR1);
 976                 waitpid(rv, &status, 0);
 977
 978                 if (WIFEXITED(status) && WEXITSTATUS(status) == 0) {
 979                         printf("Functionality test successful\n");
 980                 } else if (WIFEXITED(status)) {
 981                         atf_tc_fail("Child process exited with status %d",
 982                             WEXITSTATUS(status));
 983                 } else {
 984                         atf_tc_fail("Child process terminated with %s",
 985                             strsignal(WTERMSIG(status)));
 986                 }
 987         }
 988
 989         ATF_REQUIRE_MSG(munmap(region, psize) == 0, "munmap failed; errno=%d",
 990             errno);
 991         shm_unlink(test_path);
 992 }
 993
 994 ATF_TC_WITHOUT_HEAD(cloexec);
 995 ATF_TC_BODY(cloexec, tc)
 996 {
 997         int fd;
 998
 999         gen_test_path();
1000
1001         /* shm_open(2) is required to set FD_CLOEXEC */
1002         fd = shm_open(SHM_ANON, O_RDWR, 0777);
1003         ATF_REQUIRE_MSG(fd >= 0, "shm_open failed; errno=%d", errno);
1004         ATF_REQUIRE((fcntl(fd, F_GETFD) & FD_CLOEXEC) != 0);
1005         close(fd);
1006
1007         /* Also make sure that named shm is correct */
1008         fd = shm_open(test_path, O_CREAT | O_RDWR, 0600);
1009         ATF_REQUIRE_MSG(fd >= 0, "shm_open failed; errno=%d", errno);
1010         ATF_REQUIRE((fcntl(fd, F_GETFD) & FD_CLOEXEC) != 0);
1011         close(fd);
1012 }
1013
1014 ATF_TC_WITHOUT_HEAD(mode);
1015 ATF_TC_BODY(mode, tc)
1016 {
1017         struct stat st;
1018         int fd;
1019         mode_t restore_mask;
1020
1021         gen_test_path();
1022
1023         /* Remove inhibitions from umask */
1024         restore_mask = umask(0);
1025         fd = shm_open(test_path, O_CREAT | O_RDWR, 0600);
1026         ATF_REQUIRE_MSG(fd >= 0, "shm_open failed; errno=%d", errno);
1027         ATF_REQUIRE(fstat(fd, &st) == 0);
1028         ATF_REQUIRE((st.st_mode & ACCESSPERMS) == 0600);
1029         close(fd);
1030         ATF_REQUIRE(shm_unlink(test_path) == 0);
1031
1032         fd = shm_open(test_path, O_CREAT | O_RDWR, 0660);
1033         ATF_REQUIRE_MSG(fd >= 0, "shm_open failed; errno=%d", errno);
1034         ATF_REQUIRE(fstat(fd, &st) == 0);
1035         ATF_REQUIRE((st.st_mode & ACCESSPERMS) == 0660);
1036         close(fd);
1037         ATF_REQUIRE(shm_unlink(test_path) == 0);
1038
1039         fd = shm_open(test_path, O_CREAT | O_RDWR, 0666);
1040         ATF_REQUIRE_MSG(fd >= 0, "shm_open failed; errno=%d", errno);
1041         ATF_REQUIRE(fstat(fd, &st) == 0);
1042         ATF_REQUIRE((st.st_mode & ACCESSPERMS) == 0666);
1043         close(fd);
1044         ATF_REQUIRE(shm_unlink(test_path) == 0);
1045
1046         umask(restore_mask);
1047 }
1048
1049 ATF_TC_WITHOUT_HEAD(fallocate);
1050 ATF_TC_BODY(fallocate, tc)
1051 {
1052         struct stat st;
1053         int error, fd, sz;
1054
1055         /*
1056          * Primitive test case for posix_fallocate with shmd.  Effectively
1057          * expected to work like a smarter ftruncate that will grow the region
1058          * as needed in a race-free way.
1059          */
1060         fd = shm_open(SHM_ANON, O_RDWR, 0666);
1061         ATF_REQUIRE_MSG(fd >= 0, "shm_open failed; errno=%d", errno);
1062         /* Set the initial size. */
1063         sz = 32;
1064         ATF_REQUIRE(ftruncate(fd, sz) == 0);
1065
1066         /* Now grow it. */
1067         error = 0;
1068         sz *= 2;
1069         ATF_REQUIRE_MSG((error = posix_fallocate(fd, 0, sz)) == 0,
1070             "posix_fallocate failed; error=%d", error);
1071         ATF_REQUIRE(fstat(fd, &st) == 0);
1072         ATF_REQUIRE(st.st_size == sz);
1073         /* Attempt to shrink it; should succeed, but not change the size. */
1074         ATF_REQUIRE_MSG((error = posix_fallocate(fd, 0, sz / 2)) == 0,
1075             "posix_fallocate failed; error=%d", error);
1076         ATF_REQUIRE(fstat(fd, &st) == 0);
1077         ATF_REQUIRE(st.st_size == sz);
1078         /* Grow it using an offset of sz and len of sz. */
1079         ATF_REQUIRE_MSG((error = posix_fallocate(fd, sz, sz)) == 0,
1080             "posix_fallocate failed; error=%d", error);
1081         ATF_REQUIRE(fstat(fd, &st) == 0);
1082         ATF_REQUIRE(st.st_size == sz * 2);
1083
1084         close(fd);
1085 }
1086
1087 ATF_TC_WITHOUT_HEAD(fspacectl);
1088 ATF_TC_BODY(fspacectl, tc)
1089 {
1090         struct spacectl_range range;
1091         off_t offset, length, shm_sz;
1092         size_t page_size;
1093         int fd, error;
1094
1095         page_size = getpagesize();
1096         shm_sz = shm_max_pages * page_size;
1097
1098         fd = shm_open("/testtest", O_RDWR | O_CREAT, 0666);
1099         ATF_REQUIRE_MSG(fd >= 0, "shm_open failed; errno:%d", errno);
1100         ATF_REQUIRE_MSG((error = posix_fallocate(fd, 0, shm_sz)) == 0,
1101             "posix_fallocate failed; error=%d", error);
1102
1103         /* Aligned fspacectl(fd, SPACECTL_DEALLOC, ...) */
1104         ATF_REQUIRE(shm_fill(fd, 0, shm_sz) == 0);
1105         range.r_offset = offset = page_size;
1106         range.r_len = length = ((shm_max_pages - 1) * page_size) -
1107             range.r_offset;
1108         ATF_CHECK_MSG(fspacectl(fd, SPACECTL_DEALLOC, &range, 0, &range) == 0,
1109             "Aligned fspacectl failed; errno=%d", errno);
1110         ATF_CHECK_MSG(check_content_dealloc(fd, offset, length, shm_sz) == 0,
1111             "Aligned fspacectl content checking failed");
1112
1113         /* Unaligned fspacectl(fd, SPACECTL_DEALLOC, ...) */
1114         ATF_REQUIRE(shm_fill(fd, 0, shm_sz) == 0);
1115         range.r_offset = offset = page_size / 2;
1116         range.r_len = length = (shm_max_pages - 1) * page_size +
1117             (page_size / 2) - offset;
1118         ATF_CHECK_MSG(fspacectl(fd, SPACECTL_DEALLOC, &range, 0, &range) == 0,
1119             "Unaligned fspacectl failed; errno=%d", errno);
1120         ATF_CHECK_MSG(check_content_dealloc(fd, offset, length, shm_sz) == 0,
1121             "Unaligned fspacectl content checking failed");
1122
1123         /* Aligned fspacectl(fd, SPACECTL_DEALLOC, ...) to OFF_MAX */
1124         ATF_REQUIRE(shm_fill(fd, 0, shm_sz) == 0);
1125         range.r_offset = offset = page_size;
1126         range.r_len = length = OFF_MAX - offset;
1127         ATF_CHECK_MSG(fspacectl(fd, SPACECTL_DEALLOC, &range, 0, &range) == 0,
1128             "Aligned fspacectl to OFF_MAX failed; errno=%d", errno);
1129         ATF_CHECK_MSG(check_content_dealloc(fd, offset, length, shm_sz) == 0,
1130             "Aligned fspacectl to OFF_MAX content checking failed");
1131
1132         /* Unaligned fspacectl(fd, SPACECTL_DEALLOC, ...) to OFF_MAX */
1133         ATF_REQUIRE(shm_fill(fd, 0, shm_sz) == 0);
1134         range.r_offset = offset = page_size / 2;
1135         range.r_len = length = OFF_MAX - offset;
1136         ATF_CHECK_MSG(fspacectl(fd, SPACECTL_DEALLOC, &range, 0, &range) == 0,
1137             "Unaligned fspacectl to OFF_MAX failed; errno=%d", errno);
1138         ATF_CHECK_MSG(check_content_dealloc(fd, offset, length, shm_sz) == 0,
1139             "Unaligned fspacectl to OFF_MAX content checking failed");
1140
1141         /* Aligned fspacectl(fd, SPACECTL_DEALLOC, ...) past shm_sz */
1142         ATF_REQUIRE(shm_fill(fd, 0, shm_sz) == 0);
1143         range.r_offset = offset = page_size;
1144         range.r_len = length = (shm_max_pages + 1) * page_size - offset;
1145         ATF_CHECK_MSG(fspacectl(fd, SPACECTL_DEALLOC, &range, 0, &range) == 0,
1146             "Aligned fspacectl past shm_sz failed; errno=%d", errno);
1147         ATF_CHECK_MSG(check_content_dealloc(fd, offset, length, shm_sz) == 0,
1148             "Aligned fspacectl past shm_sz content checking failed");
1149
1150         /* Unaligned fspacectl(fd, SPACECTL_DEALLOC, ...) past shm_sz */
1151         ATF_REQUIRE(shm_fill(fd, 0, shm_sz) == 0);
1152         range.r_offset = offset = page_size / 2;
1153         range.r_len = length = (shm_max_pages + 1) * page_size - offset;
1154         ATF_CHECK_MSG(fspacectl(fd, SPACECTL_DEALLOC, &range, 0, &range) == 0,
1155             "Unaligned fspacectl past shm_sz failed; errno=%d", errno);
1156         ATF_CHECK_MSG(check_content_dealloc(fd, offset, length, shm_sz) == 0,
1157             "Unaligned fspacectl past shm_sz content checking failed");
1158
1159         ATF_REQUIRE(close(fd) == 0);
1160 }
1161
1162 ATF_TC_WITHOUT_HEAD(accounting);
1163 ATF_TC_BODY(accounting, tc)
1164 {
1165         struct spacectl_range range;
1166         struct stat st;
1167         off_t shm_sz, len;
1168         size_t page_size;
1169         int fd, error;
1170
1171         page_size = getpagesize();
1172         shm_sz = shm_max_pages * page_size;
1173
1174         fd = shm_open("/testtest1", O_RDWR | O_CREAT, 0666);
1175         ATF_REQUIRE_MSG(fd >= 0, "shm_open failed; errno:%d", errno);
1176         ATF_REQUIRE_MSG((error = posix_fallocate(fd, 0, shm_sz)) == 0,
1177             "posix_fallocate failed; error=%d", error);
1178
1179         ATF_REQUIRE(shm_fill(fd, 0, shm_sz) == 0);
1180         ATF_REQUIRE(fstat(fd, &st) == 0);
1181         ATF_REQUIRE(st.st_blksize * st.st_blocks == (blkcnt_t)shm_sz);
1182
1183         range.r_offset = page_size;
1184         range.r_len = len = (shm_max_pages - 1) * page_size -
1185             range.r_offset;
1186         ATF_CHECK_MSG(fspacectl(fd, SPACECTL_DEALLOC, &range, 0, &range) == 0,
1187             "SPACECTL_DEALLOC failed; errno=%d", errno);
1188         ATF_REQUIRE(fstat(fd, &st) == 0);
1189         ATF_REQUIRE(st.st_blksize * st.st_blocks == (blkcnt_t)(shm_sz - len));
1190
1191         ATF_REQUIRE(close(fd) == 0);
1192 }
1193
1194 static int
1195 shm_open_large(int psind, int policy, size_t sz)
1196 {
1197         int error, fd;
1198
1199         fd = shm_create_largepage(SHM_ANON, O_CREAT | O_RDWR, psind, policy, 0);
1200         if (fd < 0 && errno == ENOTTY)
1201                 atf_tc_skip("no large page support");
1202         ATF_REQUIRE_MSG(fd >= 0, "shm_create_largepage failed; errno=%d", errno);
1203
1204         error = ftruncate(fd, sz);
1205         if (error != 0 && errno == ENOMEM)
1206                 /*
1207                  * The test system might not have enough memory to accommodate
1208                  * the request.
1209                  */
1210                 atf_tc_skip("failed to allocate %zu-byte superpage", sz);
1211         ATF_REQUIRE_MSG(error == 0, "ftruncate failed; errno=%d", errno);
1212
1213         return (fd);
1214 }
1215
1216 static int
1217 pagesizes(size_t ps[MAXPAGESIZES])
1218 {
1219         int pscnt;
1220
1221         pscnt = getpagesizes(ps, MAXPAGESIZES);
1222         ATF_REQUIRE_MSG(pscnt != -1, "getpagesizes failed; errno=%d", errno);
1223         ATF_REQUIRE_MSG(ps[0] != 0, "psind 0 is %zu", ps[0]);
1224         ATF_REQUIRE_MSG(pscnt <= MAXPAGESIZES, "invalid pscnt %d", pscnt);
1225         if (pscnt == 1)
1226                 atf_tc_skip("no large page support");
1227         return (pscnt);
1228 }
1229
1230 ATF_TC_WITHOUT_HEAD(largepage_basic);
1231 ATF_TC_BODY(largepage_basic, tc)
1232 {
1233         char *zeroes;
1234         char *addr, *vec;
1235         size_t ps[MAXPAGESIZES];
1236         int error, fd, pscnt;
1237
1238         pscnt = pagesizes(ps);
1239         zeroes = calloc(1, ps[0]);
1240         ATF_REQUIRE(zeroes != NULL);
1241         for (int i = 1; i < pscnt; i++) {
1242                 fd = shm_open_large(i, SHM_LARGEPAGE_ALLOC_DEFAULT, ps[i]);
1243
1244                 addr = mmap(NULL, ps[i], PROT_READ | PROT_WRITE, MAP_SHARED, fd,
1245                     0);
1246                 ATF_REQUIRE_MSG(addr != MAP_FAILED,
1247                     "mmap(%zu bytes) failed; errno=%d", ps[i], errno);
1248                 ATF_REQUIRE_MSG(((uintptr_t)addr & (ps[i] - 1)) == 0,
1249                     "mmap(%zu bytes) returned unaligned mapping; addr=%p",
1250                     ps[i], addr);
1251
1252                 /* Force a page fault. */
1253                 *(volatile char *)addr = 0;
1254
1255                 vec = malloc(ps[i] / ps[0]);
1256                 ATF_REQUIRE(vec != NULL);
1257                 error = mincore(addr, ps[i], vec);
1258                 ATF_REQUIRE_MSG(error == 0, "mincore failed; errno=%d", errno);
1259
1260                 /* Verify that all pages in the run are mapped. */
1261                 for (size_t p = 0; p < ps[i] / ps[0]; p++) {
1262                         ATF_REQUIRE_MSG((vec[p] & MINCORE_INCORE) != 0,
1263                             "page %zu is not mapped", p);
1264                         ATF_REQUIRE_MSG((vec[p] & MINCORE_SUPER) ==
1265                             MINCORE_PSIND(i),
1266                             "page %zu is not in a %zu-byte superpage",
1267                             p, ps[i]);
1268                 }
1269
1270                 /* Validate zeroing. */
1271                 for (size_t p = 0; p < ps[i] / ps[0]; p++) {
1272                         ATF_REQUIRE_MSG(memcmp(addr + p * ps[0], zeroes,
1273                             ps[0]) == 0, "page %zu miscompare", p);
1274                 }
1275
1276                 free(vec);
1277                 ATF_REQUIRE(munmap(addr, ps[i]) == 0);
1278                 ATF_REQUIRE(close(fd) == 0);
1279         }
1280
1281         free(zeroes);
1282 }
1283
1284 extern int __sys_shm_open2(const char *, int, mode_t, int, const char *);
1285
1286 ATF_TC_WITHOUT_HEAD(largepage_config);
1287 ATF_TC_BODY(largepage_config, tc)
1288 {
1289         struct shm_largepage_conf lpc;
1290         char *addr, *buf;
1291         size_t ps[MAXPAGESIZES + 1]; /* silence warnings if MAXPAGESIZES == 1 */
1292         int error, fd;
1293
1294         (void)pagesizes(ps);
1295
1296         fd = shm_open(SHM_ANON, O_CREAT | O_RDWR, 0);
1297         ATF_REQUIRE_MSG(fd >= 0, "shm_open failed; error=%d", errno);
1298
1299         /*
1300          * Configure a large page policy for an object created without
1301          * SHM_LARGEPAGE.
1302          */
1303         lpc.psind = 1;
1304         lpc.alloc_policy = SHM_LARGEPAGE_ALLOC_DEFAULT;
1305         error = ioctl(fd, FIOSSHMLPGCNF, &lpc);
1306         ATF_REQUIRE(error != 0);
1307         ATF_REQUIRE_MSG(errno == ENOTTY, "ioctl(FIOSSHMLPGCNF) returned %d",
1308             errno);
1309         ATF_REQUIRE(close(fd) == 0);
1310
1311         /*
1312          * Create a largepage object and try to use it without actually
1313          * configuring anything.
1314          */
1315         fd = __sys_shm_open2(SHM_ANON, O_CREAT | O_RDWR, 0, SHM_LARGEPAGE,
1316             NULL);
1317         if (fd < 0 && errno == ENOTTY)
1318                 atf_tc_skip("no large page support");
1319         ATF_REQUIRE_MSG(fd >= 0, "shm_open2 failed; error=%d", errno);
1320
1321         error = ftruncate(fd, ps[1]);
1322         ATF_REQUIRE(error != 0);
1323         ATF_REQUIRE_MSG(errno == EINVAL, "ftruncate returned %d", errno);
1324
1325         addr = mmap(NULL, ps[1], PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0);
1326         ATF_REQUIRE(addr == MAP_FAILED);
1327         ATF_REQUIRE_MSG(errno == EINVAL, "mmap returned %d", errno);
1328         addr = mmap(NULL, 0, PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0);
1329         ATF_REQUIRE(addr == MAP_FAILED);
1330         ATF_REQUIRE_MSG(errno == EINVAL, "mmap returned %d", errno);
1331
1332         buf = calloc(1, ps[0]);
1333         ATF_REQUIRE(buf != NULL);
1334         ATF_REQUIRE(write(fd, buf, ps[0]) == -1);
1335         ATF_REQUIRE_MSG(errno == EINVAL, "write returned %d", errno);
1336         free(buf);
1337         buf = calloc(1, ps[1]);
1338         ATF_REQUIRE(buf != NULL);
1339         ATF_REQUIRE(write(fd, buf, ps[1]) == -1);
1340         ATF_REQUIRE_MSG(errno == EINVAL, "write returned %d", errno);
1341         free(buf);
1342
1343         error = posix_fallocate(fd, 0, ps[0]);
1344         ATF_REQUIRE_MSG(error == EINVAL, "posix_fallocate returned %d", error);
1345
1346         ATF_REQUIRE(close(fd) == 0);
1347 }
1348
1349 ATF_TC_WITHOUT_HEAD(largepage_mmap);
1350 ATF_TC_BODY(largepage_mmap, tc)
1351 {
1352         char *addr, *addr1, *vec;
1353         size_t ps[MAXPAGESIZES];
1354         int fd, pscnt;
1355
1356         pscnt = pagesizes(ps);
1357         for (int i = 1; i < pscnt; i++) {
1358                 fd = shm_open_large(i, SHM_LARGEPAGE_ALLOC_DEFAULT, ps[i]);
1359
1360                 /* For mincore(). */
1361                 vec = malloc(ps[i]);
1362                 ATF_REQUIRE(vec != NULL);
1363
1364                 /*
1365                  * Wrong mapping size.
1366                  */
1367                 addr = mmap(NULL, ps[i - 1], PROT_READ | PROT_WRITE, MAP_SHARED,
1368                     fd, 0);
1369                 ATF_REQUIRE_MSG(addr == MAP_FAILED,
1370                     "mmap(%zu bytes) succeeded", ps[i - 1]);
1371                 ATF_REQUIRE_MSG(errno == EINVAL,
1372                     "mmap(%zu bytes) failed; error=%d", ps[i - 1], errno);
1373
1374                 /*
1375                  * Fixed mappings.
1376                  */
1377                 addr = mmap(NULL, ps[i], PROT_READ | PROT_WRITE, MAP_SHARED, fd,
1378                     0);
1379                 ATF_REQUIRE_MSG(addr != MAP_FAILED,
1380                     "mmap(%zu bytes) failed; errno=%d", ps[i], errno);
1381                 ATF_REQUIRE_MSG(((uintptr_t)addr & (ps[i] - 1)) == 0,
1382                     "mmap(%zu bytes) returned unaligned mapping; addr=%p",
1383                     ps[i], addr);
1384
1385                 /* Try mapping a small page with anonymous memory. */
1386                 addr1 = mmap(addr, ps[i - 1], PROT_READ | PROT_WRITE,
1387                     MAP_PRIVATE | MAP_ANON | MAP_FIXED, -1, 0);
1388                 ATF_REQUIRE_MSG(addr1 == MAP_FAILED,
1389                     "anon mmap(%zu bytes) succeeded", ps[i - 1]);
1390                 ATF_REQUIRE_MSG(errno == EINVAL, "mmap returned %d", errno);
1391
1392                 /* Check MAP_EXCL when creating a second largepage mapping. */
1393                 addr1 = mmap(addr, ps[i], PROT_READ | PROT_WRITE,
1394                     MAP_SHARED | MAP_FIXED | MAP_EXCL, fd, 0);
1395                 ATF_REQUIRE_MSG(addr1 == MAP_FAILED,
1396                     "mmap(%zu bytes) succeeded", ps[i]);
1397                 /* XXX wrong errno */
1398                 ATF_REQUIRE_MSG(errno == ENOSPC, "mmap returned %d", errno);
1399
1400                 /* Overwrite a largepage mapping with a lagepage mapping. */
1401                 addr1 = mmap(addr, ps[i], PROT_READ | PROT_WRITE,
1402                     MAP_SHARED | MAP_FIXED, fd, 0);
1403                 ATF_REQUIRE_MSG(addr1 != MAP_FAILED,
1404                     "mmap(%zu bytes) failed; errno=%d", ps[i], errno);
1405                 ATF_REQUIRE_MSG(addr == addr1,
1406                     "mmap(%zu bytes) moved from %p to %p", ps[i], addr, addr1);
1407
1408                 ATF_REQUIRE(munmap(addr, ps[i] == 0));
1409
1410                 /* Clobber an anonymous mapping with a superpage. */
1411                 addr1 = mmap(NULL, ps[0], PROT_READ | PROT_WRITE,
1412                     MAP_ANON | MAP_PRIVATE | MAP_ALIGNED(ffsl(ps[i]) - 1), -1,
1413                     0);
1414                 ATF_REQUIRE_MSG(addr1 != MAP_FAILED,
1415                     "mmap failed; error=%d", errno);
1416                 *(volatile char *)addr1 = '\0';
1417                 addr = mmap(addr1, ps[i], PROT_READ | PROT_WRITE,
1418                     MAP_SHARED | MAP_FIXED, fd, 0);
1419                 ATF_REQUIRE_MSG(addr != MAP_FAILED,
1420                     "mmap failed; error=%d", errno);
1421                 ATF_REQUIRE_MSG(addr == addr1,
1422                     "mmap disobeyed MAP_FIXED, %p %p", addr, addr1);
1423                 *(volatile char *)addr = 0; /* fault */
1424                 ATF_REQUIRE(mincore(addr, ps[i], vec) == 0);
1425                 for (size_t p = 0; p < ps[i] / ps[0]; p++) {
1426                         ATF_REQUIRE_MSG((vec[p] & MINCORE_INCORE) != 0,
1427                             "page %zu is not resident", p);
1428                         ATF_REQUIRE_MSG((vec[p] & MINCORE_SUPER) ==
1429                             MINCORE_PSIND(i),
1430                             "page %zu is not resident", p);
1431                 }
1432
1433                 /*
1434                  * Copy-on-write mappings are not permitted.
1435                  */
1436                 addr = mmap(NULL, ps[i], PROT_READ | PROT_WRITE, MAP_PRIVATE,
1437                     fd, 0);
1438                 ATF_REQUIRE_MSG(addr == MAP_FAILED,
1439                     "mmap(%zu bytes) succeeded", ps[i]);
1440
1441                 ATF_REQUIRE(close(fd) == 0);
1442         }
1443 }
1444
1445 ATF_TC_WITHOUT_HEAD(largepage_munmap);
1446 ATF_TC_BODY(largepage_munmap, tc)
1447 {
1448         char *addr;
1449         size_t ps[MAXPAGESIZES], ps1;
1450         int fd, pscnt;
1451
1452         pscnt = pagesizes(ps);
1453         for (int i = 1; i < pscnt; i++) {
1454                 fd = shm_open_large(i, SHM_LARGEPAGE_ALLOC_DEFAULT, ps[i]);
1455                 ps1 = ps[i - 1];
1456
1457                 addr = mmap(NULL, ps[i], PROT_READ | PROT_WRITE, MAP_SHARED, fd,
1458                     0);
1459                 ATF_REQUIRE_MSG(addr != MAP_FAILED,
1460                     "mmap(%zu bytes) failed; errno=%d", ps[i], errno);
1461
1462                 /* Try several unaligned munmap() requests. */
1463                 ATF_REQUIRE(munmap(addr, ps1) != 0);
1464                 ATF_REQUIRE_MSG(errno == EINVAL,
1465                     "unexpected error %d from munmap", errno);
1466                 ATF_REQUIRE(munmap(addr, ps[i] - ps1));
1467                 ATF_REQUIRE_MSG(errno == EINVAL,
1468                     "unexpected error %d from munmap", errno);
1469                 ATF_REQUIRE(munmap(addr + ps1, ps1) != 0);
1470                 ATF_REQUIRE_MSG(errno == EINVAL,
1471                     "unexpected error %d from munmap", errno);
1472                 ATF_REQUIRE(munmap(addr, 0));
1473                 ATF_REQUIRE_MSG(errno == EINVAL,
1474                     "unexpected error %d from munmap", errno);
1475
1476                 ATF_REQUIRE(munmap(addr, ps[i]) == 0);
1477                 ATF_REQUIRE(close(fd) == 0);
1478         }
1479 }
1480
1481 static void
1482 largepage_madvise(char *addr, size_t sz, int advice, int error)
1483 {
1484         if (error == 0) {
1485                 ATF_REQUIRE_MSG(madvise(addr, sz, advice) == 0,
1486                     "madvise(%zu, %d) failed; error=%d", sz, advice, errno);
1487         } else {
1488                 ATF_REQUIRE_MSG(madvise(addr, sz, advice) != 0,
1489                     "madvise(%zu, %d) succeeded", sz, advice);
1490                 ATF_REQUIRE_MSG(errno == error,
1491                     "unexpected error %d from madvise(%zu, %d)",
1492                     errno, sz, advice);
1493         }
1494 }
1495
1496 ATF_TC_WITHOUT_HEAD(largepage_madvise);
1497 ATF_TC_BODY(largepage_madvise, tc)
1498 {
1499         char *addr;
1500         size_t ps[MAXPAGESIZES];
1501         int fd, pscnt;
1502
1503         pscnt = pagesizes(ps);
1504         for (int i = 1; i < pscnt; i++) {
1505                 fd = shm_open_large(i, SHM_LARGEPAGE_ALLOC_DEFAULT, ps[i]);
1506                 addr = mmap(NULL, ps[i], PROT_READ | PROT_WRITE, MAP_SHARED, fd,
1507                     0);
1508                 ATF_REQUIRE_MSG(addr != MAP_FAILED,
1509                     "mmap(%zu bytes) failed; error=%d", ps[i], errno);
1510
1511                 memset(addr, 0, ps[i]);
1512
1513                 /* Advice that requires clipping. */
1514                 largepage_madvise(addr, ps[0], MADV_NORMAL, EINVAL);
1515                 largepage_madvise(addr, ps[i], MADV_NORMAL, 0);
1516                 largepage_madvise(addr, ps[0], MADV_RANDOM, EINVAL);
1517                 largepage_madvise(addr, ps[i], MADV_RANDOM, 0);
1518                 largepage_madvise(addr, ps[0], MADV_SEQUENTIAL, EINVAL);
1519                 largepage_madvise(addr, ps[i], MADV_SEQUENTIAL, 0);
1520                 largepage_madvise(addr, ps[0], MADV_NOSYNC, EINVAL);
1521                 largepage_madvise(addr, ps[i], MADV_NOSYNC, 0);
1522                 largepage_madvise(addr, ps[0], MADV_AUTOSYNC, EINVAL);
1523                 largepage_madvise(addr, ps[i], MADV_AUTOSYNC, 0);
1524                 largepage_madvise(addr, ps[0], MADV_CORE, EINVAL);
1525                 largepage_madvise(addr, ps[i], MADV_CORE, 0);
1526                 largepage_madvise(addr, ps[0], MADV_NOCORE, EINVAL);
1527                 largepage_madvise(addr, ps[i], MADV_NOCORE, 0);
1528
1529                 /* Advice that does not result in clipping. */
1530                 largepage_madvise(addr, ps[0], MADV_DONTNEED, 0);
1531                 largepage_madvise(addr, ps[i], MADV_DONTNEED, 0);
1532                 largepage_madvise(addr, ps[0], MADV_WILLNEED, 0);
1533                 largepage_madvise(addr, ps[i], MADV_WILLNEED, 0);
1534                 largepage_madvise(addr, ps[0], MADV_FREE, 0);
1535                 largepage_madvise(addr, ps[i], MADV_FREE, 0);
1536
1537                 ATF_REQUIRE(munmap(addr, ps[i]) == 0);
1538                 ATF_REQUIRE(close(fd) == 0);
1539         }
1540 }
1541
1542 ATF_TC(largepage_mlock);
1543 ATF_TC_HEAD(largepage_mlock, tc)
1544 {
1545         /* Needed to set rlimit. */
1546         atf_tc_set_md_var(tc, "require.user", "root");
1547 }
1548 ATF_TC_BODY(largepage_mlock, tc)
1549 {
1550         struct rlimit rl;
1551         char *addr;
1552         size_t ps[MAXPAGESIZES], sz;
1553         u_long max_wired, wired;
1554         int fd, error, pscnt;
1555
1556         rl.rlim_cur = rl.rlim_max = RLIM_INFINITY;
1557         ATF_REQUIRE_MSG(setrlimit(RLIMIT_MEMLOCK, &rl) == 0,
1558             "setrlimit failed; error=%d", errno);
1559
1560         sz = sizeof(max_wired);
1561         error = sysctlbyname("vm.max_user_wired", &max_wired, &sz, NULL, 0);
1562         ATF_REQUIRE_MSG(error == 0,
1563             "sysctlbyname(vm.max_user_wired) failed; error=%d", errno);
1564
1565         sz = sizeof(wired);
1566         error = sysctlbyname("vm.stats.vm.v_user_wire_count", &wired, &sz, NULL,
1567             0);
1568         ATF_REQUIRE_MSG(error == 0,
1569             "sysctlbyname(vm.stats.vm.v_user_wire_count) failed; error=%d",
1570             errno);
1571
1572         pscnt = pagesizes(ps);
1573         for (int i = 1; i < pscnt; i++) {
1574                 if (ps[i] / ps[0] > max_wired - wired) {
1575                         /* Cannot wire past the limit. */
1576                         atf_tc_skip("test would exceed wiring limit");
1577                 }
1578
1579                 fd = shm_open_large(i, SHM_LARGEPAGE_ALLOC_DEFAULT, ps[i]);
1580                 addr = mmap(NULL, ps[i], PROT_READ | PROT_WRITE, MAP_SHARED, fd,
1581                     0);
1582                 ATF_REQUIRE_MSG(addr != MAP_FAILED,
1583                     "mmap(%zu bytes) failed; error=%d", ps[i], errno);
1584
1585                 ATF_REQUIRE(mlock(addr, ps[0]) != 0);
1586                 ATF_REQUIRE_MSG(errno == EINVAL,
1587                     "unexpected error %d from mlock(%zu bytes)", errno, ps[i]);
1588                 ATF_REQUIRE(mlock(addr, ps[i] - ps[0]) != 0);
1589                 ATF_REQUIRE_MSG(errno == EINVAL,
1590                     "unexpected error %d from mlock(%zu bytes)", errno, ps[i]);
1591
1592                 ATF_REQUIRE_MSG(mlock(addr, ps[i]) == 0,
1593                     "mlock failed; error=%d", errno);
1594
1595                 ATF_REQUIRE(munmap(addr, ps[i]) == 0);
1596
1597                 ATF_REQUIRE(mlockall(MCL_FUTURE) == 0);
1598                 addr = mmap(NULL, ps[i], PROT_READ | PROT_WRITE, MAP_SHARED, fd,
1599                     0);
1600                 ATF_REQUIRE_MSG(addr != MAP_FAILED,
1601                     "mmap(%zu bytes) failed; error=%d", ps[i], errno);
1602
1603                 ATF_REQUIRE(munmap(addr, ps[i]) == 0);
1604                 ATF_REQUIRE(close(fd) == 0);
1605         }
1606 }
1607
1608 ATF_TC_WITHOUT_HEAD(largepage_msync);
1609 ATF_TC_BODY(largepage_msync, tc)
1610 {
1611         char *addr;
1612         size_t ps[MAXPAGESIZES];
1613         int fd, pscnt;
1614
1615         pscnt = pagesizes(ps);
1616         for (int i = 1; i < pscnt; i++) {
1617                 fd = shm_open_large(i, SHM_LARGEPAGE_ALLOC_DEFAULT, ps[i]);
1618                 addr = mmap(NULL, ps[i], PROT_READ | PROT_WRITE, MAP_SHARED, fd,
1619                     0);
1620                 ATF_REQUIRE_MSG(addr != MAP_FAILED,
1621                     "mmap(%zu bytes) failed; error=%d", ps[i], errno);
1622
1623                 memset(addr, 0, ps[i]);
1624
1625                 /*
1626                  * "Sync" requests are no-ops for SHM objects, so small
1627                  * PAGE_SIZE-sized requests succeed.
1628                  */
1629                 ATF_REQUIRE_MSG(msync(addr, ps[0], MS_ASYNC) == 0,
1630                     "msync(MS_ASYNC) failed; error=%d", errno);
1631                 ATF_REQUIRE_MSG(msync(addr, ps[i], MS_ASYNC) == 0,
1632                     "msync(MS_ASYNC) failed; error=%d", errno);
1633                 ATF_REQUIRE_MSG(msync(addr, ps[0], MS_SYNC) == 0,
1634                     "msync(MS_SYNC) failed; error=%d", errno);
1635                 ATF_REQUIRE_MSG(msync(addr, ps[i], MS_SYNC) == 0,
1636                     "msync(MS_SYNC) failed; error=%d", errno);
1637
1638                 ATF_REQUIRE_MSG(msync(addr, ps[0], MS_INVALIDATE) != 0,
1639                     "msync(MS_INVALIDATE) succeeded");
1640                 /* XXX wrong errno */
1641                 ATF_REQUIRE_MSG(errno == EBUSY,
1642                     "unexpected error %d from msync(MS_INVALIDATE)", errno);
1643                 ATF_REQUIRE_MSG(msync(addr, ps[i], MS_INVALIDATE) == 0,
1644                     "msync(MS_INVALIDATE) failed; error=%d", errno);
1645                 memset(addr, 0, ps[i]);
1646
1647                 ATF_REQUIRE(munmap(addr, ps[i]) == 0);
1648                 ATF_REQUIRE(close(fd) == 0);
1649         }
1650 }
1651
1652 static void
1653 largepage_protect(char *addr, size_t sz, int prot, int error)
1654 {
1655         if (error == 0) {
1656                 ATF_REQUIRE_MSG(mprotect(addr, sz, prot) == 0,
1657                     "mprotect(%zu, %x) failed; error=%d", sz, prot, errno);
1658         } else {
1659                 ATF_REQUIRE_MSG(mprotect(addr, sz, prot) != 0,
1660                     "mprotect(%zu, %x) succeeded", sz, prot);
1661                 ATF_REQUIRE_MSG(errno == error,
1662                     "unexpected error %d from mprotect(%zu, %x)",
1663                     errno, sz, prot);
1664         }
1665 }
1666
1667 ATF_TC_WITHOUT_HEAD(largepage_mprotect);
1668 ATF_TC_BODY(largepage_mprotect, tc)
1669 {
1670         char *addr, *addr1;
1671         size_t ps[MAXPAGESIZES];
1672         int fd, pscnt;
1673
1674         pscnt = pagesizes(ps);
1675         for (int i = 1; i < pscnt; i++) {
1676                 /*
1677                  * Reserve a contiguous region in the address space to avoid
1678                  * spurious failures in the face of ASLR.
1679                  */
1680                 addr = mmap(NULL, ps[i] * 2, PROT_NONE,
1681                     MAP_ANON | MAP_ALIGNED(ffsl(ps[i]) - 1), -1, 0);
1682                 ATF_REQUIRE_MSG(addr != MAP_FAILED,
1683                     "mmap(%zu bytes) failed; error=%d", ps[i], errno);
1684                 ATF_REQUIRE(munmap(addr, ps[i] * 2) == 0);
1685
1686                 fd = shm_open_large(i, SHM_LARGEPAGE_ALLOC_DEFAULT, ps[i]);
1687                 addr = mmap(addr, ps[i], PROT_READ | PROT_WRITE,
1688                     MAP_SHARED | MAP_FIXED, fd, 0);
1689                 ATF_REQUIRE_MSG(addr != MAP_FAILED,
1690                     "mmap(%zu bytes) failed; error=%d", ps[i], errno);
1691
1692                 /*
1693                  * These should be no-ops from the pmap perspective since the
1694                  * page is not yet entered into the pmap.
1695                  */
1696                 largepage_protect(addr, ps[0], PROT_READ, EINVAL);
1697                 largepage_protect(addr, ps[i], PROT_READ, 0);
1698                 largepage_protect(addr, ps[0], PROT_NONE, EINVAL);
1699                 largepage_protect(addr, ps[i], PROT_NONE, 0);
1700                 largepage_protect(addr, ps[0],
1701                     PROT_READ | PROT_WRITE | PROT_EXEC, EINVAL);
1702                 largepage_protect(addr, ps[i],
1703                     PROT_READ | PROT_WRITE | PROT_EXEC, 0);
1704
1705                 /* Trigger creation of a mapping and try again. */
1706                 *(volatile char *)addr = 0;
1707                 largepage_protect(addr, ps[0], PROT_READ, EINVAL);
1708                 largepage_protect(addr, ps[i], PROT_READ, 0);
1709                 largepage_protect(addr, ps[0], PROT_NONE, EINVAL);
1710                 largepage_protect(addr, ps[i], PROT_NONE, 0);
1711                 largepage_protect(addr, ps[0],
1712                     PROT_READ | PROT_WRITE | PROT_EXEC, EINVAL);
1713                 largepage_protect(addr, ps[i],
1714                     PROT_READ | PROT_WRITE | PROT_EXEC, 0);
1715
1716                 memset(addr, 0, ps[i]);
1717
1718                 /* Map two contiguous large pages and merge map entries. */
1719                 addr1 = mmap(addr + ps[i], ps[i], PROT_READ | PROT_WRITE,
1720                     MAP_SHARED | MAP_FIXED | MAP_EXCL, fd, 0);
1721                 ATF_REQUIRE_MSG(addr1 != MAP_FAILED,
1722                     "mmap(%zu bytes) failed; error=%d", ps[i], errno);
1723
1724                 largepage_protect(addr1 - ps[0], ps[0] * 2,
1725                     PROT_READ | PROT_WRITE, EINVAL);
1726                 largepage_protect(addr, ps[i] * 2, PROT_READ | PROT_WRITE, 0);
1727
1728                 memset(addr, 0, ps[i] * 2);
1729
1730                 ATF_REQUIRE(munmap(addr, ps[i]) == 0);
1731                 ATF_REQUIRE(munmap(addr1, ps[i]) == 0);
1732                 ATF_REQUIRE(close(fd) == 0);
1733         }
1734 }
1735
1736 ATF_TC_WITHOUT_HEAD(largepage_minherit);
1737 ATF_TC_BODY(largepage_minherit, tc)
1738 {
1739         char *addr;
1740         size_t ps[MAXPAGESIZES];
1741         pid_t child;
1742         int fd, pscnt, status;
1743
1744         pscnt = pagesizes(ps);
1745         for (int i = 1; i < pscnt; i++) {
1746                 fd = shm_open_large(i, SHM_LARGEPAGE_ALLOC_DEFAULT, ps[i]);
1747                 addr = mmap(NULL, ps[i], PROT_READ | PROT_WRITE, MAP_SHARED, fd,
1748                     0);
1749                 ATF_REQUIRE_MSG(addr != MAP_FAILED,
1750                     "mmap(%zu bytes) failed; error=%d", ps[i], errno);
1751
1752                 ATF_REQUIRE(minherit(addr, ps[0], INHERIT_SHARE) != 0);
1753
1754                 ATF_REQUIRE_MSG(minherit(addr, ps[i], INHERIT_SHARE) == 0,
1755                     "minherit(%zu bytes) failed; error=%d", ps[i], errno);
1756                 child = fork();
1757                 ATF_REQUIRE_MSG(child != -1, "fork failed; error=%d", errno);
1758                 if (child == 0) {
1759                         char v;
1760
1761                         *(volatile char *)addr = 0;
1762                         if (mincore(addr, ps[0], &v) != 0)
1763                                 _exit(1);
1764                         if ((v & MINCORE_SUPER) == 0)
1765                                 _exit(2);
1766                         _exit(0);
1767                 }
1768                 ATF_REQUIRE_MSG(waitpid(child, &status, 0) == child,
1769                     "waitpid failed; error=%d", errno);
1770                 ATF_REQUIRE_MSG(WIFEXITED(status),
1771                     "child was killed by signal %d", WTERMSIG(status));
1772                 ATF_REQUIRE_MSG(WEXITSTATUS(status) == 0,
1773                     "child exited with status %d", WEXITSTATUS(status));
1774
1775                 ATF_REQUIRE_MSG(minherit(addr, ps[i], INHERIT_NONE) == 0,
1776                     "minherit(%zu bytes) failed; error=%d", ps[i], errno);
1777                 child = fork();
1778                 ATF_REQUIRE_MSG(child != -1, "fork failed; error=%d", errno);
1779                 if (child == 0) {
1780                         char v;
1781
1782                         if (mincore(addr, ps[0], &v) == 0)
1783                                 _exit(1);
1784                         _exit(0);
1785                 }
1786                 ATF_REQUIRE_MSG(waitpid(child, &status, 0) == child,
1787                     "waitpid failed; error=%d", errno);
1788                 ATF_REQUIRE_MSG(WIFEXITED(status),
1789                     "child was killed by signal %d", WTERMSIG(status));
1790                 ATF_REQUIRE_MSG(WEXITSTATUS(status) == 0,
1791                     "child exited with status %d", WEXITSTATUS(status));
1792
1793                 /* Copy-on-write is not supported for static large pages. */
1794                 ATF_REQUIRE_MSG(minherit(addr, ps[i], INHERIT_COPY) != 0,
1795                     "minherit(%zu bytes) succeeded", ps[i]);
1796
1797                 ATF_REQUIRE_MSG(minherit(addr, ps[i], INHERIT_ZERO) == 0,
1798                     "minherit(%zu bytes) failed; error=%d", ps[i], errno);
1799                 child = fork();
1800                 ATF_REQUIRE_MSG(child != -1, "fork failed; error=%d", errno);
1801                 if (child == 0) {
1802                         char v;
1803
1804                         *(volatile char *)addr = 0;
1805                         if (mincore(addr, ps[0], &v) != 0)
1806                                 _exit(1);
1807                         if ((v & MINCORE_SUPER) != 0)
1808                                 _exit(2);
1809                         _exit(0);
1810                 }
1811                 ATF_REQUIRE_MSG(waitpid(child, &status, 0) == child,
1812                     "waitpid failed; error=%d", errno);
1813                 ATF_REQUIRE_MSG(WIFEXITED(status),
1814                     "child was killed by signal %d", WTERMSIG(status));
1815                 ATF_REQUIRE_MSG(WEXITSTATUS(status) == 0,
1816                     "child exited with status %d", WEXITSTATUS(status));
1817
1818                 ATF_REQUIRE(munmap(addr, ps[i]) == 0);
1819                 ATF_REQUIRE(close(fd) == 0);
1820         }
1821 }
1822
1823 ATF_TC_WITHOUT_HEAD(largepage_pipe);
1824 ATF_TC_BODY(largepage_pipe, tc)
1825 {
1826         size_t ps[MAXPAGESIZES];
1827         char *addr;
1828         ssize_t len;
1829         int fd, pfd[2], pscnt, status;
1830         pid_t child;
1831
1832         pscnt = pagesizes(ps);
1833
1834         for (int i = 1; i < pscnt; i++) {
1835                 fd = shm_open_large(i, SHM_LARGEPAGE_ALLOC_DEFAULT, ps[i]);
1836                 addr = mmap(NULL, ps[i], PROT_READ | PROT_WRITE, MAP_SHARED, fd,
1837                     0);
1838                 ATF_REQUIRE_MSG(addr != MAP_FAILED,
1839                     "mmap(%zu bytes) failed; error=%d", ps[i], errno);
1840
1841                 /* Trigger creation of a mapping. */
1842                 *(volatile char *)addr = '\0';
1843
1844                 ATF_REQUIRE(pipe(pfd) == 0);
1845                 child = fork();
1846                 ATF_REQUIRE_MSG(child != -1, "fork() failed; error=%d", errno);
1847                 if (child == 0) {
1848                         char buf[BUFSIZ];
1849                         ssize_t resid;
1850
1851                         (void)close(pfd[0]);
1852                         for (resid = (size_t)ps[i]; resid > 0; resid -= len) {
1853                                 len = read(pfd[1], buf, sizeof(buf));
1854                                 if (len < 0)
1855                                         _exit(1);
1856                         }
1857                         _exit(0);
1858                 }
1859                 ATF_REQUIRE(close(pfd[1]) == 0);
1860                 len = write(pfd[0], addr, ps[i]);
1861                 ATF_REQUIRE_MSG(len >= 0, "write() failed; error=%d", errno);
1862                 ATF_REQUIRE_MSG(len == (ssize_t)ps[i],
1863                     "short write; len=%zd", len);
1864                 ATF_REQUIRE(close(pfd[0]) == 0);
1865
1866                 ATF_REQUIRE_MSG(waitpid(child, &status, 0) == child,
1867                     "waitpid() failed; error=%d", errno);
1868                 ATF_REQUIRE_MSG(WIFEXITED(status),
1869                     "child was killed by signal %d", WTERMSIG(status));
1870                 ATF_REQUIRE_MSG(WEXITSTATUS(status) == 0,
1871                     "child exited with status %d", WEXITSTATUS(status));
1872
1873                 ATF_REQUIRE(munmap(addr, ps[i]) == 0);
1874                 ATF_REQUIRE(close(fd) == 0);
1875         }
1876 }
1877
1878 ATF_TC_WITHOUT_HEAD(largepage_reopen);
1879 ATF_TC_BODY(largepage_reopen, tc)
1880 {
1881         char *addr, *vec;
1882         size_t ps[MAXPAGESIZES];
1883         int fd, psind;
1884
1885         (void)pagesizes(ps);
1886         psind = 1;
1887
1888         gen_test_path();
1889         fd = shm_create_largepage(test_path, O_CREAT | O_RDWR, psind,
1890             SHM_LARGEPAGE_ALLOC_DEFAULT, 0600);
1891         if (fd < 0 && errno == ENOTTY)
1892                 atf_tc_skip("no large page support");
1893         ATF_REQUIRE_MSG(fd >= 0, "shm_create_largepage failed; error=%d", errno);
1894
1895         ATF_REQUIRE_MSG(ftruncate(fd, ps[psind]) == 0,
1896             "ftruncate failed; error=%d", errno);
1897
1898         ATF_REQUIRE_MSG(close(fd) == 0, "close failed; error=%d", errno);
1899
1900         fd = shm_open(test_path, O_RDWR, 0);
1901         ATF_REQUIRE_MSG(fd >= 0, "shm_open failed; error=%d", errno);
1902
1903         addr = mmap(NULL, ps[psind], PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0);
1904         ATF_REQUIRE_MSG(addr != MAP_FAILED, "mmap failed; error=%d", errno);
1905
1906         /* Trigger a fault and mapping creation. */
1907         *(volatile char *)addr = 0;
1908
1909         vec = malloc(ps[psind] / ps[0]);
1910         ATF_REQUIRE(vec != NULL);
1911         ATF_REQUIRE_MSG(mincore(addr, ps[psind], vec) == 0,
1912             "mincore failed; error=%d", errno);
1913         ATF_REQUIRE_MSG((vec[0] & MINCORE_SUPER) == MINCORE_PSIND(psind),
1914             "page not mapped into a %zu-byte superpage", ps[psind]);
1915
1916         ATF_REQUIRE_MSG(shm_unlink(test_path) == 0,
1917             "shm_unlink failed; errno=%d", errno);
1918         ATF_REQUIRE_MSG(close(fd) == 0,
1919             "close failed; errno=%d", errno);
1920 }
1921
1922 ATF_TP_ADD_TCS(tp)
1923 {
1924
1925         ATF_TP_ADD_TC(tp, remap_object);
1926         ATF_TP_ADD_TC(tp, rename_from_anon);
1927         ATF_TP_ADD_TC(tp, rename_bad_path_pointer);
1928         ATF_TP_ADD_TC(tp, rename_from_nonexisting);
1929         ATF_TP_ADD_TC(tp, rename_to_anon);
1930         ATF_TP_ADD_TC(tp, rename_to_replace);
1931         ATF_TP_ADD_TC(tp, rename_to_noreplace);
1932         ATF_TP_ADD_TC(tp, rename_to_exchange);
1933         ATF_TP_ADD_TC(tp, rename_to_exchange_nonexisting);
1934         ATF_TP_ADD_TC(tp, rename_to_self);
1935         ATF_TP_ADD_TC(tp, rename_bad_flag);
1936         ATF_TP_ADD_TC(tp, reopen_object);
1937         ATF_TP_ADD_TC(tp, readonly_mmap_write);
1938         ATF_TP_ADD_TC(tp, open_after_link);
1939         ATF_TP_ADD_TC(tp, open_invalid_path);
1940         ATF_TP_ADD_TC(tp, open_write_only);
1941         ATF_TP_ADD_TC(tp, open_extra_flags);
1942         ATF_TP_ADD_TC(tp, open_anon);
1943         ATF_TP_ADD_TC(tp, open_anon_readonly);
1944         ATF_TP_ADD_TC(tp, open_bad_path_pointer);
1945         ATF_TP_ADD_TC(tp, open_path_too_long);
1946         ATF_TP_ADD_TC(tp, open_nonexisting_object);
1947         ATF_TP_ADD_TC(tp, open_create_existing_object);
1948         ATF_TP_ADD_TC(tp, shm_functionality_across_fork);
1949         ATF_TP_ADD_TC(tp, trunc_resets_object);
1950         ATF_TP_ADD_TC(tp, unlink_bad_path_pointer);
1951         ATF_TP_ADD_TC(tp, unlink_path_too_long);
1952         ATF_TP_ADD_TC(tp, object_resize);
1953         ATF_TP_ADD_TC(tp, cloexec);
1954         ATF_TP_ADD_TC(tp, mode);
1955         ATF_TP_ADD_TC(tp, fallocate);
1956         ATF_TP_ADD_TC(tp, fspacectl);
1957         ATF_TP_ADD_TC(tp, accounting);
1958         ATF_TP_ADD_TC(tp, largepage_basic);
1959         ATF_TP_ADD_TC(tp, largepage_config);
1960         ATF_TP_ADD_TC(tp, largepage_mmap);
1961         ATF_TP_ADD_TC(tp, largepage_munmap);
1962         ATF_TP_ADD_TC(tp, largepage_madvise);
1963         ATF_TP_ADD_TC(tp, largepage_mlock);
1964         ATF_TP_ADD_TC(tp, largepage_msync);
1965         ATF_TP_ADD_TC(tp, largepage_mprotect);
1966         ATF_TP_ADD_TC(tp, largepage_minherit);
1967         ATF_TP_ADD_TC(tp, largepage_pipe);
1968         ATF_TP_ADD_TC(tp, largepage_reopen);
1969
1970         return (atf_no_error());
1971 }