// SPDX-License-Identifier: GPL-2.0
#define _GNU_SOURCE
#include <stdio.h>
#include <stdlib.h>
#include <sys/mman.h>
#include <unistd.h>
#include <fcntl.h>
#include <errno.h>
#include <string.h>
#include <limits.h>
#include "kselftest.h"
#include "nommu.h"

#include <sys/vfs.h>
#ifndef RAMFS_MAGIC
#define RAMFS_MAGIC 0x858458f6
#endif

static size_t ps;
static int nommu;

static long get_fs_type(const char *path)
{
	struct statfs fs;

	if (statfs(path, &fs) == 0)
		return fs.f_type;

	return 0;
}

static void munmap_shrink_test(void)
{
	void *addr;
	int ret;

	/* munmap shrink test */
	for (int i = 0; i < 4; i++) {
		addr = mmap(NULL, ps * 4, PROT_READ | PROT_WRITE,
			    MAP_ANONYMOUS | MAP_PRIVATE, -1, 0);
		if (addr == MAP_FAILED) {
			ksft_print_msg("mmap failed: %s(%d)\n", strerror(errno), errno);
			ksft_test_result_fail("munmap shrink\n");
			return;
		}
		ret = munmap((char *)addr + ps * i, ps);
		if (ret != 0) {
			ksft_print_msg("memory %p isn't unmapped at %p\n",
				addr, (char *)addr + ps * i);
			goto error;
		}

		if (i == 0) {
			if (munmap(addr +  ps, ps * 3))
				goto error;
		} else if (i == 1) {
			if (munmap(addr, ps) || munmap(addr + (ps * 2), ps * 2))
				goto error;
		} else if (i == 2) {
			if (munmap(addr, ps * 2) || munmap(addr + (ps * 3), ps))
				goto error;
		} else if (i == 3) {
			if (munmap(addr, ps * 3))
				goto error;
		}
	}

	ksft_test_result_pass("munmap shrink\n");
	return;
error:
	for (int j = 0; j < 4; j++) {
		if (munmap((char *)addr + j * ps, ps))
			ksft_print_msg("cleanup munmap failed: %s\n", strerror(errno));
	}
	ksft_print_msg("clean up failures\n");
	ksft_test_result_fail("munmap shrink\n");
}

static size_t page_align(size_t len)
{
	return (len + ps - 1) / ps * ps;
}

static void mremap_shrink_test(void)
{
	void *addr, *addr2;
	size_t current_len;
	size_t old_len, new_len;
	struct param {
		size_t old;
		size_t new;
	} params[] = {
		/* should not happen any shrink */
		{ .old = ps * 4 - 1, .new = ps * 4 - 2 },
		/* should not happen any shrink */
		{ .old = ps * 4 - 1, .new = ps * 4 },
		{ .old = ps * 4, .new = ps * 2 },
		/* should not happen any shrink */
		{ .old = ps * 2, .new = ps * 2 - 2 },
		{ .old = ps * 2 - 2, .new = ps * 1 },
	};

	/* mremap shrink test */
	current_len = page_align(ps * 4 - 1);
	addr = mmap(NULL, ps * 4 - 1, PROT_READ | PROT_WRITE,
		    MAP_ANONYMOUS | MAP_PRIVATE, -1, 0);
	if (addr == MAP_FAILED) {
		ksft_print_msg("mmap failed: %s(%d)\n", strerror(errno), errno);
		ksft_test_result_fail("mremap shrink\n");
		return;
	}

	for (int i = 0; i < ARRAY_SIZE(params); i++) {
		old_len = params[i].old;
		new_len = params[i].new;
		current_len = page_align(new_len);
		addr2 = mremap(addr, old_len, new_len, MREMAP_MAYMOVE);
		if (addr2 == MAP_FAILED) {
			ksft_print_msg("memory %p isn't remapped at %p\n", addr, addr2);
			ksft_test_result_fail("mremap shrink\n");
			munmap(addr, page_align(old_len));
			return;
		}

		addr = addr2;
	}

	if (munmap(addr, current_len)) {
		ksft_print_msg("cleanup failed: %s\n", strerror(errno));
		ksft_test_result_fail("mremap shrink\n");
		return;
	}
	ksft_test_result_pass("mremap shrink\n");
}

