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

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

[Albert ARIBAUD (3ADEV)]

glibc support for 64-bit time_t on 32-bit architectures
will involve:

- Using 64-bit times inside glibc, with conversions
  to and from 32-bit times taking place as necessary
  for interfaces using such times.

- Adding 64-bit-time support in the glibc public API.
  This support should be dynamic, i.e. iglibc should
  provide both 32-bit and 64-bit implementations and
   let user code choose at compile time whether to use
   the 32-bit or 64-bit interfaces.

This requires a glibc-internal name for a type for times
that are always 64-bit.

To determine whether the default time_t interfaces are 32-bit
and so need conversions, or are 64-bit and so are compatible
with the internal 64-bit type without conversions, a macro
giving the size of the  default time_t is also required.
This macro is called __TIMESIZE.

Based on __TIMESIZE, a new macro is defined, __TIME64_T_TYPE,
 which is always the right __*_T_TYPE to hold a 64-bit-time.
__TIME64_T_TYPE equals __TIME_T_TYPE if __TIMESIZE equals 64
and equals __SQUAD_T_TYPE otherwise.

__time64_t can then replace uses of internal_time_t.

* bit/time64.h: New file.
* bits/timesize: (__TIMESIZE): New macro.
* include/time.h: replace internal_time_t with __time64_t.
* posix/bits/types (__time64_t): Add.
* stdlib/Makefile: Add bits/time64.h to includes.
* stdlib/Makefile: Add bits/timesize.h to includes.
* sysdeps/unix/sysv/linux/x86/bits/time64.h: New file.
* sysdeps/unix/sysv/linux/x86/bits/timesize.h (__TIMESIZE): New macro.
---
 bits/time64.h                               | 38 +++++++++++++++++++
 bits/timesize.h                             | 22 +++++++++++
 include/time.h                              |  7 +---
 posix/bits/types.h                          |  8 ++++
 stdlib/Makefile                             |  2 +-
 sysdeps/unix/sysv/linux/x86/bits/time64.h   | 41 +++++++++++++++++++++
 sysdeps/unix/sysv/linux/x86/bits/timesize.h | 25 +++++++++++++
 time/tzfile.c                               | 18 ++++-----
 8 files changed, 145 insertions(+), 16 deletions(-)
 create mode 100644 bits/time64.h
 create mode 100644 bits/timesize.h
 create mode 100644 sysdeps/unix/sysv/linux/x86/bits/time64.h
 create mode 100644 sysdeps/unix/sysv/linux/x86/bits/timesize.h

diff --git a/bits/time64.h b/bits/time64.h
new file mode 100644
index 0000000000..4fd60fef7e
--- /dev/null
+++ b/bits/time64.h
@@ -0,0 +1,38 @@
+/* bits/time64.h -- underlying types for __time64_t.  Generic version.
+   Copyright (C) 2018 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, see
+   <http://www.gnu.org/licenses/>.  */
+
+#ifndef _BITS_TYPES_H
+# error "Never include <bits/time64.h> directly; use <sys/types.h> instead."
+#endif
+
+#ifndef	_BITS_TIME64_H
+#define	_BITS_TIME64_H	1
+
+/* Define __TIME64_T_TYPE so that it is always a 64-bit type.
+ * On 64-bit platforms and X32, there is already a 64-bit time.
+ * On 32-bit platforms except X32, we need to create one.  */
+
+#if __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
+
+#endif /* bits/time64.h */
diff --git a/bits/timesize.h b/bits/timesize.h
new file mode 100644
index 0000000000..cc47ff165f
--- /dev/null
+++ b/bits/timesize.h
@@ -0,0 +1,22 @@
+/* Bit size of the time_t type at glibc build time, general case.
+   Copyright (C) 2018 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, see
+   <http://www.gnu.org/licenses/>.  */
+
+#include <bits/wordsize.h>
+
+/* Size in bits of the 'time_t' type of the default ABI.  */
+#define __TIMESIZE	__WORDSIZE
diff --git a/include/time.h b/include/time.h
index e30c5fc3b1..e99711a556 100644
--- a/include/time.h
+++ b/include/time.h
@@ -26,10 +26,6 @@ extern __typeof (clock_getcpuclockid) __clock_getcpuclockid;
 /* Now define the internal interfaces.  */
 struct tm;
 
