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