Generic cache handling functions for NSCD.
authordrepper <drepper>
Sun, 18 Oct 1998 14:57:26 +0000 (14:57 +0000)
committerdrepper <drepper>
Sun, 18 Oct 1998 14:57:26 +0000 (14:57 +0000)
nscd/cache.c [new file with mode: 0644]

diff --git a/nscd/cache.c b/nscd/cache.c
new file mode 100644 (file)
index 0000000..e957a57
--- /dev/null
@@ -0,0 +1,247 @@
+/* Copyright (c) 1998 Free Software Foundation, Inc.
+   This file is part of the GNU C Library.
+   Contributed by Ulrich Drepper <drepper@cygnus.com>, 1998.
+
+   The GNU C Library is free software; you can redistribute it and/or
+   modify it under the terms of the GNU Library General Public License as
+   published by the Free Software Foundation; either version 2 of the
+   License, or (at your option) any later version.
+
+   The GNU C Library 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
+   Library General Public License for more details.
+
+   You should have received a copy of the GNU Library General Public
+   License along with the GNU C Library; see the file COPYING.LIB.  If not,
+   write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+   Boston, MA 02111-1307, USA. */
+
+#include <atomicity.h>
+#include <errno.h>
+#include <error.h>
+#include <limits.h>
+#include <stdlib.h>
+#include <string.h>
+#include <rpcsvc/nis.h>
+#include <sys/param.h>
+#include <sys/stat.h>
+#include <sys/uio.h>
+
+#include "nscd.h"
+#include "dbg_log.h"
+
+/* Search the cache for a matching entry and return it when found.  If
+   this fails search the negative cache and return (void *) -1 if this
+   search was successful.  Otherwise return NULL.
+
+   This function must be called with the read-lock held.  */
+struct hashentry *
+cache_search (int type, void *key, size_t len, struct database *table)
+{
+  unsigned long int hash = __nis_hash (key, len) % table->module;
+  struct hashentry *work;
+
+  work = table->array[hash];
+
+  while (work != NULL)
+    {
+      if (type == work->type
+         && len == work->len && memcmp (key, work->key, len) == 0)
+       {
+         /* We found the entry.  Increment the appropriate counter.  */
+         if (work->data == (void *) -1)
+           ++table->neghit;
+         else
+           ++table->poshit;
+
+         return work;
+       }
+
+      work = work->next;
+    }
+
+  return NULL;
+}
+
+/* Add a new entry to the cache.  The return value is zero if the function
+   call was successful.
+
+   This function must be called with the read-lock held.
+
+   We modify the table but we nevertheless only acquire a read-lock.
+   This is ok since we use operations which would be safe even without
+   locking, given that the `prune_cache' function never runs.  Using
+   the readlock reduces the chance of conflicts.  */
+void
+cache_add (int type, void *key, size_t len, const void *packet, size_t total,
+          void *data, int last, time_t t, struct database *table)
+{
+  unsigned long int hash = __nis_hash (key, len) % table->module;
+  struct hashentry *newp;
+
+  newp = malloc (sizeof (struct hashentry));
+  if (newp == NULL)
+    error (EXIT_FAILURE, errno, _("while allocating hash table entry"));
+
+  newp->type = type;
+  newp->len = len;
+  newp->key = key;
+  newp->data = data;
+  newp->timeout = t;
+  newp->packet = packet;
+  newp->total = total;
+
+  newp->last = last;
+
+  /* Put the new entry in the first position.  */
+  do
+    newp->next = table->array[hash];
+  while (! compare_and_swap ((volatile long int *) &table->array[hash],
+                            (long int) newp->next, (long int) newp));
+
+  /* Update the statistics.  */
+  if (data == (void *) -1)
+    ++table->negmiss;
+  else if (last)
+    ++table->posmiss;
+}
+
+/* Walk through the table and remove all entries which lifetime ended.
+
+   We have a problem here.  To actually remove the entries we must get
+   the write-lock.  But since we want to keep the time we have the
+   lock as short as possible we cannot simply acquire the lock when we
+   start looking for timedout entries.
+
+   Therefore we do it in two stages: first we look for entries which
+   must be invalidated and remember them.  Then we get the lock and
+   actually remove them.  This is complicated by the way we have to
+   free the data structures since some hash table entries share the same
+   data.
+
+   This function must be called with the write-lock held.  */
+void
+prune_cache (struct database *table, time_t now)
+{
+  size_t cnt = table->module;
+  int mark[cnt];
+  int anything = 0;
+  size_t first = cnt + 1;
+  size_t last = 0;
+
+  /* If we check for the modification of the underlying file we invalidate
+     the entries also in this case.  */
+  if (table->check_file)
+    {
+      struct stat st;
+
+      if (stat (table->filename, &st) < 0)
+       {
+         char buf[128];
+         /* We cannot stat() the file, disable file checking.  */
+         dbg_log (_("cannot stat() file `%s': %s"),
+                  table->filename, strerror_r (errno, buf, sizeof (buf)));
+         table->check_file = 0;
+       }
+      else
+       {
+         if (st.st_mtime != table->file_mtime)
+           /* The file changed.  Invalidate all entries.  */
+           now = LONG_MAX;
+       }
+    }
+
+  /* We run through the table and find values which are not valid anymore.
+
+   Note that for the initial step, finding the entries to be removed,
+   we don't need to get any lock.  It is at all timed assured that the
+   linked lists are set up correctly and that no second thread prunes
+   the cache.  */
+  do
+    {
+      struct hashentry *runp = table->array[--cnt];
+
+      mark[cnt] = 0;
+
+      while (runp != NULL)
+       {
+         if (runp->timeout < now)
+           {
+             ++mark[cnt];
+             anything = 1;
+             first = MIN (first, cnt);
+             last = MAX (last, cnt);
+           }
+         runp = runp->next;
+       }
+    }
+  while (cnt > 0);
+
+  if (anything)
+    {
+      struct hashentry *head = NULL;
+
+      /* Now we have to get the write lock since we are about to modify
+        the table.  */
+      pthread_rwlock_wrlock (&table->lock);
+
+      while (first <= last)
+       {
+         if (mark[first] > 0)
+           {
+             struct hashentry *runp;
+
+             while (table->array[first]->timeout < now)
+               {
+                 table->array[first]->dellist = head;
+                 head = table->array[first];
+                 table->array[first] = head->next;
+                 if (--mark[first] == 0)
+                   break;
+               }
+
+             runp = table->array[first];
+             while (mark[first] > 0)
+               {
+                 if (runp->next->timeout < now)
+                   {
+                     runp->next->dellist = head;
+                     head = runp->next;
+                     runp->next = head->next;
+                     --mark[first];
+                   }
+                 else
+                   runp = runp->next;
+               }
+           }
+         ++first;
+       }
+
+      /* It's all done.  */
+      pthread_rwlock_unlock (&table->lock);
+
+      /* And another run to free the data.  */
+      do
+       {
+         struct hashentry *old = head;
+
+         if (debug_level > 0)
+           dbg_log ("remove %s entry \"%s\"",
+                    serv2str[old->type],
+                    old->last
+                    ? old->key : old->data == (void *) -1 ? old->key : "???");
+
+         /* Free the data structures.  */
+         if (old->data == (void *) -1)
+           free (old->key);
+         else if (old->last)
+           free (old->data);
+
+         head = head->dellist;
+
+         free (old);
+       }
+      while (head != NULL);
+    }
+}