Alex Dewar | 97870c3 | 2019-08-25 10:49:18 +0100 | [diff] [blame] | 1 | // SPDX-License-Identifier: GPL-2.0 |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 2 | /* |
Anton Ivanov | 2eb5f31 | 2015-11-02 16:16:37 +0000 | [diff] [blame] | 3 | * Copyright (C) 2015 Anton Ivanov (aivanov@{brocade.com,kot-begemot.co.uk}) |
| 4 | * Copyright (C) 2015 Thomas Meyer (thomas@m3y3r.de) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 5 | * Copyright (C) 2004 PathScale, Inc |
Jeff Dike | ba180fd | 2007-10-16 01:27:00 -0700 | [diff] [blame] | 6 | * Copyright (C) 2004 - 2007 Jeff Dike (jdike@{addtoit,linux.intel}.com) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 7 | */ |
| 8 | |
Gennady Sharapov | 0805d89 | 2006-01-08 01:01:29 -0800 | [diff] [blame] | 9 | #include <stdlib.h> |
Gennady Sharapov | 0805d89 | 2006-01-08 01:01:29 -0800 | [diff] [blame] | 10 | #include <stdarg.h> |
Jeff Dike | ba180fd | 2007-10-16 01:27:00 -0700 | [diff] [blame] | 11 | #include <errno.h> |
| 12 | #include <signal.h> |
Johannes Berg | b8f7882 | 2019-08-23 12:44:27 +0200 | [diff] [blame] | 13 | #include <string.h> |
Jeff Dike | ba180fd | 2007-10-16 01:27:00 -0700 | [diff] [blame] | 14 | #include <strings.h> |
Al Viro | 37185b3 | 2012-10-08 03:27:32 +0100 | [diff] [blame] | 15 | #include <as-layout.h> |
| 16 | #include <kern_util.h> |
| 17 | #include <os.h> |
| 18 | #include <sysdep/mcontext.h> |
Richard Weinberger | 57a05d8 | 2016-06-12 22:03:16 +0200 | [diff] [blame] | 19 | #include <um_malloc.h> |
Jason A. Donenfeld | 530ba6c | 2017-12-14 03:23:37 +0100 | [diff] [blame] | 20 | #include <sys/ucontext.h> |
Johannes Berg | d6b399a | 2021-03-05 13:19:56 +0100 | [diff] [blame] | 21 | #include <timetravel.h> |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 22 | |
Sergei Trofimovich | 72383d4 | 2012-12-30 01:37:31 +0300 | [diff] [blame] | 23 | void (*sig_info[NSIG])(int, struct siginfo *, struct uml_pt_regs *) = { |
Jeff Dike | 75ada8f | 2008-02-04 22:31:12 -0800 | [diff] [blame] | 24 | [SIGTRAP] = relay_signal, |
| 25 | [SIGFPE] = relay_signal, |
| 26 | [SIGILL] = relay_signal, |
| 27 | [SIGWINCH] = winch, |
| 28 | [SIGBUS] = bus_handler, |
| 29 | [SIGSEGV] = segv_handler, |
| 30 | [SIGIO] = sigio_handler, |
Anton Ivanov | 2eb5f31 | 2015-11-02 16:16:37 +0000 | [diff] [blame] | 31 | }; |
Jeff Dike | 75ada8f | 2008-02-04 22:31:12 -0800 | [diff] [blame] | 32 | |
Richard Weinberger | 9a8c135 | 2013-07-19 11:31:36 +0200 | [diff] [blame] | 33 | static void sig_handler_common(int sig, struct siginfo *si, mcontext_t *mc) |
Jeff Dike | 75ada8f | 2008-02-04 22:31:12 -0800 | [diff] [blame] | 34 | { |
Anton Ivanov | 5c2ffce | 2019-01-04 15:38:21 +0000 | [diff] [blame] | 35 | struct uml_pt_regs r; |
Jeff Dike | e6a2d1f | 2008-02-04 22:31:13 -0800 | [diff] [blame] | 36 | int save_errno = errno; |
Jeff Dike | 75ada8f | 2008-02-04 22:31:12 -0800 | [diff] [blame] | 37 | |
Anton Ivanov | 5c2ffce | 2019-01-04 15:38:21 +0000 | [diff] [blame] | 38 | r.is_user = 0; |
Jeff Dike | 75ada8f | 2008-02-04 22:31:12 -0800 | [diff] [blame] | 39 | if (sig == SIGSEGV) { |
Jeff Dike | e6a2d1f | 2008-02-04 22:31:13 -0800 | [diff] [blame] | 40 | /* For segfaults, we want the data from the sigcontext. */ |
Anton Ivanov | 5c2ffce | 2019-01-04 15:38:21 +0000 | [diff] [blame] | 41 | get_regs_from_mc(&r, mc); |
| 42 | GET_FAULTINFO_FROM_MC(r.faultinfo, mc); |
Jeff Dike | e6a2d1f | 2008-02-04 22:31:13 -0800 | [diff] [blame] | 43 | } |
Jeff Dike | 75ada8f | 2008-02-04 22:31:12 -0800 | [diff] [blame] | 44 | |
Jeff Dike | e6a2d1f | 2008-02-04 22:31:13 -0800 | [diff] [blame] | 45 | /* enable signals if sig isn't IRQ signal */ |
Johannes Berg | 68c15a2 | 2019-08-23 12:44:26 +0200 | [diff] [blame] | 46 | if ((sig != SIGIO) && (sig != SIGWINCH)) |
Johannes Berg | 0dafcbe | 2019-08-23 13:16:23 +0200 | [diff] [blame] | 47 | unblock_signals_trace(); |
Jeff Dike | 75ada8f | 2008-02-04 22:31:12 -0800 | [diff] [blame] | 48 | |
Anton Ivanov | 5c2ffce | 2019-01-04 15:38:21 +0000 | [diff] [blame] | 49 | (*sig_info[sig])(sig, si, &r); |
Jeff Dike | 75ada8f | 2008-02-04 22:31:12 -0800 | [diff] [blame] | 50 | |
| 51 | errno = save_errno; |
Jeff Dike | 75ada8f | 2008-02-04 22:31:12 -0800 | [diff] [blame] | 52 | } |
| 53 | |
Jeff Dike | ba180fd | 2007-10-16 01:27:00 -0700 | [diff] [blame] | 54 | /* |
Jeff Dike | 61b63c5 | 2007-10-16 01:27:27 -0700 | [diff] [blame] | 55 | * These are the asynchronous signals. SIGPROF is excluded because we want to |
Jeff Dike | 1d7173b | 2006-01-18 17:42:49 -0800 | [diff] [blame] | 56 | * be able to profile all of UML, not just the non-critical sections. If |
| 57 | * profiling is not thread-safe, then that is not my problem. We can disable |
| 58 | * profiling when SMP is enabled in that case. |
| 59 | */ |
| 60 | #define SIGIO_BIT 0 |
| 61 | #define SIGIO_MASK (1 << SIGIO_BIT) |
| 62 | |
Anton Ivanov | 2eb5f31 | 2015-11-02 16:16:37 +0000 | [diff] [blame] | 63 | #define SIGALRM_BIT 1 |
| 64 | #define SIGALRM_MASK (1 << SIGALRM_BIT) |
Jeff Dike | 1d7173b | 2006-01-18 17:42:49 -0800 | [diff] [blame] | 65 | |
Johannes Berg | fbb42e7f | 2021-03-05 13:19:54 +0100 | [diff] [blame] | 66 | int signals_enabled; |
Johannes Berg | d6b399a | 2021-03-05 13:19:56 +0100 | [diff] [blame] | 67 | #ifdef UML_CONFIG_UML_TIME_TRAVEL_SUPPORT |
| 68 | static int signals_blocked; |
| 69 | #else |
Alexey Dobriyan | 39f75da | 2021-08-02 23:40:31 +0300 | [diff] [blame] | 70 | #define signals_blocked 0 |
Johannes Berg | d6b399a | 2021-03-05 13:19:56 +0100 | [diff] [blame] | 71 | #endif |
Jeff Dike | cfef8f3 | 2008-02-04 22:31:16 -0800 | [diff] [blame] | 72 | static unsigned int signals_pending; |
Anton Ivanov | d5e3f5c | 2015-12-21 11:28:02 +0000 | [diff] [blame] | 73 | static unsigned int signals_active = 0; |
Jeff Dike | 1d7173b | 2006-01-18 17:42:49 -0800 | [diff] [blame] | 74 | |
Richard Weinberger | 9a8c135 | 2013-07-19 11:31:36 +0200 | [diff] [blame] | 75 | void sig_handler(int sig, struct siginfo *si, mcontext_t *mc) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 76 | { |
Johannes Berg | d6b399a | 2021-03-05 13:19:56 +0100 | [diff] [blame] | 77 | int enabled = signals_enabled; |
Jeff Dike | 1d7173b | 2006-01-18 17:42:49 -0800 | [diff] [blame] | 78 | |
Johannes Berg | d6b399a | 2021-03-05 13:19:56 +0100 | [diff] [blame] | 79 | if ((signals_blocked || !enabled) && (sig == SIGIO)) { |
| 80 | /* |
| 81 | * In TT_MODE_EXTERNAL, need to still call time-travel |
| 82 | * handlers unless signals are also blocked for the |
| 83 | * external time message processing. This will mark |
| 84 | * signals_pending by itself (only if necessary.) |
| 85 | */ |
| 86 | if (!signals_blocked && time_travel_mode == TT_MODE_EXTERNAL) |
| 87 | sigio_run_timetravel_handlers(); |
| 88 | else |
| 89 | signals_pending |= SIGIO_MASK; |
Jeff Dike | 1d7173b | 2006-01-18 17:42:49 -0800 | [diff] [blame] | 90 | return; |
| 91 | } |
| 92 | |
Johannes Berg | 0dafcbe | 2019-08-23 13:16:23 +0200 | [diff] [blame] | 93 | block_signals_trace(); |
Jeff Dike | 1d7173b | 2006-01-18 17:42:49 -0800 | [diff] [blame] | 94 | |
Martin Pärtel | d3c1cfc | 2012-08-02 00:49:17 +0200 | [diff] [blame] | 95 | sig_handler_common(sig, si, mc); |
Jeff Dike | 1d7173b | 2006-01-18 17:42:49 -0800 | [diff] [blame] | 96 | |
Johannes Berg | bbe3350 | 2021-08-31 09:11:15 +0200 | [diff] [blame] | 97 | um_set_signals_trace(enabled); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 98 | } |
| 99 | |
Anton Ivanov | 2eb5f31 | 2015-11-02 16:16:37 +0000 | [diff] [blame] | 100 | static void timer_real_alarm_handler(mcontext_t *mc) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 101 | { |
Anton Ivanov | 5c2ffce | 2019-01-04 15:38:21 +0000 | [diff] [blame] | 102 | struct uml_pt_regs regs; |
Jeff Dike | 2ea5bc5 | 2007-05-10 22:22:32 -0700 | [diff] [blame] | 103 | |
Al Viro | 248b74c | 2011-08-18 20:05:09 +0100 | [diff] [blame] | 104 | if (mc != NULL) |
Anton Ivanov | 5c2ffce | 2019-01-04 15:38:21 +0000 | [diff] [blame] | 105 | get_regs_from_mc(®s, mc); |
Johannes Berg | b8f7882 | 2019-08-23 12:44:27 +0200 | [diff] [blame] | 106 | else |
| 107 | memset(®s, 0, sizeof(regs)); |
Anton Ivanov | 5c2ffce | 2019-01-04 15:38:21 +0000 | [diff] [blame] | 108 | timer_handler(SIGALRM, NULL, ®s); |
Jeff Dike | 1d7173b | 2006-01-18 17:42:49 -0800 | [diff] [blame] | 109 | } |
| 110 | |
Anton Ivanov | 2eb5f31 | 2015-11-02 16:16:37 +0000 | [diff] [blame] | 111 | void timer_alarm_handler(int sig, struct siginfo *unused_si, mcontext_t *mc) |
Jeff Dike | 1d7173b | 2006-01-18 17:42:49 -0800 | [diff] [blame] | 112 | { |
Jeff Dike | 1d7173b | 2006-01-18 17:42:49 -0800 | [diff] [blame] | 113 | int enabled; |
| 114 | |
Jeff Dike | 1d7173b | 2006-01-18 17:42:49 -0800 | [diff] [blame] | 115 | enabled = signals_enabled; |
Jeff Dike | ba180fd | 2007-10-16 01:27:00 -0700 | [diff] [blame] | 116 | if (!signals_enabled) { |
Anton Ivanov | 2eb5f31 | 2015-11-02 16:16:37 +0000 | [diff] [blame] | 117 | signals_pending |= SIGALRM_MASK; |
Jeff Dike | 1d7173b | 2006-01-18 17:42:49 -0800 | [diff] [blame] | 118 | return; |
| 119 | } |
| 120 | |
Johannes Berg | 0dafcbe | 2019-08-23 13:16:23 +0200 | [diff] [blame] | 121 | block_signals_trace(); |
Jeff Dike | 1d7173b | 2006-01-18 17:42:49 -0800 | [diff] [blame] | 122 | |
Anton Ivanov | d5e3f5c | 2015-12-21 11:28:02 +0000 | [diff] [blame] | 123 | signals_active |= SIGALRM_MASK; |
| 124 | |
Anton Ivanov | 2eb5f31 | 2015-11-02 16:16:37 +0000 | [diff] [blame] | 125 | timer_real_alarm_handler(mc); |
Anton Ivanov | d5e3f5c | 2015-12-21 11:28:02 +0000 | [diff] [blame] | 126 | |
| 127 | signals_active &= ~SIGALRM_MASK; |
| 128 | |
Johannes Berg | bbe3350 | 2021-08-31 09:11:15 +0200 | [diff] [blame] | 129 | um_set_signals_trace(enabled); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 130 | } |
| 131 | |
Anton Ivanov | 2eb5f31 | 2015-11-02 16:16:37 +0000 | [diff] [blame] | 132 | void deliver_alarm(void) { |
| 133 | timer_alarm_handler(SIGALRM, NULL, NULL); |
| 134 | } |
| 135 | |
| 136 | void timer_set_signal_handler(void) |
Jeff Dike | 78a26e2 | 2007-10-16 01:27:23 -0700 | [diff] [blame] | 137 | { |
Anton Ivanov | 2eb5f31 | 2015-11-02 16:16:37 +0000 | [diff] [blame] | 138 | set_handler(SIGALRM); |
Jeff Dike | 78a26e2 | 2007-10-16 01:27:23 -0700 | [diff] [blame] | 139 | } |
| 140 | |
Gennady Sharapov | 0805d89 | 2006-01-08 01:01:29 -0800 | [diff] [blame] | 141 | void set_sigstack(void *sig_stack, int size) |
| 142 | { |
Hans-Werner Hilse | 9a75551 | 2015-06-11 11:29:18 +0200 | [diff] [blame] | 143 | stack_t stack = { |
| 144 | .ss_flags = 0, |
| 145 | .ss_sp = sig_stack, |
YiFei Zhu | 558f9b2 | 2021-04-20 00:56:10 -0500 | [diff] [blame] | 146 | .ss_size = size |
Hans-Werner Hilse | 9a75551 | 2015-06-11 11:29:18 +0200 | [diff] [blame] | 147 | }; |
Gennady Sharapov | 0805d89 | 2006-01-08 01:01:29 -0800 | [diff] [blame] | 148 | |
Jeff Dike | ba180fd | 2007-10-16 01:27:00 -0700 | [diff] [blame] | 149 | if (sigaltstack(&stack, NULL) != 0) |
Gennady Sharapov | 0805d89 | 2006-01-08 01:01:29 -0800 | [diff] [blame] | 150 | panic("enabling signal stack failed, errno = %d\n", errno); |
| 151 | } |
| 152 | |
Johannes Berg | 92dcd3d | 2020-12-02 20:58:06 +0100 | [diff] [blame] | 153 | static void sigusr1_handler(int sig, struct siginfo *unused_si, mcontext_t *mc) |
| 154 | { |
| 155 | uml_pm_wake(); |
| 156 | } |
| 157 | |
| 158 | void register_pm_wake_signal(void) |
| 159 | { |
| 160 | set_handler(SIGUSR1); |
| 161 | } |
| 162 | |
Richard Weinberger | 9a8c135 | 2013-07-19 11:31:36 +0200 | [diff] [blame] | 163 | static void (*handlers[_NSIG])(int sig, struct siginfo *si, mcontext_t *mc) = { |
Al Viro | 0036168 | 2011-08-18 20:04:39 +0100 | [diff] [blame] | 164 | [SIGSEGV] = sig_handler, |
| 165 | [SIGBUS] = sig_handler, |
| 166 | [SIGILL] = sig_handler, |
| 167 | [SIGFPE] = sig_handler, |
| 168 | [SIGTRAP] = sig_handler, |
| 169 | |
| 170 | [SIGIO] = sig_handler, |
| 171 | [SIGWINCH] = sig_handler, |
Johannes Berg | 92dcd3d | 2020-12-02 20:58:06 +0100 | [diff] [blame] | 172 | [SIGALRM] = timer_alarm_handler, |
| 173 | |
| 174 | [SIGUSR1] = sigusr1_handler, |
Al Viro | 0036168 | 2011-08-18 20:04:39 +0100 | [diff] [blame] | 175 | }; |
Jeff Dike | 4b84c69 | 2006-09-25 23:33:04 -0700 | [diff] [blame] | 176 | |
Martin Pärtel | d3c1cfc | 2012-08-02 00:49:17 +0200 | [diff] [blame] | 177 | static void hard_handler(int sig, siginfo_t *si, void *p) |
Jeff Dike | c14b849 | 2007-05-10 22:22:34 -0700 | [diff] [blame] | 178 | { |
Krzysztof Mazur | 4d1a535 | 2017-11-15 11:12:39 +0100 | [diff] [blame] | 179 | ucontext_t *uc = p; |
Al Viro | 248b74c | 2011-08-18 20:05:09 +0100 | [diff] [blame] | 180 | mcontext_t *mc = &uc->uc_mcontext; |
Jeff Dike | 508a927 | 2007-09-18 22:46:49 -0700 | [diff] [blame] | 181 | unsigned long pending = 1UL << sig; |
Jeff Dike | c14b849 | 2007-05-10 22:22:34 -0700 | [diff] [blame] | 182 | |
| 183 | do { |
| 184 | int nested, bail; |
| 185 | |
| 186 | /* |
| 187 | * pending comes back with one bit set for each |
| 188 | * interrupt that arrived while setting up the stack, |
| 189 | * plus a bit for this interrupt, plus the zero bit is |
| 190 | * set if this is a nested interrupt. |
| 191 | * If bail is true, then we interrupted another |
| 192 | * handler setting up the stack. In this case, we |
| 193 | * have to return, and the upper handler will deal |
| 194 | * with this interrupt. |
| 195 | */ |
Jeff Dike | 508a927 | 2007-09-18 22:46:49 -0700 | [diff] [blame] | 196 | bail = to_irq_stack(&pending); |
Jeff Dike | ba180fd | 2007-10-16 01:27:00 -0700 | [diff] [blame] | 197 | if (bail) |
Jeff Dike | c14b849 | 2007-05-10 22:22:34 -0700 | [diff] [blame] | 198 | return; |
| 199 | |
| 200 | nested = pending & 1; |
| 201 | pending &= ~1; |
| 202 | |
Jeff Dike | ba180fd | 2007-10-16 01:27:00 -0700 | [diff] [blame] | 203 | while ((sig = ffs(pending)) != 0){ |
Jeff Dike | c14b849 | 2007-05-10 22:22:34 -0700 | [diff] [blame] | 204 | sig--; |
| 205 | pending &= ~(1 << sig); |
Richard Weinberger | 9a8c135 | 2013-07-19 11:31:36 +0200 | [diff] [blame] | 206 | (*handlers[sig])(sig, (struct siginfo *)si, mc); |
Jeff Dike | c14b849 | 2007-05-10 22:22:34 -0700 | [diff] [blame] | 207 | } |
| 208 | |
Jeff Dike | ba180fd | 2007-10-16 01:27:00 -0700 | [diff] [blame] | 209 | /* |
| 210 | * Again, pending comes back with a mask of signals |
Jeff Dike | c14b849 | 2007-05-10 22:22:34 -0700 | [diff] [blame] | 211 | * that arrived while tearing down the stack. If this |
| 212 | * is non-zero, we just go back, set up the stack |
| 213 | * again, and handle the new interrupts. |
| 214 | */ |
Jeff Dike | ba180fd | 2007-10-16 01:27:00 -0700 | [diff] [blame] | 215 | if (!nested) |
Jeff Dike | c14b849 | 2007-05-10 22:22:34 -0700 | [diff] [blame] | 216 | pending = from_irq_stack(nested); |
Jeff Dike | ba180fd | 2007-10-16 01:27:00 -0700 | [diff] [blame] | 217 | } while (pending); |
Jeff Dike | c14b849 | 2007-05-10 22:22:34 -0700 | [diff] [blame] | 218 | } |
| 219 | |
Al Viro | 0036168 | 2011-08-18 20:04:39 +0100 | [diff] [blame] | 220 | void set_handler(int sig) |
Gennady Sharapov | 0805d89 | 2006-01-08 01:01:29 -0800 | [diff] [blame] | 221 | { |
| 222 | struct sigaction action; |
Al Viro | e87df98 | 2011-08-18 20:04:29 +0100 | [diff] [blame] | 223 | int flags = SA_SIGINFO | SA_ONSTACK; |
Jeff Dike | 1d7173b | 2006-01-18 17:42:49 -0800 | [diff] [blame] | 224 | sigset_t sig_mask; |
Gennady Sharapov | 0805d89 | 2006-01-08 01:01:29 -0800 | [diff] [blame] | 225 | |
Al Viro | 7eb1225 | 2011-08-18 20:03:39 +0100 | [diff] [blame] | 226 | action.sa_sigaction = hard_handler; |
Jeff Dike | 4b84c69 | 2006-09-25 23:33:04 -0700 | [diff] [blame] | 227 | |
Al Viro | e87df98 | 2011-08-18 20:04:29 +0100 | [diff] [blame] | 228 | /* block irq ones */ |
Gennady Sharapov | 0805d89 | 2006-01-08 01:01:29 -0800 | [diff] [blame] | 229 | sigemptyset(&action.sa_mask); |
Al Viro | e87df98 | 2011-08-18 20:04:29 +0100 | [diff] [blame] | 230 | sigaddset(&action.sa_mask, SIGIO); |
| 231 | sigaddset(&action.sa_mask, SIGWINCH); |
Anton Ivanov | 2eb5f31 | 2015-11-02 16:16:37 +0000 | [diff] [blame] | 232 | sigaddset(&action.sa_mask, SIGALRM); |
Jeff Dike | 4b84c69 | 2006-09-25 23:33:04 -0700 | [diff] [blame] | 233 | |
Jeff Dike | e6a2d1f | 2008-02-04 22:31:13 -0800 | [diff] [blame] | 234 | if (sig == SIGSEGV) |
| 235 | flags |= SA_NODEFER; |
| 236 | |
Al Viro | e87df98 | 2011-08-18 20:04:29 +0100 | [diff] [blame] | 237 | if (sigismember(&action.sa_mask, sig)) |
| 238 | flags |= SA_RESTART; /* if it's an irq signal */ |
| 239 | |
| 240 | action.sa_flags = flags; |
Gennady Sharapov | 0805d89 | 2006-01-08 01:01:29 -0800 | [diff] [blame] | 241 | action.sa_restorer = NULL; |
Jeff Dike | ba180fd | 2007-10-16 01:27:00 -0700 | [diff] [blame] | 242 | if (sigaction(sig, &action, NULL) < 0) |
Jeff Dike | 1d7173b | 2006-01-18 17:42:49 -0800 | [diff] [blame] | 243 | panic("sigaction failed - errno = %d\n", errno); |
| 244 | |
| 245 | sigemptyset(&sig_mask); |
| 246 | sigaddset(&sig_mask, sig); |
Jeff Dike | ba180fd | 2007-10-16 01:27:00 -0700 | [diff] [blame] | 247 | if (sigprocmask(SIG_UNBLOCK, &sig_mask, NULL) < 0) |
Jeff Dike | 1d7173b | 2006-01-18 17:42:49 -0800 | [diff] [blame] | 248 | panic("sigprocmask failed - errno = %d\n", errno); |
Gennady Sharapov | 0805d89 | 2006-01-08 01:01:29 -0800 | [diff] [blame] | 249 | } |
| 250 | |
Johannes Berg | a374b7c | 2020-12-02 20:58:07 +0100 | [diff] [blame] | 251 | void send_sigio_to_self(void) |
| 252 | { |
| 253 | kill(os_getpid(), SIGIO); |
| 254 | } |
| 255 | |
Gennady Sharapov | 0805d89 | 2006-01-08 01:01:29 -0800 | [diff] [blame] | 256 | int change_sig(int signal, int on) |
| 257 | { |
Jeff Dike | cfef8f3 | 2008-02-04 22:31:16 -0800 | [diff] [blame] | 258 | sigset_t sigset; |
Gennady Sharapov | 0805d89 | 2006-01-08 01:01:29 -0800 | [diff] [blame] | 259 | |
| 260 | sigemptyset(&sigset); |
| 261 | sigaddset(&sigset, signal); |
Jeff Dike | cfef8f3 | 2008-02-04 22:31:16 -0800 | [diff] [blame] | 262 | if (sigprocmask(on ? SIG_UNBLOCK : SIG_BLOCK, &sigset, NULL) < 0) |
WANG Cong | c9a3072 | 2008-02-04 22:30:35 -0800 | [diff] [blame] | 263 | return -errno; |
Jeff Dike | cfef8f3 | 2008-02-04 22:31:16 -0800 | [diff] [blame] | 264 | |
| 265 | return 0; |
Gennady Sharapov | 0805d89 | 2006-01-08 01:01:29 -0800 | [diff] [blame] | 266 | } |
| 267 | |
Gennady Sharapov | 0805d89 | 2006-01-08 01:01:29 -0800 | [diff] [blame] | 268 | void block_signals(void) |
| 269 | { |
Jeff Dike | 1d7173b | 2006-01-18 17:42:49 -0800 | [diff] [blame] | 270 | signals_enabled = 0; |
Jeff Dike | ba180fd | 2007-10-16 01:27:00 -0700 | [diff] [blame] | 271 | /* |
| 272 | * This must return with signals disabled, so this barrier |
Jeff Dike | 53b1733 | 2006-11-02 22:07:22 -0800 | [diff] [blame] | 273 | * ensures that writes are flushed out before the return. |
| 274 | * This might matter if gcc figures out how to inline this and |
| 275 | * decides to shuffle this code into the caller. |
| 276 | */ |
Jeff Dike | fce8c41 | 2008-02-04 22:31:09 -0800 | [diff] [blame] | 277 | barrier(); |
Gennady Sharapov | 0805d89 | 2006-01-08 01:01:29 -0800 | [diff] [blame] | 278 | } |
| 279 | |
| 280 | void unblock_signals(void) |
| 281 | { |
Jeff Dike | 1d7173b | 2006-01-18 17:42:49 -0800 | [diff] [blame] | 282 | int save_pending; |
Gennady Sharapov | 0805d89 | 2006-01-08 01:01:29 -0800 | [diff] [blame] | 283 | |
Jeff Dike | ba180fd | 2007-10-16 01:27:00 -0700 | [diff] [blame] | 284 | if (signals_enabled == 1) |
Jeff Dike | 1d7173b | 2006-01-18 17:42:49 -0800 | [diff] [blame] | 285 | return; |
Gennady Sharapov | 0805d89 | 2006-01-08 01:01:29 -0800 | [diff] [blame] | 286 | |
Johannes Berg | 0dafcbe | 2019-08-23 13:16:23 +0200 | [diff] [blame] | 287 | signals_enabled = 1; |
Johannes Berg | 1138553 | 2020-12-13 22:18:18 +0100 | [diff] [blame] | 288 | #ifdef UML_CONFIG_UML_TIME_TRAVEL_SUPPORT |
| 289 | deliver_time_travel_irqs(); |
| 290 | #endif |
Johannes Berg | 0dafcbe | 2019-08-23 13:16:23 +0200 | [diff] [blame] | 291 | |
Jeff Dike | ba180fd | 2007-10-16 01:27:00 -0700 | [diff] [blame] | 292 | /* |
| 293 | * We loop because the IRQ handler returns with interrupts off. So, |
Jeff Dike | 1d7173b | 2006-01-18 17:42:49 -0800 | [diff] [blame] | 294 | * interrupts may have arrived and we need to re-enable them and |
Jeff Dike | cfef8f3 | 2008-02-04 22:31:16 -0800 | [diff] [blame] | 295 | * recheck signals_pending. |
Jeff Dike | 1d7173b | 2006-01-18 17:42:49 -0800 | [diff] [blame] | 296 | */ |
Jeff Dike | 5134d8f | 2008-02-08 04:22:08 -0800 | [diff] [blame] | 297 | while (1) { |
Jeff Dike | ba180fd | 2007-10-16 01:27:00 -0700 | [diff] [blame] | 298 | /* |
| 299 | * Save and reset save_pending after enabling signals. This |
Jeff Dike | cfef8f3 | 2008-02-04 22:31:16 -0800 | [diff] [blame] | 300 | * way, signals_pending won't be changed while we're reading it. |
Johannes Berg | 0dafcbe | 2019-08-23 13:16:23 +0200 | [diff] [blame] | 301 | * |
Jeff Dike | cfef8f3 | 2008-02-04 22:31:16 -0800 | [diff] [blame] | 302 | * Setting signals_enabled and reading signals_pending must |
Johannes Berg | 0dafcbe | 2019-08-23 13:16:23 +0200 | [diff] [blame] | 303 | * happen in this order, so have the barrier here. |
Jeff Dike | 53b1733 | 2006-11-02 22:07:22 -0800 | [diff] [blame] | 304 | */ |
Jeff Dike | fce8c41 | 2008-02-04 22:31:09 -0800 | [diff] [blame] | 305 | barrier(); |
Jeff Dike | 53b1733 | 2006-11-02 22:07:22 -0800 | [diff] [blame] | 306 | |
Jeff Dike | cfef8f3 | 2008-02-04 22:31:16 -0800 | [diff] [blame] | 307 | save_pending = signals_pending; |
Jeff Dike | fce8c41 | 2008-02-04 22:31:09 -0800 | [diff] [blame] | 308 | if (save_pending == 0) |
Jeff Dike | 1d7173b | 2006-01-18 17:42:49 -0800 | [diff] [blame] | 309 | return; |
| 310 | |
Jeff Dike | cfef8f3 | 2008-02-04 22:31:16 -0800 | [diff] [blame] | 311 | signals_pending = 0; |
Jeff Dike | 1d7173b | 2006-01-18 17:42:49 -0800 | [diff] [blame] | 312 | |
Jeff Dike | ba180fd | 2007-10-16 01:27:00 -0700 | [diff] [blame] | 313 | /* |
| 314 | * We have pending interrupts, so disable signals, as the |
Jeff Dike | 1d7173b | 2006-01-18 17:42:49 -0800 | [diff] [blame] | 315 | * handlers expect them off when they are called. They will |
Johannes Berg | 0dafcbe | 2019-08-23 13:16:23 +0200 | [diff] [blame] | 316 | * be enabled again above. We need to trace this, as we're |
| 317 | * expected to be enabling interrupts already, but any more |
| 318 | * tracing that happens inside the handlers we call for the |
| 319 | * pending signals will mess up the tracing state. |
Jeff Dike | 1d7173b | 2006-01-18 17:42:49 -0800 | [diff] [blame] | 320 | */ |
Jeff Dike | 1d7173b | 2006-01-18 17:42:49 -0800 | [diff] [blame] | 321 | signals_enabled = 0; |
Johannes Berg | 0dafcbe | 2019-08-23 13:16:23 +0200 | [diff] [blame] | 322 | um_trace_signals_off(); |
Jeff Dike | 1d7173b | 2006-01-18 17:42:49 -0800 | [diff] [blame] | 323 | |
Jeff Dike | ba180fd | 2007-10-16 01:27:00 -0700 | [diff] [blame] | 324 | /* |
| 325 | * Deal with SIGIO first because the alarm handler might |
Jeff Dike | 1d7173b | 2006-01-18 17:42:49 -0800 | [diff] [blame] | 326 | * schedule, leaving the pending SIGIO stranded until we come |
| 327 | * back here. |
Martin Pärtel | d3c1cfc | 2012-08-02 00:49:17 +0200 | [diff] [blame] | 328 | * |
| 329 | * SIGIO's handler doesn't use siginfo or mcontext, |
| 330 | * so they can be NULL. |
Jeff Dike | 1d7173b | 2006-01-18 17:42:49 -0800 | [diff] [blame] | 331 | */ |
Jeff Dike | ba180fd | 2007-10-16 01:27:00 -0700 | [diff] [blame] | 332 | if (save_pending & SIGIO_MASK) |
Martin Pärtel | d3c1cfc | 2012-08-02 00:49:17 +0200 | [diff] [blame] | 333 | sig_handler_common(SIGIO, NULL, NULL); |
Jeff Dike | 1d7173b | 2006-01-18 17:42:49 -0800 | [diff] [blame] | 334 | |
Anton Ivanov | d5e3f5c | 2015-12-21 11:28:02 +0000 | [diff] [blame] | 335 | /* Do not reenter the handler */ |
| 336 | |
| 337 | if ((save_pending & SIGALRM_MASK) && (!(signals_active & SIGALRM_MASK))) |
Anton Ivanov | 2eb5f31 | 2015-11-02 16:16:37 +0000 | [diff] [blame] | 338 | timer_real_alarm_handler(NULL); |
Anton Ivanov | d5e3f5c | 2015-12-21 11:28:02 +0000 | [diff] [blame] | 339 | |
| 340 | /* Rerun the loop only if there is still pending SIGIO and not in TIMER handler */ |
| 341 | |
| 342 | if (!(signals_pending & SIGIO_MASK) && (signals_active & SIGALRM_MASK)) |
| 343 | return; |
| 344 | |
Johannes Berg | 0dafcbe | 2019-08-23 13:16:23 +0200 | [diff] [blame] | 345 | /* Re-enable signals and trace that we're doing so. */ |
| 346 | um_trace_signals_on(); |
| 347 | signals_enabled = 1; |
Jeff Dike | 1d7173b | 2006-01-18 17:42:49 -0800 | [diff] [blame] | 348 | } |
Gennady Sharapov | 0805d89 | 2006-01-08 01:01:29 -0800 | [diff] [blame] | 349 | } |
| 350 | |
Johannes Berg | bbe3350 | 2021-08-31 09:11:15 +0200 | [diff] [blame] | 351 | int um_set_signals(int enable) |
Gennady Sharapov | 0805d89 | 2006-01-08 01:01:29 -0800 | [diff] [blame] | 352 | { |
Gennady Sharapov | 0805d89 | 2006-01-08 01:01:29 -0800 | [diff] [blame] | 353 | int ret; |
Jeff Dike | ba180fd | 2007-10-16 01:27:00 -0700 | [diff] [blame] | 354 | if (signals_enabled == enable) |
Jeff Dike | 1d7173b | 2006-01-18 17:42:49 -0800 | [diff] [blame] | 355 | return enable; |
Gennady Sharapov | 0805d89 | 2006-01-08 01:01:29 -0800 | [diff] [blame] | 356 | |
Jeff Dike | 1d7173b | 2006-01-18 17:42:49 -0800 | [diff] [blame] | 357 | ret = signals_enabled; |
Jeff Dike | ba180fd | 2007-10-16 01:27:00 -0700 | [diff] [blame] | 358 | if (enable) |
Jeff Dike | 1d7173b | 2006-01-18 17:42:49 -0800 | [diff] [blame] | 359 | unblock_signals(); |
| 360 | else block_signals(); |
Gennady Sharapov | 0805d89 | 2006-01-08 01:01:29 -0800 | [diff] [blame] | 361 | |
Jeff Dike | 1d7173b | 2006-01-18 17:42:49 -0800 | [diff] [blame] | 362 | return ret; |
Gennady Sharapov | 0805d89 | 2006-01-08 01:01:29 -0800 | [diff] [blame] | 363 | } |
Richard Weinberger | f72c22e | 2013-09-23 17:38:02 +0200 | [diff] [blame] | 364 | |
Johannes Berg | bbe3350 | 2021-08-31 09:11:15 +0200 | [diff] [blame] | 365 | int um_set_signals_trace(int enable) |
Johannes Berg | 0dafcbe | 2019-08-23 13:16:23 +0200 | [diff] [blame] | 366 | { |
| 367 | int ret; |
| 368 | if (signals_enabled == enable) |
| 369 | return enable; |
| 370 | |
| 371 | ret = signals_enabled; |
| 372 | if (enable) |
| 373 | unblock_signals_trace(); |
| 374 | else |
| 375 | block_signals_trace(); |
| 376 | |
| 377 | return ret; |
| 378 | } |
| 379 | |
Johannes Berg | d6b399a | 2021-03-05 13:19:56 +0100 | [diff] [blame] | 380 | #ifdef UML_CONFIG_UML_TIME_TRAVEL_SUPPORT |
| 381 | void mark_sigio_pending(void) |
| 382 | { |
| 383 | signals_pending |= SIGIO_MASK; |
| 384 | } |
| 385 | |
| 386 | void block_signals_hard(void) |
| 387 | { |
| 388 | if (signals_blocked) |
| 389 | return; |
| 390 | signals_blocked = 1; |
| 391 | barrier(); |
| 392 | } |
| 393 | |
| 394 | void unblock_signals_hard(void) |
| 395 | { |
| 396 | if (!signals_blocked) |
| 397 | return; |
| 398 | /* Must be set to 0 before we check the pending bits etc. */ |
| 399 | signals_blocked = 0; |
| 400 | barrier(); |
| 401 | |
| 402 | if (signals_pending && signals_enabled) { |
| 403 | /* this is a bit inefficient, but that's not really important */ |
| 404 | block_signals(); |
| 405 | unblock_signals(); |
| 406 | } else if (signals_pending & SIGIO_MASK) { |
| 407 | /* we need to run time-travel handlers even if not enabled */ |
| 408 | sigio_run_timetravel_handlers(); |
| 409 | } |
| 410 | } |
| 411 | #endif |
| 412 | |
Richard Weinberger | f72c22e | 2013-09-23 17:38:02 +0200 | [diff] [blame] | 413 | int os_is_signal_stack(void) |
| 414 | { |
| 415 | stack_t ss; |
| 416 | sigaltstack(NULL, &ss); |
| 417 | |
| 418 | return ss.ss_flags & SS_ONSTACK; |
| 419 | } |