root/miscfs/portal/portal_vnops.c

DEFINITIONS

1. portal_closefd
2. portal_lookup
3. portal_connect
4. portal_open
5. portal_getattr
6. portal_setattr
7. portal_readdir
8. portal_inactive
9. portal_reclaim
10. portal_pathconf
11. portal_print
12. portal_link
13. portal_symlink
14. portal_badop
15. portal_poll

    1 /*      $OpenBSD: portal_vnops.c,v 1.24 2007/06/18 08:30:07 jasper Exp $        */
    2 /*      $NetBSD: portal_vnops.c,v 1.17 1996/02/13 13:12:57 mycroft Exp $        */
    4 /*
    5  * Copyright (c) 1992, 1993
    6  *      The Regents of the University of California.  All rights reserved.
    7  *
    8  * This code is derived from software donated to Berkeley by
    9  * Jan-Simon Pendry.
   10  *
   11  * Redistribution and use in source and binary forms, with or without
   12  * modification, are permitted provided that the following conditions
   13  * are met:
   14  * 1. Redistributions of source code must retain the above copyright
   15  *    notice, this list of conditions and the following disclaimer.
   16  * 2. Redistributions in binary form must reproduce the above copyright
   17  *    notice, this list of conditions and the following disclaimer in the
   18  *    documentation and/or other materials provided with the distribution.
   19  * 3. Neither the name of the University nor the names of its contributors
   20  *    may be used to endorse or promote products derived from this software
   21  *    without specific prior written permission.
   22  *
   23  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
   24  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
   25  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
   26  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
   27  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
   28  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
   29  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
   30  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
   31  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
   32  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
   33  * SUCH DAMAGE.
   34  *
   35  *      from: Id: portal_vnops.c,v 1.4 1992/05/30 10:05:24 jsp Exp
   36  *      @(#)portal_vnops.c      8.8 (Berkeley) 1/21/94
   37  */
   39 /*
   40  * Portal Filesystem
   41  */
   43 #include <sys/param.h>
   44 #include <sys/systm.h>
   45 #include <sys/kernel.h>
   46 #include <sys/types.h>
   47 #include <sys/time.h>
   48 #include <sys/proc.h>
   49 #include <sys/filedesc.h>
   50 #include <sys/vnode.h>
   51 #include <sys/file.h>
   52 #include <sys/stat.h>
   53 #include <sys/mount.h>
   54 #include <sys/malloc.h>
   55 #include <sys/namei.h>
   56 #include <sys/mbuf.h>
   57 #include <sys/poll.h>
   58 #include <sys/socket.h>
   59 #include <sys/socketvar.h>
   60 #include <sys/un.h>
   61 #include <sys/unpcb.h>
   62 #include <sys/syscallargs.h>
   63 #include <miscfs/portal/portal.h>
   65 static int portal_fileid = PORTAL_ROOTFILEID+1;
   67 static void     portal_closefd(struct proc *, int);
   68 static int      portal_connect(struct socket *, struct socket *);
   71 int portal_badop(void *);
   73 int     portal_lookup(void *);
   74 #define portal_create   eopnotsupp
   75 #define portal_mknod    eopnotsupp
   76 int     portal_open(void *);
   77 #define portal_close    nullop
   78 #define portal_access   nullop
   79 int     portal_getattr(void *);
   80 int     portal_setattr(void *);
   81 #define portal_read     eopnotsupp
   82 #define portal_write    eopnotsupp
   83 #define portal_ioctl    (int (*)(void *))enoioctl
   84 #define portal_fsync    nullop
   85 #define portal_remove   eopnotsupp
   86 int     portal_link(void *);
   87 #define portal_rename   eopnotsupp
   88 #define portal_mkdir    eopnotsupp
   89 #define portal_rmdir    eopnotsupp
   90 int     portal_symlink(void *);
   91 int     portal_readdir(void *);
   92 #define portal_revoke   vop_generic_revoke
   93 #define portal_readlink eopnotsupp
   94 int     portal_inactive(void *);
   95 int     portal_reclaim(void *);
   96 #define portal_lock     vop_generic_lock
   97 #define portal_unlock   vop_generic_unlock
   98 #define portal_bmap     portal_badop
   99 #define portal_strategy portal_badop
  100 int     portal_print(void *);
  101 #define portal_islocked vop_generic_islocked
  102 int     portal_pathconf(void *);
  103 #define portal_advlock  eopnotsupp
  104 #define portal_bwrite   eopnotsupp
  105 int     portal_poll(void *);
  107 int (**portal_vnodeop_p)(void *);
  108 struct vnodeopv_entry_desc portal_vnodeop_entries[] = {
  109         { &vop_default_desc, vn_default_error },
  110         { &vop_lookup_desc, portal_lookup },            /* lookup */
  111         { &vop_create_desc, portal_create },            /* create */
  112         { &vop_mknod_desc, portal_mknod },              /* mknod */
  113         { &vop_open_desc, portal_open },                /* open */
  114         { &vop_close_desc, portal_close },              /* close */
  115         { &vop_access_desc, portal_access },            /* access */
  116         { &vop_getattr_desc, portal_getattr },          /* getattr */
  117         { &vop_setattr_desc, portal_setattr },          /* setattr */
  118         { &vop_read_desc, portal_read },                /* read */
  119         { &vop_write_desc, portal_write },              /* write */
  120         { &vop_ioctl_desc, portal_ioctl },              /* ioctl */
  121         { &vop_poll_desc, portal_poll },                /* poll */
  122         { &vop_revoke_desc, portal_revoke },            /* revoke */
  123         { &vop_fsync_desc, portal_fsync },              /* fsync */
  124         { &vop_remove_desc, portal_remove },            /* remove */
  125         { &vop_link_desc, portal_link },                /* link */
  126         { &vop_rename_desc, portal_rename },            /* rename */
  127         { &vop_mkdir_desc, portal_mkdir },              /* mkdir */
  128         { &vop_rmdir_desc, portal_rmdir },              /* rmdir */
  129         { &vop_symlink_desc, portal_symlink },          /* symlink */
  130         { &vop_readdir_desc, portal_readdir },          /* readdir */
  131         { &vop_readlink_desc, portal_readlink },        /* readlink */
  132         { &vop_abortop_desc, vop_generic_abortop },             /* abortop */
  133         { &vop_inactive_desc, portal_inactive },        /* inactive */
  134         { &vop_reclaim_desc, portal_reclaim },          /* reclaim */
  135         { &vop_lock_desc, portal_lock },                /* lock */
  136         { &vop_unlock_desc, portal_unlock },            /* unlock */
  137         { &vop_bmap_desc, portal_bmap },                /* bmap */
  138         { &vop_strategy_desc, portal_strategy },        /* strategy */
  139         { &vop_print_desc, portal_print },              /* print */
  140         { &vop_islocked_desc, portal_islocked },        /* islocked */
  141         { &vop_pathconf_desc, portal_pathconf },        /* pathconf */
  142         { &vop_advlock_desc, portal_advlock },          /* advlock */
  143         { &vop_bwrite_desc, portal_bwrite },            /* bwrite */
  144         { NULL, NULL }
  145 };
  146 struct vnodeopv_desc portal_vnodeop_opv_desc =
  147         { &portal_vnodeop_p, portal_vnodeop_entries };
  149 static void
