[mirror_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

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);
}

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 = sizeof(scnames)/sizeof(struct syscallname);

/*
 * 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 TS	156
33189d31 TS	157	static void
7ccfb2eb	158	print_semctl(const struct syscallname *name,
c16f9ed3 FB	159	abi_long arg1, abi_long arg2, abi_long arg3,
c16f9ed3 FB	160	abi_long arg4, abi_long arg5, abi_long arg6)
33189d31	161	{
c16f9ed3	162	gemu_log("%s(" TARGET_ABI_FMT_ld "," TARGET_ABI_FMT_ld ",", name->name, arg1, arg2);
33189d31	163	print_ipc_cmd(arg3);
c16f9ed3	164	gemu_log(",0x" TARGET_ABI_FMT_lx ")", arg4);
33189d31 TS	165	}
	166
	167	static void
7ccfb2eb	168	print_execve(const struct syscallname *name,
c16f9ed3 FB	169	abi_long arg1, abi_long arg2, abi_long arg3,
c16f9ed3 FB	170	abi_long arg4, abi_long arg5, abi_long arg6)
33189d31	171	{
c16f9ed3	172	abi_ulong arg_ptr_addr;
33189d31 TS	173	char *s;
33189d31 TS	174
579a97f7	175	if (!(s = lock_user_string(arg1)))
33189d31	176	return;
33189d31 TS	177	gemu_log("%s(\"%s\",{", name->name, s);
	178	unlock_user(s, arg1, 0);
	179
c16f9ed3	180	for (arg_ptr_addr = arg2; ; arg_ptr_addr += sizeof(abi_ulong)) {
98448f58	181	abi_ulong *arg_ptr, arg_addr;
33189d31	182
c16f9ed3	183	arg_ptr = lock_user(VERIFY_READ, arg_ptr_addr, sizeof(abi_ulong), 1);
579a97f7	184	if (!arg_ptr)
33189d31	185	return;
33189d31 TS	186	arg_addr = tswapl(*arg_ptr);
	187	unlock_user(arg_ptr, arg_ptr_addr, 0);
	188	if (!arg_addr)
	189	break;
579a97f7 FB	190	if ((s = lock_user_string(arg_addr))) {
579a97f7 FB	191	gemu_log("\"%s\",", s);
98448f58	192	unlock_user(s, arg_addr, 0);
579a97f7	193	}
33189d31 TS	194	}
	195
	196	gemu_log("NULL})");
	197	}
	198
c16f9ed3	199	#ifdef TARGET_NR_ipc
33189d31	200	static void
7ccfb2eb	201	print_ipc(const struct syscallname *name,
c16f9ed3 FB	202	abi_long arg1, abi_long arg2, abi_long arg3,
c16f9ed3 FB	203	abi_long arg4, abi_long arg5, abi_long arg6)
33189d31 TS	204	{
	205	switch(arg1) {
	206	case IPCOP_semctl:
7ccfb2eb BS	207	gemu_log("semctl(" TARGET_ABI_FMT_ld "," TARGET_ABI_FMT_ld ",", arg1, arg2);
	208	print_ipc_cmd(arg3);
	209	gemu_log(",0x" TARGET_ABI_FMT_lx ")", arg4);
33189d31 TS	210	break;
33189d31 TS	211	default:
c16f9ed3	212	gemu_log("%s(" TARGET_ABI_FMT_ld "," TARGET_ABI_FMT_ld "," TARGET_ABI_FMT_ld "," TARGET_ABI_FMT_ld ")",
33189d31 TS	213	name->name, arg1, arg2, arg3, arg4);
	214	}
	215	}
c16f9ed3	216	#endif
33189d31 TS	217
	218	/*
	219	* Variants for the return value output function
	220	*/
	221
	222	static void
7ccfb2eb	223	print_syscall_ret_addr(const struct syscallname *name, abi_long ret)
33189d31 TS	224	{
	225	if( ret == -1 ) {
	226	gemu_log(" = -1 errno=%d (%s)\n", errno, target_strerror(errno));
	227	} else {
29fa23e7	228	gemu_log(" = 0x" TARGET_ABI_FMT_lx "\n", ret);
33189d31 TS	229	}
	230	}
	231
f3e3285d	232	#if 0 /* currently unused */
33189d31	233	static void
c16f9ed3	234	print_syscall_ret_raw(struct syscallname *name, abi_long ret)
33189d31	235	{
29fa23e7	236	gemu_log(" = 0x" TARGET_ABI_FMT_lx "\n", ret);
33189d31	237	}
f3e3285d	238	#endif
33189d31	239
f3e3285d	240	#ifdef TARGET_NR__newselect
33189d31	241	static void
7ccfb2eb	242	print_syscall_ret_newselect(const struct syscallname *name, abi_long ret)
33189d31	243	{
29fa23e7	244	gemu_log(" = 0x" TARGET_ABI_FMT_lx " (", ret);
33189d31 TS	245	print_fdset(newselect_arg1,newselect_arg2);
	246	gemu_log(",");
	247	print_fdset(newselect_arg1,newselect_arg3);
	248	gemu_log(",");
	249	print_fdset(newselect_arg1,newselect_arg4);
	250	gemu_log(",");
	251	print_timeval(newselect_arg5);
	252	gemu_log(")\n");
	253	}
f3e3285d	254	#endif
33189d31 TS	255
	256	/*
	257	* An array of all of the syscalls we know about
	258	*/
	259
7ccfb2eb	260	static const struct syscallname scnames[] = {
33189d31 TS	261	#include "strace.list"
	262	};
	263
	264	static int nsyscalls = sizeof(scnames)/sizeof(struct syscallname);
	265
	266	/*
	267	* The public interface to this module.
	268	*/
	269	void
	270	print_syscall(int num,
c16f9ed3 FB	271	abi_long arg1, abi_long arg2, abi_long arg3,
c16f9ed3 FB	272	abi_long arg4, abi_long arg5, abi_long arg6)
33189d31 TS	273	{
33189d31 TS	274	int i;
7ccfb2eb	275	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	276
	277	gemu_log("%d ", getpid() );
	278
	279	for(i=0;i<nsyscalls;i++)
	280	if( scnames[i].nr == num ) {
	281	if( scnames[i].call != NULL ) {
	282	scnames[i].call(&scnames[i],arg1,arg2,arg3,arg4,arg5,arg6);
	283	} else {
6b23f777 FB	284	/* XXX: this format system is broken because it uses
6b23f777 FB	285	host types and host pointers for strings */
33189d31 TS	286	if( scnames[i].format != NULL )
	287	format = scnames[i].format;
	288	gemu_log(format,scnames[i].name, arg1,arg2,arg3,arg4,arg5,arg6);
	289	}
74c11e55	290	return;
33189d31	291	}
74c11e55	292	gemu_log("Unknown syscall %d\n", num);
33189d31 TS	293	}
	294
	295
	296	void
c16f9ed3	297	print_syscall_ret(int num, abi_long ret)
33189d31 TS	298	{
	299	int i;
	300
	301	for(i=0;i<nsyscalls;i++)
	302	if( scnames[i].nr == num ) {
	303	if( scnames[i].result != NULL ) {
	304	scnames[i].result(&scnames[i],ret);
	305	} else {
	306	if( ret < 0 ) {
c16f9ed3	307	gemu_log(" = -1 errno=" TARGET_ABI_FMT_ld " (%s)\n", -ret, target_strerror(-ret));
33189d31	308	} else {
c16f9ed3	309	gemu_log(" = " TARGET_ABI_FMT_ld "\n", ret);
33189d31 TS	310	}
	311	}
	312	break;
	313	}
	314	}
	315