[libc] Add the POSIX waitpid function and the BSD wait4 function.

[michaelrj]

LGTM

libc/config/linux/api.td

 }
 
 def SysStatAPI : PublicAPI<"sys/stat.h"> {
   let Types = ["mode_t", "dev_t", "ino_t", "nlink_t", "uid_t", "gid_t", "off_t",
                "struct timespec", "blksize_t", "blkcnt_t", "struct stat"];
 }
 
 def SysWaitAPI : PublicAPI<"sys/wait.h"> {
-  let Types = ["pid_t"];
+  let Types = ["pid_t", "struct rusage"];
 }
 
 def SysSendfileAPI : PublicAPI<"sys/sendfile.h"> {
   let Types = ["off_t", "size_t", "ssize_t"];
 }
 
 def SysUtsNameAPI : PublicAPI<"sys/utsname.h"> {
   let Types = ["struct utsname"];
 }

libc/config/linux/x86_64/entrypoints.txt

set(TARGET_LIBC_ENTRYPOINTS
     libc.src.sys.stat.mkdirat
     libc.src.sys.stat.stat
 
     # sys/utsname.h entrypoints
     libc.src.sys.utsname.uname
 
     # sys/wait.h entrypoints
     libc.src.sys.wait.wait
+    libc.src.sys.wait.wait4
+    libc.src.sys.wait.waitpid
 
     # unistd.h entrypoints
     libc.src.unistd.access
     libc.src.unistd.chdir
     libc.src.unistd.close
     libc.src.unistd.dup
     libc.src.unistd.dup2
     libc.src.unistd.dup3

libc/include/CMakeLists.txt

 add_gen_header(
   sys_wait
   DEF_FILE sys/wait.h.def
   GEN_HDR sys/wait.h
   DEPENDS
     .llvm_libc_common_h
     .llvm-libc-macros.sys_wait_macros
     .llvm-libc-types.pid_t
+    .llvm-libc-types.struct_rusage
 )
 
 if(NOT LLVM_LIBC_FULL_BUILD)
   # We don't install headers in non-fullbuild mode.
   return()
 endif()
 
 function(get_all_install_header_targets out_var)

libc/include/llvm-libc-macros/linux/sys-wait-macros.h

 //===-- Definition of macros from sys/wait.h ------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef __LLVM_LIBC_MACROS_LINUX_SYS_WAIT_MACROS_H
 #define __LLVM_LIBC_MACROS_LINUX_SYS_WAIT_MACROS_H
 
+// Wait flags
+#define WNOHANG 1    // Do not block
+#define WUNTRACED 2  // Report is a child has stopped even if untraced
+#define WCONTINUED 8 // Report if a stopped child has been resumed by SIGCONT
+
 // Wait status info macros
 #define WTERMSIG(status) (((status)&0x7F))
 #define WIFEXITED(status) (WTERMSIG(status) == 0)
 #define WEXITSTATUS(status) (((status)&0xFF00) >> 8)
 
 #endif // __LLVM_LIBC_MACROS_LINUX_SYS_WAIT_MACROS_H

libc/include/llvm-libc-types/CMakeLists.txt

 add_header(pid_t HDR pid_t.h)
 add_header(pthread_attr_t HDR pthread_attr_t.h DEPENDS .size_t)
 add_header(pthread_key_t HDR pthread_key_t.h)
 add_header(pthread_mutex_t HDR pthread_mutex_t.h DEPENDS .__futex_word .__mutex_type)
 add_header(pthread_t HDR pthread_t.h DEPENDS .__thread_type)
 add_header(pthread_mutexattr_t HDR pthread_mutexattr_t.h)
 add_header(pthread_once_t HDR pthread_once_t.h DEPENDS .__futex_word)
 add_header(rlim_t HDR rlim_t.h)
+add_header(time_t HDR time_t.h)
+add_header(suseconds_t HDR suseconds_t.h)
+add_header(struct_timeval HDR struct_timeval.h DEPENDS .suseconds_t .time_t)
 add_header(struct_rlimit HDR struct_rlimit.h DEPENDS .rlim_t)
+add_header(struct_rusage HDR struct_rusage.h DEPENDS .struct_timeval)
 add_header(ssize_t HDR ssize_t.h)
 add_header(struct_dirent HDR struct_dirent.h DEPENDS .ino_t .off_t)
 add_header(union_sigval HDR union_sigval.h)
 add_header(siginfo_t HDR siginfo_t.h DEPENDS .union_sigval .pid_t .uid_t)
 add_header(sigset_t HDR sigset_t.h DEPENDS libc.include.llvm-libc-macros.signal_macros)
 add_header(struct_sigaction HDR struct_sigaction.h DEPENDS .sigset_t .siginfo_t)
-add_header(time_t HDR time_t.h)
 add_header(struct_timespec HDR struct_timespec.h DEPENDS .time_t)
 add_header(
   struct_stat
   HDR struct_stat.h
   DEPENDS
     .dev_t .ino_t .mode_t .nlink_t .uid_t .gid_t .off_t .struct_timespec
     .blksize_t .blkcnt_t
 )
 add_header(struct_tm HDR struct_tm.h)
 add_header(struct_utsname HDR struct_utsname.h)
 add_header(thrd_start_t HDR thrd_start_t.h)
 add_header(thrd_t HDR thrd_t.h DEPENDS .__thread_type)
 add_header(tss_t HDR tss_t.h)
 add_header(tss_dtor_t HDR tss_dtor_t.h)
 add_header(__atexithandler_t HDR __atexithandler_t.h)

libc/include/llvm-libc-types/struct_rusage.h

+//===-- Definition of type struct rusage ----------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef __LLVM_LIBC_TYPES_STRUCT_RUSAGE_H__
+#define __LLVM_LIBC_TYPES_STRUCT_RUSAGE_H__
+
+#include <llvm-libc-types/struct_timeval.h>
+
+struct rusage {
+  struct timeval ru_utime;
+  struct timeval ru_stime;
+#ifdef __linux__
+  // Following fields are linux extensions as expected by the
+  // linux syscalls.
+  long ru_maxrss;   // Maximum resident set size
+  long ru_ixrss;    // Integral shared memory size
+  long ru_idrss;    // Integral unshared data size
+  long ru_isrss;    // Integral unshared stack size
+  long ru_minflt;   // Page reclaims
+  long ru_majflt;   // Page faults
+  long ru_nswap;    // Swaps
+  long ru_inblock;  // Block input operations
+  long ru_oublock;  // Block output operations
+  long ru_msgsnd;   // Messages sent
+  long ru_msgrcv;   // Messages received
+  long ru_nsignals; // Signals received
+  long ru_nvcsw;    // Voluntary context switches
+  long ru_nivcsw;   // Involuntary context switches
+#endif
+};
+
+#endif // __LLVM_LIBC_TYPES_STRUCT_RUSAGE_H__

libc/include/llvm-libc-types/struct_timeval.h

+//===-- Definition of struct timeval -------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef __LLVM_LIBC_TYPES_TIMEVAL_H__
+#define __LLVM_LIBC_TYPES_TIMEVAL_H__
+
+#include <llvm-libc-types/suseconds_t.h>
+#include <llvm-libc-types/time_t.h>
+
+struct timeval {
+  time_t tv_sec;       // Seconds
+  suseconds_t tv_usec; // Micro seconds
+};
+
+#endif // __LLVM_LIBC_TYPES_TIMEVAL_H__

libc/include/llvm-libc-types/suseconds_t.h

+//===-- Definition of suseconds_t type ------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef __LLVM_LIBC_TYPES_SUSECONDS_T_H__
+#define __LLVM_LIBC_TYPES_SUSECONDS_T_H__
+
+typedef __INT32_TYPE__ suseconds_t;
+
+#endif // __LLVM_LIBC_TYPES_SUSECONDS_T_H__

libc/spec/bsd_ext.td

HeaderSpec String = HeaderSpec<
         FunctionSpec<
             "strlcpy",
             RetValSpec<SizeTType>,
             [ArgSpec<CharPtr>, ArgSpec<ConstCharPtr>, ArgSpec<SizeTType>]
         >,
       ]
   >;
 
