[libc] Add write(2) implementation for Linux and FDReader test utility

[abrachet]

Summary

Adds write for Linux and FDReader utility which should be useful for some stdio tests as well.

[sivachandra]

I have not read the FDReader implementation, but the rest of the change LG. I have couple comments though. I will do a final review once they are addressed.

libc/config/linux/api.td

319

I think write is part of the POSIX standard. So, we should prefer to put this in the wider standard.

libc/spec/posix.td

186

The POSIX standard says that unistd.h should define the ssize_t type. I think you should add the definition in this patch and use it. Since the standard expects multiple header files to define this type, you should put it in: https://github.com/llvm/llvm-project/blob/master/libc/include/__posix-types.h and "expose" the definition via unistd.h.

[abrachet]

Add ssize_t to __posix-types.h

[abrachet]

libc/config/linux/api.td

319

This is in the linux/api.td. We don't currently have a way to separate the common definitions into a common record files. The HeaderSpec is in posix.td though.

libc/spec/posix.td

186

Done. I think we will want to generate __posix-types.h eventually.

[sivachandra]

libc/config/linux/api.td

319

Sorry, I am not sure what I was thinking then.

libc/spec/posix.td

186

Agreed.

libc/test/src/unistd/write_test.cpp

20

Nitty nit: May be create a var for "hello".

[abrachet]

Move "hello" to a variable

libc/config/linux/api.td

 include "config/public_api.td"
 
 include "spec/gnu_ext.td"
 include "spec/linux.td"
 include "spec/posix.td"
 include "spec/stdc.td"
 
 def SizeT : TypeDecl<"size_t"> {
   let Decl = [{
     #define __need_size_t
     #include <stddef.h>
   }];
 }
 
