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