-/* time_t variant for representing time zone data, independent of
-   time_t.  */
-typedef __int64_t internal_time_t;
-
 /* Defined in mktime.c.  */
 extern const unsigned short int __mon_yday[2][13] attribute_hidden;
 
@@ -43,7 +39,7 @@ extern int __use_tzfile attribute_hidden;
 
 extern void __tzfile_read (const char *file, size_t extra,
 			   char **extrap) attribute_hidden;
-extern void __tzfile_compute (internal_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) attribute_hidden;
 extern void __tzfile_default (const char *std, const char *dst,
@@ -101,7 +97,6 @@ extern char * __strptime_internal (const char *rp, const char *fmt,
 
 extern double __difftime (time_t time1, time_t time0);
 
-
 /* Use in the clock_* functions.  Size of the field representing the
    actual clock ID.  */
 #define CLOCK_IDFIELD_SIZE	3
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
@@ -25,6 +25,7 @@
 
 #include <features.h>
 #include <bits/wordsize.h>
+#include <bits/timesize.h>
 
 /* Convenience types.  */
 typedef unsigned char __u_char;
@@ -138,6 +139,7 @@ __extension__ typedef unsigned long long int __uintmax_t;
 # error
 #endif
 #include <bits/typesizes.h>	/* Defines __*_T_TYPE macros.  */
+#include <bits/time64.h>	/* Defines __TIME*_T_TYPE macros.  */
 
 
 __STD_TYPE __DEV_T_TYPE __dev_t;	/* Type of device numbers.  */
@@ -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
+
 #undef __STD_TYPE
 
 #endif /* bits/types.h */
diff --git a/stdlib/Makefile b/stdlib/Makefile
index 01194bbf7c..bdb0a18295 100644
--- a/stdlib/Makefile
+++ b/stdlib/Makefile
@@ -29,7 +29,7 @@ headers	:= stdlib.h bits/stdlib.h bits/stdlib-ldbl.h bits/stdlib-float.h      \
 	   ucontext.h sys/ucontext.h bits/indirect-return.h		      \
 	   alloca.h fmtmsg.h						      \
 	   bits/stdlib-bsearch.h sys/random.h bits/stdint-intn.h	      \
-	   bits/stdint-uintn.h
+	   bits/stdint-uintn.h bits/time64.h bits/timesize.h		      \
 
 routines	:=							      \
 	atof atoi atol atoll						      \
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
@@ -0,0 +1,41 @@
+/* bits/time64.h -- underlying types for __time64_t.  Linux/x86-64 version.
+   Copyright (C) 2018 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, see
+   <http://www.gnu.org/licenses/>.  */
+
+#ifndef _BITS_TYPES_H
+# error "Never include <bits/time64.h> directly; use <sys/types.h> instead."
+#endif
+
+#ifndef	_BITS_TIME64_H
+#define	_BITS_TIME64_H	1
+
+/* Define __TIME64_T_TYPE so that it is always a 64-bit type.
+ * On 64-bit platforms and X32, there is already a 64-bit time.
+ * On 32-bit platforms except X32, we need to create one.  */
+
+#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
+
+#endif /* bits/time64.h */
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
@@ -0,0 +1,25 @@
+/* Bit size of the time_t type at glibc build time, x86-64 and x32 case.
+   Copyright (C) 2018 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, see
+   <http://www.gnu.org/licenses/>.  */
+
+#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
diff --git a/time/tzfile.c b/time/tzfile.c
index 72ef75f074..844a68de8c 100644
--- a/time/tzfile.c
+++ b/time/tzfile.c
@@ -44,12 +44,12 @@ struct ttinfo
 
 struct leap
   {
-    internal_time_t transition;	/* Time the transition takes effect.  */
+    __time64_t transition;	/* Time the transition takes effect.  */
     long int change;		/* Seconds of correction to apply.  */
   };
 
 static size_t num_transitions;
-libc_freeres_ptr (static internal_time_t *transitions);
+libc_freeres_ptr (static __time64_t *transitions);
 static unsigned char *type_idxs;
 static size_t num_types;
 static struct ttinfo *types;
@@ -113,8 +113,8 @@ __tzfile_read (const char *file, size_t extra, char **extrap)
   size_t tzspec_len;
   char *new = NULL;
 
-  _Static_assert (sizeof (internal_time_t) == 8,
-		  "internal_time_t must be eight bytes");
+  _Static_assert (sizeof (__time64_t) == 8,
+		  "__time64_t must be eight bytes");
 
   __use_tzfile = 0;
 
@@ -217,9 +217,9 @@ __tzfile_read (const char *file, size_t extra, char **extrap)
 
   if (__builtin_expect (num_transitions
 			> ((SIZE_MAX - (__alignof__ (struct ttinfo) - 1))
-			   / (sizeof (internal_time_t) + 1)), 0))
+			   / (sizeof (__time64_t) + 1)), 0))
     goto lose;
