blob: 69232f7e27b8cf7ee20ac2c6c1aa23df5ceb0abd [file] [log] [blame]
Peter Maydelld39594e2016-01-26 18:17:02 +00001#include "qemu/osdep.h"
ths33189d32007-11-01 00:13:36 +00002#include <sys/ipc.h>
3#include <sys/msg.h>
4#include <sys/sem.h>
5#include <sys/shm.h>
6#include <sys/select.h>
Mika Westerberg74d753a2009-04-07 16:57:29 +03007#include <sys/mount.h>
Laurent Vivierfb3aabf2016-06-11 02:19:45 +02008#include <arpa/inet.h>
9#include <netinet/tcp.h>
10#include <linux/if_packet.h>
Philippe Mathieu-Daudé814ae702019-10-21 13:48:53 +020011#include <linux/netlink.h>
Laurent Vivier608e5592011-04-07 00:25:32 +020012#include <sched.h>
ths33189d32007-11-01 00:13:36 +000013#include "qemu.h"
14
ths33189d32007-11-01 00:13:36 +000015struct syscallname {
16 int nr;
blueswir17ccfb2e2008-09-14 06:45:34 +000017 const char *name;
18 const char *format;
19 void (*call)(const struct syscallname *,
bellardc16f9ed2007-11-11 17:23:29 +000020 abi_long, abi_long, abi_long,
21 abi_long, abi_long, abi_long);
blueswir17ccfb2e2008-09-14 06:45:34 +000022 void (*result)(const struct syscallname *, abi_long);
ths33189d32007-11-01 00:13:36 +000023};
24
Mika Westerberg74d753a2009-04-07 16:57:29 +030025#ifdef __GNUC__
26/*
27 * It is possible that target doesn't have syscall that uses
28 * following flags but we don't want the compiler to warn
29 * us about them being unused. Same applies to utility print
30 * functions. It is ok to keep them while not used.
31 */
32#define UNUSED __attribute__ ((unused))
33#else
34#define UNUSED
35#endif
36
37/*
38 * Structure used to translate flag values into strings. This is
39 * similar that is in the actual strace tool.
40 */
41struct flags {
42 abi_long f_value; /* flag */
43 const char *f_string; /* stringified flag */
44};
45
46/* common flags for all architectures */
47#define FLAG_GENERIC(name) { name, #name }
48/* target specific flags (syscall_defs.h has TARGET_<flag>) */
49#define FLAG_TARGET(name) { TARGET_ ## name, #name }
50/* end of flags array */
51#define FLAG_END { 0, NULL }
52
53UNUSED static const char *get_comma(int);
54UNUSED static void print_pointer(abi_long, int);
55UNUSED static void print_flags(const struct flags *, abi_long, int);
56UNUSED static void print_at_dirfd(abi_long, int);
57UNUSED static void print_file_mode(abi_long, int);
58UNUSED static void print_open_flags(abi_long, int);
59UNUSED static void print_syscall_prologue(const struct syscallname *);
60UNUSED static void print_syscall_epilogue(const struct syscallname *);
61UNUSED static void print_string(abi_long, int);
Laurent Vivierfb3aabf2016-06-11 02:19:45 +020062UNUSED static void print_buf(abi_long addr, abi_long len, int last);
Mika Westerberg74d753a2009-04-07 16:57:29 +030063UNUSED static void print_raw_param(const char *, abi_long, int);
64UNUSED static void print_timeval(abi_ulong, int);
Philippe Mathieu-Daudé6d33e032019-10-21 13:48:50 +020065UNUSED static void print_timezone(abi_ulong, int);
Mika Westerberg74d753a2009-04-07 16:57:29 +030066UNUSED static void print_number(abi_long, int);
Laurent Vivier608e5592011-04-07 00:25:32 +020067UNUSED static void print_signal(abi_ulong, int);
Philippe Mathieu-Daudé42b15d72019-10-21 13:48:56 +020068UNUSED static void print_sockaddr(abi_ulong, abi_long, int);
Laurent Vivierfb3aabf2016-06-11 02:19:45 +020069UNUSED static void print_socket_domain(int domain);
70UNUSED static void print_socket_type(int type);
71UNUSED static void print_socket_protocol(int domain, int type, int protocol);
Mika Westerberg74d753a2009-04-07 16:57:29 +030072
ths33189d32007-11-01 00:13:36 +000073/*
74 * Utility functions
75 */
76static void
77print_ipc_cmd(int cmd)
78{
79#define output_cmd(val) \
80if( cmd == val ) { \
Josh Kunz4b25a502020-02-03 18:54:14 -080081 qemu_log(#val); \
ths33189d32007-11-01 00:13:36 +000082 return; \
83}
84
85 cmd &= 0xff;
86
87 /* General IPC commands */
88 output_cmd( IPC_RMID );
89 output_cmd( IPC_SET );
90 output_cmd( IPC_STAT );
91 output_cmd( IPC_INFO );
92 /* msgctl() commands */
ths33189d32007-11-01 00:13:36 +000093 output_cmd( MSG_STAT );
94 output_cmd( MSG_INFO );
ths33189d32007-11-01 00:13:36 +000095 /* shmctl() commands */
96 output_cmd( SHM_LOCK );
97 output_cmd( SHM_UNLOCK );
98 output_cmd( SHM_STAT );
99 output_cmd( SHM_INFO );
100 /* semctl() commands */
101 output_cmd( GETPID );
102 output_cmd( GETVAL );
103 output_cmd( GETALL );
104 output_cmd( GETNCNT );
105 output_cmd( GETZCNT );
106 output_cmd( SETVAL );
107 output_cmd( SETALL );
108 output_cmd( SEM_STAT );
109 output_cmd( SEM_INFO );
110 output_cmd( IPC_RMID );
111 output_cmd( IPC_RMID );
112 output_cmd( IPC_RMID );
113 output_cmd( IPC_RMID );
114 output_cmd( IPC_RMID );
115 output_cmd( IPC_RMID );
116 output_cmd( IPC_RMID );
117 output_cmd( IPC_RMID );
118 output_cmd( IPC_RMID );
119
120 /* Some value we don't recognize */
Josh Kunz4b25a502020-02-03 18:54:14 -0800121 qemu_log("%d", cmd);
ths33189d32007-11-01 00:13:36 +0000122}
123
Laurent Vivier608e5592011-04-07 00:25:32 +0200124static void
125print_signal(abi_ulong arg, int last)
126{
127 const char *signal_name = NULL;
128 switch(arg) {
129 case TARGET_SIGHUP: signal_name = "SIGHUP"; break;
130 case TARGET_SIGINT: signal_name = "SIGINT"; break;
131 case TARGET_SIGQUIT: signal_name = "SIGQUIT"; break;
132 case TARGET_SIGILL: signal_name = "SIGILL"; break;
133 case TARGET_SIGABRT: signal_name = "SIGABRT"; break;
134 case TARGET_SIGFPE: signal_name = "SIGFPE"; break;
135 case TARGET_SIGKILL: signal_name = "SIGKILL"; break;
136 case TARGET_SIGSEGV: signal_name = "SIGSEGV"; break;
137 case TARGET_SIGPIPE: signal_name = "SIGPIPE"; break;
138 case TARGET_SIGALRM: signal_name = "SIGALRM"; break;
139 case TARGET_SIGTERM: signal_name = "SIGTERM"; break;
140 case TARGET_SIGUSR1: signal_name = "SIGUSR1"; break;
141 case TARGET_SIGUSR2: signal_name = "SIGUSR2"; break;
142 case TARGET_SIGCHLD: signal_name = "SIGCHLD"; break;
143 case TARGET_SIGCONT: signal_name = "SIGCONT"; break;
144 case TARGET_SIGSTOP: signal_name = "SIGSTOP"; break;
145 case TARGET_SIGTTIN: signal_name = "SIGTTIN"; break;
146 case TARGET_SIGTTOU: signal_name = "SIGTTOU"; break;
147 }
148 if (signal_name == NULL) {
Peter Maydellabe20842013-03-28 14:33:24 +0000149 print_raw_param("%ld", arg, last);
Laurent Vivier608e5592011-04-07 00:25:32 +0200150 return;
151 }
Josh Kunz4b25a502020-02-03 18:54:14 -0800152 qemu_log("%s%s", signal_name, get_comma(last));
Laurent Vivier608e5592011-04-07 00:25:32 +0200153}
154
Peter Maydell0cb581d2016-07-18 18:12:24 +0100155static void print_si_code(int arg)
156{
157 const char *codename = NULL;
158
159 switch (arg) {
160 case SI_USER:
161 codename = "SI_USER";
162 break;
163 case SI_KERNEL:
164 codename = "SI_KERNEL";
165 break;
166 case SI_QUEUE:
167 codename = "SI_QUEUE";
168 break;
169 case SI_TIMER:
170 codename = "SI_TIMER";
171 break;
172 case SI_MESGQ:
173 codename = "SI_MESGQ";
174 break;
175 case SI_ASYNCIO:
176 codename = "SI_ASYNCIO";
177 break;
178 case SI_SIGIO:
179 codename = "SI_SIGIO";
180 break;
181 case SI_TKILL:
182 codename = "SI_TKILL";
183 break;
184 default:
Josh Kunz4b25a502020-02-03 18:54:14 -0800185 qemu_log("%d", arg);
Peter Maydell0cb581d2016-07-18 18:12:24 +0100186 return;
187 }
Josh Kunz4b25a502020-02-03 18:54:14 -0800188 qemu_log("%s", codename);
Peter Maydell0cb581d2016-07-18 18:12:24 +0100189}
190
Miloš Stojanovićba9fcea2017-05-15 16:59:49 +0200191static void get_target_siginfo(target_siginfo_t *tinfo,
192 const target_siginfo_t *info)
193{
194 abi_ulong sival_ptr;
195
196 int sig;
197 int si_errno;
198 int si_code;
199 int si_type;
200
201 __get_user(sig, &info->si_signo);
202 __get_user(si_errno, &tinfo->si_errno);
203 __get_user(si_code, &info->si_code);
204
205 tinfo->si_signo = sig;
206 tinfo->si_errno = si_errno;
207 tinfo->si_code = si_code;
208
209 /* Ensure we don't leak random junk to the guest later */
210 memset(tinfo->_sifields._pad, 0, sizeof(tinfo->_sifields._pad));
211
212 /* This is awkward, because we have to use a combination of
213 * the si_code and si_signo to figure out which of the union's
214 * members are valid. (Within the host kernel it is always possible
215 * to tell, but the kernel carefully avoids giving userspace the
216 * high 16 bits of si_code, so we don't have the information to
217 * do this the easy way...) We therefore make our best guess,
218 * bearing in mind that a guest can spoof most of the si_codes
219 * via rt_sigqueueinfo() if it likes.
220 *
221 * Once we have made our guess, we record it in the top 16 bits of
222 * the si_code, so that print_siginfo() later can use it.
223 * print_siginfo() will strip these top bits out before printing
224 * the si_code.
225 */
226
227 switch (si_code) {
228 case SI_USER:
229 case SI_TKILL:
230 case SI_KERNEL:
231 /* Sent via kill(), tkill() or tgkill(), or direct from the kernel.
232 * These are the only unspoofable si_code values.
233 */
234 __get_user(tinfo->_sifields._kill._pid, &info->_sifields._kill._pid);
235 __get_user(tinfo->_sifields._kill._uid, &info->_sifields._kill._uid);
236 si_type = QEMU_SI_KILL;
237 break;
238 default:
239 /* Everything else is spoofable. Make best guess based on signal */
240 switch (sig) {
241 case TARGET_SIGCHLD:
242 __get_user(tinfo->_sifields._sigchld._pid,
243 &info->_sifields._sigchld._pid);
244 __get_user(tinfo->_sifields._sigchld._uid,
245 &info->_sifields._sigchld._uid);
246 __get_user(tinfo->_sifields._sigchld._status,
247 &info->_sifields._sigchld._status);
248 __get_user(tinfo->_sifields._sigchld._utime,
249 &info->_sifields._sigchld._utime);
250 __get_user(tinfo->_sifields._sigchld._stime,
251 &info->_sifields._sigchld._stime);
252 si_type = QEMU_SI_CHLD;
253 break;
254 case TARGET_SIGIO:
255 __get_user(tinfo->_sifields._sigpoll._band,
256 &info->_sifields._sigpoll._band);
257 __get_user(tinfo->_sifields._sigpoll._fd,
258 &info->_sifields._sigpoll._fd);
259 si_type = QEMU_SI_POLL;
260 break;
261 default:
262 /* Assume a sigqueue()/mq_notify()/rt_sigqueueinfo() source. */
263 __get_user(tinfo->_sifields._rt._pid, &info->_sifields._rt._pid);
264 __get_user(tinfo->_sifields._rt._uid, &info->_sifields._rt._uid);
265 /* XXX: potential problem if 64 bit */
266 __get_user(sival_ptr, &info->_sifields._rt._sigval.sival_ptr);
267 tinfo->_sifields._rt._sigval.sival_ptr = sival_ptr;
268
269 si_type = QEMU_SI_RT;
270 break;
271 }
272 break;
273 }
274
275 tinfo->si_code = deposit32(si_code, 16, 16, si_type);
276}
277
Peter Maydell0cb581d2016-07-18 18:12:24 +0100278static void print_siginfo(const target_siginfo_t *tinfo)
279{
280 /* Print a target_siginfo_t in the format desired for printing
281 * signals being taken. We assume the target_siginfo_t is in the
282 * internal form where the top 16 bits of si_code indicate which
283 * part of the union is valid, rather than in the guest-visible
284 * form where the bottom 16 bits are sign-extended into the top 16.
285 */
286 int si_type = extract32(tinfo->si_code, 16, 16);
287 int si_code = sextract32(tinfo->si_code, 0, 16);
288
Josh Kunz4b25a502020-02-03 18:54:14 -0800289 qemu_log("{si_signo=");
Peter Maydell0cb581d2016-07-18 18:12:24 +0100290 print_signal(tinfo->si_signo, 1);
Josh Kunz4b25a502020-02-03 18:54:14 -0800291 qemu_log(", si_code=");
Peter Maydell0cb581d2016-07-18 18:12:24 +0100292 print_si_code(si_code);
293
294 switch (si_type) {
295 case QEMU_SI_KILL:
Josh Kunz4b25a502020-02-03 18:54:14 -0800296 qemu_log(", si_pid=%u, si_uid=%u",
Peter Maydell0cb581d2016-07-18 18:12:24 +0100297 (unsigned int)tinfo->_sifields._kill._pid,
298 (unsigned int)tinfo->_sifields._kill._uid);
299 break;
300 case QEMU_SI_TIMER:
Josh Kunz4b25a502020-02-03 18:54:14 -0800301 qemu_log(", si_timer1=%u, si_timer2=%u",
Peter Maydell0cb581d2016-07-18 18:12:24 +0100302 tinfo->_sifields._timer._timer1,
303 tinfo->_sifields._timer._timer2);
304 break;
305 case QEMU_SI_POLL:
Josh Kunz4b25a502020-02-03 18:54:14 -0800306 qemu_log(", si_band=%d, si_fd=%d",
Peter Maydell0cb581d2016-07-18 18:12:24 +0100307 tinfo->_sifields._sigpoll._band,
308 tinfo->_sifields._sigpoll._fd);
309 break;
310 case QEMU_SI_FAULT:
Josh Kunz4b25a502020-02-03 18:54:14 -0800311 qemu_log(", si_addr=");
Peter Maydell0cb581d2016-07-18 18:12:24 +0100312 print_pointer(tinfo->_sifields._sigfault._addr, 1);
313 break;
314 case QEMU_SI_CHLD:
Josh Kunz4b25a502020-02-03 18:54:14 -0800315 qemu_log(", si_pid=%u, si_uid=%u, si_status=%d"
Peter Maydell0cb581d2016-07-18 18:12:24 +0100316 ", si_utime=" TARGET_ABI_FMT_ld
317 ", si_stime=" TARGET_ABI_FMT_ld,
318 (unsigned int)(tinfo->_sifields._sigchld._pid),
319 (unsigned int)(tinfo->_sifields._sigchld._uid),
320 tinfo->_sifields._sigchld._status,
321 tinfo->_sifields._sigchld._utime,
322 tinfo->_sifields._sigchld._stime);
323 break;
324 case QEMU_SI_RT:
Josh Kunz4b25a502020-02-03 18:54:14 -0800325 qemu_log(", si_pid=%u, si_uid=%u, si_sigval=" TARGET_ABI_FMT_ld,
Peter Maydell0cb581d2016-07-18 18:12:24 +0100326 (unsigned int)tinfo->_sifields._rt._pid,
327 (unsigned int)tinfo->_sifields._rt._uid,
328 tinfo->_sifields._rt._sigval.sival_ptr);
329 break;
330 default:
331 g_assert_not_reached();
332 }
Josh Kunz4b25a502020-02-03 18:54:14 -0800333 qemu_log("}");
Peter Maydell0cb581d2016-07-18 18:12:24 +0100334}
335
Laurent Vivierfb3aabf2016-06-11 02:19:45 +0200336static void
Philippe Mathieu-Daudé42b15d72019-10-21 13:48:56 +0200337print_sockaddr(abi_ulong addr, abi_long addrlen, int last)
Laurent Vivierfb3aabf2016-06-11 02:19:45 +0200338{
339 struct target_sockaddr *sa;
340 int i;
341 int sa_family;
342
343 sa = lock_user(VERIFY_READ, addr, addrlen, 1);
344 if (sa) {
345 sa_family = tswap16(sa->sa_family);
346 switch (sa_family) {
347 case AF_UNIX: {
348 struct target_sockaddr_un *un = (struct target_sockaddr_un *)sa;
349 int i;
Josh Kunz4b25a502020-02-03 18:54:14 -0800350 qemu_log("{sun_family=AF_UNIX,sun_path=\"");
Laurent Vivierfb3aabf2016-06-11 02:19:45 +0200351 for (i = 0; i < addrlen -
352 offsetof(struct target_sockaddr_un, sun_path) &&
353 un->sun_path[i]; i++) {
Josh Kunz4b25a502020-02-03 18:54:14 -0800354 qemu_log("%c", un->sun_path[i]);
Laurent Vivierfb3aabf2016-06-11 02:19:45 +0200355 }
Josh Kunz4b25a502020-02-03 18:54:14 -0800356 qemu_log("\"}");
Laurent Vivierfb3aabf2016-06-11 02:19:45 +0200357 break;
358 }
359 case AF_INET: {
360 struct target_sockaddr_in *in = (struct target_sockaddr_in *)sa;
361 uint8_t *c = (uint8_t *)&in->sin_addr.s_addr;
Josh Kunz4b25a502020-02-03 18:54:14 -0800362 qemu_log("{sin_family=AF_INET,sin_port=htons(%d),",
Laurent Vivierfb3aabf2016-06-11 02:19:45 +0200363 ntohs(in->sin_port));
Josh Kunz4b25a502020-02-03 18:54:14 -0800364 qemu_log("sin_addr=inet_addr(\"%d.%d.%d.%d\")",
Laurent Vivierfb3aabf2016-06-11 02:19:45 +0200365 c[0], c[1], c[2], c[3]);
Josh Kunz4b25a502020-02-03 18:54:14 -0800366 qemu_log("}");
Laurent Vivierfb3aabf2016-06-11 02:19:45 +0200367 break;
368 }
369 case AF_PACKET: {
370 struct target_sockaddr_ll *ll = (struct target_sockaddr_ll *)sa;
371 uint8_t *c = (uint8_t *)&ll->sll_addr;
Josh Kunz4b25a502020-02-03 18:54:14 -0800372 qemu_log("{sll_family=AF_PACKET,"
Laurent Vivierfb3aabf2016-06-11 02:19:45 +0200373 "sll_protocol=htons(0x%04x),if%d,pkttype=",
374 ntohs(ll->sll_protocol), ll->sll_ifindex);
375 switch (ll->sll_pkttype) {
376 case PACKET_HOST:
Josh Kunz4b25a502020-02-03 18:54:14 -0800377 qemu_log("PACKET_HOST");
Laurent Vivierfb3aabf2016-06-11 02:19:45 +0200378 break;
379 case PACKET_BROADCAST:
Josh Kunz4b25a502020-02-03 18:54:14 -0800380 qemu_log("PACKET_BROADCAST");
Laurent Vivierfb3aabf2016-06-11 02:19:45 +0200381 break;
382 case PACKET_MULTICAST:
Josh Kunz4b25a502020-02-03 18:54:14 -0800383 qemu_log("PACKET_MULTICAST");
Laurent Vivierfb3aabf2016-06-11 02:19:45 +0200384 break;
385 case PACKET_OTHERHOST:
Josh Kunz4b25a502020-02-03 18:54:14 -0800386 qemu_log("PACKET_OTHERHOST");
Laurent Vivierfb3aabf2016-06-11 02:19:45 +0200387 break;
388 case PACKET_OUTGOING:
Josh Kunz4b25a502020-02-03 18:54:14 -0800389 qemu_log("PACKET_OUTGOING");
Laurent Vivierfb3aabf2016-06-11 02:19:45 +0200390 break;
391 default:
Josh Kunz4b25a502020-02-03 18:54:14 -0800392 qemu_log("%d", ll->sll_pkttype);
Laurent Vivierfb3aabf2016-06-11 02:19:45 +0200393 break;
394 }
Josh Kunz4b25a502020-02-03 18:54:14 -0800395 qemu_log(",sll_addr=%02x:%02x:%02x:%02x:%02x:%02x:%02x:%02x",
Laurent Vivierfb3aabf2016-06-11 02:19:45 +0200396 c[0], c[1], c[2], c[3], c[4], c[5], c[6], c[7]);
Josh Kunz4b25a502020-02-03 18:54:14 -0800397 qemu_log("}");
Laurent Vivierfb3aabf2016-06-11 02:19:45 +0200398 break;
399 }
Philippe Mathieu-Daudé814ae702019-10-21 13:48:53 +0200400 case AF_NETLINK: {
401 struct target_sockaddr_nl *nl = (struct target_sockaddr_nl *)sa;
Josh Kunz4b25a502020-02-03 18:54:14 -0800402 qemu_log("{nl_family=AF_NETLINK,nl_pid=%u,nl_groups=%u}",
Philippe Mathieu-Daudé814ae702019-10-21 13:48:53 +0200403 tswap32(nl->nl_pid), tswap32(nl->nl_groups));
404 break;
405 }
Laurent Vivierfb3aabf2016-06-11 02:19:45 +0200406 default:
Josh Kunz4b25a502020-02-03 18:54:14 -0800407 qemu_log("{sa_family=%d, sa_data={", sa->sa_family);
Laurent Vivierfb3aabf2016-06-11 02:19:45 +0200408 for (i = 0; i < 13; i++) {
Josh Kunz4b25a502020-02-03 18:54:14 -0800409 qemu_log("%02x, ", sa->sa_data[i]);
Laurent Vivierfb3aabf2016-06-11 02:19:45 +0200410 }
Josh Kunz4b25a502020-02-03 18:54:14 -0800411 qemu_log("%02x}", sa->sa_data[i]);
412 qemu_log("}");
Laurent Vivierfb3aabf2016-06-11 02:19:45 +0200413 break;
414 }
415 unlock_user(sa, addr, 0);
416 } else {
417 print_raw_param("0x"TARGET_ABI_FMT_lx, addr, 0);
418 }
Josh Kunz4b25a502020-02-03 18:54:14 -0800419 qemu_log(", "TARGET_ABI_FMT_ld"%s", addrlen, get_comma(last));
Laurent Vivierfb3aabf2016-06-11 02:19:45 +0200420}
421
422static void
423print_socket_domain(int domain)
424{
425 switch (domain) {
426 case PF_UNIX:
Josh Kunz4b25a502020-02-03 18:54:14 -0800427 qemu_log("PF_UNIX");
Laurent Vivierfb3aabf2016-06-11 02:19:45 +0200428 break;
429 case PF_INET:
Josh Kunz4b25a502020-02-03 18:54:14 -0800430 qemu_log("PF_INET");
Laurent Vivierfb3aabf2016-06-11 02:19:45 +0200431 break;
Philippe Mathieu-Daudé814ae702019-10-21 13:48:53 +0200432 case PF_NETLINK:
Josh Kunz4b25a502020-02-03 18:54:14 -0800433 qemu_log("PF_NETLINK");
Philippe Mathieu-Daudé814ae702019-10-21 13:48:53 +0200434 break;
Laurent Vivierfb3aabf2016-06-11 02:19:45 +0200435 case PF_PACKET:
Josh Kunz4b25a502020-02-03 18:54:14 -0800436 qemu_log("PF_PACKET");
Laurent Vivierfb3aabf2016-06-11 02:19:45 +0200437 break;
438 default:
Josh Kunz4b25a502020-02-03 18:54:14 -0800439 qemu_log("%d", domain);
Laurent Vivierfb3aabf2016-06-11 02:19:45 +0200440 break;
441 }
442}
443
444static void
445print_socket_type(int type)
446{
Laurent Vivier2039b1b2020-03-12 17:55:30 +0100447 switch (type & TARGET_SOCK_TYPE_MASK) {
Laurent Vivierfb3aabf2016-06-11 02:19:45 +0200448 case TARGET_SOCK_DGRAM:
Josh Kunz4b25a502020-02-03 18:54:14 -0800449 qemu_log("SOCK_DGRAM");
Laurent Vivierfb3aabf2016-06-11 02:19:45 +0200450 break;
451 case TARGET_SOCK_STREAM:
Josh Kunz4b25a502020-02-03 18:54:14 -0800452 qemu_log("SOCK_STREAM");
Laurent Vivierfb3aabf2016-06-11 02:19:45 +0200453 break;
454 case TARGET_SOCK_RAW:
Josh Kunz4b25a502020-02-03 18:54:14 -0800455 qemu_log("SOCK_RAW");
Laurent Vivierfb3aabf2016-06-11 02:19:45 +0200456 break;
457 case TARGET_SOCK_RDM:
Josh Kunz4b25a502020-02-03 18:54:14 -0800458 qemu_log("SOCK_RDM");
Laurent Vivierfb3aabf2016-06-11 02:19:45 +0200459 break;
460 case TARGET_SOCK_SEQPACKET:
Josh Kunz4b25a502020-02-03 18:54:14 -0800461 qemu_log("SOCK_SEQPACKET");
Laurent Vivierfb3aabf2016-06-11 02:19:45 +0200462 break;
463 case TARGET_SOCK_PACKET:
Josh Kunz4b25a502020-02-03 18:54:14 -0800464 qemu_log("SOCK_PACKET");
Laurent Vivierfb3aabf2016-06-11 02:19:45 +0200465 break;
466 }
Laurent Vivier2039b1b2020-03-12 17:55:30 +0100467 if (type & TARGET_SOCK_CLOEXEC) {
468 qemu_log("|SOCK_CLOEXEC");
469 }
470 if (type & TARGET_SOCK_NONBLOCK) {
471 qemu_log("|SOCK_NONBLOCK");
472 }
Laurent Vivierfb3aabf2016-06-11 02:19:45 +0200473}
474
475static void
476print_socket_protocol(int domain, int type, int protocol)
477{
478 if (domain == AF_PACKET ||
479 (domain == AF_INET && type == TARGET_SOCK_PACKET)) {
480 switch (protocol) {
481 case 0x0003:
Josh Kunz4b25a502020-02-03 18:54:14 -0800482 qemu_log("ETH_P_ALL");
Laurent Vivierfb3aabf2016-06-11 02:19:45 +0200483 break;
484 default:
Josh Kunz4b25a502020-02-03 18:54:14 -0800485 qemu_log("%d", protocol);
Laurent Vivierfb3aabf2016-06-11 02:19:45 +0200486 }
487 return;
488 }
489
Philippe Mathieu-Daudé814ae702019-10-21 13:48:53 +0200490 if (domain == PF_NETLINK) {
491 switch (protocol) {
492 case NETLINK_ROUTE:
Josh Kunz4b25a502020-02-03 18:54:14 -0800493 qemu_log("NETLINK_ROUTE");
Philippe Mathieu-Daudé814ae702019-10-21 13:48:53 +0200494 break;
495 case NETLINK_AUDIT:
Josh Kunz4b25a502020-02-03 18:54:14 -0800496 qemu_log("NETLINK_AUDIT");
Philippe Mathieu-Daudé814ae702019-10-21 13:48:53 +0200497 break;
498 case NETLINK_NETFILTER:
Josh Kunz4b25a502020-02-03 18:54:14 -0800499 qemu_log("NETLINK_NETFILTER");
Philippe Mathieu-Daudé814ae702019-10-21 13:48:53 +0200500 break;
501 case NETLINK_KOBJECT_UEVENT:
Josh Kunz4b25a502020-02-03 18:54:14 -0800502 qemu_log("NETLINK_KOBJECT_UEVENT");
Philippe Mathieu-Daudé814ae702019-10-21 13:48:53 +0200503 break;
504 case NETLINK_RDMA:
Josh Kunz4b25a502020-02-03 18:54:14 -0800505 qemu_log("NETLINK_RDMA");
Philippe Mathieu-Daudé814ae702019-10-21 13:48:53 +0200506 break;
507 case NETLINK_CRYPTO:
Josh Kunz4b25a502020-02-03 18:54:14 -0800508 qemu_log("NETLINK_CRYPTO");
Philippe Mathieu-Daudé814ae702019-10-21 13:48:53 +0200509 break;
510 default:
Josh Kunz4b25a502020-02-03 18:54:14 -0800511 qemu_log("%d", protocol);
Philippe Mathieu-Daudé814ae702019-10-21 13:48:53 +0200512 break;
513 }
514 return;
515 }
516
Laurent Vivierfb3aabf2016-06-11 02:19:45 +0200517 switch (protocol) {
518 case IPPROTO_IP:
Josh Kunz4b25a502020-02-03 18:54:14 -0800519 qemu_log("IPPROTO_IP");
Laurent Vivierfb3aabf2016-06-11 02:19:45 +0200520 break;
521 case IPPROTO_TCP:
Josh Kunz4b25a502020-02-03 18:54:14 -0800522 qemu_log("IPPROTO_TCP");
Laurent Vivierfb3aabf2016-06-11 02:19:45 +0200523 break;
524 case IPPROTO_UDP:
Josh Kunz4b25a502020-02-03 18:54:14 -0800525 qemu_log("IPPROTO_UDP");
Laurent Vivierfb3aabf2016-06-11 02:19:45 +0200526 break;
527 case IPPROTO_RAW:
Josh Kunz4b25a502020-02-03 18:54:14 -0800528 qemu_log("IPPROTO_RAW");
Laurent Vivierfb3aabf2016-06-11 02:19:45 +0200529 break;
530 default:
Josh Kunz4b25a502020-02-03 18:54:14 -0800531 qemu_log("%d", protocol);
Laurent Vivierfb3aabf2016-06-11 02:19:45 +0200532 break;
533 }
534}
535
536
bellardc16f9ed2007-11-11 17:23:29 +0000537#ifdef TARGET_NR__newselect
ths33189d32007-11-01 00:13:36 +0000538static void
bellardc16f9ed2007-11-11 17:23:29 +0000539print_fdset(int n, abi_ulong target_fds_addr)
ths33189d32007-11-01 00:13:36 +0000540{
541 int i;
542
Josh Kunz4b25a502020-02-03 18:54:14 -0800543 qemu_log("[");
ths33189d32007-11-01 00:13:36 +0000544 if( target_fds_addr ) {
bellard579a97f2007-11-11 14:26:47 +0000545 abi_long *target_fds;
ths33189d32007-11-01 00:13:36 +0000546
bellard579a97f2007-11-11 14:26:47 +0000547 target_fds = lock_user(VERIFY_READ,
548 target_fds_addr,
549 sizeof(*target_fds)*(n / TARGET_ABI_BITS + 1),
550 1);
551
552 if (!target_fds)
ths33189d32007-11-01 00:13:36 +0000553 return;
554
ths33189d32007-11-01 00:13:36 +0000555 for (i=n; i>=0; i--) {
Matthias Brauncbb21ee2011-08-12 19:57:41 +0200556 if ((tswapal(target_fds[i / TARGET_ABI_BITS]) >> (i & (TARGET_ABI_BITS - 1))) & 1)
Josh Kunz4b25a502020-02-03 18:54:14 -0800557 qemu_log("%d,", i);
ths33189d32007-11-01 00:13:36 +0000558 }
559 unlock_user(target_fds, target_fds_addr, 0);
560 }
Josh Kunz4b25a502020-02-03 18:54:14 -0800561 qemu_log("]");
ths33189d32007-11-01 00:13:36 +0000562}
bellardc16f9ed2007-11-11 17:23:29 +0000563#endif
ths33189d32007-11-01 00:13:36 +0000564
Aleksandar Markovic38860a02016-10-10 13:23:29 +0200565#ifdef TARGET_NR_clock_adjtime
566/* IDs of the various system clocks */
567#define TARGET_CLOCK_REALTIME 0
568#define TARGET_CLOCK_MONOTONIC 1
569#define TARGET_CLOCK_PROCESS_CPUTIME_ID 2
570#define TARGET_CLOCK_THREAD_CPUTIME_ID 3
571#define TARGET_CLOCK_MONOTONIC_RAW 4
572#define TARGET_CLOCK_REALTIME_COARSE 5
573#define TARGET_CLOCK_MONOTONIC_COARSE 6
574#define TARGET_CLOCK_BOOTTIME 7
575#define TARGET_CLOCK_REALTIME_ALARM 8
576#define TARGET_CLOCK_BOOTTIME_ALARM 9
577#define TARGET_CLOCK_SGI_CYCLE 10
578#define TARGET_CLOCK_TAI 11
579
580static void
581print_clockid(int clockid, int last)
582{
583 switch (clockid) {
584 case TARGET_CLOCK_REALTIME:
Josh Kunz4b25a502020-02-03 18:54:14 -0800585 qemu_log("CLOCK_REALTIME");
Aleksandar Markovic38860a02016-10-10 13:23:29 +0200586 break;
587 case TARGET_CLOCK_MONOTONIC:
Josh Kunz4b25a502020-02-03 18:54:14 -0800588 qemu_log("CLOCK_MONOTONIC");
Aleksandar Markovic38860a02016-10-10 13:23:29 +0200589 break;
590 case TARGET_CLOCK_PROCESS_CPUTIME_ID:
Josh Kunz4b25a502020-02-03 18:54:14 -0800591 qemu_log("CLOCK_PROCESS_CPUTIME_ID");
Aleksandar Markovic38860a02016-10-10 13:23:29 +0200592 break;
593 case TARGET_CLOCK_THREAD_CPUTIME_ID:
Josh Kunz4b25a502020-02-03 18:54:14 -0800594 qemu_log("CLOCK_THREAD_CPUTIME_ID");
Aleksandar Markovic38860a02016-10-10 13:23:29 +0200595 break;
596 case TARGET_CLOCK_MONOTONIC_RAW:
Josh Kunz4b25a502020-02-03 18:54:14 -0800597 qemu_log("CLOCK_MONOTONIC_RAW");
Aleksandar Markovic38860a02016-10-10 13:23:29 +0200598 break;
599 case TARGET_CLOCK_REALTIME_COARSE:
Josh Kunz4b25a502020-02-03 18:54:14 -0800600 qemu_log("CLOCK_REALTIME_COARSE");
Aleksandar Markovic38860a02016-10-10 13:23:29 +0200601 break;
602 case TARGET_CLOCK_MONOTONIC_COARSE:
Josh Kunz4b25a502020-02-03 18:54:14 -0800603 qemu_log("CLOCK_MONOTONIC_COARSE");
Aleksandar Markovic38860a02016-10-10 13:23:29 +0200604 break;
605 case TARGET_CLOCK_BOOTTIME:
Josh Kunz4b25a502020-02-03 18:54:14 -0800606 qemu_log("CLOCK_BOOTTIME");
Aleksandar Markovic38860a02016-10-10 13:23:29 +0200607 break;
608 case TARGET_CLOCK_REALTIME_ALARM:
Josh Kunz4b25a502020-02-03 18:54:14 -0800609 qemu_log("CLOCK_REALTIME_ALARM");
Aleksandar Markovic38860a02016-10-10 13:23:29 +0200610 break;
611 case TARGET_CLOCK_BOOTTIME_ALARM:
Josh Kunz4b25a502020-02-03 18:54:14 -0800612 qemu_log("CLOCK_BOOTTIME_ALARM");
Aleksandar Markovic38860a02016-10-10 13:23:29 +0200613 break;
614 case TARGET_CLOCK_SGI_CYCLE:
Josh Kunz4b25a502020-02-03 18:54:14 -0800615 qemu_log("CLOCK_SGI_CYCLE");
Aleksandar Markovic38860a02016-10-10 13:23:29 +0200616 break;
617 case TARGET_CLOCK_TAI:
Josh Kunz4b25a502020-02-03 18:54:14 -0800618 qemu_log("CLOCK_TAI");
Aleksandar Markovic38860a02016-10-10 13:23:29 +0200619 break;
620 default:
Josh Kunz4b25a502020-02-03 18:54:14 -0800621 qemu_log("%d", clockid);
Aleksandar Markovic38860a02016-10-10 13:23:29 +0200622 break;
623 }
Josh Kunz4b25a502020-02-03 18:54:14 -0800624 qemu_log("%s", get_comma(last));
Aleksandar Markovic38860a02016-10-10 13:23:29 +0200625}
626#endif
627
ths33189d32007-11-01 00:13:36 +0000628/*
629 * Sysycall specific output functions
630 */
631
632/* select */
bellardc16f9ed2007-11-11 17:23:29 +0000633#ifdef TARGET_NR__newselect
ths33189d32007-11-01 00:13:36 +0000634static long newselect_arg1 = 0;
635static long newselect_arg2 = 0;
636static long newselect_arg3 = 0;
637static long newselect_arg4 = 0;
638static long newselect_arg5 = 0;
639
640static void
blueswir17ccfb2e2008-09-14 06:45:34 +0000641print_newselect(const struct syscallname *name,
bellardc16f9ed2007-11-11 17:23:29 +0000642 abi_long arg1, abi_long arg2, abi_long arg3,
643 abi_long arg4, abi_long arg5, abi_long arg6)
ths33189d32007-11-01 00:13:36 +0000644{
Josh Kunz4b25a502020-02-03 18:54:14 -0800645 qemu_log("%s(" TARGET_ABI_FMT_ld ",", name->name, arg1);
ths33189d32007-11-01 00:13:36 +0000646 print_fdset(arg1, arg2);
Josh Kunz4b25a502020-02-03 18:54:14 -0800647 qemu_log(",");
ths33189d32007-11-01 00:13:36 +0000648 print_fdset(arg1, arg3);
Josh Kunz4b25a502020-02-03 18:54:14 -0800649 qemu_log(",");
ths33189d32007-11-01 00:13:36 +0000650 print_fdset(arg1, arg4);
Josh Kunz4b25a502020-02-03 18:54:14 -0800651 qemu_log(",");
Mika Westerberg74d753a2009-04-07 16:57:29 +0300652 print_timeval(arg5, 1);
Josh Kunz4b25a502020-02-03 18:54:14 -0800653 qemu_log(")");
ths33189d32007-11-01 00:13:36 +0000654
655 /* save for use in the return output function below */
656 newselect_arg1=arg1;
657 newselect_arg2=arg2;
658 newselect_arg3=arg3;
659 newselect_arg4=arg4;
660 newselect_arg5=arg5;
661}
bellardc16f9ed2007-11-11 17:23:29 +0000662#endif
ths33189d32007-11-01 00:13:36 +0000663
blueswir13e46b2e2008-10-03 19:01:41 +0000664#ifdef TARGET_NR_semctl
ths33189d32007-11-01 00:13:36 +0000665static void
blueswir17ccfb2e2008-09-14 06:45:34 +0000666print_semctl(const struct syscallname *name,
bellardc16f9ed2007-11-11 17:23:29 +0000667 abi_long arg1, abi_long arg2, abi_long arg3,
668 abi_long arg4, abi_long arg5, abi_long arg6)
ths33189d32007-11-01 00:13:36 +0000669{
Josh Kunz4b25a502020-02-03 18:54:14 -0800670 qemu_log("%s(" TARGET_ABI_FMT_ld "," TARGET_ABI_FMT_ld ",",
671 name->name, arg1, arg2);
ths33189d32007-11-01 00:13:36 +0000672 print_ipc_cmd(arg3);
Josh Kunz4b25a502020-02-03 18:54:14 -0800673 qemu_log(",0x" TARGET_ABI_FMT_lx ")", arg4);
ths33189d32007-11-01 00:13:36 +0000674}
blueswir13e46b2e2008-10-03 19:01:41 +0000675#endif
ths33189d32007-11-01 00:13:36 +0000676
677static void
blueswir17ccfb2e2008-09-14 06:45:34 +0000678print_execve(const struct syscallname *name,
bellardc16f9ed2007-11-11 17:23:29 +0000679 abi_long arg1, abi_long arg2, abi_long arg3,
680 abi_long arg4, abi_long arg5, abi_long arg6)
ths33189d32007-11-01 00:13:36 +0000681{
bellardc16f9ed2007-11-11 17:23:29 +0000682 abi_ulong arg_ptr_addr;
ths33189d32007-11-01 00:13:36 +0000683 char *s;
684
bellard579a97f2007-11-11 14:26:47 +0000685 if (!(s = lock_user_string(arg1)))
ths33189d32007-11-01 00:13:36 +0000686 return;
Josh Kunz4b25a502020-02-03 18:54:14 -0800687 qemu_log("%s(\"%s\",{", name->name, s);
ths33189d32007-11-01 00:13:36 +0000688 unlock_user(s, arg1, 0);
689
bellardc16f9ed2007-11-11 17:23:29 +0000690 for (arg_ptr_addr = arg2; ; arg_ptr_addr += sizeof(abi_ulong)) {
blueswir198448f52008-09-30 18:16:09 +0000691 abi_ulong *arg_ptr, arg_addr;
ths33189d32007-11-01 00:13:36 +0000692
Paolo Bonzini7d374352018-12-13 23:37:37 +0100693 arg_ptr = lock_user(VERIFY_READ, arg_ptr_addr, sizeof(abi_ulong), 1);
bellard579a97f2007-11-11 14:26:47 +0000694 if (!arg_ptr)
ths33189d32007-11-01 00:13:36 +0000695 return;
Matthias Brauncbb21ee2011-08-12 19:57:41 +0200696 arg_addr = tswapal(*arg_ptr);
Paolo Bonzini7d374352018-12-13 23:37:37 +0100697 unlock_user(arg_ptr, arg_ptr_addr, 0);
ths33189d32007-11-01 00:13:36 +0000698 if (!arg_addr)
699 break;
bellard579a97f2007-11-11 14:26:47 +0000700 if ((s = lock_user_string(arg_addr))) {
Josh Kunz4b25a502020-02-03 18:54:14 -0800701 qemu_log("\"%s\",", s);
blueswir198448f52008-09-30 18:16:09 +0000702 unlock_user(s, arg_addr, 0);
bellard579a97f2007-11-11 14:26:47 +0000703 }
ths33189d32007-11-01 00:13:36 +0000704 }
705
Josh Kunz4b25a502020-02-03 18:54:14 -0800706 qemu_log("NULL})");
ths33189d32007-11-01 00:13:36 +0000707}
708
bellardc16f9ed2007-11-11 17:23:29 +0000709#ifdef TARGET_NR_ipc
ths33189d32007-11-01 00:13:36 +0000710static void
blueswir17ccfb2e2008-09-14 06:45:34 +0000711print_ipc(const struct syscallname *name,
bellardc16f9ed2007-11-11 17:23:29 +0000712 abi_long arg1, abi_long arg2, abi_long arg3,
713 abi_long arg4, abi_long arg5, abi_long arg6)
ths33189d32007-11-01 00:13:36 +0000714{
715 switch(arg1) {
716 case IPCOP_semctl:
Josh Kunz4b25a502020-02-03 18:54:14 -0800717 qemu_log("semctl(" TARGET_ABI_FMT_ld "," TARGET_ABI_FMT_ld ",",
718 arg1, arg2);
blueswir17ccfb2e2008-09-14 06:45:34 +0000719 print_ipc_cmd(arg3);
Josh Kunz4b25a502020-02-03 18:54:14 -0800720 qemu_log(",0x" TARGET_ABI_FMT_lx ")", arg4);
ths33189d32007-11-01 00:13:36 +0000721 break;
722 default:
Josh Kunz4b25a502020-02-03 18:54:14 -0800723 qemu_log(("%s("
724 TARGET_ABI_FMT_ld ","
725 TARGET_ABI_FMT_ld ","
726 TARGET_ABI_FMT_ld ","
727 TARGET_ABI_FMT_ld
728 ")"),
ths33189d32007-11-01 00:13:36 +0000729 name->name, arg1, arg2, arg3, arg4);
730 }
731}
bellardc16f9ed2007-11-11 17:23:29 +0000732#endif
ths33189d32007-11-01 00:13:36 +0000733
734/*
735 * Variants for the return value output function
736 */
737
738static void
blueswir17ccfb2e2008-09-14 06:45:34 +0000739print_syscall_ret_addr(const struct syscallname *name, abi_long ret)
ths33189d32007-11-01 00:13:36 +0000740{
Peter Maydell7dcdaea2016-06-06 19:58:18 +0100741 const char *errstr = NULL;
Alexander Graf962b2892011-11-21 12:04:07 +0100742
Peter Maydell2a7e1242011-11-21 12:21:19 +0000743 if (ret < 0) {
744 errstr = target_strerror(-ret);
Alexander Graf962b2892011-11-21 12:04:07 +0100745 }
Peter Maydell2a7e1242011-11-21 12:21:19 +0000746 if (errstr) {
Josh Kunz4b25a502020-02-03 18:54:14 -0800747 qemu_log(" = -1 errno=%d (%s)\n", (int)-ret, errstr);
ths33189d32007-11-01 00:13:36 +0000748 } else {
Josh Kunz4b25a502020-02-03 18:54:14 -0800749 qemu_log(" = 0x" TARGET_ABI_FMT_lx "\n", ret);
ths33189d32007-11-01 00:13:36 +0000750 }
751}
752
thsf3e32852007-11-03 15:12:16 +0000753#if 0 /* currently unused */
ths33189d32007-11-01 00:13:36 +0000754static void
bellardc16f9ed2007-11-11 17:23:29 +0000755print_syscall_ret_raw(struct syscallname *name, abi_long ret)
ths33189d32007-11-01 00:13:36 +0000756{
Josh Kunz4b25a502020-02-03 18:54:14 -0800757 qemu_log(" = 0x" TARGET_ABI_FMT_lx "\n", ret);
ths33189d32007-11-01 00:13:36 +0000758}
thsf3e32852007-11-03 15:12:16 +0000759#endif
ths33189d32007-11-01 00:13:36 +0000760
thsf3e32852007-11-03 15:12:16 +0000761#ifdef TARGET_NR__newselect
ths33189d32007-11-01 00:13:36 +0000762static void
blueswir17ccfb2e2008-09-14 06:45:34 +0000763print_syscall_ret_newselect(const struct syscallname *name, abi_long ret)
ths33189d32007-11-01 00:13:36 +0000764{
Josh Kunz4b25a502020-02-03 18:54:14 -0800765 qemu_log(" = 0x" TARGET_ABI_FMT_lx " (", ret);
ths33189d32007-11-01 00:13:36 +0000766 print_fdset(newselect_arg1,newselect_arg2);
Josh Kunz4b25a502020-02-03 18:54:14 -0800767 qemu_log(",");
ths33189d32007-11-01 00:13:36 +0000768 print_fdset(newselect_arg1,newselect_arg3);
Josh Kunz4b25a502020-02-03 18:54:14 -0800769 qemu_log(",");
ths33189d32007-11-01 00:13:36 +0000770 print_fdset(newselect_arg1,newselect_arg4);
Josh Kunz4b25a502020-02-03 18:54:14 -0800771 qemu_log(",");
Mika Westerberg74d753a2009-04-07 16:57:29 +0300772 print_timeval(newselect_arg5, 1);
Josh Kunz4b25a502020-02-03 18:54:14 -0800773 qemu_log(")\n");
ths33189d32007-11-01 00:13:36 +0000774}
thsf3e32852007-11-03 15:12:16 +0000775#endif
ths33189d32007-11-01 00:13:36 +0000776
Aleksandar Markovic19f59bc2016-09-22 18:56:50 +0200777/* special meanings of adjtimex()' non-negative return values */
778#define TARGET_TIME_OK 0 /* clock synchronized, no leap second */
779#define TARGET_TIME_INS 1 /* insert leap second */
780#define TARGET_TIME_DEL 2 /* delete leap second */
781#define TARGET_TIME_OOP 3 /* leap second in progress */
782#define TARGET_TIME_WAIT 4 /* leap second has occurred */
783#define TARGET_TIME_ERROR 5 /* clock not synchronized */
784static void
785print_syscall_ret_adjtimex(const struct syscallname *name, abi_long ret)
786{
787 const char *errstr = NULL;
788
Josh Kunz4b25a502020-02-03 18:54:14 -0800789 qemu_log(" = ");
Aleksandar Markovic19f59bc2016-09-22 18:56:50 +0200790 if (ret < 0) {
Josh Kunz4b25a502020-02-03 18:54:14 -0800791 qemu_log("-1 errno=%d", errno);
Aleksandar Markovic19f59bc2016-09-22 18:56:50 +0200792 errstr = target_strerror(-ret);
793 if (errstr) {
Josh Kunz4b25a502020-02-03 18:54:14 -0800794 qemu_log(" (%s)", errstr);
Aleksandar Markovic19f59bc2016-09-22 18:56:50 +0200795 }
796 } else {
Josh Kunz4b25a502020-02-03 18:54:14 -0800797 qemu_log(TARGET_ABI_FMT_ld, ret);
Aleksandar Markovic19f59bc2016-09-22 18:56:50 +0200798 switch (ret) {
799 case TARGET_TIME_OK:
Josh Kunz4b25a502020-02-03 18:54:14 -0800800 qemu_log(" TIME_OK (clock synchronized, no leap second)");
Aleksandar Markovic19f59bc2016-09-22 18:56:50 +0200801 break;
802 case TARGET_TIME_INS:
Josh Kunz4b25a502020-02-03 18:54:14 -0800803 qemu_log(" TIME_INS (insert leap second)");
Aleksandar Markovic19f59bc2016-09-22 18:56:50 +0200804 break;
805 case TARGET_TIME_DEL:
Josh Kunz4b25a502020-02-03 18:54:14 -0800806 qemu_log(" TIME_DEL (delete leap second)");
Aleksandar Markovic19f59bc2016-09-22 18:56:50 +0200807 break;
808 case TARGET_TIME_OOP:
Josh Kunz4b25a502020-02-03 18:54:14 -0800809 qemu_log(" TIME_OOP (leap second in progress)");
Aleksandar Markovic19f59bc2016-09-22 18:56:50 +0200810 break;
811 case TARGET_TIME_WAIT:
Josh Kunz4b25a502020-02-03 18:54:14 -0800812 qemu_log(" TIME_WAIT (leap second has occurred)");
Aleksandar Markovic19f59bc2016-09-22 18:56:50 +0200813 break;
814 case TARGET_TIME_ERROR:
Josh Kunz4b25a502020-02-03 18:54:14 -0800815 qemu_log(" TIME_ERROR (clock not synchronized)");
Aleksandar Markovic19f59bc2016-09-22 18:56:50 +0200816 break;
817 }
818 }
819
Josh Kunz4b25a502020-02-03 18:54:14 -0800820 qemu_log("\n");
Aleksandar Markovic19f59bc2016-09-22 18:56:50 +0200821}
822
Mika Westerberg74d753a2009-04-07 16:57:29 +0300823UNUSED static struct flags access_flags[] = {
824 FLAG_GENERIC(F_OK),
825 FLAG_GENERIC(R_OK),
826 FLAG_GENERIC(W_OK),
827 FLAG_GENERIC(X_OK),
828 FLAG_END,
829};
830
831UNUSED static struct flags at_file_flags[] = {
832#ifdef AT_EACCESS
833 FLAG_GENERIC(AT_EACCESS),
834#endif
835#ifdef AT_SYMLINK_NOFOLLOW
836 FLAG_GENERIC(AT_SYMLINK_NOFOLLOW),
837#endif
838 FLAG_END,
839};
840
841UNUSED static struct flags unlinkat_flags[] = {
842#ifdef AT_REMOVEDIR
843 FLAG_GENERIC(AT_REMOVEDIR),
844#endif
845 FLAG_END,
846};
847
848UNUSED static struct flags mode_flags[] = {
849 FLAG_GENERIC(S_IFSOCK),
850 FLAG_GENERIC(S_IFLNK),
851 FLAG_GENERIC(S_IFREG),
852 FLAG_GENERIC(S_IFBLK),
853 FLAG_GENERIC(S_IFDIR),
854 FLAG_GENERIC(S_IFCHR),
855 FLAG_GENERIC(S_IFIFO),
856 FLAG_END,
857};
858
859UNUSED static struct flags open_access_flags[] = {
860 FLAG_TARGET(O_RDONLY),
861 FLAG_TARGET(O_WRONLY),
862 FLAG_TARGET(O_RDWR),
863 FLAG_END,
864};
865
866UNUSED static struct flags open_flags[] = {
867 FLAG_TARGET(O_APPEND),
868 FLAG_TARGET(O_CREAT),
869 FLAG_TARGET(O_DIRECTORY),
870 FLAG_TARGET(O_EXCL),
871 FLAG_TARGET(O_LARGEFILE),
872 FLAG_TARGET(O_NOCTTY),
873 FLAG_TARGET(O_NOFOLLOW),
874 FLAG_TARGET(O_NONBLOCK), /* also O_NDELAY */
Richard Hendersonafc87632012-07-25 14:30:34 -0700875 FLAG_TARGET(O_DSYNC),
876 FLAG_TARGET(__O_SYNC),
Mika Westerberg74d753a2009-04-07 16:57:29 +0300877 FLAG_TARGET(O_TRUNC),
878#ifdef O_DIRECT
879 FLAG_TARGET(O_DIRECT),
880#endif
Richard Hendersonafc87632012-07-25 14:30:34 -0700881#ifdef O_NOATIME
882 FLAG_TARGET(O_NOATIME),
883#endif
884#ifdef O_CLOEXEC
885 FLAG_TARGET(O_CLOEXEC),
886#endif
887#ifdef O_PATH
888 FLAG_TARGET(O_PATH),
889#endif
Riku Voipio5f9cee42017-08-08 16:01:19 +0300890#ifdef O_TMPFILE
891 FLAG_TARGET(O_TMPFILE),
892 FLAG_TARGET(__O_TMPFILE),
893#endif
Mika Westerberg74d753a2009-04-07 16:57:29 +0300894 FLAG_END,
895};
896
897UNUSED static struct flags mount_flags[] = {
898#ifdef MS_BIND
899 FLAG_GENERIC(MS_BIND),
900#endif
901#ifdef MS_DIRSYNC
902 FLAG_GENERIC(MS_DIRSYNC),
903#endif
904 FLAG_GENERIC(MS_MANDLOCK),
905#ifdef MS_MOVE
906 FLAG_GENERIC(MS_MOVE),
907#endif
908 FLAG_GENERIC(MS_NOATIME),
909 FLAG_GENERIC(MS_NODEV),
910 FLAG_GENERIC(MS_NODIRATIME),
911 FLAG_GENERIC(MS_NOEXEC),
912 FLAG_GENERIC(MS_NOSUID),
913 FLAG_GENERIC(MS_RDONLY),
914#ifdef MS_RELATIME
915 FLAG_GENERIC(MS_RELATIME),
916#endif
917 FLAG_GENERIC(MS_REMOUNT),
918 FLAG_GENERIC(MS_SYNCHRONOUS),
919 FLAG_END,
920};
921
922UNUSED static struct flags umount2_flags[] = {
923#ifdef MNT_FORCE
924 FLAG_GENERIC(MNT_FORCE),
925#endif
926#ifdef MNT_DETACH
927 FLAG_GENERIC(MNT_DETACH),
928#endif
929#ifdef MNT_EXPIRE
930 FLAG_GENERIC(MNT_EXPIRE),
931#endif
932 FLAG_END,
933};
934
935UNUSED static struct flags mmap_prot_flags[] = {
936 FLAG_GENERIC(PROT_NONE),
937 FLAG_GENERIC(PROT_EXEC),
938 FLAG_GENERIC(PROT_READ),
939 FLAG_GENERIC(PROT_WRITE),
Paul Brook9e0b74a2010-06-16 13:03:51 +0100940 FLAG_TARGET(PROT_SEM),
941 FLAG_GENERIC(PROT_GROWSDOWN),
942 FLAG_GENERIC(PROT_GROWSUP),
Mika Westerberg74d753a2009-04-07 16:57:29 +0300943 FLAG_END,
944};
945
946UNUSED static struct flags mmap_flags[] = {
947 FLAG_TARGET(MAP_SHARED),
948 FLAG_TARGET(MAP_PRIVATE),
949 FLAG_TARGET(MAP_ANONYMOUS),
950 FLAG_TARGET(MAP_DENYWRITE),
951 FLAG_TARGET(MAP_FIXED),
952 FLAG_TARGET(MAP_GROWSDOWN),
Mike Frysinger906c1b82011-02-07 01:05:52 -0500953 FLAG_TARGET(MAP_EXECUTABLE),
Mika Westerberg74d753a2009-04-07 16:57:29 +0300954#ifdef MAP_LOCKED
955 FLAG_TARGET(MAP_LOCKED),
956#endif
957#ifdef MAP_NONBLOCK
958 FLAG_TARGET(MAP_NONBLOCK),
959#endif
960 FLAG_TARGET(MAP_NORESERVE),
961#ifdef MAP_POPULATE
962 FLAG_TARGET(MAP_POPULATE),
963#endif
Mike Frysinger906c1b82011-02-07 01:05:52 -0500964#ifdef TARGET_MAP_UNINITIALIZED
965 FLAG_TARGET(MAP_UNINITIALIZED),
966#endif
Mika Westerberg74d753a2009-04-07 16:57:29 +0300967 FLAG_END,
968};
969
Laurent Vivier608e5592011-04-07 00:25:32 +0200970UNUSED static struct flags clone_flags[] = {
971 FLAG_GENERIC(CLONE_VM),
972 FLAG_GENERIC(CLONE_FS),
973 FLAG_GENERIC(CLONE_FILES),
974 FLAG_GENERIC(CLONE_SIGHAND),
975 FLAG_GENERIC(CLONE_PTRACE),
976 FLAG_GENERIC(CLONE_VFORK),
977 FLAG_GENERIC(CLONE_PARENT),
978 FLAG_GENERIC(CLONE_THREAD),
979 FLAG_GENERIC(CLONE_NEWNS),
980 FLAG_GENERIC(CLONE_SYSVSEM),
981 FLAG_GENERIC(CLONE_SETTLS),
982 FLAG_GENERIC(CLONE_PARENT_SETTID),
983 FLAG_GENERIC(CLONE_CHILD_CLEARTID),
984 FLAG_GENERIC(CLONE_DETACHED),
985 FLAG_GENERIC(CLONE_UNTRACED),
986 FLAG_GENERIC(CLONE_CHILD_SETTID),
Stefan Weil6f11f012011-04-27 10:44:38 +0200987#if defined(CLONE_NEWUTS)
Laurent Vivier608e5592011-04-07 00:25:32 +0200988 FLAG_GENERIC(CLONE_NEWUTS),
Stefan Weil6f11f012011-04-27 10:44:38 +0200989#endif
990#if defined(CLONE_NEWIPC)
Laurent Vivier608e5592011-04-07 00:25:32 +0200991 FLAG_GENERIC(CLONE_NEWIPC),
Stefan Weil6f11f012011-04-27 10:44:38 +0200992#endif
993#if defined(CLONE_NEWUSER)
Laurent Vivier608e5592011-04-07 00:25:32 +0200994 FLAG_GENERIC(CLONE_NEWUSER),
Stefan Weil6f11f012011-04-27 10:44:38 +0200995#endif
996#if defined(CLONE_NEWPID)
Laurent Vivier608e5592011-04-07 00:25:32 +0200997 FLAG_GENERIC(CLONE_NEWPID),
Stefan Weil6f11f012011-04-27 10:44:38 +0200998#endif
999#if defined(CLONE_NEWNET)
Laurent Vivier608e5592011-04-07 00:25:32 +02001000 FLAG_GENERIC(CLONE_NEWNET),
Stefan Weil6f11f012011-04-27 10:44:38 +02001001#endif
1002#if defined(CLONE_IO)
Laurent Vivier608e5592011-04-07 00:25:32 +02001003 FLAG_GENERIC(CLONE_IO),
Stefan Weil6f11f012011-04-27 10:44:38 +02001004#endif
Laurent Vivier608e5592011-04-07 00:25:32 +02001005 FLAG_END,
1006};
1007
Laurent Vivierfb3aabf2016-06-11 02:19:45 +02001008UNUSED static struct flags msg_flags[] = {
1009 /* send */
1010 FLAG_GENERIC(MSG_CONFIRM),
1011 FLAG_GENERIC(MSG_DONTROUTE),
1012 FLAG_GENERIC(MSG_DONTWAIT),
1013 FLAG_GENERIC(MSG_EOR),
1014 FLAG_GENERIC(MSG_MORE),
1015 FLAG_GENERIC(MSG_NOSIGNAL),
1016 FLAG_GENERIC(MSG_OOB),
1017 /* recv */
1018 FLAG_GENERIC(MSG_CMSG_CLOEXEC),
1019 FLAG_GENERIC(MSG_ERRQUEUE),
1020 FLAG_GENERIC(MSG_PEEK),
1021 FLAG_GENERIC(MSG_TRUNC),
1022 FLAG_GENERIC(MSG_WAITALL),
1023 /* recvmsg */
1024 FLAG_GENERIC(MSG_CTRUNC),
1025 FLAG_END,
1026};
1027
Jim Wilsond42744f2019-06-28 12:43:35 +02001028UNUSED static struct flags statx_flags[] = {
1029#ifdef AT_EMPTY_PATH
1030 FLAG_GENERIC(AT_EMPTY_PATH),
1031#endif
1032#ifdef AT_NO_AUTOMOUNT
1033 FLAG_GENERIC(AT_NO_AUTOMOUNT),
1034#endif
1035#ifdef AT_SYMLINK_NOFOLLOW
1036 FLAG_GENERIC(AT_SYMLINK_NOFOLLOW),
1037#endif
1038#ifdef AT_STATX_SYNC_AS_STAT
1039 FLAG_GENERIC(AT_STATX_SYNC_AS_STAT),
1040#endif
1041#ifdef AT_STATX_FORCE_SYNC
1042 FLAG_GENERIC(AT_STATX_FORCE_SYNC),
1043#endif
1044#ifdef AT_STATX_DONT_SYNC
1045 FLAG_GENERIC(AT_STATX_DONT_SYNC),
1046#endif
1047 FLAG_END,
1048};
1049
1050UNUSED static struct flags statx_mask[] = {
1051/* This must come first, because it includes everything. */
1052#ifdef STATX_ALL
1053 FLAG_GENERIC(STATX_ALL),
1054#endif
1055/* This must come second; it includes everything except STATX_BTIME. */
1056#ifdef STATX_BASIC_STATS
1057 FLAG_GENERIC(STATX_BASIC_STATS),
1058#endif
1059#ifdef STATX_TYPE
1060 FLAG_GENERIC(STATX_TYPE),
1061#endif
1062#ifdef STATX_MODE
1063 FLAG_GENERIC(STATX_MODE),
1064#endif
1065#ifdef STATX_NLINK
1066 FLAG_GENERIC(STATX_NLINK),
1067#endif
1068#ifdef STATX_UID
1069 FLAG_GENERIC(STATX_UID),
1070#endif
1071#ifdef STATX_GID
1072 FLAG_GENERIC(STATX_GID),
1073#endif
1074#ifdef STATX_ATIME
1075 FLAG_GENERIC(STATX_ATIME),
1076#endif
1077#ifdef STATX_MTIME
1078 FLAG_GENERIC(STATX_MTIME),
1079#endif
1080#ifdef STATX_CTIME
1081 FLAG_GENERIC(STATX_CTIME),
1082#endif
1083#ifdef STATX_INO
1084 FLAG_GENERIC(STATX_INO),
1085#endif
1086#ifdef STATX_SIZE
1087 FLAG_GENERIC(STATX_SIZE),
1088#endif
1089#ifdef STATX_BLOCKS
1090 FLAG_GENERIC(STATX_BLOCKS),
1091#endif
1092#ifdef STATX_BTIME
1093 FLAG_GENERIC(STATX_BTIME),
1094#endif
1095 FLAG_END,
1096};
1097
Mika Westerberg74d753a2009-04-07 16:57:29 +03001098/*
1099 * print_xxx utility functions. These are used to print syscall
1100 * parameters in certain format. All of these have parameter
1101 * named 'last'. This parameter is used to add comma to output
1102 * when last == 0.
1103 */
1104
1105static const char *
1106get_comma(int last)
1107{
1108 return ((last) ? "" : ",");
1109}
1110
1111static void
Laurent Vivierd2ee72a2011-02-15 21:10:44 +01001112print_flags(const struct flags *f, abi_long flags, int last)
Mika Westerberg74d753a2009-04-07 16:57:29 +03001113{
1114 const char *sep = "";
Mika Westerberg74d753a2009-04-07 16:57:29 +03001115 int n;
1116
Mika Westerberg74d753a2009-04-07 16:57:29 +03001117 if ((flags == 0) && (f->f_value == 0)) {
Josh Kunz4b25a502020-02-03 18:54:14 -08001118 qemu_log("%s%s", f->f_string, get_comma(last));
Mika Westerberg74d753a2009-04-07 16:57:29 +03001119 return;
1120 }
1121 for (n = 0; f->f_string != NULL; f++) {
1122 if ((f->f_value != 0) && ((flags & f->f_value) == f->f_value)) {
Josh Kunz4b25a502020-02-03 18:54:14 -08001123 qemu_log("%s%s", sep, f->f_string);
Mika Westerberg74d753a2009-04-07 16:57:29 +03001124 flags &= ~f->f_value;
1125 sep = "|";
1126 n++;
1127 }
1128 }
1129
1130 if (n > 0) {
1131 /* print rest of the flags as numeric */
1132 if (flags != 0) {
Josh Kunz4b25a502020-02-03 18:54:14 -08001133 qemu_log("%s%#x%s", sep, (unsigned int)flags, get_comma(last));
Mika Westerberg74d753a2009-04-07 16:57:29 +03001134 } else {
Josh Kunz4b25a502020-02-03 18:54:14 -08001135 qemu_log("%s", get_comma(last));
Mika Westerberg74d753a2009-04-07 16:57:29 +03001136 }
1137 } else {
1138 /* no string version of flags found, print them in hex then */
Josh Kunz4b25a502020-02-03 18:54:14 -08001139 qemu_log("%#x%s", (unsigned int)flags, get_comma(last));
Mika Westerberg74d753a2009-04-07 16:57:29 +03001140 }
1141}
1142
1143static void
Laurent Vivierd2ee72a2011-02-15 21:10:44 +01001144print_at_dirfd(abi_long dirfd, int last)
Mika Westerberg74d753a2009-04-07 16:57:29 +03001145{
Mika Westerberg74d753a2009-04-07 16:57:29 +03001146#ifdef AT_FDCWD
1147 if (dirfd == AT_FDCWD) {
Josh Kunz4b25a502020-02-03 18:54:14 -08001148 qemu_log("AT_FDCWD%s", get_comma(last));
Mika Westerberg74d753a2009-04-07 16:57:29 +03001149 return;
1150 }
1151#endif
Josh Kunz4b25a502020-02-03 18:54:14 -08001152 qemu_log("%d%s", (int)dirfd, get_comma(last));
Mika Westerberg74d753a2009-04-07 16:57:29 +03001153}
1154
1155static void
Laurent Vivierd2ee72a2011-02-15 21:10:44 +01001156print_file_mode(abi_long mode, int last)
Mika Westerberg74d753a2009-04-07 16:57:29 +03001157{
1158 const char *sep = "";
1159 const struct flags *m;
Mika Westerberg74d753a2009-04-07 16:57:29 +03001160
1161 for (m = &mode_flags[0]; m->f_string != NULL; m++) {
1162 if ((m->f_value & mode) == m->f_value) {
Josh Kunz4b25a502020-02-03 18:54:14 -08001163 qemu_log("%s%s", m->f_string, sep);
Mika Westerberg74d753a2009-04-07 16:57:29 +03001164 sep = "|";
1165 mode &= ~m->f_value;
1166 break;
1167 }
1168 }
1169
1170 mode &= ~S_IFMT;
1171 /* print rest of the mode as octal */
1172 if (mode != 0)
Josh Kunz4b25a502020-02-03 18:54:14 -08001173 qemu_log("%s%#o", sep, (unsigned int)mode);
Mika Westerberg74d753a2009-04-07 16:57:29 +03001174
Josh Kunz4b25a502020-02-03 18:54:14 -08001175 qemu_log("%s", get_comma(last));
Mika Westerberg74d753a2009-04-07 16:57:29 +03001176}
1177
1178static void
Laurent Vivierd2ee72a2011-02-15 21:10:44 +01001179print_open_flags(abi_long flags, int last)
Mika Westerberg74d753a2009-04-07 16:57:29 +03001180{
Mika Westerberg74d753a2009-04-07 16:57:29 +03001181 print_flags(open_access_flags, flags & TARGET_O_ACCMODE, 1);
1182 flags &= ~TARGET_O_ACCMODE;
1183 if (flags == 0) {
Josh Kunz4b25a502020-02-03 18:54:14 -08001184 qemu_log("%s", get_comma(last));
Mika Westerberg74d753a2009-04-07 16:57:29 +03001185 return;
1186 }
Josh Kunz4b25a502020-02-03 18:54:14 -08001187 qemu_log("|");
Mika Westerberg74d753a2009-04-07 16:57:29 +03001188 print_flags(open_flags, flags, last);
1189}
1190
1191static void
1192print_syscall_prologue(const struct syscallname *sc)
1193{
Josh Kunz4b25a502020-02-03 18:54:14 -08001194 qemu_log("%s(", sc->name);
Mika Westerberg74d753a2009-04-07 16:57:29 +03001195}
1196
1197/*ARGSUSED*/
1198static void
1199print_syscall_epilogue(const struct syscallname *sc)
1200{
1201 (void)sc;
Josh Kunz4b25a502020-02-03 18:54:14 -08001202 qemu_log(")");
Mika Westerberg74d753a2009-04-07 16:57:29 +03001203}
1204
1205static void
1206print_string(abi_long addr, int last)
1207{
1208 char *s;
1209
1210 if ((s = lock_user_string(addr)) != NULL) {
Josh Kunz4b25a502020-02-03 18:54:14 -08001211 qemu_log("\"%s\"%s", s, get_comma(last));
Mika Westerberg74d753a2009-04-07 16:57:29 +03001212 unlock_user(s, addr, 0);
1213 } else {
1214 /* can't get string out of it, so print it as pointer */
1215 print_pointer(addr, last);
1216 }
1217}
1218
Laurent Vivierfb3aabf2016-06-11 02:19:45 +02001219#define MAX_PRINT_BUF 40
1220static void
1221print_buf(abi_long addr, abi_long len, int last)
1222{
1223 uint8_t *s;
1224 int i;
1225
1226 s = lock_user(VERIFY_READ, addr, len, 1);
1227 if (s) {
Josh Kunz4b25a502020-02-03 18:54:14 -08001228 qemu_log("\"");
Laurent Vivierfb3aabf2016-06-11 02:19:45 +02001229 for (i = 0; i < MAX_PRINT_BUF && i < len; i++) {
1230 if (isprint(s[i])) {
Josh Kunz4b25a502020-02-03 18:54:14 -08001231 qemu_log("%c", s[i]);
Laurent Vivierfb3aabf2016-06-11 02:19:45 +02001232 } else {
Josh Kunz4b25a502020-02-03 18:54:14 -08001233 qemu_log("\\%o", s[i]);
Laurent Vivierfb3aabf2016-06-11 02:19:45 +02001234 }
1235 }
Josh Kunz4b25a502020-02-03 18:54:14 -08001236 qemu_log("\"");
Laurent Vivierfb3aabf2016-06-11 02:19:45 +02001237 if (i != len) {
Josh Kunz4b25a502020-02-03 18:54:14 -08001238 qemu_log("...");
Laurent Vivierfb3aabf2016-06-11 02:19:45 +02001239 }
1240 if (!last) {
Josh Kunz4b25a502020-02-03 18:54:14 -08001241 qemu_log(",");
Laurent Vivierfb3aabf2016-06-11 02:19:45 +02001242 }
1243 unlock_user(s, addr, 0);
1244 } else {
1245 print_pointer(addr, last);
1246 }
1247}
1248
Mika Westerberg74d753a2009-04-07 16:57:29 +03001249/*
1250 * Prints out raw parameter using given format. Caller needs
1251 * to do byte swapping if needed.
1252 */
1253static void
1254print_raw_param(const char *fmt, abi_long param, int last)
1255{
1256 char format[64];
1257
1258 (void) snprintf(format, sizeof (format), "%s%s", fmt, get_comma(last));
Josh Kunz4b25a502020-02-03 18:54:14 -08001259 qemu_log(format, param);
Mika Westerberg74d753a2009-04-07 16:57:29 +03001260}
1261
1262static void
1263print_pointer(abi_long p, int last)
1264{
1265 if (p == 0)
Josh Kunz4b25a502020-02-03 18:54:14 -08001266 qemu_log("NULL%s", get_comma(last));
Mika Westerberg74d753a2009-04-07 16:57:29 +03001267 else
Josh Kunz4b25a502020-02-03 18:54:14 -08001268 qemu_log("0x" TARGET_ABI_FMT_lx "%s", p, get_comma(last));
Mika Westerberg74d753a2009-04-07 16:57:29 +03001269}
1270
1271/*
1272 * Reads 32-bit (int) number from guest address space from
1273 * address 'addr' and prints it.
1274 */
1275static void
1276print_number(abi_long addr, int last)
1277{
1278 if (addr == 0) {
Josh Kunz4b25a502020-02-03 18:54:14 -08001279 qemu_log("NULL%s", get_comma(last));
Mika Westerberg74d753a2009-04-07 16:57:29 +03001280 } else {
1281 int num;
1282
1283 get_user_s32(num, addr);
Josh Kunz4b25a502020-02-03 18:54:14 -08001284 qemu_log("[%d]%s", num, get_comma(last));
Mika Westerberg74d753a2009-04-07 16:57:29 +03001285 }
1286}
1287
1288static void
1289print_timeval(abi_ulong tv_addr, int last)
1290{
1291 if( tv_addr ) {
1292 struct target_timeval *tv;
1293
1294 tv = lock_user(VERIFY_READ, tv_addr, sizeof(*tv), 1);
Philippe Mathieu-Daudé8f930892019-10-21 13:48:49 +02001295 if (!tv) {
1296 print_pointer(tv_addr, last);
Mika Westerberg74d753a2009-04-07 16:57:29 +03001297 return;
Philippe Mathieu-Daudé8f930892019-10-21 13:48:49 +02001298 }
Josh Kunz4b25a502020-02-03 18:54:14 -08001299 qemu_log("{" TARGET_ABI_FMT_ld "," TARGET_ABI_FMT_ld "}%s",
Laurent Vivier910ee4e2012-12-31 09:45:06 +00001300 tswapal(tv->tv_sec), tswapal(tv->tv_usec), get_comma(last));
Mika Westerberg74d753a2009-04-07 16:57:29 +03001301 unlock_user(tv, tv_addr, 0);
1302 } else
Josh Kunz4b25a502020-02-03 18:54:14 -08001303 qemu_log("NULL%s", get_comma(last));
Mika Westerberg74d753a2009-04-07 16:57:29 +03001304}
1305
Philippe Mathieu-Daudé6d33e032019-10-21 13:48:50 +02001306static void
1307print_timezone(abi_ulong tz_addr, int last)
1308{
1309 if (tz_addr) {
1310 struct target_timezone *tz;
1311
1312 tz = lock_user(VERIFY_READ, tz_addr, sizeof(*tz), 1);
1313 if (!tz) {
1314 print_pointer(tz_addr, last);
1315 return;
1316 }
Josh Kunz4b25a502020-02-03 18:54:14 -08001317 qemu_log("{%d,%d}%s", tswap32(tz->tz_minuteswest),
Philippe Mathieu-Daudé6d33e032019-10-21 13:48:50 +02001318 tswap32(tz->tz_dsttime), get_comma(last));
1319 unlock_user(tz, tz_addr, 0);
1320 } else {
Josh Kunz4b25a502020-02-03 18:54:14 -08001321 qemu_log("NULL%s", get_comma(last));
Philippe Mathieu-Daudé6d33e032019-10-21 13:48:50 +02001322 }
1323}
1324
Mika Westerberg74d753a2009-04-07 16:57:29 +03001325#undef UNUSED
1326
1327#ifdef TARGET_NR_accept
1328static void
1329print_accept(const struct syscallname *name,
1330 abi_long arg0, abi_long arg1, abi_long arg2,
1331 abi_long arg3, abi_long arg4, abi_long arg5)
1332{
1333 print_syscall_prologue(name);
Laurent Vivierd2ee72a2011-02-15 21:10:44 +01001334 print_raw_param("%d", arg0, 0);
Mika Westerberg74d753a2009-04-07 16:57:29 +03001335 print_pointer(arg1, 0);
1336 print_number(arg2, 1);
1337 print_syscall_epilogue(name);
1338}
1339#endif
1340
1341#ifdef TARGET_NR_access
1342static void
1343print_access(const struct syscallname *name,
1344 abi_long arg0, abi_long arg1, abi_long arg2,
1345 abi_long arg3, abi_long arg4, abi_long arg5)
1346{
1347 print_syscall_prologue(name);
1348 print_string(arg0, 0);
1349 print_flags(access_flags, arg1, 1);
1350 print_syscall_epilogue(name);
1351}
1352#endif
1353
1354#ifdef TARGET_NR_brk
1355static void
1356print_brk(const struct syscallname *name,
1357 abi_long arg0, abi_long arg1, abi_long arg2,
1358 abi_long arg3, abi_long arg4, abi_long arg5)
1359{
1360 print_syscall_prologue(name);
1361 print_pointer(arg0, 1);
1362 print_syscall_epilogue(name);
1363}
1364#endif
1365
1366#ifdef TARGET_NR_chdir
1367static void
1368print_chdir(const struct syscallname *name,
1369 abi_long arg0, abi_long arg1, abi_long arg2,
1370 abi_long arg3, abi_long arg4, abi_long arg5)
1371{
1372 print_syscall_prologue(name);
1373 print_string(arg0, 1);
1374 print_syscall_epilogue(name);
1375}
1376#endif
1377
Helge Deller1b7695f2019-02-27 20:11:15 +01001378#ifdef TARGET_NR_chroot
1379static void
1380print_chroot(const struct syscallname *name,
1381 abi_long arg0, abi_long arg1, abi_long arg2,
1382 abi_long arg3, abi_long arg4, abi_long arg5)
1383{
1384 print_syscall_prologue(name);
1385 print_string(arg0, 1);
1386 print_syscall_epilogue(name);
1387}
1388#endif
1389
Mika Westerberg74d753a2009-04-07 16:57:29 +03001390#ifdef TARGET_NR_chmod
1391static void
1392print_chmod(const struct syscallname *name,
1393 abi_long arg0, abi_long arg1, abi_long arg2,
1394 abi_long arg3, abi_long arg4, abi_long arg5)
1395{
1396 print_syscall_prologue(name);
1397 print_string(arg0, 0);
1398 print_file_mode(arg1, 1);
1399 print_syscall_epilogue(name);
1400}
1401#endif
1402
Aleksandar Markovic38860a02016-10-10 13:23:29 +02001403#ifdef TARGET_NR_clock_adjtime
1404static void
1405print_clock_adjtime(const struct syscallname *name,
1406 abi_long arg0, abi_long arg1, abi_long arg2,
1407 abi_long arg3, abi_long arg4, abi_long arg5)
1408{
1409 print_syscall_prologue(name);
1410 print_clockid(arg0, 0);
1411 print_pointer(arg1, 1);
1412 print_syscall_epilogue(name);
1413}
1414#endif
1415
Laurent Vivier608e5592011-04-07 00:25:32 +02001416#ifdef TARGET_NR_clone
Laurent Vivier84bd8282016-06-11 02:19:47 +02001417static void do_print_clone(unsigned int flags, abi_ulong newsp,
1418 abi_ulong parent_tidptr, target_ulong newtls,
1419 abi_ulong child_tidptr)
1420{
1421 print_flags(clone_flags, flags, 0);
1422 print_raw_param("child_stack=0x" TARGET_ABI_FMT_lx, newsp, 0);
1423 print_raw_param("parent_tidptr=0x" TARGET_ABI_FMT_lx, parent_tidptr, 0);
1424 print_raw_param("tls=0x" TARGET_ABI_FMT_lx, newtls, 0);
1425 print_raw_param("child_tidptr=0x" TARGET_ABI_FMT_lx, child_tidptr, 1);
1426}
1427
Laurent Vivier608e5592011-04-07 00:25:32 +02001428static void
1429print_clone(const struct syscallname *name,
Laurent Vivier84bd8282016-06-11 02:19:47 +02001430 abi_long arg1, abi_long arg2, abi_long arg3,
1431 abi_long arg4, abi_long arg5, abi_long arg6)
Laurent Vivier608e5592011-04-07 00:25:32 +02001432{
1433 print_syscall_prologue(name);
Laurent Vivier84bd8282016-06-11 02:19:47 +02001434#if defined(TARGET_MICROBLAZE)
1435 do_print_clone(arg1, arg2, arg4, arg6, arg5);
1436#elif defined(TARGET_CLONE_BACKWARDS)
1437 do_print_clone(arg1, arg2, arg3, arg4, arg5);
1438#elif defined(TARGET_CLONE_BACKWARDS2)
1439 do_print_clone(arg2, arg1, arg3, arg5, arg4);
Laurent Vivier608e5592011-04-07 00:25:32 +02001440#else
Laurent Vivier84bd8282016-06-11 02:19:47 +02001441 do_print_clone(arg1, arg2, arg3, arg5, arg4);
Laurent Vivier608e5592011-04-07 00:25:32 +02001442#endif
1443 print_syscall_epilogue(name);
1444}
1445#endif
1446
Mika Westerberg74d753a2009-04-07 16:57:29 +03001447#ifdef TARGET_NR_creat
1448static void
1449print_creat(const struct syscallname *name,
1450 abi_long arg0, abi_long arg1, abi_long arg2,
1451 abi_long arg3, abi_long arg4, abi_long arg5)
1452{
1453 print_syscall_prologue(name);
1454 print_string(arg0, 0);
1455 print_file_mode(arg1, 1);
1456 print_syscall_epilogue(name);
1457}
1458#endif
1459
1460#ifdef TARGET_NR_execv
1461static void
1462print_execv(const struct syscallname *name,
1463 abi_long arg0, abi_long arg1, abi_long arg2,
1464 abi_long arg3, abi_long arg4, abi_long arg5)
1465{
1466 print_syscall_prologue(name);
1467 print_string(arg0, 0);
Laurent Vivierd2ee72a2011-02-15 21:10:44 +01001468 print_raw_param("0x" TARGET_ABI_FMT_lx, arg1, 1);
Mika Westerberg74d753a2009-04-07 16:57:29 +03001469 print_syscall_epilogue(name);
1470}
1471#endif
1472
1473#ifdef TARGET_NR_faccessat
1474static void
1475print_faccessat(const struct syscallname *name,
1476 abi_long arg0, abi_long arg1, abi_long arg2,
1477 abi_long arg3, abi_long arg4, abi_long arg5)
1478{
1479 print_syscall_prologue(name);
1480 print_at_dirfd(arg0, 0);
1481 print_string(arg1, 0);
1482 print_flags(access_flags, arg2, 0);
1483 print_flags(at_file_flags, arg3, 1);
1484 print_syscall_epilogue(name);
1485}
1486#endif
1487
1488#ifdef TARGET_NR_fchmodat
1489static void
1490print_fchmodat(const struct syscallname *name,
1491 abi_long arg0, abi_long arg1, abi_long arg2,
1492 abi_long arg3, abi_long arg4, abi_long arg5)
1493{
1494 print_syscall_prologue(name);
1495 print_at_dirfd(arg0, 0);
1496 print_string(arg1, 0);
1497 print_file_mode(arg2, 0);
1498 print_flags(at_file_flags, arg3, 1);
1499 print_syscall_epilogue(name);
1500}
1501#endif
1502
1503#ifdef TARGET_NR_fchownat
1504static void
1505print_fchownat(const struct syscallname *name,
1506 abi_long arg0, abi_long arg1, abi_long arg2,
1507 abi_long arg3, abi_long arg4, abi_long arg5)
1508{
1509 print_syscall_prologue(name);
1510 print_at_dirfd(arg0, 0);
1511 print_string(arg1, 0);
Laurent Vivierd2ee72a2011-02-15 21:10:44 +01001512 print_raw_param("%d", arg2, 0);
1513 print_raw_param("%d", arg3, 0);
Mika Westerberg74d753a2009-04-07 16:57:29 +03001514 print_flags(at_file_flags, arg4, 1);
1515 print_syscall_epilogue(name);
1516}
1517#endif
1518
1519#if defined(TARGET_NR_fcntl) || defined(TARGET_NR_fcntl64)
1520static void
1521print_fcntl(const struct syscallname *name,
1522 abi_long arg0, abi_long arg1, abi_long arg2,
1523 abi_long arg3, abi_long arg4, abi_long arg5)
1524{
1525 print_syscall_prologue(name);
Laurent Vivierd2ee72a2011-02-15 21:10:44 +01001526 print_raw_param("%d", arg0, 0);
Laurent Vivierd95ec142012-12-31 21:00:11 +01001527 switch(arg1) {
1528 case TARGET_F_DUPFD:
Josh Kunz4b25a502020-02-03 18:54:14 -08001529 qemu_log("F_DUPFD,");
Laurent Vivierd95ec142012-12-31 21:00:11 +01001530 print_raw_param(TARGET_ABI_FMT_ld, arg2, 1);
1531 break;
1532 case TARGET_F_GETFD:
Josh Kunz4b25a502020-02-03 18:54:14 -08001533 qemu_log("F_GETFD");
Laurent Vivierd95ec142012-12-31 21:00:11 +01001534 break;
1535 case TARGET_F_SETFD:
Josh Kunz4b25a502020-02-03 18:54:14 -08001536 qemu_log("F_SETFD,");
Laurent Vivierd95ec142012-12-31 21:00:11 +01001537 print_raw_param(TARGET_ABI_FMT_ld, arg2, 1);
1538 break;
1539 case TARGET_F_GETFL:
Josh Kunz4b25a502020-02-03 18:54:14 -08001540 qemu_log("F_GETFL");
Laurent Vivierd95ec142012-12-31 21:00:11 +01001541 break;
1542 case TARGET_F_SETFL:
Josh Kunz4b25a502020-02-03 18:54:14 -08001543 qemu_log("F_SETFL,");
Laurent Vivierd95ec142012-12-31 21:00:11 +01001544 print_open_flags(arg2, 1);
1545 break;
1546 case TARGET_F_GETLK:
Josh Kunz4b25a502020-02-03 18:54:14 -08001547 qemu_log("F_GETLK,");
Laurent Vivierd95ec142012-12-31 21:00:11 +01001548 print_pointer(arg2, 1);
1549 break;
1550 case TARGET_F_SETLK:
Josh Kunz4b25a502020-02-03 18:54:14 -08001551 qemu_log("F_SETLK,");
Laurent Vivierd95ec142012-12-31 21:00:11 +01001552 print_pointer(arg2, 1);
1553 break;
1554 case TARGET_F_SETLKW:
Josh Kunz4b25a502020-02-03 18:54:14 -08001555 qemu_log("F_SETLKW,");
Laurent Vivierd95ec142012-12-31 21:00:11 +01001556 print_pointer(arg2, 1);
1557 break;
1558 case TARGET_F_GETOWN:
Josh Kunz4b25a502020-02-03 18:54:14 -08001559 qemu_log("F_GETOWN");
Laurent Vivierd95ec142012-12-31 21:00:11 +01001560 break;
1561 case TARGET_F_SETOWN:
Josh Kunz4b25a502020-02-03 18:54:14 -08001562 qemu_log("F_SETOWN,");
Laurent Vivierd95ec142012-12-31 21:00:11 +01001563 print_raw_param(TARGET_ABI_FMT_ld, arg2, 0);
1564 break;
1565 case TARGET_F_GETSIG:
Josh Kunz4b25a502020-02-03 18:54:14 -08001566 qemu_log("F_GETSIG");
Laurent Vivierd95ec142012-12-31 21:00:11 +01001567 break;
1568 case TARGET_F_SETSIG:
Josh Kunz4b25a502020-02-03 18:54:14 -08001569 qemu_log("F_SETSIG,");
Laurent Vivierd95ec142012-12-31 21:00:11 +01001570 print_raw_param(TARGET_ABI_FMT_ld, arg2, 0);
1571 break;
1572#if TARGET_ABI_BITS == 32
1573 case TARGET_F_GETLK64:
Josh Kunz4b25a502020-02-03 18:54:14 -08001574 qemu_log("F_GETLK64,");
Laurent Vivierd95ec142012-12-31 21:00:11 +01001575 print_pointer(arg2, 1);
1576 break;
1577 case TARGET_F_SETLK64:
Josh Kunz4b25a502020-02-03 18:54:14 -08001578 qemu_log("F_SETLK64,");
Laurent Vivierd95ec142012-12-31 21:00:11 +01001579 print_pointer(arg2, 1);
1580 break;
1581 case TARGET_F_SETLKW64:
Josh Kunz4b25a502020-02-03 18:54:14 -08001582 qemu_log("F_SETLKW64,");
Laurent Vivierd95ec142012-12-31 21:00:11 +01001583 print_pointer(arg2, 1);
1584 break;
1585#endif
1586 case TARGET_F_SETLEASE:
Josh Kunz4b25a502020-02-03 18:54:14 -08001587 qemu_log("F_SETLEASE,");
Laurent Vivierd95ec142012-12-31 21:00:11 +01001588 print_raw_param(TARGET_ABI_FMT_ld, arg2, 0);
1589 break;
1590 case TARGET_F_GETLEASE:
Josh Kunz4b25a502020-02-03 18:54:14 -08001591 qemu_log("F_GETLEASE");
Laurent Vivierd95ec142012-12-31 21:00:11 +01001592 break;
Peter Maydell7e3b92e2016-06-20 15:50:37 +01001593 case TARGET_F_SETPIPE_SZ:
Josh Kunz4b25a502020-02-03 18:54:14 -08001594 qemu_log("F_SETPIPE_SZ,");
Peter Maydell7e3b92e2016-06-20 15:50:37 +01001595 print_raw_param(TARGET_ABI_FMT_ld, arg2, 1);
1596 break;
1597 case TARGET_F_GETPIPE_SZ:
Josh Kunz4b25a502020-02-03 18:54:14 -08001598 qemu_log("F_GETPIPE_SZ");
Peter Maydell7e3b92e2016-06-20 15:50:37 +01001599 break;
Laurent Vivierd95ec142012-12-31 21:00:11 +01001600 case TARGET_F_DUPFD_CLOEXEC:
Josh Kunz4b25a502020-02-03 18:54:14 -08001601 qemu_log("F_DUPFD_CLOEXEC,");
Laurent Vivierd95ec142012-12-31 21:00:11 +01001602 print_raw_param(TARGET_ABI_FMT_ld, arg2, 1);
1603 break;
1604 case TARGET_F_NOTIFY:
Josh Kunz4b25a502020-02-03 18:54:14 -08001605 qemu_log("F_NOTIFY,");
Laurent Vivierd95ec142012-12-31 21:00:11 +01001606 print_raw_param(TARGET_ABI_FMT_ld, arg2, 0);
1607 break;
1608 default:
1609 print_raw_param(TARGET_ABI_FMT_ld, arg1, 0);
1610 print_pointer(arg2, 1);
1611 break;
1612 }
Mika Westerberg74d753a2009-04-07 16:57:29 +03001613 print_syscall_epilogue(name);
1614}
1615#define print_fcntl64 print_fcntl
1616#endif
1617
1618
1619#ifdef TARGET_NR_futimesat
1620static void
1621print_futimesat(const struct syscallname *name,
1622 abi_long arg0, abi_long arg1, abi_long arg2,
1623 abi_long arg3, abi_long arg4, abi_long arg5)
1624{
1625 print_syscall_prologue(name);
1626 print_at_dirfd(arg0, 0);
1627 print_string(arg1, 0);
1628 print_timeval(arg2, 0);
1629 print_timeval(arg2 + sizeof (struct target_timeval), 1);
1630 print_syscall_epilogue(name);
1631}
1632#endif
1633
Philippe Mathieu-Daudé0d2187c2019-10-21 13:48:51 +02001634#ifdef TARGET_NR_settimeofday
1635static void
1636print_settimeofday(const struct syscallname *name,
1637 abi_long arg0, abi_long arg1, abi_long arg2,
1638 abi_long arg3, abi_long arg4, abi_long arg5)
1639{
1640 print_syscall_prologue(name);
1641 print_timeval(arg0, 0);
1642 print_timezone(arg1, 1);
1643 print_syscall_epilogue(name);
1644}
1645#endif
1646
Mika Westerberg74d753a2009-04-07 16:57:29 +03001647#ifdef TARGET_NR_link
1648static void
1649print_link(const struct syscallname *name,
1650 abi_long arg0, abi_long arg1, abi_long arg2,
1651 abi_long arg3, abi_long arg4, abi_long arg5)
1652{
1653 print_syscall_prologue(name);
1654 print_string(arg0, 0);
1655 print_string(arg1, 1);
1656 print_syscall_epilogue(name);
1657}
1658#endif
1659
1660#ifdef TARGET_NR_linkat
1661static void
1662print_linkat(const struct syscallname *name,
1663 abi_long arg0, abi_long arg1, abi_long arg2,
1664 abi_long arg3, abi_long arg4, abi_long arg5)
1665{
1666 print_syscall_prologue(name);
1667 print_at_dirfd(arg0, 0);
1668 print_string(arg1, 0);
1669 print_at_dirfd(arg2, 0);
1670 print_string(arg3, 0);
1671 print_flags(at_file_flags, arg4, 1);
1672 print_syscall_epilogue(name);
1673}
1674#endif
1675
Laurent Vivier608e5592011-04-07 00:25:32 +02001676#ifdef TARGET_NR__llseek
1677static void
1678print__llseek(const struct syscallname *name,
1679 abi_long arg0, abi_long arg1, abi_long arg2,
1680 abi_long arg3, abi_long arg4, abi_long arg5)
1681{
1682 const char *whence = "UNKNOWN";
1683 print_syscall_prologue(name);
1684 print_raw_param("%d", arg0, 0);
1685 print_raw_param("%ld", arg1, 0);
1686 print_raw_param("%ld", arg2, 0);
1687 print_pointer(arg3, 0);
1688 switch(arg4) {
1689 case SEEK_SET: whence = "SEEK_SET"; break;
1690 case SEEK_CUR: whence = "SEEK_CUR"; break;
1691 case SEEK_END: whence = "SEEK_END"; break;
1692 }
Josh Kunz4b25a502020-02-03 18:54:14 -08001693 qemu_log("%s", whence);
Laurent Vivier608e5592011-04-07 00:25:32 +02001694 print_syscall_epilogue(name);
1695}
1696#endif
1697
Laurent Vivier8997d1b2016-06-11 02:19:46 +02001698#if defined(TARGET_NR_socket)
1699static void
1700print_socket(const struct syscallname *name,
1701 abi_long arg0, abi_long arg1, abi_long arg2,
1702 abi_long arg3, abi_long arg4, abi_long arg5)
1703{
1704 abi_ulong domain = arg0, type = arg1, protocol = arg2;
1705
1706 print_syscall_prologue(name);
1707 print_socket_domain(domain);
Josh Kunz4b25a502020-02-03 18:54:14 -08001708 qemu_log(",");
Laurent Vivier8997d1b2016-06-11 02:19:46 +02001709 print_socket_type(type);
Josh Kunz4b25a502020-02-03 18:54:14 -08001710 qemu_log(",");
Laurent Vivier8997d1b2016-06-11 02:19:46 +02001711 if (domain == AF_PACKET ||
1712 (domain == AF_INET && type == TARGET_SOCK_PACKET)) {
1713 protocol = tswap16(protocol);
1714 }
1715 print_socket_protocol(domain, type, protocol);
1716 print_syscall_epilogue(name);
1717}
1718
1719#endif
1720
Philippe Mathieu-Daudébb105402019-10-21 13:48:55 +02001721#if defined(TARGET_NR_socketcall) || defined(TARGET_NR_bind)
Laurent Vivierfb3aabf2016-06-11 02:19:45 +02001722
Philippe Mathieu-Daudéd84fe1e2019-10-21 13:48:54 +02001723static void print_sockfd(abi_long sockfd, int last)
1724{
1725 print_raw_param(TARGET_ABI_FMT_ld, sockfd, last);
1726}
1727
1728#endif
1729
1730#if defined(TARGET_NR_socketcall)
1731
Laurent Vivierfb3aabf2016-06-11 02:19:45 +02001732#define get_user_ualx(x, gaddr, idx) \
1733 get_user_ual(x, (gaddr) + (idx) * sizeof(abi_long))
1734
1735static void do_print_socket(const char *name, abi_long arg1)
1736{
1737 abi_ulong domain, type, protocol;
1738
1739 get_user_ualx(domain, arg1, 0);
1740 get_user_ualx(type, arg1, 1);
1741 get_user_ualx(protocol, arg1, 2);
Josh Kunz4b25a502020-02-03 18:54:14 -08001742 qemu_log("%s(", name);
Laurent Vivierfb3aabf2016-06-11 02:19:45 +02001743 print_socket_domain(domain);
Josh Kunz4b25a502020-02-03 18:54:14 -08001744 qemu_log(",");
Laurent Vivierfb3aabf2016-06-11 02:19:45 +02001745 print_socket_type(type);
Josh Kunz4b25a502020-02-03 18:54:14 -08001746 qemu_log(",");
Laurent Vivierfb3aabf2016-06-11 02:19:45 +02001747 if (domain == AF_PACKET ||
1748 (domain == AF_INET && type == TARGET_SOCK_PACKET)) {
1749 protocol = tswap16(protocol);
1750 }
1751 print_socket_protocol(domain, type, protocol);
Josh Kunz4b25a502020-02-03 18:54:14 -08001752 qemu_log(")");
Laurent Vivierfb3aabf2016-06-11 02:19:45 +02001753}
1754
1755static void do_print_sockaddr(const char *name, abi_long arg1)
1756{
1757 abi_ulong sockfd, addr, addrlen;
1758
1759 get_user_ualx(sockfd, arg1, 0);
1760 get_user_ualx(addr, arg1, 1);
1761 get_user_ualx(addrlen, arg1, 2);
1762
Josh Kunz4b25a502020-02-03 18:54:14 -08001763 qemu_log("%s(", name);
Philippe Mathieu-Daudéd84fe1e2019-10-21 13:48:54 +02001764 print_sockfd(sockfd, 0);
Philippe Mathieu-Daudé42b15d72019-10-21 13:48:56 +02001765 print_sockaddr(addr, addrlen, 0);
Josh Kunz4b25a502020-02-03 18:54:14 -08001766 qemu_log(")");
Laurent Vivierfb3aabf2016-06-11 02:19:45 +02001767}
1768
1769static void do_print_listen(const char *name, abi_long arg1)
1770{
1771 abi_ulong sockfd, backlog;
1772
1773 get_user_ualx(sockfd, arg1, 0);
1774 get_user_ualx(backlog, arg1, 1);
1775
Josh Kunz4b25a502020-02-03 18:54:14 -08001776 qemu_log("%s(", name);
Philippe Mathieu-Daudéd84fe1e2019-10-21 13:48:54 +02001777 print_sockfd(sockfd, 0);
Laurent Vivierfb3aabf2016-06-11 02:19:45 +02001778 print_raw_param(TARGET_ABI_FMT_ld, backlog, 1);
Josh Kunz4b25a502020-02-03 18:54:14 -08001779 qemu_log(")");
Laurent Vivierfb3aabf2016-06-11 02:19:45 +02001780}
1781
1782static void do_print_socketpair(const char *name, abi_long arg1)
1783{
1784 abi_ulong domain, type, protocol, tab;
1785
1786 get_user_ualx(domain, arg1, 0);
1787 get_user_ualx(type, arg1, 1);
1788 get_user_ualx(protocol, arg1, 2);
1789 get_user_ualx(tab, arg1, 3);
1790
Josh Kunz4b25a502020-02-03 18:54:14 -08001791 qemu_log("%s(", name);
Laurent Vivierfb3aabf2016-06-11 02:19:45 +02001792 print_socket_domain(domain);
Josh Kunz4b25a502020-02-03 18:54:14 -08001793 qemu_log(",");
Laurent Vivierfb3aabf2016-06-11 02:19:45 +02001794 print_socket_type(type);
Josh Kunz4b25a502020-02-03 18:54:14 -08001795 qemu_log(",");
Laurent Vivierfb3aabf2016-06-11 02:19:45 +02001796 print_socket_protocol(domain, type, protocol);
Josh Kunz4b25a502020-02-03 18:54:14 -08001797 qemu_log(",");
Laurent Vivierfb3aabf2016-06-11 02:19:45 +02001798 print_raw_param(TARGET_ABI_FMT_lx, tab, 1);
Josh Kunz4b25a502020-02-03 18:54:14 -08001799 qemu_log(")");
Laurent Vivierfb3aabf2016-06-11 02:19:45 +02001800}
1801
1802static void do_print_sendrecv(const char *name, abi_long arg1)
1803{
1804 abi_ulong sockfd, msg, len, flags;
1805
1806 get_user_ualx(sockfd, arg1, 0);
1807 get_user_ualx(msg, arg1, 1);
1808 get_user_ualx(len, arg1, 2);
1809 get_user_ualx(flags, arg1, 3);
1810
Josh Kunz4b25a502020-02-03 18:54:14 -08001811 qemu_log("%s(", name);
Philippe Mathieu-Daudéd84fe1e2019-10-21 13:48:54 +02001812 print_sockfd(sockfd, 0);
Laurent Vivierfb3aabf2016-06-11 02:19:45 +02001813 print_buf(msg, len, 0);
1814 print_raw_param(TARGET_ABI_FMT_ld, len, 0);
1815 print_flags(msg_flags, flags, 1);
Josh Kunz4b25a502020-02-03 18:54:14 -08001816 qemu_log(")");
Laurent Vivierfb3aabf2016-06-11 02:19:45 +02001817}
1818
1819static void do_print_msgaddr(const char *name, abi_long arg1)
1820{
1821 abi_ulong sockfd, msg, len, flags, addr, addrlen;
1822
1823 get_user_ualx(sockfd, arg1, 0);
1824 get_user_ualx(msg, arg1, 1);
1825 get_user_ualx(len, arg1, 2);
1826 get_user_ualx(flags, arg1, 3);
1827 get_user_ualx(addr, arg1, 4);
1828 get_user_ualx(addrlen, arg1, 5);
1829
Josh Kunz4b25a502020-02-03 18:54:14 -08001830 qemu_log("%s(", name);
Philippe Mathieu-Daudéd84fe1e2019-10-21 13:48:54 +02001831 print_sockfd(sockfd, 0);
Laurent Vivierfb3aabf2016-06-11 02:19:45 +02001832 print_buf(msg, len, 0);
1833 print_raw_param(TARGET_ABI_FMT_ld, len, 0);
1834 print_flags(msg_flags, flags, 0);
Philippe Mathieu-Daudé42b15d72019-10-21 13:48:56 +02001835 print_sockaddr(addr, addrlen, 0);
Josh Kunz4b25a502020-02-03 18:54:14 -08001836 qemu_log(")");
Laurent Vivierfb3aabf2016-06-11 02:19:45 +02001837}
1838
1839static void do_print_shutdown(const char *name, abi_long arg1)
1840{
1841 abi_ulong sockfd, how;
1842
1843 get_user_ualx(sockfd, arg1, 0);
1844 get_user_ualx(how, arg1, 1);
1845
Josh Kunz4b25a502020-02-03 18:54:14 -08001846 qemu_log("shutdown(");
Philippe Mathieu-Daudéd84fe1e2019-10-21 13:48:54 +02001847 print_sockfd(sockfd, 0);
Laurent Vivierfb3aabf2016-06-11 02:19:45 +02001848 switch (how) {
1849 case SHUT_RD:
Josh Kunz4b25a502020-02-03 18:54:14 -08001850 qemu_log("SHUT_RD");
Laurent Vivierfb3aabf2016-06-11 02:19:45 +02001851 break;
1852 case SHUT_WR:
Josh Kunz4b25a502020-02-03 18:54:14 -08001853 qemu_log("SHUT_WR");
Laurent Vivierfb3aabf2016-06-11 02:19:45 +02001854 break;
1855 case SHUT_RDWR:
Josh Kunz4b25a502020-02-03 18:54:14 -08001856 qemu_log("SHUT_RDWR");
Laurent Vivierfb3aabf2016-06-11 02:19:45 +02001857 break;
1858 default:
1859 print_raw_param(TARGET_ABI_FMT_ld, how, 1);
1860 break;
1861 }
Josh Kunz4b25a502020-02-03 18:54:14 -08001862 qemu_log(")");
Laurent Vivierfb3aabf2016-06-11 02:19:45 +02001863}
1864
1865static void do_print_msg(const char *name, abi_long arg1)
1866{
1867 abi_ulong sockfd, msg, flags;
1868
1869 get_user_ualx(sockfd, arg1, 0);
1870 get_user_ualx(msg, arg1, 1);
1871 get_user_ualx(flags, arg1, 2);
1872
Josh Kunz4b25a502020-02-03 18:54:14 -08001873 qemu_log("%s(", name);
Philippe Mathieu-Daudéd84fe1e2019-10-21 13:48:54 +02001874 print_sockfd(sockfd, 0);
Laurent Vivierfb3aabf2016-06-11 02:19:45 +02001875 print_pointer(msg, 0);
1876 print_flags(msg_flags, flags, 1);
Josh Kunz4b25a502020-02-03 18:54:14 -08001877 qemu_log(")");
Laurent Vivierfb3aabf2016-06-11 02:19:45 +02001878}
1879
1880static void do_print_sockopt(const char *name, abi_long arg1)
1881{
1882 abi_ulong sockfd, level, optname, optval, optlen;
1883
1884 get_user_ualx(sockfd, arg1, 0);
1885 get_user_ualx(level, arg1, 1);
1886 get_user_ualx(optname, arg1, 2);
1887 get_user_ualx(optval, arg1, 3);
1888 get_user_ualx(optlen, arg1, 4);
1889
Josh Kunz4b25a502020-02-03 18:54:14 -08001890 qemu_log("%s(", name);
Philippe Mathieu-Daudéd84fe1e2019-10-21 13:48:54 +02001891 print_sockfd(sockfd, 0);
Laurent Vivierfb3aabf2016-06-11 02:19:45 +02001892 switch (level) {
1893 case SOL_TCP:
Josh Kunz4b25a502020-02-03 18:54:14 -08001894 qemu_log("SOL_TCP,");
Laurent Vivierfb3aabf2016-06-11 02:19:45 +02001895 print_raw_param(TARGET_ABI_FMT_ld, optname, 0);
1896 print_pointer(optval, 0);
1897 break;
1898 case SOL_IP:
Josh Kunz4b25a502020-02-03 18:54:14 -08001899 qemu_log("SOL_IP,");
Laurent Vivierfb3aabf2016-06-11 02:19:45 +02001900 print_raw_param(TARGET_ABI_FMT_ld, optname, 0);
1901 print_pointer(optval, 0);
1902 break;
1903 case SOL_RAW:
Josh Kunz4b25a502020-02-03 18:54:14 -08001904 qemu_log("SOL_RAW,");
Laurent Vivierfb3aabf2016-06-11 02:19:45 +02001905 print_raw_param(TARGET_ABI_FMT_ld, optname, 0);
1906 print_pointer(optval, 0);
1907 break;
1908 case TARGET_SOL_SOCKET:
Josh Kunz4b25a502020-02-03 18:54:14 -08001909 qemu_log("SOL_SOCKET,");
Laurent Vivierfb3aabf2016-06-11 02:19:45 +02001910 switch (optname) {
1911 case TARGET_SO_DEBUG:
Josh Kunz4b25a502020-02-03 18:54:14 -08001912 qemu_log("SO_DEBUG,");
Laurent Vivierfb3aabf2016-06-11 02:19:45 +02001913print_optint:
1914 print_number(optval, 0);
1915 break;
1916 case TARGET_SO_REUSEADDR:
Josh Kunz4b25a502020-02-03 18:54:14 -08001917 qemu_log("SO_REUSEADDR,");
Laurent Vivierfb3aabf2016-06-11 02:19:45 +02001918 goto print_optint;
Yunqiang Su113a9dd2018-10-30 13:55:08 +01001919 case TARGET_SO_REUSEPORT:
Josh Kunz4b25a502020-02-03 18:54:14 -08001920 qemu_log("SO_REUSEPORT,");
Yunqiang Su113a9dd2018-10-30 13:55:08 +01001921 goto print_optint;
Laurent Vivierfb3aabf2016-06-11 02:19:45 +02001922 case TARGET_SO_TYPE:
Josh Kunz4b25a502020-02-03 18:54:14 -08001923 qemu_log("SO_TYPE,");
Laurent Vivierfb3aabf2016-06-11 02:19:45 +02001924 goto print_optint;
1925 case TARGET_SO_ERROR:
Josh Kunz4b25a502020-02-03 18:54:14 -08001926 qemu_log("SO_ERROR,");
Laurent Vivierfb3aabf2016-06-11 02:19:45 +02001927 goto print_optint;
1928 case TARGET_SO_DONTROUTE:
Josh Kunz4b25a502020-02-03 18:54:14 -08001929 qemu_log("SO_DONTROUTE,");
Laurent Vivierfb3aabf2016-06-11 02:19:45 +02001930 goto print_optint;
1931 case TARGET_SO_BROADCAST:
Josh Kunz4b25a502020-02-03 18:54:14 -08001932 qemu_log("SO_BROADCAST,");
Laurent Vivierfb3aabf2016-06-11 02:19:45 +02001933 goto print_optint;
1934 case TARGET_SO_SNDBUF:
Josh Kunz4b25a502020-02-03 18:54:14 -08001935 qemu_log("SO_SNDBUF,");
Laurent Vivierfb3aabf2016-06-11 02:19:45 +02001936 goto print_optint;
1937 case TARGET_SO_RCVBUF:
Josh Kunz4b25a502020-02-03 18:54:14 -08001938 qemu_log("SO_RCVBUF,");
Laurent Vivierfb3aabf2016-06-11 02:19:45 +02001939 goto print_optint;
1940 case TARGET_SO_KEEPALIVE:
Josh Kunz4b25a502020-02-03 18:54:14 -08001941 qemu_log("SO_KEEPALIVE,");
Laurent Vivierfb3aabf2016-06-11 02:19:45 +02001942 goto print_optint;
1943 case TARGET_SO_OOBINLINE:
Josh Kunz4b25a502020-02-03 18:54:14 -08001944 qemu_log("SO_OOBINLINE,");
Laurent Vivierfb3aabf2016-06-11 02:19:45 +02001945 goto print_optint;
1946 case TARGET_SO_NO_CHECK:
Josh Kunz4b25a502020-02-03 18:54:14 -08001947 qemu_log("SO_NO_CHECK,");
Laurent Vivierfb3aabf2016-06-11 02:19:45 +02001948 goto print_optint;
1949 case TARGET_SO_PRIORITY:
Josh Kunz4b25a502020-02-03 18:54:14 -08001950 qemu_log("SO_PRIORITY,");
Laurent Vivierfb3aabf2016-06-11 02:19:45 +02001951 goto print_optint;
1952 case TARGET_SO_BSDCOMPAT:
Josh Kunz4b25a502020-02-03 18:54:14 -08001953 qemu_log("SO_BSDCOMPAT,");
Laurent Vivierfb3aabf2016-06-11 02:19:45 +02001954 goto print_optint;
1955 case TARGET_SO_PASSCRED:
Josh Kunz4b25a502020-02-03 18:54:14 -08001956 qemu_log("SO_PASSCRED,");
Laurent Vivierfb3aabf2016-06-11 02:19:45 +02001957 goto print_optint;
1958 case TARGET_SO_TIMESTAMP:
Josh Kunz4b25a502020-02-03 18:54:14 -08001959 qemu_log("SO_TIMESTAMP,");
Laurent Vivierfb3aabf2016-06-11 02:19:45 +02001960 goto print_optint;
1961 case TARGET_SO_RCVLOWAT:
Josh Kunz4b25a502020-02-03 18:54:14 -08001962 qemu_log("SO_RCVLOWAT,");
Laurent Vivierfb3aabf2016-06-11 02:19:45 +02001963 goto print_optint;
1964 case TARGET_SO_RCVTIMEO:
Josh Kunz4b25a502020-02-03 18:54:14 -08001965 qemu_log("SO_RCVTIMEO,");
Laurent Vivierfb3aabf2016-06-11 02:19:45 +02001966 print_timeval(optval, 0);
1967 break;
1968 case TARGET_SO_SNDTIMEO:
Josh Kunz4b25a502020-02-03 18:54:14 -08001969 qemu_log("SO_SNDTIMEO,");
Laurent Vivierfb3aabf2016-06-11 02:19:45 +02001970 print_timeval(optval, 0);
1971 break;
1972 case TARGET_SO_ATTACH_FILTER: {
1973 struct target_sock_fprog *fprog;
1974
Josh Kunz4b25a502020-02-03 18:54:14 -08001975 qemu_log("SO_ATTACH_FILTER,");
Laurent Vivierfb3aabf2016-06-11 02:19:45 +02001976
1977 if (lock_user_struct(VERIFY_READ, fprog, optval, 0)) {
1978 struct target_sock_filter *filter;
Josh Kunz4b25a502020-02-03 18:54:14 -08001979 qemu_log("{");
Laurent Vivierfb3aabf2016-06-11 02:19:45 +02001980 if (lock_user_struct(VERIFY_READ, filter,
1981 tswapal(fprog->filter), 0)) {
1982 int i;
1983 for (i = 0; i < tswap16(fprog->len) - 1; i++) {
Josh Kunz4b25a502020-02-03 18:54:14 -08001984 qemu_log("[%d]{0x%x,%d,%d,0x%x},",
Laurent Vivierfb3aabf2016-06-11 02:19:45 +02001985 i, tswap16(filter[i].code),
1986 filter[i].jt, filter[i].jf,
1987 tswap32(filter[i].k));
1988 }
Josh Kunz4b25a502020-02-03 18:54:14 -08001989 qemu_log("[%d]{0x%x,%d,%d,0x%x}",
Laurent Vivierfb3aabf2016-06-11 02:19:45 +02001990 i, tswap16(filter[i].code),
1991 filter[i].jt, filter[i].jf,
1992 tswap32(filter[i].k));
1993 } else {
Josh Kunz4b25a502020-02-03 18:54:14 -08001994 qemu_log(TARGET_ABI_FMT_lx, tswapal(fprog->filter));
Laurent Vivierfb3aabf2016-06-11 02:19:45 +02001995 }
Josh Kunz4b25a502020-02-03 18:54:14 -08001996 qemu_log(",%d},", tswap16(fprog->len));
Laurent Vivierfb3aabf2016-06-11 02:19:45 +02001997 unlock_user(fprog, optval, 0);
1998 } else {
1999 print_pointer(optval, 0);
2000 }
2001 break;
2002 }
2003 default:
2004 print_raw_param(TARGET_ABI_FMT_ld, optname, 0);
2005 print_pointer(optval, 0);
2006 break;
2007 }
2008 break;
2009 default:
2010 print_raw_param(TARGET_ABI_FMT_ld, level, 0);
2011 print_raw_param(TARGET_ABI_FMT_ld, optname, 0);
2012 print_pointer(optval, 0);
2013 break;
2014 }
2015 print_raw_param(TARGET_ABI_FMT_ld, optlen, 1);
Josh Kunz4b25a502020-02-03 18:54:14 -08002016 qemu_log(")");
Laurent Vivierfb3aabf2016-06-11 02:19:45 +02002017}
2018
2019#define PRINT_SOCKOP(name, func) \
Aleksandar Markovicff71a452016-09-22 18:56:57 +02002020 [TARGET_SYS_##name] = { #name, func }
Laurent Vivierfb3aabf2016-06-11 02:19:45 +02002021
2022static struct {
2023 const char *name;
2024 void (*print)(const char *, abi_long);
2025} scall[] = {
Aleksandar Markovicff71a452016-09-22 18:56:57 +02002026 PRINT_SOCKOP(SOCKET, do_print_socket),
2027 PRINT_SOCKOP(BIND, do_print_sockaddr),
2028 PRINT_SOCKOP(CONNECT, do_print_sockaddr),
2029 PRINT_SOCKOP(LISTEN, do_print_listen),
2030 PRINT_SOCKOP(ACCEPT, do_print_sockaddr),
2031 PRINT_SOCKOP(GETSOCKNAME, do_print_sockaddr),
2032 PRINT_SOCKOP(GETPEERNAME, do_print_sockaddr),
2033 PRINT_SOCKOP(SOCKETPAIR, do_print_socketpair),
2034 PRINT_SOCKOP(SEND, do_print_sendrecv),
2035 PRINT_SOCKOP(RECV, do_print_sendrecv),
2036 PRINT_SOCKOP(SENDTO, do_print_msgaddr),
2037 PRINT_SOCKOP(RECVFROM, do_print_msgaddr),
2038 PRINT_SOCKOP(SHUTDOWN, do_print_shutdown),
2039 PRINT_SOCKOP(SETSOCKOPT, do_print_sockopt),
2040 PRINT_SOCKOP(GETSOCKOPT, do_print_sockopt),
2041 PRINT_SOCKOP(SENDMSG, do_print_msg),
2042 PRINT_SOCKOP(RECVMSG, do_print_msg),
2043 PRINT_SOCKOP(ACCEPT4, NULL),
2044 PRINT_SOCKOP(RECVMMSG, NULL),
2045 PRINT_SOCKOP(SENDMMSG, NULL),
Laurent Vivierfb3aabf2016-06-11 02:19:45 +02002046};
2047
2048static void
2049print_socketcall(const struct syscallname *name,
2050 abi_long arg0, abi_long arg1, abi_long arg2,
2051 abi_long arg3, abi_long arg4, abi_long arg5)
2052{
2053 if (arg0 >= 0 && arg0 < ARRAY_SIZE(scall) && scall[arg0].print) {
2054 scall[arg0].print(scall[arg0].name, arg1);
2055 return;
2056 }
2057 print_syscall_prologue(name);
2058 print_raw_param(TARGET_ABI_FMT_ld, arg0, 0);
2059 print_raw_param(TARGET_ABI_FMT_ld, arg1, 0);
2060 print_raw_param(TARGET_ABI_FMT_ld, arg2, 0);
2061 print_raw_param(TARGET_ABI_FMT_ld, arg3, 0);
2062 print_raw_param(TARGET_ABI_FMT_ld, arg4, 0);
2063 print_raw_param(TARGET_ABI_FMT_ld, arg5, 0);
2064 print_syscall_epilogue(name);
2065}
2066#endif
2067
Philippe Mathieu-Daudébb105402019-10-21 13:48:55 +02002068#if defined(TARGET_NR_bind)
2069static void
2070print_bind(const struct syscallname *name,
2071 abi_long arg0, abi_long arg1, abi_long arg2,
2072 abi_long arg3, abi_long arg4, abi_long arg5)
2073{
2074 print_syscall_prologue(name);
2075 print_sockfd(arg0, 0);
2076 print_sockaddr(arg1, arg2, 1);
2077 print_syscall_epilogue(name);
2078}
2079#endif
2080
Mika Westerberg74d753a2009-04-07 16:57:29 +03002081#if defined(TARGET_NR_stat) || defined(TARGET_NR_stat64) || \
2082 defined(TARGET_NR_lstat) || defined(TARGET_NR_lstat64)
2083static void
2084print_stat(const struct syscallname *name,
2085 abi_long arg0, abi_long arg1, abi_long arg2,
2086 abi_long arg3, abi_long arg4, abi_long arg5)
2087{
2088 print_syscall_prologue(name);
2089 print_string(arg0, 0);
2090 print_pointer(arg1, 1);
2091 print_syscall_epilogue(name);
2092}
2093#define print_lstat print_stat
2094#define print_stat64 print_stat
2095#define print_lstat64 print_stat
2096#endif
2097
2098#if defined(TARGET_NR_fstat) || defined(TARGET_NR_fstat64)
2099static void
2100print_fstat(const struct syscallname *name,
2101 abi_long arg0, abi_long arg1, abi_long arg2,
2102 abi_long arg3, abi_long arg4, abi_long arg5)
2103{
2104 print_syscall_prologue(name);
Laurent Vivierd2ee72a2011-02-15 21:10:44 +01002105 print_raw_param("%d", arg0, 0);
Mika Westerberg74d753a2009-04-07 16:57:29 +03002106 print_pointer(arg1, 1);
2107 print_syscall_epilogue(name);
2108}
2109#define print_fstat64 print_fstat
2110#endif
2111
2112#ifdef TARGET_NR_mkdir
2113static void
2114print_mkdir(const struct syscallname *name,
2115 abi_long arg0, abi_long arg1, abi_long arg2,
2116 abi_long arg3, abi_long arg4, abi_long arg5)
2117{
2118 print_syscall_prologue(name);
2119 print_string(arg0, 0);
2120 print_file_mode(arg1, 1);
2121 print_syscall_epilogue(name);
2122}
2123#endif
2124
2125#ifdef TARGET_NR_mkdirat
2126static void
2127print_mkdirat(const struct syscallname *name,
2128 abi_long arg0, abi_long arg1, abi_long arg2,
2129 abi_long arg3, abi_long arg4, abi_long arg5)
2130{
2131 print_syscall_prologue(name);
2132 print_at_dirfd(arg0, 0);
2133 print_string(arg1, 0);
2134 print_file_mode(arg2, 1);
2135 print_syscall_epilogue(name);
2136}
2137#endif
2138
Laurent Vivier4de596c2011-02-15 21:10:43 +01002139#ifdef TARGET_NR_rmdir
2140static void
2141print_rmdir(const struct syscallname *name,
2142 abi_long arg0, abi_long arg1, abi_long arg2,
2143 abi_long arg3, abi_long arg4, abi_long arg5)
2144{
2145 print_syscall_prologue(name);
2146 print_string(arg0, 0);
2147 print_syscall_epilogue(name);
2148}
2149#endif
2150
Laurent Vivier608e5592011-04-07 00:25:32 +02002151#ifdef TARGET_NR_rt_sigaction
2152static void
2153print_rt_sigaction(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_signal(arg0, 0);
2159 print_pointer(arg1, 0);
2160 print_pointer(arg2, 1);
2161 print_syscall_epilogue(name);
2162}
2163#endif
2164
2165#ifdef TARGET_NR_rt_sigprocmask
2166static void
2167print_rt_sigprocmask(const struct syscallname *name,
2168 abi_long arg0, abi_long arg1, abi_long arg2,
2169 abi_long arg3, abi_long arg4, abi_long arg5)
2170{
2171 const char *how = "UNKNOWN";
2172 print_syscall_prologue(name);
2173 switch(arg0) {
2174 case TARGET_SIG_BLOCK: how = "SIG_BLOCK"; break;
2175 case TARGET_SIG_UNBLOCK: how = "SIG_UNBLOCK"; break;
2176 case TARGET_SIG_SETMASK: how = "SIG_SETMASK"; break;
2177 }
Josh Kunz4b25a502020-02-03 18:54:14 -08002178 qemu_log("%s,", how);
Laurent Vivier608e5592011-04-07 00:25:32 +02002179 print_pointer(arg1, 0);
2180 print_pointer(arg2, 1);
2181 print_syscall_epilogue(name);
2182}
2183#endif
2184
Miloš Stojanović51622642017-05-15 16:59:42 +02002185#ifdef TARGET_NR_rt_sigqueueinfo
2186static void
2187print_rt_sigqueueinfo(const struct syscallname *name,
2188 abi_long arg0, abi_long arg1, abi_long arg2,
2189 abi_long arg3, abi_long arg4, abi_long arg5)
2190{
Miloš Stojanovićba9fcea2017-05-15 16:59:49 +02002191 void *p;
2192 target_siginfo_t uinfo;
2193
Miloš Stojanović51622642017-05-15 16:59:42 +02002194 print_syscall_prologue(name);
2195 print_raw_param("%d", arg0, 0);
2196 print_signal(arg1, 0);
Miloš Stojanovićba9fcea2017-05-15 16:59:49 +02002197 p = lock_user(VERIFY_READ, arg2, sizeof(target_siginfo_t), 1);
2198 if (p) {
2199 get_target_siginfo(&uinfo, p);
2200 print_siginfo(&uinfo);
2201
2202 unlock_user(p, arg2, 0);
2203 } else {
2204 print_pointer(arg2, 1);
2205 }
Miloš Stojanović51622642017-05-15 16:59:42 +02002206 print_syscall_epilogue(name);
2207}
2208#endif
2209
Miloš Stojanović243e0fe2017-05-15 16:59:47 +02002210#ifdef TARGET_NR_rt_tgsigqueueinfo
2211static void
2212print_rt_tgsigqueueinfo(const struct syscallname *name,
2213 abi_long arg0, abi_long arg1, abi_long arg2,
2214 abi_long arg3, abi_long arg4, abi_long arg5)
2215{
Miloš Stojanovićba9fcea2017-05-15 16:59:49 +02002216 void *p;
2217 target_siginfo_t uinfo;
2218
Miloš Stojanović243e0fe2017-05-15 16:59:47 +02002219 print_syscall_prologue(name);
2220 print_raw_param("%d", arg0, 0);
2221 print_raw_param("%d", arg1, 0);
2222 print_signal(arg2, 0);
Miloš Stojanovićba9fcea2017-05-15 16:59:49 +02002223 p = lock_user(VERIFY_READ, arg3, sizeof(target_siginfo_t), 1);
2224 if (p) {
2225 get_target_siginfo(&uinfo, p);
2226 print_siginfo(&uinfo);
2227
2228 unlock_user(p, arg3, 0);
2229 } else {
2230 print_pointer(arg3, 1);
2231 }
Miloš Stojanović243e0fe2017-05-15 16:59:47 +02002232 print_syscall_epilogue(name);
2233}
2234#endif
2235
Aleksandar Markovicda2c8ad2016-09-22 18:56:58 +02002236#ifdef TARGET_NR_syslog
2237static void
2238print_syslog_action(abi_ulong arg, int last)
2239{
2240 const char *type;
2241
2242 switch (arg) {
2243 case TARGET_SYSLOG_ACTION_CLOSE: {
2244 type = "SYSLOG_ACTION_CLOSE";
2245 break;
2246 }
2247 case TARGET_SYSLOG_ACTION_OPEN: {
2248 type = "SYSLOG_ACTION_OPEN";
2249 break;
2250 }
2251 case TARGET_SYSLOG_ACTION_READ: {
2252 type = "SYSLOG_ACTION_READ";
2253 break;
2254 }
2255 case TARGET_SYSLOG_ACTION_READ_ALL: {
2256 type = "SYSLOG_ACTION_READ_ALL";
2257 break;
2258 }
2259 case TARGET_SYSLOG_ACTION_READ_CLEAR: {
2260 type = "SYSLOG_ACTION_READ_CLEAR";
2261 break;
2262 }
2263 case TARGET_SYSLOG_ACTION_CLEAR: {
2264 type = "SYSLOG_ACTION_CLEAR";
2265 break;
2266 }
2267 case TARGET_SYSLOG_ACTION_CONSOLE_OFF: {
2268 type = "SYSLOG_ACTION_CONSOLE_OFF";
2269 break;
2270 }
2271 case TARGET_SYSLOG_ACTION_CONSOLE_ON: {
2272 type = "SYSLOG_ACTION_CONSOLE_ON";
2273 break;
2274 }
2275 case TARGET_SYSLOG_ACTION_CONSOLE_LEVEL: {
2276 type = "SYSLOG_ACTION_CONSOLE_LEVEL";
2277 break;
2278 }
2279 case TARGET_SYSLOG_ACTION_SIZE_UNREAD: {
2280 type = "SYSLOG_ACTION_SIZE_UNREAD";
2281 break;
2282 }
2283 case TARGET_SYSLOG_ACTION_SIZE_BUFFER: {
2284 type = "SYSLOG_ACTION_SIZE_BUFFER";
2285 break;
2286 }
2287 default: {
2288 print_raw_param("%ld", arg, last);
2289 return;
2290 }
2291 }
Josh Kunz4b25a502020-02-03 18:54:14 -08002292 qemu_log("%s%s", type, get_comma(last));
Aleksandar Markovicda2c8ad2016-09-22 18:56:58 +02002293}
2294
2295static void
2296print_syslog(const struct syscallname *name,
2297 abi_long arg0, abi_long arg1, abi_long arg2,
2298 abi_long arg3, abi_long arg4, abi_long arg5)
2299{
2300 print_syscall_prologue(name);
2301 print_syslog_action(arg0, 0);
2302 print_pointer(arg1, 0);
2303 print_raw_param("%d", arg2, 1);
2304 print_syscall_epilogue(name);
2305}
2306#endif
2307
Mika Westerberg74d753a2009-04-07 16:57:29 +03002308#ifdef TARGET_NR_mknod
2309static void
2310print_mknod(const struct syscallname *name,
2311 abi_long arg0, abi_long arg1, abi_long arg2,
2312 abi_long arg3, abi_long arg4, abi_long arg5)
2313{
Laurent Vivierd2ee72a2011-02-15 21:10:44 +01002314 int hasdev = (arg1 & (S_IFCHR|S_IFBLK));
Mika Westerberg74d753a2009-04-07 16:57:29 +03002315
2316 print_syscall_prologue(name);
2317 print_string(arg0, 0);
2318 print_file_mode(arg1, (hasdev == 0));
2319 if (hasdev) {
Laurent Vivierd2ee72a2011-02-15 21:10:44 +01002320 print_raw_param("makedev(%d", major(arg2), 0);
2321 print_raw_param("%d)", minor(arg2), 1);
Mika Westerberg74d753a2009-04-07 16:57:29 +03002322 }
2323 print_syscall_epilogue(name);
2324}
2325#endif
2326
2327#ifdef TARGET_NR_mknodat
2328static void
2329print_mknodat(const struct syscallname *name,
2330 abi_long arg0, abi_long arg1, abi_long arg2,
2331 abi_long arg3, abi_long arg4, abi_long arg5)
2332{
Laurent Vivierd2ee72a2011-02-15 21:10:44 +01002333 int hasdev = (arg2 & (S_IFCHR|S_IFBLK));
Mika Westerberg74d753a2009-04-07 16:57:29 +03002334
2335 print_syscall_prologue(name);
2336 print_at_dirfd(arg0, 0);
2337 print_string(arg1, 0);
2338 print_file_mode(arg2, (hasdev == 0));
2339 if (hasdev) {
Laurent Vivierd2ee72a2011-02-15 21:10:44 +01002340 print_raw_param("makedev(%d", major(arg3), 0);
2341 print_raw_param("%d)", minor(arg3), 1);
Mika Westerberg74d753a2009-04-07 16:57:29 +03002342 }
2343 print_syscall_epilogue(name);
2344}
2345#endif
2346
2347#ifdef TARGET_NR_mq_open
2348static void
2349print_mq_open(const struct syscallname *name,
2350 abi_long arg0, abi_long arg1, abi_long arg2,
2351 abi_long arg3, abi_long arg4, abi_long arg5)
2352{
Laurent Vivierd2ee72a2011-02-15 21:10:44 +01002353 int is_creat = (arg1 & TARGET_O_CREAT);
Mika Westerberg74d753a2009-04-07 16:57:29 +03002354
2355 print_syscall_prologue(name);
2356 print_string(arg0, 0);
2357 print_open_flags(arg1, (is_creat == 0));
2358 if (is_creat) {
2359 print_file_mode(arg2, 0);
2360 print_pointer(arg3, 1);
2361 }
2362 print_syscall_epilogue(name);
2363}
2364#endif
2365
2366#ifdef TARGET_NR_open
2367static void
2368print_open(const struct syscallname *name,
2369 abi_long arg0, abi_long arg1, abi_long arg2,
2370 abi_long arg3, abi_long arg4, abi_long arg5)
2371{
Laurent Vivierd2ee72a2011-02-15 21:10:44 +01002372 int is_creat = (arg1 & TARGET_O_CREAT);
Mika Westerberg74d753a2009-04-07 16:57:29 +03002373
2374 print_syscall_prologue(name);
2375 print_string(arg0, 0);
2376 print_open_flags(arg1, (is_creat == 0));
2377 if (is_creat)
2378 print_file_mode(arg2, 1);
2379 print_syscall_epilogue(name);
2380}
2381#endif
2382
2383#ifdef TARGET_NR_openat
2384static void
2385print_openat(const struct syscallname *name,
2386 abi_long arg0, abi_long arg1, abi_long arg2,
2387 abi_long arg3, abi_long arg4, abi_long arg5)
2388{
Laurent Vivierd2ee72a2011-02-15 21:10:44 +01002389 int is_creat = (arg2 & TARGET_O_CREAT);
Mika Westerberg74d753a2009-04-07 16:57:29 +03002390
2391 print_syscall_prologue(name);
2392 print_at_dirfd(arg0, 0);
2393 print_string(arg1, 0);
2394 print_open_flags(arg2, (is_creat == 0));
2395 if (is_creat)
2396 print_file_mode(arg3, 1);
2397 print_syscall_epilogue(name);
2398}
2399#endif
2400
2401#ifdef TARGET_NR_mq_unlink
2402static void
2403print_mq_unlink(const struct syscallname *name,
2404 abi_long arg0, abi_long arg1, abi_long arg2,
2405 abi_long arg3, abi_long arg4, abi_long arg5)
2406{
2407 print_syscall_prologue(name);
2408 print_string(arg0, 1);
2409 print_syscall_epilogue(name);
2410}
2411#endif
2412
2413#if defined(TARGET_NR_fstatat64) || defined(TARGET_NR_newfstatat)
2414static void
2415print_fstatat64(const struct syscallname *name,
2416 abi_long arg0, abi_long arg1, abi_long arg2,
2417 abi_long arg3, abi_long arg4, abi_long arg5)
2418{
2419 print_syscall_prologue(name);
2420 print_at_dirfd(arg0, 0);
2421 print_string(arg1, 0);
2422 print_pointer(arg2, 0);
2423 print_flags(at_file_flags, arg3, 1);
2424 print_syscall_epilogue(name);
2425}
2426#define print_newfstatat print_fstatat64
2427#endif
2428
2429#ifdef TARGET_NR_readlink
2430static void
2431print_readlink(const struct syscallname *name,
2432 abi_long arg0, abi_long arg1, abi_long arg2,
2433 abi_long arg3, abi_long arg4, abi_long arg5)
2434{
2435 print_syscall_prologue(name);
2436 print_string(arg0, 0);
2437 print_pointer(arg1, 0);
Laurent Vivierd2ee72a2011-02-15 21:10:44 +01002438 print_raw_param("%u", arg2, 1);
Mika Westerberg74d753a2009-04-07 16:57:29 +03002439 print_syscall_epilogue(name);
2440}
2441#endif
2442
2443#ifdef TARGET_NR_readlinkat
2444static void
2445print_readlinkat(const struct syscallname *name,
2446 abi_long arg0, abi_long arg1, abi_long arg2,
2447 abi_long arg3, abi_long arg4, abi_long arg5)
2448{
2449 print_syscall_prologue(name);
2450 print_at_dirfd(arg0, 0);
2451 print_string(arg1, 0);
2452 print_pointer(arg2, 0);
Laurent Vivierd2ee72a2011-02-15 21:10:44 +01002453 print_raw_param("%u", arg3, 1);
Mika Westerberg74d753a2009-04-07 16:57:29 +03002454 print_syscall_epilogue(name);
2455}
2456#endif
2457
2458#ifdef TARGET_NR_rename
2459static void
2460print_rename(const struct syscallname *name,
2461 abi_long arg0, abi_long arg1, abi_long arg2,
2462 abi_long arg3, abi_long arg4, abi_long arg5)
2463{
2464 print_syscall_prologue(name);
2465 print_string(arg0, 0);
2466 print_string(arg1, 1);
2467 print_syscall_epilogue(name);
2468}
2469#endif
2470
2471#ifdef TARGET_NR_renameat
2472static void
2473print_renameat(const struct syscallname *name,
2474 abi_long arg0, abi_long arg1, abi_long arg2,
2475 abi_long arg3, abi_long arg4, abi_long arg5)
2476{
2477 print_syscall_prologue(name);
2478 print_at_dirfd(arg0, 0);
2479 print_string(arg1, 0);
2480 print_at_dirfd(arg2, 0);
2481 print_string(arg3, 1);
2482 print_syscall_epilogue(name);
2483}
2484#endif
2485
2486#ifdef TARGET_NR_statfs
2487static void
2488print_statfs(const struct syscallname *name,
2489 abi_long arg0, abi_long arg1, abi_long arg2,
2490 abi_long arg3, abi_long arg4, abi_long arg5)
2491{
2492 print_syscall_prologue(name);
2493 print_string(arg0, 0);
2494 print_pointer(arg1, 1);
2495 print_syscall_epilogue(name);
2496}
Aleksandar Rikalo4f7f8922018-08-02 16:16:00 +02002497#endif
2498
2499#ifdef TARGET_NR_statfs64
2500static void
2501print_statfs64(const struct syscallname *name,
2502 abi_long arg0, abi_long arg1, abi_long arg2,
2503 abi_long arg3, abi_long arg4, abi_long arg5)
2504{
2505 print_syscall_prologue(name);
2506 print_string(arg0, 0);
2507 print_pointer(arg1, 1);
2508 print_syscall_epilogue(name);
2509}
Mika Westerberg74d753a2009-04-07 16:57:29 +03002510#endif
2511
2512#ifdef TARGET_NR_symlink
2513static void
2514print_symlink(const struct syscallname *name,
2515 abi_long arg0, abi_long arg1, abi_long arg2,
2516 abi_long arg3, abi_long arg4, abi_long arg5)
2517{
2518 print_syscall_prologue(name);
2519 print_string(arg0, 0);
2520 print_string(arg1, 1);
2521 print_syscall_epilogue(name);
2522}
2523#endif
2524
2525#ifdef TARGET_NR_symlinkat
2526static void
2527print_symlinkat(const struct syscallname *name,
2528 abi_long arg0, abi_long arg1, abi_long arg2,
2529 abi_long arg3, abi_long arg4, abi_long arg5)
2530{
2531 print_syscall_prologue(name);
2532 print_string(arg0, 0);
2533 print_at_dirfd(arg1, 0);
2534 print_string(arg2, 1);
2535 print_syscall_epilogue(name);
2536}
2537#endif
2538
2539#ifdef TARGET_NR_mount
2540static void
2541print_mount(const struct syscallname *name,
2542 abi_long arg0, abi_long arg1, abi_long arg2,
2543 abi_long arg3, abi_long arg4, abi_long arg5)
2544{
2545 print_syscall_prologue(name);
2546 print_string(arg0, 0);
2547 print_string(arg1, 0);
2548 print_string(arg2, 0);
2549 print_flags(mount_flags, arg3, 0);
2550 print_pointer(arg4, 1);
2551 print_syscall_epilogue(name);
2552}
2553#endif
2554
2555#ifdef TARGET_NR_umount
2556static void
2557print_umount(const struct syscallname *name,
2558 abi_long arg0, abi_long arg1, abi_long arg2,
2559 abi_long arg3, abi_long arg4, abi_long arg5)
2560{
2561 print_syscall_prologue(name);
2562 print_string(arg0, 1);
2563 print_syscall_epilogue(name);
2564}
2565#endif
2566
2567#ifdef TARGET_NR_umount2
2568static void
2569print_umount2(const struct syscallname *name,
2570 abi_long arg0, abi_long arg1, abi_long arg2,
2571 abi_long arg3, abi_long arg4, abi_long arg5)
2572{
2573 print_syscall_prologue(name);
2574 print_string(arg0, 0);
2575 print_flags(umount2_flags, arg1, 1);
2576 print_syscall_epilogue(name);
2577}
2578#endif
2579
2580#ifdef TARGET_NR_unlink
2581static void
2582print_unlink(const struct syscallname *name,
2583 abi_long arg0, abi_long arg1, abi_long arg2,
2584 abi_long arg3, abi_long arg4, abi_long arg5)
2585{
2586 print_syscall_prologue(name);
2587 print_string(arg0, 1);
2588 print_syscall_epilogue(name);
2589}
2590#endif
2591
2592#ifdef TARGET_NR_unlinkat
2593static void
2594print_unlinkat(const struct syscallname *name,
2595 abi_long arg0, abi_long arg1, abi_long arg2,
2596 abi_long arg3, abi_long arg4, abi_long arg5)
2597{
2598 print_syscall_prologue(name);
2599 print_at_dirfd(arg0, 0);
2600 print_string(arg1, 0);
2601 print_flags(unlinkat_flags, arg2, 1);
2602 print_syscall_epilogue(name);
2603}
2604#endif
2605
2606#ifdef TARGET_NR_utime
2607static void
2608print_utime(const struct syscallname *name,
2609 abi_long arg0, abi_long arg1, abi_long arg2,
2610 abi_long arg3, abi_long arg4, abi_long arg5)
2611{
2612 print_syscall_prologue(name);
2613 print_string(arg0, 0);
2614 print_pointer(arg1, 1);
2615 print_syscall_epilogue(name);
2616}
2617#endif
2618
2619#ifdef TARGET_NR_utimes
2620static void
2621print_utimes(const struct syscallname *name,
2622 abi_long arg0, abi_long arg1, abi_long arg2,
2623 abi_long arg3, abi_long arg4, abi_long arg5)
2624{
2625 print_syscall_prologue(name);
2626 print_string(arg0, 0);
2627 print_pointer(arg1, 1);
2628 print_syscall_epilogue(name);
2629}
2630#endif
2631
2632#ifdef TARGET_NR_utimensat
2633static void
2634print_utimensat(const struct syscallname *name,
2635 abi_long arg0, abi_long arg1, abi_long arg2,
2636 abi_long arg3, abi_long arg4, abi_long arg5)
2637{
2638 print_syscall_prologue(name);
2639 print_at_dirfd(arg0, 0);
2640 print_string(arg1, 0);
2641 print_pointer(arg2, 0);
2642 print_flags(at_file_flags, arg3, 1);
2643 print_syscall_epilogue(name);
2644}
2645#endif
2646
Mike Frysinger8d9016c2011-02-07 01:05:57 -05002647#if defined(TARGET_NR_mmap) || defined(TARGET_NR_mmap2)
Mika Westerberg74d753a2009-04-07 16:57:29 +03002648static void
2649print_mmap(const struct syscallname *name,
2650 abi_long arg0, abi_long arg1, abi_long arg2,
2651 abi_long arg3, abi_long arg4, abi_long arg5)
2652{
2653 print_syscall_prologue(name);
2654 print_pointer(arg0, 0);
Laurent Vivierd2ee72a2011-02-15 21:10:44 +01002655 print_raw_param("%d", arg1, 0);
Mika Westerberg74d753a2009-04-07 16:57:29 +03002656 print_flags(mmap_prot_flags, arg2, 0);
2657 print_flags(mmap_flags, arg3, 0);
Laurent Vivierd2ee72a2011-02-15 21:10:44 +01002658 print_raw_param("%d", arg4, 0);
2659 print_raw_param("%#x", arg5, 1);
Mika Westerberg74d753a2009-04-07 16:57:29 +03002660 print_syscall_epilogue(name);
2661}
2662#define print_mmap2 print_mmap
2663#endif
2664
2665#ifdef TARGET_NR_mprotect
2666static void
2667print_mprotect(const struct syscallname *name,
2668 abi_long arg0, abi_long arg1, abi_long arg2,
2669 abi_long arg3, abi_long arg4, abi_long arg5)
2670{
2671 print_syscall_prologue(name);
2672 print_pointer(arg0, 0);
Laurent Vivierd2ee72a2011-02-15 21:10:44 +01002673 print_raw_param("%d", arg1, 0);
Mika Westerberg74d753a2009-04-07 16:57:29 +03002674 print_flags(mmap_prot_flags, arg2, 1);
2675 print_syscall_epilogue(name);
2676}
2677#endif
2678
2679#ifdef TARGET_NR_munmap
2680static void
2681print_munmap(const struct syscallname *name,
2682 abi_long arg0, abi_long arg1, abi_long arg2,
2683 abi_long arg3, abi_long arg4, abi_long arg5)
2684{
2685 print_syscall_prologue(name);
2686 print_pointer(arg0, 0);
Laurent Vivierd2ee72a2011-02-15 21:10:44 +01002687 print_raw_param("%d", arg1, 1);
Mika Westerberg74d753a2009-04-07 16:57:29 +03002688 print_syscall_epilogue(name);
2689}
2690#endif
2691
2692#ifdef TARGET_NR_futex
2693static void print_futex_op(abi_long tflag, int last)
2694{
2695#define print_op(val) \
2696if( cmd == val ) { \
Josh Kunz4b25a502020-02-03 18:54:14 -08002697 qemu_log(#val); \
Mika Westerberg74d753a2009-04-07 16:57:29 +03002698 return; \
2699}
2700
Laurent Vivierd2ee72a2011-02-15 21:10:44 +01002701 int cmd = (int)tflag;
Mika Westerberg74d753a2009-04-07 16:57:29 +03002702#ifdef FUTEX_PRIVATE_FLAG
Paul Brook5f2243f2010-02-19 16:04:51 +00002703 if (cmd & FUTEX_PRIVATE_FLAG) {
Josh Kunz4b25a502020-02-03 18:54:14 -08002704 qemu_log("FUTEX_PRIVATE_FLAG|");
Paul Brook5f2243f2010-02-19 16:04:51 +00002705 cmd &= ~FUTEX_PRIVATE_FLAG;
2706 }
Mika Westerberg74d753a2009-04-07 16:57:29 +03002707#endif
John Rigbybfb669f2013-02-23 16:14:08 -07002708#ifdef FUTEX_CLOCK_REALTIME
2709 if (cmd & FUTEX_CLOCK_REALTIME) {
Josh Kunz4b25a502020-02-03 18:54:14 -08002710 qemu_log("FUTEX_CLOCK_REALTIME|");
John Rigbybfb669f2013-02-23 16:14:08 -07002711 cmd &= ~FUTEX_CLOCK_REALTIME;
2712 }
2713#endif
Mika Westerberg74d753a2009-04-07 16:57:29 +03002714 print_op(FUTEX_WAIT)
2715 print_op(FUTEX_WAKE)
2716 print_op(FUTEX_FD)
2717 print_op(FUTEX_REQUEUE)
2718 print_op(FUTEX_CMP_REQUEUE)
2719 print_op(FUTEX_WAKE_OP)
2720 print_op(FUTEX_LOCK_PI)
2721 print_op(FUTEX_UNLOCK_PI)
2722 print_op(FUTEX_TRYLOCK_PI)
2723#ifdef FUTEX_WAIT_BITSET
2724 print_op(FUTEX_WAIT_BITSET)
2725#endif
2726#ifdef FUTEX_WAKE_BITSET
2727 print_op(FUTEX_WAKE_BITSET)
2728#endif
2729 /* unknown values */
Josh Kunz4b25a502020-02-03 18:54:14 -08002730 qemu_log("%d", cmd);
Mika Westerberg74d753a2009-04-07 16:57:29 +03002731}
2732
2733static void
2734print_futex(const struct syscallname *name,
2735 abi_long arg0, abi_long arg1, abi_long arg2,
2736 abi_long arg3, abi_long arg4, abi_long arg5)
2737{
2738 print_syscall_prologue(name);
2739 print_pointer(arg0, 0);
2740 print_futex_op(arg1, 0);
Laurent Vivierd2ee72a2011-02-15 21:10:44 +01002741 print_raw_param(",%d", arg2, 0);
Mika Westerberg74d753a2009-04-07 16:57:29 +03002742 print_pointer(arg3, 0); /* struct timespec */
2743 print_pointer(arg4, 0);
Laurent Vivierd2ee72a2011-02-15 21:10:44 +01002744 print_raw_param("%d", arg4, 1);
Mika Westerberg74d753a2009-04-07 16:57:29 +03002745 print_syscall_epilogue(name);
2746}
2747#endif
2748
Laurent Vivier608e5592011-04-07 00:25:32 +02002749#ifdef TARGET_NR_kill
2750static void
2751print_kill(const struct syscallname *name,
2752 abi_long arg0, abi_long arg1, abi_long arg2,
2753 abi_long arg3, abi_long arg4, abi_long arg5)
2754{
2755 print_syscall_prologue(name);
2756 print_raw_param("%d", arg0, 0);
2757 print_signal(arg1, 1);
2758 print_syscall_epilogue(name);
2759}
2760#endif
2761
Miloš Stojanović51622642017-05-15 16:59:42 +02002762#ifdef TARGET_NR_tkill
2763static void
2764print_tkill(const struct syscallname *name,
2765 abi_long arg0, abi_long arg1, abi_long arg2,
2766 abi_long arg3, abi_long arg4, abi_long arg5)
2767{
2768 print_syscall_prologue(name);
2769 print_raw_param("%d", arg0, 0);
2770 print_signal(arg1, 1);
2771 print_syscall_epilogue(name);
2772}
2773#endif
2774
2775#ifdef TARGET_NR_tgkill
2776static void
2777print_tgkill(const struct syscallname *name,
2778 abi_long arg0, abi_long arg1, abi_long arg2,
2779 abi_long arg3, abi_long arg4, abi_long arg5)
2780{
2781 print_syscall_prologue(name);
2782 print_raw_param("%d", arg0, 0);
2783 print_raw_param("%d", arg1, 0);
2784 print_signal(arg2, 1);
2785 print_syscall_epilogue(name);
2786}
2787#endif
2788
Jim Wilsond42744f2019-06-28 12:43:35 +02002789#ifdef TARGET_NR_statx
2790static void
2791print_statx(const struct syscallname *name,
2792 abi_long arg0, abi_long arg1, abi_long arg2,
2793 abi_long arg3, abi_long arg4, abi_long arg5)
2794{
2795 print_syscall_prologue(name);
2796 print_at_dirfd(arg0, 0);
2797 print_string(arg1, 0);
2798 print_flags(statx_flags, arg2, 0);
2799 print_flags(statx_mask, arg3, 0);
2800 print_pointer(arg4, 1);
2801 print_syscall_epilogue(name);
2802}
2803#endif
2804
ths33189d32007-11-01 00:13:36 +00002805/*
2806 * An array of all of the syscalls we know about
2807 */
2808
blueswir17ccfb2e2008-09-14 06:45:34 +00002809static const struct syscallname scnames[] = {
ths33189d32007-11-01 00:13:36 +00002810#include "strace.list"
2811};
2812
malcb1503cd2008-12-22 20:33:55 +00002813static int nsyscalls = ARRAY_SIZE(scnames);
ths33189d32007-11-01 00:13:36 +00002814
2815/*
2816 * The public interface to this module.
2817 */
2818void
2819print_syscall(int num,
bellardc16f9ed2007-11-11 17:23:29 +00002820 abi_long arg1, abi_long arg2, abi_long arg3,
2821 abi_long arg4, abi_long arg5, abi_long arg6)
ths33189d32007-11-01 00:13:36 +00002822{
2823 int i;
blueswir17ccfb2e2008-09-14 06:45:34 +00002824 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 ")";
ths33189d32007-11-01 00:13:36 +00002825
Josh Kunz4b25a502020-02-03 18:54:14 -08002826 qemu_log("%d ", getpid());
ths33189d32007-11-01 00:13:36 +00002827
2828 for(i=0;i<nsyscalls;i++)
2829 if( scnames[i].nr == num ) {
2830 if( scnames[i].call != NULL ) {
Josh Kunz4b25a502020-02-03 18:54:14 -08002831 scnames[i].call(
2832 &scnames[i], arg1, arg2, arg3, arg4, arg5, arg6);
ths33189d32007-11-01 00:13:36 +00002833 } else {
bellard6b23f772007-11-14 18:04:05 +00002834 /* XXX: this format system is broken because it uses
2835 host types and host pointers for strings */
ths33189d32007-11-01 00:13:36 +00002836 if( scnames[i].format != NULL )
2837 format = scnames[i].format;
Josh Kunz4b25a502020-02-03 18:54:14 -08002838 qemu_log(format,
2839 scnames[i].name, arg1, arg2, arg3, arg4, arg5, arg6);
ths33189d32007-11-01 00:13:36 +00002840 }
pbrook74c11e52008-05-29 13:49:09 +00002841 return;
ths33189d32007-11-01 00:13:36 +00002842 }
Josh Kunz4b25a502020-02-03 18:54:14 -08002843 qemu_log("Unknown syscall %d\n", num);
ths33189d32007-11-01 00:13:36 +00002844}
2845
2846
2847void
bellardc16f9ed2007-11-11 17:23:29 +00002848print_syscall_ret(int num, abi_long ret)
ths33189d32007-11-01 00:13:36 +00002849{
2850 int i;
Peter Maydell7dcdaea2016-06-06 19:58:18 +01002851 const char *errstr = NULL;
ths33189d32007-11-01 00:13:36 +00002852
2853 for(i=0;i<nsyscalls;i++)
2854 if( scnames[i].nr == num ) {
2855 if( scnames[i].result != NULL ) {
Josh Kunz4b25a502020-02-03 18:54:14 -08002856 scnames[i].result(&scnames[i], ret);
ths33189d32007-11-01 00:13:36 +00002857 } else {
Alexander Graf962b2892011-11-21 12:04:07 +01002858 if (ret < 0) {
2859 errstr = target_strerror(-ret);
2860 }
2861 if (errstr) {
Josh Kunz4b25a502020-02-03 18:54:14 -08002862 qemu_log(" = -1 errno=" TARGET_ABI_FMT_ld " (%s)\n",
Alexander Graf962b2892011-11-21 12:04:07 +01002863 -ret, errstr);
ths33189d32007-11-01 00:13:36 +00002864 } else {
Josh Kunz4b25a502020-02-03 18:54:14 -08002865 qemu_log(" = " TARGET_ABI_FMT_ld "\n", ret);
ths33189d32007-11-01 00:13:36 +00002866 }
2867 }
2868 break;
2869 }
2870}
Peter Maydell0cb581d2016-07-18 18:12:24 +01002871
2872void print_taken_signal(int target_signum, const target_siginfo_t *tinfo)
2873{
2874 /* Print the strace output for a signal being taken:
2875 * --- SIGSEGV {si_signo=SIGSEGV, si_code=SI_KERNEL, si_addr=0} ---
2876 */
Josh Kunz4b25a502020-02-03 18:54:14 -08002877 qemu_log("--- ");
Peter Maydell0cb581d2016-07-18 18:12:24 +01002878 print_signal(target_signum, 1);
Josh Kunz4b25a502020-02-03 18:54:14 -08002879 qemu_log(" ");
Peter Maydell0cb581d2016-07-18 18:12:24 +01002880 print_siginfo(tinfo);
Josh Kunz4b25a502020-02-03 18:54:14 -08002881 qemu_log(" ---\n");
Peter Maydell0cb581d2016-07-18 18:12:24 +01002882}