[PATCH v2 21/28] bsd-user: Implement procctl(2) along with necessary conversion functions.

Karim Taha posted 28 patches 1 year, 1 month ago
Maintainers: Warner Losh <imp@bsdimp.com>, Kyle Evans <kevans@freebsd.org>
There is a newer version of this series
[PATCH v2 21/28] bsd-user: Implement procctl(2) along with necessary conversion functions.
Posted by Karim Taha 1 year, 1 month ago
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));
+        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
Re: [PATCH v2 21/28] bsd-user: Implement procctl(2) along with necessary conversion functions.
Posted by Warner Losh 1 year, 1 month ago
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
>
>