mirror of
https://sourceware.org/git/glibc.git
synced 2024-11-10 07:10:06 +00:00
2005-04-27 Roland McGrath <roland@redhat.com>
* sysdeps/unix/sysv/linux/kernel-posix-cpu-timers.h: New file. * sysdeps/unix/sysv/linux/clock_getcpuclockid.c: New file. * sysdeps/unix/sysv/linux/ia64/clock_getcpuclockid.c (HAS_CPUCLOCK): New macro. (clock_getcpuclockid): Function removed. #include the new linux file to define it instead. * sysdeps/unix/clock_gettime.c [HP_TIMING_AVAIL] (hp_timing_gettime): New function, broken out of ... (clock_gettime) [HP_TIMING_AVAIL]: ... here. Call it. (realtime_gettime): New function, broken out of ... (clock_gettime) [! HANDLED_REALTIME]: ... here. Call it. (clock_gettime) [SYSDEP_GETTIME_CPU]: Use new macro in default case. * sysdeps/unix/sysv/linux/clock_gettime.c (SYSCALL_GETTIME): New macro. (SYSDEP_GETTIME_CPUTIME): New macro. (SYSDEP_GETTIME): Use both. [! __ASSUME_POSIX_TIMERS] (maybe_syscall_gettime): New function, broken out of ... (SYSDEP_GETTIME): ... here. Use it. [__NR_clock_gettime] (HANDLED_CPUTIME): Define it. (SYSDEP_GETTIME_CPUTIME): New macro. Handle CPU timers by trying kernel support and falling back to hp-timing code. * sysdeps/posix/clock_getres.c [HP_TIMING_AVAIL] (hp_timing_getres): New function, broken out of ... (clock_getres) [HP_TIMING_AVAIL]: ... here. Call it. (realtime_getres): New function, broken out of ... (clock_getres) [! HANDLED_REALTIME]: ... here. Call it. (clock_getres) [SYSDEP_GETRES_CPU]: Use new macro in default case. * sysdeps/unix/sysv/linux/clock_getres.c (SYSCALL_GETRES): New macro. (SYSDEP_GETRES_CPUTIME): New macro. (SYSDEP_GETRES): Use both. [! __ASSUME_POSIX_TIMERS] (maybe_syscall_getres): New function, broken out of ... (SYSDEP_GETRES): ... here. Use it. [__NR_clock_getres] (HANDLED_CPUTIME): Define it. (SYSDEP_GETRES_CPUTIME): New macro. Handle CPU timers by trying kernel support and falling back to hp-timing code. * sysdeps/unix/sysv/linux/clock_nanosleep.c: Handle CLOCK_PROCESS_CPUTIME_ID and CLOCK_PROCESS_THREAD_ID specially, translating to the kernel clockid_t for our own process/thread clock.
This commit is contained in:
parent
0f888d8ec6
commit
2f4f3bd4a9
@ -1,4 +1,5 @@
|
||||
/* Copyright (C) 1999, 2000, 2001, 2003 Free Software Foundation, Inc.
|
||||
/* clock_getres -- Get the resolution of a POSIX clockid_t.
|
||||
Copyright (C) 1999, 2000, 2001, 2003, 2004 Free Software Foundation, Inc.
|
||||
This file is part of the GNU C Library.
|
||||
|
||||
The GNU C Library is free software; you can redistribute it and/or
|
||||
@ -24,11 +25,55 @@
|
||||
#include <libc-internal.h>
|
||||
|
||||
|
||||
#if HP_TIMING_AVAIL && !defined HANDLED_CPUTIME
|
||||
/* Clock frequency of the processor. */
|
||||
static long int nsec;
|
||||
#if HP_TIMING_AVAIL
|
||||
static long int nsec; /* Clock frequency of the processor. */
|
||||
|
||||
static inline int
|
||||
hp_timing_getres (struct timespec *res)
|
||||
{
|
||||
if (__builtin_expect (nsec == 0, 0))
|
||||
{
|
||||
hp_timing_t freq;
|
||||
|
||||
/* This can only happen if we haven't initialized the `nsec'
|
||||
variable yet. Do this now. We don't have to protect this
|
||||
code against multiple execution since all of them should
|
||||
lead to the same result. */
|
||||
freq = __get_clockfreq ();
|
||||
if (__builtin_expect (freq == 0, 0))
|
||||
/* Something went wrong. */
|
||||
return -1;
|
||||
|
||||
nsec = MAX (UINT64_C (1000000000) / freq, 1);
|
||||
}
|
||||
|
||||
/* Fill in the values.
|
||||
The seconds are always zero (unless we have a 1Hz machine). */
|
||||
res->tv_sec = 0;
|
||||
res->tv_nsec = nsec;
|
||||
|
||||
return 0;
|
||||
}
|
||||
#endif
|
||||
|
||||
static inline int
|
||||
realtime_getres (struct timespec *res)
|
||||
{
|
||||
long int clk_tck = sysconf (_SC_CLK_TCK);
|
||||
|
||||
if (__builtin_expect (clk_tck != -1, 1))
|
||||
{
|
||||
/* This implementation assumes that the realtime clock has a
|
||||
resolution higher than 1 second. This is the case for any
|
||||
reasonable implementation. */
|
||||
res->tv_sec = 0;
|
||||
res->tv_nsec = 1000000000 / clk_tck;
|
||||
return 0;
|
||||
}
|
||||
|
||||
return -1;
|
||||
}
|
||||
|
||||
|
||||
/* Get resolution of clock. */
|
||||
int
|
||||
@ -38,69 +83,33 @@ clock_getres (clockid_t clock_id, struct timespec *res)
|
||||
|
||||
switch (clock_id)
|
||||
{
|
||||
#define HANDLE_REALTIME \
|
||||
do { \
|
||||
long int clk_tck = sysconf (_SC_CLK_TCK); \
|
||||
\
|
||||
if (__builtin_expect (clk_tck != -1, 1)) \
|
||||
{ \
|
||||
/* This implementation assumes that the realtime clock has a \
|
||||
resolution higher than 1 second. This is the case for any \
|
||||
reasonable implementation. */ \
|
||||
res->tv_sec = 0; \
|
||||
res->tv_nsec = 1000000000 / clk_tck; \
|
||||
\
|
||||
retval = 0; \
|
||||
} \
|
||||
} while (0)
|
||||
|
||||
#ifdef SYSDEP_GETRES
|
||||
SYSDEP_GETRES;
|
||||
#endif
|
||||
|
||||
#ifndef HANDLED_REALTIME
|
||||
case CLOCK_REALTIME:
|
||||
HANDLE_REALTIME;
|
||||
retval = realtime_getres (res);
|
||||
break;
|
||||
#endif /* handled REALTIME */
|
||||
|
||||
default:
|
||||
#ifdef SYSDEP_GETRES_CPU
|
||||
SYSDEP_GETRES_CPU;
|
||||
#endif
|
||||
#if HP_TIMING_AVAIL
|
||||
if ((clock_id & ((1 << CLOCK_IDFIELD_SIZE) - 1))
|
||||
!= CLOCK_THREAD_CPUTIME_ID)
|
||||
== CLOCK_THREAD_CPUTIME_ID)
|
||||
retval = hp_timing_getres (res);
|
||||
else
|
||||
#endif
|
||||
{
|
||||
__set_errno (EINVAL);
|
||||
break;
|
||||
}
|
||||
__set_errno (EINVAL);
|
||||
break;
|
||||
|
||||
#if HP_TIMING_AVAIL && !defined HANDLED_CPUTIME
|
||||
/* FALLTHROUGH. */
|
||||
case CLOCK_PROCESS_CPUTIME_ID:
|
||||
{
|
||||
if (__builtin_expect (nsec == 0, 0))
|
||||
{
|
||||
hp_timing_t freq;
|
||||
|
||||
/* This can only happen if we haven't initialized the `freq'
|
||||
variable yet. Do this now. We don't have to protect this
|
||||
code against multiple execution since all of them should
|
||||
lead to the same result. */
|
||||
freq = __get_clockfreq ();
|
||||
if (__builtin_expect (freq == 0, 0))
|
||||
/* Something went wrong. */
|
||||
break;
|
||||
|
||||
nsec = MAX (UINT64_C (1000000000) / freq, 1);
|
||||
}
|
||||
|
||||
/* File in the values. The seconds are always zero (unless we
|
||||
have a 1Hz machine). */
|
||||
res->tv_sec = 0;
|
||||
res->tv_nsec = nsec;
|
||||
|
||||
retval = 0;
|
||||
}
|
||||
case CLOCK_THREAD_CPUTIME_ID:
|
||||
retval = hp_timing_getres (res);
|
||||
break;
|
||||
#endif
|
||||
}
|
||||
|
@ -1,4 +1,5 @@
|
||||
/* Copyright (C) 1999, 2000, 2001, 2002, 2003 Free Software Foundation, Inc.
|
||||
/* clock_gettime -- Get the current time from a POSIX clockid_t. Unix version.
|
||||
Copyright (C) 1999,2000,2001,2002,2003,2004 Free Software Foundation, Inc.
|
||||
This file is part of the GNU C Library.
|
||||
|
||||
The GNU C Library is free software; you can redistribute it and/or
|
||||
@ -35,9 +36,58 @@ static hp_timing_t freq;
|
||||
extern int __pthread_clock_gettime (clockid_t clock_id, hp_timing_t freq,
|
||||
struct timespec *tp)
|
||||
__attribute__ ((__weak__));
|
||||
|
||||
static int
|
||||
hp_timing_gettime (clockid_t clock_id, struct timespec *tp)
|
||||
{
|
||||
hp_timing_t tsc;
|
||||
|
||||
if (__builtin_expect (freq == 0, 0))
|
||||
{
|
||||
/* This can only happen if we haven't initialized the `freq'
|
||||
variable yet. Do this now. We don't have to protect this
|
||||
code against multiple execution since all of them should
|
||||
lead to the same result. */
|
||||
freq = __get_clockfreq ();
|
||||
if (__builtin_expect (freq == 0, 0))
|
||||
/* Something went wrong. */
|
||||
return -1;
|
||||
}
|
||||
|
||||
if (clock_id != CLOCK_PROCESS_CPUTIME_ID
|
||||
&& __pthread_clock_gettime != NULL)
|
||||
return __pthread_clock_gettime (clock_id, freq, tp);
|
||||
|
||||
/* Get the current counter. */
|
||||
HP_TIMING_NOW (tsc);
|
||||
|
||||
/* Compute the offset since the start time of the process. */
|
||||
tsc -= GL(dl_cpuclock_offset);
|
||||
|
||||
/* Compute the seconds. */
|
||||
tp->tv_sec = tsc / freq;
|
||||
|
||||
/* And the nanoseconds. This computation should be stable until
|
||||
we get machines with about 16GHz frequency. */
|
||||
tp->tv_nsec = ((tsc % freq) * UINT64_C (1000000000)) / freq;
|
||||
|
||||
return 0;
|
||||
}
|
||||
#endif
|
||||
|
||||
|
||||
static inline int
|
||||
realtime_gettime (struct timespec *tp)
|
||||
{
|
||||
struct timeval tv;
|
||||
int retval = gettimeofday (&tv, NULL);
|
||||
if (retval == 0)
|
||||
/* Convert into `timespec'. */
|
||||
TIMEVAL_TO_TIMESPEC (&tv, tp);
|
||||
return retval;
|
||||
}
|
||||
|
||||
|
||||
/* Get current value of CLOCK and store it in TP. */
|
||||
int
|
||||
clock_gettime (clockid_t clock_id, struct timespec *tp)
|
||||
@ -46,15 +96,6 @@ clock_gettime (clockid_t clock_id, struct timespec *tp)
|
||||
|
||||
switch (clock_id)
|
||||
{
|
||||
#define HANDLE_REALTIME \
|
||||
do { \
|
||||
struct timeval tv; \
|
||||
retval = gettimeofday (&tv, NULL); \
|
||||
if (retval == 0) \
|
||||
/* Convert into `timespec'. */ \
|
||||
TIMEVAL_TO_TIMESPEC (&tv, tp); \
|
||||
} while (0)
|
||||
|
||||
#ifdef SYSDEP_GETTIME
|
||||
SYSDEP_GETTIME;
|
||||
#endif
|
||||
@ -66,56 +107,22 @@ clock_gettime (clockid_t clock_id, struct timespec *tp)
|
||||
#endif
|
||||
|
||||
default:
|
||||
#ifdef SYSDEP_GETTIME_CPU
|
||||
SYSDEP_GETTIME_CPU;
|
||||
#endif
|
||||
#if HP_TIMING_AVAIL
|
||||
if ((clock_id & ((1 << CLOCK_IDFIELD_SIZE) - 1))
|
||||
!= CLOCK_THREAD_CPUTIME_ID)
|
||||
== CLOCK_THREAD_CPUTIME_ID)
|
||||
retval = hp_timing_gettime (clock_id, tp);
|
||||
else
|
||||
#endif
|
||||
{
|
||||
__set_errno (EINVAL);
|
||||
break;
|
||||
}
|
||||
__set_errno (EINVAL);
|
||||
break;
|
||||
|
||||
#if HP_TIMING_AVAIL
|
||||
/* FALLTHROUGH. */
|
||||
#if HP_TIMING_AVAIL && !defined HANDLED_CPUTIME
|
||||
case CLOCK_PROCESS_CPUTIME_ID:
|
||||
{
|
||||
hp_timing_t tsc;
|
||||
|
||||
if (__builtin_expect (freq == 0, 0))
|
||||
{
|
||||
/* This can only happen if we haven't initialized the `freq'
|
||||
variable yet. Do this now. We don't have to protect this
|
||||
code against multiple execution since all of them should
|
||||
lead to the same result. */
|
||||
freq = __get_clockfreq ();
|
||||
if (__builtin_expect (freq == 0, 0))
|
||||
/* Something went wrong. */
|
||||
break;
|
||||
}
|
||||
|
||||
if (clock_id != CLOCK_PROCESS_CPUTIME_ID
|
||||
&& __pthread_clock_gettime != NULL)
|
||||
{
|
||||
retval = __pthread_clock_gettime (clock_id, freq, tp);
|
||||
break;
|
||||
}
|
||||
|
||||
/* Get the current counter. */
|
||||
HP_TIMING_NOW (tsc);
|
||||
|
||||
/* Compute the offset since the start time of the process. */
|
||||
tsc -= GL(dl_cpuclock_offset);
|
||||
|
||||
/* Compute the seconds. */
|
||||
tp->tv_sec = tsc / freq;
|
||||
|
||||
/* And the nanoseconds. This computation should be stable until
|
||||
we get machines with about 16GHz frequency. */
|
||||
tp->tv_nsec = ((tsc % freq) * UINT64_C (1000000000)) / freq;
|
||||
|
||||
retval = 0;
|
||||
}
|
||||
break;
|
||||
retval = hp_timing_gettime (clock_id, tp);
|
||||
break;
|
||||
#endif
|
||||
}
|
||||
|
||||
|
103
sysdeps/unix/sysv/linux/clock_getcpuclockid.c
Normal file
103
sysdeps/unix/sysv/linux/clock_getcpuclockid.c
Normal file
@ -0,0 +1,103 @@
|
||||
/* clock_getcpuclockid -- Get a clockid_t for process CPU time. Linux version.
|
||||
Copyright (C) 2004 Free Software Foundation, Inc.
|
||||
This file is part of the GNU C Library.
|
||||
|
||||
The GNU C Library is free software; you can redistribute it and/or
|
||||
modify it under the terms of the GNU Lesser General Public
|
||||
License as published by the Free Software Foundation; either
|
||||
version 2.1 of the License, or (at your option) any later version.
|
||||
|
||||
The GNU C Library is distributed in the hope that it will be useful,
|
||||
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
||||
Lesser General Public License for more details.
|
||||
|
||||
You should have received a copy of the GNU Lesser General Public
|
||||
License along with the GNU C Library; if not, write to the Free
|
||||
Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
|
||||
02111-1307 USA. */
|
||||
|
||||
#include <errno.h>
|
||||
#include <time.h>
|
||||
#include <unistd.h>
|
||||
#include "kernel-features.h"
|
||||
#include "kernel-posix-cpu-timers.h"
|
||||
|
||||
#ifndef HAS_CPUCLOCK
|
||||
# define HAS_CPUCLOCK 1
|
||||
#endif
|
||||
|
||||
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 !(__ASSUME_POSIX_TIMERS > 0)
|
||||
extern int __libc_missing_posix_timers attribute_hidden;
|
||||
if (__libc_missing_posix_timers && !__libc_missing_posix_cpu_timers)
|
||||
__libc_missing_posix_cpu_timers = 1;
|
||||
# endif
|
||||
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))
|
||||
{
|
||||
*clock_id = pidclock;
|
||||
return 0;
|
||||
}
|
||||
|
||||
# if !(__ASSUME_POSIX_TIMERS > 0)
|
||||
if (INTERNAL_SYSCALL_ERRNO (r, err) == ENOSYS)
|
||||
{
|
||||
/* The kernel doesn't support these calls at all. */
|
||||
__libc_missing_posix_timers = 1;
|
||||
__libc_missing_posix_cpu_timers = 1;
|
||||
}
|
||||
else
|
||||
# endif
|
||||
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;
|
||||
|
||||
return 0;
|
||||
}
|
||||
#else
|
||||
/* We don't have a timer for that. */
|
||||
return ENOENT;
|
||||
#endif
|
||||
}
|
@ -1,4 +1,5 @@
|
||||
/* Copyright (C) 2003 Free Software Foundation, Inc.
|
||||
/* clock_getres -- Get the resolution of a POSIX clockid_t. Linux version.
|
||||
Copyright (C) 2003, 2004 Free Software Foundation, Inc.
|
||||
This file is part of the GNU C Library.
|
||||
|
||||
The GNU C Library is free software; you can redistribute it and/or
|
||||
@ -17,60 +18,168 @@
|
||||
02111-1307 USA. */
|
||||
|
||||
#include <sysdep.h>
|
||||
#include <errno.h>
|
||||
#include "kernel-posix-cpu-timers.h"
|
||||
|
||||
#include "kernel-features.h"
|
||||
|
||||
|
||||
#define SYSCALL_GETRES \
|
||||
retval = INLINE_SYSCALL (clock_getres, 2, clock_id, res); \
|
||||
break
|
||||
|
||||
#ifdef __ASSUME_POSIX_TIMERS
|
||||
|
||||
/* This means the REALTIME and MONOTONIC clock are definitely
|
||||
supported in the kernel. */
|
||||
# define SYSDEP_GETRES \
|
||||
# define SYSDEP_GETRES \
|
||||
SYSDEP_GETRES_CPUTIME \
|
||||
case CLOCK_REALTIME: \
|
||||
case CLOCK_MONOTONIC: \
|
||||
retval = INLINE_SYSCALL (clock_getres, 2, clock_id, res); \
|
||||
break
|
||||
SYSCALL_GETRES
|
||||
|
||||
# define __libc_missing_posix_timers 0
|
||||
#elif defined __NR_clock_getres
|
||||
/* Is the syscall known to exist? */
|
||||
extern int __libc_missing_posix_timers attribute_hidden;
|
||||
|
||||
static inline int
|
||||
maybe_syscall_getres (clockid_t clock_id, struct timespec *res)
|
||||
{
|
||||
int e = EINVAL;
|
||||
|
||||
if (!__libc_missing_posix_timers)
|
||||
{
|
||||
INTERNAL_SYSCALL_DECL (err);
|
||||
int r = INTERNAL_SYSCALL (clock_getres, err, 2, clock_id, res);
|
||||
if (!INTERNAL_SYSCALL_ERROR_P (r, err))
|
||||
return 0;
|
||||
|
||||
e = INTERNAL_SYSCALL_ERRNO (r, err);
|
||||
if (e == ENOSYS)
|
||||
{
|
||||
__libc_missing_posix_timers = 1;
|
||||
e = EINVAL;
|
||||
}
|
||||
}
|
||||
|
||||
return e;
|
||||
}
|
||||
|
||||
/* The REALTIME and MONOTONIC clock might be available. Try the
|
||||
syscall first. */
|
||||
# define SYSDEP_GETRES \
|
||||
# define SYSDEP_GETRES \
|
||||
SYSDEP_GETRES_CPUTIME \
|
||||
case CLOCK_REALTIME: \
|
||||
case CLOCK_MONOTONIC: \
|
||||
{ \
|
||||
int e = EINVAL; \
|
||||
\
|
||||
if (!__libc_missing_posix_timers) \
|
||||
{ \
|
||||
INTERNAL_SYSCALL_DECL (err); \
|
||||
int r = INTERNAL_SYSCALL (clock_getres, err, 2, clock_id, res); \
|
||||
if (!INTERNAL_SYSCALL_ERROR_P (r, err)) \
|
||||
{ \
|
||||
retval = 0; \
|
||||
break; \
|
||||
} \
|
||||
\
|
||||
e = INTERNAL_SYSCALL_ERRNO (r, err); \
|
||||
if (e == ENOSYS) \
|
||||
{ \
|
||||
__libc_missing_posix_timers = 1; \
|
||||
e = EINVAL; \
|
||||
} \
|
||||
} \
|
||||
\
|
||||
/* Fallback code. */ \
|
||||
if (e == EINVAL && clock_id == CLOCK_REALTIME) \
|
||||
HANDLE_REALTIME; \
|
||||
else \
|
||||
__set_errno (e); \
|
||||
} \
|
||||
break
|
||||
retval = maybe_syscall_getres (clock_id, res); \
|
||||
if (retval == 0) \
|
||||
break; \
|
||||
/* Fallback code. */ \
|
||||
if (retval == EINVAL && clock_id == CLOCK_REALTIME) \
|
||||
retval = realtime_getres (res); \
|
||||
else \
|
||||
{ \
|
||||
__set_errno (retval); \
|
||||
retval = -1; \
|
||||
} \
|
||||
break;
|
||||
#endif
|
||||
|
||||
#ifdef __NR_clock_getres
|
||||
/* We handled the REALTIME clock here. */
|
||||
# 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_SYSCALL (clock_getres, err, 2, clock_id, res);
|
||||
if (!INTERNAL_SYSCALL_ERROR_P (r, err))
|
||||
return 0;
|
||||
|
||||
e = INTERNAL_SYSCALL_ERRNO (r, err);
|
||||
# ifndef __ASSUME_POSIX_TIMERS
|
||||
if (e == ENOSYS)
|
||||
{
|
||||
__libc_missing_posix_timers = 1;
|
||||
__libc_missing_posix_cpu_timers = 1;
|
||||
e = EINVAL;
|
||||
}
|
||||
else
|
||||
# endif
|
||||
{
|
||||
if (e == EINVAL)
|
||||
{
|
||||
/* 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);
|
||||
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>
|
||||
|
@ -1,4 +1,5 @@
|
||||
/* Copyright (C) 2003 Free Software Foundation, Inc.
|
||||
/* clock_gettime -- Get current time from a POSIX clockid_t. Linux version.
|
||||
Copyright (C) 2003, 2004 Free Software Foundation, Inc.
|
||||
This file is part of the GNU C Library.
|
||||
|
||||
The GNU C Library is free software; you can redistribute it and/or
|
||||
@ -17,60 +18,167 @@
|
||||
02111-1307 USA. */
|
||||
|
||||
#include <sysdep.h>
|
||||
|
||||
#include <errno.h>
|
||||
#include "kernel-posix-cpu-timers.h"
|
||||
#include "kernel-features.h"
|
||||
|
||||
|
||||
#define SYSCALL_GETTIME \
|
||||
retval = INLINE_SYSCALL (clock_gettime, 2, clock_id, tp); \
|
||||
break
|
||||
|
||||
#ifdef __ASSUME_POSIX_TIMERS
|
||||
|
||||
/* This means the REALTIME and MONOTONIC clock are definitely
|
||||
supported in the kernel. */
|
||||
# define SYSDEP_GETTIME \
|
||||
# define SYSDEP_GETTIME \
|
||||
SYSDEP_GETTIME_CPUTIME \
|
||||
case CLOCK_REALTIME: \
|
||||
case CLOCK_MONOTONIC: \
|
||||
retval = INLINE_SYSCALL (clock_gettime, 2, clock_id, tp); \
|
||||
break
|
||||
SYSCALL_GETTIME
|
||||
|
||||
# define __libc_missing_posix_timers 0
|
||||
#elif defined __NR_clock_gettime
|
||||
/* Is the syscall known to exist? */
|
||||
int __libc_missing_posix_timers attribute_hidden;
|
||||
|
||||
static inline int
|
||||
maybe_syscall_gettime (clockid_t clock_id, struct timespec *tp)
|
||||
{
|
||||
int e = EINVAL;
|
||||
|
||||
if (!__libc_missing_posix_timers)
|
||||
{
|
||||
INTERNAL_SYSCALL_DECL (err);
|
||||
int r = INTERNAL_SYSCALL (clock_gettime, err, 2, clock_id, tp);
|
||||
if (!INTERNAL_SYSCALL_ERROR_P (r, err))
|
||||
return 0;
|
||||
|
||||
e = INTERNAL_SYSCALL_ERRNO (r, err);
|
||||
if (e == ENOSYS)
|
||||
{
|
||||
__libc_missing_posix_timers = 1;
|
||||
e = EINVAL;
|
||||
}
|
||||
}
|
||||
|
||||
return e;
|
||||
}
|
||||
|
||||
/* The REALTIME and MONOTONIC clock might be available. Try the
|
||||
syscall first. */
|
||||
# define SYSDEP_GETTIME \
|
||||
# define SYSDEP_GETTIME \
|
||||
SYSDEP_GETTIME_CPUTIME \
|
||||
case CLOCK_REALTIME: \
|
||||
case CLOCK_MONOTONIC: \
|
||||
{ \
|
||||
int e = EINVAL; \
|
||||
\
|
||||
if (!__libc_missing_posix_timers) \
|
||||
{ \
|
||||
INTERNAL_SYSCALL_DECL (err); \
|
||||
int r = INTERNAL_SYSCALL (clock_gettime, err, 2, clock_id, tp); \
|
||||
if (!INTERNAL_SYSCALL_ERROR_P (r, err)) \
|
||||
{ \
|
||||
retval = 0; \
|
||||
break; \
|
||||
} \
|
||||
\
|
||||
e = INTERNAL_SYSCALL_ERRNO (r, err); \
|
||||
if (e == ENOSYS) \
|
||||
{ \
|
||||
__libc_missing_posix_timers = 1; \
|
||||
e = EINVAL; \
|
||||
} \
|
||||
} \
|
||||
\
|
||||
/* Fallback code. */ \
|
||||
if (e == EINVAL && clock_id == CLOCK_REALTIME) \
|
||||
HANDLE_REALTIME; \
|
||||
else \
|
||||
__set_errno (e); \
|
||||
} \
|
||||
break
|
||||
retval = maybe_syscall_gettime (clock_id, tp); \
|
||||
if (retval == 0) \
|
||||
break; \
|
||||
/* Fallback code. */ \
|
||||
if (retval == EINVAL && clock_id == CLOCK_REALTIME) \
|
||||
retval = realtime_gettime (tp); \
|
||||
else \
|
||||
{ \
|
||||
__set_errno (retval); \
|
||||
retval = -1; \
|
||||
} \
|
||||
break;
|
||||
#endif
|
||||
|
||||
#ifdef __NR_clock_gettime
|
||||
/* We handled the REALTIME clock here. */
|
||||
# define HANDLED_REALTIME 1
|
||||
# define HANDLED_CPUTIME 1
|
||||
|
||||
# if __ASSUME_POSIX_CPU_TIMERS > 0
|
||||
|
||||
# define SYSDEP_GETTIME_CPU SYSCALL_GETTIME
|
||||
# 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_SYSCALL (clock_gettime, err, 2, clock_id, tp);
|
||||
if (!INTERNAL_SYSCALL_ERROR_P (r, err))
|
||||
return 0;
|
||||
|
||||
e = INTERNAL_SYSCALL_ERRNO (r, err);
|
||||
# ifndef __ASSUME_POSIX_TIMERS
|
||||
if (e == ENOSYS)
|
||||
{
|
||||
__libc_missing_posix_timers = 1;
|
||||
__libc_missing_posix_cpu_timers = 1;
|
||||
e = EINVAL;
|
||||
}
|
||||
else
|
||||
# endif
|
||||
{
|
||||
if (e == EINVAL)
|
||||
{
|
||||
/* 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);
|
||||
if (INTERNAL_SYSCALL_ERROR_P (r, err))
|
||||
__libc_missing_posix_cpu_timers = 1;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
return e;
|
||||
}
|
||||
|
||||
# define SYSDEP_GETTIME_CPU \
|
||||
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>
|
||||
|
@ -1,4 +1,4 @@
|
||||
/* Copyright (C) 2003 Free Software Foundation, Inc.
|
||||
/* Copyright (C) 2003, 2004, 2005 Free Software Foundation, Inc.
|
||||
This file is part of the GNU C Library.
|
||||
|
||||
The GNU C Library is free software; you can redistribute it and/or
|
||||
@ -17,9 +17,11 @@
|
||||
02111-1307 USA. */
|
||||
|
||||
#include <time.h>
|
||||
#include <errno.h>
|
||||
|
||||
#include <sysdep-cancel.h>
|
||||
#include "kernel-features.h"
|
||||
#include "kernel-posix-cpu-timers.h"
|
||||
|
||||
|
||||
#ifdef __ASSUME_POSIX_TIMERS
|
||||
@ -32,6 +34,11 @@ clock_nanosleep (clockid_t clock_id, int flags, const struct timespec *req,
|
||||
INTERNAL_SYSCALL_DECL (err);
|
||||
int r;
|
||||
|
||||
if (clock_id == CLOCK_THREAD_CPUTIME_ID)
|
||||
return EINVAL;
|
||||
if (clock_id == CLOCK_PROCESS_CPUTIME_ID)
|
||||
clock_id = MAKE_PROCESS_CPUCLOCK (0, CPUCLOCK_SCHED);
|
||||
|
||||
if (SINGLE_THREAD_P)
|
||||
r = INTERNAL_SYSCALL (clock_nanosleep, err, 4, clock_id, flags, req, rem);
|
||||
else
|
||||
@ -58,12 +65,20 @@ extern int __libc_missing_posix_timers attribute_hidden;
|
||||
# define SYSDEP_NANOSLEEP \
|
||||
if (!__libc_missing_posix_timers) \
|
||||
{ \
|
||||
clockid_t syscall_clockid; \
|
||||
INTERNAL_SYSCALL_DECL (err); \
|
||||
\
|
||||
if (clock_id == CLOCK_THREAD_CPUTIME_ID) \
|
||||
return EINVAL; \
|
||||
if (clock_id == CLOCK_PROCESS_CPUTIME_ID) \
|
||||
syscall_clockid = MAKE_PROCESS_CPUCLOCK (0, CPUCLOCK_SCHED); \
|
||||
else \
|
||||
syscall_clockid = clock_id; \
|
||||
\
|
||||
int oldstate = LIBC_CANCEL_ASYNC (); \
|
||||
\
|
||||
int r = INTERNAL_SYSCALL (clock_nanosleep, err, 4, clock_id, flags, \
|
||||
req, rem); \
|
||||
int r = INTERNAL_SYSCALL (clock_nanosleep, err, 4, \
|
||||
syscall_clockid, flags, req, rem); \
|
||||
\
|
||||
LIBC_CANCEL_RESET (oldstate); \
|
||||
\
|
||||
|
@ -1,4 +1,5 @@
|
||||
/* Copyright (C) 2000, 2001, 2003, 2004 Free Software Foundation, Inc.
|
||||
/* clock_getcpuclockid -- Get a clockid_t for process CPU time. Linux/IA64
|
||||
Copyright (C) 2000,2001,2003,2004 Free Software Foundation, Inc.
|
||||
This file is part of the GNU C Library.
|
||||
|
||||
The GNU C Library is free software; you can redistribute it and/or
|
||||
@ -26,22 +27,6 @@
|
||||
|
||||
#include "has_cpuclock.c"
|
||||
|
||||
#define HAS_CPUCLOCK (has_cpuclock () > 0)
|
||||
|
||||
int
|
||||
clock_getcpuclockid (pid_t pid, clockid_t *clock_id)
|
||||
{
|
||||
/* We don't allow any process ID but our own. */
|
||||
if (pid != 0 && pid != getpid ())
|
||||
return EPERM;
|
||||
|
||||
int retval = ENOENT;
|
||||
|
||||
if (has_cpuclock () > 0)
|
||||
{
|
||||
/* Store the number. */
|
||||
*clock_id = CLOCK_PROCESS_CPUTIME_ID;
|
||||
retval = 0;
|
||||
}
|
||||
|
||||
return retval;
|
||||
}
|
||||
#include <sysdeps/unix/sysv/linux/clock_getcpuclockid.c>
|
||||
|
18
sysdeps/unix/sysv/linux/kernel-posix-cpu-timers.h
Normal file
18
sysdeps/unix/sysv/linux/kernel-posix-cpu-timers.h
Normal file
@ -0,0 +1,18 @@
|
||||
/* Parameters for the Linux kernel ABI for CPU clocks. */
|
||||
|
||||
#define CPUCLOCK_PID(clock) ((pid_t) ~((clock) >> 3))
|
||||
#define CPUCLOCK_PERTHREAD(clock) \
|
||||
(((clock) & (clockid_t) CPUCLOCK_PERTHREAD_MASK) != 0)
|
||||
#define CPUCLOCK_PID_MASK 7
|
||||
#define CPUCLOCK_PERTHREAD_MASK 4
|
||||
#define CPUCLOCK_WHICH(clock) ((clock) & (clockid_t) CPUCLOCK_CLOCK_MASK)
|
||||
#define CPUCLOCK_CLOCK_MASK 3
|
||||
#define CPUCLOCK_PROF 0
|
||||
#define CPUCLOCK_VIRT 1
|
||||
#define CPUCLOCK_SCHED 2
|
||||
#define CPUCLOCK_MAX 3
|
||||
|
||||
#define MAKE_PROCESS_CPUCLOCK(pid, clock) \
|
||||
((~(clockid_t) (pid) << 3) | (clockid_t) (clock))
|
||||
#define MAKE_THREAD_CPUCLOCK(tid, clock) \
|
||||
MAKE_PROCESS_CPUCLOCK((tid), (clock) | CPUCLOCK_PERTHREAD_MASK)
|
Loading…
Reference in New Issue
Block a user