1 /*-
2 * SPDX-License-Identifier: BSD-3-Clause
3 *
4 * Copyright (c) 1995 Scott Bartram
5 * Copyright (c) 1995 Steven Wallace
6 * All rights reserved.
7 *
8 * Redistribution and use in source and binary forms, with or without
9 * modification, are permitted provided that the following conditions
10 * are met:
11 * 1. Redistributions of source code must retain the above copyright
12 * notice, this list of conditions and the following disclaimer.
13 * 2. Redistributions in binary form must reproduce the above copyright
14 * notice, this list of conditions and the following disclaimer in the
15 * documentation and/or other materials provided with the distribution.
16 * 3. The name of the author may not be used to endorse or promote products
17 * derived from this software without specific prior written permission
18 *
19 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
20 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
21 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
22 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
23 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
24 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
25 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
26 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
27 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
28 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
29 */
30
31 #include <sys/cdefs.h>
32 __FBSDID("$FreeBSD: stable/12/sys/i386/ibcs2/ibcs2_signal.c 326260 2017-11-27 15:08:52Z pfg $");
33
34 #include <sys/param.h>
35 #include <sys/systm.h>
36 #include <sys/lock.h>
37 #include <sys/mutex.h>
38 #include <sys/signalvar.h>
39 #include <sys/syscallsubr.h>
40 #include <sys/sysproto.h>
41
42 #include <i386/ibcs2/ibcs2_types.h>
43 #include <i386/ibcs2/ibcs2_signal.h>
44 #include <i386/ibcs2/ibcs2_proto.h>
45 #include <i386/ibcs2/ibcs2_xenix.h>
46 #include <i386/ibcs2/ibcs2_util.h>
47
48 #define sigemptyset(s) SIGEMPTYSET(*(s))
49 #define sigismember(s, n) SIGISMEMBER(*(s), n)
50 #define sigaddset(s, n) SIGADDSET(*(s), n)
51
52 #define ibcs2_sigmask(n) (1 << ((n) - 1))
53 #define ibcs2_sigemptyset(s) bzero((s), sizeof(*(s)))
54 #define ibcs2_sigismember(s, n) (*(s) & ibcs2_sigmask(n))
55 #define ibcs2_sigaddset(s, n) (*(s) |= ibcs2_sigmask(n))
56
57 static void ibcs2_to_bsd_sigset(const ibcs2_sigset_t *, sigset_t *);
58 static void bsd_to_ibcs2_sigset(const sigset_t *, ibcs2_sigset_t *);
59 static void ibcs2_to_bsd_sigaction(struct ibcs2_sigaction *,
60 struct sigaction *);
61 static void bsd_to_ibcs2_sigaction(struct sigaction *,
62 struct ibcs2_sigaction *);
63
64 int bsd_to_ibcs2_sig[IBCS2_SIGTBLSZ] = {
65 IBCS2_SIGHUP, /* 1 */
66 IBCS2_SIGINT, /* 2 */
67 IBCS2_SIGQUIT, /* 3 */
68 IBCS2_SIGILL, /* 4 */
69 IBCS2_SIGTRAP, /* 5 */
70 IBCS2_SIGABRT, /* 6 */
71 IBCS2_SIGEMT, /* 7 */
72 IBCS2_SIGFPE, /* 8 */
73 IBCS2_SIGKILL, /* 9 */
74 IBCS2_SIGBUS, /* 10 */
75 IBCS2_SIGSEGV, /* 11 */
76 IBCS2_SIGSYS, /* 12 */
77 IBCS2_SIGPIPE, /* 13 */
78 IBCS2_SIGALRM, /* 14 */
79 IBCS2_SIGTERM, /* 15 */
80 0, /* 16 - SIGURG */
81 IBCS2_SIGSTOP, /* 17 */
82 IBCS2_SIGTSTP, /* 18 */
83 IBCS2_SIGCONT, /* 19 */
84 IBCS2_SIGCLD, /* 20 */
85 IBCS2_SIGTTIN, /* 21 */
86 IBCS2_SIGTTOU, /* 22 */
87 IBCS2_SIGPOLL, /* 23 */
88 0, /* 24 - SIGXCPU */
89 0, /* 25 - SIGXFSZ */
90 IBCS2_SIGVTALRM, /* 26 */
91 IBCS2_SIGPROF, /* 27 */
92 IBCS2_SIGWINCH, /* 28 */
93 0, /* 29 */
94 IBCS2_SIGUSR1, /* 30 */
95 IBCS2_SIGUSR2, /* 31 */
96 0 /* 32 */
97 };
98
99 static int ibcs2_to_bsd_sig[IBCS2_SIGTBLSZ] = {
100 SIGHUP, /* 1 */
101 SIGINT, /* 2 */
102 SIGQUIT, /* 3 */
103 SIGILL, /* 4 */
104 SIGTRAP, /* 5 */
105 SIGABRT, /* 6 */
106 SIGEMT, /* 7 */
107 SIGFPE, /* 8 */
108 SIGKILL, /* 9 */
109 SIGBUS, /* 10 */
110 SIGSEGV, /* 11 */
111 SIGSYS, /* 12 */
112 SIGPIPE, /* 13 */
113 SIGALRM, /* 14 */
114 SIGTERM, /* 15 */
115 SIGUSR1, /* 16 */
116 SIGUSR2, /* 17 */
117 SIGCHLD, /* 18 */
118 0, /* 19 - SIGPWR */
119 SIGWINCH, /* 20 */
120 0, /* 21 */
121 SIGIO, /* 22 */
122 SIGSTOP, /* 23 */
123 SIGTSTP, /* 24 */
124 SIGCONT, /* 25 */
125 SIGTTIN, /* 26 */
126 SIGTTOU, /* 27 */
127 SIGVTALRM, /* 28 */
128 SIGPROF, /* 29 */
129 0, /* 30 */
130 0, /* 31 */
131 0 /* 32 */
132 };
133
134 void
ibcs2_to_bsd_sigset(iss,bss)135 ibcs2_to_bsd_sigset(iss, bss)
136 const ibcs2_sigset_t *iss;
137 sigset_t *bss;
138 {
139 int i, newsig;
140
141 sigemptyset(bss);
142 for (i = 1; i <= IBCS2_SIGTBLSZ; i++) {
143 if (ibcs2_sigismember(iss, i)) {
144 newsig = ibcs2_to_bsd_sig[_SIG_IDX(i)];
145 if (newsig)
146 sigaddset(bss, newsig);
147 }
148 }
149 }
150
151 static void
bsd_to_ibcs2_sigset(bss,iss)152 bsd_to_ibcs2_sigset(bss, iss)
153 const sigset_t *bss;
154 ibcs2_sigset_t *iss;
155 {
156 int i, newsig;
157
158 ibcs2_sigemptyset(iss);
159 for (i = 1; i <= IBCS2_SIGTBLSZ; i++) {
160 if (sigismember(bss, i)) {
161 newsig = bsd_to_ibcs2_sig[_SIG_IDX(i)];
162 if (newsig)
163 ibcs2_sigaddset(iss, newsig);
164 }
165 }
166 }
167
168 static void
ibcs2_to_bsd_sigaction(isa,bsa)169 ibcs2_to_bsd_sigaction(isa, bsa)
170 struct ibcs2_sigaction *isa;
171 struct sigaction *bsa;
172 {
173
174 bsa->sa_handler = isa->isa_handler;
175 ibcs2_to_bsd_sigset(&isa->isa_mask, &bsa->sa_mask);
176 bsa->sa_flags = 0; /* ??? SA_NODEFER */
177 if ((isa->isa_flags & IBCS2_SA_NOCLDSTOP) != 0)
178 bsa->sa_flags |= SA_NOCLDSTOP;
179 }
180
181 static void
bsd_to_ibcs2_sigaction(bsa,isa)182 bsd_to_ibcs2_sigaction(bsa, isa)
183 struct sigaction *bsa;
184 struct ibcs2_sigaction *isa;
185 {
186
187 isa->isa_handler = bsa->sa_handler;
188 bsd_to_ibcs2_sigset(&bsa->sa_mask, &isa->isa_mask);
189 isa->isa_flags = 0;
190 if ((bsa->sa_flags & SA_NOCLDSTOP) != 0)
191 isa->isa_flags |= IBCS2_SA_NOCLDSTOP;
192 }
193
194 int
ibcs2_sigaction(struct thread * td,struct ibcs2_sigaction_args * uap)195 ibcs2_sigaction(struct thread *td, struct ibcs2_sigaction_args *uap)
196 {
197 struct ibcs2_sigaction isa;
198 struct sigaction nbsa, obsa;
199 struct sigaction *nbsap;
200 int error;
201
202 if (uap->act != NULL) {
203 if ((error = copyin(uap->act, &isa, sizeof(isa))) != 0)
204 return (error);
205 ibcs2_to_bsd_sigaction(&isa, &nbsa);
206 nbsap = &nbsa;
207 } else
208 nbsap = NULL;
209 if (uap->sig <= 0 || uap->sig > IBCS2_NSIG)
210 return (EINVAL);
211 error = kern_sigaction(td, ibcs2_to_bsd_sig[_SIG_IDX(uap->sig)], &nbsa,
212 &obsa, 0);
213 if (error == 0 && uap->oact != NULL) {
214 bsd_to_ibcs2_sigaction(&obsa, &isa);
215 error = copyout(&isa, uap->oact, sizeof(isa));
216 }
217 return (error);
218 }
219
220 int
ibcs2_sigsys(struct thread * td,struct ibcs2_sigsys_args * uap)221 ibcs2_sigsys(struct thread *td, struct ibcs2_sigsys_args *uap)
222 {
223 struct proc *p = td->td_proc;
224 struct sigaction sa;
225 int signum = IBCS2_SIGNO(uap->sig);
226 int error;
227
228 if (signum <= 0 || signum > IBCS2_NSIG) {
229 if (IBCS2_SIGCALL(uap->sig) == IBCS2_SIGNAL_MASK ||
230 IBCS2_SIGCALL(uap->sig) == IBCS2_SIGSET_MASK)
231 td->td_retval[0] = (int)IBCS2_SIG_ERR;
232 return EINVAL;
233 }
234 signum = ibcs2_to_bsd_sig[_SIG_IDX(signum)];
235
236 switch (IBCS2_SIGCALL(uap->sig)) {
237 case IBCS2_SIGSET_MASK:
238 /*
239 * Check for SIG_HOLD action.
240 * Otherwise, perform signal() except with different sa_flags.
241 */
242 if (uap->fp != IBCS2_SIG_HOLD) {
243 /* add sig to mask before exececuting signal handler */
244 sa.sa_flags = 0;
245 goto ibcs2_sigset;
246 }
247 /* else FALLTHROUGH to sighold */
248
249 case IBCS2_SIGHOLD_MASK:
250 {
251 sigset_t mask;
252
253 SIGEMPTYSET(mask);
254 SIGADDSET(mask, signum);
255 return (kern_sigprocmask(td, SIG_BLOCK, &mask, NULL,
256 0));
257 }
258
259 case IBCS2_SIGNAL_MASK:
260 {
261 struct sigaction osa;
262
263 /* do not automatically block signal */
264 sa.sa_flags = SA_NODEFER;
265 #ifdef SA_RESETHAND
266 if((signum != IBCS2_SIGILL) &&
267 (signum != IBCS2_SIGTRAP) &&
268 (signum != IBCS2_SIGPWR))
269 /* set to SIG_DFL before executing handler */
270 sa.sa_flags |= SA_RESETHAND;
271 #endif
272 ibcs2_sigset:
273 sa.sa_handler = uap->fp;
274 sigemptyset(&sa.sa_mask);
275 #if 0
276 if (signum != SIGALRM)
277 sa.sa_flags |= SA_RESTART;
278 #endif
279 error = kern_sigaction(td, signum, &sa, &osa, 0);
280 if (error != 0) {
281 DPRINTF(("signal: sigaction failed: %d\n",
282 error));
283 td->td_retval[0] = (int)IBCS2_SIG_ERR;
284 return (error);
285 }
286 td->td_retval[0] = (int)osa.sa_handler;
287
288 /* special sigset() check */
289 if(IBCS2_SIGCALL(uap->sig) == IBCS2_SIGSET_MASK) {
290 PROC_LOCK(p);
291 /* check to make sure signal is not blocked */
292 if(sigismember(&td->td_sigmask, signum)) {
293 /* return SIG_HOLD and unblock signal*/
294 td->td_retval[0] = (int)IBCS2_SIG_HOLD;
295 SIGDELSET(td->td_sigmask, signum);
296 signotify(td);
297 }
298 PROC_UNLOCK(p);
299 }
300
301 return 0;
302 }
303
304 case IBCS2_SIGRELSE_MASK:
305 {
306 sigset_t mask;
307
308 SIGEMPTYSET(mask);
309 SIGADDSET(mask, signum);
310 return (kern_sigprocmask(td, SIG_UNBLOCK, &mask, NULL,
311 0));
312 }
313
314 case IBCS2_SIGIGNORE_MASK:
315 {
316 sa.sa_handler = SIG_IGN;
317 sigemptyset(&sa.sa_mask);
318 sa.sa_flags = 0;
319 error = kern_sigaction(td, signum, &sa, NULL, 0);
320 if (error != 0)
321 DPRINTF(("sigignore: sigaction failed\n"));
322 return (error);
323 }
324
325 case IBCS2_SIGPAUSE_MASK:
326 {
327 sigset_t mask;
328
329 PROC_LOCK(p);
330 mask = td->td_sigmask;
331 PROC_UNLOCK(p);
332 SIGDELSET(mask, signum);
333 return kern_sigsuspend(td, mask);
334 }
335
336 default:
337 return ENOSYS;
338 }
339 }
340
341 int
ibcs2_sigprocmask(struct thread * td,struct ibcs2_sigprocmask_args * uap)342 ibcs2_sigprocmask(struct thread *td, struct ibcs2_sigprocmask_args *uap)
343 {
344 ibcs2_sigset_t iss;
345 sigset_t oss, nss;
346 sigset_t *nssp;
347 int error, how;
348
349 switch (uap->how) {
350 case IBCS2_SIG_BLOCK:
351 how = SIG_BLOCK;
352 break;
353 case IBCS2_SIG_UNBLOCK:
354 how = SIG_UNBLOCK;
355 break;
356 case IBCS2_SIG_SETMASK:
357 how = SIG_SETMASK;
358 break;
359 default:
360 return (EINVAL);
361 }
362 if (uap->set != NULL) {
363 if ((error = copyin(uap->set, &iss, sizeof(iss))) != 0)
364 return error;
365 ibcs2_to_bsd_sigset(&iss, &nss);
366 nssp = &nss;
367 } else
368 nssp = NULL;
369 error = kern_sigprocmask(td, how, nssp, &oss, 0);
370 if (error == 0 && uap->oset != NULL) {
371 bsd_to_ibcs2_sigset(&oss, &iss);
372 error = copyout(&iss, uap->oset, sizeof(iss));
373 }
374 return (error);
375 }
376
377 int
ibcs2_sigpending(struct thread * td,struct ibcs2_sigpending_args * uap)378 ibcs2_sigpending(struct thread *td, struct ibcs2_sigpending_args *uap)
379 {
380 struct proc *p = td->td_proc;
381 sigset_t bss;
382 ibcs2_sigset_t iss;
383
384 PROC_LOCK(p);
385 bss = td->td_siglist;
386 SIGSETOR(bss, p->p_siglist);
387 SIGSETAND(bss, td->td_sigmask);
388 PROC_UNLOCK(p);
389 bsd_to_ibcs2_sigset(&bss, &iss);
390
391 return copyout(&iss, uap->mask, sizeof(iss));
392 }
393
394 int
ibcs2_sigsuspend(struct thread * td,struct ibcs2_sigsuspend_args * uap)395 ibcs2_sigsuspend(struct thread *td, struct ibcs2_sigsuspend_args *uap)
396 {
397 ibcs2_sigset_t sss;
398 sigset_t bss;
399 int error;
400
401 if ((error = copyin(uap->mask, &sss, sizeof(sss))) != 0)
402 return error;
403
404 ibcs2_to_bsd_sigset(&sss, &bss);
405 return kern_sigsuspend(td, bss);
406 }
407
408 int
ibcs2_pause(struct thread * td,struct ibcs2_pause_args * uap)409 ibcs2_pause(struct thread *td, struct ibcs2_pause_args *uap)
410 {
411 sigset_t mask;
412
413 PROC_LOCK(td->td_proc);
414 mask = td->td_sigmask;
415 PROC_UNLOCK(td->td_proc);
416 return kern_sigsuspend(td, mask);
417 }
418
419 int
ibcs2_kill(struct thread * td,struct ibcs2_kill_args * uap)420 ibcs2_kill(struct thread *td, struct ibcs2_kill_args *uap)
421 {
422 struct kill_args ka;
423
424 if (uap->signo <= 0 || uap->signo > IBCS2_NSIG)
425 return (EINVAL);
426 ka.pid = uap->pid;
427 ka.signum = ibcs2_to_bsd_sig[_SIG_IDX(uap->signo)];
428 return sys_kill(td, &ka);
429 }
430