AuroraMiddleware/glibc
1
0
Fork 0
mirror of https://sourceware.org/git/glibc.git synced 2024-12-26 12:41:05 +00:00
Code Issues Packages Projects Releases Wiki Activity

2005-04-27 Roland McGrath <roland@redhat.com>

Browse Source 
* 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:
Roland McGrath 2005-04-27 08:01:41 +00:00
parent 0f888d8ec6
commit 2f4f3bd4a9
8 changed files with 549 additions and 195 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

111
sysdeps/posix/clock_getres.c
View File

@ -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
}

117
sysdeps/unix/clock_gettime.c
View File

@ -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
View 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
}

175
sysdeps/unix/sysv/linux/clock_getres.c
View File

@ -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>

176
sysdeps/unix/sysv/linux/clock_gettime.c
View File

@ -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>

21
sysdeps/unix/sysv/linux/clock_nanosleep.c
View File

@ -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); \
\

23
sysdeps/unix/sysv/linux/ia64/clock_getcpuclockid.c
View File

@ -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
View 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)