45b5eafb00226313e6297693f869c72029b3f886
[kopensolaris-gnu/glibc.git] / sysdeps / unix / sysv / linux / getsysstats.c
1 /* Determine various system internal values, Linux version.
2    Copyright (C) 1996, 1997, 1998, 1999, 2000 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 Library General Public License as
8    published by the Free Software Foundation; either version 2 of the
9    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    Library General Public License for more details.
15
16    You should have received a copy of the GNU Library General Public
17    License along with the GNU C Library; see the file COPYING.LIB.  If not,
18    write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
19    Boston, MA 02111-1307, USA.  */
20
21 #include <alloca.h>
22 #include <assert.h>
23 #include <errno.h>
24 #include <mntent.h>
25 #include <paths.h>
26 #include <stdio.h>
27 #include <stdlib.h>
28 #include <string.h>
29 #include <unistd.h>
30 #include <sys/sysinfo.h>
31
32 #include <atomicity.h>
33
34
35 /* The default value for the /proc filesystem mount point.  */
36 static const char path_proc[] = "/proc";
37
38 /* Actual mount point of /proc filesystem.  */
39 static char *mount_proc;
40
41 /* Determine the path to the /proc filesystem if available.  */
42 static const char *
43 internal_function
44 get_proc_path (char *buffer, size_t bufsize)
45 {
46   struct mntent mount_point;
47   struct mntent *entry;
48   char *result;
49   char *copy_result;
50   FILE *fp;
51
52   /* First find the mount point of the proc filesystem.  */
53   fp = __setmntent (_PATH_MOUNTED, "r");
54   if (fp == NULL)
55     fp = __setmntent (_PATH_MNTTAB, "r");
56   if (fp != NULL)
57     {
58       while ((entry = __getmntent_r (fp, &mount_point, buffer, bufsize))
59              != NULL)
60         if (strcmp (mount_point.mnt_type, path_proc) == 0)
61           {
62             result = mount_point.mnt_dir;
63             break;
64           }
65       __endmntent (fp);
66     }
67
68   /* If we haven't found anything this is generally a bad sign but we
69      handle it gracefully.  We return what is hopefully the right
70      answer (/proc) but we don't remember this.  This will enable
71      programs which started before the system is fully running to
72      adjust themselves.  */
73   if (result == NULL)
74     return path_proc;
75
76   /* Make a copy we can keep around.  */
77   copy_result = __strdup (result);
78   if (copy_result == NULL)
79     return result;
80
81   /* Now strore the copied value.  But do it atomically.  */
82   assert (sizeof (long int) == sizeof (void *));
83   if (compare_and_swap ((long int *) &mount_proc, (long int) 0,
84                         (long int) copy_result) == 0)
85     /* Replacing the value failed.  This means another thread was
86        faster and we don't need the copy anymore.  */
87     free (copy_result);
88
89   return mount_proc;
90 }
91
92
93 /* How we can determine the number of available processors depends on
94    the configuration.  There is currently (as of version 2.0.21) no
95    system call to determine the number.  It is planned for the 2.1.x
96    series to add this, though.
97
98    One possibility to implement it for systems using Linux 2.0 is to
99    examine the pseudo file /proc/cpuinfo.  Here we have one entry for
100    each processor.
101
102    But not all systems have support for the /proc filesystem.  If it
103    is not available we simply return 1 since there is no way.  */
104
105 /* Other architectures use different formats for /proc/cpuinfo.  This
106    provides a hook for alternative parsers.  */
107 #ifndef GET_NPROCS_PARSER
108 # define GET_NPROCS_PARSER(FP, BUFFER, RESULT)                          \
109   do                                                                    \
110     {                                                                   \
111       (RESULT) = 0;                                                     \
112       /* Read all lines and count the lines starting with the string    \
113          "processor".  We don't have to fear extremely long lines since \
114          the kernel will not generate them.  8192 bytes are really      \
115          enough.  */                                                    \
116       while (fgets_unlocked (BUFFER, sizeof (BUFFER), FP) != NULL)      \
117         if (strncmp (BUFFER, "processor", 9) == 0)                      \
118           ++(RESULT);                                                   \
119     }                                                                   \
120   while (0)
121 #endif
122
123 int
124 __get_nprocs ()
125 {
126   FILE *fp;
127   char buffer[8192];
128   const char *proc_path;
129   int result = 1;
130
131   /* XXX Here will come a test for the new system call.  */
132
133   /* Get mount point of proc filesystem.  */
134   proc_path = get_proc_path (buffer, sizeof buffer);
135
136   /* If we haven't found an appropriate entry return 1.  */
137   if (proc_path != NULL)
138     {
139       char *proc_cpuinfo = alloca (strlen (proc_path) + sizeof ("/cpuinfo"));
140       __stpcpy (__stpcpy (proc_cpuinfo, proc_path), "/cpuinfo");
141
142       fp = fopen (proc_cpuinfo, "r");
143       if (fp != NULL)
144         {
145           GET_NPROCS_PARSER (fp, buffer, result);
146           fclose (fp);
147         }
148     }
149
150   return result;
151 }
152 weak_alias (__get_nprocs, get_nprocs)
153
154
155 #ifdef GET_NPROCS_CONF_PARSER
156 /* On some architectures it is possible to distinguish between configured
157    and active cpus.  */
158 int
159 __get_nprocs_conf ()
160 {
161   FILE *fp;
162   char buffer[8192];
163   const char *proc_path;
164   int result = 1;
165
166   /* XXX Here will come a test for the new system call.  */
167
168   /* Get mount point of proc filesystem.  */
169   proc_path = get_proc_path (buffer, sizeof buffer);
170
171   /* If we haven't found an appropriate entry return 1.  */
172   if (proc_path != NULL)
173     {
174       char *proc_cpuinfo = alloca (strlen (proc_path) + sizeof ("/cpuinfo"));
175       __stpcpy (__stpcpy (proc_cpuinfo, proc_path), "/cpuinfo");
176
177       fp = fopen (proc_cpuinfo, "r");
178       if (fp != NULL)
179         {
180           GET_NPROCS_CONF_PARSER (fp, buffer, result);
181           fclose (fp);
182         }
183     }
184
185   return result;
186 }
187 #else
188 /* As far as I know Linux has no separate numbers for configured and
189    available processors.  So make the `get_nprocs_conf' function an
190    alias.  */
191 strong_alias (__get_nprocs, __get_nprocs_conf)
192 #endif
193 weak_alias (__get_nprocs_conf, get_nprocs_conf)
194
195 /* General function to get information about memory status from proc
196    filesystem.  */
197 static int
198 internal_function
199 phys_pages_info (const char *format)
200 {
201   FILE *fp;
202   char buffer[8192];
203   const char *proc_path;
204   int result = -1;
205
206   /* Get mount point of proc filesystem.  */
207   proc_path = get_proc_path (buffer, sizeof buffer);
208
209   /* If we haven't found an appropriate entry return 1.  */
210   if (proc_path != NULL)
211     {
212       char *proc_meminfo = alloca (strlen (proc_path) + sizeof ("/meminfo"));
213       __stpcpy (__stpcpy (proc_meminfo, proc_path), "/meminfo");
214
215       fp = fopen (proc_meminfo, "r");
216       if (fp != NULL)
217         {
218           result = 0;
219           /* Read all lines and count the lines starting with the
220              string "processor".  We don't have to fear extremely long
221              lines since the kernel will not generate them.  8192
222              bytes are really enough.  */
223           while (fgets_unlocked (buffer, sizeof buffer, fp) != NULL)
224             if (sscanf (buffer, format, &result) == 1)
225               {
226                 result /= (__getpagesize () / 1024);
227                 break;
228               }
229
230           fclose (fp);
231         }
232     }
233
234   if (result == -1)
235     /* We cannot get the needed value: signal an error.  */
236     __set_errno (ENOSYS);
237
238   return result;
239 }
240
241
242 /* Return the number of pages of physical memory in the system.  There
243    is currently (as of version 2.0.21) no system call to determine the
244    number.  It is planned for the 2.1.x series to add this, though.
245
246    One possibility to implement it for systems using Linux 2.0 is to
247    examine the pseudo file /proc/cpuinfo.  Here we have one entry for
248    each processor.
249
250    But not all systems have support for the /proc filesystem.  If it
251    is not available we return -1 as an error signal.  */
252 int
253 __get_phys_pages ()
254 {
255   /* XXX Here will come a test for the new system call.  */
256
257   return phys_pages_info ("MemTotal: %d kB");
258 }
259 weak_alias (__get_phys_pages, get_phys_pages)
260
261
262 /* Return the number of available pages of physical memory in the
263    system.  There is currently (as of version 2.0.21) no system call
264    to determine the number.  It is planned for the 2.1.x series to add
265    this, though.
266
267    One possibility to implement it for systems using Linux 2.0 is to
268    examine the pseudo file /proc/cpuinfo.  Here we have one entry for
269    each processor.
270
271    But not all systems have support for the /proc filesystem.  If it
272    is not available we return -1 as an error signal.  */
273 int
274 __get_avphys_pages ()
275 {
276   /* XXX Here will come a test for the new system call.  */
277
278   return phys_pages_info ("MemFree: %d kB");
279 }
280 weak_alias (__get_avphys_pages, get_avphys_pages)
281
282
283 static void
284 free_mem (void)
285 {
286   free (mount_proc);
287 }
288 text_set_element (__libc_subfreeres, free_mem);