qemu

1
#include "qemu/osdep.h"
2

3
#include <sys/ipc.h>
4
#include <sys/msg.h>
5
#include <sys/sem.h>
6
#include <sys/shm.h>
7
#include <sys/select.h>
8
#include <sys/mount.h>
9
#include <arpa/inet.h>
10
#include <netinet/in.h>
11
#include <netinet/tcp.h>
12
#include <netinet/udp.h>
13
#include <linux/if_packet.h>
14
#include <linux/in6.h>
15
#include <linux/netlink.h>
16
#include <sched.h>
17
#include "qemu.h"
18
#include "user-internals.h"
19
#include "strace.h"
20
#include "signal-common.h"
21
#include "target_mman.h"
22

23
struct syscallname {
24
    int nr;
25
    const char *name;
26
    const char *format;
27
    void (*call)(CPUArchState *, const struct syscallname *,
28
                 abi_long, abi_long, abi_long,
29
                 abi_long, abi_long, abi_long);
30
    void (*result)(CPUArchState *, const struct syscallname *, abi_long,
31
                   abi_long, abi_long, abi_long,
32
                   abi_long, abi_long, abi_long);
33
};
34

35
/*
36
 * It is possible that target doesn't have syscall that uses
37
 * following flags but we don't want the compiler to warn
38
 * us about them being unused.  Same applies to utility print
39
 * functions.  It is ok to keep them while not used.
40
 */
41
#define UNUSED __attribute__ ((unused))
42

43
/*
44
 * Structure used to translate flag values into strings.  This is
45
 * similar that is in the actual strace tool.
46
 */
47
struct flags {
48
    abi_long    f_value;  /* flag */
49
    abi_long    f_mask;   /* mask */
50
    const char  *f_string; /* stringified flag */
51
};
52

53
/* No 'struct flags' element should have a zero mask. */
54
#define FLAG_BASIC(V, M, N)      { V, M | QEMU_BUILD_BUG_ON_ZERO(!(M)), N }
55

56
/* common flags for all architectures */
57
#define FLAG_GENERIC_MASK(V, M)  FLAG_BASIC(V, M, #V)
58
#define FLAG_GENERIC(V)          FLAG_BASIC(V, V, #V)
59
/* target specific flags (syscall_defs.h has TARGET_<flag>) */
60
#define FLAG_TARGET_MASK(V, M)   FLAG_BASIC(TARGET_##V, TARGET_##M, #V)
61
#define FLAG_TARGET(V)           FLAG_BASIC(TARGET_##V, TARGET_##V, #V)
62
/* end of flags array */
63
#define FLAG_END           { 0, 0, NULL }
64

65
/* Structure used to translate enumerated values into strings */
66
struct enums {
67
    abi_long    e_value;   /* enum value */
68
    const char  *e_string; /* stringified enum */
69
};
70

71
/* common enums for all architectures */
72
#define ENUM_GENERIC(name) { name, #name }
73
/* target specific enums */
74
#define ENUM_TARGET(name)  { TARGET_ ## name, #name }
75
/* end of enums array */
76
#define ENUM_END           { 0, NULL }
77

78
UNUSED static const char *get_comma(int);
79
UNUSED static void print_pointer(abi_long, int);
80
UNUSED static void print_flags(const struct flags *, abi_long, int);
81
UNUSED static void print_enums(const struct enums *, abi_long, int);
82
UNUSED static void print_at_dirfd(abi_long, int);
83
UNUSED static void print_file_mode(abi_long, int);
84
UNUSED static void print_open_flags(abi_long, int);
85
UNUSED static void print_syscall_prologue(const struct syscallname *);
86
UNUSED static void print_syscall_epilogue(const struct syscallname *);
87
UNUSED static void print_string(abi_long, int);
88
UNUSED static void print_buf(abi_long addr, abi_long len, int last);
89
UNUSED static void print_raw_param(const char *, abi_long, int);
90
UNUSED static void print_raw_param64(const char *, long long, int last);
91
UNUSED static void print_timeval(abi_ulong, int);
92
UNUSED static void print_timespec(abi_ulong, int);
93
UNUSED static void print_timespec64(abi_ulong, int);
94
UNUSED static void print_timezone(abi_ulong, int);
95
UNUSED static void print_itimerval(abi_ulong, int);
96
UNUSED static void print_number(abi_long, int);
97
UNUSED static void print_signal(abi_ulong, int);
98
UNUSED static void print_sockaddr(abi_ulong, abi_long, int);
99
UNUSED static void print_socket_domain(int domain);
100
UNUSED static void print_socket_type(int type);
101
UNUSED static void print_socket_protocol(int domain, int type, int protocol);
102

103
/*
104
 * Utility functions
105
 */
