root/compat/ibcs2/ibcs2_misc.c

DEFINITIONS

1. ibcs2_sys_ulimit
2. ibcs2_sys_waitsys
3. ibcs2_sys_execv
4. ibcs2_sys_execve
5. ibcs2_sys_umount
6. ibcs2_sys_mount
7. ibcs2_readdir_callback
8. ibcs2_classicread_callback
9. ibcs2_sys_getdents
10. ibcs2_sys_read
11. ibcs2_sys_mknod
12. ibcs2_sys_getgroups
13. ibcs2_sys_setgroups
14. ibcs2_sys_setuid
15. ibcs2_sys_setgid
16. xenix_sys_ftime
17. ibcs2_sys_time
18. ibcs2_sys_pathconf
19. ibcs2_sys_fpathconf
20. ibcs2_sys_sysconf
21. ibcs2_sys_alarm
22. ibcs2_sys_getmsg
23. ibcs2_sys_putmsg
24. ibcs2_sys_times
25. ibcs2_sys_stime
26. ibcs2_sys_utime
27. ibcs2_sys_nice
28. ibcs2_sys_pgrpsys
29. ibcs2_sys_plock
30. ibcs2_sys_uadmin
31. ibcs2_sys_sysfs
32. xenix_sys_rdchk
33. xenix_sys_chsize
34. xenix_sys_nap
35. ibcs2_sys_unlink
36. ibcs2_sys_chdir
37. ibcs2_sys_chmod
38. ibcs2_sys_chown
39. ibcs2_sys_rmdir
40. ibcs2_sys_mkdir
41. ibcs2_sys_symlink
42. ibcs2_sys_rename
43. ibcs2_sys_readlink
44. ibcs2_sys_sysi86

    1 /*      $OpenBSD: ibcs2_misc.c,v 1.28 2004/06/22 23:52:18 jfb Exp $     */
    2 /*      $NetBSD: ibcs2_misc.c,v 1.23 1997/01/15 01:37:49 perry Exp $    */
    4 /*
    5  * Copyright (c) 1994, 1995 Scott Bartram
    6  * Copyright (c) 1992, 1993
    7  *      The Regents of the University of California.  All rights reserved.
    8  *
    9  * This software was developed by the Computer Systems Engineering group
   10  * at Lawrence Berkeley Laboratory under DARPA contract BG 91-66 and
   11  * contributed to Berkeley.
   12  *
   13  * All advertising materials mentioning features or use of this software
   14  * must display the following acknowledgement:
   15  *      This product includes software developed by the University of
   16  *      California, Lawrence Berkeley Laboratory.
   17  *
   18  * Redistribution and use in source and binary forms, with or without
   19  * modification, are permitted provided that the following conditions
   20  * are met:
   21  * 1. Redistributions of source code must retain the above copyright
   22  *    notice, this list of conditions and the following disclaimer.
   23  * 2. Redistributions in binary form must reproduce the above copyright
   24  *    notice, this list of conditions and the following disclaimer in the
   25  *    documentation and/or other materials provided with the distribution.
   26  * 3. Neither the name of the University nor the names of its contributors
   27  *    may be used to endorse or promote products derived from this software
   28  *    without specific prior written permission.
   29  *
   30  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
   31  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
   32  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
   33  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
   34  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
   35  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
   36  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
   37  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
   38  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
   39  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
   40  * SUCH DAMAGE.
   41  *
   42  * from: Header: sun_misc.c,v 1.16 93/04/07 02:46:27 torek Exp 
   43  *
   44  *      @(#)sun_misc.c  8.1 (Berkeley) 6/18/93
   45  */
   47 /*
   48  * IBCS2 compatibility module.
   49  *
   50  * IBCS2 system calls that are implemented differently in BSD are
   51  * handled here.
   52  */
   54 #include <sys/param.h>
   55 #include <sys/systm.h>
   56 #include <sys/namei.h>
   57 #include <sys/dirent.h>
   58 #include <sys/proc.h>
   59 #include <sys/file.h>
   60 #include <sys/filedesc.h>
   61 #include <sys/ioctl.h>
   62 #include <sys/kernel.h>
   63 #include <sys/malloc.h>
   64 #include <sys/mbuf.h>
   65 #include <sys/mman.h>
   66 #include <sys/mount.h>
   67 #include <sys/reboot.h>
   68 #include <sys/resource.h>
   69 #include <sys/resourcevar.h>
   70 #include <sys/socket.h>
   71 #include <sys/stat.h>
   72 #include <sys/time.h>
   73 #include <sys/times.h>
   74 #include <sys/vnode.h>
   75 #include <sys/uio.h>
   76 #include <sys/wait.h>
   77 #include <sys/utsname.h>
   78 #include <sys/unistd.h>
   80 #include <netinet/in.h>
   81 #include <sys/syscallargs.h>
   83 #include <miscfs/specfs/specdev.h>
   85 #include <uvm/uvm_extern.h>
   86 #include <sys/sysctl.h>         /* must be included after vm.h */
   88 #include <i386/include/reg.h>
   90 #include <compat/ibcs2/ibcs2_types.h>
   91 #include <compat/ibcs2/ibcs2_dirent.h>
   92 #include <compat/ibcs2/ibcs2_fcntl.h>
   93 #include <compat/ibcs2/ibcs2_time.h>
   94 #include <compat/ibcs2/ibcs2_signal.h>
   95 #include <compat/ibcs2/ibcs2_timeb.h>
   96 #include <compat/ibcs2/ibcs2_unistd.h>
   97 #include <compat/ibcs2/ibcs2_utsname.h>
   98 #include <compat/ibcs2/ibcs2_util.h>
   99 #include <compat/ibcs2/ibcs2_utime.h>
  100 #include <compat/ibcs2/ibcs2_syscallargs.h>
  101 #include <compat/ibcs2/ibcs2_sysi86.h>
  103 #include <compat/common/compat_dir.h>
  105 int
ibcs2_sys_ulimit(p, v, retval)
  107         struct proc *p;
  108         void *v;
