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