106
static void
107
print_ipc_cmd(int cmd)
108
{
109
#define output_cmd(val) \
110
if( cmd == val ) { \
111
    qemu_log(#val); \
112
    return; \
113
}
114

115
    cmd &= 0xff;
116

117
    /* General IPC commands */
118
    output_cmd( IPC_RMID );
119
    output_cmd( IPC_SET );
120
    output_cmd( IPC_STAT );
121
    output_cmd( IPC_INFO );
122
    /* msgctl() commands */
123
    output_cmd( MSG_STAT );
124
    output_cmd( MSG_INFO );
125
    /* shmctl() commands */
126
    output_cmd( SHM_LOCK );
127
    output_cmd( SHM_UNLOCK );
128
    output_cmd( SHM_STAT );
129
    output_cmd( SHM_INFO );
130
    /* semctl() commands */
131
    output_cmd( GETPID );
132
    output_cmd( GETVAL );
133
    output_cmd( GETALL );
134
    output_cmd( GETNCNT );
135
    output_cmd( GETZCNT );
136
    output_cmd( SETVAL );
137
    output_cmd( SETALL );
138
    output_cmd( SEM_STAT );
139
    output_cmd( SEM_INFO );
140
    output_cmd( IPC_RMID );
141
    output_cmd( IPC_RMID );
142
    output_cmd( IPC_RMID );
143
    output_cmd( IPC_RMID );
144
    output_cmd( IPC_RMID );
145
    output_cmd( IPC_RMID );
146
    output_cmd( IPC_RMID );
147
    output_cmd( IPC_RMID );
148
    output_cmd( IPC_RMID );
149

150
    /* Some value we don't recognize */
151
    qemu_log("%d", cmd);
152
}
153

154
static const char * const target_signal_name[] = {
155
#define MAKE_SIG_ENTRY(sig)     [TARGET_##sig] = #sig,
156
        MAKE_SIGNAL_LIST
157
#undef MAKE_SIG_ENTRY
158
};
159

160
static void
161
print_signal(abi_ulong arg, int last)
162
{
163
    const char *signal_name = NULL;
164

165
    if (arg < ARRAY_SIZE(target_signal_name)) {
166
        signal_name = target_signal_name[arg];
167
    }
168

169
    if (signal_name == NULL) {
170
        print_raw_param("%ld", arg, last);
171
        return;
172
    }
173
    qemu_log("%s%s", signal_name, get_comma(last));
174
}
175

176
static void print_si_code(int arg)
177
{
178
    const char *codename = NULL;
179

180
    switch (arg) {
181
    case SI_USER:
182
        codename = "SI_USER";
183
        break;
184
    case SI_KERNEL:
185
        codename = "SI_KERNEL";
186
        break;
187
    case SI_QUEUE:
188
        codename = "SI_QUEUE";
189
        break;
190
    case SI_TIMER:
191
        codename = "SI_TIMER";
192
        break;
193
    case SI_MESGQ:
194
        codename = "SI_MESGQ";
195
        break;
196
    case SI_ASYNCIO:
197
        codename = "SI_ASYNCIO";
198
        break;
199
    case SI_SIGIO:
200
        codename = "SI_SIGIO";
201
        break;
202
    case SI_TKILL:
203
        codename = "SI_TKILL";
204
        break;
205
    default:
206
        qemu_log("%d", arg);
207
        return;
208
    }
209
    qemu_log("%s", codename);
210
}
211

212
static void get_target_siginfo(target_siginfo_t *tinfo,
213
                                const target_siginfo_t *info)
214
{
215
    abi_ulong sival_ptr;
216

217
    int sig;
218
    int si_errno;
219
    int si_code;
220
    int si_type;
221

222
    __get_user(sig, &info->si_signo);
223
    __get_user(si_errno, &tinfo->si_errno);
224
    __get_user(si_code, &info->si_code);
225

226
    tinfo->si_signo = sig;
227
    tinfo->si_errno = si_errno;
228
    tinfo->si_code = si_code;
229

230
    /* Ensure we don't leak random junk to the guest later */
231
    memset(tinfo->_sifields._pad, 0, sizeof(tinfo->_sifields._pad));
232

233
    /* This is awkward, because we have to use a combination of
234
     * the si_code and si_signo to figure out which of the union's
235
     * members are valid. (Within the host kernel it is always possible
236
     * to tell, but the kernel carefully avoids giving userspace the
237
     * high 16 bits of si_code, so we don't have the information to
238
     * do this the easy way...) We therefore make our best guess,
239
     * bearing in mind that a guest can spoof most of the si_codes
240
     * via rt_sigqueueinfo() if it likes.
241
     *
242
     * Once we have made our guess, we record it in the top 16 bits of
243
     * the si_code, so that print_siginfo() later can use it.
244
     * print_siginfo() will strip these top bits out before printing
245
     * the si_code.
246
     */
247

248
    switch (si_code) {
249
    case SI_USER:
250
    case SI_TKILL:
251
    case SI_KERNEL:
252
        /* Sent via kill(), tkill() or tgkill(), or direct from the kernel.
253
         * These are the only unspoofable si_code values.
254
         */
255
        __get_user(tinfo->_sifields._kill._pid, &info->_sifields._kill._pid);
256
        __get_user(tinfo->_sifields._kill._uid, &info->_sifields._kill._uid);
257
        si_type = QEMU_SI_KILL;
258
        break;
259
    default:
260
        /* Everything else is spoofable. Make best guess based on signal */
261
        switch (sig) {
262
        case TARGET_SIGCHLD:
263
            __get_user(tinfo->_sifields._sigchld._pid,
264
                       &info->_sifields._sigchld._pid);
265
            __get_user(tinfo->_sifields._sigchld._uid,
266
                       &info->_sifields._sigchld._uid);
267
            __get_user(tinfo->_sifields._sigchld._status,
268
                       &info->_sifields._sigchld._status);
269
            __get_user(tinfo->_sifields._sigchld._utime,
270
                       &info->_sifields._sigchld._utime);
271
            __get_user(tinfo->_sifields._sigchld._stime,
272
                       &info->_sifields._sigchld._stime);
273
            si_type = QEMU_SI_CHLD;
274
            break;
275
        case TARGET_SIGIO:
276
            __get_user(tinfo->_sifields._sigpoll._band,
277
                       &info->_sifields._sigpoll._band);
278
            __get_user(tinfo->_sifields._sigpoll._fd,
279
                       &info->_sifields._sigpoll._fd);
280
            si_type = QEMU_SI_POLL;
281
            break;
282
        default:
283
            /* Assume a sigqueue()/mq_notify()/rt_sigqueueinfo() source. */
284
            __get_user(tinfo->_sifields._rt._pid, &info->_sifields._rt._pid);
285
            __get_user(tinfo->_sifields._rt._uid, &info->_sifields._rt._uid);
286
            /* XXX: potential problem if 64 bit */
287
            __get_user(sival_ptr, &info->_sifields._rt._sigval.sival_ptr);
288
            tinfo->_sifields._rt._sigval.sival_ptr = sival_ptr;
289

290
            si_type = QEMU_SI_RT;
291
            break;
292
        }
293
        break;
294
    }
295

296
    tinfo->si_code = deposit32(si_code, 16, 16, si_type);
297
}
298

299
static void print_siginfo(const target_siginfo_t *tinfo)
300
{
301
    /* Print a target_siginfo_t in the format desired for printing
302
     * signals being taken. We assume the target_siginfo_t is in the
303
     * internal form where the top 16 bits of si_code indicate which
304
     * part of the union is valid, rather than in the guest-visible
305
     * form where the bottom 16 bits are sign-extended into the top 16.
306
     */
307
    int si_type = extract32(tinfo->si_code, 16, 16);
308
    int si_code = sextract32(tinfo->si_code, 0, 16);
309

310
    qemu_log("{si_signo=");
311
    print_signal(tinfo->si_signo, 1);
312
    qemu_log(", si_code=");
313
    print_si_code(si_code);
314

315
    switch (si_type) {
316
    case QEMU_SI_KILL:
317
        qemu_log(", si_pid=%u, si_uid=%u",
318
                 (unsigned int)tinfo->_sifields._kill._pid,
319
                 (unsigned int)tinfo->_sifields._kill._uid);
320
        break;
321
    case QEMU_SI_TIMER:
322
        qemu_log(", si_timer1=%u, si_timer2=%u",
323
                 tinfo->_sifields._timer._timer1,
324
                 tinfo->_sifields._timer._timer2);
325
        break;
326
    case QEMU_SI_POLL:
327
        qemu_log(", si_band=%d, si_fd=%d",
328
                 tinfo->_sifields._sigpoll._band,
329
                 tinfo->_sifields._sigpoll._fd);
330
        break;
331
    case QEMU_SI_FAULT:
332
        qemu_log(", si_addr=");
333
        print_pointer(tinfo->_sifields._sigfault._addr, 1);
334
        break;
335
    case QEMU_SI_CHLD:
336
        qemu_log(", si_pid=%u, si_uid=%u, si_status=%d"
337
                 ", si_utime=" TARGET_ABI_FMT_ld
338
                 ", si_stime=" TARGET_ABI_FMT_ld,
339
                 (unsigned int)(tinfo->_sifields._sigchld._pid),
340
                 (unsigned int)(tinfo->_sifields._sigchld._uid),
341
                 tinfo->_sifields._sigchld._status,
342
                 tinfo->_sifields._sigchld._utime,
343
                 tinfo->_sifields._sigchld._stime);
344
        break;
345
    case QEMU_SI_RT:
346
        qemu_log(", si_pid=%u, si_uid=%u, si_sigval=" TARGET_ABI_FMT_ld,
347
                 (unsigned int)tinfo->_sifields._rt._pid,
348
                 (unsigned int)tinfo->_sifields._rt._uid,
349
                 tinfo->_sifields._rt._sigval.sival_ptr);
350
        break;
351
    default:
352
        g_assert_not_reached();
353
    }
354
    qemu_log("}");
355
}
356

357
static void
358
print_sockaddr(abi_ulong addr, abi_long addrlen, int last)
359
{
360
    struct target_sockaddr *sa;
361
    int i;
362
    int sa_family;
363

364
    sa = lock_user(VERIFY_READ, addr, addrlen, 1);
365
    if (sa) {
366
        sa_family = tswap16(sa->sa_family);
367
        switch (sa_family) {
368
        case AF_UNIX: {
369
            struct target_sockaddr_un *un = (struct target_sockaddr_un *)sa;
370
            qemu_log("{sun_family=AF_UNIX,sun_path=\"");
371
            for (i = 0; i < addrlen -
372
                            offsetof(struct target_sockaddr_un, sun_path) &&
373
                 un->sun_path[i]; i++) {
374
                qemu_log("%c", un->sun_path[i]);
375
            }
376
            qemu_log("\"}");
377
            break;
378
        }
379
        case AF_INET: {
380
            struct target_sockaddr_in *in = (struct target_sockaddr_in *)sa;
381
            uint8_t *c = (uint8_t *)&in->sin_addr.s_addr;
382
            qemu_log("{sin_family=AF_INET,sin_port=htons(%d),",
383
                     ntohs(in->sin_port));
384
            qemu_log("sin_addr=inet_addr(\"%d.%d.%d.%d\")",
385
                     c[0], c[1], c[2], c[3]);
386
            qemu_log("}");
387
            break;
388
        }
389
        case AF_PACKET: {
390
            struct target_sockaddr_ll *ll = (struct target_sockaddr_ll *)sa;
391
            uint8_t *c = (uint8_t *)&ll->sll_addr;
392
            qemu_log("{sll_family=AF_PACKET,"
393
                     "sll_protocol=htons(0x%04x),if%d,pkttype=",
394
                     ntohs(ll->sll_protocol), ll->sll_ifindex);
395
            switch (ll->sll_pkttype) {
396
            case PACKET_HOST:
397
                qemu_log("PACKET_HOST");
398
                break;
399
            case PACKET_BROADCAST:
400
                qemu_log("PACKET_BROADCAST");
401
                break;
402
            case PACKET_MULTICAST:
403
                qemu_log("PACKET_MULTICAST");
404
                break;
405
            case PACKET_OTHERHOST:
406
                qemu_log("PACKET_OTHERHOST");
407
                break;
408
            case PACKET_OUTGOING:
409
                qemu_log("PACKET_OUTGOING");
410
                break;
411
            default:
412
                qemu_log("%d", ll->sll_pkttype);
413
                break;
414
            }
415
            qemu_log(",sll_addr=%02x:%02x:%02x:%02x:%02x:%02x:%02x:%02x",
416
                     c[0], c[1], c[2], c[3], c[4], c[5], c[6], c[7]);
417
            qemu_log("}");
418
            break;
419
        }
420
        case AF_NETLINK: {
421
            struct target_sockaddr_nl *nl = (struct target_sockaddr_nl *)sa;
422
            qemu_log("{nl_family=AF_NETLINK,nl_pid=%u,nl_groups=%u}",
423
                     tswap32(nl->nl_pid), tswap32(nl->nl_groups));
424
            break;
425
        }
426
        default:
427
            qemu_log("{sa_family=%d, sa_data={", sa->sa_family);
428
            for (i = 0; i < 13; i++) {
429
                qemu_log("%02x, ", sa->sa_data[i]);
430
            }
431
            qemu_log("%02x}", sa->sa_data[i]);
432
            qemu_log("}");
433
            break;
434
        }
435
        unlock_user(sa, addr, 0);
436
    } else {
437
        print_raw_param("0x"TARGET_ABI_FMT_lx, addr, 0);
438
    }
439
    qemu_log(", "TARGET_ABI_FMT_ld"%s", addrlen, get_comma(last));
440
}
441

442
static void
443
print_socket_domain(int domain)
444
{
445
    switch (domain) {
446
    case PF_UNIX:
447
        qemu_log("PF_UNIX");
448
        break;
449
    case PF_INET:
450
        qemu_log("PF_INET");
451
        break;
452
    case PF_NETLINK:
453
        qemu_log("PF_NETLINK");
454
        break;
455
    case PF_PACKET:
456
        qemu_log("PF_PACKET");
457
        break;
458
    default:
459
        qemu_log("%d", domain);
460
        break;
461
    }
462
}
463

464
static void
465
print_socket_type(int type)
466
{
467
    switch (type & TARGET_SOCK_TYPE_MASK) {
468
    case TARGET_SOCK_DGRAM:
469
        qemu_log("SOCK_DGRAM");
470
        break;
471
    case TARGET_SOCK_STREAM:
472
        qemu_log("SOCK_STREAM");
473
        break;
474
    case TARGET_SOCK_RAW:
475
        qemu_log("SOCK_RAW");
476
        break;
477
    case TARGET_SOCK_RDM:
478
        qemu_log("SOCK_RDM");
479
        break;
480
    case TARGET_SOCK_SEQPACKET:
481
        qemu_log("SOCK_SEQPACKET");
482
        break;
483
    case TARGET_SOCK_PACKET:
484
        qemu_log("SOCK_PACKET");
485
        break;
486
    }
487
    if (type & TARGET_SOCK_CLOEXEC) {
488
        qemu_log("|SOCK_CLOEXEC");
489
    }
490
    if (type & TARGET_SOCK_NONBLOCK) {
491
        qemu_log("|SOCK_NONBLOCK");
492
    }
493
}
494

495
static void
496
print_socket_protocol(int domain, int type, int protocol)
497
{
498
    if (domain == AF_PACKET ||
499
        (domain == AF_INET && type == TARGET_SOCK_PACKET)) {
500
        switch (protocol) {
501
        case 0x0003:
502
            qemu_log("ETH_P_ALL");
503
            break;
504
        default:
505
            qemu_log("%d", protocol);
506
        }
507
        return;
508
    }
509

510
    if (domain == PF_NETLINK) {
511
        switch (protocol) {
512
        case NETLINK_ROUTE:
513
            qemu_log("NETLINK_ROUTE");
514
            break;
515
        case NETLINK_UNUSED:
516
            qemu_log("NETLINK_UNUSED");
517
            break;
518
        case NETLINK_USERSOCK:
519
            qemu_log("NETLINK_USERSOCK");
520
            break;
521
        case NETLINK_FIREWALL:
522
            qemu_log("NETLINK_FIREWALL");
523
            break;
524
        case NETLINK_SOCK_DIAG:
525
            qemu_log("NETLINK_SOCK_DIAG");
526
            break;
527
        case NETLINK_NFLOG:
528
            qemu_log("NETLINK_NFLOG");
529
            break;
530
        case NETLINK_XFRM:
531
            qemu_log("NETLINK_XFRM");
532
            break;
533
        case NETLINK_SELINUX:
534
            qemu_log("NETLINK_SELINUX");
535
            break;
536
        case NETLINK_ISCSI:
537
            qemu_log("NETLINK_ISCSI");
538
            break;
539
        case NETLINK_AUDIT:
540
            qemu_log("NETLINK_AUDIT");
541
            break;
542
        case NETLINK_FIB_LOOKUP:
543
            qemu_log("NETLINK_FIB_LOOKUP");
544
            break;
545
        case NETLINK_CONNECTOR:
546
            qemu_log("NETLINK_CONNECTOR");
547
            break;
548
        case NETLINK_NETFILTER:
549
            qemu_log("NETLINK_NETFILTER");
550
            break;
551
        case NETLINK_IP6_FW:
552
            qemu_log("NETLINK_IP6_FW");
553
            break;
554
        case NETLINK_DNRTMSG:
555
            qemu_log("NETLINK_DNRTMSG");
556
            break;
557
        case NETLINK_KOBJECT_UEVENT:
558
            qemu_log("NETLINK_KOBJECT_UEVENT");
559
            break;
560
        case NETLINK_GENERIC:
561
            qemu_log("NETLINK_GENERIC");
562
            break;
563
        case NETLINK_SCSITRANSPORT:
564
            qemu_log("NETLINK_SCSITRANSPORT");
565
            break;
566
        case NETLINK_ECRYPTFS:
567
            qemu_log("NETLINK_ECRYPTFS");
568
            break;
569
        case NETLINK_RDMA:
570
            qemu_log("NETLINK_RDMA");
571
            break;
572
        case NETLINK_CRYPTO:
573
            qemu_log("NETLINK_CRYPTO");
574
            break;
575
        case NETLINK_SMC:
576
            qemu_log("NETLINK_SMC");
577
            break;
578
        default:
579
            qemu_log("%d", protocol);
580
            break;
581
        }
582
        return;
583
    }
584

585
    switch (protocol) {
586
    case IPPROTO_IP:
587
        qemu_log("IPPROTO_IP");
588
        break;
589
    case IPPROTO_TCP:
590
        qemu_log("IPPROTO_TCP");
591
        break;
592
    case IPPROTO_UDP:
593
        qemu_log("IPPROTO_UDP");
594
        break;
595
    case IPPROTO_RAW:
596
        qemu_log("IPPROTO_RAW");
597
        break;
598
    default:
599
        qemu_log("%d", protocol);
600
        break;
601
    }
602
}
603

604

605
#ifdef TARGET_NR__newselect
606
static void
607
print_fdset(int n, abi_ulong target_fds_addr)
608
{
609
    int i;
610
    int first = 1;
611

612
    qemu_log("[");
613
    if( target_fds_addr ) {
614
        abi_long *target_fds;
615

616
        target_fds = lock_user(VERIFY_READ,
617
                               target_fds_addr,
618
                               sizeof(*target_fds)*(n / TARGET_ABI_BITS + 1),
619
                               1);
620

621
        if (!target_fds)
622
            return;
623

624
        for (i=n; i>=0; i--) {
625
            if ((tswapal(target_fds[i / TARGET_ABI_BITS]) >>
626
                (i & (TARGET_ABI_BITS - 1))) & 1) {
627
                qemu_log("%s%d", get_comma(first), i);
628
                first = 0;
629
            }
630
        }
631
        unlock_user(target_fds, target_fds_addr, 0);
632
    }
633
    qemu_log("]");
634
}
635
#endif
636

637
/*
638
 * Sysycall specific output functions
639
 */
640

641
/* select */
642
#ifdef TARGET_NR__newselect
643
static void
644
print_newselect(CPUArchState *cpu_env, const struct syscallname *name,
645
                abi_long arg1, abi_long arg2, abi_long arg3,
646
                abi_long arg4, abi_long arg5, abi_long arg6)
647
{
648
    print_syscall_prologue(name);
649
    print_fdset(arg1, arg2);
650
    qemu_log(",");
651
    print_fdset(arg1, arg3);
652
    qemu_log(",");
653
    print_fdset(arg1, arg4);
654
    qemu_log(",");
655
    print_timeval(arg5, 1);
656
    print_syscall_epilogue(name);
657
}
658
#endif
659

660
static void
661
print_semctl(CPUArchState *cpu_env, const struct syscallname *name,
662
             abi_long arg1, abi_long arg2, abi_long arg3,
663
             abi_long arg4, abi_long arg5, abi_long arg6)
664
{
665
    qemu_log("%s(" TARGET_ABI_FMT_ld "," TARGET_ABI_FMT_ld ",",
666
             name->name, arg1, arg2);
667
    print_ipc_cmd(arg3);
668
    qemu_log(",0x" TARGET_ABI_FMT_lx ")", arg4);
669
}
670

671
static void
672
print_shmat(CPUArchState *cpu_env, const struct syscallname *name,
673
            abi_long arg0, abi_long arg1, abi_long arg2,
674
            abi_long arg3, abi_long arg4, abi_long arg5)
675
{
676
    static const struct flags shmat_flags[] = {
677
        FLAG_GENERIC(SHM_RND),
678
        FLAG_GENERIC(SHM_REMAP),
679
        FLAG_GENERIC(SHM_RDONLY),
680
        FLAG_GENERIC(SHM_EXEC),
681
        FLAG_END
682
    };
683

684
    print_syscall_prologue(name);
685
    print_raw_param(TARGET_ABI_FMT_ld, arg0, 0);
686
    print_pointer(arg1, 0);
687
    print_flags(shmat_flags, arg2, 1);
688
    print_syscall_epilogue(name);
689
}
690

691
#ifdef TARGET_NR_ipc
692
static void
693
print_ipc(CPUArchState *cpu_env, const struct syscallname *name,
694
          abi_long arg1, abi_long arg2, abi_long arg3,
695
          abi_long arg4, abi_long arg5, abi_long arg6)
696
{
697
    switch(arg1) {
698
    case IPCOP_semctl:
699
        print_semctl(cpu_env, &(const struct syscallname){ .name = "semctl" },
700
                     arg2, arg3, arg4, arg5, 0, 0);
701
        break;
702
    case IPCOP_shmat:
703
        print_shmat(cpu_env, &(const struct syscallname){ .name = "shmat" },
704
                    arg2, arg5, arg3, 0, 0, 0);
705
        break;
706
    default:
707
        qemu_log(("%s("
708
                  TARGET_ABI_FMT_ld ","
709
                  TARGET_ABI_FMT_ld ","
710
                  TARGET_ABI_FMT_ld ","
711
                  TARGET_ABI_FMT_ld
712
                  ")"),
713
                 name->name, arg1, arg2, arg3, arg4);
714
    }
715
}
716
#endif
717

718
/*
719
 * Variants for the return value output function
720
 */
721

722
static bool
723
print_syscall_err(abi_long ret)
724
{
725
    const char *errstr;
726

727
    qemu_log(" = ");
728
    if (is_error(ret)) {
729
        errstr = target_strerror(-ret);
730
        if (errstr) {
731
            qemu_log("-1 errno=%d (%s)", (int)-ret, errstr);
732
            return true;
733
        }
734
    }
735
    return false;
736
}
737

738
static void
739
print_syscall_ret_addr(CPUArchState *cpu_env, const struct syscallname *name,
740
                       abi_long ret, abi_long arg0, abi_long arg1,
741
                       abi_long arg2, abi_long arg3, abi_long arg4,
742
                       abi_long arg5)
743
{
744
    if (!print_syscall_err(ret)) {
745
        qemu_log("0x" TARGET_ABI_FMT_lx, ret);
746
    }
747
    qemu_log("\n");
748
}
749

750
#if 0 /* currently unused */
751
static void
752
print_syscall_ret_raw(struct syscallname *name, abi_long ret)
753
{
754
        qemu_log(" = 0x" TARGET_ABI_FMT_lx "\n", ret);
755
}
756
#endif
757

758
#ifdef TARGET_NR__newselect
759
static void
760
print_syscall_ret_newselect(CPUArchState *cpu_env, const struct syscallname *name,
761
                            abi_long ret, abi_long arg0, abi_long arg1,
762
                            abi_long arg2, abi_long arg3, abi_long arg4,
763
                            abi_long arg5)
764
{
765
    if (!print_syscall_err(ret)) {
766
        qemu_log(" = 0x" TARGET_ABI_FMT_lx " (", ret);
767
        print_fdset(arg0, arg1);
768
        qemu_log(",");
769
        print_fdset(arg0, arg2);
770
        qemu_log(",");
771
        print_fdset(arg0, arg3);
772
        qemu_log(",");
773
        print_timeval(arg4, 1);
774
        qemu_log(")");
775
    }
776

777
    qemu_log("\n");
778
}
779
#endif
780

781
/* special meanings of adjtimex()' non-negative return values */
782
#define TARGET_TIME_OK       0   /* clock synchronized, no leap second */
783
#define TARGET_TIME_INS      1   /* insert leap second */
784
#define TARGET_TIME_DEL      2   /* delete leap second */
785
#define TARGET_TIME_OOP      3   /* leap second in progress */
786
#define TARGET_TIME_WAIT     4   /* leap second has occurred */
787
#define TARGET_TIME_ERROR    5   /* clock not synchronized */
788
#ifdef TARGET_NR_adjtimex
789
static void
790
print_syscall_ret_adjtimex(CPUArchState *cpu_env, const struct syscallname *name,
791
                           abi_long ret, abi_long arg0, abi_long arg1,
792
                           abi_long arg2, abi_long arg3, abi_long arg4,
793
                           abi_long arg5)
794
{
795
    if (!print_syscall_err(ret)) {
796
        qemu_log(TARGET_ABI_FMT_ld, ret);
797
        switch (ret) {
798
        case TARGET_TIME_OK:
799
            qemu_log(" TIME_OK (clock synchronized, no leap second)");
800
            break;
801
        case TARGET_TIME_INS:
802
            qemu_log(" TIME_INS (insert leap second)");
803
            break;
804
        case TARGET_TIME_DEL:
805
            qemu_log(" TIME_DEL (delete leap second)");
806
            break;
807
        case TARGET_TIME_OOP:
808
            qemu_log(" TIME_OOP (leap second in progress)");
809
            break;
810
        case TARGET_TIME_WAIT:
811
            qemu_log(" TIME_WAIT (leap second has occurred)");
812
            break;
813
        case TARGET_TIME_ERROR:
814
            qemu_log(" TIME_ERROR (clock not synchronized)");
815
            break;
816
        }
817
    }
818

819
    qemu_log("\n");
820
}
821
#endif
822

823
#if defined(TARGET_NR_clock_gettime) || defined(TARGET_NR_clock_getres)
824
static void
825
print_syscall_ret_clock_gettime(CPUArchState *cpu_env, const struct syscallname *name,
826
                                abi_long ret, abi_long arg0, abi_long arg1,
827
                                abi_long arg2, abi_long arg3, abi_long arg4,
828
                                abi_long arg5)
829
{
830
    if (!print_syscall_err(ret)) {
831
        qemu_log(TARGET_ABI_FMT_ld, ret);
832
        qemu_log(" (");
833
        print_timespec(arg1, 1);
834
        qemu_log(")");
835
    }
836

837
    qemu_log("\n");
838
}
839
#define print_syscall_ret_clock_getres     print_syscall_ret_clock_gettime
840
#endif
841

842
#if defined(TARGET_NR_clock_gettime64)
843
static void
844
print_syscall_ret_clock_gettime64(CPUArchState *cpu_env, const struct syscallname *name,
845
                                abi_long ret, abi_long arg0, abi_long arg1,
846
                                abi_long arg2, abi_long arg3, abi_long arg4,
847
                                abi_long arg5)
848
{
849
    if (!print_syscall_err(ret)) {
850
        qemu_log(TARGET_ABI_FMT_ld, ret);
851
        qemu_log(" (");
852
        print_timespec64(arg1, 1);
853
        qemu_log(")");
854
    }
855

856
    qemu_log("\n");
857
}
858
#endif
859

860
#ifdef TARGET_NR_gettimeofday
861
static void
862
print_syscall_ret_gettimeofday(CPUArchState *cpu_env, const struct syscallname *name,
863
                               abi_long ret, abi_long arg0, abi_long arg1,
864
                               abi_long arg2, abi_long arg3, abi_long arg4,
865
                               abi_long arg5)
866
{
867
    if (!print_syscall_err(ret)) {
868
        qemu_log(TARGET_ABI_FMT_ld, ret);
869
        qemu_log(" (");
870
        print_timeval(arg0, 0);
871
        print_timezone(arg1, 1);
872
        qemu_log(")");
873
    }
874

875
    qemu_log("\n");
876
}
877
#endif
878

879
#ifdef TARGET_NR_getitimer
880
static void
881
print_syscall_ret_getitimer(CPUArchState *cpu_env, const struct syscallname *name,
882
                            abi_long ret, abi_long arg0, abi_long arg1,
883
                            abi_long arg2, abi_long arg3, abi_long arg4,
884
                            abi_long arg5)
885
{
886
    if (!print_syscall_err(ret)) {
887
        qemu_log(TARGET_ABI_FMT_ld, ret);
888
        qemu_log(" (");
889
        print_itimerval(arg1, 1);
890
        qemu_log(")");
891
    }
892

893
    qemu_log("\n");
894
}
895
#endif
896

897

898
#ifdef TARGET_NR_getitimer
899
static void
900
print_syscall_ret_setitimer(CPUArchState *cpu_env, const struct syscallname *name,
901
                            abi_long ret, abi_long arg0, abi_long arg1,
902
                            abi_long arg2, abi_long arg3, abi_long arg4,
903
                            abi_long arg5)
904
{
905
    if (!print_syscall_err(ret)) {
906
        qemu_log(TARGET_ABI_FMT_ld, ret);
907
        qemu_log(" (old_value = ");
908
        print_itimerval(arg2, 1);
909
        qemu_log(")");
910
    }
911

912
    qemu_log("\n");
913
}
914
#endif
915

916
#if defined(TARGET_NR_listxattr) || defined(TARGET_NR_llistxattr) \
917
 || defined(TARGGET_NR_flistxattr)
918
static void
919
print_syscall_ret_listxattr(CPUArchState *cpu_env, const struct syscallname *name,
920
                            abi_long ret, abi_long arg0, abi_long arg1,
921
                            abi_long arg2, abi_long arg3, abi_long arg4,
922
                            abi_long arg5)
923
{
924
    if (!print_syscall_err(ret)) {
925
        qemu_log(TARGET_ABI_FMT_ld, ret);
926
        qemu_log(" (list = ");
927
        if (arg1 != 0) {
928
            abi_long attr = arg1;
929
            while (ret) {
930
                if (attr != arg1) {
931
                    qemu_log(",");
932
                }
933
                print_string(attr, 1);
934
                ret -= target_strlen(attr) + 1;
935
                attr += target_strlen(attr) + 1;
936
            }
937
        } else {
938
            qemu_log("NULL");
939
        }
940
        qemu_log(")");
941
    }
942

943
    qemu_log("\n");
944
}
945
#define print_syscall_ret_llistxattr     print_syscall_ret_listxattr
946
#define print_syscall_ret_flistxattr     print_syscall_ret_listxattr
947
#endif
948

949
#ifdef TARGET_NR_ioctl
950
static void
951
print_syscall_ret_ioctl(CPUArchState *cpu_env, const struct syscallname *name,
952
                        abi_long ret, abi_long arg0, abi_long arg1,
953
                        abi_long arg2, abi_long arg3, abi_long arg4,
954
                        abi_long arg5)
955
{
956
    if (!print_syscall_err(ret)) {
957
        qemu_log(TARGET_ABI_FMT_ld, ret);
958

959
        const IOCTLEntry *ie;
960
        const argtype *arg_type;
961
        void *argptr;
962
        int target_size;
963

964
        for (ie = ioctl_entries; ie->target_cmd != 0; ie++) {
965
            if (ie->target_cmd == arg1) {
966
                break;
967
            }
968
        }
969

970
        if (ie->target_cmd == arg1 &&
971
           (ie->access == IOC_R || ie->access == IOC_RW)) {
972
            arg_type = ie->arg_type;
973
            qemu_log(" (");
974
            arg_type++;
975
            target_size = thunk_type_size(arg_type, 0);
976
            argptr = lock_user(VERIFY_READ, arg2, target_size, 1);
977
            if (argptr) {
978
                thunk_print(argptr, arg_type);
979
                unlock_user(argptr, arg2, target_size);
980
            } else {
981
                print_pointer(arg2, 1);
982
            }
983
            qemu_log(")");
984
        }
985
    }
986
    qemu_log("\n");
987
}
988
#endif
989

990
UNUSED static const struct flags access_flags[] = {
991
    FLAG_GENERIC_MASK(F_OK, R_OK | W_OK | X_OK),
992
    FLAG_GENERIC(R_OK),
993
    FLAG_GENERIC(W_OK),
994
    FLAG_GENERIC(X_OK),
995
    FLAG_END,
996
};
997

998
UNUSED static const struct flags at_file_flags[] = {
999
#ifdef AT_EACCESS
1000
    FLAG_GENERIC(AT_EACCESS),
1001
#endif
1002
#ifdef AT_SYMLINK_NOFOLLOW
1003
    FLAG_GENERIC(AT_SYMLINK_NOFOLLOW),
1004
#endif
1005
    FLAG_END,
1006
};
1007

1008
UNUSED static const struct flags unlinkat_flags[] = {
1009
#ifdef AT_REMOVEDIR
1010
    FLAG_GENERIC(AT_REMOVEDIR),
1011
#endif
1012
    FLAG_END,
1013
};
1014

1015
UNUSED static const struct flags mode_flags[] = {
1016
    FLAG_GENERIC(S_IFSOCK),
1017
    FLAG_GENERIC(S_IFLNK),
1018
    FLAG_GENERIC(S_IFREG),
1019
    FLAG_GENERIC(S_IFBLK),
1020
    FLAG_GENERIC(S_IFDIR),
1021
    FLAG_GENERIC(S_IFCHR),
1022
    FLAG_GENERIC(S_IFIFO),
1023
    FLAG_END,
1024
};
1025

1026
UNUSED static const struct flags open_access_flags[] = {
1027
    FLAG_TARGET_MASK(O_RDONLY, O_ACCMODE),
1028
    FLAG_TARGET_MASK(O_WRONLY, O_ACCMODE),
1029
    FLAG_TARGET_MASK(O_RDWR, O_ACCMODE),
1030
    FLAG_END,
1031
};
1032

1033
UNUSED static const struct flags open_flags[] = {
1034
    FLAG_TARGET(O_APPEND),
1035
    FLAG_TARGET(O_CREAT),
1036
    FLAG_TARGET(O_DIRECTORY),
1037
    FLAG_TARGET(O_EXCL),
1038
#if TARGET_O_LARGEFILE != 0
1039
    FLAG_TARGET(O_LARGEFILE),
1040
#endif
1041
    FLAG_TARGET(O_NOCTTY),
1042
    FLAG_TARGET(O_NOFOLLOW),
1043
    FLAG_TARGET(O_NONBLOCK),      /* also O_NDELAY */
1044
    FLAG_TARGET(O_DSYNC),
1045
    FLAG_TARGET(__O_SYNC),
1046
    FLAG_TARGET(O_TRUNC),
1047
#ifdef O_DIRECT
1048
    FLAG_TARGET(O_DIRECT),
1049
#endif
1050
#ifdef O_NOATIME
1051
    FLAG_TARGET(O_NOATIME),
1052
#endif
1053
#ifdef O_CLOEXEC
1054
    FLAG_TARGET(O_CLOEXEC),
1055
#endif
1056
#ifdef O_PATH
1057
    FLAG_TARGET(O_PATH),
1058
#endif
1059
#ifdef O_TMPFILE
1060
    FLAG_TARGET(O_TMPFILE),
1061
    FLAG_TARGET(__O_TMPFILE),
1062
#endif
1063
    FLAG_END,
1064
};
1065

1066
UNUSED static const struct flags mount_flags[] = {
1067
#ifdef MS_BIND
1068
    FLAG_GENERIC(MS_BIND),
1069
#endif
1070
#ifdef MS_DIRSYNC
1071
    FLAG_GENERIC(MS_DIRSYNC),
1072
#endif
1073
    FLAG_GENERIC(MS_MANDLOCK),
1074
#ifdef MS_MOVE
1075
    FLAG_GENERIC(MS_MOVE),
1076
#endif
1077
    FLAG_GENERIC(MS_NOATIME),
1078
    FLAG_GENERIC(MS_NODEV),
1079
    FLAG_GENERIC(MS_NODIRATIME),
1080
    FLAG_GENERIC(MS_NOEXEC),
1081
    FLAG_GENERIC(MS_NOSUID),
1082
    FLAG_GENERIC(MS_RDONLY),
1083
#ifdef MS_RELATIME
1084
    FLAG_GENERIC(MS_RELATIME),
1085
#endif
1086
    FLAG_GENERIC(MS_REMOUNT),
1087
    FLAG_GENERIC(MS_SYNCHRONOUS),
1088
    FLAG_END,
1089
};
1090

1091
UNUSED static const struct flags umount2_flags[] = {
1092
#ifdef MNT_FORCE
1093
    FLAG_GENERIC(MNT_FORCE),
1094
#endif
1095
#ifdef MNT_DETACH
1096
    FLAG_GENERIC(MNT_DETACH),
1097
#endif
1098
#ifdef MNT_EXPIRE
1099
    FLAG_GENERIC(MNT_EXPIRE),
1100
#endif
1101
    FLAG_END,
1102
};
1103

1104
UNUSED static const struct flags mmap_prot_flags[] = {
1105
    FLAG_GENERIC_MASK(PROT_NONE, PROT_READ | PROT_WRITE | PROT_EXEC),
1106
    FLAG_GENERIC(PROT_EXEC),
1107
    FLAG_GENERIC(PROT_READ),
1108
    FLAG_GENERIC(PROT_WRITE),
1109
    FLAG_TARGET(PROT_SEM),
1110
    FLAG_GENERIC(PROT_GROWSDOWN),
1111
    FLAG_GENERIC(PROT_GROWSUP),
1112
    FLAG_END,
1113
};
1114

1115
UNUSED static const struct flags mmap_flags[] = {
1116
    FLAG_TARGET_MASK(MAP_SHARED, MAP_TYPE),
1117
    FLAG_TARGET_MASK(MAP_PRIVATE, MAP_TYPE),
1118
    FLAG_TARGET_MASK(MAP_SHARED_VALIDATE, MAP_TYPE),
1119
    FLAG_TARGET(MAP_ANONYMOUS),
1120
    FLAG_TARGET(MAP_DENYWRITE),
1121
    FLAG_TARGET(MAP_EXECUTABLE),
1122
    FLAG_TARGET(MAP_FIXED),
1123
    FLAG_TARGET(MAP_FIXED_NOREPLACE),
1124
    FLAG_TARGET(MAP_GROWSDOWN),
1125
    FLAG_TARGET(MAP_HUGETLB),
1126
    FLAG_TARGET(MAP_LOCKED),
1127
    FLAG_TARGET(MAP_NONBLOCK),
1128
    FLAG_TARGET(MAP_NORESERVE),
1129
    FLAG_TARGET(MAP_POPULATE),
1130
    FLAG_TARGET(MAP_STACK),
1131
    FLAG_TARGET(MAP_SYNC),
1132
#if TARGET_MAP_UNINITIALIZED != 0
1133
    FLAG_TARGET(MAP_UNINITIALIZED),
1134
#endif
1135
    FLAG_END,
1136
};
1137

1138
#ifndef CLONE_PIDFD
1139
# define CLONE_PIDFD 0x00001000
1140
#endif
1141

1142
UNUSED static const struct flags clone_flags[] = {
1143
    FLAG_GENERIC(CLONE_VM),
1144
    FLAG_GENERIC(CLONE_FS),
1145
    FLAG_GENERIC(CLONE_FILES),
1146
    FLAG_GENERIC(CLONE_SIGHAND),
1147
    FLAG_GENERIC(CLONE_PIDFD),
1148
    FLAG_GENERIC(CLONE_PTRACE),
1149
    FLAG_GENERIC(CLONE_VFORK),
1150
    FLAG_GENERIC(CLONE_PARENT),
1151
    FLAG_GENERIC(CLONE_THREAD),
1152
    FLAG_GENERIC(CLONE_NEWNS),
1153
    FLAG_GENERIC(CLONE_SYSVSEM),
1154
    FLAG_GENERIC(CLONE_SETTLS),
1155
    FLAG_GENERIC(CLONE_PARENT_SETTID),
1156
    FLAG_GENERIC(CLONE_CHILD_CLEARTID),
1157
    FLAG_GENERIC(CLONE_DETACHED),
1158
    FLAG_GENERIC(CLONE_UNTRACED),
1159
    FLAG_GENERIC(CLONE_CHILD_SETTID),
1160
#if defined(CLONE_NEWUTS)
1161
    FLAG_GENERIC(CLONE_NEWUTS),
1162
#endif
1163
#if defined(CLONE_NEWIPC)
1164
    FLAG_GENERIC(CLONE_NEWIPC),
1165
#endif
1166
#if defined(CLONE_NEWUSER)
1167
    FLAG_GENERIC(CLONE_NEWUSER),
1168
#endif
1169
#if defined(CLONE_NEWPID)
1170
    FLAG_GENERIC(CLONE_NEWPID),
1171
#endif
1172
#if defined(CLONE_NEWNET)
1173
    FLAG_GENERIC(CLONE_NEWNET),
1174
#endif
1175
#if defined(CLONE_NEWCGROUP)
1176
    FLAG_GENERIC(CLONE_NEWCGROUP),
1177
#endif
1178
#if defined(CLONE_NEWTIME)
1179
    FLAG_GENERIC(CLONE_NEWTIME),
1180
#endif
1181
#if defined(CLONE_IO)
1182
    FLAG_GENERIC(CLONE_IO),
1183
#endif
1184
    FLAG_END,
1185
};
1186

1187
UNUSED static const struct flags execveat_flags[] = {
1188
#ifdef AT_EMPTY_PATH
1189
    FLAG_GENERIC(AT_EMPTY_PATH),
1190
#endif
1191
#ifdef AT_SYMLINK_NOFOLLOW
1192
    FLAG_GENERIC(AT_SYMLINK_NOFOLLOW),
1193
#endif
1194
    FLAG_END,
1195
};
1196

1197
UNUSED static const struct flags msg_flags[] = {
1198
    /* send */
1199
    FLAG_GENERIC(MSG_CONFIRM),
1200
    FLAG_GENERIC(MSG_DONTROUTE),
1201
    FLAG_GENERIC(MSG_DONTWAIT),
1202
    FLAG_GENERIC(MSG_EOR),
1203
    FLAG_GENERIC(MSG_MORE),
1204
    FLAG_GENERIC(MSG_NOSIGNAL),
1205
    FLAG_GENERIC(MSG_OOB),
1206
    /* recv */
1207
    FLAG_GENERIC(MSG_CMSG_CLOEXEC),
1208
    FLAG_GENERIC(MSG_ERRQUEUE),
1209
    FLAG_GENERIC(MSG_PEEK),
1210
    FLAG_GENERIC(MSG_TRUNC),
1211
    FLAG_GENERIC(MSG_WAITALL),
1212
    /* recvmsg */
1213
    FLAG_GENERIC(MSG_CTRUNC),
1214
    FLAG_END,
1215
};
1216

1217
UNUSED static const struct flags statx_flags[] = {
1218
#ifdef AT_EMPTY_PATH
1219
    FLAG_GENERIC(AT_EMPTY_PATH),
1220
#endif
1221
#ifdef AT_NO_AUTOMOUNT
1222
    FLAG_GENERIC(AT_NO_AUTOMOUNT),
1223
#endif
1224
#ifdef AT_SYMLINK_NOFOLLOW
1225
    FLAG_GENERIC(AT_SYMLINK_NOFOLLOW),
1226
#endif
1227
#ifdef AT_STATX_SYNC_AS_STAT
1228
    FLAG_GENERIC_MASK(AT_STATX_SYNC_AS_STAT, AT_STATX_SYNC_TYPE),
1229
#endif
1230
#ifdef AT_STATX_FORCE_SYNC
1231
    FLAG_GENERIC_MASK(AT_STATX_FORCE_SYNC, AT_STATX_SYNC_TYPE),
1232
#endif
1233
#ifdef AT_STATX_DONT_SYNC
1234
    FLAG_GENERIC_MASK(AT_STATX_DONT_SYNC, AT_STATX_SYNC_TYPE),
1235
#endif
1236
    FLAG_END,
1237
};
1238

1239
UNUSED static const struct flags statx_mask[] = {
1240
/* This must come first, because it includes everything.  */
1241
#ifdef STATX_ALL
1242
    FLAG_GENERIC(STATX_ALL),
1243
#endif
1244
/* This must come second; it includes everything except STATX_BTIME.  */
1245
#ifdef STATX_BASIC_STATS
1246
    FLAG_GENERIC(STATX_BASIC_STATS),
1247
#endif
1248
#ifdef STATX_TYPE
1249
    FLAG_GENERIC(STATX_TYPE),
1250
#endif
1251
#ifdef STATX_MODE
1252
    FLAG_GENERIC(STATX_MODE),
1253
#endif
1254
#ifdef STATX_NLINK
1255
    FLAG_GENERIC(STATX_NLINK),
1256
#endif
1257
#ifdef STATX_UID
1258
    FLAG_GENERIC(STATX_UID),
1259
#endif
1260
#ifdef STATX_GID
1261
    FLAG_GENERIC(STATX_GID),
1262
#endif
1263
#ifdef STATX_ATIME
1264
    FLAG_GENERIC(STATX_ATIME),
1265
#endif
1266
#ifdef STATX_MTIME
1267
    FLAG_GENERIC(STATX_MTIME),
1268
#endif
1269
#ifdef STATX_CTIME
1270
    FLAG_GENERIC(STATX_CTIME),
1271
#endif
1272
#ifdef STATX_INO
1273
    FLAG_GENERIC(STATX_INO),
1274
#endif
1275
#ifdef STATX_SIZE
1276
    FLAG_GENERIC(STATX_SIZE),
1277
#endif
1278
#ifdef STATX_BLOCKS
1279
    FLAG_GENERIC(STATX_BLOCKS),
1280
#endif
1281
#ifdef STATX_BTIME
1282
    FLAG_GENERIC(STATX_BTIME),
1283
#endif
1284
    FLAG_END,
1285
};
1286

1287
UNUSED static const struct flags falloc_flags[] = {
1288
    FLAG_GENERIC(FALLOC_FL_KEEP_SIZE),
1289
    FLAG_GENERIC(FALLOC_FL_PUNCH_HOLE),
1290
#ifdef FALLOC_FL_NO_HIDE_STALE
1291
    FLAG_GENERIC(FALLOC_FL_NO_HIDE_STALE),
1292
#endif
1293
#ifdef FALLOC_FL_COLLAPSE_RANGE
1294
    FLAG_GENERIC(FALLOC_FL_COLLAPSE_RANGE),
1295
#endif
1296
#ifdef FALLOC_FL_ZERO_RANGE
1297
    FLAG_GENERIC(FALLOC_FL_ZERO_RANGE),
1298
#endif
1299
#ifdef FALLOC_FL_INSERT_RANGE
1300
    FLAG_GENERIC(FALLOC_FL_INSERT_RANGE),
1301
#endif
1302
#ifdef FALLOC_FL_UNSHARE_RANGE
1303
    FLAG_GENERIC(FALLOC_FL_UNSHARE_RANGE),
1304
#endif
1305
};
1306

1307
UNUSED static const struct flags termios_iflags[] = {
1308
    FLAG_TARGET(IGNBRK),
1309
    FLAG_TARGET(BRKINT),
1310
    FLAG_TARGET(IGNPAR),
1311
    FLAG_TARGET(PARMRK),
1312
    FLAG_TARGET(INPCK),
1313
    FLAG_TARGET(ISTRIP),
1314
    FLAG_TARGET(INLCR),
1315
    FLAG_TARGET(IGNCR),
1316
    FLAG_TARGET(ICRNL),
1317
    FLAG_TARGET(IUCLC),
1318
    FLAG_TARGET(IXON),
1319
    FLAG_TARGET(IXANY),
1320
    FLAG_TARGET(IXOFF),
1321
    FLAG_TARGET(IMAXBEL),
1322
    FLAG_TARGET(IUTF8),
1323
    FLAG_END,
1324
};
1325

1326
UNUSED static const struct flags termios_oflags[] = {
1327
    FLAG_TARGET(OPOST),
1328
    FLAG_TARGET(OLCUC),
1329
    FLAG_TARGET(ONLCR),
1330
    FLAG_TARGET(OCRNL),
1331
    FLAG_TARGET(ONOCR),
1332
    FLAG_TARGET(ONLRET),
1333
    FLAG_TARGET(OFILL),
1334
    FLAG_TARGET(OFDEL),
1335
    FLAG_END,
1336
};
1337

1338
UNUSED static struct enums termios_oflags_NLDLY[] = {
1339
    ENUM_TARGET(NL0),
1340
    ENUM_TARGET(NL1),
1341
    ENUM_END,
1342
};
1343

1344
UNUSED static struct enums termios_oflags_CRDLY[] = {
1345
    ENUM_TARGET(CR0),
1346
    ENUM_TARGET(CR1),
1347
    ENUM_TARGET(CR2),
1348
    ENUM_TARGET(CR3),
1349
    ENUM_END,
1350
};
1351

1352
UNUSED static struct enums termios_oflags_TABDLY[] = {
1353
    ENUM_TARGET(TAB0),
1354
    ENUM_TARGET(TAB1),
1355
    ENUM_TARGET(TAB2),
1356
    ENUM_TARGET(TAB3),
1357
    ENUM_END,
1358
};
1359

1360
UNUSED static struct enums termios_oflags_VTDLY[] = {
1361
    ENUM_TARGET(VT0),
1362
    ENUM_TARGET(VT1),
1363
    ENUM_END,
1364
};
1365

1366
UNUSED static struct enums termios_oflags_FFDLY[] = {
1367
    ENUM_TARGET(FF0),
1368
    ENUM_TARGET(FF1),
1369
    ENUM_END,
1370
};
1371

1372
UNUSED static struct enums termios_oflags_BSDLY[] = {
1373
    ENUM_TARGET(BS0),
1374
    ENUM_TARGET(BS1),
1375
    ENUM_END,
1376
};
1377

1378
UNUSED static struct enums termios_cflags_CBAUD[] = {
1379
    ENUM_TARGET(B0),
1380
    ENUM_TARGET(B50),
1381
    ENUM_TARGET(B75),
1382
    ENUM_TARGET(B110),
1383
    ENUM_TARGET(B134),
1384
    ENUM_TARGET(B150),
1385
    ENUM_TARGET(B200),
1386
    ENUM_TARGET(B300),
1387
    ENUM_TARGET(B600),
1388
    ENUM_TARGET(B1200),
1389
    ENUM_TARGET(B1800),
1390
    ENUM_TARGET(B2400),
1391
    ENUM_TARGET(B4800),
1392
    ENUM_TARGET(B9600),
1393
    ENUM_TARGET(B19200),
1394
    ENUM_TARGET(B38400),
1395
    ENUM_TARGET(B57600),
1396
    ENUM_TARGET(B115200),
1397
    ENUM_TARGET(B230400),
1398
    ENUM_TARGET(B460800),
1399
    ENUM_END,
1400
};
1401

1402
UNUSED static struct enums termios_cflags_CSIZE[] = {
1403
    ENUM_TARGET(CS5),
1404
    ENUM_TARGET(CS6),
1405
    ENUM_TARGET(CS7),
1406
    ENUM_TARGET(CS8),
1407
    ENUM_END,
1408
};
1409

1410
UNUSED static const struct flags termios_cflags[] = {
1411
    FLAG_TARGET(CSTOPB),
1412
    FLAG_TARGET(CREAD),
1413
    FLAG_TARGET(PARENB),
1414
    FLAG_TARGET(PARODD),
1415
    FLAG_TARGET(HUPCL),
1416
    FLAG_TARGET(CLOCAL),
1417
    FLAG_TARGET(CRTSCTS),
1418
    FLAG_END,
1419
};
1420

1421
UNUSED static const struct flags termios_lflags[] = {
1422
    FLAG_TARGET(ISIG),
1423
    FLAG_TARGET(ICANON),
1424
    FLAG_TARGET(XCASE),
1425
    FLAG_TARGET(ECHO),
1426
    FLAG_TARGET(ECHOE),
1427
    FLAG_TARGET(ECHOK),
1428
    FLAG_TARGET(ECHONL),
1429
    FLAG_TARGET(NOFLSH),
1430
    FLAG_TARGET(TOSTOP),
1431
    FLAG_TARGET(ECHOCTL),
1432
    FLAG_TARGET(ECHOPRT),
1433
    FLAG_TARGET(ECHOKE),
1434
    FLAG_TARGET(FLUSHO),
1435
    FLAG_TARGET(PENDIN),
1436
    FLAG_TARGET(IEXTEN),
1437
    FLAG_TARGET(EXTPROC),
1438
    FLAG_END,
1439
};
1440

1441
#ifdef TARGET_NR_mlockall
1442
static const struct flags mlockall_flags[] = {
1443
    FLAG_TARGET(MCL_CURRENT),
1444
    FLAG_TARGET(MCL_FUTURE),
1445
#ifdef MCL_ONFAULT
1446
    FLAG_TARGET(MCL_ONFAULT),
1447
#endif
1448
    FLAG_END,
1449
};
1450
#endif
1451

1452
/* IDs of the various system clocks */
1453
#define TARGET_CLOCK_REALTIME              0
1454
#define TARGET_CLOCK_MONOTONIC             1
1455
#define TARGET_CLOCK_PROCESS_CPUTIME_ID    2
1456
#define TARGET_CLOCK_THREAD_CPUTIME_ID     3
1457
#define TARGET_CLOCK_MONOTONIC_RAW         4
1458
#define TARGET_CLOCK_REALTIME_COARSE       5
1459
#define TARGET_CLOCK_MONOTONIC_COARSE      6
1460
#define TARGET_CLOCK_BOOTTIME              7
1461
#define TARGET_CLOCK_REALTIME_ALARM        8
1462
#define TARGET_CLOCK_BOOTTIME_ALARM        9
1463
#define TARGET_CLOCK_SGI_CYCLE             10
1464
#define TARGET_CLOCK_TAI                   11
1465

1466
UNUSED static struct enums clockids[] = {
1467
    ENUM_TARGET(CLOCK_REALTIME),
1468
    ENUM_TARGET(CLOCK_MONOTONIC),
1469
    ENUM_TARGET(CLOCK_PROCESS_CPUTIME_ID),
1470
    ENUM_TARGET(CLOCK_THREAD_CPUTIME_ID),
1471
    ENUM_TARGET(CLOCK_MONOTONIC_RAW),
1472
    ENUM_TARGET(CLOCK_REALTIME_COARSE),
1473
    ENUM_TARGET(CLOCK_MONOTONIC_COARSE),
1474
    ENUM_TARGET(CLOCK_BOOTTIME),
1475
    ENUM_TARGET(CLOCK_REALTIME_ALARM),
1476
    ENUM_TARGET(CLOCK_BOOTTIME_ALARM),
1477
    ENUM_TARGET(CLOCK_SGI_CYCLE),
1478
    ENUM_TARGET(CLOCK_TAI),
1479
    ENUM_END,
1480
};
1481

1482
UNUSED static struct enums itimer_types[] = {
1483
    ENUM_GENERIC(ITIMER_REAL),
1484
    ENUM_GENERIC(ITIMER_VIRTUAL),
1485
    ENUM_GENERIC(ITIMER_PROF),
1486
    ENUM_END,
1487
};
1488

1489
/*
1490
 * print_xxx utility functions.  These are used to print syscall
1491
 * parameters in certain format.  All of these have parameter
1492
 * named 'last'.  This parameter is used to add comma to output
1493
 * when last == 0.
1494
 */
1495

1496
static const char *
1497
get_comma(int last)
1498
{
1499
    return ((last) ? "" : ",");
1500
}
1501

1502
static void
1503
print_flags(const struct flags *f, abi_long flags, int last)
1504
{
1505
    const char *sep = "";
1506
    int n;
1507

1508
    for (n = 0; f->f_string != NULL; f++) {
1509
        if ((flags & f->f_mask) == f->f_value) {
1510
            qemu_log("%s%s", sep, f->f_string);
1511
            flags &= ~f->f_mask;
1512
            sep = "|";
1513
            n++;
1514
        }
1515
    }
1516

1517
    if (n > 0) {
1518
        /* print rest of the flags as numeric */
1519
        if (flags != 0) {
1520
            qemu_log("%s%#x%s", sep, (unsigned int)flags, get_comma(last));
1521
        } else {
1522
            qemu_log("%s", get_comma(last));
1523
        }
1524
    } else {
1525
        /* no string version of flags found, print them in hex then */
1526
        qemu_log("%#x%s", (unsigned int)flags, get_comma(last));
1527
    }
1528
}
1529

1530
static void
1531
print_enums(const struct enums *e, abi_long enum_arg, int last)
1532
{
1533
    for (; e->e_string != NULL; e++) {
1534
        if (e->e_value == enum_arg) {
1535
            qemu_log("%s", e->e_string);
1536
            break;
1537
        }
1538
    }
1539

1540
    if (e->e_string == NULL) {
1541
        qemu_log("%#x", (unsigned int)enum_arg);
1542
    }
1543

1544
    qemu_log("%s", get_comma(last));
1545
}
1546

1547
static void
1548
print_at_dirfd(abi_long dirfd, int last)
1549
{
1550
#ifdef AT_FDCWD
1551
    if (dirfd == AT_FDCWD) {
1552
        qemu_log("AT_FDCWD%s", get_comma(last));
1553
        return;
1554
    }
1555
#endif
1556
    qemu_log("%d%s", (int)dirfd, get_comma(last));
1557
}
1558

1559
static void
1560
print_file_mode(abi_long mode, int last)
1561
{
1562
    const char *sep = "";
1563
    const struct flags *m;
1564

1565
    if (mode == 0) {
1566
        qemu_log("000%s", get_comma(last));
1567
        return;
1568
    }
1569

1570
    for (m = &mode_flags[0]; m->f_string != NULL; m++) {
1571
        if ((m->f_value & mode) == m->f_value) {
1572
            qemu_log("%s%s", m->f_string, sep);
1573
            sep = "|";
1574
            mode &= ~m->f_value;
1575
            break;
1576
        }
1577
    }
1578

1579
    mode &= ~S_IFMT;
1580
    /* print rest of the mode as octal */
1581
    if (mode != 0)
1582
        qemu_log("%s%#o", sep, (unsigned int)mode);
1583

1584
    qemu_log("%s", get_comma(last));
1585
}
1586

1587
static void
1588
print_open_flags(abi_long flags, int last)
1589
{
1590
    print_flags(open_access_flags, flags & TARGET_O_ACCMODE, 1);
1591
    flags &= ~TARGET_O_ACCMODE;
1592
    if (flags == 0) {
1593
        qemu_log("%s", get_comma(last));
1594
        return;
1595
    }
1596
    qemu_log("|");
1597
    print_flags(open_flags, flags, last);
1598
}
1599

1600
static void
1601
print_syscall_prologue(const struct syscallname *sc)
1602
{
1603
    qemu_log("%s(", sc->name);
1604
}
1605

1606
/*ARGSUSED*/
1607
static void
1608
print_syscall_epilogue(const struct syscallname *sc)
1609
{
1610
    (void)sc;
1611
    qemu_log(")");
1612
}
1613

1614
static void
1615
print_string(abi_long addr, int last)
1616
{
1617
    char *s;
1618

1619
    if ((s = lock_user_string(addr)) != NULL) {
1620
        qemu_log("\"%s\"%s", s, get_comma(last));
1621
        unlock_user(s, addr, 0);
1622
    } else {
1623
        /* can't get string out of it, so print it as pointer */
1624
        print_pointer(addr, last);
1625
    }
1626
}
1627

1628
#define MAX_PRINT_BUF 40
1629
static void
1630
print_buf(abi_long addr, abi_long len, int last)
1631
{
1632
    uint8_t *s;
1633
    int i;
1634

1635
    s = lock_user(VERIFY_READ, addr, len, 1);
1636
    if (s) {
1637
        qemu_log("\"");
1638
        for (i = 0; i < MAX_PRINT_BUF && i < len; i++) {
1639
            if (isprint(s[i])) {
1640
                qemu_log("%c", s[i]);
1641
            } else {
1642
                qemu_log("\\%o", s[i]);
1643
            }
1644
        }
1645
        qemu_log("\"");
1646
        if (i != len) {
1647
            qemu_log("...");
1648
        }
1649
        if (!last) {
1650
            qemu_log(",");
1651
        }
1652
        unlock_user(s, addr, 0);
1653
    } else {
1654
        print_pointer(addr, last);
1655
    }
1656
}
1657

1658
/*
1659
 * Prints out raw parameter using given format.  Caller needs
1660
 * to do byte swapping if needed.
1661
 */
1662
static void
1663
print_raw_param(const char *fmt, abi_long param, int last)
1664
{
1665
    char format[64];
1666

1667
    (void) snprintf(format, sizeof (format), "%s%s", fmt, get_comma(last));
1668
    qemu_log(format, param);
1669
}
1670

1671
/*
1672
 * Same as print_raw_param() but prints out raw 64-bit parameter.
1673
 */
1674
static void
1675
print_raw_param64(const char *fmt, long long param, int last)
1676
{
1677
    char format[64];
1678

1679
    (void)snprintf(format, sizeof(format), "%s%s", fmt, get_comma(last));
1680
    qemu_log(format, param);
1681
}
1682

1683

1684
static void
1685
print_pointer(abi_long p, int last)
1686
{
1687
    if (p == 0)
1688
        qemu_log("NULL%s", get_comma(last));
1689
    else
1690
        qemu_log("0x" TARGET_ABI_FMT_lx "%s", p, get_comma(last));
1691
}
1692

1693
/*
1694
 * Reads 32-bit (int) number from guest address space from
1695
 * address 'addr' and prints it.
1696
 */
1697
static void
1698
print_number(abi_long addr, int last)
1699
{
1700
    if (addr == 0) {
1701
        qemu_log("NULL%s", get_comma(last));
1702
    } else {
1703
        int num;
1704

1705
        get_user_s32(num, addr);
1706
        qemu_log("[%d]%s", num, get_comma(last));
1707
    }
1708
}
1709

1710
static void
1711
print_timeval(abi_ulong tv_addr, int last)
1712
{
1713
    if( tv_addr ) {
1714
        struct target_timeval *tv;
1715

1716
        tv = lock_user(VERIFY_READ, tv_addr, sizeof(*tv), 1);
1717
        if (!tv) {
1718
            print_pointer(tv_addr, last);
1719
            return;
1720
        }
1721
        qemu_log("{tv_sec = " TARGET_ABI_FMT_ld
1722
                 ",tv_usec = " TARGET_ABI_FMT_ld "}%s",
1723
                 tswapal(tv->tv_sec), tswapal(tv->tv_usec), get_comma(last));
1724
        unlock_user(tv, tv_addr, 0);
1725
    } else
1726
        qemu_log("NULL%s", get_comma(last));
1727
}
1728

1729
static void
1730
print_timespec(abi_ulong ts_addr, int last)
1731
{
1732
    if (ts_addr) {
1733
        struct target_timespec *ts;
1734

1735
        ts = lock_user(VERIFY_READ, ts_addr, sizeof(*ts), 1);
1736
        if (!ts) {
1737
            print_pointer(ts_addr, last);
1738
            return;
1739
        }
1740
        qemu_log("{tv_sec = " TARGET_ABI_FMT_ld
1741
                 ",tv_nsec = " TARGET_ABI_FMT_ld "}%s",
1742
                 tswapal(ts->tv_sec), tswapal(ts->tv_nsec), get_comma(last));
1743
        unlock_user(ts, ts_addr, 0);
1744
    } else {
1745
        qemu_log("NULL%s", get_comma(last));
1746
    }
1747
}
1748

1749
static void
1750
print_timespec64(abi_ulong ts_addr, int last)
1751
{
1752
    if (ts_addr) {
1753
        struct target__kernel_timespec *ts;
1754

1755
        ts = lock_user(VERIFY_READ, ts_addr, sizeof(*ts), 1);
1756
        if (!ts) {
1757
            print_pointer(ts_addr, last);
1758
            return;
1759
        }
1760
        print_raw_param64("{tv_sec=%" PRId64, tswap64(ts->tv_sec), 0);
1761
        print_raw_param64("tv_nsec=%" PRId64 "}", tswap64(ts->tv_nsec), last);
1762
        unlock_user(ts, ts_addr, 0);
1763
    } else {
1764
        qemu_log("NULL%s", get_comma(last));
1765
    }
1766
}
1767

1768
static void
1769
print_timezone(abi_ulong tz_addr, int last)
1770
{
1771
    if (tz_addr) {
1772
        struct target_timezone *tz;
1773

1774
        tz = lock_user(VERIFY_READ, tz_addr, sizeof(*tz), 1);
1775
        if (!tz) {
1776
            print_pointer(tz_addr, last);
1777
            return;
1778
        }
1779
        qemu_log("{%d,%d}%s", tswap32(tz->tz_minuteswest),
1780
                 tswap32(tz->tz_dsttime), get_comma(last));
1781
        unlock_user(tz, tz_addr, 0);
1782
    } else {
1783
        qemu_log("NULL%s", get_comma(last));
1784
    }
1785
}
1786

1787
static void
1788
print_itimerval(abi_ulong it_addr, int last)
1789
{
1790
    if (it_addr) {
1791
        qemu_log("{it_interval=");
1792
        print_timeval(it_addr +
1793
                      offsetof(struct target_itimerval, it_interval), 0);
1794
        qemu_log("it_value=");
1795
        print_timeval(it_addr +
1796
                      offsetof(struct target_itimerval, it_value), 0);
1797
        qemu_log("}%s", get_comma(last));
1798
    } else {
1799
        qemu_log("NULL%s", get_comma(last));
1800
    }
1801
}
1802

1803
void
1804
print_termios(void *arg)
1805
{
1806
    const struct target_termios *target = arg;
1807

1808
    target_tcflag_t iflags = tswap32(target->c_iflag);
1809
    target_tcflag_t oflags = tswap32(target->c_oflag);
1810
    target_tcflag_t cflags = tswap32(target->c_cflag);
1811
    target_tcflag_t lflags = tswap32(target->c_lflag);
1812

1813
    qemu_log("{");
1814

1815
    qemu_log("c_iflag = ");
1816
    print_flags(termios_iflags, iflags, 0);
1817

1818
    qemu_log("c_oflag = ");
1819
    target_tcflag_t oflags_clean =  oflags & ~(TARGET_NLDLY | TARGET_CRDLY |
1820
                                               TARGET_TABDLY | TARGET_BSDLY |
1821
                                               TARGET_VTDLY | TARGET_FFDLY);
1822
    print_flags(termios_oflags, oflags_clean, 0);
1823
    if (oflags & TARGET_NLDLY) {
1824
        print_enums(termios_oflags_NLDLY, oflags & TARGET_NLDLY, 0);
1825
    }
1826
    if (oflags & TARGET_CRDLY) {
1827
        print_enums(termios_oflags_CRDLY, oflags & TARGET_CRDLY, 0);
1828
    }
1829
    if (oflags & TARGET_TABDLY) {
1830
        print_enums(termios_oflags_TABDLY, oflags & TARGET_TABDLY, 0);
1831
    }
1832
    if (oflags & TARGET_BSDLY) {
1833
        print_enums(termios_oflags_BSDLY, oflags & TARGET_BSDLY, 0);
1834
    }
1835
    if (oflags & TARGET_VTDLY) {
1836
        print_enums(termios_oflags_VTDLY, oflags & TARGET_VTDLY, 0);
1837
    }
1838
    if (oflags & TARGET_FFDLY) {
1839
        print_enums(termios_oflags_FFDLY, oflags & TARGET_FFDLY, 0);
1840
    }
1841

1842
    qemu_log("c_cflag = ");
1843
    if (cflags & TARGET_CBAUD) {
1844
        print_enums(termios_cflags_CBAUD, cflags & TARGET_CBAUD, 0);
1845
    }
1846
    if (cflags & TARGET_CSIZE) {
1847
        print_enums(termios_cflags_CSIZE, cflags & TARGET_CSIZE, 0);
1848
    }
1849
    target_tcflag_t cflags_clean = cflags & ~(TARGET_CBAUD | TARGET_CSIZE);
1850
    print_flags(termios_cflags, cflags_clean, 0);
1851

1852
    qemu_log("c_lflag = ");
1853
    print_flags(termios_lflags, lflags, 0);
1854

1855
    qemu_log("c_cc = ");
1856
    qemu_log("\"%s\",", target->c_cc);
1857

1858
    qemu_log("c_line = ");
1859
    print_raw_param("\'%c\'", target->c_line, 1);
1860

1861
    qemu_log("}");
1862
}
1863

1864
#undef UNUSED
1865

1866
#ifdef TARGET_NR_accept
1867
static void
1868
print_accept(CPUArchState *cpu_env, const struct syscallname *name,
1869
             abi_long arg0, abi_long arg1, abi_long arg2,
1870
             abi_long arg3, abi_long arg4, abi_long arg5)
1871
{
1872
    print_syscall_prologue(name);
1873
    print_raw_param("%d", arg0, 0);
1874
    print_pointer(arg1, 0);
1875
    print_number(arg2, 1);
1876
    print_syscall_epilogue(name);
1877
}
1878
#endif
1879

1880
#ifdef TARGET_NR_access
1881
static void
1882
print_access(CPUArchState *cpu_env, const struct syscallname *name,
1883
             abi_long arg0, abi_long arg1, abi_long arg2,
1884
             abi_long arg3, abi_long arg4, abi_long arg5)
1885
{
1886
    print_syscall_prologue(name);
1887
    print_string(arg0, 0);
1888
    print_flags(access_flags, arg1, 1);
1889
    print_syscall_epilogue(name);
1890
}
1891
#endif
1892

1893
#ifdef TARGET_NR_acct
1894
static void
1895
print_acct(CPUArchState *cpu_env, const struct syscallname *name,
1896
           abi_long arg0, abi_long arg1, abi_long arg2,
1897
           abi_long arg3, abi_long arg4, abi_long arg5)
1898
{
1899
    print_syscall_prologue(name);
1900
    print_string(arg0, 1);
1901
    print_syscall_epilogue(name);
1902
}
1903
#endif
1904

1905
#ifdef TARGET_NR_brk
1906
static void
1907
print_brk(CPUArchState *cpu_env, const struct syscallname *name,
1908
          abi_long arg0, abi_long arg1, abi_long arg2,
1909
          abi_long arg3, abi_long arg4, abi_long arg5)
1910
{
1911
    print_syscall_prologue(name);
1912
    print_pointer(arg0, 1);
1913
    print_syscall_epilogue(name);
1914
}
1915
#endif
1916

1917
#ifdef TARGET_NR_chdir
1918
static void
1919
print_chdir(CPUArchState *cpu_env, const struct syscallname *name,
1920
            abi_long arg0, abi_long arg1, abi_long arg2,
1921
            abi_long arg3, abi_long arg4, abi_long arg5)
1922
{
1923
    print_syscall_prologue(name);
1924
    print_string(arg0, 1);
1925
    print_syscall_epilogue(name);
1926
}
1927
#endif
1928

1929
#ifdef TARGET_NR_chroot
1930
static void
1931
print_chroot(CPUArchState *cpu_env, const struct syscallname *name,
1932
             abi_long arg0, abi_long arg1, abi_long arg2,
1933
             abi_long arg3, abi_long arg4, abi_long arg5)
1934
{
1935
    print_syscall_prologue(name);
1936
    print_string(arg0, 1);
1937
    print_syscall_epilogue(name);
1938
}
1939
#endif
1940

1941
#ifdef TARGET_NR_chmod
1942
static void
1943
print_chmod(CPUArchState *cpu_env, const struct syscallname *name,
1944
            abi_long arg0, abi_long arg1, abi_long arg2,
1945
            abi_long arg3, abi_long arg4, abi_long arg5)
1946
{
1947
    print_syscall_prologue(name);
1948
    print_string(arg0, 0);
1949
    print_file_mode(arg1, 1);
1950
    print_syscall_epilogue(name);
1951
}
1952
#endif
1953

1954
#if defined(TARGET_NR_chown) || defined(TARGET_NR_lchown)
1955
static void
1956
print_chown(CPUArchState *cpu_env, const struct syscallname *name,
1957
            abi_long arg0, abi_long arg1, abi_long arg2,
1958
            abi_long arg3, abi_long arg4, abi_long arg5)
1959
{
1960
    print_syscall_prologue(name);
1961
    print_string(arg0, 0);
1962
    print_raw_param("%d", arg1, 0);
1963
    print_raw_param("%d", arg2, 1);
1964
    print_syscall_epilogue(name);
1965
}
1966
#define print_lchown     print_chown
1967
#endif
1968

1969
#ifdef TARGET_NR_clock_adjtime
1970
static void
1971
print_clock_adjtime(CPUArchState *cpu_env, const struct syscallname *name,
1972
                    abi_long arg0, abi_long arg1, abi_long arg2,
1973
                    abi_long arg3, abi_long arg4, abi_long arg5)
1974
{
1975
    print_syscall_prologue(name);
1976
    print_enums(clockids, arg0, 0);
1977
    print_pointer(arg1, 1);
1978
    print_syscall_epilogue(name);
1979
}
1980
#endif
1981

1982
#ifdef TARGET_NR_clone
1983
static void do_print_clone(unsigned int flags, abi_ulong newsp,
1984
                           abi_ulong parent_tidptr, target_ulong newtls,
1985
                           abi_ulong child_tidptr)
1986
{
1987
    print_flags(clone_flags, flags, 0);
1988
    print_raw_param("child_stack=0x" TARGET_ABI_FMT_lx, newsp, 0);
1989
    print_raw_param("parent_tidptr=0x" TARGET_ABI_FMT_lx, parent_tidptr, 0);
1990
    print_raw_param("tls=0x" TARGET_ABI_FMT_lx, newtls, 0);
1991
    print_raw_param("child_tidptr=0x" TARGET_ABI_FMT_lx, child_tidptr, 1);
1992
}
1993

1994
static void
1995
print_clone(CPUArchState *cpu_env, const struct syscallname *name,
1996
            abi_long arg1, abi_long arg2, abi_long arg3,
1997
            abi_long arg4, abi_long arg5, abi_long arg6)
1998
{
1999
    print_syscall_prologue(name);
2000
#if defined(TARGET_MICROBLAZE)
2001
    do_print_clone(arg1, arg2, arg4, arg6, arg5);
2002
#elif defined(TARGET_CLONE_BACKWARDS)
2003
    do_print_clone(arg1, arg2, arg3, arg4, arg5);
2004
#elif defined(TARGET_CLONE_BACKWARDS2)
2005
    do_print_clone(arg2, arg1, arg3, arg5, arg4);
2006
#else
2007
    do_print_clone(arg1, arg2, arg3, arg5, arg4);
2008
#endif
2009
    print_syscall_epilogue(name);
2010
}
2011
#endif
2012

2013
#ifdef TARGET_NR_creat
2014
static void
2015
print_creat(CPUArchState *cpu_env, const struct syscallname *name,
2016
            abi_long arg0, abi_long arg1, abi_long arg2,
2017
            abi_long arg3, abi_long arg4, abi_long arg5)
2018
{
2019
    print_syscall_prologue(name);
2020
    print_string(arg0, 0);
2021
    print_file_mode(arg1, 1);
2022
    print_syscall_epilogue(name);
2023
}
2024
#endif
2025

2026
#ifdef TARGET_NR_execv
2027
static void
2028
print_execv(CPUArchState *cpu_env, const struct syscallname *name,
2029
            abi_long arg0, abi_long arg1, abi_long arg2,
2030
            abi_long arg3, abi_long arg4, abi_long arg5)
2031
{
2032
    print_syscall_prologue(name);
2033
    print_string(arg0, 0);
2034
    print_raw_param("0x" TARGET_ABI_FMT_lx, arg1, 1);
2035
    print_syscall_epilogue(name);
2036
}
2037
#endif
2038

2039
static void
2040
print_execve_argv(abi_long argv, int last)
2041
{
2042
    abi_ulong arg_ptr_addr;
2043
    char *s;
2044

2045
    qemu_log("{");
2046
    for (arg_ptr_addr = argv; ; arg_ptr_addr += sizeof(abi_ulong)) {
2047
        abi_ulong *arg_ptr, arg_addr;
2048

2049
        arg_ptr = lock_user(VERIFY_READ, arg_ptr_addr, sizeof(abi_ulong), 1);
2050
        if (!arg_ptr) {
2051
            return;
2052
        }
2053
        arg_addr = tswapal(*arg_ptr);
2054
        unlock_user(arg_ptr, arg_ptr_addr, 0);
2055
        if (!arg_addr) {
2056
            break;
2057
        }
2058
        s = lock_user_string(arg_addr);
2059
        if (s) {
2060
            qemu_log("\"%s\",", s);
2061
            unlock_user(s, arg_addr, 0);
2062
        }
2063
    }
2064
    qemu_log("NULL}%s", get_comma(last));
2065
}
2066

2067
static void
2068
print_execve(CPUArchState *cpu_env, const struct syscallname *name,
2069
             abi_long arg1, abi_long arg2, abi_long arg3,
2070
             abi_long arg4, abi_long arg5, abi_long arg6)
2071
{
2072
    print_syscall_prologue(name);
2073
    print_string(arg1, 0);
2074
    print_execve_argv(arg2, 1);
2075
    print_syscall_epilogue(name);
2076
}
2077

2078
static void
2079
print_execveat(CPUArchState *cpu_env, const struct syscallname *name,
2080
               abi_long arg1, abi_long arg2, abi_long arg3,
2081
               abi_long arg4, abi_long arg5, abi_long arg6)
2082
{
2083
    print_syscall_prologue(name);
2084
    print_at_dirfd(arg1, 0);
2085
    print_string(arg2, 0);
2086
    print_execve_argv(arg3, 0);
2087
    print_flags(execveat_flags, arg5, 1);
2088
    print_syscall_epilogue(name);
2089
}
2090

2091
#if defined(TARGET_NR_faccessat) || defined(TARGET_NR_faccessat2)
2092
static void
2093
print_faccessat(CPUArchState *cpu_env, const struct syscallname *name,
2094
                abi_long arg0, abi_long arg1, abi_long arg2,
2095
                abi_long arg3, abi_long arg4, abi_long arg5)
2096
{
2097
    print_syscall_prologue(name);
2098
    print_at_dirfd(arg0, 0);
2099
    print_string(arg1, 0);
2100
    print_flags(access_flags, arg2, 0);
2101
    print_flags(at_file_flags, arg3, 1);
2102
    print_syscall_epilogue(name);
2103
}
2104
#endif
2105

2106
#ifdef TARGET_NR_fallocate
2107
static void
2108
print_fallocate(CPUArchState *cpu_env, const struct syscallname *name,
2109
                abi_long arg0, abi_long arg1, abi_long arg2,
2110
                abi_long arg3, abi_long arg4, abi_long arg5)
2111
{
2112
    print_syscall_prologue(name);
2113
    print_raw_param("%d", arg0, 0);
2114
    print_flags(falloc_flags, arg1, 0);
2115
#if TARGET_ABI_BITS == 32
2116
    print_raw_param("%" PRIu64, target_offset64(arg2, arg3), 0);
2117
    print_raw_param("%" PRIu64, target_offset64(arg4, arg5), 1);
2118
#else
2119
    print_raw_param(TARGET_ABI_FMT_ld, arg2, 0);
2120
    print_raw_param(TARGET_ABI_FMT_ld, arg3, 1);
2121
#endif
2122
    print_syscall_epilogue(name);
2123
}
2124
#endif
2125

2126
#ifdef TARGET_NR_fchmodat
2127
static void
2128
print_fchmodat(CPUArchState *cpu_env, const struct syscallname *name,
2129
               abi_long arg0, abi_long arg1, abi_long arg2,
2130
               abi_long arg3, abi_long arg4, abi_long arg5)
2131
{
2132
    print_syscall_prologue(name);
2133
    print_at_dirfd(arg0, 0);
2134
    print_string(arg1, 0);
2135
    print_file_mode(arg2, 0);
2136
    print_flags(at_file_flags, arg3, 1);
2137
    print_syscall_epilogue(name);
2138
}
2139
#endif
2140

2141
#ifdef TARGET_NR_fchownat
2142
static void
2143
print_fchownat(CPUArchState *cpu_env, const struct syscallname *name,
2144
               abi_long arg0, abi_long arg1, abi_long arg2,
2145
               abi_long arg3, abi_long arg4, abi_long arg5)
2146
{
2147
    print_syscall_prologue(name);
2148
    print_at_dirfd(arg0, 0);
2149
    print_string(arg1, 0);
2150
    print_raw_param("%d", arg2, 0);
2151
    print_raw_param("%d", arg3, 0);
2152
    print_flags(at_file_flags, arg4, 1);
2153
    print_syscall_epilogue(name);
2154
}
2155
#endif
2156

2157
#if defined(TARGET_NR_fcntl) || defined(TARGET_NR_fcntl64)
2158
static void
2159
print_fcntl(CPUArchState *cpu_env, const struct syscallname *name,
2160
            abi_long arg0, abi_long arg1, abi_long arg2,
2161
            abi_long arg3, abi_long arg4, abi_long arg5)
2162
{
2163
    print_syscall_prologue(name);
2164
    print_raw_param("%d", arg0, 0);
2165
    switch(arg1) {
2166
    case TARGET_F_DUPFD:
2167
        qemu_log("F_DUPFD,");
2168
        print_raw_param(TARGET_ABI_FMT_ld, arg2, 1);
2169
        break;
2170
    case TARGET_F_GETFD:
2171
        qemu_log("F_GETFD");
2172
        break;
2173
    case TARGET_F_SETFD:
2174
        qemu_log("F_SETFD,");
2175
        print_raw_param(TARGET_ABI_FMT_ld, arg2, 1);
2176
        break;
2177
    case TARGET_F_GETFL:
2178
        qemu_log("F_GETFL");
2179
        break;
2180
    case TARGET_F_SETFL:
2181
        qemu_log("F_SETFL,");
2182
        print_open_flags(arg2, 1);
2183
        break;
2184
    case TARGET_F_GETLK:
2185
        qemu_log("F_GETLK,");
2186
        print_pointer(arg2, 1);
2187
        break;
2188
    case TARGET_F_SETLK:
2189
        qemu_log("F_SETLK,");
2190
        print_pointer(arg2, 1);
2191
        break;
2192
    case TARGET_F_SETLKW:
2193
        qemu_log("F_SETLKW,");
2194
        print_pointer(arg2, 1);
2195
        break;
2196
    case TARGET_F_GETOWN:
2197
        qemu_log("F_GETOWN");
2198
        break;
2199
    case TARGET_F_SETOWN:
2200
        qemu_log("F_SETOWN,");
2201
        print_raw_param(TARGET_ABI_FMT_ld, arg2, 0);
2202
        break;
2203
    case TARGET_F_GETSIG:
2204
        qemu_log("F_GETSIG");
2205
        break;
2206
    case TARGET_F_SETSIG:
2207
        qemu_log("F_SETSIG,");
2208
        print_raw_param(TARGET_ABI_FMT_ld, arg2, 0);
2209
        break;
2210
#if TARGET_ABI_BITS == 32
2211
    case TARGET_F_GETLK64:
2212
        qemu_log("F_GETLK64,");
2213
        print_pointer(arg2, 1);
2214
        break;
2215
    case TARGET_F_SETLK64:
2216
        qemu_log("F_SETLK64,");
2217
        print_pointer(arg2, 1);
2218
        break;
2219
    case TARGET_F_SETLKW64:
2220
        qemu_log("F_SETLKW64,");
2221
        print_pointer(arg2, 1);
2222
        break;
2223
#endif
2224
    case TARGET_F_OFD_GETLK:
2225
        qemu_log("F_OFD_GETLK,");
2226
        print_pointer(arg2, 1);
2227
        break;
2228
    case TARGET_F_OFD_SETLK:
2229
        qemu_log("F_OFD_SETLK,");
2230
        print_pointer(arg2, 1);
2231
        break;
2232
    case TARGET_F_OFD_SETLKW:
2233
        qemu_log("F_OFD_SETLKW,");
2234
        print_pointer(arg2, 1);
2235
        break;
2236
    case TARGET_F_SETLEASE:
2237
        qemu_log("F_SETLEASE,");
2238
        print_raw_param(TARGET_ABI_FMT_ld, arg2, 1);
2239
        break;
2240
    case TARGET_F_GETLEASE:
2241
        qemu_log("F_GETLEASE");
2242
        break;
2243
#ifdef F_DUPFD_CLOEXEC
2244
    case TARGET_F_DUPFD_CLOEXEC:
2245
        qemu_log("F_DUPFD_CLOEXEC,");
2246
        print_raw_param(TARGET_ABI_FMT_ld, arg2, 1);
2247
        break;
2248
#endif
2249
    case TARGET_F_NOTIFY:
2250
        qemu_log("F_NOTIFY,");
2251
        print_raw_param(TARGET_ABI_FMT_ld, arg2, 1);
2252
        break;
2253
#ifdef F_GETOWN_EX
2254
    case TARGET_F_GETOWN_EX:
2255
        qemu_log("F_GETOWN_EX,");
2256
        print_pointer(arg2, 1);
2257
        break;
2258
#endif
2259
#ifdef F_SETOWN_EX
2260
    case TARGET_F_SETOWN_EX:
2261
        qemu_log("F_SETOWN_EX,");
2262
        print_pointer(arg2, 1);
2263
        break;
2264
#endif
2265
#ifdef F_SETPIPE_SZ
2266
    case TARGET_F_SETPIPE_SZ:
2267
        qemu_log("F_SETPIPE_SZ,");
2268
        print_raw_param(TARGET_ABI_FMT_ld, arg2, 1);
2269
        break;
2270
    case TARGET_F_GETPIPE_SZ:
2271
        qemu_log("F_GETPIPE_SZ");
2272
        break;
2273
#endif
2274
#ifdef F_ADD_SEALS
2275
    case TARGET_F_ADD_SEALS:
2276
        qemu_log("F_ADD_SEALS,");
2277
        print_raw_param("0x"TARGET_ABI_FMT_lx, arg2, 1);
2278
        break;
2279
    case TARGET_F_GET_SEALS:
2280
        qemu_log("F_GET_SEALS");
2281
        break;
2282
#endif
2283
    default:
2284
        print_raw_param(TARGET_ABI_FMT_ld, arg1, 0);
2285
        print_pointer(arg2, 1);
2286
        break;
2287
    }
2288
    print_syscall_epilogue(name);
2289
}
2290
#define print_fcntl64   print_fcntl
2291
#endif
2292

2293
#ifdef TARGET_NR_fgetxattr
2294
static void
2295
print_fgetxattr(CPUArchState *cpu_env, const struct syscallname *name,
2296
                abi_long arg0, abi_long arg1, abi_long arg2,
2297
                abi_long arg3, abi_long arg4, abi_long arg5)
2298
{
2299
    print_syscall_prologue(name);
2300
    print_raw_param("%d", arg0, 0);
2301
    print_string(arg1, 0);
2302
    print_pointer(arg2, 0);
2303
    print_raw_param(TARGET_FMT_lu, arg3, 1);
2304
    print_syscall_epilogue(name);
2305
}
2306
#endif
2307

2308
#ifdef TARGET_NR_flistxattr
2309
static void
2310
print_flistxattr(CPUArchState *cpu_env, const struct syscallname *name,
2311
                 abi_long arg0, abi_long arg1, abi_long arg2,
2312
                 abi_long arg3, abi_long arg4, abi_long arg5)
2313
{
2314
    print_syscall_prologue(name);
2315
    print_raw_param("%d", arg0, 0);
2316
    print_pointer(arg1, 0);
2317
    print_raw_param(TARGET_FMT_lu, arg2, 1);
2318
    print_syscall_epilogue(name);
2319
}
2320
#endif
2321

2322
#if defined(TARGET_NR_getxattr) || defined(TARGET_NR_lgetxattr)
2323
static void
2324
print_getxattr(CPUArchState *cpu_env, const struct syscallname *name,
2325
               abi_long arg0, abi_long arg1, abi_long arg2,
2326
               abi_long arg3, abi_long arg4, abi_long arg5)
2327
{
2328
    print_syscall_prologue(name);
2329
    print_string(arg0, 0);
2330
    print_string(arg1, 0);
2331
    print_pointer(arg2, 0);
2332
    print_raw_param(TARGET_FMT_lu, arg3, 1);
2333
    print_syscall_epilogue(name);
2334
}
2335
#define print_lgetxattr     print_getxattr
2336
#endif
2337

2338
#if defined(TARGET_NR_listxattr) || defined(TARGET_NR_llistxattr)
2339
static void
2340
print_listxattr(CPUArchState *cpu_env, const struct syscallname *name,
2341
                abi_long arg0, abi_long arg1, abi_long arg2,
2342
                abi_long arg3, abi_long arg4, abi_long arg5)
2343
{
2344
    print_syscall_prologue(name);
2345
    print_string(arg0, 0);
2346
    print_pointer(arg1, 0);
2347
    print_raw_param(TARGET_FMT_lu, arg2, 1);
2348
    print_syscall_epilogue(name);
2349
}
2350
#define print_llistxattr     print_listxattr
2351
#endif
2352

2353
#if defined(TARGET_NR_fremovexattr)
2354
static void
2355
print_fremovexattr(CPUArchState *cpu_env, const struct syscallname *name,
2356
                   abi_long arg0, abi_long arg1, abi_long arg2,
2357
                   abi_long arg3, abi_long arg4, abi_long arg5)
2358
{
2359
    print_syscall_prologue(name);
2360
    print_raw_param("%d", arg0, 0);
2361
    print_string(arg1, 1);
2362
    print_syscall_epilogue(name);
2363
}
2364
#endif
2365

2366
#if defined(TARGET_NR_removexattr) || defined(TARGET_NR_lremovexattr)
2367
static void
2368
print_removexattr(CPUArchState *cpu_env, const struct syscallname *name,
2369
                  abi_long arg0, abi_long arg1, abi_long arg2,
2370
                  abi_long arg3, abi_long arg4, abi_long arg5)
2371
{
2372
    print_syscall_prologue(name);
2373
    print_string(arg0, 0);
2374
    print_string(arg1, 1);
2375
    print_syscall_epilogue(name);
2376
}
2377
#define print_lremovexattr     print_removexattr
2378
#endif
2379

2380
#ifdef TARGET_NR_futimesat
2381
static void
2382
print_futimesat(CPUArchState *cpu_env, const struct syscallname *name,
2383
                abi_long arg0, abi_long arg1, abi_long arg2,
2384
                abi_long arg3, abi_long arg4, abi_long arg5)
2385
{
2386
    print_syscall_prologue(name);
2387
    print_at_dirfd(arg0, 0);
2388
    print_string(arg1, 0);
2389
    print_timeval(arg2, 0);
2390
    print_timeval(arg2 + sizeof (struct target_timeval), 1);
2391
    print_syscall_epilogue(name);
2392
}
2393
#endif
2394

2395
#ifdef TARGET_NR_gettimeofday
2396
static void
2397
print_gettimeofday(CPUArchState *cpu_env, const struct syscallname *name,
2398
                   abi_long arg0, abi_long arg1, abi_long arg2,
2399
                   abi_long arg3, abi_long arg4, abi_long arg5)
2400
{
2401
    print_syscall_prologue(name);
2402
    print_pointer(arg0, 0);
2403
    print_pointer(arg1, 1);
2404
    print_syscall_epilogue(name);
2405
}
2406
#endif
2407

2408
#ifdef TARGET_NR_settimeofday
2409
static void
2410
print_settimeofday(CPUArchState *cpu_env, const struct syscallname *name,
2411
                   abi_long arg0, abi_long arg1, abi_long arg2,
2412
                   abi_long arg3, abi_long arg4, abi_long arg5)
2413
{
2414
    print_syscall_prologue(name);
2415
    print_timeval(arg0, 0);
2416
    print_timezone(arg1, 1);
2417
    print_syscall_epilogue(name);
2418
}
2419
#endif
2420

2421
#if defined(TARGET_NR_clock_gettime) || defined(TARGET_NR_clock_getres)
2422
static void
2423
print_clock_gettime(CPUArchState *cpu_env, const struct syscallname *name,
2424
                    abi_long arg0, abi_long arg1, abi_long arg2,
2425
                    abi_long arg3, abi_long arg4, abi_long arg5)
2426
{
2427
    print_syscall_prologue(name);
2428
    print_enums(clockids, arg0, 0);
2429
    print_pointer(arg1, 1);
2430
    print_syscall_epilogue(name);
2431
}
2432
#define print_clock_getres     print_clock_gettime
2433
#endif
2434

2435
#if defined(TARGET_NR_clock_gettime64)
2436
static void
2437
print_clock_gettime64(CPUArchState *cpu_env, const struct syscallname *name,
2438
                    abi_long arg0, abi_long arg1, abi_long arg2,
2439
                    abi_long arg3, abi_long arg4, abi_long arg5)
2440
{
2441
    print_syscall_prologue(name);
2442
    print_enums(clockids, arg0, 0);
2443
    print_pointer(arg1, 1);
2444
    print_syscall_epilogue(name);
2445
}
2446
#endif
2447

2448
#ifdef TARGET_NR_clock_settime
2449
static void
2450
print_clock_settime(CPUArchState *cpu_env, const struct syscallname *name,
2451
                    abi_long arg0, abi_long arg1, abi_long arg2,
2452
                    abi_long arg3, abi_long arg4, abi_long arg5)
2453
{
2454
    print_syscall_prologue(name);
2455
    print_enums(clockids, arg0, 0);
2456
    print_timespec(arg1, 1);
2457
    print_syscall_epilogue(name);
2458
}
2459
#endif
2460

2461
#ifdef TARGET_NR_getitimer
2462
static void
2463
print_getitimer(CPUArchState *cpu_env, const struct syscallname *name,
2464
                abi_long arg0, abi_long arg1, abi_long arg2,
2465
                abi_long arg3, abi_long arg4, abi_long arg5)
2466
{
2467
    print_syscall_prologue(name);
2468
    print_enums(itimer_types, arg0, 0);
2469
    print_pointer(arg1, 1);
2470
    print_syscall_epilogue(name);
2471
}
2472
#endif
2473

2474
#ifdef TARGET_NR_setitimer
2475
static void
2476
print_setitimer(CPUArchState *cpu_env, const struct syscallname *name,
2477
                abi_long arg0, abi_long arg1, abi_long arg2,
2478
                abi_long arg3, abi_long arg4, abi_long arg5)
2479
{
2480
    print_syscall_prologue(name);
2481
    print_enums(itimer_types, arg0, 0);
2482
    print_itimerval(arg1, 0);
2483
    print_pointer(arg2, 1);
2484
    print_syscall_epilogue(name);
2485
}
2486
#endif
2487

2488
#ifdef TARGET_NR_link
2489
static void
2490
print_link(CPUArchState *cpu_env, const struct syscallname *name,
2491
           abi_long arg0, abi_long arg1, abi_long arg2,
2492
           abi_long arg3, abi_long arg4, abi_long arg5)
2493
{
2494
    print_syscall_prologue(name);
2495
    print_string(arg0, 0);
2496
    print_string(arg1, 1);
2497
    print_syscall_epilogue(name);
2498
}
2499
#endif
2500

2501
#ifdef TARGET_NR_linkat
2502
static void
2503
print_linkat(CPUArchState *cpu_env, const struct syscallname *name,
2504
             abi_long arg0, abi_long arg1, abi_long arg2,
2505
             abi_long arg3, abi_long arg4, abi_long arg5)
2506
{
2507
    print_syscall_prologue(name);
2508
    print_at_dirfd(arg0, 0);
2509
    print_string(arg1, 0);
2510
    print_at_dirfd(arg2, 0);
2511
    print_string(arg3, 0);
2512
    print_flags(at_file_flags, arg4, 1);
2513
    print_syscall_epilogue(name);
2514
}
2515
#endif
2516

2517
#if defined(TARGET_NR__llseek) || defined(TARGET_NR_llseek)
2518
static void
2519
print__llseek(CPUArchState *cpu_env, const struct syscallname *name,
2520
              abi_long arg0, abi_long arg1, abi_long arg2,
2521
              abi_long arg3, abi_long arg4, abi_long arg5)
2522
{
2523
    const char *whence = "UNKNOWN";
2524
    print_syscall_prologue(name);
2525
    print_raw_param("%d", arg0, 0);
2526
    print_raw_param("%ld", arg1, 0);
2527
    print_raw_param("%ld", arg2, 0);
2528
    print_pointer(arg3, 0);
2529
    switch(arg4) {
2530
    case SEEK_SET: whence = "SEEK_SET"; break;
2531
    case SEEK_CUR: whence = "SEEK_CUR"; break;
2532
    case SEEK_END: whence = "SEEK_END"; break;
2533
    }
2534
    qemu_log("%s", whence);
2535
    print_syscall_epilogue(name);
2536
}
2537
#define print_llseek print__llseek
2538
#endif
2539

2540
#ifdef TARGET_NR_lseek
2541
static void
2542
print_lseek(CPUArchState *cpu_env, const struct syscallname *name,
2543
            abi_long arg0, abi_long arg1, abi_long arg2,
2544
            abi_long arg3, abi_long arg4, abi_long arg5)
2545
{
2546
    print_syscall_prologue(name);
2547
    print_raw_param("%d", arg0, 0);
2548
    print_raw_param(TARGET_ABI_FMT_ld, arg1, 0);
2549
    switch (arg2) {
2550
    case SEEK_SET:
2551
        qemu_log("SEEK_SET"); break;
2552
    case SEEK_CUR:
2553
        qemu_log("SEEK_CUR"); break;
2554
    case SEEK_END:
2555
        qemu_log("SEEK_END"); break;
2556
#ifdef SEEK_DATA
2557
    case SEEK_DATA:
2558
        qemu_log("SEEK_DATA"); break;
2559
#endif
2560
#ifdef SEEK_HOLE
2561
    case SEEK_HOLE:
2562
        qemu_log("SEEK_HOLE"); break;
2563
#endif
2564
    default:
2565
        print_raw_param("%#x", arg2, 1);
2566
    }
2567
    print_syscall_epilogue(name);
2568
}
2569
#endif
2570

2571
#ifdef TARGET_NR_truncate
2572
static void
2573
print_truncate(CPUArchState *cpu_env, const struct syscallname *name,
2574
               abi_long arg0, abi_long arg1, abi_long arg2,
2575
               abi_long arg3, abi_long arg4, abi_long arg5)
2576
{
2577
    print_syscall_prologue(name);
2578
    print_string(arg0, 0);
2579
    print_raw_param(TARGET_ABI_FMT_ld, arg1, 1);
2580
    print_syscall_epilogue(name);
2581
}
2582
#endif
2583

2584
#ifdef TARGET_NR_truncate64
2585
static void
2586
print_truncate64(CPUArchState *cpu_env, const struct syscallname *name,
2587
                 abi_long arg0, abi_long arg1, abi_long arg2,
2588
                 abi_long arg3, abi_long arg4, abi_long arg5)
2589
{
2590
    print_syscall_prologue(name);
2591
    print_string(arg0, 0);
2592
    if (regpairs_aligned(cpu_env, TARGET_NR_truncate64)) {
2593
        arg1 = arg2;
2594
        arg2 = arg3;
2595
    }
2596
    print_raw_param("%" PRIu64, target_offset64(arg1, arg2), 1);
2597
    print_syscall_epilogue(name);
2598
}
2599
#endif
2600

2601
#ifdef TARGET_NR_ftruncate64
2602
static void
2603
print_ftruncate64(CPUArchState *cpu_env, const struct syscallname *name,
2604
                  abi_long arg0, abi_long arg1, abi_long arg2,
2605
                  abi_long arg3, abi_long arg4, abi_long arg5)
2606
{
2607
    print_syscall_prologue(name);
2608
    print_raw_param("%d", arg0, 0);
2609
    if (regpairs_aligned(cpu_env, TARGET_NR_ftruncate64)) {
2610
        arg1 = arg2;
2611
        arg2 = arg3;
2612
    }
2613
    print_raw_param("%" PRIu64, target_offset64(arg1, arg2), 1);
2614
    print_syscall_epilogue(name);
2615
}
2616
#endif
2617

2618
#ifdef TARGET_NR_mlockall
2619
static void
2620
print_mlockall(CPUArchState *cpu_env, const struct syscallname *name,
2621
               abi_long arg0, abi_long arg1, abi_long arg2,
2622
               abi_long arg3, abi_long arg4, abi_long arg5)
2623
{
2624
    print_syscall_prologue(name);
2625
    print_flags(mlockall_flags, arg0, 1);
2626
    print_syscall_epilogue(name);
2627
}
2628
#endif
2629

2630
#if defined(TARGET_NR_socket)
2631
static void
2632
print_socket(CPUArchState *cpu_env, const struct syscallname *name,
2633
             abi_long arg0, abi_long arg1, abi_long arg2,
2634
             abi_long arg3, abi_long arg4, abi_long arg5)
2635
{
2636
    abi_ulong domain = arg0, type = arg1, protocol = arg2;
2637

2638
    print_syscall_prologue(name);
2639
    print_socket_domain(domain);
2640
    qemu_log(",");
2641
    print_socket_type(type);
2642
    qemu_log(",");
2643
    if (domain == AF_PACKET ||
2644
        (domain == AF_INET && type == TARGET_SOCK_PACKET)) {
2645
        protocol = tswap16(protocol);
2646
    }
2647
    print_socket_protocol(domain, type, protocol);
2648
    print_syscall_epilogue(name);
2649
}
2650

2651
#endif
2652

2653
#if defined(TARGET_NR_socketcall) || defined(TARGET_NR_bind)
2654

2655
static void print_sockfd(abi_long sockfd, int last)
2656
{
2657
    print_raw_param(TARGET_ABI_FMT_ld, sockfd, last);
2658
}
2659

2660
#endif
2661

2662
#if defined(TARGET_NR_socketcall)
2663

2664
#define get_user_ualx(x, gaddr, idx) \
2665
        get_user_ual(x, (gaddr) + (idx) * sizeof(abi_long))
2666

2667
static void do_print_socket(const char *name, abi_long arg1)
2668
{
2669
    abi_ulong domain, type, protocol;
2670

2671
    get_user_ualx(domain, arg1, 0);
2672
    get_user_ualx(type, arg1, 1);
2673
    get_user_ualx(protocol, arg1, 2);
2674
    qemu_log("%s(", name);
2675
    print_socket_domain(domain);
2676
    qemu_log(",");
2677
    print_socket_type(type);
2678
    qemu_log(",");
2679
    if (domain == AF_PACKET ||
2680
        (domain == AF_INET && type == TARGET_SOCK_PACKET)) {
2681
        protocol = tswap16(protocol);
2682
    }
2683
    print_socket_protocol(domain, type, protocol);
2684
    qemu_log(")");
2685
}
2686

2687
static void do_print_sockaddr(const char *name, abi_long arg1)
2688
{
2689
    abi_ulong sockfd, addr, addrlen;
2690

2691
    get_user_ualx(sockfd, arg1, 0);
2692
    get_user_ualx(addr, arg1, 1);
2693
    get_user_ualx(addrlen, arg1, 2);
2694

2695
    qemu_log("%s(", name);
2696
    print_sockfd(sockfd, 0);
2697
    print_sockaddr(addr, addrlen, 0);
2698
    qemu_log(")");
2699
}
2700

2701
static void do_print_listen(const char *name, abi_long arg1)
2702
{
2703
    abi_ulong sockfd, backlog;
2704

2705
    get_user_ualx(sockfd, arg1, 0);
2706
    get_user_ualx(backlog, arg1, 1);
2707

2708
    qemu_log("%s(", name);
2709
    print_sockfd(sockfd, 0);
2710
    print_raw_param(TARGET_ABI_FMT_ld, backlog, 1);
2711
    qemu_log(")");
2712
}
2713

2714
static void do_print_socketpair(const char *name, abi_long arg1)
2715
{
2716
    abi_ulong domain, type, protocol, tab;
2717

2718
    get_user_ualx(domain, arg1, 0);
2719
    get_user_ualx(type, arg1, 1);
2720
    get_user_ualx(protocol, arg1, 2);
2721
    get_user_ualx(tab, arg1, 3);
2722

2723
    qemu_log("%s(", name);
2724
    print_socket_domain(domain);
2725
    qemu_log(",");
2726
    print_socket_type(type);
2727
    qemu_log(",");
2728
    print_socket_protocol(domain, type, protocol);
2729
    qemu_log(",");
2730
    print_raw_param(TARGET_ABI_FMT_lx, tab, 1);
2731
    qemu_log(")");
2732
}
2733

2734
static void do_print_sendrecv(const char *name, abi_long arg1)
2735
{
2736
    abi_ulong sockfd, msg, len, flags;
2737

2738
    get_user_ualx(sockfd, arg1, 0);
2739
    get_user_ualx(msg, arg1, 1);
2740
    get_user_ualx(len, arg1, 2);
2741
    get_user_ualx(flags, arg1, 3);
2742

2743
    qemu_log("%s(", name);
2744
    print_sockfd(sockfd, 0);
2745
    print_buf(msg, len, 0);
2746
    print_raw_param(TARGET_ABI_FMT_ld, len, 0);
2747
    print_flags(msg_flags, flags, 1);
2748
    qemu_log(")");
2749
}
2750

2751
static void do_print_msgaddr(const char *name, abi_long arg1)
2752
{
2753
    abi_ulong sockfd, msg, len, flags, addr, addrlen;
2754

2755
    get_user_ualx(sockfd, arg1, 0);
2756
    get_user_ualx(msg, arg1, 1);
2757
    get_user_ualx(len, arg1, 2);
2758
    get_user_ualx(flags, arg1, 3);
2759
    get_user_ualx(addr, arg1, 4);
2760
    get_user_ualx(addrlen, arg1, 5);
2761

2762
    qemu_log("%s(", name);
2763
    print_sockfd(sockfd, 0);
2764
    print_buf(msg, len, 0);
2765
    print_raw_param(TARGET_ABI_FMT_ld, len, 0);
2766
    print_flags(msg_flags, flags, 0);
2767
    print_sockaddr(addr, addrlen, 0);
2768
    qemu_log(")");
2769
}
2770

2771
static void do_print_shutdown(const char *name, abi_long arg1)
2772
{
2773
    abi_ulong sockfd, how;
2774

2775
    get_user_ualx(sockfd, arg1, 0);
2776
    get_user_ualx(how, arg1, 1);
2777

2778
    qemu_log("shutdown(");
2779
    print_sockfd(sockfd, 0);
2780
    switch (how) {
2781
    case SHUT_RD:
2782
        qemu_log("SHUT_RD");
2783
        break;
2784
    case SHUT_WR:
2785
        qemu_log("SHUT_WR");
2786
        break;
2787
    case SHUT_RDWR:
2788
        qemu_log("SHUT_RDWR");
2789
        break;
2790
    default:
2791
        print_raw_param(TARGET_ABI_FMT_ld, how, 1);
2792
        break;
2793
    }
2794
    qemu_log(")");
2795
}
2796

2797
static void do_print_msg(const char *name, abi_long arg1)
2798
{
2799
    abi_ulong sockfd, msg, flags;
2800

2801
    get_user_ualx(sockfd, arg1, 0);
2802
    get_user_ualx(msg, arg1, 1);
2803
    get_user_ualx(flags, arg1, 2);
2804

2805
    qemu_log("%s(", name);
2806
    print_sockfd(sockfd, 0);
2807
    print_pointer(msg, 0);
2808
    print_flags(msg_flags, flags, 1);
2809
    qemu_log(")");
2810
}
2811

2812
static void do_print_sockopt(const char *name, abi_long arg1)
2813
{
2814
    abi_ulong sockfd, level, optname, optval, optlen;
2815

2816
    get_user_ualx(sockfd, arg1, 0);
2817
    get_user_ualx(level, arg1, 1);
2818
    get_user_ualx(optname, arg1, 2);
2819
    get_user_ualx(optval, arg1, 3);
2820
    get_user_ualx(optlen, arg1, 4);
2821

2822
    qemu_log("%s(", name);
2823
    print_sockfd(sockfd, 0);
2824
    switch (level) {
2825
    case SOL_TCP:
2826
        qemu_log("SOL_TCP,");
2827
        print_raw_param(TARGET_ABI_FMT_ld, optname, 0);
2828
        print_pointer(optval, 0);
2829
        break;
2830
    case SOL_UDP:
2831
        qemu_log("SOL_UDP,");
2832
        print_raw_param(TARGET_ABI_FMT_ld, optname, 0);
2833
        print_pointer(optval, 0);
2834
        break;
2835
    case SOL_IP:
2836
        qemu_log("SOL_IP,");
2837
        print_raw_param(TARGET_ABI_FMT_ld, optname, 0);
2838
        print_pointer(optval, 0);
2839
        break;
2840
    case SOL_RAW:
2841
        qemu_log("SOL_RAW,");
2842
        print_raw_param(TARGET_ABI_FMT_ld, optname, 0);
2843
        print_pointer(optval, 0);
2844
        break;
2845
    case TARGET_SOL_SOCKET:
2846
        qemu_log("SOL_SOCKET,");
2847
        switch (optname) {
2848
        case TARGET_SO_DEBUG:
2849
            qemu_log("SO_DEBUG,");
2850
print_optint:
2851
            print_number(optval, 0);
2852
            break;
2853
        case TARGET_SO_REUSEADDR:
2854
            qemu_log("SO_REUSEADDR,");
2855
            goto print_optint;
2856
        case TARGET_SO_REUSEPORT:
2857
            qemu_log("SO_REUSEPORT,");
2858
            goto print_optint;
2859
        case TARGET_SO_TYPE:
2860
            qemu_log("SO_TYPE,");
2861
            goto print_optint;
2862
        case TARGET_SO_ERROR:
2863
            qemu_log("SO_ERROR,");
2864
            goto print_optint;
2865
        case TARGET_SO_DONTROUTE:
2866
            qemu_log("SO_DONTROUTE,");
2867
            goto print_optint;
2868
        case TARGET_SO_BROADCAST:
2869
            qemu_log("SO_BROADCAST,");
2870
            goto print_optint;
2871
        case TARGET_SO_SNDBUF:
2872
            qemu_log("SO_SNDBUF,");
2873
            goto print_optint;
2874
        case TARGET_SO_RCVBUF:
2875
            qemu_log("SO_RCVBUF,");
2876
            goto print_optint;
2877
        case TARGET_SO_KEEPALIVE:
2878
            qemu_log("SO_KEEPALIVE,");
2879
            goto print_optint;
2880
        case TARGET_SO_OOBINLINE:
2881
            qemu_log("SO_OOBINLINE,");
2882
            goto print_optint;
2883
        case TARGET_SO_NO_CHECK:
2884
            qemu_log("SO_NO_CHECK,");
2885
            goto print_optint;
2886
        case TARGET_SO_PRIORITY:
2887
            qemu_log("SO_PRIORITY,");
2888
            goto print_optint;
2889
        case TARGET_SO_BSDCOMPAT:
2890
            qemu_log("SO_BSDCOMPAT,");
2891
            goto print_optint;
2892
        case TARGET_SO_PASSCRED:
2893
            qemu_log("SO_PASSCRED,");
2894
            goto print_optint;
2895
        case TARGET_SO_TIMESTAMP:
2896
            qemu_log("SO_TIMESTAMP,");
2897
            goto print_optint;
2898
        case TARGET_SO_RCVLOWAT:
2899
            qemu_log("SO_RCVLOWAT,");
2900
            goto print_optint;
2901
        case TARGET_SO_RCVTIMEO:
2902
            qemu_log("SO_RCVTIMEO,");
2903
            print_timeval(optval, 0);
2904
            break;
2905
        case TARGET_SO_SNDTIMEO:
2906
            qemu_log("SO_SNDTIMEO,");
2907
            print_timeval(optval, 0);
2908
            break;
2909
        case TARGET_SO_ATTACH_FILTER: {
2910
            struct target_sock_fprog *fprog;
2911

2912
            qemu_log("SO_ATTACH_FILTER,");
2913

2914
            if (lock_user_struct(VERIFY_READ, fprog, optval,  0)) {
2915
                struct target_sock_filter *filter;
2916
                qemu_log("{");
2917
                if (lock_user_struct(VERIFY_READ, filter,
2918
                                     tswapal(fprog->filter),  0)) {
2919
                    int i;
2920
                    for (i = 0; i < tswap16(fprog->len) - 1; i++) {
2921
                        qemu_log("[%d]{0x%x,%d,%d,0x%x},",
2922
                                 i, tswap16(filter[i].code),
2923
                                 filter[i].jt, filter[i].jf,
2924
                                 tswap32(filter[i].k));
2925
                    }
2926
                    qemu_log("[%d]{0x%x,%d,%d,0x%x}",
2927
                             i, tswap16(filter[i].code),
2928
                             filter[i].jt, filter[i].jf,
2929
                             tswap32(filter[i].k));
2930
                } else {
2931
                    qemu_log(TARGET_ABI_FMT_lx, tswapal(fprog->filter));
2932
                }
2933
                qemu_log(",%d},", tswap16(fprog->len));
2934
                unlock_user(fprog, optval, 0);
2935
            } else {
2936
                print_pointer(optval, 0);
2937
            }
2938
            break;
2939
        }
2940
        default:
2941
            print_raw_param(TARGET_ABI_FMT_ld, optname, 0);
2942
            print_pointer(optval, 0);
2943
            break;
2944
        }
2945
        break;
2946
    case SOL_IPV6:
2947
        qemu_log("SOL_IPV6,");
2948
        switch (optname) {
2949
        case IPV6_MTU_DISCOVER:
2950
            qemu_log("IPV6_MTU_DISCOVER,");
2951
            goto print_optint;
2952
        case IPV6_MTU:
2953
            qemu_log("IPV6_MTU,");
2954
            goto print_optint;
2955
        case IPV6_V6ONLY:
2956
            qemu_log("IPV6_V6ONLY,");
2957
            goto print_optint;
2958
        case IPV6_RECVPKTINFO:
2959
            qemu_log("IPV6_RECVPKTINFO,");
2960
            goto print_optint;
2961
        case IPV6_UNICAST_HOPS:
2962
            qemu_log("IPV6_UNICAST_HOPS,");
2963
            goto print_optint;
2964
        case IPV6_MULTICAST_HOPS:
2965
            qemu_log("IPV6_MULTICAST_HOPS,");
2966
            goto print_optint;
2967
        case IPV6_MULTICAST_LOOP:
2968
            qemu_log("IPV6_MULTICAST_LOOP,");
2969
            goto print_optint;
2970
        case IPV6_RECVERR:
2971
            qemu_log("IPV6_RECVERR,");
2972
            goto print_optint;
2973
        case IPV6_RECVHOPLIMIT:
2974
            qemu_log("IPV6_RECVHOPLIMIT,");
2975
            goto print_optint;
2976
        case IPV6_2292HOPLIMIT:
2977
            qemu_log("IPV6_2292HOPLIMIT,");
2978
            goto print_optint;
2979
        case IPV6_CHECKSUM:
2980
            qemu_log("IPV6_CHECKSUM,");
2981
            goto print_optint;
2982
        case IPV6_ADDRFORM:
2983
            qemu_log("IPV6_ADDRFORM,");
2984
            goto print_optint;
2985
        case IPV6_2292PKTINFO:
2986
            qemu_log("IPV6_2292PKTINFO,");
2987
            goto print_optint;
2988
        case IPV6_RECVTCLASS:
2989
            qemu_log("IPV6_RECVTCLASS,");
2990
            goto print_optint;
2991
        case IPV6_RECVRTHDR:
2992
            qemu_log("IPV6_RECVRTHDR,");
2993
            goto print_optint;
2994
        case IPV6_2292RTHDR:
2995
            qemu_log("IPV6_2292RTHDR,");
2996
            goto print_optint;
2997
        case IPV6_RECVHOPOPTS:
2998
            qemu_log("IPV6_RECVHOPOPTS,");
2999
            goto print_optint;
3000
        case IPV6_2292HOPOPTS:
3001
            qemu_log("IPV6_2292HOPOPTS,");
3002
            goto print_optint;
3003
        case IPV6_RECVDSTOPTS:
3004
            qemu_log("IPV6_RECVDSTOPTS,");
3005
            goto print_optint;
3006
        case IPV6_2292DSTOPTS:
3007
            qemu_log("IPV6_2292DSTOPTS,");
3008
            goto print_optint;
3009
        case IPV6_TCLASS:
3010
            qemu_log("IPV6_TCLASS,");
3011
            goto print_optint;
3012
        case IPV6_ADDR_PREFERENCES:
3013
            qemu_log("IPV6_ADDR_PREFERENCES,");
3014
            goto print_optint;
3015
#ifdef IPV6_RECVPATHMTU
3016
        case IPV6_RECVPATHMTU:
3017
            qemu_log("IPV6_RECVPATHMTU,");
3018
            goto print_optint;
3019
#endif
3020
#ifdef IPV6_TRANSPARENT
3021
        case IPV6_TRANSPARENT:
3022
            qemu_log("IPV6_TRANSPARENT,");
3023
            goto print_optint;
3024
#endif
3025
#ifdef IPV6_FREEBIND
3026
        case IPV6_FREEBIND:
3027
            qemu_log("IPV6_FREEBIND,");
3028
            goto print_optint;
3029
#endif
3030
#ifdef IPV6_RECVORIGDSTADDR
3031
        case IPV6_RECVORIGDSTADDR:
3032
            qemu_log("IPV6_RECVORIGDSTADDR,");
3033
            goto print_optint;
3034
#endif
3035
        case IPV6_PKTINFO:
3036
            qemu_log("IPV6_PKTINFO,");
3037
            print_pointer(optval, 0);
3038
            break;
3039
        case IPV6_ADD_MEMBERSHIP:
3040
            qemu_log("IPV6_ADD_MEMBERSHIP,");
3041
            print_pointer(optval, 0);
3042
            break;
3043
        case IPV6_DROP_MEMBERSHIP:
3044
            qemu_log("IPV6_DROP_MEMBERSHIP,");
3045
            print_pointer(optval, 0);
3046
            break;
3047
        default:
3048
            print_raw_param(TARGET_ABI_FMT_ld, optname, 0);
3049
            print_pointer(optval, 0);
3050
            break;
3051
        }
3052
        break;
3053
    default:
3054
        print_raw_param(TARGET_ABI_FMT_ld, level, 0);
3055
        print_raw_param(TARGET_ABI_FMT_ld, optname, 0);
3056
        print_pointer(optval, 0);
3057
        break;
3058
    }
3059
    print_raw_param(TARGET_ABI_FMT_ld, optlen, 1);
3060
    qemu_log(")");
3061
}
3062

3063
#define PRINT_SOCKOP(name, func) \
3064
    [TARGET_SYS_##name] = { #name, func }
3065

3066
static struct {
3067
    const char *name;
3068
    void (*print)(const char *, abi_long);
3069
} scall[] = {
3070
    PRINT_SOCKOP(SOCKET, do_print_socket),
3071
    PRINT_SOCKOP(BIND, do_print_sockaddr),
3072
    PRINT_SOCKOP(CONNECT, do_print_sockaddr),
3073
    PRINT_SOCKOP(LISTEN, do_print_listen),
3074
    PRINT_SOCKOP(ACCEPT, do_print_sockaddr),
3075
    PRINT_SOCKOP(GETSOCKNAME, do_print_sockaddr),
3076
    PRINT_SOCKOP(GETPEERNAME, do_print_sockaddr),
3077
    PRINT_SOCKOP(SOCKETPAIR, do_print_socketpair),
3078
    PRINT_SOCKOP(SEND, do_print_sendrecv),
3079
    PRINT_SOCKOP(RECV, do_print_sendrecv),
3080
    PRINT_SOCKOP(SENDTO, do_print_msgaddr),
3081
    PRINT_SOCKOP(RECVFROM, do_print_msgaddr),
3082
    PRINT_SOCKOP(SHUTDOWN, do_print_shutdown),
3083
    PRINT_SOCKOP(SETSOCKOPT, do_print_sockopt),
3084
    PRINT_SOCKOP(GETSOCKOPT, do_print_sockopt),
3085
    PRINT_SOCKOP(SENDMSG, do_print_msg),
3086
    PRINT_SOCKOP(RECVMSG, do_print_msg),
3087
    PRINT_SOCKOP(ACCEPT4, NULL),
3088
    PRINT_SOCKOP(RECVMMSG, NULL),
3089
    PRINT_SOCKOP(SENDMMSG, NULL),
3090
};
3091

3092
static void
3093
print_socketcall(CPUArchState *cpu_env, const struct syscallname *name,
3094
                 abi_long arg0, abi_long arg1, abi_long arg2,
3095
                 abi_long arg3, abi_long arg4, abi_long arg5)
3096
{
3097
    if (arg0 >= 0 && arg0 < ARRAY_SIZE(scall) && scall[arg0].print) {
3098
        scall[arg0].print(scall[arg0].name, arg1);
3099
        return;
3100
    }
3101
    print_syscall_prologue(name);
3102
    print_raw_param(TARGET_ABI_FMT_ld, arg0, 0);
3103
    print_raw_param(TARGET_ABI_FMT_ld, arg1, 0);
3104
    print_raw_param(TARGET_ABI_FMT_ld, arg2, 0);
3105
    print_raw_param(TARGET_ABI_FMT_ld, arg3, 0);
3106
    print_raw_param(TARGET_ABI_FMT_ld, arg4, 0);
3107
    print_raw_param(TARGET_ABI_FMT_ld, arg5, 0);
3108
    print_syscall_epilogue(name);
3109
}
3110
#endif
3111

3112
#if defined(TARGET_NR_bind)
3113
static void
3114
print_bind(CPUArchState *cpu_env, const struct syscallname *name,
3115
           abi_long arg0, abi_long arg1, abi_long arg2,
3116
           abi_long arg3, abi_long arg4, abi_long arg5)
3117
{
3118
    print_syscall_prologue(name);
3119
    print_sockfd(arg0, 0);
3120
    print_sockaddr(arg1, arg2, 1);
3121
    print_syscall_epilogue(name);
3122
}
3123
#endif
3124

3125
#if defined(TARGET_NR_stat) || defined(TARGET_NR_stat64) || \
3126
    defined(TARGET_NR_lstat) || defined(TARGET_NR_lstat64)
3127
static void
3128
print_stat(CPUArchState *cpu_env, const struct syscallname *name,
3129
           abi_long arg0, abi_long arg1, abi_long arg2,
3130
           abi_long arg3, abi_long arg4, abi_long arg5)
3131
{
3132
    print_syscall_prologue(name);
3133
    print_string(arg0, 0);
3134
    print_pointer(arg1, 1);
3135
    print_syscall_epilogue(name);
3136
}
3137
#define print_lstat     print_stat
3138
#define print_stat64	print_stat
3139
#define print_lstat64   print_stat
3140
#endif
3141

3142
#if defined(TARGET_NR_madvise)
3143
static struct enums madvise_advice[] = {
3144
    ENUM_TARGET(MADV_NORMAL),
3145
    ENUM_TARGET(MADV_RANDOM),
3146
    ENUM_TARGET(MADV_SEQUENTIAL),
3147
    ENUM_TARGET(MADV_WILLNEED),
3148
    ENUM_TARGET(MADV_DONTNEED),
3149
    ENUM_TARGET(MADV_FREE),
3150
    ENUM_TARGET(MADV_REMOVE),
3151
    ENUM_TARGET(MADV_DONTFORK),
3152
    ENUM_TARGET(MADV_DOFORK),
3153
    ENUM_TARGET(MADV_MERGEABLE),
3154
    ENUM_TARGET(MADV_UNMERGEABLE),
3155
    ENUM_TARGET(MADV_HUGEPAGE),
3156
    ENUM_TARGET(MADV_NOHUGEPAGE),
3157
    ENUM_TARGET(MADV_DONTDUMP),
3158
    ENUM_TARGET(MADV_DODUMP),
3159
    ENUM_TARGET(MADV_WIPEONFORK),
3160
    ENUM_TARGET(MADV_KEEPONFORK),
3161
    ENUM_TARGET(MADV_COLD),
3162
    ENUM_TARGET(MADV_PAGEOUT),
3163
    ENUM_TARGET(MADV_POPULATE_READ),
3164
    ENUM_TARGET(MADV_POPULATE_WRITE),
3165
    ENUM_TARGET(MADV_DONTNEED_LOCKED),
3166
    ENUM_END,
3167
};
3168

3169
static void
3170
print_madvise(CPUArchState *cpu_env, const struct syscallname *name,
3171
              abi_long arg0, abi_long arg1, abi_long arg2,
3172
              abi_long arg3, abi_long arg4, abi_long arg5)
3173
{
3174
    print_syscall_prologue(name);
3175
    print_pointer(arg0, 0);
3176
    print_raw_param("%d", arg1, 0);
3177
    print_enums(madvise_advice, arg2, 1);
3178
    print_syscall_epilogue(name);
3179
}
3180
#endif
3181

3182
#if defined(TARGET_NR_fstat) || defined(TARGET_NR_fstat64)
3183
static void
3184
print_fstat(CPUArchState *cpu_env, const struct syscallname *name,
3185
            abi_long arg0, abi_long arg1, abi_long arg2,
3186
            abi_long arg3, abi_long arg4, abi_long arg5)
3187
{
3188
    print_syscall_prologue(name);
3189
    print_raw_param("%d", arg0, 0);
3190
    print_pointer(arg1, 1);
3191
    print_syscall_epilogue(name);
3192
}
3193
#define print_fstat64     print_fstat
3194
#endif
3195

3196
#ifdef TARGET_NR_mkdir
3197
static void
3198
print_mkdir(CPUArchState *cpu_env, const struct syscallname *name,
3199
            abi_long arg0, abi_long arg1, abi_long arg2,
3200
            abi_long arg3, abi_long arg4, abi_long arg5)
3201
{
3202
    print_syscall_prologue(name);
3203
    print_string(arg0, 0);
3204
    print_file_mode(arg1, 1);
3205
    print_syscall_epilogue(name);
3206
}
3207
#endif
3208

3209
#ifdef TARGET_NR_mkdirat
3210
static void
3211
print_mkdirat(CPUArchState *cpu_env, const struct syscallname *name,
3212
              abi_long arg0, abi_long arg1, abi_long arg2,
3213
              abi_long arg3, abi_long arg4, abi_long arg5)
3214
{
3215
    print_syscall_prologue(name);
3216
    print_at_dirfd(arg0, 0);
3217
    print_string(arg1, 0);
3218
    print_file_mode(arg2, 1);
3219
    print_syscall_epilogue(name);
3220
}
3221
#endif
3222

3223
#ifdef TARGET_NR_rmdir
3224
static void
3225
print_rmdir(CPUArchState *cpu_env, const struct syscallname *name,
3226
            abi_long arg0, abi_long arg1, abi_long arg2,
3227
            abi_long arg3, abi_long arg4, abi_long arg5)
3228
{
3229
    print_syscall_prologue(name);
3230
    print_string(arg0, 0);
3231
    print_syscall_epilogue(name);
3232
}
3233
#endif
3234

3235
#ifdef TARGET_NR_rt_sigaction
3236
static void
3237
print_rt_sigaction(CPUArchState *cpu_env, const struct syscallname *name,
3238
                   abi_long arg0, abi_long arg1, abi_long arg2,
3239
                   abi_long arg3, abi_long arg4, abi_long arg5)
3240
{
3241
    print_syscall_prologue(name);
3242
    print_signal(arg0, 0);
3243
    print_pointer(arg1, 0);
3244
    print_pointer(arg2, 1);
3245
    print_syscall_epilogue(name);
3246
}
3247
#endif
3248

3249
#ifdef TARGET_NR_rt_sigprocmask
3250
static void
3251
print_rt_sigprocmask(CPUArchState *cpu_env, const struct syscallname *name,
3252
                     abi_long arg0, abi_long arg1, abi_long arg2,
3253
                     abi_long arg3, abi_long arg4, abi_long arg5)
3254
{
3255
    const char *how = "UNKNOWN";
3256
    print_syscall_prologue(name);
3257
    switch(arg0) {
3258
    case TARGET_SIG_BLOCK: how = "SIG_BLOCK"; break;
3259
    case TARGET_SIG_UNBLOCK: how = "SIG_UNBLOCK"; break;
3260
    case TARGET_SIG_SETMASK: how = "SIG_SETMASK"; break;
3261
    }
3262
    qemu_log("%s,", how);
3263
    print_pointer(arg1, 0);
3264
    print_pointer(arg2, 0);
3265
    print_raw_param("%u", arg3, 1);
3266
    print_syscall_epilogue(name);
3267
}
3268
#endif
3269

3270
#ifdef TARGET_NR_rt_sigqueueinfo
3271
static void
3272
print_rt_sigqueueinfo(CPUArchState *cpu_env, const struct syscallname *name,
3273
                      abi_long arg0, abi_long arg1, abi_long arg2,
3274
                      abi_long arg3, abi_long arg4, abi_long arg5)
3275
{
3276
    void *p;
3277
    target_siginfo_t uinfo;
3278

3279
    print_syscall_prologue(name);
3280
    print_raw_param("%d", arg0, 0);
3281
    print_signal(arg1, 0);
3282
    p = lock_user(VERIFY_READ, arg2, sizeof(target_siginfo_t), 1);
3283
    if (p) {
3284
        get_target_siginfo(&uinfo, p);
3285
        print_siginfo(&uinfo);
3286

3287
        unlock_user(p, arg2, 0);
3288
    } else {
3289
        print_pointer(arg2, 1);
3290
    }
3291
    print_syscall_epilogue(name);
3292
}
3293
#endif
3294

3295
#ifdef TARGET_NR_rt_tgsigqueueinfo
3296
static void
3297
print_rt_tgsigqueueinfo(CPUArchState *cpu_env, const struct syscallname *name,
3298
                        abi_long arg0, abi_long arg1, abi_long arg2,
3299
                        abi_long arg3, abi_long arg4, abi_long arg5)
3300
{
3301
    void *p;
3302
    target_siginfo_t uinfo;
3303

3304
    print_syscall_prologue(name);
3305
    print_raw_param("%d", arg0, 0);
3306
    print_raw_param("%d", arg1, 0);
3307
    print_signal(arg2, 0);
3308
    p = lock_user(VERIFY_READ, arg3, sizeof(target_siginfo_t), 1);
3309
    if (p) {
3310
        get_target_siginfo(&uinfo, p);
3311
        print_siginfo(&uinfo);
3312

3313
        unlock_user(p, arg3, 0);
3314
    } else {
3315
        print_pointer(arg3, 1);
3316
    }
3317
    print_syscall_epilogue(name);
3318
}
3319
#endif
3320

3321
#ifdef TARGET_NR_syslog
3322
static void
3323
print_syslog_action(abi_ulong arg, int last)
3324
{
3325
    const char *type;
3326

3327
    switch (arg) {
3328
        case TARGET_SYSLOG_ACTION_CLOSE: {
3329
            type = "SYSLOG_ACTION_CLOSE";
3330
            break;
3331
        }
3332
        case TARGET_SYSLOG_ACTION_OPEN: {
3333
            type = "SYSLOG_ACTION_OPEN";
3334
            break;
3335
        }
3336
        case TARGET_SYSLOG_ACTION_READ: {
3337
            type = "SYSLOG_ACTION_READ";
3338
            break;
3339
        }
3340
        case TARGET_SYSLOG_ACTION_READ_ALL: {
3341
            type = "SYSLOG_ACTION_READ_ALL";
3342
            break;
3343
        }
3344
        case TARGET_SYSLOG_ACTION_READ_CLEAR: {
3345
            type = "SYSLOG_ACTION_READ_CLEAR";
3346
            break;
3347
        }
3348
        case TARGET_SYSLOG_ACTION_CLEAR: {
3349
            type = "SYSLOG_ACTION_CLEAR";
3350
            break;
3351
        }
3352
        case TARGET_SYSLOG_ACTION_CONSOLE_OFF: {
3353
            type = "SYSLOG_ACTION_CONSOLE_OFF";
3354
            break;
3355
        }
3356
        case TARGET_SYSLOG_ACTION_CONSOLE_ON: {
3357
            type = "SYSLOG_ACTION_CONSOLE_ON";
3358
            break;
3359
        }
3360
        case TARGET_SYSLOG_ACTION_CONSOLE_LEVEL: {
3361
            type = "SYSLOG_ACTION_CONSOLE_LEVEL";
3362
            break;
3363
        }
3364
        case TARGET_SYSLOG_ACTION_SIZE_UNREAD: {
3365
            type = "SYSLOG_ACTION_SIZE_UNREAD";
3366
            break;
3367
        }
3368
        case TARGET_SYSLOG_ACTION_SIZE_BUFFER: {
3369
            type = "SYSLOG_ACTION_SIZE_BUFFER";
3370
            break;
3371
        }
3372
        default: {
3373
            print_raw_param("%ld", arg, last);
3374
            return;
3375
        }
3376
    }
3377
    qemu_log("%s%s", type, get_comma(last));
3378
}
3379

3380
static void
3381
print_syslog(CPUArchState *cpu_env, const struct syscallname *name,
3382
             abi_long arg0, abi_long arg1, abi_long arg2,
3383
             abi_long arg3, abi_long arg4, abi_long arg5)
3384
{
3385
    print_syscall_prologue(name);
3386
    print_syslog_action(arg0, 0);
3387
    print_pointer(arg1, 0);
3388
    print_raw_param("%d", arg2, 1);
3389
    print_syscall_epilogue(name);
3390
}
3391
#endif
3392

3393
#ifdef TARGET_NR_mknod
3394
static void
3395
print_mknod(CPUArchState *cpu_env, const struct syscallname *name,
3396
            abi_long arg0, abi_long arg1, abi_long arg2,
3397
            abi_long arg3, abi_long arg4, abi_long arg5)
3398
{
3399
    int hasdev = (arg1 & (S_IFCHR|S_IFBLK));
3400

3401
    print_syscall_prologue(name);
3402
    print_string(arg0, 0);
3403
    print_file_mode(arg1, (hasdev == 0));
3404
    if (hasdev) {
3405
        print_raw_param("makedev(%d", major(arg2), 0);
3406
        print_raw_param("%d)", minor(arg2), 1);
3407
    }
3408
    print_syscall_epilogue(name);
3409
}
3410
#endif
3411

3412
#ifdef TARGET_NR_mknodat
3413
static void
3414
print_mknodat(CPUArchState *cpu_env, const struct syscallname *name,
3415
              abi_long arg0, abi_long arg1, abi_long arg2,
3416
              abi_long arg3, abi_long arg4, abi_long arg5)
3417
{
3418
    int hasdev = (arg2 & (S_IFCHR|S_IFBLK));
3419

3420
    print_syscall_prologue(name);
3421
    print_at_dirfd(arg0, 0);
3422
    print_string(arg1, 0);
3423
    print_file_mode(arg2, (hasdev == 0));
3424
    if (hasdev) {
3425
        print_raw_param("makedev(%d", major(arg3), 0);
3426
        print_raw_param("%d)", minor(arg3), 1);
3427
    }
3428
    print_syscall_epilogue(name);
3429
}
3430
#endif
3431

3432
#ifdef TARGET_NR_mq_open
3433
static void
3434
print_mq_open(CPUArchState *cpu_env, const struct syscallname *name,
3435
              abi_long arg0, abi_long arg1, abi_long arg2,
3436
              abi_long arg3, abi_long arg4, abi_long arg5)
3437
{
3438
    int is_creat = (arg1 & TARGET_O_CREAT);
3439

3440
    print_syscall_prologue(name);
3441
    print_string(arg0, 0);
3442
    print_open_flags(arg1, (is_creat == 0));
3443
    if (is_creat) {
3444
        print_file_mode(arg2, 0);
3445
        print_pointer(arg3, 1);
3446
    }
3447
    print_syscall_epilogue(name);
3448
}
3449
#endif
3450

3451
#ifdef TARGET_NR_open
3452
static void
3453
print_open(CPUArchState *cpu_env, const struct syscallname *name,
3454
           abi_long arg0, abi_long arg1, abi_long arg2,
3455
           abi_long arg3, abi_long arg4, abi_long arg5)
3456
{
3457
    int is_creat = (arg1 & TARGET_O_CREAT);
3458

3459
    print_syscall_prologue(name);
3460
    print_string(arg0, 0);
3461
    print_open_flags(arg1, (is_creat == 0));
3462
    if (is_creat)
3463
        print_file_mode(arg2, 1);
3464
    print_syscall_epilogue(name);
3465
}
3466
#endif
3467

3468
#ifdef TARGET_NR_openat
3469
static void
3470
print_openat(CPUArchState *cpu_env, const struct syscallname *name,
3471
             abi_long arg0, abi_long arg1, abi_long arg2,
3472
             abi_long arg3, abi_long arg4, abi_long arg5)
3473
{
3474
    int is_creat = (arg2 & TARGET_O_CREAT);
3475

3476
    print_syscall_prologue(name);
3477
    print_at_dirfd(arg0, 0);
3478
    print_string(arg1, 0);
3479
    print_open_flags(arg2, (is_creat == 0));
3480
    if (is_creat)
3481
        print_file_mode(arg3, 1);
3482
    print_syscall_epilogue(name);
3483
}
3484
#endif
3485

3486
#ifdef TARGET_NR_pidfd_send_signal
3487
static void
3488
print_pidfd_send_signal(CPUArchState *cpu_env, const struct syscallname *name,
3489
                abi_long arg0, abi_long arg1, abi_long arg2,
3490
                abi_long arg3, abi_long arg4, abi_long arg5)
3491
{
3492
    void *p;
3493
    target_siginfo_t uinfo;
3494

3495
    print_syscall_prologue(name);
3496
    print_raw_param("%d", arg0, 0);
3497
    print_signal(arg1, 0);
3498

3499
    p = lock_user(VERIFY_READ, arg2, sizeof(target_siginfo_t), 1);
3500
    if (p) {
3501
        get_target_siginfo(&uinfo, p);
3502
        print_siginfo(&uinfo);
3503

3504
        unlock_user(p, arg2, 0);
3505
    } else {
3506
        print_pointer(arg2, 0);
3507
    }
3508

3509
    print_raw_param("%u", arg3, 1);
3510
    print_syscall_epilogue(name);
3511
}
3512
#endif
3513

3514
#ifdef TARGET_NR_mq_unlink
3515
static void
3516
print_mq_unlink(CPUArchState *cpu_env, const struct syscallname *name,
3517
                abi_long arg0, abi_long arg1, abi_long arg2,
3518
                abi_long arg3, abi_long arg4, abi_long arg5)
3519
{
3520
    print_syscall_prologue(name);
3521
    print_string(arg0, 1);
3522
    print_syscall_epilogue(name);
3523
}
3524
#endif
3525

3526
#if defined(TARGET_NR_fstatat64) || defined(TARGET_NR_newfstatat)
3527
static void
3528
print_fstatat64(CPUArchState *cpu_env, const struct syscallname *name,
3529
                abi_long arg0, abi_long arg1, abi_long arg2,
3530
                abi_long arg3, abi_long arg4, abi_long arg5)
3531
{
3532
    print_syscall_prologue(name);
3533
    print_at_dirfd(arg0, 0);
3534
    print_string(arg1, 0);
3535
    print_pointer(arg2, 0);
3536
    print_flags(at_file_flags, arg3, 1);
3537
    print_syscall_epilogue(name);
3538
}
3539
#define print_newfstatat    print_fstatat64
3540
#endif
3541

3542
#ifdef TARGET_NR_readlink
3543
static void
3544
print_readlink(CPUArchState *cpu_env, const struct syscallname *name,
3545
               abi_long arg0, abi_long arg1, abi_long arg2,
3546
               abi_long arg3, abi_long arg4, abi_long arg5)
3547
{
3548
    print_syscall_prologue(name);
3549
    print_string(arg0, 0);
3550
    print_pointer(arg1, 0);
3551
    print_raw_param("%u", arg2, 1);
3552
    print_syscall_epilogue(name);
3553
}
3554
#endif
3555

3556
#ifdef TARGET_NR_readlinkat
3557
static void
3558
print_readlinkat(CPUArchState *cpu_env, const struct syscallname *name,
3559
                 abi_long arg0, abi_long arg1, abi_long arg2,
3560
                 abi_long arg3, abi_long arg4, abi_long arg5)
3561
{
3562
    print_syscall_prologue(name);
3563
    print_at_dirfd(arg0, 0);
3564
    print_string(arg1, 0);
3565
    print_pointer(arg2, 0);
3566
    print_raw_param("%u", arg3, 1);
3567
    print_syscall_epilogue(name);
3568
}
3569
#endif
3570

3571
#ifdef TARGET_NR_rename
3572
static void
3573
print_rename(CPUArchState *cpu_env, const struct syscallname *name,
3574
             abi_long arg0, abi_long arg1, abi_long arg2,
3575
             abi_long arg3, abi_long arg4, abi_long arg5)
3576
{
3577
    print_syscall_prologue(name);
3578
    print_string(arg0, 0);
3579
    print_string(arg1, 1);
3580
    print_syscall_epilogue(name);
3581
}
3582
#endif
3583

3584
#ifdef TARGET_NR_renameat
3585
static void
3586
print_renameat(CPUArchState *cpu_env, const struct syscallname *name,
3587
               abi_long arg0, abi_long arg1, abi_long arg2,
3588
               abi_long arg3, abi_long arg4, abi_long arg5)
3589
{
3590
    print_syscall_prologue(name);
3591
    print_at_dirfd(arg0, 0);
3592
    print_string(arg1, 0);
3593
    print_at_dirfd(arg2, 0);
3594
    print_string(arg3, 1);
3595
    print_syscall_epilogue(name);
3596
}
3597
#endif
3598

3599
#ifdef TARGET_NR_statfs
3600
static void
3601
print_statfs(CPUArchState *cpu_env, const struct syscallname *name,
3602
             abi_long arg0, abi_long arg1, abi_long arg2,
3603
             abi_long arg3, abi_long arg4, abi_long arg5)
3604
{
3605
    print_syscall_prologue(name);
3606
    print_string(arg0, 0);
3607
    print_pointer(arg1, 1);
3608
    print_syscall_epilogue(name);
3609
}
3610
#endif
3611

3612
#ifdef TARGET_NR_statfs64
3613
static void
3614
print_statfs64(CPUArchState *cpu_env, const struct syscallname *name,
3615
               abi_long arg0, abi_long arg1, abi_long arg2,
3616
               abi_long arg3, abi_long arg4, abi_long arg5)
3617
{
3618
    print_syscall_prologue(name);
3619
    print_string(arg0, 0);
3620
    print_pointer(arg1, 1);
3621
    print_syscall_epilogue(name);
3622
}
3623
#endif
3624

3625
#ifdef TARGET_NR_symlink
3626
static void
3627
print_symlink(CPUArchState *cpu_env, const struct syscallname *name,
3628
              abi_long arg0, abi_long arg1, abi_long arg2,
3629
              abi_long arg3, abi_long arg4, abi_long arg5)
3630
{
3631
    print_syscall_prologue(name);
3632
    print_string(arg0, 0);
3633
    print_string(arg1, 1);
3634
    print_syscall_epilogue(name);
3635
}
3636
#endif
3637

3638
#ifdef TARGET_NR_symlinkat
3639
static void
3640
print_symlinkat(CPUArchState *cpu_env, const struct syscallname *name,
3641
                abi_long arg0, abi_long arg1, abi_long arg2,
3642
                abi_long arg3, abi_long arg4, abi_long arg5)
3643
{
3644
    print_syscall_prologue(name);
3645
    print_string(arg0, 0);
3646
    print_at_dirfd(arg1, 0);
3647
    print_string(arg2, 1);
3648
    print_syscall_epilogue(name);
3649
}
3650
#endif
3651

3652
#ifdef TARGET_NR_mount
3653
static void
3654
print_mount(CPUArchState *cpu_env, const struct syscallname *name,
3655
            abi_long arg0, abi_long arg1, abi_long arg2,
3656
            abi_long arg3, abi_long arg4, abi_long arg5)
3657
{
3658
    print_syscall_prologue(name);
3659
    print_string(arg0, 0);
3660
    print_string(arg1, 0);
3661
    print_string(arg2, 0);
3662
    print_flags(mount_flags, arg3, 0);
3663
    print_pointer(arg4, 1);
3664
    print_syscall_epilogue(name);
3665
}
3666
#endif
3667

3668
#ifdef TARGET_NR_umount
3669
static void
3670
print_umount(CPUArchState *cpu_env, const struct syscallname *name,
3671
             abi_long arg0, abi_long arg1, abi_long arg2,
3672
             abi_long arg3, abi_long arg4, abi_long arg5)
3673
{
3674
    print_syscall_prologue(name);
3675
    print_string(arg0, 1);
3676
    print_syscall_epilogue(name);
3677
}
3678
#endif
3679

3680
#ifdef TARGET_NR_umount2
3681
static void
3682
print_umount2(CPUArchState *cpu_env, const struct syscallname *name,
3683
              abi_long arg0, abi_long arg1, abi_long arg2,
3684
              abi_long arg3, abi_long arg4, abi_long arg5)
3685
{
3686
    print_syscall_prologue(name);
3687
    print_string(arg0, 0);
3688
    print_flags(umount2_flags, arg1, 1);
3689
    print_syscall_epilogue(name);
3690
}
3691
#endif
3692

3693
#ifdef TARGET_NR_unlink
3694
static void
3695
print_unlink(CPUArchState *cpu_env, const struct syscallname *name,
3696
             abi_long arg0, abi_long arg1, abi_long arg2,
3697
             abi_long arg3, abi_long arg4, abi_long arg5)
3698
{
3699
    print_syscall_prologue(name);
3700
    print_string(arg0, 1);
3701
    print_syscall_epilogue(name);
3702
}
3703
#endif
3704

3705
#ifdef TARGET_NR_unlinkat
3706
static void
3707
print_unlinkat(CPUArchState *cpu_env, const struct syscallname *name,
3708
               abi_long arg0, abi_long arg1, abi_long arg2,
3709
               abi_long arg3, abi_long arg4, abi_long arg5)
3710
{
3711
    print_syscall_prologue(name);
3712
    print_at_dirfd(arg0, 0);
3713
    print_string(arg1, 0);
3714
    print_flags(unlinkat_flags, arg2, 1);
3715
    print_syscall_epilogue(name);
3716
}
3717
#endif
3718

3719
#ifdef TARGET_NR_unshare
3720
static void
3721
print_unshare(CPUArchState *cpu_env, const struct syscallname *name,
3722
              abi_long arg0, abi_long arg1, abi_long arg2,
3723
              abi_long arg3, abi_long arg4, abi_long arg5)
3724
{
3725
    print_syscall_prologue(name);
3726
    print_flags(clone_flags, arg0, 1);
3727
    print_syscall_epilogue(name);
3728
}
3729
#endif
3730

3731
#ifdef TARGET_NR_clock_nanosleep
3732
static void
3733
print_clock_nanosleep(CPUArchState *cpu_env, const struct syscallname *name,
3734
                abi_long arg0, abi_long arg1, abi_long arg2,
3735
                abi_long arg3, abi_long arg4, abi_long arg5)
3736
{
3737
    print_syscall_prologue(name);
3738
    print_enums(clockids, arg0, 0);
3739
    print_raw_param("%d", arg1, 0);
3740
    print_timespec(arg2, 0);
3741
    print_timespec(arg3, 1);
3742
    print_syscall_epilogue(name);
3743
}
3744
#endif
3745

3746
#ifdef TARGET_NR_utime
3747
static void
3748
print_utime(CPUArchState *cpu_env, const struct syscallname *name,
3749
            abi_long arg0, abi_long arg1, abi_long arg2,
3750
            abi_long arg3, abi_long arg4, abi_long arg5)
3751
{
3752
    print_syscall_prologue(name);
3753
    print_string(arg0, 0);
3754
    print_pointer(arg1, 1);
3755
    print_syscall_epilogue(name);
3756
}
3757
#endif
3758

3759
#ifdef TARGET_NR_utimes
3760
static void
3761
print_utimes(CPUArchState *cpu_env, const struct syscallname *name,
3762
             abi_long arg0, abi_long arg1, abi_long arg2,
3763
             abi_long arg3, abi_long arg4, abi_long arg5)
3764
{
3765
    print_syscall_prologue(name);
3766
    print_string(arg0, 0);
3767
    print_pointer(arg1, 1);
3768
    print_syscall_epilogue(name);
3769
}
3770
#endif
3771

3772
#ifdef TARGET_NR_utimensat
3773
static void
3774
print_utimensat(CPUArchState *cpu_env, const struct syscallname *name,
3775
                abi_long arg0, abi_long arg1, abi_long arg2,
3776
                abi_long arg3, abi_long arg4, abi_long arg5)
3777
{
3778
    print_syscall_prologue(name);
3779
    print_at_dirfd(arg0, 0);
3780
    print_string(arg1, 0);
3781
    print_pointer(arg2, 0);
3782
    print_flags(at_file_flags, arg3, 1);
3783
    print_syscall_epilogue(name);
3784
}
3785
#endif
3786

3787
#if defined(TARGET_NR_mmap) || defined(TARGET_NR_mmap2)
3788
static void
3789
print_mmap_both(CPUArchState *cpu_env, const struct syscallname *name,
3790
           abi_long arg0, abi_long arg1, abi_long arg2,
3791
           abi_long arg3, abi_long arg4, abi_long arg5,
3792
           bool is_old_mmap)
3793
{
3794
    if (is_old_mmap) {
3795
            abi_ulong *v;
3796
            abi_ulong argp = arg0;
3797
            if (!(v = lock_user(VERIFY_READ, argp, 6 * sizeof(abi_ulong), 1)))
3798
                return;
3799
            arg0 = tswapal(v[0]);
3800
            arg1 = tswapal(v[1]);
3801
            arg2 = tswapal(v[2]);
3802
            arg3 = tswapal(v[3]);
3803
            arg4 = tswapal(v[4]);
3804
            arg5 = tswapal(v[5]);
3805
            unlock_user(v, argp, 0);
3806
        }
3807
    print_syscall_prologue(name);
3808
    print_pointer(arg0, 0);
3809
    print_raw_param("%d", arg1, 0);
3810
    print_flags(mmap_prot_flags, arg2, 0);
3811
    print_flags(mmap_flags, arg3, 0);
3812
    print_raw_param("%d", arg4, 0);
3813
    print_raw_param("%#x", arg5, 1);
3814
    print_syscall_epilogue(name);
3815
}
3816
#endif
3817

3818
#if defined(TARGET_NR_mmap)
3819
static void
3820
print_mmap(CPUArchState *cpu_env, const struct syscallname *name,
3821
           abi_long arg0, abi_long arg1, abi_long arg2,
3822
           abi_long arg3, abi_long arg4, abi_long arg5)
3823
{
3824
    return print_mmap_both(cpu_env, name, arg0, arg1, arg2, arg3,
3825
                           arg4, arg5,
3826
#if defined(TARGET_NR_mmap2)
3827
                            true
3828
#else
3829
                            false
3830
#endif
3831
                            );
3832
}
3833
#endif
3834

3835
#if defined(TARGET_NR_mmap2)
3836
static void
3837
print_mmap2(CPUArchState *cpu_env, const struct syscallname *name,
3838
           abi_long arg0, abi_long arg1, abi_long arg2,
3839
           abi_long arg3, abi_long arg4, abi_long arg5)
3840
{
3841
    return print_mmap_both(cpu_env, name, arg0, arg1, arg2, arg3,
3842
                           arg4, arg5, false);
3843
}
3844
#endif
3845

3846
#ifdef TARGET_NR_mprotect
3847
static void
3848
print_mprotect(CPUArchState *cpu_env, const struct syscallname *name,
3849
               abi_long arg0, abi_long arg1, abi_long arg2,
3850
               abi_long arg3, abi_long arg4, abi_long arg5)
3851
{
3852
    print_syscall_prologue(name);
3853
    print_pointer(arg0, 0);
3854
    print_raw_param("%d", arg1, 0);
3855
    print_flags(mmap_prot_flags, arg2, 1);
3856
    print_syscall_epilogue(name);
3857
}
3858
#endif
3859

3860
#ifdef TARGET_NR_munmap
3861
static void
3862
print_munmap(CPUArchState *cpu_env, const struct syscallname *name,
3863
             abi_long arg0, abi_long arg1, abi_long arg2,
3864
             abi_long arg3, abi_long arg4, abi_long arg5)
3865
{
3866
    print_syscall_prologue(name);
3867
    print_pointer(arg0, 0);
3868
    print_raw_param("%d", arg1, 1);
3869
    print_syscall_epilogue(name);
3870
}
3871
#endif
3872

3873
#ifdef TARGET_NR_futex
3874
static void print_futex_op(int cmd, int last)
3875
{
3876
    static const char * const futex_names[] = {
3877
#define NAME(X)  [X] = #X
3878
        NAME(FUTEX_WAIT),
3879
        NAME(FUTEX_WAKE),
3880
        NAME(FUTEX_FD),
3881
        NAME(FUTEX_REQUEUE),
3882
        NAME(FUTEX_CMP_REQUEUE),
3883
        NAME(FUTEX_WAKE_OP),
3884
        NAME(FUTEX_LOCK_PI),
3885
        NAME(FUTEX_UNLOCK_PI),
3886
        NAME(FUTEX_TRYLOCK_PI),
3887
        NAME(FUTEX_WAIT_BITSET),
3888
        NAME(FUTEX_WAKE_BITSET),
3889
        NAME(FUTEX_WAIT_REQUEUE_PI),
3890
        NAME(FUTEX_CMP_REQUEUE_PI),
3891
        NAME(FUTEX_LOCK_PI2),
3892
#undef NAME
3893
    };
3894

3895
    unsigned base_cmd = cmd & FUTEX_CMD_MASK;
3896

3897
    if (base_cmd < ARRAY_SIZE(futex_names)) {
3898
        qemu_log("%s%s%s",
3899
                 (cmd & FUTEX_PRIVATE_FLAG ? "FUTEX_PRIVATE_FLAG|" : ""),
3900
                 (cmd & FUTEX_CLOCK_REALTIME ? "FUTEX_CLOCK_REALTIME|" : ""),
3901
                 futex_names[base_cmd]);
3902
    } else {
3903
        qemu_log("0x%x", cmd);
3904
    }
3905
}
3906

3907
static void
3908
print_futex(CPUArchState *cpu_env, const struct syscallname *name,
3909
            abi_long arg0, abi_long arg1, abi_long arg2,
3910
            abi_long arg3, abi_long arg4, abi_long arg5)
3911
{
3912
    abi_long op = arg1 & FUTEX_CMD_MASK;
3913
    print_syscall_prologue(name);
3914
    print_pointer(arg0, 0);
3915
    print_futex_op(arg1, 0);
3916
    print_raw_param(",%d", arg2, 0);
3917
    switch (op) {
3918
        case FUTEX_WAIT:
3919
        case FUTEX_WAIT_BITSET:
3920
        case FUTEX_LOCK_PI:
3921
        case FUTEX_LOCK_PI2:
3922
        case FUTEX_WAIT_REQUEUE_PI:
3923
            print_timespec(arg3, 0);
3924
            break;
3925
        default:
3926
            print_pointer(arg3, 0);
3927
            break;
3928
    }
3929
    print_pointer(arg4, 0);
3930
    print_raw_param("%d", arg4, 1);
3931
    print_syscall_epilogue(name);
3932
}
3933
#endif
3934

3935
#ifdef TARGET_NR_prlimit64
3936
static const char *target_ressource_string(abi_ulong r)
3937
{
3938
    #define RET_RES_ENTRY(res) case TARGET_##res:  return #res;
3939
    switch (r) {
3940
    RET_RES_ENTRY(RLIMIT_AS);
3941
    RET_RES_ENTRY(RLIMIT_CORE);
3942
    RET_RES_ENTRY(RLIMIT_CPU);
3943
    RET_RES_ENTRY(RLIMIT_DATA);
3944
    RET_RES_ENTRY(RLIMIT_FSIZE);
3945
    RET_RES_ENTRY(RLIMIT_LOCKS);
3946
    RET_RES_ENTRY(RLIMIT_MEMLOCK);
3947
    RET_RES_ENTRY(RLIMIT_MSGQUEUE);
3948
    RET_RES_ENTRY(RLIMIT_NICE);
3949
    RET_RES_ENTRY(RLIMIT_NOFILE);
3950
    RET_RES_ENTRY(RLIMIT_NPROC);
3951
    RET_RES_ENTRY(RLIMIT_RSS);
3952
    RET_RES_ENTRY(RLIMIT_RTPRIO);
3953
#ifdef RLIMIT_RTTIME
3954
    RET_RES_ENTRY(RLIMIT_RTTIME);
3955
#endif
3956
    RET_RES_ENTRY(RLIMIT_SIGPENDING);
3957
    RET_RES_ENTRY(RLIMIT_STACK);
3958
    default:
3959
        return NULL;
3960
    }
3961
    #undef RET_RES_ENTRY
3962
}
3963

3964
static void
3965
print_rlimit64(abi_ulong rlim_addr, int last)
3966
{
3967
    if (rlim_addr) {
3968
        struct target_rlimit64 *rl;
3969

3970
        rl = lock_user(VERIFY_READ, rlim_addr, sizeof(*rl), 1);
3971
        if (!rl) {
3972
            print_pointer(rlim_addr, last);
3973
            return;
3974
        }
3975
        print_raw_param64("{rlim_cur=%" PRId64, tswap64(rl->rlim_cur), 0);
3976
        print_raw_param64("rlim_max=%" PRId64 "}", tswap64(rl->rlim_max),
3977
                            last);
3978
        unlock_user(rl, rlim_addr, 0);
3979
    } else {
3980
        qemu_log("NULL%s", get_comma(last));
3981
    }
3982
}
3983

3984
static void
3985
print_prlimit64(CPUArchState *cpu_env, const struct syscallname *name,
3986
           abi_long arg0, abi_long arg1, abi_long arg2,
3987
           abi_long arg3, abi_long arg4, abi_long arg5)
3988
{
3989
    const char *rlim_name;
3990

3991
    print_syscall_prologue(name);
3992
    print_raw_param("%d", arg0, 0);
3993
    rlim_name = target_ressource_string(arg1);
3994
    if (rlim_name) {
3995
        qemu_log("%s,", rlim_name);
3996
    } else {
3997
        print_raw_param("%d", arg1, 0);
3998
    }
3999
    print_rlimit64(arg2, 0);
4000
    print_pointer(arg3, 1);
4001
    print_syscall_epilogue(name);
4002
}
4003

4004
static void
4005
print_syscall_ret_prlimit64(CPUArchState *cpu_env,
4006
                       const struct syscallname *name,
4007
                       abi_long ret, abi_long arg0, abi_long arg1,
4008
                       abi_long arg2, abi_long arg3, abi_long arg4,
4009
                       abi_long arg5)
4010
{
4011
    if (!print_syscall_err(ret)) {
4012
        qemu_log(TARGET_ABI_FMT_ld, ret);
4013
        if (arg3) {
4014
            qemu_log(" (");
4015
            print_rlimit64(arg3, 1);
4016
            qemu_log(")");
4017
        }
4018
    }
4019
    qemu_log("\n");
4020
}
4021
#endif
4022

4023
#ifdef TARGET_NR_kill
4024
static void
4025
print_kill(CPUArchState *cpu_env, const struct syscallname *name,
4026
           abi_long arg0, abi_long arg1, abi_long arg2,
4027
           abi_long arg3, abi_long arg4, abi_long arg5)
4028
{
4029
    print_syscall_prologue(name);
4030
    print_raw_param("%d", arg0, 0);
4031
    print_signal(arg1, 1);
4032
    print_syscall_epilogue(name);
4033
}
4034
#endif
4035

4036
#ifdef TARGET_NR_tkill
4037
static void
4038
print_tkill(CPUArchState *cpu_env, const struct syscallname *name,
4039
            abi_long arg0, abi_long arg1, abi_long arg2,
4040
            abi_long arg3, abi_long arg4, abi_long arg5)
4041
{
4042
    print_syscall_prologue(name);
4043
    print_raw_param("%d", arg0, 0);
4044
    print_signal(arg1, 1);
4045
    print_syscall_epilogue(name);
4046
}
4047
#endif
4048

4049
#ifdef TARGET_NR_tgkill
4050
static void
4051
print_tgkill(CPUArchState *cpu_env, const struct syscallname *name,
4052
             abi_long arg0, abi_long arg1, abi_long arg2,
4053
             abi_long arg3, abi_long arg4, abi_long arg5)
4054
{
4055
    print_syscall_prologue(name);
4056
    print_raw_param("%d", arg0, 0);
4057
    print_raw_param("%d", arg1, 0);
4058
    print_signal(arg2, 1);
4059
    print_syscall_epilogue(name);
4060
}
4061
#endif
4062

4063
#if defined(TARGET_NR_pread64) || defined(TARGET_NR_pwrite64)
4064
static void
4065
print_pread64(CPUArchState *cpu_env, const struct syscallname *name,
4066
        abi_long arg0, abi_long arg1, abi_long arg2,
4067
        abi_long arg3, abi_long arg4, abi_long arg5)
4068
{
4069
    if (regpairs_aligned(cpu_env, TARGET_NR_pread64)) {
4070
        arg3 = arg4;
4071
        arg4 = arg5;
4072
    }
4073
    print_syscall_prologue(name);
4074
    print_raw_param("%d", arg0, 0);
4075
    print_pointer(arg1, 0);
4076
    print_raw_param("%d", arg2, 0);
4077
    print_raw_param("%" PRIu64, target_offset64(arg3, arg4), 1);
4078
    print_syscall_epilogue(name);
4079
}
4080
#endif
4081

4082
#ifdef TARGET_NR_statx
4083
static void
4084
print_statx(CPUArchState *cpu_env, const struct syscallname *name,
4085
            abi_long arg0, abi_long arg1, abi_long arg2,
4086
            abi_long arg3, abi_long arg4, abi_long arg5)
4087
{
4088
    print_syscall_prologue(name);
4089
    print_at_dirfd(arg0, 0);
4090
    print_string(arg1, 0);
4091
    print_flags(statx_flags, arg2, 0);
4092
    print_flags(statx_mask, arg3, 0);
4093
    print_pointer(arg4, 1);
4094
    print_syscall_epilogue(name);
4095
}
4096
#endif
4097

4098
#ifdef TARGET_NR_ioctl
4099
static void
4100
print_ioctl(CPUArchState *cpu_env, const struct syscallname *name,
4101
            abi_long arg0, abi_long arg1, abi_long arg2,
4102
            abi_long arg3, abi_long arg4, abi_long arg5)
4103
{
4104
    print_syscall_prologue(name);
4105
    print_raw_param("%d", arg0, 0);
4106

4107
    const IOCTLEntry *ie;
4108
    const argtype *arg_type;
4109
    void *argptr;
4110
    int target_size;
4111

4112
    for (ie = ioctl_entries; ie->target_cmd != 0; ie++) {
4113
        if (ie->target_cmd == arg1) {
4114
            break;
4115
        }
4116
    }
4117

4118
    if (ie->target_cmd == 0) {
4119
        print_raw_param("%#x", arg1, 0);
4120
        print_raw_param("%#x", arg2, 1);
4121
    } else {
4122
        qemu_log("%s", ie->name);
4123
        arg_type = ie->arg_type;
4124

4125
        if (arg_type[0] != TYPE_NULL) {
4126
            qemu_log(",");
4127

4128
            switch (arg_type[0]) {
4129
            case TYPE_PTRVOID:
4130
                print_pointer(arg2, 1);
4131
                break;
4132
            case TYPE_CHAR:
4133
            case TYPE_SHORT:
4134
            case TYPE_INT:
4135
                print_raw_param("%d", arg2, 1);
4136
                break;
4137
            case TYPE_LONG:
4138
                print_raw_param(TARGET_ABI_FMT_ld, arg2, 1);
4139
                break;
4140
            case TYPE_ULONG:
4141
                print_raw_param(TARGET_ABI_FMT_lu, arg2, 1);
4142
                break;
4143
            case TYPE_PTR:
4144
                switch (ie->access) {
4145
                case IOC_R:
4146
                    print_pointer(arg2, 1);
4147
                    break;
4148
                case IOC_W:
4149
                case IOC_RW:
4150
                    arg_type++;
4151
                    target_size = thunk_type_size(arg_type, 0);
4152
                    argptr = lock_user(VERIFY_READ, arg2, target_size, 1);
4153
                    if (argptr) {
4154
                        thunk_print(argptr, arg_type);
4155
                        unlock_user(argptr, arg2, target_size);
4156
                    } else {
4157
                        print_pointer(arg2, 1);
4158
                    }
4159
                    break;
4160
                }
4161
                break;
4162
            default:
4163
                g_assert_not_reached();
4164
            }
4165
        }
4166
    }
4167
    print_syscall_epilogue(name);
4168
}
4169
#endif
4170

4171
/*
4172
 * An array of all of the syscalls we know about
4173
 */
4174

4175
static const struct syscallname scnames[] = {
4176
#include "strace.list"
4177
};
4178

4179
static int nsyscalls = ARRAY_SIZE(scnames);
4180

4181
/*
4182
 * The public interface to this module.
4183
 */
4184
void
4185
print_syscall(CPUArchState *cpu_env, int num,
4186
              abi_long arg1, abi_long arg2, abi_long arg3,
4187
              abi_long arg4, abi_long arg5, abi_long arg6)
4188
{
4189
    int i;
4190
    FILE *f;
4191
    const char *format = "%s(" TARGET_ABI_FMT_ld "," TARGET_ABI_FMT_ld ","
4192
                               TARGET_ABI_FMT_ld "," TARGET_ABI_FMT_ld ","
4193
                               TARGET_ABI_FMT_ld "," TARGET_ABI_FMT_ld ")";
4194

4195
    f = qemu_log_trylock();
4196
    if (!f) {
4197
        return;
4198
    }
4199
    fprintf(f, "%d ", getpid());
4200

4201
    for (i = 0; i < nsyscalls; i++) {
4202
        if (scnames[i].nr == num) {
4203
            if (scnames[i].call != NULL) {
4204
                scnames[i].call(cpu_env, &scnames[i], arg1, arg2, arg3,
4205
                                arg4, arg5, arg6);
4206
            } else {
4207
                /* XXX: this format system is broken because it uses
4208
                   host types and host pointers for strings */
4209
                if (scnames[i].format != NULL) {
4210
                    format = scnames[i].format;
4211
                }
4212
                fprintf(f, format, scnames[i].name, arg1, arg2,
4213
                        arg3, arg4, arg5, arg6);
4214
            }
4215
            qemu_log_unlock(f);
4216
            return;
4217
        }
4218
    }
4219
    fprintf(f, "Unknown syscall %d\n", num);
4220
    qemu_log_unlock(f);
4221
}
4222

4223

4224
void
4225
print_syscall_ret(CPUArchState *cpu_env, int num, abi_long ret,
4226
                  abi_long arg1, abi_long arg2, abi_long arg3,
4227
                  abi_long arg4, abi_long arg5, abi_long arg6)
4228
{
4229
    int i;
4230
    FILE *f;
4231

4232
    f = qemu_log_trylock();
4233
    if (!f) {
4234
        return;
4235
    }
4236

4237
    for (i = 0; i < nsyscalls; i++) {
4238
        if (scnames[i].nr == num) {
4239
            if (scnames[i].result != NULL) {
4240
                scnames[i].result(cpu_env, &scnames[i], ret,
4241
                                  arg1, arg2, arg3,
4242
                                  arg4, arg5, arg6);
4243
            } else {
4244
                if (!print_syscall_err(ret)) {
4245
                    fprintf(f, TARGET_ABI_FMT_ld, ret);
4246
                }
4247
                fprintf(f, "\n");
4248
            }
4249
            break;
4250
        }
4251
    }
4252
    qemu_log_unlock(f);
4253
}
4254

4255
void print_taken_signal(int target_signum, const target_siginfo_t *tinfo)
4256
{
4257
    /* Print the strace output for a signal being taken:
4258
     * --- SIGSEGV {si_signo=SIGSEGV, si_code=SI_KERNEL, si_addr=0} ---
4259
     */
4260
    FILE *f;
4261

4262
    f = qemu_log_trylock();
4263
    if (!f) {
4264
        return;
4265
    }
4266

4267
    fprintf(f, "--- ");
4268
    print_signal(target_signum, 1);
4269
    fprintf(f, " ");
4270
    print_siginfo(tinfo);
4271
    fprintf(f, " ---\n");
4272
    qemu_log_unlock(f);
4273
}
4274