[PATCH v8 1/2] Y2038: Add 64-bit time for all architectures

Now that __time_64_t exists, we can switch internal function
__tz_convert from 32-bit to 64-bit time. This involves switching
some other internal functions and turning some implementations
which use these into wrappers between public 32-bit and internal
64-bit time.

* __tz_compute: Pass timer as a __time64_t rather than time_t.
* __offtime: Pass __timer as a __time64_t value rather than
a const time_t pointer.
* __tz_convert: Likewise.
* localtime: provide a 64-bit time version and make the 32-bit
time version a wrapper of it.
* localtime_r: Likewise.
* ctime: Likewise.
* ctime_r: Likewise.
* gmtime: Likewise.
* gmtime_r: Likewise.
---
include/time.h | 39 ++++++++++++++++++++++++++++++++++-----
time/ctime.c | 17 +++++++++++++++--
time/ctime_r.c | 17 +++++++++++++++--
time/gmtime.c | 37 +++++++++++++++++++++++++++++++++----
time/localtime.c | 36 ++++++++++++++++++++++++++++++++----
time/offtime.c | 12 ++++++------
time/tzfile.c | 14 ++++----------
time/tzset.c | 27 ++++++++++-----------------
8 files changed, 149 insertions(+), 50 deletions(-)

diff --git a/include/time.h b/include/time.h
index e99711a556..7dbd4dce22 100644
--- a/include/time.h
+++ b/include/time.h
@@ -46,7 +46,7 @@ extern void __tzfile_default (const char *std, const char *dst,
long int stdoff, long int dstoff)
attribute_hidden;
extern void __tzset_parse_tz (const char *tz) attribute_hidden;
-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 attribute_hidden;

/* Subroutine of `mktime'. Return the `time_t' representation of TP and
@@ -56,18 +56,47 @@ extern time_t __mktime_internal (struct tm *__tp,
struct tm *(*__func) (const time_t *,
struct tm *),
long int *__offset) attribute_hidden;
+
+/* nis/nis_print.c needs ctime, so even if ctime is not declared here,
+ we define __ctime64 as ctime so that nis/nis_print.c can get linked
+ against a function called ctime. */
+#if __TIMESIZE == 64
+# define __ctime64 ctime
+#endif
+
+#if __TIMESIZE == 64
+# define __localtime64 localtime
+#else
+extern struct tm *__localtime64 (const __time64_t *__timer);
+#endif
+
extern struct tm *__localtime_r (const time_t *__timer,
struct tm *__tp) attribute_hidden;

+#if __TIMESIZE == 64
+# define __localtime64_r __localtime_r
+#else
+extern struct tm *__localtime64_r (const __time64_t *__timer,
+ struct tm *__tp) attribute_hidden;
+#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
+# define __gmtime64_r __gmtime_r
+#else
+extern struct tm *__gmtime64_r (const __time64_t *__restrict __timer,
+ struct tm *__restrict __tp);
+#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) attribute_hidden;

@@ -76,8 +105,8 @@ extern char *__asctime_r (const struct tm *__tp, char *__buf)
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) attribute_hidden;
+extern struct tm *__tz_convert (__time64_t timer, int use_localtime,
+ struct tm *tp) attribute_hidden;

