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