selftests/powerpc: Add a rtas_filter selftest

# SPDX-License-Identifier: GPL-2.0-only

TEST_GEN_PROGS := ipc_unmuxed

TEST_GEN_PROGS := ipc_unmuxed rtas_filter

CFLAGS += -I../../../../../usr/include

// SPDX-License-Identifier: GPL-2.0+

/*

 * Copyright 2005-2020 IBM Corporation.

 *

 * Includes code from librtas (https://github.com/ibm-power-utilities/librtas/)

 */

#include <byteswap.h>

#include <stdint.h>

#include <inttypes.h>

#include <stdio.h>

#include <string.h>

#include <sys/syscall.h>

#include <sys/types.h>

#include <unistd.h>

#include <stdarg.h>

#include <stdlib.h>

#include <fcntl.h>

#include <errno.h>

#include "utils.h"

#if __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__

#define cpu_to_be32(x)		bswap_32(x)

#define be32_to_cpu(x)		bswap_32(x)

#else

#define cpu_to_be32(x)		(x)

#define be32_to_cpu(x)		(x)

#endif

#define RTAS_IO_ASSERT	-1098	/* Unexpected I/O Error */

#define RTAS_UNKNOWN_OP -1099	/* No Firmware Implementation of Function */

#define BLOCK_SIZE 4096

#define PAGE_SIZE 4096

#define MAX_PAGES 64

static const char *ofdt_rtas_path = "/proc/device-tree/rtas";

typedef __be32 uint32_t;

struct rtas_args {

	__be32 token;

	__be32 nargs;

	__be32 nret;

	__be32 args[16];

	__be32 *rets;	  /* Pointer to return values in args[]. */

};

struct region {

	uint64_t addr;

	uint32_t size;

	struct region *next;

};

int read_entire_file(int fd, char **buf, size_t *len)

{

	size_t buf_size = 0;

	size_t off = 0;

	int rc;

	*buf = NULL;

	do {

		buf_size += BLOCK_SIZE;

		if (*buf == NULL)

			*buf = malloc(buf_size);

		else

			*buf = realloc(*buf, buf_size);

		if (*buf == NULL)

			return -ENOMEM;

		rc = read(fd, *buf + off, BLOCK_SIZE);

		if (rc < 0)

			return -EIO;

		off += rc;

	} while (rc == BLOCK_SIZE);

	if (len)

		*len = off;

	return 0;

}

static int open_prop_file(const char *prop_path, const char *prop_name, int *fd)

{

	char *path;

	int len;

	/* allocate enough for two string, a slash and trailing NULL */

	len = strlen(prop_path) + strlen(prop_name) + 1 + 1;

	path = malloc(len);

	if (path == NULL)

		return -ENOMEM;

	snprintf(path, len, "%s/%s", prop_path, prop_name);

	*fd = open(path, O_RDONLY);

	free(path);

	if (*fd < 0)

		return -errno;

	return 0;

}

static int get_property(const char *prop_path, const char *prop_name,

			char **prop_val, size_t *prop_len)

{

	int rc, fd;

	rc = open_prop_file(prop_path, prop_name, &fd);

	if (rc)

		return rc;

	rc = read_entire_file(fd, prop_val, prop_len);

	close(fd);

	return rc;

}

int rtas_token(const char *call_name)

{

	char *prop_buf = NULL;

	size_t len;

	int rc;

	rc = get_property(ofdt_rtas_path, call_name, &prop_buf, &len);

	if (rc < 0) {

		rc = RTAS_UNKNOWN_OP;

		goto err;

	}

	rc = be32_to_cpu(*(int *)prop_buf);

err:

	free(prop_buf);

	return rc;

}

static int read_kregion_bounds(struct region *kregion)

{

	char *buf;

	int fd;

	int rc;

	fd = open("/proc/ppc64/rtas/rmo_buffer", O_RDONLY);

	if (fd < 0) {

		printf("Could not open rmo_buffer file\n");

		return RTAS_IO_ASSERT;

	}

	rc = read_entire_file(fd, &buf, NULL);

	close(fd);

	if (rc) {

		free(buf);

		return rc;

	}

	sscanf(buf, "%" SCNx64 " %x", &kregion->addr, &kregion->size);

	free(buf);

	if (!(kregion->size && kregion->addr) ||

	    (kregion->size > (PAGE_SIZE * MAX_PAGES))) {

		printf("Unexpected kregion bounds\n");

		return RTAS_IO_ASSERT;

	}

	return 0;

}