portal_closefd(struct proc *p, int fd)
  151 {
  152         struct sys_close_args /* {
  153                 syscallarg(int) fd;
  154         } */ ua;
register_t retval[2];
  156         int error;
SCARG(&ua, fd) = fd;
error = sys_close(p, &ua, retval);
  160         /*
  161          * We should never get an error, and there isn't anything
  162          * we could do if we got one, so just print a message.
  163          */
  164         if (error)
printf("portal_closefd: error = %d\n", error);
  166 }
  168 /*
  169  * vp is the current namei directory
  170  * cnp is the name to locate in that directory...
  171  */
  172 int
portal_lookup(void *v)
  174 {
  175         struct vop_lookup_args *ap = v;
  176         struct componentname *cnp = ap->a_cnp;
  177         struct vnode **vpp = ap->a_vpp;
  178         struct vnode *dvp = ap->a_dvp;
  179         char *pname = cnp->cn_nameptr;
  180         struct proc *p = cnp->cn_proc;
  181         struct portalnode *pt;
  182         int error;
  183         struct vnode *fvp = 0;
  184         char *path;
  185         int size;
  187         *vpp = NULLVP;
  189         if (cnp->cn_nameiop == DELETE || cnp->cn_nameiop == RENAME)
  190                 return (EROFS);
  192         if (cnp->cn_namelen == 1 && *pname == '.') {
  193                 *vpp = dvp;
VREF(dvp);
  195                 return (0);
  196         }
error = getnewvnode(VT_PORTAL, dvp->v_mount, portal_vnodeop_p, &fvp);
  199         if (error)
  200                 goto bad;
fvp->v_type = VREG;
MALLOC(fvp->v_data, void *, sizeof(struct portalnode), M_TEMP,
M_WAITOK);
pt = VTOPORTAL(fvp);
  206         /*
  207          * Save all of the remaining pathname and
  208          * advance the namei next pointer to the end
  209          * of the string.
  210          */
  211         for (size = 0, path = pname; *path; path++)
size++;
cnp->cn_consume = size - cnp->cn_namelen;
pt->pt_arg = malloc(size+1, M_TEMP, M_WAITOK);
pt->pt_size = size+1;
bcopy(pname, pt->pt_arg, pt->pt_size);
pt->pt_fileid = portal_fileid++;
  220         *vpp = fvp;
VOP_LOCK(fvp, LK_EXCLUSIVE, p);
  222         /*
  223          * As we are the last component of the path name, fix up
  224          * the locking on the directory node.
  225          */
  226         if ((cnp->cn_flags & LOCKPARENT) == 0) {
VOP_UNLOCK(dvp, 0, p);
cnp->cn_flags |= PDIRUNLOCK;
  229         }
  230         return (0);
bad:;
  233         if (fvp)
vrele(fvp);
  235         return (error);
  236 }
  238 static int
