Change the kernel dev_t, representing a pointer to a specinfo structure,
[dragonfly.git] / sys / vfs / msdosfs / msdosfs_denode.c
1 /* $FreeBSD: src/sys/msdosfs/msdosfs_denode.c,v 1.47.2.3 2002/08/22 16:20:15 trhodes Exp $ */
2 /* $DragonFly: src/sys/vfs/msdosfs/msdosfs_denode.c,v 1.26 2006/09/10 01:26:41 dillon Exp $ */
3 /*      $NetBSD: msdosfs_denode.c,v 1.28 1998/02/10 14:10:00 mrg Exp $  */
4
5 /*-
6  * Copyright (C) 1994, 1995, 1997 Wolfgang Solfrank.
7  * Copyright (C) 1994, 1995, 1997 TooLs GmbH.
8  * All rights reserved.
9  * Original code by Paul Popelka (paulp@uts.amdahl.com) (see below).
10  *
11  * Redistribution and use in source and binary forms, with or without
12  * modification, are permitted provided that the following conditions
13  * are met:
14  * 1. Redistributions of source code must retain the above copyright
15  *    notice, this list of conditions and the following disclaimer.
16  * 2. Redistributions in binary form must reproduce the above copyright
17  *    notice, this list of conditions and the following disclaimer in the
18  *    documentation and/or other materials provided with the distribution.
19  * 3. All advertising materials mentioning features or use of this software
20  *    must display the following acknowledgement:
21  *      This product includes software developed by TooLs GmbH.
22  * 4. The name of TooLs GmbH may not be used to endorse or promote products
23  *    derived from this software without specific prior written permission.
24  *
25  * THIS SOFTWARE IS PROVIDED BY TOOLS GMBH ``AS IS'' AND ANY EXPRESS OR
26  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
27  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
28  * IN NO EVENT SHALL TOOLS GMBH BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
29  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
30  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
31  * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
32  * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
33  * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
34  * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
35  */
36 /*
37  * Written by Paul Popelka (paulp@uts.amdahl.com)
38  *
39  * You can do anything you want with this software, just don't say you wrote
40  * it, and don't remove this notice.
41  *
42  * This software is provided "as is".
43  *
44  * The author supplies this software to be publicly redistributed on the
45  * understanding that the author is not responsible for the correct
46  * functioning of this software in any circumstances and is not liable for
47  * any damages caused by this software.
48  *
49  * October 1992
50  */
51
52 #include <sys/param.h>
53 #include <sys/systm.h>
54 #include <sys/kernel.h>
55 #include <sys/mount.h>
56 #include <sys/malloc.h>
57 #include <sys/proc.h>
58 #include <sys/buf.h>
59 #include <sys/vnode.h>
60
61 #include <vm/vm.h>
62 #include <vm/vm_extern.h>
63
64 #include "bpb.h"
65 #include "msdosfsmount.h"
66 #include "direntry.h"
67 #include "denode.h"
68 #include "fat.h"
69
70 static int msdosfs_hashins (struct denode *dep);
71 static void msdosfs_hashrem (struct denode *dep);
72
73 static MALLOC_DEFINE(M_MSDOSFSNODE, "MSDOSFS node", "MSDOSFS vnode private part");
74
75 static struct denode **dehashtbl;
76 static u_long dehash;                   /* size of hash table - 1 */
77 #define DEHASH(dev, dcl, doff)  (dehashtbl[(minor(dev) + (dcl) + (doff) /       \
78                                 sizeof(struct direntry)) & dehash])
79 static struct lwkt_token dehash_token;
80
81 union _qcvt {
82         quad_t qcvt;
83         long val[2];
84 };
85 #define SETHIGH(q, h) { \
86         union _qcvt tmp; \
87         tmp.qcvt = (q); \
88         tmp.val[_QUAD_HIGHWORD] = (h); \
89         (q) = tmp.qcvt; \
90 }
91 #define SETLOW(q, l) { \
92         union _qcvt tmp; \
93         tmp.qcvt = (q); \
94         tmp.val[_QUAD_LOWWORD] = (l); \
95         (q) = tmp.qcvt; \
96 }
97
98 static struct denode *
99                 msdosfs_hashget (cdev_t dev, u_long dirclust, u_long diroff);
100
101 /*ARGSUSED*/
102 int 
103 msdosfs_init(struct vfsconf *vfsp)
104 {
105         dehash = 16;
106         while (dehash < desiredvnodes)
107                 dehash <<= 1;
108         dehashtbl = kmalloc(sizeof(void *) * dehash, M_MSDOSFSMNT,
109                            M_WAITOK|M_ZERO);
110         --dehash;
111         lwkt_token_init(&dehash_token);
112         return (0);
113 }
114
115 int 
116 msdosfs_uninit(struct vfsconf *vfsp)
117 {
118
119         if (dehashtbl)
120                 kfree(dehashtbl, M_MSDOSFSMNT);
121         return (0);
122 }
123
124 static struct denode *
125 msdosfs_hashget(cdev_t dev, u_long dirclust, u_long diroff)
126 {
127         struct denode *dep;
128         lwkt_tokref ilock;
129         struct vnode *vp;
130
131         lwkt_gettoken(&ilock, &dehash_token);
132 loop:
133         for (dep = DEHASH(dev, dirclust, diroff); dep; dep = dep->de_next) {
134                 if (dirclust != dep->de_dirclust
135                     || diroff != dep->de_diroffset
136                     || dev != dep->de_dev
137                     || dep->de_refcnt == 0) {
138                         continue;
139                 }
140                 vp = DETOV(dep);
141                 if (vget(vp, LK_EXCLUSIVE))
142                         goto loop;
143
144                 /*
145                  * We must check to see if the inode has been ripped
146                  * out from under us after blocking.
147                  */
148                 for (dep = DEHASH(dev, dirclust, diroff); dep; dep = dep->de_next) {
149                         if (dirclust == dep->de_dirclust
150                             && diroff == dep->de_diroffset
151                             && dev == dep->de_dev
152                             && dep->de_refcnt != 0) {
153                                 break;
154                         }
155                 }
156                 if (dep == NULL || DETOV(dep) != vp) {
157                         vput(vp);
158                         goto loop;
159                 }
160                 lwkt_reltoken(&ilock);
161                 return (dep);
162         }
163         lwkt_reltoken(&ilock);
164         return (NULL);
165 }
166
167 static
168 int
169 msdosfs_hashins(struct denode *dep)
170 {
171         struct denode **depp, *deq;
172         lwkt_tokref ilock;
173
174         lwkt_gettoken(&ilock, &dehash_token);
175         depp = &DEHASH(dep->de_dev, dep->de_dirclust, dep->de_diroffset);
176         while ((deq = *depp) != NULL) {
177                 if (deq->de_dev == dep->de_dev &&
178                     deq->de_dirclust == dep->de_dirclust &&
179                     deq->de_diroffset == dep->de_diroffset) {
180                         lwkt_reltoken(&ilock);
181                         return(EBUSY);
182                 }
183                 depp = &deq->de_next;
184         }
185         dep->de_next = NULL;
186         *depp = dep;
187         lwkt_reltoken(&ilock);
188         return(0);
189 }
190
191 static
192 void
193 msdosfs_hashrem(struct denode *dep)
194 {
195         struct denode **depp, *deq;
196         lwkt_tokref ilock;
197
198         lwkt_gettoken(&ilock, &dehash_token);
199         depp = &DEHASH(dep->de_dev, dep->de_dirclust, dep->de_diroffset);
200         while ((deq = *depp) != NULL) {
201                 if (dep == deq)
202                         break;
203                 depp = &deq->de_next;
204         }
205         KKASSERT(dep == deq);
206         *depp = dep->de_next;
207         dep->de_next = NULL;
208         lwkt_reltoken(&ilock);
209 }
210
211 void
212 msdosfs_reinsert(struct denode *ip, u_long new_dirclust, u_long new_diroffset)
213 {
214         lwkt_tokref ilock;
215
216         lwkt_gettoken(&ilock, &dehash_token);
217         msdosfs_hashrem(ip);
218         ip->de_dirclust = new_dirclust;
219         ip->de_diroffset = new_diroffset;
220         msdosfs_hashins(ip);
221         lwkt_reltoken(&ilock);
222 }
223
224 /*
225  * If deget() succeeds it returns with the gotten denode locked().
226  *
227  * pmp       - address of msdosfsmount structure of the filesystem containing
228  *             the denode of interest.  The pm_dev field and the address of
229  *             the msdosfsmount structure are used.
230  * dirclust  - which cluster bp contains, if dirclust is 0 (root directory)
231  *             diroffset is relative to the beginning of the root directory,
232  *             otherwise it is cluster relative.
233  * diroffset - offset past begin of cluster of denode we want
234  * depp      - returns the address of the gotten denode.
235  */
236 int
237 deget(struct msdosfsmount *pmp, /* so we know the maj/min number */
238       u_long dirclust,          /* cluster this dir entry came from */
239       u_long diroffset,         /* index of entry within the cluster */
240       struct denode **depp)     /* returns the addr of the gotten denode */
241 {
242         int error;
243         cdev_t dev = pmp->pm_dev;
244         struct mount *mntp = pmp->pm_mountp;
245         struct direntry *direntptr;
246         struct denode *ldep;
247         struct vnode *nvp;
248         struct buf *bp;
249         struct timeval tv;
250
251 #ifdef MSDOSFS_DEBUG
252         printf("deget(pmp %p, dirclust %lu, diroffset %lx, depp %p)\n",
253             pmp, dirclust, diroffset, depp);
254 #endif
255
256         /*
257          * On FAT32 filesystems, root is a (more or less) normal
258          * directory
259          */
260         if (FAT32(pmp) && dirclust == MSDOSFSROOT)
261                 dirclust = pmp->pm_rootdirblk;
262
263 again:
264         /*
265          * See if the denode is in the denode cache. Use the location of
266          * the directory entry to compute the hash value. For subdir use
267          * address of "." entry. For root dir (if not FAT32) use cluster
268          * MSDOSFSROOT, offset MSDOSFSROOT_OFS
269          *
270          * NOTE: The check for de_refcnt > 0 below insures the denode being
271          * examined does not represent an unlinked but still open file.
272          * These files are not to be accessible even when the directory
273          * entry that represented the file happens to be reused while the
274          * deleted file is still open.
275          */
276         ldep = msdosfs_hashget(dev, dirclust, diroffset);
277         if (ldep) {
278                 *depp = ldep;
279                 return (0);
280         }
281
282         /*
283          * Do the MALLOC before the getnewvnode since doing so afterward
284          * might cause a bogus v_data pointer to get dereferenced
285          * elsewhere if MALLOC should block.
286          */
287         MALLOC(ldep, struct denode *, sizeof(struct denode), M_MSDOSFSNODE, M_WAITOK);
288
289         /*
290          * Directory entry was not in cache, have to create a vnode and
291          * copy it from the passed disk buffer.
292          */
293
294         /* getnewvnode() does a vref() on the vnode */
295         error = getnewvnode(VT_MSDOSFS, mntp, &nvp, VLKTIMEOUT, 0);
296         if (error) {
297                 *depp = NULL;
298                 FREE(ldep, M_MSDOSFSNODE);
299                 return error;
300         }
301
302         bzero((caddr_t)ldep, sizeof *ldep);
303         ldep->de_vnode = nvp;
304         ldep->de_flag = 0;
305         ldep->de_devvp = 0;
306         ldep->de_dev = dev;
307         ldep->de_dirclust = dirclust;
308         ldep->de_diroffset = diroffset;
309         fc_purge(ldep, 0);      /* init the fat cache for this denode */
310
311         /*
312          * Insert the denode into the hash queue.  If a collision occurs
313          * throw away the vnode and try again.
314          */
315         if (msdosfs_hashins(ldep) != 0) {
316                 printf("debug: msdosfs: hashins collision, retrying\n");
317                 vx_put(nvp);
318                 kfree(ldep, M_MSDOSFSNODE);
319                 goto again;
320         }
321         nvp->v_data = ldep;
322         ldep->de_pmp = pmp;
323         ldep->de_refcnt = 1;
324         /*
325          * Copy the directory entry into the denode area of the vnode.
326          */
327         if ((dirclust == MSDOSFSROOT
328              || (FAT32(pmp) && dirclust == pmp->pm_rootdirblk))
329             && diroffset == MSDOSFSROOT_OFS) {
330                 /*
331                  * Directory entry for the root directory. There isn't one,
332                  * so we manufacture one. We should probably rummage
333                  * through the root directory and find a label entry (if it
334                  * exists), and then use the time and date from that entry
335                  * as the time and date for the root denode.
336                  */
337                 nvp->v_flag |= VROOT; /* should be further down         XXX */
338
339                 ldep->de_Attributes = ATTR_DIRECTORY;
340                 ldep->de_LowerCase = 0;
341                 if (FAT32(pmp))
342                         ldep->de_StartCluster = pmp->pm_rootdirblk;
343                         /* de_FileSize will be filled in further down */
344                 else {
345                         ldep->de_StartCluster = MSDOSFSROOT;
346                         ldep->de_FileSize = pmp->pm_rootdirsize * DEV_BSIZE;
347                 }
348                 /*
349                  * fill in time and date so that dos2unixtime() doesn't
350                  * spit up when called from msdosfs_getattr() with root
351                  * denode
352                  */
353                 ldep->de_CHun = 0;
354                 ldep->de_CTime = 0x0000;        /* 00:00:00      */
355                 ldep->de_CDate = (0 << DD_YEAR_SHIFT) | (1 << DD_MONTH_SHIFT)
356                     | (1 << DD_DAY_SHIFT);
357                 /* Jan 1, 1980   */
358                 ldep->de_ADate = ldep->de_CDate;
359                 ldep->de_MTime = ldep->de_CTime;
360                 ldep->de_MDate = ldep->de_CDate;
361                 /* leave the other fields as garbage */
362         } else {
363                 error = readep(pmp, dirclust, diroffset, &bp, &direntptr);
364                 if (error) {
365                         /*
366                          * The denode does not contain anything useful, so
367                          * it would be wrong to leave it on its hash chain.
368                          * Arrange for vput() to just forget about it.
369                          */
370                         ldep->de_Name[0] = SLOT_DELETED;
371
372                         vx_put(nvp);
373                         *depp = NULL;
374                         return (error);
375                 }
376                 DE_INTERNALIZE(ldep, direntptr);
377                 brelse(bp);
378         }
379
380         /*
381          * Fill in a few fields of the vnode and finish filling in the
382          * denode.  Then return the address of the found denode.
383          */
384         if (ldep->de_Attributes & ATTR_DIRECTORY) {
385                 /*
386                  * Since DOS directory entries that describe directories
387                  * have 0 in the filesize field, we take this opportunity
388                  * to find out the length of the directory and plug it into
389                  * the denode structure.
390                  */
391                 u_long size;
392
393                 /*
394                  * XXX Sometimes, these arrives that . entry have cluster
395                  * number 0, when it shouldn't.  Use real cluster number
396                  * instead of what is written in directory entry.
397                  */
398                 if ((diroffset == 0) && (ldep->de_StartCluster != dirclust)) {
399                         printf("deget(): . entry at clust %ld != %ld\n",
400                                         dirclust, ldep->de_StartCluster);
401                         ldep->de_StartCluster = dirclust;
402                 }
403
404                 nvp->v_type = VDIR;
405                 if (ldep->de_StartCluster != MSDOSFSROOT) {
406                         error = pcbmap(ldep, 0xffff, NULL, &size, NULL);
407                         if (error == E2BIG) {
408                                 ldep->de_FileSize = de_cn2off(pmp, size);
409                                 error = 0;
410                         } else
411                                 printf("deget(): pcbmap returned %d\n", error);
412                 }
413         } else {
414                 nvp->v_type = VREG;
415         }
416         getmicrouptime(&tv);
417         SETHIGH(ldep->de_modrev, tv.tv_sec);
418         SETLOW(ldep->de_modrev, tv.tv_usec * 4294);
419         ldep->de_devvp = pmp->pm_devvp;
420         vref(ldep->de_devvp);
421         vinitvmio(nvp, ldep->de_FileSize);
422         /*
423          * Leave nvp locked and refd so the returned inode is effectively
424          * locked and refd.
425          */
426         *depp = ldep;
427         return (0);
428 }
429
430 int
431 deupdat(struct denode *dep, int waitfor)
432 {
433         int error;
434         struct buf *bp;
435         struct direntry *dirp;
436         struct timespec ts;
437
438         if (DETOV(dep)->v_mount->mnt_flag & MNT_RDONLY)
439                 return (0);
440         getnanotime(&ts);
441         DETIMES(dep, &ts, &ts, &ts);
442         if ((dep->de_flag & DE_MODIFIED) == 0)
443                 return (0);
444         dep->de_flag &= ~DE_MODIFIED;
445         if (dep->de_Attributes & ATTR_DIRECTORY)
446                 return (0);
447         if (dep->de_refcnt <= 0)
448                 return (0);
449         error = readde(dep, &bp, &dirp);
450         if (error)
451                 return (error);
452         DE_EXTERNALIZE(dirp, dep);
453         if (waitfor)
454                 return (bwrite(bp));
455         else {
456                 bdwrite(bp);
457                 return (0);
458         }
459 }
460
461 /*
462  * Truncate the file described by dep to the length specified by length.
463  */
464 int
465 detrunc(struct denode *dep, u_long length, int flags)
466 {
467         int error;
468         int allerror;
469         u_long eofentry;
470         u_long chaintofree;
471         daddr_t bn, cn;
472         int boff;
473         int isadir = dep->de_Attributes & ATTR_DIRECTORY;
474         struct buf *bp;
475         struct msdosfsmount *pmp = dep->de_pmp;
476
477 #ifdef MSDOSFS_DEBUG
478         printf("detrunc(): file %s, length %lu, flags %x\n", dep->de_Name, length, flags);
479 #endif
480
481         /*
482          * Disallow attempts to truncate the root directory since it is of
483          * fixed size.  That's just the way dos filesystems are.  We use
484          * the VROOT bit in the vnode because checking for the directory
485          * bit and a startcluster of 0 in the denode is not adequate to
486          * recognize the root directory at this point in a file or
487          * directory's life.
488          */
489         if ((DETOV(dep)->v_flag & VROOT) && !FAT32(pmp)) {
490                 printf("detrunc(): can't truncate root directory, clust %ld, offset %ld\n",
491                     dep->de_dirclust, dep->de_diroffset);
492                 return (EINVAL);
493         }
494
495
496         if (dep->de_FileSize < length) {
497                 vnode_pager_setsize(DETOV(dep), length);
498                 return deextend(dep, length);
499         }
500
501         /*
502          * If the desired length is 0 then remember the starting cluster of
503          * the file and set the StartCluster field in the directory entry
504          * to 0.  If the desired length is not zero, then get the number of
505          * the last cluster in the shortened file.  Then get the number of
506          * the first cluster in the part of the file that is to be freed.
507          * Then set the next cluster pointer in the last cluster of the
508          * file to CLUST_EOFE.
509          */
510         if (length == 0) {
511                 chaintofree = dep->de_StartCluster;
512                 dep->de_StartCluster = 0;
513                 eofentry = ~0;
514         } else {
515                 error = pcbmap(dep, de_clcount(pmp, length) - 1,
516                                NULL, &eofentry, NULL);
517                 if (error) {
518 #ifdef MSDOSFS_DEBUG
519                         printf("detrunc(): pcbmap fails %d\n", error);
520 #endif
521                         return (error);
522                 }
523         }
524
525         fc_purge(dep, de_clcount(pmp, length));
526
527         /*
528          * If the new length is not a multiple of the cluster size then we
529          * must zero the tail end of the new last cluster in case it
530          * becomes part of the file again because of a seek.
531          */
532         if ((boff = length & pmp->pm_crbomask) != 0) {
533                 if (isadir) {
534                         bn = xcntobn(pmp, eofentry);
535                         error = bread(pmp->pm_devvp, de_bntodoff(pmp, bn), pmp->pm_bpcluster, &bp);
536                 } else {
537                         cn = de_cluster(pmp, length);
538                         error = bread(DETOV(dep), de_cn2doff(pmp, cn), pmp->pm_bpcluster, &bp);
539                 }
540                 if (error) {
541                         brelse(bp);
542 #ifdef MSDOSFS_DEBUG
543                         printf("detrunc(): bread fails %d\n", error);
544 #endif
545                         return (error);
546                 }
547                 /*
548                  * is this the right place for it?
549                  */
550                 bzero(bp->b_data + boff, pmp->pm_bpcluster - boff);
551                 if (flags & IO_SYNC)
552                         bwrite(bp);
553                 else
554                         bdwrite(bp);
555         }
556
557         /*
558          * Write out the updated directory entry.  Even if the update fails
559          * we free the trailing clusters.
560          */
561         dep->de_FileSize = length;
562         if (!isadir)
563                 dep->de_flag |= DE_UPDATE|DE_MODIFIED;
564         allerror = vtruncbuf(DETOV(dep), length, pmp->pm_bpcluster);
565 #ifdef MSDOSFS_DEBUG
566         if (allerror)
567                 printf("detrunc(): vtruncbuf error %d\n", allerror);
568 #endif
569         error = deupdat(dep, 1);
570         if (error && (allerror == 0))
571                 allerror = error;
572 #ifdef MSDOSFS_DEBUG
573         printf("detrunc(): allerror %d, eofentry %lu\n",
574                allerror, eofentry);
575 #endif
576
577         /*
578          * If we need to break the cluster chain for the file then do it
579          * now.
580          */
581         if (eofentry != ~0) {
582                 error = fatentry(FAT_GET_AND_SET, pmp, eofentry,
583                                  &chaintofree, CLUST_EOFE);
584                 if (error) {
585 #ifdef MSDOSFS_DEBUG
586                         printf("detrunc(): fatentry errors %d\n", error);
587 #endif
588                         return (error);
589                 }
590                 fc_setcache(dep, FC_LASTFC, de_cluster(pmp, length - 1),
591                             eofentry);
592         }
593
594         /*
595          * Now free the clusters removed from the file because of the
596          * truncation.
597          */
598         if (chaintofree != 0 && !MSDOSFSEOF(pmp, chaintofree))
599                 freeclusterchain(pmp, chaintofree);
600
601         return (allerror);
602 }
603
604 /*
605  * Extend the file described by dep to length specified by length.
606  */
607 int
608 deextend(struct denode *dep, u_long length)
609 {
610         struct msdosfsmount *pmp = dep->de_pmp;
611         u_long count;
612         int error;
613
614         /*
615          * The root of a DOS filesystem cannot be extended.
616          */
617         if ((DETOV(dep)->v_flag & VROOT) && !FAT32(pmp))
618                 return (EINVAL);
619
620         /*
621          * Directories cannot be extended.
622          */
623         if (dep->de_Attributes & ATTR_DIRECTORY)
624                 return (EISDIR);
625
626         if (length <= dep->de_FileSize)
627                 panic("deextend: file too large");
628
629         /*
630          * Compute the number of clusters to allocate.
631          */
632         count = de_clcount(pmp, length) - de_clcount(pmp, dep->de_FileSize);
633         if (count > 0) {
634                 if (count > pmp->pm_freeclustercount)
635                         return (ENOSPC);
636                 error = extendfile(dep, count, NULL, NULL, DE_CLEAR);
637                 if (error) {
638                         /* truncate the added clusters away again */
639                         detrunc(dep, dep->de_FileSize, 0);
640                         return (error);
641                 }
642         }
643         dep->de_FileSize = length;
644         dep->de_flag |= DE_UPDATE|DE_MODIFIED;
645         return (deupdat(dep, 1));
646 }
647
648 /*
649  * msdosfs_reclaim(struct vnode *a_vp)
650  */
651 int
652 msdosfs_reclaim(struct vop_reclaim_args *ap)
653 {
654         struct vnode *vp = ap->a_vp;
655         struct denode *dep = VTODE(vp);
656
657 #ifdef MSDOSFS_DEBUG
658         printf("msdosfs_reclaim(): dep %p, file %s, refcnt %ld\n",
659             dep, dep ? dep->de_Name : "?", dep ? dep->de_refcnt : -1);
660 #endif
661
662         if (prtactive && vp->v_usecount != 0)
663                 vprint("msdosfs_reclaim(): pushing active", vp);
664         /*
665          * Remove the denode from its hash chain.
666          */
667         vp->v_data = NULL;
668         if (dep) {
669                 msdosfs_hashrem(dep);
670                 if (dep->de_devvp) {
671                         vrele(dep->de_devvp);
672                         dep->de_devvp = 0;
673                 }
674                 kfree(dep, M_MSDOSFSNODE);
675         }
676         return (0);
677 }
678
679 /*
680  * msdosfs_inactive(struct vnode *a_vp, struct thread *a_td)
681  */
682 int
683 msdosfs_inactive(struct vop_inactive_args *ap)
684 {
685         struct vnode *vp = ap->a_vp;
686         struct denode *dep = VTODE(vp);
687         int error = 0;
688
689 #ifdef MSDOSFS_DEBUG
690         printf("msdosfs_inactive(): dep %p, de_Name[0] %x\n", dep, dep->de_Name[0]);
691 #endif
692
693         if (prtactive && vp->v_usecount != 0)
694                 vprint("msdosfs_inactive(): pushing active", vp);
695
696         /*
697          * Ignore denodes related to stale file handles.
698          */
699         if (dep->de_Name[0] == SLOT_DELETED)
700                 goto out;
701
702         /*
703          * If the file has been deleted and it is on a read/write
704          * filesystem, then truncate the file, and mark the directory slot
705          * as empty.  (This may not be necessary for the dos filesystem.)
706          */
707 #ifdef MSDOSFS_DEBUG
708         printf("msdosfs_inactive(): dep %p, refcnt %ld, mntflag %x, MNT_RDONLY %x\n",
709                dep, dep->de_refcnt, vp->v_mount->mnt_flag, MNT_RDONLY);
710 #endif
711         if (dep->de_refcnt <= 0 && (vp->v_mount->mnt_flag & MNT_RDONLY) == 0) {
712                 error = detrunc(dep, (u_long) 0, 0);
713                 dep->de_flag |= DE_UPDATE;
714                 dep->de_Name[0] = SLOT_DELETED;
715         }
716         deupdat(dep, 0);
717
718 out:
719         /*
720          * If we are done with the denode, reclaim it
721          * so that it can be reused immediately.
722          */
723 #ifdef MSDOSFS_DEBUG
724         printf("msdosfs_inactive(): v_usecount %d, de_Name[0] %x\n", vp->v_usecount,
725                dep->de_Name[0]);
726 #endif
727         if (dep->de_Name[0] == SLOT_DELETED)
728                 vrecycle(vp);
729         return (error);
730 }