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