static int rtas_call(const char *name, int nargs,

		     int nrets, ...)

{

	struct rtas_args args;

	__be32 *rets[16];

	int i, rc, token;

	va_list ap;

	va_start(ap, nrets);

	token = rtas_token(name);

	if (token == RTAS_UNKNOWN_OP) {

		// We don't care if the call doesn't exist

		printf("call '%s' not available, skipping...", name);

		rc = RTAS_UNKNOWN_OP;

		goto err;

	}

	args.token = cpu_to_be32(token);

	args.nargs = cpu_to_be32(nargs);

	args.nret = cpu_to_be32(nrets);

	for (i = 0; i < nargs; i++)

		args.args[i] = (__be32) va_arg(ap, unsigned long);

	for (i = 0; i < nrets; i++)

		rets[i] = (__be32 *) va_arg(ap, unsigned long);

	rc = syscall(__NR_rtas, &args);

	if (rc) {

		rc = -errno;

		goto err;

	}

	if (nrets) {

		*(rets[0]) = be32_to_cpu(args.args[nargs]);

		for (i = 1; i < nrets; i++) {

			*(rets[i]) = args.args[nargs + i];

		}

	}

err:

	va_end(ap);

	return rc;

}

static int test(void)

{

	struct region rmo_region;

	uint32_t rmo_start;

	uint32_t rmo_end;

	__be32 rets[1];

	int rc;

	// Test a legitimate harmless call

	// Expected: call succeeds

	printf("Test a permitted call, no parameters... ");

	rc = rtas_call("get-time-of-day", 0, 1, rets);

	printf("rc: %d\n", rc);

	FAIL_IF(rc != 0 && rc != RTAS_UNKNOWN_OP);

	// Test a prohibited call

	// Expected: call returns -EINVAL

	printf("Test a prohibited call... ");

	rc = rtas_call("nvram-fetch", 0, 1, rets);

	printf("rc: %d\n", rc);

	FAIL_IF(rc != -EINVAL && rc != RTAS_UNKNOWN_OP);

	// Get RMO

	rc = read_kregion_bounds(&rmo_region);

	if (rc) {

		printf("Couldn't read RMO region bounds, skipping remaining cases\n");

		return 0;

	}

	rmo_start = rmo_region.addr;

	rmo_end = rmo_start + rmo_region.size - 1;

	printf("RMO range: %08x - %08x\n", rmo_start, rmo_end);

	// Test a permitted call, user-supplied size, buffer inside RMO

	// Expected: call succeeds

	printf("Test a permitted call, user-supplied size, buffer inside RMO... ");

	rc = rtas_call("ibm,get-system-parameter", 3, 1, 0, cpu_to_be32(rmo_start),

		       cpu_to_be32(rmo_end - rmo_start + 1), rets);

	printf("rc: %d\n", rc);

	FAIL_IF(rc != 0 && rc != RTAS_UNKNOWN_OP);

	// Test a permitted call, user-supplied size, buffer start outside RMO

	// Expected: call returns -EINVAL

	printf("Test a permitted call, user-supplied size, buffer start outside RMO... ");

	rc = rtas_call("ibm,get-system-parameter", 3, 1, 0, cpu_to_be32(rmo_end + 1),

		       cpu_to_be32(4000), rets);

	printf("rc: %d\n", rc);

	FAIL_IF(rc != -EINVAL && rc != RTAS_UNKNOWN_OP);

	// Test a permitted call, user-supplied size, buffer end outside RMO

	// Expected: call returns -EINVAL

	printf("Test a permitted call, user-supplied size, buffer end outside RMO... ");

	rc = rtas_call("ibm,get-system-parameter", 3, 1, 0, cpu_to_be32(rmo_start),

		       cpu_to_be32(rmo_end - rmo_start + 2), rets);

	printf("rc: %d\n", rc);

	FAIL_IF(rc != -EINVAL && rc != RTAS_UNKNOWN_OP);

	// Test a permitted call, fixed size, buffer end outside RMO

	// Expected: call returns -EINVAL

	printf("Test a permitted call, fixed size, buffer end outside RMO... ");

	rc = rtas_call("ibm,configure-connector", 2, 1, cpu_to_be32(rmo_end - 4000), 0, rets);

	printf("rc: %d\n", rc);

	FAIL_IF(rc != -EINVAL && rc != RTAS_UNKNOWN_OP);

	return 0;

}

int main(int argc, char *argv[])

{

	return test_harness(test, "rtas_filter");

}