register_t *retval;
  110 {
  111         struct ibcs2_sys_ulimit_args /* {
  112                 syscallarg(int) cmd;
  113                 syscallarg(int) newlimit;
  114         } */ *uap = v;
  115 #ifdef notyet
  116         int error;
  117         struct rlimit rl;
  118         struct sys_setrlimit_args sra;
  119 #endif
  120 #define IBCS2_GETFSIZE          1
  121 #define IBCS2_SETFSIZE          2
  122 #define IBCS2_GETPSIZE          3
  123 #define IBCS2_GETDTABLESIZE     4
  125         switch (SCARG(uap, cmd)) {
  126         case IBCS2_GETFSIZE:
  127                 *retval = p->p_rlimit[RLIMIT_FSIZE].rlim_cur;
  128                 return 0;
  129         case IBCS2_SETFSIZE:    /* XXX - fix this */
  130 #ifdef notyet
rl.rlim_cur = SCARG(uap, newlimit);
SCARG(&sra, which) = RLIMIT_FSIZE;
SCARG(&sra, rlp) = &rl;
error = setrlimit(p, &sra, retval);
  135                 if (!error)
  136                         *retval = p->p_rlimit[RLIMIT_FSIZE].rlim_cur;
  137                 else
DPRINTF(("failed "));
  139                 return error;
  140 #else
  141                 *retval = SCARG(uap, newlimit);
  142                 return 0;
  143 #endif
  144         case IBCS2_GETPSIZE:
  145                 *retval = p->p_rlimit[RLIMIT_RSS].rlim_cur; /* XXX */
  146                 return 0;
  147         case IBCS2_GETDTABLESIZE:
SCARG(uap, cmd) = IBCS2_SC_OPEN_MAX;
  149                 return ibcs2_sys_sysconf(p, uap, retval);
  150         default:
  151                 return ENOSYS;
  152         }
  153 }
  155 int
ibcs2_sys_waitsys(p, v, retval)
  157         struct proc *p;
  158         void *v;
register_t *retval;
  160 {
  161         struct ibcs2_sys_waitsys_args /* {
  162                 syscallarg(int) a1;
  163                 syscallarg(int) a2;
  164                 syscallarg(int) a3;
  165         } */ *uap = v;
  166         int error;
  167         struct sys_wait4_args w4;
  168 #define WAITPID_EFLAGS  0x8c4   /* OF, SF, ZF, PF */
SCARG(&w4, rusage) = NULL;
  171         if ((p->p_md.md_regs->tf_eflags & WAITPID_EFLAGS) == WAITPID_EFLAGS) {
  172                 /* waitpid */
SCARG(&w4, pid) = SCARG(uap, a1);
SCARG(&w4, status) = (int *)SCARG(uap, a2);
SCARG(&w4, options) = SCARG(uap, a3);
  176         } else {
  177                 /* wait */
SCARG(&w4, pid) = WAIT_ANY;
SCARG(&w4, status) = (int *)SCARG(uap, a1);
SCARG(&w4, options) = 0;
  181         }
  182         if ((error = sys_wait4(p, &w4, retval)) != 0)
  183                 return error;
  184         if (SCARG(&w4, status))         /* this is real iBCS brain-damage */
  185                 return copyin((caddr_t)SCARG(&w4, status), (caddr_t)&retval[1],
  186                               sizeof(SCARG(&w4, status)));
  187         return 0;
  188 }
  190 int
ibcs2_sys_execv(p, v, retval)
  192         struct proc *p;
  193         void *v;
register_t *retval;
  195 {
  196         struct ibcs2_sys_execv_args /* {
  197                 syscallarg(char *) path;
  198                 syscallarg(char **) argp;
  199         } */ *uap = v;
  200         struct sys_execve_args ap;
caddr_t sg;
sg = stackgap_init(p->p_emul);
IBCS2_CHECK_ALT_EXIST(p, &sg, SCARG(uap, path));
SCARG(&ap, path) = SCARG(uap, path);
SCARG(&ap, argp) = SCARG(uap, argp);
SCARG(&ap, envp) = NULL;
  210         return sys_execve(p, &ap, retval);
  211 }
  213 int
ibcs2_sys_execve(p, v, retval) 
  215         struct proc *p;
  216         void *v;
register_t *retval;
  218 {
  219         struct ibcs2_sys_execve_args /* {
  220                 syscallarg(char *) path;
  221                 syscallarg(char **) argv;
  222                 syscallarg(char **) envp;
  223         } */ *uap = v;
  224         struct sys_execve_args ap;
caddr_t sg;
sg = stackgap_init(p->p_emul);
IBCS2_CHECK_ALT_EXIST(p, &sg, SCARG(uap, path));
SCARG(&ap, path) = SCARG(uap, path);
SCARG(&ap, argp) = SCARG(uap, argp);
SCARG(&ap, envp) = SCARG(uap, envp);
  234         return sys_execve(p, &ap, retval);
  235 }
  237 int
ibcs2_sys_umount(p, v, retval)
  239         struct proc *p;
  240         void *v;
register_t *retval;
  242 {
  243         struct ibcs2_sys_umount_args /* {
  244                 syscallarg(char *) name;
  245         } */ *uap = v;
  246         struct sys_unmount_args um;
SCARG(&um, path) = SCARG(uap, name);
SCARG(&um, flags) = 0;
  250         return sys_unmount(p, &um, retval);
  251 }
  253 int
ibcs2_sys_mount(p, v, retval)
  255         struct proc *p;
  256         void *v;
