um: Switch to the pthread-based helper in sigio workaround

The write_sigio thread and UML kernel thread share the same errno,
which can lead to conflicts when both call syscalls concurrently.
Switch to the pthread-based helper to address this issue.

Signed-off-by: Tiwei Bie <tiwei.btw@antgroup.com>
Link: https://patch.msgid.link/20250319135523.97050-4-tiwei.btw@antgroup.com
Signed-off-by: Johannes Berg <johannes.berg@intel.com>

diff --git a/arch/um/os-Linux/sigio.c b/arch/um/os-Linux/sigio.c
index 9aac8def4d6359c647d5385a9d2377262d4e7992..61b348a2ea974ab9f97d4a19fc920ba755b77eca 100644 (file)
--- a/arch/um/os-Linux/sigio.c
+++ b/arch/um/os-Linux/sigio.c
@@ -21,8 +21,7 @@
  * Protected by sigio_lock(), also used by sigio_cleanup, which is an
  * exitcall.
  */
-static int write_sigio_pid = -1;
-static unsigned long write_sigio_stack;
+static struct os_helper_thread *write_sigio_td;
 
 /*
  * These arrays are initialized before the sigio thread is started, and
@@ -48,15 +47,15 @@ static struct pollfds current_poll;
 static struct pollfds next_poll;
 static struct pollfds all_sigio_fds;
 
-static int write_sigio_thread(void *unused)
+static void *write_sigio_thread(void *unused)
 {
        struct pollfds *fds, tmp;
        struct pollfd *p;
        int i, n, respond_fd;
        char c;
 
-       os_set_pdeathsig();
-       os_fix_helper_signals();
+       os_fix_helper_thread_signals();
+
        fds = &current_poll;
        while (1) {
                n = poll(fds->poll, fds->used, -1);
@@ -98,7 +97,7 @@ static int write_sigio_thread(void *unused)
                }
        }
 
-       return 0;
+       return NULL;
 }
 
 static int need_poll(struct pollfds *polls, int n)
@@ -152,11 +151,10 @@ static void update_thread(void)
        return;
  fail:
        /* Critical section start */
-       if (write_sigio_pid != -1) {
-               os_kill_process(write_sigio_pid, 1);
-               free_stack(write_sigio_stack, 0);
+       if (write_sigio_td) {
+               os_kill_helper_thread(write_sigio_td);
+               write_sigio_td = NULL;
        }
-       write_sigio_pid = -1;
        close(sigio_private[0]);
        close(sigio_private[1]);
        close(write_sigio_fds[0]);
@@ -220,7 +218,7 @@ int __ignore_sigio_fd(int fd)
         * sigio_cleanup has already run, then update_thread will hang
         * or fail because the thread is no longer running.
         */
-       if (write_sigio_pid == -1)
+       if (!write_sigio_td)
                return -EIO;
 
        for (i = 0; i < current_poll.used; i++) {
@@ -279,14 +277,14 @@ static void write_sigio_workaround(void)
        int err;
        int l_write_sigio_fds[2];
        int l_sigio_private[2];
-       int l_write_sigio_pid;
+       struct os_helper_thread *l_write_sigio_td;
 
        /* We call this *tons* of times - and most ones we must just fail. */
        sigio_lock();
-       l_write_sigio_pid = write_sigio_pid;
+       l_write_sigio_td = write_sigio_td;
        sigio_unlock();
 
-       if (l_write_sigio_pid != -1)
+       if (l_write_sigio_td)
                return;
 
        err = os_pipe(l_write_sigio_fds, 1, 1);
@@ -312,7 +310,7 @@ static void write_sigio_workaround(void)
         * Did we race? Don't try to optimize this, please, it's not so likely
         * to happen, and no more than once at the boot.
         */
-       if (write_sigio_pid != -1)
+       if (write_sigio_td)
                goto out_free;
 
        current_poll = ((struct pollfds) { .poll        = p,
@@ -325,18 +323,15 @@ static void write_sigio_workaround(void)
        memcpy(write_sigio_fds, l_write_sigio_fds, sizeof(l_write_sigio_fds));
        memcpy(sigio_private, l_sigio_private, sizeof(l_sigio_private));
 
-       write_sigio_pid = run_helper_thread(write_sigio_thread, NULL,
-                                           CLONE_FILES | CLONE_VM,
-                                           &write_sigio_stack);
-
-       if (write_sigio_pid < 0)
+       err = os_run_helper_thread(&write_sigio_td, write_sigio_thread, NULL);
+       if (err < 0)
                goto out_clear;
 
        sigio_unlock();
        return;
 
 out_clear:
-       write_sigio_pid = -1;
+       write_sigio_td = NULL;
        write_sigio_fds[0] = -1;
        write_sigio_fds[1] = -1;
        sigio_private[0] = -1;
@@ -394,12 +389,11 @@ void maybe_sigio_broken(int fd)
 
 static void sigio_cleanup(void)
 {
-       if (write_sigio_pid == -1)
+       if (!write_sigio_td)
                return;
 
-       os_kill_process(write_sigio_pid, 1);
-       free_stack(write_sigio_stack, 0);
-       write_sigio_pid = -1;
+       os_kill_helper_thread(write_sigio_td);
+       write_sigio_td = NULL;
 }
 
 __uml_exitcall(sigio_cleanup);