| Message ID | 20230917213803.20683-22-kariem.taha2.7@gmail.com |
|---|---|
| State | New |
| Headers | show |
| Series | bsd-user: Implement freebsd process related system calls. | expand |
On Sun, Sep 17, 2023 at 10:39 PM Karim Taha <kariem.taha2.7@gmail.com> wrote: > From: Stacey Son <sson@FreeBSD.org> > > Implement t2h_procctl_cmd, h2t_reaper_status, h2t_reaper_pidinfo and > h2t/t2h reaper_kill conversion functions. > > Signed-off-by: Stacey Son <sson@FreeBSD.org> > Signed-off-by: Karim Taha <kariem.taha2.7@gmail.com> > --- > bsd-user/freebsd/os-proc.c | 223 ++++++++++++++++++++++++++++++++++ > bsd-user/freebsd/os-syscall.c | 3 + > 2 files changed, 226 insertions(+) > > diff --git a/bsd-user/freebsd/os-proc.c b/bsd-user/freebsd/os-proc.c > index 12d78b7fc9..6b8753f8e5 100644 > --- a/bsd-user/freebsd/os-proc.c > +++ b/bsd-user/freebsd/os-proc.c > @@ -255,3 +255,226 @@ execve_end: > return ret; > } > > +#include <sys/procctl.h> > + > +static abi_long > +t2h_procctl_cmd(int target_cmd, int *host_cmd) > +{ > + switch (target_cmd) { > + case TARGET_PROC_SPROTECT: > + *host_cmd = PROC_SPROTECT; > + break; > + > + case TARGET_PROC_REAP_ACQUIRE: > + *host_cmd = PROC_REAP_ACQUIRE; > + break; > + > + case TARGET_PROC_REAP_RELEASE: > + *host_cmd = PROC_REAP_RELEASE; > + break; > + > + case TARGET_PROC_REAP_STATUS: > + *host_cmd = PROC_REAP_STATUS; > + break; > + > + case TARGET_PROC_REAP_KILL: > + *host_cmd = PROC_REAP_KILL; > + break; > + > + default: > + return -TARGET_EINVAL; > + } > + > + return 0; > +} > + > +static abi_long > +h2t_reaper_status(struct procctl_reaper_status *host_rs, > + abi_ulong target_rs_addr) > +{ > + struct target_procctl_reaper_status *target_rs; > + > + if (!lock_user_struct(VERIFY_WRITE, target_rs, target_rs_addr, 0)) { > + return -TARGET_EFAULT; > + } > + __put_user(host_rs->rs_flags, &target_rs->rs_flags); > + __put_user(host_rs->rs_children, &target_rs->rs_children); > + __put_user(host_rs->rs_descendants, &target_rs->rs_descendants); > + __put_user(host_rs->rs_reaper, &target_rs->rs_reaper); > + __put_user(host_rs->rs_pid, &target_rs->rs_pid); > + unlock_user_struct(target_rs, target_rs_addr, 1); > + > + return 0; > +} > + > +static abi_long > +t2h_reaper_kill(abi_ulong target_rk_addr, struct procctl_reaper_kill > *host_rk) > +{ > + struct target_procctl_reaper_kill *target_rk; > + > + if (!lock_user_struct(VERIFY_READ, target_rk, target_rk_addr, 1)) { > + return -TARGET_EFAULT; > + } > + __get_user(host_rk->rk_sig, &target_rk->rk_sig); > + __get_user(host_rk->rk_flags, &target_rk->rk_flags); > + __get_user(host_rk->rk_subtree, &target_rk->rk_subtree); > + __get_user(host_rk->rk_killed, &target_rk->rk_killed); > + __get_user(host_rk->rk_fpid, &target_rk->rk_fpid); > + unlock_user_struct(target_rk, target_rk_addr, 0); > + > + return 0; > +} > + > +static abi_long > +h2t_reaper_kill(struct procctl_reaper_kill *host_rk, abi_ulong > target_rk_addr) > +{ > + struct target_procctl_reaper_kill *target_rk; > + > + if (!lock_user_struct(VERIFY_WRITE, target_rk, target_rk_addr, 0)) { > + return -TARGET_EFAULT; > + } > + __put_user(host_rk->rk_sig, &target_rk->rk_sig); > + __put_user(host_rk->rk_flags, &target_rk->rk_flags); > + __put_user(host_rk->rk_subtree, &target_rk->rk_subtree); > + __put_user(host_rk->rk_killed, &target_rk->rk_killed); > + __put_user(host_rk->rk_fpid, &target_rk->rk_fpid); > + unlock_user_struct(target_rk, target_rk_addr, 1); > + > + return 0; > +} > + > +static abi_long > +h2t_procctl_reaper_pidinfo(struct procctl_reaper_pidinfo *host_pi, > + abi_ulong target_pi_addr) > +{ > + struct target_procctl_reaper_pidinfo *target_pi; > + > + if (!lock_user_struct(VERIFY_WRITE, target_pi, target_pi_addr, 0)) { > + return -TARGET_EFAULT; > + } > + __put_user(host_pi->pi_pid, &target_pi->pi_pid); > + __put_user(host_pi->pi_subtree, &target_pi->pi_subtree); > + __put_user(host_pi->pi_flags, &target_pi->pi_flags); > + unlock_user_struct(target_pi, target_pi_addr, 1); > + > + return 0; > +} > + > +abi_long > +do_freebsd_procctl(void *cpu_env, int idtype, abi_ulong arg2, abi_ulong > arg3, > + abi_ulong arg4, abi_ulong arg5, abi_ulong arg6) > +{ > + abi_long error = 0, target_rp_pids; > + void *data; > + int host_cmd, flags; > + uint32_t u, target_rp_count; > + union { > + struct procctl_reaper_status rs; > + struct procctl_reaper_pids rp; > + struct procctl_reaper_kill rk; > + } host; > + struct target_procctl_reaper_pids *target_rp; > + id_t id; /* 64-bit */ > + int target_cmd; > + abi_ulong target_arg; > + > +#if TARGET_ABI_BITS == 32 > + /* See if we need to align the register pairs. */ > + if (regpairs_aligned(cpu_env)) { > + id = (id_t)target_arg64(arg3, arg4); > + target_cmd = (int)arg5; > + target_arg = arg6; > + } else { > + id = (id_t)target_arg64(arg2, arg3); > + target_cmd = (int)arg4; > + target_arg = arg5; > + } > +#else > + id = (id_t)arg2; > + target_cmd = (int)arg3; > + target_arg = arg4; > +#endif > + > + error = t2h_procctl_cmd(target_cmd, &host_cmd); > + if (error) { > + return error; > + } > + switch (host_cmd) { > + case PROC_SPROTECT: > + data = &flags; > + break; > + > + case PROC_REAP_ACQUIRE: > + case PROC_REAP_RELEASE: > + if (target_arg == 0) { > + data = NULL; > + } else { > + error = -TARGET_EINVAL; > + } > + break; > + > + case PROC_REAP_STATUS: > + data = &host.rs; > + break; > + > + case PROC_REAP_GETPIDS: > + if (!lock_user_struct(VERIFY_READ, target_rp, target_arg, 1)) { > + return -TARGET_EFAULT; > + } > + __get_user(target_rp_count, &target_rp->rp_count); > + __get_user(target_rp_pids, &target_rp->rp_pids); > + unlock_user_struct(target_rp, target_arg, 0); > + host.rp.rp_count = target_rp_count; > + /* XXX we should check target_rc_count to see if it is > reasonable. */ > + host.rp.rp_pids = alloca(target_rp_count * > + sizeof(struct procctl_reaper_pidinfo)); > I think that there's been a general move to using the 'smart pointer' version of this that you've done for other patches. I think that target_rc_count likely is going to be small enough, but that doing the conversion will ensure that it is (so we can eliminate the comment too). Warner > + if (host.rp.rp_pids == NULL) { > + error = -TARGET_ENOMEM; > + } else { > + data = &host.rp; > + } > + break; > + > + case PROC_REAP_KILL: > + error = t2h_reaper_kill(target_arg, &host.rk); > + break; > + } > + > + if (error) { > + return error; > + } > + error = get_errno(procctl(idtype, id, host_cmd, data)); > + > + if (error) { > + return error; > + } > + switch (host_cmd) { > + case PROC_SPROTECT: > + if (put_user_s32(flags, target_arg)) { > + return -TARGET_EFAULT; > + } > + break; > + > + case PROC_REAP_STATUS: > + error = h2t_reaper_status(&host.rs, target_arg); > + break; > + > + case PROC_REAP_GETPIDS: > + /* copyout reaper pidinfo */ > + for (u = 0; u < target_rp_count; u++) { > + error = h2t_procctl_reaper_pidinfo(&host.rp.rp_pids[u], > + target_rp_pids + > + (u * sizeof(struct target_procctl_reaper_pidinfo))); > + if (error) { > + break; > + } > + } > + break; > + > + case PROC_REAP_KILL: > + error = h2t_reaper_kill(&host.rk, target_arg); > + break; > + } > + > + return error; > +} > diff --git a/bsd-user/freebsd/os-syscall.c b/bsd-user/freebsd/os-syscall.c > index 71a2657dd0..b7bd0b92a6 100644 > --- a/bsd-user/freebsd/os-syscall.c > +++ b/bsd-user/freebsd/os-syscall.c > @@ -367,6 +367,9 @@ static abi_long freebsd_syscall(void *cpu_env, int > num, abi_long arg1, > ret = do_bsd_setpriority(arg1, arg2, arg3); > break; > > + case TARGET_FREEBSD_NR_procctl: /* procctl(2) */ > + ret = do_freebsd_procctl(cpu_env, arg1, arg2, arg3, arg4, arg5, > arg6); > + break; > > /* > * File system calls. > -- > 2.42.0 > >
diff --git a/bsd-user/freebsd/os-proc.c b/bsd-user/freebsd/os-proc.c index 12d78b7fc9..6b8753f8e5 100644 --- a/bsd-user/freebsd/os-proc.c +++ b/bsd-user/freebsd/os-proc.c @@ -255,3 +255,226 @@ execve_end: return ret; } +#include <sys/procctl.h> + +static abi_long +t2h_procctl_cmd(int target_cmd, int *host_cmd) +{ + switch (target_cmd) { + case TARGET_PROC_SPROTECT: + *host_cmd = PROC_SPROTECT; + break; + + case TARGET_PROC_REAP_ACQUIRE: + *host_cmd = PROC_REAP_ACQUIRE; + break; + + case TARGET_PROC_REAP_RELEASE: + *host_cmd = PROC_REAP_RELEASE; + break; + + case TARGET_PROC_REAP_STATUS: + *host_cmd = PROC_REAP_STATUS; + break; + + case TARGET_PROC_REAP_KILL: + *host_cmd = PROC_REAP_KILL; + break; + + default: + return -TARGET_EINVAL; + } + + return 0; +} + +static abi_long +h2t_reaper_status(struct procctl_reaper_status *host_rs, + abi_ulong target_rs_addr) +{ + struct target_procctl_reaper_status *target_rs; + + if (!lock_user_struct(VERIFY_WRITE, target_rs, target_rs_addr, 0)) { + return -TARGET_EFAULT; + } + __put_user(host_rs->rs_flags, &target_rs->rs_flags); + __put_user(host_rs->rs_children, &target_rs->rs_children); + __put_user(host_rs->rs_descendants, &target_rs->rs_descendants); + __put_user(host_rs->rs_reaper, &target_rs->rs_reaper); + __put_user(host_rs->rs_pid, &target_rs->rs_pid); + unlock_user_struct(target_rs, target_rs_addr, 1); + + return 0; +} + +static abi_long +t2h_reaper_kill(abi_ulong target_rk_addr, struct procctl_reaper_kill *host_rk) +{ + struct target_procctl_reaper_kill *target_rk; + + if (!lock_user_struct(VERIFY_READ, target_rk, target_rk_addr, 1)) { + return -TARGET_EFAULT; + } + __get_user(host_rk->rk_sig, &target_rk->rk_sig); + __get_user(host_rk->rk_flags, &target_rk->rk_flags); + __get_user(host_rk->rk_subtree, &target_rk->rk_subtree); + __get_user(host_rk->rk_killed, &target_rk->rk_killed); + __get_user(host_rk->rk_fpid, &target_rk->rk_fpid); + unlock_user_struct(target_rk, target_rk_addr, 0); + + return 0; +} + +static abi_long +h2t_reaper_kill(struct procctl_reaper_kill *host_rk, abi_ulong target_rk_addr) +{ + struct target_procctl_reaper_kill *target_rk; + + if (!lock_user_struct(VERIFY_WRITE, target_rk, target_rk_addr, 0)) { + return -TARGET_EFAULT; + } + __put_user(host_rk->rk_sig, &target_rk->rk_sig); + __put_user(host_rk->rk_flags, &target_rk->rk_flags); + __put_user(host_rk->rk_subtree, &target_rk->rk_subtree); + __put_user(host_rk->rk_killed, &target_rk->rk_killed); + __put_user(host_rk->rk_fpid, &target_rk->rk_fpid); + unlock_user_struct(target_rk, target_rk_addr, 1); + + return 0; +} + +static abi_long +h2t_procctl_reaper_pidinfo(struct procctl_reaper_pidinfo *host_pi, + abi_ulong target_pi_addr) +{ + struct target_procctl_reaper_pidinfo *target_pi; + + if (!lock_user_struct(VERIFY_WRITE, target_pi, target_pi_addr, 0)) { + return -TARGET_EFAULT; + } + __put_user(host_pi->pi_pid, &target_pi->pi_pid); + __put_user(host_pi->pi_subtree, &target_pi->pi_subtree); + __put_user(host_pi->pi_flags, &target_pi->pi_flags); + unlock_user_struct(target_pi, target_pi_addr, 1); + + return 0; +} + +abi_long +do_freebsd_procctl(void *cpu_env, int idtype, abi_ulong arg2, abi_ulong arg3, + abi_ulong arg4, abi_ulong arg5, abi_ulong arg6) +{ + abi_long error = 0, target_rp_pids; + void *data; + int host_cmd, flags; + uint32_t u, target_rp_count; + union { + struct procctl_reaper_status rs; + struct procctl_reaper_pids rp; + struct procctl_reaper_kill rk; + } host; + struct target_procctl_reaper_pids *target_rp; + id_t id; /* 64-bit */ + int target_cmd; + abi_ulong target_arg; + +#if TARGET_ABI_BITS == 32 + /* See if we need to align the register pairs. */ + if (regpairs_aligned(cpu_env)) { + id = (id_t)target_arg64(arg3, arg4); + target_cmd = (int)arg5; + target_arg = arg6; + } else { + id = (id_t)target_arg64(arg2, arg3); + target_cmd = (int)arg4; + target_arg = arg5; + } +#else + id = (id_t)arg2; + target_cmd = (int)arg3; + target_arg = arg4; +#endif + + error = t2h_procctl_cmd(target_cmd, &host_cmd); + if (error) { + return error; + } + switch (host_cmd) { + case PROC_SPROTECT: + data = &flags; + break; + + case PROC_REAP_ACQUIRE: + case PROC_REAP_RELEASE: + if (target_arg == 0) { + data = NULL; + } else { + error = -TARGET_EINVAL; + } + break; + + case PROC_REAP_STATUS: + data = &host.rs; + break; + + case PROC_REAP_GETPIDS: + if (!lock_user_struct(VERIFY_READ, target_rp, target_arg, 1)) { + return -TARGET_EFAULT; + } + __get_user(target_rp_count, &target_rp->rp_count); + __get_user(target_rp_pids, &target_rp->rp_pids); + unlock_user_struct(target_rp, target_arg, 0); + host.rp.rp_count = target_rp_count; + /* XXX we should check target_rc_count to see if it is reasonable. */ + host.rp.rp_pids = alloca(target_rp_count * + sizeof(struct procctl_reaper_pidinfo)); + if (host.rp.rp_pids == NULL) { + error = -TARGET_ENOMEM; + } else { + data = &host.rp; + } + break; + + case PROC_REAP_KILL: + error = t2h_reaper_kill(target_arg, &host.rk); + break; + } + + if (error) { + return error; + } + error = get_errno(procctl(idtype, id, host_cmd, data)); + + if (error) { + return error; + } + switch (host_cmd) { + case PROC_SPROTECT: + if (put_user_s32(flags, target_arg)) { + return -TARGET_EFAULT; + } + break; + + case PROC_REAP_STATUS: + error = h2t_reaper_status(&host.rs, target_arg); + break; + + case PROC_REAP_GETPIDS: + /* copyout reaper pidinfo */ + for (u = 0; u < target_rp_count; u++) { + error = h2t_procctl_reaper_pidinfo(&host.rp.rp_pids[u], + target_rp_pids + + (u * sizeof(struct target_procctl_reaper_pidinfo))); + if (error) { + break; + } + } + break; + + case PROC_REAP_KILL: + error = h2t_reaper_kill(&host.rk, target_arg); + break; + } + + return error; +} diff --git a/bsd-user/freebsd/os-syscall.c b/bsd-user/freebsd/os-syscall.c index 71a2657dd0..b7bd0b92a6 100644 --- a/bsd-user/freebsd/os-syscall.c +++ b/bsd-user/freebsd/os-syscall.c @@ -367,6 +367,9 @@ static abi_long freebsd_syscall(void *cpu_env, int num, abi_long arg1, ret = do_bsd_setpriority(arg1, arg2, arg3); break; + case TARGET_FREEBSD_NR_procctl: /* procctl(2) */ + ret = do_freebsd_procctl(cpu_env, arg1, arg2, arg3, arg4, arg5, arg6); + break; /* * File system calls.