aboutsummaryrefslogtreecommitdiff
path: root/sysdeps/unix
AgeCommit message (Collapse)Author
2018-10-24Y2038: add _TIME_BITS supportaaribaud/y2038Albert ARIBAUD (3ADEV)
This makes all previously defined Y2038-proof API types, functions and implementations the default when _TIME_BITS==64 and __WORDSIZE==32 (so that 64-bit architectures are unaffected). Note: it is assumed that the API is consistent, i.e. for each API type which is enabled here, all API functions which depend on this type are enabled and mapped to Y2038-proof implementations.
2018-10-24Y2038: add function select64Albert ARIBAUD (3ADEV)
2018-10-24Y2038: add function pselect64Albert ARIBAUD (3ADEV)
2018-10-24Y2038: add function __ntp_gettimex64Albert ARIBAUD (3ADEV)
2018-10-24Y2038: add function __ntp_gettime64Albert ARIBAUD (3ADEV)
2018-10-24Y2038: add struct __ntp_timeval64Albert ARIBAUD (3ADEV)
2018-10-24Y2038: add functions using futexesAlbert ARIBAUD (3ADEV)
This creates 64-bit time versions of the following APIs: - pthread_rwlock_timedrdlock - pthread_rwlock_timedwrlock - pthread_mutex_timedlock - pthread_cond_timedwait - sem_timedwait - aio_suspend It also creates 64-bit time versions of the following functions or macros: - lll_timedlock_elision - lll_timedlock - __lll_timedlock_wait - futex_reltimed_wait_cancelable - lll_futex_timed_wait - __pthread_cond_wait_common - futex_abstimed_wait_cancelable - lll_futex_timed_wait_bitset - do_aio_misc_wait - AIO_MISC_WAIT - __new_sem_wait_slow - do_futex_wait - __pthread_rwlock_wrlock_full - __pthread_rwlock_rdlock_full - futex_abstimed_wait
2018-10-24Y2038: add function __adjtime64, __adjtimex64 and __ntp_adjtime64Albert ARIBAUD (3ADEV)
2018-10-24Y2038: add function __msgctl64Albert ARIBAUD (3ADEV)
2018-10-24Y2038: add function __mq_timedsend_time64Albert ARIBAUD (3ADEV)
2018-10-24Y2038: add function __mq_timedreceiv_time64Albert ARIBAUD (3ADEV)
2018-10-24Y2038: add function __utimes64Albert ARIBAUD (3ADEV)
2018-10-24Y2038: add function __stime64Albert ARIBAUD (3ADEV)
This implementation uses __settimeofday64. Therefore, on a system where current time-of-day is 32 bits, this implementation will fail for dates beyond Y2038.
2018-10-24Y2038: add function __settimeofday64Albert ARIBAUD (3ADEV)
Implementing a 64-bit settimeofday requires adding a new file to build under time/ and we cannot name that new file 'settimeofday.c' or it will break the 32-bit settimeofday file symbol, so we call it 'settimeofday64.c'.
2018-10-24Y2038: add function __gettimeofday64Albert ARIBAUD (3ADEV)
Implementing a 64-bit settimeofday requires adding a new file to build under time/ and we cannot name that new file 'settimeofday.c' or it will break the 32-bit settimeofday symbol, so we call it 'settimeofday64.c'.
2018-10-24Y2038: add function __fstatat64_time64 (and __fxstatat_time64)Albert ARIBAUD (3ADEV)
These implementations just use the existing syscalls and convert from kernel 32-bit-time struct stat64 to GLIBC Y2038-ready struct __stat64_t64.
2018-10-24Y2038: add function __lstat64_time64 (and __lxstat64_time64)Albert ARIBAUD (3ADEV)
These implementations just use the existing syscalls and convert from kernel 32-bit-time struct stat64 to GLIBC Y2038-ready struct __stat64_t64.
2018-10-24Y2038: add function __stat64_time64 (and __xstat64_time64)Albert ARIBAUD (3ADEV)
These implementations just use the existing syscalls and convert from kernel 32-bit-time struct stat64 to GLIBC Y2038-ready struct __stat64_t64.
2018-10-24Y2038: add function __fstat64_time64 (and __fxstat64_time64)Albert ARIBAUD (3ADEV)
These implementations just use the existing syscalls and convert from kernel 32-bit-time struct stat64 to GLIBC Y2038-ready struct __stat64_t64.
2018-10-24Y2038: add function __timerfd_settime64Albert ARIBAUD (3ADEV)
For Linux this uses the 32-bit time syscal, so it converts syscall input from 64-bit time into 32-bit time and syscall output from 32-bit time to 64-bit time.
2018-10-24Y2038: add function __timerfd_gettime64Albert ARIBAUD (3ADEV)
For Linux this uses the 32-bit time syscall so it converts the syscall output from 32-bit time to 64-bit time.
2018-10-24Y2038: add function __timer_settime64Albert ARIBAUD (3ADEV)
For Linux this uses a 32-bit syscall, so it converts the syscall input from 64-bit time into 32-bit time, and the syscall output from 32-bit time into 64-bit time.
2018-10-24Y2038: add function __timer_gettime64Albert ARIBAUD (3ADEV)
For Linux this uses the 32-bit time syscall, so it converts the syscall output into 64-bit time.
2018-10-24Y2038: add struct __itimerspec64Albert ARIBAUD (3ADEV)
2018-10-24Y2038: add function __lutimes64Albert ARIBAUD (3ADEV)
2018-10-24Y2038: add function __futimes64Albert ARIBAUD (3ADEV)
2018-10-24Y2038: add struct __timeval64Albert ARIBAUD (3ADEV)
Also, provide static inline functions and macros for checking and converting between 32-bit and 64-bit timevals.
2018-10-24Y2038: add function __sigtimedwait_time64Albert ARIBAUD (3ADEV)
2018-10-24Y2038: add function __futimens64Albert ARIBAUD (3ADEV)
2018-10-24Y2038: add function __utimensat_time64Albert ARIBAUD (3ADEV)
2018-10-24Y2038: add function __timespec_get64Albert ARIBAUD (3ADEV)
2018-10-24Y2038: add function __clock_nanosleep64Albert ARIBAUD (3ADEV)
Linux does not provide a 64-bit-time clock_nanosleep syscall, so __clock_nanosleep64 is a wrapper calling __clock_nanosleep, with one conversion before the call and possibly one after. Note: There is no point in implementing __clock_nanosleep64 directly around the 32-bit-time syscall and making __clock_nanosleep a wrapper around __clock_nanosleep64, because __clock_nanosleep64 would still need one or two conversions, and __clock_nanosleep would now also need those, adding a cost of 2 to 4 conversions in the worst case.
2018-10-24Y2038: add function __clock_getres_time64Albert ARIBAUD (3ADEV)
* include/time.h (__clock_getres_time64): Add. * sysdeps/posix/clock_getres.c (hp_timing_getres): Use struct __timespec64. * sysdeps/posix/clock_getres.c (realtime_getres): Likewise. * sysdeps/posix/clock_getres.c (__clock_getres_time64): Add. * sysdeps/posix/clock_getres.c Use SYSDEP_GETRES64. * sysdeps/posix/clock_getres.c Use SYSDEP_GETRES_CPU64. * sysdeps/posix/clock_getres.c (__clock_getres): Use __clock_getres_time64. * sysdeps/unix/sysv/linux/clock_getres.c (SYSCALL_GETRES32): Add. * sysdeps/unix/sysv/linux/clock_getres.c (SYSCALL_GETRES64): Likewise. * sysdeps/unix/sysv/linux/clock_getres.c (SYSDEP_GETRES64): Likewise. * sysdeps/unix/sysv/linux/clock_getres.c (SYSDEP_GETRES_CPU64): Likewise.
2018-10-24Y2038: add function __clock_settime64Albert ARIBAUD (3ADEV)
* include/time.h (__clock_settime64): Add. * sysdeps/unix/clock_settime.c (__clock_settime64): Add. * sysdeps/unix/sysv/linux/clock_settime.c (DO_CLOCK_SETTIME_32): Add. * sysdeps/unix/sysv/linux/clock_settime.c (DO_CLOCK_SETTIME_64): Add. * sysdeps/unix/sysv/linux/clock_settime.c (SYSDEP_SETTIME64_CPUTIME): Add. * sysdeps/unix/sysv/linux/clock_settime.c (SYSDEP_SETTIME64): Add.
2018-10-24Y2038: add function __clock_gettime64Albert ARIBAUD (3ADEV)
* include/time.h: Declare __clock_gettime64(). * ntpl/pthread_clock_gettime.c: Add __pthread_clock_gettime64(). * ntpl/pthread_clock_gettime.c: Make __pthread_clock_gettime() a wrapper around __pthread_clock_gettime64(). * sysdeps/unix/clock_gettime.c (hp_timing_gettime): Use struct __timespec64. * sysdeps/unix/clock_gettime.c (realtime_gettime): Likewise. * sysdeps/unix/clock_gettime.c: Add __clock_gettime64(). * sysdeps/unix/clock_gettime.c: Make __clock_gettime() a wrapper around __clock_gettime64(). * sysdeps/unix/sysv/linux/clock_gettime.c: Add 64-bit-time syscall support.
2018-10-24Y2038: provide kernel support indicationAlbert ARIBAUD (3ADEV)
Introduce __ASSUME_KERNEL_Y2038_SUPPORT which means that the underlying kernel *always* implements 64-bit-time Y2038-proof syscalls. If __ASSUME_KERNEL_Y2038_SUPPORT is not defined, glibc must check dynamically whether the underlying kernel provides these syscalls or not, and must fallback to 32-bit-time syscalls if not. Introduce function __y2038_get_kernel_support(), which returns true if the underlying kernel supports 64-bit-time syscalls. Also introduce function __y2038_set_kernel_support(), which allows an implementation to notify glibc of the absence of 64-bit-time syscalls (ENOSYS) so that they are not needlessly tried again. * misc/Makefile: Add module y2038-support. * misc/Versions: (__y2038_get_kernel_support): Add to GLIBC_PRIVATE. * misc/Versions: (__y2038_set_kernel_support): Likewise. * misc/y2038-support.c: New file. * misc/y2038-support.h: Likewise. * sysdeps/unix/sysv/linux/kernel-features.h (__ASSUME_KERNEL_Y2038_SUPPORT): Add. * sysdeps/unix/sysv/linux/y2038-support.c: New file. * sysdeps/unix/sysv/linux/y2038-support.h: New file.
2018-10-24 Y2038: provide size of default time_t for target architectureAlbert ARIBAUD (3ADEV)
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. This macro can then be used instead of __WORDSIZE in msq-pad.h and shm-pad.h files, which in turn allows removing their x86 variants, and in sem-pad.h files but keeping the x86 variant. This patch was tested by running 'make check' on branch master then applying this patch and running 'make check' again, and checking that both 'make check' yield identical results. This was done on x86_64-linux-gnu and i686-linux-gnu. * bits/timesize.h: New file. * stdlib/Makefile (headers): Add bits/timesize.h. * sysdeps/unix/sysv/linux/bits/msq-pad.h (__MSQ_PAD_AFTER_TIME): Use __TIMESIZE instead of __WORDSIZE. * sysdeps/unix/sysv/linux/bits/sem-pad.h (__SEM_PAD_AFTER_TIME): Likewise. * sysdeps/unix/sysv/linux/bits/shm-pad.h (__SHM_PAD_AFTER_TIME): Likewise. * sysdeps/unix/sysv/linux/hppa/bits/msq-pad.h (__MSQ_PAD_BEFORE_TIME): Likewise. * sysdeps/unix/sysv/linux/hppa/bits/sem-pad.h (__SEM_PAD_BEFORE_TIME): Likewise. * sysdeps/unix/sysv/linux/hppa/bits/shm-pad.h (__SHM_PAD_BEFORE_TIME, __SHM_PAD_BETWEEN_TIME_AND_SEGSZ): Likewise. * sysdeps/unix/sysv/linux/mips/bits/msq-pad.h (__MSQ_PAD_AFTER_TIME, __MSQ_PAD_BEFORE_TIME): Likewise. * sysdeps/unix/sysv/linux/powerpc/bits/msq-pad.h (__MSQ_PAD_BEFORE_TIME): Likewise. * sysdeps/unix/sysv/linux/powerpc/bits/sem-pad.h (__SEM_PAD_BEFORE_TIME): Likewise. * sysdeps/unix/sysv/linux/powerpc/bits/shm-pad.h (__SHM_PAD_BEFORE_TIME, __SHM_PAD_BETWEEN_TIME_AND_SEGSZ): Likewise. * sysdeps/unix/sysv/linux/sparc/bits/msq-pad.h (__MSQ_PAD_BEFORE_TIME): Likewise. * sysdeps/unix/sysv/linux/sparc/bits/sem-pad.h (__SEM_PAD_BEFORE_TIME): Likewise. * sysdeps/unix/sysv/linux/sparc/bits/shm-pad.h (__SHM_PAD_BEFORE_TIME): Likewise. * sysdeps/unix/sysv/linux/x86/bits/msq-pad.h: Delete file. * sysdeps/unix/sysv/linux/x86/bits/shm-pad.h: Likewise. * sysdeps/unix/sysv/linux/x86/bits/timesize.h: New file.
2018-10-23Don't use PSEUDO_END for non-PSEUDO functionAndreas Schwab
2018-10-22Update kernel version in syscall-names.list to 4.19.Joseph Myers
Linux 4.19 does not add any new syscalls (some existing ones are added to more architectures); this patch updates the version number in syscall-names.list to reflect that it's still current for 4.19. Tested with build-many-glibcs.py. * sysdeps/unix/sysv/linux/syscall-names.list: Update kernel version to 4.19.
2018-10-19signal: Use correct type for si_band in siginfo_t [BZ #23562]Ilya Yu. Malakhov
2018-10-18Add VDSO support to sparc.David S. Miller
* sysdeps/unix/sysv/linux/sparc/init-first.c: New file. * sysdeps/unix/sysv/linux/sparc/libc-vdso.h: New file. * sysdeps/unix/sysv/linux/sparc/Makefile: Add dl-vdso to sysdep_routines in subdir elf. * sysdeps/unix/sysv/linux/sparc/Versions: Add GLIBC_PRIVATE version for __vdso_clock_gettime. * sysdeps/unix/sysv/linux/sparc/sysdep.h (INTERNAL_VSYSCALL_CALL): Define. (HAVE_CLOCK_GETTIME_VSYSCALL): Define. (HAVE_GETTIMEOFDAY_VSYSCALL): Define.
2018-10-17Use single bits/shm.h for all architectures.Joseph Myers
After my patch to move SHMLBA to its own header, the bits/shm.h headers for architectures using the Linux kernel still vary in a few ways: the use of __syscall_ulong_t; whether padding for 32-bit systems is present before or after time fields, or missing altogether (mips, x32); whether shm_segsz is before or after the time fields; whether, if after time fields, there is extra padding before shm_segsz. This patch arranges for a single header to be used. __syscall_ulong_t is safe to use everywhere, while bits/shm-pad.h is added with new macros __SHM_PAD_AFTER_TIME, __SHM_PAD_BEFORE_TIME, __SHM_SEGSZ_AFTER_TIME and __SHM_PAD_BETWEEN_TIME_AND_SEGSZ to describe the differences. Tested for x86_64 and x86, and with build-many-glibcs.py. * sysdeps/unix/sysv/linux/Makefile (sysdep_headers): Add bits/shm-pad.h. * sysdeps/unix/sysv/linux/bits/shm.h: Include <bits/shm-pad.h>. (shmatt_t): Define as __syscall_ulong_t. (__SHM_PAD_TIME): New macro, depending on [__SHM_PAD_BEFORE_TIME] and [__SHM_PAD_AFTER_TIME]. (struct shmid_ds): Define time fields using __SHM_PAD_TIME. Define shm_segsz and associated padding based on [__SHM_SEGSZ_AFTER_TIME] and [__SHM_PAD_BETWEEN_TIME_AND_SEGSZ]. Use __syscall_ulong_t instead of unsigned long int. [__USE_MISC] (struct shminfo): Use __syscall_ulong_t instead of unsigned long int. [__USE_MISC] (struct shm_info): Likewise. * sysdeps/unix/sysv/linux/bits/shm-pad.h: New file. * sysdeps/unix/sysv/linux/hppa/bits/shm-pad.h: Likewise. * sysdeps/unix/sysv/linux/mips/bits/shm-pad.h: Likewise. * sysdeps/unix/sysv/linux/powerpc/bits/shm-pad.h: Likewise. * sysdeps/unix/sysv/linux/sparc/bits/shm-pad.h: Likewise. * sysdeps/unix/sysv/linux/x86/bits/shm-pad.h: Likewise. * sysdeps/unix/sysv/linux/hppa/bits/shm.h: Remove. * sysdeps/unix/sysv/linux/mips/bits/shm.h: Likewise. * sysdeps/unix/sysv/linux/powerpc/bits/shm.h: Likewise. * sysdeps/unix/sysv/linux/sparc/bits/shm.h: Likewise. * sysdeps/unix/sysv/linux/x86/bits/shm.h: Likewise.
2018-10-17Move SHMLBA to its own header.Joseph Myers
One difference between bits/shm.h headers for architectures using the Linux kernel is the definition of SHMLBA. This was noted in <https://sourceware.org/ml/libc-alpha/2018-09/msg00175.html> as a reason why even a new architecture (C-SKY) might need its own bits/shm.h; thus, splitting it out of bits/shm.h can allow less duplication of headers for new architectures. This patch moves that definition to its own header, bits/shmlba.h, to allow more sharing of headers between architectures. That move allows the arm, ia64 and sh variants of bits/shm.h to be removed, as they had no other significant differences from the generic bits/shm.h; powerpc and x86 have their own bits/shm.h but do not need to get their own bits/shmlba.h because they use the same SHMLBA as the generic header. Other architectures with their own bits/shm.h get their own bits/shmlba.h without being able to remove their own bits/shm.h until the generic one has been adapted to be able to handle more architectures (where, in addition to the differences seen for bits/msq.h and bits/sem.h, the position of shm_segsz in struct shmid_ds also depends on the architecture). Tested for x86_64 and x86, and with build-many-glibcs.py. * sysdeps/unix/sysv/linux/Makefile (sysdep_headers): Add bits/shmlba.h. * sysdeps/unix/sysv/linux/bits/shm.h: Include <bits/shmlba.h>. (SHMLBA): Remove macro. (__getpagesize): Remove function declaration. * sysdeps/unix/sysv/linux/hppa/bits/shm.h: Include <bits/shmlba.h>. (SHMLBA): Remove macro. * sysdeps/unix/sysv/linux/mips/bits/shm.h: Include <bits/shmlba.h>. (SHMLBA): Remove macro. * sysdeps/unix/sysv/linux/powerpc/bits/shm.h: Include <bits/shmlba.h>. (SHMLBA): Remove macro. (__getpagesize): Remove function declaration. * sysdeps/unix/sysv/linux/sparc/bits/shm.h: Include <bits/shmlba.h>. (SHMLBA): Remove macro. (__getshmlba): Remove function declaration. * sysdeps/unix/sysv/linux/x86/bits/shm.h: Include <bits/shmlba.h>. (SHMLBA): Remove macro. (__getpagesize): Remove function declaration. * sysdeps/unix/sysv/linux/arm/bits/shm.h: Remove file. * sysdeps/unix/sysv/linux/ia64/bits/shm.h: Likewise. * sysdeps/unix/sysv/linux/sh/bits/shm.h: Likewise. * sysdeps/unix/sysv/linux/bits/shmlba.h: New file. * sysdeps/unix/sysv/linux/arm/bits/shmlba.h: Likewise. * sysdeps/unix/sysv/linux/hppa/bits/shmlba.h: Likewise. * sysdeps/unix/sysv/linux/ia64/bits/shmlba.h: Likewise. * sysdeps/unix/sysv/linux/mips/bits/shmlba.h: Likewise. * sysdeps/unix/sysv/linux/sh/bits/shmlba.h: Likewise. * sysdeps/unix/sysv/linux/sparc/bits/shmlba.h: Likewise.
2018-10-17Fix race in pthread_mutex_lock while promoting to PTHREAD_MUTEX_ELISION_NP ↵Stefan Liebler
[BZ #23275] The race leads either to pthread_mutex_destroy returning EBUSY or triggering an assertion (See description in bugzilla). This patch is fixing the race by ensuring that the elision path is used in all cases if elision is enabled by the GLIBC_TUNABLES framework. The __kind variable in struct __pthread_mutex_s is accessed concurrently. Therefore we are now using the atomic macros. The new testcase tst-mutex10 is triggering the race on s390x and intel. Presumably also on power, but I don't have access to a power machine with lock-elision. At least the code for power is the same as on the other two architectures. ChangeLog: [BZ #23275] * nptl/tst-mutex10.c: New File. * nptl/Makefile (tests): Add tst-mutex10. (tst-mutex10-ENV): New variable. * sysdeps/unix/sysv/linux/s390/force-elision.h: (FORCE_ELISION): Ensure that elision path is used if elision is available. * sysdeps/unix/sysv/linux/powerpc/force-elision.h (FORCE_ELISION): Likewise. * sysdeps/unix/sysv/linux/x86/force-elision.h: (FORCE_ELISION): Likewise. * nptl/pthreadP.h (PTHREAD_MUTEX_TYPE, PTHREAD_MUTEX_TYPE_ELISION) (PTHREAD_MUTEX_PSHARED): Use atomic_load_relaxed. * nptl/pthread_mutex_consistent.c (pthread_mutex_consistent): Likewise. * nptl/pthread_mutex_getprioceiling.c (pthread_mutex_getprioceiling): Likewise. * nptl/pthread_mutex_lock.c (__pthread_mutex_lock_full) (__pthread_mutex_cond_lock_adjust): Likewise. * nptl/pthread_mutex_setprioceiling.c (pthread_mutex_setprioceiling): Likewise. * nptl/pthread_mutex_timedlock.c (__pthread_mutex_timedlock): Likewise. * nptl/pthread_mutex_trylock.c (__pthread_mutex_trylock): Likewise. * nptl/pthread_mutex_unlock.c (__pthread_mutex_unlock_full): Likewise. * sysdeps/nptl/bits/thread-shared-types.h (struct __pthread_mutex_s): Add comments. * nptl/pthread_mutex_destroy.c (__pthread_mutex_destroy): Use atomic_load_relaxed and atomic_store_relaxed. * nptl/pthread_mutex_init.c (__pthread_mutex_init): Use atomic_store_relaxed.
2018-10-15Use single bits/sem.h for all architectures.Joseph Myers
The bits/sem.h headers for architectures using the Linux kernel vary in a few ways: * x32 uses __syscall_ulong_t instead of unsigned long int. * The x86 header uses padding after time fields unconditionally (including for both x86_64 ABIs), not just for 32-bit time (unlike in msqid_ds where there is only padding for 32-bit time). Because this padding is present for x32, and is __syscall_ulong_t there, it does have to be __syscall_ulong_t, not unsigned long int. * The MIPS header never uses padding around time fields, even when 32-bit (unlike in msqid_ds where it has endian-dependent padding for 32-bit time). * Some older 32-bit big-endian architectures have padding before rather than after time fields, although the preferred generic approach is padding after the time fields independent of endianness. (There are also insubstantial differences such as use of unsigned int for padding instead of unsigned long int, which makes no difference to layout since the padding fields using unsigned int are only present on 32-bit architectures.) For the first, __syscall_ulong_t can be used in the generic version as it's the same as unsigned long int everywhere except x32. For the other differences, this patch adds macros __SEM_PAD_BEFORE_TIME and __SEM_PAD_AFTER_TIME in a new bits/sem-pad.h header, so that header is the only one needing to be provided on architectures with differences in this area, and everything else can go in a single common bits/sem.h header. Tested for x86_64 and x86, and with build-many-glibcs.py. * sysdeps/unix/sysv/linux/Makefile (sysdep_headers): Add bits/sem-pad.h. * sysdeps/unix/sysv/linux/bits/sem.h: Include <bits/sem-pad.h> instead of <bits/wordsize.h>. (__SEM_PAD_TIME): New macro, depending on [__SEM_PAD_BEFORE_TIME] and [__SEM_PAD_AFTER_TIME]. (struct semid_ds): Define time fields using __SEM_PAD_TIME. Use __syscall_ulong_t instead of unsigned long int. * sysdeps/unix/sysv/linux/bits/sem-pad.h: New file. * sysdeps/unix/sysv/linux/hppa/bits/sem-pad.h: Likewise. * sysdeps/unix/sysv/linux/mips/bits/sem-pad.h: Likewise. * sysdeps/unix/sysv/linux/powerpc/bits/sem-pad.h: Likewise. * sysdeps/unix/sysv/linux/sparc/bits/sem-pad.h: Likewise. * sysdeps/unix/sysv/linux/x86/bits/sem-pad.h: Likewise. * sysdeps/unix/sysv/linux/hppa/bits/sem.h: Remove. * sysdeps/unix/sysv/linux/mips/bits/sem.h: Likewise. * sysdeps/unix/sysv/linux/powerpc/bits/sem.h: Likewise. * sysdeps/unix/sysv/linux/sparc/bits/sem.h: Likewise. * sysdeps/unix/sysv/linux/x86/bits/sem.h: Likewise.
2018-10-11Use single bits/msq.h for all architectures.Joseph Myers
The bits/msq.h headers for architectures using the Linux kernel vary in a few ways: * x32 uses __syscall_ulong_t instead of unsigned long int. * x32 has 64-bit time_t, so no padding around time fields despite __WORDSIZE == 32. * Some older 32-bit big-endian architectures have padding before rather than after time fields, although the preferred generic approach is padding after the time fields independent of endianness. (There are also insubstantial differences such as use of unsigned int for padding instead of unsigned long int, which makes no difference to layout since the padding fields using unsigned int are only present on 32-bit architectures.) For the first, __syscall_ulong_t can be used in the generic version as it's the same as unsigned long int everywhere except x32. For the other two differences, this patch adds macros __MSQ_PAD_BEFORE_TIME and __MSQ_PAD_AFTER_TIME in a new bits/msq-pad.h header, so that header is the only one needing to be provided on architectures with differences in this area, and everything else can go in a single common bits/msq.h header. Once we have __TIMESIZE, the generic bits/msq-pad.h can change to use that instead of __WORDSIZE, at which point the x86 version of bits/msq-pad.h won't be needed either. Tested for x86_64 and x86, and with build-many-glibcs.py. * sysdeps/unix/sysv/linux/Makefile (sysdep_headers): Add bits/msq-pad.h. * sysdeps/unix/sysv/linux/bits/msq.h: Include <bits/msq-pad.h> instead of <bits/wordsize.h>. (msgqnum_t): Define as __syscall_ulong_t. (msglen_t): Likewise. (__MSQ_PAD_TIME): New macro, depending on [__MSQ_PAD_BEFORE_TIME] and [__MSQ_PAD_AFTER_TIME]. (struct msqid_ds): Define time fields using __MSQ_PAD_TIME. Use __syscall_ulong_t instead of unsigned long int. * sysdeps/unix/sysv/linux/bits/msq-pad.h: New file. * sysdeps/unix/sysv/linux/hppa/bits/msq-pad.h: Likewise. * sysdeps/unix/sysv/linux/mips/bits/msq-pad.h: Likewise. * sysdeps/unix/sysv/linux/powerpc/bits/msq-pad.h: Likewise. * sysdeps/unix/sysv/linux/sparc/bits/msq-pad.h: Likewise. * sysdeps/unix/sysv/linux/x86/bits/msq-pad.h: Likewise. * sysdeps/unix/sysv/linux/hppa/bits/msq.h: Remove. * sysdeps/unix/sysv/linux/mips/bits/msq.h: Likewise. * sysdeps/unix/sysv/linux/powerpc/bits/msq.h: Likewise. * sysdeps/unix/sysv/linux/sparc/bits/msq.h: Likewise. * sysdeps/unix/sysv/linux/x86/bits/msq.h: Likewise.
2018-10-10Use common bits/shm.h for more architectures.Joseph Myers
sysdeps/unix/sysv/linux/bits/shm.h has padding after time fields in struct shmid_ds unconditionally, and thus is only suitable for 32-bit architectures (no 64-bit configurations use this file); sysdeps/unix/sysv/linux/generic/bits/shm.h is substantively the same, except that the padding is conditioned on __WORDSIZE == 32, and so it can be used for 64-bit architectures as well. This patch adds the conditionals to sysdeps/unix/sysv/linux/bits/shm.h. The linux/generic/ version is then no longer needed and so is removed, as are the alpha and s390 versions which are also no longer needed. The other architecture-specific versions have different padding, layout, types or SHMLBA definitions and so are still needed after this change. This is essentially the same change for bits/shm.h as the bits/msq.h patch and the bits/sem.h patch. However, the details of the padding variations for the architectures that aren't changed are not all the same between msqid_ds, shmid_ds and semid_ds. Tested with build-many-glibcs.py. * sysdeps/unix/sysv/linux/bits/shm.h: Include <bits/wordsize.h>. (struct shmid_ds): Condition padding after time fields on [__WORDSIZE == 32]. * sysdeps/unix/sysv/linux/alpha/bits/shm.h: Remove file. * sysdeps/unix/sysv/linux/generic/bits/shm.h: Likewise. * sysdeps/unix/sysv/linux/s390/bits/shm.h: Likewise.
2018-10-10Use common bits/sem.h for more architectures.Joseph Myers
sysdeps/unix/sysv/linux/bits/sem.h has padding after time fields in struct semid_ds unconditionally, and thus is only suitable for 32-bit architectures (no 64-bit configurations use this file); sysdeps/unix/sysv/linux/generic/bits/sem.h is substantively the same, except that the padding is conditioned on __WORDSIZE == 32, and so it can be used for 64-bit architectures as well. This patch adds the conditionals to sysdeps/unix/sysv/linux/bits/sem.h. The linux/generic/ version is then no longer needed and so is removed, as are the alpha, ia64 and s390 versions which are also no longer needed. The other architecture-specific versions have different padding or types and so are still needed after this change. This is essentially the same change for bits/sem.h as the bits/msq.h patch. However, the details of the padding variations for the architectures that aren't changed are not all the same between msqid_ds and semid_ds. Tested with build-many-glibcs.py. * sysdeps/unix/sysv/linux/bits/sem.h: Include <bits/wordsize.h>. (struct semid_ds): Condition padding after time fields on [__WORDSIZE == 32]. * sysdeps/unix/sysv/linux/alpha/bits/sem.h: Remove file. * sysdeps/unix/sysv/linux/generic/bits/sem.h: Likewise. * sysdeps/unix/sysv/linux/ia64/bits/sem.h: Likewise. * sysdeps/unix/sysv/linux/s390/bits/sem.h: Likewise.
2018-10-10Use common bits/msq.h for more architectures.Joseph Myers
sysdeps/unix/sysv/linux/bits/msq.h has padding after time fields in struct msqid_ds unconditionally, and thus is only suitable for 32-bit architectures (no 64-bit configurations use this file); sysdeps/unix/sysv/linux/generic/bits/msq.h is substantively the same, except that the padding is conditioned on __WORDSIZE == 32, and so it can be used for 64-bit architectures as well. This patch adds the conditionals to sysdeps/unix/sysv/linux/bits/msq.h. The linux/generic/ version is then no longer needed and so is removed, as are the alpha, ia64 and s390 versions which are also no longer needed. The other architecture-specific versions have different padding or types and so are still needed after this change. Tested with build-many-glibcs.py. * sysdeps/unix/sysv/linux/bits/msq.h: Include <bits/wordsize.h>. (struct msqid_ds): Condition padding after time fields on [__WORDSIZE == 32]. * sysdeps/unix/sysv/linux/alpha/bits/msq.h: Remove file. * sysdeps/unix/sysv/linux/generic/bits/msq.h: Likewise. * sysdeps/unix/sysv/linux/ia64/bits/msq.h: Likewise. * sysdeps/unix/sysv/linux/s390/bits/msq.h: Likewise.
2018-10-04Use bits/mman-linux.h for hppa.Joseph Myers
hppa currently has a bits/mman.h that does not include bits/mman-linux.h, unlike all other architectures using the Linux kernel. This sort of variation between architectures is generally unhelpful when making global changes for new constants added to new Linux kernel releases. This patch changes hppa to use bits/mman-linux.h, overriding constants with different values as necessary (including with #undef after bits/mman.h inclusion when needed, as already done for alpha). While there could possibly be further improvements through e.g. splitting more sets of definitions into separate bits/ headers, I think this is still an improvement on the current state. diffstat shows 27 lines added, 51 deleted (and some of that is actually existing lines moving to a different place in the file). Tested with build-many-glibcs.py for hppa-linux-gnu. * sysdeps/unix/sysv/linux/hppa/bits/mman.h: Include <bits/mman-linux.h>. (PROT_READ): Don't define here. (PROT_WRITE): Likewise. (PROT_EXEC): Likewise. (PROT_NONE): Likewise. (PROT_GROWSDOWN): Likewise. (PROT_GROWSUP): Likewise. (MAP_SHARED): Likewise. (MAP_PRIVATE): Likewise. [__USE_MISC] (MAP_SHARED_VALIDATE): Likewise. [__USE_MISC] (MAP_FILE): Likewise. [__USE_MISC] (MAP_ANONYMOUS): Likewise. [__USE_MISC] (MAP_ANON): Likewise. [__USE_MISC] (MAP_HUGE_SHIFT): Likewise. [__USE_MISC] (MAP_HUGE_MASK): Likewise. (MCL_CURRENT): Likewise. (MCL_FUTURE): Likewise. (MCL_ONFAULT): Likewise. [__USE_MISC] (MADV_NORMAL): Likewise. [__USE_MISC] (MADV_RANDOM): Likewise. [__USE_MISC] (MADV_SEQUENTIAL): Likewise. [__USE_MISC] (MADV_WILLNEED): Likewise. [__USE_MISC] (MADV_DONTNEED): Likewise. [__USE_MISC] (MADV_FREE): Likewise. [__USE_MISC] (MADV_REMOVE): Likewise. [__USE_MISC] (MADV_DONTFORK): Likewise. [__USE_MISC] (MADV_DOFORK): Likewise. [__USE_MISC] (MADV_HWPOISON): Likewise. [__USE_XOPEN2K] (POSIX_MADV_NORMAL): Likewise. [__USE_XOPEN2K] (POSIX_MADV_RANDOM): Likewise. [__USE_XOPEN2K] (POSIX_MADV_SEQUENTIAL): Likewise. [__USE_XOPEN2K] (POSIX_MADV_WILLNEED): Likewise. [__USE_XOPEN2K] (POSIX_MADV_DONTNEED): Likewise. (__MAP_ANONYMOUS): New macro. [__USE_MISC] (MAP_TYPE): Undefine and redefine after <bits/mman-linux.h> inclusion. (MAP_FIXED): Likewise. (MS_SYNC): Likewise. (MS_ASYNC): Likewise. (MS_INVALIDATE): Likewise. [__USE_MISC] (MADV_MERGEABLE): Likewise. [__USE_MISC] (MADV_UNMERGEABLE): Likewise. [__USE_MISC] (MADV_HUGEPAGE): Likewise. [__USE_MISC] (MADV_NOHUGEPAGE): Likewise. [__USE_MISC] (MADV_DONTDUMP): Likewise. [__USE_MISC] (MADV_DODUMP): Likewise. [__USE_MISC] (MADV_WIPEONFORK): Likewise. [__USE_MISC] (MADV_KEEPONFORK): Likewise.