[libc] Remove the requirement of a platform-flush operation in File abstraction.

[sivachandra]

Summary

The libc flush operation is not supposed to trigger a platform level
flush operation. See "Notes" on this Linux man page:

https://man7.org/linux/man-pages/man3/fflush.3.html

[michaelrj]

LGTM

libc/src/__support/File/file.h

#endif
   using UnlockFunc = void(File *);
 
   using WriteFunc = FileIOResult(File *, const void *, size_t);
   using ReadFunc = FileIOResult(File *, void *, size_t);
   // The SeekFunc is expected to return the current offset of the external
   // file position indicator.
   using SeekFunc = ErrorOr<long>(File *, long, int);
   using CloseFunc = int(File *);
-  using FlushFunc = int(File *);
   // CleanupFunc is a function which does the equivalent of this:
   //
   // void my_file_cleanup(File *f) {
   //   MyFile *file = reinterpret_cast<MyFile *>(f);
   //   delete file;
   // }
   //
   // Essentially, it a function which calls the delete operator on the
private:
 
   // Platfrom specific functions which create new file objects should initialize
   // these fields suitably via the constructor. Typically, they should be simple
   // syscall wrappers for the corresponding functionality.
   WriteFunc *platform_write;
   ReadFunc *platform_read;
   SeekFunc *platform_seek;
   CloseFunc *platform_close;
-  FlushFunc *platform_flush;
   CleanupFunc *platform_cleanup;
 
   Mutex mutex;
 
   // For files which are readable, we should be able to support one ungetc
   // operation even if |buf| is nullptr. So, in the constructor of File, we
   // set |buf| to point to this buffer character.
   uint8_t ungetc_buf;
public:
   // We want this constructor to be constexpr so that global file objects
   // like stdout do not require invocation of the constructor which can
   // potentially lead to static initialization order fiasco. Consequently,
   // we will assume that the |buffer| and |buffer_size| argument are
   // meaningful - that is, |buffer| is nullptr if and only if |buffer_size|
   // is zero. This way, we will not have to employ the semantics of
   // the set_buffer method and allocate a buffer.
   constexpr File(WriteFunc *wf, ReadFunc *rf, SeekFunc *sf, CloseFunc *cf,
-                 FlushFunc *ff, CleanupFunc *clf, uint8_t *buffer,
-                 size_t buffer_size, int buffer_mode, bool owned,
-                 ModeFlags modeflags)
+                 CleanupFunc *clf, uint8_t *buffer, size_t buffer_size,
+                 int buffer_mode, bool owned, ModeFlags modeflags)
       : platform_write(wf), platform_read(rf), platform_seek(sf),
