1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
|
//===-- FileCollector.cpp ---------------------------------------*- 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
//
//===----------------------------------------------------------------------===//
#include "llvm/Support/FileCollector.h"
#include "llvm/ADT/SmallString.h"
#include "llvm/Support/FileSystem.h"
#include "llvm/Support/Path.h"
#include "llvm/Support/Process.h"
using namespace llvm;
static bool isCaseSensitivePath(StringRef Path) {
SmallString<256> TmpDest = Path, UpperDest, RealDest;
// Remove component traversals, links, etc.
if (!sys::fs::real_path(Path, TmpDest))
return true; // Current default value in vfs.yaml
Path = TmpDest;
// Change path to all upper case and ask for its real path, if the latter
// exists and is equal to path, it's not case sensitive. Default to case
// sensitive in the absence of real_path, since this is the YAMLVFSWriter
// default.
UpperDest = Path.upper();
if (sys::fs::real_path(UpperDest, RealDest) && Path.equals(RealDest))
return false;
return true;
}
FileCollector::FileCollector(std::string Root, std::string OverlayRoot)
: Root(std::move(Root)), OverlayRoot(std::move(OverlayRoot)) {
sys::fs::create_directories(this->Root, true);
}
bool FileCollector::getRealPath(StringRef SrcPath,
SmallVectorImpl<char> &Result) {
SmallString<256> RealPath;
StringRef FileName = sys::path::filename(SrcPath);
std::string Directory = sys::path::parent_path(SrcPath).str();
auto DirWithSymlink = SymlinkMap.find(Directory);
// Use real_path to fix any symbolic link component present in a path.
// Computing the real path is expensive, cache the search through the parent
// path Directory.
if (DirWithSymlink == SymlinkMap.end()) {
auto EC = sys::fs::real_path(Directory, RealPath);
if (EC)
return false;
SymlinkMap[Directory] = RealPath.str();
} else {
RealPath = DirWithSymlink->second;
}
sys::path::append(RealPath, FileName);
Result.swap(RealPath);
return true;
}
void FileCollector::addFile(const Twine &file) {
std::lock_guard<std::mutex> lock(Mutex);
std::string FileStr = file.str();
if (markAsSeen(FileStr))
addFileImpl(FileStr);
}
void FileCollector::addFileImpl(StringRef SrcPath) {
// We need an absolute src path to append to the root.
SmallString<256> AbsoluteSrc = SrcPath;
sys::fs::make_absolute(AbsoluteSrc);
// Canonicalize src to a native path to avoid mixed separator styles.
sys::path::native(AbsoluteSrc);
// Remove redundant leading "./" pieces and consecutive separators.
AbsoluteSrc = sys::path::remove_leading_dotslash(AbsoluteSrc);
// Canonicalize the source path by removing "..", "." components.
SmallString<256> VirtualPath = AbsoluteSrc;
sys::path::remove_dots(VirtualPath, /*remove_dot_dot=*/true);
// If a ".." component is present after a symlink component, remove_dots may
// lead to the wrong real destination path. Let the source be canonicalized
// like that but make sure we always use the real path for the destination.
SmallString<256> CopyFrom;
if (!getRealPath(AbsoluteSrc, CopyFrom))
CopyFrom = VirtualPath;
SmallString<256> DstPath = StringRef(Root);
sys::path::append(DstPath, sys::path::relative_path(CopyFrom));
// Always map a canonical src path to its real path into the YAML, by doing
// this we map different virtual src paths to the same entry in the VFS
// overlay, which is a way to emulate symlink inside the VFS; this is also
// needed for correctness, not doing that can lead to module redefinition
// errors.
addFileToMapping(VirtualPath, DstPath);
}
/// Set the access and modification time for the given file from the given
/// status object.
static std::error_code
copyAccessAndModificationTime(StringRef Filename,
const sys::fs::file_status &Stat) {
int FD;
if (auto EC =
sys::fs::openFileForWrite(Filename, FD, sys::fs::CD_OpenExisting))
return EC;
if (auto EC = sys::fs::setLastAccessAndModificationTime(
FD, Stat.getLastAccessedTime(), Stat.getLastModificationTime()))
return EC;
if (auto EC = sys::Process::SafelyCloseFileDescriptor(FD))
return EC;
return {};
}
std::error_code FileCollector::copyFiles(bool StopOnError) {
for (auto &entry : VFSWriter.getMappings()) {
// Create directory tree.
if (std::error_code EC =
sys::fs::create_directories(sys::path::parent_path(entry.RPath),
/*IgnoreExisting=*/true)) {
if (StopOnError)
return EC;
}
// Copy file over.
if (std::error_code EC = sys::fs::copy_file(entry.VPath, entry.RPath)) {
if (StopOnError)
return EC;
}
// Copy over permissions.
if (auto perms = sys::fs::getPermissions(entry.VPath)) {
if (std::error_code EC = sys::fs::setPermissions(entry.RPath, *perms)) {
if (StopOnError)
return EC;
}
}
// Copy over modification time.
sys::fs::file_status Stat;
if (std::error_code EC = sys::fs::status(entry.VPath, Stat)) {
if (StopOnError)
return EC;
continue;
}
copyAccessAndModificationTime(entry.RPath, Stat);
}
return {};
}
std::error_code FileCollector::writeMapping(StringRef mapping_file) {
std::lock_guard<std::mutex> lock(Mutex);
VFSWriter.setOverlayDir(OverlayRoot);
VFSWriter.setCaseSensitivity(isCaseSensitivePath(OverlayRoot));
VFSWriter.setUseExternalNames(false);
std::error_code EC;
raw_fd_ostream os(mapping_file, EC, sys::fs::F_Text);
if (EC)
return EC;
VFSWriter.write(os);
return {};
}
|