register_t *retval;
  258 {
  259 #ifdef notyet
  260         struct ibcs2_sys_mount_args /* {
  261                 syscallarg(char *) special;
  262                 syscallarg(char *) dir;
  263                 syscallarg(int) flags;
  264                 syscallarg(int) fstype;
  265                 syscallarg(char *) data;
  266                 syscallarg(int) len;
  267         } */ *uap = v;
  268         int oflags = SCARG(uap, flags), nflags, error;
  269         char fsname[MFSNAMELEN];
  271         if (oflags & (IBCS2_MS_NOSUB | IBCS2_MS_SYS5))
  272                 return (EINVAL);
  273         if ((oflags & IBCS2_MS_NEWTYPE) == 0)
  274                 return (EINVAL);
nflags = 0;
  276         if (oflags & IBCS2_MS_RDONLY)
nflags |= MNT_RDONLY;
  278         if (oflags & IBCS2_MS_NOSUID)
nflags |= MNT_NOSUID;
  280         if (oflags & IBCS2_MS_REMOUNT)
nflags |= MNT_UPDATE;
SCARG(uap, flags) = nflags;
  284         if (error = copyinstr((caddr_t)SCARG(uap, type), fsname, sizeof fsname,
  285                               (u_int *)0))
  286                 return (error);
  288         if (strncmp(fsname, "4.2", sizeof fsname) == 0) {
SCARG(uap, type) = (caddr_t)STACK_ALLOC();
  290                 if (error = copyout("ffs", SCARG(uap, type), sizeof("ffs")))
  291                         return (error);
  292         } else if (strncmp(fsname, "nfs", sizeof fsname) == 0) {
  293                 struct ibcs2_nfs_args sna;
  294                 struct sockaddr_in sain;
  295                 struct nfs_args na;
  296                 struct sockaddr sa;
  298                 if (error = copyin(SCARG(uap, data), &sna, sizeof sna))
  299                         return (error);
  300                 if (error = copyin(sna.addr, &sain, sizeof sain))
  301                         return (error);
bcopy(&sain, &sa, sizeof sa);
sa.sa_len = sizeof(sain);
SCARG(uap, data) = (caddr_t)STACK_ALLOC();
na.addr = (struct sockaddr *)((int)SCARG(uap, data) + sizeof na);
na.sotype = SOCK_DGRAM;
na.proto = IPPROTO_UDP;
na.fh = (nfsv2fh_t *)sna.fh;
na.flags = sna.flags;
na.wsize = sna.wsize;
na.rsize = sna.rsize;
na.timeo = sna.timeo;
na.retrans = sna.retrans;
na.hostname = sna.hostname;
  316                 if (error = copyout(&sa, na.addr, sizeof sa))
  317                         return (error);
  318                 if (error = copyout(&na, SCARG(uap, data), sizeof na))
  319                         return (error);
  320         }
  321         return (sys_mount(p, uap, retval));
  322 #else
  323         return EINVAL;
  324 #endif
  325 }
  327 /*
  328  * Read iBCS2-style directory entries.  We suck them into kernel space so
  329  * that they can be massaged before being copied out to user code.  Like
  330  * SunOS, we squish out `empty' entries.
  331  *
  332  * This is quite ugly, but what do you expect from compatibility code?
  333  */
  335 int ibcs2_readdir_callback(void *, struct dirent *, off_t);
  336 int ibcs2_classicread_callback(void *, struct dirent *, off_t);
  338 struct ibcs2_readdir_callback_args {
caddr_t outp;
  340         int     resid;
  341 };
  343 int
ibcs2_readdir_callback(arg, bdp, cookie)
  345         void *arg;
  346         struct dirent *bdp;
off_t cookie;
  348 {
  349         struct ibcs2_dirent idb;
  350         struct ibcs2_readdir_callback_args *cb = arg; 
  351         int ibcs2_reclen;
  352         int error;
ibcs2_reclen = IBCS2_RECLEN(&idb, bdp->d_namlen);
  355         if (cb->resid < ibcs2_reclen)
  356                 return (ENOMEM);
  358         /*
  359          * Massage in place to make a iBCS2-shaped dirent (otherwise
  360          * we have to worry about touching user memory outside of
  361          * the copyout() call).
  362          */
idb.d_ino = (ibcs2_ino_t)bdp->d_fileno;
idb.d_pad = 0;
idb.d_off = (ibcs2_off_t)cookie;
idb.d_reclen = (u_short)ibcs2_reclen;
strlcpy(idb.d_name, bdp->d_name, sizeof(idb.d_name));
error = copyout((caddr_t)&idb, cb->outp, ibcs2_reclen);
  369         if (error)
  370                 return (error);
  372         /* advance output past iBCS2-shaped entry */
cb->outp += ibcs2_reclen;
cb->resid -= ibcs2_reclen;
  376         return (0);
  377 }
  379 int
ibcs2_classicread_callback(arg, bdp, cookie)
  381         void *arg;
  382         struct dirent *bdp;
off_t cookie;
  384 {
  385         struct ibcs2_direct {
ibcs2_ino_t ino;
  387                 char name[14];
  388         } idb;
  389         struct ibcs2_readdir_callback_args *cb = arg; 
  390         int ibcs2_reclen;
  391         int error;
ibcs2_reclen = 16;
  394         if (cb->resid < ibcs2_reclen)
  395                 return (ENOMEM);
  397         /*
  398          * TODO: if length(filename) > 14 then break filename into
  399          * multiple entries and set inode = 0xffff except last
  400          */
idb.ino = (bdp->d_fileno > 0xfffe) ? 0xfffe : bdp->d_fileno;
bzero(&idb.name, sizeof(idb.name));
strncpy(idb.name, bdp->d_name, 14);
error = copyout(&idb, cb->outp, ibcs2_reclen);
  405         if (error)
  406                 return (error);
  408         /* advance output past iBCS2-shaped entry */
cb->outp += ibcs2_reclen;
cb->resid -= ibcs2_reclen;
  412         return (0);
  413 }
  415 int
ibcs2_sys_getdents(p, v, retval)
  417         struct proc *p;
  418         void *v;
register_t *retval;
  420 {
  421         register struct ibcs2_sys_getdents_args /* {
  422                 syscallarg(int) fd;
  423                 syscallarg(char *) buf;
  424                 syscallarg(int) nbytes;
  425         } */ *uap = v;
  426         struct ibcs2_readdir_callback_args args;
  427         struct file *fp;
  428         int error;
  430         if ((error = getvnode(p->p_fd, SCARG(uap, fd), &fp)) != 0)
  431                 return (error);
args.resid = SCARG(uap, nbytes);
args.outp = (caddr_t)SCARG(uap, buf);
error = readdir_with_callback(fp, &fp->f_offset, args.resid,
ibcs2_readdir_callback, &args);
FRELE(fp);
  438         if (error)
  439                 return (error);
  441         *retval = SCARG(uap, nbytes) - args.resid;
  442         return (0);
  443 }
  445 int
ibcs2_sys_read(p, v, retval)
  447         struct proc *p;
  448         void *v;
