llvm/lib/Support/FileOutputBuffer.cpp

   1 //===- FileOutputBuffer.cpp - File Output Buffer ----------------*- C++ -*-===//
   2 //
   3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
   4 // See https://llvm.org/LICENSE.txt for license information.
   5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
   6 //
   7 //===----------------------------------------------------------------------===//
   8 //
   9 // Utility for creating a in-memory buffer that will be written to a file.
  10 //
  11 //===----------------------------------------------------------------------===//
  12
  13 #include "llvm/Support/FileOutputBuffer.h"
  14 #include "llvm/ADT/STLExtras.h"
  15 #include "llvm/Support/Errc.h"
  16 #include "llvm/Support/FileSystem.h"
  17 #include "llvm/Support/Memory.h"
  18 #include "llvm/Support/Path.h"
  19 #include <system_error>
  20
  21 #if !defined(_MSC_VER) && !defined(__MINGW32__)
  22 #include <unistd.h>
  23 #else
  24 #include <io.h>
  25 #endif
  26
  27 using namespace llvm;
  28 using namespace llvm::sys;
  29
  30 namespace {
  31 // A FileOutputBuffer which creates a temporary file in the same directory
  32 // as the final output file. The final output file is atomically replaced
  33 // with the temporary file on commit().
  34 class OnDiskBuffer : public FileOutputBuffer {
  35 public:
  36   OnDiskBuffer(StringRef Path, fs::TempFile Temp, fs::mapped_file_region Buf)
  37       : FileOutputBuffer(Path), Buffer(std::move(Buf)), Temp(std::move(Temp)) {}
  38
  39   uint8_t *getBufferStart() const override { return (uint8_t *)Buffer.data(); }
  40
  41   uint8_t *getBufferEnd() const override {
  42     return (uint8_t *)Buffer.data() + Buffer.size();
  43   }
  44
  45   size_t getBufferSize() const override { return Buffer.size(); }
  46
  47   Error commit() override {
  48     // Unmap buffer, letting OS flush dirty pages to file on disk.
  49     Buffer.unmap();
  50
  51     // Atomically replace the existing file with the new one.
  52     return Temp.keep(FinalPath);
  53   }
  54
  55   ~OnDiskBuffer() override {
  56     // Close the mapping before deleting the temp file, so that the removal
  57     // succeeds.
  58     Buffer.unmap();
  59     consumeError(Temp.discard());
  60   }
  61
  62   void discard() override {
  63     // Delete the temp file if it still was open, but keeping the mapping
  64     // active.
  65     consumeError(Temp.discard());
  66   }
  67
  68 private:
  69   fs::mapped_file_region Buffer;
  70   fs::TempFile Temp;
  71 };
  72
  73 // A FileOutputBuffer which keeps data in memory and writes to the final
  74 // output file on commit(). This is used only when we cannot use OnDiskBuffer.
  75 class InMemoryBuffer : public FileOutputBuffer {
  76 public:
  77   InMemoryBuffer(StringRef Path, MemoryBlock Buf, std::size_t BufSize,
  78                  unsigned Mode)
  79       : FileOutputBuffer(Path), Buffer(Buf), BufferSize(BufSize),
  80         Mode(Mode) {}
  81
  82   uint8_t *getBufferStart() const override { return (uint8_t *)Buffer.base(); }
  83
  84   uint8_t *getBufferEnd() const override {
  85     return (uint8_t *)Buffer.base() + BufferSize;
  86   }
  87
  88   size_t getBufferSize() const override { return BufferSize; }
  89
  90   Error commit() override {
  91     if (FinalPath == "-") {
  92       llvm::outs() << StringRef((const char *)Buffer.base(), BufferSize);
  93       llvm::outs().flush();
  94       return Error::success();
  95     }
  96
  97     using namespace sys::fs;
  98     int FD;
  99     std::error_code EC;
 100     if (auto EC =
 101             openFileForWrite(FinalPath, FD, CD_CreateAlways, OF_None, Mode))
 102       return errorCodeToError(EC);
 103     raw_fd_ostream OS(FD, /*shouldClose=*/true, /*unbuffered=*/true);
 104     OS << StringRef((const char *)Buffer.base(), BufferSize);
 105     return Error::success();
 106   }
 107
 108 private:
 109   // Buffer may actually contain a larger memory block than BufferSize
 110   OwningMemoryBlock Buffer;
 111   size_t BufferSize;
 112   unsigned Mode;
 113 };
 114 } // namespace
 115
 116 static Expected<std::unique_ptr<InMemoryBuffer>>
 117 createInMemoryBuffer(StringRef Path, size_t Size, unsigned Mode) {
 118   std::error_code EC;
 119   MemoryBlock MB = Memory::allocateMappedMemory(
 120       Size, nullptr, sys::Memory::MF_READ | sys::Memory::MF_WRITE, EC);
 121   if (EC)
 122     return errorCodeToError(EC);
 123   return std::make_unique<InMemoryBuffer>(Path, MB, Size, Mode);
 124 }
 125
 126 static Expected<std::unique_ptr<FileOutputBuffer>>
 127 createOnDiskBuffer(StringRef Path, size_t Size, unsigned Mode) {
 128   Expected<fs::TempFile> FileOrErr =
 129       fs::TempFile::create(Path + ".tmp%%%%%%%", Mode);
 130   if (!FileOrErr)
 131     return FileOrErr.takeError();
 132   fs::TempFile File = std::move(*FileOrErr);
 133
 134   if (auto EC = fs::resize_file_before_mapping_readwrite(File.FD, Size)) {
 135     consumeError(File.discard());
 136     return errorCodeToError(EC);
 137   }
 138
 139   // Mmap it.
 140   std::error_code EC;
 141   fs::mapped_file_region MappedFile =
 142       fs::mapped_file_region(fs::convertFDToNativeFile(File.FD),
 143                              fs::mapped_file_region::readwrite, Size, 0, EC);
 144
 145   // mmap(2) can fail if the underlying filesystem does not support it.
 146   // If that happens, we fall back to in-memory buffer as the last resort.
 147   if (EC) {
 148     consumeError(File.discard());
 149     return createInMemoryBuffer(Path, Size, Mode);
 150   }
 151
 152   return std::make_unique<OnDiskBuffer>(Path, std::move(File),
 153                                          std::move(MappedFile));
 154 }
 155
 156 // Create an instance of FileOutputBuffer.
 157 Expected<std::unique_ptr<FileOutputBuffer>>
 158 FileOutputBuffer::create(StringRef Path, size_t Size, unsigned Flags) {
 159   // Handle "-" as stdout just like llvm::raw_ostream does.
 160   if (Path == "-")
 161     return createInMemoryBuffer("-", Size, /*Mode=*/0);
 162
 163   unsigned Mode = fs::all_read | fs::all_write;
 164   if (Flags & F_executable)
 165     Mode |= fs::all_exe;
 166
 167   // If Size is zero, don't use mmap which will fail with EINVAL.
 168   if (Size == 0)
 169     return createInMemoryBuffer(Path, Size, Mode);
 170
 171   fs::file_status Stat;
 172   fs::status(Path, Stat);
 173
 174   // Usually, we want to create OnDiskBuffer to create a temporary file in
 175   // the same directory as the destination file and atomically replaces it
 176   // by rename(2).
 177   //
 178   // However, if the destination file is a special file, we don't want to
 179   // use rename (e.g. we don't want to replace /dev/null with a regular
 180   // file.) If that's the case, we create an in-memory buffer, open the
 181   // destination file and write to it on commit().
 182   switch (Stat.type()) {
 183   case fs::file_type::directory_file:
 184     return errorCodeToError(errc::is_a_directory);
 185   case fs::file_type::regular_file:
 186   case fs::file_type::file_not_found:
 187   case fs::file_type::status_error:
 188     if (Flags & F_no_mmap)
 189       return createInMemoryBuffer(Path, Size, Mode);
 190     else
 191       return createOnDiskBuffer(Path, Size, Mode);
 192   default:
 193     return createInMemoryBuffer(Path, Size, Mode);
 194   }
 195 }