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