register_t *retval;
  450 {
  451         struct ibcs2_sys_read_args /* {
  452                 syscallarg(int) fd;
  453                 syscallarg(char *) buf;
  454                 syscallarg(u_int) nbytes;
  455         } */ *uap = v;
  456         struct vnode *vp;
  457         struct ibcs2_readdir_callback_args args;
  458         struct file *fp;
  459         int error;
  461         if ((error = getvnode(p->p_fd, SCARG(uap, fd), &fp)) != 0) {
  462                 if (error == EINVAL)
  463                         return sys_read(p, uap, retval);
  464                 else
  465                         return error;
  466         }
  467         if ((fp->f_flag & FREAD) == 0) {
error = EBADF;
  469                 goto bad;
  470         }
vp = (struct vnode *)fp->f_data;
  472         if (vp->v_type != VDIR) {
FRELE(fp);
  474                 return sys_read(p, uap, retval);
  475         }
args.resid = SCARG(uap, nbytes);
args.outp = (caddr_t)SCARG(uap, buf);
error = readdir_with_callback(fp, &fp->f_offset, args.resid,
ibcs2_classicread_callback, &args);
bad:
FRELE(fp);
  484         if (error)
  485                 return (error);
  487         *retval = SCARG(uap, nbytes) - args.resid;      
  488         return (0);
  489 }
  491 int
ibcs2_sys_mknod(p, v, retval)
  493         struct proc *p;
  494         void *v;
register_t *retval;
  496 {
  497         struct ibcs2_sys_mknod_args /* {
  498                 syscallarg(char *) path;
  499                 syscallarg(int) mode;
  500                 syscallarg(int) dev;
  501         } */ *uap = v;
caddr_t sg = stackgap_init(p->p_emul);
IBCS2_CHECK_ALT_CREAT(p, &sg, SCARG(uap, path));
  505         if (S_ISFIFO(SCARG(uap, mode))) {
  506                 struct sys_mkfifo_args ap;
SCARG(&ap, path) = SCARG(uap, path);
SCARG(&ap, mode) = SCARG(uap, mode);
  509                 return sys_mkfifo(p, uap, retval);
  510         } else {
  511                 struct sys_mknod_args ap;
SCARG(&ap, path) = SCARG(uap, path);
SCARG(&ap, mode) = SCARG(uap, mode);
SCARG(&ap, dev) = SCARG(uap, dev);
  515                 return sys_mknod(p, &ap, retval);
  516         }
  517 }
  519 int
ibcs2_sys_getgroups(p, v, retval)
  521         struct proc *p;
  522         void *v;
register_t *retval;
  524 {
  525         struct ibcs2_sys_getgroups_args /* {
  526                 syscallarg(int) gidsetsize;
  527                 syscallarg(ibcs2_gid_t *) gidset;
  528         } */ *uap = v;
  529         int error, i;
ibcs2_gid_t *iset = NULL;
  531         struct sys_getgroups_args sa;
gid_t *gp;
caddr_t sg = stackgap_init(p->p_emul);
SCARG(&sa, gidsetsize) = SCARG(uap, gidsetsize);
  536         if (SCARG(uap, gidsetsize)) {
SCARG(&sa, gidset) = stackgap_alloc(&sg, NGROUPS_MAX *
  538                                                     sizeof(gid_t *));
iset = stackgap_alloc(&sg, SCARG(uap, gidsetsize) *
  540                                       sizeof(ibcs2_gid_t));
  541         }
  542         if ((error = sys_getgroups(p, &sa, retval)) != 0)
  543                 return error;
  544         if (iset) {
  545                 for (i = 0, gp = SCARG(&sa, gidset); i < retval[0]; i++)
iset[i] = (ibcs2_gid_t)*gp++;
  547                 if (retval[0] && (error = copyout((caddr_t)iset,
  548                     (caddr_t)SCARG(uap, gidset),
  549                     sizeof(ibcs2_gid_t) * retval[0])))
  550                         return error;
  551         }
  552         return 0;
  553 }
  555 int
ibcs2_sys_setgroups(p, v, retval)
  557         struct proc *p;
  558         void *v;
register_t *retval;
  560 {
  561         struct ibcs2_sys_setgroups_args /* {
  562                 syscallarg(int) gidsetsize;
  563                 syscallarg(ibcs2_gid_t *) gidset;
  564         } */ *uap = v;
  565         int error, i;
ibcs2_gid_t *iset;
  567         struct sys_setgroups_args sa;
gid_t *gp;
caddr_t sg = stackgap_init(p->p_emul);
SCARG(&sa, gidsetsize) = SCARG(uap, gidsetsize);
gp = stackgap_alloc(&sg, SCARG(&sa, gidsetsize) * sizeof(gid_t *));
iset = stackgap_alloc(&sg, SCARG(&sa, gidsetsize) *
  574                               sizeof(ibcs2_gid_t *));
  575         if (SCARG(&sa, gidsetsize)) {
error = copyin((caddr_t)SCARG(uap, gidset), (caddr_t)iset, 
  577                     sizeof(ibcs2_gid_t *) * SCARG(uap, gidsetsize));
  578                 if (error)
  579                         return error;
  580         }
  581         for (i = 0; i < SCARG(&sa, gidsetsize); i++)
gp[i]= (gid_t)iset[i];
SCARG(&sa, gidset) = gp;
  584         return sys_setgroups(p, &sa, retval);
  585 }
  587 int
ibcs2_sys_setuid(p, v, retval)
  589         struct proc *p;
  590         void *v;
register_t *retval;
  592 {
  593         struct ibcs2_sys_setuid_args /* {
  594                 syscallarg(int) uid;
  595         } */ *uap = v;
  596         struct sys_setuid_args sa;
SCARG(&sa, uid) = (uid_t)SCARG(uap, uid);
  599         return sys_setuid(p, &sa, retval);
  600 }
  602 int
ibcs2_sys_setgid(p, v, retval)
  604         struct proc *p;
  605         void *v;
register_t *retval;
  607 {
  608         struct ibcs2_sys_setgid_args /* {
  609                 syscallarg(int) gid;
  610         } */ *uap = v;
  611         struct sys_setgid_args sa;
SCARG(&sa, gid) = (gid_t)SCARG(uap, gid);
  614         return sys_setgid(p, &sa, retval);
  615 }
  617 int
xenix_sys_ftime(p, v, retval)
  619         struct proc *p;
  620         void *v;
register_t *retval;
  622 {
  623         struct xenix_sys_ftime_args /* {
  624                 syscallarg(struct xenix_timeb *) tp;
  625         } */ *uap = v;
  626         struct timeval tv;
  627         extern struct timezone tz;
  628         struct xenix_timeb itb;
microtime(&tv);
itb.time = tv.tv_sec;
itb.millitm = (tv.tv_usec / 1000);
itb.timezone = tz.tz_minuteswest;
itb.dstflag = tz.tz_dsttime;
  635         return copyout((caddr_t)&itb, (caddr_t)SCARG(uap, tp),
xenix_timeb_len);
  637 }
  639 int
