[qemu.git] / linux-user / strace.c

#include <stdio.h>
#include <errno.h>
#include <sys/ipc.h>
#include <sys/msg.h>
#include <sys/sem.h>
#include <sys/shm.h>
#include <sys/select.h>
#include <sys/types.h>
#include <unistd.h>
#include "qemu.h"

int do_strace=0;

struct syscallname {
    int nr;
    const char *name;
    const char *format;
    void (*call)(const struct syscallname *,
                 abi_long, abi_long, abi_long,
                 abi_long, abi_long, abi_long);
    void (*result)(const struct syscallname *, abi_long);
};

/*
 * Utility functions
 */
static void
print_ipc_cmd(int cmd)
{
#define output_cmd(val) \
if( cmd == val ) { \
    gemu_log(#val); \
    return; \
}

    cmd &= 0xff;

    /* General IPC commands */
    output_cmd( IPC_RMID );
    output_cmd( IPC_SET );
    output_cmd( IPC_STAT );
    output_cmd( IPC_INFO );
    /* msgctl() commands */
    #ifdef __USER_MISC
    output_cmd( MSG_STAT );
    output_cmd( MSG_INFO );
    #endif
    /* shmctl() commands */
    output_cmd( SHM_LOCK );
    output_cmd( SHM_UNLOCK );
    output_cmd( SHM_STAT );
    output_cmd( SHM_INFO );
    /* semctl() commands */
    output_cmd( GETPID );
    output_cmd( GETVAL );
    output_cmd( GETALL );
    output_cmd( GETNCNT );
    output_cmd( GETZCNT );
    output_cmd( SETVAL );
    output_cmd( SETALL );
    output_cmd( SEM_STAT );
    output_cmd( SEM_INFO );
    output_cmd( IPC_RMID );
    output_cmd( IPC_RMID );
    output_cmd( IPC_RMID );
    output_cmd( IPC_RMID );
    output_cmd( IPC_RMID );
    output_cmd( IPC_RMID );
    output_cmd( IPC_RMID );
    output_cmd( IPC_RMID );
    output_cmd( IPC_RMID );

    /* Some value we don't recognize */
    gemu_log("%d",cmd);
}

#ifdef TARGET_NR__newselect
static void
print_fdset(int n, abi_ulong target_fds_addr)
{
    int i;

    gemu_log("[");
    if( target_fds_addr ) {
        abi_long *target_fds;

        target_fds = lock_user(VERIFY_READ,
                               target_fds_addr,
                               sizeof(*target_fds)*(n / TARGET_ABI_BITS + 1),
                               1);

        if (!target_fds)
            return;

        for (i=n; i>=0; i--) {
            if ((tswapl(target_fds[i / TARGET_ABI_BITS]) >> (i & (TARGET_ABI_BITS - 1))) & 1)
                gemu_log("%d,", i );
            }
        unlock_user(target_fds, target_fds_addr, 0);
    }
    gemu_log("]");
}

static void
print_timeval(abi_ulong tv_addr)
{
    if( tv_addr ) {
        struct target_timeval *tv;

        tv = lock_user(VERIFY_READ, tv_addr, sizeof(*tv), 1);
        if (!tv)
            return;
        gemu_log("{" TARGET_ABI_FMT_ld "," TARGET_ABI_FMT_ld "}",
        	 tv->tv_sec, tv->tv_usec);
        unlock_user(tv, tv_addr, 0);
    } else
        gemu_log("NULL");
}
#endif

/*
 * Sysycall specific output functions
 */

/* select */
#ifdef TARGET_NR__newselect
static long newselect_arg1 = 0;
static long newselect_arg2 = 0;
static long newselect_arg3 = 0;
static long newselect_arg4 = 0;
static long newselect_arg5 = 0;

static void
print_newselect(const struct syscallname *name,
                abi_long arg1, abi_long arg2, abi_long arg3,
                abi_long arg4, abi_long arg5, abi_long arg6)
{
    gemu_log("%s(" TARGET_ABI_FMT_ld ",", name->name, arg1);
    print_fdset(arg1, arg2);
    gemu_log(",");
    print_fdset(arg1, arg3);
    gemu_log(",");
    print_fdset(arg1, arg4);
    gemu_log(",");
    print_timeval(arg5);
    gemu_log(")");

    /* save for use in the return output function below */
    newselect_arg1=arg1;
    newselect_arg2=arg2;
    newselect_arg3=arg3;
    newselect_arg4=arg4;
    newselect_arg5=arg5;
}
#endif

#ifdef TARGET_NR_semctl
static void
print_semctl(const struct syscallname *name,
             abi_long arg1, abi_long arg2, abi_long arg3,
             abi_long arg4, abi_long arg5, abi_long arg6)
{
    gemu_log("%s(" TARGET_ABI_FMT_ld "," TARGET_ABI_FMT_ld ",", name->name, arg1, arg2);
    print_ipc_cmd(arg3);
    gemu_log(",0x" TARGET_ABI_FMT_lx ")", arg4);
}
#endif

static void
print_execve(const struct syscallname *name,
             abi_long arg1, abi_long arg2, abi_long arg3,
             abi_long arg4, abi_long arg5, abi_long arg6)
{
    abi_ulong arg_ptr_addr;
    char *s;

    if (!(s = lock_user_string(arg1)))
        return;
    gemu_log("%s(\"%s\",{", name->name, s);
    unlock_user(s, arg1, 0);

    for (arg_ptr_addr = arg2; ; arg_ptr_addr += sizeof(abi_ulong)) {
        abi_ulong *arg_ptr, arg_addr;

	arg_ptr = lock_user(VERIFY_READ, arg_ptr_addr, sizeof(abi_ulong), 1);
        if (!arg_ptr)
            return;
	arg_addr = tswapl(*arg_ptr);
	unlock_user(arg_ptr, arg_ptr_addr, 0);
        if (!arg_addr)
            break;
        if ((s = lock_user_string(arg_addr))) {
            gemu_log("\"%s\",", s);
            unlock_user(s, arg_addr, 0);
        }
    }

    gemu_log("NULL})");
}

#ifdef TARGET_NR_ipc
static void
print_ipc(const struct syscallname *name,
          abi_long arg1, abi_long arg2, abi_long arg3,
          abi_long arg4, abi_long arg5, abi_long arg6)
{
    switch(arg1) {
    case IPCOP_semctl:
        gemu_log("semctl(" TARGET_ABI_FMT_ld "," TARGET_ABI_FMT_ld ",", arg1, arg2);
        print_ipc_cmd(arg3);
        gemu_log(",0x" TARGET_ABI_FMT_lx ")", arg4);
        break;
    default:
        gemu_log("%s(" TARGET_ABI_FMT_ld "," TARGET_ABI_FMT_ld "," TARGET_ABI_FMT_ld "," TARGET_ABI_FMT_ld ")",
                 name->name, arg1, arg2, arg3, arg4);
    }
}
#endif

/*
 * Variants for the return value output function
 */

static void
print_syscall_ret_addr(const struct syscallname *name, abi_long ret)
{
if( ret == -1 ) {
        gemu_log(" = -1 errno=%d (%s)\n", errno, target_strerror(errno));
    } else {
        gemu_log(" = 0x" TARGET_ABI_FMT_lx "\n", ret);
    }
}

#if 0 /* currently unused */
static void
print_syscall_ret_raw(struct syscallname *name, abi_long ret)
{
        gemu_log(" = 0x" TARGET_ABI_FMT_lx "\n", ret);
}
#endif

#ifdef TARGET_NR__newselect
static void
print_syscall_ret_newselect(const struct syscallname *name, abi_long ret)
{
    gemu_log(" = 0x" TARGET_ABI_FMT_lx " (", ret);
    print_fdset(newselect_arg1,newselect_arg2);
    gemu_log(",");
    print_fdset(newselect_arg1,newselect_arg3);
    gemu_log(",");
    print_fdset(newselect_arg1,newselect_arg4);
    gemu_log(",");
    print_timeval(newselect_arg5);
    gemu_log(")\n");
}
#endif

/*
 * An array of all of the syscalls we know about
 */

static const struct syscallname scnames[] = {
#include "strace.list"
};

static int nsyscalls = ARRAY_SIZE(scnames);

/*
 * The public interface to this module.
 */
void
print_syscall(int num,
              abi_long arg1, abi_long arg2, abi_long arg3,
              abi_long arg4, abi_long arg5, abi_long arg6)
{
    int i;
    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 ")";

    gemu_log("%d ", getpid() );

    for(i=0;i<nsyscalls;i++)
        if( scnames[i].nr == num ) {
            if( scnames[i].call != NULL ) {
                scnames[i].call(&scnames[i],arg1,arg2,arg3,arg4,arg5,arg6);
            } else {
                /* XXX: this format system is broken because it uses
                   host types and host pointers for strings */
                if( scnames[i].format != NULL )
                    format = scnames[i].format;
                gemu_log(format,scnames[i].name, arg1,arg2,arg3,arg4,arg5,arg6);
            }
            return;
        }
    gemu_log("Unknown syscall %d\n", num);
}


void
print_syscall_ret(int num, abi_long ret)
{
    int i;

    for(i=0;i<nsyscalls;i++)
        if( scnames[i].nr == num ) {
            if( scnames[i].result != NULL ) {
                scnames[i].result(&scnames[i],ret);
            } else {
                if( ret < 0 ) {
                    gemu_log(" = -1 errno=" TARGET_ABI_FMT_ld " (%s)\n", -ret, target_strerror(-ret));
                } else {
                    gemu_log(" = " TARGET_ABI_FMT_ld "\n", ret);
                }
            }
            break;
        }
}
Commit	Line	Data
33189d31 TS	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 <unistd.h>
	10	#include "qemu.h"
	11
	12	int do_strace=0;
	13
	14	struct syscallname {
	15	int nr;
7ccfb2eb BS	16	const char *name;
	17	const char *format;
	18	void (call)(const struct syscallname ,
c16f9ed3 FB	19	abi_long, abi_long, abi_long,
c16f9ed3 FB	20	abi_long, abi_long, abi_long);
7ccfb2eb	21	void (result)(const struct syscallname , abi_long);
33189d31 TS	22	};
	23
	24	/*
	25	* Utility functions
	26	*/
	27	static void
	28	print_ipc_cmd(int cmd)
	29	{
	30	#define output_cmd(val) \
	31	if( cmd == val ) { \
	32	gemu_log(#val); \
	33	return; \
	34	}
	35
	36	cmd &= 0xff;
	37
	38	/* General IPC commands */
	39	output_cmd( IPC_RMID );
	40	output_cmd( IPC_SET );
	41	output_cmd( IPC_STAT );
	42	output_cmd( IPC_INFO );
	43	/* msgctl() commands */
	44	#ifdef __USER_MISC
	45	output_cmd( MSG_STAT );
	46	output_cmd( MSG_INFO );
	47	#endif
	48	/* shmctl() commands */
	49	output_cmd( SHM_LOCK );
	50	output_cmd( SHM_UNLOCK );
	51	output_cmd( SHM_STAT );
	52	output_cmd( SHM_INFO );
	53	/* semctl() commands */
	54	output_cmd( GETPID );
	55	output_cmd( GETVAL );
	56	output_cmd( GETALL );
	57	output_cmd( GETNCNT );
	58	output_cmd( GETZCNT );
	59	output_cmd( SETVAL );
	60	output_cmd( SETALL );
	61	output_cmd( SEM_STAT );
	62	output_cmd( SEM_INFO );
	63	output_cmd( IPC_RMID );
	64	output_cmd( IPC_RMID );
	65	output_cmd( IPC_RMID );
	66	output_cmd( IPC_RMID );
	67	output_cmd( IPC_RMID );
	68	output_cmd( IPC_RMID );
	69	output_cmd( IPC_RMID );
	70	output_cmd( IPC_RMID );
	71	output_cmd( IPC_RMID );
	72
	73	/* Some value we don't recognize */
	74	gemu_log("%d",cmd);
	75	}
	76
c16f9ed3	77	#ifdef TARGET_NR__newselect
33189d31	78	static void
c16f9ed3	79	print_fdset(int n, abi_ulong target_fds_addr)
33189d31 TS	80	{
	81	int i;
	82
	83	gemu_log("[");
	84	if( target_fds_addr ) {
579a97f7	85	abi_long *target_fds;
33189d31	86
579a97f7 FB	87	target_fds = lock_user(VERIFY_READ,
	88	target_fds_addr,
	89	sizeof(target_fds)(n / TARGET_ABI_BITS + 1),
	90	1);
	91
	92	if (!target_fds)
33189d31 TS	93	return;
33189d31 TS	94
33189d31	95	for (i=n; i>=0; i--) {
579a97f7	96	if ((tswapl(target_fds[i / TARGET_ABI_BITS]) >> (i & (TARGET_ABI_BITS - 1))) & 1)
33189d31 TS	97	gemu_log("%d,", i );
	98	}
	99	unlock_user(target_fds, target_fds_addr, 0);
	100	}
	101	gemu_log("]");
	102	}
	103
	104	static void
c16f9ed3	105	print_timeval(abi_ulong tv_addr)
33189d31 TS	106	{
	107	if( tv_addr ) {
	108	struct target_timeval *tv;
	109
579a97f7 FB	110	tv = lock_user(VERIFY_READ, tv_addr, sizeof(*tv), 1);
579a97f7 FB	111	if (!tv)
33189d31	112	return;
f3e3285d TS	113	gemu_log("{" TARGET_ABI_FMT_ld "," TARGET_ABI_FMT_ld "}",
f3e3285d TS	114	tv->tv_sec, tv->tv_usec);
33189d31 TS	115	unlock_user(tv, tv_addr, 0);
	116	} else
	117	gemu_log("NULL");
	118	}
c16f9ed3	119	#endif
33189d31 TS	120
	121	/*
	122	* Sysycall specific output functions
	123	*/
	124
	125	/* select */
c16f9ed3	126	#ifdef TARGET_NR__newselect
33189d31 TS	127	static long newselect_arg1 = 0;
	128	static long newselect_arg2 = 0;
	129	static long newselect_arg3 = 0;
	130	static long newselect_arg4 = 0;
	131	static long newselect_arg5 = 0;
	132
	133	static void
7ccfb2eb	134	print_newselect(const struct syscallname *name,
c16f9ed3 FB	135	abi_long arg1, abi_long arg2, abi_long arg3,
c16f9ed3 FB	136	abi_long arg4, abi_long arg5, abi_long arg6)
33189d31	137	{
c16f9ed3	138	gemu_log("%s(" TARGET_ABI_FMT_ld ",", name->name, arg1);
33189d31 TS	139	print_fdset(arg1, arg2);
	140	gemu_log(",");
	141	print_fdset(arg1, arg3);
	142	gemu_log(",");
	143	print_fdset(arg1, arg4);
	144	gemu_log(",");
	145	print_timeval(arg5);
	146	gemu_log(")");
	147
	148	/* save for use in the return output function below */
	149	newselect_arg1=arg1;
	150	newselect_arg2=arg2;
	151	newselect_arg3=arg3;
	152	newselect_arg4=arg4;
	153	newselect_arg5=arg5;
	154	}
c16f9ed3	155	#endif
33189d31	156
3e46b2ef	157	#ifdef TARGET_NR_semctl
33189d31	158	static void
7ccfb2eb	159	print_semctl(const struct syscallname *name,
c16f9ed3 FB	160	abi_long arg1, abi_long arg2, abi_long arg3,
c16f9ed3 FB	161	abi_long arg4, abi_long arg5, abi_long arg6)
33189d31	162	{
c16f9ed3	163	gemu_log("%s(" TARGET_ABI_FMT_ld "," TARGET_ABI_FMT_ld ",", name->name, arg1, arg2);
33189d31	164	print_ipc_cmd(arg3);
c16f9ed3	165	gemu_log(",0x" TARGET_ABI_FMT_lx ")", arg4);
33189d31	166	}
3e46b2ef	167	#endif
33189d31 TS	168
33189d31 TS	169	static void
7ccfb2eb	170	print_execve(const struct syscallname *name,
c16f9ed3 FB	171	abi_long arg1, abi_long arg2, abi_long arg3,
c16f9ed3 FB	172	abi_long arg4, abi_long arg5, abi_long arg6)
33189d31	173	{
c16f9ed3	174	abi_ulong arg_ptr_addr;
33189d31 TS	175	char *s;
33189d31 TS	176
579a97f7	177	if (!(s = lock_user_string(arg1)))
33189d31	178	return;
33189d31 TS	179	gemu_log("%s(\"%s\",{", name->name, s);
	180	unlock_user(s, arg1, 0);
	181
c16f9ed3	182	for (arg_ptr_addr = arg2; ; arg_ptr_addr += sizeof(abi_ulong)) {
98448f58	183	abi_ulong *arg_ptr, arg_addr;
33189d31	184
c16f9ed3	185	arg_ptr = lock_user(VERIFY_READ, arg_ptr_addr, sizeof(abi_ulong), 1);
579a97f7	186	if (!arg_ptr)
33189d31	187	return;
33189d31 TS	188	arg_addr = tswapl(*arg_ptr);
	189	unlock_user(arg_ptr, arg_ptr_addr, 0);
	190	if (!arg_addr)
	191	break;
579a97f7 FB	192	if ((s = lock_user_string(arg_addr))) {
579a97f7 FB	193	gemu_log("\"%s\",", s);
98448f58	194	unlock_user(s, arg_addr, 0);
579a97f7	195	}
33189d31 TS	196	}
	197
	198	gemu_log("NULL})");
	199	}
	200
c16f9ed3	201	#ifdef TARGET_NR_ipc
33189d31	202	static void
7ccfb2eb	203	print_ipc(const struct syscallname *name,
c16f9ed3 FB	204	abi_long arg1, abi_long arg2, abi_long arg3,
c16f9ed3 FB	205	abi_long arg4, abi_long arg5, abi_long arg6)
33189d31 TS	206	{
	207	switch(arg1) {
	208	case IPCOP_semctl:
7ccfb2eb BS	209	gemu_log("semctl(" TARGET_ABI_FMT_ld "," TARGET_ABI_FMT_ld ",", arg1, arg2);
	210	print_ipc_cmd(arg3);
	211	gemu_log(",0x" TARGET_ABI_FMT_lx ")", arg4);
33189d31 TS	212	break;
33189d31 TS	213	default:
c16f9ed3	214	gemu_log("%s(" TARGET_ABI_FMT_ld "," TARGET_ABI_FMT_ld "," TARGET_ABI_FMT_ld "," TARGET_ABI_FMT_ld ")",
33189d31 TS	215	name->name, arg1, arg2, arg3, arg4);
	216	}
	217	}
c16f9ed3	218	#endif
33189d31 TS	219
	220	/*
	221	* Variants for the return value output function
	222	*/
	223
	224	static void
7ccfb2eb	225	print_syscall_ret_addr(const struct syscallname *name, abi_long ret)
33189d31 TS	226	{
	227	if( ret == -1 ) {
	228	gemu_log(" = -1 errno=%d (%s)\n", errno, target_strerror(errno));
	229	} else {
29fa23e7	230	gemu_log(" = 0x" TARGET_ABI_FMT_lx "\n", ret);
33189d31 TS	231	}
	232	}
	233
f3e3285d	234	#if 0 /* currently unused */
33189d31	235	static void
c16f9ed3	236	print_syscall_ret_raw(struct syscallname *name, abi_long ret)
33189d31	237	{
29fa23e7	238	gemu_log(" = 0x" TARGET_ABI_FMT_lx "\n", ret);
33189d31	239	}
f3e3285d	240	#endif
33189d31	241
f3e3285d	242	#ifdef TARGET_NR__newselect
33189d31	243	static void
7ccfb2eb	244	print_syscall_ret_newselect(const struct syscallname *name, abi_long ret)
33189d31	245	{
29fa23e7	246	gemu_log(" = 0x" TARGET_ABI_FMT_lx " (", ret);
33189d31 TS	247	print_fdset(newselect_arg1,newselect_arg2);
	248	gemu_log(",");
	249	print_fdset(newselect_arg1,newselect_arg3);
	250	gemu_log(",");
	251	print_fdset(newselect_arg1,newselect_arg4);
	252	gemu_log(",");
	253	print_timeval(newselect_arg5);
	254	gemu_log(")\n");
	255	}
f3e3285d	256	#endif
33189d31 TS	257
	258	/*
	259	* An array of all of the syscalls we know about
	260	*/
	261
7ccfb2eb	262	static const struct syscallname scnames[] = {
33189d31 TS	263	#include "strace.list"
	264	};
	265
b1503cda	266	static int nsyscalls = ARRAY_SIZE(scnames);
33189d31 TS	267
	268	/*
	269	* The public interface to this module.
	270	*/
	271	void
	272	print_syscall(int num,
c16f9ed3 FB	273	abi_long arg1, abi_long arg2, abi_long arg3,
c16f9ed3 FB	274	abi_long arg4, abi_long arg5, abi_long arg6)
33189d31 TS	275	{
33189d31 TS	276	int i;
7ccfb2eb	277	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 ")";
33189d31 TS	278
	279	gemu_log("%d ", getpid() );
	280
	281	for(i=0;i<nsyscalls;i++)
	282	if( scnames[i].nr == num ) {
	283	if( scnames[i].call != NULL ) {
	284	scnames[i].call(&scnames[i],arg1,arg2,arg3,arg4,arg5,arg6);
	285	} else {
6b23f777 FB	286	/* XXX: this format system is broken because it uses
6b23f777 FB	287	host types and host pointers for strings */
33189d31 TS	288	if( scnames[i].format != NULL )
	289	format = scnames[i].format;
	290	gemu_log(format,scnames[i].name, arg1,arg2,arg3,arg4,arg5,arg6);
	291	}
74c11e55	292	return;
33189d31	293	}
74c11e55	294	gemu_log("Unknown syscall %d\n", num);
33189d31 TS	295	}
	296
	297
	298	void
c16f9ed3	299	print_syscall_ret(int num, abi_long ret)
33189d31 TS	300	{
	301	int i;
	302
	303	for(i=0;i<nsyscalls;i++)
	304	if( scnames[i].nr == num ) {
	305	if( scnames[i].result != NULL ) {
	306	scnames[i].result(&scnames[i],ret);
	307	} else {
	308	if( ret < 0 ) {
c16f9ed3	309	gemu_log(" = -1 errno=" TARGET_ABI_FMT_ld " (%s)\n", -ret, target_strerror(-ret));
33189d31	310	} else {
c16f9ed3	311	gemu_log(" = " TARGET_ABI_FMT_ld "\n", ret);
33189d31 TS	312	}
	313	}
	314	break;
	315	}
	316	}