|
10 | 10 | #include <sys/syscall.h> |
11 | 11 |
|
12 | 12 | #include "main/host/host.h" |
| 13 | +#include "main/host/shimipc.h" |
13 | 14 | #include "main/host/syscall/protected.h" |
14 | 15 | #include "main/host/thread.h" |
15 | 16 | #include "main/utility/syscall.h" |
@@ -124,3 +125,129 @@ SysCallReturn syscallhandler_tkill(SysCallHandler* sys, const SysCallArgs* args) |
124 | 125 | trace("translated virtual tid %i to native tid %i", tid, native_tid); |
125 | 126 | return _syscallhandler_killHelper(sys, 0, native_tid, sig, SYS_tkill); |
126 | 127 | } |
| 128 | + |
| 129 | +// Removes `signal` from the sigset_t pointed to by `maskPtr`, if present. |
| 130 | +// Returns 0 on success (including if the signal wasn't present), or a negative |
| 131 | +// errno on failure. |
| 132 | +static int _removeSignalFromSet(SysCallHandler* sys, PluginPtr maskPtr, int signal) { |
| 133 | + sigset_t mask; |
| 134 | + int rv = process_readPtr(sys->process, &mask, maskPtr, sizeof(mask)); |
| 135 | + if (rv < 0) { |
| 136 | + trace("Error reading %p: %s", (void*)maskPtr.val, g_strerror(-rv)); |
| 137 | + return rv; |
| 138 | + } |
| 139 | + rv = sigismember(&mask, SIGSYS); |
| 140 | + if (rv < 0) { |
| 141 | + panic("sigismember: %s", g_strerror(errno)); |
| 142 | + } |
| 143 | + if (!rv) { |
| 144 | + trace("Signal %d wasn't in set", signal); |
| 145 | + return 0; |
| 146 | + } |
| 147 | + trace("Clearing %d from sigprocmask(SIG_BLOCK) set", signal); |
| 148 | + rv = sigdelset(&mask, SIGSYS); |
| 149 | + if (rv < 0) { |
| 150 | + panic("sigdelset: %s", g_strerror(errno)); |
| 151 | + } |
| 152 | + rv = process_writePtr(sys->process, maskPtr, &mask, sizeof(mask)); |
| 153 | + if (rv < 0) { |
| 154 | + trace("Error writing %p: %s", (void*)maskPtr.val, g_strerror(-rv)); |
| 155 | + return rv; |
| 156 | + } |
| 157 | + return 0; |
| 158 | +} |
| 159 | + |
| 160 | +SysCallReturn syscallhandler_sigaction(SysCallHandler* sys, const SysCallArgs* args) { |
| 161 | + utility_assert(sys && args); |
| 162 | + |
| 163 | + if (!shimipc_getUseSeccomp()) { |
| 164 | + return (SysCallReturn){.state = SYSCALL_NATIVE}; |
| 165 | + } |
| 166 | + // Prevent interference with shim's SIGSYS handler. |
| 167 | + |
| 168 | + int signum = (int)args->args[0].as_i64; |
| 169 | + PluginPtr sigaction_ptr = args->args[1].as_ptr; |
| 170 | + PluginPtr sa_mask_ptr = (PluginPtr){sigaction_ptr.val + offsetof(struct sigaction, sa_mask)}; |
| 171 | + |
| 172 | + if (signum == SIGSYS) { |
| 173 | + warning("Blocking `sigaction` for SIGSYS"); |
| 174 | + return (SysCallReturn){.state = SYSCALL_DONE, .retval = -ENOSYS}; |
| 175 | + } |
| 176 | + _removeSignalFromSet(sys, sa_mask_ptr, SIGSYS); |
| 177 | + |
| 178 | + return (SysCallReturn){.state = SYSCALL_NATIVE}; |
| 179 | +} |
| 180 | + |
| 181 | +SysCallReturn syscallhandler_rt_sigaction(SysCallHandler* sys, const SysCallArgs* args) { |
| 182 | + utility_assert(sys && args); |
| 183 | + if (!shimipc_getUseSeccomp()) { |
| 184 | + return (SysCallReturn){.state = SYSCALL_NATIVE}; |
| 185 | + } |
| 186 | + // Prevent interference with shim's SIGSYS handler. |
| 187 | + |
| 188 | + int signum = (int)args->args[0].as_i64; |
| 189 | + PluginPtr sigaction_ptr = args->args[1].as_ptr; |
| 190 | + PluginPtr sa_mask_ptr = (PluginPtr){sigaction_ptr.val + offsetof(struct sigaction, sa_mask)}; |
| 191 | + |
| 192 | + if (signum == SIGSYS) { |
| 193 | + warning("Blocking `rt_sigaction` for SIGSYS"); |
| 194 | + return (SysCallReturn){.state = SYSCALL_DONE, .retval = -ENOSYS}; |
| 195 | + } |
| 196 | + _removeSignalFromSet(sys, sa_mask_ptr, SIGSYS); |
| 197 | + |
| 198 | + return (SysCallReturn){.state = SYSCALL_NATIVE}; |
| 199 | +} |
| 200 | + |
| 201 | +SysCallReturn syscallhandler_signal(SysCallHandler* sys, const SysCallArgs* args) { |
| 202 | + utility_assert(sys && args); |
| 203 | + if (!shimipc_getUseSeccomp()) { |
| 204 | + return (SysCallReturn){.state = SYSCALL_NATIVE}; |
| 205 | + } |
| 206 | + // Prevent interference with shim's SIGSYS handler. |
| 207 | + |
| 208 | + int signum = (int)args->args[0].as_i64; |
| 209 | + |
| 210 | + if (signum == SIGSYS) { |
| 211 | + warning("Blocking `signal` for SIGSYS"); |
| 212 | + return (SysCallReturn){.state = SYSCALL_DONE, .retval = -ENOSYS}; |
| 213 | + } |
| 214 | + return (SysCallReturn){.state = SYSCALL_NATIVE}; |
| 215 | +} |
| 216 | + |
| 217 | +SysCallReturn syscallhandler_sigprocmask(SysCallHandler* sys, const SysCallArgs* args) { |
| 218 | + utility_assert(sys && args); |
| 219 | + if (!shimipc_getUseSeccomp()) { |
| 220 | + return (SysCallReturn){.state = SYSCALL_NATIVE}; |
| 221 | + } |
| 222 | + // Prevent interference with shim's SIGSYS handler. |
| 223 | + |
| 224 | + int how = (int)args->args[0].as_i64; |
| 225 | + PluginPtr maskPtr = args->args[1].as_ptr; |
| 226 | + |
| 227 | + if (how == SIG_BLOCK || how == SIG_SETMASK) { |
| 228 | + int rv = _removeSignalFromSet(sys, maskPtr, SIGSYS); |
| 229 | + if (rv != 0) { |
| 230 | + return (SysCallReturn){.state = SYSCALL_DONE, .retval = rv}; |
| 231 | + } |
| 232 | + } |
| 233 | + return (SysCallReturn){.state = SYSCALL_NATIVE}; |
| 234 | +} |
| 235 | + |
| 236 | +SysCallReturn syscallhandler_rt_sigprocmask(SysCallHandler* sys, const SysCallArgs* args) { |
| 237 | + utility_assert(sys && args); |
| 238 | + if (!shimipc_getUseSeccomp()) { |
| 239 | + return (SysCallReturn){.state = SYSCALL_NATIVE}; |
| 240 | + } |
| 241 | + // Prevent interference with shim's SIGSYS handler. |
| 242 | + |
| 243 | + int how = (int)args->args[0].as_i64; |
| 244 | + PluginPtr maskPtr = args->args[1].as_ptr; |
| 245 | + |
| 246 | + if (how == SIG_BLOCK || how == SIG_SETMASK) { |
| 247 | + int rv = _removeSignalFromSet(sys, maskPtr, SIGSYS); |
| 248 | + if (rv != 0) { |
| 249 | + return (SysCallReturn){.state = SYSCALL_DONE, .retval = rv}; |
| 250 | + } |
| 251 | + } |
| 252 | + return (SysCallReturn){.state = SYSCALL_NATIVE}; |
| 253 | +} |
0 commit comments