+  HeaderSpec SysWait = HeaderSpec<
+      "sys/wait.h",
+      [], // Macros
+      [StructRUsage], // Types
+      [], // Enumerations
+      [
+        FunctionSpec<
+            "wait4",
+            RetValSpec<PidT>,
+            [ArgSpec<PidT>, ArgSpec<IntPtr>, ArgSpec<IntType>, ArgSpec<StructRUsagePtr>]
+        >
+      ]
+  >;
+
   let Headers = [
     String,
+    SysWait,
   ];
 }

libc/spec/posix.td

HeaderSpec Time = HeaderSpec<
               [ArgSpec<ClockIdT>,ArgSpec<StructTimeSpecPtr>]
           >,
       ]
   >;
 
   HeaderSpec SysWait = HeaderSpec<
     "sys/wait.h",
     [], // Macros
-    [PidT],
+    [PidT, StructRUsage],
     [], // Enumerations
     [
       FunctionSpec<
         "wait",
         RetValSpec<PidT>,
         [ArgSpec<IntPtr>]
+      >,
+      FunctionSpec<
+        "waitpid",
+        RetValSpec<PidT>,
+        [ArgSpec<PidT>, ArgSpec<IntPtr>, ArgSpec<IntType>]
       >
     ]
   >;
 
   let Headers = [
     CType,
     Dirent,
     Errno,

libc/spec/spec.td

 
 def FILE : NamedType<"FILE">;
 def FILEPtr : PtrType<FILE>;
 def FILERestrictedPtr : RestrictedPtrType<FILE>;
 
 def PThreadTType : NamedType<"pthread_t">;
 
 def PidT : NamedType<"pid_t">;
+def StructRUsage : NamedType<"struct rusage">;
+def StructRUsagePtr : PtrType<StructRUsage>;
 
 //added because __assert_fail needs it.
 def UnsignedType : NamedType<"unsigned">;
 
 class Macro<string name> {
   string Name = name;
 }
 

libc/src/sys/wait/CMakeLists.txt

 if(EXISTS ${CMAKE_CURRENT_SOURCE_DIR}/${LIBC_TARGET_OS})
   add_subdirectory(${CMAKE_CURRENT_SOURCE_DIR}/${LIBC_TARGET_OS})
 endif()
 
 add_entrypoint_object(
   wait
   ALIAS
   DEPENDS
     .${LIBC_TARGET_OS}.wait
 )
+
+add_entrypoint_object(
+  wait4
+  ALIAS
+  DEPENDS
+    .${LIBC_TARGET_OS}.wait4
+)
+
+add_entrypoint_object(
+  waitpid
+  ALIAS
+  DEPENDS
+    .${LIBC_TARGET_OS}.waitpid
+)

libc/src/sys/wait/linux/CMakeLists.txt

 add_entrypoint_object(
   wait
   SRCS
     wait.cpp
   HDRS
     ../wait.h
   DEPENDS
     libc.include.errno
     libc.include.sys_wait
     libc.include.sys_syscall
     libc.src.__support.OSUtil.osutil
     libc.src.errno.errno
 )
+
+add_entrypoint_object(
+  wait4
+  SRCS
+    wait4.cpp
+  HDRS
+    ../wait4.h
+  DEPENDS
+    libc.include.errno
+    libc.include.sys_wait
+    libc.include.sys_syscall
+    libc.src.__support.OSUtil.osutil
+    libc.src.errno.errno
+)
+
+add_entrypoint_object(
+  waitpid
+  SRCS
+    waitpid.cpp
+  HDRS
+    ../waitpid.h
+  DEPENDS
+    libc.include.errno
+    libc.include.sys_wait
+    libc.include.sys_syscall
+    libc.src.__support.OSUtil.osutil
+    libc.src.errno.errno
+)

libc/src/sys/wait/linux/wait4.cpp

+//===-- Linux implementation of wait4 -------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#include "src/sys/wait/wait4.h"
+
+#include "src/__support/OSUtil/syscall.h" // For internal syscall function.
+#include "src/__support/common.h"
+
+#include <errno.h>
+#include <sys/syscall.h> // For syscall numbers.
+#include <sys/wait.h>
+
+namespace __llvm_libc {
+
+LLVM_LIBC_FUNCTION(pid_t, wait4,
+                   (pid_t pid, int *wait_status, int options,
+                    struct rusage *usage)) {
+  pid = __llvm_libc::syscall_impl(SYS_wait4, pid, wait_status, options, usage);
+  if (pid < 0) {
+    errno = -pid;
+    return -1;
+  }
+  return pid;
+}
+
+} // namespace __llvm_libc

libc/src/sys/wait/linux/waitpid.cpp

+//===-- Linux implementation of waitpid -----------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#include "src/sys/wait/waitpid.h"
+
+#include "src/__support/OSUtil/syscall.h" // For internal syscall function.
+#include "src/__support/common.h"
+
+#include <errno.h>
+#include <sys/syscall.h> // For syscall numbers.
+#include <sys/wait.h>
+
+namespace __llvm_libc {
+
+LLVM_LIBC_FUNCTION(pid_t, waitpid, (pid_t pid, int *wait_status, int options)) {
+  pid = __llvm_libc::syscall_impl(SYS_wait4, pid, wait_status, options, 0);
+  if (pid < 0) {
+    errno = -pid;
+    return -1;
+  }
+  return pid;
+}
+
+} // namespace __llvm_libc

libc/src/sys/wait/wait4.h

+//===-- Implementation header for wait4 -------------------------*- C++ -*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_LIBC_SRC_SYS_WAIT_WAIT4_H
+#define LLVM_LIBC_SRC_SYS_WAIT_WAIT4_H
+
+#include <sys/wait.h>
+
+namespace __llvm_libc {
+
+pid_t wait4(pid_t pid, int *waitstatus, int options, struct rusage *usage);
+
+} // namespace __llvm_libc
+
+#endif // LLVM_LIBC_SRC_SYS_WAIT_WAIT4_H

libc/src/sys/wait/waitpid.h

+//===-- Implementation header for waitpid -----------------------*- C++ -*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_LIBC_SRC_SYS_WAIT_WAITPID_H
+#define LLVM_LIBC_SRC_SYS_WAIT_WAITPID_H
+
+#include <sys/wait.h>
+
+namespace __llvm_libc {
+
+pid_t waitpid(pid_t pid, int *waitstatus, int options);
+
+} // namespace __llvm_libc
+
+#endif // LLVM_LIBC_SRC_SYS_WAIT_WAITPID_H

libc/test/integration/src/unistd/CMakeLists.txt

LOADER
     libc.loader.linux.crt1
   DEPENDS
     libc.include.errno
     libc.include.signal
     libc.include.sys_wait
     libc.include.unistd
     libc.src.signal.raise
     libc.src.sys.wait.wait
+    libc.src.sys.wait.wait4
+    libc.src.sys.wait.waitpid
     libc.src.unistd.fork
 )

