1/* Determine various system internal values, Linux version.
2 Copyright (C) 1996-2021 Free Software Foundation, Inc.
3 This file is part of the GNU C Library.
4 Contributed by Ulrich Drepper <drepper@cygnus.com>, 1996.
5
6 The GNU C Library is free software; you can redistribute it and/or
7 modify it under the terms of the GNU Lesser General Public
8 License as published by the Free Software Foundation; either
9 version 2.1 of the License, or (at your option) any later version.
10
11 The GNU C Library is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 Lesser General Public License for more details.
15
16 You should have received a copy of the GNU Lesser General Public
17 License along with the GNU C Library; if not, see
18 <https://www.gnu.org/licenses/>. */
19
20#include <alloca.h>
21#include <assert.h>
22#include <ctype.h>
23#include <dirent.h>
24#include <errno.h>
25#include <fcntl.h>
26#include <mntent.h>
27#include <paths.h>
28#include <stdio.h>
29#include <stdio_ext.h>
30#include <stdlib.h>
31#include <string.h>
32#include <unistd.h>
33#include <sys/sysinfo.h>
34
35#include <atomic.h>
36#include <not-cancel.h>
37
38
39/* How we can determine the number of available processors depends on
40 the configuration. There is currently (as of version 2.0.21) no
41 system call to determine the number. It is planned for the 2.1.x
42 series to add this, though.
43
44 One possibility to implement it for systems using Linux 2.0 is to
45 examine the pseudo file /proc/cpuinfo. Here we have one entry for
46 each processor.
47
48 But not all systems have support for the /proc filesystem. If it
49 is not available we simply return 1 since there is no way. */
50
51
52/* Other architectures use different formats for /proc/cpuinfo. This
53 provides a hook for alternative parsers. */
54#ifndef GET_NPROCS_PARSER
55# define GET_NPROCS_PARSER(FD, BUFFER, CP, RE, BUFFER_END, RESULT) \
56 do \
57 { \
58 (RESULT) = 0; \
59 /* Read all lines and count the lines starting with the string \
60 "processor". We don't have to fear extremely long lines since \
61 the kernel will not generate them. 8192 bytes are really \
62 enough. */ \
63 char *l; \
64 while ((l = next_line (FD, BUFFER, &CP, &RE, BUFFER_END)) != NULL) \
65 if (strncmp (l, "processor", 9) == 0) \
66 ++(RESULT); \
67 } \
68 while (0)
69#endif
70
71
72static char *
73next_line (int fd, char *const buffer, char **cp, char **re,
74 char *const buffer_end)
75{
76 char *res = *cp;
77 char *nl = memchr (*cp, '\n', *re - *cp);
78 if (nl == NULL)
79 {
80 if (*cp != buffer)
81 {
82 if (*re == buffer_end)
83 {
84 memmove (buffer, *cp, *re - *cp);
85 *re = buffer + (*re - *cp);
86 *cp = buffer;
87
88 ssize_t n = __read_nocancel (fd, *re, buffer_end - *re);
89 if (n < 0)
90 return NULL;
91
92 *re += n;
93
94 nl = memchr (*cp, '\n', *re - *cp);
95 while (nl == NULL && *re == buffer_end)
96 {
97 /* Truncate too long lines. */
98 *re = buffer + 3 * (buffer_end - buffer) / 4;
99 n = __read_nocancel (fd, *re, buffer_end - *re);
100 if (n < 0)
101 return NULL;
102
103 nl = memchr (*re, '\n', n);
104 **re = '\n';
105 *re += n;
106 }
107 }
108 else
109 nl = memchr (*cp, '\n', *re - *cp);
110
111 res = *cp;
112 }
113
114 if (nl == NULL)
115 nl = *re - 1;
116 }
117
118 *cp = nl + 1;
119 assert (*cp <= *re);
120
121 return res == *re ? NULL : res;
122}
123
124
125int
126__get_nprocs (void)
127{
128 static int cached_result = -1;
129 static time_t timestamp;
130
131 time_t now = time_now ();
132 time_t prev = timestamp;
133 atomic_read_barrier ();
134 if (now == prev && cached_result > -1)
135 return cached_result;
136
137 /* XXX Here will come a test for the new system call. */
138
139 const size_t buffer_size = __libc_use_alloca (8192) ? 8192 : 512;
140 char *buffer = alloca (buffer_size);
141 char *buffer_end = buffer + buffer_size;
142 char *cp = buffer_end;
143 char *re = buffer_end;
144
145 const int flags = O_RDONLY | O_CLOEXEC;
146 /* This file contains comma-separated ranges. */
147 int fd = __open_nocancel ("/sys/devices/system/cpu/online", flags);
148 char *l;
149 int result = 0;
150 if (fd != -1)
151 {
152 l = next_line (fd, buffer, &cp, &re, buffer_end);
153 if (l != NULL)
154 do
155 {
156 char *endp;
157 unsigned long int n = strtoul (l, &endp, 10);
158 if (l == endp)
159 {
160 result = 0;
161 break;
162 }
163
164 unsigned long int m = n;
165 if (*endp == '-')
166 {
167 l = endp + 1;
168 m = strtoul (l, &endp, 10);
169 if (l == endp)
170 {
171 result = 0;
172 break;
173 }
174 }
175
176 result += m - n + 1;
177
178 l = endp;
179 if (l < re && *l == ',')
180 ++l;
181 }
182 while (l < re && *l != '\n');
183
184 __close_nocancel_nostatus (fd);
185
186 if (result > 0)
187 goto out;
188 }
189
190 cp = buffer_end;
191 re = buffer_end;
192
193 /* Default to an SMP system in case we cannot obtain an accurate
194 number. */
195 result = 2;
196
197 /* The /proc/stat format is more uniform, use it by default. */
198 fd = __open_nocancel ("/proc/stat", flags);
199 if (fd != -1)
200 {
201 result = 0;
202
203 while ((l = next_line (fd, buffer, &cp, &re, buffer_end)) != NULL)
204 /* The current format of /proc/stat has all the cpu* entries
205 at the front. We assume here that stays this way. */
206 if (strncmp (l, "cpu", 3) != 0)
207 break;
208 else if (isdigit (l[3]))
209 ++result;
210
211 __close_nocancel_nostatus (fd);
212 }
213 else
214 {
215 fd = __open_nocancel ("/proc/cpuinfo", flags);
216 if (fd != -1)
217 {
218 GET_NPROCS_PARSER (fd, buffer, cp, re, buffer_end, result);
219 __close_nocancel_nostatus (fd);
220 }
221 }
222
223 out:
224 cached_result = result;
225 atomic_write_barrier ();
226 timestamp = now;
227
228 return result;
229}
230libc_hidden_def (__get_nprocs)
231weak_alias (__get_nprocs, get_nprocs)
232
233
234/* On some architectures it is possible to distinguish between configured
235 and active cpus. */
236int
237__get_nprocs_conf (void)
238{
239 /* XXX Here will come a test for the new system call. */
240
241 /* Try to use the sysfs filesystem. It has actual information about
242 online processors. */
243 DIR *dir = __opendir ("/sys/devices/system/cpu");
244 if (dir != NULL)
245 {
246 int count = 0;
247 struct dirent64 *d;
248
249 while ((d = __readdir64 (dir)) != NULL)
250 /* NB: the sysfs has d_type support. */
251 if (d->d_type == DT_DIR && strncmp (d->d_name, "cpu", 3) == 0)
252 {
253 char *endp;
254 unsigned long int nr = strtoul (d->d_name + 3, &endp, 10);
255 if (nr != ULONG_MAX && endp != d->d_name + 3 && *endp == '\0')
256 ++count;
257 }
258
259 __closedir (dir);
260
261 return count;
262 }
263
264 int result = 1;
265
266#ifdef GET_NPROCS_CONF_PARSER
267 /* If we haven't found an appropriate entry return 1. */
268 FILE *fp = fopen ("/proc/cpuinfo", "rce");
269 if (fp != NULL)
270 {
271 char buffer[8192];
272
273 /* No threads use this stream. */
274 __fsetlocking (fp, FSETLOCKING_BYCALLER);
275 GET_NPROCS_CONF_PARSER (fp, buffer, result);
276 fclose (fp);
277 }
278#else
279 result = __get_nprocs ();
280#endif
281
282 return result;
283}
284libc_hidden_def (__get_nprocs_conf)
285weak_alias (__get_nprocs_conf, get_nprocs_conf)
286
287
288/* Compute (num*mem_unit)/pagesize, but avoid overflowing long int.
289 In practice, mem_unit is never bigger than the page size, so after
290 the first loop it is 1. [In the kernel, it is initialized to
291 PAGE_SIZE in mm/page_alloc.c:si_meminfo(), and then in
292 kernel.sys.c:do_sysinfo() it is set to 1 if unsigned long can
293 represent all the sizes measured in bytes]. */
294static long int
295sysinfo_mempages (unsigned long int num, unsigned int mem_unit)
296{
297 unsigned long int ps = __getpagesize ();
298
299 while (mem_unit > 1 && ps > 1)
300 {
301 mem_unit >>= 1;
302 ps >>= 1;
303 }
304 num *= mem_unit;
305 while (ps > 1)
306 {
307 ps >>= 1;
308 num >>= 1;
309 }
310 return num;
311}
312
313/* Return the number of pages of total/available physical memory in
314 the system. This used to be done by parsing /proc/meminfo, but
315 that's unnecessarily expensive (and /proc is not always available).
316 The sysinfo syscall provides the same information, and has been
317 available at least since kernel 2.3.48. */
318long int
319__get_phys_pages (void)
320{
321 struct sysinfo info;
322
323 __sysinfo (&info);
324 return sysinfo_mempages (info.totalram, info.mem_unit);
325}
326libc_hidden_def (__get_phys_pages)
327weak_alias (__get_phys_pages, get_phys_pages)
328
329long int
330__get_avphys_pages (void)
331{
332 struct sysinfo info;
333
334 __sysinfo (&info);
335 return sysinfo_mempages (info.freeram, info.mem_unit);
336}
337libc_hidden_def (__get_avphys_pages)
338weak_alias (__get_avphys_pages, get_avphys_pages)
339