xref: /src/tests/kernel/t_memfd_create.c

/*	$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();
}