1 | /* |
2 | * Nios II Semihosting syscall interface. |
3 | * This code is derived from m68k-semi.c. |
4 | * The semihosting protocol implemented here is described in the |
5 | * libgloss sources: |
6 | * https://sourceware.org/git/gitweb.cgi?p=newlib-cygwin.git;a=blob;f=libgloss/nios2/nios2-semi.txt;hb=HEAD |
7 | * |
8 | * Copyright (c) 2017-2019 Mentor Graphics |
9 | * |
10 | * This program is free software; you can redistribute it and/or modify |
11 | * it under the terms of the GNU General Public License as published by |
12 | * the Free Software Foundation; either version 2 of the License, or |
13 | * (at your option) any later version. |
14 | * |
15 | * This program is distributed in the hope that it will be useful, |
16 | * but WITHOUT ANY WARRANTY; without even the implied warranty of |
17 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
18 | * GNU General Public License for more details. |
19 | * |
20 | * You should have received a copy of the GNU General Public License |
21 | * along with this program; if not, see <http://www.gnu.org/licenses/>. |
22 | */ |
23 | |
24 | #include "qemu/osdep.h" |
25 | |
26 | #include "cpu.h" |
27 | #if defined(CONFIG_USER_ONLY) |
28 | #include "qemu.h" |
29 | #else |
30 | #include "qemu-common.h" |
31 | #include "exec/gdbstub.h" |
32 | #include "exec/softmmu-semi.h" |
33 | #endif |
34 | #include "qemu/log.h" |
35 | |
36 | #define HOSTED_EXIT 0 |
37 | #define HOSTED_INIT_SIM 1 |
38 | #define HOSTED_OPEN 2 |
39 | #define HOSTED_CLOSE 3 |
40 | #define HOSTED_READ 4 |
41 | #define HOSTED_WRITE 5 |
42 | #define HOSTED_LSEEK 6 |
43 | #define HOSTED_RENAME 7 |
44 | #define HOSTED_UNLINK 8 |
45 | #define HOSTED_STAT 9 |
46 | #define HOSTED_FSTAT 10 |
47 | #define HOSTED_GETTIMEOFDAY 11 |
48 | #define HOSTED_ISATTY 12 |
49 | #define HOSTED_SYSTEM 13 |
50 | |
51 | typedef uint32_t gdb_mode_t; |
52 | typedef uint32_t gdb_time_t; |
53 | |
54 | struct nios2_gdb_stat { |
55 | uint32_t gdb_st_dev; /* device */ |
56 | uint32_t gdb_st_ino; /* inode */ |
57 | gdb_mode_t gdb_st_mode; /* protection */ |
58 | uint32_t gdb_st_nlink; /* number of hard links */ |
59 | uint32_t gdb_st_uid; /* user ID of owner */ |
60 | uint32_t gdb_st_gid; /* group ID of owner */ |
61 | uint32_t gdb_st_rdev; /* device type (if inode device) */ |
62 | uint64_t gdb_st_size; /* total size, in bytes */ |
63 | uint64_t gdb_st_blksize; /* blocksize for filesystem I/O */ |
64 | uint64_t gdb_st_blocks; /* number of blocks allocated */ |
65 | gdb_time_t gdb_st_atime; /* time of last access */ |
66 | gdb_time_t gdb_st_mtime; /* time of last modification */ |
67 | gdb_time_t gdb_st_ctime; /* time of last change */ |
68 | } QEMU_PACKED; |
69 | |
70 | struct gdb_timeval { |
71 | gdb_time_t tv_sec; /* second */ |
72 | uint64_t tv_usec; /* microsecond */ |
73 | } QEMU_PACKED; |
74 | |
75 | #define GDB_O_RDONLY 0x0 |
76 | #define GDB_O_WRONLY 0x1 |
77 | #define GDB_O_RDWR 0x2 |
78 | #define GDB_O_APPEND 0x8 |
79 | #define GDB_O_CREAT 0x200 |
80 | #define GDB_O_TRUNC 0x400 |
81 | #define GDB_O_EXCL 0x800 |
82 | |
83 | static int translate_openflags(int flags) |
84 | { |
85 | int hf; |
86 | |
87 | if (flags & GDB_O_WRONLY) { |
88 | hf = O_WRONLY; |
89 | } else if (flags & GDB_O_RDWR) { |
90 | hf = O_RDWR; |
91 | } else { |
92 | hf = O_RDONLY; |
93 | } |
94 | |
95 | if (flags & GDB_O_APPEND) { |
96 | hf |= O_APPEND; |
97 | } |
98 | if (flags & GDB_O_CREAT) { |
99 | hf |= O_CREAT; |
100 | } |
101 | if (flags & GDB_O_TRUNC) { |
102 | hf |= O_TRUNC; |
103 | } |
104 | if (flags & GDB_O_EXCL) { |
105 | hf |= O_EXCL; |
106 | } |
107 | |
108 | return hf; |
109 | } |
110 | |
111 | static bool translate_stat(CPUNios2State *env, target_ulong addr, |
112 | struct stat *s) |
113 | { |
114 | struct nios2_gdb_stat *p; |
115 | |
116 | p = lock_user(VERIFY_WRITE, addr, sizeof(struct nios2_gdb_stat), 0); |
117 | |
118 | if (!p) { |
119 | return false; |
120 | } |
121 | p->gdb_st_dev = cpu_to_be32(s->st_dev); |
122 | p->gdb_st_ino = cpu_to_be32(s->st_ino); |
123 | p->gdb_st_mode = cpu_to_be32(s->st_mode); |
124 | p->gdb_st_nlink = cpu_to_be32(s->st_nlink); |
125 | p->gdb_st_uid = cpu_to_be32(s->st_uid); |
126 | p->gdb_st_gid = cpu_to_be32(s->st_gid); |
127 | p->gdb_st_rdev = cpu_to_be32(s->st_rdev); |
128 | p->gdb_st_size = cpu_to_be64(s->st_size); |
129 | #ifdef _WIN32 |
130 | /* Windows stat is missing some fields. */ |
131 | p->gdb_st_blksize = 0; |
132 | p->gdb_st_blocks = 0; |
133 | #else |
134 | p->gdb_st_blksize = cpu_to_be64(s->st_blksize); |
135 | p->gdb_st_blocks = cpu_to_be64(s->st_blocks); |
136 | #endif |
137 | p->gdb_st_atime = cpu_to_be32(s->st_atime); |
138 | p->gdb_st_mtime = cpu_to_be32(s->st_mtime); |
139 | p->gdb_st_ctime = cpu_to_be32(s->st_ctime); |
140 | unlock_user(p, addr, sizeof(struct nios2_gdb_stat)); |
141 | return true; |
142 | } |
143 | |
144 | static void nios2_semi_return_u32(CPUNios2State *env, uint32_t ret, |
145 | uint32_t err) |
146 | { |
147 | target_ulong args = env->regs[R_ARG1]; |
148 | if (put_user_u32(ret, args) || |
149 | put_user_u32(err, args + 4)) { |
150 | /* |
151 | * The nios2 semihosting ABI does not provide any way to report this |
152 | * error to the guest, so the best we can do is log it in qemu. |
153 | * It is always a guest error not to pass us a valid argument block. |
154 | */ |
155 | qemu_log_mask(LOG_GUEST_ERROR, "nios2-semihosting: return value " |
156 | "discarded because argument block not writable\n" ); |
157 | } |
158 | } |
159 | |
160 | static void nios2_semi_return_u64(CPUNios2State *env, uint64_t ret, |
161 | uint32_t err) |
162 | { |
163 | target_ulong args = env->regs[R_ARG1]; |
164 | if (put_user_u32(ret >> 32, args) || |
165 | put_user_u32(ret, args + 4) || |
166 | put_user_u32(err, args + 8)) { |
167 | /* No way to report this via nios2 semihosting ABI; just log it */ |
168 | qemu_log_mask(LOG_GUEST_ERROR, "nios2-semihosting: return value " |
169 | "discarded because argument block not writable\n" ); |
170 | } |
171 | } |
172 | |
173 | static int nios2_semi_is_lseek; |
174 | |
175 | static void nios2_semi_cb(CPUState *cs, target_ulong ret, target_ulong err) |
176 | { |
177 | Nios2CPU *cpu = NIOS2_CPU(cs); |
178 | CPUNios2State *env = &cpu->env; |
179 | |
180 | if (nios2_semi_is_lseek) { |
181 | /* |
182 | * FIXME: We've already lost the high bits of the lseek |
183 | * return value. |
184 | */ |
185 | nios2_semi_return_u64(env, ret, err); |
186 | nios2_semi_is_lseek = 0; |
187 | } else { |
188 | nios2_semi_return_u32(env, ret, err); |
189 | } |
190 | } |
191 | |
192 | /* |
193 | * Read the input value from the argument block; fail the semihosting |
194 | * call if the memory read fails. |
195 | */ |
196 | #define GET_ARG(n) do { \ |
197 | if (get_user_ual(arg ## n, args + (n) * 4)) { \ |
198 | result = -1; \ |
199 | errno = EFAULT; \ |
200 | goto failed; \ |
201 | } \ |
202 | } while (0) |
203 | |
204 | void do_nios2_semihosting(CPUNios2State *env) |
205 | { |
206 | int nr; |
207 | uint32_t args; |
208 | target_ulong arg0, arg1, arg2, arg3; |
209 | void *p; |
210 | void *q; |
211 | uint32_t len; |
212 | uint32_t result; |
213 | |
214 | nr = env->regs[R_ARG0]; |
215 | args = env->regs[R_ARG1]; |
216 | switch (nr) { |
217 | case HOSTED_EXIT: |
218 | gdb_exit(env, env->regs[R_ARG0]); |
219 | exit(env->regs[R_ARG0]); |
220 | case HOSTED_OPEN: |
221 | GET_ARG(0); |
222 | GET_ARG(1); |
223 | GET_ARG(2); |
224 | GET_ARG(3); |
225 | if (use_gdb_syscalls()) { |
226 | gdb_do_syscall(nios2_semi_cb, "open,%s,%x,%x" , arg0, (int)arg1, |
227 | arg2, arg3); |
228 | return; |
229 | } else { |
230 | p = lock_user_string(arg0); |
231 | if (!p) { |
232 | result = -1; |
233 | errno = EFAULT; |
234 | } else { |
235 | result = open(p, translate_openflags(arg2), arg3); |
236 | unlock_user(p, arg0, 0); |
237 | } |
238 | } |
239 | break; |
240 | case HOSTED_CLOSE: |
241 | { |
242 | /* Ignore attempts to close stdin/out/err. */ |
243 | GET_ARG(0); |
244 | int fd = arg0; |
245 | if (fd > 2) { |
246 | if (use_gdb_syscalls()) { |
247 | gdb_do_syscall(nios2_semi_cb, "close,%x" , arg0); |
248 | return; |
249 | } else { |
250 | result = close(fd); |
251 | } |
252 | } else { |
253 | result = 0; |
254 | } |
255 | break; |
256 | } |
257 | case HOSTED_READ: |
258 | GET_ARG(0); |
259 | GET_ARG(1); |
260 | GET_ARG(2); |
261 | len = arg2; |
262 | if (use_gdb_syscalls()) { |
263 | gdb_do_syscall(nios2_semi_cb, "read,%x,%x,%x" , |
264 | arg0, arg1, len); |
265 | return; |
266 | } else { |
267 | p = lock_user(VERIFY_WRITE, arg1, len, 0); |
268 | if (!p) { |
269 | result = -1; |
270 | errno = EFAULT; |
271 | } else { |
272 | result = read(arg0, p, len); |
273 | unlock_user(p, arg1, len); |
274 | } |
275 | } |
276 | break; |
277 | case HOSTED_WRITE: |
278 | GET_ARG(0); |
279 | GET_ARG(1); |
280 | GET_ARG(2); |
281 | len = arg2; |
282 | if (use_gdb_syscalls()) { |
283 | gdb_do_syscall(nios2_semi_cb, "write,%x,%x,%x" , |
284 | arg0, arg1, len); |
285 | return; |
286 | } else { |
287 | p = lock_user(VERIFY_READ, arg1, len, 1); |
288 | if (!p) { |
289 | result = -1; |
290 | errno = EFAULT; |
291 | } else { |
292 | result = write(arg0, p, len); |
293 | unlock_user(p, arg0, 0); |
294 | } |
295 | } |
296 | break; |
297 | case HOSTED_LSEEK: |
298 | { |
299 | uint64_t off; |
300 | GET_ARG(0); |
301 | GET_ARG(1); |
302 | GET_ARG(2); |
303 | GET_ARG(3); |
304 | off = (uint32_t)arg2 | ((uint64_t)arg1 << 32); |
305 | if (use_gdb_syscalls()) { |
306 | nios2_semi_is_lseek = 1; |
307 | gdb_do_syscall(nios2_semi_cb, "lseek,%x,%lx,%x" , |
308 | arg0, off, arg3); |
309 | } else { |
310 | off = lseek(arg0, off, arg3); |
311 | nios2_semi_return_u64(env, off, errno); |
312 | } |
313 | return; |
314 | } |
315 | case HOSTED_RENAME: |
316 | GET_ARG(0); |
317 | GET_ARG(1); |
318 | GET_ARG(2); |
319 | GET_ARG(3); |
320 | if (use_gdb_syscalls()) { |
321 | gdb_do_syscall(nios2_semi_cb, "rename,%s,%s" , |
322 | arg0, (int)arg1, arg2, (int)arg3); |
323 | return; |
324 | } else { |
325 | p = lock_user_string(arg0); |
326 | q = lock_user_string(arg2); |
327 | if (!p || !q) { |
328 | result = -1; |
329 | errno = EFAULT; |
330 | } else { |
331 | result = rename(p, q); |
332 | } |
333 | unlock_user(p, arg0, 0); |
334 | unlock_user(q, arg2, 0); |
335 | } |
336 | break; |
337 | case HOSTED_UNLINK: |
338 | GET_ARG(0); |
339 | GET_ARG(1); |
340 | if (use_gdb_syscalls()) { |
341 | gdb_do_syscall(nios2_semi_cb, "unlink,%s" , |
342 | arg0, (int)arg1); |
343 | return; |
344 | } else { |
345 | p = lock_user_string(arg0); |
346 | if (!p) { |
347 | result = -1; |
348 | errno = EFAULT; |
349 | } else { |
350 | result = unlink(p); |
351 | unlock_user(p, arg0, 0); |
352 | } |
353 | } |
354 | break; |
355 | case HOSTED_STAT: |
356 | GET_ARG(0); |
357 | GET_ARG(1); |
358 | GET_ARG(2); |
359 | if (use_gdb_syscalls()) { |
360 | gdb_do_syscall(nios2_semi_cb, "stat,%s,%x" , |
361 | arg0, (int)arg1, arg2); |
362 | return; |
363 | } else { |
364 | struct stat s; |
365 | p = lock_user_string(arg0); |
366 | if (!p) { |
367 | result = -1; |
368 | errno = EFAULT; |
369 | } else { |
370 | result = stat(p, &s); |
371 | unlock_user(p, arg0, 0); |
372 | } |
373 | if (result == 0 && !translate_stat(env, arg2, &s)) { |
374 | result = -1; |
375 | errno = EFAULT; |
376 | } |
377 | } |
378 | break; |
379 | case HOSTED_FSTAT: |
380 | GET_ARG(0); |
381 | GET_ARG(1); |
382 | if (use_gdb_syscalls()) { |
383 | gdb_do_syscall(nios2_semi_cb, "fstat,%x,%x" , |
384 | arg0, arg1); |
385 | return; |
386 | } else { |
387 | struct stat s; |
388 | result = fstat(arg0, &s); |
389 | if (result == 0 && !translate_stat(env, arg1, &s)) { |
390 | result = -1; |
391 | errno = EFAULT; |
392 | } |
393 | } |
394 | break; |
395 | case HOSTED_GETTIMEOFDAY: |
396 | /* Only the tv parameter is used. tz is assumed NULL. */ |
397 | GET_ARG(0); |
398 | if (use_gdb_syscalls()) { |
399 | gdb_do_syscall(nios2_semi_cb, "gettimeofday,%x,%x" , |
400 | arg0, 0); |
401 | return; |
402 | } else { |
403 | qemu_timeval tv; |
404 | struct gdb_timeval *p; |
405 | result = qemu_gettimeofday(&tv); |
406 | if (result != 0) { |
407 | p = lock_user(VERIFY_WRITE, arg0, sizeof(struct gdb_timeval), |
408 | 0); |
409 | if (!p) { |
410 | result = -1; |
411 | errno = EFAULT; |
412 | } else { |
413 | p->tv_sec = cpu_to_be32(tv.tv_sec); |
414 | p->tv_usec = cpu_to_be64(tv.tv_usec); |
415 | unlock_user(p, arg0, sizeof(struct gdb_timeval)); |
416 | } |
417 | } |
418 | } |
419 | break; |
420 | case HOSTED_ISATTY: |
421 | GET_ARG(0); |
422 | if (use_gdb_syscalls()) { |
423 | gdb_do_syscall(nios2_semi_cb, "isatty,%x" , arg0); |
424 | return; |
425 | } else { |
426 | result = isatty(arg0); |
427 | } |
428 | break; |
429 | case HOSTED_SYSTEM: |
430 | GET_ARG(0); |
431 | GET_ARG(1); |
432 | if (use_gdb_syscalls()) { |
433 | gdb_do_syscall(nios2_semi_cb, "system,%s" , |
434 | arg0, (int)arg1); |
435 | return; |
436 | } else { |
437 | p = lock_user_string(arg0); |
438 | if (!p) { |
439 | result = -1; |
440 | errno = EFAULT; |
441 | } else { |
442 | result = system(p); |
443 | unlock_user(p, arg0, 0); |
444 | } |
445 | } |
446 | break; |
447 | default: |
448 | qemu_log_mask(LOG_GUEST_ERROR, "nios2-semihosting: unsupported " |
449 | "semihosting syscall %d\n" , nr); |
450 | result = 0; |
451 | } |
452 | failed: |
453 | nios2_semi_return_u32(env, result, errno); |
454 | } |
455 | |