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/unionfs/union_subr.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 /*-
    2  * Copyright (c) 1994 Jan-Simon Pendry
    3  * Copyright (c) 1994
    4  *      The Regents of the University of California.  All rights reserved.
    5  * Copyright (c) 2005, 2006, 2012 Masanori Ozawa <ozawa@ongs.co.jp>, ONGS Inc.
    6  * Copyright (c) 2006, 2012 Daichi Goto <daichi@freebsd.org>
    7  *
    8  * This code is derived from software contributed 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  * 4. 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  *      @(#)union_subr.c        8.20 (Berkeley) 5/20/95
   36  * $FreeBSD$
   37  */
   38 
   39 #include <sys/param.h>
   40 #include <sys/systm.h>
   41 #include <sys/kernel.h>
   42 #include <sys/lock.h>
   43 #include <sys/mutex.h>
   44 #include <sys/malloc.h>
   45 #include <sys/mount.h>
   46 #include <sys/namei.h>
   47 #include <sys/proc.h>
   48 #include <sys/vnode.h>
   49 #include <sys/dirent.h>
   50 #include <sys/fcntl.h>
   51 #include <sys/filedesc.h>
   52 #include <sys/stat.h>
   53 #include <sys/resourcevar.h>
   54 
   55 #include <security/mac/mac_framework.h>
   56 
   57 #include <vm/uma.h>
   58 
   59 #include <fs/unionfs/union.h>
   60 
   61 #define NUNIONFSNODECACHE 16
   62 
   63 static MALLOC_DEFINE(M_UNIONFSHASH, "UNIONFS hash", "UNIONFS hash table");
   64 MALLOC_DEFINE(M_UNIONFSNODE, "UNIONFS node", "UNIONFS vnode private part");
   65 MALLOC_DEFINE(M_UNIONFSPATH, "UNIONFS path", "UNIONFS path private part");
   66 
   67 /*
   68  * Initialize
   69  */
   70 int 
   71 unionfs_init(struct vfsconf *vfsp)
   72 {
   73         UNIONFSDEBUG("unionfs_init\n"); /* printed during system boot */
   74         return (0);
   75 }
   76 
   77 /*
   78  * Uninitialize
   79  */
   80 int 
   81 unionfs_uninit(struct vfsconf *vfsp)
   82 {
   83         return (0);
   84 }
   85 
   86 static struct unionfs_node_hashhead *
   87 unionfs_get_hashhead(struct vnode *dvp, char *path)
   88 {
   89         int             count;
   90         char            hash;
   91         struct unionfs_node *unp;
   92 
   93         hash = 0;
   94         unp = VTOUNIONFS(dvp);
   95         if (path != NULL) {
   96                 for (count = 0; path[count]; count++)
   97                         hash += path[count];
   98         }
   99 
  100         return (&(unp->un_hashtbl[hash & (unp->un_hashmask)]));
  101 }
  102 
  103 /*
  104  * Get the cached vnode.
  105  */
  106 static struct vnode *
  107 unionfs_get_cached_vnode(struct vnode *uvp, struct vnode *lvp,
  108                         struct vnode *dvp, char *path)
  109 {
  110         struct unionfs_node_hashhead *hd;
  111         struct unionfs_node *unp;
  112         struct vnode   *vp;
  113 
  114         KASSERT((uvp == NULLVP || uvp->v_type == VDIR),
  115             ("unionfs_get_cached_vnode: v_type != VDIR"));
  116         KASSERT((lvp == NULLVP || lvp->v_type == VDIR),
  117             ("unionfs_get_cached_vnode: v_type != VDIR"));
  118 
  119         VI_LOCK(dvp);
  120         hd = unionfs_get_hashhead(dvp, path);
  121         LIST_FOREACH(unp, hd, un_hash) {
  122                 if (!strcmp(unp->un_path, path)) {
  123                         vp = UNIONFSTOV(unp);
  124                         VI_LOCK_FLAGS(vp, MTX_DUPOK);
  125                         VI_UNLOCK(dvp);
  126                         vp->v_iflag &= ~VI_OWEINACT;
  127                         if ((vp->v_iflag & (VI_DOOMED | VI_DOINGINACT)) != 0) {
  128                                 VI_UNLOCK(vp);
  129                                 vp = NULLVP;
  130                         } else
  131                                 VI_UNLOCK(vp);
  132                         return (vp);
  133                 }
  134         }
  135         VI_UNLOCK(dvp);
  136 
  137         return (NULLVP);
  138 }
  139 
  140 /*
  141  * Add the new vnode into cache.
  142  */
  143 static struct vnode *
  144 unionfs_ins_cached_vnode(struct unionfs_node *uncp,
  145                         struct vnode *dvp, char *path)
  146 {
  147         struct unionfs_node_hashhead *hd;
  148         struct unionfs_node *unp;
  149         struct vnode   *vp;
  150 
  151         KASSERT((uncp->un_uppervp==NULLVP || uncp->un_uppervp->v_type==VDIR),
  152             ("unionfs_ins_cached_vnode: v_type != VDIR"));
  153         KASSERT((uncp->un_lowervp==NULLVP || uncp->un_lowervp->v_type==VDIR),
  154             ("unionfs_ins_cached_vnode: v_type != VDIR"));
  155 
  156         VI_LOCK(dvp);
  157         hd = unionfs_get_hashhead(dvp, path);
  158         LIST_FOREACH(unp, hd, un_hash) {
  159                 if (!strcmp(unp->un_path, path)) {
  160                         vp = UNIONFSTOV(unp);
  161                         VI_LOCK_FLAGS(vp, MTX_DUPOK);
  162                         vp->v_iflag &= ~VI_OWEINACT;
  163                         if ((vp->v_iflag & (VI_DOOMED | VI_DOINGINACT)) != 0) {
  164                                 LIST_INSERT_HEAD(hd, uncp, un_hash);
  165                                 VI_UNLOCK(vp);
  166                                 vp = NULLVP;
  167                         } else
  168                                 VI_UNLOCK(vp);
  169                         VI_UNLOCK(dvp);
  170                         return (vp);
  171                 }
  172         }
  173 
  174         LIST_INSERT_HEAD(hd, uncp, un_hash);
  175         VI_UNLOCK(dvp);
  176 
  177         return (NULLVP);
  178 }
  179 
  180 /*
  181  * Remove the vnode.
  182  */
  183 static void
  184 unionfs_rem_cached_vnode(struct unionfs_node *unp, struct vnode *dvp)
  185 {
  186         KASSERT((unp != NULL), ("unionfs_rem_cached_vnode: null node"));
  187         KASSERT((dvp != NULLVP),
  188             ("unionfs_rem_cached_vnode: null parent vnode"));
  189         KASSERT((unp->un_hash.le_prev != NULL),
  190             ("unionfs_rem_cached_vnode: null hash"));
  191 
  192         VI_LOCK(dvp);
  193         LIST_REMOVE(unp, un_hash);
  194         unp->un_hash.le_next = NULL;
  195         unp->un_hash.le_prev = NULL;
  196         VI_UNLOCK(dvp);
  197 }
  198 
  199 /*
  200  * Make a new or get existing unionfs node.
  201  * 
  202  * uppervp and lowervp should be unlocked. Because if new unionfs vnode is
  203  * locked, uppervp or lowervp is locked too. In order to prevent dead lock,
  204  * you should not lock plurality simultaneously.
  205  */
  206 int
  207 unionfs_nodeget(struct mount *mp, struct vnode *uppervp,
  208                 struct vnode *lowervp, struct vnode *dvp,
  209                 struct vnode **vpp, struct componentname *cnp,
  210                 struct thread *td)
  211 {
  212         struct unionfs_mount *ump;
  213         struct unionfs_node *unp;
  214         struct vnode   *vp;
  215         int             error;
  216         int             lkflags;
  217         enum vtype      vt;
  218         char           *path;
  219 
  220         ump = MOUNTTOUNIONFSMOUNT(mp);
  221         lkflags = (cnp ? cnp->cn_lkflags : 0);
  222         path = (cnp ? cnp->cn_nameptr : NULL);
  223         *vpp = NULLVP;
  224 
  225         if (uppervp == NULLVP && lowervp == NULLVP)
  226                 panic("unionfs_nodeget: upper and lower is null");
  227 
  228         vt = (uppervp != NULLVP ? uppervp->v_type : lowervp->v_type);
  229 
  230         /* If it has no ISLASTCN flag, path check is skipped. */
  231         if (cnp && !(cnp->cn_flags & ISLASTCN))
  232                 path = NULL;
  233 
  234         /* check the cache */
  235         if (path != NULL && dvp != NULLVP && vt == VDIR) {
  236                 vp = unionfs_get_cached_vnode(uppervp, lowervp, dvp, path);
  237                 if (vp != NULLVP) {
  238                         vref(vp);
  239                         *vpp = vp;
  240                         goto unionfs_nodeget_out;
  241                 }
  242         }
  243 
  244         if ((uppervp == NULLVP || ump->um_uppervp != uppervp) ||
  245             (lowervp == NULLVP || ump->um_lowervp != lowervp)) {
  246                 /* dvp will be NULLVP only in case of root vnode. */
  247                 if (dvp == NULLVP)
  248                         return (EINVAL);
  249         }
  250 
  251         /*
  252          * Do the MALLOC before the getnewvnode since doing so afterward
  253          * might cause a bogus v_data pointer to get dereferenced elsewhere
  254          * if MALLOC should block.
  255          */
  256         unp = malloc(sizeof(struct unionfs_node),
  257             M_UNIONFSNODE, M_WAITOK | M_ZERO);
  258 
  259         error = getnewvnode("unionfs", mp, &unionfs_vnodeops, &vp);
  260         if (error != 0) {
  261                 free(unp, M_UNIONFSNODE);
  262                 return (error);
  263         }
  264         error = insmntque(vp, mp);      /* XXX: Too early for mpsafe fs */
  265         if (error != 0) {
  266                 free(unp, M_UNIONFSNODE);
  267                 return (error);
  268         }
  269         if (dvp != NULLVP)
  270                 vref(dvp);
  271         if (uppervp != NULLVP)
  272                 vref(uppervp);
  273         if (lowervp != NULLVP)
  274                 vref(lowervp);
  275 
  276         if (vt == VDIR)
  277                 unp->un_hashtbl = hashinit(NUNIONFSNODECACHE, M_UNIONFSHASH,
  278                     &(unp->un_hashmask));
  279 
  280         unp->un_vnode = vp;
  281         unp->un_uppervp = uppervp;
  282         unp->un_lowervp = lowervp;
  283         unp->un_dvp = dvp;
  284         if (uppervp != NULLVP)
  285                 vp->v_vnlock = uppervp->v_vnlock;
  286         else
  287                 vp->v_vnlock = lowervp->v_vnlock;
  288 
  289         if (path != NULL) {
  290                 unp->un_path = (char *)
  291                     malloc(cnp->cn_namelen +1, M_UNIONFSPATH, M_WAITOK|M_ZERO);
  292                 bcopy(cnp->cn_nameptr, unp->un_path, cnp->cn_namelen);
  293                 unp->un_path[cnp->cn_namelen] = '\0';
  294         }
  295         vp->v_type = vt;
  296         vp->v_data = unp;
  297 
  298         if ((uppervp != NULLVP && ump->um_uppervp == uppervp) &&
  299             (lowervp != NULLVP && ump->um_lowervp == lowervp))
  300                 vp->v_vflag |= VV_ROOT;
  301 
  302         if (path != NULL && dvp != NULLVP && vt == VDIR)
  303                 *vpp = unionfs_ins_cached_vnode(unp, dvp, path);
  304         if ((*vpp) != NULLVP) {
  305                 if (dvp != NULLVP)
  306                         vrele(dvp);
  307                 if (uppervp != NULLVP)
  308                         vrele(uppervp);
  309                 if (lowervp != NULLVP)
  310                         vrele(lowervp);
  311 
  312                 unp->un_uppervp = NULLVP;
  313                 unp->un_lowervp = NULLVP;
  314                 unp->un_dvp = NULLVP;
  315                 vrele(vp);
  316                 vp = *vpp;
  317                 vref(vp);
  318         } else
  319                 *vpp = vp;
  320 
  321 unionfs_nodeget_out:
  322         if (lkflags & LK_TYPE_MASK)
  323                 vn_lock(vp, lkflags | LK_RETRY);
  324 
  325         return (0);
  326 }
  327 
  328 /*
  329  * Clean up the unionfs node.
  330  */
  331 void
  332 unionfs_noderem(struct vnode *vp, struct thread *td)
  333 {
  334         int             vfslocked;
  335         int             count;
  336         struct unionfs_node *unp, *unp_t1, *unp_t2;
  337         struct unionfs_node_hashhead *hd;
  338         struct unionfs_node_status *unsp, *unsp_tmp;
  339         struct vnode   *lvp;
  340         struct vnode   *uvp;
  341         struct vnode   *dvp;
  342 
  343         /*
  344          * Use the interlock to protect the clearing of v_data to
  345          * prevent faults in unionfs_lock().
  346          */
  347         VI_LOCK(vp);
  348         unp = VTOUNIONFS(vp);
  349         lvp = unp->un_lowervp;
  350         uvp = unp->un_uppervp;
  351         dvp = unp->un_dvp;
  352         unp->un_lowervp = unp->un_uppervp = NULLVP;
  353         vp->v_vnlock = &(vp->v_lock);
  354         vp->v_data = NULL;
  355         vp->v_object = NULL;
  356         VI_UNLOCK(vp);
  357 
  358         if (lvp != NULLVP)
  359                 VOP_UNLOCK(lvp, LK_RELEASE);
  360         if (uvp != NULLVP)
  361                 VOP_UNLOCK(uvp, LK_RELEASE);
  362 
  363         if (dvp != NULLVP && unp->un_hash.le_prev != NULL)
  364                 unionfs_rem_cached_vnode(unp, dvp);
  365 
  366         if (lockmgr(vp->v_vnlock, LK_EXCLUSIVE, VI_MTX(vp)) != 0)
  367                 panic("the lock for deletion is unacquirable.");
  368 
  369         if (lvp != NULLVP) {
  370                 vfslocked = VFS_LOCK_GIANT(lvp->v_mount);
  371                 vrele(lvp);
  372                 VFS_UNLOCK_GIANT(vfslocked);
  373         }
  374         if (uvp != NULLVP) {
  375                 vfslocked = VFS_LOCK_GIANT(uvp->v_mount);
  376                 vrele(uvp);
  377                 VFS_UNLOCK_GIANT(vfslocked);
  378         }
  379         if (dvp != NULLVP) {
  380                 vfslocked = VFS_LOCK_GIANT(dvp->v_mount);
  381                 vrele(dvp);
  382                 VFS_UNLOCK_GIANT(vfslocked);
  383                 unp->un_dvp = NULLVP;
  384         }
  385         if (unp->un_path != NULL) {
  386                 free(unp->un_path, M_UNIONFSPATH);
  387                 unp->un_path = NULL;
  388         }
  389 
  390         if (unp->un_hashtbl != NULL) {
  391                 for (count = 0; count <= unp->un_hashmask; count++) {
  392                         hd = unp->un_hashtbl + count;
  393                         LIST_FOREACH_SAFE(unp_t1, hd, un_hash, unp_t2) {
  394                                 LIST_REMOVE(unp_t1, un_hash);
  395                                 unp_t1->un_hash.le_next = NULL;
  396                                 unp_t1->un_hash.le_prev = NULL;
  397                         }
  398                 }
  399                 hashdestroy(unp->un_hashtbl, M_UNIONFSHASH, unp->un_hashmask);
  400         }
  401 
  402         LIST_FOREACH_SAFE(unsp, &(unp->un_unshead), uns_list, unsp_tmp) {
  403                 LIST_REMOVE(unsp, uns_list);
  404                 free(unsp, M_TEMP);
  405         }
  406         free(unp, M_UNIONFSNODE);
  407 }
  408 
  409 /*
  410  * Get the unionfs node status.
  411  * You need exclusive lock this vnode.
  412  */
  413 void
  414 unionfs_get_node_status(struct unionfs_node *unp, struct thread *td,
  415                         struct unionfs_node_status **unspp)
  416 {
  417         struct unionfs_node_status *unsp;
  418         pid_t pid = td->td_proc->p_pid;
  419 
  420         KASSERT(NULL != unspp, ("null pointer"));
  421         ASSERT_VOP_ELOCKED(UNIONFSTOV(unp), "unionfs_get_node_status");
  422 
  423         LIST_FOREACH(unsp, &(unp->un_unshead), uns_list) {
  424                 if (unsp->uns_pid == pid) {
  425                         *unspp = unsp;
  426                         return;
  427                 }
  428         }
  429 
  430         /* create a new unionfs node status */
  431         unsp = malloc(sizeof(struct unionfs_node_status),
  432             M_TEMP, M_WAITOK | M_ZERO);
  433 
  434         unsp->uns_pid = pid;
  435         LIST_INSERT_HEAD(&(unp->un_unshead), unsp, uns_list);
  436 
  437         *unspp = unsp;
  438 }
  439 
  440 /*
  441  * Remove the unionfs node status, if you can.
  442  * You need exclusive lock this vnode.
  443  */
  444 void
  445 unionfs_tryrem_node_status(struct unionfs_node *unp,
  446                            struct unionfs_node_status *unsp)
  447 {
  448         KASSERT(NULL != unsp, ("null pointer"));
  449         ASSERT_VOP_ELOCKED(UNIONFSTOV(unp), "unionfs_get_node_status");
  450 
  451         if (0 < unsp->uns_lower_opencnt || 0 < unsp->uns_upper_opencnt)
  452                 return;
  453 
  454         LIST_REMOVE(unsp, uns_list);
  455         free(unsp, M_TEMP);
  456 }
  457 
  458 /*
  459  * Create upper node attr.
  460  */
  461 void
  462 unionfs_create_uppervattr_core(struct unionfs_mount *ump,
  463                                struct vattr *lva,
  464                                struct vattr *uva,
  465                                struct thread *td)
  466 {
  467         VATTR_NULL(uva);
  468         uva->va_type = lva->va_type;
  469         uva->va_atime = lva->va_atime;
  470         uva->va_mtime = lva->va_mtime;
  471         uva->va_ctime = lva->va_ctime;
  472 
  473         switch (ump->um_copymode) {
  474         case UNIONFS_TRANSPARENT:
  475                 uva->va_mode = lva->va_mode;
  476                 uva->va_uid = lva->va_uid;
  477                 uva->va_gid = lva->va_gid;
  478                 break;
  479         case UNIONFS_MASQUERADE:
  480                 if (ump->um_uid == lva->va_uid) {
  481                         uva->va_mode = lva->va_mode & 077077;
  482                         uva->va_mode |= (lva->va_type == VDIR ? ump->um_udir : ump->um_ufile) & 0700;
  483                         uva->va_uid = lva->va_uid;
  484                         uva->va_gid = lva->va_gid;
  485                 } else {
  486                         uva->va_mode = (lva->va_type == VDIR ? ump->um_udir : ump->um_ufile);
  487                         uva->va_uid = ump->um_uid;
  488                         uva->va_gid = ump->um_gid;
  489                 }
  490                 break;
  491         default:                /* UNIONFS_TRADITIONAL */
  492                 uva->va_mode = 0777 & ~td->td_proc->p_fd->fd_cmask;
  493                 uva->va_uid = ump->um_uid;
  494                 uva->va_gid = ump->um_gid;
  495                 break;
  496         }
  497 }
  498 
  499 /*
  500  * Create upper node attr.
  501  */
  502 int
  503 unionfs_create_uppervattr(struct unionfs_mount *ump,
  504                           struct vnode *lvp,
  505                           struct vattr *uva,
  506                           struct ucred *cred,
  507                           struct thread *td)
  508 {
  509         int             error;
  510         struct vattr    lva;
  511 
  512         if ((error = VOP_GETATTR(lvp, &lva, cred)))
  513                 return (error);
  514 
  515         unionfs_create_uppervattr_core(ump, &lva, uva, td);
  516 
  517         return (error);
  518 }
  519 
  520 /*
  521  * relookup
  522  * 
  523  * dvp should be locked on entry and will be locked on return.
  524  * 
  525  * If an error is returned, *vpp will be invalid, otherwise it will hold a
  526  * locked, referenced vnode. If *vpp == dvp then remember that only one
  527  * LK_EXCLUSIVE lock is held.
  528  */
  529 int
  530 unionfs_relookup(struct vnode *dvp, struct vnode **vpp,
  531                  struct componentname *cnp, struct componentname *cn,
  532                  struct thread *td, char *path, int pathlen, u_long nameiop)
  533 {
  534         int     error;
  535 
  536         cn->cn_namelen = pathlen;
  537         cn->cn_pnbuf = uma_zalloc(namei_zone, M_WAITOK);
  538         bcopy(path, cn->cn_pnbuf, pathlen);
  539         cn->cn_pnbuf[pathlen] = '\0';
  540 
  541         cn->cn_nameiop = nameiop;
  542         cn->cn_flags = (LOCKPARENT | LOCKLEAF | HASBUF | SAVENAME | ISLASTCN);
  543         cn->cn_lkflags = LK_EXCLUSIVE;
  544         cn->cn_thread = td;
  545         cn->cn_cred = cnp->cn_cred;
  546 
  547         cn->cn_nameptr = cn->cn_pnbuf;
  548         cn->cn_consume = cnp->cn_consume;
  549 
  550         if (nameiop == DELETE)
  551                 cn->cn_flags |= (cnp->cn_flags & (DOWHITEOUT | SAVESTART));
  552         else if (RENAME == nameiop)
  553                 cn->cn_flags |= (cnp->cn_flags & SAVESTART);
  554 
  555         vref(dvp);
  556         VOP_UNLOCK(dvp, LK_RELEASE);
  557 
  558         if ((error = relookup(dvp, vpp, cn))) {
  559                 uma_zfree(namei_zone, cn->cn_pnbuf);
  560                 cn->cn_flags &= ~HASBUF;
  561                 vn_lock(dvp, LK_EXCLUSIVE | LK_RETRY);
  562         } else
  563                 vrele(dvp);
  564 
  565         return (error);
  566 }
  567 
  568 /*
  569  * relookup for CREATE namei operation.
  570  *
  571  * dvp is unionfs vnode. dvp should be locked.
  572  *
  573  * If it called 'unionfs_copyfile' function by unionfs_link etc,
  574  * VOP_LOOKUP information is broken.
  575  * So it need relookup in order to create link etc.
  576  */
  577 int
  578 unionfs_relookup_for_create(struct vnode *dvp, struct componentname *cnp,
  579                             struct thread *td)
  580 {
  581         int     error;
  582         struct vnode *udvp;
  583         struct vnode *vp;
  584         struct componentname cn;
  585 
  586         udvp = UNIONFSVPTOUPPERVP(dvp);
  587         vp = NULLVP;
  588 
  589         error = unionfs_relookup(udvp, &vp, cnp, &cn, td, cnp->cn_nameptr,
  590             strlen(cnp->cn_nameptr), CREATE);
  591         if (error)
  592                 return (error);
  593 
  594         if (vp != NULLVP) {
  595                 if (udvp == vp)
  596                         vrele(vp);
  597                 else
  598                         vput(vp);
  599 
  600                 error = EEXIST;
  601         }
  602 
  603         if (cn.cn_flags & HASBUF) {
  604                 uma_zfree(namei_zone, cn.cn_pnbuf);
  605                 cn.cn_flags &= ~HASBUF;
  606         }
  607 
  608         if (!error) {
  609                 cn.cn_flags |= (cnp->cn_flags & HASBUF);
  610                 cnp->cn_flags = cn.cn_flags;
  611         }
  612 
  613         return (error);
  614 }
  615 
  616 /*
  617  * relookup for DELETE namei operation.
  618  *
  619  * dvp is unionfs vnode. dvp should be locked.
  620  */
  621 int
  622 unionfs_relookup_for_delete(struct vnode *dvp, struct componentname *cnp,
  623                             struct thread *td)
  624 {
  625         int     error;
  626         struct vnode *udvp;
  627         struct vnode *vp;
  628         struct componentname cn;
  629 
  630         udvp = UNIONFSVPTOUPPERVP(dvp);
  631         vp = NULLVP;
  632 
  633         error = unionfs_relookup(udvp, &vp, cnp, &cn, td, cnp->cn_nameptr,
  634             strlen(cnp->cn_nameptr), DELETE);
  635         if (error)
  636                 return (error);
  637 
  638         if (vp == NULLVP)
  639                 error = ENOENT;
  640         else {
  641                 if (udvp == vp)
  642                         vrele(vp);
  643                 else
  644                         vput(vp);
  645         }
  646 
  647         if (cn.cn_flags & HASBUF) {
  648                 uma_zfree(namei_zone, cn.cn_pnbuf);
  649                 cn.cn_flags &= ~HASBUF;
  650         }
  651 
  652         if (!error) {
  653                 cn.cn_flags |= (cnp->cn_flags & HASBUF);
  654                 cnp->cn_flags = cn.cn_flags;
  655         }
  656 
  657         return (error);
  658 }
  659 
  660 /*
  661  * relookup for RENAME namei operation.
  662  *
  663  * dvp is unionfs vnode. dvp should be locked.
  664  */
  665 int
  666 unionfs_relookup_for_rename(struct vnode *dvp, struct componentname *cnp,
  667                             struct thread *td)
  668 {
  669         int error;
  670         struct vnode *udvp;
  671         struct vnode *vp;
  672         struct componentname cn;
  673 
  674         udvp = UNIONFSVPTOUPPERVP(dvp);
  675         vp = NULLVP;
  676 
  677         error = unionfs_relookup(udvp, &vp, cnp, &cn, td, cnp->cn_nameptr,
  678             strlen(cnp->cn_nameptr), RENAME);
  679         if (error)
  680                 return (error);
  681 
  682         if (vp != NULLVP) {
  683                 if (udvp == vp)
  684                         vrele(vp);
  685                 else
  686                         vput(vp);
  687         }
  688 
  689         if (cn.cn_flags & HASBUF) {
  690                 uma_zfree(namei_zone, cn.cn_pnbuf);
  691                 cn.cn_flags &= ~HASBUF;
  692         }
  693 
  694         if (!error) {
  695                 cn.cn_flags |= (cnp->cn_flags & HASBUF);
  696                 cnp->cn_flags = cn.cn_flags;
  697         }
  698 
  699         return (error);
  700 
  701 }
  702 
  703 /*
  704  * Update the unionfs_node.
  705  * 
  706  * uvp is new locked upper vnode. unionfs vnode's lock will be exchanged to the
  707  * uvp's lock and lower's lock will be unlocked.
  708  */
  709 static void
  710 unionfs_node_update(struct unionfs_node *unp, struct vnode *uvp,
  711                     struct thread *td)
  712 {
  713         unsigned        count, lockrec;
  714         struct vnode   *vp;
  715         struct vnode   *lvp;
  716         struct vnode   *dvp;
  717 
  718         vp = UNIONFSTOV(unp);
  719         lvp = unp->un_lowervp;
  720         ASSERT_VOP_ELOCKED(lvp, "unionfs_node_update");
  721         dvp = unp->un_dvp;
  722 
  723         /*
  724          * lock update
  725          */
  726         VI_LOCK(vp);
  727         unp->un_uppervp = uvp;
  728         vp->v_vnlock = uvp->v_vnlock;
  729         VI_UNLOCK(vp);
  730         lockrec = lvp->v_vnlock->lk_recurse;
  731         for (count = 0; count < lockrec; count++)
  732                 vn_lock(uvp, LK_EXCLUSIVE | LK_CANRECURSE | LK_RETRY);
  733 
  734         /*
  735          * cache update
  736          */
  737         if (unp->un_path != NULL && dvp != NULLVP && vp->v_type == VDIR) {
  738                 static struct unionfs_node_hashhead *hd;
  739 
  740                 VI_LOCK(dvp);
  741                 hd = unionfs_get_hashhead(dvp, unp->un_path);
  742                 LIST_REMOVE(unp, un_hash);
  743                 LIST_INSERT_HEAD(hd, unp, un_hash);
  744                 VI_UNLOCK(dvp);
  745         }
  746 }
  747 
  748 /*
  749  * Create a new shadow dir.
  750  * 
  751  * udvp should be locked on entry and will be locked on return.
  752  * 
  753  * If no error returned, unp will be updated.
  754  */
  755 int
  756 unionfs_mkshadowdir(struct unionfs_mount *ump, struct vnode *udvp,
  757                     struct unionfs_node *unp, struct componentname *cnp,
  758                     struct thread *td)
  759 {
  760         int             error;
  761         struct vnode   *lvp;
  762         struct vnode   *uvp;
  763         struct vattr    va;
  764         struct vattr    lva;
  765         struct componentname cn;
  766         struct mount   *mp;
  767         struct ucred   *cred;
  768         struct ucred   *credbk;
  769         struct uidinfo *rootinfo;
  770 
  771         if (unp->un_uppervp != NULLVP)
  772                 return (EEXIST);
  773 
  774         lvp = unp->un_lowervp;
  775         uvp = NULLVP;
  776         credbk = cnp->cn_cred;
  777 
  778         /* Authority change to root */
  779         rootinfo = uifind((uid_t)0);
  780         cred = crdup(cnp->cn_cred);
  781         /*
  782          * The calls to chgproccnt() are needed to compensate for change_ruid()
  783          * calling chgproccnt().
  784          */
  785         chgproccnt(cred->cr_ruidinfo, 1, 0);
  786         change_euid(cred, rootinfo);
  787         change_ruid(cred, rootinfo);
  788         change_svuid(cred, (uid_t)0);
  789         uifree(rootinfo);
  790         cnp->cn_cred = cred;
  791 
  792         memset(&cn, 0, sizeof(cn));
  793 
  794         if ((error = VOP_GETATTR(lvp, &lva, cnp->cn_cred)))
  795                 goto unionfs_mkshadowdir_abort;
  796 
  797         if ((error = unionfs_relookup(udvp, &uvp, cnp, &cn, td, cnp->cn_nameptr, cnp->cn_namelen, CREATE)))
  798                 goto unionfs_mkshadowdir_abort;
  799         if (uvp != NULLVP) {
  800                 if (udvp == uvp)
  801                         vrele(uvp);
  802                 else
  803                         vput(uvp);
  804 
  805                 error = EEXIST;
  806                 goto unionfs_mkshadowdir_free_out;
  807         }
  808 
  809         if ((error = vn_start_write(udvp, &mp, V_WAIT | PCATCH)))
  810                 goto unionfs_mkshadowdir_free_out;
  811         unionfs_create_uppervattr_core(ump, &lva, &va, td);
  812 
  813         error = VOP_MKDIR(udvp, &uvp, &cn, &va);
  814 
  815         if (!error) {
  816                 unionfs_node_update(unp, uvp, td);
  817 
  818                 /*
  819                  * XXX The bug which cannot set uid/gid was corrected.
  820                  * Ignore errors.
  821                  */
  822                 va.va_type = VNON;
  823                 VOP_SETATTR(uvp, &va, cn.cn_cred);
  824         }
  825         vn_finished_write(mp);
  826 
  827 unionfs_mkshadowdir_free_out:
  828         if (cn.cn_flags & HASBUF) {
  829                 uma_zfree(namei_zone, cn.cn_pnbuf);
  830                 cn.cn_flags &= ~HASBUF;
  831         }
  832 
  833 unionfs_mkshadowdir_abort:
  834         cnp->cn_cred = credbk;
  835         chgproccnt(cred->cr_ruidinfo, -1, 0);
  836         crfree(cred);
  837 
  838         return (error);
  839 }
  840 
  841 /*
  842  * Create a new whiteout.
  843  * 
  844  * dvp should be locked on entry and will be locked on return.
  845  */
  846 int
  847 unionfs_mkwhiteout(struct vnode *dvp, struct componentname *cnp,
  848                    struct thread *td, char *path)
  849 {
  850         int             error;
  851         struct vnode   *wvp;
  852         struct componentname cn;
  853         struct mount   *mp;
  854 
  855         if (path == NULL)
  856                 path = cnp->cn_nameptr;
  857 
  858         wvp = NULLVP;
  859         if ((error = unionfs_relookup(dvp, &wvp, cnp, &cn, td, path, strlen(path), CREATE)))
  860                 return (error);
  861         if (wvp != NULLVP) {
  862                 if (cn.cn_flags & HASBUF) {
  863                         uma_zfree(namei_zone, cn.cn_pnbuf);
  864                         cn.cn_flags &= ~HASBUF;
  865                 }
  866                 if (dvp == wvp)
  867                         vrele(wvp);
  868                 else
  869                         vput(wvp);
  870 
  871                 return (EEXIST);
  872         }
  873 
  874         if ((error = vn_start_write(dvp, &mp, V_WAIT | PCATCH)))
  875                 goto unionfs_mkwhiteout_free_out;
  876         error = VOP_WHITEOUT(dvp, &cn, CREATE);
  877 
  878         vn_finished_write(mp);
  879 
  880 unionfs_mkwhiteout_free_out:
  881         if (cn.cn_flags & HASBUF) {
  882                 uma_zfree(namei_zone, cn.cn_pnbuf);
  883                 cn.cn_flags &= ~HASBUF;
  884         }
  885 
  886         return (error);
  887 }
  888 
  889 /*
  890  * Create a new vnode for create a new shadow file.
  891  * 
  892  * If an error is returned, *vpp will be invalid, otherwise it will hold a
  893  * locked, referenced and opened vnode.
  894  * 
  895  * unp is never updated.
  896  */
  897 static int
  898 unionfs_vn_create_on_upper(struct vnode **vpp, struct vnode *udvp,
  899                            struct unionfs_node *unp, struct vattr *uvap,
  900                            struct thread *td)
  901 {
  902         struct unionfs_mount *ump;
  903         struct vnode   *vp;
  904         struct vnode   *lvp;
  905         struct ucred   *cred;
  906         struct vattr    lva;
  907         int             fmode;
  908         int             error;
  909         struct componentname cn;
  910 
  911         ump = MOUNTTOUNIONFSMOUNT(UNIONFSTOV(unp)->v_mount);
  912         vp = NULLVP;
  913         lvp = unp->un_lowervp;
  914         cred = td->td_ucred;
  915         fmode = FFLAGS(O_WRONLY | O_CREAT | O_TRUNC | O_EXCL);
  916         error = 0;
  917 
  918         if ((error = VOP_GETATTR(lvp, &lva, cred)) != 0)
  919                 return (error);
  920         unionfs_create_uppervattr_core(ump, &lva, uvap, td);
  921 
  922         if (unp->un_path == NULL)
  923                 panic("unionfs: un_path is null");
  924 
  925         cn.cn_namelen = strlen(unp->un_path);
  926         cn.cn_pnbuf = uma_zalloc(namei_zone, M_WAITOK);
  927         bcopy(unp->un_path, cn.cn_pnbuf, cn.cn_namelen + 1);
  928         cn.cn_nameiop = CREATE;
  929         cn.cn_flags = (LOCKPARENT | LOCKLEAF | HASBUF | SAVENAME | ISLASTCN);
  930         cn.cn_lkflags = LK_EXCLUSIVE;
  931         cn.cn_thread = td;
  932         cn.cn_cred = cred;
  933         cn.cn_nameptr = cn.cn_pnbuf;
  934         cn.cn_consume = 0;
  935 
  936         vref(udvp);
  937         if ((error = relookup(udvp, &vp, &cn)) != 0)
  938                 goto unionfs_vn_create_on_upper_free_out2;
  939         vrele(udvp);
  940 
  941         if (vp != NULLVP) {
  942                 if (vp == udvp)
  943                         vrele(vp);
  944                 else
  945                         vput(vp);
  946                 error = EEXIST;
  947                 goto unionfs_vn_create_on_upper_free_out1;
  948         }
  949 
  950         if ((error = VOP_CREATE(udvp, &vp, &cn, uvap)) != 0)
  951                 goto unionfs_vn_create_on_upper_free_out1;
  952 
  953         if ((error = VOP_OPEN(vp, fmode, cred, td, NULL)) != 0) {
  954                 vput(vp);
  955                 goto unionfs_vn_create_on_upper_free_out1;
  956         }
  957         VOP_ADD_WRITECOUNT(vp, 1);
  958         *vpp = vp;
  959 
  960 unionfs_vn_create_on_upper_free_out1:
  961         VOP_UNLOCK(udvp, LK_RELEASE);
  962 
  963 unionfs_vn_create_on_upper_free_out2:
  964         if (cn.cn_flags & HASBUF) {
  965                 uma_zfree(namei_zone, cn.cn_pnbuf);
  966                 cn.cn_flags &= ~HASBUF;
  967         }
  968 
  969         return (error);
  970 }
  971 
  972 /*
  973  * Copy from lvp to uvp.
  974  * 
  975  * lvp and uvp should be locked and opened on entry and will be locked and
  976  * opened on return.
  977  */
  978 static int
  979 unionfs_copyfile_core(struct vnode *lvp, struct vnode *uvp,
  980                       struct ucred *cred, struct thread *td)
  981 {
  982         int             error;
  983         off_t           offset;
  984         int             count;
  985         int             bufoffset;
  986         char           *buf;
  987         struct uio      uio;
  988         struct iovec    iov;
  989 
  990         error = 0;
  991         memset(&uio, 0, sizeof(uio));
  992 
  993         uio.uio_td = td;
  994         uio.uio_segflg = UIO_SYSSPACE;
  995         uio.uio_offset = 0;
  996 
  997         buf = malloc(MAXBSIZE, M_TEMP, M_WAITOK);
  998 
  999         while (error == 0) {
 1000                 offset = uio.uio_offset;
 1001 
 1002                 uio.uio_iov = &iov;
 1003                 uio.uio_iovcnt = 1;
 1004                 iov.iov_base = buf;
 1005                 iov.iov_len = MAXBSIZE;
 1006                 uio.uio_resid = iov.iov_len;
 1007                 uio.uio_rw = UIO_READ;
 1008 
 1009                 if ((error = VOP_READ(lvp, &uio, 0, cred)) != 0)
 1010                         break;
 1011                 if ((count = MAXBSIZE - uio.uio_resid) == 0)
 1012                         break;
 1013 
 1014                 bufoffset = 0;
 1015                 while (bufoffset < count) {
 1016                         uio.uio_iov = &iov;
 1017                         uio.uio_iovcnt = 1;
 1018                         iov.iov_base = buf + bufoffset;
 1019                         iov.iov_len = count - bufoffset;
 1020                         uio.uio_offset = offset + bufoffset;
 1021                         uio.uio_resid = iov.iov_len;
 1022                         uio.uio_rw = UIO_WRITE;
 1023 
 1024                         if ((error = VOP_WRITE(uvp, &uio, 0, cred)) != 0)
 1025                                 break;
 1026 
 1027                         bufoffset += (count - bufoffset) - uio.uio_resid;
 1028                 }
 1029 
 1030                 uio.uio_offset = offset + bufoffset;
 1031         }
 1032 
 1033         free(buf, M_TEMP);
 1034 
 1035         return (error);
 1036 }
 1037 
 1038 /*
 1039  * Copy file from lower to upper.
 1040  * 
 1041  * If you need copy of the contents, set 1 to docopy. Otherwise, set 0 to
 1042  * docopy.
 1043  * 
 1044  * If no error returned, unp will be updated.
 1045  */
 1046 int
 1047 unionfs_copyfile(struct unionfs_node *unp, int docopy, struct ucred *cred,
 1048                  struct thread *td)
 1049 {
 1050         int             error;
 1051         struct mount   *mp;
 1052         struct vnode   *udvp;
 1053         struct vnode   *lvp;
 1054         struct vnode   *uvp;
 1055         struct vattr    uva;
 1056 
 1057         lvp = unp->un_lowervp;
 1058         uvp = NULLVP;
 1059 
 1060         if ((UNIONFSTOV(unp)->v_mount->mnt_flag & MNT_RDONLY))
 1061                 return (EROFS);
 1062         if (unp->un_dvp == NULLVP)
 1063                 return (EINVAL);
 1064         if (unp->un_uppervp != NULLVP)
 1065                 return (EEXIST);
 1066         udvp = VTOUNIONFS(unp->un_dvp)->un_uppervp;
 1067         if (udvp == NULLVP)
 1068                 return (EROFS);
 1069         if ((udvp->v_mount->mnt_flag & MNT_RDONLY))
 1070                 return (EROFS);
 1071 
 1072         error = VOP_ACCESS(lvp, VREAD, cred, td);
 1073         if (error != 0)
 1074                 return (error);
 1075 
 1076         if ((error = vn_start_write(udvp, &mp, V_WAIT | PCATCH)) != 0)
 1077                 return (error);
 1078         error = unionfs_vn_create_on_upper(&uvp, udvp, unp, &uva, td);
 1079         if (error != 0) {
 1080                 vn_finished_write(mp);
 1081                 return (error);
 1082         }
 1083 
 1084         if (docopy != 0) {
 1085                 error = VOP_OPEN(lvp, FREAD, cred, td, NULL);
 1086                 if (error == 0) {
 1087                         error = unionfs_copyfile_core(lvp, uvp, cred, td);
 1088                         VOP_CLOSE(lvp, FREAD, cred, td);
 1089                 }
 1090         }
 1091         VOP_CLOSE(uvp, FWRITE, cred, td);
 1092         VOP_ADD_WRITECOUNT(uvp, -1);
 1093 
 1094         vn_finished_write(mp);
 1095 
 1096         if (error == 0) {
 1097                 /* Reset the attributes. Ignore errors. */
 1098                 uva.va_type = VNON;
 1099                 VOP_SETATTR(uvp, &uva, cred);
 1100         }
 1101 
 1102         unionfs_node_update(unp, uvp, td);
 1103 
 1104         return (error);
 1105 }
 1106 
 1107 /*
 1108  * It checks whether vp can rmdir. (check empty)
 1109  *
 1110  * vp is unionfs vnode.
 1111  * vp should be locked.
 1112  */
 1113 int
 1114 unionfs_check_rmdir(struct vnode *vp, struct ucred *cred, struct thread *td)
 1115 {
 1116         int             error;
 1117         int             eofflag;
 1118         int             lookuperr;
 1119         struct vnode   *uvp;
 1120         struct vnode   *lvp;
 1121         struct vnode   *tvp;
 1122         struct vattr    va;
 1123         struct componentname cn;
 1124         /*
 1125          * The size of buf needs to be larger than DIRBLKSIZ.
 1126          */
 1127         char            buf[256 * 6];
 1128         struct dirent  *dp;
 1129         struct dirent  *edp;
 1130         struct uio      uio;
 1131         struct iovec    iov;
 1132 
 1133         ASSERT_VOP_ELOCKED(vp, "unionfs_check_rmdir");
 1134 
 1135         eofflag = 0;
 1136         uvp = UNIONFSVPTOUPPERVP(vp);
 1137         lvp = UNIONFSVPTOLOWERVP(vp);
 1138 
 1139         /* check opaque */
 1140         if ((error = VOP_GETATTR(uvp, &va, cred)) != 0)
 1141                 return (error);
 1142         if (va.va_flags & OPAQUE)
 1143                 return (0);
 1144 
 1145         /* open vnode */
 1146 #ifdef MAC
 1147         if ((error = mac_vnode_check_open(cred, vp, VEXEC|VREAD)) != 0)
 1148                 return (error);
 1149 #endif
 1150         if ((error = VOP_ACCESS(vp, VEXEC|VREAD, cred, td)) != 0)
 1151                 return (error);
 1152         if ((error = VOP_OPEN(vp, FREAD, cred, td, NULL)) != 0)
 1153                 return (error);
 1154 
 1155         uio.uio_rw = UIO_READ;
 1156         uio.uio_segflg = UIO_SYSSPACE;
 1157         uio.uio_td = td;
 1158         uio.uio_offset = 0;
 1159 
 1160 #ifdef MAC
 1161         error = mac_vnode_check_readdir(td->td_ucred, lvp);
 1162 #endif
 1163         while (!error && !eofflag) {
 1164                 iov.iov_base = buf;
 1165                 iov.iov_len = sizeof(buf);
 1166                 uio.uio_iov = &iov;
 1167                 uio.uio_iovcnt = 1;
 1168                 uio.uio_resid = iov.iov_len;
 1169 
 1170                 error = VOP_READDIR(lvp, &uio, cred, &eofflag, NULL, NULL);
 1171                 if (error != 0)
 1172                         break;
 1173                 if (eofflag == 0 && uio.uio_resid == sizeof(buf)) {
 1174 #ifdef DIAGNOSTIC
 1175                         panic("bad readdir response from lower FS.");
 1176 #endif
 1177                         break;
 1178                 }
 1179 
 1180                 edp = (struct dirent*)&buf[sizeof(buf) - uio.uio_resid];
 1181                 for (dp = (struct dirent*)buf; !error && dp < edp;
 1182                      dp = (struct dirent*)((caddr_t)dp + dp->d_reclen)) {
 1183                         if (dp->d_type == DT_WHT ||
 1184                             (dp->d_namlen == 1 && dp->d_name[0] == '.') ||
 1185                             (dp->d_namlen == 2 && !bcmp(dp->d_name, "..", 2)))
 1186                                 continue;
 1187 
 1188                         cn.cn_namelen = dp->d_namlen;
 1189                         cn.cn_pnbuf = NULL;
 1190                         cn.cn_nameptr = dp->d_name;
 1191                         cn.cn_nameiop = LOOKUP;
 1192                         cn.cn_flags = (LOCKPARENT | LOCKLEAF | SAVENAME | RDONLY | ISLASTCN);
 1193                         cn.cn_lkflags = LK_EXCLUSIVE;
 1194                         cn.cn_thread = td;
 1195                         cn.cn_cred = cred;
 1196                         cn.cn_consume = 0;
 1197 
 1198                         /*
 1199                          * check entry in lower.
 1200                          * Sometimes, readdir function returns
 1201                          * wrong entry.
 1202                          */
 1203                         lookuperr = VOP_LOOKUP(lvp, &tvp, &cn);
 1204 
 1205                         if (!lookuperr)
 1206                                 vput(tvp);
 1207                         else
 1208                                 continue; /* skip entry */
 1209 
 1210                         /*
 1211                          * check entry
 1212                          * If it has no exist/whiteout entry in upper,
 1213                          * directory is not empty.
 1214                          */
 1215                         cn.cn_flags = (LOCKPARENT | LOCKLEAF | SAVENAME | RDONLY | ISLASTCN);
 1216                         lookuperr = VOP_LOOKUP(uvp, &tvp, &cn);
 1217 
 1218                         if (!lookuperr)
 1219                                 vput(tvp);
 1220 
 1221                         /* ignore exist or whiteout entry */
 1222                         if (!lookuperr ||
 1223                             (lookuperr == ENOENT && (cn.cn_flags & ISWHITEOUT)))
 1224                                 continue;
 1225 
 1226                         error = ENOTEMPTY;
 1227                 }
 1228         }
 1229 
 1230         /* close vnode */
 1231         VOP_CLOSE(vp, FREAD, cred, td);
 1232 
 1233         return (error);
 1234 }
 1235 
 1236 #ifdef DIAGNOSTIC
 1237 
 1238 struct vnode   *
 1239 unionfs_checkuppervp(struct vnode *vp, char *fil, int lno)
 1240 {
 1241         struct unionfs_node *unp;
 1242 
 1243         unp = VTOUNIONFS(vp);
 1244 
 1245 #ifdef notyet
 1246         if (vp->v_op != unionfs_vnodeop_p) {
 1247                 printf("unionfs_checkuppervp: on non-unionfs-node.\n");
 1248 #ifdef KDB
 1249                 kdb_enter(KDB_WHY_UNIONFS,
 1250                     "unionfs_checkuppervp: on non-unionfs-node.\n");
 1251 #endif
 1252                 panic("unionfs_checkuppervp");
 1253         };
 1254 #endif
 1255         return (unp->un_uppervp);
 1256 }
 1257 
 1258 struct vnode   *
 1259 unionfs_checklowervp(struct vnode *vp, char *fil, int lno)
 1260 {
 1261         struct unionfs_node *unp;
 1262 
 1263         unp = VTOUNIONFS(vp);
 1264 
 1265 #ifdef notyet
 1266         if (vp->v_op != unionfs_vnodeop_p) {
 1267                 printf("unionfs_checklowervp: on non-unionfs-node.\n");
 1268 #ifdef KDB
 1269                 kdb_enter(KDB_WHY_UNIONFS,
 1270                     "unionfs_checklowervp: on non-unionfs-node.\n");
 1271 #endif
 1272                 panic("unionfs_checklowervp");
 1273         };
 1274 #endif
 1275         return (unp->un_lowervp);
 1276 }
 1277 #endif

Cache object: 39af5579ee19cb759c3980d56b5d5d1f


[ 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.