1 #include "qemu/osdep.h" 2 3 #include <sys/ipc.h> 4 #include <sys/msg.h> 5 #include <sys/sem.h> 6 #include <sys/shm.h> 7 #include <sys/select.h> 8 #include <sys/mount.h> 9 #include <arpa/inet.h> 10 #include <netinet/in.h> 11 #include <netinet/tcp.h> 12 #include <netinet/udp.h> 13 #include <linux/if_packet.h> 14 #include <linux/in6.h> 15 #include <linux/netlink.h> 16 #include <sched.h> 17 #include "qemu.h" 18 #include "user-internals.h" 19 #include "strace.h" 20 #include "signal-common.h" 21 #include "target_mman.h" 22 23 struct syscallname { 24 int nr; 25 const char *name; 26 const char *format; 27 void (*call)(CPUArchState *, const struct syscallname *, 28 abi_long, abi_long, abi_long, 29 abi_long, abi_long, abi_long); 30 void (*result)(CPUArchState *, const struct syscallname *, abi_long, 31 abi_long, abi_long, abi_long, 32 abi_long, abi_long, abi_long); 33 }; 34 35 /* 36 * It is possible that target doesn't have syscall that uses 37 * following flags but we don't want the compiler to warn 38 * us about them being unused. Same applies to utility print 39 * functions. It is ok to keep them while not used. 40 */ 41 #define UNUSED __attribute__ ((unused)) 42 43 /* 44 * Structure used to translate flag values into strings. This is 45 * similar that is in the actual strace tool. 46 */ 47 struct flags { 48 abi_long f_value; /* flag */ 49 const char *f_string; /* stringified flag */ 50 }; 51 52 /* common flags for all architectures */ 53 #define FLAG_GENERIC(name) { name, #name } 54 /* target specific flags (syscall_defs.h has TARGET_<flag>) */ 55 #define FLAG_TARGET(name) { TARGET_ ## name, #name } 56 /* end of flags array */ 57 #define FLAG_END { 0, NULL } 58 59 /* Structure used to translate enumerated values into strings */ 60 struct enums { 61 abi_long e_value; /* enum value */ 62 const char *e_string; /* stringified enum */ 63 }; 64 65 /* common enums for all architectures */ 66 #define ENUM_GENERIC(name) { name, #name } 67 /* target specific enums */ 68 #define ENUM_TARGET(name) { TARGET_ ## name, #name } 69 /* end of enums array */ 70 #define ENUM_END { 0, NULL } 71 72 UNUSED static const char *get_comma(int); 73 UNUSED static void print_pointer(abi_long, int); 74 UNUSED static void print_flags(const struct flags *, abi_long, int); 75 UNUSED static void print_enums(const struct enums *, abi_long, int); 76 UNUSED static void print_at_dirfd(abi_long, int); 77 UNUSED static void print_file_mode(abi_long, int); 78 UNUSED static void print_open_flags(abi_long, int); 79 UNUSED static void print_syscall_prologue(const struct syscallname *); 80 UNUSED static void print_syscall_epilogue(const struct syscallname *); 81 UNUSED static void print_string(abi_long, int); 82 UNUSED static void print_buf(abi_long addr, abi_long len, int last); 83 UNUSED static void print_raw_param(const char *, abi_long, int); 84 UNUSED static void print_timeval(abi_ulong, int); 85 UNUSED static void print_timespec(abi_ulong, int); 86 UNUSED static void print_timespec64(abi_ulong, int); 87 UNUSED static void print_timezone(abi_ulong, int); 88 UNUSED static void print_itimerval(abi_ulong, int); 89 UNUSED static void print_number(abi_long, int); 90 UNUSED static void print_signal(abi_ulong, int); 91 UNUSED static void print_sockaddr(abi_ulong, abi_long, int); 92 UNUSED static void print_socket_domain(int domain); 93 UNUSED static void print_socket_type(int type); 94 UNUSED static void print_socket_protocol(int domain, int type, int protocol); 95 96 /* 97 * Utility functions 98 */ 99 static void 100 print_ipc_cmd(int cmd) 101 { 102 #define output_cmd(val) \ 103 if( cmd == val ) { \ 104 qemu_log(#val); \ 105 return; \ 106 } 107 108 cmd &= 0xff; 109 110 /* General IPC commands */ 111 output_cmd( IPC_RMID ); 112 output_cmd( IPC_SET ); 113 output_cmd( IPC_STAT ); 114 output_cmd( IPC_INFO ); 115 /* msgctl() commands */ 116 output_cmd( MSG_STAT ); 117 output_cmd( MSG_INFO ); 118 /* shmctl() commands */ 119 output_cmd( SHM_LOCK ); 120 output_cmd( SHM_UNLOCK ); 121 output_cmd( SHM_STAT ); 122 output_cmd( SHM_INFO ); 123 /* semctl() commands */ 124 output_cmd( GETPID ); 125 output_cmd( GETVAL ); 126 output_cmd( GETALL ); 127 output_cmd( GETNCNT ); 128 output_cmd( GETZCNT ); 129 output_cmd( SETVAL ); 130 output_cmd( SETALL ); 131 output_cmd( SEM_STAT ); 132 output_cmd( SEM_INFO ); 133 output_cmd( IPC_RMID ); 134 output_cmd( IPC_RMID ); 135 output_cmd( IPC_RMID ); 136 output_cmd( IPC_RMID ); 137 output_cmd( IPC_RMID ); 138 output_cmd( IPC_RMID ); 139 output_cmd( IPC_RMID ); 140 output_cmd( IPC_RMID ); 141 output_cmd( IPC_RMID ); 142 143 /* Some value we don't recognize */ 144 qemu_log("%d", cmd); 145 } 146 147 static const char * const target_signal_name[] = { 148 #define MAKE_SIG_ENTRY(sig) [TARGET_##sig] = #sig, 149 MAKE_SIGNAL_LIST 150 #undef MAKE_SIG_ENTRY 151 }; 152 153 static void 154 print_signal(abi_ulong arg, int last) 155 { 156 const char *signal_name = NULL; 157 158 if (arg < ARRAY_SIZE(target_signal_name)) { 159 signal_name = target_signal_name[arg]; 160 } 161 162 if (signal_name == NULL) { 163 print_raw_param("%ld", arg, last); 164 return; 165 } 166 qemu_log("%s%s", signal_name, get_comma(last)); 167 } 168 169 static void print_si_code(int arg) 170 { 171 const char *codename = NULL; 172 173 switch (arg) { 174 case SI_USER: 175 codename = "SI_USER"; 176 break; 177 case SI_KERNEL: 178 codename = "SI_KERNEL"; 179 break; 180 case SI_QUEUE: 181 codename = "SI_QUEUE"; 182 break; 183 case SI_TIMER: 184 codename = "SI_TIMER"; 185 break; 186 case SI_MESGQ: 187 codename = "SI_MESGQ"; 188 break; 189 case SI_ASYNCIO: 190 codename = "SI_ASYNCIO"; 191 break; 192 case SI_SIGIO: 193 codename = "SI_SIGIO"; 194 break; 195 case SI_TKILL: 196 codename = "SI_TKILL"; 197 break; 198 default: 199 qemu_log("%d", arg); 200 return; 201 } 202 qemu_log("%s", codename); 203 } 204 205 static void get_target_siginfo(target_siginfo_t *tinfo, 206 const target_siginfo_t *info) 207 { 208 abi_ulong sival_ptr; 209 210 int sig; 211 int si_errno; 212 int si_code; 213 int si_type; 214 215 __get_user(sig, &info->si_signo); 216 __get_user(si_errno, &tinfo->si_errno); 217 __get_user(si_code, &info->si_code); 218 219 tinfo->si_signo = sig; 220 tinfo->si_errno = si_errno; 221 tinfo->si_code = si_code; 222 223 /* Ensure we don't leak random junk to the guest later */ 224 memset(tinfo->_sifields._pad, 0, sizeof(tinfo->_sifields._pad)); 225 226 /* This is awkward, because we have to use a combination of 227 * the si_code and si_signo to figure out which of the union's 228 * members are valid. (Within the host kernel it is always possible 229 * to tell, but the kernel carefully avoids giving userspace the 230 * high 16 bits of si_code, so we don't have the information to 231 * do this the easy way...) We therefore make our best guess, 232 * bearing in mind that a guest can spoof most of the si_codes 233 * via rt_sigqueueinfo() if it likes. 234 * 235 * Once we have made our guess, we record it in the top 16 bits of 236 * the si_code, so that print_siginfo() later can use it. 237 * print_siginfo() will strip these top bits out before printing 238 * the si_code. 239 */ 240 241 switch (si_code) { 242 case SI_USER: 243 case SI_TKILL: 244 case SI_KERNEL: 245 /* Sent via kill(), tkill() or tgkill(), or direct from the kernel. 246 * These are the only unspoofable si_code values. 247 */ 248 __get_user(tinfo->_sifields._kill._pid, &info->_sifields._kill._pid); 249 __get_user(tinfo->_sifields._kill._uid, &info->_sifields._kill._uid); 250 si_type = QEMU_SI_KILL; 251 break; 252 default: 253 /* Everything else is spoofable. Make best guess based on signal */ 254 switch (sig) { 255 case TARGET_SIGCHLD: 256 __get_user(tinfo->_sifields._sigchld._pid, 257 &info->_sifields._sigchld._pid); 258 __get_user(tinfo->_sifields._sigchld._uid, 259 &info->_sifields._sigchld._uid); 260 __get_user(tinfo->_sifields._sigchld._status, 261 &info->_sifields._sigchld._status); 262 __get_user(tinfo->_sifields._sigchld._utime, 263 &info->_sifields._sigchld._utime); 264 __get_user(tinfo->_sifields._sigchld._stime, 265 &info->_sifields._sigchld._stime); 266 si_type = QEMU_SI_CHLD; 267 break; 268 case TARGET_SIGIO: 269 __get_user(tinfo->_sifields._sigpoll._band, 270 &info->_sifields._sigpoll._band); 271 __get_user(tinfo->_sifields._sigpoll._fd, 272 &info->_sifields._sigpoll._fd); 273 si_type = QEMU_SI_POLL; 274 break; 275 default: 276 /* Assume a sigqueue()/mq_notify()/rt_sigqueueinfo() source. */ 277 __get_user(tinfo->_sifields._rt._pid, &info->_sifields._rt._pid); 278 __get_user(tinfo->_sifields._rt._uid, &info->_sifields._rt._uid); 279 /* XXX: potential problem if 64 bit */ 280 __get_user(sival_ptr, &info->_sifields._rt._sigval.sival_ptr); 281 tinfo->_sifields._rt._sigval.sival_ptr = sival_ptr; 282 283 si_type = QEMU_SI_RT; 284 break; 285 } 286 break; 287 } 288 289 tinfo->si_code = deposit32(si_code, 16, 16, si_type); 290 } 291 292 static void print_siginfo(const target_siginfo_t *tinfo) 293 { 294 /* Print a target_siginfo_t in the format desired for printing 295 * signals being taken. We assume the target_siginfo_t is in the 296 * internal form where the top 16 bits of si_code indicate which 297 * part of the union is valid, rather than in the guest-visible 298 * form where the bottom 16 bits are sign-extended into the top 16. 299 */ 300 int si_type = extract32(tinfo->si_code, 16, 16); 301 int si_code = sextract32(tinfo->si_code, 0, 16); 302 303 qemu_log("{si_signo="); 304 print_signal(tinfo->si_signo, 1); 305 qemu_log(", si_code="); 306 print_si_code(si_code); 307 308 switch (si_type) { 309 case QEMU_SI_KILL: 310 qemu_log(", si_pid=%u, si_uid=%u", 311 (unsigned int)tinfo->_sifields._kill._pid, 312 (unsigned int)tinfo->_sifields._kill._uid); 313 break; 314 case QEMU_SI_TIMER: 315 qemu_log(", si_timer1=%u, si_timer2=%u", 316 tinfo->_sifields._timer._timer1, 317 tinfo->_sifields._timer._timer2); 318 break; 319 case QEMU_SI_POLL: 320 qemu_log(", si_band=%d, si_fd=%d", 321 tinfo->_sifields._sigpoll._band, 322 tinfo->_sifields._sigpoll._fd); 323 break; 324 case QEMU_SI_FAULT: 325 qemu_log(", si_addr="); 326 print_pointer(tinfo->_sifields._sigfault._addr, 1); 327 break; 328 case QEMU_SI_CHLD: 329 qemu_log(", si_pid=%u, si_uid=%u, si_status=%d" 330 ", si_utime=" TARGET_ABI_FMT_ld 331 ", si_stime=" TARGET_ABI_FMT_ld, 332 (unsigned int)(tinfo->_sifields._sigchld._pid), 333 (unsigned int)(tinfo->_sifields._sigchld._uid), 334 tinfo->_sifields._sigchld._status, 335 tinfo->_sifields._sigchld._utime, 336 tinfo->_sifields._sigchld._stime); 337 break; 338 case QEMU_SI_RT: 339 qemu_log(", si_pid=%u, si_uid=%u, si_sigval=" TARGET_ABI_FMT_ld, 340 (unsigned int)tinfo->_sifields._rt._pid, 341 (unsigned int)tinfo->_sifields._rt._uid, 342 tinfo->_sifields._rt._sigval.sival_ptr); 343 break; 344 default: 345 g_assert_not_reached(); 346 } 347 qemu_log("}"); 348 } 349 350 static void 351 print_sockaddr(abi_ulong addr, abi_long addrlen, int last) 352 { 353 struct target_sockaddr *sa; 354 int i; 355 int sa_family; 356 357 sa = lock_user(VERIFY_READ, addr, addrlen, 1); 358 if (sa) { 359 sa_family = tswap16(sa->sa_family); 360 switch (sa_family) { 361 case AF_UNIX: { 362 struct target_sockaddr_un *un = (struct target_sockaddr_un *)sa; 363 int i; 364 qemu_log("{sun_family=AF_UNIX,sun_path=\""); 365 for (i = 0; i < addrlen - 366 offsetof(struct target_sockaddr_un, sun_path) && 367 un->sun_path[i]; i++) { 368 qemu_log("%c", un->sun_path[i]); 369 } 370 qemu_log("\"}"); 371 break; 372 } 373 case AF_INET: { 374 struct target_sockaddr_in *in = (struct target_sockaddr_in *)sa; 375 uint8_t *c = (uint8_t *)&in->sin_addr.s_addr; 376 qemu_log("{sin_family=AF_INET,sin_port=htons(%d),", 377 ntohs(in->sin_port)); 378 qemu_log("sin_addr=inet_addr(\"%d.%d.%d.%d\")", 379 c[0], c[1], c[2], c[3]); 380 qemu_log("}"); 381 break; 382 } 383 case AF_PACKET: { 384 struct target_sockaddr_ll *ll = (struct target_sockaddr_ll *)sa; 385 uint8_t *c = (uint8_t *)&ll->sll_addr; 386 qemu_log("{sll_family=AF_PACKET," 387 "sll_protocol=htons(0x%04x),if%d,pkttype=", 388 ntohs(ll->sll_protocol), ll->sll_ifindex); 389 switch (ll->sll_pkttype) { 390 case PACKET_HOST: 391 qemu_log("PACKET_HOST"); 392 break; 393 case PACKET_BROADCAST: 394 qemu_log("PACKET_BROADCAST"); 395 break; 396 case PACKET_MULTICAST: 397 qemu_log("PACKET_MULTICAST"); 398 break; 399 case PACKET_OTHERHOST: 400 qemu_log("PACKET_OTHERHOST"); 401 break; 402 case PACKET_OUTGOING: 403 qemu_log("PACKET_OUTGOING"); 404 break; 405 default: 406 qemu_log("%d", ll->sll_pkttype); 407 break; 408 } 409 qemu_log(",sll_addr=%02x:%02x:%02x:%02x:%02x:%02x:%02x:%02x", 410 c[0], c[1], c[2], c[3], c[4], c[5], c[6], c[7]); 411 qemu_log("}"); 412 break; 413 } 414 case AF_NETLINK: { 415 struct target_sockaddr_nl *nl = (struct target_sockaddr_nl *)sa; 416 qemu_log("{nl_family=AF_NETLINK,nl_pid=%u,nl_groups=%u}", 417 tswap32(nl->nl_pid), tswap32(nl->nl_groups)); 418 break; 419 } 420 default: 421 qemu_log("{sa_family=%d, sa_data={", sa->sa_family); 422 for (i = 0; i < 13; i++) { 423 qemu_log("%02x, ", sa->sa_data[i]); 424 } 425 qemu_log("%02x}", sa->sa_data[i]); 426 qemu_log("}"); 427 break; 428 } 429 unlock_user(sa, addr, 0); 430 } else { 431 print_raw_param("0x"TARGET_ABI_FMT_lx, addr, 0); 432 } 433 qemu_log(", "TARGET_ABI_FMT_ld"%s", addrlen, get_comma(last)); 434 } 435 436 static void 437 print_socket_domain(int domain) 438 { 439 switch (domain) { 440 case PF_UNIX: 441 qemu_log("PF_UNIX"); 442 break; 443 case PF_INET: 444 qemu_log("PF_INET"); 445 break; 446 case PF_NETLINK: 447 qemu_log("PF_NETLINK"); 448 break; 449 case PF_PACKET: 450 qemu_log("PF_PACKET"); 451 break; 452 default: 453 qemu_log("%d", domain); 454 break; 455 } 456 } 457 458 static void 459 print_socket_type(int type) 460 { 461 switch (type & TARGET_SOCK_TYPE_MASK) { 462 case TARGET_SOCK_DGRAM: 463 qemu_log("SOCK_DGRAM"); 464 break; 465 case TARGET_SOCK_STREAM: 466 qemu_log("SOCK_STREAM"); 467 break; 468 case TARGET_SOCK_RAW: 469 qemu_log("SOCK_RAW"); 470 break; 471 case TARGET_SOCK_RDM: 472 qemu_log("SOCK_RDM"); 473 break; 474 case TARGET_SOCK_SEQPACKET: 475 qemu_log("SOCK_SEQPACKET"); 476 break; 477 case TARGET_SOCK_PACKET: 478 qemu_log("SOCK_PACKET"); 479 break; 480 } 481 if (type & TARGET_SOCK_CLOEXEC) { 482 qemu_log("|SOCK_CLOEXEC"); 483 } 484 if (type & TARGET_SOCK_NONBLOCK) { 485 qemu_log("|SOCK_NONBLOCK"); 486 } 487 } 488 489 static void 490 print_socket_protocol(int domain, int type, int protocol) 491 { 492 if (domain == AF_PACKET || 493 (domain == AF_INET && type == TARGET_SOCK_PACKET)) { 494 switch (protocol) { 495 case 0x0003: 496 qemu_log("ETH_P_ALL"); 497 break; 498 default: 499 qemu_log("%d", protocol); 500 } 501 return; 502 } 503 504 if (domain == PF_NETLINK) { 505 switch (protocol) { 506 case NETLINK_ROUTE: 507 qemu_log("NETLINK_ROUTE"); 508 break; 509 case NETLINK_AUDIT: 510 qemu_log("NETLINK_AUDIT"); 511 break; 512 case NETLINK_NETFILTER: 513 qemu_log("NETLINK_NETFILTER"); 514 break; 515 case NETLINK_KOBJECT_UEVENT: 516 qemu_log("NETLINK_KOBJECT_UEVENT"); 517 break; 518 case NETLINK_RDMA: 519 qemu_log("NETLINK_RDMA"); 520 break; 521 case NETLINK_CRYPTO: 522 qemu_log("NETLINK_CRYPTO"); 523 break; 524 default: 525 qemu_log("%d", protocol); 526 break; 527 } 528 return; 529 } 530 531 switch (protocol) { 532 case IPPROTO_IP: 533 qemu_log("IPPROTO_IP"); 534 break; 535 case IPPROTO_TCP: 536 qemu_log("IPPROTO_TCP"); 537 break; 538 case IPPROTO_UDP: 539 qemu_log("IPPROTO_UDP"); 540 break; 541 case IPPROTO_RAW: 542 qemu_log("IPPROTO_RAW"); 543 break; 544 default: 545 qemu_log("%d", protocol); 546 break; 547 } 548 } 549 550 551 #ifdef TARGET_NR__newselect 552 static void 553 print_fdset(int n, abi_ulong target_fds_addr) 554 { 555 int i; 556 int first = 1; 557 558 qemu_log("["); 559 if( target_fds_addr ) { 560 abi_long *target_fds; 561 562 target_fds = lock_user(VERIFY_READ, 563 target_fds_addr, 564 sizeof(*target_fds)*(n / TARGET_ABI_BITS + 1), 565 1); 566 567 if (!target_fds) 568 return; 569 570 for (i=n; i>=0; i--) { 571 if ((tswapal(target_fds[i / TARGET_ABI_BITS]) >> 572 (i & (TARGET_ABI_BITS - 1))) & 1) { 573 qemu_log("%s%d", get_comma(first), i); 574 first = 0; 575 } 576 } 577 unlock_user(target_fds, target_fds_addr, 0); 578 } 579 qemu_log("]"); 580 } 581 #endif 582 583 /* 584 * Sysycall specific output functions 585 */ 586 587 /* select */ 588 #ifdef TARGET_NR__newselect 589 static void 590 print_newselect(CPUArchState *cpu_env, const struct syscallname *name, 591 abi_long arg1, abi_long arg2, abi_long arg3, 592 abi_long arg4, abi_long arg5, abi_long arg6) 593 { 594 print_syscall_prologue(name); 595 print_fdset(arg1, arg2); 596 qemu_log(","); 597 print_fdset(arg1, arg3); 598 qemu_log(","); 599 print_fdset(arg1, arg4); 600 qemu_log(","); 601 print_timeval(arg5, 1); 602 print_syscall_epilogue(name); 603 } 604 #endif 605 606 #ifdef TARGET_NR_semctl 607 static void 608 print_semctl(CPUArchState *cpu_env, const struct syscallname *name, 609 abi_long arg1, abi_long arg2, abi_long arg3, 610 abi_long arg4, abi_long arg5, abi_long arg6) 611 { 612 qemu_log("%s(" TARGET_ABI_FMT_ld "," TARGET_ABI_FMT_ld ",", 613 name->name, arg1, arg2); 614 print_ipc_cmd(arg3); 615 qemu_log(",0x" TARGET_ABI_FMT_lx ")", arg4); 616 } 617 #endif 618 619 static void 620 print_execve(CPUArchState *cpu_env, const struct syscallname *name, 621 abi_long arg1, abi_long arg2, abi_long arg3, 622 abi_long arg4, abi_long arg5, abi_long arg6) 623 { 624 abi_ulong arg_ptr_addr; 625 char *s; 626 627 if (!(s = lock_user_string(arg1))) 628 return; 629 qemu_log("%s(\"%s\",{", name->name, s); 630 unlock_user(s, arg1, 0); 631 632 for (arg_ptr_addr = arg2; ; arg_ptr_addr += sizeof(abi_ulong)) { 633 abi_ulong *arg_ptr, arg_addr; 634 635 arg_ptr = lock_user(VERIFY_READ, arg_ptr_addr, sizeof(abi_ulong), 1); 636 if (!arg_ptr) 637 return; 638 arg_addr = tswapal(*arg_ptr); 639 unlock_user(arg_ptr, arg_ptr_addr, 0); 640 if (!arg_addr) 641 break; 642 if ((s = lock_user_string(arg_addr))) { 643 qemu_log("\"%s\",", s); 644 unlock_user(s, arg_addr, 0); 645 } 646 } 647 648 qemu_log("NULL})"); 649 } 650 651 #ifdef TARGET_NR_ipc 652 static void 653 print_ipc(CPUArchState *cpu_env, const struct syscallname *name, 654 abi_long arg1, abi_long arg2, abi_long arg3, 655 abi_long arg4, abi_long arg5, abi_long arg6) 656 { 657 switch(arg1) { 658 case IPCOP_semctl: 659 qemu_log("semctl(" TARGET_ABI_FMT_ld "," TARGET_ABI_FMT_ld ",", 660 arg1, arg2); 661 print_ipc_cmd(arg3); 662 qemu_log(",0x" TARGET_ABI_FMT_lx ")", arg4); 663 break; 664 default: 665 qemu_log(("%s(" 666 TARGET_ABI_FMT_ld "," 667 TARGET_ABI_FMT_ld "," 668 TARGET_ABI_FMT_ld "," 669 TARGET_ABI_FMT_ld 670 ")"), 671 name->name, arg1, arg2, arg3, arg4); 672 } 673 } 674 #endif 675 676 /* 677 * Variants for the return value output function 678 */ 679 680 static bool 681 print_syscall_err(abi_long ret) 682 { 683 const char *errstr; 684 685 qemu_log(" = "); 686 if (is_error(ret)) { 687 errstr = target_strerror(-ret); 688 if (errstr) { 689 qemu_log("-1 errno=%d (%s)", (int)-ret, errstr); 690 return true; 691 } 692 } 693 return false; 694 } 695 696 static void 697 print_syscall_ret_addr(CPUArchState *cpu_env, const struct syscallname *name, 698 abi_long ret, abi_long arg0, abi_long arg1, 699 abi_long arg2, abi_long arg3, abi_long arg4, 700 abi_long arg5) 701 { 702 if (!print_syscall_err(ret)) { 703 qemu_log("0x" TARGET_ABI_FMT_lx, ret); 704 } 705 qemu_log("\n"); 706 } 707 708 #if 0 /* currently unused */ 709 static void 710 print_syscall_ret_raw(struct syscallname *name, abi_long ret) 711 { 712 qemu_log(" = 0x" TARGET_ABI_FMT_lx "\n", ret); 713 } 714 #endif 715 716 #ifdef TARGET_NR__newselect 717 static void 718 print_syscall_ret_newselect(CPUArchState *cpu_env, const struct syscallname *name, 719 abi_long ret, abi_long arg0, abi_long arg1, 720 abi_long arg2, abi_long arg3, abi_long arg4, 721 abi_long arg5) 722 { 723 if (!print_syscall_err(ret)) { 724 qemu_log(" = 0x" TARGET_ABI_FMT_lx " (", ret); 725 print_fdset(arg0, arg1); 726 qemu_log(","); 727 print_fdset(arg0, arg2); 728 qemu_log(","); 729 print_fdset(arg0, arg3); 730 qemu_log(","); 731 print_timeval(arg4, 1); 732 qemu_log(")"); 733 } 734 735 qemu_log("\n"); 736 } 737 #endif 738 739 /* special meanings of adjtimex()' non-negative return values */ 740 #define TARGET_TIME_OK 0 /* clock synchronized, no leap second */ 741 #define TARGET_TIME_INS 1 /* insert leap second */ 742 #define TARGET_TIME_DEL 2 /* delete leap second */ 743 #define TARGET_TIME_OOP 3 /* leap second in progress */ 744 #define TARGET_TIME_WAIT 4 /* leap second has occurred */ 745 #define TARGET_TIME_ERROR 5 /* clock not synchronized */ 746 #ifdef TARGET_NR_adjtimex 747 static void 748 print_syscall_ret_adjtimex(CPUArchState *cpu_env, const struct syscallname *name, 749 abi_long ret, abi_long arg0, abi_long arg1, 750 abi_long arg2, abi_long arg3, abi_long arg4, 751 abi_long arg5) 752 { 753 if (!print_syscall_err(ret)) { 754 qemu_log(TARGET_ABI_FMT_ld, ret); 755 switch (ret) { 756 case TARGET_TIME_OK: 757 qemu_log(" TIME_OK (clock synchronized, no leap second)"); 758 break; 759 case TARGET_TIME_INS: 760 qemu_log(" TIME_INS (insert leap second)"); 761 break; 762 case TARGET_TIME_DEL: 763 qemu_log(" TIME_DEL (delete leap second)"); 764 break; 765 case TARGET_TIME_OOP: 766 qemu_log(" TIME_OOP (leap second in progress)"); 767 break; 768 case TARGET_TIME_WAIT: 769 qemu_log(" TIME_WAIT (leap second has occurred)"); 770 break; 771 case TARGET_TIME_ERROR: 772 qemu_log(" TIME_ERROR (clock not synchronized)"); 773 break; 774 } 775 } 776 777 qemu_log("\n"); 778 } 779 #endif 780 781 #if defined(TARGET_NR_clock_gettime) || defined(TARGET_NR_clock_getres) 782 static void 783 print_syscall_ret_clock_gettime(CPUArchState *cpu_env, const struct syscallname *name, 784 abi_long ret, abi_long arg0, abi_long arg1, 785 abi_long arg2, abi_long arg3, abi_long arg4, 786 abi_long arg5) 787 { 788 if (!print_syscall_err(ret)) { 789 qemu_log(TARGET_ABI_FMT_ld, ret); 790 qemu_log(" ("); 791 print_timespec(arg1, 1); 792 qemu_log(")"); 793 } 794 795 qemu_log("\n"); 796 } 797 #define print_syscall_ret_clock_getres print_syscall_ret_clock_gettime 798 #endif 799 800 #if defined(TARGET_NR_clock_gettime64) 801 static void 802 print_syscall_ret_clock_gettime64(CPUArchState *cpu_env, const struct syscallname *name, 803 abi_long ret, abi_long arg0, abi_long arg1, 804 abi_long arg2, abi_long arg3, abi_long arg4, 805 abi_long arg5) 806 { 807 if (!print_syscall_err(ret)) { 808 qemu_log(TARGET_ABI_FMT_ld, ret); 809 qemu_log(" ("); 810 print_timespec64(arg1, 1); 811 qemu_log(")"); 812 } 813 814 qemu_log("\n"); 815 } 816 #endif 817 818 #ifdef TARGET_NR_gettimeofday 819 static void 820 print_syscall_ret_gettimeofday(CPUArchState *cpu_env, const struct syscallname *name, 821 abi_long ret, abi_long arg0, abi_long arg1, 822 abi_long arg2, abi_long arg3, abi_long arg4, 823 abi_long arg5) 824 { 825 if (!print_syscall_err(ret)) { 826 qemu_log(TARGET_ABI_FMT_ld, ret); 827 qemu_log(" ("); 828 print_timeval(arg0, 0); 829 print_timezone(arg1, 1); 830 qemu_log(")"); 831 } 832 833 qemu_log("\n"); 834 } 835 #endif 836 837 #ifdef TARGET_NR_getitimer 838 static void 839 print_syscall_ret_getitimer(CPUArchState *cpu_env, const struct syscallname *name, 840 abi_long ret, abi_long arg0, abi_long arg1, 841 abi_long arg2, abi_long arg3, abi_long arg4, 842 abi_long arg5) 843 { 844 if (!print_syscall_err(ret)) { 845 qemu_log(TARGET_ABI_FMT_ld, ret); 846 qemu_log(" ("); 847 print_itimerval(arg1, 1); 848 qemu_log(")"); 849 } 850 851 qemu_log("\n"); 852 } 853 #endif 854 855 856 #ifdef TARGET_NR_getitimer 857 static void 858 print_syscall_ret_setitimer(CPUArchState *cpu_env, const struct syscallname *name, 859 abi_long ret, abi_long arg0, abi_long arg1, 860 abi_long arg2, abi_long arg3, abi_long arg4, 861 abi_long arg5) 862 { 863 if (!print_syscall_err(ret)) { 864 qemu_log(TARGET_ABI_FMT_ld, ret); 865 qemu_log(" (old_value = "); 866 print_itimerval(arg2, 1); 867 qemu_log(")"); 868 } 869 870 qemu_log("\n"); 871 } 872 #endif 873 874 #if defined(TARGET_NR_listxattr) || defined(TARGET_NR_llistxattr) \ 875 || defined(TARGGET_NR_flistxattr) 876 static void 877 print_syscall_ret_listxattr(CPUArchState *cpu_env, const struct syscallname *name, 878 abi_long ret, abi_long arg0, abi_long arg1, 879 abi_long arg2, abi_long arg3, abi_long arg4, 880 abi_long arg5) 881 { 882 if (!print_syscall_err(ret)) { 883 qemu_log(TARGET_ABI_FMT_ld, ret); 884 qemu_log(" (list = "); 885 if (arg1 != 0) { 886 abi_long attr = arg1; 887 while (ret) { 888 if (attr != arg1) { 889 qemu_log(","); 890 } 891 print_string(attr, 1); 892 ret -= target_strlen(attr) + 1; 893 attr += target_strlen(attr) + 1; 894 } 895 } else { 896 qemu_log("NULL"); 897 } 898 qemu_log(")"); 899 } 900 901 qemu_log("\n"); 902 } 903 #define print_syscall_ret_llistxattr print_syscall_ret_listxattr 904 #define print_syscall_ret_flistxattr print_syscall_ret_listxattr 905 #endif 906 907 #ifdef TARGET_NR_ioctl 908 static void 909 print_syscall_ret_ioctl(CPUArchState *cpu_env, const struct syscallname *name, 910 abi_long ret, abi_long arg0, abi_long arg1, 911 abi_long arg2, abi_long arg3, abi_long arg4, 912 abi_long arg5) 913 { 914 if (!print_syscall_err(ret)) { 915 qemu_log(TARGET_ABI_FMT_ld, ret); 916 917 const IOCTLEntry *ie; 918 const argtype *arg_type; 919 void *argptr; 920 int target_size; 921 922 for (ie = ioctl_entries; ie->target_cmd != 0; ie++) { 923 if (ie->target_cmd == arg1) { 924 break; 925 } 926 } 927 928 if (ie->target_cmd == arg1 && 929 (ie->access == IOC_R || ie->access == IOC_RW)) { 930 arg_type = ie->arg_type; 931 qemu_log(" ("); 932 arg_type++; 933 target_size = thunk_type_size(arg_type, 0); 934 argptr = lock_user(VERIFY_READ, arg2, target_size, 1); 935 if (argptr) { 936 thunk_print(argptr, arg_type); 937 unlock_user(argptr, arg2, target_size); 938 } else { 939 print_pointer(arg2, 1); 940 } 941 qemu_log(")"); 942 } 943 } 944 qemu_log("\n"); 945 } 946 #endif 947 948 UNUSED static struct flags access_flags[] = { 949 FLAG_GENERIC(F_OK), 950 FLAG_GENERIC(R_OK), 951 FLAG_GENERIC(W_OK), 952 FLAG_GENERIC(X_OK), 953 FLAG_END, 954 }; 955 956 UNUSED static struct flags at_file_flags[] = { 957 #ifdef AT_EACCESS 958 FLAG_GENERIC(AT_EACCESS), 959 #endif 960 #ifdef AT_SYMLINK_NOFOLLOW 961 FLAG_GENERIC(AT_SYMLINK_NOFOLLOW), 962 #endif 963 FLAG_END, 964 }; 965 966 UNUSED static struct flags unlinkat_flags[] = { 967 #ifdef AT_REMOVEDIR 968 FLAG_GENERIC(AT_REMOVEDIR), 969 #endif 970 FLAG_END, 971 }; 972 973 UNUSED static struct flags mode_flags[] = { 974 FLAG_GENERIC(S_IFSOCK), 975 FLAG_GENERIC(S_IFLNK), 976 FLAG_GENERIC(S_IFREG), 977 FLAG_GENERIC(S_IFBLK), 978 FLAG_GENERIC(S_IFDIR), 979 FLAG_GENERIC(S_IFCHR), 980 FLAG_GENERIC(S_IFIFO), 981 FLAG_END, 982 }; 983 984 UNUSED static struct flags open_access_flags[] = { 985 FLAG_TARGET(O_RDONLY), 986 FLAG_TARGET(O_WRONLY), 987 FLAG_TARGET(O_RDWR), 988 FLAG_END, 989 }; 990 991 UNUSED static struct flags open_flags[] = { 992 FLAG_TARGET(O_APPEND), 993 FLAG_TARGET(O_CREAT), 994 FLAG_TARGET(O_DIRECTORY), 995 FLAG_TARGET(O_EXCL), 996 FLAG_TARGET(O_LARGEFILE), 997 FLAG_TARGET(O_NOCTTY), 998 FLAG_TARGET(O_NOFOLLOW), 999 FLAG_TARGET(O_NONBLOCK), /* also O_NDELAY */ 1000 FLAG_TARGET(O_DSYNC), 1001 FLAG_TARGET(__O_SYNC), 1002 FLAG_TARGET(O_TRUNC), 1003 #ifdef O_DIRECT 1004 FLAG_TARGET(O_DIRECT), 1005 #endif 1006 #ifdef O_NOATIME 1007 FLAG_TARGET(O_NOATIME), 1008 #endif 1009 #ifdef O_CLOEXEC 1010 FLAG_TARGET(O_CLOEXEC), 1011 #endif 1012 #ifdef O_PATH 1013 FLAG_TARGET(O_PATH), 1014 #endif 1015 #ifdef O_TMPFILE 1016 FLAG_TARGET(O_TMPFILE), 1017 FLAG_TARGET(__O_TMPFILE), 1018 #endif 1019 FLAG_END, 1020 }; 1021 1022 UNUSED static struct flags mount_flags[] = { 1023 #ifdef MS_BIND 1024 FLAG_GENERIC(MS_BIND), 1025 #endif 1026 #ifdef MS_DIRSYNC 1027 FLAG_GENERIC(MS_DIRSYNC), 1028 #endif 1029 FLAG_GENERIC(MS_MANDLOCK), 1030 #ifdef MS_MOVE 1031 FLAG_GENERIC(MS_MOVE), 1032 #endif 1033 FLAG_GENERIC(MS_NOATIME), 1034 FLAG_GENERIC(MS_NODEV), 1035 FLAG_GENERIC(MS_NODIRATIME), 1036 FLAG_GENERIC(MS_NOEXEC), 1037 FLAG_GENERIC(MS_NOSUID), 1038 FLAG_GENERIC(MS_RDONLY), 1039 #ifdef MS_RELATIME 1040 FLAG_GENERIC(MS_RELATIME), 1041 #endif 1042 FLAG_GENERIC(MS_REMOUNT), 1043 FLAG_GENERIC(MS_SYNCHRONOUS), 1044 FLAG_END, 1045 }; 1046 1047 UNUSED static struct flags umount2_flags[] = { 1048 #ifdef MNT_FORCE 1049 FLAG_GENERIC(MNT_FORCE), 1050 #endif 1051 #ifdef MNT_DETACH 1052 FLAG_GENERIC(MNT_DETACH), 1053 #endif 1054 #ifdef MNT_EXPIRE 1055 FLAG_GENERIC(MNT_EXPIRE), 1056 #endif 1057 FLAG_END, 1058 }; 1059 1060 UNUSED static struct flags mmap_prot_flags[] = { 1061 FLAG_GENERIC(PROT_NONE), 1062 FLAG_GENERIC(PROT_EXEC), 1063 FLAG_GENERIC(PROT_READ), 1064 FLAG_GENERIC(PROT_WRITE), 1065 FLAG_TARGET(PROT_SEM), 1066 FLAG_GENERIC(PROT_GROWSDOWN), 1067 FLAG_GENERIC(PROT_GROWSUP), 1068 FLAG_END, 1069 }; 1070 1071 UNUSED static struct flags mmap_flags[] = { 1072 FLAG_TARGET(MAP_SHARED), 1073 FLAG_TARGET(MAP_PRIVATE), 1074 FLAG_TARGET(MAP_ANONYMOUS), 1075 FLAG_TARGET(MAP_DENYWRITE), 1076 FLAG_TARGET(MAP_FIXED), 1077 FLAG_TARGET(MAP_GROWSDOWN), 1078 FLAG_TARGET(MAP_EXECUTABLE), 1079 #ifdef MAP_LOCKED 1080 FLAG_TARGET(MAP_LOCKED), 1081 #endif 1082 #ifdef MAP_NONBLOCK 1083 FLAG_TARGET(MAP_NONBLOCK), 1084 #endif 1085 FLAG_TARGET(MAP_NORESERVE), 1086 #ifdef MAP_POPULATE 1087 FLAG_TARGET(MAP_POPULATE), 1088 #endif 1089 #ifdef TARGET_MAP_UNINITIALIZED 1090 FLAG_TARGET(MAP_UNINITIALIZED), 1091 #endif 1092 FLAG_END, 1093 }; 1094 1095 UNUSED static struct flags clone_flags[] = { 1096 FLAG_GENERIC(CLONE_VM), 1097 FLAG_GENERIC(CLONE_FS), 1098 FLAG_GENERIC(CLONE_FILES), 1099 FLAG_GENERIC(CLONE_SIGHAND), 1100 FLAG_GENERIC(CLONE_PTRACE), 1101 FLAG_GENERIC(CLONE_VFORK), 1102 FLAG_GENERIC(CLONE_PARENT), 1103 FLAG_GENERIC(CLONE_THREAD), 1104 FLAG_GENERIC(CLONE_NEWNS), 1105 FLAG_GENERIC(CLONE_SYSVSEM), 1106 FLAG_GENERIC(CLONE_SETTLS), 1107 FLAG_GENERIC(CLONE_PARENT_SETTID), 1108 FLAG_GENERIC(CLONE_CHILD_CLEARTID), 1109 FLAG_GENERIC(CLONE_DETACHED), 1110 FLAG_GENERIC(CLONE_UNTRACED), 1111 FLAG_GENERIC(CLONE_CHILD_SETTID), 1112 #if defined(CLONE_NEWUTS) 1113 FLAG_GENERIC(CLONE_NEWUTS), 1114 #endif 1115 #if defined(CLONE_NEWIPC) 1116 FLAG_GENERIC(CLONE_NEWIPC), 1117 #endif 1118 #if defined(CLONE_NEWUSER) 1119 FLAG_GENERIC(CLONE_NEWUSER), 1120 #endif 1121 #if defined(CLONE_NEWPID) 1122 FLAG_GENERIC(CLONE_NEWPID), 1123 #endif 1124 #if defined(CLONE_NEWNET) 1125 FLAG_GENERIC(CLONE_NEWNET), 1126 #endif 1127 #if defined(CLONE_NEWCGROUP) 1128 FLAG_GENERIC(CLONE_NEWCGROUP), 1129 #endif 1130 #if defined(CLONE_NEWTIME) 1131 FLAG_GENERIC(CLONE_NEWTIME), 1132 #endif 1133 #if defined(CLONE_IO) 1134 FLAG_GENERIC(CLONE_IO), 1135 #endif 1136 FLAG_END, 1137 }; 1138 1139 UNUSED static struct flags msg_flags[] = { 1140 /* send */ 1141 FLAG_GENERIC(MSG_CONFIRM), 1142 FLAG_GENERIC(MSG_DONTROUTE), 1143 FLAG_GENERIC(MSG_DONTWAIT), 1144 FLAG_GENERIC(MSG_EOR), 1145 FLAG_GENERIC(MSG_MORE), 1146 FLAG_GENERIC(MSG_NOSIGNAL), 1147 FLAG_GENERIC(MSG_OOB), 1148 /* recv */ 1149 FLAG_GENERIC(MSG_CMSG_CLOEXEC), 1150 FLAG_GENERIC(MSG_ERRQUEUE), 1151 FLAG_GENERIC(MSG_PEEK), 1152 FLAG_GENERIC(MSG_TRUNC), 1153 FLAG_GENERIC(MSG_WAITALL), 1154 /* recvmsg */ 1155 FLAG_GENERIC(MSG_CTRUNC), 1156 FLAG_END, 1157 }; 1158 1159 UNUSED static struct flags statx_flags[] = { 1160 #ifdef AT_EMPTY_PATH 1161 FLAG_GENERIC(AT_EMPTY_PATH), 1162 #endif 1163 #ifdef AT_NO_AUTOMOUNT 1164 FLAG_GENERIC(AT_NO_AUTOMOUNT), 1165 #endif 1166 #ifdef AT_SYMLINK_NOFOLLOW 1167 FLAG_GENERIC(AT_SYMLINK_NOFOLLOW), 1168 #endif 1169 #ifdef AT_STATX_SYNC_AS_STAT 1170 FLAG_GENERIC(AT_STATX_SYNC_AS_STAT), 1171 #endif 1172 #ifdef AT_STATX_FORCE_SYNC 1173 FLAG_GENERIC(AT_STATX_FORCE_SYNC), 1174 #endif 1175 #ifdef AT_STATX_DONT_SYNC 1176 FLAG_GENERIC(AT_STATX_DONT_SYNC), 1177 #endif 1178 FLAG_END, 1179 }; 1180 1181 UNUSED static struct flags statx_mask[] = { 1182 /* This must come first, because it includes everything. */ 1183 #ifdef STATX_ALL 1184 FLAG_GENERIC(STATX_ALL), 1185 #endif 1186 /* This must come second; it includes everything except STATX_BTIME. */ 1187 #ifdef STATX_BASIC_STATS 1188 FLAG_GENERIC(STATX_BASIC_STATS), 1189 #endif 1190 #ifdef STATX_TYPE 1191 FLAG_GENERIC(STATX_TYPE), 1192 #endif 1193 #ifdef STATX_MODE 1194 FLAG_GENERIC(STATX_MODE), 1195 #endif 1196 #ifdef STATX_NLINK 1197 FLAG_GENERIC(STATX_NLINK), 1198 #endif 1199 #ifdef STATX_UID 1200 FLAG_GENERIC(STATX_UID), 1201 #endif 1202 #ifdef STATX_GID 1203 FLAG_GENERIC(STATX_GID), 1204 #endif 1205 #ifdef STATX_ATIME 1206 FLAG_GENERIC(STATX_ATIME), 1207 #endif 1208 #ifdef STATX_MTIME 1209 FLAG_GENERIC(STATX_MTIME), 1210 #endif 1211 #ifdef STATX_CTIME 1212 FLAG_GENERIC(STATX_CTIME), 1213 #endif 1214 #ifdef STATX_INO 1215 FLAG_GENERIC(STATX_INO), 1216 #endif 1217 #ifdef STATX_SIZE 1218 FLAG_GENERIC(STATX_SIZE), 1219 #endif 1220 #ifdef STATX_BLOCKS 1221 FLAG_GENERIC(STATX_BLOCKS), 1222 #endif 1223 #ifdef STATX_BTIME 1224 FLAG_GENERIC(STATX_BTIME), 1225 #endif 1226 FLAG_END, 1227 }; 1228 1229 UNUSED static struct flags falloc_flags[] = { 1230 FLAG_GENERIC(FALLOC_FL_KEEP_SIZE), 1231 FLAG_GENERIC(FALLOC_FL_PUNCH_HOLE), 1232 #ifdef FALLOC_FL_NO_HIDE_STALE 1233 FLAG_GENERIC(FALLOC_FL_NO_HIDE_STALE), 1234 #endif 1235 #ifdef FALLOC_FL_COLLAPSE_RANGE 1236 FLAG_GENERIC(FALLOC_FL_COLLAPSE_RANGE), 1237 #endif 1238 #ifdef FALLOC_FL_ZERO_RANGE 1239 FLAG_GENERIC(FALLOC_FL_ZERO_RANGE), 1240 #endif 1241 #ifdef FALLOC_FL_INSERT_RANGE 1242 FLAG_GENERIC(FALLOC_FL_INSERT_RANGE), 1243 #endif 1244 #ifdef FALLOC_FL_UNSHARE_RANGE 1245 FLAG_GENERIC(FALLOC_FL_UNSHARE_RANGE), 1246 #endif 1247 }; 1248 1249 UNUSED static struct flags termios_iflags[] = { 1250 FLAG_TARGET(IGNBRK), 1251 FLAG_TARGET(BRKINT), 1252 FLAG_TARGET(IGNPAR), 1253 FLAG_TARGET(PARMRK), 1254 FLAG_TARGET(INPCK), 1255 FLAG_TARGET(ISTRIP), 1256 FLAG_TARGET(INLCR), 1257 FLAG_TARGET(IGNCR), 1258 FLAG_TARGET(ICRNL), 1259 FLAG_TARGET(IUCLC), 1260 FLAG_TARGET(IXON), 1261 FLAG_TARGET(IXANY), 1262 FLAG_TARGET(IXOFF), 1263 FLAG_TARGET(IMAXBEL), 1264 FLAG_TARGET(IUTF8), 1265 FLAG_END, 1266 }; 1267 1268 UNUSED static struct flags termios_oflags[] = { 1269 FLAG_TARGET(OPOST), 1270 FLAG_TARGET(OLCUC), 1271 FLAG_TARGET(ONLCR), 1272 FLAG_TARGET(OCRNL), 1273 FLAG_TARGET(ONOCR), 1274 FLAG_TARGET(ONLRET), 1275 FLAG_TARGET(OFILL), 1276 FLAG_TARGET(OFDEL), 1277 FLAG_END, 1278 }; 1279 1280 UNUSED static struct enums termios_oflags_NLDLY[] = { 1281 ENUM_TARGET(NL0), 1282 ENUM_TARGET(NL1), 1283 ENUM_END, 1284 }; 1285 1286 UNUSED static struct enums termios_oflags_CRDLY[] = { 1287 ENUM_TARGET(CR0), 1288 ENUM_TARGET(CR1), 1289 ENUM_TARGET(CR2), 1290 ENUM_TARGET(CR3), 1291 ENUM_END, 1292 }; 1293 1294 UNUSED static struct enums termios_oflags_TABDLY[] = { 1295 ENUM_TARGET(TAB0), 1296 ENUM_TARGET(TAB1), 1297 ENUM_TARGET(TAB2), 1298 ENUM_TARGET(TAB3), 1299 ENUM_END, 1300 }; 1301 1302 UNUSED static struct enums termios_oflags_VTDLY[] = { 1303 ENUM_TARGET(VT0), 1304 ENUM_TARGET(VT1), 1305 ENUM_END, 1306 }; 1307 1308 UNUSED static struct enums termios_oflags_FFDLY[] = { 1309 ENUM_TARGET(FF0), 1310 ENUM_TARGET(FF1), 1311 ENUM_END, 1312 }; 1313 1314 UNUSED static struct enums termios_oflags_BSDLY[] = { 1315 ENUM_TARGET(BS0), 1316 ENUM_TARGET(BS1), 1317 ENUM_END, 1318 }; 1319 1320 UNUSED static struct enums termios_cflags_CBAUD[] = { 1321 ENUM_TARGET(B0), 1322 ENUM_TARGET(B50), 1323 ENUM_TARGET(B75), 1324 ENUM_TARGET(B110), 1325 ENUM_TARGET(B134), 1326 ENUM_TARGET(B150), 1327 ENUM_TARGET(B200), 1328 ENUM_TARGET(B300), 1329 ENUM_TARGET(B600), 1330 ENUM_TARGET(B1200), 1331 ENUM_TARGET(B1800), 1332 ENUM_TARGET(B2400), 1333 ENUM_TARGET(B4800), 1334 ENUM_TARGET(B9600), 1335 ENUM_TARGET(B19200), 1336 ENUM_TARGET(B38400), 1337 ENUM_TARGET(B57600), 1338 ENUM_TARGET(B115200), 1339 ENUM_TARGET(B230400), 1340 ENUM_TARGET(B460800), 1341 ENUM_END, 1342 }; 1343 1344 UNUSED static struct enums termios_cflags_CSIZE[] = { 1345 ENUM_TARGET(CS5), 1346 ENUM_TARGET(CS6), 1347 ENUM_TARGET(CS7), 1348 ENUM_TARGET(CS8), 1349 ENUM_END, 1350 }; 1351 1352 UNUSED static struct flags termios_cflags[] = { 1353 FLAG_TARGET(CSTOPB), 1354 FLAG_TARGET(CREAD), 1355 FLAG_TARGET(PARENB), 1356 FLAG_TARGET(PARODD), 1357 FLAG_TARGET(HUPCL), 1358 FLAG_TARGET(CLOCAL), 1359 FLAG_TARGET(CRTSCTS), 1360 FLAG_END, 1361 }; 1362 1363 UNUSED static struct flags termios_lflags[] = { 1364 FLAG_TARGET(ISIG), 1365 FLAG_TARGET(ICANON), 1366 FLAG_TARGET(XCASE), 1367 FLAG_TARGET(ECHO), 1368 FLAG_TARGET(ECHOE), 1369 FLAG_TARGET(ECHOK), 1370 FLAG_TARGET(ECHONL), 1371 FLAG_TARGET(NOFLSH), 1372 FLAG_TARGET(TOSTOP), 1373 FLAG_TARGET(ECHOCTL), 1374 FLAG_TARGET(ECHOPRT), 1375 FLAG_TARGET(ECHOKE), 1376 FLAG_TARGET(FLUSHO), 1377 FLAG_TARGET(PENDIN), 1378 FLAG_TARGET(IEXTEN), 1379 FLAG_TARGET(EXTPROC), 1380 FLAG_END, 1381 }; 1382 1383 UNUSED static struct flags mlockall_flags[] = { 1384 FLAG_TARGET(MCL_CURRENT), 1385 FLAG_TARGET(MCL_FUTURE), 1386 #ifdef MCL_ONFAULT 1387 FLAG_TARGET(MCL_ONFAULT), 1388 #endif 1389 FLAG_END, 1390 }; 1391 1392 /* IDs of the various system clocks */ 1393 #define TARGET_CLOCK_REALTIME 0 1394 #define TARGET_CLOCK_MONOTONIC 1 1395 #define TARGET_CLOCK_PROCESS_CPUTIME_ID 2 1396 #define TARGET_CLOCK_THREAD_CPUTIME_ID 3 1397 #define TARGET_CLOCK_MONOTONIC_RAW 4 1398 #define TARGET_CLOCK_REALTIME_COARSE 5 1399 #define TARGET_CLOCK_MONOTONIC_COARSE 6 1400 #define TARGET_CLOCK_BOOTTIME 7 1401 #define TARGET_CLOCK_REALTIME_ALARM 8 1402 #define TARGET_CLOCK_BOOTTIME_ALARM 9 1403 #define TARGET_CLOCK_SGI_CYCLE 10 1404 #define TARGET_CLOCK_TAI 11 1405 1406 UNUSED static struct enums clockids[] = { 1407 ENUM_TARGET(CLOCK_REALTIME), 1408 ENUM_TARGET(CLOCK_MONOTONIC), 1409 ENUM_TARGET(CLOCK_PROCESS_CPUTIME_ID), 1410 ENUM_TARGET(CLOCK_THREAD_CPUTIME_ID), 1411 ENUM_TARGET(CLOCK_MONOTONIC_RAW), 1412 ENUM_TARGET(CLOCK_REALTIME_COARSE), 1413 ENUM_TARGET(CLOCK_MONOTONIC_COARSE), 1414 ENUM_TARGET(CLOCK_BOOTTIME), 1415 ENUM_TARGET(CLOCK_REALTIME_ALARM), 1416 ENUM_TARGET(CLOCK_BOOTTIME_ALARM), 1417 ENUM_TARGET(CLOCK_SGI_CYCLE), 1418 ENUM_TARGET(CLOCK_TAI), 1419 ENUM_END, 1420 }; 1421 1422 UNUSED static struct enums itimer_types[] = { 1423 ENUM_GENERIC(ITIMER_REAL), 1424 ENUM_GENERIC(ITIMER_VIRTUAL), 1425 ENUM_GENERIC(ITIMER_PROF), 1426 ENUM_END, 1427 }; 1428 1429 /* 1430 * print_xxx utility functions. These are used to print syscall 1431 * parameters in certain format. All of these have parameter 1432 * named 'last'. This parameter is used to add comma to output 1433 * when last == 0. 1434 */ 1435 1436 static const char * 1437 get_comma(int last) 1438 { 1439 return ((last) ? "" : ","); 1440 } 1441 1442 static void 1443 print_flags(const struct flags *f, abi_long flags, int last) 1444 { 1445 const char *sep = ""; 1446 int n; 1447 1448 if ((flags == 0) && (f->f_value == 0)) { 1449 qemu_log("%s%s", f->f_string, get_comma(last)); 1450 return; 1451 } 1452 for (n = 0; f->f_string != NULL; f++) { 1453 if ((f->f_value != 0) && ((flags & f->f_value) == f->f_value)) { 1454 qemu_log("%s%s", sep, f->f_string); 1455 flags &= ~f->f_value; 1456 sep = "|"; 1457 n++; 1458 } 1459 } 1460 1461 if (n > 0) { 1462 /* print rest of the flags as numeric */ 1463 if (flags != 0) { 1464 qemu_log("%s%#x%s", sep, (unsigned int)flags, get_comma(last)); 1465 } else { 1466 qemu_log("%s", get_comma(last)); 1467 } 1468 } else { 1469 /* no string version of flags found, print them in hex then */ 1470 qemu_log("%#x%s", (unsigned int)flags, get_comma(last)); 1471 } 1472 } 1473 1474 static void 1475 print_enums(const struct enums *e, abi_long enum_arg, int last) 1476 { 1477 for (; e->e_string != NULL; e++) { 1478 if (e->e_value == enum_arg) { 1479 qemu_log("%s", e->e_string); 1480 break; 1481 } 1482 } 1483 1484 if (e->e_string == NULL) { 1485 qemu_log("%#x", (unsigned int)enum_arg); 1486 } 1487 1488 qemu_log("%s", get_comma(last)); 1489 } 1490 1491 static void 1492 print_at_dirfd(abi_long dirfd, int last) 1493 { 1494 #ifdef AT_FDCWD 1495 if (dirfd == AT_FDCWD) { 1496 qemu_log("AT_FDCWD%s", get_comma(last)); 1497 return; 1498 } 1499 #endif 1500 qemu_log("%d%s", (int)dirfd, get_comma(last)); 1501 } 1502 1503 static void 1504 print_file_mode(abi_long mode, int last) 1505 { 1506 const char *sep = ""; 1507 const struct flags *m; 1508 1509 if (mode == 0) { 1510 qemu_log("000%s", get_comma(last)); 1511 return; 1512 } 1513 1514 for (m = &mode_flags[0]; m->f_string != NULL; m++) { 1515 if ((m->f_value & mode) == m->f_value) { 1516 qemu_log("%s%s", m->f_string, sep); 1517 sep = "|"; 1518 mode &= ~m->f_value; 1519 break; 1520 } 1521 } 1522 1523 mode &= ~S_IFMT; 1524 /* print rest of the mode as octal */ 1525 if (mode != 0) 1526 qemu_log("%s%#o", sep, (unsigned int)mode); 1527 1528 qemu_log("%s", get_comma(last)); 1529 } 1530 1531 static void 1532 print_open_flags(abi_long flags, int last) 1533 { 1534 print_flags(open_access_flags, flags & TARGET_O_ACCMODE, 1); 1535 flags &= ~TARGET_O_ACCMODE; 1536 if (flags == 0) { 1537 qemu_log("%s", get_comma(last)); 1538 return; 1539 } 1540 qemu_log("|"); 1541 print_flags(open_flags, flags, last); 1542 } 1543 1544 static void 1545 print_syscall_prologue(const struct syscallname *sc) 1546 { 1547 qemu_log("%s(", sc->name); 1548 } 1549 1550 /*ARGSUSED*/ 1551 static void 1552 print_syscall_epilogue(const struct syscallname *sc) 1553 { 1554 (void)sc; 1555 qemu_log(")"); 1556 } 1557 1558 static void 1559 print_string(abi_long addr, int last) 1560 { 1561 char *s; 1562 1563 if ((s = lock_user_string(addr)) != NULL) { 1564 qemu_log("\"%s\"%s", s, get_comma(last)); 1565 unlock_user(s, addr, 0); 1566 } else { 1567 /* can't get string out of it, so print it as pointer */ 1568 print_pointer(addr, last); 1569 } 1570 } 1571 1572 #define MAX_PRINT_BUF 40 1573 static void 1574 print_buf(abi_long addr, abi_long len, int last) 1575 { 1576 uint8_t *s; 1577 int i; 1578 1579 s = lock_user(VERIFY_READ, addr, len, 1); 1580 if (s) { 1581 qemu_log("\""); 1582 for (i = 0; i < MAX_PRINT_BUF && i < len; i++) { 1583 if (isprint(s[i])) { 1584 qemu_log("%c", s[i]); 1585 } else { 1586 qemu_log("\\%o", s[i]); 1587 } 1588 } 1589 qemu_log("\""); 1590 if (i != len) { 1591 qemu_log("..."); 1592 } 1593 if (!last) { 1594 qemu_log(","); 1595 } 1596 unlock_user(s, addr, 0); 1597 } else { 1598 print_pointer(addr, last); 1599 } 1600 } 1601 1602 /* 1603 * Prints out raw parameter using given format. Caller needs 1604 * to do byte swapping if needed. 1605 */ 1606 static void 1607 print_raw_param(const char *fmt, abi_long param, int last) 1608 { 1609 char format[64]; 1610 1611 (void) snprintf(format, sizeof (format), "%s%s", fmt, get_comma(last)); 1612 qemu_log(format, param); 1613 } 1614 1615 static void 1616 print_pointer(abi_long p, int last) 1617 { 1618 if (p == 0) 1619 qemu_log("NULL%s", get_comma(last)); 1620 else 1621 qemu_log("0x" TARGET_ABI_FMT_lx "%s", p, get_comma(last)); 1622 } 1623 1624 /* 1625 * Reads 32-bit (int) number from guest address space from 1626 * address 'addr' and prints it. 1627 */ 1628 static void 1629 print_number(abi_long addr, int last) 1630 { 1631 if (addr == 0) { 1632 qemu_log("NULL%s", get_comma(last)); 1633 } else { 1634 int num; 1635 1636 get_user_s32(num, addr); 1637 qemu_log("[%d]%s", num, get_comma(last)); 1638 } 1639 } 1640 1641 static void 1642 print_timeval(abi_ulong tv_addr, int last) 1643 { 1644 if( tv_addr ) { 1645 struct target_timeval *tv; 1646 1647 tv = lock_user(VERIFY_READ, tv_addr, sizeof(*tv), 1); 1648 if (!tv) { 1649 print_pointer(tv_addr, last); 1650 return; 1651 } 1652 qemu_log("{tv_sec = " TARGET_ABI_FMT_ld 1653 ",tv_usec = " TARGET_ABI_FMT_ld "}%s", 1654 tswapal(tv->tv_sec), tswapal(tv->tv_usec), get_comma(last)); 1655 unlock_user(tv, tv_addr, 0); 1656 } else 1657 qemu_log("NULL%s", get_comma(last)); 1658 } 1659 1660 static void 1661 print_timespec(abi_ulong ts_addr, int last) 1662 { 1663 if (ts_addr) { 1664 struct target_timespec *ts; 1665 1666 ts = lock_user(VERIFY_READ, ts_addr, sizeof(*ts), 1); 1667 if (!ts) { 1668 print_pointer(ts_addr, last); 1669 return; 1670 } 1671 qemu_log("{tv_sec = " TARGET_ABI_FMT_ld 1672 ",tv_nsec = " TARGET_ABI_FMT_ld "}%s", 1673 tswapal(ts->tv_sec), tswapal(ts->tv_nsec), get_comma(last)); 1674 unlock_user(ts, ts_addr, 0); 1675 } else { 1676 qemu_log("NULL%s", get_comma(last)); 1677 } 1678 } 1679 1680 static void 1681 print_timespec64(abi_ulong ts_addr, int last) 1682 { 1683 if (ts_addr) { 1684 struct target__kernel_timespec *ts; 1685 1686 ts = lock_user(VERIFY_READ, ts_addr, sizeof(*ts), 1); 1687 if (!ts) { 1688 print_pointer(ts_addr, last); 1689 return; 1690 } 1691 qemu_log("{tv_sec = %lld" 1692 ",tv_nsec = %lld}%s", 1693 (long long)tswap64(ts->tv_sec), (long long)tswap64(ts->tv_nsec), 1694 get_comma(last)); 1695 unlock_user(ts, ts_addr, 0); 1696 } else { 1697 qemu_log("NULL%s", get_comma(last)); 1698 } 1699 } 1700 1701 static void 1702 print_timezone(abi_ulong tz_addr, int last) 1703 { 1704 if (tz_addr) { 1705 struct target_timezone *tz; 1706 1707 tz = lock_user(VERIFY_READ, tz_addr, sizeof(*tz), 1); 1708 if (!tz) { 1709 print_pointer(tz_addr, last); 1710 return; 1711 } 1712 qemu_log("{%d,%d}%s", tswap32(tz->tz_minuteswest), 1713 tswap32(tz->tz_dsttime), get_comma(last)); 1714 unlock_user(tz, tz_addr, 0); 1715 } else { 1716 qemu_log("NULL%s", get_comma(last)); 1717 } 1718 } 1719 1720 static void 1721 print_itimerval(abi_ulong it_addr, int last) 1722 { 1723 if (it_addr) { 1724 qemu_log("{it_interval="); 1725 print_timeval(it_addr + 1726 offsetof(struct target_itimerval, it_interval), 0); 1727 qemu_log("it_value="); 1728 print_timeval(it_addr + 1729 offsetof(struct target_itimerval, it_value), 0); 1730 qemu_log("}%s", get_comma(last)); 1731 } else { 1732 qemu_log("NULL%s", get_comma(last)); 1733 } 1734 } 1735 1736 void 1737 print_termios(void *arg) 1738 { 1739 const struct target_termios *target = arg; 1740 1741 target_tcflag_t iflags = tswap32(target->c_iflag); 1742 target_tcflag_t oflags = tswap32(target->c_oflag); 1743 target_tcflag_t cflags = tswap32(target->c_cflag); 1744 target_tcflag_t lflags = tswap32(target->c_lflag); 1745 1746 qemu_log("{"); 1747 1748 qemu_log("c_iflag = "); 1749 print_flags(termios_iflags, iflags, 0); 1750 1751 qemu_log("c_oflag = "); 1752 target_tcflag_t oflags_clean = oflags & ~(TARGET_NLDLY | TARGET_CRDLY | 1753 TARGET_TABDLY | TARGET_BSDLY | 1754 TARGET_VTDLY | TARGET_FFDLY); 1755 print_flags(termios_oflags, oflags_clean, 0); 1756 if (oflags & TARGET_NLDLY) { 1757 print_enums(termios_oflags_NLDLY, oflags & TARGET_NLDLY, 0); 1758 } 1759 if (oflags & TARGET_CRDLY) { 1760 print_enums(termios_oflags_CRDLY, oflags & TARGET_CRDLY, 0); 1761 } 1762 if (oflags & TARGET_TABDLY) { 1763 print_enums(termios_oflags_TABDLY, oflags & TARGET_TABDLY, 0); 1764 } 1765 if (oflags & TARGET_BSDLY) { 1766 print_enums(termios_oflags_BSDLY, oflags & TARGET_BSDLY, 0); 1767 } 1768 if (oflags & TARGET_VTDLY) { 1769 print_enums(termios_oflags_VTDLY, oflags & TARGET_VTDLY, 0); 1770 } 1771 if (oflags & TARGET_FFDLY) { 1772 print_enums(termios_oflags_FFDLY, oflags & TARGET_FFDLY, 0); 1773 } 1774 1775 qemu_log("c_cflag = "); 1776 if (cflags & TARGET_CBAUD) { 1777 print_enums(termios_cflags_CBAUD, cflags & TARGET_CBAUD, 0); 1778 } 1779 if (cflags & TARGET_CSIZE) { 1780 print_enums(termios_cflags_CSIZE, cflags & TARGET_CSIZE, 0); 1781 } 1782 target_tcflag_t cflags_clean = cflags & ~(TARGET_CBAUD | TARGET_CSIZE); 1783 print_flags(termios_cflags, cflags_clean, 0); 1784 1785 qemu_log("c_lflag = "); 1786 print_flags(termios_lflags, lflags, 0); 1787 1788 qemu_log("c_cc = "); 1789 qemu_log("\"%s\",", target->c_cc); 1790 1791 qemu_log("c_line = "); 1792 print_raw_param("\'%c\'", target->c_line, 1); 1793 1794 qemu_log("}"); 1795 } 1796 1797 #undef UNUSED 1798 1799 #ifdef TARGET_NR_accept 1800 static void 1801 print_accept(CPUArchState *cpu_env, const struct syscallname *name, 1802 abi_long arg0, abi_long arg1, abi_long arg2, 1803 abi_long arg3, abi_long arg4, abi_long arg5) 1804 { 1805 print_syscall_prologue(name); 1806 print_raw_param("%d", arg0, 0); 1807 print_pointer(arg1, 0); 1808 print_number(arg2, 1); 1809 print_syscall_epilogue(name); 1810 } 1811 #endif 1812 1813 #ifdef TARGET_NR_access 1814 static void 1815 print_access(CPUArchState *cpu_env, const struct syscallname *name, 1816 abi_long arg0, abi_long arg1, abi_long arg2, 1817 abi_long arg3, abi_long arg4, abi_long arg5) 1818 { 1819 print_syscall_prologue(name); 1820 print_string(arg0, 0); 1821 print_flags(access_flags, arg1, 1); 1822 print_syscall_epilogue(name); 1823 } 1824 #endif 1825 1826 #ifdef TARGET_NR_acct 1827 static void 1828 print_acct(CPUArchState *cpu_env, const struct syscallname *name, 1829 abi_long arg0, abi_long arg1, abi_long arg2, 1830 abi_long arg3, abi_long arg4, abi_long arg5) 1831 { 1832 print_syscall_prologue(name); 1833 print_string(arg0, 1); 1834 print_syscall_epilogue(name); 1835 } 1836 #endif 1837 1838 #ifdef TARGET_NR_brk 1839 static void 1840 print_brk(CPUArchState *cpu_env, const struct syscallname *name, 1841 abi_long arg0, abi_long arg1, abi_long arg2, 1842 abi_long arg3, abi_long arg4, abi_long arg5) 1843 { 1844 print_syscall_prologue(name); 1845 print_pointer(arg0, 1); 1846 print_syscall_epilogue(name); 1847 } 1848 #endif 1849 1850 #ifdef TARGET_NR_chdir 1851 static void 1852 print_chdir(CPUArchState *cpu_env, const struct syscallname *name, 1853 abi_long arg0, abi_long arg1, abi_long arg2, 1854 abi_long arg3, abi_long arg4, abi_long arg5) 1855 { 1856 print_syscall_prologue(name); 1857 print_string(arg0, 1); 1858 print_syscall_epilogue(name); 1859 } 1860 #endif 1861 1862 #ifdef TARGET_NR_chroot 1863 static void 1864 print_chroot(CPUArchState *cpu_env, const struct syscallname *name, 1865 abi_long arg0, abi_long arg1, abi_long arg2, 1866 abi_long arg3, abi_long arg4, abi_long arg5) 1867 { 1868 print_syscall_prologue(name); 1869 print_string(arg0, 1); 1870 print_syscall_epilogue(name); 1871 } 1872 #endif 1873 1874 #ifdef TARGET_NR_chmod 1875 static void 1876 print_chmod(CPUArchState *cpu_env, const struct syscallname *name, 1877 abi_long arg0, abi_long arg1, abi_long arg2, 1878 abi_long arg3, abi_long arg4, abi_long arg5) 1879 { 1880 print_syscall_prologue(name); 1881 print_string(arg0, 0); 1882 print_file_mode(arg1, 1); 1883 print_syscall_epilogue(name); 1884 } 1885 #endif 1886 1887 #if defined(TARGET_NR_chown) || defined(TARGET_NR_lchown) 1888 static void 1889 print_chown(CPUArchState *cpu_env, const struct syscallname *name, 1890 abi_long arg0, abi_long arg1, abi_long arg2, 1891 abi_long arg3, abi_long arg4, abi_long arg5) 1892 { 1893 print_syscall_prologue(name); 1894 print_string(arg0, 0); 1895 print_raw_param("%d", arg1, 0); 1896 print_raw_param("%d", arg2, 1); 1897 print_syscall_epilogue(name); 1898 } 1899 #define print_lchown print_chown 1900 #endif 1901 1902 #ifdef TARGET_NR_clock_adjtime 1903 static void 1904 print_clock_adjtime(CPUArchState *cpu_env, const struct syscallname *name, 1905 abi_long arg0, abi_long arg1, abi_long arg2, 1906 abi_long arg3, abi_long arg4, abi_long arg5) 1907 { 1908 print_syscall_prologue(name); 1909 print_enums(clockids, arg0, 0); 1910 print_pointer(arg1, 1); 1911 print_syscall_epilogue(name); 1912 } 1913 #endif 1914 1915 #ifdef TARGET_NR_clone 1916 static void do_print_clone(unsigned int flags, abi_ulong newsp, 1917 abi_ulong parent_tidptr, target_ulong newtls, 1918 abi_ulong child_tidptr) 1919 { 1920 print_flags(clone_flags, flags, 0); 1921 print_raw_param("child_stack=0x" TARGET_ABI_FMT_lx, newsp, 0); 1922 print_raw_param("parent_tidptr=0x" TARGET_ABI_FMT_lx, parent_tidptr, 0); 1923 print_raw_param("tls=0x" TARGET_ABI_FMT_lx, newtls, 0); 1924 print_raw_param("child_tidptr=0x" TARGET_ABI_FMT_lx, child_tidptr, 1); 1925 } 1926 1927 static void 1928 print_clone(CPUArchState *cpu_env, const struct syscallname *name, 1929 abi_long arg1, abi_long arg2, abi_long arg3, 1930 abi_long arg4, abi_long arg5, abi_long arg6) 1931 { 1932 print_syscall_prologue(name); 1933 #if defined(TARGET_MICROBLAZE) 1934 do_print_clone(arg1, arg2, arg4, arg6, arg5); 1935 #elif defined(TARGET_CLONE_BACKWARDS) 1936 do_print_clone(arg1, arg2, arg3, arg4, arg5); 1937 #elif defined(TARGET_CLONE_BACKWARDS2) 1938 do_print_clone(arg2, arg1, arg3, arg5, arg4); 1939 #else 1940 do_print_clone(arg1, arg2, arg3, arg5, arg4); 1941 #endif 1942 print_syscall_epilogue(name); 1943 } 1944 #endif 1945 1946 #ifdef TARGET_NR_creat 1947 static void 1948 print_creat(CPUArchState *cpu_env, const struct syscallname *name, 1949 abi_long arg0, abi_long arg1, abi_long arg2, 1950 abi_long arg3, abi_long arg4, abi_long arg5) 1951 { 1952 print_syscall_prologue(name); 1953 print_string(arg0, 0); 1954 print_file_mode(arg1, 1); 1955 print_syscall_epilogue(name); 1956 } 1957 #endif 1958 1959 #ifdef TARGET_NR_execv 1960 static void 1961 print_execv(CPUArchState *cpu_env, const struct syscallname *name, 1962 abi_long arg0, abi_long arg1, abi_long arg2, 1963 abi_long arg3, abi_long arg4, abi_long arg5) 1964 { 1965 print_syscall_prologue(name); 1966 print_string(arg0, 0); 1967 print_raw_param("0x" TARGET_ABI_FMT_lx, arg1, 1); 1968 print_syscall_epilogue(name); 1969 } 1970 #endif 1971 1972 #if defined(TARGET_NR_faccessat) || defined(TARGET_NR_faccessat2) 1973 static void 1974 print_faccessat(CPUArchState *cpu_env, const struct syscallname *name, 1975 abi_long arg0, abi_long arg1, abi_long arg2, 1976 abi_long arg3, abi_long arg4, abi_long arg5) 1977 { 1978 print_syscall_prologue(name); 1979 print_at_dirfd(arg0, 0); 1980 print_string(arg1, 0); 1981 print_flags(access_flags, arg2, 0); 1982 print_flags(at_file_flags, arg3, 1); 1983 print_syscall_epilogue(name); 1984 } 1985 #endif 1986 1987 #ifdef TARGET_NR_fallocate 1988 static void 1989 print_fallocate(CPUArchState *cpu_env, const struct syscallname *name, 1990 abi_long arg0, abi_long arg1, abi_long arg2, 1991 abi_long arg3, abi_long arg4, abi_long arg5) 1992 { 1993 print_syscall_prologue(name); 1994 print_raw_param("%d", arg0, 0); 1995 print_flags(falloc_flags, arg1, 0); 1996 #if TARGET_ABI_BITS == 32 1997 print_raw_param("%" PRIu64, target_offset64(arg2, arg3), 0); 1998 print_raw_param("%" PRIu64, target_offset64(arg4, arg5), 1); 1999 #else 2000 print_raw_param(TARGET_ABI_FMT_ld, arg2, 0); 2001 print_raw_param(TARGET_ABI_FMT_ld, arg3, 1); 2002 #endif 2003 print_syscall_epilogue(name); 2004 } 2005 #endif 2006 2007 #ifdef TARGET_NR_fchmodat 2008 static void 2009 print_fchmodat(CPUArchState *cpu_env, const struct syscallname *name, 2010 abi_long arg0, abi_long arg1, abi_long arg2, 2011 abi_long arg3, abi_long arg4, abi_long arg5) 2012 { 2013 print_syscall_prologue(name); 2014 print_at_dirfd(arg0, 0); 2015 print_string(arg1, 0); 2016 print_file_mode(arg2, 0); 2017 print_flags(at_file_flags, arg3, 1); 2018 print_syscall_epilogue(name); 2019 } 2020 #endif 2021 2022 #ifdef TARGET_NR_fchownat 2023 static void 2024 print_fchownat(CPUArchState *cpu_env, const struct syscallname *name, 2025 abi_long arg0, abi_long arg1, abi_long arg2, 2026 abi_long arg3, abi_long arg4, abi_long arg5) 2027 { 2028 print_syscall_prologue(name); 2029 print_at_dirfd(arg0, 0); 2030 print_string(arg1, 0); 2031 print_raw_param("%d", arg2, 0); 2032 print_raw_param("%d", arg3, 0); 2033 print_flags(at_file_flags, arg4, 1); 2034 print_syscall_epilogue(name); 2035 } 2036 #endif 2037 2038 #if defined(TARGET_NR_fcntl) || defined(TARGET_NR_fcntl64) 2039 static void 2040 print_fcntl(CPUArchState *cpu_env, const struct syscallname *name, 2041 abi_long arg0, abi_long arg1, abi_long arg2, 2042 abi_long arg3, abi_long arg4, abi_long arg5) 2043 { 2044 print_syscall_prologue(name); 2045 print_raw_param("%d", arg0, 0); 2046 switch(arg1) { 2047 case TARGET_F_DUPFD: 2048 qemu_log("F_DUPFD,"); 2049 print_raw_param(TARGET_ABI_FMT_ld, arg2, 1); 2050 break; 2051 case TARGET_F_GETFD: 2052 qemu_log("F_GETFD"); 2053 break; 2054 case TARGET_F_SETFD: 2055 qemu_log("F_SETFD,"); 2056 print_raw_param(TARGET_ABI_FMT_ld, arg2, 1); 2057 break; 2058 case TARGET_F_GETFL: 2059 qemu_log("F_GETFL"); 2060 break; 2061 case TARGET_F_SETFL: 2062 qemu_log("F_SETFL,"); 2063 print_open_flags(arg2, 1); 2064 break; 2065 case TARGET_F_GETLK: 2066 qemu_log("F_GETLK,"); 2067 print_pointer(arg2, 1); 2068 break; 2069 case TARGET_F_SETLK: 2070 qemu_log("F_SETLK,"); 2071 print_pointer(arg2, 1); 2072 break; 2073 case TARGET_F_SETLKW: 2074 qemu_log("F_SETLKW,"); 2075 print_pointer(arg2, 1); 2076 break; 2077 case TARGET_F_GETOWN: 2078 qemu_log("F_GETOWN"); 2079 break; 2080 case TARGET_F_SETOWN: 2081 qemu_log("F_SETOWN,"); 2082 print_raw_param(TARGET_ABI_FMT_ld, arg2, 0); 2083 break; 2084 case TARGET_F_GETSIG: 2085 qemu_log("F_GETSIG"); 2086 break; 2087 case TARGET_F_SETSIG: 2088 qemu_log("F_SETSIG,"); 2089 print_raw_param(TARGET_ABI_FMT_ld, arg2, 0); 2090 break; 2091 #if TARGET_ABI_BITS == 32 2092 case TARGET_F_GETLK64: 2093 qemu_log("F_GETLK64,"); 2094 print_pointer(arg2, 1); 2095 break; 2096 case TARGET_F_SETLK64: 2097 qemu_log("F_SETLK64,"); 2098 print_pointer(arg2, 1); 2099 break; 2100 case TARGET_F_SETLKW64: 2101 qemu_log("F_SETLKW64,"); 2102 print_pointer(arg2, 1); 2103 break; 2104 #endif 2105 case TARGET_F_OFD_GETLK: 2106 qemu_log("F_OFD_GETLK,"); 2107 print_pointer(arg2, 1); 2108 break; 2109 case TARGET_F_OFD_SETLK: 2110 qemu_log("F_OFD_SETLK,"); 2111 print_pointer(arg2, 1); 2112 break; 2113 case TARGET_F_OFD_SETLKW: 2114 qemu_log("F_OFD_SETLKW,"); 2115 print_pointer(arg2, 1); 2116 break; 2117 case TARGET_F_SETLEASE: 2118 qemu_log("F_SETLEASE,"); 2119 print_raw_param(TARGET_ABI_FMT_ld, arg2, 1); 2120 break; 2121 case TARGET_F_GETLEASE: 2122 qemu_log("F_GETLEASE"); 2123 break; 2124 #ifdef F_DUPFD_CLOEXEC 2125 case TARGET_F_DUPFD_CLOEXEC: 2126 qemu_log("F_DUPFD_CLOEXEC,"); 2127 print_raw_param(TARGET_ABI_FMT_ld, arg2, 1); 2128 break; 2129 #endif 2130 case TARGET_F_NOTIFY: 2131 qemu_log("F_NOTIFY,"); 2132 print_raw_param(TARGET_ABI_FMT_ld, arg2, 1); 2133 break; 2134 #ifdef F_GETOWN_EX 2135 case TARGET_F_GETOWN_EX: 2136 qemu_log("F_GETOWN_EX,"); 2137 print_pointer(arg2, 1); 2138 break; 2139 #endif 2140 #ifdef F_SETOWN_EX 2141 case TARGET_F_SETOWN_EX: 2142 qemu_log("F_SETOWN_EX,"); 2143 print_pointer(arg2, 1); 2144 break; 2145 #endif 2146 #ifdef F_SETPIPE_SZ 2147 case TARGET_F_SETPIPE_SZ: 2148 qemu_log("F_SETPIPE_SZ,"); 2149 print_raw_param(TARGET_ABI_FMT_ld, arg2, 1); 2150 break; 2151 case TARGET_F_GETPIPE_SZ: 2152 qemu_log("F_GETPIPE_SZ"); 2153 break; 2154 #endif 2155 #ifdef F_ADD_SEALS 2156 case TARGET_F_ADD_SEALS: 2157 qemu_log("F_ADD_SEALS,"); 2158 print_raw_param("0x"TARGET_ABI_FMT_lx, arg2, 1); 2159 break; 2160 case TARGET_F_GET_SEALS: 2161 qemu_log("F_GET_SEALS"); 2162 break; 2163 #endif 2164 default: 2165 print_raw_param(TARGET_ABI_FMT_ld, arg1, 0); 2166 print_pointer(arg2, 1); 2167 break; 2168 } 2169 print_syscall_epilogue(name); 2170 } 2171 #define print_fcntl64 print_fcntl 2172 #endif 2173 2174 #ifdef TARGET_NR_fgetxattr 2175 static void 2176 print_fgetxattr(CPUArchState *cpu_env, const struct syscallname *name, 2177 abi_long arg0, abi_long arg1, abi_long arg2, 2178 abi_long arg3, abi_long arg4, abi_long arg5) 2179 { 2180 print_syscall_prologue(name); 2181 print_raw_param("%d", arg0, 0); 2182 print_string(arg1, 0); 2183 print_pointer(arg2, 0); 2184 print_raw_param(TARGET_FMT_lu, arg3, 1); 2185 print_syscall_epilogue(name); 2186 } 2187 #endif 2188 2189 #ifdef TARGET_NR_flistxattr 2190 static void 2191 print_flistxattr(CPUArchState *cpu_env, const struct syscallname *name, 2192 abi_long arg0, abi_long arg1, abi_long arg2, 2193 abi_long arg3, abi_long arg4, abi_long arg5) 2194 { 2195 print_syscall_prologue(name); 2196 print_raw_param("%d", arg0, 0); 2197 print_pointer(arg1, 0); 2198 print_raw_param(TARGET_FMT_lu, arg2, 1); 2199 print_syscall_epilogue(name); 2200 } 2201 #endif 2202 2203 #if defined(TARGET_NR_getxattr) || defined(TARGET_NR_lgetxattr) 2204 static void 2205 print_getxattr(CPUArchState *cpu_env, const struct syscallname *name, 2206 abi_long arg0, abi_long arg1, abi_long arg2, 2207 abi_long arg3, abi_long arg4, abi_long arg5) 2208 { 2209 print_syscall_prologue(name); 2210 print_string(arg0, 0); 2211 print_string(arg1, 0); 2212 print_pointer(arg2, 0); 2213 print_raw_param(TARGET_FMT_lu, arg3, 1); 2214 print_syscall_epilogue(name); 2215 } 2216 #define print_lgetxattr print_getxattr 2217 #endif 2218 2219 #if defined(TARGET_NR_listxattr) || defined(TARGET_NR_llistxattr) 2220 static void 2221 print_listxattr(CPUArchState *cpu_env, const struct syscallname *name, 2222 abi_long arg0, abi_long arg1, abi_long arg2, 2223 abi_long arg3, abi_long arg4, abi_long arg5) 2224 { 2225 print_syscall_prologue(name); 2226 print_string(arg0, 0); 2227 print_pointer(arg1, 0); 2228 print_raw_param(TARGET_FMT_lu, arg2, 1); 2229 print_syscall_epilogue(name); 2230 } 2231 #define print_llistxattr print_listxattr 2232 #endif 2233 2234 #if defined(TARGET_NR_fremovexattr) 2235 static void 2236 print_fremovexattr(CPUArchState *cpu_env, const struct syscallname *name, 2237 abi_long arg0, abi_long arg1, abi_long arg2, 2238 abi_long arg3, abi_long arg4, abi_long arg5) 2239 { 2240 print_syscall_prologue(name); 2241 print_raw_param("%d", arg0, 0); 2242 print_string(arg1, 1); 2243 print_syscall_epilogue(name); 2244 } 2245 #endif 2246 2247 #if defined(TARGET_NR_removexattr) || defined(TARGET_NR_lremovexattr) 2248 static void 2249 print_removexattr(CPUArchState *cpu_env, const struct syscallname *name, 2250 abi_long arg0, abi_long arg1, abi_long arg2, 2251 abi_long arg3, abi_long arg4, abi_long arg5) 2252 { 2253 print_syscall_prologue(name); 2254 print_string(arg0, 0); 2255 print_string(arg1, 1); 2256 print_syscall_epilogue(name); 2257 } 2258 #define print_lremovexattr print_removexattr 2259 #endif 2260 2261 #ifdef TARGET_NR_futimesat 2262 static void 2263 print_futimesat(CPUArchState *cpu_env, const struct syscallname *name, 2264 abi_long arg0, abi_long arg1, abi_long arg2, 2265 abi_long arg3, abi_long arg4, abi_long arg5) 2266 { 2267 print_syscall_prologue(name); 2268 print_at_dirfd(arg0, 0); 2269 print_string(arg1, 0); 2270 print_timeval(arg2, 0); 2271 print_timeval(arg2 + sizeof (struct target_timeval), 1); 2272 print_syscall_epilogue(name); 2273 } 2274 #endif 2275 2276 #ifdef TARGET_NR_gettimeofday 2277 static void 2278 print_gettimeofday(CPUArchState *cpu_env, const struct syscallname *name, 2279 abi_long arg0, abi_long arg1, abi_long arg2, 2280 abi_long arg3, abi_long arg4, abi_long arg5) 2281 { 2282 print_syscall_prologue(name); 2283 print_pointer(arg0, 0); 2284 print_pointer(arg1, 1); 2285 print_syscall_epilogue(name); 2286 } 2287 #endif 2288 2289 #ifdef TARGET_NR_settimeofday 2290 static void 2291 print_settimeofday(CPUArchState *cpu_env, const struct syscallname *name, 2292 abi_long arg0, abi_long arg1, abi_long arg2, 2293 abi_long arg3, abi_long arg4, abi_long arg5) 2294 { 2295 print_syscall_prologue(name); 2296 print_timeval(arg0, 0); 2297 print_timezone(arg1, 1); 2298 print_syscall_epilogue(name); 2299 } 2300 #endif 2301 2302 #if defined(TARGET_NR_clock_gettime) || defined(TARGET_NR_clock_getres) 2303 static void 2304 print_clock_gettime(CPUArchState *cpu_env, const struct syscallname *name, 2305 abi_long arg0, abi_long arg1, abi_long arg2, 2306 abi_long arg3, abi_long arg4, abi_long arg5) 2307 { 2308 print_syscall_prologue(name); 2309 print_enums(clockids, arg0, 0); 2310 print_pointer(arg1, 1); 2311 print_syscall_epilogue(name); 2312 } 2313 #define print_clock_getres print_clock_gettime 2314 #endif 2315 2316 #if defined(TARGET_NR_clock_gettime64) 2317 static void 2318 print_clock_gettime64(CPUArchState *cpu_env, const struct syscallname *name, 2319 abi_long arg0, abi_long arg1, abi_long arg2, 2320 abi_long arg3, abi_long arg4, abi_long arg5) 2321 { 2322 print_syscall_prologue(name); 2323 print_enums(clockids, arg0, 0); 2324 print_pointer(arg1, 1); 2325 print_syscall_epilogue(name); 2326 } 2327 #endif 2328 2329 #ifdef TARGET_NR_clock_settime 2330 static void 2331 print_clock_settime(CPUArchState *cpu_env, const struct syscallname *name, 2332 abi_long arg0, abi_long arg1, abi_long arg2, 2333 abi_long arg3, abi_long arg4, abi_long arg5) 2334 { 2335 print_syscall_prologue(name); 2336 print_enums(clockids, arg0, 0); 2337 print_timespec(arg1, 1); 2338 print_syscall_epilogue(name); 2339 } 2340 #endif 2341 2342 #ifdef TARGET_NR_getitimer 2343 static void 2344 print_getitimer(CPUArchState *cpu_env, const struct syscallname *name, 2345 abi_long arg0, abi_long arg1, abi_long arg2, 2346 abi_long arg3, abi_long arg4, abi_long arg5) 2347 { 2348 print_syscall_prologue(name); 2349 print_enums(itimer_types, arg0, 0); 2350 print_pointer(arg1, 1); 2351 print_syscall_epilogue(name); 2352 } 2353 #endif 2354 2355 #ifdef TARGET_NR_setitimer 2356 static void 2357 print_setitimer(CPUArchState *cpu_env, const struct syscallname *name, 2358 abi_long arg0, abi_long arg1, abi_long arg2, 2359 abi_long arg3, abi_long arg4, abi_long arg5) 2360 { 2361 print_syscall_prologue(name); 2362 print_enums(itimer_types, arg0, 0); 2363 print_itimerval(arg1, 0); 2364 print_pointer(arg2, 1); 2365 print_syscall_epilogue(name); 2366 } 2367 #endif 2368 2369 #ifdef TARGET_NR_link 2370 static void 2371 print_link(CPUArchState *cpu_env, const struct syscallname *name, 2372 abi_long arg0, abi_long arg1, abi_long arg2, 2373 abi_long arg3, abi_long arg4, abi_long arg5) 2374 { 2375 print_syscall_prologue(name); 2376 print_string(arg0, 0); 2377 print_string(arg1, 1); 2378 print_syscall_epilogue(name); 2379 } 2380 #endif 2381 2382 #ifdef TARGET_NR_linkat 2383 static void 2384 print_linkat(CPUArchState *cpu_env, const struct syscallname *name, 2385 abi_long arg0, abi_long arg1, abi_long arg2, 2386 abi_long arg3, abi_long arg4, abi_long arg5) 2387 { 2388 print_syscall_prologue(name); 2389 print_at_dirfd(arg0, 0); 2390 print_string(arg1, 0); 2391 print_at_dirfd(arg2, 0); 2392 print_string(arg3, 0); 2393 print_flags(at_file_flags, arg4, 1); 2394 print_syscall_epilogue(name); 2395 } 2396 #endif 2397 2398 #if defined(TARGET_NR__llseek) || defined(TARGET_NR_llseek) 2399 static void 2400 print__llseek(CPUArchState *cpu_env, const struct syscallname *name, 2401 abi_long arg0, abi_long arg1, abi_long arg2, 2402 abi_long arg3, abi_long arg4, abi_long arg5) 2403 { 2404 const char *whence = "UNKNOWN"; 2405 print_syscall_prologue(name); 2406 print_raw_param("%d", arg0, 0); 2407 print_raw_param("%ld", arg1, 0); 2408 print_raw_param("%ld", arg2, 0); 2409 print_pointer(arg3, 0); 2410 switch(arg4) { 2411 case SEEK_SET: whence = "SEEK_SET"; break; 2412 case SEEK_CUR: whence = "SEEK_CUR"; break; 2413 case SEEK_END: whence = "SEEK_END"; break; 2414 } 2415 qemu_log("%s", whence); 2416 print_syscall_epilogue(name); 2417 } 2418 #define print_llseek print__llseek 2419 #endif 2420 2421 #ifdef TARGET_NR_lseek 2422 static void 2423 print_lseek(CPUArchState *cpu_env, const struct syscallname *name, 2424 abi_long arg0, abi_long arg1, abi_long arg2, 2425 abi_long arg3, abi_long arg4, abi_long arg5) 2426 { 2427 print_syscall_prologue(name); 2428 print_raw_param("%d", arg0, 0); 2429 print_raw_param(TARGET_ABI_FMT_ld, arg1, 0); 2430 switch (arg2) { 2431 case SEEK_SET: 2432 qemu_log("SEEK_SET"); break; 2433 case SEEK_CUR: 2434 qemu_log("SEEK_CUR"); break; 2435 case SEEK_END: 2436 qemu_log("SEEK_END"); break; 2437 #ifdef SEEK_DATA 2438 case SEEK_DATA: 2439 qemu_log("SEEK_DATA"); break; 2440 #endif 2441 #ifdef SEEK_HOLE 2442 case SEEK_HOLE: 2443 qemu_log("SEEK_HOLE"); break; 2444 #endif 2445 default: 2446 print_raw_param("%#x", arg2, 1); 2447 } 2448 print_syscall_epilogue(name); 2449 } 2450 #endif 2451 2452 #ifdef TARGET_NR_truncate 2453 static void 2454 print_truncate(CPUArchState *cpu_env, const struct syscallname *name, 2455 abi_long arg0, abi_long arg1, abi_long arg2, 2456 abi_long arg3, abi_long arg4, abi_long arg5) 2457 { 2458 print_syscall_prologue(name); 2459 print_string(arg0, 0); 2460 print_raw_param(TARGET_ABI_FMT_ld, arg1, 1); 2461 print_syscall_epilogue(name); 2462 } 2463 #endif 2464 2465 #ifdef TARGET_NR_truncate64 2466 static void 2467 print_truncate64(CPUArchState *cpu_env, const struct syscallname *name, 2468 abi_long arg0, abi_long arg1, abi_long arg2, 2469 abi_long arg3, abi_long arg4, abi_long arg5) 2470 { 2471 print_syscall_prologue(name); 2472 print_string(arg0, 0); 2473 if (regpairs_aligned(cpu_env, TARGET_NR_truncate64)) { 2474 arg1 = arg2; 2475 arg2 = arg3; 2476 } 2477 print_raw_param("%" PRIu64, target_offset64(arg1, arg2), 1); 2478 print_syscall_epilogue(name); 2479 } 2480 #endif 2481 2482 #ifdef TARGET_NR_ftruncate64 2483 static void 2484 print_ftruncate64(CPUArchState *cpu_env, const struct syscallname *name, 2485 abi_long arg0, abi_long arg1, abi_long arg2, 2486 abi_long arg3, abi_long arg4, abi_long arg5) 2487 { 2488 print_syscall_prologue(name); 2489 print_raw_param("%d", arg0, 0); 2490 if (regpairs_aligned(cpu_env, TARGET_NR_ftruncate64)) { 2491 arg1 = arg2; 2492 arg2 = arg3; 2493 } 2494 print_raw_param("%" PRIu64, target_offset64(arg1, arg2), 1); 2495 print_syscall_epilogue(name); 2496 } 2497 #endif 2498 2499 #ifdef TARGET_NR_mlockall 2500 static void 2501 print_mlockall(CPUArchState *cpu_env, const struct syscallname *name, 2502 abi_long arg0, abi_long arg1, abi_long arg2, 2503 abi_long arg3, abi_long arg4, abi_long arg5) 2504 { 2505 print_syscall_prologue(name); 2506 print_flags(mlockall_flags, arg0, 1); 2507 print_syscall_epilogue(name); 2508 } 2509 #endif 2510 2511 #if defined(TARGET_NR_socket) 2512 static void 2513 print_socket(CPUArchState *cpu_env, const struct syscallname *name, 2514 abi_long arg0, abi_long arg1, abi_long arg2, 2515 abi_long arg3, abi_long arg4, abi_long arg5) 2516 { 2517 abi_ulong domain = arg0, type = arg1, protocol = arg2; 2518 2519 print_syscall_prologue(name); 2520 print_socket_domain(domain); 2521 qemu_log(","); 2522 print_socket_type(type); 2523 qemu_log(","); 2524 if (domain == AF_PACKET || 2525 (domain == AF_INET && type == TARGET_SOCK_PACKET)) { 2526 protocol = tswap16(protocol); 2527 } 2528 print_socket_protocol(domain, type, protocol); 2529 print_syscall_epilogue(name); 2530 } 2531 2532 #endif 2533 2534 #if defined(TARGET_NR_socketcall) || defined(TARGET_NR_bind) 2535 2536 static void print_sockfd(abi_long sockfd, int last) 2537 { 2538 print_raw_param(TARGET_ABI_FMT_ld, sockfd, last); 2539 } 2540 2541 #endif 2542 2543 #if defined(TARGET_NR_socketcall) 2544 2545 #define get_user_ualx(x, gaddr, idx) \ 2546 get_user_ual(x, (gaddr) + (idx) * sizeof(abi_long)) 2547 2548 static void do_print_socket(const char *name, abi_long arg1) 2549 { 2550 abi_ulong domain, type, protocol; 2551 2552 get_user_ualx(domain, arg1, 0); 2553 get_user_ualx(type, arg1, 1); 2554 get_user_ualx(protocol, arg1, 2); 2555 qemu_log("%s(", name); 2556 print_socket_domain(domain); 2557 qemu_log(","); 2558 print_socket_type(type); 2559 qemu_log(","); 2560 if (domain == AF_PACKET || 2561 (domain == AF_INET && type == TARGET_SOCK_PACKET)) { 2562 protocol = tswap16(protocol); 2563 } 2564 print_socket_protocol(domain, type, protocol); 2565 qemu_log(")"); 2566 } 2567 2568 static void do_print_sockaddr(const char *name, abi_long arg1) 2569 { 2570 abi_ulong sockfd, addr, addrlen; 2571 2572 get_user_ualx(sockfd, arg1, 0); 2573 get_user_ualx(addr, arg1, 1); 2574 get_user_ualx(addrlen, arg1, 2); 2575 2576 qemu_log("%s(", name); 2577 print_sockfd(sockfd, 0); 2578 print_sockaddr(addr, addrlen, 0); 2579 qemu_log(")"); 2580 } 2581 2582 static void do_print_listen(const char *name, abi_long arg1) 2583 { 2584 abi_ulong sockfd, backlog; 2585 2586 get_user_ualx(sockfd, arg1, 0); 2587 get_user_ualx(backlog, arg1, 1); 2588 2589 qemu_log("%s(", name); 2590 print_sockfd(sockfd, 0); 2591 print_raw_param(TARGET_ABI_FMT_ld, backlog, 1); 2592 qemu_log(")"); 2593 } 2594 2595 static void do_print_socketpair(const char *name, abi_long arg1) 2596 { 2597 abi_ulong domain, type, protocol, tab; 2598 2599 get_user_ualx(domain, arg1, 0); 2600 get_user_ualx(type, arg1, 1); 2601 get_user_ualx(protocol, arg1, 2); 2602 get_user_ualx(tab, arg1, 3); 2603 2604 qemu_log("%s(", name); 2605 print_socket_domain(domain); 2606 qemu_log(","); 2607 print_socket_type(type); 2608 qemu_log(","); 2609 print_socket_protocol(domain, type, protocol); 2610 qemu_log(","); 2611 print_raw_param(TARGET_ABI_FMT_lx, tab, 1); 2612 qemu_log(")"); 2613 } 2614 2615 static void do_print_sendrecv(const char *name, abi_long arg1) 2616 { 2617 abi_ulong sockfd, msg, len, flags; 2618 2619 get_user_ualx(sockfd, arg1, 0); 2620 get_user_ualx(msg, arg1, 1); 2621 get_user_ualx(len, arg1, 2); 2622 get_user_ualx(flags, arg1, 3); 2623 2624 qemu_log("%s(", name); 2625 print_sockfd(sockfd, 0); 2626 print_buf(msg, len, 0); 2627 print_raw_param(TARGET_ABI_FMT_ld, len, 0); 2628 print_flags(msg_flags, flags, 1); 2629 qemu_log(")"); 2630 } 2631 2632 static void do_print_msgaddr(const char *name, abi_long arg1) 2633 { 2634 abi_ulong sockfd, msg, len, flags, addr, addrlen; 2635 2636 get_user_ualx(sockfd, arg1, 0); 2637 get_user_ualx(msg, arg1, 1); 2638 get_user_ualx(len, arg1, 2); 2639 get_user_ualx(flags, arg1, 3); 2640 get_user_ualx(addr, arg1, 4); 2641 get_user_ualx(addrlen, arg1, 5); 2642 2643 qemu_log("%s(", name); 2644 print_sockfd(sockfd, 0); 2645 print_buf(msg, len, 0); 2646 print_raw_param(TARGET_ABI_FMT_ld, len, 0); 2647 print_flags(msg_flags, flags, 0); 2648 print_sockaddr(addr, addrlen, 0); 2649 qemu_log(")"); 2650 } 2651 2652 static void do_print_shutdown(const char *name, abi_long arg1) 2653 { 2654 abi_ulong sockfd, how; 2655 2656 get_user_ualx(sockfd, arg1, 0); 2657 get_user_ualx(how, arg1, 1); 2658 2659 qemu_log("shutdown("); 2660 print_sockfd(sockfd, 0); 2661 switch (how) { 2662 case SHUT_RD: 2663 qemu_log("SHUT_RD"); 2664 break; 2665 case SHUT_WR: 2666 qemu_log("SHUT_WR"); 2667 break; 2668 case SHUT_RDWR: 2669 qemu_log("SHUT_RDWR"); 2670 break; 2671 default: 2672 print_raw_param(TARGET_ABI_FMT_ld, how, 1); 2673 break; 2674 } 2675 qemu_log(")"); 2676 } 2677 2678 static void do_print_msg(const char *name, abi_long arg1) 2679 { 2680 abi_ulong sockfd, msg, flags; 2681 2682 get_user_ualx(sockfd, arg1, 0); 2683 get_user_ualx(msg, arg1, 1); 2684 get_user_ualx(flags, arg1, 2); 2685 2686 qemu_log("%s(", name); 2687 print_sockfd(sockfd, 0); 2688 print_pointer(msg, 0); 2689 print_flags(msg_flags, flags, 1); 2690 qemu_log(")"); 2691 } 2692 2693 static void do_print_sockopt(const char *name, abi_long arg1) 2694 { 2695 abi_ulong sockfd, level, optname, optval, optlen; 2696 2697 get_user_ualx(sockfd, arg1, 0); 2698 get_user_ualx(level, arg1, 1); 2699 get_user_ualx(optname, arg1, 2); 2700 get_user_ualx(optval, arg1, 3); 2701 get_user_ualx(optlen, arg1, 4); 2702 2703 qemu_log("%s(", name); 2704 print_sockfd(sockfd, 0); 2705 switch (level) { 2706 case SOL_TCP: 2707 qemu_log("SOL_TCP,"); 2708 print_raw_param(TARGET_ABI_FMT_ld, optname, 0); 2709 print_pointer(optval, 0); 2710 break; 2711 case SOL_UDP: 2712 qemu_log("SOL_UDP,"); 2713 print_raw_param(TARGET_ABI_FMT_ld, optname, 0); 2714 print_pointer(optval, 0); 2715 break; 2716 case SOL_IP: 2717 qemu_log("SOL_IP,"); 2718 print_raw_param(TARGET_ABI_FMT_ld, optname, 0); 2719 print_pointer(optval, 0); 2720 break; 2721 case SOL_RAW: 2722 qemu_log("SOL_RAW,"); 2723 print_raw_param(TARGET_ABI_FMT_ld, optname, 0); 2724 print_pointer(optval, 0); 2725 break; 2726 case TARGET_SOL_SOCKET: 2727 qemu_log("SOL_SOCKET,"); 2728 switch (optname) { 2729 case TARGET_SO_DEBUG: 2730 qemu_log("SO_DEBUG,"); 2731 print_optint: 2732 print_number(optval, 0); 2733 break; 2734 case TARGET_SO_REUSEADDR: 2735 qemu_log("SO_REUSEADDR,"); 2736 goto print_optint; 2737 case TARGET_SO_REUSEPORT: 2738 qemu_log("SO_REUSEPORT,"); 2739 goto print_optint; 2740 case TARGET_SO_TYPE: 2741 qemu_log("SO_TYPE,"); 2742 goto print_optint; 2743 case TARGET_SO_ERROR: 2744 qemu_log("SO_ERROR,"); 2745 goto print_optint; 2746 case TARGET_SO_DONTROUTE: 2747 qemu_log("SO_DONTROUTE,"); 2748 goto print_optint; 2749 case TARGET_SO_BROADCAST: 2750 qemu_log("SO_BROADCAST,"); 2751 goto print_optint; 2752 case TARGET_SO_SNDBUF: 2753 qemu_log("SO_SNDBUF,"); 2754 goto print_optint; 2755 case TARGET_SO_RCVBUF: 2756 qemu_log("SO_RCVBUF,"); 2757 goto print_optint; 2758 case TARGET_SO_KEEPALIVE: 2759 qemu_log("SO_KEEPALIVE,"); 2760 goto print_optint; 2761 case TARGET_SO_OOBINLINE: 2762 qemu_log("SO_OOBINLINE,"); 2763 goto print_optint; 2764 case TARGET_SO_NO_CHECK: 2765 qemu_log("SO_NO_CHECK,"); 2766 goto print_optint; 2767 case TARGET_SO_PRIORITY: 2768 qemu_log("SO_PRIORITY,"); 2769 goto print_optint; 2770 case TARGET_SO_BSDCOMPAT: 2771 qemu_log("SO_BSDCOMPAT,"); 2772 goto print_optint; 2773 case TARGET_SO_PASSCRED: 2774 qemu_log("SO_PASSCRED,"); 2775 goto print_optint; 2776 case TARGET_SO_TIMESTAMP: 2777 qemu_log("SO_TIMESTAMP,"); 2778 goto print_optint; 2779 case TARGET_SO_RCVLOWAT: 2780 qemu_log("SO_RCVLOWAT,"); 2781 goto print_optint; 2782 case TARGET_SO_RCVTIMEO: 2783 qemu_log("SO_RCVTIMEO,"); 2784 print_timeval(optval, 0); 2785 break; 2786 case TARGET_SO_SNDTIMEO: 2787 qemu_log("SO_SNDTIMEO,"); 2788 print_timeval(optval, 0); 2789 break; 2790 case TARGET_SO_ATTACH_FILTER: { 2791 struct target_sock_fprog *fprog; 2792 2793 qemu_log("SO_ATTACH_FILTER,"); 2794 2795 if (lock_user_struct(VERIFY_READ, fprog, optval, 0)) { 2796 struct target_sock_filter *filter; 2797 qemu_log("{"); 2798 if (lock_user_struct(VERIFY_READ, filter, 2799 tswapal(fprog->filter), 0)) { 2800 int i; 2801 for (i = 0; i < tswap16(fprog->len) - 1; i++) { 2802 qemu_log("[%d]{0x%x,%d,%d,0x%x},", 2803 i, tswap16(filter[i].code), 2804 filter[i].jt, filter[i].jf, 2805 tswap32(filter[i].k)); 2806 } 2807 qemu_log("[%d]{0x%x,%d,%d,0x%x}", 2808 i, tswap16(filter[i].code), 2809 filter[i].jt, filter[i].jf, 2810 tswap32(filter[i].k)); 2811 } else { 2812 qemu_log(TARGET_ABI_FMT_lx, tswapal(fprog->filter)); 2813 } 2814 qemu_log(",%d},", tswap16(fprog->len)); 2815 unlock_user(fprog, optval, 0); 2816 } else { 2817 print_pointer(optval, 0); 2818 } 2819 break; 2820 } 2821 default: 2822 print_raw_param(TARGET_ABI_FMT_ld, optname, 0); 2823 print_pointer(optval, 0); 2824 break; 2825 } 2826 break; 2827 case SOL_IPV6: 2828 qemu_log("SOL_IPV6,"); 2829 switch (optname) { 2830 case IPV6_MTU_DISCOVER: 2831 qemu_log("IPV6_MTU_DISCOVER,"); 2832 goto print_optint; 2833 case IPV6_MTU: 2834 qemu_log("IPV6_MTU,"); 2835 goto print_optint; 2836 case IPV6_V6ONLY: 2837 qemu_log("IPV6_V6ONLY,"); 2838 goto print_optint; 2839 case IPV6_RECVPKTINFO: 2840 qemu_log("IPV6_RECVPKTINFO,"); 2841 goto print_optint; 2842 case IPV6_UNICAST_HOPS: 2843 qemu_log("IPV6_UNICAST_HOPS,"); 2844 goto print_optint; 2845 case IPV6_MULTICAST_HOPS: 2846 qemu_log("IPV6_MULTICAST_HOPS,"); 2847 goto print_optint; 2848 case IPV6_MULTICAST_LOOP: 2849 qemu_log("IPV6_MULTICAST_LOOP,"); 2850 goto print_optint; 2851 case IPV6_RECVERR: 2852 qemu_log("IPV6_RECVERR,"); 2853 goto print_optint; 2854 case IPV6_RECVHOPLIMIT: 2855 qemu_log("IPV6_RECVHOPLIMIT,"); 2856 goto print_optint; 2857 case IPV6_2292HOPLIMIT: 2858 qemu_log("IPV6_2292HOPLIMIT,"); 2859 goto print_optint; 2860 case IPV6_CHECKSUM: 2861 qemu_log("IPV6_CHECKSUM,"); 2862 goto print_optint; 2863 case IPV6_ADDRFORM: 2864 qemu_log("IPV6_ADDRFORM,"); 2865 goto print_optint; 2866 case IPV6_2292PKTINFO: 2867 qemu_log("IPV6_2292PKTINFO,"); 2868 goto print_optint; 2869 case IPV6_RECVTCLASS: 2870 qemu_log("IPV6_RECVTCLASS,"); 2871 goto print_optint; 2872 case IPV6_RECVRTHDR: 2873 qemu_log("IPV6_RECVRTHDR,"); 2874 goto print_optint; 2875 case IPV6_2292RTHDR: 2876 qemu_log("IPV6_2292RTHDR,"); 2877 goto print_optint; 2878 case IPV6_RECVHOPOPTS: 2879 qemu_log("IPV6_RECVHOPOPTS,"); 2880 goto print_optint; 2881 case IPV6_2292HOPOPTS: 2882 qemu_log("IPV6_2292HOPOPTS,"); 2883 goto print_optint; 2884 case IPV6_RECVDSTOPTS: 2885 qemu_log("IPV6_RECVDSTOPTS,"); 2886 goto print_optint; 2887 case IPV6_2292DSTOPTS: 2888 qemu_log("IPV6_2292DSTOPTS,"); 2889 goto print_optint; 2890 case IPV6_TCLASS: 2891 qemu_log("IPV6_TCLASS,"); 2892 goto print_optint; 2893 case IPV6_ADDR_PREFERENCES: 2894 qemu_log("IPV6_ADDR_PREFERENCES,"); 2895 goto print_optint; 2896 #ifdef IPV6_RECVPATHMTU 2897 case IPV6_RECVPATHMTU: 2898 qemu_log("IPV6_RECVPATHMTU,"); 2899 goto print_optint; 2900 #endif 2901 #ifdef IPV6_TRANSPARENT 2902 case IPV6_TRANSPARENT: 2903 qemu_log("IPV6_TRANSPARENT,"); 2904 goto print_optint; 2905 #endif 2906 #ifdef IPV6_FREEBIND 2907 case IPV6_FREEBIND: 2908 qemu_log("IPV6_FREEBIND,"); 2909 goto print_optint; 2910 #endif 2911 #ifdef IPV6_RECVORIGDSTADDR 2912 case IPV6_RECVORIGDSTADDR: 2913 qemu_log("IPV6_RECVORIGDSTADDR,"); 2914 goto print_optint; 2915 #endif 2916 case IPV6_PKTINFO: 2917 qemu_log("IPV6_PKTINFO,"); 2918 print_pointer(optval, 0); 2919 break; 2920 case IPV6_ADD_MEMBERSHIP: 2921 qemu_log("IPV6_ADD_MEMBERSHIP,"); 2922 print_pointer(optval, 0); 2923 break; 2924 case IPV6_DROP_MEMBERSHIP: 2925 qemu_log("IPV6_DROP_MEMBERSHIP,"); 2926 print_pointer(optval, 0); 2927 break; 2928 default: 2929 print_raw_param(TARGET_ABI_FMT_ld, optname, 0); 2930 print_pointer(optval, 0); 2931 break; 2932 } 2933 break; 2934 default: 2935 print_raw_param(TARGET_ABI_FMT_ld, level, 0); 2936 print_raw_param(TARGET_ABI_FMT_ld, optname, 0); 2937 print_pointer(optval, 0); 2938 break; 2939 } 2940 print_raw_param(TARGET_ABI_FMT_ld, optlen, 1); 2941 qemu_log(")"); 2942 } 2943 2944 #define PRINT_SOCKOP(name, func) \ 2945 [TARGET_SYS_##name] = { #name, func } 2946 2947 static struct { 2948 const char *name; 2949 void (*print)(const char *, abi_long); 2950 } scall[] = { 2951 PRINT_SOCKOP(SOCKET, do_print_socket), 2952 PRINT_SOCKOP(BIND, do_print_sockaddr), 2953 PRINT_SOCKOP(CONNECT, do_print_sockaddr), 2954 PRINT_SOCKOP(LISTEN, do_print_listen), 2955 PRINT_SOCKOP(ACCEPT, do_print_sockaddr), 2956 PRINT_SOCKOP(GETSOCKNAME, do_print_sockaddr), 2957 PRINT_SOCKOP(GETPEERNAME, do_print_sockaddr), 2958 PRINT_SOCKOP(SOCKETPAIR, do_print_socketpair), 2959 PRINT_SOCKOP(SEND, do_print_sendrecv), 2960 PRINT_SOCKOP(RECV, do_print_sendrecv), 2961 PRINT_SOCKOP(SENDTO, do_print_msgaddr), 2962 PRINT_SOCKOP(RECVFROM, do_print_msgaddr), 2963 PRINT_SOCKOP(SHUTDOWN, do_print_shutdown), 2964 PRINT_SOCKOP(SETSOCKOPT, do_print_sockopt), 2965 PRINT_SOCKOP(GETSOCKOPT, do_print_sockopt), 2966 PRINT_SOCKOP(SENDMSG, do_print_msg), 2967 PRINT_SOCKOP(RECVMSG, do_print_msg), 2968 PRINT_SOCKOP(ACCEPT4, NULL), 2969 PRINT_SOCKOP(RECVMMSG, NULL), 2970 PRINT_SOCKOP(SENDMMSG, NULL), 2971 }; 2972 2973 static void 2974 print_socketcall(CPUArchState *cpu_env, const struct syscallname *name, 2975 abi_long arg0, abi_long arg1, abi_long arg2, 2976 abi_long arg3, abi_long arg4, abi_long arg5) 2977 { 2978 if (arg0 >= 0 && arg0 < ARRAY_SIZE(scall) && scall[arg0].print) { 2979 scall[arg0].print(scall[arg0].name, arg1); 2980 return; 2981 } 2982 print_syscall_prologue(name); 2983 print_raw_param(TARGET_ABI_FMT_ld, arg0, 0); 2984 print_raw_param(TARGET_ABI_FMT_ld, arg1, 0); 2985 print_raw_param(TARGET_ABI_FMT_ld, arg2, 0); 2986 print_raw_param(TARGET_ABI_FMT_ld, arg3, 0); 2987 print_raw_param(TARGET_ABI_FMT_ld, arg4, 0); 2988 print_raw_param(TARGET_ABI_FMT_ld, arg5, 0); 2989 print_syscall_epilogue(name); 2990 } 2991 #endif 2992 2993 #if defined(TARGET_NR_bind) 2994 static void 2995 print_bind(CPUArchState *cpu_env, const struct syscallname *name, 2996 abi_long arg0, abi_long arg1, abi_long arg2, 2997 abi_long arg3, abi_long arg4, abi_long arg5) 2998 { 2999 print_syscall_prologue(name); 3000 print_sockfd(arg0, 0); 3001 print_sockaddr(arg1, arg2, 1); 3002 print_syscall_epilogue(name); 3003 } 3004 #endif 3005 3006 #if defined(TARGET_NR_stat) || defined(TARGET_NR_stat64) || \ 3007 defined(TARGET_NR_lstat) || defined(TARGET_NR_lstat64) 3008 static void 3009 print_stat(CPUArchState *cpu_env, const struct syscallname *name, 3010 abi_long arg0, abi_long arg1, abi_long arg2, 3011 abi_long arg3, abi_long arg4, abi_long arg5) 3012 { 3013 print_syscall_prologue(name); 3014 print_string(arg0, 0); 3015 print_pointer(arg1, 1); 3016 print_syscall_epilogue(name); 3017 } 3018 #define print_lstat print_stat 3019 #define print_stat64 print_stat 3020 #define print_lstat64 print_stat 3021 #endif 3022 3023 #if defined(TARGET_NR_madvise) 3024 static struct enums madvise_advice[] = { 3025 ENUM_TARGET(MADV_NORMAL), 3026 ENUM_TARGET(MADV_RANDOM), 3027 ENUM_TARGET(MADV_SEQUENTIAL), 3028 ENUM_TARGET(MADV_WILLNEED), 3029 ENUM_TARGET(MADV_DONTNEED), 3030 ENUM_TARGET(MADV_FREE), 3031 ENUM_TARGET(MADV_REMOVE), 3032 ENUM_TARGET(MADV_DONTFORK), 3033 ENUM_TARGET(MADV_DOFORK), 3034 ENUM_TARGET(MADV_MERGEABLE), 3035 ENUM_TARGET(MADV_UNMERGEABLE), 3036 ENUM_TARGET(MADV_HUGEPAGE), 3037 ENUM_TARGET(MADV_NOHUGEPAGE), 3038 ENUM_TARGET(MADV_DONTDUMP), 3039 ENUM_TARGET(MADV_DODUMP), 3040 ENUM_TARGET(MADV_WIPEONFORK), 3041 ENUM_TARGET(MADV_KEEPONFORK), 3042 ENUM_TARGET(MADV_COLD), 3043 ENUM_TARGET(MADV_PAGEOUT), 3044 ENUM_TARGET(MADV_POPULATE_READ), 3045 ENUM_TARGET(MADV_POPULATE_WRITE), 3046 ENUM_TARGET(MADV_DONTNEED_LOCKED), 3047 ENUM_END, 3048 }; 3049 3050 static void 3051 print_madvise(CPUArchState *cpu_env, const struct syscallname *name, 3052 abi_long arg0, abi_long arg1, abi_long arg2, 3053 abi_long arg3, abi_long arg4, abi_long arg5) 3054 { 3055 print_syscall_prologue(name); 3056 print_pointer(arg0, 0); 3057 print_raw_param("%d", arg1, 0); 3058 print_enums(madvise_advice, arg2, 1); 3059 print_syscall_epilogue(name); 3060 } 3061 #endif 3062 3063 #if defined(TARGET_NR_fstat) || defined(TARGET_NR_fstat64) 3064 static void 3065 print_fstat(CPUArchState *cpu_env, const struct syscallname *name, 3066 abi_long arg0, abi_long arg1, abi_long arg2, 3067 abi_long arg3, abi_long arg4, abi_long arg5) 3068 { 3069 print_syscall_prologue(name); 3070 print_raw_param("%d", arg0, 0); 3071 print_pointer(arg1, 1); 3072 print_syscall_epilogue(name); 3073 } 3074 #define print_fstat64 print_fstat 3075 #endif 3076 3077 #ifdef TARGET_NR_mkdir 3078 static void 3079 print_mkdir(CPUArchState *cpu_env, const struct syscallname *name, 3080 abi_long arg0, abi_long arg1, abi_long arg2, 3081 abi_long arg3, abi_long arg4, abi_long arg5) 3082 { 3083 print_syscall_prologue(name); 3084 print_string(arg0, 0); 3085 print_file_mode(arg1, 1); 3086 print_syscall_epilogue(name); 3087 } 3088 #endif 3089 3090 #ifdef TARGET_NR_mkdirat 3091 static void 3092 print_mkdirat(CPUArchState *cpu_env, const struct syscallname *name, 3093 abi_long arg0, abi_long arg1, abi_long arg2, 3094 abi_long arg3, abi_long arg4, abi_long arg5) 3095 { 3096 print_syscall_prologue(name); 3097 print_at_dirfd(arg0, 0); 3098 print_string(arg1, 0); 3099 print_file_mode(arg2, 1); 3100 print_syscall_epilogue(name); 3101 } 3102 #endif 3103 3104 #ifdef TARGET_NR_rmdir 3105 static void 3106 print_rmdir(CPUArchState *cpu_env, const struct syscallname *name, 3107 abi_long arg0, abi_long arg1, abi_long arg2, 3108 abi_long arg3, abi_long arg4, abi_long arg5) 3109 { 3110 print_syscall_prologue(name); 3111 print_string(arg0, 0); 3112 print_syscall_epilogue(name); 3113 } 3114 #endif 3115 3116 #ifdef TARGET_NR_rt_sigaction 3117 static void 3118 print_rt_sigaction(CPUArchState *cpu_env, const struct syscallname *name, 3119 abi_long arg0, abi_long arg1, abi_long arg2, 3120 abi_long arg3, abi_long arg4, abi_long arg5) 3121 { 3122 print_syscall_prologue(name); 3123 print_signal(arg0, 0); 3124 print_pointer(arg1, 0); 3125 print_pointer(arg2, 1); 3126 print_syscall_epilogue(name); 3127 } 3128 #endif 3129 3130 #ifdef TARGET_NR_rt_sigprocmask 3131 static void 3132 print_rt_sigprocmask(CPUArchState *cpu_env, const struct syscallname *name, 3133 abi_long arg0, abi_long arg1, abi_long arg2, 3134 abi_long arg3, abi_long arg4, abi_long arg5) 3135 { 3136 const char *how = "UNKNOWN"; 3137 print_syscall_prologue(name); 3138 switch(arg0) { 3139 case TARGET_SIG_BLOCK: how = "SIG_BLOCK"; break; 3140 case TARGET_SIG_UNBLOCK: how = "SIG_UNBLOCK"; break; 3141 case TARGET_SIG_SETMASK: how = "SIG_SETMASK"; break; 3142 } 3143 qemu_log("%s,", how); 3144 print_pointer(arg1, 0); 3145 print_pointer(arg2, 1); 3146 print_syscall_epilogue(name); 3147 } 3148 #endif 3149 3150 #ifdef TARGET_NR_rt_sigqueueinfo 3151 static void 3152 print_rt_sigqueueinfo(CPUArchState *cpu_env, const struct syscallname *name, 3153 abi_long arg0, abi_long arg1, abi_long arg2, 3154 abi_long arg3, abi_long arg4, abi_long arg5) 3155 { 3156 void *p; 3157 target_siginfo_t uinfo; 3158 3159 print_syscall_prologue(name); 3160 print_raw_param("%d", arg0, 0); 3161 print_signal(arg1, 0); 3162 p = lock_user(VERIFY_READ, arg2, sizeof(target_siginfo_t), 1); 3163 if (p) { 3164 get_target_siginfo(&uinfo, p); 3165 print_siginfo(&uinfo); 3166 3167 unlock_user(p, arg2, 0); 3168 } else { 3169 print_pointer(arg2, 1); 3170 } 3171 print_syscall_epilogue(name); 3172 } 3173 #endif 3174 3175 #ifdef TARGET_NR_rt_tgsigqueueinfo 3176 static void 3177 print_rt_tgsigqueueinfo(CPUArchState *cpu_env, const struct syscallname *name, 3178 abi_long arg0, abi_long arg1, abi_long arg2, 3179 abi_long arg3, abi_long arg4, abi_long arg5) 3180 { 3181 void *p; 3182 target_siginfo_t uinfo; 3183 3184 print_syscall_prologue(name); 3185 print_raw_param("%d", arg0, 0); 3186 print_raw_param("%d", arg1, 0); 3187 print_signal(arg2, 0); 3188 p = lock_user(VERIFY_READ, arg3, sizeof(target_siginfo_t), 1); 3189 if (p) { 3190 get_target_siginfo(&uinfo, p); 3191 print_siginfo(&uinfo); 3192 3193 unlock_user(p, arg3, 0); 3194 } else { 3195 print_pointer(arg3, 1); 3196 } 3197 print_syscall_epilogue(name); 3198 } 3199 #endif 3200 3201 #ifdef TARGET_NR_syslog 3202 static void 3203 print_syslog_action(abi_ulong arg, int last) 3204 { 3205 const char *type; 3206 3207 switch (arg) { 3208 case TARGET_SYSLOG_ACTION_CLOSE: { 3209 type = "SYSLOG_ACTION_CLOSE"; 3210 break; 3211 } 3212 case TARGET_SYSLOG_ACTION_OPEN: { 3213 type = "SYSLOG_ACTION_OPEN"; 3214 break; 3215 } 3216 case TARGET_SYSLOG_ACTION_READ: { 3217 type = "SYSLOG_ACTION_READ"; 3218 break; 3219 } 3220 case TARGET_SYSLOG_ACTION_READ_ALL: { 3221 type = "SYSLOG_ACTION_READ_ALL"; 3222 break; 3223 } 3224 case TARGET_SYSLOG_ACTION_READ_CLEAR: { 3225 type = "SYSLOG_ACTION_READ_CLEAR"; 3226 break; 3227 } 3228 case TARGET_SYSLOG_ACTION_CLEAR: { 3229 type = "SYSLOG_ACTION_CLEAR"; 3230 break; 3231 } 3232 case TARGET_SYSLOG_ACTION_CONSOLE_OFF: { 3233 type = "SYSLOG_ACTION_CONSOLE_OFF"; 3234 break; 3235 } 3236 case TARGET_SYSLOG_ACTION_CONSOLE_ON: { 3237 type = "SYSLOG_ACTION_CONSOLE_ON"; 3238 break; 3239 } 3240 case TARGET_SYSLOG_ACTION_CONSOLE_LEVEL: { 3241 type = "SYSLOG_ACTION_CONSOLE_LEVEL"; 3242 break; 3243 } 3244 case TARGET_SYSLOG_ACTION_SIZE_UNREAD: { 3245 type = "SYSLOG_ACTION_SIZE_UNREAD"; 3246 break; 3247 } 3248 case TARGET_SYSLOG_ACTION_SIZE_BUFFER: { 3249 type = "SYSLOG_ACTION_SIZE_BUFFER"; 3250 break; 3251 } 3252 default: { 3253 print_raw_param("%ld", arg, last); 3254 return; 3255 } 3256 } 3257 qemu_log("%s%s", type, get_comma(last)); 3258 } 3259 3260 static void 3261 print_syslog(CPUArchState *cpu_env, const struct syscallname *name, 3262 abi_long arg0, abi_long arg1, abi_long arg2, 3263 abi_long arg3, abi_long arg4, abi_long arg5) 3264 { 3265 print_syscall_prologue(name); 3266 print_syslog_action(arg0, 0); 3267 print_pointer(arg1, 0); 3268 print_raw_param("%d", arg2, 1); 3269 print_syscall_epilogue(name); 3270 } 3271 #endif 3272 3273 #ifdef TARGET_NR_mknod 3274 static void 3275 print_mknod(CPUArchState *cpu_env, const struct syscallname *name, 3276 abi_long arg0, abi_long arg1, abi_long arg2, 3277 abi_long arg3, abi_long arg4, abi_long arg5) 3278 { 3279 int hasdev = (arg1 & (S_IFCHR|S_IFBLK)); 3280 3281 print_syscall_prologue(name); 3282 print_string(arg0, 0); 3283 print_file_mode(arg1, (hasdev == 0)); 3284 if (hasdev) { 3285 print_raw_param("makedev(%d", major(arg2), 0); 3286 print_raw_param("%d)", minor(arg2), 1); 3287 } 3288 print_syscall_epilogue(name); 3289 } 3290 #endif 3291 3292 #ifdef TARGET_NR_mknodat 3293 static void 3294 print_mknodat(CPUArchState *cpu_env, const struct syscallname *name, 3295 abi_long arg0, abi_long arg1, abi_long arg2, 3296 abi_long arg3, abi_long arg4, abi_long arg5) 3297 { 3298 int hasdev = (arg2 & (S_IFCHR|S_IFBLK)); 3299 3300 print_syscall_prologue(name); 3301 print_at_dirfd(arg0, 0); 3302 print_string(arg1, 0); 3303 print_file_mode(arg2, (hasdev == 0)); 3304 if (hasdev) { 3305 print_raw_param("makedev(%d", major(arg3), 0); 3306 print_raw_param("%d)", minor(arg3), 1); 3307 } 3308 print_syscall_epilogue(name); 3309 } 3310 #endif 3311 3312 #ifdef TARGET_NR_mq_open 3313 static void 3314 print_mq_open(CPUArchState *cpu_env, const struct syscallname *name, 3315 abi_long arg0, abi_long arg1, abi_long arg2, 3316 abi_long arg3, abi_long arg4, abi_long arg5) 3317 { 3318 int is_creat = (arg1 & TARGET_O_CREAT); 3319 3320 print_syscall_prologue(name); 3321 print_string(arg0, 0); 3322 print_open_flags(arg1, (is_creat == 0)); 3323 if (is_creat) { 3324 print_file_mode(arg2, 0); 3325 print_pointer(arg3, 1); 3326 } 3327 print_syscall_epilogue(name); 3328 } 3329 #endif 3330 3331 #ifdef TARGET_NR_open 3332 static void 3333 print_open(CPUArchState *cpu_env, const struct syscallname *name, 3334 abi_long arg0, abi_long arg1, abi_long arg2, 3335 abi_long arg3, abi_long arg4, abi_long arg5) 3336 { 3337 int is_creat = (arg1 & TARGET_O_CREAT); 3338 3339 print_syscall_prologue(name); 3340 print_string(arg0, 0); 3341 print_open_flags(arg1, (is_creat == 0)); 3342 if (is_creat) 3343 print_file_mode(arg2, 1); 3344 print_syscall_epilogue(name); 3345 } 3346 #endif 3347 3348 #ifdef TARGET_NR_openat 3349 static void 3350 print_openat(CPUArchState *cpu_env, const struct syscallname *name, 3351 abi_long arg0, abi_long arg1, abi_long arg2, 3352 abi_long arg3, abi_long arg4, abi_long arg5) 3353 { 3354 int is_creat = (arg2 & TARGET_O_CREAT); 3355 3356 print_syscall_prologue(name); 3357 print_at_dirfd(arg0, 0); 3358 print_string(arg1, 0); 3359 print_open_flags(arg2, (is_creat == 0)); 3360 if (is_creat) 3361 print_file_mode(arg3, 1); 3362 print_syscall_epilogue(name); 3363 } 3364 #endif 3365 3366 #ifdef TARGET_NR_pidfd_send_signal 3367 static void 3368 print_pidfd_send_signal(CPUArchState *cpu_env, const struct syscallname *name, 3369 abi_long arg0, abi_long arg1, abi_long arg2, 3370 abi_long arg3, abi_long arg4, abi_long arg5) 3371 { 3372 void *p; 3373 target_siginfo_t uinfo; 3374 3375 print_syscall_prologue(name); 3376 print_raw_param("%d", arg0, 0); 3377 print_signal(arg1, 0); 3378 3379 p = lock_user(VERIFY_READ, arg2, sizeof(target_siginfo_t), 1); 3380 if (p) { 3381 get_target_siginfo(&uinfo, p); 3382 print_siginfo(&uinfo); 3383 3384 unlock_user(p, arg2, 0); 3385 } else { 3386 print_pointer(arg2, 0); 3387 } 3388 3389 print_raw_param("%u", arg3, 1); 3390 print_syscall_epilogue(name); 3391 } 3392 #endif 3393 3394 #ifdef TARGET_NR_mq_unlink 3395 static void 3396 print_mq_unlink(CPUArchState *cpu_env, const struct syscallname *name, 3397 abi_long arg0, abi_long arg1, abi_long arg2, 3398 abi_long arg3, abi_long arg4, abi_long arg5) 3399 { 3400 print_syscall_prologue(name); 3401 print_string(arg0, 1); 3402 print_syscall_epilogue(name); 3403 } 3404 #endif 3405 3406 #if defined(TARGET_NR_fstatat64) || defined(TARGET_NR_newfstatat) 3407 static void 3408 print_fstatat64(CPUArchState *cpu_env, const struct syscallname *name, 3409 abi_long arg0, abi_long arg1, abi_long arg2, 3410 abi_long arg3, abi_long arg4, abi_long arg5) 3411 { 3412 print_syscall_prologue(name); 3413 print_at_dirfd(arg0, 0); 3414 print_string(arg1, 0); 3415 print_pointer(arg2, 0); 3416 print_flags(at_file_flags, arg3, 1); 3417 print_syscall_epilogue(name); 3418 } 3419 #define print_newfstatat print_fstatat64 3420 #endif 3421 3422 #ifdef TARGET_NR_readlink 3423 static void 3424 print_readlink(CPUArchState *cpu_env, const struct syscallname *name, 3425 abi_long arg0, abi_long arg1, abi_long arg2, 3426 abi_long arg3, abi_long arg4, abi_long arg5) 3427 { 3428 print_syscall_prologue(name); 3429 print_string(arg0, 0); 3430 print_pointer(arg1, 0); 3431 print_raw_param("%u", arg2, 1); 3432 print_syscall_epilogue(name); 3433 } 3434 #endif 3435 3436 #ifdef TARGET_NR_readlinkat 3437 static void 3438 print_readlinkat(CPUArchState *cpu_env, const struct syscallname *name, 3439 abi_long arg0, abi_long arg1, abi_long arg2, 3440 abi_long arg3, abi_long arg4, abi_long arg5) 3441 { 3442 print_syscall_prologue(name); 3443 print_at_dirfd(arg0, 0); 3444 print_string(arg1, 0); 3445 print_pointer(arg2, 0); 3446 print_raw_param("%u", arg3, 1); 3447 print_syscall_epilogue(name); 3448 } 3449 #endif 3450 3451 #ifdef TARGET_NR_rename 3452 static void 3453 print_rename(CPUArchState *cpu_env, const struct syscallname *name, 3454 abi_long arg0, abi_long arg1, abi_long arg2, 3455 abi_long arg3, abi_long arg4, abi_long arg5) 3456 { 3457 print_syscall_prologue(name); 3458 print_string(arg0, 0); 3459 print_string(arg1, 1); 3460 print_syscall_epilogue(name); 3461 } 3462 #endif 3463 3464 #ifdef TARGET_NR_renameat 3465 static void 3466 print_renameat(CPUArchState *cpu_env, const struct syscallname *name, 3467 abi_long arg0, abi_long arg1, abi_long arg2, 3468 abi_long arg3, abi_long arg4, abi_long arg5) 3469 { 3470 print_syscall_prologue(name); 3471 print_at_dirfd(arg0, 0); 3472 print_string(arg1, 0); 3473 print_at_dirfd(arg2, 0); 3474 print_string(arg3, 1); 3475 print_syscall_epilogue(name); 3476 } 3477 #endif 3478 3479 #ifdef TARGET_NR_statfs 3480 static void 3481 print_statfs(CPUArchState *cpu_env, const struct syscallname *name, 3482 abi_long arg0, abi_long arg1, abi_long arg2, 3483 abi_long arg3, abi_long arg4, abi_long arg5) 3484 { 3485 print_syscall_prologue(name); 3486 print_string(arg0, 0); 3487 print_pointer(arg1, 1); 3488 print_syscall_epilogue(name); 3489 } 3490 #endif 3491 3492 #ifdef TARGET_NR_statfs64 3493 static void 3494 print_statfs64(CPUArchState *cpu_env, const struct syscallname *name, 3495 abi_long arg0, abi_long arg1, abi_long arg2, 3496 abi_long arg3, abi_long arg4, abi_long arg5) 3497 { 3498 print_syscall_prologue(name); 3499 print_string(arg0, 0); 3500 print_pointer(arg1, 1); 3501 print_syscall_epilogue(name); 3502 } 3503 #endif 3504 3505 #ifdef TARGET_NR_symlink 3506 static void 3507 print_symlink(CPUArchState *cpu_env, const struct syscallname *name, 3508 abi_long arg0, abi_long arg1, abi_long arg2, 3509 abi_long arg3, abi_long arg4, abi_long arg5) 3510 { 3511 print_syscall_prologue(name); 3512 print_string(arg0, 0); 3513 print_string(arg1, 1); 3514 print_syscall_epilogue(name); 3515 } 3516 #endif 3517 3518 #ifdef TARGET_NR_symlinkat 3519 static void 3520 print_symlinkat(CPUArchState *cpu_env, const struct syscallname *name, 3521 abi_long arg0, abi_long arg1, abi_long arg2, 3522 abi_long arg3, abi_long arg4, abi_long arg5) 3523 { 3524 print_syscall_prologue(name); 3525 print_string(arg0, 0); 3526 print_at_dirfd(arg1, 0); 3527 print_string(arg2, 1); 3528 print_syscall_epilogue(name); 3529 } 3530 #endif 3531 3532 #ifdef TARGET_NR_mount 3533 static void 3534 print_mount(CPUArchState *cpu_env, const struct syscallname *name, 3535 abi_long arg0, abi_long arg1, abi_long arg2, 3536 abi_long arg3, abi_long arg4, abi_long arg5) 3537 { 3538 print_syscall_prologue(name); 3539 print_string(arg0, 0); 3540 print_string(arg1, 0); 3541 print_string(arg2, 0); 3542 print_flags(mount_flags, arg3, 0); 3543 print_pointer(arg4, 1); 3544 print_syscall_epilogue(name); 3545 } 3546 #endif 3547 3548 #ifdef TARGET_NR_umount 3549 static void 3550 print_umount(CPUArchState *cpu_env, const struct syscallname *name, 3551 abi_long arg0, abi_long arg1, abi_long arg2, 3552 abi_long arg3, abi_long arg4, abi_long arg5) 3553 { 3554 print_syscall_prologue(name); 3555 print_string(arg0, 1); 3556 print_syscall_epilogue(name); 3557 } 3558 #endif 3559 3560 #ifdef TARGET_NR_umount2 3561 static void 3562 print_umount2(CPUArchState *cpu_env, const struct syscallname *name, 3563 abi_long arg0, abi_long arg1, abi_long arg2, 3564 abi_long arg3, abi_long arg4, abi_long arg5) 3565 { 3566 print_syscall_prologue(name); 3567 print_string(arg0, 0); 3568 print_flags(umount2_flags, arg1, 1); 3569 print_syscall_epilogue(name); 3570 } 3571 #endif 3572 3573 #ifdef TARGET_NR_unlink 3574 static void 3575 print_unlink(CPUArchState *cpu_env, const struct syscallname *name, 3576 abi_long arg0, abi_long arg1, abi_long arg2, 3577 abi_long arg3, abi_long arg4, abi_long arg5) 3578 { 3579 print_syscall_prologue(name); 3580 print_string(arg0, 1); 3581 print_syscall_epilogue(name); 3582 } 3583 #endif 3584 3585 #ifdef TARGET_NR_unlinkat 3586 static void 3587 print_unlinkat(CPUArchState *cpu_env, const struct syscallname *name, 3588 abi_long arg0, abi_long arg1, abi_long arg2, 3589 abi_long arg3, abi_long arg4, abi_long arg5) 3590 { 3591 print_syscall_prologue(name); 3592 print_at_dirfd(arg0, 0); 3593 print_string(arg1, 0); 3594 print_flags(unlinkat_flags, arg2, 1); 3595 print_syscall_epilogue(name); 3596 } 3597 #endif 3598 3599 #ifdef TARGET_NR_unshare 3600 static void 3601 print_unshare(CPUArchState *cpu_env, const struct syscallname *name, 3602 abi_long arg0, abi_long arg1, abi_long arg2, 3603 abi_long arg3, abi_long arg4, abi_long arg5) 3604 { 3605 print_syscall_prologue(name); 3606 print_flags(clone_flags, arg0, 1); 3607 print_syscall_epilogue(name); 3608 } 3609 #endif 3610 3611 #ifdef TARGET_NR_clock_nanosleep 3612 static void 3613 print_clock_nanosleep(CPUArchState *cpu_env, const struct syscallname *name, 3614 abi_long arg0, abi_long arg1, abi_long arg2, 3615 abi_long arg3, abi_long arg4, abi_long arg5) 3616 { 3617 print_syscall_prologue(name); 3618 print_enums(clockids, arg0, 0); 3619 print_raw_param("%d", arg1, 0); 3620 print_timespec(arg2, 0); 3621 print_timespec(arg3, 1); 3622 print_syscall_epilogue(name); 3623 } 3624 #endif 3625 3626 #ifdef TARGET_NR_utime 3627 static void 3628 print_utime(CPUArchState *cpu_env, const struct syscallname *name, 3629 abi_long arg0, abi_long arg1, abi_long arg2, 3630 abi_long arg3, abi_long arg4, abi_long arg5) 3631 { 3632 print_syscall_prologue(name); 3633 print_string(arg0, 0); 3634 print_pointer(arg1, 1); 3635 print_syscall_epilogue(name); 3636 } 3637 #endif 3638 3639 #ifdef TARGET_NR_utimes 3640 static void 3641 print_utimes(CPUArchState *cpu_env, const struct syscallname *name, 3642 abi_long arg0, abi_long arg1, abi_long arg2, 3643 abi_long arg3, abi_long arg4, abi_long arg5) 3644 { 3645 print_syscall_prologue(name); 3646 print_string(arg0, 0); 3647 print_pointer(arg1, 1); 3648 print_syscall_epilogue(name); 3649 } 3650 #endif 3651 3652 #ifdef TARGET_NR_utimensat 3653 static void 3654 print_utimensat(CPUArchState *cpu_env, const struct syscallname *name, 3655 abi_long arg0, abi_long arg1, abi_long arg2, 3656 abi_long arg3, abi_long arg4, abi_long arg5) 3657 { 3658 print_syscall_prologue(name); 3659 print_at_dirfd(arg0, 0); 3660 print_string(arg1, 0); 3661 print_pointer(arg2, 0); 3662 print_flags(at_file_flags, arg3, 1); 3663 print_syscall_epilogue(name); 3664 } 3665 #endif 3666 3667 #if defined(TARGET_NR_mmap) || defined(TARGET_NR_mmap2) 3668 static void 3669 print_mmap(CPUArchState *cpu_env, const struct syscallname *name, 3670 abi_long arg0, abi_long arg1, abi_long arg2, 3671 abi_long arg3, abi_long arg4, abi_long arg5) 3672 { 3673 print_syscall_prologue(name); 3674 print_pointer(arg0, 0); 3675 print_raw_param("%d", arg1, 0); 3676 print_flags(mmap_prot_flags, arg2, 0); 3677 print_flags(mmap_flags, arg3, 0); 3678 print_raw_param("%d", arg4, 0); 3679 print_raw_param("%#x", arg5, 1); 3680 print_syscall_epilogue(name); 3681 } 3682 #define print_mmap2 print_mmap 3683 #endif 3684 3685 #ifdef TARGET_NR_mprotect 3686 static void 3687 print_mprotect(CPUArchState *cpu_env, const struct syscallname *name, 3688 abi_long arg0, abi_long arg1, abi_long arg2, 3689 abi_long arg3, abi_long arg4, abi_long arg5) 3690 { 3691 print_syscall_prologue(name); 3692 print_pointer(arg0, 0); 3693 print_raw_param("%d", arg1, 0); 3694 print_flags(mmap_prot_flags, arg2, 1); 3695 print_syscall_epilogue(name); 3696 } 3697 #endif 3698 3699 #ifdef TARGET_NR_munmap 3700 static void 3701 print_munmap(CPUArchState *cpu_env, const struct syscallname *name, 3702 abi_long arg0, abi_long arg1, abi_long arg2, 3703 abi_long arg3, abi_long arg4, abi_long arg5) 3704 { 3705 print_syscall_prologue(name); 3706 print_pointer(arg0, 0); 3707 print_raw_param("%d", arg1, 1); 3708 print_syscall_epilogue(name); 3709 } 3710 #endif 3711 3712 #ifdef TARGET_NR_futex 3713 static void print_futex_op(int cmd, int last) 3714 { 3715 static const char * const futex_names[] = { 3716 #define NAME(X) [X] = #X 3717 NAME(FUTEX_WAIT), 3718 NAME(FUTEX_WAKE), 3719 NAME(FUTEX_FD), 3720 NAME(FUTEX_REQUEUE), 3721 NAME(FUTEX_CMP_REQUEUE), 3722 NAME(FUTEX_WAKE_OP), 3723 NAME(FUTEX_LOCK_PI), 3724 NAME(FUTEX_UNLOCK_PI), 3725 NAME(FUTEX_TRYLOCK_PI), 3726 NAME(FUTEX_WAIT_BITSET), 3727 NAME(FUTEX_WAKE_BITSET), 3728 NAME(FUTEX_WAIT_REQUEUE_PI), 3729 NAME(FUTEX_CMP_REQUEUE_PI), 3730 NAME(FUTEX_LOCK_PI2), 3731 #undef NAME 3732 }; 3733 3734 unsigned base_cmd = cmd & FUTEX_CMD_MASK; 3735 3736 if (base_cmd < ARRAY_SIZE(futex_names)) { 3737 qemu_log("%s%s%s", 3738 (cmd & FUTEX_PRIVATE_FLAG ? "FUTEX_PRIVATE_FLAG|" : ""), 3739 (cmd & FUTEX_CLOCK_REALTIME ? "FUTEX_CLOCK_REALTIME|" : ""), 3740 futex_names[base_cmd]); 3741 } else { 3742 qemu_log("0x%x", cmd); 3743 } 3744 } 3745 3746 static void 3747 print_futex(CPUArchState *cpu_env, const struct syscallname *name, 3748 abi_long arg0, abi_long arg1, abi_long arg2, 3749 abi_long arg3, abi_long arg4, abi_long arg5) 3750 { 3751 abi_long op = arg1 & FUTEX_CMD_MASK; 3752 print_syscall_prologue(name); 3753 print_pointer(arg0, 0); 3754 print_futex_op(arg1, 0); 3755 print_raw_param(",%d", arg2, 0); 3756 switch (op) { 3757 case FUTEX_WAIT: 3758 case FUTEX_WAIT_BITSET: 3759 case FUTEX_LOCK_PI: 3760 case FUTEX_LOCK_PI2: 3761 case FUTEX_WAIT_REQUEUE_PI: 3762 print_timespec(arg3, 0); 3763 break; 3764 default: 3765 print_pointer(arg3, 0); 3766 break; 3767 } 3768 print_pointer(arg4, 0); 3769 print_raw_param("%d", arg4, 1); 3770 print_syscall_epilogue(name); 3771 } 3772 #endif 3773 3774 #ifdef TARGET_NR_kill 3775 static void 3776 print_kill(CPUArchState *cpu_env, const struct syscallname *name, 3777 abi_long arg0, abi_long arg1, abi_long arg2, 3778 abi_long arg3, abi_long arg4, abi_long arg5) 3779 { 3780 print_syscall_prologue(name); 3781 print_raw_param("%d", arg0, 0); 3782 print_signal(arg1, 1); 3783 print_syscall_epilogue(name); 3784 } 3785 #endif 3786 3787 #ifdef TARGET_NR_tkill 3788 static void 3789 print_tkill(CPUArchState *cpu_env, const struct syscallname *name, 3790 abi_long arg0, abi_long arg1, abi_long arg2, 3791 abi_long arg3, abi_long arg4, abi_long arg5) 3792 { 3793 print_syscall_prologue(name); 3794 print_raw_param("%d", arg0, 0); 3795 print_signal(arg1, 1); 3796 print_syscall_epilogue(name); 3797 } 3798 #endif 3799 3800 #ifdef TARGET_NR_tgkill 3801 static void 3802 print_tgkill(CPUArchState *cpu_env, const struct syscallname *name, 3803 abi_long arg0, abi_long arg1, abi_long arg2, 3804 abi_long arg3, abi_long arg4, abi_long arg5) 3805 { 3806 print_syscall_prologue(name); 3807 print_raw_param("%d", arg0, 0); 3808 print_raw_param("%d", arg1, 0); 3809 print_signal(arg2, 1); 3810 print_syscall_epilogue(name); 3811 } 3812 #endif 3813 3814 #ifdef TARGET_NR_statx 3815 static void 3816 print_statx(CPUArchState *cpu_env, const struct syscallname *name, 3817 abi_long arg0, abi_long arg1, abi_long arg2, 3818 abi_long arg3, abi_long arg4, abi_long arg5) 3819 { 3820 print_syscall_prologue(name); 3821 print_at_dirfd(arg0, 0); 3822 print_string(arg1, 0); 3823 print_flags(statx_flags, arg2, 0); 3824 print_flags(statx_mask, arg3, 0); 3825 print_pointer(arg4, 1); 3826 print_syscall_epilogue(name); 3827 } 3828 #endif 3829 3830 #ifdef TARGET_NR_ioctl 3831 static void 3832 print_ioctl(CPUArchState *cpu_env, const struct syscallname *name, 3833 abi_long arg0, abi_long arg1, abi_long arg2, 3834 abi_long arg3, abi_long arg4, abi_long arg5) 3835 { 3836 print_syscall_prologue(name); 3837 print_raw_param("%d", arg0, 0); 3838 3839 const IOCTLEntry *ie; 3840 const argtype *arg_type; 3841 void *argptr; 3842 int target_size; 3843 3844 for (ie = ioctl_entries; ie->target_cmd != 0; ie++) { 3845 if (ie->target_cmd == arg1) { 3846 break; 3847 } 3848 } 3849 3850 if (ie->target_cmd == 0) { 3851 print_raw_param("%#x", arg1, 0); 3852 print_raw_param("%#x", arg2, 1); 3853 } else { 3854 qemu_log("%s", ie->name); 3855 arg_type = ie->arg_type; 3856 3857 if (arg_type[0] != TYPE_NULL) { 3858 qemu_log(","); 3859 3860 switch (arg_type[0]) { 3861 case TYPE_PTRVOID: 3862 print_pointer(arg2, 1); 3863 break; 3864 case TYPE_CHAR: 3865 case TYPE_SHORT: 3866 case TYPE_INT: 3867 print_raw_param("%d", arg2, 1); 3868 break; 3869 case TYPE_LONG: 3870 print_raw_param(TARGET_ABI_FMT_ld, arg2, 1); 3871 break; 3872 case TYPE_ULONG: 3873 print_raw_param(TARGET_ABI_FMT_lu, arg2, 1); 3874 break; 3875 case TYPE_PTR: 3876 switch (ie->access) { 3877 case IOC_R: 3878 print_pointer(arg2, 1); 3879 break; 3880 case IOC_W: 3881 case IOC_RW: 3882 arg_type++; 3883 target_size = thunk_type_size(arg_type, 0); 3884 argptr = lock_user(VERIFY_READ, arg2, target_size, 1); 3885 if (argptr) { 3886 thunk_print(argptr, arg_type); 3887 unlock_user(argptr, arg2, target_size); 3888 } else { 3889 print_pointer(arg2, 1); 3890 } 3891 break; 3892 } 3893 break; 3894 default: 3895 g_assert_not_reached(); 3896 } 3897 } 3898 } 3899 print_syscall_epilogue(name); 3900 } 3901 #endif 3902 3903 /* 3904 * An array of all of the syscalls we know about 3905 */ 3906 3907 static const struct syscallname scnames[] = { 3908 #include "strace.list" 3909 }; 3910 3911 static int nsyscalls = ARRAY_SIZE(scnames); 3912 3913 /* 3914 * The public interface to this module. 3915 */ 3916 void 3917 print_syscall(CPUArchState *cpu_env, int num, 3918 abi_long arg1, abi_long arg2, abi_long arg3, 3919 abi_long arg4, abi_long arg5, abi_long arg6) 3920 { 3921 int i; 3922 FILE *f; 3923 const char *format = "%s(" TARGET_ABI_FMT_ld "," TARGET_ABI_FMT_ld "," 3924 TARGET_ABI_FMT_ld "," TARGET_ABI_FMT_ld "," 3925 TARGET_ABI_FMT_ld "," TARGET_ABI_FMT_ld ")"; 3926 3927 f = qemu_log_trylock(); 3928 if (!f) { 3929 return; 3930 } 3931 fprintf(f, "%d ", getpid()); 3932 3933 for (i = 0; i < nsyscalls; i++) { 3934 if (scnames[i].nr == num) { 3935 if (scnames[i].call != NULL) { 3936 scnames[i].call(cpu_env, &scnames[i], arg1, arg2, arg3, 3937 arg4, arg5, arg6); 3938 } else { 3939 /* XXX: this format system is broken because it uses 3940 host types and host pointers for strings */ 3941 if (scnames[i].format != NULL) { 3942 format = scnames[i].format; 3943 } 3944 fprintf(f, format, scnames[i].name, arg1, arg2, 3945 arg3, arg4, arg5, arg6); 3946 } 3947 qemu_log_unlock(f); 3948 return; 3949 } 3950 } 3951 fprintf(f, "Unknown syscall %d\n", num); 3952 qemu_log_unlock(f); 3953 } 3954 3955 3956 void 3957 print_syscall_ret(CPUArchState *cpu_env, int num, abi_long ret, 3958 abi_long arg1, abi_long arg2, abi_long arg3, 3959 abi_long arg4, abi_long arg5, abi_long arg6) 3960 { 3961 int i; 3962 FILE *f; 3963 3964 f = qemu_log_trylock(); 3965 if (!f) { 3966 return; 3967 } 3968 3969 for (i = 0; i < nsyscalls; i++) { 3970 if (scnames[i].nr == num) { 3971 if (scnames[i].result != NULL) { 3972 scnames[i].result(cpu_env, &scnames[i], ret, 3973 arg1, arg2, arg3, 3974 arg4, arg5, arg6); 3975 } else { 3976 if (!print_syscall_err(ret)) { 3977 fprintf(f, TARGET_ABI_FMT_ld, ret); 3978 } 3979 fprintf(f, "\n"); 3980 } 3981 break; 3982 } 3983 } 3984 qemu_log_unlock(f); 3985 } 3986 3987 void print_taken_signal(int target_signum, const target_siginfo_t *tinfo) 3988 { 3989 /* Print the strace output for a signal being taken: 3990 * --- SIGSEGV {si_signo=SIGSEGV, si_code=SI_KERNEL, si_addr=0} --- 3991 */ 3992 FILE *f; 3993 3994 f = qemu_log_trylock(); 3995 if (!f) { 3996 return; 3997 } 3998 3999 fprintf(f, "--- "); 4000 print_signal(target_signum, 1); 4001 fprintf(f, " "); 4002 print_siginfo(tinfo); 4003 fprintf(f, " ---\n"); 4004 qemu_log_unlock(f); 4005 } 4006