628 lines
12 KiB
C
628 lines
12 KiB
C
/*-
|
|
* Copyright (c) 2006 Robert N. M. Watson
|
|
* All rights reserved.
|
|
*
|
|
* Redistribution and use in source and binary forms, with or without
|
|
* modification, are permitted provided that the following conditions
|
|
* are met:
|
|
* 1. Redistributions of source code must retain the above copyright
|
|
* notice, this list of conditions and the following disclaimer.
|
|
* 2. Redistributions in binary form must reproduce the above copyright
|
|
* notice, this list of conditions and the following disclaimer in the
|
|
* documentation and/or other materials provided with the distribution.
|
|
*
|
|
* THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
|
|
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
|
|
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
|
|
* ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
|
|
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
|
|
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
|
|
* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
|
|
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
|
|
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
|
|
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
|
|
* SUCH DAMAGE.
|
|
*/
|
|
|
|
#include <sys/cdefs.h>
|
|
__FBSDID("$FreeBSD$");
|
|
|
|
#include <sys/param.h>
|
|
#include <sys/mman.h>
|
|
#include <sys/resource.h>
|
|
#include <sys/stat.h>
|
|
#include <sys/syscall.h>
|
|
#include <sys/wait.h>
|
|
|
|
#include <errno.h>
|
|
#include <fcntl.h>
|
|
#include <stdio.h>
|
|
#include <stdlib.h>
|
|
#include <string.h>
|
|
#include <unistd.h>
|
|
|
|
#include "test.h"
|
|
|
|
#define TEST_PATH "/tmp/posixshm_regression_test"
|
|
|
|
/*
|
|
* Attempt a shm_open() that should fail with an expected error of 'error'.
|
|
*/
|
|
static void
|
|
shm_open_should_fail(const char *path, int flags, mode_t mode, int error)
|
|
{
|
|
int fd;
|
|
|
|
fd = shm_open(path, flags, mode);
|
|
if (fd >= 0) {
|
|
fail_err("shm_open() didn't fail");
|
|
close(fd);
|
|
return;
|
|
}
|
|
if (errno != error) {
|
|
fail_errno("shm_open");
|
|
return;
|
|
}
|
|
pass();
|
|
}
|
|
|
|
/*
|
|
* Attempt a shm_unlink() that should fail with an expected error of 'error'.
|
|
*/
|
|
static void
|
|
shm_unlink_should_fail(const char *path, int error)
|
|
{
|
|
|
|
if (shm_unlink(path) >= 0) {
|
|
fail_err("shm_unlink() didn't fail");
|
|
return;
|
|
}
|
|
if (errno != error) {
|
|
fail_errno("shm_unlink");
|
|
return;
|
|
}
|
|
pass();
|
|
}
|
|
|
|
/*
|
|
* Open the test object and write '1' to the first byte. Returns valid fd
|
|
* on success and -1 on failure.
|
|
*/
|
|
static int
|
|
scribble_object(void)
|
|
{
|
|
char *page;
|
|
int fd;
|
|
|
|
fd = shm_open(TEST_PATH, O_CREAT | O_EXCL | O_RDWR, 0777);
|
|
if (fd < 0 && errno == EEXIST) {
|
|
if (shm_unlink(TEST_PATH) < 0) {
|
|
fail_errno("shm_unlink");
|
|
return (-1);
|
|
}
|
|
fd = shm_open(TEST_PATH, O_CREAT | O_EXCL | O_RDWR, 0777);
|
|
}
|
|
if (fd < 0) {
|
|
fail_errno("shm_open");
|
|
return (-1);
|
|
}
|
|
if (ftruncate(fd, getpagesize()) < 0) {
|
|
fail_errno("ftruncate");
|
|
close(fd);
|
|
shm_unlink(TEST_PATH);
|
|
return (-1);
|
|
}
|
|
|
|
page = mmap(0, getpagesize(), PROT_READ | PROT_WRITE, MAP_SHARED, fd,
|
|
0);
|
|
if (page == MAP_FAILED) {
|
|
fail_errno("mmap");
|
|
close(fd);
|
|
shm_unlink(TEST_PATH);
|
|
return (-1);
|
|
}
|
|
|
|
page[0] = '1';
|
|
|
|
if (munmap(page, getpagesize()) < 0) {
|
|
fail_errno("munmap");
|
|
close(fd);
|
|
shm_unlink(TEST_PATH);
|
|
return (-1);
|
|
}
|
|
|
|
return (fd);
|
|
}
|
|
|
|
static void
|
|
remap_object(void)
|
|
{
|
|
char *page;
|
|
int fd;
|
|
|
|
fd = scribble_object();
|
|
if (fd < 0)
|
|
return;
|
|
|
|
page = mmap(0, getpagesize(), PROT_READ | PROT_WRITE, MAP_SHARED, fd,
|
|
0);
|
|
if (page == MAP_FAILED) {
|
|
fail_errno("mmap(2)");
|
|
close(fd);
|
|
shm_unlink(TEST_PATH);
|
|
return;
|
|
}
|
|
|
|
if (page[0] != '1') {
|
|
fail_err("missing data");
|
|
close(fd);
|
|
shm_unlink(TEST_PATH);
|
|
return;
|
|
}
|
|
|
|
close(fd);
|
|
if (munmap(page, getpagesize()) < 0) {
|
|
fail_errno("munmap");
|
|
shm_unlink(TEST_PATH);
|
|
return;
|
|
}
|
|
|
|
if (shm_unlink(TEST_PATH) < 0) {
|
|
fail_errno("shm_unlink");
|
|
return;
|
|
}
|
|
|
|
pass();
|
|
}
|
|
TEST(remap_object, "remap object");
|
|
|
|
static void
|
|
reopen_object(void)
|
|
{
|
|
char *page;
|
|
int fd;
|
|
|
|
fd = scribble_object();
|
|
if (fd < 0)
|
|
return;
|
|
close(fd);
|
|
|
|
fd = shm_open(TEST_PATH, O_RDONLY, 0777);
|
|
if (fd < 0) {
|
|
fail_errno("shm_open(2)");
|
|
shm_unlink(TEST_PATH);
|
|
return;
|
|
}
|
|
page = mmap(0, getpagesize(), PROT_READ, MAP_SHARED, fd, 0);
|
|
if (page == MAP_FAILED) {
|
|
fail_errno("mmap(2)");
|
|
close(fd);
|
|
shm_unlink(TEST_PATH);
|
|
return;
|
|
}
|
|
|
|
if (page[0] != '1') {
|
|
fail_err("missing data");
|
|
munmap(page, getpagesize());
|
|
close(fd);
|
|
shm_unlink(TEST_PATH);
|
|
return;
|
|
}
|
|
|
|
munmap(page, getpagesize());
|
|
close(fd);
|
|
shm_unlink(TEST_PATH);
|
|
pass();
|
|
}
|
|
TEST(reopen_object, "reopen object");
|
|
|
|
static void
|
|
readonly_mmap_write(void)
|
|
{
|
|
char *page;
|
|
int fd;
|
|
|
|
fd = shm_open(TEST_PATH, O_RDONLY | O_CREAT, 0777);
|
|
if (fd < 0) {
|
|
fail_errno("shm_open");
|
|
return;
|
|
}
|
|
|
|
/* PROT_WRITE should fail with EACCES. */
|
|
page = mmap(0, getpagesize(), PROT_READ | PROT_WRITE, MAP_SHARED, fd,
|
|
0);
|
|
if (page != MAP_FAILED) {
|
|
fail_err("mmap(PROT_WRITE) succeeded");
|
|
munmap(page, getpagesize());
|
|
close(fd);
|
|
shm_unlink(TEST_PATH);
|
|
return;
|
|
}
|
|
if (errno != EACCES) {
|
|
fail_errno("mmap");
|
|
close(fd);
|
|
shm_unlink(TEST_PATH);
|
|
return;
|
|
}
|
|
|
|
close(fd);
|
|
shm_unlink(TEST_PATH);
|
|
pass();
|
|
}
|
|
TEST(readonly_mmap_write, "RDONLY object");
|
|
|
|
static void
|
|
open_after_unlink(void)
|
|
{
|
|
int fd;
|
|
|
|
fd = shm_open(TEST_PATH, O_RDONLY | O_CREAT, 0777);
|
|
if (fd < 0) {
|
|
fail_errno("shm_open(1)");
|
|
return;
|
|
}
|
|
close(fd);
|
|
|
|
if (shm_unlink(TEST_PATH) < 0) {
|
|
fail_errno("shm_unlink");
|
|
return;
|
|
}
|
|
|
|
shm_open_should_fail(TEST_PATH, O_RDONLY, 0777, ENOENT);
|
|
}
|
|
TEST(open_after_unlink, "open after unlink");
|
|
|
|
static void
|
|
open_invalid_path(void)
|
|
{
|
|
|
|
shm_open_should_fail("blah", O_RDONLY, 0777, EINVAL);
|
|
}
|
|
TEST(open_invalid_path, "open invalid path");
|
|
|
|
static void
|
|
open_write_only(void)
|
|
{
|
|
|
|
shm_open_should_fail(TEST_PATH, O_WRONLY, 0777, EINVAL);
|
|
}
|
|
TEST(open_write_only, "open with O_WRONLY");
|
|
|
|
static void
|
|
open_extra_flags(void)
|
|
{
|
|
|
|
shm_open_should_fail(TEST_PATH, O_RDONLY | O_DIRECT, 0777, EINVAL);
|
|
}
|
|
TEST(open_extra_flags, "open with extra flags");
|
|
|
|
static void
|
|
open_anon(void)
|
|
{
|
|
int fd;
|
|
|
|
fd = shm_open(SHM_ANON, O_RDWR, 0777);
|
|
if (fd < 0) {
|
|
fail_errno("shm_open");
|
|
return;
|
|
}
|
|
close(fd);
|
|
pass();
|
|
}
|
|
TEST(open_anon, "open anonymous object");
|
|
|
|
static void
|
|
open_anon_readonly(void)
|
|
{
|
|
|
|
shm_open_should_fail(SHM_ANON, O_RDONLY, 0777, EINVAL);
|
|
}
|
|
TEST(open_anon_readonly, "open SHM_ANON with O_RDONLY");
|
|
|
|
static void
|
|
open_bad_path_pointer(void)
|
|
{
|
|
|
|
shm_open_should_fail((char *)1024, O_RDONLY, 0777, EFAULT);
|
|
}
|
|
TEST(open_bad_path_pointer, "open bad path pointer");
|
|
|
|
static void
|
|
open_path_too_long(void)
|
|
{
|
|
char *page;
|
|
|
|
page = malloc(MAXPATHLEN + 1);
|
|
memset(page, 'a', MAXPATHLEN);
|
|
page[MAXPATHLEN] = '\0';
|
|
shm_open_should_fail(page, O_RDONLY, 0777, ENAMETOOLONG);
|
|
free(page);
|
|
}
|
|
TEST(open_path_too_long, "open pathname too long");
|
|
|
|
static void
|
|
open_nonexisting_object(void)
|
|
{
|
|
|
|
shm_open_should_fail("/notreallythere", O_RDONLY, 0777, ENOENT);
|
|
}
|
|
TEST(open_nonexisting_object, "open nonexistent object");
|
|
|
|
static void
|
|
exclusive_create_existing_object(void)
|
|
{
|
|
int fd;
|
|
|
|
fd = shm_open("/tmp/notreallythere", O_RDONLY | O_CREAT, 0777);
|
|
if (fd < 0) {
|
|
fail_errno("shm_open(O_CREAT)");
|
|
return;
|
|
}
|
|
close(fd);
|
|
|
|
shm_open_should_fail("/tmp/notreallythere", O_RDONLY | O_CREAT | O_EXCL,
|
|
0777, EEXIST);
|
|
|
|
shm_unlink("/tmp/notreallythere");
|
|
}
|
|
TEST(exclusive_create_existing_object, "O_EXCL of existing object");
|
|
|
|
static void
|
|
trunc_resets_object(void)
|
|
{
|
|
struct stat sb;
|
|
int fd;
|
|
|
|
/* Create object and set size to 1024. */
|
|
fd = shm_open(TEST_PATH, O_RDWR | O_CREAT, 0777);
|
|
if (fd < 0) {
|
|
fail_errno("shm_open(1)");
|
|
return;
|
|
}
|
|
if (ftruncate(fd, 1024) < 0) {
|
|
fail_errno("ftruncate");
|
|
close(fd);
|
|
return;
|
|
}
|
|
if (fstat(fd, &sb) < 0) {
|
|
fail_errno("fstat(1)");
|
|
close(fd);
|
|
return;
|
|
}
|
|
if (sb.st_size != 1024) {
|
|
fail_err("size %d != 1024", (int)sb.st_size);
|
|
close(fd);
|
|
return;
|
|
}
|
|
close(fd);
|
|
|
|
/* Open with O_TRUNC which should reset size to 0. */
|
|
fd = shm_open(TEST_PATH, O_RDWR | O_TRUNC, 0777);
|
|
if (fd < 0) {
|
|
fail_errno("shm_open(2)");
|
|
return;
|
|
}
|
|
if (fstat(fd, &sb) < 0) {
|
|
fail_errno("fstat(2)");
|
|
close(fd);
|
|
return;
|
|
}
|
|
if (sb.st_size != 0) {
|
|
fail_err("size after O_TRUNC %d != 0", (int)sb.st_size);
|
|
close(fd);
|
|
return;
|
|
}
|
|
close(fd);
|
|
if (shm_unlink(TEST_PATH) < 0) {
|
|
fail_errno("shm_unlink");
|
|
return;
|
|
}
|
|
pass();
|
|
}
|
|
TEST(trunc_resets_object, "O_TRUNC resets size");
|
|
|
|
static void
|
|
unlink_bad_path_pointer(void)
|
|
{
|
|
|
|
shm_unlink_should_fail((char *)1024, EFAULT);
|
|
}
|
|
TEST(unlink_bad_path_pointer, "unlink bad path pointer");
|
|
|
|
static void
|
|
unlink_path_too_long(void)
|
|
{
|
|
char *page;
|
|
|
|
page = malloc(MAXPATHLEN + 1);
|
|
memset(page, 'a', MAXPATHLEN);
|
|
page[MAXPATHLEN] = '\0';
|
|
shm_unlink_should_fail(page, ENAMETOOLONG);
|
|
free(page);
|
|
}
|
|
TEST(unlink_path_too_long, "unlink pathname too long");
|
|
|
|
static void
|
|
test_object_resize(void)
|
|
{
|
|
pid_t pid;
|
|
struct stat sb;
|
|
char *page;
|
|
int fd, status;
|
|
|
|
/* Start off with a size of a single page. */
|
|
fd = shm_open(SHM_ANON, O_CREAT | O_RDWR, 0777);
|
|
if (fd < 0) {
|
|
fail_errno("shm_open");
|
|
return;
|
|
}
|
|
if (ftruncate(fd, getpagesize()) < 0) {
|
|
fail_errno("ftruncate(1)");
|
|
close(fd);
|
|
return;
|
|
}
|
|
if (fstat(fd, &sb) < 0) {
|
|
fail_errno("fstat(1)");
|
|
close(fd);
|
|
return;
|
|
}
|
|
if (sb.st_size != getpagesize()) {
|
|
fail_err("first resize failed");
|
|
close(fd);
|
|
return;
|
|
}
|
|
|
|
/* Write a '1' to the first byte. */
|
|
page = mmap(0, getpagesize(), PROT_READ | PROT_WRITE, MAP_SHARED, fd,
|
|
0);
|
|
if (page == MAP_FAILED) {
|
|
fail_errno("mmap(1)");
|
|
close(fd);
|
|
return;
|
|
}
|
|
|
|
page[0] = '1';
|
|
|
|
if (munmap(page, getpagesize()) < 0) {
|
|
fail_errno("munmap(1)");
|
|
close(fd);
|
|
return;
|
|
}
|
|
|
|
/* Grow the object to 2 pages. */
|
|
if (ftruncate(fd, getpagesize() * 2) < 0) {
|
|
fail_errno("ftruncate(2)");
|
|
close(fd);
|
|
return;
|
|
}
|
|
if (fstat(fd, &sb) < 0) {
|
|
fail_errno("fstat(2)");
|
|
close(fd);
|
|
return;
|
|
}
|
|
if (sb.st_size != getpagesize() * 2) {
|
|
fail_err("second resize failed");
|
|
close(fd);
|
|
return;
|
|
}
|
|
|
|
/* Check for '1' at the first byte. */
|
|
page = mmap(0, getpagesize() * 2, PROT_READ | PROT_WRITE, MAP_SHARED,
|
|
fd, 0);
|
|
if (page == MAP_FAILED) {
|
|
fail_errno("mmap(2)");
|
|
close(fd);
|
|
return;
|
|
}
|
|
|
|
if (page[0] != '1') {
|
|
fail_err("missing data at 0");
|
|
close(fd);
|
|
return;
|
|
}
|
|
|
|
/* Write a '2' at the start of the second page. */
|
|
page[getpagesize()] = '2';
|
|
|
|
/* Shrink the object back to 1 page. */
|
|
if (ftruncate(fd, getpagesize()) < 0) {
|
|
fail_errno("ftruncate(3)");
|
|
close(fd);
|
|
return;
|
|
}
|
|
if (fstat(fd, &sb) < 0) {
|
|
fail_errno("fstat(3)");
|
|
close(fd);
|
|
return;
|
|
}
|
|
if (sb.st_size != getpagesize()) {
|
|
fail_err("third resize failed");
|
|
close(fd);
|
|
return;
|
|
}
|
|
|
|
/*
|
|
* Fork a child process to make sure the second page is no
|
|
* longer valid.
|
|
*/
|
|
pid = fork();
|
|
if (pid < 0) {
|
|
fail_errno("fork");
|
|
close(fd);
|
|
return;
|
|
}
|
|
|
|
if (pid == 0) {
|
|
struct rlimit lim;
|
|
char c;
|
|
|
|
/* Don't generate a core dump. */
|
|
getrlimit(RLIMIT_CORE, &lim);
|
|
lim.rlim_cur = 0;
|
|
setrlimit(RLIMIT_CORE, &lim);
|
|
|
|
/*
|
|
* The previous ftruncate(2) shrunk the backing object
|
|
* so that this address is no longer valid, so reading
|
|
* from it should trigger a SIGSEGV.
|
|
*/
|
|
c = page[getpagesize()];
|
|
fprintf(stderr, "child: page 1: '%c'\n", c);
|
|
exit(0);
|
|
}
|
|
if (wait(&status) < 0) {
|
|
fail_errno("wait");
|
|
close(fd);
|
|
return;
|
|
}
|
|
if (!WIFSIGNALED(status) || WTERMSIG(status) != SIGSEGV) {
|
|
fail_err("child terminated with status %x", status);
|
|
close(fd);
|
|
return;
|
|
}
|
|
|
|
/* Grow the object back to 2 pages. */
|
|
if (ftruncate(fd, getpagesize() * 2) < 0) {
|
|
fail_errno("ftruncate(4)");
|
|
close(fd);
|
|
return;
|
|
}
|
|
if (fstat(fd, &sb) < 0) {
|
|
fail_errno("fstat(4)");
|
|
close(fd);
|
|
return;
|
|
}
|
|
if (sb.st_size != getpagesize() * 2) {
|
|
fail_err("second resize failed");
|
|
close(fd);
|
|
return;
|
|
}
|
|
|
|
/*
|
|
* Note that the mapping at 'page' for the second page is
|
|
* still valid, and now that the shm object has been grown
|
|
* back up to 2 pages, there is now memory backing this page
|
|
* so the read will work. However, the data should be zero
|
|
* rather than '2' as the old data was thrown away when the
|
|
* object was shrunk and the new pages when an object are
|
|
* grown are zero-filled.
|
|
*/
|
|
if (page[getpagesize()] != 0) {
|
|
fail_err("invalid data at %d", getpagesize());
|
|
close(fd);
|
|
return;
|
|
}
|
|
|
|
close(fd);
|
|
pass();
|
|
}
|
|
TEST(test_object_resize, "object resize");
|
|
|
|
int
|
|
main(int argc, char *argv[])
|
|
{
|
|
|
|
run_tests();
|
|
return (0);
|
|
}
|