niansa-misc/glibc
1
0
Fork 0
mirror of git://sourceware.org/git/glibc.git synced 2025-03-06 20:58:33 +01:00
Code Issues Projects Releases Packages 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> 2012-08-29 H.J. Lu <hongjiu.lu@intel.com>
[BZ #14476] [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> 2012-08-31 Joseph Myers <joseph@codesourcery.com>
[BZ #14532] [BZ #14532]

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

@ -24,10 +24,6 @@
#include <kernel-posix-cpu-timers.h> #include <kernel-posix-cpu-timers.h>
#if !(__ASSUME_POSIX_CPU_TIMERS > 0)
int __libc_missing_posix_cpu_timers attribute_hidden;
#endif
int int
pthread_getcpuclockid (threadid, clockid) pthread_getcpuclockid (threadid, clockid)
pthread_t threadid; pthread_t threadid;
@ -40,55 +36,10 @@ pthread_getcpuclockid (threadid, clockid)
/* Not a valid thread handle. */ /* Not a valid thread handle. */
return ESRCH; return ESRCH;
#ifdef __NR_clock_getres /* The clockid_t value is a simple computation from the TID. */
/* 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. */
const clockid_t tidclock = MAKE_THREAD_CPUCLOCK (pd->tid, CPUCLOCK_SCHED); 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; *clockid = tidclock;
return 0; 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);
return 0;
#else
/* We don't have a timer for that. */
return ENOENT;
#endif
}

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

@ -29,17 +29,11 @@
int int
clock_getcpuclockid (pid_t pid, clockid_t *clock_id) clock_getcpuclockid (pid_t pid, clockid_t *clock_id)
{ {
#ifdef __NR_clock_getres
/* The clockid_t value is a simple computation from the PID. /* The clockid_t value is a simple computation from the PID.
But we do a clock_getres call to validate it. */ But we do a clock_getres call to validate it. */
const clockid_t pidclock = MAKE_PROCESS_CPUCLOCK (pid, CPUCLOCK_SCHED); 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); INTERNAL_SYSCALL_DECL (err);
int r = INTERNAL_SYSCALL (clock_getres, err, 2, pidclock, NULL); int r = INTERNAL_SYSCALL (clock_getres, err, 2, pidclock, NULL);
if (!INTERNAL_SYSCALL_ERROR_P (r, err)) if (!INTERNAL_SYSCALL_ERROR_P (r, err))
@ -50,39 +44,9 @@ clock_getcpuclockid (pid_t pid, clockid_t *clock_id)
if (INTERNAL_SYSCALL_ERRNO (r, err) == EINVAL) 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. */ /* The clock_getres system call checked the PID for us. */
return ESRCH; return ESRCH;
} }
else else
return INTERNAL_SYSCALL_ERRNO (r, err); 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;
return 0;
}
#endif
/* We don't have a timer for that. */
return ENOENT;
}

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

@ -46,89 +46,11 @@
case CLOCK_MONOTONIC_COARSE: \ case CLOCK_MONOTONIC_COARSE: \
SYSCALL_GETRES SYSCALL_GETRES
#ifdef __NR_clock_getres
/* We handled the REALTIME clock here. */ /* We handled the REALTIME clock here. */
#define HANDLED_REALTIME 1 #define HANDLED_REALTIME 1
#define HANDLED_CPUTIME 1 #define HANDLED_CPUTIME 1
# if __ASSUME_POSIX_CPU_TIMERS > 0
#define SYSDEP_GETRES_CPU SYSCALL_GETRES #define SYSDEP_GETRES_CPU SYSCALL_GETRES
#define SYSDEP_GETRES_CPUTIME /* Default catches them too. */ #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
#include <sysdeps/posix/clock_getres.c> #include <sysdeps/posix/clock_getres.c>

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

@ -49,99 +49,13 @@
retval = SYSCALL_GETTIME (clock_id, tp); \ retval = SYSCALL_GETTIME (clock_id, tp); \
break break
#ifdef __NR_clock_gettime
/* We handled the REALTIME clock here. */ /* We handled the REALTIME clock here. */
#define HANDLED_REALTIME 1 #define HANDLED_REALTIME 1
#define HANDLED_CPUTIME 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); \ retval = SYSCALL_GETTIME (clock_id, tp); \
break break
#define SYSDEP_GETTIME_CPUTIME /* Default catches them too. */ #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
#include <sysdeps/unix/clock_gettime.c> #include <sysdeps/unix/clock_gettime.c>

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

@ -31,38 +31,6 @@
# include <bits/libc-vdso.h> # include <bits/libc-vdso.h>
#endif #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. */ /* The REALTIME clock is definitely supported in the kernel. */
#define SYSDEP_SETTIME \ #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); \ retval = INLINE_SYSCALL (clock_settime, 2, clock_id, tp); \
break break
#ifdef __NR_clock_settime
/* We handled the REALTIME clock here. */ /* We handled the REALTIME clock here. */
#define HANDLED_REALTIME 1 #define HANDLED_REALTIME 1
#endif
#if __ASSUME_POSIX_CPU_TIMERS > 0
#define HANDLED_CPUTIME 1 #define HANDLED_CPUTIME 1
#define SYSDEP_SETTIME_CPU \ #define SYSDEP_SETTIME_CPU \
retval = INLINE_SYSCALL (clock_settime, 2, clock_id, tp) 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> #include <sysdeps/unix/clock_settime.c>

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

@ -57,9 +57,6 @@
MIPS n32). */ MIPS n32). */
#define __ASSUME_GETDENTS64_SYSCALL 1 #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). */ /* The statfs64 syscalls are available in 2.5.74 (but not for alpha). */
#define __ASSUME_STATFS64 1 #define __ASSUME_STATFS64 1