JustOS/linux-6.13/tools/testing/selftests/powerpc/papr_sysparm/papr_sysparm.c

// SPDX-License-Identifier: GPL-2.0-only
#include <errno.h>
#include <fcntl.h>
#include <stdlib.h>
#include <sys/ioctl.h>
#include <unistd.h>
#include <asm/papr-sysparm.h>

#include "utils.h"

#define DEVPATH "/dev/papr-sysparm"

static int open_close(void)
{
	const int devfd = open(DEVPATH, O_RDONLY);

	SKIP_IF_MSG(devfd < 0 && errno == ENOENT,
		    DEVPATH " not present");

	FAIL_IF(devfd < 0);
	FAIL_IF(close(devfd) != 0);

	return 0;
}

static int get_splpar(void)
{
	struct papr_sysparm_io_block sp = {
		.parameter = 20, // SPLPAR characteristics
	};
	const int devfd = open(DEVPATH, O_RDONLY);

	SKIP_IF_MSG(devfd < 0 && errno == ENOENT,
		    DEVPATH " not present");

	FAIL_IF(devfd < 0);
	FAIL_IF(ioctl(devfd, PAPR_SYSPARM_IOC_GET, &sp) != 0);
	FAIL_IF(sp.length == 0);
	FAIL_IF(sp.length > sizeof(sp.data));
	FAIL_IF(close(devfd) != 0);

	return 0;
}

static int get_bad_parameter(void)
{
	struct papr_sysparm_io_block sp = {
		.parameter = UINT32_MAX, // there are only ~60 specified parameters
	};
	const int devfd = open(DEVPATH, O_RDONLY);

	SKIP_IF_MSG(devfd < 0 && errno == ENOENT,
		    DEVPATH " not present");

	FAIL_IF(devfd < 0);

	// Ensure expected error
	FAIL_IF(ioctl(devfd, PAPR_SYSPARM_IOC_GET, &sp) != -1);
	FAIL_IF(errno != EOPNOTSUPP);

	// Ensure the buffer is unchanged
	FAIL_IF(sp.length != 0);
	for (size_t i = 0; i < ARRAY_SIZE(sp.data); ++i)
		FAIL_IF(sp.data[i] != 0);

	FAIL_IF(close(devfd) != 0);

	return 0;
}

static int check_efault_common(unsigned long cmd)
{
	const int devfd = open(DEVPATH, O_RDWR);

	SKIP_IF_MSG(devfd < 0 && errno == ENOENT,
		    DEVPATH " not present");

	FAIL_IF(devfd < 0);

	// Ensure expected error
	FAIL_IF(ioctl(devfd, cmd, NULL) != -1);
	FAIL_IF(errno != EFAULT);

	FAIL_IF(close(devfd) != 0);

	return 0;
}

static int check_efault_get(void)
{
	return check_efault_common(PAPR_SYSPARM_IOC_GET);
}

static int check_efault_set(void)
{
	return check_efault_common(PAPR_SYSPARM_IOC_SET);
}

static int set_hmc0(void)
{
	struct papr_sysparm_io_block sp = {
		.parameter = 0, // HMC0, not a settable parameter
	};
	const int devfd = open(DEVPATH, O_RDWR);

	SKIP_IF_MSG(devfd < 0 && errno == ENOENT,
		    DEVPATH " not present");

	FAIL_IF(devfd < 0);

	// Ensure expected error
	FAIL_IF(ioctl(devfd, PAPR_SYSPARM_IOC_SET, &sp) != -1);
	SKIP_IF_MSG(errno == EOPNOTSUPP, "operation not supported");
	FAIL_IF(errno != EPERM);

	FAIL_IF(close(devfd) != 0);

	return 0;
}

static int set_with_ro_fd(void)
{
	struct papr_sysparm_io_block sp = {
		.parameter = 0, // HMC0, not a settable parameter.
	};
	const int devfd = open(DEVPATH, O_RDONLY);

	SKIP_IF_MSG(devfd < 0 && errno == ENOENT,
		    DEVPATH " not present");

	FAIL_IF(devfd < 0);

	// Ensure expected error
	FAIL_IF(ioctl(devfd, PAPR_SYSPARM_IOC_SET, &sp) != -1);
	SKIP_IF_MSG(errno == EOPNOTSUPP, "operation not supported");

	// HMC0 isn't a settable parameter and we would normally
	// expect to get EPERM on attempts to modify it. However, when
	// the file is open read-only, we expect the driver to prevent
	// the attempt with a distinct error.
	FAIL_IF(errno != EBADF);

	FAIL_IF(close(devfd) != 0);

	return 0;
}

struct sysparm_test {
	int (*function)(void);
	const char *description;
};

static const struct sysparm_test sysparm_tests[] = {
	{
		.function = open_close,
		.description = "open and close " DEVPATH " without issuing commands",
	},
	{
		.function = get_splpar,
		.description = "retrieve SPLPAR characteristics",
	},
	{
		.function = get_bad_parameter,
		.description = "verify EOPNOTSUPP for known-bad parameter",
	},
	{
		.function = check_efault_get,
		.description = "PAPR_SYSPARM_IOC_GET returns EFAULT on bad address",
	},
	{
		.function = check_efault_set,
		.description = "PAPR_SYSPARM_IOC_SET returns EFAULT on bad address",
	},
	{
		.function = set_hmc0,
		.description = "ensure EPERM on attempt to update HMC0",
	},
	{
		.function = set_with_ro_fd,
		.description = "PAPR_IOC_SYSPARM_SET returns EACCES on read-only fd",
	},
};

int main(void)
{
	size_t fails = 0;

	for (size_t i = 0; i < ARRAY_SIZE(sysparm_tests); ++i) {
		const struct sysparm_test *t = &sysparm_tests[i];

		if (test_harness(t->function, t->description))
			++fails;
	}

	return fails == 0 ? EXIT_SUCCESS : EXIT_FAILURE;
}