ultrix_misc.c revision 1.115 1 /* $NetBSD: ultrix_misc.c,v 1.115 2008/08/08 16:21:44 bjs Exp $ */
2
3 /*
4 * Copyright (c) 1995, 1997 Jonathan Stone (hereinafter referred to as the author)
5 * All rights reserved.
6 *
7 * Redistribution and use in source and binary forms, with or without
8 * modification, are permitted provided that the following conditions
9 * are met:
10 * 1. Redistributions of source code must retain the above copyright
11 * notice, this list of conditions and the following disclaimer.
12 * 2. Redistributions in binary form must reproduce the above copyright
13 * notice, this list of conditions and the following disclaimer in the
14 * documentation and/or other materials provided with the distribution.
15 * 3. All advertising materials mentioning features or use of this software
16 * must display the following acknowledgement:
17 * This product includes software developed by Jonathan Stone for
18 * the NetBSD Project.
19 * 4. The name of the author may not be used to endorse or promote products
20 * derived from this software without specific prior written permission.
21 *
22 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND
23 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
24 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
25 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR BE LIABLE
26 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
27 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
28 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
29 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
30 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
31 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
32 * SUCH DAMAGE.
33 */
34
35 /*
36 * Copyright (c) 1992, 1993
37 * The Regents of the University of California. All rights reserved.
38 *
39 * This software was developed by the Computer Systems Engineering group
40 * at Lawrence Berkeley Laboratory under DARPA contract BG 91-66 and
41 * contributed to Berkeley.
42 *
43 * All advertising materials mentioning features or use of this software
44 * must display the following acknowledgement:
45 * This product includes software developed by the University of
46 * California, Lawrence Berkeley Laboratory.
47 *
48 * Redistribution and use in source and binary forms, with or without
49 * modification, are permitted provided that the following conditions
50 * are met:
51 * 1. Redistributions of source code must retain the above copyright
52 * notice, this list of conditions and the following disclaimer.
53 * 2. Redistributions in binary form must reproduce the above copyright
54 * notice, this list of conditions and the following disclaimer in the
55 * documentation and/or other materials provided with the distribution.
56 * 3. Neither the name of the University nor the names of its contributors
57 * may be used to endorse or promote products derived from this software
58 * without specific prior written permission.
59 *
60 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
61 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
62 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
63 * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
64 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
65 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
66 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
67 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
68 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
69 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
70 * SUCH DAMAGE.
71 *
72 *
73 * @(#)sun_misc.c 8.1 (Berkeley) 6/18/93
74 *
75 * from: Header: sun_misc.c,v 1.16 93/04/07 02:46:27 torek Exp
76 */
77
78 #include <sys/cdefs.h>
79 __KERNEL_RCSID(0, "$NetBSD: ultrix_misc.c,v 1.115 2008/08/08 16:21:44 bjs Exp $");
80
81 #if defined(_KERNEL_OPT)
82 #include "opt_nfsserver.h"
83 #include "opt_sysv.h"
84 #endif
85
86 #include <sys/cdefs.h> /* RCS ID & Copyright macro defns */
87
88 /*
89 * Ultrix compatibility module.
90 *
91 * Ultrix system calls that are implemented differently in BSD are
92 * handled here.
93 */
94
95 #if defined(_KERNEL_OPT)
96 #include "fs_nfs.h"
97 #endif
98
99 #include <sys/param.h>
100 #include <sys/systm.h>
101 #include <sys/namei.h>
102 #include <sys/dirent.h>
103 #include <sys/proc.h>
104 #include <sys/file.h>
105 #include <sys/filedesc.h>
106 #include <sys/kernel.h>
107 #include <sys/exec.h>
108 #include <sys/malloc.h>
109 #include <sys/mbuf.h>
110 #include <sys/mman.h>
111 #include <sys/mount.h>
112 #include <sys/resource.h>
113 #include <sys/resourcevar.h>
114 #include <sys/signal.h>
115 #include <sys/signalvar.h>
116 #include <sys/socket.h>
117 #include <sys/vnode.h>
118 #include <sys/uio.h>
119 #include <sys/wait.h>
120 #include <sys/utsname.h>
121 #include <sys/unistd.h>
122 #include <sys/ipc.h>
123
124 #include <sys/syscallargs.h>
125
126 #include <uvm/uvm_extern.h>
127
128 #include <compat/ultrix/ultrix_syscall.h>
129 #include <compat/ultrix/ultrix_syscallargs.h>
130 #include <compat/common/compat_util.h>
131
132 #include <netinet/in.h>
133
134 #include <miscfs/specfs/specdev.h>
135
136 #include <nfs/rpcv2.h>
137 #include <nfs/nfsproto.h>
138 #include <nfs/nfs.h>
139
140 #include <sys/socketvar.h> /* sosetopt() */
141
142 #include <compat/ultrix/ultrix_flock.h>
143
144 #include <compat/sys/signal.h>
145 #include <compat/sys/signalvar.h>
146
147 #ifdef __mips
148 #include <mips/cachectl.h>
149 #include <mips/frame.h>
150 #endif
151
152 static int ultrix_to_bsd_flock(struct ultrix_flock *, struct flock *);
153 static void bsd_to_ultrix_flock(struct flock *, struct ultrix_flock *);
154
155 extern struct sysent ultrix_sysent[];
156 extern const char * const ultrix_syscallnames[];
157 extern char ultrix_sigcode[], ultrix_esigcode[];
158
159 struct uvm_object *emul_ultrix_object;
160
161 #ifndef __HAVE_SYSCALL_INTERN
162 void syscall(void);
163 #endif
164
165 const struct emul emul_ultrix = {
166 "ultrix",
167 "/emul/ultrix",
168 #ifndef __HAVE_MINIMAL_EMUL
169 0,
170 NULL,
171 ULTRIX_SYS_syscall,
172 ULTRIX_SYS_NSYSENT,
173 #endif
174 ultrix_sysent,
175 ultrix_syscallnames,
176 #ifdef __mips
177 sendsig_sigcontext,
178 #else /* vax */
179 sendsig,
180 #endif
181 trapsignal,
182 NULL,
183 ultrix_sigcode,
184 ultrix_esigcode,
185 &emul_ultrix_object,
186 setregs,
187 NULL,
188 NULL,
189 NULL,
190 NULL,
191 NULL,
192 #ifdef __HAVE_SYSCALL_INTERN
193 syscall_intern,
194 #else
195 syscall,
196 #endif
197 NULL,
198 NULL,
199
200 uvm_default_mapaddr,
201 NULL,
202 0,
203 NULL
204 };
205
206 #define GSI_PROG_ENV 1
207
208 int
209 ultrix_sys_getsysinfo(struct lwp *l, const struct ultrix_sys_getsysinfo_args *uap, register_t *retval)
210 {
211 static short progenv = 0;
212
213 switch (SCARG(uap, op)) {
214 /* operations implemented: */
215 case GSI_PROG_ENV:
216 if (SCARG(uap, nbytes) < sizeof(short))
217 return EINVAL;
218 *retval = 1;
219 return copyout(&progenv, SCARG(uap, buffer), sizeof(progenv));
220 default:
221 *retval = 0; /* info unavail */
222 return 0;
223 }
224 }
225
226 int
227 ultrix_sys_setsysinfo(struct lwp *l, const struct ultrix_sys_setsysinfo_args *uap, register_t *retval)
228 {
229
230 *retval = 0;
231 return 0;
232 }
233
234 int
235 ultrix_sys_waitpid(struct lwp *l, const struct ultrix_sys_waitpid_args *uap, register_t *retval)
236 {
237 struct sys_wait4_args ap;
238
239 SCARG(&ap, pid) = SCARG(uap, pid);
240 SCARG(&ap, status) = SCARG(uap, status);
241 SCARG(&ap, options) = SCARG(uap, options);
242 SCARG(&ap, rusage) = 0;
243
244 return sys_wait4(l, &ap, retval);
245 }
246
247 int
248 ultrix_sys_wait3(struct lwp *l, const struct ultrix_sys_wait3_args *uap, register_t *retval)
249 {
250 struct sys_wait4_args ap;
251
252 SCARG(&ap, pid) = -1;
253 SCARG(&ap, status) = SCARG(uap, status);
254 SCARG(&ap, options) = SCARG(uap, options);
255 SCARG(&ap, rusage) = SCARG(uap, rusage);
256
257 return sys_wait4(l, &ap, retval);
258 }
259
260 /*
261 * Ultrix binaries pass in FD_MAX as the first arg to select().
262 * On Ultrix, FD_MAX is 4096, which is more than the NetBSD sys_select()
263 * can handle.
264 * Since we can't have more than the (native) FD_MAX descriptors open,
265 * limit nfds to at most FD_MAX.
266 */
267 int
268 ultrix_sys_select(struct lwp *l, const struct ultrix_sys_select_args *uap, register_t *retval)
269 {
270 struct timeval atv;
271 int error;
272 struct sys_select_args ap;
273
274 /* Limit number of FDs selected on to the native maximum */
275
276 if (SCARG(uap, nd) > FD_SETSIZE)
277 SCARG(&ap, nd) = FD_SETSIZE;
278 else
279 SCARG(&ap, nd) = SCARG(uap, nd);
280
281 SCARG(&ap, in) = SCARG(uap, in);
282 SCARG(&ap, ou) = SCARG(uap, ou);
283 SCARG(&ap, ex) = SCARG(uap, ex);
284 SCARG(&ap, tv) = SCARG(uap, tv);
285 /* Check for negative timeval */
286 if (SCARG(&ap, tv)) {
287 error = copyin(SCARG(uap, tv), &atv, sizeof(atv));
288 if (error)
289 goto done;
290 #ifdef DEBUG
291 /* Ultrix clients sometimes give negative timeouts? */
292 if (atv.tv_sec < 0 || atv.tv_usec < 0)
293 printf("ultrix select( %ld, %ld): negative timeout\n",
294 atv.tv_sec, atv.tv_usec);
295 #endif
296
297 }
298 error = sys_select(l, &ap, retval);
299 if (error == EINVAL)
300 printf("ultrix select: bad args?\n");
301
302 done:
303 return error;
304 }
305
306 #if defined(NFS)
307 int
308 async_daemon(struct lwp *l, const void *v, register_t *retval)
309 {
310 struct sys_nfssvc_args ouap;
311
312 SCARG(&ouap, flag) = NFSSVC_BIOD;
313 SCARG(&ouap, argp) = NULL;
314
315 return sys_nfssvc(l, &ouap, retval);
316 }
317 #endif /* NFS */
318
319
320 #define SUN__MAP_NEW 0x80000000 /* if not, old mmap & cannot handle */
321
322 int
323 ultrix_sys_mmap(struct lwp *l, const struct ultrix_sys_mmap_args *uap, register_t *retval)
324 {
325 struct sys_mmap_args ouap;
326
327 /*
328 * Verify the arguments.
329 */
330 if (SCARG(uap, prot) & ~(PROT_READ|PROT_WRITE|PROT_EXEC))
331 return EINVAL; /* XXX still needed? */
332
333 if ((SCARG(uap, flags) & SUN__MAP_NEW) == 0)
334 return EINVAL;
335
336 SCARG(&ouap, flags) = SCARG(uap, flags) & ~SUN__MAP_NEW;
337 SCARG(&ouap, addr) = SCARG(uap, addr);
338 SCARG(&ouap, len) = SCARG(uap, len);
339 SCARG(&ouap, prot) = SCARG(uap, prot);
340 SCARG(&ouap, fd) = SCARG(uap, fd);
341 SCARG(&ouap, pos) = SCARG(uap, pos);
342
343 return sys_mmap(l, &ouap, retval);
344 }
345
346 int
347 ultrix_sys_setsockopt(struct lwp *l, const struct ultrix_sys_setsockopt_args *uap, register_t *retval)
348 {
349 struct sockopt sopt;
350 struct socket *so;
351 int error;
352 struct sys_setsockopt_args ap;
353
354 SCARG(&ap, s) = SCARG(uap, s);
355 SCARG(&ap, level) = SCARG(uap, level);
356 SCARG(&ap, name) = SCARG(uap, name);
357 SCARG(&ap, val) = SCARG(uap, val);
358 SCARG(&ap, valsize) = SCARG(uap, valsize);
359
360 /* fd_getsock() will use the descriptor for us */
361 if ((error = fd_getsock(SCARG(&ap, s), &so)) != 0)
362 return error;
363 #define SO_DONTLINGER (~SO_LINGER)
364 if (SCARG(&ap, name) == SO_DONTLINGER) {
365 struct linger lg;
366
367 lg.l_onoff = 0;
368 error = so_setsockopt(l, so, SCARG(&ap, level), SO_LINGER,
369 &lg, sizeof(lg));
370 goto out;
371 }
372 if (SCARG(&ap, level) == IPPROTO_IP) {
373 #define EMUL_IP_MULTICAST_IF 2
374 #define EMUL_IP_MULTICAST_TTL 3
375 #define EMUL_IP_MULTICAST_LOOP 4
376 #define EMUL_IP_ADD_MEMBERSHIP 5
377 #define EMUL_IP_DROP_MEMBERSHIP 6
378 static const int ipoptxlat[] = {
379 IP_MULTICAST_IF,
380 IP_MULTICAST_TTL,
381 IP_MULTICAST_LOOP,
382 IP_ADD_MEMBERSHIP,
383 IP_DROP_MEMBERSHIP
384 };
385 if (SCARG(&ap, name) >= EMUL_IP_MULTICAST_IF &&
386 SCARG(&ap, name) <= EMUL_IP_DROP_MEMBERSHIP) {
387 SCARG(&ap, name) =
388 ipoptxlat[SCARG(&ap, name) - EMUL_IP_MULTICAST_IF];
389 }
390 }
391 if (SCARG(&ap, valsize) > MLEN) {
392 error = EINVAL;
393 goto out;
394 }
395 sockopt_init(&sopt, SCARG(&ap, level), SCARG(&ap, name),
396 SCARG(&ap, valsize));
397 if (SCARG(&ap, val)) {
398 error = copyin(SCARG(&ap, val), sopt.sopt_data,
399 (u_int)SCARG(&ap, valsize));
400 }
401 if (error == 0)
402 error = sosetopt(so, &sopt);
403 sockopt_destroy(&sopt);
404 out:
405 fd_putfile(SCARG(uap, s));
406 return error;
407 }
408
409 #define ULTRIX__SYS_NMLN 32
410
411 struct ultrix_utsname {
412 char sysname[ULTRIX__SYS_NMLN];
413 char nodename[ULTRIX__SYS_NMLN];
414 char release[ULTRIX__SYS_NMLN];
415 char version[ULTRIX__SYS_NMLN];
416 char machine[ULTRIX__SYS_NMLN];
417 };
418
419 int
420 ultrix_sys_uname(struct lwp *l, const struct ultrix_sys_uname_args *uap, register_t *retval)
421 {
422 struct ultrix_utsname sut;
423 const char *cp;
424 char *dp, *ep;
425
426 memset(&sut, 0, sizeof(sut));
427
428 strncpy(sut.sysname, ostype, sizeof(sut.sysname) - 1);
429 strncpy(sut.nodename, hostname, sizeof(sut.nodename) - 1);
430 strncpy(sut.release, osrelease, sizeof(sut.release) - 1);
431 dp = sut.version;
432 ep = &sut.version[sizeof(sut.version) - 1];
433 for (cp = version; *cp && *cp != '('; cp++)
434 ;
435 for (cp++; *cp && *cp != ')' && dp < ep; cp++)
436 *dp++ = *cp;
437 for (; *cp && *cp != '#'; cp++)
438 ;
439 for (; *cp && *cp != ':' && dp < ep; cp++)
440 *dp++ = *cp;
441 *dp = '\0';
442 strncpy(sut.machine, machine, sizeof(sut.machine) - 1);
443
444 return copyout(&sut, SCARG(uap, name), sizeof(sut));
445 }
446
447 int
448 ultrix_sys_setpgrp(struct lwp *l, const struct ultrix_sys_setpgrp_args *uap, register_t *retval)
449 {
450 struct proc *p = l->l_proc;
451 struct sys_setpgid_args ap;
452
453 SCARG(&ap, pid) = SCARG(uap, pid);
454 SCARG(&ap, pgid) = SCARG(uap, pgid);
455 /*
456 * difference to our setpgid call is to include backwards
457 * compatibility to pre-setsid() binaries. Do setsid()
458 * instead of setpgid() in those cases where the process
459 * tries to create a new session the old way.
460 */
461 if (!SCARG(&ap, pgid) &&
462 (!SCARG(&ap, pid) || SCARG(&ap, pid) == p->p_pid))
463 return sys_setsid(l, &ap, retval);
464 else
465 return sys_setpgid(l, &ap, retval);
466 }
467
468 #if defined (NFSSERVER)
469 int
470 ultrix_sys_nfssvc(struct lwp *l, const struct ultrix_sys_nfssvc_args *uap,
471 register_t *retval)
472 {
473
474 #if 0 /* XXX */
475 struct emul *e = p->p_emul;
476 struct sys_nfssvc_args outuap;
477 struct sockaddr sa;
478 int error;
479 void *sg = stackgap_init(p, 0);
480
481 memset(&outuap, 0, sizeof outuap);
482 SCARG(&outuap, fd) = SCARG(uap, fd);
483 SCARG(&outuap, mskval) = stackgap_alloc(p, &sg, sizeof sa);
484 SCARG(&outuap, msklen) = sizeof sa;
485 SCARG(&outuap, mtchval) = stackgap_alloc(p, &sg, sizeof sa);
486 SCARG(&outuap, mtchlen) = sizeof sa;
487
488 memset(&sa, 0, sizeof sa);
489 if (error = copyout(&sa, SCARG(&outuap, mskval), SCARG(&outuap, msklen)))
490 return error;
491 if (error = copyout(&sa, SCARG(&outuap, mtchval), SCARG(&outuap, mtchlen)))
492 return error;
493
494 return nfssvc(l, &outuap, retval);
495 #else
496 return ENOSYS;
497 #endif
498 }
499 #endif /* NFSSERVER */
500
501 struct ultrix_ustat {
502 daddr_t f_tfree; /* total free */
503 uint32_t f_tinode; /* total inodes free */
504 char f_fname[6]; /* filsys name */
505 char f_fpack[6]; /* filsys pack name */
506 };
507
508 int
509 ultrix_sys_ustat(struct lwp *l, const struct ultrix_sys_ustat_args *uap, register_t *retval)
510 {
511 struct ultrix_ustat us;
512 int error;
513
514 memset(&us, 0, sizeof us);
515
516 /*
517 * XXX: should set f_tfree and f_tinode at least
518 * How do we translate dev -> fstat? (and then to ultrix_ustat)
519 */
520
521 if ((error = copyout(&us, SCARG(uap, buf), sizeof us)) != 0)
522 return error;
523 return 0;
524 }
525
526 int
527 ultrix_sys_quotactl(struct lwp *l, const struct ultrix_sys_quotactl_args *uap, register_t *retval)
528 {
529
530 return EINVAL;
531 }
532
533 int
534 ultrix_sys_vhangup(struct lwp *l, const void *uap, register_t *retval)
535 {
536
537 return 0;
538 }
539
540
541 /*
542 * RISC Ultrix cache control syscalls
543 */
544 #ifdef __mips
545 int
546 ultrix_sys_cacheflush(struct lwp *l, const struct ultrix_sys_cacheflush_args *uap, register_t *retval)
547 {
548 /* {
549 syscallarg(void *) addr;
550 syscallarg(unsigned) nbytes;
551 syscallarg(int) flag;
552 } */
553 struct proc *p = l->l_proc;
554 vaddr_t va = (vaddr_t)SCARG(uap, addr);
555 int nbytes = SCARG(uap, nbytes);
556 int whichcache = SCARG(uap, whichcache);
557
558 return mips_user_cacheflush(p, va, nbytes, whichcache);
559 }
560
561
562 int
563 ultrix_sys_cachectl(struct lwp *l, const struct ultrix_sys_cachectl_args *uap, register_t *retval)
564 {
565 /* {
566 syscallarg(void *) addr;
567 syscallarg(int) nbytes;
568 syscallarg(int) cacheop;
569 } */
570 struct proc *p = l->l_proc;
571 vaddr_t va = (vaddr_t)SCARG(uap, addr);
572 int nbytes = SCARG(uap, nbytes);
573 int cacheop = SCARG(uap, cacheop);
574
575 return mips_user_cachectl(p, va, nbytes, cacheop);
576 }
577
578 #endif /* __mips */
579
580
581 int
582 ultrix_sys_exportfs(struct lwp *l, const struct ultrix_sys_exportfs_args *uap, register_t *retval)
583 {
584
585 /*
586 * XXX: should perhaps translate into a mount(2)
587 * with MOUNT_EXPORT?
588 */
589 return 0;
590 }
591
592 int
593 ultrix_sys_sigpending(struct lwp *l, const struct ultrix_sys_sigpending_args *uap, register_t *retval)
594 {
595 sigset_t ss;
596 int mask;
597
598 sigpending1(l, &ss);
599 mask = ss.__bits[0];
600
601 return copyout(&mask, SCARG(uap, mask), sizeof(int));
602 }
603
604 int
605 ultrix_sys_sigreturn(struct lwp *l, const struct ultrix_sys_sigreturn_args *uap, register_t *retval)
606 {
607 /* struct sigcontext13 is close enough to Ultrix */
608 struct compat_13_sys_sigreturn_args ap;
609
610 SCARG(&ap, sigcntxp) = (void *)SCARG(uap, sigcntxp);
611
612 return compat_13_sys_sigreturn(l, &ap, retval);
613 }
614
615 int
616 ultrix_sys_sigcleanup(struct lwp *l, const struct ultrix_sys_sigcleanup_args *uap, register_t *retval)
617 {
618
619 /* struct sigcontext13 is close enough to Ultrix */
620 struct compat_13_sys_sigreturn_args ap;
621
622 SCARG(&ap, sigcntxp) = (void *)SCARG(uap, sigcntxp);
623
624 return compat_13_sys_sigreturn(l, &ap, retval);
625 }
626
627 int
628 ultrix_sys_sigsuspend(struct lwp *l, const struct ultrix_sys_sigsuspend_args *uap, register_t *retval)
629 {
630 int mask = SCARG(uap, mask);
631 sigset_t ss;
632
633 ss.__bits[0] = mask;
634 ss.__bits[1] = 0;
635 ss.__bits[2] = 0;
636 ss.__bits[3] = 0;
637
638 return sigsuspend1(l, &ss);
639 }
640
641 #define ULTRIX_SV_ONSTACK 0x0001 /* take signal on signal stack */
642 #define ULTRIX_SV_INTERRUPT 0x0002 /* do not restart system on signal return */
643 #define ULTRIX_SV_OLDSIG 0x1000 /* Emulate old signal() for POSIX */
644
645 int
646 ultrix_sys_sigvec(struct lwp *l, const struct ultrix_sys_sigvec_args *uap, register_t *retval)
647 {
648 struct sigvec nsv, osv;
649 struct sigaction nsa, osa;
650 int error;
651
652 if (SCARG(uap, nsv)) {
653 error = copyin(SCARG(uap, nsv), &nsv, sizeof(nsv));
654 if (error)
655 return error;
656 nsa.sa_handler = nsv.sv_handler;
657 #if 0 /* documentation */
658 /* ONSTACK is identical */
659 nsa.sa_flags = nsv.sv_flags & ULTRIX_SV_ONSTACK;
660 if ((nsv.sv_flags & ULTRIX_SV_OLDSIG)
661 /* old signal() - always restart */
662 || (!(nsv.sv_flags & ULTRIX_SV_INTERRUPT))
663 /* inverted meaning (same bit) */
664 )
665 nsa.sa_flags |= SA_RESTART;
666 #else /* optimized - assuming ULTRIX_SV_OLDSIG=>!ULTRIX_SV_INTERRUPT */
667 nsa.sa_flags = nsv.sv_flags & ~ULTRIX_SV_OLDSIG;
668 nsa.sa_flags ^= SA_RESTART;
669 #endif
670 native_sigset13_to_sigset(&nsv.sv_mask, &nsa.sa_mask);
671 }
672 error = sigaction1(l, SCARG(uap, signum),
673 SCARG(uap, nsv) ? &nsa : 0, SCARG(uap, osv) ? &osa : 0,
674 NULL, 0);
675 if (error)
676 return error;
677 if (SCARG(uap, osv)) {
678 osv.sv_handler = osa.sa_handler;
679 osv.sv_flags = osa.sa_flags ^ SA_RESTART;
680 osv.sv_flags &= (ULTRIX_SV_ONSTACK | ULTRIX_SV_INTERRUPT);
681 native_sigset_to_sigset13(&osa.sa_mask, &osv.sv_mask);
682 error = copyout(&osv, SCARG(uap, osv), sizeof(osv));
683 if (error)
684 return error;
685 }
686 return 0;
687 }
688
689 int
690 ultrix_sys_shmsys(struct lwp *l, const struct ultrix_sys_shmsys_args *uap, register_t *retval)
691 {
692
693 #ifdef SYSVSHM
694 /* Ultrix SVSHM weirndess: */
695 struct sys_shmat_args shmat_args;
696 struct compat_14_sys_shmctl_args shmctl_args;
697 struct sys_shmdt_args shmdt_args;
698 struct sys_shmget_args shmget_args;
699
700
701 switch (SCARG(uap, shmop)) {
702 case 0: /* Ultrix shmat() */
703 SCARG(&shmat_args, shmid) = SCARG(uap, a2);
704 SCARG(&shmat_args, shmaddr) = (void *)SCARG(uap, a3);
705 SCARG(&shmat_args, shmflg) = SCARG(uap, a4);
706 return sys_shmat(l, &shmat_args, retval);
707
708 case 1: /* Ultrix shmctl() */
709 SCARG(&shmctl_args, shmid) = SCARG(uap, a2);
710 SCARG(&shmctl_args, cmd) = SCARG(uap, a3);
711 SCARG(&shmctl_args, buf) = (struct shmid_ds14 *)SCARG(uap, a4);
712 return compat_14_sys_shmctl(l, &shmctl_args, retval);
713
714 case 2: /* Ultrix shmdt() */
715 SCARG(&shmat_args, shmaddr) = (void *)SCARG(uap, a2);
716 return sys_shmdt(l, &shmdt_args, retval);
717
718 case 3: /* Ultrix shmget() */
719 SCARG(&shmget_args, key) = SCARG(uap, a2);
720 SCARG(&shmget_args, size) = SCARG(uap, a3);
721 SCARG(&shmget_args, shmflg) = SCARG(uap, a4)
722 & (IPC_CREAT|IPC_EXCL|IPC_NOWAIT);
723 return sys_shmget(l, &shmget_args, retval);
724
725 default:
726 return EINVAL;
727 }
728 #else
729 return EOPNOTSUPP;
730 #endif /* SYSVSHM */
731 }
732
733 static int
734 ultrix_to_bsd_flock(struct ultrix_flock *ufl, struct flock *fl)
735 {
736
737 fl->l_start = ufl->l_start;
738 fl->l_len = ufl->l_len;
739 fl->l_pid = ufl->l_pid;
740 fl->l_whence = ufl->l_whence;
741
742 switch (ufl->l_type) {
743 case ULTRIX_F_RDLCK:
744 fl->l_type = F_RDLCK;
745 break;
746 case ULTRIX_F_WRLCK:
747 fl->l_type = F_WRLCK;
748 break;
749 case ULTRIX_F_UNLCK:
750 fl->l_type = F_UNLCK;
751 break;
752 default:
753 return EINVAL;
754 }
755
756 return 0;
757 }
758
759 static void
760 bsd_to_ultrix_flock(struct flock *fl, struct ultrix_flock *ufl)
761 {
762
763 ufl->l_start = fl->l_start;
764 ufl->l_len = fl->l_len;
765 ufl->l_pid = fl->l_pid;
766 ufl->l_whence = fl->l_whence;
767
768 switch (fl->l_type) {
769 case F_RDLCK:
770 ufl->l_type = ULTRIX_F_RDLCK;
771 break;
772 case F_WRLCK:
773 ufl->l_type = ULTRIX_F_WRLCK;
774 break;
775 case F_UNLCK:
776 ufl->l_type = ULTRIX_F_UNLCK;
777 break;
778 }
779 }
780
781 int
782 ultrix_sys_fcntl(struct lwp *l, const struct ultrix_sys_fcntl_args *uap, register_t *retval)
783 {
784 int error;
785 struct ultrix_flock ufl;
786 struct flock fl;
787
788 switch (SCARG(uap, cmd)) {
789 case F_GETLK:
790 case F_SETLK:
791 case F_SETLKW:
792 error = copyin(SCARG(uap, arg), &ufl, sizeof(ufl));
793 if (error)
794 return error;
795 error = ultrix_to_bsd_flock(&ufl, &fl);
796 if (error)
797 return error;
798 error = do_fcntl_lock(SCARG(uap, fd), SCARG(uap, cmd), &fl);
799 if (SCARG(uap, cmd) != F_GETLK || error != 0)
800 return error;
801 bsd_to_ultrix_flock(&fl, &ufl);
802 return copyout(&ufl, SCARG(uap, arg), sizeof(ufl));
803
804 default:
805 break;
806 }
807
808 return sys_fcntl(l, (const void *)uap, retval);
809 }
810