void *
-osi_UFSOpen(afs_int32 ainode)
+osi_UFSOpen(afs_dcache_id_t *ainode)
{
struct inode *ip;
register struct osi_file *afile = NULL;
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);
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;
}
}
void *
-osi_UFSOpen(afs_int32 ainode)
+osi_UFSOpen(afs_dcache_id_t *ainode)
{
struct vnode *vp;
struct vattr va;
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;
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
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
void *
-osi_UFSOpen(afs_int32 ainode)
+osi_UFSOpen(afs_dcache_id_t *ainode)
{
struct osi_file *afile;
struct vnode *vp;
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)
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;
}
void *
-osi_UFSOpen(afs_int32 ainode)
+osi_UFSOpen(afs_dcache_id_t *ainode)
{
struct inode *ip;
register struct osi_file *afile = NULL;
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);
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;
}
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);
/* 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;
}
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;
}
#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;
}
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;
#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));
#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;
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;
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
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;
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;
void *
-osi_UFSOpen(afs_int32 ainode)
+osi_UFSOpen(afs_dcache_id_t *ainode)
{
struct inode *ip;
register struct osi_file *afile = NULL;
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) {
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;
}
void *
-osi_UFSOpen(afs_int32 ainode)
+osi_UFSOpen(afs_dcache_id_t *ainode)
{
struct osi_file *afile;
struct vnode *vp;
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;
#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;
}
}
void *
-osi_VxfsOpen(afs_int32 ainode)
+osi_VxfsOpen(afs_dcache_id_t *ainode)
{
struct vnode *vp;
register struct osi_file *afile = NULL;
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);
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;
* 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;
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()
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);
#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;
#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);
* 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;
AFS_ASSERT_GLOCK();
- if (ino > n_osi_files) {
+ if (ino->ufs > n_osi_files) {
u.u_error = ENOENT;
return NULL;
}
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));
}
fp->size = st.st_size;
fp->offset = 0;
- fp->inum = ino;
+ fp->inum = ino->ufs;
fp->vnode = (struct usr_vnode *)fp;
AFS_GLOCK();
tuio.afsio_offset = offset;
#endif
- code = afs_MemReadUIO(tdc->f.inode, tuiop);
+ code = afs_MemReadUIO(&tdc->f.inode, tuiop);
if (code) {
error = code;
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);
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);
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);
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);
#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--;
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 */
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;
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
/* 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)
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;
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;
/* 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 */
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);
}
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 */
*/
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;
* \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;
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;
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;
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;
*/
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,
};
/* 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)
#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 */
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;
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,
/*
* 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);
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);
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);
* 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;
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;
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;
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");
}
/* 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.
/*
- * 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;
else {
AFS_RELE(filevp);
}
-#endif /* AFS_LINUX22_ENV */
+#endif
return 0;
}
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);
}
/*
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)
* 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;
#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 */
#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));
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;
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;
}
}
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;
}
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);
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,
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);
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);
/* 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,
/* 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);
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;
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) {
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.
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;
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);
#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];
* 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));
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));
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));
projects / packages / o / openafs.git / commitdiff