Annotation of sys/compat/ultrix/ultrix_misc.c, Revision 1.1
1.1 ! nbrk 1: /* $OpenBSD: ultrix_misc.c,v 1.30 2007/06/06 17:15:13 deraadt Exp $ */
! 2: /* $NetBSD: ultrix_misc.c,v 1.23 1996/04/07 17:23:04 jonathan Exp $ */
! 3:
! 4: /*
! 5: * Copyright (c) 1995
! 6: * Jonathan Stone (hereinafter referred to as the author)
! 7: *
! 8: * Redistribution and use in source and binary forms, with or without
! 9: * modification, are permitted provided that the following conditions
! 10: * are met:
! 11: * 1. Redistributions of source code must retain the above copyright
! 12: * notice, this list of conditions and the following disclaimer.
! 13: * 2. Redistributions in binary form must reproduce the above copyright
! 14: * notice, this list of conditions and the following disclaimer in the
! 15: * documentation and/or other materials provided with the distribution.
! 16: * 3. The name of the author may not be used to endorse or promote products
! 17: * derived from this software without specific prior written permission.
! 18: *
! 19: * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND
! 20: * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
! 21: * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
! 22: * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR BE LIABLE
! 23: * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
! 24: * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
! 25: * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
! 26: * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
! 27: * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
! 28: * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
! 29: * SUCH DAMAGE.
! 30: */
! 31:
! 32: /*
! 33: * Copyright (c) 1992, 1993
! 34: * The Regents of the University of California. All rights reserved.
! 35: *
! 36: * This software was developed by the Computer Systems Engineering group
! 37: * at Lawrence Berkeley Laboratory under DARPA contract BG 91-66 and
! 38: * contributed to Berkeley.
! 39: *
! 40: * All advertising materials mentioning features or use of this software
! 41: * must display the following acknowledgement:
! 42: * This product includes software developed by the University of
! 43: * California, Lawrence Berkeley Laboratory.
! 44: *
! 45: * Redistribution and use in source and binary forms, with or without
! 46: * modification, are permitted provided that the following conditions
! 47: * are met:
! 48: * 1. Redistributions of source code must retain the above copyright
! 49: * notice, this list of conditions and the following disclaimer.
! 50: * 2. Redistributions in binary form must reproduce the above copyright
! 51: * notice, this list of conditions and the following disclaimer in the
! 52: * documentation and/or other materials provided with the distribution.
! 53: * 3. Neither the name of the University nor the names of its contributors
! 54: * may be used to endorse or promote products derived from this software
! 55: * without specific prior written permission.
! 56: *
! 57: * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
! 58: * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
! 59: * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
! 60: * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
! 61: * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
! 62: * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
! 63: * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
! 64: * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
! 65: * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
! 66: * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
! 67: * SUCH DAMAGE.
! 68: *
! 69: *
! 70: * @(#)sun_misc.c 8.1 (Berkeley) 6/18/93
! 71: *
! 72: * from: Header: sun_misc.c,v 1.16 93/04/07 02:46:27 torek Exp
! 73: */
! 74:
! 75: /*
! 76: * SunOS compatibility module.
! 77: *
! 78: * SunOS system calls that are implemented differently in BSD are
! 79: * handled here.
! 80: */
! 81:
! 82: #include <sys/param.h>
! 83: #include <sys/systm.h>
! 84: #include <sys/namei.h>
! 85: #include <sys/dirent.h>
! 86: #include <sys/proc.h>
! 87: #include <sys/file.h>
! 88: #include <sys/filedesc.h>
! 89: /*#include <sys/stat.h>*/
! 90: /*#include <sys/ioctl.h>*/
! 91: #include <sys/kernel.h>
! 92: #include <sys/exec.h>
! 93: #include <sys/malloc.h>
! 94: #include <sys/mbuf.h>
! 95: #include <sys/mman.h>
! 96: #include <sys/mount.h>
! 97: #include <sys/resource.h>
! 98: #include <sys/resourcevar.h>
! 99: #include <sys/signal.h>
! 100: #include <sys/signalvar.h>
! 101: #include <sys/socket.h>
! 102: #include <sys/vnode.h>
! 103: #include <sys/uio.h>
! 104: #include <sys/wait.h>
! 105: #include <sys/utsname.h>
! 106: #include <sys/unistd.h>
! 107:
! 108: #include <sys/syscallargs.h>
! 109:
! 110: #include <compat/ultrix/ultrix_syscall.h>
! 111: #include <compat/ultrix/ultrix_syscallargs.h>
! 112: #include <compat/ultrix/ultrix_util.h>
! 113:
! 114: #include <netinet/in.h>
! 115:
! 116: #include <miscfs/specfs/specdev.h>
! 117:
! 118: #include <nfs/rpcv2.h>
! 119: #include <nfs/nfsproto.h>
! 120: #include <nfs/nfs.h>
! 121:
! 122: #include <uvm/uvm_extern.h>
! 123:
! 124: #include <sys/conf.h> /* iszerodev() */
! 125: #include <sys/socketvar.h> /* sosetopt() */
! 126:
! 127: extern struct sysent ultrix_sysent[];
! 128: #ifdef SYSCALL_DEBUG
! 129: extern char *ultrix_syscallnames[];
! 130: #endif
! 131:
! 132: /*
! 133: * Select the appropriate setregs callback for the target architecture.
! 134: */
! 135: #ifdef __mips__
! 136: #define ULTRIX_EXEC_SETREGS cpu_exec_ecoff_setregs
! 137: #endif /* __mips__ */
! 138:
! 139: #ifdef __vax__
! 140: #define ULTRIX_EXEC_SETREGS setregs
! 141: #endif /* __vax__ */
! 142:
! 143:
! 144: extern void ULTRIX_EXEC_SETREGS(struct proc *, struct exec_package *,
! 145: u_long, register_t *);
! 146: extern char sigcode[], esigcode[];
! 147:
! 148: struct emul emul_ultrix = {
! 149: "ultrix",
! 150: NULL,
! 151: sendsig,
! 152: ULTRIX_SYS_syscall,
! 153: ULTRIX_SYS_MAXSYSCALL,
! 154: ultrix_sysent,
! 155: #ifdef SYSCALL_DEBUG
! 156: ultrix_syscallnames,
! 157: #else
! 158: NULL,
! 159: #endif
! 160: 0,
! 161: copyargs,
! 162: ULTRIX_EXEC_SETREGS,
! 163: NULL,
! 164: sigcode,
! 165: esigcode,
! 166: };
! 167:
! 168: #define GSI_PROG_ENV 1
! 169:
! 170: int
! 171: ultrix_sys_getsysinfo(p, v, retval)
! 172: struct proc *p;
! 173: void *v;
! 174: register_t *retval;
! 175: {
! 176: struct ultrix_sys_getsysinfo_args *uap = v;
! 177: static short progenv = 0;
! 178:
! 179: switch (SCARG(uap, op)) {
! 180: /* operations implemented: */
! 181: case GSI_PROG_ENV:
! 182: if (SCARG(uap, nbytes) < sizeof(short))
! 183: return EINVAL;
! 184: *retval = 1;
! 185: return (copyout(&progenv, SCARG(uap, buffer), sizeof(short)));
! 186: default:
! 187: *retval = 0; /* info unavail */
! 188: return 0;
! 189: }
! 190: }
! 191:
! 192: int
! 193: ultrix_sys_setsysinfo(p, v, retval)
! 194: struct proc *p;
! 195: void *v;
! 196: register_t *retval;
! 197: {
! 198:
! 199: #ifdef notyet
! 200: struct ultrix_sys_setsysinfo_args *uap = v;
! 201: #endif
! 202:
! 203: *retval = 0;
! 204: return 0;
! 205: }
! 206:
! 207: int
! 208: ultrix_sys_waitpid(p, v, retval)
! 209: struct proc *p;
! 210: void *v;
! 211: register_t *retval;
! 212: {
! 213: struct ultrix_sys_waitpid_args *uap = v;
! 214: struct sys_wait4_args ua;
! 215:
! 216: SCARG(&ua, pid) = SCARG(uap, pid);
! 217: SCARG(&ua, status) = SCARG(uap, status);
! 218: SCARG(&ua, options) = SCARG(uap, options);
! 219: SCARG(&ua, rusage) = 0;
! 220:
! 221: return (sys_wait4(p, &ua, retval));
! 222: }
! 223:
! 224: int
! 225: ultrix_sys_wait3(p, v, retval)
! 226: struct proc *p;
! 227: void *v;
! 228: register_t *retval;
! 229: {
! 230: struct ultrix_sys_wait3_args *uap = v;
! 231: struct sys_wait4_args ua;
! 232:
! 233: SCARG(&ua, pid) = -1;
! 234: SCARG(&ua, status) = SCARG(uap, status);
! 235: SCARG(&ua, options) = SCARG(uap, options);
! 236: SCARG(&ua, rusage) = SCARG(uap, rusage);
! 237:
! 238: return (sys_wait4(p, &ua, retval));
! 239: }
! 240:
! 241: /*
! 242: * Ultrix binaries pass in FD_MAX as the first arg to select().
! 243: * On Ultrix, FD_MAX is 4096, which is more than the NetBSD sys_select()
! 244: * can handle.
! 245: * Since we can't have more than the (native) FD_MAX descriptors open,
! 246: * limit nfds to at most FD_MAX.
! 247: */
! 248: int
! 249: ultrix_sys_select(p, v, retval)
! 250: struct proc *p;
! 251: void *v;
! 252: register_t *retval;
! 253: {
! 254: struct sys_select_args *uap = v;
! 255: struct timeval atv;
! 256: int error;
! 257:
! 258: /* Limit number of FDs selected on to the native maximum */
! 259:
! 260: if (SCARG(uap, nd) > FD_SETSIZE)
! 261: SCARG(uap, nd) = FD_SETSIZE;
! 262:
! 263: /* Check for negative timeval */
! 264: if (SCARG(uap, tv)) {
! 265: error = copyin((caddr_t)SCARG(uap, tv), (caddr_t)&atv,
! 266: sizeof(atv));
! 267: if (error)
! 268: goto done;
! 269: #ifdef DEBUG
! 270: /* Ultrix clients sometimes give negative timeouts? */
! 271: if (atv.tv_sec < 0 || atv.tv_usec < 0)
! 272: printf("ultrix select( %ld, %ld): negative timeout\n",
! 273: atv.tv_sec, atv.tv_usec);
! 274: /*tvp = (timeval *)STACKGAPBASE;*/
! 275: #endif
! 276:
! 277: }
! 278: error = sys_select(p, (void *) uap, retval);
! 279: if (error == EINVAL)
! 280: printf("ultrix select: bad args?\n");
! 281:
! 282: done:
! 283: return error;
! 284: }
! 285:
! 286: #if defined(NFSCLIENT)
! 287: int
! 288: async_daemon(p, v, retval)
! 289: struct proc *p;
! 290: void *v;
! 291: register_t *retval;
! 292: {
! 293: struct sys_nfssvc_args ouap;
! 294:
! 295: SCARG(&ouap, flag) = NFSSVC_BIOD;
! 296: SCARG(&ouap, argp) = NULL;
! 297:
! 298: return (sys_nfssvc(p, &ouap, retval));
! 299: }
! 300: #endif /* NFSCLIENT */
! 301:
! 302:
! 303: #define SUN__MAP_NEW 0x80000000 /* if not, old mmap & cannot handle */
! 304:
! 305: int
! 306: ultrix_sys_mmap(p, v, retval)
! 307: struct proc *p;
! 308: void *v;
! 309: register_t *retval;
! 310: {
! 311: struct ultrix_sys_mmap_args *uap = v;
! 312: struct sys_mmap_args ouap;
! 313:
! 314: /*
! 315: * Verify the arguments.
! 316: */
! 317: if (SCARG(uap, prot) & ~(PROT_READ|PROT_WRITE|PROT_EXEC))
! 318: return (EINVAL); /* XXX still needed? */
! 319:
! 320: if ((SCARG(uap, flags) & SUN__MAP_NEW) == 0)
! 321: return (EINVAL);
! 322:
! 323: SCARG(&ouap, flags) = SCARG(uap, flags) & ~SUN__MAP_NEW;
! 324: SCARG(&ouap, addr) = SCARG(uap, addr);
! 325:
! 326: if ((SCARG(&ouap, flags) & MAP_FIXED) == 0 &&
! 327: SCARG(&ouap, addr) != 0 &&
! 328: SCARG(&ouap, addr) < (void *)round_page((vaddr_t)p->p_vmspace->vm_daddr+MAXDSIZ))
! 329: SCARG(&ouap, addr) = (void *)round_page((vaddr_t)p->p_vmspace->vm_daddr+MAXDSIZ);
! 330:
! 331: SCARG(&ouap, len) = SCARG(uap, len);
! 332: SCARG(&ouap, prot) = SCARG(uap, prot);
! 333: SCARG(&ouap, fd) = SCARG(uap, fd);
! 334: SCARG(&ouap, pos) = SCARG(uap, pos);
! 335:
! 336: return (sys_mmap(p, &ouap, retval));
! 337: }
! 338:
! 339: int
! 340: ultrix_sys_setsockopt(p, v, retval)
! 341: struct proc *p;
! 342: void *v;
! 343: register_t *retval;
! 344: {
! 345: register struct ultrix_sys_setsockopt_args *uap = v;
! 346: struct file *fp;
! 347: struct mbuf *m = NULL;
! 348: int error;
! 349:
! 350: if ((error = getsock(p->p_fd, SCARG(uap, s), &fp)) != 0)
! 351: return (error);
! 352: #define SO_DONTLINGER (~SO_LINGER)
! 353: if (SCARG(uap, name) == SO_DONTLINGER) {
! 354: m = m_get(M_WAIT, MT_SOOPTS);
! 355: mtod(m, struct linger *)->l_onoff = 0;
! 356: m->m_len = sizeof(struct linger);
! 357: error = (sosetopt((struct socket *)fp->f_data, SCARG(uap, level),
! 358: SO_LINGER, m));
! 359: goto bad;
! 360: }
! 361: if (SCARG(uap, valsize) > MLEN) {
! 362: error = EINVAL;
! 363: goto bad;
! 364: }
! 365: if (SCARG(uap, val)) {
! 366: m = m_get(M_WAIT, MT_SOOPTS);
! 367: if ((error = copyin(SCARG(uap, val), mtod(m, caddr_t),
! 368: (u_int)SCARG(uap, valsize))) != 0) {
! 369: (void) m_free(m);
! 370: goto bad;
! 371: }
! 372: m->m_len = SCARG(uap, valsize);
! 373: }
! 374: error = (sosetopt((struct socket *)fp->f_data, SCARG(uap, level),
! 375: SCARG(uap, name), m));
! 376: bad:
! 377: FRELE(fp);
! 378: return (error);
! 379: }
! 380:
! 381: struct ultrix_utsname {
! 382: char sysname[9];
! 383: char nodename[9];
! 384: char nodeext[65-9];
! 385: char release[9];
! 386: char version[9];
! 387: char machine[9];
! 388: };
! 389:
! 390: int
! 391: ultrix_sys_uname(p, v, retval)
! 392: struct proc *p;
! 393: void *v;
! 394: register_t *retval;
! 395: {
! 396: struct ultrix_sys_uname_args *uap = v;
! 397: struct ultrix_utsname sut;
! 398: extern char machine[];
! 399:
! 400: bzero(&sut, sizeof(sut));
! 401:
! 402: bcopy(ostype, sut.sysname, sizeof(sut.sysname) - 1);
! 403: bcopy(hostname, sut.nodename, sizeof(sut.nodename));
! 404: sut.nodename[sizeof(sut.nodename)-1] = '\0';
! 405: bcopy(osrelease, sut.release, sizeof(sut.release) - 1);
! 406: bcopy("1", sut.version, sizeof(sut.version) - 1);
! 407: bcopy(machine, sut.machine, sizeof(sut.machine) - 1);
! 408:
! 409: return copyout((caddr_t)&sut, (caddr_t)SCARG(uap, name),
! 410: sizeof(struct ultrix_utsname));
! 411: }
! 412:
! 413: int
! 414: ultrix_sys_setpgrp(p, v, retval)
! 415: struct proc *p;
! 416: void *v;
! 417: register_t *retval;
! 418: {
! 419: struct ultrix_sys_setpgrp_args *uap = v;
! 420:
! 421: /*
! 422: * difference to our setpgid call is to include backwards
! 423: * compatibility to pre-setsid() binaries. Do setsid()
! 424: * instead of setpgid() in those cases where the process
! 425: * tries to create a new session the old way.
! 426: */
! 427: if (!SCARG(uap, pgid) &&
! 428: (!SCARG(uap, pid) || SCARG(uap, pid) == p->p_pid))
! 429: return sys_setsid(p, uap, retval);
! 430: else
! 431: return sys_setpgid(p, uap, retval);
! 432: }
! 433:
! 434: #if defined (NFSSERVER)
! 435: int
! 436: ultrix_sys_nfssvc(p, v, retval)
! 437: struct proc *p;
! 438: void *v;
! 439: register_t *retval;
! 440: {
! 441:
! 442: #if 0 /* XXX */
! 443: struct ultrix_sys_nfssvc_args *uap = v;
! 444: struct emul *e = p->p_emul;
! 445: struct sys_nfssvc_args outuap;
! 446: struct sockaddr sa;
! 447: int error;
! 448:
! 449: bzero(&outuap, sizeof outuap);
! 450: SCARG(&outuap, fd) = SCARG(uap, fd);
! 451: SCARG(&outuap, mskval) = STACKGAPBASE;
! 452: SCARG(&outuap, msklen) = sizeof sa;
! 453: SCARG(&outuap, mtchval) = outuap.mskval + sizeof sa;
! 454: SCARG(&outuap, mtchlen) = sizeof sa;
! 455:
! 456: bzero(&sa, sizeof sa);
! 457: if (error = copyout(&sa, SCARG(&outuap, mskval), SCARG(&outuap, msklen)))
! 458: return (error);
! 459: if (error = copyout(&sa, SCARG(&outuap, mtchval), SCARG(&outuap, mtchlen)))
! 460: return (error);
! 461:
! 462: return nfssvc(p, &outuap, retval);
! 463: #else
! 464: return (ENOSYS);
! 465: #endif
! 466: }
! 467: #endif /* NFSSERVER */
! 468:
! 469: struct ultrix_ustat {
! 470: int32_t f_tfree; /* total free */
! 471: ino_t f_tinode; /* total inodes free */
! 472: char f_fname[6]; /* filsys name */
! 473: char f_fpack[6]; /* filsys pack name */
! 474: };
! 475:
! 476: int
! 477: ultrix_sys_ustat(p, v, retval)
! 478: struct proc *p;
! 479: void *v;
! 480: register_t *retval;
! 481: {
! 482: struct ultrix_sys_ustat_args *uap = v;
! 483: struct ultrix_ustat us;
! 484: int error;
! 485:
! 486: bzero(&us, sizeof us);
! 487:
! 488: /*
! 489: * XXX: should set f_tfree and f_tinode at least
! 490: * How do we translate dev -> fstat? (and then to ultrix_ustat)
! 491: */
! 492:
! 493: if ((error = copyout(&us, SCARG(uap, buf), sizeof us)) != 0)
! 494: return (error);
! 495: return 0;
! 496: }
! 497:
! 498: int
! 499: ultrix_sys_quotactl(p, v, retval)
! 500: struct proc *p;
! 501: void *v;
! 502: register_t *retval;
! 503: {
! 504:
! 505: #ifdef notyet
! 506: struct ultrix_sys_quotactl_args *uap = v;
! 507: #endif
! 508:
! 509: return EINVAL;
! 510: }
! 511:
! 512: int
! 513: ultrix_sys_vhangup(p, v, retval)
! 514: struct proc *p;
! 515: void *v;
! 516: register_t *retval;
! 517: {
! 518:
! 519: return 0;
! 520: }
! 521:
! 522: int
! 523: ultrix_sys_exportfs(p, v, retval)
! 524: struct proc *p;
! 525: void *v;
! 526: register_t *retval;
! 527: {
! 528: #ifdef notyet
! 529: struct ultrix_sys_exportfs_args *uap = v;
! 530: #endif
! 531:
! 532: /*
! 533: * XXX: should perhaps translate into a mount(2)
! 534: * with MOUNT_EXPORT?
! 535: */
! 536: return 0;
! 537: }
! 538:
! 539: int
! 540: ultrix_sys_sigpending(p, v, retval)
! 541: struct proc *p;
! 542: void *v;
! 543: register_t *retval;
! 544: {
! 545: struct ultrix_sys_sigpending_args *uap = v;
! 546: int mask = p->p_siglist & p->p_sigmask;
! 547:
! 548: return (copyout((caddr_t)&mask, (caddr_t)SCARG(uap, mask), sizeof(int)));
! 549: }
! 550:
! 551: int
! 552: ultrix_sys_sigcleanup(p, v, retval)
! 553: struct proc *p;
! 554: void *v;
! 555: register_t *retval;
! 556: {
! 557: struct ultrix_sys_sigcleanup_args *uap = v;
! 558:
! 559: return sys_sigreturn(p, (struct sys_sigreturn_args *)uap, retval);
! 560: }
! 561:
! 562: int
! 563: ultrix_sys_sigreturn(p, v, retval)
! 564: struct proc *p;
! 565: void *v;
! 566: register_t *retval;
! 567: {
! 568: struct ultrix_sys_sigcleanup_args *uap = v;
! 569:
! 570: #ifdef DEBUG
! 571: printf("ultrix sigreturn\n");
! 572: #endif
! 573: return sys_sigreturn(p, (struct sys_sigreturn_args *)uap, retval);
! 574: }
! 575:
! 576: int
! 577: ultrix_sys_execve(p, v, retval)
! 578: struct proc *p;
! 579: void *v;
! 580: register_t *retval;
! 581: {
! 582: struct ultrix_sys_execve_args /* {
! 583: syscallarg(char *) path;
! 584: syscallarg(char **) argv;
! 585: syscallarg(char **) envp;
! 586: } */ *uap = v;
! 587: struct sys_execve_args ap;
! 588: caddr_t sg;
! 589:
! 590: sg = stackgap_init(p->p_emul);
! 591: ULTRIX_CHECK_ALT_EXIST(p, &sg, SCARG(uap, path));
! 592:
! 593: SCARG(&ap, path) = SCARG(uap, path);
! 594: SCARG(&ap, argp) = SCARG(uap, argp);
! 595: SCARG(&ap, envp) = SCARG(uap, envp);
! 596:
! 597: return (sys_execve(p, &ap, retval));
! 598: }
CVSweb
![[BACK]](/icons/back.gif){kind=icon}
Return to ultrix_misc.c CVS log ![[TXT]](/icons/text.gif){kind=icon}
![[DIR]](/icons/dir.gif){kind=icon}
Up to [local] / sys / compat / ultrix