Annotation of sys/compat/sunos/sunos_misc.c, Revision 1.1
1.1 ! nbrk 1: /* $OpenBSD: sunos_misc.c,v 1.46 2004/06/24 19:35:23 tholo Exp $ */
! 2: /* $NetBSD: sunos_misc.c,v 1.65 1996/04/22 01:44:31 christos Exp $ */
! 3:
! 4: /*
! 5: * Copyright (c) 1992, 1993
! 6: * The Regents of the University of California. All rights reserved.
! 7: *
! 8: * This software was developed by the Computer Systems Engineering group
! 9: * at Lawrence Berkeley Laboratory under DARPA contract BG 91-66 and
! 10: * contributed to Berkeley.
! 11: *
! 12: * All advertising materials mentioning features or use of this software
! 13: * must display the following acknowledgement:
! 14: * This product includes software developed by the University of
! 15: * California, Lawrence Berkeley Laboratory.
! 16: *
! 17: * Redistribution and use in source and binary forms, with or without
! 18: * modification, are permitted provided that the following conditions
! 19: * are met:
! 20: * 1. Redistributions of source code must retain the above copyright
! 21: * notice, this list of conditions and the following disclaimer.
! 22: * 2. Redistributions in binary form must reproduce the above copyright
! 23: * notice, this list of conditions and the following disclaimer in the
! 24: * documentation and/or other materials provided with the distribution.
! 25: * 3. Neither the name of the University nor the names of its contributors
! 26: * may be used to endorse or promote products derived from this software
! 27: * without specific prior written permission.
! 28: *
! 29: * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
! 30: * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
! 31: * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
! 32: * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
! 33: * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
! 34: * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
! 35: * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
! 36: * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
! 37: * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
! 38: * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
! 39: * SUCH DAMAGE.
! 40: *
! 41: * @(#)sunos_misc.c 8.1 (Berkeley) 6/18/93
! 42: *
! 43: * Header: sunos_misc.c,v 1.16 93/04/07 02:46:27 torek Exp
! 44: */
! 45:
! 46: /*
! 47: * SunOS compatibility module.
! 48: *
! 49: * SunOS system calls that are implemented differently in BSD are
! 50: * handled here.
! 51: */
! 52:
! 53: #include <sys/param.h>
! 54: #include <sys/systm.h>
! 55: #include <sys/namei.h>
! 56: #include <sys/proc.h>
! 57: #include <sys/dirent.h>
! 58: #include <sys/file.h>
! 59: #include <sys/stat.h>
! 60: #include <sys/filedesc.h>
! 61: #include <sys/ioctl.h>
! 62: #include <sys/kernel.h>
! 63: #include <sys/reboot.h>
! 64: #include <sys/malloc.h>
! 65: #include <sys/mbuf.h>
! 66: #include <sys/mman.h>
! 67: #include <sys/mount.h>
! 68: #include <sys/ptrace.h>
! 69: #include <sys/resource.h>
! 70: #include <sys/resourcevar.h>
! 71: #include <sys/signal.h>
! 72: #include <sys/signalvar.h>
! 73: #include <sys/socket.h>
! 74: #include <sys/tty.h>
! 75: #include <sys/vnode.h>
! 76: #include <sys/uio.h>
! 77: #include <sys/wait.h>
! 78: #include <sys/utsname.h>
! 79: #include <sys/unistd.h>
! 80: #include <sys/syscallargs.h>
! 81: #include <sys/conf.h>
! 82: #include <sys/socketvar.h>
! 83: #include <sys/times.h>
! 84:
! 85: #include <compat/sunos/sunos.h>
! 86: #include <compat/sunos/sunos_syscallargs.h>
! 87: #include <compat/sunos/sunos_util.h>
! 88: #include <compat/sunos/sunos_dirent.h>
! 89:
! 90: #include <compat/common/compat_dir.h>
! 91:
! 92: #include <netinet/in.h>
! 93:
! 94: #include <miscfs/specfs/specdev.h>
! 95:
! 96: #include <nfs/rpcv2.h>
! 97: #include <nfs/nfsproto.h>
! 98: #include <nfs/nfs.h>
! 99:
! 100: #include <uvm/uvm_extern.h>
! 101:
! 102: #ifdef sun3
! 103: # include <machine/machdep.h> /* for prototype of reboot2() */
! 104: #endif
! 105:
! 106: static int sunstatfs(struct statfs *, caddr_t);
! 107:
! 108: int
! 109: sunos_sys_wait4(p, v, retval)
! 110: struct proc *p;
! 111: void *v;
! 112: register_t *retval;
! 113: {
! 114: struct sunos_sys_wait4_args *uap = v;
! 115: if (SCARG(uap, pid) == 0)
! 116: SCARG(uap, pid) = WAIT_ANY;
! 117: return (sys_wait4(p, uap, retval));
! 118: }
! 119:
! 120: int
! 121: sunos_sys_creat(p, v, retval)
! 122: struct proc *p;
! 123: void *v;
! 124: register_t *retval;
! 125: {
! 126: struct sunos_sys_creat_args *uap = v;
! 127: struct sys_open_args ouap;
! 128:
! 129: caddr_t sg = stackgap_init(p->p_emul);
! 130: SUNOS_CHECK_ALT_EXIST(p, &sg, SCARG(uap, path));
! 131:
! 132: SCARG(&ouap, path) = SCARG(uap, path);
! 133: SCARG(&ouap, flags) = O_WRONLY | O_CREAT | O_TRUNC;
! 134: SCARG(&ouap, mode) = SCARG(uap, mode);
! 135:
! 136: return (sys_open(p, &ouap, retval));
! 137: }
! 138:
! 139: int
! 140: sunos_sys_access(p, v, retval)
! 141: struct proc *p;
! 142: void *v;
! 143: register_t *retval;
! 144: {
! 145: struct sunos_sys_access_args *uap = v;
! 146: caddr_t sg = stackgap_init(p->p_emul);
! 147: SUNOS_CHECK_ALT_EXIST(p, &sg, SCARG(uap, path));
! 148:
! 149: return (sys_access(p, uap, retval));
! 150: }
! 151:
! 152: int
! 153: sunos_sys_stat(p, v, retval)
! 154: struct proc *p;
! 155: void *v;
! 156: register_t *retval;
! 157: {
! 158: struct sunos_sys_stat_args *uap = v;
! 159: caddr_t sg = stackgap_init(p->p_emul);
! 160: SUNOS_CHECK_ALT_EXIST(p, &sg, SCARG(uap, path));
! 161:
! 162: return (compat_43_sys_stat(p, uap, retval));
! 163: }
! 164:
! 165: int
! 166: sunos_sys_lstat(p, v, retval)
! 167: struct proc *p;
! 168: void *v;
! 169: register_t *retval;
! 170: {
! 171: struct sunos_sys_lstat_args *uap = v;
! 172: caddr_t sg = stackgap_init(p->p_emul);
! 173: SUNOS_CHECK_ALT_EXIST(p, &sg, SCARG(uap, path));
! 174:
! 175: return (compat_43_sys_lstat(p, uap, retval));
! 176: }
! 177:
! 178: int
! 179: sunos_sys_execve(p, v, retval)
! 180: struct proc *p;
! 181: void *v;
! 182: register_t *retval;
! 183: {
! 184: struct sunos_sys_execve_args /* {
! 185: syscallarg(char *) path;
! 186: syscallarg(char **) argv;
! 187: syscallarg(char **) envp;
! 188: } */ *uap = v;
! 189: struct sys_execve_args ap;
! 190: caddr_t sg;
! 191:
! 192: sg = stackgap_init(p->p_emul);
! 193: SUNOS_CHECK_ALT_EXIST(p, &sg, SCARG(uap, path));
! 194:
! 195: SCARG(&ap, path) = SCARG(uap, path);
! 196: SCARG(&ap, argp) = SCARG(uap, argp);
! 197: SCARG(&ap, envp) = SCARG(uap, envp);
! 198:
! 199: return (sys_execve(p, &ap, retval));
! 200: }
! 201:
! 202: int
! 203: sunos_sys_execv(p, v, retval)
! 204: struct proc *p;
! 205: void *v;
! 206: register_t *retval;
! 207: {
! 208: struct sunos_sys_execv_args *uap = v;
! 209: struct sys_execve_args ouap;
! 210:
! 211: caddr_t sg = stackgap_init(p->p_emul);
! 212: SUNOS_CHECK_ALT_EXIST(p, &sg, SCARG(uap, path));
! 213:
! 214: SCARG(&ouap, path) = SCARG(uap, path);
! 215: SCARG(&ouap, argp) = SCARG(uap, argp);
! 216: SCARG(&ouap, envp) = NULL;
! 217:
! 218: return (sys_execve(p, &ouap, retval));
! 219: }
! 220:
! 221: int
! 222: sunos_sys_unmount(p, v, retval)
! 223: struct proc *p;
! 224: void *v;
! 225: register_t *retval;
! 226: {
! 227: struct sunos_sys_unmount_args *uap = v;
! 228: struct sys_unmount_args ouap;
! 229:
! 230: SCARG(&ouap, path) = SCARG(uap, path);
! 231: SCARG(&ouap, flags) = 0;
! 232:
! 233: return (sys_unmount(p, &ouap, retval));
! 234: }
! 235:
! 236: /*
! 237: * Conversion table for SunOS NFS mount flags.
! 238: */
! 239: static struct {
! 240: int sun_flg;
! 241: int bsd_flg;
! 242: } sunnfs_flgtab[] = {
! 243: { SUNNFS_SOFT, NFSMNT_SOFT },
! 244: { SUNNFS_WSIZE, NFSMNT_WSIZE },
! 245: { SUNNFS_RSIZE, NFSMNT_RSIZE },
! 246: { SUNNFS_TIMEO, NFSMNT_TIMEO },
! 247: { SUNNFS_RETRANS, NFSMNT_RETRANS },
! 248: { SUNNFS_HOSTNAME, 0 }, /* Ignored */
! 249: { SUNNFS_INT, NFSMNT_INT },
! 250: { SUNNFS_NOAC, 0 }, /* Ignored */
! 251: { SUNNFS_ACREGMIN, 0 }, /* Ignored */
! 252: { SUNNFS_ACREGMAX, 0 }, /* Ignored */
! 253: { SUNNFS_ACDIRMIN, 0 }, /* Ignored */
! 254: { SUNNFS_ACDIRMAX, 0 }, /* Ignored */
! 255: { SUNNFS_SECURE, 0 }, /* Ignored */
! 256: { SUNNFS_NOCTO, 0 }, /* Ignored */
! 257: { SUNNFS_POSIX, 0 } /* Ignored */
! 258: };
! 259:
! 260: int
! 261: sunos_sys_mount(p, v, retval)
! 262: struct proc *p;
! 263: void *v;
! 264: register_t *retval;
! 265: {
! 266: struct sunos_sys_mount_args *uap = v;
! 267: int oflags = SCARG(uap, flags), nflags, error;
! 268: char fsname[MFSNAMELEN];
! 269: caddr_t sg = stackgap_init(p->p_emul);
! 270:
! 271: if (oflags & (SUNM_NOSUB | SUNM_SYS5))
! 272: return (EINVAL);
! 273: if ((oflags & SUNM_NEWTYPE) == 0)
! 274: return (EINVAL);
! 275: nflags = 0;
! 276: if (oflags & SUNM_RDONLY)
! 277: nflags |= MNT_RDONLY;
! 278: if (oflags & SUNM_NOSUID)
! 279: nflags |= MNT_NOSUID;
! 280: if (oflags & SUNM_REMOUNT)
! 281: nflags |= MNT_UPDATE;
! 282: SCARG(uap, flags) = nflags;
! 283:
! 284: error = copyinstr((caddr_t)SCARG(uap, type), fsname,
! 285: sizeof fsname, (size_t *)0);
! 286: if (error)
! 287: return (error);
! 288:
! 289: if (strncmp(fsname, "4.2", sizeof fsname) == 0) {
! 290: SCARG(uap, type) = stackgap_alloc(&sg, sizeof("ffs"));
! 291: error = copyout("ffs", SCARG(uap, type), sizeof("ffs"));
! 292: if (error)
! 293: return (error);
! 294: } else if (strncmp(fsname, "nfs", sizeof fsname) == 0) {
! 295: struct sunos_nfs_args sna;
! 296: struct sockaddr_in sain;
! 297: struct nfs_args na;
! 298: struct sockaddr sa;
! 299: int n;
! 300:
! 301: error = copyin(SCARG(uap, data), &sna, sizeof sna);
! 302: if (error)
! 303: return (error);
! 304: error = copyin(sna.addr, &sain, sizeof sain);
! 305: if (error)
! 306: return (error);
! 307: bcopy(&sain, &sa, sizeof sa);
! 308: sa.sa_len = sizeof(sain);
! 309: SCARG(uap, data) = stackgap_alloc(&sg, sizeof(na));
! 310: na.version = NFS_ARGSVERSION;
! 311: na.addr = stackgap_alloc(&sg, sizeof(struct sockaddr));
! 312: na.addrlen = sizeof(struct sockaddr);
! 313: na.sotype = SOCK_DGRAM;
! 314: na.proto = IPPROTO_UDP;
! 315: na.fh = (void *)sna.fh;
! 316: na.fhsize = NFSX_V2FH;
! 317: na.flags = 0;
! 318: n = sizeof(sunnfs_flgtab) / sizeof(sunnfs_flgtab[0]);
! 319: while (--n >= 0)
! 320: if (sna.flags & sunnfs_flgtab[n].sun_flg)
! 321: na.flags |= sunnfs_flgtab[n].bsd_flg;
! 322: na.wsize = sna.wsize;
! 323: na.rsize = sna.rsize;
! 324: if (na.flags & NFSMNT_RSIZE) {
! 325: na.flags |= NFSMNT_READDIRSIZE;
! 326: na.readdirsize = na.rsize;
! 327: }
! 328: na.timeo = sna.timeo;
! 329: na.retrans = sna.retrans;
! 330: na.hostname = sna.hostname;
! 331:
! 332: error = copyout(&sa, na.addr, sizeof sa);
! 333: if (error)
! 334: return (error);
! 335: error = copyout(&na, SCARG(uap, data), sizeof na);
! 336: if (error)
! 337: return (error);
! 338: }
! 339: return (sys_mount(p, (struct sys_mount_args *)uap, retval));
! 340: }
! 341:
! 342: #if defined(NFSCLIENT)
! 343: int
! 344: async_daemon(p, v, retval)
! 345: struct proc *p;
! 346: void *v;
! 347: register_t *retval;
! 348: {
! 349: struct sys_nfssvc_args ouap;
! 350:
! 351: SCARG(&ouap, flag) = NFSSVC_BIOD;
! 352: SCARG(&ouap, argp) = NULL;
! 353:
! 354: return (sys_nfssvc(p, &ouap, retval));
! 355: }
! 356: #endif /* NFSCLIENT */
! 357:
! 358: int
! 359: sunos_sys_sigpending(p, v, retval)
! 360: struct proc *p;
! 361: void *v;
! 362: register_t *retval;
! 363: {
! 364: struct sunos_sys_sigpending_args *uap = v;
! 365: int mask = p->p_siglist & p->p_sigmask;
! 366:
! 367: return (copyout((caddr_t)&mask, (caddr_t)SCARG(uap, mask), sizeof(int)));
! 368: }
! 369:
! 370: /*
! 371: * Read Sun-style directory entries. We suck them into kernel space so
! 372: * that they can be massaged before being copied out to user code. Like
! 373: * SunOS, we squish out `empty' entries.
! 374: *
! 375: * This is quite ugly, but what do you expect from compatibility code?
! 376: */
! 377: int sunos_readdir_callback(void *, struct dirent *, off_t);
! 378:
! 379: struct sunos_readdir_callback_args {
! 380: caddr_t outp;
! 381: int resid;
! 382: };
! 383:
! 384: int
! 385: sunos_readdir_callback(arg, bdp, cookie)
! 386: void *arg;
! 387: struct dirent *bdp;
! 388: off_t cookie;
! 389: {
! 390: struct sunos_dirent idb;
! 391: struct sunos_readdir_callback_args *cb = arg;
! 392: int sunos_reclen;
! 393: int error;
! 394:
! 395: sunos_reclen = SUNOS_RECLEN(&idb, bdp->d_namlen);
! 396: if (cb->resid < sunos_reclen)
! 397: return (ENOMEM);
! 398:
! 399: idb.d_fileno = bdp->d_fileno;
! 400: idb.d_off = cookie;
! 401: idb.d_reclen = sunos_reclen;
! 402: idb.d_namlen = bdp->d_namlen;
! 403: strlcpy(idb.d_name, bdp->d_name, sizeof(idb.d_name));
! 404:
! 405: if ((error = copyout((caddr_t)&idb, cb->outp, sunos_reclen)))
! 406: return (error);
! 407:
! 408: cb->outp += sunos_reclen;
! 409: cb->resid -= sunos_reclen;
! 410:
! 411: return (0);
! 412: }
! 413:
! 414: int
! 415: sunos_sys_getdents(p, v, retval)
! 416: struct proc *p;
! 417: void *v;
! 418: register_t *retval;
! 419: {
! 420: struct sunos_sys_getdents_args /* {
! 421: syscallarg(int) fd;
! 422: syscallarg(char *) buf;
! 423: syscallarg(int) nbytes;
! 424: } */ *uap = v;
! 425: struct vnode *vp;
! 426: struct file *fp;
! 427: int error;
! 428: struct sunos_readdir_callback_args args;
! 429:
! 430: if ((error = getvnode(p->p_fd, SCARG(uap, fd), &fp)) != 0)
! 431: return (error);
! 432:
! 433: vp = (struct vnode *)fp->f_data;
! 434: /* SunOS returns ENOTDIR here, BSD would use EINVAL */
! 435: if (vp->v_type != VDIR) {
! 436: error = ENOTDIR;
! 437: goto bad;
! 438: }
! 439:
! 440: args.resid = SCARG(uap, nbytes);
! 441: args.outp = (caddr_t)SCARG(uap, buf);
! 442:
! 443: error = readdir_with_callback(fp, &fp->f_offset, args.resid,
! 444: sunos_readdir_callback, &args);
! 445: bad:
! 446: FRELE(fp);
! 447: if (error)
! 448: return (error);
! 449:
! 450: *retval = SCARG(uap, nbytes) - args.resid;
! 451:
! 452: return (0);
! 453: }
! 454:
! 455:
! 456: #define SUNOS__MAP_NEW 0x80000000 /* if not, old mmap & cannot handle */
! 457:
! 458: int
! 459: sunos_sys_mmap(p, v, retval)
! 460: struct proc *p;
! 461: void *v;
! 462: register_t *retval;
! 463: {
! 464: struct sunos_sys_mmap_args *uap = v;
! 465: struct sys_mmap_args ouap;
! 466:
! 467: /*
! 468: * Verify the arguments.
! 469: */
! 470: if (SCARG(uap, prot) & ~(PROT_READ|PROT_WRITE|PROT_EXEC))
! 471: return (EINVAL); /* XXX still needed? */
! 472:
! 473: if ((SCARG(uap, flags) & SUNOS__MAP_NEW) == 0)
! 474: return (EINVAL);
! 475:
! 476: SCARG(&ouap, flags) = SCARG(uap, flags) & ~SUNOS__MAP_NEW;
! 477: SCARG(&ouap, addr) = SCARG(uap, addr);
! 478:
! 479: if ((SCARG(&ouap, flags) & MAP_FIXED) == 0 &&
! 480: SCARG(&ouap, addr) != 0 &&
! 481: SCARG(&ouap, addr) < (void *)round_page((vaddr_t)p->p_vmspace->vm_daddr+MAXDSIZ))
! 482: SCARG(&ouap, addr) = (void *)round_page((vaddr_t)p->p_vmspace->vm_daddr+MAXDSIZ);
! 483:
! 484: SCARG(&ouap, len) = SCARG(uap, len);
! 485: SCARG(&ouap, prot) = SCARG(uap, prot);
! 486: SCARG(&ouap, fd) = SCARG(uap, fd);
! 487: SCARG(&ouap, pos) = SCARG(uap, pos);
! 488:
! 489: return (sys_mmap(p, &ouap, retval));
! 490: }
! 491:
! 492: #define MC_SYNC 1
! 493: #define MC_LOCK 2
! 494: #define MC_UNLOCK 3
! 495: #define MC_ADVISE 4
! 496: #define MC_LOCKAS 5
! 497: #define MC_UNLOCKAS 6
! 498:
! 499: int
! 500: sunos_sys_mctl(p, v, retval)
! 501: register struct proc *p;
! 502: void *v;
! 503: register_t *retval;
! 504: {
! 505: register struct sunos_sys_mctl_args *uap = v;
! 506:
! 507: switch (SCARG(uap, func)) {
! 508: case MC_ADVISE: /* ignore for now */
! 509: return (0);
! 510: case MC_SYNC: /* translate to msync */
! 511: return (sys_msync(p, uap, retval));
! 512: default:
! 513: return (EINVAL);
! 514: }
! 515: }
! 516:
! 517: int
! 518: sunos_sys_setsockopt(p, v, retval)
! 519: struct proc *p;
! 520: void *v;
! 521: register_t *retval;
! 522: {
! 523: struct sunos_sys_setsockopt_args *uap = v;
! 524: struct file *fp;
! 525: struct mbuf *m = NULL;
! 526: int error;
! 527:
! 528: if ((error = getsock(p->p_fd, SCARG(uap, s), &fp)) != 0)
! 529: return (error);
! 530: #define SO_DONTLINGER (~SO_LINGER)
! 531: if (SCARG(uap, name) == SO_DONTLINGER) {
! 532: m = m_get(M_WAIT, MT_SOOPTS);
! 533: mtod(m, struct linger *)->l_onoff = 0;
! 534: m->m_len = sizeof(struct linger);
! 535: error = (sosetopt((struct socket *)fp->f_data, SCARG(uap, level),
! 536: SO_LINGER, m));
! 537: goto bad;
! 538: }
! 539: if (SCARG(uap, level) == IPPROTO_IP) {
! 540: #define SUNOS_IP_MULTICAST_IF 2
! 541: #define SUNOS_IP_MULTICAST_TTL 3
! 542: #define SUNOS_IP_MULTICAST_LOOP 4
! 543: #define SUNOS_IP_ADD_MEMBERSHIP 5
! 544: #define SUNOS_IP_DROP_MEMBERSHIP 6
! 545: static int ipoptxlat[] = {
! 546: IP_MULTICAST_IF,
! 547: IP_MULTICAST_TTL,
! 548: IP_MULTICAST_LOOP,
! 549: IP_ADD_MEMBERSHIP,
! 550: IP_DROP_MEMBERSHIP
! 551: };
! 552: if (SCARG(uap, name) >= SUNOS_IP_MULTICAST_IF &&
! 553: SCARG(uap, name) <= SUNOS_IP_DROP_MEMBERSHIP) {
! 554: SCARG(uap, name) =
! 555: ipoptxlat[SCARG(uap, name) - SUNOS_IP_MULTICAST_IF];
! 556: }
! 557: }
! 558: if (SCARG(uap, valsize) > MLEN) {
! 559: error = EINVAL;
! 560: goto bad;
! 561: }
! 562: if (SCARG(uap, val)) {
! 563: m = m_get(M_WAIT, MT_SOOPTS);
! 564: error = copyin(SCARG(uap, val), mtod(m, caddr_t),
! 565: (u_int)SCARG(uap, valsize));
! 566: if (error) {
! 567: (void) m_free(m);
! 568: goto bad;
! 569: }
! 570: m->m_len = SCARG(uap, valsize);
! 571: }
! 572: error = (sosetopt((struct socket *)fp->f_data, SCARG(uap, level),
! 573: SCARG(uap, name), m));
! 574: bad:
! 575: FRELE(fp);
! 576: return (error);
! 577: }
! 578:
! 579: int
! 580: sunos_sys_fchroot(p, v, retval)
! 581: register struct proc *p;
! 582: void *v;
! 583: register_t *retval;
! 584: {
! 585: register struct sunos_sys_fchroot_args *uap = v;
! 586: register struct filedesc *fdp = p->p_fd;
! 587: register struct vnode *vp;
! 588: struct file *fp;
! 589: int error;
! 590:
! 591: if ((error = suser(p, 0)) != 0)
! 592: return (error);
! 593: if ((error = getvnode(fdp, SCARG(uap, fd), &fp)) != 0)
! 594: return (error);
! 595: vp = (struct vnode *)fp->f_data;
! 596: vn_lock(vp, LK_EXCLUSIVE | LK_RETRY, p);
! 597: if (vp->v_type != VDIR)
! 598: error = ENOTDIR;
! 599: else
! 600: error = VOP_ACCESS(vp, VEXEC, p->p_ucred, p);
! 601: VOP_UNLOCK(vp, 0, p);
! 602: if (error) {
! 603: FRELE(fp);
! 604: return (error);
! 605: }
! 606: VREF(vp);
! 607: if (fdp->fd_rdir != NULL)
! 608: vrele(fdp->fd_rdir);
! 609: fdp->fd_rdir = vp;
! 610: FRELE(fp);
! 611: return (0);
! 612: }
! 613:
! 614: /*
! 615: * XXX: This needs cleaning up.
! 616: */
! 617: int
! 618: sunos_sys_auditsys(p, v, retval)
! 619: struct proc *p;
! 620: void *v;
! 621: register_t *retval;
! 622: {
! 623: return 0;
! 624: }
! 625:
! 626: int
! 627: sunos_sys_uname(p, v, retval)
! 628: struct proc *p;
! 629: void *v;
! 630: register_t *retval;
! 631: {
! 632: struct sunos_sys_uname_args *uap = v;
! 633: struct sunos_utsname sut;
! 634: extern char machine[];
! 635:
! 636: bzero(&sut, sizeof(sut));
! 637:
! 638: bcopy(ostype, sut.sysname, sizeof(sut.sysname) - 1);
! 639: bcopy(hostname, sut.nodename, sizeof(sut.nodename));
! 640: sut.nodename[sizeof(sut.nodename)-1] = '\0';
! 641: bcopy(osrelease, sut.release, sizeof(sut.release) - 1);
! 642: strlcpy(sut.version, "1", sizeof(sut.version));
! 643: bcopy(machine, sut.machine, sizeof(sut.machine) - 1);
! 644:
! 645: return copyout((caddr_t)&sut, (caddr_t)SCARG(uap, name),
! 646: sizeof(struct sunos_utsname));
! 647: }
! 648:
! 649: int
! 650: sunos_sys_setpgrp(p, v, retval)
! 651: struct proc *p;
! 652: void *v;
! 653: register_t *retval;
! 654: {
! 655: struct sunos_sys_setpgrp_args *uap = v;
! 656:
! 657: /*
! 658: * difference to our setpgid call is to include backwards
! 659: * compatibility to pre-setsid() binaries. Do setsid()
! 660: * instead of setpgid() in those cases where the process
! 661: * tries to create a new session the old way.
! 662: */
! 663: if (!SCARG(uap, pgid) &&
! 664: (!SCARG(uap, pid) || SCARG(uap, pid) == p->p_pid))
! 665: return sys_setsid(p, uap, retval);
! 666: else
! 667: return sys_setpgid(p, uap, retval);
! 668: }
! 669:
! 670: int
! 671: sunos_sys_open(p, v, retval)
! 672: struct proc *p;
! 673: void *v;
! 674: register_t *retval;
! 675: {
! 676: struct sunos_sys_open_args *uap = v;
! 677: int l, r;
! 678: int noctty;
! 679: int ret;
! 680:
! 681: caddr_t sg = stackgap_init(p->p_emul);
! 682: SUNOS_CHECK_ALT_EXIST(p, &sg, SCARG(uap, path));
! 683:
! 684: /* convert mode into NetBSD mode */
! 685: l = SCARG(uap, flags);
! 686: noctty = l & 0x8000;
! 687: r = (l & (0x0001 | 0x0002 | 0x0008 | 0x0040 | 0x0200 | 0x0400 | 0x0800));
! 688: r |= ((l & (0x0004 | 0x1000 | 0x4000)) ? O_NONBLOCK : 0);
! 689: r |= ((l & 0x0080) ? O_SHLOCK : 0);
! 690: r |= ((l & 0x0100) ? O_EXLOCK : 0);
! 691: r |= ((l & 0x2000) ? O_SYNC : 0);
! 692:
! 693: SCARG(uap, flags) = r;
! 694: ret = sys_open(p, (struct sys_open_args *)uap, retval);
! 695:
! 696: if (!ret && !noctty && SESS_LEADER(p) && !(p->p_flag & P_CONTROLT)) {
! 697: struct filedesc *fdp = p->p_fd;
! 698: struct file *fp;
! 699:
! 700: if ((fp = fd_getfile(fdp, *retval)) == NULL)
! 701: return (EBADF);
! 702: FREF(fp);
! 703: /* ignore any error, just give it a try */
! 704: if (fp->f_type == DTYPE_VNODE)
! 705: (fp->f_ops->fo_ioctl)(fp, TIOCSCTTY, (caddr_t)0, p);
! 706: FRELE(fp);
! 707: }
! 708: return ret;
! 709: }
! 710:
! 711: #if defined (NFSSERVER)
! 712: int
! 713: sunos_sys_nfssvc(p, v, retval)
! 714: struct proc *p;
! 715: void *v;
! 716: register_t *retval;
! 717: {
! 718: #if 0
! 719: struct sunos_sys_nfssvc_args *uap = v;
! 720: struct emul *e = p->p_emul;
! 721: struct sys_nfssvc_args outuap;
! 722: struct sockaddr sa;
! 723: int error;
! 724:
! 725: bzero(&outuap, sizeof outuap);
! 726: SCARG(&outuap, fd) = SCARG(uap, fd);
! 727: SCARG(&outuap, mskval) = STACKGAPBASE;
! 728: SCARG(&outuap, msklen) = sizeof sa;
! 729: SCARG(&outuap, mtchval) = SCARG(&outuap, mskval) + sizeof sa;
! 730: SCARG(&outuap, mtchlen) = sizeof sa;
! 731:
! 732: bzero(&sa, sizeof sa);
! 733: if (error = copyout(&sa, SCARG(&outuap, mskval), SCARG(&outuap, msklen)))
! 734: return (error);
! 735: if (error = copyout(&sa, SCARG(&outuap, mtchval), SCARG(&outuap, mtchlen)))
! 736: return (error);
! 737:
! 738: return nfssvc(p, &outuap, retval);
! 739: #else
! 740: return (ENOSYS);
! 741: #endif
! 742: }
! 743: #endif /* NFSSERVER */
! 744:
! 745: int
! 746: sunos_sys_ustat(p, v, retval)
! 747: struct proc *p;
! 748: void *v;
! 749: register_t *retval;
! 750: {
! 751: struct sunos_sys_ustat_args *uap = v;
! 752: struct sunos_ustat us;
! 753: int error;
! 754:
! 755: bzero(&us, sizeof us);
! 756:
! 757: /*
! 758: * XXX: should set f_tfree and f_tinode at least
! 759: * How do we translate dev -> fstat? (and then to sunos_ustat)
! 760: */
! 761:
! 762: if ((error = copyout(&us, SCARG(uap, buf), sizeof us)) != 0)
! 763: return (error);
! 764: return 0;
! 765: }
! 766:
! 767: int
! 768: sunos_sys_quotactl(p, v, retval)
! 769: struct proc *p;
! 770: void *v;
! 771: register_t *retval;
! 772: {
! 773:
! 774: return EINVAL;
! 775: }
! 776:
! 777: int
! 778: sunos_sys_vhangup(p, v, retval)
! 779: struct proc *p;
! 780: void *v;
! 781: register_t *retval;
! 782: {
! 783: struct session *sp = p->p_session;
! 784:
! 785: if (sp->s_ttyvp == 0)
! 786: return 0;
! 787:
! 788: if (sp->s_ttyp && sp->s_ttyp->t_session == sp && sp->s_ttyp->t_pgrp)
! 789: pgsignal(sp->s_ttyp->t_pgrp, SIGHUP, 1);
! 790:
! 791: (void) ttywait(sp->s_ttyp);
! 792: if (sp->s_ttyvp)
! 793: VOP_REVOKE(sp->s_ttyvp, REVOKEALL);
! 794: if (sp->s_ttyvp)
! 795: vrele(sp->s_ttyvp);
! 796: sp->s_ttyvp = NULL;
! 797:
! 798: return 0;
! 799: }
! 800:
! 801: static int
! 802: sunstatfs(sp, buf)
! 803: struct statfs *sp;
! 804: caddr_t buf;
! 805: {
! 806: struct sunos_statfs ssfs;
! 807:
! 808: bzero(&ssfs, sizeof ssfs);
! 809: ssfs.f_type = 0;
! 810: ssfs.f_bsize = sp->f_bsize;
! 811: ssfs.f_blocks = sp->f_blocks;
! 812: ssfs.f_bfree = sp->f_bfree;
! 813: ssfs.f_bavail = sp->f_bavail;
! 814: ssfs.f_files = sp->f_files;
! 815: ssfs.f_ffree = sp->f_ffree;
! 816: ssfs.f_fsid = sp->f_fsid;
! 817: return copyout((caddr_t)&ssfs, buf, sizeof ssfs);
! 818: }
! 819:
! 820: int
! 821: sunos_sys_statfs(p, v, retval)
! 822: struct proc *p;
! 823: void *v;
! 824: register_t *retval;
! 825: {
! 826: struct sunos_sys_statfs_args *uap = v;
! 827: register struct mount *mp;
! 828: register struct statfs *sp;
! 829: int error;
! 830: struct nameidata nd;
! 831:
! 832: caddr_t sg = stackgap_init(p->p_emul);
! 833: SUNOS_CHECK_ALT_EXIST(p, &sg, SCARG(uap, path));
! 834:
! 835: NDINIT(&nd, LOOKUP, FOLLOW, UIO_USERSPACE, SCARG(uap, path), p);
! 836: if ((error = namei(&nd)) != 0)
! 837: return (error);
! 838: mp = nd.ni_vp->v_mount;
! 839: sp = &mp->mnt_stat;
! 840: vrele(nd.ni_vp);
! 841: if ((error = VFS_STATFS(mp, sp, p)) != 0)
! 842: return (error);
! 843: sp->f_flags = mp->mnt_flag & MNT_VISFLAGMASK;
! 844: return sunstatfs(sp, (caddr_t)SCARG(uap, buf));
! 845: }
! 846:
! 847: int
! 848: sunos_sys_fstatfs(p, v, retval)
! 849: struct proc *p;
! 850: void *v;
! 851: register_t *retval;
! 852: {
! 853: struct sunos_sys_fstatfs_args *uap = v;
! 854: struct file *fp;
! 855: struct mount *mp;
! 856: struct statfs *sp;
! 857: int error;
! 858:
! 859: if ((error = getvnode(p->p_fd, SCARG(uap, fd), &fp)) != 0)
! 860: return (error);
! 861: mp = ((struct vnode *)fp->f_data)->v_mount;
! 862: sp = &mp->mnt_stat;
! 863: error = VFS_STATFS(mp, sp, p);
! 864: FRELE(fp);
! 865: if (error)
! 866: return (error);
! 867: sp->f_flags = mp->mnt_flag & MNT_VISFLAGMASK;
! 868: return sunstatfs(sp, (caddr_t)SCARG(uap, buf));
! 869: }
! 870:
! 871: int
! 872: sunos_sys_exportfs(p, v, retval)
! 873: struct proc *p;
! 874: void *v;
! 875: register_t *retval;
! 876: {
! 877: /*
! 878: * XXX: should perhaps translate into a mount(2)
! 879: * with MOUNT_EXPORT?
! 880: */
! 881: return 0;
! 882: }
! 883:
! 884: int
! 885: sunos_sys_mknod(p, v, retval)
! 886: struct proc *p;
! 887: void *v;
! 888: register_t *retval;
! 889: {
! 890: struct sunos_sys_mknod_args *uap = v;
! 891:
! 892: caddr_t sg = stackgap_init(p->p_emul);
! 893: SUNOS_CHECK_ALT_EXIST(p, &sg, SCARG(uap, path));
! 894:
! 895: if (S_ISFIFO(SCARG(uap, mode)))
! 896: return sys_mkfifo(p, uap, retval);
! 897:
! 898: return sys_mknod(p, (struct sys_mknod_args *)uap, retval);
! 899: }
! 900:
! 901: #define SUNOS_SC_ARG_MAX 1
! 902: #define SUNOS_SC_CHILD_MAX 2
! 903: #define SUNOS_SC_CLK_TCK 3
! 904: #define SUNOS_SC_NGROUPS_MAX 4
! 905: #define SUNOS_SC_OPEN_MAX 5
! 906: #define SUNOS_SC_JOB_CONTROL 6
! 907: #define SUNOS_SC_SAVED_IDS 7
! 908: #define SUNOS_SC_VERSION 8
! 909:
! 910: int
! 911: sunos_sys_sysconf(p, v, retval)
! 912: struct proc *p;
! 913: void *v;
! 914: register_t *retval;
! 915: {
! 916: struct sunos_sys_sysconf_args *uap = v;
! 917: extern int maxfiles;
! 918:
! 919: switch(SCARG(uap, name)) {
! 920: case SUNOS_SC_ARG_MAX:
! 921: *retval = ARG_MAX;
! 922: break;
! 923: case SUNOS_SC_CHILD_MAX:
! 924: *retval = maxproc;
! 925: break;
! 926: case SUNOS_SC_CLK_TCK:
! 927: *retval = 60; /* should this be `hz', ie. 100? */
! 928: break;
! 929: case SUNOS_SC_NGROUPS_MAX:
! 930: *retval = NGROUPS_MAX;
! 931: break;
! 932: case SUNOS_SC_OPEN_MAX:
! 933: *retval = maxfiles;
! 934: break;
! 935: case SUNOS_SC_JOB_CONTROL:
! 936: *retval = 1;
! 937: break;
! 938: case SUNOS_SC_SAVED_IDS:
! 939: #ifdef _POSIX_SAVED_IDS
! 940: *retval = 1;
! 941: #else
! 942: *retval = 0;
! 943: #endif
! 944: break;
! 945: case SUNOS_SC_VERSION:
! 946: *retval = 198808;
! 947: break;
! 948: default:
! 949: return EINVAL;
! 950: }
! 951: return 0;
! 952: }
! 953:
! 954: #define SUNOS_RLIMIT_NOFILE 6 /* Other RLIMIT_* are the same */
! 955: #define SUNOS_RLIM_NLIMITS 7
! 956:
! 957: int
! 958: sunos_sys_getrlimit(p, v, retval)
! 959: struct proc *p;
! 960: void *v;
! 961: register_t *retval;
! 962: {
! 963: struct sunos_sys_getrlimit_args *uap = v;
! 964:
! 965: if (SCARG(uap, which) >= SUNOS_RLIM_NLIMITS)
! 966: return EINVAL;
! 967:
! 968: if (SCARG(uap, which) == SUNOS_RLIMIT_NOFILE)
! 969: SCARG(uap, which) = RLIMIT_NOFILE;
! 970:
! 971: return compat_43_sys_getrlimit(p, uap, retval);
! 972: }
! 973:
! 974: int
! 975: sunos_sys_setrlimit(p, v, retval)
! 976: struct proc *p;
! 977: void *v;
! 978: register_t *retval;
! 979: {
! 980: struct sunos_sys_getrlimit_args *uap = v;
! 981:
! 982: if (SCARG(uap, which) >= SUNOS_RLIM_NLIMITS)
! 983: return EINVAL;
! 984:
! 985: if (SCARG(uap, which) == SUNOS_RLIMIT_NOFILE)
! 986: SCARG(uap, which) = RLIMIT_NOFILE;
! 987:
! 988: return compat_43_sys_setrlimit(p, uap, retval);
! 989: }
! 990:
! 991: #ifdef PTRACE
! 992:
! 993: static int sreq2breq[] = {
! 994: PT_TRACE_ME, PT_READ_I, PT_READ_D, -1,
! 995: PT_WRITE_I, PT_WRITE_D, -1, PT_CONTINUE,
! 996: PT_KILL, -1, PT_ATTACH, PT_DETACH,
! 997: PT_GETREGS, PT_SETREGS, PT_GETFPREGS, PT_SETFPREGS
! 998: };
! 999: static int nreqs = sizeof(sreq2breq) / sizeof(sreq2breq[0]);
! 1000:
! 1001: int
! 1002: sunos_sys_ptrace(p, v, retval)
! 1003: struct proc *p;
! 1004: void *v;
! 1005: register_t *retval;
! 1006: {
! 1007: struct sunos_sys_ptrace_args *uap = v;
! 1008: struct sys_ptrace_args pa;
! 1009: int req;
! 1010:
! 1011: req = SCARG(uap, req);
! 1012:
! 1013: if (req < 0 || req >= nreqs)
! 1014: return (EINVAL);
! 1015:
! 1016: req = sreq2breq[req];
! 1017: if (req == -1)
! 1018: return (EINVAL);
! 1019:
! 1020: SCARG(&pa, req) = req;
! 1021: SCARG(&pa, pid) = (pid_t)SCARG(uap, pid);
! 1022: SCARG(&pa, addr) = (caddr_t)SCARG(uap, addr);
! 1023: SCARG(&pa, data) = SCARG(uap, data);
! 1024:
! 1025: return sys_ptrace(p, &pa, retval);
! 1026: }
! 1027:
! 1028: #endif /* PTRACE */
! 1029:
! 1030: /*
! 1031: * SunOS reboot system call (for compatibility).
! 1032: * Sun lets you pass in a boot string which the PROM
! 1033: * saves and provides to the next boot program.
! 1034: */
! 1035: static struct sunos_howto_conv {
! 1036: int sun_howto;
! 1037: int bsd_howto;
! 1038: } sunos_howto_conv[] = {
! 1039: { 0x001, RB_ASKNAME },
! 1040: { 0x002, RB_SINGLE },
! 1041: { 0x004, RB_NOSYNC },
! 1042: { 0x008, RB_HALT },
! 1043: { 0x080, RB_DUMP },
! 1044: { 0x000, 0 },
! 1045: };
! 1046: #define SUNOS_RB_STRING 0x200
! 1047:
! 1048: int
! 1049: sunos_sys_reboot(p, v, retval)
! 1050: struct proc *p;
! 1051: void *v;
! 1052: register_t *retval;
! 1053: {
! 1054: struct sunos_sys_reboot_args *uap = v;
! 1055: struct sunos_howto_conv *convp;
! 1056: int error, bsd_howto, sun_howto;
! 1057:
! 1058: if ((error = suser(p, 0)) != 0)
! 1059: return (error);
! 1060:
! 1061: /*
! 1062: * Convert howto bits to BSD format.
! 1063: */
! 1064: sun_howto = SCARG(uap, howto);
! 1065: bsd_howto = 0;
! 1066: convp = sunos_howto_conv;
! 1067: while (convp->sun_howto) {
! 1068: if (sun_howto & convp->sun_howto)
! 1069: bsd_howto |= convp->bsd_howto;
! 1070: convp++;
! 1071: }
! 1072:
! 1073: #ifdef sun3
! 1074: /*
! 1075: * Sun RB_STRING (Get user supplied bootstring.)
! 1076: * If the machine supports passing a string to the
! 1077: * next booted kernel, add the machine name above
! 1078: * and provide a reboot2() function (see sun3).
! 1079: */
! 1080: if (sun_howto & SUNOS_RB_STRING) {
! 1081: char bs[128];
! 1082:
! 1083: error = copyinstr(SCARG(uap, bootstr), bs, sizeof(bs), 0);
! 1084: if (error)
! 1085: return error;
! 1086:
! 1087: return (reboot2(bsd_howto, bs));
! 1088: }
! 1089: #endif /* sun3 */
! 1090:
! 1091: boot(bsd_howto);
! 1092: return 0;
! 1093: }
! 1094:
! 1095: /*
! 1096: * Generalized interface signal handler, 4.3-compatible.
! 1097: */
! 1098: /* ARGSUSED */
! 1099: int
! 1100: sunos_sys_sigvec(p, v, retval)
! 1101: struct proc *p;
! 1102: void *v;
! 1103: register_t *retval;
! 1104: {
! 1105: register struct sunos_sys_sigvec_args /* {
! 1106: syscallarg(int) signum;
! 1107: syscallarg(struct sigvec *) nsv;
! 1108: syscallarg(struct sigvec *) osv;
! 1109: } */ *uap = v;
! 1110: struct sigvec vec;
! 1111: register struct sigacts *ps = p->p_sigacts;
! 1112: register struct sigvec *sv;
! 1113: register int signum;
! 1114: int bit, error;
! 1115:
! 1116: signum = SCARG(uap, signum);
! 1117: if (signum <= 0 || signum >= NSIG ||
! 1118: signum == SIGKILL || signum == SIGSTOP)
! 1119: return (EINVAL);
! 1120: sv = &vec;
! 1121: if (SCARG(uap, osv)) {
! 1122: *(sig_t *)&sv->sv_handler = ps->ps_sigact[signum];
! 1123: sv->sv_mask = ps->ps_catchmask[signum];
! 1124: bit = sigmask(signum);
! 1125: sv->sv_flags = 0;
! 1126: if ((ps->ps_sigonstack & bit) != 0)
! 1127: sv->sv_flags |= SV_ONSTACK;
! 1128: if ((ps->ps_sigintr & bit) != 0)
! 1129: sv->sv_flags |= SV_INTERRUPT;
! 1130: if ((ps->ps_sigreset & bit) != 0)
! 1131: sv->sv_flags |= SA_RESETHAND;
! 1132: sv->sv_mask &= ~bit;
! 1133: error = copyout((caddr_t)sv, (caddr_t)SCARG(uap, osv),
! 1134: sizeof (vec));
! 1135: if (error)
! 1136: return (error);
! 1137: }
! 1138: if (SCARG(uap, nsv)) {
! 1139: error = copyin((caddr_t)SCARG(uap, nsv), (caddr_t)sv,
! 1140: sizeof (vec));
! 1141: if (error)
! 1142: return (error);
! 1143: /*
! 1144: * SunOS uses the mask 0x0004 as SV_RESETHAND
! 1145: * meaning: `reset to SIG_DFL on delivery'.
! 1146: * We support only the bits in: 0xF
! 1147: * (those bits are the same as ours)
! 1148: */
! 1149: if (sv->sv_flags & ~0xF)
! 1150: return (EINVAL);
! 1151: /* SunOS binaries have a user-mode trampoline. */
! 1152: sv->sv_flags |= SA_USERTRAMP;
! 1153: /* Convert sigvec:SV_INTERRUPT to sigaction:SA_RESTART */
! 1154: sv->sv_flags ^= SA_RESTART; /* same bit, inverted */
! 1155: setsigvec(p, signum, (struct sigaction *)sv);
! 1156: }
! 1157: return (0);
! 1158: }
! 1159:
! 1160: int
! 1161: sunos_sys_ostime(p, v, retval)
! 1162: struct proc *p;
! 1163: void *v;
! 1164: register_t *retval;
! 1165: {
! 1166: struct sunos_sys_ostime_args /* {
! 1167: syscallarg(int) time;
! 1168: } */ *uap = v;
! 1169: struct timespec ts;
! 1170: int error;
! 1171:
! 1172: if ((error = suser(p, 0)) != 0)
! 1173: return (error);
! 1174:
! 1175: ts.tv_sec = SCARG(uap, time);
! 1176: ts.tv_nsec = 0;
! 1177: error = settime(&ts);
! 1178: return (error);
! 1179: }
! 1180:
! 1181: /*
! 1182: * This code is partly stolen from src/lib/libc/gen/times.c
! 1183: * XXX - CLK_TCK isn't declared in /sys, just in <time.h>, done here
! 1184: */
! 1185:
! 1186: #define CLK_TCK 100
! 1187: #define CONVTCK(r) (r.tv_sec * CLK_TCK + r.tv_usec / (1000000 / CLK_TCK))
! 1188:
! 1189: int
! 1190: sunos_sys_otimes(p, v, retval)
! 1191: struct proc *p;
! 1192: void *v;
! 1193: register_t *retval;
! 1194: {
! 1195: struct sunos_sys_otimes_args /* {
! 1196: syscallarg(struct tms *) tp;
! 1197: } */ *uap = v;
! 1198: struct tms tms;
! 1199: struct rusage ru, *rup;
! 1200:
! 1201: /* RUSAGE_SELF */
! 1202: calcru(p, &ru.ru_utime, &ru.ru_stime, NULL);
! 1203: tms.tms_utime = CONVTCK(ru.ru_utime);
! 1204: tms.tms_stime = CONVTCK(ru.ru_stime);
! 1205:
! 1206: /* RUSAGE_CHILDREN */
! 1207: rup = &p->p_stats->p_cru;
! 1208: tms.tms_cutime = CONVTCK(rup->ru_utime);
! 1209: tms.tms_cstime = CONVTCK(rup->ru_stime);
! 1210:
! 1211: return copyout(&tms, SCARG(uap, tp), sizeof(*(SCARG(uap, tp))));
! 1212: }
CVSweb
![[BACK]](/icons/back.gif){kind=icon}
Return to sunos_misc.c CVS log ![[TXT]](/icons/text.gif){kind=icon}
![[DIR]](/icons/dir.gif){kind=icon}
Up to [local] / sys / compat / sunos