Annotation of qemu/linux-user/strace.c, revision 1.1.1.3

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),
        !           388:     FLAG_END,
        !           389: };
        !           390: 
        !           391: UNUSED static struct flags mmap_flags[] = {
        !           392:     FLAG_TARGET(MAP_SHARED),
        !           393:     FLAG_TARGET(MAP_PRIVATE),
        !           394:     FLAG_TARGET(MAP_ANONYMOUS),
        !           395:     FLAG_TARGET(MAP_DENYWRITE),
        !           396:     FLAG_TARGET(MAP_FIXED),
        !           397:     FLAG_TARGET(MAP_GROWSDOWN),
        !           398: #ifdef MAP_LOCKED
        !           399:     FLAG_TARGET(MAP_LOCKED),
        !           400: #endif
        !           401: #ifdef MAP_NONBLOCK
        !           402:     FLAG_TARGET(MAP_NONBLOCK),
        !           403: #endif
        !           404:     FLAG_TARGET(MAP_NORESERVE),
        !           405: #ifdef MAP_POPULATE
        !           406:     FLAG_TARGET(MAP_POPULATE),
        !           407: #endif
        !           408:     FLAG_END,
        !           409: };
        !           410: 
        !           411: UNUSED static struct flags fcntl_flags[] = {
        !           412:     FLAG_TARGET(F_DUPFD),
        !           413:     FLAG_TARGET(F_GETFD),
        !           414:     FLAG_TARGET(F_SETFD),
        !           415:     FLAG_TARGET(F_GETFL),
        !           416:     FLAG_TARGET(F_SETFL),
        !           417:     FLAG_TARGET(F_GETLK),
        !           418:     FLAG_TARGET(F_SETLK),
        !           419:     FLAG_TARGET(F_SETLKW),
        !           420:     FLAG_END,
        !           421: };
        !           422: 
        !           423: /*
        !           424:  * print_xxx utility functions.  These are used to print syscall
        !           425:  * parameters in certain format.  All of these have parameter
        !           426:  * named 'last'.  This parameter is used to add comma to output
        !           427:  * when last == 0.
        !           428:  */
        !           429: 
        !           430: static const char *
        !           431: get_comma(int last)
        !           432: {
        !           433:     return ((last) ? "" : ",");
        !           434: }
        !           435: 
        !           436: static void
        !           437: print_flags(const struct flags *f, abi_long tflags, int last)
        !           438: {
        !           439:     const char *sep = "";
        !           440:     int flags;
        !           441:     int n;
        !           442: 
        !           443:     flags = (int)tswap32(tflags);
        !           444: 
        !           445:     if ((flags == 0) && (f->f_value == 0)) {
        !           446:         gemu_log("%s%s", f->f_string, get_comma(last));
        !           447:         return;
        !           448:     }
        !           449:     for (n = 0; f->f_string != NULL; f++) {
        !           450:         if ((f->f_value != 0) && ((flags & f->f_value) == f->f_value)) {
        !           451:             gemu_log("%s%s", sep, f->f_string);
        !           452:             flags &= ~f->f_value;
        !           453:             sep = "|";
        !           454:             n++;
        !           455:         }
        !           456:     }
        !           457: 
        !           458:     if (n > 0) {
        !           459:         /* print rest of the flags as numeric */
        !           460:         if (flags != 0) {
        !           461:             gemu_log("%s%#x%s", sep, flags, get_comma(last));
        !           462:         } else {
        !           463:             gemu_log("%s", get_comma(last));
        !           464:         }
        !           465:     } else {
        !           466:         /* no string version of flags found, print them in hex then */
        !           467:         gemu_log("%#x%s", flags, get_comma(last));
        !           468:     }
        !           469: }
        !           470: 
        !           471: static void
        !           472: print_at_dirfd(abi_long tdirfd, int last)
        !           473: {
        !           474:     int dirfd = tswap32(tdirfd);
        !           475: 
        !           476: #ifdef AT_FDCWD
        !           477:     if (dirfd == AT_FDCWD) {
        !           478:         gemu_log("AT_FDCWD%s", get_comma(last));
        !           479:         return;
        !           480:     }
        !           481: #endif
        !           482:     gemu_log("%d%s", dirfd, get_comma(last));
        !           483: }
        !           484: 
        !           485: static void
        !           486: print_file_mode(abi_long tmode, int last)
        !           487: {
        !           488:     const char *sep = "";
        !           489:     const struct flags *m;
        !           490:     mode_t mode = (mode_t)tswap32(tmode);
        !           491: 
        !           492:     for (m = &mode_flags[0]; m->f_string != NULL; m++) {
        !           493:         if ((m->f_value & mode) == m->f_value) {
        !           494:             gemu_log("%s%s", m->f_string, sep);
        !           495:             sep = "|";
        !           496:             mode &= ~m->f_value;
        !           497:             break;
        !           498:         }
        !           499:     }
        !           500: 
        !           501:     mode &= ~S_IFMT;
        !           502:     /* print rest of the mode as octal */
        !           503:     if (mode != 0)
        !           504:         gemu_log("%s%#o", sep, mode);
        !           505: 
        !           506:     gemu_log("%s", get_comma(last));
        !           507: }
        !           508: 
        !           509: static void
        !           510: print_open_flags(abi_long tflags, int last)
        !           511: {
        !           512:     int flags = tswap32(tflags);
        !           513: 
        !           514:     print_flags(open_access_flags, flags & TARGET_O_ACCMODE, 1);
        !           515:     flags &= ~TARGET_O_ACCMODE;
        !           516:     if (flags == 0) {
        !           517:         gemu_log("%s", get_comma(last));
        !           518:         return;
        !           519:     }
        !           520:     gemu_log("|");
        !           521:     print_flags(open_flags, flags, last);
        !           522: }
        !           523: 
        !           524: static void
        !           525: print_syscall_prologue(const struct syscallname *sc)
        !           526: {
        !           527:     gemu_log("%s(", sc->name);
        !           528: }
        !           529: 
        !           530: /*ARGSUSED*/
        !           531: static void
        !           532: print_syscall_epilogue(const struct syscallname *sc)
        !           533: {
        !           534:     (void)sc;
        !           535:     gemu_log(")");
        !           536: }
        !           537: 
        !           538: static void
        !           539: print_string(abi_long addr, int last)
        !           540: {
        !           541:     char *s;
        !           542: 
        !           543:     if ((s = lock_user_string(addr)) != NULL) {
        !           544:         gemu_log("\"%s\"%s", s, get_comma(last));
        !           545:         unlock_user(s, addr, 0);
        !           546:     } else {
        !           547:         /* can't get string out of it, so print it as pointer */
        !           548:         print_pointer(addr, last);
        !           549:     }
        !           550: }
        !           551: 
        !           552: /*
        !           553:  * Prints out raw parameter using given format.  Caller needs
        !           554:  * to do byte swapping if needed.
        !           555:  */
        !           556: static void
        !           557: print_raw_param(const char *fmt, abi_long param, int last)
        !           558: {
        !           559:     char format[64];
        !           560: 
        !           561:     (void) snprintf(format, sizeof (format), "%s%s", fmt, get_comma(last));
        !           562:     gemu_log(format, param);
        !           563: }
        !           564: 
        !           565: static void
        !           566: print_pointer(abi_long p, int last)
        !           567: {
        !           568:     if (p == 0)
        !           569:         gemu_log("NULL%s", get_comma(last));
        !           570:     else
        !           571:         gemu_log("0x" TARGET_ABI_FMT_lx "%s", p, get_comma(last));
        !           572: }
        !           573: 
        !           574: /*
        !           575:  * Reads 32-bit (int) number from guest address space from
        !           576:  * address 'addr' and prints it.
        !           577:  */
        !           578: static void
        !           579: print_number(abi_long addr, int last)
        !           580: {
        !           581:     if (addr == 0) {
        !           582:         gemu_log("NULL%s", get_comma(last));
        !           583:     } else {
        !           584:         int num;
        !           585: 
        !           586:         get_user_s32(num, addr);
        !           587:         gemu_log("[%d]%s", num, get_comma(last));
        !           588:     }
        !           589: }
        !           590: 
        !           591: static void
        !           592: print_timeval(abi_ulong tv_addr, int last)
        !           593: {
        !           594:     if( tv_addr ) {
        !           595:         struct target_timeval *tv;
        !           596: 
        !           597:         tv = lock_user(VERIFY_READ, tv_addr, sizeof(*tv), 1);
        !           598:         if (!tv)
        !           599:             return;
        !           600:         gemu_log("{" TARGET_ABI_FMT_ld "," TARGET_ABI_FMT_ld "}%s",
        !           601:             tv->tv_sec, tv->tv_usec, get_comma(last));
        !           602:         unlock_user(tv, tv_addr, 0);
        !           603:     } else
        !           604:         gemu_log("NULL%s", get_comma(last));
        !           605: }
        !           606: 
        !           607: #undef UNUSED
        !           608: 
        !           609: #ifdef TARGET_NR_accept
        !           610: static void
        !           611: print_accept(const struct syscallname *name,
        !           612:     abi_long arg0, abi_long arg1, abi_long arg2,
        !           613:     abi_long arg3, abi_long arg4, abi_long arg5)
        !           614: {
        !           615:     print_syscall_prologue(name);
        !           616:     print_raw_param("%d", tswap32(arg0), 0);
        !           617:     print_pointer(arg1, 0);
        !           618:     print_number(arg2, 1);
        !           619:     print_syscall_epilogue(name);
        !           620: }
        !           621: #endif
        !           622: 
        !           623: #ifdef TARGET_NR_access
        !           624: static void
        !           625: print_access(const struct syscallname *name,
        !           626:     abi_long arg0, abi_long arg1, abi_long arg2,
        !           627:     abi_long arg3, abi_long arg4, abi_long arg5)
        !           628: {
        !           629:     print_syscall_prologue(name);
        !           630:     print_string(arg0, 0);
        !           631:     print_flags(access_flags, arg1, 1);
        !           632:     print_syscall_epilogue(name);
        !           633: }
        !           634: #endif
        !           635: 
        !           636: #ifdef TARGET_NR_brk
        !           637: static void
        !           638: print_brk(const struct syscallname *name,
        !           639:     abi_long arg0, abi_long arg1, abi_long arg2,
        !           640:     abi_long arg3, abi_long arg4, abi_long arg5)
        !           641: {
        !           642:     print_syscall_prologue(name);
        !           643:     print_pointer(arg0, 1);
        !           644:     print_syscall_epilogue(name);
        !           645: }
        !           646: #endif
        !           647: 
        !           648: #ifdef TARGET_NR_chdir
        !           649: static void
        !           650: print_chdir(const struct syscallname *name,
        !           651:     abi_long arg0, abi_long arg1, abi_long arg2,
        !           652:     abi_long arg3, abi_long arg4, abi_long arg5)
        !           653: {
        !           654:     print_syscall_prologue(name);
        !           655:     print_string(arg0, 1);
        !           656:     print_syscall_epilogue(name);
        !           657: }
        !           658: #endif
        !           659: 
        !           660: #ifdef TARGET_NR_chmod
        !           661: static void
        !           662: print_chmod(const struct syscallname *name,
        !           663:     abi_long arg0, abi_long arg1, abi_long arg2,
        !           664:     abi_long arg3, abi_long arg4, abi_long arg5)
        !           665: {
        !           666:     print_syscall_prologue(name);
        !           667:     print_string(arg0, 0);
        !           668:     print_file_mode(arg1, 1);
        !           669:     print_syscall_epilogue(name);
        !           670: }
        !           671: #endif
        !           672: 
        !           673: #ifdef TARGET_NR_creat
        !           674: static void
        !           675: print_creat(const struct syscallname *name,
        !           676:     abi_long arg0, abi_long arg1, abi_long arg2,
        !           677:     abi_long arg3, abi_long arg4, abi_long arg5)
        !           678: {
        !           679:     print_syscall_prologue(name);
        !           680:     print_string(arg0, 0);
        !           681:     print_file_mode(arg1, 1);
        !           682:     print_syscall_epilogue(name);
        !           683: }
        !           684: #endif
        !           685: 
        !           686: #ifdef TARGET_NR_execv
        !           687: static void
        !           688: print_execv(const struct syscallname *name,
        !           689:     abi_long arg0, abi_long arg1, abi_long arg2,
        !           690:     abi_long arg3, abi_long arg4, abi_long arg5)
        !           691: {
        !           692:     print_syscall_prologue(name);
        !           693:     print_string(arg0, 0);
        !           694:     print_raw_param("0x" TARGET_ABI_FMT_lx, tswapl(arg1), 1);
        !           695:     print_syscall_epilogue(name);
        !           696: }
        !           697: #endif
        !           698: 
        !           699: #ifdef TARGET_NR_faccessat
        !           700: static void
        !           701: print_faccessat(const struct syscallname *name,
        !           702:     abi_long arg0, abi_long arg1, abi_long arg2,
        !           703:     abi_long arg3, abi_long arg4, abi_long arg5)
        !           704: {
        !           705:     print_syscall_prologue(name);
        !           706:     print_at_dirfd(arg0, 0);
        !           707:     print_string(arg1, 0);
        !           708:     print_flags(access_flags, arg2, 0);
        !           709:     print_flags(at_file_flags, arg3, 1);
        !           710:     print_syscall_epilogue(name);
        !           711: }
        !           712: #endif
        !           713: 
        !           714: #ifdef TARGET_NR_fchmodat
        !           715: static void
        !           716: print_fchmodat(const struct syscallname *name,
        !           717:     abi_long arg0, abi_long arg1, abi_long arg2,
        !           718:     abi_long arg3, abi_long arg4, abi_long arg5)
        !           719: {
        !           720:     print_syscall_prologue(name);
        !           721:     print_at_dirfd(arg0, 0);
        !           722:     print_string(arg1, 0);
        !           723:     print_file_mode(arg2, 0);
        !           724:     print_flags(at_file_flags, arg3, 1);
        !           725:     print_syscall_epilogue(name);
        !           726: }
        !           727: #endif
        !           728: 
        !           729: #ifdef TARGET_NR_fchownat
        !           730: static void
        !           731: print_fchownat(const struct syscallname *name,
        !           732:     abi_long arg0, abi_long arg1, abi_long arg2,
        !           733:     abi_long arg3, abi_long arg4, abi_long arg5)
        !           734: {
        !           735:     print_syscall_prologue(name);
        !           736:     print_at_dirfd(arg0, 0);
        !           737:     print_string(arg1, 0);
        !           738: #ifdef USE_UID16
        !           739:     print_raw_param("%d", tswap16(arg2), 0);
        !           740:     print_raw_param("%d", tswap16(arg3), 0);
        !           741: #else
        !           742:     print_raw_param("%d", tswap32(arg2), 0);
        !           743:     print_raw_param("%d", tswap32(arg3), 0);
        !           744: #endif
        !           745:     print_flags(at_file_flags, arg4, 1);
        !           746:     print_syscall_epilogue(name);
        !           747: }
        !           748: #endif
        !           749: 
        !           750: #if defined(TARGET_NR_fcntl) || defined(TARGET_NR_fcntl64)
        !           751: static void
        !           752: print_fcntl(const struct syscallname *name,
        !           753:     abi_long arg0, abi_long arg1, abi_long arg2,
        !           754:     abi_long arg3, abi_long arg4, abi_long arg5)
        !           755: {
        !           756:     print_syscall_prologue(name);
        !           757:     print_raw_param("%d", tswap32(arg0), 0);
        !           758:     print_flags(fcntl_flags, arg1, 0);
        !           759:     /*
        !           760:      * TODO: check flags and print following argument only
        !           761:      *       when needed.
        !           762:      */
        !           763:     print_pointer(arg2, 1);
        !           764:     print_syscall_epilogue(name);
        !           765: }
        !           766: #define print_fcntl64   print_fcntl
        !           767: #endif
        !           768: 
        !           769: 
        !           770: #ifdef TARGET_NR_futimesat
        !           771: static void
        !           772: print_futimesat(const struct syscallname *name,
        !           773:     abi_long arg0, abi_long arg1, abi_long arg2,
        !           774:     abi_long arg3, abi_long arg4, abi_long arg5)
        !           775: {
        !           776:     print_syscall_prologue(name);
        !           777:     print_at_dirfd(arg0, 0);
        !           778:     print_string(arg1, 0);
        !           779:     print_timeval(arg2, 0);
        !           780:     print_timeval(arg2 + sizeof (struct target_timeval), 1);
        !           781:     print_syscall_epilogue(name);
        !           782: }
        !           783: #endif
        !           784: 
        !           785: #ifdef TARGET_NR_link
        !           786: static void
        !           787: print_link(const struct syscallname *name,
        !           788:     abi_long arg0, abi_long arg1, abi_long arg2,
        !           789:     abi_long arg3, abi_long arg4, abi_long arg5)
        !           790: {
        !           791:     print_syscall_prologue(name);
        !           792:     print_string(arg0, 0);
        !           793:     print_string(arg1, 1);
        !           794:     print_syscall_epilogue(name);
        !           795: }
        !           796: #endif
        !           797: 
        !           798: #ifdef TARGET_NR_linkat
        !           799: static void
        !           800: print_linkat(const struct syscallname *name,
        !           801:     abi_long arg0, abi_long arg1, abi_long arg2,
        !           802:     abi_long arg3, abi_long arg4, abi_long arg5)
        !           803: {
        !           804:     print_syscall_prologue(name);
        !           805:     print_at_dirfd(arg0, 0);
        !           806:     print_string(arg1, 0);
        !           807:     print_at_dirfd(arg2, 0);
        !           808:     print_string(arg3, 0);
        !           809:     print_flags(at_file_flags, arg4, 1);
        !           810:     print_syscall_epilogue(name);
        !           811: }
        !           812: #endif
        !           813: 
        !           814: #if defined(TARGET_NR_stat) || defined(TARGET_NR_stat64) || \
        !           815:     defined(TARGET_NR_lstat) || defined(TARGET_NR_lstat64)
        !           816: static void
        !           817: print_stat(const struct syscallname *name,
        !           818:     abi_long arg0, abi_long arg1, abi_long arg2,
        !           819:     abi_long arg3, abi_long arg4, abi_long arg5)
        !           820: {
        !           821:     print_syscall_prologue(name);
        !           822:     print_string(arg0, 0);
        !           823:     print_pointer(arg1, 1);
        !           824:     print_syscall_epilogue(name);
        !           825: }
        !           826: #define print_lstat     print_stat
        !           827: #define print_stat64   print_stat
        !           828: #define print_lstat64   print_stat
        !           829: #endif
        !           830: 
        !           831: #if defined(TARGET_NR_fstat) || defined(TARGET_NR_fstat64)
        !           832: static void
        !           833: print_fstat(const struct syscallname *name,
        !           834:     abi_long arg0, abi_long arg1, abi_long arg2,
        !           835:     abi_long arg3, abi_long arg4, abi_long arg5)
        !           836: {
        !           837:     print_syscall_prologue(name);
        !           838:     print_raw_param("%d", tswap32(arg0), 0);
        !           839:     print_pointer(arg1, 1);
        !           840:     print_syscall_epilogue(name);
        !           841: }
        !           842: #define print_fstat64     print_fstat
        !           843: #endif
        !           844: 
        !           845: #ifdef TARGET_NR_mkdir
        !           846: static void
        !           847: print_mkdir(const struct syscallname *name,
        !           848:     abi_long arg0, abi_long arg1, abi_long arg2,
        !           849:     abi_long arg3, abi_long arg4, abi_long arg5)
        !           850: {
        !           851:     print_syscall_prologue(name);
        !           852:     print_string(arg0, 0);
        !           853:     print_file_mode(arg1, 1);
        !           854:     print_syscall_epilogue(name);
        !           855: }
        !           856: #endif
        !           857: 
        !           858: #ifdef TARGET_NR_mkdirat
        !           859: static void
        !           860: print_mkdirat(const struct syscallname *name,
        !           861:     abi_long arg0, abi_long arg1, abi_long arg2,
        !           862:     abi_long arg3, abi_long arg4, abi_long arg5)
        !           863: {
        !           864:     print_syscall_prologue(name);
        !           865:     print_at_dirfd(arg0, 0);
        !           866:     print_string(arg1, 0);
        !           867:     print_file_mode(arg2, 1);
        !           868:     print_syscall_epilogue(name);
        !           869: }
        !           870: #endif
        !           871: 
        !           872: #ifdef TARGET_NR_mknod
        !           873: static void
        !           874: print_mknod(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:     int hasdev = (tswapl(arg1) & (S_IFCHR|S_IFBLK));
        !           879: 
        !           880:     print_syscall_prologue(name);
        !           881:     print_string(arg0, 0);
        !           882:     print_file_mode(arg1, (hasdev == 0));
        !           883:     if (hasdev) {
        !           884:         print_raw_param("makedev(%d", major(tswapl(arg2)), 0);
        !           885:         print_raw_param("%d)", minor(tswapl(arg2)), 1);
        !           886:     }
        !           887:     print_syscall_epilogue(name);
        !           888: }
        !           889: #endif
        !           890: 
        !           891: #ifdef TARGET_NR_mknodat
        !           892: static void
        !           893: print_mknodat(const struct syscallname *name,
        !           894:     abi_long arg0, abi_long arg1, abi_long arg2,
        !           895:     abi_long arg3, abi_long arg4, abi_long arg5)
        !           896: {
        !           897:     int hasdev = (tswapl(arg2) & (S_IFCHR|S_IFBLK));
        !           898: 
        !           899:     print_syscall_prologue(name);
        !           900:     print_at_dirfd(arg0, 0);
        !           901:     print_string(arg1, 0);
        !           902:     print_file_mode(arg2, (hasdev == 0));
        !           903:     if (hasdev) {
        !           904:         print_raw_param("makedev(%d", major(tswapl(arg3)), 0);
        !           905:         print_raw_param("%d)", minor(tswapl(arg3)), 1);
        !           906:     }
        !           907:     print_syscall_epilogue(name);
        !           908: }
        !           909: #endif
        !           910: 
        !           911: #ifdef TARGET_NR_mq_open
        !           912: static void
        !           913: print_mq_open(const struct syscallname *name,
        !           914:     abi_long arg0, abi_long arg1, abi_long arg2,
        !           915:     abi_long arg3, abi_long arg4, abi_long arg5)
        !           916: {
        !           917:     int is_creat = (tswapl(arg1) & TARGET_O_CREAT);
        !           918: 
        !           919:     print_syscall_prologue(name);
        !           920:     print_string(arg0, 0);
        !           921:     print_open_flags(arg1, (is_creat == 0));
        !           922:     if (is_creat) {
        !           923:         print_file_mode(arg2, 0);
        !           924:         print_pointer(arg3, 1);
        !           925:     }
        !           926:     print_syscall_epilogue(name);
        !           927: }
        !           928: #endif
        !           929: 
        !           930: #ifdef TARGET_NR_open
        !           931: static void
        !           932: print_open(const struct syscallname *name,
        !           933:     abi_long arg0, abi_long arg1, abi_long arg2,
        !           934:     abi_long arg3, abi_long arg4, abi_long arg5)
        !           935: {
        !           936:     int is_creat = (tswap32(arg1) & TARGET_O_CREAT);
        !           937: 
        !           938:     print_syscall_prologue(name);
        !           939:     print_string(arg0, 0);
        !           940:     print_open_flags(arg1, (is_creat == 0));
        !           941:     if (is_creat)
        !           942:         print_file_mode(arg2, 1);
        !           943:     print_syscall_epilogue(name);
        !           944: }
        !           945: #endif
        !           946: 
        !           947: #ifdef TARGET_NR_openat
        !           948: static void
        !           949: print_openat(const struct syscallname *name,
        !           950:     abi_long arg0, abi_long arg1, abi_long arg2,
        !           951:     abi_long arg3, abi_long arg4, abi_long arg5)
        !           952: {
        !           953:     int is_creat = (tswap32(arg2) & TARGET_O_CREAT);
        !           954: 
        !           955:     print_syscall_prologue(name);
        !           956:     print_at_dirfd(arg0, 0);
        !           957:     print_string(arg1, 0);
        !           958:     print_open_flags(arg2, (is_creat == 0));
        !           959:     if (is_creat)
        !           960:         print_file_mode(arg3, 1);
        !           961:     print_syscall_epilogue(name);
        !           962: }
        !           963: #endif
        !           964: 
        !           965: #ifdef TARGET_NR_mq_unlink
        !           966: static void
        !           967: print_mq_unlink(const struct syscallname *name,
        !           968:     abi_long arg0, abi_long arg1, abi_long arg2,
        !           969:     abi_long arg3, abi_long arg4, abi_long arg5)
        !           970: {
        !           971:     print_syscall_prologue(name);
        !           972:     print_string(arg0, 1);
        !           973:     print_syscall_epilogue(name);
        !           974: }
        !           975: #endif
        !           976: 
        !           977: #if defined(TARGET_NR_fstatat64) || defined(TARGET_NR_newfstatat)
        !           978: static void
        !           979: print_fstatat64(const struct syscallname *name,
        !           980:     abi_long arg0, abi_long arg1, abi_long arg2,
        !           981:     abi_long arg3, abi_long arg4, abi_long arg5)
        !           982: {
        !           983:     print_syscall_prologue(name);
        !           984:     print_at_dirfd(arg0, 0);
        !           985:     print_string(arg1, 0);
        !           986:     print_pointer(arg2, 0);
        !           987:     print_flags(at_file_flags, arg3, 1);
        !           988:     print_syscall_epilogue(name);
        !           989: }
        !           990: #define print_newfstatat    print_fstatat64
        !           991: #endif
        !           992: 
        !           993: #ifdef TARGET_NR_readlink
        !           994: static void
        !           995: print_readlink(const struct syscallname *name,
        !           996:     abi_long arg0, abi_long arg1, abi_long arg2,
        !           997:     abi_long arg3, abi_long arg4, abi_long arg5)
        !           998: {
        !           999:     print_syscall_prologue(name);
        !          1000:     print_string(arg0, 0);
        !          1001:     print_pointer(arg1, 0);
        !          1002:     print_raw_param("%u", tswapl(arg2), 1);
        !          1003:     print_syscall_epilogue(name);
        !          1004: }
        !          1005: #endif
        !          1006: 
        !          1007: #ifdef TARGET_NR_readlinkat
        !          1008: static void
        !          1009: print_readlinkat(const struct syscallname *name,
        !          1010:     abi_long arg0, abi_long arg1, abi_long arg2,
        !          1011:     abi_long arg3, abi_long arg4, abi_long arg5)
        !          1012: {
        !          1013:     print_syscall_prologue(name);
        !          1014:     print_at_dirfd(arg0, 0);
        !          1015:     print_string(arg1, 0);
        !          1016:     print_pointer(arg2, 0);
        !          1017:     print_raw_param("%u", tswapl(arg3), 1);
        !          1018:     print_syscall_epilogue(name);
        !          1019: }
        !          1020: #endif
        !          1021: 
        !          1022: #ifdef TARGET_NR_rename
        !          1023: static void
        !          1024: print_rename(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:     print_syscall_prologue(name);
        !          1029:     print_string(arg0, 0);
        !          1030:     print_string(arg1, 1);
        !          1031:     print_syscall_epilogue(name);
        !          1032: }
        !          1033: #endif
        !          1034: 
        !          1035: #ifdef TARGET_NR_renameat
        !          1036: static void
        !          1037: print_renameat(const struct syscallname *name,
        !          1038:     abi_long arg0, abi_long arg1, abi_long arg2,
        !          1039:     abi_long arg3, abi_long arg4, abi_long arg5)
        !          1040: {
        !          1041:     print_syscall_prologue(name);
        !          1042:     print_at_dirfd(arg0, 0);
        !          1043:     print_string(arg1, 0);
        !          1044:     print_at_dirfd(arg2, 0);
        !          1045:     print_string(arg3, 1);
        !          1046:     print_syscall_epilogue(name);
        !          1047: }
        !          1048: #endif
        !          1049: 
        !          1050: #ifdef TARGET_NR_statfs
        !          1051: static void
        !          1052: print_statfs(const struct syscallname *name,
        !          1053:     abi_long arg0, abi_long arg1, abi_long arg2,
        !          1054:     abi_long arg3, abi_long arg4, abi_long arg5)
        !          1055: {
        !          1056:     print_syscall_prologue(name);
        !          1057:     print_string(arg0, 0);
        !          1058:     print_pointer(arg1, 1);
        !          1059:     print_syscall_epilogue(name);
        !          1060: }
        !          1061: #define print_statfs64  print_statfs
        !          1062: #endif
        !          1063: 
        !          1064: #ifdef TARGET_NR_symlink
        !          1065: static void
        !          1066: print_symlink(const struct syscallname *name,
        !          1067:     abi_long arg0, abi_long arg1, abi_long arg2,
        !          1068:     abi_long arg3, abi_long arg4, abi_long arg5)
        !          1069: {
        !          1070:     print_syscall_prologue(name);
        !          1071:     print_string(arg0, 0);
        !          1072:     print_string(arg1, 1);
        !          1073:     print_syscall_epilogue(name);
        !          1074: }
        !          1075: #endif
        !          1076: 
        !          1077: #ifdef TARGET_NR_symlinkat
        !          1078: static void
        !          1079: print_symlinkat(const struct syscallname *name,
        !          1080:     abi_long arg0, abi_long arg1, abi_long arg2,
        !          1081:     abi_long arg3, abi_long arg4, abi_long arg5)
        !          1082: {
        !          1083:     print_syscall_prologue(name);
        !          1084:     print_string(arg0, 0);
        !          1085:     print_at_dirfd(arg1, 0);
        !          1086:     print_string(arg2, 1);
        !          1087:     print_syscall_epilogue(name);
        !          1088: }
        !          1089: #endif
        !          1090: 
        !          1091: #ifdef TARGET_NR_mount
        !          1092: static void
        !          1093: print_mount(const struct syscallname *name,
        !          1094:     abi_long arg0, abi_long arg1, abi_long arg2,
        !          1095:     abi_long arg3, abi_long arg4, abi_long arg5)
        !          1096: {
        !          1097:     print_syscall_prologue(name);
        !          1098:     print_string(arg0, 0);
        !          1099:     print_string(arg1, 0);
        !          1100:     print_string(arg2, 0);
        !          1101:     print_flags(mount_flags, arg3, 0);
        !          1102:     print_pointer(arg4, 1);
        !          1103:     print_syscall_epilogue(name);
        !          1104: }
        !          1105: #endif
        !          1106: 
        !          1107: #ifdef TARGET_NR_umount
        !          1108: static void
        !          1109: print_umount(const struct syscallname *name,
        !          1110:     abi_long arg0, abi_long arg1, abi_long arg2,
        !          1111:     abi_long arg3, abi_long arg4, abi_long arg5)
        !          1112: {
        !          1113:     print_syscall_prologue(name);
        !          1114:     print_string(arg0, 1);
        !          1115:     print_syscall_epilogue(name);
        !          1116: }
        !          1117: #endif
        !          1118: 
        !          1119: #ifdef TARGET_NR_umount2
        !          1120: static void
        !          1121: print_umount2(const struct syscallname *name,
        !          1122:     abi_long arg0, abi_long arg1, abi_long arg2,
        !          1123:     abi_long arg3, abi_long arg4, abi_long arg5)
        !          1124: {
        !          1125:     print_syscall_prologue(name);
        !          1126:     print_string(arg0, 0);
        !          1127:     print_flags(umount2_flags, arg1, 1);
        !          1128:     print_syscall_epilogue(name);
        !          1129: }
        !          1130: #endif
        !          1131: 
        !          1132: #ifdef TARGET_NR_unlink
        !          1133: static void
        !          1134: print_unlink(const struct syscallname *name,
        !          1135:     abi_long arg0, abi_long arg1, abi_long arg2,
        !          1136:     abi_long arg3, abi_long arg4, abi_long arg5)
        !          1137: {
        !          1138:     print_syscall_prologue(name);
        !          1139:     print_string(arg0, 1);
        !          1140:     print_syscall_epilogue(name);
        !          1141: }
        !          1142: #endif
        !          1143: 
        !          1144: #ifdef TARGET_NR_unlinkat
        !          1145: static void
        !          1146: print_unlinkat(const struct syscallname *name,
        !          1147:     abi_long arg0, abi_long arg1, abi_long arg2,
        !          1148:     abi_long arg3, abi_long arg4, abi_long arg5)
        !          1149: {
        !          1150:     print_syscall_prologue(name);
        !          1151:     print_at_dirfd(arg0, 0);
        !          1152:     print_string(arg1, 0);
        !          1153:     print_flags(unlinkat_flags, arg2, 1);
        !          1154:     print_syscall_epilogue(name);
        !          1155: }
        !          1156: #endif
        !          1157: 
        !          1158: #ifdef TARGET_NR_utime
        !          1159: static void
        !          1160: print_utime(const struct syscallname *name,
        !          1161:     abi_long arg0, abi_long arg1, abi_long arg2,
        !          1162:     abi_long arg3, abi_long arg4, abi_long arg5)
        !          1163: {
        !          1164:     print_syscall_prologue(name);
        !          1165:     print_string(arg0, 0);
        !          1166:     print_pointer(arg1, 1);
        !          1167:     print_syscall_epilogue(name);
        !          1168: }
        !          1169: #endif
        !          1170: 
        !          1171: #ifdef TARGET_NR_utimes
        !          1172: static void
        !          1173: print_utimes(const struct syscallname *name,
        !          1174:     abi_long arg0, abi_long arg1, abi_long arg2,
        !          1175:     abi_long arg3, abi_long arg4, abi_long arg5)
        !          1176: {
        !          1177:     print_syscall_prologue(name);
        !          1178:     print_string(arg0, 0);
        !          1179:     print_pointer(arg1, 1);
        !          1180:     print_syscall_epilogue(name);
        !          1181: }
        !          1182: #endif
        !          1183: 
        !          1184: #ifdef TARGET_NR_utimensat
        !          1185: static void
        !          1186: print_utimensat(const struct syscallname *name,
        !          1187:     abi_long arg0, abi_long arg1, abi_long arg2,
        !          1188:     abi_long arg3, abi_long arg4, abi_long arg5)
        !          1189: {
        !          1190:     print_syscall_prologue(name);
        !          1191:     print_at_dirfd(arg0, 0);
        !          1192:     print_string(arg1, 0);
        !          1193:     print_pointer(arg2, 0);
        !          1194:     print_flags(at_file_flags, arg3, 1);
        !          1195:     print_syscall_epilogue(name);
        !          1196: }
        !          1197: #endif
        !          1198: 
        !          1199: #ifdef TARGET_NR_mmap
        !          1200: static void
        !          1201: print_mmap(const struct syscallname *name,
        !          1202:     abi_long arg0, abi_long arg1, abi_long arg2,
        !          1203:     abi_long arg3, abi_long arg4, abi_long arg5)
        !          1204: {
        !          1205:     print_syscall_prologue(name);
        !          1206:     print_pointer(arg0, 0);
        !          1207:     print_raw_param("%d", tswapl(arg1), 0);
        !          1208:     print_flags(mmap_prot_flags, arg2, 0);
        !          1209:     print_flags(mmap_flags, arg3, 0);
        !          1210:     print_raw_param("%d", tswapl(arg4), 0);
        !          1211:     print_raw_param("%#x", tswapl(arg5), 1);
        !          1212:     print_syscall_epilogue(name);
        !          1213: }
        !          1214: #define print_mmap2     print_mmap
        !          1215: #endif
        !          1216: 
        !          1217: #ifdef TARGET_NR_mprotect
        !          1218: static void
        !          1219: print_mprotect(const struct syscallname *name,
        !          1220:     abi_long arg0, abi_long arg1, abi_long arg2,
        !          1221:     abi_long arg3, abi_long arg4, abi_long arg5)
        !          1222: {
        !          1223:     print_syscall_prologue(name);
        !          1224:     print_pointer(arg0, 0);
        !          1225:     print_raw_param("%d", tswapl(arg1), 0);
        !          1226:     print_flags(mmap_prot_flags, arg2, 1);
        !          1227:     print_syscall_epilogue(name);
        !          1228: }
        !          1229: #endif
        !          1230: 
        !          1231: #ifdef TARGET_NR_munmap
        !          1232: static void
        !          1233: print_munmap(const struct syscallname *name,
        !          1234:     abi_long arg0, abi_long arg1, abi_long arg2,
        !          1235:     abi_long arg3, abi_long arg4, abi_long arg5)
        !          1236: {
        !          1237:     print_syscall_prologue(name);
        !          1238:     print_pointer(arg0, 0);
        !          1239:     print_raw_param("%d", tswapl(arg1), 1);
        !          1240:     print_syscall_epilogue(name);
        !          1241: }
        !          1242: #endif
        !          1243: 
        !          1244: #ifdef TARGET_NR_futex
        !          1245: static void print_futex_op(abi_long tflag, int last)
        !          1246: {
        !          1247: #define print_op(val) \
        !          1248: if( cmd == val ) { \
        !          1249:     gemu_log(#val); \
        !          1250:     return; \
        !          1251: }
        !          1252: 
        !          1253:     int cmd = (int)tswap32(tflag);
        !          1254: #ifdef FUTEX_PRIVATE_FLAG
        !          1255:     if (cmd == FUTEX_PRIVATE_FLAG)
        !          1256:         gemu_log("FUTEX_PRIVATE_FLAG|");
        !          1257: #endif
        !          1258:     print_op(FUTEX_WAIT)
        !          1259:     print_op(FUTEX_WAKE)
        !          1260:     print_op(FUTEX_FD)
        !          1261:     print_op(FUTEX_REQUEUE)
        !          1262:     print_op(FUTEX_CMP_REQUEUE)
        !          1263:     print_op(FUTEX_WAKE_OP)
        !          1264:     print_op(FUTEX_LOCK_PI)
        !          1265:     print_op(FUTEX_UNLOCK_PI)
        !          1266:     print_op(FUTEX_TRYLOCK_PI)
        !          1267: #ifdef FUTEX_WAIT_BITSET
        !          1268:     print_op(FUTEX_WAIT_BITSET)
        !          1269: #endif
        !          1270: #ifdef FUTEX_WAKE_BITSET
        !          1271:     print_op(FUTEX_WAKE_BITSET)
        !          1272: #endif
        !          1273:     /* unknown values */
        !          1274:     gemu_log("%d",cmd);
        !          1275: }
        !          1276: 
        !          1277: static void
        !          1278: print_futex(const struct syscallname *name,
        !          1279:     abi_long arg0, abi_long arg1, abi_long arg2,
        !          1280:     abi_long arg3, abi_long arg4, abi_long arg5)
        !          1281: {
        !          1282:     print_syscall_prologue(name);
        !          1283:     print_pointer(arg0, 0);
        !          1284:     print_futex_op(arg1, 0);
        !          1285:     print_raw_param(",%d", tswapl(arg2), 0);
        !          1286:     print_pointer(arg3, 0); /* struct timespec */
        !          1287:     print_pointer(arg4, 0);
        !          1288:     print_raw_param("%d", tswapl(arg4), 1);
        !          1289:     print_syscall_epilogue(name);
        !          1290: }
        !          1291: #endif
        !          1292: 
1.1       root     1293: /*
                   1294:  * An array of all of the syscalls we know about
                   1295:  */
                   1296: 
1.1.1.2   root     1297: static const struct syscallname scnames[] = {
1.1       root     1298: #include "strace.list"
                   1299: };
                   1300: 
1.1.1.2   root     1301: static int nsyscalls = ARRAY_SIZE(scnames);
1.1       root     1302: 
                   1303: /*
                   1304:  * The public interface to this module.
                   1305:  */
                   1306: void
                   1307: print_syscall(int num,
                   1308:               abi_long arg1, abi_long arg2, abi_long arg3,
                   1309:               abi_long arg4, abi_long arg5, abi_long arg6)
                   1310: {
                   1311:     int i;
1.1.1.2   root     1312:     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     1313: 
                   1314:     gemu_log("%d ", getpid() );
                   1315: 
                   1316:     for(i=0;i<nsyscalls;i++)
                   1317:         if( scnames[i].nr == num ) {
                   1318:             if( scnames[i].call != NULL ) {
                   1319:                 scnames[i].call(&scnames[i],arg1,arg2,arg3,arg4,arg5,arg6);
                   1320:             } else {
                   1321:                 /* XXX: this format system is broken because it uses
                   1322:                    host types and host pointers for strings */
                   1323:                 if( scnames[i].format != NULL )
                   1324:                     format = scnames[i].format;
                   1325:                 gemu_log(format,scnames[i].name, arg1,arg2,arg3,arg4,arg5,arg6);
                   1326:             }
1.1.1.2   root     1327:             return;
1.1       root     1328:         }
1.1.1.2   root     1329:     gemu_log("Unknown syscall %d\n", num);
1.1       root     1330: }
                   1331: 
                   1332: 
                   1333: void
                   1334: print_syscall_ret(int num, abi_long ret)
                   1335: {
                   1336:     int i;
                   1337: 
                   1338:     for(i=0;i<nsyscalls;i++)
                   1339:         if( scnames[i].nr == num ) {
                   1340:             if( scnames[i].result != NULL ) {
                   1341:                 scnames[i].result(&scnames[i],ret);
                   1342:             } else {
                   1343:                 if( ret < 0 ) {
                   1344:                     gemu_log(" = -1 errno=" TARGET_ABI_FMT_ld " (%s)\n", -ret, target_strerror(-ret));
                   1345:                 } else {
                   1346:                     gemu_log(" = " TARGET_ABI_FMT_ld "\n", ret);
                   1347:                 }
                   1348:             }
                   1349:             break;
                   1350:         }
                   1351: }

unix.superglobalmegacorp.com