?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
hw: xhci: check return value of 'usb_packet_map'
[qemu/ar7.git] / linux-user / strace.c
blob4f77b0cf76eb7893d9cc61c36f30098b5c9c1a95
1 #include "qemu/osdep.h"
2 #include <sys/ipc.h>
3 #include <sys/msg.h>
4 #include <sys/sem.h>
5 #include <sys/shm.h>
6 #include <sys/select.h>
7 #include <sys/mount.h>
8 #include <arpa/inet.h>
9 #include <netinet/tcp.h>
10 #include <linux/if_packet.h>
11 #include <linux/netlink.h>
12 #include <sched.h>
13 #include "qemu.h"
14
15 struct syscallname {
16 int nr;
17 const char *name;
18 const char *format;
19 void (*call)(void *, const struct syscallname *,
20 abi_long, abi_long, abi_long,
21 abi_long, abi_long, abi_long);
22 void (*result)(void *, const struct syscallname *, abi_long,
23 abi_long, abi_long, abi_long,
24 abi_long, abi_long, abi_long);
25 };
26
27 #ifdef __GNUC__
28 /*
29 * It is possible that target doesn't have syscall that uses
30 * following flags but we don't want the compiler to warn
31 * us about them being unused. Same applies to utility print
32 * functions. It is ok to keep them while not used.
33 */
34 #define UNUSED __attribute__ ((unused))
35 #else
36 #define UNUSED
37 #endif
38
39 /*
40 * Structure used to translate flag values into strings. This is
41 * similar that is in the actual strace tool.
42 */
43 struct flags {
44 abi_long f_value; /* flag */
45 const char *f_string; /* stringified flag */
46 };
47
48 /* common flags for all architectures */
49 #define FLAG_GENERIC(name) { name, #name }
50 /* target specific flags (syscall_defs.h has TARGET_<flag>) */
51 #define FLAG_TARGET(name) { TARGET_ ## name, #name }
52 /* end of flags array */
53 #define FLAG_END { 0, NULL }
54
55 /* Structure used to translate enumerated values into strings */
56 struct 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
68 UNUSED static const char *get_comma(int);
69 UNUSED static void print_pointer(abi_long, int);
70 UNUSED static void print_flags(const struct flags *, abi_long, int);
71 UNUSED static void print_enums(const struct enums *, abi_long, int);
72 UNUSED static void print_at_dirfd(abi_long, int);
73 UNUSED static void print_file_mode(abi_long, int);
74 UNUSED static void print_open_flags(abi_long, int);
75 UNUSED static void print_syscall_prologue(const struct syscallname *);
76 UNUSED static void print_syscall_epilogue(const struct syscallname *);
77 UNUSED static void print_string(abi_long, int);
78 UNUSED static void print_buf(abi_long addr, abi_long len, int last);
79 UNUSED static void print_raw_param(const char *, abi_long, int);
80 UNUSED static void print_timeval(abi_ulong, int);
81 UNUSED static void print_timespec(abi_ulong, int);
82 UNUSED static void print_timezone(abi_ulong, int);
83 UNUSED static void print_itimerval(abi_ulong, int);
84 UNUSED static void print_number(abi_long, int);
85 UNUSED static void print_signal(abi_ulong, int);
86 UNUSED static void print_sockaddr(abi_ulong, abi_long, int);
87 UNUSED static void print_socket_domain(int domain);
88 UNUSED static void print_socket_type(int type);
89 UNUSED static void print_socket_protocol(int domain, int type, int protocol);
90
91 /*
92 * Utility functions
93 */
94 static void
95 print_ipc_cmd(int cmd)
96 {
97 #define output_cmd(val) \
98 if( cmd == val ) { \
99 qemu_log(#val); \
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 */
111 output_cmd( MSG_STAT );
112 output_cmd( MSG_INFO );
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 */
139 qemu_log("%d", cmd);
140 }
141
142 static void
143 print_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) {
167 print_raw_param("%ld", arg, last);
168 return;
169 }
170 qemu_log("%s%s", signal_name, get_comma(last));
171 }
172
173 static 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:
203 qemu_log("%d", arg);
204 return;
205 }
206 qemu_log("%s", codename);
207 }
208
209 static 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
296 static 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
307 qemu_log("{si_signo=");
308 print_signal(tinfo->si_signo, 1);
309 qemu_log(", si_code=");
310 print_si_code(si_code);
311
312 switch (si_type) {
313 case QEMU_SI_KILL:
314 qemu_log(", si_pid=%u, si_uid=%u",
315 (unsigned int)tinfo->_sifields._kill._pid,
316 (unsigned int)tinfo->_sifields._kill._uid);
317 break;
318 case QEMU_SI_TIMER:
319 qemu_log(", si_timer1=%u, si_timer2=%u",
320 tinfo->_sifields._timer._timer1,
321 tinfo->_sifields._timer._timer2);
322 break;
323 case QEMU_SI_POLL:
324 qemu_log(", si_band=%d, si_fd=%d",
325 tinfo->_sifields._sigpoll._band,
326 tinfo->_sifields._sigpoll._fd);
327 break;
328 case QEMU_SI_FAULT:
329 qemu_log(", si_addr=");
330 print_pointer(tinfo->_sifields._sigfault._addr, 1);
331 break;
332 case QEMU_SI_CHLD:
333 qemu_log(", si_pid=%u, si_uid=%u, si_status=%d"
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:
343 qemu_log(", si_pid=%u, si_uid=%u, si_sigval=" TARGET_ABI_FMT_ld,
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 }
351 qemu_log("}");
352 }
353
354 static void
355 print_sockaddr(abi_ulong addr, abi_long addrlen, int last)
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;
368 qemu_log("{sun_family=AF_UNIX,sun_path=\"");
369 for (i = 0; i < addrlen -
370 offsetof(struct target_sockaddr_un, sun_path) &&
371 un->sun_path[i]; i++) {
372 qemu_log("%c", un->sun_path[i]);
373 }
374 qemu_log("\"}");
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;
380 qemu_log("{sin_family=AF_INET,sin_port=htons(%d),",
381 ntohs(in->sin_port));
382 qemu_log("sin_addr=inet_addr(\"%d.%d.%d.%d\")",
383 c[0], c[1], c[2], c[3]);
384 qemu_log("}");
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;
390 qemu_log("{sll_family=AF_PACKET,"
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:
395 qemu_log("PACKET_HOST");
396 break;
397 case PACKET_BROADCAST:
398 qemu_log("PACKET_BROADCAST");
399 break;
400 case PACKET_MULTICAST:
401 qemu_log("PACKET_MULTICAST");
402 break;
403 case PACKET_OTHERHOST:
404 qemu_log("PACKET_OTHERHOST");
405 break;
406 case PACKET_OUTGOING:
407 qemu_log("PACKET_OUTGOING");
408 break;
409 default:
410 qemu_log("%d", ll->sll_pkttype);
411 break;
412 }
413 qemu_log(",sll_addr=%02x:%02x:%02x:%02x:%02x:%02x:%02x:%02x",
414 c[0], c[1], c[2], c[3], c[4], c[5], c[6], c[7]);
415 qemu_log("}");
416 break;
417 }
418 case AF_NETLINK: {
419 struct target_sockaddr_nl *nl = (struct target_sockaddr_nl *)sa;
420 qemu_log("{nl_family=AF_NETLINK,nl_pid=%u,nl_groups=%u}",
421 tswap32(nl->nl_pid), tswap32(nl->nl_groups));
422 break;
423 }
424 default:
425 qemu_log("{sa_family=%d, sa_data={", sa->sa_family);
426 for (i = 0; i < 13; i++) {
427 qemu_log("%02x, ", sa->sa_data[i]);
428 }
429 qemu_log("%02x}", sa->sa_data[i]);
430 qemu_log("}");
431 break;
432 }
433 unlock_user(sa, addr, 0);
434 } else {
435 print_raw_param("0x"TARGET_ABI_FMT_lx, addr, 0);
436 }
437 qemu_log(", "TARGET_ABI_FMT_ld"%s", addrlen, get_comma(last));
438 }
439
440 static void
441 print_socket_domain(int domain)
442 {
443 switch (domain) {
444 case PF_UNIX:
445 qemu_log("PF_UNIX");
446 break;
447 case PF_INET:
448 qemu_log("PF_INET");
449 break;
450 case PF_NETLINK:
451 qemu_log("PF_NETLINK");
452 break;
453 case PF_PACKET:
454 qemu_log("PF_PACKET");
455 break;
456 default:
457 qemu_log("%d", domain);
458 break;
459 }
460 }
461
462 static void
463 print_socket_type(int type)
464 {
465 switch (type & TARGET_SOCK_TYPE_MASK) {
466 case TARGET_SOCK_DGRAM:
467 qemu_log("SOCK_DGRAM");
468 break;
469 case TARGET_SOCK_STREAM:
470 qemu_log("SOCK_STREAM");
471 break;
472 case TARGET_SOCK_RAW:
473 qemu_log("SOCK_RAW");
474 break;
475 case TARGET_SOCK_RDM:
476 qemu_log("SOCK_RDM");
477 break;
478 case TARGET_SOCK_SEQPACKET:
479 qemu_log("SOCK_SEQPACKET");
480 break;
481 case TARGET_SOCK_PACKET:
482 qemu_log("SOCK_PACKET");
483 break;
484 }
485 if (type & TARGET_SOCK_CLOEXEC) {
486 qemu_log("|SOCK_CLOEXEC");
487 }
488 if (type & TARGET_SOCK_NONBLOCK) {
489 qemu_log("|SOCK_NONBLOCK");
490 }
491 }
492
493 static void
494 print_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:
500 qemu_log("ETH_P_ALL");
501 break;
502 default:
503 qemu_log("%d", protocol);
504 }
505 return;
506 }
507
508 if (domain == PF_NETLINK) {
509 switch (protocol) {
510 case NETLINK_ROUTE:
511 qemu_log("NETLINK_ROUTE");
512 break;
513 case NETLINK_AUDIT:
514 qemu_log("NETLINK_AUDIT");
515 break;
516 case NETLINK_NETFILTER:
517 qemu_log("NETLINK_NETFILTER");
518 break;
519 case NETLINK_KOBJECT_UEVENT:
520 qemu_log("NETLINK_KOBJECT_UEVENT");
521 break;
522 case NETLINK_RDMA:
523 qemu_log("NETLINK_RDMA");
524 break;
525 case NETLINK_CRYPTO:
526 qemu_log("NETLINK_CRYPTO");
527 break;
528 default:
529 qemu_log("%d", protocol);
530 break;
531 }
532 return;
533 }
534
535 switch (protocol) {
536 case IPPROTO_IP:
537 qemu_log("IPPROTO_IP");
538 break;
539 case IPPROTO_TCP:
540 qemu_log("IPPROTO_TCP");
541 break;
542 case IPPROTO_UDP:
543 qemu_log("IPPROTO_UDP");
544 break;
545 case IPPROTO_RAW:
546 qemu_log("IPPROTO_RAW");
547 break;
548 default:
549 qemu_log("%d", protocol);
550 break;
551 }
552 }
553
554
555 #ifdef TARGET_NR__newselect
556 static void
557 print_fdset(int n, abi_ulong target_fds_addr)
558 {
559 int i;
560 int first = 1;
561
562 qemu_log("[");
563 if( target_fds_addr ) {
564 abi_long *target_fds;
565
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)
572 return;
573
574 for (i=n; i>=0; i--) {
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;
579 }
580 }
581 unlock_user(target_fds, target_fds_addr, 0);
582 }
583 qemu_log("]");
584 }
585 #endif
586
587 /*
588 * Sysycall specific output functions
589 */
590
591 /* select */
592 #ifdef TARGET_NR__newselect
593 static void
594 print_newselect(void *cpu_env, const struct syscallname *name,
595 abi_long arg1, abi_long arg2, abi_long arg3,
596 abi_long arg4, abi_long arg5, abi_long arg6)
597 {
598 print_syscall_prologue(name);
599 print_fdset(arg1, arg2);
600 qemu_log(",");
601 print_fdset(arg1, arg3);
602 qemu_log(",");
603 print_fdset(arg1, arg4);
604 qemu_log(",");
605 print_timeval(arg5, 1);
606 print_syscall_epilogue(name);
607 }
608 #endif
609
610 #ifdef TARGET_NR_semctl
611 static void
612 print_semctl(void *cpu_env, const struct syscallname *name,
613 abi_long arg1, abi_long arg2, abi_long arg3,
614 abi_long arg4, abi_long arg5, abi_long arg6)
615 {
616 qemu_log("%s(" TARGET_ABI_FMT_ld "," TARGET_ABI_FMT_ld ",",
617 name->name, arg1, arg2);
618 print_ipc_cmd(arg3);
619 qemu_log(",0x" TARGET_ABI_FMT_lx ")", arg4);
620 }
621 #endif
622
623 static void
624 print_execve(void *cpu_env, const struct syscallname *name,
625 abi_long arg1, abi_long arg2, abi_long arg3,
626 abi_long arg4, abi_long arg5, abi_long arg6)
627 {
628 abi_ulong arg_ptr_addr;
629 char *s;
630
631 if (!(s = lock_user_string(arg1)))
632 return;
633 qemu_log("%s(\"%s\",{", name->name, s);
634 unlock_user(s, arg1, 0);
635
636 for (arg_ptr_addr = arg2; ; arg_ptr_addr += sizeof(abi_ulong)) {
637 abi_ulong *arg_ptr, arg_addr;
638
639 arg_ptr = lock_user(VERIFY_READ, arg_ptr_addr, sizeof(abi_ulong), 1);
640 if (!arg_ptr)
641 return;
642 arg_addr = tswapal(*arg_ptr);
643 unlock_user(arg_ptr, arg_ptr_addr, 0);
644 if (!arg_addr)
645 break;
646 if ((s = lock_user_string(arg_addr))) {
647 qemu_log("\"%s\",", s);
648 unlock_user(s, arg_addr, 0);
649 }
650 }
651
652 qemu_log("NULL})");
653 }
654
655 #ifdef TARGET_NR_ipc
656 static void
657 print_ipc(void *cpu_env, const struct syscallname *name,
658 abi_long arg1, abi_long arg2, abi_long arg3,
659 abi_long arg4, abi_long arg5, abi_long arg6)
660 {
661 switch(arg1) {
662 case IPCOP_semctl:
663 qemu_log("semctl(" TARGET_ABI_FMT_ld "," TARGET_ABI_FMT_ld ",",
664 arg1, arg2);
665 print_ipc_cmd(arg3);
666 qemu_log(",0x" TARGET_ABI_FMT_lx ")", arg4);
667 break;
668 default:
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 ")"),
675 name->name, arg1, arg2, arg3, arg4);
676 }
677 }
678 #endif
679
680 /*
681 * Variants for the return value output function
682 */
683
684 static bool
685 print_syscall_err(abi_long ret)
686 {
687 const char *errstr;
688
689 qemu_log(" = ");
690 if (ret < 0) {
691 errstr = target_strerror(-ret);
692 if (errstr) {
693 qemu_log("-1 errno=%d (%s)", (int)-ret, errstr);
694 return true;
695 }
696 }
697 return false;
698 }
699
700 static void
701 print_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)
705 {
706 if (!print_syscall_err(ret)) {
707 qemu_log("0x" TARGET_ABI_FMT_lx, ret);
708 }
709 qemu_log("\n");
710 }
711
712 #if 0 /* currently unused */
713 static void
714 print_syscall_ret_raw(struct syscallname *name, abi_long ret)
715 {
716 qemu_log(" = 0x" TARGET_ABI_FMT_lx "\n", ret);
717 }
718 #endif
719
720 #ifdef TARGET_NR__newselect
721 static void
722 print_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)
726 {
727 if (!print_syscall_err(ret)) {
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");
740 }
741 #endif
742
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 */
750 #ifdef TARGET_NR_adjtimex
751 static void
752 print_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)
756 {
757 if (!print_syscall_err(ret)) {
758 qemu_log(TARGET_ABI_FMT_ld, ret);
759 switch (ret) {
760 case TARGET_TIME_OK:
761 qemu_log(" TIME_OK (clock synchronized, no leap second)");
762 break;
763 case TARGET_TIME_INS:
764 qemu_log(" TIME_INS (insert leap second)");
765 break;
766 case TARGET_TIME_DEL:
767 qemu_log(" TIME_DEL (delete leap second)");
768 break;
769 case TARGET_TIME_OOP:
770 qemu_log(" TIME_OOP (leap second in progress)");
771 break;
772 case TARGET_TIME_WAIT:
773 qemu_log(" TIME_WAIT (leap second has occurred)");
774 break;
775 case TARGET_TIME_ERROR:
776 qemu_log(" TIME_ERROR (clock not synchronized)");
777 break;
778 }
779 }
780
781 qemu_log("\n");
782 }
783 #endif
784
785 #if defined(TARGET_NR_clock_gettime) || defined(TARGET_NR_clock_getres)
786 static void
787 print_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
805 static void
806 print_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
824 static void
825 print_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
843 static void
844 print_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
860 #if defined(TARGET_NR_listxattr) || defined(TARGET_NR_llistxattr) \
861 || defined(TARGGET_NR_flistxattr)
862 static void
863 print_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)
867 {
868 if (!print_syscall_err(ret)) {
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
893 #ifdef TARGET_NR_ioctl
894 static void
895 print_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)
899 {
900 if (!print_syscall_err(ret)) {
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);
921 if (argptr) {
922 thunk_print(argptr, arg_type);
923 unlock_user(argptr, arg2, target_size);
924 } else {
925 print_pointer(arg2, 1);
926 }
927 qemu_log(")");
928 }
929 }
930 qemu_log("\n");
931 }
932 #endif
933
934 UNUSED 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
942 UNUSED 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
952 UNUSED static struct flags unlinkat_flags[] = {
953 #ifdef AT_REMOVEDIR
954 FLAG_GENERIC(AT_REMOVEDIR),
955 #endif
956 FLAG_END,
957 };
958
959 UNUSED 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
970 UNUSED 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
977 UNUSED 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 */
986 FLAG_TARGET(O_DSYNC),
987 FLAG_TARGET(__O_SYNC),
988 FLAG_TARGET(O_TRUNC),
989 #ifdef O_DIRECT
990 FLAG_TARGET(O_DIRECT),
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),
1000 #endif
1001 #ifdef O_TMPFILE
1002 FLAG_TARGET(O_TMPFILE),
1003 FLAG_TARGET(__O_TMPFILE),
1004 #endif
1005 FLAG_END,
1006 };
1007
1008 UNUSED 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
1033 UNUSED 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
1046 UNUSED 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),
1051 FLAG_TARGET(PROT_SEM),
1052 FLAG_GENERIC(PROT_GROWSDOWN),
1053 FLAG_GENERIC(PROT_GROWSUP),
1054 FLAG_END,
1055 };
1056
1057 UNUSED 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),
1064 FLAG_TARGET(MAP_EXECUTABLE),
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),
1074 #endif
1075 #ifdef TARGET_MAP_UNINITIALIZED
1076 FLAG_TARGET(MAP_UNINITIALIZED),
1077 #endif
1078 FLAG_END,
1079 };
1080
1081 UNUSED 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),
1098 #if defined(CLONE_NEWUTS)
1099 FLAG_GENERIC(CLONE_NEWUTS),
1100 #endif
1101 #if defined(CLONE_NEWIPC)
1102 FLAG_GENERIC(CLONE_NEWIPC),
1103 #endif
1104 #if defined(CLONE_NEWUSER)
1105 FLAG_GENERIC(CLONE_NEWUSER),
1106 #endif
1107 #if defined(CLONE_NEWPID)
1108 FLAG_GENERIC(CLONE_NEWPID),
1109 #endif
1110 #if defined(CLONE_NEWNET)
1111 FLAG_GENERIC(CLONE_NEWNET),
1112 #endif
1113 #if defined(CLONE_IO)
1114 FLAG_GENERIC(CLONE_IO),
1115 #endif
1116 FLAG_END,
1117 };
1118
1119 UNUSED 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
1139 UNUSED 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
1161 UNUSED 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
1209 UNUSED 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
1229 UNUSED static struct flags termios_iflags[] = {
1230 FLAG_TARGET(IGNBRK),
1231 FLAG_TARGET(BRKINT),
1232 FLAG_TARGET(IGNPAR),
1233 FLAG_TARGET(PARMRK),
1234 FLAG_TARGET(INPCK),
1235 FLAG_TARGET(ISTRIP),
1236 FLAG_TARGET(INLCR),
1237 FLAG_TARGET(IGNCR),
1238 FLAG_TARGET(ICRNL),
1239 FLAG_TARGET(IUCLC),
1240 FLAG_TARGET(IXON),
1241 FLAG_TARGET(IXANY),
1242 FLAG_TARGET(IXOFF),
1243 FLAG_TARGET(IMAXBEL),
1244 FLAG_TARGET(IUTF8),
1245 FLAG_END,
1246 };
1247
1248 UNUSED static struct flags termios_oflags[] = {
1249 FLAG_TARGET(OPOST),
1250 FLAG_TARGET(OLCUC),
1251 FLAG_TARGET(ONLCR),
1252 FLAG_TARGET(OCRNL),
1253 FLAG_TARGET(ONOCR),
1254 FLAG_TARGET(ONLRET),
1255 FLAG_TARGET(OFILL),
1256 FLAG_TARGET(OFDEL),
1257 FLAG_END,
1258 };
1259
1260 UNUSED static struct enums termios_oflags_NLDLY[] = {
1261 ENUM_TARGET(NL0),
1262 ENUM_TARGET(NL1),
1263 ENUM_END,
1264 };
1265
1266 UNUSED static struct enums termios_oflags_CRDLY[] = {
1267 ENUM_TARGET(CR0),
1268 ENUM_TARGET(CR1),
1269 ENUM_TARGET(CR2),
1270 ENUM_TARGET(CR3),
1271 ENUM_END,
1272 };
1273
1274 UNUSED static struct enums termios_oflags_TABDLY[] = {
1275 ENUM_TARGET(TAB0),
1276 ENUM_TARGET(TAB1),
1277 ENUM_TARGET(TAB2),
1278 ENUM_TARGET(TAB3),
1279 ENUM_END,
1280 };
1281
1282 UNUSED static struct enums termios_oflags_VTDLY[] = {
1283 ENUM_TARGET(VT0),
1284 ENUM_TARGET(VT1),
1285 ENUM_END,
1286 };
1287
1288 UNUSED static struct enums termios_oflags_FFDLY[] = {
1289 ENUM_TARGET(FF0),
1290 ENUM_TARGET(FF1),
1291 ENUM_END,
1292 };
1293
1294 UNUSED static struct enums termios_oflags_BSDLY[] = {
1295 ENUM_TARGET(BS0),
1296 ENUM_TARGET(BS1),
1297 ENUM_END,
1298 };
1299
1300 UNUSED static struct enums termios_cflags_CBAUD[] = {
1301 ENUM_TARGET(B0),
1302 ENUM_TARGET(B50),
1303 ENUM_TARGET(B75),
1304 ENUM_TARGET(B110),
1305 ENUM_TARGET(B134),
1306 ENUM_TARGET(B150),
1307 ENUM_TARGET(B200),
1308 ENUM_TARGET(B300),
1309 ENUM_TARGET(B600),
1310 ENUM_TARGET(B1200),
1311 ENUM_TARGET(B1800),
1312 ENUM_TARGET(B2400),
1313 ENUM_TARGET(B4800),
1314 ENUM_TARGET(B9600),
1315 ENUM_TARGET(B19200),
1316 ENUM_TARGET(B38400),
1317 ENUM_TARGET(B57600),
1318 ENUM_TARGET(B115200),
1319 ENUM_TARGET(B230400),
1320 ENUM_TARGET(B460800),
1321 ENUM_END,
1322 };
1323
1324 UNUSED static struct enums termios_cflags_CSIZE[] = {
1325 ENUM_TARGET(CS5),
1326 ENUM_TARGET(CS6),
1327 ENUM_TARGET(CS7),
1328 ENUM_TARGET(CS8),
1329 ENUM_END,
1330 };
1331
1332 UNUSED static struct flags termios_cflags[] = {
1333 FLAG_TARGET(CSTOPB),
1334 FLAG_TARGET(CREAD),
1335 FLAG_TARGET(PARENB),
1336 FLAG_TARGET(PARODD),
1337 FLAG_TARGET(HUPCL),
1338 FLAG_TARGET(CLOCAL),
1339 FLAG_TARGET(CRTSCTS),
1340 FLAG_END,
1341 };
1342
1343 UNUSED static struct flags termios_lflags[] = {
1344 FLAG_TARGET(ISIG),
1345 FLAG_TARGET(ICANON),
1346 FLAG_TARGET(XCASE),
1347 FLAG_TARGET(ECHO),
1348 FLAG_TARGET(ECHOE),
1349 FLAG_TARGET(ECHOK),
1350 FLAG_TARGET(ECHONL),
1351 FLAG_TARGET(NOFLSH),
1352 FLAG_TARGET(TOSTOP),
1353 FLAG_TARGET(ECHOCTL),
1354 FLAG_TARGET(ECHOPRT),
1355 FLAG_TARGET(ECHOKE),
1356 FLAG_TARGET(FLUSHO),
1357 FLAG_TARGET(PENDIN),
1358 FLAG_TARGET(IEXTEN),
1359 FLAG_TARGET(EXTPROC),
1360 FLAG_END,
1361 };
1362
1363 UNUSED static struct flags mlockall_flags[] = {
1364 FLAG_TARGET(MCL_CURRENT),
1365 FLAG_TARGET(MCL_FUTURE),
1366 #ifdef MCL_ONFAULT
1367 FLAG_TARGET(MCL_ONFAULT),
1368 #endif
1369 FLAG_END,
1370 };
1371
1372 /* IDs of the various system clocks */
1373 #define TARGET_CLOCK_REALTIME 0
1374 #define TARGET_CLOCK_MONOTONIC 1
1375 #define TARGET_CLOCK_PROCESS_CPUTIME_ID 2
1376 #define TARGET_CLOCK_THREAD_CPUTIME_ID 3
1377 #define TARGET_CLOCK_MONOTONIC_RAW 4
1378 #define TARGET_CLOCK_REALTIME_COARSE 5
1379 #define TARGET_CLOCK_MONOTONIC_COARSE 6
1380 #define TARGET_CLOCK_BOOTTIME 7
1381 #define TARGET_CLOCK_REALTIME_ALARM 8
1382 #define TARGET_CLOCK_BOOTTIME_ALARM 9
1383 #define TARGET_CLOCK_SGI_CYCLE 10
1384 #define TARGET_CLOCK_TAI 11
1385
1386 UNUSED static struct enums clockids[] = {
1387 ENUM_TARGET(CLOCK_REALTIME),
1388 ENUM_TARGET(CLOCK_MONOTONIC),
1389 ENUM_TARGET(CLOCK_PROCESS_CPUTIME_ID),
1390 ENUM_TARGET(CLOCK_THREAD_CPUTIME_ID),
1391 ENUM_TARGET(CLOCK_MONOTONIC_RAW),
1392 ENUM_TARGET(CLOCK_REALTIME_COARSE),
1393 ENUM_TARGET(CLOCK_MONOTONIC_COARSE),
1394 ENUM_TARGET(CLOCK_BOOTTIME),
1395 ENUM_TARGET(CLOCK_REALTIME_ALARM),
1396 ENUM_TARGET(CLOCK_BOOTTIME_ALARM),
1397 ENUM_TARGET(CLOCK_SGI_CYCLE),
1398 ENUM_TARGET(CLOCK_TAI),
1399 ENUM_END,
1400 };
1401
1402 UNUSED static struct enums itimer_types[] = {
1403 ENUM_GENERIC(ITIMER_REAL),
1404 ENUM_GENERIC(ITIMER_VIRTUAL),
1405 ENUM_GENERIC(ITIMER_PROF),
1406 ENUM_END,
1407 };
1408
1409 /*
1410 * print_xxx utility functions. These are used to print syscall
1411 * parameters in certain format. All of these have parameter
1412 * named 'last'. This parameter is used to add comma to output
1413 * when last == 0.
1414 */
1415
1416 static const char *
1417 get_comma(int last)
1418 {
1419 return ((last) ? "" : ",");
1420 }
1421
1422 static void
1423 print_flags(const struct flags *f, abi_long flags, int last)
1424 {
1425 const char *sep = "";
1426 int n;
1427
1428 if ((flags == 0) && (f->f_value == 0)) {
1429 qemu_log("%s%s", f->f_string, get_comma(last));
1430 return;
1431 }
1432 for (n = 0; f->f_string != NULL; f++) {
1433 if ((f->f_value != 0) && ((flags & f->f_value) == f->f_value)) {
1434 qemu_log("%s%s", sep, f->f_string);
1435 flags &= ~f->f_value;
1436 sep = "|";
1437 n++;
1438 }
1439 }
1440
1441 if (n > 0) {
1442 /* print rest of the flags as numeric */
1443 if (flags != 0) {
1444 qemu_log("%s%#x%s", sep, (unsigned int)flags, get_comma(last));
1445 } else {
1446 qemu_log("%s", get_comma(last));
1447 }
1448 } else {
1449 /* no string version of flags found, print them in hex then */
1450 qemu_log("%#x%s", (unsigned int)flags, get_comma(last));
1451 }
1452 }
1453
1454 static void
1455 print_enums(const struct enums *e, abi_long enum_arg, int last)
1456 {
1457 for (; e->e_string != NULL; e++) {
1458 if (e->e_value == enum_arg) {
1459 qemu_log("%s", e->e_string);
1460 break;
1461 }
1462 }
1463
1464 if (e->e_string == NULL) {
1465 qemu_log("%#x", (unsigned int)enum_arg);
1466 }
1467
1468 qemu_log("%s", get_comma(last));
1469 }
1470
1471 static void
1472 print_at_dirfd(abi_long dirfd, int last)
1473 {
1474 #ifdef AT_FDCWD
1475 if (dirfd == AT_FDCWD) {
1476 qemu_log("AT_FDCWD%s", get_comma(last));
1477 return;
1478 }
1479 #endif
1480 qemu_log("%d%s", (int)dirfd, get_comma(last));
1481 }
1482
1483 static void
1484 print_file_mode(abi_long mode, int last)
1485 {
1486 const char *sep = "";
1487 const struct flags *m;
1488
1489 for (m = &mode_flags[0]; m->f_string != NULL; m++) {
1490 if ((m->f_value & mode) == m->f_value) {
1491 qemu_log("%s%s", m->f_string, sep);
1492 sep = "|";
1493 mode &= ~m->f_value;
1494 break;
1495 }
1496 }
1497
1498 mode &= ~S_IFMT;
1499 /* print rest of the mode as octal */
1500 if (mode != 0)
1501 qemu_log("%s%#o", sep, (unsigned int)mode);
1502
1503 qemu_log("%s", get_comma(last));
1504 }
1505
1506 static void
1507 print_open_flags(abi_long flags, int last)
1508 {
1509 print_flags(open_access_flags, flags & TARGET_O_ACCMODE, 1);
1510 flags &= ~TARGET_O_ACCMODE;
1511 if (flags == 0) {
1512 qemu_log("%s", get_comma(last));
1513 return;
1514 }
1515 qemu_log("|");
1516 print_flags(open_flags, flags, last);
1517 }
1518
1519 static void
1520 print_syscall_prologue(const struct syscallname *sc)
1521 {
1522 qemu_log("%s(", sc->name);
1523 }
1524
1525 /*ARGSUSED*/
1526 static void
1527 print_syscall_epilogue(const struct syscallname *sc)
1528 {
1529 (void)sc;
1530 qemu_log(")");
1531 }
1532
1533 static void
1534 print_string(abi_long addr, int last)
1535 {
1536 char *s;
1537
1538 if ((s = lock_user_string(addr)) != NULL) {
1539 qemu_log("\"%s\"%s", s, get_comma(last));
1540 unlock_user(s, addr, 0);
1541 } else {
1542 /* can't get string out of it, so print it as pointer */
1543 print_pointer(addr, last);
1544 }
1545 }
1546
1547 #define MAX_PRINT_BUF 40
1548 static void
1549 print_buf(abi_long addr, abi_long len, int last)
1550 {
1551 uint8_t *s;
1552 int i;
1553
1554 s = lock_user(VERIFY_READ, addr, len, 1);
1555 if (s) {
1556 qemu_log("\"");
1557 for (i = 0; i < MAX_PRINT_BUF && i < len; i++) {
1558 if (isprint(s[i])) {
1559 qemu_log("%c", s[i]);
1560 } else {
1561 qemu_log("\\%o", s[i]);
1562 }
1563 }
1564 qemu_log("\"");
1565 if (i != len) {
1566 qemu_log("...");
1567 }
1568 if (!last) {
1569 qemu_log(",");
1570 }
1571 unlock_user(s, addr, 0);
1572 } else {
1573 print_pointer(addr, last);
1574 }
1575 }
1576
1577 /*
1578 * Prints out raw parameter using given format. Caller needs
1579 * to do byte swapping if needed.
1580 */
1581 static void
1582 print_raw_param(const char *fmt, abi_long param, int last)
1583 {
1584 char format[64];
1585
1586 (void) snprintf(format, sizeof (format), "%s%s", fmt, get_comma(last));
1587 qemu_log(format, param);
1588 }
1589
1590 static void
1591 print_pointer(abi_long p, int last)
1592 {
1593 if (p == 0)
1594 qemu_log("NULL%s", get_comma(last));
1595 else
1596 qemu_log("0x" TARGET_ABI_FMT_lx "%s", p, get_comma(last));
1597 }
1598
1599 /*
1600 * Reads 32-bit (int) number from guest address space from
1601 * address 'addr' and prints it.
1602 */
1603 static void
1604 print_number(abi_long addr, int last)
1605 {
1606 if (addr == 0) {
1607 qemu_log("NULL%s", get_comma(last));
1608 } else {
1609 int num;
1610
1611 get_user_s32(num, addr);
1612 qemu_log("[%d]%s", num, get_comma(last));
1613 }
1614 }
1615
1616 static void
1617 print_timeval(abi_ulong tv_addr, int last)
1618 {
1619 if( tv_addr ) {
1620 struct target_timeval *tv;
1621
1622 tv = lock_user(VERIFY_READ, tv_addr, sizeof(*tv), 1);
1623 if (!tv) {
1624 print_pointer(tv_addr, last);
1625 return;
1626 }
1627 qemu_log("{tv_sec = " TARGET_ABI_FMT_ld
1628 ",tv_usec = " TARGET_ABI_FMT_ld "}%s",
1629 tswapal(tv->tv_sec), tswapal(tv->tv_usec), get_comma(last));
1630 unlock_user(tv, tv_addr, 0);
1631 } else
1632 qemu_log("NULL%s", get_comma(last));
1633 }
1634
1635 static void
1636 print_timespec(abi_ulong ts_addr, int last)
1637 {
1638 if (ts_addr) {
1639 struct target_timespec *ts;
1640
1641 ts = lock_user(VERIFY_READ, ts_addr, sizeof(*ts), 1);
1642 if (!ts) {
1643 print_pointer(ts_addr, last);
1644 return;
1645 }
1646 qemu_log("{tv_sec = " TARGET_ABI_FMT_ld
1647 ",tv_nsec = " TARGET_ABI_FMT_ld "}%s",
1648 tswapal(ts->tv_sec), tswapal(ts->tv_nsec), get_comma(last));
1649 unlock_user(ts, ts_addr, 0);
1650 } else {
1651 qemu_log("NULL%s", get_comma(last));
1652 }
1653 }
1654
1655 static void
1656 print_timezone(abi_ulong tz_addr, int last)
1657 {
1658 if (tz_addr) {
1659 struct target_timezone *tz;
1660
1661 tz = lock_user(VERIFY_READ, tz_addr, sizeof(*tz), 1);
1662 if (!tz) {
1663 print_pointer(tz_addr, last);
1664 return;
1665 }
1666 qemu_log("{%d,%d}%s", tswap32(tz->tz_minuteswest),
1667 tswap32(tz->tz_dsttime), get_comma(last));
1668 unlock_user(tz, tz_addr, 0);
1669 } else {
1670 qemu_log("NULL%s", get_comma(last));
1671 }
1672 }
1673
1674 static void
1675 print_itimerval(abi_ulong it_addr, int last)
1676 {
1677 if (it_addr) {
1678 qemu_log("{it_interval=");
1679 print_timeval(it_addr +
1680 offsetof(struct target_itimerval, it_interval), 0);
1681 qemu_log("it_value=");
1682 print_timeval(it_addr +
1683 offsetof(struct target_itimerval, it_value), 0);
1684 qemu_log("}%s", get_comma(last));
1685 } else {
1686 qemu_log("NULL%s", get_comma(last));
1687 }
1688 }
1689
1690 void
1691 print_termios(void *arg)
1692 {
1693 const struct target_termios *target = arg;
1694
1695 target_tcflag_t iflags = tswap32(target->c_iflag);
1696 target_tcflag_t oflags = tswap32(target->c_oflag);
1697 target_tcflag_t cflags = tswap32(target->c_cflag);
1698 target_tcflag_t lflags = tswap32(target->c_lflag);
1699
1700 qemu_log("{");
1701
1702 qemu_log("c_iflag = ");
1703 print_flags(termios_iflags, iflags, 0);
1704
1705 qemu_log("c_oflag = ");
1706 target_tcflag_t oflags_clean = oflags & ~(TARGET_NLDLY | TARGET_CRDLY |
1707 TARGET_TABDLY | TARGET_BSDLY |
1708 TARGET_VTDLY | TARGET_FFDLY);
1709 print_flags(termios_oflags, oflags_clean, 0);
1710 if (oflags & TARGET_NLDLY) {
1711 print_enums(termios_oflags_NLDLY, oflags & TARGET_NLDLY, 0);
1712 }
1713 if (oflags & TARGET_CRDLY) {
1714 print_enums(termios_oflags_CRDLY, oflags & TARGET_CRDLY, 0);
1715 }
1716 if (oflags & TARGET_TABDLY) {
1717 print_enums(termios_oflags_TABDLY, oflags & TARGET_TABDLY, 0);
1718 }
1719 if (oflags & TARGET_BSDLY) {
1720 print_enums(termios_oflags_BSDLY, oflags & TARGET_BSDLY, 0);
1721 }
1722 if (oflags & TARGET_VTDLY) {
1723 print_enums(termios_oflags_VTDLY, oflags & TARGET_VTDLY, 0);
1724 }
1725 if (oflags & TARGET_FFDLY) {
1726 print_enums(termios_oflags_FFDLY, oflags & TARGET_FFDLY, 0);
1727 }
1728
1729 qemu_log("c_cflag = ");
1730 if (cflags & TARGET_CBAUD) {
1731 print_enums(termios_cflags_CBAUD, cflags & TARGET_CBAUD, 0);
1732 }
1733 if (cflags & TARGET_CSIZE) {
1734 print_enums(termios_cflags_CSIZE, cflags & TARGET_CSIZE, 0);
1735 }
1736 target_tcflag_t cflags_clean = cflags & ~(TARGET_CBAUD | TARGET_CSIZE);
1737 print_flags(termios_cflags, cflags_clean, 0);
1738
1739 qemu_log("c_lflag = ");
1740 print_flags(termios_lflags, lflags, 0);
1741
1742 qemu_log("c_cc = ");
1743 qemu_log("\"%s\",", target->c_cc);
1744
1745 qemu_log("c_line = ");
1746 print_raw_param("\'%c\'", target->c_line, 1);
1747
1748 qemu_log("}");
1749 }
1750
1751 #undef UNUSED
1752
1753 #ifdef TARGET_NR_accept
1754 static void
1755 print_accept(void *cpu_env, const struct syscallname *name,
1756 abi_long arg0, abi_long arg1, abi_long arg2,
1757 abi_long arg3, abi_long arg4, abi_long arg5)
1758 {
1759 print_syscall_prologue(name);
1760 print_raw_param("%d", arg0, 0);
1761 print_pointer(arg1, 0);
1762 print_number(arg2, 1);
1763 print_syscall_epilogue(name);
1764 }
1765 #endif
1766
1767 #ifdef TARGET_NR_access
1768 static void
1769 print_access(void *cpu_env, const struct syscallname *name,
1770 abi_long arg0, abi_long arg1, abi_long arg2,
1771 abi_long arg3, abi_long arg4, abi_long arg5)
1772 {
1773 print_syscall_prologue(name);
1774 print_string(arg0, 0);
1775 print_flags(access_flags, arg1, 1);
1776 print_syscall_epilogue(name);
1777 }
1778 #endif
1779
1780 #ifdef TARGET_NR_acct
1781 static void
1782 print_acct(void *cpu_env, const struct syscallname *name,
1783 abi_long arg0, abi_long arg1, abi_long arg2,
1784 abi_long arg3, abi_long arg4, abi_long arg5)
1785 {
1786 print_syscall_prologue(name);
1787 print_string(arg0, 1);
1788 print_syscall_epilogue(name);
1789 }
1790 #endif
1791
1792 #ifdef TARGET_NR_brk
1793 static void
1794 print_brk(void *cpu_env, const struct syscallname *name,
1795 abi_long arg0, abi_long arg1, abi_long arg2,
1796 abi_long arg3, abi_long arg4, abi_long arg5)
1797 {
1798 print_syscall_prologue(name);
1799 print_pointer(arg0, 1);
1800 print_syscall_epilogue(name);
1801 }
1802 #endif
1803
1804 #ifdef TARGET_NR_chdir
1805 static void
1806 print_chdir(void *cpu_env, const struct syscallname *name,
1807 abi_long arg0, abi_long arg1, abi_long arg2,
1808 abi_long arg3, abi_long arg4, abi_long arg5)
1809 {
1810 print_syscall_prologue(name);
1811 print_string(arg0, 1);
1812 print_syscall_epilogue(name);
1813 }
1814 #endif
1815
1816 #ifdef TARGET_NR_chroot
1817 static void
1818 print_chroot(void *cpu_env, const struct syscallname *name,
1819 abi_long arg0, abi_long arg1, abi_long arg2,
1820 abi_long arg3, abi_long arg4, abi_long arg5)
1821 {
1822 print_syscall_prologue(name);
1823 print_string(arg0, 1);
1824 print_syscall_epilogue(name);
1825 }
1826 #endif
1827
1828 #ifdef TARGET_NR_chmod
1829 static void
1830 print_chmod(void *cpu_env, const struct syscallname *name,
1831 abi_long arg0, abi_long arg1, abi_long arg2,
1832 abi_long arg3, abi_long arg4, abi_long arg5)
1833 {
1834 print_syscall_prologue(name);
1835 print_string(arg0, 0);
1836 print_file_mode(arg1, 1);
1837 print_syscall_epilogue(name);
1838 }
1839 #endif
1840
1841 #if defined(TARGET_NR_chown) || defined(TARGET_NR_lchown)
1842 static void
1843 print_chown(void *cpu_env, const struct syscallname *name,
1844 abi_long arg0, abi_long arg1, abi_long arg2,
1845 abi_long arg3, abi_long arg4, abi_long arg5)
1846 {
1847 print_syscall_prologue(name);
1848 print_string(arg0, 0);
1849 print_raw_param("%d", arg1, 0);
1850 print_raw_param("%d", arg2, 1);
1851 print_syscall_epilogue(name);
1852 }
1853 #define print_lchown print_chown
1854 #endif
1855
1856 #ifdef TARGET_NR_clock_adjtime
1857 static void
1858 print_clock_adjtime(void *cpu_env, const struct syscallname *name,
1859 abi_long arg0, abi_long arg1, abi_long arg2,
1860 abi_long arg3, abi_long arg4, abi_long arg5)
1861 {
1862 print_syscall_prologue(name);
1863 print_enums(clockids, arg0, 0);
1864 print_pointer(arg1, 1);
1865 print_syscall_epilogue(name);
1866 }
1867 #endif
1868
1869 #ifdef TARGET_NR_clone
1870 static void do_print_clone(unsigned int flags, abi_ulong newsp,
1871 abi_ulong parent_tidptr, target_ulong newtls,
1872 abi_ulong child_tidptr)
1873 {
1874 print_flags(clone_flags, flags, 0);
1875 print_raw_param("child_stack=0x" TARGET_ABI_FMT_lx, newsp, 0);
1876 print_raw_param("parent_tidptr=0x" TARGET_ABI_FMT_lx, parent_tidptr, 0);
1877 print_raw_param("tls=0x" TARGET_ABI_FMT_lx, newtls, 0);
1878 print_raw_param("child_tidptr=0x" TARGET_ABI_FMT_lx, child_tidptr, 1);
1879 }
1880
1881 static void
1882 print_clone(void *cpu_env, const struct syscallname *name,
1883 abi_long arg1, abi_long arg2, abi_long arg3,
1884 abi_long arg4, abi_long arg5, abi_long arg6)
1885 {
1886 print_syscall_prologue(name);
1887 #if defined(TARGET_MICROBLAZE)
1888 do_print_clone(arg1, arg2, arg4, arg6, arg5);
1889 #elif defined(TARGET_CLONE_BACKWARDS)
1890 do_print_clone(arg1, arg2, arg3, arg4, arg5);
1891 #elif defined(TARGET_CLONE_BACKWARDS2)
1892 do_print_clone(arg2, arg1, arg3, arg5, arg4);
1893 #else
1894 do_print_clone(arg1, arg2, arg3, arg5, arg4);
1895 #endif
1896 print_syscall_epilogue(name);
1897 }
1898 #endif
1899
1900 #ifdef TARGET_NR_creat
1901 static void
1902 print_creat(void *cpu_env, const struct syscallname *name,
1903 abi_long arg0, abi_long arg1, abi_long arg2,
1904 abi_long arg3, abi_long arg4, abi_long arg5)
1905 {
1906 print_syscall_prologue(name);
1907 print_string(arg0, 0);
1908 print_file_mode(arg1, 1);
1909 print_syscall_epilogue(name);
1910 }
1911 #endif
1912
1913 #ifdef TARGET_NR_execv
1914 static void
1915 print_execv(void *cpu_env, const struct syscallname *name,
1916 abi_long arg0, abi_long arg1, abi_long arg2,
1917 abi_long arg3, abi_long arg4, abi_long arg5)
1918 {
1919 print_syscall_prologue(name);
1920 print_string(arg0, 0);
1921 print_raw_param("0x" TARGET_ABI_FMT_lx, arg1, 1);
1922 print_syscall_epilogue(name);
1923 }
1924 #endif
1925
1926 #ifdef TARGET_NR_faccessat
1927 static void
1928 print_faccessat(void *cpu_env, const struct syscallname *name,
1929 abi_long arg0, abi_long arg1, abi_long arg2,
1930 abi_long arg3, abi_long arg4, abi_long arg5)
1931 {
1932 print_syscall_prologue(name);
1933 print_at_dirfd(arg0, 0);
1934 print_string(arg1, 0);
1935 print_flags(access_flags, arg2, 0);
1936 print_flags(at_file_flags, arg3, 1);
1937 print_syscall_epilogue(name);
1938 }
1939 #endif
1940
1941 #ifdef TARGET_NR_fallocate
1942 static void
1943 print_fallocate(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)
1946 {
1947 print_syscall_prologue(name);
1948 print_raw_param("%d", arg0, 0);
1949 print_flags(falloc_flags, arg1, 0);
1950 #if TARGET_ABI_BITS == 32
1951 print_raw_param("%" PRIu64, target_offset64(arg2, arg3), 0);
1952 print_raw_param("%" PRIu64, target_offset64(arg4, arg5), 1);
1953 #else
1954 print_raw_param(TARGET_ABI_FMT_ld, arg2, 0);
1955 print_raw_param(TARGET_ABI_FMT_ld, arg3, 1);
1956 #endif
1957 print_syscall_epilogue(name);
1958 }
1959 #endif
1960
1961 #ifdef TARGET_NR_fchmodat
1962 static void
1963 print_fchmodat(void *cpu_env, const struct syscallname *name,
1964 abi_long arg0, abi_long arg1, abi_long arg2,
1965 abi_long arg3, abi_long arg4, abi_long arg5)
1966 {
1967 print_syscall_prologue(name);
1968 print_at_dirfd(arg0, 0);
1969 print_string(arg1, 0);
1970 print_file_mode(arg2, 0);
1971 print_flags(at_file_flags, arg3, 1);
1972 print_syscall_epilogue(name);
1973 }
1974 #endif
1975
1976 #ifdef TARGET_NR_fchownat
1977 static void
1978 print_fchownat(void *cpu_env, const struct syscallname *name,
1979 abi_long arg0, abi_long arg1, abi_long arg2,
1980 abi_long arg3, abi_long arg4, abi_long arg5)
1981 {
1982 print_syscall_prologue(name);
1983 print_at_dirfd(arg0, 0);
1984 print_string(arg1, 0);
1985 print_raw_param("%d", arg2, 0);
1986 print_raw_param("%d", arg3, 0);
1987 print_flags(at_file_flags, arg4, 1);
1988 print_syscall_epilogue(name);
1989 }
1990 #endif
1991
1992 #if defined(TARGET_NR_fcntl) || defined(TARGET_NR_fcntl64)
1993 static void
1994 print_fcntl(void *cpu_env, const struct syscallname *name,
1995 abi_long arg0, abi_long arg1, abi_long arg2,
1996 abi_long arg3, abi_long arg4, abi_long arg5)
1997 {
1998 print_syscall_prologue(name);
1999 print_raw_param("%d", arg0, 0);
2000 switch(arg1) {
2001 case TARGET_F_DUPFD:
2002 qemu_log("F_DUPFD,");
2003 print_raw_param(TARGET_ABI_FMT_ld, arg2, 1);
2004 break;
2005 case TARGET_F_GETFD:
2006 qemu_log("F_GETFD");
2007 break;
2008 case TARGET_F_SETFD:
2009 qemu_log("F_SETFD,");
2010 print_raw_param(TARGET_ABI_FMT_ld, arg2, 1);
2011 break;
2012 case TARGET_F_GETFL:
2013 qemu_log("F_GETFL");
2014 break;
2015 case TARGET_F_SETFL:
2016 qemu_log("F_SETFL,");
2017 print_open_flags(arg2, 1);
2018 break;
2019 case TARGET_F_GETLK:
2020 qemu_log("F_GETLK,");
2021 print_pointer(arg2, 1);
2022 break;
2023 case TARGET_F_SETLK:
2024 qemu_log("F_SETLK,");
2025 print_pointer(arg2, 1);
2026 break;
2027 case TARGET_F_SETLKW:
2028 qemu_log("F_SETLKW,");
2029 print_pointer(arg2, 1);
2030 break;
2031 case TARGET_F_GETOWN:
2032 qemu_log("F_GETOWN");
2033 break;
2034 case TARGET_F_SETOWN:
2035 qemu_log("F_SETOWN,");
2036 print_raw_param(TARGET_ABI_FMT_ld, arg2, 0);
2037 break;
2038 case TARGET_F_GETSIG:
2039 qemu_log("F_GETSIG");
2040 break;
2041 case TARGET_F_SETSIG:
2042 qemu_log("F_SETSIG,");
2043 print_raw_param(TARGET_ABI_FMT_ld, arg2, 0);
2044 break;
2045 #if TARGET_ABI_BITS == 32
2046 case TARGET_F_GETLK64:
2047 qemu_log("F_GETLK64,");
2048 print_pointer(arg2, 1);
2049 break;
2050 case TARGET_F_SETLK64:
2051 qemu_log("F_SETLK64,");
2052 print_pointer(arg2, 1);
2053 break;
2054 case TARGET_F_SETLKW64:
2055 qemu_log("F_SETLKW64,");
2056 print_pointer(arg2, 1);
2057 break;
2058 #endif
2059 case TARGET_F_SETLEASE:
2060 qemu_log("F_SETLEASE,");
2061 print_raw_param(TARGET_ABI_FMT_ld, arg2, 0);
2062 break;
2063 case TARGET_F_GETLEASE:
2064 qemu_log("F_GETLEASE");
2065 break;
2066 case TARGET_F_SETPIPE_SZ:
2067 qemu_log("F_SETPIPE_SZ,");
2068 print_raw_param(TARGET_ABI_FMT_ld, arg2, 1);
2069 break;
2070 case TARGET_F_GETPIPE_SZ:
2071 qemu_log("F_GETPIPE_SZ");
2072 break;
2073 case TARGET_F_DUPFD_CLOEXEC:
2074 qemu_log("F_DUPFD_CLOEXEC,");
2075 print_raw_param(TARGET_ABI_FMT_ld, arg2, 1);
2076 break;
2077 case TARGET_F_NOTIFY:
2078 qemu_log("F_NOTIFY,");
2079 print_raw_param(TARGET_ABI_FMT_ld, arg2, 0);
2080 break;
2081 default:
2082 print_raw_param(TARGET_ABI_FMT_ld, arg1, 0);
2083 print_pointer(arg2, 1);
2084 break;
2085 }
2086 print_syscall_epilogue(name);
2087 }
2088 #define print_fcntl64 print_fcntl
2089 #endif
2090
2091 #ifdef TARGET_NR_fgetxattr
2092 static void
2093 print_fgetxattr(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)
2096 {
2097 print_syscall_prologue(name);
2098 print_raw_param("%d", arg0, 0);
2099 print_string(arg1, 0);
2100 print_pointer(arg2, 0);
2101 print_raw_param(TARGET_FMT_lu, arg3, 1);
2102 print_syscall_epilogue(name);
2103 }
2104 #endif
2105
2106 #ifdef TARGET_NR_flistxattr
2107 static void
2108 print_flistxattr(void *cpu_env, const struct syscallname *name,
2109 abi_long arg0, abi_long arg1, abi_long arg2,
2110 abi_long arg3, abi_long arg4, abi_long arg5)
2111 {
2112 print_syscall_prologue(name);
2113 print_raw_param("%d", arg0, 0);
2114 print_pointer(arg1, 0);
2115 print_raw_param(TARGET_FMT_lu, arg2, 1);
2116 print_syscall_epilogue(name);
2117 }
2118 #endif
2119
2120 #if defined(TARGET_NR_getxattr) || defined(TARGET_NR_lgetxattr)
2121 static void
2122 print_getxattr(void *cpu_env, const struct syscallname *name,
2123 abi_long arg0, abi_long arg1, abi_long arg2,
2124 abi_long arg3, abi_long arg4, abi_long arg5)
2125 {
2126 print_syscall_prologue(name);
2127 print_string(arg0, 0);
2128 print_string(arg1, 0);
2129 print_pointer(arg2, 0);
2130 print_raw_param(TARGET_FMT_lu, arg3, 1);
2131 print_syscall_epilogue(name);
2132 }
2133 #define print_lgetxattr print_getxattr
2134 #endif
2135
2136 #if defined(TARGET_NR_listxattr) || defined(TARGET_NR_llistxattr)
2137 static void
2138 print_listxattr(void *cpu_env, const struct syscallname *name,
2139 abi_long arg0, abi_long arg1, abi_long arg2,
2140 abi_long arg3, abi_long arg4, abi_long arg5)
2141 {
2142 print_syscall_prologue(name);
2143 print_string(arg0, 0);
2144 print_pointer(arg1, 0);
2145 print_raw_param(TARGET_FMT_lu, arg2, 1);
2146 print_syscall_epilogue(name);
2147 }
2148 #define print_llistxattr print_listxattr
2149 #endif
2150
2151 #if defined(TARGET_NR_fremovexattr)
2152 static void
2153 print_fremovexattr(void *cpu_env, const struct syscallname *name,
2154 abi_long arg0, abi_long arg1, abi_long arg2,
2155 abi_long arg3, abi_long arg4, abi_long arg5)
2156 {
2157 print_syscall_prologue(name);
2158 print_raw_param("%d", arg0, 0);
2159 print_string(arg1, 1);
2160 print_syscall_epilogue(name);
2161 }
2162 #endif
2163
2164 #if defined(TARGET_NR_removexattr) || defined(TARGET_NR_lremovexattr)
2165 static void
2166 print_removexattr(void *cpu_env, const struct syscallname *name,
2167 abi_long arg0, abi_long arg1, abi_long arg2,
2168 abi_long arg3, abi_long arg4, abi_long arg5)
2169 {
2170 print_syscall_prologue(name);
2171 print_string(arg0, 0);
2172 print_string(arg1, 1);
2173 print_syscall_epilogue(name);
2174 }
2175 #define print_lremovexattr print_removexattr
2176 #endif
2177
2178 #ifdef TARGET_NR_futimesat
2179 static void
2180 print_futimesat(void *cpu_env, const struct syscallname *name,
2181 abi_long arg0, abi_long arg1, abi_long arg2,
2182 abi_long arg3, abi_long arg4, abi_long arg5)
2183 {
2184 print_syscall_prologue(name);
2185 print_at_dirfd(arg0, 0);
2186 print_string(arg1, 0);
2187 print_timeval(arg2, 0);
2188 print_timeval(arg2 + sizeof (struct target_timeval), 1);
2189 print_syscall_epilogue(name);
2190 }
2191 #endif
2192
2193 #ifdef TARGET_NR_gettimeofday
2194 static void
2195 print_gettimeofday(void *cpu_env, const struct syscallname *name,
2196 abi_long arg0, abi_long arg1, abi_long arg2,
2197 abi_long arg3, abi_long arg4, abi_long arg5)
2198 {
2199 print_syscall_prologue(name);
2200 print_pointer(arg0, 0);
2201 print_pointer(arg1, 1);
2202 print_syscall_epilogue(name);
2203 }
2204 #endif
2205
2206 #ifdef TARGET_NR_settimeofday
2207 static void
2208 print_settimeofday(void *cpu_env, const struct syscallname *name,
2209 abi_long arg0, abi_long arg1, abi_long arg2,
2210 abi_long arg3, abi_long arg4, abi_long arg5)
2211 {
2212 print_syscall_prologue(name);
2213 print_timeval(arg0, 0);
2214 print_timezone(arg1, 1);
2215 print_syscall_epilogue(name);
2216 }
2217 #endif
2218
2219 #if defined(TARGET_NR_clock_gettime) || defined(TARGET_NR_clock_getres)
2220 static void
2221 print_clock_gettime(void *cpu_env, const struct syscallname *name,
2222 abi_long arg0, abi_long arg1, abi_long arg2,
2223 abi_long arg3, abi_long arg4, abi_long arg5)
2224 {
2225 print_syscall_prologue(name);
2226 print_enums(clockids, arg0, 0);
2227 print_pointer(arg1, 1);
2228 print_syscall_epilogue(name);
2229 }
2230 #define print_clock_getres print_clock_gettime
2231 #endif
2232
2233 #ifdef TARGET_NR_clock_settime
2234 static void
2235 print_clock_settime(void *cpu_env, const struct syscallname *name,
2236 abi_long arg0, abi_long arg1, abi_long arg2,
2237 abi_long arg3, abi_long arg4, abi_long arg5)
2238 {
2239 print_syscall_prologue(name);
2240 print_enums(clockids, arg0, 0);
2241 print_timespec(arg1, 1);
2242 print_syscall_epilogue(name);
2243 }
2244 #endif
2245
2246 #ifdef TARGET_NR_getitimer
2247 static void
2248 print_getitimer(void *cpu_env, const struct syscallname *name,
2249 abi_long arg0, abi_long arg1, abi_long arg2,
2250 abi_long arg3, abi_long arg4, abi_long arg5)
2251 {
2252 print_syscall_prologue(name);
2253 print_enums(itimer_types, arg0, 0);
2254 print_pointer(arg1, 1);
2255 print_syscall_epilogue(name);
2256 }
2257 #endif
2258
2259 #ifdef TARGET_NR_setitimer
2260 static void
2261 print_setitimer(void *cpu_env, const struct syscallname *name,
2262 abi_long arg0, abi_long arg1, abi_long arg2,
2263 abi_long arg3, abi_long arg4, abi_long arg5)
2264 {
2265 print_syscall_prologue(name);
2266 print_enums(itimer_types, arg0, 0);
2267 print_itimerval(arg1, 0);
2268 print_pointer(arg2, 1);
2269 print_syscall_epilogue(name);
2270 }
2271 #endif
2272
2273 #ifdef TARGET_NR_link
2274 static void
2275 print_link(void *cpu_env, const struct syscallname *name,
2276 abi_long arg0, abi_long arg1, abi_long arg2,
2277 abi_long arg3, abi_long arg4, abi_long arg5)
2278 {
2279 print_syscall_prologue(name);
2280 print_string(arg0, 0);
2281 print_string(arg1, 1);
2282 print_syscall_epilogue(name);
2283 }
2284 #endif
2285
2286 #ifdef TARGET_NR_linkat
2287 static void
2288 print_linkat(void *cpu_env, const struct syscallname *name,
2289 abi_long arg0, abi_long arg1, abi_long arg2,
2290 abi_long arg3, abi_long arg4, abi_long arg5)
2291 {
2292 print_syscall_prologue(name);
2293 print_at_dirfd(arg0, 0);
2294 print_string(arg1, 0);
2295 print_at_dirfd(arg2, 0);
2296 print_string(arg3, 0);
2297 print_flags(at_file_flags, arg4, 1);
2298 print_syscall_epilogue(name);
2299 }
2300 #endif
2301
2302 #ifdef TARGET_NR__llseek
2303 static void
2304 print__llseek(void *cpu_env, const struct syscallname *name,
2305 abi_long arg0, abi_long arg1, abi_long arg2,
2306 abi_long arg3, abi_long arg4, abi_long arg5)
2307 {
2308 const char *whence = "UNKNOWN";
2309 print_syscall_prologue(name);
2310 print_raw_param("%d", arg0, 0);
2311 print_raw_param("%ld", arg1, 0);
2312 print_raw_param("%ld", arg2, 0);
2313 print_pointer(arg3, 0);
2314 switch(arg4) {
2315 case SEEK_SET: whence = "SEEK_SET"; break;
2316 case SEEK_CUR: whence = "SEEK_CUR"; break;
2317 case SEEK_END: whence = "SEEK_END"; break;
2318 }
2319 qemu_log("%s", whence);
2320 print_syscall_epilogue(name);
2321 }
2322 #endif
2323
2324 #ifdef TARGET_NR_lseek
2325 static void
2326 print_lseek(void *cpu_env, const struct syscallname *name,
2327 abi_long arg0, abi_long arg1, abi_long arg2,
2328 abi_long arg3, abi_long arg4, abi_long arg5)
2329 {
2330 print_syscall_prologue(name);
2331 print_raw_param("%d", arg0, 0);
2332 print_raw_param(TARGET_ABI_FMT_ld, arg1, 0);
2333 switch (arg2) {
2334 case SEEK_SET:
2335 qemu_log("SEEK_SET"); break;
2336 case SEEK_CUR:
2337 qemu_log("SEEK_CUR"); break;
2338 case SEEK_END:
2339 qemu_log("SEEK_END"); break;
2340 #ifdef SEEK_DATA
2341 case SEEK_DATA:
2342 qemu_log("SEEK_DATA"); break;
2343 #endif
2344 #ifdef SEEK_HOLE
2345 case SEEK_HOLE:
2346 qemu_log("SEEK_HOLE"); break;
2347 #endif
2348 default:
2349 print_raw_param("%#x", arg2, 1);
2350 }
2351 print_syscall_epilogue(name);
2352 }
2353 #endif
2354
2355 #ifdef TARGET_NR_truncate
2356 static void
2357 print_truncate(void *cpu_env, const struct syscallname *name,
2358 abi_long arg0, abi_long arg1, abi_long arg2,
2359 abi_long arg3, abi_long arg4, abi_long arg5)
2360 {
2361 print_syscall_prologue(name);
2362 print_string(arg0, 0);
2363 print_raw_param(TARGET_ABI_FMT_ld, arg1, 1);
2364 print_syscall_epilogue(name);
2365 }
2366 #endif
2367
2368 #ifdef TARGET_NR_truncate64
2369 static void
2370 print_truncate64(void *cpu_env, const struct syscallname *name,
2371 abi_long arg0, abi_long arg1, abi_long arg2,
2372 abi_long arg3, abi_long arg4, abi_long arg5)
2373 {
2374 print_syscall_prologue(name);
2375 print_string(arg0, 0);
2376 if (regpairs_aligned(cpu_env, TARGET_NR_truncate64)) {
2377 arg1 = arg2;
2378 arg2 = arg3;
2379 }
2380 print_raw_param("%" PRIu64, target_offset64(arg1, arg2), 1);
2381 print_syscall_epilogue(name);
2382 }
2383 #endif
2384
2385 #ifdef TARGET_NR_ftruncate64
2386 static void
2387 print_ftruncate64(void *cpu_env, const struct syscallname *name,
2388 abi_long arg0, abi_long arg1, abi_long arg2,
2389 abi_long arg3, abi_long arg4, abi_long arg5)
2390 {
2391 print_syscall_prologue(name);
2392 print_raw_param("%d", arg0, 0);
2393 if (regpairs_aligned(cpu_env, TARGET_NR_ftruncate64)) {
2394 arg1 = arg2;
2395 arg2 = arg3;
2396 }
2397 print_raw_param("%" PRIu64, target_offset64(arg1, arg2), 1);
2398 print_syscall_epilogue(name);
2399 }
2400 #endif
2401
2402 #ifdef TARGET_NR_mlockall
2403 static void
2404 print_mlockall(void *cpu_env, const struct syscallname *name,
2405 abi_long arg0, abi_long arg1, abi_long arg2,
2406 abi_long arg3, abi_long arg4, abi_long arg5)
2407 {
2408 print_syscall_prologue(name);
2409 print_flags(mlockall_flags, arg0, 1);
2410 print_syscall_epilogue(name);
2411 }
2412 #endif
2413
2414 #if defined(TARGET_NR_socket)
2415 static void
2416 print_socket(void *cpu_env, const struct syscallname *name,
2417 abi_long arg0, abi_long arg1, abi_long arg2,
2418 abi_long arg3, abi_long arg4, abi_long arg5)
2419 {
2420 abi_ulong domain = arg0, type = arg1, protocol = arg2;
2421
2422 print_syscall_prologue(name);
2423 print_socket_domain(domain);
2424 qemu_log(",");
2425 print_socket_type(type);
2426 qemu_log(",");
2427 if (domain == AF_PACKET ||
2428 (domain == AF_INET && type == TARGET_SOCK_PACKET)) {
2429 protocol = tswap16(protocol);
2430 }
2431 print_socket_protocol(domain, type, protocol);
2432 print_syscall_epilogue(name);
2433 }
2434
2435 #endif
2436
2437 #if defined(TARGET_NR_socketcall) || defined(TARGET_NR_bind)
2438
2439 static void print_sockfd(abi_long sockfd, int last)
2440 {
2441 print_raw_param(TARGET_ABI_FMT_ld, sockfd, last);
2442 }
2443
2444 #endif
2445
2446 #if defined(TARGET_NR_socketcall)
2447
2448 #define get_user_ualx(x, gaddr, idx) \
2449 get_user_ual(x, (gaddr) + (idx) * sizeof(abi_long))
2450
2451 static void do_print_socket(const char *name, abi_long arg1)
2452 {
2453 abi_ulong domain, type, protocol;
2454
2455 get_user_ualx(domain, arg1, 0);
2456 get_user_ualx(type, arg1, 1);
2457 get_user_ualx(protocol, arg1, 2);
2458 qemu_log("%s(", name);
2459 print_socket_domain(domain);
2460 qemu_log(",");
2461 print_socket_type(type);
2462 qemu_log(",");
2463 if (domain == AF_PACKET ||
2464 (domain == AF_INET && type == TARGET_SOCK_PACKET)) {
2465 protocol = tswap16(protocol);
2466 }
2467 print_socket_protocol(domain, type, protocol);
2468 qemu_log(")");
2469 }
2470
2471 static void do_print_sockaddr(const char *name, abi_long arg1)
2472 {
2473 abi_ulong sockfd, addr, addrlen;
2474
2475 get_user_ualx(sockfd, arg1, 0);
2476 get_user_ualx(addr, arg1, 1);
2477 get_user_ualx(addrlen, arg1, 2);
2478
2479 qemu_log("%s(", name);
2480 print_sockfd(sockfd, 0);
2481 print_sockaddr(addr, addrlen, 0);
2482 qemu_log(")");
2483 }
2484
2485 static void do_print_listen(const char *name, abi_long arg1)
2486 {
2487 abi_ulong sockfd, backlog;
2488
2489 get_user_ualx(sockfd, arg1, 0);
2490 get_user_ualx(backlog, arg1, 1);
2491
2492 qemu_log("%s(", name);
2493 print_sockfd(sockfd, 0);
2494 print_raw_param(TARGET_ABI_FMT_ld, backlog, 1);
2495 qemu_log(")");
2496 }
2497
2498 static void do_print_socketpair(const char *name, abi_long arg1)
2499 {
2500 abi_ulong domain, type, protocol, tab;
2501
2502 get_user_ualx(domain, arg1, 0);
2503 get_user_ualx(type, arg1, 1);
2504 get_user_ualx(protocol, arg1, 2);
2505 get_user_ualx(tab, arg1, 3);
2506
2507 qemu_log("%s(", name);
2508 print_socket_domain(domain);
2509 qemu_log(",");
2510 print_socket_type(type);
2511 qemu_log(",");
2512 print_socket_protocol(domain, type, protocol);
2513 qemu_log(",");
2514 print_raw_param(TARGET_ABI_FMT_lx, tab, 1);
2515 qemu_log(")");
2516 }
2517
2518 static void do_print_sendrecv(const char *name, abi_long arg1)
2519 {
2520 abi_ulong sockfd, msg, len, flags;
2521
2522 get_user_ualx(sockfd, arg1, 0);
2523 get_user_ualx(msg, arg1, 1);
2524 get_user_ualx(len, arg1, 2);
2525 get_user_ualx(flags, arg1, 3);
2526
2527 qemu_log("%s(", name);
2528 print_sockfd(sockfd, 0);
2529 print_buf(msg, len, 0);
2530 print_raw_param(TARGET_ABI_FMT_ld, len, 0);
2531 print_flags(msg_flags, flags, 1);
2532 qemu_log(")");
2533 }
2534
2535 static void do_print_msgaddr(const char *name, abi_long arg1)
2536 {
2537 abi_ulong sockfd, msg, len, flags, addr, addrlen;
2538
2539 get_user_ualx(sockfd, arg1, 0);
2540 get_user_ualx(msg, arg1, 1);
2541 get_user_ualx(len, arg1, 2);
2542 get_user_ualx(flags, arg1, 3);
2543 get_user_ualx(addr, arg1, 4);
2544 get_user_ualx(addrlen, arg1, 5);
2545
2546 qemu_log("%s(", name);
2547 print_sockfd(sockfd, 0);
2548 print_buf(msg, len, 0);
2549 print_raw_param(TARGET_ABI_FMT_ld, len, 0);
2550 print_flags(msg_flags, flags, 0);
2551 print_sockaddr(addr, addrlen, 0);
2552 qemu_log(")");
2553 }
2554
2555 static void do_print_shutdown(const char *name, abi_long arg1)
2556 {
2557 abi_ulong sockfd, how;
2558
2559 get_user_ualx(sockfd, arg1, 0);
2560 get_user_ualx(how, arg1, 1);
2561
2562 qemu_log("shutdown(");
2563 print_sockfd(sockfd, 0);
2564 switch (how) {
2565 case SHUT_RD:
2566 qemu_log("SHUT_RD");
2567 break;
2568 case SHUT_WR:
2569 qemu_log("SHUT_WR");
2570 break;
2571 case SHUT_RDWR:
2572 qemu_log("SHUT_RDWR");
2573 break;
2574 default:
2575 print_raw_param(TARGET_ABI_FMT_ld, how, 1);
2576 break;
2577 }
2578 qemu_log(")");
2579 }
2580
2581 static void do_print_msg(const char *name, abi_long arg1)
2582 {
2583 abi_ulong sockfd, msg, flags;
2584
2585 get_user_ualx(sockfd, arg1, 0);
2586 get_user_ualx(msg, arg1, 1);
2587 get_user_ualx(flags, arg1, 2);
2588
2589 qemu_log("%s(", name);
2590 print_sockfd(sockfd, 0);
2591 print_pointer(msg, 0);
2592 print_flags(msg_flags, flags, 1);
2593 qemu_log(")");
2594 }
2595
2596 static void do_print_sockopt(const char *name, abi_long arg1)
2597 {
2598 abi_ulong sockfd, level, optname, optval, optlen;
2599
2600 get_user_ualx(sockfd, arg1, 0);
2601 get_user_ualx(level, arg1, 1);
2602 get_user_ualx(optname, arg1, 2);
2603 get_user_ualx(optval, arg1, 3);
2604 get_user_ualx(optlen, arg1, 4);
2605
2606 qemu_log("%s(", name);
2607 print_sockfd(sockfd, 0);
2608 switch (level) {
2609 case SOL_TCP:
2610 qemu_log("SOL_TCP,");
2611 print_raw_param(TARGET_ABI_FMT_ld, optname, 0);
2612 print_pointer(optval, 0);
2613 break;
2614 case SOL_IP:
2615 qemu_log("SOL_IP,");
2616 print_raw_param(TARGET_ABI_FMT_ld, optname, 0);
2617 print_pointer(optval, 0);
2618 break;
2619 case SOL_RAW:
2620 qemu_log("SOL_RAW,");
2621 print_raw_param(TARGET_ABI_FMT_ld, optname, 0);
2622 print_pointer(optval, 0);
2623 break;
2624 case TARGET_SOL_SOCKET:
2625 qemu_log("SOL_SOCKET,");
2626 switch (optname) {
2627 case TARGET_SO_DEBUG:
2628 qemu_log("SO_DEBUG,");
2629 print_optint:
2630 print_number(optval, 0);
2631 break;
2632 case TARGET_SO_REUSEADDR:
2633 qemu_log("SO_REUSEADDR,");
2634 goto print_optint;
2635 case TARGET_SO_REUSEPORT:
2636 qemu_log("SO_REUSEPORT,");
2637 goto print_optint;
2638 case TARGET_SO_TYPE:
2639 qemu_log("SO_TYPE,");
2640 goto print_optint;
2641 case TARGET_SO_ERROR:
2642 qemu_log("SO_ERROR,");
2643 goto print_optint;
2644 case TARGET_SO_DONTROUTE:
2645 qemu_log("SO_DONTROUTE,");
2646 goto print_optint;
2647 case TARGET_SO_BROADCAST:
2648 qemu_log("SO_BROADCAST,");
2649 goto print_optint;
2650 case TARGET_SO_SNDBUF:
2651 qemu_log("SO_SNDBUF,");
2652 goto print_optint;
2653 case TARGET_SO_RCVBUF:
2654 qemu_log("SO_RCVBUF,");
2655 goto print_optint;
2656 case TARGET_SO_KEEPALIVE:
2657 qemu_log("SO_KEEPALIVE,");
2658 goto print_optint;
2659 case TARGET_SO_OOBINLINE:
2660 qemu_log("SO_OOBINLINE,");
2661 goto print_optint;
2662 case TARGET_SO_NO_CHECK:
2663 qemu_log("SO_NO_CHECK,");
2664 goto print_optint;
2665 case TARGET_SO_PRIORITY:
2666 qemu_log("SO_PRIORITY,");
2667 goto print_optint;
2668 case TARGET_SO_BSDCOMPAT:
2669 qemu_log("SO_BSDCOMPAT,");
2670 goto print_optint;
2671 case TARGET_SO_PASSCRED:
2672 qemu_log("SO_PASSCRED,");
2673 goto print_optint;
2674 case TARGET_SO_TIMESTAMP:
2675 qemu_log("SO_TIMESTAMP,");
2676 goto print_optint;
2677 case TARGET_SO_RCVLOWAT:
2678 qemu_log("SO_RCVLOWAT,");
2679 goto print_optint;
2680 case TARGET_SO_RCVTIMEO:
2681 qemu_log("SO_RCVTIMEO,");
2682 print_timeval(optval, 0);
2683 break;
2684 case TARGET_SO_SNDTIMEO:
2685 qemu_log("SO_SNDTIMEO,");
2686 print_timeval(optval, 0);
2687 break;
2688 case TARGET_SO_ATTACH_FILTER: {
2689 struct target_sock_fprog *fprog;
2690
2691 qemu_log("SO_ATTACH_FILTER,");
2692
2693 if (lock_user_struct(VERIFY_READ, fprog, optval, 0)) {
2694 struct target_sock_filter *filter;
2695 qemu_log("{");
2696 if (lock_user_struct(VERIFY_READ, filter,
2697 tswapal(fprog->filter), 0)) {
2698 int i;
2699 for (i = 0; i < tswap16(fprog->len) - 1; i++) {
2700 qemu_log("[%d]{0x%x,%d,%d,0x%x},",
2701 i, tswap16(filter[i].code),
2702 filter[i].jt, filter[i].jf,
2703 tswap32(filter[i].k));
2704 }
2705 qemu_log("[%d]{0x%x,%d,%d,0x%x}",
2706 i, tswap16(filter[i].code),
2707 filter[i].jt, filter[i].jf,
2708 tswap32(filter[i].k));
2709 } else {
2710 qemu_log(TARGET_ABI_FMT_lx, tswapal(fprog->filter));
2711 }
2712 qemu_log(",%d},", tswap16(fprog->len));
2713 unlock_user(fprog, optval, 0);
2714 } else {
2715 print_pointer(optval, 0);
2716 }
2717 break;
2718 }
2719 default:
2720 print_raw_param(TARGET_ABI_FMT_ld, optname, 0);
2721 print_pointer(optval, 0);
2722 break;
2723 }
2724 break;
2725 default:
2726 print_raw_param(TARGET_ABI_FMT_ld, level, 0);
2727 print_raw_param(TARGET_ABI_FMT_ld, optname, 0);
2728 print_pointer(optval, 0);
2729 break;
2730 }
2731 print_raw_param(TARGET_ABI_FMT_ld, optlen, 1);
2732 qemu_log(")");
2733 }
2734
2735 #define PRINT_SOCKOP(name, func) \
2736 [TARGET_SYS_##name] = { #name, func }
2737
2738 static struct {
2739 const char *name;
2740 void (*print)(const char *, abi_long);
2741 } scall[] = {
2742 PRINT_SOCKOP(SOCKET, do_print_socket),
2743 PRINT_SOCKOP(BIND, do_print_sockaddr),
2744 PRINT_SOCKOP(CONNECT, do_print_sockaddr),
2745 PRINT_SOCKOP(LISTEN, do_print_listen),
2746 PRINT_SOCKOP(ACCEPT, do_print_sockaddr),
2747 PRINT_SOCKOP(GETSOCKNAME, do_print_sockaddr),
2748 PRINT_SOCKOP(GETPEERNAME, do_print_sockaddr),
2749 PRINT_SOCKOP(SOCKETPAIR, do_print_socketpair),
2750 PRINT_SOCKOP(SEND, do_print_sendrecv),
2751 PRINT_SOCKOP(RECV, do_print_sendrecv),
2752 PRINT_SOCKOP(SENDTO, do_print_msgaddr),
2753 PRINT_SOCKOP(RECVFROM, do_print_msgaddr),
2754 PRINT_SOCKOP(SHUTDOWN, do_print_shutdown),
2755 PRINT_SOCKOP(SETSOCKOPT, do_print_sockopt),
2756 PRINT_SOCKOP(GETSOCKOPT, do_print_sockopt),
2757 PRINT_SOCKOP(SENDMSG, do_print_msg),
2758 PRINT_SOCKOP(RECVMSG, do_print_msg),
2759 PRINT_SOCKOP(ACCEPT4, NULL),
2760 PRINT_SOCKOP(RECVMMSG, NULL),
2761 PRINT_SOCKOP(SENDMMSG, NULL),
2762 };
2763
2764 static void
2765 print_socketcall(void *cpu_env, const struct syscallname *name,
2766 abi_long arg0, abi_long arg1, abi_long arg2,
2767 abi_long arg3, abi_long arg4, abi_long arg5)
2768 {
2769 if (arg0 >= 0 && arg0 < ARRAY_SIZE(scall) && scall[arg0].print) {
2770 scall[arg0].print(scall[arg0].name, arg1);
2771 return;
2772 }
2773 print_syscall_prologue(name);
2774 print_raw_param(TARGET_ABI_FMT_ld, arg0, 0);
2775 print_raw_param(TARGET_ABI_FMT_ld, arg1, 0);
2776 print_raw_param(TARGET_ABI_FMT_ld, arg2, 0);
2777 print_raw_param(TARGET_ABI_FMT_ld, arg3, 0);
2778 print_raw_param(TARGET_ABI_FMT_ld, arg4, 0);
2779 print_raw_param(TARGET_ABI_FMT_ld, arg5, 0);
2780 print_syscall_epilogue(name);
2781 }
2782 #endif
2783
2784 #if defined(TARGET_NR_bind)
2785 static void
2786 print_bind(void *cpu_env, const struct syscallname *name,
2787 abi_long arg0, abi_long arg1, abi_long arg2,
2788 abi_long arg3, abi_long arg4, abi_long arg5)
2789 {
2790 print_syscall_prologue(name);
2791 print_sockfd(arg0, 0);
2792 print_sockaddr(arg1, arg2, 1);
2793 print_syscall_epilogue(name);
2794 }
2795 #endif
2796
2797 #if defined(TARGET_NR_stat) || defined(TARGET_NR_stat64) || \
2798 defined(TARGET_NR_lstat) || defined(TARGET_NR_lstat64)
2799 static void
2800 print_stat(void *cpu_env, const struct syscallname *name,
2801 abi_long arg0, abi_long arg1, abi_long arg2,
2802 abi_long arg3, abi_long arg4, abi_long arg5)
2803 {
2804 print_syscall_prologue(name);
2805 print_string(arg0, 0);
2806 print_pointer(arg1, 1);
2807 print_syscall_epilogue(name);
2808 }
2809 #define print_lstat print_stat
2810 #define print_stat64 print_stat
2811 #define print_lstat64 print_stat
2812 #endif
2813
2814 #if defined(TARGET_NR_fstat) || defined(TARGET_NR_fstat64)
2815 static void
2816 print_fstat(void *cpu_env, const struct syscallname *name,
2817 abi_long arg0, abi_long arg1, abi_long arg2,
2818 abi_long arg3, abi_long arg4, abi_long arg5)
2819 {
2820 print_syscall_prologue(name);
2821 print_raw_param("%d", arg0, 0);
2822 print_pointer(arg1, 1);
2823 print_syscall_epilogue(name);
2824 }
2825 #define print_fstat64 print_fstat
2826 #endif
2827
2828 #ifdef TARGET_NR_mkdir
2829 static void
2830 print_mkdir(void *cpu_env, const struct syscallname *name,
2831 abi_long arg0, abi_long arg1, abi_long arg2,
2832 abi_long arg3, abi_long arg4, abi_long arg5)
2833 {
2834 print_syscall_prologue(name);
2835 print_string(arg0, 0);
2836 print_file_mode(arg1, 1);
2837 print_syscall_epilogue(name);
2838 }
2839 #endif
2840
2841 #ifdef TARGET_NR_mkdirat
2842 static void
2843 print_mkdirat(void *cpu_env, const struct syscallname *name,
2844 abi_long arg0, abi_long arg1, abi_long arg2,
2845 abi_long arg3, abi_long arg4, abi_long arg5)
2846 {
2847 print_syscall_prologue(name);
2848 print_at_dirfd(arg0, 0);
2849 print_string(arg1, 0);
2850 print_file_mode(arg2, 1);
2851 print_syscall_epilogue(name);
2852 }
2853 #endif
2854
2855 #ifdef TARGET_NR_rmdir
2856 static void
2857 print_rmdir(void *cpu_env, const struct syscallname *name,
2858 abi_long arg0, abi_long arg1, abi_long arg2,
2859 abi_long arg3, abi_long arg4, abi_long arg5)
2860 {
2861 print_syscall_prologue(name);
2862 print_string(arg0, 0);
2863 print_syscall_epilogue(name);
2864 }
2865 #endif
2866
2867 #ifdef TARGET_NR_rt_sigaction
2868 static void
2869 print_rt_sigaction(void *cpu_env, const struct syscallname *name,
2870 abi_long arg0, abi_long arg1, abi_long arg2,
2871 abi_long arg3, abi_long arg4, abi_long arg5)
2872 {
2873 print_syscall_prologue(name);
2874 print_signal(arg0, 0);
2875 print_pointer(arg1, 0);
2876 print_pointer(arg2, 1);
2877 print_syscall_epilogue(name);
2878 }
2879 #endif
2880
2881 #ifdef TARGET_NR_rt_sigprocmask
2882 static void
2883 print_rt_sigprocmask(void *cpu_env, const struct syscallname *name,
2884 abi_long arg0, abi_long arg1, abi_long arg2,
2885 abi_long arg3, abi_long arg4, abi_long arg5)
2886 {
2887 const char *how = "UNKNOWN";
2888 print_syscall_prologue(name);
2889 switch(arg0) {
2890 case TARGET_SIG_BLOCK: how = "SIG_BLOCK"; break;
2891 case TARGET_SIG_UNBLOCK: how = "SIG_UNBLOCK"; break;
2892 case TARGET_SIG_SETMASK: how = "SIG_SETMASK"; break;
2893 }
2894 qemu_log("%s,", how);
2895 print_pointer(arg1, 0);
2896 print_pointer(arg2, 1);
2897 print_syscall_epilogue(name);
2898 }
2899 #endif
2900
2901 #ifdef TARGET_NR_rt_sigqueueinfo
2902 static void
2903 print_rt_sigqueueinfo(void *cpu_env, const struct syscallname *name,
2904 abi_long arg0, abi_long arg1, abi_long arg2,
2905 abi_long arg3, abi_long arg4, abi_long arg5)
2906 {
2907 void *p;
2908 target_siginfo_t uinfo;
2909
2910 print_syscall_prologue(name);
2911 print_raw_param("%d", arg0, 0);
2912 print_signal(arg1, 0);
2913 p = lock_user(VERIFY_READ, arg2, sizeof(target_siginfo_t), 1);
2914 if (p) {
2915 get_target_siginfo(&uinfo, p);
2916 print_siginfo(&uinfo);
2917
2918 unlock_user(p, arg2, 0);
2919 } else {
2920 print_pointer(arg2, 1);
2921 }
2922 print_syscall_epilogue(name);
2923 }
2924 #endif
2925
2926 #ifdef TARGET_NR_rt_tgsigqueueinfo
2927 static void
2928 print_rt_tgsigqueueinfo(void *cpu_env, const struct syscallname *name,
2929 abi_long arg0, abi_long arg1, abi_long arg2,
2930 abi_long arg3, abi_long arg4, abi_long arg5)
2931 {
2932 void *p;
2933 target_siginfo_t uinfo;
2934
2935 print_syscall_prologue(name);
2936 print_raw_param("%d", arg0, 0);
2937 print_raw_param("%d", arg1, 0);
2938 print_signal(arg2, 0);
2939 p = lock_user(VERIFY_READ, arg3, sizeof(target_siginfo_t), 1);
2940 if (p) {
2941 get_target_siginfo(&uinfo, p);
2942 print_siginfo(&uinfo);
2943
2944 unlock_user(p, arg3, 0);
2945 } else {
2946 print_pointer(arg3, 1);
2947 }
2948 print_syscall_epilogue(name);
2949 }
2950 #endif
2951
2952 #ifdef TARGET_NR_syslog
2953 static void
2954 print_syslog_action(abi_ulong arg, int last)
2955 {
2956 const char *type;
2957
2958 switch (arg) {
2959 case TARGET_SYSLOG_ACTION_CLOSE: {
2960 type = "SYSLOG_ACTION_CLOSE";
2961 break;
2962 }
2963 case TARGET_SYSLOG_ACTION_OPEN: {
2964 type = "SYSLOG_ACTION_OPEN";
2965 break;
2966 }
2967 case TARGET_SYSLOG_ACTION_READ: {
2968 type = "SYSLOG_ACTION_READ";
2969 break;
2970 }
2971 case TARGET_SYSLOG_ACTION_READ_ALL: {
2972 type = "SYSLOG_ACTION_READ_ALL";
2973 break;
2974 }
2975 case TARGET_SYSLOG_ACTION_READ_CLEAR: {
2976 type = "SYSLOG_ACTION_READ_CLEAR";
2977 break;
2978 }
2979 case TARGET_SYSLOG_ACTION_CLEAR: {
2980 type = "SYSLOG_ACTION_CLEAR";
2981 break;
2982 }
2983 case TARGET_SYSLOG_ACTION_CONSOLE_OFF: {
2984 type = "SYSLOG_ACTION_CONSOLE_OFF";
2985 break;
2986 }
2987 case TARGET_SYSLOG_ACTION_CONSOLE_ON: {
2988 type = "SYSLOG_ACTION_CONSOLE_ON";
2989 break;
2990 }
2991 case TARGET_SYSLOG_ACTION_CONSOLE_LEVEL: {
2992 type = "SYSLOG_ACTION_CONSOLE_LEVEL";
2993 break;
2994 }
2995 case TARGET_SYSLOG_ACTION_SIZE_UNREAD: {
2996 type = "SYSLOG_ACTION_SIZE_UNREAD";
2997 break;
2998 }
2999 case TARGET_SYSLOG_ACTION_SIZE_BUFFER: {
3000 type = "SYSLOG_ACTION_SIZE_BUFFER";
3001 break;
3002 }
3003 default: {
3004 print_raw_param("%ld", arg, last);
3005 return;
3006 }
3007 }
3008 qemu_log("%s%s", type, get_comma(last));
3009 }
3010
3011 static void
3012 print_syslog(void *cpu_env, const struct syscallname *name,
3013 abi_long arg0, abi_long arg1, abi_long arg2,
3014 abi_long arg3, abi_long arg4, abi_long arg5)
3015 {
3016 print_syscall_prologue(name);
3017 print_syslog_action(arg0, 0);
3018 print_pointer(arg1, 0);
3019 print_raw_param("%d", arg2, 1);
3020 print_syscall_epilogue(name);
3021 }
3022 #endif
3023
3024 #ifdef TARGET_NR_mknod
3025 static void
3026 print_mknod(void *cpu_env, const struct syscallname *name,
3027 abi_long arg0, abi_long arg1, abi_long arg2,
3028 abi_long arg3, abi_long arg4, abi_long arg5)
3029 {
3030 int hasdev = (arg1 & (S_IFCHR|S_IFBLK));
3031
3032 print_syscall_prologue(name);
3033 print_string(arg0, 0);
3034 print_file_mode(arg1, (hasdev == 0));
3035 if (hasdev) {
3036 print_raw_param("makedev(%d", major(arg2), 0);
3037 print_raw_param("%d)", minor(arg2), 1);
3038 }
3039 print_syscall_epilogue(name);
3040 }
3041 #endif
3042
3043 #ifdef TARGET_NR_mknodat
3044 static void
3045 print_mknodat(void *cpu_env, const struct syscallname *name,
3046 abi_long arg0, abi_long arg1, abi_long arg2,
3047 abi_long arg3, abi_long arg4, abi_long arg5)
3048 {
3049 int hasdev = (arg2 & (S_IFCHR|S_IFBLK));
3050
3051 print_syscall_prologue(name);
3052 print_at_dirfd(arg0, 0);
3053 print_string(arg1, 0);
3054 print_file_mode(arg2, (hasdev == 0));
3055 if (hasdev) {
3056 print_raw_param("makedev(%d", major(arg3), 0);
3057 print_raw_param("%d)", minor(arg3), 1);
3058 }
3059 print_syscall_epilogue(name);
3060 }
3061 #endif
3062
3063 #ifdef TARGET_NR_mq_open
3064 static void
3065 print_mq_open(void *cpu_env, const struct syscallname *name,
3066 abi_long arg0, abi_long arg1, abi_long arg2,
3067 abi_long arg3, abi_long arg4, abi_long arg5)
3068 {
3069 int is_creat = (arg1 & TARGET_O_CREAT);
3070
3071 print_syscall_prologue(name);
3072 print_string(arg0, 0);
3073 print_open_flags(arg1, (is_creat == 0));
3074 if (is_creat) {
3075 print_file_mode(arg2, 0);
3076 print_pointer(arg3, 1);
3077 }
3078 print_syscall_epilogue(name);
3079 }
3080 #endif
3081
3082 #ifdef TARGET_NR_open
3083 static void
3084 print_open(void *cpu_env, const struct syscallname *name,
3085 abi_long arg0, abi_long arg1, abi_long arg2,
3086 abi_long arg3, abi_long arg4, abi_long arg5)
3087 {
3088 int is_creat = (arg1 & TARGET_O_CREAT);
3089
3090 print_syscall_prologue(name);
3091 print_string(arg0, 0);
3092 print_open_flags(arg1, (is_creat == 0));
3093 if (is_creat)
3094 print_file_mode(arg2, 1);
3095 print_syscall_epilogue(name);
3096 }
3097 #endif
3098
3099 #ifdef TARGET_NR_openat
3100 static void
3101 print_openat(void *cpu_env, const struct syscallname *name,
3102 abi_long arg0, abi_long arg1, abi_long arg2,
3103 abi_long arg3, abi_long arg4, abi_long arg5)
3104 {
3105 int is_creat = (arg2 & TARGET_O_CREAT);
3106
3107 print_syscall_prologue(name);
3108 print_at_dirfd(arg0, 0);
3109 print_string(arg1, 0);
3110 print_open_flags(arg2, (is_creat == 0));
3111 if (is_creat)
3112 print_file_mode(arg3, 1);
3113 print_syscall_epilogue(name);
3114 }
3115 #endif
3116
3117 #ifdef TARGET_NR_mq_unlink
3118 static void
3119 print_mq_unlink(void *cpu_env, const struct syscallname *name,
3120 abi_long arg0, abi_long arg1, abi_long arg2,
3121 abi_long arg3, abi_long arg4, abi_long arg5)
3122 {
3123 print_syscall_prologue(name);
3124 print_string(arg0, 1);
3125 print_syscall_epilogue(name);
3126 }
3127 #endif
3128
3129 #if defined(TARGET_NR_fstatat64) || defined(TARGET_NR_newfstatat)
3130 static void
3131 print_fstatat64(void *cpu_env, const struct syscallname *name,
3132 abi_long arg0, abi_long arg1, abi_long arg2,
3133 abi_long arg3, abi_long arg4, abi_long arg5)
3134 {
3135 print_syscall_prologue(name);
3136 print_at_dirfd(arg0, 0);
3137 print_string(arg1, 0);
3138 print_pointer(arg2, 0);
3139 print_flags(at_file_flags, arg3, 1);
3140 print_syscall_epilogue(name);
3141 }
3142 #define print_newfstatat print_fstatat64
3143 #endif
3144
3145 #ifdef TARGET_NR_readlink
3146 static void
3147 print_readlink(void *cpu_env, const struct syscallname *name,
3148 abi_long arg0, abi_long arg1, abi_long arg2,
3149 abi_long arg3, abi_long arg4, abi_long arg5)
3150 {
3151 print_syscall_prologue(name);
3152 print_string(arg0, 0);
3153 print_pointer(arg1, 0);
3154 print_raw_param("%u", arg2, 1);
3155 print_syscall_epilogue(name);
3156 }
3157 #endif
3158
3159 #ifdef TARGET_NR_readlinkat
3160 static void
3161 print_readlinkat(void *cpu_env, const struct syscallname *name,
3162 abi_long arg0, abi_long arg1, abi_long arg2,
3163 abi_long arg3, abi_long arg4, abi_long arg5)
3164 {
3165 print_syscall_prologue(name);
3166 print_at_dirfd(arg0, 0);
3167 print_string(arg1, 0);
3168 print_pointer(arg2, 0);
3169 print_raw_param("%u", arg3, 1);
3170 print_syscall_epilogue(name);
3171 }
3172 #endif
3173
3174 #ifdef TARGET_NR_rename
3175 static void
3176 print_rename(void *cpu_env, const struct syscallname *name,
3177 abi_long arg0, abi_long arg1, abi_long arg2,
3178 abi_long arg3, abi_long arg4, abi_long arg5)
3179 {
3180 print_syscall_prologue(name);
3181 print_string(arg0, 0);
3182 print_string(arg1, 1);
3183 print_syscall_epilogue(name);
3184 }
3185 #endif
3186
3187 #ifdef TARGET_NR_renameat
3188 static void
3189 print_renameat(void *cpu_env, const struct syscallname *name,
3190 abi_long arg0, abi_long arg1, abi_long arg2,
3191 abi_long arg3, abi_long arg4, abi_long arg5)
3192 {
3193 print_syscall_prologue(name);
3194 print_at_dirfd(arg0, 0);
3195 print_string(arg1, 0);
3196 print_at_dirfd(arg2, 0);
3197 print_string(arg3, 1);
3198 print_syscall_epilogue(name);
3199 }
3200 #endif
3201
3202 #ifdef TARGET_NR_statfs
3203 static void
3204 print_statfs(void *cpu_env, const struct syscallname *name,
3205 abi_long arg0, abi_long arg1, abi_long arg2,
3206 abi_long arg3, abi_long arg4, abi_long arg5)
3207 {
3208 print_syscall_prologue(name);
3209 print_string(arg0, 0);
3210 print_pointer(arg1, 1);
3211 print_syscall_epilogue(name);
3212 }
3213 #endif
3214
3215 #ifdef TARGET_NR_statfs64
3216 static void
3217 print_statfs64(void *cpu_env, const struct syscallname *name,
3218 abi_long arg0, abi_long arg1, abi_long arg2,
3219 abi_long arg3, abi_long arg4, abi_long arg5)
3220 {
3221 print_syscall_prologue(name);
3222 print_string(arg0, 0);
3223 print_pointer(arg1, 1);
3224 print_syscall_epilogue(name);
3225 }
3226 #endif
3227
3228 #ifdef TARGET_NR_symlink
3229 static void
3230 print_symlink(void *cpu_env, const struct syscallname *name,
3231 abi_long arg0, abi_long arg1, abi_long arg2,
3232 abi_long arg3, abi_long arg4, abi_long arg5)
3233 {
3234 print_syscall_prologue(name);
3235 print_string(arg0, 0);
3236 print_string(arg1, 1);
3237 print_syscall_epilogue(name);
3238 }
3239 #endif
3240
3241 #ifdef TARGET_NR_symlinkat
3242 static void
3243 print_symlinkat(void *cpu_env, const struct syscallname *name,
3244 abi_long arg0, abi_long arg1, abi_long arg2,
3245 abi_long arg3, abi_long arg4, abi_long arg5)
3246 {
3247 print_syscall_prologue(name);
3248 print_string(arg0, 0);
3249 print_at_dirfd(arg1, 0);
3250 print_string(arg2, 1);
3251 print_syscall_epilogue(name);
3252 }
3253 #endif
3254
3255 #ifdef TARGET_NR_mount
3256 static void
3257 print_mount(void *cpu_env, const struct syscallname *name,
3258 abi_long arg0, abi_long arg1, abi_long arg2,
3259 abi_long arg3, abi_long arg4, abi_long arg5)
3260 {
3261 print_syscall_prologue(name);
3262 print_string(arg0, 0);
3263 print_string(arg1, 0);
3264 print_string(arg2, 0);
3265 print_flags(mount_flags, arg3, 0);
3266 print_pointer(arg4, 1);
3267 print_syscall_epilogue(name);
3268 }
3269 #endif
3270
3271 #ifdef TARGET_NR_umount
3272 static void
3273 print_umount(void *cpu_env, const struct syscallname *name,
3274 abi_long arg0, abi_long arg1, abi_long arg2,
3275 abi_long arg3, abi_long arg4, abi_long arg5)
3276 {
3277 print_syscall_prologue(name);
3278 print_string(arg0, 1);
3279 print_syscall_epilogue(name);
3280 }
3281 #endif
3282
3283 #ifdef TARGET_NR_umount2
3284 static void
3285 print_umount2(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)
3288 {
3289 print_syscall_prologue(name);
3290 print_string(arg0, 0);
3291 print_flags(umount2_flags, arg1, 1);
3292 print_syscall_epilogue(name);
3293 }
3294 #endif
3295
3296 #ifdef TARGET_NR_unlink
3297 static void
3298 print_unlink(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)
3301 {
3302 print_syscall_prologue(name);
3303 print_string(arg0, 1);
3304 print_syscall_epilogue(name);
3305 }
3306 #endif
3307
3308 #ifdef TARGET_NR_unlinkat
3309 static void
3310 print_unlinkat(void *cpu_env, const struct syscallname *name,
3311 abi_long arg0, abi_long arg1, abi_long arg2,
3312 abi_long arg3, abi_long arg4, abi_long arg5)
3313 {
3314 print_syscall_prologue(name);
3315 print_at_dirfd(arg0, 0);
3316 print_string(arg1, 0);
3317 print_flags(unlinkat_flags, arg2, 1);
3318 print_syscall_epilogue(name);
3319 }
3320 #endif
3321
3322 #ifdef TARGET_NR_utime
3323 static void
3324 print_utime(void *cpu_env, const struct syscallname *name,
3325 abi_long arg0, abi_long arg1, abi_long arg2,
3326 abi_long arg3, abi_long arg4, abi_long arg5)
3327 {
3328 print_syscall_prologue(name);
3329 print_string(arg0, 0);
3330 print_pointer(arg1, 1);
3331 print_syscall_epilogue(name);
3332 }
3333 #endif
3334
3335 #ifdef TARGET_NR_utimes
3336 static void
3337 print_utimes(void *cpu_env, const struct syscallname *name,
3338 abi_long arg0, abi_long arg1, abi_long arg2,
3339 abi_long arg3, abi_long arg4, abi_long arg5)
3340 {
3341 print_syscall_prologue(name);
3342 print_string(arg0, 0);
3343 print_pointer(arg1, 1);
3344 print_syscall_epilogue(name);
3345 }
3346 #endif
3347
3348 #ifdef TARGET_NR_utimensat
3349 static void
3350 print_utimensat(void *cpu_env, const struct syscallname *name,
3351 abi_long arg0, abi_long arg1, abi_long arg2,
3352 abi_long arg3, abi_long arg4, abi_long arg5)
3353 {
3354 print_syscall_prologue(name);
3355 print_at_dirfd(arg0, 0);
3356 print_string(arg1, 0);
3357 print_pointer(arg2, 0);
3358 print_flags(at_file_flags, arg3, 1);
3359 print_syscall_epilogue(name);
3360 }
3361 #endif
3362
3363 #if defined(TARGET_NR_mmap) || defined(TARGET_NR_mmap2)
3364 static void
3365 print_mmap(void *cpu_env, const struct syscallname *name,
3366 abi_long arg0, abi_long arg1, abi_long arg2,
3367 abi_long arg3, abi_long arg4, abi_long arg5)
3368 {
3369 print_syscall_prologue(name);
3370 print_pointer(arg0, 0);
3371 print_raw_param("%d", arg1, 0);
3372 print_flags(mmap_prot_flags, arg2, 0);
3373 print_flags(mmap_flags, arg3, 0);
3374 print_raw_param("%d", arg4, 0);
3375 print_raw_param("%#x", arg5, 1);
3376 print_syscall_epilogue(name);
3377 }
3378 #define print_mmap2 print_mmap
3379 #endif
3380
3381 #ifdef TARGET_NR_mprotect
3382 static void
3383 print_mprotect(void *cpu_env, const struct syscallname *name,
3384 abi_long arg0, abi_long arg1, abi_long arg2,
3385 abi_long arg3, abi_long arg4, abi_long arg5)
3386 {
3387 print_syscall_prologue(name);
3388 print_pointer(arg0, 0);
3389 print_raw_param("%d", arg1, 0);
3390 print_flags(mmap_prot_flags, arg2, 1);
3391 print_syscall_epilogue(name);
3392 }
3393 #endif
3394
3395 #ifdef TARGET_NR_munmap
3396 static void
3397 print_munmap(void *cpu_env, const struct syscallname *name,
3398 abi_long arg0, abi_long arg1, abi_long arg2,
3399 abi_long arg3, abi_long arg4, abi_long arg5)
3400 {
3401 print_syscall_prologue(name);
3402 print_pointer(arg0, 0);
3403 print_raw_param("%d", arg1, 1);
3404 print_syscall_epilogue(name);
3405 }
3406 #endif
3407
3408 #ifdef TARGET_NR_futex
3409 static void print_futex_op(abi_long tflag, int last)
3410 {
3411 #define print_op(val) \
3412 if( cmd == val ) { \
3413 qemu_log(#val); \
3414 return; \
3415 }
3416
3417 int cmd = (int)tflag;
3418 #ifdef FUTEX_PRIVATE_FLAG
3419 if (cmd & FUTEX_PRIVATE_FLAG) {
3420 qemu_log("FUTEX_PRIVATE_FLAG|");
3421 cmd &= ~FUTEX_PRIVATE_FLAG;
3422 }
3423 #endif
3424 #ifdef FUTEX_CLOCK_REALTIME
3425 if (cmd & FUTEX_CLOCK_REALTIME) {
3426 qemu_log("FUTEX_CLOCK_REALTIME|");
3427 cmd &= ~FUTEX_CLOCK_REALTIME;
3428 }
3429 #endif
3430 print_op(FUTEX_WAIT)
3431 print_op(FUTEX_WAKE)
3432 print_op(FUTEX_FD)
3433 print_op(FUTEX_REQUEUE)
3434 print_op(FUTEX_CMP_REQUEUE)
3435 print_op(FUTEX_WAKE_OP)
3436 print_op(FUTEX_LOCK_PI)
3437 print_op(FUTEX_UNLOCK_PI)
3438 print_op(FUTEX_TRYLOCK_PI)
3439 #ifdef FUTEX_WAIT_BITSET
3440 print_op(FUTEX_WAIT_BITSET)
3441 #endif
3442 #ifdef FUTEX_WAKE_BITSET
3443 print_op(FUTEX_WAKE_BITSET)
3444 #endif
3445 /* unknown values */
3446 qemu_log("%d", cmd);
3447 }
3448
3449 static void
3450 print_futex(void *cpu_env, const struct syscallname *name,
3451 abi_long arg0, abi_long arg1, abi_long arg2,
3452 abi_long arg3, abi_long arg4, abi_long arg5)
3453 {
3454 print_syscall_prologue(name);
3455 print_pointer(arg0, 0);
3456 print_futex_op(arg1, 0);
3457 print_raw_param(",%d", arg2, 0);
3458 print_pointer(arg3, 0); /* struct timespec */
3459 print_pointer(arg4, 0);
3460 print_raw_param("%d", arg4, 1);
3461 print_syscall_epilogue(name);
3462 }
3463 #endif
3464
3465 #ifdef TARGET_NR_kill
3466 static void
3467 print_kill(void *cpu_env, const struct syscallname *name,
3468 abi_long arg0, abi_long arg1, abi_long arg2,
3469 abi_long arg3, abi_long arg4, abi_long arg5)
3470 {
3471 print_syscall_prologue(name);
3472 print_raw_param("%d", arg0, 0);
3473 print_signal(arg1, 1);
3474 print_syscall_epilogue(name);
3475 }
3476 #endif
3477
3478 #ifdef TARGET_NR_tkill
3479 static void
3480 print_tkill(void *cpu_env, const struct syscallname *name,
3481 abi_long arg0, abi_long arg1, abi_long arg2,
3482 abi_long arg3, abi_long arg4, abi_long arg5)
3483 {
3484 print_syscall_prologue(name);
3485 print_raw_param("%d", arg0, 0);
3486 print_signal(arg1, 1);
3487 print_syscall_epilogue(name);
3488 }
3489 #endif
3490
3491 #ifdef TARGET_NR_tgkill
3492 static void
3493 print_tgkill(void *cpu_env, const struct syscallname *name,
3494 abi_long arg0, abi_long arg1, abi_long arg2,
3495 abi_long arg3, abi_long arg4, abi_long arg5)
3496 {
3497 print_syscall_prologue(name);
3498 print_raw_param("%d", arg0, 0);
3499 print_raw_param("%d", arg1, 0);
3500 print_signal(arg2, 1);
3501 print_syscall_epilogue(name);
3502 }
3503 #endif
3504
3505 #ifdef TARGET_NR_statx
3506 static void
3507 print_statx(void *cpu_env, const struct syscallname *name,
3508 abi_long arg0, abi_long arg1, abi_long arg2,
3509 abi_long arg3, abi_long arg4, abi_long arg5)
3510 {
3511 print_syscall_prologue(name);
3512 print_at_dirfd(arg0, 0);
3513 print_string(arg1, 0);
3514 print_flags(statx_flags, arg2, 0);
3515 print_flags(statx_mask, arg3, 0);
3516 print_pointer(arg4, 1);
3517 print_syscall_epilogue(name);
3518 }
3519 #endif
3520
3521 #ifdef TARGET_NR_ioctl
3522 static void
3523 print_ioctl(void *cpu_env, const struct syscallname *name,
3524 abi_long arg0, abi_long arg1, abi_long arg2,
3525 abi_long arg3, abi_long arg4, abi_long arg5)
3526 {
3527 print_syscall_prologue(name);
3528 print_raw_param("%d", arg0, 0);
3529
3530 const IOCTLEntry *ie;
3531 const argtype *arg_type;
3532 void *argptr;
3533 int target_size;
3534
3535 for (ie = ioctl_entries; ie->target_cmd != 0; ie++) {
3536 if (ie->target_cmd == arg1) {
3537 break;
3538 }
3539 }
3540
3541 if (ie->target_cmd == 0) {
3542 print_raw_param("%#x", arg1, 0);
3543 print_raw_param("%#x", arg2, 1);
3544 } else {
3545 qemu_log("%s", ie->name);
3546 arg_type = ie->arg_type;
3547
3548 if (arg_type[0] != TYPE_NULL) {
3549 qemu_log(",");
3550
3551 switch (arg_type[0]) {
3552 case TYPE_PTRVOID:
3553 print_pointer(arg2, 1);
3554 break;
3555 case TYPE_CHAR:
3556 case TYPE_SHORT:
3557 case TYPE_INT:
3558 print_raw_param("%d", arg2, 1);
3559 break;
3560 case TYPE_LONG:
3561 print_raw_param(TARGET_ABI_FMT_ld, arg2, 1);
3562 break;
3563 case TYPE_ULONG:
3564 print_raw_param(TARGET_ABI_FMT_lu, arg2, 1);
3565 break;
3566 case TYPE_PTR:
3567 switch (ie->access) {
3568 case IOC_R:
3569 print_pointer(arg2, 1);
3570 break;
3571 case IOC_W:
3572 case IOC_RW:
3573 arg_type++;
3574 target_size = thunk_type_size(arg_type, 0);
3575 argptr = lock_user(VERIFY_READ, arg2, target_size, 1);
3576 if (argptr) {
3577 thunk_print(argptr, arg_type);
3578 unlock_user(argptr, arg2, target_size);
3579 } else {
3580 print_pointer(arg2, 1);
3581 }
3582 break;
3583 }
3584 break;
3585 default:
3586 g_assert_not_reached();
3587 }
3588 }
3589 }
3590 print_syscall_epilogue(name);
3591 }
3592 #endif
3593
3594 /*
3595 * An array of all of the syscalls we know about
3596 */
3597
3598 static const struct syscallname scnames[] = {
3599 #include "strace.list"
3600 };
3601
3602 static int nsyscalls = ARRAY_SIZE(scnames);
3603
3604 /*
3605 * The public interface to this module.
3606 */
3607 void
3608 print_syscall(void *cpu_env, int num,
3609 abi_long arg1, abi_long arg2, abi_long arg3,
3610 abi_long arg4, abi_long arg5, abi_long arg6)
3611 {
3612 int i;
3613 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 ")";
3614
3615 qemu_log("%d ", getpid());
3616
3617 for(i=0;i<nsyscalls;i++)
3618 if( scnames[i].nr == num ) {
3619 if( scnames[i].call != NULL ) {
3620 scnames[i].call(
3621 cpu_env, &scnames[i], arg1, arg2, arg3, arg4, arg5, arg6);
3622 } else {
3623 /* XXX: this format system is broken because it uses
3624 host types and host pointers for strings */
3625 if( scnames[i].format != NULL )
3626 format = scnames[i].format;
3627 qemu_log(format,
3628 scnames[i].name, arg1, arg2, arg3, arg4, arg5, arg6);
3629 }
3630 return;
3631 }
3632 qemu_log("Unknown syscall %d\n", num);
3633 }
3634
3635
3636 void
3637 print_syscall_ret(void *cpu_env, int num, abi_long ret,
3638 abi_long arg1, abi_long arg2, abi_long arg3,
3639 abi_long arg4, abi_long arg5, abi_long arg6)
3640 {
3641 int i;
3642
3643 for(i=0;i<nsyscalls;i++)
3644 if( scnames[i].nr == num ) {
3645 if( scnames[i].result != NULL ) {
3646 scnames[i].result(cpu_env, &scnames[i], ret,
3647 arg1, arg2, arg3,
3648 arg4, arg5, arg6);
3649 } else {
3650 if (!print_syscall_err(ret)) {
3651 qemu_log(TARGET_ABI_FMT_ld, ret);
3652 }
3653 qemu_log("\n");
3654 }
3655 break;
3656 }
3657 }
3658
3659 void print_taken_signal(int target_signum, const target_siginfo_t *tinfo)
3660 {
3661 /* Print the strace output for a signal being taken:
3662 * --- SIGSEGV {si_signo=SIGSEGV, si_code=SI_KERNEL, si_addr=0} ---
3663 */
3664 qemu_log("--- ");
3665 print_signal(target_signum, 1);
3666 qemu_log(" ");
3667 print_siginfo(tinfo);
3668 qemu_log(" ---\n");
3669 }
AR7 emulation for QEMU