1 /* Copyright (c) 1998-2023 Free Software Foundation, Inc.
2 This file is part of the GNU C Library.
3
4 The GNU C Library is free software; you can redistribute it and/or
5 modify it under the terms of the GNU Lesser General Public
6 License as published by the Free Software Foundation; either
7 version 2.1 of the License, or (at your option) any later version.
8
9 The GNU C Library is distributed in the hope that it will be useful,
10 but WITHOUT ANY WARRANTY; without even the implied warranty of
11 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
12 Lesser General Public License for more details.
13
14 You should have received a copy of the GNU Lesser General Public
15 License along with the GNU C Library; if not, see
16 <https://www.gnu.org/licenses/>. */
17
18 #include <errno.h>
19 #include <error.h>
20 #include <inttypes.h>
21 #include <langinfo.h>
22 #include <stdio.h>
23 #include <stdlib.h>
24 #include <string.h>
25 #include <sys/socket.h>
26 #include <unistd.h>
27 #include <libintl.h>
28
29 #include "nscd.h"
30 #include "dbg_log.h"
31 #include "selinux.h"
32 #ifdef HAVE_SELINUX
33 # include <selinux/selinux.h>
34 # include <selinux/avc.h>
35 #endif /* HAVE_SELINUX */
36
37 /* We use this to make sure the receiver is the same. The lower 16
38 bits are reserved for flags indicating compilation variants. This
39 version needs to be updated if the definition of struct statdata
40 changes. */
41 #define STATDATA_VERSION 0x01020000U
42
43 #ifdef HAVE_SELINUX
44 # define STATDATA_VERSION_SELINUX_FLAG 0x0001U
45 #else
46 # define STATDATA_VERSION_SELINUX_FLAG 0x0000U
47 #endif
48
49 /* All flags affecting the struct statdata layout. */
50 #define STATDATA_VERSION_FLAGS STATDATA_VERSION_SELINUX_FLAG
51
52 /* The full version number for struct statdata. */
53 #define STATDATA_VERSION_FULL (STATDATA_VERSION | STATDATA_VERSION_FLAGS)
54
55 /* Statistic data for one database. */
56 struct dbstat
57 {
58 int enabled;
59 int check_file;
60 int shared;
61 int persistent;
62 size_t module;
63
64 unsigned long int postimeout;
65 unsigned long int negtimeout;
66
67 size_t nentries;
68 size_t maxnentries;
69 size_t maxnsearched;
70 size_t datasize;
71 size_t dataused;
72
73 uintmax_t poshit;
74 uintmax_t neghit;
75 uintmax_t posmiss;
76 uintmax_t negmiss;
77
78 uintmax_t rdlockdelayed;
79 uintmax_t wrlockdelayed;
80
81 uintmax_t addfailed;
82 };
83
84 /* Record for transmitting statistics. If this definition changes,
85 update STATDATA_VERSION above. */
86 struct statdata
87 {
88 unsigned int version; /* Must be STATDATA_VERSION_FULL. */
89 int debug_level;
90 time_t runtime;
91 unsigned long int client_queued;
92 int nthreads;
93 int max_nthreads;
94 int paranoia;
95 time_t restart_interval;
96 unsigned int reload_count;
97 int ndbs;
98 struct dbstat dbs[lastdb];
99 #ifdef HAVE_SELINUX
100 struct avc_cache_stats cstats;
101 #endif /* HAVE_SELINUX */
102 };
103
104
105 void
106 send_stats (int fd, struct database_dyn dbs[lastdb])
107 {
108 struct statdata data;
109 int cnt;
110
111 memset (&data, 0, sizeof (data));
112
113 data.version = STATDATA_VERSION_FULL;
114 data.debug_level = debug_level;
115 data.runtime = time (NULL) - start_time;
116 data.client_queued = client_queued;
117 data.nthreads = nthreads;
118 data.max_nthreads = max_nthreads;
119 data.paranoia = paranoia;
120 data.restart_interval = restart_interval;
121 data.reload_count = reload_count;
122 data.ndbs = lastdb;
123
124 for (cnt = 0; cnt < lastdb; ++cnt)
125 {
126 memset (&data.dbs[cnt], 0, sizeof (data.dbs[cnt]));
127 data.dbs[cnt].enabled = dbs[cnt].enabled;
128 data.dbs[cnt].check_file = dbs[cnt].check_file;
129 data.dbs[cnt].shared = dbs[cnt].shared;
130 data.dbs[cnt].persistent = dbs[cnt].persistent;
131 data.dbs[cnt].postimeout = dbs[cnt].postimeout;
132 data.dbs[cnt].negtimeout = dbs[cnt].negtimeout;
133 if (dbs[cnt].head != NULL)
134 {
135 data.dbs[cnt].module = dbs[cnt].head->module;
136 data.dbs[cnt].poshit = dbs[cnt].head->poshit;
137 data.dbs[cnt].neghit = dbs[cnt].head->neghit;
138 data.dbs[cnt].posmiss = dbs[cnt].head->posmiss;
139 data.dbs[cnt].negmiss = dbs[cnt].head->negmiss;
140 data.dbs[cnt].nentries = dbs[cnt].head->nentries;
141 data.dbs[cnt].maxnentries = dbs[cnt].head->maxnentries;
142 data.dbs[cnt].datasize = dbs[cnt].head->data_size;
143 data.dbs[cnt].dataused = dbs[cnt].head->first_free;
144 data.dbs[cnt].maxnsearched = dbs[cnt].head->maxnsearched;
145 data.dbs[cnt].rdlockdelayed = dbs[cnt].head->rdlockdelayed;
146 data.dbs[cnt].wrlockdelayed = dbs[cnt].head->wrlockdelayed;
147 data.dbs[cnt].addfailed = dbs[cnt].head->addfailed;
148 }
149 }
150
151 if (selinux_enabled)
152 nscd_avc_cache_stats (&data.cstats);
153
154 if (TEMP_FAILURE_RETRY (send (fd, &data, sizeof (data), MSG_NOSIGNAL))
155 != sizeof (data))
156 {
157 char buf[256];
158 dbg_log (_("cannot write statistics: %s"),
159 strerror_r (errno, buf, sizeof (buf)));
160 }
161 }
162
163
164 int
165 receive_print_stats (void)
166 {
167 struct statdata data;
168 request_header req;
169 ssize_t nbytes;
170 int fd;
171 int i;
172 uid_t uid = getuid ();
173 const char *yesstr = _("yes");
174 const char *nostr = _("no");
175
176 /* Find out whether there is another user but root allowed to
177 request statistics. */
178 if (uid != 0)
179 {
180 /* User specified? */
181 if(stat_user == NULL || stat_uid != uid)
182 {
183 if (stat_user != NULL)
184 error (EXIT_FAILURE, 0,
185 _("Only root or %s is allowed to use this option!"),
186 stat_user);
187 else
188 error (EXIT_FAILURE, 0,
189 _("Only root is allowed to use this option!"));
190 }
191 }
192
193 /* Open a socket to the running nscd. */
194 fd = nscd_open_socket ();
195 if (fd == -1)
196 error (EXIT_FAILURE, 0, _("nscd not running!\n"));
197
198 /* Send the request. */
199 req.version = NSCD_VERSION;
200 req.type = GETSTAT;
201 req.key_len = 0;
202 nbytes = TEMP_FAILURE_RETRY (send (fd, &req, sizeof (request_header),
203 MSG_NOSIGNAL));
204 if (nbytes != sizeof (request_header))
205 {
206 int err = errno;
207 close (fd);
208 error (EXIT_FAILURE, err, _("write incomplete"));
209 }
210
211 /* Read as much data as we expect. */
212 if (TEMP_FAILURE_RETRY (read (fd, &data, sizeof (data))) != sizeof (data)
213 || (data.version != STATDATA_VERSION_FULL
214 /* Yes, this is an assignment! */
215 && (errno = EINVAL)))
216 {
217 /* Not the right version. */
218 int err = errno;
219 close (fd);
220 error (EXIT_FAILURE, err, _("cannot read statistics data"));
221 }
222
223 printf (_("nscd configuration:\n\n%15d server debug level\n"),
224 data.debug_level);
225
226 /* We know that we can simply subtract time_t values. */
227 unsigned long int diff = data.runtime;
228 unsigned int ndays = 0;
229 unsigned int nhours = 0;
230 unsigned int nmins = 0;
231 if (diff > 24 * 60 * 60)
232 {
233 ndays = diff / (24 * 60 * 60);
234 diff %= 24 * 60 * 60;
235 }
236 if (diff > 60 * 60)
237 {
238 nhours = diff / (60 * 60);
239 diff %= 60 * 60;
240 }
241 if (diff > 60)
242 {
243 nmins = diff / 60;
244 diff %= 60;
245 }
246 if (ndays != 0)
247 printf (_("%3ud %2uh %2um %2lus server runtime\n"),
248 ndays, nhours, nmins, diff);
249 else if (nhours != 0)
250 printf (_(" %2uh %2um %2lus server runtime\n"), nhours, nmins, diff);
251 else if (nmins != 0)
252 printf (_(" %2um %2lus server runtime\n"), nmins, diff);
253 else
254 printf (_(" %2lus server runtime\n"), diff);
255
256 printf (_("%15d current number of threads\n"
257 "%15d maximum number of threads\n"
258 "%15lu number of times clients had to wait\n"
259 "%15s paranoia mode enabled\n"
260 "%15lu restart internal\n"
261 "%15u reload count\n"),
262 data.nthreads, data.max_nthreads, data.client_queued,
263 data.paranoia ? yesstr : nostr,
264 (unsigned long int) data.restart_interval, data.reload_count);
265
266 for (i = 0; i < lastdb; ++i)
267 {
268 unsigned long int hit = data.dbs[i].poshit + data.dbs[i].neghit;
269 unsigned long int all = hit + data.dbs[i].posmiss + data.dbs[i].negmiss;
270 const char *enabled = data.dbs[i].enabled ? yesstr : nostr;
271 const char *check_file = data.dbs[i].check_file ? yesstr : nostr;
272 const char *shared = data.dbs[i].shared ? yesstr : nostr;
273 const char *persistent = data.dbs[i].persistent ? yesstr : nostr;
274
275 if (enabled[0] == '\0')
276 /* The locale does not provide this information so we have to
277 translate it ourself. Since we should avoid short translation
278 terms we artificially increase the length. */
279 enabled = data.dbs[i].enabled ? yesstr : nostr;
280 if (check_file[0] == '\0')
281 check_file = data.dbs[i].check_file ? yesstr : nostr;
282 if (shared[0] == '\0')
283 shared = data.dbs[i].shared ? yesstr : nostr;
284 if (persistent[0] == '\0')
285 persistent = data.dbs[i].persistent ? yesstr : nostr;
286
287 if (all == 0)
288 /* If nothing happened so far report a 0% hit rate. */
289 all = 1;
290
291 printf (_("\n%s cache:\n\n"
292 "%15s cache is enabled\n"
293 "%15s cache is persistent\n"
294 "%15s cache is shared\n"
295 "%15zu suggested size\n"
296 "%15zu total data pool size\n"
297 "%15zu used data pool size\n"
298 "%15lu seconds time to live for positive entries\n"
299 "%15lu seconds time to live for negative entries\n"
300 "%15" PRIuMAX " cache hits on positive entries\n"
301 "%15" PRIuMAX " cache hits on negative entries\n"
302 "%15" PRIuMAX " cache misses on positive entries\n"
303 "%15" PRIuMAX " cache misses on negative entries\n"
304 "%15lu%% cache hit rate\n"
305 "%15zu current number of cached values\n"
306 "%15zu maximum number of cached values\n"
307 "%15zu maximum chain length searched\n"
308 "%15" PRIuMAX " number of delays on rdlock\n"
309 "%15" PRIuMAX " number of delays on wrlock\n"
310 "%15" PRIuMAX " memory allocations failed\n"
311 "%15s check /etc/%s for changes\n"),
312 dbnames[i], enabled, persistent, shared,
313 data.dbs[i].module,
314 data.dbs[i].datasize, data.dbs[i].dataused,
315 data.dbs[i].postimeout, data.dbs[i].negtimeout,
316 data.dbs[i].poshit, data.dbs[i].neghit,
317 data.dbs[i].posmiss, data.dbs[i].negmiss,
318 (100 * hit) / all,
319 data.dbs[i].nentries, data.dbs[i].maxnentries,
320 data.dbs[i].maxnsearched,
321 data.dbs[i].rdlockdelayed,
322 data.dbs[i].wrlockdelayed,
323 data.dbs[i].addfailed, check_file, dbnames[i]);
324 }
325
326 if (selinux_enabled)
327 nscd_avc_print_stats (&data.cstats);
328
329 close (fd);
330
331 exit (0);
332 }