/* Copyright (c) 1998-2014 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; 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); }