/*      $NetBSD: t_memfd_create.c,v 1.7 2025/04/19 01:56:50 riastradh Exp $     */

/*-
* Copyright (c) 2023 The NetBSD Foundation, Inc.
* All rights reserved.
*
* This code is derived from software contributed to The NetBSD Foundation
* by Theodore Preduta.
*
* 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 NETBSD FOUNDATION, INC. 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 FOUNDATION 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>
__RCSID("$NetBSD: t_memfd_create.c,v 1.7 2025/04/19 01:56:50 riastradh Exp $");

#include <sys/param.h>
#include <sys/types.h>
#include <sys/mman.h>
#include <sys/stat.h>
#include <errno.h>
#include <fcntl.h>

#include <atf-c.h>

#include "h_macros.h"

char name_buf[NAME_MAX];
char *write_buf;
char *read_buf;
size_t rwbuf_size;

static void
setupbufs(void)
{

       rwbuf_size = (size_t)sysconf(_SC_PAGESIZE);
       ATF_REQUIRE_MSG(rwbuf_size < SIZE_MAX/2, "rwbuf_size=%zu", rwbuf_size);
       rwbuf_size *= 2;
       REQUIRE_LIBC(write_buf = calloc(1, rwbuf_size), NULL);
       REQUIRE_LIBC(read_buf = calloc(1, rwbuf_size), NULL);
}

ATF_TC(create_null_name);
ATF_TC_HEAD(create_null_name, tc)
{

       atf_tc_set_md_var(tc, "descr",
           "Checks memfd_create fails with EFAULT when invalid memory"
           " is provided");
}
ATF_TC_BODY(create_null_name, tc)
{
       int fd;

       ATF_REQUIRE_EQ_MSG(fd = memfd_create(NULL, 0), -1,
           "Unexpected success");
       ATF_REQUIRE_ERRNO(EFAULT, true);
}

ATF_TC(create_long_name);
ATF_TC_HEAD(create_long_name, tc)
{

       atf_tc_set_md_var(tc, "descr",
           "Checks memfd_create fails for names longer than NAME_MAX-6");
}
ATF_TC_BODY(create_long_name, tc)
{
       int fd;

       memset(name_buf, 'A', sizeof(name_buf));
       name_buf[NAME_MAX-6] = '\0';

       ATF_REQUIRE_EQ_MSG(fd = memfd_create(name_buf, 0), -1,
           "Unexpected success");
       ATF_REQUIRE_ERRNO(ENAMETOOLONG, true);

       name_buf[NAME_MAX-7] = '\0';

       RL(fd = memfd_create(name_buf, 0));
}

ATF_TC(read_write);
ATF_TC_HEAD(read_write, tc)
{

       atf_tc_set_md_var(tc, "descr",
           "Checks that data can be written to/read from a memfd");
}
ATF_TC_BODY(read_write, tc)
{
       int fd;
       off_t offset;

       setupbufs();

       RL(fd = memfd_create("", 0));

       tests_makegarbage(write_buf, rwbuf_size);

       RL(write(fd, write_buf, rwbuf_size));
       offset = lseek(fd, 0, SEEK_CUR);
       ATF_REQUIRE_EQ_MSG(offset, (off_t)rwbuf_size,
           "File offset not set after write (%jd != %zu)", (intmax_t)offset,
           rwbuf_size);

       RL(lseek(fd, 0, SEEK_SET));

       RL(read(fd, read_buf, rwbuf_size));
       offset = lseek(fd, 0, SEEK_CUR);
       ATF_REQUIRE_EQ_MSG(offset, (off_t)rwbuf_size,
           "File offset not set after read (%jd != %zu)", (intmax_t)offset,
           rwbuf_size);

       for (size_t i = 0; i < rwbuf_size; i++)
               ATF_REQUIRE_EQ_MSG(read_buf[i], write_buf[i],
                   "Data read does not match data written");
}

ATF_TC(truncate);
ATF_TC_HEAD(truncate, tc)
{

       atf_tc_set_md_var(tc, "descr",
           "Checks that truncation does result in data removal");
}
ATF_TC_BODY(truncate, tc)
{
       int fd;
       struct stat st;

       setupbufs();

       RL(fd = memfd_create("", 0));

       tests_makegarbage(write_buf, rwbuf_size);
       tests_makegarbage(read_buf, rwbuf_size);

       RL(write(fd, write_buf, rwbuf_size));

       RL(fstat(fd, &st));
       ATF_REQUIRE_EQ_MSG(st.st_size, (off_t)rwbuf_size,
           "Write did not grow size to %zu (is %jd)", rwbuf_size,
           (intmax_t)st.st_size);

       RL(ftruncate(fd, rwbuf_size/2));
       RL(fstat(fd, &st));
       ATF_REQUIRE_EQ_MSG(st.st_size, (off_t)rwbuf_size/2,
           "Truncate did not shrink size to %zu (is %jd)",
           rwbuf_size/2, (intmax_t)st.st_size);

       RL(ftruncate(fd, rwbuf_size));
       RL(fstat(fd, &st));
       ATF_REQUIRE_EQ_MSG(st.st_size, (off_t)rwbuf_size,
           "Truncate did not grow size to %zu (is %jd)", rwbuf_size,
           (intmax_t)st.st_size);

       RL(lseek(fd, 0, SEEK_SET));
       RL(read(fd, read_buf, rwbuf_size));

       for (size_t i = 0; i < rwbuf_size/2; i++)
               ATF_REQUIRE_EQ_MSG(read_buf[i], write_buf[i],
                   "Data read does not match data written");
       for (size_t i = rwbuf_size/2; i < rwbuf_size; i++)
               ATF_REQUIRE_EQ_MSG(read_buf[i], 0,
                   "Data read on growed region is not zeroed");
}

ATF_TC(mmap);
ATF_TC_HEAD(mmap, tc)
{

       atf_tc_set_md_var(tc, "descr", "Check that mmap succeeds");
}
ATF_TC_BODY(mmap, tc)
{
       int fd;
       void *addr;

       setupbufs();

       RL(fd = memfd_create("", 0));
       RL(ftruncate(fd, rwbuf_size));

       addr = mmap(NULL, rwbuf_size, PROT_READ|PROT_WRITE, MAP_SHARED, fd, 0);
       ATF_REQUIRE_MSG(addr != MAP_FAILED,
           "mmap(NULL, %zu, 0x%x, 0x%x, %d, 0) failed: %s",
           rwbuf_size, PROT_READ|PROT_WRITE, MAP_SHARED, fd,
           strerror(errno));
}

ATF_TC(create_no_sealing);
ATF_TC_HEAD(create_no_sealing, tc)
{

       atf_tc_set_md_var(tc, "descr",
           "Checks that seals cannot be added if MFD_ALLOW_SEALING is"
           " not specified to memfd_create");
}
ATF_TC_BODY(create_no_sealing, tc)
{
       int fd;

       RL(fd = memfd_create("", 0));

       ATF_REQUIRE_EQ_MSG(fcntl(fd, F_ADD_SEALS, F_SEAL_WRITE), -1,
           "fcntl succeeded unexpectedly");
       ATF_REQUIRE_ERRNO(EPERM, true);
}

ATF_TC(seal_seal);
ATF_TC_HEAD(seal_seal, tc)
{

       atf_tc_set_md_var(tc, "descr",
           "Checks adding F_SEAL_SEAL prevents adding other seals");
}
ATF_TC_BODY(seal_seal, tc)
{
       int fd;

       RL(fd = memfd_create("", MFD_ALLOW_SEALING));
       RL(fcntl(fd, F_ADD_SEALS, F_SEAL_SEAL));

       ATF_REQUIRE_EQ_MSG(fcntl(fd, F_ADD_SEALS, F_SEAL_WRITE), -1,
           "fcntl succeeded unexpectedly");
       ATF_REQUIRE_ERRNO(EPERM, true);
}

/*
* Tests that the seals provided in except to not also prevent some
* other operation.
*
* Note: fd must have a positive size.
*/
static void
test_all_seals_except(int fd, int except)
{
       int rv;
       struct stat st;
       void *addr;

       ATF_REQUIRE(rwbuf_size > 0);

       RL(fstat(fd, &st));
       ATF_REQUIRE(st.st_size > 0);

       if (except & ~F_SEAL_SEAL) {
               rv = fcntl(fd, F_ADD_SEALS, F_SEAL_SEAL);
               if (rv == -1) {
                       ATF_REQUIRE_MSG(errno != EPERM,
                           "Seal %x prevented F_ADD_SEALS", except);
                       ATF_REQUIRE_MSG(errno == EPERM,
                           "F_ADD_SEALS failed unexpectedly (%s)",
                           strerror(errno));
               }
       }

       if (except & ~(F_SEAL_WRITE|F_SEAL_FUTURE_WRITE)) {
               RL(lseek(fd, 0, SEEK_SET));
               rv = write(fd, write_buf, rwbuf_size);
               if (rv == -1) {
                       ATF_REQUIRE_MSG(errno != EPERM,
                           "Seal %x prevented write", except);
                       ATF_REQUIRE_MSG(errno == EPERM,
                           "Write failed unexpectedly (%s)",
                           strerror(errno));
               }

               addr = mmap(NULL, st.st_size, PROT_READ|PROT_WRITE, MAP_SHARED,
                   fd, 0);
               ATF_REQUIRE_MSG(addr != MAP_FAILED,
                   "mmap(NULL, %llu, 0x%x, 0x%x, %d, 0) failed: %s",
                   (unsigned long long)st.st_size,
                   PROT_READ|PROT_WRITE, MAP_SHARED, fd,
                   strerror(errno));
       }

       if (except & ~F_SEAL_SHRINK) {
               rv = ftruncate(fd, st.st_size - 1);
               if (rv == -1) {
                       ATF_REQUIRE_MSG(errno != EPERM,
                           "Seal %x prevented truncate to shrink", except);
                       ATF_REQUIRE_MSG(errno == EPERM,
                           "Truncate failed unexpectedly (%s)",
                           strerror(errno));
               }
       }

       if (except & ~F_SEAL_GROW) {
               rv = ftruncate(fd, st.st_size + 1);
               if (rv == -1) {
                       ATF_REQUIRE_MSG(errno != EPERM,
                           "Seal %x prevented truncate to shrink", except);
                       ATF_REQUIRE_MSG(errno == EPERM,
                           "Truncate failed unexpectedly (%s)",
                           strerror(errno));
               }
       }
}

