dread-do-validation-20041012

FIXES 15340

so we can do directory object validation in DRead()

diff --git a/src/afs/LINUX/osi_vnodeops.c b/src/afs/LINUX/osi_vnodeops.c
index 6af8d17..c09561a 100644 (file)
--- 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 ad0f0e0..c16f411 100644 (file)
--- 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 8f71cd1..0cd7ced 100644 (file)
--- 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 e48ca78..22ac2bc 100644 (file)
--- 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 bb90816..8add8d8 100644 (file)
--- 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 c681c13..d1d0330 100644 (file)
--- 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 7b25833..363bc22 100644 (file)
--- 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 cd71a79..642c421 100644 (file)
--- 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 b33f970..cd5008d 100644 (file)
--- 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 75e58d1..2c80435 100644 (file)
--- 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 47a24d4..0b56b26 100644 (file)
--- 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 f8f4b48..6124c27 100644 (file)
--- 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 923c92e..9471ba8 100644 (file)
--- 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 3dc60bd..a8c3a3b 100644 (file)
--- 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 c08265e..a185eaf 100644 (file)
--- 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 1ebbceb..41c65ce 100644 (file)
--- 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);
     }