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