nscd/nscd_stat.c

   1 /* Copyright (c) 1998, 2003, 2004 Free Software Foundation, Inc.
   2    This file is part of the GNU C Library.
   3    Contributed by Thorsten Kukuk <kukuk@vt.uni-paderborn.de>, 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 Lesser General Public
   7    License as published by the Free Software Foundation; either
   8    version 2.1 of the 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    Lesser General Public License for more details.
  14
  15    You should have received a copy of the GNU Lesser General Public
  16    License along with the GNU C Library; if not, write to the Free
  17    Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
  18    02111-1307 USA.  */
  19
  20 #include <errno.h>
  21 #include <error.h>
  22 #include <inttypes.h>
  23 #include <langinfo.h>
  24 #include <stdio.h>
  25 #include <stdlib.h>
  26 #include <string.h>
  27 #include <unistd.h>
  28 #include <libintl.h>
  29
  30 #include "nscd.h"
  31 #include "dbg_log.h"
  32
  33 /* We use this to make sure the receiver is the same.  */
  34 static const char compilation[21] = __DATE__ " " __TIME__;
  35
  36 /* Statistic data for one database.  */
  37 struct dbstat
  38 {
  39   int enabled;
  40   int check_file;
  41   int shared;
  42   int persistent;
  43   size_t module;
  44
  45   unsigned long int postimeout;
  46   unsigned long int negtimeout;
  47
  48   size_t nentries;
  49   size_t maxnentries;
  50   size_t maxnsearched;
  51   size_t datasize;
  52   size_t dataused;
  53
  54   uintmax_t poshit;
  55   uintmax_t neghit;
  56   uintmax_t posmiss;
  57   uintmax_t negmiss;
  58
  59   uintmax_t rdlockdelayed;
  60   uintmax_t wrlockdelayed;
  61
  62   uintmax_t addfailed;
  63 };
  64
  65 /* Record for transmitting statistics.  */
  66 struct statdata
  67 {
  68   char version[sizeof (compilation)];
  69   int debug_level;
  70   time_t runtime;
  71   unsigned long int client_queued;
  72   int ndbs;
  73   struct dbstat dbs[lastdb];
  74 };
  75
  76
  77 void
  78 send_stats (int fd, struct database_dyn dbs[lastdb])
  79 {
  80   struct statdata data;
  81   int cnt;
  82
  83   memcpy (data.version, compilation, sizeof (compilation));
  84   data.debug_level = debug_level;
  85   data.runtime = time (NULL) - start_time;
  86   data.client_queued = client_queued;
  87   data.ndbs = lastdb;
  88
  89   for (cnt = 0; cnt < lastdb; ++cnt)
  90     {
  91       data.dbs[cnt].enabled = dbs[cnt].enabled;
  92       data.dbs[cnt].check_file = dbs[cnt].check_file;
  93       data.dbs[cnt].shared = dbs[cnt].shared;
  94       data.dbs[cnt].persistent = dbs[cnt].persistent;
  95       data.dbs[cnt].module = dbs[cnt].head->module;
  96       data.dbs[cnt].postimeout = dbs[cnt].postimeout;
  97       data.dbs[cnt].negtimeout = dbs[cnt].negtimeout;
  98       data.dbs[cnt].poshit = dbs[cnt].head->poshit;
  99       data.dbs[cnt].neghit = dbs[cnt].head->neghit;
 100       data.dbs[cnt].posmiss = dbs[cnt].head->posmiss;
 101       data.dbs[cnt].negmiss = dbs[cnt].head->negmiss;
 102       data.dbs[cnt].nentries = dbs[cnt].head->nentries;
 103       data.dbs[cnt].maxnentries = dbs[cnt].head->maxnentries;
 104       data.dbs[cnt].datasize = dbs[cnt].head->data_size;
 105       data.dbs[cnt].dataused = dbs[cnt].head->first_free;
 106       data.dbs[cnt].maxnsearched = dbs[cnt].head->maxnsearched;
 107       data.dbs[cnt].rdlockdelayed = dbs[cnt].head->rdlockdelayed;
 108       data.dbs[cnt].wrlockdelayed = dbs[cnt].head->wrlockdelayed;
 109       data.dbs[cnt].addfailed = dbs[cnt].head->addfailed;
 110     }
 111
 112   if (TEMP_FAILURE_RETRY (write (fd, &data, sizeof (data))) != sizeof (data))
 113     {
 114       char buf[256];
 115       dbg_log (_("cannot write statistics: %s"),
 116                strerror_r (errno, buf, sizeof (buf)));
 117     }
 118 }
 119
 120
 121 int
 122 receive_print_stats (void)
 123 {
 124   struct statdata data;
 125   request_header req;
 126   ssize_t nbytes;
 127   int fd;
 128   int i;
 129   uid_t uid = getuid ();
 130
 131   /* Find out whether there is another user but root allowed to
 132      request statistics.  */
 133   if (uid != 0)
 134     {
 135       /* User specified?  */
 136       if(stat_user == NULL || stat_uid != uid)
 137         {
 138           if (stat_user != NULL)
 139             error (EXIT_FAILURE, 0,
 140                    _("Only root or %s is allowed to use this option!"),
 141                    stat_user);
 142           else
 143             error (EXIT_FAILURE, 0,
 144                    _("Only root is allowed to use this option!"));
 145         }
 146     }
 147
 148   /* Open a socket to the running nscd.  */
 149   fd = nscd_open_socket ();
 150   if (fd == -1)
 151     error (EXIT_FAILURE, 0, _("nscd not running!\n"));
 152
 153   /* Send the request.  */
 154   req.version = NSCD_VERSION;
 155   req.type = GETSTAT;
 156   req.key_len = 0;
 157   nbytes = TEMP_FAILURE_RETRY (write (fd, &req, sizeof (request_header)));
 158   if (nbytes != sizeof (request_header))
 159     {
 160       int err = errno;
 161       close (fd);
 162       error (EXIT_FAILURE, err, _("write incomplete"));
 163     }
 164
 165   /* Read as much data as we expect.  */
 166   if (TEMP_FAILURE_RETRY (read (fd, &data, sizeof (data))) != sizeof (data)
 167       || (memcmp (data.version, compilation, sizeof (compilation)) != 0
 168           /* Yes, this is an assignment!  */
 169           && (errno = EINVAL)))
 170     {
 171       /* Not the right version.  */
 172       int err = errno;
 173       close (fd);
 174       error (EXIT_FAILURE, err, _("cannot read statistics data"));
 175     }
 176
 177   printf (_("nscd configuration:\n\n%15d  server debug level\n"),
 178           data.debug_level);
 179
 180   /* We know that we can simply subtract time_t values.  */
 181   unsigned long int diff = data.runtime;
 182   unsigned int ndays = 0;
 183   unsigned int nhours = 0;
 184   unsigned int nmins = 0;
 185   if (diff > 24 * 60 * 60)
 186     {
 187       ndays = diff / (24 * 60 * 60);
 188       diff %= 24 * 60 * 60;
 189     }
 190   if (diff > 60 * 60)
 191     {
 192       nhours = diff / (60 * 60);
 193       diff %= 60 * 60;
 194     }
 195   if (diff > 60)
 196     {
 197       nmins = diff / 60;
 198       diff %= 60;
 199     }
 200   if (ndays != 0)
 201     printf (_("%3ud %2uh %2um %2lus  server runtime\n"),
 202             ndays, nhours, nmins, diff);
 203   else if (nhours != 0)
 204     printf (_("    %2uh %2um %2lus  server runtime\n"), nhours, nmins, diff);
 205   else if (nmins != 0)
 206     printf (_("        %2um %2lus  server runtime\n"), nmins, diff);
 207   else
 208     printf (_("            %2lus  server runtime\n"), diff);
 209
 210   printf (_("%15lu  number of times clients had to wait\n"),
 211           data.client_queued);
 212
 213   for (i = 0; i < lastdb; ++i)
 214     {
 215       unsigned long int hit = data.dbs[i].poshit + data.dbs[i].neghit;
 216       unsigned long int all = hit + data.dbs[i].posmiss + data.dbs[i].negmiss;
 217       const char *enabled = nl_langinfo (data.dbs[i].enabled ? YESSTR : NOSTR);
 218       const char *check_file = nl_langinfo (data.dbs[i].check_file
 219                                             ? YESSTR : NOSTR);
 220       const char *shared = nl_langinfo (data.dbs[i].shared ? YESSTR : NOSTR);
 221       const char *persistent = nl_langinfo (data.dbs[i].persistent
 222                                             ? YESSTR : NOSTR);
 223
 224       if (enabled[0] == '\0')
 225         /* The locale does not provide this information so we have to
 226            translate it ourself.  Since we should avoid short translation
 227            terms we artifically increase the length.  */
 228         enabled = data.dbs[i].enabled ? _("     yes") : _("      no");
 229       if (check_file[0] == '\0')
 230         check_file = data.dbs[i].check_file ? _("     yes") : _("      no");
 231       if (shared[0] == '\0')
 232         shared = data.dbs[i].shared ? _("     yes") : _("      no");
 233       if (persistent[0] == '\0')
 234         persistent = data.dbs[i].persistent ? _("     yes") : _("      no");
 235
 236       if (all == 0)
 237         /* If nothing happened so far report a 0% hit rate.  */
 238         all = 1;
 239
 240       printf (_("\n%s cache:\n\n"
 241                 "%15s  cache is enabled\n"
 242                 "%15s  cache is persistent\n"
 243                 "%15s  cache is shared\n"
 244                 "%15zu  suggested size\n"
 245                 "%15zu  total data pool size\n"
 246                 "%15zu  used data pool size\n"
 247                 "%15lu  seconds time to live for positive entries\n"
 248                 "%15lu  seconds time to live for negative entries\n"
 249                 "%15" PRIuMAX "  cache hits on positive entries\n"
 250                 "%15" PRIuMAX "  cache hits on negative entries\n"
 251                 "%15" PRIuMAX "  cache misses on positive entries\n"
 252                 "%15" PRIuMAX "  cache misses on negative entries\n"
 253                 "%15lu%% cache hit rate\n"
 254                 "%15zu  current number of cached values\n"
 255                 "%15zu  maximum number of cached values\n"
 256                 "%15zu  maximum chain length searched\n"
 257                 "%15" PRIuMAX "  number of delays on rdlock\n"
 258                 "%15" PRIuMAX "  number of delays on wrlock\n"
 259                 "%15" PRIuMAX "  memory allocations failed\n"
 260                 "%15s  check /etc/%s for changes\n"),
 261               dbnames[i], enabled, persistent, shared,
 262               data.dbs[i].module,
 263               data.dbs[i].datasize, data.dbs[i].dataused,
 264               data.dbs[i].postimeout, data.dbs[i].negtimeout,
 265               data.dbs[i].poshit, data.dbs[i].neghit,
 266               data.dbs[i].posmiss, data.dbs[i].negmiss,
 267               (100 * hit) / all,
 268               data.dbs[i].nentries, data.dbs[i].maxnentries,
 269               data.dbs[i].maxnsearched,
 270               data.dbs[i].rdlockdelayed,
 271               data.dbs[i].wrlockdelayed,
 272               data.dbs[i].addfailed, check_file, dbnames[i]);
 273     }
 274
 275   close (fd);
 276
 277   exit (0);
 278 }