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