ATF_TC(seal_shrink);
ATF_TC_HEAD(seal_shrink, tc)
{

       atf_tc_set_md_var(tc, "descr",
           "Checks F_SEAL_SHRINK prevents shrinking the file");
}
ATF_TC_BODY(seal_shrink, tc)
{
       int fd;

       setupbufs();

       RL(fd = memfd_create("", MFD_ALLOW_SEALING));
       RL(ftruncate(fd, rwbuf_size));
       RL(fcntl(fd, F_ADD_SEALS, F_SEAL_SHRINK));

       ATF_REQUIRE_EQ_MSG(ftruncate(fd, rwbuf_size/2), -1,
           "Truncate succeeded unexpectedly");
       ATF_REQUIRE_ERRNO(EPERM, true);

       test_all_seals_except(fd, F_SEAL_SHRINK);
}

ATF_TC(seal_grow);
ATF_TC_HEAD(seal_grow, tc)
{

       atf_tc_set_md_var(tc, "descr",
           "Checks F_SEAL_SHRINK prevents growing the file");
}
ATF_TC_BODY(seal_grow, tc)
{
       int fd;

       setupbufs();

       RL(fd = memfd_create("", MFD_ALLOW_SEALING));
       RL(ftruncate(fd, rwbuf_size/2));
       RL(fcntl(fd, F_ADD_SEALS, F_SEAL_GROW));

       ATF_REQUIRE_EQ_MSG(ftruncate(fd, rwbuf_size), -1,
           "Truncate succeeded unexpectedly");
       ATF_REQUIRE_ERRNO(EPERM, true);

       test_all_seals_except(fd, F_SEAL_GROW);
}

