ultrix_pathname.c revision 1.30.4.1
1 /* $NetBSD: ultrix_pathname.c,v 1.30.4.1 2008/01/02 21:53:39 bouyer 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 filesysten 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, prefixex with '/emul/ultrix', and 54 * if that pathname exists, it is used instead of the providd 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 filesysten namespace. 59 */ 60 61 #include <sys/cdefs.h> 62 __KERNEL_RCSID(0, "$NetBSD: ultrix_pathname.c,v 1.30.4.1 2008/01/02 21:53:39 bouyer 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 struct filedesc *fdp = p->p_fd; 177 struct file *fp; 178 179 fp = fd_getfile(fdp, *retval); 180 181 /* ignore any error, just give it a try */ 182 if (fp != NULL && fp->f_type == DTYPE_VNODE) 183 (fp->f_ops->fo_ioctl)(fp, TIOCSCTTY, (void *)0, l); 184 } 185 return ret; 186 } 187 188 189 struct ultrix_statfs { 190 long f_type; /* type of info, zero for now */ 191 long f_bsize; /* fundamental file system block size */ 192 long f_blocks; /* total blocks in file system */ 193 long f_bfree; /* free blocks */ 194 long f_bavail; /* free blocks available to non-super-user */ 195 long f_files; /* total file nodes in file system */ 196 long f_ffree; /* free file nodes in fs */ 197 fsid_t f_fsid; /* file system id */ 198 long f_spare[7]; /* spare for later */ 199 }; 200 201 /* 202 * Custruct ultrix statfs result from native. 203 * XXX should this be the same as returned by Ultrix getmnt(2)? 204 * XXX Ultrix predates DEV_BSIZE. Is conversion of disk space from 1k 205 * block units to DEV_BSIZE necessary? 206 */ 207 static int 208 ultrixstatfs(struct statvfs *sp, void *buf) 209 { 210 struct ultrix_statfs ssfs; 211 212 memset(&ssfs, 0, sizeof ssfs); 213 ssfs.f_type = 0; 214 ssfs.f_bsize = sp->f_bsize; 215 ssfs.f_blocks = sp->f_blocks; 216 ssfs.f_bfree = sp->f_bfree; 217 ssfs.f_bavail = sp->f_bavail; 218 ssfs.f_files = sp->f_files; 219 ssfs.f_ffree = sp->f_ffree; 220 ssfs.f_fsid = sp->f_fsidx; 221 return copyout((void *)&ssfs, buf, sizeof ssfs); 222 } 223 224 225 int 226 ultrix_sys_statfs(struct lwp *l, const struct ultrix_sys_statfs_args *uap, register_t *retval) 227 { 228 struct mount *mp; 229 struct statvfs *sp; 230 int error; 231 struct nameidata nd; 232 233 NDINIT(&nd, LOOKUP, FOLLOW | TRYEMULROOT, UIO_USERSPACE, 234 SCARG(uap, path)); 235 if ((error = namei(&nd)) != 0) 236 return error; 237 238 mp = nd.ni_vp->v_mount; 239 sp = &mp->mnt_stat; 240 vrele(nd.ni_vp); 241 if ((error = VFS_STATVFS(mp, sp)) != 0) 242 return error; 243 sp->f_flag = mp->mnt_flag & MNT_VISFLAGMASK; 244 return ultrixstatfs(sp, (void *)SCARG(uap, buf)); 245 } 246 247 /* 248 * sys_fstatfs() takes an fd, not a path, and so needs no emul 249 * pathname processing; but it's similar enough to sys_statvfs() that 250 * it goes here anyway. 251 */ 252 int 253 ultrix_sys_fstatfs(struct lwp *l, const struct ultrix_sys_fstatfs_args *uap, register_t *retval) 254 { 255 struct proc *p = l->l_proc; 256 struct file *fp; 257 struct mount *mp; 258 struct statvfs *sp; 259 int error; 260 261 /* getvnode() will use the descriptor for us */ 262 if ((error = getvnode(p->p_fd, SCARG(uap, fd), &fp)) != 0) 263 return error; 264 mp = ((struct vnode *)fp->f_data)->v_mount; 265 sp = &mp->mnt_stat; 266 if ((error = VFS_STATVFS(mp, sp)) != 0) 267 goto out; 268 sp->f_flag = mp->mnt_flag & MNT_VISFLAGMASK; 269 error = ultrixstatfs(sp, (void *)SCARG(uap, buf)); 270 out: 271 FILE_UNUSE(fp, l); 272 return error; 273 } 274 275 int 276 ultrix_sys_mknod(struct lwp *l, const struct ultrix_sys_mknod_args *uap, register_t *retval) 277 { 278 279 if (S_ISFIFO(SCARG(uap, mode))) 280 return sys_mkfifo(l, (const struct sys_mkfifo_args *)uap, 281 retval); 282 283 return sys_mknod(l, (const struct sys_mknod_args *)uap, retval); 284 } 285
Indexes created Thu Oct 02 01:09:59 GMT 2025