| // 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"); |
| } |