[libc][NFC] Keep the mutex with the base File data structure.

[sivachandra]

Summary

This is now possible because we have a platform independent abstraction
for mutexes.

[michaelrj]

LGTM

libc/src/__support/File/CMakeLists.txt

 add_object_library(
   file
   SRCS
     file.cpp
   HDRS
     file.h
   DEPENDS
+    libc.src.__support.threads.thread
     libc.include.errno
     libc.src.errno.errno
 )

libc/src/__support/File/file.h

 //===--- A platform independent file data structure -------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_LIBC_SRC_SUPPORT_OSUTIL_FILE_H
 #define LLVM_LIBC_SRC_SUPPORT_OSUTIL_FILE_H
 
+#include "src/__support/threads/mutex.h"
+
 #include <stddef.h>
 #include <stdint.h>
 
 namespace __llvm_libc {
 
 // 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.
private:
   // 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;
 
-  // Platform specific functions to lock and unlock file for mutually exclusive
-  // access from threads in a multi-threaded application.
-  LockFunc *platform_lock;
-  UnlockFunc *platform_unlock;
+  Mutex mutex;
 
   void *buf;      // Pointer to the stream buffer for buffered streams
   size_t bufsize; // Size of the buffer pointed to by |buf|.
 
   // Buffering mode to used to buffer.
   int bufmode;
 
   // If own_buf is true, the |buf| is owned by the stream and will be
bool read_allowed() const {
     return mode & static_cast<ModeFlags>(OpenMode::READ);
   }
 
 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.
   constexpr File(WriteFunc *wf, ReadFunc *rf, SeekFunc *sf, CloseFunc *cf,
-                 FlushFunc *ff, LockFunc *lf, UnlockFunc *ulf, void *buffer,
-                 size_t buffer_size, int buffer_mode, bool owned,
-                 ModeFlags modeflags)
+                 FlushFunc *ff, void *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_lock(lf),
-        platform_unlock(ulf), 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_flush(ff), mutex(false, false, false),
+        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) {}
 
   // This function helps initialize the various fields of the File data
   // structure after a allocating memory for it via a call to malloc.
   static void init(File *f, WriteFunc *wf, ReadFunc *rf, SeekFunc *sf,
-                   CloseFunc *cf, FlushFunc *ff, LockFunc *lf, UnlockFunc *ulf,
-                   void *buffer, size_t buffer_size, int buffer_mode,
-                   bool owned, ModeFlags modeflags) {
+                   CloseFunc *cf, FlushFunc *ff, void *buffer,
+                   size_t buffer_size, int buffer_mode, bool owned,
+                   ModeFlags modeflags) {
+    Mutex::init(&f->mutex, false, false, false);
     f->platform_write = wf;
     f->platform_read = rf;
     f->platform_seek = sf;
     f->platform_close = cf;
     f->platform_flush = ff;
-    f->platform_lock = lf;
-    f->platform_unlock = ulf;
     f->buf = reinterpret_cast<uint8_t *>(buffer);
     f->bufsize = buffer_size;
     f->bufmode = buffer_mode;
     f->own_buf = owned;
     f->mode = modeflags;
 
     f->prev_op = FileOp::NONE;
     f->read_limit = f->pos = 0;
public:
   // Sets the internal buffer to |buffer| with buffering mode |mode|.
   // |size| is the size of |buffer|. This new |buffer| is owned by the
   // stream only if |owned| is true.
   void set_buffer(void *buffer, size_t size, bool owned);
 
   // Closes the file stream and frees up all resources owned by it.
   int close();
 
-  void lock() { platform_lock(this); }
-  void unlock() { platform_unlock(this); }
+  void lock() { mutex.lock(); }
+  void unlock() { mutex.unlock(); }
 
   bool error() const { return err; }
   void clearerr() { err = false; }
   bool iseof() const { return eof; }
 
   // Returns an bit map of flags corresponding to enumerations of
   // OpenMode, ContentType and CreateType.
   static ModeFlags mode_flags(const char *mode);

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

class StringFile : public __llvm_libc::File {
   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 int 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; }
 
-  // TODO: Add a proper locking system and tests which exercise that.
-  static void str_lock(__llvm_libc::File *f) {}
-  static void str_unlock(__llvm_libc::File *f) {}
-
 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, &str_lock, &str_unlock, buffer, buflen,
-                          bufmode, owned, modeflags),
+                          &str_flush, 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 init(char *buffer, size_t buflen, int bufmode, bool owned,
             ModeFlags modeflags) {
     File::init(this, &str_write, &str_read, &str_seek, &str_close, &str_flush,
-               &str_lock, &str_unlock, buffer, buflen, bufmode, owned,
-               modeflags);
+               buffer, buflen, bufmode, owned, modeflags);
     pos = eof_marker = 0;
     if (modeflags & static_cast<ModeFlags>(__llvm_libc::File::OpenMode::APPEND))
       write_append = true;
     else
       write_append = false;
   }
 
   void reset() { pos = 0; }