extern int __nanosleep (const struct timespec *__requested_time,
struct timespec *__remaining);
diff --git a/time/ctime.c b/time/ctime.c
index 1222614f29..286c6b579c 100644
--- a/time/ctime.c
+++ b/time/ctime.c
@@ -20,9 +20,22 @@
/* Return a string as returned by asctime which
is the representation of *T in that form. */
char *
-ctime (const time_t *t)
+__ctime64 (const __time64_t *t)
{
/* The C Standard says ctime (t) is equivalent to asctime (localtime (t)).
In particular, ctime and asctime must yield the same pointer. */
- return asctime (localtime (t));
+ return asctime (__localtime64 (t));
}
+
+/* Provide a 32-bit wrapper if needed */
+
+#if __TIMESIZE != 64
+
+char *
+ctime (const time_t *t)
+{
+ __time64_t t64 = *t;
+ return __ctime64 (&t64);
+}
+
+#endif
diff --git a/time/ctime_r.c b/time/ctime_r.c
index c111146d76..84089599a7 100644
--- a/time/ctime_r.c
+++ b/time/ctime_r.c
@@ -22,8 +22,21 @@
/* Return a string as returned by asctime which is the representation
of *T in that form. Reentrant version. */
char *
-ctime_r (const time_t *t, char *buf)
+__ctime64_r (const __time64_t *t, char *buf)
{
struct tm tm;
- return __asctime_r (__localtime_r (t, &tm), buf);
+ return __asctime_r (__localtime64_r (t, &tm), buf);
}
+
+/* Provide a 32-bit wrapper if needed */
+
+#if __TIMESIZE != 64
+
+char *
+ctime_r (const time_t *t, char *buf)
+{
+ __time64_t t64 = *t;
+ return __ctime64_r (&t64, buf);
+}
+
+#endif
diff --git a/time/gmtime.c b/time/gmtime.c
index dc33b3e68a..d485a38c6f 100644
--- a/time/gmtime.c
+++ b/time/gmtime.c
@@ -18,20 +18,49 @@

#include <time.h>

-/* Return the `struct tm' representation of *T in UTC,
+/* Return the `struct tm' representation of T in UTC,
using *TP to store the result. */
+struct tm *
+__gmtime64_r (const __time64_t *t, struct tm *tp)
+{
+ return __tz_convert (*t, 0, tp);
+}
+
+/* Provide a 32-bit wrapper if needed */
+
+#if __TIMESIZE != 64
+
struct tm *
__gmtime_r (const time_t *t, struct tm *tp)
{
- return __tz_convert (t, 0, tp);
+ __time64_t t64 = *t;
+ return __gmtime64_r (&t64, tp);
}
+
+#endif
+
+/* This always works because either __TIMESIZE != 64 and __gmtime_r exists
+ or __TIMESIZE == 64 and the definition of __gmtime64_r above actually
+ defined __gmtime_r. */
libc_hidden_def (__gmtime_r)
weak_alias (__gmtime_r, gmtime_r)

+/* Return the `struct tm' representation of 64-bit-time *T in UTC. */
+struct tm *
+__gmtime64 (const __time64_t *t)
+{
+ return __tz_convert (*t, 0, &_tmbuf);
+}
+
+/* Provide a 32-bit wrapper if needed */
+
+#if __TIMESIZE != 64

-/* Return the `struct tm' representation of *T in UTC. */
struct tm *
gmtime (const time_t *t)
{
- return __tz_convert (t, 0, &_tmbuf);
+ __time64_t t64 = *t;
+ return __gmtime64 (&t64);
}
+
+#endif
diff --git a/time/localtime.c b/time/localtime.c
index 8684a8a971..e36d6ccaca 100644
--- a/time/localtime.c
+++ b/time/localtime.c
@@ -21,21 +21,49 @@
/* The C Standard says that localtime and gmtime return the same pointer. */
struct tm _tmbuf;

-
/* 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_convert (*t, 1, tp);
+}
+
+/* Provide a 32-bit wrapper if needed */
+
+#if __TIMESIZE != 64
+
struct tm *
__localtime_r (const time_t *t, struct tm *tp)
{
- return __tz_convert (t, 1, tp);
+ __time64_t t64 = *t;
+ return __localtime64_r (&t64, tp);
}
-weak_alias (__localtime_r, localtime_r)

+#endif
+
+/* This always works because either __TIMESIZE != 64 and __localtime_r
+ exists or __TIMESIZE == 64 and the definition of __localtime64_r above
+ actually defined __localtime_r. */
+weak_alias (__localtime_r, localtime_r)

