[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

33

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

51

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

54

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

56

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

54

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

56

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

32 ↗

(On Diff #481745)

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

35 ↗

(On Diff #481745)

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

libc/src/__support/File/file.cpp

43–44

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 ?
  ... 
}

54–55

Same here?

libc/src/__support/File/file.h

19

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

56

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

32 ↗

(On Diff #481745)

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

libc/src/__support/File/file.cpp

43–44

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

54–55

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

56

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

32 ↗

(On Diff #481745)

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–44

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

54–55

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

56

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

32 ↗

(On Diff #481745)

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

32 ↗

(On Diff #481745)

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!

17 ↗

(On Diff #482184)

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

19 ↗

(On Diff #482184)

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

libc/src/__support/File/file.h

19

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

21 ↗

(On Diff #482238)

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/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
 )
 
 add_object_library(
   dir
   SRCS
     dir.cpp
   HDRS
     dir.h

libc/src/__support/File/file.h

 
 #include "src/__support/threads/mutex.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 namespace __llvm_libc {
 
+template <typename T> struct FileResult {
+  T return_val;
+  int error_val;
+
+public:
+  constexpr FileResult(T val) : return_val(val), error_val(0) {}
+  constexpr FileResult(T val, int error) : return_val(val), error_val(error) {}
+
+  constexpr bool has_error() { return error_val != 0; }
+  constexpr int get_error() { return error_val; }
+  constexpr T get_value() { return return_val; }
+
+  constexpr operator T() { return return_val; }
+
+  // Only used for testing.
+  constexpr bool operator==(const FileResult<T> &other) {
+    return (return_val == other.get_value()) &&
+           (error_val == other.get_error());
+  }
+};
+
 // 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<size_t>(File *, const void *, size_t);
+  using ReadFunc = FileResult<size_t>(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 CloseFunc = int(File *);
-  using FlushFunc = int(File *);
+  using SeekFunc = FileResult<long>(File *, long, int);
+  using CloseFunc = FileResult<int>(File *);
+  using FlushFunc = FileResult<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.)
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<size_t> 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<size_t> 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<size_t> 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<size_t> read(void *data, size_t len) {
     FileLock l(this);
     return read_unlocked(data, len);
   }
 
-  int seek(long offset, int whence);
+  FileResult<int> seek(long offset, int whence);
 
-  long tell();
+  FileResult<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() {
+  FileResult<int> flush() {
     FileLock lock(this);
     return flush_unlocked();
   }
 
-  int flush_unlocked();
+  FileResult<int> flush_unlocked();
 
   // Returns EOF on error and keeps the file unchanged.
   int ungetc_unlocked(int c);
 
   int ungetc(int c) {
     FileLock lock(this);
     return ungetc_unlocked(c);
   }
 
   // Sets the internal buffer to |buffer| with buffering mode |mode|.
   // |size| is the size of |buffer|. If |size| is non-zero, but |buffer|
   // is nullptr, then a buffer owned by this file will be allocated.
   // Else, |buffer| will not be owned by this file.
   //
   // Will return zero on success, or an error value on failure. Will fail
   // if:
   //   1. |buffer| is not a nullptr but |size| is zero.
   //   2. |buffer_mode| is not one of _IOLBF, IOFBF or _IONBF.
   // In both the above cases, error returned in EINVAL.
   int set_buffer(void *buffer, size_t size, int buffer_mode);
 
   // Closes the file stream and frees up all resources owned by it.
-  int close();
+  FileResult<int> close();
 
   void lock() { mutex.lock(); }
   void unlock() { mutex.unlock(); }
 
   bool error_unlocked() const { return err; }
 
   bool error() {
     FileLock l(this);
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<size_t> write_unlocked_lbf(const uint8_t *data, size_t len);
+  FileResult<size_t> write_unlocked_fbf(const uint8_t *data, size_t len);
+  FileResult<size_t> 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);
+FileResult<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<size_t> 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<size_t> 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 buf_result = platform_write(this, buf, write_size);
+    size_t bytes_written = buf_result.get_value();
     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) {
       err = true;
-      return 0; // No bytes from data were written, so return 0.
+      // No bytes from data were written, so return 0.
+      return {0, buf_result.get_error()};
     }
   }
 
-  size_t written = platform_write(this, data, len);
+  auto result = platform_write(this, data, len);
+  size_t written = result.get_value();
   if (written < len)
     err = true;
-  return written;
+  return result;
 }
 
-size_t File::write_unlocked_fbf(const uint8_t *data, size_t len) {
+FileResult<size_t> 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<size_t> 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.get_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 (bytes_written < write_size || buf_result.has_error()) {
     err = true;
-    return bytes_written <= init_pos ? 0 : bytes_written - init_pos;
+    return {bytes_written <= init_pos ? 0 : bytes_written - init_pos,
+            buf_result.get_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.get_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 (bytes_written < remainder.size() || result.has_error()) {
       err = true;
-      return primary.size() + bytes_written;
+      return {primary.size() + bytes_written, result.get_error()};
     }
   }
 
   return len;
 }
 
-size_t File::write_unlocked_lbf(const uint8_t *data, size_t len) {
+FileResult<size_t> 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<size_t> 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<size_t> 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<size_t> 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.get_value();
+    if (fetched_size < to_fetch || result.has_error()) {
+      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.get_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 (fetched_size < to_fetch || result.has_error()) {
+    if (!result.has_error())
       eof = true;
     else
       err = true;
   }
-  return transfer_size + available_data;
+  return {transfer_size + available_data, result.get_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) {
+FileResult<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);
+    size_t transferred_size = buf_result.get_value();
+    if (transferred_size < pos || buf_result.has_error()) {
       err = true;
-      return -1;
+      return {-1, buf_result.get_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);
+  auto result = platform_seek(this, offset, whence);
+  long platform_pos = result.get_value();
   if (platform_pos >= 0)
-    return 0;
+    return {0, result.get_error()};
   else
-    return -1;
+    return {-1, result.get_error()};
 }
 
-long File::tell() {
+FileResult<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);
+  long platform_offset = result.get_value();
+  if (platform_offset < 0 || result.has_error())
+    return {-1, result.get_error()};
   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() {
+FileResult<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);
+    size_t transferred_size = buf_result.get_value();
+    if (transferred_size < pos || buf_result.has_error()) {
       err = true;
-      return -1;
+      return {-1, buf_result.get_error()};
     }
     pos = 0;
     return platform_flush(this);
   }
   // TODO: Add POSIX behavior for input streams.
   return 0;
 }
 
-int File::close() {
+FileResult<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);
+      size_t transferred_size = buf_result.get_value();
+      if (transferred_size < pos || buf_result.has_error()) {
         err = true;
-        return -1;
+        return {-1, buf_result.get_error()};
       }
     }
-    if (platform_close(this) != 0)
-      return -1;
+    auto result = platform_close(this);
+    if (result.get_value() != 0 || result.has_error())
+      return {-1, result.get_error()};
     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);
-int close_func(File *);
-int flush_func(File *);
+FileResult<size_t> write_func(File *, const void *, size_t);
+FileResult<size_t> read_func(File *, void *, size_t);
+FileResult<long> seek_func(File *, long, int);
+FileResult<int> close_func(File *);
+FileResult<int> flush_func(File *);
 
 } // anonymous namespace
 
 class LinuxFile : public File {
   int fd;
 
 public:
   constexpr LinuxFile(int file_descriptor, void *buffer, size_t buffer_size,
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<size_t> 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<size_t> 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) {
+FileResult<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;
+    return {-1, -ret};
   }
   return result;
 }
 
-int close_func(File *f) {
+FileResult<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 {-1, -ret};
   }
   return 0;
 }
 
-int flush_func(File *f) {
+FileResult<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 {-1, -ret};
   }
   return 0;
 }
 
 } // anonymous namespace
 
-File *openfile(const char *path, const char *mode) {
+FileResult<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};
   }
   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 {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/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();
+  auto result = reinterpret_cast<__llvm_libc::File *>(stream)->close();
+  if (result.has_error())
+    errno = result.get_error();
+  return result.get_value();
 }
 
 } // 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();
