From: Simon Wilkinson <sxw@inf.ed.ac.uk>
Date: Mon, 11 May 2009 14:27:42 +0000 (+0000)
Subject: abstract-cache-inode-ops-20090511
X-Git-Tag: openafs-devel-1_5_61~343
X-Git-Url: https://git.michaelhowe.org/gitweb/?a=commitdiff_plain;h=8747236d54742c1c2fb8788c1f6aee4e657b3e89;p=packages%2Fo%2Fopenafs.git

abstract-cache-inode-ops-20090511

LICENSE IPL10
FIXES 124184

previous versions had abstract functions for linux (use_fh) and osx/solaris
(cache_vnode_path) cache file access, which was contributing to code bloat

switch to a union for disk/memory cache objects, and provide functions to
convert these into something appropriate for each system
---

diff --git a/src/afs/AIX/osi_file.c b/src/afs/AIX/osi_file.c
index 7f5e60c68..fb5bf6243 100644
--- a/src/afs/AIX/osi_file.c
+++ b/src/afs/AIX/osi_file.c
@@ -26,7 +26,7 @@ extern struct vfs *afs_cacheVfsp;
 
 
 void *
-osi_UFSOpen(afs_int32 ainode)
+osi_UFSOpen(afs_dcache_id_t *ainode)
 {
     struct inode *ip;
     register struct osi_file *afile = NULL;
@@ -48,7 +48,7 @@ osi_UFSOpen(afs_int32 ainode)
     setuerror(0);
     AFS_GUNLOCK();
     ip = (struct inode *)igetinode((dev_t) cacheDev.dev, afs_cacheVfsp,
-				   (ino_t) ainode, &vp, &dummy);
+				   (ino_t) ainode->ufs, &vp, &dummy);
     AFS_GLOCK();
     if (getuerror()) {
 	osi_FreeSmallSpace(afile);
@@ -58,7 +58,7 @@ osi_UFSOpen(afs_int32 ainode)
     afile->size = VTOI(afile->vnode)->i_size;
     afile->offset = 0;
     afile->proc = (int (*)())0;
-    afile->inum = ainode;	/* for hint validity checking */
+    afile->inum = ainode->ufs;	/* for hint validity checking */
     return (void *)afile;
 }
 
diff --git a/src/afs/DARWIN/osi_file.c b/src/afs/DARWIN/osi_file.c
index d0f2f197e..d289f48b0 100644
--- a/src/afs/DARWIN/osi_file.c
+++ b/src/afs/DARWIN/osi_file.c
@@ -133,7 +133,7 @@ VnodeToDev(vnode_t avp)
 }
 
 void *
