nscd/cache.c

   1 /* Copyright (c) 1998, 1999 Free Software Foundation, Inc.
   2    This file is part of the GNU C Library.
   3    Contributed by Ulrich Drepper <drepper@cygnus.com>, 1998.
   4
   5    The GNU C Library is free software; you can redistribute it and/or
   6    modify it under the terms of the GNU Library General Public License as
   7    published by the Free Software Foundation; either version 2 of the
   8    License, or (at your option) any later version.
   9
  10    The GNU C Library is distributed in the hope that it will be useful,
  11    but WITHOUT ANY WARRANTY; without even the implied warranty of
  12    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13    Library General Public License for more details.
  14
  15    You should have received a copy of the GNU Library General Public
  16    License along with the GNU C Library; see the file COPYING.LIB.  If not,
  17    write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  18    Boston, MA 02111-1307, USA. */
  19
  20 #include <atomicity.h>
  21 #include <errno.h>
  22 #include <error.h>
  23 #include <limits.h>
  24 #include <stdlib.h>
  25 #include <string.h>
  26 #include <libintl.h>
  27 #include <arpa/inet.h>
  28 #include <rpcsvc/nis.h>
  29 #include <sys/param.h>
  30 #include <sys/stat.h>
  31 #include <sys/uio.h>
  32
  33 #include "nscd.h"
  34 #include "dbg_log.h"
  35
  36 /* Search the cache for a matching entry and return it when found.  If
  37    this fails search the negative cache and return (void *) -1 if this
  38    search was successful.  Otherwise return NULL.
  39
  40    This function must be called with the read-lock held.  */
  41 struct hashentry *
  42 cache_search (int type, void *key, size_t len, struct database *table,
  43               uid_t owner)
  44 {
  45   unsigned long int hash = __nis_hash (key, len) % table->module;
  46   struct hashentry *work;
  47
  48   work = table->array[hash];
  49
  50   while (work != NULL)
  51     {
  52       if (type == work->type && len == work->len
  53           && memcmp (key, work->key, len) == 0 && work->owner == owner)
  54         {
  55           /* We found the entry.  Increment the appropriate counter.  */
  56           if (work->data == (void *) -1)
  57             ++table->neghit;
  58           else
  59             ++table->poshit;
  60
  61           return work;
  62         }
  63
  64       work = work->next;
  65     }
  66
  67   return NULL;
  68 }
  69
  70 /* Add a new entry to the cache.  The return value is zero if the function
  71    call was successful.
  72
  73    This function must be called with the read-lock held.
  74
  75    We modify the table but we nevertheless only acquire a read-lock.
  76    This is ok since we use operations which would be safe even without
  77    locking, given that the `prune_cache' function never runs.  Using
  78    the readlock reduces the chance of conflicts.  */
  79 void
  80 cache_add (int type, void *key, size_t len, const void *packet, size_t total,
  81            void *data, int last, time_t t, struct database *table, uid_t owner)
  82 {
  83   unsigned long int hash = __nis_hash (key, len) % table->module;
  84   struct hashentry *newp;
  85
  86   newp = malloc (sizeof (struct hashentry));
  87   if (newp == NULL)
  88     error (EXIT_FAILURE, errno, _("while allocating hash table entry"));
  89
  90   newp->type = type;
  91   newp->len = len;
  92   newp->key = key;
  93   newp->owner = owner;
  94   newp->data = data;
  95   newp->timeout = t;
  96   newp->packet = packet;
  97   newp->total = total;
  98
  99   newp->last = last;
 100
 101   /* Put the new entry in the first position.  */
 102   do
 103     newp->next = table->array[hash];
 104   while (! compare_and_swap ((volatile long int *) &table->array[hash],
 105                              (long int) newp->next, (long int) newp));
 106
 107   /* Update the statistics.  */
 108   if (data == (void *) -1)
 109     ++table->negmiss;
 110   else if (last)
 111     ++table->posmiss;
 112 }
 113
 114 /* Walk through the table and remove all entries which lifetime ended.
 115
 116    We have a problem here.  To actually remove the entries we must get
 117    the write-lock.  But since we want to keep the time we have the
 118    lock as short as possible we cannot simply acquire the lock when we
 119    start looking for timedout entries.
 120
 121    Therefore we do it in two stages: first we look for entries which
 122    must be invalidated and remember them.  Then we get the lock and
 123    actually remove them.  This is complicated by the way we have to
 124    free the data structures since some hash table entries share the same
 125    data.  */
 126 void
 127 prune_cache (struct database *table, time_t now)
 128 {
 129   size_t cnt = table->module;
 130   int mark[cnt];
 131   int anything = 0;
 132   size_t first = cnt + 1;
 133   size_t last = 0;
 134
 135   /* If this table is not actually used don't do anything.  */
 136   if (cnt == 0)
 137     return;
 138
 139   /* If we check for the modification of the underlying file we invalidate
 140      the entries also in this case.  */
 141   if (table->check_file)
 142     {
 143       struct stat st;
 144
 145       if (stat (table->filename, &st) < 0)
 146         {
 147           char buf[128];
 148           /* We cannot stat() the file, disable file checking if the
 149              file does not exist.  */
 150           dbg_log (_("cannot stat() file `%s': %s"),
 151                    table->filename, strerror_r (errno, buf, sizeof (buf)));
 152           if (errno == ENOENT)
 153             table->check_file = 0;
 154         }
 155       else
 156         {
 157           if (st.st_mtime != table->file_mtime)
 158             {
 159               /* The file changed.  Invalidate all entries.  */
 160               now = LONG_MAX;
 161               table->file_mtime = st.st_mtime;
 162             }
 163         }
 164     }
 165
 166   /* We run through the table and find values which are not valid anymore.
 167
 168    Note that for the initial step, finding the entries to be removed,
 169    we don't need to get any lock.  It is at all timed assured that the
 170    linked lists are set up correctly and that no second thread prunes
 171    the cache.  */
 172   do
 173     {
 174       struct hashentry *runp = table->array[--cnt];
 175
 176       mark[cnt] = 0;
 177
 178       while (runp != NULL)
 179         {
 180           if (runp->timeout < now)
 181             {
 182               ++mark[cnt];
 183               anything = 1;
 184               first = MIN (first, cnt);
 185               last = MAX (last, cnt);
 186             }
 187           runp = runp->next;
 188         }
 189     }
 190   while (cnt > 0);
 191
 192   if (anything)
 193     {
 194       struct hashentry *head = NULL;
 195
 196       /* Now we have to get the write lock since we are about to modify
 197          the table.  */
 198       pthread_rwlock_wrlock (&table->lock);
 199
 200       while (first <= last)
 201         {
 202           if (mark[first] > 0)
 203             {
 204               struct hashentry *runp;
 205
 206               while (table->array[first]->timeout < now)
 207                 {
 208                   table->array[first]->dellist = head;
 209                   head = table->array[first];
 210                   table->array[first] = head->next;
 211                   if (--mark[first] == 0)
 212                     break;
 213                 }
 214
 215               runp = table->array[first];
 216               while (mark[first] > 0)
 217                 {
 218                   if (runp->next->timeout < now)
 219                     {
 220                       runp->next->dellist = head;
 221                       head = runp->next;
 222                       runp->next = head->next;
 223                       --mark[first];
 224                     }
 225                   else
 226                     runp = runp->next;
 227                 }
 228             }
 229           ++first;
 230         }
 231
 232       /* It's all done.  */
 233       pthread_rwlock_unlock (&table->lock);
 234
 235       /* And another run to free the data.  */
 236       do
 237         {
 238           struct hashentry *old = head;
 239
 240           if (debug_level > 0)
 241             {
 242               char buf[INET6_ADDRSTRLEN];
 243               const char *str;
 244
 245               if ((old->type == GETHOSTBYADDR || old->type == GETHOSTBYADDRv6)
 246                   && (old->last || old->data == (void *) -1))
 247                 {
 248                   inet_ntop (old->type == GETHOSTBYADDR ? AF_INET : AF_INET6,
 249                              old->key, buf, sizeof (buf));
 250                   str = buf;
 251                 }
 252               else
 253                 str = old->last ? old->key : (old->data == (void *) -1
 254                                               ? old->key : "???");
 255
 256               dbg_log ("remove %s entry \"%s\"", serv2str[old->type], str);
 257             }
 258
 259           /* Free the data structures.  */
 260           if (old->data == (void *) -1)
 261             free (old->key);
 262           else if (old->last)
 263             free (old->data);
 264
 265           head = head->dellist;
 266
 267           free (old);
 268         }
 269       while (head != NULL);
 270     }
 271 }