Home | History | Annotate | Line # | Download | only in ultrix
      1 /*	$NetBSD: ultrix_pathname.c,v 1.40 2022/10/12 20:50:43 andvar 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. Neither the name of the University nor the names of its contributors
     25  *    may be used to endorse or promote products derived from this software
     26  *    without specific prior written permission.
     27  *
     28  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
     29  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
     30  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
     31  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
     32  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
     33  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
     34  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
     35  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
     36  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
     37  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
     38  * SUCH DAMAGE.
     39  *
     40  *
     41  *	@(#)sun_misc.c	8.1 (Berkeley) 6/18/93
     42  *
     43  * from: Header: sun_misc.c,v 1.16 93/04/07 02:46:27 torek Exp
     44  */
     45 
     46 
     47 /*
     48  * Ultrix emulation filesystem-namespace compatibility module.
     49  *
     50  * Ultrix system calls that examine the filesystem namespace
     51  * are implemented here.  Each system call has a wrapper that
     52  * first checks if the given file exists at a special `emulation'
     53  * pathname: the given path, prefixed with '/emul/ultrix', and
     54  * if that pathname exists, it is used instead of the provided pathname.
     55  *
     56  * Used to locate OS-specific files (shared libraries, config files,
     57  * etc) used by emul processes at their `normal' pathnames, without
     58  * polluting, or conflicting with, the native filesystem namespace.
     59  */
     60 
     61 #include <sys/cdefs.h>
     62 __KERNEL_RCSID(0, "$NetBSD: ultrix_pathname.c,v 1.40 2022/10/12 20:50:43 andvar Exp $");
     63 
     64 #include <sys/param.h>
     65 #include <sys/systm.h>
     66 #include <sys/namei.h>
     67 #include <sys/file.h>
     68 #include <sys/filedesc.h>
     69 #include <sys/ioctl.h>
     70 #include <sys/mount.h>
     71 #include <sys/stat.h>
     72 #include <sys/vnode.h>
     73 #include <sys/syscallargs.h>
     74 #include <sys/proc.h>
     75 
     76 #include <compat/ultrix/ultrix_syscallargs.h>
     77 #include <compat/common/compat_util.h>
     78 
     79 static int ultrixstatfs(struct statvfs *, void *);
     80 
     81 int
     82 ultrix_sys_creat(struct lwp *l, const struct ultrix_sys_creat_args *uap, register_t *retval)
     83 {
     84 	struct sys_open_args ap;
     85 
     86 	SCARG(&ap, path) = SCARG(uap, path);
     87 	SCARG(&ap, flags) = O_WRONLY | O_CREAT | O_TRUNC;
     88 	SCARG(&ap, mode) = SCARG(uap, mode);
     89 
     90 	return sys_open(l, &ap, retval);
     91 }
     92 
     93 
     94 int
     95 ultrix_sys_access(struct lwp *l, const struct ultrix_sys_access_args *uap, register_t *retval)
     96 {
     97 
     98 	return sys_access(l, (const struct sys_access_args *)uap, retval);
     99 }
    100 
    101 int
    102 ultrix_sys_stat(struct lwp *l, const struct ultrix_sys_stat_args *uap, register_t *retval)
    103 {
    104 
    105 	return compat_43_sys_stat(l,
    106 	    (const struct compat_43_sys_stat_args *)uap, retval);
    107 }
    108 
    109 int
    110 ultrix_sys_lstat(struct lwp *l, const struct ultrix_sys_lstat_args *uap, register_t *retval)
    111 {
    112 
    113 	return compat_43_sys_lstat(l,
    114 	    (const struct compat_43_sys_lstat_args *)uap, retval);
    115 }
    116 
    117 int
    118 ultrix_sys_execv(struct lwp *l, const struct ultrix_sys_execv_args *uap, register_t *retval)
    119 {
    120 	/* {
    121 		syscallarg(const char *) path;
    122 		syscallarg(char **) argv;
    123 	} */
    124 	struct sys_execve_args ap;
    125 
    126 	SCARG(&ap, path) = SCARG(uap, path);
    127 	SCARG(&ap, argp) = SCARG(uap, argp);
    128 	SCARG(&ap, envp) = NULL;
    129 
    130 	return sys_execve(l, &ap, retval);
    131 }
    132 
    133 int
    134 ultrix_sys_execve(struct lwp *l, const struct ultrix_sys_execve_args *uap, register_t *retval)
    135 {
    136 	/* {
    137 		syscallarg(const char *) path;
    138 		syscallarg(char **) argv;
    139 		syscallarg(char **) envp;
    140 	} */
    141 	struct sys_execve_args ap;
    142 
    143 	SCARG(&ap, path) = SCARG(uap, path);
    144 	SCARG(&ap, argp) = SCARG(uap, argp);
    145 	SCARG(&ap, envp) = SCARG(uap, envp);
    146 
    147 	return sys_execve(l, &ap, retval);
    148 }
    149 
    150 int
    151 ultrix_sys_open(struct lwp *l, const struct ultrix_sys_open_args *uap, register_t *retval)
    152 {
    153 	struct proc *p = l->l_proc;
    154 	int q, r;
    155 	int noctty;
    156 	int ret;
    157 	struct sys_open_args ap;
    158 
    159 	/* convert open flags into NetBSD flags */
    160 
    161 	q = SCARG(uap, flags);
    162 	noctty = q & 0x8000;
    163 	r =	(q & (0x0001 | 0x0002 | 0x0008 | 0x0040 | 0x0200 | 0x0400 | 0x0800));
    164 	r |=	((q & (0x0004 | 0x1000 | 0x4000)) ? O_NONBLOCK : 0);
    165 	r |=	((q & 0x0080) ? O_SHLOCK : 0);
    166 	r |=	((q & 0x0100) ? O_EXLOCK : 0);
    167 	r |=	((q & 0x2000) ? O_FSYNC : 0);
    168 
    169 	SCARG(&ap, path) = SCARG(uap, path);
    170 	SCARG(&ap, flags) = r;
    171 	SCARG(&ap, mode) = SCARG(uap, mode);
    172 	ret = sys_open(l, &ap, retval);
    173 
    174 	/* XXXSMP */
    175 	if (!ret && !noctty && SESS_LEADER(p) && !(p->p_lflag & PL_CONTROLT)) {
    176 		file_t *fp;
    177 		int fd;
    178 
    179 		fd = (int)*retval;
    180 		fp = fd_getfile(fd);
    181 
    182 		/* ignore any error, just give it a try */
    183 		if (fp != NULL) {
    184 			if (fp->f_type == DTYPE_VNODE)
    185 				(fp->f_ops->fo_ioctl)(fp, TIOCSCTTY, NULL);
    186 			fd_putfile(fd);
    187 		}
    188 	}
    189 	return ret;
    190 }
    191 
    192 
    193 struct ultrix_statfs {
    194 	int32_t	f_type;		/* type of info, zero for now */
    195 	int32_t	f_bsize;	/* fundamental file system block size */
    196 	int32_t	f_blocks;	/* total blocks in file system */
    197 	int32_t	f_bfree;	/* free blocks */
    198 	int32_t	f_bavail;	/* free blocks available to non-super-user */
    199 	int32_t	f_files;	/* total file nodes in file system */
    200 	int32_t	f_ffree;	/* free file nodes in fs */
    201 	fsid_t	f_fsid;		/* file system id */
    202 	int32_t	f_spare[7];	/* spare for later */
    203 };
    204 
    205 /*
    206  * Custruct ultrix statfs result from native.
    207  * XXX should this be the same as returned by Ultrix getmnt(2)?
    208  * XXX Ultrix predates DEV_BSIZE.  Is  conversion of disk space from 1k
    209  *  block units to DEV_BSIZE necessary?
    210  */
    211 static int
    212 ultrixstatfs(struct statvfs *sp, void *buf)
    213 {
    214 	struct ultrix_statfs ssfs;
    215 
    216 	memset(&ssfs, 0, sizeof ssfs);
    217 	ssfs.f_type = 0;
    218 	ssfs.f_bsize = sp->f_bsize;
    219 	ssfs.f_blocks = sp->f_blocks;
    220 	ssfs.f_bfree = sp->f_bfree;
    221 	ssfs.f_bavail = sp->f_bavail;
    222 	ssfs.f_files = sp->f_files;
    223 	ssfs.f_ffree = sp->f_ffree;
    224 	ssfs.f_fsid = sp->f_fsidx;
    225 	return copyout((void *)&ssfs, buf, sizeof ssfs);
    226 }
    227 
    228 
    229 int
    230 ultrix_sys_statfs(struct lwp *l, const struct ultrix_sys_statfs_args *uap, register_t *retval)
    231 {
    232 	struct mount *mp;
    233 	struct statvfs *sp;
    234 	int error;
    235 	struct vnode *vp;
    236 
    237 	error = namei_simple_user(SCARG(uap, path),
    238 				NSM_FOLLOW_TRYEMULROOT, &vp);
    239 	if (error != 0)
    240 		return error;
    241 
    242 	mp = vp->v_mount;
    243 	sp = &mp->mnt_stat;
    244 	vrele(vp);
    245 	if ((error = VFS_STATVFS(mp, sp)) != 0)
    246 		return error;
    247 	sp->f_flag = mp->mnt_flag & MNT_VISFLAGMASK;
    248 	return ultrixstatfs(sp, (void *)SCARG(uap, buf));
    249 }
    250 
    251 /*
    252  * sys_fstatfs() takes an fd, not a path, and so needs no emul
    253  * pathname processing;  but it's similar enough to sys_statvfs() that
    254  * it goes here anyway.
    255  */
    256 int
    257 ultrix_sys_fstatfs(struct lwp *l, const struct ultrix_sys_fstatfs_args *uap, register_t *retval)
    258 {
    259 	file_t *fp;
    260 	struct mount *mp;
    261 	struct statvfs *sp;
    262 	int error;
    263 
    264 	/* fd_getvnode() will use the descriptor for us */
    265 	if ((error = fd_getvnode(SCARG(uap, fd), &fp)) != 0)
    266 		return error;
    267 	mp = fp->f_vnode->v_mount;
    268 	sp = &mp->mnt_stat;
    269 	if ((error = VFS_STATVFS(mp, sp)) != 0)
    270 		goto out;
    271 	sp->f_flag = mp->mnt_flag & MNT_VISFLAGMASK;
    272 	error = ultrixstatfs(sp, (void *)SCARG(uap, buf));
    273  out:
    274  	fd_putfile(SCARG(uap, fd));
    275 	return error;
    276 }
    277 
    278 int
    279 ultrix_sys_mknod(struct lwp *l, const struct ultrix_sys_mknod_args *uap, register_t *retval)
    280 {
    281 
    282 	if (S_ISFIFO(SCARG(uap, mode)))
    283 		return sys_mkfifo(l, (const struct sys_mkfifo_args *)uap,
    284 		    retval);
    285 
    286 	return compat_50_sys_mknod(l,
    287 				   (const struct compat_50_sys_mknod_args *)uap,
    288 				   retval);
    289 }
    290