-  total_size = num_transitions * (sizeof (internal_time_t) + 1);
+  total_size = num_transitions * (sizeof (__time64_t) + 1);
   total_size = ((total_size + __alignof__ (struct ttinfo) - 1)
 		& ~(__alignof__ (struct ttinfo) - 1));
   types_idx = total_size;
@@ -276,7 +276,7 @@ __tzfile_read (const char *file, size_t extra, char **extrap)
     goto lose;
 
   type_idxs = (unsigned char *) transitions + (num_transitions
-					       * sizeof (internal_time_t));
+					       * sizeof (__time64_t));
   types = (struct ttinfo *) ((char *) transitions + types_idx);
   zone_names = (char *) types + num_types * sizeof (struct ttinfo);
   leaps = (struct leap *) ((char *) transitions + leaps_idx);
@@ -578,7 +578,7 @@ __tzfile_default (const char *std, const char *dst,
 }
 \f
 void
-__tzfile_compute (internal_time_t timer, int use_localtime,
+__tzfile_compute (__time64_t timer, int use_localtime,
 		  long int *leap_correct, int *leap_hit,
 		  struct tm *tp)
 {
@@ -667,7 +667,7 @@ __tzfile_compute (internal_time_t timer, int use_localtime,
 	     initial search spot from it.  Half of a gregorian year
 	     has on average 365.2425 * 86400 / 2 = 15778476 seconds.
 	     The value i can be truncated if size_t is smaller than
-	     internal_time_t, but this is harmless because it is just
+	     __time64_t, but this is harmless because it is just
 	     a guess.  */
 	  i = (transitions[num_transitions - 1] - timer) / 15778476;
 	  if (i < num_transitions)
-- 
2.17.1

[PATCH v8 2/2] Y2038: make __tz_convert compatible with 64-bit-time

[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.

* __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);
 }
 \f
-/* 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)
 \f
-/* 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

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

[Florian Weimer]

* Albert ARIBAUD:

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

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

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

> index 72ef75f074..844a68de8c 100644
> --- a/time/tzfile.c
> +++ b/time/tzfile.c

The tzfile.c changes look okay to me.

Thanks,
Florian

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

[Albert ARIBAUD]

Hi Florian,

On Wed, 26 Sep 2018 10:39:59 +0200, Florian Weimer <fweimer@redhat.com>
wrote :

> * Albert ARIBAUD:
> 
> > 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?

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'.

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

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

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

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

> > index 72ef75f074..844a68de8c 100644
> > --- a/time/tzfile.c
> > +++ b/time/tzfile.c  
> 
> The tzfile.c changes look okay to me.

Thanks!

> Thanks,
> Florian

Cordialement,
Albert ARIBAUD
3ADEV

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

[Florian Weimer]

* Albert ARIBAUD:

> Hi Florian,
>
> On Wed, 26 Sep 2018 10:39:59 +0200, Florian Weimer <fweimer@redhat.com>
> wrote :
>
>> * Albert ARIBAUD:
>> 
>> > 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?
>
> 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'.
>
>> > 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.
>
> 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.

> This organization stems from previous comments by Joseph Myers:
>
> https://patchwork.ozlabs.org/patch/930876/#1935670

Sorry. 8-(

Florian

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

[Joseph Myers]

On Wed, 26 Sep 2018, Albert ARIBAUD (3ADEV) wrote:

> - Adding 64-bit-time support in the glibc public API.
>   This support should be dynamic, i.e. iglibc should

s/iglibc/glibc/

> +/* Define __TIME64_T_TYPE so that it is always a 64-bit type.
> + * On 64-bit platforms and X32, there is already a 64-bit time.
> + * On 32-bit platforms except X32, we need to create one.  */

I don't think the comments on the generic header should be referencing 
specific platforms such as x32 like that.

-- 
Joseph S. Myers
joseph@codesourcery.com

Re: [PATCH v8 2/2] Y2038: make __tz_convert compatible with 64-bit-time

[Joseph Myers]

On Wed, 26 Sep 2018, Albert ARIBAUD (3ADEV) wrote:

> 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
joseph@codesourcery.com

Re: [PATCH v8 2/2] Y2038: make __tz_convert compatible with 64-bit-time

[Albert ARIBAUD]

Hi Joseph,

On Wed, 26 Sep 2018 16:14:06 +0000, Joseph Myers
<joseph@codesourcery.com> wrote :

> On Wed, 26 Sep 2018, Albert ARIBAUD (3ADEV) wrote:
> 
> > 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.)

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

> [...]
> Summary of test results:                                       
>     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

Re: [PATCH v8 2/2] Y2038: make __tz_convert compatible with 64-bit-time

[Joseph Myers]

[-- Attachment #1: Type: text/plain, Size: 2027 bytes --]

On Sat, 29 Sep 2018, Albert ARIBAUD wrote:

> > [...]
> > Summary of test results:                                       
> >     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.

> 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
joseph@codesourcery.com

Re: [PATCH v8 2/2] Y2038: make __tz_convert compatible with 64-bit-time

[Albert ARIBAUD]

Hi Joseph,

Le Sun, 30 Sep 2018 13:37:58 +0000, Joseph Myers
<joseph@codesourcery.com> a écrit :

> On Sat, 29 Sep 2018, Albert ARIBAUD wrote:
> 
> > > [...]
> > > Summary of test results:                                       
> > >     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.
> 
> > 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

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

Re: [PATCH v8 2/2] Y2038: make __tz_convert compatible with 64-bit-time

[Joseph Myers]

On Thu, 4 Oct 2018, Albert ARIBAUD wrote:

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

Yes, those results are fine.

> 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
joseph@codesourcery.com

Re: [PATCH v8 2/2] Y2038: make __tz_convert compatible with 64-bit-time

[Albert ARIBAUD]

Hi Joseph,

Le Thu, 4 Oct 2018 12:14:46 +0000, Joseph Myers
<joseph@codesourcery.com> a écrit :

> On Thu, 4 Oct 2018, Albert ARIBAUD wrote:
> 
> > Which I assume is fine, as the two FAILs are the libidn2 ones.  
> 
> Yes, those results are fine.

Ok.

> > 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).

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

Re: [PATCH v8 2/2] Y2038: make __tz_convert compatible with 64-bit-time

[Albert ARIBAUD]

Hi Albert,

On Thu, 4 Oct 2018 15:40:52 +0200, Albert ARIBAUD
<albert.aribaud@3adev.fr> wrote :

> Hi Joseph,
> 
> Le Thu, 4 Oct 2018 12:14:46 +0000, Joseph Myers
> <joseph@codesourcery.com> a écrit :
> 
> > On Thu, 4 Oct 2018, Albert ARIBAUD wrote:
> >   
> > > 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

Re: [PATCH v8 2/2] Y2038: make __tz_convert compatible with 64-bit-time

[Joseph Myers]

On Thu, 4 Oct 2018, Albert ARIBAUD wrote:

> 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
joseph@codesourcery.com