Index: syscall.c =================================================================== RCS file: /cvsroot/qemu/qemu/linux-user/syscall.c,v retrieving revision 1.64 diff -u -p -r1.64 syscall.c --- syscall.c 28 Nov 2005 22:28:41 -0000 1.64 +++ syscall.c 30 Nov 2005 01:22:39 -0000 @@ -457,7 +457,7 @@ static inline void target_to_host_cmsg(s space += CMSG_SPACE(len); if (space > msgh->msg_controllen) { space -= CMSG_SPACE(len); - gemu_log("Host cmsg overflow"); + gemu_log("Host cmsg overflow\n"); break; } @@ -500,7 +500,7 @@ static inline void host_to_target_cmsg(s space += TARGET_CMSG_SPACE(len); if (space > tswapl(target_msgh->msg_controllen)) { space -= TARGET_CMSG_SPACE(len); - gemu_log("Target cmsg overflow"); + gemu_log("Target cmsg overflow\n"); break; } @@ -1651,6 +1651,13 @@ void syscall_init(void) } } + +#ifdef DEBUG +#define CASE_SYSCALL(name) case name: if (num == name) gemu_log("(" #name ") "); +#else +#define CASE_SYSCALL(name) case name: +#endif + long do_syscall(void *cpu_env, int num, long arg1, long arg2, long arg3, long arg4, long arg5, long arg6) { @@ -1659,10 +1666,10 @@ long do_syscall(void *cpu_env, int num, struct statfs stfs; #ifdef DEBUG - gemu_log("syscall %d", num); + gemu_log("[pid=%d] syscall=%d ", getpid(), num); #endif switch(num) { - case TARGET_NR_exit: + CASE_SYSCALL(TARGET_NR_exit) #ifdef HAVE_GPROF _mcleanup(); #endif @@ -1671,28 +1678,28 @@ long do_syscall(void *cpu_env, int num, _exit(arg1); ret = 0; /* avoid warning */ break; - case TARGET_NR_read: + CASE_SYSCALL(TARGET_NR_read) page_unprotect_range((void *)arg2, arg3); ret = get_errno(read(arg1, (void *)arg2, arg3)); break; - case TARGET_NR_write: + CASE_SYSCALL(TARGET_NR_write) ret = get_errno(write(arg1, (void *)arg2, arg3)); break; - case TARGET_NR_open: + CASE_SYSCALL(TARGET_NR_open) ret = get_errno(open(path((const char *)arg1), target_to_host_bitmask(arg2, fcntl_flags_tbl), arg3)); break; - case TARGET_NR_close: + CASE_SYSCALL(TARGET_NR_close) ret = get_errno(close(arg1)); break; - case TARGET_NR_brk: + CASE_SYSCALL(TARGET_NR_brk) ret = do_brk((char *)arg1); break; - case TARGET_NR_fork: + CASE_SYSCALL(TARGET_NR_fork) ret = get_errno(do_fork(cpu_env, SIGCHLD, 0)); break; - case TARGET_NR_waitpid: + CASE_SYSCALL(TARGET_NR_waitpid) { int *status = (int *)arg2; ret = get_errno(waitpid(arg1, status, arg3)); @@ -1700,16 +1707,16 @@ long do_syscall(void *cpu_env, int num, tswapls((long *)&status); } break; - case TARGET_NR_creat: + CASE_SYSCALL(TARGET_NR_creat) ret = get_errno(creat((const char *)arg1, arg2)); break; - case TARGET_NR_link: + CASE_SYSCALL(TARGET_NR_link) ret = get_errno(link((const char *)arg1, (const char *)arg2)); break; - case TARGET_NR_unlink: + CASE_SYSCALL(TARGET_NR_unlink) ret = get_errno(unlink((const char *)arg1)); break; - case TARGET_NR_execve: + CASE_SYSCALL(TARGET_NR_execve) { char **argp, **envp; int argc, envc; @@ -1737,11 +1744,11 @@ long do_syscall(void *cpu_env, int num, ret = get_errno(execve((const char *)arg1, argp, envp)); } break; - case TARGET_NR_chdir: + CASE_SYSCALL(TARGET_NR_chdir) ret = get_errno(chdir((const char *)arg1)); break; #ifdef TARGET_NR_time - case TARGET_NR_time: + CASE_SYSCALL(TARGET_NR_time) { int *time_ptr = (int *)arg1; ret = get_errno(time((time_t *)time_ptr)); @@ -1750,33 +1757,33 @@ long do_syscall(void *cpu_env, int num, } break; #endif - case TARGET_NR_mknod: + CASE_SYSCALL(TARGET_NR_mknod) ret = get_errno(mknod((const char *)arg1, arg2, arg3)); break; - case TARGET_NR_chmod: + CASE_SYSCALL(TARGET_NR_chmod) ret = get_errno(chmod((const char *)arg1, arg2)); break; #ifdef TARGET_NR_break - case TARGET_NR_break: + CASE_SYSCALL(TARGET_NR_break) goto unimplemented; #endif #ifdef TARGET_NR_oldstat - case TARGET_NR_oldstat: + CASE_SYSCALL(TARGET_NR_oldstat) goto unimplemented; #endif - case TARGET_NR_lseek: + CASE_SYSCALL(TARGET_NR_lseek) ret = get_errno(lseek(arg1, arg2, arg3)); break; - case TARGET_NR_getpid: + CASE_SYSCALL(TARGET_NR_getpid) ret = get_errno(getpid()); break; - case TARGET_NR_mount: + CASE_SYSCALL(TARGET_NR_mount) /* need to look at the data field */ goto unimplemented; - case TARGET_NR_umount: + CASE_SYSCALL(TARGET_NR_umount) ret = get_errno(umount((const char *)arg1)); break; - case TARGET_NR_stime: + CASE_SYSCALL(TARGET_NR_stime) { int *time_ptr = (int *)arg1; if (time_ptr) @@ -1784,19 +1791,19 @@ long do_syscall(void *cpu_env, int num, ret = get_errno(stime((time_t *)time_ptr)); } break; - case TARGET_NR_ptrace: + CASE_SYSCALL(TARGET_NR_ptrace) goto unimplemented; - case TARGET_NR_alarm: + CASE_SYSCALL(TARGET_NR_alarm) ret = alarm(arg1); break; #ifdef TARGET_NR_oldfstat - case TARGET_NR_oldfstat: + CASE_SYSCALL(TARGET_NR_oldfstat) goto unimplemented; #endif - case TARGET_NR_pause: + CASE_SYSCALL(TARGET_NR_pause) ret = get_errno(pause()); break; - case TARGET_NR_utime: + CASE_SYSCALL(TARGET_NR_utime) { struct utimbuf tbuf, *tbuf1; struct target_utimbuf *target_tbuf = (void *)arg2; @@ -1810,7 +1817,7 @@ long do_syscall(void *cpu_env, int num, ret = get_errno(utime((const char *)arg1, tbuf1)); } break; - case TARGET_NR_utimes: + CASE_SYSCALL(TARGET_NR_utimes) { struct target_timeval *target_tvp = (struct target_timeval *)arg2; struct timeval *tvp, tv[2]; @@ -1825,43 +1832,43 @@ long do_syscall(void *cpu_env, int num, } break; #ifdef TARGET_NR_stty - case TARGET_NR_stty: + CASE_SYSCALL(TARGET_NR_stty) goto unimplemented; #endif #ifdef TARGET_NR_gtty - case TARGET_NR_gtty: + CASE_SYSCALL(TARGET_NR_gtty) goto unimplemented; #endif - case TARGET_NR_access: + CASE_SYSCALL(TARGET_NR_access) ret = get_errno(access((const char *)arg1, arg2)); break; - case TARGET_NR_nice: + CASE_SYSCALL(TARGET_NR_nice) ret = get_errno(nice(arg1)); break; #ifdef TARGET_NR_ftime - case TARGET_NR_ftime: + CASE_SYSCALL(TARGET_NR_ftime) goto unimplemented; #endif - case TARGET_NR_sync: + CASE_SYSCALL(TARGET_NR_sync) sync(); ret = 0; break; - case TARGET_NR_kill: + CASE_SYSCALL(TARGET_NR_kill) ret = get_errno(kill(arg1, arg2)); break; - case TARGET_NR_rename: + CASE_SYSCALL(TARGET_NR_rename) ret = get_errno(rename((const char *)arg1, (const char *)arg2)); break; - case TARGET_NR_mkdir: + CASE_SYSCALL(TARGET_NR_mkdir) ret = get_errno(mkdir((const char *)arg1, arg2)); break; - case TARGET_NR_rmdir: + CASE_SYSCALL(TARGET_NR_rmdir) ret = get_errno(rmdir((const char *)arg1)); break; - case TARGET_NR_dup: + CASE_SYSCALL(TARGET_NR_dup) ret = get_errno(dup(arg1)); break; - case TARGET_NR_pipe: + CASE_SYSCALL(TARGET_NR_pipe) { int *pipe_ptr = (int *)arg1; ret = get_errno(pipe(pipe_ptr)); @@ -1871,7 +1878,7 @@ long do_syscall(void *cpu_env, int num, } } break; - case TARGET_NR_times: + CASE_SYSCALL(TARGET_NR_times) { struct target_tms *tmsp = (void *)arg1; struct tms tms; @@ -1887,63 +1894,63 @@ long do_syscall(void *cpu_env, int num, } break; #ifdef TARGET_NR_prof - case TARGET_NR_prof: + CASE_SYSCALL(TARGET_NR_prof) goto unimplemented; #endif - case TARGET_NR_signal: + CASE_SYSCALL(TARGET_NR_signal) goto unimplemented; - case TARGET_NR_acct: + CASE_SYSCALL(TARGET_NR_acct) goto unimplemented; - case TARGET_NR_umount2: + CASE_SYSCALL(TARGET_NR_umount2) ret = get_errno(umount2((const char *)arg1, arg2)); break; #ifdef TARGET_NR_lock - case TARGET_NR_lock: + CASE_SYSCALL(TARGET_NR_lock) goto unimplemented; #endif - case TARGET_NR_ioctl: + CASE_SYSCALL(TARGET_NR_ioctl) ret = do_ioctl(arg1, arg2, arg3); break; - case TARGET_NR_fcntl: + CASE_SYSCALL(TARGET_NR_fcntl) ret = get_errno(do_fcntl(arg1, arg2, arg3)); break; #ifdef TARGET_NR_mpx - case TARGET_NR_mpx: + CASE_SYSCALL(TARGET_NR_mpx) goto unimplemented; #endif - case TARGET_NR_setpgid: + CASE_SYSCALL(TARGET_NR_setpgid) ret = get_errno(setpgid(arg1, arg2)); break; #ifdef TARGET_NR_ulimit - case TARGET_NR_ulimit: + CASE_SYSCALL(TARGET_NR_ulimit) goto unimplemented; #endif #ifdef TARGET_NR_oldolduname - case TARGET_NR_oldolduname: + CASE_SYSCALL(TARGET_NR_oldolduname) goto unimplemented; #endif - case TARGET_NR_umask: + CASE_SYSCALL(TARGET_NR_umask) ret = get_errno(umask(arg1)); break; - case TARGET_NR_chroot: + CASE_SYSCALL(TARGET_NR_chroot) ret = get_errno(chroot((const char *)arg1)); break; - case TARGET_NR_ustat: + CASE_SYSCALL(TARGET_NR_ustat) goto unimplemented; - case TARGET_NR_dup2: + CASE_SYSCALL(TARGET_NR_dup2) ret = get_errno(dup2(arg1, arg2)); break; - case TARGET_NR_getppid: + CASE_SYSCALL(TARGET_NR_getppid) ret = get_errno(getppid()); break; - case TARGET_NR_getpgrp: + CASE_SYSCALL(TARGET_NR_getpgrp) ret = get_errno(getpgrp()); break; - case TARGET_NR_setsid: + CASE_SYSCALL(TARGET_NR_setsid) ret = get_errno(setsid()); break; - case TARGET_NR_sigaction: + CASE_SYSCALL(TARGET_NR_sigaction) { struct target_old_sigaction *old_act = (void *)arg2; struct target_old_sigaction *old_oact = (void *)arg3; @@ -1966,10 +1973,10 @@ long do_syscall(void *cpu_env, int num, } } break; - case TARGET_NR_rt_sigaction: + CASE_SYSCALL(TARGET_NR_rt_sigaction) ret = get_errno(do_sigaction(arg1, (void *)arg2, (void *)arg3)); break; - case TARGET_NR_sgetmask: + CASE_SYSCALL(TARGET_NR_sgetmask) { sigset_t cur_set; target_ulong target_set; @@ -1978,7 +1985,7 @@ long do_syscall(void *cpu_env, int num, ret = target_set; } break; - case TARGET_NR_ssetmask: + CASE_SYSCALL(TARGET_NR_ssetmask) { sigset_t set, oset, cur_set; target_ulong target_set = arg1; @@ -1990,7 +1997,7 @@ long do_syscall(void *cpu_env, int num, ret = target_set; } break; - case TARGET_NR_sigprocmask: + CASE_SYSCALL(TARGET_NR_sigprocmask) { int how = arg1; sigset_t set, oldset, *set_ptr; @@ -2023,7 +2030,7 @@ long do_syscall(void *cpu_env, int num, } } break; - case TARGET_NR_rt_sigprocmask: + CASE_SYSCALL(TARGET_NR_rt_sigprocmask) { int how = arg1; sigset_t set, oldset, *set_ptr; @@ -2057,7 +2064,7 @@ long do_syscall(void *cpu_env, int num, } } break; - case TARGET_NR_sigpending: + CASE_SYSCALL(TARGET_NR_sigpending) { sigset_t set; ret = get_errno(sigpending(&set)); @@ -2066,7 +2073,7 @@ long do_syscall(void *cpu_env, int num, } } break; - case TARGET_NR_rt_sigpending: + CASE_SYSCALL(TARGET_NR_rt_sigpending) { sigset_t set; ret = get_errno(sigpending(&set)); @@ -2075,21 +2082,21 @@ long do_syscall(void *cpu_env, int num, } } break; - case TARGET_NR_sigsuspend: + CASE_SYSCALL(TARGET_NR_sigsuspend) { sigset_t set; target_to_host_old_sigset(&set, (target_ulong *)arg1); ret = get_errno(sigsuspend(&set)); } break; - case TARGET_NR_rt_sigsuspend: + CASE_SYSCALL(TARGET_NR_rt_sigsuspend) { sigset_t set; target_to_host_sigset(&set, (target_sigset_t *)arg1); ret = get_errno(sigsuspend(&set)); } break; - case TARGET_NR_rt_sigtimedwait: + CASE_SYSCALL(TARGET_NR_rt_sigtimedwait) { target_sigset_t *target_set = (void *)arg1; target_siginfo_t *target_uinfo = (void *)arg2; @@ -2112,25 +2119,25 @@ long do_syscall(void *cpu_env, int num, } } break; - case TARGET_NR_rt_sigqueueinfo: + CASE_SYSCALL(TARGET_NR_rt_sigqueueinfo) { siginfo_t uinfo; target_to_host_siginfo(&uinfo, (target_siginfo_t *)arg3); ret = get_errno(sys_rt_sigqueueinfo(arg1, arg2, &uinfo)); } break; - case TARGET_NR_sigreturn: + CASE_SYSCALL(TARGET_NR_sigreturn) /* NOTE: ret is eax, so not transcoding must be done */ ret = do_sigreturn(cpu_env); break; - case TARGET_NR_rt_sigreturn: + CASE_SYSCALL(TARGET_NR_rt_sigreturn) /* NOTE: ret is eax, so not transcoding must be done */ ret = do_rt_sigreturn(cpu_env); break; - case TARGET_NR_sethostname: + CASE_SYSCALL(TARGET_NR_sethostname) ret = get_errno(sethostname((const char *)arg1, arg2)); break; - case TARGET_NR_setrlimit: + CASE_SYSCALL(TARGET_NR_setrlimit) { /* XXX: convert resource ? */ int resource = arg1; @@ -2141,7 +2148,7 @@ long do_syscall(void *cpu_env, int num, ret = get_errno(setrlimit(resource, &rlim)); } break; - case TARGET_NR_getrlimit: + CASE_SYSCALL(TARGET_NR_getrlimit) { /* XXX: convert resource ? */ int resource = arg1; @@ -2155,7 +2162,7 @@ long do_syscall(void *cpu_env, int num, } } break; - case TARGET_NR_getrusage: + CASE_SYSCALL(TARGET_NR_getrusage) { struct rusage rusage; struct target_rusage *target_rusage = (void *)arg2; @@ -2165,7 +2172,7 @@ long do_syscall(void *cpu_env, int num, } } break; - case TARGET_NR_gettimeofday: + CASE_SYSCALL(TARGET_NR_gettimeofday) { struct target_timeval *target_tv = (void *)arg1; struct timeval tv; @@ -2175,7 +2182,7 @@ long do_syscall(void *cpu_env, int num, } } break; - case TARGET_NR_settimeofday: + CASE_SYSCALL(TARGET_NR_settimeofday) { struct target_timeval *target_tv = (void *)arg1; struct timeval tv; @@ -2184,7 +2191,7 @@ long do_syscall(void *cpu_env, int num, } break; #ifdef TARGET_NR_select - case TARGET_NR_select: + CASE_SYSCALL(TARGET_NR_select) { struct target_sel_arg_struct *sel = (void *)arg1; sel->n = tswapl(sel->n); @@ -2197,26 +2204,26 @@ long do_syscall(void *cpu_env, int num, } break; #endif - case TARGET_NR_symlink: + CASE_SYSCALL(TARGET_NR_symlink) ret = get_errno(symlink((const char *)arg1, (const char *)arg2)); break; #ifdef TARGET_NR_oldlstat - case TARGET_NR_oldlstat: + CASE_SYSCALL(TARGET_NR_oldlstat) goto unimplemented; #endif - case TARGET_NR_readlink: + CASE_SYSCALL(TARGET_NR_readlink) ret = get_errno(readlink(path((const char *)arg1), (char *)arg2, arg3)); break; - case TARGET_NR_uselib: + CASE_SYSCALL(TARGET_NR_uselib) goto unimplemented; - case TARGET_NR_swapon: + CASE_SYSCALL(TARGET_NR_swapon) ret = get_errno(swapon((const char *)arg1, arg2)); break; - case TARGET_NR_reboot: + CASE_SYSCALL(TARGET_NR_reboot) goto unimplemented; - case TARGET_NR_readdir: + CASE_SYSCALL(TARGET_NR_readdir) goto unimplemented; - case TARGET_NR_mmap: + CASE_SYSCALL(TARGET_NR_mmap) #if defined(TARGET_I386) || defined(TARGET_ARM) { uint32_t v1, v2, v3, v4, v5, v6, *vptr; @@ -2239,7 +2246,7 @@ long do_syscall(void *cpu_env, int num, #endif break; #ifdef TARGET_NR_mmap2 - case TARGET_NR_mmap2: + CASE_SYSCALL(TARGET_NR_mmap2) #if defined(TARGET_SPARC) #define MMAP_SHIFT 12 #else @@ -2251,50 +2258,50 @@ long do_syscall(void *cpu_env, int num, arg6 << MMAP_SHIFT)); break; #endif - case TARGET_NR_munmap: + CASE_SYSCALL(TARGET_NR_munmap) ret = get_errno(target_munmap(arg1, arg2)); break; - case TARGET_NR_mprotect: + CASE_SYSCALL(TARGET_NR_mprotect) ret = get_errno(target_mprotect(arg1, arg2, arg3)); break; - case TARGET_NR_mremap: + CASE_SYSCALL(TARGET_NR_mremap) ret = get_errno(target_mremap(arg1, arg2, arg3, arg4, arg5)); break; - case TARGET_NR_msync: + CASE_SYSCALL(TARGET_NR_msync) ret = get_errno(msync((void *)arg1, arg2, arg3)); break; - case TARGET_NR_mlock: + CASE_SYSCALL(TARGET_NR_mlock) ret = get_errno(mlock((void *)arg1, arg2)); break; - case TARGET_NR_munlock: + CASE_SYSCALL(TARGET_NR_munlock) ret = get_errno(munlock((void *)arg1, arg2)); break; - case TARGET_NR_mlockall: + CASE_SYSCALL(TARGET_NR_mlockall) ret = get_errno(mlockall(arg1)); break; - case TARGET_NR_munlockall: + CASE_SYSCALL(TARGET_NR_munlockall) ret = get_errno(munlockall()); break; - case TARGET_NR_truncate: + CASE_SYSCALL(TARGET_NR_truncate) ret = get_errno(truncate((const char *)arg1, arg2)); break; - case TARGET_NR_ftruncate: + CASE_SYSCALL(TARGET_NR_ftruncate) ret = get_errno(ftruncate(arg1, arg2)); break; - case TARGET_NR_fchmod: + CASE_SYSCALL(TARGET_NR_fchmod) ret = get_errno(fchmod(arg1, arg2)); break; - case TARGET_NR_getpriority: + CASE_SYSCALL(TARGET_NR_getpriority) ret = get_errno(getpriority(arg1, arg2)); break; - case TARGET_NR_setpriority: + CASE_SYSCALL(TARGET_NR_setpriority) ret = get_errno(setpriority(arg1, arg2, arg3)); break; #ifdef TARGET_NR_profil - case TARGET_NR_profil: + CASE_SYSCALL(TARGET_NR_profil) goto unimplemented; #endif - case TARGET_NR_statfs: + CASE_SYSCALL(TARGET_NR_statfs) ret = get_errno(statfs(path((const char *)arg1), &stfs)); convert_statfs: if (!is_error(ret)) { @@ -2311,11 +2318,11 @@ long do_syscall(void *cpu_env, int num, put_user(stfs.f_namelen, &target_stfs->f_namelen); } break; - case TARGET_NR_fstatfs: + CASE_SYSCALL(TARGET_NR_fstatfs) ret = get_errno(fstatfs(arg1, &stfs)); goto convert_statfs; #ifdef TARGET_NR_statfs64 - case TARGET_NR_statfs64: + CASE_SYSCALL(TARGET_NR_statfs64) ret = get_errno(statfs(path((const char *)arg1), &stfs)); convert_statfs64: if (!is_error(ret)) { @@ -2332,20 +2339,20 @@ long do_syscall(void *cpu_env, int num, put_user(stfs.f_namelen, &target_stfs->f_namelen); } break; - case TARGET_NR_fstatfs64: + CASE_SYSCALL(TARGET_NR_fstatfs64) ret = get_errno(fstatfs(arg1, &stfs)); goto convert_statfs64; #endif #ifdef TARGET_NR_ioperm - case TARGET_NR_ioperm: + CASE_SYSCALL(TARGET_NR_ioperm) goto unimplemented; #endif - case TARGET_NR_socketcall: + CASE_SYSCALL(TARGET_NR_socketcall) ret = do_socketcall(arg1, (int32_t *)arg2); break; - case TARGET_NR_syslog: + CASE_SYSCALL(TARGET_NR_syslog) goto unimplemented; - case TARGET_NR_setitimer: + CASE_SYSCALL(TARGET_NR_setitimer) { struct target_itimerval *target_value = (void *)arg2; struct target_itimerval *target_ovalue = (void *)arg3; @@ -2369,7 +2376,7 @@ long do_syscall(void *cpu_env, int num, } } break; - case TARGET_NR_getitimer: + CASE_SYSCALL(TARGET_NR_getitimer) { struct target_itimerval *target_value = (void *)arg2; struct itimerval value; @@ -2383,13 +2390,13 @@ long do_syscall(void *cpu_env, int num, } } break; - case TARGET_NR_stat: + CASE_SYSCALL(TARGET_NR_stat) ret = get_errno(stat(path((const char *)arg1), &st)); goto do_stat; - case TARGET_NR_lstat: + CASE_SYSCALL(TARGET_NR_lstat) ret = get_errno(lstat(path((const char *)arg1), &st)); goto do_stat; - case TARGET_NR_fstat: + CASE_SYSCALL(TARGET_NR_fstat) { ret = get_errno(fstat(arg1, &st)); do_stat: @@ -2418,26 +2425,26 @@ long do_syscall(void *cpu_env, int num, } break; #ifdef TARGET_NR_olduname - case TARGET_NR_olduname: + CASE_SYSCALL(TARGET_NR_olduname) goto unimplemented; #endif #ifdef TARGET_NR_iopl - case TARGET_NR_iopl: + CASE_SYSCALL(TARGET_NR_iopl) goto unimplemented; #endif - case TARGET_NR_vhangup: + CASE_SYSCALL(TARGET_NR_vhangup) ret = get_errno(vhangup()); break; #ifdef TARGET_NR_idle - case TARGET_NR_idle: + CASE_SYSCALL(TARGET_NR_idle) goto unimplemented; #endif #ifdef TARGET_NR_syscall - case TARGET_NR_syscall: + CASE_SYSCALL(TARGET_NR_syscall) ret = do_syscall(cpu_env,arg1 & 0xffff,arg2,arg3,arg4,arg5,arg6,0); break; #endif - case TARGET_NR_wait4: + CASE_SYSCALL(TARGET_NR_wait4) { int status; target_long *status_ptr = (void *)arg2; @@ -2457,10 +2464,10 @@ long do_syscall(void *cpu_env, int num, } } break; - case TARGET_NR_swapoff: + CASE_SYSCALL(TARGET_NR_swapoff) ret = get_errno(swapoff((const char *)arg1)); break; - case TARGET_NR_sysinfo: + CASE_SYSCALL(TARGET_NR_sysinfo) { struct target_sysinfo *target_value = (void *)arg1; struct sysinfo value; @@ -2484,26 +2491,26 @@ long do_syscall(void *cpu_env, int num, } } break; - case TARGET_NR_ipc: + CASE_SYSCALL(TARGET_NR_ipc) ret = do_ipc(arg1, arg2, arg3, arg4, arg5, arg6); break; - case TARGET_NR_fsync: + CASE_SYSCALL(TARGET_NR_fsync) ret = get_errno(fsync(arg1)); break; - case TARGET_NR_clone: + CASE_SYSCALL(TARGET_NR_clone) ret = get_errno(do_fork(cpu_env, arg1, arg2)); break; #ifdef __NR_exit_group /* new thread calls */ - case TARGET_NR_exit_group: + CASE_SYSCALL(TARGET_NR_exit_group) gdb_exit(cpu_env, arg1); ret = get_errno(exit_group(arg1)); break; #endif - case TARGET_NR_setdomainname: + CASE_SYSCALL(TARGET_NR_setdomainname) ret = get_errno(setdomainname((const char *)arg1, arg2)); break; - case TARGET_NR_uname: + CASE_SYSCALL(TARGET_NR_uname) /* no need to transcode because we use the linux syscall */ { struct new_utsname * buf; @@ -2518,40 +2525,40 @@ long do_syscall(void *cpu_env, int num, } break; #ifdef TARGET_I386 - case TARGET_NR_modify_ldt: + CASE_SYSCALL(TARGET_NR_modify_ldt) ret = get_errno(do_modify_ldt(cpu_env, arg1, (void *)arg2, arg3)); break; - case TARGET_NR_vm86old: + CASE_SYSCALL(TARGET_NR_vm86old) goto unimplemented; - case TARGET_NR_vm86: + CASE_SYSCALL(TARGET_NR_vm86) ret = do_vm86(cpu_env, arg1, (void *)arg2); break; #endif - case TARGET_NR_adjtimex: + CASE_SYSCALL(TARGET_NR_adjtimex) goto unimplemented; - case TARGET_NR_create_module: - case TARGET_NR_init_module: - case TARGET_NR_delete_module: - case TARGET_NR_get_kernel_syms: + CASE_SYSCALL(TARGET_NR_create_module) + CASE_SYSCALL(TARGET_NR_init_module) + CASE_SYSCALL(TARGET_NR_delete_module) + CASE_SYSCALL(TARGET_NR_get_kernel_syms) goto unimplemented; - case TARGET_NR_quotactl: + CASE_SYSCALL(TARGET_NR_quotactl) goto unimplemented; - case TARGET_NR_getpgid: + CASE_SYSCALL(TARGET_NR_getpgid) ret = get_errno(getpgid(arg1)); break; - case TARGET_NR_fchdir: + CASE_SYSCALL(TARGET_NR_fchdir) ret = get_errno(fchdir(arg1)); break; - case TARGET_NR_bdflush: + CASE_SYSCALL(TARGET_NR_bdflush) goto unimplemented; - case TARGET_NR_sysfs: + CASE_SYSCALL(TARGET_NR_sysfs) goto unimplemented; - case TARGET_NR_personality: + CASE_SYSCALL(TARGET_NR_personality) ret = get_errno(personality(arg1)); break; - case TARGET_NR_afs_syscall: + CASE_SYSCALL(TARGET_NR_afs_syscall) goto unimplemented; - case TARGET_NR__llseek: + CASE_SYSCALL(TARGET_NR__llseek) { #if defined (__x86_64__) ret = get_errno(lseek(arg1, ((uint64_t )arg2 << 32) | arg3, arg5)); @@ -2563,7 +2570,7 @@ long do_syscall(void *cpu_env, int num, #endif } break; - case TARGET_NR_getdents: + CASE_SYSCALL(TARGET_NR_getdents) #if TARGET_LONG_SIZE != 4 #warning not supported #elif TARGET_LONG_SIZE == 4 && HOST_LONG_SIZE == 8 @@ -2633,7 +2640,7 @@ long do_syscall(void *cpu_env, int num, #endif break; #ifdef TARGET_NR_getdents64 - case TARGET_NR_getdents64: + CASE_SYSCALL(TARGET_NR_getdents64) { struct dirent64 *dirp = (void *)arg2; long count = arg3; @@ -2657,11 +2664,11 @@ long do_syscall(void *cpu_env, int num, } break; #endif /* TARGET_NR_getdents64 */ - case TARGET_NR__newselect: + CASE_SYSCALL(TARGET_NR__newselect) ret = do_select(arg1, (void *)arg2, (void *)arg3, (void *)arg4, (void *)arg5); break; - case TARGET_NR_poll: + CASE_SYSCALL(TARGET_NR_poll) { struct target_pollfd *target_pfd = (void *)arg1; unsigned int nfds = arg2; @@ -2682,12 +2689,12 @@ long do_syscall(void *cpu_env, int num, } } break; - case TARGET_NR_flock: + CASE_SYSCALL(TARGET_NR_flock) /* NOTE: the flock constant seems to be the same for every Linux platform */ ret = get_errno(flock(arg1, arg2)); break; - case TARGET_NR_readv: + CASE_SYSCALL(TARGET_NR_readv) { int count = arg3; int i; @@ -2702,7 +2709,7 @@ long do_syscall(void *cpu_env, int num, ret = get_errno(readv(arg1, vec, count)); } break; - case TARGET_NR_writev: + CASE_SYSCALL(TARGET_NR_writev) { int count = arg3; int i; @@ -2717,17 +2724,17 @@ long do_syscall(void *cpu_env, int num, ret = get_errno(writev(arg1, vec, count)); } break; - case TARGET_NR_getsid: + CASE_SYSCALL(TARGET_NR_getsid) ret = get_errno(getsid(arg1)); break; - case TARGET_NR_fdatasync: + CASE_SYSCALL(TARGET_NR_fdatasync) ret = get_errno(fdatasync(arg1)); break; - case TARGET_NR__sysctl: + CASE_SYSCALL(TARGET_NR__sysctl) /* We don't implement this, but ENODIR is always a safe return value. */ return -ENOTDIR; - case TARGET_NR_sched_setparam: + CASE_SYSCALL(TARGET_NR_sched_setparam) { struct sched_param *target_schp = (void *)arg2; struct sched_param schp; @@ -2735,7 +2742,7 @@ long do_syscall(void *cpu_env, int num, ret = get_errno(sched_setparam(arg1, &schp)); } break; - case TARGET_NR_sched_getparam: + CASE_SYSCALL(TARGET_NR_sched_getparam) { struct sched_param *target_schp = (void *)arg2; struct sched_param schp; @@ -2745,7 +2752,7 @@ long do_syscall(void *cpu_env, int num, } } break; - case TARGET_NR_sched_setscheduler: + CASE_SYSCALL(TARGET_NR_sched_setscheduler) { struct sched_param *target_schp = (void *)arg3; struct sched_param schp; @@ -2753,19 +2760,19 @@ long do_syscall(void *cpu_env, int num, ret = get_errno(sched_setscheduler(arg1, arg2, &schp)); } break; - case TARGET_NR_sched_getscheduler: + CASE_SYSCALL(TARGET_NR_sched_getscheduler) ret = get_errno(sched_getscheduler(arg1)); break; - case TARGET_NR_sched_yield: + CASE_SYSCALL(TARGET_NR_sched_yield) ret = get_errno(sched_yield()); break; - case TARGET_NR_sched_get_priority_max: + CASE_SYSCALL(TARGET_NR_sched_get_priority_max) ret = get_errno(sched_get_priority_max(arg1)); break; - case TARGET_NR_sched_get_priority_min: + CASE_SYSCALL(TARGET_NR_sched_get_priority_min) ret = get_errno(sched_get_priority_min(arg1)); break; - case TARGET_NR_sched_rr_get_interval: + CASE_SYSCALL(TARGET_NR_sched_rr_get_interval) { struct target_timespec *target_ts = (void *)arg2; struct timespec ts; @@ -2776,7 +2783,7 @@ long do_syscall(void *cpu_env, int num, } } break; - case TARGET_NR_nanosleep: + CASE_SYSCALL(TARGET_NR_nanosleep) { struct target_timespec *target_req = (void *)arg1; struct target_timespec *target_rem = (void *)arg2; @@ -2790,47 +2797,47 @@ long do_syscall(void *cpu_env, int num, } } break; - case TARGET_NR_query_module: + CASE_SYSCALL(TARGET_NR_query_module) goto unimplemented; - case TARGET_NR_nfsservctl: + CASE_SYSCALL(TARGET_NR_nfsservctl) goto unimplemented; - case TARGET_NR_prctl: + CASE_SYSCALL(TARGET_NR_prctl) goto unimplemented; #ifdef TARGET_NR_pread - case TARGET_NR_pread: + CASE_SYSCALL(TARGET_NR_pread) page_unprotect_range((void *)arg2, arg3); ret = get_errno(pread(arg1, (void *)arg2, arg3, arg4)); break; - case TARGET_NR_pwrite: + CASE_SYSCALL(TARGET_NR_pwrite) ret = get_errno(pwrite(arg1, (void *)arg2, arg3, arg4)); break; #endif - case TARGET_NR_getcwd: + CASE_SYSCALL(TARGET_NR_getcwd) ret = get_errno(sys_getcwd1((char *)arg1, arg2)); break; - case TARGET_NR_capget: + CASE_SYSCALL(TARGET_NR_capget) goto unimplemented; - case TARGET_NR_capset: + CASE_SYSCALL(TARGET_NR_capset) goto unimplemented; - case TARGET_NR_sigaltstack: + CASE_SYSCALL(TARGET_NR_sigaltstack) goto unimplemented; - case TARGET_NR_sendfile: + CASE_SYSCALL(TARGET_NR_sendfile) goto unimplemented; #ifdef TARGET_NR_getpmsg - case TARGET_NR_getpmsg: + CASE_SYSCALL(TARGET_NR_getpmsg) goto unimplemented; #endif #ifdef TARGET_NR_putpmsg - case TARGET_NR_putpmsg: + CASE_SYSCALL(TARGET_NR_putpmsg) goto unimplemented; #endif #ifdef TARGET_NR_vfork - case TARGET_NR_vfork: + CASE_SYSCALL(TARGET_NR_vfork) ret = get_errno(do_fork(cpu_env, CLONE_VFORK | CLONE_VM | SIGCHLD, 0)); break; #endif #ifdef TARGET_NR_ugetrlimit - case TARGET_NR_ugetrlimit: + CASE_SYSCALL(TARGET_NR_ugetrlimit) { struct rlimit rlim; ret = get_errno(getrlimit(arg1, &rlim)); @@ -2843,27 +2850,27 @@ long do_syscall(void *cpu_env, int num, } #endif #ifdef TARGET_NR_truncate64 - case TARGET_NR_truncate64: + CASE_SYSCALL(TARGET_NR_truncate64) ret = get_errno(truncate64((const char *)arg1, arg2)); break; #endif #ifdef TARGET_NR_ftruncate64 - case TARGET_NR_ftruncate64: + CASE_SYSCALL(TARGET_NR_ftruncate64) ret = get_errno(ftruncate64(arg1, arg2)); break; #endif #ifdef TARGET_NR_stat64 - case TARGET_NR_stat64: + CASE_SYSCALL(TARGET_NR_stat64) ret = get_errno(stat(path((const char *)arg1), &st)); goto do_stat64; #endif #ifdef TARGET_NR_lstat64 - case TARGET_NR_lstat64: + CASE_SYSCALL(TARGET_NR_lstat64) ret = get_errno(lstat(path((const char *)arg1), &st)); goto do_stat64; #endif #ifdef TARGET_NR_fstat64 - case TARGET_NR_fstat64: + CASE_SYSCALL(TARGET_NR_fstat64) { ret = get_errno(fstat(arg1, &st)); do_stat64: @@ -2892,28 +2899,28 @@ long do_syscall(void *cpu_env, int num, break; #endif #ifdef USE_UID16 - case TARGET_NR_lchown: + CASE_SYSCALL(TARGET_NR_lchown) ret = get_errno(lchown((const char *)arg1, low2highuid(arg2), low2highgid(arg3))); break; - case TARGET_NR_getuid: + CASE_SYSCALL(TARGET_NR_getuid) ret = get_errno(high2lowuid(getuid())); break; - case TARGET_NR_getgid: + CASE_SYSCALL(TARGET_NR_getgid) ret = get_errno(high2lowgid(getgid())); break; - case TARGET_NR_geteuid: + CASE_SYSCALL(TARGET_NR_geteuid) ret = get_errno(high2lowuid(geteuid())); break; - case TARGET_NR_getegid: + CASE_SYSCALL(TARGET_NR_getegid) ret = get_errno(high2lowgid(getegid())); break; - case TARGET_NR_setreuid: + CASE_SYSCALL(TARGET_NR_setreuid) ret = get_errno(setreuid(low2highuid(arg1), low2highuid(arg2))); break; - case TARGET_NR_setregid: + CASE_SYSCALL(TARGET_NR_setregid) ret = get_errno(setregid(low2highgid(arg1), low2highgid(arg2))); break; - case TARGET_NR_getgroups: + CASE_SYSCALL(TARGET_NR_getgroups) { int gidsetsize = arg1; uint16_t *target_grouplist = (void *)arg2; @@ -2928,7 +2935,7 @@ long do_syscall(void *cpu_env, int num, } } break; - case TARGET_NR_setgroups: + CASE_SYSCALL(TARGET_NR_setgroups) { int gidsetsize = arg1; uint16_t *target_grouplist = (void *)arg2; @@ -2941,18 +2948,18 @@ long do_syscall(void *cpu_env, int num, ret = get_errno(setgroups(gidsetsize, grouplist)); } break; - case TARGET_NR_fchown: + CASE_SYSCALL(TARGET_NR_fchown) ret = get_errno(fchown(arg1, low2highuid(arg2), low2highgid(arg3))); break; #ifdef TARGET_NR_setresuid - case TARGET_NR_setresuid: + CASE_SYSCALL(TARGET_NR_setresuid) ret = get_errno(setresuid(low2highuid(arg1), low2highuid(arg2), low2highuid(arg3))); break; #endif #ifdef TARGET_NR_getresuid - case TARGET_NR_getresuid: + CASE_SYSCALL(TARGET_NR_getresuid) { int ruid, euid, suid; ret = get_errno(getresuid(&ruid, &euid, &suid)); @@ -2965,14 +2972,14 @@ long do_syscall(void *cpu_env, int num, break; #endif #ifdef TARGET_NR_getresgid - case TARGET_NR_setresgid: + CASE_SYSCALL(TARGET_NR_setresgid) ret = get_errno(setresgid(low2highgid(arg1), low2highgid(arg2), low2highgid(arg3))); break; #endif #ifdef TARGET_NR_getresgid - case TARGET_NR_getresgid: + CASE_SYSCALL(TARGET_NR_getresgid) { int rgid, egid, sgid; ret = get_errno(getresgid(&rgid, &egid, &sgid)); @@ -2984,60 +2991,60 @@ long do_syscall(void *cpu_env, int num, } break; #endif - case TARGET_NR_chown: + CASE_SYSCALL(TARGET_NR_chown) ret = get_errno(chown((const char *)arg1, low2highuid(arg2), low2highgid(arg3))); break; - case TARGET_NR_setuid: + CASE_SYSCALL(TARGET_NR_setuid) ret = get_errno(setuid(low2highuid(arg1))); break; - case TARGET_NR_setgid: + CASE_SYSCALL(TARGET_NR_setgid) ret = get_errno(setgid(low2highgid(arg1))); break; - case TARGET_NR_setfsuid: + CASE_SYSCALL(TARGET_NR_setfsuid) ret = get_errno(setfsuid(arg1)); break; - case TARGET_NR_setfsgid: + CASE_SYSCALL(TARGET_NR_setfsgid) ret = get_errno(setfsgid(arg1)); break; #endif /* USE_UID16 */ #ifdef TARGET_NR_lchown32 - case TARGET_NR_lchown32: + CASE_SYSCALL(TARGET_NR_lchown32) ret = get_errno(lchown((const char *)arg1, arg2, arg3)); break; #endif #ifdef TARGET_NR_getuid32 - case TARGET_NR_getuid32: + CASE_SYSCALL(TARGET_NR_getuid32) ret = get_errno(getuid()); break; #endif #ifdef TARGET_NR_getgid32 - case TARGET_NR_getgid32: + CASE_SYSCALL(TARGET_NR_getgid32) ret = get_errno(getgid()); break; #endif #ifdef TARGET_NR_geteuid32 - case TARGET_NR_geteuid32: + CASE_SYSCALL(TARGET_NR_geteuid32) ret = get_errno(geteuid()); break; #endif #ifdef TARGET_NR_getegid32 - case TARGET_NR_getegid32: + CASE_SYSCALL(TARGET_NR_getegid32) ret = get_errno(getegid()); break; #endif #ifdef TARGET_NR_setreuid32 - case TARGET_NR_setreuid32: + CASE_SYSCALL(TARGET_NR_setreuid32) ret = get_errno(setreuid(arg1, arg2)); break; #endif #ifdef TARGET_NR_setregid32 - case TARGET_NR_setregid32: + CASE_SYSCALL(TARGET_NR_setregid32) ret = get_errno(setregid(arg1, arg2)); break; #endif #ifdef TARGET_NR_getgroups32 - case TARGET_NR_getgroups32: + CASE_SYSCALL(TARGET_NR_getgroups32) { int gidsetsize = arg1; uint32_t *target_grouplist = (void *)arg2; @@ -3054,7 +3061,7 @@ long do_syscall(void *cpu_env, int num, break; #endif #ifdef TARGET_NR_setgroups32 - case TARGET_NR_setgroups32: + CASE_SYSCALL(TARGET_NR_setgroups32) { int gidsetsize = arg1; uint32_t *target_grouplist = (void *)arg2; @@ -3069,17 +3076,17 @@ long do_syscall(void *cpu_env, int num, break; #endif #ifdef TARGET_NR_fchown32 - case TARGET_NR_fchown32: + CASE_SYSCALL(TARGET_NR_fchown32) ret = get_errno(fchown(arg1, arg2, arg3)); break; #endif #ifdef TARGET_NR_setresuid32 - case TARGET_NR_setresuid32: + CASE_SYSCALL(TARGET_NR_setresuid32) ret = get_errno(setresuid(arg1, arg2, arg3)); break; #endif #ifdef TARGET_NR_getresuid32 - case TARGET_NR_getresuid32: + CASE_SYSCALL(TARGET_NR_getresuid32) { int ruid, euid, suid; ret = get_errno(getresuid(&ruid, &euid, &suid)); @@ -3092,12 +3099,12 @@ long do_syscall(void *cpu_env, int num, break; #endif #ifdef TARGET_NR_setresgid32 - case TARGET_NR_setresgid32: + CASE_SYSCALL(TARGET_NR_setresgid32) ret = get_errno(setresgid(arg1, arg2, arg3)); break; #endif #ifdef TARGET_NR_getresgid32 - case TARGET_NR_getresgid32: + CASE_SYSCALL(TARGET_NR_getresgid32) { int rgid, egid, sgid; ret = get_errno(getresgid(&rgid, &egid, &sgid)); @@ -3110,43 +3117,43 @@ long do_syscall(void *cpu_env, int num, break; #endif #ifdef TARGET_NR_chown32 - case TARGET_NR_chown32: + CASE_SYSCALL(TARGET_NR_chown32) ret = get_errno(chown((const char *)arg1, arg2, arg3)); break; #endif #ifdef TARGET_NR_setuid32 - case TARGET_NR_setuid32: + CASE_SYSCALL(TARGET_NR_setuid32) ret = get_errno(setuid(arg1)); break; #endif #ifdef TARGET_NR_setgid32 - case TARGET_NR_setgid32: + CASE_SYSCALL(TARGET_NR_setgid32) ret = get_errno(setgid(arg1)); break; #endif #ifdef TARGET_NR_setfsuid32 - case TARGET_NR_setfsuid32: + CASE_SYSCALL(TARGET_NR_setfsuid32) ret = get_errno(setfsuid(arg1)); break; #endif #ifdef TARGET_NR_setfsgid32 - case TARGET_NR_setfsgid32: + CASE_SYSCALL(TARGET_NR_setfsgid32) ret = get_errno(setfsgid(arg1)); break; #endif - case TARGET_NR_pivot_root: + CASE_SYSCALL(TARGET_NR_pivot_root) goto unimplemented; #ifdef TARGET_NR_mincore - case TARGET_NR_mincore: + CASE_SYSCALL(TARGET_NR_mincore) goto unimplemented; #endif #ifdef TARGET_NR_madvise - case TARGET_NR_madvise: + CASE_SYSCALL(TARGET_NR_madvise) goto unimplemented; #endif #if TARGET_LONG_BITS == 32 - case TARGET_NR_fcntl64: + CASE_SYSCALL(TARGET_NR_fcntl64) { struct flock64 fl; struct target_flock64 *target_fl = (void *)arg3; @@ -3180,42 +3187,42 @@ long do_syscall(void *cpu_env, int num, } #endif #ifdef TARGET_NR_security - case TARGET_NR_security: + CASE_SYSCALL(TARGET_NR_security) goto unimplemented; #endif #ifdef TARGET_NR_getpagesize - case TARGET_NR_getpagesize: + CASE_SYSCALL(TARGET_NR_getpagesize) ret = TARGET_PAGE_SIZE; break; #endif - case TARGET_NR_gettid: + CASE_SYSCALL(TARGET_NR_gettid) ret = get_errno(gettid()); break; - case TARGET_NR_readahead: + CASE_SYSCALL(TARGET_NR_readahead) goto unimplemented; #ifdef TARGET_NR_setxattr - case TARGET_NR_setxattr: - case TARGET_NR_lsetxattr: - case TARGET_NR_fsetxattr: - case TARGET_NR_getxattr: - case TARGET_NR_lgetxattr: - case TARGET_NR_fgetxattr: - case TARGET_NR_listxattr: - case TARGET_NR_llistxattr: - case TARGET_NR_flistxattr: - case TARGET_NR_removexattr: - case TARGET_NR_lremovexattr: - case TARGET_NR_fremovexattr: + CASE_SYSCALL(TARGET_NR_setxattr) + CASE_SYSCALL(TARGET_NR_lsetxattr) + CASE_SYSCALL(TARGET_NR_fsetxattr) + CASE_SYSCALL(TARGET_NR_getxattr) + CASE_SYSCALL(TARGET_NR_lgetxattr) + CASE_SYSCALL(TARGET_NR_fgetxattr) + CASE_SYSCALL(TARGET_NR_listxattr) + CASE_SYSCALL(TARGET_NR_llistxattr) + CASE_SYSCALL(TARGET_NR_flistxattr) + CASE_SYSCALL(TARGET_NR_removexattr) + CASE_SYSCALL(TARGET_NR_lremovexattr) + CASE_SYSCALL(TARGET_NR_fremovexattr) goto unimplemented_nowarn; #endif #ifdef TARGET_NR_set_thread_area - case TARGET_NR_set_thread_area: - case TARGET_NR_get_thread_area: + CASE_SYSCALL(TARGET_NR_set_thread_area) + CASE_SYSCALL(TARGET_NR_get_thread_area) goto unimplemented_nowarn; #endif default: unimplemented: - gemu_log("qemu: Unsupported syscall: %d\n", num); + gemu_log("unsupported syscall "); #if defined(TARGET_NR_setxattr) || defined(TARGET_NR_set_thread_area) unimplemented_nowarn: #endif