File:  [Qemu by Fabrice Bellard] / qemu / linux-user / strace.c
Revision 1.1.1.4 (vendor branch): download - view: text, annotated - select for diffs
Tue Apr 24 18:26:13 2018 UTC (3 years, 3 months ago) by root
Branches: qemu, MAIN
CVS tags: qemu0150, qemu0141, qemu0140, qemu0130, HEAD
qemu 0.13.0

    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 "qemu.h"
   13: 
   14: int do_strace=0;
   15: 
   16: struct syscallname {
   17:     int nr;
   18:     const char *name;
   19:     const char *format;
   20:     void (*call)(const struct syscallname *,
   21:                  abi_long, abi_long, abi_long,
   22:                  abi_long, abi_long, abi_long);
   23:     void (*result)(const struct syscallname *, abi_long);
   24: };
   25: 
   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: 
   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
  161: print_newselect(const struct syscallname *name,
  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(",");
  172:     print_timeval(arg5, 1);
  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: 
  184: #ifdef TARGET_NR_semctl
  185: static void
  186: print_semctl(const struct syscallname *name,
  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: }
  194: #endif
  195: 
  196: static void
  197: print_execve(const struct syscallname *name,
  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)) {
  210:         abi_ulong *arg_ptr, arg_addr;
  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);
  221:             unlock_user(s, arg_addr, 0);
  222:         }
  223:     }
  224: 
  225:     gemu_log("NULL})");
  226: }
  227: 
  228: #ifdef TARGET_NR_ipc
  229: static void
  230: print_ipc(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:     switch(arg1) {
  235:     case IPCOP_semctl:
  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);
  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
  252: print_syscall_ret_addr(const struct syscallname *name, abi_long ret)
  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
  271: print_syscall_ret_newselect(const struct syscallname *name, abi_long ret)
  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(",");
  280:     print_timeval(newselect_arg5, 1);
  281:     gemu_log(")\n");
  282: }
  283: #endif
  284: 
  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),
  388:     FLAG_TARGET(PROT_SEM),
  389:     FLAG_GENERIC(PROT_GROWSDOWN),
  390:     FLAG_GENERIC(PROT_GROWSUP),
  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
 1258:     if (cmd & FUTEX_PRIVATE_FLAG) {
 1259:         gemu_log("FUTEX_PRIVATE_FLAG|");
 1260:         cmd &= ~FUTEX_PRIVATE_FLAG;
 1261:     }
 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: 
 1298: /*
 1299:  * An array of all of the syscalls we know about
 1300:  */
 1301: 
 1302: static const struct syscallname scnames[] = {
 1303: #include "strace.list"
 1304: };
 1305: 
 1306: static int nsyscalls = ARRAY_SIZE(scnames);
 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;
 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 ")";
 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:             }
 1332:             return;
 1333:         }
 1334:     gemu_log("Unknown syscall %d\n", num);
 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: }

unix.superglobalmegacorp.com