static int get_shared_writable_file_expected_error(const char *path)
{
	if (nommu && get_fs_type(path) == RAMFS_MAGIC)
		return EPERM; /* ramfs failed */

	return 0;
}

struct mremap_case_t {
	const char *name;
	const char *pathname;
	int open_flags;
	int mmap_prot;
	int mmap_flags;
	int exp_err;
	int nommu_exp_err;
	int (*resolve_exp_err)(const char *path);
	unsigned int old_pages;
	unsigned int new_pages;
};

static struct mremap_case_t mremap_cases[] = {
	{
		.name = "anonymous shrink (r--)",
		.pathname = NULL,
		.open_flags = O_CREAT | O_RDWR | O_EXCL,
		.mmap_prot = PROT_READ,
		.mmap_flags = MAP_ANONYMOUS | MAP_PRIVATE,
		.exp_err = 0,
		.resolve_exp_err = 0,
	},
	{
		.name = "shared file shrink (r--)",
		.pathname = "/tmp/ksft.nommu-remap-XXXXXX",
		.open_flags = O_CREAT | O_RDWR | O_EXCL,
		.mmap_prot = PROT_READ,
		.mmap_flags = MAP_SHARED,
		.exp_err = 0,
		.resolve_exp_err = get_shared_writable_file_expected_error,
	},
	{
		.name = "private file unchanged length (r-)",
		.pathname = "/tmp/ksft.nommu-remap-XXXXXX",
		.open_flags = O_CREAT | O_RDWR | O_EXCL,
		.mmap_prot = PROT_READ,
		.mmap_flags = MAP_PRIVATE,
		.exp_err = 0,
		.nommu_exp_err = EPERM,
		.resolve_exp_err = 0,
		.old_pages = 4,
		.new_pages = 4,
	},
	{
		.name = "private file unchanged length (rw-)",
		.pathname = "/tmp/ksft.nommu-remap-XXXXXX",
		.open_flags = O_CREAT | O_RDWR | O_EXCL,
		.mmap_prot = PROT_READ | PROT_WRITE,
		.mmap_flags = MAP_PRIVATE,
		.exp_err = 0,
		.resolve_exp_err = 0,
		.old_pages = 4,
		.new_pages = 4,
	},
	{
		.name = "private file growth (r-)",
		.pathname = "/tmp/ksft.nommu-remap-XXXXXX",
		.open_flags = O_CREAT | O_RDWR | O_EXCL,
		.mmap_prot = PROT_READ,
		.mmap_flags = MAP_PRIVATE,
		.exp_err = 0,
		.nommu_exp_err = EPERM,
		.resolve_exp_err = 0,
		.old_pages = 4,
		.new_pages = 8,
	},
	{
		.name = "private file growth (rw-)",
		.pathname = "/tmp/ksft.nommu-remap-XXXXXX",
		.open_flags = O_CREAT | O_RDWR | O_EXCL,
		.mmap_prot = PROT_READ | PROT_WRITE,
		.mmap_flags = MAP_PRIVATE,
		.exp_err = 0,
		.nommu_exp_err = ENOMEM,
		.resolve_exp_err = 0,
		.old_pages = 4,
		.new_pages = 8,
	},
};

