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
|
// Copyright 2018 The Chromium Authors
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#ifdef UNSAFE_BUFFERS_BUILD
// TODO(crbug.com/390223051): Remove C-library calls to fix the errors.
#pragma allow_unsafe_libc_calls
#endif
#include "base/metrics/persistent_histogram_storage.h"
#include <cinttypes>
#include <string_view>
#include "base/files/file_util.h"
#include "base/files/important_file_writer.h"
#include "base/logging.h"
#include "base/metrics/persistent_histogram_allocator.h"
#include "base/metrics/persistent_memory_allocator.h"
#include "base/process/memory.h"
#include "base/strings/string_util.h"
#include "base/strings/stringprintf.h"
#include "base/time/time.h"
#include "build/build_config.h"
#if BUILDFLAG(IS_WIN)
#include <windows.h>
// Must be after <windows.h>
#include <memoryapi.h>
#elif BUILDFLAG(IS_POSIX) || BUILDFLAG(IS_FUCHSIA)
#include <sys/mman.h>
#endif
namespace {
constexpr size_t kAllocSize = 1 << 20; // 1 MiB
void* AllocateLocalMemory(size_t size) {
void* address;
#if BUILDFLAG(IS_WIN)
address =
::VirtualAlloc(nullptr, size, MEM_RESERVE | MEM_COMMIT, PAGE_READWRITE);
if (address) {
return address;
}
#elif BUILDFLAG(IS_POSIX) || BUILDFLAG(IS_FUCHSIA)
// MAP_ANON is deprecated on Linux but MAP_ANONYMOUS is not universal on Mac.
// MAP_SHARED is not available on Linux <2.4 but required on Mac.
address = ::mmap(nullptr, size, PROT_READ | PROT_WRITE, MAP_ANON | MAP_SHARED,
-1, 0);
if (address != MAP_FAILED) {
return address;
}
#else
#error This architecture is not (yet) supported.
#endif
// As a last resort, just allocate the memory from the heap. This will
// achieve the same basic result but the acquired memory has to be
// explicitly zeroed and thus realized immediately (i.e. all pages are
// added to the process now instead of only when first accessed).
if (!base::UncheckedMalloc(size, &address)) {
return nullptr;
}
DCHECK(address);
memset(address, 0, size);
return address;
}
} // namespace
namespace base {
PersistentHistogramStorage::PersistentHistogramStorage(
std::string_view allocator_name,
StorageDirManagement storage_dir_management)
: storage_dir_management_(storage_dir_management) {
DCHECK(!allocator_name.empty());
DCHECK(IsStringASCII(allocator_name));
// This code may be executed before crash handling and/or OOM handling has
// been initialized for the process. Silently ignore a failed allocation
// (no metric persistence) rather that generating a crash that won't be
// caught/reported.
void* memory = AllocateLocalMemory(kAllocSize);
if (!memory) {
return;
}
GlobalHistogramAllocator::CreateWithPersistentMemory(memory, kAllocSize, 0,
0, // No identifier.
allocator_name);
GlobalHistogramAllocator::Get()->CreateTrackingHistograms(allocator_name);
}
PersistentHistogramStorage::~PersistentHistogramStorage() {
PersistentHistogramAllocator* allocator = GlobalHistogramAllocator::Get();
if (!allocator) {
return;
}
allocator->UpdateTrackingHistograms();
if (disabled_) {
return;
}
// Stop if the storage base directory has not been properly set.
if (storage_base_dir_.empty()) {
LOG(ERROR)
<< "Could not write \"" << allocator->Name()
<< "\" persistent histograms to file as the storage base directory "
"is not properly set.";
return;
}
FilePath storage_dir = storage_base_dir_.AppendASCII(allocator->Name());
switch (storage_dir_management_) {
case StorageDirManagement::kCreate:
if (!CreateDirectory(storage_dir)) {
LOG(ERROR)
<< "Could not write \"" << allocator->Name()
<< "\" persistent histograms to file as the storage directory "
"cannot be created.";
return;
}
break;
case StorageDirManagement::kUseExisting:
if (!DirectoryExists(storage_dir)) {
// When the consumer of this class decides to use an existing storage
// directory, it should ensure the directory's existence if it's
// essential.
LOG(ERROR)
<< "Could not write \"" << allocator->Name()
<< "\" persistent histograms to file as the storage directory "
"does not exist.";
return;
}
break;
}
// Save data using the process ID and microseconds since Windows Epoch for the
// filename with the correct extension. Using this format prevents collisions
// between multiple processes using the same provider name.
const FilePath file_path =
storage_dir
.AppendASCII(StringPrintf(
"%" CrPRIdPid "_%" PRId64, GetCurrentProcId(),
Time::Now().ToDeltaSinceWindowsEpoch().InMicroseconds()))
.AddExtension(PersistentMemoryAllocator::kFileExtension);
std::string_view contents(static_cast<const char*>(allocator->data()),
allocator->used());
if (!ImportantFileWriter::WriteFileAtomically(file_path, contents)) {
LOG(ERROR) << "Persistent histograms fail to write to file: "
<< file_path.value();
}
}
} // namespace base
|