portal_connect(struct socket *so, struct socket *so2)
  240 {
  241         /* from unp_connect, bypassing the namei stuff... */
  242         struct socket *so3;
  243         struct unpcb *unp2;
  244         struct unpcb *unp3;
  246         if (so2 == 0)
  247                 return (ECONNREFUSED);
  249         if (so->so_type != so2->so_type)
  250                 return (EPROTOTYPE);
  252         if ((so2->so_options & SO_ACCEPTCONN) == 0)
  253                 return (ECONNREFUSED);
  255         if ((so3 = sonewconn(so2, 0)) == 0)
  256                 return (ECONNREFUSED);
unp2 = sotounpcb(so2);
unp3 = sotounpcb(so3);
  260         if (unp2->unp_addr)
unp3->unp_addr = m_copy(unp2->unp_addr, 0, (int)M_COPYALL);
so2 = so3;
  266         return (unp_connect2(so, so2));
  267 }
  269 int
portal_open(void *v)
  271 {
  272         struct vop_open_args *ap = v;
  273         struct socket *so = 0;
  274         struct portalnode *pt;
  275         struct proc *p = ap->a_p;
  276         struct vnode *vp = ap->a_vp;
  277         int s;
  278         struct uio auio;
  279         struct iovec aiov[2];
  280         int res;
  281         struct mbuf *cm = 0;
  282         struct cmsghdr *cmsg;
  283         int newfds;
  284         int *ip;
  285         int fd;
  286         int error;
  287         int len;
  288         struct portalmount *fmp;
  289         struct file *fp;
  290         struct portal_cred pcred;
  292         /*
  293          * Nothing to do when opening the root node.
  294          */
  295         if (vp->v_flag & VROOT)
  296                 return (0);
  298         /*
  299          * Can't be opened unless the caller is set up
  300          * to deal with the side effects.  Check for this
  301          * by testing whether the p_dupfd has been set.
  302          */
  303         if (p->p_dupfd >= 0)
  304                 return (ENODEV);
pt = VTOPORTAL(vp);
fmp = VFSTOPORTAL(vp->v_mount);
  309         /*
  310          * Create a new socket.
  311          */
error = socreate(AF_UNIX, &so, SOCK_STREAM, 0);
  313         if (error)
  314                 goto bad;
  316         /*
  317          * Reserve some buffer space
  318          */
res = pt->pt_size + sizeof(pcred) + 512;        /* XXX */
error = soreserve(so, res, res);
  321         if (error)
  322                 goto bad;
  324         /*
  325          * Kick off connection
  326          */
s = splsoftnet();
error = portal_connect(so, (struct socket *)fmp->pm_server->f_data);
splx(s);
  330         if (error)
  331                 goto bad;
  333         /*
  334          * Wait for connection to complete
  335          */
  336         /*
  337          * XXX: Since the mount point is holding a reference on the
  338          * underlying server socket, it is not easy to find out whether
  339          * the server process is still running.  To handle this problem
  340          * we loop waiting for the new socket to be connected (something
  341          * which will only happen if the server is still running) or for
  342          * the reference count on the server socket to drop to 1, which
  343          * will happen if the server dies.  Sleep for 5 second intervals
  344          * and keep polling the reference count.   XXX.
  345          */
s = splsoftnet();
  347         while ((so->so_state & SS_ISCONNECTING) && so->so_error == 0) {
  348                 if (fmp->pm_server->f_count == 1) {
error = ECONNREFUSED;
splx(s);
  351                         goto bad;
  352                 }
  353                 (void) tsleep(&so->so_timeo, PSOCK, "portalcon", 5 * hz);
  354         }
splx(s);
  357         if (so->so_error) {
error = so->so_error;
  359                 goto bad;
  360         }
  362         /*
  363          * Set miscellaneous flags
  364          */
so->so_rcv.sb_timeo = 0;
so->so_snd.sb_timeo = 0;
so->so_rcv.sb_flags |= SB_NOINTR;
so->so_snd.sb_flags |= SB_NOINTR;
pcred.pcr_flag = ap->a_mode;
pcred.pcr_uid = ap->a_cred->cr_uid;
pcred.pcr_gid = ap->a_cred->cr_gid;
pcred.pcr_ngroups = ap->a_cred->cr_ngroups;
bcopy(ap->a_cred->cr_groups, pcred.pcr_groups, NGROUPS * sizeof(gid_t));
aiov[0].iov_base = &pcred;
aiov[0].iov_len = sizeof(pcred);
aiov[1].iov_base = pt->pt_arg;
aiov[1].iov_len = pt->pt_size;
auio.uio_iov = aiov;
auio.uio_iovcnt = 2;
auio.uio_rw = UIO_WRITE;
auio.uio_segflg = UIO_SYSSPACE;
auio.uio_procp = p;
auio.uio_offset = 0;
auio.uio_resid = aiov[0].iov_len + aiov[1].iov_len;
error = sosend(so, (struct mbuf *) 0, &auio,
  389                         (struct mbuf *) 0, (struct mbuf *) 0, 0);
  390         if (error)
  391                 goto bad;
len = auio.uio_resid = sizeof(int);
  394         do {
  395                 struct mbuf *m = 0;
  396                 int flags = MSG_WAITALL;
fdpunlock(p->p_fd);
error = soreceive(so, (struct mbuf **) 0, &auio,
  399                                         &m, &cm, &flags);
fdplock(p->p_fd);
  401                 if (error)
  402                         goto bad;
  404                 /*
  405                  * Grab an error code from the mbuf.
  406                  */
  407                 if (m) {
m = m_pullup(m, sizeof(int));   /* Needed? */
  409                         if (m) {
error = *(mtod(m, int *));
m_freem(m);
  412                         } else {
error = EINVAL;
  414                         }
  415                 } else {
  416                         if (cm == 0) {
error = ECONNRESET;      /* XXX */
  418 #ifdef notdef
  419                                 break;
  420 #endif
  421                         }
  422                 }
  423         } while (cm == 0 && auio.uio_resid == len && !error);
  425         if (cm == 0)
  426                 goto bad;
  428         if (auio.uio_resid) {
error = 0;
  430 #ifdef notdef
error = EMSGSIZE;
  432                 goto bad;
  433 #endif
  434         }
  436         /*
  437          * XXX: Break apart the control message, and retrieve the
  438          * received file descriptor.  Note that more than one descriptor
  439          * may have been received, or that the rights chain may have more
  440          * than a single mbuf in it.  What to do?
  441          */
cmsg = mtod(cm, struct cmsghdr *);
newfds = (cmsg->cmsg_len - sizeof(*cmsg)) / sizeof (int);
  444         if (newfds == 0) {
error = ECONNREFUSED;
  446                 goto bad;
  447         }
  448         /*
  449          * At this point the rights message consists of a control message
  450          * header, followed by a data region containing a vector of
  451          * integer file descriptors.  The fds were allocated by the action
  452          * of receiving the control message.
  453          */
ip = (int *)(cmsg + 1);
fd = *ip++;
  456         if (newfds > 1) {
  457                 /*
  458                  * Close extra fds.
  459                  */
  460                 int i;
printf("portal_open: %d extra fds\n", newfds - 1);
  462                 for (i = 1; i < newfds; i++) {
portal_closefd(p, *ip);
ip++;
  465                 }
  466         }
  468         /*
  469          * Check that the mode the file is being opened for is a subset 
  470          * of the mode of the existing descriptor.
  471          */
  472         if ((fp = fd_getfile(p->p_fd, fd)) == NULL) {
error = EBADF;
  474                 goto bad;
  475         }
  476         if (((ap->a_mode & (FREAD|FWRITE)) | fp->f_flag) != fp->f_flag) {
portal_closefd(p, fd);
error = EACCES;
  479                 goto bad;
  480         }
  482         /*
  483          * Save the dup fd in the proc structure then return the
  484          * special error code (ENXIO) which causes magic things to
  485          * happen in vn_open.  The whole concept is, well, hmmm.
  486          */
p->p_dupfd = fd;
error = ENXIO;
bad:;
  491         /*
  492          * And discard the control message.
  493          */
  494         if (cm) { 
m_freem(cm);
  496         }
  498         if (so) {
soshutdown(so, 2);
soclose(so);
  501         }
  502         return (error);
  503 }
  505 int