+  auto result = reinterpret_cast<__llvm_libc::File *>(stream)->flush();
+  if (result.has_error())
+    errno = result.get_error();
+  return result.get_value();
 }
 
 } // 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.get_value();
+  if (result.has_error())
+    errno = result.get_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.get_value();
+  if (result.has_error())
+    errno = result.get_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.get_value();
+    if (result.has_error())
+      errno = result.get_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_error())
+    errno = result.get_error();
+  return reinterpret_cast<::FILE *>(result.get_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<size_t> 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<size_t> 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) {
+FileResult<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 {-1, EINVAL};
   }
   off64_t offset64 = offset;
   int result = cookie_file->ops.seek(cookie_file->cookie, &offset64, whence);
   if (result == 0)
     return offset64;
   else
     return -1;
 }
 
-int close_func(File *f) {
+FileResult<int> close_func(File *f) {
   auto cookie_file = reinterpret_cast<CookieFile *>(f);
   if (cookie_file->ops.close == nullptr)
     return 0;
   return cookie_file->ops.close(cookie_file->cookie);
 }
 
-int flush_func(File *) { return 0; }
+FileResult<int> flush_func(File *) { return 0; }
 
 } // anonymous namespace
 
 LLVM_LIBC_FUNCTION(::FILE *, fopencookie,
                    (void *cookie, const char *mode,
                     cookie_io_functions_t ops)) {
   auto modeflags = File::mode_flags(mode);
   void *buffer = malloc(File::DEFAULT_BUFFER_SIZE);

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.get_error();
+  size_t written = result.get_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.get_error();
+  size_t written = result.get_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.get_error();
+  return result.get_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.get_error();
+  return result.get_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_error())
+    errno = result.get_error();
+  return result.get_value();
 }
 
 } // 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_error())
