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