1 | // SPDX-License-Identifier: GPL-2.0-only |
2 | |
3 | #define pr_fmt(fmt) "papr-sysparm: " fmt |
4 | |
5 | #include <linux/anon_inodes.h> |
6 | #include <linux/bug.h> |
7 | #include <linux/file.h> |
8 | #include <linux/fs.h> |
9 | #include <linux/init.h> |
10 | #include <linux/kernel.h> |
11 | #include <linux/miscdevice.h> |
12 | #include <linux/printk.h> |
13 | #include <linux/slab.h> |
14 | #include <linux/uaccess.h> |
15 | #include <asm/machdep.h> |
16 | #include <asm/papr-sysparm.h> |
17 | #include <asm/rtas-work-area.h> |
18 | #include <asm/rtas.h> |
19 | |
20 | struct papr_sysparm_buf *papr_sysparm_buf_alloc(void) |
21 | { |
22 | struct papr_sysparm_buf *buf = kzalloc(sizeof(*buf), GFP_KERNEL); |
23 | |
24 | return buf; |
25 | } |
26 | |
27 | void papr_sysparm_buf_free(struct papr_sysparm_buf *buf) |
28 | { |
29 | kfree(objp: buf); |
30 | } |
31 | |
32 | static size_t papr_sysparm_buf_get_length(const struct papr_sysparm_buf *buf) |
33 | { |
34 | return be16_to_cpu(buf->len); |
35 | } |
36 | |
37 | static void papr_sysparm_buf_set_length(struct papr_sysparm_buf *buf, size_t length) |
38 | { |
39 | WARN_ONCE(length > sizeof(buf->val), |
40 | "bogus length %zu, clamping to safe value" , length); |
41 | length = min(sizeof(buf->val), length); |
42 | buf->len = cpu_to_be16(length); |
43 | } |
44 | |
45 | /* |
46 | * For use on buffers returned from ibm,get-system-parameter before |
47 | * returning them to callers. Ensures the encoded length of valid data |
48 | * cannot overrun buf->val[]. |
49 | */ |
50 | static void papr_sysparm_buf_clamp_length(struct papr_sysparm_buf *buf) |
51 | { |
52 | papr_sysparm_buf_set_length(buf, length: papr_sysparm_buf_get_length(buf)); |
53 | } |
54 | |
55 | /* |
56 | * Perform some basic diligence on the system parameter buffer before |
57 | * submitting it to RTAS. |
58 | */ |
59 | static bool papr_sysparm_buf_can_submit(const struct papr_sysparm_buf *buf) |
60 | { |
61 | /* |
62 | * Firmware ought to reject buffer lengths that exceed the |
63 | * maximum specified in PAPR, but there's no reason for the |
64 | * kernel to allow them either. |
65 | */ |
66 | if (papr_sysparm_buf_get_length(buf) > sizeof(buf->val)) |
67 | return false; |
68 | |
69 | return true; |
70 | } |
71 | |
72 | /** |
73 | * papr_sysparm_get() - Retrieve the value of a PAPR system parameter. |
74 | * @param: PAPR system parameter token as described in |
75 | * 7.3.16 "System Parameters Option". |
76 | * @buf: A &struct papr_sysparm_buf as returned from papr_sysparm_buf_alloc(). |
77 | * |
78 | * Place the result of querying the specified parameter, if available, |
79 | * in @buf. The result includes a be16 length header followed by the |
80 | * value, which may be a string or binary data. See &struct papr_sysparm_buf. |
81 | * |
82 | * Since there is at least one parameter (60, OS Service Entitlement |
83 | * Status) where the results depend on the incoming contents of the |
84 | * work area, the caller-supplied buffer is copied unmodified into the |
85 | * work area before calling ibm,get-system-parameter. |
86 | * |
87 | * A defined parameter may not be implemented on a given system, and |
88 | * some implemented parameters may not be available to all partitions |
89 | * on a system. A parameter's disposition may change at any time due |
90 | * to system configuration changes or partition migration. |
91 | * |
92 | * Context: This function may sleep. |
93 | * |
94 | * Return: 0 on success, -errno otherwise. @buf is unmodified on error. |
95 | */ |
96 | int papr_sysparm_get(papr_sysparm_t param, struct papr_sysparm_buf *buf) |
97 | { |
98 | const s32 token = rtas_function_token(RTAS_FN_IBM_GET_SYSTEM_PARAMETER); |
99 | struct rtas_work_area *work_area; |
100 | s32 fwrc; |
101 | int ret; |
102 | |
103 | might_sleep(); |
104 | |
105 | if (WARN_ON(!buf)) |
106 | return -EFAULT; |
107 | |
108 | if (token == RTAS_UNKNOWN_SERVICE) |
109 | return -ENOENT; |
110 | |
111 | if (!papr_sysparm_buf_can_submit(buf)) |
112 | return -EINVAL; |
113 | |
114 | work_area = rtas_work_area_alloc(sizeof(*buf)); |
115 | |
116 | memcpy(rtas_work_area_raw_buf(work_area), buf, sizeof(*buf)); |
117 | |
118 | do { |
119 | fwrc = rtas_call(token, 3, 1, NULL, param.token, |
120 | rtas_work_area_phys(work_area), |
121 | rtas_work_area_size(work_area)); |
122 | } while (rtas_busy_delay(fwrc)); |
123 | |
124 | switch (fwrc) { |
125 | case 0: |
126 | ret = 0; |
127 | memcpy(buf, rtas_work_area_raw_buf(work_area), sizeof(*buf)); |
128 | papr_sysparm_buf_clamp_length(buf); |
129 | break; |
130 | case -3: /* parameter not implemented */ |
131 | ret = -EOPNOTSUPP; |
132 | break; |
133 | case -9002: /* this partition not authorized to retrieve this parameter */ |
134 | ret = -EPERM; |
135 | break; |
136 | case -9999: /* "parameter error" e.g. the buffer is too small */ |
137 | ret = -EINVAL; |
138 | break; |
139 | default: |
140 | pr_err("unexpected ibm,get-system-parameter result %d\n" , fwrc); |
141 | fallthrough; |
142 | case -1: /* Hardware/platform error */ |
143 | ret = -EIO; |
144 | break; |
145 | } |
146 | |
147 | rtas_work_area_free(work_area); |
148 | |
149 | return ret; |
150 | } |
151 | |
152 | int papr_sysparm_set(papr_sysparm_t param, const struct papr_sysparm_buf *buf) |
153 | { |
154 | const s32 token = rtas_function_token(RTAS_FN_IBM_SET_SYSTEM_PARAMETER); |
155 | struct rtas_work_area *work_area; |
156 | s32 fwrc; |
157 | int ret; |
158 | |
159 | might_sleep(); |
160 | |
161 | if (WARN_ON(!buf)) |
162 | return -EFAULT; |
163 | |
164 | if (token == RTAS_UNKNOWN_SERVICE) |
165 | return -ENOENT; |
166 | |
167 | if (!papr_sysparm_buf_can_submit(buf)) |
168 | return -EINVAL; |
169 | |
170 | work_area = rtas_work_area_alloc(sizeof(*buf)); |
171 | |
172 | memcpy(rtas_work_area_raw_buf(work_area), buf, sizeof(*buf)); |
173 | |
174 | do { |
175 | fwrc = rtas_call(token, 2, 1, NULL, param.token, |
176 | rtas_work_area_phys(work_area)); |
177 | } while (rtas_busy_delay(fwrc)); |
178 | |
179 | switch (fwrc) { |
180 | case 0: |
181 | ret = 0; |
182 | break; |
183 | case -3: /* parameter not supported */ |
184 | ret = -EOPNOTSUPP; |
185 | break; |
186 | case -9002: /* this partition not authorized to modify this parameter */ |
187 | ret = -EPERM; |
188 | break; |
189 | case -9999: /* "parameter error" e.g. invalid input data */ |
190 | ret = -EINVAL; |
191 | break; |
192 | default: |
193 | pr_err("unexpected ibm,set-system-parameter result %d\n" , fwrc); |
194 | fallthrough; |
195 | case -1: /* Hardware/platform error */ |
196 | ret = -EIO; |
197 | break; |
198 | } |
199 | |
200 | rtas_work_area_free(work_area); |
201 | |
202 | return ret; |
203 | } |
204 | |
205 | static struct papr_sysparm_buf * |
206 | papr_sysparm_buf_from_user(const struct papr_sysparm_io_block __user *user_iob) |
207 | { |
208 | struct papr_sysparm_buf *kern_spbuf; |
209 | long err; |
210 | u16 len; |
211 | |
212 | /* |
213 | * The length of valid data that userspace claims to be in |
214 | * user_iob->data[]. |
215 | */ |
216 | if (get_user(len, &user_iob->length)) |
217 | return ERR_PTR(error: -EFAULT); |
218 | |
219 | static_assert(sizeof(user_iob->data) >= PAPR_SYSPARM_MAX_INPUT); |
220 | static_assert(sizeof(kern_spbuf->val) >= PAPR_SYSPARM_MAX_INPUT); |
221 | |
222 | if (len > PAPR_SYSPARM_MAX_INPUT) |
223 | return ERR_PTR(error: -EINVAL); |
224 | |
225 | kern_spbuf = papr_sysparm_buf_alloc(); |
226 | if (!kern_spbuf) |
227 | return ERR_PTR(error: -ENOMEM); |
228 | |
229 | papr_sysparm_buf_set_length(buf: kern_spbuf, length: len); |
230 | |
231 | if (len > 0 && copy_from_user(to: kern_spbuf->val, from: user_iob->data, n: len)) { |
232 | err = -EFAULT; |
233 | goto free_sysparm_buf; |
234 | } |
235 | |
236 | return kern_spbuf; |
237 | |
238 | free_sysparm_buf: |
239 | papr_sysparm_buf_free(buf: kern_spbuf); |
240 | return ERR_PTR(error: err); |
241 | } |
242 | |
243 | static int papr_sysparm_buf_to_user(const struct papr_sysparm_buf *kern_spbuf, |
244 | struct papr_sysparm_io_block __user *user_iob) |
245 | { |
246 | u16 len_out = papr_sysparm_buf_get_length(buf: kern_spbuf); |
247 | |
248 | if (put_user(len_out, &user_iob->length)) |
249 | return -EFAULT; |
250 | |
251 | static_assert(sizeof(user_iob->data) >= PAPR_SYSPARM_MAX_OUTPUT); |
252 | static_assert(sizeof(kern_spbuf->val) >= PAPR_SYSPARM_MAX_OUTPUT); |
253 | |
254 | if (copy_to_user(to: user_iob->data, from: kern_spbuf->val, n: PAPR_SYSPARM_MAX_OUTPUT)) |
255 | return -EFAULT; |
256 | |
257 | return 0; |
258 | } |
259 | |
260 | static long papr_sysparm_ioctl_get(struct papr_sysparm_io_block __user *user_iob) |
261 | { |
262 | struct papr_sysparm_buf *kern_spbuf; |
263 | papr_sysparm_t param; |
264 | long ret; |
265 | |
266 | if (get_user(param.token, &user_iob->parameter)) |
267 | return -EFAULT; |
268 | |
269 | kern_spbuf = papr_sysparm_buf_from_user(user_iob); |
270 | if (IS_ERR(ptr: kern_spbuf)) |
271 | return PTR_ERR(ptr: kern_spbuf); |
272 | |
273 | ret = papr_sysparm_get(param, kern_spbuf); |
274 | if (ret) |
275 | goto free_sysparm_buf; |
276 | |
277 | ret = papr_sysparm_buf_to_user(kern_spbuf, user_iob); |
278 | if (ret) |
279 | goto free_sysparm_buf; |
280 | |
281 | ret = 0; |
282 | |
283 | free_sysparm_buf: |
284 | papr_sysparm_buf_free(buf: kern_spbuf); |
285 | return ret; |
286 | } |
287 | |
288 | |
289 | static long papr_sysparm_ioctl_set(struct papr_sysparm_io_block __user *user_iob) |
290 | { |
291 | struct papr_sysparm_buf *kern_spbuf; |
292 | papr_sysparm_t param; |
293 | long ret; |
294 | |
295 | if (get_user(param.token, &user_iob->parameter)) |
296 | return -EFAULT; |
297 | |
298 | kern_spbuf = papr_sysparm_buf_from_user(user_iob); |
299 | if (IS_ERR(ptr: kern_spbuf)) |
300 | return PTR_ERR(ptr: kern_spbuf); |
301 | |
302 | ret = papr_sysparm_set(param, kern_spbuf); |
303 | if (ret) |
304 | goto free_sysparm_buf; |
305 | |
306 | ret = 0; |
307 | |
308 | free_sysparm_buf: |
309 | papr_sysparm_buf_free(buf: kern_spbuf); |
310 | return ret; |
311 | } |
312 | |
313 | static long papr_sysparm_ioctl(struct file *filp, unsigned int ioctl, unsigned long arg) |
314 | { |
315 | void __user *argp = (__force void __user *)arg; |
316 | long ret; |
317 | |
318 | switch (ioctl) { |
319 | case PAPR_SYSPARM_IOC_GET: |
320 | ret = papr_sysparm_ioctl_get(user_iob: argp); |
321 | break; |
322 | case PAPR_SYSPARM_IOC_SET: |
323 | if (filp->f_mode & FMODE_WRITE) |
324 | ret = papr_sysparm_ioctl_set(user_iob: argp); |
325 | else |
326 | ret = -EBADF; |
327 | break; |
328 | default: |
329 | ret = -ENOIOCTLCMD; |
330 | break; |
331 | } |
332 | return ret; |
333 | } |
334 | |
335 | static const struct file_operations papr_sysparm_ops = { |
336 | .unlocked_ioctl = papr_sysparm_ioctl, |
337 | }; |
338 | |
339 | static struct miscdevice papr_sysparm_dev = { |
340 | .minor = MISC_DYNAMIC_MINOR, |
341 | .name = "papr-sysparm" , |
342 | .fops = &papr_sysparm_ops, |
343 | }; |
344 | |
345 | static __init int papr_sysparm_init(void) |
346 | { |
347 | if (!rtas_function_implemented(RTAS_FN_IBM_GET_SYSTEM_PARAMETER)) |
348 | return -ENODEV; |
349 | |
350 | return misc_register(misc: &papr_sysparm_dev); |
351 | } |
352 | machine_device_initcall(pseries, papr_sysparm_init); |
353 | |