libc/test/integration/src/unistd/fork_test.cpp

 //===-- Unittests for fork ------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "src/signal/raise.h"
 #include "src/sys/wait/wait.h"
+#include "src/sys/wait/wait4.h"
+#include "src/sys/wait/waitpid.h"
 #include "src/unistd/fork.h"
 
 #include "utils/IntegrationTest/test.h"
 
 #include <errno.h>
 #include <signal.h>
 #include <sys/wait.h>
 #include <unistd.h>
 
+// The tests wait4 and waitpid are present as tests for those functions
+// really and not for the fork function. They are here along with the tests
+// for fork because it is convenient to invoke and test them after forking
+// a child.
+
 void fork_and_wait_normal_exit() {
   pid_t pid = __llvm_libc::fork();
   if (pid == 0)
     return; // Just end without any thing special.
   ASSERT_TRUE(pid > 0);
   int status;
   pid_t cpid = __llvm_libc::wait(&status);
   ASSERT_TRUE(cpid > 0);
   ASSERT_EQ(cpid, pid);
   ASSERT_TRUE(WIFEXITED(status));
 }
 
+void fork_and_wait4_normal_exit() {
+  pid_t pid = __llvm_libc::fork();
+  if (pid == 0)
+    return; // Just end without any thing special.
+  ASSERT_TRUE(pid > 0);
+  int status;
+  struct rusage usage;
+  usage.ru_utime = {0, 0};
+  usage.ru_stime = {0, 0};
+  pid_t cpid = __llvm_libc::wait4(pid, &status, 0, &usage);
+  ASSERT_TRUE(cpid > 0);
+  ASSERT_EQ(cpid, pid);
+  ASSERT_TRUE(WIFEXITED(status));
+}
+
+void fork_and_waitpid_normal_exit() {
+  pid_t pid = __llvm_libc::fork();
+  if (pid == 0)
+    return; // Just end without any thing special.
+  ASSERT_TRUE(pid > 0);
+  int status;
+  pid_t cpid = __llvm_libc::waitpid(pid, &status, 0);
+  ASSERT_TRUE(cpid > 0);
+  ASSERT_EQ(cpid, pid);
+  ASSERT_TRUE(WIFEXITED(status));
+}
+
 void fork_and_wait_signal_exit() {
   pid_t pid = __llvm_libc::fork();
   if (pid == 0)
     __llvm_libc::raise(SIGUSR1);
   ASSERT_TRUE(pid > 0);
   int status;
   pid_t cpid = __llvm_libc::wait(&status);
   ASSERT_TRUE(cpid > 0);
   ASSERT_EQ(cpid, pid);
   ASSERT_FALSE(WIFEXITED(status));
   ASSERT_TRUE(WTERMSIG(status) == SIGUSR1);
 }
 