+def SSizeT : TypeDecl<"ssize_t"> {
+  let Decl = [{
+    #define __need_ssize_t
+    #include <__posix-types.h>
+  }];
+}
+
 def OffT : TypeDecl<"off_t"> {
   let Decl = [{
     #define __need_off_t
     #include <__posix-types.h>
   }];
 }
 
 def FILE : TypeDecl<"FILE"> {
def ThreadsAPI : PublicAPI<"threads.h"> {
   let Functions = [
     "mtx_init",
     "mtx_lock",
     "mtx_unlock",
     "thrd_create",
     "thrd_join",
   ];
 }
+
+def UniStdAPI : PublicAPI<"unistd.h"> {
+  let TypeDeclarations = [
+    SSizeT,
+    SizeT,
+  ];
+
+  let Functions = [
+    "write",
+  ];
+}

libc/include/CMakeLists.txt

 add_gen_header(
   stdlib
   DEF_FILE stdlib.h.def
   GEN_HDR stdlib.h
   DEPENDS
     .llvm_libc_common_h
 )
 
+add_gen_header(
+  unistd
+  DEF_FILE unistd.h.def
+  GEN_HDR unistd.h
+  DEPENDS
+    .llvm_libc_common_h
+)
+
 # TODO: Not all platforms will have a include/sys directory. Add the sys
 # directory and the targets for sys/*.h files conditional to the OS requiring
 # them.
 file(MAKE_DIRECTORY "sys")
 
 add_gen_header(
   sys_mman
   DEF_FILE sys/mman.h.def

libc/include/__posix-types.h

 //===-- Definitions of common POSIX types ---------------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 // This header file does not have a header guard. It is internal to LLVM libc
 // and intended to be used to pick specific definitions without polluting the
 // public headers with unnecessary definitions.
 
 #if defined(__need_off_t) && !defined(__llvm_libc_off_t_defined)
 typedef __INT64_TYPE__ off_t;
 #define __llvm_libc_off_t_defined
 #endif // __need_off_t
+
+#if defined(__need_ssize_t) && !defined(__llvm_libc_ssize_t_defined)
+typedef __INT64_TYPE__ ssize_t;
+#define __llvm_libc_ssize_t_defined
+#endif // __need_ssize_t

libc/include/unistd.h.def

+//===-- C standard library header unistd.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_UNISTD_H
+#define LLVM_LIBC_UNISTD_H
+
+#include <__llvm-libc-common.h>
+
+%%public_api()
+
+#endif // LLVM_LIBC_UNISTD_H

libc/lib/CMakeLists.txt

DEPENDS
     libc.src.sys.mman.munmap
 
     # threads.h entrypoints
     libc.src.threads.mtx_init
     libc.src.threads.mtx_lock
     libc.src.threads.mtx_unlock
     libc.src.threads.thrd_create
     libc.src.threads.thrd_join
+
+    # unistd.h entrypoints
+    libc.src.unistd.write
 )
 
 add_entrypoint_library(
   llvmlibm
   DEPENDS
     # math.h entrypoints
     libc.src.math.cosf
     libc.src.math.round

libc/spec/posix.td

 def SigSetType : NamedType<"sigset_t">;
 def SigSetPtrType : PtrType<SigSetType>;
 def ConstSigSetPtrType : ConstType<SigSetPtrType>;
 def RestrictSigSetType : RestrictedPtrType<SigSetType>;
 def ConstRestrictSigSetType : ConstType<RestrictSigSetType>;
 
 def StructSigaction : NamedType<"struct sigaction">;
 def StructSigactionPtr : PtrType<StructSigaction>;
 def ConstStructSigactionPtr : ConstType<StructSigactionPtr>;
 def RestrictStructSigactionPtr : RestrictedPtrType<StructSigaction>;
 def ConstRestrictStructSigactionPtr : ConstType<RestrictStructSigactionPtr>;
 
 def POSIX : StandardSpec<"POSIX"> {
   NamedType OffTType = NamedType<"off_t">;
+  NamedType SSizeTType = NamedType<"ssize_t">;
 
   HeaderSpec Errno = HeaderSpec<
       "errno.h",
       [
         Macro<"E2BIG">,
         Macro<"EACCES">,
         Macro<"EADDRINUSE">,
         Macro<"EADDRNOTAVAIL">,
HeaderSpec Signal = HeaderSpec<
         FunctionSpec<
           "sigaddset",
           RetValSpec<IntType>,
           [ArgSpec<SigSetPtrType>]
         >,
       ]
   >;
 
+  HeaderSpec UniStd = HeaderSpec<
+    "unistd.h",
+    [], // Macros
+    [
+      SSizeTType,
+      SizeTType,
+    ],
+    [], // Enumerations
+    [
+        FunctionSpec<
+          "write",
+          RetValSpec<SSizeTType>,
+          [ArgSpec<IntType>, ArgSpec<ConstVoidPtr>, ArgSpec<SizeTType>]
+        >,
+    ]
+  >;
+
   let Headers = [
     Errno,
     SysMMan,
     Signal,
+    UniStd,
   ];
 }

libc/spec/spec.td

 def IntType : NamedType<"int">;
 def FloatType : NamedType<"float">;
 def DoubleType : NamedType<"double">;
 def LongDoubleType : NamedType<"long double">;
 def CharType : NamedType<"char">;
 
 // Common types
 def VoidPtr : PtrType<VoidType>;
+def ConstVoidPtr : ConstType<VoidPtr>;
 def SizeTType : NamedType<"size_t">;
 def FloatPtr : PtrType<FloatType>;
 
 // _Noreturn is really not a type, but it is convenient to treat it as a type.
 def NoReturn : NamedType<"_Noreturn void">;
 
 class Macro<string name> {
   string Name = name;

libc/src/CMakeLists.txt

 add_subdirectory(assert)
 add_subdirectory(errno)
 add_subdirectory(math)
 add_subdirectory(signal)
 add_subdirectory(stdio)
 add_subdirectory(stdlib)
 add_subdirectory(string)
 # TODO: Add this target conditional to the target OS.
 add_subdirectory(sys)
 add_subdirectory(threads)
+add_subdirectory(unistd)
 
 add_subdirectory(__support)

libc/src/unistd/CMakeLists.txt

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

libc/src/unistd/linux/CMakeLists.txt

+add_entrypoint_object(
+  write
+  SRCS
+    write.cpp
+  HDRS
+    ../write.h
+  DEPENDS
+    libc.include.unistd
+    libc.config.linux.linux_syscall_h
+    libc.include.sys_syscall
+    libc.src.errno.__errno_location
+)

libc/src/unistd/linux/write.cpp

+//===-- Linux implementation of write -------------------------------------===//
+//
+// 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/write.h"
+
+#include "config/linux/syscall.h" // For internal syscall function.
+#include "include/sys/syscall.h"  // For syscall numbers.
+#include "src/__support/common.h"
+#include "src/errno/llvmlibc_errno.h"
+
+namespace __llvm_libc {
+
+ssize_t LLVM_LIBC_ENTRYPOINT(write)(int fd, const void *buf, size_t count) {
+  long ret = __llvm_libc::syscall(SYS_write, fd, buf, count);
+  if (ret < 0) {
+    llvmlibc_errno = -ret;
+    return -1;
+  }
+  return ret;
+}
+
+} // namespace __llvm_libc

libc/src/unistd/write.h

+//===-- Implementation header for write -------------------------*- 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_WRITE_H
+#define LLVM_LIBC_SRC_UNISTD_WRITE_H
+
+#include "include/unistd.h"
+#include <stddef.h>
+
+namespace __llvm_libc {
+
+ssize_t write(int fd, const void *buf, size_t count);
+
+} // namespace __llvm_libc
+
+#endif // LLVM_LIBC_SRC_UNISTD_WRITE_H

libc/test/src/CMakeLists.txt

 add_subdirectory(assert)
 add_subdirectory(errno)
 add_subdirectory(math)
 add_subdirectory(signal)
 add_subdirectory(stdio)
 add_subdirectory(stdlib)
 add_subdirectory(string)
 add_subdirectory(sys)
 add_subdirectory(threads)
+add_subdirectory(unistd)

libc/test/src/unistd/CMakeLists.txt

+add_libc_testsuite(libc_unistd_unittests)
+
+add_libc_unittest(
+  write_test
+  SUITE
+    libc_unistd_unittests
+  SRCS
+    write_test.cpp
+  DEPENDS
+    libc.src.unistd.write
+    libc.include.errno
+    # TODO(sivachandra): Remove redundant deps.
+    libc.src.errno.__errno_location
+    libc.include.unistd
+)

libc/test/src/unistd/write_test.cpp

+//===-- Unittests for write -----------------------------------------------===//
+//
+// 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 "include/errno.h"
+#include "src/unistd/write.h"
+#include "utils/UnitTest/ErrnoSetterMatcher.h"
+#include "utils/UnitTest/Test.h"
+#include "utils/testutils/FDReader.h"
+
+TEST(UniStd, WriteBasic) {
+  using __llvm_libc::testing::ErrnoSetterMatcher::Succeeds;
+  constexpr const char *hello = "hello";
+  __llvm_libc::testutils::FDReader reader;
+  EXPECT_THAT(__llvm_libc::write(reader.getWriteFD(), hello, 5), Succeeds(5));
+  EXPECT_TRUE(reader.matchWritten(hello));
+}
+
+TEST(UniStd, WriteFails) {
+  using __llvm_libc::testing::ErrnoSetterMatcher::Fails;
+
+  EXPECT_THAT(__llvm_libc::write(-1, "", 1), Fails(EBADF));
+  EXPECT_THAT(__llvm_libc::write(1, reinterpret_cast<const void *>(-1), 1),
+              Fails(EFAULT));
+}

libc/utils/testutils/CMakeLists.txt

 if(CMAKE_HOST_UNIX)
   set(EFFile ExecuteFunctionUnix.cpp)
+  set(FDReaderFile FDReaderUnix.cpp)
 endif()
 
 add_llvm_library(
   libc_test_utils
   StreamWrapper.cpp
   StreamWrapper.h
   ${EFFile}
   ExecuteFunction.h
+  ${FDReaderFile}
+  FDReader.h
   LINK_COMPONENTS
     Support
 )

libc/utils/testutils/FDReader.h

+//===-- FDReader.h ----------------------------------------------*- 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_UTILS_TESTUTILS_FDREADER_H
+#define LLVM_LIBC_UTILS_TESTUTILS_FDREADER_H
+
+namespace __llvm_libc {
+namespace testutils {
+
+class FDReader {
+  int pipefd[2];
+
+public:
+  FDReader();
+  ~FDReader();
+
+  int getWriteFD() { return pipefd[1]; }
+  bool matchWritten(const char *);
+};
+
+} // namespace testutils
+} // namespace __llvm_libc
+
+#endif // LLVM_LIBC_UTILS_TESTUTILS_FDREADER_H

libc/utils/testutils/FDReaderUnix.cpp

+//===-- FDReader.cpp ------------------------------------------------------===//
+//
+// 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 "FDReader.h"
+#include "llvm/Support/MemoryBuffer.h"
+#include <cassert>
+#include <cstring>
+#include <unistd.h>
+
+namespace __llvm_libc {
+namespace testutils {
+
+FDReader::FDReader() {
+  int err = ::pipe(pipefd);
+  assert(!err && "pipe(2) failed");
+}
+
+FDReader::~FDReader() {
+  ::close(pipefd[0]);
+  ::close(pipefd[1]);
+}
+
+bool FDReader::matchWritten(const char *str) {
+  llvm::ErrorOr<std::unique_ptr<llvm::MemoryBuffer>> bufOrErr =
+      llvm::MemoryBuffer::getOpenFile(pipefd[0], "<pipe>",
+                                      /* FileSize (irrelevant) */ 0);
+  if (!bufOrErr) {
+    assert(0 && "Error reading from pipe");
+    return false;
+  }
+  const llvm::MemoryBuffer &buf = **bufOrErr;
+  return !std::strncmp(buf.getBufferStart(), str, buf.getBufferSize());
+}
+
+} // namespace testutils
+} // namespace __llvm_libc