/* $NetBSD: osf1_misc.c,v 1.14 1998/05/20 16:34:29 chs Exp $ */ /* * Copyright (c) 1994, 1995 Carnegie-Mellon University. * All rights reserved. * * Author: Chris G. Demetriou * * Permission to use, copy, modify and distribute this software and * its documentation is hereby granted, provided that both the copyright * notice and this permission notice appear in all copies of the * software, derivative works or modified versions, and any portions * thereof, and that both notices appear in supporting documentation. * * CARNEGIE MELLON ALLOWS FREE USE OF THIS SOFTWARE IN ITS "AS IS" * CONDITION. CARNEGIE MELLON DISCLAIMS ANY LIABILITY OF ANY KIND * FOR ANY DAMAGES WHATSOEVER RESULTING FROM THE USE OF THIS SOFTWARE. * * Carnegie Mellon requests users of this software to return to * * Software Distribution Coordinator or Software.Distribution@CS.CMU.EDU * School of Computer Science * Carnegie Mellon University * Pittsburgh PA 15213-3890 * * any improvements or extensions that they make and grant Carnegie the * rights to redistribute these changes. */ /* * Additional Copyright (c) 1999 by Andrew Gallatin * $FreeBSD$ */ #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include static void cvtstat2osf1 __P((struct stat *, struct osf1_stat *)); static int osf2bsd_pathconf __P((int *)); static const char osf1_emul_path[] = "/compat/osf1"; /* * [ taken from the linux emulator ] * Search an alternate path before passing pathname arguments on * to system calls. Useful for keeping a separate 'emulation tree'. * * If cflag is set, we check if an attempt can be made to create * the named file, i.e. we check if the directory it should * be in exists. */ int osf1_emul_find(p, sgp, prefix, path, pbuf, cflag) struct proc *p; caddr_t *sgp; /* Pointer to stackgap memory */ const char *prefix; char *path; char **pbuf; int cflag; { int error; size_t len, sz; char *buf, *cp, *ptr; struct nameidata nd; struct nameidata ndroot; struct vattr vat; struct vattr vatroot; buf = (char *) malloc(MAXPATHLEN, M_TEMP, M_WAITOK); *pbuf = path; for (ptr = buf; (*ptr = *prefix) != '\0'; ptr++, prefix++) continue; sz = MAXPATHLEN - (ptr - buf); /* * If sgp is not given then the path is already in kernel space */ if (sgp == NULL) error = copystr(path, ptr, sz, &len); else error = copyinstr(path, ptr, sz, &len); if (error) { free(buf, M_TEMP); return error; } if (*ptr != '/') { free(buf, M_TEMP); return EINVAL; } /* * We know that there is a / somewhere in this pathname. * Search backwards for it, to find the file's parent dir * to see if it exists in the alternate tree. If it does, * and we want to create a file (cflag is set). We don't * need to worry about the root comparison in this case. */ if (cflag) { for (cp = &ptr[len] - 1; *cp != '/'; cp--) ; *cp = '\0'; NDINIT(&nd, LOOKUP, FOLLOW, UIO_SYSSPACE, buf, p); if ((error = namei(&nd)) != 0) { free(buf, M_TEMP); return error; } *cp = '/'; } else { NDINIT(&nd, LOOKUP, FOLLOW, UIO_SYSSPACE, buf, p); if ((error = namei(&nd)) != 0) { free(buf, M_TEMP); return error; } /* * We now compare the vnode of the osf1_root to the one * vnode asked. If they resolve to be the same, then we * ignore the match so that the real root gets used. * This avoids the problem of traversing "../.." to find the * root directory and never finding it, because "/" resolves * to the emulation root directory. This is expensive :-( */ NDINIT(&ndroot, LOOKUP, FOLLOW, UIO_SYSSPACE, osf1_emul_path, p); if ((error = namei(&ndroot)) != 0) { /* Cannot happen! */ free(buf, M_TEMP); vrele(nd.ni_vp); return error; } if ((error = VOP_GETATTR(nd.ni_vp, &vat, p->p_ucred, p)) != 0) { goto bad; } if ((error = VOP_GETATTR(ndroot.ni_vp, &vatroot, p->p_ucred, p)) != 0) { goto bad; } if (vat.va_fsid == vatroot.va_fsid && vat.va_fileid == vatroot.va_fileid) { error = ENOENT; goto bad; } } if (sgp == NULL) *pbuf = buf; else { sz = &ptr[len] - buf; *pbuf = stackgap_alloc(sgp, sz + 1); error = copyout(buf, *pbuf, sz); free(buf, M_TEMP); } vrele(nd.ni_vp); if (!cflag) vrele(ndroot.ni_vp); return error; bad: vrele(ndroot.ni_vp); vrele(nd.ni_vp); free(buf, M_TEMP); return error; } int osf1_open(p, uap) struct proc *p; struct osf1_open_args *uap; { struct open_args /* { syscallarg(char *) path; syscallarg(int) flags; syscallarg(int) mode; } */ a; caddr_t sg; sg = stackgap_init(); CHECKALTEXIST(p, &sg, uap->path); SCARG(&a, path) = SCARG(uap, path); SCARG(&a, flags) = SCARG(uap, flags); /* XXX translate */ SCARG(&a, mode) = SCARG(uap, mode); return open(p, &a); } extern int totalphysmem; int osf1_getsysinfo(p, uap) struct proc *p; struct osf1_getsysinfo_args *uap; { int error, retval; int ncpus = 1; /* XXX until SMP */ int ophysmem; int unit; long percpu; long proctype; struct osf1_cpu_info cpuinfo; error = retval = 0; switch(uap->op) { case OSF_GET_MAX_UPROCS: error = copyout(&maxprocperuid, uap->buffer, sizeof(maxprocperuid)); retval = 1; break; case OSF_GET_PHYSMEM: ophysmem = totalphysmem * (PAGE_SIZE >> 10); error = copyout(&ophysmem, uap->buffer, sizeof(ophysmem)); retval = 1; break; case OSF_GET_MAX_CPU: case OSF_GET_CPUS_IN_BOX: error = copyout(&ncpus, uap->buffer, sizeof(ncpus)); retval = 1; break; case OSF_GET_IEEE_FP_CONTROL: error = copyout(&p->p_addr->u_pcb.pcb_fp_control,uap->buffer, sizeof(p->p_addr->u_pcb.pcb_fp_control)); retval = 1; break; case OSF_GET_CPU_INFO: if (uap->nbytes < sizeof(cpuinfo)) error = EINVAL; else { bzero(&cpuinfo, sizeof(cpuinfo)); unit = alpha_pal_whami(); cpuinfo.current_cpu = unit; cpuinfo.cpus_in_box = ncpus; cpuinfo.cpu_type = LOCATE_PCS(hwrpb, unit)->pcs_proc_type; cpuinfo.ncpus = ncpus; cpuinfo.cpus_present = ncpus; cpuinfo.cpus_running = ncpus; cpuinfo.cpu_binding = 1; cpuinfo.cpu_ex_binding = 0; cpuinfo.mhz = hwrpb->rpb_cc_freq / 1000000; error = copyout(&cpuinfo, uap->buffer, sizeof(cpuinfo)); retval = 1; } break; case OSF_GET_PROC_TYPE: if(uap->nbytes < sizeof(proctype)) error = EINVAL; else { unit = alpha_pal_whami(); proctype = LOCATE_PCS(hwrpb, unit)->pcs_proc_type; error = copyout (&proctype, uap->buffer, sizeof(percpu)); retval = 1; } break; case OSF_GET_HWRPB: { /* note -- osf/1 doesn't have rpb_tbhint[8] */ unsigned long rpb_size; rpb_size = (unsigned long)&hwrpb->rpb_tbhint - (unsigned long)hwrpb; if(uap->nbytes < rpb_size){ uprintf("nbytes = %ld, sizeof(struct rpb) = %ld\n", uap->nbytes, rpb_size); error = EINVAL; } else { error = copyout(hwrpb, uap->buffer, rpb_size); retval = 1; } } break; case OSF_GET_PLATFORM_NAME: error = copyout(platform.model, uap->buffer, strlen(platform.model)); retval = 1; break; default: printf("osf1_getsysinfo called with unknown op=%ld\n", uap->op); return EINVAL; } p->p_retval[0] = retval; return(error); } int osf1_setsysinfo(p, uap) struct proc *p; struct osf1_setsysinfo_args *uap; { int error; error = 0; switch(uap->op) { case OSF_SET_IEEE_FP_CONTROL: { u_int64_t temp, *fp_control; if ((error = copyin(uap->buffer, &temp, sizeof(temp)))) break; fp_control = &p->p_addr->u_pcb.pcb_fp_control; *fp_control = temp & IEEE_TRAP_ENABLE_MASK; break; } default: uprintf("osf1_setsysinfo called with op=%ld\n", uap->op); /*error = EINVAL;*/ } return (error); } int osf1_getrlimit(p, uap) struct proc *p; struct osf1_getrlimit_args *uap; { struct __getrlimit_args /* { syscallarg(u_int) which; syscallarg(struct rlimit *) rlp; } */ a; if (SCARG(uap, which) >= OSF1_RLIMIT_NLIMITS) return (EINVAL); if (SCARG(uap, which) <= OSF1_RLIMIT_LASTCOMMON) SCARG(&a, which) = SCARG(uap, which); else if (SCARG(uap, which) == OSF1_RLIMIT_NOFILE) SCARG(&a, which) = RLIMIT_NOFILE; else return (0); SCARG(&a, rlp) = (struct rlimit *)SCARG(uap, rlp); return getrlimit(p, &a); } int osf1_setrlimit(p, uap) struct proc *p; struct osf1_setrlimit_args *uap; { struct __setrlimit_args /* { syscallarg(u_int) which; syscallarg(struct rlimit *) rlp; } */ a; if (SCARG(uap, which) >= OSF1_RLIMIT_NLIMITS) return (EINVAL); if (SCARG(uap, which) <= OSF1_RLIMIT_LASTCOMMON) SCARG(&a, which) = SCARG(uap, which); else if (SCARG(uap, which) == OSF1_RLIMIT_NOFILE) SCARG(&a, which) = RLIMIT_NOFILE; else return (0); SCARG(&a, rlp) = (struct rlimit *)SCARG(uap, rlp); return setrlimit(p, &a); } /* * As linux says, this is a total guess. */ int osf1_set_program_attributes(p, uap) struct proc *p; struct osf1_set_program_attributes_args *uap; { struct vmspace *vm = p->p_vmspace; vm->vm_taddr = (caddr_t)uap->text_start; vm->vm_tsize = btoc(round_page(uap->text_len)); vm->vm_daddr = (caddr_t)uap->bss_start; vm->vm_dsize = btoc(round_page(uap->bss_len)); return(KERN_SUCCESS); } int osf1_mmap(p, uap) struct proc *p; struct osf1_mmap_args *uap; { struct mmap_args /* { syscallarg(caddr_t) addr; syscallarg(size_t) len; syscallarg(int) prot; syscallarg(int) flags; syscallarg(int) fd; syscallarg(long) pad; syscallarg(off_t) pos; } */ a; int retval; vm_map_t map; vm_offset_t addr, len, newaddr; SCARG(&a, addr) = SCARG(uap, addr); SCARG(&a, len) = SCARG(uap, len); SCARG(&a, prot) = SCARG(uap, prot); SCARG(&a, fd) = SCARG(uap, fd); SCARG(&a, pad) = 0; SCARG(&a, pos) = SCARG(uap, pos); SCARG(&a, flags) = 0; /* * OSF/1's mmap, unlike FreeBSD's, does its best to map memory at the * user's requested address, even if MAP_FIXED is not set. Here we * try to replicate this behaviour as much as we can because some * applications (like /sbin/loader) depend on having things put as * close to where they've requested as possible. */ if (SCARG(uap, addr) != NULL) addr = round_page((vm_offset_t)SCARG(&a,addr)); else /* * Try to use the apparent OSF/1 default placement of 0x10000 for * NULL addrs, this helps to prevent non-64 bit clean binaries from * SEGV'ing. */ addr = round_page((vm_offset_t)0x10000UL); len = (vm_offset_t)SCARG(&a, len); map = &p->p_vmspace->vm_map; if (!vm_map_findspace(map, addr, len, &newaddr)) { SCARG(&a,addr) = (caddr_t) newaddr; SCARG(&a, flags) |= (MAP_FIXED); } #ifdef DEBUG else uprintf("osf1_mmap:vm_map_findspace failed for: %p 0x%lx\n", (caddr_t)addr, len); #endif if (SCARG(uap, flags) & OSF1_MAP_SHARED) SCARG(&a, flags) |= MAP_SHARED; if (SCARG(uap, flags) & OSF1_MAP_PRIVATE) SCARG(&a, flags) |= MAP_PRIVATE; switch (SCARG(uap, flags) & OSF1_MAP_TYPE) { case OSF1_MAP_ANONYMOUS: SCARG(&a, flags) |= MAP_ANON; break; case OSF1_MAP_FILE: SCARG(&a, flags) |= MAP_FILE; break; default: return (EINVAL); } if (SCARG(uap, flags) & OSF1_MAP_FIXED) SCARG(&a, flags) |= MAP_FIXED; if (SCARG(uap, flags) & OSF1_MAP_HASSEMAPHORE) SCARG(&a, flags) |= MAP_HASSEMAPHORE; if (SCARG(uap, flags) & OSF1_MAP_INHERIT) SCARG(&a, flags) |= MAP_INHERIT; if (SCARG(uap, flags) & OSF1_MAP_UNALIGNED) return (EINVAL); /* * Emulate an osf/1 bug: Apparently, mmap'ed segments are always * readable even if the user doesn't or in PROT_READ. This causes * some buggy programs to segv. */ SCARG(&a, prot) |= PROT_READ; retval = mmap(p, &a); #ifdef DEBUG uprintf( "\nosf1_mmap: addr=%p (%p), len = 0x%lx, prot=0x%x, fd=%d, pad=0, pos=0x%lx", SCARG(uap, addr), SCARG(&a, addr),SCARG(uap, len), SCARG(uap, prot), SCARG(uap, fd), SCARG(uap, pos)); printf(" flags = 0x%x\n",SCARG(uap, flags)); #endif return (retval); } int osf1_msync(p, uap) struct proc *p; struct osf1_msync_args *uap; { struct msync_args a; a.addr = SCARG(uap, addr); a.len = SCARG(uap, len); a.flags = 0; if(SCARG(uap, flags) & OSF1_MS_ASYNC) SCARG(&a, flags) |= MS_ASYNC; if(SCARG(uap, flags) & OSF1_MS_SYNC) SCARG(&a, flags) |= MS_SYNC; if(SCARG(uap, flags) & OSF1_MS_INVALIDATE) SCARG(&a, flags) |= MS_INVALIDATE; return(msync(p, &a)); } struct osf1_stat { int32_t st_dev; u_int32_t st_ino; u_int32_t st_mode; u_int16_t st_nlink; u_int32_t st_uid; u_int32_t st_gid; int32_t st_rdev; u_int64_t st_size; int32_t st_atime_sec; int32_t st_spare1; int32_t st_mtime_sec; int32_t st_spare2; int32_t st_ctime_sec; int32_t st_spare3; u_int32_t st_blksize; int32_t st_blocks; u_int32_t st_flags; u_int32_t st_gen; }; /* * Get file status; this version follows links. */ /* ARGSUSED */ int osf1_stat(p, uap) struct proc *p; struct osf1_stat_args *uap; { int error; struct stat sb; struct osf1_stat osb; struct nameidata nd; caddr_t sg; sg = stackgap_init(); CHECKALTEXIST(p, &sg, uap->path); NDINIT(&nd, LOOKUP, FOLLOW | LOCKLEAF, UIO_USERSPACE, SCARG(uap, path), p); if ((error = namei(&nd))) return (error); error = vn_stat(nd.ni_vp, &sb, p); vput(nd.ni_vp); if (error) return (error); cvtstat2osf1(&sb, &osb); error = copyout((caddr_t)&osb, (caddr_t)SCARG(uap, ub), sizeof (osb)); return (error); } /* * Get file status; this version does not follow links. */ /* ARGSUSED */ int osf1_lstat(p, uap) struct proc *p; register struct osf1_lstat_args *uap; { struct stat sb; struct osf1_stat osb; int error; struct nameidata nd; caddr_t sg = stackgap_init(); CHECKALTEXIST(p, &sg, uap->path); NDINIT(&nd, LOOKUP, NOFOLLOW | LOCKLEAF, UIO_USERSPACE, SCARG(uap, path), p); if ((error = namei(&nd))) return (error); error = vn_stat(nd.ni_vp, &sb, p); vput(nd.ni_vp); if (error) return (error); cvtstat2osf1(&sb, &osb); error = copyout((caddr_t)&osb, (caddr_t)SCARG(uap, ub), sizeof (osb)); return (error); } /* * Return status information about a file descriptor. */ int osf1_fstat(p, uap) struct proc *p; register struct osf1_fstat_args *uap; { register struct filedesc *fdp = p->p_fd; register struct file *fp; struct stat ub; struct osf1_stat oub; int error; if ((unsigned)SCARG(uap, fd) >= fdp->fd_nfiles || (fp = fdp->fd_ofiles[SCARG(uap, fd)]) == NULL) return (EBADF); error = fo_stat(fp, &ub, p); cvtstat2osf1(&ub, &oub); if (error == 0) error = copyout((caddr_t)&oub, (caddr_t)SCARG(uap, sb), sizeof (oub)); return (error); } #if 1 #define bsd2osf_dev(dev) (umajor(dev) << 20 | uminor(dev)) #define osf2bsd_dev(dev) umakedev((umajor(dev) >> 20) & 0xfff, uminor(dev) & 0xfffff) #else #define minor(x) ((int)((x)&0xffff00ff)) #define major(x) ((int)(((u_int)(x) >> 8)&0xff)) #define makedev(x,y) ((dev_t)(((x) << 8) | (y))) #define bsd2osf_dev(dev) (major(dev) << 20 | minor(dev)) #define osf2bsd_dev(dev) makedev(((dev) >> 20) & 0xfff, (dev) & 0xfffff) #endif /* * Convert from a stat structure to an osf1 stat structure. */ static void cvtstat2osf1(st, ost) struct stat *st; struct osf1_stat *ost; { ost->st_dev = bsd2osf_dev(st->st_dev); ost->st_ino = st->st_ino; ost->st_mode = st->st_mode; ost->st_nlink = st->st_nlink; ost->st_uid = st->st_uid == -2 ? (u_int16_t) -2 : st->st_uid; ost->st_gid = st->st_gid == -2 ? (u_int16_t) -2 : st->st_gid; ost->st_rdev = bsd2osf_dev(st->st_rdev); ost->st_size = st->st_size; ost->st_atime_sec = st->st_atime; ost->st_spare1 = 0; ost->st_mtime_sec = st->st_mtime; ost->st_spare2 = 0; ost->st_ctime_sec = st->st_ctime; ost->st_spare3 = 0; ost->st_blksize = st->st_blksize; ost->st_blocks = st->st_blocks; ost->st_flags = st->st_flags; ost->st_gen = st->st_gen; } int osf1_mknod(p, uap) struct proc *p; struct osf1_mknod_args *uap; { #if notanymore struct mknod_args a; caddr_t sg; sg = stackgap_init(); CHECKALTEXIST(p, &sg, uap->path); SCARG(&a, path) = SCARG(uap, path); SCARG(&a, mode) = SCARG(uap, mode); SCARG(&a, dev) = osf2bsd_dev(SCARG(uap, dev)); return mknod(p, &a); #endif printf("osf1_mknod no longer implemented\n"); return ENOSYS; } int osf1_access(p, uap) struct proc *p; struct osf1_access_args *uap; { caddr_t sg; sg = stackgap_init(); CHECKALTEXIST(p, &sg, uap->path); return access(p, (struct access_args *)uap); } struct osf1_flock { short l_type; short l_whence; off_t l_start; off_t l_len; pid_t l_pid; }; int osf1_fcntl(p, uap) struct proc *p; struct osf1_fcntl_args *uap; { int error; long tmp; caddr_t oarg, sg; struct fcntl_args a; struct osf1_flock osf_flock; struct flock bsd_flock; struct flock *nflock; error = 0; switch (SCARG(uap, cmd)) { case F_SETFL: SCARG(&a, fd) = SCARG(uap, fd); SCARG(&a, cmd) = F_SETFL; /* need to translate flags here */ tmp = 0; if ((long)SCARG(uap, arg) & OSF1_FNONBLOCK) tmp |= FNONBLOCK; if ((long)SCARG(uap, arg) & OSF1_FAPPEND) tmp |= FAPPEND; if ((long)SCARG(uap, arg) & OSF1_FDEFER) tmp |= FDEFER; if ((long)SCARG(uap, arg) & OSF1_FASYNC) tmp |= FASYNC; if ((long)SCARG(uap, arg) & OSF1_FCREAT) tmp |= O_CREAT; if ((long)SCARG(uap, arg) & OSF1_FTRUNC) tmp |= O_TRUNC; if ((long)SCARG(uap, arg) & OSF1_FEXCL) tmp |= O_EXCL; if ((long)SCARG(uap, arg) & OSF1_FNDELAY) tmp |= FNDELAY; if ((long)SCARG(uap, arg) & OSF1_FSYNC) tmp |= FFSYNC; SCARG(&a, arg) = tmp; error = fcntl(p, &a); break; case F_SETLK: case F_SETLKW: case F_GETLK: /* * The OSF/1 flock stucture has a different order than * the BSD one, but all else is the same. We must * reorder the one we've gotten so that flock() groks it. */ if ((error = copyin(uap->arg, &osf_flock, sizeof(osf_flock)))) return error; bsd_flock.l_type = osf_flock.l_type; bsd_flock.l_whence = osf_flock.l_whence; bsd_flock.l_start = osf_flock.l_start; bsd_flock.l_len = osf_flock.l_len; bsd_flock.l_pid = osf_flock.l_pid; sg = stackgap_init(); nflock = stackgap_alloc(&sg, sizeof(struct flock)); if ((error = copyout(&bsd_flock, nflock, sizeof(bsd_flock))) != 0) return error; oarg = uap->arg; uap->arg = nflock; error = fcntl(p, (struct fcntl_args *) uap); /* if (error) { printf("fcntl called with cmd=%d, args=0x%lx\n returns %d\n",uap->cmd,(long)uap->arg,error); printf("bsd_flock.l_type = 0x%x\n", bsd_flock.l_type); printf("bsd_flock.l_whence = 0x%x\n", bsd_flock.l_whence); printf("bsd_flock.l_start = 0x%lx\n", bsd_flock.l_start); printf("bsd_flock.l_len = 0x%lx\n", bsd_flock.l_len); printf("bsd_flock.l_pid = 0x%x\n", bsd_flock.l_pid); } */ if ((uap->cmd == F_GETLK) && !error) { osf_flock.l_type = F_UNLCK; if ((error = copyout(&osf_flock, oarg, sizeof(osf_flock)))) return error; } break; default: error = fcntl(p, (struct fcntl_args *) uap); if ((uap->cmd == OSF1_F_GETFL) && !error ) { tmp = p->p_retval[0] & O_ACCMODE; if (p->p_retval[0] & FNONBLOCK) tmp |= OSF1_FNONBLOCK; if (p->p_retval[0] & FAPPEND) tmp |= OSF1_FAPPEND; if (p->p_retval[0] & FDEFER) tmp |= OSF1_FDEFER; if (p->p_retval[0] & FASYNC) tmp |= OSF1_FASYNC; if (p->p_retval[0] & O_CREAT) tmp |= OSF1_FCREAT; if (p->p_retval[0] & O_TRUNC) tmp |= OSF1_FTRUNC; if (p->p_retval[0] & O_EXCL) tmp |= OSF1_FEXCL; if (p->p_retval[0] & FNDELAY) tmp |= OSF1_FNDELAY; if (p->p_retval[0] & FFSYNC) tmp |= OSF1_FSYNC; p->p_retval[0] = tmp; } } return (error); } #if 0 int osf1_fcntl(p, uap) struct proc *p; struct osf1_fcntl_args *uap; { struct fcntl_args a; long tmp; int error; SCARG(&a, fd) = SCARG(uap, fd); switch (SCARG(uap, cmd)) { case OSF1_F_DUPFD: SCARG(&a, cmd) = F_DUPFD; SCARG(&a, arg) = (long)SCARG(uap, arg); break; case OSF1_F_GETFD: SCARG(&a, cmd) = F_GETFD; SCARG(&a, arg) = (long)SCARG(uap, arg); break; case OSF1_F_SETFD: SCARG(&a, cmd) = F_SETFD; SCARG(&a, arg) = (long)SCARG(uap, arg); break; case OSF1_F_GETFL: SCARG(&a, cmd) = F_GETFL; SCARG(&a, arg) = (long)SCARG(uap, arg); /* ignored */ break; case OSF1_F_SETFL: SCARG(&a, cmd) = F_SETFL; tmp = 0; if ((long)SCARG(uap, arg) & OSF1_FAPPEND) tmp |= FAPPEND; if ((long)SCARG(uap, arg) & OSF1_FNONBLOCK) tmp |= FNONBLOCK; if ((long)SCARG(uap, arg) & OSF1_FASYNC) tmp |= FASYNC; if ((long)SCARG(uap, arg) & OSF1_FSYNC) tmp |= FFSYNC; SCARG(&a, arg) = tmp; break; default: /* XXX other cases */ return (EINVAL); } error = fcntl(p, &a); if (error) return error; switch (SCARG(uap, cmd)) { case OSF1_F_GETFL: /* XXX */ break; } return error; } #endif int osf1_socket(p, uap) struct proc *p; struct osf1_socket_args *uap; { struct socket_args a; if (SCARG(uap, type) > AF_LINK) return (EINVAL); /* XXX After AF_LINK, divergence. */ SCARG(&a, domain) = SCARG(uap, domain); SCARG(&a, type) = SCARG(uap, type); SCARG(&a, protocol) = SCARG(uap, protocol); return socket(p, &a); } int osf1_sendto(p, uap) struct proc *p; register struct osf1_sendto_args *uap; { struct sendto_args a; if (SCARG(uap, flags) & ~0x7f) /* unsupported flags */ return (EINVAL); SCARG(&a, s) = SCARG(uap, s); SCARG(&a, buf) = SCARG(uap, buf); SCARG(&a, len) = SCARG(uap, len); SCARG(&a, flags) = SCARG(uap, flags); SCARG(&a, to) = (caddr_t)SCARG(uap, to); SCARG(&a, tolen) = SCARG(uap, tolen); return sendto(p, &a); } int osf1_reboot(p, uap) struct proc *p; struct osf1_reboot_args *uap; { struct reboot_args a; if (SCARG(uap, opt) & ~OSF1_RB_ALLFLAGS && SCARG(uap, opt) & (OSF1_RB_ALTBOOT|OSF1_RB_UNIPROC)) return (EINVAL); SCARG(&a, opt) = 0; if (SCARG(uap, opt) & OSF1_RB_ASKNAME) SCARG(&a, opt) |= RB_ASKNAME; if (SCARG(uap, opt) & OSF1_RB_SINGLE) SCARG(&a, opt) |= RB_SINGLE; if (SCARG(uap, opt) & OSF1_RB_NOSYNC) SCARG(&a, opt) |= RB_NOSYNC; if (SCARG(uap, opt) & OSF1_RB_HALT) SCARG(&a, opt) |= RB_HALT; if (SCARG(uap, opt) & OSF1_RB_INITNAME) SCARG(&a, opt) |= RB_INITNAME; if (SCARG(uap, opt) & OSF1_RB_DFLTROOT) SCARG(&a, opt) |= RB_DFLTROOT; return reboot(p, &a); } int osf1_lseek(p, uap) struct proc *p; struct osf1_lseek_args *uap; { struct lseek_args a; SCARG(&a, fd) = SCARG(uap, fd); SCARG(&a, pad) = 0; SCARG(&a, offset) = SCARG(uap, offset); SCARG(&a, whence) = SCARG(uap, whence); return lseek(p, &a); } /* * OSF/1 defines _POSIX_SAVED_IDS, which means that our normal * setuid() won't work. * * Instead, by P1003.1b-1993, setuid() is supposed to work like: * If the process has appropriate [super-user] priviledges, the * setuid() function sets the real user ID, effective user * ID, and the saved set-user-ID to uid. * If the process does not have appropriate priviledges, but uid * is equal to the real user ID or the saved set-user-ID, the * setuid() function sets the effective user ID to uid; the * real user ID and saved set-user-ID remain unchanged by * this function call. */ int osf1_setuid(p, uap) struct proc *p; struct osf1_setuid_args *uap; { int error; uid_t uid; register struct pcred *pc; uid = SCARG(uap, uid); pc = p->p_cred; if ((error = suser(p)) != 0 && uid != pc->p_ruid && uid != pc->p_svuid) return (error); if (error == 0) { if (uid != pc->p_ruid) { change_ruid(p, uid); setsugid(p); } if (pc->p_svuid != uid) { pc->p_svuid = uid; setsugid(p); } } if (pc->pc_ucred->cr_uid != uid) { change_euid(p, uid); setsugid(p); } return (0); } /* * OSF/1 defines _POSIX_SAVED_IDS, which means that our normal * setgid() won't work. * * If you change "uid" to "gid" in the discussion, above, about * setuid(), you'll get a correct description of setgid(). */ int osf1_setgid(p, uap) struct proc *p; struct osf1_setgid_args *uap; { int error; gid_t gid; register struct pcred *pc; gid = SCARG(uap, gid); pc = p->p_cred; if (((error = suser(p)) != 0 ) && gid != pc->p_rgid && gid != pc->p_svgid) return (error); pc->pc_ucred = crcopy(pc->pc_ucred); pc->pc_ucred->cr_gid = gid; if (error == 0) { pc->p_rgid = gid; pc->p_svgid = gid; } setsugid(p); return (0); } /* * The structures end up being the same... but we can't be sure that * the other word of our iov_len is zero! */ struct osf1_iovec { char *iov_base; int iov_len; }; #define STACKGAPLEN 400 int osf1_readv(p, uap) struct proc *p; struct osf1_readv_args *uap; { int error, osize, nsize, i; caddr_t sg; struct readv_args /* { syscallarg(int) fd; syscallarg(struct iovec *) iovp; syscallarg(u_int) iovcnt; } */ a; struct osf1_iovec *oio; struct iovec *nio; sg = stackgap_init(); if (SCARG(uap, iovcnt) > (STACKGAPLEN / sizeof (struct iovec))) return (EINVAL); osize = SCARG(uap, iovcnt) * sizeof (struct osf1_iovec); nsize = SCARG(uap, iovcnt) * sizeof (struct iovec); oio = malloc(osize, M_TEMP, M_WAITOK); nio = malloc(nsize, M_TEMP, M_WAITOK); error = 0; if ((error = copyin(SCARG(uap, iovp), oio, osize))) goto punt; for (i = 0; i < SCARG(uap, iovcnt); i++) { nio[i].iov_base = oio[i].iov_base; nio[i].iov_len = oio[i].iov_len; } SCARG(&a, fd) = SCARG(uap, fd); SCARG(&a, iovp) = stackgap_alloc(&sg, nsize); SCARG(&a, iovcnt) = SCARG(uap, iovcnt); if ((error = copyout(nio, (caddr_t)SCARG(&a, iovp), nsize))) goto punt; error = readv(p, &a); punt: free(oio, M_TEMP); free(nio, M_TEMP); return (error); } int osf1_writev(p, uap) struct proc *p; struct osf1_writev_args *uap; { int error, i, nsize, osize; caddr_t sg; struct writev_args /* { syscallarg(int) fd; syscallarg(struct iovec *) iovp; syscallarg(u_int) iovcnt; } */ a; struct osf1_iovec *oio; struct iovec *nio; sg = stackgap_init(); if (SCARG(uap, iovcnt) > (STACKGAPLEN / sizeof (struct iovec))) return (EINVAL); osize = SCARG(uap, iovcnt) * sizeof (struct osf1_iovec); nsize = SCARG(uap, iovcnt) * sizeof (struct iovec); oio = malloc(osize, M_TEMP, M_WAITOK); nio = malloc(nsize, M_TEMP, M_WAITOK); error = 0; if ((error = copyin(SCARG(uap, iovp), oio, osize))) goto punt; for (i = 0; i < SCARG(uap, iovcnt); i++) { nio[i].iov_base = oio[i].iov_base; nio[i].iov_len = oio[i].iov_len; } SCARG(&a, fd) = SCARG(uap, fd); SCARG(&a, iovp) = stackgap_alloc(&sg, nsize); SCARG(&a, iovcnt) = SCARG(uap, iovcnt); if ((error = copyout(nio, (caddr_t)SCARG(&a, iovp), nsize))) goto punt; error = writev(p, &a); punt: free(oio, M_TEMP); free(nio, M_TEMP); return (error); } /* * More of the stupid off_t padding! */ int osf1_truncate(p, uap) struct proc *p; struct osf1_truncate_args *uap; { caddr_t sg; struct truncate_args a; sg = stackgap_init(); CHECKALTEXIST(p, &sg, uap->path); SCARG(&a, path) = SCARG(uap, path); SCARG(&a, pad) = 0; SCARG(&a, length) = SCARG(uap, length); return truncate(p, &a); } int osf1_ftruncate(p, uap) struct proc *p; struct osf1_ftruncate_args *uap; { struct ftruncate_args a; SCARG(&a, fd) = SCARG(uap, fd); SCARG(&a, pad) = 0; SCARG(&a, length) = SCARG(uap, length); return ftruncate(p, &a); } static int osf2bsd_pathconf(name) int *name; { switch (*name) { case _OSF1_PC_LINK_MAX: case _OSF1_PC_MAX_CANON: case _OSF1_PC_MAX_INPUT: case _OSF1_PC_NAME_MAX: *name -= 10; break; case _OSF1_PC_PATH_MAX: case _OSF1_PC_PIPE_BUF: *name -= 9; case _OSF1_PC_NO_TRUNC: *name = _PC_NO_TRUNC; break; case _OSF1_PC_CHOWN_RESTRICTED: *name = _PC_CHOWN_RESTRICTED; break; case _OSF1_PC_VDISABLE: *name = _PC_VDISABLE; break; default: return (EINVAL); } return 0; } int osf1_pathconf(p, uap) struct proc *p; struct osf1_pathconf_args *uap; { if (osf2bsd_pathconf(&uap->name)) return (EINVAL); else return (pathconf(p, (void *)uap)); } int osf1_fpathconf(p, uap) struct proc *p; struct osf1_fpathconf_args *uap; { if (osf2bsd_pathconf(&uap->name)) return (EINVAL); else return (fpathconf(p, (void *)uap)); } int osf1_getrusage(p, uap) struct proc *p; struct osf1_getrusage_args *uap; { struct rusage *rup; struct osf1_rusage oru; switch (uap->who) { case RUSAGE_SELF: rup = &p->p_stats->p_ru; mtx_lock_spin(&sched_lock); calcru(p, &rup->ru_utime, &rup->ru_stime, NULL); mtx_unlock_spin(&sched_lock); break; case RUSAGE_CHILDREN: rup = &p->p_stats->p_cru; break; default: return (EINVAL); } TV_CP(rup->ru_utime, oru.ru_utime); TV_CP(rup->ru_stime, oru.ru_stime); bcopy(&(rup->ru_first), &(oru.ru_first), (&(oru.ru_last) - &(oru.ru_first))); return (copyout((caddr_t)&oru, (caddr_t)uap->rusage, sizeof (struct osf1_rusage))); } int osf1_wait4(p, uap) struct proc *p; struct osf1_wait4_args *uap; { int error; caddr_t sg; struct osf1_rusage *orusage, oru; struct rusage *rusage = NULL, ru; orusage = SCARG(uap, rusage); if (orusage) { sg = stackgap_init(); rusage = stackgap_alloc(&sg, sizeof(struct rusage)); SCARG(uap, rusage) = (struct osf1_rusage *)rusage; } if ((error = wait4(p, (struct wait_args *)uap))) return error; if (orusage && (error = copyin(rusage, &ru, sizeof(ru)) == 0)){ TV_CP(ru.ru_utime, oru.ru_utime); TV_CP(ru.ru_stime, oru.ru_stime); bcopy(&ru.ru_first, &oru.ru_first, (&(oru.ru_last) - &(oru.ru_first))); copyout(&oru, orusage, sizeof (struct osf1_rusage)); } return (0); } int osf1_madvise(p, uap) struct proc *p; struct osf1_madvise_args *uap; { /* XXX */ return EINVAL; } int osf1_execve(p, uap) struct proc *p; struct osf1_execve_args *uap; { caddr_t sg; struct execve_args ap; sg = stackgap_init(); CHECKALTEXIST(p, &sg, SCARG(uap, path)); SCARG(&ap, fname) = SCARG(uap, path); SCARG(&ap, argv) = SCARG(uap, argp); SCARG(&ap, envv) = SCARG(uap, envp); return execve(p, &ap); } int osf1_usleep_thread(p, uap) struct proc *p; struct osf1_usleep_thread_args *uap; { int error, s, timo; struct osf1_timeval time; struct timeval difftv, endtv, sleeptv, tv; if ((error = copyin(SCARG(uap, sleep), &time, sizeof time))) return (error); sleeptv.tv_sec = (u_long)time.tv_sec; sleeptv.tv_usec = (u_long)time.tv_usec; timo = tvtohz(&sleeptv); /* * Some callers use usleep(0) as a sort of thread-yield so make * sure that the timeout is non-zero. */ if (timo == 0) timo = 1; s = splclock(); microtime(&tv); splx(s); tsleep(p, PUSER|PCATCH, "OSF/1", timo); if (SCARG(uap, slept) != NULL) { s = splclock(); microtime(&endtv); timersub(&time, &endtv, &difftv); splx(s); if (tv.tv_sec < 0 || tv.tv_usec < 0) tv.tv_sec = tv.tv_usec = 0; TV_CP(difftv, time) error = copyout(&time, SCARG(uap, slept), sizeof time); } return (error); } int osf1_gettimeofday(p, uap) struct proc *p; register struct osf1_gettimeofday_args *uap; { int error; struct timeval atv; struct osf1_timeval otv; error = 0; if (uap->tp) { microtime(&atv); otv.tv_sec = atv.tv_sec; otv.tv_usec = atv.tv_usec; if ((error = copyout((caddr_t)&otv, (caddr_t)uap->tp, sizeof (otv)))) return (error); } if (uap->tzp) error = copyout((caddr_t)&tz, (caddr_t)uap->tzp, sizeof (tz)); return (error); } int osf1_select(p, uap) struct proc *p; register struct osf1_select_args *uap; { if (uap->tv) { int error; caddr_t sg; struct osf1_timeval otv; struct timeval tv; sg = stackgap_init(); if ((error=copyin((caddr_t)uap->tv,(caddr_t)&otv,sizeof(otv)))) return(error); TV_CP(otv,tv); uap->tv = stackgap_alloc(&sg, sizeof(struct timeval)); if ((error=copyout((caddr_t)&tv, (caddr_t)uap->tv,sizeof(tv)))) return(error); } return(select(p, (struct select_args *)uap)); } int osf1_setitimer(p, uap) struct proc *p; struct osf1_setitimer_args *uap; { int error; caddr_t old_oitv, sg; struct itimerval itv; struct osf1_itimerval otv; error = 0; old_oitv = (caddr_t)uap->oitv; sg = stackgap_init(); if ((error = copyin((caddr_t)uap->itv,(caddr_t)&otv,sizeof(otv)))) { printf("%s(%d): error = %d\n", __FILE__, __LINE__, error); return error; } TV_CP(otv.it_interval,itv.it_interval); TV_CP(otv.it_value,itv.it_value); uap->itv = stackgap_alloc(&sg, sizeof(struct itimerval)); if ((error = copyout((caddr_t)&itv,(caddr_t)uap->itv,sizeof(itv)))) { printf("%s(%d): error = %d\n", __FILE__, __LINE__, error); return error; } uap->oitv = stackgap_alloc(&sg, sizeof(struct itimerval)); if ((error = setitimer(p, (struct setitimer_args *)uap))) { printf("%s(%d): error = %d\n", __FILE__, __LINE__, error); return error; } if ((error = copyin((caddr_t)uap->oitv,(caddr_t)&itv,sizeof(itv)))) { printf("%s(%d): error = %d\n", __FILE__, __LINE__, error); return error; } TV_CP(itv.it_interval,otv.it_interval); TV_CP(itv.it_value,otv.it_value); if (old_oitv && (error = copyout((caddr_t)&otv, old_oitv, sizeof(otv)))) { printf("%s(%d): error = %d\n", __FILE__, __LINE__, error); } return error; } int osf1_getitimer(p, uap) struct proc *p; struct osf1_getitimer_args *uap; { int error; caddr_t old_itv, sg; struct itimerval itv; struct osf1_itimerval otv; error = 0; old_itv = (caddr_t)uap->itv; sg = stackgap_init(); uap->itv = stackgap_alloc(&sg, sizeof(struct itimerval)); if ((error = getitimer(p, (struct getitimer_args *)uap))) { printf("%s(%d): error = %d\n", __FILE__, __LINE__, error); return error; } if ((error = copyin((caddr_t)uap->itv,(caddr_t)&itv,sizeof(itv)))) { printf("%s(%d): error = %d\n", __FILE__, __LINE__, error); return error; } TV_CP(itv.it_interval,otv.it_interval); TV_CP(itv.it_value,otv.it_value); if ((error = copyout((caddr_t)&otv, old_itv, sizeof(otv)))) { printf("%s(%d): error = %d\n", __FILE__, __LINE__, error); } return error; } int osf1_proplist_syscall(p, uap) struct proc *p; struct osf1_proplist_syscall_args *uap; { return(EOPNOTSUPP); } int osf1_ntpgettime(p, uap) struct proc *p; struct osf1_ntpgettime_args *uap; { return(ENOSYS); } int osf1_ntpadjtime(p, uap) struct proc *p; struct osf1_ntpadjtime_args *uap; { return(ENOSYS); } int osf1_setpgrp(p, uap) struct proc *p; struct osf1_setpgrp_args *uap; { return(setpgid(p, (struct setpgid_args *)uap)); } int osf1_uswitch(p, uap) struct proc *p; struct osf1_uswitch_args *uap; { int rv; vm_map_entry_t entry; vm_offset_t zero; zero = 0; if (uap->cmd == OSF1_USC_GET) { if (vm_map_lookup_entry(&(p->p_vmspace->vm_map),0, &entry)) p->p_retval[0] = OSF1_USW_NULLP; else p->p_retval[0] = 0; return(KERN_SUCCESS); } else if (uap->cmd == OSF1_USC_SET) if (uap->mask & OSF1_USW_NULLP) { rv = vm_mmap(&(p->p_vmspace->vm_map), &zero, PAGE_SIZE, VM_PROT_READ, VM_PROT_ALL, MAP_PRIVATE | MAP_FIXED | MAP_ANON, NULL, 0); if (!rv) return(KERN_SUCCESS); else { printf( "osf1_uswitch:vm_mmap of zero page failed with status %d\n", rv); return(rv); } } return(EINVAL); } int osf1_classcntl(p, uap) struct proc *p; struct osf1_classcntl_args *uap; { return(EACCES); /* class scheduling not enabled */ } struct osf1_tbl_loadavg { union { long l[3]; double d[3]; } tl_avenrun; int tl_lscale; long tl_mach_factor[3]; /* ???? */ }; struct osf1_tbl_sysinfo { long si_user; long si_nice; long si_sys; long si_idle; long si_hz; long si_phz; long si_boottime; long wait; }; #define TBL_LOADAVG 3 #define TBL_SYSINFO 12 int osf1_table(p, uap) struct proc *p; struct osf1_table_args /*{ long id; long index; void *addr; long nel; u_long lel; }*/ *uap; { int retval; struct osf1_tbl_loadavg ld; struct osf1_tbl_sysinfo si; retval = 0; switch(uap->id) { case TBL_LOADAVG: /* xemacs wants this */ if ((uap->index != 0) || (uap->nel != 1)) retval = EINVAL; bcopy(&averunnable, &ld, sizeof(averunnable)); ld.tl_lscale = (u_int)averunnable.fscale; retval = copyout(&ld, uap->addr, sizeof(ld)); break; case TBL_SYSINFO: if ((uap->index != 0) || (uap->nel != 1)) retval = EINVAL; bzero(&si, sizeof(si)); #if 0 si.si_user = cp_time[CP_USER]; si.si_nice = cp_time[CP_NICE]; si.si_sys = cp_time[CP_SYS]; si.si_idle = cp_time[CP_IDLE]; si.wait = cp_time[CP_INTR]; #endif si.si_hz = hz; si.si_phz = profhz; si.si_boottime = boottime.tv_sec; retval = copyout(&si, uap->addr, sizeof(si)); break; default: printf("osf1_table: %ld, %ld, %p, %ld %ld\n", uap->id, uap->index, uap->addr, uap->nel, uap->lel); retval = EINVAL; } return retval; } int osf1_sysinfo(p, uap) struct proc *p; struct osf1_sysinfo_args /*{ int cmd; char *buf; long count; }*/ *uap; { int name[2], retval; size_t bytes, len; char *string; string = NULL; switch(uap->cmd) { case 1: /* OS */ string = "OSF1"; break; case 2: /* hostname, from ogethostname */ len = uap->count; name[0] = CTL_KERN; name[1] = KERN_HOSTNAME; retval = userland_sysctl(p, name, 2, uap->buf, &len, 1, 0, 0, &bytes); p->p_retval[0] = bytes; return(retval); break; case 3: /* release of osf1 */ string = "V4.0"; break; case 4: /* minor version of osf1 */ string = "878"; break; case 5: /* machine or arch */ case 6: string = "alpha"; break; case 7: /* serial number, real osf1 returns 0! */ string = "0"; break; case 8: /* HW vendor */ string = "Digital"; break; case 9: /* dunno, this is what du does.. */ return(ENOSYS); break; default: return(EINVAL); } bytes = min(uap->count, strlen(string)+1); copyout(string, uap->buf, bytes); p->p_retval[0] = bytes; return(0); }