+void fork_and_wait4_signal_exit() {
+  pid_t pid = __llvm_libc::fork();
+  if (pid == 0)
+    __llvm_libc::raise(SIGUSR1);
+  ASSERT_TRUE(pid > 0);
+  int status;
+  struct rusage usage;
+  usage.ru_utime = {0, 0};
+  usage.ru_stime = {0, 0};
+  pid_t cpid = __llvm_libc::wait4(pid, &status, 0, &usage);
+  ASSERT_TRUE(cpid > 0);
+  ASSERT_EQ(cpid, pid);
+  ASSERT_FALSE(WIFEXITED(status));
+  ASSERT_TRUE(WTERMSIG(status) == SIGUSR1);
+}
+
+void fork_and_waitpid_signal_exit() {
+  pid_t pid = __llvm_libc::fork();
+  if (pid == 0)
+    __llvm_libc::raise(SIGUSR1);
+  ASSERT_TRUE(pid > 0);
+  int status;
+  pid_t cpid = __llvm_libc::waitpid(pid, &status, 0);
+  ASSERT_TRUE(cpid > 0);
+  ASSERT_EQ(cpid, pid);
+  ASSERT_FALSE(WIFEXITED(status));
+  ASSERT_TRUE(WTERMSIG(status) == SIGUSR1);
+}
+
 TEST_MAIN(int argc, char **argv, char **envp) {
   fork_and_wait_normal_exit();
+  fork_and_wait4_normal_exit();
+  fork_and_waitpid_normal_exit();
   fork_and_wait_signal_exit();
+  fork_and_wait4_signal_exit();
+  fork_and_waitpid_signal_exit();
   return 0;
 }