/* Return the `struct tm' representation of *T in local time. */
+struct tm *
+__localtime64 (const __time64_t *t)
+{
+ return __tz_convert (*t, 1, &_tmbuf);
+}
+
+/* Provide a 32-bit wrapper if needed */
+
+#if __TIMESIZE != 64
+
struct tm *
localtime (const time_t *t)
{
- return __tz_convert (t, 1, &_tmbuf);
+ __time64_t t64 = *t;
+ return __localtime64 (&t64);
}
libc_hidden_def (localtime)
+
+#endif
diff --git a/time/offtime.c b/time/offtime.c
index 04c48389fc..3309fcd484 100644
--- a/time/offtime.c
+++ b/time/offtime.c
@@ -21,18 +21,18 @@
#define SECS_PER_HOUR (60 * 60)
#define SECS_PER_DAY (SECS_PER_HOUR * 24)

-/* Compute the `struct tm' representation of *T,
+/* 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. */
int
-__offtime (const time_t *t, long int offset, struct tm *tp)
+__offtime (__time64_t t, long int offset, struct tm *tp)
{
- time_t days, rem, y;
+ __time64_t days, rem, y;
const unsigned short int *ip;

- days = *t / SECS_PER_DAY;
- rem = *t % SECS_PER_DAY;
+ days = t / SECS_PER_DAY;
+ rem = t % SECS_PER_DAY;
rem += offset;
while (rem < 0)
{
@@ -60,7 +60,7 @@ __offtime (const time_t *t, long int offset, struct tm *tp)
while (days < 0 || days >= (__isleap (y) ? 366 : 365))
{
/* Guess a corrected year, assuming 365 days per year. */
- time_t yg = y + days / 365 - (days % 365 < 0);
+ __time64_t yg = y + days / 365 - (days % 365 < 0);

/* Adjust DAYS and Y to match the guessed year. */
days -= ((yg - y) * 365
diff --git a/time/tzfile.c b/time/tzfile.c
index 844a68de8c..3920525bf3 100644
--- a/time/tzfile.c
+++ b/time/tzfile.c
@@ -633,16 +633,10 @@ __tzfile_compute (__time64_t timer, int use_localtime,

/* Convert to broken down structure. If this fails do not
use the string. */
- {
- time_t truncated = timer;
- if (__glibc_unlikely (truncated != timer
- || ! __offtime (&truncated, 0, tp)))
- goto use_last;
- }
-
- /* Use the rules from the TZ string to compute the change.
- timer fits into time_t due to the truncation check
- above. */
+ if (__glibc_unlikely (! __offtime (timer, 0, tp)))
+ goto use_last;
+
+ /* Use the rules from the TZ string to compute the change. */
__tz_compute (timer, tp, 1);

/* If tzspec comes from posixrules loaded by __tzfile_default,
diff --git a/time/tzset.c b/time/tzset.c
index a828b9fb75..834cc3ccec 100644
--- a/time/tzset.c
+++ b/time/tzset.c
@@ -16,7 +16,6 @@
<http://www.gnu.org/licenses/>. */

#include <ctype.h>
-#include <errno.h>
#include <libc-lock.h>
#include <stdbool.h>
#include <stddef.h>
@@ -27,7 +26,7 @@

#include <timezone/tzfile.h>

-#define SECSPERDAY ((time_t) 86400)
+#define SECSPERDAY ((__time64_t) 86400)

char *__tzname[2] = { (char *) "GMT", (char *) "GMT" };
int __daylight = 0;
@@ -55,7 +54,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;

@@ -416,7 +415,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 = -1;
update_vars ();
return;
}
@@ -424,13 +423,13 @@ tzset_internal (int always)
__tzset_parse_tz (tz);
}

-/* Figure out the exact time (as a time_t) in YEAR
+/* Figure out the exact time (as a __time64_t) in YEAR
when the change described by RULE will occur and
put it in RULE->change, saving YEAR in RULE->computed_for. */
static void
compute_change (tz_rule *rule, int year)
{
- time_t t;
+ __time64_t t;

if (year != -1 && rule->computed_for == year)
/* Operations on times in 2 BC will be slower. Oh well. */
@@ -516,7 +515,7 @@ compute_change (tz_rule *rule, int year)
/* Figure out the correct timezone for TM and set `__tzname',
`__timezone', and `__daylight' accordingly. */
void
-__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);
@@ -562,20 +561,14 @@ __tzset (void)
}
weak_alias (__tzset, tzset)

-/* Return the `struct tm' representation of *TIMER in the local timezone.
+/* Return the `struct tm' representation of TIMER in the local timezone.
Use local time if USE_LOCALTIME is nonzero, UTC otherwise. */
struct tm *
-__tz_convert (const time_t *timer, int use_localtime, struct tm *tp)
+__tz_convert (__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.
@@ -584,14 +577,14 @@ __tz_convert (const time_t *timer, int use_localtime, struct tm *tp)
tzset_internal (tp == &_tmbuf && use_localtime);

if (__use_tzfile)
- __tzfile_compute (*timer, use_localtime, &leap_correction,
+ __tzfile_compute (timer, use_localtime, &leap_correction,
&leap_extra_secs, tp);
else
{
if (! __offtime (timer, 0, tp))
tp = NULL;
else
- __tz_compute (*timer, tp, use_localtime);
+ __tz_compute (timer, tp, use_localtime);
leap_correction = 0L;
leap_extra_secs = 0;
}

--
2.17.1

Joseph Myers

2018-09-26 16:14:06 UTC

Post by Albert ARIBAUD (3ADEV)
Now that __time_64_t exists, we can switch internal function
__tz_convert from 32-bit to 64-bit time. This involves switching
some other internal functions and turning some implementations
which use these into wrappers between public 32-bit and internal
64-bit time.

You're missing the information about what platforms this patch was tested
on with the full glibc testsuite. That's critical information for such a
patch submission, which needs testing on both 32-bit and 64-bit platforms.
(Later patches supporting using new syscalls will need testing on
additional configurations, including building with old kernel headers;
building with kernel headers with the new syscalls but running on a kernel
without them; and building with new kernel headers and running on a kernel
with the new syscalls.)

--
Joseph S. Myers
***@codesourcery.com

Albert ARIBAUD

2018-09-29 11:41:08 UTC

Hi Joseph,

On Wed, 26 Sep 2018 16:14:06 +0000, Joseph Myers

I've started with the simplest case for me, a native x86_64 test on
a Xubuntu 18.04 machine with gcc 7.3.0. This is how I did it:

$ cd /home/3adev/glibc/build
$ /home/3dev/glibc/src/configure --prefix /home/3adev/glibc/local
$ make -j3
$ make -j3 check

Running this with /home/3dev/glibc/{build,local} empty,
and /home/3dev/glibc/src being a checkout of tag glibc-2.28, that is,
without any patches of mine.

I end up with

Post by Joseph Myers
[...]
132 FAIL
5788 PASS
11 UNSUPPORTED
17 XFAIL
2 XPASS
Makefile:345: recipe for target 'tests' failed
make[1]: *** [tests] Error 1
make[1] : on quitte le répertoire « /home/3adev/glibc/src »
Makefile:9: recipe for target 'check' failed
make: *** [check] Error 2

Is it normal that the make check fail with a non-zero number of FAIL and
XFAIL?

If it is not a normal result, then what could possibly cause it
considering I am building the official glibc 2.28?

Is it is a normal result (i.e. this release of glibc is known to FAIL
and XFAIL this way for x86_64), then where can I find the expected FAIL
and XFAIL details for a given architecture and a given release of glibc?

Cordialement,
Albert ARIBAUD
3ADEV

Joseph Myers

2018-09-30 13:37:58 UTC

Post by Albert ARIBAUD

Post by Joseph Myers
[...]
132 FAIL
5788 PASS
11 UNSUPPORTED
17 XFAIL
2 XPASS
Makefile:345: recipe for target 'tests' failed
make[1]: *** [tests] Error 1
make[1]Â : on quitte le rÃ©pertoire Â«Â /home/3adev/glibc/srcÂ Â»
Makefile:9: recipe for target 'check' failed
make: *** [check] Error 2

Is it normal that the make check fail with a non-zero number of FAIL and
XFAIL?

You should expect XFAILs (for example, for conform/ tests that
deliberately test features of the relevant standard that are either not
provided by glibc, or are deliberately unsupported).

You should not expect anything like 132 FAILs; you'll need to get a
working configuration for testing without so many FAILs on unmodified
sources before you can effectively test proposed patches.

Post by Albert ARIBAUD
Is it is a normal result (i.e. this release of glibc is known to FAIL
and XFAIL this way for x86_64), then where can I find the expected FAIL
and XFAIL details for a given architecture and a given release of glibc?

See the per-release wiki pages, e.g.
<https://sourceware.org/glibc/wiki/Release/2.28>. That shows 17 XFAILs as
expected for x86_64, but no FAILs. (Ignore the results for WSL - the
Windows subsystem for Linux emulation - all they show is defects in that
subsystem, it's not a suitable environment for normal glibc testing.)

On Ubuntu 18.04 (using a locally built compiler - if you do that, note you
need to copy libgcc_s.so.* and libstdc++.so.* into the build directory
before running the tests) I get two FAILs:

FAIL: resolv/tst-resolv-ai_idn
FAIL: resolv/tst-resolv-ai_idn-latin1

Those appear in the architecture-independent section of the wiki page, for
systems with too-old libidn2.

For 32-bit testing on 64-bit Ubuntu 18.04 (again, with a locally built
compiler) I get one FAIL:

FAIL: nss/tst-nss-test3

--
Joseph S. Myers
***@codesourcery.com

Albert ARIBAUD

2018-10-04 11:09:00 UTC

Hi Joseph,

Le Sun, 30 Sep 2018 13:37:58 +0000, Joseph Myers

Post by Albert ARIBAUD

Is it normal that the make check fail with a non-zero number of FAIL and
XFAIL?

You should expect XFAILs (for example, for conform/ tests that
deliberately test features of the relevant standard that are either not
provided by glibc, or are deliberately unsupported).
You should not expect anything like 132 FAILs; you'll need to get a
working configuration for testing without so many FAILs on unmodified
sources before you can effectively test proposed patches.

See the per-release wiki pages, e.g.
<https://sourceware.org/glibc/wiki/Release/2.28>. That shows 17 XFAILs as
expected for x86_64, but no FAILs. (Ignore the results for WSL - the
Windows subsystem for Linux emulation - all they show is defects in that
subsystem, it's not a suitable environment for normal glibc testing.)
On Ubuntu 18.04 (using a locally built compiler - if you do that, note you
need to copy libgcc_s.so.* and libstdc++.so.* into the build directory
FAIL: resolv/tst-resolv-ai_idn
FAIL: resolv/tst-resolv-ai_idn-latin1
Those appear in the architecture-independent section of the wiki page, for
systems with too-old libidn2.
For 32-bit testing on 64-bit Ubuntu 18.04 (again, with a locally built
FAIL: nss/tst-nss-test3

I'd run make check in the past without these errors, hence my surprise.
Apparently, the issue lies with the value of --prefix at configure
time; It was not /usr, whereas if it is, and on a X86_64 machine, I do:

mkdir temp
cd temp
git clone git://sourceware.org/git/glibc.git src
cd src
git checkout origin/release/2.28/master
cd ..
mkdir build
cd build
./configure --prefix=/usr
make
make check

I end up with

UNSUPPORTED: elf/tst-audit10
UNSUPPORTED: elf/tst-avx512
XPASS: elf/tst-protected1a
XPASS: elf/tst-protected1b
UNSUPPORTED: math/test-double-libmvec-alias-avx512
UNSUPPORTED: math/test-double-libmvec-alias-avx512-main
UNSUPPORTED: math/test-double-libmvec-sincos-avx512
UNSUPPORTED: math/test-float-libmvec-alias-avx512
UNSUPPORTED: math/test-float-libmvec-alias-avx512-main
UNSUPPORTED: math/test-float-libmvec-sincosf-avx512
UNSUPPORTED: misc/tst-pkey
FAIL: resolv/tst-resolv-ai_idn
FAIL: resolv/tst-resolv-ai_idn-latin1
Summary of test results:
2 FAIL
5924 PASS
9 UNSUPPORTED
17 XFAIL
2 XPASS

Which I assume is fine, as the two FAILs are the libidn2 ones.

I take this result as a reference and am running make check now on
patches applied above release/2.28/master; If the results are the
same as the reference, I'll consider the patches good for resubmission.

Cordialement,
Albert ARIBAUD
3ADEV

Joseph Myers

2018-10-04 12:14:46 UTC

Post by Albert ARIBAUD
Which I assume is fine, as the two FAILs are the libidn2 ones.

Yes, those results are fine.

Post by Albert ARIBAUD
I take this result as a reference and am running make check now on
patches applied above release/2.28/master; If the results are the
same as the reference, I'll consider the patches good for resubmission.

Note that you should test for a 32-bit configuration as well - this
applies to pretty much all the patches for 64-bit time, they need testing
for both 32-bit and 64-bit configurations (some will need other testing,
e.g. with kernels with the Y2038 patches included, but that doesn't apply
to this one).

It should be possible to test natively for 32-bit on a 64-bit system if
you install the relevant OS packages for 32-bit libraries (including
development packages), and specify CC="gcc -m32" CXX="g++ -m32" when
configuring for i686-pc-linux-gnu, but I haven't tried that using OS
compiler packages (I test natively for 32-bit on a 64-bit system, but
using locally built compilers).

--
Joseph S. Myers
***@codesourcery.com

Albert ARIBAUD

2018-10-04 13:40:52 UTC

Hi Joseph,

Le Thu, 4 Oct 2018 12:14:46 +0000, Joseph Myers

Post by Albert ARIBAUD
Which I assume is fine, as the two FAILs are the libidn2 ones.

Yes, those results are fine.

Ok.

Note that you should test for a 32-bit configuration as well - this
applies to pretty much all the patches for 64-bit time, they need testing
for both 32-bit and 64-bit configurations (some will need other testing,
e.g. with kernels with the Y2038 patches included, but that doesn't apply
to this one).
It should be possible to test natively for 32-bit on a 64-bit system if
you install the relevant OS packages for 32-bit libraries (including
development packages), and specify CC="gcc -m32" CXX="g++ -m32" when
configuring for i686-pc-linux-gnu, but I haven't tried that using OS
compiler packages (I test natively for 32-bit on a 64-bit system, but
using locally built compilers).

I'll launch a test once the current jobs have finished running, however
I've got a physical 32-bit ARM system with a Debian Stretch distro, so
I'll most certainly go the simpler native route for now, at least until
I get to test on on really many systems, at which point I'll include
the "32-bit on 64-bit" case too.

Cordialement,
Albert ARIBAUD
3ADEV

Albert ARIBAUD

2018-10-04 14:36:51 UTC

Hi Albert,

On Thu, 4 Oct 2018 15:40:52 +0200, Albert ARIBAUD

Post by Albert ARIBAUD
Hi Joseph,
Le Thu, 4 Oct 2018 12:14:46 +0000, Joseph Myers

Post by Albert ARIBAUD
Which I assume is fine, as the two FAILs are the libidn2 ones.

Yes, those results are fine.

Ok.

BTW, one quick question re the summary shown at the end of a make
check.

Here I get

Summary of test results:
2 FAIL
5924 PASS
9 UNSUPPORTED
17 XFAIL
2 XPASS

I assumed that for each category (FAIL, PASS, UNSUPPORTED, XFAIL,
XPASS) the number before it was equal to the number of files named
"*.test-result" whose content started with said category, so for
instance if I ran the command:

find . -name "*.test-result" -exec grep ^FAIL: {} \; | wc -l

The output would be 2, because there are 2 FAIL results.

While the summary and grep agree for FAIL (2), UNSUPPORTED (9), XFAIL
(17) and XPASS (2), they disagree on PASS: the results say 5924, the
grep says 6018.

Also, the total number of files named "*.test-result" is 6048, which
equals 6018 + 2 + 9 +17 + 2 -- in other words, it is as if some actual
"PASS" test results were not counted in the summary.

Could anyone explain to me why the summary PASS count and the actual
PASS result file count disagree?

Cordialement,
Albert ARIBAUD
3ADEV

Joseph Myers

2018-10-04 14:48:46 UTC

Post by Albert ARIBAUD
Could anyone explain to me why the summary PASS count and the actual
PASS result file count disagree?

The rules for generating some files used in the testsuite generate the
.test-result files; those files are not listed in tests-special as being
tests, but some other similar files, using the same makefile rules, are so
listed, hence the files being generated. It's the settings of tests and
tests-special in each subdirectory that determine what counts as a test
for the purposes of the summaries.

(I think the files in question probably *should* be listed in
tests-special.)

--
Joseph S. Myers
***@codesourcery.com

Florian Weimer

2018-09-26 08:39:59 UTC

Post by Albert ARIBAUD (3ADEV)
diff --git a/posix/bits/types.h b/posix/bits/types.h
index 5e22ce41bf..cda0a70dd8 100644
--- a/posix/bits/types.h
+++ b/posix/bits/types.h
@@ -211,6 +213,12 @@ __STD_TYPE __U32_TYPE __socklen_t;
It is not currently necessary for this to be machine-specific. */
typedef int __sig_atomic_t;
+#if __TIMESIZE == 64
+# define __time64_t __time_t
+#else
+__STD_TYPE __TIME64_T_TYPE __time64_t; /* Seconds since the Epoch. */
+#endif

Should the __TIMESIZE == 64 case use typedef as well?

Post by Albert ARIBAUD (3ADEV)
diff --git a/sysdeps/unix/sysv/linux/x86/bits/time64.h b/sysdeps/unix/sysv/linux/x86/bits/time64.h
new file mode 100644
index 0000000000..81de09e23f
--- /dev/null
+++ b/sysdeps/unix/sysv/linux/x86/bits/time64.h
+#if defined __x86_64__ && defined __ILP32__
+/* For x32, time is 64-bit even though word size is 32-bit. */
+# define __TIME64_T_TYPE __SQUAD_TYPE
+#elif __TIMESIZE == 64
+/* If we already have 64-bit time then use it. */
+# define __TIME64_T_TYPE __TIME_T_TYPE
+#else
+/* Define a 64-bit type alongsize the 32-bit one. */
+# define __TIME64_T_TYPE __SQUAD_TYPE
+#endif

Perhaps I'm missing something, but I think this should be put into a
generic header and could be written like this:

#if __TIMESIZE == 64
# define __TIME64_T_TYPE __TIME_T_TYPE
#else
# if __WORDSIZE != 32
# error "32-bit word size expected for non-64-bit time_t"
# endif
# define __TIME64_T_TYPE __SQUAD_TYPE
#endif

I don't think there is a 64-bit port with a 32-bit time_t.

Post by Albert ARIBAUD (3ADEV)
diff --git a/sysdeps/unix/sysv/linux/x86/bits/timesize.h b/sysdeps/unix/sysv/linux/x86/bits/timesize.h
new file mode 100644
index 0000000000..8b88ab84b0
--- /dev/null
+++ b/sysdeps/unix/sysv/linux/x86/bits/timesize.h
+#if defined __x86_64__ && defined __ILP32__
+/* For x32, time is 64-bit even though word size is 32-bit. */
+# define __TIMESIZE 64
+#else
+/* For others, time size is word size. */
+# define __TIMESIZE __WORDSIZE
+#endif

I think writing this as

#ifdef __x86_64__
/* This includes x32, where time_t is 64-bit even though the word size
is 32-bit. */
# define __TIMESIZE 64
#else
# define __TIMESIZE 32
#endif

is much clearer. It's not that there's going to be a different x86-64
API with yet another time_t size any time soon.

Post by Albert ARIBAUD (3ADEV)
index 72ef75f074..844a68de8c 100644
--- a/time/tzfile.c
+++ b/time/tzfile.c

The tzfile.c changes look okay to me.

Thanks,
Florian

Albert ARIBAUD

2018-09-26 14:39:50 UTC

Hi Florian,

Should the __TIMESIZE == 64 case use typedef as well?

It was requested that the Y038 code cause as little change as possible
at the object level in the TIMESIZE == 64 case, hence the #define which
ensures that after the preprocessor stage, the compiler can only see
'time_t', not 'time64_t'.

Perhaps I'm missing something, but I think this should be put into a
#if __TIMESIZE == 64
# define __TIME64_T_TYPE __TIME_T_TYPE
#else
# if __WORDSIZE != 32
# error "32-bit word size expected for non-64-bit time_t"
# endif
# define __TIME64_T_TYPE __SQUAD_TYPE
#endif
I don't think there is a 64-bit port with a 32-bit time_t.

The patch does provide definitions for __TIMESIZE and __TIME64_T_TYPE
in generic headers (bits/timesize and bits/time64.h respectively)
which cover all cases for all 64-bit architectures and all 32-bit
architectures.

Since the only exception is X32, it makes sense that the definitions
which take this exception into account be put in the most X32 specific
header, which is the x86 one.

This organization stems from previous comments by Joseph Myers:

https://patchwork.ozlabs.org/patch/930876/#1935670

I think writing this as
#ifdef __x86_64__
/* This includes x32, where time_t is 64-bit even though the word size
is 32-bit. */
# define __TIMESIZE 64
#else
# define __TIMESIZE 32
#endif
is much clearer. It's not that there's going to be a different x86-64
API with yet another time_t size any time soon.

I prefer the #if/#else condition to explicitly involve x32
(through the symbol __ILP32__) rather than implicitly.

Post by Albert ARIBAUD (3ADEV)
index 72ef75f074..844a68de8c 100644
--- a/time/tzfile.c
+++ b/time/tzfile.c

The tzfile.c changes look okay to me.

Thanks!

Post by Florian Weimer
Thanks,
Florian

Cordialement,
Albert ARIBAUD
3ADEV

Florian Weimer

2018-09-26 14:43:19 UTC

Post by Albert ARIBAUD
Hi Florian,

Should the __TIMESIZE == 64 case use typedef as well?

The patch does provide definitions for __TIMESIZE and __TIME64_T_TYPE
in generic headers (bits/timesize and bits/time64.h respectively)
which cover all cases for all 64-bit architectures and all 32-bit
architectures.
Since the only exception is X32, it makes sense that the definitions
which take this exception into account be put in the most X32 specific
header, which is the x86 one.

My concern is that x32 is the only exception today, but future ports
will need the logic I sketched above as well.

Post by Albert ARIBAUD
https://patchwork.ozlabs.org/patch/930876/#1935670

Sorry. 8-(

Florian

Joseph Myers

2018-09-26 16:10:59 UTC