1// SPDX-License-Identifier: GPL-2.0+
2/*
3 * Copyright 2005-2020 IBM Corporation.
4 *
5 * Includes code from librtas (https://github.com/ibm-power-utilities/librtas/)
6 */
7
8#include <byteswap.h>
9#include <stdint.h>
10#include <inttypes.h>
11#include <linux/limits.h>
12#include <stdio.h>
13#include <string.h>
14#include <sys/syscall.h>
15#include <sys/types.h>
16#include <unistd.h>
17#include <stdarg.h>
18#include <stdlib.h>
19#include <fcntl.h>
20#include <errno.h>
21#include "utils.h"
22
23#if __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__
24#define cpu_to_be32(x) bswap_32(x)
25#define be32_to_cpu(x) bswap_32(x)
26#else
27#define cpu_to_be32(x) (x)
28#define be32_to_cpu(x) (x)
29#endif
30
31#define RTAS_IO_ASSERT -1098 /* Unexpected I/O Error */
32#define RTAS_UNKNOWN_OP -1099 /* No Firmware Implementation of Function */
33#define BLOCK_SIZE 4096
34#define PAGE_SIZE 4096
35#define MAX_PAGES 64
36
37static const char *ofdt_rtas_path = "/proc/device-tree/rtas";
38
39typedef __be32 uint32_t;
40struct rtas_args {
41 __be32 token;
42 __be32 nargs;
43 __be32 nret;
44 __be32 args[16];
45 __be32 *rets; /* Pointer to return values in args[]. */
46};
47
48struct region {
49 uint64_t addr;
50 uint32_t size;
51 struct region *next;
52};
53
54static int get_property(const char *prop_path, const char *prop_name,
55 char **prop_val, size_t *prop_len)
56{
57 char path[PATH_MAX];
58
59 int len = snprintf(path, sizeof(path), "%s/%s", prop_path, prop_name);
60 if (len < 0 || len >= sizeof(path))
61 return -ENOMEM;
62
63 return read_file_alloc(path, prop_val, prop_len);
64}
65
66int rtas_token(const char *call_name)
67{
68 char *prop_buf = NULL;
69 size_t len;
70 int rc;
71
72 rc = get_property(prop_path: ofdt_rtas_path, prop_name: call_name, prop_val: &prop_buf, prop_len: &len);
73 if (rc < 0) {
74 rc = RTAS_UNKNOWN_OP;
75 goto err;
76 }
77
78 rc = be32_to_cpu(*(int *)prop_buf);
79
80err:
81 free(prop_buf);
82 return rc;
83}
84
85static int read_kregion_bounds(struct region *kregion)
86{
87 char *buf;
88 int err;
89
90 err = read_file_alloc("/proc/ppc64/rtas/rmo_buffer", &buf, NULL);
91 if (err) {
92 perror("Could not open rmo_buffer file");
93 return RTAS_IO_ASSERT;
94 }
95
96 sscanf(buf, "%" SCNx64 " %x", &kregion->addr, &kregion->size);
97 free(buf);
98
99 if (!(kregion->size && kregion->addr) ||
100 (kregion->size > (PAGE_SIZE * MAX_PAGES))) {
101 printf("Unexpected kregion bounds\n");
102 return RTAS_IO_ASSERT;
103 }
104
105 return 0;
106}
107
108static int rtas_call(const char *name, int nargs,
109 int nrets, ...)
110{
111 struct rtas_args args;
112 __be32 *rets[16];
113 int i, rc, token;
114 va_list ap;
115
116 va_start(ap, nrets);
117
118 token = rtas_token(call_name: name);
119 if (token == RTAS_UNKNOWN_OP) {
120 // We don't care if the call doesn't exist
121 printf("call '%s' not available, skipping...", name);
122 rc = RTAS_UNKNOWN_OP;
123 goto err;
124 }
125
126 args.token = cpu_to_be32(token);
127 args.nargs = cpu_to_be32(nargs);
128 args.nret = cpu_to_be32(nrets);
129
130 for (i = 0; i < nargs; i++)
131 args.args[i] = (__be32) va_arg(ap, unsigned long);
132
133 for (i = 0; i < nrets; i++)
134 rets[i] = (__be32 *) va_arg(ap, unsigned long);
135
136 rc = syscall(__NR_rtas, &args);
137 if (rc) {
138 rc = -errno;
139 goto err;
140 }
141
142 if (nrets) {
143 *(rets[0]) = be32_to_cpu(args.args[nargs]);
144
145 for (i = 1; i < nrets; i++) {
146 *(rets[i]) = args.args[nargs + i];
147 }
148 }
149
150err:
151 va_end(ap);
152 return rc;
153}
154
155static int test(void)
156{
157 struct region rmo_region;
158 uint32_t rmo_start;
159 uint32_t rmo_end;
160 __be32 rets[1];
161 int rc;
162
163 // Test a legitimate harmless call
164 // Expected: call succeeds
165 printf("Test a permitted call, no parameters... ");
166 rc = rtas_call(name: "get-time-of-day", nargs: 0, nrets: 1, rets);
167 printf("rc: %d\n", rc);
168 FAIL_IF(rc != 0 && rc != RTAS_UNKNOWN_OP);
169
170 // Test a prohibited call
171 // Expected: call returns -EINVAL
172 printf("Test a prohibited call... ");
173 rc = rtas_call(name: "nvram-fetch", nargs: 0, nrets: 1, rets);
174 printf("rc: %d\n", rc);
175 FAIL_IF(rc != -EINVAL && rc != RTAS_UNKNOWN_OP);
176
177 // Get RMO
178 rc = read_kregion_bounds(kregion: &rmo_region);
179 if (rc) {
180 printf("Couldn't read RMO region bounds, skipping remaining cases\n");
181 return 0;
182 }
183 rmo_start = rmo_region.addr;
184 rmo_end = rmo_start + rmo_region.size - 1;
185 printf("RMO range: %08x - %08x\n", rmo_start, rmo_end);
186
187 // Test a permitted call, user-supplied size, buffer inside RMO
188 // Expected: call succeeds
189 printf("Test a permitted call, user-supplied size, buffer inside RMO... ");
190 rc = rtas_call(name: "ibm,get-system-parameter", nargs: 3, nrets: 1, 0, cpu_to_be32(rmo_start),
191 cpu_to_be32(rmo_end - rmo_start + 1), rets);
192 printf("rc: %d\n", rc);
193 FAIL_IF(rc != 0 && rc != RTAS_UNKNOWN_OP);
194
195 // Test a permitted call, user-supplied size, buffer start outside RMO
196 // Expected: call returns -EINVAL
197 printf("Test a permitted call, user-supplied size, buffer start outside RMO... ");
198 rc = rtas_call(name: "ibm,get-system-parameter", nargs: 3, nrets: 1, 0, cpu_to_be32(rmo_end + 1),
199 cpu_to_be32(4000), rets);
200 printf("rc: %d\n", rc);
201 FAIL_IF(rc != -EINVAL && rc != RTAS_UNKNOWN_OP);
202
203 // Test a permitted call, user-supplied size, buffer end outside RMO
204 // Expected: call returns -EINVAL
205 printf("Test a permitted call, user-supplied size, buffer end outside RMO... ");
206 rc = rtas_call(name: "ibm,get-system-parameter", nargs: 3, nrets: 1, 0, cpu_to_be32(rmo_start),
207 cpu_to_be32(rmo_end - rmo_start + 2), rets);
208 printf("rc: %d\n", rc);
209 FAIL_IF(rc != -EINVAL && rc != RTAS_UNKNOWN_OP);
210
211 // Test a permitted call, fixed size, buffer end outside RMO
212 // Expected: call returns -EINVAL
213 printf("Test a permitted call, fixed size, buffer end outside RMO... ");
214 rc = rtas_call(name: "ibm,configure-connector", nargs: 2, nrets: 1, cpu_to_be32(rmo_end - 4000), 0, rets);
215 printf("rc: %d\n", rc);
216 FAIL_IF(rc != -EINVAL && rc != RTAS_UNKNOWN_OP);
217
218 return 0;
219}
220
221int main(int argc, char *argv[])
222{
223 return test_harness(test, "rtas_filter");
224}
225

source code of linux/tools/testing/selftests/powerpc/syscalls/rtas_filter.c