1 //===- FileOutputBuffer.cpp - File Output Buffer ----------------*- C++ -*-===//
3 // The LLVM Compiler Infrastructure
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
8 //===----------------------------------------------------------------------===//
10 // Utility for creating a in-memory buffer that will be written to a file.
12 //===----------------------------------------------------------------------===//
14 #include "llvm/Support/FileOutputBuffer.h"
15 #include "llvm/ADT/STLExtras.h"
16 #include "llvm/ADT/SmallString.h"
17 #include "llvm/Support/Errc.h"
18 #include "llvm/Support/Memory.h"
19 #include "llvm/Support/Path.h"
20 #include <system_error>
22 #if !defined(_MSC_VER) && !defined(__MINGW32__)
29 using namespace llvm::sys
;
32 // A FileOutputBuffer which creates a temporary file in the same directory
33 // as the final output file. The final output file is atomically replaced
34 // with the temporary file on commit().
35 class OnDiskBuffer
: public FileOutputBuffer
{
37 OnDiskBuffer(StringRef Path
, fs::TempFile Temp
,
38 std::unique_ptr
<fs::mapped_file_region
> Buf
)
39 : FileOutputBuffer(Path
), Buffer(std::move(Buf
)), Temp(std::move(Temp
)) {}
41 uint8_t *getBufferStart() const override
{ return (uint8_t *)Buffer
->data(); }
43 uint8_t *getBufferEnd() const override
{
44 return (uint8_t *)Buffer
->data() + Buffer
->size();
47 size_t getBufferSize() const override
{ return Buffer
->size(); }
49 Error
commit() override
{
50 // Unmap buffer, letting OS flush dirty pages to file on disk.
53 // Atomically replace the existing file with the new one.
54 return Temp
.keep(FinalPath
);
57 ~OnDiskBuffer() override
{
58 // Close the mapping before deleting the temp file, so that the removal
61 consumeError(Temp
.discard());
64 void discard() override
{
65 // Delete the temp file if it still was open, but keeping the mapping
67 consumeError(Temp
.discard());
71 std::unique_ptr
<fs::mapped_file_region
> Buffer
;
75 // A FileOutputBuffer which keeps data in memory and writes to the final
76 // output file on commit(). This is used only when we cannot use OnDiskBuffer.
77 class InMemoryBuffer
: public FileOutputBuffer
{
79 InMemoryBuffer(StringRef Path
, MemoryBlock Buf
, unsigned Mode
)
80 : FileOutputBuffer(Path
), Buffer(Buf
), Mode(Mode
) {}
82 uint8_t *getBufferStart() const override
{ return (uint8_t *)Buffer
.base(); }
84 uint8_t *getBufferEnd() const override
{
85 return (uint8_t *)Buffer
.base() + Buffer
.size();
88 size_t getBufferSize() const override
{ return Buffer
.size(); }
90 Error
commit() override
{
91 using namespace sys::fs
;
95 openFileForWrite(FinalPath
, FD
, CD_CreateAlways
, OF_None
, Mode
))
96 return errorCodeToError(EC
);
97 raw_fd_ostream
OS(FD
, /*shouldClose=*/true, /*unbuffered=*/true);
98 OS
<< StringRef((const char *)Buffer
.base(), Buffer
.size());
99 return Error::success();
103 OwningMemoryBlock Buffer
;
108 static Expected
<std::unique_ptr
<InMemoryBuffer
>>
109 createInMemoryBuffer(StringRef Path
, size_t Size
, unsigned Mode
) {
111 MemoryBlock MB
= Memory::allocateMappedMemory(
112 Size
, nullptr, sys::Memory::MF_READ
| sys::Memory::MF_WRITE
, EC
);
114 return errorCodeToError(EC
);
115 return llvm::make_unique
<InMemoryBuffer
>(Path
, MB
, Mode
);
118 static Expected
<std::unique_ptr
<OnDiskBuffer
>>
119 createOnDiskBuffer(StringRef Path
, size_t Size
, bool InitExisting
,
121 Expected
<fs::TempFile
> FileOrErr
=
122 fs::TempFile::create(Path
+ ".tmp%%%%%%%", Mode
);
124 return FileOrErr
.takeError();
125 fs::TempFile File
= std::move(*FileOrErr
);
128 if (auto EC
= sys::fs::copy_file(Path
, File
.FD
))
129 return errorCodeToError(EC
);
132 // On Windows, CreateFileMapping (the mmap function on Windows)
133 // automatically extends the underlying file. We don't need to
134 // extend the file beforehand. _chsize (ftruncate on Windows) is
135 // pretty slow just like it writes specified amount of bytes,
136 // so we should avoid calling that function.
137 if (auto EC
= fs::resize_file(File
.FD
, Size
)) {
138 consumeError(File
.discard());
139 return errorCodeToError(EC
);
146 auto MappedFile
= llvm::make_unique
<fs::mapped_file_region
>(
147 File
.FD
, fs::mapped_file_region::readwrite
, Size
, 0, EC
);
149 consumeError(File
.discard());
150 return errorCodeToError(EC
);
152 return llvm::make_unique
<OnDiskBuffer
>(Path
, std::move(File
),
153 std::move(MappedFile
));
156 // Create an instance of FileOutputBuffer.
157 Expected
<std::unique_ptr
<FileOutputBuffer
>>
158 FileOutputBuffer::create(StringRef Path
, size_t Size
, unsigned Flags
) {
159 unsigned Mode
= fs::all_read
| fs::all_write
;
160 if (Flags
& F_executable
)
163 fs::file_status Stat
;
164 fs::status(Path
, Stat
);
166 if ((Flags
& F_modify
) && Size
== size_t(-1)) {
167 if (Stat
.type() == fs::file_type::regular_file
)
168 Size
= Stat
.getSize();
169 else if (Stat
.type() == fs::file_type::file_not_found
)
170 return errorCodeToError(errc::no_such_file_or_directory
);
172 return errorCodeToError(errc::invalid_argument
);
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
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(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 return createOnDiskBuffer(Path
, Size
, !!(Flags
& F_modify
), Mode
);
191 return createInMemoryBuffer(Path
, Size
, Mode
);