[libc] move errno out of file internals

[michaelrj]

Summary

Now errno is only set by the terminal entrypoints, and not the internal
implementations. This patch is part of the larger effort to not set
errno in libc internal code: https://github.com/llvm/llvm-project/issues/59278

[lntue]

libc/src/__support/File/file.h

34

Is this used in the test somewhere? So far all the tests I've seen are directly tested with get_value()?

[sivachandra]

libc/src/__support/File/file.h

43

For read and write operations, I think is fine with a slight modification. Instead of calling the result type FileResult and making it a template, just define it this way:

struct FileIOResult {
  size_t size;
  int error;

  constexpr FileResult(size_t s) : size(s), error(0) {}
  constexpr FileResult(size_t s, int err) : size(s), error(err) {}

  constexpr operator size_t() const { return size; }
  constexpr operator bool() const { return error != 0; }
};

The call sites will be like:

const auto result = file.write(...)
if (!result)
  errno = result.error;
return result; // OK because of operator size_t

48

This is an example of an ErrorOr or StatusOr return value.

50

The close and flush operation functions can return the error value directly. Call sites will detect an error if they see a non-zero return value.

[sivachandra]

libc/src/__support/File/file.h

48

Actually, we should be use an equivalent of std::expected: https://en.cppreference.com/w/cpp/utility/expected

[tschuett]

You can find an implementation effort here:
https://reviews.llvm.org/D124516

[michaelrj]

move to ErrorOr for the functions that effectively return a boolean. Also build a generic "expected" class.

[michaelrj]

libc/src/__support/File/file.h

50

close and flush call write, meaning that they can theoretically have any error that write can, not just EBADF.

[sivachandra]

libc/src/__support/CPP/expected.h

33

Does std::expected have constructors of this kind? If no, then we should not add incompatible constructors.

36

Likewise, if has_error is not present, do not include it here.

libc/src/__support/File/file.cpp

43

Do you need a var like buf_result ? Could we just do:

auto bytes_written = platform_write(...);
if (bytes_written < write_size) { // This should OK because of operator size_t ?
  ... 
}

52–53

Same here?

libc/src/__support/File/file.h

20

Is it used with T != size_t anywhere? If not, it need not be a template.

50

EBADF or any error that write returns is still of an integer type. So, call sites can detect error if return value is non-zero. That non-zero value is itself the error. Otherwise, what meaning would the int value in ErrorOr have for flush and close?

[michaelrj]

address comments

libc/src/__support/CPP/expected.h

33

Yes, this is how the std::expected constructors are defined.

libc/src/__support/File/file.cpp

43

yes. If you look below, we extract the error from buf_result if we're returning an error.

52–53

Same as above, by returning result we preserve the error information. written is only used to determine if the error flag should be set.

libc/src/__support/File/file.h

50

while theoretically we could say that the int result for flush and close actually represents the error instead of the usual return value (which is effectively a boolean for success) I feel like that would be confusing for someone trying to read the codebase.

If you're used to a file function named flush that returns 0 on success and -1 on failure (as laid out in the standard), then the internal version of the function actually returning 0 on success and any positive integer on failure could be unexpected. This way it's unambiguous what the error state is.

[sivachandra]

libc/src/__support/CPP/expected.h

33

Can you point me to a link or section in the standard where its listed? I am looking at cppreference.com and I don't see an unexpected type. I see one which takes std::unexpect_t followed by args for in-place construction of the error value.

libc/src/__support/File/file.cpp

43

You can still do return {0, bytes_written.error}, no?

52–53

Over here, you shouldn't need the written var because you can still compare result < len? I am not advocating for keeping the names as is though. For example, here and above, you can name the var capturing the return value from platform_write as write_result.

libc/src/__support/File/file.h

50

I would actually say using ErrorOr is confusing because one will then start looking for the meaning of the non-error int value.

I am not sure the "used to a file function named flush that return 0 ..." is an argument to use - when you return an error ErrorOr value there is no 0 or -1. But, if you actually return int value, then you can still do:

if (flush_result != 0) {
  // Error handling
}

[tschuett]

Your optional has a separate storage class:
https://github.com/llvm/llvm-project/blob/ebd3eef0b2b0255e4cf1cd825019ff66d3cd1426/libc/src/__support/CPP/optional.h#L30
Your expected does not.

[michaelrj]

address comments:

Moved flush and close to returning an int.
Avoided using additional variables where it was unnecessary.

libc/src/__support/CPP/expected.h

33

here is std::unexpected: https://en.cppreference.com/w/cpp/error/unexpected
It's used in constructors 7 and 8 in the list on this page: https://en.cppreference.com/w/cpp/utility/expected/expected

[sivachandra]

Minor comments inline, but LGTM.

libc/src/__support/CPP/expected.h

17

I think, per https://eel.is/c++draft/expected.unexpected, this should be private?

19

explicit ? Without explicit, the constructor on line 30 below can become ambiguous if T and E are same.

33

here is std::unexpected: https://en.cppreference.com/w/cpp/error/unexpected

Ah! That stale cppreference page threw me off! That page is actually talking about a removed function std::unexpected and not a type named std::unexpected. But, your interpretation is correct and according to the C++23 draft: https://eel.is/c++draft/expected.unexpected

It's used in constructors 7 and 8 in the list on this page: https://en.cppreference.com/w/cpp/utility/expected/expected

Thanks!

libc/src/__support/File/file.h

20

I have read this patch on three different days and all those three times the name FileResult has made me a bit uncomfortable. Can we give it a less general name, say FileIOResult or something which makes it clear that this only relates to read/write operations?

[michaelrj]

address comments:

Rename FileResult to FileIOResult
Make cpp::unexpected constructor explicit to avoid implicit conversions
Make cpp::unexpected member private and accessed through a getter

[sivachandra]

libc/src/__support/CPP/expected.h

22

The getter should be named error according to this: https://en.cppreference.com/w/cpp/utility/expected/unexpected

[michaelrj]

fix final comment before landing

libc/src/__support/CMakeLists.txt

