linux-user/strace.c

   1 #include "qemu/osdep.h"
   2 #include <sys/ipc.h>
   3 #include <sys/msg.h>
   4 #include <sys/sem.h>
   5 #include <sys/shm.h>
   6 #include <sys/select.h>
   7 #include <sys/mount.h>
   8 #include <arpa/inet.h>
   9 #include <netinet/tcp.h>
  10 #include <linux/if_packet.h>
  11 #include <linux/netlink.h>
  12 #include <sched.h>
  13 #include "qemu.h"
  14
  15 struct syscallname {
  16     int nr;
  17     const char *name;
  18     const char *format;
  19     void (*call)(const struct syscallname *,
  20                  abi_long, abi_long, abi_long,
  21                  abi_long, abi_long, abi_long);
  22     void (*result)(const struct syscallname *, abi_long,
  23                    abi_long, abi_long, abi_long,
  24                    abi_long, abi_long, abi_long);
  25 };
  26
  27 #ifdef __GNUC__
  28 /*
  29  * It is possible that target doesn't have syscall that uses
  30  * following flags but we don't want the compiler to warn
  31  * us about them being unused.  Same applies to utility print
  32  * functions.  It is ok to keep them while not used.
  33  */
  34 #define UNUSED __attribute__ ((unused))
  35 #else
  36 #define UNUSED
  37 #endif
  38
  39 /*
  40  * Structure used to translate flag values into strings.  This is
  41  * similar that is in the actual strace tool.
  42  */
  43 struct flags {
  44     abi_long    f_value;  /* flag */
  45     const char  *f_string; /* stringified flag */
  46 };
  47
  48 /* common flags for all architectures */
  49 #define FLAG_GENERIC(name) { name, #name }
  50 /* target specific flags (syscall_defs.h has TARGET_<flag>) */
  51 #define FLAG_TARGET(name)  { TARGET_ ## name, #name }
  52 /* end of flags array */
  53 #define FLAG_END           { 0, NULL }
  54
  55 UNUSED static const char *get_comma(int);
  56 UNUSED static void print_pointer(abi_long, int);
  57 UNUSED static void print_flags(const struct flags *, abi_long, int);
  58 UNUSED static void print_at_dirfd(abi_long, int);
  59 UNUSED static void print_file_mode(abi_long, int);
  60 UNUSED static void print_open_flags(abi_long, int);
  61 UNUSED static void print_syscall_prologue(const struct syscallname *);
  62 UNUSED static void print_syscall_epilogue(const struct syscallname *);
  63 UNUSED static void print_string(abi_long, int);
  64 UNUSED static void print_buf(abi_long addr, abi_long len, int last);
  65 UNUSED static void print_raw_param(const char *, abi_long, int);
  66 UNUSED static void print_timeval(abi_ulong, int);
  67 UNUSED static void print_timezone(abi_ulong, int);
  68 UNUSED static void print_number(abi_long, int);
  69 UNUSED static void print_signal(abi_ulong, int);
  70 UNUSED static void print_sockaddr(abi_ulong, abi_long, int);
  71 UNUSED static void print_socket_domain(int domain);
  72 UNUSED static void print_socket_type(int type);
  73 UNUSED static void print_socket_protocol(int domain, int type, int protocol);
  74
  75 /*
  76  * Utility functions
  77  */
  78 static void
  79 print_ipc_cmd(int cmd)
  80 {
  81 #define output_cmd(val) \
  82 if( cmd == val ) { \
  83     qemu_log(#val); \
  84     return; \
  85 }
  86
  87     cmd &= 0xff;
  88
  89     /* General IPC commands */
  90     output_cmd( IPC_RMID );
  91     output_cmd( IPC_SET );
  92     output_cmd( IPC_STAT );
  93     output_cmd( IPC_INFO );
  94     /* msgctl() commands */
  95     output_cmd( MSG_STAT );
  96     output_cmd( MSG_INFO );
  97     /* shmctl() commands */
  98     output_cmd( SHM_LOCK );
  99     output_cmd( SHM_UNLOCK );
 100     output_cmd( SHM_STAT );
 101     output_cmd( SHM_INFO );
 102     /* semctl() commands */
 103     output_cmd( GETPID );
 104     output_cmd( GETVAL );
 105     output_cmd( GETALL );
 106     output_cmd( GETNCNT );
 107     output_cmd( GETZCNT );
 108     output_cmd( SETVAL );
 109     output_cmd( SETALL );
 110     output_cmd( SEM_STAT );
 111     output_cmd( SEM_INFO );
 112     output_cmd( IPC_RMID );
 113     output_cmd( IPC_RMID );
 114     output_cmd( IPC_RMID );
 115     output_cmd( IPC_RMID );
 116     output_cmd( IPC_RMID );
 117     output_cmd( IPC_RMID );
 118     output_cmd( IPC_RMID );
 119     output_cmd( IPC_RMID );
 120     output_cmd( IPC_RMID );
 121
 122     /* Some value we don't recognize */
 123     qemu_log("%d", cmd);
 124 }
 125
 126 static void
 127 print_signal(abi_ulong arg, int last)
 128 {
 129     const char *signal_name = NULL;
 130     switch(arg) {
 131     case TARGET_SIGHUP: signal_name = "SIGHUP"; break;
 132     case TARGET_SIGINT: signal_name = "SIGINT"; break;
 133     case TARGET_SIGQUIT: signal_name = "SIGQUIT"; break;
 134     case TARGET_SIGILL: signal_name = "SIGILL"; break;
 135     case TARGET_SIGABRT: signal_name = "SIGABRT"; break;
 136     case TARGET_SIGFPE: signal_name = "SIGFPE"; break;
 137     case TARGET_SIGKILL: signal_name = "SIGKILL"; break;
 138     case TARGET_SIGSEGV: signal_name = "SIGSEGV"; break;
 139     case TARGET_SIGPIPE: signal_name = "SIGPIPE"; break;
 140     case TARGET_SIGALRM: signal_name = "SIGALRM"; break;
 141     case TARGET_SIGTERM: signal_name = "SIGTERM"; break;
 142     case TARGET_SIGUSR1: signal_name = "SIGUSR1"; break;
 143     case TARGET_SIGUSR2: signal_name = "SIGUSR2"; break;
 144     case TARGET_SIGCHLD: signal_name = "SIGCHLD"; break;
 145     case TARGET_SIGCONT: signal_name = "SIGCONT"; break;
 146     case TARGET_SIGSTOP: signal_name = "SIGSTOP"; break;
 147     case TARGET_SIGTTIN: signal_name = "SIGTTIN"; break;
 148     case TARGET_SIGTTOU: signal_name = "SIGTTOU"; break;
 149     }
 150     if (signal_name == NULL) {
 151         print_raw_param("%ld", arg, last);
 152         return;
 153     }
 154     qemu_log("%s%s", signal_name, get_comma(last));
 155 }
 156
 157 static void print_si_code(int arg)
 158 {
 159     const char *codename = NULL;
 160
 161     switch (arg) {
 162     case SI_USER:
 163         codename = "SI_USER";
 164         break;
 165     case SI_KERNEL:
 166         codename = "SI_KERNEL";
 167         break;
 168     case SI_QUEUE:
 169         codename = "SI_QUEUE";
 170         break;
 171     case SI_TIMER:
 172         codename = "SI_TIMER";
 173         break;
 174     case SI_MESGQ:
 175         codename = "SI_MESGQ";
 176         break;
 177     case SI_ASYNCIO:
 178         codename = "SI_ASYNCIO";
 179         break;
 180     case SI_SIGIO:
 181         codename = "SI_SIGIO";
 182         break;
 183     case SI_TKILL:
 184         codename = "SI_TKILL";
 185         break;
 186     default:
 187         qemu_log("%d", arg);
 188         return;
 189     }
 190     qemu_log("%s", codename);
 191 }
 192
 193 static void get_target_siginfo(target_siginfo_t *tinfo,
 194                                 const target_siginfo_t *info)
 195 {
 196     abi_ulong sival_ptr;
 197
 198     int sig;
 199     int si_errno;
 200     int si_code;
 201     int si_type;
 202
 203     __get_user(sig, &info->si_signo);
 204     __get_user(si_errno, &tinfo->si_errno);
 205     __get_user(si_code, &info->si_code);
 206
 207     tinfo->si_signo = sig;
 208     tinfo->si_errno = si_errno;
 209     tinfo->si_code = si_code;
 210
 211     /* Ensure we don't leak random junk to the guest later */
 212     memset(tinfo->_sifields._pad, 0, sizeof(tinfo->_sifields._pad));
 213
 214     /* This is awkward, because we have to use a combination of
 215      * the si_code and si_signo to figure out which of the union's
 216      * members are valid. (Within the host kernel it is always possible
 217      * to tell, but the kernel carefully avoids giving userspace the
 218      * high 16 bits of si_code, so we don't have the information to
 219      * do this the easy way...) We therefore make our best guess,
 220      * bearing in mind that a guest can spoof most of the si_codes
 221      * via rt_sigqueueinfo() if it likes.
 222      *
 223      * Once we have made our guess, we record it in the top 16 bits of
 224      * the si_code, so that print_siginfo() later can use it.
 225      * print_siginfo() will strip these top bits out before printing
 226      * the si_code.
 227      */
 228
 229     switch (si_code) {
 230     case SI_USER:
 231     case SI_TKILL:
 232     case SI_KERNEL:
 233         /* Sent via kill(), tkill() or tgkill(), or direct from the kernel.
 234          * These are the only unspoofable si_code values.
 235          */
 236         __get_user(tinfo->_sifields._kill._pid, &info->_sifields._kill._pid);
 237         __get_user(tinfo->_sifields._kill._uid, &info->_sifields._kill._uid);
 238         si_type = QEMU_SI_KILL;
 239         break;
 240     default:
 241         /* Everything else is spoofable. Make best guess based on signal */
 242         switch (sig) {
 243         case TARGET_SIGCHLD:
 244             __get_user(tinfo->_sifields._sigchld._pid,
 245                        &info->_sifields._sigchld._pid);
 246             __get_user(tinfo->_sifields._sigchld._uid,
 247                        &info->_sifields._sigchld._uid);
 248             __get_user(tinfo->_sifields._sigchld._status,
 249                        &info->_sifields._sigchld._status);
 250             __get_user(tinfo->_sifields._sigchld._utime,
 251                        &info->_sifields._sigchld._utime);
 252             __get_user(tinfo->_sifields._sigchld._stime,
 253                        &info->_sifields._sigchld._stime);
 254             si_type = QEMU_SI_CHLD;
 255             break;
 256         case TARGET_SIGIO:
 257             __get_user(tinfo->_sifields._sigpoll._band,
 258                        &info->_sifields._sigpoll._band);
 259             __get_user(tinfo->_sifields._sigpoll._fd,
 260                        &info->_sifields._sigpoll._fd);
 261             si_type = QEMU_SI_POLL;
 262             break;
 263         default:
 264             /* Assume a sigqueue()/mq_notify()/rt_sigqueueinfo() source. */
 265             __get_user(tinfo->_sifields._rt._pid, &info->_sifields._rt._pid);
 266             __get_user(tinfo->_sifields._rt._uid, &info->_sifields._rt._uid);
 267             /* XXX: potential problem if 64 bit */
 268             __get_user(sival_ptr, &info->_sifields._rt._sigval.sival_ptr);
 269             tinfo->_sifields._rt._sigval.sival_ptr = sival_ptr;
 270
 271             si_type = QEMU_SI_RT;
 272             break;
 273         }
 274         break;
 275     }
 276
 277     tinfo->si_code = deposit32(si_code, 16, 16, si_type);
 278 }
 279
 280 static void print_siginfo(const target_siginfo_t *tinfo)
 281 {
 282     /* Print a target_siginfo_t in the format desired for printing
 283      * signals being taken. We assume the target_siginfo_t is in the
 284      * internal form where the top 16 bits of si_code indicate which
 285      * part of the union is valid, rather than in the guest-visible
 286      * form where the bottom 16 bits are sign-extended into the top 16.
 287      */
 288     int si_type = extract32(tinfo->si_code, 16, 16);
 289     int si_code = sextract32(tinfo->si_code, 0, 16);
 290
 291     qemu_log("{si_signo=");
 292     print_signal(tinfo->si_signo, 1);
 293     qemu_log(", si_code=");
 294     print_si_code(si_code);
 295
 296     switch (si_type) {
 297     case QEMU_SI_KILL:
 298         qemu_log(", si_pid=%u, si_uid=%u",
 299                  (unsigned int)tinfo->_sifields._kill._pid,
 300                  (unsigned int)tinfo->_sifields._kill._uid);
 301         break;
 302     case QEMU_SI_TIMER:
 303         qemu_log(", si_timer1=%u, si_timer2=%u",
 304                  tinfo->_sifields._timer._timer1,
 305                  tinfo->_sifields._timer._timer2);
 306         break;
 307     case QEMU_SI_POLL:
 308         qemu_log(", si_band=%d, si_fd=%d",
 309                  tinfo->_sifields._sigpoll._band,
 310                  tinfo->_sifields._sigpoll._fd);
 311         break;
 312     case QEMU_SI_FAULT:
 313         qemu_log(", si_addr=");
 314         print_pointer(tinfo->_sifields._sigfault._addr, 1);
 315         break;
 316     case QEMU_SI_CHLD:
 317         qemu_log(", si_pid=%u, si_uid=%u, si_status=%d"
 318                  ", si_utime=" TARGET_ABI_FMT_ld
 319                  ", si_stime=" TARGET_ABI_FMT_ld,
 320                  (unsigned int)(tinfo->_sifields._sigchld._pid),
 321                  (unsigned int)(tinfo->_sifields._sigchld._uid),
 322                  tinfo->_sifields._sigchld._status,
 323                  tinfo->_sifields._sigchld._utime,
 324                  tinfo->_sifields._sigchld._stime);
 325         break;
 326     case QEMU_SI_RT:
 327         qemu_log(", si_pid=%u, si_uid=%u, si_sigval=" TARGET_ABI_FMT_ld,
 328                  (unsigned int)tinfo->_sifields._rt._pid,
 329                  (unsigned int)tinfo->_sifields._rt._uid,
 330                  tinfo->_sifields._rt._sigval.sival_ptr);
 331         break;
 332     default:
 333         g_assert_not_reached();
 334     }
 335     qemu_log("}");
 336 }
 337
 338 static void
 339 print_sockaddr(abi_ulong addr, abi_long addrlen, int last)
 340 {
 341     struct target_sockaddr *sa;
 342     int i;
 343     int sa_family;
 344
 345     sa = lock_user(VERIFY_READ, addr, addrlen, 1);
 346     if (sa) {
 347         sa_family = tswap16(sa->sa_family);
 348         switch (sa_family) {
 349         case AF_UNIX: {
 350             struct target_sockaddr_un *un = (struct target_sockaddr_un *)sa;
 351             int i;
 352             qemu_log("{sun_family=AF_UNIX,sun_path=\"");
 353             for (i = 0; i < addrlen -
 354                             offsetof(struct target_sockaddr_un, sun_path) &&
 355                  un->sun_path[i]; i++) {
 356                 qemu_log("%c", un->sun_path[i]);
 357             }
 358             qemu_log("\"}");
 359             break;
 360         }
 361         case AF_INET: {
 362             struct target_sockaddr_in *in = (struct target_sockaddr_in *)sa;
 363             uint8_t *c = (uint8_t *)&in->sin_addr.s_addr;
 364             qemu_log("{sin_family=AF_INET,sin_port=htons(%d),",
 365                      ntohs(in->sin_port));
 366             qemu_log("sin_addr=inet_addr(\"%d.%d.%d.%d\")",
 367                      c[0], c[1], c[2], c[3]);
 368             qemu_log("}");
 369             break;
 370         }
 371         case AF_PACKET: {
 372             struct target_sockaddr_ll *ll = (struct target_sockaddr_ll *)sa;
 373             uint8_t *c = (uint8_t *)&ll->sll_addr;
 374             qemu_log("{sll_family=AF_PACKET,"
 375                      "sll_protocol=htons(0x%04x),if%d,pkttype=",
 376                      ntohs(ll->sll_protocol), ll->sll_ifindex);
 377             switch (ll->sll_pkttype) {
 378             case PACKET_HOST:
 379                 qemu_log("PACKET_HOST");
 380                 break;
 381             case PACKET_BROADCAST:
 382                 qemu_log("PACKET_BROADCAST");
 383                 break;
 384             case PACKET_MULTICAST:
 385                 qemu_log("PACKET_MULTICAST");
 386                 break;
 387             case PACKET_OTHERHOST:
 388                 qemu_log("PACKET_OTHERHOST");
 389                 break;
 390             case PACKET_OUTGOING:
 391                 qemu_log("PACKET_OUTGOING");
 392                 break;
 393             default:
 394                 qemu_log("%d", ll->sll_pkttype);
 395                 break;
 396             }
 397             qemu_log(",sll_addr=%02x:%02x:%02x:%02x:%02x:%02x:%02x:%02x",
 398                      c[0], c[1], c[2], c[3], c[4], c[5], c[6], c[7]);
 399             qemu_log("}");
 400             break;
 401         }
 402         case AF_NETLINK: {
 403             struct target_sockaddr_nl *nl = (struct target_sockaddr_nl *)sa;
 404             qemu_log("{nl_family=AF_NETLINK,nl_pid=%u,nl_groups=%u}",
 405                      tswap32(nl->nl_pid), tswap32(nl->nl_groups));
 406             break;
 407         }
 408         default:
 409             qemu_log("{sa_family=%d, sa_data={", sa->sa_family);
 410             for (i = 0; i < 13; i++) {
 411                 qemu_log("%02x, ", sa->sa_data[i]);
 412             }
 413             qemu_log("%02x}", sa->sa_data[i]);
 414             qemu_log("}");
 415             break;
 416         }
 417         unlock_user(sa, addr, 0);
 418     } else {
 419         print_raw_param("0x"TARGET_ABI_FMT_lx, addr, 0);
 420     }
 421     qemu_log(", "TARGET_ABI_FMT_ld"%s", addrlen, get_comma(last));
 422 }
 423
 424 static void
 425 print_socket_domain(int domain)
 426 {
 427     switch (domain) {
 428     case PF_UNIX:
 429         qemu_log("PF_UNIX");
 430         break;
 431     case PF_INET:
 432         qemu_log("PF_INET");
 433         break;
 434     case PF_NETLINK:
 435         qemu_log("PF_NETLINK");
 436         break;
 437     case PF_PACKET:
 438         qemu_log("PF_PACKET");
 439         break;
 440     default:
 441         qemu_log("%d", domain);
 442         break;
 443     }
 444 }
 445
 446 static void
 447 print_socket_type(int type)
 448 {
 449     switch (type & TARGET_SOCK_TYPE_MASK) {
 450     case TARGET_SOCK_DGRAM:
 451         qemu_log("SOCK_DGRAM");
 452         break;
 453     case TARGET_SOCK_STREAM:
 454         qemu_log("SOCK_STREAM");
 455         break;
 456     case TARGET_SOCK_RAW:
 457         qemu_log("SOCK_RAW");
 458         break;
 459     case TARGET_SOCK_RDM:
 460         qemu_log("SOCK_RDM");
 461         break;
 462     case TARGET_SOCK_SEQPACKET:
 463         qemu_log("SOCK_SEQPACKET");
 464         break;
 465     case TARGET_SOCK_PACKET:
 466         qemu_log("SOCK_PACKET");
 467         break;
 468     }
 469     if (type & TARGET_SOCK_CLOEXEC) {
 470         qemu_log("|SOCK_CLOEXEC");
 471     }
 472     if (type & TARGET_SOCK_NONBLOCK) {
 473         qemu_log("|SOCK_NONBLOCK");
 474     }
 475 }
 476
 477 static void
 478 print_socket_protocol(int domain, int type, int protocol)
 479 {
 480     if (domain == AF_PACKET ||
 481         (domain == AF_INET && type == TARGET_SOCK_PACKET)) {
 482         switch (protocol) {
 483         case 0x0003:
 484             qemu_log("ETH_P_ALL");
 485             break;
 486         default:
 487             qemu_log("%d", protocol);
 488         }
 489         return;
 490     }
 491
 492     if (domain == PF_NETLINK) {
 493         switch (protocol) {
 494         case NETLINK_ROUTE:
 495             qemu_log("NETLINK_ROUTE");
 496             break;
 497         case NETLINK_AUDIT:
 498             qemu_log("NETLINK_AUDIT");
 499             break;
 500         case NETLINK_NETFILTER:
 501             qemu_log("NETLINK_NETFILTER");
 502             break;
 503         case NETLINK_KOBJECT_UEVENT:
 504             qemu_log("NETLINK_KOBJECT_UEVENT");
 505             break;
 506         case NETLINK_RDMA:
 507             qemu_log("NETLINK_RDMA");
 508             break;
 509         case NETLINK_CRYPTO:
 510             qemu_log("NETLINK_CRYPTO");
 511             break;
 512         default:
 513             qemu_log("%d", protocol);
 514             break;
 515         }
 516         return;
 517     }
 518
 519     switch (protocol) {
 520     case IPPROTO_IP:
 521         qemu_log("IPPROTO_IP");
 522         break;
 523     case IPPROTO_TCP:
 524         qemu_log("IPPROTO_TCP");
 525         break;
 526     case IPPROTO_UDP:
 527         qemu_log("IPPROTO_UDP");
 528         break;
 529     case IPPROTO_RAW:
 530         qemu_log("IPPROTO_RAW");
 531         break;
 532     default:
 533         qemu_log("%d", protocol);
 534         break;
 535     }
 536 }
 537
 538
 539 #ifdef TARGET_NR__newselect
 540 static void
 541 print_fdset(int n, abi_ulong target_fds_addr)
 542 {
 543     int i;
 544
 545     qemu_log("[");
 546     if( target_fds_addr ) {
 547         abi_long *target_fds;
 548
 549         target_fds = lock_user(VERIFY_READ,
 550                                target_fds_addr,
 551                                sizeof(*target_fds)*(n / TARGET_ABI_BITS + 1),
 552                                1);
 553
 554         if (!target_fds)
 555             return;
 556
 557         for (i=n; i>=0; i--) {
 558             if ((tswapal(target_fds[i / TARGET_ABI_BITS]) >> (i & (TARGET_ABI_BITS - 1))) & 1)
 559                 qemu_log("%d,", i);
 560             }
 561         unlock_user(target_fds, target_fds_addr, 0);
 562     }
 563     qemu_log("]");
 564 }
 565 #endif
 566
 567 #ifdef TARGET_NR_clock_adjtime
 568 /* IDs of the various system clocks */
 569 #define TARGET_CLOCK_REALTIME              0
 570 #define TARGET_CLOCK_MONOTONIC             1
 571 #define TARGET_CLOCK_PROCESS_CPUTIME_ID    2
 572 #define TARGET_CLOCK_THREAD_CPUTIME_ID     3
 573 #define TARGET_CLOCK_MONOTONIC_RAW         4
 574 #define TARGET_CLOCK_REALTIME_COARSE       5
 575 #define TARGET_CLOCK_MONOTONIC_COARSE      6
 576 #define TARGET_CLOCK_BOOTTIME              7
 577 #define TARGET_CLOCK_REALTIME_ALARM        8
 578 #define TARGET_CLOCK_BOOTTIME_ALARM        9
 579 #define TARGET_CLOCK_SGI_CYCLE             10
 580 #define TARGET_CLOCK_TAI                   11
 581
 582 static void
 583 print_clockid(int clockid, int last)
 584 {
 585     switch (clockid) {
 586     case TARGET_CLOCK_REALTIME:
 587         qemu_log("CLOCK_REALTIME");
 588         break;
 589     case TARGET_CLOCK_MONOTONIC:
 590         qemu_log("CLOCK_MONOTONIC");
 591         break;
 592     case TARGET_CLOCK_PROCESS_CPUTIME_ID:
 593         qemu_log("CLOCK_PROCESS_CPUTIME_ID");
 594         break;
 595     case TARGET_CLOCK_THREAD_CPUTIME_ID:
 596         qemu_log("CLOCK_THREAD_CPUTIME_ID");
 597         break;
 598     case TARGET_CLOCK_MONOTONIC_RAW:
 599         qemu_log("CLOCK_MONOTONIC_RAW");
 600         break;
 601     case TARGET_CLOCK_REALTIME_COARSE:
 602         qemu_log("CLOCK_REALTIME_COARSE");
 603         break;
 604     case TARGET_CLOCK_MONOTONIC_COARSE:
 605         qemu_log("CLOCK_MONOTONIC_COARSE");
 606         break;
 607     case TARGET_CLOCK_BOOTTIME:
 608         qemu_log("CLOCK_BOOTTIME");
 609         break;
 610     case TARGET_CLOCK_REALTIME_ALARM:
 611         qemu_log("CLOCK_REALTIME_ALARM");
 612         break;
 613     case TARGET_CLOCK_BOOTTIME_ALARM:
 614         qemu_log("CLOCK_BOOTTIME_ALARM");
 615         break;
 616     case TARGET_CLOCK_SGI_CYCLE:
 617         qemu_log("CLOCK_SGI_CYCLE");
 618         break;
 619     case TARGET_CLOCK_TAI:
 620         qemu_log("CLOCK_TAI");
 621         break;
 622     default:
 623         qemu_log("%d", clockid);
 624         break;
 625     }
 626     qemu_log("%s", get_comma(last));
 627 }
 628 #endif
 629
 630 /*
 631  * Sysycall specific output functions
 632  */
 633
 634 /* select */
 635 #ifdef TARGET_NR__newselect
 636 static void
 637 print_newselect(const struct syscallname *name,
 638                 abi_long arg1, abi_long arg2, abi_long arg3,
 639                 abi_long arg4, abi_long arg5, abi_long arg6)
 640 {
 641     print_syscall_prologue(name);
 642     print_fdset(arg1, arg2);
 643     qemu_log(",");
 644     print_fdset(arg1, arg3);
 645     qemu_log(",");
 646     print_fdset(arg1, arg4);
 647     qemu_log(",");
 648     print_timeval(arg5, 1);
 649     print_syscall_epilogue(name);
 650 }
 651 #endif
 652
 653 #ifdef TARGET_NR_semctl
 654 static void
 655 print_semctl(const struct syscallname *name,
 656              abi_long arg1, abi_long arg2, abi_long arg3,
 657              abi_long arg4, abi_long arg5, abi_long arg6)
 658 {
 659     qemu_log("%s(" TARGET_ABI_FMT_ld "," TARGET_ABI_FMT_ld ",",
 660              name->name, arg1, arg2);
 661     print_ipc_cmd(arg3);
 662     qemu_log(",0x" TARGET_ABI_FMT_lx ")", arg4);
 663 }
 664 #endif
 665
 666 static void
 667 print_execve(const struct syscallname *name,
 668              abi_long arg1, abi_long arg2, abi_long arg3,
 669              abi_long arg4, abi_long arg5, abi_long arg6)
 670 {
 671     abi_ulong arg_ptr_addr;
 672     char *s;
 673
 674     if (!(s = lock_user_string(arg1)))
 675         return;
 676     qemu_log("%s(\"%s\",{", name->name, s);
 677     unlock_user(s, arg1, 0);
 678
 679     for (arg_ptr_addr = arg2; ; arg_ptr_addr += sizeof(abi_ulong)) {
 680         abi_ulong *arg_ptr, arg_addr;
 681
 682         arg_ptr = lock_user(VERIFY_READ, arg_ptr_addr, sizeof(abi_ulong), 1);
 683         if (!arg_ptr)
 684             return;
 685     arg_addr = tswapal(*arg_ptr);
 686         unlock_user(arg_ptr, arg_ptr_addr, 0);
 687         if (!arg_addr)
 688             break;
 689         if ((s = lock_user_string(arg_addr))) {
 690             qemu_log("\"%s\",", s);
 691             unlock_user(s, arg_addr, 0);
 692         }
 693     }
 694
 695     qemu_log("NULL})");
 696 }
 697
 698 #ifdef TARGET_NR_ipc
 699 static void
 700 print_ipc(const struct syscallname *name,
 701           abi_long arg1, abi_long arg2, abi_long arg3,
 702           abi_long arg4, abi_long arg5, abi_long arg6)
 703 {
 704     switch(arg1) {
 705     case IPCOP_semctl:
 706         qemu_log("semctl(" TARGET_ABI_FMT_ld "," TARGET_ABI_FMT_ld ",",
 707                  arg1, arg2);
 708         print_ipc_cmd(arg3);
 709         qemu_log(",0x" TARGET_ABI_FMT_lx ")", arg4);
 710         break;
 711     default:
 712         qemu_log(("%s("
 713                   TARGET_ABI_FMT_ld ","
 714                   TARGET_ABI_FMT_ld ","
 715                   TARGET_ABI_FMT_ld ","
 716                   TARGET_ABI_FMT_ld
 717                   ")"),
 718                  name->name, arg1, arg2, arg3, arg4);
 719     }
 720 }
 721 #endif
 722
 723 /*
 724  * Variants for the return value output function
 725  */
 726
 727 static bool
 728 print_syscall_err(abi_long ret)
 729 {
 730     const char *errstr;
 731
 732     qemu_log(" = ");
 733     if (ret < 0) {
 734         errstr = target_strerror(-ret);
 735         if (errstr) {
 736             qemu_log("-1 errno=%d (%s)", (int)-ret, errstr);
 737             return true;
 738         }
 739     }
 740     return false;
 741 }
 742
 743 static void
 744 print_syscall_ret_addr(const struct syscallname *name, abi_long ret,
 745                        abi_long arg0, abi_long arg1, abi_long arg2,
 746                        abi_long arg3, abi_long arg4, abi_long arg5)
 747 {
 748     if (!print_syscall_err(ret)) {
 749         qemu_log("0x" TARGET_ABI_FMT_lx, ret);
 750     }
 751     qemu_log("\n");
 752 }
 753
 754 #if 0 /* currently unused */
 755 static void
 756 print_syscall_ret_raw(struct syscallname *name, abi_long ret)
 757 {
 758         qemu_log(" = 0x" TARGET_ABI_FMT_lx "\n", ret);
 759 }
 760 #endif
 761
 762 #ifdef TARGET_NR__newselect
 763 static void
 764 print_syscall_ret_newselect(const struct syscallname *name, abi_long ret,
 765                             abi_long arg0, abi_long arg1, abi_long arg2,
 766                             abi_long arg3, abi_long arg4, abi_long arg5)
 767 {
 768     if (!print_syscall_err(ret)) {
 769         qemu_log(" = 0x" TARGET_ABI_FMT_lx " (", ret);
 770         print_fdset(arg0, arg1);
 771         qemu_log(",");
 772         print_fdset(arg0, arg2);
 773         qemu_log(",");
 774         print_fdset(arg0, arg3);
 775         qemu_log(",");
 776         print_timeval(arg4, 1);
 777         qemu_log(")");
 778     }
 779
 780     qemu_log("\n");
 781 }
 782 #endif
 783
 784 /* special meanings of adjtimex()' non-negative return values */
 785 #define TARGET_TIME_OK       0   /* clock synchronized, no leap second */
 786 #define TARGET_TIME_INS      1   /* insert leap second */
 787 #define TARGET_TIME_DEL      2   /* delete leap second */
 788 #define TARGET_TIME_OOP      3   /* leap second in progress */
 789 #define TARGET_TIME_WAIT     4   /* leap second has occurred */
 790 #define TARGET_TIME_ERROR    5   /* clock not synchronized */
 791 #ifdef TARGET_NR_adjtimex
 792 static void
 793 print_syscall_ret_adjtimex(const struct syscallname *name, abi_long ret,
 794                            abi_long arg0, abi_long arg1, abi_long arg2,
 795                            abi_long arg3, abi_long arg4, abi_long arg5)
 796 {
 797     if (!print_syscall_err(ret)) {
 798         qemu_log(TARGET_ABI_FMT_ld, ret);
 799         switch (ret) {
 800         case TARGET_TIME_OK:
 801             qemu_log(" TIME_OK (clock synchronized, no leap second)");
 802             break;
 803         case TARGET_TIME_INS:
 804             qemu_log(" TIME_INS (insert leap second)");
 805             break;
 806         case TARGET_TIME_DEL:
 807             qemu_log(" TIME_DEL (delete leap second)");
 808             break;
 809         case TARGET_TIME_OOP:
 810             qemu_log(" TIME_OOP (leap second in progress)");
 811             break;
 812         case TARGET_TIME_WAIT:
 813             qemu_log(" TIME_WAIT (leap second has occurred)");
 814             break;
 815         case TARGET_TIME_ERROR:
 816             qemu_log(" TIME_ERROR (clock not synchronized)");
 817             break;
 818         }
 819     }
 820
 821     qemu_log("\n");
 822 }
 823 #endif
 824
 825 #if defined(TARGET_NR_listxattr) || defined(TARGET_NR_llistxattr) \
 826  || defined(TARGGET_NR_flistxattr)
 827 static void
 828 print_syscall_ret_listxattr(const struct syscallname *name, abi_long ret,
 829                             abi_long arg0, abi_long arg1, abi_long arg2,
 830                             abi_long arg3, abi_long arg4, abi_long arg5)
 831 {
 832     if (!print_syscall_err(ret)) {
 833         qemu_log(TARGET_ABI_FMT_ld, ret);
 834         qemu_log(" (list = ");
 835         if (arg1 != 0) {
 836             abi_long attr = arg1;
 837             while (ret) {
 838                 if (attr != arg1) {
 839                     qemu_log(",");
 840                 }
 841                 print_string(attr, 1);
 842                 ret -= target_strlen(attr) + 1;
 843                 attr += target_strlen(attr) + 1;
 844             }
 845         } else {
 846             qemu_log("NULL");
 847         }
 848         qemu_log(")");
 849     }
 850
 851     qemu_log("\n");
 852 }
 853 #define print_syscall_ret_llistxattr     print_syscall_ret_listxattr
 854 #define print_syscall_ret_flistxattr     print_syscall_ret_listxattr
 855 #endif
 856
 857 #ifdef TARGET_NR_ioctl
 858 static void
 859 print_syscall_ret_ioctl(const struct syscallname *name, abi_long ret,
 860                         abi_long arg0, abi_long arg1, abi_long arg2,
 861                         abi_long arg3, abi_long arg4, abi_long arg5)
 862 {
 863     if (!print_syscall_err(ret)) {
 864         qemu_log(TARGET_ABI_FMT_ld, ret);
 865
 866         const IOCTLEntry *ie;
 867         const argtype *arg_type;
 868         void *argptr;
 869         int target_size;
 870
 871         for (ie = ioctl_entries; ie->target_cmd != 0; ie++) {
 872             if (ie->target_cmd == arg1) {
 873                 break;
 874             }
 875         }
 876
 877         if (ie->target_cmd == arg1 &&
 878            (ie->access == IOC_R || ie->access == IOC_RW)) {
 879             arg_type = ie->arg_type;
 880             qemu_log(" (");
 881             arg_type++;
 882             target_size = thunk_type_size(arg_type, 0);
 883             argptr = lock_user(VERIFY_READ, arg2, target_size, 1);
 884             if (argptr) {
 885                 thunk_print(argptr, arg_type);
 886                 unlock_user(argptr, arg2, target_size);
 887             } else {
 888                 print_pointer(arg2, 1);
 889             }
 890             qemu_log(")");
 891         }
 892     }
 893     qemu_log("\n");
 894 }
 895 #endif
 896
 897 UNUSED static struct flags access_flags[] = {
 898     FLAG_GENERIC(F_OK),
 899     FLAG_GENERIC(R_OK),
 900     FLAG_GENERIC(W_OK),
 901     FLAG_GENERIC(X_OK),
 902     FLAG_END,
 903 };
 904
 905 UNUSED static struct flags at_file_flags[] = {
 906 #ifdef AT_EACCESS
 907     FLAG_GENERIC(AT_EACCESS),
 908 #endif
 909 #ifdef AT_SYMLINK_NOFOLLOW
 910     FLAG_GENERIC(AT_SYMLINK_NOFOLLOW),
 911 #endif
 912     FLAG_END,
 913 };
 914
 915 UNUSED static struct flags unlinkat_flags[] = {
 916 #ifdef AT_REMOVEDIR
 917     FLAG_GENERIC(AT_REMOVEDIR),
 918 #endif
 919     FLAG_END,
 920 };
 921
 922 UNUSED static struct flags mode_flags[] = {
 923     FLAG_GENERIC(S_IFSOCK),
 924     FLAG_GENERIC(S_IFLNK),
 925     FLAG_GENERIC(S_IFREG),
 926     FLAG_GENERIC(S_IFBLK),
 927     FLAG_GENERIC(S_IFDIR),
 928     FLAG_GENERIC(S_IFCHR),
 929     FLAG_GENERIC(S_IFIFO),
 930     FLAG_END,
 931 };
 932
 933 UNUSED static struct flags open_access_flags[] = {
 934     FLAG_TARGET(O_RDONLY),
 935     FLAG_TARGET(O_WRONLY),
 936     FLAG_TARGET(O_RDWR),
 937     FLAG_END,
 938 };
 939
 940 UNUSED static struct flags open_flags[] = {
 941     FLAG_TARGET(O_APPEND),
 942     FLAG_TARGET(O_CREAT),
 943     FLAG_TARGET(O_DIRECTORY),
 944     FLAG_TARGET(O_EXCL),
 945     FLAG_TARGET(O_LARGEFILE),
 946     FLAG_TARGET(O_NOCTTY),
 947     FLAG_TARGET(O_NOFOLLOW),
 948     FLAG_TARGET(O_NONBLOCK),      /* also O_NDELAY */
 949     FLAG_TARGET(O_DSYNC),
 950     FLAG_TARGET(__O_SYNC),
 951     FLAG_TARGET(O_TRUNC),
 952 #ifdef O_DIRECT
 953     FLAG_TARGET(O_DIRECT),
 954 #endif
 955 #ifdef O_NOATIME
 956     FLAG_TARGET(O_NOATIME),
 957 #endif
 958 #ifdef O_CLOEXEC
 959     FLAG_TARGET(O_CLOEXEC),
 960 #endif
 961 #ifdef O_PATH
 962     FLAG_TARGET(O_PATH),
 963 #endif
 964 #ifdef O_TMPFILE
 965     FLAG_TARGET(O_TMPFILE),
 966     FLAG_TARGET(__O_TMPFILE),
 967 #endif
 968     FLAG_END,
 969 };
 970
 971 UNUSED static struct flags mount_flags[] = {
 972 #ifdef MS_BIND
 973     FLAG_GENERIC(MS_BIND),
 974 #endif
 975 #ifdef MS_DIRSYNC
 976     FLAG_GENERIC(MS_DIRSYNC),
 977 #endif
 978     FLAG_GENERIC(MS_MANDLOCK),
 979 #ifdef MS_MOVE
 980     FLAG_GENERIC(MS_MOVE),
 981 #endif
 982     FLAG_GENERIC(MS_NOATIME),
 983     FLAG_GENERIC(MS_NODEV),
 984     FLAG_GENERIC(MS_NODIRATIME),
 985     FLAG_GENERIC(MS_NOEXEC),
 986     FLAG_GENERIC(MS_NOSUID),
 987     FLAG_GENERIC(MS_RDONLY),
 988 #ifdef MS_RELATIME
 989     FLAG_GENERIC(MS_RELATIME),
 990 #endif
 991     FLAG_GENERIC(MS_REMOUNT),
 992     FLAG_GENERIC(MS_SYNCHRONOUS),
 993     FLAG_END,
 994 };
 995
 996 UNUSED static struct flags umount2_flags[] = {
 997 #ifdef MNT_FORCE
 998     FLAG_GENERIC(MNT_FORCE),
 999 #endif
1000 #ifdef MNT_DETACH
1001     FLAG_GENERIC(MNT_DETACH),
1002 #endif
1003 #ifdef MNT_EXPIRE
1004     FLAG_GENERIC(MNT_EXPIRE),
1005 #endif
1006     FLAG_END,
1007 };
1008
1009 UNUSED static struct flags mmap_prot_flags[] = {
1010     FLAG_GENERIC(PROT_NONE),
1011     FLAG_GENERIC(PROT_EXEC),
1012     FLAG_GENERIC(PROT_READ),
1013     FLAG_GENERIC(PROT_WRITE),
1014     FLAG_TARGET(PROT_SEM),
1015     FLAG_GENERIC(PROT_GROWSDOWN),
1016     FLAG_GENERIC(PROT_GROWSUP),
1017     FLAG_END,
1018 };
1019
1020 UNUSED static struct flags mmap_flags[] = {
1021     FLAG_TARGET(MAP_SHARED),
1022     FLAG_TARGET(MAP_PRIVATE),
1023     FLAG_TARGET(MAP_ANONYMOUS),
1024     FLAG_TARGET(MAP_DENYWRITE),
1025     FLAG_TARGET(MAP_FIXED),
1026     FLAG_TARGET(MAP_GROWSDOWN),
1027     FLAG_TARGET(MAP_EXECUTABLE),
1028 #ifdef MAP_LOCKED
1029     FLAG_TARGET(MAP_LOCKED),
1030 #endif
1031 #ifdef MAP_NONBLOCK
1032     FLAG_TARGET(MAP_NONBLOCK),
1033 #endif
1034     FLAG_TARGET(MAP_NORESERVE),
1035 #ifdef MAP_POPULATE
1036     FLAG_TARGET(MAP_POPULATE),
1037 #endif
1038 #ifdef TARGET_MAP_UNINITIALIZED
1039     FLAG_TARGET(MAP_UNINITIALIZED),
1040 #endif
1041     FLAG_END,
1042 };
1043
1044 UNUSED static struct flags clone_flags[] = {
1045     FLAG_GENERIC(CLONE_VM),
1046     FLAG_GENERIC(CLONE_FS),
1047     FLAG_GENERIC(CLONE_FILES),
1048     FLAG_GENERIC(CLONE_SIGHAND),
1049     FLAG_GENERIC(CLONE_PTRACE),
1050     FLAG_GENERIC(CLONE_VFORK),
1051     FLAG_GENERIC(CLONE_PARENT),
1052     FLAG_GENERIC(CLONE_THREAD),
1053     FLAG_GENERIC(CLONE_NEWNS),
1054     FLAG_GENERIC(CLONE_SYSVSEM),
1055     FLAG_GENERIC(CLONE_SETTLS),
1056     FLAG_GENERIC(CLONE_PARENT_SETTID),
1057     FLAG_GENERIC(CLONE_CHILD_CLEARTID),
1058     FLAG_GENERIC(CLONE_DETACHED),
1059     FLAG_GENERIC(CLONE_UNTRACED),
1060     FLAG_GENERIC(CLONE_CHILD_SETTID),
1061 #if defined(CLONE_NEWUTS)
1062     FLAG_GENERIC(CLONE_NEWUTS),
1063 #endif
1064 #if defined(CLONE_NEWIPC)
1065     FLAG_GENERIC(CLONE_NEWIPC),
1066 #endif
1067 #if defined(CLONE_NEWUSER)
1068     FLAG_GENERIC(CLONE_NEWUSER),
1069 #endif
1070 #if defined(CLONE_NEWPID)
1071     FLAG_GENERIC(CLONE_NEWPID),
1072 #endif
1073 #if defined(CLONE_NEWNET)
1074     FLAG_GENERIC(CLONE_NEWNET),
1075 #endif
1076 #if defined(CLONE_IO)
1077     FLAG_GENERIC(CLONE_IO),
1078 #endif
1079     FLAG_END,
1080 };
1081
1082 UNUSED static struct flags msg_flags[] = {
1083     /* send */
1084     FLAG_GENERIC(MSG_CONFIRM),
1085     FLAG_GENERIC(MSG_DONTROUTE),
1086     FLAG_GENERIC(MSG_DONTWAIT),
1087     FLAG_GENERIC(MSG_EOR),
1088     FLAG_GENERIC(MSG_MORE),
1089     FLAG_GENERIC(MSG_NOSIGNAL),
1090     FLAG_GENERIC(MSG_OOB),
1091     /* recv */
1092     FLAG_GENERIC(MSG_CMSG_CLOEXEC),
1093     FLAG_GENERIC(MSG_ERRQUEUE),
1094     FLAG_GENERIC(MSG_PEEK),
1095     FLAG_GENERIC(MSG_TRUNC),
1096     FLAG_GENERIC(MSG_WAITALL),
1097     /* recvmsg */
1098     FLAG_GENERIC(MSG_CTRUNC),
1099     FLAG_END,
1100 };
1101
1102 UNUSED static struct flags statx_flags[] = {
1103 #ifdef AT_EMPTY_PATH
1104     FLAG_GENERIC(AT_EMPTY_PATH),
1105 #endif
1106 #ifdef AT_NO_AUTOMOUNT
1107     FLAG_GENERIC(AT_NO_AUTOMOUNT),
1108 #endif
1109 #ifdef AT_SYMLINK_NOFOLLOW
1110     FLAG_GENERIC(AT_SYMLINK_NOFOLLOW),
1111 #endif
1112 #ifdef AT_STATX_SYNC_AS_STAT
1113     FLAG_GENERIC(AT_STATX_SYNC_AS_STAT),
1114 #endif
1115 #ifdef AT_STATX_FORCE_SYNC
1116     FLAG_GENERIC(AT_STATX_FORCE_SYNC),
1117 #endif
1118 #ifdef AT_STATX_DONT_SYNC
1119     FLAG_GENERIC(AT_STATX_DONT_SYNC),
1120 #endif
1121     FLAG_END,
1122 };
1123
1124 UNUSED static struct flags statx_mask[] = {
1125 /* This must come first, because it includes everything.  */
1126 #ifdef STATX_ALL
1127     FLAG_GENERIC(STATX_ALL),
1128 #endif
1129 /* This must come second; it includes everything except STATX_BTIME.  */
1130 #ifdef STATX_BASIC_STATS
1131     FLAG_GENERIC(STATX_BASIC_STATS),
1132 #endif
1133 #ifdef STATX_TYPE
1134     FLAG_GENERIC(STATX_TYPE),
1135 #endif
1136 #ifdef STATX_MODE
1137     FLAG_GENERIC(STATX_MODE),
1138 #endif
1139 #ifdef STATX_NLINK
1140     FLAG_GENERIC(STATX_NLINK),
1141 #endif
1142 #ifdef STATX_UID
1143     FLAG_GENERIC(STATX_UID),
1144 #endif
1145 #ifdef STATX_GID
1146     FLAG_GENERIC(STATX_GID),
1147 #endif
1148 #ifdef STATX_ATIME
1149     FLAG_GENERIC(STATX_ATIME),
1150 #endif
1151 #ifdef STATX_MTIME
1152     FLAG_GENERIC(STATX_MTIME),
1153 #endif
1154 #ifdef STATX_CTIME
1155     FLAG_GENERIC(STATX_CTIME),
1156 #endif
1157 #ifdef STATX_INO
1158     FLAG_GENERIC(STATX_INO),
1159 #endif
1160 #ifdef STATX_SIZE
1161     FLAG_GENERIC(STATX_SIZE),
1162 #endif
1163 #ifdef STATX_BLOCKS
1164     FLAG_GENERIC(STATX_BLOCKS),
1165 #endif
1166 #ifdef STATX_BTIME
1167     FLAG_GENERIC(STATX_BTIME),
1168 #endif
1169     FLAG_END,
1170 };
1171
1172 UNUSED static struct flags falloc_flags[] = {
1173     FLAG_GENERIC(FALLOC_FL_KEEP_SIZE),
1174     FLAG_GENERIC(FALLOC_FL_PUNCH_HOLE),
1175 #ifdef FALLOC_FL_NO_HIDE_STALE
1176     FLAG_GENERIC(FALLOC_FL_NO_HIDE_STALE),
1177 #endif
1178 #ifdef FALLOC_FL_COLLAPSE_RANGE
1179     FLAG_GENERIC(FALLOC_FL_COLLAPSE_RANGE),
1180 #endif
1181 #ifdef FALLOC_FL_ZERO_RANGE
1182     FLAG_GENERIC(FALLOC_FL_ZERO_RANGE),
1183 #endif
1184 #ifdef FALLOC_FL_INSERT_RANGE
1185     FLAG_GENERIC(FALLOC_FL_INSERT_RANGE),
1186 #endif
1187 #ifdef FALLOC_FL_UNSHARE_RANGE
1188     FLAG_GENERIC(FALLOC_FL_UNSHARE_RANGE),
1189 #endif
1190 };
1191
1192 /*
1193  * print_xxx utility functions.  These are used to print syscall
1194  * parameters in certain format.  All of these have parameter
1195  * named 'last'.  This parameter is used to add comma to output
1196  * when last == 0.
1197  */
1198
1199 static const char *
1200 get_comma(int last)
1201 {
1202     return ((last) ? "" : ",");
1203 }
1204
1205 static void
1206 print_flags(const struct flags *f, abi_long flags, int last)
1207 {
1208     const char *sep = "";
1209     int n;
1210
1211     if ((flags == 0) && (f->f_value == 0)) {
1212         qemu_log("%s%s", f->f_string, get_comma(last));
1213         return;
1214     }
1215     for (n = 0; f->f_string != NULL; f++) {
1216         if ((f->f_value != 0) && ((flags & f->f_value) == f->f_value)) {
1217             qemu_log("%s%s", sep, f->f_string);
1218             flags &= ~f->f_value;
1219             sep = "|";
1220             n++;
1221         }
1222     }
1223
1224     if (n > 0) {
1225         /* print rest of the flags as numeric */
1226         if (flags != 0) {
1227             qemu_log("%s%#x%s", sep, (unsigned int)flags, get_comma(last));
1228         } else {
1229             qemu_log("%s", get_comma(last));
1230         }
1231     } else {
1232         /* no string version of flags found, print them in hex then */
1233         qemu_log("%#x%s", (unsigned int)flags, get_comma(last));
1234     }
1235 }
1236
1237 static void
1238 print_at_dirfd(abi_long dirfd, int last)
1239 {
1240 #ifdef AT_FDCWD
1241     if (dirfd == AT_FDCWD) {
1242         qemu_log("AT_FDCWD%s", get_comma(last));
1243         return;
1244     }
1245 #endif
1246     qemu_log("%d%s", (int)dirfd, get_comma(last));
1247 }
1248
1249 static void
1250 print_file_mode(abi_long mode, int last)
1251 {
1252     const char *sep = "";
1253     const struct flags *m;
1254
1255     for (m = &mode_flags[0]; m->f_string != NULL; m++) {
1256         if ((m->f_value & mode) == m->f_value) {
1257             qemu_log("%s%s", m->f_string, sep);
1258             sep = "|";
1259             mode &= ~m->f_value;
1260             break;
1261         }
1262     }
1263
1264     mode &= ~S_IFMT;
1265     /* print rest of the mode as octal */
1266     if (mode != 0)
1267         qemu_log("%s%#o", sep, (unsigned int)mode);
1268
1269     qemu_log("%s", get_comma(last));
1270 }
1271
1272 static void
1273 print_open_flags(abi_long flags, int last)
1274 {
1275     print_flags(open_access_flags, flags & TARGET_O_ACCMODE, 1);
1276     flags &= ~TARGET_O_ACCMODE;
1277     if (flags == 0) {
1278         qemu_log("%s", get_comma(last));
1279         return;
1280     }
1281     qemu_log("|");
1282     print_flags(open_flags, flags, last);
1283 }
1284
1285 static void
1286 print_syscall_prologue(const struct syscallname *sc)
1287 {
1288     qemu_log("%s(", sc->name);
1289 }
1290
1291 /*ARGSUSED*/
1292 static void
1293 print_syscall_epilogue(const struct syscallname *sc)
1294 {
1295     (void)sc;
1296     qemu_log(")");
1297 }
1298
1299 static void
1300 print_string(abi_long addr, int last)
1301 {
1302     char *s;
1303
1304     if ((s = lock_user_string(addr)) != NULL) {
1305         qemu_log("\"%s\"%s", s, get_comma(last));
1306         unlock_user(s, addr, 0);
1307     } else {
1308         /* can't get string out of it, so print it as pointer */
1309         print_pointer(addr, last);
1310     }
1311 }
1312
1313 #define MAX_PRINT_BUF 40
1314 static void
1315 print_buf(abi_long addr, abi_long len, int last)
1316 {
1317     uint8_t *s;
1318     int i;
1319
1320     s = lock_user(VERIFY_READ, addr, len, 1);
1321     if (s) {
1322         qemu_log("\"");
1323         for (i = 0; i < MAX_PRINT_BUF && i < len; i++) {
1324             if (isprint(s[i])) {
1325                 qemu_log("%c", s[i]);
1326             } else {
1327                 qemu_log("\\%o", s[i]);
1328             }
1329         }
1330         qemu_log("\"");
1331         if (i != len) {
1332             qemu_log("...");
1333         }
1334         if (!last) {
1335             qemu_log(",");
1336         }
1337         unlock_user(s, addr, 0);
1338     } else {
1339         print_pointer(addr, last);
1340     }
1341 }
1342
1343 /*
1344  * Prints out raw parameter using given format.  Caller needs
1345  * to do byte swapping if needed.
1346  */
1347 static void
1348 print_raw_param(const char *fmt, abi_long param, int last)
1349 {
1350     char format[64];
1351
1352     (void) snprintf(format, sizeof (format), "%s%s", fmt, get_comma(last));
1353     qemu_log(format, param);
1354 }
1355
1356 static void
1357 print_pointer(abi_long p, int last)
1358 {
1359     if (p == 0)
1360         qemu_log("NULL%s", get_comma(last));
1361     else
1362         qemu_log("0x" TARGET_ABI_FMT_lx "%s", p, get_comma(last));
1363 }
1364
1365 /*
1366  * Reads 32-bit (int) number from guest address space from
1367  * address 'addr' and prints it.
1368  */
1369 static void
1370 print_number(abi_long addr, int last)
1371 {
1372     if (addr == 0) {
1373         qemu_log("NULL%s", get_comma(last));
1374     } else {
1375         int num;
1376
1377         get_user_s32(num, addr);
1378         qemu_log("[%d]%s", num, get_comma(last));
1379     }
1380 }
1381
1382 static void
1383 print_timeval(abi_ulong tv_addr, int last)
1384 {
1385     if( tv_addr ) {
1386         struct target_timeval *tv;
1387
1388         tv = lock_user(VERIFY_READ, tv_addr, sizeof(*tv), 1);
1389         if (!tv) {
1390             print_pointer(tv_addr, last);
1391             return;
1392         }
1393         qemu_log("{" TARGET_ABI_FMT_ld "," TARGET_ABI_FMT_ld "}%s",
1394             tswapal(tv->tv_sec), tswapal(tv->tv_usec), get_comma(last));
1395         unlock_user(tv, tv_addr, 0);
1396     } else
1397         qemu_log("NULL%s", get_comma(last));
1398 }
1399
1400 static void
1401 print_timezone(abi_ulong tz_addr, int last)
1402 {
1403     if (tz_addr) {
1404         struct target_timezone *tz;
1405
1406         tz = lock_user(VERIFY_READ, tz_addr, sizeof(*tz), 1);
1407         if (!tz) {
1408             print_pointer(tz_addr, last);
1409             return;
1410         }
1411         qemu_log("{%d,%d}%s", tswap32(tz->tz_minuteswest),
1412                  tswap32(tz->tz_dsttime), get_comma(last));
1413         unlock_user(tz, tz_addr, 0);
1414     } else {
1415         qemu_log("NULL%s", get_comma(last));
1416     }
1417 }
1418
1419 #undef UNUSED
1420
1421 #ifdef TARGET_NR_accept
1422 static void
1423 print_accept(const struct syscallname *name,
1424     abi_long arg0, abi_long arg1, abi_long arg2,
1425     abi_long arg3, abi_long arg4, abi_long arg5)
1426 {
1427     print_syscall_prologue(name);
1428     print_raw_param("%d", arg0, 0);
1429     print_pointer(arg1, 0);
1430     print_number(arg2, 1);
1431     print_syscall_epilogue(name);
1432 }
1433 #endif
1434
1435 #ifdef TARGET_NR_access
1436 static void
1437 print_access(const struct syscallname *name,
1438     abi_long arg0, abi_long arg1, abi_long arg2,
1439     abi_long arg3, abi_long arg4, abi_long arg5)
1440 {
1441     print_syscall_prologue(name);
1442     print_string(arg0, 0);
1443     print_flags(access_flags, arg1, 1);
1444     print_syscall_epilogue(name);
1445 }
1446 #endif
1447
1448 #ifdef TARGET_NR_acct
1449 static void
1450 print_acct(const struct syscallname *name,
1451     abi_long arg0, abi_long arg1, abi_long arg2,
1452     abi_long arg3, abi_long arg4, abi_long arg5)
1453 {
1454     print_syscall_prologue(name);
1455     print_string(arg0, 1);
1456     print_syscall_epilogue(name);
1457 }
1458 #endif
1459
1460 #ifdef TARGET_NR_brk
1461 static void
1462 print_brk(const struct syscallname *name,
1463     abi_long arg0, abi_long arg1, abi_long arg2,
1464     abi_long arg3, abi_long arg4, abi_long arg5)
1465 {
1466     print_syscall_prologue(name);
1467     print_pointer(arg0, 1);
1468     print_syscall_epilogue(name);
1469 }
1470 #endif
1471
1472 #ifdef TARGET_NR_chdir
1473 static void
1474 print_chdir(const struct syscallname *name,
1475     abi_long arg0, abi_long arg1, abi_long arg2,
1476     abi_long arg3, abi_long arg4, abi_long arg5)
1477 {
1478     print_syscall_prologue(name);
1479     print_string(arg0, 1);
1480     print_syscall_epilogue(name);
1481 }
1482 #endif
1483
1484 #ifdef TARGET_NR_chroot
1485 static void
1486 print_chroot(const struct syscallname *name,
1487     abi_long arg0, abi_long arg1, abi_long arg2,
1488     abi_long arg3, abi_long arg4, abi_long arg5)
1489 {
1490     print_syscall_prologue(name);
1491     print_string(arg0, 1);
1492     print_syscall_epilogue(name);
1493 }
1494 #endif
1495
1496 #ifdef TARGET_NR_chmod
1497 static void
1498 print_chmod(const struct syscallname *name,
1499     abi_long arg0, abi_long arg1, abi_long arg2,
1500     abi_long arg3, abi_long arg4, abi_long arg5)
1501 {
1502     print_syscall_prologue(name);
1503     print_string(arg0, 0);
1504     print_file_mode(arg1, 1);
1505     print_syscall_epilogue(name);
1506 }
1507 #endif
1508
1509 #if defined(TARGET_NR_chown) || defined(TARGET_NR_lchown)
1510 static void
1511 print_chown(const struct syscallname *name,
1512     abi_long arg0, abi_long arg1, abi_long arg2,
1513     abi_long arg3, abi_long arg4, abi_long arg5)
1514 {
1515     print_syscall_prologue(name);
1516     print_string(arg0, 0);
1517     print_raw_param("%d", arg1, 0);
1518     print_raw_param("%d", arg2, 1);
1519     print_syscall_epilogue(name);
1520 }
1521 #define print_lchown     print_chown
1522 #endif
1523
1524 #ifdef TARGET_NR_clock_adjtime
1525 static void
1526 print_clock_adjtime(const struct syscallname *name,
1527     abi_long arg0, abi_long arg1, abi_long arg2,
1528     abi_long arg3, abi_long arg4, abi_long arg5)
1529 {
1530     print_syscall_prologue(name);
1531     print_clockid(arg0, 0);
1532     print_pointer(arg1, 1);
1533     print_syscall_epilogue(name);
1534 }
1535 #endif
1536
1537 #ifdef TARGET_NR_clone
1538 static void do_print_clone(unsigned int flags, abi_ulong newsp,
1539                            abi_ulong parent_tidptr, target_ulong newtls,
1540                            abi_ulong child_tidptr)
1541 {
1542     print_flags(clone_flags, flags, 0);
1543     print_raw_param("child_stack=0x" TARGET_ABI_FMT_lx, newsp, 0);
1544     print_raw_param("parent_tidptr=0x" TARGET_ABI_FMT_lx, parent_tidptr, 0);
1545     print_raw_param("tls=0x" TARGET_ABI_FMT_lx, newtls, 0);
1546     print_raw_param("child_tidptr=0x" TARGET_ABI_FMT_lx, child_tidptr, 1);
1547 }
1548
1549 static void
1550 print_clone(const struct syscallname *name,
1551     abi_long arg1, abi_long arg2, abi_long arg3,
1552     abi_long arg4, abi_long arg5, abi_long arg6)
1553 {
1554     print_syscall_prologue(name);
1555 #if defined(TARGET_MICROBLAZE)
1556     do_print_clone(arg1, arg2, arg4, arg6, arg5);
1557 #elif defined(TARGET_CLONE_BACKWARDS)
1558     do_print_clone(arg1, arg2, arg3, arg4, arg5);
1559 #elif defined(TARGET_CLONE_BACKWARDS2)
1560     do_print_clone(arg2, arg1, arg3, arg5, arg4);
1561 #else
1562     do_print_clone(arg1, arg2, arg3, arg5, arg4);
1563 #endif
1564     print_syscall_epilogue(name);
1565 }
1566 #endif
1567
1568 #ifdef TARGET_NR_creat
1569 static void
1570 print_creat(const struct syscallname *name,
1571     abi_long arg0, abi_long arg1, abi_long arg2,
1572     abi_long arg3, abi_long arg4, abi_long arg5)
1573 {
1574     print_syscall_prologue(name);
1575     print_string(arg0, 0);
1576     print_file_mode(arg1, 1);
1577     print_syscall_epilogue(name);
1578 }
1579 #endif
1580
1581 #ifdef TARGET_NR_execv
1582 static void
1583 print_execv(const struct syscallname *name,
1584     abi_long arg0, abi_long arg1, abi_long arg2,
1585     abi_long arg3, abi_long arg4, abi_long arg5)
1586 {
1587     print_syscall_prologue(name);
1588     print_string(arg0, 0);
1589     print_raw_param("0x" TARGET_ABI_FMT_lx, arg1, 1);
1590     print_syscall_epilogue(name);
1591 }
1592 #endif
1593
1594 #ifdef TARGET_NR_faccessat
1595 static void
1596 print_faccessat(const struct syscallname *name,
1597     abi_long arg0, abi_long arg1, abi_long arg2,
1598     abi_long arg3, abi_long arg4, abi_long arg5)
1599 {
1600     print_syscall_prologue(name);
1601     print_at_dirfd(arg0, 0);
1602     print_string(arg1, 0);
1603     print_flags(access_flags, arg2, 0);
1604     print_flags(at_file_flags, arg3, 1);
1605     print_syscall_epilogue(name);
1606 }
1607 #endif
1608
1609 #ifdef TARGET_NR_fallocate
1610 static void
1611 print_fallocate(const struct syscallname *name,
1612     abi_long arg0, abi_long arg1, abi_long arg2,
1613     abi_long arg3, abi_long arg4, abi_long arg5)
1614 {
1615     print_syscall_prologue(name);
1616     print_raw_param("%d", arg0, 0);
1617     print_flags(falloc_flags, arg1, 0);
1618 #if TARGET_ABI_BITS == 32
1619     print_raw_param("%" PRIu64, target_offset64(arg2, arg3), 0);
1620     print_raw_param("%" PRIu64, target_offset64(arg4, arg5), 1);
1621 #else
1622     print_raw_param(TARGET_ABI_FMT_ld, arg2, 0);
1623     print_raw_param(TARGET_ABI_FMT_ld, arg3, 1);
1624 #endif
1625     print_syscall_epilogue(name);
1626 }
1627 #endif
1628
1629 #ifdef TARGET_NR_fchmodat
1630 static void
1631 print_fchmodat(const struct syscallname *name,
1632     abi_long arg0, abi_long arg1, abi_long arg2,
1633     abi_long arg3, abi_long arg4, abi_long arg5)
1634 {
1635     print_syscall_prologue(name);
1636     print_at_dirfd(arg0, 0);
1637     print_string(arg1, 0);
1638     print_file_mode(arg2, 0);
1639     print_flags(at_file_flags, arg3, 1);
1640     print_syscall_epilogue(name);
1641 }
1642 #endif
1643
1644 #ifdef TARGET_NR_fchownat
1645 static void
1646 print_fchownat(const struct syscallname *name,
1647     abi_long arg0, abi_long arg1, abi_long arg2,
1648     abi_long arg3, abi_long arg4, abi_long arg5)
1649 {
1650     print_syscall_prologue(name);
1651     print_at_dirfd(arg0, 0);
1652     print_string(arg1, 0);
1653     print_raw_param("%d", arg2, 0);
1654     print_raw_param("%d", arg3, 0);
1655     print_flags(at_file_flags, arg4, 1);
1656     print_syscall_epilogue(name);
1657 }
1658 #endif
1659
1660 #if defined(TARGET_NR_fcntl) || defined(TARGET_NR_fcntl64)
1661 static void
1662 print_fcntl(const struct syscallname *name,
1663     abi_long arg0, abi_long arg1, abi_long arg2,
1664     abi_long arg3, abi_long arg4, abi_long arg5)
1665 {
1666     print_syscall_prologue(name);
1667     print_raw_param("%d", arg0, 0);
1668     switch(arg1) {
1669     case TARGET_F_DUPFD:
1670         qemu_log("F_DUPFD,");
1671         print_raw_param(TARGET_ABI_FMT_ld, arg2, 1);
1672         break;
1673     case TARGET_F_GETFD:
1674         qemu_log("F_GETFD");
1675         break;
1676     case TARGET_F_SETFD:
1677         qemu_log("F_SETFD,");
1678         print_raw_param(TARGET_ABI_FMT_ld, arg2, 1);
1679         break;
1680     case TARGET_F_GETFL:
1681         qemu_log("F_GETFL");
1682         break;
1683     case TARGET_F_SETFL:
1684         qemu_log("F_SETFL,");
1685         print_open_flags(arg2, 1);
1686         break;
1687     case TARGET_F_GETLK:
1688         qemu_log("F_GETLK,");
1689         print_pointer(arg2, 1);
1690         break;
1691     case TARGET_F_SETLK:
1692         qemu_log("F_SETLK,");
1693         print_pointer(arg2, 1);
1694         break;
1695     case TARGET_F_SETLKW:
1696         qemu_log("F_SETLKW,");
1697         print_pointer(arg2, 1);
1698         break;
1699     case TARGET_F_GETOWN:
1700         qemu_log("F_GETOWN");
1701         break;
1702     case TARGET_F_SETOWN:
1703         qemu_log("F_SETOWN,");
1704         print_raw_param(TARGET_ABI_FMT_ld, arg2, 0);
1705         break;
1706     case TARGET_F_GETSIG:
1707         qemu_log("F_GETSIG");
1708         break;
1709     case TARGET_F_SETSIG:
1710         qemu_log("F_SETSIG,");
1711         print_raw_param(TARGET_ABI_FMT_ld, arg2, 0);
1712         break;
1713 #if TARGET_ABI_BITS == 32
1714     case TARGET_F_GETLK64:
1715         qemu_log("F_GETLK64,");
1716         print_pointer(arg2, 1);
1717         break;
1718     case TARGET_F_SETLK64:
1719         qemu_log("F_SETLK64,");
1720         print_pointer(arg2, 1);
1721         break;
1722     case TARGET_F_SETLKW64:
1723         qemu_log("F_SETLKW64,");
1724         print_pointer(arg2, 1);
1725         break;
1726 #endif
1727     case TARGET_F_SETLEASE:
1728         qemu_log("F_SETLEASE,");
1729         print_raw_param(TARGET_ABI_FMT_ld, arg2, 0);
1730         break;
1731     case TARGET_F_GETLEASE:
1732         qemu_log("F_GETLEASE");
1733         break;
1734     case TARGET_F_SETPIPE_SZ:
1735         qemu_log("F_SETPIPE_SZ,");
1736         print_raw_param(TARGET_ABI_FMT_ld, arg2, 1);
1737         break;
1738     case TARGET_F_GETPIPE_SZ:
1739         qemu_log("F_GETPIPE_SZ");
1740         break;
1741     case TARGET_F_DUPFD_CLOEXEC:
1742         qemu_log("F_DUPFD_CLOEXEC,");
1743         print_raw_param(TARGET_ABI_FMT_ld, arg2, 1);
1744         break;
1745     case TARGET_F_NOTIFY:
1746         qemu_log("F_NOTIFY,");
1747         print_raw_param(TARGET_ABI_FMT_ld, arg2, 0);
1748         break;
1749     default:
1750         print_raw_param(TARGET_ABI_FMT_ld, arg1, 0);
1751         print_pointer(arg2, 1);
1752         break;
1753     }
1754     print_syscall_epilogue(name);
1755 }
1756 #define print_fcntl64   print_fcntl
1757 #endif
1758
1759 #ifdef TARGET_NR_fgetxattr
1760 static void
1761 print_fgetxattr(const struct syscallname *name,
1762     abi_long arg0, abi_long arg1, abi_long arg2,
1763     abi_long arg3, abi_long arg4, abi_long arg5)
1764 {
1765     print_syscall_prologue(name);
1766     print_raw_param("%d", arg0, 0);
1767     print_string(arg1, 0);
1768     print_pointer(arg2, 0);
1769     print_raw_param(TARGET_FMT_lu, arg3, 1);
1770     print_syscall_epilogue(name);
1771 }
1772 #endif
1773
1774 #ifdef TARGET_NR_flistxattr
1775 static void
1776 print_flistxattr(const struct syscallname *name,
1777     abi_long arg0, abi_long arg1, abi_long arg2,
1778     abi_long arg3, abi_long arg4, abi_long arg5)
1779 {
1780     print_syscall_prologue(name);
1781     print_raw_param("%d", arg0, 0);
1782     print_pointer(arg1, 0);
1783     print_raw_param(TARGET_FMT_lu, arg2, 1);
1784     print_syscall_epilogue(name);
1785 }
1786 #endif
1787
1788 #if defined(TARGET_NR_getxattr) || defined(TARGET_NR_lgetxattr)
1789 static void
1790 print_getxattr(const struct syscallname *name,
1791     abi_long arg0, abi_long arg1, abi_long arg2,
1792     abi_long arg3, abi_long arg4, abi_long arg5)
1793 {
1794     print_syscall_prologue(name);
1795     print_string(arg0, 0);
1796     print_string(arg1, 0);
1797     print_pointer(arg2, 0);
1798     print_raw_param(TARGET_FMT_lu, arg3, 1);
1799     print_syscall_epilogue(name);
1800 }
1801 #define print_lgetxattr     print_getxattr
1802 #endif
1803
1804 #if defined(TARGET_NR_listxattr) || defined(TARGET_NR_llistxattr)
1805 static void
1806 print_listxattr(const struct syscallname *name,
1807     abi_long arg0, abi_long arg1, abi_long arg2,
1808     abi_long arg3, abi_long arg4, abi_long arg5)
1809 {
1810     print_syscall_prologue(name);
1811     print_string(arg0, 0);
1812     print_pointer(arg1, 0);
1813     print_raw_param(TARGET_FMT_lu, arg2, 1);
1814     print_syscall_epilogue(name);
1815 }
1816 #define print_llistxattr     print_listxattr
1817 #endif
1818
1819 #if defined(TARGET_NR_fremovexattr)
1820 static void
1821 print_fremovexattr(const struct syscallname *name,
1822     abi_long arg0, abi_long arg1, abi_long arg2,
1823     abi_long arg3, abi_long arg4, abi_long arg5)
1824 {
1825     print_syscall_prologue(name);
1826     print_raw_param("%d", arg0, 0);
1827     print_string(arg1, 1);
1828     print_syscall_epilogue(name);
1829 }
1830 #endif
1831
1832 #if defined(TARGET_NR_removexattr) || defined(TARGET_NR_lremovexattr)
1833 static void
1834 print_removexattr(const struct syscallname *name,
1835     abi_long arg0, abi_long arg1, abi_long arg2,
1836     abi_long arg3, abi_long arg4, abi_long arg5)
1837 {
1838     print_syscall_prologue(name);
1839     print_string(arg0, 0);
1840     print_string(arg1, 1);
1841     print_syscall_epilogue(name);
1842 }
1843 #define print_lremovexattr     print_removexattr
1844 #endif
1845
1846 #ifdef TARGET_NR_futimesat
1847 static void
1848 print_futimesat(const struct syscallname *name,
1849     abi_long arg0, abi_long arg1, abi_long arg2,
1850     abi_long arg3, abi_long arg4, abi_long arg5)
1851 {
1852     print_syscall_prologue(name);
1853     print_at_dirfd(arg0, 0);
1854     print_string(arg1, 0);
1855     print_timeval(arg2, 0);
1856     print_timeval(arg2 + sizeof (struct target_timeval), 1);
1857     print_syscall_epilogue(name);
1858 }
1859 #endif
1860
1861 #ifdef TARGET_NR_settimeofday
1862 static void
1863 print_settimeofday(const struct syscallname *name,
1864                 abi_long arg0, abi_long arg1, abi_long arg2,
1865                 abi_long arg3, abi_long arg4, abi_long arg5)
1866 {
1867     print_syscall_prologue(name);
1868     print_timeval(arg0, 0);
1869     print_timezone(arg1, 1);
1870     print_syscall_epilogue(name);
1871 }
1872 #endif
1873
1874 #ifdef TARGET_NR_link
1875 static void
1876 print_link(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_string(arg1, 1);
1883     print_syscall_epilogue(name);
1884 }
1885 #endif
1886
1887 #ifdef TARGET_NR_linkat
1888 static void
1889 print_linkat(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_at_dirfd(arg0, 0);
1895     print_string(arg1, 0);
1896     print_at_dirfd(arg2, 0);
1897     print_string(arg3, 0);
1898     print_flags(at_file_flags, arg4, 1);
1899     print_syscall_epilogue(name);
1900 }
1901 #endif
1902
1903 #ifdef TARGET_NR__llseek
1904 static void
1905 print__llseek(const struct syscallname *name,
1906     abi_long arg0, abi_long arg1, abi_long arg2,
1907     abi_long arg3, abi_long arg4, abi_long arg5)
1908 {
1909     const char *whence = "UNKNOWN";
1910     print_syscall_prologue(name);
1911     print_raw_param("%d", arg0, 0);
1912     print_raw_param("%ld", arg1, 0);
1913     print_raw_param("%ld", arg2, 0);
1914     print_pointer(arg3, 0);
1915     switch(arg4) {
1916     case SEEK_SET: whence = "SEEK_SET"; break;
1917     case SEEK_CUR: whence = "SEEK_CUR"; break;
1918     case SEEK_END: whence = "SEEK_END"; break;
1919     }
1920     qemu_log("%s", whence);
1921     print_syscall_epilogue(name);
1922 }
1923 #endif
1924
1925 #ifdef TARGET_NR_lseek
1926 static void
1927 print_lseek(const struct syscallname *name,
1928     abi_long arg0, abi_long arg1, abi_long arg2,
1929     abi_long arg3, abi_long arg4, abi_long arg5)
1930 {
1931     print_syscall_prologue(name);
1932     print_raw_param("%d", arg0, 0);
1933     print_raw_param(TARGET_ABI_FMT_ld, arg1, 0);
1934     switch (arg2) {
1935     case SEEK_SET:
1936         qemu_log("SEEK_SET"); break;
1937     case SEEK_CUR:
1938         qemu_log("SEEK_CUR"); break;
1939     case SEEK_END:
1940         qemu_log("SEEK_END"); break;
1941 #ifdef SEEK_DATA
1942     case SEEK_DATA:
1943         qemu_log("SEEK_DATA"); break;
1944 #endif
1945 #ifdef SEEK_HOLE
1946     case SEEK_HOLE:
1947         qemu_log("SEEK_HOLE"); break;
1948 #endif
1949     default:
1950         print_raw_param("%#x", arg2, 1);
1951     }
1952     print_syscall_epilogue(name);
1953 }
1954 #endif
1955
1956 #if defined(TARGET_NR_socket)
1957 static void
1958 print_socket(const struct syscallname *name,
1959              abi_long arg0, abi_long arg1, abi_long arg2,
1960              abi_long arg3, abi_long arg4, abi_long arg5)
1961 {
1962     abi_ulong domain = arg0, type = arg1, protocol = arg2;
1963
1964     print_syscall_prologue(name);
1965     print_socket_domain(domain);
1966     qemu_log(",");
1967     print_socket_type(type);
1968     qemu_log(",");
1969     if (domain == AF_PACKET ||
1970         (domain == AF_INET && type == TARGET_SOCK_PACKET)) {
1971         protocol = tswap16(protocol);
1972     }
1973     print_socket_protocol(domain, type, protocol);
1974     print_syscall_epilogue(name);
1975 }
1976
1977 #endif
1978
1979 #if defined(TARGET_NR_socketcall) || defined(TARGET_NR_bind)
1980
1981 static void print_sockfd(abi_long sockfd, int last)
1982 {
1983     print_raw_param(TARGET_ABI_FMT_ld, sockfd, last);
1984 }
1985
1986 #endif
1987
1988 #if defined(TARGET_NR_socketcall)
1989
1990 #define get_user_ualx(x, gaddr, idx) \
1991         get_user_ual(x, (gaddr) + (idx) * sizeof(abi_long))
1992
1993 static void do_print_socket(const char *name, abi_long arg1)
1994 {
1995     abi_ulong domain, type, protocol;
1996
1997     get_user_ualx(domain, arg1, 0);
1998     get_user_ualx(type, arg1, 1);
1999     get_user_ualx(protocol, arg1, 2);
2000     qemu_log("%s(", name);
2001     print_socket_domain(domain);
2002     qemu_log(",");
2003     print_socket_type(type);
2004     qemu_log(",");
2005     if (domain == AF_PACKET ||
2006         (domain == AF_INET && type == TARGET_SOCK_PACKET)) {
2007         protocol = tswap16(protocol);
2008     }
2009     print_socket_protocol(domain, type, protocol);
2010     qemu_log(")");
2011 }
2012
2013 static void do_print_sockaddr(const char *name, abi_long arg1)
2014 {
2015     abi_ulong sockfd, addr, addrlen;
2016
2017     get_user_ualx(sockfd, arg1, 0);
2018     get_user_ualx(addr, arg1, 1);
2019     get_user_ualx(addrlen, arg1, 2);
2020
2021     qemu_log("%s(", name);
2022     print_sockfd(sockfd, 0);
2023     print_sockaddr(addr, addrlen, 0);
2024     qemu_log(")");
2025 }
2026
2027 static void do_print_listen(const char *name, abi_long arg1)
2028 {
2029     abi_ulong sockfd, backlog;
2030
2031     get_user_ualx(sockfd, arg1, 0);
2032     get_user_ualx(backlog, arg1, 1);
2033
2034     qemu_log("%s(", name);
2035     print_sockfd(sockfd, 0);
2036     print_raw_param(TARGET_ABI_FMT_ld, backlog, 1);
2037     qemu_log(")");
2038 }
2039
2040 static void do_print_socketpair(const char *name, abi_long arg1)
2041 {
2042     abi_ulong domain, type, protocol, tab;
2043
2044     get_user_ualx(domain, arg1, 0);
2045     get_user_ualx(type, arg1, 1);
2046     get_user_ualx(protocol, arg1, 2);
2047     get_user_ualx(tab, arg1, 3);
2048
2049     qemu_log("%s(", name);
2050     print_socket_domain(domain);
2051     qemu_log(",");
2052     print_socket_type(type);
2053     qemu_log(",");
2054     print_socket_protocol(domain, type, protocol);
2055     qemu_log(",");
2056     print_raw_param(TARGET_ABI_FMT_lx, tab, 1);
2057     qemu_log(")");
2058 }
2059
2060 static void do_print_sendrecv(const char *name, abi_long arg1)
2061 {
2062     abi_ulong sockfd, msg, len, flags;
2063
2064     get_user_ualx(sockfd, arg1, 0);
2065     get_user_ualx(msg, arg1, 1);
2066     get_user_ualx(len, arg1, 2);
2067     get_user_ualx(flags, arg1, 3);
2068
2069     qemu_log("%s(", name);
2070     print_sockfd(sockfd, 0);
2071     print_buf(msg, len, 0);
2072     print_raw_param(TARGET_ABI_FMT_ld, len, 0);
2073     print_flags(msg_flags, flags, 1);
2074     qemu_log(")");
2075 }
2076
2077 static void do_print_msgaddr(const char *name, abi_long arg1)
2078 {
2079     abi_ulong sockfd, msg, len, flags, addr, addrlen;
2080
2081     get_user_ualx(sockfd, arg1, 0);
2082     get_user_ualx(msg, arg1, 1);
2083     get_user_ualx(len, arg1, 2);
2084     get_user_ualx(flags, arg1, 3);
2085     get_user_ualx(addr, arg1, 4);
2086     get_user_ualx(addrlen, arg1, 5);
2087
2088     qemu_log("%s(", name);
2089     print_sockfd(sockfd, 0);
2090     print_buf(msg, len, 0);
2091     print_raw_param(TARGET_ABI_FMT_ld, len, 0);
2092     print_flags(msg_flags, flags, 0);
2093     print_sockaddr(addr, addrlen, 0);
2094     qemu_log(")");
2095 }
2096
2097 static void do_print_shutdown(const char *name, abi_long arg1)
2098 {
2099     abi_ulong sockfd, how;
2100
2101     get_user_ualx(sockfd, arg1, 0);
2102     get_user_ualx(how, arg1, 1);
2103
2104     qemu_log("shutdown(");
2105     print_sockfd(sockfd, 0);
2106     switch (how) {
2107     case SHUT_RD:
2108         qemu_log("SHUT_RD");
2109         break;
2110     case SHUT_WR:
2111         qemu_log("SHUT_WR");
2112         break;
2113     case SHUT_RDWR:
2114         qemu_log("SHUT_RDWR");
2115         break;
2116     default:
2117         print_raw_param(TARGET_ABI_FMT_ld, how, 1);
2118         break;
2119     }
2120     qemu_log(")");
2121 }
2122
2123 static void do_print_msg(const char *name, abi_long arg1)
2124 {
2125     abi_ulong sockfd, msg, flags;
2126
2127     get_user_ualx(sockfd, arg1, 0);
2128     get_user_ualx(msg, arg1, 1);
2129     get_user_ualx(flags, arg1, 2);
2130
2131     qemu_log("%s(", name);
2132     print_sockfd(sockfd, 0);
2133     print_pointer(msg, 0);
2134     print_flags(msg_flags, flags, 1);
2135     qemu_log(")");
2136 }
2137
2138 static void do_print_sockopt(const char *name, abi_long arg1)
2139 {
2140     abi_ulong sockfd, level, optname, optval, optlen;
2141
2142     get_user_ualx(sockfd, arg1, 0);
2143     get_user_ualx(level, arg1, 1);
2144     get_user_ualx(optname, arg1, 2);
2145     get_user_ualx(optval, arg1, 3);
2146     get_user_ualx(optlen, arg1, 4);
2147
2148     qemu_log("%s(", name);
2149     print_sockfd(sockfd, 0);
2150     switch (level) {
2151     case SOL_TCP:
2152         qemu_log("SOL_TCP,");
2153         print_raw_param(TARGET_ABI_FMT_ld, optname, 0);
2154         print_pointer(optval, 0);
2155         break;
2156     case SOL_IP:
2157         qemu_log("SOL_IP,");
2158         print_raw_param(TARGET_ABI_FMT_ld, optname, 0);
2159         print_pointer(optval, 0);
2160         break;
2161     case SOL_RAW:
2162         qemu_log("SOL_RAW,");
2163         print_raw_param(TARGET_ABI_FMT_ld, optname, 0);
2164         print_pointer(optval, 0);
2165         break;
2166     case TARGET_SOL_SOCKET:
2167         qemu_log("SOL_SOCKET,");
2168         switch (optname) {
2169         case TARGET_SO_DEBUG:
2170             qemu_log("SO_DEBUG,");
2171 print_optint:
2172             print_number(optval, 0);
2173             break;
2174         case TARGET_SO_REUSEADDR:
2175             qemu_log("SO_REUSEADDR,");
2176             goto print_optint;
2177         case TARGET_SO_REUSEPORT:
2178             qemu_log("SO_REUSEPORT,");
2179             goto print_optint;
2180         case TARGET_SO_TYPE:
2181             qemu_log("SO_TYPE,");
2182             goto print_optint;
2183         case TARGET_SO_ERROR:
2184             qemu_log("SO_ERROR,");
2185             goto print_optint;
2186         case TARGET_SO_DONTROUTE:
2187             qemu_log("SO_DONTROUTE,");
2188             goto print_optint;
2189         case TARGET_SO_BROADCAST:
2190             qemu_log("SO_BROADCAST,");
2191             goto print_optint;
2192         case TARGET_SO_SNDBUF:
2193             qemu_log("SO_SNDBUF,");
2194             goto print_optint;
2195         case TARGET_SO_RCVBUF:
2196             qemu_log("SO_RCVBUF,");
2197             goto print_optint;
2198         case TARGET_SO_KEEPALIVE:
2199             qemu_log("SO_KEEPALIVE,");
2200             goto print_optint;
2201         case TARGET_SO_OOBINLINE:
2202             qemu_log("SO_OOBINLINE,");
2203             goto print_optint;
2204         case TARGET_SO_NO_CHECK:
2205             qemu_log("SO_NO_CHECK,");
2206             goto print_optint;
2207         case TARGET_SO_PRIORITY:
2208             qemu_log("SO_PRIORITY,");
2209             goto print_optint;
2210         case TARGET_SO_BSDCOMPAT:
2211             qemu_log("SO_BSDCOMPAT,");
2212             goto print_optint;
2213         case TARGET_SO_PASSCRED:
2214             qemu_log("SO_PASSCRED,");
2215             goto print_optint;
2216         case TARGET_SO_TIMESTAMP:
2217             qemu_log("SO_TIMESTAMP,");
2218             goto print_optint;
2219         case TARGET_SO_RCVLOWAT:
2220             qemu_log("SO_RCVLOWAT,");
2221             goto print_optint;
2222         case TARGET_SO_RCVTIMEO:
2223             qemu_log("SO_RCVTIMEO,");
2224             print_timeval(optval, 0);
2225             break;
2226         case TARGET_SO_SNDTIMEO:
2227             qemu_log("SO_SNDTIMEO,");
2228             print_timeval(optval, 0);
2229             break;
2230         case TARGET_SO_ATTACH_FILTER: {
2231             struct target_sock_fprog *fprog;
2232
2233             qemu_log("SO_ATTACH_FILTER,");
2234
2235             if (lock_user_struct(VERIFY_READ, fprog, optval,  0)) {
2236                 struct target_sock_filter *filter;
2237                 qemu_log("{");
2238                 if (lock_user_struct(VERIFY_READ, filter,
2239                                      tswapal(fprog->filter),  0)) {
2240                     int i;
2241                     for (i = 0; i < tswap16(fprog->len) - 1; i++) {
2242                         qemu_log("[%d]{0x%x,%d,%d,0x%x},",
2243                                  i, tswap16(filter[i].code),
2244                                  filter[i].jt, filter[i].jf,
2245                                  tswap32(filter[i].k));
2246                     }
2247                     qemu_log("[%d]{0x%x,%d,%d,0x%x}",
2248                              i, tswap16(filter[i].code),
2249                              filter[i].jt, filter[i].jf,
2250                              tswap32(filter[i].k));
2251                 } else {
2252                     qemu_log(TARGET_ABI_FMT_lx, tswapal(fprog->filter));
2253                 }
2254                 qemu_log(",%d},", tswap16(fprog->len));
2255                 unlock_user(fprog, optval, 0);
2256             } else {
2257                 print_pointer(optval, 0);
2258             }
2259             break;
2260         }
2261         default:
2262             print_raw_param(TARGET_ABI_FMT_ld, optname, 0);
2263             print_pointer(optval, 0);
2264             break;
2265         }
2266         break;
2267     default:
2268         print_raw_param(TARGET_ABI_FMT_ld, level, 0);
2269         print_raw_param(TARGET_ABI_FMT_ld, optname, 0);
2270         print_pointer(optval, 0);
2271         break;
2272     }
2273     print_raw_param(TARGET_ABI_FMT_ld, optlen, 1);
2274     qemu_log(")");
2275 }
2276
2277 #define PRINT_SOCKOP(name, func) \
2278     [TARGET_SYS_##name] = { #name, func }
2279
2280 static struct {
2281     const char *name;
2282     void (*print)(const char *, abi_long);
2283 } scall[] = {
2284     PRINT_SOCKOP(SOCKET, do_print_socket),
2285     PRINT_SOCKOP(BIND, do_print_sockaddr),
2286     PRINT_SOCKOP(CONNECT, do_print_sockaddr),
2287     PRINT_SOCKOP(LISTEN, do_print_listen),
2288     PRINT_SOCKOP(ACCEPT, do_print_sockaddr),
2289     PRINT_SOCKOP(GETSOCKNAME, do_print_sockaddr),
2290     PRINT_SOCKOP(GETPEERNAME, do_print_sockaddr),
2291     PRINT_SOCKOP(SOCKETPAIR, do_print_socketpair),
2292     PRINT_SOCKOP(SEND, do_print_sendrecv),
2293     PRINT_SOCKOP(RECV, do_print_sendrecv),
2294     PRINT_SOCKOP(SENDTO, do_print_msgaddr),
2295     PRINT_SOCKOP(RECVFROM, do_print_msgaddr),
2296     PRINT_SOCKOP(SHUTDOWN, do_print_shutdown),
2297     PRINT_SOCKOP(SETSOCKOPT, do_print_sockopt),
2298     PRINT_SOCKOP(GETSOCKOPT, do_print_sockopt),
2299     PRINT_SOCKOP(SENDMSG, do_print_msg),
2300     PRINT_SOCKOP(RECVMSG, do_print_msg),
2301     PRINT_SOCKOP(ACCEPT4, NULL),
2302     PRINT_SOCKOP(RECVMMSG, NULL),
2303     PRINT_SOCKOP(SENDMMSG, NULL),
2304 };
2305
2306 static void
2307 print_socketcall(const struct syscallname *name,
2308                  abi_long arg0, abi_long arg1, abi_long arg2,
2309                  abi_long arg3, abi_long arg4, abi_long arg5)
2310 {
2311     if (arg0 >= 0 && arg0 < ARRAY_SIZE(scall) && scall[arg0].print) {
2312         scall[arg0].print(scall[arg0].name, arg1);
2313         return;
2314     }
2315     print_syscall_prologue(name);
2316     print_raw_param(TARGET_ABI_FMT_ld, arg0, 0);
2317     print_raw_param(TARGET_ABI_FMT_ld, arg1, 0);
2318     print_raw_param(TARGET_ABI_FMT_ld, arg2, 0);
2319     print_raw_param(TARGET_ABI_FMT_ld, arg3, 0);
2320     print_raw_param(TARGET_ABI_FMT_ld, arg4, 0);
2321     print_raw_param(TARGET_ABI_FMT_ld, arg5, 0);
2322     print_syscall_epilogue(name);
2323 }
2324 #endif
2325
2326 #if defined(TARGET_NR_bind)
2327 static void
2328 print_bind(const struct syscallname *name,
2329            abi_long arg0, abi_long arg1, abi_long arg2,
2330            abi_long arg3, abi_long arg4, abi_long arg5)
2331 {
2332     print_syscall_prologue(name);
2333     print_sockfd(arg0, 0);
2334     print_sockaddr(arg1, arg2, 1);
2335     print_syscall_epilogue(name);
2336 }
2337 #endif
2338
2339 #if defined(TARGET_NR_stat) || defined(TARGET_NR_stat64) || \
2340     defined(TARGET_NR_lstat) || defined(TARGET_NR_lstat64)
2341 static void
2342 print_stat(const struct syscallname *name,
2343     abi_long arg0, abi_long arg1, abi_long arg2,
2344     abi_long arg3, abi_long arg4, abi_long arg5)
2345 {
2346     print_syscall_prologue(name);
2347     print_string(arg0, 0);
2348     print_pointer(arg1, 1);
2349     print_syscall_epilogue(name);
2350 }
2351 #define print_lstat     print_stat
2352 #define print_stat64    print_stat
2353 #define print_lstat64   print_stat
2354 #endif
2355
2356 #if defined(TARGET_NR_fstat) || defined(TARGET_NR_fstat64)
2357 static void
2358 print_fstat(const struct syscallname *name,
2359     abi_long arg0, abi_long arg1, abi_long arg2,
2360     abi_long arg3, abi_long arg4, abi_long arg5)
2361 {
2362     print_syscall_prologue(name);
2363     print_raw_param("%d", arg0, 0);
2364     print_pointer(arg1, 1);
2365     print_syscall_epilogue(name);
2366 }
2367 #define print_fstat64     print_fstat
2368 #endif
2369
2370 #ifdef TARGET_NR_mkdir
2371 static void
2372 print_mkdir(const struct syscallname *name,
2373     abi_long arg0, abi_long arg1, abi_long arg2,
2374     abi_long arg3, abi_long arg4, abi_long arg5)
2375 {
2376     print_syscall_prologue(name);
2377     print_string(arg0, 0);
2378     print_file_mode(arg1, 1);
2379     print_syscall_epilogue(name);
2380 }
2381 #endif
2382
2383 #ifdef TARGET_NR_mkdirat
2384 static void
2385 print_mkdirat(const struct syscallname *name,
2386     abi_long arg0, abi_long arg1, abi_long arg2,
2387     abi_long arg3, abi_long arg4, abi_long arg5)
2388 {
2389     print_syscall_prologue(name);
2390     print_at_dirfd(arg0, 0);
2391     print_string(arg1, 0);
2392     print_file_mode(arg2, 1);
2393     print_syscall_epilogue(name);
2394 }
2395 #endif
2396
2397 #ifdef TARGET_NR_rmdir
2398 static void
2399 print_rmdir(const struct syscallname *name,
2400     abi_long arg0, abi_long arg1, abi_long arg2,
2401     abi_long arg3, abi_long arg4, abi_long arg5)
2402 {
2403     print_syscall_prologue(name);
2404     print_string(arg0, 0);
2405     print_syscall_epilogue(name);
2406 }
2407 #endif
2408
2409 #ifdef TARGET_NR_rt_sigaction
2410 static void
2411 print_rt_sigaction(const struct syscallname *name,
2412     abi_long arg0, abi_long arg1, abi_long arg2,
2413     abi_long arg3, abi_long arg4, abi_long arg5)
2414 {
2415     print_syscall_prologue(name);
2416     print_signal(arg0, 0);
2417     print_pointer(arg1, 0);
2418     print_pointer(arg2, 1);
2419     print_syscall_epilogue(name);
2420 }
2421 #endif
2422
2423 #ifdef TARGET_NR_rt_sigprocmask
2424 static void
2425 print_rt_sigprocmask(const struct syscallname *name,
2426     abi_long arg0, abi_long arg1, abi_long arg2,
2427     abi_long arg3, abi_long arg4, abi_long arg5)
2428 {
2429     const char *how = "UNKNOWN";
2430     print_syscall_prologue(name);
2431     switch(arg0) {
2432     case TARGET_SIG_BLOCK: how = "SIG_BLOCK"; break;
2433     case TARGET_SIG_UNBLOCK: how = "SIG_UNBLOCK"; break;
2434     case TARGET_SIG_SETMASK: how = "SIG_SETMASK"; break;
2435     }
2436     qemu_log("%s,", how);
2437     print_pointer(arg1, 0);
2438     print_pointer(arg2, 1);
2439     print_syscall_epilogue(name);
2440 }
2441 #endif
2442
2443 #ifdef TARGET_NR_rt_sigqueueinfo
2444 static void
2445 print_rt_sigqueueinfo(const struct syscallname *name,
2446     abi_long arg0, abi_long arg1, abi_long arg2,
2447     abi_long arg3, abi_long arg4, abi_long arg5)
2448 {
2449     void *p;
2450     target_siginfo_t uinfo;
2451
2452     print_syscall_prologue(name);
2453     print_raw_param("%d", arg0, 0);
2454     print_signal(arg1, 0);
2455     p = lock_user(VERIFY_READ, arg2, sizeof(target_siginfo_t), 1);
2456     if (p) {
2457         get_target_siginfo(&uinfo, p);
2458         print_siginfo(&uinfo);
2459
2460         unlock_user(p, arg2, 0);
2461     } else {
2462         print_pointer(arg2, 1);
2463     }
2464     print_syscall_epilogue(name);
2465 }
2466 #endif
2467
2468 #ifdef TARGET_NR_rt_tgsigqueueinfo
2469 static void
2470 print_rt_tgsigqueueinfo(const struct syscallname *name,
2471     abi_long arg0, abi_long arg1, abi_long arg2,
2472     abi_long arg3, abi_long arg4, abi_long arg5)
2473 {
2474     void *p;
2475     target_siginfo_t uinfo;
2476
2477     print_syscall_prologue(name);
2478     print_raw_param("%d", arg0, 0);
2479     print_raw_param("%d", arg1, 0);
2480     print_signal(arg2, 0);
2481     p = lock_user(VERIFY_READ, arg3, sizeof(target_siginfo_t), 1);
2482     if (p) {
2483         get_target_siginfo(&uinfo, p);
2484         print_siginfo(&uinfo);
2485
2486         unlock_user(p, arg3, 0);
2487     } else {
2488         print_pointer(arg3, 1);
2489     }
2490     print_syscall_epilogue(name);
2491 }
2492 #endif
2493
2494 #ifdef TARGET_NR_syslog
2495 static void
2496 print_syslog_action(abi_ulong arg, int last)
2497 {
2498     const char *type;
2499
2500     switch (arg) {
2501         case TARGET_SYSLOG_ACTION_CLOSE: {
2502             type = "SYSLOG_ACTION_CLOSE";
2503             break;
2504         }
2505         case TARGET_SYSLOG_ACTION_OPEN: {
2506             type = "SYSLOG_ACTION_OPEN";
2507             break;
2508         }
2509         case TARGET_SYSLOG_ACTION_READ: {
2510             type = "SYSLOG_ACTION_READ";
2511             break;
2512         }
2513         case TARGET_SYSLOG_ACTION_READ_ALL: {
2514             type = "SYSLOG_ACTION_READ_ALL";
2515             break;
2516         }
2517         case TARGET_SYSLOG_ACTION_READ_CLEAR: {
2518             type = "SYSLOG_ACTION_READ_CLEAR";
2519             break;
2520         }
2521         case TARGET_SYSLOG_ACTION_CLEAR: {
2522             type = "SYSLOG_ACTION_CLEAR";
2523             break;
2524         }
2525         case TARGET_SYSLOG_ACTION_CONSOLE_OFF: {
2526             type = "SYSLOG_ACTION_CONSOLE_OFF";
2527             break;
2528         }
2529         case TARGET_SYSLOG_ACTION_CONSOLE_ON: {
2530             type = "SYSLOG_ACTION_CONSOLE_ON";
2531             break;
2532         }
2533         case TARGET_SYSLOG_ACTION_CONSOLE_LEVEL: {
2534             type = "SYSLOG_ACTION_CONSOLE_LEVEL";
2535             break;
2536         }
2537         case TARGET_SYSLOG_ACTION_SIZE_UNREAD: {
2538             type = "SYSLOG_ACTION_SIZE_UNREAD";
2539             break;
2540         }
2541         case TARGET_SYSLOG_ACTION_SIZE_BUFFER: {
2542             type = "SYSLOG_ACTION_SIZE_BUFFER";
2543             break;
2544         }
2545         default: {
2546             print_raw_param("%ld", arg, last);
2547             return;
2548         }
2549     }
2550     qemu_log("%s%s", type, get_comma(last));
2551 }
2552
2553 static void
2554 print_syslog(const struct syscallname *name,
2555     abi_long arg0, abi_long arg1, abi_long arg2,
2556     abi_long arg3, abi_long arg4, abi_long arg5)
2557 {
2558     print_syscall_prologue(name);
2559     print_syslog_action(arg0, 0);
2560     print_pointer(arg1, 0);
2561     print_raw_param("%d", arg2, 1);
2562     print_syscall_epilogue(name);
2563 }
2564 #endif
2565
2566 #ifdef TARGET_NR_mknod
2567 static void
2568 print_mknod(const struct syscallname *name,
2569     abi_long arg0, abi_long arg1, abi_long arg2,
2570     abi_long arg3, abi_long arg4, abi_long arg5)
2571 {
2572     int hasdev = (arg1 & (S_IFCHR|S_IFBLK));
2573
2574     print_syscall_prologue(name);
2575     print_string(arg0, 0);
2576     print_file_mode(arg1, (hasdev == 0));
2577     if (hasdev) {
2578         print_raw_param("makedev(%d", major(arg2), 0);
2579         print_raw_param("%d)", minor(arg2), 1);
2580     }
2581     print_syscall_epilogue(name);
2582 }
2583 #endif
2584
2585 #ifdef TARGET_NR_mknodat
2586 static void
2587 print_mknodat(const struct syscallname *name,
2588     abi_long arg0, abi_long arg1, abi_long arg2,
2589     abi_long arg3, abi_long arg4, abi_long arg5)
2590 {
2591     int hasdev = (arg2 & (S_IFCHR|S_IFBLK));
2592
2593     print_syscall_prologue(name);
2594     print_at_dirfd(arg0, 0);
2595     print_string(arg1, 0);
2596     print_file_mode(arg2, (hasdev == 0));
2597     if (hasdev) {
2598         print_raw_param("makedev(%d", major(arg3), 0);
2599         print_raw_param("%d)", minor(arg3), 1);
2600     }
2601     print_syscall_epilogue(name);
2602 }
2603 #endif
2604
2605 #ifdef TARGET_NR_mq_open
2606 static void
2607 print_mq_open(const struct syscallname *name,
2608     abi_long arg0, abi_long arg1, abi_long arg2,
2609     abi_long arg3, abi_long arg4, abi_long arg5)
2610 {
2611     int is_creat = (arg1 & TARGET_O_CREAT);
2612
2613     print_syscall_prologue(name);
2614     print_string(arg0, 0);
2615     print_open_flags(arg1, (is_creat == 0));
2616     if (is_creat) {
2617         print_file_mode(arg2, 0);
2618         print_pointer(arg3, 1);
2619     }
2620     print_syscall_epilogue(name);
2621 }
2622 #endif
2623
2624 #ifdef TARGET_NR_open
2625 static void
2626 print_open(const struct syscallname *name,
2627     abi_long arg0, abi_long arg1, abi_long arg2,
2628     abi_long arg3, abi_long arg4, abi_long arg5)
2629 {
2630     int is_creat = (arg1 & TARGET_O_CREAT);
2631
2632     print_syscall_prologue(name);
2633     print_string(arg0, 0);
2634     print_open_flags(arg1, (is_creat == 0));
2635     if (is_creat)
2636         print_file_mode(arg2, 1);
2637     print_syscall_epilogue(name);
2638 }
2639 #endif
2640
2641 #ifdef TARGET_NR_openat
2642 static void
2643 print_openat(const struct syscallname *name,
2644     abi_long arg0, abi_long arg1, abi_long arg2,
2645     abi_long arg3, abi_long arg4, abi_long arg5)
2646 {
2647     int is_creat = (arg2 & TARGET_O_CREAT);
2648
2649     print_syscall_prologue(name);
2650     print_at_dirfd(arg0, 0);
2651     print_string(arg1, 0);
2652     print_open_flags(arg2, (is_creat == 0));
2653     if (is_creat)
2654         print_file_mode(arg3, 1);
2655     print_syscall_epilogue(name);
2656 }
2657 #endif
2658
2659 #ifdef TARGET_NR_mq_unlink
2660 static void
2661 print_mq_unlink(const struct syscallname *name,
2662     abi_long arg0, abi_long arg1, abi_long arg2,
2663     abi_long arg3, abi_long arg4, abi_long arg5)
2664 {
2665     print_syscall_prologue(name);
2666     print_string(arg0, 1);
2667     print_syscall_epilogue(name);
2668 }
2669 #endif
2670
2671 #if defined(TARGET_NR_fstatat64) || defined(TARGET_NR_newfstatat)
2672 static void
2673 print_fstatat64(const struct syscallname *name,
2674     abi_long arg0, abi_long arg1, abi_long arg2,
2675     abi_long arg3, abi_long arg4, abi_long arg5)
2676 {
2677     print_syscall_prologue(name);
2678     print_at_dirfd(arg0, 0);
2679     print_string(arg1, 0);
2680     print_pointer(arg2, 0);
2681     print_flags(at_file_flags, arg3, 1);
2682     print_syscall_epilogue(name);
2683 }
2684 #define print_newfstatat    print_fstatat64
2685 #endif
2686
2687 #ifdef TARGET_NR_readlink
2688 static void
2689 print_readlink(const struct syscallname *name,
2690     abi_long arg0, abi_long arg1, abi_long arg2,
2691     abi_long arg3, abi_long arg4, abi_long arg5)
2692 {
2693     print_syscall_prologue(name);
2694     print_string(arg0, 0);
2695     print_pointer(arg1, 0);
2696     print_raw_param("%u", arg2, 1);
2697     print_syscall_epilogue(name);
2698 }
2699 #endif
2700
2701 #ifdef TARGET_NR_readlinkat
2702 static void
2703 print_readlinkat(const struct syscallname *name,
2704     abi_long arg0, abi_long arg1, abi_long arg2,
2705     abi_long arg3, abi_long arg4, abi_long arg5)
2706 {
2707     print_syscall_prologue(name);
2708     print_at_dirfd(arg0, 0);
2709     print_string(arg1, 0);
2710     print_pointer(arg2, 0);
2711     print_raw_param("%u", arg3, 1);
2712     print_syscall_epilogue(name);
2713 }
2714 #endif
2715
2716 #ifdef TARGET_NR_rename
2717 static void
2718 print_rename(const struct syscallname *name,
2719     abi_long arg0, abi_long arg1, abi_long arg2,
2720     abi_long arg3, abi_long arg4, abi_long arg5)
2721 {
2722     print_syscall_prologue(name);
2723     print_string(arg0, 0);
2724     print_string(arg1, 1);
2725     print_syscall_epilogue(name);
2726 }
2727 #endif
2728
2729 #ifdef TARGET_NR_renameat
2730 static void
2731 print_renameat(const struct syscallname *name,
2732     abi_long arg0, abi_long arg1, abi_long arg2,
2733     abi_long arg3, abi_long arg4, abi_long arg5)
2734 {
2735     print_syscall_prologue(name);
2736     print_at_dirfd(arg0, 0);
2737     print_string(arg1, 0);
2738     print_at_dirfd(arg2, 0);
2739     print_string(arg3, 1);
2740     print_syscall_epilogue(name);
2741 }
2742 #endif
2743
2744 #ifdef TARGET_NR_statfs
2745 static void
2746 print_statfs(const struct syscallname *name,
2747     abi_long arg0, abi_long arg1, abi_long arg2,
2748     abi_long arg3, abi_long arg4, abi_long arg5)
2749 {
2750     print_syscall_prologue(name);
2751     print_string(arg0, 0);
2752     print_pointer(arg1, 1);
2753     print_syscall_epilogue(name);
2754 }
2755 #endif
2756
2757 #ifdef TARGET_NR_statfs64
2758 static void
2759 print_statfs64(const struct syscallname *name,
2760     abi_long arg0, abi_long arg1, abi_long arg2,
2761     abi_long arg3, abi_long arg4, abi_long arg5)
2762 {
2763     print_syscall_prologue(name);
2764     print_string(arg0, 0);
2765     print_pointer(arg1, 1);
2766     print_syscall_epilogue(name);
2767 }
2768 #endif
2769
2770 #ifdef TARGET_NR_symlink
2771 static void
2772 print_symlink(const struct syscallname *name,
2773     abi_long arg0, abi_long arg1, abi_long arg2,
2774     abi_long arg3, abi_long arg4, abi_long arg5)
2775 {
2776     print_syscall_prologue(name);
2777     print_string(arg0, 0);
2778     print_string(arg1, 1);
2779     print_syscall_epilogue(name);
2780 }
2781 #endif
2782
2783 #ifdef TARGET_NR_symlinkat
2784 static void
2785 print_symlinkat(const struct syscallname *name,
2786     abi_long arg0, abi_long arg1, abi_long arg2,
2787     abi_long arg3, abi_long arg4, abi_long arg5)
2788 {
2789     print_syscall_prologue(name);
2790     print_string(arg0, 0);
2791     print_at_dirfd(arg1, 0);
2792     print_string(arg2, 1);
2793     print_syscall_epilogue(name);
2794 }
2795 #endif
2796
2797 #ifdef TARGET_NR_mount
2798 static void
2799 print_mount(const struct syscallname *name,
2800     abi_long arg0, abi_long arg1, abi_long arg2,
2801     abi_long arg3, abi_long arg4, abi_long arg5)
2802 {
2803     print_syscall_prologue(name);
2804     print_string(arg0, 0);
2805     print_string(arg1, 0);
2806     print_string(arg2, 0);
2807     print_flags(mount_flags, arg3, 0);
2808     print_pointer(arg4, 1);
2809     print_syscall_epilogue(name);
2810 }
2811 #endif
2812
2813 #ifdef TARGET_NR_umount
2814 static void
2815 print_umount(const struct syscallname *name,
2816     abi_long arg0, abi_long arg1, abi_long arg2,
2817     abi_long arg3, abi_long arg4, abi_long arg5)
2818 {
2819     print_syscall_prologue(name);
2820     print_string(arg0, 1);
2821     print_syscall_epilogue(name);
2822 }
2823 #endif
2824
2825 #ifdef TARGET_NR_umount2
2826 static void
2827 print_umount2(const struct syscallname *name,
2828     abi_long arg0, abi_long arg1, abi_long arg2,
2829     abi_long arg3, abi_long arg4, abi_long arg5)
2830 {
2831     print_syscall_prologue(name);
2832     print_string(arg0, 0);
2833     print_flags(umount2_flags, arg1, 1);
2834     print_syscall_epilogue(name);
2835 }
2836 #endif
2837
2838 #ifdef TARGET_NR_unlink
2839 static void
2840 print_unlink(const struct syscallname *name,
2841     abi_long arg0, abi_long arg1, abi_long arg2,
2842     abi_long arg3, abi_long arg4, abi_long arg5)
2843 {
2844     print_syscall_prologue(name);
2845     print_string(arg0, 1);
2846     print_syscall_epilogue(name);
2847 }
2848 #endif
2849
2850 #ifdef TARGET_NR_unlinkat
2851 static void
2852 print_unlinkat(const struct syscallname *name,
2853     abi_long arg0, abi_long arg1, abi_long arg2,
2854     abi_long arg3, abi_long arg4, abi_long arg5)
2855 {
2856     print_syscall_prologue(name);
2857     print_at_dirfd(arg0, 0);
2858     print_string(arg1, 0);
2859     print_flags(unlinkat_flags, arg2, 1);
2860     print_syscall_epilogue(name);
2861 }
2862 #endif
2863
2864 #ifdef TARGET_NR_utime
2865 static void
2866 print_utime(const struct syscallname *name,
2867     abi_long arg0, abi_long arg1, abi_long arg2,
2868     abi_long arg3, abi_long arg4, abi_long arg5)
2869 {
2870     print_syscall_prologue(name);
2871     print_string(arg0, 0);
2872     print_pointer(arg1, 1);
2873     print_syscall_epilogue(name);
2874 }
2875 #endif
2876
2877 #ifdef TARGET_NR_utimes
2878 static void
2879 print_utimes(const struct syscallname *name,
2880     abi_long arg0, abi_long arg1, abi_long arg2,
2881     abi_long arg3, abi_long arg4, abi_long arg5)
2882 {
2883     print_syscall_prologue(name);
2884     print_string(arg0, 0);
2885     print_pointer(arg1, 1);
2886     print_syscall_epilogue(name);
2887 }
2888 #endif
2889
2890 #ifdef TARGET_NR_utimensat
2891 static void
2892 print_utimensat(const struct syscallname *name,
2893     abi_long arg0, abi_long arg1, abi_long arg2,
2894     abi_long arg3, abi_long arg4, abi_long arg5)
2895 {
2896     print_syscall_prologue(name);
2897     print_at_dirfd(arg0, 0);
2898     print_string(arg1, 0);
2899     print_pointer(arg2, 0);
2900     print_flags(at_file_flags, arg3, 1);
2901     print_syscall_epilogue(name);
2902 }
2903 #endif
2904
2905 #if defined(TARGET_NR_mmap) || defined(TARGET_NR_mmap2)
2906 static void
2907 print_mmap(const struct syscallname *name,
2908     abi_long arg0, abi_long arg1, abi_long arg2,
2909     abi_long arg3, abi_long arg4, abi_long arg5)
2910 {
2911     print_syscall_prologue(name);
2912     print_pointer(arg0, 0);
2913     print_raw_param("%d", arg1, 0);
2914     print_flags(mmap_prot_flags, arg2, 0);
2915     print_flags(mmap_flags, arg3, 0);
2916     print_raw_param("%d", arg4, 0);
2917     print_raw_param("%#x", arg5, 1);
2918     print_syscall_epilogue(name);
2919 }
2920 #define print_mmap2     print_mmap
2921 #endif
2922
2923 #ifdef TARGET_NR_mprotect
2924 static void
2925 print_mprotect(const struct syscallname *name,
2926     abi_long arg0, abi_long arg1, abi_long arg2,
2927     abi_long arg3, abi_long arg4, abi_long arg5)
2928 {
2929     print_syscall_prologue(name);
2930     print_pointer(arg0, 0);
2931     print_raw_param("%d", arg1, 0);
2932     print_flags(mmap_prot_flags, arg2, 1);
2933     print_syscall_epilogue(name);
2934 }
2935 #endif
2936
2937 #ifdef TARGET_NR_munmap
2938 static void
2939 print_munmap(const struct syscallname *name,
2940     abi_long arg0, abi_long arg1, abi_long arg2,
2941     abi_long arg3, abi_long arg4, abi_long arg5)
2942 {
2943     print_syscall_prologue(name);
2944     print_pointer(arg0, 0);
2945     print_raw_param("%d", arg1, 1);
2946     print_syscall_epilogue(name);
2947 }
2948 #endif
2949
2950 #ifdef TARGET_NR_futex
2951 static void print_futex_op(abi_long tflag, int last)
2952 {
2953 #define print_op(val) \
2954 if( cmd == val ) { \
2955     qemu_log(#val); \
2956     return; \
2957 }
2958
2959     int cmd = (int)tflag;
2960 #ifdef FUTEX_PRIVATE_FLAG
2961     if (cmd & FUTEX_PRIVATE_FLAG) {
2962         qemu_log("FUTEX_PRIVATE_FLAG|");
2963         cmd &= ~FUTEX_PRIVATE_FLAG;
2964     }
2965 #endif
2966 #ifdef FUTEX_CLOCK_REALTIME
2967     if (cmd & FUTEX_CLOCK_REALTIME) {
2968         qemu_log("FUTEX_CLOCK_REALTIME|");
2969         cmd &= ~FUTEX_CLOCK_REALTIME;
2970     }
2971 #endif
2972     print_op(FUTEX_WAIT)
2973     print_op(FUTEX_WAKE)
2974     print_op(FUTEX_FD)
2975     print_op(FUTEX_REQUEUE)
2976     print_op(FUTEX_CMP_REQUEUE)
2977     print_op(FUTEX_WAKE_OP)
2978     print_op(FUTEX_LOCK_PI)
2979     print_op(FUTEX_UNLOCK_PI)
2980     print_op(FUTEX_TRYLOCK_PI)
2981 #ifdef FUTEX_WAIT_BITSET
2982     print_op(FUTEX_WAIT_BITSET)
2983 #endif
2984 #ifdef FUTEX_WAKE_BITSET
2985     print_op(FUTEX_WAKE_BITSET)
2986 #endif
2987     /* unknown values */
2988     qemu_log("%d", cmd);
2989 }
2990
2991 static void
2992 print_futex(const struct syscallname *name,
2993     abi_long arg0, abi_long arg1, abi_long arg2,
2994     abi_long arg3, abi_long arg4, abi_long arg5)
2995 {
2996     print_syscall_prologue(name);
2997     print_pointer(arg0, 0);
2998     print_futex_op(arg1, 0);
2999     print_raw_param(",%d", arg2, 0);
3000     print_pointer(arg3, 0); /* struct timespec */
3001     print_pointer(arg4, 0);
3002     print_raw_param("%d", arg4, 1);
3003     print_syscall_epilogue(name);
3004 }
3005 #endif
3006
3007 #ifdef TARGET_NR_kill
3008 static void
3009 print_kill(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_raw_param("%d", arg0, 0);
3015     print_signal(arg1, 1);
3016     print_syscall_epilogue(name);
3017 }
3018 #endif
3019
3020 #ifdef TARGET_NR_tkill
3021 static void
3022 print_tkill(const struct syscallname *name,
3023     abi_long arg0, abi_long arg1, abi_long arg2,
3024     abi_long arg3, abi_long arg4, abi_long arg5)
3025 {
3026     print_syscall_prologue(name);
3027     print_raw_param("%d", arg0, 0);
3028     print_signal(arg1, 1);
3029     print_syscall_epilogue(name);
3030 }
3031 #endif
3032
3033 #ifdef TARGET_NR_tgkill
3034 static void
3035 print_tgkill(const struct syscallname *name,
3036     abi_long arg0, abi_long arg1, abi_long arg2,
3037     abi_long arg3, abi_long arg4, abi_long arg5)
3038 {
3039     print_syscall_prologue(name);
3040     print_raw_param("%d", arg0, 0);
3041     print_raw_param("%d", arg1, 0);
3042     print_signal(arg2, 1);
3043     print_syscall_epilogue(name);
3044 }
3045 #endif
3046
3047 #ifdef TARGET_NR_statx
3048 static void
3049 print_statx(const struct syscallname *name,
3050             abi_long arg0, abi_long arg1, abi_long arg2,
3051             abi_long arg3, abi_long arg4, abi_long arg5)
3052 {
3053     print_syscall_prologue(name);
3054     print_at_dirfd(arg0, 0);
3055     print_string(arg1, 0);
3056     print_flags(statx_flags, arg2, 0);
3057     print_flags(statx_mask, arg3, 0);
3058     print_pointer(arg4, 1);
3059     print_syscall_epilogue(name);
3060 }
3061 #endif
3062
3063 #ifdef TARGET_NR_ioctl
3064 static void
3065 print_ioctl(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
3072     const IOCTLEntry *ie;
3073     const argtype *arg_type;
3074     void *argptr;
3075     int target_size;
3076
3077     for (ie = ioctl_entries; ie->target_cmd != 0; ie++) {
3078         if (ie->target_cmd == arg1) {
3079             break;
3080         }
3081     }
3082
3083     if (ie->target_cmd == 0) {
3084         print_raw_param("%#x", arg1, 0);
3085         print_raw_param("%#x", arg2, 1);
3086     } else {
3087         qemu_log("%s", ie->name);
3088         arg_type = ie->arg_type;
3089
3090         if (arg_type[0] != TYPE_NULL) {
3091             qemu_log(",");
3092
3093             switch (arg_type[0]) {
3094             case TYPE_PTRVOID:
3095                 print_pointer(arg2, 1);
3096                 break;
3097             case TYPE_CHAR:
3098             case TYPE_SHORT:
3099             case TYPE_INT:
3100                 print_raw_param("%d", arg2, 1);
3101                 break;
3102             case TYPE_LONG:
3103                 print_raw_param(TARGET_ABI_FMT_ld, arg2, 1);
3104                 break;
3105             case TYPE_ULONG:
3106                 print_raw_param(TARGET_ABI_FMT_lu, arg2, 1);
3107                 break;
3108             case TYPE_PTR:
3109                 switch (ie->access) {
3110                 case IOC_R:
3111                     print_pointer(arg2, 1);
3112                     break;
3113                 case IOC_W:
3114                 case IOC_RW:
3115                     arg_type++;
3116                     target_size = thunk_type_size(arg_type, 0);
3117                     argptr = lock_user(VERIFY_READ, arg2, target_size, 1);
3118                     if (argptr) {
3119                         thunk_print(argptr, arg_type);
3120                         unlock_user(argptr, arg2, target_size);
3121                     } else {
3122                         print_pointer(arg2, 1);
3123                     }
3124                     break;
3125                 }
3126                 break;
3127             default:
3128                 g_assert_not_reached();
3129             }
3130         }
3131     }
3132     print_syscall_epilogue(name);
3133 }
3134 #endif
3135
3136 /*
3137  * An array of all of the syscalls we know about
3138  */
3139
3140 static const struct syscallname scnames[] = {
3141 #include "strace.list"
3142 };
3143
3144 static int nsyscalls = ARRAY_SIZE(scnames);
3145
3146 /*
3147  * The public interface to this module.
3148  */
3149 void
3150 print_syscall(int num,
3151               abi_long arg1, abi_long arg2, abi_long arg3,
3152               abi_long arg4, abi_long arg5, abi_long arg6)
3153 {
3154     int i;
3155     const char *format="%s(" TARGET_ABI_FMT_ld "," TARGET_ABI_FMT_ld "," TARGET_ABI_FMT_ld "," TARGET_ABI_FMT_ld "," TARGET_ABI_FMT_ld "," TARGET_ABI_FMT_ld ")";
3156
3157     qemu_log("%d ", getpid());
3158
3159     for(i=0;i<nsyscalls;i++)
3160         if( scnames[i].nr == num ) {
3161             if( scnames[i].call != NULL ) {
3162                 scnames[i].call(
3163                     &scnames[i], arg1, arg2, arg3, arg4, arg5, arg6);
3164             } else {
3165                 /* XXX: this format system is broken because it uses
3166                    host types and host pointers for strings */
3167                 if( scnames[i].format != NULL )
3168                     format = scnames[i].format;
3169                 qemu_log(format,
3170                          scnames[i].name, arg1, arg2, arg3, arg4, arg5, arg6);
3171             }
3172             return;
3173         }
3174     qemu_log("Unknown syscall %d\n", num);
3175 }
3176
3177
3178 void
3179 print_syscall_ret(int num, abi_long ret,
3180                   abi_long arg1, abi_long arg2, abi_long arg3,
3181                   abi_long arg4, abi_long arg5, abi_long arg6)
3182 {
3183     int i;
3184
3185     for(i=0;i<nsyscalls;i++)
3186         if( scnames[i].nr == num ) {
3187             if( scnames[i].result != NULL ) {
3188                 scnames[i].result(&scnames[i], ret,
3189                                   arg1, arg2, arg3,
3190                                   arg4, arg5, arg6);
3191             } else {
3192                 if (!print_syscall_err(ret)) {
3193                     qemu_log(TARGET_ABI_FMT_ld, ret);
3194                 }
3195                 qemu_log("\n");
3196             }
3197             break;
3198         }
3199 }
3200
3201 void print_taken_signal(int target_signum, const target_siginfo_t *tinfo)
3202 {
3203     /* Print the strace output for a signal being taken:
3204      * --- SIGSEGV {si_signo=SIGSEGV, si_code=SI_KERNEL, si_addr=0} ---
3205      */
3206     qemu_log("--- ");
3207     print_signal(target_signum, 1);
3208     qemu_log(" ");
3209     print_siginfo(tinfo);
3210     qemu_log(" ---\n");
3211 }