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 | |
37 | static const char *ofdt_rtas_path = "/proc/device-tree/rtas" ; |
38 | |
39 | typedef __be32 uint32_t; |
40 | struct 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 | |
48 | struct region { |
49 | uint64_t addr; |
50 | uint32_t size; |
51 | struct region *next; |
52 | }; |
53 | |
54 | static 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 | |
66 | int 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 | |
80 | err: |
81 | free(prop_buf); |
82 | return rc; |
83 | } |
84 | |
85 | static 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 | |
108 | static 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 | |
150 | err: |
151 | va_end(ap); |
152 | return rc; |
153 | } |
154 | |
155 | static 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 | |
221 | int main(int argc, char *argv[]) |
222 | { |
223 | return test_harness(test, "rtas_filter" ); |
224 | } |
225 | |