ibcs2_sys_time(p, v, retval)
  641         struct proc *p;
  642         void *v;
register_t *retval;
  644 {
  645         struct ibcs2_sys_time_args /* {
  646                 syscallarg(ibcs2_time_t *) tp;
  647         } */ *uap = v;
  648         struct timeval tv;
microtime(&tv);
  651         *retval = tv.tv_sec;
  652         if (SCARG(uap, tp))
  653                 return copyout((caddr_t)&tv.tv_sec, (caddr_t)SCARG(uap, tp),
  654                                sizeof(ibcs2_time_t));
  655         else
  656                 return 0;
  657 }
  659 int
ibcs2_sys_pathconf(p, v, retval)
  661         struct proc *p;
  662         void *v;
register_t *retval;
  664 {
  665         struct ibcs2_sys_pathconf_args /* {
  666                 syscallarg(char *) path;
  667                 syscallarg(int) name;
  668         } */ *uap = v;
SCARG(uap, name)++;     /* iBCS2 _PC_* defines are offset by one */
  670         return sys_pathconf(p, uap, retval);
  671 }
  673 int
ibcs2_sys_fpathconf(p, v, retval)
  675         struct proc *p;
  676         void *v;
register_t *retval;
  678 {
  679         struct ibcs2_sys_fpathconf_args /* {
  680                 syscallarg(int) fd;
  681                 syscallarg(int) name;
  682         } */ *uap = v;
SCARG(uap, name)++;     /* iBCS2 _PC_* defines are offset by one */
  684         return sys_fpathconf(p, uap, retval);
  685 }
  687 int
ibcs2_sys_sysconf(p, v, retval)
  689         struct proc *p;
  690         void *v;
register_t *retval;
  692 {
  693         struct ibcs2_sys_sysconf_args /* {
  694                 syscallarg(int) name;
  695         } */ *uap = v;
  696         int mib[2], value, error;
size_t len;
  698         struct sys___sysctl_args sa;
  699         struct sys_getrlimit_args ga;
  701         switch(SCARG(uap, name)) {
  702         case IBCS2_SC_ARG_MAX:
mib[1] = KERN_ARGMAX;
  704                 break;
  706         case IBCS2_SC_CHILD_MAX:
  707             {
caddr_t sg = stackgap_init(p->p_emul);
SCARG(&ga, which) = RLIMIT_NPROC;
SCARG(&ga, rlp) = stackgap_alloc(&sg, sizeof(struct rlimit *));
  712                 if ((error = sys_getrlimit(p, &ga, retval)) != 0)
  713                         return error;
  714                 *retval = SCARG(&ga, rlp)->rlim_cur;
  715                 return 0;
  716             }
  718         case IBCS2_SC_CLK_TCK:
  719                 *retval = hz;
  720                 return 0;
  722         case IBCS2_SC_NGROUPS_MAX:
mib[1] = KERN_NGROUPS;
  724                 break;
  726         case IBCS2_SC_OPEN_MAX:
  727             {
caddr_t sg = stackgap_init(p->p_emul);
SCARG(&ga, which) = RLIMIT_NOFILE;
SCARG(&ga, rlp) = stackgap_alloc(&sg, sizeof(struct rlimit *));
  732                 if ((error = sys_getrlimit(p, &ga, retval)) != 0)
  733                         return error;
  734                 *retval = SCARG(&ga, rlp)->rlim_cur;
  735                 return 0;
  736             }
  738         case IBCS2_SC_JOB_CONTROL:
mib[1] = KERN_JOB_CONTROL;
  740                 break;
  742         case IBCS2_SC_SAVED_IDS:
mib[1] = KERN_SAVED_IDS;
  744                 break;
  746         case IBCS2_SC_VERSION:
mib[1] = KERN_POSIX1;
  748                 break;
  750         case IBCS2_SC_PASS_MAX:
  751                 *retval = 128;          /* XXX - should we create PASS_MAX ? */
  752                 return 0;
  754         case IBCS2_SC_XOPEN_VERSION:
  755                 *retval = 2;            /* XXX: What should that be? */
  756                 return 0;
  758         default:
  759                 return EINVAL;
  760         }
mib[0] = CTL_KERN;
len = sizeof(value);
SCARG(&sa, name) = mib;
SCARG(&sa, namelen) = 2;
SCARG(&sa, old) = &value;
SCARG(&sa, oldlenp) = &len;
SCARG(&sa, new) = NULL;
SCARG(&sa, newlen) = 0;
  770         if ((error = sys___sysctl(p, &sa, retval)) != 0)
  771                 return error;
  772         *retval = value;
  773         return 0;
  774 }
  776 int
ibcs2_sys_alarm(p, v, retval)
  778         struct proc *p;
  779         void *v;
register_t *retval;
  781 {
  782         struct ibcs2_sys_alarm_args /* {
  783                 syscallarg(unsigned) sec;
  784         } */ *uap = v;
  785         int error;
  786         struct itimerval *itp, *oitp;
  787         struct sys_setitimer_args sa;
caddr_t sg = stackgap_init(p->p_emul);
itp = stackgap_alloc(&sg, sizeof(*itp));
oitp = stackgap_alloc(&sg, sizeof(*oitp));
timerclear(&itp->it_interval);
itp->it_value.tv_sec = SCARG(uap, sec);
itp->it_value.tv_usec = 0;
SCARG(&sa, which) = ITIMER_REAL;
SCARG(&sa, itv) = itp;
SCARG(&sa, oitv) = oitp;
error = sys_setitimer(p, &sa, retval);
  800         if (error)
  801                 return error;
  802         if (oitp->it_value.tv_usec)
oitp->it_value.tv_sec++;
  804         *retval = oitp->it_value.tv_sec;
  805         return 0;
  806 }
  808 int
ibcs2_sys_getmsg(p, v, retval)
  810         struct proc *p;
  811         void *v;
register_t *retval;
  813 {
  814 #ifdef notyet
  815         struct ibcs2_sys_getmsg_args /* {
  816                 syscallarg(int) fd;
  817                 syscallarg(struct ibcs2_stropts *) ctl;
  818                 syscallarg(struct ibcs2_stropts *) dat;
  819                 syscallarg(int *) flags;
  820         } */ *uap = v;
  821 #endif
  823         return 0;
  824 }
  826 int
