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/Support/Errc.h"
15#include "llvm/Support/FileSystem.h"
16#include "llvm/Support/Memory.h"
17#include "llvm/Support/TimeProfiler.h"
18#include <system_error>
19
20#if !defined(_MSC_VER) && !defined(__MINGW32__)
21#include <unistd.h>
22#else
23#include <io.h>
24#endif
25
26using namespace llvm;
27using namespace llvm::sys;
28
29namespace {
30// A FileOutputBuffer which creates a temporary file in the same directory
31// as the final output file. The final output file is atomically replaced
32// with the temporary file on commit().
33class OnDiskBuffer : public FileOutputBuffer {
34public:
35 OnDiskBuffer(StringRef Path, fs::TempFile Temp, fs::mapped_file_region Buf)
36 : FileOutputBuffer(Path), Buffer(std::move(Buf)), Temp(std::move(Temp)) {}
37
38 uint8_t *getBufferStart() const override { return (uint8_t *)Buffer.data(); }
39
40 uint8_t *getBufferEnd() const override {
41 return (uint8_t *)Buffer.data() + Buffer.size();
42 }
43
44 size_t getBufferSize() const override { return Buffer.size(); }
45
46 Error commit() override {
47 llvm::TimeTraceScope timeScope("Commit buffer to disk");
48
49 // Unmap buffer, letting OS flush dirty pages to file on disk.
50 Buffer.unmap();
51
52 // Atomically replace the existing file with the new one.
53 return Temp.keep(Name: FinalPath);
54 }
55
56 ~OnDiskBuffer() override {
57 // Close the mapping before deleting the temp file, so that the removal
58 // succeeds.
59 Buffer.unmap();
60 consumeError(Err: 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(Err: Temp.discard());
67 }
68
69private:
70 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.
76class InMemoryBuffer : public FileOutputBuffer {
77public:
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(Name: FinalPath, ResultFD&: FD, Disp: CD_CreateAlways, Flags: OF_Delete, 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
109private:
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
117static Expected<std::unique_ptr<InMemoryBuffer>>
118createInMemoryBuffer(StringRef Path, size_t Size, unsigned Mode) {
119 std::error_code EC;
120 MemoryBlock MB = Memory::allocateMappedMemory(
121 NumBytes: Size, NearBlock: nullptr, Flags: sys::Memory::MF_READ | sys::Memory::MF_WRITE, EC);
122 if (EC)
123 return errorCodeToError(EC);
124 return std::make_unique<InMemoryBuffer>(args&: Path, args&: MB, args&: Size, args&: Mode);
125}
126
127static Expected<std::unique_ptr<FileOutputBuffer>>
128createOnDiskBuffer(StringRef Path, size_t Size, unsigned Mode) {
129 Expected<fs::TempFile> FileOrErr =
130 fs::TempFile::create(Model: Path + ".tmp%%%%%%%", Mode);
131 if (!FileOrErr)
132 return FileOrErr.takeError();
133 fs::TempFile File = std::move(*FileOrErr);
134
135 if (auto EC = fs::resize_file_before_mapping_readwrite(FD: File.FD, Size)) {
136 consumeError(Err: File.discard());
137 return errorCodeToError(EC);
138 }
139
140 // Mmap it.
141 std::error_code EC;
142 fs::mapped_file_region MappedFile =
143 fs::mapped_file_region(fs::convertFDToNativeFile(FD: File.FD),
144 fs::mapped_file_region::readwrite, Size, 0, EC);
145
146 // mmap(2) can fail if the underlying filesystem does not support it.
147 // If that happens, we fall back to in-memory buffer as the last resort.
148 if (EC) {
149 consumeError(Err: File.discard());
150 return createInMemoryBuffer(Path, Size, Mode);
151 }
152
153 return std::make_unique<OnDiskBuffer>(args&: Path, args: std::move(File),
154 args: std::move(MappedFile));
155}
156
157// Create an instance of FileOutputBuffer.
158Expected<std::unique_ptr<FileOutputBuffer>>
159FileOutputBuffer::create(StringRef Path, size_t Size, unsigned Flags) {
160 // Handle "-" as stdout just like llvm::raw_ostream does.
161 if (Path == "-")
162 return createInMemoryBuffer(Path: "-", Size, /*Mode=*/0);
163
164 unsigned Mode = fs::all_read | fs::all_write;
165 if (Flags & F_executable)
166 Mode |= fs::all_exe;
167
168 // If Size is zero, don't use mmap which will fail with EINVAL.
169 if (Size == 0)
170 return createInMemoryBuffer(Path, Size, Mode);
171
172 fs::file_status Stat;
173 fs::status(path: Path, result&: Stat);
174
175 // Usually, we want to create OnDiskBuffer to create a temporary file in
176 // the same directory as the destination file and atomically replaces it
177 // by rename(2).
178 //
179 // However, if the destination file is a special file, we don't want to
180 // use rename (e.g. we don't want to replace /dev/null with a regular
181 // file.) If that's the case, we create an in-memory buffer, open the
182 // destination file and write to it on commit().
183 switch (Stat.type()) {
184 case fs::file_type::directory_file:
185 return errorCodeToError(EC: errc::is_a_directory);
186 case fs::file_type::regular_file:
187 case fs::file_type::file_not_found:
188 case fs::file_type::status_error:
189 if (Flags & F_mmap)
190 return createInMemoryBuffer(Path, Size, Mode);
191 else
192 return createOnDiskBuffer(Path, Size, Mode);
193 default:
194 return createInMemoryBuffer(Path, Size, Mode);
195 }
196}
197