[5/7] linux: Use waitid on wait4 if __NR_wait4 is not defined
diff mbox series

Message ID 20191114144704.19002-5-adhemerval.zanella@linaro.org
State New
Headers show
Series
  • [1/7] Remove __waitpid_nocancel
Related show

Commit Message

Adhemerval Zanella Nov. 14, 2019, 2:47 p.m. UTC
If the wait4 syscall is not avaliable (such as y2038 safe 32-bit
systems) waitid should be used instead.  However prior Linux 5.4
waitid is not a fully superset of other wait instruction, since it
does not include support for waiting for the current process group.

It would be possible to emulate to issue an extra syscall to get
the current process group, but it is inherent racy: after the current
process group is received and before it is passed to waitid a signal
could arrive causing the current process group to change

So waitid is used if wait4 is not defined iff the build is
enabled with a minimum kernel if 5.4+.  The new assume
__ASSUME_WAITID_PID0_P_PGID is added and an error is issued if waitid
can not be implemented by either __NR_wait4 or
__NR_waitid && __ASSUME_WAITID_PID0_P_PGID.

Checked on x86_64-linux-gnu and i686-linux-gnu.

Co-authored-by: Alistair Francis <alistair.francis@wdc.com>
---
 sysdeps/unix/sysv/linux/kernel-features.h |  6 ++
 sysdeps/unix/sysv/linux/syscalls.list     |  1 -
 sysdeps/unix/sysv/linux/wait4.c           | 88 +++++++++++++++++++++++
 3 files changed, 94 insertions(+), 1 deletion(-)
 create mode 100644 sysdeps/unix/sysv/linux/wait4.c

Comments

