ultrix_misc.c revision 1.13
1 /* $NetBSD: ultrix_misc.c,v 1.13 1995/06/01 16:38:17 mellon Exp $ */ 2 3 /* 4 * Copyright (c) 1992, 1993 5 * The Regents of the University of California. All rights reserved. 6 * 7 * This software was developed by the Computer Systems Engineering group 8 * at Lawrence Berkeley Laboratory under DARPA contract BG 91-66 and 9 * contributed to Berkeley. 10 * 11 * All advertising materials mentioning features or use of this software 12 * must display the following acknowledgement: 13 * This product includes software developed by the University of 14 * California, Lawrence Berkeley Laboratory. 15 * 16 * Redistribution and use in source and binary forms, with or without 17 * modification, are permitted provided that the following conditions 18 * are met: 19 * 1. Redistributions of source code must retain the above copyright 20 * notice, this list of conditions and the following disclaimer. 21 * 2. Redistributions in binary form must reproduce the above copyright 22 * notice, this list of conditions and the following disclaimer in the 23 * documentation and/or other materials provided with the distribution. 24 * 3. All advertising materials mentioning features or use of this software 25 * must display the following acknowledgement: 26 * This product includes software developed by the University of 27 * California, Berkeley and its contributors. 28 * 4. Neither the name of the University nor the names of its contributors 29 * may be used to endorse or promote products derived from this software 30 * without specific prior written permission. 31 * 32 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND 33 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 34 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 35 * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE 36 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 37 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 38 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 39 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 40 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 41 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 42 * SUCH DAMAGE. 43 * 44 * 45 * @(#)sun_misc.c 8.1 (Berkeley) 6/18/93 46 * 47 * from: Header: sun_misc.c,v 1.16 93/04/07 02:46:27 torek Exp 48 */ 49 50 /* 51 * SunOS compatibility module. 52 * 53 * SunOS system calls that are implemented differently in BSD are 54 * handled here. 55 */ 56 57 #include <sys/param.h> 58 #include <sys/systm.h> 59 #include <sys/namei.h> 60 #include <sys/dir.h> 61 #include <sys/proc.h> 62 #include <sys/file.h> 63 #include <sys/stat.h> 64 #include <sys/filedesc.h> 65 #include <sys/ioctl.h> 66 #include <sys/kernel.h> 67 #include <sys/exec.h> 68 #include <sys/malloc.h> 69 #include <sys/mbuf.h> 70 #include <sys/mman.h> 71 #include <sys/mount.h> 72 #include <sys/resource.h> 73 #include <sys/resourcevar.h> 74 #include <sys/signal.h> 75 #include <sys/signalvar.h> 76 #include <sys/socket.h> 77 #include <sys/vnode.h> 78 #include <sys/uio.h> 79 #include <sys/wait.h> 80 #include <sys/utsname.h> 81 #include <sys/unistd.h> 82 83 #include <netinet/in.h> 84 85 #include <miscfs/specfs/specdev.h> 86 #include <compat/ultrix/ultrix_syscall.h> 87 88 #include <nfs/rpcv2.h> 89 #include <nfs/nfsv2.h> 90 #include <nfs/nfs.h> 91 92 #include <vm/vm.h> 93 94 extern struct sysent ultrix_sysent[]; 95 extern char *ultrix_syscallnames[]; 96 extern void cpu_exec_ecoff_setregs __P((struct proc *, struct exec_package *, 97 u_long, register_t *)); 98 struct emul emul_ultrix = { 99 "ultrix", 100 NULL, 101 sendsig, 102 ULTRIX_SYS_syscall, 103 ULTRIX_SYS_MAXSYSCALL, 104 ultrix_sysent, 105 ultrix_syscallnames, 106 0, 107 copyargs, 108 cpu_exec_ecoff_setregs, 109 0, 110 0, 111 }; 112 113 #define GSI_PROG_ENV 1 114 115 struct ultrix_getsysinfo_args { 116 unsigned op; 117 char *buffer; 118 unsigned nbytes; 119 int *start; 120 char *arg; 121 }; 122 123 ultrix_getsysinfo(p, uap, retval) 124 struct proc *p; 125 struct ultrix_getsysinfo_args *uap; 126 int *retval; 127 { 128 static short progenv = 0; 129 130 switch (uap->op) { 131 /* operations implemented: */ 132 case GSI_PROG_ENV: 133 if (uap->nbytes < sizeof(short)) 134 return EINVAL; 135 *retval = 1; 136 return(copyout(&progenv, uap->buffer, sizeof(short))); 137 default: 138 *retval = 0; /* info unavail */ 139 return 0; 140 } 141 } 142 143 struct ultrix_setsysinfo_args { 144 unsigned op; 145 char *buffer; 146 unsigned nbytes; 147 unsigned arg; 148 unsigned flag; 149 }; 150 151 ultrix_setsysinfo(p, uap, retval) 152 struct proc *p; 153 struct ultrix_setsysinfo_args *uap; 154 int *retval; 155 { 156 *retval = 0; 157 return 0; 158 } 159 160 struct ultrix_waitpid_args { 161 int pid; 162 int *status; 163 int options; 164 struct rusage *rusage; 165 }; 166 167 ultrix_waitpid(p, uap, retval) 168 struct proc *p; 169 struct ultrix_waitpid_args *uap; 170 register_t *retval; 171 { 172 173 uap->rusage = 0; 174 return (wait4(p, uap, retval)); 175 } 176 struct sun_wait4_args { 177 int pid; 178 int *status; 179 int options; 180 struct rusage *rusage; 181 int compat; 182 }; 183 sun_wait4(p, uap, retval) 184 struct proc *p; 185 struct sun_wait4_args *uap; 186 register_t *retval; 187 { 188 189 if (uap->pid == 0) 190 uap->pid = WAIT_ANY; 191 return (wait4(p, uap, retval)); 192 } 193 194 struct sun_wait3_args { 195 int *status; 196 int options; 197 struct rusage *rusage; 198 }; 199 200 sun_wait3(p, uap, retval) 201 struct proc *p; 202 struct sun_wait3_args *uap; 203 register_t *retval; 204 { 205 struct sun_wait4_args ua; 206 207 if (uap == NULL) 208 panic("uap == NULL"); 209 ua.pid = -1; 210 ua.status = uap->status; 211 ua.options = uap->options; 212 ua.rusage = uap->rusage; 213 214 return (wait4(p, &ua, retval)); 215 } 216 217 struct sun_creat_args { 218 char *fname; 219 int fmode; 220 }; 221 sun_creat(p, uap, retval) 222 struct proc *p; 223 struct sun_creat_args *uap; 224 register_t *retval; 225 { 226 struct args { 227 char *fname; 228 int mode; 229 int crtmode; 230 } openuap; 231 232 openuap.fname = uap->fname; 233 openuap.crtmode = uap->fmode; 234 openuap.mode = O_WRONLY | O_CREAT | O_TRUNC; 235 return (open(p, &openuap, retval)); 236 } 237 238 struct sun_execv_args { 239 char *fname; 240 char **argp; 241 char **envp; /* pseudo */ 242 }; 243 sun_execv(p, uap, retval) 244 struct proc *p; 245 struct sun_execv_args *uap; 246 register_t *retval; 247 { 248 249 uap->envp = NULL; 250 return (execve(p, uap, retval)); 251 } 252 253 struct sun_omsync_args { 254 caddr_t addr; 255 int len; 256 int flags; 257 }; 258 sun_omsync(p, uap, retval) 259 struct proc *p; 260 struct sun_omsync_args *uap; 261 register_t *retval; 262 { 263 264 if (uap->flags) 265 return (EINVAL); 266 return (msync(p, uap, retval)); 267 } 268 269 struct sun_unmount_args { 270 char *name; 271 int flags; /* pseudo */ 272 }; 273 sun_unmount(p, uap, retval) 274 struct proc *p; 275 struct sun_unmount_args *uap; 276 register_t *retval; 277 { 278 279 uap->flags = 0; 280 return (unmount(p, uap, retval)); 281 } 282 283 #define SUNM_RDONLY 0x01 /* mount fs read-only */ 284 #define SUNM_NOSUID 0x02 /* mount fs with setuid disallowed */ 285 #define SUNM_NEWTYPE 0x04 /* type is string (char *), not int */ 286 #define SUNM_GRPID 0x08 /* (bsd semantics; ignored) */ 287 #define SUNM_REMOUNT 0x10 /* update existing mount */ 288 #define SUNM_NOSUB 0x20 /* prevent submounts (rejected) */ 289 #define SUNM_MULTI 0x40 /* (ignored) */ 290 #define SUNM_SYS5 0x80 /* Sys 5-specific semantics (rejected) */ 291 292 struct sun_nfs_args { 293 struct sockaddr_in *addr; /* file server address */ 294 caddr_t fh; /* file handle to be mounted */ 295 int flags; /* flags */ 296 int wsize; /* write size in bytes */ 297 int rsize; /* read size in bytes */ 298 int timeo; /* initial timeout in .1 secs */ 299 int retrans; /* times to retry send */ 300 char *hostname; /* server's hostname */ 301 int acregmin; /* attr cache file min secs */ 302 int acregmax; /* attr cache file max secs */ 303 int acdirmin; /* attr cache dir min secs */ 304 int acdirmax; /* attr cache dir max secs */ 305 char *netname; /* server's netname */ 306 struct pathcnf *pathconf; /* static pathconf kludge */ 307 }; 308 309 struct sun_mount_args { 310 char *type; 311 char *dir; 312 int flags; 313 caddr_t data; 314 }; 315 sun_mount(p, uap, retval) 316 struct proc *p; 317 struct sun_mount_args *uap; 318 register_t *retval; 319 { 320 int oflags = uap->flags, nflags, error; 321 extern char sigcode[], esigcode[]; 322 char fsname[MFSNAMELEN]; 323 324 #define szsigcode (esigcode - sigcode) 325 326 if (oflags & (SUNM_NOSUB | SUNM_SYS5)) 327 return (EINVAL); 328 if ((oflags & SUNM_NEWTYPE) == 0) 329 return (EINVAL); 330 nflags = 0; 331 if (oflags & SUNM_RDONLY) 332 nflags |= MNT_RDONLY; 333 if (oflags & SUNM_NOSUID) 334 nflags |= MNT_NOSUID; 335 if (oflags & SUNM_REMOUNT) 336 nflags |= MNT_UPDATE; 337 uap->flags = nflags; 338 339 if (error = copyinstr((caddr_t)uap->type, fsname, sizeof fsname, 340 (size_t *)0)) 341 return (error); 342 343 if (strcmp(fsname, "4.2") == 0) { 344 uap->type = (caddr_t)ALIGN(PS_STRINGS - szsigcode - STACKGAPLEN); 345 if (error = copyout("ufs", uap->type, sizeof("ufs"))) 346 return (error); 347 } else if (strcmp(fsname, "nfs") == 0) { 348 struct sun_nfs_args sna; 349 struct sockaddr_in sain; 350 struct nfs_args na; 351 struct sockaddr sa; 352 353 if (error = copyin(uap->data, &sna, sizeof sna)) 354 return (error); 355 if (error = copyin(sna.addr, &sain, sizeof sain)) 356 return (error); 357 bcopy(&sain, &sa, sizeof sa); 358 sa.sa_len = sizeof(sain); 359 uap->data = (caddr_t)ALIGN(PS_STRINGS - szsigcode - STACKGAPLEN); 360 na.addr = (struct sockaddr *)((int)uap->data + sizeof na); 361 na.sotype = SOCK_DGRAM; 362 na.proto = IPPROTO_UDP; 363 na.fh = (nfsv2fh_t *)sna.fh; 364 na.flags = sna.flags; 365 na.wsize = sna.wsize; 366 na.rsize = sna.rsize; 367 na.timeo = sna.timeo; 368 na.retrans = sna.retrans; 369 na.hostname = sna.hostname; 370 371 if (error = copyout(&sa, na.addr, sizeof sa)) 372 return (error); 373 if (error = copyout(&na, uap->data, sizeof na)) 374 return (error); 375 } 376 return (mount(p, uap, retval)); 377 } 378 379 #if defined(NFSCLIENT) 380 async_daemon(p, uap, retval) 381 struct proc *p; 382 void *uap; 383 register_t *retval; 384 { 385 struct nfssvc_args { 386 int flag; 387 caddr_t argp; 388 } args; 389 390 args.flag = NFSSVC_BIOD; 391 return nfssvc(p, &args, retval); 392 } 393 #endif /* NFSCLIENT */ 394 395 struct sun_sigpending_args { 396 int *mask; 397 }; 398 sun_sigpending(p, uap, retval) 399 struct proc *p; 400 struct sun_sigpending_args *uap; 401 register_t *retval; 402 { 403 int mask = p->p_siglist & p->p_sigmask; 404 405 return (copyout((caddr_t)&mask, (caddr_t)uap->mask, sizeof(int))); 406 } 407 408 #if 0 409 /* XXX: Temporary until sys/dir.h, include/dirent.h and sys/dirent.h are fixed */ 410 struct dirent { 411 u_long d_fileno; /* file number of entry */ 412 u_short d_reclen; /* length of this record */ 413 u_short d_namlen; /* length of string in d_name */ 414 char d_name[255 + 1]; /* name must be no longer than this */ 415 }; 416 #endif 417 418 /* 419 * Here is the sun layout. (Compare the BSD layout in <sys/dirent.h>.) 420 * We can assume big-endian, so the BSD d_type field is just the high 421 * byte of the SunOS d_namlen field, after adjusting for the extra "long". 422 */ 423 struct sun_dirent { 424 long d_off; 425 u_long d_fileno; 426 u_short d_reclen; 427 u_short d_namlen; 428 char d_name[256]; 429 }; 430 431 /* 432 * Read Sun-style directory entries. We suck them into kernel space so 433 * that they can be massaged before being copied out to user code. Like 434 * SunOS, we squish out `empty' entries. 435 * 436 * This is quite ugly, but what do you expect from compatibility code? 437 */ 438 struct sun_getdents_args { 439 int fd; 440 char *buf; 441 int nbytes; 442 }; 443 sun_getdents(p, uap, retval) 444 struct proc *p; 445 register struct sun_getdents_args *uap; 446 register_t *retval; 447 { 448 register struct vnode *vp; 449 register caddr_t inp, buf; /* BSD-format */ 450 register int len, reclen; /* BSD-format */ 451 register caddr_t outp; /* Sun-format */ 452 register int resid; /* Sun-format */ 453 struct file *fp; 454 struct uio auio; 455 struct iovec aiov; 456 off_t off; /* true file offset */ 457 long soff; /* Sun file offset */ 458 int buflen, error, eofflag; 459 #define BSD_DIRENT(cp) ((struct dirent *)(cp)) 460 #define SUN_RECLEN(reclen) (reclen + sizeof(long)) 461 462 if ((error = getvnode(p->p_fd, uap->fd, &fp)) != 0) 463 return (error); 464 if ((fp->f_flag & FREAD) == 0) 465 return (EBADF); 466 vp = (struct vnode *)fp->f_data; 467 if (vp->v_type != VDIR) /* XXX vnode readdir op should do this */ 468 return (EINVAL); 469 buflen = min(MAXBSIZE, uap->nbytes); 470 buf = malloc(buflen, M_TEMP, M_WAITOK); 471 VOP_LOCK(vp); 472 off = fp->f_offset; 473 again: 474 aiov.iov_base = buf; 475 aiov.iov_len = buflen; 476 auio.uio_iov = &aiov; 477 auio.uio_iovcnt = 1; 478 auio.uio_rw = UIO_READ; 479 auio.uio_segflg = UIO_SYSSPACE; 480 auio.uio_procp = p; 481 auio.uio_resid = buflen; 482 auio.uio_offset = off; 483 /* 484 * First we read into the malloc'ed buffer, then 485 * we massage it into user space, one record at a time. 486 */ 487 if (error = VOP_READDIR(vp, &auio, fp->f_cred, &eofflag, (u_long *)0, 488 0)) 489 goto out; 490 inp = buf; 491 outp = uap->buf; 492 resid = uap->nbytes; 493 if ((len = buflen - auio.uio_resid) == 0) 494 goto eof; 495 for (; len > 0; len -= reclen) { 496 reclen = ((struct dirent *)inp)->d_reclen; 497 if (reclen & 3) 498 panic("sun_getdents"); 499 off += reclen; /* each entry points to next */ 500 if (BSD_DIRENT(inp)->d_fileno == 0) { 501 inp += reclen; /* it is a hole; squish it out */ 502 continue; 503 } 504 if (reclen > len || resid < SUN_RECLEN(reclen)) { 505 /* entry too big for buffer, so just stop */ 506 outp++; 507 break; 508 } 509 /* 510 * Massage in place to make a Sun-shaped dirent (otherwise 511 * we have to worry about touching user memory outside of 512 * the copyout() call). 513 */ 514 BSD_DIRENT(inp)->d_reclen = SUN_RECLEN(reclen); 515 #if notdef 516 BSD_DIRENT(inp)->d_type = 0; /* 4.4 specific */ 517 #endif 518 soff = off; 519 if ((error = copyout((caddr_t)&soff, outp, sizeof soff)) != 0 || 520 (error = copyout(inp, outp + sizeof soff, reclen)) != 0) 521 goto out; 522 /* advance past this real entry */ 523 inp += reclen; 524 /* advance output past Sun-shaped entry */ 525 outp += SUN_RECLEN(reclen); 526 resid -= SUN_RECLEN(reclen); 527 } 528 /* if we squished out the whole block, try again */ 529 if (outp == uap->buf) 530 goto again; 531 fp->f_offset = off; /* update the vnode offset */ 532 eof: 533 *retval = uap->nbytes - resid; 534 out: 535 VOP_UNLOCK(vp); 536 free(buf, M_TEMP); 537 return (error); 538 } 539 540 #define SUN__MAP_NEW 0x80000000 /* if not, old mmap & cannot handle */ 541 542 struct sun_mmap_args { 543 caddr_t addr; 544 size_t len; 545 int prot; 546 int flags; 547 int fd; 548 long off; /* not off_t! */ 549 off_t qoff; /* created here and fed to mmap() */ 550 }; 551 sun_mmap(p, uap, retval) 552 register struct proc *p; 553 register struct sun_mmap_args *uap; 554 register_t *retval; 555 { 556 register struct filedesc *fdp; 557 register struct file *fp; 558 register struct vnode *vp; 559 560 /* 561 * Verify the arguments. 562 */ 563 if (uap->prot & ~(PROT_READ|PROT_WRITE|PROT_EXEC)) 564 return (EINVAL); /* XXX still needed? */ 565 566 if ((uap->flags & SUN__MAP_NEW) == 0) 567 return (EINVAL); 568 uap->flags &= ~SUN__MAP_NEW; 569 570 if ((uap->flags & MAP_FIXED) == 0 && 571 uap->addr != 0 && 572 uap->addr < (caddr_t)round_page(p->p_vmspace->vm_daddr+MAXDSIZ)) 573 uap->addr = (caddr_t)round_page(p->p_vmspace->vm_daddr+MAXDSIZ); 574 575 /* 576 * Special case: if fd refers to /dev/zero, map as MAP_ANON. (XXX) 577 */ 578 fdp = p->p_fd; 579 if ((unsigned)uap->fd < fdp->fd_nfiles && /*XXX*/ 580 (fp = fdp->fd_ofiles[uap->fd]) != NULL && /*XXX*/ 581 fp->f_type == DTYPE_VNODE && /*XXX*/ 582 (vp = (struct vnode *)fp->f_data)->v_type == VCHR && /*XXX*/ 583 iszerodev(vp->v_rdev)) { /*XXX*/ 584 uap->flags |= MAP_ANON; 585 uap->fd = -1; 586 } 587 588 uap->qoff = uap->off; 589 return (mmap(p, uap, retval)); 590 } 591 592 #define MC_SYNC 1 593 #define MC_LOCK 2 594 #define MC_UNLOCK 3 595 #define MC_ADVISE 4 596 #define MC_LOCKAS 5 597 #define MC_UNLOCKAS 6 598 599 struct sun_mctl_args { 600 caddr_t addr; 601 size_t len; 602 int func; 603 void *arg; 604 }; 605 sun_mctl(p, uap, retval) 606 register struct proc *p; 607 register struct sun_mctl_args *uap; 608 register_t *retval; 609 { 610 611 switch (uap->func) { 612 613 case MC_ADVISE: /* ignore for now */ 614 return (0); 615 616 case MC_SYNC: /* translate to msync */ 617 return (msync(p, uap, retval)); 618 619 default: 620 return (EINVAL); 621 } 622 } 623 624 struct sun_setsockopt_args { 625 int s; 626 int level; 627 int name; 628 caddr_t val; 629 int valsize; 630 }; 631 sun_setsockopt(p, uap, retval) 632 struct proc *p; 633 register struct sun_setsockopt_args *uap; 634 register_t *retval; 635 { 636 struct file *fp; 637 struct mbuf *m = NULL; 638 int error; 639 640 if (error = getsock(p->p_fd, uap->s, &fp)) 641 return (error); 642 #define SO_DONTLINGER (~SO_LINGER) 643 if (uap->name == SO_DONTLINGER) { 644 m = m_get(M_WAIT, MT_SOOPTS); 645 if (m == NULL) 646 return (ENOBUFS); 647 mtod(m, struct linger *)->l_onoff = 0; 648 m->m_len = sizeof(struct linger); 649 return (sosetopt((struct socket *)fp->f_data, uap->level, 650 SO_LINGER, m)); 651 } 652 if (uap->valsize > MLEN) 653 return (EINVAL); 654 if (uap->val) { 655 m = m_get(M_WAIT, MT_SOOPTS); 656 if (m == NULL) 657 return (ENOBUFS); 658 if (error = copyin(uap->val, mtod(m, caddr_t), 659 (u_int)uap->valsize)) { 660 (void) m_free(m); 661 return (error); 662 } 663 m->m_len = uap->valsize; 664 } 665 return (sosetopt((struct socket *)fp->f_data, uap->level, 666 uap->name, m)); 667 } 668 669 struct sun_fchroot_args { 670 int fdes; 671 }; 672 sun_fchroot(p, uap, retval) 673 register struct proc *p; 674 register struct sun_fchroot_args *uap; 675 register_t *retval; 676 { 677 register struct filedesc *fdp = p->p_fd; 678 register struct vnode *vp; 679 struct file *fp; 680 int error; 681 682 if ((error = suser(p->p_ucred, &p->p_acflag)) != 0) 683 return (error); 684 if ((error = getvnode(fdp, uap->fdes, &fp)) != 0) 685 return (error); 686 vp = (struct vnode *)fp->f_data; 687 VOP_LOCK(vp); 688 if (vp->v_type != VDIR) 689 error = ENOTDIR; 690 else 691 error = VOP_ACCESS(vp, VEXEC, p->p_ucred, p); 692 VOP_UNLOCK(vp); 693 if (error) 694 return (error); 695 VREF(vp); 696 if (fdp->fd_rdir != NULL) 697 vrele(fdp->fd_rdir); 698 fdp->fd_rdir = vp; 699 return (0); 700 } 701 702 /* 703 * XXX: This needs cleaning up. 704 */ 705 sun_auditsys() 706 { 707 return 0; 708 } 709 710 struct sun_utsname { 711 char sysname[9]; 712 char nodename[9]; 713 char nodeext[65-9]; 714 char release[9]; 715 char version[9]; 716 char machine[9]; 717 }; 718 719 struct sun_uname_args { 720 struct sun_utsname *name; 721 }; 722 sun_uname(p, uap, retval) 723 struct proc *p; 724 struct sun_uname_args *uap; 725 register_t *retval; 726 { 727 struct sun_utsname sut; 728 extern char ostype[], machine[], osrelease[]; 729 730 bzero(&sut, sizeof(sut)); 731 732 bcopy(ostype, sut.sysname, sizeof(sut.sysname) - 1); 733 bcopy(hostname, sut.nodename, sizeof(sut.nodename)); 734 sut.nodename[sizeof(sut.nodename)-1] = '\0'; 735 bcopy(osrelease, sut.release, sizeof(sut.release) - 1); 736 bcopy("1", sut.version, sizeof(sut.version) - 1); 737 bcopy(machine, sut.machine, sizeof(sut.machine) - 1); 738 739 return copyout((caddr_t)&sut, (caddr_t)uap->name, sizeof(struct sun_utsname)); 740 } 741 742 struct sun_setpgid_args { 743 int pid; /* target process id */ 744 int pgid; /* target pgrp id */ 745 }; 746 int 747 sun_setpgid(p, uap, retval) 748 struct proc *p; 749 struct sun_setpgid_args *uap; 750 register_t *retval; 751 { 752 /* 753 * difference to our setpgid call is to include backwards 754 * compatibility to pre-setsid() binaries. Do setsid() 755 * instead of setpgid() in those cases where the process 756 * tries to create a new session the old way. 757 */ 758 if (!uap->pgid && (!uap->pid || uap->pid == p->p_pid)) 759 return setsid(p, uap, retval); 760 else 761 return setpgid(p, uap, retval); 762 } 763 764 struct sun_open_args { 765 char *fname; 766 int fmode; 767 int crtmode; 768 }; 769 sun_open(p, uap, retval) 770 struct proc *p; 771 struct sun_open_args *uap; 772 register_t *retval; 773 { 774 int l, r; 775 int noctty = uap->fmode & 0x8000; 776 int ret; 777 778 /* convert mode into NetBSD mode */ 779 l = uap->fmode; 780 r = (l & (0x0001 | 0x0002 | 0x0008 | 0x0040 | 0x0200 | 0x0400 | 0x0800)); 781 r |= ((l & (0x0004 | 0x1000 | 0x4000)) ? O_NONBLOCK : 0); 782 r |= ((l & 0x0080) ? O_SHLOCK : 0); 783 r |= ((l & 0x0100) ? O_EXLOCK : 0); 784 r |= ((l & 0x2000) ? O_FSYNC : 0); 785 786 uap->fmode = r; 787 ret = open(p, uap, retval); 788 789 if (!ret && !noctty && SESS_LEADER(p) && !(p->p_flag & P_CONTROLT)) { 790 struct filedesc *fdp = p->p_fd; 791 struct file *fp = fdp->fd_ofiles[*retval]; 792 793 /* ignore any error, just give it a try */ 794 if (fp->f_type == DTYPE_VNODE) 795 (fp->f_ops->fo_ioctl)(fp, TIOCSCTTY, (caddr_t) 0, p); 796 } 797 return ret; 798 } 799 800 #if defined (NFSSERVER) 801 struct nfssvc_args { 802 int fd; 803 caddr_t mskval; 804 int msklen; 805 caddr_t mtchval; 806 int mtchlen; 807 }; 808 struct sun_nfssvc_args { 809 int fd; 810 }; 811 sun_nfssvc(p, uap, retval) 812 struct proc *p; 813 struct sun_nfssvc_args *uap; 814 register_t *retval; 815 { 816 struct nfssvc_args outuap; 817 struct sockaddr sa; 818 int error; 819 extern char sigcode[], esigcode[]; 820 821 bzero(&outuap, sizeof outuap); 822 outuap.fd = uap->fd; 823 outuap.mskval = (caddr_t)ALIGN(PS_STRINGS - szsigcode - STACKGAPLEN); 824 outuap.msklen = sizeof sa; 825 outuap.mtchval = outuap.mskval + sizeof sa; 826 outuap.mtchlen = sizeof sa; 827 828 bzero(&sa, sizeof sa); 829 if (error = copyout(&sa, outuap.mskval, outuap.msklen)) 830 return (error); 831 if (error = copyout(&sa, outuap.mtchval, outuap.mtchlen)) 832 return (error); 833 834 return nfssvc(p, &outuap, retval); 835 } 836 #endif /* NFSSERVER */ 837 838 struct sun_ustat { 839 daddr_t f_tfree; /* total free */ 840 ino_t f_tinode; /* total inodes free */ 841 char f_fname[6]; /* filsys name */ 842 char f_fpack[6]; /* filsys pack name */ 843 }; 844 struct sun_ustat_args { 845 int dev; 846 struct sun_ustat *buf; 847 }; 848 sun_ustat(p, uap, retval) 849 struct proc *p; 850 struct sun_ustat_args *uap; 851 register_t *retval; 852 { 853 struct sun_ustat us; 854 int error; 855 856 bzero(&us, sizeof us); 857 858 /* 859 * XXX: should set f_tfree and f_tinode at least 860 * How do we translate dev -> fstat? (and then to sun_ustat) 861 */ 862 863 if (error = copyout(&us, uap->buf, sizeof us)) 864 return (error); 865 return 0; 866 } 867 868 struct sun_quotactl_args { 869 int cmd; 870 char *special; 871 int uid; 872 caddr_t addr; 873 }; 874 sun_quotactl(p, uap, retval) 875 struct proc *p; 876 struct sun_quotactl_args *uap; 877 register_t *retval; 878 { 879 return EINVAL; 880 } 881 882 sun_vhangup(p, uap, retval) 883 struct proc *p; 884 void *uap; 885 register_t *retval; 886 { 887 return 0; 888 } 889 890 struct sun_statfs { 891 long f_type; /* type of info, zero for now */ 892 long f_bsize; /* fundamental file system block size */ 893 long f_blocks; /* total blocks in file system */ 894 long f_bfree; /* free blocks */ 895 long f_bavail; /* free blocks available to non-super-user */ 896 long f_files; /* total file nodes in file system */ 897 long f_ffree; /* free file nodes in fs */ 898 fsid_t f_fsid; /* file system id */ 899 long f_spare[7]; /* spare for later */ 900 }; 901 static 902 sunstatfs(sp, buf) 903 struct statfs *sp; 904 caddr_t buf; 905 { 906 struct sun_statfs ssfs; 907 908 bzero(&ssfs, sizeof ssfs); 909 ssfs.f_type = 0; 910 ssfs.f_bsize = sp->f_bsize; 911 ssfs.f_blocks = sp->f_blocks; 912 ssfs.f_bfree = sp->f_bfree; 913 ssfs.f_bavail = sp->f_bavail; 914 ssfs.f_files = sp->f_files; 915 ssfs.f_ffree = sp->f_ffree; 916 ssfs.f_fsid = sp->f_fsid; 917 return copyout((caddr_t)&ssfs, buf, sizeof ssfs); 918 } 919 920 struct sun_statfs_args { 921 char *path; 922 struct sun_statfs *buf; 923 }; 924 sun_statfs(p, uap, retval) 925 struct proc *p; 926 struct sun_statfs_args *uap; 927 register_t *retval; 928 { 929 register struct mount *mp; 930 register struct statfs *sp; 931 int error; 932 struct nameidata nd; 933 934 NDINIT(&nd, LOOKUP, FOLLOW, UIO_USERSPACE, uap->path, p); 935 if (error = namei(&nd)) 936 return (error); 937 mp = nd.ni_vp->v_mount; 938 sp = &mp->mnt_stat; 939 vrele(nd.ni_vp); 940 if (error = VFS_STATFS(mp, sp, p)) 941 return (error); 942 sp->f_flags = mp->mnt_flag & MNT_VISFLAGMASK; 943 return sunstatfs(sp, (caddr_t)uap->buf); 944 } 945 946 struct sun_fstatfs_args { 947 int fd; 948 struct sun_statfs *buf; 949 }; 950 sun_fstatfs(p, uap, retval) 951 struct proc *p; 952 struct sun_fstatfs_args *uap; 953 register_t *retval; 954 { 955 struct file *fp; 956 struct mount *mp; 957 register struct statfs *sp; 958 int error; 959 960 if (error = getvnode(p->p_fd, uap->fd, &fp)) 961 return (error); 962 mp = ((struct vnode *)fp->f_data)->v_mount; 963 sp = &mp->mnt_stat; 964 if (error = VFS_STATFS(mp, sp, p)) 965 return (error); 966 sp->f_flags = mp->mnt_flag & MNT_VISFLAGMASK; 967 return sunstatfs(sp, (caddr_t)uap->buf); 968 } 969 970 struct sun_exportfs_args { 971 char *path; 972 char *ex; /* struct sun_export * */ 973 }; 974 sun_exportfs(p, uap, retval) 975 struct proc *p; 976 struct sun_exportfs_args *uap; 977 register_t *retval; 978 { 979 /* 980 * XXX: should perhaps translate into a mount(2) 981 * with MOUNT_EXPORT? 982 */ 983 return 0; 984 } 985 986 struct sun_mknod_args { 987 char *fname; 988 int fmode; 989 int dev; 990 }; 991 992 sun_mknod(p, uap, retval) 993 struct proc *p; 994 struct sun_mknod_args *uap; 995 register_t *retval; 996 { 997 if (S_ISFIFO(uap->fmode)) 998 return mkfifo(p, uap, retval); 999 1000 return mknod(p, uap, retval); 1001 } 1002 1003 #define SUN_SC_ARG_MAX 1 1004 #define SUN_SC_CHILD_MAX 2 1005 #define SUN_SC_CLK_TCK 3 1006 #define SUN_SC_NGROUPS_MAX 4 1007 #define SUN_SC_OPEN_MAX 5 1008 #define SUN_SC_JOB_CONTROL 6 1009 #define SUN_SC_SAVED_IDS 7 1010 #define SUN_SC_VERSION 8 1011 1012 struct sun_sysconf_args { 1013 int name; 1014 }; 1015 1016 sun_sysconf(p, uap, retval) 1017 struct proc *p; 1018 struct sun_sysconf_args *uap; 1019 register_t *retval; 1020 { 1021 extern int maxfiles; 1022 1023 switch(uap->name) { 1024 case SUN_SC_ARG_MAX: 1025 *retval = ARG_MAX; 1026 break; 1027 case SUN_SC_CHILD_MAX: 1028 *retval = maxproc; 1029 break; 1030 case SUN_SC_CLK_TCK: 1031 *retval = 60; /* should this be `hz', ie. 100? */ 1032 break; 1033 case SUN_SC_NGROUPS_MAX: 1034 *retval = NGROUPS_MAX; 1035 break; 1036 case SUN_SC_OPEN_MAX: 1037 *retval = maxfiles; 1038 break; 1039 case SUN_SC_JOB_CONTROL: 1040 *retval = 1; 1041 break; 1042 case SUN_SC_SAVED_IDS: 1043 #ifdef _POSIX_SAVED_IDS 1044 *retval = 1; 1045 #else 1046 *retval = 0; 1047 #endif 1048 break; 1049 case SUN_SC_VERSION: 1050 *retval = 198808; 1051 break; 1052 default: 1053 return EINVAL; 1054 } 1055 return 0; 1056 } 1057 1058 struct ultrix_sigcleanup_args { 1059 struct sigcontext *sigcntxp; 1060 }; 1061 1062 int ultrix_sigcleanup(p, uap, retval) 1063 struct proc *p; 1064 struct ultrix_sigcleanup_args *uap; 1065 register_t *retval; 1066 { 1067 sigreturn (p, (struct sigreturn_args *)uap, retval); 1068 } 1069
Indexes created Sun Sep 21 20:09:37 GMT 2025