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