Annotation of sys/compat/ultrix/ultrix_pathname.c, Revision 1.1
1.1 ! nbrk 1: /* $OpenBSD: ultrix_pathname.c,v 1.9 2003/06/02 23:28:01 millert Exp $ */
! 2: /* $NetBSD: ultrix_pathname.c,v 1.2 1996/04/07 17:23:07 jonathan Exp $ */
! 3:
! 4: /*
! 5: * Copyright (c) 1992, 1993
! 6: * The Regents of the University of California. All rights reserved.
! 7: *
! 8: * This software was developed by the Computer Systems Engineering group
! 9: * at Lawrence Berkeley Laboratory under DARPA contract BG 91-66 and
! 10: * contributed to Berkeley.
! 11: *
! 12: * All advertising materials mentioning features or use of this software
! 13: * must display the following acknowledgement:
! 14: * This product includes software developed by the University of
! 15: * California, Lawrence Berkeley Laboratory.
! 16: *
! 17: * Redistribution and use in source and binary forms, with or without
! 18: * modification, are permitted provided that the following conditions
! 19: * are met:
! 20: * 1. Redistributions of source code must retain the above copyright
! 21: * notice, this list of conditions and the following disclaimer.
! 22: * 2. Redistributions in binary form must reproduce the above copyright
! 23: * notice, this list of conditions and the following disclaimer in the
! 24: * documentation and/or other materials provided with the distribution.
! 25: * 3. Neither the name of the University nor the names of its contributors
! 26: * may be used to endorse or promote products derived from this software
! 27: * without specific prior written permission.
! 28: *
! 29: * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
! 30: * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
! 31: * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
! 32: * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
! 33: * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
! 34: * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
! 35: * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
! 36: * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
! 37: * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
! 38: * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
! 39: * SUCH DAMAGE.
! 40: *
! 41: *
! 42: * @(#)sun_misc.c 8.1 (Berkeley) 6/18/93
! 43: *
! 44: * from: Header: sun_misc.c,v 1.16 93/04/07 02:46:27 torek Exp
! 45: */
! 46:
! 47:
! 48: /*
! 49: * Ultrix emulation filesystem-namespace compatibility module.
! 50: *
! 51: * Ultrix system calls that examine the filesysten namespace
! 52: * are implemented here. Each system call has a wrapper that
! 53: * first checks if the given file exists at a special `emulation'
! 54: * pathname: the given path, prefixex with '/emul/ultrix', and
! 55: * if that pathname exists, it is used instead of the providd pathname.
! 56: *
! 57: * Used to locate OS-specific files (shared libraries, config files,
! 58: * etc) used by emul processes at their `normal' pathnames, without
! 59: * polluting, or conflicting with, the native filesysten namespace.
! 60: */
! 61:
! 62: #include <sys/param.h>
! 63: #include <sys/systm.h>
! 64: #include <sys/namei.h>
! 65: #include <sys/file.h>
! 66: #include <sys/filedesc.h>
! 67: #include <sys/ioctl.h>
! 68: #include <sys/mount.h>
! 69: #include <sys/stat.h>
! 70: #include <sys/vnode.h>
! 71: #include <sys/syscallargs.h>
! 72:
! 73: #include <compat/ultrix/ultrix_syscallargs.h>
! 74: #include <compat/ultrix/ultrix_util.h>
! 75:
! 76: const char ultrix_emul_path[] = "/emul/ultrix";
! 77:
! 78: int
! 79: ultrix_sys_creat(p, v, retval)
! 80: struct proc *p;
! 81: void *v;
! 82: register_t *retval;
! 83: {
! 84: struct ultrix_sys_creat_args *uap = v;
! 85: struct sys_open_args ouap;
! 86:
! 87: caddr_t sg = stackgap_init(p->p_emul);
! 88: ULTRIX_CHECK_ALT_EXIST(p, &sg, SCARG(uap, path));
! 89:
! 90: SCARG(&ouap, path) = SCARG(uap, path);
! 91: SCARG(&ouap, flags) = O_WRONLY | O_CREAT | O_TRUNC;
! 92: SCARG(&ouap, mode) = SCARG(uap, mode);
! 93:
! 94: return (sys_open(p, &ouap, retval));
! 95: }
! 96:
! 97:
! 98: int
! 99: ultrix_sys_access(p, v, retval)
! 100: struct proc *p;
! 101: void *v;
! 102: register_t *retval;
! 103: {
! 104: struct ultrix_sys_access_args *uap = v;
! 105: caddr_t sg = stackgap_init(p->p_emul);
! 106: ULTRIX_CHECK_ALT_EXIST(p, &sg, SCARG(uap, path));
! 107:
! 108: return (sys_access(p, uap, retval));
! 109: }
! 110:
! 111: int
! 112: ultrix_sys_stat(p, v, retval)
! 113: struct proc *p;
! 114: void *v;
! 115: register_t *retval;
! 116: {
! 117: struct ultrix_sys_stat_args *uap = v;
! 118: caddr_t sg = stackgap_init(p->p_emul);
! 119: ULTRIX_CHECK_ALT_EXIST(p, &sg, SCARG(uap, path));
! 120:
! 121: return (compat_43_sys_stat(p, uap, retval));
! 122: }
! 123:
! 124: int
! 125: ultrix_sys_lstat(p, v, retval)
! 126: struct proc *p;
! 127: void *v;
! 128: register_t *retval;
! 129: {
! 130: struct ultrix_sys_lstat_args *uap = v;
! 131: caddr_t sg = stackgap_init(p->p_emul);
! 132: ULTRIX_CHECK_ALT_EXIST(p, &sg, SCARG(uap, path));
! 133:
! 134: return (compat_43_sys_lstat(p, uap, retval));
! 135: }
! 136:
! 137: int
! 138: ultrix_sys_execv(p, v, retval)
! 139: struct proc *p;
! 140: void *v;
! 141: register_t *retval;
! 142: {
! 143: struct ultrix_sys_execv_args *uap = v;
! 144: struct sys_execve_args ouap;
! 145:
! 146: caddr_t sg = stackgap_init(p->p_emul);
! 147: ULTRIX_CHECK_ALT_EXIST(p, &sg, SCARG(uap, path));
! 148:
! 149: SCARG(&ouap, path) = SCARG(uap, path);
! 150: SCARG(&ouap, argp) = SCARG(uap, argp);
! 151: SCARG(&ouap, envp) = NULL;
! 152:
! 153: return (sys_execve(p, &ouap, retval));
! 154: }
! 155:
! 156: int
! 157: ultrix_sys_open(p, v, retval)
! 158: struct proc *p;
! 159: void *v;
! 160: register_t *retval;
! 161: {
! 162: struct ultrix_sys_open_args *uap = v;
! 163: int l, r;
! 164: int noctty;
! 165: int ret;
! 166:
! 167: caddr_t sg = stackgap_init(p->p_emul);
! 168: ULTRIX_CHECK_ALT_EXIST(p, &sg, SCARG(uap, path));
! 169:
! 170: /* convert open flags into NetBSD flags */
! 171: l = SCARG(uap, flags);
! 172: noctty = l & 0x8000;
! 173: r = (l & (0x0001 | 0x0002 | 0x0008 | 0x0040 | 0x0200 | 0x0400 | 0x0800));
! 174: r |= ((l & (0x0004 | 0x1000 | 0x4000)) ? O_NONBLOCK : 0);
! 175: r |= ((l & 0x0080) ? O_SHLOCK : 0);
! 176: r |= ((l & 0x0100) ? O_EXLOCK : 0);
! 177: r |= ((l & 0x2000) ? O_SYNC : 0);
! 178:
! 179: SCARG(uap, flags) = r;
! 180: ret = sys_open(p, (struct sys_open_args *)uap, retval);
! 181:
! 182: if (!ret && !noctty && SESS_LEADER(p) && !(p->p_flag & P_CONTROLT)) {
! 183: struct filedesc *fdp = p->p_fd;
! 184: struct file *fp;
! 185:
! 186: if ((fd = fd_getfile(fdp, *retval)) == NULL)
! 187: return (EBADF);
! 188: FREF(fp);
! 189: /* ignore any error, just give it a try */
! 190: if (fp->f_type == DTYPE_VNODE)
! 191: (fp->f_ops->fo_ioctl)(fp, TIOCSCTTY, (caddr_t)0, p);
! 192: FRELE(fp);
! 193: }
! 194: return ret;
! 195: }
! 196:
! 197:
! 198: struct ultrix_statfs {
! 199: long f_type; /* type of info, zero for now */
! 200: long f_bsize; /* fundamental file system block size */
! 201: long f_blocks; /* total blocks in file system */
! 202: long f_bfree; /* free blocks */
! 203: long f_bavail; /* free blocks available to non-super-user */
! 204: long f_files; /* total file nodes in file system */
! 205: long f_ffree; /* free file nodes in fs */
! 206: fsid_t f_fsid; /* file system id */
! 207: long f_spare[7]; /* spare for later */
! 208: };
! 209:
! 210: /*
! 211: * Custruct ultrix statfs result from native.
! 212: * XXX should this be the same as returned by Ultrix getmnt(2)?
! 213: * XXX Ultrix predates DEV_BSIZE. Is conversion of disk space from 1k
! 214: * block units to DEV_BSIZE necessary?
! 215: */
! 216: static int
! 217: ultrixstatfs(sp, buf)
! 218: struct statfs *sp;
! 219: caddr_t buf;
! 220: {
! 221: struct ultrix_statfs ssfs;
! 222:
! 223: bzero(&ssfs, sizeof ssfs);
! 224: ssfs.f_type = 0;
! 225: ssfs.f_bsize = sp->f_bsize;
! 226: ssfs.f_blocks = sp->f_blocks;
! 227: ssfs.f_bfree = sp->f_bfree;
! 228: ssfs.f_bavail = sp->f_bavail;
! 229: ssfs.f_files = sp->f_files;
! 230: ssfs.f_ffree = sp->f_ffree;
! 231: ssfs.f_fsid = sp->f_fsid;
! 232: return copyout((caddr_t)&ssfs, buf, sizeof ssfs);
! 233: }
! 234:
! 235:
! 236: int
! 237: ultrix_sys_statfs(p, v, retval)
! 238: struct proc *p;
! 239: void *v;
! 240: register_t *retval;
! 241: {
! 242: struct ultrix_sys_statfs_args *uap = v;
! 243: register struct mount *mp;
! 244: register struct statfs *sp;
! 245: int error;
! 246: struct nameidata nd;
! 247:
! 248: caddr_t sg = stackgap_init(p->p_emul);
! 249: ULTRIX_CHECK_ALT_EXIST(p, &sg, SCARG(uap, path));
! 250:
! 251: NDINIT(&nd, LOOKUP, FOLLOW, UIO_USERSPACE, SCARG(uap, path), p);
! 252: if ((error = namei(&nd)) != 0)
! 253: return (error);
! 254:
! 255: mp = nd.ni_vp->v_mount;
! 256: sp = &mp->mnt_stat;
! 257: vrele(nd.ni_vp);
! 258: if ((error = VFS_STATFS(mp, sp, p)) != 0)
! 259: return (error);
! 260: sp->f_flags = mp->mnt_flag & MNT_VISFLAGMASK;
! 261: return ultrixstatfs(sp, (caddr_t)SCARG(uap, buf));
! 262: }
! 263:
! 264: /*
! 265: * sys_fstatfs() takes an fd, not a path, and so needs no emul
! 266: * pathname processing; but it's similar enough to sys_statfs() that
! 267: * it goes here anyway.
! 268: */
! 269: int
! 270: ultrix_sys_fstatfs(p, v, retval)
! 271: struct proc *p;
! 272: void *v;
! 273: register_t *retval;
! 274: {
! 275: struct ultrix_sys_fstatfs_args *uap = v;
! 276: struct file *fp;
! 277: struct mount *mp;
! 278: register struct statfs *sp;
! 279: int error;
! 280:
! 281: if ((error = getvnode(p->p_fd, SCARG(uap, fd), &fp)) != 0)
! 282: return (error);
! 283:
! 284: mp = ((struct vnode *)fp->f_data)->v_mount;
! 285: sp = &mp->mnt_stat;
! 286: error = VFS_STATFS(mp, sp, p);
! 287: FRELE(fp);
! 288: if (error)
! 289: return (error);
! 290: sp->f_flags = mp->mnt_flag & MNT_VISFLAGMASK;
! 291: return ultrixstatfs(sp, (caddr_t)SCARG(uap, buf));
! 292: }
! 293:
! 294: int
! 295: ultrix_sys_mknod(p, v, retval)
! 296: struct proc *p;
! 297: void *v;
! 298: register_t *retval;
! 299: {
! 300: struct ultrix_sys_mknod_args *uap = v;
! 301:
! 302: caddr_t sg = stackgap_init(p->p_emul);
! 303: ULTRIX_CHECK_ALT_EXIST(p, &sg, SCARG(uap, path));
! 304:
! 305: if (S_ISFIFO(SCARG(uap, mode)))
! 306: return sys_mkfifo(p, uap, retval);
! 307:
! 308: return sys_mknod(p, (struct sys_mknod_args *)uap, retval);
! 309: }
CVSweb
![[BACK]](/icons/back.gif){kind=icon}
Return to ultrix_pathname.c CVS log ![[TXT]](/icons/text.gif){kind=icon}
![[DIR]](/icons/dir.gif){kind=icon}
Up to [local] / sys / compat / ultrix