picnoir/glibc
1
0
Fork 0
Code Issues Pull requests Packages Projects Releases Wiki Activity

Remove __ASSUME_POSIX_CPU_TIMERS.

Browse source
This commit is contained in:
Joseph Myers 2012-09-01 21:32:04 +00:00
parent 033d54a2d4
commit 26889eacc2
8 changed files with 55 additions and 324 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

23
ChangeLog
View file

@ -1,3 +1,26 @@
2012-09-01 Joseph Myers <joseph@codesourcery.com>
* sysdeps/unix/sysv/linux/kernel-features.h
(__ASSUME_POSIX_CPU_TIMERS): Remove.
* sysdeps/unix/sysv/linux/clock_getcpuclockid.c
[__NR_clock_getres]: Make code unconditional.
[!__ASSUME_POSIX_CPU_TIMERS]: Remoce conditional code.
(clock_getcpuclockid): Remove code left unreachable by removal of
conditionals.
* sysdeps/unix/sysv/linux/clock_getres.c [__NR_clock_getres]: Make
code unconditional.
[__ASSUME_POSIX_CPU_TIMERS]: Likewise.
[!__ASSUME_POSIX_CPU_TIMERS]: Remove conditional code.
* sysdeps/unix/sysv/linux/clock_gettime.c [__NR_clock_gettime]:
Make code unconditional.
[__ASSUME_POSIX_CPU_TIMERS]: Likewise.
[!__ASSUME_POSIX_CPU_TIMERS]: Remove conditional code.
* sysdeps/unix/sysv/linux/clock_settime.c
[__ASSUME_POSIX_CPU_TIMERS <= 0 && __NR_clock_settime]: Remove
conditional code.
[__ASSUME_POSIX_CPU_TIMERS]: Make code unconditional.
[!__ASSUME_POSIX_CPU_TIMERS]: Remove conditional code.
2012-08-29 H.J. Lu <hongjiu.lu@intel.com>
[BZ #14476]

8
nptl/ChangeLog
View file

@ -1,3 +1,11 @@
2012-09-01 Joseph Myers <joseph@codesourcery.com>
* sysdeps/unix/sysv/linux/pthread_getcpuclockid.c
[!__ASSUME_POSIX_CPU_TIMERS]: Remove conditional code.
[__NR_clock_getres]: Make code unconditional.
(pthread_getcpuclockid): Remove code left unreachable by removal
of conditionals.
2012-08-31 Joseph Myers <joseph@codesourcery.com>
[BZ #14532]

53
nptl/sysdeps/unix/sysv/linux/pthread_getcpuclockid.c
View file

@ -24,10 +24,6 @@
#include <kernel-posix-cpu-timers.h>
#if !(__ASSUME_POSIX_CPU_TIMERS > 0)
int __libc_missing_posix_cpu_timers attribute_hidden;
#endif
int
pthread_getcpuclockid (threadid, clockid)
pthread_t threadid;
@ -40,55 +36,10 @@ pthread_getcpuclockid (threadid, clockid)
/* Not a valid thread handle. */
return ESRCH;
#ifdef __NR_clock_getres
/* The clockid_t value is a simple computation from the TID.
But we do a clock_getres call to validate it if we aren't
yet sure we have the kernel support. */
/* The clockid_t value is a simple computation from the TID. */
const clockid_t tidclock = MAKE_THREAD_CPUCLOCK (pd->tid, CPUCLOCK_SCHED);
# if !(__ASSUME_POSIX_CPU_TIMERS > 0)
if (!__libc_missing_posix_cpu_timers)
{
INTERNAL_SYSCALL_DECL (err);
int r = INTERNAL_SYSCALL (clock_getres, err, 2, tidclock, NULL);
if (!INTERNAL_SYSCALL_ERROR_P (r, err))
# endif
{
*clockid = tidclock;
return 0;
}
# if !(__ASSUME_POSIX_CPU_TIMERS > 0)
if (INTERNAL_SYSCALL_ERRNO (r, err) == EINVAL)
{
/* The kernel doesn't support these clocks at all. */
__libc_missing_posix_cpu_timers = 1;
}
else
return INTERNAL_SYSCALL_ERRNO (r, err);
}
# endif
#endif
#ifdef CLOCK_THREAD_CPUTIME_ID
/* We need to store the thread ID in the CLOCKID variable together
with a number identifying the clock. We reserve the low 3 bits
for the clock ID and the rest for the thread ID. This is
problematic if the thread ID is too large. But 29 bits should be
fine.
If some day more clock IDs are needed the ID part can be
enlarged. The IDs are entirely internal. */
if (pd->tid >= 1 << (8 * sizeof (*clockid) - CLOCK_IDFIELD_SIZE))
return ERANGE;
/* Store the number. */
*clockid = CLOCK_THREAD_CPUTIME_ID | (pd->tid << CLOCK_IDFIELD_SIZE);
*clockid = tidclock;
return 0;
#else
/* We don't have a timer for that. */
return ENOENT;
#endif
}

58
sysdeps/unix/sysv/linux/clock_getcpuclockid.c
View file

@ -29,60 +29,24 @@
int
clock_getcpuclockid (pid_t pid, clockid_t *clock_id)
{
#ifdef __NR_clock_getres
/* The clockid_t value is a simple computation from the PID.
But we do a clock_getres call to validate it. */
const clockid_t pidclock = MAKE_PROCESS_CPUCLOCK (pid, CPUCLOCK_SCHED);
# if !(__ASSUME_POSIX_CPU_TIMERS > 0)
extern int __libc_missing_posix_cpu_timers attribute_hidden;
if (!__libc_missing_posix_cpu_timers)
# endif
INTERNAL_SYSCALL_DECL (err);
int r = INTERNAL_SYSCALL (clock_getres, err, 2, pidclock, NULL);
if (!INTERNAL_SYSCALL_ERROR_P (r, err))
{
INTERNAL_SYSCALL_DECL (err);
int r = INTERNAL_SYSCALL (clock_getres, err, 2, pidclock, NULL);
if (!INTERNAL_SYSCALL_ERROR_P (r, err))
{
*clock_id = pidclock;
return 0;
}
if (INTERNAL_SYSCALL_ERRNO (r, err) == EINVAL)
{
# if !(__ASSUME_POSIX_CPU_TIMERS > 0)
if (pidclock == MAKE_PROCESS_CPUCLOCK (0, CPUCLOCK_SCHED)
|| INTERNAL_SYSCALL_ERROR_P (INTERNAL_SYSCALL
(clock_getres, err, 2,
MAKE_PROCESS_CPUCLOCK
(0, CPUCLOCK_SCHED), NULL),
err))
/* The kernel doesn't support these clocks at all. */
__libc_missing_posix_cpu_timers = 1;
else
# endif
/* The clock_getres system call checked the PID for us. */
return ESRCH;
}
else
return INTERNAL_SYSCALL_ERRNO (r, err);
}
#endif
/* We don't allow any process ID but our own. */
if (pid != 0 && pid != getpid ())
return EPERM;
#ifdef CLOCK_PROCESS_CPUTIME_ID
if (HAS_CPUCLOCK)
{
/* Store the number. */
*clock_id = CLOCK_PROCESS_CPUTIME_ID;
*clock_id = pidclock;
return 0;
}
#endif
/* We don't have a timer for that. */
return ENOENT;
if (INTERNAL_SYSCALL_ERRNO (r, err) == EINVAL)
{
/* The clock_getres system call checked the PID for us. */
return ESRCH;
}
else
return INTERNAL_SYSCALL_ERRNO (r, err);
}

86
sysdeps/unix/sysv/linux/clock_getres.c
View file

@ -46,89 +46,11 @@
case CLOCK_MONOTONIC_COARSE: \
SYSCALL_GETRES
#ifdef __NR_clock_getres
/* We handled the REALTIME clock here. */
# define HANDLED_REALTIME 1
# define HANDLED_CPUTIME 1
#define HANDLED_REALTIME 1
#define HANDLED_CPUTIME 1
# if __ASSUME_POSIX_CPU_TIMERS > 0
# define SYSDEP_GETRES_CPU SYSCALL_GETRES
# define SYSDEP_GETRES_CPUTIME /* Default catches them too. */
# else
extern int __libc_missing_posix_cpu_timers attribute_hidden;
static int
maybe_syscall_getres_cpu (clockid_t clock_id, struct timespec *res)
{
int e = EINVAL;
if (!__libc_missing_posix_cpu_timers)
{
INTERNAL_SYSCALL_DECL (err);
int r = INTERNAL_VSYSCALL (clock_getres, err, 2, clock_id, res);
if (!INTERNAL_SYSCALL_ERROR_P (r, err))
return 0;
e = INTERNAL_SYSCALL_ERRNO (r, err);
if (e == EINVAL)
{
/* Check whether the kernel supports CPU clocks at all.
If not, record it for the future. */
r = INTERNAL_VSYSCALL (clock_getres, err, 2,
MAKE_PROCESS_CPUCLOCK (0, CPUCLOCK_SCHED),
NULL);
if (INTERNAL_SYSCALL_ERROR_P (r, err))
__libc_missing_posix_cpu_timers = 1;
}
}
return e;
}
# define SYSDEP_GETRES_CPU \
retval = maybe_syscall_getres_cpu (clock_id, res); \
if (retval == 0) \
break; \
if (retval != EINVAL || !__libc_missing_posix_cpu_timers) \
{ \
__set_errno (retval); \
retval = -1; \
break; \
} \
retval = -1 /* Otherwise continue on to the HP_TIMING version. */;
static inline int
maybe_syscall_getres_cputime (clockid_t clock_id, struct timespec *res)
{
return maybe_syscall_getres_cpu
(clock_id == CLOCK_THREAD_CPUTIME_ID
? MAKE_THREAD_CPUCLOCK (0, CPUCLOCK_SCHED)
: MAKE_PROCESS_CPUCLOCK (0, CPUCLOCK_SCHED),
res);
}
# define SYSDEP_GETRES_CPUTIME \
case CLOCK_PROCESS_CPUTIME_ID: \
case CLOCK_THREAD_CPUTIME_ID: \
retval = maybe_syscall_getres_cputime (clock_id, res); \
if (retval == 0) \
break; \
if (retval != EINVAL || !__libc_missing_posix_cpu_timers) \
{ \
__set_errno (retval); \
retval = -1; \
break; \
} \
retval = hp_timing_getres (res); \
break;
# if !HP_TIMING_AVAIL
# define hp_timing_getres(res) (__set_errno (EINVAL), -1)
# endif
# endif
#endif
#define SYSDEP_GETRES_CPU SYSCALL_GETRES
#define SYSDEP_GETRES_CPUTIME /* Default catches them too. */
#include <sysdeps/posix/clock_getres.c>

94
sysdeps/unix/sysv/linux/clock_gettime.c
View file

@ -49,99 +49,13 @@
retval = SYSCALL_GETTIME (clock_id, tp); \
break
#ifdef __NR_clock_gettime
/* We handled the REALTIME clock here. */
# define HANDLED_REALTIME 1
# define HANDLED_CPUTIME 1
#define HANDLED_REALTIME 1
#define HANDLED_CPUTIME 1
# if __ASSUME_POSIX_CPU_TIMERS > 0
# define SYSDEP_GETTIME_CPU(clock_id, tp) \
#define SYSDEP_GETTIME_CPU(clock_id, tp) \
retval = SYSCALL_GETTIME (clock_id, tp); \
break
# define SYSDEP_GETTIME_CPUTIME /* Default catches them too. */
# else
int __libc_missing_posix_cpu_timers attribute_hidden;
static int
maybe_syscall_gettime_cpu (clockid_t clock_id, struct timespec *tp)
{
int e = EINVAL;
if (!__libc_missing_posix_cpu_timers)
{
INTERNAL_SYSCALL_DECL (err);
int r = INTERNAL_GETTIME (clock_id, tp);
if (!INTERNAL_SYSCALL_ERROR_P (r, err))
return 0;
e = INTERNAL_SYSCALL_ERRNO (r, err);
if (e == EINVAL)
{
# ifdef HAVE_CLOCK_GETRES_VSYSCALL
/* Check whether the kernel supports CPU clocks at all.
If not, record it for the future. */
r = INTERNAL_VSYSCALL (clock_getres, err, 2,
MAKE_PROCESS_CPUCLOCK (0, CPUCLOCK_SCHED),
NULL);
# else
/* Check whether the kernel supports CPU clocks at all.
If not, record it for the future. */
r = INTERNAL_SYSCALL (clock_getres, err, 2,
MAKE_PROCESS_CPUCLOCK (0, CPUCLOCK_SCHED),
NULL);
# endif
if (INTERNAL_SYSCALL_ERROR_P (r, err))
__libc_missing_posix_cpu_timers = 1;
}
}
return e;
}
# define SYSDEP_GETTIME_CPU(clock_id, tp) \
retval = maybe_syscall_gettime_cpu (clock_id, tp); \
if (retval == 0) \
break; \
if (retval != EINVAL || !__libc_missing_posix_cpu_timers) \
{ \
__set_errno (retval); \
retval = -1; \
break; \
} \
retval = -1 /* Otherwise continue on to the HP_TIMING version. */;
static inline int
maybe_syscall_gettime_cputime (clockid_t clock_id, struct timespec *tp)
{
return maybe_syscall_gettime_cpu
(clock_id == CLOCK_THREAD_CPUTIME_ID
? MAKE_THREAD_CPUCLOCK (0, CPUCLOCK_SCHED)
: MAKE_PROCESS_CPUCLOCK (0, CPUCLOCK_SCHED),
tp);
}
# define SYSDEP_GETTIME_CPUTIME \
case CLOCK_PROCESS_CPUTIME_ID: \
case CLOCK_THREAD_CPUTIME_ID: \
retval = maybe_syscall_gettime_cputime (clock_id, tp); \
if (retval == 0) \
break; \
if (retval != EINVAL || !__libc_missing_posix_cpu_timers) \
{ \
__set_errno (retval); \
retval = -1; \
break; \
} \
retval = hp_timing_gettime (clock_id, tp); \
break
# if !HP_TIMING_AVAIL
# define hp_timing_gettime(clock_id, tp) (__set_errno (EINVAL), -1)
# endif
# endif
#endif
#define SYSDEP_GETTIME_CPUTIME /* Default catches them too. */
#include <sysdeps/unix/clock_gettime.c>

54
sysdeps/unix/sysv/linux/clock_settime.c
View file

@ -31,38 +31,6 @@
# include <bits/libc-vdso.h>
#endif
#if __ASSUME_POSIX_CPU_TIMERS <= 0 && defined __NR_clock_settime
extern int __libc_missing_posix_cpu_timers attribute_hidden;
static int
maybe_syscall_settime_cpu (clockid_t clock_id, const struct timespec *tp)
{
int e = EINVAL;
if (!__libc_missing_posix_cpu_timers)
{
INTERNAL_SYSCALL_DECL (err);
int r = INTERNAL_SYSCALL (clock_settime, err, 2, clock_id, tp);
if (!INTERNAL_SYSCALL_ERROR_P (r, err))
return 0;
e = INTERNAL_SYSCALL_ERRNO (r, err);
if (e == EINVAL)
{
/* Check whether the kernel supports CPU clocks at all.
If not, record it for the future. */
r = INTERNAL_VSYSCALL (clock_getres, err, 2,
MAKE_PROCESS_CPUCLOCK (0, CPUCLOCK_SCHED),
NULL);
if (INTERNAL_SYSCALL_ERROR_P (r, err))
__libc_missing_posix_cpu_timers = 1;
}
}
return e;
}
#endif
/* The REALTIME clock is definitely supported in the kernel. */
#define SYSDEP_SETTIME \
@ -70,27 +38,11 @@ maybe_syscall_settime_cpu (clockid_t clock_id, const struct timespec *tp)
retval = INLINE_SYSCALL (clock_settime, 2, clock_id, tp); \
break
#ifdef __NR_clock_settime
/* We handled the REALTIME clock here. */
# define HANDLED_REALTIME 1
#endif
#define HANDLED_REALTIME 1
#if __ASSUME_POSIX_CPU_TIMERS > 0
# define HANDLED_CPUTIME 1
# define SYSDEP_SETTIME_CPU \
#define HANDLED_CPUTIME 1
#define SYSDEP_SETTIME_CPU \
retval = INLINE_SYSCALL (clock_settime, 2, clock_id, tp)
#elif defined __NR_clock_settime
# define SYSDEP_SETTIME_CPU \
retval = maybe_syscall_settime_cpu (clock_id, tp); \
if (retval == 0) \
break; \
if (retval != EINVAL || !__libc_missing_posix_cpu_timers) \
{ \
__set_errno (retval); \
retval = -1; \
break; \
} \
do { } while (0)
#endif
#include <sysdeps/unix/clock_settime.c>

3
sysdeps/unix/sysv/linux/kernel-features.h
View file

@ -57,9 +57,6 @@
MIPS n32). */
#define __ASSUME_GETDENTS64_SYSCALL 1
/* Beginning with 2.6.12 the clock and timer supports CPU clocks. */
#define __ASSUME_POSIX_CPU_TIMERS 1
/* The statfs64 syscalls are available in 2.5.74 (but not for alpha). */
#define __ASSUME_STATFS64 1