From patchwork Thu Sep 7 22:41:30 2017 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: "Albert ARIBAUD (3ADEV)" X-Patchwork-Id: 811197 Return-Path: X-Original-To: incoming@patchwork.ozlabs.org Delivered-To: patchwork-incoming@bilbo.ozlabs.org Authentication-Results: ozlabs.org; spf=pass (mailfrom) smtp.mailfrom=sourceware.org (client-ip=209.132.180.131; helo=sourceware.org; envelope-from=libc-alpha-return-84321-incoming=patchwork.ozlabs.org@sourceware.org; receiver=) Authentication-Results: ozlabs.org; dkim=pass (1024-bit key; secure) header.d=sourceware.org header.i=@sourceware.org header.b="O0PXN/wd"; dkim-atps=neutral Received: from sourceware.org (server1.sourceware.org [209.132.180.131]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by ozlabs.org (Postfix) with ESMTPS id 3xpFpf2Pxbz9sCZ for ; Fri, 8 Sep 2017 08:43:06 +1000 (AEST) DomainKey-Signature: a=rsa-sha1; c=nofws; d=sourceware.org; h=list-id :list-unsubscribe:list-subscribe:list-archive:list-post :list-help:sender:from:to:cc:subject:date:message-id:in-reply-to :references; q=dns; s=default; b=DA/r7u1vgK0JvFzbMj2y2XB1vCqc//l MV2/hyMTYpkN3jPG/mMH2mKB+oBeZi+lF+o9pwwgjSwM1QydAWCHFKh6z634ZHak blkF5uy9ug4vzQVVRyjeGNd+dlrdJONmIm0vFLeJmH9Rf5vkyDFdhqwCYJhAuekI RWWj87rKFMpI= DKIM-Signature: v=1; a=rsa-sha1; c=relaxed; d=sourceware.org; h=list-id :list-unsubscribe:list-subscribe:list-archive:list-post :list-help:sender:from:to:cc:subject:date:message-id:in-reply-to :references; s=default; bh=enql6Ra+WyRz4G9DEfnkDSfI3Ck=; b=O0PXN /wd/cYbFA6DvsmwWazaQ2iZJTnCqmn3Na1bnkxlKXl8g8UhZBz7nXDTckvpVs3rL UQP86lI+05AxsJFSgCZBIzRTTkkQ68axnXFWBZoQJyz82YEitnkQn6Thn40Sufpy QmO9foTx4SI9pvgypfvB1QdD3Hh0iZ54AJvUsw= Received: (qmail 59252 invoked by alias); 7 Sep 2017 22:42:44 -0000 Mailing-List: contact libc-alpha-help@sourceware.org; run by ezmlm Precedence: bulk List-Id: List-Unsubscribe: List-Subscribe: List-Archive: List-Post: List-Help: , Sender: libc-alpha-owner@sourceware.org Delivered-To: mailing list libc-alpha@sourceware.org Received: (qmail 59109 invoked by uid 89); 7 Sep 2017 22:42:44 -0000 Authentication-Results: sourceware.org; auth=none X-Virus-Found: No X-Spam-SWARE-Status: No, score=-26.6 required=5.0 tests=BAYES_00, GIT_PATCH_0, GIT_PATCH_1, GIT_PATCH_2, GIT_PATCH_3, KAM_LAZY_DOMAIN_SECURITY, RCVD_IN_DNSWL_LOW autolearn=ham version=3.3.2 spammy=east, january X-HELO: smtp6-g21.free.fr From: "Albert ARIBAUD (3ADEV)" To: libc-alpha@sourceware.org Cc: "Albert ARIBAUD (3ADEV)" Subject: [RFC PATCH 03/52] Y2038: add functions using struct tm Date: Fri, 8 Sep 2017 00:41:30 +0200 Message-Id: <20170907224219.12483-4-albert.aribaud@3adev.fr> In-Reply-To: <20170907224219.12483-3-albert.aribaud@3adev.fr> References: <20170907224219.12483-1-albert.aribaud@3adev.fr> <20170907224219.12483-2-albert.aribaud@3adev.fr> <20170907224219.12483-3-albert.aribaud@3adev.fr> This consists in the following implementation additions: ([file] 32-bit implementation -> [file] 64-bit addition) time/ctime.c ctime() -> __ctime64() time/ctime_r.c ctime_r() -> __ctime64_r() time/gmtime.c gmtime() -> __gmtime64() time/gmtime.c gmtime_r() -> __gmtime64_r() time/localtime.c localtime() -> __localtime64() time/localtime.c localtime_r() -> __localtime64_r() which require the following internal function additions time/offtime.c __offtime() -> __offtime64() time/tzset.c __tz_convert() -> __tz64_convert() and internal function (32-bit-time-compatible) changes time/tzfile.c __tzfile_compute() time/tzset.c tzset_internal() time/tzset.c compute_change() Signed-off-by: Albert ARIBAUD (3ADEV) --- include/time.h | 26 ++++++++++++--- sysdeps/unix/sysv/linux/arm/Versions | 3 ++ time/ctime.c | 10 ++++++ time/ctime_r.c | 9 +++++ time/gmtime.c | 15 +++++++++ time/localtime.c | 17 ++++++++++ time/offtime.c | 64 ++++++++++++++++++++++++++++++++++++ time/tzfile.c | 4 +-- time/tzset.c | 64 +++++++++++++++++++++++++++++++++--- 9 files changed, 201 insertions(+), 11 deletions(-) diff --git a/include/time.h b/include/time.h index 9956b82eb8..d2b1080fd6 100644 --- a/include/time.h +++ b/include/time.h @@ -8,6 +8,8 @@ extern __typeof (strftime_l) __strftime_l; libc_hidden_proto (__strftime_l) extern __typeof (strptime_l) __strptime_l; +extern struct tm *__localtime64 (const __time64_t *__timer); + libc_hidden_proto (time) libc_hidden_proto (asctime) libc_hidden_proto (mktime) @@ -39,13 +41,13 @@ 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, +extern void __tzfile_compute (__time64_t timer, int use_localtime, long int *leap_correct, int *leap_hit, struct tm *tp); extern void __tzfile_default (const char *std, const char *dst, long int stdoff, long int dstoff); extern void __tzset_parse_tz (const char *tz); -extern void __tz_compute (time_t timer, struct tm *tm, int use_localtime) +extern void __tz_compute (__time64_t timer, struct tm *tm, int use_localtime) __THROW internal_function; /* Subroutine of `mktime'. Return the `time_t' representation of TP and @@ -58,23 +60,37 @@ extern time_t __mktime_internal (struct tm *__tp, extern struct tm *__localtime_r (const time_t *__timer, struct tm *__tp) attribute_hidden; -extern struct tm *__gmtime_r (const time_t *__restrict __timer, +extern struct tm *__localtime64_r (const __time64_t *__timer, + struct tm *__tp) attribute_hidden; + +extern struct tm *__gmtime_r (const __time_t *__restrict __timer, struct tm *__restrict __tp); libc_hidden_proto (__gmtime_r) +extern struct tm *__gmtime64_r (const __time64_t *__restrict __timer, + struct tm *__restrict __tp); + /* 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 (const __time_t *__timer, long int __offset, struct tm *__tp); +extern int __offtime64 (const __time64_t *__timer, + long int __offset, + struct tm *__tp); + extern char *__asctime_r (const struct tm *__tp, char *__buf); extern void __tzset (void); /* 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); +extern struct tm *__tz_convert (const __time_t *timer, int use_localtime, + struct tm *tp); + +extern struct tm *__tz_convert64 (const __time64_t *timer, + int use_localtime, struct tm *tp); extern int __nanosleep (const struct timespec *__requested_time, struct timespec *__remaining); diff --git a/sysdeps/unix/sysv/linux/arm/Versions b/sysdeps/unix/sysv/linux/arm/Versions index d3655768c8..dd6a160c75 100644 --- a/sysdeps/unix/sysv/linux/arm/Versions +++ b/sysdeps/unix/sysv/linux/arm/Versions @@ -22,5 +22,8 @@ libc { GLIBC_Y2038 { __difftime64; + __ctime64; __ctime64_r; + __gmtime64; __gmtime64_r; + __localtime64; __localtime64_r; } } diff --git a/time/ctime.c b/time/ctime.c index 7baca1bb57..a5150c1845 100644 --- a/time/ctime.c +++ b/time/ctime.c @@ -26,3 +26,13 @@ ctime (const time_t *t) In particular, ctime and asctime must yield the same pointer. */ return asctime (localtime (t)); } + +/* Return a string as returned by asctime which + is the representation of *T in that form. */ +char * +__ctime64 (const __time64_t *t) +{ + /* Apply the same rule as ctime: + make ctime64 (t) is equivalent to asctime (localtime64 (t)). */ + return asctime (__localtime64 (t)); +} diff --git a/time/ctime_r.c b/time/ctime_r.c index ecd7731038..74d856f17e 100644 --- a/time/ctime_r.c +++ b/time/ctime_r.c @@ -27,3 +27,12 @@ ctime_r (const time_t *t, char *buf) struct tm tm; return __asctime_r (__localtime_r (t, &tm), buf); } + +/* Return a string as returned by asctime which is the representation + of *T in that form. Reentrant Y2038-proof version. */ +char * +__ctime64_r (const __time64_t *t, char *buf) +{ + struct tm tm; + return __asctime_r (__localtime64_r (t, &tm), buf); +} diff --git a/time/gmtime.c b/time/gmtime.c index 049d551cdf..7662c1d1f7 100644 --- a/time/gmtime.c +++ b/time/gmtime.c @@ -35,3 +35,18 @@ gmtime (const time_t *t) { return __tz_convert (t, 0, &_tmbuf); } + +/* Return the `struct tm' representation of 64-bit-time *T + in UTC, using *TP to store the result. */ +struct tm * +__gmtime64_r (const __time64_t *t, struct tm *tp) +{ + return __tz_convert64 (t, 0, tp); +} + +/* Return the `struct tm' representation of 64-bit-time *T in UTC. */ +struct tm * +__gmtime64 (const __time64_t *t) +{ + return __tz_convert64 (t, 0, &_tmbuf); +} diff --git a/time/localtime.c b/time/localtime.c index 07dd67ca71..fd2d997e60 100644 --- a/time/localtime.c +++ b/time/localtime.c @@ -39,3 +39,20 @@ localtime (const time_t *t) return __tz_convert (t, 1, &_tmbuf); } libc_hidden_def (localtime) + +/* 64-bit-time versions */ + +/* Return the `struct tm' representation of *T in local time, + using *TP to store the result. */ +struct tm * +__localtime64_r (const __time64_t *t, struct tm *tp) +{ + return __tz_convert64 (t, 1, tp); +} + +/* Return the `struct tm' representation of *T in local time. */ +struct tm * +__localtime64 (const __time64_t *t) +{ + return __tz_convert64 (t, 1, &_tmbuf); +} diff --git a/time/offtime.c b/time/offtime.c index 75a28fed84..84237db440 100644 --- a/time/offtime.c +++ b/time/offtime.c @@ -84,3 +84,67 @@ __offtime (const time_t *t, long int offset, struct tm *tp) tp->tm_mday = days + 1; return 1; } + +/* Compute the `struct tm' representation of 64-bit-time *T, + offset OFFSET seconds east of UTC, + and store year, yday, mon, mday, wday, hour, min, sec into *TP. + Return nonzero if successful. */ +int +__offtime64 (const __time64_t *t, long int offset, struct tm *tp) +{ + __time64_t days, rem, y; + const unsigned short int *ip; + + days = *t / SECS_PER_DAY; + rem = *t % SECS_PER_DAY; + rem += offset; + while (rem < 0) + { + rem += SECS_PER_DAY; + --days; + } + while (rem >= SECS_PER_DAY) + { + rem -= SECS_PER_DAY; + ++days; + } + tp->tm_hour = rem / SECS_PER_HOUR; + rem %= SECS_PER_HOUR; + tp->tm_min = rem / 60; + tp->tm_sec = rem % 60; + /* January 1, 1970 was a Thursday. */ + tp->tm_wday = (4 + days) % 7; + if (tp->tm_wday < 0) + tp->tm_wday += 7; + y = 1970; + +#define DIV(a, b) ((a) / (b) - ((a) % (b) < 0)) +#define LEAPS_THRU_END_OF(y) (DIV (y, 4) - DIV (y, 100) + DIV (y, 400)) + + while (days < 0 || days >= (__isleap (y) ? 366 : 365)) + { + /* Guess a corrected year, assuming 365 days per year. */ + __time64_t yg = y + days / 365 - (days % 365 < 0); + + /* Adjust DAYS and Y to match the guessed year. */ + days -= ((yg - y) * 365 + + LEAPS_THRU_END_OF (yg - 1) + - LEAPS_THRU_END_OF (y - 1)); + y = yg; + } + tp->tm_year = y - 1900; + if (tp->tm_year != y - 1900) + { + /* The year cannot be represented due to overflow. */ + __set_errno (EOVERFLOW); + return 0; + } + tp->tm_yday = days; + ip = __mon_yday[__isleap(y)]; + for (y = 11; days < (long int) ip[y]; --y) + continue; + days -= ip[y]; + tp->tm_mon = y; + tp->tm_mday = days + 1; + return 1; +} diff --git a/time/tzfile.c b/time/tzfile.c index d41246980b..9da9d0b38b 100644 --- a/time/tzfile.c +++ b/time/tzfile.c @@ -630,7 +630,7 @@ __tzfile_default (const char *std, const char *dst, } void -__tzfile_compute (time_t timer, int use_localtime, +__tzfile_compute (__time64_t timer, int use_localtime, long int *leap_correct, int *leap_hit, struct tm *tp) { @@ -685,7 +685,7 @@ __tzfile_compute (time_t timer, int use_localtime, /* Convert to broken down structure. If this fails do not use the string. */ - if (__glibc_unlikely (! __offtime (&timer, 0, tp))) + if (__glibc_unlikely (! __offtime64 (&timer, 0, tp))) goto use_last; /* Use the rules from the TZ string to compute the change. */ diff --git a/time/tzset.c b/time/tzset.c index cf5fe969b6..ee462107e1 100644 --- a/time/tzset.c +++ b/time/tzset.c @@ -55,7 +55,7 @@ typedef struct /* We cache the computed time of change for a given year so we don't have to recompute it. */ - time_t change; /* When to change to this zone. */ + __time64_t change; /* When to change to this zone. */ int computed_for; /* Year above is computed for. */ } tz_rule; @@ -417,7 +417,7 @@ tzset_internal (int always) tz_rules[0].name = tz_rules[1].name = "UTC"; if (J0 != 0) tz_rules[0].type = tz_rules[1].type = J0; - tz_rules[0].change = tz_rules[1].change = (time_t) -1; + tz_rules[0].change = tz_rules[1].change = (__time64_t) -1; update_vars (); return; } @@ -516,10 +516,11 @@ compute_change (tz_rule *rule, int year) /* Figure out the correct timezone for TM and set `__tzname', - `__timezone', and `__daylight' accordingly. */ + `__timezone', and `__daylight' accordingly. + NOTE: this takes a __time64_t value, so passing a __time_t value is OK. */ void internal_function -__tz_compute (time_t timer, struct tm *tm, int use_localtime) +__tz_compute (__time64_t timer, struct tm *tm, int use_localtime) { compute_change (&tz_rules[0], 1900 + tm->tm_year); compute_change (&tz_rules[1], 1900 + tm->tm_year); @@ -620,6 +621,61 @@ __tz_convert (const time_t *timer, int use_localtime, struct tm *tp) } +/* Return the `struct tm' representation of *TIMER in the local timezone. + Use local time if USE_LOCALTIME is nonzero, UTC otherwise. */ +struct tm * +__tz_convert64 (const __time64_t *timer, int use_localtime, struct tm *tp) +{ + long int leap_correction; + int leap_extra_secs; + + if (timer == NULL) + { + __set_errno (EINVAL); + return NULL; + } + + __libc_lock_lock (tzset_lock); + + /* Update internal database according to current TZ setting. + POSIX.1 8.3.7.2 says that localtime_r is not required to set tzname. + This is a good idea since this allows at least a bit more parallelism. */ + tzset_internal (tp == &_tmbuf && use_localtime); + + if (__use_tzfile) + __tzfile_compute (*timer, use_localtime, &leap_correction, + &leap_extra_secs, tp); + else + { + if (! __offtime64 (timer, 0, tp)) + tp = NULL; + else + __tz_compute (*timer, tp, use_localtime); + leap_correction = 0L; + leap_extra_secs = 0; + } + + __libc_lock_unlock (tzset_lock); + + if (tp) + { + if (! use_localtime) + { + tp->tm_isdst = 0; + tp->tm_zone = "GMT"; + tp->tm_gmtoff = 0L; + } + + if (__offtime64 (timer, tp->tm_gmtoff - leap_correction, tp)) + tp->tm_sec += leap_extra_secs; + else + tp = NULL; + } + + return tp; +} + + libc_freeres_fn (free_mem) { while (tzstring_list != NULL)