portal_getattr(void *v)
  507 {
  508         struct vop_getattr_args *ap = v;
  509         struct vnode *vp = ap->a_vp;
  510         struct vattr *vap = ap->a_vap;
bzero(vap, sizeof(*vap));
vattr_null(vap);
vap->va_uid = 0;
vap->va_gid = 0;
vap->va_fsid = vp->v_mount->mnt_stat.f_fsid.val[0];
vap->va_size = DEV_BSIZE;
vap->va_blocksize = DEV_BSIZE;
getnanotime(&vap->va_atime);
vap->va_mtime = vap->va_atime;
vap->va_ctime = vap->va_atime;
vap->va_gen = 0;
vap->va_flags = 0;
vap->va_rdev = 0;
  525         /* vap->va_qbytes = 0; */
vap->va_bytes = 0;
  527         /* vap->va_qsize = 0; */
  528         if (vp->v_flag & VROOT) {
vap->va_type = VDIR;
vap->va_mode = S_IRUSR|S_IWUSR|S_IXUSR|
S_IRGRP|S_IWGRP|S_IXGRP|
S_IROTH|S_IWOTH|S_IXOTH;
vap->va_nlink = 2;
vap->va_fileid = 2;
  535         } else {
vap->va_type = VREG;
vap->va_mode = S_IRUSR|S_IWUSR|
S_IRGRP|S_IWGRP|
S_IROTH|S_IWOTH;
vap->va_nlink = 1;
vap->va_fileid = VTOPORTAL(vp)->pt_fileid;
  542         }
  543         return (0);
  544 }
  546 int
