abi_long do_syscall(void *cpu_env, int num, abi_long arg1,

                    abi_long arg2, abi_long arg3, abi_long arg4,

                    abi_long arg5, abi_long arg6)

{

    abi_long ret;

    struct stat st;

    struct statfs stfs;

    void *p;



#ifdef DEBUG

    gemu_log("syscall %d", num);

#endif

    if(do_strace)

        print_syscall(num, arg1, arg2, arg3, arg4, arg5, arg6);



    switch(num) {

    case TARGET_NR_exit:

#ifdef CONFIG_USE_NPTL

      /* In old applications this may be used to implement _exit(2).

         However in threaded applictions it is used for thread termination,

         and _exit_group is used for application termination.

         Do thread termination if we have more then one thread.  */

      /* FIXME: This probably breaks if a signal arrives.  We should probably

         be disabling signals.  */

      if (first_cpu->next_cpu) {

          TaskState *ts;

          CPUState **lastp;

          CPUState *p;



          cpu_list_lock();

          lastp = &first_cpu;

          p = first_cpu;

          while (p && p != (CPUState *)cpu_env) {

              lastp = &p->next_cpu;

              p = p->next_cpu;

          }

          /* If we didn't find the CPU for this thread then something is

             horribly wrong.  */

          if (!p)

              abort();

          /* Remove the CPU from the list.  */

          *lastp = p->next_cpu;

          cpu_list_unlock();

          ts = ((CPUState *)cpu_env)->opaque;

          if (ts->child_tidptr) {

              put_user_u32(0, ts->child_tidptr);

              sys_futex(g2h(ts->child_tidptr), FUTEX_WAKE, INT_MAX,

                        NULL, NULL, 0);

          }

          /* TODO: Free CPU state.  */

          pthread_exit(NULL);

      }

#endif

#ifdef TARGET_GPROF

        _mcleanup();

#endif

        gdb_exit(cpu_env, arg1);

        _exit(arg1);

        ret = 0; /* avoid warning */

        break;

    case TARGET_NR_read:

        if (arg3 == 0)

            ret = 0;

        else {

            if (!(p = lock_user(VERIFY_WRITE, arg2, arg3, 0)))

                goto efault;

            ret = get_errno(read(arg1, p, arg3));

            unlock_user(p, arg2, ret);

        }

        break;

    case TARGET_NR_write:

        if (!(p = lock_user(VERIFY_READ, arg2, arg3, 1)))

            goto efault;

        ret = get_errno(write(arg1, p, arg3));

        unlock_user(p, arg2, 0);

        break;

    case TARGET_NR_open:

        if (!(p = lock_user_string(arg1)))

            goto efault;

        ret = get_errno(open(path(p),

                             target_to_host_bitmask(arg2, fcntl_flags_tbl),

                             arg3));

        unlock_user(p, arg1, 0);

        break;

#if defined(TARGET_NR_openat) && defined(__NR_openat)

    case TARGET_NR_openat:

        if (!(p = lock_user_string(arg2)))

            goto efault;

        ret = get_errno(sys_openat(arg1,

                                   path(p),

                                   target_to_host_bitmask(arg3, fcntl_flags_tbl),

                                   arg4));

        unlock_user(p, arg2, 0);

        break;

#endif

    case TARGET_NR_close:

        ret = get_errno(close(arg1));

        break;

    case TARGET_NR_brk:

        ret = do_brk(arg1);

        break;

    case TARGET_NR_fork:

        ret = get_errno(do_fork(cpu_env, SIGCHLD, 0, 0, 0, 0));

        break;

#ifdef TARGET_NR_waitpid

    case TARGET_NR_waitpid:

        {

            int status;

            ret = get_errno(waitpid(arg1, &status, arg3));

            if (!is_error(ret) && arg2

                && put_user_s32(host_to_target_waitstatus(status), arg2))

                goto efault;

        }

        break;

#endif

#ifdef TARGET_NR_waitid

    case TARGET_NR_waitid:

        {

            siginfo_t info;

            info.si_pid = 0;

            ret = get_errno(waitid(arg1, arg2, &info, arg4));

            if (!is_error(ret) && arg3 && info.si_pid != 0) {

                if (!(p = lock_user(VERIFY_WRITE, arg3, sizeof(target_siginfo_t), 0)))

                    goto efault;

                host_to_target_siginfo(p, &info);

                unlock_user(p, arg3, sizeof(target_siginfo_t));

            }

        }

        break;

#endif

#ifdef TARGET_NR_creat /* not on alpha */

    case TARGET_NR_creat:

        if (!(p = lock_user_string(arg1)))

            goto efault;

        ret = get_errno(creat(p, arg2));

        unlock_user(p, arg1, 0);

        break;

#endif

    case TARGET_NR_link:

        {

            void * p2;

            p = lock_user_string(arg1);

            p2 = lock_user_string(arg2);

            if (!p || !p2)

                ret = -TARGET_EFAULT;

            else

                ret = get_errno(link(p, p2));

            unlock_user(p2, arg2, 0);

            unlock_user(p, arg1, 0);

        }

        break;

#if defined(TARGET_NR_linkat) && defined(__NR_linkat)

    case TARGET_NR_linkat:

        {

            void * p2 = NULL;

            if (!arg2 || !arg4)

                goto efault;

            p  = lock_user_string(arg2);

            p2 = lock_user_string(arg4);

            if (!p || !p2)

                ret = -TARGET_EFAULT;

            else

                ret = get_errno(sys_linkat(arg1, p, arg3, p2, arg5));

            unlock_user(p, arg2, 0);

            unlock_user(p2, arg4, 0);

        }

        break;

#endif

    case TARGET_NR_unlink:

        if (!(p = lock_user_string(arg1)))

            goto efault;

        ret = get_errno(unlink(p));

        unlock_user(p, arg1, 0);

        break;

#if defined(TARGET_NR_unlinkat) && defined(__NR_unlinkat)

    case TARGET_NR_unlinkat:

        if (!(p = lock_user_string(arg2)))

            goto efault;

        ret = get_errno(sys_unlinkat(arg1, p, arg3));

        unlock_user(p, arg2, 0);

        break;

#endif

    case TARGET_NR_execve:

        {

            char **argp, **envp;

            int argc, envc;

            abi_ulong gp;

            abi_ulong guest_argp;

            abi_ulong guest_envp;

            abi_ulong addr;

            char **q;



            argc = 0;

            guest_argp = arg2;

            for (gp = guest_argp; gp; gp += sizeof(abi_ulong)) {

                if (get_user_ual(addr, gp))

                    goto efault;

                if (!addr)

                    break;

                argc++;

            }

            envc = 0;

            guest_envp = arg3;

            for (gp = guest_envp; gp; gp += sizeof(abi_ulong)) {

                if (get_user_ual(addr, gp))

                    goto efault;

                if (!addr)

                    break;

                envc++;

            }



            argp = alloca((argc + 1) * sizeof(void *));

            envp = alloca((envc + 1) * sizeof(void *));



            for (gp = guest_argp, q = argp; gp;

                  gp += sizeof(abi_ulong), q++) {

                if (get_user_ual(addr, gp))

                    goto execve_efault;

                if (!addr)

                    break;

                if (!(*q = lock_user_string(addr)))

                    goto execve_efault;

            }

            *q = NULL;



            for (gp = guest_envp, q = envp; gp;

                  gp += sizeof(abi_ulong), q++) {

                if (get_user_ual(addr, gp))

                    goto execve_efault;

                if (!addr)

                    break;

                if (!(*q = lock_user_string(addr)))

                    goto execve_efault;

            }

            *q = NULL;



            if (!(p = lock_user_string(arg1)))

                goto execve_efault;

            ret = get_errno(execve(p, argp, envp));

            unlock_user(p, arg1, 0);



            goto execve_end;



        execve_efault:

            ret = -TARGET_EFAULT;



        execve_end:

            for (gp = guest_argp, q = argp; *q;

                  gp += sizeof(abi_ulong), q++) {

                if (get_user_ual(addr, gp)

                    || !addr)

                    break;

                unlock_user(*q, addr, 0);

            }

            for (gp = guest_envp, q = envp; *q;

                  gp += sizeof(abi_ulong), q++) {

                if (get_user_ual(addr, gp)

                    || !addr)

                    break;

                unlock_user(*q, addr, 0);

            }

        }

        break;

    case TARGET_NR_chdir:

        if (!(p = lock_user_string(arg1)))

            goto efault;

        ret = get_errno(chdir(p));

        unlock_user(p, arg1, 0);

        break;

#ifdef TARGET_NR_time

    case TARGET_NR_time:

        {

            time_t host_time;

            ret = get_errno(time(&host_time));

            if (!is_error(ret)

                && arg1

                && put_user_sal(host_time, arg1))

                goto efault;

        }

        break;

#endif

    case TARGET_NR_mknod:

        if (!(p = lock_user_string(arg1)))

            goto efault;

        ret = get_errno(mknod(p, arg2, arg3));

        unlock_user(p, arg1, 0);

        break;

#if defined(TARGET_NR_mknodat) && defined(__NR_mknodat)

    case TARGET_NR_mknodat:

        if (!(p = lock_user_string(arg2)))

            goto efault;

        ret = get_errno(sys_mknodat(arg1, p, arg3, arg4));

        unlock_user(p, arg2, 0);

        break;

#endif

    case TARGET_NR_chmod:

        if (!(p = lock_user_string(arg1)))

            goto efault;

        ret = get_errno(chmod(p, arg2));

        unlock_user(p, arg1, 0);

        break;

#ifdef TARGET_NR_break

    case TARGET_NR_break:

        goto unimplemented;

#endif

#ifdef TARGET_NR_oldstat

    case TARGET_NR_oldstat:

        goto unimplemented;

#endif

    case TARGET_NR_lseek:

        ret = get_errno(lseek(arg1, arg2, arg3));

        break;

#ifdef TARGET_NR_getxpid

    case TARGET_NR_getxpid:

#else

    case TARGET_NR_getpid:

#endif

        ret = get_errno(getpid());

        break;

    case TARGET_NR_mount:

		{

			/* need to look at the data field */

			void *p2, *p3;

			p = lock_user_string(arg1);

			p2 = lock_user_string(arg2);

			p3 = lock_user_string(arg3);

                        if (!p || !p2 || !p3)

                            ret = -TARGET_EFAULT;

                        else

                            /* FIXME - arg5 should be locked, but it isn't clear how to

                             * do that since it's not guaranteed to be a NULL-terminated

                             * string.

                             */

                            ret = get_errno(mount(p, p2, p3, (unsigned long)arg4, g2h(arg5)));

                        unlock_user(p, arg1, 0);

                        unlock_user(p2, arg2, 0);

                        unlock_user(p3, arg3, 0);

			break;

		}

#ifdef TARGET_NR_umount

    case TARGET_NR_umount:

        if (!(p = lock_user_string(arg1)))

            goto efault;

        ret = get_errno(umount(p));

        unlock_user(p, arg1, 0);

        break;

#endif

#ifdef TARGET_NR_stime /* not on alpha */

    case TARGET_NR_stime:

        {

            time_t host_time;

            if (get_user_sal(host_time, arg1))

                goto efault;

            ret = get_errno(stime(&host_time));

        }

        break;

#endif

    case TARGET_NR_ptrace:

        goto unimplemented;

#ifdef TARGET_NR_alarm /* not on alpha */

    case TARGET_NR_alarm:

        ret = alarm(arg1);

        break;

#endif

#ifdef TARGET_NR_oldfstat

    case TARGET_NR_oldfstat:

        goto unimplemented;

#endif

#ifdef TARGET_NR_pause /* not on alpha */

    case TARGET_NR_pause:

        ret = get_errno(pause());

        break;

#endif

#ifdef TARGET_NR_utime

    case TARGET_NR_utime:

        {

            struct utimbuf tbuf, *host_tbuf;

            struct target_utimbuf *target_tbuf;

            if (arg2) {

                if (!lock_user_struct(VERIFY_READ, target_tbuf, arg2, 1))

                    goto efault;

                tbuf.actime = tswapl(target_tbuf->actime);

                tbuf.modtime = tswapl(target_tbuf->modtime);

                unlock_user_struct(target_tbuf, arg2, 0);

                host_tbuf = &tbuf;

            } else {

                host_tbuf = NULL;

            }

            if (!(p = lock_user_string(arg1)))

                goto efault;

            ret = get_errno(utime(p, host_tbuf));

            unlock_user(p, arg1, 0);

        }

        break;

#endif

    case TARGET_NR_utimes:

        {

            struct timeval *tvp, tv[2];

            if (arg2) {

                if (copy_from_user_timeval(&tv[0], arg2)

                    || copy_from_user_timeval(&tv[1],

                                              arg2 + sizeof(struct target_timeval)))

                    goto efault;

                tvp = tv;

            } else {

                tvp = NULL;

            }

            if (!(p = lock_user_string(arg1)))

                goto efault;

            ret = get_errno(utimes(p, tvp));

            unlock_user(p, arg1, 0);

        }

        break;

#if defined(TARGET_NR_futimesat) && defined(__NR_futimesat)

    case TARGET_NR_futimesat:

        {

            struct timeval *tvp, tv[2];

            if (arg3) {

                if (copy_from_user_timeval(&tv[0], arg3)

                    || copy_from_user_timeval(&tv[1],

                                              arg3 + sizeof(struct target_timeval)))

                    goto efault;

                tvp = tv;

            } else {

                tvp = NULL;

            }

            if (!(p = lock_user_string(arg2)))

                goto efault;

            ret = get_errno(sys_futimesat(arg1, path(p), tvp));

            unlock_user(p, arg2, 0);

        }

        break;

#endif

#ifdef TARGET_NR_stty

    case TARGET_NR_stty:

        goto unimplemented;

#endif

#ifdef TARGET_NR_gtty

    case TARGET_NR_gtty:

        goto unimplemented;

#endif

    case TARGET_NR_access:

        if (!(p = lock_user_string(arg1)))

            goto efault;

        ret = get_errno(access(path(p), arg2));

        unlock_user(p, arg1, 0);

        break;

#if defined(TARGET_NR_faccessat) && defined(__NR_faccessat)

    case TARGET_NR_faccessat:

        if (!(p = lock_user_string(arg2)))

            goto efault;

        ret = get_errno(sys_faccessat(arg1, p, arg3));

        unlock_user(p, arg2, 0);

        break;

#endif

#ifdef TARGET_NR_nice /* not on alpha */

    case TARGET_NR_nice:

        ret = get_errno(nice(arg1));

        break;

#endif

#ifdef TARGET_NR_ftime

    case TARGET_NR_ftime:

        goto unimplemented;

#endif

    case TARGET_NR_sync:

        sync();

        ret = 0;

        break;

    case TARGET_NR_kill:

        ret = get_errno(kill(arg1, target_to_host_signal(arg2)));

        break;

    case TARGET_NR_rename:

        {

            void *p2;

            p = lock_user_string(arg1);

            p2 = lock_user_string(arg2);

            if (!p || !p2)

                ret = -TARGET_EFAULT;

            else

                ret = get_errno(rename(p, p2));

            unlock_user(p2, arg2, 0);

            unlock_user(p, arg1, 0);

        }

        break;

#if defined(TARGET_NR_renameat) && defined(__NR_renameat)

    case TARGET_NR_renameat:

        {

            void *p2;

            p  = lock_user_string(arg2);

            p2 = lock_user_string(arg4);

            if (!p || !p2)

                ret = -TARGET_EFAULT;

            else

                ret = get_errno(sys_renameat(arg1, p, arg3, p2));

            unlock_user(p2, arg4, 0);

            unlock_user(p, arg2, 0);

        }

        break;

#endif

    case TARGET_NR_mkdir:

        if (!(p = lock_user_string(arg1)))

            goto efault;

        ret = get_errno(mkdir(p, arg2));

        unlock_user(p, arg1, 0);

        break;

#if defined(TARGET_NR_mkdirat) && defined(__NR_mkdirat)

    case TARGET_NR_mkdirat:

        if (!(p = lock_user_string(arg2)))

            goto efault;

        ret = get_errno(sys_mkdirat(arg1, p, arg3));

        unlock_user(p, arg2, 0);

        break;

#endif

    case TARGET_NR_rmdir:

        if (!(p = lock_user_string(arg1)))

            goto efault;

        ret = get_errno(rmdir(p));

        unlock_user(p, arg1, 0);

        break;

    case TARGET_NR_dup:

        ret = get_errno(dup(arg1));

        break;

    case TARGET_NR_pipe:

        ret = do_pipe(cpu_env, arg1, 0);

        break;

#ifdef TARGET_NR_pipe2

    case TARGET_NR_pipe2:

        ret = do_pipe(cpu_env, arg1, arg2);

        break;

#endif

    case TARGET_NR_times:

        {

            struct target_tms *tmsp;

            struct tms tms;

            ret = get_errno(times(&tms));

            if (arg1) {

                tmsp = lock_user(VERIFY_WRITE, arg1, sizeof(struct target_tms), 0);

                if (!tmsp)

                    goto efault;

                tmsp->tms_utime = tswapl(host_to_target_clock_t(tms.tms_utime));

                tmsp->tms_stime = tswapl(host_to_target_clock_t(tms.tms_stime));

                tmsp->tms_cutime = tswapl(host_to_target_clock_t(tms.tms_cutime));

                tmsp->tms_cstime = tswapl(host_to_target_clock_t(tms.tms_cstime));

            }

            if (!is_error(ret))

                ret = host_to_target_clock_t(ret);

        }

        break;

#ifdef TARGET_NR_prof

    case TARGET_NR_prof:

        goto unimplemented;

#endif

#ifdef TARGET_NR_signal

    case TARGET_NR_signal:

        goto unimplemented;

#endif

    case TARGET_NR_acct:

        if (arg1 == 0) {

            ret = get_errno(acct(NULL));

        } else {

            if (!(p = lock_user_string(arg1)))

                goto efault;

            ret = get_errno(acct(path(p)));

            unlock_user(p, arg1, 0);

        }

        break;

#ifdef TARGET_NR_umount2 /* not on alpha */

    case TARGET_NR_umount2:

        if (!(p = lock_user_string(arg1)))

            goto efault;

        ret = get_errno(umount2(p, arg2));

        unlock_user(p, arg1, 0);

        break;

#endif

#ifdef TARGET_NR_lock

    case TARGET_NR_lock:

        goto unimplemented;

#endif

    case TARGET_NR_ioctl:

        ret = do_ioctl(arg1, arg2, arg3);

        break;

    case TARGET_NR_fcntl:

        ret = do_fcntl(arg1, arg2, arg3);

        break;

#ifdef TARGET_NR_mpx

    case TARGET_NR_mpx:

        goto unimplemented;

#endif

    case TARGET_NR_setpgid:

        ret = get_errno(setpgid(arg1, arg2));

        break;

#ifdef TARGET_NR_ulimit

    case TARGET_NR_ulimit:

        goto unimplemented;

#endif

#ifdef TARGET_NR_oldolduname

    case TARGET_NR_oldolduname:

        goto unimplemented;

#endif

    case TARGET_NR_umask:

        ret = get_errno(umask(arg1));

        break;

    case TARGET_NR_chroot:

        if (!(p = lock_user_string(arg1)))

            goto efault;

        ret = get_errno(chroot(p));

        unlock_user(p, arg1, 0);

        break;

    case TARGET_NR_ustat:

        goto unimplemented;

    case TARGET_NR_dup2:

        ret = get_errno(dup2(arg1, arg2));

        break;

#ifdef TARGET_NR_getppid /* not on alpha */

    case TARGET_NR_getppid:

        ret = get_errno(getppid());

        break;

#endif

    case TARGET_NR_getpgrp:

        ret = get_errno(getpgrp());

        break;

    case TARGET_NR_setsid:

        ret = get_errno(setsid());

        break;

#ifdef TARGET_NR_sigaction

    case TARGET_NR_sigaction:

        {

#if !defined(TARGET_MIPS)

            struct target_old_sigaction *old_act;

            struct target_sigaction act, oact, *pact;

            if (arg2) {

                if (!lock_user_struct(VERIFY_READ, old_act, arg2, 1))

                    goto efault;

                act._sa_handler = old_act->_sa_handler;

                target_siginitset(&act.sa_mask, old_act->sa_mask);

                act.sa_flags = old_act->sa_flags;

                act.sa_restorer = old_act->sa_restorer;

                unlock_user_struct(old_act, arg2, 0);

                pact = &act;

            } else {

                pact = NULL;

            }

            ret = get_errno(do_sigaction(arg1, pact, &oact));

            if (!is_error(ret) && arg3) {

                if (!lock_user_struct(VERIFY_WRITE, old_act, arg3, 0))

                    goto efault;

                old_act->_sa_handler = oact._sa_handler;

                old_act->sa_mask = oact.sa_mask.sig[0];

                old_act->sa_flags = oact.sa_flags;

                old_act->sa_restorer = oact.sa_restorer;

                unlock_user_struct(old_act, arg3, 1);

            }

#else

	    struct target_sigaction act, oact, *pact, *old_act;



	    if (arg2) {

                if (!lock_user_struct(VERIFY_READ, old_act, arg2, 1))

                    goto efault;

		act._sa_handler = old_act->_sa_handler;

		target_siginitset(&act.sa_mask, old_act->sa_mask.sig[0]);

		act.sa_flags = old_act->sa_flags;

		unlock_user_struct(old_act, arg2, 0);

		pact = &act;

	    } else {

		pact = NULL;

	    }



	    ret = get_errno(do_sigaction(arg1, pact, &oact));



	    if (!is_error(ret) && arg3) {

                if (!lock_user_struct(VERIFY_WRITE, old_act, arg3, 0))

                    goto efault;

		old_act->_sa_handler = oact._sa_handler;

		old_act->sa_flags = oact.sa_flags;

		old_act->sa_mask.sig[0] = oact.sa_mask.sig[0];

		old_act->sa_mask.sig[1] = 0;

		old_act->sa_mask.sig[2] = 0;

		old_act->sa_mask.sig[3] = 0;

		unlock_user_struct(old_act, arg3, 1);

	    }

#endif

        }

        break;

#endif

    case TARGET_NR_rt_sigaction:

        {

            struct target_sigaction *act;

            struct target_sigaction *oact;



            if (arg2) {

                if (!lock_user_struct(VERIFY_READ, act, arg2, 1))

                    goto efault;

            } else

                act = NULL;

            if (arg3) {

                if (!lock_user_struct(VERIFY_WRITE, oact, arg3, 0)) {

                    ret = -TARGET_EFAULT;

                    goto rt_sigaction_fail;

                }

            } else

                oact = NULL;

            ret = get_errno(do_sigaction(arg1, act, oact));

	rt_sigaction_fail:

            if (act)

                unlock_user_struct(act, arg2, 0);

            if (oact)

                unlock_user_struct(oact, arg3, 1);

        }

        break;

#ifdef TARGET_NR_sgetmask /* not on alpha */

    case TARGET_NR_sgetmask:

        {

            sigset_t cur_set;

            abi_ulong target_set;

            sigprocmask(0, NULL, &cur_set);

            host_to_target_old_sigset(&target_set, &cur_set);

            ret = target_set;

        }

        break;

#endif

#ifdef TARGET_NR_ssetmask /* not on alpha */

    case TARGET_NR_ssetmask:

        {

            sigset_t set, oset, cur_set;

            abi_ulong target_set = arg1;

            sigprocmask(0, NULL, &cur_set);

            target_to_host_old_sigset(&set, &target_set);

            sigorset(&set, &set, &cur_set);

            sigprocmask(SIG_SETMASK, &set, &oset);

            host_to_target_old_sigset(&target_set, &oset);

            ret = target_set;

        }

        break;

#endif

#ifdef TARGET_NR_sigprocmask

    case TARGET_NR_sigprocmask:

        {

            int how = arg1;

            sigset_t set, oldset, *set_ptr;



            if (arg2) {

                switch(how) {

                case TARGET_SIG_BLOCK:

                    how = SIG_BLOCK;

                    break;

                case TARGET_SIG_UNBLOCK:

                    how = SIG_UNBLOCK;

                    break;

                case TARGET_SIG_SETMASK:

                    how = SIG_SETMASK;

                    break;

                default:

                    ret = -TARGET_EINVAL;

                    goto fail;

                }

                if (!(p = lock_user(VERIFY_READ, arg2, sizeof(target_sigset_t), 1)))

                    goto efault;

                target_to_host_old_sigset(&set, p);

                unlock_user(p, arg2, 0);

                set_ptr = &set;

            } else {

                how = 0;

                set_ptr = NULL;

            }

            ret = get_errno(sigprocmask(arg1, set_ptr, &oldset));

            if (!is_error(ret) && arg3) {

                if (!(p = lock_user(VERIFY_WRITE, arg3, sizeof(target_sigset_t), 0)))

                    goto efault;

                host_to_target_old_sigset(p, &oldset);

                unlock_user(p, arg3, sizeof(target_sigset_t));

            }

        }

        break;

#endif

    case TARGET_NR_rt_sigprocmask:

        {

            int how = arg1;

            sigset_t set, oldset, *set_ptr;



            if (arg2) {

                switch(how) {

                case TARGET_SIG_BLOCK:

                    how = SIG_BLOCK;

                    break;

                case TARGET_SIG_UNBLOCK:

                    how = SIG_UNBLOCK;

                    break;

                case TARGET_SIG_SETMASK:

                    how = SIG_SETMASK;

                    break;

                default:

                    ret = -TARGET_EINVAL;

                    goto fail;

                }

                if (!(p = lock_user(VERIFY_READ, arg2, sizeof(target_sigset_t), 1)))

                    goto efault;

                target_to_host_sigset(&set, p);

                unlock_user(p, arg2, 0);

                set_ptr = &set;

            } else {

                how = 0;

                set_ptr = NULL;

            }

            ret = get_errno(sigprocmask(how, set_ptr, &oldset));

            if (!is_error(ret) && arg3) {

                if (!(p = lock_user(VERIFY_WRITE, arg3, sizeof(target_sigset_t), 0)))

                    goto efault;

                host_to_target_sigset(p, &oldset);

                unlock_user(p, arg3, sizeof(target_sigset_t));

            }

        }

        break;

#ifdef TARGET_NR_sigpending

    case TARGET_NR_sigpending:

        {

            sigset_t set;

            ret = get_errno(sigpending(&set));

            if (!is_error(ret)) {

                if (!(p = lock_user(VERIFY_WRITE, arg1, sizeof(target_sigset_t), 0)))

                    goto efault;

                host_to_target_old_sigset(p, &set);

                unlock_user(p, arg1, sizeof(target_sigset_t));

            }

        }

        break;

#endif

    case TARGET_NR_rt_sigpending:

        {

            sigset_t set;

            ret = get_errno(sigpending(&set));

            if (!is_error(ret)) {

                if (!(p = lock_user(VERIFY_WRITE, arg1, sizeof(target_sigset_t), 0)))

                    goto efault;

                host_to_target_sigset(p, &set);

                unlock_user(p, arg1, sizeof(target_sigset_t));

            }

        }

        break;

#ifdef TARGET_NR_sigsuspend

    case TARGET_NR_sigsuspend:

        {

            sigset_t set;

            if (!(p = lock_user(VERIFY_READ, arg1, sizeof(target_sigset_t), 1)))

                goto efault;

            target_to_host_old_sigset(&set, p);

            unlock_user(p, arg1, 0);

            ret = get_errno(sigsuspend(&set));

        }

        break;

#endif

    case TARGET_NR_rt_sigsuspend:

        {

            sigset_t set;

            if (!(p = lock_user(VERIFY_READ, arg1, sizeof(target_sigset_t), 1)))

                goto efault;

            target_to_host_sigset(&set, p);

            unlock_user(p, arg1, 0);

            ret = get_errno(sigsuspend(&set));

        }

        break;

    case TARGET_NR_rt_sigtimedwait:

        {

            sigset_t set;

            struct timespec uts, *puts;

            siginfo_t uinfo;



            if (!(p = lock_user(VERIFY_READ, arg1, sizeof(target_sigset_t), 1)))

                goto efault;

            target_to_host_sigset(&set, p);

            unlock_user(p, arg1, 0);

            if (arg3) {

                puts = &uts;

                target_to_host_timespec(puts, arg3);

            } else {

                puts = NULL;

            }

            ret = get_errno(sigtimedwait(&set, &uinfo, puts));

            if (!is_error(ret) && arg2) {

                if (!(p = lock_user(VERIFY_WRITE, arg2, sizeof(target_siginfo_t), 0)))

                    goto efault;

                host_to_target_siginfo(p, &uinfo);

                unlock_user(p, arg2, sizeof(target_siginfo_t));

            }

        }

        break;

    case TARGET_NR_rt_sigqueueinfo:

        {

            siginfo_t uinfo;

            if (!(p = lock_user(VERIFY_READ, arg3, sizeof(target_sigset_t), 1)))

                goto efault;

            target_to_host_siginfo(&uinfo, p);

            unlock_user(p, arg1, 0);

            ret = get_errno(sys_rt_sigqueueinfo(arg1, arg2, &uinfo));

        }

        break;

#ifdef TARGET_NR_sigreturn

    case TARGET_NR_sigreturn:

        /* NOTE: ret is eax, so not transcoding must be done */

        ret = do_sigreturn(cpu_env);

        break;

#endif

    case 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:

        if (!(p = lock_user_string(arg1)))

            goto efault;

        ret = get_errno(sethostname(p, arg2));

        unlock_user(p, arg1, 0);

        break;

    case TARGET_NR_setrlimit:

        {

            /* XXX: convert resource ? */

            int resource = arg1;

            struct target_rlimit *target_rlim;

            struct rlimit rlim;

            if (!lock_user_struct(VERIFY_READ, target_rlim, arg2, 1))

                goto efault;

            rlim.rlim_cur = tswapl(target_rlim->rlim_cur);

            rlim.rlim_max = tswapl(target_rlim->rlim_max);

            unlock_user_struct(target_rlim, arg2, 0);

            ret = get_errno(setrlimit(resource, &rlim));

        }

        break;

    case TARGET_NR_getrlimit:

        {

            /* XXX: convert resource ? */

            int resource = arg1;

            struct target_rlimit *target_rlim;

            struct rlimit rlim;



            ret = get_errno(getrlimit(resource, &rlim));

            if (!is_error(ret)) {

                if (!lock_user_struct(VERIFY_WRITE, target_rlim, arg2, 0))

                    goto efault;

                target_rlim->rlim_cur = tswapl(rlim.rlim_cur);

                target_rlim->rlim_max = tswapl(rlim.rlim_max);

                unlock_user_struct(target_rlim, arg2, 1);

            }

        }

        break;

    case TARGET_NR_getrusage:

        {

            struct rusage rusage;

            ret = get_errno(getrusage(arg1, &rusage));

            if (!is_error(ret)) {

                host_to_target_rusage(arg2, &rusage);

            }

        }

        break;

    case TARGET_NR_gettimeofday:

        {

            struct timeval tv;

            ret = get_errno(gettimeofday(&tv, NULL));

            if (!is_error(ret)) {

                if (copy_to_user_timeval(arg1, &tv))

                    goto efault;

            }

        }

        break;

    case TARGET_NR_settimeofday:

        {

            struct timeval tv;

            if (copy_from_user_timeval(&tv, arg1))

                goto efault;

            ret = get_errno(settimeofday(&tv, NULL));

        }

        break;

#ifdef TARGET_NR_select

    case TARGET_NR_select:

        {

            struct target_sel_arg_struct *sel;

            abi_ulong inp, outp, exp, tvp;

            long nsel;



            if (!lock_user_struct(VERIFY_READ, sel, arg1, 1))

                goto efault;

            nsel = tswapl(sel->n);

            inp = tswapl(sel->inp);

            outp = tswapl(sel->outp);

            exp = tswapl(sel->exp);

            tvp = tswapl(sel->tvp);

            unlock_user_struct(sel, arg1, 0);

            ret = do_select(nsel, inp, outp, exp, tvp);

        }

        break;

#endif

    case TARGET_NR_symlink:

        {

            void *p2;

            p = lock_user_string(arg1);

            p2 = lock_user_string(arg2);

            if (!p || !p2)

                ret = -TARGET_EFAULT;

            else

                ret = get_errno(symlink(p, p2));

            unlock_user(p2, arg2, 0);

            unlock_user(p, arg1, 0);

        }

        break;

#if defined(TARGET_NR_symlinkat) && defined(__NR_symlinkat)

    case TARGET_NR_symlinkat:

        {

            void *p2;

            p  = lock_user_string(arg1);

            p2 = lock_user_string(arg3);

            if (!p || !p2)

                ret = -TARGET_EFAULT;

            else

                ret = get_errno(sys_symlinkat(p, arg2, p2));

            unlock_user(p2, arg3, 0);

            unlock_user(p, arg1, 0);

        }

        break;

#endif

#ifdef TARGET_NR_oldlstat

    case TARGET_NR_oldlstat:

        goto unimplemented;

#endif

    case TARGET_NR_readlink:

        {

            void *p2, *temp;

            p = lock_user_string(arg1);

            p2 = lock_user(VERIFY_WRITE, arg2, arg3, 0);

            if (!p || !p2)

                ret = -TARGET_EFAULT;

            else {

                if (strncmp((const char *)p, "/proc/self/exe", 14) == 0) {

                    char real[PATH_MAX];

                    temp = realpath(exec_path,real);

                    ret = (temp==NULL) ? get_errno(-1) : strlen(real) ;

                    snprintf((char *)p2, arg3, "%s", real);

                    }

                else

                    ret = get_errno(readlink(path(p), p2, arg3));

            }

            unlock_user(p2, arg2, ret);

            unlock_user(p, arg1, 0);

        }

        break;

#if defined(TARGET_NR_readlinkat) && defined(__NR_readlinkat)

    case TARGET_NR_readlinkat:

        {

            void *p2;

            p  = lock_user_string(arg2);

            p2 = lock_user(VERIFY_WRITE, arg3, arg4, 0);

            if (!p || !p2)

        	ret = -TARGET_EFAULT;

            else

                ret = get_errno(sys_readlinkat(arg1, path(p), p2, arg4));

            unlock_user(p2, arg3, ret);

            unlock_user(p, arg2, 0);

        }

        break;

#endif

#ifdef TARGET_NR_uselib

    case TARGET_NR_uselib:

        goto unimplemented;

#endif

#ifdef TARGET_NR_swapon

    case TARGET_NR_swapon:

        if (!(p = lock_user_string(arg1)))

            goto efault;

        ret = get_errno(swapon(p, arg2));

        unlock_user(p, arg1, 0);

        break;

#endif

    case TARGET_NR_reboot:

        goto unimplemented;

#ifdef TARGET_NR_readdir

    case TARGET_NR_readdir:

        goto unimplemented;

#endif

#ifdef TARGET_NR_mmap

    case TARGET_NR_mmap:

#if (defined(TARGET_I386) && defined(TARGET_ABI32)) || defined(TARGET_ARM) || defined(TARGET_M68K) || defined(TARGET_CRIS) || defined(TARGET_MICROBLAZE)

        {

            abi_ulong *v;

            abi_ulong v1, v2, v3, v4, v5, v6;

            if (!(v = lock_user(VERIFY_READ, arg1, 6 * sizeof(abi_ulong), 1)))

                goto efault;

            v1 = tswapl(v[0]);

            v2 = tswapl(v[1]);

            v3 = tswapl(v[2]);

            v4 = tswapl(v[3]);

            v5 = tswapl(v[4]);

            v6 = tswapl(v[5]);

            unlock_user(v, arg1, 0);

            ret = get_errno(target_mmap(v1, v2, v3,

                                        target_to_host_bitmask(v4, mmap_flags_tbl),

                                        v5, v6));

        }

#else

        ret = get_errno(target_mmap(arg1, arg2, arg3,

                                    target_to_host_bitmask(arg4, mmap_flags_tbl),

                                    arg5,

                                    arg6));

#endif

        break;

#endif

#ifdef TARGET_NR_mmap2

    case TARGET_NR_mmap2:

#ifndef MMAP_SHIFT

#define MMAP_SHIFT 12

#endif

        ret = get_errno(target_mmap(arg1, arg2, arg3,

                                    target_to_host_bitmask(arg4, mmap_flags_tbl),

                                    arg5,

                                    arg6 << MMAP_SHIFT));

        break;

#endif

    case TARGET_NR_munmap:

        ret = get_errno(target_munmap(arg1, arg2));

        break;

    case TARGET_NR_mprotect:

        ret = get_errno(target_mprotect(arg1, arg2, arg3));

        break;

#ifdef TARGET_NR_mremap

    case TARGET_NR_mremap:

        ret = get_errno(target_mremap(arg1, arg2, arg3, arg4, arg5));

        break;

#endif

        /* ??? msync/mlock/munlock are broken for softmmu.  */

#ifdef TARGET_NR_msync

    case TARGET_NR_msync:

        ret = get_errno(msync(g2h(arg1), arg2, arg3));

        break;

#endif

#ifdef TARGET_NR_mlock

    case TARGET_NR_mlock:

        ret = get_errno(mlock(g2h(arg1), arg2));

        break;

#endif

#ifdef TARGET_NR_munlock

    case TARGET_NR_munlock:

        ret = get_errno(munlock(g2h(arg1), arg2));

        break;

#endif

#ifdef TARGET_NR_mlockall

    case TARGET_NR_mlockall:

        ret = get_errno(mlockall(arg1));

        break;

#endif

#ifdef TARGET_NR_munlockall

    case TARGET_NR_munlockall:

        ret = get_errno(munlockall());

        break;

#endif

    case TARGET_NR_truncate:

        if (!(p = lock_user_string(arg1)))

            goto efault;

        ret = get_errno(truncate(p, arg2));

        unlock_user(p, arg1, 0);

        break;

    case TARGET_NR_ftruncate:

        ret = get_errno(ftruncate(arg1, arg2));

        break;

    case TARGET_NR_fchmod:

        ret = get_errno(fchmod(arg1, arg2));

        break;

#if defined(TARGET_NR_fchmodat) && defined(__NR_fchmodat)

    case TARGET_NR_fchmodat:

        if (!(p = lock_user_string(arg2)))

            goto efault;

        ret = get_errno(sys_fchmodat(arg1, p, arg3));

        unlock_user(p, arg2, 0);

        break;

#endif

    case TARGET_NR_getpriority:

        /* libc does special remapping of the return value of

         * sys_getpriority() so it's just easiest to call

         * sys_getpriority() directly rather than through libc. */

        ret = sys_getpriority(arg1, arg2);

        break;

    case TARGET_NR_setpriority:

        ret = get_errno(setpriority(arg1, arg2, arg3));

        break;

#ifdef TARGET_NR_profil

    case TARGET_NR_profil:

        goto unimplemented;

#endif

    case TARGET_NR_statfs:

        if (!(p = lock_user_string(arg1)))

            goto efault;

        ret = get_errno(statfs(path(p), &stfs));

        unlock_user(p, arg1, 0);

    convert_statfs:

        if (!is_error(ret)) {

            struct target_statfs *target_stfs;



            if (!lock_user_struct(VERIFY_WRITE, target_stfs, arg2, 0))

                goto efault;

            __put_user(stfs.f_type, &target_stfs->f_type);

            __put_user(stfs.f_bsize, &target_stfs->f_bsize);

            __put_user(stfs.f_blocks, &target_stfs->f_blocks);

            __put_user(stfs.f_bfree, &target_stfs->f_bfree);

            __put_user(stfs.f_bavail, &target_stfs->f_bavail);

            __put_user(stfs.f_files, &target_stfs->f_files);

            __put_user(stfs.f_ffree, &target_stfs->f_ffree);

            __put_user(stfs.f_fsid.__val[0], &target_stfs->f_fsid.val[0]);

            __put_user(stfs.f_fsid.__val[1], &target_stfs->f_fsid.val[1]);

            __put_user(stfs.f_namelen, &target_stfs->f_namelen);

            unlock_user_struct(target_stfs, arg2, 1);

        }

        break;

    case TARGET_NR_fstatfs:

        ret = get_errno(fstatfs(arg1, &stfs));

        goto convert_statfs;

#ifdef TARGET_NR_statfs64

    case TARGET_NR_statfs64:

        if (!(p = lock_user_string(arg1)))

            goto efault;

        ret = get_errno(statfs(path(p), &stfs));

        unlock_user(p, arg1, 0);

    convert_statfs64:

        if (!is_error(ret)) {

            struct target_statfs64 *target_stfs;



            if (!lock_user_struct(VERIFY_WRITE, target_stfs, arg3, 0))

                goto efault;

            __put_user(stfs.f_type, &target_stfs->f_type);

            __put_user(stfs.f_bsize, &target_stfs->f_bsize);

            __put_user(stfs.f_blocks, &target_stfs->f_blocks);

            __put_user(stfs.f_bfree, &target_stfs->f_bfree);

            __put_user(stfs.f_bavail, &target_stfs->f_bavail);

            __put_user(stfs.f_files, &target_stfs->f_files);

            __put_user(stfs.f_ffree, &target_stfs->f_ffree);

            __put_user(stfs.f_fsid.__val[0], &target_stfs->f_fsid.val[0]);

            __put_user(stfs.f_fsid.__val[1], &target_stfs->f_fsid.val[1]);

            __put_user(stfs.f_namelen, &target_stfs->f_namelen);

            unlock_user_struct(target_stfs, arg3, 1);

        }

        break;

    case TARGET_NR_fstatfs64:

        ret = get_errno(fstatfs(arg1, &stfs));

        goto convert_statfs64;

#endif

#ifdef TARGET_NR_ioperm

    case TARGET_NR_ioperm:

        goto unimplemented;

#endif

#ifdef TARGET_NR_socketcall

    case TARGET_NR_socketcall:

        ret = do_socketcall(arg1, arg2);

        break;

#endif

#ifdef TARGET_NR_accept

    case TARGET_NR_accept:

        ret = do_accept(arg1, arg2, arg3);

        break;

#endif

#ifdef TARGET_NR_bind

    case TARGET_NR_bind:

        ret = do_bind(arg1, arg2, arg3);

        break;

#endif

#ifdef TARGET_NR_connect

    case TARGET_NR_connect:

        ret = do_connect(arg1, arg2, arg3);

        break;

#endif

#ifdef TARGET_NR_getpeername

    case TARGET_NR_getpeername:

        ret = do_getpeername(arg1, arg2, arg3);

        break;

#endif

#ifdef TARGET_NR_getsockname

    case TARGET_NR_getsockname:

        ret = do_getsockname(arg1, arg2, arg3);

        break;

#endif

#ifdef TARGET_NR_getsockopt

    case TARGET_NR_getsockopt:

        ret = do_getsockopt(arg1, arg2, arg3, arg4, arg5);

        break;

#endif

#ifdef TARGET_NR_listen

    case TARGET_NR_listen:

        ret = get_errno(listen(arg1, arg2));

        break;

#endif

#ifdef TARGET_NR_recv

    case TARGET_NR_recv:

        ret = do_recvfrom(arg1, arg2, arg3, arg4, 0, 0);

        break;

#endif

#ifdef TARGET_NR_recvfrom

    case TARGET_NR_recvfrom:

        ret = do_recvfrom(arg1, arg2, arg3, arg4, arg5, arg6);

        break;

#endif

#ifdef TARGET_NR_recvmsg

    case TARGET_NR_recvmsg:

        ret = do_sendrecvmsg(arg1, arg2, arg3, 0);

        break;

#endif

#ifdef TARGET_NR_send

    case TARGET_NR_send:

        ret = do_sendto(arg1, arg2, arg3, arg4, 0, 0);

        break;

#endif

#ifdef TARGET_NR_sendmsg

    case TARGET_NR_sendmsg:

        ret = do_sendrecvmsg(arg1, arg2, arg3, 1);

        break;

#endif

#ifdef TARGET_NR_sendto

    case TARGET_NR_sendto:

        ret = do_sendto(arg1, arg2, arg3, arg4, arg5, arg6);

        break;

#endif

#ifdef TARGET_NR_shutdown

    case TARGET_NR_shutdown:

        ret = get_errno(shutdown(arg1, arg2));

        break;

#endif

#ifdef TARGET_NR_socket

    case TARGET_NR_socket:

        ret = do_socket(arg1, arg2, arg3);

        break;

#endif

#ifdef TARGET_NR_socketpair

    case TARGET_NR_socketpair:

        ret = do_socketpair(arg1, arg2, arg3, arg4);

        break;

#endif

#ifdef TARGET_NR_setsockopt

    case TARGET_NR_setsockopt:

        ret = do_setsockopt(arg1, arg2, arg3, arg4, (socklen_t) arg5);

        break;

#endif



    case TARGET_NR_syslog:

        if (!(p = lock_user_string(arg2)))

            goto efault;

        ret = get_errno(sys_syslog((int)arg1, p, (int)arg3));

        unlock_user(p, arg2, 0);

        break;



    case TARGET_NR_setitimer:

        {

            struct itimerval value, ovalue, *pvalue;



            if (arg2) {

                pvalue = &value;

                if (copy_from_user_timeval(&pvalue->it_interval, arg2)

                    || copy_from_user_timeval(&pvalue->it_value,

                                              arg2 + sizeof(struct target_timeval)))

                    goto efault;

            } else {

                pvalue = NULL;

            }

            ret = get_errno(setitimer(arg1, pvalue, &ovalue));

            if (!is_error(ret) && arg3) {

                if (copy_to_user_timeval(arg3,

                                         &ovalue.it_interval)

                    || copy_to_user_timeval(arg3 + sizeof(struct target_timeval),

                                            &ovalue.it_value))

                    goto efault;

            }

        }

        break;

    case TARGET_NR_getitimer:

        {

            struct itimerval value;



            ret = get_errno(getitimer(arg1, &value));

            if (!is_error(ret) && arg2) {

                if (copy_to_user_timeval(arg2,

                                         &value.it_interval)

                    || copy_to_user_timeval(arg2 + sizeof(struct target_timeval),

                                            &value.it_value))

                    goto efault;

            }

        }

        break;

    case TARGET_NR_stat:

        if (!(p = lock_user_string(arg1)))

            goto efault;

        ret = get_errno(stat(path(p), &st));

        unlock_user(p, arg1, 0);

        goto do_stat;

    case TARGET_NR_lstat:

        if (!(p = lock_user_string(arg1)))

            goto efault;

        ret = get_errno(lstat(path(p), &st));

        unlock_user(p, arg1, 0);

        goto do_stat;

    case TARGET_NR_fstat:

        {

            ret = get_errno(fstat(arg1, &st));

        do_stat:

            if (!is_error(ret)) {

                struct target_stat *target_st;



                if (!lock_user_struct(VERIFY_WRITE, target_st, arg2, 0))

                    goto efault;


                __put_user(st.st_dev, &target_st->st_dev);

                __put_user(st.st_ino, &target_st->st_ino);

                __put_user(st.st_mode, &target_st->st_mode);

                __put_user(st.st_uid, &target_st->st_uid);

                __put_user(st.st_gid, &target_st->st_gid);

                __put_user(st.st_nlink, &target_st->st_nlink);

                __put_user(st.st_rdev, &target_st->st_rdev);

                __put_user(st.st_size, &target_st->st_size);

                __put_user(st.st_blksize, &target_st->st_blksize);

                __put_user(st.st_blocks, &target_st->st_blocks);

                __put_user(st.st_atime, &target_st->target_st_atime);

                __put_user(st.st_mtime, &target_st->target_st_mtime);

                __put_user(st.st_ctime, &target_st->target_st_ctime);

                unlock_user_struct(target_st, arg2, 1);

            }

        }

        break;

#ifdef TARGET_NR_olduname

    case TARGET_NR_olduname:

        goto unimplemented;

#endif

#ifdef TARGET_NR_iopl

    case TARGET_NR_iopl:

        goto unimplemented;

#endif

    case TARGET_NR_vhangup:

        ret = get_errno(vhangup());

        break;

#ifdef TARGET_NR_idle

    case TARGET_NR_idle:

        goto unimplemented;

#endif

#ifdef TARGET_NR_syscall

    case TARGET_NR_syscall:

    	ret = do_syscall(cpu_env,arg1 & 0xffff,arg2,arg3,arg4,arg5,arg6,0);

    	break;

#endif

    case TARGET_NR_wait4:

        {

            int status;

            abi_long status_ptr = arg2;

            struct rusage rusage, *rusage_ptr;

            abi_ulong target_rusage = arg4;

            if (target_rusage)

                rusage_ptr = &rusage;

            else

                rusage_ptr = NULL;

            ret = get_errno(wait4(arg1, &status, arg3, rusage_ptr));

            if (!is_error(ret)) {

                if (status_ptr) {

                    status = host_to_target_waitstatus(status);

                    if (put_user_s32(status, status_ptr))

                        goto efault;

                }

                if (target_rusage)

                    host_to_target_rusage(target_rusage, &rusage);

            }

        }

        break;

#ifdef TARGET_NR_swapoff

    case TARGET_NR_swapoff:

        if (!(p = lock_user_string(arg1)))

            goto efault;

        ret = get_errno(swapoff(p));

        unlock_user(p, arg1, 0);

        break;

#endif

    case TARGET_NR_sysinfo:

        {

            struct target_sysinfo *target_value;

            struct sysinfo value;

            ret = get_errno(sysinfo(&value));

            if (!is_error(ret) && arg1)

            {

                if (!lock_user_struct(VERIFY_WRITE, target_value, arg1, 0))

                    goto efault;

                __put_user(value.uptime, &target_value->uptime);

                __put_user(value.loads[0], &target_value->loads[0]);

                __put_user(value.loads[1], &target_value->loads[1]);

                __put_user(value.loads[2], &target_value->loads[2]);

                __put_user(value.totalram, &target_value->totalram);

                __put_user(value.freeram, &target_value->freeram);

                __put_user(value.sharedram, &target_value->sharedram);

                __put_user(value.bufferram, &target_value->bufferram);

                __put_user(value.totalswap, &target_value->totalswap);

                __put_user(value.freeswap, &target_value->freeswap);

                __put_user(value.procs, &target_value->procs);

                __put_user(value.totalhigh, &target_value->totalhigh);

                __put_user(value.freehigh, &target_value->freehigh);

                __put_user(value.mem_unit, &target_value->mem_unit);

                unlock_user_struct(target_value, arg1, 1);

            }

        }

        break;

#ifdef TARGET_NR_ipc

    case TARGET_NR_ipc:

	ret = do_ipc(arg1, arg2, arg3, arg4, arg5, arg6);

	break;

#endif

#ifdef TARGET_NR_semget

    case TARGET_NR_semget:

        ret = get_errno(semget(arg1, arg2, arg3));

        break;

#endif

#ifdef TARGET_NR_semop

    case TARGET_NR_semop:

        ret = get_errno(do_semop(arg1, arg2, arg3));

        break;

#endif

#ifdef TARGET_NR_semctl

    case TARGET_NR_semctl:

        ret = do_semctl(arg1, arg2, arg3, (union target_semun)(abi_ulong)arg4);

        break;

#endif

#ifdef TARGET_NR_msgctl

    case TARGET_NR_msgctl:

        ret = do_msgctl(arg1, arg2, arg3);

        break;

#endif

#ifdef TARGET_NR_msgget

    case TARGET_NR_msgget:

        ret = get_errno(msgget(arg1, arg2));

        break;

#endif

#ifdef TARGET_NR_msgrcv

    case TARGET_NR_msgrcv:

        ret = do_msgrcv(arg1, arg2, arg3, arg4, arg5);

        break;

#endif

#ifdef TARGET_NR_msgsnd

    case TARGET_NR_msgsnd:

        ret = do_msgsnd(arg1, arg2, arg3, arg4);

        break;

#endif

#ifdef TARGET_NR_shmget

    case TARGET_NR_shmget:

        ret = get_errno(shmget(arg1, arg2, arg3));

        break;

#endif

#ifdef TARGET_NR_shmctl

    case TARGET_NR_shmctl:

        ret = do_shmctl(arg1, arg2, arg3);

        break;

#endif

#ifdef TARGET_NR_shmat

    case TARGET_NR_shmat:

        ret = do_shmat(arg1, arg2, arg3);

        break;

#endif

#ifdef TARGET_NR_shmdt

    case TARGET_NR_shmdt:

        ret = do_shmdt(arg1);

        break;

#endif

    case TARGET_NR_fsync:

        ret = get_errno(fsync(arg1));

        break;

    case TARGET_NR_clone:

#if defined(TARGET_SH4)

        ret = get_errno(do_fork(cpu_env, arg1, arg2, arg3, arg5, arg4));

#elif defined(TARGET_CRIS)

        ret = get_errno(do_fork(cpu_env, arg2, arg1, arg3, arg4, arg5));

#else

        ret = get_errno(do_fork(cpu_env, arg1, arg2, arg3, arg4, arg5));

#endif

        break;

#ifdef __NR_exit_group

        /* new thread calls */

    case TARGET_NR_exit_group:

#ifdef TARGET_GPROF

        _mcleanup();

#endif

        gdb_exit(cpu_env, arg1);

        ret = get_errno(exit_group(arg1));

        break;

#endif

    case TARGET_NR_setdomainname:

        if (!(p = lock_user_string(arg1)))

            goto efault;

        ret = get_errno(setdomainname(p, arg2));

        unlock_user(p, arg1, 0);

        break;

    case TARGET_NR_uname:

        /* no need to transcode because we use the linux syscall */

        {

            struct new_utsname * buf;



            if (!lock_user_struct(VERIFY_WRITE, buf, arg1, 0))

                goto efault;

            ret = get_errno(sys_uname(buf));

            if (!is_error(ret)) {

                /* Overrite the native machine name with whatever is being

                   emulated. */

                strcpy (buf->machine, UNAME_MACHINE);

                /* Allow the user to override the reported release.  */

                if (qemu_uname_release && *qemu_uname_release)

                  strcpy (buf->release, qemu_uname_release);

            }

            unlock_user_struct(buf, arg1, 1);

        }

        break;

#ifdef TARGET_I386

    case TARGET_NR_modify_ldt:

        ret = do_modify_ldt(cpu_env, arg1, arg2, arg3);

        break;

#if !defined(TARGET_X86_64)

    case TARGET_NR_vm86old:

        goto unimplemented;

    case TARGET_NR_vm86:

        ret = do_vm86(cpu_env, arg1, arg2);

        break;

#endif

#endif

    case TARGET_NR_adjtimex:

        goto unimplemented;

#ifdef TARGET_NR_create_module

    case TARGET_NR_create_module:

#endif

    case TARGET_NR_init_module:

    case TARGET_NR_delete_module:

#ifdef TARGET_NR_get_kernel_syms

    case TARGET_NR_get_kernel_syms:

#endif

        goto unimplemented;

    case TARGET_NR_quotactl:

        goto unimplemented;

    case TARGET_NR_getpgid:

        ret = get_errno(getpgid(arg1));

        break;

    case TARGET_NR_fchdir:

        ret = get_errno(fchdir(arg1));

        break;

#ifdef TARGET_NR_bdflush /* not on x86_64 */

    case TARGET_NR_bdflush:

        goto unimplemented;

#endif

#ifdef TARGET_NR_sysfs

    case TARGET_NR_sysfs:

        goto unimplemented;

#endif

    case TARGET_NR_personality:

        ret = get_errno(personality(arg1));

        break;

#ifdef TARGET_NR_afs_syscall

    case TARGET_NR_afs_syscall:

        goto unimplemented;

#endif

#ifdef TARGET_NR__llseek /* Not on alpha */

    case TARGET_NR__llseek:

        {

#if defined (__x86_64__)

            ret = get_errno(lseek(arg1, ((uint64_t )arg2 << 32) | arg3, arg5));

            if (put_user_s64(ret, arg4))

                goto efault;

#else

            int64_t res;

            ret = get_errno(_llseek(arg1, arg2, arg3, &res, arg5));

            if (put_user_s64(res, arg4))

                goto efault;

#endif

        }

        break;

#endif

    case TARGET_NR_getdents:

#if TARGET_ABI_BITS == 32 && HOST_LONG_BITS == 64

        {

            struct target_dirent *target_dirp;

            struct linux_dirent *dirp;

            abi_long count = arg3;



	    dirp = malloc(count);

	    if (!dirp) {

                ret = -TARGET_ENOMEM;

                goto fail;

            }



            ret = get_errno(sys_getdents(arg1, dirp, count));

            if (!is_error(ret)) {

                struct linux_dirent *de;

		struct target_dirent *tde;

                int len = ret;

                int reclen, treclen;

		int count1, tnamelen;



		count1 = 0;

                de = dirp;

                if (!(target_dirp = lock_user(VERIFY_WRITE, arg2, count, 0)))

                    goto efault;

		tde = target_dirp;

                while (len > 0) {

                    reclen = de->d_reclen;

		    treclen = reclen - (2 * (sizeof(long) - sizeof(abi_long)));

                    tde->d_reclen = tswap16(treclen);

                    tde->d_ino = tswapl(de->d_ino);

                    tde->d_off = tswapl(de->d_off);

		    tnamelen = treclen - (2 * sizeof(abi_long) + 2);

		    if (tnamelen > 256)

                        tnamelen = 256;

                    /* XXX: may not be correct */

                    pstrcpy(tde->d_name, tnamelen, de->d_name);

                    de = (struct linux_dirent *)((char *)de + reclen);

                    len -= reclen;

                    tde = (struct target_dirent *)((char *)tde + treclen);

		    count1 += treclen;

                }

		ret = count1;

                unlock_user(target_dirp, arg2, ret);

            }

	    free(dirp);

        }

#else

        {

            struct linux_dirent *dirp;

            abi_long count = arg3;



            if (!(dirp = lock_user(VERIFY_WRITE, arg2, count, 0)))

                goto efault;

            ret = get_errno(sys_getdents(arg1, dirp, count));

            if (!is_error(ret)) {

                struct linux_dirent *de;

                int len = ret;

                int reclen;

                de = dirp;

                while (len > 0) {

                    reclen = de->d_reclen;

                    if (reclen > len)

                        break;

                    de->d_reclen = tswap16(reclen);

                    tswapls(&de->d_ino);

                    tswapls(&de->d_off);

                    de = (struct linux_dirent *)((char *)de + reclen);

                    len -= reclen;

                }

            }

            unlock_user(dirp, arg2, ret);

        }

#endif

        break;

#if defined(TARGET_NR_getdents64) && defined(__NR_getdents64)

    case TARGET_NR_getdents64:

        {

            struct linux_dirent64 *dirp;

            abi_long count = arg3;

            if (!(dirp = lock_user(VERIFY_WRITE, arg2, count, 0)))

                goto efault;

            ret = get_errno(sys_getdents64(arg1, dirp, count));

            if (!is_error(ret)) {

                struct linux_dirent64 *de;

                int len = ret;

                int reclen;

                de = dirp;

                while (len > 0) {

                    reclen = de->d_reclen;

                    if (reclen > len)

                        break;

                    de->d_reclen = tswap16(reclen);

                    tswap64s((uint64_t *)&de->d_ino);

                    tswap64s((uint64_t *)&de->d_off);

                    de = (struct linux_dirent64 *)((char *)de + reclen);

                    len -= reclen;

                }

            }

            unlock_user(dirp, arg2, ret);

        }

        break;

#endif /* TARGET_NR_getdents64 */

#ifdef TARGET_NR__newselect

    case TARGET_NR__newselect:

        ret = do_select(arg1, arg2, arg3, arg4, arg5);

        break;

#endif

#ifdef TARGET_NR_poll

    case TARGET_NR_poll:

        {

            struct target_pollfd *target_pfd;

            unsigned int nfds = arg2;

            int timeout = arg3;

            struct pollfd *pfd;

            unsigned int i;



            target_pfd = lock_user(VERIFY_WRITE, arg1, sizeof(struct target_pollfd) * nfds, 1);

            if (!target_pfd)

                goto efault;

            pfd = alloca(sizeof(struct pollfd) * nfds);

            for(i = 0; i < nfds; i++) {

                pfd[i].fd = tswap32(target_pfd[i].fd);

                pfd[i].events = tswap16(target_pfd[i].events);

            }

            ret = get_errno(poll(pfd, nfds, timeout));

            if (!is_error(ret)) {

                for(i = 0; i < nfds; i++) {

                    target_pfd[i].revents = tswap16(pfd[i].revents);

                }

                ret += nfds * (sizeof(struct target_pollfd)

                               - sizeof(struct pollfd));

            }

            unlock_user(target_pfd, arg1, ret);

        }

        break;

#endif

    case 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:

        {

            int count = arg3;

            struct iovec *vec;



            vec = alloca(count * sizeof(struct iovec));

            if (lock_iovec(VERIFY_WRITE, vec, arg2, count, 0) < 0)

                goto efault;

            ret = get_errno(readv(arg1, vec, count));

            unlock_iovec(vec, arg2, count, 1);

        }

        break;

    case TARGET_NR_writev:

        {

            int count = arg3;

            struct iovec *vec;



            vec = alloca(count * sizeof(struct iovec));

            if (lock_iovec(VERIFY_READ, vec, arg2, count, 1) < 0)

                goto efault;

            ret = get_errno(writev(arg1, vec, count));

            unlock_iovec(vec, arg2, count, 0);

        }

        break;

    case TARGET_NR_getsid:

        ret = get_errno(getsid(arg1));

        break;

#if defined(TARGET_NR_fdatasync) /* Not on alpha (osf_datasync ?) */

    case TARGET_NR_fdatasync:

        ret = get_errno(fdatasync(arg1));

        break;

#endif

    case TARGET_NR__sysctl:

        /* We don't implement this, but ENOTDIR is always a safe

           return value. */

        ret = -TARGET_ENOTDIR;

        break;

    case TARGET_NR_sched_setparam:

        {

            struct sched_param *target_schp;

            struct sched_param schp;



            if (!lock_user_struct(VERIFY_READ, target_schp, arg2, 1))

                goto efault;

            schp.sched_priority = tswap32(target_schp->sched_priority);

            unlock_user_struct(target_schp, arg2, 0);

            ret = get_errno(sched_setparam(arg1, &schp));

        }

        break;

    case TARGET_NR_sched_getparam:

        {

            struct sched_param *target_schp;

            struct sched_param schp;

            ret = get_errno(sched_getparam(arg1, &schp));

            if (!is_error(ret)) {

                if (!lock_user_struct(VERIFY_WRITE, target_schp, arg2, 0))

                    goto efault;

                target_schp->sched_priority = tswap32(schp.sched_priority);

                unlock_user_struct(target_schp, arg2, 1);

            }

        }

        break;

    case TARGET_NR_sched_setscheduler:

        {

            struct sched_param *target_schp;

            struct sched_param schp;

            if (!lock_user_struct(VERIFY_READ, target_schp, arg3, 1))

                goto efault;

            schp.sched_priority = tswap32(target_schp->sched_priority);

            unlock_user_struct(target_schp, arg3, 0);

            ret = get_errno(sched_setscheduler(arg1, arg2, &schp));

        }

        break;

    case TARGET_NR_sched_getscheduler:

        ret = get_errno(sched_getscheduler(arg1));

        break;

    case TARGET_NR_sched_yield:

        ret = get_errno(sched_yield());

        break;

    case TARGET_NR_sched_get_priority_max:

        ret = get_errno(sched_get_priority_max(arg1));

        break;

    case TARGET_NR_sched_get_priority_min:

        ret = get_errno(sched_get_priority_min(arg1));

        break;

    case TARGET_NR_sched_rr_get_interval:

        {

            struct timespec ts;

            ret = get_errno(sched_rr_get_interval(arg1, &ts));

            if (!is_error(ret)) {

                host_to_target_timespec(arg2, &ts);

            }

        }

        break;

    case TARGET_NR_nanosleep:

        {

            struct timespec req, rem;

            target_to_host_timespec(&req, arg1);

            ret = get_errno(nanosleep(&req, &rem));

            if (is_error(ret) && arg2) {

                host_to_target_timespec(arg2, &rem);

            }

        }

        break;

#ifdef TARGET_NR_query_module

    case TARGET_NR_query_module:

        goto unimplemented;

#endif

#ifdef TARGET_NR_nfsservctl

    case TARGET_NR_nfsservctl:

        goto unimplemented;

#endif

    case TARGET_NR_prctl:

        switch (arg1)

            {

            case PR_GET_PDEATHSIG:

                {

                    int deathsig;

                    ret = get_errno(prctl(arg1, &deathsig, arg3, arg4, arg5));

                    if (!is_error(ret) && arg2

                        && put_user_ual(deathsig, arg2))

                        goto efault;

                }

                break;

            default:

                ret = get_errno(prctl(arg1, arg2, arg3, arg4, arg5));

                break;

            }

        break;

#ifdef TARGET_NR_arch_prctl

    case TARGET_NR_arch_prctl:

#if defined(TARGET_I386) && !defined(TARGET_ABI32)

        ret = do_arch_prctl(cpu_env, arg1, arg2);

        break;

#else

        goto unimplemented;

#endif

#endif

#ifdef TARGET_NR_pread

    case TARGET_NR_pread:

#ifdef TARGET_ARM

        if (((CPUARMState *)cpu_env)->eabi)

            arg4 = arg5;

#endif

        if (!(p = lock_user(VERIFY_WRITE, arg2, arg3, 0)))

            goto efault;

        ret = get_errno(pread(arg1, p, arg3, arg4));

        unlock_user(p, arg2, ret);

        break;

    case TARGET_NR_pwrite:

#ifdef TARGET_ARM

        if (((CPUARMState *)cpu_env)->eabi)

            arg4 = arg5;

#endif

        if (!(p = lock_user(VERIFY_READ, arg2, arg3, 1)))

            goto efault;

        ret = get_errno(pwrite(arg1, p, arg3, arg4));

        unlock_user(p, arg2, 0);

        break;

#endif

#ifdef TARGET_NR_pread64

    case TARGET_NR_pread64:

        if (!(p = lock_user(VERIFY_WRITE, arg2, arg3, 0)))

            goto efault;

        ret = get_errno(pread64(arg1, p, arg3, target_offset64(arg4, arg5)));

        unlock_user(p, arg2, ret);

        break;

    case TARGET_NR_pwrite64:

        if (!(p = lock_user(VERIFY_READ, arg2, arg3, 1)))

            goto efault;

        ret = get_errno(pwrite64(arg1, p, arg3, target_offset64(arg4, arg5)));

        unlock_user(p, arg2, 0);

        break;

#endif

    case TARGET_NR_getcwd:

        if (!(p = lock_user(VERIFY_WRITE, arg1, arg2, 0)))

            goto efault;

        ret = get_errno(sys_getcwd1(p, arg2));

        unlock_user(p, arg1, ret);

        break;

    case TARGET_NR_capget:

        goto unimplemented;

    case TARGET_NR_capset:

        goto unimplemented;

    case TARGET_NR_sigaltstack:

#if defined(TARGET_I386) || defined(TARGET_ARM) || defined(TARGET_MIPS) || \

    defined(TARGET_SPARC) || defined(TARGET_PPC) || defined(TARGET_ALPHA) || \

    defined(TARGET_M68K)

        ret = do_sigaltstack(arg1, arg2, get_sp_from_cpustate((CPUState *)cpu_env));

        break;

#else

        goto unimplemented;

#endif

    case TARGET_NR_sendfile:

        goto unimplemented;

#ifdef TARGET_NR_getpmsg

    case TARGET_NR_getpmsg:

        goto unimplemented;

#endif

#ifdef TARGET_NR_putpmsg

    case TARGET_NR_putpmsg:

        goto unimplemented;

#endif

#ifdef TARGET_NR_vfork

    case TARGET_NR_vfork:

        ret = get_errno(do_fork(cpu_env, CLONE_VFORK | CLONE_VM | SIGCHLD,

                        0, 0, 0, 0));

        break;

#endif

#ifdef TARGET_NR_ugetrlimit

    case TARGET_NR_ugetrlimit:

    {

	struct rlimit rlim;

	ret = get_errno(getrlimit(arg1, &rlim));

	if (!is_error(ret)) {

	    struct target_rlimit *target_rlim;

            if (!lock_user_struct(VERIFY_WRITE, target_rlim, arg2, 0))

                goto efault;

	    target_rlim->rlim_cur = tswapl(rlim.rlim_cur);

	    target_rlim->rlim_max = tswapl(rlim.rlim_max);

            unlock_user_struct(target_rlim, arg2, 1);

	}

	break;

    }

#endif

#ifdef TARGET_NR_truncate64

    case TARGET_NR_truncate64:

        if (!(p = lock_user_string(arg1)))

            goto efault;

	ret = target_truncate64(cpu_env, p, arg2, arg3, arg4);

        unlock_user(p, arg1, 0);

	break;

#endif

#ifdef TARGET_NR_ftruncate64

    case TARGET_NR_ftruncate64:

	ret = target_ftruncate64(cpu_env, arg1, arg2, arg3, arg4);

	break;

#endif

#ifdef TARGET_NR_stat64

    case TARGET_NR_stat64:

        if (!(p = lock_user_string(arg1)))

            goto efault;

        ret = get_errno(stat(path(p), &st));

        unlock_user(p, arg1, 0);

        if (!is_error(ret))

            ret = host_to_target_stat64(cpu_env, arg2, &st);

        break;

#endif

#ifdef TARGET_NR_lstat64

    case TARGET_NR_lstat64:

        if (!(p = lock_user_string(arg1)))

            goto efault;

        ret = get_errno(lstat(path(p), &st));

        unlock_user(p, arg1, 0);

        if (!is_error(ret))

            ret = host_to_target_stat64(cpu_env, arg2, &st);

        break;

#endif

#ifdef TARGET_NR_fstat64

    case TARGET_NR_fstat64:

        ret = get_errno(fstat(arg1, &st));

        if (!is_error(ret))

            ret = host_to_target_stat64(cpu_env, arg2, &st);

        break;

#endif

#if (defined(TARGET_NR_fstatat64) || defined(TARGET_NR_newfstatat)) && \

        (defined(__NR_fstatat64) || defined(__NR_newfstatat))

#ifdef TARGET_NR_fstatat64

    case TARGET_NR_fstatat64:

#endif

#ifdef TARGET_NR_newfstatat

    case TARGET_NR_newfstatat:

#endif

        if (!(p = lock_user_string(arg2)))

            goto efault;

#ifdef __NR_fstatat64

        ret = get_errno(sys_fstatat64(arg1, path(p), &st, arg4));

#else

        ret = get_errno(sys_newfstatat(arg1, path(p), &st, arg4));

#endif

        if (!is_error(ret))

            ret = host_to_target_stat64(cpu_env, arg3, &st);

        break;

#endif

#ifdef USE_UID16

    case TARGET_NR_lchown:

        if (!(p = lock_user_string(arg1)))

            goto efault;

        ret = get_errno(lchown(p, low2highuid(arg2), low2highgid(arg3)));

        unlock_user(p, arg1, 0);

        break;

    case TARGET_NR_getuid:

        ret = get_errno(high2lowuid(getuid()));

        break;

    case TARGET_NR_getgid:

        ret = get_errno(high2lowgid(getgid()));

        break;

    case TARGET_NR_geteuid:

        ret = get_errno(high2lowuid(geteuid()));

        break;

    case TARGET_NR_getegid:

        ret = get_errno(high2lowgid(getegid()));

        break;

    case TARGET_NR_setreuid:

        ret = get_errno(setreuid(low2highuid(arg1), low2highuid(arg2)));

        break;

    case TARGET_NR_setregid:

        ret = get_errno(setregid(low2highgid(arg1), low2highgid(arg2)));

        break;

    case TARGET_NR_getgroups:

        {

            int gidsetsize = arg1;

            uint16_t *target_grouplist;

            gid_t *grouplist;

            int i;



            grouplist = alloca(gidsetsize * sizeof(gid_t));

            ret = get_errno(getgroups(gidsetsize, grouplist));

            if (gidsetsize == 0)

                break;

            if (!is_error(ret)) {

                target_grouplist = lock_user(VERIFY_WRITE, arg2, gidsetsize * 2, 0);

                if (!target_grouplist)

                    goto efault;

                for(i = 0;i < ret; i++)

                    target_grouplist[i] = tswap16(grouplist[i]);

                unlock_user(target_grouplist, arg2, gidsetsize * 2);

            }

        }

        break;

    case TARGET_NR_setgroups:

        {

            int gidsetsize = arg1;

            uint16_t *target_grouplist;

            gid_t *grouplist;

            int i;



            grouplist = alloca(gidsetsize * sizeof(gid_t));

            target_grouplist = lock_user(VERIFY_READ, arg2, gidsetsize * 2, 1);

            if (!target_grouplist) {

                ret = -TARGET_EFAULT;

                goto fail;

            }

            for(i = 0;i < gidsetsize; i++)

                grouplist[i] = tswap16(target_grouplist[i]);

            unlock_user(target_grouplist, arg2, 0);

            ret = get_errno(setgroups(gidsetsize, grouplist));

        }

        break;

    case TARGET_NR_fchown:

        ret = get_errno(fchown(arg1, low2highuid(arg2), low2highgid(arg3)));

        break;

#if defined(TARGET_NR_fchownat) && defined(__NR_fchownat)

    case TARGET_NR_fchownat:

        if (!(p = lock_user_string(arg2))) 

            goto efault;

        ret = get_errno(sys_fchownat(arg1, p, low2highuid(arg3), low2highgid(arg4), arg5));

        unlock_user(p, arg2, 0);

        break;

#endif

#ifdef TARGET_NR_setresuid

    case TARGET_NR_setresuid:

        ret = get_errno(setresuid(low2highuid(arg1),

                                  low2highuid(arg2),

                                  low2highuid(arg3)));

        break;

#endif

#ifdef TARGET_NR_getresuid

    case TARGET_NR_getresuid:

        {

            uid_t ruid, euid, suid;

            ret = get_errno(getresuid(&ruid, &euid, &suid));

            if (!is_error(ret)) {

                if (put_user_u16(high2lowuid(ruid), arg1)

                    || put_user_u16(high2lowuid(euid), arg2)

                    || put_user_u16(high2lowuid(suid), arg3))

                    goto efault;

            }

        }

        break;

#endif

#ifdef TARGET_NR_getresgid

    case TARGET_NR_setresgid:

        ret = get_errno(setresgid(low2highgid(arg1),

                                  low2highgid(arg2),

                                  low2highgid(arg3)));

        break;

#endif

#ifdef TARGET_NR_getresgid

    case TARGET_NR_getresgid:

        {

            gid_t rgid, egid, sgid;

            ret = get_errno(getresgid(&rgid, &egid, &sgid));

            if (!is_error(ret)) {

                if (put_user_u16(high2lowgid(rgid), arg1)

                    || put_user_u16(high2lowgid(egid), arg2)

                    || put_user_u16(high2lowgid(sgid), arg3))

                    goto efault;

            }

        }

        break;

#endif

    case TARGET_NR_chown:

        if (!(p = lock_user_string(arg1)))

            goto efault;

        ret = get_errno(chown(p, low2highuid(arg2), low2highgid(arg3)));

        unlock_user(p, arg1, 0);

        break;

    case TARGET_NR_setuid:

        ret = get_errno(setuid(low2highuid(arg1)));

        break;

    case TARGET_NR_setgid:

        ret = get_errno(setgid(low2highgid(arg1)));

        break;

    case TARGET_NR_setfsuid:

        ret = get_errno(setfsuid(arg1));

        break;

    case TARGET_NR_setfsgid:

        ret = get_errno(setfsgid(arg1));

        break;

#endif /* USE_UID16 */



#ifdef TARGET_NR_lchown32

    case TARGET_NR_lchown32:

        if (!(p = lock_user_string(arg1)))

            goto efault;

        ret = get_errno(lchown(p, arg2, arg3));

        unlock_user(p, arg1, 0);

        break;

#endif

#ifdef TARGET_NR_getuid32

    case TARGET_NR_getuid32:

        ret = get_errno(getuid());

        break;

#endif



#if defined(TARGET_NR_getxuid) && defined(TARGET_ALPHA)

   /* Alpha specific */

    case TARGET_NR_getxuid:

	 {

	    uid_t euid;

	    euid=geteuid();

	    ((CPUAlphaState *)cpu_env)->ir[IR_A4]=euid;

	 }

        ret = get_errno(getuid());

        break;

#endif

#if defined(TARGET_NR_getxgid) && defined(TARGET_ALPHA)

   /* Alpha specific */

    case TARGET_NR_getxgid:

	 {

	    uid_t egid;

	    egid=getegid();

	    ((CPUAlphaState *)cpu_env)->ir[IR_A4]=egid;

	 }

        ret = get_errno(getgid());

        break;

#endif



#ifdef TARGET_NR_getgid32

    case TARGET_NR_getgid32:

        ret = get_errno(getgid());

        break;

#endif

#ifdef TARGET_NR_geteuid32

    case TARGET_NR_geteuid32:

        ret = get_errno(geteuid());

        break;

#endif

#ifdef TARGET_NR_getegid32

    case TARGET_NR_getegid32:

        ret = get_errno(getegid());

        break;

#endif

#ifdef TARGET_NR_setreuid32

    case TARGET_NR_setreuid32:

        ret = get_errno(setreuid(arg1, arg2));

        break;

#endif

#ifdef TARGET_NR_setregid32

    case TARGET_NR_setregid32:

        ret = get_errno(setregid(arg1, arg2));

        break;

#endif

#ifdef TARGET_NR_getgroups32

    case TARGET_NR_getgroups32:

        {

            int gidsetsize = arg1;

            uint32_t *target_grouplist;

            gid_t *grouplist;

            int i;



            grouplist = alloca(gidsetsize * sizeof(gid_t));

            ret = get_errno(getgroups(gidsetsize, grouplist));

            if (gidsetsize == 0)

                break;

            if (!is_error(ret)) {

                target_grouplist = lock_user(VERIFY_WRITE, arg2, gidsetsize * 4, 0);

                if (!target_grouplist) {

                    ret = -TARGET_EFAULT;

                    goto fail;

                }

                for(i = 0;i < ret; i++)

                    target_grouplist[i] = tswap32(grouplist[i]);

                unlock_user(target_grouplist, arg2, gidsetsize * 4);

            }

        }

        break;

#endif

#ifdef TARGET_NR_setgroups32

    case TARGET_NR_setgroups32:

        {

            int gidsetsize = arg1;

            uint32_t *target_grouplist;

            gid_t *grouplist;

            int i;



            grouplist = alloca(gidsetsize * sizeof(gid_t));

            target_grouplist = lock_user(VERIFY_READ, arg2, gidsetsize * 4, 1);

            if (!target_grouplist) {

                ret = -TARGET_EFAULT;

                goto fail;

            }

            for(i = 0;i < gidsetsize; i++)

                grouplist[i] = tswap32(target_grouplist[i]);

            unlock_user(target_grouplist, arg2, 0);

            ret = get_errno(setgroups(gidsetsize, grouplist));

        }

        break;

#endif

#ifdef TARGET_NR_fchown32

    case TARGET_NR_fchown32:

        ret = get_errno(fchown(arg1, arg2, arg3));

        break;

#endif

#ifdef TARGET_NR_setresuid32

    case TARGET_NR_setresuid32:

        ret = get_errno(setresuid(arg1, arg2, arg3));

        break;

#endif

#ifdef TARGET_NR_getresuid32

    case TARGET_NR_getresuid32:

        {

            uid_t ruid, euid, suid;

            ret = get_errno(getresuid(&ruid, &euid, &suid));

            if (!is_error(ret)) {

                if (put_user_u32(ruid, arg1)

                    || put_user_u32(euid, arg2)

                    || put_user_u32(suid, arg3))

                    goto efault;

            }

        }

        break;

#endif

#ifdef TARGET_NR_setresgid32

    case TARGET_NR_setresgid32:

        ret = get_errno(setresgid(arg1, arg2, arg3));

        break;

#endif

#ifdef TARGET_NR_getresgid32

    case TARGET_NR_getresgid32:

        {

            gid_t rgid, egid, sgid;

            ret = get_errno(getresgid(&rgid, &egid, &sgid));

            if (!is_error(ret)) {

                if (put_user_u32(rgid, arg1)

                    || put_user_u32(egid, arg2)

                    || put_user_u32(sgid, arg3))

                    goto efault;

            }

        }

        break;

#endif

#ifdef TARGET_NR_chown32

    case TARGET_NR_chown32:

        if (!(p = lock_user_string(arg1)))

            goto efault;

        ret = get_errno(chown(p, arg2, arg3));

        unlock_user(p, arg1, 0);

        break;

#endif

#ifdef TARGET_NR_setuid32

    case TARGET_NR_setuid32:

        ret = get_errno(setuid(arg1));

        break;

#endif

#ifdef TARGET_NR_setgid32

    case TARGET_NR_setgid32:

        ret = get_errno(setgid(arg1));

        break;

#endif

#ifdef TARGET_NR_setfsuid32

    case TARGET_NR_setfsuid32:

        ret = get_errno(setfsuid(arg1));

        break;

#endif

#ifdef TARGET_NR_setfsgid32

    case TARGET_NR_setfsgid32:

        ret = get_errno(setfsgid(arg1));

        break;

#endif



    case TARGET_NR_pivot_root:

        goto unimplemented;

#ifdef TARGET_NR_mincore

    case TARGET_NR_mincore:

        {

            void *a;

            ret = -TARGET_EFAULT;

            if (!(a = lock_user(VERIFY_READ, arg1,arg2, 0)))

                goto efault;

            if (!(p = lock_user_string(arg3)))

                goto mincore_fail;

            ret = get_errno(mincore(a, arg2, p));

            unlock_user(p, arg3, ret);

            mincore_fail:

            unlock_user(a, arg1, 0);

        }

        break;

#endif

#ifdef TARGET_NR_arm_fadvise64_64

    case TARGET_NR_arm_fadvise64_64:

	{

		/*

		 * arm_fadvise64_64 looks like fadvise64_64 but

		 * with different argument order

		 */

		abi_long temp;

		temp = arg3;

		arg3 = arg4;

		arg4 = temp;

	}

#endif

#if defined(TARGET_NR_fadvise64_64) || defined(TARGET_NR_arm_fadvise64_64) || defined(TARGET_NR_fadvise64)

#ifdef TARGET_NR_fadvise64_64

    case TARGET_NR_fadvise64_64:

#endif

#ifdef TARGET_NR_fadvise64

    case TARGET_NR_fadvise64:

#endif

#ifdef TARGET_S390X

        switch (arg4) {

        case 4: arg4 = POSIX_FADV_NOREUSE + 1; break; /* make sure it's an invalid value */

        case 5: arg4 = POSIX_FADV_NOREUSE + 2; break; /* ditto */

        case 6: arg4 = POSIX_FADV_DONTNEED; break;

        case 7: arg4 = POSIX_FADV_NOREUSE; break;

        default: break;

        }

#endif

        ret = -posix_fadvise(arg1, arg2, arg3, arg4);

	break;

#endif

#ifdef TARGET_NR_madvise

    case TARGET_NR_madvise:

        /* A straight passthrough may not be safe because qemu sometimes

           turns private flie-backed mappings into anonymous mappings.

           This will break MADV_DONTNEED.

           This is a hint, so ignoring and returning success is ok.  */

        ret = get_errno(0);

        break;

#endif

#if TARGET_ABI_BITS == 32

    case TARGET_NR_fcntl64:

    {

	int cmd;

	struct flock64 fl;

	struct target_flock64 *target_fl;

#ifdef TARGET_ARM

	struct target_eabi_flock64 *target_efl;

#endif



	cmd = target_to_host_fcntl_cmd(arg2);

	if (cmd == -TARGET_EINVAL)

		return cmd;



        switch(arg2) {

        case TARGET_F_GETLK64:

#ifdef TARGET_ARM

            if (((CPUARMState *)cpu_env)->eabi) {

                if (!lock_user_struct(VERIFY_READ, target_efl, arg3, 1)) 

                    goto efault;

                fl.l_type = tswap16(target_efl->l_type);

                fl.l_whence = tswap16(target_efl->l_whence);

                fl.l_start = tswap64(target_efl->l_start);

                fl.l_len = tswap64(target_efl->l_len);

                fl.l_pid = tswap32(target_efl->l_pid);

                unlock_user_struct(target_efl, arg3, 0);

            } else

#endif

            {

                if (!lock_user_struct(VERIFY_READ, target_fl, arg3, 1)) 

                    goto efault;

                fl.l_type = tswap16(target_fl->l_type);

                fl.l_whence = tswap16(target_fl->l_whence);

                fl.l_start = tswap64(target_fl->l_start);

                fl.l_len = tswap64(target_fl->l_len);

                fl.l_pid = tswap32(target_fl->l_pid);

                unlock_user_struct(target_fl, arg3, 0);

            }

            ret = get_errno(fcntl(arg1, cmd, &fl));

	    if (ret == 0) {

#ifdef TARGET_ARM

                if (((CPUARMState *)cpu_env)->eabi) {

                    if (!lock_user_struct(VERIFY_WRITE, target_efl, arg3, 0)) 

                        goto efault;

                    target_efl->l_type = tswap16(fl.l_type);

                    target_efl->l_whence = tswap16(fl.l_whence);

                    target_efl->l_start = tswap64(fl.l_start);

                    target_efl->l_len = tswap64(fl.l_len);

                    target_efl->l_pid = tswap32(fl.l_pid);

                    unlock_user_struct(target_efl, arg3, 1);

                } else

#endif

                {

                    if (!lock_user_struct(VERIFY_WRITE, target_fl, arg3, 0)) 

                        goto efault;

                    target_fl->l_type = tswap16(fl.l_type);

                    target_fl->l_whence = tswap16(fl.l_whence);

                    target_fl->l_start = tswap64(fl.l_start);

                    target_fl->l_len = tswap64(fl.l_len);

                    target_fl->l_pid = tswap32(fl.l_pid);

                    unlock_user_struct(target_fl, arg3, 1);

                }

	    }

	    break;



        case TARGET_F_SETLK64:

        case TARGET_F_SETLKW64:

#ifdef TARGET_ARM

            if (((CPUARMState *)cpu_env)->eabi) {

                if (!lock_user_struct(VERIFY_READ, target_efl, arg3, 1)) 

                    goto efault;

                fl.l_type = tswap16(target_efl->l_type);

                fl.l_whence = tswap16(target_efl->l_whence);

                fl.l_start = tswap64(target_efl->l_start);

                fl.l_len = tswap64(target_efl->l_len);

                fl.l_pid = tswap32(target_efl->l_pid);

                unlock_user_struct(target_efl, arg3, 0);

            } else

#endif

            {

                if (!lock_user_struct(VERIFY_READ, target_fl, arg3, 1)) 

                    goto efault;

                fl.l_type = tswap16(target_fl->l_type);

                fl.l_whence = tswap16(target_fl->l_whence);

                fl.l_start = tswap64(target_fl->l_start);

                fl.l_len = tswap64(target_fl->l_len);

                fl.l_pid = tswap32(target_fl->l_pid);

                unlock_user_struct(target_fl, arg3, 0);

            }

            ret = get_errno(fcntl(arg1, cmd, &fl));

	    break;

        default:

            ret = do_fcntl(arg1, arg2, arg3);

            break;

        }

	break;

    }

#endif

#ifdef TARGET_NR_cacheflush

    case TARGET_NR_cacheflush:

        /* self-modifying code is handled automatically, so nothing needed */

        ret = 0;

        break;

#endif

#ifdef TARGET_NR_security

    case TARGET_NR_security:

        goto unimplemented;

#endif

#ifdef TARGET_NR_getpagesize

    case TARGET_NR_getpagesize:

        ret = TARGET_PAGE_SIZE;

        break;

#endif

    case TARGET_NR_gettid:

        ret = get_errno(gettid());

        break;

#ifdef TARGET_NR_readahead

    case TARGET_NR_readahead:

#if TARGET_ABI_BITS == 32

#ifdef TARGET_ARM

        if (((CPUARMState *)cpu_env)->eabi)

        {

            arg2 = arg3;

            arg3 = arg4;

            arg4 = arg5;

        }

#endif

        ret = get_errno(readahead(arg1, ((off64_t)arg3 << 32) | arg2, arg4));

#else

        ret = get_errno(readahead(arg1, arg2, arg3));

#endif

        break;

#endif

#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:

        ret = -TARGET_EOPNOTSUPP;

        break;

#endif

#ifdef TARGET_NR_set_thread_area

    case TARGET_NR_set_thread_area:

#if defined(TARGET_MIPS)

      ((CPUMIPSState *) cpu_env)->tls_value = arg1;

      ret = 0;

      break;

#elif defined(TARGET_CRIS)

      if (arg1 & 0xff)

          ret = -TARGET_EINVAL;

      else {

          ((CPUCRISState *) cpu_env)->pregs[PR_PID] = arg1;

          ret = 0;

      }

      break;

#elif defined(TARGET_I386) && defined(TARGET_ABI32)

      ret = do_set_thread_area(cpu_env, arg1);

      break;

#else

      goto unimplemented_nowarn;

#endif

#endif

#ifdef TARGET_NR_get_thread_area

    case TARGET_NR_get_thread_area:

#if defined(TARGET_I386) && defined(TARGET_ABI32)

        ret = do_get_thread_area(cpu_env, arg1);

#else

        goto unimplemented_nowarn;

#endif

#endif

#ifdef TARGET_NR_getdomainname

    case TARGET_NR_getdomainname:

        goto unimplemented_nowarn;

#endif



#ifdef TARGET_NR_clock_gettime

    case TARGET_NR_clock_gettime:

    {

        struct timespec ts;

        ret = get_errno(clock_gettime(arg1, &ts));

        if (!is_error(ret)) {

            host_to_target_timespec(arg2, &ts);

        }

        break;

    }

#endif

#ifdef TARGET_NR_clock_getres

    case TARGET_NR_clock_getres:

    {

        struct timespec ts;

        ret = get_errno(clock_getres(arg1, &ts));

        if (!is_error(ret)) {

            host_to_target_timespec(arg2, &ts);

        }

        break;

    }

#endif

#ifdef TARGET_NR_clock_nanosleep

    case TARGET_NR_clock_nanosleep:

    {

        struct timespec ts;

        target_to_host_timespec(&ts, arg3);

        ret = get_errno(clock_nanosleep(arg1, arg2, &ts, arg4 ? &ts : NULL));

        if (arg4)

            host_to_target_timespec(arg4, &ts);

        break;

    }

#endif



#if defined(TARGET_NR_set_tid_address) && defined(__NR_set_tid_address)

    case TARGET_NR_set_tid_address:

        ret = get_errno(set_tid_address((int *)g2h(arg1)));

        break;

#endif



#if defined(TARGET_NR_tkill) && defined(__NR_tkill)

    case TARGET_NR_tkill:

        ret = get_errno(sys_tkill((int)arg1, target_to_host_signal(arg2)));

        break;

#endif



#if defined(TARGET_NR_tgkill) && defined(__NR_tgkill)

    case TARGET_NR_tgkill:

	ret = get_errno(sys_tgkill((int)arg1, (int)arg2,

                        target_to_host_signal(arg3)));

	break;

#endif



#ifdef TARGET_NR_set_robust_list

    case TARGET_NR_set_robust_list:

	goto unimplemented_nowarn;

#endif



#if defined(TARGET_NR_utimensat) && defined(__NR_utimensat)

    case TARGET_NR_utimensat:

        {

            struct timespec *tsp, ts[2];

            if (!arg3) {

                tsp = NULL;

            } else {

                target_to_host_timespec(ts, arg3);

                target_to_host_timespec(ts+1, arg3+sizeof(struct target_timespec));

                tsp = ts;

            }

            if (!arg2)

                ret = get_errno(sys_utimensat(arg1, NULL, tsp, arg4));

            else {

                if (!(p = lock_user_string(arg2))) {

                    ret = -TARGET_EFAULT;

                    goto fail;

                }

                ret = get_errno(sys_utimensat(arg1, path(p), tsp, arg4));

                unlock_user(p, arg2, 0);

            }

        }

	break;

#endif

#if defined(CONFIG_USE_NPTL)

    case TARGET_NR_futex:

        ret = do_futex(arg1, arg2, arg3, arg4, arg5, arg6);

        break;

#endif

#if defined(TARGET_NR_inotify_init) && defined(__NR_inotify_init)

    case TARGET_NR_inotify_init:

        ret = get_errno(sys_inotify_init());

        break;

#endif

#if defined(TARGET_NR_inotify_add_watch) && defined(__NR_inotify_add_watch)

    case TARGET_NR_inotify_add_watch:

        p = lock_user_string(arg2);

        ret = get_errno(sys_inotify_add_watch(arg1, path(p), arg3));

        unlock_user(p, arg2, 0);

        break;

#endif

#if defined(TARGET_NR_inotify_rm_watch) && defined(__NR_inotify_rm_watch)

    case TARGET_NR_inotify_rm_watch:

        ret = get_errno(sys_inotify_rm_watch(arg1, arg2));

        break;

#endif



#if defined(TARGET_NR_mq_open) && defined(__NR_mq_open)

    case TARGET_NR_mq_open:

        {

            struct mq_attr posix_mq_attr;



            p = lock_user_string(arg1 - 1);

            if (arg4 != 0)

                copy_from_user_mq_attr (&posix_mq_attr, arg4);

            ret = get_errno(mq_open(p, arg2, arg3, &posix_mq_attr));

            unlock_user (p, arg1, 0);

        }

        break;



    case TARGET_NR_mq_unlink:

        p = lock_user_string(arg1 - 1);

        ret = get_errno(mq_unlink(p));

        unlock_user (p, arg1, 0);

        break;



    case TARGET_NR_mq_timedsend:

        {

            struct timespec ts;



            p = lock_user (VERIFY_READ, arg2, arg3, 1);

            if (arg5 != 0) {

                target_to_host_timespec(&ts, arg5);

                ret = get_errno(mq_timedsend(arg1, p, arg3, arg4, &ts));

                host_to_target_timespec(arg5, &ts);

            }

            else

                ret = get_errno(mq_send(arg1, p, arg3, arg4));

            unlock_user (p, arg2, arg3);

        }

        break;



    case TARGET_NR_mq_timedreceive:

        {

            struct timespec ts;

            unsigned int prio;



            p = lock_user (VERIFY_READ, arg2, arg3, 1);

            if (arg5 != 0) {

                target_to_host_timespec(&ts, arg5);

                ret = get_errno(mq_timedreceive(arg1, p, arg3, &prio, &ts));

                host_to_target_timespec(arg5, &ts);

            }

            else

                ret = get_errno(mq_receive(arg1, p, arg3, &prio));

            unlock_user (p, arg2, arg3);

            if (arg4 != 0)

                put_user_u32(prio, arg4);

        }

        break;



    /* Not implemented for now... */

/*     case TARGET_NR_mq_notify: */

/*         break; */



    case TARGET_NR_mq_getsetattr:

        {

            struct mq_attr posix_mq_attr_in, posix_mq_attr_out;

            ret = 0;

            if (arg3 != 0) {

                ret = mq_getattr(arg1, &posix_mq_attr_out);

                copy_to_user_mq_attr(arg3, &posix_mq_attr_out);

            }

            if (arg2 != 0) {

                copy_from_user_mq_attr(&posix_mq_attr_in, arg2);

                ret |= mq_setattr(arg1, &posix_mq_attr_in, &posix_mq_attr_out);

            }



        }

        break;

#endif



#ifdef CONFIG_SPLICE

#ifdef TARGET_NR_tee

    case TARGET_NR_tee:

        {

            ret = get_errno(tee(arg1,arg2,arg3,arg4));

        }

        break;

#endif

#ifdef TARGET_NR_splice

    case TARGET_NR_splice:

        {

            loff_t loff_in, loff_out;

            loff_t *ploff_in = NULL, *ploff_out = NULL;

            if(arg2) {

                get_user_u64(loff_in, arg2);

                ploff_in = &loff_in;

            }

            if(arg4) {

                get_user_u64(loff_out, arg2);

                ploff_out = &loff_out;

            }

            ret = get_errno(splice(arg1, ploff_in, arg3, ploff_out, arg5, arg6));

        }

        break;

#endif

#ifdef TARGET_NR_vmsplice

	case TARGET_NR_vmsplice:

        {

            int count = arg3;

            struct iovec *vec;



            vec = alloca(count * sizeof(struct iovec));

            if (lock_iovec(VERIFY_READ, vec, arg2, count, 1) < 0)

                goto efault;

            ret = get_errno(vmsplice(arg1, vec, count, arg4));

            unlock_iovec(vec, arg2, count, 0);

        }

        break;

#endif

#endif /* CONFIG_SPLICE */

#ifdef CONFIG_EVENTFD

#if defined(TARGET_NR_eventfd)

    case TARGET_NR_eventfd:

        ret = get_errno(eventfd(arg1, 0));

        break;

#endif

#if defined(TARGET_NR_eventfd2)

    case TARGET_NR_eventfd2:

        ret = get_errno(eventfd(arg1, arg2));

        break;

#endif

#endif /* CONFIG_EVENTFD  */

    default:

    unimplemented:

        gemu_log("qemu: Unsupported syscall: %d\n", num);

#if defined(TARGET_NR_setxattr) || defined(TARGET_NR_get_thread_area) || defined(TARGET_NR_getdomainname) || defined(TARGET_NR_set_robust_list)

    unimplemented_nowarn:

#endif

        ret = -TARGET_ENOSYS;

        break;

    }

fail:

#ifdef DEBUG

    gemu_log(" = " TARGET_ABI_FMT_ld "\n", ret);

#endif

    if(do_strace)

        print_syscall_ret(num, ret);

    return ret;

efault:

    ret = -TARGET_EFAULT;

    goto fail;

}
abi_long do_syscall(void *cpu_env, int num, abi_long arg1,

                    abi_long arg2, abi_long arg3, abi_long arg4,

                    abi_long arg5, abi_long arg6)

{

    abi_long ret;

    struct stat st;

    struct statfs stfs;

    void *p;



#ifdef DEBUG

    gemu_log("syscall %d", num);

#endif

    if(do_strace)

        print_syscall(num, arg1, arg2, arg3, arg4, arg5, arg6);



    switch(num) {

    case TARGET_NR_exit:

#ifdef CONFIG_USE_NPTL

      







      



      if (first_cpu->next_cpu) {

          TaskState *ts;

          CPUState **lastp;

          CPUState *p;



          cpu_list_lock();

          lastp = &first_cpu;

          p = first_cpu;

          while (p && p != (CPUState *)cpu_env) {

              lastp = &p->next_cpu;

              p = p->next_cpu;

          }

          



          if (!p)

              abort();

          

          *lastp = p->next_cpu;

          cpu_list_unlock();

          ts = ((CPUState *)cpu_env)->opaque;

          if (ts->child_tidptr) {

              put_user_u32(0, ts->child_tidptr);

              sys_futex(g2h(ts->child_tidptr), FUTEX_WAKE, INT_MAX,

                        NULL, NULL, 0);

          }

          

          pthread_exit(NULL);

      }

#endif

#ifdef TARGET_GPROF

        _mcleanup();

#endif

        gdb_exit(cpu_env, arg1);

        _exit(arg1);

        ret = 0; 

        break;

    case TARGET_NR_read:

        if (arg3 == 0)

            ret = 0;

        else {

            if (!(p = lock_user(VERIFY_WRITE, arg2, arg3, 0)))

                goto efault;

            ret = get_errno(read(arg1, p, arg3));

            unlock_user(p, arg2, ret);

        }

        break;

    case TARGET_NR_write:

        if (!(p = lock_user(VERIFY_READ, arg2, arg3, 1)))

            goto efault;

        ret = get_errno(write(arg1, p, arg3));

        unlock_user(p, arg2, 0);

        break;

    case TARGET_NR_open:

        if (!(p = lock_user_string(arg1)))

            goto efault;

        ret = get_errno(open(path(p),

                             target_to_host_bitmask(arg2, fcntl_flags_tbl),

                             arg3));

        unlock_user(p, arg1, 0);

        break;

#if defined(TARGET_NR_openat) && defined(__NR_openat)

    case TARGET_NR_openat:

        if (!(p = lock_user_string(arg2)))

            goto efault;

        ret = get_errno(sys_openat(arg1,

                                   path(p),

                                   target_to_host_bitmask(arg3, fcntl_flags_tbl),

                                   arg4));

        unlock_user(p, arg2, 0);

        break;

#endif

    case TARGET_NR_close:

        ret = get_errno(close(arg1));

        break;

    case TARGET_NR_brk:

        ret = do_brk(arg1);

        break;

    case TARGET_NR_fork:

        ret = get_errno(do_fork(cpu_env, SIGCHLD, 0, 0, 0, 0));

        break;

#ifdef TARGET_NR_waitpid

    case TARGET_NR_waitpid:

        {

            int status;

            ret = get_errno(waitpid(arg1, &status, arg3));

            if (!is_error(ret) && arg2

                && put_user_s32(host_to_target_waitstatus(status), arg2))

                goto efault;

        }

        break;

#endif

#ifdef TARGET_NR_waitid

    case TARGET_NR_waitid:

        {

            siginfo_t info;

            info.si_pid = 0;

            ret = get_errno(waitid(arg1, arg2, &info, arg4));

            if (!is_error(ret) && arg3 && info.si_pid != 0) {

                if (!(p = lock_user(VERIFY_WRITE, arg3, sizeof(target_siginfo_t), 0)))

                    goto efault;

                host_to_target_siginfo(p, &info);

                unlock_user(p, arg3, sizeof(target_siginfo_t));

            }

        }

        break;

#endif

#ifdef TARGET_NR_creat 

    case TARGET_NR_creat:

        if (!(p = lock_user_string(arg1)))

            goto efault;

        ret = get_errno(creat(p, arg2));

        unlock_user(p, arg1, 0);

        break;

#endif

    case TARGET_NR_link:

        {

            void * p2;

            p = lock_user_string(arg1);

            p2 = lock_user_string(arg2);

            if (!p || !p2)

                ret = -TARGET_EFAULT;

            else

                ret = get_errno(link(p, p2));

            unlock_user(p2, arg2, 0);

            unlock_user(p, arg1, 0);

        }

        break;

#if defined(TARGET_NR_linkat) && defined(__NR_linkat)

    case TARGET_NR_linkat:

        {

            void * p2 = NULL;

            if (!arg2 || !arg4)

                goto efault;

            p  = lock_user_string(arg2);

            p2 = lock_user_string(arg4);

            if (!p || !p2)

                ret = -TARGET_EFAULT;

            else

                ret = get_errno(sys_linkat(arg1, p, arg3, p2, arg5));

            unlock_user(p, arg2, 0);

            unlock_user(p2, arg4, 0);

        }

        break;

#endif

    case TARGET_NR_unlink:

        if (!(p = lock_user_string(arg1)))

            goto efault;

        ret = get_errno(unlink(p));

        unlock_user(p, arg1, 0);

        break;

#if defined(TARGET_NR_unlinkat) && defined(__NR_unlinkat)

    case TARGET_NR_unlinkat:

        if (!(p = lock_user_string(arg2)))

            goto efault;

        ret = get_errno(sys_unlinkat(arg1, p, arg3));

        unlock_user(p, arg2, 0);

        break;

#endif

    case TARGET_NR_execve:

        {

            char **argp, **envp;

            int argc, envc;

            abi_ulong gp;

            abi_ulong guest_argp;

            abi_ulong guest_envp;

            abi_ulong addr;

            char **q;



            argc = 0;

            guest_argp = arg2;

            for (gp = guest_argp; gp; gp += sizeof(abi_ulong)) {

                if (get_user_ual(addr, gp))

                    goto efault;

                if (!addr)

                    break;

                argc++;

            }

            envc = 0;

            guest_envp = arg3;

            for (gp = guest_envp; gp; gp += sizeof(abi_ulong)) {

                if (get_user_ual(addr, gp))

                    goto efault;

                if (!addr)

                    break;

                envc++;

            }



            argp = alloca((argc + 1) * sizeof(void *));

            envp = alloca((envc + 1) * sizeof(void *));



            for (gp = guest_argp, q = argp; gp;

                  gp += sizeof(abi_ulong), q++) {

                if (get_user_ual(addr, gp))

                    goto execve_efault;

                if (!addr)

                    break;

                if (!(*q = lock_user_string(addr)))

                    goto execve_efault;

            }

            *q = NULL;



            for (gp = guest_envp, q = envp; gp;

                  gp += sizeof(abi_ulong), q++) {

                if (get_user_ual(addr, gp))

                    goto execve_efault;

                if (!addr)

                    break;

                if (!(*q = lock_user_string(addr)))

                    goto execve_efault;

            }

            *q = NULL;



            if (!(p = lock_user_string(arg1)))

                goto execve_efault;

            ret = get_errno(execve(p, argp, envp));

            unlock_user(p, arg1, 0);



            goto execve_end;



        execve_efault:

            ret = -TARGET_EFAULT;



        execve_end:

            for (gp = guest_argp, q = argp; *q;

                  gp += sizeof(abi_ulong), q++) {

                if (get_user_ual(addr, gp)

                    || !addr)

                    break;

                unlock_user(*q, addr, 0);

            }

            for (gp = guest_envp, q = envp; *q;

                  gp += sizeof(abi_ulong), q++) {

                if (get_user_ual(addr, gp)

                    || !addr)

                    break;

                unlock_user(*q, addr, 0);

            }

        }

        break;

    case TARGET_NR_chdir:

        if (!(p = lock_user_string(arg1)))

            goto efault;

        ret = get_errno(chdir(p));

        unlock_user(p, arg1, 0);

        break;

#ifdef TARGET_NR_time

    case TARGET_NR_time:

        {

            time_t host_time;

            ret = get_errno(time(&host_time));

            if (!is_error(ret)

                && arg1

                && put_user_sal(host_time, arg1))

                goto efault;

        }

        break;

#endif

    case TARGET_NR_mknod:

        if (!(p = lock_user_string(arg1)))

            goto efault;

        ret = get_errno(mknod(p, arg2, arg3));

        unlock_user(p, arg1, 0);

        break;

#if defined(TARGET_NR_mknodat) && defined(__NR_mknodat)

    case TARGET_NR_mknodat:

        if (!(p = lock_user_string(arg2)))

            goto efault;

        ret = get_errno(sys_mknodat(arg1, p, arg3, arg4));

        unlock_user(p, arg2, 0);

        break;

#endif

    case TARGET_NR_chmod:

        if (!(p = lock_user_string(arg1)))

            goto efault;

        ret = get_errno(chmod(p, arg2));

        unlock_user(p, arg1, 0);

        break;

#ifdef TARGET_NR_break

    case TARGET_NR_break:

        goto unimplemented;

#endif

#ifdef TARGET_NR_oldstat

    case TARGET_NR_oldstat:

        goto unimplemented;

#endif

    case TARGET_NR_lseek:

        ret = get_errno(lseek(arg1, arg2, arg3));

        break;

#ifdef TARGET_NR_getxpid

    case TARGET_NR_getxpid:

#else

    case TARGET_NR_getpid:

#endif

        ret = get_errno(getpid());

        break;

    case TARGET_NR_mount:

		{

			

			void *p2, *p3;

			p = lock_user_string(arg1);

			p2 = lock_user_string(arg2);

			p3 = lock_user_string(arg3);

                        if (!p || !p2 || !p3)

                            ret = -TARGET_EFAULT;

                        else

                            







                            ret = get_errno(mount(p, p2, p3, (unsigned long)arg4, g2h(arg5)));

                        unlock_user(p, arg1, 0);

                        unlock_user(p2, arg2, 0);

                        unlock_user(p3, arg3, 0);

			break;

		}

#ifdef TARGET_NR_umount

    case TARGET_NR_umount:

        if (!(p = lock_user_string(arg1)))

            goto efault;

        ret = get_errno(umount(p));

        unlock_user(p, arg1, 0);

        break;

#endif

#ifdef TARGET_NR_stime 

    case TARGET_NR_stime:

        {

            time_t host_time;

            if (get_user_sal(host_time, arg1))

                goto efault;

            ret = get_errno(stime(&host_time));

        }

        break;

#endif

    case TARGET_NR_ptrace:

        goto unimplemented;

#ifdef TARGET_NR_alarm 

    case TARGET_NR_alarm:

        ret = alarm(arg1);

        break;

#endif

#ifdef TARGET_NR_oldfstat

    case TARGET_NR_oldfstat:

        goto unimplemented;

#endif

#ifdef TARGET_NR_pause 

    case TARGET_NR_pause:

        ret = get_errno(pause());

        break;

#endif

#ifdef TARGET_NR_utime

    case TARGET_NR_utime:

        {

            struct utimbuf tbuf, *host_tbuf;

            struct target_utimbuf *target_tbuf;

            if (arg2) {

                if (!lock_user_struct(VERIFY_READ, target_tbuf, arg2, 1))

                    goto efault;

                tbuf.actime = tswapl(target_tbuf->actime);

                tbuf.modtime = tswapl(target_tbuf->modtime);

                unlock_user_struct(target_tbuf, arg2, 0);

                host_tbuf = &tbuf;

            } else {

                host_tbuf = NULL;

            }

            if (!(p = lock_user_string(arg1)))

                goto efault;

            ret = get_errno(utime(p, host_tbuf));

            unlock_user(p, arg1, 0);

        }

        break;

#endif

    case TARGET_NR_utimes:

        {

            struct timeval *tvp, tv[2];

            if (arg2) {

                if (copy_from_user_timeval(&tv[0], arg2)

                    || copy_from_user_timeval(&tv[1],

                                              arg2 + sizeof(struct target_timeval)))

                    goto efault;

                tvp = tv;

            } else {

                tvp = NULL;

            }

            if (!(p = lock_user_string(arg1)))

                goto efault;

            ret = get_errno(utimes(p, tvp));

            unlock_user(p, arg1, 0);

        }

        break;

#if defined(TARGET_NR_futimesat) && defined(__NR_futimesat)

    case TARGET_NR_futimesat:

        {

            struct timeval *tvp, tv[2];

            if (arg3) {

                if (copy_from_user_timeval(&tv[0], arg3)

                    || copy_from_user_timeval(&tv[1],

                                              arg3 + sizeof(struct target_timeval)))

                    goto efault;

                tvp = tv;

            } else {

                tvp = NULL;

            }

            if (!(p = lock_user_string(arg2)))

                goto efault;

            ret = get_errno(sys_futimesat(arg1, path(p), tvp));

            unlock_user(p, arg2, 0);

        }

        break;

#endif

#ifdef TARGET_NR_stty

    case TARGET_NR_stty:

        goto unimplemented;

#endif

#ifdef TARGET_NR_gtty

    case TARGET_NR_gtty:

        goto unimplemented;

#endif

    case TARGET_NR_access:

        if (!(p = lock_user_string(arg1)))

            goto efault;

        ret = get_errno(access(path(p), arg2));

        unlock_user(p, arg1, 0);

        break;

#if defined(TARGET_NR_faccessat) && defined(__NR_faccessat)

    case TARGET_NR_faccessat:

        if (!(p = lock_user_string(arg2)))

            goto efault;

        ret = get_errno(sys_faccessat(arg1, p, arg3));

        unlock_user(p, arg2, 0);

        break;

#endif

#ifdef TARGET_NR_nice 

    case TARGET_NR_nice:

        ret = get_errno(nice(arg1));

        break;

#endif

#ifdef TARGET_NR_ftime

    case TARGET_NR_ftime:

        goto unimplemented;

#endif

    case TARGET_NR_sync:

        sync();

        ret = 0;

        break;

    case TARGET_NR_kill:

        ret = get_errno(kill(arg1, target_to_host_signal(arg2)));

        break;

    case TARGET_NR_rename:

        {

            void *p2;

            p = lock_user_string(arg1);

            p2 = lock_user_string(arg2);

            if (!p || !p2)

                ret = -TARGET_EFAULT;

            else

                ret = get_errno(rename(p, p2));

            unlock_user(p2, arg2, 0);

            unlock_user(p, arg1, 0);

        }

        break;

#if defined(TARGET_NR_renameat) && defined(__NR_renameat)

    case TARGET_NR_renameat:

        {

            void *p2;

            p  = lock_user_string(arg2);

            p2 = lock_user_string(arg4);

            if (!p || !p2)

                ret = -TARGET_EFAULT;

            else

                ret = get_errno(sys_renameat(arg1, p, arg3, p2));

            unlock_user(p2, arg4, 0);

            unlock_user(p, arg2, 0);

        }

        break;

#endif

    case TARGET_NR_mkdir:

        if (!(p = lock_user_string(arg1)))

            goto efault;

        ret = get_errno(mkdir(p, arg2));

        unlock_user(p, arg1, 0);

        break;

#if defined(TARGET_NR_mkdirat) && defined(__NR_mkdirat)

    case TARGET_NR_mkdirat:

        if (!(p = lock_user_string(arg2)))

            goto efault;

        ret = get_errno(sys_mkdirat(arg1, p, arg3));

        unlock_user(p, arg2, 0);

        break;

#endif

    case TARGET_NR_rmdir:

        if (!(p = lock_user_string(arg1)))

            goto efault;

        ret = get_errno(rmdir(p));

        unlock_user(p, arg1, 0);

        break;

    case TARGET_NR_dup:

        ret = get_errno(dup(arg1));

        break;

    case TARGET_NR_pipe:

        ret = do_pipe(cpu_env, arg1, 0);

        break;

#ifdef TARGET_NR_pipe2

    case TARGET_NR_pipe2:

        ret = do_pipe(cpu_env, arg1, arg2);

        break;

#endif

    case TARGET_NR_times:

        {

            struct target_tms *tmsp;

            struct tms tms;

            ret = get_errno(times(&tms));

            if (arg1) {

                tmsp = lock_user(VERIFY_WRITE, arg1, sizeof(struct target_tms), 0);

                if (!tmsp)

                    goto efault;

                tmsp->tms_utime = tswapl(host_to_target_clock_t(tms.tms_utime));

                tmsp->tms_stime = tswapl(host_to_target_clock_t(tms.tms_stime));

                tmsp->tms_cutime = tswapl(host_to_target_clock_t(tms.tms_cutime));

                tmsp->tms_cstime = tswapl(host_to_target_clock_t(tms.tms_cstime));

            }

            if (!is_error(ret))

                ret = host_to_target_clock_t(ret);

        }

        break;

#ifdef TARGET_NR_prof

    case TARGET_NR_prof:

        goto unimplemented;

#endif

#ifdef TARGET_NR_signal

    case TARGET_NR_signal:

        goto unimplemented;

#endif

    case TARGET_NR_acct:

        if (arg1 == 0) {

            ret = get_errno(acct(NULL));

        } else {

            if (!(p = lock_user_string(arg1)))

                goto efault;

            ret = get_errno(acct(path(p)));

            unlock_user(p, arg1, 0);

        }

        break;

#ifdef TARGET_NR_umount2 

    case TARGET_NR_umount2:

        if (!(p = lock_user_string(arg1)))

            goto efault;

        ret = get_errno(umount2(p, arg2));

        unlock_user(p, arg1, 0);

        break;

#endif

#ifdef TARGET_NR_lock

    case TARGET_NR_lock:

        goto unimplemented;

#endif

    case TARGET_NR_ioctl:

        ret = do_ioctl(arg1, arg2, arg3);

        break;

    case TARGET_NR_fcntl:

        ret = do_fcntl(arg1, arg2, arg3);

        break;

#ifdef TARGET_NR_mpx

    case TARGET_NR_mpx:

        goto unimplemented;

#endif

    case TARGET_NR_setpgid:

        ret = get_errno(setpgid(arg1, arg2));

        break;

#ifdef TARGET_NR_ulimit

    case TARGET_NR_ulimit:

        goto unimplemented;

#endif

#ifdef TARGET_NR_oldolduname

    case TARGET_NR_oldolduname:

        goto unimplemented;

#endif

    case TARGET_NR_umask:

        ret = get_errno(umask(arg1));

        break;

    case TARGET_NR_chroot:

        if (!(p = lock_user_string(arg1)))

            goto efault;

        ret = get_errno(chroot(p));

        unlock_user(p, arg1, 0);

        break;

    case TARGET_NR_ustat:

        goto unimplemented;

    case TARGET_NR_dup2:

        ret = get_errno(dup2(arg1, arg2));

        break;

#ifdef TARGET_NR_getppid 

    case TARGET_NR_getppid:

        ret = get_errno(getppid());

        break;

#endif

    case TARGET_NR_getpgrp:

        ret = get_errno(getpgrp());

        break;

    case TARGET_NR_setsid:

        ret = get_errno(setsid());

        break;

#ifdef TARGET_NR_sigaction

    case TARGET_NR_sigaction:

        {

#if !defined(TARGET_MIPS)

            struct target_old_sigaction *old_act;

            struct target_sigaction act, oact, *pact;

            if (arg2) {

                if (!lock_user_struct(VERIFY_READ, old_act, arg2, 1))

                    goto efault;

                act._sa_handler = old_act->_sa_handler;

                target_siginitset(&act.sa_mask, old_act->sa_mask);

                act.sa_flags = old_act->sa_flags;

                act.sa_restorer = old_act->sa_restorer;

                unlock_user_struct(old_act, arg2, 0);

                pact = &act;

            } else {

                pact = NULL;

            }

            ret = get_errno(do_sigaction(arg1, pact, &oact));

            if (!is_error(ret) && arg3) {

                if (!lock_user_struct(VERIFY_WRITE, old_act, arg3, 0))

                    goto efault;

                old_act->_sa_handler = oact._sa_handler;

                old_act->sa_mask = oact.sa_mask.sig[0];

                old_act->sa_flags = oact.sa_flags;

                old_act->sa_restorer = oact.sa_restorer;

                unlock_user_struct(old_act, arg3, 1);

            }

#else

	    struct target_sigaction act, oact, *pact, *old_act;



	    if (arg2) {

                if (!lock_user_struct(VERIFY_READ, old_act, arg2, 1))

                    goto efault;

		act._sa_handler = old_act->_sa_handler;

		target_siginitset(&act.sa_mask, old_act->sa_mask.sig[0]);

		act.sa_flags = old_act->sa_flags;

		unlock_user_struct(old_act, arg2, 0);

		pact = &act;

	    } else {

		pact = NULL;

	    }



	    ret = get_errno(do_sigaction(arg1, pact, &oact));



	    if (!is_error(ret) && arg3) {

                if (!lock_user_struct(VERIFY_WRITE, old_act, arg3, 0))

                    goto efault;

		old_act->_sa_handler = oact._sa_handler;

		old_act->sa_flags = oact.sa_flags;

		old_act->sa_mask.sig[0] = oact.sa_mask.sig[0];

		old_act->sa_mask.sig[1] = 0;

		old_act->sa_mask.sig[2] = 0;

		old_act->sa_mask.sig[3] = 0;

		unlock_user_struct(old_act, arg3, 1);

	    }

#endif

        }

        break;

#endif

    case TARGET_NR_rt_sigaction:

        {

            struct target_sigaction *act;

            struct target_sigaction *oact;



            if (arg2) {

                if (!lock_user_struct(VERIFY_READ, act, arg2, 1))

                    goto efault;

            } else

                act = NULL;

            if (arg3) {

                if (!lock_user_struct(VERIFY_WRITE, oact, arg3, 0)) {

                    ret = -TARGET_EFAULT;

                    goto rt_sigaction_fail;

                }

            } else

                oact = NULL;

            ret = get_errno(do_sigaction(arg1, act, oact));

	rt_sigaction_fail:

            if (act)

                unlock_user_struct(act, arg2, 0);

            if (oact)

                unlock_user_struct(oact, arg3, 1);

        }

        break;

#ifdef TARGET_NR_sgetmask 

    case TARGET_NR_sgetmask:

        {

            sigset_t cur_set;

            abi_ulong target_set;

            sigprocmask(0, NULL, &cur_set);

            host_to_target_old_sigset(&target_set, &cur_set);

            ret = target_set;

        }

        break;

#endif

#ifdef TARGET_NR_ssetmask 

    case TARGET_NR_ssetmask:

        {

            sigset_t set, oset, cur_set;

            abi_ulong target_set = arg1;

            sigprocmask(0, NULL, &cur_set);

            target_to_host_old_sigset(&set, &target_set);

            sigorset(&set, &set, &cur_set);

            sigprocmask(SIG_SETMASK, &set, &oset);

            host_to_target_old_sigset(&target_set, &oset);

            ret = target_set;

        }

        break;

#endif

#ifdef TARGET_NR_sigprocmask

    case TARGET_NR_sigprocmask:

        {

            int how = arg1;

            sigset_t set, oldset, *set_ptr;



            if (arg2) {

                switch(how) {

                case TARGET_SIG_BLOCK:

                    how = SIG_BLOCK;

                    break;

                case TARGET_SIG_UNBLOCK:

                    how = SIG_UNBLOCK;

                    break;

                case TARGET_SIG_SETMASK:

                    how = SIG_SETMASK;

                    break;

                default:

                    ret = -TARGET_EINVAL;

                    goto fail;

                }

                if (!(p = lock_user(VERIFY_READ, arg2, sizeof(target_sigset_t), 1)))

                    goto efault;

                target_to_host_old_sigset(&set, p);

                unlock_user(p, arg2, 0);

                set_ptr = &set;

            } else {

                how = 0;

                set_ptr = NULL;

            }

            ret = get_errno(sigprocmask(arg1, set_ptr, &oldset));

            if (!is_error(ret) && arg3) {

                if (!(p = lock_user(VERIFY_WRITE, arg3, sizeof(target_sigset_t), 0)))

                    goto efault;

                host_to_target_old_sigset(p, &oldset);

                unlock_user(p, arg3, sizeof(target_sigset_t));

            }

        }

        break;

#endif

    case TARGET_NR_rt_sigprocmask:

        {

            int how = arg1;

            sigset_t set, oldset, *set_ptr;



            if (arg2) {

                switch(how) {

                case TARGET_SIG_BLOCK:

                    how = SIG_BLOCK;

                    break;

                case TARGET_SIG_UNBLOCK:

                    how = SIG_UNBLOCK;

                    break;

                case TARGET_SIG_SETMASK:

                    how = SIG_SETMASK;

                    break;

                default:

                    ret = -TARGET_EINVAL;

                    goto fail;

                }

                if (!(p = lock_user(VERIFY_READ, arg2, sizeof(target_sigset_t), 1)))

                    goto efault;

                target_to_host_sigset(&set, p);

                unlock_user(p, arg2, 0);

                set_ptr = &set;

            } else {

                how = 0;

                set_ptr = NULL;

            }

            ret = get_errno(sigprocmask(how, set_ptr, &oldset));

            if (!is_error(ret) && arg3) {

                if (!(p = lock_user(VERIFY_WRITE, arg3, sizeof(target_sigset_t), 0)))

                    goto efault;

                host_to_target_sigset(p, &oldset);

                unlock_user(p, arg3, sizeof(target_sigset_t));

            }

        }

        break;

#ifdef TARGET_NR_sigpending

    case TARGET_NR_sigpending:

        {

            sigset_t set;

            ret = get_errno(sigpending(&set));

            if (!is_error(ret)) {

                if (!(p = lock_user(VERIFY_WRITE, arg1, sizeof(target_sigset_t), 0)))

                    goto efault;

                host_to_target_old_sigset(p, &set);

                unlock_user(p, arg1, sizeof(target_sigset_t));

            }

        }

        break;

#endif

    case TARGET_NR_rt_sigpending:

        {

            sigset_t set;

            ret = get_errno(sigpending(&set));

            if (!is_error(ret)) {

                if (!(p = lock_user(VERIFY_WRITE, arg1, sizeof(target_sigset_t), 0)))

                    goto efault;

                host_to_target_sigset(p, &set);

                unlock_user(p, arg1, sizeof(target_sigset_t));

            }

        }

        break;

#ifdef TARGET_NR_sigsuspend

    case TARGET_NR_sigsuspend:

        {

            sigset_t set;

            if (!(p = lock_user(VERIFY_READ, arg1, sizeof(target_sigset_t), 1)))

                goto efault;

            target_to_host_old_sigset(&set, p);

            unlock_user(p, arg1, 0);

            ret = get_errno(sigsuspend(&set));

        }

        break;

#endif

    case TARGET_NR_rt_sigsuspend:

        {

            sigset_t set;

            if (!(p = lock_user(VERIFY_READ, arg1, sizeof(target_sigset_t), 1)))

                goto efault;

            target_to_host_sigset(&set, p);

            unlock_user(p, arg1, 0);

            ret = get_errno(sigsuspend(&set));

        }

        break;

    case TARGET_NR_rt_sigtimedwait:

        {

            sigset_t set;

            struct timespec uts, *puts;

            siginfo_t uinfo;



            if (!(p = lock_user(VERIFY_READ, arg1, sizeof(target_sigset_t), 1)))

                goto efault;

            target_to_host_sigset(&set, p);

            unlock_user(p, arg1, 0);

            if (arg3) {

                puts = &uts;

                target_to_host_timespec(puts, arg3);

            } else {

                puts = NULL;

            }

            ret = get_errno(sigtimedwait(&set, &uinfo, puts));

            if (!is_error(ret) && arg2) {

                if (!(p = lock_user(VERIFY_WRITE, arg2, sizeof(target_siginfo_t), 0)))

                    goto efault;

                host_to_target_siginfo(p, &uinfo);

                unlock_user(p, arg2, sizeof(target_siginfo_t));

            }

        }

        break;

    case TARGET_NR_rt_sigqueueinfo:

        {

            siginfo_t uinfo;

            if (!(p = lock_user(VERIFY_READ, arg3, sizeof(target_sigset_t), 1)))

                goto efault;

            target_to_host_siginfo(&uinfo, p);

            unlock_user(p, arg1, 0);

            ret = get_errno(sys_rt_sigqueueinfo(arg1, arg2, &uinfo));

        }

        break;

#ifdef TARGET_NR_sigreturn

    case TARGET_NR_sigreturn:

        

        ret = do_sigreturn(cpu_env);

        break;

#endif

    case TARGET_NR_rt_sigreturn:

        

        ret = do_rt_sigreturn(cpu_env);

        break;

    case TARGET_NR_sethostname:

        if (!(p = lock_user_string(arg1)))

            goto efault;

        ret = get_errno(sethostname(p, arg2));

        unlock_user(p, arg1, 0);

        break;

    case TARGET_NR_setrlimit:

        {

            

            int resource = arg1;

            struct target_rlimit *target_rlim;

            struct rlimit rlim;

            if (!lock_user_struct(VERIFY_READ, target_rlim, arg2, 1))

                goto efault;

            rlim.rlim_cur = tswapl(target_rlim->rlim_cur);

            rlim.rlim_max = tswapl(target_rlim->rlim_max);

            unlock_user_struct(target_rlim, arg2, 0);

            ret = get_errno(setrlimit(resource, &rlim));

        }

        break;

    case TARGET_NR_getrlimit:

        {

            

            int resource = arg1;

            struct target_rlimit *target_rlim;

            struct rlimit rlim;



            ret = get_errno(getrlimit(resource, &rlim));

            if (!is_error(ret)) {

                if (!lock_user_struct(VERIFY_WRITE, target_rlim, arg2, 0))

                    goto efault;

                target_rlim->rlim_cur = tswapl(rlim.rlim_cur);

                target_rlim->rlim_max = tswapl(rlim.rlim_max);

                unlock_user_struct(target_rlim, arg2, 1);

            }

        }

        break;

    case TARGET_NR_getrusage:

        {

            struct rusage rusage;

            ret = get_errno(getrusage(arg1, &rusage));

            if (!is_error(ret)) {

                host_to_target_rusage(arg2, &rusage);

            }

        }

        break;

    case TARGET_NR_gettimeofday:

        {

            struct timeval tv;

            ret = get_errno(gettimeofday(&tv, NULL));

            if (!is_error(ret)) {

                if (copy_to_user_timeval(arg1, &tv))

                    goto efault;

            }

        }

        break;

    case TARGET_NR_settimeofday:

        {

            struct timeval tv;

            if (copy_from_user_timeval(&tv, arg1))

                goto efault;

            ret = get_errno(settimeofday(&tv, NULL));

        }

        break;

#ifdef TARGET_NR_select

    case TARGET_NR_select:

        {

            struct target_sel_arg_struct *sel;

            abi_ulong inp, outp, exp, tvp;

            long nsel;



            if (!lock_user_struct(VERIFY_READ, sel, arg1, 1))

                goto efault;

            nsel = tswapl(sel->n);

            inp = tswapl(sel->inp);

            outp = tswapl(sel->outp);

            exp = tswapl(sel->exp);

            tvp = tswapl(sel->tvp);

            unlock_user_struct(sel, arg1, 0);

            ret = do_select(nsel, inp, outp, exp, tvp);

        }

        break;

#endif

    case TARGET_NR_symlink:

        {

            void *p2;

            p = lock_user_string(arg1);

            p2 = lock_user_string(arg2);

            if (!p || !p2)

                ret = -TARGET_EFAULT;

            else

                ret = get_errno(symlink(p, p2));

            unlock_user(p2, arg2, 0);

            unlock_user(p, arg1, 0);

        }

        break;

#if defined(TARGET_NR_symlinkat) && defined(__NR_symlinkat)

    case TARGET_NR_symlinkat:

        {

            void *p2;

            p  = lock_user_string(arg1);

            p2 = lock_user_string(arg3);

            if (!p || !p2)

                ret = -TARGET_EFAULT;

            else

                ret = get_errno(sys_symlinkat(p, arg2, p2));

            unlock_user(p2, arg3, 0);

            unlock_user(p, arg1, 0);

        }

        break;

#endif

#ifdef TARGET_NR_oldlstat

    case TARGET_NR_oldlstat:

        goto unimplemented;

#endif

    case TARGET_NR_readlink:

        {

            void *p2, *temp;

            p = lock_user_string(arg1);

            p2 = lock_user(VERIFY_WRITE, arg2, arg3, 0);

            if (!p || !p2)

                ret = -TARGET_EFAULT;

            else {

                if (strncmp((const char *)p, "/proc/self/exe", 14) == 0) {

                    char real[PATH_MAX];

                    temp = realpath(exec_path,real);

                    ret = (temp==NULL) ? get_errno(-1) : strlen(real) ;

                    snprintf((char *)p2, arg3, "%s", real);

                    }

                else

                    ret = get_errno(readlink(path(p), p2, arg3));

            }

            unlock_user(p2, arg2, ret);

            unlock_user(p, arg1, 0);

        }

        break;

#if defined(TARGET_NR_readlinkat) && defined(__NR_readlinkat)

    case TARGET_NR_readlinkat:

        {

            void *p2;

            p  = lock_user_string(arg2);

            p2 = lock_user(VERIFY_WRITE, arg3, arg4, 0);

            if (!p || !p2)

        	ret = -TARGET_EFAULT;

            else

                ret = get_errno(sys_readlinkat(arg1, path(p), p2, arg4));

            unlock_user(p2, arg3, ret);

            unlock_user(p, arg2, 0);

        }

        break;

#endif

#ifdef TARGET_NR_uselib

    case TARGET_NR_uselib:

        goto unimplemented;

#endif

#ifdef TARGET_NR_swapon

    case TARGET_NR_swapon:

        if (!(p = lock_user_string(arg1)))

            goto efault;

        ret = get_errno(swapon(p, arg2));

        unlock_user(p, arg1, 0);

        break;

#endif

    case TARGET_NR_reboot:

        goto unimplemented;

#ifdef TARGET_NR_readdir

    case TARGET_NR_readdir:

        goto unimplemented;

#endif

#ifdef TARGET_NR_mmap

    case TARGET_NR_mmap:

#if (defined(TARGET_I386) && defined(TARGET_ABI32)) || defined(TARGET_ARM) || defined(TARGET_M68K) || defined(TARGET_CRIS) || defined(TARGET_MICROBLAZE)

        {

            abi_ulong *v;

            abi_ulong v1, v2, v3, v4, v5, v6;

            if (!(v = lock_user(VERIFY_READ, arg1, 6 * sizeof(abi_ulong), 1)))

                goto efault;

            v1 = tswapl(v[0]);

            v2 = tswapl(v[1]);

            v3 = tswapl(v[2]);

            v4 = tswapl(v[3]);

            v5 = tswapl(v[4]);

            v6 = tswapl(v[5]);

            unlock_user(v, arg1, 0);

            ret = get_errno(target_mmap(v1, v2, v3,

                                        target_to_host_bitmask(v4, mmap_flags_tbl),

                                        v5, v6));

        }

#else

        ret = get_errno(target_mmap(arg1, arg2, arg3,

                                    target_to_host_bitmask(arg4, mmap_flags_tbl),

                                    arg5,

                                    arg6));

#endif

        break;

#endif

#ifdef TARGET_NR_mmap2

    case TARGET_NR_mmap2:

#ifndef MMAP_SHIFT

#define MMAP_SHIFT 12

#endif

        ret = get_errno(target_mmap(arg1, arg2, arg3,

                                    target_to_host_bitmask(arg4, mmap_flags_tbl),

                                    arg5,

                                    arg6 << MMAP_SHIFT));

        break;

#endif

    case TARGET_NR_munmap:

        ret = get_errno(target_munmap(arg1, arg2));

        break;

    case TARGET_NR_mprotect:

        ret = get_errno(target_mprotect(arg1, arg2, arg3));

        break;

#ifdef TARGET_NR_mremap

    case TARGET_NR_mremap:

        ret = get_errno(target_mremap(arg1, arg2, arg3, arg4, arg5));

        break;

#endif

        

#ifdef TARGET_NR_msync

    case TARGET_NR_msync:

        ret = get_errno(msync(g2h(arg1), arg2, arg3));

        break;

#endif

#ifdef TARGET_NR_mlock

    case TARGET_NR_mlock:

        ret = get_errno(mlock(g2h(arg1), arg2));

        break;

#endif

#ifdef TARGET_NR_munlock

    case TARGET_NR_munlock:

        ret = get_errno(munlock(g2h(arg1), arg2));

        break;

#endif

#ifdef TARGET_NR_mlockall

    case TARGET_NR_mlockall:

        ret = get_errno(mlockall(arg1));

        break;

#endif

#ifdef TARGET_NR_munlockall

    case TARGET_NR_munlockall:

        ret = get_errno(munlockall());

        break;

#endif

    case TARGET_NR_truncate:

        if (!(p = lock_user_string(arg1)))

            goto efault;

        ret = get_errno(truncate(p, arg2));

        unlock_user(p, arg1, 0);

        break;

    case TARGET_NR_ftruncate:

        ret = get_errno(ftruncate(arg1, arg2));

        break;

    case TARGET_NR_fchmod:

        ret = get_errno(fchmod(arg1, arg2));

        break;

#if defined(TARGET_NR_fchmodat) && defined(__NR_fchmodat)

    case TARGET_NR_fchmodat:

        if (!(p = lock_user_string(arg2)))

            goto efault;

        ret = get_errno(sys_fchmodat(arg1, p, arg3));

        unlock_user(p, arg2, 0);

        break;

#endif

    case TARGET_NR_getpriority:

        





        ret = sys_getpriority(arg1, arg2);

        break;

    case TARGET_NR_setpriority:

        ret = get_errno(setpriority(arg1, arg2, arg3));

        break;

#ifdef TARGET_NR_profil

    case TARGET_NR_profil:

        goto unimplemented;

#endif

    case TARGET_NR_statfs:

        if (!(p = lock_user_string(arg1)))

            goto efault;

        ret = get_errno(statfs(path(p), &stfs));

        unlock_user(p, arg1, 0);

    convert_statfs:

        if (!is_error(ret)) {

            struct target_statfs *target_stfs;



            if (!lock_user_struct(VERIFY_WRITE, target_stfs, arg2, 0))

                goto efault;

            __put_user(stfs.f_type, &target_stfs->f_type);

            __put_user(stfs.f_bsize, &target_stfs->f_bsize);

            __put_user(stfs.f_blocks, &target_stfs->f_blocks);

            __put_user(stfs.f_bfree, &target_stfs->f_bfree);

            __put_user(stfs.f_bavail, &target_stfs->f_bavail);

            __put_user(stfs.f_files, &target_stfs->f_files);

            __put_user(stfs.f_ffree, &target_stfs->f_ffree);

            __put_user(stfs.f_fsid.__val[0], &target_stfs->f_fsid.val[0]);

            __put_user(stfs.f_fsid.__val[1], &target_stfs->f_fsid.val[1]);

            __put_user(stfs.f_namelen, &target_stfs->f_namelen);

            unlock_user_struct(target_stfs, arg2, 1);

        }

        break;

    case TARGET_NR_fstatfs:

        ret = get_errno(fstatfs(arg1, &stfs));

        goto convert_statfs;

#ifdef TARGET_NR_statfs64

    case TARGET_NR_statfs64:

        if (!(p = lock_user_string(arg1)))

            goto efault;

        ret = get_errno(statfs(path(p), &stfs));

        unlock_user(p, arg1, 0);

    convert_statfs64:

        if (!is_error(ret)) {

            struct target_statfs64 *target_stfs;



            if (!lock_user_struct(VERIFY_WRITE, target_stfs, arg3, 0))

                goto efault;

            __put_user(stfs.f_type, &target_stfs->f_type);

            __put_user(stfs.f_bsize, &target_stfs->f_bsize);

            __put_user(stfs.f_blocks, &target_stfs->f_blocks);

            __put_user(stfs.f_bfree, &target_stfs->f_bfree);

            __put_user(stfs.f_bavail, &target_stfs->f_bavail);

            __put_user(stfs.f_files, &target_stfs->f_files);

            __put_user(stfs.f_ffree, &target_stfs->f_ffree);

            __put_user(stfs.f_fsid.__val[0], &target_stfs->f_fsid.val[0]);

            __put_user(stfs.f_fsid.__val[1], &target_stfs->f_fsid.val[1]);

            __put_user(stfs.f_namelen, &target_stfs->f_namelen);

            unlock_user_struct(target_stfs, arg3, 1);

        }

        break;

    case TARGET_NR_fstatfs64:

        ret = get_errno(fstatfs(arg1, &stfs));

        goto convert_statfs64;

#endif

#ifdef TARGET_NR_ioperm

    case TARGET_NR_ioperm:

        goto unimplemented;

#endif

#ifdef TARGET_NR_socketcall

    case TARGET_NR_socketcall:

        ret = do_socketcall(arg1, arg2);

        break;

#endif

#ifdef TARGET_NR_accept

    case TARGET_NR_accept:

        ret = do_accept(arg1, arg2, arg3);

        break;

#endif

#ifdef TARGET_NR_bind

    case TARGET_NR_bind:

        ret = do_bind(arg1, arg2, arg3);

        break;

#endif

#ifdef TARGET_NR_connect

    case TARGET_NR_connect:

        ret = do_connect(arg1, arg2, arg3);

        break;

#endif

#ifdef TARGET_NR_getpeername

    case TARGET_NR_getpeername:

        ret = do_getpeername(arg1, arg2, arg3);

        break;

#endif

#ifdef TARGET_NR_getsockname

    case TARGET_NR_getsockname:

        ret = do_getsockname(arg1, arg2, arg3);

        break;

#endif

#ifdef TARGET_NR_getsockopt

    case TARGET_NR_getsockopt:

        ret = do_getsockopt(arg1, arg2, arg3, arg4, arg5);

        break;

#endif

#ifdef TARGET_NR_listen

    case TARGET_NR_listen:

        ret = get_errno(listen(arg1, arg2));

        break;

#endif

#ifdef TARGET_NR_recv

    case TARGET_NR_recv:

        ret = do_recvfrom(arg1, arg2, arg3, arg4, 0, 0);

        break;

#endif

#ifdef TARGET_NR_recvfrom

    case TARGET_NR_recvfrom:

        ret = do_recvfrom(arg1, arg2, arg3, arg4, arg5, arg6);

        break;

#endif

#ifdef TARGET_NR_recvmsg

    case TARGET_NR_recvmsg:

        ret = do_sendrecvmsg(arg1, arg2, arg3, 0);

        break;

#endif

#ifdef TARGET_NR_send

    case TARGET_NR_send:

        ret = do_sendto(arg1, arg2, arg3, arg4, 0, 0);

        break;

#endif

#ifdef TARGET_NR_sendmsg

    case TARGET_NR_sendmsg:

        ret = do_sendrecvmsg(arg1, arg2, arg3, 1);

        break;

#endif

#ifdef TARGET_NR_sendto

    case TARGET_NR_sendto:

        ret = do_sendto(arg1, arg2, arg3, arg4, arg5, arg6);

        break;

#endif

#ifdef TARGET_NR_shutdown

    case TARGET_NR_shutdown:

        ret = get_errno(shutdown(arg1, arg2));

        break;

#endif

#ifdef TARGET_NR_socket

    case TARGET_NR_socket:

        ret = do_socket(arg1, arg2, arg3);

        break;

#endif

#ifdef TARGET_NR_socketpair

    case TARGET_NR_socketpair:

        ret = do_socketpair(arg1, arg2, arg3, arg4);

        break;

#endif

#ifdef TARGET_NR_setsockopt

    case TARGET_NR_setsockopt:

        ret = do_setsockopt(arg1, arg2, arg3, arg4, (socklen_t) arg5);

        break;

#endif



    case TARGET_NR_syslog:

        if (!(p = lock_user_string(arg2)))

            goto efault;

        ret = get_errno(sys_syslog((int)arg1, p, (int)arg3));

        unlock_user(p, arg2, 0);

        break;



    case TARGET_NR_setitimer:

        {

            struct itimerval value, ovalue, *pvalue;



            if (arg2) {

                pvalue = &value;

                if (copy_from_user_timeval(&pvalue->it_interval, arg2)

                    || copy_from_user_timeval(&pvalue->it_value,

                                              arg2 + sizeof(struct target_timeval)))

                    goto efault;

            } else {

                pvalue = NULL;

            }

            ret = get_errno(setitimer(arg1, pvalue, &ovalue));

            if (!is_error(ret) && arg3) {

                if (copy_to_user_timeval(arg3,

                                         &ovalue.it_interval)

                    || copy_to_user_timeval(arg3 + sizeof(struct target_timeval),

                                            &ovalue.it_value))

                    goto efault;

            }

        }

        break;

    case TARGET_NR_getitimer:

        {

            struct itimerval value;



            ret = get_errno(getitimer(arg1, &value));

            if (!is_error(ret) && arg2) {

                if (copy_to_user_timeval(arg2,

                                         &value.it_interval)

                    || copy_to_user_timeval(arg2 + sizeof(struct target_timeval),

                                            &value.it_value))

                    goto efault;

            }

        }

        break;

    case TARGET_NR_stat:

        if (!(p = lock_user_string(arg1)))

            goto efault;

        ret = get_errno(stat(path(p), &st));

        unlock_user(p, arg1, 0);

        goto do_stat;

    case TARGET_NR_lstat:

        if (!(p = lock_user_string(arg1)))

            goto efault;

        ret = get_errno(lstat(path(p), &st));

        unlock_user(p, arg1, 0);

        goto do_stat;

    case TARGET_NR_fstat:

        {

            ret = get_errno(fstat(arg1, &st));

        do_stat:

            if (!is_error(ret)) {

                struct target_stat *target_st;



                if (!lock_user_struct(VERIFY_WRITE, target_st, arg2, 0))

                    goto efault;


                __put_user(st.st_dev, &target_st->st_dev);

                __put_user(st.st_ino, &target_st->st_ino);

                __put_user(st.st_mode, &target_st->st_mode);

                __put_user(st.st_uid, &target_st->st_uid);

                __put_user(st.st_gid, &target_st->st_gid);

                __put_user(st.st_nlink, &target_st->st_nlink);

                __put_user(st.st_rdev, &target_st->st_rdev);

                __put_user(st.st_size, &target_st->st_size);

                __put_user(st.st_blksize, &target_st->st_blksize);

                __put_user(st.st_blocks, &target_st->st_blocks);

                __put_user(st.st_atime, &target_st->target_st_atime);

                __put_user(st.st_mtime, &target_st->target_st_mtime);

                __put_user(st.st_ctime, &target_st->target_st_ctime);

                unlock_user_struct(target_st, arg2, 1);

            }

        }

        break;

#ifdef TARGET_NR_olduname

    case TARGET_NR_olduname:

        goto unimplemented;

#endif

#ifdef TARGET_NR_iopl

    case TARGET_NR_iopl:

        goto unimplemented;

#endif

    case TARGET_NR_vhangup:

        ret = get_errno(vhangup());

        break;

#ifdef TARGET_NR_idle

    case TARGET_NR_idle:

        goto unimplemented;

#endif

#ifdef TARGET_NR_syscall

    case TARGET_NR_syscall:

    	ret = do_syscall(cpu_env,arg1 & 0xffff,arg2,arg3,arg4,arg5,arg6,0);

    	break;

#endif

    case TARGET_NR_wait4:

        {

            int status;

            abi_long status_ptr = arg2;

            struct rusage rusage, *rusage_ptr;

            abi_ulong target_rusage = arg4;

            if (target_rusage)

                rusage_ptr = &rusage;

            else

                rusage_ptr = NULL;

            ret = get_errno(wait4(arg1, &status, arg3, rusage_ptr));

            if (!is_error(ret)) {

                if (status_ptr) {

                    status = host_to_target_waitstatus(status);

                    if (put_user_s32(status, status_ptr))

                        goto efault;

                }

                if (target_rusage)

                    host_to_target_rusage(target_rusage, &rusage);

            }

        }

        break;

#ifdef TARGET_NR_swapoff

    case TARGET_NR_swapoff:

        if (!(p = lock_user_string(arg1)))

            goto efault;

        ret = get_errno(swapoff(p));

        unlock_user(p, arg1, 0);

        break;

#endif

    case TARGET_NR_sysinfo:

        {

            struct target_sysinfo *target_value;

            struct sysinfo value;

            ret = get_errno(sysinfo(&value));

            if (!is_error(ret) && arg1)

            {

                if (!lock_user_struct(VERIFY_WRITE, target_value, arg1, 0))

                    goto efault;

                __put_user(value.uptime, &target_value->uptime);

                __put_user(value.loads[0], &target_value->loads[0]);

                __put_user(value.loads[1], &target_value->loads[1]);

                __put_user(value.loads[2], &target_value->loads[2]);

                __put_user(value.totalram, &target_value->totalram);

                __put_user(value.freeram, &target_value->freeram);

                __put_user(value.sharedram, &target_value->sharedram);

                __put_user(value.bufferram, &target_value->bufferram);

                __put_user(value.totalswap, &target_value->totalswap);

                __put_user(value.freeswap, &target_value->freeswap);

                __put_user(value.procs, &target_value->procs);

                __put_user(value.totalhigh, &target_value->totalhigh);

                __put_user(value.freehigh, &target_value->freehigh);

                __put_user(value.mem_unit, &target_value->mem_unit);

                unlock_user_struct(target_value, arg1, 1);

            }

        }

        break;

#ifdef TARGET_NR_ipc

    case TARGET_NR_ipc:

	ret = do_ipc(arg1, arg2, arg3, arg4, arg5, arg6);

	break;

#endif

#ifdef TARGET_NR_semget

    case TARGET_NR_semget:

        ret = get_errno(semget(arg1, arg2, arg3));

        break;

#endif

#ifdef TARGET_NR_semop

    case TARGET_NR_semop:

        ret = get_errno(do_semop(arg1, arg2, arg3));

        break;

#endif

#ifdef TARGET_NR_semctl

    case TARGET_NR_semctl:

        ret = do_semctl(arg1, arg2, arg3, (union target_semun)(abi_ulong)arg4);

        break;

#endif

#ifdef TARGET_NR_msgctl

    case TARGET_NR_msgctl:

        ret = do_msgctl(arg1, arg2, arg3);

        break;

#endif

#ifdef TARGET_NR_msgget

    case TARGET_NR_msgget:

        ret = get_errno(msgget(arg1, arg2));

        break;

#endif

#ifdef TARGET_NR_msgrcv

    case TARGET_NR_msgrcv:

        ret = do_msgrcv(arg1, arg2, arg3, arg4, arg5);

        break;

#endif

#ifdef TARGET_NR_msgsnd

    case TARGET_NR_msgsnd:

        ret = do_msgsnd(arg1, arg2, arg3, arg4);

        break;

#endif

#ifdef TARGET_NR_shmget

    case TARGET_NR_shmget:

        ret = get_errno(shmget(arg1, arg2, arg3));

        break;

#endif

#ifdef TARGET_NR_shmctl

    case TARGET_NR_shmctl:

        ret = do_shmctl(arg1, arg2, arg3);

        break;

#endif

#ifdef TARGET_NR_shmat

    case TARGET_NR_shmat:

        ret = do_shmat(arg1, arg2, arg3);

        break;

#endif

#ifdef TARGET_NR_shmdt

    case TARGET_NR_shmdt:

        ret = do_shmdt(arg1);

        break;

#endif

    case TARGET_NR_fsync:

        ret = get_errno(fsync(arg1));

        break;

    case TARGET_NR_clone:

#if defined(TARGET_SH4)

        ret = get_errno(do_fork(cpu_env, arg1, arg2, arg3, arg5, arg4));

#elif defined(TARGET_CRIS)

        ret = get_errno(do_fork(cpu_env, arg2, arg1, arg3, arg4, arg5));

#else

        ret = get_errno(do_fork(cpu_env, arg1, arg2, arg3, arg4, arg5));

#endif

        break;

#ifdef __NR_exit_group

        

    case TARGET_NR_exit_group:

#ifdef TARGET_GPROF

        _mcleanup();

#endif

        gdb_exit(cpu_env, arg1);

        ret = get_errno(exit_group(arg1));

        break;

#endif

    case TARGET_NR_setdomainname:

        if (!(p = lock_user_string(arg1)))

            goto efault;

        ret = get_errno(setdomainname(p, arg2));

        unlock_user(p, arg1, 0);

        break;

    case TARGET_NR_uname:

        

        {

            struct new_utsname * buf;



            if (!lock_user_struct(VERIFY_WRITE, buf, arg1, 0))

                goto efault;

            ret = get_errno(sys_uname(buf));

            if (!is_error(ret)) {

                



                strcpy (buf->machine, UNAME_MACHINE);

                

                if (qemu_uname_release && *qemu_uname_release)

                  strcpy (buf->release, qemu_uname_release);

            }

            unlock_user_struct(buf, arg1, 1);

        }

        break;

#ifdef TARGET_I386

    case TARGET_NR_modify_ldt:

        ret = do_modify_ldt(cpu_env, arg1, arg2, arg3);

        break;

#if !defined(TARGET_X86_64)

    case TARGET_NR_vm86old:

        goto unimplemented;

    case TARGET_NR_vm86:

        ret = do_vm86(cpu_env, arg1, arg2);

        break;

#endif

#endif

    case TARGET_NR_adjtimex:

        goto unimplemented;

#ifdef TARGET_NR_create_module

    case TARGET_NR_create_module:

#endif

    case TARGET_NR_init_module:

    case TARGET_NR_delete_module:

#ifdef TARGET_NR_get_kernel_syms

    case TARGET_NR_get_kernel_syms:

#endif

        goto unimplemented;

    case TARGET_NR_quotactl:

        goto unimplemented;

    case TARGET_NR_getpgid:

        ret = get_errno(getpgid(arg1));

        break;

    case TARGET_NR_fchdir:

        ret = get_errno(fchdir(arg1));

        break;

#ifdef TARGET_NR_bdflush 

    case TARGET_NR_bdflush:

        goto unimplemented;

#endif

#ifdef TARGET_NR_sysfs

    case TARGET_NR_sysfs:

        goto unimplemented;

#endif

    case TARGET_NR_personality:

        ret = get_errno(personality(arg1));

        break;

#ifdef TARGET_NR_afs_syscall

    case TARGET_NR_afs_syscall:

        goto unimplemented;

#endif

#ifdef TARGET_NR__llseek 

    case TARGET_NR__llseek:

        {

#if defined (__x86_64__)

            ret = get_errno(lseek(arg1, ((uint64_t )arg2 << 32) | arg3, arg5));

            if (put_user_s64(ret, arg4))

                goto efault;

#else

            int64_t res;

            ret = get_errno(_llseek(arg1, arg2, arg3, &res, arg5));

            if (put_user_s64(res, arg4))

                goto efault;

#endif

        }

        break;

#endif

    case TARGET_NR_getdents:

#if TARGET_ABI_BITS == 32 && HOST_LONG_BITS == 64

        {

            struct target_dirent *target_dirp;

            struct linux_dirent *dirp;

            abi_long count = arg3;



	    dirp = malloc(count);

	    if (!dirp) {

                ret = -TARGET_ENOMEM;

                goto fail;

            }



            ret = get_errno(sys_getdents(arg1, dirp, count));

            if (!is_error(ret)) {

                struct linux_dirent *de;

		struct target_dirent *tde;

                int len = ret;

                int reclen, treclen;

		int count1, tnamelen;



		count1 = 0;

                de = dirp;

                if (!(target_dirp = lock_user(VERIFY_WRITE, arg2, count, 0)))

                    goto efault;

		tde = target_dirp;

                while (len > 0) {

                    reclen = de->d_reclen;

		    treclen = reclen - (2 * (sizeof(long) - sizeof(abi_long)));

                    tde->d_reclen = tswap16(treclen);

                    tde->d_ino = tswapl(de->d_ino);

                    tde->d_off = tswapl(de->d_off);

		    tnamelen = treclen - (2 * sizeof(abi_long) + 2);

		    if (tnamelen > 256)

                        tnamelen = 256;

                    

                    pstrcpy(tde->d_name, tnamelen, de->d_name);

                    de = (struct linux_dirent *)((char *)de + reclen);

                    len -= reclen;

                    tde = (struct target_dirent *)((char *)tde + treclen);

		    count1 += treclen;

                }

		ret = count1;

                unlock_user(target_dirp, arg2, ret);

            }

	    free(dirp);

        }

#else

        {

            struct linux_dirent *dirp;

            abi_long count = arg3;



            if (!(dirp = lock_user(VERIFY_WRITE, arg2, count, 0)))

                goto efault;

            ret = get_errno(sys_getdents(arg1, dirp, count));

            if (!is_error(ret)) {

                struct linux_dirent *de;

                int len = ret;

                int reclen;

                de = dirp;

                while (len > 0) {

                    reclen = de->d_reclen;

                    if (reclen > len)

                        break;

                    de->d_reclen = tswap16(reclen);

                    tswapls(&de->d_ino);

                    tswapls(&de->d_off);

                    de = (struct linux_dirent *)((char *)de + reclen);

                    len -= reclen;

                }

            }

            unlock_user(dirp, arg2, ret);

        }

#endif

        break;

#if defined(TARGET_NR_getdents64) && defined(__NR_getdents64)

    case TARGET_NR_getdents64:

        {

            struct linux_dirent64 *dirp;

            abi_long count = arg3;

            if (!(dirp = lock_user(VERIFY_WRITE, arg2, count, 0)))

                goto efault;

            ret = get_errno(sys_getdents64(arg1, dirp, count));

            if (!is_error(ret)) {

                struct linux_dirent64 *de;

                int len = ret;

                int reclen;

                de = dirp;

                while (len > 0) {

                    reclen = de->d_reclen;

                    if (reclen > len)

                        break;

                    de->d_reclen = tswap16(reclen);

                    tswap64s((uint64_t *)&de->d_ino);

                    tswap64s((uint64_t *)&de->d_off);

                    de = (struct linux_dirent64 *)((char *)de + reclen);

                    len -= reclen;

                }

            }

            unlock_user(dirp, arg2, ret);

        }

        break;

#endif 

#ifdef TARGET_NR__newselect

    case TARGET_NR__newselect:

        ret = do_select(arg1, arg2, arg3, arg4, arg5);

        break;

#endif

#ifdef TARGET_NR_poll

    case TARGET_NR_poll:

        {

            struct target_pollfd *target_pfd;

            unsigned int nfds = arg2;

            int timeout = arg3;

            struct pollfd *pfd;

            unsigned int i;



            target_pfd = lock_user(VERIFY_WRITE, arg1, sizeof(struct target_pollfd) * nfds, 1);

            if (!target_pfd)

                goto efault;

            pfd = alloca(sizeof(struct pollfd) * nfds);

            for(i = 0; i < nfds; i++) {

                pfd[i].fd = tswap32(target_pfd[i].fd);

                pfd[i].events = tswap16(target_pfd[i].events);

            }

            ret = get_errno(poll(pfd, nfds, timeout));

            if (!is_error(ret)) {

                for(i = 0; i < nfds; i++) {

                    target_pfd[i].revents = tswap16(pfd[i].revents);

                }

                ret += nfds * (sizeof(struct target_pollfd)

                               - sizeof(struct pollfd));

            }

            unlock_user(target_pfd, arg1, ret);

        }

        break;

#endif

    case TARGET_NR_flock:

        



        ret = get_errno(flock(arg1, arg2));

        break;

    case TARGET_NR_readv:

        {

            int count = arg3;

            struct iovec *vec;



            vec = alloca(count * sizeof(struct iovec));

            if (lock_iovec(VERIFY_WRITE, vec, arg2, count, 0) < 0)

                goto efault;

            ret = get_errno(readv(arg1, vec, count));

            unlock_iovec(vec, arg2, count, 1);

        }

        break;

    case TARGET_NR_writev:

        {

            int count = arg3;

            struct iovec *vec;



            vec = alloca(count * sizeof(struct iovec));

            if (lock_iovec(VERIFY_READ, vec, arg2, count, 1) < 0)

                goto efault;

            ret = get_errno(writev(arg1, vec, count));

            unlock_iovec(vec, arg2, count, 0);

        }

        break;

    case TARGET_NR_getsid:

        ret = get_errno(getsid(arg1));

        break;

#if defined(TARGET_NR_fdatasync) 

    case TARGET_NR_fdatasync:

        ret = get_errno(fdatasync(arg1));

        break;

#endif

    case TARGET_NR__sysctl:

        



        ret = -TARGET_ENOTDIR;

        break;

    case TARGET_NR_sched_setparam:

        {

            struct sched_param *target_schp;

            struct sched_param schp;



            if (!lock_user_struct(VERIFY_READ, target_schp, arg2, 1))

                goto efault;

            schp.sched_priority = tswap32(target_schp->sched_priority);

            unlock_user_struct(target_schp, arg2, 0);

            ret = get_errno(sched_setparam(arg1, &schp));

        }

        break;

    case TARGET_NR_sched_getparam:

        {

            struct sched_param *target_schp;

            struct sched_param schp;

            ret = get_errno(sched_getparam(arg1, &schp));

            if (!is_error(ret)) {

                if (!lock_user_struct(VERIFY_WRITE, target_schp, arg2, 0))

                    goto efault;

                target_schp->sched_priority = tswap32(schp.sched_priority);

                unlock_user_struct(target_schp, arg2, 1);

            }

        }

        break;

    case TARGET_NR_sched_setscheduler:

        {

            struct sched_param *target_schp;

            struct sched_param schp;

            if (!lock_user_struct(VERIFY_READ, target_schp, arg3, 1))

                goto efault;

            schp.sched_priority = tswap32(target_schp->sched_priority);

            unlock_user_struct(target_schp, arg3, 0);

            ret = get_errno(sched_setscheduler(arg1, arg2, &schp));

        }

        break;

    case TARGET_NR_sched_getscheduler:

        ret = get_errno(sched_getscheduler(arg1));

        break;

    case TARGET_NR_sched_yield:

        ret = get_errno(sched_yield());

        break;

    case TARGET_NR_sched_get_priority_max:

        ret = get_errno(sched_get_priority_max(arg1));

        break;

    case TARGET_NR_sched_get_priority_min:

        ret = get_errno(sched_get_priority_min(arg1));

        break;

    case TARGET_NR_sched_rr_get_interval:

        {

            struct timespec ts;

            ret = get_errno(sched_rr_get_interval(arg1, &ts));

            if (!is_error(ret)) {

                host_to_target_timespec(arg2, &ts);

            }

        }

        break;

    case TARGET_NR_nanosleep:

        {

            struct timespec req, rem;

            target_to_host_timespec(&req, arg1);

            ret = get_errno(nanosleep(&req, &rem));

            if (is_error(ret) && arg2) {

                host_to_target_timespec(arg2, &rem);

            }

        }

        break;

#ifdef TARGET_NR_query_module

    case TARGET_NR_query_module:

        goto unimplemented;

#endif

#ifdef TARGET_NR_nfsservctl

    case TARGET_NR_nfsservctl:

        goto unimplemented;

#endif

    case TARGET_NR_prctl:

        switch (arg1)

            {

            case PR_GET_PDEATHSIG:

                {

                    int deathsig;

                    ret = get_errno(prctl(arg1, &deathsig, arg3, arg4, arg5));

                    if (!is_error(ret) && arg2

                        && put_user_ual(deathsig, arg2))

                        goto efault;

                }

                break;

            default:

                ret = get_errno(prctl(arg1, arg2, arg3, arg4, arg5));

                break;

            }

        break;

#ifdef TARGET_NR_arch_prctl

    case TARGET_NR_arch_prctl:

#if defined(TARGET_I386) && !defined(TARGET_ABI32)

        ret = do_arch_prctl(cpu_env, arg1, arg2);

        break;

#else

        goto unimplemented;

#endif

#endif

#ifdef TARGET_NR_pread

    case TARGET_NR_pread:

#ifdef TARGET_ARM

        if (((CPUARMState *)cpu_env)->eabi)

            arg4 = arg5;

#endif

        if (!(p = lock_user(VERIFY_WRITE, arg2, arg3, 0)))

            goto efault;

        ret = get_errno(pread(arg1, p, arg3, arg4));

        unlock_user(p, arg2, ret);

        break;

    case TARGET_NR_pwrite:

#ifdef TARGET_ARM

        if (((CPUARMState *)cpu_env)->eabi)

            arg4 = arg5;

#endif

        if (!(p = lock_user(VERIFY_READ, arg2, arg3, 1)))

            goto efault;

        ret = get_errno(pwrite(arg1, p, arg3, arg4));

        unlock_user(p, arg2, 0);

        break;

#endif

#ifdef TARGET_NR_pread64

    case TARGET_NR_pread64:

        if (!(p = lock_user(VERIFY_WRITE, arg2, arg3, 0)))

            goto efault;

        ret = get_errno(pread64(arg1, p, arg3, target_offset64(arg4, arg5)));

        unlock_user(p, arg2, ret);

        break;

    case TARGET_NR_pwrite64:

        if (!(p = lock_user(VERIFY_READ, arg2, arg3, 1)))

            goto efault;

        ret = get_errno(pwrite64(arg1, p, arg3, target_offset64(arg4, arg5)));

        unlock_user(p, arg2, 0);

        break;

#endif

    case TARGET_NR_getcwd:

        if (!(p = lock_user(VERIFY_WRITE, arg1, arg2, 0)))

            goto efault;

        ret = get_errno(sys_getcwd1(p, arg2));

        unlock_user(p, arg1, ret);

        break;

    case TARGET_NR_capget:

        goto unimplemented;

    case TARGET_NR_capset:

        goto unimplemented;

    case TARGET_NR_sigaltstack:

#if defined(TARGET_I386) || defined(TARGET_ARM) || defined(TARGET_MIPS) || \

    defined(TARGET_SPARC) || defined(TARGET_PPC) || defined(TARGET_ALPHA) || \

    defined(TARGET_M68K)

        ret = do_sigaltstack(arg1, arg2, get_sp_from_cpustate((CPUState *)cpu_env));

        break;

#else

        goto unimplemented;

#endif

    case TARGET_NR_sendfile:

        goto unimplemented;

#ifdef TARGET_NR_getpmsg

    case TARGET_NR_getpmsg:

        goto unimplemented;

#endif

#ifdef TARGET_NR_putpmsg

    case TARGET_NR_putpmsg:

        goto unimplemented;

#endif

#ifdef TARGET_NR_vfork

    case TARGET_NR_vfork:

        ret = get_errno(do_fork(cpu_env, CLONE_VFORK | CLONE_VM | SIGCHLD,

                        0, 0, 0, 0));

        break;

#endif

#ifdef TARGET_NR_ugetrlimit

    case TARGET_NR_ugetrlimit:

    {

	struct rlimit rlim;

	ret = get_errno(getrlimit(arg1, &rlim));

	if (!is_error(ret)) {

	    struct target_rlimit *target_rlim;

            if (!lock_user_struct(VERIFY_WRITE, target_rlim, arg2, 0))

                goto efault;

	    target_rlim->rlim_cur = tswapl(rlim.rlim_cur);

	    target_rlim->rlim_max = tswapl(rlim.rlim_max);

            unlock_user_struct(target_rlim, arg2, 1);

	}

	break;

    }

#endif

#ifdef TARGET_NR_truncate64

    case TARGET_NR_truncate64:

        if (!(p = lock_user_string(arg1)))

            goto efault;

	ret = target_truncate64(cpu_env, p, arg2, arg3, arg4);

        unlock_user(p, arg1, 0);

	break;

#endif

#ifdef TARGET_NR_ftruncate64

    case TARGET_NR_ftruncate64:

	ret = target_ftruncate64(cpu_env, arg1, arg2, arg3, arg4);

	break;

#endif

#ifdef TARGET_NR_stat64

    case TARGET_NR_stat64:

        if (!(p = lock_user_string(arg1)))

            goto efault;

        ret = get_errno(stat(path(p), &st));

        unlock_user(p, arg1, 0);

        if (!is_error(ret))

            ret = host_to_target_stat64(cpu_env, arg2, &st);

        break;

#endif

#ifdef TARGET_NR_lstat64

    case TARGET_NR_lstat64:

        if (!(p = lock_user_string(arg1)))

            goto efault;

        ret = get_errno(lstat(path(p), &st));

        unlock_user(p, arg1, 0);

        if (!is_error(ret))

            ret = host_to_target_stat64(cpu_env, arg2, &st);

        break;

#endif

#ifdef TARGET_NR_fstat64

    case TARGET_NR_fstat64:

        ret = get_errno(fstat(arg1, &st));

        if (!is_error(ret))

            ret = host_to_target_stat64(cpu_env, arg2, &st);

        break;

#endif

#if (defined(TARGET_NR_fstatat64) || defined(TARGET_NR_newfstatat)) && \

        (defined(__NR_fstatat64) || defined(__NR_newfstatat))

#ifdef TARGET_NR_fstatat64

    case TARGET_NR_fstatat64:

#endif

#ifdef TARGET_NR_newfstatat

    case TARGET_NR_newfstatat:

#endif

        if (!(p = lock_user_string(arg2)))

            goto efault;

#ifdef __NR_fstatat64

        ret = get_errno(sys_fstatat64(arg1, path(p), &st, arg4));

#else

        ret = get_errno(sys_newfstatat(arg1, path(p), &st, arg4));

#endif

        if (!is_error(ret))

            ret = host_to_target_stat64(cpu_env, arg3, &st);

        break;

#endif

#ifdef USE_UID16

    case TARGET_NR_lchown:

        if (!(p = lock_user_string(arg1)))

            goto efault;

        ret = get_errno(lchown(p, low2highuid(arg2), low2highgid(arg3)));

        unlock_user(p, arg1, 0);

        break;

    case TARGET_NR_getuid:

        ret = get_errno(high2lowuid(getuid()));

        break;

    case TARGET_NR_getgid:

        ret = get_errno(high2lowgid(getgid()));

        break;

    case TARGET_NR_geteuid:

        ret = get_errno(high2lowuid(geteuid()));

        break;

    case TARGET_NR_getegid:

        ret = get_errno(high2lowgid(getegid()));

        break;

    case TARGET_NR_setreuid:

        ret = get_errno(setreuid(low2highuid(arg1), low2highuid(arg2)));

        break;

    case TARGET_NR_setregid:

        ret = get_errno(setregid(low2highgid(arg1), low2highgid(arg2)));

        break;

    case TARGET_NR_getgroups:

        {

            int gidsetsize = arg1;

            uint16_t *target_grouplist;

            gid_t *grouplist;

            int i;



            grouplist = alloca(gidsetsize * sizeof(gid_t));

            ret = get_errno(getgroups(gidsetsize, grouplist));

            if (gidsetsize == 0)

                break;

            if (!is_error(ret)) {

                target_grouplist = lock_user(VERIFY_WRITE, arg2, gidsetsize * 2, 0);

                if (!target_grouplist)

                    goto efault;

                for(i = 0;i < ret; i++)

                    target_grouplist[i] = tswap16(grouplist[i]);

                unlock_user(target_grouplist, arg2, gidsetsize * 2);

            }

        }

        break;

    case TARGET_NR_setgroups:

        {

            int gidsetsize = arg1;

            uint16_t *target_grouplist;

            gid_t *grouplist;

            int i;



            grouplist = alloca(gidsetsize * sizeof(gid_t));

            target_grouplist = lock_user(VERIFY_READ, arg2, gidsetsize * 2, 1);

            if (!target_grouplist) {

                ret = -TARGET_EFAULT;

                goto fail;

            }

            for(i = 0;i < gidsetsize; i++)

                grouplist[i] = tswap16(target_grouplist[i]);

            unlock_user(target_grouplist, arg2, 0);

            ret = get_errno(setgroups(gidsetsize, grouplist));

        }

        break;

    case TARGET_NR_fchown:

        ret = get_errno(fchown(arg1, low2highuid(arg2), low2highgid(arg3)));

        break;

#if defined(TARGET_NR_fchownat) && defined(__NR_fchownat)

    case TARGET_NR_fchownat:

        if (!(p = lock_user_string(arg2))) 

            goto efault;

        ret = get_errno(sys_fchownat(arg1, p, low2highuid(arg3), low2highgid(arg4), arg5));

        unlock_user(p, arg2, 0);

        break;

#endif

#ifdef TARGET_NR_setresuid

    case TARGET_NR_setresuid:

        ret = get_errno(setresuid(low2highuid(arg1),

                                  low2highuid(arg2),

                                  low2highuid(arg3)));

        break;

#endif

#ifdef TARGET_NR_getresuid

    case TARGET_NR_getresuid:

        {

            uid_t ruid, euid, suid;

            ret = get_errno(getresuid(&ruid, &euid, &suid));

            if (!is_error(ret)) {

                if (put_user_u16(high2lowuid(ruid), arg1)

                    || put_user_u16(high2lowuid(euid), arg2)

                    || put_user_u16(high2lowuid(suid), arg3))

                    goto efault;

            }

        }

        break;

#endif

#ifdef TARGET_NR_getresgid

    case TARGET_NR_setresgid:

        ret = get_errno(setresgid(low2highgid(arg1),

                                  low2highgid(arg2),

                                  low2highgid(arg3)));

        break;

#endif

#ifdef TARGET_NR_getresgid

    case TARGET_NR_getresgid:

        {

            gid_t rgid, egid, sgid;

            ret = get_errno(getresgid(&rgid, &egid, &sgid));

            if (!is_error(ret)) {

                if (put_user_u16(high2lowgid(rgid), arg1)

                    || put_user_u16(high2lowgid(egid), arg2)

                    || put_user_u16(high2lowgid(sgid), arg3))

                    goto efault;

            }

        }

        break;

#endif

    case TARGET_NR_chown:

        if (!(p = lock_user_string(arg1)))

            goto efault;

        ret = get_errno(chown(p, low2highuid(arg2), low2highgid(arg3)));

        unlock_user(p, arg1, 0);

        break;

    case TARGET_NR_setuid:

        ret = get_errno(setuid(low2highuid(arg1)));

        break;

    case TARGET_NR_setgid:

        ret = get_errno(setgid(low2highgid(arg1)));

        break;

    case TARGET_NR_setfsuid:

        ret = get_errno(setfsuid(arg1));

        break;

    case TARGET_NR_setfsgid:

        ret = get_errno(setfsgid(arg1));

        break;

#endif 



#ifdef TARGET_NR_lchown32

    case TARGET_NR_lchown32:

        if (!(p = lock_user_string(arg1)))

            goto efault;

        ret = get_errno(lchown(p, arg2, arg3));

        unlock_user(p, arg1, 0);

        break;

#endif

#ifdef TARGET_NR_getuid32

    case TARGET_NR_getuid32:

        ret = get_errno(getuid());

        break;

#endif



#if defined(TARGET_NR_getxuid) && defined(TARGET_ALPHA)

   

    case TARGET_NR_getxuid:

	 {

	    uid_t euid;

	    euid=geteuid();

	    ((CPUAlphaState *)cpu_env)->ir[IR_A4]=euid;

	 }

        ret = get_errno(getuid());

        break;

#endif

#if defined(TARGET_NR_getxgid) && defined(TARGET_ALPHA)

   

    case TARGET_NR_getxgid:

	 {

	    uid_t egid;

	    egid=getegid();

	    ((CPUAlphaState *)cpu_env)->ir[IR_A4]=egid;

	 }

        ret = get_errno(getgid());

        break;

#endif



#ifdef TARGET_NR_getgid32

    case TARGET_NR_getgid32:

        ret = get_errno(getgid());

        break;

#endif

#ifdef TARGET_NR_geteuid32

    case TARGET_NR_geteuid32:

        ret = get_errno(geteuid());

        break;

#endif

#ifdef TARGET_NR_getegid32

    case TARGET_NR_getegid32:

        ret = get_errno(getegid());

        break;

#endif

#ifdef TARGET_NR_setreuid32

    case TARGET_NR_setreuid32:

        ret = get_errno(setreuid(arg1, arg2));

        break;

#endif

#ifdef TARGET_NR_setregid32

    case TARGET_NR_setregid32:

        ret = get_errno(setregid(arg1, arg2));

        break;

#endif

#ifdef TARGET_NR_getgroups32

    case TARGET_NR_getgroups32:

        {

            int gidsetsize = arg1;

            uint32_t *target_grouplist;

            gid_t *grouplist;

            int i;



            grouplist = alloca(gidsetsize * sizeof(gid_t));

            ret = get_errno(getgroups(gidsetsize, grouplist));

            if (gidsetsize == 0)

                break;

            if (!is_error(ret)) {

                target_grouplist = lock_user(VERIFY_WRITE, arg2, gidsetsize * 4, 0);

                if (!target_grouplist) {

                    ret = -TARGET_EFAULT;

                    goto fail;

                }

                for(i = 0;i < ret; i++)

                    target_grouplist[i] = tswap32(grouplist[i]);

                unlock_user(target_grouplist, arg2, gidsetsize * 4);

            }

        }

        break;

#endif

#ifdef TARGET_NR_setgroups32

    case TARGET_NR_setgroups32:

        {

            int gidsetsize = arg1;

            uint32_t *target_grouplist;

            gid_t *grouplist;

            int i;



            grouplist = alloca(gidsetsize * sizeof(gid_t));

            target_grouplist = lock_user(VERIFY_READ, arg2, gidsetsize * 4, 1);

            if (!target_grouplist) {

                ret = -TARGET_EFAULT;

                goto fail;

            }

            for(i = 0;i < gidsetsize; i++)

                grouplist[i] = tswap32(target_grouplist[i]);

            unlock_user(target_grouplist, arg2, 0);

            ret = get_errno(setgroups(gidsetsize, grouplist));

        }

        break;

#endif

#ifdef TARGET_NR_fchown32

    case TARGET_NR_fchown32:

        ret = get_errno(fchown(arg1, arg2, arg3));

        break;

#endif

#ifdef TARGET_NR_setresuid32

    case TARGET_NR_setresuid32:

        ret = get_errno(setresuid(arg1, arg2, arg3));

        break;

#endif

#ifdef TARGET_NR_getresuid32

    case TARGET_NR_getresuid32:

        {

            uid_t ruid, euid, suid;

            ret = get_errno(getresuid(&ruid, &euid, &suid));

            if (!is_error(ret)) {

                if (put_user_u32(ruid, arg1)

                    || put_user_u32(euid, arg2)

                    || put_user_u32(suid, arg3))

                    goto efault;

            }

        }

        break;

#endif

#ifdef TARGET_NR_setresgid32

    case TARGET_NR_setresgid32:

        ret = get_errno(setresgid(arg1, arg2, arg3));

        break;

#endif

#ifdef TARGET_NR_getresgid32

    case TARGET_NR_getresgid32:

        {

            gid_t rgid, egid, sgid;

            ret = get_errno(getresgid(&rgid, &egid, &sgid));

            if (!is_error(ret)) {

                if (put_user_u32(rgid, arg1)

                    || put_user_u32(egid, arg2)

                    || put_user_u32(sgid, arg3))

                    goto efault;

            }

        }

        break;

#endif

#ifdef TARGET_NR_chown32

    case TARGET_NR_chown32:

        if (!(p = lock_user_string(arg1)))

            goto efault;

        ret = get_errno(chown(p, arg2, arg3));

        unlock_user(p, arg1, 0);

        break;

#endif

#ifdef TARGET_NR_setuid32

    case TARGET_NR_setuid32:

        ret = get_errno(setuid(arg1));

        break;

#endif

#ifdef TARGET_NR_setgid32

    case TARGET_NR_setgid32:

        ret = get_errno(setgid(arg1));

        break;

#endif

#ifdef TARGET_NR_setfsuid32

    case TARGET_NR_setfsuid32:

        ret = get_errno(setfsuid(arg1));

        break;

#endif

#ifdef TARGET_NR_setfsgid32

    case TARGET_NR_setfsgid32:

        ret = get_errno(setfsgid(arg1));

        break;

#endif



    case TARGET_NR_pivot_root:

        goto unimplemented;

#ifdef TARGET_NR_mincore

    case TARGET_NR_mincore:

        {

            void *a;

            ret = -TARGET_EFAULT;

            if (!(a = lock_user(VERIFY_READ, arg1,arg2, 0)))

                goto efault;

            if (!(p = lock_user_string(arg3)))

                goto mincore_fail;

            ret = get_errno(mincore(a, arg2, p));

            unlock_user(p, arg3, ret);

            mincore_fail:

            unlock_user(a, arg1, 0);

        }

        break;

#endif

#ifdef TARGET_NR_arm_fadvise64_64

    case TARGET_NR_arm_fadvise64_64:

	{

		







		abi_long temp;

		temp = arg3;

		arg3 = arg4;

		arg4 = temp;

	}

#endif

#if defined(TARGET_NR_fadvise64_64) || defined(TARGET_NR_arm_fadvise64_64) || defined(TARGET_NR_fadvise64)

#ifdef TARGET_NR_fadvise64_64

    case TARGET_NR_fadvise64_64:

#endif

#ifdef TARGET_NR_fadvise64

    case TARGET_NR_fadvise64:

#endif

#ifdef TARGET_S390X

        switch (arg4) {

        case 4: arg4 = POSIX_FADV_NOREUSE + 1; break; 

        case 5: arg4 = POSIX_FADV_NOREUSE + 2; break; 

        case 6: arg4 = POSIX_FADV_DONTNEED; break;

        case 7: arg4 = POSIX_FADV_NOREUSE; break;

        default: break;

        }

#endif

        ret = -posix_fadvise(arg1, arg2, arg3, arg4);

	break;

#endif

#ifdef TARGET_NR_madvise

    case TARGET_NR_madvise:

        







        ret = get_errno(0);

        break;

#endif

#if TARGET_ABI_BITS == 32

    case TARGET_NR_fcntl64:

    {

	int cmd;

	struct flock64 fl;

	struct target_flock64 *target_fl;

#ifdef TARGET_ARM

	struct target_eabi_flock64 *target_efl;

#endif



	cmd = target_to_host_fcntl_cmd(arg2);

	if (cmd == -TARGET_EINVAL)

		return cmd;



        switch(arg2) {

        case TARGET_F_GETLK64:

#ifdef TARGET_ARM

            if (((CPUARMState *)cpu_env)->eabi) {

                if (!lock_user_struct(VERIFY_READ, target_efl, arg3, 1)) 

                    goto efault;

                fl.l_type = tswap16(target_efl->l_type);

                fl.l_whence = tswap16(target_efl->l_whence);

                fl.l_start = tswap64(target_efl->l_start);

                fl.l_len = tswap64(target_efl->l_len);

                fl.l_pid = tswap32(target_efl->l_pid);

                unlock_user_struct(target_efl, arg3, 0);

            } else

#endif

            {

                if (!lock_user_struct(VERIFY_READ, target_fl, arg3, 1)) 

                    goto efault;

                fl.l_type = tswap16(target_fl->l_type);

                fl.l_whence = tswap16(target_fl->l_whence);

                fl.l_start = tswap64(target_fl->l_start);

                fl.l_len = tswap64(target_fl->l_len);

                fl.l_pid = tswap32(target_fl->l_pid);

                unlock_user_struct(target_fl, arg3, 0);

            }

            ret = get_errno(fcntl(arg1, cmd, &fl));

	    if (ret == 0) {

#ifdef TARGET_ARM

                if (((CPUARMState *)cpu_env)->eabi) {

                    if (!lock_user_struct(VERIFY_WRITE, target_efl, arg3, 0)) 

                        goto efault;

                    target_efl->l_type = tswap16(fl.l_type);

                    target_efl->l_whence = tswap16(fl.l_whence);

                    target_efl->l_start = tswap64(fl.l_start);

                    target_efl->l_len = tswap64(fl.l_len);

                    target_efl->l_pid = tswap32(fl.l_pid);

                    unlock_user_struct(target_efl, arg3, 1);

                } else

#endif

                {

                    if (!lock_user_struct(VERIFY_WRITE, target_fl, arg3, 0)) 

                        goto efault;

                    target_fl->l_type = tswap16(fl.l_type);

                    target_fl->l_whence = tswap16(fl.l_whence);

                    target_fl->l_start = tswap64(fl.l_start);

                    target_fl->l_len = tswap64(fl.l_len);

                    target_fl->l_pid = tswap32(fl.l_pid);

                    unlock_user_struct(target_fl, arg3, 1);

                }

	    }

	    break;



        case TARGET_F_SETLK64:

        case TARGET_F_SETLKW64:

#ifdef TARGET_ARM

            if (((CPUARMState *)cpu_env)->eabi) {

                if (!lock_user_struct(VERIFY_READ, target_efl, arg3, 1)) 

                    goto efault;

                fl.l_type = tswap16(target_efl->l_type);

                fl.l_whence = tswap16(target_efl->l_whence);

                fl.l_start = tswap64(target_efl->l_start);

                fl.l_len = tswap64(target_efl->l_len);

                fl.l_pid = tswap32(target_efl->l_pid);

                unlock_user_struct(target_efl, arg3, 0);

            } else

#endif

            {

                if (!lock_user_struct(VERIFY_READ, target_fl, arg3, 1)) 

                    goto efault;

                fl.l_type = tswap16(target_fl->l_type);

                fl.l_whence = tswap16(target_fl->l_whence);

                fl.l_start = tswap64(target_fl->l_start);

                fl.l_len = tswap64(target_fl->l_len);

                fl.l_pid = tswap32(target_fl->l_pid);

                unlock_user_struct(target_fl, arg3, 0);

            }

            ret = get_errno(fcntl(arg1, cmd, &fl));

	    break;

        default:

            ret = do_fcntl(arg1, arg2, arg3);

            break;

        }

	break;

    }

#endif

#ifdef TARGET_NR_cacheflush

    case TARGET_NR_cacheflush:

        

        ret = 0;

        break;

#endif

#ifdef TARGET_NR_security

    case TARGET_NR_security:

        goto unimplemented;

#endif

#ifdef TARGET_NR_getpagesize

    case TARGET_NR_getpagesize:

        ret = TARGET_PAGE_SIZE;

        break;

#endif

    case TARGET_NR_gettid:

        ret = get_errno(gettid());

        break;

#ifdef TARGET_NR_readahead

    case TARGET_NR_readahead:

#if TARGET_ABI_BITS == 32

#ifdef TARGET_ARM

        if (((CPUARMState *)cpu_env)->eabi)

        {

            arg2 = arg3;

            arg3 = arg4;

            arg4 = arg5;

        }

#endif

        ret = get_errno(readahead(arg1, ((off64_t)arg3 << 32) | arg2, arg4));

#else

        ret = get_errno(readahead(arg1, arg2, arg3));

#endif

        break;

#endif

#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:

        ret = -TARGET_EOPNOTSUPP;

        break;

#endif

#ifdef TARGET_NR_set_thread_area

    case TARGET_NR_set_thread_area:

#if defined(TARGET_MIPS)

      ((CPUMIPSState *) cpu_env)->tls_value = arg1;

      ret = 0;

      break;

#elif defined(TARGET_CRIS)

      if (arg1 & 0xff)

          ret = -TARGET_EINVAL;

      else {

          ((CPUCRISState *) cpu_env)->pregs[PR_PID] = arg1;

          ret = 0;

      }

      break;

#elif defined(TARGET_I386) && defined(TARGET_ABI32)

      ret = do_set_thread_area(cpu_env, arg1);

      break;

#else

      goto unimplemented_nowarn;

#endif

#endif

#ifdef TARGET_NR_get_thread_area

    case TARGET_NR_get_thread_area:

#if defined(TARGET_I386) && defined(TARGET_ABI32)

        ret = do_get_thread_area(cpu_env, arg1);

#else

        goto unimplemented_nowarn;

#endif

#endif

#ifdef TARGET_NR_getdomainname

    case TARGET_NR_getdomainname:

        goto unimplemented_nowarn;

#endif



#ifdef TARGET_NR_clock_gettime

    case TARGET_NR_clock_gettime:

    {

        struct timespec ts;

        ret = get_errno(clock_gettime(arg1, &ts));

        if (!is_error(ret)) {

            host_to_target_timespec(arg2, &ts);

        }

        break;

    }

#endif

#ifdef TARGET_NR_clock_getres

    case TARGET_NR_clock_getres:

    {

        struct timespec ts;

        ret = get_errno(clock_getres(arg1, &ts));

        if (!is_error(ret)) {

            host_to_target_timespec(arg2, &ts);

        }

        break;

    }

#endif

#ifdef TARGET_NR_clock_nanosleep

    case TARGET_NR_clock_nanosleep:

    {

        struct timespec ts;

        target_to_host_timespec(&ts, arg3);

        ret = get_errno(clock_nanosleep(arg1, arg2, &ts, arg4 ? &ts : NULL));

        if (arg4)

            host_to_target_timespec(arg4, &ts);

        break;

    }

#endif



#if defined(TARGET_NR_set_tid_address) && defined(__NR_set_tid_address)

    case TARGET_NR_set_tid_address:

        ret = get_errno(set_tid_address((int *)g2h(arg1)));

        break;

#endif



#if defined(TARGET_NR_tkill) && defined(__NR_tkill)

    case TARGET_NR_tkill:

        ret = get_errno(sys_tkill((int)arg1, target_to_host_signal(arg2)));

        break;

#endif



#if defined(TARGET_NR_tgkill) && defined(__NR_tgkill)

    case TARGET_NR_tgkill:

	ret = get_errno(sys_tgkill((int)arg1, (int)arg2,

                        target_to_host_signal(arg3)));

	break;

#endif



#ifdef TARGET_NR_set_robust_list

    case TARGET_NR_set_robust_list:

	goto unimplemented_nowarn;

#endif



#if defined(TARGET_NR_utimensat) && defined(__NR_utimensat)

    case TARGET_NR_utimensat:

        {

            struct timespec *tsp, ts[2];

            if (!arg3) {

                tsp = NULL;

            } else {

                target_to_host_timespec(ts, arg3);

                target_to_host_timespec(ts+1, arg3+sizeof(struct target_timespec));

                tsp = ts;

            }

            if (!arg2)

                ret = get_errno(sys_utimensat(arg1, NULL, tsp, arg4));

            else {

                if (!(p = lock_user_string(arg2))) {

                    ret = -TARGET_EFAULT;

                    goto fail;

                }

                ret = get_errno(sys_utimensat(arg1, path(p), tsp, arg4));

                unlock_user(p, arg2, 0);

            }

        }

	break;

#endif

#if defined(CONFIG_USE_NPTL)

    case TARGET_NR_futex:

        ret = do_futex(arg1, arg2, arg3, arg4, arg5, arg6);

        break;

#endif

#if defined(TARGET_NR_inotify_init) && defined(__NR_inotify_init)

    case TARGET_NR_inotify_init:

        ret = get_errno(sys_inotify_init());

        break;

#endif

#if defined(TARGET_NR_inotify_add_watch) && defined(__NR_inotify_add_watch)

    case TARGET_NR_inotify_add_watch:

        p = lock_user_string(arg2);

        ret = get_errno(sys_inotify_add_watch(arg1, path(p), arg3));

        unlock_user(p, arg2, 0);

        break;

#endif

#if defined(TARGET_NR_inotify_rm_watch) && defined(__NR_inotify_rm_watch)

    case TARGET_NR_inotify_rm_watch:

        ret = get_errno(sys_inotify_rm_watch(arg1, arg2));

        break;

#endif



#if defined(TARGET_NR_mq_open) && defined(__NR_mq_open)

    case TARGET_NR_mq_open:

        {

            struct mq_attr posix_mq_attr;



            p = lock_user_string(arg1 - 1);

            if (arg4 != 0)

                copy_from_user_mq_attr (&posix_mq_attr, arg4);

            ret = get_errno(mq_open(p, arg2, arg3, &posix_mq_attr));

            unlock_user (p, arg1, 0);

        }

        break;



    case TARGET_NR_mq_unlink:

        p = lock_user_string(arg1 - 1);

        ret = get_errno(mq_unlink(p));

        unlock_user (p, arg1, 0);

        break;



    case TARGET_NR_mq_timedsend:

        {

            struct timespec ts;



            p = lock_user (VERIFY_READ, arg2, arg3, 1);

            if (arg5 != 0) {

                target_to_host_timespec(&ts, arg5);

                ret = get_errno(mq_timedsend(arg1, p, arg3, arg4, &ts));

                host_to_target_timespec(arg5, &ts);

            }

            else

                ret = get_errno(mq_send(arg1, p, arg3, arg4));

            unlock_user (p, arg2, arg3);

        }

        break;



    case TARGET_NR_mq_timedreceive:

        {

            struct timespec ts;

            unsigned int prio;



            p = lock_user (VERIFY_READ, arg2, arg3, 1);

            if (arg5 != 0) {

                target_to_host_timespec(&ts, arg5);

                ret = get_errno(mq_timedreceive(arg1, p, arg3, &prio, &ts));

                host_to_target_timespec(arg5, &ts);

            }

            else

                ret = get_errno(mq_receive(arg1, p, arg3, &prio));

            unlock_user (p, arg2, arg3);

            if (arg4 != 0)

                put_user_u32(prio, arg4);

        }

        break;



    







    case TARGET_NR_mq_getsetattr:

        {

            struct mq_attr posix_mq_attr_in, posix_mq_attr_out;

            ret = 0;

            if (arg3 != 0) {

                ret = mq_getattr(arg1, &posix_mq_attr_out);

                copy_to_user_mq_attr(arg3, &posix_mq_attr_out);

            }

            if (arg2 != 0) {

                copy_from_user_mq_attr(&posix_mq_attr_in, arg2);

                ret |= mq_setattr(arg1, &posix_mq_attr_in, &posix_mq_attr_out);

            }



        }

        break;

#endif



#ifdef CONFIG_SPLICE

#ifdef TARGET_NR_tee

    case TARGET_NR_tee:

        {

            ret = get_errno(tee(arg1,arg2,arg3,arg4));

        }

        break;

#endif

#ifdef TARGET_NR_splice

    case TARGET_NR_splice:

        {

            loff_t loff_in, loff_out;

            loff_t *ploff_in = NULL, *ploff_out = NULL;

            if(arg2) {

                get_user_u64(loff_in, arg2);

                ploff_in = &loff_in;

            }

            if(arg4) {

                get_user_u64(loff_out, arg2);

                ploff_out = &loff_out;

            }

            ret = get_errno(splice(arg1, ploff_in, arg3, ploff_out, arg5, arg6));

        }

        break;

#endif

#ifdef TARGET_NR_vmsplice

	case TARGET_NR_vmsplice:

        {

            int count = arg3;

            struct iovec *vec;



            vec = alloca(count * sizeof(struct iovec));

            if (lock_iovec(VERIFY_READ, vec, arg2, count, 1) < 0)

                goto efault;

            ret = get_errno(vmsplice(arg1, vec, count, arg4));

            unlock_iovec(vec, arg2, count, 0);

        }

        break;

#endif

#endif 

#ifdef CONFIG_EVENTFD

#if defined(TARGET_NR_eventfd)

    case TARGET_NR_eventfd:

        ret = get_errno(eventfd(arg1, 0));

        break;

#endif

#if defined(TARGET_NR_eventfd2)

    case TARGET_NR_eventfd2:

        ret = get_errno(eventfd(arg1, arg2));

        break;

#endif

#endif 

    default:

    unimplemented:

        gemu_log("qemu: Unsupported syscall: %d\n", num);

#if defined(TARGET_NR_setxattr) || defined(TARGET_NR_get_thread_area) || defined(TARGET_NR_getdomainname) || defined(TARGET_NR_set_robust_list)

    unimplemented_nowarn:

#endif

        ret = -TARGET_ENOSYS;

        break;

    }

fail:

#ifdef DEBUG

    gemu_log(" = " TARGET_ABI_FMT_ld "\n", ret);

#endif

    if(do_strace)

        print_syscall_ret(num, ret);

    return ret;

efault:

    ret = -TARGET_EFAULT;

    goto fail;

}
abi_long FUNC_0(void *cpu_env, int num, abi_long arg1,

                    abi_long arg2, abi_long arg3, abi_long arg4,

                    abi_long arg5, abi_long arg6)

{

    abi_long ret;

    struct stat VAR_0;

    struct statfs VAR_1;

    void *VAR_2;



#ifdef DEBUG

    gemu_log("syscall %d", num);

#endif

    if(do_strace)

        print_syscall(num, arg1, arg2, arg3, arg4, arg5, arg6);



    switch(num) {

    case TARGET_NR_exit:

#ifdef CONFIG_USE_NPTL

      







      



      if (first_cpu->next_cpu) {

          TaskState *VAR_42;

          CPUState **lastp;

          CPUState *VAR_2;



          cpu_list_lock();

          lastp = &first_cpu;

          VAR_2 = first_cpu;

          while (VAR_2 && VAR_2 != (CPUState *)cpu_env) {

              lastp = &VAR_2->next_cpu;

              VAR_2 = VAR_2->next_cpu;

          }

          



          if (!VAR_2)

              abort();

          

          *lastp = VAR_2->next_cpu;

          cpu_list_unlock();

          VAR_42 = ((CPUState *)cpu_env)->opaque;

          if (VAR_42->child_tidptr) {

              put_user_u32(0, VAR_42->child_tidptr);

              sys_futex(g2h(VAR_42->child_tidptr), FUTEX_WAKE, INT_MAX,

                        NULL, NULL, 0);

          }

          

          pthread_exit(NULL);

      }

#endif

#ifdef TARGET_GPROF

        _mcleanup();

#endif

        gdb_exit(cpu_env, arg1);

        _exit(arg1);

        ret = 0; 

        break;

    case TARGET_NR_read:

        if (arg3 == 0)

            ret = 0;

        else {

            if (!(VAR_2 = lock_user(VERIFY_WRITE, arg2, arg3, 0)))

                goto efault;

            ret = get_errno(read(arg1, VAR_2, arg3));

            unlock_user(VAR_2, arg2, ret);

        }

        break;

    case TARGET_NR_write:

        if (!(VAR_2 = lock_user(VERIFY_READ, arg2, arg3, 1)))

            goto efault;

        ret = get_errno(write(arg1, VAR_2, arg3));

        unlock_user(VAR_2, arg2, 0);

        break;

    case TARGET_NR_open:

        if (!(VAR_2 = lock_user_string(arg1)))

            goto efault;

        ret = get_errno(open(path(VAR_2),

                             target_to_host_bitmask(arg2, fcntl_flags_tbl),

                             arg3));

        unlock_user(VAR_2, arg1, 0);

        break;

#if defined(TARGET_NR_openat) && defined(__NR_openat)

    case TARGET_NR_openat:

        if (!(VAR_2 = lock_user_string(arg2)))

            goto efault;

        ret = get_errno(sys_openat(arg1,

                                   path(VAR_2),

                                   target_to_host_bitmask(arg3, fcntl_flags_tbl),

                                   arg4));

        unlock_user(VAR_2, arg2, 0);

        break;

#endif

    case TARGET_NR_close:

        ret = get_errno(close(arg1));

        break;

    case TARGET_NR_brk:

        ret = do_brk(arg1);

        break;

    case TARGET_NR_fork:

        ret = get_errno(do_fork(cpu_env, SIGCHLD, 0, 0, 0, 0));

        break;

#ifdef TARGET_NR_waitpid

    case TARGET_NR_waitpid:

        {

            int VAR_30;

            ret = get_errno(waitpid(arg1, &VAR_30, arg3));

            if (!is_error(ret) && arg2

                && put_user_s32(host_to_target_waitstatus(VAR_30), arg2))

                goto efault;

        }

        break;

#endif

#ifdef TARGET_NR_waitid

    case TARGET_NR_waitid:

        {

            siginfo_t info;

            info.si_pid = 0;

            ret = get_errno(waitid(arg1, arg2, &info, arg4));

            if (!is_error(ret) && arg3 && info.si_pid != 0) {

                if (!(VAR_2 = lock_user(VERIFY_WRITE, arg3, sizeof(target_siginfo_t), 0)))

                    goto efault;

                host_to_target_siginfo(VAR_2, &info);

                unlock_user(VAR_2, arg3, sizeof(target_siginfo_t));

            }

        }

        break;

#endif

#ifdef TARGET_NR_creat 

    case TARGET_NR_creat:

        if (!(VAR_2 = lock_user_string(arg1)))

            goto efault;

        ret = get_errno(creat(VAR_2, arg2));

        unlock_user(VAR_2, arg1, 0);

        break;

#endif

    case TARGET_NR_link:

        {

            void * VAR_23;

            VAR_2 = lock_user_string(arg1);

            VAR_23 = lock_user_string(arg2);

            if (!VAR_2 || !VAR_23)

                ret = -TARGET_EFAULT;

            else

                ret = get_errno(link(VAR_2, VAR_23));

            unlock_user(VAR_23, arg2, 0);

            unlock_user(VAR_2, arg1, 0);

        }

        break;

#if defined(TARGET_NR_linkat) && defined(__NR_linkat)

    case TARGET_NR_linkat:

        {

            void * VAR_23 = NULL;

            if (!arg2 || !arg4)

                goto efault;

            VAR_2  = lock_user_string(arg2);

            VAR_23 = lock_user_string(arg4);

            if (!VAR_2 || !VAR_23)

                ret = -TARGET_EFAULT;

            else

                ret = get_errno(sys_linkat(arg1, VAR_2, arg3, VAR_23, arg5));

            unlock_user(VAR_2, arg2, 0);

            unlock_user(VAR_23, arg4, 0);

        }

        break;

#endif

    case TARGET_NR_unlink:

        if (!(VAR_2 = lock_user_string(arg1)))

            goto efault;

        ret = get_errno(unlink(VAR_2));

        unlock_user(VAR_2, arg1, 0);

        break;

#if defined(TARGET_NR_unlinkat) && defined(__NR_unlinkat)

    case TARGET_NR_unlinkat:

        if (!(VAR_2 = lock_user_string(arg2)))

            goto efault;

        ret = get_errno(sys_unlinkat(arg1, VAR_2, arg3));

        unlock_user(VAR_2, arg2, 0);

        break;

#endif

    case TARGET_NR_execve:

        {

            char **VAR_4, **VAR_5;

            int VAR_6, VAR_7;

            abi_ulong gp;

            abi_ulong guest_argp;

            abi_ulong guest_envp;

            abi_ulong addr;

            char **VAR_8;



            VAR_6 = 0;

            guest_argp = arg2;

            for (gp = guest_argp; gp; gp += sizeof(abi_ulong)) {

                if (get_user_ual(addr, gp))

                    goto efault;

                if (!addr)

                    break;

                VAR_6++;

            }

            VAR_7 = 0;

            guest_envp = arg3;

            for (gp = guest_envp; gp; gp += sizeof(abi_ulong)) {

                if (get_user_ual(addr, gp))

                    goto efault;

                if (!addr)

                    break;

                VAR_7++;

            }



            VAR_4 = alloca((VAR_6 + 1) * sizeof(void *));

            VAR_5 = alloca((VAR_7 + 1) * sizeof(void *));



            for (gp = guest_argp, VAR_8 = VAR_4; gp;

                  gp += sizeof(abi_ulong), VAR_8++) {

                if (get_user_ual(addr, gp))

                    goto execve_efault;

                if (!addr)

                    break;

                if (!(*VAR_8 = lock_user_string(addr)))

                    goto execve_efault;

            }

            *VAR_8 = NULL;



            for (gp = guest_envp, VAR_8 = VAR_5; gp;

                  gp += sizeof(abi_ulong), VAR_8++) {

                if (get_user_ual(addr, gp))

                    goto execve_efault;

                if (!addr)

                    break;

                if (!(*VAR_8 = lock_user_string(addr)))

                    goto execve_efault;

            }

            *VAR_8 = NULL;



            if (!(VAR_2 = lock_user_string(arg1)))

                goto execve_efault;

            ret = get_errno(execve(VAR_2, VAR_4, VAR_5));

            unlock_user(VAR_2, arg1, 0);



            goto execve_end;



        execve_efault:

            ret = -TARGET_EFAULT;



        execve_end:

            for (gp = guest_argp, VAR_8 = VAR_4; *VAR_8;

                  gp += sizeof(abi_ulong), VAR_8++) {

                if (get_user_ual(addr, gp)

                    || !addr)

                    break;

                unlock_user(*VAR_8, addr, 0);

            }

            for (gp = guest_envp, VAR_8 = VAR_5; *VAR_8;

                  gp += sizeof(abi_ulong), VAR_8++) {

                if (get_user_ual(addr, gp)

                    || !addr)

                    break;

                unlock_user(*VAR_8, addr, 0);

            }

        }

        break;

    case TARGET_NR_chdir:

        if (!(VAR_2 = lock_user_string(arg1)))

            goto efault;

        ret = get_errno(chdir(VAR_2));

        unlock_user(VAR_2, arg1, 0);

        break;

#ifdef TARGET_NR_time

    case TARGET_NR_time:

        {

            time_t host_time;

            ret = get_errno(time(&host_time));

            if (!is_error(ret)

                && arg1

                && put_user_sal(host_time, arg1))

                goto efault;

        }

        break;

#endif

    case TARGET_NR_mknod:

        if (!(VAR_2 = lock_user_string(arg1)))

            goto efault;

        ret = get_errno(mknod(VAR_2, arg2, arg3));

        unlock_user(VAR_2, arg1, 0);

        break;

#if defined(TARGET_NR_mknodat) && defined(__NR_mknodat)

    case TARGET_NR_mknodat:

        if (!(VAR_2 = lock_user_string(arg2)))

            goto efault;

        ret = get_errno(sys_mknodat(arg1, VAR_2, arg3, arg4));

        unlock_user(VAR_2, arg2, 0);

        break;

#endif

    case TARGET_NR_chmod:

        if (!(VAR_2 = lock_user_string(arg1)))

            goto efault;

        ret = get_errno(chmod(VAR_2, arg2));

        unlock_user(VAR_2, arg1, 0);

        break;

#ifdef TARGET_NR_break

    case TARGET_NR_break:

        goto unimplemented;

#endif

#ifdef TARGET_NR_oldstat

    case TARGET_NR_oldstat:

        goto unimplemented;

#endif

    case TARGET_NR_lseek:

        ret = get_errno(lseek(arg1, arg2, arg3));

        break;

#ifdef TARGET_NR_getxpid

    case TARGET_NR_getxpid:

#else

    case TARGET_NR_getpid:

#endif

        ret = get_errno(getpid());

        break;

    case TARGET_NR_mount:

		{

			

			void *VAR_23, *VAR_9;

			VAR_2 = lock_user_string(arg1);

			VAR_23 = lock_user_string(arg2);

			VAR_9 = lock_user_string(arg3);

                        if (!VAR_2 || !VAR_23 || !VAR_9)

                            ret = -TARGET_EFAULT;

                        else

                            







                            ret = get_errno(mount(VAR_2, VAR_23, VAR_9, (unsigned long)arg4, g2h(arg5)));

                        unlock_user(VAR_2, arg1, 0);

                        unlock_user(VAR_23, arg2, 0);

                        unlock_user(VAR_9, arg3, 0);

			break;

		}

#ifdef TARGET_NR_umount

    case TARGET_NR_umount:

        if (!(VAR_2 = lock_user_string(arg1)))

            goto efault;

        ret = get_errno(umount(VAR_2));

        unlock_user(VAR_2, arg1, 0);

        break;

#endif

#ifdef TARGET_NR_stime 

    case TARGET_NR_stime:

        {

            time_t host_time;

            if (get_user_sal(host_time, arg1))

                goto efault;

            ret = get_errno(stime(&host_time));

        }

        break;

#endif

    case TARGET_NR_ptrace:

        goto unimplemented;

#ifdef TARGET_NR_alarm 

    case TARGET_NR_alarm:

        ret = alarm(arg1);

        break;

#endif

#ifdef TARGET_NR_oldfstat

    case TARGET_NR_oldfstat:

        goto unimplemented;

#endif

#ifdef TARGET_NR_pause 

    case TARGET_NR_pause:

        ret = get_errno(pause());

        break;

#endif

#ifdef TARGET_NR_utime

    case TARGET_NR_utime:

        {

            struct utimbuf tbuf, *host_tbuf;

            struct target_utimbuf *target_tbuf;

            if (arg2) {

                if (!lock_user_struct(VERIFY_READ, target_tbuf, arg2, 1))

                    goto efault;

                tbuf.actime = tswapl(target_tbuf->actime);

                tbuf.modtime = tswapl(target_tbuf->modtime);

                unlock_user_struct(target_tbuf, arg2, 0);

                host_tbuf = &tbuf;

            } else {

                host_tbuf = NULL;

            }

            if (!(VAR_2 = lock_user_string(arg1)))

                goto efault;

            ret = get_errno(utime(VAR_2, host_tbuf));

            unlock_user(VAR_2, arg1, 0);

        }

        break;

#endif

    case TARGET_NR_utimes:

        {

            struct timeval *VAR_10, VAR_23[2];

            if (arg2) {

                if (copy_from_user_timeval(&VAR_23[0], arg2)

                    || copy_from_user_timeval(&VAR_23[1],

                                              arg2 + sizeof(struct target_timeval)))

                    goto efault;

                VAR_10 = VAR_23;

            } else {

                VAR_10 = NULL;

            }

            if (!(VAR_2 = lock_user_string(arg1)))

                goto efault;

            ret = get_errno(utimes(VAR_2, VAR_10));

            unlock_user(VAR_2, arg1, 0);

        }

        break;

#if defined(TARGET_NR_futimesat) && defined(__NR_futimesat)

    case TARGET_NR_futimesat:

        {

            struct timeval *VAR_10, VAR_23[2];

            if (arg3) {

                if (copy_from_user_timeval(&VAR_23[0], arg3)

                    || copy_from_user_timeval(&VAR_23[1],

                                              arg3 + sizeof(struct target_timeval)))

                    goto efault;

                VAR_10 = VAR_23;

            } else {

                VAR_10 = NULL;

            }

            if (!(VAR_2 = lock_user_string(arg2)))

                goto efault;

            ret = get_errno(sys_futimesat(arg1, path(VAR_2), VAR_10));

            unlock_user(VAR_2, arg2, 0);

        }

        break;

#endif

#ifdef TARGET_NR_stty

    case TARGET_NR_stty:

        goto unimplemented;

#endif

#ifdef TARGET_NR_gtty

    case TARGET_NR_gtty:

        goto unimplemented;

#endif

    case TARGET_NR_access:

        if (!(VAR_2 = lock_user_string(arg1)))

            goto efault;

        ret = get_errno(access(path(VAR_2), arg2));

        unlock_user(VAR_2, arg1, 0);

        break;

#if defined(TARGET_NR_faccessat) && defined(__NR_faccessat)

    case TARGET_NR_faccessat:

        if (!(VAR_2 = lock_user_string(arg2)))

            goto efault;

        ret = get_errno(sys_faccessat(arg1, VAR_2, arg3));

        unlock_user(VAR_2, arg2, 0);

        break;

#endif

#ifdef TARGET_NR_nice 

    case TARGET_NR_nice:

        ret = get_errno(nice(arg1));

        break;

#endif

#ifdef TARGET_NR_ftime

    case TARGET_NR_ftime:

        goto unimplemented;

#endif

    case TARGET_NR_sync:

        sync();

        ret = 0;

        break;

    case TARGET_NR_kill:

        ret = get_errno(kill(arg1, target_to_host_signal(arg2)));

        break;

    case TARGET_NR_rename:

        {

            void *VAR_23;

            VAR_2 = lock_user_string(arg1);

            VAR_23 = lock_user_string(arg2);

            if (!VAR_2 || !VAR_23)

                ret = -TARGET_EFAULT;

            else

                ret = get_errno(rename(VAR_2, VAR_23));

            unlock_user(VAR_23, arg2, 0);

            unlock_user(VAR_2, arg1, 0);

        }

        break;

#if defined(TARGET_NR_renameat) && defined(__NR_renameat)

    case TARGET_NR_renameat:

        {

            void *VAR_23;

            VAR_2  = lock_user_string(arg2);

            VAR_23 = lock_user_string(arg4);

            if (!VAR_2 || !VAR_23)

                ret = -TARGET_EFAULT;

            else

                ret = get_errno(sys_renameat(arg1, VAR_2, arg3, VAR_23));

            unlock_user(VAR_23, arg4, 0);

            unlock_user(VAR_2, arg2, 0);

        }

        break;

#endif

    case TARGET_NR_mkdir:

        if (!(VAR_2 = lock_user_string(arg1)))

            goto efault;

        ret = get_errno(mkdir(VAR_2, arg2));

        unlock_user(VAR_2, arg1, 0);

        break;

#if defined(TARGET_NR_mkdirat) && defined(__NR_mkdirat)

    case TARGET_NR_mkdirat:

        if (!(VAR_2 = lock_user_string(arg2)))

            goto efault;

        ret = get_errno(sys_mkdirat(arg1, VAR_2, arg3));

        unlock_user(VAR_2, arg2, 0);

        break;

#endif

    case TARGET_NR_rmdir:

        if (!(VAR_2 = lock_user_string(arg1)))

            goto efault;

        ret = get_errno(rmdir(VAR_2));

        unlock_user(VAR_2, arg1, 0);

        break;

    case TARGET_NR_dup:

        ret = get_errno(dup(arg1));

        break;

    case TARGET_NR_pipe:

        ret = do_pipe(cpu_env, arg1, 0);

        break;

#ifdef TARGET_NR_pipe2

    case TARGET_NR_pipe2:

        ret = do_pipe(cpu_env, arg1, arg2);

        break;

#endif

    case TARGET_NR_times:

        {

            struct target_tms *VAR_12;

            struct VAR_13 VAR_13;

            ret = get_errno(times(&VAR_13));

            if (arg1) {

                VAR_12 = lock_user(VERIFY_WRITE, arg1, sizeof(struct target_tms), 0);

                if (!VAR_12)

                    goto efault;

                VAR_12->tms_utime = tswapl(host_to_target_clock_t(VAR_13.tms_utime));

                VAR_12->tms_stime = tswapl(host_to_target_clock_t(VAR_13.tms_stime));

                VAR_12->tms_cutime = tswapl(host_to_target_clock_t(VAR_13.tms_cutime));

                VAR_12->tms_cstime = tswapl(host_to_target_clock_t(VAR_13.tms_cstime));

            }

            if (!is_error(ret))

                ret = host_to_target_clock_t(ret);

        }

        break;

#ifdef TARGET_NR_prof

    case TARGET_NR_prof:

        goto unimplemented;

#endif

#ifdef TARGET_NR_signal

    case TARGET_NR_signal:

        goto unimplemented;

#endif

    case TARGET_NR_acct:

        if (arg1 == 0) {

            ret = get_errno(acct(NULL));

        } else {

            if (!(VAR_2 = lock_user_string(arg1)))

                goto efault;

            ret = get_errno(acct(path(VAR_2)));

            unlock_user(VAR_2, arg1, 0);

        }

        break;

#ifdef TARGET_NR_umount2 

    case TARGET_NR_umount2:

        if (!(VAR_2 = lock_user_string(arg1)))

            goto efault;

        ret = get_errno(umount2(VAR_2, arg2));

        unlock_user(VAR_2, arg1, 0);

        break;

#endif

#ifdef TARGET_NR_lock

    case TARGET_NR_lock:

        goto unimplemented;

#endif

    case TARGET_NR_ioctl:

        ret = do_ioctl(arg1, arg2, arg3);

        break;

    case TARGET_NR_fcntl:

        ret = do_fcntl(arg1, arg2, arg3);

        break;

#ifdef TARGET_NR_mpx

    case TARGET_NR_mpx:

        goto unimplemented;

#endif

    case TARGET_NR_setpgid:

        ret = get_errno(setpgid(arg1, arg2));

        break;

#ifdef TARGET_NR_ulimit

    case TARGET_NR_ulimit:

        goto unimplemented;

#endif

#ifdef TARGET_NR_oldolduname

    case TARGET_NR_oldolduname:

        goto unimplemented;

#endif

    case TARGET_NR_umask:

        ret = get_errno(umask(arg1));

        break;

    case TARGET_NR_chroot:

        if (!(VAR_2 = lock_user_string(arg1)))

            goto efault;

        ret = get_errno(chroot(VAR_2));

        unlock_user(VAR_2, arg1, 0);

        break;

    case TARGET_NR_ustat:

        goto unimplemented;

    case TARGET_NR_dup2:

        ret = get_errno(dup2(arg1, arg2));

        break;

#ifdef TARGET_NR_getppid 

    case TARGET_NR_getppid:

        ret = get_errno(getppid());

        break;

#endif

    case TARGET_NR_getpgrp:

        ret = get_errno(getpgrp());

        break;

    case TARGET_NR_setsid:

        ret = get_errno(setsid());

        break;

#ifdef TARGET_NR_sigaction

    case TARGET_NR_sigaction:

        {

#if !defined(TARGET_MIPS)

            struct target_old_sigaction *old_act;

            struct target_sigaction VAR_14, VAR_15, *pact;

            if (arg2) {

                if (!lock_user_struct(VERIFY_READ, old_act, arg2, 1))

                    goto efault;

                VAR_14._sa_handler = old_act->_sa_handler;

                target_siginitset(&VAR_14.sa_mask, old_act->sa_mask);

                VAR_14.sa_flags = old_act->sa_flags;

                VAR_14.sa_restorer = old_act->sa_restorer;

                unlock_user_struct(old_act, arg2, 0);

                pact = &VAR_14;

            } else {

                pact = NULL;

            }

            ret = get_errno(do_sigaction(arg1, pact, &VAR_15));

            if (!is_error(ret) && arg3) {

                if (!lock_user_struct(VERIFY_WRITE, old_act, arg3, 0))

                    goto efault;

                old_act->_sa_handler = VAR_15._sa_handler;

                old_act->sa_mask = VAR_15.sa_mask.sig[0];

                old_act->sa_flags = VAR_15.sa_flags;

                old_act->sa_restorer = VAR_15.sa_restorer;

                unlock_user_struct(old_act, arg3, 1);

            }

#else

	    struct target_sigaction VAR_14, VAR_15, *pact, *old_act;



	    if (arg2) {

                if (!lock_user_struct(VERIFY_READ, old_act, arg2, 1))

                    goto efault;

		VAR_14._sa_handler = old_act->_sa_handler;

		target_siginitset(&VAR_14.sa_mask, old_act->sa_mask.sig[0]);

		VAR_14.sa_flags = old_act->sa_flags;

		unlock_user_struct(old_act, arg2, 0);

		pact = &VAR_14;

	    } else {

		pact = NULL;

	    }



	    ret = get_errno(do_sigaction(arg1, pact, &VAR_15));



	    if (!is_error(ret) && arg3) {

                if (!lock_user_struct(VERIFY_WRITE, old_act, arg3, 0))

                    goto efault;

		old_act->_sa_handler = VAR_15._sa_handler;

		old_act->sa_flags = VAR_15.sa_flags;

		old_act->sa_mask.sig[0] = VAR_15.sa_mask.sig[0];

		old_act->sa_mask.sig[1] = 0;

		old_act->sa_mask.sig[2] = 0;

		old_act->sa_mask.sig[3] = 0;

		unlock_user_struct(old_act, arg3, 1);

	    }

#endif

        }

        break;

#endif

    case TARGET_NR_rt_sigaction:

        {

            struct target_sigaction *VAR_14;

            struct target_sigaction *VAR_15;



            if (arg2) {

                if (!lock_user_struct(VERIFY_READ, VAR_14, arg2, 1))

                    goto efault;

            } else

                VAR_14 = NULL;

            if (arg3) {

                if (!lock_user_struct(VERIFY_WRITE, VAR_15, arg3, 0)) {

                    ret = -TARGET_EFAULT;

                    goto rt_sigaction_fail;

                }

            } else

                VAR_15 = NULL;

            ret = get_errno(do_sigaction(arg1, VAR_14, VAR_15));

	rt_sigaction_fail:

            if (VAR_14)

                unlock_user_struct(VAR_14, arg2, 0);

            if (VAR_15)

                unlock_user_struct(VAR_15, arg3, 1);

        }

        break;

#ifdef TARGET_NR_sgetmask 

    case TARGET_NR_sgetmask:

        {

            sigset_t cur_set;

            abi_ulong target_set;

            sigprocmask(0, NULL, &cur_set);

            host_to_target_old_sigset(&target_set, &cur_set);

            ret = target_set;

        }

        break;

#endif

#ifdef TARGET_NR_ssetmask 

    case TARGET_NR_ssetmask:

        {

            sigset_t set, oset, cur_set;

            abi_ulong target_set = arg1;

            sigprocmask(0, NULL, &cur_set);

            target_to_host_old_sigset(&set, &target_set);

            sigorset(&set, &set, &cur_set);

            sigprocmask(SIG_SETMASK, &set, &oset);

            host_to_target_old_sigset(&target_set, &oset);

            ret = target_set;

        }

        break;

#endif

#ifdef TARGET_NR_sigprocmask

    case TARGET_NR_sigprocmask:

        {

            int VAR_16 = arg1;

            sigset_t set, oldset, *set_ptr;



            if (arg2) {

                switch(VAR_16) {

                case TARGET_SIG_BLOCK:

                    VAR_16 = SIG_BLOCK;

                    break;

                case TARGET_SIG_UNBLOCK:

                    VAR_16 = SIG_UNBLOCK;

                    break;

                case TARGET_SIG_SETMASK:

                    VAR_16 = SIG_SETMASK;

                    break;

                default:

                    ret = -TARGET_EINVAL;

                    goto fail;

                }

                if (!(VAR_2 = lock_user(VERIFY_READ, arg2, sizeof(target_sigset_t), 1)))

                    goto efault;

                target_to_host_old_sigset(&set, VAR_2);

                unlock_user(VAR_2, arg2, 0);

                set_ptr = &set;

            } else {

                VAR_16 = 0;

                set_ptr = NULL;

            }

            ret = get_errno(sigprocmask(arg1, set_ptr, &oldset));

            if (!is_error(ret) && arg3) {

                if (!(VAR_2 = lock_user(VERIFY_WRITE, arg3, sizeof(target_sigset_t), 0)))

                    goto efault;

                host_to_target_old_sigset(VAR_2, &oldset);

                unlock_user(VAR_2, arg3, sizeof(target_sigset_t));

            }

        }

        break;

#endif

    case TARGET_NR_rt_sigprocmask:

        {

            int VAR_16 = arg1;

            sigset_t set, oldset, *set_ptr;



            if (arg2) {

                switch(VAR_16) {

                case TARGET_SIG_BLOCK:

                    VAR_16 = SIG_BLOCK;

                    break;

                case TARGET_SIG_UNBLOCK:

                    VAR_16 = SIG_UNBLOCK;

                    break;

                case TARGET_SIG_SETMASK:

                    VAR_16 = SIG_SETMASK;

                    break;

                default:

                    ret = -TARGET_EINVAL;

                    goto fail;

                }

                if (!(VAR_2 = lock_user(VERIFY_READ, arg2, sizeof(target_sigset_t), 1)))

                    goto efault;

                target_to_host_sigset(&set, VAR_2);

                unlock_user(VAR_2, arg2, 0);

                set_ptr = &set;

            } else {

                VAR_16 = 0;

                set_ptr = NULL;

            }

            ret = get_errno(sigprocmask(VAR_16, set_ptr, &oldset));

            if (!is_error(ret) && arg3) {

                if (!(VAR_2 = lock_user(VERIFY_WRITE, arg3, sizeof(target_sigset_t), 0)))

                    goto efault;

                host_to_target_sigset(VAR_2, &oldset);

                unlock_user(VAR_2, arg3, sizeof(target_sigset_t));

            }

        }

        break;

#ifdef TARGET_NR_sigpending

    case TARGET_NR_sigpending:

        {

            sigset_t set;

            ret = get_errno(sigpending(&set));

            if (!is_error(ret)) {

                if (!(VAR_2 = lock_user(VERIFY_WRITE, arg1, sizeof(target_sigset_t), 0)))

                    goto efault;

                host_to_target_old_sigset(VAR_2, &set);

                unlock_user(VAR_2, arg1, sizeof(target_sigset_t));

            }

        }

        break;

#endif

    case TARGET_NR_rt_sigpending:

        {

            sigset_t set;

            ret = get_errno(sigpending(&set));

            if (!is_error(ret)) {

                if (!(VAR_2 = lock_user(VERIFY_WRITE, arg1, sizeof(target_sigset_t), 0)))

                    goto efault;

                host_to_target_sigset(VAR_2, &set);

                unlock_user(VAR_2, arg1, sizeof(target_sigset_t));

            }

        }

        break;

#ifdef TARGET_NR_sigsuspend

    case TARGET_NR_sigsuspend:

        {

            sigset_t set;

            if (!(VAR_2 = lock_user(VERIFY_READ, arg1, sizeof(target_sigset_t), 1)))

                goto efault;

            target_to_host_old_sigset(&set, VAR_2);

            unlock_user(VAR_2, arg1, 0);

            ret = get_errno(sigsuspend(&set));

        }

        break;

#endif

    case TARGET_NR_rt_sigsuspend:

        {

            sigset_t set;

            if (!(VAR_2 = lock_user(VERIFY_READ, arg1, sizeof(target_sigset_t), 1)))

                goto efault;

            target_to_host_sigset(&set, VAR_2);

            unlock_user(VAR_2, arg1, 0);

            ret = get_errno(sigsuspend(&set));

        }

        break;

    case TARGET_NR_rt_sigtimedwait:

        {

            sigset_t set;

            struct timespec VAR_17, *VAR_18;

            siginfo_t uinfo;



            if (!(VAR_2 = lock_user(VERIFY_READ, arg1, sizeof(target_sigset_t), 1)))

                goto efault;

            target_to_host_sigset(&set, VAR_2);

            unlock_user(VAR_2, arg1, 0);

            if (arg3) {

                VAR_18 = &VAR_17;

                target_to_host_timespec(VAR_18, arg3);

            } else {

                VAR_18 = NULL;

            }

            ret = get_errno(sigtimedwait(&set, &uinfo, VAR_18));

            if (!is_error(ret) && arg2) {

                if (!(VAR_2 = lock_user(VERIFY_WRITE, arg2, sizeof(target_siginfo_t), 0)))

                    goto efault;

                host_to_target_siginfo(VAR_2, &uinfo);

                unlock_user(VAR_2, arg2, sizeof(target_siginfo_t));

            }

        }

        break;

    case TARGET_NR_rt_sigqueueinfo:

        {

            siginfo_t uinfo;

            if (!(VAR_2 = lock_user(VERIFY_READ, arg3, sizeof(target_sigset_t), 1)))

                goto efault;

            target_to_host_siginfo(&uinfo, VAR_2);

            unlock_user(VAR_2, arg1, 0);

            ret = get_errno(sys_rt_sigqueueinfo(arg1, arg2, &uinfo));

        }

        break;

#ifdef TARGET_NR_sigreturn

    case TARGET_NR_sigreturn:

        

        ret = do_sigreturn(cpu_env);

        break;

#endif

    case TARGET_NR_rt_sigreturn:

        

        ret = do_rt_sigreturn(cpu_env);

        break;

    case TARGET_NR_sethostname:

        if (!(VAR_2 = lock_user_string(arg1)))

            goto efault;

        ret = get_errno(sethostname(VAR_2, arg2));

        unlock_user(VAR_2, arg1, 0);

        break;

    case TARGET_NR_setrlimit:

        {

            

            int VAR_22 = arg1;

            struct target_rlimit *VAR_22;

            struct rlimit VAR_22;

            if (!lock_user_struct(VERIFY_READ, VAR_22, arg2, 1))

                goto efault;

            VAR_22.rlim_cur = tswapl(VAR_22->rlim_cur);

            VAR_22.rlim_max = tswapl(VAR_22->rlim_max);

            unlock_user_struct(VAR_22, arg2, 0);

            ret = get_errno(setrlimit(VAR_22, &VAR_22));

        }

        break;

    case TARGET_NR_getrlimit:

        {

            

            int VAR_22 = arg1;

            struct target_rlimit *VAR_22;

            struct rlimit VAR_22;



            ret = get_errno(getrlimit(VAR_22, &VAR_22));

            if (!is_error(ret)) {

                if (!lock_user_struct(VERIFY_WRITE, VAR_22, arg2, 0))

                    goto efault;

                VAR_22->rlim_cur = tswapl(VAR_22.rlim_cur);

                VAR_22->rlim_max = tswapl(VAR_22.rlim_max);

                unlock_user_struct(VAR_22, arg2, 1);

            }

        }

        break;

    case TARGET_NR_getrusage:

        {

            struct VAR_31 VAR_31;

            ret = get_errno(getrusage(arg1, &VAR_31));

            if (!is_error(ret)) {

                host_to_target_rusage(arg2, &VAR_31);

            }

        }

        break;

    case TARGET_NR_gettimeofday:

        {

            struct timeval VAR_23;

            ret = get_errno(gettimeofday(&VAR_23, NULL));

            if (!is_error(ret)) {

                if (copy_to_user_timeval(arg1, &VAR_23))

                    goto efault;

            }

        }

        break;

    case TARGET_NR_settimeofday:

        {

            struct timeval VAR_23;

            if (copy_from_user_timeval(&VAR_23, arg1))

                goto efault;

            ret = get_errno(settimeofday(&VAR_23, NULL));

        }

        break;

#ifdef TARGET_NR_select

    case TARGET_NR_select:

        {

            struct target_sel_arg_struct *sel;

            abi_ulong inp, outp, exp, VAR_10;

            long nsel;



            if (!lock_user_struct(VERIFY_READ, sel, arg1, 1))

                goto efault;

            nsel = tswapl(sel->n);

            inp = tswapl(sel->inp);

            outp = tswapl(sel->outp);

            exp = tswapl(sel->exp);

            VAR_10 = tswapl(sel->VAR_10);

            unlock_user_struct(sel, arg1, 0);

            ret = do_select(nsel, inp, outp, exp, VAR_10);

        }

        break;

#endif

    case TARGET_NR_symlink:

        {

            void *VAR_23;

            VAR_2 = lock_user_string(arg1);

            VAR_23 = lock_user_string(arg2);

            if (!VAR_2 || !VAR_23)

                ret = -TARGET_EFAULT;

            else

                ret = get_errno(symlink(VAR_2, VAR_23));

            unlock_user(VAR_23, arg2, 0);

            unlock_user(VAR_2, arg1, 0);

        }

        break;

#if defined(TARGET_NR_symlinkat) && defined(__NR_symlinkat)

    case TARGET_NR_symlinkat:

        {

            void *VAR_23;

            VAR_2  = lock_user_string(arg1);

            VAR_23 = lock_user_string(arg3);

            if (!VAR_2 || !VAR_23)

                ret = -TARGET_EFAULT;

            else

                ret = get_errno(sys_symlinkat(VAR_2, arg2, VAR_23));

            unlock_user(VAR_23, arg3, 0);

            unlock_user(VAR_2, arg1, 0);

        }

        break;

#endif

#ifdef TARGET_NR_oldlstat

    case TARGET_NR_oldlstat:

        goto unimplemented;

#endif

    case TARGET_NR_readlink:

        {

            void *VAR_23, *VAR_23;

            VAR_2 = lock_user_string(arg1);

            VAR_23 = lock_user(VERIFY_WRITE, arg2, arg3, 0);

            if (!VAR_2 || !VAR_23)

                ret = -TARGET_EFAULT;

            else {

                if (strncmp((const char *)VAR_2, "/proc/self/exe", 14) == 0) {

                    char VAR_24[PATH_MAX];

                    VAR_23 = realpath(exec_path,VAR_24);

                    ret = (VAR_23==NULL) ? get_errno(-1) : strlen(VAR_24) ;

                    snprintf((char *)VAR_23, arg3, "%s", VAR_24);

                    }

                else

                    ret = get_errno(readlink(path(VAR_2), VAR_23, arg3));

            }

            unlock_user(VAR_23, arg2, ret);

            unlock_user(VAR_2, arg1, 0);

        }

        break;

#if defined(TARGET_NR_readlinkat) && defined(__NR_readlinkat)

    case TARGET_NR_readlinkat:

        {

            void *VAR_23;

            VAR_2  = lock_user_string(arg2);

            VAR_23 = lock_user(VERIFY_WRITE, arg3, arg4, 0);

            if (!VAR_2 || !VAR_23)

        	ret = -TARGET_EFAULT;

            else

                ret = get_errno(sys_readlinkat(arg1, path(VAR_2), VAR_23, arg4));

            unlock_user(VAR_23, arg3, ret);

            unlock_user(VAR_2, arg2, 0);

        }

        break;

#endif

#ifdef TARGET_NR_uselib

    case TARGET_NR_uselib:

        goto unimplemented;

#endif

#ifdef TARGET_NR_swapon

    case TARGET_NR_swapon:

        if (!(VAR_2 = lock_user_string(arg1)))

            goto efault;

        ret = get_errno(swapon(VAR_2, arg2));

        unlock_user(VAR_2, arg1, 0);

        break;

#endif

    case TARGET_NR_reboot:

        goto unimplemented;

#ifdef TARGET_NR_readdir

    case TARGET_NR_readdir:

        goto unimplemented;

#endif

#ifdef TARGET_NR_mmap

    case TARGET_NR_mmap:

#if (defined(TARGET_I386) && defined(TARGET_ABI32)) || defined(TARGET_ARM) || defined(TARGET_M68K) || defined(TARGET_CRIS) || defined(TARGET_MICROBLAZE)

        {

            abi_ulong *v;

            abi_ulong v1, v2, v3, v4, v5, v6;

            if (!(v = lock_user(VERIFY_READ, arg1, 6 * sizeof(abi_ulong), 1)))

                goto efault;

            v1 = tswapl(v[0]);

            v2 = tswapl(v[1]);

            v3 = tswapl(v[2]);

            v4 = tswapl(v[3]);

            v5 = tswapl(v[4]);

            v6 = tswapl(v[5]);

            unlock_user(v, arg1, 0);

            ret = get_errno(target_mmap(v1, v2, v3,

                                        target_to_host_bitmask(v4, mmap_flags_tbl),

                                        v5, v6));

        }

#else

        ret = get_errno(target_mmap(arg1, arg2, arg3,

                                    target_to_host_bitmask(arg4, mmap_flags_tbl),

                                    arg5,

                                    arg6));

#endif

        break;

#endif

#ifdef TARGET_NR_mmap2

    case TARGET_NR_mmap2:

#ifndef MMAP_SHIFT

#define MMAP_SHIFT 12

#endif

        ret = get_errno(target_mmap(arg1, arg2, arg3,

                                    target_to_host_bitmask(arg4, mmap_flags_tbl),

                                    arg5,

                                    arg6 << MMAP_SHIFT));

        break;

#endif

    case TARGET_NR_munmap:

        ret = get_errno(target_munmap(arg1, arg2));

        break;

    case TARGET_NR_mprotect:

        ret = get_errno(target_mprotect(arg1, arg2, arg3));

        break;

#ifdef TARGET_NR_mremap

    case TARGET_NR_mremap:

        ret = get_errno(target_mremap(arg1, arg2, arg3, arg4, arg5));

        break;

#endif

        

#ifdef TARGET_NR_msync

    case TARGET_NR_msync:

        ret = get_errno(msync(g2h(arg1), arg2, arg3));

        break;

#endif

#ifdef TARGET_NR_mlock

    case TARGET_NR_mlock:

        ret = get_errno(mlock(g2h(arg1), arg2));

        break;

#endif

#ifdef TARGET_NR_munlock

    case TARGET_NR_munlock:

        ret = get_errno(munlock(g2h(arg1), arg2));

        break;

#endif

#ifdef TARGET_NR_mlockall

    case TARGET_NR_mlockall:

        ret = get_errno(mlockall(arg1));

        break;

#endif

#ifdef TARGET_NR_munlockall

    case TARGET_NR_munlockall:

        ret = get_errno(munlockall());

        break;

#endif

    case TARGET_NR_truncate:

        if (!(VAR_2 = lock_user_string(arg1)))

            goto efault;

        ret = get_errno(truncate(VAR_2, arg2));

        unlock_user(VAR_2, arg1, 0);

        break;

    case TARGET_NR_ftruncate:

        ret = get_errno(ftruncate(arg1, arg2));

        break;

    case TARGET_NR_fchmod:

        ret = get_errno(fchmod(arg1, arg2));

        break;

#if defined(TARGET_NR_fchmodat) && defined(__NR_fchmodat)

    case TARGET_NR_fchmodat:

        if (!(VAR_2 = lock_user_string(arg2)))

            goto efault;

        ret = get_errno(sys_fchmodat(arg1, VAR_2, arg3));

        unlock_user(VAR_2, arg2, 0);

        break;

#endif

    case TARGET_NR_getpriority:

        





        ret = sys_getpriority(arg1, arg2);

        break;

    case TARGET_NR_setpriority:

        ret = get_errno(setpriority(arg1, arg2, arg3));

        break;

#ifdef TARGET_NR_profil

    case TARGET_NR_profil:

        goto unimplemented;

#endif

    case TARGET_NR_statfs:

        if (!(VAR_2 = lock_user_string(arg1)))

            goto efault;

        ret = get_errno(statfs(path(VAR_2), &VAR_1));

        unlock_user(VAR_2, arg1, 0);

    convert_statfs:

        if (!is_error(ret)) {

            struct target_statfs *VAR_25;



            if (!lock_user_struct(VERIFY_WRITE, VAR_25, arg2, 0))

                goto efault;

            __put_user(VAR_1.f_type, &VAR_25->f_type);

            __put_user(VAR_1.f_bsize, &VAR_25->f_bsize);

            __put_user(VAR_1.f_blocks, &VAR_25->f_blocks);

            __put_user(VAR_1.f_bfree, &VAR_25->f_bfree);

            __put_user(VAR_1.f_bavail, &VAR_25->f_bavail);

            __put_user(VAR_1.f_files, &VAR_25->f_files);

            __put_user(VAR_1.f_ffree, &VAR_25->f_ffree);

            __put_user(VAR_1.f_fsid.__val[0], &VAR_25->f_fsid.val[0]);

            __put_user(VAR_1.f_fsid.__val[1], &VAR_25->f_fsid.val[1]);

            __put_user(VAR_1.f_namelen, &VAR_25->f_namelen);

            unlock_user_struct(VAR_25, arg2, 1);

        }

        break;

    case TARGET_NR_fstatfs:

        ret = get_errno(fstatfs(arg1, &VAR_1));

        goto convert_statfs;

#ifdef TARGET_NR_statfs64

    case TARGET_NR_statfs64:

        if (!(VAR_2 = lock_user_string(arg1)))

            goto efault;

        ret = get_errno(statfs(path(VAR_2), &VAR_1));

        unlock_user(VAR_2, arg1, 0);

    convert_statfs64:

        if (!is_error(ret)) {

            struct target_statfs64 *VAR_25;



            if (!lock_user_struct(VERIFY_WRITE, VAR_25, arg3, 0))

                goto efault;

            __put_user(VAR_1.f_type, &VAR_25->f_type);

            __put_user(VAR_1.f_bsize, &VAR_25->f_bsize);

            __put_user(VAR_1.f_blocks, &VAR_25->f_blocks);

            __put_user(VAR_1.f_bfree, &VAR_25->f_bfree);

            __put_user(VAR_1.f_bavail, &VAR_25->f_bavail);

            __put_user(VAR_1.f_files, &VAR_25->f_files);

            __put_user(VAR_1.f_ffree, &VAR_25->f_ffree);

            __put_user(VAR_1.f_fsid.__val[0], &VAR_25->f_fsid.val[0]);

            __put_user(VAR_1.f_fsid.__val[1], &VAR_25->f_fsid.val[1]);

            __put_user(VAR_1.f_namelen, &VAR_25->f_namelen);

            unlock_user_struct(VAR_25, arg3, 1);

        }

        break;

    case TARGET_NR_fstatfs64:

        ret = get_errno(fstatfs(arg1, &VAR_1));

        goto convert_statfs64;

#endif

#ifdef TARGET_NR_ioperm

    case TARGET_NR_ioperm:

        goto unimplemented;

#endif

#ifdef TARGET_NR_socketcall

    case TARGET_NR_socketcall:

        ret = do_socketcall(arg1, arg2);

        break;

#endif

#ifdef TARGET_NR_accept

    case TARGET_NR_accept:

        ret = do_accept(arg1, arg2, arg3);

        break;

#endif

#ifdef TARGET_NR_bind

    case TARGET_NR_bind:

        ret = do_bind(arg1, arg2, arg3);

        break;

#endif

#ifdef TARGET_NR_connect

    case TARGET_NR_connect:

        ret = do_connect(arg1, arg2, arg3);

        break;

#endif

#ifdef TARGET_NR_getpeername

    case TARGET_NR_getpeername:

        ret = do_getpeername(arg1, arg2, arg3);

        break;

#endif

#ifdef TARGET_NR_getsockname

    case TARGET_NR_getsockname:

        ret = do_getsockname(arg1, arg2, arg3);

        break;

#endif

#ifdef TARGET_NR_getsockopt

    case TARGET_NR_getsockopt:

        ret = do_getsockopt(arg1, arg2, arg3, arg4, arg5);

        break;

#endif

#ifdef TARGET_NR_listen

    case TARGET_NR_listen:

        ret = get_errno(listen(arg1, arg2));

        break;

#endif

#ifdef TARGET_NR_recv

    case TARGET_NR_recv:

        ret = do_recvfrom(arg1, arg2, arg3, arg4, 0, 0);

        break;

#endif

#ifdef TARGET_NR_recvfrom

    case TARGET_NR_recvfrom:

        ret = do_recvfrom(arg1, arg2, arg3, arg4, arg5, arg6);

        break;

#endif

#ifdef TARGET_NR_recvmsg

    case TARGET_NR_recvmsg:

        ret = do_sendrecvmsg(arg1, arg2, arg3, 0);

        break;

#endif

#ifdef TARGET_NR_send

    case TARGET_NR_send:

        ret = do_sendto(arg1, arg2, arg3, arg4, 0, 0);

        break;

#endif

#ifdef TARGET_NR_sendmsg

    case TARGET_NR_sendmsg:

        ret = do_sendrecvmsg(arg1, arg2, arg3, 1);

        break;

#endif

#ifdef TARGET_NR_sendto

    case TARGET_NR_sendto:

        ret = do_sendto(arg1, arg2, arg3, arg4, arg5, arg6);

        break;

#endif

#ifdef TARGET_NR_shutdown

    case TARGET_NR_shutdown:

        ret = get_errno(shutdown(arg1, arg2));

        break;

#endif

#ifdef TARGET_NR_socket

    case TARGET_NR_socket:

        ret = do_socket(arg1, arg2, arg3);

        break;

#endif

#ifdef TARGET_NR_socketpair

    case TARGET_NR_socketpair:

        ret = do_socketpair(arg1, arg2, arg3, arg4);

        break;

#endif

#ifdef TARGET_NR_setsockopt

    case TARGET_NR_setsockopt:

        ret = do_setsockopt(arg1, arg2, arg3, arg4, (socklen_t) arg5);

        break;

#endif



    case TARGET_NR_syslog:

        if (!(VAR_2 = lock_user_string(arg2)))

            goto efault;

        ret = get_errno(sys_syslog((int)arg1, VAR_2, (int)arg3));

        unlock_user(VAR_2, arg2, 0);

        break;



    case TARGET_NR_setitimer:

        {

            struct itimerval VAR_33, VAR_27, *VAR_28;



            if (arg2) {

                VAR_28 = &VAR_33;

                if (copy_from_user_timeval(&VAR_28->it_interval, arg2)

                    || copy_from_user_timeval(&VAR_28->it_value,

                                              arg2 + sizeof(struct target_timeval)))

                    goto efault;

            } else {

                VAR_28 = NULL;

            }

            ret = get_errno(setitimer(arg1, VAR_28, &VAR_27));

            if (!is_error(ret) && arg3) {

                if (copy_to_user_timeval(arg3,

                                         &VAR_27.it_interval)

                    || copy_to_user_timeval(arg3 + sizeof(struct target_timeval),

                                            &VAR_27.it_value))

                    goto efault;

            }

        }

        break;

    case TARGET_NR_getitimer:

        {

            struct itimerval VAR_33;



            ret = get_errno(getitimer(arg1, &VAR_33));

            if (!is_error(ret) && arg2) {

                if (copy_to_user_timeval(arg2,

                                         &VAR_33.it_interval)

                    || copy_to_user_timeval(arg2 + sizeof(struct target_timeval),

                                            &VAR_33.it_value))

                    goto efault;

            }

        }

        break;

    case TARGET_NR_stat:

        if (!(VAR_2 = lock_user_string(arg1)))

            goto efault;

        ret = get_errno(stat(path(VAR_2), &VAR_0));

        unlock_user(VAR_2, arg1, 0);

        goto do_stat;

    case TARGET_NR_lstat:

        if (!(VAR_2 = lock_user_string(arg1)))

            goto efault;

        ret = get_errno(lstat(path(VAR_2), &VAR_0));

        unlock_user(VAR_2, arg1, 0);

        goto do_stat;

    case TARGET_NR_fstat:

        {

            ret = get_errno(fstat(arg1, &VAR_0));

        do_stat:

            if (!is_error(ret)) {

                struct target_stat *VAR_29;



                if (!lock_user_struct(VERIFY_WRITE, VAR_29, arg2, 0))

                    goto efault;


                __put_user(VAR_0.st_dev, &VAR_29->st_dev);

                __put_user(VAR_0.st_ino, &VAR_29->st_ino);

                __put_user(VAR_0.st_mode, &VAR_29->st_mode);

                __put_user(VAR_0.st_uid, &VAR_29->st_uid);

                __put_user(VAR_0.st_gid, &VAR_29->st_gid);

                __put_user(VAR_0.st_nlink, &VAR_29->st_nlink);

                __put_user(VAR_0.st_rdev, &VAR_29->st_rdev);

                __put_user(VAR_0.st_size, &VAR_29->st_size);

                __put_user(VAR_0.st_blksize, &VAR_29->st_blksize);

                __put_user(VAR_0.st_blocks, &VAR_29->st_blocks);

                __put_user(VAR_0.st_atime, &VAR_29->target_st_atime);

                __put_user(VAR_0.st_mtime, &VAR_29->target_st_mtime);

                __put_user(VAR_0.st_ctime, &VAR_29->target_st_ctime);

                unlock_user_struct(VAR_29, arg2, 1);

            }

        }

        break;

#ifdef TARGET_NR_olduname

    case TARGET_NR_olduname:

        goto unimplemented;

#endif

#ifdef TARGET_NR_iopl

    case TARGET_NR_iopl:

        goto unimplemented;

#endif

    case TARGET_NR_vhangup:

        ret = get_errno(vhangup());

        break;

#ifdef TARGET_NR_idle

    case TARGET_NR_idle:

        goto unimplemented;

#endif

#ifdef TARGET_NR_syscall

    case TARGET_NR_syscall:

    	ret = FUNC_0(cpu_env,arg1 & 0xffff,arg2,arg3,arg4,arg5,arg6,0);

    	break;

#endif

    case TARGET_NR_wait4:

        {

            int VAR_30;

            abi_long status_ptr = arg2;

            struct VAR_31 VAR_31, *VAR_31;

            abi_ulong target_rusage = arg4;

            if (target_rusage)

                VAR_31 = &VAR_31;

            else

                VAR_31 = NULL;

            ret = get_errno(wait4(arg1, &VAR_30, arg3, VAR_31));

            if (!is_error(ret)) {

                if (status_ptr) {

                    VAR_30 = host_to_target_waitstatus(VAR_30);

                    if (put_user_s32(VAR_30, status_ptr))

                        goto efault;

                }

                if (target_rusage)

                    host_to_target_rusage(target_rusage, &VAR_31);

            }

        }

        break;

#ifdef TARGET_NR_swapoff

    case TARGET_NR_swapoff:

        if (!(VAR_2 = lock_user_string(arg1)))

            goto efault;

        ret = get_errno(swapoff(VAR_2));

        unlock_user(VAR_2, arg1, 0);

        break;

#endif

    case TARGET_NR_sysinfo:

        {

            struct target_sysinfo *VAR_32;

            struct sysinfo VAR_33;

            ret = get_errno(sysinfo(&VAR_33));

            if (!is_error(ret) && arg1)

            {

                if (!lock_user_struct(VERIFY_WRITE, VAR_32, arg1, 0))

                    goto efault;

                __put_user(VAR_33.uptime, &VAR_32->uptime);

                __put_user(VAR_33.loads[0], &VAR_32->loads[0]);

                __put_user(VAR_33.loads[1], &VAR_32->loads[1]);

                __put_user(VAR_33.loads[2], &VAR_32->loads[2]);

                __put_user(VAR_33.totalram, &VAR_32->totalram);

                __put_user(VAR_33.freeram, &VAR_32->freeram);

                __put_user(VAR_33.sharedram, &VAR_32->sharedram);

                __put_user(VAR_33.bufferram, &VAR_32->bufferram);

                __put_user(VAR_33.totalswap, &VAR_32->totalswap);

                __put_user(VAR_33.freeswap, &VAR_32->freeswap);

                __put_user(VAR_33.procs, &VAR_32->procs);

                __put_user(VAR_33.totalhigh, &VAR_32->totalhigh);

                __put_user(VAR_33.freehigh, &VAR_32->freehigh);

                __put_user(VAR_33.mem_unit, &VAR_32->mem_unit);

                unlock_user_struct(VAR_32, arg1, 1);

            }

        }

        break;

#ifdef TARGET_NR_ipc

    case TARGET_NR_ipc:

	ret = do_ipc(arg1, arg2, arg3, arg4, arg5, arg6);

	break;

#endif

#ifdef TARGET_NR_semget

    case TARGET_NR_semget:

        ret = get_errno(semget(arg1, arg2, arg3));

        break;

#endif

#ifdef TARGET_NR_semop

    case TARGET_NR_semop:

        ret = get_errno(do_semop(arg1, arg2, arg3));

        break;

#endif

#ifdef TARGET_NR_semctl

    case TARGET_NR_semctl:

        ret = do_semctl(arg1, arg2, arg3, (union target_semun)(abi_ulong)arg4);

        break;

#endif

#ifdef TARGET_NR_msgctl

    case TARGET_NR_msgctl:

        ret = do_msgctl(arg1, arg2, arg3);

        break;

#endif

#ifdef TARGET_NR_msgget

    case TARGET_NR_msgget:

        ret = get_errno(msgget(arg1, arg2));

        break;

#endif

#ifdef TARGET_NR_msgrcv

    case TARGET_NR_msgrcv:

        ret = do_msgrcv(arg1, arg2, arg3, arg4, arg5);

        break;

#endif

#ifdef TARGET_NR_msgsnd

    case TARGET_NR_msgsnd:

        ret = do_msgsnd(arg1, arg2, arg3, arg4);

        break;

#endif

#ifdef TARGET_NR_shmget

    case TARGET_NR_shmget:

        ret = get_errno(shmget(arg1, arg2, arg3));

        break;

#endif

#ifdef TARGET_NR_shmctl

    case TARGET_NR_shmctl:

        ret = do_shmctl(arg1, arg2, arg3);

        break;

#endif

#ifdef TARGET_NR_shmat

    case TARGET_NR_shmat:

        ret = do_shmat(arg1, arg2, arg3);

        break;

#endif

#ifdef TARGET_NR_shmdt

    case TARGET_NR_shmdt:

        ret = do_shmdt(arg1);

        break;

#endif

    case TARGET_NR_fsync:

        ret = get_errno(fsync(arg1));

        break;

    case TARGET_NR_clone:

#if defined(TARGET_SH4)

        ret = get_errno(do_fork(cpu_env, arg1, arg2, arg3, arg5, arg4));

#elif defined(TARGET_CRIS)

        ret = get_errno(do_fork(cpu_env, arg2, arg1, arg3, arg4, arg5));

#else

        ret = get_errno(do_fork(cpu_env, arg1, arg2, arg3, arg4, arg5));

#endif

        break;

#ifdef __NR_exit_group

        

    case TARGET_NR_exit_group:

#ifdef TARGET_GPROF

        _mcleanup();

#endif

        gdb_exit(cpu_env, arg1);

        ret = get_errno(exit_group(arg1));

        break;

#endif

    case TARGET_NR_setdomainname:

        if (!(VAR_2 = lock_user_string(arg1)))

            goto efault;

        ret = get_errno(setdomainname(VAR_2, arg2));

        unlock_user(VAR_2, arg1, 0);

        break;

    case TARGET_NR_uname:

        

        {

            struct new_utsname * VAR_33;



            if (!lock_user_struct(VERIFY_WRITE, VAR_33, arg1, 0))

                goto efault;

            ret = get_errno(sys_uname(VAR_33));

            if (!is_error(ret)) {

                



                strcpy (VAR_33->machine, UNAME_MACHINE);

                

                if (qemu_uname_release && *qemu_uname_release)

                  strcpy (VAR_33->release, qemu_uname_release);

            }

            unlock_user_struct(VAR_33, arg1, 1);

        }

        break;

#ifdef TARGET_I386

    case TARGET_NR_modify_ldt:

        ret = do_modify_ldt(cpu_env, arg1, arg2, arg3);

        break;

#if !defined(TARGET_X86_64)

    case TARGET_NR_vm86old:

        goto unimplemented;

    case TARGET_NR_vm86:

        ret = do_vm86(cpu_env, arg1, arg2);

        break;

#endif

#endif

    case TARGET_NR_adjtimex:

        goto unimplemented;

#ifdef TARGET_NR_create_module

    case TARGET_NR_create_module:

#endif

    case TARGET_NR_init_module:

    case TARGET_NR_delete_module:

#ifdef TARGET_NR_get_kernel_syms

    case TARGET_NR_get_kernel_syms:

#endif

        goto unimplemented;

    case TARGET_NR_quotactl:

        goto unimplemented;

    case TARGET_NR_getpgid:

        ret = get_errno(getpgid(arg1));

        break;

    case TARGET_NR_fchdir:

        ret = get_errno(fchdir(arg1));

        break;

#ifdef TARGET_NR_bdflush 

    case TARGET_NR_bdflush:

        goto unimplemented;

#endif

#ifdef TARGET_NR_sysfs

    case TARGET_NR_sysfs:

        goto unimplemented;

#endif

    case TARGET_NR_personality:

        ret = get_errno(personality(arg1));

        break;

#ifdef TARGET_NR_afs_syscall

    case TARGET_NR_afs_syscall:

        goto unimplemented;

#endif

#ifdef TARGET_NR__llseek 

    case TARGET_NR__llseek:

        {

#if defined (__x86_64__)

            ret = get_errno(lseek(arg1, ((uint64_t )arg2 << 32) | arg3, arg5));

            if (put_user_s64(ret, arg4))

                goto efault;

#else

            int64_t res;

            ret = get_errno(_llseek(arg1, arg2, arg3, &res, arg5));

            if (put_user_s64(res, arg4))

                goto efault;

#endif

        }

        break;

#endif

    case TARGET_NR_getdents:

#if TARGET_ABI_BITS == 32 && HOST_LONG_BITS == 64

        {

            struct target_dirent *target_dirp;

            struct linux_dirent *VAR_34;

            abi_long VAR_40 = arg3;



	    VAR_34 = malloc(VAR_40);

	    if (!VAR_34) {

                ret = -TARGET_ENOMEM;

                goto fail;

            }



            ret = get_errno(sys_getdents(arg1, VAR_34, VAR_40));

            if (!is_error(ret)) {

                struct linux_dirent *VAR_35;

		struct target_dirent *tde;

                int VAR_36 = ret;

                int VAR_37, treclen;

		int count1, tnamelen;



		count1 = 0;

                VAR_35 = VAR_34;

                if (!(target_dirp = lock_user(VERIFY_WRITE, arg2, VAR_40, 0)))

                    goto efault;

		tde = target_dirp;

                while (VAR_36 > 0) {

                    VAR_37 = VAR_35->d_reclen;

		    treclen = VAR_37 - (2 * (sizeof(long) - sizeof(abi_long)));

                    tde->d_reclen = tswap16(treclen);

                    tde->d_ino = tswapl(VAR_35->d_ino);

                    tde->d_off = tswapl(VAR_35->d_off);

		    tnamelen = treclen - (2 * sizeof(abi_long) + 2);

		    if (tnamelen > 256)

                        tnamelen = 256;

                    

                    pstrcpy(tde->d_name, tnamelen, VAR_35->d_name);

                    VAR_35 = (struct linux_dirent *)((char *)VAR_35 + VAR_37);

                    VAR_36 -= VAR_37;

                    tde = (struct target_dirent *)((char *)tde + treclen);

		    count1 += treclen;

                }

		ret = count1;

                unlock_user(target_dirp, arg2, ret);

            }

	    free(VAR_34);

        }

#else

        {

            struct linux_dirent *VAR_34;

            abi_long VAR_40 = arg3;



            if (!(VAR_34 = lock_user(VERIFY_WRITE, arg2, VAR_40, 0)))

                goto efault;

            ret = get_errno(sys_getdents(arg1, VAR_34, VAR_40));

            if (!is_error(ret)) {

                struct linux_dirent *VAR_35;

                int VAR_36 = ret;

                int VAR_37;

                VAR_35 = VAR_34;

                while (VAR_36 > 0) {

                    VAR_37 = VAR_35->d_reclen;

                    if (VAR_37 > VAR_36)

                        break;

                    VAR_35->d_reclen = tswap16(VAR_37);

                    tswapls(&VAR_35->d_ino);

                    tswapls(&VAR_35->d_off);

                    VAR_35 = (struct linux_dirent *)((char *)VAR_35 + VAR_37);

                    VAR_36 -= VAR_37;

                }

            }

            unlock_user(VAR_34, arg2, ret);

        }

#endif

        break;

#if defined(TARGET_NR_getdents64) && defined(__NR_getdents64)

    case TARGET_NR_getdents64:

        {

            struct linux_dirent64 *VAR_34;

            abi_long VAR_40 = arg3;

            if (!(VAR_34 = lock_user(VERIFY_WRITE, arg2, VAR_40, 0)))

                goto efault;

            ret = get_errno(sys_getdents64(arg1, VAR_34, VAR_40));

            if (!is_error(ret)) {

                struct linux_dirent64 *VAR_35;

                int VAR_36 = ret;

                int VAR_37;

                VAR_35 = VAR_34;

                while (VAR_36 > 0) {

                    VAR_37 = VAR_35->d_reclen;

                    if (VAR_37 > VAR_36)

                        break;

                    VAR_35->d_reclen = tswap16(VAR_37);

                    tswap64s((uint64_t *)&VAR_35->d_ino);

                    tswap64s((uint64_t *)&VAR_35->d_off);

                    VAR_35 = (struct linux_dirent64 *)((char *)VAR_35 + VAR_37);

                    VAR_36 -= VAR_37;

                }

            }

            unlock_user(VAR_34, arg2, ret);

        }

        break;

#endif 

#ifdef TARGET_NR__newselect

    case TARGET_NR__newselect:

        ret = do_select(arg1, arg2, arg3, arg4, arg5);

        break;

#endif

#ifdef TARGET_NR_poll

    case TARGET_NR_poll:

        {

            struct target_pollfd *target_pfd;

            unsigned int nfds = arg2;

            int timeout = arg3;

            struct pollfd *pfd;

            unsigned int i;



            target_pfd = lock_user(VERIFY_WRITE, arg1, sizeof(struct target_pollfd) * nfds, 1);

            if (!target_pfd)

                goto efault;

            pfd = alloca(sizeof(struct pollfd) * nfds);

            for(i = 0; i < nfds; i++) {

                pfd[i].fd = tswap32(target_pfd[i].fd);

                pfd[i].events = tswap16(target_pfd[i].events);

            }

            ret = get_errno(poll(pfd, nfds, timeout));

            if (!is_error(ret)) {

                for(i = 0; i < nfds; i++) {

                    target_pfd[i].revents = tswap16(pfd[i].revents);

                }

                ret += nfds * (sizeof(struct target_pollfd)

                               - sizeof(struct pollfd));

            }

            unlock_user(target_pfd, arg1, ret);

        }

        break;

#endif

    case TARGET_NR_flock:

        



        ret = get_errno(flock(arg1, arg2));

        break;

    case TARGET_NR_readv:

        {

            int VAR_40 = arg3;

            struct iovec *VAR_40;



            VAR_40 = alloca(VAR_40 * sizeof(struct iovec));

            if (lock_iovec(VERIFY_WRITE, VAR_40, arg2, VAR_40, 0) < 0)

                goto efault;

            ret = get_errno(readv(arg1, VAR_40, VAR_40));

            unlock_iovec(VAR_40, arg2, VAR_40, 1);

        }

        break;

    case TARGET_NR_writev:

        {

            int VAR_40 = arg3;

            struct iovec *VAR_40;



            VAR_40 = alloca(VAR_40 * sizeof(struct iovec));

            if (lock_iovec(VERIFY_READ, VAR_40, arg2, VAR_40, 1) < 0)

                goto efault;

            ret = get_errno(writev(arg1, VAR_40, VAR_40));

            unlock_iovec(VAR_40, arg2, VAR_40, 0);

        }

        break;

    case TARGET_NR_getsid:

        ret = get_errno(getsid(arg1));

        break;

#if defined(TARGET_NR_fdatasync) 

    case TARGET_NR_fdatasync:

        ret = get_errno(fdatasync(arg1));

        break;

#endif

    case TARGET_NR__sysctl:

        



        ret = -TARGET_ENOTDIR;

        break;

    case TARGET_NR_sched_setparam:

        {

            struct sched_param *VAR_42;

            struct sched_param VAR_42;



            if (!lock_user_struct(VERIFY_READ, VAR_42, arg2, 1))

                goto efault;

            VAR_42.sched_priority = tswap32(VAR_42->sched_priority);

            unlock_user_struct(VAR_42, arg2, 0);

            ret = get_errno(sched_setparam(arg1, &VAR_42));

        }

        break;

    case TARGET_NR_sched_getparam:

        {

            struct sched_param *VAR_42;

            struct sched_param VAR_42;

            ret = get_errno(sched_getparam(arg1, &VAR_42));

            if (!is_error(ret)) {

                if (!lock_user_struct(VERIFY_WRITE, VAR_42, arg2, 0))

                    goto efault;

                VAR_42->sched_priority = tswap32(VAR_42.sched_priority);

                unlock_user_struct(VAR_42, arg2, 1);

            }

        }

        break;

    case TARGET_NR_sched_setscheduler:

        {

            struct sched_param *VAR_42;

            struct sched_param VAR_42;

            if (!lock_user_struct(VERIFY_READ, VAR_42, arg3, 1))

                goto efault;

            VAR_42.sched_priority = tswap32(VAR_42->sched_priority);

            unlock_user_struct(VAR_42, arg3, 0);

            ret = get_errno(sched_setscheduler(arg1, arg2, &VAR_42));

        }

        break;

    case TARGET_NR_sched_getscheduler:

        ret = get_errno(sched_getscheduler(arg1));

        break;

    case TARGET_NR_sched_yield:

        ret = get_errno(sched_yield());

        break;

    case TARGET_NR_sched_get_priority_max:

        ret = get_errno(sched_get_priority_max(arg1));

        break;

    case TARGET_NR_sched_get_priority_min:

        ret = get_errno(sched_get_priority_min(arg1));

        break;

    case TARGET_NR_sched_rr_get_interval:

        {

            struct timespec VAR_42;

            ret = get_errno(sched_rr_get_interval(arg1, &VAR_42));

            if (!is_error(ret)) {

                host_to_target_timespec(arg2, &VAR_42);

            }

        }

        break;

    case TARGET_NR_nanosleep:

        {

            struct timespec VAR_43, VAR_44;

            target_to_host_timespec(&VAR_43, arg1);

            ret = get_errno(nanosleep(&VAR_43, &VAR_44));

            if (is_error(ret) && arg2) {

                host_to_target_timespec(arg2, &VAR_44);

            }

        }

        break;

#ifdef TARGET_NR_query_module

    case TARGET_NR_query_module:

        goto unimplemented;

#endif

#ifdef TARGET_NR_nfsservctl

    case TARGET_NR_nfsservctl:

        goto unimplemented;

#endif

    case TARGET_NR_prctl:

        switch (arg1)

            {

            case PR_GET_PDEATHSIG:

                {

                    int VAR_45;

                    ret = get_errno(prctl(arg1, &VAR_45, arg3, arg4, arg5));

                    if (!is_error(ret) && arg2

                        && put_user_ual(VAR_45, arg2))

                        goto efault;

                }

                break;

            default:

                ret = get_errno(prctl(arg1, arg2, arg3, arg4, arg5));

                break;

            }

        break;

#ifdef TARGET_NR_arch_prctl

    case TARGET_NR_arch_prctl:

#if defined(TARGET_I386) && !defined(TARGET_ABI32)

        ret = do_arch_prctl(cpu_env, arg1, arg2);

        break;

#else

        goto unimplemented;

#endif

#endif

#ifdef TARGET_NR_pread

    case TARGET_NR_pread:

#ifdef TARGET_ARM

        if (((CPUARMState *)cpu_env)->eabi)

            arg4 = arg5;

#endif

        if (!(VAR_2 = lock_user(VERIFY_WRITE, arg2, arg3, 0)))

            goto efault;

        ret = get_errno(pread(arg1, VAR_2, arg3, arg4));

        unlock_user(VAR_2, arg2, ret);

        break;

    case TARGET_NR_pwrite:

#ifdef TARGET_ARM

        if (((CPUARMState *)cpu_env)->eabi)

            arg4 = arg5;

#endif

        if (!(VAR_2 = lock_user(VERIFY_READ, arg2, arg3, 1)))

            goto efault;

        ret = get_errno(pwrite(arg1, VAR_2, arg3, arg4));

        unlock_user(VAR_2, arg2, 0);

        break;

#endif

#ifdef TARGET_NR_pread64

    case TARGET_NR_pread64:

        if (!(VAR_2 = lock_user(VERIFY_WRITE, arg2, arg3, 0)))

            goto efault;

        ret = get_errno(pread64(arg1, VAR_2, arg3, target_offset64(arg4, arg5)));

        unlock_user(VAR_2, arg2, ret);

        break;

    case TARGET_NR_pwrite64:

        if (!(VAR_2 = lock_user(VERIFY_READ, arg2, arg3, 1)))

            goto efault;

        ret = get_errno(pwrite64(arg1, VAR_2, arg3, target_offset64(arg4, arg5)));

        unlock_user(VAR_2, arg2, 0);

        break;

#endif

    case TARGET_NR_getcwd:

        if (!(VAR_2 = lock_user(VERIFY_WRITE, arg1, arg2, 0)))

            goto efault;

        ret = get_errno(sys_getcwd1(VAR_2, arg2));

        unlock_user(VAR_2, arg1, ret);

        break;

    case TARGET_NR_capget:

        goto unimplemented;

    case TARGET_NR_capset:

        goto unimplemented;

    case TARGET_NR_sigaltstack:

#if defined(TARGET_I386) || defined(TARGET_ARM) || defined(TARGET_MIPS) || \

    defined(TARGET_SPARC) || defined(TARGET_PPC) || defined(TARGET_ALPHA) || \

    defined(TARGET_M68K)

        ret = do_sigaltstack(arg1, arg2, get_sp_from_cpustate((CPUState *)cpu_env));

        break;

#else

        goto unimplemented;

#endif

    case TARGET_NR_sendfile:

        goto unimplemented;

#ifdef TARGET_NR_getpmsg

    case TARGET_NR_getpmsg:

        goto unimplemented;

#endif

#ifdef TARGET_NR_putpmsg

    case TARGET_NR_putpmsg:

        goto unimplemented;

#endif

#ifdef TARGET_NR_vfork

    case TARGET_NR_vfork:

        ret = get_errno(do_fork(cpu_env, CLONE_VFORK | CLONE_VM | SIGCHLD,

                        0, 0, 0, 0));

        break;

#endif

#ifdef TARGET_NR_ugetrlimit

    case TARGET_NR_ugetrlimit:

    {

	struct rlimit VAR_22;

	ret = get_errno(getrlimit(arg1, &VAR_22));

	if (!is_error(ret)) {

	    struct target_rlimit *VAR_22;

            if (!lock_user_struct(VERIFY_WRITE, VAR_22, arg2, 0))

                goto efault;

	    VAR_22->rlim_cur = tswapl(VAR_22.rlim_cur);

	    VAR_22->rlim_max = tswapl(VAR_22.rlim_max);

            unlock_user_struct(VAR_22, arg2, 1);

	}

	break;

    }

#endif

#ifdef TARGET_NR_truncate64

    case TARGET_NR_truncate64:

        if (!(VAR_2 = lock_user_string(arg1)))

            goto efault;

	ret = target_truncate64(cpu_env, VAR_2, arg2, arg3, arg4);

        unlock_user(VAR_2, arg1, 0);

	break;

#endif

#ifdef TARGET_NR_ftruncate64

    case TARGET_NR_ftruncate64:

	ret = target_ftruncate64(cpu_env, arg1, arg2, arg3, arg4);

	break;

#endif

#ifdef TARGET_NR_stat64

    case TARGET_NR_stat64:

        if (!(VAR_2 = lock_user_string(arg1)))

            goto efault;

        ret = get_errno(stat(path(VAR_2), &VAR_0));

        unlock_user(VAR_2, arg1, 0);

        if (!is_error(ret))

            ret = host_to_target_stat64(cpu_env, arg2, &VAR_0);

        break;

#endif

#ifdef TARGET_NR_lstat64

    case TARGET_NR_lstat64:

        if (!(VAR_2 = lock_user_string(arg1)))

            goto efault;

        ret = get_errno(lstat(path(VAR_2), &VAR_0));

        unlock_user(VAR_2, arg1, 0);

        if (!is_error(ret))

            ret = host_to_target_stat64(cpu_env, arg2, &VAR_0);

        break;

#endif

#ifdef TARGET_NR_fstat64

    case TARGET_NR_fstat64:

        ret = get_errno(fstat(arg1, &VAR_0));

        if (!is_error(ret))

            ret = host_to_target_stat64(cpu_env, arg2, &VAR_0);

        break;

#endif

#if (defined(TARGET_NR_fstatat64) || defined(TARGET_NR_newfstatat)) && \

        (defined(__NR_fstatat64) || defined(__NR_newfstatat))

#ifdef TARGET_NR_fstatat64

    case TARGET_NR_fstatat64:

#endif

#ifdef TARGET_NR_newfstatat

    case TARGET_NR_newfstatat:

#endif

        if (!(VAR_2 = lock_user_string(arg2)))

            goto efault;

#ifdef __NR_fstatat64

        ret = get_errno(sys_fstatat64(arg1, path(VAR_2), &VAR_0, arg4));

#else

        ret = get_errno(sys_newfstatat(arg1, path(VAR_2), &VAR_0, arg4));

#endif

        if (!is_error(ret))

            ret = host_to_target_stat64(cpu_env, arg3, &VAR_0);

        break;

#endif

#ifdef USE_UID16

    case TARGET_NR_lchown:

        if (!(VAR_2 = lock_user_string(arg1)))

            goto efault;

        ret = get_errno(lchown(VAR_2, low2highuid(arg2), low2highgid(arg3)));

        unlock_user(VAR_2, arg1, 0);

        break;

    case TARGET_NR_getuid:

        ret = get_errno(high2lowuid(getuid()));

        break;

    case TARGET_NR_getgid:

        ret = get_errno(high2lowgid(getgid()));

        break;

    case TARGET_NR_geteuid:

        ret = get_errno(high2lowuid(geteuid()));

        break;

    case TARGET_NR_getegid:

        ret = get_errno(high2lowgid(getegid()));

        break;

    case TARGET_NR_setreuid:

        ret = get_errno(setreuid(low2highuid(arg1), low2highuid(arg2)));

        break;

    case TARGET_NR_setregid:

        ret = get_errno(setregid(low2highgid(arg1), low2highgid(arg2)));

        break;

    case TARGET_NR_getgroups:

        {

            int gidsetsize = arg1;

            uint16_t *target_grouplist;

            gid_t *grouplist;

            int i;



            grouplist = alloca(gidsetsize * sizeof(gid_t));

            ret = get_errno(getgroups(gidsetsize, grouplist));

            if (gidsetsize == 0)

                break;

            if (!is_error(ret)) {

                target_grouplist = lock_user(VERIFY_WRITE, arg2, gidsetsize * 2, 0);

                if (!target_grouplist)

                    goto efault;

                for(i = 0;i < ret; i++)

                    target_grouplist[i] = tswap16(grouplist[i]);

                unlock_user(target_grouplist, arg2, gidsetsize * 2);

            }

        }

        break;

    case TARGET_NR_setgroups:

        {

            int gidsetsize = arg1;

            uint16_t *target_grouplist;

            gid_t *grouplist;

            int i;



            grouplist = alloca(gidsetsize * sizeof(gid_t));

            target_grouplist = lock_user(VERIFY_READ, arg2, gidsetsize * 2, 1);

            if (!target_grouplist) {

                ret = -TARGET_EFAULT;

                goto fail;

            }

            for(i = 0;i < gidsetsize; i++)

                grouplist[i] = tswap16(target_grouplist[i]);

            unlock_user(target_grouplist, arg2, 0);

            ret = get_errno(setgroups(gidsetsize, grouplist));

        }

        break;

    case TARGET_NR_fchown:

        ret = get_errno(fchown(arg1, low2highuid(arg2), low2highgid(arg3)));

        break;

#if defined(TARGET_NR_fchownat) && defined(__NR_fchownat)

    case TARGET_NR_fchownat:

        if (!(VAR_2 = lock_user_string(arg2))) 

            goto efault;

        ret = get_errno(sys_fchownat(arg1, VAR_2, low2highuid(arg3), low2highgid(arg4), arg5));

        unlock_user(VAR_2, arg2, 0);

        break;

#endif

#ifdef TARGET_NR_setresuid

    case TARGET_NR_setresuid:

        ret = get_errno(setresuid(low2highuid(arg1),

                                  low2highuid(arg2),

                                  low2highuid(arg3)));

        break;

#endif

#ifdef TARGET_NR_getresuid

    case TARGET_NR_getresuid:

        {

            uid_t ruid, euid, suid;

            ret = get_errno(getresuid(&ruid, &euid, &suid));

            if (!is_error(ret)) {

                if (put_user_u16(high2lowuid(ruid), arg1)

                    || put_user_u16(high2lowuid(euid), arg2)

                    || put_user_u16(high2lowuid(suid), arg3))

                    goto efault;

            }

        }

        break;

#endif

#ifdef TARGET_NR_getresgid

    case TARGET_NR_setresgid:

        ret = get_errno(setresgid(low2highgid(arg1),

                                  low2highgid(arg2),

                                  low2highgid(arg3)));

        break;

#endif

#ifdef TARGET_NR_getresgid

    case TARGET_NR_getresgid:

        {

            gid_t rgid, egid, sgid;

            ret = get_errno(getresgid(&rgid, &egid, &sgid));

            if (!is_error(ret)) {

                if (put_user_u16(high2lowgid(rgid), arg1)

                    || put_user_u16(high2lowgid(egid), arg2)

                    || put_user_u16(high2lowgid(sgid), arg3))

                    goto efault;

            }

        }

        break;

#endif

    case TARGET_NR_chown:

        if (!(VAR_2 = lock_user_string(arg1)))

            goto efault;

        ret = get_errno(chown(VAR_2, low2highuid(arg2), low2highgid(arg3)));

        unlock_user(VAR_2, arg1, 0);

        break;

    case TARGET_NR_setuid:

        ret = get_errno(setuid(low2highuid(arg1)));

        break;

    case TARGET_NR_setgid:

        ret = get_errno(setgid(low2highgid(arg1)));

        break;

    case TARGET_NR_setfsuid:

        ret = get_errno(setfsuid(arg1));

        break;

    case TARGET_NR_setfsgid:

        ret = get_errno(setfsgid(arg1));

        break;

#endif 



#ifdef TARGET_NR_lchown32

    case TARGET_NR_lchown32:

        if (!(VAR_2 = lock_user_string(arg1)))

            goto efault;

        ret = get_errno(lchown(VAR_2, arg2, arg3));

        unlock_user(VAR_2, arg1, 0);

        break;

#endif

#ifdef TARGET_NR_getuid32

    case TARGET_NR_getuid32:

        ret = get_errno(getuid());

        break;

#endif



#if defined(TARGET_NR_getxuid) && defined(TARGET_ALPHA)

   

    case TARGET_NR_getxuid:

	 {

	    uid_t euid;

	    euid=geteuid();

	    ((CPUAlphaState *)cpu_env)->ir[IR_A4]=euid;

	 }

        ret = get_errno(getuid());

        break;

#endif

#if defined(TARGET_NR_getxgid) && defined(TARGET_ALPHA)

   

    case TARGET_NR_getxgid:

	 {

	    uid_t egid;

	    egid=getegid();

	    ((CPUAlphaState *)cpu_env)->ir[IR_A4]=egid;

	 }

        ret = get_errno(getgid());

        break;

#endif



#ifdef TARGET_NR_getgid32

    case TARGET_NR_getgid32:

        ret = get_errno(getgid());

        break;

#endif

#ifdef TARGET_NR_geteuid32

    case TARGET_NR_geteuid32:

        ret = get_errno(geteuid());

        break;

#endif

#ifdef TARGET_NR_getegid32

    case TARGET_NR_getegid32:

        ret = get_errno(getegid());

        break;

#endif

#ifdef TARGET_NR_setreuid32

    case TARGET_NR_setreuid32:

        ret = get_errno(setreuid(arg1, arg2));

        break;

#endif

#ifdef TARGET_NR_setregid32

    case TARGET_NR_setregid32:

        ret = get_errno(setregid(arg1, arg2));

        break;

#endif

#ifdef TARGET_NR_getgroups32

    case TARGET_NR_getgroups32:

        {

            int gidsetsize = arg1;

            uint32_t *target_grouplist;

            gid_t *grouplist;

            int i;



            grouplist = alloca(gidsetsize * sizeof(gid_t));

            ret = get_errno(getgroups(gidsetsize, grouplist));

            if (gidsetsize == 0)

                break;

            if (!is_error(ret)) {

                target_grouplist = lock_user(VERIFY_WRITE, arg2, gidsetsize * 4, 0);

                if (!target_grouplist) {

                    ret = -TARGET_EFAULT;

                    goto fail;

                }

                for(i = 0;i < ret; i++)

                    target_grouplist[i] = tswap32(grouplist[i]);

                unlock_user(target_grouplist, arg2, gidsetsize * 4);

            }

        }

        break;

#endif

#ifdef TARGET_NR_setgroups32

    case TARGET_NR_setgroups32:

        {

            int gidsetsize = arg1;

            uint32_t *target_grouplist;

            gid_t *grouplist;

            int i;



            grouplist = alloca(gidsetsize * sizeof(gid_t));

            target_grouplist = lock_user(VERIFY_READ, arg2, gidsetsize * 4, 1);

            if (!target_grouplist) {

                ret = -TARGET_EFAULT;

                goto fail;

            }

            for(i = 0;i < gidsetsize; i++)

                grouplist[i] = tswap32(target_grouplist[i]);

            unlock_user(target_grouplist, arg2, 0);

            ret = get_errno(setgroups(gidsetsize, grouplist));

        }

        break;

#endif

#ifdef TARGET_NR_fchown32

    case TARGET_NR_fchown32:

        ret = get_errno(fchown(arg1, arg2, arg3));

        break;

#endif

#ifdef TARGET_NR_setresuid32

    case TARGET_NR_setresuid32:

        ret = get_errno(setresuid(arg1, arg2, arg3));

        break;

#endif

#ifdef TARGET_NR_getresuid32

    case TARGET_NR_getresuid32:

        {

            uid_t ruid, euid, suid;

            ret = get_errno(getresuid(&ruid, &euid, &suid));

            if (!is_error(ret)) {

                if (put_user_u32(ruid, arg1)

                    || put_user_u32(euid, arg2)

                    || put_user_u32(suid, arg3))

                    goto efault;

            }

        }

        break;

#endif

#ifdef TARGET_NR_setresgid32

    case TARGET_NR_setresgid32:

        ret = get_errno(setresgid(arg1, arg2, arg3));

        break;

#endif

#ifdef TARGET_NR_getresgid32

    case TARGET_NR_getresgid32:

        {

            gid_t rgid, egid, sgid;

            ret = get_errno(getresgid(&rgid, &egid, &sgid));

            if (!is_error(ret)) {

                if (put_user_u32(rgid, arg1)

                    || put_user_u32(egid, arg2)

                    || put_user_u32(sgid, arg3))

                    goto efault;

            }

        }

        break;

#endif

#ifdef TARGET_NR_chown32

    case TARGET_NR_chown32:

        if (!(VAR_2 = lock_user_string(arg1)))

            goto efault;

        ret = get_errno(chown(VAR_2, arg2, arg3));

        unlock_user(VAR_2, arg1, 0);

        break;

#endif

#ifdef TARGET_NR_setuid32

    case TARGET_NR_setuid32:

        ret = get_errno(setuid(arg1));

        break;

#endif

#ifdef TARGET_NR_setgid32

    case TARGET_NR_setgid32:

        ret = get_errno(setgid(arg1));

        break;

#endif

#ifdef TARGET_NR_setfsuid32

    case TARGET_NR_setfsuid32:

        ret = get_errno(setfsuid(arg1));

        break;

#endif

#ifdef TARGET_NR_setfsgid32

    case TARGET_NR_setfsgid32:

        ret = get_errno(setfsgid(arg1));

        break;

#endif



    case TARGET_NR_pivot_root:

        goto unimplemented;

#ifdef TARGET_NR_mincore

    case TARGET_NR_mincore:

        {

            void *a;

            ret = -TARGET_EFAULT;

            if (!(a = lock_user(VERIFY_READ, arg1,arg2, 0)))

                goto efault;

            if (!(VAR_2 = lock_user_string(arg3)))

                goto mincore_fail;

            ret = get_errno(mincore(a, arg2, VAR_2));

            unlock_user(VAR_2, arg3, ret);

            mincore_fail:

            unlock_user(a, arg1, 0);

        }

        break;

#endif

#ifdef TARGET_NR_arm_fadvise64_64

    case TARGET_NR_arm_fadvise64_64:

	{

		







		abi_long VAR_23;

		VAR_23 = arg3;

		arg3 = arg4;

		arg4 = VAR_23;

	}

#endif

#if defined(TARGET_NR_fadvise64_64) || defined(TARGET_NR_arm_fadvise64_64) || defined(TARGET_NR_fadvise64)

#ifdef TARGET_NR_fadvise64_64

    case TARGET_NR_fadvise64_64:

#endif

#ifdef TARGET_NR_fadvise64

    case TARGET_NR_fadvise64:

#endif

#ifdef TARGET_S390X

        switch (arg4) {

        case 4: arg4 = POSIX_FADV_NOREUSE + 1; break; 

        case 5: arg4 = POSIX_FADV_NOREUSE + 2; break; 

        case 6: arg4 = POSIX_FADV_DONTNEED; break;

        case 7: arg4 = POSIX_FADV_NOREUSE; break;

        default: break;

        }

#endif

        ret = -posix_fadvise(arg1, arg2, arg3, arg4);

	break;

#endif

#ifdef TARGET_NR_madvise

    case TARGET_NR_madvise:

        







        ret = get_errno(0);

        break;

#endif

#if TARGET_ABI_BITS == 32

    case TARGET_NR_fcntl64:

    {

	int cmd;

	struct flock64 fl;

	struct target_flock64 *target_fl;

#ifdef TARGET_ARM

	struct target_eabi_flock64 *target_efl;

#endif



	cmd = target_to_host_fcntl_cmd(arg2);

	if (cmd == -TARGET_EINVAL)

		return cmd;



        switch(arg2) {

        case TARGET_F_GETLK64:

#ifdef TARGET_ARM

            if (((CPUARMState *)cpu_env)->eabi) {

                if (!lock_user_struct(VERIFY_READ, target_efl, arg3, 1)) 

                    goto efault;

                fl.l_type = tswap16(target_efl->l_type);

                fl.l_whence = tswap16(target_efl->l_whence);

                fl.l_start = tswap64(target_efl->l_start);

                fl.l_len = tswap64(target_efl->l_len);

                fl.l_pid = tswap32(target_efl->l_pid);

                unlock_user_struct(target_efl, arg3, 0);

            } else

#endif

            {

                if (!lock_user_struct(VERIFY_READ, target_fl, arg3, 1)) 

                    goto efault;

                fl.l_type = tswap16(target_fl->l_type);

                fl.l_whence = tswap16(target_fl->l_whence);

                fl.l_start = tswap64(target_fl->l_start);

                fl.l_len = tswap64(target_fl->l_len);

                fl.l_pid = tswap32(target_fl->l_pid);

                unlock_user_struct(target_fl, arg3, 0);

            }

            ret = get_errno(fcntl(arg1, cmd, &fl));

	    if (ret == 0) {

#ifdef TARGET_ARM

                if (((CPUARMState *)cpu_env)->eabi) {

                    if (!lock_user_struct(VERIFY_WRITE, target_efl, arg3, 0)) 

                        goto efault;

                    target_efl->l_type = tswap16(fl.l_type);

                    target_efl->l_whence = tswap16(fl.l_whence);

                    target_efl->l_start = tswap64(fl.l_start);

                    target_efl->l_len = tswap64(fl.l_len);

                    target_efl->l_pid = tswap32(fl.l_pid);

                    unlock_user_struct(target_efl, arg3, 1);

                } else

#endif

                {

                    if (!lock_user_struct(VERIFY_WRITE, target_fl, arg3, 0)) 

                        goto efault;

                    target_fl->l_type = tswap16(fl.l_type);

                    target_fl->l_whence = tswap16(fl.l_whence);

                    target_fl->l_start = tswap64(fl.l_start);

                    target_fl->l_len = tswap64(fl.l_len);

                    target_fl->l_pid = tswap32(fl.l_pid);

                    unlock_user_struct(target_fl, arg3, 1);

                }

	    }

	    break;



        case TARGET_F_SETLK64:

        case TARGET_F_SETLKW64:

#ifdef TARGET_ARM

            if (((CPUARMState *)cpu_env)->eabi) {

                if (!lock_user_struct(VERIFY_READ, target_efl, arg3, 1)) 

                    goto efault;

                fl.l_type = tswap16(target_efl->l_type);

                fl.l_whence = tswap16(target_efl->l_whence);

                fl.l_start = tswap64(target_efl->l_start);

                fl.l_len = tswap64(target_efl->l_len);

                fl.l_pid = tswap32(target_efl->l_pid);

                unlock_user_struct(target_efl, arg3, 0);

            } else

#endif

            {

                if (!lock_user_struct(VERIFY_READ, target_fl, arg3, 1)) 

                    goto efault;

                fl.l_type = tswap16(target_fl->l_type);

                fl.l_whence = tswap16(target_fl->l_whence);

                fl.l_start = tswap64(target_fl->l_start);

                fl.l_len = tswap64(target_fl->l_len);

                fl.l_pid = tswap32(target_fl->l_pid);

                unlock_user_struct(target_fl, arg3, 0);

            }

            ret = get_errno(fcntl(arg1, cmd, &fl));

	    break;

        default:

            ret = do_fcntl(arg1, arg2, arg3);

            break;

        }

	break;

    }

#endif

#ifdef TARGET_NR_cacheflush

    case TARGET_NR_cacheflush:

        

        ret = 0;

        break;

#endif

#ifdef TARGET_NR_security

    case TARGET_NR_security:

        goto unimplemented;

#endif

#ifdef TARGET_NR_getpagesize

    case TARGET_NR_getpagesize:

        ret = TARGET_PAGE_SIZE;

        break;

#endif

    case TARGET_NR_gettid:

        ret = get_errno(gettid());

        break;

#ifdef TARGET_NR_readahead

    case TARGET_NR_readahead:

#if TARGET_ABI_BITS == 32

#ifdef TARGET_ARM

        if (((CPUARMState *)cpu_env)->eabi)

        {

            arg2 = arg3;

            arg3 = arg4;

            arg4 = arg5;

        }

#endif

        ret = get_errno(readahead(arg1, ((off64_t)arg3 << 32) | arg2, arg4));

#else

        ret = get_errno(readahead(arg1, arg2, arg3));

#endif

        break;

#endif

#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:

        ret = -TARGET_EOPNOTSUPP;

        break;

#endif

#ifdef TARGET_NR_set_thread_area

    case TARGET_NR_set_thread_area:

#if defined(TARGET_MIPS)

      ((CPUMIPSState *) cpu_env)->tls_value = arg1;

      ret = 0;

      break;

#elif defined(TARGET_CRIS)

      if (arg1 & 0xff)

          ret = -TARGET_EINVAL;

      else {

          ((CPUCRISState *) cpu_env)->pregs[PR_PID] = arg1;

          ret = 0;

      }

      break;

#elif defined(TARGET_I386) && defined(TARGET_ABI32)

      ret = do_set_thread_area(cpu_env, arg1);

      break;

#else

      goto unimplemented_nowarn;

#endif

#endif

#ifdef TARGET_NR_get_thread_area

    case TARGET_NR_get_thread_area:

#if defined(TARGET_I386) && defined(TARGET_ABI32)

        ret = do_get_thread_area(cpu_env, arg1);

#else

        goto unimplemented_nowarn;

#endif

#endif

#ifdef TARGET_NR_getdomainname

    case TARGET_NR_getdomainname:

        goto unimplemented_nowarn;

#endif



#ifdef TARGET_NR_clock_gettime

    case TARGET_NR_clock_gettime:

    {

        struct timespec VAR_42;

        ret = get_errno(clock_gettime(arg1, &VAR_42));

        if (!is_error(ret)) {

            host_to_target_timespec(arg2, &VAR_42);

        }

        break;

    }

#endif

#ifdef TARGET_NR_clock_getres

    case TARGET_NR_clock_getres:

    {

        struct timespec VAR_42;

        ret = get_errno(clock_getres(arg1, &VAR_42));

        if (!is_error(ret)) {

            host_to_target_timespec(arg2, &VAR_42);

        }

        break;

    }

#endif

#ifdef TARGET_NR_clock_nanosleep

    case TARGET_NR_clock_nanosleep:

    {

        struct timespec VAR_42;

        target_to_host_timespec(&VAR_42, arg3);

        ret = get_errno(clock_nanosleep(arg1, arg2, &VAR_42, arg4 ? &VAR_42 : NULL));

        if (arg4)

            host_to_target_timespec(arg4, &VAR_42);

        break;

    }

#endif



#if defined(TARGET_NR_set_tid_address) && defined(__NR_set_tid_address)

    case TARGET_NR_set_tid_address:

        ret = get_errno(set_tid_address((int *)g2h(arg1)));

        break;

#endif



#if defined(TARGET_NR_tkill) && defined(__NR_tkill)

    case TARGET_NR_tkill:

        ret = get_errno(sys_tkill((int)arg1, target_to_host_signal(arg2)));

        break;

#endif



#if defined(TARGET_NR_tgkill) && defined(__NR_tgkill)

    case TARGET_NR_tgkill:

	ret = get_errno(sys_tgkill((int)arg1, (int)arg2,

                        target_to_host_signal(arg3)));

	break;

#endif



#ifdef TARGET_NR_set_robust_list

    case TARGET_NR_set_robust_list:

	goto unimplemented_nowarn;

#endif



#if defined(TARGET_NR_utimensat) && defined(__NR_utimensat)

    case TARGET_NR_utimensat:

        {

            struct timespec *tsp, VAR_42[2];

            if (!arg3) {

                tsp = NULL;

            } else {

                target_to_host_timespec(VAR_42, arg3);

                target_to_host_timespec(VAR_42+1, arg3+sizeof(struct target_timespec));

                tsp = VAR_42;

            }

            if (!arg2)

                ret = get_errno(sys_utimensat(arg1, NULL, tsp, arg4));

            else {

                if (!(VAR_2 = lock_user_string(arg2))) {

                    ret = -TARGET_EFAULT;

                    goto fail;

                }

                ret = get_errno(sys_utimensat(arg1, path(VAR_2), tsp, arg4));

                unlock_user(VAR_2, arg2, 0);

            }

        }

	break;

#endif

#if defined(CONFIG_USE_NPTL)

    case TARGET_NR_futex:

        ret = do_futex(arg1, arg2, arg3, arg4, arg5, arg6);

        break;

#endif

#if defined(TARGET_NR_inotify_init) && defined(__NR_inotify_init)

    case TARGET_NR_inotify_init:

        ret = get_errno(sys_inotify_init());

        break;

#endif

#if defined(TARGET_NR_inotify_add_watch) && defined(__NR_inotify_add_watch)

    case TARGET_NR_inotify_add_watch:

        VAR_2 = lock_user_string(arg2);

        ret = get_errno(sys_inotify_add_watch(arg1, path(VAR_2), arg3));

        unlock_user(VAR_2, arg2, 0);

        break;

#endif

#if defined(TARGET_NR_inotify_rm_watch) && defined(__NR_inotify_rm_watch)

    case TARGET_NR_inotify_rm_watch:

        ret = get_errno(sys_inotify_rm_watch(arg1, arg2));

        break;

#endif



#if defined(TARGET_NR_mq_open) && defined(__NR_mq_open)

    case TARGET_NR_mq_open:

        {

            struct mq_attr posix_mq_attr;



            VAR_2 = lock_user_string(arg1 - 1);

            if (arg4 != 0)

                copy_from_user_mq_attr (&posix_mq_attr, arg4);

            ret = get_errno(mq_open(VAR_2, arg2, arg3, &posix_mq_attr));

            unlock_user (VAR_2, arg1, 0);

        }

        break;



    case TARGET_NR_mq_unlink:

        VAR_2 = lock_user_string(arg1 - 1);

        ret = get_errno(mq_unlink(VAR_2));

        unlock_user (VAR_2, arg1, 0);

        break;



    case TARGET_NR_mq_timedsend:

        {

            struct timespec VAR_42;



            VAR_2 = lock_user (VERIFY_READ, arg2, arg3, 1);

            if (arg5 != 0) {

                target_to_host_timespec(&VAR_42, arg5);

                ret = get_errno(mq_timedsend(arg1, VAR_2, arg3, arg4, &VAR_42));

                host_to_target_timespec(arg5, &VAR_42);

            }

            else

                ret = get_errno(mq_send(arg1, VAR_2, arg3, arg4));

            unlock_user (VAR_2, arg2, arg3);

        }

        break;



    case TARGET_NR_mq_timedreceive:

        {

            struct timespec VAR_42;

            unsigned int prio;



            VAR_2 = lock_user (VERIFY_READ, arg2, arg3, 1);

            if (arg5 != 0) {

                target_to_host_timespec(&VAR_42, arg5);

                ret = get_errno(mq_timedreceive(arg1, VAR_2, arg3, &prio, &VAR_42));

                host_to_target_timespec(arg5, &VAR_42);

            }

            else

                ret = get_errno(mq_receive(arg1, VAR_2, arg3, &prio));

            unlock_user (VAR_2, arg2, arg3);

            if (arg4 != 0)

                put_user_u32(prio, arg4);

        }

        break;



    







    case TARGET_NR_mq_getsetattr:

        {

            struct mq_attr posix_mq_attr_in, posix_mq_attr_out;

            ret = 0;

            if (arg3 != 0) {

                ret = mq_getattr(arg1, &posix_mq_attr_out);

                copy_to_user_mq_attr(arg3, &posix_mq_attr_out);

            }

            if (arg2 != 0) {

                copy_from_user_mq_attr(&posix_mq_attr_in, arg2);

                ret |= mq_setattr(arg1, &posix_mq_attr_in, &posix_mq_attr_out);

            }



        }

        break;

#endif



#ifdef CONFIG_SPLICE

#ifdef TARGET_NR_tee

    case TARGET_NR_tee:

        {

            ret = get_errno(tee(arg1,arg2,arg3,arg4));

        }

        break;

#endif

#ifdef TARGET_NR_splice

    case TARGET_NR_splice:

        {

            loff_t loff_in, loff_out;

            loff_t *ploff_in = NULL, *ploff_out = NULL;

            if(arg2) {

                get_user_u64(loff_in, arg2);

                ploff_in = &loff_in;

            }

            if(arg4) {

                get_user_u64(loff_out, arg2);

                ploff_out = &loff_out;

            }

            ret = get_errno(splice(arg1, ploff_in, arg3, ploff_out, arg5, arg6));

        }

        break;

#endif

#ifdef TARGET_NR_vmsplice

	case TARGET_NR_vmsplice:

        {

            int VAR_40 = arg3;

            struct iovec *VAR_40;



            VAR_40 = alloca(VAR_40 * sizeof(struct iovec));

            if (lock_iovec(VERIFY_READ, VAR_40, arg2, VAR_40, 1) < 0)

                goto efault;

            ret = get_errno(vmsplice(arg1, VAR_40, VAR_40, arg4));

            unlock_iovec(VAR_40, arg2, VAR_40, 0);

        }

        break;

#endif

#endif 

#ifdef CONFIG_EVENTFD

#if defined(TARGET_NR_eventfd)

    case TARGET_NR_eventfd:

        ret = get_errno(eventfd(arg1, 0));

        break;

#endif

#if defined(TARGET_NR_eventfd2)

    case TARGET_NR_eventfd2:

        ret = get_errno(eventfd(arg1, arg2));

        break;

#endif

#endif 

    default:

    unimplemented:

        gemu_log("qemu: Unsupported syscall: %d\n", num);

#if defined(TARGET_NR_setxattr) || defined(TARGET_NR_get_thread_area) || defined(TARGET_NR_getdomainname) || defined(TARGET_NR_set_robust_list)

    unimplemented_nowarn:

#endif

        ret = -TARGET_ENOSYS;

        break;

    }

fail:

#ifdef DEBUG

    gemu_log(" = " TARGET_ABI_FMT_ld "\n", ret);

#endif

    if(do_strace)

        print_syscall_ret(num, ret);

    return ret;

efault:

    ret = -TARGET_EFAULT;

    goto fail;

}
abi_long FUNC_0(void *cpu_env, int num, abi_long arg1,
abi_long arg2, abi_long arg3, abi_long arg4,
abi_long arg5, abi_long arg6)
{ abi_long ret; struct stat VAR_0; struct statfs VAR_1; void *VAR_2; #ifdef DEBUG
gemu_log("syscall %d", num); #endif
if(do_strace)
print_syscall(num, arg1, arg2, arg3, arg4, arg5, arg6); switch(num) { case TARGET_NR_exit:
#ifdef CONFIG_USE_NPTL
if (first_cpu->next_cpu) { TaskState *VAR_42; CPUState **lastp; CPUState *VAR_2; cpu_list_lock(); lastp = &first_cpu; VAR_2 = first_cpu; while (VAR_2 && VAR_2 != (CPUState *)cpu_env) { lastp = &VAR_2->next_cpu; VAR_2 = VAR_2->next_cpu; } if (!VAR_2)
abort(); *lastp = VAR_2->next_cpu; cpu_list_unlock(); VAR_42 = ((CPUState *)cpu_env)->opaque; if (VAR_42->child_tidptr) { put_user_u32(0, VAR_42->child_tidptr); sys_futex(g2h(VAR_42->child_tidptr), FUTEX_WAKE, INT_MAX,
NULL, NULL, 0); } pthread_exit(NULL); } #endif
#ifdef TARGET_GPROF
_mcleanup(); #endif
gdb_exit(cpu_env, arg1); _exit(arg1); ret = 0; break; case TARGET_NR_read:
if (arg3 == 0)
ret = 0; else { if (!(VAR_2 = lock_user(VERIFY_WRITE, arg2, arg3, 0)))
goto efault; ret = get_errno(read(arg1, VAR_2, arg3)); unlock_user(VAR_2, arg2, ret); } break; case TARGET_NR_write:
if (!(VAR_2 = lock_user(VERIFY_READ, arg2, arg3, 1)))
goto efault; ret = get_errno(write(arg1, VAR_2, arg3)); unlock_user(VAR_2, arg2, 0); break; case TARGET_NR_open:
if (!(VAR_2 = lock_user_string(arg1)))
goto efault; ret = get_errno(open(path(VAR_2),
target_to_host_bitmask(arg2, fcntl_flags_tbl),
arg3)); unlock_user(VAR_2, arg1, 0); break; #if defined(TARGET_NR_openat) && defined(__NR_openat)
case TARGET_NR_openat:
if (!(VAR_2 = lock_user_string(arg2)))
goto efault; ret = get_errno(sys_openat(arg1,
path(VAR_2),
target_to_host_bitmask(arg3, fcntl_flags_tbl),
arg4)); unlock_user(VAR_2, arg2, 0); break; #endif
case TARGET_NR_close:
ret = get_errno(close(arg1)); break; case TARGET_NR_brk:
ret = do_brk(arg1); break; case TARGET_NR_fork:
ret = get_errno(do_fork(cpu_env, SIGCHLD, 0, 0, 0, 0)); break; #ifdef TARGET_NR_waitpid
case TARGET_NR_waitpid:
{ int VAR_30; ret = get_errno(waitpid(arg1, &VAR_30, arg3)); if (!is_error(ret) && arg2
&& put_user_s32(host_to_target_waitstatus(VAR_30), arg2))
goto efault; } break; #endif
#ifdef TARGET_NR_waitid
case TARGET_NR_waitid:
{ siginfo_t info; info.si_pid = 0; ret = get_errno(waitid(arg1, arg2, &info, arg4)); if (!is_error(ret) && arg3 && info.si_pid != 0) { if (!(VAR_2 = lock_user(VERIFY_WRITE, arg3, sizeof(target_siginfo_t), 0)))
goto efault; host_to_target_siginfo(VAR_2, &info); unlock_user(VAR_2, arg3, sizeof(target_siginfo_t)); } } break; #endif
#ifdef TARGET_NR_creat
case TARGET_NR_creat:
if (!(VAR_2 = lock_user_string(arg1)))
goto efault; ret = get_errno(creat(VAR_2, arg2)); unlock_user(VAR_2, arg1, 0); break; #endif
case TARGET_NR_link:
{ void * VAR_23; VAR_2 = lock_user_string(arg1); VAR_23 = lock_user_string(arg2); if (!VAR_2 || !VAR_23)
ret = -TARGET_EFAULT; else
ret = get_errno(link(VAR_2, VAR_23)); unlock_user(VAR_23, arg2, 0); unlock_user(VAR_2, arg1, 0); } break; #if defined(TARGET_NR_linkat) && defined(__NR_linkat)
case TARGET_NR_linkat:
{ void * VAR_23 = NULL; if (!arg2 || !arg4)
goto efault; VAR_2  = lock_user_string(arg2); VAR_23 = lock_user_string(arg4); if (!VAR_2 || !VAR_23)
ret = -TARGET_EFAULT; else
ret = get_errno(sys_linkat(arg1, VAR_2, arg3, VAR_23, arg5)); unlock_user(VAR_2, arg2, 0); unlock_user(VAR_23, arg4, 0); } break; #endif
case TARGET_NR_unlink:
if (!(VAR_2 = lock_user_string(arg1)))
goto efault; ret = get_errno(unlink(VAR_2)); unlock_user(VAR_2, arg1, 0); break; #if defined(TARGET_NR_unlinkat) && defined(__NR_unlinkat)
case TARGET_NR_unlinkat:
if (!(VAR_2 = lock_user_string(arg2)))
goto efault; ret = get_errno(sys_unlinkat(arg1, VAR_2, arg3)); unlock_user(VAR_2, arg2, 0); break; #endif
case TARGET_NR_execve:
{ char **VAR_4, **VAR_5; int VAR_6, VAR_7; abi_ulong gp; abi_ulong guest_argp; abi_ulong guest_envp; abi_ulong addr; char **VAR_8; VAR_6 = 0; guest_argp = arg2; for (gp = guest_argp; gp; gp += sizeof(abi_ulong)) { if (get_user_ual(addr, gp))
goto efault; if (!addr)
break; VAR_6++; } VAR_7 = 0; guest_envp = arg3; for (gp = guest_envp; gp; gp += sizeof(abi_ulong)) { if (get_user_ual(addr, gp))
goto efault; if (!addr)
break; VAR_7++; } VAR_4 = alloca((VAR_6 + 1) * sizeof(void *)); VAR_5 = alloca((VAR_7 + 1) * sizeof(void *)); for (gp = guest_argp, VAR_8 = VAR_4; gp; gp += sizeof(abi_ulong), VAR_8++) { if (get_user_ual(addr, gp))
goto execve_efault; if (!addr)
break; if (!(*VAR_8 = lock_user_string(addr)))
goto execve_efault; } *VAR_8 = NULL; for (gp = guest_envp, VAR_8 = VAR_5; gp; gp += sizeof(abi_ulong), VAR_8++) { if (get_user_ual(addr, gp))
goto execve_efault; if (!addr)
break; if (!(*VAR_8 = lock_user_string(addr)))
goto execve_efault; } *VAR_8 = NULL; if (!(VAR_2 = lock_user_string(arg1)))
goto execve_efault; ret = get_errno(execve(VAR_2, VAR_4, VAR_5)); unlock_user(VAR_2, arg1, 0); goto execve_end; execve_efault:
ret = -TARGET_EFAULT; execve_end:
for (gp = guest_argp, VAR_8 = VAR_4; *VAR_8; gp += sizeof(abi_ulong), VAR_8++) { if (get_user_ual(addr, gp)
|| !addr)
break; unlock_user(*VAR_8, addr, 0); } for (gp = guest_envp, VAR_8 = VAR_5; *VAR_8; gp += sizeof(abi_ulong), VAR_8++) { if (get_user_ual(addr, gp)
|| !addr)
break; unlock_user(*VAR_8, addr, 0); } } break; case TARGET_NR_chdir:
if (!(VAR_2 = lock_user_string(arg1)))
goto efault; ret = get_errno(chdir(VAR_2)); unlock_user(VAR_2, arg1, 0); break; #ifdef TARGET_NR_time
case TARGET_NR_time:
{ time_t host_time; ret = get_errno(time(&host_time)); if (!is_error(ret)
&& arg1
&& put_user_sal(host_time, arg1))
goto efault; } break; #endif
case TARGET_NR_mknod:
if (!(VAR_2 = lock_user_string(arg1)))
goto efault; ret = get_errno(mknod(VAR_2, arg2, arg3)); unlock_user(VAR_2, arg1, 0); break; #if defined(TARGET_NR_mknodat) && defined(__NR_mknodat)
case TARGET_NR_mknodat:
if (!(VAR_2 = lock_user_string(arg2)))
goto efault; ret = get_errno(sys_mknodat(arg1, VAR_2, arg3, arg4)); unlock_user(VAR_2, arg2, 0); break; #endif
case TARGET_NR_chmod:
if (!(VAR_2 = lock_user_string(arg1)))
goto efault; ret = get_errno(chmod(VAR_2, arg2)); unlock_user(VAR_2, arg1, 0); break; #ifdef TARGET_NR_break
case TARGET_NR_break:
goto unimplemented; #endif
#ifdef TARGET_NR_oldstat
case TARGET_NR_oldstat:
goto unimplemented; #endif
case TARGET_NR_lseek:
ret = get_errno(lseek(arg1, arg2, arg3)); break; #ifdef TARGET_NR_getxpid
case TARGET_NR_getxpid:
#else
case TARGET_NR_getpid:
#endif
ret = get_errno(getpid()); break; case TARGET_NR_mount:
{ void *VAR_23, *VAR_9; VAR_2 = lock_user_string(arg1); VAR_23 = lock_user_string(arg2); VAR_9 = lock_user_string(arg3); if (!VAR_2 || !VAR_23 || !VAR_9)
ret = -TARGET_EFAULT; else
ret = get_errno(mount(VAR_2, VAR_23, VAR_9, (unsigned long)arg4, g2h(arg5))); unlock_user(VAR_2, arg1, 0); unlock_user(VAR_23, arg2, 0); unlock_user(VAR_9, arg3, 0); break; } #ifdef TARGET_NR_umount
case TARGET_NR_umount:
if (!(VAR_2 = lock_user_string(arg1)))
goto efault; ret = get_errno(umount(VAR_2)); unlock_user(VAR_2, arg1, 0); break; #endif
#ifdef TARGET_NR_stime
case TARGET_NR_stime:
{ time_t host_time; if (get_user_sal(host_time, arg1))
goto efault; ret = get_errno(stime(&host_time)); } break; #endif
case TARGET_NR_ptrace:
goto unimplemented; #ifdef TARGET_NR_alarm
case TARGET_NR_alarm:
ret = alarm(arg1); break; #endif
#ifdef TARGET_NR_oldfstat
case TARGET_NR_oldfstat:
goto unimplemented; #endif
#ifdef TARGET_NR_pause
case TARGET_NR_pause:
ret = get_errno(pause()); break; #endif
#ifdef TARGET_NR_utime
case TARGET_NR_utime:
{ struct utimbuf tbuf, *host_tbuf; struct target_utimbuf *target_tbuf; if (arg2) { if (!lock_user_struct(VERIFY_READ, target_tbuf, arg2, 1))
goto efault; tbuf.actime = tswapl(target_tbuf->actime); tbuf.modtime = tswapl(target_tbuf->modtime); unlock_user_struct(target_tbuf, arg2, 0); host_tbuf = &tbuf; } else { host_tbuf = NULL; } if (!(VAR_2 = lock_user_string(arg1)))
goto efault; ret = get_errno(utime(VAR_2, host_tbuf)); unlock_user(VAR_2, arg1, 0); } break; #endif
case TARGET_NR_utimes:
{ struct timeval *VAR_10, VAR_23[2]; if (arg2) { if (copy_from_user_timeval(&VAR_23[0], arg2)
|| copy_from_user_timeval(&VAR_23[1],
arg2 + sizeof(struct target_timeval)))
goto efault; VAR_10 = VAR_23; } else { VAR_10 = NULL; } if (!(VAR_2 = lock_user_string(arg1)))
goto efault; ret = get_errno(utimes(VAR_2, VAR_10)); unlock_user(VAR_2, arg1, 0); } break; #if defined(TARGET_NR_futimesat) && defined(__NR_futimesat)
case TARGET_NR_futimesat:
{ struct timeval *VAR_10, VAR_23[2]; if (arg3) { if (copy_from_user_timeval(&VAR_23[0], arg3)
|| copy_from_user_timeval(&VAR_23[1],
arg3 + sizeof(struct target_timeval)))
goto efault; VAR_10 = VAR_23; } else { VAR_10 = NULL; } if (!(VAR_2 = lock_user_string(arg2)))
goto efault; ret = get_errno(sys_futimesat(arg1, path(VAR_2), VAR_10)); unlock_user(VAR_2, arg2, 0); } break; #endif
#ifdef TARGET_NR_stty
case TARGET_NR_stty:
goto unimplemented; #endif
#ifdef TARGET_NR_gtty
case TARGET_NR_gtty:
goto unimplemented; #endif
case TARGET_NR_access:
if (!(VAR_2 = lock_user_string(arg1)))
goto efault; ret = get_errno(access(path(VAR_2), arg2)); unlock_user(VAR_2, arg1, 0); break; #if defined(TARGET_NR_faccessat) && defined(__NR_faccessat)
case TARGET_NR_faccessat:
if (!(VAR_2 = lock_user_string(arg2)))
goto efault; ret = get_errno(sys_faccessat(arg1, VAR_2, arg3)); unlock_user(VAR_2, arg2, 0); break; #endif
#ifdef TARGET_NR_nice
case TARGET_NR_nice:
ret = get_errno(nice(arg1)); break; #endif
#ifdef TARGET_NR_ftime
case TARGET_NR_ftime:
goto unimplemented; #endif
case TARGET_NR_sync:
sync(); ret = 0; break; case TARGET_NR_kill:
ret = get_errno(kill(arg1, target_to_host_signal(arg2))); break; case TARGET_NR_rename:
{ void *VAR_23; VAR_2 = lock_user_string(arg1); VAR_23 = lock_user_string(arg2); if (!VAR_2 || !VAR_23)
ret = -TARGET_EFAULT; else
ret = get_errno(rename(VAR_2, VAR_23)); unlock_user(VAR_23, arg2, 0); unlock_user(VAR_2, arg1, 0); } break; #if defined(TARGET_NR_renameat) && defined(__NR_renameat)
case TARGET_NR_renameat:
{ void *VAR_23; VAR_2  = lock_user_string(arg2); VAR_23 = lock_user_string(arg4); if (!VAR_2 || !VAR_23)
ret = -TARGET_EFAULT; else
ret = get_errno(sys_renameat(arg1, VAR_2, arg3, VAR_23)); unlock_user(VAR_23, arg4, 0); unlock_user(VAR_2, arg2, 0); } break; #endif
case TARGET_NR_mkdir:
if (!(VAR_2 = lock_user_string(arg1)))
goto efault; ret = get_errno(mkdir(VAR_2, arg2)); unlock_user(VAR_2, arg1, 0); break; #if defined(TARGET_NR_mkdirat) && defined(__NR_mkdirat)
case TARGET_NR_mkdirat:
if (!(VAR_2 = lock_user_string(arg2)))
goto efault; ret = get_errno(sys_mkdirat(arg1, VAR_2, arg3)); unlock_user(VAR_2, arg2, 0); break; #endif
case TARGET_NR_rmdir:
if (!(VAR_2 = lock_user_string(arg1)))
goto efault; ret = get_errno(rmdir(VAR_2)); unlock_user(VAR_2, arg1, 0); break; case TARGET_NR_dup:
ret = get_errno(dup(arg1)); break; case TARGET_NR_pipe:
ret = do_pipe(cpu_env, arg1, 0); break; #ifdef TARGET_NR_pipe2
case TARGET_NR_pipe2:
ret = do_pipe(cpu_env, arg1, arg2); break; #endif
case TARGET_NR_times:
{ struct target_tms *VAR_12; struct VAR_13 VAR_13; ret = get_errno(times(&VAR_13)); if (arg1) { VAR_12 = lock_user(VERIFY_WRITE, arg1, sizeof(struct target_tms), 0); if (!VAR_12)
goto efault; VAR_12->tms_utime = tswapl(host_to_target_clock_t(VAR_13.tms_utime)); VAR_12->tms_stime = tswapl(host_to_target_clock_t(VAR_13.tms_stime)); VAR_12->tms_cutime = tswapl(host_to_target_clock_t(VAR_13.tms_cutime)); VAR_12->tms_cstime = tswapl(host_to_target_clock_t(VAR_13.tms_cstime)); } if (!is_error(ret))
ret = host_to_target_clock_t(ret); } break; #ifdef TARGET_NR_prof
case TARGET_NR_prof:
goto unimplemented; #endif
#ifdef TARGET_NR_signal
case TARGET_NR_signal:
goto unimplemented; #endif
case TARGET_NR_acct:
if (arg1 == 0) { ret = get_errno(acct(NULL)); } else { if (!(VAR_2 = lock_user_string(arg1)))
goto efault; ret = get_errno(acct(path(VAR_2))); unlock_user(VAR_2, arg1, 0); } break; #ifdef TARGET_NR_umount2
case TARGET_NR_umount2:
if (!(VAR_2 = lock_user_string(arg1)))
goto efault; ret = get_errno(umount2(VAR_2, arg2)); unlock_user(VAR_2, arg1, 0); break; #endif
#ifdef TARGET_NR_lock
case TARGET_NR_lock:
goto unimplemented; #endif
case TARGET_NR_ioctl:
ret = do_ioctl(arg1, arg2, arg3); break; case TARGET_NR_fcntl:
ret = do_fcntl(arg1, arg2, arg3); break; #ifdef TARGET_NR_mpx
case TARGET_NR_mpx:
goto unimplemented; #endif
case TARGET_NR_setpgid:
ret = get_errno(setpgid(arg1, arg2)); break; #ifdef TARGET_NR_ulimit
case TARGET_NR_ulimit:
goto unimplemented; #endif
#ifdef TARGET_NR_oldolduname
case TARGET_NR_oldolduname:
goto unimplemented; #endif
case TARGET_NR_umask:
ret = get_errno(umask(arg1)); break; case TARGET_NR_chroot:
if (!(VAR_2 = lock_user_string(arg1)))
goto efault; ret = get_errno(chroot(VAR_2)); unlock_user(VAR_2, arg1, 0); break; case TARGET_NR_ustat:
goto unimplemented; case TARGET_NR_dup2:
ret = get_errno(dup2(arg1, arg2)); break; #ifdef TARGET_NR_getppid
case TARGET_NR_getppid:
ret = get_errno(getppid()); break; #endif
case TARGET_NR_getpgrp:
ret = get_errno(getpgrp()); break; case TARGET_NR_setsid:
ret = get_errno(setsid()); break; #ifdef TARGET_NR_sigaction
case TARGET_NR_sigaction:
{ #if !defined(TARGET_MIPS)
struct target_old_sigaction *old_act; struct target_sigaction VAR_14, VAR_15, *pact; if (arg2) { if (!lock_user_struct(VERIFY_READ, old_act, arg2, 1))
goto efault; VAR_14._sa_handler = old_act->_sa_handler; target_siginitset(&VAR_14.sa_mask, old_act->sa_mask); VAR_14.sa_flags = old_act->sa_flags; VAR_14.sa_restorer = old_act->sa_restorer; unlock_user_struct(old_act, arg2, 0); pact = &VAR_14; } else { pact = NULL; } ret = get_errno(do_sigaction(arg1, pact, &VAR_15)); if (!is_error(ret) && arg3) { if (!lock_user_struct(VERIFY_WRITE, old_act, arg3, 0))
goto efault; old_act->_sa_handler = VAR_15._sa_handler; old_act->sa_mask = VAR_15.sa_mask.sig[0]; old_act->sa_flags = VAR_15.sa_flags; old_act->sa_restorer = VAR_15.sa_restorer; unlock_user_struct(old_act, arg3, 1); } #else
struct target_sigaction VAR_14, VAR_15, *pact, *old_act; if (arg2) { if (!lock_user_struct(VERIFY_READ, old_act, arg2, 1))
goto efault; VAR_14._sa_handler = old_act->_sa_handler; target_siginitset(&VAR_14.sa_mask, old_act->sa_mask.sig[0]); VAR_14.sa_flags = old_act->sa_flags; unlock_user_struct(old_act, arg2, 0); pact = &VAR_14; } else { pact = NULL; } ret = get_errno(do_sigaction(arg1, pact, &VAR_15)); if (!is_error(ret) && arg3) { if (!lock_user_struct(VERIFY_WRITE, old_act, arg3, 0))
goto efault; old_act->_sa_handler = VAR_15._sa_handler; old_act->sa_flags = VAR_15.sa_flags; old_act->sa_mask.sig[0] = VAR_15.sa_mask.sig[0]; old_act->sa_mask.sig[1] = 0; old_act->sa_mask.sig[2] = 0; old_act->sa_mask.sig[3] = 0; unlock_user_struct(old_act, arg3, 1); } #endif
} break; #endif
case TARGET_NR_rt_sigaction:
{ struct target_sigaction *VAR_14; struct target_sigaction *VAR_15; if (arg2) { if (!lock_user_struct(VERIFY_READ, VAR_14, arg2, 1))
goto efault; } else VAR_14 = NULL; if (arg3) { if (!lock_user_struct(VERIFY_WRITE, VAR_15, arg3, 0)) { ret = -TARGET_EFAULT; goto rt_sigaction_fail; } } else VAR_15 = NULL; ret = get_errno(do_sigaction(arg1, VAR_14, VAR_15)); rt_sigaction_fail:
if (VAR_14)
unlock_user_struct(VAR_14, arg2, 0); if (VAR_15)
unlock_user_struct(VAR_15, arg3, 1); } break; #ifdef TARGET_NR_sgetmask
case TARGET_NR_sgetmask:
{ sigset_t cur_set; abi_ulong target_set; sigprocmask(0, NULL, &cur_set); host_to_target_old_sigset(&target_set, &cur_set); ret = target_set; } break; #endif
#ifdef TARGET_NR_ssetmask
case TARGET_NR_ssetmask:
{ sigset_t set, oset, cur_set; abi_ulong target_set = arg1; sigprocmask(0, NULL, &cur_set); target_to_host_old_sigset(&set, &target_set); sigorset(&set, &set, &cur_set); sigprocmask(SIG_SETMASK, &set, &oset); host_to_target_old_sigset(&target_set, &oset); ret = target_set; } break; #endif
#ifdef TARGET_NR_sigprocmask
case TARGET_NR_sigprocmask:
{ int VAR_16 = arg1; sigset_t set, oldset, *set_ptr; if (arg2) { switch(VAR_16) { case TARGET_SIG_BLOCK:
VAR_16 = SIG_BLOCK; break; case TARGET_SIG_UNBLOCK:
VAR_16 = SIG_UNBLOCK; break; case TARGET_SIG_SETMASK:
VAR_16 = SIG_SETMASK; break; default:
ret = -TARGET_EINVAL; goto fail; } if (!(VAR_2 = lock_user(VERIFY_READ, arg2, sizeof(target_sigset_t), 1)))
goto efault; target_to_host_old_sigset(&set, VAR_2); unlock_user(VAR_2, arg2, 0); set_ptr = &set; } else { VAR_16 = 0; set_ptr = NULL; } ret = get_errno(sigprocmask(arg1, set_ptr, &oldset)); if (!is_error(ret) && arg3) { if (!(VAR_2 = lock_user(VERIFY_WRITE, arg3, sizeof(target_sigset_t), 0)))
goto efault; host_to_target_old_sigset(VAR_2, &oldset); unlock_user(VAR_2, arg3, sizeof(target_sigset_t)); } } break; #endif
case TARGET_NR_rt_sigprocmask:
{ int VAR_16 = arg1; sigset_t set, oldset, *set_ptr; if (arg2) { switch(VAR_16) { case TARGET_SIG_BLOCK:
VAR_16 = SIG_BLOCK; break; case TARGET_SIG_UNBLOCK:
VAR_16 = SIG_UNBLOCK; break; case TARGET_SIG_SETMASK:
VAR_16 = SIG_SETMASK; break; default:
ret = -TARGET_EINVAL; goto fail; } if (!(VAR_2 = lock_user(VERIFY_READ, arg2, sizeof(target_sigset_t), 1)))
goto efault; target_to_host_sigset(&set, VAR_2); unlock_user(VAR_2, arg2, 0); set_ptr = &set; } else { VAR_16 = 0; set_ptr = NULL; } ret = get_errno(sigprocmask(VAR_16, set_ptr, &oldset)); if (!is_error(ret) && arg3) { if (!(VAR_2 = lock_user(VERIFY_WRITE, arg3, sizeof(target_sigset_t), 0)))
goto efault; host_to_target_sigset(VAR_2, &oldset); unlock_user(VAR_2, arg3, sizeof(target_sigset_t)); } } break; #ifdef TARGET_NR_sigpending
case TARGET_NR_sigpending:
{ sigset_t set; ret = get_errno(sigpending(&set)); if (!is_error(ret)) { if (!(VAR_2 = lock_user(VERIFY_WRITE, arg1, sizeof(target_sigset_t), 0)))
goto efault; host_to_target_old_sigset(VAR_2, &set); unlock_user(VAR_2, arg1, sizeof(target_sigset_t)); } } break; #endif
case TARGET_NR_rt_sigpending:
{ sigset_t set; ret = get_errno(sigpending(&set)); if (!is_error(ret)) { if (!(VAR_2 = lock_user(VERIFY_WRITE, arg1, sizeof(target_sigset_t), 0)))
goto efault; host_to_target_sigset(VAR_2, &set); unlock_user(VAR_2, arg1, sizeof(target_sigset_t)); } } break; #ifdef TARGET_NR_sigsuspend
case TARGET_NR_sigsuspend:
{ sigset_t set; if (!(VAR_2 = lock_user(VERIFY_READ, arg1, sizeof(target_sigset_t), 1)))
goto efault; target_to_host_old_sigset(&set, VAR_2); unlock_user(VAR_2, arg1, 0); ret = get_errno(sigsuspend(&set)); } break; #endif
case TARGET_NR_rt_sigsuspend:
{ sigset_t set; if (!(VAR_2 = lock_user(VERIFY_READ, arg1, sizeof(target_sigset_t), 1)))
goto efault; target_to_host_sigset(&set, VAR_2); unlock_user(VAR_2, arg1, 0); ret = get_errno(sigsuspend(&set)); } break; case TARGET_NR_rt_sigtimedwait:
{ sigset_t set; struct timespec VAR_17, *VAR_18; siginfo_t uinfo; if (!(VAR_2 = lock_user(VERIFY_READ, arg1, sizeof(target_sigset_t), 1)))
goto efault; target_to_host_sigset(&set, VAR_2); unlock_user(VAR_2, arg1, 0); if (arg3) { VAR_18 = &VAR_17; target_to_host_timespec(VAR_18, arg3); } else { VAR_18 = NULL; } ret = get_errno(sigtimedwait(&set, &uinfo, VAR_18)); if (!is_error(ret) && arg2) { if (!(VAR_2 = lock_user(VERIFY_WRITE, arg2, sizeof(target_siginfo_t), 0)))
goto efault; host_to_target_siginfo(VAR_2, &uinfo); unlock_user(VAR_2, arg2, sizeof(target_siginfo_t)); } } break; case TARGET_NR_rt_sigqueueinfo:
{ siginfo_t uinfo; if (!(VAR_2 = lock_user(VERIFY_READ, arg3, sizeof(target_sigset_t), 1)))
goto efault; target_to_host_siginfo(&uinfo, VAR_2); unlock_user(VAR_2, arg1, 0); ret = get_errno(sys_rt_sigqueueinfo(arg1, arg2, &uinfo)); } break; #ifdef TARGET_NR_sigreturn
case TARGET_NR_sigreturn:
ret = do_sigreturn(cpu_env); break; #endif
case TARGET_NR_rt_sigreturn:
ret = do_rt_sigreturn(cpu_env); break; case TARGET_NR_sethostname:
if (!(VAR_2 = lock_user_string(arg1)))
goto efault; ret = get_errno(sethostname(VAR_2, arg2)); unlock_user(VAR_2, arg1, 0); break; case TARGET_NR_setrlimit:
{ int VAR_22 = arg1; struct target_rlimit *VAR_22; struct rlimit VAR_22; if (!lock_user_struct(VERIFY_READ, VAR_22, arg2, 1))
goto efault; VAR_22.rlim_cur = tswapl(VAR_22->rlim_cur); VAR_22.rlim_max = tswapl(VAR_22->rlim_max); unlock_user_struct(VAR_22, arg2, 0); ret = get_errno(setrlimit(VAR_22, &VAR_22)); } break; case TARGET_NR_getrlimit:
{ int VAR_22 = arg1; struct target_rlimit *VAR_22; struct rlimit VAR_22; ret = get_errno(getrlimit(VAR_22, &VAR_22)); if (!is_error(ret)) { if (!lock_user_struct(VERIFY_WRITE, VAR_22, arg2, 0))
goto efault; VAR_22->rlim_cur = tswapl(VAR_22.rlim_cur); VAR_22->rlim_max = tswapl(VAR_22.rlim_max); unlock_user_struct(VAR_22, arg2, 1); } } break; case TARGET_NR_getrusage:
{ struct VAR_31 VAR_31; ret = get_errno(getrusage(arg1, &VAR_31)); if (!is_error(ret)) { host_to_target_rusage(arg2, &VAR_31); } } break; case TARGET_NR_gettimeofday:
{ struct timeval VAR_23; ret = get_errno(gettimeofday(&VAR_23, NULL)); if (!is_error(ret)) { if (copy_to_user_timeval(arg1, &VAR_23))
goto efault; } } break; case TARGET_NR_settimeofday:
{ struct timeval VAR_23; if (copy_from_user_timeval(&VAR_23, arg1))
goto efault; ret = get_errno(settimeofday(&VAR_23, NULL)); } break; #ifdef TARGET_NR_select
case TARGET_NR_select:
{ struct target_sel_arg_struct *sel; abi_ulong inp, outp, exp, VAR_10; long nsel; if (!lock_user_struct(VERIFY_READ, sel, arg1, 1))
goto efault; nsel = tswapl(sel->n); inp = tswapl(sel->inp); outp = tswapl(sel->outp); exp = tswapl(sel->exp); VAR_10 = tswapl(sel->VAR_10); unlock_user_struct(sel, arg1, 0); ret = do_select(nsel, inp, outp, exp, VAR_10); } break; #endif
case TARGET_NR_symlink:
{ void *VAR_23; VAR_2 = lock_user_string(arg1); VAR_23 = lock_user_string(arg2); if (!VAR_2 || !VAR_23)
ret = -TARGET_EFAULT; else
ret = get_errno(symlink(VAR_2, VAR_23)); unlock_user(VAR_23, arg2, 0); unlock_user(VAR_2, arg1, 0); } break; #if defined(TARGET_NR_symlinkat) && defined(__NR_symlinkat)
case TARGET_NR_symlinkat:
{ void *VAR_23; VAR_2  = lock_user_string(arg1); VAR_23 = lock_user_string(arg3); if (!VAR_2 || !VAR_23)
ret = -TARGET_EFAULT; else
ret = get_errno(sys_symlinkat(VAR_2, arg2, VAR_23)); unlock_user(VAR_23, arg3, 0); unlock_user(VAR_2, arg1, 0); } break; #endif
#ifdef TARGET_NR_oldlstat
case TARGET_NR_oldlstat:
goto unimplemented; #endif
case TARGET_NR_readlink:
{ void *VAR_23, *VAR_23; VAR_2 = lock_user_string(arg1); VAR_23 = lock_user(VERIFY_WRITE, arg2, arg3, 0); if (!VAR_2 || !VAR_23)
ret = -TARGET_EFAULT; else { if (strncmp((const char *)VAR_2, "/proc/self/exe", 14) == 0) { char VAR_24[PATH_MAX]; VAR_23 = realpath(exec_path,VAR_24); ret = (VAR_23==NULL) ? get_errno(-1) : strlen(VAR_24) ; snprintf((char *)VAR_23, arg3, "%s", VAR_24); } else
ret = get_errno(readlink(path(VAR_2), VAR_23, arg3)); } unlock_user(VAR_23, arg2, ret); unlock_user(VAR_2, arg1, 0); } break; #if defined(TARGET_NR_readlinkat) && defined(__NR_readlinkat)
case TARGET_NR_readlinkat:
{ void *VAR_23; VAR_2  = lock_user_string(arg2); VAR_23 = lock_user(VERIFY_WRITE, arg3, arg4, 0); if (!VAR_2 || !VAR_23)
ret = -TARGET_EFAULT; else
ret = get_errno(sys_readlinkat(arg1, path(VAR_2), VAR_23, arg4)); unlock_user(VAR_23, arg3, ret); unlock_user(VAR_2, arg2, 0); } break; #endif
#ifdef TARGET_NR_uselib
case TARGET_NR_uselib:
goto unimplemented; #endif
#ifdef TARGET_NR_swapon
case TARGET_NR_swapon:
if (!(VAR_2 = lock_user_string(arg1)))
goto efault; ret = get_errno(swapon(VAR_2, arg2)); unlock_user(VAR_2, arg1, 0); break; #endif
case TARGET_NR_reboot:
goto unimplemented; #ifdef TARGET_NR_readdir
case TARGET_NR_readdir:
goto unimplemented; #endif
#ifdef TARGET_NR_mmap
case TARGET_NR_mmap:
#if (defined(TARGET_I386) && defined(TARGET_ABI32)) || defined(TARGET_ARM) || defined(TARGET_M68K) || defined(TARGET_CRIS) || defined(TARGET_MICROBLAZE)
{ abi_ulong *v; abi_ulong v1, v2, v3, v4, v5, v6; if (!(v = lock_user(VERIFY_READ, arg1, 6 * sizeof(abi_ulong), 1)))
goto efault; v1 = tswapl(v[0]); v2 = tswapl(v[1]); v3 = tswapl(v[2]); v4 = tswapl(v[3]); v5 = tswapl(v[4]); v6 = tswapl(v[5]); unlock_user(v, arg1, 0); ret = get_errno(target_mmap(v1, v2, v3,
target_to_host_bitmask(v4, mmap_flags_tbl),
v5, v6)); } #else
ret = get_errno(target_mmap(arg1, arg2, arg3,
target_to_host_bitmask(arg4, mmap_flags_tbl),
arg5,
arg6)); #endif
break; #endif
#ifdef TARGET_NR_mmap2
case TARGET_NR_mmap2:
#ifndef MMAP_SHIFT
#define MMAP_SHIFT 12
#endif
ret = get_errno(target_mmap(arg1, arg2, arg3,
target_to_host_bitmask(arg4, mmap_flags_tbl),
arg5,
arg6 << MMAP_SHIFT)); break; #endif
case TARGET_NR_munmap:
ret = get_errno(target_munmap(arg1, arg2)); break; case TARGET_NR_mprotect:
ret = get_errno(target_mprotect(arg1, arg2, arg3)); break; #ifdef TARGET_NR_mremap
case TARGET_NR_mremap:
ret = get_errno(target_mremap(arg1, arg2, arg3, arg4, arg5)); break; #endif
#ifdef TARGET_NR_msync
case TARGET_NR_msync:
ret = get_errno(msync(g2h(arg1), arg2, arg3)); break; #endif
#ifdef TARGET_NR_mlock
case TARGET_NR_mlock:
ret = get_errno(mlock(g2h(arg1), arg2)); break; #endif
#ifdef TARGET_NR_munlock
case TARGET_NR_munlock:
ret = get_errno(munlock(g2h(arg1), arg2)); break; #endif
#ifdef TARGET_NR_mlockall
case TARGET_NR_mlockall:
ret = get_errno(mlockall(arg1)); break; #endif
#ifdef TARGET_NR_munlockall
case TARGET_NR_munlockall:
ret = get_errno(munlockall()); break; #endif
case TARGET_NR_truncate:
if (!(VAR_2 = lock_user_string(arg1)))
goto efault; ret = get_errno(truncate(VAR_2, arg2)); unlock_user(VAR_2, arg1, 0); break; case TARGET_NR_ftruncate:
ret = get_errno(ftruncate(arg1, arg2)); break; case TARGET_NR_fchmod:
ret = get_errno(fchmod(arg1, arg2)); break; #if defined(TARGET_NR_fchmodat) && defined(__NR_fchmodat)
case TARGET_NR_fchmodat:
if (!(VAR_2 = lock_user_string(arg2)))
goto efault; ret = get_errno(sys_fchmodat(arg1, VAR_2, arg3)); unlock_user(VAR_2, arg2, 0); break; #endif
case TARGET_NR_getpriority:
ret = sys_getpriority(arg1, arg2); break; case TARGET_NR_setpriority:
ret = get_errno(setpriority(arg1, arg2, arg3)); break; #ifdef TARGET_NR_profil
case TARGET_NR_profil:
goto unimplemented; #endif
case TARGET_NR_statfs:
if (!(VAR_2 = lock_user_string(arg1)))
goto efault; ret = get_errno(statfs(path(VAR_2), &VAR_1)); unlock_user(VAR_2, arg1, 0); convert_statfs:
if (!is_error(ret)) { struct target_statfs *VAR_25; if (!lock_user_struct(VERIFY_WRITE, VAR_25, arg2, 0))
goto efault; __put_user(VAR_1.f_type, &VAR_25->f_type); __put_user(VAR_1.f_bsize, &VAR_25->f_bsize); __put_user(VAR_1.f_blocks, &VAR_25->f_blocks); __put_user(VAR_1.f_bfree, &VAR_25->f_bfree); __put_user(VAR_1.f_bavail, &VAR_25->f_bavail); __put_user(VAR_1.f_files, &VAR_25->f_files); __put_user(VAR_1.f_ffree, &VAR_25->f_ffree); __put_user(VAR_1.f_fsid.__val[0], &VAR_25->f_fsid.val[0]); __put_user(VAR_1.f_fsid.__val[1], &VAR_25->f_fsid.val[1]); __put_user(VAR_1.f_namelen, &VAR_25->f_namelen); unlock_user_struct(VAR_25, arg2, 1); } break; case TARGET_NR_fstatfs:
ret = get_errno(fstatfs(arg1, &VAR_1)); goto convert_statfs; #ifdef TARGET_NR_statfs64
case TARGET_NR_statfs64:
if (!(VAR_2 = lock_user_string(arg1)))
goto efault; ret = get_errno(statfs(path(VAR_2), &VAR_1)); unlock_user(VAR_2, arg1, 0); convert_statfs64:
if (!is_error(ret)) { struct target_statfs64 *VAR_25; if (!lock_user_struct(VERIFY_WRITE, VAR_25, arg3, 0))
goto efault; __put_user(VAR_1.f_type, &VAR_25->f_type); __put_user(VAR_1.f_bsize, &VAR_25->f_bsize); __put_user(VAR_1.f_blocks, &VAR_25->f_blocks); __put_user(VAR_1.f_bfree, &VAR_25->f_bfree); __put_user(VAR_1.f_bavail, &VAR_25->f_bavail); __put_user(VAR_1.f_files, &VAR_25->f_files); __put_user(VAR_1.f_ffree, &VAR_25->f_ffree); __put_user(VAR_1.f_fsid.__val[0], &VAR_25->f_fsid.val[0]); __put_user(VAR_1.f_fsid.__val[1], &VAR_25->f_fsid.val[1]); __put_user(VAR_1.f_namelen, &VAR_25->f_namelen); unlock_user_struct(VAR_25, arg3, 1); } break; case TARGET_NR_fstatfs64:
ret = get_errno(fstatfs(arg1, &VAR_1)); goto convert_statfs64; #endif
#ifdef TARGET_NR_ioperm
case TARGET_NR_ioperm:
goto unimplemented; #endif
#ifdef TARGET_NR_socketcall
case TARGET_NR_socketcall:
ret = do_socketcall(arg1, arg2); break; #endif
#ifdef TARGET_NR_accept
case TARGET_NR_accept:
ret = do_accept(arg1, arg2, arg3); break; #endif
#ifdef TARGET_NR_bind
case TARGET_NR_bind:
ret = do_bind(arg1, arg2, arg3); break; #endif
#ifdef TARGET_NR_connect
case TARGET_NR_connect:
ret = do_connect(arg1, arg2, arg3); break; #endif
#ifdef TARGET_NR_getpeername
case TARGET_NR_getpeername:
ret = do_getpeername(arg1, arg2, arg3); break; #endif
#ifdef TARGET_NR_getsockname
case TARGET_NR_getsockname:
ret = do_getsockname(arg1, arg2, arg3); break; #endif
#ifdef TARGET_NR_getsockopt
case TARGET_NR_getsockopt:
ret = do_getsockopt(arg1, arg2, arg3, arg4, arg5); break; #endif
#ifdef TARGET_NR_listen
case TARGET_NR_listen:
ret = get_errno(listen(arg1, arg2)); break; #endif
#ifdef TARGET_NR_recv
case TARGET_NR_recv:
ret = do_recvfrom(arg1, arg2, arg3, arg4, 0, 0); break; #endif
#ifdef TARGET_NR_recvfrom
case TARGET_NR_recvfrom:
ret = do_recvfrom(arg1, arg2, arg3, arg4, arg5, arg6); break; #endif
#ifdef TARGET_NR_recvmsg
case TARGET_NR_recvmsg:
ret = do_sendrecvmsg(arg1, arg2, arg3, 0); break; #endif
#ifdef TARGET_NR_send
case TARGET_NR_send:
ret = do_sendto(arg1, arg2, arg3, arg4, 0, 0); break; #endif
#ifdef TARGET_NR_sendmsg
case TARGET_NR_sendmsg:
ret = do_sendrecvmsg(arg1, arg2, arg3, 1); break; #endif
#ifdef TARGET_NR_sendto
case TARGET_NR_sendto:
ret = do_sendto(arg1, arg2, arg3, arg4, arg5, arg6); break; #endif
#ifdef TARGET_NR_shutdown
case TARGET_NR_shutdown:
ret = get_errno(shutdown(arg1, arg2)); break; #endif
#ifdef TARGET_NR_socket
case TARGET_NR_socket:
ret = do_socket(arg1, arg2, arg3); break; #endif
#ifdef TARGET_NR_socketpair
case TARGET_NR_socketpair:
ret = do_socketpair(arg1, arg2, arg3, arg4); break; #endif
#ifdef TARGET_NR_setsockopt
case TARGET_NR_setsockopt:
ret = do_setsockopt(arg1, arg2, arg3, arg4, (socklen_t) arg5); break; #endif
case TARGET_NR_syslog:
if (!(VAR_2 = lock_user_string(arg2)))
goto efault; ret = get_errno(sys_syslog((int)arg1, VAR_2, (int)arg3)); unlock_user(VAR_2, arg2, 0); break; case TARGET_NR_setitimer:
{ struct itimerval VAR_33, VAR_27, *VAR_28; if (arg2) { VAR_28 = &VAR_33; if (copy_from_user_timeval(&VAR_28->it_interval, arg2)
|| copy_from_user_timeval(&VAR_28->it_value,
arg2 + sizeof(struct target_timeval)))
goto efault; } else { VAR_28 = NULL; } ret = get_errno(setitimer(arg1, VAR_28, &VAR_27)); if (!is_error(ret) && arg3) { if (copy_to_user_timeval(arg3,
&VAR_27.it_interval)
|| copy_to_user_timeval(arg3 + sizeof(struct target_timeval),
&VAR_27.it_value))
goto efault; } } break; case TARGET_NR_getitimer:
{ struct itimerval VAR_33; ret = get_errno(getitimer(arg1, &VAR_33)); if (!is_error(ret) && arg2) { if (copy_to_user_timeval(arg2,
&VAR_33.it_interval)
|| copy_to_user_timeval(arg2 + sizeof(struct target_timeval),
&VAR_33.it_value))
goto efault; } } break; case TARGET_NR_stat:
if (!(VAR_2 = lock_user_string(arg1)))
goto efault; ret = get_errno(stat(path(VAR_2), &VAR_0)); unlock_user(VAR_2, arg1, 0); goto do_stat; case TARGET_NR_lstat:
if (!(VAR_2 = lock_user_string(arg1)))
goto efault; ret = get_errno(lstat(path(VAR_2), &VAR_0)); unlock_user(VAR_2, arg1, 0); goto do_stat; case TARGET_NR_fstat:
{ ret = get_errno(fstat(arg1, &VAR_0)); do_stat:
if (!is_error(ret)) { struct target_stat *VAR_29; if (!lock_user_struct(VERIFY_WRITE, VAR_29, arg2, 0))
goto efault; __put_user(VAR_0.st_dev, &VAR_29->st_dev); __put_user(VAR_0.st_ino, &VAR_29->st_ino); __put_user(VAR_0.st_mode, &VAR_29->st_mode); __put_user(VAR_0.st_uid, &VAR_29->st_uid); __put_user(VAR_0.st_gid, &VAR_29->st_gid); __put_user(VAR_0.st_nlink, &VAR_29->st_nlink); __put_user(VAR_0.st_rdev, &VAR_29->st_rdev); __put_user(VAR_0.st_size, &VAR_29->st_size); __put_user(VAR_0.st_blksize, &VAR_29->st_blksize); __put_user(VAR_0.st_blocks, &VAR_29->st_blocks); __put_user(VAR_0.st_atime, &VAR_29->target_st_atime); __put_user(VAR_0.st_mtime, &VAR_29->target_st_mtime); __put_user(VAR_0.st_ctime, &VAR_29->target_st_ctime); unlock_user_struct(VAR_29, arg2, 1); } } break; #ifdef TARGET_NR_olduname
case TARGET_NR_olduname:
goto unimplemented; #endif
#ifdef TARGET_NR_iopl
case TARGET_NR_iopl:
goto unimplemented; #endif
case TARGET_NR_vhangup:
ret = get_errno(vhangup()); break; #ifdef TARGET_NR_idle
case TARGET_NR_idle:
goto unimplemented; #endif
#ifdef TARGET_NR_syscall
case TARGET_NR_syscall:
ret = FUNC_0(cpu_env,arg1 & 0xffff,arg2,arg3,arg4,arg5,arg6,0); break; #endif
case TARGET_NR_wait4:
{ int VAR_30; abi_long status_ptr = arg2; struct VAR_31 VAR_31, *VAR_31; abi_ulong target_rusage = arg4; if (target_rusage)
VAR_31 = &VAR_31; else
VAR_31 = NULL; ret = get_errno(wait4(arg1, &VAR_30, arg3, VAR_31)); if (!is_error(ret)) { if (status_ptr) { VAR_30 = host_to_target_waitstatus(VAR_30); if (put_user_s32(VAR_30, status_ptr))
goto efault; } if (target_rusage)
host_to_target_rusage(target_rusage, &VAR_31); } } break; #ifdef TARGET_NR_swapoff
case TARGET_NR_swapoff:
if (!(VAR_2 = lock_user_string(arg1)))
goto efault; ret = get_errno(swapoff(VAR_2)); unlock_user(VAR_2, arg1, 0); break; #endif
case TARGET_NR_sysinfo:
{ struct target_sysinfo *VAR_32; struct sysinfo VAR_33; ret = get_errno(sysinfo(&VAR_33)); if (!is_error(ret) && arg1)
{ if (!lock_user_struct(VERIFY_WRITE, VAR_32, arg1, 0))
goto efault; __put_user(VAR_33.uptime, &VAR_32->uptime); __put_user(VAR_33.loads[0], &VAR_32->loads[0]); __put_user(VAR_33.loads[1], &VAR_32->loads[1]); __put_user(VAR_33.loads[2], &VAR_32->loads[2]); __put_user(VAR_33.totalram, &VAR_32->totalram); __put_user(VAR_33.freeram, &VAR_32->freeram); __put_user(VAR_33.sharedram, &VAR_32->sharedram); __put_user(VAR_33.bufferram, &VAR_32->bufferram); __put_user(VAR_33.totalswap, &VAR_32->totalswap); __put_user(VAR_33.freeswap, &VAR_32->freeswap); __put_user(VAR_33.procs, &VAR_32->procs); __put_user(VAR_33.totalhigh, &VAR_32->totalhigh); __put_user(VAR_33.freehigh, &VAR_32->freehigh); __put_user(VAR_33.mem_unit, &VAR_32->mem_unit); unlock_user_struct(VAR_32, arg1, 1); } } break; #ifdef TARGET_NR_ipc
case TARGET_NR_ipc:
ret = do_ipc(arg1, arg2, arg3, arg4, arg5, arg6); break; #endif
#ifdef TARGET_NR_semget
case TARGET_NR_semget:
ret = get_errno(semget(arg1, arg2, arg3)); break; #endif
#ifdef TARGET_NR_semop
case TARGET_NR_semop:
ret = get_errno(do_semop(arg1, arg2, arg3)); break; #endif
#ifdef TARGET_NR_semctl
case TARGET_NR_semctl:
ret = do_semctl(arg1, arg2, arg3, (union target_semun)(abi_ulong)arg4); break; #endif
#ifdef TARGET_NR_msgctl
case TARGET_NR_msgctl:
ret = do_msgctl(arg1, arg2, arg3); break; #endif
#ifdef TARGET_NR_msgget
case TARGET_NR_msgget:
ret = get_errno(msgget(arg1, arg2)); break; #endif
#ifdef TARGET_NR_msgrcv
case TARGET_NR_msgrcv:
ret = do_msgrcv(arg1, arg2, arg3, arg4, arg5); break; #endif
#ifdef TARGET_NR_msgsnd
case TARGET_NR_msgsnd:
ret = do_msgsnd(arg1, arg2, arg3, arg4); break; #endif
#ifdef TARGET_NR_shmget
case TARGET_NR_shmget:
ret = get_errno(shmget(arg1, arg2, arg3)); break; #endif
#ifdef TARGET_NR_shmctl
case TARGET_NR_shmctl:
ret = do_shmctl(arg1, arg2, arg3); break; #endif
#ifdef TARGET_NR_shmat
case TARGET_NR_shmat:
ret = do_shmat(arg1, arg2, arg3); break; #endif
#ifdef TARGET_NR_shmdt
case TARGET_NR_shmdt:
ret = do_shmdt(arg1); break; #endif
case TARGET_NR_fsync:
ret = get_errno(fsync(arg1)); break; case TARGET_NR_clone:
#if defined(TARGET_SH4)
ret = get_errno(do_fork(cpu_env, arg1, arg2, arg3, arg5, arg4)); #elif defined(TARGET_CRIS)
ret = get_errno(do_fork(cpu_env, arg2, arg1, arg3, arg4, arg5)); #else
ret = get_errno(do_fork(cpu_env, arg1, arg2, arg3, arg4, arg5)); #endif
break; #ifdef __NR_exit_group
case TARGET_NR_exit_group:
#ifdef TARGET_GPROF
_mcleanup(); #endif
gdb_exit(cpu_env, arg1); ret = get_errno(exit_group(arg1)); break; #endif
case TARGET_NR_setdomainname:
if (!(VAR_2 = lock_user_string(arg1)))
goto efault; ret = get_errno(setdomainname(VAR_2, arg2)); unlock_user(VAR_2, arg1, 0); break; case TARGET_NR_uname:
{ struct new_utsname * VAR_33; if (!lock_user_struct(VERIFY_WRITE, VAR_33, arg1, 0))
goto efault; ret = get_errno(sys_uname(VAR_33)); if (!is_error(ret)) { strcpy (VAR_33->machine, UNAME_MACHINE); if (qemu_uname_release && *qemu_uname_release)
strcpy (VAR_33->release, qemu_uname_release); } unlock_user_struct(VAR_33, arg1, 1); } break; #ifdef TARGET_I386
case TARGET_NR_modify_ldt:
ret = do_modify_ldt(cpu_env, arg1, arg2, arg3); break; #if !defined(TARGET_X86_64)
case TARGET_NR_vm86old:
goto unimplemented; case TARGET_NR_vm86:
ret = do_vm86(cpu_env, arg1, arg2); break; #endif
#endif
case TARGET_NR_adjtimex:
goto unimplemented; #ifdef TARGET_NR_create_module
case TARGET_NR_create_module:
#endif
case TARGET_NR_init_module:
case TARGET_NR_delete_module:
#ifdef TARGET_NR_get_kernel_syms
case TARGET_NR_get_kernel_syms:
#endif
goto unimplemented; case TARGET_NR_quotactl:
goto unimplemented; case TARGET_NR_getpgid:
ret = get_errno(getpgid(arg1)); break; case TARGET_NR_fchdir:
ret = get_errno(fchdir(arg1)); break; #ifdef TARGET_NR_bdflush
case TARGET_NR_bdflush:
goto unimplemented; #endif
#ifdef TARGET_NR_sysfs
case TARGET_NR_sysfs:
goto unimplemented; #endif
case TARGET_NR_personality:
ret = get_errno(personality(arg1)); break; #ifdef TARGET_NR_afs_syscall
case TARGET_NR_afs_syscall:
goto unimplemented; #endif
#ifdef TARGET_NR__llseek
case TARGET_NR__llseek:
{ #if defined (__x86_64__)
ret = get_errno(lseek(arg1, ((uint64_t )arg2 << 32) | arg3, arg5)); if (put_user_s64(ret, arg4))
goto efault; #else
int64_t res; ret = get_errno(_llseek(arg1, arg2, arg3, &res, arg5)); if (put_user_s64(res, arg4))
goto efault; #endif
} break; #endif
case TARGET_NR_getdents:
#if TARGET_ABI_BITS == 32 && HOST_LONG_BITS == 64
{ struct target_dirent *target_dirp; struct linux_dirent *VAR_34; abi_long VAR_40 = arg3; VAR_34 = malloc(VAR_40); if (!VAR_34) { ret = -TARGET_ENOMEM; goto fail; } ret = get_errno(sys_getdents(arg1, VAR_34, VAR_40)); if (!is_error(ret)) { struct linux_dirent *VAR_35; struct target_dirent *tde; int VAR_36 = ret; int VAR_37, treclen; int count1, tnamelen; count1 = 0; VAR_35 = VAR_34; if (!(target_dirp = lock_user(VERIFY_WRITE, arg2, VAR_40, 0)))
goto efault; tde = target_dirp; while (VAR_36 > 0) { VAR_37 = VAR_35->d_reclen; treclen = VAR_37 - (2 * (sizeof(long) - sizeof(abi_long))); tde->d_reclen = tswap16(treclen); tde->d_ino = tswapl(VAR_35->d_ino); tde->d_off = tswapl(VAR_35->d_off); tnamelen = treclen - (2 * sizeof(abi_long) + 2); if (tnamelen > 256)
tnamelen = 256; pstrcpy(tde->d_name, tnamelen, VAR_35->d_name); VAR_35 = (struct linux_dirent *)((char *)VAR_35 + VAR_37); VAR_36 -= VAR_37; tde = (struct target_dirent *)((char *)tde + treclen); count1 += treclen; } ret = count1; unlock_user(target_dirp, arg2, ret); } free(VAR_34); } #else
{ struct linux_dirent *VAR_34; abi_long VAR_40 = arg3; if (!(VAR_34 = lock_user(VERIFY_WRITE, arg2, VAR_40, 0)))
goto efault; ret = get_errno(sys_getdents(arg1, VAR_34, VAR_40)); if (!is_error(ret)) { struct linux_dirent *VAR_35; int VAR_36 = ret; int VAR_37; VAR_35 = VAR_34; while (VAR_36 > 0) { VAR_37 = VAR_35->d_reclen; if (VAR_37 > VAR_36)
break; VAR_35->d_reclen = tswap16(VAR_37); tswapls(&VAR_35->d_ino); tswapls(&VAR_35->d_off); VAR_35 = (struct linux_dirent *)((char *)VAR_35 + VAR_37); VAR_36 -= VAR_37; } } unlock_user(VAR_34, arg2, ret); } #endif
break; #if defined(TARGET_NR_getdents64) && defined(__NR_getdents64)
case TARGET_NR_getdents64:
{ struct linux_dirent64 *VAR_34; abi_long VAR_40 = arg3; if (!(VAR_34 = lock_user(VERIFY_WRITE, arg2, VAR_40, 0)))
goto efault; ret = get_errno(sys_getdents64(arg1, VAR_34, VAR_40)); if (!is_error(ret)) { struct linux_dirent64 *VAR_35; int VAR_36 = ret; int VAR_37; VAR_35 = VAR_34; while (VAR_36 > 0) { VAR_37 = VAR_35->d_reclen; if (VAR_37 > VAR_36)
break; VAR_35->d_reclen = tswap16(VAR_37); tswap64s((uint64_t *)&VAR_35->d_ino); tswap64s((uint64_t *)&VAR_35->d_off); VAR_35 = (struct linux_dirent64 *)((char *)VAR_35 + VAR_37); VAR_36 -= VAR_37; } } unlock_user(VAR_34, arg2, ret); } break; #endif
#ifdef TARGET_NR__newselect
case TARGET_NR__newselect:
ret = do_select(arg1, arg2, arg3, arg4, arg5); break; #endif
#ifdef TARGET_NR_poll
case TARGET_NR_poll:
{ struct target_pollfd *target_pfd; unsigned int nfds = arg2; int timeout = arg3; struct pollfd *pfd; unsigned int i; target_pfd = lock_user(VERIFY_WRITE, arg1, sizeof(struct target_pollfd) * nfds, 1); if (!target_pfd)
goto efault; pfd = alloca(sizeof(struct pollfd) * nfds); for(i = 0; i < nfds; i++) { pfd[i].fd = tswap32(target_pfd[i].fd); pfd[i].events = tswap16(target_pfd[i].events); } ret = get_errno(poll(pfd, nfds, timeout)); if (!is_error(ret)) { for(i = 0; i < nfds; i++) { target_pfd[i].revents = tswap16(pfd[i].revents); } ret += nfds * (sizeof(struct target_pollfd)
- sizeof(struct pollfd)); } unlock_user(target_pfd, arg1, ret); } break; #endif
case TARGET_NR_flock:
ret = get_errno(flock(arg1, arg2)); break; case TARGET_NR_readv:
{ int VAR_40 = arg3; struct iovec *VAR_40; VAR_40 = alloca(VAR_40 * sizeof(struct iovec)); if (lock_iovec(VERIFY_WRITE, VAR_40, arg2, VAR_40, 0) < 0)
goto efault; ret = get_errno(readv(arg1, VAR_40, VAR_40)); unlock_iovec(VAR_40, arg2, VAR_40, 1); } break; case TARGET_NR_writev:
{ int VAR_40 = arg3; struct iovec *VAR_40; VAR_40 = alloca(VAR_40 * sizeof(struct iovec)); if (lock_iovec(VERIFY_READ, VAR_40, arg2, VAR_40, 1) < 0)
goto efault; ret = get_errno(writev(arg1, VAR_40, VAR_40)); unlock_iovec(VAR_40, arg2, VAR_40, 0); } break; case TARGET_NR_getsid:
ret = get_errno(getsid(arg1)); break; #if defined(TARGET_NR_fdatasync)
case TARGET_NR_fdatasync:
ret = get_errno(fdatasync(arg1)); break; #endif
case TARGET_NR__sysctl:
ret = -TARGET_ENOTDIR; break; case TARGET_NR_sched_setparam:
{ struct sched_param *VAR_42; struct sched_param VAR_42; if (!lock_user_struct(VERIFY_READ, VAR_42, arg2, 1))
goto efault; VAR_42.sched_priority = tswap32(VAR_42->sched_priority); unlock_user_struct(VAR_42, arg2, 0); ret = get_errno(sched_setparam(arg1, &VAR_42)); } break; case TARGET_NR_sched_getparam:
{ struct sched_param *VAR_42; struct sched_param VAR_42; ret = get_errno(sched_getparam(arg1, &VAR_42)); if (!is_error(ret)) { if (!lock_user_struct(VERIFY_WRITE, VAR_42, arg2, 0))
goto efault; VAR_42->sched_priority = tswap32(VAR_42.sched_priority); unlock_user_struct(VAR_42, arg2, 1); } } break; case TARGET_NR_sched_setscheduler:
{ struct sched_param *VAR_42; struct sched_param VAR_42; if (!lock_user_struct(VERIFY_READ, VAR_42, arg3, 1))
goto efault; VAR_42.sched_priority = tswap32(VAR_42->sched_priority); unlock_user_struct(VAR_42, arg3, 0); ret = get_errno(sched_setscheduler(arg1, arg2, &VAR_42)); } break; case TARGET_NR_sched_getscheduler:
ret = get_errno(sched_getscheduler(arg1)); break; case TARGET_NR_sched_yield:
ret = get_errno(sched_yield()); break; case TARGET_NR_sched_get_priority_max:
ret = get_errno(sched_get_priority_max(arg1)); break; case TARGET_NR_sched_get_priority_min:
ret = get_errno(sched_get_priority_min(arg1)); break; case TARGET_NR_sched_rr_get_interval:
{ struct timespec VAR_42; ret = get_errno(sched_rr_get_interval(arg1, &VAR_42)); if (!is_error(ret)) { host_to_target_timespec(arg2, &VAR_42); } } break; case TARGET_NR_nanosleep:
{ struct timespec VAR_43, VAR_44; target_to_host_timespec(&VAR_43, arg1); ret = get_errno(nanosleep(&VAR_43, &VAR_44)); if (is_error(ret) && arg2) { host_to_target_timespec(arg2, &VAR_44); } } break; #ifdef TARGET_NR_query_module
case TARGET_NR_query_module:
goto unimplemented; #endif
#ifdef TARGET_NR_nfsservctl
case TARGET_NR_nfsservctl:
goto unimplemented; #endif
case TARGET_NR_prctl:
switch (arg1)
{ case PR_GET_PDEATHSIG:
{ int VAR_45; ret = get_errno(prctl(arg1, &VAR_45, arg3, arg4, arg5)); if (!is_error(ret) && arg2
&& put_user_ual(VAR_45, arg2))
goto efault; } break; default:
ret = get_errno(prctl(arg1, arg2, arg3, arg4, arg5)); break; } break; #ifdef TARGET_NR_arch_prctl
case TARGET_NR_arch_prctl:
#if defined(TARGET_I386) && !defined(TARGET_ABI32)
ret = do_arch_prctl(cpu_env, arg1, arg2); break; #else
goto unimplemented; #endif
#endif
#ifdef TARGET_NR_pread
case TARGET_NR_pread:
#ifdef TARGET_ARM
if (((CPUARMState *)cpu_env)->eabi)
arg4 = arg5; #endif
if (!(VAR_2 = lock_user(VERIFY_WRITE, arg2, arg3, 0)))
goto efault; ret = get_errno(pread(arg1, VAR_2, arg3, arg4)); unlock_user(VAR_2, arg2, ret); break; case TARGET_NR_pwrite:
#ifdef TARGET_ARM
if (((CPUARMState *)cpu_env)->eabi)
arg4 = arg5; #endif
if (!(VAR_2 = lock_user(VERIFY_READ, arg2, arg3, 1)))
goto efault; ret = get_errno(pwrite(arg1, VAR_2, arg3, arg4)); unlock_user(VAR_2, arg2, 0); break; #endif
#ifdef TARGET_NR_pread64
case TARGET_NR_pread64:
if (!(VAR_2 = lock_user(VERIFY_WRITE, arg2, arg3, 0)))
goto efault; ret = get_errno(pread64(arg1, VAR_2, arg3, target_offset64(arg4, arg5))); unlock_user(VAR_2, arg2, ret); break; case TARGET_NR_pwrite64:
if (!(VAR_2 = lock_user(VERIFY_READ, arg2, arg3, 1)))
goto efault; ret = get_errno(pwrite64(arg1, VAR_2, arg3, target_offset64(arg4, arg5))); unlock_user(VAR_2, arg2, 0); break; #endif
case TARGET_NR_getcwd:
if (!(VAR_2 = lock_user(VERIFY_WRITE, arg1, arg2, 0)))
goto efault; ret = get_errno(sys_getcwd1(VAR_2, arg2)); unlock_user(VAR_2, arg1, ret); break; case TARGET_NR_capget:
goto unimplemented; case TARGET_NR_capset:
goto unimplemented; case TARGET_NR_sigaltstack:
#if defined(TARGET_I386) || defined(TARGET_ARM) || defined(TARGET_MIPS) || \
defined(TARGET_SPARC) || defined(TARGET_PPC) || defined(TARGET_ALPHA) || \
defined(TARGET_M68K)
ret = do_sigaltstack(arg1, arg2, get_sp_from_cpustate((CPUState *)cpu_env)); break; #else
goto unimplemented; #endif
case TARGET_NR_sendfile:
goto unimplemented; #ifdef TARGET_NR_getpmsg
case TARGET_NR_getpmsg:
goto unimplemented; #endif
#ifdef TARGET_NR_putpmsg
case TARGET_NR_putpmsg:
goto unimplemented; #endif
#ifdef TARGET_NR_vfork
case TARGET_NR_vfork:
ret = get_errno(do_fork(cpu_env, CLONE_VFORK | CLONE_VM | SIGCHLD,
0, 0, 0, 0)); break; #endif
#ifdef TARGET_NR_ugetrlimit
case TARGET_NR_ugetrlimit:
{ struct rlimit VAR_22; ret = get_errno(getrlimit(arg1, &VAR_22)); if (!is_error(ret)) { struct target_rlimit *VAR_22; if (!lock_user_struct(VERIFY_WRITE, VAR_22, arg2, 0))
goto efault; VAR_22->rlim_cur = tswapl(VAR_22.rlim_cur); VAR_22->rlim_max = tswapl(VAR_22.rlim_max); unlock_user_struct(VAR_22, arg2, 1); } break; } #endif
#ifdef TARGET_NR_truncate64
case TARGET_NR_truncate64:
if (!(VAR_2 = lock_user_string(arg1)))
goto efault; ret = target_truncate64(cpu_env, VAR_2, arg2, arg3, arg4); unlock_user(VAR_2, arg1, 0); break; #endif
#ifdef TARGET_NR_ftruncate64
case TARGET_NR_ftruncate64:
ret = target_ftruncate64(cpu_env, arg1, arg2, arg3, arg4); break; #endif
#ifdef TARGET_NR_stat64
case TARGET_NR_stat64:
if (!(VAR_2 = lock_user_string(arg1)))
goto efault; ret = get_errno(stat(path(VAR_2), &VAR_0)); unlock_user(VAR_2, arg1, 0); if (!is_error(ret))
ret = host_to_target_stat64(cpu_env, arg2, &VAR_0); break; #endif
#ifdef TARGET_NR_lstat64
case TARGET_NR_lstat64:
if (!(VAR_2 = lock_user_string(arg1)))
goto efault; ret = get_errno(lstat(path(VAR_2), &VAR_0)); unlock_user(VAR_2, arg1, 0); if (!is_error(ret))
ret = host_to_target_stat64(cpu_env, arg2, &VAR_0); break; #endif
#ifdef TARGET_NR_fstat64
case TARGET_NR_fstat64:
ret = get_errno(fstat(arg1, &VAR_0)); if (!is_error(ret))
ret = host_to_target_stat64(cpu_env, arg2, &VAR_0); break; #endif
#if (defined(TARGET_NR_fstatat64) || defined(TARGET_NR_newfstatat)) && \
(defined(__NR_fstatat64) || defined(__NR_newfstatat))
#ifdef TARGET_NR_fstatat64
case TARGET_NR_fstatat64:
#endif
#ifdef TARGET_NR_newfstatat
case TARGET_NR_newfstatat:
#endif
if (!(VAR_2 = lock_user_string(arg2)))
goto efault; #ifdef __NR_fstatat64
ret = get_errno(sys_fstatat64(arg1, path(VAR_2), &VAR_0, arg4)); #else
ret = get_errno(sys_newfstatat(arg1, path(VAR_2), &VAR_0, arg4)); #endif
if (!is_error(ret))
ret = host_to_target_stat64(cpu_env, arg3, &VAR_0); break; #endif
#ifdef USE_UID16
case TARGET_NR_lchown:
if (!(VAR_2 = lock_user_string(arg1)))
goto efault; ret = get_errno(lchown(VAR_2, low2highuid(arg2), low2highgid(arg3))); unlock_user(VAR_2, arg1, 0); break; case TARGET_NR_getuid:
ret = get_errno(high2lowuid(getuid())); break; case TARGET_NR_getgid:
ret = get_errno(high2lowgid(getgid())); break; case TARGET_NR_geteuid:
ret = get_errno(high2lowuid(geteuid())); break; case TARGET_NR_getegid:
ret = get_errno(high2lowgid(getegid())); break; case TARGET_NR_setreuid:
ret = get_errno(setreuid(low2highuid(arg1), low2highuid(arg2))); break; case TARGET_NR_setregid:
ret = get_errno(setregid(low2highgid(arg1), low2highgid(arg2))); break; case TARGET_NR_getgroups:
{ int gidsetsize = arg1; uint16_t *target_grouplist; gid_t *grouplist; int i; grouplist = alloca(gidsetsize * sizeof(gid_t)); ret = get_errno(getgroups(gidsetsize, grouplist)); if (gidsetsize == 0)
break; if (!is_error(ret)) { target_grouplist = lock_user(VERIFY_WRITE, arg2, gidsetsize * 2, 0); if (!target_grouplist)
goto efault; for(i = 0;i < ret; i++) target_grouplist[i] = tswap16(grouplist[i]); unlock_user(target_grouplist, arg2, gidsetsize * 2); } } break; case TARGET_NR_setgroups:
{ int gidsetsize = arg1; uint16_t *target_grouplist; gid_t *grouplist; int i; grouplist = alloca(gidsetsize * sizeof(gid_t)); target_grouplist = lock_user(VERIFY_READ, arg2, gidsetsize * 2, 1); if (!target_grouplist) { ret = -TARGET_EFAULT; goto fail; } for(i = 0;i < gidsetsize; i++) grouplist[i] = tswap16(target_grouplist[i]); unlock_user(target_grouplist, arg2, 0); ret = get_errno(setgroups(gidsetsize, grouplist)); } break; case TARGET_NR_fchown:
ret = get_errno(fchown(arg1, low2highuid(arg2), low2highgid(arg3))); break; #if defined(TARGET_NR_fchownat) && defined(__NR_fchownat)
case TARGET_NR_fchownat:
if (!(VAR_2 = lock_user_string(arg2)))
goto efault; ret = get_errno(sys_fchownat(arg1, VAR_2, low2highuid(arg3), low2highgid(arg4), arg5)); unlock_user(VAR_2, arg2, 0); break; #endif
#ifdef TARGET_NR_setresuid
case TARGET_NR_setresuid:
ret = get_errno(setresuid(low2highuid(arg1),
low2highuid(arg2),
low2highuid(arg3))); break; #endif
#ifdef TARGET_NR_getresuid
case TARGET_NR_getresuid:
{ uid_t ruid, euid, suid; ret = get_errno(getresuid(&ruid, &euid, &suid)); if (!is_error(ret)) { if (put_user_u16(high2lowuid(ruid), arg1)
|| put_user_u16(high2lowuid(euid), arg2)
|| put_user_u16(high2lowuid(suid), arg3))
goto efault; } } break; #endif
#ifdef TARGET_NR_getresgid
case TARGET_NR_setresgid:
ret = get_errno(setresgid(low2highgid(arg1),
low2highgid(arg2),
low2highgid(arg3))); break; #endif
#ifdef TARGET_NR_getresgid
case TARGET_NR_getresgid:
{ gid_t rgid, egid, sgid; ret = get_errno(getresgid(&rgid, &egid, &sgid)); if (!is_error(ret)) { if (put_user_u16(high2lowgid(rgid), arg1)
|| put_user_u16(high2lowgid(egid), arg2)
|| put_user_u16(high2lowgid(sgid), arg3))
goto efault; } } break; #endif
case TARGET_NR_chown:
if (!(VAR_2 = lock_user_string(arg1)))
goto efault; ret = get_errno(chown(VAR_2, low2highuid(arg2), low2highgid(arg3))); unlock_user(VAR_2, arg1, 0); break; case TARGET_NR_setuid:
ret = get_errno(setuid(low2highuid(arg1))); break; case TARGET_NR_setgid:
ret = get_errno(setgid(low2highgid(arg1))); break; case TARGET_NR_setfsuid:
ret = get_errno(setfsuid(arg1)); break; case TARGET_NR_setfsgid:
ret = get_errno(setfsgid(arg1)); break; #endif
#ifdef TARGET_NR_lchown32
case TARGET_NR_lchown32:
if (!(VAR_2 = lock_user_string(arg1)))
goto efault; ret = get_errno(lchown(VAR_2, arg2, arg3)); unlock_user(VAR_2, arg1, 0); break; #endif
#ifdef TARGET_NR_getuid32
case TARGET_NR_getuid32:
ret = get_errno(getuid()); break; #endif
#if defined(TARGET_NR_getxuid) && defined(TARGET_ALPHA)
case TARGET_NR_getxuid:
{ uid_t euid; euid=geteuid(); ((CPUAlphaState *)cpu_env)->ir[IR_A4]=euid; } ret = get_errno(getuid()); break; #endif
#if defined(TARGET_NR_getxgid) && defined(TARGET_ALPHA)
case TARGET_NR_getxgid:
{ uid_t egid; egid=getegid(); ((CPUAlphaState *)cpu_env)->ir[IR_A4]=egid; } ret = get_errno(getgid()); break; #endif
#ifdef TARGET_NR_getgid32
case TARGET_NR_getgid32:
ret = get_errno(getgid()); break; #endif
#ifdef TARGET_NR_geteuid32
case TARGET_NR_geteuid32:
ret = get_errno(geteuid()); break; #endif
#ifdef TARGET_NR_getegid32
case TARGET_NR_getegid32:
ret = get_errno(getegid()); break; #endif
#ifdef TARGET_NR_setreuid32
case TARGET_NR_setreuid32:
ret = get_errno(setreuid(arg1, arg2)); break; #endif
#ifdef TARGET_NR_setregid32
case TARGET_NR_setregid32:
ret = get_errno(setregid(arg1, arg2)); break; #endif
#ifdef TARGET_NR_getgroups32
case TARGET_NR_getgroups32:
{ int gidsetsize = arg1; uint32_t *target_grouplist; gid_t *grouplist; int i; grouplist = alloca(gidsetsize * sizeof(gid_t)); ret = get_errno(getgroups(gidsetsize, grouplist)); if (gidsetsize == 0)
break; if (!is_error(ret)) { target_grouplist = lock_user(VERIFY_WRITE, arg2, gidsetsize * 4, 0); if (!target_grouplist) { ret = -TARGET_EFAULT; goto fail; } for(i = 0;i < ret; i++) target_grouplist[i] = tswap32(grouplist[i]); unlock_user(target_grouplist, arg2, gidsetsize * 4); } } break; #endif
#ifdef TARGET_NR_setgroups32
case TARGET_NR_setgroups32:
{ int gidsetsize = arg1; uint32_t *target_grouplist; gid_t *grouplist; int i; grouplist = alloca(gidsetsize * sizeof(gid_t)); target_grouplist = lock_user(VERIFY_READ, arg2, gidsetsize * 4, 1); if (!target_grouplist) { ret = -TARGET_EFAULT; goto fail; } for(i = 0;i < gidsetsize; i++) grouplist[i] = tswap32(target_grouplist[i]); unlock_user(target_grouplist, arg2, 0); ret = get_errno(setgroups(gidsetsize, grouplist)); } break; #endif
#ifdef TARGET_NR_fchown32
case TARGET_NR_fchown32:
ret = get_errno(fchown(arg1, arg2, arg3)); break; #endif
#ifdef TARGET_NR_setresuid32
case TARGET_NR_setresuid32:
ret = get_errno(setresuid(arg1, arg2, arg3)); break; #endif
#ifdef TARGET_NR_getresuid32
case TARGET_NR_getresuid32:
{ uid_t ruid, euid, suid; ret = get_errno(getresuid(&ruid, &euid, &suid)); if (!is_error(ret)) { if (put_user_u32(ruid, arg1)
|| put_user_u32(euid, arg2)
|| put_user_u32(suid, arg3))
goto efault; } } break; #endif
#ifdef TARGET_NR_setresgid32
case TARGET_NR_setresgid32:
ret = get_errno(setresgid(arg1, arg2, arg3)); break; #endif
#ifdef TARGET_NR_getresgid32
case TARGET_NR_getresgid32:
{ gid_t rgid, egid, sgid; ret = get_errno(getresgid(&rgid, &egid, &sgid)); if (!is_error(ret)) { if (put_user_u32(rgid, arg1)
|| put_user_u32(egid, arg2)
|| put_user_u32(sgid, arg3))
goto efault; } } break; #endif
#ifdef TARGET_NR_chown32
case TARGET_NR_chown32:
if (!(VAR_2 = lock_user_string(arg1)))
goto efault; ret = get_errno(chown(VAR_2, arg2, arg3)); unlock_user(VAR_2, arg1, 0); break; #endif
#ifdef TARGET_NR_setuid32
case TARGET_NR_setuid32:
ret = get_errno(setuid(arg1)); break; #endif
#ifdef TARGET_NR_setgid32
case TARGET_NR_setgid32:
ret = get_errno(setgid(arg1)); break; #endif
#ifdef TARGET_NR_setfsuid32
case TARGET_NR_setfsuid32:
ret = get_errno(setfsuid(arg1)); break; #endif
#ifdef TARGET_NR_setfsgid32
case TARGET_NR_setfsgid32:
ret = get_errno(setfsgid(arg1)); break; #endif
case TARGET_NR_pivot_root:
goto unimplemented; #ifdef TARGET_NR_mincore
case TARGET_NR_mincore:
{ void *a; ret = -TARGET_EFAULT; if (!(a = lock_user(VERIFY_READ, arg1,arg2, 0)))
goto efault; if (!(VAR_2 = lock_user_string(arg3)))
goto mincore_fail; ret = get_errno(mincore(a, arg2, VAR_2)); unlock_user(VAR_2, arg3, ret); mincore_fail:
unlock_user(a, arg1, 0); } break; #endif
#ifdef TARGET_NR_arm_fadvise64_64
case TARGET_NR_arm_fadvise64_64:
{ abi_long VAR_23; VAR_23 = arg3; arg3 = arg4; arg4 = VAR_23; } #endif
#if defined(TARGET_NR_fadvise64_64) || defined(TARGET_NR_arm_fadvise64_64) || defined(TARGET_NR_fadvise64)
#ifdef TARGET_NR_fadvise64_64
case TARGET_NR_fadvise64_64:
#endif
#ifdef TARGET_NR_fadvise64
case TARGET_NR_fadvise64:
#endif
#ifdef TARGET_S390X
switch (arg4) { case 4: arg4 = POSIX_FADV_NOREUSE + 1; break; case 5: arg4 = POSIX_FADV_NOREUSE + 2; break; case 6: arg4 = POSIX_FADV_DONTNEED; break; case 7: arg4 = POSIX_FADV_NOREUSE; break; default: break; } #endif
ret = -posix_fadvise(arg1, arg2, arg3, arg4); break; #endif
#ifdef TARGET_NR_madvise
case TARGET_NR_madvise:
ret = get_errno(0); break; #endif
#if TARGET_ABI_BITS == 32
case TARGET_NR_fcntl64:
{ int cmd; struct flock64 fl; struct target_flock64 *target_fl; #ifdef TARGET_ARM
struct target_eabi_flock64 *target_efl; #endif
cmd = target_to_host_fcntl_cmd(arg2); if (cmd == -TARGET_EINVAL)
return cmd; switch(arg2) { case TARGET_F_GETLK64:
#ifdef TARGET_ARM
if (((CPUARMState *)cpu_env)->eabi) { if (!lock_user_struct(VERIFY_READ, target_efl, arg3, 1))
goto efault; fl.l_type = tswap16(target_efl->l_type); fl.l_whence = tswap16(target_efl->l_whence); fl.l_start = tswap64(target_efl->l_start); fl.l_len = tswap64(target_efl->l_len); fl.l_pid = tswap32(target_efl->l_pid); unlock_user_struct(target_efl, arg3, 0); } else #endif
{ if (!lock_user_struct(VERIFY_READ, target_fl, arg3, 1))
goto efault; fl.l_type = tswap16(target_fl->l_type); fl.l_whence = tswap16(target_fl->l_whence); fl.l_start = tswap64(target_fl->l_start); fl.l_len = tswap64(target_fl->l_len); fl.l_pid = tswap32(target_fl->l_pid); unlock_user_struct(target_fl, arg3, 0); } ret = get_errno(fcntl(arg1, cmd, &fl)); if (ret == 0) { #ifdef TARGET_ARM
if (((CPUARMState *)cpu_env)->eabi) { if (!lock_user_struct(VERIFY_WRITE, target_efl, arg3, 0))
goto efault; target_efl->l_type = tswap16(fl.l_type); target_efl->l_whence = tswap16(fl.l_whence); target_efl->l_start = tswap64(fl.l_start); target_efl->l_len = tswap64(fl.l_len); target_efl->l_pid = tswap32(fl.l_pid); unlock_user_struct(target_efl, arg3, 1); } else #endif
{ if (!lock_user_struct(VERIFY_WRITE, target_fl, arg3, 0))
goto efault; target_fl->l_type = tswap16(fl.l_type); target_fl->l_whence = tswap16(fl.l_whence); target_fl->l_start = tswap64(fl.l_start); target_fl->l_len = tswap64(fl.l_len); target_fl->l_pid = tswap32(fl.l_pid); unlock_user_struct(target_fl, arg3, 1); } } break; case TARGET_F_SETLK64:
case TARGET_F_SETLKW64:
#ifdef TARGET_ARM
if (((CPUARMState *)cpu_env)->eabi) { if (!lock_user_struct(VERIFY_READ, target_efl, arg3, 1))
goto efault; fl.l_type = tswap16(target_efl->l_type); fl.l_whence = tswap16(target_efl->l_whence); fl.l_start = tswap64(target_efl->l_start); fl.l_len = tswap64(target_efl->l_len); fl.l_pid = tswap32(target_efl->l_pid); unlock_user_struct(target_efl, arg3, 0); } else #endif
{ if (!lock_user_struct(VERIFY_READ, target_fl, arg3, 1))
goto efault; fl.l_type = tswap16(target_fl->l_type); fl.l_whence = tswap16(target_fl->l_whence); fl.l_start = tswap64(target_fl->l_start); fl.l_len = tswap64(target_fl->l_len); fl.l_pid = tswap32(target_fl->l_pid); unlock_user_struct(target_fl, arg3, 0); } ret = get_errno(fcntl(arg1, cmd, &fl)); break; default:
ret = do_fcntl(arg1, arg2, arg3); break; } break; } #endif
#ifdef TARGET_NR_cacheflush
case TARGET_NR_cacheflush:
ret = 0; break; #endif
#ifdef TARGET_NR_security
case TARGET_NR_security:
goto unimplemented; #endif
#ifdef TARGET_NR_getpagesize
case TARGET_NR_getpagesize:
ret = TARGET_PAGE_SIZE; break; #endif
case TARGET_NR_gettid:
ret = get_errno(gettid()); break; #ifdef TARGET_NR_readahead
case TARGET_NR_readahead:
#if TARGET_ABI_BITS == 32
#ifdef TARGET_ARM
if (((CPUARMState *)cpu_env)->eabi)
{ arg2 = arg3; arg3 = arg4; arg4 = arg5; } #endif
ret = get_errno(readahead(arg1, ((off64_t)arg3 << 32) | arg2, arg4)); #else
ret = get_errno(readahead(arg1, arg2, arg3)); #endif
break; #endif
#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:
ret = -TARGET_EOPNOTSUPP; break; #endif
#ifdef TARGET_NR_set_thread_area
case TARGET_NR_set_thread_area:
#if defined(TARGET_MIPS)
((CPUMIPSState *) cpu_env)->tls_value = arg1; ret = 0; break; #elif defined(TARGET_CRIS)
if (arg1 & 0xff)
ret = -TARGET_EINVAL; else { ((CPUCRISState *) cpu_env)->pregs[PR_PID] = arg1; ret = 0; } break; #elif defined(TARGET_I386) && defined(TARGET_ABI32)
ret = do_set_thread_area(cpu_env, arg1); break; #else
goto unimplemented_nowarn; #endif
#endif
#ifdef TARGET_NR_get_thread_area
case TARGET_NR_get_thread_area:
#if defined(TARGET_I386) && defined(TARGET_ABI32)
ret = do_get_thread_area(cpu_env, arg1); #else
goto unimplemented_nowarn; #endif
#endif
#ifdef TARGET_NR_getdomainname
case TARGET_NR_getdomainname:
goto unimplemented_nowarn; #endif
#ifdef TARGET_NR_clock_gettime
case TARGET_NR_clock_gettime:
{ struct timespec VAR_42; ret = get_errno(clock_gettime(arg1, &VAR_42)); if (!is_error(ret)) { host_to_target_timespec(arg2, &VAR_42); } break; } #endif
#ifdef TARGET_NR_clock_getres
case TARGET_NR_clock_getres:
{ struct timespec VAR_42; ret = get_errno(clock_getres(arg1, &VAR_42)); if (!is_error(ret)) { host_to_target_timespec(arg2, &VAR_42); } break; } #endif
#ifdef TARGET_NR_clock_nanosleep
case TARGET_NR_clock_nanosleep:
{ struct timespec VAR_42; target_to_host_timespec(&VAR_42, arg3); ret = get_errno(clock_nanosleep(arg1, arg2, &VAR_42, arg4 ? &VAR_42 : NULL)); if (arg4)
host_to_target_timespec(arg4, &VAR_42); break; } #endif
#if defined(TARGET_NR_set_tid_address) && defined(__NR_set_tid_address)
case TARGET_NR_set_tid_address:
ret = get_errno(set_tid_address((int *)g2h(arg1))); break; #endif
#if defined(TARGET_NR_tkill) && defined(__NR_tkill)
case TARGET_NR_tkill:
ret = get_errno(sys_tkill((int)arg1, target_to_host_signal(arg2))); break; #endif
#if defined(TARGET_NR_tgkill) && defined(__NR_tgkill)
case TARGET_NR_tgkill:
ret = get_errno(sys_tgkill((int)arg1, (int)arg2,
target_to_host_signal(arg3))); break; #endif
#ifdef TARGET_NR_set_robust_list
case TARGET_NR_set_robust_list:
goto unimplemented_nowarn; #endif
#if defined(TARGET_NR_utimensat) && defined(__NR_utimensat)
case TARGET_NR_utimensat:
{ struct timespec *tsp, VAR_42[2]; if (!arg3) { tsp = NULL; } else { target_to_host_timespec(VAR_42, arg3); target_to_host_timespec(VAR_42+1, arg3+sizeof(struct target_timespec)); tsp = VAR_42; } if (!arg2)
ret = get_errno(sys_utimensat(arg1, NULL, tsp, arg4)); else { if (!(VAR_2 = lock_user_string(arg2))) { ret = -TARGET_EFAULT; goto fail; } ret = get_errno(sys_utimensat(arg1, path(VAR_2), tsp, arg4)); unlock_user(VAR_2, arg2, 0); } } break; #endif
#if defined(CONFIG_USE_NPTL)
case TARGET_NR_futex:
ret = do_futex(arg1, arg2, arg3, arg4, arg5, arg6); break; #endif
#if defined(TARGET_NR_inotify_init) && defined(__NR_inotify_init)
case TARGET_NR_inotify_init:
ret = get_errno(sys_inotify_init()); break; #endif
#if defined(TARGET_NR_inotify_add_watch) && defined(__NR_inotify_add_watch)
case TARGET_NR_inotify_add_watch:
VAR_2 = lock_user_string(arg2); ret = get_errno(sys_inotify_add_watch(arg1, path(VAR_2), arg3)); unlock_user(VAR_2, arg2, 0); break; #endif
#if defined(TARGET_NR_inotify_rm_watch) && defined(__NR_inotify_rm_watch)
case TARGET_NR_inotify_rm_watch:
ret = get_errno(sys_inotify_rm_watch(arg1, arg2)); break; #endif
#if defined(TARGET_NR_mq_open) && defined(__NR_mq_open)
case TARGET_NR_mq_open:
{ struct mq_attr posix_mq_attr; VAR_2 = lock_user_string(arg1 - 1); if (arg4 != 0)
copy_from_user_mq_attr (&posix_mq_attr, arg4); ret = get_errno(mq_open(VAR_2, arg2, arg3, &posix_mq_attr)); unlock_user (VAR_2, arg1, 0); } break; case TARGET_NR_mq_unlink:
VAR_2 = lock_user_string(arg1 - 1); ret = get_errno(mq_unlink(VAR_2)); unlock_user (VAR_2, arg1, 0); break; case TARGET_NR_mq_timedsend:
{ struct timespec VAR_42; VAR_2 = lock_user (VERIFY_READ, arg2, arg3, 1); if (arg5 != 0) { target_to_host_timespec(&VAR_42, arg5); ret = get_errno(mq_timedsend(arg1, VAR_2, arg3, arg4, &VAR_42)); host_to_target_timespec(arg5, &VAR_42); } else
ret = get_errno(mq_send(arg1, VAR_2, arg3, arg4)); unlock_user (VAR_2, arg2, arg3); } break; case TARGET_NR_mq_timedreceive:
{ struct timespec VAR_42; unsigned int prio; VAR_2 = lock_user (VERIFY_READ, arg2, arg3, 1); if (arg5 != 0) { target_to_host_timespec(&VAR_42, arg5); ret = get_errno(mq_timedreceive(arg1, VAR_2, arg3, &prio, &VAR_42)); host_to_target_timespec(arg5, &VAR_42); } else
ret = get_errno(mq_receive(arg1, VAR_2, arg3, &prio)); unlock_user (VAR_2, arg2, arg3); if (arg4 != 0)
put_user_u32(prio, arg4); } break; case TARGET_NR_mq_getsetattr:
{ struct mq_attr posix_mq_attr_in, posix_mq_attr_out; ret = 0; if (arg3 != 0) { ret = mq_getattr(arg1, &posix_mq_attr_out); copy_to_user_mq_attr(arg3, &posix_mq_attr_out); } if (arg2 != 0) { copy_from_user_mq_attr(&posix_mq_attr_in, arg2); ret |= mq_setattr(arg1, &posix_mq_attr_in, &posix_mq_attr_out); } } break; #endif
#ifdef CONFIG_SPLICE
#ifdef TARGET_NR_tee
case TARGET_NR_tee:
{ ret = get_errno(tee(arg1,arg2,arg3,arg4)); } break; #endif
#ifdef TARGET_NR_splice
case TARGET_NR_splice:
{ loff_t loff_in, loff_out; loff_t *ploff_in = NULL, *ploff_out = NULL; if(arg2) { get_user_u64(loff_in, arg2); ploff_in = &loff_in; } if(arg4) { get_user_u64(loff_out, arg2); ploff_out = &loff_out; } ret = get_errno(splice(arg1, ploff_in, arg3, ploff_out, arg5, arg6)); } break; #endif
#ifdef TARGET_NR_vmsplice
case TARGET_NR_vmsplice:
{ int VAR_40 = arg3; struct iovec *VAR_40; VAR_40 = alloca(VAR_40 * sizeof(struct iovec)); if (lock_iovec(VERIFY_READ, VAR_40, arg2, VAR_40, 1) < 0)
goto efault; ret = get_errno(vmsplice(arg1, VAR_40, VAR_40, arg4)); unlock_iovec(VAR_40, arg2, VAR_40, 0); } break; #endif
#endif
#ifdef CONFIG_EVENTFD
#if defined(TARGET_NR_eventfd)
case TARGET_NR_eventfd:
ret = get_errno(eventfd(arg1, 0)); break; #endif
#if defined(TARGET_NR_eventfd2)
case TARGET_NR_eventfd2:
ret = get_errno(eventfd(arg1, arg2)); break; #endif
#endif
default:
unimplemented:
gemu_log("qemu: Unsupported syscall: %d\n", num); #if defined(TARGET_NR_setxattr) || defined(TARGET_NR_get_thread_area) || defined(TARGET_NR_getdomainname) || defined(TARGET_NR_set_robust_list)
unimplemented_nowarn:
#endif
ret = -TARGET_ENOSYS; break; } fail:
#ifdef DEBUG
gemu_log(" = " TARGET_ABI_FMT_ld "\n", ret); #endif
if(do_strace)
print_syscall_ret(num, ret); return ret; efault:
ret = -TARGET_EFAULT; goto fail; }