ibcs2_sys_putmsg(p, v, retval)
  828         struct proc *p;
  829         void *v;
register_t *retval;
  831 {
  832 #ifdef notyet
  833         struct ibcs2_sys_putmsg_args /* {
  834                 syscallarg(int) fd;
  835                 syscallarg(struct ibcs2_stropts *) ctl;
  836                 syscallarg(struct ibcs2_stropts *) dat;
  837                 syscallarg(int) flags;
  838         } */ *uap = v;
  839 #endif
  841         return 0;
  842 }
  844 int
ibcs2_sys_times(p, v, retval)
  846         struct proc *p;
  847         void *v;
register_t *retval;
  849 {
  850         struct ibcs2_sys_times_args /* {
  851                 syscallarg(struct tms *) tp;
  852         } */ *uap = v;
  853         int error;
  854         struct sys_getrusage_args ga;
  855         struct tms tms;
  856         struct timeval t;
caddr_t sg = stackgap_init(p->p_emul);
  858         struct rusage *ru = stackgap_alloc(&sg, sizeof(*ru));
  859 #define CONVTCK(r)      (r.tv_sec * hz + r.tv_usec / (1000000 / hz))
SCARG(&ga, who) = RUSAGE_SELF;
SCARG(&ga, rusage) = ru;
error = sys_getrusage(p, &ga, retval);
  864         if (error)
  865                 return error;
tms.tms_utime = CONVTCK(ru->ru_utime);
tms.tms_stime = CONVTCK(ru->ru_stime);
SCARG(&ga, who) = RUSAGE_CHILDREN;
error = sys_getrusage(p, &ga, retval);
  871         if (error)
  872                 return error;
tms.tms_cutime = CONVTCK(ru->ru_utime);
tms.tms_cstime = CONVTCK(ru->ru_stime);
microtime(&t);
  877         *retval = CONVTCK(t);
  879         return copyout((caddr_t)&tms, (caddr_t)SCARG(uap, tp),
  880                        sizeof(struct tms));
  881 }
  883 int
ibcs2_sys_stime(p, v, retval)
  885         struct proc *p;
  886         void *v;
register_t *retval;
  888 {
  889         struct ibcs2_sys_stime_args /* {
  890                 syscallarg(long *) timep;
  891         } */ *uap = v;
  892         int error;
  893         struct sys_settimeofday_args sa;
caddr_t sg = stackgap_init(p->p_emul);
  895         struct timeval *tvp;
tvp = stackgap_alloc(&sg, sizeof(*SCARG(&sa, tv)));
SCARG(&sa, tzp) = NULL;
error = copyin((caddr_t)SCARG(uap, timep), (void *)&tvp->tv_sec,
  900             sizeof(long));
  901         if (error)
  902                 return error;
tvp->tv_usec = 0;
SCARG(&sa, tv) = tvp;
  905         if ((error = sys_settimeofday(p, &sa, retval)) != 0)
  906                 return EPERM;
  907         return 0;
  908 }
  910 int
ibcs2_sys_utime(p, v, retval)
  912         struct proc *p;
  913         void *v;
register_t *retval;
  915 {
  916         struct ibcs2_sys_utime_args /* {
  917                 syscallarg(char *) path;
  918                 syscallarg(struct ibcs2_utimbuf *) buf;
  919         } */ *uap = v;
  920         int error;
  921         struct sys_utimes_args sa;
  922         struct timeval *tp;
caddr_t sg = stackgap_init(p->p_emul);
tp = stackgap_alloc(&sg, 2 * sizeof(struct timeval *));
IBCS2_CHECK_ALT_EXIST(p, &sg, SCARG(uap, path));
SCARG(&sa, path) = SCARG(uap, path);
  928         if (SCARG(uap, buf)) {
  929                 struct ibcs2_utimbuf ubuf;
error = copyin((caddr_t)SCARG(uap, buf), (caddr_t)&ubuf,
  932                     sizeof(ubuf));
  933                 if (error)
  934                         return error;
tp[0].tv_sec = ubuf.actime;
tp[0].tv_usec = 0;
tp[1].tv_sec = ubuf.modtime;
tp[1].tv_usec = 0;
SCARG(&sa, tptr) = tp;
  940         } else
SCARG(&sa, tptr) = NULL;
  942         return sys_utimes(p, &sa, retval);
  943 }
  945 int
ibcs2_sys_nice(p, v, retval)
  947         struct proc *p;
  948         void *v;
register_t *retval;
  950 {
  951         struct ibcs2_sys_nice_args /* {
  952                 syscallarg(int) incr;
  953         } */ *uap = v;
  954         int error;
  955         struct sys_setpriority_args sa;
SCARG(&sa, which) = PRIO_PROCESS;
SCARG(&sa, who) = 0;
SCARG(&sa, prio) = p->p_nice - PZERO + SCARG(uap, incr);
  960         if ((error = sys_setpriority(p, &sa, retval)) != 0)
  961                 return EPERM;
  962         *retval = p->p_nice - PZERO;
  963         return 0;
  964 }
  966 /*
  967  * iBCS2 getpgrp, setpgrp, setsid, and setpgid
  968  */
  970 int
ibcs2_sys_pgrpsys(p, v, retval)
  972         struct proc *p;
  973         void *v;
register_t *retval;
  975 {
  976         struct ibcs2_sys_pgrpsys_args /* {
  977                 syscallarg(int) type;
  978                 syscallarg(caddr_t) dummy;
  979                 syscallarg(int) pid;
  980                 syscallarg(int) pgid;
  981         } */ *uap = v;
  982         switch (SCARG(uap, type)) {
  983         case 0:                 /* getpgrp */
  984                 *retval = p->p_pgrp->pg_id;
  985                 return 0;
  987         case 1:                 /* setpgrp */
  988             {
  989                 struct sys_setpgid_args sa;
SCARG(&sa, pid) = 0;
SCARG(&sa, pgid) = 0;
sys_setpgid(p, &sa, retval);
  994                 *retval = p->p_pgrp->pg_id;
  995                 return 0;
  996             }
  998         case 2:                 /* setpgid */
  999             {
 1000                 struct sys_setpgid_args sa;
SCARG(&sa, pid) = SCARG(uap, pid);
SCARG(&sa, pgid) = SCARG(uap, pgid);
 1004                 return sys_setpgid(p, &sa, retval);
 1005             }
 1007         case 3:                 /* setsid */
 1008                 return sys_setsid(p, NULL, retval);
 1010         default:
 1011                 return EINVAL;
 1012         }
 1013 }
 1015 /*
 1016  * XXX - need to check for nested calls
 1017  */
 1019 int
