/* Directory name lookup caching Copyright (C) 1996, 1997 Free Software Foundation, Inc. Written by Thomas Bushnell, n/BSG, & Miles Bader. This file is part of the GNU Hurd. The GNU Hurd is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 2, or (at your option) any later version. The GNU Hurd is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with this program; if not, write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111, USA. */ #include "nfs.h" #include #include /* Maximum number of names to cache at once */ #define MAXCACHE 200 /* Maximum length of file name we bother caching */ #define CACHE_NAME_LEN 100 /* Cache entry */ struct lookup_cache { struct cacheq_hdr hdr; /* File handles and lengths for cache entries. 0 for NODE_CACHE_LEN means a `negative' entry -- recording that there's definitely no node with this name. */ char dir_cache_fh[NFS3_FHSIZE], node_cache_fh[NFS3_FHSIZE]; size_t dir_cache_len, node_cache_len; /* Name of the node NODE_CACHE_ID in the directory DIR_CACHE_ID. Entries with names too long to fit in this buffer aren't cached at all. */ char name[CACHE_NAME_LEN]; /* Strlen of NAME. If this is zero, it's an unused entry. */ size_t name_len; /* Time that this cache entry was created. */ time_t cache_stamp; /* XXX */ int stati; }; /* The contents of the cache in no particular order */ static struct cacheq lookup_cache = { sizeof (struct lookup_cache) }; static spin_lock_t cache_lock = SPIN_LOCK_INITIALIZER; /* Buffer to hold statistics */ static struct stats { long pos_hits; long neg_hits; long miss; long fetch_errors; } statistics; #define PARTIAL_THRESH 100 #define NPARTIALS MAXCACHE / PARTIAL_THRESH struct stats partial_stats [NPARTIALS]; /* If there's an entry for NAME, of length NAME_LEN, in directory DIR in the cache, return its entry, otherwise 0. CACHE_LOCK must be held. */ static struct lookup_cache * find_cache (char *dir, size_t len, const char *name, size_t name_len) { struct lookup_cache *c; int i; /* Search the list. All unused entries are contiguous at the end of the list, so we can stop searching when we see the first one. */ for (i = 0, c = lookup_cache.mru; c && c->name_len; c = c->hdr.next, i++) if (c->name_len == name_len && c->dir_cache_len == len && c->name[0] == name[0] && bcmp (c->dir_cache_fh, dir, len) == 0 && strcmp (c->name, name) == 0) { c->stati = i / 100; return c; } return 0; } /* Node NP has just been found in DIR with NAME. If NP is null, that means that this name has been confirmed as absent in the directory. DIR is the fhandle of the directory; its length is LEN. */ void enter_lookup_cache (char *dir, size_t len, struct node *np, char *name) { struct lookup_cache *c; size_t name_len = strlen (name); if (name_len > CACHE_NAME_LEN - 1) return; spin_lock (&cache_lock); if (lookup_cache.length == 0) /* There should always be an lru_cache; this being zero means that the cache hasn't been initialized yet. Do so. */ cacheq_set_length (&lookup_cache, MAXCACHE); /* See if there's an old entry for NAME in DIR. If not, replace the least recently used entry. */ c = find_cache (dir, len, name, name_len) ?: lookup_cache.lru; /* Fill C with the new entry. */ bcopy (dir, c->dir_cache_fh, len); c->dir_cache_len = len; if (np) bcopy (np->nn->handle.data, c->node_cache_fh, np->nn->handle.size); c->node_cache_len = np ? np->nn->handle.size : 0; strcpy (c->name, name); c->name_len = name_len; c->cache_stamp = mapped_time->seconds; /* Now C becomes the MRU entry! */ cacheq_make_mru (&lookup_cache, c); spin_unlock (&cache_lock); } /* Purge all references in the cache to NAME within directory DIR. */ void purge_lookup_cache (struct node *dp, char *name, size_t namelen) { struct lookup_cache *c, *next; spin_lock (&cache_lock); for (c = lookup_cache.mru; c; c = next) { /* Save C->hdr.next, since we may move C from this position. */ next = c->hdr.next; if (c->name_len == namelen && c->dir_cache_len == dp->nn->handle.size && bcmp (c->dir_cache_fh, dp->nn->handle.data, c->dir_cache_len) == 0 && strcmp (c->name, name) == 0) { c->name_len = 0; cacheq_make_lru (&lookup_cache, c); /* Use C as the next free entry. */ } } spin_unlock (&cache_lock); } /* Register a negative hit for an entry in the Nth stat class */ void register_neg_hit (int n) { int i; statistics.neg_hits++; for (i = 0; i < n; i++) partial_stats[i].miss++; for (; i < NPARTIALS; i++) partial_stats[i].neg_hits++; } /* Register a positive hit for an entry in the Nth stat class */ void register_pos_hit (int n) { int i; statistics.pos_hits++; for (i = 0; i < n; i++) partial_stats[i].miss++; for (; i < NPARTIALS; i++) partial_stats[i].pos_hits++; } /* Register a miss */ void register_miss () { int i; statistics.miss++; for (i = 0; i < NPARTIALS; i++) partial_stats[i].miss++; } /* Scan the cache looking for NAME inside DIR. If we don't know anything entry at all, then return 0. If the entry is confirmed to not exist, then return -1. Otherwise, return NP for the entry, with a newly allocated reference. For any return value but 0, unlock DP before returning. */ struct node * check_lookup_cache (struct node *dir, char *name) { struct lookup_cache *c; spin_lock (&cache_lock); c = find_cache (dir->nn->handle.data, dir->nn->handle.size, name, strlen (name)); if (c) { int timeout = c->node_cache_len ? name_cache_timeout : name_cache_neg_timeout; /* Make sure the entry is still usable; if not, zap it now. */ if (mapped_time->seconds - c->cache_stamp >= timeout) { register_neg_hit (c->stati); c->name_len = 0; cacheq_make_lru (&lookup_cache, c); spin_unlock (&cache_lock); return 0; } cacheq_make_mru (&lookup_cache, c); /* Record C as recently used. */ if (c->node_cache_len == 0) /* A negative cache entry. */ { register_neg_hit (c->stati); spin_unlock (&cache_lock); mutex_unlock (&dir->lock); return (struct node *)-1; } else { struct node *np; char handle[NFS3_FHSIZE]; size_t len; register_pos_hit (c->stati); mutex_unlock (&dir->lock); bcopy (c->node_cache_fh, handle, c->node_cache_len); len = c->node_cache_len; spin_unlock (&cache_lock); lookup_fhandle (handle, len, &np); return np; } } register_miss (); spin_unlock (&cache_lock); return 0; }