nscd_stat.c

/* Copyright (c) 1998-2016 Free Software Foundation, Inc.
   This file is part of the GNU C Library.
   Contributed by Thorsten Kukuk <kukuk@vt.uni-paderborn.de>, 1998.

   The GNU C Library is free software; you can redistribute it and/or
   modify it under the terms of the GNU Lesser General Public
   License as published by the Free Software Foundation; either
   version 2.1 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
   Lesser General Public License for more details.

   You should have received a copy of the GNU Lesser General Public
   License along with the GNU C Library; if not, see
   <http://www.gnu.org/licenses/>.  */

#include <errno.h>
#include <error.h>
#include <inttypes.h>
#include <langinfo.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/socket.h>
#include <unistd.h>
#include <libintl.h>

#include "nscd.h"
#include "dbg_log.h"
#include "selinux.h"
#ifdef HAVE_SELINUX
# include <selinux/selinux.h>
# include <selinux/avc.h>
#endif /* HAVE_SELINUX */


/* We use this to make sure the receiver is the same.  */
static const char compilation[21] = __DATE__ " " __TIME__;

/* Statistic data for one database.  */
struct dbstat
{
  int enabled;
  int check_file;
  int shared;
  int persistent;
  size_t module;

  unsigned long int postimeout;
  unsigned long int negtimeout;

  size_t nentries;
  size_t maxnentries;
  size_t maxnsearched;
  size_t datasize;
  size_t dataused;

  uintmax_t poshit;
  uintmax_t neghit;
  uintmax_t posmiss;
  uintmax_t negmiss;

  uintmax_t rdlockdelayed;
  uintmax_t wrlockdelayed;

  uintmax_t addfailed;
};

/* Record for transmitting statistics.  */
struct statdata
{
  char version[sizeof (compilation)];
  int debug_level;
  time_t runtime;
  unsigned long int client_queued;
  int nthreads;
  int max_nthreads;
  int paranoia;
  time_t restart_interval;
  unsigned int reload_count;
  int ndbs;
  struct dbstat dbs[lastdb];
#ifdef HAVE_SELINUX
  struct avc_cache_stats cstats;
#endif /* HAVE_SELINUX */
};


void
send_stats (int fd, struct database_dyn dbs[lastdb])
{
  struct statdata data;
  int cnt;

  memset (&data, 0, sizeof (data));

  memcpy (data.version, compilation, sizeof (compilation));
  data.debug_level = debug_level;
  data.runtime = time (NULL) - start_time;
  data.client_queued = client_queued;
  data.nthreads = nthreads;
  data.max_nthreads = max_nthreads;
  data.paranoia = paranoia;
  data.restart_interval = restart_interval;
  data.reload_count = reload_count;
  data.ndbs = lastdb;

  for (cnt = 0; cnt < lastdb; ++cnt)
    {
      memset (&data.dbs[cnt], 0, sizeof (data.dbs[cnt]));
      data.dbs[cnt].enabled = dbs[cnt].enabled;
      data.dbs[cnt].check_file = dbs[cnt].check_file;
      data.dbs[cnt].shared = dbs[cnt].shared;
      data.dbs[cnt].persistent = dbs[cnt].persistent;
      data.dbs[cnt].postimeout = dbs[cnt].postimeout;
      data.dbs[cnt].negtimeout = dbs[cnt].negtimeout;
      if (dbs[cnt].head != NULL)
	{
	  data.dbs[cnt].module = dbs[cnt].head->module;
	  data.dbs[cnt].poshit = dbs[cnt].head->poshit;
	  data.dbs[cnt].neghit = dbs[cnt].head->neghit;
	  data.dbs[cnt].posmiss = dbs[cnt].head->posmiss;
	  data.dbs[cnt].negmiss = dbs[cnt].head->negmiss;
	  data.dbs[cnt].nentries = dbs[cnt].head->nentries;
	  data.dbs[cnt].maxnentries = dbs[cnt].head->maxnentries;
	  data.dbs[cnt].datasize = dbs[cnt].head->data_size;
	  data.dbs[cnt].dataused = dbs[cnt].head->first_free;
	  data.dbs[cnt].maxnsearched = dbs[cnt].head->maxnsearched;
	  data.dbs[cnt].rdlockdelayed = dbs[cnt].head->rdlockdelayed;
	  data.dbs[cnt].wrlockdelayed = dbs[cnt].head->wrlockdelayed;
	  data.dbs[cnt].addfailed = dbs[cnt].head->addfailed;
	}
    }

  if (selinux_enabled)
    nscd_avc_cache_stats (&data.cstats);

  if (TEMP_FAILURE_RETRY (send (fd, &data, sizeof (data), MSG_NOSIGNAL))
      != sizeof (data))
    {
      char buf[256];
      dbg_log (_("cannot write statistics: %s"),
	       strerror_r (errno, buf, sizeof (buf)));
    }
}


