util/async-teardown.c

   1 /*
   2  * Asynchronous teardown
   3  *
   4  * Copyright IBM, Corp. 2022
   5  *
   6  * Authors:
   7  *  Claudio Imbrenda <imbrenda@linux.ibm.com>
   8  *
   9  * This work is licensed under the terms of the GNU GPL, version 2 or (at your
  10  * option) any later version.  See the COPYING file in the top-level directory.
  11  *
  12  */
  13
  14 #include "qemu/osdep.h"
  15 #include "qemu/config-file.h"
  16 #include "qemu/option.h"
  17 #include "qemu/module.h"
  18 #include <dirent.h>
  19 #include <sys/prctl.h>
  20 #include <sched.h>
  21
  22 #include "qemu/async-teardown.h"
  23
  24 #ifdef _SC_THREAD_STACK_MIN
  25 #define CLONE_STACK_SIZE sysconf(_SC_THREAD_STACK_MIN)
  26 #else
  27 #define CLONE_STACK_SIZE 16384
  28 #endif
  29
  30 static pid_t the_ppid;
  31
  32 /*
  33  * Close all open file descriptors.
  34  */
  35 static void close_all_open_fd(void)
  36 {
  37     struct dirent *de;
  38     int fd, dfd;
  39     DIR *dir;
  40
  41 #ifdef CONFIG_CLOSE_RANGE
  42     int r = close_range(0, ~0U, 0);
  43     if (!r) {
  44         /* Success, no need to try other ways. */
  45         return;
  46     }
  47 #endif
  48
  49     dir = opendir("/proc/self/fd");
  50     if (!dir) {
  51         /* If /proc is not mounted, there is nothing that can be done. */
  52         return;
  53     }
  54     /* Avoid closing the directory. */
  55     dfd = dirfd(dir);
  56
  57     for (de = readdir(dir); de; de = readdir(dir)) {
  58         fd = atoi(de->d_name);
  59         if (fd != dfd) {
  60             close(fd);
  61         }
  62     }
  63     closedir(dir);
  64 }
  65
  66 static void hup_handler(int signal)
  67 {
  68     /* Check every second if this process has been reparented. */
  69     while (the_ppid == getppid()) {
  70         /* sleep() is safe to use in a signal handler. */
  71         sleep(1);
  72     }
  73
  74     /* At this point the parent process has terminated completely. */
  75     _exit(0);
  76 }
  77
  78 static int async_teardown_fn(void *arg)
  79 {
  80     struct sigaction sa = { .sa_handler = hup_handler };
  81     sigset_t hup_signal;
  82     char name[16];
  83
  84     /* Set a meaningful name for this process. */
  85     snprintf(name, 16, "cleanup/%d", the_ppid);
  86     prctl(PR_SET_NAME, (unsigned long)name);
  87
  88     /*
  89      * Close all file descriptors that might have been inherited from the
  90      * main qemu process when doing clone, needed to make libvirt happy.
  91      * Not using close_range for increased compatibility with older kernels.
  92      */
  93     close_all_open_fd();
  94
  95     /* Set up a handler for SIGHUP and unblock SIGHUP. */
  96     sigaction(SIGHUP, &sa, NULL);
  97     sigemptyset(&hup_signal);
  98     sigaddset(&hup_signal, SIGHUP);
  99     sigprocmask(SIG_UNBLOCK, &hup_signal, NULL);
 100
 101     /* Ask to receive SIGHUP when the parent dies. */
 102     prctl(PR_SET_PDEATHSIG, SIGHUP);
 103
 104     /*
 105      * Sleep forever, unless the parent process has already terminated. The
 106      * only interruption can come from the SIGHUP signal, which in normal
 107      * operation is received when the parent process dies.
 108      */
 109     if (the_ppid == getppid()) {
 110         pause();
 111     }
 112
 113     /* At this point the parent process has terminated completely. */
 114     _exit(0);
 115 }
 116
 117 /*
 118  * Allocate a new stack of a reasonable size, and return a pointer to its top.
 119  */
 120 static void *new_stack_for_clone(void)
 121 {
 122     size_t stack_size = CLONE_STACK_SIZE;
 123     char *stack_ptr;
 124
 125     /* Allocate a new stack and get a pointer to its top. */
 126     stack_ptr = qemu_alloc_stack(&stack_size);
 127 #if !defined(HOST_HPPA)
 128     /* The top is at the end of the area, except on HPPA. */
 129     stack_ptr += stack_size;
 130 #endif
 131
 132     return stack_ptr;
 133 }
 134
 135 /*
 136  * Block all signals, start (clone) a new process sharing the address space
 137  * with qemu (CLONE_VM), then restore signals.
 138  */
 139 void init_async_teardown(void)
 140 {
 141     sigset_t all_signals, old_signals;
 142
 143     the_ppid = getpid();
 144
 145     sigfillset(&all_signals);
 146     sigprocmask(SIG_BLOCK, &all_signals, &old_signals);
 147     clone(async_teardown_fn, new_stack_for_clone(), CLONE_VM, NULL);
 148     sigprocmask(SIG_SETMASK, &old_signals, NULL);
 149 }
 150
 151 static QemuOptsList qemu_run_with_opts = {
 152     .name = "run-with",
 153     .head = QTAILQ_HEAD_INITIALIZER(qemu_run_with_opts.head),
 154     .desc = {
 155         {
 156             .name = "async-teardown",
 157             .type = QEMU_OPT_BOOL,
 158         },
 159         { /* end of list */ }
 160     },
 161 };
 162
 163 static void register_teardown(void)
 164 {
 165     qemu_add_opts(&qemu_run_with_opts);
 166 }
 167 opts_init(register_teardown);