root/compat/ultrix/ultrix_pathname.c

DEFINITIONS

1. ultrix_sys_creat
2. ultrix_sys_access
3. ultrix_sys_stat
4. ultrix_sys_lstat
5. ultrix_sys_execv
6. ultrix_sys_open
7. ultrixstatfs
8. ultrix_sys_statfs
9. ultrix_sys_fstatfs
10. ultrix_sys_mknod

    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 $     */
    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  */
   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  */
   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>
   73 #include <compat/ultrix/ultrix_syscallargs.h>
   74 #include <compat/ultrix/ultrix_util.h>
   76 const char ultrix_emul_path[] = "/emul/ultrix";
   78 int
ultrix_sys_creat(p, v, retval)
   80         struct proc *p;
   81         void *v;
register_t *retval;
   83 {
   84         struct ultrix_sys_creat_args *uap = v;
   85         struct sys_open_args ouap;
caddr_t sg = stackgap_init(p->p_emul);
ULTRIX_CHECK_ALT_EXIST(p, &sg, SCARG(uap, path));
SCARG(&ouap, path) = SCARG(uap, path);
SCARG(&ouap, flags) = O_WRONLY | O_CREAT | O_TRUNC;
SCARG(&ouap, mode) = SCARG(uap, mode);
   94         return (sys_open(p, &ouap, retval));
   95 }
   98 int
ultrix_sys_access(p, v, retval)
  100         struct proc *p;
  101         void *v;
register_t *retval;
  103 {
  104         struct ultrix_sys_access_args *uap = v;
caddr_t sg = stackgap_init(p->p_emul);
ULTRIX_CHECK_ALT_EXIST(p, &sg, SCARG(uap, path));
  108         return (sys_access(p, uap, retval));
  109 }
  111 int
ultrix_sys_stat(p, v, retval)
  113         struct proc *p;
  114         void *v;
register_t *retval;
  116 {
  117         struct ultrix_sys_stat_args *uap = v;
caddr_t sg = stackgap_init(p->p_emul);
ULTRIX_CHECK_ALT_EXIST(p, &sg, SCARG(uap, path));
  121         return (compat_43_sys_stat(p, uap, retval));
  122 }
  124 int
ultrix_sys_lstat(p, v, retval)
  126         struct proc *p;
  127         void *v;
register_t *retval;
  129 {
  130         struct ultrix_sys_lstat_args *uap = v;
caddr_t sg = stackgap_init(p->p_emul);
ULTRIX_CHECK_ALT_EXIST(p, &sg, SCARG(uap, path));
  134         return (compat_43_sys_lstat(p, uap, retval));
  135 }
  137 int
ultrix_sys_execv(p, v, retval)
  139         struct proc *p;
  140         void *v;
register_t *retval;
  142 {
  143         struct ultrix_sys_execv_args *uap = v;
  144         struct sys_execve_args ouap;
caddr_t sg = stackgap_init(p->p_emul);
ULTRIX_CHECK_ALT_EXIST(p, &sg, SCARG(uap, path));
SCARG(&ouap, path) = SCARG(uap, path);
SCARG(&ouap, argp) = SCARG(uap, argp);
SCARG(&ouap, envp) = NULL;
  153         return (sys_execve(p, &ouap, retval));
  154 }
  156 int
ultrix_sys_open(p, v, retval)
  158         struct proc *p;
  159         void *v;
register_t *retval;
  161 {
  162         struct ultrix_sys_open_args *uap = v;
  163         int l, r;
  164         int noctty;
  165         int ret;
caddr_t sg = stackgap_init(p->p_emul);
ULTRIX_CHECK_ALT_EXIST(p, &sg, SCARG(uap, path));
  170         /* convert open flags into NetBSD flags */
l = SCARG(uap, flags);
noctty = l & 0x8000;
r =     (l & (0x0001 | 0x0002 | 0x0008 | 0x0040 | 0x0200 | 0x0400 | 0x0800));
r |=    ((l & (0x0004 | 0x1000 | 0x4000)) ? O_NONBLOCK : 0);
r |=    ((l & 0x0080) ? O_SHLOCK : 0);
r |=    ((l & 0x0100) ? O_EXLOCK : 0);
r |=    ((l & 0x2000) ? O_SYNC : 0);
SCARG(uap, flags) = r;
ret = sys_open(p, (struct sys_open_args *)uap, retval);
  182         if (!ret && !noctty && SESS_LEADER(p) && !(p->p_flag & P_CONTROLT)) {
  183                 struct filedesc *fdp = p->p_fd;
  184                 struct file *fp;
  186                 if ((fd = fd_getfile(fdp, *retval)) == NULL)
  187                         return (EBADF);
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);
FRELE(fp);
  193         }
  194         return ret;
  195 }
  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 */
fsid_t  f_fsid;         /* file system id */
  207         long    f_spare[7];     /* spare for later */
  208 };
  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
ultrixstatfs(sp, buf)
  218         struct statfs *sp;
caddr_t buf;
  220 {
  221         struct ultrix_statfs ssfs;
bzero(&ssfs, 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_fsid;
  232         return copyout((caddr_t)&ssfs, buf, sizeof ssfs);
  233 }
  236 int
ultrix_sys_statfs(p, v, retval)
  238         struct proc *p;
  239         void *v;
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;
caddr_t sg = stackgap_init(p->p_emul);
ULTRIX_CHECK_ALT_EXIST(p, &sg, SCARG(uap, path));
NDINIT(&nd, LOOKUP, FOLLOW, UIO_USERSPACE, SCARG(uap, path), p);
  252         if ((error = namei(&nd)) != 0)
  253                 return (error);
mp = nd.ni_vp->v_mount;
sp = &mp->mnt_stat;
vrele(nd.ni_vp);
  258         if ((error = VFS_STATFS(mp, sp, p)) != 0)
  259                 return (error);
sp->f_flags = mp->mnt_flag & MNT_VISFLAGMASK;
  261         return ultrixstatfs(sp, (caddr_t)SCARG(uap, buf));
  262 }
  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
ultrix_sys_fstatfs(p, v, retval)
  271         struct proc *p;
  272         void *v;
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;
  281         if ((error = getvnode(p->p_fd, SCARG(uap, fd), &fp)) != 0)
  282                 return (error);
mp = ((struct vnode *)fp->f_data)->v_mount;
sp = &mp->mnt_stat;
error = VFS_STATFS(mp, sp, p);
FRELE(fp);
  288         if (error)
  289                 return (error);
sp->f_flags = mp->mnt_flag & MNT_VISFLAGMASK;
  291         return ultrixstatfs(sp, (caddr_t)SCARG(uap, buf));
  292 }
  294 int
ultrix_sys_mknod(p, v, retval)
  296         struct proc *p;
  297         void *v;
register_t *retval;
  299 {
  300         struct ultrix_sys_mknod_args *uap = v;
caddr_t sg = stackgap_init(p->p_emul);
ULTRIX_CHECK_ALT_EXIST(p, &sg, SCARG(uap, path));
  305         if (S_ISFIFO(SCARG(uap, mode)))
  306                 return sys_mkfifo(p, uap, retval);
  308         return sys_mknod(p, (struct sys_mknod_args *)uap, retval);
  309 }