int
receive_print_stats (void)
{
  struct statdata data;
  request_header req;
  ssize_t nbytes;
  int fd;
  int i;
  uid_t uid = getuid ();
  const char *yesstr = _("yes");
  const char *nostr = _("no");

  /* Find out whether there is another user but root allowed to
     request statistics.  */
  if (uid != 0)
    {
      /* User specified?  */
      if(stat_user == NULL || stat_uid != uid)
	{
	  if (stat_user != NULL)
	    error (EXIT_FAILURE, 0,
		   _("Only root or %s is allowed to use this option!"),
		   stat_user);
	  else
	    error (EXIT_FAILURE, 0,
		   _("Only root is allowed to use this option!"));
	}
    }

  /* Open a socket to the running nscd.  */
  fd = nscd_open_socket ();
  if (fd == -1)
    error (EXIT_FAILURE, 0, _("nscd not running!\n"));

  /* Send the request.  */
  req.version = NSCD_VERSION;
  req.type = GETSTAT;
  req.key_len = 0;
  nbytes = TEMP_FAILURE_RETRY (send (fd, &req, sizeof (request_header),
				     MSG_NOSIGNAL));
  if (nbytes != sizeof (request_header))
    {
      int err = errno;
      close (fd);
      error (EXIT_FAILURE, err, _("write incomplete"));
    }

  /* Read as much data as we expect.  */
  if (TEMP_FAILURE_RETRY (read (fd, &data, sizeof (data))) != sizeof (data)
      || (memcmp (data.version, compilation, sizeof (compilation)) != 0
	  /* Yes, this is an assignment!  */
	  && (errno = EINVAL)))
    {
      /* Not the right version.  */
      int err = errno;
      close (fd);
      error (EXIT_FAILURE, err, _("cannot read statistics data"));
    }

  printf (_("nscd configuration:\n\n%15d  server debug level\n"),
	  data.debug_level);

  /* We know that we can simply subtract time_t values.  */
  unsigned long int diff = data.runtime;
  unsigned int ndays = 0;
  unsigned int nhours = 0;
  unsigned int nmins = 0;
  if (diff > 24 * 60 * 60)
    {
      ndays = diff / (24 * 60 * 60);
      diff %= 24 * 60 * 60;
    }
  if (diff > 60 * 60)
    {
      nhours = diff / (60 * 60);
      diff %= 60 * 60;
    }
  if (diff > 60)
    {
      nmins = diff / 60;
      diff %= 60;
    }
  if (ndays != 0)
    printf (_("%3ud %2uh %2um %2lus  server runtime\n"),
	    ndays, nhours, nmins, diff);
  else if (nhours != 0)
    printf (_("    %2uh %2um %2lus  server runtime\n"), nhours, nmins, diff);
  else if (nmins != 0)
    printf (_("        %2um %2lus  server runtime\n"), nmins, diff);
  else
    printf (_("            %2lus  server runtime\n"), diff);

  printf (_("%15d  current number of threads\n"
	    "%15d  maximum number of threads\n"
	    "%15lu  number of times clients had to wait\n"
	    "%15s  paranoia mode enabled\n"
	    "%15lu  restart internal\n"
	    "%15u  reload count\n"),
	  data.nthreads, data.max_nthreads, data.client_queued,
	  data.paranoia ? yesstr : nostr,
	  (unsigned long int) data.restart_interval, data.reload_count);

  for (i = 0; i < lastdb; ++i)
    {
      unsigned long int hit = data.dbs[i].poshit + data.dbs[i].neghit;
      unsigned long int all = hit + data.dbs[i].posmiss + data.dbs[i].negmiss;
      const char *enabled = data.dbs[i].enabled ? yesstr : nostr;
      const char *check_file = data.dbs[i].check_file ? yesstr : nostr;
      const char *shared = data.dbs[i].shared ? yesstr : nostr;
      const char *persistent = data.dbs[i].persistent ? yesstr : nostr;

      if (enabled[0] == '\0')
	/* The locale does not provide this information so we have to
	   translate it ourself.  Since we should avoid short translation
	   terms we artifically increase the length.  */
	enabled = data.dbs[i].enabled ? yesstr : nostr;
      if (check_file[0] == '\0')
	check_file = data.dbs[i].check_file ? yesstr : nostr;
      if (shared[0] == '\0')
	shared = data.dbs[i].shared ? yesstr : nostr;
      if (persistent[0] == '\0')
	persistent = data.dbs[i].persistent ? yesstr : nostr;

      if (all == 0)
	/* If nothing happened so far report a 0% hit rate.  */
	all = 1;

      printf (_("\n%s cache:\n\n"
		"%15s  cache is enabled\n"
		"%15s  cache is persistent\n"
		"%15s  cache is shared\n"
		"%15zu  suggested size\n"
		"%15zu  total data pool size\n"
		"%15zu  used data pool size\n"
		"%15lu  seconds time to live for positive entries\n"
		"%15lu  seconds time to live for negative entries\n"
		"%15" PRIuMAX "  cache hits on positive entries\n"
		"%15" PRIuMAX "  cache hits on negative entries\n"
		"%15" PRIuMAX "  cache misses on positive entries\n"
		"%15" PRIuMAX "  cache misses on negative entries\n"
		"%15lu%% cache hit rate\n"
		"%15zu  current number of cached values\n"
		"%15zu  maximum number of cached values\n"
		"%15zu  maximum chain length searched\n"
		"%15" PRIuMAX "  number of delays on rdlock\n"
		"%15" PRIuMAX "  number of delays on wrlock\n"
		"%15" PRIuMAX "  memory allocations failed\n"
		"%15s  check /etc/%s for changes\n"),
	      dbnames[i], enabled, persistent, shared,
	      data.dbs[i].module,
	      data.dbs[i].datasize, data.dbs[i].dataused,
	      data.dbs[i].postimeout, data.dbs[i].negtimeout,
	      data.dbs[i].poshit, data.dbs[i].neghit,
	      data.dbs[i].posmiss, data.dbs[i].negmiss,
	      (100 * hit) / all,
	      data.dbs[i].nentries, data.dbs[i].maxnentries,
	      data.dbs[i].maxnsearched,
	      data.dbs[i].rdlockdelayed,
	      data.dbs[i].wrlockdelayed,
	      data.dbs[i].addfailed, check_file, dbnames[i]);
    }

  if (selinux_enabled)
    nscd_avc_print_stats (&data.cstats);

  close (fd);

  exit (0);
}