ibcs2_sys_plock(p, v, retval)
 1021         struct proc *p;
 1022         void *v;
register_t *retval;
 1024 {
 1025         struct ibcs2_sys_plock_args /* {
 1026                 syscallarg(int) cmd;
 1027         } */ *uap = v;
 1028         int error;
 1029 #define IBCS2_UNLOCK    0
 1030 #define IBCS2_PROCLOCK  1
 1031 #define IBCS2_TEXTLOCK  2
 1032 #define IBCS2_DATALOCK  4
 1035         if ((error = suser(p, 0)) != 0)
 1036                 return EPERM;
 1037         switch(SCARG(uap, cmd)) {
 1038         case IBCS2_UNLOCK:
 1039         case IBCS2_PROCLOCK:
 1040         case IBCS2_TEXTLOCK:
 1041         case IBCS2_DATALOCK:
 1042                 return 0;       /* XXX - TODO */
 1043         }
 1044         return EINVAL;
 1045 }
 1047 int
ibcs2_sys_uadmin(p, v, retval)
 1049         struct proc *p;
 1050         void *v;
register_t *retval;
 1052 {
 1053         struct ibcs2_sys_uadmin_args /* {
 1054                 syscallarg(int) cmd;
 1055                 syscallarg(int) func;
 1056                 syscallarg(caddr_t) data;
 1057         } */ *uap = v;
 1058         int error;
 1060 #define SCO_A_REBOOT        1
 1061 #define SCO_A_SHUTDOWN      2
 1062 #define SCO_A_REMOUNT       4
 1063 #define SCO_A_CLOCK         8
 1064 #define SCO_A_SETCONFIG     128
 1065 #define SCO_A_GETDEV        130
 1067 #define SCO_AD_HALT         0
 1068 #define SCO_AD_BOOT         1
 1069 #define SCO_AD_IBOOT        2
 1070 #define SCO_AD_PWRDOWN      3
 1071 #define SCO_AD_PWRNAP       4
 1073 #define SCO_AD_PANICBOOT    1
 1075 #define SCO_AD_GETBMAJ      0
 1076 #define SCO_AD_GETCMAJ      1
 1078         /* XXX: is this the right place for this call? */
 1079         if ((error = suser(p, 0)) != 0)
 1080                 return (error);
 1082         switch(SCARG(uap, cmd)) {
 1083         case SCO_A_REBOOT:
 1084         case SCO_A_SHUTDOWN:
 1085                 switch(SCARG(uap, func)) {
 1086                 case SCO_AD_HALT:
 1087                 case SCO_AD_PWRDOWN:
 1088                 case SCO_AD_PWRNAP:
boot(RB_HALT);
 1090                 case SCO_AD_BOOT:
 1091                 case SCO_AD_IBOOT:
boot(RB_AUTOBOOT);
 1093                 }
 1094                 return EINVAL;
 1095         case SCO_A_REMOUNT:
 1096         case SCO_A_CLOCK:
 1097         case SCO_A_SETCONFIG:
 1098                 return 0;
 1099         case SCO_A_GETDEV:
 1100                 return EINVAL;  /* XXX - TODO */
 1101         }
 1102         return EINVAL;
 1103 }
 1105 int
ibcs2_sys_sysfs(p, v, retval)
 1107         struct proc *p;
 1108         void *v;
register_t *retval;
 1110 {
 1111         struct ibcs2_sys_sysfs_args /* {
 1112                 syscallarg(int) cmd;
 1113                 syscallarg(caddr_t) d1;
 1114                 syscallarg(char *) buf;
 1115         } */ *uap = v;
 1117 #define IBCS2_GETFSIND        1
 1118 #define IBCS2_GETFSTYP        2
 1119 #define IBCS2_GETNFSTYP       3
 1121         switch(SCARG(uap, cmd)) {
 1122         case IBCS2_GETFSIND:
 1123         case IBCS2_GETFSTYP:
 1124         case IBCS2_GETNFSTYP:
 1125                 break;
 1126         }
 1127         return EINVAL;          /* XXX - TODO */
 1128 }
 1130 int
xenix_sys_rdchk(p, v, retval)
 1132         struct proc *p;
 1133         void *v;
register_t *retval;
 1135 {
 1136         struct xenix_sys_rdchk_args /* {
 1137                 syscallarg(int) fd;
 1138         } */ *uap = v;
 1139         int error;
 1140         struct sys_ioctl_args sa;
caddr_t sg = stackgap_init(p->p_emul);
SCARG(&sa, fd) = SCARG(uap, fd);
SCARG(&sa, com) = FIONREAD;
SCARG(&sa, data) = stackgap_alloc(&sg, sizeof(int));
 1146         if ((error = sys_ioctl(p, &sa, retval)) != 0)
 1147                 return error;
 1148         *retval = (*((int *)SCARG(&sa, data))) ? 1 : 0;
 1149         return 0;
 1150 }
 1152 int
xenix_sys_chsize(p, v, retval)
 1154         struct proc *p;
 1155         void *v;
register_t *retval;
 1157 {
 1158         struct xenix_sys_chsize_args /* {
 1159                 syscallarg(int) fd;
 1160                 syscallarg(long) size;
 1161         } */ *uap = v;
 1162         struct sys_ftruncate_args sa;
SCARG(&sa, fd) = SCARG(uap, fd);
SCARG(&sa, pad) = 0;
SCARG(&sa, length) = SCARG(uap, size);
 1167         return sys_ftruncate(p, &sa, retval);
 1168 }
 1170 int
xenix_sys_nap(p, v, retval)
 1172         struct proc *p;
 1173         void *v;
register_t *retval;
 1175 {
 1176 #ifdef notyet
 1177         struct xenix_sys_nap_args /* {
 1178                 syscallarg(int) millisec;
 1179         } */ *uap = v;
 1180 #endif
 1182         return ENOSYS;
 1183 }
 1185 int
