From d566c1cf874d15ca02020894ff0af62c4e39e7bb Mon Sep 17 00:00:00 2001
From: Chaskiel M Grundman <cg2v@andrew.cmu.edu>
Date: Wed, 13 Oct 2004 01:51:00 +0000
Subject: [PATCH] dread-do-validation-20041012

FIXES 15340

so we can do directory object validation in DRead()
---
 src/afs/LINUX/osi_vnodeops.c     |  4 ++--
 src/afs/VNOPS/afs_vnop_create.c  |  8 ++++----
 src/afs/VNOPS/afs_vnop_dirops.c  | 10 +++++-----
 src/afs/VNOPS/afs_vnop_link.c    |  4 ++--
 src/afs/VNOPS/afs_vnop_lookup.c  | 12 ++++++------
 src/afs/VNOPS/afs_vnop_readdir.c | 26 +++++---------------------
 src/afs/VNOPS/afs_vnop_remove.c  |  6 +++---
 src/afs/VNOPS/afs_vnop_rename.c  | 22 +++++++++++-----------
 src/afs/VNOPS/afs_vnop_symlink.c |  4 ++--
 src/afs/afs.h                    |  2 +-
 src/afs/afs_buffer.c             | 21 ++++++++++-----------
 src/afs/afs_dcache.c             |  6 +++---
 src/afs/afs_osi.h                |  6 +++---
 src/afs/afs_pioctl.c             | 10 +++++-----
 src/afs/afs_prototypes.h         |  6 +++---
 src/afs/afs_segments.c           |  2 +-
 16 files changed, 66 insertions(+), 83 deletions(-)