+    errno = result.get_error();
+  return result.get_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.get_error();
+
+  return result.get_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.get_error();
+
+  return result.get_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.get_value();
+  if (result.has_error())
+    errno = result.get_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.get_value();
+  if (result.has_error())
+    errno = result.get_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.get_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.get_error();
+  size_t written = result.get_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.get_error();
+  size_t written = result.get_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.get_error();
+  size_t written = result.get_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.get_error();
+  written = result.get_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.get_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 "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::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 int str_close(__llvm_libc::File *f) { return 0; }
-  static int str_flush(__llvm_libc::File *f) { return 0; }
+  static FileResult<size_t> str_read(__llvm_libc::File *f, void *data,
+                                     size_t len);
+  static FileResult<size_t> str_write(__llvm_libc::File *f, const void *data,
+                                      size_t len);
+  static FileResult<long> str_seek(__llvm_libc::File *f, long offset,
+                                   int whence);
+  static FileResult<int> str_close(__llvm_libc::File *f) { return 0; }
+  static FileResult<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,
                           modeflags),
         pos(0), eof_marker(0), write_append(false) {
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<size_t> 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<size_t> 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) {
+FileResult<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)).get_value());
   EXPECT_EQ(f->get_pos(), size_t(0)); // Data is buffered in the file stream
-  ASSERT_EQ(f->flush(), 0);
+  ASSERT_EQ(f->flush().get_value(), 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)).get_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)).get_value());
   EXPECT_GE(f->get_pos(), size_t(0));
-  ASSERT_EQ(f->flush(), 0);
+  ASSERT_EQ(f->flush().get_value(), 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.get_value(), size_t(0));
     EXPECT_TRUE(f->error());
-  EXPECT_NE(errno, 0);
-  errno = 0;
+    EXPECT_TRUE(result.has_error());
+  }
 
-  ASSERT_EQ(f->close(), 0);
+  ASSERT_EQ(f->close().get_value(), 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)).get_value());
+  ASSERT_EQ(sizeof(data), f_full->write(data, sizeof(data)).get_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)).get_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)).get_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),
       dst2(f_line->get_str(), 27);
   EXPECT_MEM_EQ(src2, dst2);
 
   MemoryView src3("hello\n file\0longer for an \n overflow", 37),
       dst_full_final(f_full->get_str(), 37);
   EXPECT_MEM_EQ(src3, dst_full_final);
 
-  ASSERT_EQ(f_line->flush(), 0);
-  ASSERT_EQ(f_full->flush(), 0);
+  ASSERT_EQ(f_line->flush().get_value(), 0);
+  ASSERT_EQ(f_full->flush().get_value(), 0);
 
   EXPECT_EQ(f_line->get_pos(), sizeof(data) + sizeof(data2));
   MemoryView dst_line_final(f_line->get_str(), 37);
   EXPECT_MEM_EQ(src3, dst_line_final);
   EXPECT_MEM_EQ(src3, dst_full_final);
 