Alistair Francis Nov. 15, 2019, 6:27 p.m. UTC | #1
On Thu, Nov 14, 2019 at 9:47 AM Adhemerval Zanella
<adhemerval.zanella@linaro.org> wrote:
>
> If the wait4 syscall is not avaliable (such as y2038 safe 32-bit
> systems) waitid should be used instead.  However prior Linux 5.4
> waitid is not a fully superset of other wait instruction, since it
> does not include support for waiting for the current process group.
>
> It would be possible to emulate to issue an extra syscall to get
> the current process group, but it is inherent racy: after the current
> process group is received and before it is passed to waitid a signal
> could arrive causing the current process group to change
>
> So waitid is used if wait4 is not defined iff the build is
> enabled with a minimum kernel if 5.4+.  The new assume
> __ASSUME_WAITID_PID0_P_PGID is added and an error is issued if waitid
> can not be implemented by either __NR_wait4 or
> __NR_waitid && __ASSUME_WAITID_PID0_P_PGID.
>
> Checked on x86_64-linux-gnu and i686-linux-gnu.
>
> Co-authored-by: Alistair Francis <alistair.francis@wdc.com>
> ---
>  sysdeps/unix/sysv/linux/kernel-features.h |  6 ++
>  sysdeps/unix/sysv/linux/syscalls.list     |  1 -
>  sysdeps/unix/sysv/linux/wait4.c           | 88 +++++++++++++++++++++++
>  3 files changed, 94 insertions(+), 1 deletion(-)
>  create mode 100644 sysdeps/unix/sysv/linux/wait4.c
>
> diff --git a/sysdeps/unix/sysv/linux/kernel-features.h b/sysdeps/unix/sysv/linux/kernel-features.h
> index e6be76ff46..43faaa3f9d 100644
> --- a/sysdeps/unix/sysv/linux/kernel-features.h
> +++ b/sysdeps/unix/sysv/linux/kernel-features.h
> @@ -208,4 +208,10 @@
>  # define __ASSUME_TIME64_SYSCALLS 1
>  #endif
>
> +/* Linux waitid prior kernel 5.4 does not support waiting for the current
> +   process group.  */
> +#if __LINUX_KERNEL_VERSION >= 0x050400
> +# define __ASSUME_WAITID_PID0_P_PGID
> +#endif
> +
>  #endif /* kernel-features.h */
> diff --git a/sysdeps/unix/sysv/linux/syscalls.list b/sysdeps/unix/sysv/linux/syscalls.list
> index 603e517ca6..5f1352ad43 100644
> --- a/sysdeps/unix/sysv/linux/syscalls.list
> +++ b/sysdeps/unix/sysv/linux/syscalls.list
> @@ -67,7 +67,6 @@ swapoff               -       swapoff         i:s     __swapoff       swapoff
>  unshare                EXTRA   unshare         i:i     unshare
>  uselib         EXTRA   uselib          i:s     __compat_uselib uselib@GLIBC_2.0:GLIBC_2.23
>  utime          -       utime           i:sP    utime
> -wait4          -       wait4           i:iWiP  __wait4         wait4
>
>  chown          -       chown           i:sii   __libc_chown    __chown chown
>
> diff --git a/sysdeps/unix/sysv/linux/wait4.c b/sysdeps/unix/sysv/linux/wait4.c
> new file mode 100644
> index 0000000000..d09917c7ff
> --- /dev/null
> +++ b/sysdeps/unix/sysv/linux/wait4.c
> @@ -0,0 +1,88 @@
> +/* Wait for process to change state.  Linux version.
> +   Copyright (C) 2019 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
> +   <https://www.gnu.org/licenses/>.  */
> +
> +#include <sys/wait.h>
> +#include <sys/resource.h>
> +#include <sysdep-cancel.h>
> +
> +pid_t
> +__wait4 (pid_t pid, int *stat_loc, int options, struct rusage *usage)
> +{
> +#if __NR_wait4

This needs to be #ifdef as __NR_wait4 doesn't exist on RV32.

Alistair

> +   return SYSCALL_CANCEL (wait4, pid, stat_loc, options, usage);
> +#elif defined (__ASSUME_WAITID_PID0_P_PGID)
> +  idtype_t idtype = P_PID;
> +
> +  if (pid < -1)
> +    {
> +      idtype = P_PGID;
> +      pid *= -1;
> +    }
> +  else if (pid == -1)
> +    {
> +      idtype = P_ALL;
> +    }
> +  else if (pid == 0)
> +    {
> +      idtype = P_PGID;
> +    }
> +
> +  options |= WEXITED;
> +
> +  siginfo_t infop;
> +  if (SYSCALL_CANCEL (waitid, idtype, pid, &infop, options, usage) < 0)
> +    return -1;
> +
> +  if (stat_loc)
> +    {
> +      switch (infop.si_code)
> +        {
> +        case CLD_EXITED:
> +          *stat_loc = W_EXITCODE (infop.si_status, 0);
> +          break;
> +        case CLD_DUMPED:
> +          *stat_loc = WCOREFLAG | infop.si_status;
> +         break;
> +        case CLD_KILLED:
> +          *stat_loc = infop.si_status;
> +          break;
> +        case CLD_TRAPPED:
> +        case CLD_STOPPED:
> +          *stat_loc = W_STOPCODE (infop.si_status);
> +          break;
> +        case CLD_CONTINUED:
> +          *stat_loc = __W_CONTINUED;
> +          break;
> +       default:
> +         *stat_loc = 0;
> +         break;
> +        }
> +    }
> +
> +  return infop.si_pid;
> +# else
> +/* Linux waitid prior kernel 5.4 does not support waiting for the current
> +   process.  It would be possible to emulate it by calling getpgid for pid 0,
> +   however, it would require an additional syscall and it is inherent racy:
> +   after the current process group is received and before it is passed
> +   to waitid a signal could arrive causing the current process group to
> +   change.  */
> +# error "The kernel ABI does not provide a way to implement wait4"
> +#endif
> +}
> +weak_alias (__wait4, wait4)
> --
> 2.17.1
>
Adhemerval Zanella Nov. 21, 2019, 5:48 p.m. UTC | #2
On 15/11/2019 15:27, Alistair Francis wrote:
>> +
>> +pid_t
>> +__wait4 (pid_t pid, int *stat_loc, int options, struct rusage *usage)
>> +{
>> +#if __NR_wait4
> 
> This needs to be #ifdef as __NR_wait4 doesn't exist on RV32.
> 
> Alistair

Acked.
Adhemerval Zanella Nov. 21, 2019, 5:52 p.m. UTC | #3
On 14/11/2019 11:47, Adhemerval Zanella wrote:
> +pid_t
> +__wait4 (pid_t pid, int *stat_loc, int options, struct rusage *usage)
> +{
> +#if __NR_wait4
> +   return SYSCALL_CANCEL (wait4, pid, stat_loc, options, usage);
> +#elif defined (__ASSUME_WAITID_PID0_P_PGID)
[...]
> +# else
> +/* Linux waitid prior kernel 5.4 does not support waiting for the current
> +   process.  It would be possible to emulate it by calling getpgid for pid 0,
> +   however, it would require an additional syscall and it is inherent racy:
> +   after the current process group is received and before it is passed
> +   to waitid a signal could arrive causing the current process group to
> +   change.  */
> +# error "The kernel ABI does not provide a way to implement wait4"
> +#endif

So the only design here that I am not sure is if the best one is to trigger
a build error to avoid an architecture to not define __NR_wait4 and also 
support kernels older than 5.4 (which would not define 
__ASSUME_WAITID_PID0_P_PGID), or if it should do as generic implementation
and return ENOSYS along with a stub.

Thoughts?
Alistair Francis Nov. 21, 2019, 6:41 p.m. UTC | #4
On Thu, Nov 21, 2019 at 9:53 AM Adhemerval Zanella
<adhemerval.zanella@linaro.org> wrote:
>
>
>
> On 14/11/2019 11:47, Adhemerval Zanella wrote:
> > +pid_t
> > +__wait4 (pid_t pid, int *stat_loc, int options, struct rusage *usage)
> > +{
> > +#if __NR_wait4
> > +   return SYSCALL_CANCEL (wait4, pid, stat_loc, options, usage);
> > +#elif defined (__ASSUME_WAITID_PID0_P_PGID)
> [...]
> > +# else
> > +/* Linux waitid prior kernel 5.4 does not support waiting for the current
> > +   process.  It would be possible to emulate it by calling getpgid for pid 0,
> > +   however, it would require an additional syscall and it is inherent racy:
> > +   after the current process group is received and before it is passed
> > +   to waitid a signal could arrive causing the current process group to
> > +   change.  */
> > +# error "The kernel ABI does not provide a way to implement wait4"
> > +#endif
>
> So the only design here that I am not sure is if the best one is to trigger
> a build error to avoid an architecture to not define __NR_wait4 and also
> support kernels older than 5.4 (which would not define
> __ASSUME_WAITID_PID0_P_PGID), or if it should do as generic implementation
> and return ENOSYS along with a stub.
>
> Thoughts?

I think a build error makes sense. Currently only RV32 doesn't have
__NR_wait4 (which isn't upstreamed) so you aren't breaking anything.

The only kernels that could possibly not have __NR_wait4 and be less
then 5.4 are 5.1, 5.2 and 5.3, non of which are stable so they will
slowly disappear anyway.

Not producing a build error could be very confusing for developers
that do get bitten by the missing implementation.

Alistair
Adhemerval Zanella Nov. 22, 2019, 12:15 p.m. UTC | #5
On 21/11/2019 15:41, Alistair Francis wrote:
> On Thu, Nov 21, 2019 at 9:53 AM Adhemerval Zanella
> <adhemerval.zanella@linaro.org> wrote:
>>
>>
>>
>> On 14/11/2019 11:47, Adhemerval Zanella wrote:
>>> +pid_t
>>> +__wait4 (pid_t pid, int *stat_loc, int options, struct rusage *usage)
>>> +{
>>> +#if __NR_wait4
>>> +   return SYSCALL_CANCEL (wait4, pid, stat_loc, options, usage);
>>> +#elif defined (__ASSUME_WAITID_PID0_P_PGID)
>> [...]
>>> +# else
>>> +/* Linux waitid prior kernel 5.4 does not support waiting for the current
>>> +   process.  It would be possible to emulate it by calling getpgid for pid 0,
>>> +   however, it would require an additional syscall and it is inherent racy:
>>> +   after the current process group is received and before it is passed
>>> +   to waitid a signal could arrive causing the current process group to
>>> +   change.  */
>>> +# error "The kernel ABI does not provide a way to implement wait4"
>>> +#endif
>>
>> So the only design here that I am not sure is if the best one is to trigger
>> a build error to avoid an architecture to not define __NR_wait4 and also
>> support kernels older than 5.4 (which would not define
>> __ASSUME_WAITID_PID0_P_PGID), or if it should do as generic implementation
>> and return ENOSYS along with a stub.
>>
>> Thoughts?
> 
> I think a build error makes sense. Currently only RV32 doesn't have
> __NR_wait4 (which isn't upstreamed) so you aren't breaking anything.
> 
> The only kernels that could possibly not have __NR_wait4 and be less
> then 5.4 are 5.1, 5.2 and 5.3, non of which are stable so they will
> slowly disappear anyway.
> 
> Not producing a build error could be very confusing for developers
> that do get bitten by the missing implementation.
> 

My point if if checking for kernel version to define __ASSUME_WAITID_PID0_P_PGID
does make, meaning it is possible with some config option in the kernel
to enable only waitid for kernels older than 5.3; or if we can assume
some configuration in always invalid and thus the kernel won't allow
enable it.

If the latter we can then remove the __ASSUME_WAITID_PID0_P_PGID and
add a comment on waitid implementation stating that if waitid is the
only syscall supported then it is suppose to be the superset of all
wait* functionalities.
Alistair Francis Nov. 22, 2019, 8 p.m. UTC | #6
On Fri, Nov 22, 2019 at 4:15 AM Adhemerval Zanella
<adhemerval.zanella@linaro.org> wrote:
>
>
>
> On 21/11/2019 15:41, Alistair Francis wrote:
> > On Thu, Nov 21, 2019 at 9:53 AM Adhemerval Zanella
> > <adhemerval.zanella@linaro.org> wrote:
> >>
> >>
> >>
> >> On 14/11/2019 11:47, Adhemerval Zanella wrote:
> >>> +pid_t
> >>> +__wait4 (pid_t pid, int *stat_loc, int options, struct rusage *usage)
> >>> +{
> >>> +#if __NR_wait4
> >>> +   return SYSCALL_CANCEL (wait4, pid, stat_loc, options, usage);
> >>> +#elif defined (__ASSUME_WAITID_PID0_P_PGID)
> >> [...]
> >>> +# else
> >>> +/* Linux waitid prior kernel 5.4 does not support waiting for the current
> >>> +   process.  It would be possible to emulate it by calling getpgid for pid 0,
> >>> +   however, it would require an additional syscall and it is inherent racy:
> >>> +   after the current process group is received and before it is passed
> >>> +   to waitid a signal could arrive causing the current process group to
> >>> +   change.  */
> >>> +# error "The kernel ABI does not provide a way to implement wait4"
> >>> +#endif
> >>
> >> So the only design here that I am not sure is if the best one is to trigger
> >> a build error to avoid an architecture to not define __NR_wait4 and also
> >> support kernels older than 5.4 (which would not define
> >> __ASSUME_WAITID_PID0_P_PGID), or if it should do as generic implementation
> >> and return ENOSYS along with a stub.
> >>
> >> Thoughts?
> >
> > I think a build error makes sense. Currently only RV32 doesn't have
> > __NR_wait4 (which isn't upstreamed) so you aren't breaking anything.
> >
> > The only kernels that could possibly not have __NR_wait4 and be less
> > then 5.4 are 5.1, 5.2 and 5.3, non of which are stable so they will
> > slowly disappear anyway.
> >
> > Not producing a build error could be very confusing for developers
> > that do get bitten by the missing implementation.
> >
>
> My point if if checking for kernel version to define __ASSUME_WAITID_PID0_P_PGID
> does make, meaning it is possible with some config option in the kernel
> to enable only waitid for kernels older than 5.3; or if we can assume
> some configuration in always invalid and thus the kernel won't allow
> enable it.
>
> If the latter we can then remove the __ASSUME_WAITID_PID0_P_PGID and
> add a comment on waitid implementation stating that if waitid is the
> only syscall supported then it is suppose to be the superset of all
> wait* functionalities.

I think I understand what you are saying.

It is NOT the case that if waitid is the only syscall supported then
it is a superset of all wait* functions.

For RV32 the 5.1, 5.2 and 5.3 only support waitid but do not support
the PID0 P_PGID functionality. In these three kernel cases the call
will fail.

Alistair
Adhemerval Zanella Nov. 25, 2019, 12:39 p.m. UTC | #7
On 22/11/2019 17:00, Alistair Francis wrote:
> On Fri, Nov 22, 2019 at 4:15 AM Adhemerval Zanella
> <adhemerval.zanella@linaro.org> wrote:
>>
>>
>>
>> On 21/11/2019 15:41, Alistair Francis wrote:
>>> On Thu, Nov 21, 2019 at 9:53 AM Adhemerval Zanella
>>> <adhemerval.zanella@linaro.org> wrote:
>>>>
>>>>
>>>>
>>>> On 14/11/2019 11:47, Adhemerval Zanella wrote:
>>>>> +pid_t
>>>>> +__wait4 (pid_t pid, int *stat_loc, int options, struct rusage *usage)
>>>>> +{
>>>>> +#if __NR_wait4
>>>>> +   return SYSCALL_CANCEL (wait4, pid, stat_loc, options, usage);
>>>>> +#elif defined (__ASSUME_WAITID_PID0_P_PGID)
>>>> [...]
>>>>> +# else
>>>>> +/* Linux waitid prior kernel 5.4 does not support waiting for the current
>>>>> +   process.  It would be possible to emulate it by calling getpgid for pid 0,
>>>>> +   however, it would require an additional syscall and it is inherent racy:
>>>>> +   after the current process group is received and before it is passed
>>>>> +   to waitid a signal could arrive causing the current process group to
>>>>> +   change.  */
>>>>> +# error "The kernel ABI does not provide a way to implement wait4"
>>>>> +#endif
>>>>
>>>> So the only design here that I am not sure is if the best one is to trigger
>>>> a build error to avoid an architecture to not define __NR_wait4 and also
>>>> support kernels older than 5.4 (which would not define
>>>> __ASSUME_WAITID_PID0_P_PGID), or if it should do as generic implementation
>>>> and return ENOSYS along with a stub.
>>>>
>>>> Thoughts?
>>>
>>> I think a build error makes sense. Currently only RV32 doesn't have
>>> __NR_wait4 (which isn't upstreamed) so you aren't breaking anything.
>>>
>>> The only kernels that could possibly not have __NR_wait4 and be less
>>> then 5.4 are 5.1, 5.2 and 5.3, non of which are stable so they will
>>> slowly disappear anyway.
>>>
>>> Not producing a build error could be very confusing for developers
>>> that do get bitten by the missing implementation.
>>>
>>
>> My point if if checking for kernel version to define __ASSUME_WAITID_PID0_P_PGID
>> does make, meaning it is possible with some config option in the kernel
>> to enable only waitid for kernels older than 5.3; or if we can assume
>> some configuration in always invalid and thus the kernel won't allow
>> enable it.
>>
>> If the latter we can then remove the __ASSUME_WAITID_PID0_P_PGID and
>> add a comment on waitid implementation stating that if waitid is the
>> only syscall supported then it is suppose to be the superset of all
>> wait* functionalities.
> 
> I think I understand what you are saying.
> 
> It is NOT the case that if waitid is the only syscall supported then
> it is a superset of all wait* functions.
> 
> For RV32 the 5.1, 5.2 and 5.3 only support waitid but do not support
> the PID0 P_PGID functionality. In these three kernel cases the call
> will fail.
> 

If it is the case (and it does seems linux support RV32 for kernel older
than v5.4), we will need to make the 5.4 the minimum supported kernel for
RV32 and any other architecture that only support waitid syscall.

The kernel check can be done at the configure level, but it does not
help on some kernel configuration for a architecture that explicit 
try to remove olds syscall to mimic the generic user API (not sure if
this is possible with current kernel configuration flags).

So it seems that __ASSUME_WAITID_PID0_P_PGID should be a safe call to
avoid such theoretical scenarios.  I will rework how the flag is used
to mimic other assume usage where newer kernel version undef the flag,
so it should be simpler to remove it once the minimum kernel is lifted.
Adhemerval Zanella Nov. 25, 2019, 12:42 p.m. UTC | #8
On 25/11/2019 09:39, Adhemerval Zanella wrote:

> So it seems that __ASSUME_WAITID_PID0_P_PGID should be a safe call to
> avoid such theoretical scenarios.  I will rework how the flag is used
> to mimic other assume usage where newer kernel version undef the flag,
> so it should be simpler to remove it once the minimum kernel is lifted.
> 

In fact I think change the __ASSUME_WAITID_PID0_P_PGID won't be much
a improvement
Alistair Francis Dec. 3, 2019, 6:58 p.m. UTC | #9
On Mon, Nov 25, 2019 at 4:42 AM Adhemerval Zanella
<adhemerval.zanella@linaro.org> wrote:
>
>
>
> On 25/11/2019 09:39, Adhemerval Zanella wrote:
>
> > So it seems that __ASSUME_WAITID_PID0_P_PGID should be a safe call to
> > avoid such theoretical scenarios.  I will rework how the flag is used
> > to mimic other assume usage where newer kernel version undef the flag,
> > so it should be simpler to remove it once the minimum kernel is lifted.
> >
>
> In fact I think change the __ASSUME_WAITID_PID0_P_PGID won't be much
> a improvement

Any update on this series?

Alistair
Adhemerval Zanella Dec. 3, 2019, 7:18 p.m. UTC | #10
On 03/12/2019 15:58, Alistair Francis wrote:
> On Mon, Nov 25, 2019 at 4:42 AM Adhemerval Zanella
> <adhemerval.zanella@linaro.org> wrote:
>>
>>
>>
>> On 25/11/2019 09:39, Adhemerval Zanella wrote:
>>
>>> So it seems that __ASSUME_WAITID_PID0_P_PGID should be a safe call to
>>> avoid such theoretical scenarios.  I will rework how the flag is used
>>> to mimic other assume usage where newer kernel version undef the flag,
>>> so it should be simpler to remove it once the minimum kernel is lifted.
>>>
>>
>> In fact I think change the __ASSUME_WAITID_PID0_P_PGID won't be much
>> a improvement
> 
> Any update on this series?

I am working on a libpthread-compat.c patch I plan to update, so I can
rebase against it.

Patch
diff mbox series

diff --git a/sysdeps/unix/sysv/linux/kernel-features.h b/sysdeps/unix/sysv/linux/kernel-features.h
index e6be76ff46..43faaa3f9d 100644
--- a/sysdeps/unix/sysv/linux/kernel-features.h
+++ b/sysdeps/unix/sysv/linux/kernel-features.h
@@ -208,4 +208,10 @@ 
 # define __ASSUME_TIME64_SYSCALLS 1
 #endif
 
+/* Linux waitid prior kernel 5.4 does not support waiting for the current
+   process group.  */
+#if __LINUX_KERNEL_VERSION >= 0x050400
+# define __ASSUME_WAITID_PID0_P_PGID
+#endif
+
 #endif /* kernel-features.h */
diff --git a/sysdeps/unix/sysv/linux/syscalls.list b/sysdeps/unix/sysv/linux/syscalls.list
index 603e517ca6..5f1352ad43 100644
--- a/sysdeps/unix/sysv/linux/syscalls.list
+++ b/sysdeps/unix/sysv/linux/syscalls.list
@@ -67,7 +67,6 @@  swapoff		-	swapoff		i:s	__swapoff	swapoff
 unshare		EXTRA	unshare		i:i	unshare
 uselib		EXTRA	uselib		i:s	__compat_uselib	uselib@GLIBC_2.0:GLIBC_2.23
 utime		-	utime		i:sP	utime
-wait4		-	wait4		i:iWiP	__wait4		wait4
 
 chown		-	chown		i:sii	__libc_chown	__chown chown
 
diff --git a/sysdeps/unix/sysv/linux/wait4.c b/sysdeps/unix/sysv/linux/wait4.c
new file mode 100644
index 0000000000..d09917c7ff
--- /dev/null
+++ b/sysdeps/unix/sysv/linux/wait4.c
@@ -0,0 +1,88 @@ 
+/* Wait for process to change state.  Linux version.
+   Copyright (C) 2019 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
+   <https://www.gnu.org/licenses/>.  */
+
+#include <sys/wait.h>
+#include <sys/resource.h>
+#include <sysdep-cancel.h>
+
+pid_t
+__wait4 (pid_t pid, int *stat_loc, int options, struct rusage *usage)
+{
+#if __NR_wait4
+   return SYSCALL_CANCEL (wait4, pid, stat_loc, options, usage);
+#elif defined (__ASSUME_WAITID_PID0_P_PGID)
+  idtype_t idtype = P_PID;
+
+  if (pid < -1)
+    {
+      idtype = P_PGID;
+      pid *= -1;
+    }
+  else if (pid == -1)
+    {
+      idtype = P_ALL;
+    }
+  else if (pid == 0)
+    {
+      idtype = P_PGID;
+    }
+
+  options |= WEXITED;
+
+  siginfo_t infop;
+  if (SYSCALL_CANCEL (waitid, idtype, pid, &infop, options, usage) < 0)
+    return -1;
+
+  if (stat_loc)
+    {
+      switch (infop.si_code)
+        {
+        case CLD_EXITED:
+          *stat_loc = W_EXITCODE (infop.si_status, 0);
+          break;
+        case CLD_DUMPED:
+          *stat_loc = WCOREFLAG | infop.si_status;
+	  break;
+        case CLD_KILLED:
+          *stat_loc = infop.si_status;
+          break;
+        case CLD_TRAPPED:
+        case CLD_STOPPED:
+          *stat_loc = W_STOPCODE (infop.si_status);
+          break;
+        case CLD_CONTINUED:
+          *stat_loc = __W_CONTINUED;
+          break;
+	default:
+	  *stat_loc = 0;
+	  break;
+        }
+    }
+
+  return infop.si_pid;
+# else
+/* Linux waitid prior kernel 5.4 does not support waiting for the current
+   process.  It would be possible to emulate it by calling getpgid for pid 0,
+   however, it would require an additional syscall and it is inherent racy:
+   after the current process group is received and before it is passed
+   to waitid a signal could arrive causing the current process group to
+   change.  */
+# error "The kernel ABI does not provide a way to implement wait4"
+#endif
+}
+weak_alias (__wait4, wait4)