diff --git a/src/afs/LINUX/osi_vnodeops.c b/src/afs/LINUX/osi_vnodeops.c
index 6af8d17ea..c09561a1f 100644
--- a/src/afs/LINUX/osi_vnodeops.c
+++ b/src/afs/LINUX/osi_vnodeops.c
@@ -333,11 +333,11 @@ afs_linux_readdir(struct file *fp, void *dirbuf, filldir_t filldir)
     code = 0;
     offset = (int) fp->f_pos;
     while (1) {
-	dirpos = BlobScan(&tdc->f.inode, offset);
+	dirpos = BlobScan(&tdc->f, offset);
 	if (!dirpos)
 	    break;
 
-	de = afs_dir_GetBlob(&tdc->f.inode, dirpos);
+	de = afs_dir_GetBlob(&tdc->f, dirpos);
 	if (!de)
 	    break;
 
diff --git a/src/afs/VNOPS/afs_vnop_create.c b/src/afs/VNOPS/afs_vnop_create.c
index ad0f0e0c8..c16f411b9 100644
--- a/src/afs/VNOPS/afs_vnop_create.c
+++ b/src/afs/VNOPS/afs_vnop_create.c
@@ -154,7 +154,7 @@ afs_create(OSI_VC_DECL(adp), char *aname, struct vattr *attrs,
     if (tdc) {
 	/* see if file already exists.  If it does, we only set 
 	 * the size attributes (to handle O_TRUNC) */
-	code = afs_dir_Lookup(&tdc->f.inode, aname, &newFid.Fid);	/* use dnlc first xxx */
+	code = afs_dir_Lookup(&tdc->f, aname, &newFid.Fid);	/* use dnlc first xxx */
 	if (code == 0) {
 	    ReleaseSharedLock(&tdc->lock);
 	    afs_PutDCache(tdc);
@@ -368,10 +368,10 @@ afs_create(OSI_VC_DECL(adp), char *aname, struct vattr *attrs,
 	UpgradeSToWLock(&tdc->lock, 631);
     if (afs_LocalHero(adp, tdc, &OutDirStatus, 1)) {
 	/* we can do it locally */
-	code = afs_dir_Create(&tdc->f.inode, aname, &newFid.Fid);
+	code = afs_dir_Create(&tdc->f, aname, &newFid.Fid);
 	if (code) {
 	    ZapDCE(tdc);
-	    DZap(&tdc->f.inode);
+	    DZap(&tdc->f);
 	}
     }
     if (tdc) {
@@ -531,7 +531,7 @@ afs_LocalHero(register struct vcache *avc, register struct dcache *adc,
     } else {
 	if (adc) {
 	    ZapDCE(adc);
-	    DZap(&adc->f.inode);
+	    DZap(&adc->f);
 	}
 	if (avc->states & CStatd) {
 	    osi_dnlc_purgedp(avc);
diff --git a/src/afs/VNOPS/afs_vnop_dirops.c b/src/afs/VNOPS/afs_vnop_dirops.c
index 8f71cd136..0cd7cedd5 100644
--- a/src/afs/VNOPS/afs_vnop_dirops.c
+++ b/src/afs/VNOPS/afs_vnop_dirops.c
@@ -147,10 +147,10 @@ afs_mkdir(OSI_VC_ARG(adp), aname, attrs, avcp, acred)
 	ObtainWriteLock(&tdc->lock, 632);
     if (afs_LocalHero(adp, tdc, &OutDirStatus, 1)) {
 	/* we can do it locally */
-	code = afs_dir_Create(&tdc->f.inode, aname, &newFid.Fid);
+	code = afs_dir_Create(&tdc->f, aname, &newFid.Fid);
 	if (code) {
 	    ZapDCE(tdc);	/* surprise error -- use invalid value */
-	    DZap(&tdc->f.inode);
+	    DZap(&tdc->f);
 	}
     }
     if (tdc) {
@@ -250,7 +250,7 @@ afs_rmdir(adp, aname, acred)
 	struct VenusFid unlinkFid;
 
 	unlinkFid.Fid.Vnode = 0;
-	code = afs_dir_Lookup(&tdc->f.inode, aname, &unlinkFid.Fid);
+	code = afs_dir_Lookup(&tdc->f, aname, &unlinkFid.Fid);
 	if (code == 0) {
 	    afs_int32 cached = 0;
 
@@ -304,10 +304,10 @@ afs_rmdir(adp, aname, acred)
 	UpgradeSToWLock(&tdc->lock, 634);
     if (afs_LocalHero(adp, tdc, &OutDirStatus, 1)) {
 	/* we can do it locally */
-	code = afs_dir_Delete(&tdc->f.inode, aname);
+	code = afs_dir_Delete(&tdc->f, aname);
 	if (code) {
 	    ZapDCE(tdc);	/* surprise error -- invalid value */
-	    DZap(&tdc->f.inode);
+	    DZap(&tdc->f);
 	}
     }
     if (tdc) {
diff --git a/src/afs/VNOPS/afs_vnop_link.c b/src/afs/VNOPS/afs_vnop_link.c
index e48ca7831..22ac2bc1c 100644
--- a/src/afs/VNOPS/afs_vnop_link.c
+++ b/src/afs/VNOPS/afs_vnop_link.c
@@ -137,10 +137,10 @@ afs_link(avc, OSI_VC_ARG(adp), aname, acred)
 	ObtainWriteLock(&tdc->lock, 635);
     if (afs_LocalHero(adp, tdc, &OutDirStatus, 1)) {
 	/* we can do it locally */
-	code = afs_dir_Create(&tdc->f.inode, aname, &avc->fid.Fid);
+	code = afs_dir_Create(&tdc->f, aname, &avc->fid.Fid);
 	if (code) {
 	    ZapDCE(tdc);	/* surprise error -- invalid value */
-	    DZap(&tdc->f.inode);
+	    DZap(&tdc->f);
 	}
     }
     if (tdc) {
diff --git a/src/afs/VNOPS/afs_vnop_lookup.c b/src/afs/VNOPS/afs_vnop_lookup.c
index bb908163d..8add8d8c7 100644
--- a/src/afs/VNOPS/afs_vnop_lookup.c
+++ b/src/afs/VNOPS/afs_vnop_lookup.c
@@ -674,7 +674,7 @@ afs_DoBulkStat(struct vcache *adp, long dirCookie, struct vrequest *areqp)
 	/* look for first safe entry to examine in the directory.  BlobScan
 	 * looks for a the 1st allocated dir after the dirCookie slot.
 	 */
-	newIndex = BlobScan(&dcp->f.inode, (dirCookie >> 5));
+	newIndex = BlobScan(&dcp->f, (dirCookie >> 5));
 	if (newIndex == 0)
 	    break;
 
@@ -683,7 +683,7 @@ afs_DoBulkStat(struct vcache *adp, long dirCookie, struct vrequest *areqp)
 
 	/* get a ptr to the dir entry */
 	dirEntryp =
-	    (struct DirEntry *)afs_dir_GetBlob(&dcp->f.inode, newIndex);
+	    (struct DirEntry *)afs_dir_GetBlob(&dcp->f, newIndex);
 	if (!dirEntryp)
 	    break;
 
@@ -1293,7 +1293,7 @@ afs_lookup(adp, aname, avcp, acred)
     {				/* sub-block just to reduce stack usage */
 	register struct dcache *tdc;
 	afs_size_t dirOffset, dirLen;
-	ino_t theDir;
+	struct fcache *theDir;
 	struct VenusFid tfid;
 
 	/* now we have to lookup the next fid */
@@ -1351,15 +1351,15 @@ afs_lookup(adp, aname, avcp, acred)
 
 	/* lookup the name in the appropriate dir, and return a cache entry
 	 * on the resulting fid */
-	theDir = tdc->f.inode;
+	theDir = &tdc->f;
 	code =
-	    afs_dir_LookupOffset(&theDir, sysState.name, &tfid.Fid,
+	    afs_dir_LookupOffset(theDir, sysState.name, &tfid.Fid,
 				 &dirCookie);
 
 	/* If the first lookup doesn't succeed, maybe it's got @sys in the name */
 	while (code == ENOENT && Next_AtSys(adp, &treq, &sysState))
 	    code =
-		afs_dir_LookupOffset(&theDir, sysState.name, &tfid.Fid,
+		afs_dir_LookupOffset(theDir, sysState.name, &tfid.Fid,
 				     &dirCookie);
 	tname = sysState.name;
 
diff --git a/src/afs/VNOPS/afs_vnop_readdir.c b/src/afs/VNOPS/afs_vnop_readdir.c
index c681c136a..d1d0330ae 100644
--- a/src/afs/VNOPS/afs_vnop_readdir.c
+++ b/src/afs/VNOPS/afs_vnop_readdir.c
@@ -66,24 +66,8 @@ extern struct DirEntry *afs_dir_GetBlob();
     BlobScan is used by the Linux port in a separate file, so it should not
     become static.
 */
-#if defined(AFS_SGI62_ENV) || defined(AFS_SUN57_64BIT_ENV)
 int
-BlobScan(ino64_t * afile, afs_int32 ablob)
-#else
-#if defined(AFS_HPUX1123_ENV)
-/*DEE should use afs_inode_t for all */
-int
-BlobScan(ino_t * afile, afs_int32 ablob)
-#else
-#ifdef AFS_LINUX_64BIT_KERNEL
-int
-BlobScan(long *afile, afs_int32 ablob)
-#else
-int
-BlobScan(afs_int32 * afile, afs_int32 ablob)
-#endif
-#endif
-#endif
+BlobScan(struct fcache * afile, afs_int32 ablob)
 {
     register afs_int32 relativeBlob;
     afs_int32 pageBlob;
@@ -657,8 +641,8 @@ afs_readdir(OSI_VC_ARG(avc), auio, acred)
 	origOffset = auio->afsio_offset;
 	/* scan for the next interesting entry scan for in-use blob otherwise up point at
 	 * this blob note that ode, if non-zero, also represents a held dir page */
-	if (!(us = BlobScan(&tdc->f.inode, (origOffset >> 5)))
-	    || !(nde = (struct DirEntry *)afs_dir_GetBlob(&tdc->f.inode, us))) {
+	if (!(us = BlobScan(&tdc->f, (origOffset >> 5)))
+	    || !(nde = (struct DirEntry *)afs_dir_GetBlob(&tdc->f, us))) {
 	    /* failed to setup nde, return what we've got, and release ode */
 	    if (len) {
 		/* something to hand over. */
@@ -948,8 +932,8 @@ afs1_readdir(avc, auio, acred)
 
 	/* scan for the next interesting entry scan for in-use blob otherwise up point at
 	 * this blob note that ode, if non-zero, also represents a held dir page */
-	if (!(us = BlobScan(&tdc->f.inode, (origOffset >> 5)))
-	    || !(nde = (struct DirEntry *)afs_dir_GetBlob(&tdc->f.inode, us))) {
+	if (!(us = BlobScan(&tdc->f, (origOffset >> 5)))
+	    || !(nde = (struct DirEntry *)afs_dir_GetBlob(&tdc->f, us))) {
 	    /* failed to setup nde, return what we've got, and release ode */
 	    if (len) {
 		/* something to hand over. */
diff --git a/src/afs/VNOPS/afs_vnop_remove.c b/src/afs/VNOPS/afs_vnop_remove.c
index 7b2583310..363bc2290 100644
--- a/src/afs/VNOPS/afs_vnop_remove.c
+++ b/src/afs/VNOPS/afs_vnop_remove.c
@@ -154,10 +154,10 @@ afsremove(register struct vcache *adp, register struct dcache *tdc,
 	UpgradeSToWLock(&tdc->lock, 637);
     if (afs_LocalHero(adp, tdc, &OutDirStatus, 1)) {
 	/* we can do it locally */
-	code = afs_dir_Delete(&tdc->f.inode, aname);
+	code = afs_dir_Delete(&tdc->f, aname);
 	if (code) {
 	    ZapDCE(tdc);	/* surprise error -- invalid value */
-	    DZap(&tdc->f.inode);
+	    DZap(&tdc->f);
 	}
     }
     if (tdc) {
@@ -357,7 +357,7 @@ afs_remove(OSI_VC_ARG(adp), aname, acred)
      * done the work */
     if (!tvc)
 	if (tdc) {
-	    code = afs_dir_Lookup(&tdc->f.inode, aname, &unlinkFid.Fid);
+	    code = afs_dir_Lookup(&tdc->f, aname, &unlinkFid.Fid);
 	    if (code == 0) {
 		afs_int32 cached = 0;
 
diff --git a/src/afs/VNOPS/afs_vnop_rename.c b/src/afs/VNOPS/afs_vnop_rename.c
index cd71a798f..642c421e7 100644
--- a/src/afs/VNOPS/afs_vnop_rename.c
+++ b/src/afs/VNOPS/afs_vnop_rename.c
@@ -146,7 +146,7 @@ afsrename(struct vcache *aodp, char *aname1, struct vcache *andp,
     }
 
     if (code == 0)
-	code = afs_dir_Lookup(&tdc1->f.inode, aname1, &fileFid.Fid);
+	code = afs_dir_Lookup(&tdc1->f, aname1, &fileFid.Fid);
     if (code) {
 	if (tdc1) {
 	    ReleaseWriteLock(&tdc1->lock);
@@ -205,38 +205,38 @@ afsrename(struct vcache *aodp, char *aname1, struct vcache *andp,
 	    if (!doLocally) {
 		if (tdc1) {
 		    ZapDCE(tdc1);
-		    DZap(&tdc1->f.inode);
+		    DZap(&tdc1->f);
 		}
 		if (tdc2) {
 		    ZapDCE(tdc2);
-		    DZap(&tdc2->f.inode);
+		    DZap(&tdc2->f);
 		}
 	    }
 	}
 	/* now really do the work */
 	if (doLocally) {
 	    /* first lookup the fid of the dude we're moving */
-	    code = afs_dir_Lookup(&tdc1->f.inode, aname1, &fileFid.Fid);
+	    code = afs_dir_Lookup(&tdc1->f, aname1, &fileFid.Fid);
 	    if (code == 0) {
 		/* delete the source */
-		code = afs_dir_Delete(&tdc1->f.inode, aname1);
+		code = afs_dir_Delete(&tdc1->f, aname1);
 	    }
 	    /* first see if target is there */
 	    if (code == 0
-		&& afs_dir_Lookup(&tdc2->f.inode, aname2,
+		&& afs_dir_Lookup(&tdc2->f, aname2,
 				  &unlinkFid.Fid) == 0) {
 		/* target already exists, and will be unlinked by server */
-		code = afs_dir_Delete(&tdc2->f.inode, aname2);
+		code = afs_dir_Delete(&tdc2->f, aname2);
 	    }
 	    if (code == 0) {
-		code = afs_dir_Create(&tdc2->f.inode, aname2, &fileFid.Fid);
+		code = afs_dir_Create(&tdc2->f, aname2, &fileFid.Fid);
 	    }
 	    if (code != 0) {
 		ZapDCE(tdc1);
-		DZap(&tdc1->f.inode);
+		DZap(&tdc1->f);
 		if (!oneDir) {
 		    ZapDCE(tdc2);
-		    DZap(&tdc2->f.inode);
+		    DZap(&tdc2->f);
 		}
 	    }
 	}
@@ -339,7 +339,7 @@ afsrename(struct vcache *aodp, char *aname1, struct vcache *andp,
 	    if (tdc1) {
 		ObtainWriteLock(&tdc1->lock, 648);
 		ZapDCE(tdc1);	/* mark as unknown */
-		DZap(&tdc1->f.inode);
+		DZap(&tdc1->f);
 		ReleaseWriteLock(&tdc1->lock);
 		afs_PutDCache(tdc1);	/* put it back */
 	    }
diff --git a/src/afs/VNOPS/afs_vnop_symlink.c b/src/afs/VNOPS/afs_vnop_symlink.c
index b33f970b4..cd5008d5c 100644
--- a/src/afs/VNOPS/afs_vnop_symlink.c
+++ b/src/afs/VNOPS/afs_vnop_symlink.c
@@ -184,10 +184,10 @@ int afs_symlink
     /* otherwise, we should see if we can make the change to the dir locally */
     if (afs_LocalHero(adp, tdc, &OutDirStatus, 1)) {
 	/* we can do it locally */
-	code = afs_dir_Create(&tdc->f.inode, aname, &newFid.Fid);
+	code = afs_dir_Create(&tdc->f, aname, &newFid.Fid);
 	if (code) {
 	    ZapDCE(tdc);	/* surprise error -- use invalid value */
-	    DZap(&tdc->f.inode);
+	    DZap(&tdc->f);
 	}
     }
     if (tdc) {
diff --git a/src/afs/afs.h b/src/afs/afs.h
index 75e58d1ed..2c80435f2 100644
--- a/src/afs/afs.h
+++ b/src/afs/afs.h
@@ -1195,7 +1195,7 @@ struct afs_fakestat_state {
 extern int afs_fakestat_enable;
 
 struct buffer {
-    ino_t fid[1];		/* Unique cache key + i/o addressing */
+    struct fcache *fid;
     afs_int32 page;
     afs_int32 accesstime;
     struct buffer *hashNext;
diff --git a/src/afs/afs_buffer.c b/src/afs/afs_buffer.c
index 47a24d4d1..0b56b262f 100644
--- a/src/afs/afs_buffer.c
+++ b/src/afs/afs_buffer.c
@@ -63,7 +63,7 @@ RCSID
 /* page hash table size - this is pretty intertwined with pHash */
 #define PHSIZE (PHPAGEMASK + PHFIDMASK + 1)
 /* the pHash macro */
-#define pHash(fid,page) ((((afs_int32)((fid)[0])) & PHFIDMASK) \
+#define pHash(fid,page) ((((afs_int32)((fid)->inode)) & PHFIDMASK) \
 			 | (page & PHPAGEMASK))
 
 #ifdef	dirty
@@ -88,7 +88,7 @@ static int nbuffers;
 static afs_int32 timecounter;
 
 /* Prototypes for static routines */
-static struct buffer *afs_newslot(afs_inode_t * afid, afs_int32 apage,
+static struct buffer *afs_newslot(struct fcache * afid, afs_int32 apage,
 				  register struct buffer *lp);
 
 static int dinit_flag = 0;
@@ -150,7 +150,7 @@ DInit(int abuffers)
 }
 
 void *
-DRead(register afs_inode_t * fid, register int page)
+DRead(register struct fcache * fid, register int page)
 {
     /* Read a page from the disk. */
     register struct buffer *tb, *tb2;
@@ -224,14 +224,13 @@ DRead(register afs_inode_t * fid, register int page)
     MObtainWriteLock(&tb->lock, 260);
     MReleaseWriteLock(&afs_bufferLock);
     tb->lockers++;
-    tfile = afs_CFileOpen(fid[0]);
-    if (page * AFS_BUFFER_PAGESIZE >= tfile->size) {
+    if (page * AFS_BUFFER_PAGESIZE >= fid->chunkBytes) {
 	dirp_Zap(tb->fid);
 	tb->lockers--;
 	MReleaseWriteLock(&tb->lock);
-	afs_CFileClose(tfile);
 	return NULL;
     }
+    tfile = afs_CFileOpen(fid->inode);
     code =
 	afs_CFileRead(tfile, tb->page * AFS_BUFFER_PAGESIZE, tb->data,
 		      AFS_BUFFER_PAGESIZE);
@@ -274,7 +273,7 @@ FixupBucket(register struct buffer *ap)
 
 /* lp is pointer to a fairly-old buffer */
 static struct buffer *
-afs_newslot(afs_inode_t * afid, afs_int32 apage, register struct buffer *lp)
+afs_newslot(struct fcache * afid, afs_int32 apage, register struct buffer *lp)
 {
     /* Find a usable buffer slot */
     register afs_int32 i;
@@ -341,7 +340,7 @@ afs_newslot(afs_inode_t * afid, afs_int32 apage, register struct buffer *lp)
     }
 
     if (lp->dirty) {
-	tfile = afs_CFileOpen(lp->fid[0]);
+	tfile = afs_CFileOpen(lp->fid->inode);
 	afs_CFileWrite(tfile, lp->page * AFS_BUFFER_PAGESIZE, lp->data,
 		       AFS_BUFFER_PAGESIZE);
 	lp->dirty = 0;
@@ -433,7 +432,7 @@ DVOffset(register void *ap)
  * method of DRead...
  */
 void
-DZap(afs_inode_t * fid)
+DZap(struct fcache * fid)
 {
     register int i;
     /* Destroy all buffers pertaining to a particular fid. */
@@ -470,7 +469,7 @@ DFlush(void)
 	    tb->lockers++;
 	    MReleaseReadLock(&afs_bufferLock);
 	    if (tb->dirty) {
-		tfile = afs_CFileOpen(tb->fid[0]);
+		tfile = afs_CFileOpen(tb->fid->inode);
 		afs_CFileWrite(tfile, tb->page * AFS_BUFFER_PAGESIZE,
 			       tb->data, AFS_BUFFER_PAGESIZE);
 		tb->dirty = 0;	/* Clear the dirty flag */
@@ -485,7 +484,7 @@ DFlush(void)
 }
 
 void *
-DNew(register afs_inode_t * fid, register int page)
+DNew(register struct fcache * fid, register int page)
 {
     /* Same as read, only do *not* even try to read the page, since it probably doesn't exist. */
     register struct buffer *tb;
diff --git a/src/afs/afs_dcache.c b/src/afs/afs_dcache.c
index f8f4b4845..6124c273f 100644
--- a/src/afs/afs_dcache.c
+++ b/src/afs/afs_dcache.c
@@ -686,7 +686,7 @@ afs_HashOutDCache(struct dcache *adc)
     AFS_STATCNT(afs_glink);
 #endif
     /* we know this guy's in the LRUQ.  We'll move dude into DCQ below */
-    DZap(&adc->f.inode);
+    DZap(&adc->f);
     /* if this guy is in the hash table, pull him out */
     if (adc->f.fid.Fid.Volume != 0) {
 	/* remove entry from first hash chains */
@@ -2038,7 +2038,7 @@ afs_GetDCache(register struct vcache *avc, afs_size_t abyte,
 	 * Right now, we only have one tool, and it's a hammer.  So, we
 	 * fetch the whole file.
 	 */
-	DZap(&tdc->f.inode);	/* pages in cache may be old */
+	DZap(&tdc->f);	/* pages in cache may be old */
 #ifdef  IHINT
 	if (file = tdc->ihint) {
 	    if (tdc->f.inode == file->inum)
@@ -2415,7 +2415,7 @@ afs_GetDCache(register struct vcache *avc, afs_size_t abyte,
 	    afs_CFileClose(file);
 	    ZapDCE(tdc);	/* sets DFEntryMod */
 	    if (vType(avc) == VDIR) {
-		DZap(&tdc->f.inode);
+		DZap(&tdc->f);
 	    }
 	    ReleaseWriteLock(&tdc->lock);
 	    afs_PutDCache(tdc);
diff --git a/src/afs/afs_osi.h b/src/afs/afs_osi.h
index 923c92e95..9471ba8e1 100644
--- a/src/afs/afs_osi.h
+++ b/src/afs/afs_osi.h
@@ -187,9 +187,9 @@ typedef struct timeval osi_timeval_t;
  * The following three routines provide the fid routines used by the buffer
  * and directory packages.
  */
-#define dirp_Zap(afid)    (*(afid) = -1)
-#define dirp_Eq(afid, bfid) (*(afid) == *(bfid))
-#define dirp_Cpy(dfid,sfid) (*(dfid) = *(sfid))
+#define dirp_Zap(afid)    ((afid) = 0)
+#define dirp_Eq(afid, bfid) ((afid) == (bfid))
+#define dirp_Cpy(dfid,sfid) ((dfid) = (sfid))
 
 
 /*
diff --git a/src/afs/afs_pioctl.c b/src/afs/afs_pioctl.c
index 3dc60bd64..a8c3a3b41 100644
--- a/src/afs/afs_pioctl.c
+++ b/src/afs/afs_pioctl.c
@@ -1717,7 +1717,7 @@ DECL_PIOCTL(PNewStatMount)
     Check_AtSys(avc, ain, &sysState, areq);
     ObtainReadLock(&tdc->lock);
     do {
-	code = afs_dir_Lookup(&tdc->f.inode, sysState.name, &tfid.Fid);
+	code = afs_dir_Lookup(&tdc->f, sysState.name, &tfid.Fid);
     } while (code == ENOENT && Next_AtSys(avc, areq, &sysState));
     ReleaseReadLock(&tdc->lock);
     afs_PutDCache(tdc);		/* we're done with the data */
@@ -2397,7 +2397,7 @@ DECL_PIOCTL(PRemoveMount)
     Check_AtSys(avc, ain, &sysState, areq);
     ObtainReadLock(&tdc->lock);
     do {
-	code = afs_dir_Lookup(&tdc->f.inode, sysState.name, &tfid.Fid);
+	code = afs_dir_Lookup(&tdc->f, sysState.name, &tfid.Fid);
     } while (code == ENOENT && Next_AtSys(avc, areq, &sysState));
     ReleaseReadLock(&tdc->lock);
     bufp = sysState.name;
@@ -2468,10 +2468,10 @@ DECL_PIOCTL(PRemoveMount)
 	ObtainWriteLock(&tdc->lock, 661);
 	if (afs_LocalHero(avc, tdc, &OutDirStatus, 1)) {
 	    /* we can do it locally */
-	    code = afs_dir_Delete(&tdc->f.inode, bufp);
+	    code = afs_dir_Delete(&tdc->f, bufp);
 	    if (code) {
 		ZapDCE(tdc);	/* surprise error -- invalid value */
-		DZap(&tdc->f.inode);
+		DZap(&tdc->f);
 	    }
 	}
 	ReleaseWriteLock(&tdc->lock);
@@ -3503,7 +3503,7 @@ DECL_PIOCTL(PFlushMount)
     Check_AtSys(avc, ain, &sysState, areq);
     ObtainReadLock(&tdc->lock);
     do {
-	code = afs_dir_Lookup(&tdc->f.inode, sysState.name, &tfid.Fid);
+	code = afs_dir_Lookup(&tdc->f, sysState.name, &tfid.Fid);
     } while (code == ENOENT && Next_AtSys(avc, areq, &sysState));
     ReleaseReadLock(&tdc->lock);
     afs_PutDCache(tdc);		/* we're done with the data */
diff --git a/src/afs/afs_prototypes.h b/src/afs/afs_prototypes.h
index c08265e4c..a185eaf4e 100644
--- a/src/afs/afs_prototypes.h
+++ b/src/afs/afs_prototypes.h
@@ -31,12 +31,12 @@ extern void afs_FreeAllAxs(struct axscache **headp);
 
 /* afs_buffer.c */
 extern void DInit(int abuffers);
-extern void *DRead(register afs_inode_t * fid, register int page);
+extern void *DRead(register struct fcache * fid, register int page);
 extern void DRelease(register struct buffer *bp, int flag);
 extern int DVOffset(register void *ap);
-extern void DZap(afs_inode_t * fid);
+extern void DZap(struct fcache * fid);
 extern void DFlush(void);
-extern void *DNew(register afs_inode_t * fid, register int page);
+extern void *DNew(register struct fcache * fid, register int page);
 extern void shutdown_bufferpackage(void);
 
 /* afs_call.c */
diff --git a/src/afs/afs_segments.c b/src/afs/afs_segments.c
index 1ebbcebc6..41c65cee2 100644
--- a/src/afs/afs_segments.c
+++ b/src/afs/afs_segments.c
@@ -898,7 +898,7 @@ afs_InvalidateAllSegments(struct vcache *avc)
 	ObtainWriteLock(&tdc->lock, 679);
 	ZapDCE(tdc);
 	if (vType(avc) == VDIR)
-	    DZap(&tdc->f.inode);
+	    DZap(&tdc->f);
 	ReleaseWriteLock(&tdc->lock);
 	afs_PutDCache(tdc);
     }
-- 
2.39.5