/* $NetBSD: ultrix_pathname.c,v 1.40 2022/10/12 20:50:43 andvar Exp $ */ /* * Copyright (c) 1992, 1993 * The Regents of the University of California. All rights reserved. * * This software was developed by the Computer Systems Engineering group * at Lawrence Berkeley Laboratory under DARPA contract BG 91-66 and * contributed to Berkeley. * * All advertising materials mentioning features or use of this software * must display the following acknowledgement: * This product includes software developed by the University of * California, Lawrence Berkeley Laboratory. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * 1. Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * 2. Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * 3. Neither the name of the University nor the names of its contributors * may be used to endorse or promote products derived from this software * without specific prior written permission. * * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF * SUCH DAMAGE. * * * @(#)sun_misc.c 8.1 (Berkeley) 6/18/93 * * from: Header: sun_misc.c,v 1.16 93/04/07 02:46:27 torek Exp */ /* * Ultrix emulation filesystem-namespace compatibility module. * * Ultrix system calls that examine the filesystem namespace * are implemented here. Each system call has a wrapper that * first checks if the given file exists at a special `emulation' * pathname: the given path, prefixed with '/emul/ultrix', and * if that pathname exists, it is used instead of the provided pathname. * * Used to locate OS-specific files (shared libraries, config files, * etc) used by emul processes at their `normal' pathnames, without * polluting, or conflicting with, the native filesystem namespace. */ #include __KERNEL_RCSID(0, "$NetBSD: ultrix_pathname.c,v 1.40 2022/10/12 20:50:43 andvar Exp $"); #include #include #include #include #include #include #include #include #include #include #include #include #include static int ultrixstatfs(struct statvfs *, void *); int ultrix_sys_creat(struct lwp *l, const struct ultrix_sys_creat_args *uap, register_t *retval) { struct sys_open_args ap; SCARG(&ap, path) = SCARG(uap, path); SCARG(&ap, flags) = O_WRONLY | O_CREAT | O_TRUNC; SCARG(&ap, mode) = SCARG(uap, mode); return sys_open(l, &ap, retval); } int ultrix_sys_access(struct lwp *l, const struct ultrix_sys_access_args *uap, register_t *retval) { return sys_access(l, (const struct sys_access_args *)uap, retval); } int ultrix_sys_stat(struct lwp *l, const struct ultrix_sys_stat_args *uap, register_t *retval) { return compat_43_sys_stat(l, (const struct compat_43_sys_stat_args *)uap, retval); } int ultrix_sys_lstat(struct lwp *l, const struct ultrix_sys_lstat_args *uap, register_t *retval) { return compat_43_sys_lstat(l, (const struct compat_43_sys_lstat_args *)uap, retval); } int ultrix_sys_execv(struct lwp *l, const struct ultrix_sys_execv_args *uap, register_t *retval) { /* { syscallarg(const char *) path; syscallarg(char **) argv; } */ struct sys_execve_args ap; SCARG(&ap, path) = SCARG(uap, path); SCARG(&ap, argp) = SCARG(uap, argp); SCARG(&ap, envp) = NULL; return sys_execve(l, &ap, retval); } int ultrix_sys_execve(struct lwp *l, const struct ultrix_sys_execve_args *uap, register_t *retval) { /* { syscallarg(const char *) path; syscallarg(char **) argv; syscallarg(char **) envp; } */ struct sys_execve_args ap; SCARG(&ap, path) = SCARG(uap, path); SCARG(&ap, argp) = SCARG(uap, argp); SCARG(&ap, envp) = SCARG(uap, envp); return sys_execve(l, &ap, retval); } int ultrix_sys_open(struct lwp *l, const struct ultrix_sys_open_args *uap, register_t *retval) { struct proc *p = l->l_proc; int q, r; int noctty; int ret; struct sys_open_args ap; /* convert open flags into NetBSD flags */ q = SCARG(uap, flags); noctty = q & 0x8000; r = (q & (0x0001 | 0x0002 | 0x0008 | 0x0040 | 0x0200 | 0x0400 | 0x0800)); r |= ((q & (0x0004 | 0x1000 | 0x4000)) ? O_NONBLOCK : 0); r |= ((q & 0x0080) ? O_SHLOCK : 0); r |= ((q & 0x0100) ? O_EXLOCK : 0); r |= ((q & 0x2000) ? O_FSYNC : 0); SCARG(&ap, path) = SCARG(uap, path); SCARG(&ap, flags) = r; SCARG(&ap, mode) = SCARG(uap, mode); ret = sys_open(l, &ap, retval); /* XXXSMP */ if (!ret && !noctty && SESS_LEADER(p) && !(p->p_lflag & PL_CONTROLT)) { file_t *fp; int fd; fd = (int)*retval; fp = fd_getfile(fd); /* ignore any error, just give it a try */ if (fp != NULL) { if (fp->f_type == DTYPE_VNODE) (fp->f_ops->fo_ioctl)(fp, TIOCSCTTY, NULL); fd_putfile(fd); } } return ret; } struct ultrix_statfs { int32_t f_type; /* type of info, zero for now */ int32_t f_bsize; /* fundamental file system block size */ int32_t f_blocks; /* total blocks in file system */ int32_t f_bfree; /* free blocks */ int32_t f_bavail; /* free blocks available to non-super-user */ int32_t f_files; /* total file nodes in file system */ int32_t f_ffree; /* free file nodes in fs */ fsid_t f_fsid; /* file system id */ int32_t f_spare[7]; /* spare for later */ }; /* * Custruct ultrix statfs result from native. * XXX should this be the same as returned by Ultrix getmnt(2)? * XXX Ultrix predates DEV_BSIZE. Is conversion of disk space from 1k * block units to DEV_BSIZE necessary? */ static int ultrixstatfs(struct statvfs *sp, void *buf) { struct ultrix_statfs ssfs; memset(&ssfs, 0, sizeof ssfs); ssfs.f_type = 0; ssfs.f_bsize = sp->f_bsize; ssfs.f_blocks = sp->f_blocks; ssfs.f_bfree = sp->f_bfree; ssfs.f_bavail = sp->f_bavail; ssfs.f_files = sp->f_files; ssfs.f_ffree = sp->f_ffree; ssfs.f_fsid = sp->f_fsidx; return copyout((void *)&ssfs, buf, sizeof ssfs); } int ultrix_sys_statfs(struct lwp *l, const struct ultrix_sys_statfs_args *uap, register_t *retval) { struct mount *mp; struct statvfs *sp; int error; struct vnode *vp; error = namei_simple_user(SCARG(uap, path), NSM_FOLLOW_TRYEMULROOT, &vp); if (error != 0) return error; mp = vp->v_mount; sp = &mp->mnt_stat; vrele(vp); if ((error = VFS_STATVFS(mp, sp)) != 0) return error; sp->f_flag = mp->mnt_flag & MNT_VISFLAGMASK; return ultrixstatfs(sp, (void *)SCARG(uap, buf)); } /* * sys_fstatfs() takes an fd, not a path, and so needs no emul * pathname processing; but it's similar enough to sys_statvfs() that * it goes here anyway. */ int ultrix_sys_fstatfs(struct lwp *l, const struct ultrix_sys_fstatfs_args *uap, register_t *retval) { file_t *fp; struct mount *mp; struct statvfs *sp; int error; /* fd_getvnode() will use the descriptor for us */ if ((error = fd_getvnode(SCARG(uap, fd), &fp)) != 0) return error; mp = fp->f_vnode->v_mount; sp = &mp->mnt_stat; if ((error = VFS_STATVFS(mp, sp)) != 0) goto out; sp->f_flag = mp->mnt_flag & MNT_VISFLAGMASK; error = ultrixstatfs(sp, (void *)SCARG(uap, buf)); out: fd_putfile(SCARG(uap, fd)); return error; } int ultrix_sys_mknod(struct lwp *l, const struct ultrix_sys_mknod_args *uap, register_t *retval) { if (S_ISFIFO(SCARG(uap, mode))) return sys_mkfifo(l, (const struct sys_mkfifo_args *)uap, retval); return compat_50_sys_mknod(l, (const struct compat_50_sys_mknod_args *)uap, retval); }