ATF_TC(seal_write);
ATF_TC_HEAD(seal_write, tc)
{

       atf_tc_set_md_var(tc, "descr",
           "Checks F_SEAL_WRITE prevents writing");
}
ATF_TC_BODY(seal_write, tc)
{
       int fd;

       setupbufs();

       RL(fd = memfd_create("", MFD_ALLOW_SEALING));
       RL(ftruncate(fd, rwbuf_size/2));
       RL(fcntl(fd, F_ADD_SEALS, F_SEAL_WRITE));

       ATF_REQUIRE_EQ_MSG(write(fd, write_buf, rwbuf_size), -1,
           "Write succeeded unexpectedly");
       ATF_REQUIRE_ERRNO(EPERM, true);

       test_all_seals_except(fd, F_SEAL_WRITE);
}

ATF_TC(seal_write_mmap);
ATF_TC_HEAD(seal_write_mmap, tc)
{

       atf_tc_set_md_var(tc, "descr",
           "Checks that F_SEAL_WRITE cannot be added with open mmaps");
}
ATF_TC_BODY(seal_write_mmap, tc)
{
       int fd;
       void *addr;

       setupbufs();

       RL(fd = memfd_create("", MFD_ALLOW_SEALING));
       RL(ftruncate(fd, rwbuf_size));

       addr = mmap(NULL, rwbuf_size, PROT_READ|PROT_WRITE, MAP_SHARED, fd, 0);
       ATF_REQUIRE_MSG(addr != MAP_FAILED,
           "mmap(NULL, %zu, 0x%x, 0x%x, %d, 0) failed: %s",
           rwbuf_size, PROT_READ|PROT_WRITE, MAP_SHARED, fd,
           strerror(errno));

       ATF_REQUIRE_EQ_MSG(fcntl(fd, F_ADD_SEALS, F_SEAL_WRITE), -1,
           "fcntl succeeded unexpectedly");
       ATF_REQUIRE_ERRNO(EBUSY, true);
}

