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/msdosfs/msdosfs_denode.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 /* $FreeBSD: releng/12.0/sys/fs/msdosfs/msdosfs_denode.c 336966 2018-07-31 12:44:28Z emaste $ */
    2 /*      $NetBSD: msdosfs_denode.c,v 1.28 1998/02/10 14:10:00 mrg Exp $  */
    3 
    4 /*-
    5  * SPDX-License-Identifier: BSD-4-Clause
    6  *
    7  * Copyright (C) 1994, 1995, 1997 Wolfgang Solfrank.
    8  * Copyright (C) 1994, 1995, 1997 TooLs GmbH.
    9  * All rights reserved.
   10  * Original code by Paul Popelka (paulp@uts.amdahl.com) (see below).
   11  *
   12  * Redistribution and use in source and binary forms, with or without
   13  * modification, are permitted provided that the following conditions
   14  * are met:
   15  * 1. Redistributions of source code must retain the above copyright
   16  *    notice, this list of conditions and the following disclaimer.
   17  * 2. Redistributions in binary form must reproduce the above copyright
   18  *    notice, this list of conditions and the following disclaimer in the
   19  *    documentation and/or other materials provided with the distribution.
   20  * 3. All advertising materials mentioning features or use of this software
   21  *    must display the following acknowledgement:
   22  *      This product includes software developed by TooLs GmbH.
   23  * 4. The name of TooLs GmbH may not be used to endorse or promote products
   24  *    derived from this software without specific prior written permission.
   25  *
   26  * THIS SOFTWARE IS PROVIDED BY TOOLS GMBH ``AS IS'' AND ANY EXPRESS OR
   27  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
   28  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
   29  * IN NO EVENT SHALL TOOLS GMBH BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
   30  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
   31  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
   32  * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
   33  * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
   34  * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
   35  * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
   36  */
   37 /*-
   38  * Written by Paul Popelka (paulp@uts.amdahl.com)
   39  *
   40  * You can do anything you want with this software, just don't say you wrote
   41  * it, and don't remove this notice.
   42  *
   43  * This software is provided "as is".
   44  *
   45  * The author supplies this software to be publicly redistributed on the
   46  * understanding that the author is not responsible for the correct
   47  * functioning of this software in any circumstances and is not liable for
   48  * any damages caused by this software.
   49  *
   50  * October 1992
   51  */
   52 
   53 #include <sys/param.h>
   54 #include <sys/systm.h>
   55 #include <sys/buf.h>
   56 #include <sys/clock.h>
   57 #include <sys/kernel.h>
   58 #include <sys/malloc.h>
   59 #include <sys/mount.h>
   60 #include <sys/vmmeter.h>
   61 #include <sys/vnode.h>
   62 
   63 #include <vm/vm.h>
   64 #include <vm/vm_extern.h>
   65 
   66 #include <fs/msdosfs/bpb.h>
   67 #include <fs/msdosfs/direntry.h>
   68 #include <fs/msdosfs/denode.h>
   69 #include <fs/msdosfs/fat.h>
   70 #include <fs/msdosfs/msdosfsmount.h>
   71 
   72 static MALLOC_DEFINE(M_MSDOSFSNODE, "msdosfs_node", "MSDOSFS vnode private part");
   73 
   74 static int
   75 de_vncmpf(struct vnode *vp, void *arg)
   76 {
   77         struct denode *de;
   78         uint64_t *a;
   79 
   80         a = arg;
   81         de = VTODE(vp);
   82         return (de->de_inode != *a);
   83 }
   84 
   85 /*
   86  * If deget() succeeds it returns with the gotten denode locked().
   87  *
   88  * pmp       - address of msdosfsmount structure of the filesystem containing
   89  *             the denode of interest.  The address of
   90  *             the msdosfsmount structure are used.
   91  * dirclust  - which cluster bp contains, if dirclust is 0 (root directory)
   92  *             diroffset is relative to the beginning of the root directory,
   93  *             otherwise it is cluster relative.
   94  * diroffset - offset past begin of cluster of denode we want
   95  * depp      - returns the address of the gotten denode.
   96  */
   97 int
   98 deget(struct msdosfsmount *pmp, u_long dirclust, u_long diroffset,
   99     struct denode **depp)
  100 {
  101         int error;
  102         uint64_t inode;
  103         struct mount *mntp = pmp->pm_mountp;
  104         struct direntry *direntptr;
  105         struct denode *ldep;
  106         struct vnode *nvp, *xvp;
  107         struct buf *bp;
  108 
  109 #ifdef MSDOSFS_DEBUG
  110         printf("deget(pmp %p, dirclust %lu, diroffset %lx, depp %p)\n",
  111             pmp, dirclust, diroffset, depp);
  112 #endif
  113 
  114         /*
  115          * On FAT32 filesystems, root is a (more or less) normal
  116          * directory
  117          */
  118         if (FAT32(pmp) && dirclust == MSDOSFSROOT)
  119                 dirclust = pmp->pm_rootdirblk;
  120 
  121         /*
  122          * See if the denode is in the denode cache. Use the location of
  123          * the directory entry to compute the hash value. For subdir use
  124          * address of "." entry. For root dir (if not FAT32) use cluster
  125          * MSDOSFSROOT, offset MSDOSFSROOT_OFS
  126          *
  127          * NOTE: The check for de_refcnt > 0 below insures the denode being
  128          * examined does not represent an unlinked but still open file.
  129          * These files are not to be accessible even when the directory
  130          * entry that represented the file happens to be reused while the
  131          * deleted file is still open.
  132          */
  133         inode = (uint64_t)pmp->pm_bpcluster * dirclust + diroffset;
  134 
  135         error = vfs_hash_get(mntp, inode, LK_EXCLUSIVE, curthread, &nvp,
  136             de_vncmpf, &inode);
  137         if (error)
  138                 return (error);
  139         if (nvp != NULL) {
  140                 *depp = VTODE(nvp);
  141                 KASSERT((*depp)->de_dirclust == dirclust, ("wrong dirclust"));
  142                 KASSERT((*depp)->de_diroffset == diroffset, ("wrong diroffset"));
  143                 return (0);
  144         }
  145         ldep = malloc(sizeof(struct denode), M_MSDOSFSNODE, M_WAITOK | M_ZERO);
  146 
  147         /*
  148          * Directory entry was not in cache, have to create a vnode and
  149          * copy it from the passed disk buffer.
  150          */
  151         /* getnewvnode() does a VREF() on the vnode */
  152         error = getnewvnode("msdosfs", mntp, &msdosfs_vnodeops, &nvp);
  153         if (error) {
  154                 *depp = NULL;
  155                 free(ldep, M_MSDOSFSNODE);
  156                 return error;
  157         }
  158         nvp->v_data = ldep;
  159         ldep->de_vnode = nvp;
  160         ldep->de_flag = 0;
  161         ldep->de_dirclust = dirclust;
  162         ldep->de_diroffset = diroffset;
  163         ldep->de_inode = inode;
  164         lockmgr(nvp->v_vnlock, LK_EXCLUSIVE, NULL);
  165         fc_purge(ldep, 0);      /* init the FAT cache for this denode */
  166         error = insmntque(nvp, mntp);
  167         if (error != 0) {
  168                 free(ldep, M_MSDOSFSNODE);
  169                 *depp = NULL;
  170                 return (error);
  171         }
  172         error = vfs_hash_insert(nvp, inode, LK_EXCLUSIVE, curthread, &xvp,
  173             de_vncmpf, &inode);
  174         if (error) {
  175                 *depp = NULL;
  176                 return (error);
  177         }
  178         if (xvp != NULL) {
  179                 *depp = xvp->v_data;
  180                 return (0);
  181         }
  182 
  183         ldep->de_pmp = pmp;
  184         ldep->de_refcnt = 1;
  185         /*
  186          * Copy the directory entry into the denode area of the vnode.
  187          */
  188         if ((dirclust == MSDOSFSROOT
  189              || (FAT32(pmp) && dirclust == pmp->pm_rootdirblk))
  190             && diroffset == MSDOSFSROOT_OFS) {
  191                 /*
  192                  * Directory entry for the root directory. There isn't one,
  193                  * so we manufacture one. We should probably rummage
  194                  * through the root directory and find a label entry (if it
  195                  * exists), and then use the time and date from that entry
  196                  * as the time and date for the root denode.
  197                  */
  198                 nvp->v_vflag |= VV_ROOT; /* should be further down XXX */
  199 
  200                 ldep->de_Attributes = ATTR_DIRECTORY;
  201                 ldep->de_LowerCase = 0;
  202                 if (FAT32(pmp))
  203                         ldep->de_StartCluster = pmp->pm_rootdirblk;
  204                         /* de_FileSize will be filled in further down */
  205                 else {
  206                         ldep->de_StartCluster = MSDOSFSROOT;
  207                         ldep->de_FileSize = pmp->pm_rootdirsize * DEV_BSIZE;
  208                 }
  209                 /*
  210                  * fill in time and date so that fattime2timespec() doesn't
  211                  * spit up when called from msdosfs_getattr() with root
  212                  * denode
  213                  */
  214                 ldep->de_CHun = 0;
  215                 ldep->de_CTime = 0x0000;        /* 00:00:00      */
  216                 ldep->de_CDate = (0 << DD_YEAR_SHIFT) | (1 << DD_MONTH_SHIFT)
  217                     | (1 << DD_DAY_SHIFT);
  218                 /* Jan 1, 1980   */
  219                 ldep->de_ADate = ldep->de_CDate;
  220                 ldep->de_MTime = ldep->de_CTime;
  221                 ldep->de_MDate = ldep->de_CDate;
  222                 /* leave the other fields as garbage */
  223         } else {
  224                 error = readep(pmp, dirclust, diroffset, &bp, &direntptr);
  225                 if (error) {
  226                         /*
  227                          * The denode does not contain anything useful, so
  228                          * it would be wrong to leave it on its hash chain.
  229                          * Arrange for vput() to just forget about it.
  230                          */
  231                         ldep->de_Name[0] = SLOT_DELETED;
  232 
  233                         vput(nvp);
  234                         *depp = NULL;
  235                         return (error);
  236                 }
  237                 (void)DE_INTERNALIZE(ldep, direntptr);
  238                 brelse(bp);
  239         }
  240 
  241         /*
  242          * Fill in a few fields of the vnode and finish filling in the
  243          * denode.  Then return the address of the found denode.
  244          */
  245         if (ldep->de_Attributes & ATTR_DIRECTORY) {
  246                 /*
  247                  * Since DOS directory entries that describe directories
  248                  * have 0 in the filesize field, we take this opportunity
  249                  * to find out the length of the directory and plug it into
  250                  * the denode structure.
  251                  */
  252                 u_long size;
  253 
  254                 /*
  255                  * XXX it sometimes happens that the "." entry has cluster
  256                  * number 0 when it shouldn't.  Use the actual cluster number
  257                  * instead of what is written in directory entry.
  258                  */
  259                 if (diroffset == 0 && ldep->de_StartCluster != dirclust) {
  260 #ifdef MSDOSFS_DEBUG
  261                         printf("deget(): \".\" entry at clust %lu != %lu\n",
  262                             dirclust, ldep->de_StartCluster);
  263 #endif
  264                         ldep->de_StartCluster = dirclust;
  265                 }
  266 
  267                 nvp->v_type = VDIR;
  268                 if (ldep->de_StartCluster != MSDOSFSROOT) {
  269                         error = pcbmap(ldep, 0xffff, 0, &size, 0);
  270                         if (error == E2BIG) {
  271                                 ldep->de_FileSize = de_cn2off(pmp, size);
  272                                 error = 0;
  273                         } else {
  274 #ifdef MSDOSFS_DEBUG
  275                                 printf("deget(): pcbmap returned %d\n", error);
  276 #endif
  277                         }
  278                 }
  279         } else
  280                 nvp->v_type = VREG;
  281         ldep->de_modrev = init_va_filerev();
  282         *depp = ldep;
  283         return (0);
  284 }
  285 
  286 int
  287 deupdat(struct denode *dep, int waitfor)
  288 {
  289         struct direntry dir;
  290         struct timespec ts;
  291         struct buf *bp;
  292         struct direntry *dirp;
  293         int error;
  294 
  295         if (DETOV(dep)->v_mount->mnt_flag & MNT_RDONLY) {
  296                 dep->de_flag &= ~(DE_UPDATE | DE_CREATE | DE_ACCESS |
  297                     DE_MODIFIED);
  298                 return (0);
  299         }
  300         vfs_timestamp(&ts);
  301         DETIMES(dep, &ts, &ts, &ts);
  302         if ((dep->de_flag & DE_MODIFIED) == 0 && waitfor == 0)
  303                 return (0);
  304         dep->de_flag &= ~DE_MODIFIED;
  305         if (DETOV(dep)->v_vflag & VV_ROOT)
  306                 return (EINVAL);
  307         if (dep->de_refcnt <= 0)
  308                 return (0);
  309         error = readde(dep, &bp, &dirp);
  310         if (error)
  311                 return (error);
  312         DE_EXTERNALIZE(&dir, dep);
  313         if (bcmp(dirp, &dir, sizeof(dir)) == 0) {
  314                 if (waitfor == 0 || (bp->b_flags & B_DELWRI) == 0) {
  315                         brelse(bp);
  316                         return (0);
  317                 }
  318         } else
  319                 *dirp = dir;
  320         if ((DETOV(dep)->v_mount->mnt_flag & MNT_NOCLUSTERW) == 0)
  321                 bp->b_flags |= B_CLUSTEROK;
  322         if (waitfor)
  323                 error = bwrite(bp);
  324         else if (vm_page_count_severe() || buf_dirty_count_severe())
  325                 bawrite(bp);
  326         else
  327                 bdwrite(bp);
  328         return (error);
  329 }
  330 
  331 /*
  332  * Truncate the file described by dep to the length specified by length.
  333  */
  334 int
  335 detrunc(struct denode *dep, u_long length, int flags, struct ucred *cred)
  336 {
  337         int error;
  338         int allerror;
  339         u_long eofentry;
  340         u_long chaintofree;
  341         daddr_t bn;
  342         int boff;
  343         int isadir = dep->de_Attributes & ATTR_DIRECTORY;
  344         struct buf *bp;
  345         struct msdosfsmount *pmp = dep->de_pmp;
  346 
  347 #ifdef MSDOSFS_DEBUG
  348         printf("detrunc(): file %s, length %lu, flags %x\n", dep->de_Name, length, flags);
  349 #endif
  350 
  351         /*
  352          * Disallow attempts to truncate the root directory since it is of
  353          * fixed size.  That's just the way dos filesystems are.  We use
  354          * the VROOT bit in the vnode because checking for the directory
  355          * bit and a startcluster of 0 in the denode is not adequate to
  356          * recognize the root directory at this point in a file or
  357          * directory's life.
  358          */
  359         if ((DETOV(dep)->v_vflag & VV_ROOT) && !FAT32(pmp)) {
  360 #ifdef MSDOSFS_DEBUG
  361                 printf("detrunc(): can't truncate root directory, clust %ld, offset %ld\n",
  362                     dep->de_dirclust, dep->de_diroffset);
  363 #endif
  364                 return (EINVAL);
  365         }
  366 
  367         if (dep->de_FileSize < length) {
  368                 vnode_pager_setsize(DETOV(dep), length);
  369                 return deextend(dep, length, cred);
  370         }
  371 
  372         /*
  373          * If the desired length is 0 then remember the starting cluster of
  374          * the file and set the StartCluster field in the directory entry
  375          * to 0.  If the desired length is not zero, then get the number of
  376          * the last cluster in the shortened file.  Then get the number of
  377          * the first cluster in the part of the file that is to be freed.
  378          * Then set the next cluster pointer in the last cluster of the
  379          * file to CLUST_EOFE.
  380          */
  381         if (length == 0) {
  382                 chaintofree = dep->de_StartCluster;
  383                 dep->de_StartCluster = 0;
  384                 eofentry = ~0;
  385         } else {
  386                 error = pcbmap(dep, de_clcount(pmp, length) - 1, 0,
  387                                &eofentry, 0);
  388                 if (error) {
  389 #ifdef MSDOSFS_DEBUG
  390                         printf("detrunc(): pcbmap fails %d\n", error);
  391 #endif
  392                         return (error);
  393                 }
  394         }
  395 
  396         fc_purge(dep, de_clcount(pmp, length));
  397 
  398         /*
  399          * If the new length is not a multiple of the cluster size then we
  400          * must zero the tail end of the new last cluster in case it
  401          * becomes part of the file again because of a seek.
  402          */
  403         if ((boff = length & pmp->pm_crbomask) != 0) {
  404                 if (isadir) {
  405                         bn = cntobn(pmp, eofentry);
  406                         error = bread(pmp->pm_devvp, bn, pmp->pm_bpcluster,
  407                             NOCRED, &bp);
  408                         if (error) {
  409                                 brelse(bp);
  410 #ifdef MSDOSFS_DEBUG
  411                                 printf("detrunc(): bread fails %d\n", error);
  412 #endif
  413                                 return (error);
  414                         }
  415                         memset(bp->b_data + boff, 0, pmp->pm_bpcluster - boff);
  416                         if (flags & IO_SYNC)
  417                                 bwrite(bp);
  418                         else
  419                                 bdwrite(bp);
  420                 }
  421         }
  422 
  423         /*
  424          * Write out the updated directory entry.  Even if the update fails
  425          * we free the trailing clusters.
  426          */
  427         dep->de_FileSize = length;
  428         if (!isadir)
  429                 dep->de_flag |= DE_UPDATE | DE_MODIFIED;
  430         allerror = vtruncbuf(DETOV(dep), cred, length, pmp->pm_bpcluster);
  431 #ifdef MSDOSFS_DEBUG
  432         if (allerror)
  433                 printf("detrunc(): vtruncbuf error %d\n", allerror);
  434 #endif
  435         error = deupdat(dep, !DOINGASYNC((DETOV(dep))));
  436         if (error != 0 && allerror == 0)
  437                 allerror = error;
  438 #ifdef MSDOSFS_DEBUG
  439         printf("detrunc(): allerror %d, eofentry %lu\n",
  440                allerror, eofentry);
  441 #endif
  442 
  443         /*
  444          * If we need to break the cluster chain for the file then do it
  445          * now.
  446          */
  447         if (eofentry != ~0) {
  448                 error = fatentry(FAT_GET_AND_SET, pmp, eofentry,
  449                                  &chaintofree, CLUST_EOFE);
  450                 if (error) {
  451 #ifdef MSDOSFS_DEBUG
  452                         printf("detrunc(): fatentry errors %d\n", error);
  453 #endif
  454                         return (error);
  455                 }
  456                 fc_setcache(dep, FC_LASTFC, de_cluster(pmp, length - 1),
  457                             eofentry);
  458         }
  459 
  460         /*
  461          * Now free the clusters removed from the file because of the
  462          * truncation.
  463          */
  464         if (chaintofree != 0 && !MSDOSFSEOF(pmp, chaintofree))
  465                 freeclusterchain(pmp, chaintofree);
  466 
  467         return (allerror);
  468 }
  469 
  470 /*
  471  * Extend the file described by dep to length specified by length.
  472  */
  473 int
  474 deextend(struct denode *dep, u_long length, struct ucred *cred)
  475 {
  476         struct msdosfsmount *pmp = dep->de_pmp;
  477         u_long count;
  478         int error;
  479 
  480         /*
  481          * The root of a DOS filesystem cannot be extended.
  482          */
  483         if ((DETOV(dep)->v_vflag & VV_ROOT) && !FAT32(pmp))
  484                 return (EINVAL);
  485 
  486         /*
  487          * Directories cannot be extended.
  488          */
  489         if (dep->de_Attributes & ATTR_DIRECTORY)
  490                 return (EISDIR);
  491 
  492         if (length <= dep->de_FileSize)
  493                 panic("deextend: file too large");
  494 
  495         /*
  496          * Compute the number of clusters to allocate.
  497          */
  498         count = de_clcount(pmp, length) - de_clcount(pmp, dep->de_FileSize);
  499         if (count > 0) {
  500                 if (count > pmp->pm_freeclustercount)
  501                         return (ENOSPC);
  502                 error = extendfile(dep, count, NULL, NULL, DE_CLEAR);
  503                 if (error) {
  504                         /* truncate the added clusters away again */
  505                         (void) detrunc(dep, dep->de_FileSize, 0, cred);
  506                         return (error);
  507                 }
  508         }
  509         dep->de_FileSize = length;
  510         dep->de_flag |= DE_UPDATE | DE_MODIFIED;
  511         return (deupdat(dep, !DOINGASYNC(DETOV(dep))));
  512 }
  513 
  514 /*
  515  * Move a denode to its correct hash queue after the file it represents has
  516  * been moved to a new directory.
  517  */
  518 void
  519 reinsert(struct denode *dep)
  520 {
  521         struct vnode *vp;
  522 
  523         /*
  524          * Fix up the denode cache.  If the denode is for a directory,
  525          * there is nothing to do since the hash is based on the starting
  526          * cluster of the directory file and that hasn't changed.  If for a
  527          * file the hash is based on the location of the directory entry,
  528          * so we must remove it from the cache and re-enter it with the
  529          * hash based on the new location of the directory entry.
  530          */
  531 #if 0
  532         if (dep->de_Attributes & ATTR_DIRECTORY)
  533                 return;
  534 #endif
  535         vp = DETOV(dep);
  536         dep->de_inode = (uint64_t)dep->de_pmp->pm_bpcluster * dep->de_dirclust +
  537             dep->de_diroffset;
  538         vfs_hash_rehash(vp, dep->de_inode);
  539 }
  540 
  541 int
  542 msdosfs_reclaim(struct vop_reclaim_args *ap)
  543 {
  544         struct vnode *vp = ap->a_vp;
  545         struct denode *dep = VTODE(vp);
  546 
  547 #ifdef MSDOSFS_DEBUG
  548         printf("msdosfs_reclaim(): dep %p, file %s, refcnt %ld\n",
  549             dep, dep->de_Name, dep->de_refcnt);
  550 #endif
  551 
  552         /*
  553          * Destroy the vm object and flush associated pages.
  554          */
  555         vnode_destroy_vobject(vp);
  556         /*
  557          * Remove the denode from its hash chain.
  558          */
  559         vfs_hash_remove(vp);
  560         /*
  561          * Purge old data structures associated with the denode.
  562          */
  563 #if 0 /* XXX */
  564         dep->de_flag = 0;
  565 #endif
  566         free(dep, M_MSDOSFSNODE);
  567         vp->v_data = NULL;
  568 
  569         return (0);
  570 }
  571 
  572 int
  573 msdosfs_inactive(struct vop_inactive_args *ap)
  574 {
  575         struct vnode *vp = ap->a_vp;
  576         struct denode *dep = VTODE(vp);
  577         int error = 0;
  578 
  579 #ifdef MSDOSFS_DEBUG
  580         printf("msdosfs_inactive(): dep %p, de_Name[0] %x\n", dep, dep->de_Name[0]);
  581 #endif
  582 
  583         /*
  584          * Ignore denodes related to stale file handles.
  585          */
  586         if (dep->de_Name[0] == SLOT_DELETED || dep->de_Name[0] == SLOT_EMPTY)
  587                 goto out;
  588 
  589         /*
  590          * If the file has been deleted and it is on a read/write
  591          * filesystem, then truncate the file, and mark the directory slot
  592          * as empty.  (This may not be necessary for the dos filesystem.)
  593          */
  594 #ifdef MSDOSFS_DEBUG
  595         printf("msdosfs_inactive(): dep %p, refcnt %ld, mntflag %llx, MNT_RDONLY %llx\n",
  596             dep, dep->de_refcnt, (unsigned long long)vp->v_mount->mnt_flag,
  597             (unsigned long long)MNT_RDONLY);
  598 #endif
  599         if (dep->de_refcnt <= 0 && (vp->v_mount->mnt_flag & MNT_RDONLY) == 0) {
  600                 error = detrunc(dep, (u_long) 0, 0, NOCRED);
  601                 dep->de_flag |= DE_UPDATE;
  602                 dep->de_Name[0] = SLOT_DELETED;
  603         }
  604         deupdat(dep, 0);
  605 
  606 out:
  607         /*
  608          * If we are done with the denode, reclaim it
  609          * so that it can be reused immediately.
  610          */
  611 #ifdef MSDOSFS_DEBUG
  612         printf("msdosfs_inactive(): v_usecount %d, de_Name[0] %x\n",
  613                vrefcnt(vp), dep->de_Name[0]);
  614 #endif
  615         if (dep->de_Name[0] == SLOT_DELETED || dep->de_Name[0] == SLOT_EMPTY)
  616                 vrecycle(vp);
  617         return (error);
  618 }

Cache object: f2b40296f2802c1530c37e72668c99b5


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