lib/glibc
1
0
Fork 0
mirror of https://sourceware.org/git/glibc.git synced 2026-01-06 11:51:29 +03:00
Code Activity

2005-12-08 Steven Munroe <sjmunroe@us.ibm.com>

Browse Source 
Tom Gall <tom_gall@vnet.ibm.com>

	* elf/rtld.c (dl_main): Initialize l_local_scope for sysinfo_map.
	* sysdeps/powerpc/elf/libc-start.c: Move this...
	* sysdeps/unix/sysv/linux/powerpc/libc-start.c: ...to here.
	* sysdeps/powerpc/powerpc32/dl-start.S: Add _dl_main_dispatch label.
	* sysdeps/powerpc/powerpc32/hp-timing.h: New file.
	* sysdeps/unix/sysv/linux/powerpc/Versions: New file.
	* sysdeps/unix/sysv/linux/clock_getres.c: If HAVE_CLOCK_GETRES_VSYSCALL
	is not defined, redefine INTERNAL_VSYSCALL and INLINE_VSYSCALL to
	INTERNAL_SYSCALL and INLINE_SYSCALL respectively.  Otherwise include
	<bits/libc-vdso.h>.  Use INLINE_VSYSCALL and INTERNAL_SYSCALL instead
	of the normal versions throughout the code.
	* sysdeps/unix/sysv/linux/clock_gettime.c: Likewise if
	HAVE_CLOCK_GETTIME_VSYSCALL is defined.
	* sysdeps/unix/sysv/linux/powerpc/bits/libc-vdso.h: New file.
	* sysdeps/unix/sysv/linux/powerpc/dl-vdso.c: New file.
	* sysdeps/unix/sysv/linux/powerpc/dl-vdso.h: New file.
	* sysdeps/unix/sysv/linux/powerpc/get_clockfreq.c: Use vDSO.
	* sysdeps/unix/sysv/linux/powerpc/gettimeofday.c: New file.
	* sysdeps/unix/sysv/linux/powerpc/Makefile: Add dl-vdso to routines.
	* sysdeps/unix/sysv/linux/powerpc/powerpc32/sysdep.h: Define
	INLINE_VSYSCALL, INTERNAL_VSYSCALL, INTERNAL_SYSCALL_NCS,
	INTERNAL_VSYSCALL_NO_SYSCALL_FALLBACK, HAVE_CLOCK_GETRES_VSYSCALL,
	and HAVE_CLOCK_GETTIME_VSYSCALL.
	* sysdeps/unix/sysv/linux/powerpc/powerpc64/sysdep.h: Likewise.
This commit is contained in:
Ulrich Drepper
2005-12-30 07:32:48 +00:00
parent 4e54d7e476
commit 8c2e201ba9
16 changed files with 665 additions and 104 deletions
Download Patch File Download Diff File Expand all files Collapse all files

122
sysdeps/unix/sysv/linux/powerpc/get_clockfreq.c
View File

