[libc] Add a minimal implementation of the POSIX fork function.

[sivachandra]

Summary

A very simple and minimal implementation of fork is added. Future
changes will add more functionality to satisfy POSIX and Linux
requirements.

An implementation of wait and a few support macros in sys/wait.h
have also been added to help with testing the fork function.

[lntue]

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

14

((status) & 0x7F) instead.

libc/src/unistd/linux/fork.cpp

25

SYS_fork?

[sivachandra]

Fix typos and other copy-paste errors.

[michaelrj]

LGTM

libc/config/linux/api.td

def SysResourceAPI : PublicAPI<"sys/resource.h"> {
   let Types = ["rlim_t", "struct rlimit"];
 }
 
 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"];
+}
+
 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.lstat
     libc.src.sys.stat.mkdir
     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
+
     # 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.src.unistd.fchdir
list(APPEND TARGET_LIBC_ENTRYPOINTS
     # time.h entrypoints
     libc.src.time.asctime
     libc.src.time.asctime_r
     libc.src.time.gmtime
     libc.src.time.gmtime_r
     libc.src.time.mktime
     libc.src.time.nanosleep
     libc.src.time.clock_gettime
+
+    # unistd.h entrypoints
+    libc.src.unistd.fork
   )
 endif()
 
 set(TARGET_LLVMLIBC_ENTRYPOINTS
   ${TARGET_LIBC_ENTRYPOINTS}
   ${TARGET_LIBM_ENTRYPOINTS}
 )

libc/include/CMakeLists.txt

 add_gen_header(
   unistd
   DEF_FILE unistd.h.def
   GEN_HDR unistd.h
   DEPENDS
     .llvm_libc_common_h
     .llvm-libc-macros.file_seek_macros
     .llvm-libc-macros.unistd_macros
+    .llvm-libc-types.off_t
     .llvm-libc-types.pid_t
     .llvm-libc-types.size_t
     .llvm-libc-types.ssize_t
     .llvm-libc-types.uid_t
 )
 
 add_gen_header(
   pthread
add_gen_header(
   sys_utsname
   DEF_FILE sys/utsname.h.def
   GEN_HDR sys/utsname.h
   DEPENDS
     .llvm_libc_common_h
     .llvm-libc-types.struct_utsname
 )
 
+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
+)
+
 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)
   set(all_deps ${ARGN})
   foreach(target IN LISTS ARGN)

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

add_header(
   sys_resource_macros
   HDR
     sys-resource-macros.h
   DEPENDS
     .linux.sys_resource_macros
 )
 
 add_header(
+  sys_wait_macros
+  HDR
+    sys-wait-macros.h
+  DEPENDS
+    .linux.sys_wait_macros
+)
+
+add_header(
   time_macros
   HDR
     time-macros.h
   DEPENDS
     .linux.time_macros
 )
 
 add_header(
   unistd_macros
   HDR
     unistd-macros.h
   DEPENDS
     .linux.unistd_macros
 )

libc/include/llvm-libc-macros/linux/CMakeLists.txt

 
 add_header(
   sys_stat_macros
   HDR
     sys-stat-macros.h
 )
 
 add_header(
+  sys_wait_macros
+  HDR
+    sys-wait-macros.h
+)
+
+add_header(
   time_macros
   HDR
     time-macros.h
 )
 
 add_header(
   sys_resource_macros
   HDR

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 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-macros/sys-wait-macros.h

+//===-- Macros defined in sys/wait.h header file --------------------------===//
+//
+// 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_SYS_WAIT_MACROS_H
+#define __LLVM_LIBC_MACROS_SYS_WAIT_MACROS_H
+
+#ifdef __linux__
+#include "linux/sys-wait-macros.h"
+#endif
+
+#endif // __LLVM_LIBC_MACROS_SYS_WAIT_MACROS_H

libc/include/sys/wait.h.def

+//===-- POSIX header 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_SYS_WAIT_H
+#define LLVM_LIBC_SYS_WAIT_H
+
+#include <__llvm-libc-common.h>
+
+#include <llvm-libc-macros/sys-wait-macros.h>
+
+%%public_api()
+
+#endif // LLVM_LIBC_SYS_WAIT_H

libc/spec/posix.td

[
           [ArgSpec<IntType>]
         >,
         FunctionSpec<
           "close",
           RetValSpec<IntType>,
           [ArgSpec<IntType>]
         >,
         FunctionSpec<
+          "fork",
+          RetValSpec<PidT>,
+          [ArgSpec<VoidType>]
+        >,
+        FunctionSpec<
           "fsync",
           RetValSpec<IntType>,
           [ArgSpec<IntType>]
         >,
         FunctionSpec<
           "ftruncate",
           RetValSpec<IntType>,
           [ArgSpec<ConstCharPtr>, ArgSpec<OffTType>]
HeaderSpec Time = HeaderSpec<
           FunctionSpec<
               "clock_gettime",
               RetValSpec<IntType>,
               [ArgSpec<ClockIdT>,ArgSpec<StructTimeSpecPtr>]
           >,
       ]
   >;
 
+  HeaderSpec SysWait = HeaderSpec<
+    "sys/wait.h",
+    [], // Macros
+    [PidT],
+    [], // Enumerations
+    [
+      FunctionSpec<
+        "wait",
+        RetValSpec<PidT>,
+        [ArgSpec<IntPtr>]
+      >
+    ]
+  >;
+
   let Headers = [
     CType,
     Dirent,
     Errno,
     FCntl,
     PThread,
     Signal,
     StdIO,
     StdLib,
     SysMMan,
     SysResource,
     SysStat,
     SysUtsName,
+    SysWait,
     Time,
     UniStd,
     String
   ];
 }

