![[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 <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>
1.1.1.3 root 9: #include <sys/mount.h>
10: #include <sys/mman.h>
1.1 root 11: #include <unistd.h>
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);
66:
1.1 root 67: /*
68: * Utility functions
69: */
70: static void
71: print_ipc_cmd(int cmd)
72: {
73: #define output_cmd(val) \
74: if( cmd == val ) { \
75: gemu_log(#val); \
76: return; \
77: }
78:
79: cmd &= 0xff;
80:
81: /* General IPC commands */
82: output_cmd( IPC_RMID );
83: output_cmd( IPC_SET );
84: output_cmd( IPC_STAT );
85: output_cmd( IPC_INFO );
86: /* msgctl() commands */
87: #ifdef __USER_MISC
88: output_cmd( MSG_STAT );
89: output_cmd( MSG_INFO );
90: #endif
91: /* shmctl() commands */
92: output_cmd( SHM_LOCK );
93: output_cmd( SHM_UNLOCK );
94: output_cmd( SHM_STAT );
95: output_cmd( SHM_INFO );
96: /* semctl() commands */
97: output_cmd( GETPID );
98: output_cmd( GETVAL );
99: output_cmd( GETALL );
100: output_cmd( GETNCNT );
101: output_cmd( GETZCNT );
102: output_cmd( SETVAL );
103: output_cmd( SETALL );
104: output_cmd( SEM_STAT );
105: output_cmd( SEM_INFO );
106: output_cmd( IPC_RMID );
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:
116: /* Some value we don't recognize */
117: gemu_log("%d",cmd);
118: }
119:
120: #ifdef TARGET_NR__newselect
121: static void
122: print_fdset(int n, abi_ulong target_fds_addr)
123: {
124: int i;
125:
126: gemu_log("[");
127: if( target_fds_addr ) {
128: abi_long *target_fds;
129:
130: target_fds = lock_user(VERIFY_READ,
131: target_fds_addr,
132: sizeof(*target_fds)*(n / TARGET_ABI_BITS + 1),
133: 1);
134:
135: if (!target_fds)
136: return;
137:
138: for (i=n; i>=0; i--) {
139: if ((tswapl(target_fds[i / TARGET_ABI_BITS]) >> (i & (TARGET_ABI_BITS - 1))) & 1)
140: gemu_log("%d,", i );
141: }
142: unlock_user(target_fds, target_fds_addr, 0);
143: }
144: gemu_log("]");
145: }
146: #endif
147:
148: /*
149: * Sysycall specific output functions
150: */
151:
152: /* select */
153: #ifdef TARGET_NR__newselect
154: static long newselect_arg1 = 0;
155: static long newselect_arg2 = 0;
156: static long newselect_arg3 = 0;
157: static long newselect_arg4 = 0;
158: static long newselect_arg5 = 0;
159:
160: static void
1.1.1.2 root 161: print_newselect(const struct syscallname *name,
1.1 root 162: abi_long arg1, abi_long arg2, abi_long arg3,
163: abi_long arg4, abi_long arg5, abi_long arg6)
164: {
165: gemu_log("%s(" TARGET_ABI_FMT_ld ",", name->name, arg1);
166: print_fdset(arg1, arg2);
167: gemu_log(",");
168: print_fdset(arg1, arg3);
169: gemu_log(",");
170: print_fdset(arg1, arg4);
171: gemu_log(",");
1.1.1.3 root 172: print_timeval(arg5, 1);
1.1 root 173: gemu_log(")");
174:
175: /* save for use in the return output function below */
176: newselect_arg1=arg1;
177: newselect_arg2=arg2;
178: newselect_arg3=arg3;
179: newselect_arg4=arg4;
180: newselect_arg5=arg5;
181: }
182: #endif
183:
1.1.1.2 root 184: #ifdef TARGET_NR_semctl
1.1 root 185: static void
1.1.1.2 root 186: print_semctl(const struct syscallname *name,
1.1 root 187: abi_long arg1, abi_long arg2, abi_long arg3,
188: abi_long arg4, abi_long arg5, abi_long arg6)
189: {
190: gemu_log("%s(" TARGET_ABI_FMT_ld "," TARGET_ABI_FMT_ld ",", name->name, arg1, arg2);
191: print_ipc_cmd(arg3);
192: gemu_log(",0x" TARGET_ABI_FMT_lx ")", arg4);
193: }
1.1.1.2 root 194: #endif
1.1 root 195:
196: static void
1.1.1.2 root 197: print_execve(const struct syscallname *name,
1.1 root 198: abi_long arg1, abi_long arg2, abi_long arg3,
199: abi_long arg4, abi_long arg5, abi_long arg6)
200: {
201: abi_ulong arg_ptr_addr;
202: char *s;
203:
204: if (!(s = lock_user_string(arg1)))
205: return;
206: gemu_log("%s(\"%s\",{", name->name, s);
207: unlock_user(s, arg1, 0);
208:
209: for (arg_ptr_addr = arg2; ; arg_ptr_addr += sizeof(abi_ulong)) {
1.1.1.2 root 210: abi_ulong *arg_ptr, arg_addr;
1.1 root 211:
212: arg_ptr = lock_user(VERIFY_READ, arg_ptr_addr, sizeof(abi_ulong), 1);
213: if (!arg_ptr)
214: return;
215: arg_addr = tswapl(*arg_ptr);
216: unlock_user(arg_ptr, arg_ptr_addr, 0);
217: if (!arg_addr)
218: break;
219: if ((s = lock_user_string(arg_addr))) {
220: gemu_log("\"%s\",", s);
1.1.1.2 root 221: unlock_user(s, arg_addr, 0);
1.1 root 222: }
223: }
224:
225: gemu_log("NULL})");
226: }
227:
228: #ifdef TARGET_NR_ipc
229: static void
1.1.1.2 root 230: print_ipc(const struct syscallname *name,
1.1 root 231: abi_long arg1, abi_long arg2, abi_long arg3,
232: abi_long arg4, abi_long arg5, abi_long arg6)
233: {
234: switch(arg1) {
235: case IPCOP_semctl:
1.1.1.2 root 236: gemu_log("semctl(" TARGET_ABI_FMT_ld "," TARGET_ABI_FMT_ld ",", arg1, arg2);
237: print_ipc_cmd(arg3);
238: gemu_log(",0x" TARGET_ABI_FMT_lx ")", arg4);
1.1 root 239: break;
240: default:
241: gemu_log("%s(" TARGET_ABI_FMT_ld "," TARGET_ABI_FMT_ld "," TARGET_ABI_FMT_ld "," TARGET_ABI_FMT_ld ")",
242: name->name, arg1, arg2, arg3, arg4);
243: }
244: }
245: #endif
246:
247: /*
248: * Variants for the return value output function
249: */
250:
251: static void
1.1.1.2 root 252: print_syscall_ret_addr(const struct syscallname *name, abi_long ret)
1.1 root 253: {
254: if( ret == -1 ) {
255: gemu_log(" = -1 errno=%d (%s)\n", errno, target_strerror(errno));
256: } else {
257: gemu_log(" = 0x" TARGET_ABI_FMT_lx "\n", ret);
258: }
259: }
260:
261: #if 0 /* currently unused */
262: static void
263: print_syscall_ret_raw(struct syscallname *name, abi_long ret)
264: {
265: gemu_log(" = 0x" TARGET_ABI_FMT_lx "\n", ret);
266: }
267: #endif
268:
269: #ifdef TARGET_NR__newselect
270: static void
1.1.1.2 root 271: print_syscall_ret_newselect(const struct syscallname *name, abi_long ret)
1.1 root 272: {
273: gemu_log(" = 0x" TARGET_ABI_FMT_lx " (", ret);
274: print_fdset(newselect_arg1,newselect_arg2);
275: gemu_log(",");
276: print_fdset(newselect_arg1,newselect_arg3);
277: gemu_log(",");
278: print_fdset(newselect_arg1,newselect_arg4);
279: gemu_log(",");
1.1.1.3 root 280: print_timeval(newselect_arg5, 1);
1.1 root 281: gemu_log(")\n");
282: }
283: #endif
284:
1.1.1.3 root 285: UNUSED static struct flags access_flags[] = {
286: FLAG_GENERIC(F_OK),
287: FLAG_GENERIC(R_OK),
288: FLAG_GENERIC(W_OK),
289: FLAG_GENERIC(X_OK),
290: FLAG_END,
291: };
292:
293: UNUSED static struct flags at_file_flags[] = {
294: #ifdef AT_EACCESS
295: FLAG_GENERIC(AT_EACCESS),
296: #endif
297: #ifdef AT_SYMLINK_NOFOLLOW
298: FLAG_GENERIC(AT_SYMLINK_NOFOLLOW),
299: #endif
300: FLAG_END,
301: };
302:
303: UNUSED static struct flags unlinkat_flags[] = {
304: #ifdef AT_REMOVEDIR
305: FLAG_GENERIC(AT_REMOVEDIR),
306: #endif
307: FLAG_END,
308: };
309:
310: UNUSED static struct flags mode_flags[] = {
311: FLAG_GENERIC(S_IFSOCK),
312: FLAG_GENERIC(S_IFLNK),
313: FLAG_GENERIC(S_IFREG),
314: FLAG_GENERIC(S_IFBLK),
315: FLAG_GENERIC(S_IFDIR),
316: FLAG_GENERIC(S_IFCHR),
317: FLAG_GENERIC(S_IFIFO),
318: FLAG_END,
319: };
320:
321: UNUSED static struct flags open_access_flags[] = {
322: FLAG_TARGET(O_RDONLY),
323: FLAG_TARGET(O_WRONLY),
324: FLAG_TARGET(O_RDWR),
325: FLAG_END,
326: };
327:
328: UNUSED static struct flags open_flags[] = {
329: FLAG_TARGET(O_APPEND),
330: FLAG_TARGET(O_CREAT),
331: FLAG_TARGET(O_DIRECTORY),
332: FLAG_TARGET(O_EXCL),
333: FLAG_TARGET(O_LARGEFILE),
334: FLAG_TARGET(O_NOCTTY),
335: FLAG_TARGET(O_NOFOLLOW),
336: FLAG_TARGET(O_NONBLOCK), /* also O_NDELAY */
337: FLAG_TARGET(O_SYNC),
338: FLAG_TARGET(O_TRUNC),
339: #ifdef O_DIRECT
340: FLAG_TARGET(O_DIRECT),
341: #endif
342: FLAG_END,
343: };
344:
345: UNUSED static struct flags mount_flags[] = {
346: #ifdef MS_BIND
347: FLAG_GENERIC(MS_BIND),
348: #endif
349: #ifdef MS_DIRSYNC
350: FLAG_GENERIC(MS_DIRSYNC),
351: #endif
352: FLAG_GENERIC(MS_MANDLOCK),
353: #ifdef MS_MOVE
354: FLAG_GENERIC(MS_MOVE),
355: #endif
356: FLAG_GENERIC(MS_NOATIME),
357: FLAG_GENERIC(MS_NODEV),
358: FLAG_GENERIC(MS_NODIRATIME),
359: FLAG_GENERIC(MS_NOEXEC),
360: FLAG_GENERIC(MS_NOSUID),
361: FLAG_GENERIC(MS_RDONLY),
362: #ifdef MS_RELATIME
363: FLAG_GENERIC(MS_RELATIME),
364: #endif
365: FLAG_GENERIC(MS_REMOUNT),
366: FLAG_GENERIC(MS_SYNCHRONOUS),
367: FLAG_END,
368: };
369:
370: UNUSED static struct flags umount2_flags[] = {
371: #ifdef MNT_FORCE
372: FLAG_GENERIC(MNT_FORCE),
373: #endif
374: #ifdef MNT_DETACH
375: FLAG_GENERIC(MNT_DETACH),
376: #endif
377: #ifdef MNT_EXPIRE
378: FLAG_GENERIC(MNT_EXPIRE),
379: #endif
380: FLAG_END,
381: };
382:
383: UNUSED static struct flags mmap_prot_flags[] = {
384: FLAG_GENERIC(PROT_NONE),
385: FLAG_GENERIC(PROT_EXEC),
386: FLAG_GENERIC(PROT_READ),
387: FLAG_GENERIC(PROT_WRITE),
1.1.1.4 ! root 388: FLAG_TARGET(PROT_SEM),
! 389: FLAG_GENERIC(PROT_GROWSDOWN),
! 390: FLAG_GENERIC(PROT_GROWSUP),
1.1.1.3 root 391: FLAG_END,
392: };
393:
394: UNUSED static struct flags mmap_flags[] = {
395: FLAG_TARGET(MAP_SHARED),
396: FLAG_TARGET(MAP_PRIVATE),
397: FLAG_TARGET(MAP_ANONYMOUS),
398: FLAG_TARGET(MAP_DENYWRITE),
399: FLAG_TARGET(MAP_FIXED),
400: FLAG_TARGET(MAP_GROWSDOWN),
401: #ifdef MAP_LOCKED
402: FLAG_TARGET(MAP_LOCKED),
403: #endif
404: #ifdef MAP_NONBLOCK
405: FLAG_TARGET(MAP_NONBLOCK),
406: #endif
407: FLAG_TARGET(MAP_NORESERVE),
408: #ifdef MAP_POPULATE
409: FLAG_TARGET(MAP_POPULATE),
410: #endif
411: FLAG_END,
412: };
413:
414: UNUSED static struct flags fcntl_flags[] = {
415: FLAG_TARGET(F_DUPFD),
416: FLAG_TARGET(F_GETFD),
417: FLAG_TARGET(F_SETFD),
418: FLAG_TARGET(F_GETFL),
419: FLAG_TARGET(F_SETFL),
420: FLAG_TARGET(F_GETLK),
421: FLAG_TARGET(F_SETLK),
422: FLAG_TARGET(F_SETLKW),
423: FLAG_END,
424: };
425:
426: /*
427: * print_xxx utility functions. These are used to print syscall
428: * parameters in certain format. All of these have parameter
429: * named 'last'. This parameter is used to add comma to output
430: * when last == 0.
431: */
432:
433: static const char *
434: get_comma(int last)
435: {
436: return ((last) ? "" : ",");
437: }
438:
439: static void
440: print_flags(const struct flags *f, abi_long tflags, int last)
441: {
442: const char *sep = "";
443: int flags;
444: int n;
445:
446: flags = (int)tswap32(tflags);
447:
448: if ((flags == 0) && (f->f_value == 0)) {
449: gemu_log("%s%s", f->f_string, get_comma(last));
450: return;
451: }
452: for (n = 0; f->f_string != NULL; f++) {
453: if ((f->f_value != 0) && ((flags & f->f_value) == f->f_value)) {
454: gemu_log("%s%s", sep, f->f_string);
455: flags &= ~f->f_value;
456: sep = "|";
457: n++;
458: }
459: }
460:
461: if (n > 0) {
462: /* print rest of the flags as numeric */
463: if (flags != 0) {
464: gemu_log("%s%#x%s", sep, flags, get_comma(last));
465: } else {
466: gemu_log("%s", get_comma(last));
467: }
468: } else {
469: /* no string version of flags found, print them in hex then */
470: gemu_log("%#x%s", flags, get_comma(last));
471: }
472: }
473:
474: static void
475: print_at_dirfd(abi_long tdirfd, int last)
476: {
477: int dirfd = tswap32(tdirfd);
478:
479: #ifdef AT_FDCWD
480: if (dirfd == AT_FDCWD) {
481: gemu_log("AT_FDCWD%s", get_comma(last));
482: return;
483: }
484: #endif
485: gemu_log("%d%s", dirfd, get_comma(last));
486: }
487:
488: static void
489: print_file_mode(abi_long tmode, int last)
490: {
491: const char *sep = "";
492: const struct flags *m;
493: mode_t mode = (mode_t)tswap32(tmode);
494:
495: for (m = &mode_flags[0]; m->f_string != NULL; m++) {
496: if ((m->f_value & mode) == m->f_value) {
497: gemu_log("%s%s", m->f_string, sep);
498: sep = "|";
499: mode &= ~m->f_value;
500: break;
501: }
502: }
503:
504: mode &= ~S_IFMT;
505: /* print rest of the mode as octal */
506: if (mode != 0)
507: gemu_log("%s%#o", sep, mode);
508:
509: gemu_log("%s", get_comma(last));
510: }
511:
512: static void
513: print_open_flags(abi_long tflags, int last)
514: {
515: int flags = tswap32(tflags);
516:
517: print_flags(open_access_flags, flags & TARGET_O_ACCMODE, 1);
518: flags &= ~TARGET_O_ACCMODE;
519: if (flags == 0) {
520: gemu_log("%s", get_comma(last));
521: return;
522: }
523: gemu_log("|");
524: print_flags(open_flags, flags, last);
525: }
526:
527: static void
528: print_syscall_prologue(const struct syscallname *sc)
529: {
530: gemu_log("%s(", sc->name);
531: }
532:
533: /*ARGSUSED*/
534: static void
535: print_syscall_epilogue(const struct syscallname *sc)
536: {
537: (void)sc;
538: gemu_log(")");
539: }
540:
541: static void
542: print_string(abi_long addr, int last)
543: {
544: char *s;
545:
546: if ((s = lock_user_string(addr)) != NULL) {
547: gemu_log("\"%s\"%s", s, get_comma(last));
548: unlock_user(s, addr, 0);
549: } else {
550: /* can't get string out of it, so print it as pointer */
551: print_pointer(addr, last);
552: }
553: }
554:
555: /*
556: * Prints out raw parameter using given format. Caller needs
557: * to do byte swapping if needed.
558: */
559: static void
560: print_raw_param(const char *fmt, abi_long param, int last)
561: {
562: char format[64];
563:
564: (void) snprintf(format, sizeof (format), "%s%s", fmt, get_comma(last));
565: gemu_log(format, param);
566: }
567:
568: static void
569: print_pointer(abi_long p, int last)
570: {
571: if (p == 0)
572: gemu_log("NULL%s", get_comma(last));
573: else
574: gemu_log("0x" TARGET_ABI_FMT_lx "%s", p, get_comma(last));
575: }
576:
577: /*
578: * Reads 32-bit (int) number from guest address space from
579: * address 'addr' and prints it.
580: */
581: static void
582: print_number(abi_long addr, int last)
583: {
584: if (addr == 0) {
585: gemu_log("NULL%s", get_comma(last));
586: } else {
587: int num;
588:
589: get_user_s32(num, addr);
590: gemu_log("[%d]%s", num, get_comma(last));
591: }
592: }
593:
594: static void
595: print_timeval(abi_ulong tv_addr, int last)
596: {
597: if( tv_addr ) {
598: struct target_timeval *tv;
599:
600: tv = lock_user(VERIFY_READ, tv_addr, sizeof(*tv), 1);
601: if (!tv)
602: return;
603: gemu_log("{" TARGET_ABI_FMT_ld "," TARGET_ABI_FMT_ld "}%s",
604: tv->tv_sec, tv->tv_usec, get_comma(last));
605: unlock_user(tv, tv_addr, 0);
606: } else
607: gemu_log("NULL%s", get_comma(last));
608: }
609:
610: #undef UNUSED
611:
612: #ifdef TARGET_NR_accept
613: static void
614: print_accept(const struct syscallname *name,
615: abi_long arg0, abi_long arg1, abi_long arg2,
616: abi_long arg3, abi_long arg4, abi_long arg5)
617: {
618: print_syscall_prologue(name);
619: print_raw_param("%d", tswap32(arg0), 0);
620: print_pointer(arg1, 0);
621: print_number(arg2, 1);
622: print_syscall_epilogue(name);
623: }
624: #endif
625:
626: #ifdef TARGET_NR_access
627: static void
628: print_access(const struct syscallname *name,
629: abi_long arg0, abi_long arg1, abi_long arg2,
630: abi_long arg3, abi_long arg4, abi_long arg5)
631: {
632: print_syscall_prologue(name);
633: print_string(arg0, 0);
634: print_flags(access_flags, arg1, 1);
635: print_syscall_epilogue(name);
636: }
637: #endif
638:
639: #ifdef TARGET_NR_brk
640: static void
641: print_brk(const struct syscallname *name,
642: abi_long arg0, abi_long arg1, abi_long arg2,
643: abi_long arg3, abi_long arg4, abi_long arg5)
644: {
645: print_syscall_prologue(name);
646: print_pointer(arg0, 1);
647: print_syscall_epilogue(name);
648: }
649: #endif
650:
651: #ifdef TARGET_NR_chdir
652: static void
653: print_chdir(const struct syscallname *name,
654: abi_long arg0, abi_long arg1, abi_long arg2,
655: abi_long arg3, abi_long arg4, abi_long arg5)
656: {
657: print_syscall_prologue(name);
658: print_string(arg0, 1);
659: print_syscall_epilogue(name);
660: }
661: #endif
662:
663: #ifdef TARGET_NR_chmod
664: static void
665: print_chmod(const struct syscallname *name,
666: abi_long arg0, abi_long arg1, abi_long arg2,
667: abi_long arg3, abi_long arg4, abi_long arg5)
668: {
669: print_syscall_prologue(name);
670: print_string(arg0, 0);
671: print_file_mode(arg1, 1);
672: print_syscall_epilogue(name);
673: }
674: #endif
675:
676: #ifdef TARGET_NR_creat
677: static void
678: print_creat(const struct syscallname *name,
679: abi_long arg0, abi_long arg1, abi_long arg2,
680: abi_long arg3, abi_long arg4, abi_long arg5)
681: {
682: print_syscall_prologue(name);
683: print_string(arg0, 0);
684: print_file_mode(arg1, 1);
685: print_syscall_epilogue(name);
686: }
687: #endif
688:
689: #ifdef TARGET_NR_execv
690: static void
691: print_execv(const struct syscallname *name,
692: abi_long arg0, abi_long arg1, abi_long arg2,
693: abi_long arg3, abi_long arg4, abi_long arg5)
694: {
695: print_syscall_prologue(name);
696: print_string(arg0, 0);
697: print_raw_param("0x" TARGET_ABI_FMT_lx, tswapl(arg1), 1);
698: print_syscall_epilogue(name);
699: }
700: #endif
701:
702: #ifdef TARGET_NR_faccessat
703: static void
704: print_faccessat(const struct syscallname *name,
705: abi_long arg0, abi_long arg1, abi_long arg2,
706: abi_long arg3, abi_long arg4, abi_long arg5)
707: {
708: print_syscall_prologue(name);
709: print_at_dirfd(arg0, 0);
710: print_string(arg1, 0);
711: print_flags(access_flags, arg2, 0);
712: print_flags(at_file_flags, arg3, 1);
713: print_syscall_epilogue(name);
714: }
715: #endif
716:
717: #ifdef TARGET_NR_fchmodat
718: static void
719: print_fchmodat(const struct syscallname *name,
720: abi_long arg0, abi_long arg1, abi_long arg2,
721: abi_long arg3, abi_long arg4, abi_long arg5)
722: {
723: print_syscall_prologue(name);
724: print_at_dirfd(arg0, 0);
725: print_string(arg1, 0);
726: print_file_mode(arg2, 0);
727: print_flags(at_file_flags, arg3, 1);
728: print_syscall_epilogue(name);
729: }
730: #endif
731:
732: #ifdef TARGET_NR_fchownat
733: static void
734: print_fchownat(const struct syscallname *name,
735: abi_long arg0, abi_long arg1, abi_long arg2,
736: abi_long arg3, abi_long arg4, abi_long arg5)
737: {
738: print_syscall_prologue(name);
739: print_at_dirfd(arg0, 0);
740: print_string(arg1, 0);
741: #ifdef USE_UID16
742: print_raw_param("%d", tswap16(arg2), 0);
743: print_raw_param("%d", tswap16(arg3), 0);
744: #else
745: print_raw_param("%d", tswap32(arg2), 0);
746: print_raw_param("%d", tswap32(arg3), 0);
747: #endif
748: print_flags(at_file_flags, arg4, 1);
749: print_syscall_epilogue(name);
750: }
751: #endif
752:
753: #if defined(TARGET_NR_fcntl) || defined(TARGET_NR_fcntl64)
754: static void
755: print_fcntl(const struct syscallname *name,
756: abi_long arg0, abi_long arg1, abi_long arg2,
757: abi_long arg3, abi_long arg4, abi_long arg5)
758: {
759: print_syscall_prologue(name);
760: print_raw_param("%d", tswap32(arg0), 0);
761: print_flags(fcntl_flags, arg1, 0);
762: /*
763: * TODO: check flags and print following argument only
764: * when needed.
765: */
766: print_pointer(arg2, 1);
767: print_syscall_epilogue(name);
768: }
769: #define print_fcntl64 print_fcntl
770: #endif
771:
772:
773: #ifdef TARGET_NR_futimesat
774: static void
775: print_futimesat(const struct syscallname *name,
776: abi_long arg0, abi_long arg1, abi_long arg2,
777: abi_long arg3, abi_long arg4, abi_long arg5)
778: {
779: print_syscall_prologue(name);
780: print_at_dirfd(arg0, 0);
781: print_string(arg1, 0);
782: print_timeval(arg2, 0);
783: print_timeval(arg2 + sizeof (struct target_timeval), 1);
784: print_syscall_epilogue(name);
785: }
786: #endif
787:
788: #ifdef TARGET_NR_link
789: static void
790: print_link(const struct syscallname *name,
791: abi_long arg0, abi_long arg1, abi_long arg2,
792: abi_long arg3, abi_long arg4, abi_long arg5)
793: {
794: print_syscall_prologue(name);
795: print_string(arg0, 0);
796: print_string(arg1, 1);
797: print_syscall_epilogue(name);
798: }
799: #endif
800:
801: #ifdef TARGET_NR_linkat
802: static void
803: print_linkat(const struct syscallname *name,
804: abi_long arg0, abi_long arg1, abi_long arg2,
805: abi_long arg3, abi_long arg4, abi_long arg5)
806: {
807: print_syscall_prologue(name);
808: print_at_dirfd(arg0, 0);
809: print_string(arg1, 0);
810: print_at_dirfd(arg2, 0);
811: print_string(arg3, 0);
812: print_flags(at_file_flags, arg4, 1);
813: print_syscall_epilogue(name);
814: }
815: #endif
816:
817: #if defined(TARGET_NR_stat) || defined(TARGET_NR_stat64) || \
818: defined(TARGET_NR_lstat) || defined(TARGET_NR_lstat64)
819: static void
820: print_stat(const struct syscallname *name,
821: abi_long arg0, abi_long arg1, abi_long arg2,
822: abi_long arg3, abi_long arg4, abi_long arg5)
823: {
824: print_syscall_prologue(name);
825: print_string(arg0, 0);
826: print_pointer(arg1, 1);
827: print_syscall_epilogue(name);
828: }
829: #define print_lstat print_stat
830: #define print_stat64 print_stat
831: #define print_lstat64 print_stat
832: #endif
833:
834: #if defined(TARGET_NR_fstat) || defined(TARGET_NR_fstat64)
835: static void
836: print_fstat(const struct syscallname *name,
837: abi_long arg0, abi_long arg1, abi_long arg2,
838: abi_long arg3, abi_long arg4, abi_long arg5)
839: {
840: print_syscall_prologue(name);
841: print_raw_param("%d", tswap32(arg0), 0);
842: print_pointer(arg1, 1);
843: print_syscall_epilogue(name);
844: }
845: #define print_fstat64 print_fstat
846: #endif
847:
848: #ifdef TARGET_NR_mkdir
849: static void
850: print_mkdir(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_string(arg0, 0);
856: print_file_mode(arg1, 1);
857: print_syscall_epilogue(name);
858: }
859: #endif
860:
861: #ifdef TARGET_NR_mkdirat
862: static void
863: print_mkdirat(const struct syscallname *name,
864: abi_long arg0, abi_long arg1, abi_long arg2,
865: abi_long arg3, abi_long arg4, abi_long arg5)
866: {
867: print_syscall_prologue(name);
868: print_at_dirfd(arg0, 0);
869: print_string(arg1, 0);
870: print_file_mode(arg2, 1);
871: print_syscall_epilogue(name);
872: }
873: #endif
874:
875: #ifdef TARGET_NR_mknod
876: static void
877: print_mknod(const struct syscallname *name,
878: abi_long arg0, abi_long arg1, abi_long arg2,
879: abi_long arg3, abi_long arg4, abi_long arg5)
880: {
881: int hasdev = (tswapl(arg1) & (S_IFCHR|S_IFBLK));
882:
883: print_syscall_prologue(name);
884: print_string(arg0, 0);
885: print_file_mode(arg1, (hasdev == 0));
886: if (hasdev) {
887: print_raw_param("makedev(%d", major(tswapl(arg2)), 0);
888: print_raw_param("%d)", minor(tswapl(arg2)), 1);
889: }
890: print_syscall_epilogue(name);
891: }
892: #endif
893:
894: #ifdef TARGET_NR_mknodat
895: static void
896: print_mknodat(const struct syscallname *name,
897: abi_long arg0, abi_long arg1, abi_long arg2,
898: abi_long arg3, abi_long arg4, abi_long arg5)
899: {
900: int hasdev = (tswapl(arg2) & (S_IFCHR|S_IFBLK));
901:
902: print_syscall_prologue(name);
903: print_at_dirfd(arg0, 0);
904: print_string(arg1, 0);
905: print_file_mode(arg2, (hasdev == 0));
906: if (hasdev) {
907: print_raw_param("makedev(%d", major(tswapl(arg3)), 0);
908: print_raw_param("%d)", minor(tswapl(arg3)), 1);
909: }
910: print_syscall_epilogue(name);
911: }
912: #endif
913:
914: #ifdef TARGET_NR_mq_open
915: static void
916: print_mq_open(const struct syscallname *name,
917: abi_long arg0, abi_long arg1, abi_long arg2,
918: abi_long arg3, abi_long arg4, abi_long arg5)
919: {
920: int is_creat = (tswapl(arg1) & TARGET_O_CREAT);
921:
922: print_syscall_prologue(name);
923: print_string(arg0, 0);
924: print_open_flags(arg1, (is_creat == 0));
925: if (is_creat) {
926: print_file_mode(arg2, 0);
927: print_pointer(arg3, 1);
928: }
929: print_syscall_epilogue(name);
930: }
931: #endif
932:
933: #ifdef TARGET_NR_open
934: static void
935: print_open(const struct syscallname *name,
936: abi_long arg0, abi_long arg1, abi_long arg2,
937: abi_long arg3, abi_long arg4, abi_long arg5)
938: {
939: int is_creat = (tswap32(arg1) & TARGET_O_CREAT);
940:
941: print_syscall_prologue(name);
942: print_string(arg0, 0);
943: print_open_flags(arg1, (is_creat == 0));
944: if (is_creat)
945: print_file_mode(arg2, 1);
946: print_syscall_epilogue(name);
947: }
948: #endif
949:
950: #ifdef TARGET_NR_openat
951: static void
952: print_openat(const struct syscallname *name,
953: abi_long arg0, abi_long arg1, abi_long arg2,
954: abi_long arg3, abi_long arg4, abi_long arg5)
955: {
956: int is_creat = (tswap32(arg2) & TARGET_O_CREAT);
957:
958: print_syscall_prologue(name);
959: print_at_dirfd(arg0, 0);
960: print_string(arg1, 0);
961: print_open_flags(arg2, (is_creat == 0));
962: if (is_creat)
963: print_file_mode(arg3, 1);
964: print_syscall_epilogue(name);
965: }
966: #endif
967:
968: #ifdef TARGET_NR_mq_unlink
969: static void
970: print_mq_unlink(const struct syscallname *name,
971: abi_long arg0, abi_long arg1, abi_long arg2,
972: abi_long arg3, abi_long arg4, abi_long arg5)
973: {
974: print_syscall_prologue(name);
975: print_string(arg0, 1);
976: print_syscall_epilogue(name);
977: }
978: #endif
979:
980: #if defined(TARGET_NR_fstatat64) || defined(TARGET_NR_newfstatat)
981: static void
982: print_fstatat64(const struct syscallname *name,
983: abi_long arg0, abi_long arg1, abi_long arg2,
984: abi_long arg3, abi_long arg4, abi_long arg5)
985: {
986: print_syscall_prologue(name);
987: print_at_dirfd(arg0, 0);
988: print_string(arg1, 0);
989: print_pointer(arg2, 0);
990: print_flags(at_file_flags, arg3, 1);
991: print_syscall_epilogue(name);
992: }
993: #define print_newfstatat print_fstatat64
994: #endif
995:
996: #ifdef TARGET_NR_readlink
997: static void
998: print_readlink(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_pointer(arg1, 0);
1005: print_raw_param("%u", tswapl(arg2), 1);
1006: print_syscall_epilogue(name);
1007: }
1008: #endif
1009:
1010: #ifdef TARGET_NR_readlinkat
1011: static void
1012: print_readlinkat(const struct syscallname *name,
1013: abi_long arg0, abi_long arg1, abi_long arg2,
1014: abi_long arg3, abi_long arg4, abi_long arg5)
1015: {
1016: print_syscall_prologue(name);
1017: print_at_dirfd(arg0, 0);
1018: print_string(arg1, 0);
1019: print_pointer(arg2, 0);
1020: print_raw_param("%u", tswapl(arg3), 1);
1021: print_syscall_epilogue(name);
1022: }
1023: #endif
1024:
1025: #ifdef TARGET_NR_rename
1026: static void
1027: print_rename(const struct syscallname *name,
1028: abi_long arg0, abi_long arg1, abi_long arg2,
1029: abi_long arg3, abi_long arg4, abi_long arg5)
1030: {
1031: print_syscall_prologue(name);
1032: print_string(arg0, 0);
1033: print_string(arg1, 1);
1034: print_syscall_epilogue(name);
1035: }
1036: #endif
1037:
1038: #ifdef TARGET_NR_renameat
1039: static void
1040: print_renameat(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: print_syscall_prologue(name);
1045: print_at_dirfd(arg0, 0);
1046: print_string(arg1, 0);
1047: print_at_dirfd(arg2, 0);
1048: print_string(arg3, 1);
1049: print_syscall_epilogue(name);
1050: }
1051: #endif
1052:
1053: #ifdef TARGET_NR_statfs
1054: static void
1055: print_statfs(const struct syscallname *name,
1056: abi_long arg0, abi_long arg1, abi_long arg2,
1057: abi_long arg3, abi_long arg4, abi_long arg5)
1058: {
1059: print_syscall_prologue(name);
1060: print_string(arg0, 0);
1061: print_pointer(arg1, 1);
1062: print_syscall_epilogue(name);
1063: }
1064: #define print_statfs64 print_statfs
1065: #endif
1066:
1067: #ifdef TARGET_NR_symlink
1068: static void
1069: print_symlink(const struct syscallname *name,
1070: abi_long arg0, abi_long arg1, abi_long arg2,
1071: abi_long arg3, abi_long arg4, abi_long arg5)
1072: {
1073: print_syscall_prologue(name);
1074: print_string(arg0, 0);
1075: print_string(arg1, 1);
1076: print_syscall_epilogue(name);
1077: }
1078: #endif
1079:
1080: #ifdef TARGET_NR_symlinkat
1081: static void
1082: print_symlinkat(const struct syscallname *name,
1083: abi_long arg0, abi_long arg1, abi_long arg2,
1084: abi_long arg3, abi_long arg4, abi_long arg5)
1085: {
1086: print_syscall_prologue(name);
1087: print_string(arg0, 0);
1088: print_at_dirfd(arg1, 0);
1089: print_string(arg2, 1);
1090: print_syscall_epilogue(name);
1091: }
1092: #endif
1093:
1094: #ifdef TARGET_NR_mount
1095: static void
1096: print_mount(const struct syscallname *name,
1097: abi_long arg0, abi_long arg1, abi_long arg2,
1098: abi_long arg3, abi_long arg4, abi_long arg5)
1099: {
1100: print_syscall_prologue(name);
1101: print_string(arg0, 0);
1102: print_string(arg1, 0);
1103: print_string(arg2, 0);
1104: print_flags(mount_flags, arg3, 0);
1105: print_pointer(arg4, 1);
1106: print_syscall_epilogue(name);
1107: }
1108: #endif
1109:
1110: #ifdef TARGET_NR_umount
1111: static void
1112: print_umount(const struct syscallname *name,
1113: abi_long arg0, abi_long arg1, abi_long arg2,
1114: abi_long arg3, abi_long arg4, abi_long arg5)
1115: {
1116: print_syscall_prologue(name);
1117: print_string(arg0, 1);
1118: print_syscall_epilogue(name);
1119: }
1120: #endif
1121:
1122: #ifdef TARGET_NR_umount2
1123: static void
1124: print_umount2(const struct syscallname *name,
1125: abi_long arg0, abi_long arg1, abi_long arg2,
1126: abi_long arg3, abi_long arg4, abi_long arg5)
1127: {
1128: print_syscall_prologue(name);
1129: print_string(arg0, 0);
1130: print_flags(umount2_flags, arg1, 1);
1131: print_syscall_epilogue(name);
1132: }
1133: #endif
1134:
1135: #ifdef TARGET_NR_unlink
1136: static void
1137: print_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: #ifdef TARGET_NR_unlinkat
1148: static void
1149: print_unlinkat(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_flags(unlinkat_flags, arg2, 1);
1157: print_syscall_epilogue(name);
1158: }
1159: #endif
1160:
1161: #ifdef TARGET_NR_utime
1162: static void
1163: print_utime(const struct syscallname *name,
1164: abi_long arg0, abi_long arg1, abi_long arg2,
1165: abi_long arg3, abi_long arg4, abi_long arg5)
1166: {
1167: print_syscall_prologue(name);
1168: print_string(arg0, 0);
1169: print_pointer(arg1, 1);
1170: print_syscall_epilogue(name);
1171: }
1172: #endif
1173:
1174: #ifdef TARGET_NR_utimes
1175: static void
1176: print_utimes(const struct syscallname *name,
1177: abi_long arg0, abi_long arg1, abi_long arg2,
1178: abi_long arg3, abi_long arg4, abi_long arg5)
1179: {
1180: print_syscall_prologue(name);
1181: print_string(arg0, 0);
1182: print_pointer(arg1, 1);
1183: print_syscall_epilogue(name);
1184: }
1185: #endif
1186:
1187: #ifdef TARGET_NR_utimensat
1188: static void
1189: print_utimensat(const struct syscallname *name,
1190: abi_long arg0, abi_long arg1, abi_long arg2,
1191: abi_long arg3, abi_long arg4, abi_long arg5)
1192: {
1193: print_syscall_prologue(name);
1194: print_at_dirfd(arg0, 0);
1195: print_string(arg1, 0);
1196: print_pointer(arg2, 0);
1197: print_flags(at_file_flags, arg3, 1);
1198: print_syscall_epilogue(name);
1199: }
1200: #endif
1201:
1202: #ifdef TARGET_NR_mmap
1203: static void
1204: print_mmap(const struct syscallname *name,
1205: abi_long arg0, abi_long arg1, abi_long arg2,
1206: abi_long arg3, abi_long arg4, abi_long arg5)
1207: {
1208: print_syscall_prologue(name);
1209: print_pointer(arg0, 0);
1210: print_raw_param("%d", tswapl(arg1), 0);
1211: print_flags(mmap_prot_flags, arg2, 0);
1212: print_flags(mmap_flags, arg3, 0);
1213: print_raw_param("%d", tswapl(arg4), 0);
1214: print_raw_param("%#x", tswapl(arg5), 1);
1215: print_syscall_epilogue(name);
1216: }
1217: #define print_mmap2 print_mmap
1218: #endif
1219:
1220: #ifdef TARGET_NR_mprotect
1221: static void
1222: print_mprotect(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_pointer(arg0, 0);
1228: print_raw_param("%d", tswapl(arg1), 0);
1229: print_flags(mmap_prot_flags, arg2, 1);
1230: print_syscall_epilogue(name);
1231: }
1232: #endif
1233:
1234: #ifdef TARGET_NR_munmap
1235: static void
1236: print_munmap(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_pointer(arg0, 0);
1242: print_raw_param("%d", tswapl(arg1), 1);
1243: print_syscall_epilogue(name);
1244: }
1245: #endif
1246:
1247: #ifdef TARGET_NR_futex
1248: static void print_futex_op(abi_long tflag, int last)
1249: {
1250: #define print_op(val) \
1251: if( cmd == val ) { \
1252: gemu_log(#val); \
1253: return; \
1254: }
1255:
1256: int cmd = (int)tswap32(tflag);
1257: #ifdef FUTEX_PRIVATE_FLAG
1.1.1.4 ! root 1258: if (cmd & FUTEX_PRIVATE_FLAG) {
1.1.1.3 root 1259: gemu_log("FUTEX_PRIVATE_FLAG|");
1.1.1.4 ! root 1260: cmd &= ~FUTEX_PRIVATE_FLAG;
! 1261: }
1.1.1.3 root 1262: #endif
1263: print_op(FUTEX_WAIT)
1264: print_op(FUTEX_WAKE)
1265: print_op(FUTEX_FD)
1266: print_op(FUTEX_REQUEUE)
1267: print_op(FUTEX_CMP_REQUEUE)
1268: print_op(FUTEX_WAKE_OP)
1269: print_op(FUTEX_LOCK_PI)
1270: print_op(FUTEX_UNLOCK_PI)
1271: print_op(FUTEX_TRYLOCK_PI)
1272: #ifdef FUTEX_WAIT_BITSET
1273: print_op(FUTEX_WAIT_BITSET)
1274: #endif
1275: #ifdef FUTEX_WAKE_BITSET
1276: print_op(FUTEX_WAKE_BITSET)
1277: #endif
1278: /* unknown values */
1279: gemu_log("%d",cmd);
1280: }
1281:
1282: static void
1283: print_futex(const struct syscallname *name,
1284: abi_long arg0, abi_long arg1, abi_long arg2,
1285: abi_long arg3, abi_long arg4, abi_long arg5)
1286: {
1287: print_syscall_prologue(name);
1288: print_pointer(arg0, 0);
1289: print_futex_op(arg1, 0);
1290: print_raw_param(",%d", tswapl(arg2), 0);
1291: print_pointer(arg3, 0); /* struct timespec */
1292: print_pointer(arg4, 0);
1293: print_raw_param("%d", tswapl(arg4), 1);
1294: print_syscall_epilogue(name);
1295: }
1296: #endif
1297:
1.1 root 1298: /*
1299: * An array of all of the syscalls we know about
1300: */
1301:
1.1.1.2 root 1302: static const struct syscallname scnames[] = {
1.1 root 1303: #include "strace.list"
1304: };
1305:
1.1.1.2 root 1306: static int nsyscalls = ARRAY_SIZE(scnames);
1.1 root 1307:
1308: /*
1309: * The public interface to this module.
1310: */
1311: void
1312: print_syscall(int num,
1313: abi_long arg1, abi_long arg2, abi_long arg3,
1314: abi_long arg4, abi_long arg5, abi_long arg6)
1315: {
1316: int i;
1.1.1.2 root 1317: 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 1318:
1319: gemu_log("%d ", getpid() );
1320:
1321: for(i=0;i<nsyscalls;i++)
1322: if( scnames[i].nr == num ) {
1323: if( scnames[i].call != NULL ) {
1324: scnames[i].call(&scnames[i],arg1,arg2,arg3,arg4,arg5,arg6);
1325: } else {
1326: /* XXX: this format system is broken because it uses
1327: host types and host pointers for strings */
1328: if( scnames[i].format != NULL )
1329: format = scnames[i].format;
1330: gemu_log(format,scnames[i].name, arg1,arg2,arg3,arg4,arg5,arg6);
1331: }
1.1.1.2 root 1332: return;
1.1 root 1333: }
1.1.1.2 root 1334: gemu_log("Unknown syscall %d\n", num);
1.1 root 1335: }
1336:
1337:
1338: void
1339: print_syscall_ret(int num, abi_long ret)
1340: {
1341: int i;
1342:
1343: for(i=0;i<nsyscalls;i++)
1344: if( scnames[i].nr == num ) {
1345: if( scnames[i].result != NULL ) {
1346: scnames[i].result(&scnames[i],ret);
1347: } else {
1348: if( ret < 0 ) {
1349: gemu_log(" = -1 errno=" TARGET_ABI_FMT_ld " (%s)\n", -ret, target_strerror(-ret));
1350: } else {
1351: gemu_log(" = " TARGET_ABI_FMT_ld "\n", ret);
1352: }
1353: }
1354: break;
1355: }
1356: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.