-  ASSERT_EQ(f_line->close(), 0);
-  ASSERT_EQ(f_full->close(), 0);
+  ASSERT_EQ(f_line->close().get_value(), 0);
+  ASSERT_EQ(f_full->close().get_value(), 0);
 }
 
 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)).get_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);
+  ASSERT_EQ(f->close().get_value(), 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).get_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).get_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).get_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).get_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.get_value(), size_t(0));
     EXPECT_TRUE(f->error());
-  EXPECT_NE(errno, 0);
-  errno = 0;
+    EXPECT_TRUE(result.has_error());
+  }
 
-  ASSERT_EQ(f->close(), 0);
+  ASSERT_EQ(f->close().get_value(), 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).get_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).get_value(), 0);
+  ASSERT_EQ(f->read(data, READ_SIZE - 1).get_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).get_value(), 0);
+  ASSERT_EQ(f->read(data, READ_SIZE - 1).get_value(), READ_SIZE - 1);
   ASSERT_STREQ(data, "9098");
-  ASSERT_EQ(f->close(), 0);
+  ASSERT_EQ(f->close().get_value(), 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.get_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)).get_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->flush().get_value(), int(0));
   EXPECT_EQ(f->get_pos(), sizeof(write_data) + sizeof(initial_content));
 
-  ASSERT_EQ(f->close(), 0);
+  ASSERT_EQ(f->close().get_value(), 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)).get_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).get_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)).get_value(), sizeof(data));
   EXPECT_STREQ(read_data, data);
 
-  ASSERT_EQ(f->close(), 0);
+  ASSERT_EQ(f->close().get_value(), 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).get_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).get_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)).get_value());
   EXPECT_STREQ(file_buffer, write_data);
-  ASSERT_EQ(f->flush(), 0);
+  ASSERT_EQ(f->flush().get_value(), 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);
+  ASSERT_EQ(f->close().get_value(), 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)).get_value());
   EXPECT_EQ(f->get_pos(), size_t(0)); // Data is buffered in the file stream
-  ASSERT_EQ(f->flush(), 0);
+  ASSERT_EQ(f->flush().get_value(), 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).get_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(f->flush(), 0);
+  ASSERT_EQ(sizeof(data), f->write(data, sizeof(data)).get_value());
+  ASSERT_EQ(f->flush().get_value(), 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).get_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).get_value());
   MemoryView src4(initial_content, READ_SIZE), dst4(read_data, READ_SIZE);
   EXPECT_MEM_EQ(src4, dst4);
 
-  ASSERT_EQ(f->close(), 0);
+  ASSERT_EQ(f->close().get_value(), 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).get_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);
+  ASSERT_EQ(f->close().get_value(), 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).get_value());
+  ASSERT_EQ(WRITE_SIZE, f_lbf->write(WRITE_DATA, WRITE_SIZE).get_value());
+  ASSERT_EQ(WRITE_SIZE, f_nbf->write(WRITE_DATA, WRITE_SIZE).get_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);
 
-  ASSERT_EQ(f_fbf->close(), 0);
-  ASSERT_EQ(f_lbf->close(), 0);
-  ASSERT_EQ(f_nbf->close(), 0);
+  ASSERT_EQ(f_fbf->close().get_value(), 0);
+  ASSERT_EQ(f_lbf->close().get_value(), 0);
+  ASSERT_EQ(f_nbf->close().get_value(), 0);
 }
 
 TEST(LlvmLibcFileTest, WriteNothing) {
   const char WRITE_DATA[] = "";
   constexpr size_t WRITE_SIZE = 0;
   constexpr size_t FILE_BUFFER_SIZE = 5;
   char file_buffer_fbf[FILE_BUFFER_SIZE];
   char file_buffer_lbf[FILE_BUFFER_SIZE];
   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).get_value());