portal_setattr(void *v)
  548 {
  549         struct vop_setattr_args *ap = v;
  551         /*
  552          * Can't mess with the root vnode
  553          */
  554         if (ap->a_vp->v_flag & VROOT)
  555                 return (EACCES);
  557         if (ap->a_vap->va_flags != VNOVAL)
  558                 return (EOPNOTSUPP);
  560         return (0);
  561 }
  563 /*
  564  * Fake readdir, just return empty directory.
  565  * It is hard to deal with '.' and '..' so don't bother.
  566  */
  567 /*ARGSUSED*/
  568 int
portal_readdir(void *v)
  570 {
  571         return (0);
  572 }
  574 /*ARGSUSED*/
  575 int
portal_inactive(void *v)
  577 {
  578         struct vop_inactive_args *ap = v;
VOP_UNLOCK(ap->a_vp, 0, ap->a_p);
  581         return (0);
  582 }
  584 int
portal_reclaim(void *v)
  586 {
  587         struct vop_reclaim_args *ap = v;
  588         struct portalnode *pt = VTOPORTAL(ap->a_vp);
  590         if (pt->pt_arg) {
free(pt->pt_arg, M_TEMP);
pt->pt_arg = 0;
  593         }
FREE(ap->a_vp->v_data, M_TEMP);
ap->a_vp->v_data = 0;
  597         return (0);
  598 }
  600 /*
  601  * Return POSIX pathconf information applicable to special devices.
  602  */
  603 int
