linux-user: add SO_PEERCRED support for getsockopt
[qemu.git] / linux-user / strace.c
1 #include <stdio.h>
2 #include <errno.h>
3 #include <sys/ipc.h>
4 #include <sys/msg.h>
5 #include <sys/sem.h>
6 #include <sys/shm.h>
7 #include <sys/select.h>
8 #include <sys/types.h>
9 #include <sys/mount.h>
10 #include <sys/mman.h>
11 #include <unistd.h>
12 #include <sched.h>
13 #include "qemu.h"
14
15 int do_strace=0;
16
17 struct syscallname {
18 int nr;
19 const char *name;
20 const char *format;
21 void (*call)(const struct syscallname *,
22 abi_long, abi_long, abi_long,
23 abi_long, abi_long, abi_long);
24 void (*result)(const struct syscallname *, abi_long);
25 };
26
27 #ifdef __GNUC__
28 /*
29 * It is possible that target doesn't have syscall that uses
30 * following flags but we don't want the compiler to warn
31 * us about them being unused. Same applies to utility print
32 * functions. It is ok to keep them while not used.
33 */
34 #define UNUSED __attribute__ ((unused))
35 #else
36 #define UNUSED
37 #endif
38
39 /*
40 * Structure used to translate flag values into strings. This is
41 * similar that is in the actual strace tool.
42 */
43 struct flags {
44 abi_long f_value; /* flag */
45 const char *f_string; /* stringified flag */
46 };
47
48 /* common flags for all architectures */
49 #define FLAG_GENERIC(name) { name, #name }
50 /* target specific flags (syscall_defs.h has TARGET_<flag>) */
51 #define FLAG_TARGET(name) { TARGET_ ## name, #name }
52 /* end of flags array */
53 #define FLAG_END { 0, NULL }
54
55 UNUSED static const char *get_comma(int);
56 UNUSED static void print_pointer(abi_long, int);
57 UNUSED static void print_flags(const struct flags *, abi_long, int);
58 UNUSED static void print_at_dirfd(abi_long, int);
59 UNUSED static void print_file_mode(abi_long, int);
60 UNUSED static void print_open_flags(abi_long, int);
61 UNUSED static void print_syscall_prologue(const struct syscallname *);
62 UNUSED static void print_syscall_epilogue(const struct syscallname *);
63 UNUSED static void print_string(abi_long, int);
64 UNUSED static void print_raw_param(const char *, abi_long, int);
65 UNUSED static void print_timeval(abi_ulong, int);
66 UNUSED static void print_number(abi_long, int);
67 UNUSED static void print_signal(abi_ulong, int);
68
69 /*
70 * Utility functions
71 */
72 static void
73 print_ipc_cmd(int cmd)
74 {
75 #define output_cmd(val) \
76 if( cmd == val ) { \
77 gemu_log(#val); \
78 return; \
79 }
80
81 cmd &= 0xff;
82
83 /* General IPC commands */
84 output_cmd( IPC_RMID );
85 output_cmd( IPC_SET );
86 output_cmd( IPC_STAT );
87 output_cmd( IPC_INFO );
88 /* msgctl() commands */
89 #ifdef __USER_MISC
90 output_cmd( MSG_STAT );
91 output_cmd( MSG_INFO );
92 #endif
93 /* shmctl() commands */
94 output_cmd( SHM_LOCK );
95 output_cmd( SHM_UNLOCK );
96 output_cmd( SHM_STAT );
97 output_cmd( SHM_INFO );
98 /* semctl() commands */
99 output_cmd( GETPID );
100 output_cmd( GETVAL );
101 output_cmd( GETALL );
102 output_cmd( GETNCNT );
103 output_cmd( GETZCNT );
104 output_cmd( SETVAL );
105 output_cmd( SETALL );
106 output_cmd( SEM_STAT );
107 output_cmd( SEM_INFO );
108 output_cmd( IPC_RMID );
109 output_cmd( IPC_RMID );
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
118 /* Some value we don't recognize */
119 gemu_log("%d",cmd);
120 }
121
122 static void
123 print_signal(abi_ulong arg, int last)
124 {
125 const char *signal_name = NULL;
126 switch(arg) {
127 case TARGET_SIGHUP: signal_name = "SIGHUP"; break;
128 case TARGET_SIGINT: signal_name = "SIGINT"; break;
129 case TARGET_SIGQUIT: signal_name = "SIGQUIT"; break;
130 case TARGET_SIGILL: signal_name = "SIGILL"; break;
131 case TARGET_SIGABRT: signal_name = "SIGABRT"; break;
132 case TARGET_SIGFPE: signal_name = "SIGFPE"; break;
133 case TARGET_SIGKILL: signal_name = "SIGKILL"; break;
134 case TARGET_SIGSEGV: signal_name = "SIGSEGV"; break;
135 case TARGET_SIGPIPE: signal_name = "SIGPIPE"; break;
136 case TARGET_SIGALRM: signal_name = "SIGALRM"; break;
137 case TARGET_SIGTERM: signal_name = "SIGTERM"; break;
138 case TARGET_SIGUSR1: signal_name = "SIGUSR1"; break;
139 case TARGET_SIGUSR2: signal_name = "SIGUSR2"; break;
140 case TARGET_SIGCHLD: signal_name = "SIGCHLD"; break;
141 case TARGET_SIGCONT: signal_name = "SIGCONT"; break;
142 case TARGET_SIGSTOP: signal_name = "SIGSTOP"; break;
143 case TARGET_SIGTTIN: signal_name = "SIGTTIN"; break;
144 case TARGET_SIGTTOU: signal_name = "SIGTTOU"; break;
145 }
146 if (signal_name == NULL) {
147 print_raw_param("%ld", arg, 1);
148 return;
149 }
150 gemu_log("%s%s", signal_name, get_comma(last));
151 }
152
153 #ifdef TARGET_NR__newselect
154 static void
155 print_fdset(int n, abi_ulong target_fds_addr)
156 {
157 int i;
158
159 gemu_log("[");
160 if( target_fds_addr ) {
161 abi_long *target_fds;
162
163 target_fds = lock_user(VERIFY_READ,
164 target_fds_addr,
165 sizeof(*target_fds)*(n / TARGET_ABI_BITS + 1),
166 1);
167
168 if (!target_fds)
169 return;
170
171 for (i=n; i>=0; i--) {
172 if ((tswapal(target_fds[i / TARGET_ABI_BITS]) >> (i & (TARGET_ABI_BITS - 1))) & 1)
173 gemu_log("%d,", i );
174 }
175 unlock_user(target_fds, target_fds_addr, 0);
176 }
177 gemu_log("]");
178 }
179 #endif
180
181 /*
182 * Sysycall specific output functions
183 */
184
185 /* select */
186 #ifdef TARGET_NR__newselect
187 static long newselect_arg1 = 0;
188 static long newselect_arg2 = 0;
189 static long newselect_arg3 = 0;
190 static long newselect_arg4 = 0;
191 static long newselect_arg5 = 0;
192
193 static void
194 print_newselect(const struct syscallname *name,
195 abi_long arg1, abi_long arg2, abi_long arg3,
196 abi_long arg4, abi_long arg5, abi_long arg6)
197 {
198 gemu_log("%s(" TARGET_ABI_FMT_ld ",", name->name, arg1);
199 print_fdset(arg1, arg2);
200 gemu_log(",");
201 print_fdset(arg1, arg3);
202 gemu_log(",");
203 print_fdset(arg1, arg4);
204 gemu_log(",");
205 print_timeval(arg5, 1);
206 gemu_log(")");
207
208 /* save for use in the return output function below */
209 newselect_arg1=arg1;
210 newselect_arg2=arg2;
211 newselect_arg3=arg3;
212 newselect_arg4=arg4;
213 newselect_arg5=arg5;
214 }
215 #endif
216
217 #ifdef TARGET_NR_semctl
218 static void
219 print_semctl(const struct syscallname *name,
220 abi_long arg1, abi_long arg2, abi_long arg3,
221 abi_long arg4, abi_long arg5, abi_long arg6)
222 {
223 gemu_log("%s(" TARGET_ABI_FMT_ld "," TARGET_ABI_FMT_ld ",", name->name, arg1, arg2);
224 print_ipc_cmd(arg3);
225 gemu_log(",0x" TARGET_ABI_FMT_lx ")", arg4);
226 }
227 #endif
228
229 static void
230 print_execve(const struct syscallname *name,
231 abi_long arg1, abi_long arg2, abi_long arg3,
232 abi_long arg4, abi_long arg5, abi_long arg6)
233 {
234 abi_ulong arg_ptr_addr;
235 char *s;
236
237 if (!(s = lock_user_string(arg1)))
238 return;
239 gemu_log("%s(\"%s\",{", name->name, s);
240 unlock_user(s, arg1, 0);
241
242 for (arg_ptr_addr = arg2; ; arg_ptr_addr += sizeof(abi_ulong)) {
243 abi_ulong *arg_ptr, arg_addr;
244
245 arg_ptr = lock_user(VERIFY_READ, arg_ptr_addr, sizeof(abi_ulong), 1);
246 if (!arg_ptr)
247 return;
248 arg_addr = tswapal(*arg_ptr);
249 unlock_user(arg_ptr, arg_ptr_addr, 0);
250 if (!arg_addr)
251 break;
252 if ((s = lock_user_string(arg_addr))) {
253 gemu_log("\"%s\",", s);
254 unlock_user(s, arg_addr, 0);
255 }
256 }
257
258 gemu_log("NULL})");
259 }
260
261 #ifdef TARGET_NR_ipc
262 static void
263 print_ipc(const struct syscallname *name,
264 abi_long arg1, abi_long arg2, abi_long arg3,
265 abi_long arg4, abi_long arg5, abi_long arg6)
266 {
267 switch(arg1) {
268 case IPCOP_semctl:
269 gemu_log("semctl(" TARGET_ABI_FMT_ld "," TARGET_ABI_FMT_ld ",", arg1, arg2);
270 print_ipc_cmd(arg3);
271 gemu_log(",0x" TARGET_ABI_FMT_lx ")", arg4);
272 break;
273 default:
274 gemu_log("%s(" TARGET_ABI_FMT_ld "," TARGET_ABI_FMT_ld "," TARGET_ABI_FMT_ld "," TARGET_ABI_FMT_ld ")",
275 name->name, arg1, arg2, arg3, arg4);
276 }
277 }
278 #endif
279
280 /*
281 * Variants for the return value output function
282 */
283
284 static void
285 print_syscall_ret_addr(const struct syscallname *name, abi_long ret)
286 {
287 if( ret == -1 ) {
288 gemu_log(" = -1 errno=%d (%s)\n", errno, target_strerror(errno));
289 } else {
290 gemu_log(" = 0x" TARGET_ABI_FMT_lx "\n", ret);
291 }
292 }
293
294 #if 0 /* currently unused */
295 static void
296 print_syscall_ret_raw(struct syscallname *name, abi_long ret)
297 {
298 gemu_log(" = 0x" TARGET_ABI_FMT_lx "\n", ret);
299 }
300 #endif
301
302 #ifdef TARGET_NR__newselect
303 static void
304 print_syscall_ret_newselect(const struct syscallname *name, abi_long ret)
305 {
306 gemu_log(" = 0x" TARGET_ABI_FMT_lx " (", ret);
307 print_fdset(newselect_arg1,newselect_arg2);
308 gemu_log(",");
309 print_fdset(newselect_arg1,newselect_arg3);
310 gemu_log(",");
311 print_fdset(newselect_arg1,newselect_arg4);
312 gemu_log(",");
313 print_timeval(newselect_arg5, 1);
314 gemu_log(")\n");
315 }
316 #endif
317
318 UNUSED static struct flags access_flags[] = {
319 FLAG_GENERIC(F_OK),
320 FLAG_GENERIC(R_OK),
321 FLAG_GENERIC(W_OK),
322 FLAG_GENERIC(X_OK),
323 FLAG_END,
324 };
325
326 UNUSED static struct flags at_file_flags[] = {
327 #ifdef AT_EACCESS
328 FLAG_GENERIC(AT_EACCESS),
329 #endif
330 #ifdef AT_SYMLINK_NOFOLLOW
331 FLAG_GENERIC(AT_SYMLINK_NOFOLLOW),
332 #endif
333 FLAG_END,
334 };
335
336 UNUSED static struct flags unlinkat_flags[] = {
337 #ifdef AT_REMOVEDIR
338 FLAG_GENERIC(AT_REMOVEDIR),
339 #endif
340 FLAG_END,
341 };
342
343 UNUSED static struct flags mode_flags[] = {
344 FLAG_GENERIC(S_IFSOCK),
345 FLAG_GENERIC(S_IFLNK),
346 FLAG_GENERIC(S_IFREG),
347 FLAG_GENERIC(S_IFBLK),
348 FLAG_GENERIC(S_IFDIR),
349 FLAG_GENERIC(S_IFCHR),
350 FLAG_GENERIC(S_IFIFO),
351 FLAG_END,
352 };
353
354 UNUSED static struct flags open_access_flags[] = {
355 FLAG_TARGET(O_RDONLY),
356 FLAG_TARGET(O_WRONLY),
357 FLAG_TARGET(O_RDWR),
358 FLAG_END,
359 };
360
361 UNUSED static struct flags open_flags[] = {
362 FLAG_TARGET(O_APPEND),
363 FLAG_TARGET(O_CREAT),
364 FLAG_TARGET(O_DIRECTORY),
365 FLAG_TARGET(O_EXCL),
366 FLAG_TARGET(O_LARGEFILE),
367 FLAG_TARGET(O_NOCTTY),
368 FLAG_TARGET(O_NOFOLLOW),
369 FLAG_TARGET(O_NONBLOCK), /* also O_NDELAY */
370 FLAG_TARGET(O_SYNC),
371 FLAG_TARGET(O_TRUNC),
372 #ifdef O_DIRECT
373 FLAG_TARGET(O_DIRECT),
374 #endif
375 FLAG_END,
376 };
377
378 UNUSED static struct flags mount_flags[] = {
379 #ifdef MS_BIND
380 FLAG_GENERIC(MS_BIND),
381 #endif
382 #ifdef MS_DIRSYNC
383 FLAG_GENERIC(MS_DIRSYNC),
384 #endif
385 FLAG_GENERIC(MS_MANDLOCK),
386 #ifdef MS_MOVE
387 FLAG_GENERIC(MS_MOVE),
388 #endif
389 FLAG_GENERIC(MS_NOATIME),
390 FLAG_GENERIC(MS_NODEV),
391 FLAG_GENERIC(MS_NODIRATIME),
392 FLAG_GENERIC(MS_NOEXEC),
393 FLAG_GENERIC(MS_NOSUID),
394 FLAG_GENERIC(MS_RDONLY),
395 #ifdef MS_RELATIME
396 FLAG_GENERIC(MS_RELATIME),
397 #endif
398 FLAG_GENERIC(MS_REMOUNT),
399 FLAG_GENERIC(MS_SYNCHRONOUS),
400 FLAG_END,
401 };
402
403 UNUSED static struct flags umount2_flags[] = {
404 #ifdef MNT_FORCE
405 FLAG_GENERIC(MNT_FORCE),
406 #endif
407 #ifdef MNT_DETACH
408 FLAG_GENERIC(MNT_DETACH),
409 #endif
410 #ifdef MNT_EXPIRE
411 FLAG_GENERIC(MNT_EXPIRE),
412 #endif
413 FLAG_END,
414 };
415
416 UNUSED static struct flags mmap_prot_flags[] = {
417 FLAG_GENERIC(PROT_NONE),
418 FLAG_GENERIC(PROT_EXEC),
419 FLAG_GENERIC(PROT_READ),
420 FLAG_GENERIC(PROT_WRITE),
421 FLAG_TARGET(PROT_SEM),
422 FLAG_GENERIC(PROT_GROWSDOWN),
423 FLAG_GENERIC(PROT_GROWSUP),
424 FLAG_END,
425 };
426
427 UNUSED static struct flags mmap_flags[] = {
428 FLAG_TARGET(MAP_SHARED),
429 FLAG_TARGET(MAP_PRIVATE),
430 FLAG_TARGET(MAP_ANONYMOUS),
431 FLAG_TARGET(MAP_DENYWRITE),
432 FLAG_TARGET(MAP_FIXED),
433 FLAG_TARGET(MAP_GROWSDOWN),
434 FLAG_TARGET(MAP_EXECUTABLE),
435 #ifdef MAP_LOCKED
436 FLAG_TARGET(MAP_LOCKED),
437 #endif
438 #ifdef MAP_NONBLOCK
439 FLAG_TARGET(MAP_NONBLOCK),
440 #endif
441 FLAG_TARGET(MAP_NORESERVE),
442 #ifdef MAP_POPULATE
443 FLAG_TARGET(MAP_POPULATE),
444 #endif
445 #ifdef TARGET_MAP_UNINITIALIZED
446 FLAG_TARGET(MAP_UNINITIALIZED),
447 #endif
448 FLAG_END,
449 };
450
451 UNUSED static struct flags fcntl_flags[] = {
452 FLAG_TARGET(F_DUPFD),
453 FLAG_TARGET(F_GETFD),
454 FLAG_TARGET(F_SETFD),
455 FLAG_TARGET(F_GETFL),
456 FLAG_TARGET(F_SETFL),
457 FLAG_TARGET(F_GETLK),
458 FLAG_TARGET(F_SETLK),
459 FLAG_TARGET(F_SETLKW),
460 FLAG_END,
461 };
462
463 UNUSED static struct flags clone_flags[] = {
464 FLAG_GENERIC(CLONE_VM),
465 FLAG_GENERIC(CLONE_FS),
466 FLAG_GENERIC(CLONE_FILES),
467 FLAG_GENERIC(CLONE_SIGHAND),
468 FLAG_GENERIC(CLONE_PTRACE),
469 FLAG_GENERIC(CLONE_VFORK),
470 FLAG_GENERIC(CLONE_PARENT),
471 FLAG_GENERIC(CLONE_THREAD),
472 FLAG_GENERIC(CLONE_NEWNS),
473 FLAG_GENERIC(CLONE_SYSVSEM),
474 FLAG_GENERIC(CLONE_SETTLS),
475 FLAG_GENERIC(CLONE_PARENT_SETTID),
476 FLAG_GENERIC(CLONE_CHILD_CLEARTID),
477 FLAG_GENERIC(CLONE_DETACHED),
478 FLAG_GENERIC(CLONE_UNTRACED),
479 FLAG_GENERIC(CLONE_CHILD_SETTID),
480 #if defined(CLONE_NEWUTS)
481 FLAG_GENERIC(CLONE_NEWUTS),
482 #endif
483 #if defined(CLONE_NEWIPC)
484 FLAG_GENERIC(CLONE_NEWIPC),
485 #endif
486 #if defined(CLONE_NEWUSER)
487 FLAG_GENERIC(CLONE_NEWUSER),
488 #endif
489 #if defined(CLONE_NEWPID)
490 FLAG_GENERIC(CLONE_NEWPID),
491 #endif
492 #if defined(CLONE_NEWNET)
493 FLAG_GENERIC(CLONE_NEWNET),
494 #endif
495 #if defined(CLONE_IO)
496 FLAG_GENERIC(CLONE_IO),
497 #endif
498 FLAG_END,
499 };
500
501 /*
502 * print_xxx utility functions. These are used to print syscall
503 * parameters in certain format. All of these have parameter
504 * named 'last'. This parameter is used to add comma to output
505 * when last == 0.
506 */
507
508 static const char *
509 get_comma(int last)
510 {
511 return ((last) ? "" : ",");
512 }
513
514 static void
515 print_flags(const struct flags *f, abi_long flags, int last)
516 {
517 const char *sep = "";
518 int n;
519
520 if ((flags == 0) && (f->f_value == 0)) {
521 gemu_log("%s%s", f->f_string, get_comma(last));
522 return;
523 }
524 for (n = 0; f->f_string != NULL; f++) {
525 if ((f->f_value != 0) && ((flags & f->f_value) == f->f_value)) {
526 gemu_log("%s%s", sep, f->f_string);
527 flags &= ~f->f_value;
528 sep = "|";
529 n++;
530 }
531 }
532
533 if (n > 0) {
534 /* print rest of the flags as numeric */
535 if (flags != 0) {
536 gemu_log("%s%#x%s", sep, (unsigned int)flags, get_comma(last));
537 } else {
538 gemu_log("%s", get_comma(last));
539 }
540 } else {
541 /* no string version of flags found, print them in hex then */
542 gemu_log("%#x%s", (unsigned int)flags, get_comma(last));
543 }
544 }
545
546 static void
547 print_at_dirfd(abi_long dirfd, int last)
548 {
549 #ifdef AT_FDCWD
550 if (dirfd == AT_FDCWD) {
551 gemu_log("AT_FDCWD%s", get_comma(last));
552 return;
553 }
554 #endif
555 gemu_log("%d%s", (int)dirfd, get_comma(last));
556 }
557
558 static void
559 print_file_mode(abi_long mode, int last)
560 {
561 const char *sep = "";
562 const struct flags *m;
563
564 for (m = &mode_flags[0]; m->f_string != NULL; m++) {
565 if ((m->f_value & mode) == m->f_value) {
566 gemu_log("%s%s", m->f_string, sep);
567 sep = "|";
568 mode &= ~m->f_value;
569 break;
570 }
571 }
572
573 mode &= ~S_IFMT;
574 /* print rest of the mode as octal */
575 if (mode != 0)
576 gemu_log("%s%#o", sep, (unsigned int)mode);
577
578 gemu_log("%s", get_comma(last));
579 }
580
581 static void
582 print_open_flags(abi_long flags, int last)
583 {
584 print_flags(open_access_flags, flags & TARGET_O_ACCMODE, 1);
585 flags &= ~TARGET_O_ACCMODE;
586 if (flags == 0) {
587 gemu_log("%s", get_comma(last));
588 return;
589 }
590 gemu_log("|");
591 print_flags(open_flags, flags, last);
592 }
593
594 static void
595 print_syscall_prologue(const struct syscallname *sc)
596 {
597 gemu_log("%s(", sc->name);
598 }
599
600 /*ARGSUSED*/
601 static void
602 print_syscall_epilogue(const struct syscallname *sc)
603 {
604 (void)sc;
605 gemu_log(")");
606 }
607
608 static void
609 print_string(abi_long addr, int last)
610 {
611 char *s;
612
613 if ((s = lock_user_string(addr)) != NULL) {
614 gemu_log("\"%s\"%s", s, get_comma(last));
615 unlock_user(s, addr, 0);
616 } else {
617 /* can't get string out of it, so print it as pointer */
618 print_pointer(addr, last);
619 }
620 }
621
622 /*
623 * Prints out raw parameter using given format. Caller needs
624 * to do byte swapping if needed.
625 */
626 static void
627 print_raw_param(const char *fmt, abi_long param, int last)
628 {
629 char format[64];
630
631 (void) snprintf(format, sizeof (format), "%s%s", fmt, get_comma(last));
632 gemu_log(format, param);
633 }
634
635 static void
636 print_pointer(abi_long p, int last)
637 {
638 if (p == 0)
639 gemu_log("NULL%s", get_comma(last));
640 else
641 gemu_log("0x" TARGET_ABI_FMT_lx "%s", p, get_comma(last));
642 }
643
644 /*
645 * Reads 32-bit (int) number from guest address space from
646 * address 'addr' and prints it.
647 */
648 static void
649 print_number(abi_long addr, int last)
650 {
651 if (addr == 0) {
652 gemu_log("NULL%s", get_comma(last));
653 } else {
654 int num;
655
656 get_user_s32(num, addr);
657 gemu_log("[%d]%s", num, get_comma(last));
658 }
659 }
660
661 static void
662 print_timeval(abi_ulong tv_addr, int last)
663 {
664 if( tv_addr ) {
665 struct target_timeval *tv;
666
667 tv = lock_user(VERIFY_READ, tv_addr, sizeof(*tv), 1);
668 if (!tv)
669 return;
670 gemu_log("{" TARGET_ABI_FMT_ld "," TARGET_ABI_FMT_ld "}%s",
671 tv->tv_sec, tv->tv_usec, get_comma(last));
672 unlock_user(tv, tv_addr, 0);
673 } else
674 gemu_log("NULL%s", get_comma(last));
675 }
676
677 #undef UNUSED
678
679 #ifdef TARGET_NR_accept
680 static void
681 print_accept(const struct syscallname *name,
682 abi_long arg0, abi_long arg1, abi_long arg2,
683 abi_long arg3, abi_long arg4, abi_long arg5)
684 {
685 print_syscall_prologue(name);
686 print_raw_param("%d", arg0, 0);
687 print_pointer(arg1, 0);
688 print_number(arg2, 1);
689 print_syscall_epilogue(name);
690 }
691 #endif
692
693 #ifdef TARGET_NR_access
694 static void
695 print_access(const struct syscallname *name,
696 abi_long arg0, abi_long arg1, abi_long arg2,
697 abi_long arg3, abi_long arg4, abi_long arg5)
698 {
699 print_syscall_prologue(name);
700 print_string(arg0, 0);
701 print_flags(access_flags, arg1, 1);
702 print_syscall_epilogue(name);
703 }
704 #endif
705
706 #ifdef TARGET_NR_brk
707 static void
708 print_brk(const struct syscallname *name,
709 abi_long arg0, abi_long arg1, abi_long arg2,
710 abi_long arg3, abi_long arg4, abi_long arg5)
711 {
712 print_syscall_prologue(name);
713 print_pointer(arg0, 1);
714 print_syscall_epilogue(name);
715 }
716 #endif
717
718 #ifdef TARGET_NR_chdir
719 static void
720 print_chdir(const struct syscallname *name,
721 abi_long arg0, abi_long arg1, abi_long arg2,
722 abi_long arg3, abi_long arg4, abi_long arg5)
723 {
724 print_syscall_prologue(name);
725 print_string(arg0, 1);
726 print_syscall_epilogue(name);
727 }
728 #endif
729
730 #ifdef TARGET_NR_chmod
731 static void
732 print_chmod(const struct syscallname *name,
733 abi_long arg0, abi_long arg1, abi_long arg2,
734 abi_long arg3, abi_long arg4, abi_long arg5)
735 {
736 print_syscall_prologue(name);
737 print_string(arg0, 0);
738 print_file_mode(arg1, 1);
739 print_syscall_epilogue(name);
740 }
741 #endif
742
743 #ifdef TARGET_NR_clone
744 static void
745 print_clone(const struct syscallname *name,
746 abi_long arg0, abi_long arg1, abi_long arg2,
747 abi_long arg3, abi_long arg4, abi_long arg5)
748 {
749 print_syscall_prologue(name);
750 #if defined(TARGET_M68K)
751 print_flags(clone_flags, arg0, 0);
752 print_raw_param("newsp=0x" TARGET_ABI_FMT_lx, arg1, 1);
753 #elif defined(TARGET_SH4) || defined(TARGET_ALPHA)
754 print_flags(clone_flags, arg0, 0);
755 print_raw_param("child_stack=0x" TARGET_ABI_FMT_lx, arg1, 0);
756 print_raw_param("parent_tidptr=0x" TARGET_ABI_FMT_lx, arg2, 0);
757 print_raw_param("child_tidptr=0x" TARGET_ABI_FMT_lx, arg3, 0);
758 print_raw_param("tls=0x" TARGET_ABI_FMT_lx, arg4, 1);
759 #elif defined(TARGET_CRIS)
760 print_raw_param("child_stack=0x" TARGET_ABI_FMT_lx, arg0, 0);
761 print_flags(clone_flags, arg1, 0);
762 print_raw_param("parent_tidptr=0x" TARGET_ABI_FMT_lx, arg2, 0);
763 print_raw_param("tls=0x" TARGET_ABI_FMT_lx, arg3, 0);
764 print_raw_param("child_tidptr=0x" TARGET_ABI_FMT_lx, arg4, 1);
765 #else
766 print_flags(clone_flags, arg0, 0);
767 print_raw_param("child_stack=0x" TARGET_ABI_FMT_lx, arg1, 0);
768 print_raw_param("parent_tidptr=0x" TARGET_ABI_FMT_lx, arg2, 0);
769 print_raw_param("tls=0x" TARGET_ABI_FMT_lx, arg3, 0);
770 print_raw_param("child_tidptr=0x" TARGET_ABI_FMT_lx, arg4, 1);
771 #endif
772 print_syscall_epilogue(name);
773 }
774 #endif
775
776 #ifdef TARGET_NR_creat
777 static void
778 print_creat(const struct syscallname *name,
779 abi_long arg0, abi_long arg1, abi_long arg2,
780 abi_long arg3, abi_long arg4, abi_long arg5)
781 {
782 print_syscall_prologue(name);
783 print_string(arg0, 0);
784 print_file_mode(arg1, 1);
785 print_syscall_epilogue(name);
786 }
787 #endif
788
789 #ifdef TARGET_NR_execv
790 static void
791 print_execv(const struct syscallname *name,
792 abi_long arg0, abi_long arg1, abi_long arg2,
793 abi_long arg3, abi_long arg4, abi_long arg5)
794 {
795 print_syscall_prologue(name);
796 print_string(arg0, 0);
797 print_raw_param("0x" TARGET_ABI_FMT_lx, arg1, 1);
798 print_syscall_epilogue(name);
799 }
800 #endif
801
802 #ifdef TARGET_NR_faccessat
803 static void
804 print_faccessat(const struct syscallname *name,
805 abi_long arg0, abi_long arg1, abi_long arg2,
806 abi_long arg3, abi_long arg4, abi_long arg5)
807 {
808 print_syscall_prologue(name);
809 print_at_dirfd(arg0, 0);
810 print_string(arg1, 0);
811 print_flags(access_flags, arg2, 0);
812 print_flags(at_file_flags, arg3, 1);
813 print_syscall_epilogue(name);
814 }
815 #endif
816
817 #ifdef TARGET_NR_fchmodat
818 static void
819 print_fchmodat(const struct syscallname *name,
820 abi_long arg0, abi_long arg1, abi_long arg2,
821 abi_long arg3, abi_long arg4, abi_long arg5)
822 {
823 print_syscall_prologue(name);
824 print_at_dirfd(arg0, 0);
825 print_string(arg1, 0);
826 print_file_mode(arg2, 0);
827 print_flags(at_file_flags, arg3, 1);
828 print_syscall_epilogue(name);
829 }
830 #endif
831
832 #ifdef TARGET_NR_fchownat
833 static void
834 print_fchownat(const struct syscallname *name,
835 abi_long arg0, abi_long arg1, abi_long arg2,
836 abi_long arg3, abi_long arg4, abi_long arg5)
837 {
838 print_syscall_prologue(name);
839 print_at_dirfd(arg0, 0);
840 print_string(arg1, 0);
841 print_raw_param("%d", arg2, 0);
842 print_raw_param("%d", arg3, 0);
843 print_flags(at_file_flags, arg4, 1);
844 print_syscall_epilogue(name);
845 }
846 #endif
847
848 #if defined(TARGET_NR_fcntl) || defined(TARGET_NR_fcntl64)
849 static void
850 print_fcntl(const struct syscallname *name,
851 abi_long arg0, abi_long arg1, abi_long arg2,
852 abi_long arg3, abi_long arg4, abi_long arg5)
853 {
854 print_syscall_prologue(name);
855 print_raw_param("%d", arg0, 0);
856 print_flags(fcntl_flags, arg1, 0);
857 /*
858 * TODO: check flags and print following argument only
859 * when needed.
860 */
861 print_pointer(arg2, 1);
862 print_syscall_epilogue(name);
863 }
864 #define print_fcntl64 print_fcntl
865 #endif
866
867
868 #ifdef TARGET_NR_futimesat
869 static void
870 print_futimesat(const struct syscallname *name,
871 abi_long arg0, abi_long arg1, abi_long arg2,
872 abi_long arg3, abi_long arg4, abi_long arg5)
873 {
874 print_syscall_prologue(name);
875 print_at_dirfd(arg0, 0);
876 print_string(arg1, 0);
877 print_timeval(arg2, 0);
878 print_timeval(arg2 + sizeof (struct target_timeval), 1);
879 print_syscall_epilogue(name);
880 }
881 #endif
882
883 #ifdef TARGET_NR_link
884 static void
885 print_link(const struct syscallname *name,
886 abi_long arg0, abi_long arg1, abi_long arg2,
887 abi_long arg3, abi_long arg4, abi_long arg5)
888 {
889 print_syscall_prologue(name);
890 print_string(arg0, 0);
891 print_string(arg1, 1);
892 print_syscall_epilogue(name);
893 }
894 #endif
895
896 #ifdef TARGET_NR_linkat
897 static void
898 print_linkat(const struct syscallname *name,
899 abi_long arg0, abi_long arg1, abi_long arg2,
900 abi_long arg3, abi_long arg4, abi_long arg5)
901 {
902 print_syscall_prologue(name);
903 print_at_dirfd(arg0, 0);
904 print_string(arg1, 0);
905 print_at_dirfd(arg2, 0);
906 print_string(arg3, 0);
907 print_flags(at_file_flags, arg4, 1);
908 print_syscall_epilogue(name);
909 }
910 #endif
911
912 #ifdef TARGET_NR__llseek
913 static void
914 print__llseek(const struct syscallname *name,
915 abi_long arg0, abi_long arg1, abi_long arg2,
916 abi_long arg3, abi_long arg4, abi_long arg5)
917 {
918 const char *whence = "UNKNOWN";
919 print_syscall_prologue(name);
920 print_raw_param("%d", arg0, 0);
921 print_raw_param("%ld", arg1, 0);
922 print_raw_param("%ld", arg2, 0);
923 print_pointer(arg3, 0);
924 switch(arg4) {
925 case SEEK_SET: whence = "SEEK_SET"; break;
926 case SEEK_CUR: whence = "SEEK_CUR"; break;
927 case SEEK_END: whence = "SEEK_END"; break;
928 }
929 gemu_log("%s",whence);
930 print_syscall_epilogue(name);
931 }
932 #endif
933
934 #if defined(TARGET_NR_stat) || defined(TARGET_NR_stat64) || \
935 defined(TARGET_NR_lstat) || defined(TARGET_NR_lstat64)
936 static void
937 print_stat(const struct syscallname *name,
938 abi_long arg0, abi_long arg1, abi_long arg2,
939 abi_long arg3, abi_long arg4, abi_long arg5)
940 {
941 print_syscall_prologue(name);
942 print_string(arg0, 0);
943 print_pointer(arg1, 1);
944 print_syscall_epilogue(name);
945 }
946 #define print_lstat print_stat
947 #define print_stat64 print_stat
948 #define print_lstat64 print_stat
949 #endif
950
951 #if defined(TARGET_NR_fstat) || defined(TARGET_NR_fstat64)
952 static void
953 print_fstat(const struct syscallname *name,
954 abi_long arg0, abi_long arg1, abi_long arg2,
955 abi_long arg3, abi_long arg4, abi_long arg5)
956 {
957 print_syscall_prologue(name);
958 print_raw_param("%d", arg0, 0);
959 print_pointer(arg1, 1);
960 print_syscall_epilogue(name);
961 }
962 #define print_fstat64 print_fstat
963 #endif
964
965 #ifdef TARGET_NR_mkdir
966 static void
967 print_mkdir(const struct syscallname *name,
968 abi_long arg0, abi_long arg1, abi_long arg2,
969 abi_long arg3, abi_long arg4, abi_long arg5)
970 {
971 print_syscall_prologue(name);
972 print_string(arg0, 0);
973 print_file_mode(arg1, 1);
974 print_syscall_epilogue(name);
975 }
976 #endif
977
978 #ifdef TARGET_NR_mkdirat
979 static void
980 print_mkdirat(const struct syscallname *name,
981 abi_long arg0, abi_long arg1, abi_long arg2,
982 abi_long arg3, abi_long arg4, abi_long arg5)
983 {
984 print_syscall_prologue(name);
985 print_at_dirfd(arg0, 0);
986 print_string(arg1, 0);
987 print_file_mode(arg2, 1);
988 print_syscall_epilogue(name);
989 }
990 #endif
991
992 #ifdef TARGET_NR_rmdir
993 static void
994 print_rmdir(const struct syscallname *name,
995 abi_long arg0, abi_long arg1, abi_long arg2,
996 abi_long arg3, abi_long arg4, abi_long arg5)
997 {
998 print_syscall_prologue(name);
999 print_string(arg0, 0);
1000 print_syscall_epilogue(name);
1001 }
1002 #endif
1003
1004 #ifdef TARGET_NR_rt_sigaction
1005 static void
1006 print_rt_sigaction(const struct syscallname *name,
1007 abi_long arg0, abi_long arg1, abi_long arg2,
1008 abi_long arg3, abi_long arg4, abi_long arg5)
1009 {
1010 print_syscall_prologue(name);
1011 print_signal(arg0, 0);
1012 print_pointer(arg1, 0);
1013 print_pointer(arg2, 1);
1014 print_syscall_epilogue(name);
1015 }
1016 #endif
1017
1018 #ifdef TARGET_NR_rt_sigprocmask
1019 static void
1020 print_rt_sigprocmask(const struct syscallname *name,
1021 abi_long arg0, abi_long arg1, abi_long arg2,
1022 abi_long arg3, abi_long arg4, abi_long arg5)
1023 {
1024 const char *how = "UNKNOWN";
1025 print_syscall_prologue(name);
1026 switch(arg0) {
1027 case TARGET_SIG_BLOCK: how = "SIG_BLOCK"; break;
1028 case TARGET_SIG_UNBLOCK: how = "SIG_UNBLOCK"; break;
1029 case TARGET_SIG_SETMASK: how = "SIG_SETMASK"; break;
1030 }
1031 gemu_log("%s,",how);
1032 print_pointer(arg1, 0);
1033 print_pointer(arg2, 1);
1034 print_syscall_epilogue(name);
1035 }
1036 #endif
1037
1038 #ifdef TARGET_NR_mknod
1039 static void
1040 print_mknod(const struct syscallname *name,
1041 abi_long arg0, abi_long arg1, abi_long arg2,
1042 abi_long arg3, abi_long arg4, abi_long arg5)
1043 {
1044 int hasdev = (arg1 & (S_IFCHR|S_IFBLK));
1045
1046 print_syscall_prologue(name);
1047 print_string(arg0, 0);
1048 print_file_mode(arg1, (hasdev == 0));
1049 if (hasdev) {
1050 print_raw_param("makedev(%d", major(arg2), 0);
1051 print_raw_param("%d)", minor(arg2), 1);
1052 }
1053 print_syscall_epilogue(name);
1054 }
1055 #endif
1056
1057 #ifdef TARGET_NR_mknodat
1058 static void
1059 print_mknodat(const struct syscallname *name,
1060 abi_long arg0, abi_long arg1, abi_long arg2,
1061 abi_long arg3, abi_long arg4, abi_long arg5)
1062 {
1063 int hasdev = (arg2 & (S_IFCHR|S_IFBLK));
1064
1065 print_syscall_prologue(name);
1066 print_at_dirfd(arg0, 0);
1067 print_string(arg1, 0);
1068 print_file_mode(arg2, (hasdev == 0));
1069 if (hasdev) {
1070 print_raw_param("makedev(%d", major(arg3), 0);
1071 print_raw_param("%d)", minor(arg3), 1);
1072 }
1073 print_syscall_epilogue(name);
1074 }
1075 #endif
1076
1077 #ifdef TARGET_NR_mq_open
1078 static void
1079 print_mq_open(const struct syscallname *name,
1080 abi_long arg0, abi_long arg1, abi_long arg2,
1081 abi_long arg3, abi_long arg4, abi_long arg5)
1082 {
1083 int is_creat = (arg1 & TARGET_O_CREAT);
1084
1085 print_syscall_prologue(name);
1086 print_string(arg0, 0);
1087 print_open_flags(arg1, (is_creat == 0));
1088 if (is_creat) {
1089 print_file_mode(arg2, 0);
1090 print_pointer(arg3, 1);
1091 }
1092 print_syscall_epilogue(name);
1093 }
1094 #endif
1095
1096 #ifdef TARGET_NR_open
1097 static void
1098 print_open(const struct syscallname *name,
1099 abi_long arg0, abi_long arg1, abi_long arg2,
1100 abi_long arg3, abi_long arg4, abi_long arg5)
1101 {
1102 int is_creat = (arg1 & TARGET_O_CREAT);
1103
1104 print_syscall_prologue(name);
1105 print_string(arg0, 0);
1106 print_open_flags(arg1, (is_creat == 0));
1107 if (is_creat)
1108 print_file_mode(arg2, 1);
1109 print_syscall_epilogue(name);
1110 }
1111 #endif
1112
1113 #ifdef TARGET_NR_openat
1114 static void
1115 print_openat(const struct syscallname *name,
1116 abi_long arg0, abi_long arg1, abi_long arg2,
1117 abi_long arg3, abi_long arg4, abi_long arg5)
1118 {
1119 int is_creat = (arg2 & TARGET_O_CREAT);
1120
1121 print_syscall_prologue(name);
1122 print_at_dirfd(arg0, 0);
1123 print_string(arg1, 0);
1124 print_open_flags(arg2, (is_creat == 0));
1125 if (is_creat)
1126 print_file_mode(arg3, 1);
1127 print_syscall_epilogue(name);
1128 }
1129 #endif
1130
1131 #ifdef TARGET_NR_mq_unlink
1132 static void
1133 print_mq_unlink(const struct syscallname *name,
1134 abi_long arg0, abi_long arg1, abi_long arg2,
1135 abi_long arg3, abi_long arg4, abi_long arg5)
1136 {
1137 print_syscall_prologue(name);
1138 print_string(arg0, 1);
1139 print_syscall_epilogue(name);
1140 }
1141 #endif
1142
1143 #if defined(TARGET_NR_fstatat64) || defined(TARGET_NR_newfstatat)
1144 static void
1145 print_fstatat64(const struct syscallname *name,
1146 abi_long arg0, abi_long arg1, abi_long arg2,
1147 abi_long arg3, abi_long arg4, abi_long arg5)
1148 {
1149 print_syscall_prologue(name);
1150 print_at_dirfd(arg0, 0);
1151 print_string(arg1, 0);
1152 print_pointer(arg2, 0);
1153 print_flags(at_file_flags, arg3, 1);
1154 print_syscall_epilogue(name);
1155 }
1156 #define print_newfstatat print_fstatat64
1157 #endif
1158
1159 #ifdef TARGET_NR_readlink
1160 static void
1161 print_readlink(const struct syscallname *name,
1162 abi_long arg0, abi_long arg1, abi_long arg2,
1163 abi_long arg3, abi_long arg4, abi_long arg5)
1164 {
1165 print_syscall_prologue(name);
1166 print_string(arg0, 0);
1167 print_pointer(arg1, 0);
1168 print_raw_param("%u", arg2, 1);
1169 print_syscall_epilogue(name);
1170 }
1171 #endif
1172
1173 #ifdef TARGET_NR_readlinkat
1174 static void
1175 print_readlinkat(const struct syscallname *name,
1176 abi_long arg0, abi_long arg1, abi_long arg2,
1177 abi_long arg3, abi_long arg4, abi_long arg5)
1178 {
1179 print_syscall_prologue(name);
1180 print_at_dirfd(arg0, 0);
1181 print_string(arg1, 0);
1182 print_pointer(arg2, 0);
1183 print_raw_param("%u", arg3, 1);
1184 print_syscall_epilogue(name);
1185 }
1186 #endif
1187
1188 #ifdef TARGET_NR_rename
1189 static void
1190 print_rename(const struct syscallname *name,
1191 abi_long arg0, abi_long arg1, abi_long arg2,
1192 abi_long arg3, abi_long arg4, abi_long arg5)
1193 {
1194 print_syscall_prologue(name);
1195 print_string(arg0, 0);
1196 print_string(arg1, 1);
1197 print_syscall_epilogue(name);
1198 }
1199 #endif
1200
1201 #ifdef TARGET_NR_renameat
1202 static void
1203 print_renameat(const struct syscallname *name,
1204 abi_long arg0, abi_long arg1, abi_long arg2,
1205 abi_long arg3, abi_long arg4, abi_long arg5)
1206 {
1207 print_syscall_prologue(name);
1208 print_at_dirfd(arg0, 0);
1209 print_string(arg1, 0);
1210 print_at_dirfd(arg2, 0);
1211 print_string(arg3, 1);
1212 print_syscall_epilogue(name);
1213 }
1214 #endif
1215
1216 #ifdef TARGET_NR_statfs
1217 static void
1218 print_statfs(const struct syscallname *name,
1219 abi_long arg0, abi_long arg1, abi_long arg2,
1220 abi_long arg3, abi_long arg4, abi_long arg5)
1221 {
1222 print_syscall_prologue(name);
1223 print_string(arg0, 0);
1224 print_pointer(arg1, 1);
1225 print_syscall_epilogue(name);
1226 }
1227 #define print_statfs64 print_statfs
1228 #endif
1229
1230 #ifdef TARGET_NR_symlink
1231 static void
1232 print_symlink(const struct syscallname *name,
1233 abi_long arg0, abi_long arg1, abi_long arg2,
1234 abi_long arg3, abi_long arg4, abi_long arg5)
1235 {
1236 print_syscall_prologue(name);
1237 print_string(arg0, 0);
1238 print_string(arg1, 1);
1239 print_syscall_epilogue(name);
1240 }
1241 #endif
1242
1243 #ifdef TARGET_NR_symlinkat
1244 static void
1245 print_symlinkat(const struct syscallname *name,
1246 abi_long arg0, abi_long arg1, abi_long arg2,
1247 abi_long arg3, abi_long arg4, abi_long arg5)
1248 {
1249 print_syscall_prologue(name);
1250 print_string(arg0, 0);
1251 print_at_dirfd(arg1, 0);
1252 print_string(arg2, 1);
1253 print_syscall_epilogue(name);
1254 }
1255 #endif
1256
1257 #ifdef TARGET_NR_mount
1258 static void
1259 print_mount(const struct syscallname *name,
1260 abi_long arg0, abi_long arg1, abi_long arg2,
1261 abi_long arg3, abi_long arg4, abi_long arg5)
1262 {
1263 print_syscall_prologue(name);
1264 print_string(arg0, 0);
1265 print_string(arg1, 0);
1266 print_string(arg2, 0);
1267 print_flags(mount_flags, arg3, 0);
1268 print_pointer(arg4, 1);
1269 print_syscall_epilogue(name);
1270 }
1271 #endif
1272
1273 #ifdef TARGET_NR_umount
1274 static void
1275 print_umount(const struct syscallname *name,
1276 abi_long arg0, abi_long arg1, abi_long arg2,
1277 abi_long arg3, abi_long arg4, abi_long arg5)
1278 {
1279 print_syscall_prologue(name);
1280 print_string(arg0, 1);
1281 print_syscall_epilogue(name);
1282 }
1283 #endif
1284
1285 #ifdef TARGET_NR_umount2
1286 static void
1287 print_umount2(const struct syscallname *name,
1288 abi_long arg0, abi_long arg1, abi_long arg2,
1289 abi_long arg3, abi_long arg4, abi_long arg5)
1290 {
1291 print_syscall_prologue(name);
1292 print_string(arg0, 0);
1293 print_flags(umount2_flags, arg1, 1);
1294 print_syscall_epilogue(name);
1295 }
1296 #endif
1297
1298 #ifdef TARGET_NR_unlink
1299 static void
1300 print_unlink(const struct syscallname *name,
1301 abi_long arg0, abi_long arg1, abi_long arg2,
1302 abi_long arg3, abi_long arg4, abi_long arg5)
1303 {
1304 print_syscall_prologue(name);
1305 print_string(arg0, 1);
1306 print_syscall_epilogue(name);
1307 }
1308 #endif
1309
1310 #ifdef TARGET_NR_unlinkat
1311 static void
1312 print_unlinkat(const struct syscallname *name,
1313 abi_long arg0, abi_long arg1, abi_long arg2,
1314 abi_long arg3, abi_long arg4, abi_long arg5)
1315 {
1316 print_syscall_prologue(name);
1317 print_at_dirfd(arg0, 0);
1318 print_string(arg1, 0);
1319 print_flags(unlinkat_flags, arg2, 1);
1320 print_syscall_epilogue(name);
1321 }
1322 #endif
1323
1324 #ifdef TARGET_NR_utime
1325 static void
1326 print_utime(const struct syscallname *name,
1327 abi_long arg0, abi_long arg1, abi_long arg2,
1328 abi_long arg3, abi_long arg4, abi_long arg5)
1329 {
1330 print_syscall_prologue(name);
1331 print_string(arg0, 0);
1332 print_pointer(arg1, 1);
1333 print_syscall_epilogue(name);
1334 }
1335 #endif
1336
1337 #ifdef TARGET_NR_utimes
1338 static void
1339 print_utimes(const struct syscallname *name,
1340 abi_long arg0, abi_long arg1, abi_long arg2,
1341 abi_long arg3, abi_long arg4, abi_long arg5)
1342 {
1343 print_syscall_prologue(name);
1344 print_string(arg0, 0);
1345 print_pointer(arg1, 1);
1346 print_syscall_epilogue(name);
1347 }
1348 #endif
1349
1350 #ifdef TARGET_NR_utimensat
1351 static void
1352 print_utimensat(const struct syscallname *name,
1353 abi_long arg0, abi_long arg1, abi_long arg2,
1354 abi_long arg3, abi_long arg4, abi_long arg5)
1355 {
1356 print_syscall_prologue(name);
1357 print_at_dirfd(arg0, 0);
1358 print_string(arg1, 0);
1359 print_pointer(arg2, 0);
1360 print_flags(at_file_flags, arg3, 1);
1361 print_syscall_epilogue(name);
1362 }
1363 #endif
1364
1365 #if defined(TARGET_NR_mmap) || defined(TARGET_NR_mmap2)
1366 static void
1367 print_mmap(const struct syscallname *name,
1368 abi_long arg0, abi_long arg1, abi_long arg2,
1369 abi_long arg3, abi_long arg4, abi_long arg5)
1370 {
1371 print_syscall_prologue(name);
1372 print_pointer(arg0, 0);
1373 print_raw_param("%d", arg1, 0);
1374 print_flags(mmap_prot_flags, arg2, 0);
1375 print_flags(mmap_flags, arg3, 0);
1376 print_raw_param("%d", arg4, 0);
1377 print_raw_param("%#x", arg5, 1);
1378 print_syscall_epilogue(name);
1379 }
1380 #define print_mmap2 print_mmap
1381 #endif
1382
1383 #ifdef TARGET_NR_mprotect
1384 static void
1385 print_mprotect(const struct syscallname *name,
1386 abi_long arg0, abi_long arg1, abi_long arg2,
1387 abi_long arg3, abi_long arg4, abi_long arg5)
1388 {
1389 print_syscall_prologue(name);
1390 print_pointer(arg0, 0);
1391 print_raw_param("%d", arg1, 0);
1392 print_flags(mmap_prot_flags, arg2, 1);
1393 print_syscall_epilogue(name);
1394 }
1395 #endif
1396
1397 #ifdef TARGET_NR_munmap
1398 static void
1399 print_munmap(const struct syscallname *name,
1400 abi_long arg0, abi_long arg1, abi_long arg2,
1401 abi_long arg3, abi_long arg4, abi_long arg5)
1402 {
1403 print_syscall_prologue(name);
1404 print_pointer(arg0, 0);
1405 print_raw_param("%d", arg1, 1);
1406 print_syscall_epilogue(name);
1407 }
1408 #endif
1409
1410 #ifdef TARGET_NR_futex
1411 static void print_futex_op(abi_long tflag, int last)
1412 {
1413 #define print_op(val) \
1414 if( cmd == val ) { \
1415 gemu_log(#val); \
1416 return; \
1417 }
1418
1419 int cmd = (int)tflag;
1420 #ifdef FUTEX_PRIVATE_FLAG
1421 if (cmd & FUTEX_PRIVATE_FLAG) {
1422 gemu_log("FUTEX_PRIVATE_FLAG|");
1423 cmd &= ~FUTEX_PRIVATE_FLAG;
1424 }
1425 #endif
1426 print_op(FUTEX_WAIT)
1427 print_op(FUTEX_WAKE)
1428 print_op(FUTEX_FD)
1429 print_op(FUTEX_REQUEUE)
1430 print_op(FUTEX_CMP_REQUEUE)
1431 print_op(FUTEX_WAKE_OP)
1432 print_op(FUTEX_LOCK_PI)
1433 print_op(FUTEX_UNLOCK_PI)
1434 print_op(FUTEX_TRYLOCK_PI)
1435 #ifdef FUTEX_WAIT_BITSET
1436 print_op(FUTEX_WAIT_BITSET)
1437 #endif
1438 #ifdef FUTEX_WAKE_BITSET
1439 print_op(FUTEX_WAKE_BITSET)
1440 #endif
1441 /* unknown values */
1442 gemu_log("%d",cmd);
1443 }
1444
1445 static void
1446 print_futex(const struct syscallname *name,
1447 abi_long arg0, abi_long arg1, abi_long arg2,
1448 abi_long arg3, abi_long arg4, abi_long arg5)
1449 {
1450 print_syscall_prologue(name);
1451 print_pointer(arg0, 0);
1452 print_futex_op(arg1, 0);
1453 print_raw_param(",%d", arg2, 0);
1454 print_pointer(arg3, 0); /* struct timespec */
1455 print_pointer(arg4, 0);
1456 print_raw_param("%d", arg4, 1);
1457 print_syscall_epilogue(name);
1458 }
1459 #endif
1460
1461 #ifdef TARGET_NR_kill
1462 static void
1463 print_kill(const struct syscallname *name,
1464 abi_long arg0, abi_long arg1, abi_long arg2,
1465 abi_long arg3, abi_long arg4, abi_long arg5)
1466 {
1467 print_syscall_prologue(name);
1468 print_raw_param("%d", arg0, 0);
1469 print_signal(arg1, 1);
1470 print_syscall_epilogue(name);
1471 }
1472 #endif
1473
1474 /*
1475 * An array of all of the syscalls we know about
1476 */
1477
1478 static const struct syscallname scnames[] = {
1479 #include "strace.list"
1480 };
1481
1482 static int nsyscalls = ARRAY_SIZE(scnames);
1483
1484 /*
1485 * The public interface to this module.
1486 */
1487 void
1488 print_syscall(int num,
1489 abi_long arg1, abi_long arg2, abi_long arg3,
1490 abi_long arg4, abi_long arg5, abi_long arg6)
1491 {
1492 int i;
1493 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 ")";
1494
1495 gemu_log("%d ", getpid() );
1496
1497 for(i=0;i<nsyscalls;i++)
1498 if( scnames[i].nr == num ) {
1499 if( scnames[i].call != NULL ) {
1500 scnames[i].call(&scnames[i],arg1,arg2,arg3,arg4,arg5,arg6);
1501 } else {
1502 /* XXX: this format system is broken because it uses
1503 host types and host pointers for strings */
1504 if( scnames[i].format != NULL )
1505 format = scnames[i].format;
1506 gemu_log(format,scnames[i].name, arg1,arg2,arg3,arg4,arg5,arg6);
1507 }
1508 return;
1509 }
1510 gemu_log("Unknown syscall %d\n", num);
1511 }
1512
1513
1514 void
1515 print_syscall_ret(int num, abi_long ret)
1516 {
1517 int i;
1518
1519 for(i=0;i<nsyscalls;i++)
1520 if( scnames[i].nr == num ) {
1521 if( scnames[i].result != NULL ) {
1522 scnames[i].result(&scnames[i],ret);
1523 } else {
1524 if( ret < 0 ) {
1525 gemu_log(" = -1 errno=" TARGET_ABI_FMT_ld " (%s)\n", -ret, target_strerror(-ret));
1526 } else {
1527 gemu_log(" = " TARGET_ABI_FMT_ld "\n", ret);
1528 }
1529 }
1530 break;
1531 }
1532 }