+  ASSERT_EQ(WRITE_SIZE, f_lbf->write(WRITE_DATA, WRITE_SIZE).get_value());
+  ASSERT_EQ(WRITE_SIZE, f_nbf->write(WRITE_DATA, WRITE_SIZE).get_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);
+  ASSERT_EQ(f_fbf->close().get_value(), 0);
+  ASSERT_EQ(f_lbf->close().get_value(), 0);
+  ASSERT_EQ(f_nbf->close().get_value(), 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->close(), 0);
+  ASSERT_EQ(file->write(TEXT, TEXT_SIZE).get_value(), TEXT_SIZE);
+  ASSERT_EQ(file->close().get_value(), 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).get_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).get_value(), size_t(0));
   ASSERT_TRUE(file->iseof());
 
-  ASSERT_EQ(file->close(), 0);
+  ASSERT_EQ(file->close().get_value(), 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).get_value(), TEXT_SIZE);
 
-  ASSERT_EQ(file->seek(0, SEEK_SET), 0);
+  ASSERT_EQ(file->seek(0, SEEK_SET).get_value(), 0);
 
   char data[sizeof(TEXT)];
-  ASSERT_EQ(file->read(data, TEXT_SIZE), TEXT_SIZE);
+  ASSERT_EQ(file->read(data, TEXT_SIZE).get_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).get_value(), size_t(0));
   ASSERT_TRUE(file->iseof());
 
-  ASSERT_EQ(file->close(), 0);
+  ASSERT_EQ(file->close().get_value(), 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->close(), 0);
+  ASSERT_EQ(file->write(TEXT, TEXT_SIZE).get_value(), TEXT_SIZE);
+  ASSERT_EQ(file->close().get_value(), 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->close(), 0);
+  ASSERT_EQ(file->write(APPEND_TEXT, APPEND_TEXT_SIZE).get_value(),
+            APPEND_TEXT_SIZE);
+  ASSERT_EQ(file->close().get_value(), 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).get_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).get_value(), size_t(0));
   ASSERT_TRUE(file->iseof());
 
-  ASSERT_EQ(file->close(), 0);
+  ASSERT_EQ(file->close().get_value(), 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->close(), 0);
+  ASSERT_EQ(file->write(TEXT, TEXT_SIZE).get_value(), TEXT_SIZE);
+  ASSERT_EQ(file->close().get_value(), 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).get_value(),
+            APPEND_TEXT_SIZE);
 
-  ASSERT_EQ(file->seek(-APPEND_TEXT_SIZE, SEEK_END), 0);
+  ASSERT_EQ(file->seek(-APPEND_TEXT_SIZE, SEEK_END).get_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).get_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).get_value(), size_t(0));
   ASSERT_TRUE(file->iseof());
 
-  ASSERT_EQ(file->close(), 0);
+  ASSERT_EQ(file->close().get_value(), 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).get_value(), DATA_SIZE);
   }
-  ASSERT_EQ(file->close(), 0);
+  ASSERT_EQ(file->close().get_value(), 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).get_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).get_value(), size_t(0));
   ASSERT_TRUE(file->iseof());
 
-  ASSERT_EQ(file->close(), 0);
+  ASSERT_EQ(file->close().get_value(), 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(0, file->close());
+  ASSERT_EQ(sizeof(CONTENT) - 1,
+            file->write(CONTENT, sizeof(CONTENT) - 1).get_value());
+  ASSERT_EQ(0, file->close().get_value());
 
   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).get_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).get_value(), 0);
+  ASSERT_EQ(file->read(data, READ_SIZE - 1).get_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).get_value(), 0);
+  ASSERT_EQ(file->read(data, READ_SIZE - 1).get_value(), READ_SIZE - 1);
   ASSERT_STREQ(data, "9098");
 
-  ASSERT_EQ(file->close(), 0);
+  ASSERT_EQ(file->close().get_value(), 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).get_value(), size_t(0)); // Cannot read
   ASSERT_FALSE(file->iseof());
   ASSERT_TRUE(file->error());
-  ASSERT_EQ(file->close(), 0);
+  ASSERT_EQ(file->close().get_value(), 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).get_value(), size_t(0)); // Cannot write
   ASSERT_FALSE(file->iseof());
   ASSERT_TRUE(file->error());
-  ASSERT_EQ(file->close(), 0);
+  ASSERT_EQ(file->close().get_value(), 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).get_value(), size_t(0)); // Cannot read
   ASSERT_FALSE(file->iseof());
   ASSERT_TRUE(file->error());
-  ASSERT_EQ(file->close(), 0);
+  ASSERT_EQ(file->close().get_value(), 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); }