#ifndef _TIME_H
-#if defined __need_time_t || defined __need_clock_t || defined __need_timespec
-# include <time/time.h>
-#else
-# include <time/time.h>
-# include <xlocale.h>
+#include <time/time.h>
-__BEGIN_DECLS
+#ifndef _ISOMAC
+# include <bits/types/struct_timeval.h>
+# include <struct___timespec64.h>
+# include <struct___timeval64.h>
+# include <bits/types/locale_t.h>
+# include <stdbool.h>
+# include <time/mktime-internal.h>
+# include <sys/time.h>
+# include <time-clockid.h>
+# include <sys/time.h>
+# include <stdint.h>
extern __typeof (strftime_l) __strftime_l;
libc_hidden_proto (__strftime_l)
extern __typeof (strptime_l) __strptime_l;
-libc_hidden_proto (time)
libc_hidden_proto (asctime)
libc_hidden_proto (mktime)
libc_hidden_proto (timelocal)
libc_hidden_proto (strftime)
libc_hidden_proto (strptime)
-librt_hidden_proto (clock_gettime)
+extern __typeof (clock_gettime) __clock_gettime;
+libc_hidden_proto (__clock_gettime)
+extern __typeof (clock_settime) __clock_settime;
+libc_hidden_proto (__clock_settime)
+
+extern __typeof (clock_getres) __clock_getres;
+libc_hidden_proto (__clock_getres)
+
+extern __typeof (clock_nanosleep) __clock_nanosleep;
+libc_hidden_proto (__clock_nanosleep);
+
+#ifdef __linux__
+extern __typeof (clock_adjtime) __clock_adjtime;
+libc_hidden_proto (__clock_adjtime);
+#endif
/* Now define the internal interfaces. */
struct tm;
extern struct tm _tmbuf attribute_hidden;
/* Defined in tzset.c. */
-extern char *__tzstring (const char *string);
-
-/* Defined in tzset.c. */
-extern size_t __tzname_cur_max attribute_hidden;
-
+extern char *__tzstring (const char *string) attribute_hidden;
extern int __use_tzfile attribute_hidden;
extern void __tzfile_read (const char *file, size_t extra,
- char **extrap);
-extern void __tzfile_compute (time_t timer, int use_localtime,
+ char **extrap) attribute_hidden;
+extern void __tzfile_compute (__time64_t timer, int use_localtime,
long int *leap_correct, int *leap_hit,
- struct tm *tp);
+ struct tm *tp) attribute_hidden;
extern void __tzfile_default (const char *std, const char *dst,
- long int stdoff, long int dstoff);
-
-/* Subroutine of `mktime'. Return the `time_t' representation of TP and
- normalize TP, given that a `struct tm *' maps to a `time_t' as performed
- by FUNC. Keep track of next guess for time_t offset in *OFFSET. */
-extern time_t __mktime_internal (struct tm *__tp,
- struct tm *(*__func) (const time_t *,
- struct tm *),
- time_t *__offset);
-extern struct tm *__localtime_r (__const time_t *__timer,
+ int stdoff, int dstoff)
+ attribute_hidden;
+extern void __tzset_parse_tz (const char *tz) attribute_hidden;
+extern void __tz_compute (__time64_t timer, struct tm *tm, int use_localtime)
+ __THROW attribute_hidden;
+
+
+#if __TIMESIZE == 64
+# define __itimerspec64 itimerspec
+#else
+/* The glibc's internal representation of the struct itimerspec. */
+struct __itimerspec64
+{
+ struct __timespec64 it_interval;
+ struct __timespec64 it_value;
+};
+#endif
+
+#if __TIMESIZE == 64
+# define __utimbuf64 utimbuf
+# define __itimerval64 itimerval
+#else
+/* The glibc Y2038-proof struct __utimbuf64 structure for file's access
+ and modification time values. */
+struct __utimbuf64
+{
+ __time64_t actime; /* Access time. */
+ __time64_t modtime; /* Modification time. */
+};
+/* The glibc's internal representation of the struct itimerval. */
+struct __itimerval64
+{
+ struct __timeval64 it_interval;
+ struct __timeval64 it_value;
+};
+#endif
+
+#if __TIMESIZE == 64
+# define __getitimer64 __getitimer
+# define __setitimer64 __setitimer
+#else
+extern int __getitimer64 (enum __itimer_which __which,
+ struct __itimerval64 *__value);
+
+libc_hidden_proto (__getitimer64)
+extern int __setitimer64 (enum __itimer_which __which,
+ const struct __itimerval64 *__restrict __new,
+ struct __itimerval64 *__restrict __old);
+libc_hidden_proto (__setitimer64)
+#endif
+
+#if __TIMESIZE == 64
+# define __ctime64 ctime
+#else
+extern char *__ctime64 (const __time64_t *__timer) __THROW;
+libc_hidden_proto (__ctime64)
+#endif
+
+#if __TIMESIZE == 64
+# define __ctime64_r ctime_r
+#else
+extern char *__ctime64_r (const __time64_t *__restrict __timer,
+ char *__restrict __buf) __THROW;
+libc_hidden_proto (__ctime64_r)
+#endif
+
+#if __TIMESIZE == 64
+# define __localtime64 localtime
+#else
+extern struct tm *__localtime64 (const __time64_t *__timer);
+libc_hidden_proto (__localtime64)
+#endif
+
+extern struct tm *__localtime_r (const time_t *__timer,
struct tm *__tp) attribute_hidden;
+#if __TIMESIZE != 64
+extern struct tm *__localtime64_r (const __time64_t *__timer,
+ struct tm *__tp);
+libc_hidden_proto (__localtime64_r)
-extern struct tm *__gmtime_r (__const time_t *__restrict __timer,
+extern __time64_t __mktime64 (struct tm *__tp) __THROW;
+libc_hidden_proto (__mktime64)
+#endif
+
+extern struct tm *__gmtime_r (const time_t *__restrict __timer,
struct tm *__restrict __tp);
libc_hidden_proto (__gmtime_r)
-/* Compute the `struct tm' representation of *T,
+#if __TIMESIZE == 64
+# define __gmtime64 gmtime
+#else
+extern struct tm *__gmtime64 (const __time64_t *__timer);
+libc_hidden_proto (__gmtime64)
+
+extern struct tm *__gmtime64_r (const __time64_t *__restrict __timer,
+ struct tm *__restrict __tp);
+libc_hidden_proto (__gmtime64_r)
+
+extern __time64_t __timegm64 (struct tm *__tp) __THROW;
+libc_hidden_proto (__timegm64)
+#endif
+
+#if __TIMESIZE == 64
+# define __clock_settime64 __clock_settime
+#else
+extern int __clock_settime64 (clockid_t clock_id,
+ const struct __timespec64 *tp) __nonnull((2));
+libc_hidden_proto (__clock_settime64)
+#endif
+
+#if __TIMESIZE == 64
+# define __clock_getres64 __clock_getres
+#else
+extern int __clock_getres64 (clockid_t clock_id,
+ struct __timespec64 *tp);
+libc_hidden_proto (__clock_getres64);
+#endif
+
+#if __TIMESIZE == 64
+# define __utime64 __utime
+# define __utimes64 __utimes
+# define __utimensat64 __utimensat
+#else
+extern int __utime64 (const char *file, const struct __utimbuf64 *times);
+libc_hidden_proto (__utime64)
+extern int __utimes64 (const char *file, const struct __timeval64 tvp[2]);
+libc_hidden_proto (__utimes64)
+extern int __utimensat64 (int fd, const char *file,
+ const struct __timespec64 tsp[2], int flags);
+libc_hidden_proto (__utimensat64);
+#endif
+
+extern int __utimensat64_helper (int fd, const char *file,
+ const struct __timespec64 tsp[2], int flags);
+libc_hidden_proto (__utimensat64_helper);
+
+extern int __futimesat (int __fd, const char *__file, const struct timeval __tvp[2]);
+#if __TIMESIZE == 64
+# define __futimes64 __futimes
+# define __futimesat64 __futimesat
+# define __lutimes64 __lutimes
+# define __futimens64 __futimens
+#else
+extern int __futimes64 (int fd, const struct __timeval64 tvp64[2]);
+libc_hidden_proto (__futimes64);
+extern int __futimesat64 (int fd, const char *file,
+ const struct __timeval64 tvp[2]);
+libc_hidden_proto (__futimesat64);
+extern int __lutimes64 (const char *file, const struct __timeval64 tvp64[2]);
+libc_hidden_proto (__lutimes64);
+extern int __futimens64 (int fd, const struct __timespec64 tsp[2]);
+libc_hidden_proto (__futimens64);
+#endif
+
+#if __TIMESIZE == 64
+# define __timer_gettime64 __timer_gettime
+# define __timerfd_gettime64 __timerfd_gettime
+#else
+extern int __timer_gettime64 (timer_t timerid, struct __itimerspec64 *value);
+extern int __timerfd_gettime64 (int fd, struct __itimerspec64 *value);
+# if PTHREAD_IN_LIBC
+libc_hidden_proto (__timer_gettime64)
+# else
+librt_hidden_proto (__timer_gettime64)
+# endif
+libc_hidden_proto (__timerfd_gettime64);
+#endif
+
+#if __TIMESIZE == 64
+# define __timer_settime64 __timer_settime
+# define __timerfd_settime64 __timerfd_settime
+#else
+extern int __timer_settime64 (timer_t timerid, int flags,
+ const struct __itimerspec64 *value,
+ struct __itimerspec64 *ovalue);
+extern int __timerfd_settime64 (int fd, int flags,
+ const struct __itimerspec64 *value,
+ struct __itimerspec64 *ovalue);
+# if PTHREAD_IN_LIBC
+libc_hidden_proto (__timer_settime64)
+#else
+librt_hidden_proto (__timer_settime64)
+#endif
+libc_hidden_proto (__timerfd_settime64);
+#endif
+
+#if __TIMESIZE == 64
+# define __sched_rr_get_interval64 __sched_rr_get_interval
+#else
+extern int __sched_rr_get_interval64 (pid_t pid, struct __timespec64 *tp);
+libc_hidden_proto (__sched_rr_get_interval64);
+#endif
+
+#if __TIMESIZE == 64
+# define __settimeofday64 __settimeofday
+# define __gettimeofday64 __gettimeofday
+#else
+extern int __settimeofday64 (const struct __timeval64 *tv,
+ const struct timezone *tz);
+libc_hidden_proto (__settimeofday64)
+extern int __gettimeofday64 (struct __timeval64 *restrict tv,
+ void *restrict tz);
+libc_hidden_proto (__gettimeofday64)
+#endif
+
+/* Compute the `struct tm' representation of T,
offset OFFSET seconds east of UTC,
and store year, yday, mon, mday, wday, hour, min, sec into *TP.
Return nonzero if successful. */
-extern int __offtime (__const time_t *__timer,
+extern int __offtime (__time64_t __timer,
long int __offset,
- struct tm *__tp);
+ struct tm *__tp) attribute_hidden;
-extern char *__asctime_r (__const struct tm *__tp, char *__buf);
-extern void __tzset (void);
+extern char *__asctime_r (const struct tm *__tp, char *__buf)
+ attribute_hidden;
+extern void __tzset (void) attribute_hidden;
/* Prototype for the internal function to get information based on TZ. */
-extern struct tm *__tz_convert (const time_t *timer, int use_localtime, struct tm *tp);
-
-/* Return the maximum length of a timezone name.
- This is what `sysconf (_SC_TZNAME_MAX)' does. */
-extern long int __tzname_max (void);
+extern struct tm *__tz_convert (__time64_t timer, int use_localtime,
+ struct tm *tp) attribute_hidden;
-extern int __nanosleep (__const struct timespec *__requested_time,
+extern int __nanosleep (const struct timespec *__requested_time,
struct timespec *__remaining);
-libc_hidden_proto(__nanosleep)
-extern int __getdate_r (__const char *__string, struct tm *__resbufp);
+hidden_proto (__nanosleep)
+#if __TIMESIZE == 64
+# define __nanosleep64 __nanosleep
+#else
+extern int __nanosleep64 (const struct __timespec64 *__requested_time,
+ struct __timespec64 *__remaining);
+hidden_proto (__nanosleep64)
+#endif
+
+
+extern int __getdate_r (const char *__string, struct tm *__resbufp);
+libc_hidden_proto (__getdate_r);
/* Determine CLK_TCK value. */
-extern int __getclktck (void);
+extern int __getclktck (void) attribute_hidden;
/* strptime support. */
-/* Status of lookup: do we use the locale data or the raw data? */
-#ifndef __cplusplus
-// C++ cannot deal with using 'not'.
-enum ptime_locale_status { not, loc, raw };
-
extern char * __strptime_internal (const char *rp, const char *fmt,
- struct tm *tm,
- enum ptime_locale_status *decided,
- int era_cnt, __locale_t locparam)
- internal_function;
+ struct tm *tm, void *statep,
+ locale_t locparam) attribute_hidden;
+
+#if __TIMESIZE == 64
+# define __difftime64 __difftime
+#else
+extern double __difftime64 (__time64_t time1, __time64_t time0);
+libc_hidden_proto (__difftime64)
#endif
extern double __difftime (time_t time1, time_t time0);
+#if __TIMESIZE == 64
+# define __clock_nanosleep_time64 __clock_nanosleep
+# define __clock_gettime64 __clock_gettime
+# define __timespec_get64 __timespec_get
+# define __timespec_getres64 __timespec_getres
+#else
+extern int __clock_nanosleep_time64 (clockid_t clock_id,
+ int flags, const struct __timespec64 *req,
+ struct __timespec64 *rem);
+libc_hidden_proto (__clock_nanosleep_time64)
+extern int __clock_gettime64 (clockid_t clock_id, struct __timespec64 *tp) __nonnull((2));
+libc_hidden_proto (__clock_gettime64)
+extern int __timespec_get64 (struct __timespec64 *ts, int base);
+libc_hidden_proto (__timespec_get64)
+extern int __timespec_getres64 (struct __timespec64 *ts, int base);
+libc_hidden_proto (__timespec_getres64)
+#endif
+
+#if __TIMESIZE == 64
+# define __time64 __time
+#else
+extern __time64_t __time64 (__time64_t *timer);
+libc_hidden_proto (__time64)
+#endif
/* Use in the clock_* functions. Size of the field representing the
actual clock ID. */
-#ifndef _ISOMAC
-# define CLOCK_IDFIELD_SIZE 3
-#endif
+#define CLOCK_IDFIELD_SIZE 3
+
+/* Check whether T fits in int32_t, assume all usages are for
+ sizeof(time_t) == 32. */
+static inline bool
+in_int32_t_range (__time64_t t)
+{
+ int32_t s = t;
+ return s == t;
+}
+
+/* Check whether T fits in time_t. */
+static inline bool
+in_time_t_range (__time64_t t)
+{
+ time_t s = t;
+ return s == t;
+}
+
+/* Convert a known valid struct timeval into a struct __timespec64. */
+static inline struct __timespec64
+valid_timeval_to_timespec64 (const struct timeval tv)
+{
+ struct __timespec64 ts64;
+
+ ts64.tv_sec = tv.tv_sec;
+ ts64.tv_nsec = tv.tv_usec * 1000;
+
+ return ts64;
+}
+
+/* Convert a known valid struct timeval into a struct __timeval64. */
+static inline struct __timeval64
+valid_timeval_to_timeval64 (const struct timeval tv)
+{
+ struct __timeval64 tv64;
+
+ tv64.tv_sec = tv.tv_sec;
+ tv64.tv_usec = tv.tv_usec;
+
+ return tv64;
+}
+
+/* Convert a valid and within range of struct timeval, struct
+ __timeval64 into a struct timeval. */
+static inline struct timeval
+valid_timeval64_to_timeval (const struct __timeval64 tv64)
+{
+ struct timeval tv;
-__END_DECLS
+ tv.tv_sec = (time_t) tv64.tv_sec;
+ tv.tv_usec = (suseconds_t) tv64.tv_usec;
+
+ return tv;
+}
+
+/* Convert a struct __timeval64 into a struct __timespec64. */
+static inline struct __timespec64
+timeval64_to_timespec64 (const struct __timeval64 tv64)
+{
+ struct __timespec64 ts64;
+
+ ts64.tv_sec = tv64.tv_sec;
+ ts64.tv_nsec = tv64.tv_usec * 1000;
+
+ return ts64;
+}
+
+/* Convert a known valid struct timespec into a struct __timespec64. */
+static inline struct __timespec64
+valid_timespec_to_timespec64 (const struct timespec ts)
+{
+ struct __timespec64 ts64;
+
+ ts64.tv_sec = ts.tv_sec;
+ ts64.tv_nsec = ts.tv_nsec;
+
+ return ts64;
+}
+
+/* Convert a valid and within range of struct timespec, struct
+ __timespec64 into a struct timespec. */
+static inline struct timespec
+valid_timespec64_to_timespec (const struct __timespec64 ts64)
+{
+ struct timespec ts;
+
+ ts.tv_sec = (time_t) ts64.tv_sec;
+ ts.tv_nsec = ts64.tv_nsec;
+
+ return ts;
+}
+
+/* Convert a valid and within range of struct timeval struct
+ __timespec64 into a struct timeval. */
+static inline struct timeval
+valid_timespec64_to_timeval (const struct __timespec64 ts64)
+{
+ struct timeval tv;
+
+ tv.tv_sec = (time_t) ts64.tv_sec;
+ tv.tv_usec = ts64.tv_nsec / 1000;
+
+ return tv;
+}
+
+/* Convert a struct __timespec64 into a struct __timeval64. */
+static inline struct __timeval64
+timespec64_to_timeval64 (const struct __timespec64 ts64)
+{
+ struct __timeval64 tv64;
+
+ tv64.tv_sec = ts64.tv_sec;
+ tv64.tv_usec = ts64.tv_nsec / 1000;
+
+ return tv64;
+}
+
+/* A version of 'struct timeval' with 32-bit time_t
+ and suseconds_t. */
+struct __timeval32
+{
+ int32_t tv_sec; /* Seconds. */
+ int32_t tv_usec; /* Microseconds. */
+};
+
+/* Conversion functions for converting to/from __timeval32 */
+static inline struct __timeval64
+valid_timeval32_to_timeval64 (const struct __timeval32 tv)
+{
+ return (struct __timeval64) { tv.tv_sec, tv.tv_usec };
+}
+
+static inline struct __timeval32
+valid_timeval64_to_timeval32 (const struct __timeval64 tv64)
+{
+ return (struct __timeval32) { tv64.tv_sec, tv64.tv_usec };
+}
+
+static inline struct timeval
+valid_timeval32_to_timeval (const struct __timeval32 tv)
+{
+ return (struct timeval) { tv.tv_sec, tv.tv_usec };
+}
+
+static inline struct __timeval32
+valid_timeval_to_timeval32 (const struct timeval tv)
+{
+ return (struct __timeval32) { tv.tv_sec, tv.tv_usec };
+}
+
+static inline struct timespec
+valid_timeval32_to_timespec (const struct __timeval32 tv)
+{
+ return (struct timespec) { tv.tv_sec, tv.tv_usec * 1000 };
+}
+
+static inline struct __timeval32
+valid_timespec_to_timeval32 (const struct timespec ts)
+{
+ return (struct __timeval32) { (time_t) ts.tv_sec, ts.tv_nsec / 1000 };
+}
+
+static inline struct __timeval64
+valid_timespec_to_timeval64 (const struct timespec ts)
+{
+ return (struct __timeval64) { (time_t) ts.tv_sec, ts.tv_nsec / 1000 };
+}
+
+/* Check if a value is in the valid nanoseconds range. Return true if
+ it is, false otherwise. */
+static inline bool
+valid_nanoseconds (__syscall_slong_t ns)
+{
+ return __glibc_likely (0 <= ns && ns < 1000000000);
+}
+
+/* Helper function to get time in seconds, similar to time. */
+static inline time_t
+time_now (void)
+{
+ struct timespec ts;
+ __clock_gettime (TIME_CLOCK_GETTIME_CLOCKID, &ts);
+ return ts.tv_sec;
+}
+
+static inline __time64_t
+time64_now (void)
+{
+ struct __timespec64 ts;
+ __clock_gettime64 (TIME_CLOCK_GETTIME_CLOCKID, &ts);
+ return ts.tv_sec;
+}
+
+#define NSEC_PER_SEC 1000000000L /* Nanoseconds per second. */
+#define USEC_PER_SEC 1000000L /* Microseconds per second. */
+#define NSEC_PER_USEC 1000L /* Nanoseconds per microsecond. */
#endif
+
#endif
projects / thirdparty / glibc.git / blobdiff