[libc] Add POSIX close, fsync, open, read and write functions.

[sivachandra]

Summary

They are implemented as simple syscall wrappers. The file creation
macros have been put in a header file as a temporary solution until we
have a cleaner approach to listing platform relevant macros.

[abrachet]

libc/include/llvm-libc-macros/linux/fcntl-macros.h

2

With errno we just include linux/errno.h can we use linux/fcntl.h?

[sivachandra]

libc/include/llvm-libc-macros/linux/fcntl-macros.h

2

I think, including linux headers was an error on our part. Primary reason is that the linux headers bring in more names and pollute the user namespace. I think there are ways to avoid this hard-coding as done in this patch, but I will propose that in a follow up patch.

libc/config/linux/api.td

let Macros = [
     AssertMacro,
     StaticAssertMacro,
   ];
 }
 
 def CTypeAPI : PublicAPI<"ctype.h"> {
 }
 
+def FCntlAPI : PublicAPI<"fcntl.h"> {
+  let Types = ["mode_t"];
+}
+
 def IntTypesAPI : PublicAPI<"inttypes.h"> {
   let Types = ["imaxdiv_t"];
 }
 
 def MathErrHandlingMacro : MacroDef<"math_errhandling"> {
   let Defn = [{
     #ifndef math_errhandling
     #ifdef __FAST_MATH__

libc/config/linux/x86_64/entrypoints.txt

set(TARGET_LIBC_ENTRYPOINTS
     libc.src.ctype.isxdigit
     libc.src.ctype.toascii
     libc.src.ctype.tolower
     libc.src.ctype.toupper
 
     # errno.h entrypoints
     libc.src.errno.__errno_location
 
+    # fcntl.h entrypoints
+    libc.src.fcntl.open
+
     # string.h entrypoints
     libc.src.string.bcmp
     libc.src.string.bzero
     libc.src.string.memccpy
     libc.src.string.memchr
     libc.src.string.memcmp
     libc.src.string.memcpy
     libc.src.string.memmove
set(TARGET_LIBC_ENTRYPOINTS
     libc.src.stdlib.strtoul
     libc.src.stdlib.strtoull
 
     # sys/mman.h entrypoints
     libc.src.sys.mman.mmap
     libc.src.sys.mman.munmap
 
     # unistd.h entrypoints
+    libc.src.unistd.close
+    libc.src.unistd.fsync
+    libc.src.unistd.read
     libc.src.unistd.write
 )
 
 set(TARGET_LIBM_ENTRYPOINTS
     # fenv.h entrypoints
     libc.src.fenv.feclearexcept
     libc.src.fenv.fedisableexcept
     libc.src.fenv.feenableexcept

libc/include/CMakeLists.txt

+add_subdirectory(llvm-libc-macros)
 add_subdirectory(llvm-libc-types)
 
 add_header(
   llvm_libc_common_h
   HDR
     __llvm-libc-common.h
 )
 
 add_gen_header(
   ctype
   DEF_FILE ctype.h.def
   GEN_HDR ctype.h
   DEPENDS
     .llvm_libc_common_h
 )
 
 add_gen_header(
+  fcntl
+  DEF_FILE fcntl.h.def
+  GEN_HDR fcntl.h
+  DEPENDS
+    .llvm_libc_common_h
+    .llvm-libc-macros.fcntl_macros
+    .llvm-libc-types.mode_t
+)
+
+add_gen_header(
   fenv
   DEF_FILE fenv.h.def
   GEN_HDR fenv.h
   DEPENDS
     .llvm_libc_common_h
     .llvm-libc-types.fenv_t
     .llvm-libc-types.fexcept_t
 )

libc/include/fcntl.h.def

+//===-- C standard library header fcntl.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_FCNTL_H
+#define LLVM_LIBC_FCNTL_H
+
+#include <__llvm-libc-common.h>
+#include <llvm-libc-macros/fcntl-macros.h>
+
+%%public_api()
+
+#endif // LLVM_LIBC_FCNTL_H 

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

+add_subdirectory(linux)
+
+add_header(
+  fcntl_macros
+  HDR
+    fcntl-macros.h
+  DEPENDS
+    .linux.fcntl_macros
+)

libc/include/llvm-libc-macros/fcntl-macros.h

+#ifndef __LLVM_LIBC_MACROS_FCNTL_MACROS_H
+#define __LLVM_LIBC_MACROS_FCNTL_MACROS_H
+
+#ifdef __unix__
+#include "linux/fcntl-macros.h"
+#endif
+
+#endif // __LLVM_LIBC_MACROS_FCNTL_MACROS_H

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

+add_header(
+  fcntl_macros
+  HDR
+    fcntl-macros.h
+)

libc/include/llvm-libc-macros/linux/fcntl-macros.h

+//===-- Definition of macros from fcntl.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_FCNTL_MACROS_H
+#define __LLVM_LIBC_MACROS_LINUX_FCNTL_MACROS_H
+
+// File creation flags
+#define O_CLOEXEC 02000000
+#define O_CREAT 00000100
+#define O_DIRECTORY 00200000
+#define O_EXCL 00000200
+#define O_NOCTTY 00000400
+#define O_NOFOLLOW 00400000
+#define O_TRUNC 00001000
+#define O_TMPFILE (020000000 | O_DIRECTORY)
+
+// File status flags
+#define O_APPEND 00002000
+#define O_DSYNC 00010000
+#define O_NONBLOCK 00004000
+#define O_SYNC 04000000 | O_DSYNC
+
+// File access mode mask
+#define O_ACCMODE 00000003
+
+// File access mode flags
+#define O_RDONLY 00000000
+#define O_RDWR 00000002
+#define O_WRONLY 00000001
+
+// File mode flags
+#define S_IRWXU 0700
+#define S_IRUSR 0400
+#define S_IWUSR 0200
+#define S_IXUSR 0100
+#define S_IRWXG 070
+#define S_IRGRP 040
+#define S_IWGRP 020
+#define S_IXGRP 010
+#define S_IRWXO 07
+#define S_IROTH 04
+#define S_IWOTH 02
+#define S_IXOTH 01
+#define S_ISUID 04000
+#define S_ISGID 02000
+
+#endif // __LLVM_LIBC_MACROS_LINUX_FCNTL_MACROS_H

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

 add_header(__bsearchcompare_t HDR __bsearchcompare_t.h)
 add_header(__call_once_func_t HDR __call_once_func_t.h)
 add_header(__qsortcompare_t HDR __qsortcompare_t.h)
 add_header(__sighandler_t HDR __sighandler_t.h)
 add_header(cnd_t HDR cnd_t.h)
 add_header(double_t HDR double_t.h)
 add_header(div_t HDR div_t.h)
 add_header(ldiv_t HDR ldiv_t.h)
 add_header(lldiv_t HDR lldiv_t.h)
 add_header(FILE HDR FILE.h)
 add_header(fenv_t HDR fenv_t.h)
 add_header(fexcept_t HDR fexcept_t.h)
 add_header(float_t HDR float_t.h)
 add_header(imaxdiv_t HDR imaxdiv_t.h)
+add_header(mode_t HDR mode_t.h)
 add_header(mtx_t HDR mtx_t.h)
 add_header(off_t HDR off_t.h)
 add_header(once_flag HDR once_flag.h)
 add_header(size_t HDR size_t.h)
 add_header(ssize_t HDR ssize_t.h)
 add_header(struct_sigaction HDR struct_sigaction.h)
 add_header(struct_tm HDR struct_tm.h)
 add_header(thrd_start_t HDR thrd_start_t.h)
 add_header(thrd_t HDR thrd_t.h)
 add_header(time_t HDR time_t.h)

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

+//===-- Definition of mode_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_MODE_T_H
+#define __LLVM_LIBC_TYPES_MODE_T_H
+
+typedef unsigned mode_t;
+
+#endif // __LLVM_LIBC_TYPES_MODE_T_H

libc/spec/posix.td

 
 def POSIX : StandardSpec<"POSIX"> {
   PtrType CharPtr = PtrType<CharType>;
   RestrictedPtrType RestrictedCharPtr = RestrictedPtrType<CharType>;
   RestrictedPtrType CharRestrictedDoublePtr = RestrictedPtrType<CharPtr>;
   ConstType ConstCharPtr = ConstType<CharPtr>;
   ConstType ConstRestrictedCharPtr = ConstType<RestrictedCharPtr>;
 
+  NamedType ModeTType = NamedType<"mode_t">;
   NamedType OffTType = NamedType<"off_t">;
   NamedType SSizeTType = NamedType<"ssize_t">;
 
   HeaderSpec Errno = HeaderSpec<
       "errno.h",
       [
         Macro<"E2BIG">,
         Macro<"EACCES">,
HeaderSpec Errno = HeaderSpec<
         Macro<"EWOULDBLOCK">,
         Macro<"EXDEV">,
       ],
       [], // Types
       [], // Enumerations
       []  // Functions
   >;
 
+  HeaderSpec FCntl = HeaderSpec<
+    "fcntl.h",
+    [], // Macros
+    [ModeTType],
+    [], // Enumerations
+    [
+      FunctionSpec<
+          "open",
+          RetValSpec<IntType>,
+          [ArgSpec<ConstCharPtr>, ArgSpec<IntType>, ArgSpec<VarArgType>]
+      >,
+    ]
+  >;
+
   HeaderSpec SysMMan = HeaderSpec<
       "sys/mman.h",
       [
         // TODO: Add a facility to bunch macros into bitwise-or-able groups.
         // POSIX requires it, so such thing should be captured in this spec.
         Macro<"PROT_EXEC">,
         Macro<"PROT_NONE">,
         Macro<"PROT_READ">,
HeaderSpec UniStd = HeaderSpec<
     [], // Macros
     [
       SSizeTType,
       SizeTType,
     ],
     [], // Enumerations
     [
         FunctionSpec<
+          "close",
+          RetValSpec<IntType>,
+          [ArgSpec<IntType>]
+        >,
+        FunctionSpec<
+          "fsync",
+          RetValSpec<IntType>,
+          [ArgSpec<IntType>]
+        >,
+        FunctionSpec<
+          "read",
+          RetValSpec<SSizeTType>,
+          [ArgSpec<IntType>, ArgSpec<VoidPtr>, ArgSpec<SizeTType>]
+        >,
+        FunctionSpec<
           "write",
           RetValSpec<SSizeTType>,
           [ArgSpec<IntType>, ArgSpec<ConstVoidPtr>, ArgSpec<SizeTType>]
         >,
     ]
   >;
   
   HeaderSpec String = HeaderSpec<
[
             [ArgSpec<IntType>]
         >,
     ]
   >;
 
   let Headers = [
     CType,
     Errno,
+    FCntl,
     SysMMan,
     Signal,
     UniStd,
     String
   ];
 }

libc/src/CMakeLists.txt

 add_subdirectory(__support)
 
 add_subdirectory(ctype)
 add_subdirectory(errno)
 add_subdirectory(fenv)
 add_subdirectory(inttypes)
 add_subdirectory(math)
 add_subdirectory(string)
 add_subdirectory(stdlib)
 
 if(${LIBC_TARGET_OS} STREQUAL "linux")
+  add_subdirectory(fcntl)
   add_subdirectory(sys)
   add_subdirectory(unistd)
 endif()
 
 if(NOT LLVM_LIBC_FULL_BUILD)
   return()
 endif()
 
 # The signal API is currently disabled as signal.h is incorrect.
 # since assert uses the signal API, we disable assert also.
 # add_subdirectory(assert)
 # add_subdirectory(signal)
 add_subdirectory(stdio)
 add_subdirectory(threads)
 add_subdirectory(time)

libc/src/fcntl/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
+  open
   ALIAS
   DEPENDS
-    .${LIBC_TARGET_OS}.write
+    .${LIBC_TARGET_OS}.open
 )

libc/src/fcntl/linux/CMakeLists.txt

 add_entrypoint_object(
-  write
+  open
   SRCS
-    write.cpp
+    open.cpp
   HDRS
-    ../write.h
+    ../open.h
   DEPENDS
-    libc.include.unistd
-    libc.include.sys_syscall
+    libc.include.errno
+    libc.include.fcntl
     libc.src.__support.OSUtil.osutil
     libc.src.errno.__errno_location
 )

libc/src/fcntl/linux/open.cpp

+//===-- Implementation of open --------------------------------------------===//
+//
+// 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/fcntl/open.h"
+
+#include "src/__support/OSUtil/syscall.h" // For internal syscall function.
+#include "src/__support/common.h"
+
+#include <errno.h>
+#include <fcntl.h>
+#include <stdarg.h>
+#include <sys/syscall.h> // For syscall numbers.
+
+namespace __llvm_libc {
+
+LLVM_LIBC_FUNCTION(int, open, (const char *path, int flags, ...)) {
+  mode_t mode_flags = 0;
+  // O_TMPFILE is a multi-bit flag so we test all bits by checking for equality
+  // with O_TMPFILE
+  if ((flags & O_CREAT) || (flags & O_TMPFILE) == O_TMPFILE) {
+    va_list varargs;
+    va_start(varargs, flags);
+    mode_flags = va_arg(varargs, mode_t);
+    va_end(varargs);
+  }
+
+  int fd = __llvm_libc::syscall(SYS_open, path, flags, mode_flags);
+  if (fd > 0)
+    return fd;
+
+  errno = -fd;
+  return -1;
+}
+
+} // namespace __llvm_libc

libc/src/fcntl/open.h

+//===-- Implementation header of open ---------------------------*- 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_FCNTL_OPEN_H
+#define LLVM_LIBC_SRC_FCNTL_OPEN_H
+
+#include <fcntl.h>
+
+namespace __llvm_libc {
+
+int open(const char *path, int flags, ...);
+
+} // namespace __llvm_libc
+
+#endif // LLVM_LIBC_SRC_FCNTL_OPEN_H

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(
+  close
+  ALIAS
+  DEPENDS
+    .${LIBC_TARGET_OS}.close
+)
+
+add_entrypoint_object(
+  fsync
+  ALIAS
+  DEPENDS
+    .${LIBC_TARGET_OS}.fsync
+)
+
+add_entrypoint_object(
+  read
+  ALIAS
+  DEPENDS
+    .${LIBC_TARGET_OS}.read
+)
+
+add_entrypoint_object(
   write
   ALIAS
   DEPENDS
     .${LIBC_TARGET_OS}.write
 )

libc/src/unistd/close.h

+//===-- Implementation header for close -------------------------*- 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_CLOSE_H
+#define LLVM_LIBC_SRC_UNISTD_CLOSE_H
+
+namespace __llvm_libc {
+
+int close(int fd);
+
+} // namespace __llvm_libc
+
+#endif // LLVM_LIBC_SRC_UNISTD_CLOSE_H

libc/src/unistd/fsync.h

+//===-- Implementation header for fsync -------------------------*- 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_FSYNC_H
+#define LLVM_LIBC_SRC_UNISTD_FSYNC_H
+
+namespace __llvm_libc {
+
+int fsync(int fd);
+
+} // namespace __llvm_libc
+
+#endif // LLVM_LIBC_SRC_UNISTD_FSYNC_H

libc/src/unistd/linux/CMakeLists.txt

 add_entrypoint_object(
+  close
+  SRCS
+    close.cpp
+  HDRS
+    ../close.h
+  DEPENDS
+    libc.include.unistd
+    libc.include.sys_syscall
+    libc.src.__support.OSUtil.osutil
+    libc.src.errno.__errno_location
+)
+
+add_entrypoint_object(
+  fsync
+  SRCS
+    fsync.cpp
+  HDRS
+    ../fsync.h
+  DEPENDS
+    libc.include.unistd
+    libc.include.sys_syscall
+    libc.src.__support.OSUtil.osutil
+    libc.src.errno.__errno_location
+)
+
+add_entrypoint_object(
+  read
+  SRCS
+    read.cpp
+  HDRS
+    ../read.h
+  DEPENDS
+    libc.include.unistd
+    libc.include.sys_syscall
+    libc.src.__support.OSUtil.osutil
+    libc.src.errno.__errno_location
+)
+
+add_entrypoint_object(
   write
   SRCS
     write.cpp
   HDRS
     ../write.h
   DEPENDS
     libc.include.unistd
     libc.include.sys_syscall
     libc.src.__support.OSUtil.osutil
     libc.src.errno.__errno_location
 )

libc/src/unistd/linux/close.cpp

-//===-- Linux implementation of write -------------------------------------===//
+//===-- Linux implementation of close -------------------------------------===//
 //
 // 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 "src/unistd/close.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/syscall.h> // For syscall numbers.
 
 namespace __llvm_libc {
 
-LLVM_LIBC_FUNCTION(ssize_t, write, (int fd, const void *buf, size_t count)) {
-  long ret = __llvm_libc::syscall(SYS_write, fd, buf, count);
+LLVM_LIBC_FUNCTION(int, close, (int fd)) {
+  long ret = __llvm_libc::syscall(SYS_close, fd);
   if (ret < 0) {
     errno = -ret;
     return -1;
   }
   return ret;
 }
 
 } // namespace __llvm_libc

libc/src/unistd/linux/fsync.cpp

-//===-- Linux implementation of write -------------------------------------===//
+//===-- Linux implementation of fsync -------------------------------------===//
 //
 // 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 "src/unistd/fsync.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/syscall.h> // For syscall numbers.
 
 namespace __llvm_libc {
 
-LLVM_LIBC_FUNCTION(ssize_t, write, (int fd, const void *buf, size_t count)) {
-  long ret = __llvm_libc::syscall(SYS_write, fd, buf, count);
+LLVM_LIBC_FUNCTION(int, fsync, (int fd)) {
+  long ret = __llvm_libc::syscall(SYS_fsync, fd);
   if (ret < 0) {
     errno = -ret;
     return -1;
   }
   return ret;
 }
 
 } // namespace __llvm_libc

libc/src/unistd/linux/read.cpp

-//===-- Linux implementation of write -------------------------------------===//
+//===-- Linux implementation of read --------------------------------------===//
 //
 // 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 "src/unistd/read.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/syscall.h> // For syscall numbers.
 
 namespace __llvm_libc {
 
-LLVM_LIBC_FUNCTION(ssize_t, write, (int fd, const void *buf, size_t count)) {
-  long ret = __llvm_libc::syscall(SYS_write, fd, buf, count);
+LLVM_LIBC_FUNCTION(ssize_t, read, (int fd, void *buf, size_t count)) {
+  long ret = __llvm_libc::syscall(SYS_read, fd, buf, count);
   if (ret < 0) {
     errno = -ret;
     return -1;
   }
   return ret;
 }
 
 } // namespace __llvm_libc

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 "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/syscall.h> // For syscall numbers.
 
 namespace __llvm_libc {
 
 LLVM_LIBC_FUNCTION(ssize_t, write, (int fd, const void *buf, size_t count)) {
   long ret = __llvm_libc::syscall(SYS_write, fd, buf, count);
   if (ret < 0) {
     errno = -ret;
     return -1;
   }
   return ret;
 }
 
 } // namespace __llvm_libc

libc/src/unistd/read.h

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

libc/test/src/unistd/CMakeLists.txt

 add_libc_testsuite(libc_unistd_unittests)
 
 add_libc_unittest(
-  write_test
+  read_write_test
   SUITE
     libc_unistd_unittests
   SRCS
-    write_test.cpp
+    read_write_test.cpp
   DEPENDS
     libc.include.errno
     libc.include.unistd
+    libc.src.fcntl.open
+    libc.src.unistd.close
+    libc.src.unistd.fsync
+    libc.src.unistd.read
     libc.src.unistd.write
     libc.test.errno_setter_matcher
 )

libc/test/src/unistd/read_write_test.cpp

+//===-- Unittests for read and 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/fcntl/open.h"
+#include "src/unistd/close.h"
+#include "src/unistd/fsync.h"
+#include "src/unistd/read.h"
+#include "src/unistd/write.h"
+#include "test/ErrnoSetterMatcher.h"
+#include "utils/UnitTest/Test.h"
+#include "utils/testutils/FDReader.h"
+
+#include <errno.h>
+
+TEST(LlvmLibcUniStd, WriteAndReadBackTest) {
+  using __llvm_libc::testing::ErrnoSetterMatcher::Succeeds;
+  constexpr const char *TEST_FILE = "__unistd_read_write.test";
+  int write_fd = __llvm_libc::open(TEST_FILE, O_WRONLY | O_CREAT);
+  ASSERT_EQ(errno, 0);
+  ASSERT_GT(write_fd, 0);
+  constexpr const char HELLO[] = "hello";
+  constexpr int HELLO_SIZE = sizeof(HELLO);
+  ASSERT_THAT(__llvm_libc::write(write_fd, HELLO, HELLO_SIZE),
+              Succeeds(HELLO_SIZE));
+  ASSERT_THAT(__llvm_libc::fsync(write_fd), Succeeds(0));
+  ASSERT_THAT(__llvm_libc::close(write_fd), Succeeds(0));
+
+  int read_fd = __llvm_libc::open(TEST_FILE, O_RDONLY);
+  ASSERT_EQ(errno, 0);
+  ASSERT_GT(read_fd, 0);
+  char read_buf[10];
+  ASSERT_THAT(__llvm_libc::read(read_fd, read_buf, HELLO_SIZE),
+              Succeeds(HELLO_SIZE));
+  EXPECT_STREQ(read_buf, HELLO);
+  ASSERT_THAT(__llvm_libc::close(read_fd), Succeeds(0));
+
+  // TODO: 'remove' the test file after the test.
+}
+
+TEST(LlvmLibcUniStd, 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));
+}
+
+TEST(LlvmLibcUniStd, ReadFails) {
+  using __llvm_libc::testing::ErrnoSetterMatcher::Fails;
+
+  EXPECT_THAT(__llvm_libc::read(-1, nullptr, 1), Fails(EBADF));
+  EXPECT_THAT(__llvm_libc::read(0, reinterpret_cast<void *>(-1), 1),
+              Fails(EFAULT));
+}

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 "src/unistd/write.h"
-#include "test/ErrnoSetterMatcher.h"
-#include "utils/UnitTest/Test.h"
-#include "utils/testutils/FDReader.h"
-
-#include <errno.h>
-
-TEST(LlvmLibcUniStd, WriteBasic) {
-  using __llvm_libc::testing::ErrnoSetterMatcher::Succeeds;
-  constexpr const char *HELLO = "hello";
-  __llvm_libc::testutils::FDReader reader;
-  EXPECT_THAT(__llvm_libc::write(reader.get_write_fd(), HELLO, 5), Succeeds(5));
-  EXPECT_TRUE(reader.match_written(HELLO));
-}
-
-TEST(LlvmLibcUniStd, 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));
-}