2 * Copyright (c) 2006 Robert N. M. Watson
5 * Copyright (c) 2021 The FreeBSD Foundation
7 * Portions of this software were developed by Ka Ho Ng
8 * under sponsorship from the FreeBSD Foundation.
10 * Redistribution and use in source and binary forms, with or without
11 * modification, are permitted provided that the following conditions
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.
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
32 #include <sys/cdefs.h>
33 __FBSDID("$FreeBSD$");
35 #include <sys/param.h>
36 #include <sys/ioctl.h>
38 #include <sys/resource.h>
40 #include <sys/syscall.h>
41 #include <sys/sysctl.h>
55 #define TEST_PATH_LEN 256
56 static char test_path[TEST_PATH_LEN];
57 static char test_path2[TEST_PATH_LEN];
58 static unsigned int test_path_idx = 0;
61 gen_a_test_path(char *path)
63 snprintf(path, TEST_PATH_LEN, "/%s/tmp.XXXXXX%d",
64 getenv("TMPDIR") == NULL ? "/tmp" : getenv("TMPDIR"),
69 ATF_REQUIRE_MSG(mkstemp(path) != -1,
70 "mkstemp failed; errno=%d", errno);
71 ATF_REQUIRE_MSG(unlink(path) == 0,
72 "unlink failed; errno=%d", errno);
78 gen_a_test_path(test_path);
84 gen_a_test_path(test_path2);
88 * Attempt a shm_open() that should fail with an expected error of 'error'.
91 shm_open_should_fail(const char *path, int flags, mode_t mode, int error)
95 fd = shm_open(path, flags, mode);
96 ATF_CHECK_MSG(fd == -1, "shm_open didn't fail");
97 ATF_CHECK_MSG(error == errno,
98 "shm_open didn't fail with expected errno; errno=%d; expected "
99 "errno=%d", errno, error);
103 * Attempt a shm_unlink() that should fail with an expected error of 'error'.
106 shm_unlink_should_fail(const char *path, int error)
109 ATF_CHECK_MSG(shm_unlink(path) == -1, "shm_unlink didn't fail");
110 ATF_CHECK_MSG(error == errno,
111 "shm_unlink didn't fail with expected errno; errno=%d; expected "
112 "errno=%d", errno, error);
116 * Open the test object and write a value to the first byte. Returns valid fd
117 * on success and -1 on failure.
120 scribble_object(const char *path, char value)
125 ATF_REQUIRE(0 < (pagesize = getpagesize()));
127 fd = shm_open(path, O_CREAT|O_EXCL|O_RDWR, 0777);
128 if (fd < 0 && errno == EEXIST) {
129 if (shm_unlink(test_path) < 0)
130 atf_tc_fail("shm_unlink");
131 fd = shm_open(test_path, O_CREAT | O_EXCL | O_RDWR, 0777);
134 atf_tc_fail("shm_open failed; errno=%d", errno);
135 if (ftruncate(fd, pagesize) < 0)
136 atf_tc_fail("ftruncate failed; errno=%d", errno);
138 page = mmap(0, pagesize, PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0);
139 if (page == MAP_FAILED)
140 atf_tc_fail("mmap failed; errno=%d", errno);
143 ATF_REQUIRE_MSG(munmap(page, pagesize) == 0, "munmap failed; errno=%d",
150 * Fail the test case if the 'path' does not refer to an shm whose first byte
151 * is equal to expected_value
154 verify_object(const char *path, char expected_value)
160 ATF_REQUIRE(0 < (pagesize = getpagesize()));
162 fd = shm_open(path, O_RDONLY, 0777);
164 atf_tc_fail("shm_open failed in verify_object; errno=%d, path=%s",
167 page = mmap(0, pagesize, PROT_READ, MAP_SHARED, fd, 0);
168 if (page == MAP_FAILED)
169 atf_tc_fail("mmap(1)");
170 if (page[0] != expected_value)
171 atf_tc_fail("Renamed object has incorrect value; has"
172 "%d (0x%x, '%c'), expected %d (0x%x, '%c')\n",
173 page[0], page[0], isprint(page[0]) ? page[0] : ' ',
174 expected_value, expected_value,
175 isprint(expected_value) ? expected_value : ' ');
176 ATF_REQUIRE_MSG(munmap(page, pagesize) == 0, "munmap failed; errno=%d",
181 static off_t shm_max_pages = 32;
182 static const char byte_to_fill = 0x5f;
185 shm_fill(int fd, off_t offset, off_t len)
188 size_t blen, page_size;
192 page_size = getpagesize();
193 buf = malloc(page_size);
198 blen = len < (off_t)page_size ? len : page_size;
199 memset(buf, byte_to_fill, blen);
200 if (pwrite(fd, buf, blen, offset) != (ssize_t)blen) {
213 check_content_dealloc(int fd, off_t hole_start, off_t hole_len, off_t shm_sz)
216 size_t blen, page_size;
222 page_size = getpagesize();
223 buf = malloc(page_size * 2);
226 sblk = buf + page_size;
228 memset(sblk, 0, page_size);
230 if ((uint64_t)hole_start + hole_len > (uint64_t)shm_sz)
231 hole_len = shm_sz - hole_start;
234 * Check hole is zeroed.
239 blen = resid < (off_t)page_size ? resid : page_size;
240 if (pread(fd, buf, blen, offset) != (ssize_t)blen) {
244 if (memcmp(buf, sblk, blen) != 0) {
252 memset(sblk, byte_to_fill, page_size);
255 * Check file region before hole is zeroed.
260 blen = resid < (off_t)page_size ? resid : page_size;
261 if (pread(fd, buf, blen, offset) != (ssize_t)blen) {
265 if (memcmp(buf, sblk, blen) != 0) {
274 * Check file region after hole is zeroed.
276 offset = hole_start + hole_len;
277 resid = shm_sz - offset;
279 blen = resid < (off_t)page_size ? resid : page_size;
280 if (pread(fd, buf, blen, offset) != (ssize_t)blen) {
284 if (memcmp(buf, sblk, blen) != 0) {
293 * Check file size matches with expected file size.
295 if (fstat(fd, &statbuf) == -1)
297 if (statbuf.st_size != shm_sz)
304 ATF_TC_WITHOUT_HEAD(remap_object);
305 ATF_TC_BODY(remap_object, tc)
310 ATF_REQUIRE(0 < (pagesize = getpagesize()));
313 fd = scribble_object(test_path, '1');
315 page = mmap(0, pagesize, PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0);
316 if (page == MAP_FAILED)
317 atf_tc_fail("mmap(2) failed; errno=%d", errno);
320 atf_tc_fail("missing data ('%c' != '1')", page[0]);
323 ATF_REQUIRE_MSG(munmap(page, pagesize) == 0, "munmap failed; errno=%d",
326 ATF_REQUIRE_MSG(shm_unlink(test_path) != -1,
327 "shm_unlink failed; errno=%d", errno);
330 ATF_TC_WITHOUT_HEAD(rename_from_anon);
331 ATF_TC_BODY(rename_from_anon, tc)
336 rc = shm_rename(SHM_ANON, test_path, 0);
338 atf_tc_fail("shm_rename from SHM_ANON succeeded unexpectedly");
341 ATF_TC_WITHOUT_HEAD(rename_bad_path_pointer);
342 ATF_TC_BODY(rename_bad_path_pointer, tc)
344 const char *bad_path;
347 bad_path = (const char *)0x1;
350 rc = shm_rename(test_path, bad_path, 0);
352 atf_tc_fail("shm_rename of nonexisting shm succeeded unexpectedly");
354 rc = shm_rename(bad_path, test_path, 0);
356 atf_tc_fail("shm_rename of nonexisting shm succeeded unexpectedly");
359 ATF_TC_WITHOUT_HEAD(rename_from_nonexisting);
360 ATF_TC_BODY(rename_from_nonexisting, tc)
366 rc = shm_rename(test_path, test_path2, 0);
368 atf_tc_fail("shm_rename of nonexisting shm succeeded unexpectedly");
371 atf_tc_fail("Expected ENOENT to rename of nonexistent shm; got %d",
375 ATF_TC_WITHOUT_HEAD(rename_to_anon);
376 ATF_TC_BODY(rename_to_anon, tc)
381 rc = shm_rename(test_path, SHM_ANON, 0);
383 atf_tc_fail("shm_rename to SHM_ANON succeeded unexpectedly");
386 ATF_TC_WITHOUT_HEAD(rename_to_replace);
387 ATF_TC_BODY(rename_to_replace, tc)
393 // Some contents we can verify later
394 expected_value = 'g';
397 fd = scribble_object(test_path, expected_value);
400 // Give the other some different value so we can detect success
402 fd2 = scribble_object(test_path2, 'h');
405 ATF_REQUIRE_MSG(shm_rename(test_path, test_path2, 0) == 0,
406 "shm_rename failed; errno=%d", errno);
408 // Read back renamed; verify contents
409 verify_object(test_path2, expected_value);
412 ATF_TC_WITHOUT_HEAD(rename_to_noreplace);
413 ATF_TC_BODY(rename_to_noreplace, tc)
415 char expected_value_from;
416 char expected_value_to;
421 // Some contents we can verify later
422 expected_value_from = 'g';
424 fd_from = scribble_object(test_path, expected_value_from);
427 // Give the other some different value so we can detect success
428 expected_value_to = 'h';
430 fd_to = scribble_object(test_path2, expected_value_to);
433 rc = shm_rename(test_path, test_path2, SHM_RENAME_NOREPLACE);
434 ATF_REQUIRE_MSG((rc == -1) && (errno == EEXIST),
435 "shm_rename didn't fail as expected; errno: %d; return: %d", errno,
438 // Read back renamed; verify contents
439 verify_object(test_path2, expected_value_to);
442 ATF_TC_WITHOUT_HEAD(rename_to_exchange);
443 ATF_TC_BODY(rename_to_exchange, tc)
445 char expected_value_from;
446 char expected_value_to;
450 // Some contents we can verify later
451 expected_value_from = 'g';
453 fd_from = scribble_object(test_path, expected_value_from);
456 // Give the other some different value so we can detect success
457 expected_value_to = 'h';
459 fd_to = scribble_object(test_path2, expected_value_to);
462 ATF_REQUIRE_MSG(shm_rename(test_path, test_path2,
463 SHM_RENAME_EXCHANGE) == 0,
464 "shm_rename failed; errno=%d", errno);
466 // Read back renamed; verify contents
467 verify_object(test_path, expected_value_to);
468 verify_object(test_path2, expected_value_from);
471 ATF_TC_WITHOUT_HEAD(rename_to_exchange_nonexisting);
472 ATF_TC_BODY(rename_to_exchange_nonexisting, tc)
474 char expected_value_from;
477 // Some contents we can verify later
478 expected_value_from = 'g';
480 fd_from = scribble_object(test_path, expected_value_from);
485 ATF_REQUIRE_MSG(shm_rename(test_path, test_path2,
486 SHM_RENAME_EXCHANGE) == 0,
487 "shm_rename failed; errno=%d", errno);
489 // Read back renamed; verify contents
490 verify_object(test_path2, expected_value_from);
493 ATF_TC_WITHOUT_HEAD(rename_to_self);
494 ATF_TC_BODY(rename_to_self, tc)
499 expected_value = 't';
502 fd = scribble_object(test_path, expected_value);
505 ATF_REQUIRE_MSG(shm_rename(test_path, test_path, 0) == 0,
506 "shm_rename failed; errno=%d", errno);
508 verify_object(test_path, expected_value);
511 ATF_TC_WITHOUT_HEAD(rename_bad_flag);
512 ATF_TC_BODY(rename_bad_flag, tc)
517 /* Make sure we don't fail out due to ENOENT */
520 fd = scribble_object(test_path, 'd');
522 fd = scribble_object(test_path2, 'd');
526 * Note: if we end up with enough flags that we use all the bits,
527 * then remove this test completely.
529 rc = shm_rename(test_path, test_path2, INT_MIN);
530 ATF_REQUIRE_MSG((rc == -1) && (errno == EINVAL),
531 "shm_rename should have failed with EINVAL; got: return=%d, "
532 "errno=%d", rc, errno);
535 ATF_TC_WITHOUT_HEAD(reopen_object);
536 ATF_TC_BODY(reopen_object, tc)
541 ATF_REQUIRE(0 < (pagesize = getpagesize()));
544 fd = scribble_object(test_path, '1');
547 fd = shm_open(test_path, O_RDONLY, 0777);
549 atf_tc_fail("shm_open(2) failed; errno=%d", errno);
551 page = mmap(0, pagesize, PROT_READ, MAP_SHARED, fd, 0);
552 if (page == MAP_FAILED)
553 atf_tc_fail("mmap(2) failed; errno=%d", errno);
556 atf_tc_fail("missing data ('%c' != '1')", page[0]);
558 ATF_REQUIRE_MSG(munmap(page, pagesize) == 0, "munmap failed; errno=%d",
561 ATF_REQUIRE_MSG(shm_unlink(test_path) != -1,
562 "shm_unlink failed; errno=%d", errno);
565 ATF_TC_WITHOUT_HEAD(readonly_mmap_write);
566 ATF_TC_BODY(readonly_mmap_write, tc)
571 ATF_REQUIRE(0 < (pagesize = getpagesize()));
575 fd = shm_open(test_path, O_RDONLY | O_CREAT, 0777);
576 ATF_REQUIRE_MSG(fd >= 0, "shm_open failed; errno=%d", errno);
578 /* PROT_WRITE should fail with EACCES. */
579 page = mmap(0, pagesize, PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0);
580 if (page != MAP_FAILED)
581 atf_tc_fail("mmap(PROT_WRITE) succeeded unexpectedly");
584 atf_tc_fail("mmap(PROT_WRITE) didn't fail with EACCES; "
588 ATF_REQUIRE_MSG(shm_unlink(test_path) != -1,
589 "shm_unlink failed; errno=%d", errno);
592 ATF_TC_WITHOUT_HEAD(open_after_link);
593 ATF_TC_BODY(open_after_link, tc)
599 fd = shm_open(test_path, O_RDONLY | O_CREAT, 0777);
600 ATF_REQUIRE_MSG(fd >= 0, "shm_open(1) failed; errno=%d", errno);
603 ATF_REQUIRE_MSG(shm_unlink(test_path) != -1, "shm_unlink failed: %d",
606 shm_open_should_fail(test_path, O_RDONLY, 0777, ENOENT);
609 ATF_TC_WITHOUT_HEAD(open_invalid_path);
610 ATF_TC_BODY(open_invalid_path, tc)
613 shm_open_should_fail("blah", O_RDONLY, 0777, EINVAL);
616 ATF_TC_WITHOUT_HEAD(open_write_only);
617 ATF_TC_BODY(open_write_only, tc)
622 shm_open_should_fail(test_path, O_WRONLY, 0777, EINVAL);
625 ATF_TC_WITHOUT_HEAD(open_extra_flags);
626 ATF_TC_BODY(open_extra_flags, tc)
631 shm_open_should_fail(test_path, O_RDONLY | O_DIRECT, 0777, EINVAL);
634 ATF_TC_WITHOUT_HEAD(open_anon);
635 ATF_TC_BODY(open_anon, tc)
639 fd = shm_open(SHM_ANON, O_RDWR, 0777);
640 ATF_REQUIRE_MSG(fd >= 0, "shm_open failed; errno=%d", errno);
644 ATF_TC_WITHOUT_HEAD(open_anon_readonly);
645 ATF_TC_BODY(open_anon_readonly, tc)
648 shm_open_should_fail(SHM_ANON, O_RDONLY, 0777, EINVAL);
651 ATF_TC_WITHOUT_HEAD(open_bad_path_pointer);
652 ATF_TC_BODY(open_bad_path_pointer, tc)
655 shm_open_should_fail((char *)1024, O_RDONLY, 0777, EFAULT);
658 ATF_TC_WITHOUT_HEAD(open_path_too_long);
659 ATF_TC_BODY(open_path_too_long, tc)
663 page = malloc(MAXPATHLEN + 1);
664 memset(page, 'a', MAXPATHLEN);
665 page[MAXPATHLEN] = '\0';
666 shm_open_should_fail(page, O_RDONLY, 0777, ENAMETOOLONG);
670 ATF_TC_WITHOUT_HEAD(open_nonexisting_object);
671 ATF_TC_BODY(open_nonexisting_object, tc)
674 shm_open_should_fail("/notreallythere", O_RDONLY, 0777, ENOENT);
677 ATF_TC_WITHOUT_HEAD(open_create_existing_object);
678 ATF_TC_BODY(open_create_existing_object, tc)
684 fd = shm_open(test_path, O_RDONLY|O_CREAT, 0777);
685 ATF_REQUIRE_MSG(fd >= 0, "shm_open failed; errno=%d", errno);
688 shm_open_should_fail(test_path, O_RDONLY|O_CREAT|O_EXCL,
691 ATF_REQUIRE_MSG(shm_unlink(test_path) != -1,
692 "shm_unlink failed; errno=%d", errno);
695 ATF_TC_WITHOUT_HEAD(trunc_resets_object);
696 ATF_TC_BODY(trunc_resets_object, tc)
703 /* Create object and set size to 1024. */
704 fd = shm_open(test_path, O_RDWR | O_CREAT, 0777);
705 ATF_REQUIRE_MSG(fd >= 0, "shm_open(1) failed; errno=%d", errno);
706 ATF_REQUIRE_MSG(ftruncate(fd, 1024) != -1,
707 "ftruncate failed; errno=%d", errno);
708 ATF_REQUIRE_MSG(fstat(fd, &sb) != -1,
709 "fstat(1) failed; errno=%d", errno);
710 ATF_REQUIRE_MSG(sb.st_size == 1024, "size %d != 1024", (int)sb.st_size);
713 /* Open with O_TRUNC which should reset size to 0. */
714 fd = shm_open(test_path, O_RDWR | O_TRUNC, 0777);
715 ATF_REQUIRE_MSG(fd >= 0, "shm_open(2) failed; errno=%d", errno);
716 ATF_REQUIRE_MSG(fstat(fd, &sb) != -1,
717 "fstat(2) failed; errno=%d", errno);
718 ATF_REQUIRE_MSG(sb.st_size == 0,
719 "size was not 0 after truncation: %d", (int)sb.st_size);
721 ATF_REQUIRE_MSG(shm_unlink(test_path) != -1,
722 "shm_unlink failed; errno=%d", errno);
725 ATF_TC_WITHOUT_HEAD(unlink_bad_path_pointer);
726 ATF_TC_BODY(unlink_bad_path_pointer, tc)
729 shm_unlink_should_fail((char *)1024, EFAULT);
732 ATF_TC_WITHOUT_HEAD(unlink_path_too_long);
733 ATF_TC_BODY(unlink_path_too_long, tc)
737 page = malloc(MAXPATHLEN + 1);
738 memset(page, 'a', MAXPATHLEN);
739 page[MAXPATHLEN] = '\0';
740 shm_unlink_should_fail(page, ENAMETOOLONG);
744 ATF_TC_WITHOUT_HEAD(object_resize);
745 ATF_TC_BODY(object_resize, tc)
750 int fd, pagesize, status;
752 ATF_REQUIRE(0 < (pagesize = getpagesize()));
754 /* Start off with a size of a single page. */
755 fd = shm_open(SHM_ANON, O_CREAT|O_RDWR, 0777);
757 atf_tc_fail("shm_open failed; errno=%d", errno);
759 if (ftruncate(fd, pagesize) < 0)
760 atf_tc_fail("ftruncate(1) failed; errno=%d", errno);
762 if (fstat(fd, &sb) < 0)
763 atf_tc_fail("fstat(1) failed; errno=%d", errno);
765 if (sb.st_size != pagesize)
766 atf_tc_fail("first resize failed (%d != %d)",
767 (int)sb.st_size, pagesize);
769 /* Write a '1' to the first byte. */
770 page = mmap(0, pagesize, PROT_READ|PROT_WRITE, MAP_SHARED, fd, 0);
771 if (page == MAP_FAILED)
772 atf_tc_fail("mmap(1)");
776 ATF_REQUIRE_MSG(munmap(page, pagesize) == 0, "munmap failed; errno=%d",
779 /* Grow the object to 2 pages. */
780 if (ftruncate(fd, pagesize * 2) < 0)
781 atf_tc_fail("ftruncate(2) failed; errno=%d", errno);
783 if (fstat(fd, &sb) < 0)
784 atf_tc_fail("fstat(2) failed; errno=%d", errno);
786 if (sb.st_size != pagesize * 2)
787 atf_tc_fail("second resize failed (%d != %d)",
788 (int)sb.st_size, pagesize * 2);
790 /* Check for '1' at the first byte. */
791 page = mmap(0, pagesize * 2, PROT_READ|PROT_WRITE, MAP_SHARED, fd, 0);
792 if (page == MAP_FAILED)
793 atf_tc_fail("mmap(2) failed; errno=%d", errno);
796 atf_tc_fail("'%c' != '1'", page[0]);
798 /* Write a '2' at the start of the second page. */
799 page[pagesize] = '2';
801 /* Shrink the object back to 1 page. */
802 if (ftruncate(fd, pagesize) < 0)
803 atf_tc_fail("ftruncate(3) failed; errno=%d", errno);
805 if (fstat(fd, &sb) < 0)
806 atf_tc_fail("fstat(3) failed; errno=%d", errno);
808 if (sb.st_size != pagesize)
809 atf_tc_fail("third resize failed (%d != %d)",
810 (int)sb.st_size, pagesize);
813 * Fork a child process to make sure the second page is no
818 atf_tc_fail("fork failed; errno=%d", errno);
824 /* Don't generate a core dump. */
825 ATF_REQUIRE(getrlimit(RLIMIT_CORE, &lim) == 0);
827 ATF_REQUIRE(setrlimit(RLIMIT_CORE, &lim) == 0);
830 * The previous ftruncate(2) shrunk the backing object
831 * so that this address is no longer valid, so reading
832 * from it should trigger a SIGBUS.
835 fprintf(stderr, "child: page 1: '%c'\n", c);
839 if (wait(&status) < 0)
840 atf_tc_fail("wait failed; errno=%d", errno);
842 if (!WIFSIGNALED(status) || WTERMSIG(status) != SIGBUS)
843 atf_tc_fail("child terminated with status %x", status);
845 /* Grow the object back to 2 pages. */
846 if (ftruncate(fd, pagesize * 2) < 0)
847 atf_tc_fail("ftruncate(2) failed; errno=%d", errno);
849 if (fstat(fd, &sb) < 0)
850 atf_tc_fail("fstat(2) failed; errno=%d", errno);
852 if (sb.st_size != pagesize * 2)
853 atf_tc_fail("fourth resize failed (%d != %d)",
854 (int)sb.st_size, pagesize);
857 * Note that the mapping at 'page' for the second page is
858 * still valid, and now that the shm object has been grown
859 * back up to 2 pages, there is now memory backing this page
860 * so the read will work. However, the data should be zero
861 * rather than '2' as the old data was thrown away when the
862 * object was shrunk and the new pages when an object are
863 * grown are zero-filled.
865 if (page[pagesize] != 0)
866 atf_tc_fail("invalid data at %d: %x != 0",
867 pagesize, (int)page[pagesize]);
872 /* Signal handler which does nothing. */
874 ignoreit(int sig __unused)
879 ATF_TC_WITHOUT_HEAD(shm_functionality_across_fork);
880 ATF_TC_BODY(shm_functionality_across_fork, tc)
890 #ifndef _POSIX_SHARED_MEMORY_OBJECTS
891 printf("_POSIX_SHARED_MEMORY_OBJECTS is undefined\n");
893 printf("_POSIX_SHARED_MEMORY_OBJECTS is defined as %ld\n",
894 (long)_POSIX_SHARED_MEMORY_OBJECTS - 0);
895 if (_POSIX_SHARED_MEMORY_OBJECTS - 0 == -1)
896 printf("***Indicates this feature may be unsupported!\n");
899 scval = sysconf(_SC_SHARED_MEMORY_OBJECTS);
900 if (scval == -1 && errno != 0) {
901 atf_tc_fail("sysconf(_SC_SHARED_MEMORY_OBJECTS) failed; "
904 printf("sysconf(_SC_SHARED_MEMORY_OBJECTS) returns %ld\n",
907 printf("***Indicates this feature is unsupported!\n");
911 scval = sysconf(_SC_PAGESIZE);
912 if (scval == -1 && errno != 0) {
913 atf_tc_fail("sysconf(_SC_PAGESIZE) failed; errno=%d", errno);
914 } else if (scval <= 0) {
915 fprintf(stderr, "bogus return from sysconf(_SC_PAGESIZE): %ld",
919 printf("sysconf(_SC_PAGESIZE) returns %ld\n", scval);
924 desc = shm_open(test_path, O_EXCL | O_CREAT | O_RDWR, 0600);
926 ATF_REQUIRE_MSG(desc >= 0, "shm_open failed; errno=%d", errno);
927 ATF_REQUIRE_MSG(shm_unlink(test_path) == 0,
928 "shm_unlink failed; errno=%d", errno);
929 ATF_REQUIRE_MSG(ftruncate(desc, (off_t)psize) != -1,
930 "ftruncate failed; errno=%d", errno);
932 region = mmap(NULL, psize, PROT_READ | PROT_WRITE, MAP_SHARED, desc, 0);
933 ATF_REQUIRE_MSG(region != MAP_FAILED, "mmap failed; errno=%d", errno);
934 memset(region, '\377', psize);
937 sa.sa_handler = ignoreit;
938 sigemptyset(&sa.sa_mask);
939 ATF_REQUIRE_MSG(sigaction(SIGUSR1, &sa, (struct sigaction *)0) == 0,
940 "sigaction failed; errno=%d", errno);
943 sigaddset(&ss, SIGUSR1);
944 ATF_REQUIRE_MSG(sigprocmask(SIG_BLOCK, &ss, (sigset_t *)0) == 0,
945 "sigprocmask failed; errno=%d", errno);
948 ATF_REQUIRE_MSG(rv != -1, "fork failed; errno=%d", errno);
953 for (cp = region; cp < (char *)region + psize; cp++) {
957 if (lseek(desc, 0, SEEK_SET) == -1)
959 for (i = 0; i < psize; i++) {
960 error = read(desc, &c, 1);
968 memset(region, '\151', psize - 2);
969 error = pwrite(desc, region, 2, psize - 2);
972 atf_tc_fail("short write; %d bytes written",
975 atf_tc_fail("shmfd write");
978 waitpid(rv, &status, 0);
980 if (WIFEXITED(status) && WEXITSTATUS(status) == 0) {
981 printf("Functionality test successful\n");
982 } else if (WIFEXITED(status)) {
983 atf_tc_fail("Child process exited with status %d",
984 WEXITSTATUS(status));
986 atf_tc_fail("Child process terminated with %s",
987 strsignal(WTERMSIG(status)));
991 ATF_REQUIRE_MSG(munmap(region, psize) == 0, "munmap failed; errno=%d",
993 shm_unlink(test_path);
996 ATF_TC_WITHOUT_HEAD(cloexec);
997 ATF_TC_BODY(cloexec, tc)
1003 /* shm_open(2) is required to set FD_CLOEXEC */
1004 fd = shm_open(SHM_ANON, O_RDWR, 0777);
1005 ATF_REQUIRE_MSG(fd >= 0, "shm_open failed; errno=%d", errno);
1006 ATF_REQUIRE((fcntl(fd, F_GETFD) & FD_CLOEXEC) != 0);
1009 /* Also make sure that named shm is correct */
1010 fd = shm_open(test_path, O_CREAT | O_RDWR, 0600);
1011 ATF_REQUIRE_MSG(fd >= 0, "shm_open failed; errno=%d", errno);
1012 ATF_REQUIRE((fcntl(fd, F_GETFD) & FD_CLOEXEC) != 0);
1016 ATF_TC_WITHOUT_HEAD(mode);
1017 ATF_TC_BODY(mode, tc)
1021 mode_t restore_mask;
1025 /* Remove inhibitions from umask */
1026 restore_mask = umask(0);
1027 fd = shm_open(test_path, O_CREAT | O_RDWR, 0600);
1028 ATF_REQUIRE_MSG(fd >= 0, "shm_open failed; errno=%d", errno);
1029 ATF_REQUIRE(fstat(fd, &st) == 0);
1030 ATF_REQUIRE((st.st_mode & ACCESSPERMS) == 0600);
1032 ATF_REQUIRE(shm_unlink(test_path) == 0);
1034 fd = shm_open(test_path, O_CREAT | O_RDWR, 0660);
1035 ATF_REQUIRE_MSG(fd >= 0, "shm_open failed; errno=%d", errno);
1036 ATF_REQUIRE(fstat(fd, &st) == 0);
1037 ATF_REQUIRE((st.st_mode & ACCESSPERMS) == 0660);
1039 ATF_REQUIRE(shm_unlink(test_path) == 0);
1041 fd = shm_open(test_path, O_CREAT | O_RDWR, 0666);
1042 ATF_REQUIRE_MSG(fd >= 0, "shm_open failed; errno=%d", errno);
1043 ATF_REQUIRE(fstat(fd, &st) == 0);
1044 ATF_REQUIRE((st.st_mode & ACCESSPERMS) == 0666);
1046 ATF_REQUIRE(shm_unlink(test_path) == 0);
1048 umask(restore_mask);
1051 ATF_TC_WITHOUT_HEAD(fallocate);
1052 ATF_TC_BODY(fallocate, tc)
1058 * Primitive test case for posix_fallocate with shmd. Effectively
1059 * expected to work like a smarter ftruncate that will grow the region
1060 * as needed in a race-free way.
1062 fd = shm_open(SHM_ANON, O_RDWR, 0666);
1063 ATF_REQUIRE_MSG(fd >= 0, "shm_open failed; errno=%d", errno);
1064 /* Set the initial size. */
1066 ATF_REQUIRE(ftruncate(fd, sz) == 0);
1071 ATF_REQUIRE_MSG((error = posix_fallocate(fd, 0, sz)) == 0,
1072 "posix_fallocate failed; error=%d", error);
1073 ATF_REQUIRE(fstat(fd, &st) == 0);
1074 ATF_REQUIRE(st.st_size == sz);
1075 /* Attempt to shrink it; should succeed, but not change the size. */
1076 ATF_REQUIRE_MSG((error = posix_fallocate(fd, 0, sz / 2)) == 0,
1077 "posix_fallocate failed; error=%d", error);
1078 ATF_REQUIRE(fstat(fd, &st) == 0);
1079 ATF_REQUIRE(st.st_size == sz);
1080 /* Grow it using an offset of sz and len of sz. */
1081 ATF_REQUIRE_MSG((error = posix_fallocate(fd, sz, sz)) == 0,
1082 "posix_fallocate failed; error=%d", error);
1083 ATF_REQUIRE(fstat(fd, &st) == 0);
1084 ATF_REQUIRE(st.st_size == (sz * 2));
1089 ATF_TC_WITHOUT_HEAD(fspacectl);
1090 ATF_TC_BODY(fspacectl, tc)
1092 struct spacectl_range range;
1093 off_t offset, length, shm_sz;
1097 page_size = getpagesize();
1098 shm_sz = shm_max_pages * page_size;
1100 fd = shm_open("/testtest", O_RDWR|O_CREAT, 0666);
1101 ATF_REQUIRE_MSG(fd >= 0, "shm_open failed; errno:%d", errno);
1102 ATF_REQUIRE_MSG((error = posix_fallocate(fd, 0, shm_sz)) == 0,
1103 "posix_fallocate failed; error=%d", error);
1105 /* Aligned fspacectl(fd, SPACECTL_DEALLOC, ...) */
1106 ATF_REQUIRE(shm_fill(fd, 0, shm_sz) == 0);
1107 range.r_offset = offset = page_size;
1108 range.r_len = length = ((shm_max_pages - 1) * page_size) -
1110 ATF_CHECK_MSG(fspacectl(fd, SPACECTL_DEALLOC, &range, 0, &range) == 0,
1111 "Aligned fspacectl failed; errno=%d", errno);
1112 ATF_CHECK_MSG(check_content_dealloc(fd, offset, length, shm_sz) == 0,
1113 "Aligned fspacectl content checking failed");
1115 /* Unaligned fspacectl(fd, SPACECTL_DEALLOC, ...) */
1116 ATF_REQUIRE(shm_fill(fd, 0, shm_sz) == 0);
1117 range.r_offset = offset = page_size / 2;
1118 range.r_len = length = ((shm_max_pages - 1) * page_size) +
1119 (page_size / 2) - offset;
1120 ATF_CHECK_MSG(fspacectl(fd, SPACECTL_DEALLOC, &range, 0, &range) == 0,
1121 "Unaligned fspacectl failed; errno=%d", errno);
1122 ATF_CHECK_MSG(check_content_dealloc(fd, offset, length, shm_sz) == 0,
1123 "Unaligned fspacectl content checking failed");
1125 /* Aligned fspacectl(fd, SPACECTL_DEALLOC, ...) to OFF_MAX */
1126 ATF_REQUIRE(shm_fill(fd, 0, shm_sz) == 0);
1127 range.r_offset = offset = page_size;
1128 range.r_len = length = OFF_MAX - offset;
1129 ATF_CHECK_MSG(fspacectl(fd, SPACECTL_DEALLOC, &range, 0, &range) == 0,
1130 "Aligned fspacectl to OFF_MAX failed; errno=%d", errno);
1131 ATF_CHECK_MSG(check_content_dealloc(fd, offset, length, shm_sz) == 0,
1132 "Aligned fspacectl to OFF_MAX content checking failed");
1134 /* Unaligned fspacectl(fd, SPACECTL_DEALLOC, ...) to OFF_MAX */
1135 ATF_REQUIRE(shm_fill(fd, 0, shm_sz) == 0);
1136 range.r_offset = offset = page_size / 2;
1137 range.r_len = length = OFF_MAX - offset;
1138 ATF_CHECK_MSG(fspacectl(fd, SPACECTL_DEALLOC, &range, 0, &range) == 0,
1139 "Unaligned fspacectl to OFF_MAX failed; errno=%d", errno);
1140 ATF_CHECK_MSG(check_content_dealloc(fd, offset, length, shm_sz) == 0,
1141 "Unaligned fspacectl to OFF_MAX content checking failed");
1143 /* Aligned fspacectl(fd, SPACECTL_DEALLOC, ...) past shm_sz */
1144 ATF_REQUIRE(shm_fill(fd, 0, shm_sz) == 0);
1145 range.r_offset = offset = page_size;
1146 range.r_len = length = ((shm_max_pages + 1) * page_size) - offset;
1147 ATF_CHECK_MSG(fspacectl(fd, SPACECTL_DEALLOC, &range, 0, &range) == 0,
1148 "Aligned fspacectl past shm_sz failed; errno=%d", errno);
1149 ATF_CHECK_MSG(check_content_dealloc(fd, offset, length, shm_sz) == 0,
1150 "Aligned fspacectl past shm_sz content checking failed");
1152 /* Unaligned fspacectl(fd, SPACECTL_DEALLOC, ...) past shm_sz */
1153 ATF_REQUIRE(shm_fill(fd, 0, shm_sz) == 0);
1154 range.r_offset = offset = page_size / 2;
1155 range.r_len = length = ((shm_max_pages + 1) * page_size) - offset;
1156 ATF_CHECK_MSG(fspacectl(fd, SPACECTL_DEALLOC, &range, 0, &range) == 0,
1157 "Unaligned fspacectl past shm_sz failed; errno=%d", errno);
1158 ATF_CHECK_MSG(check_content_dealloc(fd, offset, length, shm_sz) == 0,
1159 "Unaligned fspacectl past shm_sz content checking failed");
1161 ATF_REQUIRE(close(fd) == 0);
1165 shm_open_large(int psind, int policy, size_t sz)
1169 fd = shm_create_largepage(SHM_ANON, O_CREAT | O_RDWR, psind, policy, 0);
1170 if (fd < 0 && errno == ENOTTY)
1171 atf_tc_skip("no large page support");
1172 ATF_REQUIRE_MSG(fd >= 0, "shm_create_largepage failed; errno=%d", errno);
1174 error = ftruncate(fd, sz);
1175 if (error != 0 && errno == ENOMEM)
1177 * The test system might not have enough memory to accommodate
1180 atf_tc_skip("failed to allocate %zu-byte superpage", sz);
1181 ATF_REQUIRE_MSG(error == 0, "ftruncate failed; errno=%d", errno);
1187 pagesizes(size_t ps[MAXPAGESIZES])
1191 pscnt = getpagesizes(ps, MAXPAGESIZES);
1192 ATF_REQUIRE_MSG(pscnt != -1, "getpagesizes failed; errno=%d", errno);
1193 ATF_REQUIRE_MSG(ps[0] != 0, "psind 0 is %zu", ps[0]);
1194 ATF_REQUIRE_MSG(pscnt <= MAXPAGESIZES, "invalid pscnt %d", pscnt);
1196 atf_tc_skip("no large page support");
1200 ATF_TC_WITHOUT_HEAD(largepage_basic);
1201 ATF_TC_BODY(largepage_basic, tc)
1205 size_t ps[MAXPAGESIZES];
1206 int error, fd, pscnt;
1208 pscnt = pagesizes(ps);
1209 zeroes = calloc(1, ps[0]);
1210 ATF_REQUIRE(zeroes != NULL);
1211 for (int i = 1; i < pscnt; i++) {
1212 fd = shm_open_large(i, SHM_LARGEPAGE_ALLOC_DEFAULT, ps[i]);
1214 addr = mmap(NULL, ps[i], PROT_READ | PROT_WRITE, MAP_SHARED, fd,
1216 ATF_REQUIRE_MSG(addr != MAP_FAILED,
1217 "mmap(%zu bytes) failed; errno=%d", ps[i], errno);
1218 ATF_REQUIRE_MSG(((uintptr_t)addr & (ps[i] - 1)) == 0,
1219 "mmap(%zu bytes) returned unaligned mapping; addr=%p",
1222 /* Force a page fault. */
1223 *(volatile char *)addr = 0;
1225 vec = malloc(ps[i] / ps[0]);
1226 ATF_REQUIRE(vec != NULL);
1227 error = mincore(addr, ps[i], vec);
1228 ATF_REQUIRE_MSG(error == 0, "mincore failed; errno=%d", errno);
1230 /* Verify that all pages in the run are mapped. */
1231 for (size_t p = 0; p < ps[i] / ps[0]; p++) {
1232 ATF_REQUIRE_MSG((vec[p] & MINCORE_INCORE) != 0,
1233 "page %zu is not mapped", p);
1234 ATF_REQUIRE_MSG((vec[p] & MINCORE_PSIND(i)) != 0,
1235 "page %zu is not in a %zu-byte superpage",
1239 /* Validate zeroing. */
1240 for (size_t p = 0; p < ps[i] / ps[0]; p++) {
1241 ATF_REQUIRE_MSG(memcmp(addr + p * ps[0], zeroes,
1242 ps[0]) == 0, "page %zu miscompare", p);
1246 ATF_REQUIRE(munmap(addr, ps[i]) == 0);
1247 ATF_REQUIRE(close(fd) == 0);
1253 extern int __sys_shm_open2(const char *, int, mode_t, int, const char *);
1255 ATF_TC_WITHOUT_HEAD(largepage_config);
1256 ATF_TC_BODY(largepage_config, tc)
1258 struct shm_largepage_conf lpc;
1260 size_t ps[MAXPAGESIZES + 1]; /* silence warnings if MAXPAGESIZES == 1 */
1263 (void)pagesizes(ps);
1265 fd = shm_open(SHM_ANON, O_CREAT | O_RDWR, 0);
1266 ATF_REQUIRE_MSG(fd >= 0, "shm_open failed; error=%d", errno);
1269 * Configure a large page policy for an object created without
1273 lpc.alloc_policy = SHM_LARGEPAGE_ALLOC_DEFAULT;
1274 error = ioctl(fd, FIOSSHMLPGCNF, &lpc);
1275 ATF_REQUIRE(error != 0);
1276 ATF_REQUIRE_MSG(errno == ENOTTY, "ioctl(FIOSSHMLPGCNF) returned %d",
1278 ATF_REQUIRE(close(fd) == 0);
1281 * Create a largepage object and try to use it without actually
1282 * configuring anything.
1284 fd = __sys_shm_open2(SHM_ANON, O_CREAT | O_RDWR, 0, SHM_LARGEPAGE,
1286 if (fd < 0 && errno == ENOTTY)
1287 atf_tc_skip("no large page support");
1288 ATF_REQUIRE_MSG(fd >= 0, "shm_open2 failed; error=%d", errno);
1290 error = ftruncate(fd, ps[1]);
1291 ATF_REQUIRE(error != 0);
1292 ATF_REQUIRE_MSG(errno == EINVAL, "ftruncate returned %d", errno);
1294 addr = mmap(NULL, ps[1], PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0);
1295 ATF_REQUIRE(addr == MAP_FAILED);
1296 ATF_REQUIRE_MSG(errno == EINVAL, "mmap returned %d", errno);
1297 addr = mmap(NULL, 0, PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0);
1298 ATF_REQUIRE(addr == MAP_FAILED);
1299 ATF_REQUIRE_MSG(errno == EINVAL, "mmap returned %d", errno);
1301 buf = calloc(1, ps[0]);
1302 ATF_REQUIRE(buf != NULL);
1303 ATF_REQUIRE(write(fd, buf, ps[0]) == -1);
1304 ATF_REQUIRE_MSG(errno == EINVAL, "write returned %d", errno);
1306 buf = calloc(1, ps[1]);
1307 ATF_REQUIRE(buf != NULL);
1308 ATF_REQUIRE(write(fd, buf, ps[1]) == -1);
1309 ATF_REQUIRE_MSG(errno == EINVAL, "write returned %d", errno);
1312 error = posix_fallocate(fd, 0, ps[0]);
1313 ATF_REQUIRE_MSG(error == EINVAL, "posix_fallocate returned %d", error);
1315 ATF_REQUIRE(close(fd) == 0);
1318 ATF_TC_WITHOUT_HEAD(largepage_mmap);
1319 ATF_TC_BODY(largepage_mmap, tc)
1321 char *addr, *addr1, *vec;
1322 size_t ps[MAXPAGESIZES];
1325 pscnt = pagesizes(ps);
1326 for (int i = 1; i < pscnt; i++) {
1327 fd = shm_open_large(i, SHM_LARGEPAGE_ALLOC_DEFAULT, ps[i]);
1329 /* For mincore(). */
1330 vec = malloc(ps[i]);
1331 ATF_REQUIRE(vec != NULL);
1334 * Wrong mapping size.
1336 addr = mmap(NULL, ps[i - 1], PROT_READ | PROT_WRITE, MAP_SHARED,
1338 ATF_REQUIRE_MSG(addr == MAP_FAILED,
1339 "mmap(%zu bytes) succeeded", ps[i - 1]);
1340 ATF_REQUIRE_MSG(errno == EINVAL,
1341 "mmap(%zu bytes) failed; error=%d", ps[i - 1], errno);
1346 addr = mmap(NULL, ps[i], PROT_READ | PROT_WRITE, MAP_SHARED, fd,
1348 ATF_REQUIRE_MSG(addr != MAP_FAILED,
1349 "mmap(%zu bytes) failed; errno=%d", ps[i], errno);
1350 ATF_REQUIRE_MSG(((uintptr_t)addr & (ps[i] - 1)) == 0,
1351 "mmap(%zu bytes) returned unaligned mapping; addr=%p",
1354 /* Try mapping a small page with anonymous memory. */
1355 addr1 = mmap(addr, ps[i - 1], PROT_READ | PROT_WRITE,
1356 MAP_PRIVATE | MAP_ANON | MAP_FIXED, -1, 0);
1357 ATF_REQUIRE_MSG(addr1 == MAP_FAILED,
1358 "anon mmap(%zu bytes) succeeded", ps[i - 1]);
1359 ATF_REQUIRE_MSG(errno == EINVAL, "mmap returned %d", errno);
1361 /* Check MAP_EXCL when creating a second largepage mapping. */
1362 addr1 = mmap(addr, ps[i], PROT_READ | PROT_WRITE,
1363 MAP_SHARED | MAP_FIXED | MAP_EXCL, fd, 0);
1364 ATF_REQUIRE_MSG(addr1 == MAP_FAILED,
1365 "mmap(%zu bytes) succeeded", ps[i]);
1366 /* XXX wrong errno */
1367 ATF_REQUIRE_MSG(errno == ENOSPC, "mmap returned %d", errno);
1369 /* Overwrite a largepage mapping with a lagepage mapping. */
1370 addr1 = mmap(addr, ps[i], PROT_READ | PROT_WRITE,
1371 MAP_SHARED | MAP_FIXED, fd, 0);
1372 ATF_REQUIRE_MSG(addr1 != MAP_FAILED,
1373 "mmap(%zu bytes) failed; errno=%d", ps[i], errno);
1374 ATF_REQUIRE_MSG(addr == addr1,
1375 "mmap(%zu bytes) moved from %p to %p", ps[i], addr, addr1);
1377 ATF_REQUIRE(munmap(addr, ps[i] == 0));
1379 /* Clobber an anonymous mapping with a superpage. */
1380 addr1 = mmap(NULL, ps[0], PROT_READ | PROT_WRITE,
1381 MAP_ANON | MAP_PRIVATE | MAP_ALIGNED(ffsl(ps[i]) - 1), -1,
1383 ATF_REQUIRE_MSG(addr1 != MAP_FAILED,
1384 "mmap failed; error=%d", errno);
1385 *(volatile char *)addr1 = '\0';
1386 addr = mmap(addr1, ps[i], PROT_READ | PROT_WRITE,
1387 MAP_SHARED | MAP_FIXED, fd, 0);
1388 ATF_REQUIRE_MSG(addr != MAP_FAILED,
1389 "mmap failed; error=%d", errno);
1390 ATF_REQUIRE_MSG(addr == addr1,
1391 "mmap disobeyed MAP_FIXED, %p %p", addr, addr1);
1392 *(volatile char *)addr = 0; /* fault */
1393 ATF_REQUIRE(mincore(addr, ps[i], vec) == 0);
1394 for (size_t p = 0; p < ps[i] / ps[0]; p++) {
1395 ATF_REQUIRE_MSG((vec[p] & MINCORE_INCORE) != 0,
1396 "page %zu is not resident", p);
1397 ATF_REQUIRE_MSG((vec[p] & MINCORE_PSIND(i)) != 0,
1398 "page %zu is not resident", p);
1402 * Copy-on-write mappings are not permitted.
1404 addr = mmap(NULL, ps[i], PROT_READ | PROT_WRITE, MAP_PRIVATE,
1406 ATF_REQUIRE_MSG(addr == MAP_FAILED,
1407 "mmap(%zu bytes) succeeded", ps[i]);
1409 ATF_REQUIRE(close(fd) == 0);
1413 ATF_TC_WITHOUT_HEAD(largepage_munmap);
1414 ATF_TC_BODY(largepage_munmap, tc)
1417 size_t ps[MAXPAGESIZES], ps1;
1420 pscnt = pagesizes(ps);
1421 for (int i = 1; i < pscnt; i++) {
1422 fd = shm_open_large(i, SHM_LARGEPAGE_ALLOC_DEFAULT, ps[i]);
1425 addr = mmap(NULL, ps[i], PROT_READ | PROT_WRITE, MAP_SHARED, fd,
1427 ATF_REQUIRE_MSG(addr != MAP_FAILED,
1428 "mmap(%zu bytes) failed; errno=%d", ps[i], errno);
1430 /* Try several unaligned munmap() requests. */
1431 ATF_REQUIRE(munmap(addr, ps1) != 0);
1432 ATF_REQUIRE_MSG(errno == EINVAL,
1433 "unexpected error %d from munmap", errno);
1434 ATF_REQUIRE(munmap(addr, ps[i] - ps1));
1435 ATF_REQUIRE_MSG(errno == EINVAL,
1436 "unexpected error %d from munmap", errno);
1437 ATF_REQUIRE(munmap(addr + ps1, ps1) != 0);
1438 ATF_REQUIRE_MSG(errno == EINVAL,
1439 "unexpected error %d from munmap", errno);
1440 ATF_REQUIRE(munmap(addr, 0));
1441 ATF_REQUIRE_MSG(errno == EINVAL,
1442 "unexpected error %d from munmap", errno);
1444 ATF_REQUIRE(munmap(addr, ps[i]) == 0);
1445 ATF_REQUIRE(close(fd) == 0);
1450 largepage_madvise(char *addr, size_t sz, int advice, int error)
1453 ATF_REQUIRE_MSG(madvise(addr, sz, advice) == 0,
1454 "madvise(%zu, %d) failed; error=%d", sz, advice, errno);
1456 ATF_REQUIRE_MSG(madvise(addr, sz, advice) != 0,
1457 "madvise(%zu, %d) succeeded", sz, advice);
1458 ATF_REQUIRE_MSG(errno == error,
1459 "unexpected error %d from madvise(%zu, %d)",
1464 ATF_TC_WITHOUT_HEAD(largepage_madvise);
1465 ATF_TC_BODY(largepage_madvise, tc)
1468 size_t ps[MAXPAGESIZES];
1471 pscnt = pagesizes(ps);
1472 for (int i = 1; i < pscnt; i++) {
1473 fd = shm_open_large(i, SHM_LARGEPAGE_ALLOC_DEFAULT, ps[i]);
1474 addr = mmap(NULL, ps[i], PROT_READ | PROT_WRITE, MAP_SHARED, fd,
1476 ATF_REQUIRE_MSG(addr != MAP_FAILED,
1477 "mmap(%zu bytes) failed; error=%d", ps[i], errno);
1479 memset(addr, 0, ps[i]);
1481 /* Advice that requires clipping. */
1482 largepage_madvise(addr, ps[0], MADV_NORMAL, EINVAL);
1483 largepage_madvise(addr, ps[i], MADV_NORMAL, 0);
1484 largepage_madvise(addr, ps[0], MADV_RANDOM, EINVAL);
1485 largepage_madvise(addr, ps[i], MADV_RANDOM, 0);
1486 largepage_madvise(addr, ps[0], MADV_SEQUENTIAL, EINVAL);
1487 largepage_madvise(addr, ps[i], MADV_SEQUENTIAL, 0);
1488 largepage_madvise(addr, ps[0], MADV_NOSYNC, EINVAL);
1489 largepage_madvise(addr, ps[i], MADV_NOSYNC, 0);
1490 largepage_madvise(addr, ps[0], MADV_AUTOSYNC, EINVAL);
1491 largepage_madvise(addr, ps[i], MADV_AUTOSYNC, 0);
1492 largepage_madvise(addr, ps[0], MADV_CORE, EINVAL);
1493 largepage_madvise(addr, ps[i], MADV_CORE, 0);
1494 largepage_madvise(addr, ps[0], MADV_NOCORE, EINVAL);
1495 largepage_madvise(addr, ps[i], MADV_NOCORE, 0);
1497 /* Advice that does not result in clipping. */
1498 largepage_madvise(addr, ps[0], MADV_DONTNEED, 0);
1499 largepage_madvise(addr, ps[i], MADV_DONTNEED, 0);
1500 largepage_madvise(addr, ps[0], MADV_WILLNEED, 0);
1501 largepage_madvise(addr, ps[i], MADV_WILLNEED, 0);
1502 largepage_madvise(addr, ps[0], MADV_FREE, 0);
1503 largepage_madvise(addr, ps[i], MADV_FREE, 0);
1505 ATF_REQUIRE(munmap(addr, ps[i]) == 0);
1506 ATF_REQUIRE(close(fd) == 0);
1510 ATF_TC(largepage_mlock);
1511 ATF_TC_HEAD(largepage_mlock, tc)
1513 /* Needed to set rlimit. */
1514 atf_tc_set_md_var(tc, "require.user", "root");
1516 ATF_TC_BODY(largepage_mlock, tc)
1520 size_t ps[MAXPAGESIZES], sz;
1521 u_long max_wired, wired;
1522 int fd, error, pscnt;
1524 rl.rlim_cur = rl.rlim_max = RLIM_INFINITY;
1525 ATF_REQUIRE_MSG(setrlimit(RLIMIT_MEMLOCK, &rl) == 0,
1526 "setrlimit failed; error=%d", errno);
1528 sz = sizeof(max_wired);
1529 error = sysctlbyname("vm.max_user_wired", &max_wired, &sz, NULL, 0);
1530 ATF_REQUIRE_MSG(error == 0,
1531 "sysctlbyname(vm.max_user_wired) failed; error=%d", errno);
1534 error = sysctlbyname("vm.stats.vm.v_user_wire_count", &wired, &sz, NULL,
1536 ATF_REQUIRE_MSG(error == 0,
1537 "sysctlbyname(vm.stats.vm.v_user_wire_count) failed; error=%d",
1540 pscnt = pagesizes(ps);
1541 for (int i = 1; i < pscnt; i++) {
1542 if (ps[i] / ps[0] > max_wired - wired) {
1543 /* Cannot wire past the limit. */
1544 atf_tc_skip("test would exceed wiring limit");
1547 fd = shm_open_large(i, SHM_LARGEPAGE_ALLOC_DEFAULT, ps[i]);
1548 addr = mmap(NULL, ps[i], PROT_READ | PROT_WRITE, MAP_SHARED, fd,
1550 ATF_REQUIRE_MSG(addr != MAP_FAILED,
1551 "mmap(%zu bytes) failed; error=%d", ps[i], errno);
1553 ATF_REQUIRE(mlock(addr, ps[0]) != 0);
1554 ATF_REQUIRE_MSG(errno == EINVAL,
1555 "unexpected error %d from mlock(%zu bytes)", errno, ps[i]);
1556 ATF_REQUIRE(mlock(addr, ps[i] - ps[0]) != 0);
1557 ATF_REQUIRE_MSG(errno == EINVAL,
1558 "unexpected error %d from mlock(%zu bytes)", errno, ps[i]);
1560 ATF_REQUIRE_MSG(mlock(addr, ps[i]) == 0,
1561 "mlock failed; error=%d", errno);
1563 ATF_REQUIRE(munmap(addr, ps[i]) == 0);
1565 ATF_REQUIRE(mlockall(MCL_FUTURE) == 0);
1566 addr = mmap(NULL, ps[i], PROT_READ | PROT_WRITE, MAP_SHARED, fd,
1568 ATF_REQUIRE_MSG(addr != MAP_FAILED,
1569 "mmap(%zu bytes) failed; error=%d", ps[i], errno);
1571 ATF_REQUIRE(munmap(addr, ps[i]) == 0);
1572 ATF_REQUIRE(close(fd) == 0);
1576 ATF_TC_WITHOUT_HEAD(largepage_msync);
1577 ATF_TC_BODY(largepage_msync, tc)
1580 size_t ps[MAXPAGESIZES];
1583 pscnt = pagesizes(ps);
1584 for (int i = 1; i < pscnt; i++) {
1585 fd = shm_open_large(i, SHM_LARGEPAGE_ALLOC_DEFAULT, ps[i]);
1586 addr = mmap(NULL, ps[i], PROT_READ | PROT_WRITE, MAP_SHARED, fd,
1588 ATF_REQUIRE_MSG(addr != MAP_FAILED,
1589 "mmap(%zu bytes) failed; error=%d", ps[i], errno);
1591 memset(addr, 0, ps[i]);
1594 * "Sync" requests are no-ops for SHM objects, so small
1595 * PAGE_SIZE-sized requests succeed.
1597 ATF_REQUIRE_MSG(msync(addr, ps[0], MS_ASYNC) == 0,
1598 "msync(MS_ASYNC) failed; error=%d", errno);
1599 ATF_REQUIRE_MSG(msync(addr, ps[i], MS_ASYNC) == 0,
1600 "msync(MS_ASYNC) failed; error=%d", errno);
1601 ATF_REQUIRE_MSG(msync(addr, ps[0], MS_SYNC) == 0,
1602 "msync(MS_SYNC) failed; error=%d", errno);
1603 ATF_REQUIRE_MSG(msync(addr, ps[i], MS_SYNC) == 0,
1604 "msync(MS_SYNC) failed; error=%d", errno);
1606 ATF_REQUIRE_MSG(msync(addr, ps[0], MS_INVALIDATE) != 0,
1607 "msync(MS_INVALIDATE) succeeded");
1608 /* XXX wrong errno */
1609 ATF_REQUIRE_MSG(errno == EBUSY,
1610 "unexpected error %d from msync(MS_INVALIDATE)", errno);
1611 ATF_REQUIRE_MSG(msync(addr, ps[i], MS_INVALIDATE) == 0,
1612 "msync(MS_INVALIDATE) failed; error=%d", errno);
1613 memset(addr, 0, ps[i]);
1615 ATF_REQUIRE(munmap(addr, ps[i]) == 0);
1616 ATF_REQUIRE(close(fd) == 0);
1621 largepage_protect(char *addr, size_t sz, int prot, int error)
1624 ATF_REQUIRE_MSG(mprotect(addr, sz, prot) == 0,
1625 "mprotect(%zu, %x) failed; error=%d", sz, prot, errno);
1627 ATF_REQUIRE_MSG(mprotect(addr, sz, prot) != 0,
1628 "mprotect(%zu, %x) succeeded", sz, prot);
1629 ATF_REQUIRE_MSG(errno == error,
1630 "unexpected error %d from mprotect(%zu, %x)",
1635 ATF_TC_WITHOUT_HEAD(largepage_mprotect);
1636 ATF_TC_BODY(largepage_mprotect, tc)
1639 size_t ps[MAXPAGESIZES];
1642 pscnt = pagesizes(ps);
1643 for (int i = 1; i < pscnt; i++) {
1645 * Reserve a contiguous region in the address space to avoid
1646 * spurious failures in the face of ASLR.
1648 addr = mmap(NULL, ps[i] * 2, PROT_NONE,
1649 MAP_ANON | MAP_ALIGNED(ffsl(ps[i]) - 1), -1, 0);
1650 ATF_REQUIRE_MSG(addr != MAP_FAILED,
1651 "mmap(%zu bytes) failed; error=%d", ps[i], errno);
1652 ATF_REQUIRE(munmap(addr, ps[i] * 2) == 0);
1654 fd = shm_open_large(i, SHM_LARGEPAGE_ALLOC_DEFAULT, ps[i]);
1655 addr = mmap(addr, ps[i], PROT_READ | PROT_WRITE,
1656 MAP_SHARED | MAP_FIXED, fd, 0);
1657 ATF_REQUIRE_MSG(addr != MAP_FAILED,
1658 "mmap(%zu bytes) failed; error=%d", ps[i], errno);
1661 * These should be no-ops from the pmap perspective since the
1662 * page is not yet entered into the pmap.
1664 largepage_protect(addr, ps[0], PROT_READ, EINVAL);
1665 largepage_protect(addr, ps[i], PROT_READ, 0);
1666 largepage_protect(addr, ps[0], PROT_NONE, EINVAL);
1667 largepage_protect(addr, ps[i], PROT_NONE, 0);
1668 largepage_protect(addr, ps[0],
1669 PROT_READ | PROT_WRITE | PROT_EXEC, EINVAL);
1670 largepage_protect(addr, ps[i],
1671 PROT_READ | PROT_WRITE | PROT_EXEC, 0);
1673 /* Trigger creation of a mapping and try again. */
1674 *(volatile char *)addr = 0;
1675 largepage_protect(addr, ps[0], PROT_READ, EINVAL);
1676 largepage_protect(addr, ps[i], PROT_READ, 0);
1677 largepage_protect(addr, ps[0], PROT_NONE, EINVAL);
1678 largepage_protect(addr, ps[i], PROT_NONE, 0);
1679 largepage_protect(addr, ps[0],
1680 PROT_READ | PROT_WRITE | PROT_EXEC, EINVAL);
1681 largepage_protect(addr, ps[i],
1682 PROT_READ | PROT_WRITE | PROT_EXEC, 0);
1684 memset(addr, 0, ps[i]);
1686 /* Map two contiguous large pages and merge map entries. */
1687 addr1 = mmap(addr + ps[i], ps[i], PROT_READ | PROT_WRITE,
1688 MAP_SHARED | MAP_FIXED | MAP_EXCL, fd, 0);
1689 ATF_REQUIRE_MSG(addr1 != MAP_FAILED,
1690 "mmap(%zu bytes) failed; error=%d", ps[i], errno);
1692 largepage_protect(addr1 - ps[0], ps[0] * 2,
1693 PROT_READ | PROT_WRITE, EINVAL);
1694 largepage_protect(addr, ps[i] * 2, PROT_READ | PROT_WRITE, 0);
1696 memset(addr, 0, ps[i] * 2);
1698 ATF_REQUIRE(munmap(addr, ps[i]) == 0);
1699 ATF_REQUIRE(munmap(addr1, ps[i]) == 0);
1700 ATF_REQUIRE(close(fd) == 0);
1704 ATF_TC_WITHOUT_HEAD(largepage_minherit);
1705 ATF_TC_BODY(largepage_minherit, tc)
1708 size_t ps[MAXPAGESIZES];
1710 int fd, pscnt, status;
1712 pscnt = pagesizes(ps);
1713 for (int i = 1; i < pscnt; i++) {
1714 fd = shm_open_large(i, SHM_LARGEPAGE_ALLOC_DEFAULT, ps[i]);
1715 addr = mmap(NULL, ps[i], PROT_READ | PROT_WRITE, MAP_SHARED, fd,
1717 ATF_REQUIRE_MSG(addr != MAP_FAILED,
1718 "mmap(%zu bytes) failed; error=%d", ps[i], errno);
1720 ATF_REQUIRE(minherit(addr, ps[0], INHERIT_SHARE) != 0);
1722 ATF_REQUIRE_MSG(minherit(addr, ps[i], INHERIT_SHARE) == 0,
1723 "minherit(%zu bytes) failed; error=%d", ps[i], errno);
1725 ATF_REQUIRE_MSG(child != -1, "fork failed; error=%d", errno);
1729 *(volatile char *)addr = 0;
1730 if (mincore(addr, ps[0], &v) != 0)
1732 if ((v & MINCORE_PSIND(i)) == 0)
1736 ATF_REQUIRE_MSG(waitpid(child, &status, 0) == child,
1737 "waitpid failed; error=%d", errno);
1738 ATF_REQUIRE_MSG(WIFEXITED(status),
1739 "child was killed by signal %d", WTERMSIG(status));
1740 ATF_REQUIRE_MSG(WEXITSTATUS(status) == 0,
1741 "child exited with status %d", WEXITSTATUS(status));
1743 ATF_REQUIRE_MSG(minherit(addr, ps[i], INHERIT_NONE) == 0,
1744 "minherit(%zu bytes) failed; error=%d", ps[i], errno);
1746 ATF_REQUIRE_MSG(child != -1, "fork failed; error=%d", errno);
1750 if (mincore(addr, ps[0], &v) == 0)
1754 ATF_REQUIRE_MSG(waitpid(child, &status, 0) == child,
1755 "waitpid failed; error=%d", errno);
1756 ATF_REQUIRE_MSG(WIFEXITED(status),
1757 "child was killed by signal %d", WTERMSIG(status));
1758 ATF_REQUIRE_MSG(WEXITSTATUS(status) == 0,
1759 "child exited with status %d", WEXITSTATUS(status));
1761 /* Copy-on-write is not supported for static large pages. */
1762 ATF_REQUIRE_MSG(minherit(addr, ps[i], INHERIT_COPY) != 0,
1763 "minherit(%zu bytes) succeeded", ps[i]);
1765 ATF_REQUIRE_MSG(minherit(addr, ps[i], INHERIT_ZERO) == 0,
1766 "minherit(%zu bytes) failed; error=%d", ps[i], errno);
1768 ATF_REQUIRE_MSG(child != -1, "fork failed; error=%d", errno);
1772 *(volatile char *)addr = 0;
1773 if (mincore(addr, ps[0], &v) != 0)
1775 if ((v & MINCORE_SUPER) != 0)
1779 ATF_REQUIRE_MSG(waitpid(child, &status, 0) == child,
1780 "waitpid failed; error=%d", errno);
1781 ATF_REQUIRE_MSG(WIFEXITED(status),
1782 "child was killed by signal %d", WTERMSIG(status));
1783 ATF_REQUIRE_MSG(WEXITSTATUS(status) == 0,
1784 "child exited with status %d", WEXITSTATUS(status));
1786 ATF_REQUIRE(munmap(addr, ps[i]) == 0);
1787 ATF_REQUIRE(close(fd) == 0);
1791 ATF_TC_WITHOUT_HEAD(largepage_pipe);
1792 ATF_TC_BODY(largepage_pipe, tc)
1794 size_t ps[MAXPAGESIZES];
1797 int fd, pfd[2], pscnt, status;
1800 pscnt = pagesizes(ps);
1802 for (int i = 1; i < pscnt; i++) {
1803 fd = shm_open_large(i, SHM_LARGEPAGE_ALLOC_DEFAULT, ps[i]);
1804 addr = mmap(NULL, ps[i], PROT_READ | PROT_WRITE, MAP_SHARED, fd,
1806 ATF_REQUIRE_MSG(addr != MAP_FAILED,
1807 "mmap(%zu bytes) failed; error=%d", ps[i], errno);
1809 /* Trigger creation of a mapping. */
1810 *(volatile char *)addr = '\0';
1812 ATF_REQUIRE(pipe(pfd) == 0);
1814 ATF_REQUIRE_MSG(child != -1, "fork() failed; error=%d", errno);
1819 (void)close(pfd[0]);
1820 for (resid = (size_t)ps[i]; resid > 0; resid -= len) {
1821 len = read(pfd[1], buf, sizeof(buf));
1827 ATF_REQUIRE(close(pfd[1]) == 0);
1828 len = write(pfd[0], addr, ps[i]);
1829 ATF_REQUIRE_MSG(len >= 0, "write() failed; error=%d", errno);
1830 ATF_REQUIRE_MSG(len == (ssize_t)ps[i],
1831 "short write; len=%zd", len);
1832 ATF_REQUIRE(close(pfd[0]) == 0);
1834 ATF_REQUIRE_MSG(waitpid(child, &status, 0) == child,
1835 "waitpid() failed; error=%d", errno);
1836 ATF_REQUIRE_MSG(WIFEXITED(status),
1837 "child was killed by signal %d", WTERMSIG(status));
1838 ATF_REQUIRE_MSG(WEXITSTATUS(status) == 0,
1839 "child exited with status %d", WEXITSTATUS(status));
1841 ATF_REQUIRE(munmap(addr, ps[i]) == 0);
1842 ATF_REQUIRE(close(fd) == 0);
1846 ATF_TC_WITHOUT_HEAD(largepage_reopen);
1847 ATF_TC_BODY(largepage_reopen, tc)
1850 size_t ps[MAXPAGESIZES];
1853 (void)pagesizes(ps);
1857 fd = shm_create_largepage(test_path, O_CREAT | O_RDWR, psind,
1858 SHM_LARGEPAGE_ALLOC_DEFAULT, 0600);
1859 if (fd < 0 && errno == ENOTTY)
1860 atf_tc_skip("no large page support");
1861 ATF_REQUIRE_MSG(fd >= 0, "shm_create_largepage failed; error=%d", errno);
1863 ATF_REQUIRE_MSG(ftruncate(fd, ps[psind]) == 0,
1864 "ftruncate failed; error=%d", errno);
1866 ATF_REQUIRE_MSG(close(fd) == 0, "close failed; error=%d", errno);
1868 fd = shm_open(test_path, O_RDWR, 0);
1869 ATF_REQUIRE_MSG(fd >= 0, "shm_open failed; error=%d", errno);
1871 addr = mmap(NULL, ps[psind], PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0);
1872 ATF_REQUIRE_MSG(addr != MAP_FAILED, "mmap failed; error=%d", errno);
1874 /* Trigger a fault and mapping creation. */
1875 *(volatile char *)addr = 0;
1877 vec = malloc(ps[psind] / ps[0]);
1878 ATF_REQUIRE(vec != NULL);
1879 ATF_REQUIRE_MSG(mincore(addr, ps[psind], vec) == 0,
1880 "mincore failed; error=%d", errno);
1881 ATF_REQUIRE_MSG((vec[0] & MINCORE_PSIND(psind)) != 0,
1882 "page not mapped into a %zu-byte superpage", ps[psind]);
1884 ATF_REQUIRE_MSG(shm_unlink(test_path) == 0,
1885 "shm_unlink failed; errno=%d", errno);
1886 ATF_REQUIRE_MSG(close(fd) == 0,
1887 "close failed; errno=%d", errno);
1893 ATF_TP_ADD_TC(tp, remap_object);
1894 ATF_TP_ADD_TC(tp, rename_from_anon);
1895 ATF_TP_ADD_TC(tp, rename_bad_path_pointer);
1896 ATF_TP_ADD_TC(tp, rename_from_nonexisting);
1897 ATF_TP_ADD_TC(tp, rename_to_anon);
1898 ATF_TP_ADD_TC(tp, rename_to_replace);
1899 ATF_TP_ADD_TC(tp, rename_to_noreplace);
1900 ATF_TP_ADD_TC(tp, rename_to_exchange);
1901 ATF_TP_ADD_TC(tp, rename_to_exchange_nonexisting);
1902 ATF_TP_ADD_TC(tp, rename_to_self);
1903 ATF_TP_ADD_TC(tp, rename_bad_flag);
1904 ATF_TP_ADD_TC(tp, reopen_object);
1905 ATF_TP_ADD_TC(tp, readonly_mmap_write);
1906 ATF_TP_ADD_TC(tp, open_after_link);
1907 ATF_TP_ADD_TC(tp, open_invalid_path);
1908 ATF_TP_ADD_TC(tp, open_write_only);
1909 ATF_TP_ADD_TC(tp, open_extra_flags);
1910 ATF_TP_ADD_TC(tp, open_anon);
1911 ATF_TP_ADD_TC(tp, open_anon_readonly);
1912 ATF_TP_ADD_TC(tp, open_bad_path_pointer);
1913 ATF_TP_ADD_TC(tp, open_path_too_long);
1914 ATF_TP_ADD_TC(tp, open_nonexisting_object);
1915 ATF_TP_ADD_TC(tp, open_create_existing_object);
1916 ATF_TP_ADD_TC(tp, shm_functionality_across_fork);
1917 ATF_TP_ADD_TC(tp, trunc_resets_object);
1918 ATF_TP_ADD_TC(tp, unlink_bad_path_pointer);
1919 ATF_TP_ADD_TC(tp, unlink_path_too_long);
1920 ATF_TP_ADD_TC(tp, object_resize);
1921 ATF_TP_ADD_TC(tp, cloexec);
1922 ATF_TP_ADD_TC(tp, mode);
1923 ATF_TP_ADD_TC(tp, fallocate);
1924 ATF_TP_ADD_TC(tp, fspacectl);
1925 ATF_TP_ADD_TC(tp, largepage_basic);
1926 ATF_TP_ADD_TC(tp, largepage_config);
1927 ATF_TP_ADD_TC(tp, largepage_mmap);
1928 ATF_TP_ADD_TC(tp, largepage_munmap);
1929 ATF_TP_ADD_TC(tp, largepage_madvise);
1930 ATF_TP_ADD_TC(tp, largepage_mlock);
1931 ATF_TP_ADD_TC(tp, largepage_msync);
1932 ATF_TP_ADD_TC(tp, largepage_mprotect);
1933 ATF_TP_ADD_TC(tp, largepage_minherit);
1934 ATF_TP_ADD_TC(tp, largepage_pipe);
1935 ATF_TP_ADD_TC(tp, largepage_reopen);
1937 return (atf_no_error());