static int run_mremap_test(struct mremap_case_t *tcase)
{
	int fd = -1;
	void *addr, *addr2;
	char pb[PATH_MAX];
	const char *path = tcase->pathname;
	int rc = KSFT_PASS;
	int expected_error;
	unsigned int old_pages = tcase->old_pages ?: 4;
	unsigned int new_pages = tcase->new_pages ?: 2;
	unsigned int file_pages = old_pages > new_pages ?
				  old_pages : new_pages;

	ksft_print_msg("[RUN] Testing mremap: %s\n", tcase->name);

	if (tcase->pathname && strstr(tcase->pathname, "XXXXXX")) {
		strncpy(pb, tcase->pathname, sizeof(pb) - 1);
		pb[sizeof(pb) - 1] = '\0';
		fd = mkstemp(pb);
		if (fd < 0) {
			ksft_print_msg("Failed to setup file backing\n");
			ksft_test_result_skip("%s\n", tcase->name);
			return KSFT_SKIP;
		}
		if (ftruncate(fd, ps * file_pages) != 0) {
			ksft_print_msg("Failed to setup file backing\n");
			rc = KSFT_FAIL;
			goto out;
		}

		if (nommu && (tcase->mmap_flags & MAP_SHARED) &&
		    get_fs_type(pb) != RAMFS_MAGIC) {
			ksft_print_msg("Skip the test under non-ramfs filesystem (%s)\n",
				pb);
			rc = KSFT_SKIP;
			goto out;
		}
		path = pb;
	} else if (tcase->pathname) {
		fd = open(tcase->pathname, tcase->open_flags, 0600);
		if (fd < 0) {
			ksft_print_msg("Backing node not accessible\n");
			ksft_test_result_skip("%s\n", tcase->name);
			return KSFT_SKIP;
		}

		if (nommu && (tcase->mmap_flags & MAP_SHARED) &&
		    get_fs_type(tcase->pathname) != RAMFS_MAGIC) {
			ksft_print_msg("Skip the test under non-ramfs filesystem (%s)\n",
					      tcase->pathname);
			rc = KSFT_SKIP;
			goto out;
		}
	}

	addr = mmap(NULL, ps * old_pages, tcase->mmap_prot,
		    tcase->mmap_flags, fd, 0);
	if (addr == MAP_FAILED) {
		ksft_print_msg("mmap mapping failed %s(%d)\n", strerror(errno), errno);
		rc = KSFT_FAIL;
		goto out;
	}

	expected_error = nommu ? tcase->nommu_exp_err : tcase->exp_err;
	if (tcase->resolve_exp_err && fd >= 0)
		expected_error = tcase->resolve_exp_err(path);

	addr2 = mremap(addr, ps * old_pages, ps * new_pages,
		       MREMAP_MAYMOVE);

	if (expected_error != 0) {
		if (addr2 != MAP_FAILED) {
			ksft_print_msg("Expected error %d, but mremap unexpectedly succeeded\n",
				       expected_error);
			rc = KSFT_FAIL;
		} else if (errno != expected_error) {
			ksft_print_msg("Expected error %d, got %s(%d)\n",
				       expected_error, strerror(errno), errno);
			rc = KSFT_FAIL;
		} else {
			ksft_print_msg("%s: Handled expected error path (errno=%d)\n",
				       tcase->name, expected_error);
		}
	} else if (addr2 == MAP_FAILED) {
		ksft_print_msg("mremap shrink failed unexpectedly: %s\n",
			       strerror(errno));
		rc = KSFT_FAIL;
	} else {
		ksft_print_msg("%s step successful\n", tcase->name);
	}

	/* clean up */
	if (munmap(addr2 == MAP_FAILED ? addr : addr2,
		   addr2 == MAP_FAILED ? ps * old_pages : ps * new_pages)) {
		ksft_print_msg("munmap failed: %s\n", strerror(errno));
		rc = KSFT_FAIL;
	}

out:
	if (fd >= 0) {
		close(fd);
		if (tcase->pathname && strstr(tcase->pathname, "XXXXXX") &&
		    unlink(pb)) {
			ksft_print_msg("unlink failed for %s: %s\n", pb, strerror(errno));
			rc = KSFT_FAIL;
		}
	}

	ksft_test_result_report(rc, "%s\n", tcase->name);
	return rc;
}

int main(int argc, char **argv)
{
	int i;

	nommu = ksft_is_nommu();
	if (nommu < 0)
		ksft_exit_skip("Cannot read /proc/meminfo; mount procfs at /proc\n");

	ps = sysconf(_SC_PAGESIZE);
	ksft_print_header();
	ksft_set_plan(ARRAY_SIZE(mremap_cases) + 2);

	munmap_shrink_test();
	mremap_shrink_test();

	for (i = 0; i < (int)ARRAY_SIZE(mremap_cases); i++)
		run_mremap_test(&mremap_cases[i]);

	ksft_finished();
}