ATF_TC(seal_future_write);
ATF_TC_HEAD(seal_future_write, tc)
{

       atf_tc_set_md_var(tc, "descr",
           "Checks F_SEAL_FUTURE_WRITE prevents writing");
}
ATF_TC_BODY(seal_future_write, tc)
{
       int fd;

       setupbufs();

       RL(fd = memfd_create("", MFD_ALLOW_SEALING));
       RL(ftruncate(fd, rwbuf_size/2));
       RL(fcntl(fd, F_ADD_SEALS, F_SEAL_FUTURE_WRITE));

       ATF_REQUIRE_EQ_MSG(write(fd, write_buf, rwbuf_size), -1,
           "Write succeeded unexpectedly");
       ATF_REQUIRE_ERRNO(EPERM, true);

       test_all_seals_except(fd, F_SEAL_FUTURE_WRITE);
}

ATF_TC(seal_future_write_mmap);
ATF_TC_HEAD(seal_future_write_mmap, tc)
{

       atf_tc_set_md_var(tc, "descr",
           "Checks that F_SEAL_WRITE can be added with open mmaps but"
           " prevents creating new ones");
}
ATF_TC_BODY(seal_future_write_mmap, tc)
{
       int fd;
       void *addr;

       setupbufs();

       RL(fd = memfd_create("", MFD_ALLOW_SEALING));
       RL(ftruncate(fd, rwbuf_size));
       addr = mmap(NULL, rwbuf_size, PROT_READ|PROT_WRITE, MAP_SHARED, fd, 0);
       ATF_REQUIRE_MSG(addr != MAP_FAILED,
           "mmap(NULL, %zu, 0x%x, 0x%x, %d, 0) failed: %s",
           rwbuf_size, PROT_READ|PROT_WRITE, MAP_SHARED, fd,
           strerror(errno));

       RL(fcntl(fd, F_ADD_SEALS, F_SEAL_FUTURE_WRITE));

       ATF_REQUIRE_EQ_MSG(mmap(NULL, rwbuf_size, PROT_READ|PROT_WRITE,
               MAP_SHARED, fd, 0), MAP_FAILED,
           "mmap(NULL, %zu, 0x%x, 0x%x, %d, 0) succeeded unexpectedly",
           rwbuf_size, PROT_READ|PROT_WRITE, MAP_SHARED, fd);
       ATF_REQUIRE_ERRNO(EPERM, true);
}


ATF_TP_ADD_TCS(tp)
{
       ATF_TP_ADD_TC(tp, create_null_name);
       ATF_TP_ADD_TC(tp, create_long_name);
       ATF_TP_ADD_TC(tp, read_write);
       ATF_TP_ADD_TC(tp, truncate);
       ATF_TP_ADD_TC(tp, mmap);
       ATF_TP_ADD_TC(tp, create_no_sealing);
       ATF_TP_ADD_TC(tp, seal_seal);
       ATF_TP_ADD_TC(tp, seal_shrink);
       ATF_TP_ADD_TC(tp, seal_grow);
       ATF_TP_ADD_TC(tp, seal_write);
       ATF_TP_ADD_TC(tp, seal_write_mmap);
       ATF_TP_ADD_TC(tp, seal_future_write);
       ATF_TP_ADD_TC(tp, seal_future_write_mmap);

       return atf_no_error();
}

You are viewing proxied material from ftp.icm.edu.pl. The copyright of proxied material belongs to its original authors. Any comments or complaints in relation to proxied material should be directed to the original authors of the content concerned. Please see the disclaimer for more details.