add_header_library(
   HDRS
     architectures.h
     common.h
     endian.h
     sanitizer.h
 )
 
 add_header_library(
+  error_or
+  HDRS
+    error_or.h
+  DEPENDS
+    libc.src.__support.CPP.expected
+)
+
+add_header_library(
   ctype_utils
   HDRS
     ctype_utils.h
 )
 
 add_header_library(
   str_to_num_result
   HDRS

libc/src/__support/CPP/CMakeLists.txt

 
 add_header_library(
   atomic
   HDRS
     atomic.h
 )
 
 add_header_library(
-  error
+  expected
   HDRS
-    error.h
+    expected.h
 )

libc/src/__support/CPP/error.h

-//===-- A simple classes to manage error return vals ----------*- 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_SUPPORT_CPP_ERROR_H
-#define LLVM_LIBC_SRC_SUPPORT_CPP_ERROR_H
-
-namespace __llvm_libc {
-namespace cpp {
-// Many C functions return an error val and/or the actual result of the
-// evaluation/operation performed by the function. This file defines a simple
-// convenience data structure to encapsulate the error and the actual val in
-// a single place.
-
-struct Error {
-  int error_code;
-};
-
-// This class is implemented in a simple fashion as the intention is it add
-// more generality as required. Currently, it only supports simple copyable
-// types for T.
-template <typename T> class ErrorOr {
-  bool is_error;
-
-  union {
-    T val;
-    Error error;
-  };
-
-public:
-  ErrorOr(const T &value) : is_error(false), val(value) {}
-
-  ErrorOr(const Error &error) : is_error(true), error(error) {}
-
-  operator bool() { return !is_error; }
-
-  operator T &() { return val; }
-
-  T &value() { return val; }
-
-  int error_code() { return is_error ? error.error_code : 0; }
-};
-
-} // namespace cpp
-} // namespace __llvm_libc
-
-#endif // LLVM_LIBC_SRC_SUPPORT_CPP_ERROR_H

libc/src/__support/CPP/expected.h

+//===-- Holds an expected or unexpected value -------------------*- 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_SUPPORT_CPP_EXPECTED_H
+#define LLVM_LIBC_SUPPORT_CPP_EXPECTED_H
+
+namespace __llvm_libc::cpp {
+
+// This is used to hold an unexpected value so that a different constructor is
+// selected.
+template <class T> struct unexpected {
+  T value;
+
+  constexpr unexpected(T value) : value(value) {}
+};
+
+template <class T, class E> class expected {
+  union {
+    T exp;
+    E unexp;
+  };
+  bool is_expected;
+
+public:
+  constexpr expected(T exp) : exp(exp), is_expected(true) {}
+  constexpr expected(unexpected<E> unexp)
+      : unexp(unexp.value), is_expected(false) {}
+
+  constexpr bool has_value() { return is_expected; }
+
+  constexpr T value() { return exp; }
+  constexpr E error() { return unexp; }
+
+  constexpr operator T() { return exp; }
+  constexpr operator bool() { return is_expected; }
+
+  constexpr T &operator*() { return exp; }
+  constexpr const T &operator*() const { return exp; }
+  constexpr T *operator->() { return &exp; }
+  constexpr const T *operator->() const { return &exp; }
+};
+
+} // namespace __llvm_libc::cpp
+
+#endif // LLVM_LIBC_SUPPORT_CPP_EXPECTED_H

libc/src/__support/File/CMakeLists.txt

 if(NOT (TARGET libc.src.__support.threads.mutex))
   # Not all platforms have a mutex implementation. If mutex is unvailable,
   # we just skip everything about files.
   return()
 endif()
 
 add_object_library(
   file
   SRCS
     file.cpp
   HDRS
     file.h
   DEPENDS
     libc.include.errno
     libc.src.__support.CPP.span
     libc.src.__support.threads.mutex
-    libc.src.errno.errno
+    libc.src.__support.error_or
 )
 
 add_object_library(
   dir
   SRCS
     dir.cpp
   HDRS
     dir.h
add_object_library(
     DEPENDS
       .file
       libc.include.errno
       libc.include.fcntl
       libc.include.stdio
       libc.include.sys_syscall
       libc.src.__support.OSUtil.osutil
       libc.src.errno.errno
+      libc.src.__support.error_or
   )
 endif()
 
 if(EXISTS ${CMAKE_CURRENT_SOURCE_DIR}/${LIBC_TARGET_OS}_dir.cpp)
   add_object_library(
     platform_dir
     SRCS
       ${LIBC_TARGET_OS}_dir.cpp

libc/src/__support/File/file.h

 //===--- A platform independent file data structure -------------*- 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_SUPPORT_OSUTIL_FILE_H
 #define LLVM_LIBC_SRC_SUPPORT_OSUTIL_FILE_H
 
+#include "src/__support/error_or.h"
 #include "src/__support/threads/mutex.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 namespace __llvm_libc {
 
+struct FileResult {
+  size_t value;
+  int error;
+
+  constexpr FileResult(size_t val) : value(val), error(0) {}
+  constexpr FileResult(size_t val, int error) : value(val), error(error) {}
+
+  constexpr bool has_error() { return error != 0; }
+
+  constexpr operator size_t() { return value; }
+};
+
 // This a generic base class to encapsulate a platform independent file data
 // structure. Platform specific specializations should create a subclass as
 // suitable for their platform.
 class File {
 public:
   static constexpr size_t DEFAULT_BUFFER_SIZE = 1024;
 
   using LockFunc = void(File *);
   using UnlockFunc = void(File *);
 
-  using WriteFunc = size_t(File *, const void *, size_t);
-  using ReadFunc = size_t(File *, void *, size_t);
+  using WriteFunc = FileResult(File *, const void *, size_t);
+  using ReadFunc = FileResult(File *, void *, size_t);
   // The SeekFunc is expected to return the current offset of the external
   // file position indicator.
-  using SeekFunc = long(File *, long, int);
+  using SeekFunc = ErrorOr<long>(File *, long, int);
   using CloseFunc = int(File *);
   using FlushFunc = int(File *);
 
   using ModeFlags = uint32_t;
 
   // The three different types of flags below are to be used with '|' operator.
   // Their values correspond to mutually exclusive bits in a 32-bit unsigned
   // integer value. A flag set can include both READ and WRITE if the file
   // is opened in update mode (ie. if the file was opened with a '+' the mode
   // string.)
   enum class OpenMode : ModeFlags {
     READ = 0x1,
static void init(File *f, WriteFunc *wf, ReadFunc *rf, SeekFunc *sf,
     f->prev_op = FileOp::NONE;
     f->read_limit = f->pos = 0;
     f->eof = f->err = false;
 
     f->adjust_buf();
   }
 
   // Buffered write of |len| bytes from |data| without the file lock.
-  size_t write_unlocked(const void *data, size_t len);
+  FileResult write_unlocked(const void *data, size_t len);
 
   // Buffered write of |len| bytes from |data| under the file lock.
-  size_t write(const void *data, size_t len) {
+  FileResult write(const void *data, size_t len) {
     FileLock l(this);
     return write_unlocked(data, len);
   }
 
   // Buffered read of |len| bytes into |data| without the file lock.
-  size_t read_unlocked(void *data, size_t len);
+  FileResult read_unlocked(void *data, size_t len);
 
   // Buffered read of |len| bytes into |data| under the file lock.
-  size_t read(void *data, size_t len) {
+  FileResult read(void *data, size_t len) {
     FileLock l(this);
     return read_unlocked(data, len);
   }
 
-  int seek(long offset, int whence);
+  ErrorOr<int> seek(long offset, int whence);
 
-  long tell();
+  ErrorOr<long> tell();
 
   // If buffer has data written to it, flush it out. Does nothing if the
   // buffer is currently being used as a read buffer.
   int flush() {
     FileLock lock(this);
     return flush_unlocked();
   }
 
bool iseof() {
     return iseof_unlocked();
   }
 
   // Returns an bit map of flags corresponding to enumerations of
   // OpenMode, ContentType and CreateType.
   static ModeFlags mode_flags(const char *mode);
 
 private:
-  size_t write_unlocked_lbf(const uint8_t *data, size_t len);
-  size_t write_unlocked_fbf(const uint8_t *data, size_t len);
-  size_t write_unlocked_nbf(const uint8_t *data, size_t len);
+  FileResult write_unlocked_lbf(const uint8_t *data, size_t len);
+  FileResult write_unlocked_fbf(const uint8_t *data, size_t len);
+  FileResult write_unlocked_nbf(const uint8_t *data, size_t len);
 
   constexpr void adjust_buf() {
     if (read_allowed() && (buf == nullptr || bufsize == 0)) {
       // We should allow atleast one ungetc operation.
       // This might give an impression that a buffer will be used even when
       // the user does not want a buffer. But, that will not be the case.
       // For reading, the buffering does not come into play. For writing, let
       // us take up the three different kinds of buffering separately:
if (read_allowed() && (buf == nullptr || bufsize == 0)) {
       bufsize = 1;
       own_buf = false; // We shouldn't call free on |buf| when closing the file.
     }
   }
 };
 
 // The implementaiton of this function is provided by the platfrom_file
 // library.
-File *openfile(const char *path, const char *mode);
+ErrorOr<File *> openfile(const char *path, const char *mode);
 
 // The platform_file library should implement it if it relevant for that
 // platform.
 int get_fileno(File *f);
 
 extern File *stdin;
 extern File *stdout;
 extern File *stderr;
 
 } // namespace __llvm_libc
 
 #endif // LLVM_LIBC_SRC_SUPPORT_OSUTIL_FILE_H

libc/src/__support/File/file.cpp

 //===--- Implementation of a platform independent file data structure -----===//
 //
 // 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 "file.h"
 
 #include "src/__support/CPP/span.h"
 
-#include <errno.h>
+#include <errno.h> // For error macros
 #include <stdio.h>
 #include <stdlib.h>
 
 namespace __llvm_libc {
 
-size_t File::write_unlocked(const void *data, size_t len) {
+FileResult File::write_unlocked(const void *data, size_t len) {
   if (!write_allowed()) {
-    errno = EBADF;
     err = true;
-    return 0;
+    return {0, EBADF};
   }
 
   prev_op = FileOp::WRITE;
 
   if (bufmode == _IOFBF) { // fully buffered
     return write_unlocked_fbf(static_cast<const uint8_t *>(data), len);
   } else if (bufmode == _IOLBF) { // line buffered
     return write_unlocked_lbf(static_cast<const uint8_t *>(data), len);
   } else /*if (bufmode == _IONBF) */ { // unbuffered
     size_t ret_val =
         write_unlocked_nbf(static_cast<const uint8_t *>(data), len);
     flush_unlocked();
     return ret_val;
   }
 }
 
-size_t File::write_unlocked_nbf(const uint8_t *data, size_t len) {
+FileResult File::write_unlocked_nbf(const uint8_t *data, size_t len) {
   if (pos > 0) { // If the buffer is not empty
     // Flush the buffer
     const size_t write_size = pos;
-    size_t bytes_written = platform_write(this, buf, write_size);
+    auto write_result = platform_write(this, buf, write_size);
     pos = 0; // Buffer is now empty so reset pos to the beginning.
     // If less bytes were written than expected, then an error occurred.
-    if (bytes_written < write_size) {
+    if (write_result < write_size) {
       err = true;
-      return 0; // No bytes from data were written, so return 0.
+      // No bytes from data were written, so return 0.
+      return {0, write_result.error};
     }
   }
 
-  size_t written = platform_write(this, data, len);
-  if (written < len)
+  auto write_result = platform_write(this, data, len);
+  if (write_result < len)
     err = true;
-  return written;
+  return write_result;
 }
 
-size_t File::write_unlocked_fbf(const uint8_t *data, size_t len) {
+FileResult File::write_unlocked_fbf(const uint8_t *data, size_t len) {
   const size_t init_pos = pos;
   const size_t bufspace = bufsize - pos;
 
   // If data is too large to be buffered at all, then just write it unbuffered.
   if (len > bufspace + bufsize)
     return write_unlocked_nbf(data, len);
 
   // we split |data| (conceptually) using the split point. Then we handle the
FileResult File::write_unlocked_fbf(const uint8_t *data, size_t len) {
   // If there is no remainder, we can return early, since the first piece has
   // fit completely into the buffer.
   if (remainder.size() == 0)
     return len;
 
   // We need to flush the buffer now, since there is still data and the buffer
   // is full.
   const size_t write_size = pos;
-  size_t bytes_written = platform_write(this, buf, write_size);
+
+  auto buf_result = platform_write(this, buf, write_size);
+  size_t bytes_written = buf_result.value;
+
   pos = 0; // Buffer is now empty so reset pos to the beginning.
   // If less bytes were written than expected, then an error occurred. Return
   // the number of bytes that have been written from |data|.
-  if (bytes_written < write_size) {
+  if (buf_result.has_error() || bytes_written < write_size) {
     err = true;
-    return bytes_written <= init_pos ? 0 : bytes_written - init_pos;
+    return {bytes_written <= init_pos ? 0 : bytes_written - init_pos,
+            buf_result.error};
   }
 
   // The second piece is handled basically the same as the first, although we
   // know that if the second piece has data in it then the buffer has been
   // flushed, meaning that pos is always 0.
   if (remainder.size() < bufsize) {
     // TODO: Replace the for loop below with a call to internal memcpy.
     for (size_t i = 0; i < remainder.size(); ++i)
       bufref[i] = remainder[i];
     pos = remainder.size();
   } else {
-    size_t bytes_written =
-        platform_write(this, remainder.data(), remainder.size());
+
+    auto result = platform_write(this, remainder.data(), remainder.size());
+    size_t bytes_written = buf_result.value;
 
     // If less bytes were written than expected, then an error occurred. Return
     // the number of bytes that have been written from |data|.
-    if (bytes_written < remainder.size()) {
+    if (result.has_error() || bytes_written < remainder.size()) {
       err = true;
-      return primary.size() + bytes_written;
+      return {primary.size() + bytes_written, result.error};
     }
   }
 
   return len;
 }
 
-size_t File::write_unlocked_lbf(const uint8_t *data, size_t len) {
+FileResult File::write_unlocked_lbf(const uint8_t *data, size_t len) {
   constexpr uint8_t NEWLINE_CHAR = '\n';
   size_t last_newline = len;
   for (size_t i = len; i >= 1; --i) {
     if (data[i - 1] == NEWLINE_CHAR) {
       last_newline = i - 1;
       break;
     }
   }
FileResult File::write_unlocked_lbf(const uint8_t *data, size_t len) {
   if (written < len) {
     err = true;
     return written;
   }
 
   return len;
 }
 
-size_t File::read_unlocked(void *data, size_t len) {
+FileResult File::read_unlocked(void *data, size_t len) {
   if (!read_allowed()) {
-    errno = EBADF;
     err = true;
-    return 0;
+    return {0, EBADF};
   }
 
   prev_op = FileOp::READ;
 
   cpp::span<uint8_t> bufref(static_cast<uint8_t *>(buf), bufsize);
   cpp::span<uint8_t> dataref(static_cast<uint8_t *>(data), len);
 
   // Because read_limit is always greater than equal to pos,
FileResult File::read_unlocked(void *data, size_t len) {
   read_limit = pos = 0; // Reset the pointers.
   // Update the dataref to reflect that fact that we have already
   // copied |available_data| into |data|.
   dataref = cpp::span<uint8_t>(dataref.data() + available_data,
                                dataref.size() - available_data);
 
   size_t to_fetch = len - available_data;
   if (to_fetch > bufsize) {
-    size_t fetched_size = platform_read(this, dataref.data(), to_fetch);
-    if (fetched_size < to_fetch) {
-      if (errno == 0)
+    auto result = platform_read(this, dataref.data(), to_fetch);
+    size_t fetched_size = result.value;
+    if (result.has_error() || fetched_size < to_fetch) {
+      if (!result.has_error())
         eof = true;
       else
         err = true;
-      return available_data + fetched_size;
+      return {available_data + fetched_size, result.has_error()};
     }
     return len;
   }
 
   // Fetch and buffer another buffer worth of data.
-  size_t fetched_size = platform_read(this, buf, bufsize);
+  auto result = platform_read(this, buf, bufsize);
+  size_t fetched_size = result.value;
   read_limit += fetched_size;
   size_t transfer_size = fetched_size >= to_fetch ? to_fetch : fetched_size;
   for (size_t i = 0; i < transfer_size; ++i)
     dataref[i] = bufref[i];
   pos += transfer_size;
-  if (fetched_size < to_fetch) {
-    if (errno == 0)
+  if (result.has_error() || fetched_size < to_fetch) {
+    if (!result.has_error())
       eof = true;
     else
       err = true;
   }
-  return transfer_size + available_data;
+  return {transfer_size + available_data, result.error};
 }
 
 int File::ungetc_unlocked(int c) {
   // There is no meaning to unget if:
   // 1. You are trying to push back EOF.
   // 2. Read operations are not allowed on this file.
   // 3. The previous operation was a write operation.
   if (c == EOF || !read_allowed() || (prev_op == FileOp::WRITE))
if (read_limit == 0) {
     bufref[pos] = static_cast<unsigned char>(c);
   }
 
   eof = false; // There is atleast one character that can be read now.
   err = false; // This operation was a success.
   return c;
 }
 
-int File::seek(long offset, int whence) {
+ErrorOr<int> File::seek(long offset, int whence) {
   FileLock lock(this);
   if (prev_op == FileOp::WRITE && pos > 0) {
-    size_t transferred_size = platform_write(this, buf, pos);
-    if (transferred_size < pos) {
+
+    auto buf_result = platform_write(this, buf, pos);
+    if (buf_result.has_error() || buf_result.value < pos) {
       err = true;
-      return -1;
+      return Error(buf_result.error);
     }
   } else if (prev_op == FileOp::READ && whence == SEEK_CUR) {
     // More data could have been read out from the platform file than was
     // required. So, we have to adjust the offset we pass to platform seek
     // function. Note that read_limit >= pos is always true.
     offset -= (read_limit - pos);
   }
   pos = read_limit = 0;
   prev_op = FileOp::SEEK;
   // Reset the eof flag as a seek might move the file positon to some place
   // readable.
   eof = false;
-  long platform_pos = platform_seek(this, offset, whence);
-  if (platform_pos >= 0)
-    return 0;
+  auto result = platform_seek(this, offset, whence);
+  if (!result.has_value())
+    return Error(result.error());
   else
-    return -1;
+    return 0;
 }
 
-long File::tell() {
+ErrorOr<long> File::tell() {
   FileLock lock(this);
-  long platform_offset;
-  if (eof)
-    platform_offset = platform_seek(this, 0, SEEK_END);
-  else
-    platform_offset = platform_seek(this, 0, SEEK_CUR);
-  if (platform_offset < 0)
-    return -1;
+  auto seek_target = eof ? SEEK_END : SEEK_CUR;
+  auto result = platform_seek(this, 0, seek_target);
+  if (!result.has_value() || result.value() < 0)
+    return Error(result.error());
+  long platform_offset = result.value();
   if (prev_op == FileOp::READ)
     return platform_offset - (read_limit - pos);
   else if (prev_op == FileOp::WRITE)
     return platform_offset + pos;
   else
     return platform_offset;
 }
 
 int File::flush_unlocked() {
   if (prev_op == FileOp::WRITE && pos > 0) {
-    size_t transferred_size = platform_write(this, buf, pos);
-    if (transferred_size < pos) {
+    auto buf_result = platform_write(this, buf, pos);
+    if (buf_result.has_error() || buf_result.value < pos) {
       err = true;
-      return -1;
+      return buf_result.error;
     }
     pos = 0;
     return platform_flush(this);
   }
   // TODO: Add POSIX behavior for input streams.
   return 0;
 }
 
 int File::close() {
   {
     FileLock lock(this);
     if (prev_op == FileOp::WRITE && pos > 0) {
-      size_t transferred_size = platform_write(this, buf, pos);
-      if (transferred_size < pos) {
+      auto buf_result = platform_write(this, buf, pos);
+      if (buf_result.has_error() || buf_result.value < pos) {
         err = true;
-        return -1;
+        return buf_result.error;
       }
     }
-    if (platform_close(this) != 0)
-      return -1;
+    int result = platform_close(this);
+    if (result != 0)
+      return result;
     if (own_buf)
       free(buf);
   }
   free(this);
   return 0;
 }
 
 int File::set_buffer(void *buffer, size_t size, int buffer_mode) {

libc/src/__support/File/linux_file.cpp

 //===--- Linux specialization of the File data structure ------------------===//
 //
 // 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 "file.h"
 
 #include "src/__support/OSUtil/syscall.h" // For internal syscall function.
 
-#include <errno.h>
+#include <errno.h> // For error macros
 #include <fcntl.h> // For mode_t and other flags to the open syscall
 #include <stdio.h>
 #include <stdlib.h>      // For malloc
 #include <sys/syscall.h> // For syscall numbers
 
 namespace __llvm_libc {
 
 namespace {
 
-size_t write_func(File *, const void *, size_t);
-size_t read_func(File *, void *, size_t);
-long seek_func(File *, long, int);
+FileResult write_func(File *, const void *, size_t);
+FileResult read_func(File *, void *, size_t);
+ErrorOr<long> seek_func(File *, long, int);
 int close_func(File *);
 int flush_func(File *);
 
 } // anonymous namespace
 
 class LinuxFile : public File {
   int fd;
 
static void init(LinuxFile *f, int file_descriptor, void *buffer,
     f->fd = file_descriptor;
   }
 
   int get_fd() const { return fd; }
 };
 
 namespace {
 
-size_t write_func(File *f, const void *data, size_t size) {
+FileResult write_func(File *f, const void *data, size_t size) {
   auto *lf = reinterpret_cast<LinuxFile *>(f);
-  long ret = __llvm_libc::syscall_impl(SYS_write, lf->get_fd(), data, size);
+  int ret = __llvm_libc::syscall_impl(SYS_write, lf->get_fd(), data, size);
   if (ret < 0) {
-    errno = -ret;
-    return 0;
+    return {0, -ret};
   }
   return ret;
 }
 
-size_t read_func(File *f, void *buf, size_t size) {
+FileResult read_func(File *f, void *buf, size_t size) {
   auto *lf = reinterpret_cast<LinuxFile *>(f);
-  long ret = __llvm_libc::syscall_impl(SYS_read, lf->get_fd(), buf, size);
+  int ret = __llvm_libc::syscall_impl(SYS_read, lf->get_fd(), buf, size);
   if (ret < 0) {
-    errno = -ret;
-    return 0;
+    return {0, -ret};
   }
   return ret;
 }
 
-long seek_func(File *f, long offset, int whence) {
+ErrorOr<long> seek_func(File *f, long offset, int whence) {
   auto *lf = reinterpret_cast<LinuxFile *>(f);
   long result;
 #ifdef SYS_lseek
-  long ret = __llvm_libc::syscall_impl(SYS_lseek, lf->get_fd(), offset, whence);
+  int ret = __llvm_libc::syscall_impl(SYS_lseek, lf->get_fd(), offset, whence);
   result = ret;
 #elif defined(SYS__llseek)
   long result;
-  long ret = __llvm_libc::syscall_impl(SYS__llseek, lf->get_fd(), offset >> 32,
-                                       offset, &result, whence);
+  int ret = __llvm_libc::syscall_impl(SYS__llseek, lf->get_fd(), offset >> 32,
 #else
 #error "lseek and _llseek syscalls not available to perform a seek operation."
 #endif
 
-  if (ret < 0) {
-    errno = -ret;
-    return -1;
-  }
+  if (ret < 0)
+    return Error(-ret);
+
   return result;
 }
 
 int close_func(File *f) {
   auto *lf = reinterpret_cast<LinuxFile *>(f);
-  long ret = __llvm_libc::syscall_impl(SYS_close, lf->get_fd());
+  int ret = __llvm_libc::syscall_impl(SYS_close, lf->get_fd());
   if (ret < 0) {
-    errno = -ret;
-    return -1;
+    return -ret;
   }
   return 0;
 }
 
 int flush_func(File *f) {
   auto *lf = reinterpret_cast<LinuxFile *>(f);
-  long ret = __llvm_libc::syscall_impl(SYS_fsync, lf->get_fd());
+  int ret = __llvm_libc::syscall_impl(SYS_fsync, lf->get_fd());
   if (ret < 0) {
-    errno = -ret;
-    return -1;
+    return -ret;
   }
   return 0;
 }
 
 } // anonymous namespace
 
-File *openfile(const char *path, const char *mode) {
+ErrorOr<File *> openfile(const char *path, const char *mode) {
   using ModeFlags = File::ModeFlags;
   auto modeflags = File::mode_flags(mode);
   if (modeflags == 0) {
-    errno = EINVAL;
-    return nullptr;
+    // return {nullptr, EINVAL};
+    return Error(EINVAL);
   }
   long open_flags = 0;
   if (modeflags & ModeFlags(File::OpenMode::APPEND)) {
     open_flags = O_CREAT | O_APPEND;
     if (modeflags & ModeFlags(File::OpenMode::PLUS))
       open_flags |= O_RDWR;
     else
       open_flags |= O_WRONLY;

 #elif defined(SYS_openat)
   int fd = __llvm_libc::syscall_impl(SYS_openat, AT_FDCWD, path, open_flags,
                                      OPEN_MODE);
 #else
 #error "SYS_open and SYS_openat syscalls not available to perform a file open."
 #endif
 
   if (fd < 0) {
-    errno = -fd;
-    return nullptr;
+    return Error(-fd);
+    // return {nullptr, -fd};
   }
 
   void *buffer = malloc(File::DEFAULT_BUFFER_SIZE);
   auto *file = reinterpret_cast<LinuxFile *>(malloc(sizeof(LinuxFile)));
   LinuxFile::init(file, fd, buffer, File::DEFAULT_BUFFER_SIZE, _IOFBF, true,
                   modeflags);
   return file;
 }

libc/src/__support/error_or.h

+//===-- A data structure for returning an error or a value ------*- 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_SUPPORT_ERROR_OR_RESULT_H
+#define LLVM_LIBC_SUPPORT_ERROR_OR_RESULT_H
+
+#include "src/__support/CPP/expected.h"
+
+namespace __llvm_libc {
+
+template <class T> using ErrorOr = cpp::expected<T, int>;
+
+using Error = cpp::unexpected<int>;
+
+// template <typename T> struct ErrorOr {
+//   union {
+//     T value;
+//     int error;
+//   };
+//   bool is_error;
+
+//   constexpr ErrorOr(T value) : value(value), is_error(false) {}
+//   constexpr ErrorOr(int error, bool is_error)
+//       : error(error), is_error(is_error) {}
+
+//   constexpr bool has_error() { return is_error; }
+
+//   constexpr operator bool() { return is_error; }
+//   constexpr operator T() { return value; }
+// };
+
+} // namespace __llvm_libc
+
+#endif // LLVM_LIBC_SUPPORT_ERROR_OR_RESULT_H

libc/src/__support/threads/linux/CMakeLists.txt

add_object_library(
   thread
   SRCS
     thread.cpp
   DEPENDS
     .futex_word_type
     libc.config.linux.app_h
     libc.include.sys_syscall
     libc.src.__support.CPP.atomic
-    libc.src.__support.CPP.error
+    libc.src.__support.error_or
     libc.src.__support.CPP.stringstream
     libc.src.__support.CPP.string_view
     libc.src.__support.threads.thread_common
   COMPILE_OPTIONS
     -O3
     -fno-omit-frame-pointer # This allows us to sniff out the thread args from
                             # the new thread's stack reliably.
 )

libc/src/__support/threads/linux/thread.cpp

 //===--- Implementation of a Linux thread class -----------------*- 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
 //
 //===----------------------------------------------------------------------===//
 
 #include "src/__support/threads/thread.h"
 #include "config/linux/app.h"
-#include "src/__support/CPP/string_view.h"
 #include "src/__support/CPP/atomic.h"
-#include "src/__support/CPP/error.h"
+#include "src/__support/CPP/string_view.h"
 #include "src/__support/CPP/stringstream.h"
-#include "src/__support/OSUtil/syscall.h"           // For syscall functions.
+#include "src/__support/OSUtil/syscall.h" // For syscall functions.
+#include "src/__support/error_or.h"
 #include "src/__support/threads/linux/futex_word.h" // For FutexWordType
 
 #ifdef LLVM_LIBC_ARCH_AARCH64
 #include <arm_acle.h>
 #endif
 
 #include <errno.h>
 #include <fcntl.h>
static constexpr unsigned CLONE_SYSCALL_FLAGS =
     | CLONE_THREAD  // Same thread group as the parent.
     | CLONE_SYSVSEM // Share a single list of System V semaphore adjustment
                     // values
     | CLONE_PARENT_SETTID  // Set child thread ID in |ptid| of the parent.
     | CLONE_CHILD_CLEARTID // Let the kernel clear the tid address
                            // wake the joining thread.
     | CLONE_SETTLS;        // Setup the thread pointer of the new thread.
 
-static inline cpp::ErrorOr<void *> alloc_stack(size_t size) {
+static inline ErrorOr<void *> alloc_stack(size_t size) {
   long mmap_result =
       __llvm_libc::syscall_impl(MMAP_SYSCALL_NUMBER,
                                 0, // No special address
                                 size,
                                 PROT_READ | PROT_WRITE, // Read and write stack
                                 MAP_ANONYMOUS | MAP_PRIVATE, // Process private
                                 -1, // Not backed by any file
                                 0   // No offset
       );
   if (mmap_result < 0 && (uintptr_t(mmap_result) >= UINTPTR_MAX - size))
-    return cpp::Error{int(-mmap_result)};
+    return Error{int(-mmap_result)};
   return reinterpret_cast<void *>(mmap_result);
 }
 
 static inline void free_stack(void *stack, size_t size) {
   __llvm_libc::syscall_impl(SYS_munmap, stack, size);
 }
 
 struct Thread;

 #elif defined(LLVM_LIBC_ARCH_AARCH64)
   // The frame pointer after cloning the new thread in the Thread::run method
   // is set to the stack pointer where start args are stored. So, we fetch
   // from there.
   return reinterpret_cast<uintptr_t>(__builtin_frame_address(1));
 #endif
 }
 
-__attribute__((noinline))
-static void start_thread() {
+__attribute__((noinline)) static void start_thread() {
   auto *start_args = reinterpret_cast<StartArgs *>(get_start_args_addr());
   auto *attrib = start_args->thread_attrib;
   self.attrib = attrib;
   self.attrib->atexit_callback_mgr = internal::get_thread_atexit_callback_mgr();
 
   if (attrib->style == ThreadStyle::POSIX) {
     attrib->retval.posix_retval =
         start_args->runner.posix_runner(start_args->arg);

 int Thread::run(ThreadStyle style, ThreadRunner runner, void *arg, void *stack,
                 size_t size, bool detached) {
   bool owned_stack = false;
   if (stack == nullptr) {
     if (size == 0)
       size = DEFAULT_STACK_SIZE;
     auto alloc = alloc_stack(size);
     if (!alloc)
-      return alloc.error_code();
+      return alloc.error();
     else
       stack = alloc.value();
     owned_stack = true;
   }
 
   TLSDescriptor tls;
   init_tls(tls);
 

 
 void thread_exit(ThreadReturnValue retval, ThreadStyle style) {
   auto attrib = self.attrib;
 
   // The very first thing we do is to call the thread's atexit callbacks.
   // These callbacks could be the ones registered by the language runtimes,
   // for example, the destructors of thread local objects. They can also
   // be destructors of the TSS objects set using API like pthread_setspecific.
-  // NOTE: We cannot call the atexit callbacks as part of the 
+  // NOTE: We cannot call the atexit callbacks as part of the
   // cleanup_thread_resources function as that function can be called from a
   // different thread. The destructors of thread local and TSS objects should
   // be called by the thread which owns them.
   internal::call_atexit_callbacks(attrib);
 
   uint32_t joinable_state = uint32_t(DetachState::JOINABLE);
   if (!attrib->detach_state.compare_exchange_strong(
           joinable_state, uint32_t(DetachState::EXITING))) {

libc/src/pthread/pthread_setname_np.cpp

 //===-- Linux implementation of the pthread_setname_np function -----------===//
 //
 // 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 "pthread_setname_np.h"
 
 #include "src/__support/CPP/string_view.h"
-#include "src/__support/CPP/error.h"
 #include "src/__support/common.h"
 #include "src/__support/threads/thread.h"
 
 #include <pthread.h>
 
 namespace __llvm_libc {
 
 static_assert(sizeof(pthread_t) == sizeof(__llvm_libc::Thread),
               "Mismatch between pthread_t and internal Thread.");
 
 LLVM_LIBC_FUNCTION(int, pthread_setname_np, (pthread_t th, const char *name)) {
   auto *thread = reinterpret_cast<__llvm_libc::Thread *>(&th);
   return thread->set_name(cpp::string_view(name));
 }
 
 } // namespace __llvm_libc

libc/src/stdio/CMakeLists.txt

 add_entrypoint_object(
   fclose
   SRCS
     fclose.cpp
   HDRS
     fclose.h
   DEPENDS
     libc.include.stdio
+    libc.include.errno
     libc.src.__support.File.file
     libc.src.__support.File.platform_file
 )
 
 add_entrypoint_object(
   clearerr
   SRCS
     clearerr.cpp

 
 add_entrypoint_object(
   fgetc
   SRCS
     fgetc.cpp
   HDRS
     fgetc.h
   DEPENDS
+    libc.include.errno
     libc.include.stdio
     libc.src.__support.File.file
     libc.src.__support.File.platform_file
 )
 
 add_entrypoint_object(
   fgetc_unlocked
   SRCS
     fgetc_unlocked.cpp
   HDRS
     fgetc_unlocked.h
   DEPENDS
+    libc.include.errno
     libc.include.stdio
     libc.src.__support.File.file
     libc.src.__support.File.platform_file
 )
 
 add_entrypoint_object(
   getc
   SRCS
     getc.cpp
   HDRS
     getc.h
   DEPENDS
+    libc.include.errno
     libc.include.stdio
     libc.src.__support.File.file
     libc.src.__support.File.platform_file
 )
 
 add_entrypoint_object(
   getc_unlocked
   SRCS
     getc_unlocked.cpp
   HDRS
     getc_unlocked.h
   DEPENDS
+    libc.include.errno
     libc.include.stdio
     libc.src.__support.File.file
     libc.src.__support.File.platform_file
 )
 
 add_entrypoint_object(
   fgets
   SRCS
     fgets.cpp
   HDRS
     fgets.h
   DEPENDS
+    libc.include.errno
     libc.include.stdio
     libc.src.__support.File.file
     libc.src.__support.File.platform_file
 )
 
 add_entrypoint_object(
   fflush
   SRCS
     fflush.cpp
   HDRS
     fflush.h
   DEPENDS
+    libc.include.errno
     libc.include.stdio
     libc.src.__support.File.file
     libc.src.__support.File.platform_file
 )
 
 add_entrypoint_object(
   flockfile
   SRCS

 
 add_entrypoint_object(
   fread_unlocked
   SRCS
     fread_unlocked.cpp
   HDRS
     fread_unlocked.h
   DEPENDS
+    libc.include.errno
     libc.include.stdio
     libc.src.__support.File.file
     libc.src.__support.File.platform_file
 )
 
 add_entrypoint_object(
   fread
   SRCS
     fread.cpp
   HDRS
     fread.h
   DEPENDS
+    libc.include.errno
     libc.include.stdio
     libc.src.__support.File.file
     libc.src.__support.File.platform_file
 )
 
 add_entrypoint_object(
   fwrite_unlocked
   SRCS
     fwrite_unlocked.cpp
   HDRS
     fwrite_unlocked.h
   DEPENDS
+    libc.include.errno
     libc.include.stdio
     libc.src.__support.File.file
     libc.src.__support.File.platform_file
 )
 
 add_entrypoint_object(
   fwrite
   SRCS
     fwrite.cpp
   HDRS
     fwrite.h
   DEPENDS
+    libc.include.errno
     libc.include.stdio
     libc.src.__support.File.file
     libc.src.__support.File.platform_file
 )
 
 add_entrypoint_object(
   fputc
   SRCS
     fputc.cpp
   HDRS
     fputc.h
   DEPENDS
+    libc.include.errno
     libc.include.stdio
     libc.src.__support.File.file
     libc.src.__support.File.platform_file
 )
 
 add_entrypoint_object(
   putc
   SRCS
     putc.cpp
   HDRS
     putc.h
   DEPENDS
+    libc.include.errno
     libc.include.stdio
     libc.src.__support.File.file
     libc.src.__support.File.platform_file
 )
 
 add_entrypoint_object(
   putchar
   SRCS
     putchar.cpp
   HDRS
     putchar.h
   DEPENDS
+    libc.include.errno
     libc.include.stdio
     libc.src.__support.File.file
     libc.src.__support.File.platform_file
 )
 
 add_entrypoint_object(
   fputs
   SRCS
     fputs.cpp
   HDRS
     fputs.h
   DEPENDS
+    libc.include.errno
     libc.include.stdio
     libc.src.__support.File.file
     libc.src.__support.File.platform_file
 )
 
 
 add_entrypoint_object(
   puts
   SRCS
     puts.cpp
   HDRS
     puts.h
   DEPENDS
+    libc.include.errno
     libc.include.stdio
     libc.src.__support.File.file
     libc.src.__support.File.platform_file
 )
 
 add_entrypoint_object(
   fseek
   SRCS
     fseek.cpp
   HDRS
     fseek.h
   DEPENDS
+    libc.include.errno
     libc.include.stdio
     libc.src.__support.File.file
     libc.src.__support.File.platform_file
 )
 
 add_entrypoint_object(
   ungetc
   SRCS

 
 add_entrypoint_object(
   ftell
   SRCS
     ftell.cpp
   HDRS
     ftell.h
   DEPENDS
+    libc.include.errno
     libc.include.stdio
     libc.src.__support.File.file
     libc.src.__support.File.platform_file
 )
 
 add_entrypoint_object(
   remove
   ALIAS
   DEPENDS
     .${LIBC_TARGET_OS}.remove
 )

libc/src/stdio/fclose.cpp

 //===-- Implementation of fclose ------------------------------------------===//
 //
 // 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/stdio/fclose.h"
 #include "src/__support/File/file.h"
 
+#include <errno.h>
 #include <stdio.h>
 
 namespace __llvm_libc {
 
 LLVM_LIBC_FUNCTION(int, fclose, (::FILE * stream)) {
-  return reinterpret_cast<__llvm_libc::File *>(stream)->close();
+  int result = reinterpret_cast<__llvm_libc::File *>(stream)->close();
+  if (result != 0) {
+    errno = result;
+    return EOF;
+  }
+  return 0;
 }
 
 } // namespace __llvm_libc

libc/src/stdio/fflush.cpp

 //===-- Implementation of fflush ------------------------------------------===//
 //
 // 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/stdio/fflush.h"
 #include "src/__support/File/file.h"
 
+#include <errno.h>
 #include <stdio.h>
 
 namespace __llvm_libc {
 
 LLVM_LIBC_FUNCTION(int, fflush, (::FILE * stream)) {
-  return reinterpret_cast<__llvm_libc::File *>(stream)->flush();
+  int result = reinterpret_cast<__llvm_libc::File *>(stream)->flush();
+  if (result != 0) {
+    errno = result;
+    return EOF;
+  }
+  return 0;
 }
 
 } // namespace __llvm_libc

libc/src/stdio/fgetc.cpp

 //===-- Implementation of fgetc -------------------------------------------===//
 //
 // 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/stdio/fgetc.h"
 #include "src/__support/File/file.h"
 
+#include <errno.h>
 #include <stdio.h>
 
 namespace __llvm_libc {
 
 LLVM_LIBC_FUNCTION(int, fgetc, (::FILE * stream)) {
   unsigned char c;
-  size_t r = reinterpret_cast<__llvm_libc::File *>(stream)->read(&c, 1);
+  auto result = reinterpret_cast<__llvm_libc::File *>(stream)->read(&c, 1);
+  size_t r = result.value;
+  if (result.has_error())
+    errno = result.error;
+
   if (r != 1)
     return EOF;
   return c;
 }
 
 } // namespace __llvm_libc

libc/src/stdio/fgetc_unlocked.cpp

 //===-- Implementation of fgetc_unlocked ----------------------------------===//
 //
 // 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/stdio/fgetc_unlocked.h"
 #include "src/__support/File/file.h"
 
+#include <errno.h>
 #include <stdio.h>
 
 namespace __llvm_libc {
 
 LLVM_LIBC_FUNCTION(int, fgetc_unlocked, (::FILE * stream)) {
   unsigned char c;
-  size_t r =
+  auto result =
       reinterpret_cast<__llvm_libc::File *>(stream)->read_unlocked(&c, 1);
+  size_t r = result.value;
+  if (result.has_error())
+    errno = result.error;
   if (r != 1)
     return EOF;
   return c;
 }
 
 } // namespace __llvm_libc

libc/src/stdio/fgets.cpp

 //===-- Implementation of fgets -------------------------------------------===//
 //
 // 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/stdio/fgets.h"
 #include "src/__support/File/file.h"
 
+#include <errno.h>
 #include <stddef.h>
 #include <stdio.h>
 
 namespace __llvm_libc {
 
 LLVM_LIBC_FUNCTION(char *, fgets,
                    (char *__restrict str, int count,
                     ::FILE *__restrict raw_stream)) {
   if (count < 1)
     return nullptr;
 
   unsigned char c = '\0';
   auto stream = reinterpret_cast<__llvm_libc::File *__restrict>(raw_stream);
   stream->lock();
 
   // i is an int because it's frequently compared to count, which is also int.
   int i = 0;
 
   for (; i < (count - 1) && c != '\n'; ++i) {
-    size_t r = stream->read_unlocked(&c, 1);
+    auto result = stream->read_unlocked(&c, 1);
+    size_t r = result.value;
+    if (result.has_error())
+      errno = result.error;
+
     if (r != 1)
       break;
     str[i] = c;
   }
 
   bool has_error = stream->error_unlocked();
   bool has_eof = stream->iseof_unlocked();
   stream->unlock();

libc/src/stdio/fopen.cpp

 //===-- Implementation of fopen -------------------------------------------===//
 //
 // 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/stdio/fopen.h"
 #include "src/__support/File/file.h"
 
+#include <errno.h>
 #include <stdio.h>
 
 namespace __llvm_libc {
 
 LLVM_LIBC_FUNCTION(::FILE *, fopen,
                    (const char *__restrict name, const char *__restrict mode)) {
-  return reinterpret_cast<::FILE *>(__llvm_libc::openfile(name, mode));
+  auto result = __llvm_libc::openfile(name, mode);
+  if (!result.has_value()) {
+    errno = result.error();
+    return nullptr;
+  }
+  return reinterpret_cast<::FILE *>(result.value());
 }
 
 } // namespace __llvm_libc

libc/src/stdio/fopencookie.cpp

 namespace {
 
 class CookieFile : public __llvm_libc::File {
 public:
   void *cookie;
   cookie_io_functions_t ops;
 };
 
-size_t write_func(File *f, const void *data, size_t size) {
+FileResult write_func(File *f, const void *data, size_t size) {
   auto cookie_file = reinterpret_cast<CookieFile *>(f);
   if (cookie_file->ops.write == nullptr)
     return 0;
   return cookie_file->ops.write(cookie_file->cookie,
                                 reinterpret_cast<const char *>(data), size);
 }
 
-size_t read_func(File *f, void *data, size_t size) {
+FileResult read_func(File *f, void *data, size_t size) {
   auto cookie_file = reinterpret_cast<CookieFile *>(f);
   if (cookie_file->ops.read == nullptr)
     return 0;
   return cookie_file->ops.read(cookie_file->cookie,
                                reinterpret_cast<char *>(data), size);
 }
 
-long seek_func(File *f, long offset, int whence) {
+ErrorOr<long> seek_func(File *f, long offset, int whence) {
   auto cookie_file = reinterpret_cast<CookieFile *>(f);
   if (cookie_file->ops.seek == nullptr) {
-    errno = EINVAL;
-    return -1;
+    return Error(EINVAL);
   }
   off64_t offset64 = offset;
   int result = cookie_file->ops.seek(cookie_file->cookie, &offset64, whence);
   if (result == 0)
     return offset64;
   else
     return -1;
 }

libc/src/stdio/fputc.cpp

 //===-- Implementation of fputc -------------------------------------------===//
 //
 // 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/stdio/fputc.h"
 #include "src/__support/File/file.h"
 
+#include <errno.h>
 #include <stdio.h>
 
 namespace __llvm_libc {
 
 LLVM_LIBC_FUNCTION(int, fputc, (int c, ::FILE *stream)) {
   unsigned char uc = static_cast<unsigned char>(c);
-  size_t written = reinterpret_cast<__llvm_libc::File *>(stream)->write(&uc, 1);
+
+  auto result = reinterpret_cast<__llvm_libc::File *>(stream)->write(&uc, 1);
+  if (result.has_error())
+    errno = result.error;
+  size_t written = result.value;
+
   if (1 != written) {
     // The stream should be in an error state in this case.
     return EOF;
   }
   return 0;
 }
 
 } // namespace __llvm_libc

libc/src/stdio/fputs.cpp

 //===-- Implementation of fputs -------------------------------------------===//
 //
 // 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/stdio/fputs.h"
 #include "src/__support/CPP/string_view.h"
 #include "src/__support/File/file.h"
 
+#include <errno.h>
 #include <stdio.h>
 
 namespace __llvm_libc {
 
 LLVM_LIBC_FUNCTION(int, fputs,
                    (const char *__restrict str, ::FILE *__restrict stream)) {
   cpp::string_view str_view(str);
 
-  size_t written = reinterpret_cast<__llvm_libc::File *>(stream)->write(
+  auto result = reinterpret_cast<__llvm_libc::File *>(stream)->write(
       str, str_view.size());
+  if (result.has_error())
+    errno = result.error;
+  size_t written = result.value;
+
   if (str_view.size() != written) {
     // The stream should be in an error state in this case.
     return EOF;
   }
   return 0;
 }
 
 } // namespace __llvm_libc

libc/src/stdio/fread.cpp

 //===-- Implementation of fread -------------------------------------------===//
 //
 // 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/stdio/fread.h"
 #include "src/__support/File/file.h"
 
+#include <errno.h>
 #include <stdio.h>
 
 namespace __llvm_libc {
 
 LLVM_LIBC_FUNCTION(size_t, fread,
                    (void *__restrict buffer, size_t size, size_t nmemb,
                     ::FILE *stream)) {
   if (size == 0 || nmemb == 0)
     return 0;
-  return reinterpret_cast<__llvm_libc::File *>(stream)->read(buffer,
-                                                             size * nmemb) /
-         size;
+  auto result =
+      reinterpret_cast<__llvm_libc::File *>(stream)->read(buffer, size * nmemb);
+  if (result.has_error())
+    errno = result.error;
+  return result.value / size;
 }
 
 } // namespace __llvm_libc

libc/src/stdio/fread_unlocked.cpp

 //===-- Implementation of fread_unlocked ----------------------------------===//
 //
 // 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/stdio/fread_unlocked.h"
 #include "src/__support/File/file.h"
 
+#include <errno.h>
 #include <stdio.h>
 
 namespace __llvm_libc {
 
 LLVM_LIBC_FUNCTION(size_t, fread_unlocked,
                    (void *__restrict buffer, size_t size, size_t nmemb,
                     ::FILE *stream)) {
-  return reinterpret_cast<__llvm_libc::File *>(stream)->read_unlocked(
+  if (size == 0 || nmemb == 0)
+    return 0;
+  auto result = reinterpret_cast<__llvm_libc::File *>(stream)->read_unlocked(
       buffer, size * nmemb);
+  if (result.has_error())
+    errno = result.error;
+  return result.value / size;
 }
 
 } // namespace __llvm_libc

libc/src/stdio/fseek.cpp

 //===-- Implementation of fseek -------------------------------------------===//
 //
 // 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/stdio/fseek.h"
 #include "src/__support/File/file.h"
 
+#include <errno.h>
 #include <stdio.h>
 
 namespace __llvm_libc {
 
 LLVM_LIBC_FUNCTION(int, fseek, (::FILE * stream, long offset, int whence)) {
-  return reinterpret_cast<__llvm_libc::File *>(stream)->seek(offset, whence);
+  auto result =
+      reinterpret_cast<__llvm_libc::File *>(stream)->seek(offset, whence);
+  if (!result.has_value()) {
+    errno = result.error();
+    return -1;
+  }
+  return 0;
 }
 
 } // namespace __llvm_libc

libc/src/stdio/ftell.cpp

 //===-- Implementation of ftell -------------------------------------------===//
 //
 // 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/stdio/ftell.h"
 #include "src/__support/File/file.h"
 
+#include <errno.h>
 #include <stdio.h>
 
 namespace __llvm_libc {
 
 LLVM_LIBC_FUNCTION(long, ftell, (::FILE * stream)) {
-  return reinterpret_cast<__llvm_libc::File *>(stream)->tell();
+  auto result = reinterpret_cast<__llvm_libc::File *>(stream)->tell();
+  if (!result.has_value()) {
+    errno = result.error();
+    return -1;
+  }
+  return result.value();
 }
 
 } // namespace __llvm_libc

libc/src/stdio/fwrite.cpp

 //===-- Implementation of fwrite ------------------------------------------===//
 //
 // 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/stdio/fwrite.h"
 #include "src/__support/File/file.h"
 
+#include <errno.h>
 #include <stdio.h>
 
 namespace __llvm_libc {
 
 LLVM_LIBC_FUNCTION(size_t, fwrite,
                    (const void *__restrict buffer, size_t size, size_t nmemb,
                     ::FILE *stream)) {
   if (size == 0 || nmemb == 0)
     return 0;
-  return reinterpret_cast<__llvm_libc::File *>(stream)->write(buffer,
-                                                              size * nmemb) /
-         size;
+  auto result = reinterpret_cast<__llvm_libc::File *>(stream)->write(
+      buffer, size * nmemb);
+  if (result.has_error())
+    errno = result.error;
+
+  return result.value / size;
 }
 
 } // namespace __llvm_libc

libc/src/stdio/fwrite_unlocked.cpp

 //===-- Implementation of fwrite_unlocked ---------------------------------===//
 //
 // 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/stdio/fwrite_unlocked.h"
 #include "src/__support/File/file.h"
 
+#include <errno.h>
 #include <stdio.h>
 
 namespace __llvm_libc {
 
 LLVM_LIBC_FUNCTION(size_t, fwrite_unlocked,
                    (const void *__restrict buffer, size_t size, size_t nmemb,
                     ::FILE *stream)) {
-  return reinterpret_cast<__llvm_libc::File *>(stream)->write_unlocked(
+
+  if (size == 0 || nmemb == 0)
+    return 0;
+  auto result = reinterpret_cast<__llvm_libc::File *>(stream)->write_unlocked(
       buffer, size * nmemb);
+  if (result.has_error())
+    errno = result.error;
+
+  return result.value / size;
 }
 
 } // namespace __llvm_libc

libc/src/stdio/getc.cpp

 //===-- Implementation of getc --------------------------------------------===//
 //
 // 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/stdio/getc.h"
 #include "src/__support/File/file.h"
 
+#include <errno.h>
 #include <stdio.h>
 
 namespace __llvm_libc {
 
 LLVM_LIBC_FUNCTION(int, getc, (::FILE * stream)) {
   unsigned char c;
-  size_t r = reinterpret_cast<__llvm_libc::File *>(stream)->read(&c, 1);
+  auto result = reinterpret_cast<__llvm_libc::File *>(stream)->read(&c, 1);
+  size_t r = result.value;
+  if (result.has_error())
+    errno = result.error;
+
   if (r != 1)
     return EOF;
   return c;
 }
 
 } // namespace __llvm_libc

libc/src/stdio/getc_unlocked.cpp

 //===-- Implementation of getc_unlocked ----------------------------------===//
 //
 // 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/stdio/getc_unlocked.h"
 #include "src/__support/File/file.h"
 
+#include <errno.h>
 #include <stdio.h>
 
 namespace __llvm_libc {
 
 LLVM_LIBC_FUNCTION(int, getc_unlocked, (::FILE * stream)) {
   unsigned char c;
-  size_t r =
+  auto result =
       reinterpret_cast<__llvm_libc::File *>(stream)->read_unlocked(&c, 1);
+  size_t r = result.value;
+  if (result.has_error())
+    errno = result.error;
+
   if (r != 1)
     return EOF;
   return c;
 }
 
 } // namespace __llvm_libc

libc/src/stdio/printf_core/file_writer.cpp

 #include "src/__support/File/file.h"
 #include "src/stdio/printf_core/core_structs.h"
 #include <stddef.h>
 
 namespace __llvm_libc {
 namespace printf_core {
 
 int FileWriter::write(const char *__restrict to_write, size_t len) {
-  int written = file->write_unlocked(to_write, len);
-  if (written != static_cast<int>(len))
+  auto result = file->write_unlocked(to_write, len);
+  int written = result.value;
+  if (written != static_cast<int>(len) || result.has_error())
     written = FILE_WRITE_ERROR;
   if (file->error_unlocked())
     written = FILE_STATUS_ERROR;
   return written;
 }
 
 int FileWriter::write_str(void *raw_pointer, cpp::string_view new_string) {
   FileWriter *file_writer = reinterpret_cast<FileWriter *>(raw_pointer);

libc/src/stdio/putc.cpp

 //===-- Implementation of putc --------------------------------------------===//
 //
 // 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/stdio/putc.h"
 #include "src/__support/File/file.h"
 
+#include <errno.h>
 #include <stdio.h>
 
 namespace __llvm_libc {
 
 LLVM_LIBC_FUNCTION(int, putc, (int c, ::FILE *stream)) {
   unsigned char uc = static_cast<unsigned char>(c);
-  size_t written = reinterpret_cast<__llvm_libc::File *>(stream)->write(&uc, 1);
+
+  auto result = reinterpret_cast<__llvm_libc::File *>(stream)->write(&uc, 1);
+  if (result.has_error())
+    errno = result.error;
+  size_t written = result.value;
+
   if (1 != written) {
     // The stream should be in an error state in this case.
     return EOF;
   }
   return 0;
 }
 
 } // namespace __llvm_libc

libc/src/stdio/putchar.cpp

 //===-- Implementation of putchar -----------------------------------------===//
 //
 // 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/stdio/putchar.h"
 #include "src/__support/File/file.h"
 
+#include <errno.h>
 #include <stdio.h>
 
 namespace __llvm_libc {
 
 LLVM_LIBC_FUNCTION(int, putchar, (int c)) {
   unsigned char uc = static_cast<unsigned char>(c);
-  size_t written = __llvm_libc::stdout->write(&uc, 1);
+
+  auto result = __llvm_libc::stdout->write(&uc, 1);
+  if (result.has_error())
+    errno = result.error;
+  size_t written = result.value;
+
   if (1 != written) {
     // The stream should be in an error state in this case.
     return EOF;
   }
   return 0;
 }
 
 } // namespace __llvm_libc

libc/src/stdio/puts.cpp

 //===-- Implementation of puts --------------------------------------------===//
 //
 // 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/stdio/puts.h"
 #include "src/__support/CPP/string_view.h"
 #include "src/__support/File/file.h"
 
+#include <errno.h>
 #include <stdio.h>
 
 namespace __llvm_libc {
 
 LLVM_LIBC_FUNCTION(int, puts, (const char *__restrict str)) {
   cpp::string_view str_view(str);
-  size_t written = __llvm_libc::stdout->write(str, str_view.size());
+  auto result = __llvm_libc::stdout->write(str, str_view.size());
+  if (result.has_error())
+    errno = result.error;
+  size_t written = result.value;
   if (str_view.size() != written) {
     // The stream should be in an error state in this case.
     return EOF;
   }
-  written = __llvm_libc::stdout->write("\n", 1);
+  result = __llvm_libc::stdout->write("\n", 1);
+  if (result.has_error())
+    errno = result.error;
+  written = result.value;
   if (1 != written) {
     // The stream should be in an error state in this case.
     return EOF;
   }
   return 0;
 }
 
 } // namespace __llvm_libc

libc/src/stdio/scanf_core/file_reader.cpp

 #include "src/__support/File/file.h"
 #include <stddef.h>
 
 namespace __llvm_libc {
 namespace scanf_core {
 
 char FileReader::get_char() {
   char tiny_buff = 0;
-  if (file->read_unlocked(&tiny_buff, 1) != 1)
+  auto result = file->read_unlocked(&tiny_buff, 1);
+  if (result.value != 1 || result.has_error())
     return 0;
   return tiny_buff;
 }
 
 void FileReader::unget_char(char c) { file->ungetc_unlocked(c); }
 
 } // namespace scanf_core
 } // namespace __llvm_libc

libc/test/src/__support/File/file_test.cpp

 //===-- Unittests for platform independent file class ---------------------===//
 //
 // 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/__support/File/file.h"
+#include "src/__support/error_or.h"
 #include "utils/UnitTest/MemoryMatcher.h"
 #include "utils/UnitTest/Test.h"
 
-#include <errno.h>
 #include <stdio.h>
 #include <stdlib.h>
 
 using ModeFlags = __llvm_libc::File::ModeFlags;
 using MemoryView = __llvm_libc::memory::testing::MemoryView;
+using __llvm_libc::ErrorOr;
+using __llvm_libc::FileResult;
 
 class StringFile : public __llvm_libc::File {
   static constexpr size_t SIZE = 512;
   size_t pos;
   char str[SIZE] = {0};
   size_t eof_marker;
   bool write_append;
 
-  static size_t str_read(__llvm_libc::File *f, void *data, size_t len);
-  static size_t str_write(__llvm_libc::File *f, const void *data, size_t len);
-  static long str_seek(__llvm_libc::File *f, long offset, int whence);
+  static FileResult str_read(__llvm_libc::File *f, void *data, size_t len);
+  static FileResult str_write(__llvm_libc::File *f, const void *data,
+                              size_t len);
+  static ErrorOr<long> str_seek(__llvm_libc::File *f, long offset, int whence);
   static int str_close(__llvm_libc::File *f) { return 0; }
   static int str_flush(__llvm_libc::File *f) { return 0; }
 
 public:
   explicit StringFile(char *buffer, size_t buflen, int bufmode, bool owned,
                       ModeFlags modeflags)
       : __llvm_libc::File(&str_write, &str_read, &str_seek, &str_close,
                           &str_flush, buffer, buflen, bufmode, owned,
void reset_and_fill(const char *data, size_t len) {
     for (i = 0; i < len && i < SIZE; ++i) {
       str[i] = data[i];
     }
     pos = 0;
     eof_marker = i;
   }
 };
 
-size_t StringFile::str_read(__llvm_libc::File *f, void *data, size_t len) {
+FileResult StringFile::str_read(__llvm_libc::File *f, void *data, size_t len) {
   StringFile *sf = static_cast<StringFile *>(f);
   if (sf->pos >= sf->eof_marker)
     return 0;
   size_t i = 0;
   for (i = 0; i < len; ++i)
     reinterpret_cast<char *>(data)[i] = sf->str[sf->pos + i];
   sf->pos += i;
   return i;
 }
 
-size_t StringFile::str_write(__llvm_libc::File *f, const void *data,
+FileResult StringFile::str_write(__llvm_libc::File *f, const void *data,
                                  size_t len) {
   StringFile *sf = static_cast<StringFile *>(f);
   if (sf->write_append)
     sf->pos = sf->eof_marker;
   if (sf->pos >= SIZE)
     return 0;
   size_t i = 0;
   for (i = 0; i < len && sf->pos < SIZE; ++i, ++sf->pos)
     sf->str[sf->pos] = reinterpret_cast<const char *>(data)[i];
   // Move the eof marker if the data was written beyond the current eof marker.
   if (sf->pos > sf->eof_marker)
     sf->eof_marker = sf->pos;
   return i;
 }
 
-long StringFile::str_seek(__llvm_libc::File *f, long offset, int whence) {
+ErrorOr<long> StringFile::str_seek(__llvm_libc::File *f, long offset,
+                                   int whence) {
   StringFile *sf = static_cast<StringFile *>(f);
   if (whence == SEEK_SET)
     sf->pos = offset;
   if (whence == SEEK_CUR)
     sf->pos += offset;
   if (whence == SEEK_END)
     sf->pos = SIZE + offset;
   return sf->pos;
 }
 
 StringFile *new_string_file(char *buffer, size_t buflen, int bufmode,
                             bool owned, const char *mode) {
   StringFile *f = reinterpret_cast<StringFile *>(malloc(sizeof(StringFile)));
   f->init(buffer, buflen, bufmode, owned, __llvm_libc::File::mode_flags(mode));
   return f;
 }
 
 TEST(LlvmLibcFileTest, WriteOnly) {
   const char data[] = "hello, file";
   constexpr size_t FILE_BUFFER_SIZE = sizeof(data) * 3 / 2;
   char file_buffer[FILE_BUFFER_SIZE];
   StringFile *f =
       new_string_file(file_buffer, FILE_BUFFER_SIZE, _IOFBF, false, "w");
 
-  ASSERT_EQ(sizeof(data), f->write(data, sizeof(data)));
+  ASSERT_EQ(sizeof(data), f->write(data, sizeof(data)).value);
   EXPECT_EQ(f->get_pos(), size_t(0)); // Data is buffered in the file stream
   ASSERT_EQ(f->flush(), 0);
   EXPECT_EQ(f->get_pos(), sizeof(data)); // Data should now be available
   EXPECT_STREQ(f->get_str(), data);
 
   f->reset();
   ASSERT_EQ(f->get_pos(), size_t(0));
-  ASSERT_EQ(sizeof(data), f->write(data, sizeof(data)));
+  ASSERT_EQ(sizeof(data), f->write(data, sizeof(data)).value);
   EXPECT_EQ(f->get_pos(), size_t(0)); // Data is buffered in the file stream
   // The second write should trigger a buffer flush.
-  ASSERT_EQ(sizeof(data), f->write(data, sizeof(data)));
+  ASSERT_EQ(sizeof(data), f->write(data, sizeof(data)).value);
   EXPECT_GE(f->get_pos(), size_t(0));
   ASSERT_EQ(f->flush(), 0);
   EXPECT_EQ(f->get_pos(), 2 * sizeof(data));
   MemoryView src1("hello, file\0hello, file", sizeof(data) * 2),
       dst1(f->get_str(), sizeof(data) * 2);
   EXPECT_MEM_EQ(src1, dst1);
 
   char read_data[sizeof(data)];
+  {
     // This is not a readable file.
-  EXPECT_EQ(f->read(read_data, sizeof(data)), size_t(0));
+    auto result = f->read(read_data, sizeof(data));
+    EXPECT_EQ(result.value, size_t(0));
     EXPECT_TRUE(f->error());
-  EXPECT_NE(errno, 0);
-  errno = 0;
+    EXPECT_TRUE(result.has_error());
+  }
 
   ASSERT_EQ(f->close(), 0);
 }
 
 TEST(LlvmLibcFileTest, WriteLineBuffered) {
   const char data[] = "hello\n file";
   constexpr size_t FILE_BUFFER_SIZE = sizeof(data) * 3 / 2;
 
   char file_buffer_line[FILE_BUFFER_SIZE];
   char file_buffer_full[FILE_BUFFER_SIZE];
 
   StringFile *f_line =
       new_string_file(file_buffer_line, FILE_BUFFER_SIZE, _IOLBF, false, "w");
   // We also initialize a fully buffered file we'll do the same writes to for
   // comparison.
   StringFile *f_full =
       new_string_file(file_buffer_full, FILE_BUFFER_SIZE, _IOFBF, false, "w");
 
-  ASSERT_EQ(sizeof(data), f_line->write(data, sizeof(data)));
-  ASSERT_EQ(sizeof(data), f_full->write(data, sizeof(data)));
+  ASSERT_EQ(sizeof(data), f_line->write(data, sizeof(data)).value);
+  ASSERT_EQ(sizeof(data), f_full->write(data, sizeof(data)).value);
 
   EXPECT_EQ(f_line->get_pos(), size_t(6)); // buffer after the newline
   EXPECT_EQ(f_full->get_pos(), size_t(0)); // buffer all of data
 
   MemoryView src1("hello\n", 6), dst1(f_line->get_str(), 6);
   EXPECT_MEM_EQ(src1, dst1);
 
   // We can't check the data in f_full, since no data has been written.
 
   const char data2[] = "longer for an \n overflow";
 
-  ASSERT_EQ(sizeof(data2), f_line->write(data2, sizeof(data2)));
+  ASSERT_EQ(sizeof(data2), f_line->write(data2, sizeof(data2)).value);
   // The line buffer's initial contents should be " file\0"
   // Writing data2 should write up until the newline, even though that doesn't
   // all fit in the buffer.
 
-  ASSERT_EQ(sizeof(data2), f_full->write(data2, sizeof(data2)));
+  ASSERT_EQ(sizeof(data2), f_full->write(data2, sizeof(data2)).value);
   // The full buffer's initial contents should be "hello\n file\0"
   // Writing data2 should cause a flush of the buffer, as well as the remainder
   // to be written directly since it doesn't fit in the buffer.
 
   EXPECT_EQ(f_line->get_pos(), size_t(27));
   EXPECT_EQ(f_full->get_pos(), sizeof(data) + sizeof(data2));
 
   MemoryView src2("hello\n file\0longer for an \n", 27),

 
 TEST(LlvmLibcFileTest, WriteUnbuffered) {
   const char data[] = "written immediately";
   constexpr size_t FILE_BUFFER_SIZE = sizeof(data) + 1;
   char file_buffer[FILE_BUFFER_SIZE];
   StringFile *f =
       new_string_file(file_buffer, FILE_BUFFER_SIZE, _IONBF, false, "w");
 
-  ASSERT_EQ(sizeof(data), f->write(data, sizeof(data)));
+  ASSERT_EQ(sizeof(data), f->write(data, sizeof(data)).value);
   EXPECT_EQ(f->get_pos(),
             sizeof(data)); // no buffering means this is written immediately.
   EXPECT_STREQ(f->get_str(), data);
 
   ASSERT_EQ(f->close(), 0);
 }
 
 TEST(LlvmLibcFileTest, ReadOnly) {
   const char initial_content[] = "1234567890987654321";
   constexpr size_t FILE_BUFFER_SIZE = sizeof(initial_content);
   char file_buffer[FILE_BUFFER_SIZE];
   StringFile *f =
       new_string_file(file_buffer, FILE_BUFFER_SIZE, _IOFBF, false, "r");
   f->reset_and_fill(initial_content, sizeof(initial_content));
 
   constexpr size_t READ_SIZE = sizeof(initial_content) / 2;
   char read_data[READ_SIZE];
-  ASSERT_EQ(READ_SIZE, f->read(read_data, READ_SIZE));
+  ASSERT_EQ(READ_SIZE, f->read(read_data, READ_SIZE).value);
   EXPECT_FALSE(f->iseof());
   // Reading less than file buffer worth will still read one
   // full buffer worth of data.
   EXPECT_STREQ(file_buffer, initial_content);
   EXPECT_STREQ(file_buffer, f->get_str());
   EXPECT_EQ(FILE_BUFFER_SIZE, f->get_pos());
   // The read data should match what was supposed to be read anyway.
   MemoryView src1(initial_content, READ_SIZE), dst1(read_data, READ_SIZE);
   EXPECT_MEM_EQ(src1, dst1);
 
   // Reading another buffer worth should read out everything in
   // the file.
-  ASSERT_EQ(READ_SIZE, f->read(read_data, READ_SIZE));
+  ASSERT_EQ(READ_SIZE, f->read(read_data, READ_SIZE).value);
   EXPECT_FALSE(f->iseof());
   MemoryView src2(initial_content + READ_SIZE, READ_SIZE),
       dst2(read_data, READ_SIZE);
   EXPECT_MEM_EQ(src2, dst2);
 
   // Another read should trigger an EOF.
-  ASSERT_GT(READ_SIZE, f->read(read_data, READ_SIZE));
+  ASSERT_GT(READ_SIZE, f->read(read_data, READ_SIZE).value);
   EXPECT_TRUE(f->iseof());
 
   // Reset the pos to the beginning of the file which should allow
   // reading again.
   for (size_t i = 0; i < READ_SIZE; ++i)
     read_data[i] = 0;
   f->seek(0, SEEK_SET);
-  ASSERT_EQ(READ_SIZE, f->read(read_data, READ_SIZE));
+  ASSERT_EQ(READ_SIZE, f->read(read_data, READ_SIZE).value);
   MemoryView src3(initial_content, READ_SIZE), dst3(read_data, READ_SIZE);
   EXPECT_MEM_EQ(src3, dst3);
 
+  {
     // This is not a writable file.
-  EXPECT_EQ(f->write(initial_content, sizeof(initial_content)), size_t(0));
+    auto result = f->write(initial_content, sizeof(initial_content));
+    EXPECT_EQ(result.value, size_t(0));
     EXPECT_TRUE(f->error());
-  EXPECT_NE(errno, 0);
-  errno = 0;
+    EXPECT_TRUE(result.has_error());
+  }
 
   ASSERT_EQ(f->close(), 0);
 }
 
 TEST(LlvmLibcFileTest, ReadSeekCurAndRead) {
   const char initial_content[] = "1234567890987654321";
   constexpr size_t FILE_BUFFER_SIZE = sizeof(initial_content);
   char file_buffer[FILE_BUFFER_SIZE];
   StringFile *f =
       new_string_file(file_buffer, FILE_BUFFER_SIZE, _IOFBF, false, "r");
   f->reset_and_fill(initial_content, sizeof(initial_content));
 
   constexpr size_t READ_SIZE = 5;
   char data[READ_SIZE];
   data[READ_SIZE - 1] = '\0';
-  ASSERT_EQ(f->read(data, READ_SIZE - 1), READ_SIZE - 1);
+  ASSERT_EQ(f->read(data, READ_SIZE - 1).value, READ_SIZE - 1);
   ASSERT_STREQ(data, "1234");
-  ASSERT_EQ(f->seek(5, SEEK_CUR), 0);
-  ASSERT_EQ(f->read(data, READ_SIZE - 1), READ_SIZE - 1);
+  ASSERT_EQ(f->seek(5, SEEK_CUR).value(), 0);
+  ASSERT_EQ(f->read(data, READ_SIZE - 1).value, READ_SIZE - 1);
   ASSERT_STREQ(data, "0987");
-  ASSERT_EQ(f->seek(-5, SEEK_CUR), 0);
-  ASSERT_EQ(f->read(data, READ_SIZE - 1), READ_SIZE - 1);
+  ASSERT_EQ(f->seek(-5, SEEK_CUR).value(), 0);
+  ASSERT_EQ(f->read(data, READ_SIZE - 1).value, READ_SIZE - 1);
   ASSERT_STREQ(data, "9098");
   ASSERT_EQ(f->close(), 0);
 }
 
 TEST(LlvmLibcFileTest, AppendOnly) {
   const char initial_content[] = "1234567890987654321";
   const char write_data[] = "append";
   constexpr size_t FILE_BUFFER_SIZE = sizeof(write_data) * 3 / 2;
   char file_buffer[FILE_BUFFER_SIZE];
   StringFile *f =
       new_string_file(file_buffer, FILE_BUFFER_SIZE, _IOFBF, false, "a");
   f->reset_and_fill(initial_content, sizeof(initial_content));
 
   constexpr size_t READ_SIZE = 5;
   char read_data[READ_SIZE];
+
+  {
     // This is not a readable file.
-  ASSERT_EQ(f->read(read_data, READ_SIZE), size_t(0));
+    auto result = f->read(read_data, READ_SIZE);
+    EXPECT_EQ(result.value, size_t(0));
     EXPECT_TRUE(f->error());
-  EXPECT_NE(errno, 0);
-  errno = 0;
+    EXPECT_TRUE(result.has_error());
+  }
 
   // Write should succeed but will be buffered in the file stream.
-  ASSERT_EQ(f->write(write_data, sizeof(write_data)), sizeof(write_data));
+  ASSERT_EQ(f->write(write_data, sizeof(write_data)).value, sizeof(write_data));
   EXPECT_EQ(f->get_pos(), size_t(0));
   // Flushing will write to the file.
   EXPECT_EQ(f->flush(), int(0));
   EXPECT_EQ(f->get_pos(), sizeof(write_data) + sizeof(initial_content));
 
   ASSERT_EQ(f->close(), 0);
 }
 
 TEST(LlvmLibcFileTest, WriteUpdate) {
   const char data[] = "hello, file";
   constexpr size_t FILE_BUFFER_SIZE = sizeof(data) * 3 / 2;
   char file_buffer[FILE_BUFFER_SIZE];
   StringFile *f =
       new_string_file(file_buffer, FILE_BUFFER_SIZE, _IOFBF, false, "w+");
 
-  ASSERT_EQ(sizeof(data), f->write(data, sizeof(data)));
+  ASSERT_EQ(sizeof(data), f->write(data, sizeof(data)).value);
   EXPECT_EQ(f->get_pos(), size_t(0)); // Data is buffered in the file stream
 
-  ASSERT_EQ(f->seek(0, SEEK_SET), 0);
+  ASSERT_EQ(f->seek(0, SEEK_SET).value(), 0);
 
   // Seek flushes the stream buffer so we can read the previously written data.
   char read_data[sizeof(data)];
-  ASSERT_EQ(f->read(read_data, sizeof(data)), sizeof(data));
+  ASSERT_EQ(f->read(read_data, sizeof(data)).value, sizeof(data));
   EXPECT_STREQ(read_data, data);
 
   ASSERT_EQ(f->close(), 0);
 }
 
 TEST(LlvmLibcFileTest, ReadUpdate) {
   const char initial_content[] = "1234567890987654321";
   constexpr size_t FILE_BUFFER_SIZE = sizeof(initial_content);
   char file_buffer[FILE_BUFFER_SIZE];
   StringFile *f =
       new_string_file(file_buffer, FILE_BUFFER_SIZE, _IOFBF, false, "r+");
   f->reset_and_fill(initial_content, sizeof(initial_content));
 
   constexpr size_t READ_SIZE = sizeof(initial_content) / 2;
   char read_data[READ_SIZE];
-  ASSERT_EQ(READ_SIZE, f->read(read_data, READ_SIZE));
+  ASSERT_EQ(READ_SIZE, f->read(read_data, READ_SIZE).value);
   EXPECT_FALSE(f->iseof());
   // Reading less than file buffer worth will still read one
   // full buffer worth of data.
   EXPECT_STREQ(file_buffer, initial_content);
   EXPECT_STREQ(file_buffer, f->get_str());
   EXPECT_EQ(FILE_BUFFER_SIZE, f->get_pos());
   // The read data should match what was supposed to be read anyway.
   MemoryView src1(initial_content, READ_SIZE), dst1(read_data, READ_SIZE);
   EXPECT_MEM_EQ(src1, dst1);
 
-  ASSERT_EQ(f->seek(0, SEEK_SET), 0);
+  ASSERT_EQ(f->seek(0, SEEK_SET).value(), 0);
   const char write_data[] = "hello, file";
-  ASSERT_EQ(sizeof(write_data), f->write(write_data, sizeof(write_data)));
+  ASSERT_EQ(sizeof(write_data), f->write(write_data, sizeof(write_data)).value);
   EXPECT_STREQ(file_buffer, write_data);
   ASSERT_EQ(f->flush(), 0);
   MemoryView dst2(f->get_str(), sizeof(write_data)),
       src2(write_data, sizeof(write_data));
   EXPECT_MEM_EQ(src2, dst2);
 
   ASSERT_EQ(f->close(), 0);
 }
 
 TEST(LlvmLibcFileTest, AppendUpdate) {
   const char initial_content[] = "1234567890987654321";
   const char data[] = "hello, file";
   constexpr size_t FILE_BUFFER_SIZE = sizeof(data) * 3 / 2;
   char file_buffer[FILE_BUFFER_SIZE];
   StringFile *f =
       new_string_file(file_buffer, FILE_BUFFER_SIZE, _IOFBF, false, "a+");
   f->reset_and_fill(initial_content, sizeof(initial_content));
 
-  ASSERT_EQ(sizeof(data), f->write(data, sizeof(data)));
+  ASSERT_EQ(sizeof(data), f->write(data, sizeof(data)).value);
   EXPECT_EQ(f->get_pos(), size_t(0)); // Data is buffered in the file stream
   ASSERT_EQ(f->flush(), 0);
   // The flush should write |data| to the endof the file.
   EXPECT_EQ(f->get_pos(), sizeof(data) + sizeof(initial_content));
 
-  ASSERT_EQ(f->seek(0, SEEK_SET), 0);
+  ASSERT_EQ(f->seek(0, SEEK_SET).value(), 0);
   // Seeking to the beginning of the file should not affect the place
   // where write happens.
-  ASSERT_EQ(sizeof(data), f->write(data, sizeof(data)));
+  ASSERT_EQ(sizeof(data), f->write(data, sizeof(data)).value);
   ASSERT_EQ(f->flush(), 0);
   EXPECT_EQ(f->get_pos(), sizeof(data) * 2 + sizeof(initial_content));
   MemoryView src1(initial_content, sizeof(initial_content)),
       dst1(f->get_str(), sizeof(initial_content));
   EXPECT_MEM_EQ(src1, dst1);
   MemoryView src2(data, sizeof(data)),
       dst2(f->get_str() + sizeof(initial_content), sizeof(data));
   EXPECT_MEM_EQ(src2, dst2);
   MemoryView src3(data, sizeof(data)),
       dst3(f->get_str() + sizeof(initial_content) + sizeof(data), sizeof(data));
   EXPECT_MEM_EQ(src3, dst3);
 
   // Reads can happen from any point.
-  ASSERT_EQ(f->seek(0, SEEK_SET), 0);
+  ASSERT_EQ(f->seek(0, SEEK_SET).value(), 0);
   constexpr size_t READ_SIZE = 10;
   char read_data[READ_SIZE];
-  ASSERT_EQ(READ_SIZE, f->read(read_data, READ_SIZE));
+  ASSERT_EQ(READ_SIZE, f->read(read_data, READ_SIZE).value);
   MemoryView src4(initial_content, READ_SIZE), dst4(read_data, READ_SIZE);
   EXPECT_MEM_EQ(src4, dst4);
 
   ASSERT_EQ(f->close(), 0);
 }
 
 TEST(LlvmLibcFileTest, SmallBuffer) {
   const char WRITE_DATA[] = "small buffer";
   constexpr size_t WRITE_SIZE = sizeof(WRITE_DATA);
   constexpr size_t FILE_BUFFER_SIZE = sizeof(WRITE_DATA) / 2 - 1;
   char file_buffer[FILE_BUFFER_SIZE];
   StringFile *f =
       new_string_file(file_buffer, FILE_BUFFER_SIZE, _IOFBF, false, "w");
 
-  ASSERT_EQ(WRITE_SIZE, f->write(WRITE_DATA, WRITE_SIZE));
+  ASSERT_EQ(WRITE_SIZE, f->write(WRITE_DATA, WRITE_SIZE).value);
   // Since data much larger than the buffer is being written, all of it should
   // be available in the file without a flush operation.
   EXPECT_EQ(f->get_pos(), sizeof(WRITE_DATA));
   ASSERT_STREQ(f->get_str(), WRITE_DATA);
 
   ASSERT_EQ(f->close(), 0);
 }
 
 TEST(LlvmLibcFileTest, ZeroLengthBuffer) {
   const char WRITE_DATA[] = "small buffer";
   constexpr size_t WRITE_SIZE = sizeof(WRITE_DATA);
   StringFile *f_fbf = new_string_file(nullptr, 0, _IOFBF, true, "w");
   StringFile *f_lbf = new_string_file(nullptr, 0, _IOLBF, true, "w");
   StringFile *f_nbf = new_string_file(nullptr, 0, _IONBF, true, "w");
 
-  ASSERT_EQ(WRITE_SIZE, f_fbf->write(WRITE_DATA, WRITE_SIZE));
-  ASSERT_EQ(WRITE_SIZE, f_lbf->write(WRITE_DATA, WRITE_SIZE));
-  ASSERT_EQ(WRITE_SIZE, f_nbf->write(WRITE_DATA, WRITE_SIZE));
+  ASSERT_EQ(WRITE_SIZE, f_fbf->write(WRITE_DATA, WRITE_SIZE).value);
+  ASSERT_EQ(WRITE_SIZE, f_lbf->write(WRITE_DATA, WRITE_SIZE).value);
+  ASSERT_EQ(WRITE_SIZE, f_nbf->write(WRITE_DATA, WRITE_SIZE).value);
   // Since there is no buffer space, all of the written data should
   // be available in the file without a flush operation.
   EXPECT_EQ(f_fbf->get_pos(), sizeof(WRITE_DATA));
   EXPECT_EQ(f_lbf->get_pos(), sizeof(WRITE_DATA));
   EXPECT_EQ(f_nbf->get_pos(), sizeof(WRITE_DATA));
   ASSERT_STREQ(f_fbf->get_str(), WRITE_DATA);
   ASSERT_STREQ(f_lbf->get_str(), WRITE_DATA);
   ASSERT_STREQ(f_nbf->get_str(), WRITE_DATA);
TEST(LlvmLibcFileTest, WriteNothing) {
   char file_buffer_nbf[FILE_BUFFER_SIZE];
   StringFile *f_fbf =
       new_string_file(file_buffer_fbf, FILE_BUFFER_SIZE, _IOFBF, false, "w");
   StringFile *f_lbf =
       new_string_file(file_buffer_lbf, FILE_BUFFER_SIZE, _IOLBF, false, "w");
   StringFile *f_nbf =
       new_string_file(file_buffer_nbf, FILE_BUFFER_SIZE, _IONBF, false, "w");
 
-  ASSERT_EQ(WRITE_SIZE, f_fbf->write(WRITE_DATA, WRITE_SIZE));
-  ASSERT_EQ(WRITE_SIZE, f_lbf->write(WRITE_DATA, WRITE_SIZE));
-  ASSERT_EQ(WRITE_SIZE, f_nbf->write(WRITE_DATA, WRITE_SIZE));
+  ASSERT_EQ(WRITE_SIZE, f_fbf->write(WRITE_DATA, WRITE_SIZE).value);
+  ASSERT_EQ(WRITE_SIZE, f_lbf->write(WRITE_DATA, WRITE_SIZE).value);
+  ASSERT_EQ(WRITE_SIZE, f_nbf->write(WRITE_DATA, WRITE_SIZE).value);
 
   ASSERT_FALSE(f_fbf->error_unlocked());
   ASSERT_FALSE(f_lbf->error_unlocked());
   ASSERT_FALSE(f_nbf->error_unlocked());
 
   ASSERT_EQ(f_fbf->close(), 0);
   ASSERT_EQ(f_lbf->close(), 0);
   ASSERT_EQ(f_nbf->close(), 0);
 }

libc/test/src/__support/File/platform_file_test.cpp

 using File = __llvm_libc::File;
 constexpr char TEXT[] = "Hello, File";
 constexpr size_t TEXT_SIZE = sizeof(TEXT) - 1; // Ignore the null terminator
 
 TEST(LlvmLibcPlatformFileTest, CreateWriteCloseAndReadBack) {
   constexpr char FILENAME[] = "testdata/create_write_close_and_readback.test";
   File *file = __llvm_libc::openfile(FILENAME, "w");
   ASSERT_FALSE(file == nullptr);
-  ASSERT_EQ(file->write(TEXT, TEXT_SIZE), TEXT_SIZE);
+  ASSERT_EQ(file->write(TEXT, TEXT_SIZE).value, TEXT_SIZE);
   ASSERT_EQ(file->close(), 0);
 
   file = __llvm_libc::openfile(FILENAME, "r");
   ASSERT_FALSE(file == nullptr);
   char data[sizeof(TEXT)];
-  ASSERT_EQ(file->read(data, TEXT_SIZE), TEXT_SIZE);
+  ASSERT_EQ(file->read(data, TEXT_SIZE).value, TEXT_SIZE);
   data[TEXT_SIZE] = '\0';
   ASSERT_STREQ(data, TEXT);
 
   // Reading more data should trigger EOF.
-  ASSERT_EQ(file->read(data, TEXT_SIZE), size_t(0));
+  ASSERT_EQ(file->read(data, TEXT_SIZE).value, size_t(0));
   ASSERT_TRUE(file->iseof());
 
   ASSERT_EQ(file->close(), 0);
 }
 
 TEST(LlvmLibcPlatformFileTest, CreateWriteSeekAndReadBack) {
   constexpr char FILENAME[] = "testdata/create_write_seek_and_readback.test";
   File *file = __llvm_libc::openfile(FILENAME, "w+");
   ASSERT_FALSE(file == nullptr);
-  ASSERT_EQ(file->write(TEXT, TEXT_SIZE), TEXT_SIZE);
+  ASSERT_EQ(file->write(TEXT, TEXT_SIZE).value, TEXT_SIZE);
 
-  ASSERT_EQ(file->seek(0, SEEK_SET), 0);
+  ASSERT_EQ(file->seek(0, SEEK_SET).value(), 0);
 
   char data[sizeof(TEXT)];
-  ASSERT_EQ(file->read(data, TEXT_SIZE), TEXT_SIZE);
+  ASSERT_EQ(file->read(data, TEXT_SIZE).value, TEXT_SIZE);
   data[TEXT_SIZE] = '\0';
   ASSERT_STREQ(data, TEXT);
 
   // Reading more data should trigger EOF.
-  ASSERT_EQ(file->read(data, TEXT_SIZE), size_t(0));
+  ASSERT_EQ(file->read(data, TEXT_SIZE).value, size_t(0));
   ASSERT_TRUE(file->iseof());
 
   ASSERT_EQ(file->close(), 0);
 }
 
 TEST(LlvmLibcPlatformFileTest, CreateAppendCloseAndReadBack) {
   constexpr char FILENAME[] = "testdata/create_append_close_and_readback.test";
   File *file = __llvm_libc::openfile(FILENAME, "w");
   ASSERT_FALSE(file == nullptr);
-  ASSERT_EQ(file->write(TEXT, TEXT_SIZE), TEXT_SIZE);
+  ASSERT_EQ(file->write(TEXT, TEXT_SIZE).value, TEXT_SIZE);
   ASSERT_EQ(file->close(), 0);
 
   file = __llvm_libc::openfile(FILENAME, "a");
   ASSERT_FALSE(file == nullptr);
   constexpr char APPEND_TEXT[] = " Append Text";
   constexpr size_t APPEND_TEXT_SIZE = sizeof(APPEND_TEXT) - 1;
-  ASSERT_EQ(file->write(APPEND_TEXT, APPEND_TEXT_SIZE), APPEND_TEXT_SIZE);
+  ASSERT_EQ(file->write(APPEND_TEXT, APPEND_TEXT_SIZE).value, APPEND_TEXT_SIZE);
   ASSERT_EQ(file->close(), 0);
 
   file = __llvm_libc::openfile(FILENAME, "r");
   ASSERT_FALSE(file == nullptr);
   constexpr size_t READ_SIZE = TEXT_SIZE + APPEND_TEXT_SIZE;
   char data[READ_SIZE + 1];
-  ASSERT_EQ(file->read(data, READ_SIZE), READ_SIZE);
+  ASSERT_EQ(file->read(data, READ_SIZE).value, READ_SIZE);
   data[READ_SIZE] = '\0';
   ASSERT_STREQ(data, "Hello, File Append Text");
 
   // Reading more data should trigger EOF.
-  ASSERT_EQ(file->read(data, READ_SIZE), size_t(0));
+  ASSERT_EQ(file->read(data, READ_SIZE).value, size_t(0));
   ASSERT_TRUE(file->iseof());
 
   ASSERT_EQ(file->close(), 0);
 }
 
 TEST(LlvmLibcPlatformFileTest, CreateAppendSeekAndReadBack) {
   constexpr char FILENAME[] = "testdata/create_append_seek_and_readback.test";
   File *file = __llvm_libc::openfile(FILENAME, "w");
   ASSERT_FALSE(file == nullptr);
-  ASSERT_EQ(file->write(TEXT, TEXT_SIZE), TEXT_SIZE);
+  ASSERT_EQ(file->write(TEXT, TEXT_SIZE).value, TEXT_SIZE);
   ASSERT_EQ(file->close(), 0);
 
   file = __llvm_libc::openfile(FILENAME, "a+");
   ASSERT_FALSE(file == nullptr);
   constexpr char APPEND_TEXT[] = " Append Text";
   constexpr size_t APPEND_TEXT_SIZE = sizeof(APPEND_TEXT) - 1;
-  ASSERT_EQ(file->write(APPEND_TEXT, APPEND_TEXT_SIZE), APPEND_TEXT_SIZE);
+  ASSERT_EQ(file->write(APPEND_TEXT, APPEND_TEXT_SIZE).value, APPEND_TEXT_SIZE);
 
-  ASSERT_EQ(file->seek(-APPEND_TEXT_SIZE, SEEK_END), 0);
+  ASSERT_EQ(file->seek(-APPEND_TEXT_SIZE, SEEK_END).value(), 0);
   char data[APPEND_TEXT_SIZE + 1];
-  ASSERT_EQ(file->read(data, APPEND_TEXT_SIZE), APPEND_TEXT_SIZE);
+  ASSERT_EQ(file->read(data, APPEND_TEXT_SIZE).value, APPEND_TEXT_SIZE);
   data[APPEND_TEXT_SIZE] = '\0';
   ASSERT_STREQ(data, APPEND_TEXT);
 
   // Reading more data should trigger EOF.
-  ASSERT_EQ(file->read(data, APPEND_TEXT_SIZE), size_t(0));
+  ASSERT_EQ(file->read(data, APPEND_TEXT_SIZE).value, size_t(0));
   ASSERT_TRUE(file->iseof());
 
   ASSERT_EQ(file->close(), 0);
 }
 
 TEST(LlvmLibcPlatformFileTest, LargeFile) {
   constexpr size_t DATA_SIZE = File::DEFAULT_BUFFER_SIZE >> 2;
   constexpr char BYTE = 123;
   char write_data[DATA_SIZE];
   for (size_t i = 0; i < DATA_SIZE; ++i)
     write_data[i] = BYTE;
 
   constexpr char FILENAME[] = "testdata/large_file.test";
   File *file = __llvm_libc::openfile(FILENAME, "w");
   ASSERT_FALSE(file == nullptr);
 
   constexpr int REPEAT = 5;
   for (int i = 0; i < REPEAT; ++i) {
-    ASSERT_EQ(file->write(write_data, DATA_SIZE), DATA_SIZE);
+    ASSERT_EQ(file->write(write_data, DATA_SIZE).value, DATA_SIZE);
   }
   ASSERT_EQ(file->close(), 0);
 
   file = __llvm_libc::openfile(FILENAME, "r");
   ASSERT_FALSE(file == nullptr);
   constexpr size_t READ_SIZE = DATA_SIZE * REPEAT;
   char data[READ_SIZE] = {0};
-  ASSERT_EQ(file->read(data, READ_SIZE), READ_SIZE);
+  ASSERT_EQ(file->read(data, READ_SIZE).value, READ_SIZE);
 
   for (size_t i = 0; i < READ_SIZE; ++i)
     ASSERT_EQ(data[i], BYTE);
 
   // Reading more data should trigger EOF.
-  ASSERT_EQ(file->read(data, 1), size_t(0));
+  ASSERT_EQ(file->read(data, 1).value, size_t(0));
   ASSERT_TRUE(file->iseof());
 
   ASSERT_EQ(file->close(), 0);
 }
 
 TEST(LlvmLibcPlatformFileTest, ReadSeekCurAndRead) {
   constexpr char FILENAME[] = "testdata/read_seek_cur_and_read.test";
   File *file = __llvm_libc::openfile(FILENAME, "w");
   ASSERT_FALSE(file == nullptr);
   constexpr char CONTENT[] = "1234567890987654321";
-  ASSERT_EQ(sizeof(CONTENT) - 1, file->write(CONTENT, sizeof(CONTENT) - 1));
+  ASSERT_EQ(sizeof(CONTENT) - 1,
+            file->write(CONTENT, sizeof(CONTENT) - 1).value);
   ASSERT_EQ(0, file->close());
 
   file = __llvm_libc::openfile(FILENAME, "r");
   ASSERT_FALSE(file == nullptr);
 
   constexpr size_t READ_SIZE = 5;
   char data[READ_SIZE];
   data[READ_SIZE - 1] = '\0';
-  ASSERT_EQ(file->read(data, READ_SIZE - 1), READ_SIZE - 1);
+  ASSERT_EQ(file->read(data, READ_SIZE - 1).value, READ_SIZE - 1);
   ASSERT_STREQ(data, "1234");
-  ASSERT_EQ(file->seek(5, SEEK_CUR), 0);
-  ASSERT_EQ(file->read(data, READ_SIZE - 1), READ_SIZE - 1);
+  ASSERT_EQ(file->seek(5, SEEK_CUR).value(), 0);
+  ASSERT_EQ(file->read(data, READ_SIZE - 1).value, READ_SIZE - 1);
   ASSERT_STREQ(data, "0987");
-  ASSERT_EQ(file->seek(-5, SEEK_CUR), 0);
-  ASSERT_EQ(file->read(data, READ_SIZE - 1), READ_SIZE - 1);
+  ASSERT_EQ(file->seek(-5, SEEK_CUR).value(), 0);
+  ASSERT_EQ(file->read(data, READ_SIZE - 1).value, READ_SIZE - 1);
   ASSERT_STREQ(data, "9098");
 
   ASSERT_EQ(file->close(), 0);
 }
 
 TEST(LlvmLibcPlatformFileTest, IncorrectOperation) {
   constexpr char FILENAME[] = "testdata/incorrect_operation.test";
   char data[1] = {123};
 
   File *file = __llvm_libc::openfile(FILENAME, "w");
   ASSERT_FALSE(file == nullptr);
-  ASSERT_EQ(file->read(data, 1), size_t(0)); // Cannot read
+  ASSERT_EQ(file->read(data, 1).value, size_t(0)); // Cannot read
   ASSERT_FALSE(file->iseof());
   ASSERT_TRUE(file->error());
   ASSERT_EQ(file->close(), 0);
 
   file = __llvm_libc::openfile(FILENAME, "r");
   ASSERT_FALSE(file == nullptr);
-  ASSERT_EQ(file->write(data, 1), size_t(0)); // Cannot write
+  ASSERT_EQ(file->write(data, 1).value, size_t(0)); // Cannot write
   ASSERT_FALSE(file->iseof());
   ASSERT_TRUE(file->error());
   ASSERT_EQ(file->close(), 0);
 
   file = __llvm_libc::openfile(FILENAME, "a");
   ASSERT_FALSE(file == nullptr);
-  ASSERT_EQ(file->read(data, 1), size_t(0)); // Cannot read
+  ASSERT_EQ(file->read(data, 1).value, size_t(0)); // Cannot read
   ASSERT_FALSE(file->iseof());
   ASSERT_TRUE(file->error());
   ASSERT_EQ(file->close(), 0);
 }
 
 TEST(LlvmLibcPlatformFileTest, StdOutStdErrSmokeTest) {
   EXPECT_FALSE(__llvm_libc::stdout == nullptr);
   EXPECT_FALSE(__llvm_libc::stderr == nullptr);
 }

libc/test/src/stdio/fileop_test.cpp

TEST(LlvmLibcFILETest, SimpleFileOperations) {
   ASSERT_EQ(EOF, __llvm_libc::fputs(CONTENT, file));
   ASSERT_NE(__llvm_libc::ferror(file), 0);
   ASSERT_NE(errno, 0);
   errno = 0;
 
   __llvm_libc::clearerr(file);
   ASSERT_EQ(__llvm_libc::ferror(file), 0);
 
+  errno = 0;
+  ASSERT_EQ(__llvm_libc::fwrite("nothing", 1, 1, file), size_t(0));
+  ASSERT_NE(errno, 0);
+  errno = 0;
+
   ASSERT_EQ(__llvm_libc::fclose(file), 0);
 
   // Now try puts.
   file = __llvm_libc::fopen(FILENAME, "w");
   ASSERT_FALSE(file == nullptr);
   // fputs returns a negative value on error (EOF) or any non-negative value on
   // success. This assert checks that the return value is non-negative.
   ASSERT_GE(__llvm_libc::fputs(CONTENT, file), 0);
 
   __llvm_libc::clearerr(file);
   ASSERT_EQ(__llvm_libc::ferror(file), 0);
 
+  // This is not a readable file.
+  errno = 0;
+  ASSERT_EQ(__llvm_libc::fread(data, 1, 1, file), size_t(0));
+  ASSERT_NE(errno, 0);
+  errno = 0;
+
   ASSERT_EQ(0, __llvm_libc::fclose(file));
 
   file = __llvm_libc::fopen(FILENAME, "r");
   ASSERT_FALSE(file == nullptr);
 
   ASSERT_EQ(__llvm_libc::fread(read_data, 1, sizeof(CONTENT) - 1, file),
             sizeof(CONTENT) - 1);
   read_data[sizeof(CONTENT) - 1] = '\0';
   ASSERT_STREQ(read_data, CONTENT);
   ASSERT_EQ(__llvm_libc::fclose(file), 0);
+
+  // Check that the other functions correctly set errno.
+
+  errno = 0;
+  ASSERT_NE(__llvm_libc::fseek(file, 0, SEEK_SET), 0);
+  EXPECT_NE(errno, 0);
+
+  errno = 0;
+  ASSERT_NE(__llvm_libc::fclose(file), 0);
+  EXPECT_NE(errno, 0);
+
+  errno = 0;
+  ASSERT_EQ(__llvm_libc::fopen("INVALID FILE NAME", "r"),
+            static_cast<FILE *>(nullptr));
+  EXPECT_NE(errno, 0);
 }
 
 TEST(LlvmLibcFILETest, FFlush) {
   constexpr char FILENAME[] = "testdata/fflush.test";
   ::FILE *file = __llvm_libc::fopen(FILENAME, "w+");
   ASSERT_FALSE(file == nullptr);
   constexpr char CONTENT[] = "1234567890987654321";
   ASSERT_EQ(sizeof(CONTENT),
TEST(LlvmLibcFILETest, FOpenFWriteSizeGreaterThanOne) {
   using MyStruct = struct {
     char c;
     unsigned long long i;
   };
   constexpr MyStruct WRITE_DATA[] = {{'a', 1}, {'b', 2}, {'c', 3}};
   constexpr size_t WRITE_NMEMB = sizeof(WRITE_DATA) / sizeof(MyStruct);
   constexpr char FILENAME[] = "testdata/fread_fwrite.test";
 
+  errno = 0;
   FILE *file = __llvm_libc::fopen(FILENAME, "w");
   ASSERT_FALSE(file == nullptr);
   ASSERT_EQ(size_t(0), __llvm_libc::fwrite(WRITE_DATA, 0, 1, file));
   ASSERT_EQ(WRITE_NMEMB, __llvm_libc::fwrite(WRITE_DATA, sizeof(MyStruct),
                                              WRITE_NMEMB, file));
   EXPECT_EQ(errno, 0);
   ASSERT_EQ(__llvm_libc::fclose(file), 0);
 

libc/test/src/stdio/ftell_test.cpp

 #include "src/stdio/fopen.h"
 #include "src/stdio/fread.h"
 #include "src/stdio/fseek.h"
 #include "src/stdio/ftell.h"
 #include "src/stdio/fwrite.h"
 #include "src/stdio/setvbuf.h"
 #include "utils/UnitTest/Test.h"
 
+#include <errno.h>
 #include <stdio.h>
 
 class LlvmLibcFTellTest : public __llvm_libc::testing::Test {
 protected:
   void test_with_bufmode(int bufmode) {
     constexpr char FILENAME[] = "testdata/ftell.test";
     // We will set a special buffer to the file so that we guarantee buffering.
     constexpr size_t BUFFER_SIZE = 1024;
void test_with_bufmode(int bufmode) {
     constexpr size_t READ_SIZE = WRITE_SIZE / 2;
     char data[READ_SIZE];
     // Reading a small amount will actually read out much more data and
     // buffer it. But, ftell should return the correct effective offset.
     ASSERT_EQ(READ_SIZE, __llvm_libc::fread(data, 1, READ_SIZE, file));
     ASSERT_EQ(size_t(__llvm_libc::ftell(file)), READ_SIZE);
 
     ASSERT_EQ(0, __llvm_libc::fclose(file));
+
+    errno = 0;
+    ASSERT_EQ(__llvm_libc::ftell(file), long(-1));
+    ASSERT_NE(errno, 0);
   }
 };
 
 TEST_F(LlvmLibcFTellTest, TellWithFBF) { test_with_bufmode(_IOFBF); }
 
 TEST_F(LlvmLibcFTellTest, TellWithNBF) { test_with_bufmode(_IONBF); }
 
 TEST_F(LlvmLibcFTellTest, TellWithLBF) { test_with_bufmode(_IOLBF); }