-        platform_close(cf), platform_flush(ff), platform_cleanup(clf),
-        mutex(false, false, false), ungetc_buf(0), buf(buffer),
-        bufsize(buffer_size), bufmode(buffer_mode), own_buf(owned),
-        mode(modeflags), pos(0), prev_op(FileOp::NONE), read_limit(0),
-        eof(false), err(false) {
+        platform_close(cf), platform_cleanup(clf), mutex(false, false, false),
+        ungetc_buf(0), buf(buffer), bufsize(buffer_size), bufmode(buffer_mode),
+        own_buf(owned), mode(modeflags), pos(0), prev_op(FileOp::NONE),
+        read_limit(0), eof(false), err(false) {
     if constexpr (ENABLE_BUFFER)
       adjust_buf();
   }
 
   // Close |f| and cleanup resources held by it.
   // Returns the non-zero error value if an error occurs when closing the
   // file.
   static int cleanup(File *f) {

libc/src/__support/File/file.cpp

int File::flush_unlocked() {
 
   if (prev_op == FileOp::WRITE && pos > 0) {
     auto buf_result = platform_write(this, buf, pos);
     if (buf_result.has_error() || buf_result.value < pos) {
       err = true;
       return buf_result.error;
     }
     pos = 0;
-    return platform_flush(this);
   }
   // TODO: Add POSIX behavior for input streams.
   return 0;
 }
 
 int File::set_buffer(void *buffer, size_t size, int buffer_mode) {
   if constexpr (!ENABLE_BUFFER)
     return EINVAL;

libc/src/__support/File/gpu/file.cpp

 
 } // namespace
 
 class GPUFile : public File {
   uintptr_t file;
 
 public:
   constexpr GPUFile(uintptr_t file, File::ModeFlags modeflags)
-      : File(&write_func, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr,
-             0, _IONBF, false, modeflags),
+      : File(&write_func, nullptr, nullptr, nullptr, nullptr, nullptr, 0,
+             _IONBF, false, modeflags),
         file(file) {}
 
   uintptr_t get_file() const { return file; }
 };
 
 namespace {
 
 int write_to_stdout(const void *data, size_t size) {

libc/src/__support/File/linux/file.cpp

 namespace __llvm_libc {
 
 namespace {
 
 FileIOResult write_func(File *, const void *, size_t);
 FileIOResult read_func(File *, void *, size_t);
 ErrorOr<long> seek_func(File *, long, int);
 int close_func(File *);
-int flush_func(File *);
 
 } // anonymous namespace
 
 class LinuxFile : public File {
   int fd;
 
 public:
   constexpr LinuxFile(int file_descriptor, uint8_t *buffer, size_t buffer_size,
                       int buffer_mode, bool owned, File::ModeFlags modeflags)
-      : File(&write_func, &read_func, &seek_func, &close_func, flush_func,
+      : File(&write_func, &read_func, &seek_func, &close_func,
              &cleanup_file<LinuxFile>, buffer, buffer_size, buffer_mode, owned,
              modeflags),
         fd(file_descriptor) {}
 
   int get_fd() const { return fd; }
 };
 
 namespace {
int close_func(File *f) {
   auto *lf = reinterpret_cast<LinuxFile *>(f);
   int ret = __llvm_libc::syscall_impl(SYS_close, lf->get_fd());
   if (ret < 0) {
     return -ret;
   }
   return 0;
 }
 
-int flush_func(File *f) {
-  auto *lf = reinterpret_cast<LinuxFile *>(f);
-  int ret = __llvm_libc::syscall_impl(SYS_fsync, lf->get_fd());
-  if (ret < 0) {
-    return -ret;
-  }
-  return 0;
-}
-
 } // anonymous namespace
 
 ErrorOr<File *> openfile(const char *path, const char *mode) {
   using ModeFlags = File::ModeFlags;
   auto modeflags = File::mode_flags(mode);
   if (modeflags == 0) {
     // return {nullptr, EINVAL};
     return Error(EINVAL);

libc/src/stdio/fopencookie.cpp

 class CookieFile : public __llvm_libc::File {
   void *cookie;
   cookie_io_functions_t ops;
 
   static FileIOResult cookie_write(File *f, const void *data, size_t size);
   static FileIOResult cookie_read(File *f, void *data, size_t size);
   static ErrorOr<long> cookie_seek(File *f, long offset, int whence);
   static int cookie_close(File *f);
-  static int cookie_flush(File *);
 
 public:
   CookieFile(void *c, cookie_io_functions_t cops, uint8_t *buffer,
              size_t bufsize, File::ModeFlags mode)
       : File(&cookie_write, &cookie_read, &CookieFile::cookie_seek,
-             &cookie_close, &cookie_flush, &cleanup_file<CookieFile>, buffer,
-             bufsize, 0 /* default buffering mode */,
-             true /* File owns buffer */, mode),
+             &cookie_close, &cleanup_file<CookieFile>, buffer, bufsize,
+             0 /* default buffering mode */, true /* File owns buffer */, mode),
         cookie(c), ops(cops) {}
 };
 
 FileIOResult CookieFile::cookie_write(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,

 
 int CookieFile::cookie_close(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 CookieFile::cookie_flush(File *) { return 0; }
-
 } // anonymous namespace
 
 LLVM_LIBC_FUNCTION(::FILE *, fopencookie,
                    (void *cookie, const char *mode,
                     cookie_io_functions_t ops)) {
   uint8_t *buffer;
   {
     AllocChecker ac;

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

class StringFile : public File {
   size_t eof_marker;
   bool write_append;
 
   static FileIOResult str_read(__llvm_libc::File *f, void *data, size_t len);
   static FileIOResult str_write(__llvm_libc::File *f, const void *data,
                                 size_t len);
   static ErrorOr<long> str_seek(__llvm_libc::File *f, long offset, int whence);
   static int str_close(__llvm_libc::File *f) { return 0; }
-  static int str_flush(__llvm_libc::File *f) { return 0; }
 
 public:
   explicit StringFile(char *buffer, size_t buflen, int bufmode, bool owned,
                       ModeFlags modeflags)
       : __llvm_libc::File(&str_write, &str_read, &str_seek, &str_close,
-                          &str_flush, &__llvm_libc::cleanup_file<StringFile>,
+                          &__llvm_libc::cleanup_file<StringFile>,
                           reinterpret_cast<uint8_t *>(buffer), buflen, bufmode,
                           owned, modeflags),
         pos(0), eof_marker(0), write_append(false) {
     if (modeflags & static_cast<ModeFlags>(__llvm_libc::File::OpenMode::APPEND))
       write_append = true;
   }
 
   void reset() { pos = 0; }

libc/test/src/stdio/ftell_test.cpp

 //===-- Unittests for 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/fclose.h"
-#include "src/stdio/fflush.h"
 #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 "test/UnitTest/Test.h"