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
|
// Copyright 2015 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#include "base/android/library_loader/library_prefetcher.h"
#include <sys/resource.h>
#include <sys/wait.h>
#include <unistd.h>
#include <utility>
#include <vector>
#include "base/macros.h"
#include "base/posix/eintr_wrapper.h"
#include "base/strings/string_util.h"
namespace base {
namespace android {
namespace {
// Android defines the background priority to this value since at least 2009
// (see Process.java).
const int kBackgroundPriority = 10;
// Valid for all the Android architectures.
const size_t kPageSize = 4096;
const char* kLibchromeSuffix = "libchrome.so";
// "base.apk" is a suffix because the library may be loaded directly from the
// APK.
const char* kSuffixesToMatch[] = {kLibchromeSuffix, "base.apk"};
bool IsReadableAndPrivate(const base::debug::MappedMemoryRegion& region) {
return region.permissions & base::debug::MappedMemoryRegion::READ &&
region.permissions & base::debug::MappedMemoryRegion::PRIVATE;
}
bool PathMatchesSuffix(const std::string& path) {
for (size_t i = 0; i < arraysize(kSuffixesToMatch); i++) {
if (EndsWith(path, kSuffixesToMatch[i], CompareCase::SENSITIVE)) {
return true;
}
}
return false;
}
// For each range, reads a byte per page to force it into the page cache.
// Heap allocations, syscalls and library functions are not allowed in this
// function.
// Returns true for success.
bool Prefetch(const std::vector<std::pair<uintptr_t, uintptr_t>>& ranges) {
for (const auto& range : ranges) {
const uintptr_t page_mask = kPageSize - 1;
// If start or end is not page-aligned, parsing went wrong. It is better to
// exit with an error.
if ((range.first & page_mask) || (range.second & page_mask)) {
return false; // CHECK() is not allowed here.
}
unsigned char* start_ptr = reinterpret_cast<unsigned char*>(range.first);
unsigned char* end_ptr = reinterpret_cast<unsigned char*>(range.second);
unsigned char dummy = 0;
for (unsigned char* ptr = start_ptr; ptr < end_ptr; ptr += kPageSize) {
// Volatile is required to prevent the compiler from eliminating this
// loop.
dummy ^= *static_cast<volatile unsigned char*>(ptr);
}
}
return true;
}
} // namespace
// static
bool NativeLibraryPrefetcher::IsGoodToPrefetch(
const base::debug::MappedMemoryRegion& region) {
return PathMatchesSuffix(region.path) &&
IsReadableAndPrivate(region); // .text and .data mappings are private.
}
// static
void NativeLibraryPrefetcher::FilterLibchromeRangesOnlyIfPossible(
const std::vector<base::debug::MappedMemoryRegion>& regions,
std::vector<AddressRange>* ranges) {
bool has_libchrome_region = false;
for (const base::debug::MappedMemoryRegion& region : regions) {
if (EndsWith(region.path, kLibchromeSuffix, CompareCase::SENSITIVE)) {
has_libchrome_region = true;
break;
}
}
for (const base::debug::MappedMemoryRegion& region : regions) {
if (has_libchrome_region &&
!EndsWith(region.path, kLibchromeSuffix, CompareCase::SENSITIVE)) {
continue;
}
ranges->push_back(std::make_pair(region.start, region.end));
}
}
// static
bool NativeLibraryPrefetcher::FindRanges(std::vector<AddressRange>* ranges) {
std::string proc_maps;
if (!base::debug::ReadProcMaps(&proc_maps))
return false;
std::vector<base::debug::MappedMemoryRegion> regions;
if (!base::debug::ParseProcMaps(proc_maps, ®ions))
return false;
std::vector<base::debug::MappedMemoryRegion> regions_to_prefetch;
for (const auto& region : regions) {
if (IsGoodToPrefetch(region)) {
regions_to_prefetch.push_back(region);
}
}
FilterLibchromeRangesOnlyIfPossible(regions_to_prefetch, ranges);
return true;
}
// static
bool NativeLibraryPrefetcher::ForkAndPrefetchNativeLibrary() {
// Looking for ranges is done before the fork, to avoid syscalls and/or memory
// allocations in the forked process. The child process inherits the lock
// state of its parent thread. It cannot rely on being able to acquire any
// lock (unless special care is taken in a pre-fork handler), including being
// able to call malloc().
std::vector<AddressRange> ranges;
if (!FindRanges(&ranges))
return false;
pid_t pid = fork();
if (pid == 0) {
setpriority(PRIO_PROCESS, 0, kBackgroundPriority);
// _exit() doesn't call the atexit() handlers.
_exit(Prefetch(ranges) ? 0 : 1);
} else {
if (pid < 0) {
return false;
}
int status;
const pid_t result = HANDLE_EINTR(waitpid(pid, &status, 0));
if (result == pid) {
if (WIFEXITED(status)) {
return WEXITSTATUS(status) == 0;
}
}
return false;
}
}
} // namespace android
} // namespace base
|