libc/test/src/sys/CMakeLists.txt

 add_subdirectory(mman)
 add_subdirectory(resource)
 add_subdirectory(sendfile)
 add_subdirectory(stat)
 add_subdirectory(utsname)
+add_subdirectory(wait)

libc/test/src/sys/wait/CMakeLists.txt

+add_libc_testsuite(libc_sys_wait_unittests)
+
+add_libc_unittest(
+  waitpid_test
+  SUITE
+    libc_sys_stat_unittests
+  SRCS
+    waitpid_test.cpp
+  DEPENDS
+    libc.include.errno
+    libc.include.sys_wait
+    libc.src.sys.wait.waitpid
+)
+
+add_libc_unittest(
+  wait4_test
+  SUITE
+    libc_sys_stat_unittests
+  SRCS
+    wait4_test.cpp
+  DEPENDS
+    libc.include.errno
+    libc.include.sys_wait
+    libc.src.sys.wait.wait4
+)

libc/test/src/sys/wait/wait4_test.cpp

+//===-- Unittests for wait4 -----------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#include "src/sys/wait/wait4.h"
+#include "test/ErrnoSetterMatcher.h"
+#include "utils/UnitTest/Test.h"
+
+#include <errno.h>
+#include <sys/wait.h>
+
+// The test here is a simpl test for WNOHANG functionality. For a more
+// involved test, look at fork_test.
+
+TEST(LlvmLibcwait4Test, NoHangTest) {
+  using __llvm_libc::testing::ErrnoSetterMatcher::Fails;
+  int status;
+  ASSERT_THAT(__llvm_libc::wait4(-1, &status, WNOHANG, nullptr), Fails(ECHILD));
+}

libc/test/src/sys/wait/waitpid_test.cpp

+//===-- Unittests for waitpid ---------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#include "src/sys/wait/waitpid.h"
+#include "test/ErrnoSetterMatcher.h"
+#include "utils/UnitTest/Test.h"
+
+#include <errno.h>
+#include <sys/wait.h>
+
+// The test here is a simpl test for WNOHANG functionality. For a more
+// involved test, look at fork_test.
+
+TEST(LlvmLibcWaitPidTest, NoHangTest) {
+  using __llvm_libc::testing::ErrnoSetterMatcher::Fails;
+  int status;
+  ASSERT_THAT(__llvm_libc::waitpid(-1, &status, WNOHANG), Fails(ECHILD));
+}