afile = (struct osi_file *)osi_AllocSmallSpace(sizeof(struct osi_file));
AFS_GUNLOCK();
#ifdef AFS_CACHE_VNODE_PATH
- if (ainode->ufs < 0) {
- switch (ainode->ufs) {
- case AFS_CACHE_CELLS_INODE:
- snprintf(fname, 1024, "%s/%s", afs_cachebasedir, "CellItems");
- break;
- case AFS_CACHE_ITEMS_INODE:
- snprintf(fname, 1024, "%s/%s", afs_cachebasedir, "CacheItems");
- break;
- case AFS_CACHE_VOLUME_INODE:
- snprintf(fname, 1024, "%s/%s", afs_cachebasedir, "VolumeItems");
- break;
- default:
- osi_Panic("Invalid negative inode");
- }
- } else {
- dummy = ainode->ufs / afs_numfilesperdir;
- snprintf(fname, 1024, "%s/D%d/V%d", afs_cachebasedir, dummy, ainode->ufs);
+ if (!ainode->ufs) {
+ osi_Panic("No cache inode\n");
}
- code = vnode_open(fname, O_RDWR, 0, 0, &vp, afs_osi_ctxtp);
+ code = vnode_open(ainode->ufs, O_RDWR, 0, 0, &vp, afs_osi_ctxtp);
#else
#ifndef AFS_DARWIN80_ENV
if (afs_CacheFSType == AFS_APPL_HFS_CACHE)
register struct osi_file *afile = NULL;
afs_int32 code = 0;
int dummy;
- char fname[1024];
#ifdef AFS_CACHE_VNODE_PATH
char namebuf[1024];
struct pathname lookpn;
/*
* AFS_CACHE_VNODE_PATH can be used with any file system, including ZFS or tmpfs.
- * The ainode is not an inode number but a signed index used to generate file names.
+ * The ainode is not an inode number but a path.
*/
#ifdef AFS_CACHE_VNODE_PATH
- switch (ainode->ufs) {
- case AFS_CACHE_CELLS_INODE:
- snprintf(fname, 1024, "%s/%s", afs_cachebasedir, "CellItems");
- break;
- case AFS_CACHE_ITEMS_INODE:
- snprintf(fname, 1024, "%s/%s", afs_cachebasedir, "CacheItems");
- break;
- case AFS_CACHE_VOLUME_INODE:
- snprintf(fname, 1024, "%s/%s", afs_cachebasedir, "VolumeItems");
- break;
- default:
- 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()
- * We need to run as root So must use low level lookuppnvp
- * assume fname starts with /
+ * We need to run as root So must use low level lookuppnvp
+ * assume fname starts with /
*/
- code = pn_get_buf(fname, AFS_UIOSYS, &lookpn, namebuf, sizeof(namebuf));
+ code = pn_get_buf(ainode->ufs, AFS_UIOSYS, &lookpn, namebuf, sizeof(namebuf));
if (code != 0)
- osi_Panic("UfsOpen: pn_get_buf failed %ld %s %ld", code, fname, ainode->ufs);
+ osi_Panic("UfsOpen: pn_get_buf failed %ld %s", code, 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->ufs);
+ osi_Panic("UfsOpen: lookuppnvp failed %ld %s", code, 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->ufs);
+ osi_Panic("UfsOpen: VOP_OPEN failed %ld %s", code, ainode->ufs);
#else
code =
AFS_GLOCK();
if (code) {
osi_FreeSmallSpace(afile);
- osi_Panic("UfsOpen: igetinode failed %ld %s %ld", code, fname, ainode->ufs);
+ osi_Panic("UfsOpen: igetinode failed %ld %s", code, ainode->ufs);
}
#ifdef AFS_CACHE_VNODE_PATH
- afile->vnode = vp;
- code = afs_osi_Stat(afile, &tstat);
- afile->size = tstat.size;
+ afile->vnode = vp;
+ code = afs_osi_Stat(afile, &tstat);
+ afile->size = tstat.size;
#else
afile->vnode = ITOV(ip);
afile->size = VTOI(afile->vnode)->i_size;
afs_int32 otherCSize;
};
-#if defined(AFS_CACHE_VNODE_PATH) || defined(UKERNEL)
+#if defined(AFS_CACHE_VNODE_PATH)
+typedef char *afs_ufs_dcache_id_t;
+#elif 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
}
#endif
-static void
-wait_for_cachedefs(void) {
-#ifdef AFS_CACHE_VNODE_PATH
- if (cacheDiskType != AFS_FCACHE_TYPE_MEM)
- while ((afs_numcachefiles < 1) || (afs_numfilesperdir < 1) ||
- (afs_cachebasedir[0] != '/')) {
- printf("afs: waiting for cache parameter definitions\n");
- afs_osi_Sleep(&afs_initState);
- }
-#endif
-}
-
#ifdef AFS_DARWIN100_ENV
#define AFSKPTR(X) k ## X
int
} else
code = 0;
} else if (parm == AFSOP_CACHEFILE || parm == AFSOP_CACHEINFO
- || parm == AFSOP_VOLUMEINFO || parm == AFSOP_AFSLOG
- || parm == AFSOP_CELLINFO || parm == AFSOP_CACHEBASEDIR) {
+ || parm == AFSOP_VOLUMEINFO || parm == AFSOP_CELLINFO) {
char *tbuffer = osi_AllocSmallSpace(AFS_SMALLOCSIZ);
code = 0;
#ifdef AFS_DARWIN80_ENV
get_vfs_context();
#endif
- if (parm == AFSOP_CACHEBASEDIR) {
- strncpy(afs_cachebasedir, tbuffer, 1024);
- afs_cachebasedir[1023] = '\0';
- afs_osi_Wakeup(&afs_initState);
- } else if (parm == AFSOP_CACHEFILE) {
- wait_for_cachedefs();
+ if (parm == AFSOP_CACHEFILE) {
code = afs_InitCacheFile(tbuffer, 0);
} else if (parm == AFSOP_CACHEINFO) {
- wait_for_cachedefs();
code = afs_InitCacheInfo(tbuffer);
} else if (parm == AFSOP_VOLUMEINFO) {
- wait_for_cachedefs();
code = afs_InitVolumeInfo(tbuffer);
} else if (parm == AFSOP_CELLINFO) {
- wait_for_cachedefs();
code = afs_InitCellInfo(tbuffer);
}
#ifdef AFS_DARWIN80_ENV
}
osi_FreeSmallSpace(tbuffer);
} else if (parm == AFSOP_GO) {
-#ifdef AFS_CACHE_VNODE_PATH
- if (cacheDiskType != AFS_FCACHE_TYPE_MEM) {
- afs_int32 dummy;
-
- wait_for_cachedefs();
-
-#ifdef AFS_DARWIN80_ENV
- get_vfs_context();
-#endif
- if ((afs_numcachefiles > 0) && (afs_numfilesperdir > 0) &&
- (afs_cachebasedir[0] == '/')) {
- for (dummy = 0; dummy < afs_numcachefiles; dummy++) {
- code = afs_InitCacheFile(NULL, dummy);
- }
- }
-#ifdef AFS_DARWIN80_ENV
- put_vfs_context();
-#endif
- }
-#endif
/* the generic initialization calls come here. One parameter: should we do the
* set-time operation on this workstation */
if (afs_Go_Done)
struct afs_q *cq, *tq;
struct cell *tc;
+#ifdef AFS_CACHE_VNODE_PATH
+ if (cacheDiskType != AFS_FCACHE_TYPE_MEM) {
+ afs_osi_FreeStr(afs_cellname_inode.ufs);
+ }
+#endif
AFS_RWLOCK_INIT(&afs_xcell, "afs_xcell");
for (cq = CellLRU.next; cq != &CellLRU; cq = tq) {
}
} else {
/* Add any other 'complex' inode types here ... */
-#if defined(UKERNEL) || !defined(LINUX_USE_FH)
+#if defined(UKERNEL) || !(defined(LINUX_USE_FH) || defined(AFS_CACHE_VNODE_PATH))
tdc->f.inode.ufs = ainode;
#else
osi_Panic("Can't init cache with inode numbers when complex inodes are "
{
int i;
+#ifdef AFS_CACHE_VNODE_PATH
+ if (cacheDiskType != AFS_FCACHE_TYPE_MEM) {
+ struct dcache *tdc;
+ for (i = 0; i < afs_cacheFiles; i++) {
+ tdc = afs_indexTable[i];
+ if (tdc) {
+ afs_osi_FreeStr(tdc->f.inode.ufs);
+ }
+ }
+ }
+#endif
+
afs_osi_Free(afs_dvnextTbl, afs_cacheFiles * sizeof(afs_int32));
afs_osi_Free(afs_dcnextTbl, afs_cacheFiles * sizeof(afs_int32));
afs_osi_Free(afs_indexTable, afs_cacheFiles * sizeof(struct dcache *));
code = gop_lookupname(filename, AFS_UIOSYS, 0, &filevp);
if (code)
return code;
+#ifdef AFS_CACHE_VNODE_PATH
+ *inode = afs_strdup(filename);
+#else
*inode = afs_vnodeToInumber(filevp);
+#endif
if (fvpp)
*fvpp = filevp;
else {
afs_dcache_id_t inode;
int code = 0;
-#ifdef AFS_CACHE_VNODE_PATH
- inode.ufs = AFS_CACHE_CELLS_INODE;
-#else
code = afs_LookupInodeByPath(afile, &inode.ufs, NULL);
-#endif
return afs_cellname_init(&inode, code);
}
* it in the cache...
*/
code = afs_LookupInodeByPath(afile, &volumeInode.ufs, &volumeVnode);
-#elif defined(AFS_CACHE_VNODE_PATH)
- volumeInode.ufs = AFS_CACHE_VOLUME_INODE;
#else
code = afs_LookupInodeByPath(afile, &volumeInode.ufs, NULL);
#endif
#endif
cacheInode.ufs = afs_vnodeToInumber(filevp);
#else
- cacheInode.ufs = AFS_CACHE_ITEMS_INODE;
+ afs_LookupInodeByPath(afile, &cacheInode.ufs, NULL);
#endif
cacheDev.dev = afs_vnodeToDev(filevp);
#endif /* AFS_LINUX20_ENV */
{
AFS_STATCNT(shutdown_cache);
afs_WriteThroughDSlots();
- if (afs_cold_shutdown) {
+ if (1/*afs_cold_shutdown*/) {
afs_cacheinit_flag = 0;
shutdown_dcache();
shutdown_vcache();
cacheDev.held_vnode = NULL;
}
#endif
+#ifdef AFS_CACHE_VNODE_PATH
+ if (cacheDiskType != AFS_FCACHE_TYPE_MEM) {
+ afs_osi_FreeStr(cacheInode.ufs);
+ afs_osi_FreeStr(volumeInode.ufs);
+ }
+#endif
afs_reset_inode(&cacheInode);
afs_reset_inode(&volumeInode);
cacheInfoModTime = 0;
static char rn[] = "afsd"; /*Name of this routine */
afs_int32 code; /*Result of fork() */
int i;
-#ifndef AFS_CACHE_VNODE_PATH
int currVFile; /*Current AFS cache file number passed in */
-#endif
int mountFlags; /*Flags passed to mount() */
int lookupResult; /*Result of GetLocalCellName() */
int cacheIteration; /*How many times through cache verification */
rn, vFilesFound, cacheFiles, cacheIteration);
} while ((vFilesFound < cacheFiles)
&& (cacheIteration < MAX_CACHE_LOOPS));
-#ifdef AFS_CACHE_VNODE_PATH
- if (afsd_debug)
- printf
- ("%s: Calling AFSOP_CACHEBASEDIR with '%s'\n",
- rn, cacheBaseDir);
- call_syscall(AFSOP_CACHEBASEDIR, cacheBaseDir);
- if (afsd_debug)
- printf
- ("%s: Calling AFSOP_CACHEDIRS with %d dirs\n",
- rn, nFilesPerDir);
- call_syscall(AFSOP_CACHEDIRS, nFilesPerDir);
- if (afsd_debug)
- printf
- ("%s: Calling AFSOP_CACHEFILES with %d files\n",
- rn, cacheFiles);
- call_syscall(AFSOP_CACHEFILES, cacheFiles);
-#endif
} else if (afsd_verbose)
printf("%s: Using memory cache, not swept\n", rn);
if (!(cacheFlags & AFSCALL_INIT_MEMCACHE))
call_syscall(AFSOP_VOLUMEINFO, fullpn_VolInfoFile);
-#ifndef AFS_CACHE_VNODE_PATH
/*
* Give the kernel the names of the AFS files cached on the workstation's
* disk.
(afs_uint32) (inode_for_V[currVFile] >> 32),
(afs_uint32) (inode_for_V[currVFile] & 0xffffffff));
#else
-#if defined(LINUX_USE_FH)
+#if defined(LINUX_USE_FH) || defined(AFS_CACHE_VNODE_PATH)
sprintf(fullpn_VFile, "%s/D%d/V%d", cacheBaseDir, dir_for_V[currVFile], currVFile);
call_syscall(AFSOP_CACHEFILE, fullpn_VFile);
#else
#endif
#endif
}
-#endif
/*end for */
/*