@@ -22,14 +22,15 @@
#include <string.h>
#include <unistd.h>
#include <libc-internal.h>
#include <sysdep.h>
#include <bits/libc-vdso.h>
hp_timing_t
__get_clockfreq (void)
{
/* We read the information from the /proc filesystem. /proc/cpuinfo
contains at least one line like:
timebase : 33333333
timebase : 33333333
We search for this line and convert the number into an integer. */
static hp_timing_t timebase_freq;
hp_timing_t result = 0L;
@@ -38,67 +39,78 @@ __get_clockfreq (void)
if (timebase_freq != 0)
return timebase_freq;
int fd = open ("/proc/cpuinfo", O_RDONLY);
if (__builtin_expect (fd != -1, 1))
/* If we can use the vDSO to obtain the timebase even better. */
#ifdef SHARED
INTERNAL_SYSCALL_DECL (err);
timebase_freq = INTERNAL_VSYSCALL_NO_SYSCALL_FALLBACK (get_tbfreq, err, 0);
if (INTERNAL_SYSCALL_ERROR_P (timebase_freq, err)
&& INTERNAL_SYSCALL_ERRNO (timebase_freq, err) == ENOSYS)
#endif
{
/* The timebase will be in the 1st 1024 bytes for systems with up
to 8 processors. If the first read returns less then 1024
bytes read, we have the whole cpuinfo and can start the scan.
Otherwise we will have to read more to insure we have the
timebase value in the scan. */
char buf[1024];
ssize_t n;
int fd = open ("/proc/cpuinfo", O_RDONLY);
n = read (fd, buf, sizeof (buf));
if (n == sizeof (buf))
if (__builtin_expect (fd != -1, 1))
{
/* We are here because the 1st read returned exactly sizeof
(buf) bytes. This implies that we are not at EOF and may
not have read the timebase value yet. So we need to read
more bytes until we know we have EOF. We copy the lower
half of buf to the upper half and read sizeof (buf)/2
bytes into the lower half of buf and repeat until we
reach EOF. We can assume that the timebase will be in
the last 512 bytes of cpuinfo, so two 512 byte half_bufs
will be sufficient to contain the timebase and will
handle the case where the timebase spans the half_buf
boundry. */
const ssize_t half_buf = sizeof (buf) / 2;
while (n >= half_buf)
/* The timebase will be in the 1st 1024 bytes for systems with up
to 8 processors. If the first read returns less then 1024
bytes read, we have the whole cpuinfo and can start the scan.
Otherwise we will have to read more to insure we have the
timebase value in the scan. */
char buf[1024];
ssize_t n;
n = read (fd, buf, sizeof (buf));
if (n == sizeof (buf))
{
memcpy (buf, buf + half_buf, half_buf);
n = read (fd, buf + half_buf, half_buf);
}
if (n >= 0)
n += half_buf;
}
if (__builtin_expect (n, 1) > 0)
{
char *mhz = memmem (buf, n, "timebase", 7);
if (__builtin_expect (mhz != NULL, 1))
{
char *endp = buf + n;
/* Search for the beginning of the string. */
while (mhz < endp && (*mhz < '0' || *mhz > '9') && *mhz != '\n')
++mhz;
while (mhz < endp && *mhz != '\n')
/* We are here because the 1st read returned exactly sizeof
(buf) bytes. This implies that we are not at EOF and may
not have read the timebase value yet. So we need to read
more bytes until we know we have EOF. We copy the lower
half of buf to the upper half and read sizeof (buf)/2
bytes into the lower half of buf and repeat until we
reach EOF. We can assume that the timebase will be in
the last 512 bytes of cpuinfo, so two 512 byte half_bufs
will be sufficient to contain the timebase and will
handle the case where the timebase spans the half_buf
boundry. */
const ssize_t half_buf = sizeof (buf) / 2;
while (n >= half_buf)
{
if (*mhz >= '0' && *mhz <= '9')
{
result *= 10;
result += *mhz - '0';
}
++mhz;
memcpy (buf, buf + half_buf, half_buf);
n = read (fd, buf + half_buf, half_buf);
}
if (n >= 0)
n += half_buf;
}
timebase_freq = result;
if (__builtin_expect (n, 1) > 0)
{
char *mhz = memmem (buf, n, "timebase", 7);
if (__builtin_expect (mhz != NULL, 1))
{
char *endp = buf + n;
/* Search for the beginning of the string. */
while (mhz < endp && (*mhz < '0' || *mhz > '9')
&& *mhz != '\n')
++mhz;
while (mhz < endp && *mhz != '\n')
{
if (*mhz >= '0' && *mhz <= '9')
{
result *= 10;
result += *mhz - '0';
}
++mhz;
}
}
timebase_freq = result;
}
close (fd);
}
close (fd);
}
return timebase_freq;