linux-user/strace.c

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