libc/src/sys/CMakeLists.txt

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

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

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

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

+//===-- Linux implementation of wait --------------------------------------===//
+//
+// 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/wait.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 {
+
+// The implementation of wait here is very minimal. We will add more
+// functionality and standard compliance in future.
+
+LLVM_LIBC_FUNCTION(pid_t, wait, (int *wait_status)) {
+  pid_t pid = __llvm_libc::syscall_impl(SYS_wait4, -1, wait_status, 0, 0);
+  if (pid < 0) {
+    // Error case, a child process was not created.
+    errno = -pid;
+    return -1;
+  }
+
+  return pid;
+}
+
+} // namespace __llvm_libc

libc/src/sys/wait/wait.h

+//===-- Implementation header for wait --------------------------*- 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_WAIT_H
+#define LLVM_LIBC_SRC_SYS_WAIT_WAIT_H
+
+#include <sys/wait.h>
+
+namespace __llvm_libc {
+
+pid_t wait(int *waitstatus);
+
+} // namespace __llvm_libc
+
+#endif // LLVM_LIBC_SRC_SYS_WAIT_WAIT_H

libc/src/unistd/CMakeLists.txt

 add_entrypoint_object(
   fchdir
   ALIAS
   DEPENDS
     .${LIBC_TARGET_OS}.fchdir
 )
 
 add_entrypoint_object(
+  fork
+  ALIAS
+  DEPENDS
+    .${LIBC_TARGET_OS}.fork
+)
+
+add_entrypoint_object(
   fsync
   ALIAS
   DEPENDS
     .${LIBC_TARGET_OS}.fsync
 )
 
 add_entrypoint_object(
   ftruncate

libc/src/unistd/fork.h

+//===-- Implementation header for fork --------------------------*- 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_UNISTD_FORK_H
+#define LLVM_LIBC_SRC_UNISTD_FORK_H
+
+#include <unistd.h>
+
+namespace __llvm_libc {
+
+pid_t fork();
+
+} // namespace __llvm_libc
+
+#endif // LLVM_LIBC_SRC_UNISTD_FORK_H

libc/src/unistd/linux/CMakeLists.txt

add_entrypoint_object(
   DEPENDS
     libc.include.unistd
     libc.include.sys_syscall
     libc.src.__support.OSUtil.osutil
     libc.src.errno.errno
 )
 
 add_entrypoint_object(
+  fork
+  SRCS
+    fork.cpp
+  HDRS
+    ../fork.h
+  DEPENDS
+    libc.include.errno
+    libc.include.unistd
+    libc.include.sys_syscall
+    libc.src.__support.OSUtil.osutil
+    libc.src.__support.threads.thread
+    libc.src.errno.errno
+)
+
+add_entrypoint_object(
   fsync
   SRCS
     fsync.cpp
   HDRS
     ../fsync.h
   DEPENDS
     libc.include.unistd
     libc.include.sys_syscall

libc/src/unistd/linux/fork.cpp

+//===-- Linux implementation of 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/unistd/fork.h"
+
+#include "src/__support/OSUtil/syscall.h" // For internal syscall function.
+#include "src/__support/common.h"
+#include "src/__support/threads/thread.h" // For thread self object
+
+#include <errno.h>
+#include <sys/syscall.h> // For syscall numbers.
+
+namespace __llvm_libc {
+
+// The implementation of fork here is very minimal. We will add more
+// functionality and standard compliance in future.
+
+LLVM_LIBC_FUNCTION(pid_t, fork, (void)) {
+#ifdef SYS_fork
+  pid_t ret = __llvm_libc::syscall_impl(SYS_fork);
+#elif defined(SYS_clone)
+  pid_t ret = __llvm_libc::syscall_impl(SYS_clone, SIGCHLD, 0);
+#else
+#error "SYS_fork or SYS_clone not available."
+#endif
+  if (ret == 0) {
+    // Return value is 0 in the child process.
+    // The child is created with a single thread whose self object will be a
+    // copy of parent process' thread which called fork. So, we have to fix up
+    // the child process' self object with the new process' tid.
+    self.attrib->tid = __llvm_libc::syscall_impl(SYS_gettid);
+    return 0;
+  }
+
+  if (ret < 0) {
+    // Error case, a child process was not created.
+    errno = -ret;
+    return -1;
+  }
+
+  return ret;
+}
+
+} // namespace __llvm_libc

libc/test/integration/src/CMakeLists.txt

 add_subdirectory(__support)
 add_subdirectory(pthread)
 add_subdirectory(stdio)
 add_subdirectory(stdlib)
 add_subdirectory(threads)
+add_subdirectory(unistd)

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

+add_custom_target(unistd-integration-tests)
+add_dependencies(libc-integration-tests unistd-integration-tests)
+
+add_integration_test(
+  fork_test
+  SUITE
+    unistd-integration-tests
+  SRCS
+    fork_test.cpp
+  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.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/unistd/fork.h"
+
+#include "utils/IntegrationTest/test.h"
+
+#include <errno.h>
+#include <signal.h>
+#include <sys/wait.h>
+#include <unistd.h>
+
+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_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);
+}
+
+TEST_MAIN(int argc, char **argv, char **envp) {
+  fork_and_wait_normal_exit();
+  fork_and_wait_signal_exit();
+  return 0;
+}