ibcs2_sys_unlink(p, v, retval)
 1187         struct proc *p;
 1188         void *v;
register_t *retval;
 1190 {
 1191         struct ibcs2_sys_unlink_args /* {
 1192                 syscallarg(char *) path;
 1193         } */ *uap = v;
caddr_t sg = stackgap_init(p->p_emul);
IBCS2_CHECK_ALT_EXIST(p, &sg, SCARG(uap, path));
 1197         return sys_unlink(p, uap, retval);
 1198 }
 1200 int
ibcs2_sys_chdir(p, v, retval)
 1202         struct proc *p;
 1203         void *v;
register_t *retval;
 1205 {
 1206         struct ibcs2_sys_chdir_args /* {
 1207                 syscallarg(char *) path;
 1208         } */ *uap = v;
caddr_t sg = stackgap_init(p->p_emul);
IBCS2_CHECK_ALT_EXIST(p, &sg, SCARG(uap, path));
 1212         return sys_chdir(p, uap, retval);
 1213 }
 1215 int
ibcs2_sys_chmod(p, v, retval)
 1217         struct proc *p;
 1218         void *v;
register_t *retval;
 1220 {
 1221         struct ibcs2_sys_chmod_args /* {
 1222                 syscallarg(char *) path;
 1223                 syscallarg(int) mode;
 1224         } */ *uap = v;
caddr_t sg = stackgap_init(p->p_emul);
IBCS2_CHECK_ALT_EXIST(p, &sg, SCARG(uap, path));
 1228         return sys_chmod(p, uap, retval);
 1229 }
 1231 int
ibcs2_sys_chown(p, v, retval)
 1233         struct proc *p;
 1234         void *v;
register_t *retval;
 1236 {
 1237         struct ibcs2_sys_chown_args /* {
 1238                 syscallarg(char *) path;
 1239                 syscallarg(int) uid;
 1240                 syscallarg(int) gid;
 1241         } */ *uap = v;
caddr_t sg = stackgap_init(p->p_emul);
IBCS2_CHECK_ALT_EXIST(p, &sg, SCARG(uap, path));
 1245         return sys_chown(p, uap, retval);
 1246 }
 1248 int
ibcs2_sys_rmdir(p, v, retval)
 1250         struct proc *p;
 1251         void *v;
register_t *retval;
 1253 {
 1254         struct ibcs2_sys_rmdir_args /* {
 1255                 syscallarg(char *) path;
 1256         } */ *uap = v;
caddr_t sg = stackgap_init(p->p_emul);
IBCS2_CHECK_ALT_EXIST(p, &sg, SCARG(uap, path));
 1260         return sys_rmdir(p, uap, retval);
 1261 }
 1263 int
ibcs2_sys_mkdir(p, v, retval)
 1265         struct proc *p;
 1266         void *v;
register_t *retval;
 1268 {
 1269         struct ibcs2_sys_mkdir_args /* {
 1270                 syscallarg(char *) path;
 1271                 syscallarg(int) mode;
 1272         } */ *uap = v;
caddr_t sg = stackgap_init(p->p_emul);
IBCS2_CHECK_ALT_CREAT(p, &sg, SCARG(uap, path));
 1276         return sys_mkdir(p, uap, retval);
 1277 }
 1279 int
ibcs2_sys_symlink(p, v, retval)
 1281         struct proc *p;
 1282         void *v;
register_t *retval;
 1284 {
 1285         struct ibcs2_sys_symlink_args /* {
 1286                 syscallarg(char *) path;
 1287                 syscallarg(char *) link;
 1288         } */ *uap = v;
caddr_t sg = stackgap_init(p->p_emul);
IBCS2_CHECK_ALT_EXIST(p, &sg, SCARG(uap, path));
IBCS2_CHECK_ALT_CREAT(p, &sg, SCARG(uap, link));
 1293         return sys_symlink(p, uap, retval);
 1294 }
 1296 int
ibcs2_sys_rename(p, v, retval)
 1298         struct proc *p;
 1299         void *v;
register_t *retval;
 1301 {
 1302         struct ibcs2_sys_rename_args /* {
 1303                 syscallarg(char *) from;
 1304                 syscallarg(char *) to;
 1305         } */ *uap = v;
caddr_t sg = stackgap_init(p->p_emul);
IBCS2_CHECK_ALT_EXIST(p, &sg, SCARG(uap, from));
IBCS2_CHECK_ALT_CREAT(p, &sg, SCARG(uap, to));
 1310         return sys_rename(p, uap, retval);
 1311 }
 1313 int
ibcs2_sys_readlink(p, v, retval)
 1315         struct proc *p;
 1316         void *v;
register_t *retval;
 1318 {
 1319         struct ibcs2_sys_readlink_args /* {
 1320                 syscallarg(char *) path;
 1321                 syscallarg(char *) buf;
 1322                 syscallarg(int) count;
 1323         } */ *uap = v;
caddr_t sg = stackgap_init(p->p_emul);
IBCS2_CHECK_ALT_EXIST(p, &sg, SCARG(uap, path));
 1327         return sys_readlink(p, uap, retval);
 1328 }
 1330 int
ibcs2_sys_sysi86(p, v, retval)
 1332         struct proc *p;
 1333         void *v;
register_t *retval;
 1335 {
 1336         struct ibcs2_sys_sysi86_args /* {
 1337                 syscallarg(int) cmd;
 1338                 syscallarg(int) arg;
 1339         } */ *uap = v;
 1340         int val, error;
 1342         switch (SCARG(uap, cmd)) {
 1343         case IBCS2_SI86FPHW:
val = IBCS2_FP_NO;
 1345 #ifdef MATH_EMULATE
val = IBCS2_FP_SW;
 1347 #else
val = IBCS2_FP_387;             /* a real coprocessor */
 1349 #endif
 1350                 if ((error = copyout((caddr_t)&val, (caddr_t)SCARG(uap, arg),
 1351                                      sizeof(val))))
 1352                         return error;
 1353                 break;
 1355         case IBCS2_SI86STIME:           /* XXX - not used much, if at all */
 1356         case IBCS2_SI86SETNAME:
 1357                 return EINVAL;
 1359         case IBCS2_SI86PHYSMEM:
 1360                 *retval = ctob(physmem);
 1361                 break;
 1363         default:
 1364                 return EINVAL;
 1365         }
 1366         return 0;
 1367 }