llvm-project

1
//===-- sanitizer_file.cpp -----------------------------------------------===//
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
// This file is shared between AddressSanitizer and ThreadSanitizer
10
// run-time libraries.  It defines filesystem-related interfaces.  This
11
// is separate from sanitizer_common.cpp so that it's simpler to disable
12
// all the filesystem support code for a port that doesn't use it.
13
//
14
//===---------------------------------------------------------------------===//
15

16
#include "sanitizer_platform.h"
17

18
#if !SANITIZER_FUCHSIA
19

20
#include "sanitizer_common.h"
21
#include "sanitizer_file.h"
22
#  include "sanitizer_interface_internal.h"
23

24
namespace __sanitizer {
25

26
void CatastrophicErrorWrite(const char *buffer, uptr length) {
27
  WriteToFile(kStderrFd, buffer, length);
28
}
29

30
StaticSpinMutex report_file_mu;
31
ReportFile report_file = {&report_file_mu, kStderrFd, "", "", 0};
32

33
void RawWrite(const char *buffer) {
34
  report_file.Write(buffer, internal_strlen(buffer));
35
}
36

37
void ReportFile::ReopenIfNecessary() {
38
  mu->CheckLocked();
39
  if (fd == kStdoutFd || fd == kStderrFd) return;
40

41
  uptr pid = internal_getpid();
42
  // If in tracer, use the parent's file.
43
  if (pid == stoptheworld_tracer_pid)
44
    pid = stoptheworld_tracer_ppid;
45
  if (fd != kInvalidFd) {
46
    // If the report file is already opened by the current process,
47
    // do nothing. Otherwise the report file was opened by the parent
48
    // process, close it now.
49
    if (fd_pid == pid)
50
      return;
51
    else
52
      CloseFile(fd);
53
  }
54

55
  const char *exe_name = GetProcessName();
56
  if (common_flags()->log_exe_name && exe_name) {
57
    internal_snprintf(full_path, kMaxPathLength, "%s.%s.%zu", path_prefix,
58
                      exe_name, pid);
59
  } else {
60
    internal_snprintf(full_path, kMaxPathLength, "%s.%zu", path_prefix, pid);
61
  }
62
  if (common_flags()->log_suffix) {
63
    internal_strlcat(full_path, common_flags()->log_suffix, kMaxPathLength);
64
  }
65
  error_t err;
66
  fd = OpenFile(full_path, WrOnly, &err);
67
  if (fd == kInvalidFd) {
68
    const char *ErrorMsgPrefix = "ERROR: Can't open file: ";
69
    WriteToFile(kStderrFd, ErrorMsgPrefix, internal_strlen(ErrorMsgPrefix));
70
    WriteToFile(kStderrFd, full_path, internal_strlen(full_path));
71
    char errmsg[100];
72
    internal_snprintf(errmsg, sizeof(errmsg), " (reason: %d)", err);
73
    WriteToFile(kStderrFd, errmsg, internal_strlen(errmsg));
74
    Die();
75
  }
76
  fd_pid = pid;
77
}
78

79
static void RecursiveCreateParentDirs(char *path) {
80
  if (path[0] == '\0')
81
    return;
82
  for (int i = 1; path[i] != '\0'; ++i) {
83
    char save = path[i];
84
    if (!IsPathSeparator(path[i]))
85
      continue;
86
    path[i] = '\0';
87
    if (!DirExists(path) && !CreateDir(path)) {
88
      const char *ErrorMsgPrefix = "ERROR: Can't create directory: ";
89
      WriteToFile(kStderrFd, ErrorMsgPrefix, internal_strlen(ErrorMsgPrefix));
90
      WriteToFile(kStderrFd, path, internal_strlen(path));
91
      Die();
92
    }
93
    path[i] = save;
94
  }
95
}
96

97
void ReportFile::SetReportPath(const char *path) {
98
  if (path) {
99
    uptr len = internal_strlen(path);
100
    if (len > sizeof(path_prefix) - 100) {
101
      Report("ERROR: Path is too long: %c%c%c%c%c%c%c%c...\n", path[0], path[1],
102
             path[2], path[3], path[4], path[5], path[6], path[7]);
103
      Die();
104
    }
105
  }
106

107
  SpinMutexLock l(mu);
108
  if (fd != kStdoutFd && fd != kStderrFd && fd != kInvalidFd)
109
    CloseFile(fd);
110
  fd = kInvalidFd;
111
  if (!path || internal_strcmp(path, "stderr") == 0) {
112
    fd = kStderrFd;
113
  } else if (internal_strcmp(path, "stdout") == 0) {
114
    fd = kStdoutFd;
115
  } else {
116
    internal_snprintf(path_prefix, kMaxPathLength, "%s", path);
117
    RecursiveCreateParentDirs(path_prefix);
118
  }
119
}
120

121
const char *ReportFile::GetReportPath() {
122
  SpinMutexLock l(mu);
123
  ReopenIfNecessary();
124
  return full_path;
125
}
126

127
bool ReadFileToBuffer(const char *file_name, char **buff, uptr *buff_size,
128
                      uptr *read_len, uptr max_len, error_t *errno_p) {
129
  *buff = nullptr;
130
  *buff_size = 0;
131
  *read_len = 0;
132
  if (!max_len)
133
    return true;
134
  uptr PageSize = GetPageSizeCached();
135
  uptr kMinFileLen = Min(PageSize, max_len);
136

137
  // The files we usually open are not seekable, so try different buffer sizes.
138
  for (uptr size = kMinFileLen;; size = Min(size * 2, max_len)) {
139
    UnmapOrDie(*buff, *buff_size);
140
    *buff = (char*)MmapOrDie(size, __func__);
141
    *buff_size = size;
142
    fd_t fd = OpenFile(file_name, RdOnly, errno_p);
143
    if (fd == kInvalidFd) {
144
      UnmapOrDie(*buff, *buff_size);
145
      return false;
146
    }
147
    *read_len = 0;
148
    // Read up to one page at a time.
149
    bool reached_eof = false;
150
    while (*read_len < size) {
151
      uptr just_read;
152
      if (!ReadFromFile(fd, *buff + *read_len, size - *read_len, &just_read,
153
                        errno_p)) {
154
        UnmapOrDie(*buff, *buff_size);
155
        CloseFile(fd);
156
        return false;
157
      }
158
      *read_len += just_read;
159
      if (just_read == 0 || *read_len == max_len) {
160
        reached_eof = true;
161
        break;
162
      }
163
    }
164
    CloseFile(fd);
165
    if (reached_eof)  // We've read the whole file.
166
      break;
167
  }
168
  return true;
169
}
170

171
bool ReadFileToVector(const char *file_name,
172
                      InternalMmapVectorNoCtor<char> *buff, uptr max_len,
173
                      error_t *errno_p) {
174
  buff->clear();
175
  if (!max_len)
176
    return true;
177
  uptr PageSize = GetPageSizeCached();
178
  fd_t fd = OpenFile(file_name, RdOnly, errno_p);
179
  if (fd == kInvalidFd)
180
    return false;
181
  uptr read_len = 0;
182
  while (read_len < max_len) {
183
    if (read_len >= buff->size())
184
      buff->resize(Min(Max(PageSize, read_len * 2), max_len));
185
    CHECK_LT(read_len, buff->size());
186
    CHECK_LE(buff->size(), max_len);
187
    uptr just_read;
188
    if (!ReadFromFile(fd, buff->data() + read_len, buff->size() - read_len,
189
                      &just_read, errno_p)) {
190
      CloseFile(fd);
191
      return false;
192
    }
193
    read_len += just_read;
194
    if (!just_read)
195
      break;
196
  }
197
  CloseFile(fd);
198
  buff->resize(read_len);
199
  return true;
200
}
201

202
static const char kPathSeparator = SANITIZER_WINDOWS ? ';' : ':';
203

204
char *FindPathToBinary(const char *name) {
205
  if (FileExists(name)) {
206
    return internal_strdup(name);
207
  }
208

209
  const char *path = GetEnv("PATH");
210
  if (!path)
211
    return nullptr;
212
  uptr name_len = internal_strlen(name);
213
  InternalMmapVector<char> buffer(kMaxPathLength);
214
  const char *beg = path;
215
  while (true) {
216
    const char *end = internal_strchrnul(beg, kPathSeparator);
217
    uptr prefix_len = end - beg;
218
    if (prefix_len + name_len + 2 <= kMaxPathLength) {
219
      internal_memcpy(buffer.data(), beg, prefix_len);
220
      buffer[prefix_len] = '/';
221
      internal_memcpy(&buffer[prefix_len + 1], name, name_len);
222
      buffer[prefix_len + 1 + name_len] = '\0';
223
      if (FileExists(buffer.data()))
224
        return internal_strdup(buffer.data());
225
    }
226
    if (*end == '\0') break;
227
    beg = end + 1;
228
  }
229
  return nullptr;
230
}
231

232
} // namespace __sanitizer
233

234
using namespace __sanitizer;
235

236
extern "C" {
237
void __sanitizer_set_report_path(const char *path) {
238
  report_file.SetReportPath(path);
239
}
240

241
void __sanitizer_set_report_fd(void *fd) {
242
  report_file.fd = (fd_t)reinterpret_cast<uptr>(fd);
243
  report_file.fd_pid = internal_getpid();
244
}
245

246
const char *__sanitizer_get_report_path() {
247
  return report_file.GetReportPath();
248
}
249
} // extern "C"
250

251
#endif  // !SANITIZER_FUCHSIA
252