[PATCH v1] linux-user: Add option to run `execve`d programs through QEMU
The new option '-qemu-children' makes it so that on `execve` the child
process will be launch by the same `qemu` executable that is currently
running along with its current commandline arguments.
The motivation for the change is to make it so that plugins running
through `qemu` can continue to run on children. Why not just
`binfmt`?: Plugins can be desirable regardless of system/architecture
emulation, and can sometimes be useful for elf files that can run
natively. Enabling `binfmt` for all natively runnable elf files may
not be desirable.
Signed-off-by: Noah Goldstein
---
linux-user/main.c | 22 ++
linux-user/syscall.c| 20 +++-
linux-user/user-internals.h | 4
3 files changed, 41 insertions(+), 5 deletions(-)
diff --git a/linux-user/main.c b/linux-user/main.c
index 8143a0d4b0..dfb303a1f2 100644
--- a/linux-user/main.c
+++ b/linux-user/main.c
@@ -81,6 +81,10 @@ unsigned long mmap_min_addr;
uintptr_t guest_base;
bool have_guest_base;
+bool qemu_dup_for_children;
+int qemu_argc;
+char ** qemu_argv;
+
/*
* Used to implement backwards-compatibility for the `-strace`, and
* QEMU_STRACE options. Without this, the QEMU_LOG can be overwritten by
@@ -451,6 +455,11 @@ static void handle_arg_jitdump(const char *arg)
perf_enable_jitdump();
}
+static void handle_arg_qemu_children(const char *arg)
+{
+qemu_dup_for_children = true;
+}
+
static QemuPluginList plugins = QTAILQ_HEAD_INITIALIZER(plugins);
#ifdef CONFIG_PLUGIN
@@ -526,6 +535,10 @@ static const struct qemu_argument arg_table[] = {
"", "Generate a /tmp/perf-${pid}.map file for perf"},
{"jitdump","QEMU_JITDUMP", false, handle_arg_jitdump,
"", "Generate a jit-${pid}.dump file for perf"},
+{"qemu-children",
+ "QEMU_CHILDREN",false, handle_arg_qemu_children,
+ "", "Run child processes (created with execve) with qemu "
+ "(as instantiated for the parent)"},
{NULL, NULL, false, NULL, NULL, NULL}
};
@@ -729,6 +742,15 @@ int main(int argc, char **argv, char **envp)
optind = parse_args(argc, argv);
+if (qemu_dup_for_children) {
+int i;
+qemu_argc = optind;
+qemu_argv = g_new0(char *, qemu_argc);
+for (i = 0; i < optind; ++i) {
+qemu_argv[i] = strdup(argv[i]);
+}
+}
+
qemu_set_log_filename_flags(last_log_filename,
last_log_mask | (enable_strace * LOG_STRACE),
&error_fatal);
diff --git a/linux-user/syscall.c b/linux-user/syscall.c
index 9d5415674d..732ef89054 100644
--- a/linux-user/syscall.c
+++ b/linux-user/syscall.c
@@ -8459,13 +8459,14 @@ static int do_execv(CPUArchState *cpu_env, int dirfd,
abi_long pathname, abi_long guest_argp,
abi_long guest_envp, int flags, bool is_execveat)
{
-int ret;
+int ret, argp_offset;
char **argp, **envp;
int argc, envc;
abi_ulong gp;
abi_ulong addr;
char **q;
void *p;
+bool through_qemu = !is_execveat && qemu_dup_for_children;
argc = 0;
@@ -8489,10 +8490,11 @@ static int do_execv(CPUArchState *cpu_env, int dirfd,
envc++;
}
-argp = g_new0(char *, argc + 1);
+argp_offset = through_qemu ? qemu_argc : 0;
+argp = g_new0(char *, argc + argp_offset + 1);
envp = g_new0(char *, envc + 1);
-for (gp = guest_argp, q = argp; gp; gp += sizeof(abi_ulong), q++) {
+for (gp = guest_argp, q = argp + argp_offset; gp; gp += sizeof(abi_ulong),
q++) {
if (get_user_ual(addr, gp)) {
goto execve_efault;
}
@@ -8537,9 +8539,17 @@ static int do_execv(CPUArchState *cpu_env, int dirfd,
}
const char *exe = p;
-if (is_proc_myself(p, "exe")) {
+if (through_qemu) {
+int i;
+for (i = 0; i < argp_offset; ++i) {
+argp[i] = qemu_argv[i];
+}
+exe = qemu_argv[0];
+}
+else if (is_proc_myself(p, "exe")) {
exe = exec_path;
}
+
ret = is_execveat
? safe_execveat(dirfd, exe, argp, envp, flags)
: safe_execve(exe, argp, envp);
@@ -8553,7 +8563,7 @@ execve_efault:
ret = -TARGET_EFAULT;
execve_end:
-for (gp = guest_argp, q = argp; *q; gp += sizeof(abi_ulong), q++) {
+for (gp = guest_argp, q = argp + argp_offset; *q; gp += sizeof(abi_ulong),
q++) {
if (get_user_ual(addr, gp) || !addr) {
break;
}
diff --git a/linux-user/user-internals.h b/linux-user/user-internals.h
index 5c7f173ceb..0719e65ff4 100644
--- a/linux-user/user-internals.h
+++ b/linux-user/user-internals.h
@@ -30,6 +30,10 @@ void stop_all_tasks(void);
extern const char *qemu_uname_release;
extern unsigned l
Re: [PATCH v1] linux-user: Add option to run `execve`d programs through QEMU
On Fri, Aug 30, 2024 at 3:36 PM Noah Goldstein wrote:
>
> The new option '-qemu-children' makes it so that on `execve` the child
> process will be launch by the same `qemu` executable that is currently
> running along with its current commandline arguments.
>
> The motivation for the change is to make it so that plugins running
> through `qemu` can continue to run on children. Why not just
> `binfmt`?: Plugins can be desirable regardless of system/architecture
> emulation, and can sometimes be useful for elf files that can run
> natively. Enabling `binfmt` for all natively runnable elf files may
> not be desirable.
>
> Signed-off-by: Noah Goldstein
> ---
> linux-user/main.c | 22 ++
> linux-user/syscall.c| 20 +++-
> linux-user/user-internals.h | 4
> 3 files changed, 41 insertions(+), 5 deletions(-)
>
> diff --git a/linux-user/main.c b/linux-user/main.c
> index 8143a0d4b0..dfb303a1f2 100644
> --- a/linux-user/main.c
> +++ b/linux-user/main.c
> @@ -81,6 +81,10 @@ unsigned long mmap_min_addr;
> uintptr_t guest_base;
> bool have_guest_base;
>
> +bool qemu_dup_for_children;
> +int qemu_argc;
> +char ** qemu_argv;
> +
> /*
> * Used to implement backwards-compatibility for the `-strace`, and
> * QEMU_STRACE options. Without this, the QEMU_LOG can be overwritten by
> @@ -451,6 +455,11 @@ static void handle_arg_jitdump(const char *arg)
> perf_enable_jitdump();
> }
>
> +static void handle_arg_qemu_children(const char *arg)
> +{
> +qemu_dup_for_children = true;
> +}
> +
> static QemuPluginList plugins = QTAILQ_HEAD_INITIALIZER(plugins);
>
> #ifdef CONFIG_PLUGIN
> @@ -526,6 +535,10 @@ static const struct qemu_argument arg_table[] = {
> "", "Generate a /tmp/perf-${pid}.map file for perf"},
> {"jitdump","QEMU_JITDUMP", false, handle_arg_jitdump,
> "", "Generate a jit-${pid}.dump file for perf"},
> +{"qemu-children",
> + "QEMU_CHILDREN",false, handle_arg_qemu_children,
> + "", "Run child processes (created with execve) with qemu "
> + "(as instantiated for the parent)"},
> {NULL, NULL, false, NULL, NULL, NULL}
> };
>
> @@ -729,6 +742,15 @@ int main(int argc, char **argv, char **envp)
>
> optind = parse_args(argc, argv);
>
> +if (qemu_dup_for_children) {
> +int i;
> +qemu_argc = optind;
> +qemu_argv = g_new0(char *, qemu_argc);
> +for (i = 0; i < optind; ++i) {
> +qemu_argv[i] = strdup(argv[i]);
> +}
> +}
> +
> qemu_set_log_filename_flags(last_log_filename,
> last_log_mask | (enable_strace * LOG_STRACE),
> &error_fatal);
> diff --git a/linux-user/syscall.c b/linux-user/syscall.c
> index 9d5415674d..732ef89054 100644
> --- a/linux-user/syscall.c
> +++ b/linux-user/syscall.c
> @@ -8459,13 +8459,14 @@ static int do_execv(CPUArchState *cpu_env, int dirfd,
> abi_long pathname, abi_long guest_argp,
> abi_long guest_envp, int flags, bool is_execveat)
> {
> -int ret;
> +int ret, argp_offset;
> char **argp, **envp;
> int argc, envc;
> abi_ulong gp;
> abi_ulong addr;
> char **q;
> void *p;
> +bool through_qemu = !is_execveat && qemu_dup_for_children;
>
I wasn't sure if this was feasible for `evecveat`. If anyone has any thoughts
it would be nice to support that as well.
> argc = 0;
>
> @@ -8489,10 +8490,11 @@ static int do_execv(CPUArchState *cpu_env, int dirfd,
> envc++;
> }
>
> -argp = g_new0(char *, argc + 1);
> +argp_offset = through_qemu ? qemu_argc : 0;
> +argp = g_new0(char *, argc + argp_offset + 1);
> envp = g_new0(char *, envc + 1);
>
> -for (gp = guest_argp, q = argp; gp; gp += sizeof(abi_ulong), q++) {
> +for (gp = guest_argp, q = argp + argp_offset; gp; gp +=
> sizeof(abi_ulong), q++) {
> if (get_user_ual(addr, gp)) {
> goto execve_efault;
> }
> @@ -8537,9 +8539,17 @@ static int do_execv(CPUArchState *cpu_env, int dirfd,
> }
>
> const char *exe = p;
> -if (is_proc_myself(p, "exe")) {
> +if (through_qemu) {
> +int i;
> +for (i = 0; i < argp_offset; ++i) {
> +argp[i] = qemu_argv[i];
> +}
> +exe = qemu_argv[0];
> +}
> +else if (is_proc_myself(p, "exe"))
Re: [PATCH v1] linux-user: Add option to run `execve`d programs through QEMU
On Fri, Aug 30, 2024 at 3:37 PM Noah Goldstein wrote:
>
> On Fri, Aug 30, 2024 at 3:36 PM Noah Goldstein
> wrote:
> >
> > The new option '-qemu-children' makes it so that on `execve` the child
> > process will be launch by the same `qemu` executable that is currently
> > running along with its current commandline arguments.
> >
> > The motivation for the change is to make it so that plugins running
> > through `qemu` can continue to run on children. Why not just
> > `binfmt`?: Plugins can be desirable regardless of system/architecture
> > emulation, and can sometimes be useful for elf files that can run
> > natively. Enabling `binfmt` for all natively runnable elf files may
> > not be desirable.
> >
> > Signed-off-by: Noah Goldstein
> > ---
> > linux-user/main.c | 22 ++
> > linux-user/syscall.c| 20 +++-
> > linux-user/user-internals.h | 4
> > 3 files changed, 41 insertions(+), 5 deletions(-)
> >
> > diff --git a/linux-user/main.c b/linux-user/main.c
> > index 8143a0d4b0..dfb303a1f2 100644
> > --- a/linux-user/main.c
> > +++ b/linux-user/main.c
> > @@ -81,6 +81,10 @@ unsigned long mmap_min_addr;
> > uintptr_t guest_base;
> > bool have_guest_base;
> >
> > +bool qemu_dup_for_children;
> > +int qemu_argc;
> > +char ** qemu_argv;
> > +
> > /*
> > * Used to implement backwards-compatibility for the `-strace`, and
> > * QEMU_STRACE options. Without this, the QEMU_LOG can be overwritten by
> > @@ -451,6 +455,11 @@ static void handle_arg_jitdump(const char *arg)
> > perf_enable_jitdump();
> > }
> >
> > +static void handle_arg_qemu_children(const char *arg)
> > +{
> > +qemu_dup_for_children = true;
> > +}
> > +
> > static QemuPluginList plugins = QTAILQ_HEAD_INITIALIZER(plugins);
> >
> > #ifdef CONFIG_PLUGIN
> > @@ -526,6 +535,10 @@ static const struct qemu_argument arg_table[] = {
> > "", "Generate a /tmp/perf-${pid}.map file for perf"},
> > {"jitdump","QEMU_JITDUMP", false, handle_arg_jitdump,
> > "", "Generate a jit-${pid}.dump file for perf"},
> > +{"qemu-children",
> > + "QEMU_CHILDREN",false, handle_arg_qemu_children,
> > + "", "Run child processes (created with execve) with qemu "
> > + "(as instantiated for the parent)"},
> > {NULL, NULL, false, NULL, NULL, NULL}
> > };
> >
> > @@ -729,6 +742,15 @@ int main(int argc, char **argv, char **envp)
> >
> > optind = parse_args(argc, argv);
> >
> > +if (qemu_dup_for_children) {
> > +int i;
> > +qemu_argc = optind;
> > +qemu_argv = g_new0(char *, qemu_argc);
> > +for (i = 0; i < optind; ++i) {
> > +qemu_argv[i] = strdup(argv[i]);
> > +}
> > +}
> > +
> > qemu_set_log_filename_flags(last_log_filename,
> > last_log_mask | (enable_strace *
> > LOG_STRACE),
> > &error_fatal);
> > diff --git a/linux-user/syscall.c b/linux-user/syscall.c
> > index 9d5415674d..732ef89054 100644
> > --- a/linux-user/syscall.c
> > +++ b/linux-user/syscall.c
> > @@ -8459,13 +8459,14 @@ static int do_execv(CPUArchState *cpu_env, int
> > dirfd,
> > abi_long pathname, abi_long guest_argp,
> > abi_long guest_envp, int flags, bool is_execveat)
> > {
> > -int ret;
> > +int ret, argp_offset;
> > char **argp, **envp;
> > int argc, envc;
> > abi_ulong gp;
> > abi_ulong addr;
> > char **q;
> > void *p;
> > +bool through_qemu = !is_execveat && qemu_dup_for_children;
> >
> I wasn't sure if this was feasible for `evecveat`. If anyone has any thoughts
> it would be nice to support that as well.
>
> > argc = 0;
> >
> > @@ -8489,10 +8490,11 @@ static int do_execv(CPUArchState *cpu_env, int
> > dirfd,
> > envc++;
> > }
> >
> > -argp = g_new0(char *, argc + 1);
> > +argp_offset = through_qemu ? qemu_argc : 0;
> > +argp = g_new0(char *, argc + argp_offset + 1);
> > envp = g_new0(char *, envc + 1);
> >
> > -for (gp = guest_argp, q = argp; gp; gp += sizeof(abi_ulong), q++) {
&
Re: [PATCH v1] linux-user: Add option to run `execve`d programs through QEMU
On Wed, Oct 2, 2024 at 11:42 AM Noah Goldstein wrote: > > On Wed, Oct 2, 2024 at 11:39 AM Ilya Leoshkevich wrote: > > > > On Wed, 2024-10-02 at 09:05 -0500, Noah Goldstein wrote: > > > On Wed, Oct 2, 2024 at 3:08 AM Ilya Leoshkevich > > > wrote: > > > > > > > > On Fri, 2024-08-30 at 15:36 -0700, Noah Goldstein wrote: > > > > > The new option '-qemu-children' makes it so that on `execve` the > > > > > child > > > > > process will be launch by the same `qemu` executable that is > > > > > currently > > > > > running along with its current commandline arguments. > > > > > > > > > > The motivation for the change is to make it so that plugins > > > > > running > > > > > through `qemu` can continue to run on children. Why not just > > > > > `binfmt`?: Plugins can be desirable regardless of > > > > > system/architecture > > > > > emulation, and can sometimes be useful for elf files that can run > > > > > natively. Enabling `binfmt` for all natively runnable elf files > > > > > may > > > > > not be desirable. > > > > > > > > Another reason to have this is that one may not have root > > > > permissions > > > > to configure binfmt-misc. > > > > > > > +1 > > > > > > > There was a similar patch posted to the mailing list some years > > > > back, > > > > which I used to cherry-pick when I needed this. I'm not sure what > > > > happened to that discussion though. > > > > > > Yes(ish): > > > https://patchwork.ozlabs.org/project/qemu-devel/patch/1455515507-26877-1-git-send-email-petros...@resin.io/ > > > > Thanks for finding this! Don't we need the shebang handling here as > > well? > > > I don't think so. In this case we aren't making it so execve can point to > some arbitrary impl, just that we propagate the current running qemu > env. > ping > > Laurent, do you per chance know why was it not accepted back > > then?Unfortunately I cannot find any discussion associated with v3 or > > v4 > > [1]. There were some concerns regarding v1 [2], but from what I can see > > they all were addressed. > > > > [1] > > https://patchew.org/QEMU/20200730160106.16613-1-rj.bcje...@gmail.com/ > > [2] > > https://patchwork.kernel.org/project/qemu-devel/patch/1453091602-21843-1-git-send-email-petros...@gmail.com/
Re: [PATCH v1] linux-user: Add option to run `execve`d programs through QEMU
On Fri, Oct 11, 2024 at 1:14 PM Noah Goldstein wrote: > > On Wed, Oct 2, 2024 at 11:42 AM Noah Goldstein > wrote: > > > > On Wed, Oct 2, 2024 at 11:39 AM Ilya Leoshkevich wrote: > > > > > > On Wed, 2024-10-02 at 09:05 -0500, Noah Goldstein wrote: > > > > On Wed, Oct 2, 2024 at 3:08 AM Ilya Leoshkevich > > > > wrote: > > > > > > > > > > On Fri, 2024-08-30 at 15:36 -0700, Noah Goldstein wrote: > > > > > > The new option '-qemu-children' makes it so that on `execve` the > > > > > > child > > > > > > process will be launch by the same `qemu` executable that is > > > > > > currently > > > > > > running along with its current commandline arguments. > > > > > > > > > > > > The motivation for the change is to make it so that plugins > > > > > > running > > > > > > through `qemu` can continue to run on children. Why not just > > > > > > `binfmt`?: Plugins can be desirable regardless of > > > > > > system/architecture > > > > > > emulation, and can sometimes be useful for elf files that can run > > > > > > natively. Enabling `binfmt` for all natively runnable elf files > > > > > > may > > > > > > not be desirable. > > > > > > > > > > Another reason to have this is that one may not have root > > > > > permissions > > > > > to configure binfmt-misc. > > > > > > > > > +1 > > > > > > > > > There was a similar patch posted to the mailing list some years > > > > > back, > > > > > which I used to cherry-pick when I needed this. I'm not sure what > > > > > happened to that discussion though. > > > > > > > > Yes(ish): > > > > https://patchwork.ozlabs.org/project/qemu-devel/patch/1455515507-26877-1-git-send-email-petros...@resin.io/ > > > > > > Thanks for finding this! Don't we need the shebang handling here as > > > well? > > > > > I don't think so. In this case we aren't making it so execve can point to > > some arbitrary impl, just that we propagate the current running qemu > > env. > > > > ping ping2 > > > Laurent, do you per chance know why was it not accepted back > > > then?Unfortunately I cannot find any discussion associated with v3 or > > > v4 > > > [1]. There were some concerns regarding v1 [2], but from what I can see > > > they all were addressed. > > > > > > [1] > > > https://patchew.org/QEMU/20200730160106.16613-1-rj.bcje...@gmail.com/ > > > [2] > > > https://patchwork.kernel.org/project/qemu-devel/patch/1453091602-21843-1-git-send-email-petros...@gmail.com/
Re: [PATCH v1] linux-user: Add option to run `execve`d programs through QEMU
On Tue, Oct 22, 2024 at 5:06 PM Noah Goldstein wrote: > > On Fri, Oct 11, 2024 at 1:14 PM Noah Goldstein > wrote: > > > > On Wed, Oct 2, 2024 at 11:42 AM Noah Goldstein > > wrote: > > > > > > On Wed, Oct 2, 2024 at 11:39 AM Ilya Leoshkevich > > > wrote: > > > > > > > > On Wed, 2024-10-02 at 09:05 -0500, Noah Goldstein wrote: > > > > > On Wed, Oct 2, 2024 at 3:08 AM Ilya Leoshkevich > > > > > wrote: > > > > > > > > > > > > On Fri, 2024-08-30 at 15:36 -0700, Noah Goldstein wrote: > > > > > > > The new option '-qemu-children' makes it so that on `execve` the > > > > > > > child > > > > > > > process will be launch by the same `qemu` executable that is > > > > > > > currently > > > > > > > running along with its current commandline arguments. > > > > > > > > > > > > > > The motivation for the change is to make it so that plugins > > > > > > > running > > > > > > > through `qemu` can continue to run on children. Why not just > > > > > > > `binfmt`?: Plugins can be desirable regardless of > > > > > > > system/architecture > > > > > > > emulation, and can sometimes be useful for elf files that can run > > > > > > > natively. Enabling `binfmt` for all natively runnable elf files > > > > > > > may > > > > > > > not be desirable. > > > > > > > > > > > > Another reason to have this is that one may not have root > > > > > > permissions > > > > > > to configure binfmt-misc. > > > > > > > > > > > +1 > > > > > > > > > > > There was a similar patch posted to the mailing list some years > > > > > > back, > > > > > > which I used to cherry-pick when I needed this. I'm not sure what > > > > > > happened to that discussion though. > > > > > > > > > > Yes(ish): > > > > > https://patchwork.ozlabs.org/project/qemu-devel/patch/1455515507-26877-1-git-send-email-petros...@resin.io/ > > > > > > > > Thanks for finding this! Don't we need the shebang handling here as > > > > well? > > > > > > > I don't think so. In this case we aren't making it so execve can point to > > > some arbitrary impl, just that we propagate the current running qemu > > > env. > > > > > > > ping > ping2 pint3 > > > > Laurent, do you per chance know why was it not accepted back > > > > then?Unfortunately I cannot find any discussion associated with v3 or > > > > v4 > > > > [1]. There were some concerns regarding v1 [2], but from what I can see > > > > they all were addressed. > > > > > > > > [1] > > > > https://patchew.org/QEMU/20200730160106.16613-1-rj.bcje...@gmail.com/ > > > > [2] > > > > https://patchwork.kernel.org/project/qemu-devel/patch/1453091602-21843-1-git-send-email-petros...@gmail.com/
Re: [PATCH v1] linux-user: Add option to run `execve`d programs through QEMU
On Tue, Oct 29, 2024 at 10:23 AM Alex Bennée wrote:
>
> Noah Goldstein writes:
>
> > The new option '-qemu-children' makes it so that on `execve` the child
> > process will be launch by the same `qemu` executable that is currently
> > running along with its current commandline arguments.
> >
> > The motivation for the change is to make it so that plugins running
> > through `qemu` can continue to run on children. Why not just
> > `binfmt`?: Plugins can be desirable regardless of system/architecture
> > emulation, and can sometimes be useful for elf files that can run
> > natively. Enabling `binfmt` for all natively runnable elf files may
> > not be desirable.
>
> Broadly I don't see anything wrong with the patch. However my principle
> concern is how test it. Currently nothing in check-tcg ensures this
> mechanism works and stresses the argument copying.
Fair enough. I will add some tests.
>
> >
> > Signed-off-by: Noah Goldstein
> > ---
> > linux-user/main.c | 22 ++
> > linux-user/syscall.c| 20 +++-
> > linux-user/user-internals.h | 4
> > 3 files changed, 41 insertions(+), 5 deletions(-)
> >
> > diff --git a/linux-user/main.c b/linux-user/main.c
> > index 8143a0d4b0..dfb303a1f2 100644
> > --- a/linux-user/main.c
> > +++ b/linux-user/main.c
> > @@ -81,6 +81,10 @@ unsigned long mmap_min_addr;
> > uintptr_t guest_base;
> > bool have_guest_base;
> >
> > +bool qemu_dup_for_children;
> > +int qemu_argc;
> > +char ** qemu_argv;
> > +
> > /*
> > * Used to implement backwards-compatibility for the `-strace`, and
> > * QEMU_STRACE options. Without this, the QEMU_LOG can be overwritten by
> > @@ -451,6 +455,11 @@ static void handle_arg_jitdump(const char *arg)
> > perf_enable_jitdump();
> > }
> >
> > +static void handle_arg_qemu_children(const char *arg)
> > +{
> > +qemu_dup_for_children = true;
> > +}
> > +
> > static QemuPluginList plugins = QTAILQ_HEAD_INITIALIZER(plugins);
> >
> > #ifdef CONFIG_PLUGIN
> > @@ -526,6 +535,10 @@ static const struct qemu_argument arg_table[] = {
> > "", "Generate a /tmp/perf-${pid}.map file for perf"},
> > {"jitdump","QEMU_JITDUMP", false, handle_arg_jitdump,
> > "", "Generate a jit-${pid}.dump file for perf"},
> > +{"qemu-children",
> > + "QEMU_CHILDREN",false, handle_arg_qemu_children,
> > + "", "Run child processes (created with execve) with qemu "
> > + "(as instantiated for the parent)"},
> > {NULL, NULL, false, NULL, NULL, NULL}
> > };
> >
> > @@ -729,6 +742,15 @@ int main(int argc, char **argv, char **envp)
> >
> > optind = parse_args(argc, argv);
> >
> > +if (qemu_dup_for_children) {
> > +int i;
> > +qemu_argc = optind;
> > +qemu_argv = g_new0(char *, qemu_argc);
> > +for (i = 0; i < optind; ++i) {
> > +qemu_argv[i] = strdup(argv[i]);
> > +}
> > +}
> > +
> > qemu_set_log_filename_flags(last_log_filename,
> > last_log_mask | (enable_strace *
> > LOG_STRACE),
> > &error_fatal);
> > diff --git a/linux-user/syscall.c b/linux-user/syscall.c
> > index 9d5415674d..732ef89054 100644
> > --- a/linux-user/syscall.c
> > +++ b/linux-user/syscall.c
> > @@ -8459,13 +8459,14 @@ static int do_execv(CPUArchState *cpu_env, int
> > dirfd,
> > abi_long pathname, abi_long guest_argp,
> > abi_long guest_envp, int flags, bool is_execveat)
> > {
> > -int ret;
> > +int ret, argp_offset;
> > char **argp, **envp;
> > int argc, envc;
> > abi_ulong gp;
> > abi_ulong addr;
> > char **q;
> > void *p;
> > +bool through_qemu = !is_execveat && qemu_dup_for_children;
> >
> > argc = 0;
> >
> > @@ -8489,10 +8490,11 @@ static int do_execv(CPUArchState *cpu_env, int
> > dirfd,
> > envc++;
> > }
> >
> > -argp = g_new0(char *, argc + 1);
> > +argp_offset = through_qemu ? qemu_argc : 0;
> > +argp = g_new0(char *, argc + argp_offset + 1);
> > envp = g_new0(char *, envc + 1);
> >
> > -f
Re: linux-user: Add option to run `execve`d programs through QEMU
On Wed, Oct 30, 2024 at 9:10 AM Noah Goldstein wrote:
>
> The new option '-qemu-children' makes it so that on `execve` the child
> process will be launch by the same `qemu` executable that is currently
> running along with its current commandline arguments.
>
> The motivation for the change is to make it so that plugins running
> through `qemu` can continue to run on children. Why not just
> `binfmt`?: Plugins can be desirable regardless of system/architecture
> emulation, and can sometimes be useful for elf files that can run
> natively. Enabling `binfmt` for all natively runnable elf files may
> not be desirable.
>
> Signed-off-by: Noah Goldstein
> ---
> linux-user/main.c | 21 ++
> linux-user/syscall.c | 21 --
> linux-user/user-internals.h | 4 ++
> tests/tcg/multiarch/Makefile.target | 8 +++
> .../linux/linux-execve-qemu-children.c| 68 +++
> 5 files changed, 117 insertions(+), 5 deletions(-)
> create mode 100644 tests/tcg/multiarch/linux/linux-execve-qemu-children.c
>
> diff --git a/linux-user/main.c b/linux-user/main.c
> index 8143a0d4b0..5e3d41dc2b 100644
> --- a/linux-user/main.c
> +++ b/linux-user/main.c
> @@ -81,6 +81,10 @@ unsigned long mmap_min_addr;
> uintptr_t guest_base;
> bool have_guest_base;
>
> +bool qemu_dup_for_children;
> +int qemu_argc;
> +char **qemu_argv;
> +
> /*
> * Used to implement backwards-compatibility for the `-strace`, and
> * QEMU_STRACE options. Without this, the QEMU_LOG can be overwritten by
> @@ -451,6 +455,11 @@ static void handle_arg_jitdump(const char *arg)
> perf_enable_jitdump();
> }
>
> +static void handle_arg_qemu_children(const char *arg)
> +{
> +qemu_dup_for_children = true;
> +}
> +
> static QemuPluginList plugins = QTAILQ_HEAD_INITIALIZER(plugins);
>
> #ifdef CONFIG_PLUGIN
> @@ -526,6 +535,10 @@ static const struct qemu_argument arg_table[] = {
> "", "Generate a /tmp/perf-${pid}.map file for perf"},
> {"jitdump","QEMU_JITDUMP", false, handle_arg_jitdump,
> "", "Generate a jit-${pid}.dump file for perf"},
> +{"qemu-children",
> + "QEMU_CHILDREN",false, handle_arg_qemu_children,
> + "", "Run child processes (created with execve) with qemu "
> + "(as instantiated for the parent)"},
> {NULL, NULL, false, NULL, NULL, NULL}
> };
>
> @@ -729,6 +742,14 @@ int main(int argc, char **argv, char **envp)
>
> optind = parse_args(argc, argv);
>
> +if (qemu_dup_for_children) {
> +qemu_argc = optind;
> +qemu_argv = g_new0(char *, qemu_argc);
> +for (i = 0; i < optind; ++i) {
> +qemu_argv[i] = strdup(argv[i]);
> +}
> +}
> +
> qemu_set_log_filename_flags(last_log_filename,
> last_log_mask | (enable_strace * LOG_STRACE),
> &error_fatal);
> diff --git a/linux-user/syscall.c b/linux-user/syscall.c
> index 59b2080b98..96b105e9ce 100644
> --- a/linux-user/syscall.c
> +++ b/linux-user/syscall.c
> @@ -8550,13 +8550,14 @@ static int do_execv(CPUArchState *cpu_env, int dirfd,
> abi_long pathname, abi_long guest_argp,
> abi_long guest_envp, int flags, bool is_execveat)
> {
> -int ret;
> +int ret, argp_offset;
> char **argp, **envp;
> int argc, envc;
> abi_ulong gp;
> abi_ulong addr;
> char **q;
> void *p;
> +bool through_qemu = dirfd == AT_FDCWD && qemu_dup_for_children;
>
> argc = 0;
>
> @@ -8580,10 +8581,12 @@ static int do_execv(CPUArchState *cpu_env, int dirfd,
> envc++;
> }
>
> -argp = g_new0(char *, argc + 1);
> +argp_offset = through_qemu ? qemu_argc : 0;
> +argp = g_new0(char *, argc + argp_offset + 1);
> envp = g_new0(char *, envc + 1);
>
> -for (gp = guest_argp, q = argp; gp; gp += sizeof(abi_ulong), q++) {
> +for (gp = guest_argp, q = argp + argp_offset;
> + gp; gp += sizeof(abi_ulong), q++) {
> if (get_user_ual(addr, gp)) {
> goto execve_efault;
> }
> @@ -8628,9 +8631,16 @@ static int do_execv(CPUArchState *cpu_env, int dirfd,
> }
>
> const char *exe = p;
> -if (is_proc_myself(p, "exe")) {
> +if (through_qemu) {
> +int i;
> +for (i = 0; i < argp_offset; ++i) {
> +argp[i] = qemu_argv[i];
> +
linux-user: Add option to run `execve`d programs through QEMU
The new option '-qemu-children' makes it so that on `execve` the child
process will be launch by the same `qemu` executable that is currently
running along with its current commandline arguments.
The motivation for the change is to make it so that plugins running
through `qemu` can continue to run on children. Why not just
`binfmt`?: Plugins can be desirable regardless of system/architecture
emulation, and can sometimes be useful for elf files that can run
natively. Enabling `binfmt` for all natively runnable elf files may
not be desirable.
Signed-off-by: Noah Goldstein
---
linux-user/main.c | 21 ++
linux-user/syscall.c | 21 --
linux-user/user-internals.h | 4 ++
tests/tcg/multiarch/Makefile.target | 8 +++
.../linux/linux-execve-qemu-children.c| 68 +++
5 files changed, 117 insertions(+), 5 deletions(-)
create mode 100644 tests/tcg/multiarch/linux/linux-execve-qemu-children.c
diff --git a/linux-user/main.c b/linux-user/main.c
index 8143a0d4b0..5e3d41dc2b 100644
--- a/linux-user/main.c
+++ b/linux-user/main.c
@@ -81,6 +81,10 @@ unsigned long mmap_min_addr;
uintptr_t guest_base;
bool have_guest_base;
+bool qemu_dup_for_children;
+int qemu_argc;
+char **qemu_argv;
+
/*
* Used to implement backwards-compatibility for the `-strace`, and
* QEMU_STRACE options. Without this, the QEMU_LOG can be overwritten by
@@ -451,6 +455,11 @@ static void handle_arg_jitdump(const char *arg)
perf_enable_jitdump();
}
+static void handle_arg_qemu_children(const char *arg)
+{
+qemu_dup_for_children = true;
+}
+
static QemuPluginList plugins = QTAILQ_HEAD_INITIALIZER(plugins);
#ifdef CONFIG_PLUGIN
@@ -526,6 +535,10 @@ static const struct qemu_argument arg_table[] = {
"", "Generate a /tmp/perf-${pid}.map file for perf"},
{"jitdump","QEMU_JITDUMP", false, handle_arg_jitdump,
"", "Generate a jit-${pid}.dump file for perf"},
+{"qemu-children",
+ "QEMU_CHILDREN",false, handle_arg_qemu_children,
+ "", "Run child processes (created with execve) with qemu "
+ "(as instantiated for the parent)"},
{NULL, NULL, false, NULL, NULL, NULL}
};
@@ -729,6 +742,14 @@ int main(int argc, char **argv, char **envp)
optind = parse_args(argc, argv);
+if (qemu_dup_for_children) {
+qemu_argc = optind;
+qemu_argv = g_new0(char *, qemu_argc);
+for (i = 0; i < optind; ++i) {
+qemu_argv[i] = strdup(argv[i]);
+}
+}
+
qemu_set_log_filename_flags(last_log_filename,
last_log_mask | (enable_strace * LOG_STRACE),
&error_fatal);
diff --git a/linux-user/syscall.c b/linux-user/syscall.c
index 59b2080b98..96b105e9ce 100644
--- a/linux-user/syscall.c
+++ b/linux-user/syscall.c
@@ -8550,13 +8550,14 @@ static int do_execv(CPUArchState *cpu_env, int dirfd,
abi_long pathname, abi_long guest_argp,
abi_long guest_envp, int flags, bool is_execveat)
{
-int ret;
+int ret, argp_offset;
char **argp, **envp;
int argc, envc;
abi_ulong gp;
abi_ulong addr;
char **q;
void *p;
+bool through_qemu = dirfd == AT_FDCWD && qemu_dup_for_children;
argc = 0;
@@ -8580,10 +8581,12 @@ static int do_execv(CPUArchState *cpu_env, int dirfd,
envc++;
}
-argp = g_new0(char *, argc + 1);
+argp_offset = through_qemu ? qemu_argc : 0;
+argp = g_new0(char *, argc + argp_offset + 1);
envp = g_new0(char *, envc + 1);
-for (gp = guest_argp, q = argp; gp; gp += sizeof(abi_ulong), q++) {
+for (gp = guest_argp, q = argp + argp_offset;
+ gp; gp += sizeof(abi_ulong), q++) {
if (get_user_ual(addr, gp)) {
goto execve_efault;
}
@@ -8628,9 +8631,16 @@ static int do_execv(CPUArchState *cpu_env, int dirfd,
}
const char *exe = p;
-if (is_proc_myself(p, "exe")) {
+if (through_qemu) {
+int i;
+for (i = 0; i < argp_offset; ++i) {
+argp[i] = qemu_argv[i];
+}
+exe = qemu_argv[0];
+} else if (is_proc_myself(p, "exe")) {
exe = exec_path;
}
+
ret = is_execveat
? safe_execveat(dirfd, exe, argp, envp, flags)
: safe_execve(exe, argp, envp);
@@ -8644,7 +8654,8 @@ execve_efault:
ret = -TARGET_EFAULT;
execve_end:
-for (gp = guest_argp, q = argp; *q; gp += sizeof(abi_ulong), q++) {
+for (gp = guest_argp, q = argp + argp_offset;
+ *q; gp += sizeof(abi_ulong), q++) {
if (get_user_ual(addr, gp) || !addr) {
break;
}
diff --git a/linux-user/user-internals.h b/linux-user/u
Re: linux-user: Add option to run `execve`d programs through QEMU
On Tue, Nov 5, 2024 at 5:37 AM Richard Henderson
wrote:
>
> On 10/30/24 14:10, Noah Goldstein wrote:
> > The new option '-qemu-children' makes it so that on `execve` the child
> > process will be launch by the same `qemu` executable that is currently
> > running along with its current commandline arguments.
> >
> > The motivation for the change is to make it so that plugins running
> > through `qemu` can continue to run on children. Why not just
> > `binfmt`?: Plugins can be desirable regardless of system/architecture
> > emulation, and can sometimes be useful for elf files that can run
> > natively. Enabling `binfmt` for all natively runnable elf files may
> > not be desirable.
> >
> > Signed-off-by: Noah Goldstein
> > ---
> > linux-user/main.c | 21 ++
> > linux-user/syscall.c | 21 --
> > linux-user/user-internals.h | 4 ++
> > tests/tcg/multiarch/Makefile.target | 8 +++
> > .../linux/linux-execve-qemu-children.c| 68 +++
> > 5 files changed, 117 insertions(+), 5 deletions(-)
> > create mode 100644 tests/tcg/multiarch/linux/linux-execve-qemu-children.c
> >
> > diff --git a/linux-user/main.c b/linux-user/main.c
> > index 8143a0d4b0..5e3d41dc2b 100644
> > --- a/linux-user/main.c
> > +++ b/linux-user/main.c
> > @@ -81,6 +81,10 @@ unsigned long mmap_min_addr;
> > uintptr_t guest_base;
> > bool have_guest_base;
> >
> > +bool qemu_dup_for_children;
> > +int qemu_argc;
> > +char **qemu_argv;
> > +
> > /*
> >* Used to implement backwards-compatibility for the `-strace`, and
> >* QEMU_STRACE options. Without this, the QEMU_LOG can be overwritten by
> > @@ -451,6 +455,11 @@ static void handle_arg_jitdump(const char *arg)
> > perf_enable_jitdump();
> > }
> >
> > +static void handle_arg_qemu_children(const char *arg)
> > +{
> > +qemu_dup_for_children = true;
> > +}
> > +
> > static QemuPluginList plugins = QTAILQ_HEAD_INITIALIZER(plugins);
> >
> > #ifdef CONFIG_PLUGIN
> > @@ -526,6 +535,10 @@ static const struct qemu_argument arg_table[] = {
> >"", "Generate a /tmp/perf-${pid}.map file for perf"},
> > {"jitdump","QEMU_JITDUMP", false, handle_arg_jitdump,
> >"", "Generate a jit-${pid}.dump file for perf"},
> > +{"qemu-children",
> > + "QEMU_CHILDREN",false, handle_arg_qemu_children,
> > + "", "Run child processes (created with execve) with qemu "
> > + "(as instantiated for the parent)"},
> > {NULL, NULL, false, NULL, NULL, NULL}
> > };
> >
> > @@ -729,6 +742,14 @@ int main(int argc, char **argv, char **envp)
> >
> > optind = parse_args(argc, argv);
> >
> > +if (qemu_dup_for_children) {
> > +qemu_argc = optind;
> > +qemu_argv = g_new0(char *, qemu_argc);
> > +for (i = 0; i < optind; ++i) {
> > +qemu_argv[i] = strdup(argv[i]);
>
> g_strdup.
ack
>
> > +bool through_qemu = dirfd == AT_FDCWD && qemu_dup_for_children;
>
> Why is this limited to AT_FDCWD? Why not for execvat too?
>
We could, initially it was because AFAICT qemu doesn't support executing a
program relative to another dir, but it would be simple enough to just join
the relative program path and path dirfd points to.
Want me to add support?
> > @@ -8628,9 +8631,16 @@ static int do_execv(CPUArchState *cpu_env, int dirfd,
> > }
> >
> > const char *exe = p;
> > -if (is_proc_myself(p, "exe")) {
> > +if (through_qemu) {
> > +int i;
> > +for (i = 0; i < argp_offset; ++i) {
> > +argp[i] = qemu_argv[i];
> > +}
> > +exe = qemu_argv[0];
> > +} else if (is_proc_myself(p, "exe")) {
> > exe = exec_path;
> > }
> > +
>
> You still need to handle is_proc_myself, for the guest binary.
>
> I wonder if those two cases are related. Do we need to also add an argument
> so that we
> can pass the executable to the next qemu via file descriptor? I.e. execvat
> becomes
>
> f = openat()
> execv(qemu, "-execfd", f)
>
> and is_proc_myself uses execfd, which we already have open.
>
>
> r~
Re: linux-user: Add option to run `execve`d programs through QEMU
On Tue, Nov 5, 2024 at 5:48 PM Noah Goldstein wrote:
>
> On Tue, Nov 5, 2024 at 5:37 AM Richard Henderson
> wrote:
> >
> > On 10/30/24 14:10, Noah Goldstein wrote:
> > > The new option '-qemu-children' makes it so that on `execve` the child
> > > process will be launch by the same `qemu` executable that is currently
> > > running along with its current commandline arguments.
> > >
> > > The motivation for the change is to make it so that plugins running
> > > through `qemu` can continue to run on children. Why not just
> > > `binfmt`?: Plugins can be desirable regardless of system/architecture
> > > emulation, and can sometimes be useful for elf files that can run
> > > natively. Enabling `binfmt` for all natively runnable elf files may
> > > not be desirable.
> > >
> > > Signed-off-by: Noah Goldstein
> > > ---
> > > linux-user/main.c | 21 ++
> > > linux-user/syscall.c | 21 --
> > > linux-user/user-internals.h | 4 ++
> > > tests/tcg/multiarch/Makefile.target | 8 +++
> > > .../linux/linux-execve-qemu-children.c| 68 +++
> > > 5 files changed, 117 insertions(+), 5 deletions(-)
> > > create mode 100644
> > > tests/tcg/multiarch/linux/linux-execve-qemu-children.c
> > >
> > > diff --git a/linux-user/main.c b/linux-user/main.c
> > > index 8143a0d4b0..5e3d41dc2b 100644
> > > --- a/linux-user/main.c
> > > +++ b/linux-user/main.c
> > > @@ -81,6 +81,10 @@ unsigned long mmap_min_addr;
> > > uintptr_t guest_base;
> > > bool have_guest_base;
> > >
> > > +bool qemu_dup_for_children;
> > > +int qemu_argc;
> > > +char **qemu_argv;
> > > +
> > > /*
> > >* Used to implement backwards-compatibility for the `-strace`, and
> > >* QEMU_STRACE options. Without this, the QEMU_LOG can be overwritten by
> > > @@ -451,6 +455,11 @@ static void handle_arg_jitdump(const char *arg)
> > > perf_enable_jitdump();
> > > }
> > >
> > > +static void handle_arg_qemu_children(const char *arg)
> > > +{
> > > +qemu_dup_for_children = true;
> > > +}
> > > +
> > > static QemuPluginList plugins = QTAILQ_HEAD_INITIALIZER(plugins);
> > >
> > > #ifdef CONFIG_PLUGIN
> > > @@ -526,6 +535,10 @@ static const struct qemu_argument arg_table[] = {
> > >"", "Generate a /tmp/perf-${pid}.map file for perf"},
> > > {"jitdump","QEMU_JITDUMP", false, handle_arg_jitdump,
> > >"", "Generate a jit-${pid}.dump file for perf"},
> > > +{"qemu-children",
> > > + "QEMU_CHILDREN",false, handle_arg_qemu_children,
> > > + "", "Run child processes (created with execve) with qemu "
> > > + "(as instantiated for the parent)"},
> > > {NULL, NULL, false, NULL, NULL, NULL}
> > > };
> > >
> > > @@ -729,6 +742,14 @@ int main(int argc, char **argv, char **envp)
> > >
> > > optind = parse_args(argc, argv);
> > >
> > > +if (qemu_dup_for_children) {
> > > +qemu_argc = optind;
> > > +qemu_argv = g_new0(char *, qemu_argc);
> > > +for (i = 0; i < optind; ++i) {
> > > +qemu_argv[i] = strdup(argv[i]);
> >
> > g_strdup.
> ack
> >
> > > +bool through_qemu = dirfd == AT_FDCWD && qemu_dup_for_children;
> >
> > Why is this limited to AT_FDCWD? Why not for execvat too?
> >
>
> We could, initially it was because AFAICT qemu doesn't support executing a
> program relative to another dir, but it would be simple enough to just join
> the relative program path and path dirfd points to.
>
> Want me to add support?
> > > @@ -8628,9 +8631,16 @@ static int do_execv(CPUArchState *cpu_env, int
> > > dirfd,
> > > }
> > >
> > > const char *exe = p;
> > > -if (is_proc_myself(p, "exe")) {
> > > +if (through_qemu) {
> > > +int i;
> > > +for (i = 0; i < argp_offset; ++i) {
> > > +argp[i] = qemu_argv[i];
> > > +}
> > > +exe = qemu_argv[0];
> > > +} else if (is_proc_myself(p, "exe")) {
> > > exe = exec_path;
> > > }
> > > +
> >
> > You still need to handle is_proc_myself, for the guest binary.
Would this by handled by basically do:
```
if (is_proc_myself(p, "exe")) {
exe = exec_path;
if (through_qemu)
argp[argp_offset] = exec_path;
}
```
Or am I missing something?
> >
> > I wonder if those two cases are related. Do we need to also add an
> > argument so that we
> > can pass the executable to the next qemu via file descriptor? I.e. execvat
> > becomes
> >
> > f = openat()
> > execv(qemu, "-execfd", f)
> >
> > and is_proc_myself uses execfd, which we already have open.
How does passing a fd from one process to another work?
> >
> >
> > r~
Re: [PATCH v1] linux-user: Add option to run `execve`d programs through QEMU
On Tue, Sep 10, 2024 at 3:06 PM Noah Goldstein wrote:
>
> On Fri, Aug 30, 2024 at 3:37 PM Noah Goldstein
> wrote:
> >
> > On Fri, Aug 30, 2024 at 3:36 PM Noah Goldstein
> > wrote:
> > >
> > > The new option '-qemu-children' makes it so that on `execve` the child
> > > process will be launch by the same `qemu` executable that is currently
> > > running along with its current commandline arguments.
> > >
> > > The motivation for the change is to make it so that plugins running
> > > through `qemu` can continue to run on children. Why not just
> > > `binfmt`?: Plugins can be desirable regardless of system/architecture
> > > emulation, and can sometimes be useful for elf files that can run
> > > natively. Enabling `binfmt` for all natively runnable elf files may
> > > not be desirable.
> > >
> > > Signed-off-by: Noah Goldstein
> > > ---
> > > linux-user/main.c | 22 ++
> > > linux-user/syscall.c| 20 +++-
> > > linux-user/user-internals.h | 4
> > > 3 files changed, 41 insertions(+), 5 deletions(-)
> > >
> > > diff --git a/linux-user/main.c b/linux-user/main.c
> > > index 8143a0d4b0..dfb303a1f2 100644
> > > --- a/linux-user/main.c
> > > +++ b/linux-user/main.c
> > > @@ -81,6 +81,10 @@ unsigned long mmap_min_addr;
> > > uintptr_t guest_base;
> > > bool have_guest_base;
> > >
> > > +bool qemu_dup_for_children;
> > > +int qemu_argc;
> > > +char ** qemu_argv;
> > > +
> > > /*
> > > * Used to implement backwards-compatibility for the `-strace`, and
> > > * QEMU_STRACE options. Without this, the QEMU_LOG can be overwritten by
> > > @@ -451,6 +455,11 @@ static void handle_arg_jitdump(const char *arg)
> > > perf_enable_jitdump();
> > > }
> > >
> > > +static void handle_arg_qemu_children(const char *arg)
> > > +{
> > > +qemu_dup_for_children = true;
> > > +}
> > > +
> > > static QemuPluginList plugins = QTAILQ_HEAD_INITIALIZER(plugins);
> > >
> > > #ifdef CONFIG_PLUGIN
> > > @@ -526,6 +535,10 @@ static const struct qemu_argument arg_table[] = {
> > > "", "Generate a /tmp/perf-${pid}.map file for perf"},
> > > {"jitdump","QEMU_JITDUMP", false, handle_arg_jitdump,
> > > "", "Generate a jit-${pid}.dump file for perf"},
> > > +{"qemu-children",
> > > + "QEMU_CHILDREN",false, handle_arg_qemu_children,
> > > + "", "Run child processes (created with execve) with qemu "
> > > + "(as instantiated for the parent)"},
> > > {NULL, NULL, false, NULL, NULL, NULL}
> > > };
> > >
> > > @@ -729,6 +742,15 @@ int main(int argc, char **argv, char **envp)
> > >
> > > optind = parse_args(argc, argv);
> > >
> > > +if (qemu_dup_for_children) {
> > > +int i;
> > > +qemu_argc = optind;
> > > +qemu_argv = g_new0(char *, qemu_argc);
> > > +for (i = 0; i < optind; ++i) {
> > > +qemu_argv[i] = strdup(argv[i]);
> > > +}
> > > +}
> > > +
> > > qemu_set_log_filename_flags(last_log_filename,
> > > last_log_mask | (enable_strace *
> > > LOG_STRACE),
> > > &error_fatal);
> > > diff --git a/linux-user/syscall.c b/linux-user/syscall.c
> > > index 9d5415674d..732ef89054 100644
> > > --- a/linux-user/syscall.c
> > > +++ b/linux-user/syscall.c
> > > @@ -8459,13 +8459,14 @@ static int do_execv(CPUArchState *cpu_env, int
> > > dirfd,
> > > abi_long pathname, abi_long guest_argp,
> > > abi_long guest_envp, int flags, bool is_execveat)
> > > {
> > > -int ret;
> > > +int ret, argp_offset;
> > > char **argp, **envp;
> > > int argc, envc;
> > > abi_ulong gp;
> > > abi_ulong addr;
> > > char **q;
> > > void *p;
> > > +bool through_qemu = !is_execveat && qemu_dup_for_children;
> > >
> > I wasn't sure if this was feasible for `evecveat`. If
Re: [PATCH v1] linux-user: Add option to run `execve`d programs through QEMU
On Wed, Oct 2, 2024 at 9:53 AM Ilya Leoshkevich wrote: > > On Wed, 2024-10-02 at 09:44 -0500, Noah Goldstein wrote: > > On Wed, Oct 2, 2024 at 9:38 AM Ilya Leoshkevich > > wrote: > > > > > > On Wed, 2024-10-02 at 16:08 +0200, Laurent Vivier wrote: > > > > Le 02/10/2024 à 10:08, Ilya Leoshkevich a écrit : > > > > > On Fri, 2024-08-30 at 15:36 -0700, Noah Goldstein wrote: > > > > > > The new option '-qemu-children' makes it so that on `execve` > > > > > > the > > > > > > child > > > > > > process will be launch by the same `qemu` executable that is > > > > > > currently > > > > > > running along with its current commandline arguments. > > > > > > > > > > > > The motivation for the change is to make it so that plugins > > > > > > running > > > > > > through `qemu` can continue to run on children. Why not just > > > > > > `binfmt`?: Plugins can be desirable regardless of > > > > > > system/architecture > > > > > > emulation, and can sometimes be useful for elf files that can > > > > > > run > > > > > > natively. Enabling `binfmt` for all natively runnable elf > > > > > > files > > > > > > may > > > > > > not be desirable. > > > > > > > > > > Another reason to have this is that one may not have root > > > > > permissions > > > > > to configure binfmt-misc. > > > > > > > > A little note on that: binfmt_misc is now part of the user > > > > namespace > > > > (since linux v6.7), so you can > > > > configure binfmt_misc as a non root user in a given namepace. > > > > > > > > There is helper to use it with unshare from util-linux, you can > > > > do > > > > things like that: > > > > > > > >With 'F' flag, load the interpreter from the initial > > > > namespace: > > > > > > > > $ /bin/qemu-m68k-static --version > > > > qemu-m68k version 8.2.2 (qemu-8.2.2-1.fc40) > > > > Copyright (c) 2003-2023 Fabrice Bellard and the QEMU Project > > > > developers > > > > $ unshare --map-root-user --fork --pid > > > > --load-interp=":qemu- > > > > m68k:M::\\x7fELF\\x01\\x02\\x01\\x00\\x00\\x00\\x00\\x00\\x00\\x0 > > > > 0\\x > > > > 00\\x00\\x00\\x02\\x00\\x04:\\xff\\xff\\xff\\xff\\xff\\xff\\xfe\\ > > > > x00\ > > > > \xff\\xff\\xff\\xff\\xff\\xff\\xff\\xff\\xff\\xfe\\xff\\xff:/bin/ > > > > qemu > > > > -m68k-static:OCF" > > > > --root=chroot/m68k/sid > > > > # QEMU_VERSION= ls > > > > qemu-m68k version 8.2.2 (qemu-8.2.2-1.fc40) > > > > Copyright (c) 2003-2023 Fabrice Bellard and the QEMU Project > > > > developers > > > > # /qemu-m68k --version > > > > qemu-m68k version 8.0.50 (v8.0.0-340-gb1cff5e2da95) > > > > Copyright (c) 2003-2022 Fabrice Bellard and the QEMU Project > > > > developers > > > > > > > >Without 'F' flag, from inside the namespace: > > > > > > > > $ unshare --map-root-user --fork --pid > > > > --load-interp=":qemu- > > > > m68k:M::\\x7fELF\\x01\\x02\\x01\\x00\\x00\\x00\\x00\\x00\\x00\\x0 > > > > 0\\x > > > > 00\\x00\\x00\\x02\\x00\\x04:\\xff\\xff\\xff\\xff\\xff\\xff\\xfe\\ > > > > x00\ > > > > \xff\\xff\\xff\\xff\\xff\\xff\\xff\\xff\\xff\\xfe\\xff\\xff:/qemu > > > > - > > > > m68k:OC" > > > > --root=chroot/m68k/sid > > > > # QEMU_VERSION= ls > > > > qemu-m68k version 8.0.50 (v8.0.0-340-gb1cff5e2da95) > > > > Copyright (c) 2003-2022 Fabrice Bellard and the QEMU Project > > > > developers > > > > # /qemu-m68k --version > > > > qemu-m68k version 8.0.50 (v8.0.0-340-gb1cff5e2da95) > > > > Copyright (c) 2003-2022 Fabrice Bellard and the QEMU Project > > > > developers > > > > > > > > Thanks, > > > > Laurent > > > > > > > > > > Thanks for posting this, I wasn't aware of this feature and it > > > looks > > > really useful. > > > > > > IIUC it also resolves the main problem this patch is dealing with: > > > > I might misunderstand, but I don't think it does in the sense > > that it still might not be desirable to use the same qemu flags > > for the entire class of executables. > > > > I.e the original motivating case was wanting to attach > > some plugins to a process and its children and AFAICT > > binfmt still doesn't give that level of control. > > I think if you start a process in a user namespace, which has a > binfmt_misc handler for a certain class of binaries, then this handler > will affect only this process and its children, and not the rest of the > system. It won't also affect other binaries in the user namespace? > > > > Enabling `binfmt` for all natively runnable elf files may > > > not be desirable. >
Re: [PATCH v1] linux-user: Add option to run `execve`d programs through QEMU
On Wed, Oct 2, 2024 at 11:14 AM Ilya Leoshkevich wrote: > > On Wed, 2024-10-02 at 10:10 -0500, Noah Goldstein wrote: > > On Wed, Oct 2, 2024 at 9:53 AM Ilya Leoshkevich > > wrote: > > > > > > On Wed, 2024-10-02 at 09:44 -0500, Noah Goldstein wrote: > > > > On Wed, Oct 2, 2024 at 9:38 AM Ilya Leoshkevich > > > > > > > > wrote: > > > > > > > > > > On Wed, 2024-10-02 at 16:08 +0200, Laurent Vivier wrote: > > > > > > Le 02/10/2024 à 10:08, Ilya Leoshkevich a écrit : > > > > > > > On Fri, 2024-08-30 at 15:36 -0700, Noah Goldstein wrote: > > > > > > > > The new option '-qemu-children' makes it so that on > > > > > > > > `execve` > > > > > > > > the > > > > > > > > child > > > > > > > > process will be launch by the same `qemu` executable that > > > > > > > > is > > > > > > > > currently > > > > > > > > running along with its current commandline arguments. > > > > > > > > > > > > > > > > The motivation for the change is to make it so that > > > > > > > > plugins > > > > > > > > running > > > > > > > > through `qemu` can continue to run on children. Why not > > > > > > > > just > > > > > > > > `binfmt`?: Plugins can be desirable regardless of > > > > > > > > system/architecture > > > > > > > > emulation, and can sometimes be useful for elf files that > > > > > > > > can > > > > > > > > run > > > > > > > > natively. Enabling `binfmt` for all natively runnable elf > > > > > > > > files > > > > > > > > may > > > > > > > > not be desirable. > > > > > > > > > > > > > > Another reason to have this is that one may not have root > > > > > > > permissions > > > > > > > to configure binfmt-misc. > > > > > > > > > > > > A little note on that: binfmt_misc is now part of the user > > > > > > namespace > > > > > > (since linux v6.7), so you can > > > > > > configure binfmt_misc as a non root user in a given namepace. > > > > > > > > > > > > There is helper to use it with unshare from util-linux, you > > > > > > can > > > > > > do > > > > > > things like that: > > > > > > > > > > > >With 'F' flag, load the interpreter from the initial > > > > > > namespace: > > > > > > > > > > > > $ /bin/qemu-m68k-static --version > > > > > > qemu-m68k version 8.2.2 (qemu-8.2.2-1.fc40) > > > > > > Copyright (c) 2003-2023 Fabrice Bellard and the QEMU > > > > > > Project > > > > > > developers > > > > > > $ unshare --map-root-user --fork --pid > > > > > > --load-interp=":qemu- > > > > > > m68k:M::\\x7fELF\\x01\\x02\\x01\\x00\\x00\\x00\\x00\\x00\\x00 > > > > > > \\x0 > > > > > > 0\\x > > > > > > 00\\x00\\x00\\x02\\x00\\x04:\\xff\\xff\\xff\\xff\\xff\\xff\\x > > > > > > fe\\ > > > > > > x00\ > > > > > > \xff\\xff\\xff\\xff\\xff\\xff\\xff\\xff\\xff\\xfe\\xff\\xff:/ > > > > > > bin/ > > > > > > qemu > > > > > > -m68k-static:OCF" > > > > > > --root=chroot/m68k/sid > > > > > > # QEMU_VERSION= ls > > > > > > qemu-m68k version 8.2.2 (qemu-8.2.2-1.fc40) > > > > > > Copyright (c) 2003-2023 Fabrice Bellard and the QEMU > > > > > > Project > > > > > > developers > > > > > > # /qemu-m68k --version > > > > > > qemu-m68k version 8.0.50 (v8.0.0-340-gb1cff5e2da95) > > > > > > Copyright (c) 2003-2022 Fabrice Bellard and the QEMU > > > > > > Project > > > > > > developers > > > > > > > > > > > >Without 'F' flag, from inside the namespace: > > > > > > > > > > > > $ unshare --map-root-us
Re: [PATCH v1] linux-user: Add option to run `execve`d programs through QEMU
On Wed, Oct 2, 2024 at 11:35 AM Ilya Leoshkevich wrote: > > On Wed, 2024-10-02 at 11:24 -0500, Noah Goldstein wrote: > > On Wed, Oct 2, 2024 at 11:14 AM Ilya Leoshkevich > > wrote: > > > > > > On Wed, 2024-10-02 at 10:10 -0500, Noah Goldstein wrote: > > > > On Wed, Oct 2, 2024 at 9:53 AM Ilya Leoshkevich > > > > > > > > wrote: > > > > > > > > > > On Wed, 2024-10-02 at 09:44 -0500, Noah Goldstein wrote: > > > > > > On Wed, Oct 2, 2024 at 9:38 AM Ilya Leoshkevich > > > > > > > > > > > > wrote: > > > > > > > > > > > > > > On Wed, 2024-10-02 at 16:08 +0200, Laurent Vivier wrote: > > > > > > > > Le 02/10/2024 à 10:08, Ilya Leoshkevich a écrit : > > > > > > > > > On Fri, 2024-08-30 at 15:36 -0700, Noah Goldstein > > > > > > > > > wrote: > > > > > > > > > > The new option '-qemu-children' makes it so that on > > > > > > > > > > `execve` > > > > > > > > > > the > > > > > > > > > > child > > > > > > > > > > process will be launch by the same `qemu` executable > > > > > > > > > > that > > > > > > > > > > is > > > > > > > > > > currently > > > > > > > > > > running along with its current commandline arguments. > > > > > > > > > > > > > > > > > > > > The motivation for the change is to make it so that > > > > > > > > > > plugins > > > > > > > > > > running > > > > > > > > > > through `qemu` can continue to run on children. Why > > > > > > > > > > not > > > > > > > > > > just > > > > > > > > > > `binfmt`?: Plugins can be desirable regardless of > > > > > > > > > > system/architecture > > > > > > > > > > emulation, and can sometimes be useful for elf files > > > > > > > > > > that > > > > > > > > > > can > > > > > > > > > > run > > > > > > > > > > natively. Enabling `binfmt` for all natively runnable > > > > > > > > > > elf > > > > > > > > > > files > > > > > > > > > > may > > > > > > > > > > not be desirable. > > > > > > > > > > > > > > > > > > Another reason to have this is that one may not have > > > > > > > > > root > > > > > > > > > permissions > > > > > > > > > to configure binfmt-misc. > > > > > > > > > > > > > > > > A little note on that: binfmt_misc is now part of the > > > > > > > > user > > > > > > > > namespace > > > > > > > > (since linux v6.7), so you can > > > > > > > > configure binfmt_misc as a non root user in a given > > > > > > > > namepace. > > > > > > > > > > > > > > > > There is helper to use it with unshare from util-linux, > > > > > > > > you > > > > > > > > can > > > > > > > > do > > > > > > > > things like that: > > > > > > > > > > > > > > > >With 'F' flag, load the interpreter from the initial > > > > > > > > namespace: > > > > > > > > > > > > > > > > $ /bin/qemu-m68k-static --version > > > > > > > > qemu-m68k version 8.2.2 (qemu-8.2.2-1.fc40) > > > > > > > > Copyright (c) 2003-2023 Fabrice Bellard and the QEMU > > > > > > > > Project > > > > > > > > developers > > > > > > > > $ unshare --map-root-user --fork --pid > > > > > > > > --load-interp=":qemu- > > > > > > > > m68k:M::\\x7fELF\\x01\\x02\\x01\\x00\\x00\\x00\\x00\\x00\ > > > > > > > > \x00 > > > > > > > > \\x0 > > > > > > > &g
Re: [PATCH v1] linux-user: Add option to run `execve`d programs through QEMU
On Wed, Oct 2, 2024 at 11:39 AM Ilya Leoshkevich wrote: > > On Wed, 2024-10-02 at 09:05 -0500, Noah Goldstein wrote: > > On Wed, Oct 2, 2024 at 3:08 AM Ilya Leoshkevich > > wrote: > > > > > > On Fri, 2024-08-30 at 15:36 -0700, Noah Goldstein wrote: > > > > The new option '-qemu-children' makes it so that on `execve` the > > > > child > > > > process will be launch by the same `qemu` executable that is > > > > currently > > > > running along with its current commandline arguments. > > > > > > > > The motivation for the change is to make it so that plugins > > > > running > > > > through `qemu` can continue to run on children. Why not just > > > > `binfmt`?: Plugins can be desirable regardless of > > > > system/architecture > > > > emulation, and can sometimes be useful for elf files that can run > > > > natively. Enabling `binfmt` for all natively runnable elf files > > > > may > > > > not be desirable. > > > > > > Another reason to have this is that one may not have root > > > permissions > > > to configure binfmt-misc. > > > > > +1 > > > > > There was a similar patch posted to the mailing list some years > > > back, > > > which I used to cherry-pick when I needed this. I'm not sure what > > > happened to that discussion though. > > > > Yes(ish): > > https://patchwork.ozlabs.org/project/qemu-devel/patch/1455515507-26877-1-git-send-email-petros...@resin.io/ > > Thanks for finding this! Don't we need the shebang handling here as > well? > I don't think so. In this case we aren't making it so execve can point to some arbitrary impl, just that we propagate the current running qemu env. > Laurent, do you per chance know why was it not accepted back > then?Unfortunately I cannot find any discussion associated with v3 or > v4 > [1]. There were some concerns regarding v1 [2], but from what I can see > they all were addressed. > > [1] > https://patchew.org/QEMU/20200730160106.16613-1-rj.bcje...@gmail.com/ > [2] > https://patchwork.kernel.org/project/qemu-devel/patch/1453091602-21843-1-git-send-email-petros...@gmail.com/
Re: [PATCH v1] linux-user: Add option to run `execve`d programs through QEMU
On Wed, Oct 2, 2024 at 9:38 AM Ilya Leoshkevich wrote: > > On Wed, 2024-10-02 at 16:08 +0200, Laurent Vivier wrote: > > Le 02/10/2024 à 10:08, Ilya Leoshkevich a écrit : > > > On Fri, 2024-08-30 at 15:36 -0700, Noah Goldstein wrote: > > > > The new option '-qemu-children' makes it so that on `execve` the > > > > child > > > > process will be launch by the same `qemu` executable that is > > > > currently > > > > running along with its current commandline arguments. > > > > > > > > The motivation for the change is to make it so that plugins > > > > running > > > > through `qemu` can continue to run on children. Why not just > > > > `binfmt`?: Plugins can be desirable regardless of > > > > system/architecture > > > > emulation, and can sometimes be useful for elf files that can run > > > > natively. Enabling `binfmt` for all natively runnable elf files > > > > may > > > > not be desirable. > > > > > > Another reason to have this is that one may not have root > > > permissions > > > to configure binfmt-misc. > > > > A little note on that: binfmt_misc is now part of the user namespace > > (since linux v6.7), so you can > > configure binfmt_misc as a non root user in a given namepace. > > > > There is helper to use it with unshare from util-linux, you can do > > things like that: > > > >With 'F' flag, load the interpreter from the initial namespace: > > > > $ /bin/qemu-m68k-static --version > > qemu-m68k version 8.2.2 (qemu-8.2.2-1.fc40) > > Copyright (c) 2003-2023 Fabrice Bellard and the QEMU Project > > developers > > $ unshare --map-root-user --fork --pid > > --load-interp=":qemu- > > m68k:M::\\x7fELF\\x01\\x02\\x01\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x > > 00\\x00\\x00\\x02\\x00\\x04:\\xff\\xff\\xff\\xff\\xff\\xff\\xfe\\x00\ > > \xff\\xff\\xff\\xff\\xff\\xff\\xff\\xff\\xff\\xfe\\xff\\xff:/bin/qemu > > -m68k-static:OCF" > > --root=chroot/m68k/sid > > # QEMU_VERSION= ls > > qemu-m68k version 8.2.2 (qemu-8.2.2-1.fc40) > > Copyright (c) 2003-2023 Fabrice Bellard and the QEMU Project > > developers > > # /qemu-m68k --version > > qemu-m68k version 8.0.50 (v8.0.0-340-gb1cff5e2da95) > > Copyright (c) 2003-2022 Fabrice Bellard and the QEMU Project > > developers > > > >Without 'F' flag, from inside the namespace: > > > > $ unshare --map-root-user --fork --pid > > --load-interp=":qemu- > > m68k:M::\\x7fELF\\x01\\x02\\x01\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x > > 00\\x00\\x00\\x02\\x00\\x04:\\xff\\xff\\xff\\xff\\xff\\xff\\xfe\\x00\ > > \xff\\xff\\xff\\xff\\xff\\xff\\xff\\xff\\xff\\xfe\\xff\\xff:/qemu- > > m68k:OC" > > --root=chroot/m68k/sid > > # QEMU_VERSION= ls > > qemu-m68k version 8.0.50 (v8.0.0-340-gb1cff5e2da95) > > Copyright (c) 2003-2022 Fabrice Bellard and the QEMU Project > > developers > > # /qemu-m68k --version > > qemu-m68k version 8.0.50 (v8.0.0-340-gb1cff5e2da95) > > Copyright (c) 2003-2022 Fabrice Bellard and the QEMU Project > > developers > > > > Thanks, > > Laurent > > > > Thanks for posting this, I wasn't aware of this feature and it looks > really useful. > > IIUC it also resolves the main problem this patch is dealing with: I might misunderstand, but I don't think it does in the sense that it still might not be desirable to use the same qemu flags for the entire class of executables. I.e the original motivating case was wanting to attach some plugins to a process and its children and AFAICT binfmt still doesn't give that level of control. > > Enabling `binfmt` for all natively runnable elf files may > not be desirable.
[PATCH v2] linux-user: Add option to run `execve`d programs through QEMU
The new option '-qemu-children' makes it so that on `execve` the child
process will be launch by the same `qemu` executable that is currently
running along with its current commandline arguments.
The motivation for the change is to make it so that plugins running
through `qemu` can continue to run on children. Why not just
`binfmt`?: Plugins can be desirable regardless of system/architecture
emulation, and can sometimes be useful for elf files that can run
natively. Enabling `binfmt` for all natively runnable elf files may
not be desirable.
Signed-off-by: Noah Goldstein
---
linux-user/main.c | 21 +
linux-user/syscall.c| 21 -
linux-user/user-internals.h | 4
3 files changed, 41 insertions(+), 5 deletions(-)
diff --git a/linux-user/main.c b/linux-user/main.c
index 8143a0d4b0..5e3d41dc2b 100644
--- a/linux-user/main.c
+++ b/linux-user/main.c
@@ -81,6 +81,10 @@ unsigned long mmap_min_addr;
uintptr_t guest_base;
bool have_guest_base;
+bool qemu_dup_for_children;
+int qemu_argc;
+char **qemu_argv;
+
/*
* Used to implement backwards-compatibility for the `-strace`, and
* QEMU_STRACE options. Without this, the QEMU_LOG can be overwritten by
@@ -451,6 +455,11 @@ static void handle_arg_jitdump(const char *arg)
perf_enable_jitdump();
}
+static void handle_arg_qemu_children(const char *arg)
+{
+qemu_dup_for_children = true;
+}
+
static QemuPluginList plugins = QTAILQ_HEAD_INITIALIZER(plugins);
#ifdef CONFIG_PLUGIN
@@ -526,6 +535,10 @@ static const struct qemu_argument arg_table[] = {
"", "Generate a /tmp/perf-${pid}.map file for perf"},
{"jitdump","QEMU_JITDUMP", false, handle_arg_jitdump,
"", "Generate a jit-${pid}.dump file for perf"},
+{"qemu-children",
+ "QEMU_CHILDREN",false, handle_arg_qemu_children,
+ "", "Run child processes (created with execve) with qemu "
+ "(as instantiated for the parent)"},
{NULL, NULL, false, NULL, NULL, NULL}
};
@@ -729,6 +742,14 @@ int main(int argc, char **argv, char **envp)
optind = parse_args(argc, argv);
+if (qemu_dup_for_children) {
+qemu_argc = optind;
+qemu_argv = g_new0(char *, qemu_argc);
+for (i = 0; i < optind; ++i) {
+qemu_argv[i] = strdup(argv[i]);
+}
+}
+
qemu_set_log_filename_flags(last_log_filename,
last_log_mask | (enable_strace * LOG_STRACE),
&error_fatal);
diff --git a/linux-user/syscall.c b/linux-user/syscall.c
index a666986189..79019c0db0 100644
--- a/linux-user/syscall.c
+++ b/linux-user/syscall.c
@@ -8457,13 +8457,14 @@ static int do_execv(CPUArchState *cpu_env, int dirfd,
abi_long pathname, abi_long guest_argp,
abi_long guest_envp, int flags, bool is_execveat)
{
-int ret;
+int ret, argp_offset;
char **argp, **envp;
int argc, envc;
abi_ulong gp;
abi_ulong addr;
char **q;
void *p;
+bool through_qemu = dirfd == AT_FDCWD && qemu_dup_for_children;
argc = 0;
@@ -8487,10 +8488,12 @@ static int do_execv(CPUArchState *cpu_env, int dirfd,
envc++;
}
-argp = g_new0(char *, argc + 1);
+argp_offset = through_qemu ? qemu_argc : 0;
+argp = g_new0(char *, argc + argp_offset + 1);
envp = g_new0(char *, envc + 1);
-for (gp = guest_argp, q = argp; gp; gp += sizeof(abi_ulong), q++) {
+for (gp = guest_argp, q = argp + argp_offset;
+ gp; gp += sizeof(abi_ulong), q++) {
if (get_user_ual(addr, gp)) {
goto execve_efault;
}
@@ -8535,9 +8538,16 @@ static int do_execv(CPUArchState *cpu_env, int dirfd,
}
const char *exe = p;
-if (is_proc_myself(p, "exe")) {
+if (through_qemu) {
+int i;
+for (i = 0; i < argp_offset; ++i) {
+argp[i] = qemu_argv[i];
+}
+exe = qemu_argv[0];
+} else if (is_proc_myself(p, "exe")) {
exe = exec_path;
}
+
ret = is_execveat
? safe_execveat(dirfd, exe, argp, envp, flags)
: safe_execve(exe, argp, envp);
@@ -8551,7 +8561,8 @@ execve_efault:
ret = -TARGET_EFAULT;
execve_end:
-for (gp = guest_argp, q = argp; *q; gp += sizeof(abi_ulong), q++) {
+for (gp = guest_argp, q = argp + argp_offset;
+ *q; gp += sizeof(abi_ulong), q++) {
if (get_user_ual(addr, gp) || !addr) {
break;
}
diff --git a/linux-user/user-internals.h b/linux-user/user-internals.h
index 5c7f173ceb..a4615eee54 100644
--- a/linux-user/user-internals.h
+++ b/linux-user/user-internals.h
@@ -30,6 +30,10 @@ void stop_all_tasks(void);
extern const char *qemu_uname_release;
extern unsigned
Re: [PATCH v1] linux-user: Add option to run `execve`d programs through QEMU
On Wed, Oct 2, 2024 at 3:08 AM Ilya Leoshkevich wrote:
>
> On Fri, 2024-08-30 at 15:36 -0700, Noah Goldstein wrote:
> > The new option '-qemu-children' makes it so that on `execve` the
> > child
> > process will be launch by the same `qemu` executable that is
> > currently
> > running along with its current commandline arguments.
> >
> > The motivation for the change is to make it so that plugins running
> > through `qemu` can continue to run on children. Why not just
> > `binfmt`?: Plugins can be desirable regardless of system/architecture
> > emulation, and can sometimes be useful for elf files that can run
> > natively. Enabling `binfmt` for all natively runnable elf files may
> > not be desirable.
>
> Another reason to have this is that one may not have root permissions
> to configure binfmt-misc.
>
+1
> There was a similar patch posted to the mailing list some years back,
> which I used to cherry-pick when I needed this. I'm not sure what
> happened to that discussion though.
Yes(ish):
https://patchwork.ozlabs.org/project/qemu-devel/patch/1455515507-26877-1-git-send-email-petros...@resin.io/
>
> > Signed-off-by: Noah Goldstein
> > ---
> > linux-user/main.c | 22 ++
> > linux-user/syscall.c| 20 +++-
> > linux-user/user-internals.h | 4
> > 3 files changed, 41 insertions(+), 5 deletions(-)
> >
> > diff --git a/linux-user/main.c b/linux-user/main.c
> > index 8143a0d4b0..dfb303a1f2 100644
> > --- a/linux-user/main.c
> > +++ b/linux-user/main.c
> > @@ -81,6 +81,10 @@ unsigned long mmap_min_addr;
> > uintptr_t guest_base;
> > bool have_guest_base;
> >
> > +bool qemu_dup_for_children;
> > +int qemu_argc;
> > +char ** qemu_argv;
>
> Style: ** belong to the variable name.
> There are a couple other issues, please check the output of
>
> git format-patch -1 --stdout | ./scripts/checkpatch.pl -
>
Will Do.
> > +
> > /*
> > * Used to implement backwards-compatibility for the `-strace`, and
> > * QEMU_STRACE options. Without this, the QEMU_LOG can be
> > overwritten by
> > @@ -451,6 +455,11 @@ static void handle_arg_jitdump(const char *arg)
> > perf_enable_jitdump();
> > }
> >
> > +static void handle_arg_qemu_children(const char *arg)
> > +{
> > +qemu_dup_for_children = true;
> > +}
> > +
> > static QemuPluginList plugins = QTAILQ_HEAD_INITIALIZER(plugins);
> >
> > #ifdef CONFIG_PLUGIN
> > @@ -526,6 +535,10 @@ static const struct qemu_argument arg_table[] =
> > {
> > "", "Generate a /tmp/perf-${pid}.map file for perf"},
> > {"jitdump","QEMU_JITDUMP", false, handle_arg_jitdump,
> > "", "Generate a jit-${pid}.dump file for perf"},
> > +{"qemu-children",
> > + "QEMU_CHILDREN",false,
> > handle_arg_qemu_children,
> > + "", "Run child processes (created with execve) with
> > qemu "
> > + "(as instantiated for the parent)"},
> > {NULL, NULL, false, NULL, NULL, NULL}
> > };
> >
> > @@ -729,6 +742,15 @@ int main(int argc, char **argv, char **envp)
> >
> > optind = parse_args(argc, argv);
> >
> > +if (qemu_dup_for_children) {
> > +int i;
>
> I get the following build error:
>
> qemu/linux-user/main.c: In function ‘main’:
> qemu/linux-user/main.c:746:13: error: declaration of ‘i’ shadows a
> previous local [-Werror=shadow=compatible-local]
> 746 | int i;
> | ^
> qemu/linux-user/main.c:699:9: note: shadowed declaration is here
> 699 | int i;
> | ^
>
> I don't think this variable is needed at all.
>
Bah sorry.
> > +qemu_argc = optind;
> > +qemu_argv = g_new0(char *, qemu_argc);
> > +for (i = 0; i < optind; ++i) {
> > +qemu_argv[i] = strdup(argv[i]);
> > +}
> > +}
> > +
> > qemu_set_log_filename_flags(last_log_filename,
> > last_log_mask | (enable_strace *
> > LOG_STRACE),
> > &error_fatal);
> > diff --git a/linux-user/syscall.c b/linux-user/syscall.c
> > index 9d5415674d..732ef89054 100644
> > --- a/linux-user/syscall.c
> > +++ b/linux-user/syscall.c
> > @@ -8459,13 +8459,14 @@ static int do_execv(CPUArchState *cpu_env,
> > int
Re: linux-user: Add option to run `execve`d programs through QEMU
On Wed, Nov 6, 2024 at 3:30 PM Noah Goldstein wrote:
>
> On Wed, Nov 6, 2024 at 3:10 PM Richard Henderson
> wrote:
> >
> > On 11/6/24 18:13, Noah Goldstein wrote:
> > > Question about impl regarding handling of `-execfd` with/without a
> > > program name.
> > >
> > > 1) `-execfd` + program name ie: `qemu -execfd ls -a`.
> > > 2) `-execfd` without program name i.e: `qemu -execfd -a`.
> > >
> > > Do you want to allow both of these? If you want to allow (1), what should
> > > we use for `argv[0]`/`exec_path`. The program pass ("ls") or
> > > `readlink()`?
> >
> > The canonical response is, examine the kernel source.
> > We're not implementing this in a vacuum, you're replicating execveat(2).
> >
> > I suspect the answer is (1), to be compared with
> >
> > syscall(__NR_execveat, some_fd, "", &["ls", "-a"], env, AT_EMPTY_PATH);
>
> Err, I think the reference for '-execfd' is `fexecve`:
> https://man7.org/linux/man-pages/man3/fexecve.3.html
>
> Which doesn't take a path. So I guess we just interpret the "ls" as
> argv[0] but not
> as "exec_path".
One more point, what should the behavior be if we have
AT_EXECFD from binfmt-misc?
> >
> >
> > r~
Re: linux-user: Add option to run `execve`d programs through QEMU
On Wed, Nov 6, 2024 at 11:53 AM Noah Goldstein wrote:
>
> On Wed, Nov 6, 2024 at 11:26 AM Richard Henderson
> wrote:
> >
> > On 11/6/24 17:03, Noah Goldstein wrote:
> > > On Wed, Nov 6, 2024 at 3:38 AM Richard Henderson
> > > wrote:
> > >>
> > >> On 11/5/24 23:54, Noah Goldstein wrote:
> > >>>>> You still need to handle is_proc_myself, for the guest binary.
> > >>>
> > >>> Would this by handled by basically do:
> > >>>
> > >>> ```
> > >>> if (is_proc_myself(p, "exe")) {
> > >>> exe = exec_path;
> > >>> if (through_qemu)
> > >>> argp[argp_offset] = exec_path;
> > >>> }
> > >>> ```
> > >>> Or am I missing something?
> > >>
> > >> Something like that, yes.
> > >>
> > >>>>> I wonder if those two cases are related. Do we need to also add an
> > >>>>> argument so that we
> > >>>>> can pass the executable to the next qemu via file descriptor? I.e.
> > >>>>> execvat becomes
> > >>>>>
> > >>>>>f = openat()
> > >>>>>execv(qemu, "-execfd", f)
> > >>>>>
> > >>>>> and is_proc_myself uses execfd, which we already have open.
> > >>>
> > >>> How does passing a fd from one process to another work?
> > >> As long as the fd is not marked O_CLOEXEC, it stays open in the new
> > >> process. Providing
> > >> the number via command-line, or whatever, is sufficient for the new
> > >> process to know what
> > >> is going on.
> > >
> > > Err I guess I was thinking its a bit weird having an option that is
> > > only really applicable
> > > if qemu is a child process. I.e the `-execfd` argument is not usable
> > > from commandline.
> >
> > qemu-foo -execfd 3 3< /some/file
> >
> > Or perhaps opened via other tooling.
> >
> > >> I now realize this is necessary for the AT_EMPTY_PATH flag, where we
> > >> only have the file
> > >> descriptor.
> > >
> > > We could also do something along the lines of:
> > >
> > > ```
> > > fd = openat(dirfd, exe);
> > > char new_exe[PATH_MAX];
> > > char fd_path[PATH_MAX];
> > > sprintf(fd_path, "/proc/self/fd/%d", fd);
> > > readlink(fd_path, new_exe, PATH_MAX);
> >
> > Reading the link doesn't always work.
> > Reading or passing the link means AT_SYMLINK_NOFOLLOW isn't honored.
>
> Okay, fair enough, I will get started on adding `-execfd`
Question about impl regarding handling of `-execfd` with/without a program name.
1) `-execfd` + program name ie: `qemu -execfd ls -a`.
2) `-execfd` without program name i.e: `qemu -execfd -a`.
Do you want to allow both of these? If you want to allow (1), what should
we use for `argv[0]`/`exec_path`. The program pass ("ls") or
`readlink()`?
Re: linux-user: Add option to run `execve`d programs through QEMU
On Wed, Nov 6, 2024 at 3:10 PM Richard Henderson
wrote:
>
> On 11/6/24 18:13, Noah Goldstein wrote:
> > Question about impl regarding handling of `-execfd` with/without a program
> > name.
> >
> > 1) `-execfd` + program name ie: `qemu -execfd ls -a`.
> > 2) `-execfd` without program name i.e: `qemu -execfd -a`.
> >
> > Do you want to allow both of these? If you want to allow (1), what should
> > we use for `argv[0]`/`exec_path`. The program pass ("ls") or
> > `readlink()`?
>
> The canonical response is, examine the kernel source.
> We're not implementing this in a vacuum, you're replicating execveat(2).
>
> I suspect the answer is (1), to be compared with
>
> syscall(__NR_execveat, some_fd, "", &["ls", "-a"], env, AT_EMPTY_PATH);
Err, I think the reference for '-execfd' is `fexecve`:
https://man7.org/linux/man-pages/man3/fexecve.3.html
Which doesn't take a path. So I guess we just interpret the "ls" as
argv[0] but not
as "exec_path".
>
>
> r~
Re: linux-user: Add option to run `execve`d programs through QEMU
On Wed, Nov 6, 2024 at 3:38 AM Richard Henderson
wrote:
>
> On 11/5/24 23:54, Noah Goldstein wrote:
> >>> You still need to handle is_proc_myself, for the guest binary.
> >
> > Would this by handled by basically do:
> >
> > ```
> > if (is_proc_myself(p, "exe")) {
> > exe = exec_path;
> > if (through_qemu)
> > argp[argp_offset] = exec_path;
> > }
> > ```
> > Or am I missing something?
>
> Something like that, yes.
>
> >>> I wonder if those two cases are related. Do we need to also add an
> >>> argument so that we
> >>> can pass the executable to the next qemu via file descriptor? I.e.
> >>> execvat becomes
> >>>
> >>> f = openat()
> >>> execv(qemu, "-execfd", f)
> >>>
> >>> and is_proc_myself uses execfd, which we already have open.
> >
> > How does passing a fd from one process to another work?
> As long as the fd is not marked O_CLOEXEC, it stays open in the new process.
> Providing
> the number via command-line, or whatever, is sufficient for the new process
> to know what
> is going on.
Err I guess I was thinking its a bit weird having an option that is
only really applicable
if qemu is a child process. I.e the `-execfd` argument is not usable
from commandline.
>
> I now realize this is necessary for the AT_EMPTY_PATH flag, where we only
> have the file
> descriptor.
We could also do something along the lines of:
```
fd = openat(dirfd, exe);
char new_exe[PATH_MAX];
char fd_path[PATH_MAX];
sprintf(fd_path, "/proc/self/fd/%d", fd);
readlink(fd_path, new_exe, PATH_MAX);
exe = new_exe;
```
>
>
> r~
Re: linux-user: Add option to run `execve`d programs through QEMU
On Wed, Nov 6, 2024 at 11:26 AM Richard Henderson
wrote:
>
> On 11/6/24 17:03, Noah Goldstein wrote:
> > On Wed, Nov 6, 2024 at 3:38 AM Richard Henderson
> > wrote:
> >>
> >> On 11/5/24 23:54, Noah Goldstein wrote:
> >>>>> You still need to handle is_proc_myself, for the guest binary.
> >>>
> >>> Would this by handled by basically do:
> >>>
> >>> ```
> >>> if (is_proc_myself(p, "exe")) {
> >>> exe = exec_path;
> >>> if (through_qemu)
> >>> argp[argp_offset] = exec_path;
> >>> }
> >>> ```
> >>> Or am I missing something?
> >>
> >> Something like that, yes.
> >>
> >>>>> I wonder if those two cases are related. Do we need to also add an
> >>>>> argument so that we
> >>>>> can pass the executable to the next qemu via file descriptor? I.e.
> >>>>> execvat becomes
> >>>>>
> >>>>>f = openat()
> >>>>>execv(qemu, "-execfd", f)
> >>>>>
> >>>>> and is_proc_myself uses execfd, which we already have open.
> >>>
> >>> How does passing a fd from one process to another work?
> >> As long as the fd is not marked O_CLOEXEC, it stays open in the new
> >> process. Providing
> >> the number via command-line, or whatever, is sufficient for the new
> >> process to know what
> >> is going on.
> >
> > Err I guess I was thinking its a bit weird having an option that is
> > only really applicable
> > if qemu is a child process. I.e the `-execfd` argument is not usable
> > from commandline.
>
> qemu-foo -execfd 3 3< /some/file
>
> Or perhaps opened via other tooling.
>
> >> I now realize this is necessary for the AT_EMPTY_PATH flag, where we only
> >> have the file
> >> descriptor.
> >
> > We could also do something along the lines of:
> >
> > ```
> > fd = openat(dirfd, exe);
> > char new_exe[PATH_MAX];
> > char fd_path[PATH_MAX];
> > sprintf(fd_path, "/proc/self/fd/%d", fd);
> > readlink(fd_path, new_exe, PATH_MAX);
>
> Reading the link doesn't always work.
> Reading or passing the link means AT_SYMLINK_NOFOLLOW isn't honored.
Okay, fair enough, I will get started on adding `-execfd`
>
>
> r~
