Remove now-unused Coda namecache.
MFC after: 1 month
This commit is contained in:
parent
a9d8becadf
commit
70ff5c5a61
@ -1,700 +0,0 @@
|
||||
/*-
|
||||
* Coda: an Experimental Distributed File System
|
||||
* Release 3.1
|
||||
*
|
||||
* Copyright (c) 1987-1998 Carnegie Mellon University
|
||||
* All Rights Reserved
|
||||
*
|
||||
* Permission to use, copy, modify and distribute this software and its
|
||||
* documentation is hereby granted, provided that both the copyright
|
||||
* notice and this permission notice appear in all copies of the
|
||||
* software, derivative works or modified versions, and any portions
|
||||
* thereof, and that both notices appear in supporting documentation, and
|
||||
* that credit is given to Carnegie Mellon University in all documents
|
||||
* and publicity pertaining to direct or indirect use of this code or its
|
||||
* derivatives.
|
||||
*
|
||||
* CODA IS AN EXPERIMENTAL SOFTWARE SYSTEM AND IS KNOWN TO HAVE BUGS,
|
||||
* SOME OF WHICH MAY HAVE SERIOUS CONSEQUENCES. CARNEGIE MELLON ALLOWS
|
||||
* FREE USE OF THIS SOFTWARE IN ITS "AS IS" CONDITION. CARNEGIE MELLON
|
||||
* DISCLAIMS ANY LIABILITY OF ANY KIND FOR ANY DAMAGES WHATSOEVER
|
||||
* RESULTING DIRECTLY OR INDIRECTLY FROM THE USE OF THIS SOFTWARE OR OF
|
||||
* ANY DERIVATIVE WORK.
|
||||
*
|
||||
* Carnegie Mellon encourages users of this software to return any
|
||||
* improvements or extensions that they make, and to grant Carnegie
|
||||
* Mellon the rights to redistribute these changes without encumbrance.
|
||||
*
|
||||
* @(#) src/sys/coda/coda_namecache.c,v 1.1.1.1 1998/08/29 21:14:52 rvb Exp $
|
||||
*/
|
||||
/*-
|
||||
* Mach Operating System
|
||||
* Copyright (c) 1990 Carnegie-Mellon University
|
||||
* Copyright (c) 1989 Carnegie-Mellon University
|
||||
* All rights reserved. The CMU software License Agreement specifies
|
||||
* the terms and conditions for use and redistribution.
|
||||
*/
|
||||
|
||||
/*
|
||||
* This code was written for the Coda filesystem at Carnegie Mellon University.
|
||||
* Contributers include David Steere, James Kistler, and M. Satyanarayanan.
|
||||
*/
|
||||
|
||||
/*
|
||||
* This module contains the routines to implement the CODA name cache. The
|
||||
* purpose of this cache is to reduce the cost of translating pathnames into
|
||||
* Vice FIDs. Each entry in the cache contains the name of the file, the
|
||||
* vnode (FID) of the parent directory, and the cred structure of the user
|
||||
* accessing the file.
|
||||
*
|
||||
* The first time a file is accessed, it is looked up by the local Venus
|
||||
* which first ensures that the user has access to the file. In addition we
|
||||
* are guaranteed that Venus will invalidate any name cache entries in case
|
||||
* the user no longer should be able to access the file. For these reasons we
|
||||
* do not need to keep access list information as well as a cred structure
|
||||
* for each entry.
|
||||
*
|
||||
* The table can be accessed through the routines coda_nc_init(),
|
||||
* coda_nc_enter(), coda_nc_lookup(), coda_nc_rmfidcred(), coda_nc_rmfid(),
|
||||
* coda_nc_rmcred(), and coda_nc_purge(). There are several other routines
|
||||
* which aid in the implementation of the hash table.
|
||||
*/
|
||||
|
||||
/*-
|
||||
* NOTES: rvb@cs
|
||||
* 1. The name cache holds a reference to every vnode in it. Hence files
|
||||
* can not be closed or made inactive until they are released.
|
||||
* 2. coda_nc_name(cp) was added to get a name for a cnode pointer for
|
||||
* debugging.
|
||||
* 3. coda_nc_find() has debug code to detect when entries are stored with
|
||||
* different credentials. We don't understand yet, if/how entries are
|
||||
* NOT EQ but still EQUAL.
|
||||
* 4. I wonder if this name cache could be replace by the vnode name cache.
|
||||
* The latter has no zapping functions, so probably not.
|
||||
*/
|
||||
|
||||
#include <sys/cdefs.h>
|
||||
__FBSDID("$FreeBSD$");
|
||||
|
||||
#include <sys/param.h>
|
||||
#include <sys/systm.h>
|
||||
#include <sys/errno.h>
|
||||
#include <sys/lock.h>
|
||||
#include <sys/malloc.h>
|
||||
#include <sys/mutex.h>
|
||||
#include <sys/ucred.h>
|
||||
|
||||
#include <vm/vm.h>
|
||||
#include <vm/vm_object.h>
|
||||
|
||||
#include <fs/coda/coda.h>
|
||||
#include <fs/coda/cnode.h>
|
||||
#include <fs/coda/coda_namecache.h>
|
||||
|
||||
#ifdef DEBUG
|
||||
#include <fs/coda/coda_vnops.h>
|
||||
#endif
|
||||
|
||||
/*
|
||||
* Declaration of the name cache data structure.
|
||||
*/
|
||||
int coda_nc_use = 1; /* Indicate use of CODA Name Cache */
|
||||
int coda_nc_size = CODA_NC_CACHESIZE; /* size of the cache */
|
||||
int coda_nc_hashsize = CODA_NC_HASHSIZE; /* size of the primary hash */
|
||||
|
||||
struct coda_cache *coda_nc_heap; /* pointer to the cache entries */
|
||||
struct coda_hash *coda_nc_hash; /* hash table of coda_cache pointers */
|
||||
struct coda_lru coda_nc_lru; /* head of lru chain */
|
||||
struct coda_nc_statistics coda_nc_stat; /* Keep various stats */
|
||||
|
||||
/*
|
||||
* For testing purposes.
|
||||
*/
|
||||
int coda_nc_debug = 0;
|
||||
|
||||
/*
|
||||
* Entry points for the CODA Name Cache.
|
||||
*/
|
||||
static struct coda_cache *coda_nc_find(struct cnode *dcp,
|
||||
const char *name, int namelen,
|
||||
struct ucred *cred, int hash);
|
||||
static void coda_nc_remove(struct coda_cache *cncp,
|
||||
enum dc_status dcstat);
|
||||
|
||||
/*
|
||||
* Initialize the cache, the LRU structure and the Hash structure(s).
|
||||
*/
|
||||
#define TOTAL_CACHE_SIZE (sizeof(struct coda_cache) * coda_nc_size)
|
||||
#define TOTAL_HASH_SIZE (sizeof(struct coda_hash) * coda_nc_hashsize)
|
||||
|
||||
int coda_nc_initialized = 0; /* Initially the cache has not been initialized */
|
||||
|
||||
void
|
||||
coda_nc_init(void)
|
||||
{
|
||||
int i;
|
||||
|
||||
bzero(&coda_nc_stat, (sizeof(struct coda_nc_statistics)));
|
||||
|
||||
#ifdef CODA_VERBOSE
|
||||
printf("CODA NAME CACHE: CACHE %d, HASH TBL %d\n", CODA_NC_CACHESIZE,
|
||||
CODA_NC_HASHSIZE);
|
||||
#endif
|
||||
CODA_ALLOC(coda_nc_heap, struct coda_cache *, TOTAL_CACHE_SIZE);
|
||||
CODA_ALLOC(coda_nc_hash, struct coda_hash *, TOTAL_HASH_SIZE);
|
||||
coda_nc_lru.lru_next = coda_nc_lru.lru_prev =
|
||||
(struct coda_cache *)LRU_PART(&coda_nc_lru);
|
||||
|
||||
/*
|
||||
* Initialize the heap.
|
||||
*/
|
||||
for (i=0; i < coda_nc_size; i++) {
|
||||
CODA_NC_LRUINS(&coda_nc_heap[i], &coda_nc_lru);
|
||||
CODA_NC_HSHNUL(&coda_nc_heap[i]);
|
||||
coda_nc_heap[i].cp = coda_nc_heap[i].dcp = NULL;
|
||||
}
|
||||
|
||||
/*
|
||||
* Initialize the hashtable.
|
||||
*/
|
||||
for (i=0; i < coda_nc_hashsize; i++)
|
||||
CODA_NC_HSHNUL((struct coda_cache *)&coda_nc_hash[i]);
|
||||
coda_nc_initialized++;
|
||||
}
|
||||
|
||||
/*
|
||||
* Auxillary routines -- shouldn't be entry points.
|
||||
*/
|
||||
static struct coda_cache *
|
||||
coda_nc_find(struct cnode *dcp, const char *name, int namelen,
|
||||
struct ucred *cred, int hash)
|
||||
{
|
||||
struct coda_cache *cncp;
|
||||
int count = 1;
|
||||
|
||||
/*
|
||||
* Hash to find the appropriate bucket, look through the chain for
|
||||
* the right entry (especially right cred, unless cred == 0).
|
||||
*/
|
||||
CODA_NC_DEBUG(CODA_NC_FIND, myprintf(("coda_nc_find(dcp %p, name %s, "
|
||||
"len %d, cred %p, hash %d\n", dcp, name, namelen, cred, hash)););
|
||||
for (cncp = coda_nc_hash[hash].hash_next;
|
||||
cncp != (struct coda_cache *)&coda_nc_hash[hash];
|
||||
cncp = cncp->hash_next, count++) {
|
||||
if ((CODA_NAMEMATCH(cncp, name, namelen, dcp)) &&
|
||||
((cred == 0) || (cncp->cred == cred))) {
|
||||
/* Compare cr_uid instead. */
|
||||
coda_nc_stat.Search_len += count;
|
||||
return (cncp);
|
||||
}
|
||||
#ifdef DEBUG
|
||||
else if (CODA_NAMEMATCH(cncp, name, namelen, dcp)) {
|
||||
printf("coda_nc_find: name %s, new cred = %p, "
|
||||
"cred = %p\n", name, cred, cncp->cred);
|
||||
printf("nref %d, nuid %d, ngid %d // oref %d, "
|
||||
"ocred %d, ogid %d\n", cred->cr_ref,
|
||||
cred->cr_uid, cred->cr_gid, cncp->cred->cr_ref,
|
||||
cncp->cred->cr_uid, cncp->cred->cr_gid);
|
||||
coda_print_cred(cred);
|
||||
coda_print_cred(cncp->cred);
|
||||
}
|
||||
#endif
|
||||
}
|
||||
return (NULL);
|
||||
}
|
||||
|
||||
/*
|
||||
* Enter a new (dir cnode, name) pair into the cache, updating the LRU and
|
||||
* Hash as needed.
|
||||
*/
|
||||
void
|
||||
coda_nc_enter(struct cnode *dcp, const char *name, int namelen,
|
||||
struct ucred *cred, struct cnode *cp)
|
||||
{
|
||||
struct coda_cache *cncp;
|
||||
int hash;
|
||||
|
||||
if (coda_nc_use == 0)
|
||||
return;
|
||||
CODA_NC_DEBUG(CODA_NC_ENTER, myprintf(("Enter: dcp %p cp %p name %s "
|
||||
"cred %p \n", dcp, cp, name, cred)); );
|
||||
if (namelen > CODA_NC_NAMELEN) {
|
||||
CODA_NC_DEBUG(CODA_NC_ENTER, myprintf(("long name enter %s\n",
|
||||
name)););
|
||||
coda_nc_stat.long_name_enters++;
|
||||
return;
|
||||
}
|
||||
hash = CODA_NC_HASH(name, namelen, dcp);
|
||||
cncp = coda_nc_find(dcp, name, namelen, cred, hash);
|
||||
if (cncp != NULL) {
|
||||
/*
|
||||
* Duplicate entry.
|
||||
*/
|
||||
coda_nc_stat.dbl_enters++;
|
||||
return;
|
||||
}
|
||||
coda_nc_stat.enters++;
|
||||
|
||||
/*
|
||||
* Grab the next element in the LRU chain.
|
||||
*/
|
||||
cncp = CODA_NC_LRUGET(coda_nc_lru);
|
||||
|
||||
/*
|
||||
* Remove it from the lists.
|
||||
*/
|
||||
CODA_NC_LRUREM(cncp);
|
||||
if (CODA_NC_VALID(cncp)) {
|
||||
/*
|
||||
* Seems really ugly, but we have to decrement the
|
||||
* appropriate hash bucket length here, so we have to find
|
||||
* the hash bucket.
|
||||
*/
|
||||
coda_nc_hash[CODA_NC_HASH(cncp->name, cncp->namelen,
|
||||
cncp->dcp)].length--;
|
||||
coda_nc_stat.lru_rm++; /* Zapped a valid entry. */
|
||||
CODA_NC_HSHREM(cncp);
|
||||
vrele(CTOV(cncp->dcp));
|
||||
vrele(CTOV(cncp->cp));
|
||||
crfree(cncp->cred);
|
||||
}
|
||||
|
||||
/*
|
||||
* Put a hold on the current vnodes and fill in the cache entry.
|
||||
*/
|
||||
vref(CTOV(cp));
|
||||
vref(CTOV(dcp));
|
||||
cncp->dcp = dcp;
|
||||
cncp->cp = cp;
|
||||
cncp->namelen = namelen;
|
||||
cncp->cred = crhold(cred);
|
||||
bcopy(name, cncp->name, (unsigned)namelen);
|
||||
|
||||
/*
|
||||
* Insert into the lru and hash chains.
|
||||
*/
|
||||
CODA_NC_LRUINS(cncp, &coda_nc_lru);
|
||||
CODA_NC_HSHINS(cncp, &coda_nc_hash[hash]);
|
||||
coda_nc_hash[hash].length++; /* Used for tuning. */
|
||||
CODA_NC_DEBUG(CODA_NC_PRINTCODA_NC, print_coda_nc(););
|
||||
}
|
||||
|
||||
/*
|
||||
* Find the (dir cnode, name) pair in the cache, if its cred matches the
|
||||
* input, return it, otherwise return NULL.
|
||||
*/
|
||||
struct cnode *
|
||||
coda_nc_lookup(struct cnode *dcp, const char *name, int namelen,
|
||||
struct ucred *cred)
|
||||
{
|
||||
struct coda_cache *cncp;
|
||||
int hash;
|
||||
|
||||
if (coda_nc_use == 0)
|
||||
return (NULL);
|
||||
if (namelen > CODA_NC_NAMELEN) {
|
||||
CODA_NC_DEBUG(CODA_NC_LOOKUP, myprintf(("long name lookup "
|
||||
"%s\n",name)););
|
||||
coda_nc_stat.long_name_lookups++;
|
||||
return (NULL);
|
||||
}
|
||||
|
||||
/*
|
||||
* Use the hash function to locate the starting point, then the
|
||||
* search routine to go down the list looking for the correct cred.
|
||||
*/
|
||||
hash = CODA_NC_HASH(name, namelen, dcp);
|
||||
cncp = coda_nc_find(dcp, name, namelen, cred, hash);
|
||||
if (cncp == NULL) {
|
||||
coda_nc_stat.misses++;
|
||||
return (NULL);
|
||||
}
|
||||
coda_nc_stat.hits++;
|
||||
|
||||
/*
|
||||
* Put this entry at the end of the LRU.
|
||||
*/
|
||||
CODA_NC_LRUREM(cncp);
|
||||
CODA_NC_LRUINS(cncp, &coda_nc_lru);
|
||||
|
||||
/*
|
||||
* Move it to the front of the hash chain; don't need to change the
|
||||
* hash bucket length.
|
||||
*/
|
||||
CODA_NC_HSHREM(cncp);
|
||||
CODA_NC_HSHINS(cncp, &coda_nc_hash[hash]);
|
||||
CODA_NC_DEBUG(CODA_NC_LOOKUP, printf("lookup: dcp %p, name %s, cred "
|
||||
"%p = cp %p\n", dcp, name, cred, cncp->cp););
|
||||
return (cncp->cp);
|
||||
}
|
||||
|
||||
static void
|
||||
coda_nc_remove(struct coda_cache *cncp, enum dc_status dcstat)
|
||||
{
|
||||
|
||||
/*
|
||||
* Remove an entry -- vrele(cncp->dcp, cp), crfree(cred), remove it
|
||||
* from it's hash chain, and place it at the head of the lru list.
|
||||
*/
|
||||
CODA_NC_DEBUG(CODA_NC_REMOVE, myprintf(("coda_nc_remove %s from "
|
||||
"parent %s\n", cncp->name, coda_f2s(&cncp->dcp->c_fid))););
|
||||
CODA_NC_HSHREM(cncp);
|
||||
CODA_NC_HSHNUL(cncp); /* Have it be a null chain. */
|
||||
if ((dcstat == IS_DOWNCALL) && (vrefcnt(CTOV(cncp->dcp)) == 1))
|
||||
cncp->dcp->c_flags |= C_PURGING;
|
||||
vrele(CTOV(cncp->dcp));
|
||||
if ((dcstat == IS_DOWNCALL) && (vrefcnt(CTOV(cncp->cp)) == 1))
|
||||
cncp->cp->c_flags |= C_PURGING;
|
||||
vrele(CTOV(cncp->cp));
|
||||
crfree(cncp->cred);
|
||||
bzero(DATA_PART(cncp),DATA_SIZE);
|
||||
|
||||
/*
|
||||
* Put the null entry just after the least-recently-used entry.
|
||||
* LRU_TOP adjusts the pointer to point to the top of the structure.
|
||||
*/
|
||||
CODA_NC_LRUREM(cncp);
|
||||
CODA_NC_LRUINS(cncp, LRU_TOP(coda_nc_lru.lru_prev));
|
||||
}
|
||||
|
||||
/*
|
||||
* Remove all entries with a parent which has the input fid.
|
||||
*/
|
||||
void
|
||||
coda_nc_zapParentfid(CodaFid *fid, enum dc_status dcstat)
|
||||
{
|
||||
struct coda_cache *cncp, *ncncp;
|
||||
int i;
|
||||
|
||||
/*
|
||||
* To get to a specific fid, we might either have another hashing
|
||||
* function or do a sequential search through the cache for the
|
||||
* appropriate entries. The later may be acceptable since I don't
|
||||
* think callbacks or whatever Case 1 covers are frequent occurences.
|
||||
*/
|
||||
if (coda_nc_use == 0)
|
||||
return;
|
||||
CODA_NC_DEBUG(CODA_NC_ZAPPFID, myprintf(("ZapParent: fid %s\n",
|
||||
coda_f2s(fid))););
|
||||
coda_nc_stat.zapPfids++;
|
||||
for (i = 0; i < coda_nc_hashsize; i++) {
|
||||
/*
|
||||
* Need to save the hash_next pointer in case we remove the
|
||||
* entry. remove causes hash_next to point to itself.
|
||||
*/
|
||||
for (cncp = coda_nc_hash[i].hash_next;
|
||||
cncp != (struct coda_cache *)&coda_nc_hash[i];
|
||||
cncp = ncncp) {
|
||||
ncncp = cncp->hash_next;
|
||||
if (coda_fid_eq(&(cncp->dcp->c_fid), fid)) {
|
||||
/* Used for tuning. */
|
||||
coda_nc_hash[i].length--;
|
||||
coda_nc_remove(cncp, dcstat);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/*
|
||||
* Remove all entries which have the same fid as the input.
|
||||
*/
|
||||
void
|
||||
coda_nc_zapfid(CodaFid *fid, enum dc_status dcstat)
|
||||
{
|
||||
struct coda_cache *cncp, *ncncp;
|
||||
int i;
|
||||
|
||||
/*
|
||||
* See comment for zapParentfid. This routine will be used if
|
||||
* attributes are being cached.
|
||||
*/
|
||||
if (coda_nc_use == 0)
|
||||
return;
|
||||
CODA_NC_DEBUG(CODA_NC_ZAPFID, myprintf(("Zapfid: fid %s\n",
|
||||
coda_f2s(fid))););
|
||||
coda_nc_stat.zapFids++;
|
||||
for (i = 0; i < coda_nc_hashsize; i++) {
|
||||
for (cncp = coda_nc_hash[i].hash_next;
|
||||
cncp != (struct coda_cache *)&coda_nc_hash[i];
|
||||
cncp = ncncp) {
|
||||
ncncp = cncp->hash_next;
|
||||
if (coda_fid_eq(&cncp->cp->c_fid, fid)) {
|
||||
/* Used for tuning. */
|
||||
coda_nc_hash[i].length--;
|
||||
coda_nc_remove(cncp, dcstat);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/*
|
||||
* Remove all entries which match the fid and the cred.
|
||||
*
|
||||
* XXX: This is unused.
|
||||
*/
|
||||
void
|
||||
coda_nc_zapvnode(CodaFid *fid, struct ucred *cred, enum dc_status dcsta)
|
||||
{
|
||||
|
||||
/*
|
||||
* See comment for zapfid. I don't think that one would ever want to
|
||||
* zap a file with a specific cred from the kernel. We'll leave this
|
||||
* one unimplemented.
|
||||
*/
|
||||
if (coda_nc_use == 0)
|
||||
return;
|
||||
CODA_NC_DEBUG(CODA_NC_ZAPVNODE, myprintf(("Zapvnode: fid %s cred "
|
||||
"%p\n", coda_f2s(fid), cred)););
|
||||
}
|
||||
|
||||
/*
|
||||
* Remove all entries which have the (dir vnode, name) pair.
|
||||
*/
|
||||
void
|
||||
coda_nc_zapfile(struct cnode *dcp, const char *name, int namelen)
|
||||
{
|
||||
struct coda_cache *cncp;
|
||||
int hash;
|
||||
|
||||
/*
|
||||
* use the hash function to locate the file, then zap all entries of
|
||||
* it regardless of the cred.
|
||||
*/
|
||||
if (coda_nc_use == 0)
|
||||
return;
|
||||
CODA_NC_DEBUG(CODA_NC_ZAPFILE, myprintf(("Zapfile: dcp %p name %s\n",
|
||||
dcp, name)););
|
||||
if (namelen > CODA_NC_NAMELEN) {
|
||||
coda_nc_stat.long_remove++;
|
||||
return;
|
||||
}
|
||||
coda_nc_stat.zapFile++;
|
||||
hash = CODA_NC_HASH(name, namelen, dcp);
|
||||
cncp = coda_nc_find(dcp, name, namelen, 0, hash);
|
||||
while (cncp) {
|
||||
/* Used for tuning. */
|
||||
coda_nc_hash[hash].length--;
|
||||
coda_nc_remove(cncp, NOT_DOWNCALL);
|
||||
cncp = coda_nc_find(dcp, name, namelen, 0, hash);
|
||||
}
|
||||
}
|
||||
|
||||
/*
|
||||
* Remove all the entries for a particular user. Used when tokens expire. A
|
||||
* user is determined by his/her effective user id (id_uid).
|
||||
*/
|
||||
void
|
||||
coda_nc_purge_user(uid_t uid, enum dc_status dcstat)
|
||||
{
|
||||
struct coda_cache *cncp, *ncncp;
|
||||
int hash;
|
||||
|
||||
/*
|
||||
* I think the best approach is to go through the entire cache via
|
||||
* HASH or whatever and zap all entries which match the input cred.
|
||||
* Or just flush the whole cache. It might be best to go through on
|
||||
* basis of LRU since cache will almost always be full and LRU is
|
||||
* more straightforward.
|
||||
*/
|
||||
if (coda_nc_use == 0)
|
||||
return;
|
||||
CODA_NC_DEBUG(CODA_NC_PURGEUSER, myprintf(("ZapDude: uid %x\n",
|
||||
uid)););
|
||||
coda_nc_stat.zapUsers++;
|
||||
for (cncp = CODA_NC_LRUGET(coda_nc_lru);
|
||||
cncp != (struct coda_cache *)(&coda_nc_lru);
|
||||
cncp = ncncp) {
|
||||
ncncp = CODA_NC_LRUGET(*cncp);
|
||||
if ((CODA_NC_VALID(cncp)) &&
|
||||
((cncp->cred)->cr_uid == uid)) {
|
||||
/*
|
||||
* Seems really ugly, but we have to decrement the
|
||||
* appropriate hash bucket length here, so we have to
|
||||
* find the hash bucket.
|
||||
*/
|
||||
hash = CODA_NC_HASH(cncp->name, cncp->namelen,
|
||||
cncp->dcp);
|
||||
/* For performance tuning. */
|
||||
coda_nc_hash[hash].length--;
|
||||
coda_nc_remove(cncp, dcstat);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/*
|
||||
* Flush the entire name cache. In response to a flush of the Venus cache.
|
||||
*/
|
||||
void
|
||||
coda_nc_flush(enum dc_status dcstat)
|
||||
{
|
||||
struct coda_cache *cncp;
|
||||
int i;
|
||||
|
||||
/*
|
||||
* One option is to deallocate the current name cache and call init
|
||||
* to start again. Or just deallocate, then rebuild. Or again, we
|
||||
* could just go through the array and zero the appropriate fields.
|
||||
*/
|
||||
|
||||
/*
|
||||
* Go through the whole lru chain and kill everything as we go. I
|
||||
* don't use remove since that would rebuild the LRU chain as it went
|
||||
* and that seemed unneccesary.
|
||||
*/
|
||||
if (coda_nc_use == 0)
|
||||
return;
|
||||
coda_nc_stat.Flushes++;
|
||||
for (cncp = CODA_NC_LRUGET(coda_nc_lru);
|
||||
cncp != (struct coda_cache *)&coda_nc_lru;
|
||||
cncp = CODA_NC_LRUGET(*cncp)) {
|
||||
if (CODA_NC_VALID(cncp)) {
|
||||
CODA_NC_HSHREM(cncp); /* Only zero valid nodes. */
|
||||
CODA_NC_HSHNUL(cncp);
|
||||
if ((dcstat == IS_DOWNCALL) &&
|
||||
(vrefcnt(CTOV(cncp->dcp)) == 1))
|
||||
cncp->dcp->c_flags |= C_PURGING;
|
||||
vrele(CTOV(cncp->dcp));
|
||||
ASSERT_VOP_LOCKED(CTOV(cncp->cp), "coda_nc_flush");
|
||||
if (CTOV(cncp->cp)->v_vflag & VV_TEXT &&
|
||||
coda_vmflush(cncp->cp))
|
||||
CODADEBUG(CODA_FLUSH, myprintf(("coda_nc_"
|
||||
"flush: %s busy\n", coda_f2s(
|
||||
&cncp->cp->c_fid))););
|
||||
if ((dcstat == IS_DOWNCALL) &&
|
||||
(vrefcnt(CTOV(cncp->cp)) == 1))
|
||||
cncp->cp->c_flags |= C_PURGING;
|
||||
vrele(CTOV(cncp->cp));
|
||||
crfree(cncp->cred);
|
||||
bzero(DATA_PART(cncp),DATA_SIZE);
|
||||
}
|
||||
}
|
||||
for (i = 0; i < coda_nc_hashsize; i++)
|
||||
coda_nc_hash[i].length = 0;
|
||||
}
|
||||
|
||||
/*
|
||||
* Debugging routines.
|
||||
*/
|
||||
|
||||
/*
|
||||
* This routine should print out all the hash chains to the console.
|
||||
*/
|
||||
void
|
||||
print_coda_nc(void)
|
||||
{
|
||||
int hash;
|
||||
struct coda_cache *cncp;
|
||||
|
||||
for (hash = 0; hash < coda_nc_hashsize; hash++) {
|
||||
myprintf(("\nhash %d\n",hash));
|
||||
for (cncp = coda_nc_hash[hash].hash_next;
|
||||
cncp != (struct coda_cache *)&coda_nc_hash[hash];
|
||||
cncp = cncp->hash_next) {
|
||||
myprintf(("cp %p dcp %p cred %p name %s\n",
|
||||
cncp->cp, cncp->dcp, cncp->cred, cncp->name));
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
void
|
||||
coda_nc_gather_stats(void)
|
||||
{
|
||||
int i, max = 0, sum = 0, temp, zeros = 0, ave, n;
|
||||
|
||||
for (i = 0; i < coda_nc_hashsize; i++) {
|
||||
if (coda_nc_hash[i].length)
|
||||
sum += coda_nc_hash[i].length;
|
||||
else
|
||||
zeros++;
|
||||
if (coda_nc_hash[i].length > max)
|
||||
max = coda_nc_hash[i].length;
|
||||
}
|
||||
|
||||
/*
|
||||
* When computing the Arithmetic mean, only count slots which are not
|
||||
* empty in the distribution.
|
||||
*/
|
||||
coda_nc_stat.Sum_bucket_len = sum;
|
||||
coda_nc_stat.Num_zero_len = zeros;
|
||||
coda_nc_stat.Max_bucket_len = max;
|
||||
if ((n = coda_nc_hashsize - zeros) > 0)
|
||||
ave = sum / n;
|
||||
else
|
||||
ave = 0;
|
||||
sum = 0;
|
||||
for (i = 0; i < coda_nc_hashsize; i++) {
|
||||
if (coda_nc_hash[i].length) {
|
||||
temp = coda_nc_hash[i].length - ave;
|
||||
sum += temp * temp;
|
||||
}
|
||||
}
|
||||
coda_nc_stat.Sum2_bucket_len = sum;
|
||||
}
|
||||
|
||||
/*
|
||||
* The purpose of this routine is to allow the hash and cache sizes to be
|
||||
* changed dynamically. This should only be used in controlled environments,
|
||||
* it makes no effort to lock other users from accessing the cache while it
|
||||
* is in an improper state (except by turning the cache off).
|
||||
*/
|
||||
int
|
||||
coda_nc_resize(int hashsize, int heapsize, enum dc_status dcstat)
|
||||
{
|
||||
|
||||
/*
|
||||
* Check for illegal hash or cache sizes.
|
||||
*/
|
||||
if ((hashsize % 2) || (heapsize % 2))
|
||||
return (EINVAL);
|
||||
|
||||
/*
|
||||
* Turn off the cache and free any cnodes in the cache.
|
||||
*/
|
||||
coda_nc_use = 0;
|
||||
coda_nc_flush(dcstat);
|
||||
|
||||
/*
|
||||
* WARNING: free must happen *before* size is reset.
|
||||
*/
|
||||
CODA_FREE(coda_nc_heap,TOTAL_CACHE_SIZE);
|
||||
CODA_FREE(coda_nc_hash,TOTAL_HASH_SIZE);
|
||||
|
||||
/*
|
||||
* Set up a cache with the new size and turn the cache back on.
|
||||
*/
|
||||
coda_nc_hashsize = hashsize;
|
||||
coda_nc_size = heapsize;
|
||||
coda_nc_init();
|
||||
coda_nc_use = 1;
|
||||
return (0);
|
||||
}
|
||||
|
||||
#ifdef DEBUG
|
||||
static char coda_nc_name_buf[CODA_MAXNAMLEN+1];
|
||||
|
||||
void
|
||||
coda_nc_name(struct cnode *cp)
|
||||
{
|
||||
struct coda_cache *cncp, *ncncp;
|
||||
int i;
|
||||
|
||||
if (coda_nc_use == 0)
|
||||
return;
|
||||
|
||||
for (i = 0; i < coda_nc_hashsize; i++) {
|
||||
for (cncp = coda_nc_hash[i].hash_next;
|
||||
cncp != (struct coda_cache *)&coda_nc_hash[i];
|
||||
cncp = ncncp) {
|
||||
ncncp = cncp->hash_next;
|
||||
if (cncp->cp == cp) {
|
||||
bcopy(cncp->name, coda_nc_name_buf,
|
||||
cncp->namelen);
|
||||
coda_nc_name_buf[cncp->namelen] = 0;
|
||||
printf(" is %s (%p,%p)@%p", coda_nc_name_buf,
|
||||
cncp->cp, cncp->dcp, cncp);
|
||||
}
|
||||
|
||||
}
|
||||
}
|
||||
}
|
||||
#endif
|
@ -1,205 +0,0 @@
|
||||
/*-
|
||||
*
|
||||
* Coda: an Experimental Distributed File System
|
||||
* Release 3.1
|
||||
*
|
||||
* Copyright (c) 1987-1998 Carnegie Mellon University
|
||||
* All Rights Reserved
|
||||
*
|
||||
* Permission to use, copy, modify and distribute this software and its
|
||||
* documentation is hereby granted, provided that both the copyright
|
||||
* notice and this permission notice appear in all copies of the
|
||||
* software, derivative works or modified versions, and any portions
|
||||
* thereof, and that both notices appear in supporting documentation, and
|
||||
* that credit is given to Carnegie Mellon University in all documents
|
||||
* and publicity pertaining to direct or indirect use of this code or its
|
||||
* derivatives.
|
||||
*
|
||||
* CODA IS AN EXPERIMENTAL SOFTWARE SYSTEM AND IS KNOWN TO HAVE BUGS,
|
||||
* SOME OF WHICH MAY HAVE SERIOUS CONSEQUENCES. CARNEGIE MELLON ALLOWS
|
||||
* FREE USE OF THIS SOFTWARE IN ITS "AS IS" CONDITION. CARNEGIE MELLON
|
||||
* DISCLAIMS ANY LIABILITY OF ANY KIND FOR ANY DAMAGES WHATSOEVER
|
||||
* RESULTING DIRECTLY OR INDIRECTLY FROM THE USE OF THIS SOFTWARE OR OF
|
||||
* ANY DERIVATIVE WORK.
|
||||
*
|
||||
* Carnegie Mellon encourages users of this software to return any
|
||||
* improvements or extensions that they make, and to grant Carnegie
|
||||
* Mellon the rights to redistribute these changes without encumbrance.
|
||||
*
|
||||
* @(#) src/sys/coda/coda_namecache.h,v 1.1.1.1 1998/08/29 21:14:52 rvb Exp $
|
||||
* $FreeBSD$
|
||||
*
|
||||
*/
|
||||
|
||||
/*-
|
||||
* Mach Operating System
|
||||
* Copyright (c) 1990 Carnegie-Mellon University
|
||||
* Copyright (c) 1989 Carnegie-Mellon University
|
||||
* All rights reserved. The CMU software License Agreement specifies
|
||||
* the terms and conditions for use and redistribution.
|
||||
*/
|
||||
|
||||
/*
|
||||
* This code was written for the Coda filesystem at Carnegie Mellon University.
|
||||
* Contributers include David Steere, James Kistler, and M. Satyanarayanan.
|
||||
*/
|
||||
|
||||
#ifndef _CODA_NC_HEADER_
|
||||
#define _CODA_NC_HEADER_
|
||||
|
||||
/*
|
||||
* Coda constants.
|
||||
*/
|
||||
#define CODA_NC_NAMELEN 15 /* Longest name stored in cache */
|
||||
#define CODA_NC_CACHESIZE 256 /* Default cache size */
|
||||
#define CODA_NC_HASHSIZE 64 /* Must be multiple of 2 */
|
||||
|
||||
/*
|
||||
* Hash function for the primary hash.
|
||||
*
|
||||
* First try -- (first + last letters + length + (int)cp) mod size
|
||||
* 2nd try -- same, except dir fid.vnode instead of cp
|
||||
*/
|
||||
#define CODA_NC_HASH(name, namelen, cp) \
|
||||
((name[0] + (name[namelen-1]<<4) + namelen + \
|
||||
(((int)(intptr_t)cp)>>8)) & (coda_nc_hashsize-1))
|
||||
|
||||
#define CODA_NAMEMATCH(cp, name, namelen, dcp) \
|
||||
((namelen == cp->namelen) && (dcp == cp->dcp) && \
|
||||
(bcmp(cp->name,name,namelen) == 0))
|
||||
|
||||
/*
|
||||
* Functions to modify the hash and LRU chains. insque and remque assume
|
||||
* that the pointers are the first thing in the list node, thus the trickery
|
||||
* for LRU.
|
||||
*/
|
||||
#define CODA_NC_HSHINS(elem, pred) insque(elem,pred)
|
||||
#define CODA_NC_HSHREM(elem) remque(elem)
|
||||
#define CODA_NC_HSHNUL(elem) (elem)->hash_next = \
|
||||
(elem)->hash_prev = (elem)
|
||||
|
||||
#define CODA_NC_LRUINS(elem, pred) insque(LRU_PART(elem), LRU_PART(pred))
|
||||
#define CODA_NC_LRUREM(elem) remque(LRU_PART(elem));
|
||||
#define CODA_NC_LRUGET(lruhead) LRU_TOP((lruhead).lru_prev)
|
||||
|
||||
#define CODA_NC_VALID(cncp) (cncp->dcp != (struct cnode *)0)
|
||||
|
||||
#define LRU_PART(cncp) (struct coda_cache *) ((char *)cncp + \
|
||||
(2*sizeof(struct coda_cache *)))
|
||||
#define LRU_TOP(cncp) (struct coda_cache *) ((char *)cncp - \
|
||||
(2*sizeof(struct coda_cache *)))
|
||||
#define DATA_PART(cncp) (struct coda_cache *) ((char *)cncp + \
|
||||
(4*sizeof(struct coda_cache *)))
|
||||
#define DATA_SIZE (sizeof(struct coda_cache) - \
|
||||
(4*sizeof(struct coda_cache *)))
|
||||
|
||||
/*
|
||||
* Structure for an element in the CODA Name Cache.
|
||||
*
|
||||
* NOTE: I use the position of arguments and their size in the implementation
|
||||
* of the functions CODA_NC_LRUINS, CODA_NC_LRUREM, and DATA_PART.
|
||||
*/
|
||||
struct coda_cache {
|
||||
struct coda_cache *hash_next, *hash_prev; /* Hash list */
|
||||
struct coda_cache *lru_next, *lru_prev; /* LRU list */
|
||||
struct cnode *cp; /* vnode of the file */
|
||||
struct cnode *dcp; /* parent's cnode */
|
||||
struct ucred *cred; /* user credentials */
|
||||
char name[CODA_NC_NAMELEN]; /* segment name */
|
||||
int namelen; /* length of name */
|
||||
};
|
||||
|
||||
/*
|
||||
* Start of an LRU chain -- notice position of pointers.
|
||||
*/
|
||||
struct coda_lru {
|
||||
char *dummy1, *dummy2;
|
||||
struct coda_cache *lru_next, *lru_prev;
|
||||
};
|
||||
|
||||
/*
|
||||
* Start of Hash chain -- notice position of pointers -- chain pointers must
|
||||
* be first.
|
||||
*/
|
||||
struct coda_hash {
|
||||
struct coda_cache *hash_next, *hash_prev;
|
||||
int length; /* Used for tuning purposes. */
|
||||
};
|
||||
|
||||
/*
|
||||
* Symbols to aid in debugging the namecache code. Assumes the existence of
|
||||
* the variable coda_nc_debug, which is defined in cfs_namecache.c
|
||||
*/
|
||||
#define CODA_NC_DEBUG(N, STMT) do { \
|
||||
if (coda_nc_debug & (1 << N)) { \
|
||||
STMT \
|
||||
} \
|
||||
} while (0)
|
||||
|
||||
/*
|
||||
* Prototypes of functions exported within cfs.
|
||||
*/
|
||||
void coda_nc_init(void);
|
||||
void coda_nc_enter(struct cnode *, const char *, int, struct ucred *,
|
||||
struct cnode *);
|
||||
struct cnode *coda_nc_lookup(struct cnode *, const char *, int,
|
||||
struct ucred *);
|
||||
|
||||
void coda_nc_zapParentfid(CodaFid *, enum dc_status);
|
||||
void coda_nc_zapfid(CodaFid *, enum dc_status);
|
||||
void coda_nc_zapvnode(CodaFid *, struct ucred *, enum dc_status);
|
||||
void coda_nc_zapfile(struct cnode *, const char *, int);
|
||||
void coda_nc_purge_user(uid_t, enum dc_status);
|
||||
void coda_nc_flush(enum dc_status);
|
||||
|
||||
void print_coda_nc(void);
|
||||
void coda_nc_gather_stats(void);
|
||||
int coda_nc_resize(int, int, enum dc_status);
|
||||
void coda_nc_name(struct cnode *cp);
|
||||
|
||||
/*
|
||||
* Global variables tracking and controlling Coda namecache operation.
|
||||
*/
|
||||
extern int coda_nc_debug; /* Set to enable debugging printfs */
|
||||
extern int coda_nc_initialized; /* Set if cache has been initialized */
|
||||
extern int coda_nc_use; /* Indicate use of CODA Name Cache */
|
||||
|
||||
/*
|
||||
* Structure to contain statistics on the cache usage.
|
||||
*/
|
||||
struct coda_nc_statistics {
|
||||
u_int hits;
|
||||
u_int misses;
|
||||
u_int enters;
|
||||
u_int dbl_enters;
|
||||
u_int long_name_enters;
|
||||
u_int long_name_lookups;
|
||||
u_int long_remove;
|
||||
u_int lru_rm;
|
||||
u_int zapPfids;
|
||||
u_int zapFids;
|
||||
u_int zapFile;
|
||||
u_int zapUsers;
|
||||
u_int Flushes;
|
||||
u_int Sum_bucket_len;
|
||||
u_int Sum2_bucket_len;
|
||||
u_int Max_bucket_len;
|
||||
u_int Num_zero_len;
|
||||
u_int Search_len;
|
||||
};
|
||||
|
||||
#define CODA_NC_FIND ((u_long) 1)
|
||||
#define CODA_NC_REMOVE ((u_long) 2)
|
||||
#define CODA_NC_INIT ((u_long) 3)
|
||||
#define CODA_NC_ENTER ((u_long) 4)
|
||||
#define CODA_NC_LOOKUP ((u_long) 5)
|
||||
#define CODA_NC_ZAPPFID ((u_long) 6)
|
||||
#define CODA_NC_ZAPFID ((u_long) 7)
|
||||
#define CODA_NC_ZAPVNODE ((u_long) 8)
|
||||
#define CODA_NC_ZAPFILE ((u_long) 9)
|
||||
#define CODA_NC_PURGEUSER ((u_long) 10)
|
||||
#define CODA_NC_FLUSH ((u_long) 11)
|
||||
#define CODA_NC_PRINTCODA_NC ((u_long) 12)
|
||||
#define CODA_NC_PRINTSTATS ((u_long) 13)
|
||||
|
||||
#endif /* !_CODA_NC_HEADER_ */
|
Loading…
Reference in New Issue
Block a user