-osi_UFSOpen(afs_int32 ainode)
+osi_UFSOpen(afs_dcache_id_t *ainode)
 {
     struct vnode *vp;
     struct vattr va;
@@ -158,8 +158,8 @@ osi_UFSOpen(afs_int32 ainode)
     afile = (struct osi_file *)osi_AllocSmallSpace(sizeof(struct osi_file));
     AFS_GUNLOCK();
 #ifdef AFS_CACHE_VNODE_PATH
-    if (ainode < 0) {
-	switch (ainode) {
+    if (ainode->ufs < 0) {
+	switch (ainode->ufs) {
 	case AFS_CACHE_CELLS_INODE:
 	    snprintf(fname, 1024, "%s/%s", afs_cachebasedir, "CellItems");
 	    break;
@@ -173,19 +173,19 @@ osi_UFSOpen(afs_int32 ainode)
 	    osi_Panic("Invalid negative inode");
 	}
     } else {
-	dummy = ainode / afs_numfilesperdir;
-	snprintf(fname, 1024, "%s/D%d/V%d", afs_cachebasedir, dummy, ainode);
+	dummy = ainode->ufs / afs_numfilesperdir;
+	snprintf(fname, 1024, "%s/D%d/V%d", afs_cachebasedir, dummy, ainode->ufs);
     }
 
     code = vnode_open(fname, O_RDWR, 0, 0, &vp, afs_osi_ctxtp);
 #else
 #ifndef AFS_DARWIN80_ENV
     if (afs_CacheFSType == AFS_APPL_HFS_CACHE)
-	code = igetinode(afs_cacheVfsp, (dev_t) cacheDev.dev, &ainode, &vp, &va, &dummy);	/* XXX hfs is broken */
+	code = igetinode(afs_cacheVfsp, (dev_t) cacheDev.dev, &ainode->ufs, &vp, &va, &dummy);	/* XXX hfs is broken */
     else if (afs_CacheFSType == AFS_APPL_UFS_CACHE)
 #endif
 	code =
-	    igetinode(afs_cacheVfsp, (dev_t) cacheDev.dev, (ino_t) ainode,
+	    igetinode(afs_cacheVfsp, (dev_t) cacheDev.dev, (ino_t) ainode->ufs,
 		      &vp, &va, &dummy);
 #ifndef AFS_DARWIN80_ENV
     else
@@ -200,7 +200,7 @@ osi_UFSOpen(afs_int32 ainode)
     afile->vnode = vp;
     afile->offset = 0;
     afile->proc = (int (*)())0;
-    afile->inum = ainode;	/* for hint validity checking */
+    afile->inum = ainode->ufs;	/* for hint validity checking */
 #ifndef AFS_CACHE_VNODE_PATH
     afile->size = va.va_size;
 #else
diff --git a/src/afs/FBSD/osi_file.c b/src/afs/FBSD/osi_file.c
index 662e4b00b..9c5f7e23e 100644
--- a/src/afs/FBSD/osi_file.c
+++ b/src/afs/FBSD/osi_file.c
@@ -26,7 +26,7 @@ extern struct mount *afs_cacheVfsp;
 
 
 void *
-osi_UFSOpen(afs_int32 ainode)
+osi_UFSOpen(afs_dcache_id_t *ainode)
 {
     struct osi_file *afile;
     struct vnode *vp;
@@ -39,9 +39,9 @@ osi_UFSOpen(afs_int32 ainode)
     afile = (struct osi_file *)osi_AllocSmallSpace(sizeof(struct osi_file));
     AFS_GUNLOCK();
 #if defined(AFS_FBSD50_ENV)
-    code = VFS_VGET(afs_cacheVfsp, (ino_t) ainode, LK_EXCLUSIVE, &vp);
+    code = VFS_VGET(afs_cacheVfsp, (ino_t) ainode->ufs, LK_EXCLUSIVE, &vp);
 #else
-    code = VFS_VGET(afs_cacheVfsp, (ino_t) ainode, &vp);
+    code = VFS_VGET(afs_cacheVfsp, (ino_t) ainode->ufs, &vp);
 #endif
     AFS_GLOCK();
     if (code == 0 && vp->v_type == VNON)
@@ -61,7 +61,7 @@ osi_UFSOpen(afs_int32 ainode)
     afile->size = VTOI(vp)->i_size;
     afile->offset = 0;
     afile->proc = NULL;
-    afile->inum = ainode;	/* for hint validity checking */
+    afile->inum = ainode->ufs;	/* for hint validity checking */
     return (void *)afile;
 }
 
diff --git a/src/afs/HPUX/osi_file.c b/src/afs/HPUX/osi_file.c
index 96365ab64..a3b039d03 100644
--- a/src/afs/HPUX/osi_file.c
+++ b/src/afs/HPUX/osi_file.c
@@ -27,7 +27,7 @@ extern struct vfs *afs_cacheVfsp;
 
 
 void *
-osi_UFSOpen(afs_int32 ainode)
+osi_UFSOpen(afs_dcache_id_t *ainode)
 {
     struct inode *ip;
     register struct osi_file *afile = NULL;
@@ -48,7 +48,7 @@ osi_UFSOpen(afs_int32 ainode)
     setuerror(0);
     AFS_GUNLOCK();
     ip = (struct inode *)igetinode(afs_cacheVfsp, (dev_t) cacheDev.dev,
-				   (ino_t) ainode, &dummy);
+				   (ino_t) ainode->ufs, &dummy);
     AFS_GLOCK();
     if (getuerror()) {
 	osi_FreeSmallSpace(afile);
@@ -59,7 +59,7 @@ osi_UFSOpen(afs_int32 ainode)
     afile->size = VTOI(afile->vnode)->i_size;
     afile->offset = 0;
     afile->proc = (int (*)())0;
-    afile->inum = ainode;	/* for hint validity checking */
+    afile->inum = ainode->ufs;	/* for hint validity checking */
     return (void *)afile;
 }
 
diff --git a/src/afs/IRIX/osi_file.c b/src/afs/IRIX/osi_file.c
index 731132f91..ca351e995 100644
--- a/src/afs/IRIX/osi_file.c
+++ b/src/afs/IRIX/osi_file.c
@@ -24,14 +24,14 @@ extern struct osi_dev cacheDev;
 extern struct vfs *afs_cacheVfsp;
 
 vnode_t *
-afs_XFSIGetVnode(ino_t ainode)
+afs_XFSIGetVnode(afs_dcache_id_t *ainode)
 {
     struct xfs_inode *ip;
     int error;
     vnode_t *vp;
 
     if ((error =
-	 xfs_igetinode(afs_cacheVfsp, (dev_t) cacheDev.dev, ainode, &ip))) {
+	 xfs_igetinode(afs_cacheVfsp, (dev_t) cacheDev.dev, ainode->ufs, &ip))) {
 	osi_Panic("afs_XFSIGetVnode: xfs_igetinode failed, error=%d", error);
     }
     vp = XFS_ITOV(ip);
@@ -40,7 +40,7 @@ afs_XFSIGetVnode(ino_t ainode)
 
 /* Force to 64 bits, even for EFS filesystems. */
 void *
-osi_UFSOpen(ino_t ainode)
+osi_UFSOpen(afs_dcache_id_t *ainode)
 {
     struct inode *ip;
     register struct osi_file *afile = NULL;
@@ -59,12 +59,12 @@ osi_UFSOpen(ino_t ainode)
     }
     afile = (struct osi_file *)osi_AllocSmallSpace(sizeof(struct osi_file));
     AFS_GUNLOCK();
-    afile->vnode = AFS_SGI_IGETVNODE(ainode);
+    afile->vnode = AFS_SGI_IGETVNODE(ainode->ufs);
     AFS_GLOCK();
     afile->size = VnodeToSize(afile->vnode);
     afile->offset = 0;
     afile->proc = (int (*)())0;
-    afile->inum = ainode;	/* for hint validity checking */
+    afile->inum = ainode->ufs;	/* for hint validity checking */
     return (void *)afile;
 }
 
diff --git a/src/afs/LINUX/osi_file.c b/src/afs/LINUX/osi_file.c
index 5c8097866..e21706501 100644
--- a/src/afs/LINUX/osi_file.c
+++ b/src/afs/LINUX/osi_file.c
@@ -36,13 +36,9 @@ extern struct super_block *afs_cacheSBp;
 
 #if defined(AFS_LINUX26_ENV) 
 void *
-#if defined(LINUX_USE_FH)
-osi_UFSOpen_fh(struct fid *fh, int fh_type)
-#else
-osi_UFSOpen(afs_int32 ainode)
-#endif
+osi_UFSOpen(afs_dcache_id_t *ainode)
 {
-    register struct osi_file *afile = NULL;
+    struct osi_file *afile = NULL;
     extern int cacheDiskType;
     struct inode *tip = NULL;
     struct dentry *dp = NULL;
@@ -68,19 +64,19 @@ osi_UFSOpen(afs_int32 ainode)
     }
     memset(afile, 0, sizeof(struct osi_file));
 #if defined(HAVE_IGET)
-    tip = iget(afs_cacheSBp, (u_long) ainode);
+    tip = iget(afs_cacheSBp, ainode->ufs);
     if (!tip)
-	osi_Panic("Can't get inode %d\n", ainode);
+	osi_Panic("Can't get inode %d\n", ainode->ufs);
 
     dp = d_alloc_anon(tip);
 #else
-#if defined(LINUX_USE_FH)
-    dp = afs_cacheSBp->s_export_op->fh_to_dentry(afs_cacheSBp, fh, sizeof(struct fid), fh_type);
-#else
-    fid.i32.ino = ainode;
+# if defined(LINUX_USE_FH)
+    dp = afs_cacheSBp->s_export_op->fh_to_dentry(afs_cacheSBp, &ainode->ufs.fh, sizeof(struct fid), ainode->ufs.fh_type);
+# else
+    fid.i32.ino = ainode->ufs;
     fid.i32.gen = 0;
     dp = afs_cacheSBp->s_export_op->fh_to_dentry(afs_cacheSBp, &fid, sizeof(fid), FILEID_INO32_GEN);
-#endif
+# endif
     if (!dp) 
            osi_Panic("Can't get dentry\n");          
     tip = dp->d_inode;
@@ -96,7 +92,7 @@ osi_UFSOpen(afs_int32 ainode)
 #if defined(LINUX_USE_FH)
 	osi_Panic("Can't open file\n");
 #else
-	osi_Panic("Can't open inode %d\n", ainode);
+	osi_Panic("Can't open inode %d\n", ainode->ufs);
 #endif
     afile->filp = filp;
     afile->size = i_size_read(FILE_INODE(filp));
@@ -106,13 +102,13 @@ osi_UFSOpen(afs_int32 ainode)
 #if defined(LINUX_USE_FH)
     afile->inum = tip->i_ino;	/* for hint validity checking */
 #else
-    afile->inum = ainode;	/* for hint validity checking */
+    afile->inum = ainode->ufs;	/* for hint validity checking */
 #endif
     return (void *)afile;
 }
 #else
 void *
-osi_UFSOpen(afs_int32 ainode)
+osi_UFSOpen(afs_dcache_id_t *ainode)
 {
     register struct osi_file *afile = NULL;
     extern int cacheDiskType;
@@ -138,9 +134,9 @@ osi_UFSOpen(afs_int32 ainode)
     memset(afile, 0, sizeof(struct osi_file));
     filp = &afile->file;
     filp->f_dentry = &afile->dentry;
-    tip = iget(afs_cacheSBp, (u_long) ainode);
+    tip = iget(afs_cacheSBp, ainode->ufs);
     if (!tip)
-	osi_Panic("Can't get inode %d\n", ainode);
+	osi_Panic("Can't get inode %d\n", ainode->ufs);
     FILE_INODE(filp) = tip;
     tip->i_flags |= MS_NOATIME;	/* Disable updating access times. */
     filp->f_flags = O_RDWR;
@@ -153,30 +149,31 @@ osi_UFSOpen(afs_int32 ainode)
     if (filp->f_op && filp->f_op->open)
 	code = filp->f_op->open(tip, filp);
     if (code)
-	osi_Panic("Can't open inode %d\n", ainode);
+	osi_Panic("Can't open inode %d\n", ainode->ufs);
     afile->size = i_size_read(tip);
     AFS_GLOCK();
     afile->offset = 0;
     afile->proc = (int (*)())0;
-    afile->inum = ainode;	/* for hint validity checking */
+    afile->inum = ainode->ufs;	/* for hint validity checking */
     return (void *)afile;
 }
 #endif
 
 #if defined(LINUX_USE_FH)
-int
-osi_get_fh(struct dentry *dp, struct fid *fh, int *max_len) {
-    int fh_type;
+void osi_get_fh(struct dentry *dp, afs_ufs_dcache_id_t *ainode) {
+    int max_len = sizeof(struct fid);
 
     if (dp->d_sb->s_export_op->encode_fh) {
-           fh_type = dp->d_sb->s_export_op->encode_fh(dp, (__u32 *)fh, max_len, 0);
+	ainode->fh_type = dp->d_sb->s_export_op->encode_fh(dp, (__u32 *)&ainode->fh, &max_len, 0);
     } else {
-           fh_type = FILEID_INO32_GEN;
-           fh->i32.ino = dp->d_inode->i_ino;
-           fh->i32.gen = dp->d_inode->i_generation;
+	ainode->fh_type = FILEID_INO32_GEN;
+ 	ainode->fh.i32.ino = dp->d_inode->i_ino;
+	ainode->fh.i32.gen = dp->d_inode->i_generation;
     }
-    dput(dp);
-    return(fh_type);
+}
+#else
+void osi_get_fh(struct dentry *dp, afs_ufs_dcache_id_t *ainode) {
+    *ainode = dp->d_inode->i_ino;
 }
 #endif
 
@@ -409,13 +406,8 @@ int
 osi_InitCacheInfo(char *aname)
 {
     int code;
-#if defined(LINUX_USE_FH)
-    int max_len = sizeof(struct fid);
-#else
-    extern ino_t cacheInode;
-#endif
+    extern afs_dcache_id_t cacheInode;
     struct dentry *dp;
-    extern ino_t cacheInode;
     extern struct osi_dev cacheDev;
     extern afs_int32 afs_fsfragsize;
     extern struct super_block *afs_cacheSBp;
@@ -424,17 +416,7 @@ osi_InitCacheInfo(char *aname)
     if (code)
 	return ENOENT;
 
-#if defined(LINUX_USE_FH)
-    if (dp->d_sb->s_export_op->encode_fh) {
-	cacheitems_fh_type = dp->d_sb->s_export_op->encode_fh(dp, (__u32 *)&cacheitems_fh, &max_len, 0);
-    } else {
-        cacheitems_fh_type = FILEID_INO32_GEN;
-	cacheitems_fh.i32.ino = dp->d_inode->i_ino;
-        cacheitems_fh.i32.gen = dp->d_inode->i_generation;
-    }
-#else
-    cacheInode = dp->d_inode->i_ino;
-#endif
+    osi_get_fh(dp, &cacheInode.ufs);
     cacheDev.dev = dp->d_inode->i_sb->s_dev;
     afs_fsfragsize = dp->d_inode->i_sb->s_blocksize - 1;
     afs_cacheSBp = dp->d_inode->i_sb;
diff --git a/src/afs/NBSD/osi_file.c b/src/afs/NBSD/osi_file.c
index 7f6a004e6..c6a00a988 100644
--- a/src/afs/NBSD/osi_file.c
+++ b/src/afs/NBSD/osi_file.c
@@ -26,7 +26,7 @@ extern struct mount *afs_cacheVfsp;
 
 
 void *
-osi_UFSOpen(afs_int32 ainode)
+osi_UFSOpen(afs_dcache_id_t *ainode)
 {
     struct inode *ip;
     register struct osi_file *afile = NULL;
@@ -39,7 +39,7 @@ osi_UFSOpen(afs_int32 ainode)
     afile = (struct osi_file *)osi_AllocSmallSpace(sizeof(struct osi_file));
     AFS_GUNLOCK();
     code =
-	igetinode(afs_cacheVfsp, (dev_t) cacheDev.dev, (ino_t) ainode, &ip,
+	igetinode(afs_cacheVfsp, (dev_t) cacheDev.dev, ainode->ufs, &ip,
 		  &dummy);
     AFS_GLOCK();
     if (code) {
@@ -51,7 +51,7 @@ osi_UFSOpen(afs_int32 ainode)
     afile->size = VTOI(afile->vnode)->i_size;
     afile->offset = 0;
     afile->proc = (int (*)())0;
-    afile->inum = ainode;	/* for hint validity checking */
+    afile->inum = ainode->ufs;	/* for hint validity checking */
     return (void *)afile;
 }
 
diff --git a/src/afs/OBSD/osi_file.c b/src/afs/OBSD/osi_file.c
index 39328bef9..3e000b7bb 100644
--- a/src/afs/OBSD/osi_file.c
+++ b/src/afs/OBSD/osi_file.c
@@ -26,7 +26,7 @@ extern struct mount *afs_cacheVfsp;
 
 
 void *
-osi_UFSOpen(afs_int32 ainode)
+osi_UFSOpen(afs_dcache_id_t *ainode)
 {
     struct osi_file *afile;
     struct vnode *vp;
@@ -38,7 +38,7 @@ osi_UFSOpen(afs_int32 ainode)
 	osi_Panic("UFSOpen called for non-UFS cache\n");
     afile = (struct osi_file *)osi_AllocSmallSpace(sizeof(struct osi_file));
     AFS_GUNLOCK();
-    code = VFS_VGET(cacheDev.mp, (ino_t) ainode, &vp);
+    code = VFS_VGET(cacheDev.mp, ainode->ufs, &vp);
     AFS_GLOCK();
     if (code == 0 && vp->v_type == VNON)
 	code = ENOENT;
@@ -55,7 +55,7 @@ osi_UFSOpen(afs_int32 ainode)
 #endif
     afile->offset = 0;
     afile->proc = NULL;
-    afile->inum = ainode;	/* for hint validity checking */
+    afile->inum = ainode->ufs;	/* for hint validity checking */
     return (void *)afile;
 }
 
diff --git a/src/afs/SOLARIS/osi_file.c b/src/afs/SOLARIS/osi_file.c
index 4ba701526..e96a2d6ad 100644
--- a/src/afs/SOLARIS/osi_file.c
+++ b/src/afs/SOLARIS/osi_file.c
@@ -144,7 +144,7 @@ VnodeToSize(vnode_t * vp)
 }
 
 void *
-osi_VxfsOpen(afs_int32 ainode)
+osi_VxfsOpen(afs_dcache_id_t *ainode)
 {
     struct vnode *vp;
     register struct osi_file *afile = NULL;
@@ -152,7 +152,7 @@ osi_VxfsOpen(afs_int32 ainode)
     int dummy;
     afile = (struct osi_file *)osi_AllocSmallSpace(sizeof(struct osi_file));
     AFS_GUNLOCK();
-    code = (*vxfs_vx_vp_byino) (afs_cacheVfsp, &vp, (unsigned int)ainode);
+    code = (*vxfs_vx_vp_byino) (afs_cacheVfsp, &vp, (unsigned int)ainode->ufs);
     AFS_GLOCK();
     if (code) {
 	osi_FreeSmallSpace(afile);
@@ -162,18 +162,13 @@ osi_VxfsOpen(afs_int32 ainode)
     afile->size = VnodeToSize(afile->vnode);
     afile->offset = 0;
     afile->proc = (int (*)())0;
-    afile->inum = ainode;	/* for hint validity checking */
+    afile->inum = ainode->ufs;	/* for hint validity checking */
     return (void *)afile;
 }
 #endif /* AFS_HAVE_VXFS */
 
-#if defined(AFS_SUN57_64BIT_ENV)
 void *
-osi_UfsOpen(ino_t ainode)
-#else
-void *
-osi_UfsOpen(afs_int32 ainode)
-#endif
+osi_UfsOpen(afs_dcache_id_t *ainode)
 {
 #ifdef AFS_CACHE_VNODE_PATH
     struct vnode *vp;
@@ -197,7 +192,7 @@ osi_UfsOpen(afs_int32 ainode)
  * The ainode is not an inode number but a signed index used to generate file names. 
  */
 #ifdef AFS_CACHE_VNODE_PATH
-	switch (ainode) {
+	switch (ainode->ufs) {
 	case AFS_CACHE_CELLS_INODE:
 	    snprintf(fname, 1024, "%s/%s", afs_cachebasedir, "CellItems");
 	    break;
@@ -208,8 +203,8 @@ osi_UfsOpen(afs_int32 ainode)
 	    snprintf(fname, 1024, "%s/%s", afs_cachebasedir, "VolumeItems");
 	    break;
 	default:
-		dummy = ainode / afs_numfilesperdir;
-		snprintf(fname, 1024, "%s/D%d/V%d", afs_cachebasedir, dummy, ainode);
+	    dummy = ainode->ufs / afs_numfilesperdir;
+	    snprintf(fname, 1024, "%s/D%d/V%d", afs_cachebasedir, dummy, ainode->ufs);
     }
 		
 	/* Can not use vn_open or lookupname, they use user's CRED() 
@@ -219,13 +214,13 @@ osi_UfsOpen(afs_int32 ainode)
 
 	code = pn_get_buf(fname, AFS_UIOSYS, &lookpn, namebuf, sizeof(namebuf));
     if (code != 0) 
-        osi_Panic("UfsOpen: pn_get_buf failed %ld %s %ld", code, fname, ainode);
+        osi_Panic("UfsOpen: pn_get_buf failed %ld %s %ld", code, fname, ainode->ufs);
  
 	VN_HOLD(rootdir); /* released in loopuppnvp */
 	code = lookuppnvp(&lookpn, NULL, FOLLOW, NULL, &vp, 
            rootdir, rootdir, &afs_osi_cred); 
     if (code != 0)  
-        osi_Panic("UfsOpen: lookuppnvp failed %ld %s %ld", code, fname, ainode);
+        osi_Panic("UfsOpen: lookuppnvp failed %ld %s %ld", code, fname, ainode->ufs);
 	
 #ifdef AFS_SUN511_ENV
     code = VOP_OPEN(&vp, FREAD|FWRITE, &afs_osi_cred, NULL);
@@ -234,17 +229,17 @@ osi_UfsOpen(afs_int32 ainode)
 #endif
 
     if (code != 0)
-        osi_Panic("UfsOpen: VOP_OPEN failed %ld %s %ld", code, fname, ainode);
+        osi_Panic("UfsOpen: VOP_OPEN failed %ld %s %ld", code, fname, ainode->ufs);
 
 #else
     code =
-	igetinode(afs_cacheVfsp, (dev_t) cacheDev.dev, (ino_t) ainode, &ip,
+	igetinode(afs_cacheVfsp, (dev_t) cacheDev.dev, ainode->ufs, &ip,
 		  CRED(), &dummy);
 #endif
     AFS_GLOCK();
     if (code) {
 	osi_FreeSmallSpace(afile);
-	osi_Panic("UfsOpen: igetinode failed %ld %s %ld", code, fname, ainode);
+	osi_Panic("UfsOpen: igetinode failed %ld %s %ld", code, fname, ainode->ufs);
     }
 #ifdef AFS_CACHE_VNODE_PATH
 	afile->vnode = vp;
@@ -256,20 +251,15 @@ osi_UfsOpen(afs_int32 ainode)
 #endif
     afile->offset = 0;
     afile->proc = (int (*)())0;
-    afile->inum = ainode;	/* for hint validity checking */
+    afile->inum = ainode->ufs;	/* for hint validity checking */
     return (void *)afile;
 }
 
 /**
   * In Solaris 7 we use 64 bit inode numbers
   */
-#if defined(AFS_SUN57_64BIT_ENV)
 void *
-osi_UFSOpen(ino_t ainode)
-#else
-void *
-osi_UFSOpen(afs_int32 ainode)
-#endif
+osi_UFSOpen(afs_dcache_id_t *ainode)
 {
     extern int cacheDiskType;
     AFS_STATCNT(osi_UFSOpen);
diff --git a/src/afs/UKERNEL/afs_usrops.c b/src/afs/UKERNEL/afs_usrops.c
index 15b1367f6..833c78feb 100644
--- a/src/afs/UKERNEL/afs_usrops.c
+++ b/src/afs/UKERNEL/afs_usrops.c
@@ -702,7 +702,7 @@ lookupname(char *fnamep, int segflg, int followlink,
  * open a file given its i-node number
  */
 void *
-osi_UFSOpen(afs_int32 ino)
+osi_UFSOpen(afs_dcache_id_t *ino)
 {
     int rc;
     struct osi_file *fp;
@@ -710,7 +710,7 @@ osi_UFSOpen(afs_int32 ino)
 
     AFS_ASSERT_GLOCK();
 
-    if (ino > n_osi_files) {
+    if (ino->ufs > n_osi_files) {
 	u.u_error = ENOENT;
 	return NULL;
     }
@@ -718,7 +718,7 @@ osi_UFSOpen(afs_int32 ino)
     AFS_GUNLOCK();
     fp = (struct osi_file *)afs_osi_Alloc(sizeof(struct osi_file));
     usr_assert(fp != NULL);
-    fp->fd = open(osi_file_table[ino - 1].name, O_RDWR | O_CREAT, 0);
+    fp->fd = open(osi_file_table[ino->ufs - 1].name, O_RDWR | O_CREAT, 0);
     if (fp->fd < 0) {
 	u.u_error = errno;
 	afs_osi_Free((char *)fp, sizeof(struct osi_file));
@@ -734,7 +734,7 @@ osi_UFSOpen(afs_int32 ino)
     }
     fp->size = st.st_size;
     fp->offset = 0;
-    fp->inum = ino;
+    fp->inum = ino->ufs;
     fp->vnode = (struct usr_vnode *)fp;
 
     AFS_GLOCK();
diff --git a/src/afs/VNOPS/afs_vnop_read.c b/src/afs/VNOPS/afs_vnop_read.c
index 285acfaeb..bbe8e88af 100644
--- a/src/afs/VNOPS/afs_vnop_read.c
+++ b/src/afs/VNOPS/afs_vnop_read.c
@@ -351,7 +351,7 @@ afs_MemRead(register struct vcache *avc, struct uio *auio,
 	    tuio.afsio_offset = offset;
 #endif
 
-	    code = afs_MemReadUIO(tdc->f.inode, tuiop);
+	    code = afs_MemReadUIO(&tdc->f.inode, tuiop);
 
 	    if (code) {
 		error = code;
@@ -806,11 +806,7 @@ afs_UFSRead(register struct vcache *avc, struct uio *auio,
 		usedihint++;
 	    } else
 #endif /* IHINT */
-#if defined(LINUX_USE_FH)
-		tfile = (struct osi_file *)osi_UFSOpen_fh(&tdc->f.fh, tdc->f.fh_type);
-#else
-		tfile = (struct osi_file *)osi_UFSOpen(tdc->f.inode);
-#endif
+	    tfile = (struct osi_file *)osi_UFSOpen(&tdc->f.inode);
 #ifdef AFS_DARWIN80_ENV
 	    trimlen = len;
             tuiop = afsio_darwin_partialcopy(auio, trimlen);
diff --git a/src/afs/VNOPS/afs_vnop_symlink.c b/src/afs/VNOPS/afs_vnop_symlink.c
index d1e635f09..66b77c143 100644
--- a/src/afs/VNOPS/afs_vnop_symlink.c
+++ b/src/afs/VNOPS/afs_vnop_symlink.c
@@ -59,7 +59,7 @@ afs_DisconCreateSymlink(struct vcache *avc, char *aname,
     ObtainWriteLock(&tdc->lock, 720);
     afs_AdjustSize(tdc, len);
     tdc->validPos = len;
-    tfile = afs_CFileOpen(tdc->f.inode);
+    tfile = afs_CFileOpen(&tdc->f.inode);
     afs_CFileWrite(tfile, 0, aname, len);
     afs_CFileClose(tfile);
     ReleaseWriteLock(&tdc->lock);
@@ -329,7 +329,7 @@ afs_MemHandleLink(register struct vcache *avc, struct vrequest *areq)
 	    alen = len;		/* mt point */
 	rbuf = (char *)osi_AllocLargeSpace(AFS_LRALLOCSIZ);
 	ObtainReadLock(&tdc->lock);
-	addr = afs_MemCacheOpen(tdc->f.inode);
+	addr = afs_MemCacheOpen(&tdc->f.inode);
 	tlen = len;
 	code = afs_MemReadBlk(addr, 0, rbuf, tlen);
 	afs_MemCacheClose(addr);
@@ -386,11 +386,7 @@ afs_UFSHandleLink(register struct vcache *avc, struct vrequest *areq)
 	rbuf = (char *)osi_AllocLargeSpace(AFS_LRALLOCSIZ);
 	tlen = len;
 	ObtainReadLock(&tdc->lock);
-#if defined(LINUX_USE_FH)
-	tfile = osi_UFSOpen_fh(&tdc->f.fh, tdc->f.fh_type);
-#else
-	tfile = osi_UFSOpen(tdc->f.inode);
-#endif
+	tfile = osi_UFSOpen(&tdc->f.inode);
 	code = afs_osi_Read(tfile, -1, rbuf, tlen);
 	osi_UFSClose(tfile);
 	ReleaseReadLock(&tdc->lock);
diff --git a/src/afs/VNOPS/afs_vnop_write.c b/src/afs/VNOPS/afs_vnop_write.c
index 39685a674..32ca45bad 100644
--- a/src/afs/VNOPS/afs_vnop_write.c
+++ b/src/afs/VNOPS/afs_vnop_write.c
@@ -231,12 +231,12 @@ afs_MemWrite(register struct vcache *avc, struct uio *auio, int aio,
 #endif
 	AFS_UIO_SETOFFSET(tuiop, offset);
 
-	code = afs_MemWriteUIO(tdc->f.inode, tuiop);
+	code = afs_MemWriteUIO(&tdc->f.inode, tuiop);
 	if (code) {
 	    void *mep;		/* XXX in prototype world is struct memCacheEntry * */
 	    error = code;
 	    ZapDCE(tdc);	/* bad data */
-	    mep = afs_MemCacheOpen(tdc->f.inode);
+	    mep = afs_MemCacheOpen(&tdc->f.inode);
 	    afs_MemCacheTruncate(mep, 0);
 	    afs_MemCacheClose(mep);
 	    afs_stats_cmperf.cacheCurrDirtyChunks--;
@@ -425,11 +425,7 @@ afs_UFSWrite(register struct vcache *avc, struct uio *auio, int aio,
 	    error = EIO;
 	    break;
 	}
-#if defined(LINUX_USE_FH)
-	tfile = (struct osi_file *)osi_UFSOpen_fh(&tdc->f.fh, tdc->f.fh_type);
-#else
-	tfile = (struct osi_file *)osi_UFSOpen(tdc->f.inode);
-#endif
+	tfile = (struct osi_file *)osi_UFSOpen(&tdc->f.inode);
 	len = totalLength;	/* write this amount by default */
 	offset = filePos - AFS_CHUNKTOBASE(tdc->f.chunk);
 	max = AFS_CHUNKTOSIZE(tdc->f.chunk);	/* max size of this chunk */
diff --git a/src/afs/afs.h b/src/afs/afs.h
index d410aa169..b9b35adc7 100644
--- a/src/afs/afs.h
+++ b/src/afs/afs.h
@@ -1021,34 +1021,39 @@ struct afs_fheader {
     afs_int32 otherCSize;
 };
 
-#if defined(AFS_SGI61_ENV) || defined(AFS_SUN57_64BIT_ENV)
+#if defined(AFS_CACHE_VNODE_PATH) || defined(UKERNEL)
+typedef afs_int32 afs_ufs_dcache_id_t;
+#elif defined(AFS_SGI61_ENV) || defined(AFS_SUN57_64BIT_ENV)
 /* Using ino64_t here so that user level debugging programs compile
  * the size correctly.
  */
-#define afs_inode_t ino64_t
+typedef ino64_t afs_ufs_dcache_id_t;
+#elif defined(LINUX_USE_FH)
+typedef struct {
+     struct fid fh;
+     int fh_type;
+} afs_ufs_dcache_id_t;
+#elif defined(AFS_LINUX_64BIT_KERNEL) && !defined(AFS_S390X_LINUX24_ENV)
+typedef long afs_ufs_dcache_id_t;
+#elif defined(AFS_AIX51_ENV) || defined(AFS_HPUX1123_ENV)
+typedef ino_t afs_ufs_dcache_id_t;
 #else
-#if defined(AFS_LINUX_64BIT_KERNEL) && !defined(AFS_S390X_LINUX24_ENV)
-#define afs_inode_t long
-#else
-#if defined(AFS_AIX51_ENV) || defined(AFS_HPUX1123_ENV)
-#define afs_inode_t ino_t
-#else
-#define afs_inode_t afs_int32
-#endif
-#endif
+typedef afs_int32 afs_ufs_dcache_id_t;
 #endif
 
+typedef afs_int32 afs_mem_dcache_id_t;
+
+typedef union {
+    afs_ufs_dcache_id_t ufs;
+    afs_mem_dcache_id_t mem;
+} afs_dcache_id_t;
 
 #ifdef KERNEL
 /* it does not compile outside kernel */
 struct buffer {
   afs_int32 fid;              /* is adc->index, the cache file number */
-  afs_inode_t inode;          /* is adc->f.inode, the inode number of the cac\
+  afs_dcache_id_t inode;          /* is adc->f.inode, the inode number of the cac\
 				 he file */
-#if defined(LINUX_USE_FH)
-  struct fid fh;		/* Opaque file handle */
-  int fh_type;			/* Opaque file handle type */
-#endif
   afs_int32 page;
   afs_int32 accesstime;
   struct buffer *hashNext;
@@ -1068,13 +1073,9 @@ struct fcache {
     afs_int32 modTime;		/* last time this entry was modified */
     afs_hyper_t versionNo;	/* Associated data version number */
     afs_int32 chunk;		/* Relative chunk number */
-    afs_inode_t inode;		/* Unix inode for this chunk */
+    afs_dcache_id_t inode;		/* Unix inode for this chunk */
     afs_int32 chunkBytes;	/* Num bytes in this chunk */
     char states;		/* Has this chunk been modified? */
-#if defined(LINUX_USE_FH)
-    struct fid fh;		/* File handle */
-    int fh_type;		/* File handle type */
-#endif
 };
 #endif
 
diff --git a/src/afs/afs_buffer.c b/src/afs/afs_buffer.c
index b170046ae..3ecb04bf2 100644
--- a/src/afs/afs_buffer.c
+++ b/src/afs/afs_buffer.c
@@ -130,7 +130,7 @@ DInit(int abuffers)
 	/* Fill in each buffer with an empty indication. */
 	tb = &Buffers[i];
 	tb->fid = NULLIDX;
-	tb->inode = 0;
+	afs_reset_inode(&tb->inode);
 	tb->accesstime = 0;
 	tb->lockers = 0;
 #if defined(AFS_USEBUFFERS)
@@ -226,23 +226,19 @@ DRead(register struct dcache *adc, register int page)
     tb->lockers++;
     if (page * AFS_BUFFER_PAGESIZE >= adc->f.chunkBytes) {
 	tb->fid = NULLIDX;
-	tb->inode = 0;
+	afs_reset_inode(&tb->inode);
 	tb->lockers--;
 	MReleaseWriteLock(&tb->lock);
 	return NULL;
     }
-#if defined(LINUX_USE_FH)
-    tfile = afs_CFileOpen(&adc->f.fh, adc->f.fh_type);
-#else
-    tfile = afs_CFileOpen(adc->f.inode);
-#endif
+    tfile = afs_CFileOpen(&adc->f.inode);
     code =
 	afs_CFileRead(tfile, tb->page * AFS_BUFFER_PAGESIZE, tb->data,
 		      AFS_BUFFER_PAGESIZE);
     afs_CFileClose(tfile);
     if (code < AFS_BUFFER_PAGESIZE) {
 	tb->fid = NULLIDX;
-	tb->inode = 0;
+	afs_reset_inode(&tb->inode);
 	tb->lockers--;
 	MReleaseWriteLock(&tb->lock);
 	return NULL;
@@ -347,11 +343,7 @@ afs_newslot(struct dcache *adc, afs_int32 apage, register struct buffer *lp)
 
     if (lp->dirty) {
 	/* see DFlush for rationale for not getting and locking the dcache */
-#if defined(LINUX_USE_FH)
-        tfile = afs_CFileOpen(&lp->fh, lp->fh_type);
-#else
-        tfile = afs_CFileOpen(lp->inode);
-#endif
+        tfile = afs_CFileOpen(&lp->inode);
 	afs_CFileWrite(tfile, lp->page * AFS_BUFFER_PAGESIZE, lp->data,
 		       AFS_BUFFER_PAGESIZE);
 	lp->dirty = 0;
@@ -361,12 +353,7 @@ afs_newslot(struct dcache *adc, afs_int32 apage, register struct buffer *lp)
 
     /* Now fill in the header. */
     lp->fid = adc->index;
-#if defined(LINUX_USE_FH)
-    memcpy(&lp->fh, &adc->f.fh, sizeof(struct fid));
-    lp->fh_type = adc->f.fh_type;
-#else
-    lp->inode = adc->f.inode;
-#endif
+    afs_copy_inode(&lp->inode, &adc->f.inode);
     lp->page = apage;
     lp->accesstime = timecounter++;
     FixupBucket(lp);		/* move to the right hash bucket */
@@ -468,7 +455,7 @@ DZap(struct dcache *adc)
 	    if (tb->fid == adc->index) {
 		MObtainWriteLock(&tb->lock, 262);
 		tb->fid = NULLIDX;
-		tb->inode = 0;
+		afs_reset_inode(&tb->inode);
 		tb->dirty = 0;
 		MReleaseWriteLock(&tb->lock);
 	    }
@@ -479,11 +466,7 @@ static void
 DFlushBuffer(struct buffer *ab) {
     struct osi_file *tfile;
     
-#if defined(LINUX_USE_FH)
-    tfile = afs_CFileOpen(&ab->fh, ab->fh_type);
-#else
-    tfile = afs_CFileOpen(ab->inode);
-#endif
+    tfile = afs_CFileOpen(&ab->inode);
     afs_CFileWrite(tfile, ab->page * AFS_BUFFER_PAGESIZE,
 		   ab->data, AFS_BUFFER_PAGESIZE);
     ab->dirty = 0;	/* Clear the dirty flag */
diff --git a/src/afs/afs_cell.c b/src/afs/afs_cell.c
index 8bcfd39bf..ad3e56867 100644
--- a/src/afs/afs_cell.c
+++ b/src/afs/afs_cell.c
@@ -215,14 +215,8 @@ afs_LookupAFSDB(char *acellName)
  */
 
 struct cell_name *afs_cellname_head;	/* Export for kdump */
-#if defined(LINUX_USE_FH)
-struct fid afs_cellname_fh;
-int afs_cellname_fh_type;
-static int afs_cellname_fh_set;
-#else
-static ino_t afs_cellname_inode;
+static afs_dcache_id_t afs_cellname_inode;
 static int afs_cellname_inode_set;
-#endif
 static int afs_cellname_dirty;
 static afs_int32 afs_cellnum_next;
 
@@ -307,11 +301,7 @@ afs_cellname_ref(struct cell_name *cn)
  * \return 0 for success. < 0 for error.
  */
 int
-#if defined(LINUX_USE_FH)
-afs_cellname_init(struct fid *fh, int fh_type, int lookupcode)
-#else
-afs_cellname_init(ino_t inode, int lookupcode)
-#endif
+afs_cellname_init(afs_dcache_id_t *inode, int lookupcode)
 {
     struct osi_file *tfile;
     int cc, off = 0;
@@ -330,24 +320,14 @@ afs_cellname_init(ino_t inode, int lookupcode)
 	return lookupcode;
     }
 
-#if defined(LINUX_USE_FH)
-    tfile = osi_UFSOpen_fh(fh, fh_type);
-#else
     tfile = osi_UFSOpen(inode);
-#endif
     if (!tfile) {
 	ReleaseWriteLock(&afs_xcell);
 	return EIO;
     }
 
-#if defined(LINUX_USE_FH)
-    memcpy(&afs_cellname_fh, fh, sizeof(struct fid));
-    afs_cellname_fh_type = fh_type;
-    afs_cellname_fh_set = 1;
-#else
-    afs_cellname_inode = inode;
+    afs_copy_inode(&afs_cellname_inode, inode);
     afs_cellname_inode_set = 1;
-#endif
 
     while (1) {
 	afs_int32 cellnum, clen, magic;
@@ -408,11 +388,7 @@ afs_cellname_write(void)
     struct cell_name *cn;
     int off;
 
-#if defined(LINUX_USE_FH)
-    if (!afs_cellname_dirty || !afs_cellname_fh_set)
-#else
     if (!afs_cellname_dirty || !afs_cellname_inode_set)
-#endif
 	return 0;
     if (afs_initState != 300)
 	return 0;
@@ -420,11 +396,7 @@ afs_cellname_write(void)
     ObtainWriteLock(&afs_xcell, 693);
     afs_cellname_dirty = 0;
     off = 0;
-#if defined(LINUX_USE_FH)
-    tfile = osi_UFSOpen_fh(&afs_cellname_fh, afs_cellname_fh_type);
-#else
-    tfile = osi_UFSOpen(afs_cellname_inode);
-#endif
+    tfile = osi_UFSOpen(&afs_cellname_inode);
     if (!tfile) {
 	ReleaseWriteLock(&afs_xcell);
 	return EIO;
diff --git a/src/afs/afs_chunkops.h b/src/afs/afs_chunkops.h
index 9b1608fd6..05f3ff798 100644
--- a/src/afs/afs_chunkops.h
+++ b/src/afs/afs_chunkops.h
@@ -52,15 +52,7 @@
  */
 
 struct afs_cacheOps {
-#if defined(AFS_SUN57_64BIT_ENV) || defined(AFS_SGI62_ENV)
-    void *(*open) (ino_t ainode);
-#else
-#if defined(LINUX_USE_FH)
-    void *(*open) (struct fid *fh, int fh_type);
-#else
-    void *(*open) (afs_int32 ainode);
-#endif
-#endif
+    void *(*open) (afs_dcache_id_t *ainode);
     int (*truncate) (struct osi_file * fp, afs_int32 len);
     int (*fread) (struct osi_file * fp, int offset, void *buf, afs_int32 len);
     int (*fwrite) (struct osi_file * fp, afs_int32 offset, void *buf,
@@ -88,11 +80,7 @@ struct afs_cacheOps {
 };
 
 /* Ideally we should have used consistent naming - like COP_OPEN, COP_TRUNCATE, etc. */
-#if defined(LINUX_USE_FH)
-#define	afs_CFileOpen(fh, fh_type)	      (void *)(*(afs_cacheType->open))(fh, fh_type)
-#else
 #define	afs_CFileOpen(inode)	      (void *)(*(afs_cacheType->open))(inode)
-#endif
 #define	afs_CFileTruncate(handle, size)	(*(afs_cacheType->truncate))((handle), size)
 #define	afs_CFileRead(file, offset, data, size) (*(afs_cacheType->fread))(file, offset, data, size)
 #define	afs_CFileWrite(file, offset, data, size) (*(afs_cacheType->fwrite))(file, offset, data, size)
@@ -106,4 +94,21 @@ struct afs_cacheOps {
 #define	afs_CacheStoreProc(call, file, bytes, avc, wake, toxfer, xfered) \
           (*(afs_cacheType->StoreProc))(call, file, bytes, avc, wake, toxfer, xfered)
 
+/* These memcpys should get optimised to simple assignments when afs_dcache_id_t 
+ * is simple */
+static inline void afs_copy_inode(afs_dcache_id_t *dst, afs_dcache_id_t *src) {
+    memcpy(dst, src, sizeof(afs_dcache_id_t));
+}
+
+static inline void afs_reset_inode(afs_dcache_id_t *i) {
+    memset(i, 0, sizeof(afs_dcache_id_t));
+}
+
+/* We need to have something we can output as the 'inode' for fstrace calls. 
+ * This is a hack */
+static inline int afs_inode2trace(afs_dcache_id_t *i) {
+    return i->mem;
+}
+
+
 #endif /* AFS_CHUNKOPS */
diff --git a/src/afs/afs_dcache.c b/src/afs/afs_dcache.c
index 878bfab93..db998f5ba 100644
--- a/src/afs/afs_dcache.c
+++ b/src/afs/afs_dcache.c
@@ -54,12 +54,7 @@ afs_int32 afs_discardDCList;	/*!< Discarded disk cache entries */
 afs_int32 afs_discardDCCount;	/*!< Count of elts in discardDCList */
 struct dcache *afs_freeDSList;	/*!< Free list for disk slots */
 struct dcache *afs_Initial_freeDSList;	/*!< Initial list for above */
-#if defined(LINUX_USE_FH)
-struct fid cacheitems_fh;
-int cacheitems_fh_type;
-#else
-ino_t cacheInode;               /*!< Inode for CacheItems file */
-#endif
+afs_dcache_id_t cacheInode;               /*!< Inode for CacheItems file */
 struct osi_file *afs_cacheInodep = 0;	/*!< file for CacheItems inode */
 struct afs_q afs_DLRU;		/*!< dcache LRU */
 afs_int32 afs_dhashsize = 1024;
@@ -117,11 +112,7 @@ static int afs_UFSCacheStoreProc(struct rx_call *, struct osi_file *,
 				 afs_size_t *);
 
 struct afs_cacheOps afs_UfsCacheOps = {
-#if defined(LINUX_USE_FH)
-    osi_UFSOpen_fh,
-#else
     osi_UFSOpen,
-#endif
     osi_UFSTruncate,
     afs_osi_Read,
     afs_osi_Write,
@@ -1108,11 +1099,7 @@ afs_FreeDiscardedDCache(void)
     /*
      * Truncate the element to reclaim its space
      */
-#if defined(LINUX_USE_FH)
-    tfile = afs_CFileOpen(&tdc->f.fh, tdc->f.fh_type);
-#else
-    tfile = afs_CFileOpen(tdc->f.inode);
-#endif
+    tfile = afs_CFileOpen(&tdc->f.inode);
     afs_CFileTruncate(tfile, 0);
     afs_CFileClose(tfile);
     afs_AdjustSize(tdc, 0);
@@ -1746,11 +1733,7 @@ struct dcache *afs_AllocDCache(struct vcache *avc,
 	afs_stats_cmperf.cacheBlocksDiscarded = afs_blocksDiscarded;
 	if (lock & 2) {
 	    /* Truncate the chunk so zeroes get filled properly */
-#if defined(LINUX_USE_FH)
-	    file = afs_CFileOpen(&tdc->f.fh, tdc->f.fh_type);
-#else
-	    file = afs_CFileOpen(tdc->f.inode);
-#endif
+	    file = afs_CFileOpen(&tdc->f.inode);
 	    afs_CFileTruncate(file, 0);
 	    afs_CFileClose(file);
 	    afs_AdjustSize(tdc, 0);
@@ -2167,12 +2150,7 @@ afs_GetDCache(register struct vcache *avc, afs_size_t abyte,
 	if (doReallyAdjustSize || overWriteWholeChunk) {
 	    /* no data in file to read at this position */
 	    UpgradeSToWLock(&tdc->lock, 607);
-
-#if defined(LINUX_USE_FH)
-	    file = afs_CFileOpen(&tdc->f.fh, tdc->f.fh_type);
-#else
-	    file = afs_CFileOpen(tdc->f.inode);
-#endif
+	    file = afs_CFileOpen(&tdc->f.inode);
 	    afs_CFileTruncate(file, 0);
 	    afs_CFileClose(file);
 	    afs_AdjustSize(tdc, 0);
@@ -2359,11 +2337,7 @@ afs_GetDCache(register struct vcache *avc, afs_size_t abyte,
 	 * fetch the whole file.
 	 */
 	DZap(tdc);	/* pages in cache may be old */
-#if defined(LINUX_USE_FH)
-	file = afs_CFileOpen(&tdc->f.fh, tdc->f.fh_type);
-#else
-	file = afs_CFileOpen(tdc->f.inode);
-#endif
+	file = afs_CFileOpen(&tdc->f.inode);
 	afs_RemoveVCB(&avc->f.fid);
 	tdc->f.states |= DWriting;
 	tdc->dflags |= DFFetching;
@@ -3061,7 +3035,7 @@ afs_MemGetDSlot(register afs_int32 aslot, register struct dcache *tmpdc)
     tdc->f.fid.Fid.Volume = 0;
     tdc->f.chunk = -1;
     hones(tdc->f.versionNo);
-    tdc->f.inode = aslot;
+    tdc->f.inode.mem = aslot;
     tdc->dflags |= DFEntryMod;
     tdc->refCount = 1;
     tdc->index = aslot;
@@ -3320,19 +3294,11 @@ int
 afs_InitCacheFile(char *afile, ino_t ainode)
 {
     register afs_int32 code;
-#if defined(AFS_LINUX22_ENV)
-    struct dentry *filevp;
-#else
-    struct vnode *filevp;
-#endif
     afs_int32 index;
     int fileIsBad;
     struct osi_file *tfile;
     struct osi_stat tstat;
     register struct dcache *tdc;
-#if defined(LINUX_USE_FH)
-    int max_len = sizeof(struct fid);
-#endif
 
     AFS_STATCNT(afs_InitCacheFile);
     index = afs_stats_cmperf.cacheNumEntries;
@@ -3347,40 +3313,26 @@ afs_InitCacheFile(char *afile, ino_t ainode)
     ObtainWriteLock(&tdc->lock, 621);
     MObtainWriteLock(&afs_xdcache, 622);
     if (afile) {
-	code = gop_lookupname(afile, AFS_UIOSYS, 0, &filevp);
+	code = afs_LookupInodeByPath(afile, &tdc->f.inode.ufs, NULL);
 	if (code) {
 	    ReleaseWriteLock(&afs_xdcache);
 	    ReleaseWriteLock(&tdc->lock);
 	    afs_PutDCache(tdc);
 	    return code;
 	}
-	/*
-	 * We have a VN_HOLD on filevp.  Get the useful info out and
-	 * return.  We make use of the fact that the cache is in the
-	 * UFS file system, and just record the inode number.
-	 */
-#ifdef AFS_LINUX22_ENV
-#if defined(LINUX_USE_FH)
-        tdc->f.fh_type = osi_get_fh(filevp, &tdc->f.fh, &max_len);
+    } else {
+	/* Add any other 'complex' inode types here ... */
+#if defined(UKERNEL) || !defined(LINUX_USE_FH)
+	tdc->f.inode.ufs = ainode;
 #else
-        tdc->f.inode = VTOI(filevp->d_inode)->i_number;
-	dput(filevp);
+	osi_Panic("Can't init cache with inode numbers when complex inodes are "
+	          "in use\n");
 #endif
-#else
-	tdc->f.inode = afs_vnodeToInumber(filevp);
-	AFS_RELE(filevp);
-#endif /* AFS_LINUX22_ENV */
-    } else {
-	tdc->f.inode = ainode;
     }
     fileIsBad = 0;
     if ((tdc->f.states & DWriting) || tdc->f.fid.Fid.Volume == 0)
 	fileIsBad = 1;
-#if defined(LINUX_USE_FH)
-    tfile = osi_UFSOpen_fh(&tdc->f.fh, tdc->f.fh_type);
-#else
-    tfile = osi_UFSOpen(tdc->f.inode);
-#endif
+    tfile = osi_UFSOpen(&tdc->f.inode);
     code = afs_osi_Stat(tfile, &tstat);
     if (code)
 	osi_Panic("initcachefile stat");
@@ -3810,8 +3762,8 @@ int afs_MakeShadowDir(struct vcache *avc, struct dcache *adc)
     }
 
     /* Open the files. */
-    tfile_src = afs_CFileOpen(adc->f.inode);
-    tfile_dst = afs_CFileOpen(new_dc->f.inode);
+    tfile_src = afs_CFileOpen(&adc->f.inode);
+    tfile_dst = afs_CFileOpen(&new_dc->f.inode);
 
     /* And now copy dir dcache data into this dcache,
      * 4k at a time.
diff --git a/src/afs/afs_init.c b/src/afs/afs_init.c
index b59db0874..f172019a2 100644
--- a/src/afs/afs_init.c
+++ b/src/afs/afs_init.c
@@ -225,23 +225,23 @@ afs_ComputeCacheParms(void)
 
 
 /*
- * LookupInodeByPath
+ * afs_LookupInodeByPath
  *
  * Look up inode given a file name.
  * Optionally return the vnode too.
  * If the vnode is not returned, we rele it.
  */
-static int
-LookupInodeByPath(char *filename, ino_t * inode, struct vnode **fvpp)
+int
+afs_LookupInodeByPath(char *filename, afs_ufs_dcache_id_t *inode, struct vnode **fvpp)
 {
     afs_int32 code;
 
-#ifdef AFS_LINUX22_ENV
+#if defined(AFS_LINUX22_ENV)
     struct dentry *dp;
     code = gop_lookupname(filename, AFS_UIOSYS, 0, &dp);
     if (code)
 	return code;
-    *inode = dp->d_inode->i_ino;
+    osi_get_fh(dp, inode);
     dput(dp);
 #else
     struct vnode *filevp;
@@ -254,7 +254,7 @@ LookupInodeByPath(char *filename, ino_t * inode, struct vnode **fvpp)
     else {
 	AFS_RELE(filevp);
     }
-#endif /* AFS_LINUX22_ENV */
+#endif
 
     return 0;
 }
@@ -262,25 +262,15 @@ LookupInodeByPath(char *filename, ino_t * inode, struct vnode **fvpp)
 int
 afs_InitCellInfo(char *afile)
 {
-    ino_t inode = 0;
-    int code;
-#if defined(LINUX_USE_FH)
-    struct fid fh;
-    int fh_type;
-    int max_len = sizeof(struct fid);
-    struct dentry *dp;
-#endif
-
+    afs_dcache_id_t inode;
+    int code = 0;
+    
 #ifdef AFS_CACHE_VNODE_PATH
-    return afs_cellname_init(AFS_CACHE_CELLS_INODE, code);
-#elif defined(LINUX_USE_FH)
-    code = gop_lookupname(afile, AFS_UIOSYS, 0, &dp);
-    fh_type = osi_get_fh(dp, &fh, &max_len);
-    return afs_cellname_init(&fh, fh_type, code);
+    inode.ufs = AFS_CACHE_CELLS_INODE;
 #else
-    code = LookupInodeByPath(afile, &inode, NULL);
-    return afs_cellname_init(inode, code);
+    code = afs_LookupInodeByPath(afile, &inode.ufs, NULL);
 #endif
+    return afs_cellname_init(&inode, code);
 }
 
 /*
@@ -302,12 +292,8 @@ afs_InitCellInfo(char *afile)
 int
 afs_InitVolumeInfo(char *afile)
 {
-    int code;
+    int code = 0;
     struct osi_file *tfile;
-#if defined(LINUX_USE_FH)
-    int max_len = sizeof(struct fid);
-    struct dentry *dp;
-#endif
 
     AFS_STATCNT(afs_InitVolumeInfo);
 #if defined(AFS_XBSD_ENV)
@@ -324,22 +310,15 @@ afs_InitVolumeInfo(char *afile)
      * are things which try to get the volumeInode, and since we keep
      * it in the cache...
      */
-    code = LookupInodeByPath(afile, &volumeInode, &volumeVnode);
+    code = afs_LookupInodeByPath(afile, &volumeInode.ufs, &volumeVnode);
 #elif defined(AFS_CACHE_VNODE_PATH)
-    volumeInode = AFS_CACHE_VOLUME_INODE;
-#elif defined(LINUX_USE_FH)
-    code = gop_lookupname(afile, AFS_UIOSYS, 0, &dp);
-    volumeinfo_fh_type = osi_get_fh(dp, &volumeinfo_fh, &max_len);
+    volumeInode.ufs = AFS_CACHE_VOLUME_INODE;
 #else
-    code = LookupInodeByPath(afile, &volumeInode, NULL);
+    code = afs_LookupInodeByPath(afile, &volumeInode.ufs, NULL);
 #endif
     if (code)
 	return code;
-#if defined(LINUX_USE_FH)
-    tfile = osi_UFSOpen_fh(&volumeinfo_fh, volumeinfo_fh_type);
-#else
-    tfile = afs_CFileOpen(volumeInode);
-#endif
+    tfile = afs_CFileOpen(&volumeInode);
     afs_CFileTruncate(tfile, 0);
     afs_CFileClose(tfile);
     return 0;
@@ -450,10 +429,10 @@ afs_InitCacheInfo(register char *afile)
 #endif
     }
 #if defined(AFS_LINUX20_ENV)
-    cacheInode = filevp->i_ino;
+    cacheInode.ufs = filevp->i_ino;
     afs_cacheSBp = filevp->i_sb;
 #elif defined(AFS_XBSD_ENV)
-    cacheInode = VTOI(filevp)->i_number;
+    cacheInode.ufs = VTOI(filevp)->i_number;
     cacheDev.mp = filevp->v_mount;
     cacheDev.held_vnode = filevp;
     vref(filevp);		/* Make sure mount point stays busy. XXX */
@@ -468,19 +447,15 @@ afs_InitCacheInfo(register char *afile)
 #ifndef AFS_DARWIN80_ENV
     afs_cacheVfsp = filevp->v_vfsp;
 #endif
-    cacheInode = afs_vnodeToInumber(filevp);
+    cacheInode.ufs = afs_vnodeToInumber(filevp);
 #else
-    cacheInode = AFS_CACHE_ITEMS_INODE;
+    cacheInode.ufs = AFS_CACHE_ITEMS_INODE;
 #endif
     cacheDev.dev = afs_vnodeToDev(filevp);
 #endif /* AFS_LINUX20_ENV */
     AFS_RELE(filevp);
 #endif /* AFS_LINUX22_ENV */
-#if defined(LINUX_USE_FH)
-    tfile = osi_UFSOpen_fh(&cacheitems_fh, cacheitems_fh_type);
-#else
-    tfile = osi_UFSOpen(cacheInode);
-#endif
+    tfile = osi_UFSOpen(&cacheInode);
     afs_osi_Stat(tfile, &tstat);
     cacheInfoModTime = tstat.mtime;
     code = afs_osi_Read(tfile, -1, &theader, sizeof(theader));
@@ -705,9 +680,8 @@ shutdown_cache(void)
 	    cacheDev.held_vnode = NULL;
 	}
 #endif
-#if !defined(LINUX_USE_FH)
-	cacheInode = volumeInode = (ino_t) 0;
-#endif
+	afs_reset_inode(&cacheInode);
+	afs_reset_inode(&volumeInode);
 	cacheInfoModTime = 0;
 
 	afs_fsfragsize = 1023;
diff --git a/src/afs/afs_memcache.c b/src/afs/afs_memcache.c
index 9ea744a95..2f0b7e9d0 100644
--- a/src/afs/afs_memcache.c
+++ b/src/afs/afs_memcache.c
@@ -89,21 +89,16 @@ afs_MemCacheClose(struct osi_file *file)
     return 0;
 }
 
-#if defined(AFS_SUN57_64BIT_ENV) || defined(AFS_SGI62_ENV)
 void *
-afs_MemCacheOpen(ino_t blkno)
-#else
-void *
-afs_MemCacheOpen(afs_int32 blkno)
-#endif
+afs_MemCacheOpen(afs_dcache_id_t *ainode)
 {
     struct memCacheEntry *mep;
 
-    if (blkno < 0 || blkno > memMaxBlkNumber) {
+    if (ainode->mem < 0 || ainode->mem > memMaxBlkNumber) {
 	osi_Panic("afs_MemCacheOpen: invalid block #");
     }
-    mep = (memCache + blkno);
-    afs_Trace3(afs_iclSetp, CM_TRACE_MEMOPEN, ICL_TYPE_INT32, blkno,
+    mep = (memCache + ainode->mem);
+    afs_Trace3(afs_iclSetp, CM_TRACE_MEMOPEN, ICL_TYPE_INT32, ainode->mem,
 	       ICL_TYPE_POINTER, mep, ICL_TYPE_POINTER, mep ? mep->data : 0);
     return (void *)mep;
 }
@@ -176,10 +171,10 @@ afs_MemReadvBlk(register struct memCacheEntry *mceP, int offset,
 }
 
 int
-afs_MemReadUIO(ino_t blkno, struct uio *uioP)
+afs_MemReadUIO(afs_dcache_id_t *ainode, struct uio *uioP)
 {
     register struct memCacheEntry *mceP =
-	(struct memCacheEntry *)afs_MemCacheOpen(blkno);
+	(struct memCacheEntry *)afs_MemCacheOpen(ainode);
     int length = mceP->size - AFS_UIO_OFFSET(uioP);
     afs_int32 code;
 
@@ -280,10 +275,10 @@ afs_MemWritevBlk(register struct memCacheEntry *mceP, int offset,
 }
 
 int
-afs_MemWriteUIO(ino_t blkno, struct uio *uioP)
+afs_MemWriteUIO(afs_dcache_id_t *ainode, struct uio *uioP)
 {
     register struct memCacheEntry *mceP =
-	(struct memCacheEntry *)afs_MemCacheOpen(blkno);
+	(struct memCacheEntry *)afs_MemCacheOpen(ainode);
     afs_int32 code;
 
     AFS_STATCNT(afs_MemWriteUIO);
diff --git a/src/afs/afs_prototypes.h b/src/afs/afs_prototypes.h
index a84303a51..7eb42d3c0 100644
--- a/src/afs/afs_prototypes.h
+++ b/src/afs/afs_prototypes.h
@@ -130,11 +130,7 @@ extern struct afs_q CellLRU;
 
 extern void afs_CellInit(void);
 extern void shutdown_cell(void);
-#if defined(LINUX_USE_FH)
-extern int afs_cellname_init(struct fid *fh, int fh_type, int lookupcode);
-#else
-extern int afs_cellname_init(ino_t inode, int lookupcode);
-#endif
+extern int afs_cellname_init(afs_dcache_id_t *inode, int lookupcode);
 extern int afs_cellname_write(void);
 extern afs_int32 afs_NewCell(char *acellName, afs_int32 * acellHosts,
 			     int aflags, char *linkedcname, u_short fsport,
@@ -237,12 +233,7 @@ extern int cacheDiskType;
 extern afs_uint32 afs_tpct1, afs_tpct2, splitdcache;
 extern unsigned char *afs_indexFlags;
 extern struct afs_cacheOps *afs_cacheType;
-#if defined(LINUX_USE_FH)
-extern struct fid cacheitems_fh;
-extern int cacheitems_fh_type;
-#else
-extern ino_t cacheInode;
-#endif
+extern afs_dcache_id_t cacheInode;
 extern struct osi_file *afs_cacheInodep;
 extern void afs_dcacheInit(int afiles, int ablocks, int aDentries, int achunk,
 			   int aflags);
@@ -428,6 +419,8 @@ extern int afs_ResourceInit(int preallocs);
 extern void shutdown_cache(void);
 extern void shutdown_vnodeops(void);
 extern void shutdown_AFS(void);
+extern int afs_LookupInodeByPath(char *filename, afs_ufs_dcache_id_t *inode,
+				 struct vnode **fvpp);
 
 /* afs_lock.c */
 extern void Lock_Init(register struct afs_lock *lock);
@@ -475,21 +468,17 @@ extern void shutdown_mariner(void);
 /* afs_memcache.c */
 extern int afs_InitMemCache(int blkCount, int blkSize, int flags);
 extern int afs_MemCacheClose(struct osi_file *file);
-#if defined(AFS_SUN57_64BIT_ENV) || defined(AFS_SGI62_ENV)
-extern void *afs_MemCacheOpen(ino_t blkno);
-#else
-extern void *afs_MemCacheOpen(afs_int32 blkno);
-#endif
+extern void *afs_MemCacheOpen(afs_dcache_id_t *ainode);
 extern int afs_MemReadBlk(register struct osi_file *fP, int offset,
 			  void *dest, int size);
 extern int afs_MemReadvBlk(register struct memCacheEntry *mceP, int offset,
 			   struct iovec *iov, int nio, int size);
-extern int afs_MemReadUIO(ino_t blkno, struct uio *uioP);
+extern int afs_MemReadUIO(afs_dcache_id_t *ainode, struct uio *uioP);
 extern int afs_MemWriteBlk(register struct osi_file *fP, int offset,
 			   void *src, int size);
 extern int afs_MemWritevBlk(register struct memCacheEntry *mceP, int offset,
 			    struct iovec *iov, int nio, int size);
-extern int afs_MemWriteUIO(ino_t blkno, struct uio *uioP);
+extern int afs_MemWriteUIO(afs_dcache_id_t *ainode, struct uio *uioP);
 extern int afs_MemCacheTruncate(register struct osi_file *fP,
 				int size);
 extern int afs_MemCacheStoreProc(register struct rx_call *acall,
@@ -666,15 +655,9 @@ extern int afs_syscall_iincdec(int, int, int, int);
 
 /* ARCH/osi_file.c */
 extern int afs_osicred_initialized;
-#if defined(AFS_SUN57_64BIT_ENV) || defined(AFS_SGI62_ENV)
-extern void *osi_UFSOpen(ino_t ainode);
-#else
-#if defined(LINUX_USE_FH)
-extern void *osi_UFSOpen_fh(struct fid *fh, int fh_type);
-extern int osi_get_fh(struct dentry *dp, struct fid *fh, int *max_len);
-#else
-extern void *osi_UFSOpen(afs_int32 ainode);
-#endif
+extern void *osi_UFSOpen(afs_dcache_id_t *ainode);
+#if defined(AFS_LINUX22_ENV)
+extern void osi_get_fh(struct dentry *dp, afs_ufs_dcache_id_t *ainode);
 #endif
 extern int afs_osi_Stat(register struct osi_file *afile,
 			register struct osi_stat *astat);
@@ -1276,12 +1259,7 @@ extern afs_int32 afs_FVIndex;
 extern afs_int32 afs_volCounter;
 extern afs_rwlock_t afs_xvolume;
 extern struct volume *afs_volumes[NVOLS];
-#if defined(LINUX_USE_FH)
-extern struct fid volumeinfo_fh;
-extern int volumeinfo_fh_type;
-#else
-extern ino_t volumeInode;
-#endif
+extern afs_dcache_id_t volumeInode;
 extern struct volume *afs_FindVolume(struct VenusFid *afid,
 				     afs_int32 locktype);
 extern struct volume *afs_freeVolList;
diff --git a/src/afs/afs_segments.c b/src/afs/afs_segments.c
index 5df9743cf..b6da6460a 100644
--- a/src/afs/afs_segments.c
+++ b/src/afs/afs_segments.c
@@ -417,7 +417,7 @@ afs_StoreAllSegments(register struct vcache *avc, struct vrequest *areq,
 				       ICL_TYPE_POINTER, avc, ICL_TYPE_INT32,
 				       tdc->f.chunk, ICL_TYPE_INT32,
 				       tdc->index, ICL_TYPE_INT32,
-				       tdc->f.inode);
+				       afs_inode2trace(&tdc->f.inode));
 			    shouldwake = 0;
 			    if (nomore) {
 				if (avc->asynchrony == -1) {
@@ -430,11 +430,7 @@ afs_StoreAllSegments(register struct vcache *avc, struct vrequest *areq,
 				    shouldwake = &nomore;
 				}
 			    }
-#if defined(LINUX_USE_FH)
-			    tfile = afs_CFileOpen(&tdc->f.fh, tdc->f.fh_type);
-#else
-			    tfile = afs_CFileOpen(tdc->f.inode);
-#endif
+			    tfile = afs_CFileOpen(&tdc->f.inode);
 #ifndef AFS_NOSTATS
 			    xferP =
 				&(afs_stats_cmfullperf.rpc.
@@ -954,11 +950,7 @@ afs_ExtendSegments(struct vcache *avc, afs_size_t alen, struct vrequest *areq) {
 	if (offset + toAdd > AFS_CHUNKTOSIZE(tdc->f.chunk)) {
 	    toAdd = AFS_CHUNKTOSIZE(tdc->f.chunk) - offset;
 	}
-#if defined(LINUX_USE_FH)
-        tfile = afs_CFileOpen(&tdc->f.fh, tdc->f.fh_type);
-#else
-        tfile = afs_CFileOpen(tdc->f.inode);
-#endif
+        tfile = afs_CFileOpen(&tdc->f.inode);
 	while(tdc->validPos < avc->f.m.Length + toAdd) {
 	     afs_size_t towrite;
 
@@ -1109,11 +1101,7 @@ afs_TruncateAllSegments(register struct vcache *avc, afs_size_t alen,
 	ObtainSharedLock(&tdc->lock, 672);
 	if (newSize < tdc->f.chunkBytes) {
 	    UpgradeSToWLock(&tdc->lock, 673);
-#if defined(LINUX_USE_FH)
-	    tfile = afs_CFileOpen(&tdc->f.fh, tdc->f.fh_type);
-#else
-	    tfile = afs_CFileOpen(tdc->f.inode);
-#endif
+	    tfile = afs_CFileOpen(&tdc->f.inode);
 	    afs_CFileTruncate(tfile, newSize);
 	    afs_CFileClose(tfile);
 	    afs_AdjustSize(tdc, newSize);
diff --git a/src/afs/afs_volume.c b/src/afs/afs_volume.c
index cff5801ad..a3470bb77 100644
--- a/src/afs/afs_volume.c
+++ b/src/afs/afs_volume.c
@@ -58,12 +58,7 @@ RCSID
 #endif /* vlserver error base define */
 
 /* Exported variables */
-#if defined(LINUX_USE_FH)
-struct fid volumeinfo_fh;     /* File handle for VolumeItems file */
-int volumeinfo_fh_type;
-#else
-ino_t volumeInode;            /* Inode for VolumeItems file */
-#endif
+afs_dcache_id_t volumeInode;	/* Inode for VolumeItems file */
 afs_rwlock_t afs_xvolume;	/** allocation lock for volumes */
 struct volume *afs_freeVolList;
 struct volume *afs_volumes[NVOLS];
@@ -164,11 +159,7 @@ afs_UFSGetVolSlot(void)
 	     * next chain
 	     */
 	    if (afs_FVIndex != tv->vtix) {
-#if defined(LINUX_USE_FH)
-		tfile = osi_UFSOpen_fh(&volumeinfo_fh, volumeinfo_fh_type);
-#else
-		tfile = osi_UFSOpen(volumeInode);
-#endif
+		tfile = osi_UFSOpen(&volumeInode);
 		code =
 		    afs_osi_Read(tfile, sizeof(struct fvolume) * tv->vtix,
 				 &staticFVolume, sizeof(struct fvolume));
@@ -185,11 +176,7 @@ afs_UFSGetVolSlot(void)
 	staticFVolume.dotdot = tv->dotdot;
 	staticFVolume.rootVnode = tv->rootVnode;
 	staticFVolume.rootUnique = tv->rootUnique;
-#if defined(LINUX_USE_FH)
-	tfile = osi_UFSOpen_fh(&volumeinfo_fh, volumeinfo_fh_type);
-#else
-	tfile = osi_UFSOpen(volumeInode);
-#endif
+	tfile = osi_UFSOpen(&volumeInode);
 	code =
 	    afs_osi_Write(tfile, sizeof(struct fvolume) * afs_FVIndex,
 			  &staticFVolume, sizeof(struct fvolume));
@@ -558,11 +545,7 @@ afs_SetupVolume(afs_int32 volid, char *aname, void *ve, struct cell *tcell,
 	for (j = fvTable[FVHash(tv->cell, volid)]; j != 0; j = tf->next) {
 	    if (afs_FVIndex != j) {
 		struct osi_file *tfile;
-#if defined(LINUX_USE_FH)
-	        tfile = osi_UFSOpen_fh(&volumeinfo_fh, volumeinfo_fh_type);
-#else
-	        tfile = osi_UFSOpen(volumeInode);
-#endif
+	        tfile = osi_UFSOpen(&volumeInode);
 		err =
 		    afs_osi_Read(tfile, sizeof(struct fvolume) * j,
 				 &staticFVolume, sizeof(struct fvolume));