xref: /qemu/semihosting/syscalls.c (revision 8f9abdf5) 
1 /*
2  * Syscall implementations for semihosting.
3  *
4  * Copyright (c) 2022 Linaro
5  *
6  * SPDX-License-Identifier: GPL-2.0-or-later
7  */
8 
9 #include "qemu/osdep.h"
10 #include "exec/gdbstub.h"
11 #include "semihosting/guestfd.h"
12 #include "semihosting/syscalls.h"
13 #include "semihosting/console.h"
14 #ifdef CONFIG_USER_ONLY
15 #include "qemu.h"
16 #else
17 #include "semihosting/softmmu-uaccess.h"
18 #endif
19 
20 
21 /*
22  * Validate or compute the length of the string (including terminator).
23  */
24 static int validate_strlen(CPUState *cs, target_ulong str, target_ulong tlen)
25 {
26     CPUArchState *env G_GNUC_UNUSED = cs->env_ptr;
27     char c;
28 
29     if (tlen == 0) {
30         ssize_t slen = target_strlen(str);
31 
32         if (slen < 0) {
33             return -EFAULT;
34         }
35         if (slen >= INT32_MAX) {
36             return -ENAMETOOLONG;
37         }
38         return slen + 1;
39     }
40     if (tlen > INT32_MAX) {
41         return -ENAMETOOLONG;
42     }
43     if (get_user_u8(c, str + tlen - 1)) {
44         return -EFAULT;
45     }
46     if (c != 0) {
47         return -EINVAL;
48     }
49     return tlen;
50 }
51 
52 static int validate_lock_user_string(char **pstr, CPUState *cs,
53                                      target_ulong tstr, target_ulong tlen)
54 {
55     int ret = validate_strlen(cs, tstr, tlen);
56     CPUArchState *env G_GNUC_UNUSED = cs->env_ptr;
57     char *str = NULL;
58 
59     if (ret > 0) {
60         str = lock_user(VERIFY_READ, tstr, ret, true);
61         ret = str ? 0 : -EFAULT;
62     }
63     *pstr = str;
64     return ret;
65 }
66 
67 /*
68  * TODO: Note that gdb always stores the stat structure big-endian.
69  * So far, that's ok, as the only two targets using this are also
70  * big-endian.  Until we do something with gdb, also produce the
71  * same big-endian result from the host.
72  */
73 static int copy_stat_to_user(CPUState *cs, target_ulong addr,
74                              const struct stat *s)
75 {
76     CPUArchState *env G_GNUC_UNUSED = cs->env_ptr;
77     struct gdb_stat *p;
78 
79     if (s->st_dev != (uint32_t)s->st_dev ||
80         s->st_ino != (uint32_t)s->st_ino) {
81         return -EOVERFLOW;
82     }
83 
84     p = lock_user(VERIFY_WRITE, addr, sizeof(struct gdb_stat), 0);
85     if (!p) {
86         return -EFAULT;
87     }
88 
89     p->gdb_st_dev = cpu_to_be32(s->st_dev);
90     p->gdb_st_ino = cpu_to_be32(s->st_ino);
91     p->gdb_st_mode = cpu_to_be32(s->st_mode);
92     p->gdb_st_nlink = cpu_to_be32(s->st_nlink);
93     p->gdb_st_uid = cpu_to_be32(s->st_uid);
94     p->gdb_st_gid = cpu_to_be32(s->st_gid);
95     p->gdb_st_rdev = cpu_to_be32(s->st_rdev);
96     p->gdb_st_size = cpu_to_be64(s->st_size);
97 #ifdef _WIN32
98     /* Windows stat is missing some fields.  */
99     p->gdb_st_blksize = 0;
100     p->gdb_st_blocks = 0;
101 #else
102     p->gdb_st_blksize = cpu_to_be64(s->st_blksize);
103     p->gdb_st_blocks = cpu_to_be64(s->st_blocks);
104 #endif
105     p->gdb_st_atime = cpu_to_be32(s->st_atime);
106     p->gdb_st_mtime = cpu_to_be32(s->st_mtime);
107     p->gdb_st_ctime = cpu_to_be32(s->st_ctime);
108 
109     unlock_user(p, addr, sizeof(struct gdb_stat));
110     return 0;
111 }
112 
113 /*
114  * GDB semihosting syscall implementations.
115  */
116 
117 static gdb_syscall_complete_cb gdb_open_complete;
118 
119 static void gdb_open_cb(CPUState *cs, uint64_t ret, int err)
120 {
121     if (!err) {
122         int guestfd = alloc_guestfd();
123         associate_guestfd(guestfd, ret);
124         ret = guestfd;
125     }
126     gdb_open_complete(cs, ret, err);
127 }
128 
129 static void gdb_open(CPUState *cs, gdb_syscall_complete_cb complete,
130                      target_ulong fname, target_ulong fname_len,
131                      int gdb_flags, int mode)
132 {
133     int len = validate_strlen(cs, fname, fname_len);
134     if (len < 0) {
135         complete(cs, -1, -len);
136         return;
137     }
138 
139     gdb_open_complete = complete;
140     gdb_do_syscall(gdb_open_cb, "open,%s,%x,%x",
141                    fname, len, (target_ulong)gdb_flags, (target_ulong)mode);
142 }
143 
144 static void gdb_close(CPUState *cs, gdb_syscall_complete_cb complete,
145                       GuestFD *gf)
146 {
147     gdb_do_syscall(complete, "close,%x", (target_ulong)gf->hostfd);
148 }
149 
150 static void gdb_read(CPUState *cs, gdb_syscall_complete_cb complete,
151                      GuestFD *gf, target_ulong buf, target_ulong len)
152 {
153     gdb_do_syscall(complete, "read,%x,%x,%x",
154                    (target_ulong)gf->hostfd, buf, len);
155 }
156 
157 static void gdb_write(CPUState *cs, gdb_syscall_complete_cb complete,
158                       GuestFD *gf, target_ulong buf, target_ulong len)
159 {
160     gdb_do_syscall(complete, "write,%x,%x,%x",
161                    (target_ulong)gf->hostfd, buf, len);
162 }
163 
164 static void gdb_lseek(CPUState *cs, gdb_syscall_complete_cb complete,
165                       GuestFD *gf, int64_t off, int gdb_whence)
166 {
167     gdb_do_syscall(complete, "lseek,%x,%lx,%x",
168                    (target_ulong)gf->hostfd, off, (target_ulong)gdb_whence);
169 }
170 
171 static void gdb_isatty(CPUState *cs, gdb_syscall_complete_cb complete,
172                        GuestFD *gf)
173 {
174     gdb_do_syscall(complete, "isatty,%x", (target_ulong)gf->hostfd);
175 }
176 
177 static void gdb_fstat(CPUState *cs, gdb_syscall_complete_cb complete,
178                       GuestFD *gf, target_ulong addr)
179 {
180     gdb_do_syscall(complete, "fstat,%x,%x", (target_ulong)gf->hostfd, addr);
181 }
182 
183 static void gdb_stat(CPUState *cs, gdb_syscall_complete_cb complete,
184                      target_ulong fname, target_ulong fname_len,
185                      target_ulong addr)
186 {
187     int len = validate_strlen(cs, fname, fname_len);
188     if (len < 0) {
189         complete(cs, -1, -len);
190         return;
191     }
192 
193     gdb_do_syscall(complete, "stat,%s,%x", fname, len, addr);
194 }
195 
196 static void gdb_remove(CPUState *cs, gdb_syscall_complete_cb complete,
197                        target_ulong fname, target_ulong fname_len)
198 {
199     int len = validate_strlen(cs, fname, fname_len);
200     if (len < 0) {
201         complete(cs, -1, -len);
202         return;
203     }
204 
205     gdb_do_syscall(complete, "unlink,%s", fname, len);
206 }
207 
208 static void gdb_rename(CPUState *cs, gdb_syscall_complete_cb complete,
209                        target_ulong oname, target_ulong oname_len,
210                        target_ulong nname, target_ulong nname_len)
211 {
212     int olen, nlen;
213 
214     olen = validate_strlen(cs, oname, oname_len);
215     if (olen < 0) {
216         complete(cs, -1, -olen);
217         return;
218     }
219     nlen = validate_strlen(cs, nname, nname_len);
220     if (nlen < 0) {
221         complete(cs, -1, -nlen);
222         return;
223     }
224 
225     gdb_do_syscall(complete, "rename,%s,%s", oname, olen, nname, nlen);
226 }
227 
228 static void gdb_system(CPUState *cs, gdb_syscall_complete_cb complete,
229                        target_ulong cmd, target_ulong cmd_len)
230 {
231     int len = validate_strlen(cs, cmd, cmd_len);
232     if (len < 0) {
233         complete(cs, -1, -len);
234         return;
235     }
236 
237     gdb_do_syscall(complete, "system,%s", cmd, len);
238 }
239 
240 static void gdb_gettimeofday(CPUState *cs, gdb_syscall_complete_cb complete,
241                              target_ulong tv_addr, target_ulong tz_addr)
242 {
243     gdb_do_syscall(complete, "gettimeofday,%x,%x", tv_addr, tz_addr);
244 }
245 
246 /*
247  * Host semihosting syscall implementations.
248  */
249 
250 static void host_open(CPUState *cs, gdb_syscall_complete_cb complete,
251                       target_ulong fname, target_ulong fname_len,
252                       int gdb_flags, int mode)
253 {
254     CPUArchState *env G_GNUC_UNUSED = cs->env_ptr;
255     char *p;
256     int ret, host_flags;
257 
258     ret = validate_lock_user_string(&p, cs, fname, fname_len);
259     if (ret < 0) {
260         complete(cs, -1, -ret);
261         return;
262     }
263 
264     if (gdb_flags & GDB_O_WRONLY) {
265         host_flags = O_WRONLY;
266     } else if (gdb_flags & GDB_O_RDWR) {
267         host_flags = O_RDWR;
268     } else {
269         host_flags = O_RDONLY;
270     }
271     if (gdb_flags & GDB_O_CREAT) {
272         host_flags |= O_CREAT;
273     }
274     if (gdb_flags & GDB_O_TRUNC) {
275         host_flags |= O_TRUNC;
276     }
277     if (gdb_flags & GDB_O_EXCL) {
278         host_flags |= O_EXCL;
279     }
280 
281     ret = open(p, host_flags, mode);
282     if (ret < 0) {
283         complete(cs, -1, errno);
284     } else {
285         int guestfd = alloc_guestfd();
286         associate_guestfd(guestfd, ret);
287         complete(cs, guestfd, 0);
288     }
289     unlock_user(p, fname, 0);
290 }
291 
292 static void host_close(CPUState *cs, gdb_syscall_complete_cb complete,
293                        GuestFD *gf)
294 {
295     /*
296      * Only close the underlying host fd if it's one we opened on behalf
297      * of the guest in SYS_OPEN.
298      */
299     if (gf->hostfd != STDIN_FILENO &&
300         gf->hostfd != STDOUT_FILENO &&
301         gf->hostfd != STDERR_FILENO &&
302         close(gf->hostfd) < 0) {
303         complete(cs, -1, errno);
304     } else {
305         complete(cs, 0, 0);
306     }
307 }
308 
309 static void host_read(CPUState *cs, gdb_syscall_complete_cb complete,
310                       GuestFD *gf, target_ulong buf, target_ulong len)
311 {
312     CPUArchState *env G_GNUC_UNUSED = cs->env_ptr;
313     void *ptr = lock_user(VERIFY_WRITE, buf, len, 0);
314     ssize_t ret;
315 
316     if (!ptr) {
317         complete(cs, -1, EFAULT);
318         return;
319     }
320     do {
321         ret = read(gf->hostfd, ptr, len);
322     } while (ret == -1 && errno == EINTR);
323     if (ret == -1) {
324         complete(cs, -1, errno);
325         unlock_user(ptr, buf, 0);
326     } else {
327         complete(cs, ret, 0);
328         unlock_user(ptr, buf, ret);
329     }
330 }
331 
332 static void host_write(CPUState *cs, gdb_syscall_complete_cb complete,
333                        GuestFD *gf, target_ulong buf, target_ulong len)
334 {
335     CPUArchState *env G_GNUC_UNUSED = cs->env_ptr;
336     void *ptr = lock_user(VERIFY_READ, buf, len, 1);
337     ssize_t ret;
338 
339     if (!ptr) {
340         complete(cs, -1, EFAULT);
341         return;
342     }
343     ret = write(gf->hostfd, ptr, len);
344     complete(cs, ret, ret == -1 ? errno : 0);
345     unlock_user(ptr, buf, 0);
346 }
347 
348 static void host_lseek(CPUState *cs, gdb_syscall_complete_cb complete,
349                        GuestFD *gf, int64_t off, int whence)
350 {
351     /* So far, all hosts use the same values. */
352     QEMU_BUILD_BUG_ON(GDB_SEEK_SET != SEEK_SET);
353     QEMU_BUILD_BUG_ON(GDB_SEEK_CUR != SEEK_CUR);
354     QEMU_BUILD_BUG_ON(GDB_SEEK_END != SEEK_END);
355 
356     off_t ret = off;
357     int err = 0;
358 
359     if (ret == off) {
360         ret = lseek(gf->hostfd, ret, whence);
361         if (ret == -1) {
362             err = errno;
363         }
364     } else {
365         ret = -1;
366         err = EINVAL;
367     }
368     complete(cs, ret, err);
369 }
370 
371 static void host_isatty(CPUState *cs, gdb_syscall_complete_cb complete,
372                         GuestFD *gf)
373 {
374     int ret = isatty(gf->hostfd);
375     complete(cs, ret, ret ? 0 : errno);
376 }
377 
378 static void host_flen(CPUState *cs, gdb_syscall_complete_cb complete,
379                       GuestFD *gf)
380 {
381     struct stat buf;
382 
383     if (fstat(gf->hostfd, &buf) < 0) {
384         complete(cs, -1, errno);
385     } else {
386         complete(cs, buf.st_size, 0);
387     }
388 }
389 
390 static void host_fstat(CPUState *cs, gdb_syscall_complete_cb complete,
391                        GuestFD *gf, target_ulong addr)
392 {
393     struct stat buf;
394     int ret;
395 
396     ret = fstat(gf->hostfd, &buf);
397     if (ret) {
398         complete(cs, -1, errno);
399         return;
400     }
401     ret = copy_stat_to_user(cs, addr, &buf);
402     complete(cs, ret ? -1 : 0, ret ? -ret : 0);
403 }
404 
405 static void host_stat(CPUState *cs, gdb_syscall_complete_cb complete,
406                       target_ulong fname, target_ulong fname_len,
407                       target_ulong addr)
408 {
409     CPUArchState *env G_GNUC_UNUSED = cs->env_ptr;
410     struct stat buf;
411     char *name;
412     int ret, err;
413 
414     ret = validate_lock_user_string(&name, cs, fname, fname_len);
415     if (ret < 0) {
416         complete(cs, -1, -ret);
417         return;
418     }
419 
420     ret = stat(name, &buf);
421     if (ret) {
422         err = errno;
423     } else {
424         ret = copy_stat_to_user(cs, addr, &buf);
425         err = 0;
426         if (ret < 0) {
427             err = -ret;
428             ret = -1;
429         }
430     }
431     complete(cs, ret, err);
432     unlock_user(name, fname, 0);
433 }
434 
435 static void host_remove(CPUState *cs, gdb_syscall_complete_cb complete,
436                         target_ulong fname, target_ulong fname_len)
437 {
438     CPUArchState *env G_GNUC_UNUSED = cs->env_ptr;
439     char *p;
440     int ret;
441 
442     ret = validate_lock_user_string(&p, cs, fname, fname_len);
443     if (ret < 0) {
444         complete(cs, -1, -ret);
445         return;
446     }
447 
448     ret = remove(p);
449     complete(cs, ret, ret ? errno : 0);
450     unlock_user(p, fname, 0);
451 }
452 
453 static void host_rename(CPUState *cs, gdb_syscall_complete_cb complete,
454                         target_ulong oname, target_ulong oname_len,
455                         target_ulong nname, target_ulong nname_len)
456 {
457     CPUArchState *env G_GNUC_UNUSED = cs->env_ptr;
458     char *ostr, *nstr;
459     int ret;
460 
461     ret = validate_lock_user_string(&ostr, cs, oname, oname_len);
462     if (ret < 0) {
463         complete(cs, -1, -ret);
464         return;
465     }
466     ret = validate_lock_user_string(&nstr, cs, nname, nname_len);
467     if (ret < 0) {
468         unlock_user(ostr, oname, 0);
469         complete(cs, -1, -ret);
470         return;
471     }
472 
473     ret = rename(ostr, nstr);
474     complete(cs, ret, ret ? errno : 0);
475     unlock_user(ostr, oname, 0);
476     unlock_user(nstr, nname, 0);
477 }
478 
479 static void host_system(CPUState *cs, gdb_syscall_complete_cb complete,
480                         target_ulong cmd, target_ulong cmd_len)
481 {
482     CPUArchState *env G_GNUC_UNUSED = cs->env_ptr;
483     char *p;
484     int ret;
485 
486     ret = validate_lock_user_string(&p, cs, cmd, cmd_len);
487     if (ret < 0) {
488         complete(cs, -1, -ret);
489         return;
490     }
491 
492     ret = system(p);
493     complete(cs, ret, ret == -1 ? errno : 0);
494     unlock_user(p, cmd, 0);
495 }
496 
497 static void host_gettimeofday(CPUState *cs, gdb_syscall_complete_cb complete,
498                               target_ulong tv_addr, target_ulong tz_addr)
499 {
500     CPUArchState *env G_GNUC_UNUSED = cs->env_ptr;
501     struct gdb_timeval *p;
502     int64_t rt;
503 
504     /* GDB fails on non-null TZ, so be consistent. */
505     if (tz_addr != 0) {
506         complete(cs, -1, EINVAL);
507         return;
508     }
509 
510     p = lock_user(VERIFY_WRITE, tv_addr, sizeof(struct gdb_timeval), 0);
511     if (!p) {
512         complete(cs, -1, EFAULT);
513         return;
514     }
515 
516     /* TODO: Like stat, gdb always produces big-endian results; match it. */
517     rt = g_get_real_time();
518     p->tv_sec = cpu_to_be32(rt / G_USEC_PER_SEC);
519     p->tv_usec = cpu_to_be64(rt % G_USEC_PER_SEC);
520     unlock_user(p, tv_addr, sizeof(struct gdb_timeval));
521 }
522 
523 #ifndef CONFIG_USER_ONLY
524 static void host_poll_one(CPUState *cs, gdb_syscall_complete_cb complete,
525                           GuestFD *gf, GIOCondition cond, int timeout)
526 {
527     /*
528      * Since this is only used by xtensa in system mode, and stdio is
529      * handled through GuestFDConsole, and there are no semihosting
530      * system calls for sockets and the like, that means this descriptor
531      * must be a normal file.  Normal files never block and are thus
532      * always ready.
533      */
534     complete(cs, cond & (G_IO_IN | G_IO_OUT), 0);
535 }
536 #endif
537 
538 /*
539  * Static file semihosting syscall implementations.
540  */
541 
542 static void staticfile_read(CPUState *cs, gdb_syscall_complete_cb complete,
543                             GuestFD *gf, target_ulong buf, target_ulong len)
544 {
545     CPUArchState *env G_GNUC_UNUSED = cs->env_ptr;
546     target_ulong rest = gf->staticfile.len - gf->staticfile.off;
547     void *ptr;
548 
549     if (len > rest) {
550         len = rest;
551     }
552     ptr = lock_user(VERIFY_WRITE, buf, len, 0);
553     if (!ptr) {
554         complete(cs, -1, EFAULT);
555         return;
556     }
557     memcpy(ptr, gf->staticfile.data + gf->staticfile.off, len);
558     gf->staticfile.off += len;
559     complete(cs, len, 0);
560     unlock_user(ptr, buf, len);
561 }
562 
563 static void staticfile_lseek(CPUState *cs, gdb_syscall_complete_cb complete,
564                              GuestFD *gf, int64_t off, int gdb_whence)
565 {
566     int64_t ret;
567 
568     switch (gdb_whence) {
569     case GDB_SEEK_SET:
570         ret = off;
571         break;
572     case GDB_SEEK_CUR:
573         ret = gf->staticfile.off + off;
574         break;
575     case GDB_SEEK_END:
576         ret = gf->staticfile.len + off;
577         break;
578     default:
579         ret = -1;
580         break;
581     }
582     if (ret >= 0 && ret <= gf->staticfile.len) {
583         gf->staticfile.off = ret;
584         complete(cs, ret, 0);
585     } else {
586         complete(cs, -1, EINVAL);
587     }
588 }
589 
590 static void staticfile_flen(CPUState *cs, gdb_syscall_complete_cb complete,
591                             GuestFD *gf)
592 {
593     complete(cs, gf->staticfile.len, 0);
594 }
595 
596 /*
597  * Console semihosting syscall implementations.
598  */
599 
600 static void console_read(CPUState *cs, gdb_syscall_complete_cb complete,
601                          GuestFD *gf, target_ulong buf, target_ulong len)
602 {
603     CPUArchState *env G_GNUC_UNUSED = cs->env_ptr;
604     char *ptr;
605     int ret;
606 
607     ptr = lock_user(VERIFY_WRITE, buf, len, 0);
608     if (!ptr) {
609         complete(cs, -1, EFAULT);
610         return;
611     }
612     ret = qemu_semihosting_console_read(cs, ptr, len);
613     complete(cs, ret, 0);
614     unlock_user(ptr, buf, ret);
615 }
616 
617 static void console_write(CPUState *cs, gdb_syscall_complete_cb complete,
618                           GuestFD *gf, target_ulong buf, target_ulong len)
619 {
620     CPUArchState *env G_GNUC_UNUSED = cs->env_ptr;
621     char *ptr = lock_user(VERIFY_READ, buf, len, 1);
622     int ret;
623 
624     if (!ptr) {
625         complete(cs, -1, EFAULT);
626         return;
627     }
628     ret = qemu_semihosting_console_write(ptr, len);
629     complete(cs, ret ? ret : -1, ret ? 0 : EIO);
630     unlock_user(ptr, buf, 0);
631 }
632 
633 static void console_fstat(CPUState *cs, gdb_syscall_complete_cb complete,
634                           GuestFD *gf, target_ulong addr)
635 {
636     static const struct stat tty_buf = {
637         .st_mode = 020666,  /* S_IFCHR, ugo+rw */
638         .st_rdev = 5,       /* makedev(5, 0) -- linux /dev/tty */
639     };
640     int ret;
641 
642     ret = copy_stat_to_user(cs, addr, &tty_buf);
643     complete(cs, ret ? -1 : 0, ret ? -ret : 0);
644 }
645 
646 #ifndef CONFIG_USER_ONLY
647 static void console_poll_one(CPUState *cs, gdb_syscall_complete_cb complete,
648                              GuestFD *gf, GIOCondition cond, int timeout)
649 {
650     /* The semihosting console does not support urgent data or errors. */
651     cond &= G_IO_IN | G_IO_OUT;
652 
653     /*
654      * Since qemu_semihosting_console_write never blocks, we can
655      * consider output always ready -- leave G_IO_OUT alone.
656      * All that remains is to conditionally signal input ready.
657      * Since output ready causes an immediate return, only block
658      * for G_IO_IN alone.
659      *
660      * TODO: Implement proper timeout.  For now, only support
661      * indefinite wait or immediate poll.
662      */
663     if (cond == G_IO_IN && timeout < 0) {
664         qemu_semihosting_console_block_until_ready(cs);
665         /* We returned -- input must be ready. */
666     } else if ((cond & G_IO_IN) && !qemu_semihosting_console_ready()) {
667         cond &= ~G_IO_IN;
668     }
669 
670     complete(cs, cond, 0);
671 }
672 #endif
673 
674 /*
675  * Syscall entry points.
676  */
677 
678 void semihost_sys_open(CPUState *cs, gdb_syscall_complete_cb complete,
679                        target_ulong fname, target_ulong fname_len,
680                        int gdb_flags, int mode)
681 {
682     if (use_gdb_syscalls()) {
683         gdb_open(cs, complete, fname, fname_len, gdb_flags, mode);
684     } else {
685         host_open(cs, complete, fname, fname_len, gdb_flags, mode);
686     }
687 }
688 
689 void semihost_sys_close(CPUState *cs, gdb_syscall_complete_cb complete, int fd)
690 {
691     GuestFD *gf = get_guestfd(fd);
692 
693     if (!gf) {
694         complete(cs, -1, EBADF);
695         return;
696     }
697     switch (gf->type) {
698     case GuestFDGDB:
699         gdb_close(cs, complete, gf);
700         break;
701     case GuestFDHost:
702         host_close(cs, complete, gf);
703         break;
704     case GuestFDStatic:
705     case GuestFDConsole:
706         complete(cs, 0, 0);
707         break;
708     default:
709         g_assert_not_reached();
710     }
711     dealloc_guestfd(fd);
712 }
713 
714 void semihost_sys_read_gf(CPUState *cs, gdb_syscall_complete_cb complete,
715                           GuestFD *gf, target_ulong buf, target_ulong len)
716 {
717     /*
718      * Bound length for 64-bit guests on 32-bit hosts, not overlowing ssize_t.
719      * Note the Linux kernel does this with MAX_RW_COUNT, so it's not a bad
720      * idea to do this unconditionally.
721      */
722     if (len > INT32_MAX) {
723         len = INT32_MAX;
724     }
725     switch (gf->type) {
726     case GuestFDGDB:
727         gdb_read(cs, complete, gf, buf, len);
728         break;
729     case GuestFDHost:
730         host_read(cs, complete, gf, buf, len);
731         break;
732     case GuestFDStatic:
733         staticfile_read(cs, complete, gf, buf, len);
734         break;
735     case GuestFDConsole:
736         console_read(cs, complete, gf, buf, len);
737         break;
738     default:
739         g_assert_not_reached();
740     }
741 }
742 
743 void semihost_sys_read(CPUState *cs, gdb_syscall_complete_cb complete,
744                        int fd, target_ulong buf, target_ulong len)
745 {
746     GuestFD *gf = get_guestfd(fd);
747 
748     if (gf) {
749         semihost_sys_read_gf(cs, complete, gf, buf, len);
750     } else {
751         complete(cs, -1, EBADF);
752     }
753 }
754 
755 void semihost_sys_write_gf(CPUState *cs, gdb_syscall_complete_cb complete,
756                            GuestFD *gf, target_ulong buf, target_ulong len)
757 {
758     /*
759      * Bound length for 64-bit guests on 32-bit hosts, not overlowing ssize_t.
760      * Note the Linux kernel does this with MAX_RW_COUNT, so it's not a bad
761      * idea to do this unconditionally.
762      */
763     if (len > INT32_MAX) {
764         len = INT32_MAX;
765     }
766     switch (gf->type) {
767     case GuestFDGDB:
768         gdb_write(cs, complete, gf, buf, len);
769         break;
770     case GuestFDHost:
771         host_write(cs, complete, gf, buf, len);
772         break;
773     case GuestFDConsole:
774         console_write(cs, complete, gf, buf, len);
775         break;
776     case GuestFDStatic:
777         /* Static files are never open for writing: EBADF. */
778         complete(cs, -1, EBADF);
779         break;
780     default:
781         g_assert_not_reached();
782     }
783 }
784 
785 void semihost_sys_write(CPUState *cs, gdb_syscall_complete_cb complete,
786                         int fd, target_ulong buf, target_ulong len)
787 {
788     GuestFD *gf = get_guestfd(fd);
789 
790     if (gf) {
791         semihost_sys_write_gf(cs, complete, gf, buf, len);
792     } else {
793         complete(cs, -1, EBADF);
794     }
795 }
796 
797 void semihost_sys_lseek(CPUState *cs, gdb_syscall_complete_cb complete,
798                         int fd, int64_t off, int gdb_whence)
799 {
800     GuestFD *gf = get_guestfd(fd);
801 
802     if (!gf) {
803         complete(cs, -1, EBADF);
804         return;
805     }
806     switch (gf->type) {
807     case GuestFDGDB:
808         gdb_lseek(cs, complete, gf, off, gdb_whence);
809         return;
810     case GuestFDHost:
811         host_lseek(cs, complete, gf, off, gdb_whence);
812         break;
813     case GuestFDStatic:
814         staticfile_lseek(cs, complete, gf, off, gdb_whence);
815         break;
816     case GuestFDConsole:
817         complete(cs, -1, ESPIPE);
818         break;
819     default:
820         g_assert_not_reached();
821     }
822 }
823 
824 void semihost_sys_isatty(CPUState *cs, gdb_syscall_complete_cb complete, int fd)
825 {
826     GuestFD *gf = get_guestfd(fd);
827 
828     if (!gf) {
829         complete(cs, 0, EBADF);
830         return;
831     }
832     switch (gf->type) {
833     case GuestFDGDB:
834         gdb_isatty(cs, complete, gf);
835         break;
836     case GuestFDHost:
837         host_isatty(cs, complete, gf);
838         break;
839     case GuestFDStatic:
840         complete(cs, 0, ENOTTY);
841         break;
842     case GuestFDConsole:
843         complete(cs, 1, 0);
844         break;
845     default:
846         g_assert_not_reached();
847     }
848 }
849 
850 void semihost_sys_flen(CPUState *cs, gdb_syscall_complete_cb fstat_cb,
851                        gdb_syscall_complete_cb flen_cb, int fd,
852                        target_ulong fstat_addr)
853 {
854     GuestFD *gf = get_guestfd(fd);
855 
856     if (!gf) {
857         flen_cb(cs, -1, EBADF);
858         return;
859     }
860     switch (gf->type) {
861     case GuestFDGDB:
862         gdb_fstat(cs, fstat_cb, gf, fstat_addr);
863         break;
864     case GuestFDHost:
865         host_flen(cs, flen_cb, gf);
866         break;
867     case GuestFDStatic:
868         staticfile_flen(cs, flen_cb, gf);
869         break;
870     case GuestFDConsole:
871     default:
872         g_assert_not_reached();
873     }
874 }
875 
876 void semihost_sys_fstat(CPUState *cs, gdb_syscall_complete_cb complete,
877                         int fd, target_ulong addr)
878 {
879     GuestFD *gf = get_guestfd(fd);
880 
881     if (!gf) {
882         complete(cs, -1, EBADF);
883         return;
884     }
885     switch (gf->type) {
886     case GuestFDGDB:
887         gdb_fstat(cs, complete, gf, addr);
888         break;
889     case GuestFDHost:
890         host_fstat(cs, complete, gf, addr);
891         break;
892     case GuestFDConsole:
893         console_fstat(cs, complete, gf, addr);
894         break;
895     case GuestFDStatic:
896     default:
897         g_assert_not_reached();
898     }
899 }
900 
901 void semihost_sys_stat(CPUState *cs, gdb_syscall_complete_cb complete,
902                        target_ulong fname, target_ulong fname_len,
903                        target_ulong addr)
904 {
905     if (use_gdb_syscalls()) {
906         gdb_stat(cs, complete, fname, fname_len, addr);
907     } else {
908         host_stat(cs, complete, fname, fname_len, addr);
909     }
910 }
911 
912 void semihost_sys_remove(CPUState *cs, gdb_syscall_complete_cb complete,
913                          target_ulong fname, target_ulong fname_len)
914 {
915     if (use_gdb_syscalls()) {
916         gdb_remove(cs, complete, fname, fname_len);
917     } else {
918         host_remove(cs, complete, fname, fname_len);
919     }
920 }
921 
922 void semihost_sys_rename(CPUState *cs, gdb_syscall_complete_cb complete,
923                          target_ulong oname, target_ulong oname_len,
924                          target_ulong nname, target_ulong nname_len)
925 {
926     if (use_gdb_syscalls()) {
927         gdb_rename(cs, complete, oname, oname_len, nname, nname_len);
928     } else {
929         host_rename(cs, complete, oname, oname_len, nname, nname_len);
930     }
931 }
932 
933 void semihost_sys_system(CPUState *cs, gdb_syscall_complete_cb complete,
934                          target_ulong cmd, target_ulong cmd_len)
935 {
936     if (use_gdb_syscalls()) {
937         gdb_system(cs, complete, cmd, cmd_len);
938     } else {
939         host_system(cs, complete, cmd, cmd_len);
940     }
941 }
942 
943 void semihost_sys_gettimeofday(CPUState *cs, gdb_syscall_complete_cb complete,
944                                target_ulong tv_addr, target_ulong tz_addr)
945 {
946     if (use_gdb_syscalls()) {
947         gdb_gettimeofday(cs, complete, tv_addr, tz_addr);
948     } else {
949         host_gettimeofday(cs, complete, tv_addr, tz_addr);
950     }
951 }
952 
953 #ifndef CONFIG_USER_ONLY
954 void semihost_sys_poll_one(CPUState *cs, gdb_syscall_complete_cb complete,
955                            int fd, GIOCondition cond, int timeout)
956 {
957     GuestFD *gf = get_guestfd(fd);
958 
959     if (!gf) {
960         complete(cs, G_IO_NVAL, 1);
961         return;
962     }
963     switch (gf->type) {
964     case GuestFDGDB:
965         complete(cs, G_IO_NVAL, 1);
966         break;
967     case GuestFDHost:
968         host_poll_one(cs, complete, gf, cond, timeout);
969         break;
970     case GuestFDConsole:
971         console_poll_one(cs, complete, gf, cond, timeout);
972         break;
973     case GuestFDStatic:
974     default:
975         g_assert_not_reached();
976     }
977 }
978 #endif
979