diff options
Diffstat (limited to 'fs/coda/namecache.c')
| -rw-r--r-- | fs/coda/namecache.c | 832 |
1 files changed, 832 insertions, 0 deletions
diff --git a/fs/coda/namecache.c b/fs/coda/namecache.c new file mode 100644 index 000000000..08f1ee9e7 --- /dev/null +++ b/fs/coda/namecache.c @@ -0,0 +1,832 @@ +/* + * Cache operations for Coda. + * Original version: (C) 1996 Peter Braam + * Rewritten for Linux 2.1: (C) 1997 Carnegie Mellon University + * + * Carnegie Mellon encourages users of this code to contribute improvements + * to the Coda project. Contact Peter Braam <coda@cs.cmu.edu>. + */ + +/* + * This module contains the routines to implement the CFS 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 insures 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 cnc_init(), cnc_enter(), + * cnc_lookup(), cnc_rmfidcred(), cnc_rmfid(), cnc_rmcred(), and cnc_purge(). + * There are several other routines which aid in the implementation of the + * hash table. + */ + +#include <linux/types.h> +#include <linux/kernel.h> +#include <linux/sched.h> +#include <linux/fs.h> +#include <linux/stat.h> +#include <linux/errno.h> +#include <linux/locks.h> +#include <asm/segment.h> +#include <linux/string.h> + +#include <linux/coda.h> +#include <linux/coda_linux.h> +#include <linux/coda_cnode.h> +#include <linux/coda_namecache.h> + +int cfsnc_use; + +static struct cfscache * cfsnc_find(struct cnode *dcp, const char * name, int namelen, int hash); +static void cfsnc_remove(struct cfscache *cncp); +static inline int nchash(const char *, int, struct cnode *); +static inline int ncmatch(struct cfscache *, const char *, int, + struct cnode *); +static inline void hashins(struct cfscache *a, struct cfscache *pred); +static inline void hashrem(struct cfscache *a); +static inline void hashnull(struct cfscache *); +static inline void lrurem(struct cfscache *a); +static inline void lruins(struct cfscache *a, struct cfscache *pred); +static void cfsnc_gather_stats(void); + + +/* externals */ +extern int coda_fideq(ViceFid *fid1, ViceFid *fid2); +extern int coda_debug; +extern int coda_print_entry; +extern struct super_block *coda_super_block; + + + +/* + * Declaration of the name cache data structure. + */ + +int cfsnc_use = 0; /* Indicate use of CFS Name Cache */ +int cfsnc_size = CFSNC_CACHESIZE; /* size of the cache */ +int cfsnc_hashsize = CFSNC_HASHSIZE; /* size of the primary hash */ +int cfsnc_flushme = 0; +int cfsnc_procsize = 0; +static int cfsnc_force = 0; + +struct cfshash { + struct cfscache *hash_next, *hash_prev; + int length; +}; + +struct cfslruhead { + struct cfscache *dummy1, *dummy2; + struct cfscache *lru_next, *lru_prev; +}; + +struct cfscache *cfsncheap; /* pointer to the cache entries */ +struct cfshash *cfsnchash; /* hash table of cfscache pointers */ +struct cfslruhead cfsnc_lru; /* head of lru chain; prev = lru */ + +struct cfsnc_statistics cfsnc_stat; /* Keep various stats */ + +#define TOTAL_CACHE_SIZE (sizeof(struct cfscache) * cfsnc_size) +#define TOTAL_HASH_SIZE (sizeof(struct cfshash) * cfsnc_hashsize) +int cfsnc_initialized = 0; /* Initially the cache has not been initialized */ + +/* + * for testing purposes + */ +int cfsnc_debug = 1; + + +/* + * Auxillary routines -- shouldn't be entry points + */ + + +/* + * 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 + */ +static inline int +nchash(const char *name, int namelen, struct cnode *cp) +{ + return ((name[0] + name[namelen-1] + + namelen + (int)(cp)) & (cfsnc_hashsize-1)); +} + +/* matching function */ +static inline int ncmatch(struct cfscache *cp, const char *name, int namelen, + struct cnode *dcp) +{ + return ((namelen == cp->namelen) && (dcp == cp->dcp) && + (memcmp(cp->name,name,namelen) == 0)); +} + +/* insert a behind pred */ +static inline void hashins(struct cfscache *a, struct cfscache *pred) +{ + a->hash_next = pred->hash_next; + pred->hash_next->hash_prev= a; + pred->hash_next = a; + a->hash_prev = pred; +} + +static inline void hashrem(struct cfscache *a) +{ + a->hash_prev->hash_next = a->hash_next; + a->hash_next->hash_prev = a->hash_prev; +} + +static inline void hashnull(struct cfscache *elem) { + elem->hash_next = elem; + elem->hash_prev = elem; +} + +static inline void lrurem(struct cfscache *a) +{ + a->lru_prev->lru_next = a->lru_next; + a->lru_next->lru_prev = a->lru_prev; +} + +static inline void lruins(struct cfscache *a, struct cfscache *pred) +{ + pred->lru_next->lru_prev= a; + a->lru_next = pred->lru_next; + + a->lru_prev = pred; + pred->lru_next = a; +} + +static struct cfscache * +cfsnc_find(struct cnode *dcp, const char * name, int namelen, int hash) +{ + /* + * hash to find the appropriate bucket, look through the chain + * for the right entry + */ + register struct cfscache *cncp; + int count = 1; + + CDEBUG(D_CACHE, "dcp 0x%x, name %s, len %d, hash %d\n", + (int)dcp, name, namelen, hash); + + for (cncp = cfsnchash[hash].hash_next; + cncp != (struct cfscache *)&cfsnchash[hash]; + cncp = cncp->hash_next, count++) + { + + if (ncmatch(cncp, name, namelen, dcp)) + { + cfsnc_stat.Search_len += count; + CDEBUG(D_CACHE, "dcp 0x%x,found.\n", (int) dcp); + return(cncp); + + } + } + CDEBUG(D_CACHE, "dcp 0x%x,not found.\n", (int) dcp); + return((struct cfscache *)0); +} + +static void +cfsnc_remove(struct cfscache *cncp) +{ + /* + * remove an entry -- VN_RELE(cncp->dcp, cp), crfree(cred), + * remove it from it's hash chain, and + * place it at the head of the lru list. + */ + CDEBUG(D_CACHE, "remove %s from parent %lx.%lx.%lx\n", + cncp->name, (cncp->dcp)->c_fid.Volume, + (cncp->dcp)->c_fid.Vnode, (cncp->dcp)->c_fid.Unique); + + hashrem(cncp); + hashnull(cncp); /* have it be a null chain */ + + /* VN_RELE(CTOV(cncp->dcp)); */ + iput(CTOI(cncp->cp)); + /* crfree(cncp->cred); */ + + memset(DATA_PART(cncp), 0 ,DATA_SIZE); + cncp->cp = NULL; + cncp->dcp = (struct cnode *) 0; + + /* Put the null entry just after the least-recently-used entry */ + lrurem(cncp); + lruins(cncp, cfsnc_lru.lru_prev); +} + + +/* + * Entry points for the CFS Name Cache + */ + +/* + * Initialize the cache, the LRU structure and the Hash structure(s) + */ +void +cfsnc_init(void) +{ + register int i; + + /* zero the statistics structure */ + cfsnc_procsize = 10000 * cfsnc_hashsize + cfsnc_size; + memset(&cfsnc_stat, 0, (sizeof(struct cfsnc_statistics))); + + CODA_ALLOC(cfsncheap, struct cfscache *, TOTAL_CACHE_SIZE); + CODA_ALLOC(cfsnchash, struct cfshash *, TOTAL_HASH_SIZE); + + cfsnc_lru.lru_next = cfsnc_lru.lru_prev = (struct cfscache *)&cfsnc_lru; + + /* initialize the heap */ + for (i=0; i < cfsnc_size; i++) { + lruins(&cfsncheap[i], (struct cfscache *) &cfsnc_lru); + hashnull(&cfsncheap[i]); + cfsncheap[i].cp = cfsncheap[i].dcp = (struct cnode *)0; + } + + for (i=0; i < cfsnc_hashsize; i++) { /* initialize the hashtable */ + hashnull((struct cfscache *)&cfsnchash[i]); + cfsnchash[i].length=0; /* bucket length */ + } + + cfsnc_initialized = 1; + CDEBUG(D_CACHE, "cfsnc_initialized is now 1.\n"); +} + +/* + * Enter a new (dir cnode, name) pair into the cache, updating the + * LRU and Hash as needed. + */ + +void +cfsnc_enter(struct cnode *dcp, register const char *name, int namelen, struct cnode *cp) +{ + register struct cfscache *cncp; + register int hash; + + if (cfsnc_use == 0) /* Cache is off */ + return; + + CDEBUG(D_CACHE, "dcp 0x%x cp 0x%x name %s, ind 0x%x \n", + (int)dcp, (int)cp, name, (int)cp->c_vnode); + + if (namelen > CFSNC_NAMELEN) { + CDEBUG(D_CACHE, "long name enter %s\n",name); + cfsnc_stat.long_name_enters++; /* record stats */ + return; + } + + hash = nchash(name, namelen, dcp); + CDEBUG(D_CACHE, "Calling find with name %s, dcp %d, hash %d\n", + name, (int) dcp, (int) hash); + + cncp = cfsnc_find(dcp, name, namelen, hash); + if (cncp != (struct cfscache *) 0) { + printk("cfsnc_enter: Duplicate cache entry; tell Peter.\n"); + cfsnc_stat.dbl_enters++; /* duplicate entry */ + return; + } + + cfsnc_stat.enters++; /* record the enters statistic */ + + /* Grab the lru element in the lru chain */ + cncp = cfsnc_lru.lru_prev; + + lrurem(cncp); /* remove it from the lists */ + + /* if cncp is on hash list remove it */ + if ( cncp->dcp != (struct cnode *) 0 ) { + /* We have to decrement the appropriate hash bucket length + here, so we have to find the hash bucket */ + cfsnchash[nchash(cncp->name, cncp->namelen, cncp->dcp)].length--; + cfsnc_stat.lru_rm++; /* zapped a valid entry */ + hashrem(cncp); + iput(CTOI(cncp->cp)); + /* VN_RELE(CTOV(cncp->dcp)); */ + /* crfree(cncp->cred); */ + } + /* + * Put a hold on the current vnodes and fill in the cache entry. + */ + iget((CTOI(cp))->i_sb, CTOI(cp)->i_ino); + /* VN_HOLD(CTOV(dcp)); */ + /* XXXX crhold(cred); */ + cncp->dcp = dcp; + cncp->cp = cp; + cncp->namelen = namelen; + /* cncp->cred = cred; */ + + memcpy(cncp->name, name, (unsigned)namelen); + + /* Insert into the lru and hash chains. */ + + lruins(cncp, (struct cfscache *) &cfsnc_lru); + hashins(cncp, (struct cfscache *)&cfsnchash[hash]); + cfsnchash[hash].length++; /* Used for tuning */ + CDEBUG(D_CACHE, "Entering:\n"); + coda_print_ce(cncp); +} + +/* + * Find the (dir cnode, name) pair in the cache, if it's cred + * matches the input, return it, otherwise return 0 + */ + +struct cnode * +cfsnc_lookup(struct cnode *dcp, register const char *name, int namelen) +{ + register int hash; + register struct cfscache *cncp; + /* this should go into a callback funcntion for /proc/sys + don't know how at the moment? */ + if (cfsnc_flushme == 1) { + cfsnc_flush(); + cfsnc_flushme = 0; + } + + if (cfsnc_procsize != 10000*cfsnc_hashsize + cfsnc_size ) { + int hsh = cfsnc_procsize/10000; + int siz = cfsnc_procsize%10000; + int rc; + + if ( (hsh > 1) && (siz > 2) ) { + rc = cfsnc_resize(hsh, siz); + if ( !rc ) { + printk("Coda:cache size (hash,size) (%d,%d)\n", + hsh, siz); + } else { + printk("Coda: cache resize failed\n"); + } + } + } + + if (cfsnc_use == 0) /* Cache is off */ + return((struct cnode *) 0); + + if (namelen > CFSNC_NAMELEN) { + CDEBUG(D_CACHE,"long name lookup %s\n",name); + cfsnc_stat.long_name_lookups++; /* record stats */ + return((struct cnode *) 0); + } + + /* Use the hash function to locate the starting point, + then the search routine to go down the list looking for + the correct cred. + */ + + hash = nchash(name, namelen, dcp); + CDEBUG(D_CACHE, "Calling find with name %s, dcp %d, hash %d\n", + name, (int) dcp, (int) hash); + cncp = cfsnc_find(dcp, name, namelen, hash); + if (cncp == (struct cfscache *) 0) { + cfsnc_stat.misses++; /* record miss */ + return((struct cnode *) 0); + } + + cfsnc_stat.hits++; + + /* put this entry at the mru end of the LRU */ + lrurem(cncp); + lruins(cncp, (struct cfscache *) &cfsnc_lru); + + /* move it to the front of the hash chain */ + /* don't need to change the hash bucket length */ + hashrem(cncp); + hashins(cncp, (struct cfscache *) &cfsnchash[hash]); + + CDEBUG(D_CACHE, "lookup: dcp 0x%x, name %s, cp 0x%x\n", + (int) dcp, name, (int) cncp->cp); + + return(cncp->cp); +} + +/* + * Remove all entries with a parent which has the input fid. + */ + +void +cfsnc_zapParentfid(ViceFid *fid) +{ + /* 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. + */ + register struct cfscache *cncp, *ncncp; + register int i; + + if (cfsnc_use == 0) /* Cache is off */ + return; + + CDEBUG(D_CACHE, " fid 0x%lx, 0x%lx, 0x%lx \n", + fid->Volume, fid->Vnode, fid->Unique); + + cfsnc_stat.zapPfids++; + + for (i = 0; i < cfsnc_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 = cfsnchash[i].hash_next; + cncp != (struct cfscache *) &cfsnchash[i]; + cncp = ncncp) { + ncncp = cncp->hash_next; + if ( coda_fideq(&cncp->dcp->c_fid, fid) ) { + cfsnchash[i].length--; /* Used for tuning */ + cfsnc_remove(cncp); + } + } + } +} + +/* + * Remove all entries which have the same fid as the input + */ +void +cfsnc_zapfid(ViceFid *fid) +{ + /* See comment for zapParentfid. This routine will be used + if attributes are being cached. + */ + register struct cfscache *cncp, *ncncp; + register int i; + + if (cfsnc_use == 0) /* Cache is off */ + return; + + CDEBUG(D_CACHE, "Zapfid: fid 0x%lx, 0x%lx, 0x%lx \n", + fid->Volume, fid->Vnode, fid->Unique); + + cfsnc_stat.zapFids++; + + for (i = 0; i < cfsnc_hashsize; i++) { + for (cncp = cfsnchash[i].hash_next; + cncp != (struct cfscache *) &cfsnchash[i]; + cncp = ncncp) { + ncncp = cncp->hash_next; + if (coda_fideq(&(cncp->cp->c_fid), fid)) { + CDEBUG(D_CACHE, "Found cncp: name %s\n", cncp->name); + cfsnchash[i].length--; /* Used for tuning */ + cfsnc_remove(cncp); + } + } + } +} + + +/* + * Remove all entries which have the (dir vnode, name) pair + */ +void +cfsnc_zapfile(struct cnode *dcp, register const char *name, int length) +{ + /* use the hash function to locate the file, then zap all + entries of it regardless of the cred. + */ + register struct cfscache *cncp; + int hash; + + if (cfsnc_use == 0) /* Cache is off */ + return; + + CDEBUG(D_CACHE,"Zapfile: dcp 0x%x name %s \n", + (int) dcp, name); + + if (length > CFSNC_NAMELEN) { + cfsnc_stat.long_remove++; /* record stats */ + return; + } + + cfsnc_stat.zapFile++; + + hash = nchash(name, length, dcp); + /* remove entries: remember they might exist for more than a + single cred */ + while ( (cncp = cfsnc_find(dcp, name, length, hash)) != NULL ) { + cfsnchash[hash].length--; + cfsnc_remove(cncp); + } +} + +/* + * 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 +cfsnc_purge_user(struct CodaCred *cred) +{ + /* 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. + */ + + register struct cfscache *cncp; + int hash; + + if (cfsnc_use == 0) /* Cache is off */ + return; + + CDEBUG(D_CACHE,"ZapDude: uid %ld\n",cred->cr_uid); + cfsnc_stat.zapUsers++; + + for (cncp = cfsnc_lru.lru_next; + cncp != (struct cfscache *) &cfsnc_lru; + cncp = cncp->lru_next) { + + if ((CFSNC_VALID(cncp)) && + ((cncp->cred)->cr_uid == cred->cr_uid)) { + /* Seems really ugly, but we have to decrement the appropriate + hash bucket length here, so we have to find the hash bucket + */ + hash = nchash(cncp->name, cncp->namelen, cncp->dcp); + cfsnchash[hash].length--; /* For performance tuning */ + + cfsnc_remove(cncp); + } + } +} + +/* + * Flush the entire name cache. In response to a flush of the Venus cache. + */ + +void +cfsnc_flush(void) +{ + /* 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. + */ + register struct cfscache *cncp; + int i; + + if ((cfsnc_use == 0 || cfsnc_initialized == 0) && (cfsnc_force == 0) ) + return; + + cfsnc_stat.Flushes++; + + for (cncp = cfsnc_lru.lru_next; + cncp != (struct cfscache *) &cfsnc_lru; + cncp = cncp->lru_next) { + if ( cncp->cp ) { + hashrem(cncp); /* only zero valid nodes */ + hashnull(cncp); + iput(CTOI(cncp->cp)); + /* crfree(cncp->cred); */ + memset(DATA_PART(cncp), 0, DATA_SIZE); + } + } + + for (i = 0; i < cfsnc_hashsize; i++) + cfsnchash[i].length = 0; +} + +/* + * This routine replaces a ViceFid in the name cache with another. + * It is added to allow Venus during reintegration to replace + * locally allocated temp fids while disconnected with global fids + * even when the reference count on those fids are not zero. + */ +void +cfsnc_replace(ViceFid *f1, ViceFid *f2) +{ + /* + * Replace f1 with f2 throughout the name cache + */ + int hash; + register struct cfscache *cncp; + + CDEBUG(D_CACHE, + "cfsnc_replace fid_1 = (%lx.%lx.%lx) and fid_2 = (%lx.%lx.%lx)\n", + f1->Volume, f1->Vnode, f1->Unique, + f2->Volume, f2->Vnode, f2->Unique); + + for (hash = 0; hash < cfsnc_hashsize; hash++) { + for (cncp = cfsnchash[hash].hash_next; + cncp != (struct cfscache *) &cfsnchash[hash]; + cncp = cncp->hash_next) { + if (!memcmp(&cncp->cp->c_fid, f1, sizeof(ViceFid))) { + memcpy(&cncp->cp->c_fid, f2, sizeof(ViceFid)); + continue; /* no need to check cncp->dcp now */ + } + if (!memcmp(&cncp->dcp->c_fid, f1, sizeof(ViceFid))) + memcpy(&cncp->dcp->c_fid, f2, sizeof(ViceFid)); + } + } +} + +/* + * Debugging routines + */ + +/* + * This routine should print out all the hash chains to the console. + */ + +void +print_cfsnc(void) +{ + int hash; + register struct cfscache *cncp; + + for (hash = 0; hash < cfsnc_hashsize; hash++) { + printk("\nhash %d\n",hash); + + for (cncp = cfsnchash[hash].hash_next; + cncp != (struct cfscache *)&cfsnchash[hash]; + cncp = cncp->hash_next) { + printk("cp 0x%x dcp 0x%x cred 0x%x name %s ino %d count %d dev %d\n", + (int)cncp->cp, (int)cncp->dcp, + (int)cncp->cred, cncp->name, CTOI(cncp->cp)->i_count, CTOI(cncp->cp)->i_count, CTOI(cncp->cp)->i_dev); + } + } +} + +int +cfsnc_get_info(char *buffer, char **start, off_t offset, int length, int dummy) +{ + int hash; + int len=0; + off_t pos=0; + off_t begin; + struct cfscache *cncp; + char tmpbuf[80]; + + if (offset < 80) + len += sprintf(buffer, "%-79s\n", + "hash len volume vnode unique name ino pino ct"); + if ( !cfsnc_initialized ) { + *start = buffer; + return len; + } + pos = 80; + for (hash = 0; hash < cfsnc_hashsize; hash++) { + for (cncp = cfsnchash[hash].hash_next; + cncp != (struct cfscache *)&cfsnchash[hash]; + cncp = cncp->hash_next) { + pos += 80; + if (pos < offset) + continue; + sprintf(tmpbuf, "%4d %3d %8x %8x %8x %16s %10ld %10ld %2d", + hash, cfsnchash[hash].length, (int) cncp->cp->c_fid.Volume, + (int) cncp->cp->c_fid.Vnode, (int) cncp->cp->c_fid.Unique , cncp->name, + CTOI(cncp->cp)->i_ino, + CTOI(cncp->dcp)->i_ino, + CTOI(cncp->cp)->i_count); + len += sprintf(buffer+len, "%-79s\n", tmpbuf); + if(len >= length) + break; + } + if(len>= length) + break; + } + begin = len - (pos - offset); + *start = buffer + begin; + len -= begin; + if(len>length) + len = length; + return len; +} + +int +cfsnc_nc_info(char *buffer, char **start, off_t offset, int length, int dummy) +{ + int len=0; + off_t begin; + + cfsnc_gather_stats(); + + /* this works as long as we are below 1024 characters! */ + len += sprintf(buffer,"Coda minicache statistics\n\n"); + len += sprintf(buffer+len, "cfsnc_hits : %d\n", cfsnc_stat.hits); + len += sprintf(buffer+len, "cfsnc_misses : %d\n", cfsnc_stat.misses); + len += sprintf(buffer+len, "cfsnc_enters : %d\n", cfsnc_stat.enters); + len += sprintf(buffer+len, "cfsnc_dbl_enters : %d\n", cfsnc_stat.dbl_enters); + len += sprintf(buffer+len, "cfsnc_long_name_enters : %d\n", cfsnc_stat.long_name_enters); + len += sprintf(buffer+len, "cfsnc_long_name_lookups : %d\n", cfsnc_stat.long_name_lookups); + len += sprintf(buffer+len, "cfsnc_long_remove : %d\n", cfsnc_stat.long_remove); + len += sprintf(buffer+len, "cfsnc_lru_rm : %d\n", cfsnc_stat.lru_rm); + len += sprintf(buffer+len, "cfsnc_zapPfids : %d\n", cfsnc_stat.zapPfids); + len += sprintf(buffer+len, "cfsnc_zapFids : %d\n", cfsnc_stat.zapFids); + len += sprintf(buffer+len, "cfsnc_zapFile : %d\n", cfsnc_stat.zapFile); + len += sprintf(buffer+len, "cfsnc_zapUsers : %d\n", cfsnc_stat.zapUsers); + len += sprintf(buffer+len, "cfsnc_Flushes : %d\n", cfsnc_stat.Flushes); + len += sprintf(buffer+len, "cfsnc_SumLen : %d\n", cfsnc_stat.Sum_bucket_len); + len += sprintf(buffer+len, "cfsnc_Sum2Len : %d\n", cfsnc_stat.Sum2_bucket_len); + len += sprintf(buffer+len, "cfsnc_# 0 len : %d\n", cfsnc_stat.Num_zero_len); + len += sprintf(buffer+len, "cfsnc_MaxLen : %d\n", cfsnc_stat.Max_bucket_len); + len += sprintf(buffer+len, "cfsnc_SearchLen : %d\n", cfsnc_stat.Search_len); + begin = offset; + *start = buffer + begin; + len -= begin; + + if(len>length) + len = length; + if (len< 0) + len = 0; + return len; +} + + + +void +coda_print_ce(struct cfscache *ce) +{ +CDEBUG(D_CACHE, "cp 0x%x, dcp 0x%x, name %s, inod 0x%x, ino %d, count %d, dev %d\n", + (int)ce->cp, (int)ce->dcp, ce->name, (int)CTOI(ce->cp),(int)CTOI(ce->cp)->i_ino, CTOI(ce->cp)->i_count, CTOI(ce->cp)->i_dev); +} + +static void +cfsnc_gather_stats(void) +{ + int i, max = 0, sum = 0, temp, zeros = 0, ave, n; + + for (i = 0; i < cfsnc_hashsize; i++) { + if (cfsnchash[i].length) { + sum += cfsnchash[i].length; + } else { + zeros++; + } + + if (cfsnchash[i].length > max) + max = cfsnchash[i].length; + } + +/* + * When computing the Arithmetic mean, only count slots which + * are not empty in the distribution. + */ + cfsnc_stat.Sum_bucket_len = sum; + cfsnc_stat.Num_zero_len = zeros; + cfsnc_stat.Max_bucket_len = max; + + if ((n = cfsnc_hashsize - zeros) > 0) + ave = sum / n; + else + ave = 0; + + sum = 0; + for (i = 0; i < cfsnc_hashsize; i++) { + if (cfsnchash[i].length) { + temp = cfsnchash[i].length - ave; + sum += temp * temp; + } + } + cfsnc_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 +cfsnc_resize(int hashsize, int heapsize) +{ + if ( !cfsnc_use ) + return 0; + + if ((hashsize % 2) || (heapsize % 2)) { /* Illegal hash or cache sizes */ + return(EINVAL); + } + + cfsnc_use = 0; /* Turn the cache off */ + cfsnc_force = 1; /* otherwise we can't flush */ + + cfsnc_flush(); /* free any cnodes in the cache */ + cfsnc_force = 0; + + /* WARNING: free must happen *before* size is reset */ + CODA_FREE(cfsncheap,TOTAL_CACHE_SIZE); + CODA_FREE(cfsnchash,TOTAL_HASH_SIZE); + + cfsnc_hashsize = hashsize; + cfsnc_size = heapsize; + + cfsnc_init(); /* Set up a cache with the new size */ + + cfsnc_use = 1; /* Turn the cache back on */ + return(0); +} + + + |