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/ADT/SmallString.h"
16 #include "llvm/Support/Errc.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,
37                std::unique_ptr<fs::mapped_file_region> Buf)
38       : FileOutputBuffer(Path), Buffer(std::move(Buf)), Temp(std::move(Temp)) {}
39 
40   uint8_t *getBufferStart() const override { return (uint8_t *)Buffer->data(); }
41 
42   uint8_t *getBufferEnd() const override {
43     return (uint8_t *)Buffer->data() + Buffer->size();
44   }
45 
46   size_t getBufferSize() const override { return Buffer->size(); }
47 
48   Error commit() override {
49     // Unmap buffer, letting OS flush dirty pages to file on disk.
50     Buffer.reset();
51 
52     // Atomically replace the existing file with the new one.
53     return Temp.keep(FinalPath);
54   }
55 
56   ~OnDiskBuffer() override {
57     // Close the mapping before deleting the temp file, so that the removal
58     // succeeds.
59     Buffer.reset();
60     consumeError(Temp.discard());
61   }
62 
63   void discard() override {
64     // Delete the temp file if it still was open, but keeping the mapping
65     // active.
66     consumeError(Temp.discard());
67   }
68 
69 private:
70   std::unique_ptr<fs::mapped_file_region> Buffer;
71   fs::TempFile Temp;
72 };
73 
74 // A FileOutputBuffer which keeps data in memory and writes to the final
75 // output file on commit(). This is used only when we cannot use OnDiskBuffer.
76 class InMemoryBuffer : public FileOutputBuffer {
77 public:
78   InMemoryBuffer(StringRef Path, MemoryBlock Buf, std::size_t BufSize,
79                  unsigned Mode)
80       : FileOutputBuffer(Path), Buffer(Buf), BufferSize(BufSize),
81         Mode(Mode) {}
82 
83   uint8_t *getBufferStart() const override { return (uint8_t *)Buffer.base(); }
84 
85   uint8_t *getBufferEnd() const override {
86     return (uint8_t *)Buffer.base() + BufferSize;
87   }
88 
89   size_t getBufferSize() const override { return BufferSize; }
90 
91   Error commit() override {
92     if (FinalPath == "-") {
93       llvm::outs() << StringRef((const char *)Buffer.base(), BufferSize);
94       llvm::outs().flush();
95       return Error::success();
96     }
97 
98     using namespace sys::fs;
99     int FD;
100     std::error_code EC;
101     if (auto EC =
102             openFileForWrite(FinalPath, FD, CD_CreateAlways, OF_None, Mode))
103       return errorCodeToError(EC);
104     raw_fd_ostream OS(FD, /*shouldClose=*/true, /*unbuffered=*/true);
105     OS << StringRef((const char *)Buffer.base(), BufferSize);
106     return Error::success();
107   }
108 
109 private:
110   // Buffer may actually contain a larger memory block than BufferSize
111   OwningMemoryBlock Buffer;
112   size_t BufferSize;
113   unsigned Mode;
114 };
115 } // namespace
116 
117 static Expected<std::unique_ptr<InMemoryBuffer>>
118 createInMemoryBuffer(StringRef Path, size_t Size, unsigned Mode) {
119   std::error_code EC;
120   MemoryBlock MB = Memory::allocateMappedMemory(
121       Size, nullptr, sys::Memory::MF_READ | sys::Memory::MF_WRITE, EC);
122   if (EC)
123     return errorCodeToError(EC);
124   return std::make_unique<InMemoryBuffer>(Path, MB, Size, Mode);
125 }
126 
127 static Expected<std::unique_ptr<FileOutputBuffer>>
128 createOnDiskBuffer(StringRef Path, size_t Size, unsigned Mode) {
129   Expected<fs::TempFile> FileOrErr =
130       fs::TempFile::create(Path + ".tmp%%%%%%%", Mode);
131   if (!FileOrErr)
132     return FileOrErr.takeError();
133   fs::TempFile File = std::move(*FileOrErr);
134 
135 #ifndef _WIN32
136   // On Windows, CreateFileMapping (the mmap function on Windows)
137   // automatically extends the underlying file. We don't need to
138   // extend the file beforehand. _chsize (ftruncate on Windows) is
139   // pretty slow just like it writes specified amount of bytes,
140   // so we should avoid calling that function.
141   if (auto EC = fs::resize_file(File.FD, Size)) {
142     consumeError(File.discard());
143     return errorCodeToError(EC);
144   }
145 #endif
146 
147   // Mmap it.
148   std::error_code EC;
149   auto MappedFile = std::make_unique<fs::mapped_file_region>(
150       fs::convertFDToNativeFile(File.FD), fs::mapped_file_region::readwrite,
151       Size, 0, EC);
152 
153   // mmap(2) can fail if the underlying filesystem does not support it.
154   // If that happens, we fall back to in-memory buffer as the last resort.
155   if (EC) {
156     consumeError(File.discard());
157     return createInMemoryBuffer(Path, Size, Mode);
158   }
159 
160   return std::make_unique<OnDiskBuffer>(Path, std::move(File),
161                                          std::move(MappedFile));
162 }
163 
164 // Create an instance of FileOutputBuffer.
165 Expected<std::unique_ptr<FileOutputBuffer>>
166 FileOutputBuffer::create(StringRef Path, size_t Size, unsigned Flags) {
167   // Handle "-" as stdout just like llvm::raw_ostream does.
168   if (Path == "-")
169     return createInMemoryBuffer("-", Size, /*Mode=*/0);
170 
171   unsigned Mode = fs::all_read | fs::all_write;
172   if (Flags & F_executable)
173     Mode |= fs::all_exe;
174 
175   fs::file_status Stat;
176   fs::status(Path, Stat);
177 
178   // Usually, we want to create OnDiskBuffer to create a temporary file in
179   // the same directory as the destination file and atomically replaces it
180   // by rename(2).
181   //
182   // However, if the destination file is a special file, we don't want to
183   // use rename (e.g. we don't want to replace /dev/null with a regular
184   // file.) If that's the case, we create an in-memory buffer, open the
185   // destination file and write to it on commit().
186   switch (Stat.type()) {
187   case fs::file_type::directory_file:
188     return errorCodeToError(errc::is_a_directory);
189   case fs::file_type::regular_file:
190   case fs::file_type::file_not_found:
191   case fs::file_type::status_error:
192     if (Flags & F_no_mmap)
193       return createInMemoryBuffer(Path, Size, Mode);
194     else
195       return createOnDiskBuffer(Path, Size, Mode);
196   default:
197     return createInMemoryBuffer(Path, Size, Mode);
198   }
199 }
200