portal_pathconf(void *v)
  605 {
  606         struct vop_pathconf_args *ap = v;
  608         switch (ap->a_name) {
  609         case _PC_LINK_MAX:
  610                 *ap->a_retval = LINK_MAX;
  611                 return (0);
  612         case _PC_MAX_CANON:
  613                 *ap->a_retval = MAX_CANON;
  614                 return (0);
  615         case _PC_MAX_INPUT:
  616                 *ap->a_retval = MAX_INPUT;
  617                 return (0);
  618         case _PC_PIPE_BUF:
  619                 *ap->a_retval = PIPE_BUF;
  620                 return (0);
  621         case _PC_CHOWN_RESTRICTED:
  622                 *ap->a_retval = 1;
  623                 return (0);
  624         case _PC_VDISABLE:
  625                 *ap->a_retval = _POSIX_VDISABLE;
  626                 return (0);
  627         default:
  628                 return (EINVAL);
  629         }
  630         /* NOTREACHED */
  631 }
  633 /*
  634  * Print out the contents of a Portal vnode.
  635  */
  636 /* ARGSUSED */
  637 int
portal_print(void *v)
  639 {
printf("tag VT_PORTAL, portal vnode\n");
  641         return (0);
  642 }
  644 int
portal_link(void *v) 
  646 {
  647         struct vop_link_args *ap = v;
VOP_ABORTOP(ap->a_dvp, ap->a_cnp);
vput(ap->a_dvp);
  651         return (EROFS);
  652 }
  654 int
portal_symlink(void *v)
  656 {
  657         struct vop_symlink_args *ap = v;
VOP_ABORTOP(ap->a_dvp, ap->a_cnp);
vput(ap->a_dvp);
  661         return (EROFS);
  662 }
  664 int
portal_badop(void *v)
  666 {
panic ("portal: bad op");
  668         return (0);
  669 }
  671 int
portal_poll(void *v)
  673 {
  674         struct vop_poll_args *ap = v;
  676         return (ap->a_events & (POLLIN | POLLOUT | POLLRDNORM | POLLWRNORM));
  677 }