The Design and Implementation of the FreeBSD Operating System, Second Edition
Now available: The Design and Implementation of the FreeBSD Operating System (Second Edition)


[ source navigation ] [ diff markup ] [ identifier search ] [ freetext search ] [ file search ] [ list types ] [ track identifier ]

FreeBSD/Linux Kernel Cross Reference
sys/fs/tmpfs/tmpfs_vnops.c

Version: -  FREEBSD  -  FREEBSD-13-STABLE  -  FREEBSD-13-0  -  FREEBSD-12-STABLE  -  FREEBSD-12-0  -  FREEBSD-11-STABLE  -  FREEBSD-11-0  -  FREEBSD-10-STABLE  -  FREEBSD-10-0  -  FREEBSD-9-STABLE  -  FREEBSD-9-0  -  FREEBSD-8-STABLE  -  FREEBSD-8-0  -  FREEBSD-7-STABLE  -  FREEBSD-7-0  -  FREEBSD-6-STABLE  -  FREEBSD-6-0  -  FREEBSD-5-STABLE  -  FREEBSD-5-0  -  FREEBSD-4-STABLE  -  FREEBSD-3-STABLE  -  FREEBSD22  -  l41  -  OPENBSD  -  linux-2.6  -  MK84  -  PLAN9  -  xnu-8792 
SearchContext: -  none  -  3  -  10 

    1 /*      $NetBSD: tmpfs_vnops.c,v 1.39 2007/07/23 15:41:01 jmmv Exp $    */
    2 
    3 /*-
    4  * Copyright (c) 2005, 2006 The NetBSD Foundation, Inc.
    5  * All rights reserved.
    6  *
    7  * This code is derived from software contributed to The NetBSD Foundation
    8  * by Julio M. Merino Vidal, developed as part of Google's Summer of Code
    9  * 2005 program.
   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  *
   20  * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
   21  * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
   22  * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
   23  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
   24  * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
   25  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
   26  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
   27  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
   28  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
   29  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
   30  * POSSIBILITY OF SUCH DAMAGE.
   31  */
   32 
   33 /*
   34  * tmpfs vnode interface.
   35  */
   36 #include <sys/cdefs.h>
   37 __FBSDID("$FreeBSD: releng/9.0/sys/fs/tmpfs/tmpfs_vnops.c 225418 2011-09-06 10:30:11Z kib $");
   38 
   39 #include <sys/param.h>
   40 #include <sys/fcntl.h>
   41 #include <sys/lockf.h>
   42 #include <sys/namei.h>
   43 #include <sys/priv.h>
   44 #include <sys/proc.h>
   45 #include <sys/sched.h>
   46 #include <sys/sf_buf.h>
   47 #include <sys/stat.h>
   48 #include <sys/systm.h>
   49 #include <sys/unistd.h>
   50 #include <sys/vnode.h>
   51 
   52 #include <vm/vm.h>
   53 #include <vm/vm_object.h>
   54 #include <vm/vm_page.h>
   55 #include <vm/vm_pager.h>
   56 
   57 #include <machine/_inttypes.h>
   58 
   59 #include <fs/fifofs/fifo.h>
   60 #include <fs/tmpfs/tmpfs_vnops.h>
   61 #include <fs/tmpfs/tmpfs.h>
   62 
   63 /* --------------------------------------------------------------------- */
   64 
   65 static int
   66 tmpfs_lookup(struct vop_cachedlookup_args *v)
   67 {
   68         struct vnode *dvp = v->a_dvp;
   69         struct vnode **vpp = v->a_vpp;
   70         struct componentname *cnp = v->a_cnp;
   71 
   72         int error;
   73         struct tmpfs_dirent *de;
   74         struct tmpfs_node *dnode;
   75 
   76         dnode = VP_TO_TMPFS_DIR(dvp);
   77         *vpp = NULLVP;
   78 
   79         /* Check accessibility of requested node as a first step. */
   80         error = VOP_ACCESS(dvp, VEXEC, cnp->cn_cred, cnp->cn_thread);
   81         if (error != 0)
   82                 goto out;
   83 
   84         /* We cannot be requesting the parent directory of the root node. */
   85         MPASS(IMPLIES(dnode->tn_type == VDIR &&
   86             dnode->tn_dir.tn_parent == dnode,
   87             !(cnp->cn_flags & ISDOTDOT)));
   88 
   89         TMPFS_ASSERT_LOCKED(dnode);
   90         if (dnode->tn_dir.tn_parent == NULL) {
   91                 error = ENOENT;
   92                 goto out;
   93         }
   94         if (cnp->cn_flags & ISDOTDOT) {
   95                 int ltype = 0;
   96 
   97                 ltype = VOP_ISLOCKED(dvp);
   98                 vhold(dvp);
   99                 VOP_UNLOCK(dvp, 0);
  100                 /* Allocate a new vnode on the matching entry. */
  101                 error = tmpfs_alloc_vp(dvp->v_mount, dnode->tn_dir.tn_parent,
  102                     cnp->cn_lkflags, vpp);
  103 
  104                 vn_lock(dvp, ltype | LK_RETRY);
  105                 vdrop(dvp);
  106         } else if (cnp->cn_namelen == 1 && cnp->cn_nameptr[0] == '.') {
  107                 VREF(dvp);
  108                 *vpp = dvp;
  109                 error = 0;
  110         } else {
  111                 de = tmpfs_dir_lookup(dnode, NULL, cnp);
  112                 if (de != NULL && de->td_node == NULL)
  113                         cnp->cn_flags |= ISWHITEOUT;
  114                 if (de == NULL || de->td_node == NULL) {
  115                         /* The entry was not found in the directory.
  116                          * This is OK if we are creating or renaming an
  117                          * entry and are working on the last component of
  118                          * the path name. */
  119                         if ((cnp->cn_flags & ISLASTCN) &&
  120                             (cnp->cn_nameiop == CREATE || \
  121                             cnp->cn_nameiop == RENAME ||
  122                             (cnp->cn_nameiop == DELETE &&
  123                             cnp->cn_flags & DOWHITEOUT &&
  124                             cnp->cn_flags & ISWHITEOUT))) {
  125                                 error = VOP_ACCESS(dvp, VWRITE, cnp->cn_cred,
  126                                     cnp->cn_thread);
  127                                 if (error != 0)
  128                                         goto out;
  129 
  130                                 /* Keep the component name in the buffer for
  131                                  * future uses. */
  132                                 cnp->cn_flags |= SAVENAME;
  133 
  134                                 error = EJUSTRETURN;
  135                         } else
  136                                 error = ENOENT;
  137                 } else {
  138                         struct tmpfs_node *tnode;
  139 
  140                         /* The entry was found, so get its associated
  141                          * tmpfs_node. */
  142                         tnode = de->td_node;
  143 
  144                         /* If we are not at the last path component and
  145                          * found a non-directory or non-link entry (which
  146                          * may itself be pointing to a directory), raise
  147                          * an error. */
  148                         if ((tnode->tn_type != VDIR &&
  149                             tnode->tn_type != VLNK) &&
  150                             !(cnp->cn_flags & ISLASTCN)) {
  151                                 error = ENOTDIR;
  152                                 goto out;
  153                         }
  154 
  155                         /* If we are deleting or renaming the entry, keep
  156                          * track of its tmpfs_dirent so that it can be
  157                          * easily deleted later. */
  158                         if ((cnp->cn_flags & ISLASTCN) &&
  159                             (cnp->cn_nameiop == DELETE ||
  160                             cnp->cn_nameiop == RENAME)) {
  161                                 error = VOP_ACCESS(dvp, VWRITE, cnp->cn_cred,
  162                                     cnp->cn_thread);
  163                                 if (error != 0)
  164                                         goto out;
  165 
  166                                 /* Allocate a new vnode on the matching entry. */
  167                                 error = tmpfs_alloc_vp(dvp->v_mount, tnode,
  168                                                 cnp->cn_lkflags, vpp);
  169                                 if (error != 0)
  170                                         goto out;
  171 
  172                                 if ((dnode->tn_mode & S_ISTXT) &&
  173                                   VOP_ACCESS(dvp, VADMIN, cnp->cn_cred, cnp->cn_thread) &&
  174                                   VOP_ACCESS(*vpp, VADMIN, cnp->cn_cred, cnp->cn_thread)) {
  175                                         error = EPERM;
  176                                         vput(*vpp);
  177                                         *vpp = NULL;
  178                                         goto out;
  179                                 }
  180                                 cnp->cn_flags |= SAVENAME;
  181                         } else {
  182                                 error = tmpfs_alloc_vp(dvp->v_mount, tnode,
  183                                                 cnp->cn_lkflags, vpp);
  184                         }
  185                 }
  186         }
  187 
  188         /* Store the result of this lookup in the cache.  Avoid this if the
  189          * request was for creation, as it does not improve timings on
  190          * emprical tests. */
  191         if ((cnp->cn_flags & MAKEENTRY) && cnp->cn_nameiop != CREATE)
  192                 cache_enter(dvp, *vpp, cnp);
  193 
  194 out:
  195         /* If there were no errors, *vpp cannot be null and it must be
  196          * locked. */
  197         MPASS(IFF(error == 0, *vpp != NULLVP && VOP_ISLOCKED(*vpp)));
  198 
  199         return error;
  200 }
  201 
  202 /* --------------------------------------------------------------------- */
  203 
  204 static int
  205 tmpfs_create(struct vop_create_args *v)
  206 {
  207         struct vnode *dvp = v->a_dvp;
  208         struct vnode **vpp = v->a_vpp;
  209         struct componentname *cnp = v->a_cnp;
  210         struct vattr *vap = v->a_vap;
  211 
  212         MPASS(vap->va_type == VREG || vap->va_type == VSOCK);
  213 
  214         return tmpfs_alloc_file(dvp, vpp, vap, cnp, NULL);
  215 }
  216 /* --------------------------------------------------------------------- */
  217 
  218 static int
  219 tmpfs_mknod(struct vop_mknod_args *v)
  220 {
  221         struct vnode *dvp = v->a_dvp;
  222         struct vnode **vpp = v->a_vpp;
  223         struct componentname *cnp = v->a_cnp;
  224         struct vattr *vap = v->a_vap;
  225 
  226         if (vap->va_type != VBLK && vap->va_type != VCHR &&
  227             vap->va_type != VFIFO)
  228                 return EINVAL;
  229 
  230         return tmpfs_alloc_file(dvp, vpp, vap, cnp, NULL);
  231 }
  232 
  233 /* --------------------------------------------------------------------- */
  234 
  235 static int
  236 tmpfs_open(struct vop_open_args *v)
  237 {
  238         struct vnode *vp = v->a_vp;
  239         int mode = v->a_mode;
  240 
  241         int error;
  242         struct tmpfs_node *node;
  243 
  244         MPASS(VOP_ISLOCKED(vp));
  245 
  246         node = VP_TO_TMPFS_NODE(vp);
  247 
  248         /* The file is still active but all its names have been removed
  249          * (e.g. by a "rmdir $(pwd)").  It cannot be opened any more as
  250          * it is about to die. */
  251         if (node->tn_links < 1)
  252                 return (ENOENT);
  253 
  254         /* If the file is marked append-only, deny write requests. */
  255         if (node->tn_flags & APPEND && (mode & (FWRITE | O_APPEND)) == FWRITE)
  256                 error = EPERM;
  257         else {
  258                 error = 0;
  259                 vnode_create_vobject(vp, node->tn_size, v->a_td);
  260         }
  261 
  262         MPASS(VOP_ISLOCKED(vp));
  263         return error;
  264 }
  265 
  266 /* --------------------------------------------------------------------- */
  267 
  268 static int
  269 tmpfs_close(struct vop_close_args *v)
  270 {
  271         struct vnode *vp = v->a_vp;
  272 
  273         MPASS(VOP_ISLOCKED(vp));
  274 
  275         /* Update node times. */
  276         tmpfs_update(vp);
  277 
  278         return (0);
  279 }
  280 
  281 /* --------------------------------------------------------------------- */
  282 
  283 int
  284 tmpfs_access(struct vop_access_args *v)
  285 {
  286         struct vnode *vp = v->a_vp;
  287         accmode_t accmode = v->a_accmode;
  288         struct ucred *cred = v->a_cred;
  289 
  290         int error;
  291         struct tmpfs_node *node;
  292 
  293         MPASS(VOP_ISLOCKED(vp));
  294 
  295         node = VP_TO_TMPFS_NODE(vp);
  296 
  297         switch (vp->v_type) {
  298         case VDIR:
  299                 /* FALLTHROUGH */
  300         case VLNK:
  301                 /* FALLTHROUGH */
  302         case VREG:
  303                 if (accmode & VWRITE && vp->v_mount->mnt_flag & MNT_RDONLY) {
  304                         error = EROFS;
  305                         goto out;
  306                 }
  307                 break;
  308 
  309         case VBLK:
  310                 /* FALLTHROUGH */
  311         case VCHR:
  312                 /* FALLTHROUGH */
  313         case VSOCK:
  314                 /* FALLTHROUGH */
  315         case VFIFO:
  316                 break;
  317 
  318         default:
  319                 error = EINVAL;
  320                 goto out;
  321         }
  322 
  323         if (accmode & VWRITE && node->tn_flags & IMMUTABLE) {
  324                 error = EPERM;
  325                 goto out;
  326         }
  327 
  328         error = vaccess(vp->v_type, node->tn_mode, node->tn_uid,
  329             node->tn_gid, accmode, cred, NULL);
  330 
  331 out:
  332         MPASS(VOP_ISLOCKED(vp));
  333 
  334         return error;
  335 }
  336 
  337 /* --------------------------------------------------------------------- */
  338 
  339 int
  340 tmpfs_getattr(struct vop_getattr_args *v)
  341 {
  342         struct vnode *vp = v->a_vp;
  343         struct vattr *vap = v->a_vap;
  344 
  345         struct tmpfs_node *node;
  346 
  347         node = VP_TO_TMPFS_NODE(vp);
  348 
  349         tmpfs_update(vp);
  350 
  351         vap->va_type = vp->v_type;
  352         vap->va_mode = node->tn_mode;
  353         vap->va_nlink = node->tn_links;
  354         vap->va_uid = node->tn_uid;
  355         vap->va_gid = node->tn_gid;
  356         vap->va_fsid = vp->v_mount->mnt_stat.f_fsid.val[0];
  357         vap->va_fileid = node->tn_id;
  358         vap->va_size = node->tn_size;
  359         vap->va_blocksize = PAGE_SIZE;
  360         vap->va_atime = node->tn_atime;
  361         vap->va_mtime = node->tn_mtime;
  362         vap->va_ctime = node->tn_ctime;
  363         vap->va_birthtime = node->tn_birthtime;
  364         vap->va_gen = node->tn_gen;
  365         vap->va_flags = node->tn_flags;
  366         vap->va_rdev = (vp->v_type == VBLK || vp->v_type == VCHR) ?
  367                 node->tn_rdev : NODEV;
  368         vap->va_bytes = round_page(node->tn_size);
  369         vap->va_filerev = 0;
  370 
  371         return 0;
  372 }
  373 
  374 /* --------------------------------------------------------------------- */
  375 
  376 /* XXX Should this operation be atomic?  I think it should, but code in
  377  * XXX other places (e.g., ufs) doesn't seem to be... */
  378 int
  379 tmpfs_setattr(struct vop_setattr_args *v)
  380 {
  381         struct vnode *vp = v->a_vp;
  382         struct vattr *vap = v->a_vap;
  383         struct ucred *cred = v->a_cred;
  384         struct thread *td = curthread;
  385 
  386         int error;
  387 
  388         MPASS(VOP_ISLOCKED(vp));
  389 
  390         error = 0;
  391 
  392         /* Abort if any unsettable attribute is given. */
  393         if (vap->va_type != VNON ||
  394             vap->va_nlink != VNOVAL ||
  395             vap->va_fsid != VNOVAL ||
  396             vap->va_fileid != VNOVAL ||
  397             vap->va_blocksize != VNOVAL ||
  398             vap->va_gen != VNOVAL ||
  399             vap->va_rdev != VNOVAL ||
  400             vap->va_bytes != VNOVAL)
  401                 error = EINVAL;
  402 
  403         if (error == 0 && (vap->va_flags != VNOVAL))
  404                 error = tmpfs_chflags(vp, vap->va_flags, cred, td);
  405 
  406         if (error == 0 && (vap->va_size != VNOVAL))
  407                 error = tmpfs_chsize(vp, vap->va_size, cred, td);
  408 
  409         if (error == 0 && (vap->va_uid != VNOVAL || vap->va_gid != VNOVAL))
  410                 error = tmpfs_chown(vp, vap->va_uid, vap->va_gid, cred, td);
  411 
  412         if (error == 0 && (vap->va_mode != (mode_t)VNOVAL))
  413                 error = tmpfs_chmod(vp, vap->va_mode, cred, td);
  414 
  415         if (error == 0 && ((vap->va_atime.tv_sec != VNOVAL &&
  416             vap->va_atime.tv_nsec != VNOVAL) ||
  417             (vap->va_mtime.tv_sec != VNOVAL &&
  418             vap->va_mtime.tv_nsec != VNOVAL) ||
  419             (vap->va_birthtime.tv_sec != VNOVAL &&
  420             vap->va_birthtime.tv_nsec != VNOVAL)))
  421                 error = tmpfs_chtimes(vp, &vap->va_atime, &vap->va_mtime,
  422                         &vap->va_birthtime, vap->va_vaflags, cred, td);
  423 
  424         /* Update the node times.  We give preference to the error codes
  425          * generated by this function rather than the ones that may arise
  426          * from tmpfs_update. */
  427         tmpfs_update(vp);
  428 
  429         MPASS(VOP_ISLOCKED(vp));
  430 
  431         return error;
  432 }
  433 
  434 /* --------------------------------------------------------------------- */
  435 static int
  436 tmpfs_nocacheread(vm_object_t tobj, vm_pindex_t idx,
  437     vm_offset_t offset, size_t tlen, struct uio *uio)
  438 {
  439         vm_page_t       m;
  440         int             error;
  441 
  442         VM_OBJECT_LOCK(tobj);
  443         vm_object_pip_add(tobj, 1);
  444         m = vm_page_grab(tobj, idx, VM_ALLOC_WIRED |
  445             VM_ALLOC_ZERO | VM_ALLOC_NORMAL | VM_ALLOC_RETRY);
  446         if (m->valid != VM_PAGE_BITS_ALL) {
  447                 if (vm_pager_has_page(tobj, idx, NULL, NULL)) {
  448                         error = vm_pager_get_pages(tobj, &m, 1, 0);
  449                         if (error != 0) {
  450                                 printf("tmpfs get pages from pager error [read]\n");
  451                                 goto out;
  452                         }
  453                 } else
  454                         vm_page_zero_invalid(m, TRUE);
  455         }
  456         VM_OBJECT_UNLOCK(tobj);
  457         error = uiomove_fromphys(&m, offset, tlen, uio);
  458         VM_OBJECT_LOCK(tobj);
  459 out:
  460         vm_page_lock(m);
  461         vm_page_unwire(m, TRUE);
  462         vm_page_unlock(m);
  463         vm_page_wakeup(m);
  464         vm_object_pip_subtract(tobj, 1);
  465         VM_OBJECT_UNLOCK(tobj);
  466 
  467         return (error);
  468 }
  469 
  470 static __inline int
  471 tmpfs_nocacheread_buf(vm_object_t tobj, vm_pindex_t idx,
  472     vm_offset_t offset, size_t tlen, void *buf)
  473 {
  474         struct uio uio;
  475         struct iovec iov;
  476 
  477         uio.uio_iovcnt = 1;
  478         uio.uio_iov = &iov;
  479         iov.iov_base = buf;
  480         iov.iov_len = tlen;
  481 
  482         uio.uio_offset = 0;
  483         uio.uio_resid = tlen;
  484         uio.uio_rw = UIO_READ;
  485         uio.uio_segflg = UIO_SYSSPACE;
  486         uio.uio_td = curthread;
  487 
  488         return (tmpfs_nocacheread(tobj, idx, offset, tlen, &uio));
  489 }
  490 
  491 static int
  492 tmpfs_mappedread(vm_object_t vobj, vm_object_t tobj, size_t len, struct uio *uio)
  493 {
  494         struct sf_buf   *sf;
  495         vm_pindex_t     idx;
  496         vm_page_t       m;
  497         vm_offset_t     offset;
  498         off_t           addr;
  499         size_t          tlen;
  500         char            *ma;
  501         int             error;
  502 
  503         addr = uio->uio_offset;
  504         idx = OFF_TO_IDX(addr);
  505         offset = addr & PAGE_MASK;
  506         tlen = MIN(PAGE_SIZE - offset, len);
  507 
  508         if ((vobj == NULL) ||
  509             (vobj->resident_page_count == 0 && vobj->cache == NULL))
  510                 goto nocache;
  511 
  512         VM_OBJECT_LOCK(vobj);
  513 lookupvpg:
  514         if (((m = vm_page_lookup(vobj, idx)) != NULL) &&
  515             vm_page_is_valid(m, offset, tlen)) {
  516                 if ((m->oflags & VPO_BUSY) != 0) {
  517                         /*
  518                          * Reference the page before unlocking and sleeping so
  519                          * that the page daemon is less likely to reclaim it.  
  520                          */
  521                         vm_page_reference(m);
  522                         vm_page_sleep(m, "tmfsmr");
  523                         goto lookupvpg;
  524                 }
  525                 vm_page_busy(m);
  526                 VM_OBJECT_UNLOCK(vobj);
  527                 error = uiomove_fromphys(&m, offset, tlen, uio);
  528                 VM_OBJECT_LOCK(vobj);
  529                 vm_page_wakeup(m);
  530                 VM_OBJECT_UNLOCK(vobj);
  531                 return  (error);
  532         } else if (m != NULL && uio->uio_segflg == UIO_NOCOPY) {
  533                 KASSERT(offset == 0,
  534                     ("unexpected offset in tmpfs_mappedread for sendfile"));
  535                 if ((m->oflags & VPO_BUSY) != 0) {
  536                         /*
  537                          * Reference the page before unlocking and sleeping so
  538                          * that the page daemon is less likely to reclaim it.  
  539                          */
  540                         vm_page_reference(m);
  541                         vm_page_sleep(m, "tmfsmr");
  542                         goto lookupvpg;
  543                 }
  544                 vm_page_busy(m);
  545                 VM_OBJECT_UNLOCK(vobj);
  546                 sched_pin();
  547                 sf = sf_buf_alloc(m, SFB_CPUPRIVATE);
  548                 ma = (char *)sf_buf_kva(sf);
  549                 error = tmpfs_nocacheread_buf(tobj, idx, 0, tlen, ma);
  550                 if (error == 0) {
  551                         if (tlen != PAGE_SIZE)
  552                                 bzero(ma + tlen, PAGE_SIZE - tlen);
  553                         uio->uio_offset += tlen;
  554                         uio->uio_resid -= tlen;
  555                 }
  556                 sf_buf_free(sf);
  557                 sched_unpin();
  558                 VM_OBJECT_LOCK(vobj);
  559                 if (error == 0)
  560                         m->valid = VM_PAGE_BITS_ALL;
  561                 vm_page_wakeup(m);
  562                 VM_OBJECT_UNLOCK(vobj);
  563                 return  (error);
  564         }
  565         VM_OBJECT_UNLOCK(vobj);
  566 nocache:
  567         error = tmpfs_nocacheread(tobj, idx, offset, tlen, uio);
  568 
  569         return  (error);
  570 }
  571 
  572 static int
  573 tmpfs_read(struct vop_read_args *v)
  574 {
  575         struct vnode *vp = v->a_vp;
  576         struct uio *uio = v->a_uio;
  577 
  578         struct tmpfs_node *node;
  579         vm_object_t uobj;
  580         size_t len;
  581         int resid;
  582 
  583         int error = 0;
  584 
  585         node = VP_TO_TMPFS_NODE(vp);
  586 
  587         if (vp->v_type != VREG) {
  588                 error = EISDIR;
  589                 goto out;
  590         }
  591 
  592         if (uio->uio_offset < 0) {
  593                 error = EINVAL;
  594                 goto out;
  595         }
  596 
  597         node->tn_status |= TMPFS_NODE_ACCESSED;
  598 
  599         uobj = node->tn_reg.tn_aobj;
  600         while ((resid = uio->uio_resid) > 0) {
  601                 error = 0;
  602                 if (node->tn_size <= uio->uio_offset)
  603                         break;
  604                 len = MIN(node->tn_size - uio->uio_offset, resid);
  605                 if (len == 0)
  606                         break;
  607                 error = tmpfs_mappedread(vp->v_object, uobj, len, uio);
  608                 if ((error != 0) || (resid == uio->uio_resid))
  609                         break;
  610         }
  611 
  612 out:
  613 
  614         return error;
  615 }
  616 
  617 /* --------------------------------------------------------------------- */
  618 
  619 static int
  620 tmpfs_mappedwrite(vm_object_t vobj, vm_object_t tobj, size_t len, struct uio *uio)
  621 {
  622         vm_pindex_t     idx;
  623         vm_page_t       vpg, tpg;
  624         vm_offset_t     offset;
  625         off_t           addr;
  626         size_t          tlen;
  627         int             error;
  628 
  629         error = 0;
  630         
  631         addr = uio->uio_offset;
  632         idx = OFF_TO_IDX(addr);
  633         offset = addr & PAGE_MASK;
  634         tlen = MIN(PAGE_SIZE - offset, len);
  635 
  636         if ((vobj == NULL) ||
  637             (vobj->resident_page_count == 0 && vobj->cache == NULL)) {
  638                 vpg = NULL;
  639                 goto nocache;
  640         }
  641 
  642         VM_OBJECT_LOCK(vobj);
  643 lookupvpg:
  644         if (((vpg = vm_page_lookup(vobj, idx)) != NULL) &&
  645             vm_page_is_valid(vpg, offset, tlen)) {
  646                 if ((vpg->oflags & VPO_BUSY) != 0) {
  647                         /*
  648                          * Reference the page before unlocking and sleeping so
  649                          * that the page daemon is less likely to reclaim it.  
  650                          */
  651                         vm_page_reference(vpg);
  652                         vm_page_sleep(vpg, "tmfsmw");
  653                         goto lookupvpg;
  654                 }
  655                 vm_page_busy(vpg);
  656                 vm_page_undirty(vpg);
  657                 VM_OBJECT_UNLOCK(vobj);
  658                 error = uiomove_fromphys(&vpg, offset, tlen, uio);
  659         } else {
  660                 if (__predict_false(vobj->cache != NULL))
  661                         vm_page_cache_free(vobj, idx, idx + 1);
  662                 VM_OBJECT_UNLOCK(vobj);
  663                 vpg = NULL;
  664         }
  665 nocache:
  666         VM_OBJECT_LOCK(tobj);
  667         vm_object_pip_add(tobj, 1);
  668         tpg = vm_page_grab(tobj, idx, VM_ALLOC_WIRED |
  669             VM_ALLOC_ZERO | VM_ALLOC_NORMAL | VM_ALLOC_RETRY);
  670         if (tpg->valid != VM_PAGE_BITS_ALL) {
  671                 if (vm_pager_has_page(tobj, idx, NULL, NULL)) {
  672                         error = vm_pager_get_pages(tobj, &tpg, 1, 0);
  673                         if (error != 0) {
  674                                 printf("tmpfs get pages from pager error [write]\n");
  675                                 goto out;
  676                         }
  677                 } else
  678                         vm_page_zero_invalid(tpg, TRUE);
  679         }
  680         VM_OBJECT_UNLOCK(tobj);
  681         if (vpg == NULL)
  682                 error = uiomove_fromphys(&tpg, offset, tlen, uio);
  683         else {
  684                 KASSERT(vpg->valid == VM_PAGE_BITS_ALL, ("parts of vpg invalid"));
  685                 pmap_copy_page(vpg, tpg);
  686         }
  687         VM_OBJECT_LOCK(tobj);
  688 out:
  689         if (vobj != NULL)
  690                 VM_OBJECT_LOCK(vobj);
  691         if (error == 0) {
  692                 KASSERT(tpg->valid == VM_PAGE_BITS_ALL,
  693                     ("parts of tpg invalid"));
  694                 vm_page_dirty(tpg);
  695         }
  696         vm_page_lock(tpg);
  697         vm_page_unwire(tpg, TRUE);
  698         vm_page_unlock(tpg);
  699         vm_page_wakeup(tpg);
  700         if (vpg != NULL)
  701                 vm_page_wakeup(vpg);
  702         if (vobj != NULL)
  703                 VM_OBJECT_UNLOCK(vobj);
  704         vm_object_pip_subtract(tobj, 1);
  705         VM_OBJECT_UNLOCK(tobj);
  706 
  707         return  (error);
  708 }
  709 
  710 static int
  711 tmpfs_write(struct vop_write_args *v)
  712 {
  713         struct vnode *vp = v->a_vp;
  714         struct uio *uio = v->a_uio;
  715         int ioflag = v->a_ioflag;
  716 
  717         boolean_t extended;
  718         int error = 0;
  719         off_t oldsize;
  720         struct tmpfs_node *node;
  721         vm_object_t uobj;
  722         size_t len;
  723         int resid;
  724 
  725         node = VP_TO_TMPFS_NODE(vp);
  726         oldsize = node->tn_size;
  727 
  728         if (uio->uio_offset < 0 || vp->v_type != VREG) {
  729                 error = EINVAL;
  730                 goto out;
  731         }
  732 
  733         if (uio->uio_resid == 0) {
  734                 error = 0;
  735                 goto out;
  736         }
  737 
  738         if (ioflag & IO_APPEND)
  739                 uio->uio_offset = node->tn_size;
  740 
  741         if (uio->uio_offset + uio->uio_resid >
  742           VFS_TO_TMPFS(vp->v_mount)->tm_maxfilesize)
  743                 return (EFBIG);
  744 
  745         if (vn_rlimit_fsize(vp, uio, uio->uio_td))
  746                 return (EFBIG);
  747 
  748         extended = uio->uio_offset + uio->uio_resid > node->tn_size;
  749         if (extended) {
  750                 error = tmpfs_reg_resize(vp, uio->uio_offset + uio->uio_resid);
  751                 if (error != 0)
  752                         goto out;
  753         }
  754 
  755         uobj = node->tn_reg.tn_aobj;
  756         while ((resid = uio->uio_resid) > 0) {
  757                 if (node->tn_size <= uio->uio_offset)
  758                         break;
  759                 len = MIN(node->tn_size - uio->uio_offset, resid);
  760                 if (len == 0)
  761                         break;
  762                 error = tmpfs_mappedwrite(vp->v_object, uobj, len, uio);
  763                 if ((error != 0) || (resid == uio->uio_resid))
  764                         break;
  765         }
  766 
  767         node->tn_status |= TMPFS_NODE_ACCESSED | TMPFS_NODE_MODIFIED |
  768             (extended ? TMPFS_NODE_CHANGED : 0);
  769 
  770         if (node->tn_mode & (S_ISUID | S_ISGID)) {
  771                 if (priv_check_cred(v->a_cred, PRIV_VFS_RETAINSUGID, 0))
  772                         node->tn_mode &= ~(S_ISUID | S_ISGID);
  773         }
  774 
  775         if (error != 0)
  776                 (void)tmpfs_reg_resize(vp, oldsize);
  777 
  778 out:
  779         MPASS(IMPLIES(error == 0, uio->uio_resid == 0));
  780         MPASS(IMPLIES(error != 0, oldsize == node->tn_size));
  781 
  782         return error;
  783 }
  784 
  785 /* --------------------------------------------------------------------- */
  786 
  787 static int
  788 tmpfs_fsync(struct vop_fsync_args *v)
  789 {
  790         struct vnode *vp = v->a_vp;
  791 
  792         MPASS(VOP_ISLOCKED(vp));
  793 
  794         tmpfs_update(vp);
  795 
  796         return 0;
  797 }
  798 
  799 /* --------------------------------------------------------------------- */
  800 
  801 static int
  802 tmpfs_remove(struct vop_remove_args *v)
  803 {
  804         struct vnode *dvp = v->a_dvp;
  805         struct vnode *vp = v->a_vp;
  806 
  807         int error;
  808         struct tmpfs_dirent *de;
  809         struct tmpfs_mount *tmp;
  810         struct tmpfs_node *dnode;
  811         struct tmpfs_node *node;
  812 
  813         MPASS(VOP_ISLOCKED(dvp));
  814         MPASS(VOP_ISLOCKED(vp));
  815 
  816         if (vp->v_type == VDIR) {
  817                 error = EISDIR;
  818                 goto out;
  819         }
  820 
  821         dnode = VP_TO_TMPFS_DIR(dvp);
  822         node = VP_TO_TMPFS_NODE(vp);
  823         tmp = VFS_TO_TMPFS(vp->v_mount);
  824         de = tmpfs_dir_lookup(dnode, node, v->a_cnp);
  825         MPASS(de != NULL);
  826 
  827         /* Files marked as immutable or append-only cannot be deleted. */
  828         if ((node->tn_flags & (IMMUTABLE | APPEND | NOUNLINK)) ||
  829             (dnode->tn_flags & APPEND)) {
  830                 error = EPERM;
  831                 goto out;
  832         }
  833 
  834         /* Remove the entry from the directory; as it is a file, we do not
  835          * have to change the number of hard links of the directory. */
  836         tmpfs_dir_detach(dvp, de);
  837         if (v->a_cnp->cn_flags & DOWHITEOUT)
  838                 tmpfs_dir_whiteout_add(dvp, v->a_cnp);
  839 
  840         /* Free the directory entry we just deleted.  Note that the node
  841          * referred by it will not be removed until the vnode is really
  842          * reclaimed. */
  843         tmpfs_free_dirent(tmp, de, TRUE);
  844 
  845         node->tn_status |= TMPFS_NODE_ACCESSED | TMPFS_NODE_CHANGED;
  846         error = 0;
  847 
  848 out:
  849 
  850         return error;
  851 }
  852 
  853 /* --------------------------------------------------------------------- */
  854 
  855 static int
  856 tmpfs_link(struct vop_link_args *v)
  857 {
  858         struct vnode *dvp = v->a_tdvp;
  859         struct vnode *vp = v->a_vp;
  860         struct componentname *cnp = v->a_cnp;
  861 
  862         int error;
  863         struct tmpfs_dirent *de;
  864         struct tmpfs_node *node;
  865 
  866         MPASS(VOP_ISLOCKED(dvp));
  867         MPASS(cnp->cn_flags & HASBUF);
  868         MPASS(dvp != vp); /* XXX When can this be false? */
  869 
  870         node = VP_TO_TMPFS_NODE(vp);
  871 
  872         /* XXX: Why aren't the following two tests done by the caller? */
  873 
  874         /* Hard links of directories are forbidden. */
  875         if (vp->v_type == VDIR) {
  876                 error = EPERM;
  877                 goto out;
  878         }
  879 
  880         /* Cannot create cross-device links. */
  881         if (dvp->v_mount != vp->v_mount) {
  882                 error = EXDEV;
  883                 goto out;
  884         }
  885 
  886         /* Ensure that we do not overflow the maximum number of links imposed
  887          * by the system. */
  888         MPASS(node->tn_links <= LINK_MAX);
  889         if (node->tn_links == LINK_MAX) {
  890                 error = EMLINK;
  891                 goto out;
  892         }
  893 
  894         /* We cannot create links of files marked immutable or append-only. */
  895         if (node->tn_flags & (IMMUTABLE | APPEND)) {
  896                 error = EPERM;
  897                 goto out;
  898         }
  899 
  900         /* Allocate a new directory entry to represent the node. */
  901         error = tmpfs_alloc_dirent(VFS_TO_TMPFS(vp->v_mount), node,
  902             cnp->cn_nameptr, cnp->cn_namelen, &de);
  903         if (error != 0)
  904                 goto out;
  905 
  906         /* Insert the new directory entry into the appropriate directory. */
  907         if (cnp->cn_flags & ISWHITEOUT)
  908                 tmpfs_dir_whiteout_remove(dvp, cnp);
  909         tmpfs_dir_attach(dvp, de);
  910 
  911         /* vp link count has changed, so update node times. */
  912         node->tn_status |= TMPFS_NODE_CHANGED;
  913         tmpfs_update(vp);
  914 
  915         error = 0;
  916 
  917 out:
  918         return error;
  919 }
  920 
  921 /* --------------------------------------------------------------------- */
  922 
  923 static int
  924 tmpfs_rename(struct vop_rename_args *v)
  925 {
  926         struct vnode *fdvp = v->a_fdvp;
  927         struct vnode *fvp = v->a_fvp;
  928         struct componentname *fcnp = v->a_fcnp;
  929         struct vnode *tdvp = v->a_tdvp;
  930         struct vnode *tvp = v->a_tvp;
  931         struct componentname *tcnp = v->a_tcnp;
  932 
  933         char *newname;
  934         int error;
  935         struct tmpfs_dirent *de;
  936         struct tmpfs_mount *tmp;
  937         struct tmpfs_node *fdnode;
  938         struct tmpfs_node *fnode;
  939         struct tmpfs_node *tnode;
  940         struct tmpfs_node *tdnode;
  941 
  942         MPASS(VOP_ISLOCKED(tdvp));
  943         MPASS(IMPLIES(tvp != NULL, VOP_ISLOCKED(tvp)));
  944         MPASS(fcnp->cn_flags & HASBUF);
  945         MPASS(tcnp->cn_flags & HASBUF);
  946 
  947         tnode = (tvp == NULL) ? NULL : VP_TO_TMPFS_NODE(tvp);
  948 
  949         /* Disallow cross-device renames.
  950          * XXX Why isn't this done by the caller? */
  951         if (fvp->v_mount != tdvp->v_mount ||
  952             (tvp != NULL && fvp->v_mount != tvp->v_mount)) {
  953                 error = EXDEV;
  954                 goto out;
  955         }
  956 
  957         tmp = VFS_TO_TMPFS(tdvp->v_mount);
  958         tdnode = VP_TO_TMPFS_DIR(tdvp);
  959 
  960         /* If source and target are the same file, there is nothing to do. */
  961         if (fvp == tvp) {
  962                 error = 0;
  963                 goto out;
  964         }
  965 
  966         /* If we need to move the directory between entries, lock the
  967          * source so that we can safely operate on it. */
  968         if (tdvp != fdvp) {
  969                 error = vn_lock(fdvp, LK_EXCLUSIVE | LK_RETRY);
  970                 if (error != 0)
  971                         goto out;
  972         }
  973         fdnode = VP_TO_TMPFS_DIR(fdvp);
  974         fnode = VP_TO_TMPFS_NODE(fvp);
  975         de = tmpfs_dir_lookup(fdnode, fnode, fcnp);
  976 
  977         /* Entry can disappear before we lock fdvp,
  978          * also avoid manipulating '.' and '..' entries. */
  979         if (de == NULL) {
  980                 if ((fcnp->cn_flags & ISDOTDOT) != 0 ||
  981                     (fcnp->cn_namelen == 1 && fcnp->cn_nameptr[0] == '.'))
  982                         error = EINVAL;
  983                 else
  984                         error = ENOENT;
  985                 goto out_locked;
  986         }
  987         MPASS(de->td_node == fnode);
  988 
  989         /* If re-naming a directory to another preexisting directory
  990          * ensure that the target directory is empty so that its
  991          * removal causes no side effects.
  992          * Kern_rename gurantees the destination to be a directory
  993          * if the source is one. */
  994         if (tvp != NULL) {
  995                 MPASS(tnode != NULL);
  996 
  997                 if ((tnode->tn_flags & (NOUNLINK | IMMUTABLE | APPEND)) ||
  998                     (tdnode->tn_flags & (APPEND | IMMUTABLE))) {
  999                         error = EPERM;
 1000                         goto out_locked;
 1001                 }
 1002 
 1003                 if (fnode->tn_type == VDIR && tnode->tn_type == VDIR) {
 1004                         if (tnode->tn_size > 0) {
 1005                                 error = ENOTEMPTY;
 1006                                 goto out_locked;
 1007                         }
 1008                 } else if (fnode->tn_type == VDIR && tnode->tn_type != VDIR) {
 1009                         error = ENOTDIR;
 1010                         goto out_locked;
 1011                 } else if (fnode->tn_type != VDIR && tnode->tn_type == VDIR) {
 1012                         error = EISDIR;
 1013                         goto out_locked;
 1014                 } else {
 1015                         MPASS(fnode->tn_type != VDIR &&
 1016                                 tnode->tn_type != VDIR);
 1017                 }
 1018         }
 1019 
 1020         if ((fnode->tn_flags & (NOUNLINK | IMMUTABLE | APPEND))
 1021             || (fdnode->tn_flags & (APPEND | IMMUTABLE))) {
 1022                 error = EPERM;
 1023                 goto out_locked;
 1024         }
 1025 
 1026         /* Ensure that we have enough memory to hold the new name, if it
 1027          * has to be changed. */
 1028         if (fcnp->cn_namelen != tcnp->cn_namelen ||
 1029             bcmp(fcnp->cn_nameptr, tcnp->cn_nameptr, fcnp->cn_namelen) != 0) {
 1030                 newname = malloc(tcnp->cn_namelen, M_TMPFSNAME, M_WAITOK);
 1031         } else
 1032                 newname = NULL;
 1033 
 1034         /* If the node is being moved to another directory, we have to do
 1035          * the move. */
 1036         if (fdnode != tdnode) {
 1037                 /* In case we are moving a directory, we have to adjust its
 1038                  * parent to point to the new parent. */
 1039                 if (de->td_node->tn_type == VDIR) {
 1040                         struct tmpfs_node *n;
 1041 
 1042                         /* Ensure the target directory is not a child of the
 1043                          * directory being moved.  Otherwise, we'd end up
 1044                          * with stale nodes. */
 1045                         n = tdnode;
 1046                         /* TMPFS_LOCK garanties that no nodes are freed while
 1047                          * traversing the list. Nodes can only be marked as
 1048                          * removed: tn_parent == NULL. */
 1049                         TMPFS_LOCK(tmp);
 1050                         TMPFS_NODE_LOCK(n);
 1051                         while (n != n->tn_dir.tn_parent) {
 1052                                 struct tmpfs_node *parent;
 1053 
 1054                                 if (n == fnode) {
 1055                                         TMPFS_NODE_UNLOCK(n);
 1056                                         TMPFS_UNLOCK(tmp);
 1057                                         error = EINVAL;
 1058                                         if (newname != NULL)
 1059                                                     free(newname, M_TMPFSNAME);
 1060                                         goto out_locked;
 1061                                 }
 1062                                 parent = n->tn_dir.tn_parent;
 1063                                 TMPFS_NODE_UNLOCK(n);
 1064                                 if (parent == NULL) {
 1065                                         n = NULL;
 1066                                         break;
 1067                                 }
 1068                                 TMPFS_NODE_LOCK(parent);
 1069                                 if (parent->tn_dir.tn_parent == NULL) {
 1070                                         TMPFS_NODE_UNLOCK(parent);
 1071                                         n = NULL;
 1072                                         break;
 1073                                 }
 1074                                 n = parent;
 1075                         }
 1076                         TMPFS_UNLOCK(tmp);
 1077                         if (n == NULL) {
 1078                                 error = EINVAL;
 1079                                 if (newname != NULL)
 1080                                             free(newname, M_TMPFSNAME);
 1081                                 goto out_locked;
 1082                         }
 1083                         TMPFS_NODE_UNLOCK(n);
 1084 
 1085                         /* Adjust the parent pointer. */
 1086                         TMPFS_VALIDATE_DIR(fnode);
 1087                         TMPFS_NODE_LOCK(de->td_node);
 1088                         de->td_node->tn_dir.tn_parent = tdnode;
 1089                         TMPFS_NODE_UNLOCK(de->td_node);
 1090 
 1091                         /* As a result of changing the target of the '..'
 1092                          * entry, the link count of the source and target
 1093                          * directories has to be adjusted. */
 1094                         TMPFS_NODE_LOCK(tdnode);
 1095                         TMPFS_ASSERT_LOCKED(tdnode);
 1096                         tdnode->tn_links++;
 1097                         TMPFS_NODE_UNLOCK(tdnode);
 1098 
 1099                         TMPFS_NODE_LOCK(fdnode);
 1100                         TMPFS_ASSERT_LOCKED(fdnode);
 1101                         fdnode->tn_links--;
 1102                         TMPFS_NODE_UNLOCK(fdnode);
 1103                 }
 1104 
 1105                 /* Do the move: just remove the entry from the source directory
 1106                  * and insert it into the target one. */
 1107                 tmpfs_dir_detach(fdvp, de);
 1108                 if (fcnp->cn_flags & DOWHITEOUT)
 1109                         tmpfs_dir_whiteout_add(fdvp, fcnp);
 1110                 if (tcnp->cn_flags & ISWHITEOUT)
 1111                         tmpfs_dir_whiteout_remove(tdvp, tcnp);
 1112                 tmpfs_dir_attach(tdvp, de);
 1113         }
 1114 
 1115         /* If the name has changed, we need to make it effective by changing
 1116          * it in the directory entry. */
 1117         if (newname != NULL) {
 1118                 MPASS(tcnp->cn_namelen <= MAXNAMLEN);
 1119 
 1120                 free(de->td_name, M_TMPFSNAME);
 1121                 de->td_namelen = (uint16_t)tcnp->cn_namelen;
 1122                 memcpy(newname, tcnp->cn_nameptr, tcnp->cn_namelen);
 1123                 de->td_name = newname;
 1124 
 1125                 fnode->tn_status |= TMPFS_NODE_CHANGED;
 1126                 tdnode->tn_status |= TMPFS_NODE_MODIFIED;
 1127         }
 1128 
 1129         /* If we are overwriting an entry, we have to remove the old one
 1130          * from the target directory. */
 1131         if (tvp != NULL) {
 1132                 /* Remove the old entry from the target directory. */
 1133                 de = tmpfs_dir_lookup(tdnode, tnode, tcnp);
 1134                 tmpfs_dir_detach(tdvp, de);
 1135 
 1136                 /* Free the directory entry we just deleted.  Note that the
 1137                  * node referred by it will not be removed until the vnode is
 1138                  * really reclaimed. */
 1139                 tmpfs_free_dirent(VFS_TO_TMPFS(tvp->v_mount), de, TRUE);
 1140         }
 1141 
 1142         error = 0;
 1143 
 1144 out_locked:
 1145         if (fdnode != tdnode)
 1146                 VOP_UNLOCK(fdvp, 0);
 1147 
 1148 out:
 1149         /* Release target nodes. */
 1150         /* XXX: I don't understand when tdvp can be the same as tvp, but
 1151          * other code takes care of this... */
 1152         if (tdvp == tvp)
 1153                 vrele(tdvp);
 1154         else
 1155                 vput(tdvp);
 1156         if (tvp != NULL)
 1157                 vput(tvp);
 1158 
 1159         /* Release source nodes. */
 1160         vrele(fdvp);
 1161         vrele(fvp);
 1162 
 1163         return error;
 1164 }
 1165 
 1166 /* --------------------------------------------------------------------- */
 1167 
 1168 static int
 1169 tmpfs_mkdir(struct vop_mkdir_args *v)
 1170 {
 1171         struct vnode *dvp = v->a_dvp;
 1172         struct vnode **vpp = v->a_vpp;
 1173         struct componentname *cnp = v->a_cnp;
 1174         struct vattr *vap = v->a_vap;
 1175 
 1176         MPASS(vap->va_type == VDIR);
 1177 
 1178         return tmpfs_alloc_file(dvp, vpp, vap, cnp, NULL);
 1179 }
 1180 
 1181 /* --------------------------------------------------------------------- */
 1182 
 1183 static int
 1184 tmpfs_rmdir(struct vop_rmdir_args *v)
 1185 {
 1186         struct vnode *dvp = v->a_dvp;
 1187         struct vnode *vp = v->a_vp;
 1188 
 1189         int error;
 1190         struct tmpfs_dirent *de;
 1191         struct tmpfs_mount *tmp;
 1192         struct tmpfs_node *dnode;
 1193         struct tmpfs_node *node;
 1194 
 1195         MPASS(VOP_ISLOCKED(dvp));
 1196         MPASS(VOP_ISLOCKED(vp));
 1197 
 1198         tmp = VFS_TO_TMPFS(dvp->v_mount);
 1199         dnode = VP_TO_TMPFS_DIR(dvp);
 1200         node = VP_TO_TMPFS_DIR(vp);
 1201 
 1202         /* Directories with more than two entries ('.' and '..') cannot be
 1203          * removed. */
 1204          if (node->tn_size > 0) {
 1205                  error = ENOTEMPTY;
 1206                  goto out;
 1207          }
 1208 
 1209         if ((dnode->tn_flags & APPEND)
 1210             || (node->tn_flags & (NOUNLINK | IMMUTABLE | APPEND))) {
 1211                 error = EPERM;
 1212                 goto out;
 1213         }
 1214 
 1215         /* This invariant holds only if we are not trying to remove "..".
 1216           * We checked for that above so this is safe now. */
 1217         MPASS(node->tn_dir.tn_parent == dnode);
 1218 
 1219         /* Get the directory entry associated with node (vp).  This was
 1220          * filled by tmpfs_lookup while looking up the entry. */
 1221         de = tmpfs_dir_lookup(dnode, node, v->a_cnp);
 1222         MPASS(TMPFS_DIRENT_MATCHES(de,
 1223             v->a_cnp->cn_nameptr,
 1224             v->a_cnp->cn_namelen));
 1225 
 1226         /* Check flags to see if we are allowed to remove the directory. */
 1227         if (dnode->tn_flags & APPEND
 1228                 || node->tn_flags & (NOUNLINK | IMMUTABLE | APPEND)) {
 1229                 error = EPERM;
 1230                 goto out;
 1231         }
 1232 
 1233 
 1234         /* Detach the directory entry from the directory (dnode). */
 1235         tmpfs_dir_detach(dvp, de);
 1236         if (v->a_cnp->cn_flags & DOWHITEOUT)
 1237                 tmpfs_dir_whiteout_add(dvp, v->a_cnp);
 1238 
 1239         /* No vnode should be allocated for this entry from this point */
 1240         TMPFS_NODE_LOCK(node);
 1241         TMPFS_ASSERT_ELOCKED(node);
 1242         node->tn_links--;
 1243         node->tn_dir.tn_parent = NULL;
 1244         node->tn_status |= TMPFS_NODE_ACCESSED | TMPFS_NODE_CHANGED | \
 1245             TMPFS_NODE_MODIFIED;
 1246 
 1247         TMPFS_NODE_UNLOCK(node);
 1248 
 1249         TMPFS_NODE_LOCK(dnode);
 1250         TMPFS_ASSERT_ELOCKED(dnode);
 1251         dnode->tn_links--;
 1252         dnode->tn_status |= TMPFS_NODE_ACCESSED | \
 1253             TMPFS_NODE_CHANGED | TMPFS_NODE_MODIFIED;
 1254         TMPFS_NODE_UNLOCK(dnode);
 1255 
 1256         cache_purge(dvp);
 1257         cache_purge(vp);
 1258 
 1259         /* Free the directory entry we just deleted.  Note that the node
 1260          * referred by it will not be removed until the vnode is really
 1261          * reclaimed. */
 1262         tmpfs_free_dirent(tmp, de, TRUE);
 1263 
 1264         /* Release the deleted vnode (will destroy the node, notify
 1265          * interested parties and clean it from the cache). */
 1266 
 1267         dnode->tn_status |= TMPFS_NODE_CHANGED;
 1268         tmpfs_update(dvp);
 1269 
 1270         error = 0;
 1271 
 1272 out:
 1273         return error;
 1274 }
 1275 
 1276 /* --------------------------------------------------------------------- */
 1277 
 1278 static int
 1279 tmpfs_symlink(struct vop_symlink_args *v)
 1280 {
 1281         struct vnode *dvp = v->a_dvp;
 1282         struct vnode **vpp = v->a_vpp;
 1283         struct componentname *cnp = v->a_cnp;
 1284         struct vattr *vap = v->a_vap;
 1285         char *target = v->a_target;
 1286 
 1287 #ifdef notyet /* XXX FreeBSD BUG: kern_symlink is not setting VLNK */
 1288         MPASS(vap->va_type == VLNK);
 1289 #else
 1290         vap->va_type = VLNK;
 1291 #endif
 1292 
 1293         return tmpfs_alloc_file(dvp, vpp, vap, cnp, target);
 1294 }
 1295 
 1296 /* --------------------------------------------------------------------- */
 1297 
 1298 static int
 1299 tmpfs_readdir(struct vop_readdir_args *v)
 1300 {
 1301         struct vnode *vp = v->a_vp;
 1302         struct uio *uio = v->a_uio;
 1303         int *eofflag = v->a_eofflag;
 1304         u_long **cookies = v->a_cookies;
 1305         int *ncookies = v->a_ncookies;
 1306 
 1307         int error;
 1308         off_t startoff;
 1309         off_t cnt = 0;
 1310         struct tmpfs_node *node;
 1311 
 1312         /* This operation only makes sense on directory nodes. */
 1313         if (vp->v_type != VDIR)
 1314                 return ENOTDIR;
 1315 
 1316         node = VP_TO_TMPFS_DIR(vp);
 1317 
 1318         startoff = uio->uio_offset;
 1319 
 1320         if (uio->uio_offset == TMPFS_DIRCOOKIE_DOT) {
 1321                 error = tmpfs_dir_getdotdent(node, uio);
 1322                 if (error != 0)
 1323                         goto outok;
 1324                 cnt++;
 1325         }
 1326 
 1327         if (uio->uio_offset == TMPFS_DIRCOOKIE_DOTDOT) {
 1328                 error = tmpfs_dir_getdotdotdent(node, uio);
 1329                 if (error != 0)
 1330                         goto outok;
 1331                 cnt++;
 1332         }
 1333 
 1334         error = tmpfs_dir_getdents(node, uio, &cnt);
 1335 
 1336 outok:
 1337         MPASS(error >= -1);
 1338 
 1339         if (error == -1)
 1340                 error = (cnt != 0) ? 0 : EINVAL;
 1341 
 1342         if (eofflag != NULL)
 1343                 *eofflag =
 1344                     (error == 0 && uio->uio_offset == TMPFS_DIRCOOKIE_EOF);
 1345 
 1346         /* Update NFS-related variables. */
 1347         if (error == 0 && cookies != NULL && ncookies != NULL) {
 1348                 off_t i;
 1349                 off_t off = startoff;
 1350                 struct tmpfs_dirent *de = NULL;
 1351 
 1352                 *ncookies = cnt;
 1353                 *cookies = malloc(cnt * sizeof(off_t), M_TEMP, M_WAITOK);
 1354 
 1355                 for (i = 0; i < cnt; i++) {
 1356                         MPASS(off != TMPFS_DIRCOOKIE_EOF);
 1357                         if (off == TMPFS_DIRCOOKIE_DOT) {
 1358                                 off = TMPFS_DIRCOOKIE_DOTDOT;
 1359                         } else {
 1360                                 if (off == TMPFS_DIRCOOKIE_DOTDOT) {
 1361                                         de = TAILQ_FIRST(&node->tn_dir.tn_dirhead);
 1362                                 } else if (de != NULL) {
 1363                                         de = TAILQ_NEXT(de, td_entries);
 1364                                 } else {
 1365                                         de = tmpfs_dir_lookupbycookie(node,
 1366                                             off);
 1367                                         MPASS(de != NULL);
 1368                                         de = TAILQ_NEXT(de, td_entries);
 1369                                 }
 1370                                 if (de == NULL)
 1371                                         off = TMPFS_DIRCOOKIE_EOF;
 1372                                 else
 1373                                         off = tmpfs_dircookie(de);
 1374                         }
 1375 
 1376                         (*cookies)[i] = off;
 1377                 }
 1378                 MPASS(uio->uio_offset == off);
 1379         }
 1380 
 1381         return error;
 1382 }
 1383 
 1384 /* --------------------------------------------------------------------- */
 1385 
 1386 static int
 1387 tmpfs_readlink(struct vop_readlink_args *v)
 1388 {
 1389         struct vnode *vp = v->a_vp;
 1390         struct uio *uio = v->a_uio;
 1391 
 1392         int error;
 1393         struct tmpfs_node *node;
 1394 
 1395         MPASS(uio->uio_offset == 0);
 1396         MPASS(vp->v_type == VLNK);
 1397 
 1398         node = VP_TO_TMPFS_NODE(vp);
 1399 
 1400         error = uiomove(node->tn_link, MIN(node->tn_size, uio->uio_resid),
 1401             uio);
 1402         node->tn_status |= TMPFS_NODE_ACCESSED;
 1403 
 1404         return error;
 1405 }
 1406 
 1407 /* --------------------------------------------------------------------- */
 1408 
 1409 static int
 1410 tmpfs_inactive(struct vop_inactive_args *v)
 1411 {
 1412         struct vnode *vp = v->a_vp;
 1413         struct thread *l = v->a_td;
 1414 
 1415         struct tmpfs_node *node;
 1416 
 1417         MPASS(VOP_ISLOCKED(vp));
 1418 
 1419         node = VP_TO_TMPFS_NODE(vp);
 1420 
 1421         if (node->tn_links == 0)
 1422                 vrecycle(vp, l);
 1423 
 1424         return 0;
 1425 }
 1426 
 1427 /* --------------------------------------------------------------------- */
 1428 
 1429 int
 1430 tmpfs_reclaim(struct vop_reclaim_args *v)
 1431 {
 1432         struct vnode *vp = v->a_vp;
 1433 
 1434         struct tmpfs_mount *tmp;
 1435         struct tmpfs_node *node;
 1436 
 1437         node = VP_TO_TMPFS_NODE(vp);
 1438         tmp = VFS_TO_TMPFS(vp->v_mount);
 1439 
 1440         vnode_destroy_vobject(vp);
 1441         cache_purge(vp);
 1442 
 1443         TMPFS_NODE_LOCK(node);
 1444         TMPFS_ASSERT_ELOCKED(node);
 1445         tmpfs_free_vp(vp);
 1446 
 1447         /* If the node referenced by this vnode was deleted by the user,
 1448          * we must free its associated data structures (now that the vnode
 1449          * is being reclaimed). */
 1450         if (node->tn_links == 0 &&
 1451             (node->tn_vpstate & TMPFS_VNODE_ALLOCATING) == 0) {
 1452                 node->tn_vpstate = TMPFS_VNODE_DOOMED;
 1453                 TMPFS_NODE_UNLOCK(node);
 1454                 tmpfs_free_node(tmp, node);
 1455         } else
 1456                 TMPFS_NODE_UNLOCK(node);
 1457 
 1458         MPASS(vp->v_data == NULL);
 1459         return 0;
 1460 }
 1461 
 1462 /* --------------------------------------------------------------------- */
 1463 
 1464 static int
 1465 tmpfs_print(struct vop_print_args *v)
 1466 {
 1467         struct vnode *vp = v->a_vp;
 1468 
 1469         struct tmpfs_node *node;
 1470 
 1471         node = VP_TO_TMPFS_NODE(vp);
 1472 
 1473         printf("tag VT_TMPFS, tmpfs_node %p, flags 0x%x, links %d\n",
 1474             node, node->tn_flags, node->tn_links);
 1475         printf("\tmode 0%o, owner %d, group %d, size %" PRIdMAX
 1476             ", status 0x%x\n",
 1477             node->tn_mode, node->tn_uid, node->tn_gid,
 1478             (uintmax_t)node->tn_size, node->tn_status);
 1479 
 1480         if (vp->v_type == VFIFO)
 1481                 fifo_printinfo(vp);
 1482 
 1483         printf("\n");
 1484 
 1485         return 0;
 1486 }
 1487 
 1488 /* --------------------------------------------------------------------- */
 1489 
 1490 static int
 1491 tmpfs_pathconf(struct vop_pathconf_args *v)
 1492 {
 1493         int name = v->a_name;
 1494         register_t *retval = v->a_retval;
 1495 
 1496         int error;
 1497 
 1498         error = 0;
 1499 
 1500         switch (name) {
 1501         case _PC_LINK_MAX:
 1502                 *retval = LINK_MAX;
 1503                 break;
 1504 
 1505         case _PC_NAME_MAX:
 1506                 *retval = NAME_MAX;
 1507                 break;
 1508 
 1509         case _PC_PATH_MAX:
 1510                 *retval = PATH_MAX;
 1511                 break;
 1512 
 1513         case _PC_PIPE_BUF:
 1514                 *retval = PIPE_BUF;
 1515                 break;
 1516 
 1517         case _PC_CHOWN_RESTRICTED:
 1518                 *retval = 1;
 1519                 break;
 1520 
 1521         case _PC_NO_TRUNC:
 1522                 *retval = 1;
 1523                 break;
 1524 
 1525         case _PC_SYNC_IO:
 1526                 *retval = 1;
 1527                 break;
 1528 
 1529         case _PC_FILESIZEBITS:
 1530                 *retval = 0; /* XXX Don't know which value should I return. */
 1531                 break;
 1532 
 1533         default:
 1534                 error = EINVAL;
 1535         }
 1536 
 1537         return error;
 1538 }
 1539 
 1540 static int
 1541 tmpfs_vptofh(struct vop_vptofh_args *ap)
 1542 {
 1543         struct tmpfs_fid *tfhp;
 1544         struct tmpfs_node *node;
 1545 
 1546         tfhp = (struct tmpfs_fid *)ap->a_fhp;
 1547         node = VP_TO_TMPFS_NODE(ap->a_vp);
 1548 
 1549         tfhp->tf_len = sizeof(struct tmpfs_fid);
 1550         tfhp->tf_id = node->tn_id;
 1551         tfhp->tf_gen = node->tn_gen;
 1552 
 1553         return (0);
 1554 }
 1555 
 1556 static int
 1557 tmpfs_whiteout(struct vop_whiteout_args *ap)
 1558 {
 1559         struct vnode *dvp = ap->a_dvp;
 1560         struct componentname *cnp = ap->a_cnp;
 1561         struct tmpfs_dirent *de;
 1562 
 1563         switch (ap->a_flags) {
 1564         case LOOKUP:
 1565                 return (0);
 1566         case CREATE:
 1567                 de = tmpfs_dir_lookup(VP_TO_TMPFS_DIR(dvp), NULL, cnp);
 1568                 if (de != NULL)
 1569                         return (de->td_node == NULL ? 0 : EEXIST);
 1570                 return (tmpfs_dir_whiteout_add(dvp, cnp));
 1571         case DELETE:
 1572                 tmpfs_dir_whiteout_remove(dvp, cnp);
 1573                 return (0);
 1574         default:
 1575                 panic("tmpfs_whiteout: unknown op");
 1576         }
 1577 }
 1578 
 1579 /* --------------------------------------------------------------------- */
 1580 
 1581 /*
 1582  * vnode operations vector used for files stored in a tmpfs file system.
 1583  */
 1584 struct vop_vector tmpfs_vnodeop_entries = {
 1585         .vop_default =                  &default_vnodeops,
 1586         .vop_lookup =                   vfs_cache_lookup,
 1587         .vop_cachedlookup =             tmpfs_lookup,
 1588         .vop_create =                   tmpfs_create,
 1589         .vop_mknod =                    tmpfs_mknod,
 1590         .vop_open =                     tmpfs_open,
 1591         .vop_close =                    tmpfs_close,
 1592         .vop_access =                   tmpfs_access,
 1593         .vop_getattr =                  tmpfs_getattr,
 1594         .vop_setattr =                  tmpfs_setattr,
 1595         .vop_read =                     tmpfs_read,
 1596         .vop_write =                    tmpfs_write,
 1597         .vop_fsync =                    tmpfs_fsync,
 1598         .vop_remove =                   tmpfs_remove,
 1599         .vop_link =                     tmpfs_link,
 1600         .vop_rename =                   tmpfs_rename,
 1601         .vop_mkdir =                    tmpfs_mkdir,
 1602         .vop_rmdir =                    tmpfs_rmdir,
 1603         .vop_symlink =                  tmpfs_symlink,
 1604         .vop_readdir =                  tmpfs_readdir,
 1605         .vop_readlink =                 tmpfs_readlink,
 1606         .vop_inactive =                 tmpfs_inactive,
 1607         .vop_reclaim =                  tmpfs_reclaim,
 1608         .vop_print =                    tmpfs_print,
 1609         .vop_pathconf =                 tmpfs_pathconf,
 1610         .vop_vptofh =                   tmpfs_vptofh,
 1611         .vop_whiteout =                 tmpfs_whiteout,
 1612         .vop_bmap =                     VOP_EOPNOTSUPP,
 1613 };
 1614 

Cache object: 10458dbf9f91f57e27bca061c8d18750


[ source navigation ] [ diff markup ] [ identifier search ] [ freetext search ] [ file search ] [ list types ] [ track identifier ]


This page is part of the FreeBSD/Linux Linux Kernel Cross-Reference, and was automatically generated using a modified version of the LXR engine.