diff options
117 files changed, 4811 insertions, 7760 deletions
diff --git a/cmds/atrace/atrace.cpp b/cmds/atrace/atrace.cpp index 79419d3ae6..021fdb53b2 100644 --- a/cmds/atrace/atrace.cpp +++ b/cmds/atrace/atrace.cpp @@ -245,6 +245,7 @@ static const TracingCategory k_categories[] = { { OPT, "events/kmem/ion_heap_shrink/enable" }, { OPT, "events/ion/ion_stat/enable" }, { OPT, "events/gpu_mem/gpu_mem_total/enable" }, + { OPT, "events/fastrpc/fastrpc_dma_stat/enable" }, } }, { "thermal", "Thermal event", 0, { { REQ, "events/thermal/thermal_temperature/enable" }, diff --git a/cmds/dumpsys/dumpsys.cpp b/cmds/dumpsys/dumpsys.cpp index ba1c449dbf..83a52b85a3 100644 --- a/cmds/dumpsys/dumpsys.cpp +++ b/cmds/dumpsys/dumpsys.cpp @@ -24,6 +24,7 @@ #include <android-base/unique_fd.h> #include <binder/Parcel.h> #include <binder/ProcessState.h> +#include <binder/Stability.h> #include <binder/TextOutput.h> #include <binderdebug/BinderDebug.h> #include <serviceutils/PriorityDumper.h> @@ -69,12 +70,13 @@ static void usage() { " -t TIMEOUT_SEC: TIMEOUT to use in seconds instead of default 10 seconds\n" " -T TIMEOUT_MS: TIMEOUT to use in milliseconds instead of default 10 seconds\n" " --pid: dump PID instead of usual dump\n" - " --thread: dump thread usage instead of usual dump\n" " --proto: filter services that support dumping data in proto format. Dumps\n" " will be in proto format.\n" " --priority LEVEL: filter services based on specified priority\n" " LEVEL must be one of CRITICAL | HIGH | NORMAL\n" " --skip SERVICES: dumps all services but SERVICES (comma-separated list)\n" + " --stability: dump binder stability information instead of usual dump\n" + " --thread: dump thread usage instead of usual dump\n" " SERVICE [ARGS]: dumps only service SERVICE, optionally passing ARGS to it\n"); } @@ -128,12 +130,13 @@ int Dumpsys::main(int argc, char* const argv[]) { Type type = Type::DUMP; int timeoutArgMs = 10000; int priorityFlags = IServiceManager::DUMP_FLAG_PRIORITY_ALL; - static struct option longOptions[] = {{"thread", no_argument, 0, 0}, + static struct option longOptions[] = {{"help", no_argument, 0, 0}, {"pid", no_argument, 0, 0}, {"priority", required_argument, 0, 0}, {"proto", no_argument, 0, 0}, {"skip", no_argument, 0, 0}, - {"help", no_argument, 0, 0}, + {"stability", no_argument, 0, 0}, + {"thread", no_argument, 0, 0}, {0, 0, 0, 0}}; // Must reset optind, otherwise subsequent calls will fail (wouldn't happen on main.cpp, but @@ -167,6 +170,8 @@ int Dumpsys::main(int argc, char* const argv[]) { } } else if (!strcmp(longOptions[optionIndex].name, "pid")) { type = Type::PID; + } else if (!strcmp(longOptions[optionIndex].name, "stability")) { + type = Type::STABILITY; } else if (!strcmp(longOptions[optionIndex].name, "thread")) { type = Type::THREAD; } @@ -335,6 +340,11 @@ static status_t dumpPidToFd(const sp<IBinder>& service, const unique_fd& fd) { return OK; } +static status_t dumpStabilityToFd(const sp<IBinder>& service, const unique_fd& fd) { + WriteStringToFd(internal::Stability::debugToString(service) + "\n", fd); + return OK; +} + static status_t dumpThreadsToFd(const sp<IBinder>& service, const unique_fd& fd) { pid_t pid; status_t status = service->getDebugPid(&pid); @@ -382,6 +392,9 @@ status_t Dumpsys::startDumpThread(Type type, const String16& serviceName, case Type::PID: err = dumpPidToFd(service, remote_end); break; + case Type::STABILITY: + err = dumpStabilityToFd(service, remote_end); + break; case Type::THREAD: err = dumpThreadsToFd(service, remote_end); break; diff --git a/cmds/dumpsys/dumpsys.h b/cmds/dumpsys/dumpsys.h index 349947ce12..1b3ae6a81c 100644 --- a/cmds/dumpsys/dumpsys.h +++ b/cmds/dumpsys/dumpsys.h @@ -52,9 +52,10 @@ class Dumpsys { static void setServiceArgs(Vector<String16>& args, bool asProto, int priorityFlags); enum class Type { - DUMP, // dump using `dump` function - PID, // dump pid of server only - THREAD, // dump thread usage of server only + DUMP, // dump using `dump` function + PID, // dump pid of server only + STABILITY, // dump stability information of server + THREAD, // dump thread usage of server only }; /** diff --git a/cmds/dumpsys/tests/dumpsys_test.cpp b/cmds/dumpsys/tests/dumpsys_test.cpp index c9d2dbb883..277f445931 100644 --- a/cmds/dumpsys/tests/dumpsys_test.cpp +++ b/cmds/dumpsys/tests/dumpsys_test.cpp @@ -582,6 +582,27 @@ TEST_F(DumpsysTest, ListServiceWithPid) { AssertOutput(std::to_string(getpid()) + "\n"); } +// Tests 'dumpsys --stability' +TEST_F(DumpsysTest, ListAllServicesWithStability) { + ExpectListServices({"Locksmith", "Valet"}); + ExpectCheckService("Locksmith"); + ExpectCheckService("Valet"); + + CallMain({"--stability"}); + + AssertRunningServices({"Locksmith", "Valet"}); + AssertOutputContains("stability"); +} + +// Tests 'dumpsys --stability service_name' +TEST_F(DumpsysTest, ListServiceWithStability) { + ExpectCheckService("Locksmith"); + + CallMain({"--stability", "Locksmith"}); + + AssertOutputContains("stability"); +} + // Tests 'dumpsys --thread' TEST_F(DumpsysTest, ListAllServicesWithThread) { ExpectListServices({"Locksmith", "Valet"}); diff --git a/cmds/surfacereplayer/proto/src/trace.proto b/cmds/surfacereplayer/proto/src/trace.proto index 3798ba73a4..29d4409a86 100644 --- a/cmds/surfacereplayer/proto/src/trace.proto +++ b/cmds/surfacereplayer/proto/src/trace.proto @@ -100,6 +100,10 @@ message LayerStackChange { required uint32 layer_stack = 1; } +message DisplayFlagsChange { + required uint32 flags = 1; +} + message HiddenFlagChange { required bool hidden_flag = 1; } @@ -120,6 +124,7 @@ message DisplayChange { LayerStackChange layer_stack = 3; SizeChange size = 4; ProjectionChange projection = 5; + DisplayFlagsChange flags = 6; } } @@ -212,4 +217,4 @@ message BlurRegionChange { message Origin { required int32 pid = 1; required int32 uid = 2; -}
\ No newline at end of file +} diff --git a/include/ftl/cast.h b/include/ftl/cast.h new file mode 100644 index 0000000000..ff1b58ad56 --- /dev/null +++ b/include/ftl/cast.h @@ -0,0 +1,84 @@ +/* + * Copyright 2021 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#pragma once + +#include <limits> +#include <type_traits> + +#include <ftl/details/cast.h> + +namespace android::ftl { + +enum class CastSafety { kSafe, kUnderflow, kOverflow }; + +// Returns whether static_cast<R>(v) is safe, or would result in underflow or overflow. +// +// static_assert(ftl::cast_safety<uint8_t>(-1) == ftl::CastSafety::kUnderflow); +// static_assert(ftl::cast_safety<int8_t>(128u) == ftl::CastSafety::kOverflow); +// +// static_assert(ftl::cast_safety<uint32_t>(-.1f) == ftl::CastSafety::kUnderflow); +// static_assert(ftl::cast_safety<int32_t>(static_cast<float>(INT32_MAX)) == +// ftl::CastSafety::kOverflow); +// +// static_assert(ftl::cast_safety<float>(-DBL_MAX) == ftl::CastSafety::kUnderflow); +// +template <typename R, typename T> +constexpr CastSafety cast_safety(T v) { + static_assert(std::is_arithmetic_v<T>); + static_assert(std::is_arithmetic_v<R>); + + constexpr bool kFromSigned = std::is_signed_v<T>; + constexpr bool kToSigned = std::is_signed_v<R>; + + using details::max_exponent; + + // If the R range contains the T range, then casting is always safe. + if constexpr ((kFromSigned == kToSigned && max_exponent<R> >= max_exponent<T>) || + (!kFromSigned && kToSigned && max_exponent<R> > max_exponent<T>)) { + return CastSafety::kSafe; + } + + using C = std::common_type_t<R, T>; + + if constexpr (kFromSigned) { + using L = details::safe_limits<R, T>; + + if constexpr (kToSigned) { + // Signed to signed. + if (v < L::lowest()) return CastSafety::kUnderflow; + return v <= L::max() ? CastSafety::kSafe : CastSafety::kOverflow; + } else { + // Signed to unsigned. + if (v < 0) return CastSafety::kUnderflow; + return static_cast<C>(v) <= static_cast<C>(L::max()) ? CastSafety::kSafe + : CastSafety::kOverflow; + } + } else { + using L = std::numeric_limits<R>; + + if constexpr (kToSigned) { + // Unsigned to signed. + return static_cast<C>(v) <= static_cast<C>(L::max()) ? CastSafety::kSafe + : CastSafety::kOverflow; + } else { + // Unsigned to unsigned. + return v <= L::max() ? CastSafety::kSafe : CastSafety::kOverflow; + } + } +} + +} // namespace android::ftl diff --git a/include/ftl/details/cast.h b/include/ftl/details/cast.h new file mode 100644 index 0000000000..87b9f1e20a --- /dev/null +++ b/include/ftl/details/cast.h @@ -0,0 +1,57 @@ +/* + * Copyright 2021 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#pragma once + +#include <limits> +#include <type_traits> + +namespace android::ftl::details { + +// Exponent whose power of 2 is the (exclusive) upper bound of T. +template <typename T, typename L = std::numeric_limits<T>> +constexpr int max_exponent = std::is_floating_point_v<T> ? L::max_exponent : L::digits; + +// Extension of std::numeric_limits<T> that reduces the maximum for integral types T such that it +// has an exact representation for floating-point types F. For example, the maximum int32_t value +// is 2'147'483'647, but casting it to float commonly rounds up to 2'147'483'650.f, which cannot +// be safely converted back lest the signed overflow invokes undefined behavior. This pitfall is +// avoided by clearing the lower (31 - 24 =) 7 bits of precision to 2'147'483'520. Note that the +// minimum is representable. +template <typename T, typename F> +struct safe_limits : std::numeric_limits<T> { + static constexpr T max() { + using Base = std::numeric_limits<T>; + + if constexpr (std::is_integral_v<T> && std::is_floating_point_v<F>) { + // Assume the mantissa is 24 bits for float, or 53 bits for double. + using Float = std::numeric_limits<F>; + static_assert(Float::is_iec559); + + // If the integer is wider than the mantissa, clear the excess bits of precision. + constexpr int kShift = Base::digits - Float::digits; + if constexpr (kShift > 0) { + using U = std::make_unsigned_t<T>; + constexpr U kOne = static_cast<U>(1); + return static_cast<U>(Base::max()) & ~((kOne << kShift) - kOne); + } + } + + return Base::max(); + } +}; + +} // namespace android::ftl::details diff --git a/include/ftl/small_map.h b/include/ftl/small_map.h index 84c15ebdca..bcaba82934 100644 --- a/include/ftl/small_map.h +++ b/include/ftl/small_map.h @@ -19,6 +19,7 @@ #include <ftl/initializer_list.h> #include <ftl/small_vector.h> +#include <algorithm> #include <functional> #include <optional> #include <type_traits> @@ -28,7 +29,10 @@ namespace android::ftl { // Associative container with unique, unordered keys. Unlike std::unordered_map, key-value pairs are // stored in contiguous storage for cache efficiency. The map is allocated statically until its size -// exceeds N, at which point mappings are relocated to dynamic memory. +// exceeds N, at which point mappings are relocated to dynamic memory. The try_emplace operation has +// a non-standard analogue try_replace that destructively emplaces. The API also defines an in-place +// counterpart to insert_or_assign: emplace_or_replace. Lookup is done not via a subscript operator, +// but immutable getters that can optionally transform the value. // // SmallMap<K, V, 0> unconditionally allocates on the heap. // @@ -43,16 +47,19 @@ namespace android::ftl { // assert(!map.dynamic()); // // assert(map.contains(123)); -// assert(map.find(42, [](const std::string& s) { return s.size(); }) == 3u); +// assert(map.get(42, [](const std::string& s) { return s.size(); }) == 3u); // -// const auto opt = map.find(-1); +// const auto opt = map.get(-1); // assert(opt); // // std::string& ref = *opt; // assert(ref.empty()); // ref = "xyz"; // -// assert(map == SmallMap(ftl::init::map(-1, "xyz")(42, "???")(123, "abc"))); +// map.emplace_or_replace(0, "vanilla", 2u, 3u); +// assert(map.dynamic()); +// +// assert(map == SmallMap(ftl::init::map(-1, "xyz")(0, "nil")(42, "???")(123, "abc"))); // template <typename K, typename V, std::size_t N> class SmallMap final { @@ -80,12 +87,7 @@ class SmallMap final { // The syntax for listing pairs is as follows: // // ftl::SmallMap map = ftl::init::map<int, std::string>(123, "abc")(-1)(42, 3u, '?'); - // // static_assert(std::is_same_v<decltype(map), ftl::SmallMap<int, std::string, 3>>); - // assert(map.size() == 3u); - // assert(map.contains(-1) && map.find(-1)->get().empty()); - // assert(map.contains(42) && map.find(42)->get() == "???"); - // assert(map.contains(123) && map.find(123)->get() == "abc"); // // The types of the key and value are deduced if the first pair contains exactly two arguments: // @@ -95,7 +97,7 @@ class SmallMap final { template <typename U, std::size_t... Sizes, typename... Types> SmallMap(InitializerList<U, std::index_sequence<Sizes...>, Types...>&& list) : map_(std::move(list)) { - // TODO: Enforce unique keys. + deduplicate(); } size_type max_size() const { return map_.max_size(); } @@ -115,27 +117,27 @@ class SmallMap final { // Returns whether a mapping exists for the given key. bool contains(const key_type& key) const { - return find(key, [](const mapped_type&) {}); + return get(key, [](const mapped_type&) {}); } // Returns a reference to the value for the given key, or std::nullopt if the key was not found. // // ftl::SmallMap map = ftl::init::map('a', 'A')('b', 'B')('c', 'C'); // - // const auto opt = map.find('c'); + // const auto opt = map.get('c'); // assert(opt == 'C'); // // char d = 'd'; - // const auto ref = map.find('d').value_or(std::ref(d)); + // const auto ref = map.get('d').value_or(std::ref(d)); // ref.get() = 'D'; // assert(d == 'D'); // - auto find(const key_type& key) const -> std::optional<std::reference_wrapper<const mapped_type>> { - return find(key, [](const mapped_type& v) { return std::cref(v); }); + auto get(const key_type& key) const -> std::optional<std::reference_wrapper<const mapped_type>> { + return get(key, [](const mapped_type& v) { return std::cref(v); }); } - auto find(const key_type& key) -> std::optional<std::reference_wrapper<mapped_type>> { - return find(key, [](mapped_type& v) { return std::ref(v); }); + auto get(const key_type& key) -> std::optional<std::reference_wrapper<mapped_type>> { + return get(key, [](mapped_type& v) { return std::ref(v); }); } // Returns the result R of a unary operation F on (a constant or mutable reference to) the value @@ -144,11 +146,11 @@ class SmallMap final { // // ftl::SmallMap map = ftl::init::map('a', 'x')('b', 'y')('c', 'z'); // - // assert(map.find('c', [](char c) { return std::toupper(c); }) == 'Z'); - // assert(map.find('c', [](char& c) { c = std::toupper(c); })); + // assert(map.get('c', [](char c) { return std::toupper(c); }) == 'Z'); + // assert(map.get('c', [](char& c) { c = std::toupper(c); })); // template <typename F, typename R = std::invoke_result_t<F, const mapped_type&>> - auto find(const key_type& key, F f) const + auto get(const key_type& key, F f) const -> std::conditional_t<std::is_void_v<R>, bool, std::optional<R>> { for (auto& [k, v] : *this) { if (k == key) { @@ -165,12 +167,96 @@ class SmallMap final { } template <typename F> - auto find(const key_type& key, F f) { - return std::as_const(*this).find( + auto get(const key_type& key, F f) { + return std::as_const(*this).get( key, [&f](const mapped_type& v) { return f(const_cast<mapped_type&>(v)); }); } + // Returns an iterator to an existing mapping for the given key, or the end() iterator otherwise. + const_iterator find(const key_type& key) const { return const_cast<SmallMap&>(*this).find(key); } + iterator find(const key_type& key) { return find(key, begin()); } + + // Inserts a mapping unless it exists. Returns an iterator to the inserted or existing mapping, + // and whether the mapping was inserted. + // + // On emplace, if the map reaches its static or dynamic capacity, then all iterators are + // invalidated. Otherwise, only the end() iterator is invalidated. + // + template <typename... Args> + std::pair<iterator, bool> try_emplace(const key_type& key, Args&&... args) { + if (const auto it = find(key); it != end()) { + return {it, false}; + } + + auto& ref = map_.emplace_back(std::piecewise_construct, std::forward_as_tuple(key), + std::forward_as_tuple(std::forward<Args>(args)...)); + return {&ref, true}; + } + + // Replaces a mapping if it exists, and returns an iterator to it. Returns the end() iterator + // otherwise. + // + // The value is replaced via move constructor, so type V does not need to define copy/move + // assignment, e.g. its data members may be const. + // + // The arguments may directly or indirectly refer to the mapping being replaced. + // + // Iterators to the replaced mapping point to its replacement, and others remain valid. + // + template <typename... Args> + iterator try_replace(const key_type& key, Args&&... args) { + const auto it = find(key); + if (it == end()) return it; + map_.replace(it, std::piecewise_construct, std::forward_as_tuple(key), + std::forward_as_tuple(std::forward<Args>(args)...)); + return it; + } + + // In-place counterpart of std::unordered_map's insert_or_assign. Returns true on emplace, or + // false on replace. + // + // The value is emplaced and replaced via move constructor, so type V does not need to define + // copy/move assignment, e.g. its data members may be const. + // + // On emplace, if the map reaches its static or dynamic capacity, then all iterators are + // invalidated. Otherwise, only the end() iterator is invalidated. On replace, iterators + // to the replaced mapping point to its replacement, and others remain valid. + // + template <typename... Args> + std::pair<iterator, bool> emplace_or_replace(const key_type& key, Args&&... args) { + const auto [it, ok] = try_emplace(key, std::forward<Args>(args)...); + if (ok) return {it, ok}; + map_.replace(it, std::piecewise_construct, std::forward_as_tuple(key), + std::forward_as_tuple(std::forward<Args>(args)...)); + return {it, ok}; + } + + // Removes a mapping if it exists, and returns whether it did. + // + // The last() and end() iterators, as well as those to the erased mapping, are invalidated. + // + bool erase(const key_type& key) { return erase(key, begin()); } + private: + iterator find(const key_type& key, iterator first) { + return std::find_if(first, end(), [&key](const auto& pair) { return pair.first == key; }); + } + + bool erase(const key_type& key, iterator first) { + const auto it = find(key, first); + if (it == end()) return false; + map_.unstable_erase(it); + return true; + } + + void deduplicate() { + for (auto it = begin(); it != end();) { + if (const auto key = it->first; ++it != end()) { + while (erase(key, it)); + } + } + } + Map map_; }; @@ -186,7 +272,7 @@ bool operator==(const SmallMap<K, V, N>& lhs, const SmallMap<Q, W, M>& rhs) { for (const auto& [k, v] : lhs) { const auto& lv = v; - if (!rhs.find(k, [&lv](const auto& rv) { return lv == rv; }).value_or(false)) { + if (!rhs.get(k, [&lv](const auto& rv) { return lv == rv; }).value_or(false)) { return false; } } diff --git a/include/ftl/small_vector.h b/include/ftl/small_vector.h index cb0ae359eb..0341435813 100644 --- a/include/ftl/small_vector.h +++ b/include/ftl/small_vector.h @@ -348,7 +348,7 @@ class SmallVector<T, 0> final : ArrayTraits<T>, using Impl::pop_back; void unstable_erase(iterator it) { - if (it != last()) std::iter_swap(it, last()); + if (it != last()) replace(it, std::move(back())); pop_back(); } diff --git a/include/ftl/string.h b/include/ftl/string.h new file mode 100644 index 0000000000..2d96b06a2f --- /dev/null +++ b/include/ftl/string.h @@ -0,0 +1,101 @@ +/* + * Copyright 2021 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#pragma once + +#include <cassert> +#include <charconv> +#include <limits> +#include <string> +#include <string_view> +#include <type_traits> + +namespace android::ftl { + +enum class Radix { kBin = 2, kDec = 10, kHex = 16 }; + +template <typename T> +struct to_chars_length { + static_assert(std::is_integral_v<T>); + // Maximum binary digits, plus minus sign and radix prefix. + static constexpr std::size_t value = std::numeric_limits<std::make_unsigned_t<T>>::digits + 3; +}; + +template <typename T> +constexpr std::size_t to_chars_length_v = to_chars_length<T>::value; + +template <typename T = std::int64_t> +using to_chars_buffer_t = char[to_chars_length_v<T>]; + +// Lightweight (not allocating nor sprintf-based) alternative to std::to_string for integers, with +// optional radix. See also ftl::to_string below. +// +// ftl::to_chars_buffer_t<> buffer; +// +// assert(ftl::to_chars(buffer, 123u) == "123"); +// assert(ftl::to_chars(buffer, -42, ftl::Radix::kBin) == "-0b101010"); +// assert(ftl::to_chars(buffer, 0xcafe, ftl::Radix::kHex) == "0xcafe"); +// assert(ftl::to_chars(buffer, '*', ftl::Radix::kHex) == "0x2a"); +// +template <typename T, std::size_t N> +std::string_view to_chars(char (&buffer)[N], T v, Radix radix = Radix::kDec) { + static_assert(N >= to_chars_length_v<T>); + + auto begin = buffer + 2; + const auto [end, err] = std::to_chars(begin, buffer + N, v, static_cast<int>(radix)); + assert(err == std::errc()); + + if (radix == Radix::kDec) { + // TODO: Replace with {begin, end} in C++20. + return {begin, static_cast<std::size_t>(end - begin)}; + } + + const auto prefix = radix == Radix::kBin ? 'b' : 'x'; + if constexpr (std::is_unsigned_v<T>) { + buffer[0] = '0'; + buffer[1] = prefix; + } else { + if (*begin == '-') { + *buffer = '-'; + } else { + --begin; + } + + *begin-- = prefix; + *begin = '0'; + } + + // TODO: Replace with {buffer, end} in C++20. + return {buffer, static_cast<std::size_t>(end - buffer)}; +} + +// Lightweight (not sprintf-based) alternative to std::to_string for integers, with optional radix. +// +// assert(ftl::to_string(123u) == "123"); +// assert(ftl::to_string(-42, ftl::Radix::kBin) == "-0b101010"); +// assert(ftl::to_string(0xcafe, ftl::Radix::kHex) == "0xcafe"); +// assert(ftl::to_string('*', ftl::Radix::kHex) == "0x2a"); +// +template <typename T> +inline std::string to_string(T v, Radix radix = Radix::kDec) { + to_chars_buffer_t<T> buffer; + return std::string(to_chars(buffer, v, radix)); +} + +std::string to_string(bool) = delete; +std::string to_string(bool, Radix) = delete; + +} // namespace android::ftl diff --git a/include/input/Input.h b/include/input/Input.h index e8678d27c3..438121b30e 100644 --- a/include/input/Input.h +++ b/include/input/Input.h @@ -368,8 +368,6 @@ struct PointerCoords { float getAxisValue(int32_t axis) const; status_t setAxisValue(int32_t axis, float value); - void scale(float globalScale); - // Scale the pointer coordinates according to a global scale and a // window scale. The global scale will be applied to TOUCH/TOOL_MAJOR/MINOR // axes, however the window scaling will not. diff --git a/libs/binder/Android.bp b/libs/binder/Android.bp index ec697a0223..b64b4a03e0 100644 --- a/libs/binder/Android.bp +++ b/libs/binder/Android.bp @@ -64,10 +64,15 @@ libbinder_device_interface_sources = [ "PermissionCache.cpp", "PermissionController.cpp", ] +libbinder_no_vendor_interface_sources = [ + ":packagemanager_aidl", +] cc_library { name: "libbinder", + version_script: "libbinder.map", + // for vndbinder vendor_available: true, vndk: { @@ -120,9 +125,8 @@ cc_library { "Status.cpp", "TextOutput.cpp", "Utils.cpp", - ":packagemanager_aidl", ":libbinder_aidl", - ], + ] + libbinder_no_vendor_interface_sources, target: { android: { @@ -133,36 +137,8 @@ cc_library { enabled: false, }, }, - android_arm64: { - // b/189438896 Sampling PGO restricted to arm64, arm32 in sc-dev - pgo: { - sampling: true, - profile_file: "libbinder/libbinder.profdata", - }, - // b/189438896 Add exported symbols in a map file for ABI stability - version_script: "libbinder.arm64.map", - target: { - vendor: { - version_script: "libbinder.arm64.vendor.map", - }, - }, - }, - android_arm: { - // b/189438896 Sampling PGO restricted to arm64, arm32 in sc-dev - pgo: { - sampling: true, - profile_file: "libbinder/libbinder.profdata", - }, - // b/189438896 Add exported symbols in a map file for ABI stability - version_script: "libbinder.arm32.map", - target: { - vendor: { - version_script: "libbinder.arm32.vendor.map", - }, - }, - }, vendor: { - exclude_srcs: libbinder_device_interface_sources, + exclude_srcs: libbinder_device_interface_sources + libbinder_no_vendor_interface_sources, }, darwin: { enabled: false, @@ -190,6 +166,10 @@ cc_library { binder32bit: { cflags: ["-DBINDER_IPC_32BIT=1"], }, + + debuggable: { + cflags: ["-DBINDER_RPC_DEV_SERVERS"], + }, }, shared_libs: [ @@ -232,6 +212,11 @@ cc_library { "performance*", "portability*", ], + + pgo: { + sampling: true, + profile_file: "libbinder/libbinder.profdata", + }, } // AIDL interface between libbinder and framework.jar @@ -269,6 +254,32 @@ aidl_interface { }, } +// TODO(b/184872979): remove once the Rust API is created. +cc_library { + name: "libbinder_rpc_unstable", + srcs: ["libbinder_rpc_unstable.cpp"], + defaults: ["libbinder_ndk_host_user"], + shared_libs: [ + "libbase", + "libbinder", + "libbinder_ndk", + "libutils", + ], + + // enumerate stable entry points, for apex use + stubs: { + symbol_file: "libbinder_rpc_unstable.map.txt", + }, + + // This library is intentionally limited to these targets, and it will be removed later. + // Do not expand the visibility. + visibility: [ + "//packages/modules/Virtualization/authfs:__subpackages__", + "//packages/modules/Virtualization/compos", + "//packages/modules/Virtualization/microdroid", + ], +} + // libbinder historically contained additional interfaces that provided specific // functionality in the platform but have nothing to do with binder itself. These // are moved out of libbinder in order to avoid the overhead of their vtables. @@ -321,3 +332,17 @@ cc_library { export_aidl_headers: true, }, } + +cc_binary { + name: "servicedispatcher", + host_supported: false, + srcs: [ + "servicedispatcher.cpp", + ], + shared_libs: [ + "libbase", + "libbinder", + "liblog", + "libutils", + ], +} diff --git a/libs/binder/Binder.cpp b/libs/binder/Binder.cpp index d5bdd1c803..02321cdf97 100644 --- a/libs/binder/Binder.cpp +++ b/libs/binder/Binder.cpp @@ -17,16 +17,25 @@ #include <binder/Binder.h> #include <atomic> -#include <utils/misc.h> +#include <set> + +#include <android-base/unique_fd.h> #include <binder/BpBinder.h> #include <binder/IInterface.h> +#include <binder/IPCThreadState.h> #include <binder/IResultReceiver.h> #include <binder/IShellCallback.h> #include <binder/Parcel.h> +#include <binder/RpcServer.h> +#include <private/android_filesystem_config.h> +#include <utils/misc.h> +#include <inttypes.h> #include <linux/sched.h> #include <stdio.h> +#include "RpcState.h" + namespace android { // Service implementations inherit from BBinder and IBinder, and this is frozen @@ -39,6 +48,12 @@ static_assert(sizeof(IBinder) == 12); static_assert(sizeof(BBinder) == 20); #endif +#ifdef BINDER_RPC_DEV_SERVERS +constexpr const bool kEnableRpcDevServers = true; +#else +constexpr const bool kEnableRpcDevServers = false; +#endif + // --------------------------------------------------------------------------- IBinder::IBinder() @@ -136,8 +151,68 @@ status_t IBinder::getDebugPid(pid_t* out) { return OK; } +status_t IBinder::setRpcClientDebug(android::base::unique_fd socketFd, + const sp<IBinder>& keepAliveBinder) { + if constexpr (!kEnableRpcDevServers) { + ALOGW("setRpcClientDebug disallowed because RPC is not enabled"); + return INVALID_OPERATION; + } + + BBinder* local = this->localBinder(); + if (local != nullptr) { + return local->BBinder::setRpcClientDebug(std::move(socketFd), keepAliveBinder); + } + + BpBinder* proxy = this->remoteBinder(); + LOG_ALWAYS_FATAL_IF(proxy == nullptr, "binder object must be either local or remote"); + + Parcel data; + Parcel reply; + status_t status; + if (status = data.writeBool(socketFd.ok()); status != OK) return status; + if (socketFd.ok()) { + // writeUniqueFileDescriptor currently makes an unnecessary dup(). + status = data.writeFileDescriptor(socketFd.release(), true /* own */); + if (status != OK) return status; + } + if (status = data.writeStrongBinder(keepAliveBinder); status != OK) return status; + return transact(SET_RPC_CLIENT_TRANSACTION, data, &reply); +} + // --------------------------------------------------------------------------- +class BBinder::RpcServerLink : public IBinder::DeathRecipient { +public: + // On binder died, calls RpcServer::shutdown on @a rpcServer, and removes itself from @a binder. + RpcServerLink(const sp<RpcServer>& rpcServer, const sp<IBinder>& keepAliveBinder, + const wp<BBinder>& binder) + : mRpcServer(rpcServer), mKeepAliveBinder(keepAliveBinder), mBinder(binder) {} + void binderDied(const wp<IBinder>&) override { + LOG_RPC_DETAIL("RpcServerLink: binder died, shutting down RpcServer"); + if (mRpcServer == nullptr) { + ALOGW("RpcServerLink: Unable to shut down RpcServer because it does not exist."); + } else { + ALOGW_IF(!mRpcServer->shutdown(), + "RpcServerLink: RpcServer did not shut down properly. Not started?"); + } + mRpcServer.clear(); + + auto promoted = mBinder.promote(); + if (promoted == nullptr) { + ALOGW("RpcServerLink: Unable to remove link from parent binder object because parent " + "binder object is gone."); + } else { + promoted->removeRpcServerLink(sp<RpcServerLink>::fromExisting(this)); + } + mBinder.clear(); + } + +private: + sp<RpcServer> mRpcServer; + sp<IBinder> mKeepAliveBinder; // hold to avoid automatically unlinking + wp<BBinder> mBinder; +}; + class BBinder::Extras { public: @@ -150,14 +225,13 @@ public: // for below objects Mutex mLock; + std::set<sp<RpcServerLink>> mRpcServerLinks; BpBinder::ObjectManager mObjects; }; // --------------------------------------------------------------------------- -BBinder::BBinder() : mExtras(nullptr), mStability(0) -{ -} +BBinder::BBinder() : mExtras(nullptr), mStability(0), mParceled(false) {} bool BBinder::isBinderAlive() const { @@ -199,6 +273,10 @@ status_t BBinder::transact( case DEBUG_PID_TRANSACTION: err = reply->writeInt32(getDebugPid()); break; + case SET_RPC_CLIENT_TRANSACTION: { + err = setRpcClientDebug(data); + break; + } default: err = onTransact(code, data, reply, flags); break; @@ -276,6 +354,10 @@ bool BBinder::isRequestingSid() void BBinder::setRequestingSid(bool requestingSid) { + LOG_ALWAYS_FATAL_IF(mParceled, + "setRequestingSid() should not be called after a binder object " + "is parceled/sent to another process"); + Extras* e = mExtras.load(std::memory_order_acquire); if (!e) { @@ -298,6 +380,10 @@ sp<IBinder> BBinder::getExtension() { } void BBinder::setMinSchedulerPolicy(int policy, int priority) { + LOG_ALWAYS_FATAL_IF(mParceled, + "setMinSchedulerPolicy() should not be called after a binder object " + "is parceled/sent to another process"); + switch (policy) { case SCHED_NORMAL: LOG_ALWAYS_FATAL_IF(priority < -20 || priority > 19, "Invalid priority for SCHED_NORMAL: %d", priority); @@ -345,6 +431,10 @@ bool BBinder::isInheritRt() { } void BBinder::setInheritRt(bool inheritRt) { + LOG_ALWAYS_FATAL_IF(mParceled, + "setInheritRt() should not be called after a binder object " + "is parceled/sent to another process"); + Extras* e = mExtras.load(std::memory_order_acquire); if (!e) { @@ -364,10 +454,106 @@ pid_t BBinder::getDebugPid() { } void BBinder::setExtension(const sp<IBinder>& extension) { + LOG_ALWAYS_FATAL_IF(mParceled, + "setExtension() should not be called after a binder object " + "is parceled/sent to another process"); + Extras* e = getOrCreateExtras(); e->mExtension = extension; } +bool BBinder::wasParceled() { + return mParceled; +} + +void BBinder::setParceled() { + mParceled = true; +} + +status_t BBinder::setRpcClientDebug(const Parcel& data) { + if constexpr (!kEnableRpcDevServers) { + ALOGW("%s: disallowed because RPC is not enabled", __PRETTY_FUNCTION__); + return INVALID_OPERATION; + } + uid_t uid = IPCThreadState::self()->getCallingUid(); + if (uid != AID_ROOT) { + ALOGE("%s: not allowed because client %" PRIu32 " is not root", __PRETTY_FUNCTION__, uid); + return PERMISSION_DENIED; + } + status_t status; + bool hasSocketFd; + android::base::unique_fd clientFd; + + if (status = data.readBool(&hasSocketFd); status != OK) return status; + if (hasSocketFd) { + if (status = data.readUniqueFileDescriptor(&clientFd); status != OK) return status; + } + sp<IBinder> keepAliveBinder; + if (status = data.readNullableStrongBinder(&keepAliveBinder); status != OK) return status; + + return setRpcClientDebug(std::move(clientFd), keepAliveBinder); +} + +status_t BBinder::setRpcClientDebug(android::base::unique_fd socketFd, + const sp<IBinder>& keepAliveBinder) { + if constexpr (!kEnableRpcDevServers) { + ALOGW("%s: disallowed because RPC is not enabled", __PRETTY_FUNCTION__); + return INVALID_OPERATION; + } + + const int socketFdForPrint = socketFd.get(); + LOG_RPC_DETAIL("%s(fd=%d)", __PRETTY_FUNCTION__, socketFdForPrint); + + if (!socketFd.ok()) { + ALOGE("%s: No socket FD provided.", __PRETTY_FUNCTION__); + return BAD_VALUE; + } + + if (keepAliveBinder == nullptr) { + ALOGE("%s: No keepAliveBinder provided.", __PRETTY_FUNCTION__); + return UNEXPECTED_NULL; + } + + size_t binderThreadPoolMaxCount = ProcessState::self()->getThreadPoolMaxThreadCount(); + if (binderThreadPoolMaxCount <= 1) { + ALOGE("%s: ProcessState thread pool max count is %zu. RPC is disabled for this service " + "because RPC requires the service to support multithreading.", + __PRETTY_FUNCTION__, binderThreadPoolMaxCount); + return INVALID_OPERATION; + } + + // Weak ref to avoid circular dependency: + // BBinder -> RpcServerLink ----> RpcServer -X-> BBinder + // `-X-> BBinder + auto weakThis = wp<BBinder>::fromExisting(this); + + Extras* e = getOrCreateExtras(); + AutoMutex _l(e->mLock); + auto rpcServer = RpcServer::make(); + LOG_ALWAYS_FATAL_IF(rpcServer == nullptr, "RpcServer::make returns null"); + rpcServer->iUnderstandThisCodeIsExperimentalAndIWillNotUseItInProduction(); + auto link = sp<RpcServerLink>::make(rpcServer, keepAliveBinder, weakThis); + if (auto status = keepAliveBinder->linkToDeath(link, nullptr, 0); status != OK) { + ALOGE("%s: keepAliveBinder->linkToDeath returns %s", __PRETTY_FUNCTION__, + statusToString(status).c_str()); + return status; + } + rpcServer->setRootObjectWeak(weakThis); + rpcServer->setupExternalServer(std::move(socketFd)); + rpcServer->setMaxThreads(binderThreadPoolMaxCount); + rpcServer->start(); + e->mRpcServerLinks.emplace(link); + LOG_RPC_DETAIL("%s(fd=%d) successful", __PRETTY_FUNCTION__, socketFdForPrint); + return OK; +} + +void BBinder::removeRpcServerLink(const sp<RpcServerLink>& link) { + Extras* e = mExtras.load(std::memory_order_acquire); + if (!e) return; + AutoMutex _l(e->mLock); + (void)e->mRpcServerLinks.erase(link); +} + BBinder::~BBinder() { Extras* e = mExtras.load(std::memory_order_relaxed); diff --git a/libs/binder/BpBinder.cpp b/libs/binder/BpBinder.cpp index 1dcb94c80f..5e44a0f7c1 100644 --- a/libs/binder/BpBinder.cpp +++ b/libs/binder/BpBinder.cpp @@ -273,7 +273,8 @@ status_t BpBinder::transact( status_t status; if (CC_UNLIKELY(isRpcBinder())) { - status = rpcSession()->transact(rpcAddress(), code, data, reply, flags); + status = rpcSession()->transact(sp<IBinder>::fromExisting(this), code, data, reply, + flags); } else { status = IPCThreadState::self()->transact(binderHandle(), code, data, reply, flags); } diff --git a/libs/binder/IPCThreadState.cpp b/libs/binder/IPCThreadState.cpp index 445df9eeff..fa9f3a9749 100644 --- a/libs/binder/IPCThreadState.cpp +++ b/libs/binder/IPCThreadState.cpp @@ -366,19 +366,46 @@ status_t IPCThreadState::clearLastError() pid_t IPCThreadState::getCallingPid() const { + checkContextIsBinderForUse(__func__); return mCallingPid; } const char* IPCThreadState::getCallingSid() const { + checkContextIsBinderForUse(__func__); return mCallingSid; } uid_t IPCThreadState::getCallingUid() const { + checkContextIsBinderForUse(__func__); return mCallingUid; } +const IPCThreadState::SpGuard* IPCThreadState::pushGetCallingSpGuard(const SpGuard* guard) { + const SpGuard* orig = mServingStackPointerGuard; + mServingStackPointerGuard = guard; + return orig; +} + +void IPCThreadState::restoreGetCallingSpGuard(const SpGuard* guard) { + mServingStackPointerGuard = guard; +} + +void IPCThreadState::checkContextIsBinderForUse(const char* use) const { + if (LIKELY(mServingStackPointerGuard == nullptr)) return; + + if (!mServingStackPointer || mServingStackPointerGuard->address < mServingStackPointer) { + LOG_ALWAYS_FATAL("In context %s, %s does not make sense (binder sp: %p, guard: %p).", + mServingStackPointerGuard->context, use, mServingStackPointer, + mServingStackPointerGuard->address); + } + + // in the case mServingStackPointer is deeper in the stack than the guard, + // we must be serving a binder transaction (maybe nested). This is a binder + // context, so we don't abort +} + int64_t IPCThreadState::clearCallingIdentity() { // ignore mCallingSid for legacy reasons @@ -845,6 +872,7 @@ status_t IPCThreadState::clearDeathNotification(int32_t handle, BpBinder* proxy) IPCThreadState::IPCThreadState() : mProcess(ProcessState::self()), mServingStackPointer(nullptr), + mServingStackPointerGuard(nullptr), mWorkSource(kUnsetWorkSource), mPropagateWorkSource(false), mIsLooper(false), @@ -1226,7 +1254,7 @@ status_t IPCThreadState::executeCommand(int32_t cmd) tr.offsets_size/sizeof(binder_size_t), freeBuffer); const void* origServingStackPointer = mServingStackPointer; - mServingStackPointer = &origServingStackPointer; // anything on the stack + mServingStackPointer = __builtin_frame_address(0); const pid_t origPid = mCallingPid; const char* origSid = mCallingSid; diff --git a/libs/binder/IServiceManager.cpp b/libs/binder/IServiceManager.cpp index f684cf672f..d421060aec 100644 --- a/libs/binder/IServiceManager.cpp +++ b/libs/binder/IServiceManager.cpp @@ -129,8 +129,7 @@ bool checkCallingPermission(const String16& permission) return checkCallingPermission(permission, nullptr, nullptr); } -static String16 _permission("permission"); - +static StaticString16 _permission(u"permission"); bool checkCallingPermission(const String16& permission, int32_t* outPid, int32_t* outUid) { @@ -320,14 +319,18 @@ sp<IBinder> ServiceManagerShim::waitForService(const String16& name16) const std::string name = String8(name16).c_str(); sp<IBinder> out; - if (!mTheRealServiceManager->getService(name, &out).isOk()) { + if (Status status = mTheRealServiceManager->getService(name, &out); !status.isOk()) { + ALOGW("Failed to getService in waitForService for %s: %s", name.c_str(), + status.toString8().c_str()); return nullptr; } if (out != nullptr) return out; sp<Waiter> waiter = sp<Waiter>::make(); - if (!mTheRealServiceManager->registerForNotifications( - name, waiter).isOk()) { + if (Status status = mTheRealServiceManager->registerForNotifications(name, waiter); + !status.isOk()) { + ALOGW("Failed to registerForNotifications in waitForService for %s: %s", name.c_str(), + status.toString8().c_str()); return nullptr; } Defer unregister ([&] { @@ -360,7 +363,9 @@ sp<IBinder> ServiceManagerShim::waitForService(const String16& name16) // - init gets death signal, but doesn't know it needs to restart // the service // - we need to request service again to get it to start - if (!mTheRealServiceManager->getService(name, &out).isOk()) { + if (Status status = mTheRealServiceManager->getService(name, &out); !status.isOk()) { + ALOGW("Failed to getService in waitForService on later try for %s: %s", name.c_str(), + status.toString8().c_str()); return nullptr; } if (out != nullptr) return out; @@ -369,7 +374,10 @@ sp<IBinder> ServiceManagerShim::waitForService(const String16& name16) bool ServiceManagerShim::isDeclared(const String16& name) { bool declared; - if (!mTheRealServiceManager->isDeclared(String8(name).c_str(), &declared).isOk()) { + if (Status status = mTheRealServiceManager->isDeclared(String8(name).c_str(), &declared); + !status.isOk()) { + ALOGW("Failed to get isDeclard for %s: %s", String8(name).c_str(), + status.toString8().c_str()); return false; } return declared; @@ -377,7 +385,11 @@ bool ServiceManagerShim::isDeclared(const String16& name) { Vector<String16> ServiceManagerShim::getDeclaredInstances(const String16& interface) { std::vector<std::string> out; - if (!mTheRealServiceManager->getDeclaredInstances(String8(interface).c_str(), &out).isOk()) { + if (Status status = + mTheRealServiceManager->getDeclaredInstances(String8(interface).c_str(), &out); + !status.isOk()) { + ALOGW("Failed to getDeclaredInstances for %s: %s", String8(interface).c_str(), + status.toString8().c_str()); return {}; } @@ -391,7 +403,10 @@ Vector<String16> ServiceManagerShim::getDeclaredInstances(const String16& interf std::optional<String16> ServiceManagerShim::updatableViaApex(const String16& name) { std::optional<std::string> declared; - if (!mTheRealServiceManager->updatableViaApex(String8(name).c_str(), &declared).isOk()) { + if (Status status = mTheRealServiceManager->updatableViaApex(String8(name).c_str(), &declared); + !status.isOk()) { + ALOGW("Failed to get updatableViaApex for %s: %s", String8(name).c_str(), + status.toString8().c_str()); return std::nullopt; } return declared ? std::optional<String16>(String16(declared.value().c_str())) : std::nullopt; diff --git a/libs/binder/Parcel.cpp b/libs/binder/Parcel.cpp index ee834ea43c..a2ac96e4f5 100644 --- a/libs/binder/Parcel.cpp +++ b/libs/binder/Parcel.cpp @@ -173,8 +173,8 @@ static void release_object(const sp<ProcessState>& proc, status_t Parcel::finishFlattenBinder(const sp<IBinder>& binder) { internal::Stability::tryMarkCompilationUnit(binder.get()); - auto category = internal::Stability::getCategory(binder.get()); - return writeInt32(category.repr()); + int16_t rep = internal::Stability::getCategory(binder.get()).repr(); + return writeInt32(rep); } status_t Parcel::finishUnflattenBinder( @@ -184,7 +184,8 @@ status_t Parcel::finishUnflattenBinder( status_t status = readInt32(&stability); if (status != OK) return status; - status = internal::Stability::setRepr(binder.get(), stability, true /*log*/); + status = internal::Stability::setRepr(binder.get(), static_cast<int16_t>(stability), + true /*log*/); if (status != OK) return status; *out = binder; @@ -195,13 +196,17 @@ static constexpr inline int schedPolicyMask(int policy, int priority) { return (priority & FLAT_BINDER_FLAG_PRIORITY_MASK) | ((policy & 3) << FLAT_BINDER_FLAG_SCHED_POLICY_SHIFT); } -status_t Parcel::flattenBinder(const sp<IBinder>& binder) -{ +status_t Parcel::flattenBinder(const sp<IBinder>& binder) { + BBinder* local = nullptr; + if (binder) local = binder->localBinder(); + if (local) local->setParceled(); + if (isForRpc()) { if (binder) { status_t status = writeInt32(1); // non-null if (status != OK) return status; RpcAddress address = RpcAddress::zero(); + // TODO(b/167966510): need to undo this if the Parcel is not sent status = mSession->state()->onBinderLeaving(mSession, binder, &address); if (status != OK) return status; status = address.writeToParcel(this); @@ -222,7 +227,6 @@ status_t Parcel::flattenBinder(const sp<IBinder>& binder) } if (binder != nullptr) { - BBinder *local = binder->localBinder(); if (!local) { BpBinder *proxy = binder->remoteBinder(); if (proxy == nullptr) { @@ -283,9 +287,10 @@ status_t Parcel::unflattenBinder(sp<IBinder>* out) const if (isNull & 1) { auto addr = RpcAddress::zero(); - status_t status = addr.readFromParcel(*this); - if (status != OK) return status; - binder = mSession->state()->onBinderEntering(mSession, addr); + if (status_t status = addr.readFromParcel(*this); status != OK) return status; + if (status_t status = mSession->state()->onBinderEntering(mSession, addr, &binder); + status != OK) + return status; } return finishUnflattenBinder(binder, out); @@ -1466,6 +1471,29 @@ const void* Parcel::readInplace(size_t len) const return nullptr; } +status_t Parcel::readOutVectorSizeWithCheck(size_t elmSize, int32_t* size) const { + if (status_t status = readInt32(size); status != OK) return status; + if (*size < 0) return OK; // may be null, client to handle + + LOG_ALWAYS_FATAL_IF(elmSize > INT32_MAX, "Cannot have element as big as %zu", elmSize); + + // approximation, can't know max element size (e.g. if it makes heap + // allocations) + static_assert(sizeof(int) == sizeof(int32_t), "Android is LP64"); + int32_t allocationSize; + if (__builtin_smul_overflow(elmSize, *size, &allocationSize)) return NO_MEMORY; + + // High limit of 1MB since something this big could never be returned. Could + // probably scope this down, but might impact very specific usecases. + constexpr int32_t kMaxAllocationSize = 1 * 1000 * 1000; + + if (allocationSize >= kMaxAllocationSize) { + return NO_MEMORY; + } + + return OK; +} + template<class T> status_t Parcel::readAligned(T *pArg) const { static_assert(PAD_SIZE_UNSAFE(sizeof(T)) == sizeof(T)); diff --git a/libs/binder/ProcessState.cpp b/libs/binder/ProcessState.cpp index bade9187ac..650a108aeb 100644 --- a/libs/binder/ProcessState.cpp +++ b/libs/binder/ProcessState.cpp @@ -359,6 +359,14 @@ status_t ProcessState::setThreadPoolMaxThreadCount(size_t maxThreads) { return result; } +size_t ProcessState::getThreadPoolMaxThreadCount() const { + // may actually be one more than this, if join is called + if (mThreadPoolStarted) return mMaxThreads; + // must not be initialized or maybe has poll thread setup, we + // currently don't track this in libbinder + return 0; +} + status_t ProcessState::enableOnewaySpamDetection(bool enable) { uint32_t enableDetection = enable ? 1 : 0; if (ioctl(mDriverFD, BINDER_ENABLE_ONEWAY_SPAM_DETECTION, &enableDetection) == -1) { diff --git a/libs/binder/RpcAddress.cpp b/libs/binder/RpcAddress.cpp index 5c3232045e..98dee9a039 100644 --- a/libs/binder/RpcAddress.cpp +++ b/libs/binder/RpcAddress.cpp @@ -29,7 +29,7 @@ RpcAddress RpcAddress::zero() { } bool RpcAddress::isZero() const { - RpcWireAddress ZERO{0}; + RpcWireAddress ZERO{.options = 0}; return memcmp(mRawAddr.get(), &ZERO, sizeof(RpcWireAddress)) == 0; } @@ -51,13 +51,34 @@ static void ReadRandomBytes(uint8_t* buf, size_t len) { close(fd); } -RpcAddress RpcAddress::unique() { +RpcAddress RpcAddress::random(bool forServer) { + // The remainder of this header acts as reserved space for different kinds + // of binder objects. + uint64_t options = RPC_WIRE_ADDRESS_OPTION_CREATED; + + // servers and clients allocate addresses independently, so this bit can + // tell you where an address originates + if (forServer) options |= RPC_WIRE_ADDRESS_OPTION_FOR_SERVER; + RpcAddress ret; - ReadRandomBytes((uint8_t*)ret.mRawAddr.get(), sizeof(RpcWireAddress)); + RpcWireAddress* raw = ret.mRawAddr.get(); + + raw->options = options; + ReadRandomBytes(raw->address, sizeof(raw->address)); + LOG_RPC_DETAIL("Creating new address: %s", ret.toString().c_str()); return ret; } +bool RpcAddress::isForServer() const { + return mRawAddr.get()->options & RPC_WIRE_ADDRESS_OPTION_FOR_SERVER; +} + +bool RpcAddress::isRecognizedType() const { + uint64_t allKnownOptions = RPC_WIRE_ADDRESS_OPTION_CREATED | RPC_WIRE_ADDRESS_OPTION_FOR_SERVER; + return (mRawAddr.get()->options & ~allKnownOptions) == 0; +} + RpcAddress RpcAddress::fromRawEmbedded(const RpcWireAddress* raw) { RpcAddress addr; memcpy(addr.mRawAddr.get(), raw, sizeof(RpcWireAddress)); diff --git a/libs/binder/RpcServer.cpp b/libs/binder/RpcServer.cpp index 9cc6e7fe04..a8f3fa8f6f 100644 --- a/libs/binder/RpcServer.cpp +++ b/libs/binder/RpcServer.cpp @@ -26,9 +26,9 @@ #include <binder/Parcel.h> #include <binder/RpcServer.h> #include <log/log.h> -#include "RpcState.h" #include "RpcSocketAddress.h" +#include "RpcState.h" #include "RpcWireFormat.h" namespace android { @@ -37,7 +37,9 @@ using base::ScopeGuard; using base::unique_fd; RpcServer::RpcServer() {} -RpcServer::~RpcServer() {} +RpcServer::~RpcServer() { + (void)shutdown(); +} sp<RpcServer> RpcServer::make() { return sp<RpcServer>::make(); @@ -99,7 +101,7 @@ bool RpcServer::setupInetServer(unsigned int port, unsigned int* assignedPort) { void RpcServer::setMaxThreads(size_t threads) { LOG_ALWAYS_FATAL_IF(threads <= 0, "RpcServer is useless without threads"); - LOG_ALWAYS_FATAL_IF(mStarted, "must be called before started"); + LOG_ALWAYS_FATAL_IF(mJoinThreadRunning, "Cannot set max threads while running"); mMaxThreads = threads; } @@ -126,33 +128,91 @@ sp<IBinder> RpcServer::getRootObject() { return ret; } -void RpcServer::join() { - while (true) { - (void)acceptOne(); - } +static void joinRpcServer(sp<RpcServer>&& thiz) { + thiz->join(); } -bool RpcServer::acceptOne() { +void RpcServer::start() { LOG_ALWAYS_FATAL_IF(!mAgreedExperimental, "no!"); - LOG_ALWAYS_FATAL_IF(!hasServer(), "RpcServer must be setup to join."); + std::lock_guard<std::mutex> _l(mLock); + LOG_ALWAYS_FATAL_IF(mJoinThread.get(), "Already started!"); + mJoinThread = std::make_unique<std::thread>(&joinRpcServer, sp<RpcServer>::fromExisting(this)); +} - unique_fd clientFd( - TEMP_FAILURE_RETRY(accept4(mServer.get(), nullptr, nullptr /*length*/, SOCK_CLOEXEC))); +void RpcServer::join() { + LOG_ALWAYS_FATAL_IF(!mAgreedExperimental, "no!"); - if (clientFd < 0) { - ALOGE("Could not accept4 socket: %s", strerror(errno)); - return false; + { + std::lock_guard<std::mutex> _l(mLock); + LOG_ALWAYS_FATAL_IF(!mServer.ok(), "RpcServer must be setup to join."); + LOG_ALWAYS_FATAL_IF(mShutdownTrigger != nullptr, "Already joined"); + mJoinThreadRunning = true; + mShutdownTrigger = RpcSession::FdTrigger::make(); + LOG_ALWAYS_FATAL_IF(mShutdownTrigger == nullptr, "Cannot create join signaler"); + } + + status_t status; + while ((status = mShutdownTrigger->triggerablePollRead(mServer)) == OK) { + unique_fd clientFd(TEMP_FAILURE_RETRY( + accept4(mServer.get(), nullptr, nullptr /*length*/, SOCK_CLOEXEC))); + + if (clientFd < 0) { + ALOGE("Could not accept4 socket: %s", strerror(errno)); + continue; + } + LOG_RPC_DETAIL("accept4 on fd %d yields fd %d", mServer.get(), clientFd.get()); + + { + std::lock_guard<std::mutex> _l(mLock); + std::thread thread = + std::thread(&RpcServer::establishConnection, sp<RpcServer>::fromExisting(this), + std::move(clientFd)); + mConnectingThreads[thread.get_id()] = std::move(thread); + } } - LOG_RPC_DETAIL("accept4 on fd %d yields fd %d", mServer.get(), clientFd.get()); + LOG_RPC_DETAIL("RpcServer::join exiting with %s", statusToString(status).c_str()); { std::lock_guard<std::mutex> _l(mLock); - std::thread thread = - std::thread(&RpcServer::establishConnection, this, - std::move(sp<RpcServer>::fromExisting(this)), std::move(clientFd)); - mConnectingThreads[thread.get_id()] = std::move(thread); + mJoinThreadRunning = false; + } + mShutdownCv.notify_all(); +} + +bool RpcServer::shutdown() { + std::unique_lock<std::mutex> _l(mLock); + if (mShutdownTrigger == nullptr) { + LOG_RPC_DETAIL("Cannot shutdown. No shutdown trigger installed."); + return false; + } + + mShutdownTrigger->trigger(); + for (auto& [id, session] : mSessions) { + (void)id; + session->mShutdownTrigger->trigger(); } + while (mJoinThreadRunning || !mConnectingThreads.empty() || !mSessions.empty()) { + if (std::cv_status::timeout == mShutdownCv.wait_for(_l, std::chrono::seconds(1))) { + ALOGE("Waiting for RpcServer to shut down (1s w/o progress). Join thread running: %d, " + "Connecting threads: " + "%zu, Sessions: %zu. Is your server deadlocked?", + mJoinThreadRunning, mConnectingThreads.size(), mSessions.size()); + } + } + + // At this point, we know join() is about to exit, but the thread that calls + // join() may not have exited yet. + // If RpcServer owns the join thread (aka start() is called), make sure the thread exits; + // otherwise ~thread() may call std::terminate(), which may crash the process. + // If RpcServer does not own the join thread (aka join() is called directly), + // then the owner of RpcServer is responsible for cleaning up that thread. + if (mJoinThread.get()) { + mJoinThread->join(); + mJoinThread.reset(); + } + + mShutdownTrigger = nullptr; return true; } @@ -172,62 +232,102 @@ size_t RpcServer::numUninitializedSessions() { } void RpcServer::establishConnection(sp<RpcServer>&& server, base::unique_fd clientFd) { - LOG_ALWAYS_FATAL_IF(this != server.get(), "Must pass same ownership object"); - // TODO(b/183988761): cannot trust this simple ID - LOG_ALWAYS_FATAL_IF(!mAgreedExperimental, "no!"); - bool idValid = true; - int32_t id; - if (sizeof(id) != read(clientFd.get(), &id, sizeof(id))) { - ALOGE("Could not read ID from fd %d", clientFd.get()); - idValid = false; + LOG_ALWAYS_FATAL_IF(!server->mAgreedExperimental, "no!"); + + // mShutdownTrigger can only be cleared once connection threads have joined. + // It must be set before this thread is started + LOG_ALWAYS_FATAL_IF(server->mShutdownTrigger == nullptr); + + RpcConnectionHeader header; + status_t status = server->mShutdownTrigger->interruptableReadFully(clientFd.get(), &header, + sizeof(header)); + bool idValid = status == OK; + if (!idValid) { + ALOGE("Failed to read ID for client connecting to RPC server: %s", + statusToString(status).c_str()); + // still need to cleanup before we can return } + bool reverse = header.options & RPC_CONNECTION_OPTION_REVERSE; std::thread thisThread; sp<RpcSession> session; { - std::lock_guard<std::mutex> _l(mLock); + std::unique_lock<std::mutex> _l(server->mLock); - auto threadId = mConnectingThreads.find(std::this_thread::get_id()); - LOG_ALWAYS_FATAL_IF(threadId == mConnectingThreads.end(), + auto threadId = server->mConnectingThreads.find(std::this_thread::get_id()); + LOG_ALWAYS_FATAL_IF(threadId == server->mConnectingThreads.end(), "Must establish connection on owned thread"); thisThread = std::move(threadId->second); - ScopeGuard detachGuard = [&]() { thisThread.detach(); }; - mConnectingThreads.erase(threadId); - - if (!idValid) { + ScopeGuard detachGuard = [&]() { + thisThread.detach(); + _l.unlock(); + server->mShutdownCv.notify_all(); + }; + server->mConnectingThreads.erase(threadId); + + if (!idValid || server->mShutdownTrigger->isTriggered()) { return; } - if (id == RPC_SESSION_ID_NEW) { - LOG_ALWAYS_FATAL_IF(mSessionIdCounter >= INT32_MAX, "Out of session IDs"); - mSessionIdCounter++; + RpcAddress sessionId = RpcAddress::fromRawEmbedded(&header.sessionId); + + if (sessionId.isZero()) { + if (reverse) { + ALOGE("Cannot create a new session with a reverse connection, would leak"); + return; + } + + RpcAddress sessionId = RpcAddress::zero(); + size_t tries = 0; + do { + // don't block if there is some entropy issue + if (tries++ > 5) { + ALOGE("Cannot find new address: %s", sessionId.toString().c_str()); + return; + } + + sessionId = RpcAddress::random(true /*forServer*/); + } while (server->mSessions.end() != server->mSessions.find(sessionId)); session = RpcSession::make(); - session->setForServer(wp<RpcServer>::fromExisting(this), mSessionIdCounter); + session->setMaxThreads(server->mMaxThreads); + if (!session->setForServer(server, + sp<RpcServer::EventListener>::fromExisting( + static_cast<RpcServer::EventListener*>( + server.get())), + sessionId)) { + ALOGE("Failed to attach server to session"); + return; + } - mSessions[mSessionIdCounter] = session; + server->mSessions[sessionId] = session; } else { - auto it = mSessions.find(id); - if (it == mSessions.end()) { - ALOGE("Cannot add thread, no record of session with ID %d", id); + auto it = server->mSessions.find(sessionId); + if (it == server->mSessions.end()) { + ALOGE("Cannot add thread, no record of session with ID %s", + sessionId.toString().c_str()); return; } session = it->second; } + if (reverse) { + LOG_ALWAYS_FATAL_IF(!session->addOutgoingConnection(std::move(clientFd), true), + "server state must already be initialized"); + return; + } + detachGuard.Disable(); - session->preJoin(std::move(thisThread)); + session->preJoinThreadOwnership(std::move(thisThread)); } + auto setupResult = session->preJoinSetup(std::move(clientFd)); + // avoid strong cycle server = nullptr; - // - // - // DO NOT ACCESS MEMBER VARIABLES BELOW - // - session->join(std::move(clientFd)); + RpcSession::join(std::move(session), std::move(setupResult)); } bool RpcServer::setupSocketServer(const RpcSocketAddress& addr) { @@ -255,22 +355,31 @@ bool RpcServer::setupSocketServer(const RpcSocketAddress& addr) { LOG_RPC_DETAIL("Successfully setup socket server %s", addr.toString().c_str()); - mServer = std::move(serverFd); + if (!setupExternalServer(std::move(serverFd))) { + ALOGE("Another thread has set up server while calling setupSocketServer. Race?"); + return false; + } return true; } -void RpcServer::onSessionTerminating(const sp<RpcSession>& session) { +void RpcServer::onSessionLockedAllIncomingThreadsEnded(const sp<RpcSession>& session) { auto id = session->mId; LOG_ALWAYS_FATAL_IF(id == std::nullopt, "Server sessions must be initialized with ID"); - LOG_RPC_DETAIL("Dropping session %d", *id); + LOG_RPC_DETAIL("Dropping session with address %s", id->toString().c_str()); std::lock_guard<std::mutex> _l(mLock); auto it = mSessions.find(*id); - LOG_ALWAYS_FATAL_IF(it == mSessions.end(), "Bad state, unknown session id %d", *id); - LOG_ALWAYS_FATAL_IF(it->second != session, "Bad state, session has id mismatch %d", *id); + LOG_ALWAYS_FATAL_IF(it == mSessions.end(), "Bad state, unknown session id %s", + id->toString().c_str()); + LOG_ALWAYS_FATAL_IF(it->second != session, "Bad state, session has id mismatch %s", + id->toString().c_str()); (void)mSessions.erase(it); } +void RpcServer::onSessionIncomingThreadEnded() { + mShutdownCv.notify_all(); +} + bool RpcServer::hasServer() { LOG_ALWAYS_FATAL_IF(!mAgreedExperimental, "no!"); std::lock_guard<std::mutex> _l(mLock); diff --git a/libs/binder/RpcSession.cpp b/libs/binder/RpcSession.cpp index 05fa49ec76..4f55eef2d1 100644 --- a/libs/binder/RpcSession.cpp +++ b/libs/binder/RpcSession.cpp @@ -19,10 +19,12 @@ #include <binder/RpcSession.h> #include <inttypes.h> +#include <poll.h> #include <unistd.h> #include <string_view> +#include <android-base/macros.h> #include <binder/Parcel.h> #include <binder/RpcServer.h> #include <binder/Stability.h> @@ -49,7 +51,7 @@ RpcSession::~RpcSession() { LOG_RPC_DETAIL("RpcSession destroyed %p", this); std::lock_guard<std::mutex> _l(mMutex); - LOG_ALWAYS_FATAL_IF(mServerConnections.size() != 0, + LOG_ALWAYS_FATAL_IF(mIncomingConnections.size() != 0, "Should not be able to destroy a session with servers in use."); } @@ -57,6 +59,20 @@ sp<RpcSession> RpcSession::make() { return sp<RpcSession>::make(); } +void RpcSession::setMaxThreads(size_t threads) { + std::lock_guard<std::mutex> _l(mMutex); + LOG_ALWAYS_FATAL_IF(!mOutgoingConnections.empty() || !mIncomingConnections.empty(), + "Must set max threads before setting up connections, but has %zu client(s) " + "and %zu server(s)", + mOutgoingConnections.size(), mIncomingConnections.size()); + mMaxThreads = threads; +} + +size_t RpcSession::getMaxThreads() { + std::lock_guard<std::mutex> _l(mMutex); + return mMaxThreads; +} + bool RpcSession::setupUnixDomainClient(const char* path) { return setupSocketClient(UnixSocketAddress(path)); } @@ -84,33 +100,116 @@ bool RpcSession::addNullDebuggingClient() { return false; } - addClientConnection(std::move(serverFd)); - return true; + return addOutgoingConnection(std::move(serverFd), false); } sp<IBinder> RpcSession::getRootObject() { - ExclusiveConnection connection(sp<RpcSession>::fromExisting(this), ConnectionUse::CLIENT); - return state()->getRootObject(connection.fd(), sp<RpcSession>::fromExisting(this)); + ExclusiveConnection connection; + status_t status = ExclusiveConnection::find(sp<RpcSession>::fromExisting(this), + ConnectionUse::CLIENT, &connection); + if (status != OK) return nullptr; + return state()->getRootObject(connection.get(), sp<RpcSession>::fromExisting(this)); } status_t RpcSession::getRemoteMaxThreads(size_t* maxThreads) { - ExclusiveConnection connection(sp<RpcSession>::fromExisting(this), ConnectionUse::CLIENT); - return state()->getMaxThreads(connection.fd(), sp<RpcSession>::fromExisting(this), maxThreads); + ExclusiveConnection connection; + status_t status = ExclusiveConnection::find(sp<RpcSession>::fromExisting(this), + ConnectionUse::CLIENT, &connection); + if (status != OK) return status; + return state()->getMaxThreads(connection.get(), sp<RpcSession>::fromExisting(this), maxThreads); +} + +bool RpcSession::shutdownAndWait(bool wait) { + std::unique_lock<std::mutex> _l(mMutex); + LOG_ALWAYS_FATAL_IF(mShutdownTrigger == nullptr, "Shutdown trigger not installed"); + + mShutdownTrigger->trigger(); + + if (wait) { + LOG_ALWAYS_FATAL_IF(mShutdownListener == nullptr, "Shutdown listener not installed"); + mShutdownListener->waitForShutdown(_l); + LOG_ALWAYS_FATAL_IF(!mThreads.empty(), "Shutdown failed"); + } + + _l.unlock(); + mState->clear(); + + return true; } -status_t RpcSession::transact(const RpcAddress& address, uint32_t code, const Parcel& data, +status_t RpcSession::transact(const sp<IBinder>& binder, uint32_t code, const Parcel& data, Parcel* reply, uint32_t flags) { - ExclusiveConnection connection(sp<RpcSession>::fromExisting(this), - (flags & IBinder::FLAG_ONEWAY) ? ConnectionUse::CLIENT_ASYNC - : ConnectionUse::CLIENT); - return state()->transact(connection.fd(), address, code, data, + ExclusiveConnection connection; + status_t status = + ExclusiveConnection::find(sp<RpcSession>::fromExisting(this), + (flags & IBinder::FLAG_ONEWAY) ? ConnectionUse::CLIENT_ASYNC + : ConnectionUse::CLIENT, + &connection); + if (status != OK) return status; + return state()->transact(connection.get(), binder, code, data, sp<RpcSession>::fromExisting(this), reply, flags); } status_t RpcSession::sendDecStrong(const RpcAddress& address) { - ExclusiveConnection connection(sp<RpcSession>::fromExisting(this), - ConnectionUse::CLIENT_REFCOUNT); - return state()->sendDecStrong(connection.fd(), address); + ExclusiveConnection connection; + status_t status = ExclusiveConnection::find(sp<RpcSession>::fromExisting(this), + ConnectionUse::CLIENT_REFCOUNT, &connection); + if (status != OK) return status; + return state()->sendDecStrong(connection.get(), sp<RpcSession>::fromExisting(this), address); +} + +std::unique_ptr<RpcSession::FdTrigger> RpcSession::FdTrigger::make() { + auto ret = std::make_unique<RpcSession::FdTrigger>(); + if (!android::base::Pipe(&ret->mRead, &ret->mWrite)) { + ALOGE("Could not create pipe %s", strerror(errno)); + return nullptr; + } + return ret; +} + +void RpcSession::FdTrigger::trigger() { + mWrite.reset(); +} + +bool RpcSession::FdTrigger::isTriggered() { + return mWrite == -1; +} + +status_t RpcSession::FdTrigger::triggerablePollRead(base::borrowed_fd fd) { + while (true) { + pollfd pfd[]{{.fd = fd.get(), .events = POLLIN | POLLHUP, .revents = 0}, + {.fd = mRead.get(), .events = POLLHUP, .revents = 0}}; + int ret = TEMP_FAILURE_RETRY(poll(pfd, arraysize(pfd), -1)); + if (ret < 0) { + return -errno; + } + if (ret == 0) { + continue; + } + if (pfd[1].revents & POLLHUP) { + return -ECANCELED; + } + return pfd[0].revents & POLLIN ? OK : DEAD_OBJECT; + } +} + +status_t RpcSession::FdTrigger::interruptableReadFully(base::borrowed_fd fd, void* data, + size_t size) { + uint8_t* buffer = reinterpret_cast<uint8_t*>(data); + uint8_t* end = buffer + size; + + status_t status; + while ((status = triggerablePollRead(fd)) == OK) { + ssize_t readSize = TEMP_FAILURE_RETRY(recv(fd.get(), buffer, end - buffer, MSG_NOSIGNAL)); + if (readSize == 0) return DEAD_OBJECT; // EOF + + if (readSize < 0) { + return -errno; + } + buffer += readSize; + if (buffer == end) return OK; + } + return status; } status_t RpcSession::readId() { @@ -119,19 +218,39 @@ status_t RpcSession::readId() { LOG_ALWAYS_FATAL_IF(mForServer != nullptr, "Can only update ID for client."); } - int32_t id; + ExclusiveConnection connection; + status_t status = ExclusiveConnection::find(sp<RpcSession>::fromExisting(this), + ConnectionUse::CLIENT, &connection); + if (status != OK) return status; - ExclusiveConnection connection(sp<RpcSession>::fromExisting(this), ConnectionUse::CLIENT); - status_t status = - state()->getSessionId(connection.fd(), sp<RpcSession>::fromExisting(this), &id); + mId = RpcAddress::zero(); + status = state()->getSessionId(connection.get(), sp<RpcSession>::fromExisting(this), + &mId.value()); if (status != OK) return status; - LOG_RPC_DETAIL("RpcSession %p has id %d", this, id); - mId = id; + LOG_RPC_DETAIL("RpcSession %p has id %s", this, mId->toString().c_str()); return OK; } -void RpcSession::preJoin(std::thread thread) { +void RpcSession::WaitForShutdownListener::onSessionLockedAllIncomingThreadsEnded( + const sp<RpcSession>& session) { + (void)session; + mShutdown = true; +} + +void RpcSession::WaitForShutdownListener::onSessionIncomingThreadEnded() { + mCv.notify_all(); +} + +void RpcSession::WaitForShutdownListener::waitForShutdown(std::unique_lock<std::mutex>& lock) { + while (!mShutdown) { + if (std::cv_status::timeout == mCv.wait_for(lock, std::chrono::seconds(1))) { + ALOGE("Waiting for RpcSession to shut down (1s w/o progress)."); + } + } +} + +void RpcSession::preJoinThreadOwnership(std::thread thread) { LOG_ALWAYS_FATAL_IF(thread.get_id() != std::this_thread::get_id(), "Must own this thread"); { @@ -140,64 +259,78 @@ void RpcSession::preJoin(std::thread thread) { } } -void RpcSession::join(unique_fd client) { +RpcSession::PreJoinSetupResult RpcSession::preJoinSetup(base::unique_fd fd) { // must be registered to allow arbitrary client code executing commands to // be able to do nested calls (we can't only read from it) - sp<RpcConnection> connection = assignServerToThisThread(std::move(client)); + sp<RpcConnection> connection = assignIncomingConnectionToThisThread(std::move(fd)); - while (true) { - status_t error = - state()->getAndExecuteCommand(connection->fd, sp<RpcSession>::fromExisting(this)); + status_t status = mState->readConnectionInit(connection, sp<RpcSession>::fromExisting(this)); - if (error != OK) { - ALOGI("Binder connection thread closing w/ status %s", statusToString(error).c_str()); - break; + return PreJoinSetupResult{ + .connection = std::move(connection), + .status = status, + }; +} + +void RpcSession::join(sp<RpcSession>&& session, PreJoinSetupResult&& setupResult) { + sp<RpcConnection>& connection = setupResult.connection; + + if (setupResult.status == OK) { + while (true) { + status_t status = session->state()->getAndExecuteCommand(connection, session, + RpcState::CommandType::ANY); + if (status != OK) { + LOG_RPC_DETAIL("Binder connection thread closing w/ status %s", + statusToString(status).c_str()); + break; + } } + } else { + ALOGE("Connection failed to init, closing with status %s", + statusToString(setupResult.status).c_str()); } - LOG_ALWAYS_FATAL_IF(!removeServerConnection(connection), + LOG_ALWAYS_FATAL_IF(!session->removeIncomingConnection(connection), "bad state: connection object guaranteed to be in list"); + sp<RpcSession::EventListener> listener; { - std::lock_guard<std::mutex> _l(mMutex); - auto it = mThreads.find(std::this_thread::get_id()); - LOG_ALWAYS_FATAL_IF(it == mThreads.end()); + std::lock_guard<std::mutex> _l(session->mMutex); + auto it = session->mThreads.find(std::this_thread::get_id()); + LOG_ALWAYS_FATAL_IF(it == session->mThreads.end()); it->second.detach(); - mThreads.erase(it); - } -} + session->mThreads.erase(it); -void RpcSession::terminateLocked() { - // TODO(b/185167543): - // - kindly notify other side of the connection of termination (can't be - // locked) - // - prevent new client/servers from being added - // - stop all threads which are currently reading/writing - // - terminate RpcState? + listener = session->mEventListener.promote(); + } - if (mTerminated) return; + session = nullptr; - sp<RpcServer> server = mForServer.promote(); - if (server) { - server->onSessionTerminating(sp<RpcSession>::fromExisting(this)); + if (listener != nullptr) { + listener->onSessionIncomingThreadEnded(); } } -wp<RpcServer> RpcSession::server() { - return mForServer; +sp<RpcServer> RpcSession::server() { + RpcServer* unsafeServer = mForServer.unsafe_get(); + sp<RpcServer> server = mForServer.promote(); + + LOG_ALWAYS_FATAL_IF((unsafeServer == nullptr) != (server == nullptr), + "wp<> is to avoid strong cycle only"); + return server; } bool RpcSession::setupSocketClient(const RpcSocketAddress& addr) { { std::lock_guard<std::mutex> _l(mMutex); - LOG_ALWAYS_FATAL_IF(mClientConnections.size() != 0, + LOG_ALWAYS_FATAL_IF(mOutgoingConnections.size() != 0, "Must only setup session once, but already has %zu clients", - mClientConnections.size()); + mOutgoingConnections.size()); } - if (!setupOneSocketClient(addr, RPC_SESSION_ID_NEW)) return false; + if (!setupOneSocketConnection(addr, RpcAddress::zero(), false /*reverse*/)) return false; - // TODO(b/185167543): we should add additional sessions dynamically + // TODO(b/189955605): we should add additional sessions dynamically // instead of all at once. // TODO(b/186470974): first risk of blocking size_t numThreadsAvailable; @@ -215,14 +348,25 @@ bool RpcSession::setupSocketClient(const RpcSocketAddress& addr) { // we've already setup one client for (size_t i = 0; i + 1 < numThreadsAvailable; i++) { - // TODO(b/185167543): shutdown existing connections? - if (!setupOneSocketClient(addr, mId.value())) return false; + // TODO(b/189955605): shutdown existing connections? + if (!setupOneSocketConnection(addr, mId.value(), false /*reverse*/)) return false; + } + + // TODO(b/189955605): we should add additional sessions dynamically + // instead of all at once - the other side should be responsible for setting + // up additional connections. We need to create at least one (unless 0 are + // requested to be set) in order to allow the other side to reliably make + // any requests at all. + + for (size_t i = 0; i < mMaxThreads; i++) { + if (!setupOneSocketConnection(addr, mId.value(), true /*reverse*/)) return false; } return true; } -bool RpcSession::setupOneSocketClient(const RpcSocketAddress& addr, int32_t id) { +bool RpcSession::setupOneSocketConnection(const RpcSocketAddress& addr, const RpcAddress& id, + bool reverse) { for (size_t tries = 0; tries < 5; tries++) { if (tries > 0) usleep(10000); @@ -246,77 +390,153 @@ bool RpcSession::setupOneSocketClient(const RpcSocketAddress& addr, int32_t id) return false; } - if (sizeof(id) != TEMP_FAILURE_RETRY(write(serverFd.get(), &id, sizeof(id)))) { + RpcConnectionHeader header{.options = 0}; + memcpy(&header.sessionId, &id.viewRawEmbedded(), sizeof(RpcWireAddress)); + + if (reverse) header.options |= RPC_CONNECTION_OPTION_REVERSE; + + if (sizeof(header) != TEMP_FAILURE_RETRY(write(serverFd.get(), &header, sizeof(header)))) { int savedErrno = errno; - ALOGE("Could not write id to socket at %s: %s", addr.toString().c_str(), + ALOGE("Could not write connection header to socket at %s: %s", addr.toString().c_str(), strerror(savedErrno)); return false; } LOG_RPC_DETAIL("Socket at %s client with fd %d", addr.toString().c_str(), serverFd.get()); - addClientConnection(std::move(serverFd)); - return true; + if (reverse) { + std::mutex mutex; + std::condition_variable joinCv; + std::unique_lock<std::mutex> lock(mutex); + std::thread thread; + sp<RpcSession> thiz = sp<RpcSession>::fromExisting(this); + bool ownershipTransferred = false; + thread = std::thread([&]() { + std::unique_lock<std::mutex> threadLock(mutex); + unique_fd fd = std::move(serverFd); + // NOLINTNEXTLINE(performance-unnecessary-copy-initialization) + sp<RpcSession> session = thiz; + session->preJoinThreadOwnership(std::move(thread)); + + // only continue once we have a response or the connection fails + auto setupResult = session->preJoinSetup(std::move(fd)); + + ownershipTransferred = true; + threadLock.unlock(); + joinCv.notify_one(); + // do not use & vars below + + RpcSession::join(std::move(session), std::move(setupResult)); + }); + joinCv.wait(lock, [&] { return ownershipTransferred; }); + LOG_ALWAYS_FATAL_IF(!ownershipTransferred); + return true; + } else { + return addOutgoingConnection(std::move(serverFd), true); + } } ALOGE("Ran out of retries to connect to %s", addr.toString().c_str()); return false; } -void RpcSession::addClientConnection(unique_fd fd) { - std::lock_guard<std::mutex> _l(mMutex); - sp<RpcConnection> session = sp<RpcConnection>::make(); - session->fd = std::move(fd); - mClientConnections.push_back(session); +bool RpcSession::addOutgoingConnection(unique_fd fd, bool init) { + sp<RpcConnection> connection = sp<RpcConnection>::make(); + { + std::lock_guard<std::mutex> _l(mMutex); + + // first client connection added, but setForServer not called, so + // initializaing for a client. + if (mShutdownTrigger == nullptr) { + mShutdownTrigger = FdTrigger::make(); + mEventListener = mShutdownListener = sp<WaitForShutdownListener>::make(); + if (mShutdownTrigger == nullptr) return false; + } + + connection->fd = std::move(fd); + connection->exclusiveTid = gettid(); + mOutgoingConnections.push_back(connection); + } + + status_t status = OK; + if (init) { + mState->sendConnectionInit(connection, sp<RpcSession>::fromExisting(this)); + } + + { + std::lock_guard<std::mutex> _l(mMutex); + connection->exclusiveTid = std::nullopt; + } + + return status == OK; } -void RpcSession::setForServer(const wp<RpcServer>& server, int32_t sessionId) { +bool RpcSession::setForServer(const wp<RpcServer>& server, const wp<EventListener>& eventListener, + const RpcAddress& sessionId) { + LOG_ALWAYS_FATAL_IF(mForServer != nullptr); + LOG_ALWAYS_FATAL_IF(server == nullptr); + LOG_ALWAYS_FATAL_IF(mEventListener != nullptr); + LOG_ALWAYS_FATAL_IF(eventListener == nullptr); + LOG_ALWAYS_FATAL_IF(mShutdownTrigger != nullptr); + + mShutdownTrigger = FdTrigger::make(); + if (mShutdownTrigger == nullptr) return false; + mId = sessionId; mForServer = server; + mEventListener = eventListener; + return true; } -sp<RpcSession::RpcConnection> RpcSession::assignServerToThisThread(unique_fd fd) { +sp<RpcSession::RpcConnection> RpcSession::assignIncomingConnectionToThisThread(unique_fd fd) { std::lock_guard<std::mutex> _l(mMutex); sp<RpcConnection> session = sp<RpcConnection>::make(); session->fd = std::move(fd); session->exclusiveTid = gettid(); - mServerConnections.push_back(session); + mIncomingConnections.push_back(session); return session; } -bool RpcSession::removeServerConnection(const sp<RpcConnection>& connection) { +bool RpcSession::removeIncomingConnection(const sp<RpcConnection>& connection) { std::lock_guard<std::mutex> _l(mMutex); - if (auto it = std::find(mServerConnections.begin(), mServerConnections.end(), connection); - it != mServerConnections.end()) { - mServerConnections.erase(it); - if (mServerConnections.size() == 0) { - terminateLocked(); + if (auto it = std::find(mIncomingConnections.begin(), mIncomingConnections.end(), connection); + it != mIncomingConnections.end()) { + mIncomingConnections.erase(it); + if (mIncomingConnections.size() == 0) { + sp<EventListener> listener = mEventListener.promote(); + if (listener) { + listener->onSessionLockedAllIncomingThreadsEnded( + sp<RpcSession>::fromExisting(this)); + } } return true; } return false; } -RpcSession::ExclusiveConnection::ExclusiveConnection(const sp<RpcSession>& session, - ConnectionUse use) - : mSession(session) { +status_t RpcSession::ExclusiveConnection::find(const sp<RpcSession>& session, ConnectionUse use, + ExclusiveConnection* connection) { + connection->mSession = session; + connection->mConnection = nullptr; + connection->mReentrant = false; + pid_t tid = gettid(); - std::unique_lock<std::mutex> _l(mSession->mMutex); + std::unique_lock<std::mutex> _l(session->mMutex); - mSession->mWaitingThreads++; + session->mWaitingThreads++; while (true) { sp<RpcConnection> exclusive; sp<RpcConnection> available; // CHECK FOR DEDICATED CLIENT SOCKET // - // A server/looper should always use a dedicated session if available - findConnection(tid, &exclusive, &available, mSession->mClientConnections, - mSession->mClientConnectionsOffset); + // A server/looper should always use a dedicated connection if available + findConnection(tid, &exclusive, &available, session->mOutgoingConnections, + session->mOutgoingConnectionsOffset); // WARNING: this assumes a server cannot request its client to send - // a transaction, as mServerConnections is excluded below. + // a transaction, as mIncomingConnections is excluded below. // // Imagine we have more than one thread in play, and a single thread // sends a synchronous, then an asynchronous command. Imagine the @@ -326,41 +546,59 @@ RpcSession::ExclusiveConnection::ExclusiveConnection(const sp<RpcSession>& sessi // command. So, we move to considering the second available thread // for subsequent calls. if (use == ConnectionUse::CLIENT_ASYNC && (exclusive != nullptr || available != nullptr)) { - mSession->mClientConnectionsOffset = - (mSession->mClientConnectionsOffset + 1) % mSession->mClientConnections.size(); + session->mOutgoingConnectionsOffset = (session->mOutgoingConnectionsOffset + 1) % + session->mOutgoingConnections.size(); } - // USE SERVING SOCKET (for nested transaction) - // - // asynchronous calls cannot be nested + // USE SERVING SOCKET (e.g. nested transaction) if (use != ConnectionUse::CLIENT_ASYNC) { + sp<RpcConnection> exclusiveIncoming; // server connections are always assigned to a thread - findConnection(tid, &exclusive, nullptr /*available*/, mSession->mServerConnections, - 0 /* index hint */); + findConnection(tid, &exclusiveIncoming, nullptr /*available*/, + session->mIncomingConnections, 0 /* index hint */); + + // asynchronous calls cannot be nested, we currently allow ref count + // calls to be nested (so that you can use this without having extra + // threads). Note 'drainCommands' is used so that these ref counts can't + // build up. + if (exclusiveIncoming != nullptr) { + if (exclusiveIncoming->allowNested) { + // guaranteed to be processed as nested command + exclusive = exclusiveIncoming; + } else if (use == ConnectionUse::CLIENT_REFCOUNT && available == nullptr) { + // prefer available socket, but if we don't have one, don't + // wait for one + exclusive = exclusiveIncoming; + } + } } - // if our thread is already using a session, prioritize using that + // if our thread is already using a connection, prioritize using that if (exclusive != nullptr) { - mConnection = exclusive; - mReentrant = true; + connection->mConnection = exclusive; + connection->mReentrant = true; break; } else if (available != nullptr) { - mConnection = available; - mConnection->exclusiveTid = tid; + connection->mConnection = available; + connection->mConnection->exclusiveTid = tid; break; } - // in regular binder, this would usually be a deadlock :) - LOG_ALWAYS_FATAL_IF(mSession->mClientConnections.size() == 0, - "Not a client of any session. You must create a session to an " - "RPC server to make any non-nested (e.g. oneway or on another thread) " - "calls."); + if (session->mOutgoingConnections.size() == 0) { + ALOGE("Session has no client connections. This is required for an RPC server to make " + "any non-nested (e.g. oneway or on another thread) calls. Use: %d. Server " + "connections: %zu", + static_cast<int>(use), session->mIncomingConnections.size()); + return WOULD_BLOCK; + } - LOG_RPC_DETAIL("No available session (have %zu clients and %zu servers). Waiting...", - mSession->mClientConnections.size(), mSession->mServerConnections.size()); - mSession->mAvailableConnectionCv.wait(_l); + LOG_RPC_DETAIL("No available connections (have %zu clients and %zu servers). Waiting...", + session->mOutgoingConnections.size(), session->mIncomingConnections.size()); + session->mAvailableConnectionCv.wait(_l); } - mSession->mWaitingThreads--; + session->mWaitingThreads--; + + return OK; } void RpcSession::ExclusiveConnection::findConnection(pid_t tid, sp<RpcConnection>* exclusive, @@ -375,13 +613,13 @@ void RpcSession::ExclusiveConnection::findConnection(pid_t tid, sp<RpcConnection for (size_t i = 0; i < sockets.size(); i++) { sp<RpcConnection>& socket = sockets[(i + socketsIndexHint) % sockets.size()]; - // take first available session (intuition = caching) + // take first available connection (intuition = caching) if (available && *available == nullptr && socket->exclusiveTid == std::nullopt) { *available = socket; continue; } - // though, prefer to take session which is already inuse by this thread + // though, prefer to take connection which is already inuse by this thread // (nested transactions) if (exclusive && socket->exclusiveTid == tid) { *exclusive = socket; @@ -391,10 +629,10 @@ void RpcSession::ExclusiveConnection::findConnection(pid_t tid, sp<RpcConnection } RpcSession::ExclusiveConnection::~ExclusiveConnection() { - // reentrant use of a session means something less deep in the call stack + // reentrant use of a connection means something less deep in the call stack // is using this fd, and it retains the right to it. So, we don't give up // exclusive ownership, and no thread is freed. - if (!mReentrant) { + if (!mReentrant && mConnection != nullptr) { std::unique_lock<std::mutex> _l(mSession->mMutex); mConnection->exclusiveTid = std::nullopt; if (mSession->mWaitingThreads > 0) { diff --git a/libs/binder/RpcState.cpp b/libs/binder/RpcState.cpp index 2ba9fa2bd5..fd2eff6870 100644 --- a/libs/binder/RpcState.cpp +++ b/libs/binder/RpcState.cpp @@ -18,7 +18,9 @@ #include "RpcState.h" +#include <android-base/scopeguard.h> #include <binder/BpBinder.h> +#include <binder/IPCThreadState.h> #include <binder/RpcServer.h> #include "Debug.h" @@ -28,6 +30,8 @@ namespace android { +using base::ScopeGuard; + RpcState::RpcState() {} RpcState::~RpcState() {} @@ -57,6 +61,7 @@ status_t RpcState::onBinderLeaving(const sp<RpcSession>& session, const sp<IBind } std::lock_guard<std::mutex> _l(mNodeMutex); + if (mTerminated) return DEAD_OBJECT; // TODO(b/182939933): maybe move address out of BpBinder, and keep binder->address map // in RpcState @@ -78,24 +83,50 @@ status_t RpcState::onBinderLeaving(const sp<RpcSession>& session, const sp<IBind } LOG_ALWAYS_FATAL_IF(isRpc, "RPC binder must have known address at this point"); - auto&& [it, inserted] = mNodeForAddress.insert({RpcAddress::unique(), - BinderNode{ - .binder = binder, - .timesSent = 1, - .sentRef = binder, - }}); - // TODO(b/182939933): better organization could avoid needing this log - LOG_ALWAYS_FATAL_IF(!inserted); + bool forServer = session->server() != nullptr; + + for (size_t tries = 0; tries < 5; tries++) { + auto&& [it, inserted] = mNodeForAddress.insert({RpcAddress::random(forServer), + BinderNode{ + .binder = binder, + .timesSent = 1, + .sentRef = binder, + }}); + if (inserted) { + *outAddress = it->first; + return OK; + } - *outAddress = it->first; - return OK; + // well, we don't have visibility into the header here, but still + static_assert(sizeof(RpcWireAddress) == 40, "this log needs updating"); + ALOGW("2**256 is 1e77. If you see this log, you probably have some entropy issue, or maybe " + "you witness something incredible!"); + } + + ALOGE("Unable to create an address in order to send out %p", binder.get()); + return WOULD_BLOCK; } -sp<IBinder> RpcState::onBinderEntering(const sp<RpcSession>& session, const RpcAddress& address) { +status_t RpcState::onBinderEntering(const sp<RpcSession>& session, const RpcAddress& address, + sp<IBinder>* out) { + // ensure that: if we want to use addresses for something else in the future (for + // instance, allowing transitive binder sends), that we don't accidentally + // send those addresses to old server. Accidentally ignoring this in that + // case and considering the binder to be recognized could cause this + // process to accidentally proxy transactions for that binder. Of course, + // if we communicate with a binder, it could always be proxying + // information. However, we want to make sure that isn't done on accident + // by a client. + if (!address.isRecognizedType()) { + ALOGE("Address is of an unknown type, rejecting: %s", address.toString().c_str()); + return BAD_VALUE; + } + std::unique_lock<std::mutex> _l(mNodeMutex); + if (mTerminated) return DEAD_OBJECT; if (auto it = mNodeForAddress.find(address); it != mNodeForAddress.end()) { - sp<IBinder> binder = it->second.binder.promote(); + *out = it->second.binder.promote(); // implicitly have strong RPC refcount, since we received this binder it->second.timesRecd++; @@ -107,7 +138,15 @@ sp<IBinder> RpcState::onBinderEntering(const sp<RpcSession>& session, const RpcA // immediately, we wait to send the last one in BpBinder::onLastDecStrong. (void)session->sendDecStrong(address); - return binder; + return OK; + } + + // we don't know about this binder, so the other side of the connection + // should have created it. + if (address.isForServer() == !!session->server()) { + ALOGE("Server received unrecognized address which we should own the creation of %s.", + address.toString().c_str()); + return BAD_VALUE; } auto&& [it, inserted] = mNodeForAddress.insert({address, BinderNode{}}); @@ -115,10 +154,9 @@ sp<IBinder> RpcState::onBinderEntering(const sp<RpcSession>& session, const RpcA // Currently, all binders are assumed to be part of the same session (no // device global binders in the RPC world). - sp<IBinder> binder = BpBinder::create(session, it->first); - it->second.binder = binder; + it->second.binder = *out = BpBinder::create(session, it->first); it->second.timesRecd = 1; - return binder; + return OK; } size_t RpcState::countBinders() { @@ -128,6 +166,45 @@ size_t RpcState::countBinders() { void RpcState::dump() { std::lock_guard<std::mutex> _l(mNodeMutex); + dumpLocked(); +} + +void RpcState::clear() { + std::unique_lock<std::mutex> _l(mNodeMutex); + + if (mTerminated) { + LOG_ALWAYS_FATAL_IF(!mNodeForAddress.empty(), + "New state should be impossible after terminating!"); + return; + } + + if (SHOULD_LOG_RPC_DETAIL) { + ALOGE("RpcState::clear()"); + dumpLocked(); + } + + // if the destructor of a binder object makes another RPC call, then calling + // decStrong could deadlock. So, we must hold onto these binders until + // mNodeMutex is no longer taken. + std::vector<sp<IBinder>> tempHoldBinder; + + mTerminated = true; + for (auto& [address, node] : mNodeForAddress) { + sp<IBinder> binder = node.binder.promote(); + LOG_ALWAYS_FATAL_IF(binder == nullptr, "Binder %p expected to be owned.", binder.get()); + + if (node.sentRef != nullptr) { + tempHoldBinder.push_back(node.sentRef); + } + } + + mNodeForAddress.clear(); + + _l.unlock(); + tempHoldBinder.clear(); // explicit +} + +void RpcState::dumpLocked() { ALOGE("DUMP OF RpcState %p", this); ALOGE("DUMP OF RpcState (%zu nodes)", mNodeForAddress.size()); for (const auto& [address, node] : mNodeForAddress) { @@ -155,32 +232,6 @@ void RpcState::dump() { ALOGE("END DUMP OF RpcState"); } -void RpcState::terminate() { - if (SHOULD_LOG_RPC_DETAIL) { - ALOGE("RpcState::terminate()"); - dump(); - } - - // if the destructor of a binder object makes another RPC call, then calling - // decStrong could deadlock. So, we must hold onto these binders until - // mNodeMutex is no longer taken. - std::vector<sp<IBinder>> tempHoldBinder; - - { - std::lock_guard<std::mutex> _l(mNodeMutex); - mTerminated = true; - for (auto& [address, node] : mNodeForAddress) { - sp<IBinder> binder = node.binder.promote(); - LOG_ALWAYS_FATAL_IF(binder == nullptr, "Binder %p expected to be owned.", binder.get()); - - if (node.sentRef != nullptr) { - tempHoldBinder.push_back(node.sentRef); - } - } - - mNodeForAddress.clear(); - } -} RpcState::CommandData::CommandData(size_t size) : mSize(size) { // The maximum size for regular binder is 1MB for all concurrent @@ -203,62 +254,86 @@ RpcState::CommandData::CommandData(size_t size) : mSize(size) { mData.reset(new (std::nothrow) uint8_t[size]); } -bool RpcState::rpcSend(const base::unique_fd& fd, const char* what, const void* data, size_t size) { - LOG_RPC_DETAIL("Sending %s on fd %d: %s", what, fd.get(), hexString(data, size).c_str()); +status_t RpcState::rpcSend(const sp<RpcSession::RpcConnection>& connection, + const sp<RpcSession>& session, const char* what, const void* data, + size_t size) { + LOG_RPC_DETAIL("Sending %s on fd %d: %s", what, connection->fd.get(), + hexString(data, size).c_str()); if (size > std::numeric_limits<ssize_t>::max()) { ALOGE("Cannot send %s at size %zu (too big)", what, size); - terminate(); - return false; + (void)session->shutdownAndWait(false); + return BAD_VALUE; } - ssize_t sent = TEMP_FAILURE_RETRY(send(fd.get(), data, size, MSG_NOSIGNAL)); + ssize_t sent = TEMP_FAILURE_RETRY(send(connection->fd.get(), data, size, MSG_NOSIGNAL)); if (sent < 0 || sent != static_cast<ssize_t>(size)) { - ALOGE("Failed to send %s (sent %zd of %zu bytes) on fd %d, error: %s", what, sent, size, - fd.get(), strerror(errno)); + int savedErrno = errno; + LOG_RPC_DETAIL("Failed to send %s (sent %zd of %zu bytes) on fd %d, error: %s", what, sent, + size, connection->fd.get(), strerror(savedErrno)); - terminate(); - return false; + (void)session->shutdownAndWait(false); + return -savedErrno; } - return true; + return OK; } -bool RpcState::rpcRec(const base::unique_fd& fd, const char* what, void* data, size_t size) { +status_t RpcState::rpcRec(const sp<RpcSession::RpcConnection>& connection, + const sp<RpcSession>& session, const char* what, void* data, + size_t size) { if (size > std::numeric_limits<ssize_t>::max()) { ALOGE("Cannot rec %s at size %zu (too big)", what, size); - terminate(); - return false; + (void)session->shutdownAndWait(false); + return BAD_VALUE; } - ssize_t recd = TEMP_FAILURE_RETRY(recv(fd.get(), data, size, MSG_WAITALL | MSG_NOSIGNAL)); + if (status_t status = + session->mShutdownTrigger->interruptableReadFully(connection->fd.get(), data, size); + status != OK) { + LOG_RPC_DETAIL("Failed to read %s (%zu bytes) on fd %d, error: %s", what, size, + connection->fd.get(), statusToString(status).c_str()); + return status; + } - if (recd < 0 || recd != static_cast<ssize_t>(size)) { - terminate(); + LOG_RPC_DETAIL("Received %s on fd %d: %s", what, connection->fd.get(), + hexString(data, size).c_str()); + return OK; +} - if (recd == 0 && errno == 0) { - LOG_RPC_DETAIL("No more data when trying to read %s on fd %d", what, fd.get()); - return false; - } +status_t RpcState::sendConnectionInit(const sp<RpcSession::RpcConnection>& connection, + const sp<RpcSession>& session) { + RpcOutgoingConnectionInit init{ + .msg = RPC_CONNECTION_INIT_OKAY, + }; + return rpcSend(connection, session, "connection init", &init, sizeof(init)); +} - ALOGE("Failed to read %s (received %zd of %zu bytes) on fd %d, error: %s", what, recd, size, - fd.get(), strerror(errno)); - return false; - } else { - LOG_RPC_DETAIL("Received %s on fd %d: %s", what, fd.get(), hexString(data, size).c_str()); - } +status_t RpcState::readConnectionInit(const sp<RpcSession::RpcConnection>& connection, + const sp<RpcSession>& session) { + RpcOutgoingConnectionInit init; + if (status_t status = rpcRec(connection, session, "connection init", &init, sizeof(init)); + status != OK) + return status; - return true; + static_assert(sizeof(init.msg) == sizeof(RPC_CONNECTION_INIT_OKAY)); + if (0 != strncmp(init.msg, RPC_CONNECTION_INIT_OKAY, sizeof(init.msg))) { + ALOGE("Connection init message unrecognized %.*s", static_cast<int>(sizeof(init.msg)), + init.msg); + return BAD_VALUE; + } + return OK; } -sp<IBinder> RpcState::getRootObject(const base::unique_fd& fd, const sp<RpcSession>& session) { +sp<IBinder> RpcState::getRootObject(const sp<RpcSession::RpcConnection>& connection, + const sp<RpcSession>& session) { Parcel data; data.markForRpc(session); Parcel reply; - status_t status = transact(fd, RpcAddress::zero(), RPC_SPECIAL_TRANSACT_GET_ROOT, data, session, - &reply, 0); + status_t status = transactAddress(connection, RpcAddress::zero(), RPC_SPECIAL_TRANSACT_GET_ROOT, + data, session, &reply, 0); if (status != OK) { ALOGE("Error getting root object: %s", statusToString(status).c_str()); return nullptr; @@ -267,14 +342,15 @@ sp<IBinder> RpcState::getRootObject(const base::unique_fd& fd, const sp<RpcSessi return reply.readStrongBinder(); } -status_t RpcState::getMaxThreads(const base::unique_fd& fd, const sp<RpcSession>& session, - size_t* maxThreadsOut) { +status_t RpcState::getMaxThreads(const sp<RpcSession::RpcConnection>& connection, + const sp<RpcSession>& session, size_t* maxThreadsOut) { Parcel data; data.markForRpc(session); Parcel reply; - status_t status = transact(fd, RpcAddress::zero(), RPC_SPECIAL_TRANSACT_GET_MAX_THREADS, data, - session, &reply, 0); + status_t status = + transactAddress(connection, RpcAddress::zero(), RPC_SPECIAL_TRANSACT_GET_MAX_THREADS, + data, session, &reply, 0); if (status != OK) { ALOGE("Error getting max threads: %s", statusToString(status).c_str()); return status; @@ -292,93 +368,113 @@ status_t RpcState::getMaxThreads(const base::unique_fd& fd, const sp<RpcSession> return OK; } -status_t RpcState::getSessionId(const base::unique_fd& fd, const sp<RpcSession>& session, - int32_t* sessionIdOut) { +status_t RpcState::getSessionId(const sp<RpcSession::RpcConnection>& connection, + const sp<RpcSession>& session, RpcAddress* sessionIdOut) { Parcel data; data.markForRpc(session); Parcel reply; - status_t status = transact(fd, RpcAddress::zero(), RPC_SPECIAL_TRANSACT_GET_SESSION_ID, data, - session, &reply, 0); + status_t status = + transactAddress(connection, RpcAddress::zero(), RPC_SPECIAL_TRANSACT_GET_SESSION_ID, + data, session, &reply, 0); if (status != OK) { ALOGE("Error getting session ID: %s", statusToString(status).c_str()); return status; } - int32_t sessionId; - status = reply.readInt32(&sessionId); - if (status != OK) return status; + return sessionIdOut->readFromParcel(reply); +} - *sessionIdOut = sessionId; - return OK; +status_t RpcState::transact(const sp<RpcSession::RpcConnection>& connection, + const sp<IBinder>& binder, uint32_t code, const Parcel& data, + const sp<RpcSession>& session, Parcel* reply, uint32_t flags) { + if (!data.isForRpc()) { + ALOGE("Refusing to send RPC with parcel not crafted for RPC"); + return BAD_TYPE; + } + + if (data.objectsCount() != 0) { + ALOGE("Parcel at %p has attached objects but is being used in an RPC call", &data); + return BAD_TYPE; + } + + RpcAddress address = RpcAddress::zero(); + if (status_t status = onBinderLeaving(session, binder, &address); status != OK) return status; + + return transactAddress(connection, address, code, data, session, reply, flags); } -status_t RpcState::transact(const base::unique_fd& fd, const RpcAddress& address, uint32_t code, - const Parcel& data, const sp<RpcSession>& session, Parcel* reply, - uint32_t flags) { +status_t RpcState::transactAddress(const sp<RpcSession::RpcConnection>& connection, + const RpcAddress& address, uint32_t code, const Parcel& data, + const sp<RpcSession>& session, Parcel* reply, uint32_t flags) { + LOG_ALWAYS_FATAL_IF(!data.isForRpc()); + LOG_ALWAYS_FATAL_IF(data.objectsCount() != 0); + uint64_t asyncNumber = 0; if (!address.isZero()) { - std::lock_guard<std::mutex> _l(mNodeMutex); + std::unique_lock<std::mutex> _l(mNodeMutex); if (mTerminated) return DEAD_OBJECT; // avoid fatal only, otherwise races auto it = mNodeForAddress.find(address); LOG_ALWAYS_FATAL_IF(it == mNodeForAddress.end(), "Sending transact on unknown address %s", address.toString().c_str()); if (flags & IBinder::FLAG_ONEWAY) { - asyncNumber = it->second.asyncNumber++; + asyncNumber = it->second.asyncNumber; + if (!nodeProgressAsyncNumber(&it->second)) { + _l.unlock(); + (void)session->shutdownAndWait(false); + return DEAD_OBJECT; + } } } - if (!data.isForRpc()) { - ALOGE("Refusing to send RPC with parcel not crafted for RPC"); - return BAD_TYPE; - } - - if (data.objectsCount() != 0) { - ALOGE("Parcel at %p has attached objects but is being used in an RPC call", &data); - return BAD_TYPE; - } + LOG_ALWAYS_FATAL_IF(std::numeric_limits<int32_t>::max() - sizeof(RpcWireHeader) - + sizeof(RpcWireTransaction) < + data.dataSize(), + "Too much data %zu", data.dataSize()); + RpcWireHeader command{ + .command = RPC_COMMAND_TRANSACT, + .bodySize = static_cast<uint32_t>(sizeof(RpcWireTransaction) + data.dataSize()), + }; RpcWireTransaction transaction{ .address = address.viewRawEmbedded(), .code = code, .flags = flags, .asyncNumber = asyncNumber, }; - - CommandData transactionData(sizeof(RpcWireTransaction) + data.dataSize()); + CommandData transactionData(sizeof(RpcWireHeader) + sizeof(RpcWireTransaction) + + data.dataSize()); if (!transactionData.valid()) { return NO_MEMORY; } - memcpy(transactionData.data() + 0, &transaction, sizeof(RpcWireTransaction)); - memcpy(transactionData.data() + sizeof(RpcWireTransaction), data.data(), data.dataSize()); + memcpy(transactionData.data() + 0, &command, sizeof(RpcWireHeader)); + memcpy(transactionData.data() + sizeof(RpcWireHeader), &transaction, + sizeof(RpcWireTransaction)); + memcpy(transactionData.data() + sizeof(RpcWireHeader) + sizeof(RpcWireTransaction), data.data(), + data.dataSize()); - if (transactionData.size() > std::numeric_limits<uint32_t>::max()) { - ALOGE("Transaction size too big %zu", transactionData.size()); - return BAD_VALUE; - } - - RpcWireHeader command{ - .command = RPC_COMMAND_TRANSACT, - .bodySize = static_cast<uint32_t>(transactionData.size()), - }; - - if (!rpcSend(fd, "transact header", &command, sizeof(command))) { - return DEAD_OBJECT; - } - if (!rpcSend(fd, "command body", transactionData.data(), transactionData.size())) { - return DEAD_OBJECT; - } + if (status_t status = rpcSend(connection, session, "transaction", transactionData.data(), + transactionData.size()); + status != OK) + // TODO(b/167966510): need to undo onBinderLeaving - we know the + // refcount isn't successfully transferred. + return status; if (flags & IBinder::FLAG_ONEWAY) { - return OK; // do not wait for result + LOG_RPC_DETAIL("Oneway command, so no longer waiting on %d", connection->fd.get()); + + // Do not wait on result. + // However, too many oneway calls may cause refcounts to build up and fill up the socket, + // so process those. + return drainCommands(connection, session, CommandType::CONTROL_ONLY); } LOG_ALWAYS_FATAL_IF(reply == nullptr, "Reply parcel must be used for synchronous transaction."); - return waitForReply(fd, session, reply); + return waitForReply(connection, session, reply); } static void cleanup_reply_data(Parcel* p, const uint8_t* data, size_t dataSize, @@ -390,33 +486,33 @@ static void cleanup_reply_data(Parcel* p, const uint8_t* data, size_t dataSize, LOG_ALWAYS_FATAL_IF(objectsCount, 0); } -status_t RpcState::waitForReply(const base::unique_fd& fd, const sp<RpcSession>& session, - Parcel* reply) { +status_t RpcState::waitForReply(const sp<RpcSession::RpcConnection>& connection, + const sp<RpcSession>& session, Parcel* reply) { RpcWireHeader command; while (true) { - if (!rpcRec(fd, "command header", &command, sizeof(command))) { - return DEAD_OBJECT; - } + if (status_t status = + rpcRec(connection, session, "command header", &command, sizeof(command)); + status != OK) + return status; if (command.command == RPC_COMMAND_REPLY) break; - status_t status = processServerCommand(fd, session, command); - if (status != OK) return status; + if (status_t status = processCommand(connection, session, command, CommandType::ANY); + status != OK) + return status; } CommandData data(command.bodySize); - if (!data.valid()) { - return NO_MEMORY; - } + if (!data.valid()) return NO_MEMORY; - if (!rpcRec(fd, "reply body", data.data(), command.bodySize)) { - return DEAD_OBJECT; - } + if (status_t status = rpcRec(connection, session, "reply body", data.data(), command.bodySize); + status != OK) + return status; if (command.bodySize < sizeof(RpcWireReply)) { ALOGE("Expecting %zu but got %" PRId32 " bytes for RpcWireReply. Terminating!", sizeof(RpcWireReply), command.bodySize); - terminate(); + (void)session->shutdownAndWait(false); return BAD_VALUE; } RpcWireReply* rpcReply = reinterpret_cast<RpcWireReply*>(data.data()); @@ -431,7 +527,8 @@ status_t RpcState::waitForReply(const base::unique_fd& fd, const sp<RpcSession>& return OK; } -status_t RpcState::sendDecStrong(const base::unique_fd& fd, const RpcAddress& addr) { +status_t RpcState::sendDecStrong(const sp<RpcSession::RpcConnection>& connection, + const sp<RpcSession>& session, const RpcAddress& addr) { { std::lock_guard<std::mutex> _l(mNodeMutex); if (mTerminated) return DEAD_OBJECT; // avoid fatal only, otherwise races @@ -442,39 +539,71 @@ status_t RpcState::sendDecStrong(const base::unique_fd& fd, const RpcAddress& ad addr.toString().c_str()); it->second.timesRecd--; - if (it->second.timesRecd == 0 && it->second.timesSent == 0) { - mNodeForAddress.erase(it); - } + LOG_ALWAYS_FATAL_IF(nullptr != tryEraseNode(it), + "Bad state. RpcState shouldn't own received binder"); } RpcWireHeader cmd = { .command = RPC_COMMAND_DEC_STRONG, .bodySize = sizeof(RpcWireAddress), }; - if (!rpcSend(fd, "dec ref header", &cmd, sizeof(cmd))) return DEAD_OBJECT; - if (!rpcSend(fd, "dec ref body", &addr.viewRawEmbedded(), sizeof(RpcWireAddress))) - return DEAD_OBJECT; + if (status_t status = rpcSend(connection, session, "dec ref header", &cmd, sizeof(cmd)); + status != OK) + return status; + if (status_t status = rpcSend(connection, session, "dec ref body", &addr.viewRawEmbedded(), + sizeof(RpcWireAddress)); + status != OK) + return status; return OK; } -status_t RpcState::getAndExecuteCommand(const base::unique_fd& fd, const sp<RpcSession>& session) { - LOG_RPC_DETAIL("getAndExecuteCommand on fd %d", fd.get()); +status_t RpcState::getAndExecuteCommand(const sp<RpcSession::RpcConnection>& connection, + const sp<RpcSession>& session, CommandType type) { + LOG_RPC_DETAIL("getAndExecuteCommand on fd %d", connection->fd.get()); RpcWireHeader command; - if (!rpcRec(fd, "command header", &command, sizeof(command))) { - return DEAD_OBJECT; - } + if (status_t status = rpcRec(connection, session, "command header", &command, sizeof(command)); + status != OK) + return status; + + return processCommand(connection, session, command, type); +} - return processServerCommand(fd, session, command); +status_t RpcState::drainCommands(const sp<RpcSession::RpcConnection>& connection, + const sp<RpcSession>& session, CommandType type) { + uint8_t buf; + while (0 < TEMP_FAILURE_RETRY( + recv(connection->fd.get(), &buf, sizeof(buf), MSG_PEEK | MSG_DONTWAIT))) { + status_t status = getAndExecuteCommand(connection, session, type); + if (status != OK) return status; + } + return OK; } -status_t RpcState::processServerCommand(const base::unique_fd& fd, const sp<RpcSession>& session, - const RpcWireHeader& command) { +status_t RpcState::processCommand(const sp<RpcSession::RpcConnection>& connection, + const sp<RpcSession>& session, const RpcWireHeader& command, + CommandType type) { + IPCThreadState* kernelBinderState = IPCThreadState::selfOrNull(); + IPCThreadState::SpGuard spGuard{ + .address = __builtin_frame_address(0), + .context = "processing binder RPC command", + }; + const IPCThreadState::SpGuard* origGuard; + if (kernelBinderState != nullptr) { + origGuard = kernelBinderState->pushGetCallingSpGuard(&spGuard); + } + ScopeGuard guardUnguard = [&]() { + if (kernelBinderState != nullptr) { + kernelBinderState->restoreGetCallingSpGuard(origGuard); + } + }; + switch (command.command) { case RPC_COMMAND_TRANSACT: - return processTransact(fd, session, command); + if (type != CommandType::ANY) return BAD_TYPE; + return processTransact(connection, session, command); case RPC_COMMAND_DEC_STRONG: - return processDecStrong(fd, command); + return processDecStrong(connection, session, command); } // We should always know the version of the opposing side, and since the @@ -483,22 +612,23 @@ status_t RpcState::processServerCommand(const base::unique_fd& fd, const sp<RpcS // also can't consider it a fatal error because this would allow any client // to kill us, so ending the session for misbehaving client. ALOGE("Unknown RPC command %d - terminating session", command.command); - terminate(); + (void)session->shutdownAndWait(false); return DEAD_OBJECT; } -status_t RpcState::processTransact(const base::unique_fd& fd, const sp<RpcSession>& session, - const RpcWireHeader& command) { +status_t RpcState::processTransact(const sp<RpcSession::RpcConnection>& connection, + const sp<RpcSession>& session, const RpcWireHeader& command) { LOG_ALWAYS_FATAL_IF(command.command != RPC_COMMAND_TRANSACT, "command: %d", command.command); CommandData transactionData(command.bodySize); if (!transactionData.valid()) { return NO_MEMORY; } - if (!rpcRec(fd, "transaction body", transactionData.data(), transactionData.size())) { - return DEAD_OBJECT; - } + if (status_t status = rpcRec(connection, session, "transaction body", transactionData.data(), + transactionData.size()); + status != OK) + return status; - return processTransactInternal(fd, session, std::move(transactionData)); + return processTransactInternal(connection, session, std::move(transactionData)); } static void do_nothing_to_transact_data(Parcel* p, const uint8_t* data, size_t dataSize, @@ -510,12 +640,19 @@ static void do_nothing_to_transact_data(Parcel* p, const uint8_t* data, size_t d (void)objectsCount; } -status_t RpcState::processTransactInternal(const base::unique_fd& fd, const sp<RpcSession>& session, +status_t RpcState::processTransactInternal(const sp<RpcSession::RpcConnection>& connection, + const sp<RpcSession>& session, CommandData transactionData) { + // for 'recursive' calls to this, we have already read and processed the + // binder from the transaction data and taken reference counts into account, + // so it is cached here. + sp<IBinder> targetRef; +processTransactInternalTailCall: + if (transactionData.size() < sizeof(RpcWireTransaction)) { ALOGE("Expecting %zu but got %zu bytes for RpcWireTransaction. Terminating!", sizeof(RpcWireTransaction), transactionData.size()); - terminate(); + (void)session->shutdownAndWait(false); return BAD_VALUE; } RpcWireTransaction* transaction = reinterpret_cast<RpcWireTransaction*>(transactionData.data()); @@ -523,49 +660,73 @@ status_t RpcState::processTransactInternal(const base::unique_fd& fd, const sp<R // TODO(b/182939933): heap allocation just for lookup in mNodeForAddress, // maybe add an RpcAddress 'view' if the type remains 'heavy' auto addr = RpcAddress::fromRawEmbedded(&transaction->address); + bool oneway = transaction->flags & IBinder::FLAG_ONEWAY; status_t replyStatus = OK; sp<IBinder> target; if (!addr.isZero()) { - std::lock_guard<std::mutex> _l(mNodeMutex); + if (!targetRef) { + replyStatus = onBinderEntering(session, addr, &target); + } else { + target = targetRef; + } - auto it = mNodeForAddress.find(addr); - if (it == mNodeForAddress.end()) { - ALOGE("Unknown binder address %s.", addr.toString().c_str()); + if (replyStatus != OK) { + // do nothing + } else if (target == nullptr) { + // This can happen if the binder is remote in this process, and + // another thread has called the last decStrong on this binder. + // However, for local binders, it indicates a misbehaving client + // (any binder which is being transacted on should be holding a + // strong ref count), so in either case, terminating the + // session. + ALOGE("While transacting, binder has been deleted at address %s. Terminating!", + addr.toString().c_str()); + (void)session->shutdownAndWait(false); replyStatus = BAD_VALUE; - } else { - target = it->second.binder.promote(); - if (target == nullptr) { - // This can happen if the binder is remote in this process, and - // another thread has called the last decStrong on this binder. - // However, for local binders, it indicates a misbehaving client - // (any binder which is being transacted on should be holding a - // strong ref count), so in either case, terminating the - // session. - ALOGE("While transacting, binder has been deleted at address %s. Terminating!", - addr.toString().c_str()); - terminate(); - replyStatus = BAD_VALUE; - } else if (target->localBinder() == nullptr) { - ALOGE("Transactions can only go to local binders, not address %s. Terminating!", + } else if (target->localBinder() == nullptr) { + ALOGE("Unknown binder address or non-local binder, not address %s. Terminating!", + addr.toString().c_str()); + (void)session->shutdownAndWait(false); + replyStatus = BAD_VALUE; + } else if (oneway) { + std::unique_lock<std::mutex> _l(mNodeMutex); + auto it = mNodeForAddress.find(addr); + if (it->second.binder.promote() != target) { + ALOGE("Binder became invalid during transaction. Bad client? %s", addr.toString().c_str()); - terminate(); replyStatus = BAD_VALUE; - } else if (transaction->flags & IBinder::FLAG_ONEWAY) { - if (transaction->asyncNumber != it->second.asyncNumber) { - // we need to process some other asynchronous transaction - // first - // TODO(b/183140903): limit enqueues/detect overfill for bad client - // TODO(b/183140903): detect when an object is deleted when it still has - // pending async transactions - it->second.asyncTodo.push(BinderNode::AsyncTodo{ - .data = std::move(transactionData), - .asyncNumber = transaction->asyncNumber, - }); - LOG_RPC_DETAIL("Enqueuing %" PRId64 " on %s", transaction->asyncNumber, - addr.toString().c_str()); - return OK; + } else if (transaction->asyncNumber != it->second.asyncNumber) { + // we need to process some other asynchronous transaction + // first + it->second.asyncTodo.push(BinderNode::AsyncTodo{ + .ref = target, + .data = std::move(transactionData), + .asyncNumber = transaction->asyncNumber, + }); + + size_t numPending = it->second.asyncTodo.size(); + LOG_RPC_DETAIL("Enqueuing %" PRId64 " on %s (%zu pending)", + transaction->asyncNumber, addr.toString().c_str(), numPending); + + constexpr size_t kArbitraryOnewayCallTerminateLevel = 10000; + constexpr size_t kArbitraryOnewayCallWarnLevel = 1000; + constexpr size_t kArbitraryOnewayCallWarnPer = 1000; + + if (numPending >= kArbitraryOnewayCallWarnLevel) { + if (numPending >= kArbitraryOnewayCallTerminateLevel) { + ALOGE("WARNING: %zu pending oneway transactions. Terminating!", numPending); + _l.unlock(); + (void)session->shutdownAndWait(false); + return FAILED_TRANSACTION; + } + + if (numPending % kArbitraryOnewayCallWarnPer == 0) { + ALOGW("Warning: many oneway transactions built up on %p (%zu)", + target.get(), numPending); + } } + return OK; } } } @@ -585,43 +746,48 @@ status_t RpcState::processTransactInternal(const base::unique_fd& fd, const sp<R data.markForRpc(session); if (target) { + bool origAllowNested = connection->allowNested; + connection->allowNested = !oneway; + replyStatus = target->transact(transaction->code, data, &reply, transaction->flags); + + connection->allowNested = origAllowNested; } else { LOG_RPC_DETAIL("Got special transaction %u", transaction->code); - sp<RpcServer> server = session->server().promote(); - if (server) { - // special case for 'zero' address (special server commands) - switch (transaction->code) { - case RPC_SPECIAL_TRANSACT_GET_ROOT: { - replyStatus = reply.writeStrongBinder(server->getRootObject()); - break; - } - case RPC_SPECIAL_TRANSACT_GET_MAX_THREADS: { - replyStatus = reply.writeInt32(server->getMaxThreads()); - break; - } - case RPC_SPECIAL_TRANSACT_GET_SESSION_ID: { - // only sessions w/ services can be the source of a - // session ID (so still guarded by non-null server) - // - // sessions associated with servers must have an ID - // (hence abort) - int32_t id = session->getPrivateAccessorForId().get().value(); - replyStatus = reply.writeInt32(id); - break; - } - default: { - replyStatus = UNKNOWN_TRANSACTION; + switch (transaction->code) { + case RPC_SPECIAL_TRANSACT_GET_MAX_THREADS: { + replyStatus = reply.writeInt32(session->getMaxThreads()); + break; + } + case RPC_SPECIAL_TRANSACT_GET_SESSION_ID: { + // for client connections, this should always report the value + // originally returned from the server, so this is asserting + // that it exists + replyStatus = session->mId.value().writeToParcel(&reply); + break; + } + default: { + sp<RpcServer> server = session->server(); + if (server) { + switch (transaction->code) { + case RPC_SPECIAL_TRANSACT_GET_ROOT: { + replyStatus = reply.writeStrongBinder(server->getRootObject()); + break; + } + default: { + replyStatus = UNKNOWN_TRANSACTION; + } + } + } else { + ALOGE("Special command sent, but no server object attached."); } } - } else { - ALOGE("Special command sent, but no server object attached."); } } } - if (transaction->flags & IBinder::FLAG_ONEWAY) { + if (oneway) { if (replyStatus != OK) { ALOGW("Oneway call failed with error: %d", replyStatus); } @@ -645,13 +811,11 @@ status_t RpcState::processTransactInternal(const base::unique_fd& fd, const sp<R // last refcount dropped after this transaction happened if (it == mNodeForAddress.end()) return OK; - // note - only updated now, instead of later, so that other threads - // will queue any later transactions - - // TODO(b/183140903): support > 2**64 async transactions - // (we can do this by allowing asyncNumber to wrap, since we - // don't expect more than 2**64 simultaneous transactions) - it->second.asyncNumber++; + if (!nodeProgressAsyncNumber(&it->second)) { + _l.unlock(); + (void)session->shutdownAndWait(false); + return DEAD_OBJECT; + } if (it->second.asyncTodo.size() == 0) return OK; if (it->second.asyncTodo.top().asyncNumber == it->second.asyncNumber) { @@ -659,64 +823,63 @@ status_t RpcState::processTransactInternal(const base::unique_fd& fd, const sp<R it->second.asyncNumber, addr.toString().c_str()); // justification for const_cast (consider avoiding priority_queue): - // - AsyncTodo operator< doesn't depend on 'data' object + // - AsyncTodo operator< doesn't depend on 'data' or 'ref' objects // - gotta go fast - CommandData data = std::move( - const_cast<BinderNode::AsyncTodo&>(it->second.asyncTodo.top()).data); + auto& todo = const_cast<BinderNode::AsyncTodo&>(it->second.asyncTodo.top()); + + // reset up arguments + transactionData = std::move(todo.data); + targetRef = std::move(todo.ref); + it->second.asyncTodo.pop(); - _l.unlock(); - return processTransactInternal(fd, session, std::move(data)); + goto processTransactInternalTailCall; } } return OK; } + LOG_ALWAYS_FATAL_IF(std::numeric_limits<int32_t>::max() - sizeof(RpcWireHeader) - + sizeof(RpcWireReply) < + reply.dataSize(), + "Too much data for reply %zu", reply.dataSize()); + + RpcWireHeader cmdReply{ + .command = RPC_COMMAND_REPLY, + .bodySize = static_cast<uint32_t>(sizeof(RpcWireReply) + reply.dataSize()), + }; RpcWireReply rpcReply{ .status = replyStatus, }; - CommandData replyData(sizeof(RpcWireReply) + reply.dataSize()); + CommandData replyData(sizeof(RpcWireHeader) + sizeof(RpcWireReply) + reply.dataSize()); if (!replyData.valid()) { return NO_MEMORY; } - memcpy(replyData.data() + 0, &rpcReply, sizeof(RpcWireReply)); - memcpy(replyData.data() + sizeof(RpcWireReply), reply.data(), reply.dataSize()); - - if (replyData.size() > std::numeric_limits<uint32_t>::max()) { - ALOGE("Reply size too big %zu", transactionData.size()); - terminate(); - return BAD_VALUE; - } + memcpy(replyData.data() + 0, &cmdReply, sizeof(RpcWireHeader)); + memcpy(replyData.data() + sizeof(RpcWireHeader), &rpcReply, sizeof(RpcWireReply)); + memcpy(replyData.data() + sizeof(RpcWireHeader) + sizeof(RpcWireReply), reply.data(), + reply.dataSize()); - RpcWireHeader cmdReply{ - .command = RPC_COMMAND_REPLY, - .bodySize = static_cast<uint32_t>(replyData.size()), - }; - - if (!rpcSend(fd, "reply header", &cmdReply, sizeof(RpcWireHeader))) { - return DEAD_OBJECT; - } - if (!rpcSend(fd, "reply body", replyData.data(), replyData.size())) { - return DEAD_OBJECT; - } - return OK; + return rpcSend(connection, session, "reply", replyData.data(), replyData.size()); } -status_t RpcState::processDecStrong(const base::unique_fd& fd, const RpcWireHeader& command) { +status_t RpcState::processDecStrong(const sp<RpcSession::RpcConnection>& connection, + const sp<RpcSession>& session, const RpcWireHeader& command) { LOG_ALWAYS_FATAL_IF(command.command != RPC_COMMAND_DEC_STRONG, "command: %d", command.command); CommandData commandData(command.bodySize); if (!commandData.valid()) { return NO_MEMORY; } - if (!rpcRec(fd, "dec ref body", commandData.data(), commandData.size())) { - return DEAD_OBJECT; - } + if (status_t status = + rpcRec(connection, session, "dec ref body", commandData.data(), commandData.size()); + status != OK) + return status; if (command.bodySize < sizeof(RpcWireAddress)) { ALOGE("Expecting %zu but got %" PRId32 " bytes for RpcWireAddress. Terminating!", sizeof(RpcWireAddress), command.bodySize); - terminate(); + (void)session->shutdownAndWait(false); return BAD_VALUE; } RpcWireAddress* address = reinterpret_cast<RpcWireAddress*>(commandData.data()); @@ -734,7 +897,8 @@ status_t RpcState::processDecStrong(const base::unique_fd& fd, const RpcWireHead if (target == nullptr) { ALOGE("While requesting dec strong, binder has been deleted at address %s. Terminating!", addr.toString().c_str()); - terminate(); + _l.unlock(); + (void)session->shutdownAndWait(false); return BAD_VALUE; } @@ -746,22 +910,39 @@ status_t RpcState::processDecStrong(const base::unique_fd& fd, const RpcWireHead LOG_ALWAYS_FATAL_IF(it->second.sentRef == nullptr, "Inconsistent state, lost ref for %s", addr.toString().c_str()); - sp<IBinder> tempHold; - it->second.timesSent--; + sp<IBinder> tempHold = tryEraseNode(it); + _l.unlock(); + tempHold = nullptr; // destructor may make binder calls on this session + + return OK; +} + +sp<IBinder> RpcState::tryEraseNode(std::map<RpcAddress, BinderNode>::iterator& it) { + sp<IBinder> ref; + if (it->second.timesSent == 0) { - tempHold = it->second.sentRef; - it->second.sentRef = nullptr; + ref = std::move(it->second.sentRef); if (it->second.timesRecd == 0) { + LOG_ALWAYS_FATAL_IF(!it->second.asyncTodo.empty(), + "Can't delete binder w/ pending async transactions"); mNodeForAddress.erase(it); } } - _l.unlock(); - tempHold = nullptr; // destructor may make binder calls on this session + return ref; +} - return OK; +bool RpcState::nodeProgressAsyncNumber(BinderNode* node) { + // 2**64 =~ 10**19 =~ 1000 transactions per second for 585 million years to + // a single binder + if (node->asyncNumber >= std::numeric_limits<decltype(node->asyncNumber)>::max()) { + ALOGE("Out of async transaction IDs. Terminating"); + return false; + } + node->asyncNumber++; + return true; } } // namespace android diff --git a/libs/binder/RpcState.h b/libs/binder/RpcState.h index 31f8a22065..529dee534c 100644 --- a/libs/binder/RpcState.h +++ b/libs/binder/RpcState.h @@ -51,19 +51,37 @@ public: RpcState(); ~RpcState(); + status_t sendConnectionInit(const sp<RpcSession::RpcConnection>& connection, + const sp<RpcSession>& session); + status_t readConnectionInit(const sp<RpcSession::RpcConnection>& connection, + const sp<RpcSession>& session); + // TODO(b/182940634): combine some special transactions into one "getServerInfo" call? - sp<IBinder> getRootObject(const base::unique_fd& fd, const sp<RpcSession>& session); - status_t getMaxThreads(const base::unique_fd& fd, const sp<RpcSession>& session, - size_t* maxThreadsOut); - status_t getSessionId(const base::unique_fd& fd, const sp<RpcSession>& session, - int32_t* sessionIdOut); - - [[nodiscard]] status_t transact(const base::unique_fd& fd, const RpcAddress& address, - uint32_t code, const Parcel& data, + sp<IBinder> getRootObject(const sp<RpcSession::RpcConnection>& connection, + const sp<RpcSession>& session); + status_t getMaxThreads(const sp<RpcSession::RpcConnection>& connection, + const sp<RpcSession>& session, size_t* maxThreadsOut); + status_t getSessionId(const sp<RpcSession::RpcConnection>& connection, + const sp<RpcSession>& session, RpcAddress* sessionIdOut); + + [[nodiscard]] status_t transact(const sp<RpcSession::RpcConnection>& connection, + const sp<IBinder>& address, uint32_t code, const Parcel& data, const sp<RpcSession>& session, Parcel* reply, uint32_t flags); - [[nodiscard]] status_t sendDecStrong(const base::unique_fd& fd, const RpcAddress& address); - [[nodiscard]] status_t getAndExecuteCommand(const base::unique_fd& fd, - const sp<RpcSession>& session); + [[nodiscard]] status_t transactAddress(const sp<RpcSession::RpcConnection>& connection, + const RpcAddress& address, uint32_t code, + const Parcel& data, const sp<RpcSession>& session, + Parcel* reply, uint32_t flags); + [[nodiscard]] status_t sendDecStrong(const sp<RpcSession::RpcConnection>& connection, + const sp<RpcSession>& session, const RpcAddress& address); + + enum class CommandType { + ANY, + CONTROL_ONLY, + }; + [[nodiscard]] status_t getAndExecuteCommand(const sp<RpcSession::RpcConnection>& connection, + const sp<RpcSession>& session, CommandType type); + [[nodiscard]] status_t drainCommands(const sp<RpcSession::RpcConnection>& connection, + const sp<RpcSession>& session, CommandType type); /** * Called by Parcel for outgoing binders. This implies one refcount of @@ -77,12 +95,12 @@ public: * to the process, if this process already has one, or it takes ownership of * that refcount */ - sp<IBinder> onBinderEntering(const sp<RpcSession>& session, const RpcAddress& address); + [[nodiscard]] status_t onBinderEntering(const sp<RpcSession>& session, + const RpcAddress& address, sp<IBinder>* out); size_t countBinders(); void dump(); -private: /** * Called when reading or writing data to a session fails to clean up * data associated with the session in order to cleanup binders. @@ -99,7 +117,10 @@ private: * WARNING: RpcState is responsible for calling this when the session is * no longer recoverable. */ - void terminate(); + void clear(); + +private: + void dumpLocked(); // Alternative to std::vector<uint8_t> that doesn't abort on allocation failure and caps // large allocations to avoid being requested from allocating too much data. @@ -115,21 +136,26 @@ private: size_t mSize; }; - [[nodiscard]] bool rpcSend(const base::unique_fd& fd, const char* what, const void* data, - size_t size); - [[nodiscard]] bool rpcRec(const base::unique_fd& fd, const char* what, void* data, size_t size); - - [[nodiscard]] status_t waitForReply(const base::unique_fd& fd, const sp<RpcSession>& session, - Parcel* reply); - [[nodiscard]] status_t processServerCommand(const base::unique_fd& fd, - const sp<RpcSession>& session, - const RpcWireHeader& command); - [[nodiscard]] status_t processTransact(const base::unique_fd& fd, const sp<RpcSession>& session, + [[nodiscard]] status_t rpcSend(const sp<RpcSession::RpcConnection>& connection, + const sp<RpcSession>& session, const char* what, + const void* data, size_t size); + [[nodiscard]] status_t rpcRec(const sp<RpcSession::RpcConnection>& connection, + const sp<RpcSession>& session, const char* what, void* data, + size_t size); + + [[nodiscard]] status_t waitForReply(const sp<RpcSession::RpcConnection>& connection, + const sp<RpcSession>& session, Parcel* reply); + [[nodiscard]] status_t processCommand(const sp<RpcSession::RpcConnection>& connection, + const sp<RpcSession>& session, + const RpcWireHeader& command, CommandType type); + [[nodiscard]] status_t processTransact(const sp<RpcSession::RpcConnection>& connection, + const sp<RpcSession>& session, const RpcWireHeader& command); - [[nodiscard]] status_t processTransactInternal(const base::unique_fd& fd, + [[nodiscard]] status_t processTransactInternal(const sp<RpcSession::RpcConnection>& connection, const sp<RpcSession>& session, CommandData transactionData); - [[nodiscard]] status_t processDecStrong(const base::unique_fd& fd, + [[nodiscard]] status_t processDecStrong(const sp<RpcSession::RpcConnection>& connection, + const sp<RpcSession>& session, const RpcWireHeader& command); struct BinderNode { @@ -163,6 +189,7 @@ private: // async transaction queue, _only_ for local binder struct AsyncTodo { + sp<IBinder> ref; CommandData data; uint64_t asyncNumber = 0; @@ -179,6 +206,15 @@ private: // (no additional data specific to remote binders) }; + // checks if there is any reference left to a node and erases it. If erase + // happens, and there is a strong reference to the binder kept by + // binderNode, this returns that strong reference, so that it can be + // dropped after any locks are removed. + sp<IBinder> tryEraseNode(std::map<RpcAddress, BinderNode>::iterator& it); + // true - success + // false - session shutdown, halt + [[nodiscard]] bool nodeProgressAsyncNumber(BinderNode* node); + std::mutex mNodeMutex; bool mTerminated = false; // binders known by both sides of a session diff --git a/libs/binder/RpcWireFormat.h b/libs/binder/RpcWireFormat.h index c5fa008308..2016483138 100644 --- a/libs/binder/RpcWireFormat.h +++ b/libs/binder/RpcWireFormat.h @@ -20,6 +20,40 @@ namespace android { #pragma clang diagnostic push #pragma clang diagnostic error "-Wpadded" +enum : uint8_t { + RPC_CONNECTION_OPTION_REVERSE = 0x1, +}; + +constexpr uint64_t RPC_WIRE_ADDRESS_OPTION_CREATED = 1 << 0; // distinguish from '0' address +constexpr uint64_t RPC_WIRE_ADDRESS_OPTION_FOR_SERVER = 1 << 1; + +struct RpcWireAddress { + uint64_t options; + uint8_t address[32]; +}; + +/** + * This is sent to an RpcServer in order to request a new connection is created, + * either as part of a new session or an existing session + */ +struct RpcConnectionHeader { + RpcWireAddress sessionId; + uint8_t options; + uint8_t reserved[7]; +}; + +#define RPC_CONNECTION_INIT_OKAY "cci" + +/** + * Whenever a client connection is setup, this is sent as the initial + * transaction. The main use of this is in order to control the timing for when + * a reverse connection is setup. + */ +struct RpcOutgoingConnectionInit { + char msg[4]; + uint8_t reserved[4]; +}; + enum : uint32_t { /** * follows is RpcWireTransaction, if flags != oneway, reply w/ RPC_COMMAND_REPLY expected @@ -51,8 +85,6 @@ enum : uint32_t { RPC_SPECIAL_TRANSACT_GET_SESSION_ID = 2, }; -constexpr int32_t RPC_SESSION_ID_NEW = -1; - // serialization is like: // |RpcWireHeader|struct desginated by 'command'| (over and over again) @@ -63,10 +95,6 @@ struct RpcWireHeader { uint32_t reserved[2]; }; -struct RpcWireAddress { - uint8_t address[32]; -}; - struct RpcWireTransaction { RpcWireAddress address; uint32_t code; diff --git a/libs/binder/Stability.cpp b/libs/binder/Stability.cpp index f12ef4e35b..00b69d527a 100644 --- a/libs/binder/Stability.cpp +++ b/libs/binder/Stability.cpp @@ -33,7 +33,6 @@ constexpr uint8_t kBinderWireFormatVersion = 1; Stability::Category Stability::Category::currentFromLevel(Level level) { return { .version = kBinderWireFormatVersion, - .reserved = {0}, .level = level, }; } @@ -79,9 +78,9 @@ void Stability::markVintf(IBinder* binder) { LOG_ALWAYS_FATAL_IF(result != OK, "Should only mark known object."); } -void Stability::debugLogStability(const std::string& tag, const sp<IBinder>& binder) { +std::string Stability::debugToString(const sp<IBinder>& binder) { auto stability = getCategory(binder.get()); - ALOGE("%s: stability is %s", tag.c_str(), stability.debugString().c_str()); + return stability.debugString(); } void Stability::markVndk(IBinder* binder) { diff --git a/libs/binder/include/binder/Binder.h b/libs/binder/include/binder/Binder.h index 7e9be417e1..472e546944 100644 --- a/libs/binder/include/binder/Binder.h +++ b/libs/binder/include/binder/Binder.h @@ -94,6 +94,16 @@ public: pid_t getDebugPid(); + // Whether this binder has been sent to another process. + bool wasParceled(); + // Consider this binder as parceled (setup/init-related calls should no + // longer by called. This is automatically set by when this binder is sent + // to another process. + void setParceled(); + + [[nodiscard]] status_t setRpcClientDebug(android::base::unique_fd clientFd, + const sp<IBinder>& keepAliveBinder); + protected: virtual ~BBinder(); @@ -107,17 +117,24 @@ private: BBinder(const BBinder& o); BBinder& operator=(const BBinder& o); + class RpcServerLink; class Extras; Extras* getOrCreateExtras(); + [[nodiscard]] status_t setRpcClientDebug(const Parcel& data); + void removeRpcServerLink(const sp<RpcServerLink>& link); + std::atomic<Extras*> mExtras; friend ::android::internal::Stability; - union { - int32_t mStability; - void* mReserved0; - }; + int16_t mStability; + bool mParceled; + uint8_t mReserved0; + +#ifdef __LP64__ + int32_t mReserved1; +#endif }; // --------------------------------------------------------------------------- diff --git a/libs/binder/include/binder/BinderService.h b/libs/binder/include/binder/BinderService.h index 5776f3c91f..e58d4894d9 100644 --- a/libs/binder/include/binder/BinderService.h +++ b/libs/binder/include/binder/BinderService.h @@ -26,6 +26,24 @@ #include <binder/ProcessState.h> #include <binder/IServiceManager.h> +// WARNING: deprecated - DO NOT USE - prefer to setup service directly. +// +// This class embellishes a class with a few static methods which can be used in +// limited circumstances (when one service needs to be registered and +// published). However, this is an anti-pattern: +// - these methods are aliases of existing methods, and as such, represent an +// incremental amount of information required to understand the system but +// which does not actually save in terms of lines of code. For instance, users +// of this class should be surprised to know that this will start up to 16 +// threads in the binder threadpool. +// - the template instantiation costs need to be paid, even though everything +// done here is generic. +// - the getServiceName API here is undocumented and non-local (for instance, +// this unnecessarily assumes a single service type will only be instantiated +// once with no arguments). +// +// So, DO NOT USE. + // --------------------------------------------------------------------------- namespace android { diff --git a/libs/binder/include/binder/IBinder.h b/libs/binder/include/binder/IBinder.h index 97c826ce76..f9cdac7de9 100644 --- a/libs/binder/include/binder/IBinder.h +++ b/libs/binder/include/binder/IBinder.h @@ -60,6 +60,7 @@ public: SYSPROPS_TRANSACTION = B_PACK_CHARS('_', 'S', 'P', 'R'), EXTENSION_TRANSACTION = B_PACK_CHARS('_', 'E', 'X', 'T'), DEBUG_PID_TRANSACTION = B_PACK_CHARS('_', 'P', 'I', 'D'), + SET_RPC_CLIENT_TRANSACTION = B_PACK_CHARS('_', 'R', 'P', 'C'), // See android.os.IBinder.TWEET_TRANSACTION // Most importantly, messages can be anything not exceeding 130 UTF-8 @@ -152,6 +153,27 @@ public: */ status_t getDebugPid(pid_t* outPid); + /** + * Set the RPC client fd to this binder service, for debugging. This is only available on + * debuggable builds. + * + * When this is called on a binder service, the service: + * 1. sets up RPC server + * 2. spawns 1 new thread that calls RpcServer::join() + * - join() spawns some number of threads that accept() connections; see RpcServer + * + * setRpcClientDebug() may be called multiple times. Each call will add a new RpcServer + * and opens up a TCP port. + * + * Note: A thread is spawned for each accept()'ed fd, which may call into functions of the + * interface freely. See RpcServer::join(). To avoid such race conditions, implement the service + * functions with multithreading support. + * + * On death of @a keepAliveBinder, the RpcServer shuts down. + */ + [[nodiscard]] status_t setRpcClientDebug(android::base::unique_fd socketFd, + const sp<IBinder>& keepAliveBinder); + // NOLINTNEXTLINE(google-default-arguments) virtual status_t transact( uint32_t code, const Parcel& data, diff --git a/libs/binder/include/binder/IPCThreadState.h b/libs/binder/include/binder/IPCThreadState.h index 196a41ba55..20a9f36842 100644 --- a/libs/binder/include/binder/IPCThreadState.h +++ b/libs/binder/include/binder/IPCThreadState.h @@ -62,7 +62,7 @@ public: * call. If not in a binder call, this will return getpid. If the * call is oneway, this will return 0. */ - pid_t getCallingPid() const; + [[nodiscard]] pid_t getCallingPid() const; /** * Returns the SELinux security identifier of the process which has @@ -73,13 +73,43 @@ public: * This can't be restored once it's cleared, and it does not return the * context of the current process when not in a binder call. */ - const char* getCallingSid() const; + [[nodiscard]] const char* getCallingSid() const; /** * Returns the UID of the process which has made the current binder * call. If not in a binder call, this will return 0. */ - uid_t getCallingUid() const; + [[nodiscard]] uid_t getCallingUid() const; + + /** + * Make it an abort to rely on getCalling* for a section of + * execution. + * + * Usage: + * IPCThreadState::SpGuard guard { + * .address = __builtin_frame_address(0), + * .context = "...", + * }; + * const auto* orig = pushGetCallingSpGuard(&guard); + * { + * // will abort if you call getCalling*, unless you are + * // serving a nested binder transaction + * } + * restoreCallingSpGuard(orig); + */ + struct SpGuard { + const void* address; + const char* context; + }; + const SpGuard* pushGetCallingSpGuard(const SpGuard* guard); + void restoreGetCallingSpGuard(const SpGuard* guard); + /** + * Used internally by getCalling*. Can also be used to assert that + * you are in a binder context (getCalling* is valid). This is + * intentionally not exposed as a boolean API since code should be + * written to know its environment. + */ + void checkContextIsBinderForUse(const char* use) const; void setStrictModePolicy(int32_t policy); int32_t getStrictModePolicy() const; @@ -197,6 +227,7 @@ private: Parcel mOut; status_t mLastError; const void* mServingStackPointer; + const SpGuard* mServingStackPointerGuard; pid_t mCallingPid; const char* mCallingSid; uid_t mCallingUid; diff --git a/libs/binder/include/binder/Parcel.h b/libs/binder/include/binder/Parcel.h index 5aaaa0c3d2..02052ad77e 100644 --- a/libs/binder/include/binder/Parcel.h +++ b/libs/binder/include/binder/Parcel.h @@ -561,6 +561,8 @@ private: status_t flattenBinder(const sp<IBinder>& binder); status_t unflattenBinder(sp<IBinder>* out) const; + status_t readOutVectorSizeWithCheck(size_t elmSize, int32_t* size) const; + template<class T> status_t readAligned(T *pArg) const; @@ -1315,7 +1317,7 @@ status_t Parcel::writeVectorSize(const std::unique_ptr<std::vector<T>>& val) { template<typename T> status_t Parcel::resizeOutVector(std::vector<T>* val) const { int32_t size; - status_t err = readInt32(&size); + status_t err = readOutVectorSizeWithCheck(sizeof(T), &size); if (err != NO_ERROR) { return err; } @@ -1330,7 +1332,7 @@ status_t Parcel::resizeOutVector(std::vector<T>* val) const { template<typename T> status_t Parcel::resizeOutVector(std::optional<std::vector<T>>* val) const { int32_t size; - status_t err = readInt32(&size); + status_t err = readOutVectorSizeWithCheck(sizeof(T), &size); if (err != NO_ERROR) { return err; } @@ -1346,7 +1348,7 @@ status_t Parcel::resizeOutVector(std::optional<std::vector<T>>* val) const { template<typename T> status_t Parcel::resizeOutVector(std::unique_ptr<std::vector<T>>* val) const { int32_t size; - status_t err = readInt32(&size); + status_t err = readOutVectorSizeWithCheck(sizeof(T), &size); if (err != NO_ERROR) { return err; } diff --git a/libs/binder/include/binder/ProcessState.h b/libs/binder/include/binder/ProcessState.h index b9db5d726c..72c2ab7b31 100644 --- a/libs/binder/include/binder/ProcessState.h +++ b/libs/binder/include/binder/ProcessState.h @@ -18,8 +18,8 @@ #include <binder/IBinder.h> #include <utils/KeyedVector.h> -#include <utils/String8.h> #include <utils/String16.h> +#include <utils/String8.h> #include <utils/threads.h> @@ -30,11 +30,10 @@ namespace android { class IPCThreadState; -class ProcessState : public virtual RefBase -{ +class ProcessState : public virtual RefBase { public: - static sp<ProcessState> self(); - static sp<ProcessState> selfOrNull(); + static sp<ProcessState> self(); + static sp<ProcessState> selfOrNull(); /* initWithDriver() can be used to configure libbinder to use * a different binder driver dev node. It must be called *before* @@ -44,94 +43,101 @@ public: * * If this is called with nullptr, the behavior is the same as selfOrNull. */ - static sp<ProcessState> initWithDriver(const char *driver); + static sp<ProcessState> initWithDriver(const char* driver); - sp<IBinder> getContextObject(const sp<IBinder>& caller); + sp<IBinder> getContextObject(const sp<IBinder>& caller); - void startThreadPool(); + void startThreadPool(); - bool becomeContextManager(); + bool becomeContextManager(); - sp<IBinder> getStrongProxyForHandle(int32_t handle); - void expungeHandle(int32_t handle, IBinder* binder); + sp<IBinder> getStrongProxyForHandle(int32_t handle); + void expungeHandle(int32_t handle, IBinder* binder); - void spawnPooledThread(bool isMain); - - status_t setThreadPoolMaxThreadCount(size_t maxThreads); - status_t enableOnewaySpamDetection(bool enable); - void giveThreadPoolName(); + void spawnPooledThread(bool isMain); - String8 getDriverName(); + status_t setThreadPoolMaxThreadCount(size_t maxThreads); + status_t enableOnewaySpamDetection(bool enable); + void giveThreadPoolName(); - ssize_t getKernelReferences(size_t count, uintptr_t* buf); + String8 getDriverName(); - // Only usable by the context manager. - // This refcount includes: - // 1. Strong references to the node by this and other processes - // 2. Temporary strong references held by the kernel during a - // transaction on the node. - // It does NOT include local strong references to the node - ssize_t getStrongRefCountForNode(const sp<BpBinder>& binder); + ssize_t getKernelReferences(size_t count, uintptr_t* buf); - enum class CallRestriction { - // all calls okay - NONE, - // log when calls are blocking - ERROR_IF_NOT_ONEWAY, - // abort process on blocking calls - FATAL_IF_NOT_ONEWAY, - }; - // Sets calling restrictions for all transactions in this process. This must be called - // before any threads are spawned. - void setCallRestriction(CallRestriction restriction); + // Only usable by the context manager. + // This refcount includes: + // 1. Strong references to the node by this and other processes + // 2. Temporary strong references held by the kernel during a + // transaction on the node. + // It does NOT include local strong references to the node + ssize_t getStrongRefCountForNode(const sp<BpBinder>& binder); + + enum class CallRestriction { + // all calls okay + NONE, + // log when calls are blocking + ERROR_IF_NOT_ONEWAY, + // abort process on blocking calls + FATAL_IF_NOT_ONEWAY, + }; + // Sets calling restrictions for all transactions in this process. This must be called + // before any threads are spawned. + void setCallRestriction(CallRestriction restriction); + + /** + * Get the max number of threads that the kernel can start. + * + * Note: this is the lower bound. Additional threads may be started. + */ + size_t getThreadPoolMaxThreadCount() const; private: - static sp<ProcessState> init(const char *defaultDriver, bool requireDefault); + static sp<ProcessState> init(const char* defaultDriver, bool requireDefault); friend class IPCThreadState; friend class sp<ProcessState>; - explicit ProcessState(const char* driver); - ~ProcessState(); + explicit ProcessState(const char* driver); + ~ProcessState(); - ProcessState(const ProcessState& o); - ProcessState& operator=(const ProcessState& o); - String8 makeBinderThreadName(); + ProcessState(const ProcessState& o); + ProcessState& operator=(const ProcessState& o); + String8 makeBinderThreadName(); - struct handle_entry { - IBinder* binder; - RefBase::weakref_type* refs; - }; + struct handle_entry { + IBinder* binder; + RefBase::weakref_type* refs; + }; - handle_entry* lookupHandleLocked(int32_t handle); + handle_entry* lookupHandleLocked(int32_t handle); - String8 mDriverName; - int mDriverFD; - void* mVMStart; + String8 mDriverName; + int mDriverFD; + void* mVMStart; - // Protects thread count and wait variables below. - pthread_mutex_t mThreadCountLock; - // Broadcast whenever mWaitingForThreads > 0 - pthread_cond_t mThreadCountDecrement; - // Number of binder threads current executing a command. - size_t mExecutingThreadsCount; - // Number of threads calling IPCThreadState::blockUntilThreadAvailable() - size_t mWaitingForThreads; - // Maximum number for binder threads allowed for this process. - size_t mMaxThreads; - // Time when thread pool was emptied - int64_t mStarvationStartTimeMs; + // Protects thread count and wait variables below. + pthread_mutex_t mThreadCountLock; + // Broadcast whenever mWaitingForThreads > 0 + pthread_cond_t mThreadCountDecrement; + // Number of binder threads current executing a command. + size_t mExecutingThreadsCount; + // Number of threads calling IPCThreadState::blockUntilThreadAvailable() + size_t mWaitingForThreads; + // Maximum number for binder threads allowed for this process. + size_t mMaxThreads; + // Time when thread pool was emptied + int64_t mStarvationStartTimeMs; - mutable Mutex mLock; // protects everything below. + mutable Mutex mLock; // protects everything below. - Vector<handle_entry>mHandleToObject; + Vector<handle_entry> mHandleToObject; - bool mThreadPoolStarted; - volatile int32_t mThreadPoolSeq; + bool mThreadPoolStarted; + volatile int32_t mThreadPoolSeq; - CallRestriction mCallRestriction; + CallRestriction mCallRestriction; }; - + } // namespace android // --------------------------------------------------------------------------- diff --git a/libs/binder/include/binder/RpcAddress.h b/libs/binder/include/binder/RpcAddress.h index 5a3f3a6afa..e428908c88 100644 --- a/libs/binder/include/binder/RpcAddress.h +++ b/libs/binder/include/binder/RpcAddress.h @@ -29,11 +29,7 @@ class Parcel; struct RpcWireAddress; /** - * This class represents an identifier of a binder object. - * - * The purpose of this class it to hide the ABI of an RpcWireAddress, and - * potentially allow us to change the size of it in the future (RpcWireAddress - * is PIMPL, essentially - although the type that is used here is not exposed). + * This class represents an identifier across an RPC boundary. */ class RpcAddress { public: @@ -46,9 +42,20 @@ public: bool isZero() const; /** - * Create a new address which is unique + * Create a new random address. + */ + static RpcAddress random(bool forServer); + + /** + * Whether this address was created with 'bool forServer' true + */ + bool isForServer() const; + + /** + * Whether this address is one that could be created with this version of + * libbinder. */ - static RpcAddress unique(); + bool isRecognizedType() const; /** * Creates a new address as a copy of an embedded object. diff --git a/libs/binder/include/binder/RpcServer.h b/libs/binder/include/binder/RpcServer.h index 8f0c6fd5e1..c8d2857347 100644 --- a/libs/binder/include/binder/RpcServer.h +++ b/libs/binder/include/binder/RpcServer.h @@ -17,6 +17,7 @@ #include <android-base/unique_fd.h> #include <binder/IBinder.h> +#include <binder/RpcAddress.h> #include <binder/RpcSession.h> #include <utils/Errors.h> #include <utils/RefBase.h> @@ -44,7 +45,7 @@ class RpcSocketAddress; * } * server->join(); */ -class RpcServer final : public virtual RefBase { +class RpcServer final : public virtual RefBase, private RpcSession::EventListener { public: static sp<RpcServer> make(); @@ -97,7 +98,7 @@ public: * * If this is not specified, this will be a single-threaded server. * - * TODO(b/185167543): these are currently created per client, but these + * TODO(b/167966510): these are currently created per client, but these * should be shared. */ void setMaxThreads(size_t threads); @@ -117,17 +118,31 @@ public: sp<IBinder> getRootObject(); /** + * Runs join() in a background thread. Immediately returns. + */ + void start(); + + /** * You must have at least one client session before calling this. * - * TODO(b/185167543): way to shut down? + * If a client needs to actively terminate join, call shutdown() in a separate thread. + * + * At any given point, there can only be one thread calling join(). + * + * Warning: if shutdown is called, this will return while the shutdown is + * still occurring. To ensure that the service is fully shutdown, you might + * want to call shutdown after 'join' returns. */ void join(); /** - * Accept one connection on this server. You must have at least one client - * session before calling this. + * Shut down any existing join(). Return true if successfully shut down, false otherwise + * (e.g. no join() is running). Will wait for the server to be fully + * shutdown. + * + * Warning: this will hang if it is called from its own thread. */ - [[nodiscard]] bool acceptOne(); + [[nodiscard]] bool shutdown(); /** * For debugging! @@ -137,28 +152,29 @@ public: ~RpcServer(); - // internal use only - - void onSessionTerminating(const sp<RpcSession>& session); - private: friend sp<RpcServer>; RpcServer(); - void establishConnection(sp<RpcServer>&& session, base::unique_fd clientFd); + void onSessionLockedAllIncomingThreadsEnded(const sp<RpcSession>& session) override; + void onSessionIncomingThreadEnded() override; + + static void establishConnection(sp<RpcServer>&& server, base::unique_fd clientFd); bool setupSocketServer(const RpcSocketAddress& address); bool mAgreedExperimental = false; - bool mStarted = false; // TODO(b/185167543): support dynamically added clients size_t mMaxThreads = 1; base::unique_fd mServer; // socket we are accepting sessions on std::mutex mLock; // for below + std::unique_ptr<std::thread> mJoinThread; + bool mJoinThreadRunning = false; std::map<std::thread::id, std::thread> mConnectingThreads; sp<IBinder> mRootObject; wp<IBinder> mRootObjectWeak; - std::map<int32_t, sp<RpcSession>> mSessions; - int32_t mSessionIdCounter = 0; + std::map<RpcAddress, sp<RpcSession>> mSessions; + std::unique_ptr<RpcSession::FdTrigger> mShutdownTrigger; + std::condition_variable mShutdownCv; }; } // namespace android diff --git a/libs/binder/include/binder/RpcSession.h b/libs/binder/include/binder/RpcSession.h index bcc213c8bd..69c2a1a956 100644 --- a/libs/binder/include/binder/RpcSession.h +++ b/libs/binder/include/binder/RpcSession.h @@ -47,6 +47,19 @@ public: static sp<RpcSession> make(); /** + * Set the maximum number of threads allowed to be made (for things like callbacks). + * By default, this is 0. This must be called before setting up this connection as a client. + * Server sessions will inherits this value from RpcServer. + * + * If this is called, 'shutdown' on this session must also be called. + * Otherwise, a threadpool will leak. + * + * TODO(b/189955605): start these dynamically + */ + void setMaxThreads(size_t threads); + size_t getMaxThreads(); + + /** * This should be called once per thread, matching 'join' in the remote * process. */ @@ -83,42 +96,98 @@ public: */ status_t getRemoteMaxThreads(size_t* maxThreads); - [[nodiscard]] status_t transact(const RpcAddress& address, uint32_t code, const Parcel& data, + /** + * Shuts down the service. + * + * For client sessions, wait can be true or false. For server sessions, + * waiting is not currently supported (will abort). + * + * Warning: this is currently not active/nice (the server isn't told we're + * shutting down). Being nicer to the server could potentially make it + * reclaim resources faster. + * + * If this is called w/ 'wait' true, then this will wait for shutdown to + * complete before returning. This will hang if it is called from the + * session threadpool (when processing received calls). + */ + [[nodiscard]] bool shutdownAndWait(bool wait); + + [[nodiscard]] status_t transact(const sp<IBinder>& binder, uint32_t code, const Parcel& data, Parcel* reply, uint32_t flags); [[nodiscard]] status_t sendDecStrong(const RpcAddress& address); ~RpcSession(); - wp<RpcServer> server(); + /** + * Server if this session is created as part of a server (symmetrical to + * client servers). Otherwise, nullptr. + */ + sp<RpcServer> server(); // internal only const std::unique_ptr<RpcState>& state() { return mState; } - class PrivateAccessorForId { - private: - friend class RpcSession; - friend class RpcState; - explicit PrivateAccessorForId(const RpcSession* session) : mSession(session) {} - - const std::optional<int32_t> get() { return mSession->mId; } - - const RpcSession* mSession; - }; - PrivateAccessorForId getPrivateAccessorForId() const { return PrivateAccessorForId(this); } - private: - friend PrivateAccessorForId; friend sp<RpcSession>; friend RpcServer; + friend RpcState; RpcSession(); - status_t readId(); + /** This is not a pipe. */ + struct FdTrigger { + /** Returns nullptr for error case */ + static std::unique_ptr<FdTrigger> make(); + + /** + * Close the write end of the pipe so that the read end receives POLLHUP. + * Not threadsafe. + */ + void trigger(); + + /** + * Whether this has been triggered. + */ + bool isTriggered(); + + /** + * Poll for a read event. + * + * Return: + * true - time to read! + * false - trigger happened + */ + status_t triggerablePollRead(base::borrowed_fd fd); + + /** + * Read, but allow the read to be interrupted by this trigger. + * + * Return: + * true - read succeeded at 'size' + * false - interrupted (failure or trigger) + */ + status_t interruptableReadFully(base::borrowed_fd fd, void* data, size_t size); - // transfer ownership of thread - void preJoin(std::thread thread); - // join on thread passed to preJoin - void join(base::unique_fd client); - void terminateLocked(); + private: + base::unique_fd mWrite; + base::unique_fd mRead; + }; + + class EventListener : public virtual RefBase { + public: + virtual void onSessionLockedAllIncomingThreadsEnded(const sp<RpcSession>& session) = 0; + virtual void onSessionIncomingThreadEnded() = 0; + }; + + class WaitForShutdownListener : public EventListener { + public: + void onSessionLockedAllIncomingThreadsEnded(const sp<RpcSession>& session) override; + void onSessionIncomingThreadEnded() override; + void waitForShutdown(std::unique_lock<std::mutex>& lock); + + private: + std::condition_variable mCv; + bool mShutdown = false; + }; struct RpcConnection : public RefBase { base::unique_fd fd; @@ -126,14 +195,40 @@ private: // whether this or another thread is currently using this fd to make // or receive transactions. std::optional<pid_t> exclusiveTid; + + bool allowNested = false; }; - bool setupSocketClient(const RpcSocketAddress& address); - bool setupOneSocketClient(const RpcSocketAddress& address, int32_t sessionId); - void addClientConnection(base::unique_fd fd); - void setForServer(const wp<RpcServer>& server, int32_t sessionId); - sp<RpcConnection> assignServerToThisThread(base::unique_fd fd); - bool removeServerConnection(const sp<RpcConnection>& connection); + status_t readId(); + + // A thread joining a server must always call these functions in order, and + // cleanup is only programmed once into join. These are in separate + // functions in order to allow for different locks to be taken during + // different parts of setup. + // + // transfer ownership of thread (usually done while a lock is taken on the + // structure which originally owns the thread) + void preJoinThreadOwnership(std::thread thread); + // pass FD to thread and read initial connection information + struct PreJoinSetupResult { + // Server connection object associated with this + sp<RpcConnection> connection; + // Status of setup + status_t status; + }; + PreJoinSetupResult preJoinSetup(base::unique_fd fd); + // join on thread passed to preJoinThreadOwnership + static void join(sp<RpcSession>&& session, PreJoinSetupResult&& result); + + [[nodiscard]] bool setupSocketClient(const RpcSocketAddress& address); + [[nodiscard]] bool setupOneSocketConnection(const RpcSocketAddress& address, + const RpcAddress& sessionId, bool server); + [[nodiscard]] bool addOutgoingConnection(base::unique_fd fd, bool init); + [[nodiscard]] bool setForServer(const wp<RpcServer>& server, + const wp<RpcSession::EventListener>& eventListener, + const RpcAddress& sessionId); + sp<RpcConnection> assignIncomingConnectionToThisThread(base::unique_fd fd); + [[nodiscard]] bool removeIncomingConnection(const sp<RpcConnection>& connection); enum class ConnectionUse { CLIENT, @@ -141,12 +236,14 @@ private: CLIENT_REFCOUNT, }; - // RAII object for session connection + // Object representing exclusive access to a connection. class ExclusiveConnection { public: - explicit ExclusiveConnection(const sp<RpcSession>& session, ConnectionUse use); + static status_t find(const sp<RpcSession>& session, ConnectionUse use, + ExclusiveConnection* connection); + ~ExclusiveConnection(); - const base::unique_fd& fd() { return mConnection->fd; } + const sp<RpcConnection>& get() { return mConnection; } private: static void findConnection(pid_t tid, sp<RpcConnection>* exclusive, @@ -163,13 +260,13 @@ private: bool mReentrant = false; }; - // On the other side of a session, for each of mClientConnections here, there should - // be one of mServerConnections on the other side (and vice versa). + // On the other side of a session, for each of mOutgoingConnections here, there should + // be one of mIncomingConnections on the other side (and vice versa). // // For the simplest session, a single server with one client, you would // have: - // - the server has a single 'mServerConnections' and a thread listening on this - // - the client has a single 'mClientConnections' and makes calls to this + // - the server has a single 'mIncomingConnections' and a thread listening on this + // - the client has a single 'mOutgoingConnections' and makes calls to this // - here, when the client makes a call, the server can call back into it // (nested calls), but outside of this, the client will only ever read // calls from the server when it makes a call itself. @@ -178,27 +275,26 @@ private: // serve calls to the server at all times (e.g. if it hosts a callback) wp<RpcServer> mForServer; // maybe null, for client sessions + sp<WaitForShutdownListener> mShutdownListener; // used for client sessions + wp<EventListener> mEventListener; // mForServer if server, mShutdownListener if client - // TODO(b/183988761): this shouldn't be guessable - std::optional<int32_t> mId; + std::optional<RpcAddress> mId; + + std::unique_ptr<FdTrigger> mShutdownTrigger; std::unique_ptr<RpcState> mState; std::mutex mMutex; // for all below + size_t mMaxThreads = 0; + std::condition_variable mAvailableConnectionCv; // for mWaitingThreads size_t mWaitingThreads = 0; // hint index into clients, ++ when sending an async transaction - size_t mClientConnectionsOffset = 0; - std::vector<sp<RpcConnection>> mClientConnections; - std::vector<sp<RpcConnection>> mServerConnections; - - // TODO(b/185167543): use for reverse sessions (allow client to also - // serve calls on a session). - // TODO(b/185167543): allow sharing between different sessions in a - // process? (or combine with mServerConnections) + size_t mOutgoingConnectionsOffset = 0; + std::vector<sp<RpcConnection>> mOutgoingConnections; + std::vector<sp<RpcConnection>> mIncomingConnections; std::map<std::thread::id, std::thread> mThreads; - bool mTerminated = false; }; } // namespace android diff --git a/libs/binder/include/binder/Stability.h b/libs/binder/include/binder/Stability.h index f4bfac890a..629b565985 100644 --- a/libs/binder/include/binder/Stability.h +++ b/libs/binder/include/binder/Stability.h @@ -100,7 +100,7 @@ public: static void markVintf(IBinder* binder); // WARNING: for debugging only - static void debugLogStability(const std::string& tag, const sp<IBinder>& binder); + static std::string debugToString(const sp<IBinder>& binder); // WARNING: This is only ever expected to be called by auto-generated code or tests. // You likely want to change or modify the stability of the interface you are using. @@ -136,14 +136,15 @@ private: VINTF = 0b111111, }; - // This is the format of stability passed on the wire. + // This is the format of stability passed on the wire. It is only 2 bytes + // long, but 2 bytes in addition to this are reserved here. The difference + // in size is in order to free up space in BBinder, which is fixed by + // prebuilts inheriting from it. struct Category { - static inline Category fromRepr(int32_t representation) { + static inline Category fromRepr(int16_t representation) { return *reinterpret_cast<Category*>(&representation); } - int32_t repr() const { - return *reinterpret_cast<const int32_t*>(this); - } + int16_t repr() const { return *reinterpret_cast<const int16_t*>(this); } static inline Category currentFromLevel(Level level); bool operator== (const Category& o) const { @@ -161,12 +162,10 @@ private: // class must write parcels according to the version documented here. uint8_t version; - uint8_t reserved[2]; - // bitmask of Stability::Level Level level; }; - static_assert(sizeof(Category) == sizeof(int32_t)); + static_assert(sizeof(Category) == sizeof(int16_t)); // returns the stability according to how this was built static Level getLocalLevel(); diff --git a/libs/binder/libbinder.arm32.map b/libs/binder/libbinder.arm32.map deleted file mode 100644 index 64fdd910a8..0000000000 --- a/libs/binder/libbinder.arm32.map +++ /dev/null @@ -1,1615 +0,0 @@ -LIBBINDER { - global: - getBinderKernelReferences; - kDefaultDriver; - _ZN7android10AllocationC1ERKNS_2spINS_12MemoryDealerEEERKNS1_INS_11IMemoryHeapEEEij; - _ZN7android10AllocationC2ERKNS_2spINS_12MemoryDealerEEERKNS1_INS_11IMemoryHeapEEEij; - _ZN7android10AllocationD0Ev; - _ZN7android10AllocationD1Ev; - _ZN7android10AllocationD2Ev; - _ZN7android10IInterface8asBinderEPKS0_; - _ZN7android10IInterface8asBinderERKNS_2spIS0_EE; - _ZN7android10IInterfaceC2Ev; - _ZN7android10IInterfaceD0Ev; - _ZN7android10IInterfaceD1Ev; - _ZN7android10IInterfaceD2Ev; - _ZN7android10MemoryBaseC1ERKNS_2spINS_11IMemoryHeapEEEij; - _ZN7android10MemoryBaseC2ERKNS_2spINS_11IMemoryHeapEEEij; - _ZN7android10MemoryBaseD0Ev; - _ZN7android10MemoryBaseD1Ev; - _ZN7android10MemoryBaseD2Ev; - _ZN7android10RpcAddress14readFromParcelERKNS_6ParcelE; - _ZN7android10RpcAddress15fromRawEmbeddedEPKNS_14RpcWireAddressE; - _ZN7android10RpcAddress4zeroEv; - _ZN7android10RpcAddress6uniqueEv; - _ZN7android10RpcAddressC1Ev; - _ZN7android10RpcAddressC2Ev; - _ZN7android10RpcAddressD1Ev; - _ZN7android10RpcAddressD2Ev; - _ZN7android10RpcSession12setForServerERKNS_2wpINS_9RpcServerEEEi; - _ZN7android10RpcSession13getRootObjectEv; - _ZN7android10RpcSession13sendDecStrongERKNS_10RpcAddressE; - _ZN7android10RpcSession15setupInetClientEPKcj; - _ZN7android10RpcSession15terminateLockedEv; - _ZN7android10RpcSession16setupVsockClientEjj; - _ZN7android10RpcSession17setupSocketClientERKNS_16RpcSocketAddressE; - _ZN7android10RpcSession19addClientConnectionENS_4base14unique_fd_implINS1_13DefaultCloserEEE; - _ZN7android10RpcSession19ExclusiveConnection14findConnectionEiPNS_2spINS0_13RpcConnectionEEES5_RNSt3__16vectorIS4_NS6_9allocatorIS4_EEEEj; - _ZN7android10RpcSession19ExclusiveConnectionC1ERKNS_2spIS0_EENS0_13ConnectionUseE; - _ZN7android10RpcSession19ExclusiveConnectionC2ERKNS_2spIS0_EENS0_13ConnectionUseE; - _ZN7android10RpcSession19ExclusiveConnectionD1Ev; - _ZN7android10RpcSession19ExclusiveConnectionD2Ev; - _ZN7android10RpcSession19getRemoteMaxThreadsEPj; - _ZN7android10RpcSession20setupOneSocketClientERKNS_16RpcSocketAddressEi; - _ZN7android10RpcSession21setupUnixDomainClientEPKc; - _ZN7android10RpcSession22addNullDebuggingClientEv; - _ZN7android10RpcSession22removeServerConnectionERKNS_2spINS0_13RpcConnectionEEE; - _ZN7android10RpcSession24assignServerToThisThreadENS_4base14unique_fd_implINS1_13DefaultCloserEEE; - _ZN7android10RpcSession4joinENS_4base14unique_fd_implINS1_13DefaultCloserEEE; - _ZN7android10RpcSession4makeEv; - _ZN7android10RpcSession6readIdEv; - _ZN7android10RpcSession6serverEv; - _ZN7android10RpcSession7preJoinENSt3__16threadE; - _ZN7android10RpcSession8transactERKNS_10RpcAddressEjRKNS_6ParcelEPS4_j; - _ZN7android10RpcSessionC1Ev; - _ZN7android10RpcSessionC2Ev; - _ZN7android10RpcSessionD0Ev; - _ZN7android10RpcSessionD1Ev; - _ZN7android10RpcSessionD2Ev; - _ZN7android10TextOutputC2Ev; - _ZN7android10TextOutputD0Ev; - _ZN7android10TextOutputD1Ev; - _ZN7android10TextOutputD2Ev; - _ZN7android10zeroMemoryEPhj; - _ZN7android11BnInterfaceINS_11IMemoryHeapEE10onAsBinderEv; - _ZN7android11BnInterfaceINS_14IShellCallbackEE10onAsBinderEv; - _ZN7android11BnInterfaceINS_15IResultReceiverEE10onAsBinderEv; - _ZN7android11BnInterfaceINS_21IPermissionControllerEE10onAsBinderEv; - _ZN7android11BnInterfaceINS_2os15IClientCallbackEE10onAsBinderEv; - _ZN7android11BnInterfaceINS_2os15IServiceManagerEE10onAsBinderEv; - _ZN7android11BnInterfaceINS_2os16IServiceCallbackEE10onAsBinderEv; - _ZN7android11BnInterfaceINS_7content2pm21IPackageManagerNativeEE10onAsBinderEv; - _ZN7android11BnInterfaceINS_7content2pm22IPackageChangeObserverEE10onAsBinderEv; - _ZN7android11BnInterfaceINS_7IMemoryEE10onAsBinderEv; - _ZN7android11IMemoryHeap10descriptorE; - _ZN7android11IMemoryHeap11asInterfaceERKNS_2spINS_7IBinderEEE; - _ZN7android11IMemoryHeap12default_implE; - _ZN7android11IMemoryHeap14getDefaultImplEv; - _ZN7android11IMemoryHeap14setDefaultImplENSt3__110unique_ptrIS0_NS1_14default_deleteIS0_EEEE; - _ZN7android11IMemoryHeapC2Ev; - _ZN7android11IMemoryHeapD0Ev; - _ZN7android11IMemoryHeapD1Ev; - _ZN7android11IMemoryHeapD2Ev; - _ZN7android12BnMemoryHeap10onTransactEjRKNS_6ParcelEPS1_j; - _ZN7android12BnMemoryHeapC2Ev; - _ZN7android12BnMemoryHeapD0Ev; - _ZN7android12BnMemoryHeapD1Ev; - _ZN7android12BnMemoryHeapD2Ev; - _ZN7android12BpMemoryHeapC1ERKNS_2spINS_7IBinderEEE; - _ZN7android12BpMemoryHeapC2ERKNS_2spINS_7IBinderEEE; - _ZN7android12BpMemoryHeapD0Ev; - _ZN7android12BpMemoryHeapD1Ev; - _ZN7android12BpMemoryHeapD2Ev; - _ZN7android12gTextBuffersE; - _ZN7android12MemoryDealer10deallocateEj; - _ZN7android12MemoryDealer22getAllocationAlignmentEv; - _ZN7android12MemoryDealer8allocateEj; - _ZN7android12MemoryDealerC1EjPKcj; - _ZN7android12MemoryDealerC2EjPKcj; - _ZN7android12MemoryDealerD0Ev; - _ZN7android12MemoryDealerD1Ev; - _ZN7android12MemoryDealerD2Ev; - _ZN7android12printHexDataEiPKvjjijbPFvPvPKcES2_; - _ZN7android12ProcessState10selfOrNullEv; - _ZN7android12ProcessState13expungeHandleEiPNS_7IBinderE; - _ZN7android12ProcessState13getDriverNameEv; - _ZN7android12ProcessState14initWithDriverEPKc; - _ZN7android12ProcessState15startThreadPoolEv; - _ZN7android12ProcessState16getContextObjectERKNS_2spINS_7IBinderEEE; - _ZN7android12ProcessState17spawnPooledThreadEb; - _ZN7android12ProcessState18giveThreadPoolNameEv; - _ZN7android12ProcessState18lookupHandleLockedEi; - _ZN7android12ProcessState18setCallRestrictionENS0_15CallRestrictionE; - _ZN7android12ProcessState19getKernelReferencesEjPj; - _ZN7android12ProcessState20becomeContextManagerEv; - _ZN7android12ProcessState20makeBinderThreadNameEv; - _ZN7android12ProcessState23getStrongProxyForHandleEi; - _ZN7android12ProcessState24getStrongRefCountForNodeERKNS_2spINS_8BpBinderEEE; - _ZN7android12ProcessState25enableOnewaySpamDetectionEb; - _ZN7android12ProcessState27setThreadPoolMaxThreadCountEj; - _ZN7android12ProcessState4initEPKcb; - _ZN7android12ProcessState4selfEv; - _ZN7android12ProcessStateC1EPKc; - _ZN7android12ProcessStateC2EPKc; - _ZN7android12ProcessStateD0Ev; - _ZN7android12ProcessStateD1Ev; - _ZN7android12ProcessStateD2Ev; - _ZN7android13printTypeCodeEjPFvPvPKcES0_; - _ZN7android14IPCThreadState10freeBufferEPNS_6ParcelEPKhjPKyj; - _ZN7android14IPCThreadState10selfOrNullEv; - _ZN7android14IPCThreadState11clearCallerEv; - _ZN7android14IPCThreadState11stopProcessEb; - _ZN7android14IPCThreadState12setupPollingEPi; - _ZN7android14IPCThreadState13decWeakHandleEi; - _ZN7android14IPCThreadState13expungeHandleEiPNS_7IBinderE; - _ZN7android14IPCThreadState13flushCommandsEv; - _ZN7android14IPCThreadState13flushIfNeededEv; - _ZN7android14IPCThreadState13incWeakHandleEiPNS_8BpBinderE; - _ZN7android14IPCThreadState14clearLastErrorEv; - _ZN7android14IPCThreadState14executeCommandEi; - _ZN7android14IPCThreadState14joinThreadPoolEb; - _ZN7android14IPCThreadState14talkWithDriverEb; - _ZN7android14IPCThreadState15decStrongHandleEi; - _ZN7android14IPCThreadState15incStrongHandleEiPNS_8BpBinderE; - _ZN7android14IPCThreadState15waitForResponseEPNS_6ParcelEPi; - _ZN7android14IPCThreadState16threadDestructorEPv; - _ZN7android14IPCThreadState18setCallRestrictionENS_12ProcessState15CallRestrictionE; - _ZN7android14IPCThreadState19setStrictModePolicyEi; - _ZN7android14IPCThreadState19setTheContextObjectERKNS_2spINS_7BBinderEEE; - _ZN7android14IPCThreadState20clearCallingIdentityEv; - _ZN7android14IPCThreadState20getAndExecuteCommandEv; - _ZN7android14IPCThreadState20getProcessFreezeInfoEiPbS1_; - _ZN7android14IPCThreadState20handlePolledCommandsEv; - _ZN7android14IPCThreadState20processPendingDerefsEv; - _ZN7android14IPCThreadState20writeTransactionDataEijijRKNS_6ParcelEPi; - _ZN7android14IPCThreadState22attemptIncStrongHandleEi; - _ZN7android14IPCThreadState22clearCallingWorkSourceEv; - _ZN7android14IPCThreadState22clearDeathNotificationEiPNS_8BpBinderE; - _ZN7android14IPCThreadState22processPostWriteDerefsEv; - _ZN7android14IPCThreadState22restoreCallingIdentityEx; - _ZN7android14IPCThreadState23setCallingWorkSourceUidEj; - _ZN7android14IPCThreadState24clearPropagateWorkSourceEv; - _ZN7android14IPCThreadState24requestDeathNotificationEiPNS_8BpBinderE; - _ZN7android14IPCThreadState24restoreCallingWorkSourceEx; - _ZN7android14IPCThreadState25blockUntilThreadAvailableEv; - _ZN7android14IPCThreadState27disableBackgroundSchedulingEb; - _ZN7android14IPCThreadState28backgroundSchedulingDisabledEv; - _ZN7android14IPCThreadState29setLastTransactionBinderFlagsEi; - _ZN7android14IPCThreadState41setCallingWorkSourceUidWithoutPropagationEj; - _ZN7android14IPCThreadState4selfEv; - _ZN7android14IPCThreadState6freezeEibj; - _ZN7android14IPCThreadState7processEv; - _ZN7android14IPCThreadState8shutdownEv; - _ZN7android14IPCThreadState8transactEijRKNS_6ParcelEPS1_j; - _ZN7android14IPCThreadState9sendReplyERKNS_6ParcelEj; - _ZN7android14IPCThreadStateC1Ev; - _ZN7android14IPCThreadStateC2Ev; - _ZN7android14IPCThreadStateD1Ev; - _ZN7android14IPCThreadStateD2Ev; - _ZN7android14IShellCallback10descriptorE; - _ZN7android14IShellCallback11asInterfaceERKNS_2spINS_7IBinderEEE; - _ZN7android14IShellCallback12default_implE; - _ZN7android14IShellCallback14getDefaultImplEv; - _ZN7android14IShellCallback14setDefaultImplENSt3__110unique_ptrIS0_NS1_14default_deleteIS0_EEEE; - _ZN7android14IShellCallbackC2Ev; - _ZN7android14IShellCallbackD0Ev; - _ZN7android14IShellCallbackD1Ev; - _ZN7android14IShellCallbackD2Ev; - _ZN7android14MemoryHeapBase4initEiPvjiPKc; - _ZN7android14MemoryHeapBase5mapfdEibjl; - _ZN7android14MemoryHeapBase7disposeEv; - _ZN7android14MemoryHeapBaseC1Eijjl; - _ZN7android14MemoryHeapBaseC1EjjPKc; - _ZN7android14MemoryHeapBaseC1EPKcjj; - _ZN7android14MemoryHeapBaseC1Ev; - _ZN7android14MemoryHeapBaseC2Eijjl; - _ZN7android14MemoryHeapBaseC2EjjPKc; - _ZN7android14MemoryHeapBaseC2EPKcjj; - _ZN7android14MemoryHeapBaseC2Ev; - _ZN7android14MemoryHeapBaseD0Ev; - _ZN7android14MemoryHeapBaseD1Ev; - _ZN7android14MemoryHeapBaseD2Ev; - _ZN7android15BnShellCallback10onTransactEjRKNS_6ParcelEPS1_j; - _ZN7android15checkPermissionERKNS_8String16Eij; - _ZN7android15IResultReceiver10descriptorE; - _ZN7android15IResultReceiver11asInterfaceERKNS_2spINS_7IBinderEEE; - _ZN7android15IResultReceiver12default_implE; - _ZN7android15IResultReceiver14getDefaultImplEv; - _ZN7android15IResultReceiver14setDefaultImplENSt3__110unique_ptrIS0_NS1_14default_deleteIS0_EEEE; - _ZN7android15IResultReceiverC2Ev; - _ZN7android15IResultReceiverD0Ev; - _ZN7android15IResultReceiverD1Ev; - _ZN7android15IResultReceiverD2Ev; - _ZN7android15IServiceManagerC2Ev; - _ZN7android15IServiceManagerD0Ev; - _ZN7android15IServiceManagerD1Ev; - _ZN7android15IServiceManagerD2Ev; - _ZN7android15PermissionCache10purgeCacheEv; - _ZN7android15PermissionCache15checkPermissionERKNS_8String16Eij; - _ZN7android15PermissionCache22checkCallingPermissionERKNS_8String16E; - _ZN7android15PermissionCache22checkCallingPermissionERKNS_8String16EPiS4_; - _ZN7android15PermissionCache5cacheERKNS_8String16Ejb; - _ZN7android15PermissionCache5purgeEv; - _ZN7android15PermissionCacheC1Ev; - _ZN7android15PermissionCacheC2Ev; - _ZN7android15stringForIndentEi; - _ZN7android16BnResultReceiver10onTransactEjRKNS_6ParcelEPS1_j; - _ZN7android18BufferedTextOutput10moveIndentEi; - _ZN7android18BufferedTextOutput10pushBundleEv; - _ZN7android18BufferedTextOutput5printEPKcj; - _ZN7android18BufferedTextOutput9popBundleEv; - _ZN7android18BufferedTextOutputC2Ej; - _ZN7android18BufferedTextOutputD0Ev; - _ZN7android18BufferedTextOutputD1Ev; - _ZN7android18BufferedTextOutputD2Ev; - _ZN7android18ServiceManagerShim10addServiceERKNS_8String16ERKNS_2spINS_7IBinderEEEbi; - _ZN7android18ServiceManagerShim10isDeclaredERKNS_8String16E; - _ZN7android18ServiceManagerShim12listServicesEi; - _ZN7android18ServiceManagerShim14waitForServiceERKNS_8String16E; - _ZN7android18ServiceManagerShim16updatableViaApexERKNS_8String16E; - _ZN7android18ServiceManagerShim20getDeclaredInstancesERKNS_8String16E; - _ZN7android18ServiceManagerShimC1ERKNS_2spINS_2os15IServiceManagerEEE; - _ZN7android18ServiceManagerShimC2ERKNS_2spINS_2os15IServiceManagerEEE; - _ZN7android18the_context_objectE; - _ZN7android20PermissionController10getServiceEv; - _ZN7android20PermissionController13getPackageUidERKNS_8String16Ei; - _ZN7android20PermissionController15checkPermissionERKNS_8String16Eii; - _ZN7android20PermissionController17getPackagesForUidEjRNS_6VectorINS_8String16EEE; - _ZN7android20PermissionController19isRuntimePermissionERKNS_8String16E; - _ZN7android20PermissionController6noteOpERKNS_8String16EiS3_; - _ZN7android20PermissionControllerC1Ev; - _ZN7android20PermissionControllerC2Ev; - _ZN7android21defaultServiceManagerEv; - _ZN7android21IPermissionController10descriptorE; - _ZN7android21IPermissionController11asInterfaceERKNS_2spINS_7IBinderEEE; - _ZN7android21IPermissionController12default_implE; - _ZN7android21IPermissionController14getDefaultImplEv; - _ZN7android21IPermissionController14setDefaultImplENSt3__110unique_ptrIS0_NS1_14default_deleteIS0_EEEE; - _ZN7android21IPermissionControllerC2Ev; - _ZN7android21IPermissionControllerD0Ev; - _ZN7android21IPermissionControllerD1Ev; - _ZN7android21IPermissionControllerD2Ev; - _ZN7android22BnPermissionController10onTransactEjRKNS_6ParcelEPS1_j; - _ZN7android22checkCallingPermissionERKNS_8String16E; - _ZN7android22checkCallingPermissionERKNS_8String16EPiS3_; - _ZN7android22SimpleBestFitAllocator10deallocateEj; - _ZN7android22SimpleBestFitAllocator12kMemoryAlignE; - _ZN7android22SimpleBestFitAllocator5allocEjj; - _ZN7android22SimpleBestFitAllocator7deallocEj; - _ZN7android22SimpleBestFitAllocator8allocateEjj; - _ZN7android22SimpleBestFitAllocatorC1Ej; - _ZN7android22SimpleBestFitAllocatorC2Ej; - _ZN7android22SimpleBestFitAllocatorD1Ev; - _ZN7android22SimpleBestFitAllocatorD2Ev; - _ZN7android24setDefaultServiceManagerERKNS_2spINS_15IServiceManagerEEE; - _ZN7android2os15IClientCallback10descriptorE; - _ZN7android2os15IClientCallback11asInterfaceERKNS_2spINS_7IBinderEEE; - _ZN7android2os15IClientCallback12default_implE; - _ZN7android2os15IClientCallback14getDefaultImplEv; - _ZN7android2os15IClientCallback14setDefaultImplENSt3__110unique_ptrIS1_NS2_14default_deleteIS1_EEEE; - _ZN7android2os15IClientCallbackC2Ev; - _ZN7android2os15IClientCallbackD0Ev; - _ZN7android2os15IClientCallbackD1Ev; - _ZN7android2os15IClientCallbackD2Ev; - _ZN7android2os15IServiceManager10descriptorE; - _ZN7android2os15IServiceManager11asInterfaceERKNS_2spINS_7IBinderEEE; - _ZN7android2os15IServiceManager12default_implE; - _ZN7android2os15IServiceManager14getDefaultImplEv; - _ZN7android2os15IServiceManager14setDefaultImplENSt3__110unique_ptrIS1_NS2_14default_deleteIS1_EEEE; - _ZN7android2os15IServiceManagerC2Ev; - _ZN7android2os15IServiceManagerD0Ev; - _ZN7android2os15IServiceManagerD1Ev; - _ZN7android2os15IServiceManagerD2Ev; - _ZN7android2os16BnClientCallback10onTransactEjRKNS_6ParcelEPS2_j; - _ZN7android2os16BnClientCallbackC2Ev; - _ZN7android2os16BnServiceManager10onTransactEjRKNS_6ParcelEPS2_j; - _ZN7android2os16BnServiceManagerC2Ev; - _ZN7android2os16BpClientCallback9onClientsERKNS_2spINS_7IBinderEEEb; - _ZN7android2os16BpClientCallbackC1ERKNS_2spINS_7IBinderEEE; - _ZN7android2os16BpClientCallbackC2ERKNS_2spINS_7IBinderEEE; - _ZN7android2os16BpServiceManager10addServiceERKNSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEERKNS_2spINS_7IBinderEEEbi; - _ZN7android2os16BpServiceManager10getServiceERKNSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEPNS_2spINS_7IBinderEEE; - _ZN7android2os16BpServiceManager10isDeclaredERKNSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEPb; - _ZN7android2os16BpServiceManager12checkServiceERKNSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEPNS_2spINS_7IBinderEEE; - _ZN7android2os16BpServiceManager12listServicesEiPNSt3__16vectorINS2_12basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEENS7_IS9_EEEE; - _ZN7android2os16BpServiceManager16updatableViaApexERKNSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEPNS2_8optionalIS8_EE; - _ZN7android2os16BpServiceManager19getServiceDebugInfoEPNSt3__16vectorINS0_16ServiceDebugInfoENS2_9allocatorIS4_EEEE; - _ZN7android2os16BpServiceManager20getDeclaredInstancesERKNSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEPNS2_6vectorIS8_NS6_IS8_EEEE; - _ZN7android2os16BpServiceManager20tryUnregisterServiceERKNSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEERKNS_2spINS_7IBinderEEE; - _ZN7android2os16BpServiceManager22registerClientCallbackERKNSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEERKNS_2spINS_7IBinderEEERKNSB_INS0_15IClientCallbackEEE; - _ZN7android2os16BpServiceManager24registerForNotificationsERKNSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEERKNS_2spINS0_16IServiceCallbackEEE; - _ZN7android2os16BpServiceManager26unregisterForNotificationsERKNSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEERKNS_2spINS0_16IServiceCallbackEEE; - _ZN7android2os16BpServiceManagerC1ERKNS_2spINS_7IBinderEEE; - _ZN7android2os16BpServiceManagerC2ERKNS_2spINS_7IBinderEEE; - _ZN7android2os16IServiceCallback10descriptorE; - _ZN7android2os16IServiceCallback11asInterfaceERKNS_2spINS_7IBinderEEE; - _ZN7android2os16IServiceCallback12default_implE; - _ZN7android2os16IServiceCallback14getDefaultImplEv; - _ZN7android2os16IServiceCallback14setDefaultImplENSt3__110unique_ptrIS1_NS2_14default_deleteIS1_EEEE; - _ZN7android2os16IServiceCallbackC2Ev; - _ZN7android2os16IServiceCallbackD0Ev; - _ZN7android2os16IServiceCallbackD1Ev; - _ZN7android2os16IServiceCallbackD2Ev; - _ZN7android2os16ParcelableHolder14readFromParcelEPKNS_6ParcelE; - _ZN7android2os16ServiceDebugInfo14readFromParcelEPKNS_6ParcelE; - _ZN7android2os17BnServiceCallback10onTransactEjRKNS_6ParcelEPS2_j; - _ZN7android2os17BnServiceCallbackC2Ev; - _ZN7android2os17BpServiceCallback14onRegistrationERKNSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEERKNS_2spINS_7IBinderEEE; - _ZN7android2os17BpServiceCallbackC1ERKNS_2spINS_7IBinderEEE; - _ZN7android2os17BpServiceCallbackC2ERKNS_2spINS_7IBinderEEE; - _ZN7android2os17PersistableBundle10putBooleanERKNS_8String16Eb; - _ZN7android2os17PersistableBundle12putIntVectorERKNS_8String16ERKNSt3__16vectorIiNS5_9allocatorIiEEEE; - _ZN7android2os17PersistableBundle13putLongVectorERKNS_8String16ERKNSt3__16vectorIxNS5_9allocatorIxEEEE; - _ZN7android2os17PersistableBundle14readFromParcelEPKNS_6ParcelE; - _ZN7android2os17PersistableBundle15putDoubleVectorERKNS_8String16ERKNSt3__16vectorIdNS5_9allocatorIdEEEE; - _ZN7android2os17PersistableBundle15putStringVectorERKNS_8String16ERKNSt3__16vectorIS2_NS5_9allocatorIS2_EEEE; - _ZN7android2os17PersistableBundle16putBooleanVectorERKNS_8String16ERKNSt3__16vectorIbNS5_9allocatorIbEEEE; - _ZN7android2os17PersistableBundle19readFromParcelInnerEPKNS_6ParcelEj; - _ZN7android2os17PersistableBundle20putPersistableBundleERKNS_8String16ERKS1_; - _ZN7android2os17PersistableBundle5eraseERKNS_8String16E; - _ZN7android2os17PersistableBundle6putIntERKNS_8String16Ei; - _ZN7android2os17PersistableBundle7putLongERKNS_8String16Ex; - _ZN7android2os17PersistableBundle9putDoubleERKNS_8String16Ed; - _ZN7android2os17PersistableBundle9putStringERKNS_8String16ES4_; - _ZN7android2os20ParcelFileDescriptor14readFromParcelEPKNS_6ParcelE; - _ZN7android2os20ParcelFileDescriptorC1ENS_4base14unique_fd_implINS2_13DefaultCloserEEE; - _ZN7android2os20ParcelFileDescriptorC1Ev; - _ZN7android2os20ParcelFileDescriptorC2ENS_4base14unique_fd_implINS2_13DefaultCloserEEE; - _ZN7android2os20ParcelFileDescriptorC2Ev; - _ZN7android2os20ParcelFileDescriptorD0Ev; - _ZN7android2os20ParcelFileDescriptorD1Ev; - _ZN7android2os20ParcelFileDescriptorD2Ev; - _ZN7android2spINS_21IPermissionControllerEED2Ev; - _ZN7android2spINS_7BBinderEED2Ev; - _ZN7android2spINS_7IBinderEEaSEOS2_; - _ZN7android2spINS_7IBinderEEaSERKS2_; - _ZN7android2spINS_9HeapCacheEED2Ev; - _ZN7android4aerrE; - _ZN7android4alogE; - _ZN7android4aoutE; - _ZN7android6binder20LazyServiceRegistrar10reRegisterEv; - _ZN7android6binder20LazyServiceRegistrar11getInstanceEv; - _ZN7android6binder20LazyServiceRegistrar12forcePersistEb; - _ZN7android6binder20LazyServiceRegistrar13tryUnregisterEv; - _ZN7android6binder20LazyServiceRegistrar15registerServiceERKNS_2spINS_7IBinderEEERKNSt3__112basic_stringIcNS7_11char_traitsIcEENS7_9allocatorIcEEEEbi; - _ZN7android6binder20LazyServiceRegistrar25setActiveServicesCallbackERKNSt3__18functionIFbbEEE; - _ZN7android6binder20LazyServiceRegistrarC1Ev; - _ZN7android6binder20LazyServiceRegistrarC2Ev; - _ZN7android6binder6Status11fromStatusTEi; - _ZN7android6binder6Status12setExceptionEiRKNS_7String8E; - _ZN7android6binder6Status14readFromParcelERKNS_6ParcelE; - _ZN7android6binder6Status14setFromStatusTEi; - _ZN7android6binder6Status17exceptionToStringEi; - _ZN7android6binder6Status17fromExceptionCodeEi; - _ZN7android6binder6Status17fromExceptionCodeEiPKc; - _ZN7android6binder6Status17fromExceptionCodeEiRKNS_7String8E; - _ZN7android6binder6Status23setServiceSpecificErrorEiRKNS_7String8E; - _ZN7android6binder6Status24fromServiceSpecificErrorEi; - _ZN7android6binder6Status24fromServiceSpecificErrorEiPKc; - _ZN7android6binder6Status24fromServiceSpecificErrorEiRKNS_7String8E; - _ZN7android6binder6Status2okEv; - _ZN7android6binder6StatusC1Eii; - _ZN7android6binder6StatusC1EiiRKNS_7String8E; - _ZN7android6binder6StatusC2Eii; - _ZN7android6binder6StatusC2EiiRKNS_7String8E; - _ZN7android6binder8internal21ClientCounterCallback10reRegisterEv; - _ZN7android6binder8internal21ClientCounterCallback12forcePersistEb; - _ZN7android6binder8internal21ClientCounterCallback13tryUnregisterEv; - _ZN7android6binder8internal21ClientCounterCallback15registerServiceERKNS_2spINS_7IBinderEEERKNSt3__112basic_stringIcNS8_11char_traitsIcEENS8_9allocatorIcEEEEbi; - _ZN7android6binder8internal21ClientCounterCallback25setActiveServicesCallbackERKNSt3__18functionIFbbEEE; - _ZN7android6binder8internal21ClientCounterCallbackC1Ev; - _ZN7android6binder8internal21ClientCounterCallbackC2Ev; - _ZN7android6binder8internal25ClientCounterCallbackImpl10reRegisterEv; - _ZN7android6binder8internal25ClientCounterCallbackImpl11tryShutdownEv; - _ZN7android6binder8internal25ClientCounterCallbackImpl12forcePersistEb; - _ZN7android6binder8internal25ClientCounterCallbackImpl13tryUnregisterEv; - _ZN7android6binder8internal25ClientCounterCallbackImpl15registerServiceERKNS_2spINS_7IBinderEEERKNSt3__112basic_stringIcNS8_11char_traitsIcEENS8_9allocatorIcEEEEbi; - _ZN7android6binder8internal25ClientCounterCallbackImpl16maybeTryShutdownEv; - _ZN7android6binder8internal25ClientCounterCallbackImpl23assertRegisteredServiceERKNS_2spINS_7IBinderEEE; - _ZN7android6binder8internal25ClientCounterCallbackImpl25setActiveServicesCallbackERKNSt3__18functionIFbbEEE; - _ZN7android6binder8internal25ClientCounterCallbackImpl9onClientsERKNS_2spINS_7IBinderEEEb; - _ZN7android6Parcel10appendFromEPKS0_jj; - _ZN7android6Parcel10markForRpcERKNS_2spINS_10RpcSessionEEE; - _ZN7android6Parcel10writeFloatEf; - _ZN7android6Parcel10writeInt32Ei; - _ZN7android6Parcel10writeInt64Ex; - _ZN7android6Parcel11compareDataERKS0_; - _ZN7android6Parcel11finishWriteEj; - _ZN7android6Parcel11setDataSizeEj; - _ZN7android6Parcel11writeDoubleEd; - _ZN7android6Parcel11writeObjectERK18flat_binder_objectb; - _ZN7android6Parcel11writeUint32Ej; - _ZN7android6Parcel11writeUint64Ey; - _ZN7android6Parcel12pushAllowFdsEb; - _ZN7android6Parcel12restartWriteEj; - _ZN7android6Parcel12writeCStringEPKc; - _ZN7android6Parcel12writeInplaceEj; - _ZN7android6Parcel12writePointerEj; - _ZN7android6Parcel12writeString8EPKcj; - _ZN7android6Parcel12writeString8ERKNS_7String8E; - _ZN7android6Parcel13continueWriteEj; - _ZN7android6Parcel13flattenBinderERKNS_2spINS_7IBinderEEE; - _ZN7android6Parcel13markForBinderERKNS_2spINS_7IBinderEEE; - _ZN7android6Parcel13writeString16EPKDsj; - _ZN7android6Parcel13writeString16ERKNS_8String16E; - _ZN7android6Parcel13writeString16ERKNSt3__110unique_ptrINS_8String16ENS1_14default_deleteIS3_EEEE; - _ZN7android6Parcel13writeString16ERKNSt3__18optionalINS_8String16EEE; - _ZN7android6Parcel13writeUnpaddedEPKvj; - _ZN7android6Parcel14acquireObjectsEv; - _ZN7android6Parcel14freeDataNoInitEv; - _ZN7android6Parcel14releaseObjectsEv; - _ZN7android6Parcel14writeByteArrayEjPKh; - _ZN7android6Parcel15restoreAllowFdsEb; - _ZN7android6Parcel15setDataCapacityEj; - _ZN7android6Parcel15writeBoolVectorERKNSt3__110unique_ptrINS1_6vectorIbNS1_9allocatorIbEEEENS1_14default_deleteIS6_EEEE; - _ZN7android6Parcel15writeBoolVectorERKNSt3__16vectorIbNS1_9allocatorIbEEEE; - _ZN7android6Parcel15writeBoolVectorERKNSt3__18optionalINS1_6vectorIbNS1_9allocatorIbEEEEEE; - _ZN7android6Parcel15writeByteVectorERKNSt3__110unique_ptrINS1_6vectorIaNS1_9allocatorIaEEEENS1_14default_deleteIS6_EEEE; - _ZN7android6Parcel15writeByteVectorERKNSt3__110unique_ptrINS1_6vectorIhNS1_9allocatorIhEEEENS1_14default_deleteIS6_EEEE; - _ZN7android6Parcel15writeByteVectorERKNSt3__16vectorIaNS1_9allocatorIaEEEE; - _ZN7android6Parcel15writeByteVectorERKNSt3__16vectorIhNS1_9allocatorIhEEEE; - _ZN7android6Parcel15writeByteVectorERKNSt3__18optionalINS1_6vectorIaNS1_9allocatorIaEEEEEE; - _ZN7android6Parcel15writeByteVectorERKNSt3__18optionalINS1_6vectorIhNS1_9allocatorIhEEEEEE; - _ZN7android6Parcel15writeCharVectorERKNSt3__110unique_ptrINS1_6vectorIDsNS1_9allocatorIDsEEEENS1_14default_deleteIS6_EEEE; - _ZN7android6Parcel15writeCharVectorERKNSt3__16vectorIDsNS1_9allocatorIDsEEEE; - _ZN7android6Parcel15writeCharVectorERKNSt3__18optionalINS1_6vectorIDsNS1_9allocatorIDsEEEEEE; - _ZN7android6Parcel15writeInt32ArrayEjPKi; - _ZN7android6Parcel15writeParcelableERKNS_10ParcelableE; - _ZN7android6Parcel16writeFloatVectorERKNSt3__110unique_ptrINS1_6vectorIfNS1_9allocatorIfEEEENS1_14default_deleteIS6_EEEE; - _ZN7android6Parcel16writeFloatVectorERKNSt3__16vectorIfNS1_9allocatorIfEEEE; - _ZN7android6Parcel16writeFloatVectorERKNSt3__18optionalINS1_6vectorIfNS1_9allocatorIfEEEEEE; - _ZN7android6Parcel16writeInt32VectorERKNSt3__110unique_ptrINS1_6vectorIiNS1_9allocatorIiEEEENS1_14default_deleteIS6_EEEE; - _ZN7android6Parcel16writeInt32VectorERKNSt3__16vectorIiNS1_9allocatorIiEEEE; - _ZN7android6Parcel16writeInt32VectorERKNSt3__18optionalINS1_6vectorIiNS1_9allocatorIiEEEEEE; - _ZN7android6Parcel16writeInt64VectorERKNSt3__110unique_ptrINS1_6vectorIxNS1_9allocatorIxEEEENS1_14default_deleteIS6_EEEE; - _ZN7android6Parcel16writeInt64VectorERKNSt3__16vectorIxNS1_9allocatorIxEEEE; - _ZN7android6Parcel16writeInt64VectorERKNSt3__18optionalINS1_6vectorIxNS1_9allocatorIxEEEEEE; - _ZN7android6Parcel16writeNoExceptionEv; - _ZN7android6Parcel16writeUtf8AsUtf16ERKNSt3__110unique_ptrINS1_12basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEENS1_14default_deleteIS8_EEEE; - _ZN7android6Parcel16writeUtf8AsUtf16ERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEE; - _ZN7android6Parcel16writeUtf8AsUtf16ERKNSt3__18optionalINS1_12basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEEE; - _ZN7android6Parcel17writeDoubleVectorERKNSt3__110unique_ptrINS1_6vectorIdNS1_9allocatorIdEEEENS1_14default_deleteIS6_EEEE; - _ZN7android6Parcel17writeDoubleVectorERKNSt3__16vectorIdNS1_9allocatorIdEEEE; - _ZN7android6Parcel17writeDoubleVectorERKNSt3__18optionalINS1_6vectorIdNS1_9allocatorIdEEEEEE; - _ZN7android6Parcel17writeNativeHandleEPK13native_handle; - _ZN7android6Parcel17writeStrongBinderERKNS_2spINS_7IBinderEEE; - _ZN7android6Parcel17writeUint64VectorERKNSt3__110unique_ptrINS1_6vectorIyNS1_9allocatorIyEEEENS1_14default_deleteIS6_EEEE; - _ZN7android6Parcel17writeUint64VectorERKNSt3__16vectorIyNS1_9allocatorIyEEEE; - _ZN7android6Parcel17writeUint64VectorERKNSt3__18optionalINS1_6vectorIyNS1_9allocatorIyEEEEEE; - _ZN7android6Parcel18getGlobalAllocSizeEv; - _ZN7android6Parcel19finishFlattenBinderERKNS_2spINS_7IBinderEEE; - _ZN7android6Parcel19getGlobalAllocCountEv; - _ZN7android6Parcel19ipcSetDataReferenceEPKhjPKyjPFvPS0_S2_jS4_jE; - _ZN7android6Parcel19writeFileDescriptorEib; - _ZN7android6Parcel19writeInterfaceTokenEPKDsj; - _ZN7android6Parcel19writeInterfaceTokenERKNS_8String16E; - _ZN7android6Parcel19writeString16VectorERKNSt3__110unique_ptrINS1_6vectorINS2_INS_8String16ENS1_14default_deleteIS4_EEEENS1_9allocatorIS7_EEEENS5_ISA_EEEE; - _ZN7android6Parcel19writeString16VectorERKNSt3__16vectorINS_8String16ENS1_9allocatorIS3_EEEE; - _ZN7android6Parcel19writeString16VectorERKNSt3__18optionalINS1_6vectorINS2_INS_8String16EEENS1_9allocatorIS5_EEEEEE; - _ZN7android6Parcel20closeFileDescriptorsEv; - _ZN7android6Parcel22writeDupFileDescriptorEi; - _ZN7android6Parcel23writeStrongBinderVectorERKNSt3__110unique_ptrINS1_6vectorINS_2spINS_7IBinderEEENS1_9allocatorIS6_EEEENS1_14default_deleteIS9_EEEE; - _ZN7android6Parcel23writeStrongBinderVectorERKNSt3__16vectorINS_2spINS_7IBinderEEENS1_9allocatorIS5_EEEE; - _ZN7android6Parcel23writeStrongBinderVectorERKNSt3__18optionalINS1_6vectorINS_2spINS_7IBinderEEENS1_9allocatorIS6_EEEEEE; - _ZN7android6Parcel25writeParcelFileDescriptorEib; - _ZN7android6Parcel25writeUniqueFileDescriptorERKNS_4base14unique_fd_implINS1_13DefaultCloserEEE; - _ZN7android6Parcel26writeRawNullableParcelableEPKNS_10ParcelableE; - _ZN7android6Parcel27replaceCallingWorkSourceUidEj; - _ZN7android6Parcel28writeDupParcelFileDescriptorEi; - _ZN7android6Parcel28writeUtf8VectorAsUtf16VectorERKNSt3__110unique_ptrINS1_6vectorINS2_INS1_12basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEENS1_14default_deleteIS9_EEEENS7_ISC_EEEENSA_ISE_EEEE; - _ZN7android6Parcel28writeUtf8VectorAsUtf16VectorERKNSt3__16vectorINS1_12basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEENS6_IS8_EEEE; - _ZN7android6Parcel28writeUtf8VectorAsUtf16VectorERKNSt3__18optionalINS1_6vectorINS2_INS1_12basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEEENS7_ISA_EEEEEE; - _ZN7android6Parcel31writeUniqueFileDescriptorVectorERKNSt3__110unique_ptrINS1_6vectorINS_4base14unique_fd_implINS4_13DefaultCloserEEENS1_9allocatorIS7_EEEENS1_14default_deleteISA_EEEE; - _ZN7android6Parcel31writeUniqueFileDescriptorVectorERKNSt3__16vectorINS_4base14unique_fd_implINS3_13DefaultCloserEEENS1_9allocatorIS6_EEEE; - _ZN7android6Parcel31writeUniqueFileDescriptorVectorERKNSt3__18optionalINS1_6vectorINS_4base14unique_fd_implINS4_13DefaultCloserEEENS1_9allocatorIS7_EEEEEE; - _ZN7android6Parcel35writeDupImmutableBlobFileDescriptorEi; - _ZN7android6Parcel4Blob4initEiPvjb; - _ZN7android6Parcel4Blob5clearEv; - _ZN7android6Parcel4Blob7releaseEv; - _ZN7android6Parcel4BlobC1Ev; - _ZN7android6Parcel4BlobC2Ev; - _ZN7android6Parcel4BlobD1Ev; - _ZN7android6Parcel4BlobD2Ev; - _ZN7android6Parcel5writeEPKvj; - _ZN7android6Parcel5writeERKNS0_26FlattenableHelperInterfaceE; - _ZN7android6Parcel7setDataEPKhj; - _ZN7android6Parcel8freeDataEv; - _ZN7android6Parcel8growDataEj; - _ZN7android6Parcel8setErrorEi; - _ZN7android6Parcel9initStateEv; - _ZN7android6Parcel9writeBlobEjbPNS0_12WritableBlobE; - _ZN7android6Parcel9writeBoolEb; - _ZN7android6Parcel9writeByteEa; - _ZN7android6Parcel9writeCharEDs; - _ZN7android6ParcelC1Ev; - _ZN7android6ParcelC2Ev; - _ZN7android6ParcelD1Ev; - _ZN7android6ParcelD2Ev; - _ZN7android7BBinder10onTransactEjRKNS_6ParcelEPS1_j; - _ZN7android7BBinder10pingBinderEv; - _ZN7android7BBinder11getDebugPidEv; - _ZN7android7BBinder11isInheritRtEv; - _ZN7android7BBinder11linkToDeathERKNS_2spINS_7IBinder14DeathRecipientEEEPvj; - _ZN7android7BBinder11localBinderEv; - _ZN7android7BBinder12attachObjectEPKvPvS3_PFvS2_S3_S3_E; - _ZN7android7BBinder12detachObjectEPKv; - _ZN7android7BBinder12getExtensionEv; - _ZN7android7BBinder12setExtensionERKNS_2spINS_7IBinderEEE; - _ZN7android7BBinder12setInheritRtEb; - _ZN7android7BBinder13unlinkToDeathERKNS_2wpINS_7IBinder14DeathRecipientEEEPvjPS4_; - _ZN7android7BBinder15isRequestingSidEv; - _ZN7android7BBinder16setRequestingSidEb; - _ZN7android7BBinder17getOrCreateExtrasEv; - _ZN7android7BBinder21getMinSchedulerPolicyEv; - _ZN7android7BBinder21setMinSchedulerPolicyEii; - _ZN7android7BBinder23getMinSchedulerPriorityEv; - _ZN7android7BBinder4dumpEiRKNS_6VectorINS_8String16EEE; - _ZN7android7BBinder8transactEjRKNS_6ParcelEPS1_j; - _ZN7android7BBinderC1Ev; - _ZN7android7BBinderC2Ev; - _ZN7android7BBinderD0Ev; - _ZN7android7BBinderD1Ev; - _ZN7android7BBinderD2Ev; - _ZN7android7content2pm18PackageChangeEvent14readFromParcelEPKNS_6ParcelE; - _ZN7android7content2pm21IPackageManagerNative10descriptorE; - _ZN7android7content2pm21IPackageManagerNative11asInterfaceERKNS_2spINS_7IBinderEEE; - _ZN7android7content2pm21IPackageManagerNative12default_implE; - _ZN7android7content2pm21IPackageManagerNative14getDefaultImplEv; - _ZN7android7content2pm21IPackageManagerNative14setDefaultImplENSt3__110unique_ptrIS2_NS3_14default_deleteIS2_EEEE; - _ZN7android7content2pm21IPackageManagerNativeC2Ev; - _ZN7android7content2pm21IPackageManagerNativeD0Ev; - _ZN7android7content2pm21IPackageManagerNativeD1Ev; - _ZN7android7content2pm21IPackageManagerNativeD2Ev; - _ZN7android7content2pm22BnPackageManagerNative10onTransactEjRKNS_6ParcelEPS3_j; - _ZN7android7content2pm22BnPackageManagerNativeC2Ev; - _ZN7android7content2pm22BpPackageManagerNative14getAllPackagesEPNSt3__16vectorINS3_12basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEENS8_ISA_EEEE; - _ZN7android7content2pm22BpPackageManagerNative15getNamesForUidsERKNSt3__16vectorIiNS3_9allocatorIiEEEEPNS4_INS3_12basic_stringIcNS3_11char_traitsIcEENS5_IcEEEENS5_ISE_EEEE; - _ZN7android7content2pm22BpPackageManagerNative16getLocationFlagsERKNSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEPi; - _ZN7android7content2pm22BpPackageManagerNative16hasSystemFeatureERKNS_8String16EiPb; - _ZN7android7content2pm22BpPackageManagerNative19isPackageDebuggableERKNS_8String16EPb; - _ZN7android7content2pm22BpPackageManagerNative22getInstallerForPackageERKNS_8String16EPNSt3__112basic_stringIcNS6_11char_traitsIcEENS6_9allocatorIcEEEE; - _ZN7android7content2pm22BpPackageManagerNative24getVersionCodeForPackageERKNS_8String16EPx; - _ZN7android7content2pm22BpPackageManagerNative27hasSha256SigningCertificateERKNSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEERKNS3_6vectorIhNS7_IhEEEEPb; - _ZN7android7content2pm22BpPackageManagerNative28getModuleMetadataPackageNameEPNSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEE; - _ZN7android7content2pm22BpPackageManagerNative29getTargetSdkVersionForPackageERKNS_8String16EPi; - _ZN7android7content2pm22BpPackageManagerNative29isAudioPlaybackCaptureAllowedERKNSt3__16vectorINS3_12basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEENS8_ISA_EEEEPNS4_IbNS8_IbEEEE; - _ZN7android7content2pm22BpPackageManagerNative29registerPackageChangeObserverERKNS_2spINS1_22IPackageChangeObserverEEE; - _ZN7android7content2pm22BpPackageManagerNative31unregisterPackageChangeObserverERKNS_2spINS1_22IPackageChangeObserverEEE; - _ZN7android7content2pm22BpPackageManagerNativeC1ERKNS_2spINS_7IBinderEEE; - _ZN7android7content2pm22BpPackageManagerNativeC2ERKNS_2spINS_7IBinderEEE; - _ZN7android7content2pm22IPackageChangeObserver10descriptorE; - _ZN7android7content2pm22IPackageChangeObserver11asInterfaceERKNS_2spINS_7IBinderEEE; - _ZN7android7content2pm22IPackageChangeObserver12default_implE; - _ZN7android7content2pm22IPackageChangeObserver14getDefaultImplEv; - _ZN7android7content2pm22IPackageChangeObserver14setDefaultImplENSt3__110unique_ptrIS2_NS3_14default_deleteIS2_EEEE; - _ZN7android7content2pm22IPackageChangeObserverC2Ev; - _ZN7android7content2pm22IPackageChangeObserverD0Ev; - _ZN7android7content2pm22IPackageChangeObserverD1Ev; - _ZN7android7content2pm22IPackageChangeObserverD2Ev; - _ZN7android7content2pm23BnPackageChangeObserver10onTransactEjRKNS_6ParcelEPS3_j; - _ZN7android7content2pm23BnPackageChangeObserverC2Ev; - _ZN7android7content2pm23BpPackageChangeObserver16onPackageChangedERKNS1_18PackageChangeEventE; - _ZN7android7content2pm23BpPackageChangeObserverC1ERKNS_2spINS_7IBinderEEE; - _ZN7android7content2pm23BpPackageChangeObserverC2ERKNS_2spINS_7IBinderEEE; - _ZN7android7HexDumpC1EPKvjj; - _ZN7android7HexDumpC2EPKvjj; - _ZN7android7IBinder11getDebugPidEPi; - _ZN7android7IBinder11localBinderEv; - _ZN7android7IBinder12getExtensionEPNS_2spIS0_EE; - _ZN7android7IBinder12remoteBinderEv; - _ZN7android7IBinder12shellCommandERKNS_2spIS0_EEiiiRNS_6VectorINS_8String16EEERKNS1_INS_14IShellCallbackEEERKNS1_INS_15IResultReceiverEEE; - _ZN7android7IBinder19queryLocalInterfaceERKNS_8String16E; - _ZN7android7IBinderC2Ev; - _ZN7android7IBinderD0Ev; - _ZN7android7IBinderD1Ev; - _ZN7android7IBinderD2Ev; - _ZN7android7IMemory10descriptorE; - _ZN7android7IMemory11asInterfaceERKNS_2spINS_7IBinderEEE; - _ZN7android7IMemory12default_implE; - _ZN7android7IMemory14getDefaultImplEv; - _ZN7android7IMemory14setDefaultImplENSt3__110unique_ptrIS0_NS1_14default_deleteIS0_EEEE; - _ZN7android7IMemoryC2Ev; - _ZN7android7IMemoryD0Ev; - _ZN7android7IMemoryD1Ev; - _ZN7android7IMemoryD2Ev; - _ZN7android8BnMemory10onTransactEjRKNS_6ParcelEPS1_j; - _ZN7android8BnMemoryC2Ev; - _ZN7android8BnMemoryD0Ev; - _ZN7android8BnMemoryD1Ev; - _ZN7android8BnMemoryD2Ev; - _ZN7android8BpBinder10onFirstRefEv; - _ZN7android8BpBinder10pingBinderEv; - _ZN7android8BpBinder11linkToDeathERKNS_2spINS_7IBinder14DeathRecipientEEEPvj; - _ZN7android8BpBinder12attachObjectEPKvPvS3_PFvS2_S3_S3_E; - _ZN7android8BpBinder12detachObjectEPKv; - _ZN7android8BpBinder12remoteBinderEv; - _ZN7android8BpBinder12sendObituaryEv; - _ZN7android8BpBinder12sTrackingMapE; - _ZN7android8BpBinder13getCountByUidERNS_6VectorIjEES3_; - _ZN7android8BpBinder13ObjectManager4killEv; - _ZN7android8BpBinder13ObjectManager6attachEPKvPvS4_PFvS3_S4_S4_E; - _ZN7android8BpBinder13ObjectManager6detachEPKv; - _ZN7android8BpBinder13ObjectManagerC1Ev; - _ZN7android8BpBinder13ObjectManagerC2Ev; - _ZN7android8BpBinder13ObjectManagerD1Ev; - _ZN7android8BpBinder13ObjectManagerD2Ev; - _ZN7android8BpBinder13sTrackingLockE; - _ZN7android8BpBinder13unlinkToDeathERKNS_2wpINS_7IBinder14DeathRecipientEEEPvjPS4_; - _ZN7android8BpBinder14reportOneDeathERKNS0_8ObituaryE; - _ZN7android8BpBinder14sLimitCallbackE; - _ZN7android8BpBinder15onLastStrongRefEPKv; - _ZN7android8BpBinder15sNumTrackedUidsE; - _ZN7android8BpBinder16enableCountByUidEv; - _ZN7android8BpBinder16setLimitCallbackEPFviE; - _ZN7android8BpBinder17disableCountByUidEv; - _ZN7android8BpBinder18sCountByUidEnabledE; - _ZN7android8BpBinder19getBinderProxyCountEj; - _ZN7android8BpBinder20onIncStrongAttemptedEjPKv; - _ZN7android8BpBinder20setCountByUidEnabledEb; - _ZN7android8BpBinder26sBinderProxyThrottleCreateE; - _ZN7android8BpBinder29sBinderProxyCountLowWatermarkE; - _ZN7android8BpBinder29setBinderProxyCountWatermarksEii; - _ZN7android8BpBinder30sBinderProxyCountHighWatermarkE; - _ZN7android8BpBinder4dumpEiRKNS_6VectorINS_8String16EEE; - _ZN7android8BpBinder6createEi; - _ZN7android8BpBinder6createERKNS_2spINS_10RpcSessionEEERKNS_10RpcAddressE; - _ZN7android8BpBinder8transactEjRKNS_6ParcelEPS1_j; - _ZN7android8BpBinderC1EONS0_12BinderHandleEi; - _ZN7android8BpBinderC1EONS0_9RpcHandleE; - _ZN7android8BpBinderC1EONSt3__17variantIJNS0_12BinderHandleENS0_9RpcHandleEEEE; - _ZN7android8BpBinderC2EONS0_12BinderHandleEi; - _ZN7android8BpBinderC2EONS0_9RpcHandleE; - _ZN7android8BpBinderC2EONSt3__17variantIJNS0_12BinderHandleENS0_9RpcHandleEEEE; - _ZN7android8BpBinderD0Ev; - _ZN7android8BpBinderD1Ev; - _ZN7android8BpBinderD2Ev; - _ZN7android8BpMemoryC1ERKNS_2spINS_7IBinderEEE; - _ZN7android8BpMemoryC2ERKNS_2spINS_7IBinderEEE; - _ZN7android8BpMemoryD0Ev; - _ZN7android8BpMemoryD1Ev; - _ZN7android8BpMemoryD2Ev; - _ZN7android8internal9Stability11getCategoryEPNS_7IBinderE; - _ZN7android8internal9Stability11levelStringENS1_5LevelE; - _ZN7android8internal9Stability13getLocalLevelEv; - _ZN7android8internal9Stability15isDeclaredLevelENS1_5LevelE; - _ZN7android8internal9Stability17debugLogStabilityERKNSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEERKNS_2spINS_7IBinderEEE; - _ZN7android8internal9Stability19markCompilationUnitEPNS_7IBinderE; - _ZN7android8internal9Stability22tryMarkCompilationUnitEPNS_7IBinderE; - _ZN7android8internal9Stability24requiresVintfDeclarationERKNS_2spINS_7IBinderEEE; - _ZN7android8internal9Stability25forceDowngradeToStabilityERKNS_2spINS_7IBinderEEENS1_5LevelE; - _ZN7android8internal9Stability30forceDowngradeToLocalStabilityERKNS_2spINS_7IBinderEEE; - _ZN7android8internal9Stability31forceDowngradeToSystemStabilityERKNS_2spINS_7IBinderEEE; - _ZN7android8internal9Stability31forceDowngradeToVendorStabilityERKNS_2spINS_7IBinderEEE; - _ZN7android8internal9Stability5checkENS1_8CategoryENS1_5LevelE; - _ZN7android8internal9Stability7setReprEPNS_7IBinderEij; - _ZN7android8internal9Stability8Category11debugStringEv; - _ZN7android8internal9Stability8markVndkEPNS_7IBinderE; - _ZN7android8internal9Stability9markVintfEPNS_7IBinderE; - _ZN7android8RpcState11CommandDataC1Ej; - _ZN7android8RpcState11CommandDataC2Ej; - _ZN7android8RpcState12countBindersEv; - _ZN7android8RpcState12getSessionIdERKNS_4base14unique_fd_implINS1_13DefaultCloserEEERKNS_2spINS_10RpcSessionEEEPi; - _ZN7android8RpcState12waitForReplyERKNS_4base14unique_fd_implINS1_13DefaultCloserEEERKNS_2spINS_10RpcSessionEEEPNS_6ParcelE; - _ZN7android8RpcState13getMaxThreadsERKNS_4base14unique_fd_implINS1_13DefaultCloserEEERKNS_2spINS_10RpcSessionEEEPj; - _ZN7android8RpcState13getRootObjectERKNS_4base14unique_fd_implINS1_13DefaultCloserEEERKNS_2spINS_10RpcSessionEEE; - _ZN7android8RpcState13sendDecStrongERKNS_4base14unique_fd_implINS1_13DefaultCloserEEERKNS_10RpcAddressE; - _ZN7android8RpcState15onBinderLeavingERKNS_2spINS_10RpcSessionEEERKNS1_INS_7IBinderEEEPNS_10RpcAddressE; - _ZN7android8RpcState15processTransactERKNS_4base14unique_fd_implINS1_13DefaultCloserEEERKNS_2spINS_10RpcSessionEEERKNS_13RpcWireHeaderE; - _ZN7android8RpcState16onBinderEnteringERKNS_2spINS_10RpcSessionEEERKNS_10RpcAddressE; - _ZN7android8RpcState16processDecStrongERKNS_4base14unique_fd_implINS1_13DefaultCloserEEERKNS_13RpcWireHeaderE; - _ZN7android8RpcState20getAndExecuteCommandERKNS_4base14unique_fd_implINS1_13DefaultCloserEEERKNS_2spINS_10RpcSessionEEE; - _ZN7android8RpcState20processServerCommandERKNS_4base14unique_fd_implINS1_13DefaultCloserEEERKNS_2spINS_10RpcSessionEEERKNS_13RpcWireHeaderE; - _ZN7android8RpcState23processTransactInternalERKNS_4base14unique_fd_implINS1_13DefaultCloserEEERKNS_2spINS_10RpcSessionEEENS0_11CommandDataE; - _ZN7android8RpcState4dumpEv; - _ZN7android8RpcState6rpcRecERKNS_4base14unique_fd_implINS1_13DefaultCloserEEEPKcPvj; - _ZN7android8RpcState7rpcSendERKNS_4base14unique_fd_implINS1_13DefaultCloserEEEPKcPKvj; - _ZN7android8RpcState8transactERKNS_4base14unique_fd_implINS1_13DefaultCloserEEERKNS_10RpcAddressEjRKNS_6ParcelERKNS_2spINS_10RpcSessionEEEPSA_j; - _ZN7android8RpcState9terminateEv; - _ZN7android8RpcStateC1Ev; - _ZN7android8RpcStateC2Ev; - _ZN7android8RpcStateD1Ev; - _ZN7android8RpcStateD2Ev; - _ZN7android9BpRefBase10onFirstRefEv; - _ZN7android9BpRefBase15onLastStrongRefEPKv; - _ZN7android9BpRefBase20onIncStrongAttemptedEjPKv; - _ZN7android9BpRefBaseC1ERKNS_2spINS_7IBinderEEE; - _ZN7android9BpRefBaseC2ERKNS_2spINS_7IBinderEEE; - _ZN7android9BpRefBaseD0Ev; - _ZN7android9BpRefBaseD1Ev; - _ZN7android9BpRefBaseD2Ev; - _ZN7android9HeapCache10binderDiedERKNS_2wpINS_7IBinderEEE; - _ZN7android9HeapCache10dump_heapsEv; - _ZN7android9HeapCache8get_heapERKNS_2spINS_7IBinderEEE; - _ZN7android9HeapCache9find_heapERKNS_2spINS_7IBinderEEE; - _ZN7android9HeapCache9free_heapERKNS_2spINS_7IBinderEEE; - _ZN7android9HeapCache9free_heapERKNS_2wpINS_7IBinderEEE; - _ZN7android9HeapCacheC1Ev; - _ZN7android9HeapCacheC2Ev; - _ZN7android9HeapCacheD0Ev; - _ZN7android9HeapCacheD1Ev; - _ZN7android9HeapCacheD2Ev; - _ZN7android9hexStringEPKvj; - _ZN7android9RpcServer12listSessionsEv; - _ZN7android9RpcServer13getMaxThreadsEv; - _ZN7android9RpcServer13getRootObjectEv; - _ZN7android9RpcServer13releaseServerEv; - _ZN7android9RpcServer13setMaxThreadsEj; - _ZN7android9RpcServer13setRootObjectERKNS_2spINS_7IBinderEEE; - _ZN7android9RpcServer15setupInetServerEjPj; - _ZN7android9RpcServer16setupVsockServerEj; - _ZN7android9RpcServer17setRootObjectWeakERKNS_2wpINS_7IBinderEEE; - _ZN7android9RpcServer17setupSocketServerERKNS_16RpcSocketAddressE; - _ZN7android9RpcServer19establishConnectionEONS_2spIS0_EENS_4base14unique_fd_implINS4_13DefaultCloserEEE; - _ZN7android9RpcServer19setupExternalServerENS_4base14unique_fd_implINS1_13DefaultCloserEEE; - _ZN7android9RpcServer20onSessionTerminatingERKNS_2spINS_10RpcSessionEEE; - _ZN7android9RpcServer21setupUnixDomainServerEPKc; - _ZN7android9RpcServer24numUninitializedSessionsEv; - _ZN7android9RpcServer4joinEv; - _ZN7android9RpcServer4makeEv; - _ZN7android9RpcServer61iUnderstandThisCodeIsExperimentalAndIWillNotUseItInProductionEv; - _ZN7android9RpcServer9acceptOneEv; - _ZN7android9RpcServer9hasServerEv; - _ZN7android9RpcServerC1Ev; - _ZN7android9RpcServerC2Ev; - _ZN7android9RpcServerD0Ev; - _ZN7android9RpcServerD1Ev; - _ZN7android9RpcServerD2Ev; - _ZN7android9SingletonINS_15PermissionCacheEE11getInstanceEv; - _ZN7android9SingletonINS_15PermissionCacheEE11hasInstanceEv; - _ZN7android9SingletonINS_15PermissionCacheEE5sLockE; - _ZN7android9SingletonINS_15PermissionCacheEE9sInstanceE; - _ZN7android9SingletonINS_15PermissionCacheEEC1Ev; - _ZN7android9SingletonINS_15PermissionCacheEEC2Ev; - _ZN7android9SingletonINS_15PermissionCacheEED1Ev; - _ZN7android9SingletonINS_15PermissionCacheEED2Ev; - _ZN7androidlsERNS_10TextOutputERKNS_7HexDumpE; - _ZN7androidlsERNS_10TextOutputERKNS_8TypeCodeE; - _ZN7androidlsIA15_cEERNS_10TextOutputES3_RKT_; - _ZN7androidlsIA24_cEERNS_10TextOutputES3_RKT_; - _ZN7androidlsIA2_cEERNS_10TextOutputES3_RKT_; - _ZN7androidlsIA34_cEERNS_10TextOutputES3_RKT_; - _ZN7androidlsIA3_cEERNS_10TextOutputES3_RKT_; - _ZN7androidlsIA43_cEERNS_10TextOutputES3_RKT_; - _ZN7androidlsIA4_cEERNS_10TextOutputES3_RKT_; - _ZN7androidlsIA5_cEERNS_10TextOutputES3_RKT_; - _ZN7androidlsIA8_cEERNS_10TextOutputES3_RKT_; - _ZN7androidlsIA9_cEERNS_10TextOutputES3_RKT_; - _ZN7androidlsIjEERNS_10TextOutputES2_RKT_; - _ZN7androidlsINSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEEERNS_10TextOutputES9_RKT_; - _ZN7androidlsIPcEERNS_10TextOutputES3_RKT_; - _ZN7androidlsIPvEERNS_10TextOutputES3_RKT_; - _ZN7androidlsIyEERNS_10TextOutputES2_RKT_; - _ZNK7android10MemoryBase9getMemoryEPiPj; - _ZNK7android10RpcAddress13writeToParcelEPNS_6ParcelE; - _ZNK7android10RpcAddress15viewRawEmbeddedEv; - _ZNK7android10RpcAddress6isZeroEv; - _ZNK7android10RpcAddress8toStringEv; - _ZNK7android10RpcAddressltERKS0_; - _ZNK7android11IMemoryHeap22getInterfaceDescriptorEv; - _ZNK7android12BpMemoryHeap12assertMappedEv; - _ZNK7android12BpMemoryHeap18assertReallyMappedEv; - _ZNK7android12BpMemoryHeap7getBaseEv; - _ZNK7android12BpMemoryHeap7getSizeEv; - _ZNK7android12BpMemoryHeap8getFlagsEv; - _ZNK7android12BpMemoryHeap9getHeapIDEv; - _ZNK7android12BpMemoryHeap9getOffsetEv; - _ZNK7android12MemoryDealer4dumpEPKc; - _ZNK7android12MemoryDealer4heapEv; - _ZNK7android12MemoryDealer9allocatorEv; - _ZNK7android12SortedVectorINS_15PermissionCache5EntryEE10do_compareEPKvS5_; - _ZNK7android12SortedVectorINS_15PermissionCache5EntryEE10do_destroyEPvj; - _ZNK7android12SortedVectorINS_15PermissionCache5EntryEE12do_constructEPvj; - _ZNK7android12SortedVectorINS_15PermissionCache5EntryEE15do_move_forwardEPvPKvj; - _ZNK7android12SortedVectorINS_15PermissionCache5EntryEE16do_move_backwardEPvPKvj; - _ZNK7android12SortedVectorINS_15PermissionCache5EntryEE7do_copyEPvPKvj; - _ZNK7android12SortedVectorINS_15PermissionCache5EntryEE8do_splatEPvPKvj; - _ZNK7android12SortedVectorINS_16key_value_pair_tINS_2wpINS_7IBinderEEENS_9HeapCache11heap_info_tEEEE10do_compareEPKvSA_; - _ZNK7android12SortedVectorINS_16key_value_pair_tINS_2wpINS_7IBinderEEENS_9HeapCache11heap_info_tEEEE10do_destroyEPvj; - _ZNK7android12SortedVectorINS_16key_value_pair_tINS_2wpINS_7IBinderEEENS_9HeapCache11heap_info_tEEEE12do_constructEPvj; - _ZNK7android12SortedVectorINS_16key_value_pair_tINS_2wpINS_7IBinderEEENS_9HeapCache11heap_info_tEEEE15do_move_forwardEPvPKvj; - _ZNK7android12SortedVectorINS_16key_value_pair_tINS_2wpINS_7IBinderEEENS_9HeapCache11heap_info_tEEEE16do_move_backwardEPvPKvj; - _ZNK7android12SortedVectorINS_16key_value_pair_tINS_2wpINS_7IBinderEEENS_9HeapCache11heap_info_tEEEE7do_copyEPvPKvj; - _ZNK7android12SortedVectorINS_16key_value_pair_tINS_2wpINS_7IBinderEEENS_9HeapCache11heap_info_tEEEE8do_splatEPvPKvj; - _ZNK7android12SortedVectorINS_16key_value_pair_tIPKvNS_8BpBinder13ObjectManager7entry_tEEEE10do_compareES3_S3_; - _ZNK7android12SortedVectorINS_16key_value_pair_tIPKvNS_8BpBinder13ObjectManager7entry_tEEEE10do_destroyEPvj; - _ZNK7android12SortedVectorINS_16key_value_pair_tIPKvNS_8BpBinder13ObjectManager7entry_tEEEE12do_constructEPvj; - _ZNK7android12SortedVectorINS_16key_value_pair_tIPKvNS_8BpBinder13ObjectManager7entry_tEEEE15do_move_forwardEPvS3_j; - _ZNK7android12SortedVectorINS_16key_value_pair_tIPKvNS_8BpBinder13ObjectManager7entry_tEEEE16do_move_backwardEPvS3_j; - _ZNK7android12SortedVectorINS_16key_value_pair_tIPKvNS_8BpBinder13ObjectManager7entry_tEEEE7do_copyEPvS3_j; - _ZNK7android12SortedVectorINS_16key_value_pair_tIPKvNS_8BpBinder13ObjectManager7entry_tEEEE8do_splatEPvS3_j; - _ZNK7android12SortedVectorINS_8String16EE10do_compareEPKvS4_; - _ZNK7android12SortedVectorINS_8String16EE10do_destroyEPvj; - _ZNK7android12SortedVectorINS_8String16EE12do_constructEPvj; - _ZNK7android12SortedVectorINS_8String16EE15do_move_forwardEPvPKvj; - _ZNK7android12SortedVectorINS_8String16EE16do_move_backwardEPvPKvj; - _ZNK7android12SortedVectorINS_8String16EE7do_copyEPvPKvj; - _ZNK7android12SortedVectorINS_8String16EE8do_splatEPvPKvj; - _ZNK7android14IPCThreadState13getCallingPidEv; - _ZNK7android14IPCThreadState13getCallingSidEv; - _ZNK7android14IPCThreadState13getCallingUidEv; - _ZNK7android14IPCThreadState18getCallRestrictionEv; - _ZNK7android14IPCThreadState19getStrictModePolicyEv; - _ZNK7android14IPCThreadState22getServingStackPointerEv; - _ZNK7android14IPCThreadState23getCallingWorkSourceUidEv; - _ZNK7android14IPCThreadState25shouldPropagateWorkSourceEv; - _ZNK7android14IPCThreadState29getLastTransactionBinderFlagsEv; - _ZNK7android14IShellCallback22getInterfaceDescriptorEv; - _ZNK7android14MemoryHeapBase7getBaseEv; - _ZNK7android14MemoryHeapBase7getSizeEv; - _ZNK7android14MemoryHeapBase8getFlagsEv; - _ZNK7android14MemoryHeapBase9getDeviceEv; - _ZNK7android14MemoryHeapBase9getHeapIDEv; - _ZNK7android14MemoryHeapBase9getOffsetEv; - _ZNK7android15IResultReceiver22getInterfaceDescriptorEv; - _ZNK7android15IServiceManager22getInterfaceDescriptorEv; - _ZNK7android15PermissionCache5checkEPbRKNS_8String16Ej; - _ZNK7android18BufferedTextOutput9getBufferEv; - _ZNK7android18ServiceManagerShim10getServiceERKNS_8String16E; - _ZNK7android18ServiceManagerShim12checkServiceERKNS_8String16E; - _ZNK7android21IPermissionController22getInterfaceDescriptorEv; - _ZNK7android22SimpleBestFitAllocator4dumpEPKc; - _ZNK7android22SimpleBestFitAllocator4dumpERNS_7String8EPKc; - _ZNK7android22SimpleBestFitAllocator4sizeEv; - _ZNK7android22SimpleBestFitAllocator6dump_lEPKc; - _ZNK7android22SimpleBestFitAllocator6dump_lERNS_7String8EPKc; - _ZNK7android2os15IClientCallback22getInterfaceDescriptorEv; - _ZNK7android2os15IServiceManager22getInterfaceDescriptorEv; - _ZNK7android2os16IServiceCallback22getInterfaceDescriptorEv; - _ZNK7android2os16ParcelableHolder13writeToParcelEPNS_6ParcelE; - _ZNK7android2os16ServiceDebugInfo13writeToParcelEPNS_6ParcelE; - _ZNK7android2os17PersistableBundle10getBooleanERKNS_8String16EPb; - _ZNK7android2os17PersistableBundle10getIntKeysEv; - _ZNK7android2os17PersistableBundle11getLongKeysEv; - _ZNK7android2os17PersistableBundle12getIntVectorERKNS_8String16EPNSt3__16vectorIiNS5_9allocatorIiEEEE; - _ZNK7android2os17PersistableBundle13getDoubleKeysEv; - _ZNK7android2os17PersistableBundle13getLongVectorERKNS_8String16EPNSt3__16vectorIxNS5_9allocatorIxEEEE; - _ZNK7android2os17PersistableBundle13getStringKeysEv; - _ZNK7android2os17PersistableBundle13writeToParcelEPNS_6ParcelE; - _ZNK7android2os17PersistableBundle14getBooleanKeysEv; - _ZNK7android2os17PersistableBundle15getDoubleVectorERKNS_8String16EPNSt3__16vectorIdNS5_9allocatorIdEEEE; - _ZNK7android2os17PersistableBundle15getStringVectorERKNS_8String16EPNSt3__16vectorIS2_NS5_9allocatorIS2_EEEE; - _ZNK7android2os17PersistableBundle16getBooleanVectorERKNS_8String16EPNSt3__16vectorIbNS5_9allocatorIbEEEE; - _ZNK7android2os17PersistableBundle16getIntVectorKeysEv; - _ZNK7android2os17PersistableBundle17getLongVectorKeysEv; - _ZNK7android2os17PersistableBundle18writeToParcelInnerEPNS_6ParcelE; - _ZNK7android2os17PersistableBundle19getDoubleVectorKeysEv; - _ZNK7android2os17PersistableBundle19getStringVectorKeysEv; - _ZNK7android2os17PersistableBundle20getBooleanVectorKeysEv; - _ZNK7android2os17PersistableBundle20getPersistableBundleERKNS_8String16EPS1_; - _ZNK7android2os17PersistableBundle24getPersistableBundleKeysEv; - _ZNK7android2os17PersistableBundle4sizeEv; - _ZNK7android2os17PersistableBundle5emptyEv; - _ZNK7android2os17PersistableBundle6getIntERKNS_8String16EPi; - _ZNK7android2os17PersistableBundle7getLongERKNS_8String16EPx; - _ZNK7android2os17PersistableBundle9getDoubleERKNS_8String16EPd; - _ZNK7android2os17PersistableBundle9getStringERKNS_8String16EPS2_; - _ZNK7android2os20ParcelFileDescriptor13writeToParcelEPNS_6ParcelE; - _ZNK7android6binder6Status13writeToParcelEPNS_6ParcelE; - _ZNK7android6binder6Status9toString8Ev; - _ZNK7android6Parcel10errorCheckEv; - _ZNK7android6Parcel10ipcObjectsEv; - _ZNK7android6Parcel10readDoubleEPd; - _ZNK7android6Parcel10readDoubleEv; - _ZNK7android6Parcel10readObjectEb; - _ZNK7android6Parcel10readUint32EPj; - _ZNK7android6Parcel10readUint32Ev; - _ZNK7android6Parcel10readUint64EPy; - _ZNK7android6Parcel10readUint64Ev; - _ZNK7android6Parcel10scanForFdsEv; - _ZNK7android6Parcel11ipcDataSizeEv; - _ZNK7android6Parcel11readCStringEv; - _ZNK7android6Parcel11readInplaceEj; - _ZNK7android6Parcel11readPointerEPj; - _ZNK7android6Parcel11readPointerEv; - _ZNK7android6Parcel11readString8EPNS_7String8E; - _ZNK7android6Parcel11readString8Ev; - _ZNK7android6Parcel12dataCapacityEv; - _ZNK7android6Parcel12dataPositionEv; - _ZNK7android6Parcel12objectsCountEv; - _ZNK7android6Parcel12readString16EPNS_8String16E; - _ZNK7android6Parcel12readString16EPNSt3__110unique_ptrINS_8String16ENS1_14default_deleteIS3_EEEE; - _ZNK7android6Parcel12readString16EPNSt3__18optionalINS_8String16EEE; - _ZNK7android6Parcel12readString16Ev; - _ZNK7android6Parcel13markSensitiveEv; - _ZNK7android6Parcel14checkInterfaceEPNS_7IBinderE; - _ZNK7android6Parcel14readBoolVectorEPNSt3__110unique_ptrINS1_6vectorIbNS1_9allocatorIbEEEENS1_14default_deleteIS6_EEEE; - _ZNK7android6Parcel14readBoolVectorEPNSt3__16vectorIbNS1_9allocatorIbEEEE; - _ZNK7android6Parcel14readBoolVectorEPNSt3__18optionalINS1_6vectorIbNS1_9allocatorIbEEEEEE; - _ZNK7android6Parcel14readByteVectorEPNSt3__110unique_ptrINS1_6vectorIaNS1_9allocatorIaEEEENS1_14default_deleteIS6_EEEE; - _ZNK7android6Parcel14readByteVectorEPNSt3__110unique_ptrINS1_6vectorIhNS1_9allocatorIhEEEENS1_14default_deleteIS6_EEEE; - _ZNK7android6Parcel14readByteVectorEPNSt3__16vectorIaNS1_9allocatorIaEEEE; - _ZNK7android6Parcel14readByteVectorEPNSt3__16vectorIhNS1_9allocatorIhEEEE; - _ZNK7android6Parcel14readByteVectorEPNSt3__18optionalINS1_6vectorIaNS1_9allocatorIaEEEEEE; - _ZNK7android6Parcel14readByteVectorEPNSt3__18optionalINS1_6vectorIhNS1_9allocatorIhEEEEEE; - _ZNK7android6Parcel14readCharVectorEPNSt3__110unique_ptrINS1_6vectorIDsNS1_9allocatorIDsEEEENS1_14default_deleteIS6_EEEE; - _ZNK7android6Parcel14readCharVectorEPNSt3__16vectorIDsNS1_9allocatorIDsEEEE; - _ZNK7android6Parcel14readCharVectorEPNSt3__18optionalINS1_6vectorIDsNS1_9allocatorIDsEEEEEE; - _ZNK7android6Parcel14readParcelableEPNS_10ParcelableE; - _ZNK7android6Parcel15ipcObjectsCountEv; - _ZNK7android6Parcel15readFloatVectorEPNSt3__110unique_ptrINS1_6vectorIfNS1_9allocatorIfEEEENS1_14default_deleteIS6_EEEE; - _ZNK7android6Parcel15readFloatVectorEPNSt3__16vectorIfNS1_9allocatorIfEEEE; - _ZNK7android6Parcel15readFloatVectorEPNSt3__18optionalINS1_6vectorIfNS1_9allocatorIfEEEEEE; - _ZNK7android6Parcel15readInt32VectorEPNSt3__110unique_ptrINS1_6vectorIiNS1_9allocatorIiEEEENS1_14default_deleteIS6_EEEE; - _ZNK7android6Parcel15readInt32VectorEPNSt3__16vectorIiNS1_9allocatorIiEEEE; - _ZNK7android6Parcel15readInt32VectorEPNSt3__18optionalINS1_6vectorIiNS1_9allocatorIiEEEEEE; - _ZNK7android6Parcel15readInt64VectorEPNSt3__110unique_ptrINS1_6vectorIxNS1_9allocatorIxEEEENS1_14default_deleteIS6_EEEE; - _ZNK7android6Parcel15readInt64VectorEPNSt3__16vectorIxNS1_9allocatorIxEEEE; - _ZNK7android6Parcel15readInt64VectorEPNSt3__18optionalINS1_6vectorIxNS1_9allocatorIxEEEEEE; - _ZNK7android6Parcel15setDataPositionEj; - _ZNK7android6Parcel15unflattenBinderEPNS_2spINS_7IBinderEEE; - _ZNK7android6Parcel16enforceInterfaceEPKDsjPNS_14IPCThreadStateE; - _ZNK7android6Parcel16enforceInterfaceERKNS_8String16EPNS_14IPCThreadStateE; - _ZNK7android6Parcel16readDoubleVectorEPNSt3__110unique_ptrINS1_6vectorIdNS1_9allocatorIdEEEENS1_14default_deleteIS6_EEEE; - _ZNK7android6Parcel16readDoubleVectorEPNSt3__16vectorIdNS1_9allocatorIdEEEE; - _ZNK7android6Parcel16readDoubleVectorEPNSt3__18optionalINS1_6vectorIdNS1_9allocatorIdEEEEEE; - _ZNK7android6Parcel16readNativeHandleEv; - _ZNK7android6Parcel16readStrongBinderEPNS_2spINS_7IBinderEEE; - _ZNK7android6Parcel16readStrongBinderEv; - _ZNK7android6Parcel16readStrongBinderINS_2os15IClientCallbackEEEiPNS_2spIT_EE; - _ZNK7android6Parcel16readStrongBinderINS_2os16IServiceCallbackEEEiPNS_2spIT_EE; - _ZNK7android6Parcel16readStrongBinderINS_7content2pm22IPackageChangeObserverEEEiPNS_2spIT_EE; - _ZNK7android6Parcel16readUint64VectorEPNSt3__110unique_ptrINS1_6vectorIyNS1_9allocatorIyEEEENS1_14default_deleteIS6_EEEE; - _ZNK7android6Parcel16readUint64VectorEPNSt3__16vectorIyNS1_9allocatorIyEEEE; - _ZNK7android6Parcel16readUint64VectorEPNSt3__18optionalINS1_6vectorIyNS1_9allocatorIyEEEEEE; - _ZNK7android6Parcel16validateReadDataEj; - _ZNK7android6Parcel17getBlobAshmemSizeEv; - _ZNK7android6Parcel17getOpenAshmemSizeEv; - _ZNK7android6Parcel17readExceptionCodeEv; - _ZNK7android6Parcel17readUtf8FromUtf16EPNSt3__110unique_ptrINS1_12basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEENS1_14default_deleteIS8_EEEE; - _ZNK7android6Parcel17readUtf8FromUtf16EPNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEE; - _ZNK7android6Parcel17readUtf8FromUtf16EPNSt3__18optionalINS1_12basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEEE; - _ZNK7android6Parcel18hasFileDescriptorsEv; - _ZNK7android6Parcel18readFileDescriptorEv; - _ZNK7android6Parcel18readString16VectorEPNSt3__110unique_ptrINS1_6vectorINS2_INS_8String16ENS1_14default_deleteIS4_EEEENS1_9allocatorIS7_EEEENS5_ISA_EEEE; - _ZNK7android6Parcel18readString16VectorEPNSt3__16vectorINS_8String16ENS1_9allocatorIS3_EEEE; - _ZNK7android6Parcel18readString16VectorEPNSt3__18optionalINS1_6vectorINS2_INS_8String16EEENS1_9allocatorIS5_EEEEEE; - _ZNK7android6Parcel18readString8InplaceEPj; - _ZNK7android6Parcel19readString16InplaceEPj; - _ZNK7android6Parcel21finishUnflattenBinderERKNS_2spINS_7IBinderEEEPS3_; - _ZNK7android6Parcel22readStrongBinderVectorEPNSt3__110unique_ptrINS1_6vectorINS_2spINS_7IBinderEEENS1_9allocatorIS6_EEEENS1_14default_deleteIS9_EEEE; - _ZNK7android6Parcel22readStrongBinderVectorEPNSt3__16vectorINS_2spINS_7IBinderEEENS1_9allocatorIS5_EEEE; - _ZNK7android6Parcel22readStrongBinderVectorEPNSt3__18optionalINS1_6vectorINS_2spINS_7IBinderEEENS1_9allocatorIS6_EEEEEE; - _ZNK7android6Parcel24readCallingWorkSourceUidEv; - _ZNK7android6Parcel24readNullableStrongBinderEPNS_2spINS_7IBinderEEE; - _ZNK7android6Parcel24readParcelFileDescriptorEv; - _ZNK7android6Parcel24readUniqueFileDescriptorEPNS_4base14unique_fd_implINS1_13DefaultCloserEEE; - _ZNK7android6Parcel29readUtf8VectorFromUtf16VectorEPNSt3__110unique_ptrINS1_6vectorINS2_INS1_12basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEENS1_14default_deleteIS9_EEEENS7_ISC_EEEENSA_ISE_EEEE; - _ZNK7android6Parcel29readUtf8VectorFromUtf16VectorEPNSt3__16vectorINS1_12basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEENS6_IS8_EEEE; - _ZNK7android6Parcel29readUtf8VectorFromUtf16VectorEPNSt3__18optionalINS1_6vectorINS2_INS1_12basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEEENS7_ISA_EEEEEE; - _ZNK7android6Parcel30readUniqueFileDescriptorVectorEPNSt3__110unique_ptrINS1_6vectorINS_4base14unique_fd_implINS4_13DefaultCloserEEENS1_9allocatorIS7_EEEENS1_14default_deleteISA_EEEE; - _ZNK7android6Parcel30readUniqueFileDescriptorVectorEPNSt3__16vectorINS_4base14unique_fd_implINS3_13DefaultCloserEEENS1_9allocatorIS6_EEEE; - _ZNK7android6Parcel30readUniqueFileDescriptorVectorEPNSt3__18optionalINS1_6vectorINS_4base14unique_fd_implINS4_13DefaultCloserEEENS1_9allocatorIS7_EEEEEE; - _ZNK7android6Parcel30readUniqueParcelFileDescriptorEPNS_4base14unique_fd_implINS1_13DefaultCloserEEE; - _ZNK7android6Parcel37updateWorkSourceRequestHeaderPositionEv; - _ZNK7android6Parcel4dataEv; - _ZNK7android6Parcel4readEPvj; - _ZNK7android6Parcel4readERNS0_26FlattenableHelperInterfaceE; - _ZNK7android6Parcel5printERNS_10TextOutputEj; - _ZNK7android6Parcel7ipcDataEv; - _ZNK7android6Parcel8allowFdsEv; - _ZNK7android6Parcel8dataSizeEv; - _ZNK7android6Parcel8isForRpcEv; - _ZNK7android6Parcel8readBlobEjPNS0_12ReadableBlobE; - _ZNK7android6Parcel8readBoolEPb; - _ZNK7android6Parcel8readBoolEv; - _ZNK7android6Parcel8readByteEPa; - _ZNK7android6Parcel8readByteEv; - _ZNK7android6Parcel8readCharEPDs; - _ZNK7android6Parcel8readCharEv; - _ZNK7android6Parcel9dataAvailEv; - _ZNK7android6Parcel9readFloatEPf; - _ZNK7android6Parcel9readFloatEv; - _ZNK7android6Parcel9readInt32EPi; - _ZNK7android6Parcel9readInt32Ev; - _ZNK7android6Parcel9readInt64EPx; - _ZNK7android6Parcel9readInt64Ev; - _ZNK7android6VectorIiE10do_destroyEPvj; - _ZNK7android6VectorIiE12do_constructEPvj; - _ZNK7android6VectorIiE15do_move_forwardEPvPKvj; - _ZNK7android6VectorIiE16do_move_backwardEPvPKvj; - _ZNK7android6VectorIiE7do_copyEPvPKvj; - _ZNK7android6VectorIiE8do_splatEPvPKvj; - _ZNK7android6VectorINS_12ProcessState12handle_entryEE10do_destroyEPvj; - _ZNK7android6VectorINS_12ProcessState12handle_entryEE12do_constructEPvj; - _ZNK7android6VectorINS_12ProcessState12handle_entryEE15do_move_forwardEPvPKvj; - _ZNK7android6VectorINS_12ProcessState12handle_entryEE16do_move_backwardEPvPKvj; - _ZNK7android6VectorINS_12ProcessState12handle_entryEE7do_copyEPvPKvj; - _ZNK7android6VectorINS_12ProcessState12handle_entryEE8do_splatEPvPKvj; - _ZNK7android6VectorINS_2spINS_18BufferedTextOutput11BufferStateEEEE10do_destroyEPvj; - _ZNK7android6VectorINS_2spINS_18BufferedTextOutput11BufferStateEEEE12do_constructEPvj; - _ZNK7android6VectorINS_2spINS_18BufferedTextOutput11BufferStateEEEE15do_move_forwardEPvPKvj; - _ZNK7android6VectorINS_2spINS_18BufferedTextOutput11BufferStateEEEE16do_move_backwardEPvPKvj; - _ZNK7android6VectorINS_2spINS_18BufferedTextOutput11BufferStateEEEE7do_copyEPvPKvj; - _ZNK7android6VectorINS_2spINS_18BufferedTextOutput11BufferStateEEEE8do_splatEPvPKvj; - _ZNK7android6VectorINS_8BpBinder8ObituaryEE10do_destroyEPvj; - _ZNK7android6VectorINS_8BpBinder8ObituaryEE12do_constructEPvj; - _ZNK7android6VectorINS_8BpBinder8ObituaryEE15do_move_forwardEPvPKvj; - _ZNK7android6VectorINS_8BpBinder8ObituaryEE16do_move_backwardEPvPKvj; - _ZNK7android6VectorINS_8BpBinder8ObituaryEE7do_copyEPvPKvj; - _ZNK7android6VectorINS_8BpBinder8ObituaryEE8do_splatEPvPKvj; - _ZNK7android6VectorINS_8String16EE10do_destroyEPvj; - _ZNK7android6VectorINS_8String16EE12do_constructEPvj; - _ZNK7android6VectorINS_8String16EE15do_move_forwardEPvPKvj; - _ZNK7android6VectorINS_8String16EE16do_move_backwardEPvPKvj; - _ZNK7android6VectorINS_8String16EE7do_copyEPvPKvj; - _ZNK7android6VectorINS_8String16EE8do_splatEPvPKvj; - _ZNK7android6VectorIPNS_7BBinderEE10do_destroyEPvj; - _ZNK7android6VectorIPNS_7BBinderEE12do_constructEPvj; - _ZNK7android6VectorIPNS_7BBinderEE15do_move_forwardEPvPKvj; - _ZNK7android6VectorIPNS_7BBinderEE16do_move_backwardEPvPKvj; - _ZNK7android6VectorIPNS_7BBinderEE7do_copyEPvPKvj; - _ZNK7android6VectorIPNS_7BBinderEE8do_splatEPvPKvj; - _ZNK7android6VectorIPNS_7RefBase12weakref_typeEE10do_destroyEPvj; - _ZNK7android6VectorIPNS_7RefBase12weakref_typeEE12do_constructEPvj; - _ZNK7android6VectorIPNS_7RefBase12weakref_typeEE15do_move_forwardEPvPKvj; - _ZNK7android6VectorIPNS_7RefBase12weakref_typeEE16do_move_backwardEPvPKvj; - _ZNK7android6VectorIPNS_7RefBase12weakref_typeEE7do_copyEPvPKvj; - _ZNK7android6VectorIPNS_7RefBase12weakref_typeEE8do_splatEPvPKvj; - _ZNK7android6VectorIPNS_7RefBaseEE10do_destroyEPvj; - _ZNK7android6VectorIPNS_7RefBaseEE12do_constructEPvj; - _ZNK7android6VectorIPNS_7RefBaseEE15do_move_forwardEPvPKvj; - _ZNK7android6VectorIPNS_7RefBaseEE16do_move_backwardEPvPKvj; - _ZNK7android6VectorIPNS_7RefBaseEE7do_copyEPvPKvj; - _ZNK7android6VectorIPNS_7RefBaseEE8do_splatEPvPKvj; - _ZNK7android7BBinder10findObjectEPKv; - _ZNK7android7BBinder13isBinderAliveEv; - _ZNK7android7BBinder22getInterfaceDescriptorEv; - _ZNK7android7content2pm18PackageChangeEvent13writeToParcelEPNS_6ParcelE; - _ZNK7android7content2pm21IPackageManagerNative22getInterfaceDescriptorEv; - _ZNK7android7content2pm22IPackageChangeObserver22getInterfaceDescriptorEv; - _ZNK7android7IBinder13checkSubclassEPKv; - _ZNK7android7IMemory11fastPointerERKNS_2spINS_7IBinderEEEi; - _ZNK7android7IMemory15unsecurePointerEv; - _ZNK7android7IMemory22getInterfaceDescriptorEv; - _ZNK7android7IMemory4sizeEv; - _ZNK7android7IMemory6offsetEv; - _ZNK7android7IMemory7pointerEv; - _ZNK7android8BpBinder10findObjectEPKv; - _ZNK7android8BpBinder10rpcAddressEv; - _ZNK7android8BpBinder10rpcSessionEv; - _ZNK7android8BpBinder11isRpcBinderEv; - _ZNK7android8BpBinder12binderHandleEv; - _ZNK7android8BpBinder13isBinderAliveEv; - _ZNK7android8BpBinder13ObjectManager4findEPKv; - _ZNK7android8BpBinder18isDescriptorCachedEv; - _ZNK7android8BpBinder22getInterfaceDescriptorEv; - _ZNK7android8BpMemory9getMemoryEPiPj; - _ZNKSt3__115basic_stringbufIcNS_11char_traitsIcEENS_9allocatorIcEEE3strEv; - _ZNKSt3__16__treeINS_12__value_typeIN7android8String16EbEENS_19__map_value_compareIS3_S4_NS_4lessIS3_EELb1EEENS_9allocatorIS4_EEE4findIS3_EENS_21__tree_const_iteratorIS4_PNS_11__tree_nodeIS4_PvEEiEERKT_; - _ZNKSt3__16__treeINS_12__value_typeIN7android8String16EdEENS_19__map_value_compareIS3_S4_NS_4lessIS3_EELb1EEENS_9allocatorIS4_EEE4findIS3_EENS_21__tree_const_iteratorIS4_PNS_11__tree_nodeIS4_PvEEiEERKT_; - _ZNKSt3__16__treeINS_12__value_typeIN7android8String16EiEENS_19__map_value_compareIS3_S4_NS_4lessIS3_EELb1EEENS_9allocatorIS4_EEE4findIS3_EENS_21__tree_const_iteratorIS4_PNS_11__tree_nodeIS4_PvEEiEERKT_; - _ZNKSt3__16__treeINS_12__value_typeIN7android8String16ENS2_2os17PersistableBundleEEENS_19__map_value_compareIS3_S6_NS_4lessIS3_EELb1EEENS_9allocatorIS6_EEE4findIS3_EENS_21__tree_const_iteratorIS6_PNS_11__tree_nodeIS6_PvEEiEERKT_; - _ZNKSt3__16__treeINS_12__value_typeIN7android8String16ENS_6vectorIbNS_9allocatorIbEEEEEENS_19__map_value_compareIS3_S8_NS_4lessIS3_EELb1EEENS5_IS8_EEE4findIS3_EENS_21__tree_const_iteratorIS8_PNS_11__tree_nodeIS8_PvEEiEERKT_; - _ZNKSt3__16__treeINS_12__value_typeIN7android8String16ENS_6vectorIdNS_9allocatorIdEEEEEENS_19__map_value_compareIS3_S8_NS_4lessIS3_EELb1EEENS5_IS8_EEE4findIS3_EENS_21__tree_const_iteratorIS8_PNS_11__tree_nodeIS8_PvEEiEERKT_; - _ZNKSt3__16__treeINS_12__value_typeIN7android8String16ENS_6vectorIiNS_9allocatorIiEEEEEENS_19__map_value_compareIS3_S8_NS_4lessIS3_EELb1EEENS5_IS8_EEE4findIS3_EENS_21__tree_const_iteratorIS8_PNS_11__tree_nodeIS8_PvEEiEERKT_; - _ZNKSt3__16__treeINS_12__value_typeIN7android8String16ENS_6vectorIS3_NS_9allocatorIS3_EEEEEENS_19__map_value_compareIS3_S8_NS_4lessIS3_EELb1EEENS5_IS8_EEE4findIS3_EENS_21__tree_const_iteratorIS8_PNS_11__tree_nodeIS8_PvEEiEERKT_; - _ZNKSt3__16__treeINS_12__value_typeIN7android8String16ENS_6vectorIxNS_9allocatorIxEEEEEENS_19__map_value_compareIS3_S8_NS_4lessIS3_EELb1EEENS5_IS8_EEE4findIS3_EENS_21__tree_const_iteratorIS8_PNS_11__tree_nodeIS8_PvEEiEERKT_; - _ZNKSt3__16__treeINS_12__value_typeIN7android8String16ES3_EENS_19__map_value_compareIS3_S4_NS_4lessIS3_EELb1EEENS_9allocatorIS4_EEE4findIS3_EENS_21__tree_const_iteratorIS4_PNS_11__tree_nodeIS4_PvEEiEERKT_; - _ZNKSt3__16__treeINS_12__value_typeIN7android8String16ExEENS_19__map_value_compareIS3_S4_NS_4lessIS3_EELb1EEENS_9allocatorIS4_EEE4findIS3_EENS_21__tree_const_iteratorIS4_PNS_11__tree_nodeIS4_PvEEiEERKT_; - _ZNKSt3__16__treeINS_12__value_typeINS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEEN7android6binder8internal25ClientCounterCallbackImpl7ServiceEEENS_19__map_value_compareIS7_SD_NS_4lessIS7_EELb1EEENS5_ISD_EEE14__count_uniqueIS7_EEjRKT_; - _ZNSt3__111__sift_downIRNS_4lessIN7android8RpcState10BinderNode9AsyncTodoEEENS_11__wrap_iterIPS5_EEEEvT0_SB_T_NS_15iterator_traitsISB_E15difference_typeESB_; - _ZNSt3__111unique_lockINS_5mutexEE6unlockEv; - _ZNSt3__112__hash_tableINS_17__hash_value_typeIijEENS_22__unordered_map_hasherIiS2_NS_4hashIiEELb1EEENS_21__unordered_map_equalIiS2_NS_8equal_toIiEELb1EEENS_9allocatorIS2_EEE14__erase_uniqueIiEEjRKT_; - _ZNSt3__112__hash_tableINS_17__hash_value_typeIijEENS_22__unordered_map_hasherIiS2_NS_4hashIiEELb1EEENS_21__unordered_map_equalIiS2_NS_8equal_toIiEELb1EEENS_9allocatorIS2_EEE25__emplace_unique_key_argsIiJRKNS_21piecewise_construct_tENS_5tupleIJRKiEEENSI_IJEEEEEENS_4pairINS_15__hash_iteratorIPNS_11__hash_nodeIS2_PvEEEEbEERKT_DpOT0_; - _ZNSt3__112__hash_tableINS_17__hash_value_typeIijEENS_22__unordered_map_hasherIiS2_NS_4hashIiEELb1EEENS_21__unordered_map_equalIiS2_NS_8equal_toIiEELb1EEENS_9allocatorIS2_EEE6rehashEj; - _ZNSt3__112__hash_tableINS_17__hash_value_typeIijEENS_22__unordered_map_hasherIiS2_NS_4hashIiEELb1EEENS_21__unordered_map_equalIiS2_NS_8equal_toIiEELb1EEENS_9allocatorIS2_EEE6removeENS_21__hash_const_iteratorIPNS_11__hash_nodeIS2_PvEEEE; - _ZNSt3__112__hash_tableINS_17__hash_value_typeIijEENS_22__unordered_map_hasherIiS2_NS_4hashIiEELb1EEENS_21__unordered_map_equalIiS2_NS_8equal_toIiEELb1EEENS_9allocatorIS2_EEE8__rehashEj; - _ZNSt3__113__tree_removeIPNS_16__tree_node_baseIPvEEEEvT_S5_; - _ZNSt3__113unordered_mapIijNS_4hashIiEENS_8equal_toIiEENS_9allocatorINS_4pairIKijEEEEEixERS7_; - _ZNSt3__114__copy_alignedINS_6vectorIbNS_9allocatorIbEEEELb0EEENS_14__bit_iteratorIT_Lb0EXLi0EEEENS5_IS6_XT0_EXLi0EEEES8_S7_; - _ZNSt3__114__copy_alignedINS_6vectorIbNS_9allocatorIbEEEELb1EEENS_14__bit_iteratorIT_Lb0EXLi0EEEENS5_IS6_XT0_EXLi0EEEES8_S7_; - _ZNSt3__114__thread_proxyINS_5tupleIJNS_10unique_ptrINS_15__thread_structENS_14default_deleteIS3_EEEEMN7android9RpcServerEFvONS7_2spIS8_EENS7_4base14unique_fd_implINSC_13DefaultCloserEEEEPS8_SA_SF_EEEEEPvSK_; - _ZNSt3__115basic_stringbufIcNS_11char_traitsIcEENS_9allocatorIcEEE7seekoffExNS_8ios_base7seekdirEj; - _ZNSt3__115basic_stringbufIcNS_11char_traitsIcEENS_9allocatorIcEEE8overflowEi; - _ZNSt3__115basic_stringbufIcNS_11char_traitsIcEENS_9allocatorIcEEE9pbackfailEi; - _ZNSt3__115basic_stringbufIcNS_11char_traitsIcEENS_9allocatorIcEEE9underflowEv; - _ZNSt3__116__copy_unalignedINS_6vectorIbNS_9allocatorIbEEEELb0EEENS_14__bit_iteratorIT_Lb0EXLi0EEEENS5_IS6_XT0_EXLi0EEEES8_S7_; - _ZNSt3__116__copy_unalignedINS_6vectorIbNS_9allocatorIbEEEELb1EEENS_14__bit_iteratorIT_Lb0EXLi0EEEENS5_IS6_XT0_EXLi0EEEES8_S7_; - _ZNSt3__120__shared_ptr_emplaceIN7android14RpcWireAddressENS_9allocatorIS2_EEE16__on_zero_sharedEv; - _ZNSt3__120__shared_ptr_emplaceIN7android14RpcWireAddressENS_9allocatorIS2_EEE21__on_zero_shared_weakEv; - _ZNSt3__120__shared_ptr_emplaceIN7android6binder8internal21ClientCounterCallbackENS_9allocatorIS4_EEE16__on_zero_sharedEv; - _ZNSt3__120__shared_ptr_emplaceIN7android6binder8internal21ClientCounterCallbackENS_9allocatorIS4_EEE21__on_zero_shared_weakEv; - _ZNSt3__124__put_character_sequenceIcNS_11char_traitsIcEEEERNS_13basic_ostreamIT_T0_EES7_PKS4_j; - _ZNSt3__127__tree_balance_after_insertIPNS_16__tree_node_baseIPvEEEEvT_S5_; - _ZNSt3__13mapIiN7android2spINS1_10RpcSessionEEENS_4lessIiEENS_9allocatorINS_4pairIKiS4_EEEEEixERS9_; - _ZNSt3__13mapIN7android8String16EbNS_4lessIS2_EENS_9allocatorINS_4pairIKS2_bEEEEEixERS7_; - _ZNSt3__13mapIN7android8String16EdNS_4lessIS2_EENS_9allocatorINS_4pairIKS2_dEEEEEixERS7_; - _ZNSt3__13mapIN7android8String16EiNS_4lessIS2_EENS_9allocatorINS_4pairIKS2_iEEEEEixERS7_; - _ZNSt3__13mapIN7android8String16ENS1_2os17PersistableBundleENS_4lessIS2_EENS_9allocatorINS_4pairIKS2_S4_EEEEEixERS9_; - _ZNSt3__13mapIN7android8String16ENS_6vectorIbNS_9allocatorIbEEEENS_4lessIS2_EENS4_INS_4pairIKS2_S6_EEEEEixERSA_; - _ZNSt3__13mapIN7android8String16ENS_6vectorIdNS_9allocatorIdEEEENS_4lessIS2_EENS4_INS_4pairIKS2_S6_EEEEEixERSA_; - _ZNSt3__13mapIN7android8String16ENS_6vectorIiNS_9allocatorIiEEEENS_4lessIS2_EENS4_INS_4pairIKS2_S6_EEEEEixERSA_; - _ZNSt3__13mapIN7android8String16ENS_6vectorIS2_NS_9allocatorIS2_EEEENS_4lessIS2_EENS4_INS_4pairIKS2_S6_EEEEEixERSA_; - _ZNSt3__13mapIN7android8String16ENS_6vectorIxNS_9allocatorIxEEEENS_4lessIS2_EENS4_INS_4pairIKS2_S6_EEEEEixERSA_; - _ZNSt3__13mapIN7android8String16ES2_NS_4lessIS2_EENS_9allocatorINS_4pairIKS2_S2_EEEEEixERS7_; - _ZNSt3__13mapIN7android8String16ExNS_4lessIS2_EENS_9allocatorINS_4pairIKS2_xEEEEEixERS7_; - _ZNSt3__16__treeIN7android8String16ENS_4lessIS2_EENS_9allocatorIS2_EEE12__find_equalIS2_EERPNS_16__tree_node_baseIPvEERPNS_15__tree_end_nodeISC_EERKT_; - _ZNSt3__16__treeIN7android8String16ENS_4lessIS2_EENS_9allocatorIS2_EEE25__emplace_unique_key_argsIS2_JRKS2_EEENS_4pairINS_15__tree_iteratorIS2_PNS_11__tree_nodeIS2_PvEEiEEbEERKT_DpOT0_; - _ZNSt3__16__treeIN7android8String16ENS_4lessIS2_EENS_9allocatorIS2_EEE7destroyEPNS_11__tree_nodeIS2_PvEE; - _ZNSt3__16__treeINS_12__value_typeIiN7android2spINS2_10RpcSessionEEEEENS_19__map_value_compareIiS6_NS_4lessIiEELb1EEENS_9allocatorIS6_EEE5eraseENS_21__tree_const_iteratorIS6_PNS_11__tree_nodeIS6_PvEEiEE; - _ZNSt3__16__treeINS_12__value_typeIiN7android2spINS2_10RpcSessionEEEEENS_19__map_value_compareIiS6_NS_4lessIiEELb1EEENS_9allocatorIS6_EEE7destroyEPNS_11__tree_nodeIS6_PvEE; - _ZNSt3__16__treeINS_12__value_typeIN7android10RpcAddressENS2_8RpcState10BinderNodeEEENS_19__map_value_compareIS3_S6_NS_4lessIS3_EELb1EEENS_9allocatorIS6_EEE25__emplace_unique_key_argsIS3_JNS_4pairIKS3_S5_EEEEENSF_INS_15__tree_iteratorIS6_PNS_11__tree_nodeIS6_PvEEiEEbEERKT_DpOT0_; - _ZNSt3__16__treeINS_12__value_typeIN7android10RpcAddressENS2_8RpcState10BinderNodeEEENS_19__map_value_compareIS3_S6_NS_4lessIS3_EELb1EEENS_9allocatorIS6_EEE7destroyEPNS_11__tree_nodeIS6_PvEE; - _ZNSt3__16__treeINS_12__value_typeIN7android8String16EbEENS_19__map_value_compareIS3_S4_NS_4lessIS3_EELb1EEENS_9allocatorIS4_EEE12__find_equalIS3_EERPNS_16__tree_node_baseIPvEENS_21__tree_const_iteratorIS4_PNS_11__tree_nodeIS4_SE_EEiEERPNS_15__tree_end_nodeISG_EESH_RKT_; - _ZNSt3__16__treeINS_12__value_typeIN7android8String16EbEENS_19__map_value_compareIS3_S4_NS_4lessIS3_EELb1EEENS_9allocatorIS4_EEE12__find_equalIS3_EERPNS_16__tree_node_baseIPvEERPNS_15__tree_end_nodeISG_EERKT_; - _ZNSt3__16__treeINS_12__value_typeIN7android8String16EbEENS_19__map_value_compareIS3_S4_NS_4lessIS3_EELb1EEENS_9allocatorIS4_EEE14__assign_multiINS_21__tree_const_iteratorIS4_PNS_11__tree_nodeIS4_PvEEiEEEEvT_SJ_; - _ZNSt3__16__treeINS_12__value_typeIN7android8String16EbEENS_19__map_value_compareIS3_S4_NS_4lessIS3_EELb1EEENS_9allocatorIS4_EEE15__emplace_multiIJRKNS_4pairIKS3_bEEEEENS_15__tree_iteratorIS4_PNS_11__tree_nodeIS4_PvEEiEEDpOT_; - _ZNSt3__16__treeINS_12__value_typeIN7android8String16EbEENS_19__map_value_compareIS3_S4_NS_4lessIS3_EELb1EEENS_9allocatorIS4_EEE25__emplace_unique_key_argsIS3_JRKNS_21piecewise_construct_tENS_5tupleIJRKS3_EEENSG_IJEEEEEENS_4pairINS_15__tree_iteratorIS4_PNS_11__tree_nodeIS4_PvEEiEEbEERKT_DpOT0_; - _ZNSt3__16__treeINS_12__value_typeIN7android8String16EbEENS_19__map_value_compareIS3_S4_NS_4lessIS3_EELb1EEENS_9allocatorIS4_EEE30__emplace_hint_unique_key_argsIS3_JRKNS_4pairIKS3_bEEEEENS_15__tree_iteratorIS4_PNS_11__tree_nodeIS4_PvEEiEENS_21__tree_const_iteratorIS4_SM_iEERKT_DpOT0_; - _ZNSt3__16__treeINS_12__value_typeIN7android8String16EbEENS_19__map_value_compareIS3_S4_NS_4lessIS3_EELb1EEENS_9allocatorIS4_EEE4findIS3_EENS_15__tree_iteratorIS4_PNS_11__tree_nodeIS4_PvEEiEERKT_; - _ZNSt3__16__treeINS_12__value_typeIN7android8String16EbEENS_19__map_value_compareIS3_S4_NS_4lessIS3_EELb1EEENS_9allocatorIS4_EEE7destroyEPNS_11__tree_nodeIS4_PvEE; - _ZNSt3__16__treeINS_12__value_typeIN7android8String16EdEENS_19__map_value_compareIS3_S4_NS_4lessIS3_EELb1EEENS_9allocatorIS4_EEE12__find_equalIS3_EERPNS_16__tree_node_baseIPvEENS_21__tree_const_iteratorIS4_PNS_11__tree_nodeIS4_SE_EEiEERPNS_15__tree_end_nodeISG_EESH_RKT_; - _ZNSt3__16__treeINS_12__value_typeIN7android8String16EdEENS_19__map_value_compareIS3_S4_NS_4lessIS3_EELb1EEENS_9allocatorIS4_EEE12__find_equalIS3_EERPNS_16__tree_node_baseIPvEERPNS_15__tree_end_nodeISG_EERKT_; - _ZNSt3__16__treeINS_12__value_typeIN7android8String16EdEENS_19__map_value_compareIS3_S4_NS_4lessIS3_EELb1EEENS_9allocatorIS4_EEE14__assign_multiINS_21__tree_const_iteratorIS4_PNS_11__tree_nodeIS4_PvEEiEEEEvT_SJ_; - _ZNSt3__16__treeINS_12__value_typeIN7android8String16EdEENS_19__map_value_compareIS3_S4_NS_4lessIS3_EELb1EEENS_9allocatorIS4_EEE15__emplace_multiIJRKNS_4pairIKS3_dEEEEENS_15__tree_iteratorIS4_PNS_11__tree_nodeIS4_PvEEiEEDpOT_; - _ZNSt3__16__treeINS_12__value_typeIN7android8String16EdEENS_19__map_value_compareIS3_S4_NS_4lessIS3_EELb1EEENS_9allocatorIS4_EEE25__emplace_unique_key_argsIS3_JRKNS_21piecewise_construct_tENS_5tupleIJRKS3_EEENSG_IJEEEEEENS_4pairINS_15__tree_iteratorIS4_PNS_11__tree_nodeIS4_PvEEiEEbEERKT_DpOT0_; - _ZNSt3__16__treeINS_12__value_typeIN7android8String16EdEENS_19__map_value_compareIS3_S4_NS_4lessIS3_EELb1EEENS_9allocatorIS4_EEE30__emplace_hint_unique_key_argsIS3_JRKNS_4pairIKS3_dEEEEENS_15__tree_iteratorIS4_PNS_11__tree_nodeIS4_PvEEiEENS_21__tree_const_iteratorIS4_SM_iEERKT_DpOT0_; - _ZNSt3__16__treeINS_12__value_typeIN7android8String16EdEENS_19__map_value_compareIS3_S4_NS_4lessIS3_EELb1EEENS_9allocatorIS4_EEE4findIS3_EENS_15__tree_iteratorIS4_PNS_11__tree_nodeIS4_PvEEiEERKT_; - _ZNSt3__16__treeINS_12__value_typeIN7android8String16EdEENS_19__map_value_compareIS3_S4_NS_4lessIS3_EELb1EEENS_9allocatorIS4_EEE7destroyEPNS_11__tree_nodeIS4_PvEE; - _ZNSt3__16__treeINS_12__value_typeIN7android8String16EiEENS_19__map_value_compareIS3_S4_NS_4lessIS3_EELb1EEENS_9allocatorIS4_EEE12__find_equalIS3_EERPNS_16__tree_node_baseIPvEENS_21__tree_const_iteratorIS4_PNS_11__tree_nodeIS4_SE_EEiEERPNS_15__tree_end_nodeISG_EESH_RKT_; - _ZNSt3__16__treeINS_12__value_typeIN7android8String16EiEENS_19__map_value_compareIS3_S4_NS_4lessIS3_EELb1EEENS_9allocatorIS4_EEE12__find_equalIS3_EERPNS_16__tree_node_baseIPvEERPNS_15__tree_end_nodeISG_EERKT_; - _ZNSt3__16__treeINS_12__value_typeIN7android8String16EiEENS_19__map_value_compareIS3_S4_NS_4lessIS3_EELb1EEENS_9allocatorIS4_EEE14__assign_multiINS_21__tree_const_iteratorIS4_PNS_11__tree_nodeIS4_PvEEiEEEEvT_SJ_; - _ZNSt3__16__treeINS_12__value_typeIN7android8String16EiEENS_19__map_value_compareIS3_S4_NS_4lessIS3_EELb1EEENS_9allocatorIS4_EEE15__emplace_multiIJRKNS_4pairIKS3_iEEEEENS_15__tree_iteratorIS4_PNS_11__tree_nodeIS4_PvEEiEEDpOT_; - _ZNSt3__16__treeINS_12__value_typeIN7android8String16EiEENS_19__map_value_compareIS3_S4_NS_4lessIS3_EELb1EEENS_9allocatorIS4_EEE25__emplace_unique_key_argsIS3_JRKNS_21piecewise_construct_tENS_5tupleIJRKS3_EEENSG_IJEEEEEENS_4pairINS_15__tree_iteratorIS4_PNS_11__tree_nodeIS4_PvEEiEEbEERKT_DpOT0_; - _ZNSt3__16__treeINS_12__value_typeIN7android8String16EiEENS_19__map_value_compareIS3_S4_NS_4lessIS3_EELb1EEENS_9allocatorIS4_EEE30__emplace_hint_unique_key_argsIS3_JRKNS_4pairIKS3_iEEEEENS_15__tree_iteratorIS4_PNS_11__tree_nodeIS4_PvEEiEENS_21__tree_const_iteratorIS4_SM_iEERKT_DpOT0_; - _ZNSt3__16__treeINS_12__value_typeIN7android8String16EiEENS_19__map_value_compareIS3_S4_NS_4lessIS3_EELb1EEENS_9allocatorIS4_EEE4findIS3_EENS_15__tree_iteratorIS4_PNS_11__tree_nodeIS4_PvEEiEERKT_; - _ZNSt3__16__treeINS_12__value_typeIN7android8String16EiEENS_19__map_value_compareIS3_S4_NS_4lessIS3_EELb1EEENS_9allocatorIS4_EEE7destroyEPNS_11__tree_nodeIS4_PvEE; - _ZNSt3__16__treeINS_12__value_typeIN7android8String16ENS2_2os17PersistableBundleEEENS_19__map_value_compareIS3_S6_NS_4lessIS3_EELb1EEENS_9allocatorIS6_EEE12__find_equalIS3_EERPNS_16__tree_node_baseIPvEENS_21__tree_const_iteratorIS6_PNS_11__tree_nodeIS6_SG_EEiEERPNS_15__tree_end_nodeISI_EESJ_RKT_; - _ZNSt3__16__treeINS_12__value_typeIN7android8String16ENS2_2os17PersistableBundleEEENS_19__map_value_compareIS3_S6_NS_4lessIS3_EELb1EEENS_9allocatorIS6_EEE12__find_equalIS3_EERPNS_16__tree_node_baseIPvEERPNS_15__tree_end_nodeISI_EERKT_; - _ZNSt3__16__treeINS_12__value_typeIN7android8String16ENS2_2os17PersistableBundleEEENS_19__map_value_compareIS3_S6_NS_4lessIS3_EELb1EEENS_9allocatorIS6_EEE14__assign_multiINS_21__tree_const_iteratorIS6_PNS_11__tree_nodeIS6_PvEEiEEEEvT_SL_; - _ZNSt3__16__treeINS_12__value_typeIN7android8String16ENS2_2os17PersistableBundleEEENS_19__map_value_compareIS3_S6_NS_4lessIS3_EELb1EEENS_9allocatorIS6_EEE14__erase_uniqueIS3_EEjRKT_; - _ZNSt3__16__treeINS_12__value_typeIN7android8String16ENS2_2os17PersistableBundleEEENS_19__map_value_compareIS3_S6_NS_4lessIS3_EELb1EEENS_9allocatorIS6_EEE15__emplace_multiIJRKNS_4pairIKS3_S5_EEEEENS_15__tree_iteratorIS6_PNS_11__tree_nodeIS6_PvEEiEEDpOT_; - _ZNSt3__16__treeINS_12__value_typeIN7android8String16ENS2_2os17PersistableBundleEEENS_19__map_value_compareIS3_S6_NS_4lessIS3_EELb1EEENS_9allocatorIS6_EEE25__emplace_unique_key_argsIS3_JRKNS_21piecewise_construct_tENS_5tupleIJRKS3_EEENSI_IJEEEEEENS_4pairINS_15__tree_iteratorIS6_PNS_11__tree_nodeIS6_PvEEiEEbEERKT_DpOT0_; - _ZNSt3__16__treeINS_12__value_typeIN7android8String16ENS2_2os17PersistableBundleEEENS_19__map_value_compareIS3_S6_NS_4lessIS3_EELb1EEENS_9allocatorIS6_EEE30__emplace_hint_unique_key_argsIS3_JRKNS_4pairIKS3_S5_EEEEENS_15__tree_iteratorIS6_PNS_11__tree_nodeIS6_PvEEiEENS_21__tree_const_iteratorIS6_SO_iEERKT_DpOT0_; - _ZNSt3__16__treeINS_12__value_typeIN7android8String16ENS2_2os17PersistableBundleEEENS_19__map_value_compareIS3_S6_NS_4lessIS3_EELb1EEENS_9allocatorIS6_EEE4findIS3_EENS_15__tree_iteratorIS6_PNS_11__tree_nodeIS6_PvEEiEERKT_; - _ZNSt3__16__treeINS_12__value_typeIN7android8String16ENS2_2os17PersistableBundleEEENS_19__map_value_compareIS3_S6_NS_4lessIS3_EELb1EEENS_9allocatorIS6_EEE5eraseENS_21__tree_const_iteratorIS6_PNS_11__tree_nodeIS6_PvEEiEE; - _ZNSt3__16__treeINS_12__value_typeIN7android8String16ENS2_2os17PersistableBundleEEENS_19__map_value_compareIS3_S6_NS_4lessIS3_EELb1EEENS_9allocatorIS6_EEE7destroyEPNS_11__tree_nodeIS6_PvEE; - _ZNSt3__16__treeINS_12__value_typeIN7android8String16ENS_6vectorIbNS_9allocatorIbEEEEEENS_19__map_value_compareIS3_S8_NS_4lessIS3_EELb1EEENS5_IS8_EEE12__find_equalIS3_EERPNS_16__tree_node_baseIPvEENS_21__tree_const_iteratorIS8_PNS_11__tree_nodeIS8_SH_EEiEERPNS_15__tree_end_nodeISJ_EESK_RKT_; - _ZNSt3__16__treeINS_12__value_typeIN7android8String16ENS_6vectorIbNS_9allocatorIbEEEEEENS_19__map_value_compareIS3_S8_NS_4lessIS3_EELb1EEENS5_IS8_EEE12__find_equalIS3_EERPNS_16__tree_node_baseIPvEERPNS_15__tree_end_nodeISJ_EERKT_; - _ZNSt3__16__treeINS_12__value_typeIN7android8String16ENS_6vectorIbNS_9allocatorIbEEEEEENS_19__map_value_compareIS3_S8_NS_4lessIS3_EELb1EEENS5_IS8_EEE14__assign_multiINS_21__tree_const_iteratorIS8_PNS_11__tree_nodeIS8_PvEEiEEEEvT_SM_; - _ZNSt3__16__treeINS_12__value_typeIN7android8String16ENS_6vectorIbNS_9allocatorIbEEEEEENS_19__map_value_compareIS3_S8_NS_4lessIS3_EELb1EEENS5_IS8_EEE14__erase_uniqueIS3_EEjRKT_; - _ZNSt3__16__treeINS_12__value_typeIN7android8String16ENS_6vectorIbNS_9allocatorIbEEEEEENS_19__map_value_compareIS3_S8_NS_4lessIS3_EELb1EEENS5_IS8_EEE15__emplace_multiIJRKNS_4pairIKS3_S7_EEEEENS_15__tree_iteratorIS8_PNS_11__tree_nodeIS8_PvEEiEEDpOT_; - _ZNSt3__16__treeINS_12__value_typeIN7android8String16ENS_6vectorIbNS_9allocatorIbEEEEEENS_19__map_value_compareIS3_S8_NS_4lessIS3_EELb1EEENS5_IS8_EEE25__emplace_unique_key_argsIS3_JRKNS_21piecewise_construct_tENS_5tupleIJRKS3_EEENSJ_IJEEEEEENS_4pairINS_15__tree_iteratorIS8_PNS_11__tree_nodeIS8_PvEEiEEbEERKT_DpOT0_; - _ZNSt3__16__treeINS_12__value_typeIN7android8String16ENS_6vectorIbNS_9allocatorIbEEEEEENS_19__map_value_compareIS3_S8_NS_4lessIS3_EELb1EEENS5_IS8_EEE30__emplace_hint_unique_key_argsIS3_JRKNS_4pairIKS3_S7_EEEEENS_15__tree_iteratorIS8_PNS_11__tree_nodeIS8_PvEEiEENS_21__tree_const_iteratorIS8_SP_iEERKT_DpOT0_; - _ZNSt3__16__treeINS_12__value_typeIN7android8String16ENS_6vectorIbNS_9allocatorIbEEEEEENS_19__map_value_compareIS3_S8_NS_4lessIS3_EELb1EEENS5_IS8_EEE4findIS3_EENS_15__tree_iteratorIS8_PNS_11__tree_nodeIS8_PvEEiEERKT_; - _ZNSt3__16__treeINS_12__value_typeIN7android8String16ENS_6vectorIbNS_9allocatorIbEEEEEENS_19__map_value_compareIS3_S8_NS_4lessIS3_EELb1EEENS5_IS8_EEE5eraseENS_21__tree_const_iteratorIS8_PNS_11__tree_nodeIS8_PvEEiEE; - _ZNSt3__16__treeINS_12__value_typeIN7android8String16ENS_6vectorIbNS_9allocatorIbEEEEEENS_19__map_value_compareIS3_S8_NS_4lessIS3_EELb1EEENS5_IS8_EEE7destroyEPNS_11__tree_nodeIS8_PvEE; - _ZNSt3__16__treeINS_12__value_typeIN7android8String16ENS_6vectorIdNS_9allocatorIdEEEEEENS_19__map_value_compareIS3_S8_NS_4lessIS3_EELb1EEENS5_IS8_EEE12__find_equalIS3_EERPNS_16__tree_node_baseIPvEENS_21__tree_const_iteratorIS8_PNS_11__tree_nodeIS8_SH_EEiEERPNS_15__tree_end_nodeISJ_EESK_RKT_; - _ZNSt3__16__treeINS_12__value_typeIN7android8String16ENS_6vectorIdNS_9allocatorIdEEEEEENS_19__map_value_compareIS3_S8_NS_4lessIS3_EELb1EEENS5_IS8_EEE12__find_equalIS3_EERPNS_16__tree_node_baseIPvEERPNS_15__tree_end_nodeISJ_EERKT_; - _ZNSt3__16__treeINS_12__value_typeIN7android8String16ENS_6vectorIdNS_9allocatorIdEEEEEENS_19__map_value_compareIS3_S8_NS_4lessIS3_EELb1EEENS5_IS8_EEE14__assign_multiINS_21__tree_const_iteratorIS8_PNS_11__tree_nodeIS8_PvEEiEEEEvT_SM_; - _ZNSt3__16__treeINS_12__value_typeIN7android8String16ENS_6vectorIdNS_9allocatorIdEEEEEENS_19__map_value_compareIS3_S8_NS_4lessIS3_EELb1EEENS5_IS8_EEE14__erase_uniqueIS3_EEjRKT_; - _ZNSt3__16__treeINS_12__value_typeIN7android8String16ENS_6vectorIdNS_9allocatorIdEEEEEENS_19__map_value_compareIS3_S8_NS_4lessIS3_EELb1EEENS5_IS8_EEE15__emplace_multiIJRKNS_4pairIKS3_S7_EEEEENS_15__tree_iteratorIS8_PNS_11__tree_nodeIS8_PvEEiEEDpOT_; - _ZNSt3__16__treeINS_12__value_typeIN7android8String16ENS_6vectorIdNS_9allocatorIdEEEEEENS_19__map_value_compareIS3_S8_NS_4lessIS3_EELb1EEENS5_IS8_EEE25__emplace_unique_key_argsIS3_JRKNS_21piecewise_construct_tENS_5tupleIJRKS3_EEENSJ_IJEEEEEENS_4pairINS_15__tree_iteratorIS8_PNS_11__tree_nodeIS8_PvEEiEEbEERKT_DpOT0_; - _ZNSt3__16__treeINS_12__value_typeIN7android8String16ENS_6vectorIdNS_9allocatorIdEEEEEENS_19__map_value_compareIS3_S8_NS_4lessIS3_EELb1EEENS5_IS8_EEE30__emplace_hint_unique_key_argsIS3_JRKNS_4pairIKS3_S7_EEEEENS_15__tree_iteratorIS8_PNS_11__tree_nodeIS8_PvEEiEENS_21__tree_const_iteratorIS8_SP_iEERKT_DpOT0_; - _ZNSt3__16__treeINS_12__value_typeIN7android8String16ENS_6vectorIdNS_9allocatorIdEEEEEENS_19__map_value_compareIS3_S8_NS_4lessIS3_EELb1EEENS5_IS8_EEE4findIS3_EENS_15__tree_iteratorIS8_PNS_11__tree_nodeIS8_PvEEiEERKT_; - _ZNSt3__16__treeINS_12__value_typeIN7android8String16ENS_6vectorIdNS_9allocatorIdEEEEEENS_19__map_value_compareIS3_S8_NS_4lessIS3_EELb1EEENS5_IS8_EEE5eraseENS_21__tree_const_iteratorIS8_PNS_11__tree_nodeIS8_PvEEiEE; - _ZNSt3__16__treeINS_12__value_typeIN7android8String16ENS_6vectorIdNS_9allocatorIdEEEEEENS_19__map_value_compareIS3_S8_NS_4lessIS3_EELb1EEENS5_IS8_EEE7destroyEPNS_11__tree_nodeIS8_PvEE; - _ZNSt3__16__treeINS_12__value_typeIN7android8String16ENS_6vectorIiNS_9allocatorIiEEEEEENS_19__map_value_compareIS3_S8_NS_4lessIS3_EELb1EEENS5_IS8_EEE12__find_equalIS3_EERPNS_16__tree_node_baseIPvEENS_21__tree_const_iteratorIS8_PNS_11__tree_nodeIS8_SH_EEiEERPNS_15__tree_end_nodeISJ_EESK_RKT_; - _ZNSt3__16__treeINS_12__value_typeIN7android8String16ENS_6vectorIiNS_9allocatorIiEEEEEENS_19__map_value_compareIS3_S8_NS_4lessIS3_EELb1EEENS5_IS8_EEE12__find_equalIS3_EERPNS_16__tree_node_baseIPvEERPNS_15__tree_end_nodeISJ_EERKT_; - _ZNSt3__16__treeINS_12__value_typeIN7android8String16ENS_6vectorIiNS_9allocatorIiEEEEEENS_19__map_value_compareIS3_S8_NS_4lessIS3_EELb1EEENS5_IS8_EEE14__assign_multiINS_21__tree_const_iteratorIS8_PNS_11__tree_nodeIS8_PvEEiEEEEvT_SM_; - _ZNSt3__16__treeINS_12__value_typeIN7android8String16ENS_6vectorIiNS_9allocatorIiEEEEEENS_19__map_value_compareIS3_S8_NS_4lessIS3_EELb1EEENS5_IS8_EEE14__erase_uniqueIS3_EEjRKT_; - _ZNSt3__16__treeINS_12__value_typeIN7android8String16ENS_6vectorIiNS_9allocatorIiEEEEEENS_19__map_value_compareIS3_S8_NS_4lessIS3_EELb1EEENS5_IS8_EEE15__emplace_multiIJRKNS_4pairIKS3_S7_EEEEENS_15__tree_iteratorIS8_PNS_11__tree_nodeIS8_PvEEiEEDpOT_; - _ZNSt3__16__treeINS_12__value_typeIN7android8String16ENS_6vectorIiNS_9allocatorIiEEEEEENS_19__map_value_compareIS3_S8_NS_4lessIS3_EELb1EEENS5_IS8_EEE25__emplace_unique_key_argsIS3_JRKNS_21piecewise_construct_tENS_5tupleIJRKS3_EEENSJ_IJEEEEEENS_4pairINS_15__tree_iteratorIS8_PNS_11__tree_nodeIS8_PvEEiEEbEERKT_DpOT0_; - _ZNSt3__16__treeINS_12__value_typeIN7android8String16ENS_6vectorIiNS_9allocatorIiEEEEEENS_19__map_value_compareIS3_S8_NS_4lessIS3_EELb1EEENS5_IS8_EEE30__emplace_hint_unique_key_argsIS3_JRKNS_4pairIKS3_S7_EEEEENS_15__tree_iteratorIS8_PNS_11__tree_nodeIS8_PvEEiEENS_21__tree_const_iteratorIS8_SP_iEERKT_DpOT0_; - _ZNSt3__16__treeINS_12__value_typeIN7android8String16ENS_6vectorIiNS_9allocatorIiEEEEEENS_19__map_value_compareIS3_S8_NS_4lessIS3_EELb1EEENS5_IS8_EEE4findIS3_EENS_15__tree_iteratorIS8_PNS_11__tree_nodeIS8_PvEEiEERKT_; - _ZNSt3__16__treeINS_12__value_typeIN7android8String16ENS_6vectorIiNS_9allocatorIiEEEEEENS_19__map_value_compareIS3_S8_NS_4lessIS3_EELb1EEENS5_IS8_EEE5eraseENS_21__tree_const_iteratorIS8_PNS_11__tree_nodeIS8_PvEEiEE; - _ZNSt3__16__treeINS_12__value_typeIN7android8String16ENS_6vectorIiNS_9allocatorIiEEEEEENS_19__map_value_compareIS3_S8_NS_4lessIS3_EELb1EEENS5_IS8_EEE7destroyEPNS_11__tree_nodeIS8_PvEE; - _ZNSt3__16__treeINS_12__value_typeIN7android8String16ENS_6vectorIS3_NS_9allocatorIS3_EEEEEENS_19__map_value_compareIS3_S8_NS_4lessIS3_EELb1EEENS5_IS8_EEE12__find_equalIS3_EERPNS_16__tree_node_baseIPvEENS_21__tree_const_iteratorIS8_PNS_11__tree_nodeIS8_SH_EEiEERPNS_15__tree_end_nodeISJ_EESK_RKT_; - _ZNSt3__16__treeINS_12__value_typeIN7android8String16ENS_6vectorIS3_NS_9allocatorIS3_EEEEEENS_19__map_value_compareIS3_S8_NS_4lessIS3_EELb1EEENS5_IS8_EEE12__find_equalIS3_EERPNS_16__tree_node_baseIPvEERPNS_15__tree_end_nodeISJ_EERKT_; - _ZNSt3__16__treeINS_12__value_typeIN7android8String16ENS_6vectorIS3_NS_9allocatorIS3_EEEEEENS_19__map_value_compareIS3_S8_NS_4lessIS3_EELb1EEENS5_IS8_EEE14__assign_multiINS_21__tree_const_iteratorIS8_PNS_11__tree_nodeIS8_PvEEiEEEEvT_SM_; - _ZNSt3__16__treeINS_12__value_typeIN7android8String16ENS_6vectorIS3_NS_9allocatorIS3_EEEEEENS_19__map_value_compareIS3_S8_NS_4lessIS3_EELb1EEENS5_IS8_EEE14__erase_uniqueIS3_EEjRKT_; - _ZNSt3__16__treeINS_12__value_typeIN7android8String16ENS_6vectorIS3_NS_9allocatorIS3_EEEEEENS_19__map_value_compareIS3_S8_NS_4lessIS3_EELb1EEENS5_IS8_EEE15__emplace_multiIJRKNS_4pairIKS3_S7_EEEEENS_15__tree_iteratorIS8_PNS_11__tree_nodeIS8_PvEEiEEDpOT_; - _ZNSt3__16__treeINS_12__value_typeIN7android8String16ENS_6vectorIS3_NS_9allocatorIS3_EEEEEENS_19__map_value_compareIS3_S8_NS_4lessIS3_EELb1EEENS5_IS8_EEE25__emplace_unique_key_argsIS3_JRKNS_21piecewise_construct_tENS_5tupleIJRKS3_EEENSJ_IJEEEEEENS_4pairINS_15__tree_iteratorIS8_PNS_11__tree_nodeIS8_PvEEiEEbEERKT_DpOT0_; - _ZNSt3__16__treeINS_12__value_typeIN7android8String16ENS_6vectorIS3_NS_9allocatorIS3_EEEEEENS_19__map_value_compareIS3_S8_NS_4lessIS3_EELb1EEENS5_IS8_EEE30__emplace_hint_unique_key_argsIS3_JRKNS_4pairIKS3_S7_EEEEENS_15__tree_iteratorIS8_PNS_11__tree_nodeIS8_PvEEiEENS_21__tree_const_iteratorIS8_SP_iEERKT_DpOT0_; - _ZNSt3__16__treeINS_12__value_typeIN7android8String16ENS_6vectorIS3_NS_9allocatorIS3_EEEEEENS_19__map_value_compareIS3_S8_NS_4lessIS3_EELb1EEENS5_IS8_EEE4findIS3_EENS_15__tree_iteratorIS8_PNS_11__tree_nodeIS8_PvEEiEERKT_; - _ZNSt3__16__treeINS_12__value_typeIN7android8String16ENS_6vectorIS3_NS_9allocatorIS3_EEEEEENS_19__map_value_compareIS3_S8_NS_4lessIS3_EELb1EEENS5_IS8_EEE5eraseENS_21__tree_const_iteratorIS8_PNS_11__tree_nodeIS8_PvEEiEE; - _ZNSt3__16__treeINS_12__value_typeIN7android8String16ENS_6vectorIS3_NS_9allocatorIS3_EEEEEENS_19__map_value_compareIS3_S8_NS_4lessIS3_EELb1EEENS5_IS8_EEE7destroyEPNS_11__tree_nodeIS8_PvEE; - _ZNSt3__16__treeINS_12__value_typeIN7android8String16ENS_6vectorIxNS_9allocatorIxEEEEEENS_19__map_value_compareIS3_S8_NS_4lessIS3_EELb1EEENS5_IS8_EEE12__find_equalIS3_EERPNS_16__tree_node_baseIPvEENS_21__tree_const_iteratorIS8_PNS_11__tree_nodeIS8_SH_EEiEERPNS_15__tree_end_nodeISJ_EESK_RKT_; - _ZNSt3__16__treeINS_12__value_typeIN7android8String16ENS_6vectorIxNS_9allocatorIxEEEEEENS_19__map_value_compareIS3_S8_NS_4lessIS3_EELb1EEENS5_IS8_EEE12__find_equalIS3_EERPNS_16__tree_node_baseIPvEERPNS_15__tree_end_nodeISJ_EERKT_; - _ZNSt3__16__treeINS_12__value_typeIN7android8String16ENS_6vectorIxNS_9allocatorIxEEEEEENS_19__map_value_compareIS3_S8_NS_4lessIS3_EELb1EEENS5_IS8_EEE14__assign_multiINS_21__tree_const_iteratorIS8_PNS_11__tree_nodeIS8_PvEEiEEEEvT_SM_; - _ZNSt3__16__treeINS_12__value_typeIN7android8String16ENS_6vectorIxNS_9allocatorIxEEEEEENS_19__map_value_compareIS3_S8_NS_4lessIS3_EELb1EEENS5_IS8_EEE14__erase_uniqueIS3_EEjRKT_; - _ZNSt3__16__treeINS_12__value_typeIN7android8String16ENS_6vectorIxNS_9allocatorIxEEEEEENS_19__map_value_compareIS3_S8_NS_4lessIS3_EELb1EEENS5_IS8_EEE15__emplace_multiIJRKNS_4pairIKS3_S7_EEEEENS_15__tree_iteratorIS8_PNS_11__tree_nodeIS8_PvEEiEEDpOT_; - _ZNSt3__16__treeINS_12__value_typeIN7android8String16ENS_6vectorIxNS_9allocatorIxEEEEEENS_19__map_value_compareIS3_S8_NS_4lessIS3_EELb1EEENS5_IS8_EEE25__emplace_unique_key_argsIS3_JRKNS_21piecewise_construct_tENS_5tupleIJRKS3_EEENSJ_IJEEEEEENS_4pairINS_15__tree_iteratorIS8_PNS_11__tree_nodeIS8_PvEEiEEbEERKT_DpOT0_; - _ZNSt3__16__treeINS_12__value_typeIN7android8String16ENS_6vectorIxNS_9allocatorIxEEEEEENS_19__map_value_compareIS3_S8_NS_4lessIS3_EELb1EEENS5_IS8_EEE30__emplace_hint_unique_key_argsIS3_JRKNS_4pairIKS3_S7_EEEEENS_15__tree_iteratorIS8_PNS_11__tree_nodeIS8_PvEEiEENS_21__tree_const_iteratorIS8_SP_iEERKT_DpOT0_; - _ZNSt3__16__treeINS_12__value_typeIN7android8String16ENS_6vectorIxNS_9allocatorIxEEEEEENS_19__map_value_compareIS3_S8_NS_4lessIS3_EELb1EEENS5_IS8_EEE4findIS3_EENS_15__tree_iteratorIS8_PNS_11__tree_nodeIS8_PvEEiEERKT_; - _ZNSt3__16__treeINS_12__value_typeIN7android8String16ENS_6vectorIxNS_9allocatorIxEEEEEENS_19__map_value_compareIS3_S8_NS_4lessIS3_EELb1EEENS5_IS8_EEE5eraseENS_21__tree_const_iteratorIS8_PNS_11__tree_nodeIS8_PvEEiEE; - _ZNSt3__16__treeINS_12__value_typeIN7android8String16ENS_6vectorIxNS_9allocatorIxEEEEEENS_19__map_value_compareIS3_S8_NS_4lessIS3_EELb1EEENS5_IS8_EEE7destroyEPNS_11__tree_nodeIS8_PvEE; - _ZNSt3__16__treeINS_12__value_typeIN7android8String16ES3_EENS_19__map_value_compareIS3_S4_NS_4lessIS3_EELb1EEENS_9allocatorIS4_EEE12__find_equalIS3_EERPNS_16__tree_node_baseIPvEENS_21__tree_const_iteratorIS4_PNS_11__tree_nodeIS4_SE_EEiEERPNS_15__tree_end_nodeISG_EESH_RKT_; - _ZNSt3__16__treeINS_12__value_typeIN7android8String16ES3_EENS_19__map_value_compareIS3_S4_NS_4lessIS3_EELb1EEENS_9allocatorIS4_EEE12__find_equalIS3_EERPNS_16__tree_node_baseIPvEERPNS_15__tree_end_nodeISG_EERKT_; - _ZNSt3__16__treeINS_12__value_typeIN7android8String16ES3_EENS_19__map_value_compareIS3_S4_NS_4lessIS3_EELb1EEENS_9allocatorIS4_EEE14__assign_multiINS_21__tree_const_iteratorIS4_PNS_11__tree_nodeIS4_PvEEiEEEEvT_SJ_; - _ZNSt3__16__treeINS_12__value_typeIN7android8String16ES3_EENS_19__map_value_compareIS3_S4_NS_4lessIS3_EELb1EEENS_9allocatorIS4_EEE14__erase_uniqueIS3_EEjRKT_; - _ZNSt3__16__treeINS_12__value_typeIN7android8String16ES3_EENS_19__map_value_compareIS3_S4_NS_4lessIS3_EELb1EEENS_9allocatorIS4_EEE15__emplace_multiIJRKNS_4pairIKS3_S3_EEEEENS_15__tree_iteratorIS4_PNS_11__tree_nodeIS4_PvEEiEEDpOT_; - _ZNSt3__16__treeINS_12__value_typeIN7android8String16ES3_EENS_19__map_value_compareIS3_S4_NS_4lessIS3_EELb1EEENS_9allocatorIS4_EEE25__emplace_unique_key_argsIS3_JRKNS_21piecewise_construct_tENS_5tupleIJRKS3_EEENSG_IJEEEEEENS_4pairINS_15__tree_iteratorIS4_PNS_11__tree_nodeIS4_PvEEiEEbEERKT_DpOT0_; - _ZNSt3__16__treeINS_12__value_typeIN7android8String16ES3_EENS_19__map_value_compareIS3_S4_NS_4lessIS3_EELb1EEENS_9allocatorIS4_EEE30__emplace_hint_unique_key_argsIS3_JRKNS_4pairIKS3_S3_EEEEENS_15__tree_iteratorIS4_PNS_11__tree_nodeIS4_PvEEiEENS_21__tree_const_iteratorIS4_SM_iEERKT_DpOT0_; - _ZNSt3__16__treeINS_12__value_typeIN7android8String16ES3_EENS_19__map_value_compareIS3_S4_NS_4lessIS3_EELb1EEENS_9allocatorIS4_EEE4findIS3_EENS_15__tree_iteratorIS4_PNS_11__tree_nodeIS4_PvEEiEERKT_; - _ZNSt3__16__treeINS_12__value_typeIN7android8String16ES3_EENS_19__map_value_compareIS3_S4_NS_4lessIS3_EELb1EEENS_9allocatorIS4_EEE5eraseENS_21__tree_const_iteratorIS4_PNS_11__tree_nodeIS4_PvEEiEE; - _ZNSt3__16__treeINS_12__value_typeIN7android8String16ES3_EENS_19__map_value_compareIS3_S4_NS_4lessIS3_EELb1EEENS_9allocatorIS4_EEE7destroyEPNS_11__tree_nodeIS4_PvEE; - _ZNSt3__16__treeINS_12__value_typeIN7android8String16ExEENS_19__map_value_compareIS3_S4_NS_4lessIS3_EELb1EEENS_9allocatorIS4_EEE12__find_equalIS3_EERPNS_16__tree_node_baseIPvEENS_21__tree_const_iteratorIS4_PNS_11__tree_nodeIS4_SE_EEiEERPNS_15__tree_end_nodeISG_EESH_RKT_; - _ZNSt3__16__treeINS_12__value_typeIN7android8String16ExEENS_19__map_value_compareIS3_S4_NS_4lessIS3_EELb1EEENS_9allocatorIS4_EEE12__find_equalIS3_EERPNS_16__tree_node_baseIPvEERPNS_15__tree_end_nodeISG_EERKT_; - _ZNSt3__16__treeINS_12__value_typeIN7android8String16ExEENS_19__map_value_compareIS3_S4_NS_4lessIS3_EELb1EEENS_9allocatorIS4_EEE14__assign_multiINS_21__tree_const_iteratorIS4_PNS_11__tree_nodeIS4_PvEEiEEEEvT_SJ_; - _ZNSt3__16__treeINS_12__value_typeIN7android8String16ExEENS_19__map_value_compareIS3_S4_NS_4lessIS3_EELb1EEENS_9allocatorIS4_EEE15__emplace_multiIJRKNS_4pairIKS3_xEEEEENS_15__tree_iteratorIS4_PNS_11__tree_nodeIS4_PvEEiEEDpOT_; - _ZNSt3__16__treeINS_12__value_typeIN7android8String16ExEENS_19__map_value_compareIS3_S4_NS_4lessIS3_EELb1EEENS_9allocatorIS4_EEE25__emplace_unique_key_argsIS3_JRKNS_21piecewise_construct_tENS_5tupleIJRKS3_EEENSG_IJEEEEEENS_4pairINS_15__tree_iteratorIS4_PNS_11__tree_nodeIS4_PvEEiEEbEERKT_DpOT0_; - _ZNSt3__16__treeINS_12__value_typeIN7android8String16ExEENS_19__map_value_compareIS3_S4_NS_4lessIS3_EELb1EEENS_9allocatorIS4_EEE30__emplace_hint_unique_key_argsIS3_JRKNS_4pairIKS3_xEEEEENS_15__tree_iteratorIS4_PNS_11__tree_nodeIS4_PvEEiEENS_21__tree_const_iteratorIS4_SM_iEERKT_DpOT0_; - _ZNSt3__16__treeINS_12__value_typeIN7android8String16ExEENS_19__map_value_compareIS3_S4_NS_4lessIS3_EELb1EEENS_9allocatorIS4_EEE4findIS3_EENS_15__tree_iteratorIS4_PNS_11__tree_nodeIS4_PvEEiEERKT_; - _ZNSt3__16__treeINS_12__value_typeIN7android8String16ExEENS_19__map_value_compareIS3_S4_NS_4lessIS3_EELb1EEENS_9allocatorIS4_EEE7destroyEPNS_11__tree_nodeIS4_PvEE; - _ZNSt3__16__treeINS_12__value_typeINS_11__thread_idENS_6threadEEENS_19__map_value_compareIS2_S4_NS_4lessIS2_EELb1EEENS_9allocatorIS4_EEE7destroyEPNS_11__tree_nodeIS4_PvEE; - _ZNSt3__16__treeINS_12__value_typeINS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEEN7android6binder8internal25ClientCounterCallbackImpl7ServiceEEENS_19__map_value_compareIS7_SD_NS_4lessIS7_EELb1EEENS5_ISD_EEE12__find_equalIS7_EERPNS_16__tree_node_baseIPvEERPNS_15__tree_end_nodeISO_EERKT_; - _ZNSt3__16__treeINS_12__value_typeINS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEEN7android6binder8internal25ClientCounterCallbackImpl7ServiceEEENS_19__map_value_compareIS7_SD_NS_4lessIS7_EELb1EEENS5_ISD_EEE25__emplace_unique_key_argsIS7_JRKNS_21piecewise_construct_tENS_5tupleIJRKS7_EEENSO_IJEEEEEENS_4pairINS_15__tree_iteratorISD_PNS_11__tree_nodeISD_PvEEiEEbEERKT_DpOT0_; - _ZNSt3__16__treeINS_12__value_typeINS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEEN7android6binder8internal25ClientCounterCallbackImpl7ServiceEEENS_19__map_value_compareIS7_SD_NS_4lessIS7_EELb1EEENS5_ISD_EEE7destroyEPNS_11__tree_nodeISD_PvEE; - _ZNSt3__16vectorIaNS_9allocatorIaEEE6insertIPKaEENS_9enable_ifIXaasr21__is_forward_iteratorIT_EE5valuesr16is_constructibleIaNS_15iterator_traitsIS8_E9referenceEEE5valueENS_11__wrap_iterIPaEEE4typeENSC_IS6_EES8_S8_; - _ZNSt3__16vectorIbNS_9allocatorIbEEE18__construct_at_endINS_14__bit_iteratorIS3_Lb0ELj0EEEEENS_9enable_ifIXsr21__is_forward_iteratorIT_EE5valueEvE4typeES8_S8_; - _ZNSt3__16vectorIbNS_9allocatorIbEEE18__construct_at_endINS_14__bit_iteratorIS3_Lb1ELj0EEEEENS_9enable_ifIXsr21__is_forward_iteratorIT_EE5valueEvE4typeES8_S8_; - _ZNSt3__16vectorIbNS_9allocatorIbEEE7reserveEj; - _ZNSt3__16vectorIbNS_9allocatorIbEEE9push_backERKb; - _ZNSt3__16vectorIbNS_9allocatorIbEEEaSERKS3_; - _ZNSt3__16vectorIdNS_9allocatorIdEEE6assignIPdEENS_9enable_ifIXaasr21__is_forward_iteratorIT_EE5valuesr16is_constructibleIdNS_15iterator_traitsIS7_E9referenceEEE5valueEvE4typeES7_S7_; - _ZNSt3__16vectorIdNS_9allocatorIdEEE6insertIPKdEENS_9enable_ifIXaasr21__is_forward_iteratorIT_EE5valuesr16is_constructibleIdNS_15iterator_traitsIS8_E9referenceEEE5valueENS_11__wrap_iterIPdEEE4typeENSC_IS6_EES8_S8_; - _ZNSt3__16vectorIdNS_9allocatorIdEEEC2ERKS3_; - _ZNSt3__16vectorIDsNS_9allocatorIDsEEE24__emplace_back_slow_pathIJDsEEEvDpOT_; - _ZNSt3__16vectorIDsNS_9allocatorIDsEEE7reserveEj; - _ZNSt3__16vectorIfNS_9allocatorIfEEE6insertIPKfEENS_9enable_ifIXaasr21__is_forward_iteratorIT_EE5valuesr16is_constructibleIfNS_15iterator_traitsIS8_E9referenceEEE5valueENS_11__wrap_iterIPfEEE4typeENSC_IS6_EES8_S8_; - _ZNSt3__16vectorIhNS_9allocatorIhEEE6insertIPKhEENS_9enable_ifIXaasr21__is_forward_iteratorIT_EE5valuesr16is_constructibleIhNS_15iterator_traitsIS8_E9referenceEEE5valueENS_11__wrap_iterIPhEEE4typeENSC_IS6_EES8_S8_; - _ZNSt3__16vectorIiNS_9allocatorIiEEE6assignIPiEENS_9enable_ifIXaasr21__is_forward_iteratorIT_EE5valuesr16is_constructibleIiNS_15iterator_traitsIS7_E9referenceEEE5valueEvE4typeES7_S7_; - _ZNSt3__16vectorIiNS_9allocatorIiEEE6insertIPKiEENS_9enable_ifIXaasr21__is_forward_iteratorIT_EE5valuesr16is_constructibleIiNS_15iterator_traitsIS8_E9referenceEEE5valueENS_11__wrap_iterIPiEEE4typeENSC_IS6_EES8_S8_; - _ZNSt3__16vectorIN7android2os16ServiceDebugInfoENS_9allocatorIS3_EEE8__appendEj; - _ZNSt3__16vectorIN7android2spINS1_10RpcSession13RpcConnectionEEENS_9allocatorIS5_EEE21__push_back_slow_pathIRKS5_EEvOT_; - _ZNSt3__16vectorIN7android2spINS1_10RpcSessionEEENS_9allocatorIS4_EEE21__push_back_slow_pathIRKS4_EEvOT_; - _ZNSt3__16vectorIN7android2spINS1_7IBinderEEENS_9allocatorIS4_EEE21__push_back_slow_pathIRKS4_EEvOT_; - _ZNSt3__16vectorIN7android2spINS1_7IBinderEEENS_9allocatorIS4_EEE8__appendEj; - _ZNSt3__16vectorIN7android4base14unique_fd_implINS2_13DefaultCloserEEENS_9allocatorIS5_EEE8__appendEj; - _ZNSt3__16vectorIN7android8RpcState10BinderNode9AsyncTodoENS_9allocatorIS4_EEE21__push_back_slow_pathIS4_EEvOT_; - _ZNSt3__16vectorIN7android8String16ENS_9allocatorIS2_EEE6assignIPS2_EENS_9enable_ifIXaasr21__is_forward_iteratorIT_EE5valuesr16is_constructibleIS2_NS_15iterator_traitsIS9_E9referenceEEE5valueEvE4typeES9_S9_; - _ZNSt3__16vectorIN7android8String16ENS_9allocatorIS2_EEE8__appendEj; - _ZNSt3__16vectorINS_10unique_ptrIN7android8String16ENS_14default_deleteIS3_EEEENS_9allocatorIS6_EEE8__appendEj; - _ZNSt3__16vectorINS_10unique_ptrINS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEENS_14default_deleteIS7_EEEENS5_ISA_EEE8__appendEj; - _ZNSt3__16vectorINS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEENS4_IS6_EEE8__appendEj; - _ZNSt3__16vectorINS_8optionalIN7android8String16EEENS_9allocatorIS4_EEE8__appendEj; - _ZNSt3__16vectorINS_8optionalINS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEEEENS5_IS8_EEE8__appendEj; - _ZNSt3__16vectorIxNS_9allocatorIxEEE6assignIPxEENS_9enable_ifIXaasr21__is_forward_iteratorIT_EE5valuesr16is_constructibleIxNS_15iterator_traitsIS7_E9referenceEEE5valueEvE4typeES7_S7_; - _ZNSt3__16vectorIxNS_9allocatorIxEEE6insertIPKxEENS_9enable_ifIXaasr21__is_forward_iteratorIT_EE5valuesr16is_constructibleIxNS_15iterator_traitsIS8_E9referenceEEE5valueENS_11__wrap_iterIPxEEE4typeENSC_IS6_EES8_S8_; - _ZNSt3__16vectorIxNS_9allocatorIxEEEC2ERKS3_; - _ZNSt3__16vectorIyNS_9allocatorIyEEE6insertIPKyEENS_9enable_ifIXaasr21__is_forward_iteratorIT_EE5valuesr16is_constructibleIyNS_15iterator_traitsIS8_E9referenceEEE5valueENS_11__wrap_iterIPyEEE4typeENSC_IS6_EES8_S8_; - _ZNSt3__19__sift_upIRNS_4lessIN7android8RpcState10BinderNode9AsyncTodoEEENS_11__wrap_iterIPS5_EEEEvT0_SB_T_NS_15iterator_traitsISB_E15difference_typeE; - _ZTCN7android10AllocationE0_NS_10IInterfaceE; - _ZTCN7android10AllocationE0_NS_10MemoryBaseE; - _ZTCN7android10AllocationE0_NS_11BnInterfaceINS_7IMemoryEEE; - _ZTCN7android10AllocationE0_NS_7IMemoryE; - _ZTCN7android10AllocationE0_NS_8BnMemoryE; - _ZTCN7android10AllocationE4_NS_7BBinderE; - _ZTCN7android10AllocationE4_NS_7IBinderE; - _ZTCN7android10MemoryBaseE0_NS_10IInterfaceE; - _ZTCN7android10MemoryBaseE0_NS_11BnInterfaceINS_7IMemoryEEE; - _ZTCN7android10MemoryBaseE0_NS_7IMemoryE; - _ZTCN7android10MemoryBaseE0_NS_8BnMemoryE; - _ZTCN7android10MemoryBaseE4_NS_7BBinderE; - _ZTCN7android10MemoryBaseE4_NS_7IBinderE; - _ZTCN7android10PoolThreadE0_NS_6ThreadE; - _ZTCN7android11IMemoryHeapE0_NS_10IInterfaceE; - _ZTCN7android12BnMemoryHeapE0_NS_10IInterfaceE; - _ZTCN7android12BnMemoryHeapE0_NS_11BnInterfaceINS_11IMemoryHeapEEE; - _ZTCN7android12BnMemoryHeapE0_NS_11IMemoryHeapE; - _ZTCN7android12BnMemoryHeapE4_NS_7BBinderE; - _ZTCN7android12BnMemoryHeapE4_NS_7IBinderE; - _ZTCN7android12BpMemoryHeapE0_NS_10IInterfaceE; - _ZTCN7android12BpMemoryHeapE0_NS_11BpInterfaceINS_11IMemoryHeapEEE; - _ZTCN7android12BpMemoryHeapE0_NS_11IMemoryHeapE; - _ZTCN7android12BpMemoryHeapE4_NS_9BpRefBaseE; - _ZTCN7android14IShellCallbackE0_NS_10IInterfaceE; - _ZTCN7android14MemoryHeapBaseE32_NS_10IInterfaceE; - _ZTCN7android14MemoryHeapBaseE32_NS_11BnInterfaceINS_11IMemoryHeapEEE; - _ZTCN7android14MemoryHeapBaseE32_NS_11IMemoryHeapE; - _ZTCN7android14MemoryHeapBaseE32_NS_12BnMemoryHeapE; - _ZTCN7android14MemoryHeapBaseE36_NS_7BBinderE; - _ZTCN7android14MemoryHeapBaseE36_NS_7IBinderE; - _ZTCN7android15BnShellCallbackE0_NS_10IInterfaceE; - _ZTCN7android15BnShellCallbackE0_NS_11BnInterfaceINS_14IShellCallbackEEE; - _ZTCN7android15BnShellCallbackE0_NS_14IShellCallbackE; - _ZTCN7android15BnShellCallbackE4_NS_7BBinderE; - _ZTCN7android15BnShellCallbackE4_NS_7IBinderE; - _ZTCN7android15BpShellCallbackE0_NS_10IInterfaceE; - _ZTCN7android15BpShellCallbackE0_NS_11BpInterfaceINS_14IShellCallbackEEE; - _ZTCN7android15BpShellCallbackE0_NS_14IShellCallbackE; - _ZTCN7android15BpShellCallbackE4_NS_9BpRefBaseE; - _ZTCN7android15IResultReceiverE0_NS_10IInterfaceE; - _ZTCN7android15IServiceManagerE0_NS_10IInterfaceE; - _ZTCN7android16BnResultReceiverE0_NS_10IInterfaceE; - _ZTCN7android16BnResultReceiverE0_NS_11BnInterfaceINS_15IResultReceiverEEE; - _ZTCN7android16BnResultReceiverE0_NS_15IResultReceiverE; - _ZTCN7android16BnResultReceiverE4_NS_7BBinderE; - _ZTCN7android16BnResultReceiverE4_NS_7IBinderE; - _ZTCN7android16BpResultReceiverE0_NS_10IInterfaceE; - _ZTCN7android16BpResultReceiverE0_NS_11BpInterfaceINS_15IResultReceiverEEE; - _ZTCN7android16BpResultReceiverE0_NS_15IResultReceiverE; - _ZTCN7android16BpResultReceiverE4_NS_9BpRefBaseE; - _ZTCN7android18ServiceManagerShimE0_NS_10IInterfaceE; - _ZTCN7android18ServiceManagerShimE0_NS_15IServiceManagerE; - _ZTCN7android21IPermissionControllerE0_NS_10IInterfaceE; - _ZTCN7android22BnPermissionControllerE0_NS_10IInterfaceE; - _ZTCN7android22BnPermissionControllerE0_NS_11BnInterfaceINS_21IPermissionControllerEEE; - _ZTCN7android22BnPermissionControllerE0_NS_21IPermissionControllerE; - _ZTCN7android22BnPermissionControllerE4_NS_7BBinderE; - _ZTCN7android22BnPermissionControllerE4_NS_7IBinderE; - _ZTCN7android22BpPermissionControllerE0_NS_10IInterfaceE; - _ZTCN7android22BpPermissionControllerE0_NS_11BpInterfaceINS_21IPermissionControllerEEE; - _ZTCN7android22BpPermissionControllerE0_NS_21IPermissionControllerE; - _ZTCN7android22BpPermissionControllerE4_NS_9BpRefBaseE; - _ZTCN7android2os15IClientCallbackE0_NS_10IInterfaceE; - _ZTCN7android2os15IServiceManagerE0_NS_10IInterfaceE; - _ZTCN7android2os16BnClientCallbackE0_NS0_15IClientCallbackE; - _ZTCN7android2os16BnClientCallbackE0_NS_10IInterfaceE; - _ZTCN7android2os16BnClientCallbackE0_NS_11BnInterfaceINS0_15IClientCallbackEEE; - _ZTCN7android2os16BnClientCallbackE4_NS_7BBinderE; - _ZTCN7android2os16BnClientCallbackE4_NS_7IBinderE; - _ZTCN7android2os16BnServiceManagerE0_NS0_15IServiceManagerE; - _ZTCN7android2os16BnServiceManagerE0_NS_10IInterfaceE; - _ZTCN7android2os16BnServiceManagerE0_NS_11BnInterfaceINS0_15IServiceManagerEEE; - _ZTCN7android2os16BnServiceManagerE4_NS_7BBinderE; - _ZTCN7android2os16BnServiceManagerE4_NS_7IBinderE; - _ZTCN7android2os16BpClientCallbackE0_NS0_15IClientCallbackE; - _ZTCN7android2os16BpClientCallbackE0_NS_10IInterfaceE; - _ZTCN7android2os16BpClientCallbackE0_NS_11BpInterfaceINS0_15IClientCallbackEEE; - _ZTCN7android2os16BpClientCallbackE4_NS_9BpRefBaseE; - _ZTCN7android2os16BpServiceManagerE0_NS0_15IServiceManagerE; - _ZTCN7android2os16BpServiceManagerE0_NS_10IInterfaceE; - _ZTCN7android2os16BpServiceManagerE0_NS_11BpInterfaceINS0_15IServiceManagerEEE; - _ZTCN7android2os16BpServiceManagerE4_NS_9BpRefBaseE; - _ZTCN7android2os16IServiceCallbackE0_NS_10IInterfaceE; - _ZTCN7android2os17BnServiceCallbackE0_NS0_16IServiceCallbackE; - _ZTCN7android2os17BnServiceCallbackE0_NS_10IInterfaceE; - _ZTCN7android2os17BnServiceCallbackE0_NS_11BnInterfaceINS0_16IServiceCallbackEEE; - _ZTCN7android2os17BnServiceCallbackE4_NS_7BBinderE; - _ZTCN7android2os17BnServiceCallbackE4_NS_7IBinderE; - _ZTCN7android2os17BpServiceCallbackE0_NS0_16IServiceCallbackE; - _ZTCN7android2os17BpServiceCallbackE0_NS_10IInterfaceE; - _ZTCN7android2os17BpServiceCallbackE0_NS_11BpInterfaceINS0_16IServiceCallbackEEE; - _ZTCN7android2os17BpServiceCallbackE4_NS_9BpRefBaseE; - _ZTCN7android6binder8internal25ClientCounterCallbackImplE0_NS_10IInterfaceE; - _ZTCN7android6binder8internal25ClientCounterCallbackImplE0_NS_11BnInterfaceINS_2os15IClientCallbackEEE; - _ZTCN7android6binder8internal25ClientCounterCallbackImplE0_NS_2os15IClientCallbackE; - _ZTCN7android6binder8internal25ClientCounterCallbackImplE0_NS_2os16BnClientCallbackE; - _ZTCN7android6binder8internal25ClientCounterCallbackImplE4_NS_7BBinderE; - _ZTCN7android6binder8internal25ClientCounterCallbackImplE4_NS_7IBinderE; - _ZTCN7android7BBinderE0_NS_7IBinderE; - _ZTCN7android7content2pm21IPackageManagerNativeE0_NS_10IInterfaceE; - _ZTCN7android7content2pm22BnPackageManagerNativeE0_NS_10IInterfaceE; - _ZTCN7android7content2pm22BnPackageManagerNativeE0_NS_11BnInterfaceINS1_21IPackageManagerNativeEEE; - _ZTCN7android7content2pm22BnPackageManagerNativeE0_NS1_21IPackageManagerNativeE; - _ZTCN7android7content2pm22BnPackageManagerNativeE4_NS_7BBinderE; - _ZTCN7android7content2pm22BnPackageManagerNativeE4_NS_7IBinderE; - _ZTCN7android7content2pm22BpPackageManagerNativeE0_NS_10IInterfaceE; - _ZTCN7android7content2pm22BpPackageManagerNativeE0_NS_11BpInterfaceINS1_21IPackageManagerNativeEEE; - _ZTCN7android7content2pm22BpPackageManagerNativeE0_NS1_21IPackageManagerNativeE; - _ZTCN7android7content2pm22BpPackageManagerNativeE4_NS_9BpRefBaseE; - _ZTCN7android7content2pm22IPackageChangeObserverE0_NS_10IInterfaceE; - _ZTCN7android7content2pm23BnPackageChangeObserverE0_NS_10IInterfaceE; - _ZTCN7android7content2pm23BnPackageChangeObserverE0_NS_11BnInterfaceINS1_22IPackageChangeObserverEEE; - _ZTCN7android7content2pm23BnPackageChangeObserverE0_NS1_22IPackageChangeObserverE; - _ZTCN7android7content2pm23BnPackageChangeObserverE4_NS_7BBinderE; - _ZTCN7android7content2pm23BnPackageChangeObserverE4_NS_7IBinderE; - _ZTCN7android7content2pm23BpPackageChangeObserverE0_NS_10IInterfaceE; - _ZTCN7android7content2pm23BpPackageChangeObserverE0_NS_11BpInterfaceINS1_22IPackageChangeObserverEEE; - _ZTCN7android7content2pm23BpPackageChangeObserverE0_NS1_22IPackageChangeObserverE; - _ZTCN7android7content2pm23BpPackageChangeObserverE4_NS_9BpRefBaseE; - _ZTCN7android7IMemoryE0_NS_10IInterfaceE; - _ZTCN7android8BnMemoryE0_NS_10IInterfaceE; - _ZTCN7android8BnMemoryE0_NS_11BnInterfaceINS_7IMemoryEEE; - _ZTCN7android8BnMemoryE0_NS_7IMemoryE; - _ZTCN7android8BnMemoryE4_NS_7BBinderE; - _ZTCN7android8BnMemoryE4_NS_7IBinderE; - _ZTCN7android8BpBinderE0_NS_7IBinderE; - _ZTCN7android8BpMemoryE0_NS_10IInterfaceE; - _ZTCN7android8BpMemoryE0_NS_11BpInterfaceINS_7IMemoryEEE; - _ZTCN7android8BpMemoryE0_NS_7IMemoryE; - _ZTCN7android8BpMemoryE4_NS_9BpRefBaseE; - _ZTCN7android9HeapCacheE0_NS_7IBinder14DeathRecipientE; - _ZTCNSt3__118basic_stringstreamIcNS_11char_traitsIcEENS_9allocatorIcEEEE0_NS_13basic_istreamIcS2_EE; - _ZTCNSt3__118basic_stringstreamIcNS_11char_traitsIcEENS_9allocatorIcEEEE0_NS_14basic_iostreamIcS2_EE; - _ZTCNSt3__118basic_stringstreamIcNS_11char_traitsIcEENS_9allocatorIcEEEE8_NS_13basic_ostreamIcS2_EE; - _ZThn4_N7android10AllocationD0Ev; - _ZThn4_N7android10AllocationD1Ev; - _ZThn4_N7android10MemoryBaseD0Ev; - _ZThn4_N7android10MemoryBaseD1Ev; - _ZThn4_N7android12BnMemoryHeap10onTransactEjRKNS_6ParcelEPS1_j; - _ZThn4_N7android12BnMemoryHeapD0Ev; - _ZThn4_N7android12BnMemoryHeapD1Ev; - _ZThn4_N7android12BpMemoryHeapD0Ev; - _ZThn4_N7android12BpMemoryHeapD1Ev; - _ZThn4_N7android15BnShellCallback10onTransactEjRKNS_6ParcelEPS1_j; - _ZThn4_N7android16BnResultReceiver10onTransactEjRKNS_6ParcelEPS1_j; - _ZThn4_N7android22BnPermissionController10onTransactEjRKNS_6ParcelEPS1_j; - _ZThn4_N7android2os16BnClientCallback10onTransactEjRKNS_6ParcelEPS2_j; - _ZThn4_N7android2os16BnServiceManager10onTransactEjRKNS_6ParcelEPS2_j; - _ZThn4_N7android2os17BnServiceCallback10onTransactEjRKNS_6ParcelEPS2_j; - _ZThn4_N7android7content2pm22BnPackageManagerNative10onTransactEjRKNS_6ParcelEPS3_j; - _ZThn4_N7android7content2pm23BnPackageChangeObserver10onTransactEjRKNS_6ParcelEPS3_j; - _ZThn4_N7android8BnMemory10onTransactEjRKNS_6ParcelEPS1_j; - _ZThn4_N7android8BnMemoryD0Ev; - _ZThn4_N7android8BnMemoryD1Ev; - _ZThn4_N7android8BpMemoryD0Ev; - _ZThn4_N7android8BpMemoryD1Ev; - _ZTTN7android10AllocationE; - _ZTTN7android10IInterfaceE; - _ZTTN7android10MemoryBaseE; - _ZTTN7android10PoolThreadE; - _ZTTN7android10RpcSessionE; - _ZTTN7android11IMemoryHeapE; - _ZTTN7android12BnMemoryHeapE; - _ZTTN7android12BpMemoryHeapE; - _ZTTN7android12ProcessStateE; - _ZTTN7android14IShellCallbackE; - _ZTTN7android14MemoryHeapBaseE; - _ZTTN7android15BnShellCallbackE; - _ZTTN7android15BpShellCallbackE; - _ZTTN7android15IResultReceiverE; - _ZTTN7android15IServiceManagerE; - _ZTTN7android16BnResultReceiverE; - _ZTTN7android16BpResultReceiverE; - _ZTTN7android18ServiceManagerShimE; - _ZTTN7android21IPermissionControllerE; - _ZTTN7android22BnPermissionControllerE; - _ZTTN7android22BpPermissionControllerE; - _ZTTN7android2os15IClientCallbackE; - _ZTTN7android2os15IServiceManagerE; - _ZTTN7android2os16BnClientCallbackE; - _ZTTN7android2os16BnServiceManagerE; - _ZTTN7android2os16BpClientCallbackE; - _ZTTN7android2os16BpServiceManagerE; - _ZTTN7android2os16IServiceCallbackE; - _ZTTN7android2os17BnServiceCallbackE; - _ZTTN7android2os17BpServiceCallbackE; - _ZTTN7android6binder8internal25ClientCounterCallbackImplE; - _ZTTN7android7BBinderE; - _ZTTN7android7content2pm21IPackageManagerNativeE; - _ZTTN7android7content2pm22BnPackageManagerNativeE; - _ZTTN7android7content2pm22BpPackageManagerNativeE; - _ZTTN7android7content2pm22IPackageChangeObserverE; - _ZTTN7android7content2pm23BnPackageChangeObserverE; - _ZTTN7android7content2pm23BpPackageChangeObserverE; - _ZTTN7android7IBinderE; - _ZTTN7android7IMemoryE; - _ZTTN7android8BnMemoryE; - _ZTTN7android8BpBinderE; - _ZTTN7android8BpMemoryE; - _ZTTN7android9BpRefBaseE; - _ZTTN7android9HeapCacheE; - _ZTTN7android9RpcServerE; - _ZTTNSt3__118basic_stringstreamIcNS_11char_traitsIcEENS_9allocatorIcEEEE; - _ZTv0_n12_N7android10AllocationD0Ev; - _ZTv0_n12_N7android10AllocationD1Ev; - _ZTv0_n12_N7android10IInterfaceD0Ev; - _ZTv0_n12_N7android10IInterfaceD1Ev; - _ZTv0_n12_N7android10MemoryBaseD0Ev; - _ZTv0_n12_N7android10MemoryBaseD1Ev; - _ZTv0_n12_N7android10RpcSessionD0Ev; - _ZTv0_n12_N7android10RpcSessionD1Ev; - _ZTv0_n12_N7android11IMemoryHeapD0Ev; - _ZTv0_n12_N7android11IMemoryHeapD1Ev; - _ZTv0_n12_N7android12BnMemoryHeapD0Ev; - _ZTv0_n12_N7android12BnMemoryHeapD1Ev; - _ZTv0_n12_N7android12BpMemoryHeapD0Ev; - _ZTv0_n12_N7android12BpMemoryHeapD1Ev; - _ZTv0_n12_N7android12ProcessStateD0Ev; - _ZTv0_n12_N7android12ProcessStateD1Ev; - _ZTv0_n12_N7android14IShellCallbackD0Ev; - _ZTv0_n12_N7android14IShellCallbackD1Ev; - _ZTv0_n12_N7android14MemoryHeapBaseD0Ev; - _ZTv0_n12_N7android14MemoryHeapBaseD1Ev; - _ZTv0_n12_N7android15IResultReceiverD0Ev; - _ZTv0_n12_N7android15IResultReceiverD1Ev; - _ZTv0_n12_N7android15IServiceManagerD0Ev; - _ZTv0_n12_N7android15IServiceManagerD1Ev; - _ZTv0_n12_N7android21IPermissionControllerD0Ev; - _ZTv0_n12_N7android21IPermissionControllerD1Ev; - _ZTv0_n12_N7android2os15IClientCallbackD0Ev; - _ZTv0_n12_N7android2os15IClientCallbackD1Ev; - _ZTv0_n12_N7android2os15IServiceManagerD0Ev; - _ZTv0_n12_N7android2os15IServiceManagerD1Ev; - _ZTv0_n12_N7android2os16IServiceCallbackD0Ev; - _ZTv0_n12_N7android2os16IServiceCallbackD1Ev; - _ZTv0_n12_N7android7BBinderD0Ev; - _ZTv0_n12_N7android7BBinderD1Ev; - _ZTv0_n12_N7android7content2pm21IPackageManagerNativeD0Ev; - _ZTv0_n12_N7android7content2pm21IPackageManagerNativeD1Ev; - _ZTv0_n12_N7android7content2pm22IPackageChangeObserverD0Ev; - _ZTv0_n12_N7android7content2pm22IPackageChangeObserverD1Ev; - _ZTv0_n12_N7android7IBinderD0Ev; - _ZTv0_n12_N7android7IBinderD1Ev; - _ZTv0_n12_N7android7IMemoryD0Ev; - _ZTv0_n12_N7android7IMemoryD1Ev; - _ZTv0_n12_N7android8BnMemoryD0Ev; - _ZTv0_n12_N7android8BnMemoryD1Ev; - _ZTv0_n12_N7android8BpBinderD0Ev; - _ZTv0_n12_N7android8BpBinderD1Ev; - _ZTv0_n12_N7android8BpMemoryD0Ev; - _ZTv0_n12_N7android8BpMemoryD1Ev; - _ZTv0_n12_N7android9BpRefBaseD0Ev; - _ZTv0_n12_N7android9BpRefBaseD1Ev; - _ZTv0_n12_N7android9HeapCacheD0Ev; - _ZTv0_n12_N7android9HeapCacheD1Ev; - _ZTv0_n12_N7android9RpcServerD0Ev; - _ZTv0_n12_N7android9RpcServerD1Ev; - _ZTv0_n16_N7android14MemoryHeapBaseD0Ev; - _ZTv0_n16_N7android14MemoryHeapBaseD1Ev; - _ZTv0_n16_N7android8BpBinder10onFirstRefEv; - _ZTv0_n16_N7android9BpRefBase10onFirstRefEv; - _ZTv0_n20_N7android8BpBinder15onLastStrongRefEPKv; - _ZTv0_n20_N7android9BpRefBase15onLastStrongRefEPKv; - _ZTv0_n24_N7android8BpBinder20onIncStrongAttemptedEjPKv; - _ZTv0_n24_N7android9BpRefBase20onIncStrongAttemptedEjPKv; - _ZTv0_n28_NK7android14MemoryHeapBase9getHeapIDEv; - _ZTv0_n32_NK7android14MemoryHeapBase7getBaseEv; - _ZTv0_n36_NK7android14MemoryHeapBase7getSizeEv; - _ZTv0_n40_NK7android14MemoryHeapBase8getFlagsEv; - _ZTv0_n44_NK7android14MemoryHeapBase9getOffsetEv; - _ZTvn4_n16_N7android14MemoryHeapBaseD0Ev; - _ZTvn4_n16_N7android14MemoryHeapBaseD1Ev; - _ZTVN7android10AllocationE; - _ZTVN7android10IInterfaceE; - _ZTVN7android10MemoryBaseE; - _ZTVN7android10PoolThreadE; - _ZTVN7android10RpcSession13RpcConnectionE; - _ZTVN7android10RpcSessionE; - _ZTVN7android10TextOutputE; - _ZTVN7android11IMemoryHeapE; - _ZTVN7android12BnMemoryHeapE; - _ZTVN7android12BpMemoryHeapE; - _ZTVN7android12FdTextOutputE; - _ZTVN7android12MemoryDealerE; - _ZTVN7android12ProcessStateE; - _ZTVN7android12SortedVectorINS_15PermissionCache5EntryEEE; - _ZTVN7android12SortedVectorINS_16key_value_pair_tINS_2wpINS_7IBinderEEENS_9HeapCache11heap_info_tEEEEE; - _ZTVN7android12SortedVectorINS_16key_value_pair_tIPKvNS_8BpBinder13ObjectManager7entry_tEEEEE; - _ZTVN7android12SortedVectorINS_8String16EEE; - _ZTVN7android13LogTextOutputE; - _ZTVN7android14IShellCallbackE; - _ZTVN7android14MemoryHeapBaseE; - _ZTVN7android15BnShellCallbackE; - _ZTVN7android15BpShellCallbackE; - _ZTVN7android15IResultReceiverE; - _ZTVN7android15IServiceManagerE; - _ZTVN7android16BnResultReceiverE; - _ZTVN7android16BpResultReceiverE; - _ZTVN7android17InetSocketAddressE; - _ZTVN7android17UnixSocketAddressE; - _ZTVN7android18BufferedTextOutput11BufferStateE; - _ZTVN7android18BufferedTextOutputE; - _ZTVN7android18ServiceManagerShimE; - _ZTVN7android18VsockSocketAddressE; - _ZTVN7android21IPermissionControllerE; - _ZTVN7android22BnPermissionControllerE; - _ZTVN7android22BpPermissionControllerE; - _ZTVN7android2os15IClientCallbackE; - _ZTVN7android2os15IServiceManagerE; - _ZTVN7android2os16BnClientCallbackE; - _ZTVN7android2os16BnServiceManagerE; - _ZTVN7android2os16BpClientCallbackE; - _ZTVN7android2os16BpServiceManagerE; - _ZTVN7android2os16IServiceCallbackE; - _ZTVN7android2os16ParcelableHolderE; - _ZTVN7android2os16ServiceDebugInfoE; - _ZTVN7android2os17BnServiceCallbackE; - _ZTVN7android2os17BpServiceCallbackE; - _ZTVN7android2os17PersistableBundleE; - _ZTVN7android2os20ParcelFileDescriptorE; - _ZTVN7android6binder8internal25ClientCounterCallbackImplE; - _ZTVN7android6VectorIiEE; - _ZTVN7android6VectorINS_12ProcessState12handle_entryEEE; - _ZTVN7android6VectorINS_2spINS_18BufferedTextOutput11BufferStateEEEEE; - _ZTVN7android6VectorINS_8BpBinder8ObituaryEEE; - _ZTVN7android6VectorINS_8String16EEE; - _ZTVN7android6VectorIPNS_7BBinderEEE; - _ZTVN7android6VectorIPNS_7RefBase12weakref_typeEEE; - _ZTVN7android6VectorIPNS_7RefBaseEEE; - _ZTVN7android7BBinderE; - _ZTVN7android7content2pm18PackageChangeEventE; - _ZTVN7android7content2pm21IPackageManagerNativeE; - _ZTVN7android7content2pm22BnPackageManagerNativeE; - _ZTVN7android7content2pm22BpPackageManagerNativeE; - _ZTVN7android7content2pm22IPackageChangeObserverE; - _ZTVN7android7content2pm23BnPackageChangeObserverE; - _ZTVN7android7content2pm23BpPackageChangeObserverE; - _ZTVN7android7IBinderE; - _ZTVN7android7IMemoryE; - _ZTVN7android8BnMemoryE; - _ZTVN7android8BpBinderE; - _ZTVN7android8BpMemoryE; - _ZTVN7android9BpRefBaseE; - _ZTVN7android9HeapCacheE; - _ZTVN7android9RpcServerE; - _ZTVNSt3__115basic_stringbufIcNS_11char_traitsIcEENS_9allocatorIcEEEE; - _ZTVNSt3__118basic_stringstreamIcNS_11char_traitsIcEENS_9allocatorIcEEEE; - _ZTVNSt3__120__shared_ptr_emplaceIN7android14RpcWireAddressENS_9allocatorIS2_EEEE; - _ZTVNSt3__120__shared_ptr_emplaceIN7android6binder8internal21ClientCounterCallbackENS_9allocatorIS4_EEEE; - local: - *; -}; diff --git a/libs/binder/libbinder.arm32.vendor.map b/libs/binder/libbinder.arm32.vendor.map deleted file mode 100644 index 8d5a323806..0000000000 --- a/libs/binder/libbinder.arm32.vendor.map +++ /dev/null @@ -1,1540 +0,0 @@ -# b/190148312: Populate with correct list of ABI symbols -LIBBINDER { - global: - getBinderKernelReferences; - kDefaultDriver; - _ZN7android10AllocationC1ERKNS_2spINS_12MemoryDealerEEERKNS1_INS_11IMemoryHeapEEEij; - _ZN7android10AllocationC2ERKNS_2spINS_12MemoryDealerEEERKNS1_INS_11IMemoryHeapEEEij; - _ZN7android10AllocationD0Ev; - _ZN7android10AllocationD1Ev; - _ZN7android10AllocationD2Ev; - _ZN7android10IInterface8asBinderEPKS0_; - _ZN7android10IInterface8asBinderERKNS_2spIS0_EE; - _ZN7android10IInterfaceC2Ev; - _ZN7android10IInterfaceD0Ev; - _ZN7android10IInterfaceD1Ev; - _ZN7android10IInterfaceD2Ev; - _ZN7android10MemoryBaseC1ERKNS_2spINS_11IMemoryHeapEEEij; - _ZN7android10MemoryBaseC2ERKNS_2spINS_11IMemoryHeapEEEij; - _ZN7android10MemoryBaseD0Ev; - _ZN7android10MemoryBaseD1Ev; - _ZN7android10MemoryBaseD2Ev; - _ZN7android10RpcAddress14readFromParcelERKNS_6ParcelE; - _ZN7android10RpcAddress15fromRawEmbeddedEPKNS_14RpcWireAddressE; - _ZN7android10RpcAddress4zeroEv; - _ZN7android10RpcAddress6uniqueEv; - _ZN7android10RpcAddressC1Ev; - _ZN7android10RpcAddressC2Ev; - _ZN7android10RpcAddressD1Ev; - _ZN7android10RpcAddressD2Ev; - _ZN7android10RpcSession12setForServerERKNS_2wpINS_9RpcServerEEEi; - _ZN7android10RpcSession13getRootObjectEv; - _ZN7android10RpcSession13sendDecStrongERKNS_10RpcAddressE; - _ZN7android10RpcSession15setupInetClientEPKcj; - _ZN7android10RpcSession15terminateLockedEv; - _ZN7android10RpcSession16setupVsockClientEjj; - _ZN7android10RpcSession17setupSocketClientERKNS_16RpcSocketAddressE; - _ZN7android10RpcSession19addClientConnectionENS_4base14unique_fd_implINS1_13DefaultCloserEEE; - _ZN7android10RpcSession19ExclusiveConnection14findConnectionEiPNS_2spINS0_13RpcConnectionEEES5_RNSt3__16vectorIS4_NS6_9allocatorIS4_EEEEj; - _ZN7android10RpcSession19ExclusiveConnectionC1ERKNS_2spIS0_EENS0_13ConnectionUseE; - _ZN7android10RpcSession19ExclusiveConnectionC2ERKNS_2spIS0_EENS0_13ConnectionUseE; - _ZN7android10RpcSession19ExclusiveConnectionD1Ev; - _ZN7android10RpcSession19ExclusiveConnectionD2Ev; - _ZN7android10RpcSession19getRemoteMaxThreadsEPj; - _ZN7android10RpcSession20setupOneSocketClientERKNS_16RpcSocketAddressEi; - _ZN7android10RpcSession21setupUnixDomainClientEPKc; - _ZN7android10RpcSession22addNullDebuggingClientEv; - _ZN7android10RpcSession22removeServerConnectionERKNS_2spINS0_13RpcConnectionEEE; - _ZN7android10RpcSession24assignServerToThisThreadENS_4base14unique_fd_implINS1_13DefaultCloserEEE; - _ZN7android10RpcSession4joinENS_4base14unique_fd_implINS1_13DefaultCloserEEE; - _ZN7android10RpcSession4makeEv; - _ZN7android10RpcSession6readIdEv; - _ZN7android10RpcSession6serverEv; - _ZN7android10RpcSession7preJoinENSt3__16threadE; - _ZN7android10RpcSession8transactERKNS_10RpcAddressEjRKNS_6ParcelEPS4_j; - _ZN7android10RpcSessionC1Ev; - _ZN7android10RpcSessionC2Ev; - _ZN7android10RpcSessionD0Ev; - _ZN7android10RpcSessionD1Ev; - _ZN7android10RpcSessionD2Ev; - _ZN7android10TextOutputC2Ev; - _ZN7android10TextOutputD0Ev; - _ZN7android10TextOutputD1Ev; - _ZN7android10TextOutputD2Ev; - _ZN7android10zeroMemoryEPhj; - _ZN7android11BnInterfaceINS_11IMemoryHeapEE10onAsBinderEv; - _ZN7android11BnInterfaceINS_14IShellCallbackEE10onAsBinderEv; - _ZN7android11BnInterfaceINS_15IResultReceiverEE10onAsBinderEv; - _ZN7android11BnInterfaceINS_2os15IClientCallbackEE10onAsBinderEv; - _ZN7android11BnInterfaceINS_2os15IServiceManagerEE10onAsBinderEv; - _ZN7android11BnInterfaceINS_2os16IServiceCallbackEE10onAsBinderEv; - _ZN7android11BnInterfaceINS_7content2pm21IPackageManagerNativeEE10onAsBinderEv; - _ZN7android11BnInterfaceINS_7content2pm22IPackageChangeObserverEE10onAsBinderEv; - _ZN7android11BnInterfaceINS_7IMemoryEE10onAsBinderEv; - _ZN7android11IMemoryHeap10descriptorE; - _ZN7android11IMemoryHeap11asInterfaceERKNS_2spINS_7IBinderEEE; - _ZN7android11IMemoryHeap12default_implE; - _ZN7android11IMemoryHeap14getDefaultImplEv; - _ZN7android11IMemoryHeap14setDefaultImplENSt3__110unique_ptrIS0_NS1_14default_deleteIS0_EEEE; - _ZN7android11IMemoryHeapC2Ev; - _ZN7android11IMemoryHeapD0Ev; - _ZN7android11IMemoryHeapD1Ev; - _ZN7android11IMemoryHeapD2Ev; - _ZN7android12BnMemoryHeap10onTransactEjRKNS_6ParcelEPS1_j; - _ZN7android12BnMemoryHeapC2Ev; - _ZN7android12BnMemoryHeapD0Ev; - _ZN7android12BnMemoryHeapD1Ev; - _ZN7android12BnMemoryHeapD2Ev; - _ZN7android12BpMemoryHeapC1ERKNS_2spINS_7IBinderEEE; - _ZN7android12BpMemoryHeapC2ERKNS_2spINS_7IBinderEEE; - _ZN7android12BpMemoryHeapD0Ev; - _ZN7android12BpMemoryHeapD1Ev; - _ZN7android12BpMemoryHeapD2Ev; - _ZN7android12gTextBuffersE; - _ZN7android12MemoryDealer10deallocateEj; - _ZN7android12MemoryDealer22getAllocationAlignmentEv; - _ZN7android12MemoryDealer8allocateEj; - _ZN7android12MemoryDealerC1EjPKcj; - _ZN7android12MemoryDealerC2EjPKcj; - _ZN7android12MemoryDealerD0Ev; - _ZN7android12MemoryDealerD1Ev; - _ZN7android12MemoryDealerD2Ev; - _ZN7android12printHexDataEiPKvjjijbPFvPvPKcES2_; - _ZN7android12ProcessState10selfOrNullEv; - _ZN7android12ProcessState13expungeHandleEiPNS_7IBinderE; - _ZN7android12ProcessState13getDriverNameEv; - _ZN7android12ProcessState14initWithDriverEPKc; - _ZN7android12ProcessState15startThreadPoolEv; - _ZN7android12ProcessState16getContextObjectERKNS_2spINS_7IBinderEEE; - _ZN7android12ProcessState17spawnPooledThreadEb; - _ZN7android12ProcessState18giveThreadPoolNameEv; - _ZN7android12ProcessState18lookupHandleLockedEi; - _ZN7android12ProcessState18setCallRestrictionENS0_15CallRestrictionE; - _ZN7android12ProcessState19getKernelReferencesEjPj; - _ZN7android12ProcessState20becomeContextManagerEv; - _ZN7android12ProcessState20makeBinderThreadNameEv; - _ZN7android12ProcessState23getStrongProxyForHandleEi; - _ZN7android12ProcessState24getStrongRefCountForNodeERKNS_2spINS_8BpBinderEEE; - _ZN7android12ProcessState25enableOnewaySpamDetectionEb; - _ZN7android12ProcessState27setThreadPoolMaxThreadCountEj; - _ZN7android12ProcessState4initEPKcb; - _ZN7android12ProcessState4selfEv; - _ZN7android12ProcessStateC1EPKc; - _ZN7android12ProcessStateC2EPKc; - _ZN7android12ProcessStateD0Ev; - _ZN7android12ProcessStateD1Ev; - _ZN7android12ProcessStateD2Ev; - _ZN7android13printTypeCodeEjPFvPvPKcES0_; - _ZN7android14IPCThreadState10freeBufferEPNS_6ParcelEPKhjPKyj; - _ZN7android14IPCThreadState10selfOrNullEv; - _ZN7android14IPCThreadState11clearCallerEv; - _ZN7android14IPCThreadState11stopProcessEb; - _ZN7android14IPCThreadState12setupPollingEPi; - _ZN7android14IPCThreadState13decWeakHandleEi; - _ZN7android14IPCThreadState13expungeHandleEiPNS_7IBinderE; - _ZN7android14IPCThreadState13flushCommandsEv; - _ZN7android14IPCThreadState13flushIfNeededEv; - _ZN7android14IPCThreadState13incWeakHandleEiPNS_8BpBinderE; - _ZN7android14IPCThreadState14clearLastErrorEv; - _ZN7android14IPCThreadState14executeCommandEi; - _ZN7android14IPCThreadState14joinThreadPoolEb; - _ZN7android14IPCThreadState14talkWithDriverEb; - _ZN7android14IPCThreadState15decStrongHandleEi; - _ZN7android14IPCThreadState15incStrongHandleEiPNS_8BpBinderE; - _ZN7android14IPCThreadState15waitForResponseEPNS_6ParcelEPi; - _ZN7android14IPCThreadState16threadDestructorEPv; - _ZN7android14IPCThreadState18setCallRestrictionENS_12ProcessState15CallRestrictionE; - _ZN7android14IPCThreadState19setStrictModePolicyEi; - _ZN7android14IPCThreadState19setTheContextObjectERKNS_2spINS_7BBinderEEE; - _ZN7android14IPCThreadState20clearCallingIdentityEv; - _ZN7android14IPCThreadState20getAndExecuteCommandEv; - _ZN7android14IPCThreadState20getProcessFreezeInfoEiPbS1_; - _ZN7android14IPCThreadState20handlePolledCommandsEv; - _ZN7android14IPCThreadState20processPendingDerefsEv; - _ZN7android14IPCThreadState20writeTransactionDataEijijRKNS_6ParcelEPi; - _ZN7android14IPCThreadState22attemptIncStrongHandleEi; - _ZN7android14IPCThreadState22clearCallingWorkSourceEv; - _ZN7android14IPCThreadState22clearDeathNotificationEiPNS_8BpBinderE; - _ZN7android14IPCThreadState22processPostWriteDerefsEv; - _ZN7android14IPCThreadState22restoreCallingIdentityEx; - _ZN7android14IPCThreadState23setCallingWorkSourceUidEj; - _ZN7android14IPCThreadState24clearPropagateWorkSourceEv; - _ZN7android14IPCThreadState24requestDeathNotificationEiPNS_8BpBinderE; - _ZN7android14IPCThreadState24restoreCallingWorkSourceEx; - _ZN7android14IPCThreadState25blockUntilThreadAvailableEv; - _ZN7android14IPCThreadState27disableBackgroundSchedulingEb; - _ZN7android14IPCThreadState28backgroundSchedulingDisabledEv; - _ZN7android14IPCThreadState29setLastTransactionBinderFlagsEi; - _ZN7android14IPCThreadState41setCallingWorkSourceUidWithoutPropagationEj; - _ZN7android14IPCThreadState4selfEv; - _ZN7android14IPCThreadState6freezeEibj; - _ZN7android14IPCThreadState7processEv; - _ZN7android14IPCThreadState8shutdownEv; - _ZN7android14IPCThreadState8transactEijRKNS_6ParcelEPS1_j; - _ZN7android14IPCThreadState9sendReplyERKNS_6ParcelEj; - _ZN7android14IPCThreadStateC1Ev; - _ZN7android14IPCThreadStateC2Ev; - _ZN7android14IPCThreadStateD1Ev; - _ZN7android14IPCThreadStateD2Ev; - _ZN7android14IShellCallback10descriptorE; - _ZN7android14IShellCallback11asInterfaceERKNS_2spINS_7IBinderEEE; - _ZN7android14IShellCallback12default_implE; - _ZN7android14IShellCallback14getDefaultImplEv; - _ZN7android14IShellCallback14setDefaultImplENSt3__110unique_ptrIS0_NS1_14default_deleteIS0_EEEE; - _ZN7android14IShellCallbackC2Ev; - _ZN7android14IShellCallbackD0Ev; - _ZN7android14IShellCallbackD1Ev; - _ZN7android14IShellCallbackD2Ev; - _ZN7android14MemoryHeapBase4initEiPvjiPKc; - _ZN7android14MemoryHeapBase5mapfdEibjl; - _ZN7android14MemoryHeapBase7disposeEv; - _ZN7android14MemoryHeapBaseC1Eijjl; - _ZN7android14MemoryHeapBaseC1EjjPKc; - _ZN7android14MemoryHeapBaseC1EPKcjj; - _ZN7android14MemoryHeapBaseC1Ev; - _ZN7android14MemoryHeapBaseC2Eijjl; - _ZN7android14MemoryHeapBaseC2EjjPKc; - _ZN7android14MemoryHeapBaseC2EPKcjj; - _ZN7android14MemoryHeapBaseC2Ev; - _ZN7android14MemoryHeapBaseD0Ev; - _ZN7android14MemoryHeapBaseD1Ev; - _ZN7android14MemoryHeapBaseD2Ev; - _ZN7android15BnShellCallback10onTransactEjRKNS_6ParcelEPS1_j; - _ZN7android15IResultReceiver10descriptorE; - _ZN7android15IResultReceiver11asInterfaceERKNS_2spINS_7IBinderEEE; - _ZN7android15IResultReceiver12default_implE; - _ZN7android15IResultReceiver14getDefaultImplEv; - _ZN7android15IResultReceiver14setDefaultImplENSt3__110unique_ptrIS0_NS1_14default_deleteIS0_EEEE; - _ZN7android15IResultReceiverC2Ev; - _ZN7android15IResultReceiverD0Ev; - _ZN7android15IResultReceiverD1Ev; - _ZN7android15IResultReceiverD2Ev; - _ZN7android15IServiceManagerC2Ev; - _ZN7android15IServiceManagerD0Ev; - _ZN7android15IServiceManagerD1Ev; - _ZN7android15IServiceManagerD2Ev; - _ZN7android15stringForIndentEi; - _ZN7android16BnResultReceiver10onTransactEjRKNS_6ParcelEPS1_j; - _ZN7android18BufferedTextOutput10moveIndentEi; - _ZN7android18BufferedTextOutput10pushBundleEv; - _ZN7android18BufferedTextOutput5printEPKcj; - _ZN7android18BufferedTextOutput9popBundleEv; - _ZN7android18BufferedTextOutputC2Ej; - _ZN7android18BufferedTextOutputD0Ev; - _ZN7android18BufferedTextOutputD1Ev; - _ZN7android18BufferedTextOutputD2Ev; - _ZN7android18ServiceManagerShim10addServiceERKNS_8String16ERKNS_2spINS_7IBinderEEEbi; - _ZN7android18ServiceManagerShim10isDeclaredERKNS_8String16E; - _ZN7android18ServiceManagerShim12listServicesEi; - _ZN7android18ServiceManagerShim14waitForServiceERKNS_8String16E; - _ZN7android18ServiceManagerShim16updatableViaApexERKNS_8String16E; - _ZN7android18ServiceManagerShim20getDeclaredInstancesERKNS_8String16E; - _ZN7android18ServiceManagerShimC1ERKNS_2spINS_2os15IServiceManagerEEE; - _ZN7android18ServiceManagerShimC2ERKNS_2spINS_2os15IServiceManagerEEE; - _ZN7android18the_context_objectE; - _ZN7android21defaultServiceManagerEv; - _ZN7android22SimpleBestFitAllocator10deallocateEj; - _ZN7android22SimpleBestFitAllocator12kMemoryAlignE; - _ZN7android22SimpleBestFitAllocator5allocEjj; - _ZN7android22SimpleBestFitAllocator7deallocEj; - _ZN7android22SimpleBestFitAllocator8allocateEjj; - _ZN7android22SimpleBestFitAllocatorC1Ej; - _ZN7android22SimpleBestFitAllocatorC2Ej; - _ZN7android22SimpleBestFitAllocatorD1Ev; - _ZN7android22SimpleBestFitAllocatorD2Ev; - _ZN7android24setDefaultServiceManagerERKNS_2spINS_15IServiceManagerEEE; - _ZN7android2os15IClientCallback10descriptorE; - _ZN7android2os15IClientCallback11asInterfaceERKNS_2spINS_7IBinderEEE; - _ZN7android2os15IClientCallback12default_implE; - _ZN7android2os15IClientCallback14getDefaultImplEv; - _ZN7android2os15IClientCallback14setDefaultImplENSt3__110unique_ptrIS1_NS2_14default_deleteIS1_EEEE; - _ZN7android2os15IClientCallbackC2Ev; - _ZN7android2os15IClientCallbackD0Ev; - _ZN7android2os15IClientCallbackD1Ev; - _ZN7android2os15IClientCallbackD2Ev; - _ZN7android2os15IServiceManager10descriptorE; - _ZN7android2os15IServiceManager11asInterfaceERKNS_2spINS_7IBinderEEE; - _ZN7android2os15IServiceManager12default_implE; - _ZN7android2os15IServiceManager14getDefaultImplEv; - _ZN7android2os15IServiceManager14setDefaultImplENSt3__110unique_ptrIS1_NS2_14default_deleteIS1_EEEE; - _ZN7android2os15IServiceManagerC2Ev; - _ZN7android2os15IServiceManagerD0Ev; - _ZN7android2os15IServiceManagerD1Ev; - _ZN7android2os15IServiceManagerD2Ev; - _ZN7android2os16BnClientCallback10onTransactEjRKNS_6ParcelEPS2_j; - _ZN7android2os16BnClientCallbackC2Ev; - _ZN7android2os16BnServiceManager10onTransactEjRKNS_6ParcelEPS2_j; - _ZN7android2os16BnServiceManagerC2Ev; - _ZN7android2os16BpClientCallback9onClientsERKNS_2spINS_7IBinderEEEb; - _ZN7android2os16BpClientCallbackC1ERKNS_2spINS_7IBinderEEE; - _ZN7android2os16BpClientCallbackC2ERKNS_2spINS_7IBinderEEE; - _ZN7android2os16BpServiceManager10addServiceERKNSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEERKNS_2spINS_7IBinderEEEbi; - _ZN7android2os16BpServiceManager10getServiceERKNSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEPNS_2spINS_7IBinderEEE; - _ZN7android2os16BpServiceManager10isDeclaredERKNSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEPb; - _ZN7android2os16BpServiceManager12checkServiceERKNSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEPNS_2spINS_7IBinderEEE; - _ZN7android2os16BpServiceManager12listServicesEiPNSt3__16vectorINS2_12basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEENS7_IS9_EEEE; - _ZN7android2os16BpServiceManager16updatableViaApexERKNSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEPNS2_8optionalIS8_EE; - _ZN7android2os16BpServiceManager19getServiceDebugInfoEPNSt3__16vectorINS0_16ServiceDebugInfoENS2_9allocatorIS4_EEEE; - _ZN7android2os16BpServiceManager20getDeclaredInstancesERKNSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEPNS2_6vectorIS8_NS6_IS8_EEEE; - _ZN7android2os16BpServiceManager20tryUnregisterServiceERKNSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEERKNS_2spINS_7IBinderEEE; - _ZN7android2os16BpServiceManager22registerClientCallbackERKNSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEERKNS_2spINS_7IBinderEEERKNSB_INS0_15IClientCallbackEEE; - _ZN7android2os16BpServiceManager24registerForNotificationsERKNSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEERKNS_2spINS0_16IServiceCallbackEEE; - _ZN7android2os16BpServiceManager26unregisterForNotificationsERKNSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEERKNS_2spINS0_16IServiceCallbackEEE; - _ZN7android2os16BpServiceManagerC1ERKNS_2spINS_7IBinderEEE; - _ZN7android2os16BpServiceManagerC2ERKNS_2spINS_7IBinderEEE; - _ZN7android2os16IServiceCallback10descriptorE; - _ZN7android2os16IServiceCallback11asInterfaceERKNS_2spINS_7IBinderEEE; - _ZN7android2os16IServiceCallback12default_implE; - _ZN7android2os16IServiceCallback14getDefaultImplEv; - _ZN7android2os16IServiceCallback14setDefaultImplENSt3__110unique_ptrIS1_NS2_14default_deleteIS1_EEEE; - _ZN7android2os16IServiceCallbackC2Ev; - _ZN7android2os16IServiceCallbackD0Ev; - _ZN7android2os16IServiceCallbackD1Ev; - _ZN7android2os16IServiceCallbackD2Ev; - _ZN7android2os16ParcelableHolder14readFromParcelEPKNS_6ParcelE; - _ZN7android2os16ServiceDebugInfo14readFromParcelEPKNS_6ParcelE; - _ZN7android2os17BnServiceCallback10onTransactEjRKNS_6ParcelEPS2_j; - _ZN7android2os17BnServiceCallbackC2Ev; - _ZN7android2os17BpServiceCallback14onRegistrationERKNSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEERKNS_2spINS_7IBinderEEE; - _ZN7android2os17BpServiceCallbackC1ERKNS_2spINS_7IBinderEEE; - _ZN7android2os17BpServiceCallbackC2ERKNS_2spINS_7IBinderEEE; - _ZN7android2os17PersistableBundle10putBooleanERKNS_8String16Eb; - _ZN7android2os17PersistableBundle12putIntVectorERKNS_8String16ERKNSt3__16vectorIiNS5_9allocatorIiEEEE; - _ZN7android2os17PersistableBundle13putLongVectorERKNS_8String16ERKNSt3__16vectorIxNS5_9allocatorIxEEEE; - _ZN7android2os17PersistableBundle14readFromParcelEPKNS_6ParcelE; - _ZN7android2os17PersistableBundle15putDoubleVectorERKNS_8String16ERKNSt3__16vectorIdNS5_9allocatorIdEEEE; - _ZN7android2os17PersistableBundle15putStringVectorERKNS_8String16ERKNSt3__16vectorIS2_NS5_9allocatorIS2_EEEE; - _ZN7android2os17PersistableBundle16putBooleanVectorERKNS_8String16ERKNSt3__16vectorIbNS5_9allocatorIbEEEE; - _ZN7android2os17PersistableBundle19readFromParcelInnerEPKNS_6ParcelEj; - _ZN7android2os17PersistableBundle20putPersistableBundleERKNS_8String16ERKS1_; - _ZN7android2os17PersistableBundle5eraseERKNS_8String16E; - _ZN7android2os17PersistableBundle6putIntERKNS_8String16Ei; - _ZN7android2os17PersistableBundle7putLongERKNS_8String16Ex; - _ZN7android2os17PersistableBundle9putDoubleERKNS_8String16Ed; - _ZN7android2os17PersistableBundle9putStringERKNS_8String16ES4_; - _ZN7android2os20ParcelFileDescriptor14readFromParcelEPKNS_6ParcelE; - _ZN7android2os20ParcelFileDescriptorC1ENS_4base14unique_fd_implINS2_13DefaultCloserEEE; - _ZN7android2os20ParcelFileDescriptorC1Ev; - _ZN7android2os20ParcelFileDescriptorC2ENS_4base14unique_fd_implINS2_13DefaultCloserEEE; - _ZN7android2os20ParcelFileDescriptorC2Ev; - _ZN7android2os20ParcelFileDescriptorD0Ev; - _ZN7android2os20ParcelFileDescriptorD1Ev; - _ZN7android2os20ParcelFileDescriptorD2Ev; - _ZN7android2spINS_7BBinderEED2Ev; - _ZN7android2spINS_7IBinderEEaSEOS2_; - _ZN7android2spINS_7IBinderEEaSERKS2_; - _ZN7android2spINS_9HeapCacheEED2Ev; - _ZN7android4aerrE; - _ZN7android4alogE; - _ZN7android4aoutE; - _ZN7android6binder20LazyServiceRegistrar10reRegisterEv; - _ZN7android6binder20LazyServiceRegistrar11getInstanceEv; - _ZN7android6binder20LazyServiceRegistrar12forcePersistEb; - _ZN7android6binder20LazyServiceRegistrar13tryUnregisterEv; - _ZN7android6binder20LazyServiceRegistrar15registerServiceERKNS_2spINS_7IBinderEEERKNSt3__112basic_stringIcNS7_11char_traitsIcEENS7_9allocatorIcEEEEbi; - _ZN7android6binder20LazyServiceRegistrar25setActiveServicesCallbackERKNSt3__18functionIFbbEEE; - _ZN7android6binder20LazyServiceRegistrarC1Ev; - _ZN7android6binder20LazyServiceRegistrarC2Ev; - _ZN7android6binder6Status11fromStatusTEi; - _ZN7android6binder6Status12setExceptionEiRKNS_7String8E; - _ZN7android6binder6Status14readFromParcelERKNS_6ParcelE; - _ZN7android6binder6Status14setFromStatusTEi; - _ZN7android6binder6Status17exceptionToStringEi; - _ZN7android6binder6Status17fromExceptionCodeEi; - _ZN7android6binder6Status17fromExceptionCodeEiPKc; - _ZN7android6binder6Status17fromExceptionCodeEiRKNS_7String8E; - _ZN7android6binder6Status23setServiceSpecificErrorEiRKNS_7String8E; - _ZN7android6binder6Status24fromServiceSpecificErrorEi; - _ZN7android6binder6Status24fromServiceSpecificErrorEiPKc; - _ZN7android6binder6Status24fromServiceSpecificErrorEiRKNS_7String8E; - _ZN7android6binder6Status2okEv; - _ZN7android6binder6StatusC1Eii; - _ZN7android6binder6StatusC1EiiRKNS_7String8E; - _ZN7android6binder6StatusC2Eii; - _ZN7android6binder6StatusC2EiiRKNS_7String8E; - _ZN7android6binder8internal21ClientCounterCallback10reRegisterEv; - _ZN7android6binder8internal21ClientCounterCallback12forcePersistEb; - _ZN7android6binder8internal21ClientCounterCallback13tryUnregisterEv; - _ZN7android6binder8internal21ClientCounterCallback15registerServiceERKNS_2spINS_7IBinderEEERKNSt3__112basic_stringIcNS8_11char_traitsIcEENS8_9allocatorIcEEEEbi; - _ZN7android6binder8internal21ClientCounterCallback25setActiveServicesCallbackERKNSt3__18functionIFbbEEE; - _ZN7android6binder8internal21ClientCounterCallbackC1Ev; - _ZN7android6binder8internal21ClientCounterCallbackC2Ev; - _ZN7android6binder8internal25ClientCounterCallbackImpl10reRegisterEv; - _ZN7android6binder8internal25ClientCounterCallbackImpl11tryShutdownEv; - _ZN7android6binder8internal25ClientCounterCallbackImpl12forcePersistEb; - _ZN7android6binder8internal25ClientCounterCallbackImpl13tryUnregisterEv; - _ZN7android6binder8internal25ClientCounterCallbackImpl15registerServiceERKNS_2spINS_7IBinderEEERKNSt3__112basic_stringIcNS8_11char_traitsIcEENS8_9allocatorIcEEEEbi; - _ZN7android6binder8internal25ClientCounterCallbackImpl16maybeTryShutdownEv; - _ZN7android6binder8internal25ClientCounterCallbackImpl23assertRegisteredServiceERKNS_2spINS_7IBinderEEE; - _ZN7android6binder8internal25ClientCounterCallbackImpl25setActiveServicesCallbackERKNSt3__18functionIFbbEEE; - _ZN7android6binder8internal25ClientCounterCallbackImpl9onClientsERKNS_2spINS_7IBinderEEEb; - _ZN7android6Parcel10appendFromEPKS0_jj; - _ZN7android6Parcel10markForRpcERKNS_2spINS_10RpcSessionEEE; - _ZN7android6Parcel10writeFloatEf; - _ZN7android6Parcel10writeInt32Ei; - _ZN7android6Parcel10writeInt64Ex; - _ZN7android6Parcel11compareDataERKS0_; - _ZN7android6Parcel11finishWriteEj; - _ZN7android6Parcel11setDataSizeEj; - _ZN7android6Parcel11writeDoubleEd; - _ZN7android6Parcel11writeObjectERK18flat_binder_objectb; - _ZN7android6Parcel11writeUint32Ej; - _ZN7android6Parcel11writeUint64Ey; - _ZN7android6Parcel12pushAllowFdsEb; - _ZN7android6Parcel12restartWriteEj; - _ZN7android6Parcel12writeCStringEPKc; - _ZN7android6Parcel12writeInplaceEj; - _ZN7android6Parcel12writePointerEj; - _ZN7android6Parcel12writeString8EPKcj; - _ZN7android6Parcel12writeString8ERKNS_7String8E; - _ZN7android6Parcel13continueWriteEj; - _ZN7android6Parcel13flattenBinderERKNS_2spINS_7IBinderEEE; - _ZN7android6Parcel13markForBinderERKNS_2spINS_7IBinderEEE; - _ZN7android6Parcel13writeString16EPKDsj; - _ZN7android6Parcel13writeString16ERKNS_8String16E; - _ZN7android6Parcel13writeString16ERKNSt3__110unique_ptrINS_8String16ENS1_14default_deleteIS3_EEEE; - _ZN7android6Parcel13writeString16ERKNSt3__18optionalINS_8String16EEE; - _ZN7android6Parcel13writeUnpaddedEPKvj; - _ZN7android6Parcel14acquireObjectsEv; - _ZN7android6Parcel14freeDataNoInitEv; - _ZN7android6Parcel14releaseObjectsEv; - _ZN7android6Parcel14writeByteArrayEjPKh; - _ZN7android6Parcel15restoreAllowFdsEb; - _ZN7android6Parcel15setDataCapacityEj; - _ZN7android6Parcel15writeBoolVectorERKNSt3__110unique_ptrINS1_6vectorIbNS1_9allocatorIbEEEENS1_14default_deleteIS6_EEEE; - _ZN7android6Parcel15writeBoolVectorERKNSt3__16vectorIbNS1_9allocatorIbEEEE; - _ZN7android6Parcel15writeBoolVectorERKNSt3__18optionalINS1_6vectorIbNS1_9allocatorIbEEEEEE; - _ZN7android6Parcel15writeByteVectorERKNSt3__110unique_ptrINS1_6vectorIaNS1_9allocatorIaEEEENS1_14default_deleteIS6_EEEE; - _ZN7android6Parcel15writeByteVectorERKNSt3__110unique_ptrINS1_6vectorIhNS1_9allocatorIhEEEENS1_14default_deleteIS6_EEEE; - _ZN7android6Parcel15writeByteVectorERKNSt3__16vectorIaNS1_9allocatorIaEEEE; - _ZN7android6Parcel15writeByteVectorERKNSt3__16vectorIhNS1_9allocatorIhEEEE; - _ZN7android6Parcel15writeByteVectorERKNSt3__18optionalINS1_6vectorIaNS1_9allocatorIaEEEEEE; - _ZN7android6Parcel15writeByteVectorERKNSt3__18optionalINS1_6vectorIhNS1_9allocatorIhEEEEEE; - _ZN7android6Parcel15writeCharVectorERKNSt3__110unique_ptrINS1_6vectorIDsNS1_9allocatorIDsEEEENS1_14default_deleteIS6_EEEE; - _ZN7android6Parcel15writeCharVectorERKNSt3__16vectorIDsNS1_9allocatorIDsEEEE; - _ZN7android6Parcel15writeCharVectorERKNSt3__18optionalINS1_6vectorIDsNS1_9allocatorIDsEEEEEE; - _ZN7android6Parcel15writeInt32ArrayEjPKi; - _ZN7android6Parcel15writeParcelableERKNS_10ParcelableE; - _ZN7android6Parcel16writeFloatVectorERKNSt3__110unique_ptrINS1_6vectorIfNS1_9allocatorIfEEEENS1_14default_deleteIS6_EEEE; - _ZN7android6Parcel16writeFloatVectorERKNSt3__16vectorIfNS1_9allocatorIfEEEE; - _ZN7android6Parcel16writeFloatVectorERKNSt3__18optionalINS1_6vectorIfNS1_9allocatorIfEEEEEE; - _ZN7android6Parcel16writeInt32VectorERKNSt3__110unique_ptrINS1_6vectorIiNS1_9allocatorIiEEEENS1_14default_deleteIS6_EEEE; - _ZN7android6Parcel16writeInt32VectorERKNSt3__16vectorIiNS1_9allocatorIiEEEE; - _ZN7android6Parcel16writeInt32VectorERKNSt3__18optionalINS1_6vectorIiNS1_9allocatorIiEEEEEE; - _ZN7android6Parcel16writeInt64VectorERKNSt3__110unique_ptrINS1_6vectorIxNS1_9allocatorIxEEEENS1_14default_deleteIS6_EEEE; - _ZN7android6Parcel16writeInt64VectorERKNSt3__16vectorIxNS1_9allocatorIxEEEE; - _ZN7android6Parcel16writeInt64VectorERKNSt3__18optionalINS1_6vectorIxNS1_9allocatorIxEEEEEE; - _ZN7android6Parcel16writeNoExceptionEv; - _ZN7android6Parcel16writeUtf8AsUtf16ERKNSt3__110unique_ptrINS1_12basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEENS1_14default_deleteIS8_EEEE; - _ZN7android6Parcel16writeUtf8AsUtf16ERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEE; - _ZN7android6Parcel16writeUtf8AsUtf16ERKNSt3__18optionalINS1_12basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEEE; - _ZN7android6Parcel17writeDoubleVectorERKNSt3__110unique_ptrINS1_6vectorIdNS1_9allocatorIdEEEENS1_14default_deleteIS6_EEEE; - _ZN7android6Parcel17writeDoubleVectorERKNSt3__16vectorIdNS1_9allocatorIdEEEE; - _ZN7android6Parcel17writeDoubleVectorERKNSt3__18optionalINS1_6vectorIdNS1_9allocatorIdEEEEEE; - _ZN7android6Parcel17writeNativeHandleEPK13native_handle; - _ZN7android6Parcel17writeStrongBinderERKNS_2spINS_7IBinderEEE; - _ZN7android6Parcel17writeUint64VectorERKNSt3__110unique_ptrINS1_6vectorIyNS1_9allocatorIyEEEENS1_14default_deleteIS6_EEEE; - _ZN7android6Parcel17writeUint64VectorERKNSt3__16vectorIyNS1_9allocatorIyEEEE; - _ZN7android6Parcel17writeUint64VectorERKNSt3__18optionalINS1_6vectorIyNS1_9allocatorIyEEEEEE; - _ZN7android6Parcel18getGlobalAllocSizeEv; - _ZN7android6Parcel19finishFlattenBinderERKNS_2spINS_7IBinderEEE; - _ZN7android6Parcel19getGlobalAllocCountEv; - _ZN7android6Parcel19ipcSetDataReferenceEPKhjPKyjPFvPS0_S2_jS4_jE; - _ZN7android6Parcel19writeFileDescriptorEib; - _ZN7android6Parcel19writeInterfaceTokenEPKDsj; - _ZN7android6Parcel19writeInterfaceTokenERKNS_8String16E; - _ZN7android6Parcel19writeString16VectorERKNSt3__110unique_ptrINS1_6vectorINS2_INS_8String16ENS1_14default_deleteIS4_EEEENS1_9allocatorIS7_EEEENS5_ISA_EEEE; - _ZN7android6Parcel19writeString16VectorERKNSt3__16vectorINS_8String16ENS1_9allocatorIS3_EEEE; - _ZN7android6Parcel19writeString16VectorERKNSt3__18optionalINS1_6vectorINS2_INS_8String16EEENS1_9allocatorIS5_EEEEEE; - _ZN7android6Parcel20closeFileDescriptorsEv; - _ZN7android6Parcel22writeDupFileDescriptorEi; - _ZN7android6Parcel23writeStrongBinderVectorERKNSt3__110unique_ptrINS1_6vectorINS_2spINS_7IBinderEEENS1_9allocatorIS6_EEEENS1_14default_deleteIS9_EEEE; - _ZN7android6Parcel23writeStrongBinderVectorERKNSt3__16vectorINS_2spINS_7IBinderEEENS1_9allocatorIS5_EEEE; - _ZN7android6Parcel23writeStrongBinderVectorERKNSt3__18optionalINS1_6vectorINS_2spINS_7IBinderEEENS1_9allocatorIS6_EEEEEE; - _ZN7android6Parcel25writeParcelFileDescriptorEib; - _ZN7android6Parcel25writeUniqueFileDescriptorERKNS_4base14unique_fd_implINS1_13DefaultCloserEEE; - _ZN7android6Parcel26writeRawNullableParcelableEPKNS_10ParcelableE; - _ZN7android6Parcel27replaceCallingWorkSourceUidEj; - _ZN7android6Parcel28writeDupParcelFileDescriptorEi; - _ZN7android6Parcel28writeUtf8VectorAsUtf16VectorERKNSt3__110unique_ptrINS1_6vectorINS2_INS1_12basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEENS1_14default_deleteIS9_EEEENS7_ISC_EEEENSA_ISE_EEEE; - _ZN7android6Parcel28writeUtf8VectorAsUtf16VectorERKNSt3__16vectorINS1_12basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEENS6_IS8_EEEE; - _ZN7android6Parcel28writeUtf8VectorAsUtf16VectorERKNSt3__18optionalINS1_6vectorINS2_INS1_12basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEEENS7_ISA_EEEEEE; - _ZN7android6Parcel31writeUniqueFileDescriptorVectorERKNSt3__110unique_ptrINS1_6vectorINS_4base14unique_fd_implINS4_13DefaultCloserEEENS1_9allocatorIS7_EEEENS1_14default_deleteISA_EEEE; - _ZN7android6Parcel31writeUniqueFileDescriptorVectorERKNSt3__16vectorINS_4base14unique_fd_implINS3_13DefaultCloserEEENS1_9allocatorIS6_EEEE; - _ZN7android6Parcel31writeUniqueFileDescriptorVectorERKNSt3__18optionalINS1_6vectorINS_4base14unique_fd_implINS4_13DefaultCloserEEENS1_9allocatorIS7_EEEEEE; - _ZN7android6Parcel35writeDupImmutableBlobFileDescriptorEi; - _ZN7android6Parcel4Blob4initEiPvjb; - _ZN7android6Parcel4Blob5clearEv; - _ZN7android6Parcel4Blob7releaseEv; - _ZN7android6Parcel4BlobC1Ev; - _ZN7android6Parcel4BlobC2Ev; - _ZN7android6Parcel4BlobD1Ev; - _ZN7android6Parcel4BlobD2Ev; - _ZN7android6Parcel5writeEPKvj; - _ZN7android6Parcel5writeERKNS0_26FlattenableHelperInterfaceE; - _ZN7android6Parcel7setDataEPKhj; - _ZN7android6Parcel8freeDataEv; - _ZN7android6Parcel8growDataEj; - _ZN7android6Parcel8setErrorEi; - _ZN7android6Parcel9initStateEv; - _ZN7android6Parcel9writeBlobEjbPNS0_12WritableBlobE; - _ZN7android6Parcel9writeBoolEb; - _ZN7android6Parcel9writeByteEa; - _ZN7android6Parcel9writeCharEDs; - _ZN7android6ParcelC1Ev; - _ZN7android6ParcelC2Ev; - _ZN7android6ParcelD1Ev; - _ZN7android6ParcelD2Ev; - _ZN7android7BBinder10onTransactEjRKNS_6ParcelEPS1_j; - _ZN7android7BBinder10pingBinderEv; - _ZN7android7BBinder11getDebugPidEv; - _ZN7android7BBinder11isInheritRtEv; - _ZN7android7BBinder11linkToDeathERKNS_2spINS_7IBinder14DeathRecipientEEEPvj; - _ZN7android7BBinder11localBinderEv; - _ZN7android7BBinder12attachObjectEPKvPvS3_PFvS2_S3_S3_E; - _ZN7android7BBinder12detachObjectEPKv; - _ZN7android7BBinder12getExtensionEv; - _ZN7android7BBinder12setExtensionERKNS_2spINS_7IBinderEEE; - _ZN7android7BBinder12setInheritRtEb; - _ZN7android7BBinder13unlinkToDeathERKNS_2wpINS_7IBinder14DeathRecipientEEEPvjPS4_; - _ZN7android7BBinder15isRequestingSidEv; - _ZN7android7BBinder16setRequestingSidEb; - _ZN7android7BBinder17getOrCreateExtrasEv; - _ZN7android7BBinder21getMinSchedulerPolicyEv; - _ZN7android7BBinder21setMinSchedulerPolicyEii; - _ZN7android7BBinder23getMinSchedulerPriorityEv; - _ZN7android7BBinder4dumpEiRKNS_6VectorINS_8String16EEE; - _ZN7android7BBinder8transactEjRKNS_6ParcelEPS1_j; - _ZN7android7BBinderC1Ev; - _ZN7android7BBinderC2Ev; - _ZN7android7BBinderD0Ev; - _ZN7android7BBinderD1Ev; - _ZN7android7BBinderD2Ev; - _ZN7android7content2pm18PackageChangeEvent14readFromParcelEPKNS_6ParcelE; - _ZN7android7content2pm21IPackageManagerNative10descriptorE; - _ZN7android7content2pm21IPackageManagerNative11asInterfaceERKNS_2spINS_7IBinderEEE; - _ZN7android7content2pm21IPackageManagerNative12default_implE; - _ZN7android7content2pm21IPackageManagerNative14getDefaultImplEv; - _ZN7android7content2pm21IPackageManagerNative14setDefaultImplENSt3__110unique_ptrIS2_NS3_14default_deleteIS2_EEEE; - _ZN7android7content2pm21IPackageManagerNativeC2Ev; - _ZN7android7content2pm21IPackageManagerNativeD0Ev; - _ZN7android7content2pm21IPackageManagerNativeD1Ev; - _ZN7android7content2pm21IPackageManagerNativeD2Ev; - _ZN7android7content2pm22BnPackageManagerNative10onTransactEjRKNS_6ParcelEPS3_j; - _ZN7android7content2pm22BnPackageManagerNativeC2Ev; - _ZN7android7content2pm22BpPackageManagerNative14getAllPackagesEPNSt3__16vectorINS3_12basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEENS8_ISA_EEEE; - _ZN7android7content2pm22BpPackageManagerNative15getNamesForUidsERKNSt3__16vectorIiNS3_9allocatorIiEEEEPNS4_INS3_12basic_stringIcNS3_11char_traitsIcEENS5_IcEEEENS5_ISE_EEEE; - _ZN7android7content2pm22BpPackageManagerNative16getLocationFlagsERKNSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEPi; - _ZN7android7content2pm22BpPackageManagerNative16hasSystemFeatureERKNS_8String16EiPb; - _ZN7android7content2pm22BpPackageManagerNative19isPackageDebuggableERKNS_8String16EPb; - _ZN7android7content2pm22BpPackageManagerNative22getInstallerForPackageERKNS_8String16EPNSt3__112basic_stringIcNS6_11char_traitsIcEENS6_9allocatorIcEEEE; - _ZN7android7content2pm22BpPackageManagerNative24getVersionCodeForPackageERKNS_8String16EPx; - _ZN7android7content2pm22BpPackageManagerNative27hasSha256SigningCertificateERKNSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEERKNS3_6vectorIhNS7_IhEEEEPb; - _ZN7android7content2pm22BpPackageManagerNative28getModuleMetadataPackageNameEPNSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEE; - _ZN7android7content2pm22BpPackageManagerNative29getTargetSdkVersionForPackageERKNS_8String16EPi; - _ZN7android7content2pm22BpPackageManagerNative29isAudioPlaybackCaptureAllowedERKNSt3__16vectorINS3_12basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEENS8_ISA_EEEEPNS4_IbNS8_IbEEEE; - _ZN7android7content2pm22BpPackageManagerNative29registerPackageChangeObserverERKNS_2spINS1_22IPackageChangeObserverEEE; - _ZN7android7content2pm22BpPackageManagerNative31unregisterPackageChangeObserverERKNS_2spINS1_22IPackageChangeObserverEEE; - _ZN7android7content2pm22BpPackageManagerNativeC1ERKNS_2spINS_7IBinderEEE; - _ZN7android7content2pm22BpPackageManagerNativeC2ERKNS_2spINS_7IBinderEEE; - _ZN7android7content2pm22IPackageChangeObserver10descriptorE; - _ZN7android7content2pm22IPackageChangeObserver11asInterfaceERKNS_2spINS_7IBinderEEE; - _ZN7android7content2pm22IPackageChangeObserver12default_implE; - _ZN7android7content2pm22IPackageChangeObserver14getDefaultImplEv; - _ZN7android7content2pm22IPackageChangeObserver14setDefaultImplENSt3__110unique_ptrIS2_NS3_14default_deleteIS2_EEEE; - _ZN7android7content2pm22IPackageChangeObserverC2Ev; - _ZN7android7content2pm22IPackageChangeObserverD0Ev; - _ZN7android7content2pm22IPackageChangeObserverD1Ev; - _ZN7android7content2pm22IPackageChangeObserverD2Ev; - _ZN7android7content2pm23BnPackageChangeObserver10onTransactEjRKNS_6ParcelEPS3_j; - _ZN7android7content2pm23BnPackageChangeObserverC2Ev; - _ZN7android7content2pm23BpPackageChangeObserver16onPackageChangedERKNS1_18PackageChangeEventE; - _ZN7android7content2pm23BpPackageChangeObserverC1ERKNS_2spINS_7IBinderEEE; - _ZN7android7content2pm23BpPackageChangeObserverC2ERKNS_2spINS_7IBinderEEE; - _ZN7android7HexDumpC1EPKvjj; - _ZN7android7HexDumpC2EPKvjj; - _ZN7android7IBinder11getDebugPidEPi; - _ZN7android7IBinder11localBinderEv; - _ZN7android7IBinder12getExtensionEPNS_2spIS0_EE; - _ZN7android7IBinder12remoteBinderEv; - _ZN7android7IBinder12shellCommandERKNS_2spIS0_EEiiiRNS_6VectorINS_8String16EEERKNS1_INS_14IShellCallbackEEERKNS1_INS_15IResultReceiverEEE; - _ZN7android7IBinder19queryLocalInterfaceERKNS_8String16E; - _ZN7android7IBinderC2Ev; - _ZN7android7IBinderD0Ev; - _ZN7android7IBinderD1Ev; - _ZN7android7IBinderD2Ev; - _ZN7android7IMemory10descriptorE; - _ZN7android7IMemory11asInterfaceERKNS_2spINS_7IBinderEEE; - _ZN7android7IMemory12default_implE; - _ZN7android7IMemory14getDefaultImplEv; - _ZN7android7IMemory14setDefaultImplENSt3__110unique_ptrIS0_NS1_14default_deleteIS0_EEEE; - _ZN7android7IMemoryC2Ev; - _ZN7android7IMemoryD0Ev; - _ZN7android7IMemoryD1Ev; - _ZN7android7IMemoryD2Ev; - _ZN7android8BnMemory10onTransactEjRKNS_6ParcelEPS1_j; - _ZN7android8BnMemoryC2Ev; - _ZN7android8BnMemoryD0Ev; - _ZN7android8BnMemoryD1Ev; - _ZN7android8BnMemoryD2Ev; - _ZN7android8BpBinder10onFirstRefEv; - _ZN7android8BpBinder10pingBinderEv; - _ZN7android8BpBinder11linkToDeathERKNS_2spINS_7IBinder14DeathRecipientEEEPvj; - _ZN7android8BpBinder12attachObjectEPKvPvS3_PFvS2_S3_S3_E; - _ZN7android8BpBinder12detachObjectEPKv; - _ZN7android8BpBinder12remoteBinderEv; - _ZN7android8BpBinder12sendObituaryEv; - _ZN7android8BpBinder12sTrackingMapE; - _ZN7android8BpBinder13getCountByUidERNS_6VectorIjEES3_; - _ZN7android8BpBinder13ObjectManager4killEv; - _ZN7android8BpBinder13ObjectManager6attachEPKvPvS4_PFvS3_S4_S4_E; - _ZN7android8BpBinder13ObjectManager6detachEPKv; - _ZN7android8BpBinder13ObjectManagerC1Ev; - _ZN7android8BpBinder13ObjectManagerC2Ev; - _ZN7android8BpBinder13ObjectManagerD1Ev; - _ZN7android8BpBinder13ObjectManagerD2Ev; - _ZN7android8BpBinder13sTrackingLockE; - _ZN7android8BpBinder13unlinkToDeathERKNS_2wpINS_7IBinder14DeathRecipientEEEPvjPS4_; - _ZN7android8BpBinder14reportOneDeathERKNS0_8ObituaryE; - _ZN7android8BpBinder14sLimitCallbackE; - _ZN7android8BpBinder15onLastStrongRefEPKv; - _ZN7android8BpBinder15sNumTrackedUidsE; - _ZN7android8BpBinder16enableCountByUidEv; - _ZN7android8BpBinder16setLimitCallbackEPFviE; - _ZN7android8BpBinder17disableCountByUidEv; - _ZN7android8BpBinder18sCountByUidEnabledE; - _ZN7android8BpBinder19getBinderProxyCountEj; - _ZN7android8BpBinder20onIncStrongAttemptedEjPKv; - _ZN7android8BpBinder20setCountByUidEnabledEb; - _ZN7android8BpBinder26sBinderProxyThrottleCreateE; - _ZN7android8BpBinder29sBinderProxyCountLowWatermarkE; - _ZN7android8BpBinder29setBinderProxyCountWatermarksEii; - _ZN7android8BpBinder30sBinderProxyCountHighWatermarkE; - _ZN7android8BpBinder4dumpEiRKNS_6VectorINS_8String16EEE; - _ZN7android8BpBinder6createEi; - _ZN7android8BpBinder6createERKNS_2spINS_10RpcSessionEEERKNS_10RpcAddressE; - _ZN7android8BpBinder8transactEjRKNS_6ParcelEPS1_j; - _ZN7android8BpBinderC1EONS0_12BinderHandleEi; - _ZN7android8BpBinderC1EONS0_9RpcHandleE; - _ZN7android8BpBinderC1EONSt3__17variantIJNS0_12BinderHandleENS0_9RpcHandleEEEE; - _ZN7android8BpBinderC2EONS0_12BinderHandleEi; - _ZN7android8BpBinderC2EONS0_9RpcHandleE; - _ZN7android8BpBinderC2EONSt3__17variantIJNS0_12BinderHandleENS0_9RpcHandleEEEE; - _ZN7android8BpBinderD0Ev; - _ZN7android8BpBinderD1Ev; - _ZN7android8BpBinderD2Ev; - _ZN7android8BpMemoryC1ERKNS_2spINS_7IBinderEEE; - _ZN7android8BpMemoryC2ERKNS_2spINS_7IBinderEEE; - _ZN7android8BpMemoryD0Ev; - _ZN7android8BpMemoryD1Ev; - _ZN7android8BpMemoryD2Ev; - _ZN7android8internal9Stability11getCategoryEPNS_7IBinderE; - _ZN7android8internal9Stability11levelStringENS1_5LevelE; - _ZN7android8internal9Stability13getLocalLevelEv; - _ZN7android8internal9Stability15isDeclaredLevelENS1_5LevelE; - _ZN7android8internal9Stability17debugLogStabilityERKNSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEERKNS_2spINS_7IBinderEEE; - _ZN7android8internal9Stability19markCompilationUnitEPNS_7IBinderE; - _ZN7android8internal9Stability22tryMarkCompilationUnitEPNS_7IBinderE; - _ZN7android8internal9Stability24requiresVintfDeclarationERKNS_2spINS_7IBinderEEE; - _ZN7android8internal9Stability25forceDowngradeToStabilityERKNS_2spINS_7IBinderEEENS1_5LevelE; - _ZN7android8internal9Stability30forceDowngradeToLocalStabilityERKNS_2spINS_7IBinderEEE; - _ZN7android8internal9Stability31forceDowngradeToSystemStabilityERKNS_2spINS_7IBinderEEE; - _ZN7android8internal9Stability31forceDowngradeToVendorStabilityERKNS_2spINS_7IBinderEEE; - _ZN7android8internal9Stability5checkENS1_8CategoryENS1_5LevelE; - _ZN7android8internal9Stability7setReprEPNS_7IBinderEij; - _ZN7android8internal9Stability8Category11debugStringEv; - _ZN7android8internal9Stability8markVndkEPNS_7IBinderE; - _ZN7android8internal9Stability9markVintfEPNS_7IBinderE; - _ZN7android8RpcState11CommandDataC1Ej; - _ZN7android8RpcState11CommandDataC2Ej; - _ZN7android8RpcState12countBindersEv; - _ZN7android8RpcState12getSessionIdERKNS_4base14unique_fd_implINS1_13DefaultCloserEEERKNS_2spINS_10RpcSessionEEEPi; - _ZN7android8RpcState12waitForReplyERKNS_4base14unique_fd_implINS1_13DefaultCloserEEERKNS_2spINS_10RpcSessionEEEPNS_6ParcelE; - _ZN7android8RpcState13getMaxThreadsERKNS_4base14unique_fd_implINS1_13DefaultCloserEEERKNS_2spINS_10RpcSessionEEEPj; - _ZN7android8RpcState13getRootObjectERKNS_4base14unique_fd_implINS1_13DefaultCloserEEERKNS_2spINS_10RpcSessionEEE; - _ZN7android8RpcState13sendDecStrongERKNS_4base14unique_fd_implINS1_13DefaultCloserEEERKNS_10RpcAddressE; - _ZN7android8RpcState15onBinderLeavingERKNS_2spINS_10RpcSessionEEERKNS1_INS_7IBinderEEEPNS_10RpcAddressE; - _ZN7android8RpcState15processTransactERKNS_4base14unique_fd_implINS1_13DefaultCloserEEERKNS_2spINS_10RpcSessionEEERKNS_13RpcWireHeaderE; - _ZN7android8RpcState16onBinderEnteringERKNS_2spINS_10RpcSessionEEERKNS_10RpcAddressE; - _ZN7android8RpcState16processDecStrongERKNS_4base14unique_fd_implINS1_13DefaultCloserEEERKNS_13RpcWireHeaderE; - _ZN7android8RpcState20getAndExecuteCommandERKNS_4base14unique_fd_implINS1_13DefaultCloserEEERKNS_2spINS_10RpcSessionEEE; - _ZN7android8RpcState20processServerCommandERKNS_4base14unique_fd_implINS1_13DefaultCloserEEERKNS_2spINS_10RpcSessionEEERKNS_13RpcWireHeaderE; - _ZN7android8RpcState23processTransactInternalERKNS_4base14unique_fd_implINS1_13DefaultCloserEEERKNS_2spINS_10RpcSessionEEENS0_11CommandDataE; - _ZN7android8RpcState4dumpEv; - _ZN7android8RpcState6rpcRecERKNS_4base14unique_fd_implINS1_13DefaultCloserEEEPKcPvj; - _ZN7android8RpcState7rpcSendERKNS_4base14unique_fd_implINS1_13DefaultCloserEEEPKcPKvj; - _ZN7android8RpcState8transactERKNS_4base14unique_fd_implINS1_13DefaultCloserEEERKNS_10RpcAddressEjRKNS_6ParcelERKNS_2spINS_10RpcSessionEEEPSA_j; - _ZN7android8RpcState9terminateEv; - _ZN7android8RpcStateC1Ev; - _ZN7android8RpcStateC2Ev; - _ZN7android8RpcStateD1Ev; - _ZN7android8RpcStateD2Ev; - _ZN7android9BpRefBase10onFirstRefEv; - _ZN7android9BpRefBase15onLastStrongRefEPKv; - _ZN7android9BpRefBase20onIncStrongAttemptedEjPKv; - _ZN7android9BpRefBaseC1ERKNS_2spINS_7IBinderEEE; - _ZN7android9BpRefBaseC2ERKNS_2spINS_7IBinderEEE; - _ZN7android9BpRefBaseD0Ev; - _ZN7android9BpRefBaseD1Ev; - _ZN7android9BpRefBaseD2Ev; - _ZN7android9HeapCache10binderDiedERKNS_2wpINS_7IBinderEEE; - _ZN7android9HeapCache10dump_heapsEv; - _ZN7android9HeapCache8get_heapERKNS_2spINS_7IBinderEEE; - _ZN7android9HeapCache9find_heapERKNS_2spINS_7IBinderEEE; - _ZN7android9HeapCache9free_heapERKNS_2spINS_7IBinderEEE; - _ZN7android9HeapCache9free_heapERKNS_2wpINS_7IBinderEEE; - _ZN7android9HeapCacheC1Ev; - _ZN7android9HeapCacheC2Ev; - _ZN7android9HeapCacheD0Ev; - _ZN7android9HeapCacheD1Ev; - _ZN7android9HeapCacheD2Ev; - _ZN7android9hexStringEPKvj; - _ZN7android9RpcServer12listSessionsEv; - _ZN7android9RpcServer13getMaxThreadsEv; - _ZN7android9RpcServer13getRootObjectEv; - _ZN7android9RpcServer13releaseServerEv; - _ZN7android9RpcServer13setMaxThreadsEj; - _ZN7android9RpcServer13setRootObjectERKNS_2spINS_7IBinderEEE; - _ZN7android9RpcServer15setupInetServerEjPj; - _ZN7android9RpcServer16setupVsockServerEj; - _ZN7android9RpcServer17setRootObjectWeakERKNS_2wpINS_7IBinderEEE; - _ZN7android9RpcServer17setupSocketServerERKNS_16RpcSocketAddressE; - _ZN7android9RpcServer19establishConnectionEONS_2spIS0_EENS_4base14unique_fd_implINS4_13DefaultCloserEEE; - _ZN7android9RpcServer19setupExternalServerENS_4base14unique_fd_implINS1_13DefaultCloserEEE; - _ZN7android9RpcServer20onSessionTerminatingERKNS_2spINS_10RpcSessionEEE; - _ZN7android9RpcServer21setupUnixDomainServerEPKc; - _ZN7android9RpcServer24numUninitializedSessionsEv; - _ZN7android9RpcServer4joinEv; - _ZN7android9RpcServer4makeEv; - _ZN7android9RpcServer61iUnderstandThisCodeIsExperimentalAndIWillNotUseItInProductionEv; - _ZN7android9RpcServer9acceptOneEv; - _ZN7android9RpcServer9hasServerEv; - _ZN7android9RpcServerC1Ev; - _ZN7android9RpcServerC2Ev; - _ZN7android9RpcServerD0Ev; - _ZN7android9RpcServerD1Ev; - _ZN7android9RpcServerD2Ev; - _ZN7androidlsERNS_10TextOutputERKNS_7HexDumpE; - _ZN7androidlsERNS_10TextOutputERKNS_8TypeCodeE; - _ZN7androidlsIA15_cEERNS_10TextOutputES3_RKT_; - _ZN7androidlsIA24_cEERNS_10TextOutputES3_RKT_; - _ZN7androidlsIA2_cEERNS_10TextOutputES3_RKT_; - _ZN7androidlsIA34_cEERNS_10TextOutputES3_RKT_; - _ZN7androidlsIA3_cEERNS_10TextOutputES3_RKT_; - _ZN7androidlsIA43_cEERNS_10TextOutputES3_RKT_; - _ZN7androidlsIA4_cEERNS_10TextOutputES3_RKT_; - _ZN7androidlsIA5_cEERNS_10TextOutputES3_RKT_; - _ZN7androidlsIA8_cEERNS_10TextOutputES3_RKT_; - _ZN7androidlsIA9_cEERNS_10TextOutputES3_RKT_; - _ZN7androidlsIjEERNS_10TextOutputES2_RKT_; - _ZN7androidlsINSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEEERNS_10TextOutputES9_RKT_; - _ZN7androidlsIPcEERNS_10TextOutputES3_RKT_; - _ZN7androidlsIPvEERNS_10TextOutputES3_RKT_; - _ZN7androidlsIyEERNS_10TextOutputES2_RKT_; - _ZNK7android10MemoryBase9getMemoryEPiPj; - _ZNK7android10RpcAddress13writeToParcelEPNS_6ParcelE; - _ZNK7android10RpcAddress15viewRawEmbeddedEv; - _ZNK7android10RpcAddress6isZeroEv; - _ZNK7android10RpcAddress8toStringEv; - _ZNK7android10RpcAddressltERKS0_; - _ZNK7android11IMemoryHeap22getInterfaceDescriptorEv; - _ZNK7android12BpMemoryHeap12assertMappedEv; - _ZNK7android12BpMemoryHeap18assertReallyMappedEv; - _ZNK7android12BpMemoryHeap7getBaseEv; - _ZNK7android12BpMemoryHeap7getSizeEv; - _ZNK7android12BpMemoryHeap8getFlagsEv; - _ZNK7android12BpMemoryHeap9getHeapIDEv; - _ZNK7android12BpMemoryHeap9getOffsetEv; - _ZNK7android12MemoryDealer4dumpEPKc; - _ZNK7android12MemoryDealer4heapEv; - _ZNK7android12MemoryDealer9allocatorEv; - _ZNK7android12SortedVectorINS_16key_value_pair_tINS_2wpINS_7IBinderEEENS_9HeapCache11heap_info_tEEEE10do_compareEPKvSA_; - _ZNK7android12SortedVectorINS_16key_value_pair_tINS_2wpINS_7IBinderEEENS_9HeapCache11heap_info_tEEEE10do_destroyEPvj; - _ZNK7android12SortedVectorINS_16key_value_pair_tINS_2wpINS_7IBinderEEENS_9HeapCache11heap_info_tEEEE12do_constructEPvj; - _ZNK7android12SortedVectorINS_16key_value_pair_tINS_2wpINS_7IBinderEEENS_9HeapCache11heap_info_tEEEE15do_move_forwardEPvPKvj; - _ZNK7android12SortedVectorINS_16key_value_pair_tINS_2wpINS_7IBinderEEENS_9HeapCache11heap_info_tEEEE16do_move_backwardEPvPKvj; - _ZNK7android12SortedVectorINS_16key_value_pair_tINS_2wpINS_7IBinderEEENS_9HeapCache11heap_info_tEEEE7do_copyEPvPKvj; - _ZNK7android12SortedVectorINS_16key_value_pair_tINS_2wpINS_7IBinderEEENS_9HeapCache11heap_info_tEEEE8do_splatEPvPKvj; - _ZNK7android12SortedVectorINS_16key_value_pair_tIPKvNS_8BpBinder13ObjectManager7entry_tEEEE10do_compareES3_S3_; - _ZNK7android12SortedVectorINS_16key_value_pair_tIPKvNS_8BpBinder13ObjectManager7entry_tEEEE10do_destroyEPvj; - _ZNK7android12SortedVectorINS_16key_value_pair_tIPKvNS_8BpBinder13ObjectManager7entry_tEEEE12do_constructEPvj; - _ZNK7android12SortedVectorINS_16key_value_pair_tIPKvNS_8BpBinder13ObjectManager7entry_tEEEE15do_move_forwardEPvS3_j; - _ZNK7android12SortedVectorINS_16key_value_pair_tIPKvNS_8BpBinder13ObjectManager7entry_tEEEE16do_move_backwardEPvS3_j; - _ZNK7android12SortedVectorINS_16key_value_pair_tIPKvNS_8BpBinder13ObjectManager7entry_tEEEE7do_copyEPvS3_j; - _ZNK7android12SortedVectorINS_16key_value_pair_tIPKvNS_8BpBinder13ObjectManager7entry_tEEEE8do_splatEPvS3_j; - _ZNK7android14IPCThreadState13getCallingPidEv; - _ZNK7android14IPCThreadState13getCallingSidEv; - _ZNK7android14IPCThreadState13getCallingUidEv; - _ZNK7android14IPCThreadState18getCallRestrictionEv; - _ZNK7android14IPCThreadState19getStrictModePolicyEv; - _ZNK7android14IPCThreadState22getServingStackPointerEv; - _ZNK7android14IPCThreadState23getCallingWorkSourceUidEv; - _ZNK7android14IPCThreadState25shouldPropagateWorkSourceEv; - _ZNK7android14IPCThreadState29getLastTransactionBinderFlagsEv; - _ZNK7android14IShellCallback22getInterfaceDescriptorEv; - _ZNK7android14MemoryHeapBase7getBaseEv; - _ZNK7android14MemoryHeapBase7getSizeEv; - _ZNK7android14MemoryHeapBase8getFlagsEv; - _ZNK7android14MemoryHeapBase9getDeviceEv; - _ZNK7android14MemoryHeapBase9getHeapIDEv; - _ZNK7android14MemoryHeapBase9getOffsetEv; - _ZNK7android15IResultReceiver22getInterfaceDescriptorEv; - _ZNK7android15IServiceManager22getInterfaceDescriptorEv; - _ZNK7android18BufferedTextOutput9getBufferEv; - _ZNK7android18ServiceManagerShim10getServiceERKNS_8String16E; - _ZNK7android18ServiceManagerShim12checkServiceERKNS_8String16E; - _ZNK7android22SimpleBestFitAllocator4dumpEPKc; - _ZNK7android22SimpleBestFitAllocator4dumpERNS_7String8EPKc; - _ZNK7android22SimpleBestFitAllocator4sizeEv; - _ZNK7android22SimpleBestFitAllocator6dump_lEPKc; - _ZNK7android22SimpleBestFitAllocator6dump_lERNS_7String8EPKc; - _ZNK7android2os15IClientCallback22getInterfaceDescriptorEv; - _ZNK7android2os15IServiceManager22getInterfaceDescriptorEv; - _ZNK7android2os16IServiceCallback22getInterfaceDescriptorEv; - _ZNK7android2os16ParcelableHolder13writeToParcelEPNS_6ParcelE; - _ZNK7android2os16ServiceDebugInfo13writeToParcelEPNS_6ParcelE; - _ZNK7android2os17PersistableBundle10getBooleanERKNS_8String16EPb; - _ZNK7android2os17PersistableBundle10getIntKeysEv; - _ZNK7android2os17PersistableBundle11getLongKeysEv; - _ZNK7android2os17PersistableBundle12getIntVectorERKNS_8String16EPNSt3__16vectorIiNS5_9allocatorIiEEEE; - _ZNK7android2os17PersistableBundle13getDoubleKeysEv; - _ZNK7android2os17PersistableBundle13getLongVectorERKNS_8String16EPNSt3__16vectorIxNS5_9allocatorIxEEEE; - _ZNK7android2os17PersistableBundle13getStringKeysEv; - _ZNK7android2os17PersistableBundle13writeToParcelEPNS_6ParcelE; - _ZNK7android2os17PersistableBundle14getBooleanKeysEv; - _ZNK7android2os17PersistableBundle15getDoubleVectorERKNS_8String16EPNSt3__16vectorIdNS5_9allocatorIdEEEE; - _ZNK7android2os17PersistableBundle15getStringVectorERKNS_8String16EPNSt3__16vectorIS2_NS5_9allocatorIS2_EEEE; - _ZNK7android2os17PersistableBundle16getBooleanVectorERKNS_8String16EPNSt3__16vectorIbNS5_9allocatorIbEEEE; - _ZNK7android2os17PersistableBundle16getIntVectorKeysEv; - _ZNK7android2os17PersistableBundle17getLongVectorKeysEv; - _ZNK7android2os17PersistableBundle18writeToParcelInnerEPNS_6ParcelE; - _ZNK7android2os17PersistableBundle19getDoubleVectorKeysEv; - _ZNK7android2os17PersistableBundle19getStringVectorKeysEv; - _ZNK7android2os17PersistableBundle20getBooleanVectorKeysEv; - _ZNK7android2os17PersistableBundle20getPersistableBundleERKNS_8String16EPS1_; - _ZNK7android2os17PersistableBundle24getPersistableBundleKeysEv; - _ZNK7android2os17PersistableBundle4sizeEv; - _ZNK7android2os17PersistableBundle5emptyEv; - _ZNK7android2os17PersistableBundle6getIntERKNS_8String16EPi; - _ZNK7android2os17PersistableBundle7getLongERKNS_8String16EPx; - _ZNK7android2os17PersistableBundle9getDoubleERKNS_8String16EPd; - _ZNK7android2os17PersistableBundle9getStringERKNS_8String16EPS2_; - _ZNK7android2os20ParcelFileDescriptor13writeToParcelEPNS_6ParcelE; - _ZNK7android6binder6Status13writeToParcelEPNS_6ParcelE; - _ZNK7android6binder6Status9toString8Ev; - _ZNK7android6Parcel10errorCheckEv; - _ZNK7android6Parcel10ipcObjectsEv; - _ZNK7android6Parcel10readDoubleEPd; - _ZNK7android6Parcel10readDoubleEv; - _ZNK7android6Parcel10readObjectEb; - _ZNK7android6Parcel10readUint32EPj; - _ZNK7android6Parcel10readUint32Ev; - _ZNK7android6Parcel10readUint64EPy; - _ZNK7android6Parcel10readUint64Ev; - _ZNK7android6Parcel10scanForFdsEv; - _ZNK7android6Parcel11ipcDataSizeEv; - _ZNK7android6Parcel11readCStringEv; - _ZNK7android6Parcel11readInplaceEj; - _ZNK7android6Parcel11readPointerEPj; - _ZNK7android6Parcel11readPointerEv; - _ZNK7android6Parcel11readString8EPNS_7String8E; - _ZNK7android6Parcel11readString8Ev; - _ZNK7android6Parcel12dataCapacityEv; - _ZNK7android6Parcel12dataPositionEv; - _ZNK7android6Parcel12objectsCountEv; - _ZNK7android6Parcel12readString16EPNS_8String16E; - _ZNK7android6Parcel12readString16EPNSt3__110unique_ptrINS_8String16ENS1_14default_deleteIS3_EEEE; - _ZNK7android6Parcel12readString16EPNSt3__18optionalINS_8String16EEE; - _ZNK7android6Parcel12readString16Ev; - _ZNK7android6Parcel13markSensitiveEv; - _ZNK7android6Parcel14checkInterfaceEPNS_7IBinderE; - _ZNK7android6Parcel14readBoolVectorEPNSt3__110unique_ptrINS1_6vectorIbNS1_9allocatorIbEEEENS1_14default_deleteIS6_EEEE; - _ZNK7android6Parcel14readBoolVectorEPNSt3__16vectorIbNS1_9allocatorIbEEEE; - _ZNK7android6Parcel14readBoolVectorEPNSt3__18optionalINS1_6vectorIbNS1_9allocatorIbEEEEEE; - _ZNK7android6Parcel14readByteVectorEPNSt3__110unique_ptrINS1_6vectorIaNS1_9allocatorIaEEEENS1_14default_deleteIS6_EEEE; - _ZNK7android6Parcel14readByteVectorEPNSt3__110unique_ptrINS1_6vectorIhNS1_9allocatorIhEEEENS1_14default_deleteIS6_EEEE; - _ZNK7android6Parcel14readByteVectorEPNSt3__16vectorIaNS1_9allocatorIaEEEE; - _ZNK7android6Parcel14readByteVectorEPNSt3__16vectorIhNS1_9allocatorIhEEEE; - _ZNK7android6Parcel14readByteVectorEPNSt3__18optionalINS1_6vectorIaNS1_9allocatorIaEEEEEE; - _ZNK7android6Parcel14readByteVectorEPNSt3__18optionalINS1_6vectorIhNS1_9allocatorIhEEEEEE; - _ZNK7android6Parcel14readCharVectorEPNSt3__110unique_ptrINS1_6vectorIDsNS1_9allocatorIDsEEEENS1_14default_deleteIS6_EEEE; - _ZNK7android6Parcel14readCharVectorEPNSt3__16vectorIDsNS1_9allocatorIDsEEEE; - _ZNK7android6Parcel14readCharVectorEPNSt3__18optionalINS1_6vectorIDsNS1_9allocatorIDsEEEEEE; - _ZNK7android6Parcel14readParcelableEPNS_10ParcelableE; - _ZNK7android6Parcel15ipcObjectsCountEv; - _ZNK7android6Parcel15readFloatVectorEPNSt3__110unique_ptrINS1_6vectorIfNS1_9allocatorIfEEEENS1_14default_deleteIS6_EEEE; - _ZNK7android6Parcel15readFloatVectorEPNSt3__16vectorIfNS1_9allocatorIfEEEE; - _ZNK7android6Parcel15readFloatVectorEPNSt3__18optionalINS1_6vectorIfNS1_9allocatorIfEEEEEE; - _ZNK7android6Parcel15readInt32VectorEPNSt3__110unique_ptrINS1_6vectorIiNS1_9allocatorIiEEEENS1_14default_deleteIS6_EEEE; - _ZNK7android6Parcel15readInt32VectorEPNSt3__16vectorIiNS1_9allocatorIiEEEE; - _ZNK7android6Parcel15readInt32VectorEPNSt3__18optionalINS1_6vectorIiNS1_9allocatorIiEEEEEE; - _ZNK7android6Parcel15readInt64VectorEPNSt3__110unique_ptrINS1_6vectorIxNS1_9allocatorIxEEEENS1_14default_deleteIS6_EEEE; - _ZNK7android6Parcel15readInt64VectorEPNSt3__16vectorIxNS1_9allocatorIxEEEE; - _ZNK7android6Parcel15readInt64VectorEPNSt3__18optionalINS1_6vectorIxNS1_9allocatorIxEEEEEE; - _ZNK7android6Parcel15setDataPositionEj; - _ZNK7android6Parcel15unflattenBinderEPNS_2spINS_7IBinderEEE; - _ZNK7android6Parcel16enforceInterfaceEPKDsjPNS_14IPCThreadStateE; - _ZNK7android6Parcel16enforceInterfaceERKNS_8String16EPNS_14IPCThreadStateE; - _ZNK7android6Parcel16readDoubleVectorEPNSt3__110unique_ptrINS1_6vectorIdNS1_9allocatorIdEEEENS1_14default_deleteIS6_EEEE; - _ZNK7android6Parcel16readDoubleVectorEPNSt3__16vectorIdNS1_9allocatorIdEEEE; - _ZNK7android6Parcel16readDoubleVectorEPNSt3__18optionalINS1_6vectorIdNS1_9allocatorIdEEEEEE; - _ZNK7android6Parcel16readNativeHandleEv; - _ZNK7android6Parcel16readStrongBinderEPNS_2spINS_7IBinderEEE; - _ZNK7android6Parcel16readStrongBinderEv; - _ZNK7android6Parcel16readStrongBinderINS_2os15IClientCallbackEEEiPNS_2spIT_EE; - _ZNK7android6Parcel16readStrongBinderINS_2os16IServiceCallbackEEEiPNS_2spIT_EE; - _ZNK7android6Parcel16readStrongBinderINS_7content2pm22IPackageChangeObserverEEEiPNS_2spIT_EE; - _ZNK7android6Parcel16readUint64VectorEPNSt3__110unique_ptrINS1_6vectorIyNS1_9allocatorIyEEEENS1_14default_deleteIS6_EEEE; - _ZNK7android6Parcel16readUint64VectorEPNSt3__16vectorIyNS1_9allocatorIyEEEE; - _ZNK7android6Parcel16readUint64VectorEPNSt3__18optionalINS1_6vectorIyNS1_9allocatorIyEEEEEE; - _ZNK7android6Parcel16validateReadDataEj; - _ZNK7android6Parcel17getBlobAshmemSizeEv; - _ZNK7android6Parcel17getOpenAshmemSizeEv; - _ZNK7android6Parcel17readExceptionCodeEv; - _ZNK7android6Parcel17readUtf8FromUtf16EPNSt3__110unique_ptrINS1_12basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEENS1_14default_deleteIS8_EEEE; - _ZNK7android6Parcel17readUtf8FromUtf16EPNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEE; - _ZNK7android6Parcel17readUtf8FromUtf16EPNSt3__18optionalINS1_12basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEEE; - _ZNK7android6Parcel18hasFileDescriptorsEv; - _ZNK7android6Parcel18readFileDescriptorEv; - _ZNK7android6Parcel18readString16VectorEPNSt3__110unique_ptrINS1_6vectorINS2_INS_8String16ENS1_14default_deleteIS4_EEEENS1_9allocatorIS7_EEEENS5_ISA_EEEE; - _ZNK7android6Parcel18readString16VectorEPNSt3__16vectorINS_8String16ENS1_9allocatorIS3_EEEE; - _ZNK7android6Parcel18readString16VectorEPNSt3__18optionalINS1_6vectorINS2_INS_8String16EEENS1_9allocatorIS5_EEEEEE; - _ZNK7android6Parcel18readString8InplaceEPj; - _ZNK7android6Parcel19readString16InplaceEPj; - _ZNK7android6Parcel21finishUnflattenBinderERKNS_2spINS_7IBinderEEEPS3_; - _ZNK7android6Parcel22readStrongBinderVectorEPNSt3__110unique_ptrINS1_6vectorINS_2spINS_7IBinderEEENS1_9allocatorIS6_EEEENS1_14default_deleteIS9_EEEE; - _ZNK7android6Parcel22readStrongBinderVectorEPNSt3__16vectorINS_2spINS_7IBinderEEENS1_9allocatorIS5_EEEE; - _ZNK7android6Parcel22readStrongBinderVectorEPNSt3__18optionalINS1_6vectorINS_2spINS_7IBinderEEENS1_9allocatorIS6_EEEEEE; - _ZNK7android6Parcel24readCallingWorkSourceUidEv; - _ZNK7android6Parcel24readNullableStrongBinderEPNS_2spINS_7IBinderEEE; - _ZNK7android6Parcel24readParcelFileDescriptorEv; - _ZNK7android6Parcel24readUniqueFileDescriptorEPNS_4base14unique_fd_implINS1_13DefaultCloserEEE; - _ZNK7android6Parcel29readUtf8VectorFromUtf16VectorEPNSt3__110unique_ptrINS1_6vectorINS2_INS1_12basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEENS1_14default_deleteIS9_EEEENS7_ISC_EEEENSA_ISE_EEEE; - _ZNK7android6Parcel29readUtf8VectorFromUtf16VectorEPNSt3__16vectorINS1_12basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEENS6_IS8_EEEE; - _ZNK7android6Parcel29readUtf8VectorFromUtf16VectorEPNSt3__18optionalINS1_6vectorINS2_INS1_12basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEEENS7_ISA_EEEEEE; - _ZNK7android6Parcel30readUniqueFileDescriptorVectorEPNSt3__110unique_ptrINS1_6vectorINS_4base14unique_fd_implINS4_13DefaultCloserEEENS1_9allocatorIS7_EEEENS1_14default_deleteISA_EEEE; - _ZNK7android6Parcel30readUniqueFileDescriptorVectorEPNSt3__16vectorINS_4base14unique_fd_implINS3_13DefaultCloserEEENS1_9allocatorIS6_EEEE; - _ZNK7android6Parcel30readUniqueFileDescriptorVectorEPNSt3__18optionalINS1_6vectorINS_4base14unique_fd_implINS4_13DefaultCloserEEENS1_9allocatorIS7_EEEEEE; - _ZNK7android6Parcel30readUniqueParcelFileDescriptorEPNS_4base14unique_fd_implINS1_13DefaultCloserEEE; - _ZNK7android6Parcel37updateWorkSourceRequestHeaderPositionEv; - _ZNK7android6Parcel4dataEv; - _ZNK7android6Parcel4readEPvj; - _ZNK7android6Parcel4readERNS0_26FlattenableHelperInterfaceE; - _ZNK7android6Parcel5printERNS_10TextOutputEj; - _ZNK7android6Parcel7ipcDataEv; - _ZNK7android6Parcel8allowFdsEv; - _ZNK7android6Parcel8dataSizeEv; - _ZNK7android6Parcel8isForRpcEv; - _ZNK7android6Parcel8readBlobEjPNS0_12ReadableBlobE; - _ZNK7android6Parcel8readBoolEPb; - _ZNK7android6Parcel8readBoolEv; - _ZNK7android6Parcel8readByteEPa; - _ZNK7android6Parcel8readByteEv; - _ZNK7android6Parcel8readCharEPDs; - _ZNK7android6Parcel8readCharEv; - _ZNK7android6Parcel9dataAvailEv; - _ZNK7android6Parcel9readFloatEPf; - _ZNK7android6Parcel9readFloatEv; - _ZNK7android6Parcel9readInt32EPi; - _ZNK7android6Parcel9readInt32Ev; - _ZNK7android6Parcel9readInt64EPx; - _ZNK7android6Parcel9readInt64Ev; - _ZNK7android6VectorIiE10do_destroyEPvj; - _ZNK7android6VectorIiE12do_constructEPvj; - _ZNK7android6VectorIiE15do_move_forwardEPvPKvj; - _ZNK7android6VectorIiE16do_move_backwardEPvPKvj; - _ZNK7android6VectorIiE7do_copyEPvPKvj; - _ZNK7android6VectorIiE8do_splatEPvPKvj; - _ZNK7android6VectorINS_12ProcessState12handle_entryEE10do_destroyEPvj; - _ZNK7android6VectorINS_12ProcessState12handle_entryEE12do_constructEPvj; - _ZNK7android6VectorINS_12ProcessState12handle_entryEE15do_move_forwardEPvPKvj; - _ZNK7android6VectorINS_12ProcessState12handle_entryEE16do_move_backwardEPvPKvj; - _ZNK7android6VectorINS_12ProcessState12handle_entryEE7do_copyEPvPKvj; - _ZNK7android6VectorINS_12ProcessState12handle_entryEE8do_splatEPvPKvj; - _ZNK7android6VectorINS_2spINS_18BufferedTextOutput11BufferStateEEEE10do_destroyEPvj; - _ZNK7android6VectorINS_2spINS_18BufferedTextOutput11BufferStateEEEE12do_constructEPvj; - _ZNK7android6VectorINS_2spINS_18BufferedTextOutput11BufferStateEEEE15do_move_forwardEPvPKvj; - _ZNK7android6VectorINS_2spINS_18BufferedTextOutput11BufferStateEEEE16do_move_backwardEPvPKvj; - _ZNK7android6VectorINS_2spINS_18BufferedTextOutput11BufferStateEEEE7do_copyEPvPKvj; - _ZNK7android6VectorINS_2spINS_18BufferedTextOutput11BufferStateEEEE8do_splatEPvPKvj; - _ZNK7android6VectorINS_8BpBinder8ObituaryEE10do_destroyEPvj; - _ZNK7android6VectorINS_8BpBinder8ObituaryEE12do_constructEPvj; - _ZNK7android6VectorINS_8BpBinder8ObituaryEE15do_move_forwardEPvPKvj; - _ZNK7android6VectorINS_8BpBinder8ObituaryEE16do_move_backwardEPvPKvj; - _ZNK7android6VectorINS_8BpBinder8ObituaryEE7do_copyEPvPKvj; - _ZNK7android6VectorINS_8BpBinder8ObituaryEE8do_splatEPvPKvj; - _ZNK7android6VectorINS_8String16EE10do_destroyEPvj; - _ZNK7android6VectorINS_8String16EE12do_constructEPvj; - _ZNK7android6VectorINS_8String16EE15do_move_forwardEPvPKvj; - _ZNK7android6VectorINS_8String16EE16do_move_backwardEPvPKvj; - _ZNK7android6VectorINS_8String16EE7do_copyEPvPKvj; - _ZNK7android6VectorINS_8String16EE8do_splatEPvPKvj; - _ZNK7android6VectorIPNS_7BBinderEE10do_destroyEPvj; - _ZNK7android6VectorIPNS_7BBinderEE12do_constructEPvj; - _ZNK7android6VectorIPNS_7BBinderEE15do_move_forwardEPvPKvj; - _ZNK7android6VectorIPNS_7BBinderEE16do_move_backwardEPvPKvj; - _ZNK7android6VectorIPNS_7BBinderEE7do_copyEPvPKvj; - _ZNK7android6VectorIPNS_7BBinderEE8do_splatEPvPKvj; - _ZNK7android6VectorIPNS_7RefBase12weakref_typeEE10do_destroyEPvj; - _ZNK7android6VectorIPNS_7RefBase12weakref_typeEE12do_constructEPvj; - _ZNK7android6VectorIPNS_7RefBase12weakref_typeEE15do_move_forwardEPvPKvj; - _ZNK7android6VectorIPNS_7RefBase12weakref_typeEE16do_move_backwardEPvPKvj; - _ZNK7android6VectorIPNS_7RefBase12weakref_typeEE7do_copyEPvPKvj; - _ZNK7android6VectorIPNS_7RefBase12weakref_typeEE8do_splatEPvPKvj; - _ZNK7android6VectorIPNS_7RefBaseEE10do_destroyEPvj; - _ZNK7android6VectorIPNS_7RefBaseEE12do_constructEPvj; - _ZNK7android6VectorIPNS_7RefBaseEE15do_move_forwardEPvPKvj; - _ZNK7android6VectorIPNS_7RefBaseEE16do_move_backwardEPvPKvj; - _ZNK7android6VectorIPNS_7RefBaseEE7do_copyEPvPKvj; - _ZNK7android6VectorIPNS_7RefBaseEE8do_splatEPvPKvj; - _ZNK7android7BBinder10findObjectEPKv; - _ZNK7android7BBinder13isBinderAliveEv; - _ZNK7android7BBinder22getInterfaceDescriptorEv; - _ZNK7android7content2pm18PackageChangeEvent13writeToParcelEPNS_6ParcelE; - _ZNK7android7content2pm21IPackageManagerNative22getInterfaceDescriptorEv; - _ZNK7android7content2pm22IPackageChangeObserver22getInterfaceDescriptorEv; - _ZNK7android7IBinder13checkSubclassEPKv; - _ZNK7android7IMemory11fastPointerERKNS_2spINS_7IBinderEEEi; - _ZNK7android7IMemory15unsecurePointerEv; - _ZNK7android7IMemory22getInterfaceDescriptorEv; - _ZNK7android7IMemory4sizeEv; - _ZNK7android7IMemory6offsetEv; - _ZNK7android7IMemory7pointerEv; - _ZNK7android8BpBinder10findObjectEPKv; - _ZNK7android8BpBinder10rpcAddressEv; - _ZNK7android8BpBinder10rpcSessionEv; - _ZNK7android8BpBinder11isRpcBinderEv; - _ZNK7android8BpBinder12binderHandleEv; - _ZNK7android8BpBinder13isBinderAliveEv; - _ZNK7android8BpBinder13ObjectManager4findEPKv; - _ZNK7android8BpBinder18isDescriptorCachedEv; - _ZNK7android8BpBinder22getInterfaceDescriptorEv; - _ZNK7android8BpMemory9getMemoryEPiPj; - _ZNKSt3__115basic_stringbufIcNS_11char_traitsIcEENS_9allocatorIcEEE3strEv; - _ZNKSt3__16__treeINS_12__value_typeIN7android8String16EbEENS_19__map_value_compareIS3_S4_NS_4lessIS3_EELb1EEENS_9allocatorIS4_EEE4findIS3_EENS_21__tree_const_iteratorIS4_PNS_11__tree_nodeIS4_PvEEiEERKT_; - _ZNKSt3__16__treeINS_12__value_typeIN7android8String16EdEENS_19__map_value_compareIS3_S4_NS_4lessIS3_EELb1EEENS_9allocatorIS4_EEE4findIS3_EENS_21__tree_const_iteratorIS4_PNS_11__tree_nodeIS4_PvEEiEERKT_; - _ZNKSt3__16__treeINS_12__value_typeIN7android8String16EiEENS_19__map_value_compareIS3_S4_NS_4lessIS3_EELb1EEENS_9allocatorIS4_EEE4findIS3_EENS_21__tree_const_iteratorIS4_PNS_11__tree_nodeIS4_PvEEiEERKT_; - _ZNKSt3__16__treeINS_12__value_typeIN7android8String16ENS2_2os17PersistableBundleEEENS_19__map_value_compareIS3_S6_NS_4lessIS3_EELb1EEENS_9allocatorIS6_EEE4findIS3_EENS_21__tree_const_iteratorIS6_PNS_11__tree_nodeIS6_PvEEiEERKT_; - _ZNKSt3__16__treeINS_12__value_typeIN7android8String16ENS_6vectorIbNS_9allocatorIbEEEEEENS_19__map_value_compareIS3_S8_NS_4lessIS3_EELb1EEENS5_IS8_EEE4findIS3_EENS_21__tree_const_iteratorIS8_PNS_11__tree_nodeIS8_PvEEiEERKT_; - _ZNKSt3__16__treeINS_12__value_typeIN7android8String16ENS_6vectorIdNS_9allocatorIdEEEEEENS_19__map_value_compareIS3_S8_NS_4lessIS3_EELb1EEENS5_IS8_EEE4findIS3_EENS_21__tree_const_iteratorIS8_PNS_11__tree_nodeIS8_PvEEiEERKT_; - _ZNKSt3__16__treeINS_12__value_typeIN7android8String16ENS_6vectorIiNS_9allocatorIiEEEEEENS_19__map_value_compareIS3_S8_NS_4lessIS3_EELb1EEENS5_IS8_EEE4findIS3_EENS_21__tree_const_iteratorIS8_PNS_11__tree_nodeIS8_PvEEiEERKT_; - _ZNKSt3__16__treeINS_12__value_typeIN7android8String16ENS_6vectorIS3_NS_9allocatorIS3_EEEEEENS_19__map_value_compareIS3_S8_NS_4lessIS3_EELb1EEENS5_IS8_EEE4findIS3_EENS_21__tree_const_iteratorIS8_PNS_11__tree_nodeIS8_PvEEiEERKT_; - _ZNKSt3__16__treeINS_12__value_typeIN7android8String16ENS_6vectorIxNS_9allocatorIxEEEEEENS_19__map_value_compareIS3_S8_NS_4lessIS3_EELb1EEENS5_IS8_EEE4findIS3_EENS_21__tree_const_iteratorIS8_PNS_11__tree_nodeIS8_PvEEiEERKT_; - _ZNKSt3__16__treeINS_12__value_typeIN7android8String16ES3_EENS_19__map_value_compareIS3_S4_NS_4lessIS3_EELb1EEENS_9allocatorIS4_EEE4findIS3_EENS_21__tree_const_iteratorIS4_PNS_11__tree_nodeIS4_PvEEiEERKT_; - _ZNKSt3__16__treeINS_12__value_typeIN7android8String16ExEENS_19__map_value_compareIS3_S4_NS_4lessIS3_EELb1EEENS_9allocatorIS4_EEE4findIS3_EENS_21__tree_const_iteratorIS4_PNS_11__tree_nodeIS4_PvEEiEERKT_; - _ZNKSt3__16__treeINS_12__value_typeINS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEEN7android6binder8internal25ClientCounterCallbackImpl7ServiceEEENS_19__map_value_compareIS7_SD_NS_4lessIS7_EELb1EEENS5_ISD_EEE14__count_uniqueIS7_EEjRKT_; - _ZNSt3__111__sift_downIRNS_4lessIN7android8RpcState10BinderNode9AsyncTodoEEENS_11__wrap_iterIPS5_EEEEvT0_SB_T_NS_15iterator_traitsISB_E15difference_typeESB_; - _ZNSt3__111unique_lockINS_5mutexEE6unlockEv; - _ZNSt3__112__hash_tableINS_17__hash_value_typeIijEENS_22__unordered_map_hasherIiS2_NS_4hashIiEELb1EEENS_21__unordered_map_equalIiS2_NS_8equal_toIiEELb1EEENS_9allocatorIS2_EEE14__erase_uniqueIiEEjRKT_; - _ZNSt3__112__hash_tableINS_17__hash_value_typeIijEENS_22__unordered_map_hasherIiS2_NS_4hashIiEELb1EEENS_21__unordered_map_equalIiS2_NS_8equal_toIiEELb1EEENS_9allocatorIS2_EEE25__emplace_unique_key_argsIiJRKNS_21piecewise_construct_tENS_5tupleIJRKiEEENSI_IJEEEEEENS_4pairINS_15__hash_iteratorIPNS_11__hash_nodeIS2_PvEEEEbEERKT_DpOT0_; - _ZNSt3__112__hash_tableINS_17__hash_value_typeIijEENS_22__unordered_map_hasherIiS2_NS_4hashIiEELb1EEENS_21__unordered_map_equalIiS2_NS_8equal_toIiEELb1EEENS_9allocatorIS2_EEE6rehashEj; - _ZNSt3__112__hash_tableINS_17__hash_value_typeIijEENS_22__unordered_map_hasherIiS2_NS_4hashIiEELb1EEENS_21__unordered_map_equalIiS2_NS_8equal_toIiEELb1EEENS_9allocatorIS2_EEE6removeENS_21__hash_const_iteratorIPNS_11__hash_nodeIS2_PvEEEE; - _ZNSt3__112__hash_tableINS_17__hash_value_typeIijEENS_22__unordered_map_hasherIiS2_NS_4hashIiEELb1EEENS_21__unordered_map_equalIiS2_NS_8equal_toIiEELb1EEENS_9allocatorIS2_EEE8__rehashEj; - _ZNSt3__113__tree_removeIPNS_16__tree_node_baseIPvEEEEvT_S5_; - _ZNSt3__113unordered_mapIijNS_4hashIiEENS_8equal_toIiEENS_9allocatorINS_4pairIKijEEEEEixERS7_; - _ZNSt3__114__copy_alignedINS_6vectorIbNS_9allocatorIbEEEELb0EEENS_14__bit_iteratorIT_Lb0EXLi0EEEENS5_IS6_XT0_EXLi0EEEES8_S7_; - _ZNSt3__114__copy_alignedINS_6vectorIbNS_9allocatorIbEEEELb1EEENS_14__bit_iteratorIT_Lb0EXLi0EEEENS5_IS6_XT0_EXLi0EEEES8_S7_; - _ZNSt3__114__thread_proxyINS_5tupleIJNS_10unique_ptrINS_15__thread_structENS_14default_deleteIS3_EEEEMN7android9RpcServerEFvONS7_2spIS8_EENS7_4base14unique_fd_implINSC_13DefaultCloserEEEEPS8_SA_SF_EEEEEPvSK_; - _ZNSt3__115basic_stringbufIcNS_11char_traitsIcEENS_9allocatorIcEEE7seekoffExNS_8ios_base7seekdirEj; - _ZNSt3__115basic_stringbufIcNS_11char_traitsIcEENS_9allocatorIcEEE8overflowEi; - _ZNSt3__115basic_stringbufIcNS_11char_traitsIcEENS_9allocatorIcEEE9pbackfailEi; - _ZNSt3__115basic_stringbufIcNS_11char_traitsIcEENS_9allocatorIcEEE9underflowEv; - _ZNSt3__116__copy_unalignedINS_6vectorIbNS_9allocatorIbEEEELb0EEENS_14__bit_iteratorIT_Lb0EXLi0EEEENS5_IS6_XT0_EXLi0EEEES8_S7_; - _ZNSt3__116__copy_unalignedINS_6vectorIbNS_9allocatorIbEEEELb1EEENS_14__bit_iteratorIT_Lb0EXLi0EEEENS5_IS6_XT0_EXLi0EEEES8_S7_; - _ZNSt3__120__shared_ptr_emplaceIN7android14RpcWireAddressENS_9allocatorIS2_EEE16__on_zero_sharedEv; - _ZNSt3__120__shared_ptr_emplaceIN7android14RpcWireAddressENS_9allocatorIS2_EEE21__on_zero_shared_weakEv; - _ZNSt3__120__shared_ptr_emplaceIN7android6binder8internal21ClientCounterCallbackENS_9allocatorIS4_EEE16__on_zero_sharedEv; - _ZNSt3__120__shared_ptr_emplaceIN7android6binder8internal21ClientCounterCallbackENS_9allocatorIS4_EEE21__on_zero_shared_weakEv; - _ZNSt3__124__put_character_sequenceIcNS_11char_traitsIcEEEERNS_13basic_ostreamIT_T0_EES7_PKS4_j; - _ZNSt3__127__tree_balance_after_insertIPNS_16__tree_node_baseIPvEEEEvT_S5_; - _ZNSt3__13mapIiN7android2spINS1_10RpcSessionEEENS_4lessIiEENS_9allocatorINS_4pairIKiS4_EEEEEixERS9_; - _ZNSt3__13mapIN7android8String16EbNS_4lessIS2_EENS_9allocatorINS_4pairIKS2_bEEEEEixERS7_; - _ZNSt3__13mapIN7android8String16EdNS_4lessIS2_EENS_9allocatorINS_4pairIKS2_dEEEEEixERS7_; - _ZNSt3__13mapIN7android8String16EiNS_4lessIS2_EENS_9allocatorINS_4pairIKS2_iEEEEEixERS7_; - _ZNSt3__13mapIN7android8String16ENS1_2os17PersistableBundleENS_4lessIS2_EENS_9allocatorINS_4pairIKS2_S4_EEEEEixERS9_; - _ZNSt3__13mapIN7android8String16ENS_6vectorIbNS_9allocatorIbEEEENS_4lessIS2_EENS4_INS_4pairIKS2_S6_EEEEEixERSA_; - _ZNSt3__13mapIN7android8String16ENS_6vectorIdNS_9allocatorIdEEEENS_4lessIS2_EENS4_INS_4pairIKS2_S6_EEEEEixERSA_; - _ZNSt3__13mapIN7android8String16ENS_6vectorIiNS_9allocatorIiEEEENS_4lessIS2_EENS4_INS_4pairIKS2_S6_EEEEEixERSA_; - _ZNSt3__13mapIN7android8String16ENS_6vectorIS2_NS_9allocatorIS2_EEEENS_4lessIS2_EENS4_INS_4pairIKS2_S6_EEEEEixERSA_; - _ZNSt3__13mapIN7android8String16ENS_6vectorIxNS_9allocatorIxEEEENS_4lessIS2_EENS4_INS_4pairIKS2_S6_EEEEEixERSA_; - _ZNSt3__13mapIN7android8String16ES2_NS_4lessIS2_EENS_9allocatorINS_4pairIKS2_S2_EEEEEixERS7_; - _ZNSt3__13mapIN7android8String16ExNS_4lessIS2_EENS_9allocatorINS_4pairIKS2_xEEEEEixERS7_; - _ZNSt3__16__treeIN7android8String16ENS_4lessIS2_EENS_9allocatorIS2_EEE12__find_equalIS2_EERPNS_16__tree_node_baseIPvEERPNS_15__tree_end_nodeISC_EERKT_; - _ZNSt3__16__treeIN7android8String16ENS_4lessIS2_EENS_9allocatorIS2_EEE25__emplace_unique_key_argsIS2_JRKS2_EEENS_4pairINS_15__tree_iteratorIS2_PNS_11__tree_nodeIS2_PvEEiEEbEERKT_DpOT0_; - _ZNSt3__16__treeIN7android8String16ENS_4lessIS2_EENS_9allocatorIS2_EEE7destroyEPNS_11__tree_nodeIS2_PvEE; - _ZNSt3__16__treeINS_12__value_typeIiN7android2spINS2_10RpcSessionEEEEENS_19__map_value_compareIiS6_NS_4lessIiEELb1EEENS_9allocatorIS6_EEE5eraseENS_21__tree_const_iteratorIS6_PNS_11__tree_nodeIS6_PvEEiEE; - _ZNSt3__16__treeINS_12__value_typeIiN7android2spINS2_10RpcSessionEEEEENS_19__map_value_compareIiS6_NS_4lessIiEELb1EEENS_9allocatorIS6_EEE7destroyEPNS_11__tree_nodeIS6_PvEE; - _ZNSt3__16__treeINS_12__value_typeIN7android10RpcAddressENS2_8RpcState10BinderNodeEEENS_19__map_value_compareIS3_S6_NS_4lessIS3_EELb1EEENS_9allocatorIS6_EEE25__emplace_unique_key_argsIS3_JNS_4pairIKS3_S5_EEEEENSF_INS_15__tree_iteratorIS6_PNS_11__tree_nodeIS6_PvEEiEEbEERKT_DpOT0_; - _ZNSt3__16__treeINS_12__value_typeIN7android10RpcAddressENS2_8RpcState10BinderNodeEEENS_19__map_value_compareIS3_S6_NS_4lessIS3_EELb1EEENS_9allocatorIS6_EEE7destroyEPNS_11__tree_nodeIS6_PvEE; - _ZNSt3__16__treeINS_12__value_typeIN7android8String16EbEENS_19__map_value_compareIS3_S4_NS_4lessIS3_EELb1EEENS_9allocatorIS4_EEE12__find_equalIS3_EERPNS_16__tree_node_baseIPvEENS_21__tree_const_iteratorIS4_PNS_11__tree_nodeIS4_SE_EEiEERPNS_15__tree_end_nodeISG_EESH_RKT_; - _ZNSt3__16__treeINS_12__value_typeIN7android8String16EbEENS_19__map_value_compareIS3_S4_NS_4lessIS3_EELb1EEENS_9allocatorIS4_EEE12__find_equalIS3_EERPNS_16__tree_node_baseIPvEERPNS_15__tree_end_nodeISG_EERKT_; - _ZNSt3__16__treeINS_12__value_typeIN7android8String16EbEENS_19__map_value_compareIS3_S4_NS_4lessIS3_EELb1EEENS_9allocatorIS4_EEE14__assign_multiINS_21__tree_const_iteratorIS4_PNS_11__tree_nodeIS4_PvEEiEEEEvT_SJ_; - _ZNSt3__16__treeINS_12__value_typeIN7android8String16EbEENS_19__map_value_compareIS3_S4_NS_4lessIS3_EELb1EEENS_9allocatorIS4_EEE15__emplace_multiIJRKNS_4pairIKS3_bEEEEENS_15__tree_iteratorIS4_PNS_11__tree_nodeIS4_PvEEiEEDpOT_; - _ZNSt3__16__treeINS_12__value_typeIN7android8String16EbEENS_19__map_value_compareIS3_S4_NS_4lessIS3_EELb1EEENS_9allocatorIS4_EEE25__emplace_unique_key_argsIS3_JRKNS_21piecewise_construct_tENS_5tupleIJRKS3_EEENSG_IJEEEEEENS_4pairINS_15__tree_iteratorIS4_PNS_11__tree_nodeIS4_PvEEiEEbEERKT_DpOT0_; - _ZNSt3__16__treeINS_12__value_typeIN7android8String16EbEENS_19__map_value_compareIS3_S4_NS_4lessIS3_EELb1EEENS_9allocatorIS4_EEE30__emplace_hint_unique_key_argsIS3_JRKNS_4pairIKS3_bEEEEENS_15__tree_iteratorIS4_PNS_11__tree_nodeIS4_PvEEiEENS_21__tree_const_iteratorIS4_SM_iEERKT_DpOT0_; - _ZNSt3__16__treeINS_12__value_typeIN7android8String16EbEENS_19__map_value_compareIS3_S4_NS_4lessIS3_EELb1EEENS_9allocatorIS4_EEE4findIS3_EENS_15__tree_iteratorIS4_PNS_11__tree_nodeIS4_PvEEiEERKT_; - _ZNSt3__16__treeINS_12__value_typeIN7android8String16EbEENS_19__map_value_compareIS3_S4_NS_4lessIS3_EELb1EEENS_9allocatorIS4_EEE7destroyEPNS_11__tree_nodeIS4_PvEE; - _ZNSt3__16__treeINS_12__value_typeIN7android8String16EdEENS_19__map_value_compareIS3_S4_NS_4lessIS3_EELb1EEENS_9allocatorIS4_EEE12__find_equalIS3_EERPNS_16__tree_node_baseIPvEENS_21__tree_const_iteratorIS4_PNS_11__tree_nodeIS4_SE_EEiEERPNS_15__tree_end_nodeISG_EESH_RKT_; - _ZNSt3__16__treeINS_12__value_typeIN7android8String16EdEENS_19__map_value_compareIS3_S4_NS_4lessIS3_EELb1EEENS_9allocatorIS4_EEE12__find_equalIS3_EERPNS_16__tree_node_baseIPvEERPNS_15__tree_end_nodeISG_EERKT_; - _ZNSt3__16__treeINS_12__value_typeIN7android8String16EdEENS_19__map_value_compareIS3_S4_NS_4lessIS3_EELb1EEENS_9allocatorIS4_EEE14__assign_multiINS_21__tree_const_iteratorIS4_PNS_11__tree_nodeIS4_PvEEiEEEEvT_SJ_; - _ZNSt3__16__treeINS_12__value_typeIN7android8String16EdEENS_19__map_value_compareIS3_S4_NS_4lessIS3_EELb1EEENS_9allocatorIS4_EEE15__emplace_multiIJRKNS_4pairIKS3_dEEEEENS_15__tree_iteratorIS4_PNS_11__tree_nodeIS4_PvEEiEEDpOT_; - _ZNSt3__16__treeINS_12__value_typeIN7android8String16EdEENS_19__map_value_compareIS3_S4_NS_4lessIS3_EELb1EEENS_9allocatorIS4_EEE25__emplace_unique_key_argsIS3_JRKNS_21piecewise_construct_tENS_5tupleIJRKS3_EEENSG_IJEEEEEENS_4pairINS_15__tree_iteratorIS4_PNS_11__tree_nodeIS4_PvEEiEEbEERKT_DpOT0_; - _ZNSt3__16__treeINS_12__value_typeIN7android8String16EdEENS_19__map_value_compareIS3_S4_NS_4lessIS3_EELb1EEENS_9allocatorIS4_EEE30__emplace_hint_unique_key_argsIS3_JRKNS_4pairIKS3_dEEEEENS_15__tree_iteratorIS4_PNS_11__tree_nodeIS4_PvEEiEENS_21__tree_const_iteratorIS4_SM_iEERKT_DpOT0_; - _ZNSt3__16__treeINS_12__value_typeIN7android8String16EdEENS_19__map_value_compareIS3_S4_NS_4lessIS3_EELb1EEENS_9allocatorIS4_EEE4findIS3_EENS_15__tree_iteratorIS4_PNS_11__tree_nodeIS4_PvEEiEERKT_; - _ZNSt3__16__treeINS_12__value_typeIN7android8String16EdEENS_19__map_value_compareIS3_S4_NS_4lessIS3_EELb1EEENS_9allocatorIS4_EEE7destroyEPNS_11__tree_nodeIS4_PvEE; - _ZNSt3__16__treeINS_12__value_typeIN7android8String16EiEENS_19__map_value_compareIS3_S4_NS_4lessIS3_EELb1EEENS_9allocatorIS4_EEE12__find_equalIS3_EERPNS_16__tree_node_baseIPvEENS_21__tree_const_iteratorIS4_PNS_11__tree_nodeIS4_SE_EEiEERPNS_15__tree_end_nodeISG_EESH_RKT_; - _ZNSt3__16__treeINS_12__value_typeIN7android8String16EiEENS_19__map_value_compareIS3_S4_NS_4lessIS3_EELb1EEENS_9allocatorIS4_EEE12__find_equalIS3_EERPNS_16__tree_node_baseIPvEERPNS_15__tree_end_nodeISG_EERKT_; - _ZNSt3__16__treeINS_12__value_typeIN7android8String16EiEENS_19__map_value_compareIS3_S4_NS_4lessIS3_EELb1EEENS_9allocatorIS4_EEE14__assign_multiINS_21__tree_const_iteratorIS4_PNS_11__tree_nodeIS4_PvEEiEEEEvT_SJ_; - _ZNSt3__16__treeINS_12__value_typeIN7android8String16EiEENS_19__map_value_compareIS3_S4_NS_4lessIS3_EELb1EEENS_9allocatorIS4_EEE15__emplace_multiIJRKNS_4pairIKS3_iEEEEENS_15__tree_iteratorIS4_PNS_11__tree_nodeIS4_PvEEiEEDpOT_; - _ZNSt3__16__treeINS_12__value_typeIN7android8String16EiEENS_19__map_value_compareIS3_S4_NS_4lessIS3_EELb1EEENS_9allocatorIS4_EEE25__emplace_unique_key_argsIS3_JRKNS_21piecewise_construct_tENS_5tupleIJRKS3_EEENSG_IJEEEEEENS_4pairINS_15__tree_iteratorIS4_PNS_11__tree_nodeIS4_PvEEiEEbEERKT_DpOT0_; - _ZNSt3__16__treeINS_12__value_typeIN7android8String16EiEENS_19__map_value_compareIS3_S4_NS_4lessIS3_EELb1EEENS_9allocatorIS4_EEE30__emplace_hint_unique_key_argsIS3_JRKNS_4pairIKS3_iEEEEENS_15__tree_iteratorIS4_PNS_11__tree_nodeIS4_PvEEiEENS_21__tree_const_iteratorIS4_SM_iEERKT_DpOT0_; - _ZNSt3__16__treeINS_12__value_typeIN7android8String16EiEENS_19__map_value_compareIS3_S4_NS_4lessIS3_EELb1EEENS_9allocatorIS4_EEE4findIS3_EENS_15__tree_iteratorIS4_PNS_11__tree_nodeIS4_PvEEiEERKT_; - _ZNSt3__16__treeINS_12__value_typeIN7android8String16EiEENS_19__map_value_compareIS3_S4_NS_4lessIS3_EELb1EEENS_9allocatorIS4_EEE7destroyEPNS_11__tree_nodeIS4_PvEE; - _ZNSt3__16__treeINS_12__value_typeIN7android8String16ENS2_2os17PersistableBundleEEENS_19__map_value_compareIS3_S6_NS_4lessIS3_EELb1EEENS_9allocatorIS6_EEE12__find_equalIS3_EERPNS_16__tree_node_baseIPvEENS_21__tree_const_iteratorIS6_PNS_11__tree_nodeIS6_SG_EEiEERPNS_15__tree_end_nodeISI_EESJ_RKT_; - _ZNSt3__16__treeINS_12__value_typeIN7android8String16ENS2_2os17PersistableBundleEEENS_19__map_value_compareIS3_S6_NS_4lessIS3_EELb1EEENS_9allocatorIS6_EEE12__find_equalIS3_EERPNS_16__tree_node_baseIPvEERPNS_15__tree_end_nodeISI_EERKT_; - _ZNSt3__16__treeINS_12__value_typeIN7android8String16ENS2_2os17PersistableBundleEEENS_19__map_value_compareIS3_S6_NS_4lessIS3_EELb1EEENS_9allocatorIS6_EEE14__assign_multiINS_21__tree_const_iteratorIS6_PNS_11__tree_nodeIS6_PvEEiEEEEvT_SL_; - _ZNSt3__16__treeINS_12__value_typeIN7android8String16ENS2_2os17PersistableBundleEEENS_19__map_value_compareIS3_S6_NS_4lessIS3_EELb1EEENS_9allocatorIS6_EEE14__erase_uniqueIS3_EEjRKT_; - _ZNSt3__16__treeINS_12__value_typeIN7android8String16ENS2_2os17PersistableBundleEEENS_19__map_value_compareIS3_S6_NS_4lessIS3_EELb1EEENS_9allocatorIS6_EEE15__emplace_multiIJRKNS_4pairIKS3_S5_EEEEENS_15__tree_iteratorIS6_PNS_11__tree_nodeIS6_PvEEiEEDpOT_; - _ZNSt3__16__treeINS_12__value_typeIN7android8String16ENS2_2os17PersistableBundleEEENS_19__map_value_compareIS3_S6_NS_4lessIS3_EELb1EEENS_9allocatorIS6_EEE25__emplace_unique_key_argsIS3_JRKNS_21piecewise_construct_tENS_5tupleIJRKS3_EEENSI_IJEEEEEENS_4pairINS_15__tree_iteratorIS6_PNS_11__tree_nodeIS6_PvEEiEEbEERKT_DpOT0_; - _ZNSt3__16__treeINS_12__value_typeIN7android8String16ENS2_2os17PersistableBundleEEENS_19__map_value_compareIS3_S6_NS_4lessIS3_EELb1EEENS_9allocatorIS6_EEE30__emplace_hint_unique_key_argsIS3_JRKNS_4pairIKS3_S5_EEEEENS_15__tree_iteratorIS6_PNS_11__tree_nodeIS6_PvEEiEENS_21__tree_const_iteratorIS6_SO_iEERKT_DpOT0_; - _ZNSt3__16__treeINS_12__value_typeIN7android8String16ENS2_2os17PersistableBundleEEENS_19__map_value_compareIS3_S6_NS_4lessIS3_EELb1EEENS_9allocatorIS6_EEE4findIS3_EENS_15__tree_iteratorIS6_PNS_11__tree_nodeIS6_PvEEiEERKT_; - _ZNSt3__16__treeINS_12__value_typeIN7android8String16ENS2_2os17PersistableBundleEEENS_19__map_value_compareIS3_S6_NS_4lessIS3_EELb1EEENS_9allocatorIS6_EEE5eraseENS_21__tree_const_iteratorIS6_PNS_11__tree_nodeIS6_PvEEiEE; - _ZNSt3__16__treeINS_12__value_typeIN7android8String16ENS2_2os17PersistableBundleEEENS_19__map_value_compareIS3_S6_NS_4lessIS3_EELb1EEENS_9allocatorIS6_EEE7destroyEPNS_11__tree_nodeIS6_PvEE; - _ZNSt3__16__treeINS_12__value_typeIN7android8String16ENS_6vectorIbNS_9allocatorIbEEEEEENS_19__map_value_compareIS3_S8_NS_4lessIS3_EELb1EEENS5_IS8_EEE12__find_equalIS3_EERPNS_16__tree_node_baseIPvEENS_21__tree_const_iteratorIS8_PNS_11__tree_nodeIS8_SH_EEiEERPNS_15__tree_end_nodeISJ_EESK_RKT_; - _ZNSt3__16__treeINS_12__value_typeIN7android8String16ENS_6vectorIbNS_9allocatorIbEEEEEENS_19__map_value_compareIS3_S8_NS_4lessIS3_EELb1EEENS5_IS8_EEE12__find_equalIS3_EERPNS_16__tree_node_baseIPvEERPNS_15__tree_end_nodeISJ_EERKT_; - _ZNSt3__16__treeINS_12__value_typeIN7android8String16ENS_6vectorIbNS_9allocatorIbEEEEEENS_19__map_value_compareIS3_S8_NS_4lessIS3_EELb1EEENS5_IS8_EEE14__assign_multiINS_21__tree_const_iteratorIS8_PNS_11__tree_nodeIS8_PvEEiEEEEvT_SM_; - _ZNSt3__16__treeINS_12__value_typeIN7android8String16ENS_6vectorIbNS_9allocatorIbEEEEEENS_19__map_value_compareIS3_S8_NS_4lessIS3_EELb1EEENS5_IS8_EEE14__erase_uniqueIS3_EEjRKT_; - _ZNSt3__16__treeINS_12__value_typeIN7android8String16ENS_6vectorIbNS_9allocatorIbEEEEEENS_19__map_value_compareIS3_S8_NS_4lessIS3_EELb1EEENS5_IS8_EEE15__emplace_multiIJRKNS_4pairIKS3_S7_EEEEENS_15__tree_iteratorIS8_PNS_11__tree_nodeIS8_PvEEiEEDpOT_; - _ZNSt3__16__treeINS_12__value_typeIN7android8String16ENS_6vectorIbNS_9allocatorIbEEEEEENS_19__map_value_compareIS3_S8_NS_4lessIS3_EELb1EEENS5_IS8_EEE25__emplace_unique_key_argsIS3_JRKNS_21piecewise_construct_tENS_5tupleIJRKS3_EEENSJ_IJEEEEEENS_4pairINS_15__tree_iteratorIS8_PNS_11__tree_nodeIS8_PvEEiEEbEERKT_DpOT0_; - _ZNSt3__16__treeINS_12__value_typeIN7android8String16ENS_6vectorIbNS_9allocatorIbEEEEEENS_19__map_value_compareIS3_S8_NS_4lessIS3_EELb1EEENS5_IS8_EEE30__emplace_hint_unique_key_argsIS3_JRKNS_4pairIKS3_S7_EEEEENS_15__tree_iteratorIS8_PNS_11__tree_nodeIS8_PvEEiEENS_21__tree_const_iteratorIS8_SP_iEERKT_DpOT0_; - _ZNSt3__16__treeINS_12__value_typeIN7android8String16ENS_6vectorIbNS_9allocatorIbEEEEEENS_19__map_value_compareIS3_S8_NS_4lessIS3_EELb1EEENS5_IS8_EEE4findIS3_EENS_15__tree_iteratorIS8_PNS_11__tree_nodeIS8_PvEEiEERKT_; - _ZNSt3__16__treeINS_12__value_typeIN7android8String16ENS_6vectorIbNS_9allocatorIbEEEEEENS_19__map_value_compareIS3_S8_NS_4lessIS3_EELb1EEENS5_IS8_EEE5eraseENS_21__tree_const_iteratorIS8_PNS_11__tree_nodeIS8_PvEEiEE; - _ZNSt3__16__treeINS_12__value_typeIN7android8String16ENS_6vectorIbNS_9allocatorIbEEEEEENS_19__map_value_compareIS3_S8_NS_4lessIS3_EELb1EEENS5_IS8_EEE7destroyEPNS_11__tree_nodeIS8_PvEE; - _ZNSt3__16__treeINS_12__value_typeIN7android8String16ENS_6vectorIdNS_9allocatorIdEEEEEENS_19__map_value_compareIS3_S8_NS_4lessIS3_EELb1EEENS5_IS8_EEE12__find_equalIS3_EERPNS_16__tree_node_baseIPvEENS_21__tree_const_iteratorIS8_PNS_11__tree_nodeIS8_SH_EEiEERPNS_15__tree_end_nodeISJ_EESK_RKT_; - _ZNSt3__16__treeINS_12__value_typeIN7android8String16ENS_6vectorIdNS_9allocatorIdEEEEEENS_19__map_value_compareIS3_S8_NS_4lessIS3_EELb1EEENS5_IS8_EEE12__find_equalIS3_EERPNS_16__tree_node_baseIPvEERPNS_15__tree_end_nodeISJ_EERKT_; - _ZNSt3__16__treeINS_12__value_typeIN7android8String16ENS_6vectorIdNS_9allocatorIdEEEEEENS_19__map_value_compareIS3_S8_NS_4lessIS3_EELb1EEENS5_IS8_EEE14__assign_multiINS_21__tree_const_iteratorIS8_PNS_11__tree_nodeIS8_PvEEiEEEEvT_SM_; - _ZNSt3__16__treeINS_12__value_typeIN7android8String16ENS_6vectorIdNS_9allocatorIdEEEEEENS_19__map_value_compareIS3_S8_NS_4lessIS3_EELb1EEENS5_IS8_EEE14__erase_uniqueIS3_EEjRKT_; - _ZNSt3__16__treeINS_12__value_typeIN7android8String16ENS_6vectorIdNS_9allocatorIdEEEEEENS_19__map_value_compareIS3_S8_NS_4lessIS3_EELb1EEENS5_IS8_EEE15__emplace_multiIJRKNS_4pairIKS3_S7_EEEEENS_15__tree_iteratorIS8_PNS_11__tree_nodeIS8_PvEEiEEDpOT_; - _ZNSt3__16__treeINS_12__value_typeIN7android8String16ENS_6vectorIdNS_9allocatorIdEEEEEENS_19__map_value_compareIS3_S8_NS_4lessIS3_EELb1EEENS5_IS8_EEE25__emplace_unique_key_argsIS3_JRKNS_21piecewise_construct_tENS_5tupleIJRKS3_EEENSJ_IJEEEEEENS_4pairINS_15__tree_iteratorIS8_PNS_11__tree_nodeIS8_PvEEiEEbEERKT_DpOT0_; - _ZNSt3__16__treeINS_12__value_typeIN7android8String16ENS_6vectorIdNS_9allocatorIdEEEEEENS_19__map_value_compareIS3_S8_NS_4lessIS3_EELb1EEENS5_IS8_EEE30__emplace_hint_unique_key_argsIS3_JRKNS_4pairIKS3_S7_EEEEENS_15__tree_iteratorIS8_PNS_11__tree_nodeIS8_PvEEiEENS_21__tree_const_iteratorIS8_SP_iEERKT_DpOT0_; - _ZNSt3__16__treeINS_12__value_typeIN7android8String16ENS_6vectorIdNS_9allocatorIdEEEEEENS_19__map_value_compareIS3_S8_NS_4lessIS3_EELb1EEENS5_IS8_EEE4findIS3_EENS_15__tree_iteratorIS8_PNS_11__tree_nodeIS8_PvEEiEERKT_; - _ZNSt3__16__treeINS_12__value_typeIN7android8String16ENS_6vectorIdNS_9allocatorIdEEEEEENS_19__map_value_compareIS3_S8_NS_4lessIS3_EELb1EEENS5_IS8_EEE5eraseENS_21__tree_const_iteratorIS8_PNS_11__tree_nodeIS8_PvEEiEE; - _ZNSt3__16__treeINS_12__value_typeIN7android8String16ENS_6vectorIdNS_9allocatorIdEEEEEENS_19__map_value_compareIS3_S8_NS_4lessIS3_EELb1EEENS5_IS8_EEE7destroyEPNS_11__tree_nodeIS8_PvEE; - _ZNSt3__16__treeINS_12__value_typeIN7android8String16ENS_6vectorIiNS_9allocatorIiEEEEEENS_19__map_value_compareIS3_S8_NS_4lessIS3_EELb1EEENS5_IS8_EEE12__find_equalIS3_EERPNS_16__tree_node_baseIPvEENS_21__tree_const_iteratorIS8_PNS_11__tree_nodeIS8_SH_EEiEERPNS_15__tree_end_nodeISJ_EESK_RKT_; - _ZNSt3__16__treeINS_12__value_typeIN7android8String16ENS_6vectorIiNS_9allocatorIiEEEEEENS_19__map_value_compareIS3_S8_NS_4lessIS3_EELb1EEENS5_IS8_EEE12__find_equalIS3_EERPNS_16__tree_node_baseIPvEERPNS_15__tree_end_nodeISJ_EERKT_; - _ZNSt3__16__treeINS_12__value_typeIN7android8String16ENS_6vectorIiNS_9allocatorIiEEEEEENS_19__map_value_compareIS3_S8_NS_4lessIS3_EELb1EEENS5_IS8_EEE14__assign_multiINS_21__tree_const_iteratorIS8_PNS_11__tree_nodeIS8_PvEEiEEEEvT_SM_; - _ZNSt3__16__treeINS_12__value_typeIN7android8String16ENS_6vectorIiNS_9allocatorIiEEEEEENS_19__map_value_compareIS3_S8_NS_4lessIS3_EELb1EEENS5_IS8_EEE14__erase_uniqueIS3_EEjRKT_; - _ZNSt3__16__treeINS_12__value_typeIN7android8String16ENS_6vectorIiNS_9allocatorIiEEEEEENS_19__map_value_compareIS3_S8_NS_4lessIS3_EELb1EEENS5_IS8_EEE15__emplace_multiIJRKNS_4pairIKS3_S7_EEEEENS_15__tree_iteratorIS8_PNS_11__tree_nodeIS8_PvEEiEEDpOT_; - _ZNSt3__16__treeINS_12__value_typeIN7android8String16ENS_6vectorIiNS_9allocatorIiEEEEEENS_19__map_value_compareIS3_S8_NS_4lessIS3_EELb1EEENS5_IS8_EEE25__emplace_unique_key_argsIS3_JRKNS_21piecewise_construct_tENS_5tupleIJRKS3_EEENSJ_IJEEEEEENS_4pairINS_15__tree_iteratorIS8_PNS_11__tree_nodeIS8_PvEEiEEbEERKT_DpOT0_; - _ZNSt3__16__treeINS_12__value_typeIN7android8String16ENS_6vectorIiNS_9allocatorIiEEEEEENS_19__map_value_compareIS3_S8_NS_4lessIS3_EELb1EEENS5_IS8_EEE30__emplace_hint_unique_key_argsIS3_JRKNS_4pairIKS3_S7_EEEEENS_15__tree_iteratorIS8_PNS_11__tree_nodeIS8_PvEEiEENS_21__tree_const_iteratorIS8_SP_iEERKT_DpOT0_; - _ZNSt3__16__treeINS_12__value_typeIN7android8String16ENS_6vectorIiNS_9allocatorIiEEEEEENS_19__map_value_compareIS3_S8_NS_4lessIS3_EELb1EEENS5_IS8_EEE4findIS3_EENS_15__tree_iteratorIS8_PNS_11__tree_nodeIS8_PvEEiEERKT_; - _ZNSt3__16__treeINS_12__value_typeIN7android8String16ENS_6vectorIiNS_9allocatorIiEEEEEENS_19__map_value_compareIS3_S8_NS_4lessIS3_EELb1EEENS5_IS8_EEE5eraseENS_21__tree_const_iteratorIS8_PNS_11__tree_nodeIS8_PvEEiEE; - _ZNSt3__16__treeINS_12__value_typeIN7android8String16ENS_6vectorIiNS_9allocatorIiEEEEEENS_19__map_value_compareIS3_S8_NS_4lessIS3_EELb1EEENS5_IS8_EEE7destroyEPNS_11__tree_nodeIS8_PvEE; - _ZNSt3__16__treeINS_12__value_typeIN7android8String16ENS_6vectorIS3_NS_9allocatorIS3_EEEEEENS_19__map_value_compareIS3_S8_NS_4lessIS3_EELb1EEENS5_IS8_EEE12__find_equalIS3_EERPNS_16__tree_node_baseIPvEENS_21__tree_const_iteratorIS8_PNS_11__tree_nodeIS8_SH_EEiEERPNS_15__tree_end_nodeISJ_EESK_RKT_; - _ZNSt3__16__treeINS_12__value_typeIN7android8String16ENS_6vectorIS3_NS_9allocatorIS3_EEEEEENS_19__map_value_compareIS3_S8_NS_4lessIS3_EELb1EEENS5_IS8_EEE12__find_equalIS3_EERPNS_16__tree_node_baseIPvEERPNS_15__tree_end_nodeISJ_EERKT_; - _ZNSt3__16__treeINS_12__value_typeIN7android8String16ENS_6vectorIS3_NS_9allocatorIS3_EEEEEENS_19__map_value_compareIS3_S8_NS_4lessIS3_EELb1EEENS5_IS8_EEE14__assign_multiINS_21__tree_const_iteratorIS8_PNS_11__tree_nodeIS8_PvEEiEEEEvT_SM_; - _ZNSt3__16__treeINS_12__value_typeIN7android8String16ENS_6vectorIS3_NS_9allocatorIS3_EEEEEENS_19__map_value_compareIS3_S8_NS_4lessIS3_EELb1EEENS5_IS8_EEE14__erase_uniqueIS3_EEjRKT_; - _ZNSt3__16__treeINS_12__value_typeIN7android8String16ENS_6vectorIS3_NS_9allocatorIS3_EEEEEENS_19__map_value_compareIS3_S8_NS_4lessIS3_EELb1EEENS5_IS8_EEE15__emplace_multiIJRKNS_4pairIKS3_S7_EEEEENS_15__tree_iteratorIS8_PNS_11__tree_nodeIS8_PvEEiEEDpOT_; - _ZNSt3__16__treeINS_12__value_typeIN7android8String16ENS_6vectorIS3_NS_9allocatorIS3_EEEEEENS_19__map_value_compareIS3_S8_NS_4lessIS3_EELb1EEENS5_IS8_EEE25__emplace_unique_key_argsIS3_JRKNS_21piecewise_construct_tENS_5tupleIJRKS3_EEENSJ_IJEEEEEENS_4pairINS_15__tree_iteratorIS8_PNS_11__tree_nodeIS8_PvEEiEEbEERKT_DpOT0_; - _ZNSt3__16__treeINS_12__value_typeIN7android8String16ENS_6vectorIS3_NS_9allocatorIS3_EEEEEENS_19__map_value_compareIS3_S8_NS_4lessIS3_EELb1EEENS5_IS8_EEE30__emplace_hint_unique_key_argsIS3_JRKNS_4pairIKS3_S7_EEEEENS_15__tree_iteratorIS8_PNS_11__tree_nodeIS8_PvEEiEENS_21__tree_const_iteratorIS8_SP_iEERKT_DpOT0_; - _ZNSt3__16__treeINS_12__value_typeIN7android8String16ENS_6vectorIS3_NS_9allocatorIS3_EEEEEENS_19__map_value_compareIS3_S8_NS_4lessIS3_EELb1EEENS5_IS8_EEE4findIS3_EENS_15__tree_iteratorIS8_PNS_11__tree_nodeIS8_PvEEiEERKT_; - _ZNSt3__16__treeINS_12__value_typeIN7android8String16ENS_6vectorIS3_NS_9allocatorIS3_EEEEEENS_19__map_value_compareIS3_S8_NS_4lessIS3_EELb1EEENS5_IS8_EEE5eraseENS_21__tree_const_iteratorIS8_PNS_11__tree_nodeIS8_PvEEiEE; - _ZNSt3__16__treeINS_12__value_typeIN7android8String16ENS_6vectorIS3_NS_9allocatorIS3_EEEEEENS_19__map_value_compareIS3_S8_NS_4lessIS3_EELb1EEENS5_IS8_EEE7destroyEPNS_11__tree_nodeIS8_PvEE; - _ZNSt3__16__treeINS_12__value_typeIN7android8String16ENS_6vectorIxNS_9allocatorIxEEEEEENS_19__map_value_compareIS3_S8_NS_4lessIS3_EELb1EEENS5_IS8_EEE12__find_equalIS3_EERPNS_16__tree_node_baseIPvEENS_21__tree_const_iteratorIS8_PNS_11__tree_nodeIS8_SH_EEiEERPNS_15__tree_end_nodeISJ_EESK_RKT_; - _ZNSt3__16__treeINS_12__value_typeIN7android8String16ENS_6vectorIxNS_9allocatorIxEEEEEENS_19__map_value_compareIS3_S8_NS_4lessIS3_EELb1EEENS5_IS8_EEE12__find_equalIS3_EERPNS_16__tree_node_baseIPvEERPNS_15__tree_end_nodeISJ_EERKT_; - _ZNSt3__16__treeINS_12__value_typeIN7android8String16ENS_6vectorIxNS_9allocatorIxEEEEEENS_19__map_value_compareIS3_S8_NS_4lessIS3_EELb1EEENS5_IS8_EEE14__assign_multiINS_21__tree_const_iteratorIS8_PNS_11__tree_nodeIS8_PvEEiEEEEvT_SM_; - _ZNSt3__16__treeINS_12__value_typeIN7android8String16ENS_6vectorIxNS_9allocatorIxEEEEEENS_19__map_value_compareIS3_S8_NS_4lessIS3_EELb1EEENS5_IS8_EEE14__erase_uniqueIS3_EEjRKT_; - _ZNSt3__16__treeINS_12__value_typeIN7android8String16ENS_6vectorIxNS_9allocatorIxEEEEEENS_19__map_value_compareIS3_S8_NS_4lessIS3_EELb1EEENS5_IS8_EEE15__emplace_multiIJRKNS_4pairIKS3_S7_EEEEENS_15__tree_iteratorIS8_PNS_11__tree_nodeIS8_PvEEiEEDpOT_; - _ZNSt3__16__treeINS_12__value_typeIN7android8String16ENS_6vectorIxNS_9allocatorIxEEEEEENS_19__map_value_compareIS3_S8_NS_4lessIS3_EELb1EEENS5_IS8_EEE25__emplace_unique_key_argsIS3_JRKNS_21piecewise_construct_tENS_5tupleIJRKS3_EEENSJ_IJEEEEEENS_4pairINS_15__tree_iteratorIS8_PNS_11__tree_nodeIS8_PvEEiEEbEERKT_DpOT0_; - _ZNSt3__16__treeINS_12__value_typeIN7android8String16ENS_6vectorIxNS_9allocatorIxEEEEEENS_19__map_value_compareIS3_S8_NS_4lessIS3_EELb1EEENS5_IS8_EEE30__emplace_hint_unique_key_argsIS3_JRKNS_4pairIKS3_S7_EEEEENS_15__tree_iteratorIS8_PNS_11__tree_nodeIS8_PvEEiEENS_21__tree_const_iteratorIS8_SP_iEERKT_DpOT0_; - _ZNSt3__16__treeINS_12__value_typeIN7android8String16ENS_6vectorIxNS_9allocatorIxEEEEEENS_19__map_value_compareIS3_S8_NS_4lessIS3_EELb1EEENS5_IS8_EEE4findIS3_EENS_15__tree_iteratorIS8_PNS_11__tree_nodeIS8_PvEEiEERKT_; - _ZNSt3__16__treeINS_12__value_typeIN7android8String16ENS_6vectorIxNS_9allocatorIxEEEEEENS_19__map_value_compareIS3_S8_NS_4lessIS3_EELb1EEENS5_IS8_EEE5eraseENS_21__tree_const_iteratorIS8_PNS_11__tree_nodeIS8_PvEEiEE; - _ZNSt3__16__treeINS_12__value_typeIN7android8String16ENS_6vectorIxNS_9allocatorIxEEEEEENS_19__map_value_compareIS3_S8_NS_4lessIS3_EELb1EEENS5_IS8_EEE7destroyEPNS_11__tree_nodeIS8_PvEE; - _ZNSt3__16__treeINS_12__value_typeIN7android8String16ES3_EENS_19__map_value_compareIS3_S4_NS_4lessIS3_EELb1EEENS_9allocatorIS4_EEE12__find_equalIS3_EERPNS_16__tree_node_baseIPvEENS_21__tree_const_iteratorIS4_PNS_11__tree_nodeIS4_SE_EEiEERPNS_15__tree_end_nodeISG_EESH_RKT_; - _ZNSt3__16__treeINS_12__value_typeIN7android8String16ES3_EENS_19__map_value_compareIS3_S4_NS_4lessIS3_EELb1EEENS_9allocatorIS4_EEE12__find_equalIS3_EERPNS_16__tree_node_baseIPvEERPNS_15__tree_end_nodeISG_EERKT_; - _ZNSt3__16__treeINS_12__value_typeIN7android8String16ES3_EENS_19__map_value_compareIS3_S4_NS_4lessIS3_EELb1EEENS_9allocatorIS4_EEE14__assign_multiINS_21__tree_const_iteratorIS4_PNS_11__tree_nodeIS4_PvEEiEEEEvT_SJ_; - _ZNSt3__16__treeINS_12__value_typeIN7android8String16ES3_EENS_19__map_value_compareIS3_S4_NS_4lessIS3_EELb1EEENS_9allocatorIS4_EEE14__erase_uniqueIS3_EEjRKT_; - _ZNSt3__16__treeINS_12__value_typeIN7android8String16ES3_EENS_19__map_value_compareIS3_S4_NS_4lessIS3_EELb1EEENS_9allocatorIS4_EEE15__emplace_multiIJRKNS_4pairIKS3_S3_EEEEENS_15__tree_iteratorIS4_PNS_11__tree_nodeIS4_PvEEiEEDpOT_; - _ZNSt3__16__treeINS_12__value_typeIN7android8String16ES3_EENS_19__map_value_compareIS3_S4_NS_4lessIS3_EELb1EEENS_9allocatorIS4_EEE25__emplace_unique_key_argsIS3_JRKNS_21piecewise_construct_tENS_5tupleIJRKS3_EEENSG_IJEEEEEENS_4pairINS_15__tree_iteratorIS4_PNS_11__tree_nodeIS4_PvEEiEEbEERKT_DpOT0_; - _ZNSt3__16__treeINS_12__value_typeIN7android8String16ES3_EENS_19__map_value_compareIS3_S4_NS_4lessIS3_EELb1EEENS_9allocatorIS4_EEE30__emplace_hint_unique_key_argsIS3_JRKNS_4pairIKS3_S3_EEEEENS_15__tree_iteratorIS4_PNS_11__tree_nodeIS4_PvEEiEENS_21__tree_const_iteratorIS4_SM_iEERKT_DpOT0_; - _ZNSt3__16__treeINS_12__value_typeIN7android8String16ES3_EENS_19__map_value_compareIS3_S4_NS_4lessIS3_EELb1EEENS_9allocatorIS4_EEE4findIS3_EENS_15__tree_iteratorIS4_PNS_11__tree_nodeIS4_PvEEiEERKT_; - _ZNSt3__16__treeINS_12__value_typeIN7android8String16ES3_EENS_19__map_value_compareIS3_S4_NS_4lessIS3_EELb1EEENS_9allocatorIS4_EEE5eraseENS_21__tree_const_iteratorIS4_PNS_11__tree_nodeIS4_PvEEiEE; - _ZNSt3__16__treeINS_12__value_typeIN7android8String16ES3_EENS_19__map_value_compareIS3_S4_NS_4lessIS3_EELb1EEENS_9allocatorIS4_EEE7destroyEPNS_11__tree_nodeIS4_PvEE; - _ZNSt3__16__treeINS_12__value_typeIN7android8String16ExEENS_19__map_value_compareIS3_S4_NS_4lessIS3_EELb1EEENS_9allocatorIS4_EEE12__find_equalIS3_EERPNS_16__tree_node_baseIPvEENS_21__tree_const_iteratorIS4_PNS_11__tree_nodeIS4_SE_EEiEERPNS_15__tree_end_nodeISG_EESH_RKT_; - _ZNSt3__16__treeINS_12__value_typeIN7android8String16ExEENS_19__map_value_compareIS3_S4_NS_4lessIS3_EELb1EEENS_9allocatorIS4_EEE12__find_equalIS3_EERPNS_16__tree_node_baseIPvEERPNS_15__tree_end_nodeISG_EERKT_; - _ZNSt3__16__treeINS_12__value_typeIN7android8String16ExEENS_19__map_value_compareIS3_S4_NS_4lessIS3_EELb1EEENS_9allocatorIS4_EEE14__assign_multiINS_21__tree_const_iteratorIS4_PNS_11__tree_nodeIS4_PvEEiEEEEvT_SJ_; - _ZNSt3__16__treeINS_12__value_typeIN7android8String16ExEENS_19__map_value_compareIS3_S4_NS_4lessIS3_EELb1EEENS_9allocatorIS4_EEE15__emplace_multiIJRKNS_4pairIKS3_xEEEEENS_15__tree_iteratorIS4_PNS_11__tree_nodeIS4_PvEEiEEDpOT_; - _ZNSt3__16__treeINS_12__value_typeIN7android8String16ExEENS_19__map_value_compareIS3_S4_NS_4lessIS3_EELb1EEENS_9allocatorIS4_EEE25__emplace_unique_key_argsIS3_JRKNS_21piecewise_construct_tENS_5tupleIJRKS3_EEENSG_IJEEEEEENS_4pairINS_15__tree_iteratorIS4_PNS_11__tree_nodeIS4_PvEEiEEbEERKT_DpOT0_; - _ZNSt3__16__treeINS_12__value_typeIN7android8String16ExEENS_19__map_value_compareIS3_S4_NS_4lessIS3_EELb1EEENS_9allocatorIS4_EEE30__emplace_hint_unique_key_argsIS3_JRKNS_4pairIKS3_xEEEEENS_15__tree_iteratorIS4_PNS_11__tree_nodeIS4_PvEEiEENS_21__tree_const_iteratorIS4_SM_iEERKT_DpOT0_; - _ZNSt3__16__treeINS_12__value_typeIN7android8String16ExEENS_19__map_value_compareIS3_S4_NS_4lessIS3_EELb1EEENS_9allocatorIS4_EEE4findIS3_EENS_15__tree_iteratorIS4_PNS_11__tree_nodeIS4_PvEEiEERKT_; - _ZNSt3__16__treeINS_12__value_typeIN7android8String16ExEENS_19__map_value_compareIS3_S4_NS_4lessIS3_EELb1EEENS_9allocatorIS4_EEE7destroyEPNS_11__tree_nodeIS4_PvEE; - _ZNSt3__16__treeINS_12__value_typeINS_11__thread_idENS_6threadEEENS_19__map_value_compareIS2_S4_NS_4lessIS2_EELb1EEENS_9allocatorIS4_EEE7destroyEPNS_11__tree_nodeIS4_PvEE; - _ZNSt3__16__treeINS_12__value_typeINS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEEN7android6binder8internal25ClientCounterCallbackImpl7ServiceEEENS_19__map_value_compareIS7_SD_NS_4lessIS7_EELb1EEENS5_ISD_EEE12__find_equalIS7_EERPNS_16__tree_node_baseIPvEERPNS_15__tree_end_nodeISO_EERKT_; - _ZNSt3__16__treeINS_12__value_typeINS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEEN7android6binder8internal25ClientCounterCallbackImpl7ServiceEEENS_19__map_value_compareIS7_SD_NS_4lessIS7_EELb1EEENS5_ISD_EEE25__emplace_unique_key_argsIS7_JRKNS_21piecewise_construct_tENS_5tupleIJRKS7_EEENSO_IJEEEEEENS_4pairINS_15__tree_iteratorISD_PNS_11__tree_nodeISD_PvEEiEEbEERKT_DpOT0_; - _ZNSt3__16__treeINS_12__value_typeINS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEEN7android6binder8internal25ClientCounterCallbackImpl7ServiceEEENS_19__map_value_compareIS7_SD_NS_4lessIS7_EELb1EEENS5_ISD_EEE7destroyEPNS_11__tree_nodeISD_PvEE; - _ZNSt3__16vectorIaNS_9allocatorIaEEE6insertIPKaEENS_9enable_ifIXaasr21__is_forward_iteratorIT_EE5valuesr16is_constructibleIaNS_15iterator_traitsIS8_E9referenceEEE5valueENS_11__wrap_iterIPaEEE4typeENSC_IS6_EES8_S8_; - _ZNSt3__16vectorIbNS_9allocatorIbEEE18__construct_at_endINS_14__bit_iteratorIS3_Lb0ELj0EEEEENS_9enable_ifIXsr21__is_forward_iteratorIT_EE5valueEvE4typeES8_S8_; - _ZNSt3__16vectorIbNS_9allocatorIbEEE18__construct_at_endINS_14__bit_iteratorIS3_Lb1ELj0EEEEENS_9enable_ifIXsr21__is_forward_iteratorIT_EE5valueEvE4typeES8_S8_; - _ZNSt3__16vectorIbNS_9allocatorIbEEE7reserveEj; - _ZNSt3__16vectorIbNS_9allocatorIbEEE9push_backERKb; - _ZNSt3__16vectorIbNS_9allocatorIbEEEaSERKS3_; - _ZNSt3__16vectorIdNS_9allocatorIdEEE6assignIPdEENS_9enable_ifIXaasr21__is_forward_iteratorIT_EE5valuesr16is_constructibleIdNS_15iterator_traitsIS7_E9referenceEEE5valueEvE4typeES7_S7_; - _ZNSt3__16vectorIdNS_9allocatorIdEEE6insertIPKdEENS_9enable_ifIXaasr21__is_forward_iteratorIT_EE5valuesr16is_constructibleIdNS_15iterator_traitsIS8_E9referenceEEE5valueENS_11__wrap_iterIPdEEE4typeENSC_IS6_EES8_S8_; - _ZNSt3__16vectorIdNS_9allocatorIdEEEC2ERKS3_; - _ZNSt3__16vectorIDsNS_9allocatorIDsEEE24__emplace_back_slow_pathIJDsEEEvDpOT_; - _ZNSt3__16vectorIDsNS_9allocatorIDsEEE7reserveEj; - _ZNSt3__16vectorIfNS_9allocatorIfEEE6insertIPKfEENS_9enable_ifIXaasr21__is_forward_iteratorIT_EE5valuesr16is_constructibleIfNS_15iterator_traitsIS8_E9referenceEEE5valueENS_11__wrap_iterIPfEEE4typeENSC_IS6_EES8_S8_; - _ZNSt3__16vectorIhNS_9allocatorIhEEE6insertIPKhEENS_9enable_ifIXaasr21__is_forward_iteratorIT_EE5valuesr16is_constructibleIhNS_15iterator_traitsIS8_E9referenceEEE5valueENS_11__wrap_iterIPhEEE4typeENSC_IS6_EES8_S8_; - _ZNSt3__16vectorIiNS_9allocatorIiEEE6assignIPiEENS_9enable_ifIXaasr21__is_forward_iteratorIT_EE5valuesr16is_constructibleIiNS_15iterator_traitsIS7_E9referenceEEE5valueEvE4typeES7_S7_; - _ZNSt3__16vectorIiNS_9allocatorIiEEE6insertIPKiEENS_9enable_ifIXaasr21__is_forward_iteratorIT_EE5valuesr16is_constructibleIiNS_15iterator_traitsIS8_E9referenceEEE5valueENS_11__wrap_iterIPiEEE4typeENSC_IS6_EES8_S8_; - _ZNSt3__16vectorIN7android2os16ServiceDebugInfoENS_9allocatorIS3_EEE8__appendEj; - _ZNSt3__16vectorIN7android2spINS1_10RpcSession13RpcConnectionEEENS_9allocatorIS5_EEE21__push_back_slow_pathIRKS5_EEvOT_; - _ZNSt3__16vectorIN7android2spINS1_10RpcSessionEEENS_9allocatorIS4_EEE21__push_back_slow_pathIRKS4_EEvOT_; - _ZNSt3__16vectorIN7android2spINS1_7IBinderEEENS_9allocatorIS4_EEE21__push_back_slow_pathIRKS4_EEvOT_; - _ZNSt3__16vectorIN7android2spINS1_7IBinderEEENS_9allocatorIS4_EEE8__appendEj; - _ZNSt3__16vectorIN7android4base14unique_fd_implINS2_13DefaultCloserEEENS_9allocatorIS5_EEE8__appendEj; - _ZNSt3__16vectorIN7android8RpcState10BinderNode9AsyncTodoENS_9allocatorIS4_EEE21__push_back_slow_pathIS4_EEvOT_; - _ZNSt3__16vectorIN7android8String16ENS_9allocatorIS2_EEE6assignIPS2_EENS_9enable_ifIXaasr21__is_forward_iteratorIT_EE5valuesr16is_constructibleIS2_NS_15iterator_traitsIS9_E9referenceEEE5valueEvE4typeES9_S9_; - _ZNSt3__16vectorIN7android8String16ENS_9allocatorIS2_EEE8__appendEj; - _ZNSt3__16vectorINS_10unique_ptrIN7android8String16ENS_14default_deleteIS3_EEEENS_9allocatorIS6_EEE8__appendEj; - _ZNSt3__16vectorINS_10unique_ptrINS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEENS_14default_deleteIS7_EEEENS5_ISA_EEE8__appendEj; - _ZNSt3__16vectorINS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEENS4_IS6_EEE8__appendEj; - _ZNSt3__16vectorINS_8optionalIN7android8String16EEENS_9allocatorIS4_EEE8__appendEj; - _ZNSt3__16vectorINS_8optionalINS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEEEENS5_IS8_EEE8__appendEj; - _ZNSt3__16vectorIxNS_9allocatorIxEEE6assignIPxEENS_9enable_ifIXaasr21__is_forward_iteratorIT_EE5valuesr16is_constructibleIxNS_15iterator_traitsIS7_E9referenceEEE5valueEvE4typeES7_S7_; - _ZNSt3__16vectorIxNS_9allocatorIxEEE6insertIPKxEENS_9enable_ifIXaasr21__is_forward_iteratorIT_EE5valuesr16is_constructibleIxNS_15iterator_traitsIS8_E9referenceEEE5valueENS_11__wrap_iterIPxEEE4typeENSC_IS6_EES8_S8_; - _ZNSt3__16vectorIxNS_9allocatorIxEEEC2ERKS3_; - _ZNSt3__16vectorIyNS_9allocatorIyEEE6insertIPKyEENS_9enable_ifIXaasr21__is_forward_iteratorIT_EE5valuesr16is_constructibleIyNS_15iterator_traitsIS8_E9referenceEEE5valueENS_11__wrap_iterIPyEEE4typeENSC_IS6_EES8_S8_; - _ZNSt3__19__sift_upIRNS_4lessIN7android8RpcState10BinderNode9AsyncTodoEEENS_11__wrap_iterIPS5_EEEEvT0_SB_T_NS_15iterator_traitsISB_E15difference_typeE; - _ZTCN7android10AllocationE0_NS_10IInterfaceE; - _ZTCN7android10AllocationE0_NS_10MemoryBaseE; - _ZTCN7android10AllocationE0_NS_11BnInterfaceINS_7IMemoryEEE; - _ZTCN7android10AllocationE0_NS_7IMemoryE; - _ZTCN7android10AllocationE0_NS_8BnMemoryE; - _ZTCN7android10AllocationE4_NS_7BBinderE; - _ZTCN7android10AllocationE4_NS_7IBinderE; - _ZTCN7android10MemoryBaseE0_NS_10IInterfaceE; - _ZTCN7android10MemoryBaseE0_NS_11BnInterfaceINS_7IMemoryEEE; - _ZTCN7android10MemoryBaseE0_NS_7IMemoryE; - _ZTCN7android10MemoryBaseE0_NS_8BnMemoryE; - _ZTCN7android10MemoryBaseE4_NS_7BBinderE; - _ZTCN7android10MemoryBaseE4_NS_7IBinderE; - _ZTCN7android10PoolThreadE0_NS_6ThreadE; - _ZTCN7android11IMemoryHeapE0_NS_10IInterfaceE; - _ZTCN7android12BnMemoryHeapE0_NS_10IInterfaceE; - _ZTCN7android12BnMemoryHeapE0_NS_11BnInterfaceINS_11IMemoryHeapEEE; - _ZTCN7android12BnMemoryHeapE0_NS_11IMemoryHeapE; - _ZTCN7android12BnMemoryHeapE4_NS_7BBinderE; - _ZTCN7android12BnMemoryHeapE4_NS_7IBinderE; - _ZTCN7android12BpMemoryHeapE0_NS_10IInterfaceE; - _ZTCN7android12BpMemoryHeapE0_NS_11BpInterfaceINS_11IMemoryHeapEEE; - _ZTCN7android12BpMemoryHeapE0_NS_11IMemoryHeapE; - _ZTCN7android12BpMemoryHeapE4_NS_9BpRefBaseE; - _ZTCN7android14IShellCallbackE0_NS_10IInterfaceE; - _ZTCN7android14MemoryHeapBaseE32_NS_10IInterfaceE; - _ZTCN7android14MemoryHeapBaseE32_NS_11BnInterfaceINS_11IMemoryHeapEEE; - _ZTCN7android14MemoryHeapBaseE32_NS_11IMemoryHeapE; - _ZTCN7android14MemoryHeapBaseE32_NS_12BnMemoryHeapE; - _ZTCN7android14MemoryHeapBaseE36_NS_7BBinderE; - _ZTCN7android14MemoryHeapBaseE36_NS_7IBinderE; - _ZTCN7android15BnShellCallbackE0_NS_10IInterfaceE; - _ZTCN7android15BnShellCallbackE0_NS_11BnInterfaceINS_14IShellCallbackEEE; - _ZTCN7android15BnShellCallbackE0_NS_14IShellCallbackE; - _ZTCN7android15BnShellCallbackE4_NS_7BBinderE; - _ZTCN7android15BnShellCallbackE4_NS_7IBinderE; - _ZTCN7android15BpShellCallbackE0_NS_10IInterfaceE; - _ZTCN7android15BpShellCallbackE0_NS_11BpInterfaceINS_14IShellCallbackEEE; - _ZTCN7android15BpShellCallbackE0_NS_14IShellCallbackE; - _ZTCN7android15BpShellCallbackE4_NS_9BpRefBaseE; - _ZTCN7android15IResultReceiverE0_NS_10IInterfaceE; - _ZTCN7android15IServiceManagerE0_NS_10IInterfaceE; - _ZTCN7android16BnResultReceiverE0_NS_10IInterfaceE; - _ZTCN7android16BnResultReceiverE0_NS_11BnInterfaceINS_15IResultReceiverEEE; - _ZTCN7android16BnResultReceiverE0_NS_15IResultReceiverE; - _ZTCN7android16BnResultReceiverE4_NS_7BBinderE; - _ZTCN7android16BnResultReceiverE4_NS_7IBinderE; - _ZTCN7android16BpResultReceiverE0_NS_10IInterfaceE; - _ZTCN7android16BpResultReceiverE0_NS_11BpInterfaceINS_15IResultReceiverEEE; - _ZTCN7android16BpResultReceiverE0_NS_15IResultReceiverE; - _ZTCN7android16BpResultReceiverE4_NS_9BpRefBaseE; - _ZTCN7android18ServiceManagerShimE0_NS_10IInterfaceE; - _ZTCN7android18ServiceManagerShimE0_NS_15IServiceManagerE; - _ZTCN7android2os15IClientCallbackE0_NS_10IInterfaceE; - _ZTCN7android2os15IServiceManagerE0_NS_10IInterfaceE; - _ZTCN7android2os16BnClientCallbackE0_NS0_15IClientCallbackE; - _ZTCN7android2os16BnClientCallbackE0_NS_10IInterfaceE; - _ZTCN7android2os16BnClientCallbackE0_NS_11BnInterfaceINS0_15IClientCallbackEEE; - _ZTCN7android2os16BnClientCallbackE4_NS_7BBinderE; - _ZTCN7android2os16BnClientCallbackE4_NS_7IBinderE; - _ZTCN7android2os16BnServiceManagerE0_NS0_15IServiceManagerE; - _ZTCN7android2os16BnServiceManagerE0_NS_10IInterfaceE; - _ZTCN7android2os16BnServiceManagerE0_NS_11BnInterfaceINS0_15IServiceManagerEEE; - _ZTCN7android2os16BnServiceManagerE4_NS_7BBinderE; - _ZTCN7android2os16BnServiceManagerE4_NS_7IBinderE; - _ZTCN7android2os16BpClientCallbackE0_NS0_15IClientCallbackE; - _ZTCN7android2os16BpClientCallbackE0_NS_10IInterfaceE; - _ZTCN7android2os16BpClientCallbackE0_NS_11BpInterfaceINS0_15IClientCallbackEEE; - _ZTCN7android2os16BpClientCallbackE4_NS_9BpRefBaseE; - _ZTCN7android2os16BpServiceManagerE0_NS0_15IServiceManagerE; - _ZTCN7android2os16BpServiceManagerE0_NS_10IInterfaceE; - _ZTCN7android2os16BpServiceManagerE0_NS_11BpInterfaceINS0_15IServiceManagerEEE; - _ZTCN7android2os16BpServiceManagerE4_NS_9BpRefBaseE; - _ZTCN7android2os16IServiceCallbackE0_NS_10IInterfaceE; - _ZTCN7android2os17BnServiceCallbackE0_NS0_16IServiceCallbackE; - _ZTCN7android2os17BnServiceCallbackE0_NS_10IInterfaceE; - _ZTCN7android2os17BnServiceCallbackE0_NS_11BnInterfaceINS0_16IServiceCallbackEEE; - _ZTCN7android2os17BnServiceCallbackE4_NS_7BBinderE; - _ZTCN7android2os17BnServiceCallbackE4_NS_7IBinderE; - _ZTCN7android2os17BpServiceCallbackE0_NS0_16IServiceCallbackE; - _ZTCN7android2os17BpServiceCallbackE0_NS_10IInterfaceE; - _ZTCN7android2os17BpServiceCallbackE0_NS_11BpInterfaceINS0_16IServiceCallbackEEE; - _ZTCN7android2os17BpServiceCallbackE4_NS_9BpRefBaseE; - _ZTCN7android6binder8internal25ClientCounterCallbackImplE0_NS_10IInterfaceE; - _ZTCN7android6binder8internal25ClientCounterCallbackImplE0_NS_11BnInterfaceINS_2os15IClientCallbackEEE; - _ZTCN7android6binder8internal25ClientCounterCallbackImplE0_NS_2os15IClientCallbackE; - _ZTCN7android6binder8internal25ClientCounterCallbackImplE0_NS_2os16BnClientCallbackE; - _ZTCN7android6binder8internal25ClientCounterCallbackImplE4_NS_7BBinderE; - _ZTCN7android6binder8internal25ClientCounterCallbackImplE4_NS_7IBinderE; - _ZTCN7android7BBinderE0_NS_7IBinderE; - _ZTCN7android7content2pm21IPackageManagerNativeE0_NS_10IInterfaceE; - _ZTCN7android7content2pm22BnPackageManagerNativeE0_NS_10IInterfaceE; - _ZTCN7android7content2pm22BnPackageManagerNativeE0_NS_11BnInterfaceINS1_21IPackageManagerNativeEEE; - _ZTCN7android7content2pm22BnPackageManagerNativeE0_NS1_21IPackageManagerNativeE; - _ZTCN7android7content2pm22BnPackageManagerNativeE4_NS_7BBinderE; - _ZTCN7android7content2pm22BnPackageManagerNativeE4_NS_7IBinderE; - _ZTCN7android7content2pm22BpPackageManagerNativeE0_NS_10IInterfaceE; - _ZTCN7android7content2pm22BpPackageManagerNativeE0_NS_11BpInterfaceINS1_21IPackageManagerNativeEEE; - _ZTCN7android7content2pm22BpPackageManagerNativeE0_NS1_21IPackageManagerNativeE; - _ZTCN7android7content2pm22BpPackageManagerNativeE4_NS_9BpRefBaseE; - _ZTCN7android7content2pm22IPackageChangeObserverE0_NS_10IInterfaceE; - _ZTCN7android7content2pm23BnPackageChangeObserverE0_NS_10IInterfaceE; - _ZTCN7android7content2pm23BnPackageChangeObserverE0_NS_11BnInterfaceINS1_22IPackageChangeObserverEEE; - _ZTCN7android7content2pm23BnPackageChangeObserverE0_NS1_22IPackageChangeObserverE; - _ZTCN7android7content2pm23BnPackageChangeObserverE4_NS_7BBinderE; - _ZTCN7android7content2pm23BnPackageChangeObserverE4_NS_7IBinderE; - _ZTCN7android7content2pm23BpPackageChangeObserverE0_NS_10IInterfaceE; - _ZTCN7android7content2pm23BpPackageChangeObserverE0_NS_11BpInterfaceINS1_22IPackageChangeObserverEEE; - _ZTCN7android7content2pm23BpPackageChangeObserverE0_NS1_22IPackageChangeObserverE; - _ZTCN7android7content2pm23BpPackageChangeObserverE4_NS_9BpRefBaseE; - _ZTCN7android7IMemoryE0_NS_10IInterfaceE; - _ZTCN7android8BnMemoryE0_NS_10IInterfaceE; - _ZTCN7android8BnMemoryE0_NS_11BnInterfaceINS_7IMemoryEEE; - _ZTCN7android8BnMemoryE0_NS_7IMemoryE; - _ZTCN7android8BnMemoryE4_NS_7BBinderE; - _ZTCN7android8BnMemoryE4_NS_7IBinderE; - _ZTCN7android8BpBinderE0_NS_7IBinderE; - _ZTCN7android8BpMemoryE0_NS_10IInterfaceE; - _ZTCN7android8BpMemoryE0_NS_11BpInterfaceINS_7IMemoryEEE; - _ZTCN7android8BpMemoryE0_NS_7IMemoryE; - _ZTCN7android8BpMemoryE4_NS_9BpRefBaseE; - _ZTCN7android9HeapCacheE0_NS_7IBinder14DeathRecipientE; - _ZTCNSt3__118basic_stringstreamIcNS_11char_traitsIcEENS_9allocatorIcEEEE0_NS_13basic_istreamIcS2_EE; - _ZTCNSt3__118basic_stringstreamIcNS_11char_traitsIcEENS_9allocatorIcEEEE0_NS_14basic_iostreamIcS2_EE; - _ZTCNSt3__118basic_stringstreamIcNS_11char_traitsIcEENS_9allocatorIcEEEE8_NS_13basic_ostreamIcS2_EE; - _ZThn4_N7android10AllocationD0Ev; - _ZThn4_N7android10AllocationD1Ev; - _ZThn4_N7android10MemoryBaseD0Ev; - _ZThn4_N7android10MemoryBaseD1Ev; - _ZThn4_N7android12BnMemoryHeap10onTransactEjRKNS_6ParcelEPS1_j; - _ZThn4_N7android12BnMemoryHeapD0Ev; - _ZThn4_N7android12BnMemoryHeapD1Ev; - _ZThn4_N7android12BpMemoryHeapD0Ev; - _ZThn4_N7android12BpMemoryHeapD1Ev; - _ZThn4_N7android15BnShellCallback10onTransactEjRKNS_6ParcelEPS1_j; - _ZThn4_N7android16BnResultReceiver10onTransactEjRKNS_6ParcelEPS1_j; - _ZThn4_N7android2os16BnClientCallback10onTransactEjRKNS_6ParcelEPS2_j; - _ZThn4_N7android2os16BnServiceManager10onTransactEjRKNS_6ParcelEPS2_j; - _ZThn4_N7android2os17BnServiceCallback10onTransactEjRKNS_6ParcelEPS2_j; - _ZThn4_N7android7content2pm22BnPackageManagerNative10onTransactEjRKNS_6ParcelEPS3_j; - _ZThn4_N7android7content2pm23BnPackageChangeObserver10onTransactEjRKNS_6ParcelEPS3_j; - _ZThn4_N7android8BnMemory10onTransactEjRKNS_6ParcelEPS1_j; - _ZThn4_N7android8BnMemoryD0Ev; - _ZThn4_N7android8BnMemoryD1Ev; - _ZThn4_N7android8BpMemoryD0Ev; - _ZThn4_N7android8BpMemoryD1Ev; - _ZTTN7android10AllocationE; - _ZTTN7android10IInterfaceE; - _ZTTN7android10MemoryBaseE; - _ZTTN7android10PoolThreadE; - _ZTTN7android10RpcSessionE; - _ZTTN7android11IMemoryHeapE; - _ZTTN7android12BnMemoryHeapE; - _ZTTN7android12BpMemoryHeapE; - _ZTTN7android12ProcessStateE; - _ZTTN7android14IShellCallbackE; - _ZTTN7android14MemoryHeapBaseE; - _ZTTN7android15BnShellCallbackE; - _ZTTN7android15BpShellCallbackE; - _ZTTN7android15IResultReceiverE; - _ZTTN7android15IServiceManagerE; - _ZTTN7android16BnResultReceiverE; - _ZTTN7android16BpResultReceiverE; - _ZTTN7android18ServiceManagerShimE; - _ZTTN7android2os15IClientCallbackE; - _ZTTN7android2os15IServiceManagerE; - _ZTTN7android2os16BnClientCallbackE; - _ZTTN7android2os16BnServiceManagerE; - _ZTTN7android2os16BpClientCallbackE; - _ZTTN7android2os16BpServiceManagerE; - _ZTTN7android2os16IServiceCallbackE; - _ZTTN7android2os17BnServiceCallbackE; - _ZTTN7android2os17BpServiceCallbackE; - _ZTTN7android6binder8internal25ClientCounterCallbackImplE; - _ZTTN7android7BBinderE; - _ZTTN7android7content2pm21IPackageManagerNativeE; - _ZTTN7android7content2pm22BnPackageManagerNativeE; - _ZTTN7android7content2pm22BpPackageManagerNativeE; - _ZTTN7android7content2pm22IPackageChangeObserverE; - _ZTTN7android7content2pm23BnPackageChangeObserverE; - _ZTTN7android7content2pm23BpPackageChangeObserverE; - _ZTTN7android7IBinderE; - _ZTTN7android7IMemoryE; - _ZTTN7android8BnMemoryE; - _ZTTN7android8BpBinderE; - _ZTTN7android8BpMemoryE; - _ZTTN7android9BpRefBaseE; - _ZTTN7android9HeapCacheE; - _ZTTN7android9RpcServerE; - _ZTTNSt3__118basic_stringstreamIcNS_11char_traitsIcEENS_9allocatorIcEEEE; - _ZTv0_n12_N7android10AllocationD0Ev; - _ZTv0_n12_N7android10AllocationD1Ev; - _ZTv0_n12_N7android10IInterfaceD0Ev; - _ZTv0_n12_N7android10IInterfaceD1Ev; - _ZTv0_n12_N7android10MemoryBaseD0Ev; - _ZTv0_n12_N7android10MemoryBaseD1Ev; - _ZTv0_n12_N7android10RpcSessionD0Ev; - _ZTv0_n12_N7android10RpcSessionD1Ev; - _ZTv0_n12_N7android11IMemoryHeapD0Ev; - _ZTv0_n12_N7android11IMemoryHeapD1Ev; - _ZTv0_n12_N7android12BnMemoryHeapD0Ev; - _ZTv0_n12_N7android12BnMemoryHeapD1Ev; - _ZTv0_n12_N7android12BpMemoryHeapD0Ev; - _ZTv0_n12_N7android12BpMemoryHeapD1Ev; - _ZTv0_n12_N7android12ProcessStateD0Ev; - _ZTv0_n12_N7android12ProcessStateD1Ev; - _ZTv0_n12_N7android14IShellCallbackD0Ev; - _ZTv0_n12_N7android14IShellCallbackD1Ev; - _ZTv0_n12_N7android14MemoryHeapBaseD0Ev; - _ZTv0_n12_N7android14MemoryHeapBaseD1Ev; - _ZTv0_n12_N7android15IResultReceiverD0Ev; - _ZTv0_n12_N7android15IResultReceiverD1Ev; - _ZTv0_n12_N7android15IServiceManagerD0Ev; - _ZTv0_n12_N7android15IServiceManagerD1Ev; - _ZTv0_n12_N7android2os15IClientCallbackD0Ev; - _ZTv0_n12_N7android2os15IClientCallbackD1Ev; - _ZTv0_n12_N7android2os15IServiceManagerD0Ev; - _ZTv0_n12_N7android2os15IServiceManagerD1Ev; - _ZTv0_n12_N7android2os16IServiceCallbackD0Ev; - _ZTv0_n12_N7android2os16IServiceCallbackD1Ev; - _ZTv0_n12_N7android7BBinderD0Ev; - _ZTv0_n12_N7android7BBinderD1Ev; - _ZTv0_n12_N7android7content2pm21IPackageManagerNativeD0Ev; - _ZTv0_n12_N7android7content2pm21IPackageManagerNativeD1Ev; - _ZTv0_n12_N7android7content2pm22IPackageChangeObserverD0Ev; - _ZTv0_n12_N7android7content2pm22IPackageChangeObserverD1Ev; - _ZTv0_n12_N7android7IBinderD0Ev; - _ZTv0_n12_N7android7IBinderD1Ev; - _ZTv0_n12_N7android7IMemoryD0Ev; - _ZTv0_n12_N7android7IMemoryD1Ev; - _ZTv0_n12_N7android8BnMemoryD0Ev; - _ZTv0_n12_N7android8BnMemoryD1Ev; - _ZTv0_n12_N7android8BpBinderD0Ev; - _ZTv0_n12_N7android8BpBinderD1Ev; - _ZTv0_n12_N7android8BpMemoryD0Ev; - _ZTv0_n12_N7android8BpMemoryD1Ev; - _ZTv0_n12_N7android9BpRefBaseD0Ev; - _ZTv0_n12_N7android9BpRefBaseD1Ev; - _ZTv0_n12_N7android9HeapCacheD0Ev; - _ZTv0_n12_N7android9HeapCacheD1Ev; - _ZTv0_n12_N7android9RpcServerD0Ev; - _ZTv0_n12_N7android9RpcServerD1Ev; - _ZTv0_n16_N7android14MemoryHeapBaseD0Ev; - _ZTv0_n16_N7android14MemoryHeapBaseD1Ev; - _ZTv0_n16_N7android8BpBinder10onFirstRefEv; - _ZTv0_n16_N7android9BpRefBase10onFirstRefEv; - _ZTv0_n20_N7android8BpBinder15onLastStrongRefEPKv; - _ZTv0_n20_N7android9BpRefBase15onLastStrongRefEPKv; - _ZTv0_n24_N7android8BpBinder20onIncStrongAttemptedEjPKv; - _ZTv0_n24_N7android9BpRefBase20onIncStrongAttemptedEjPKv; - _ZTv0_n28_NK7android14MemoryHeapBase9getHeapIDEv; - _ZTv0_n32_NK7android14MemoryHeapBase7getBaseEv; - _ZTv0_n36_NK7android14MemoryHeapBase7getSizeEv; - _ZTv0_n40_NK7android14MemoryHeapBase8getFlagsEv; - _ZTv0_n44_NK7android14MemoryHeapBase9getOffsetEv; - _ZTvn4_n16_N7android14MemoryHeapBaseD0Ev; - _ZTvn4_n16_N7android14MemoryHeapBaseD1Ev; - _ZTVN7android10AllocationE; - _ZTVN7android10IInterfaceE; - _ZTVN7android10MemoryBaseE; - _ZTVN7android10PoolThreadE; - _ZTVN7android10RpcSession13RpcConnectionE; - _ZTVN7android10RpcSessionE; - _ZTVN7android10TextOutputE; - _ZTVN7android11IMemoryHeapE; - _ZTVN7android12BnMemoryHeapE; - _ZTVN7android12BpMemoryHeapE; - _ZTVN7android12FdTextOutputE; - _ZTVN7android12MemoryDealerE; - _ZTVN7android12ProcessStateE; - _ZTVN7android12SortedVectorINS_16key_value_pair_tINS_2wpINS_7IBinderEEENS_9HeapCache11heap_info_tEEEEE; - _ZTVN7android12SortedVectorINS_16key_value_pair_tIPKvNS_8BpBinder13ObjectManager7entry_tEEEEE; - _ZTVN7android13LogTextOutputE; - _ZTVN7android14IShellCallbackE; - _ZTVN7android14MemoryHeapBaseE; - _ZTVN7android15BnShellCallbackE; - _ZTVN7android15BpShellCallbackE; - _ZTVN7android15IResultReceiverE; - _ZTVN7android15IServiceManagerE; - _ZTVN7android16BnResultReceiverE; - _ZTVN7android16BpResultReceiverE; - _ZTVN7android17InetSocketAddressE; - _ZTVN7android17UnixSocketAddressE; - _ZTVN7android18BufferedTextOutput11BufferStateE; - _ZTVN7android18BufferedTextOutputE; - _ZTVN7android18ServiceManagerShimE; - _ZTVN7android18VsockSocketAddressE; - _ZTVN7android2os15IClientCallbackE; - _ZTVN7android2os15IServiceManagerE; - _ZTVN7android2os16BnClientCallbackE; - _ZTVN7android2os16BnServiceManagerE; - _ZTVN7android2os16BpClientCallbackE; - _ZTVN7android2os16BpServiceManagerE; - _ZTVN7android2os16IServiceCallbackE; - _ZTVN7android2os16ParcelableHolderE; - _ZTVN7android2os16ServiceDebugInfoE; - _ZTVN7android2os17BnServiceCallbackE; - _ZTVN7android2os17BpServiceCallbackE; - _ZTVN7android2os17PersistableBundleE; - _ZTVN7android2os20ParcelFileDescriptorE; - _ZTVN7android6binder8internal25ClientCounterCallbackImplE; - _ZTVN7android6VectorIiEE; - _ZTVN7android6VectorINS_12ProcessState12handle_entryEEE; - _ZTVN7android6VectorINS_2spINS_18BufferedTextOutput11BufferStateEEEEE; - _ZTVN7android6VectorINS_8BpBinder8ObituaryEEE; - _ZTVN7android6VectorINS_8String16EEE; - _ZTVN7android6VectorIPNS_7BBinderEEE; - _ZTVN7android6VectorIPNS_7RefBase12weakref_typeEEE; - _ZTVN7android6VectorIPNS_7RefBaseEEE; - _ZTVN7android7BBinderE; - _ZTVN7android7content2pm18PackageChangeEventE; - _ZTVN7android7content2pm21IPackageManagerNativeE; - _ZTVN7android7content2pm22BnPackageManagerNativeE; - _ZTVN7android7content2pm22BpPackageManagerNativeE; - _ZTVN7android7content2pm22IPackageChangeObserverE; - _ZTVN7android7content2pm23BnPackageChangeObserverE; - _ZTVN7android7content2pm23BpPackageChangeObserverE; - _ZTVN7android7IBinderE; - _ZTVN7android7IMemoryE; - _ZTVN7android8BnMemoryE; - _ZTVN7android8BpBinderE; - _ZTVN7android8BpMemoryE; - _ZTVN7android9BpRefBaseE; - _ZTVN7android9HeapCacheE; - _ZTVN7android9RpcServerE; - _ZTVNSt3__115basic_stringbufIcNS_11char_traitsIcEENS_9allocatorIcEEEE; - _ZTVNSt3__118basic_stringstreamIcNS_11char_traitsIcEENS_9allocatorIcEEEE; - _ZTVNSt3__120__shared_ptr_emplaceIN7android14RpcWireAddressENS_9allocatorIS2_EEEE; - _ZTVNSt3__120__shared_ptr_emplaceIN7android6binder8internal21ClientCounterCallbackENS_9allocatorIS4_EEEE; - local: - *; -}; diff --git a/libs/binder/libbinder.arm64.map b/libs/binder/libbinder.arm64.map deleted file mode 100644 index dc34de8641..0000000000 --- a/libs/binder/libbinder.arm64.map +++ /dev/null @@ -1,1601 +0,0 @@ -# b/190148312: Populate with correct list of ABI symbols -LIBBINDER { - global: - getBinderKernelReferences; - kDefaultDriver; - _ZN7android10AllocationC1ERKNS_2spINS_12MemoryDealerEEERKNS1_INS_11IMemoryHeapEEElm; - _ZN7android10AllocationC2ERKNS_2spINS_12MemoryDealerEEERKNS1_INS_11IMemoryHeapEEElm; - _ZN7android10AllocationD0Ev; - _ZN7android10AllocationD1Ev; - _ZN7android10AllocationD2Ev; - _ZN7android10IInterface8asBinderEPKS0_; - _ZN7android10IInterface8asBinderERKNS_2spIS0_EE; - _ZN7android10IInterfaceC2Ev; - _ZN7android10IInterfaceD0Ev; - _ZN7android10IInterfaceD1Ev; - _ZN7android10IInterfaceD2Ev; - _ZN7android10MemoryBaseC1ERKNS_2spINS_11IMemoryHeapEEElm; - _ZN7android10MemoryBaseC2ERKNS_2spINS_11IMemoryHeapEEElm; - _ZN7android10MemoryBaseD0Ev; - _ZN7android10MemoryBaseD1Ev; - _ZN7android10MemoryBaseD2Ev; - _ZN7android10RpcAddress14readFromParcelERKNS_6ParcelE; - _ZN7android10RpcAddress15fromRawEmbeddedEPKNS_14RpcWireAddressE; - _ZN7android10RpcAddress4zeroEv; - _ZN7android10RpcAddress6uniqueEv; - _ZN7android10RpcAddressC1Ev; - _ZN7android10RpcAddressC2Ev; - _ZN7android10RpcAddressD1Ev; - _ZN7android10RpcAddressD2Ev; - _ZN7android10RpcSession12setForServerERKNS_2wpINS_9RpcServerEEEi; - _ZN7android10RpcSession13getRootObjectEv; - _ZN7android10RpcSession13sendDecStrongERKNS_10RpcAddressE; - _ZN7android10RpcSession15setupInetClientEPKcj; - _ZN7android10RpcSession15terminateLockedEv; - _ZN7android10RpcSession16setupVsockClientEjj; - _ZN7android10RpcSession17setupSocketClientERKNS_16RpcSocketAddressE; - _ZN7android10RpcSession19addClientConnectionENS_4base14unique_fd_implINS1_13DefaultCloserEEE; - _ZN7android10RpcSession19ExclusiveConnection14findConnectionEiPNS_2spINS0_13RpcConnectionEEES5_RNSt3__16vectorIS4_NS6_9allocatorIS4_EEEEm; - _ZN7android10RpcSession19ExclusiveConnectionC1ERKNS_2spIS0_EENS0_13ConnectionUseE; - _ZN7android10RpcSession19ExclusiveConnectionC2ERKNS_2spIS0_EENS0_13ConnectionUseE; - _ZN7android10RpcSession19ExclusiveConnectionD1Ev; - _ZN7android10RpcSession19ExclusiveConnectionD2Ev; - _ZN7android10RpcSession19getRemoteMaxThreadsEPm; - _ZN7android10RpcSession20setupOneSocketClientERKNS_16RpcSocketAddressEi; - _ZN7android10RpcSession21setupUnixDomainClientEPKc; - _ZN7android10RpcSession22addNullDebuggingClientEv; - _ZN7android10RpcSession22removeServerConnectionERKNS_2spINS0_13RpcConnectionEEE; - _ZN7android10RpcSession24assignServerToThisThreadENS_4base14unique_fd_implINS1_13DefaultCloserEEE; - _ZN7android10RpcSession4joinENS_4base14unique_fd_implINS1_13DefaultCloserEEE; - _ZN7android10RpcSession4makeEv; - _ZN7android10RpcSession6readIdEv; - _ZN7android10RpcSession6serverEv; - _ZN7android10RpcSession7preJoinENSt3__16threadE; - _ZN7android10RpcSession8transactERKNS_10RpcAddressEjRKNS_6ParcelEPS4_j; - _ZN7android10RpcSessionC1Ev; - _ZN7android10RpcSessionC2Ev; - _ZN7android10RpcSessionD0Ev; - _ZN7android10RpcSessionD1Ev; - _ZN7android10RpcSessionD2Ev; - _ZN7android10TextOutputC2Ev; - _ZN7android10TextOutputD0Ev; - _ZN7android10TextOutputD1Ev; - _ZN7android10TextOutputD2Ev; - _ZN7android10zeroMemoryEPhm; - _ZN7android11BnInterfaceINS_11IMemoryHeapEE10onAsBinderEv; - _ZN7android11BnInterfaceINS_14IShellCallbackEE10onAsBinderEv; - _ZN7android11BnInterfaceINS_15IResultReceiverEE10onAsBinderEv; - _ZN7android11BnInterfaceINS_21IPermissionControllerEE10onAsBinderEv; - _ZN7android11BnInterfaceINS_2os15IClientCallbackEE10onAsBinderEv; - _ZN7android11BnInterfaceINS_2os15IServiceManagerEE10onAsBinderEv; - _ZN7android11BnInterfaceINS_2os16IServiceCallbackEE10onAsBinderEv; - _ZN7android11BnInterfaceINS_7content2pm21IPackageManagerNativeEE10onAsBinderEv; - _ZN7android11BnInterfaceINS_7content2pm22IPackageChangeObserverEE10onAsBinderEv; - _ZN7android11BnInterfaceINS_7IMemoryEE10onAsBinderEv; - _ZN7android11IMemoryHeap10descriptorE; - _ZN7android11IMemoryHeap11asInterfaceERKNS_2spINS_7IBinderEEE; - _ZN7android11IMemoryHeap12default_implE; - _ZN7android11IMemoryHeap14getDefaultImplEv; - _ZN7android11IMemoryHeap14setDefaultImplENSt3__110unique_ptrIS0_NS1_14default_deleteIS0_EEEE; - _ZN7android11IMemoryHeapC2Ev; - _ZN7android11IMemoryHeapD0Ev; - _ZN7android11IMemoryHeapD1Ev; - _ZN7android11IMemoryHeapD2Ev; - _ZN7android12BnMemoryHeap10onTransactEjRKNS_6ParcelEPS1_j; - _ZN7android12BnMemoryHeapC2Ev; - _ZN7android12BnMemoryHeapD0Ev; - _ZN7android12BnMemoryHeapD1Ev; - _ZN7android12BnMemoryHeapD2Ev; - _ZN7android12BpMemoryHeapC1ERKNS_2spINS_7IBinderEEE; - _ZN7android12BpMemoryHeapC2ERKNS_2spINS_7IBinderEEE; - _ZN7android12BpMemoryHeapD0Ev; - _ZN7android12BpMemoryHeapD1Ev; - _ZN7android12BpMemoryHeapD2Ev; - _ZN7android12gTextBuffersE; - _ZN7android12MemoryDealer10deallocateEm; - _ZN7android12MemoryDealer22getAllocationAlignmentEv; - _ZN7android12MemoryDealer8allocateEm; - _ZN7android12MemoryDealerC1EmPKcj; - _ZN7android12MemoryDealerC2EmPKcj; - _ZN7android12MemoryDealerD0Ev; - _ZN7android12MemoryDealerD1Ev; - _ZN7android12MemoryDealerD2Ev; - _ZN7android12printHexDataEiPKvmmimbPFvPvPKcES2_; - _ZN7android12ProcessState10selfOrNullEv; - _ZN7android12ProcessState13expungeHandleEiPNS_7IBinderE; - _ZN7android12ProcessState13getDriverNameEv; - _ZN7android12ProcessState14initWithDriverEPKc; - _ZN7android12ProcessState15startThreadPoolEv; - _ZN7android12ProcessState16getContextObjectERKNS_2spINS_7IBinderEEE; - _ZN7android12ProcessState17spawnPooledThreadEb; - _ZN7android12ProcessState18giveThreadPoolNameEv; - _ZN7android12ProcessState18lookupHandleLockedEi; - _ZN7android12ProcessState18setCallRestrictionENS0_15CallRestrictionE; - _ZN7android12ProcessState19getKernelReferencesEmPm; - _ZN7android12ProcessState20becomeContextManagerEv; - _ZN7android12ProcessState20makeBinderThreadNameEv; - _ZN7android12ProcessState23getStrongProxyForHandleEi; - _ZN7android12ProcessState24getStrongRefCountForNodeERKNS_2spINS_8BpBinderEEE; - _ZN7android12ProcessState25enableOnewaySpamDetectionEb; - _ZN7android12ProcessState27setThreadPoolMaxThreadCountEm; - _ZN7android12ProcessState4initEPKcb; - _ZN7android12ProcessState4selfEv; - _ZN7android12ProcessStateC1EPKc; - _ZN7android12ProcessStateC2EPKc; - _ZN7android12ProcessStateD0Ev; - _ZN7android12ProcessStateD1Ev; - _ZN7android12ProcessStateD2Ev; - _ZN7android13printTypeCodeEjPFvPvPKcES0_; - _ZN7android14IPCThreadState10freeBufferEPNS_6ParcelEPKhmPKym; - _ZN7android14IPCThreadState10selfOrNullEv; - _ZN7android14IPCThreadState11clearCallerEv; - _ZN7android14IPCThreadState11stopProcessEb; - _ZN7android14IPCThreadState12setupPollingEPi; - _ZN7android14IPCThreadState13decWeakHandleEi; - _ZN7android14IPCThreadState13expungeHandleEiPNS_7IBinderE; - _ZN7android14IPCThreadState13flushCommandsEv; - _ZN7android14IPCThreadState13flushIfNeededEv; - _ZN7android14IPCThreadState13incWeakHandleEiPNS_8BpBinderE; - _ZN7android14IPCThreadState14clearLastErrorEv; - _ZN7android14IPCThreadState14executeCommandEi; - _ZN7android14IPCThreadState14joinThreadPoolEb; - _ZN7android14IPCThreadState14talkWithDriverEb; - _ZN7android14IPCThreadState15decStrongHandleEi; - _ZN7android14IPCThreadState15incStrongHandleEiPNS_8BpBinderE; - _ZN7android14IPCThreadState15waitForResponseEPNS_6ParcelEPi; - _ZN7android14IPCThreadState16threadDestructorEPv; - _ZN7android14IPCThreadState18setCallRestrictionENS_12ProcessState15CallRestrictionE; - _ZN7android14IPCThreadState19setStrictModePolicyEi; - _ZN7android14IPCThreadState19setTheContextObjectERKNS_2spINS_7BBinderEEE; - _ZN7android14IPCThreadState20clearCallingIdentityEv; - _ZN7android14IPCThreadState20getAndExecuteCommandEv; - _ZN7android14IPCThreadState20getProcessFreezeInfoEiPbS1_; - _ZN7android14IPCThreadState20handlePolledCommandsEv; - _ZN7android14IPCThreadState20processPendingDerefsEv; - _ZN7android14IPCThreadState20writeTransactionDataEijijRKNS_6ParcelEPi; - _ZN7android14IPCThreadState22attemptIncStrongHandleEi; - _ZN7android14IPCThreadState22clearCallingWorkSourceEv; - _ZN7android14IPCThreadState22clearDeathNotificationEiPNS_8BpBinderE; - _ZN7android14IPCThreadState22processPostWriteDerefsEv; - _ZN7android14IPCThreadState22restoreCallingIdentityEl; - _ZN7android14IPCThreadState23setCallingWorkSourceUidEj; - _ZN7android14IPCThreadState24clearPropagateWorkSourceEv; - _ZN7android14IPCThreadState24requestDeathNotificationEiPNS_8BpBinderE; - _ZN7android14IPCThreadState24restoreCallingWorkSourceEl; - _ZN7android14IPCThreadState25blockUntilThreadAvailableEv; - _ZN7android14IPCThreadState27disableBackgroundSchedulingEb; - _ZN7android14IPCThreadState28backgroundSchedulingDisabledEv; - _ZN7android14IPCThreadState29setLastTransactionBinderFlagsEi; - _ZN7android14IPCThreadState41setCallingWorkSourceUidWithoutPropagationEj; - _ZN7android14IPCThreadState4selfEv; - _ZN7android14IPCThreadState6freezeEibj; - _ZN7android14IPCThreadState7processEv; - _ZN7android14IPCThreadState8shutdownEv; - _ZN7android14IPCThreadState8transactEijRKNS_6ParcelEPS1_j; - _ZN7android14IPCThreadState9sendReplyERKNS_6ParcelEj; - _ZN7android14IPCThreadStateC1Ev; - _ZN7android14IPCThreadStateC2Ev; - _ZN7android14IPCThreadStateD1Ev; - _ZN7android14IPCThreadStateD2Ev; - _ZN7android14IShellCallback10descriptorE; - _ZN7android14IShellCallback11asInterfaceERKNS_2spINS_7IBinderEEE; - _ZN7android14IShellCallback12default_implE; - _ZN7android14IShellCallback14getDefaultImplEv; - _ZN7android14IShellCallback14setDefaultImplENSt3__110unique_ptrIS0_NS1_14default_deleteIS0_EEEE; - _ZN7android14IShellCallbackC2Ev; - _ZN7android14IShellCallbackD0Ev; - _ZN7android14IShellCallbackD1Ev; - _ZN7android14IShellCallbackD2Ev; - _ZN7android14MemoryHeapBase4initEiPvmiPKc; - _ZN7android14MemoryHeapBase5mapfdEibml; - _ZN7android14MemoryHeapBase7disposeEv; - _ZN7android14MemoryHeapBaseC1Eimjl; - _ZN7android14MemoryHeapBaseC1EmjPKc; - _ZN7android14MemoryHeapBaseC1EPKcmj; - _ZN7android14MemoryHeapBaseC1Ev; - _ZN7android14MemoryHeapBaseC2Eimjl; - _ZN7android14MemoryHeapBaseC2EmjPKc; - _ZN7android14MemoryHeapBaseC2EPKcmj; - _ZN7android14MemoryHeapBaseC2Ev; - _ZN7android14MemoryHeapBaseD0Ev; - _ZN7android14MemoryHeapBaseD1Ev; - _ZN7android14MemoryHeapBaseD2Ev; - _ZN7android15BnShellCallback10onTransactEjRKNS_6ParcelEPS1_j; - _ZN7android15checkPermissionERKNS_8String16Eij; - _ZN7android15IResultReceiver10descriptorE; - _ZN7android15IResultReceiver11asInterfaceERKNS_2spINS_7IBinderEEE; - _ZN7android15IResultReceiver12default_implE; - _ZN7android15IResultReceiver14getDefaultImplEv; - _ZN7android15IResultReceiver14setDefaultImplENSt3__110unique_ptrIS0_NS1_14default_deleteIS0_EEEE; - _ZN7android15IResultReceiverC2Ev; - _ZN7android15IResultReceiverD0Ev; - _ZN7android15IResultReceiverD1Ev; - _ZN7android15IResultReceiverD2Ev; - _ZN7android15IServiceManagerC2Ev; - _ZN7android15IServiceManagerD0Ev; - _ZN7android15IServiceManagerD1Ev; - _ZN7android15IServiceManagerD2Ev; - _ZN7android15PermissionCache10purgeCacheEv; - _ZN7android15PermissionCache15checkPermissionERKNS_8String16Eij; - _ZN7android15PermissionCache22checkCallingPermissionERKNS_8String16E; - _ZN7android15PermissionCache22checkCallingPermissionERKNS_8String16EPiS4_; - _ZN7android15PermissionCache5cacheERKNS_8String16Ejb; - _ZN7android15PermissionCache5purgeEv; - _ZN7android15PermissionCacheC1Ev; - _ZN7android15PermissionCacheC2Ev; - _ZN7android15stringForIndentEi; - _ZN7android16BnResultReceiver10onTransactEjRKNS_6ParcelEPS1_j; - _ZN7android18BufferedTextOutput10moveIndentEi; - _ZN7android18BufferedTextOutput10pushBundleEv; - _ZN7android18BufferedTextOutput5printEPKcm; - _ZN7android18BufferedTextOutput9popBundleEv; - _ZN7android18BufferedTextOutputC2Ej; - _ZN7android18BufferedTextOutputD0Ev; - _ZN7android18BufferedTextOutputD1Ev; - _ZN7android18BufferedTextOutputD2Ev; - _ZN7android18ServiceManagerShim10addServiceERKNS_8String16ERKNS_2spINS_7IBinderEEEbi; - _ZN7android18ServiceManagerShim10isDeclaredERKNS_8String16E; - _ZN7android18ServiceManagerShim12listServicesEi; - _ZN7android18ServiceManagerShim14waitForServiceERKNS_8String16E; - _ZN7android18ServiceManagerShim16updatableViaApexERKNS_8String16E; - _ZN7android18ServiceManagerShim20getDeclaredInstancesERKNS_8String16E; - _ZN7android18ServiceManagerShimC1ERKNS_2spINS_2os15IServiceManagerEEE; - _ZN7android18ServiceManagerShimC2ERKNS_2spINS_2os15IServiceManagerEEE; - _ZN7android18the_context_objectE; - _ZN7android20PermissionController10getServiceEv; - _ZN7android20PermissionController13getPackageUidERKNS_8String16Ei; - _ZN7android20PermissionController15checkPermissionERKNS_8String16Eii; - _ZN7android20PermissionController17getPackagesForUidEjRNS_6VectorINS_8String16EEE; - _ZN7android20PermissionController19isRuntimePermissionERKNS_8String16E; - _ZN7android20PermissionController6noteOpERKNS_8String16EiS3_; - _ZN7android20PermissionControllerC1Ev; - _ZN7android20PermissionControllerC2Ev; - _ZN7android21defaultServiceManagerEv; - _ZN7android21IPermissionController10descriptorE; - _ZN7android21IPermissionController11asInterfaceERKNS_2spINS_7IBinderEEE; - _ZN7android21IPermissionController12default_implE; - _ZN7android21IPermissionController14getDefaultImplEv; - _ZN7android21IPermissionController14setDefaultImplENSt3__110unique_ptrIS0_NS1_14default_deleteIS0_EEEE; - _ZN7android21IPermissionControllerC2Ev; - _ZN7android21IPermissionControllerD0Ev; - _ZN7android21IPermissionControllerD1Ev; - _ZN7android21IPermissionControllerD2Ev; - _ZN7android22BnPermissionController10onTransactEjRKNS_6ParcelEPS1_j; - _ZN7android22checkCallingPermissionERKNS_8String16E; - _ZN7android22checkCallingPermissionERKNS_8String16EPiS3_; - _ZN7android22SimpleBestFitAllocator10deallocateEm; - _ZN7android22SimpleBestFitAllocator12kMemoryAlignE; - _ZN7android22SimpleBestFitAllocator5allocEmj; - _ZN7android22SimpleBestFitAllocator7deallocEm; - _ZN7android22SimpleBestFitAllocator8allocateEmj; - _ZN7android22SimpleBestFitAllocatorC1Em; - _ZN7android22SimpleBestFitAllocatorC2Em; - _ZN7android22SimpleBestFitAllocatorD1Ev; - _ZN7android22SimpleBestFitAllocatorD2Ev; - _ZN7android24setDefaultServiceManagerERKNS_2spINS_15IServiceManagerEEE; - _ZN7android2os15IClientCallback10descriptorE; - _ZN7android2os15IClientCallback11asInterfaceERKNS_2spINS_7IBinderEEE; - _ZN7android2os15IClientCallback12default_implE; - _ZN7android2os15IClientCallback14getDefaultImplEv; - _ZN7android2os15IClientCallback14setDefaultImplENSt3__110unique_ptrIS1_NS2_14default_deleteIS1_EEEE; - _ZN7android2os15IClientCallbackC2Ev; - _ZN7android2os15IClientCallbackD0Ev; - _ZN7android2os15IClientCallbackD1Ev; - _ZN7android2os15IClientCallbackD2Ev; - _ZN7android2os15IServiceManager10descriptorE; - _ZN7android2os15IServiceManager11asInterfaceERKNS_2spINS_7IBinderEEE; - _ZN7android2os15IServiceManager12default_implE; - _ZN7android2os15IServiceManager14getDefaultImplEv; - _ZN7android2os15IServiceManager14setDefaultImplENSt3__110unique_ptrIS1_NS2_14default_deleteIS1_EEEE; - _ZN7android2os15IServiceManagerC2Ev; - _ZN7android2os15IServiceManagerD0Ev; - _ZN7android2os15IServiceManagerD1Ev; - _ZN7android2os15IServiceManagerD2Ev; - _ZN7android2os16BnClientCallback10onTransactEjRKNS_6ParcelEPS2_j; - _ZN7android2os16BnClientCallbackC2Ev; - _ZN7android2os16BnServiceManager10onTransactEjRKNS_6ParcelEPS2_j; - _ZN7android2os16BnServiceManagerC2Ev; - _ZN7android2os16BpClientCallback9onClientsERKNS_2spINS_7IBinderEEEb; - _ZN7android2os16BpClientCallbackC1ERKNS_2spINS_7IBinderEEE; - _ZN7android2os16BpClientCallbackC2ERKNS_2spINS_7IBinderEEE; - _ZN7android2os16BpServiceManager10addServiceERKNSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEERKNS_2spINS_7IBinderEEEbi; - _ZN7android2os16BpServiceManager10getServiceERKNSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEPNS_2spINS_7IBinderEEE; - _ZN7android2os16BpServiceManager10isDeclaredERKNSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEPb; - _ZN7android2os16BpServiceManager12checkServiceERKNSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEPNS_2spINS_7IBinderEEE; - _ZN7android2os16BpServiceManager12listServicesEiPNSt3__16vectorINS2_12basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEENS7_IS9_EEEE; - _ZN7android2os16BpServiceManager16updatableViaApexERKNSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEPNS2_8optionalIS8_EE; - _ZN7android2os16BpServiceManager19getServiceDebugInfoEPNSt3__16vectorINS0_16ServiceDebugInfoENS2_9allocatorIS4_EEEE; - _ZN7android2os16BpServiceManager20getDeclaredInstancesERKNSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEPNS2_6vectorIS8_NS6_IS8_EEEE; - _ZN7android2os16BpServiceManager20tryUnregisterServiceERKNSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEERKNS_2spINS_7IBinderEEE; - _ZN7android2os16BpServiceManager22registerClientCallbackERKNSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEERKNS_2spINS_7IBinderEEERKNSB_INS0_15IClientCallbackEEE; - _ZN7android2os16BpServiceManager24registerForNotificationsERKNSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEERKNS_2spINS0_16IServiceCallbackEEE; - _ZN7android2os16BpServiceManager26unregisterForNotificationsERKNSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEERKNS_2spINS0_16IServiceCallbackEEE; - _ZN7android2os16BpServiceManagerC1ERKNS_2spINS_7IBinderEEE; - _ZN7android2os16BpServiceManagerC2ERKNS_2spINS_7IBinderEEE; - _ZN7android2os16IServiceCallback10descriptorE; - _ZN7android2os16IServiceCallback11asInterfaceERKNS_2spINS_7IBinderEEE; - _ZN7android2os16IServiceCallback12default_implE; - _ZN7android2os16IServiceCallback14getDefaultImplEv; - _ZN7android2os16IServiceCallback14setDefaultImplENSt3__110unique_ptrIS1_NS2_14default_deleteIS1_EEEE; - _ZN7android2os16IServiceCallbackC2Ev; - _ZN7android2os16IServiceCallbackD0Ev; - _ZN7android2os16IServiceCallbackD1Ev; - _ZN7android2os16IServiceCallbackD2Ev; - _ZN7android2os16ParcelableHolder14readFromParcelEPKNS_6ParcelE; - _ZN7android2os16ServiceDebugInfo14readFromParcelEPKNS_6ParcelE; - _ZN7android2os17BnServiceCallback10onTransactEjRKNS_6ParcelEPS2_j; - _ZN7android2os17BnServiceCallbackC2Ev; - _ZN7android2os17BpServiceCallback14onRegistrationERKNSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEERKNS_2spINS_7IBinderEEE; - _ZN7android2os17BpServiceCallbackC1ERKNS_2spINS_7IBinderEEE; - _ZN7android2os17BpServiceCallbackC2ERKNS_2spINS_7IBinderEEE; - _ZN7android2os17PersistableBundle10putBooleanERKNS_8String16Eb; - _ZN7android2os17PersistableBundle12putIntVectorERKNS_8String16ERKNSt3__16vectorIiNS5_9allocatorIiEEEE; - _ZN7android2os17PersistableBundle13putLongVectorERKNS_8String16ERKNSt3__16vectorIlNS5_9allocatorIlEEEE; - _ZN7android2os17PersistableBundle14readFromParcelEPKNS_6ParcelE; - _ZN7android2os17PersistableBundle15putDoubleVectorERKNS_8String16ERKNSt3__16vectorIdNS5_9allocatorIdEEEE; - _ZN7android2os17PersistableBundle15putStringVectorERKNS_8String16ERKNSt3__16vectorIS2_NS5_9allocatorIS2_EEEE; - _ZN7android2os17PersistableBundle16putBooleanVectorERKNS_8String16ERKNSt3__16vectorIbNS5_9allocatorIbEEEE; - _ZN7android2os17PersistableBundle19readFromParcelInnerEPKNS_6ParcelEm; - _ZN7android2os17PersistableBundle20putPersistableBundleERKNS_8String16ERKS1_; - _ZN7android2os17PersistableBundle5eraseERKNS_8String16E; - _ZN7android2os17PersistableBundle6putIntERKNS_8String16Ei; - _ZN7android2os17PersistableBundle7putLongERKNS_8String16El; - _ZN7android2os17PersistableBundle9putDoubleERKNS_8String16Ed; - _ZN7android2os17PersistableBundle9putStringERKNS_8String16ES4_; - _ZN7android2os20ParcelFileDescriptor14readFromParcelEPKNS_6ParcelE; - _ZN7android2os20ParcelFileDescriptorC1ENS_4base14unique_fd_implINS2_13DefaultCloserEEE; - _ZN7android2os20ParcelFileDescriptorC1Ev; - _ZN7android2os20ParcelFileDescriptorC2ENS_4base14unique_fd_implINS2_13DefaultCloserEEE; - _ZN7android2os20ParcelFileDescriptorC2Ev; - _ZN7android2os20ParcelFileDescriptorD0Ev; - _ZN7android2os20ParcelFileDescriptorD1Ev; - _ZN7android2os20ParcelFileDescriptorD2Ev; - _ZN7android2spINS_21IPermissionControllerEED2Ev; - _ZN7android2spINS_7BBinderEED2Ev; - _ZN7android2spINS_7IBinderEEaSEOS2_; - _ZN7android2spINS_7IBinderEEaSERKS2_; - _ZN7android2spINS_9HeapCacheEED2Ev; - _ZN7android4aerrE; - _ZN7android4alogE; - _ZN7android4aoutE; - _ZN7android6binder20LazyServiceRegistrar10reRegisterEv; - _ZN7android6binder20LazyServiceRegistrar11getInstanceEv; - _ZN7android6binder20LazyServiceRegistrar12forcePersistEb; - _ZN7android6binder20LazyServiceRegistrar13tryUnregisterEv; - _ZN7android6binder20LazyServiceRegistrar15registerServiceERKNS_2spINS_7IBinderEEERKNSt3__112basic_stringIcNS7_11char_traitsIcEENS7_9allocatorIcEEEEbi; - _ZN7android6binder20LazyServiceRegistrar25setActiveServicesCallbackERKNSt3__18functionIFbbEEE; - _ZN7android6binder20LazyServiceRegistrarC1Ev; - _ZN7android6binder20LazyServiceRegistrarC2Ev; - _ZN7android6binder6Status11fromStatusTEi; - _ZN7android6binder6Status12setExceptionEiRKNS_7String8E; - _ZN7android6binder6Status14readFromParcelERKNS_6ParcelE; - _ZN7android6binder6Status14setFromStatusTEi; - _ZN7android6binder6Status17exceptionToStringEi; - _ZN7android6binder6Status17fromExceptionCodeEi; - _ZN7android6binder6Status17fromExceptionCodeEiPKc; - _ZN7android6binder6Status17fromExceptionCodeEiRKNS_7String8E; - _ZN7android6binder6Status23setServiceSpecificErrorEiRKNS_7String8E; - _ZN7android6binder6Status24fromServiceSpecificErrorEi; - _ZN7android6binder6Status24fromServiceSpecificErrorEiPKc; - _ZN7android6binder6Status24fromServiceSpecificErrorEiRKNS_7String8E; - _ZN7android6binder6Status2okEv; - _ZN7android6binder6StatusC1Eii; - _ZN7android6binder6StatusC1EiiRKNS_7String8E; - _ZN7android6binder6StatusC2Eii; - _ZN7android6binder6StatusC2EiiRKNS_7String8E; - _ZN7android6binder8internal21ClientCounterCallback10reRegisterEv; - _ZN7android6binder8internal21ClientCounterCallback12forcePersistEb; - _ZN7android6binder8internal21ClientCounterCallback13tryUnregisterEv; - _ZN7android6binder8internal21ClientCounterCallback15registerServiceERKNS_2spINS_7IBinderEEERKNSt3__112basic_stringIcNS8_11char_traitsIcEENS8_9allocatorIcEEEEbi; - _ZN7android6binder8internal21ClientCounterCallback25setActiveServicesCallbackERKNSt3__18functionIFbbEEE; - _ZN7android6binder8internal21ClientCounterCallbackC1Ev; - _ZN7android6binder8internal21ClientCounterCallbackC2Ev; - _ZN7android6binder8internal25ClientCounterCallbackImpl10reRegisterEv; - _ZN7android6binder8internal25ClientCounterCallbackImpl11tryShutdownEv; - _ZN7android6binder8internal25ClientCounterCallbackImpl12forcePersistEb; - _ZN7android6binder8internal25ClientCounterCallbackImpl13tryUnregisterEv; - _ZN7android6binder8internal25ClientCounterCallbackImpl15registerServiceERKNS_2spINS_7IBinderEEERKNSt3__112basic_stringIcNS8_11char_traitsIcEENS8_9allocatorIcEEEEbi; - _ZN7android6binder8internal25ClientCounterCallbackImpl16maybeTryShutdownEv; - _ZN7android6binder8internal25ClientCounterCallbackImpl23assertRegisteredServiceERKNS_2spINS_7IBinderEEE; - _ZN7android6binder8internal25ClientCounterCallbackImpl25setActiveServicesCallbackERKNSt3__18functionIFbbEEE; - _ZN7android6binder8internal25ClientCounterCallbackImpl9onClientsERKNS_2spINS_7IBinderEEEb; - _ZN7android6Parcel10appendFromEPKS0_mm; - _ZN7android6Parcel10markForRpcERKNS_2spINS_10RpcSessionEEE; - _ZN7android6Parcel10writeFloatEf; - _ZN7android6Parcel10writeInt32Ei; - _ZN7android6Parcel10writeInt64El; - _ZN7android6Parcel11compareDataERKS0_; - _ZN7android6Parcel11finishWriteEm; - _ZN7android6Parcel11setDataSizeEm; - _ZN7android6Parcel11writeDoubleEd; - _ZN7android6Parcel11writeObjectERK18flat_binder_objectb; - _ZN7android6Parcel11writeUint32Ej; - _ZN7android6Parcel11writeUint64Em; - _ZN7android6Parcel12pushAllowFdsEb; - _ZN7android6Parcel12restartWriteEm; - _ZN7android6Parcel12writeCStringEPKc; - _ZN7android6Parcel12writeInplaceEm; - _ZN7android6Parcel12writePointerEm; - _ZN7android6Parcel12writeString8EPKcm; - _ZN7android6Parcel12writeString8ERKNS_7String8E; - _ZN7android6Parcel13continueWriteEm; - _ZN7android6Parcel13flattenBinderERKNS_2spINS_7IBinderEEE; - _ZN7android6Parcel13markForBinderERKNS_2spINS_7IBinderEEE; - _ZN7android6Parcel13writeString16EPKDsm; - _ZN7android6Parcel13writeString16ERKNS_8String16E; - _ZN7android6Parcel13writeString16ERKNSt3__110unique_ptrINS_8String16ENS1_14default_deleteIS3_EEEE; - _ZN7android6Parcel13writeString16ERKNSt3__18optionalINS_8String16EEE; - _ZN7android6Parcel13writeUnpaddedEPKvm; - _ZN7android6Parcel14acquireObjectsEv; - _ZN7android6Parcel14freeDataNoInitEv; - _ZN7android6Parcel14releaseObjectsEv; - _ZN7android6Parcel14writeByteArrayEmPKh; - _ZN7android6Parcel15restoreAllowFdsEb; - _ZN7android6Parcel15setDataCapacityEm; - _ZN7android6Parcel15writeBoolVectorERKNSt3__110unique_ptrINS1_6vectorIbNS1_9allocatorIbEEEENS1_14default_deleteIS6_EEEE; - _ZN7android6Parcel15writeBoolVectorERKNSt3__16vectorIbNS1_9allocatorIbEEEE; - _ZN7android6Parcel15writeBoolVectorERKNSt3__18optionalINS1_6vectorIbNS1_9allocatorIbEEEEEE; - _ZN7android6Parcel15writeByteVectorERKNSt3__110unique_ptrINS1_6vectorIaNS1_9allocatorIaEEEENS1_14default_deleteIS6_EEEE; - _ZN7android6Parcel15writeByteVectorERKNSt3__110unique_ptrINS1_6vectorIhNS1_9allocatorIhEEEENS1_14default_deleteIS6_EEEE; - _ZN7android6Parcel15writeByteVectorERKNSt3__16vectorIaNS1_9allocatorIaEEEE; - _ZN7android6Parcel15writeByteVectorERKNSt3__16vectorIhNS1_9allocatorIhEEEE; - _ZN7android6Parcel15writeByteVectorERKNSt3__18optionalINS1_6vectorIaNS1_9allocatorIaEEEEEE; - _ZN7android6Parcel15writeByteVectorERKNSt3__18optionalINS1_6vectorIhNS1_9allocatorIhEEEEEE; - _ZN7android6Parcel15writeCharVectorERKNSt3__110unique_ptrINS1_6vectorIDsNS1_9allocatorIDsEEEENS1_14default_deleteIS6_EEEE; - _ZN7android6Parcel15writeCharVectorERKNSt3__16vectorIDsNS1_9allocatorIDsEEEE; - _ZN7android6Parcel15writeCharVectorERKNSt3__18optionalINS1_6vectorIDsNS1_9allocatorIDsEEEEEE; - _ZN7android6Parcel15writeInt32ArrayEmPKi; - _ZN7android6Parcel15writeParcelableERKNS_10ParcelableE; - _ZN7android6Parcel16writeFloatVectorERKNSt3__110unique_ptrINS1_6vectorIfNS1_9allocatorIfEEEENS1_14default_deleteIS6_EEEE; - _ZN7android6Parcel16writeFloatVectorERKNSt3__16vectorIfNS1_9allocatorIfEEEE; - _ZN7android6Parcel16writeFloatVectorERKNSt3__18optionalINS1_6vectorIfNS1_9allocatorIfEEEEEE; - _ZN7android6Parcel16writeInt32VectorERKNSt3__110unique_ptrINS1_6vectorIiNS1_9allocatorIiEEEENS1_14default_deleteIS6_EEEE; - _ZN7android6Parcel16writeInt32VectorERKNSt3__16vectorIiNS1_9allocatorIiEEEE; - _ZN7android6Parcel16writeInt32VectorERKNSt3__18optionalINS1_6vectorIiNS1_9allocatorIiEEEEEE; - _ZN7android6Parcel16writeInt64VectorERKNSt3__110unique_ptrINS1_6vectorIlNS1_9allocatorIlEEEENS1_14default_deleteIS6_EEEE; - _ZN7android6Parcel16writeInt64VectorERKNSt3__16vectorIlNS1_9allocatorIlEEEE; - _ZN7android6Parcel16writeInt64VectorERKNSt3__18optionalINS1_6vectorIlNS1_9allocatorIlEEEEEE; - _ZN7android6Parcel16writeNoExceptionEv; - _ZN7android6Parcel16writeUtf8AsUtf16ERKNSt3__110unique_ptrINS1_12basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEENS1_14default_deleteIS8_EEEE; - _ZN7android6Parcel16writeUtf8AsUtf16ERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEE; - _ZN7android6Parcel16writeUtf8AsUtf16ERKNSt3__18optionalINS1_12basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEEE; - _ZN7android6Parcel17writeDoubleVectorERKNSt3__110unique_ptrINS1_6vectorIdNS1_9allocatorIdEEEENS1_14default_deleteIS6_EEEE; - _ZN7android6Parcel17writeDoubleVectorERKNSt3__16vectorIdNS1_9allocatorIdEEEE; - _ZN7android6Parcel17writeDoubleVectorERKNSt3__18optionalINS1_6vectorIdNS1_9allocatorIdEEEEEE; - _ZN7android6Parcel17writeNativeHandleEPK13native_handle; - _ZN7android6Parcel17writeStrongBinderERKNS_2spINS_7IBinderEEE; - _ZN7android6Parcel17writeUint64VectorERKNSt3__110unique_ptrINS1_6vectorImNS1_9allocatorImEEEENS1_14default_deleteIS6_EEEE; - _ZN7android6Parcel17writeUint64VectorERKNSt3__16vectorImNS1_9allocatorImEEEE; - _ZN7android6Parcel17writeUint64VectorERKNSt3__18optionalINS1_6vectorImNS1_9allocatorImEEEEEE; - _ZN7android6Parcel18getGlobalAllocSizeEv; - _ZN7android6Parcel19finishFlattenBinderERKNS_2spINS_7IBinderEEE; - _ZN7android6Parcel19getGlobalAllocCountEv; - _ZN7android6Parcel19ipcSetDataReferenceEPKhmPKymPFvPS0_S2_mS4_mE; - _ZN7android6Parcel19writeFileDescriptorEib; - _ZN7android6Parcel19writeInterfaceTokenEPKDsm; - _ZN7android6Parcel19writeInterfaceTokenERKNS_8String16E; - _ZN7android6Parcel19writeString16VectorERKNSt3__110unique_ptrINS1_6vectorINS2_INS_8String16ENS1_14default_deleteIS4_EEEENS1_9allocatorIS7_EEEENS5_ISA_EEEE; - _ZN7android6Parcel19writeString16VectorERKNSt3__16vectorINS_8String16ENS1_9allocatorIS3_EEEE; - _ZN7android6Parcel19writeString16VectorERKNSt3__18optionalINS1_6vectorINS2_INS_8String16EEENS1_9allocatorIS5_EEEEEE; - _ZN7android6Parcel20closeFileDescriptorsEv; - _ZN7android6Parcel22writeDupFileDescriptorEi; - _ZN7android6Parcel23writeStrongBinderVectorERKNSt3__110unique_ptrINS1_6vectorINS_2spINS_7IBinderEEENS1_9allocatorIS6_EEEENS1_14default_deleteIS9_EEEE; - _ZN7android6Parcel23writeStrongBinderVectorERKNSt3__16vectorINS_2spINS_7IBinderEEENS1_9allocatorIS5_EEEE; - _ZN7android6Parcel23writeStrongBinderVectorERKNSt3__18optionalINS1_6vectorINS_2spINS_7IBinderEEENS1_9allocatorIS6_EEEEEE; - _ZN7android6Parcel25writeParcelFileDescriptorEib; - _ZN7android6Parcel25writeUniqueFileDescriptorERKNS_4base14unique_fd_implINS1_13DefaultCloserEEE; - _ZN7android6Parcel26writeRawNullableParcelableEPKNS_10ParcelableE; - _ZN7android6Parcel27replaceCallingWorkSourceUidEj; - _ZN7android6Parcel28writeDupParcelFileDescriptorEi; - _ZN7android6Parcel28writeUtf8VectorAsUtf16VectorERKNSt3__110unique_ptrINS1_6vectorINS2_INS1_12basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEENS1_14default_deleteIS9_EEEENS7_ISC_EEEENSA_ISE_EEEE; - _ZN7android6Parcel28writeUtf8VectorAsUtf16VectorERKNSt3__16vectorINS1_12basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEENS6_IS8_EEEE; - _ZN7android6Parcel28writeUtf8VectorAsUtf16VectorERKNSt3__18optionalINS1_6vectorINS2_INS1_12basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEEENS7_ISA_EEEEEE; - _ZN7android6Parcel31writeUniqueFileDescriptorVectorERKNSt3__110unique_ptrINS1_6vectorINS_4base14unique_fd_implINS4_13DefaultCloserEEENS1_9allocatorIS7_EEEENS1_14default_deleteISA_EEEE; - _ZN7android6Parcel31writeUniqueFileDescriptorVectorERKNSt3__16vectorINS_4base14unique_fd_implINS3_13DefaultCloserEEENS1_9allocatorIS6_EEEE; - _ZN7android6Parcel31writeUniqueFileDescriptorVectorERKNSt3__18optionalINS1_6vectorINS_4base14unique_fd_implINS4_13DefaultCloserEEENS1_9allocatorIS7_EEEEEE; - _ZN7android6Parcel35writeDupImmutableBlobFileDescriptorEi; - _ZN7android6Parcel4Blob4initEiPvmb; - _ZN7android6Parcel4Blob5clearEv; - _ZN7android6Parcel4Blob7releaseEv; - _ZN7android6Parcel4BlobC1Ev; - _ZN7android6Parcel4BlobC2Ev; - _ZN7android6Parcel4BlobD1Ev; - _ZN7android6Parcel4BlobD2Ev; - _ZN7android6Parcel5writeEPKvm; - _ZN7android6Parcel5writeERKNS0_26FlattenableHelperInterfaceE; - _ZN7android6Parcel7setDataEPKhm; - _ZN7android6Parcel8freeDataEv; - _ZN7android6Parcel8growDataEm; - _ZN7android6Parcel8setErrorEi; - _ZN7android6Parcel9initStateEv; - _ZN7android6Parcel9writeBlobEmbPNS0_12WritableBlobE; - _ZN7android6Parcel9writeBoolEb; - _ZN7android6Parcel9writeByteEa; - _ZN7android6Parcel9writeCharEDs; - _ZN7android6ParcelC1Ev; - _ZN7android6ParcelC2Ev; - _ZN7android6ParcelD1Ev; - _ZN7android6ParcelD2Ev; - _ZN7android7BBinder10onTransactEjRKNS_6ParcelEPS1_j; - _ZN7android7BBinder10pingBinderEv; - _ZN7android7BBinder11getDebugPidEv; - _ZN7android7BBinder11isInheritRtEv; - _ZN7android7BBinder11linkToDeathERKNS_2spINS_7IBinder14DeathRecipientEEEPvj; - _ZN7android7BBinder11localBinderEv; - _ZN7android7BBinder12attachObjectEPKvPvS3_PFvS2_S3_S3_E; - _ZN7android7BBinder12detachObjectEPKv; - _ZN7android7BBinder12getExtensionEv; - _ZN7android7BBinder12setExtensionERKNS_2spINS_7IBinderEEE; - _ZN7android7BBinder12setInheritRtEb; - _ZN7android7BBinder13unlinkToDeathERKNS_2wpINS_7IBinder14DeathRecipientEEEPvjPS4_; - _ZN7android7BBinder15isRequestingSidEv; - _ZN7android7BBinder16setRequestingSidEb; - _ZN7android7BBinder17getOrCreateExtrasEv; - _ZN7android7BBinder21getMinSchedulerPolicyEv; - _ZN7android7BBinder21setMinSchedulerPolicyEii; - _ZN7android7BBinder23getMinSchedulerPriorityEv; - _ZN7android7BBinder4dumpEiRKNS_6VectorINS_8String16EEE; - _ZN7android7BBinder8transactEjRKNS_6ParcelEPS1_j; - _ZN7android7BBinderC1Ev; - _ZN7android7BBinderC2Ev; - _ZN7android7BBinderD0Ev; - _ZN7android7BBinderD1Ev; - _ZN7android7BBinderD2Ev; - _ZN7android7content2pm18PackageChangeEvent14readFromParcelEPKNS_6ParcelE; - _ZN7android7content2pm21IPackageManagerNative10descriptorE; - _ZN7android7content2pm21IPackageManagerNative11asInterfaceERKNS_2spINS_7IBinderEEE; - _ZN7android7content2pm21IPackageManagerNative12default_implE; - _ZN7android7content2pm21IPackageManagerNative14getDefaultImplEv; - _ZN7android7content2pm21IPackageManagerNative14setDefaultImplENSt3__110unique_ptrIS2_NS3_14default_deleteIS2_EEEE; - _ZN7android7content2pm21IPackageManagerNativeC2Ev; - _ZN7android7content2pm21IPackageManagerNativeD0Ev; - _ZN7android7content2pm21IPackageManagerNativeD1Ev; - _ZN7android7content2pm21IPackageManagerNativeD2Ev; - _ZN7android7content2pm22BnPackageManagerNative10onTransactEjRKNS_6ParcelEPS3_j; - _ZN7android7content2pm22BnPackageManagerNativeC2Ev; - _ZN7android7content2pm22BpPackageManagerNative14getAllPackagesEPNSt3__16vectorINS3_12basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEENS8_ISA_EEEE; - _ZN7android7content2pm22BpPackageManagerNative15getNamesForUidsERKNSt3__16vectorIiNS3_9allocatorIiEEEEPNS4_INS3_12basic_stringIcNS3_11char_traitsIcEENS5_IcEEEENS5_ISE_EEEE; - _ZN7android7content2pm22BpPackageManagerNative16getLocationFlagsERKNSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEPi; - _ZN7android7content2pm22BpPackageManagerNative16hasSystemFeatureERKNS_8String16EiPb; - _ZN7android7content2pm22BpPackageManagerNative19isPackageDebuggableERKNS_8String16EPb; - _ZN7android7content2pm22BpPackageManagerNative22getInstallerForPackageERKNS_8String16EPNSt3__112basic_stringIcNS6_11char_traitsIcEENS6_9allocatorIcEEEE; - _ZN7android7content2pm22BpPackageManagerNative24getVersionCodeForPackageERKNS_8String16EPl; - _ZN7android7content2pm22BpPackageManagerNative27hasSha256SigningCertificateERKNSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEERKNS3_6vectorIhNS7_IhEEEEPb; - _ZN7android7content2pm22BpPackageManagerNative28getModuleMetadataPackageNameEPNSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEE; - _ZN7android7content2pm22BpPackageManagerNative29getTargetSdkVersionForPackageERKNS_8String16EPi; - _ZN7android7content2pm22BpPackageManagerNative29isAudioPlaybackCaptureAllowedERKNSt3__16vectorINS3_12basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEENS8_ISA_EEEEPNS4_IbNS8_IbEEEE; - _ZN7android7content2pm22BpPackageManagerNative29registerPackageChangeObserverERKNS_2spINS1_22IPackageChangeObserverEEE; - _ZN7android7content2pm22BpPackageManagerNative31unregisterPackageChangeObserverERKNS_2spINS1_22IPackageChangeObserverEEE; - _ZN7android7content2pm22BpPackageManagerNativeC1ERKNS_2spINS_7IBinderEEE; - _ZN7android7content2pm22BpPackageManagerNativeC2ERKNS_2spINS_7IBinderEEE; - _ZN7android7content2pm22IPackageChangeObserver10descriptorE; - _ZN7android7content2pm22IPackageChangeObserver11asInterfaceERKNS_2spINS_7IBinderEEE; - _ZN7android7content2pm22IPackageChangeObserver12default_implE; - _ZN7android7content2pm22IPackageChangeObserver14getDefaultImplEv; - _ZN7android7content2pm22IPackageChangeObserver14setDefaultImplENSt3__110unique_ptrIS2_NS3_14default_deleteIS2_EEEE; - _ZN7android7content2pm22IPackageChangeObserverC2Ev; - _ZN7android7content2pm22IPackageChangeObserverD0Ev; - _ZN7android7content2pm22IPackageChangeObserverD1Ev; - _ZN7android7content2pm22IPackageChangeObserverD2Ev; - _ZN7android7content2pm23BnPackageChangeObserver10onTransactEjRKNS_6ParcelEPS3_j; - _ZN7android7content2pm23BnPackageChangeObserverC2Ev; - _ZN7android7content2pm23BpPackageChangeObserver16onPackageChangedERKNS1_18PackageChangeEventE; - _ZN7android7content2pm23BpPackageChangeObserverC1ERKNS_2spINS_7IBinderEEE; - _ZN7android7content2pm23BpPackageChangeObserverC2ERKNS_2spINS_7IBinderEEE; - _ZN7android7HexDumpC1EPKvmm; - _ZN7android7HexDumpC2EPKvmm; - _ZN7android7IBinder11getDebugPidEPi; - _ZN7android7IBinder11localBinderEv; - _ZN7android7IBinder12getExtensionEPNS_2spIS0_EE; - _ZN7android7IBinder12remoteBinderEv; - _ZN7android7IBinder12shellCommandERKNS_2spIS0_EEiiiRNS_6VectorINS_8String16EEERKNS1_INS_14IShellCallbackEEERKNS1_INS_15IResultReceiverEEE; - _ZN7android7IBinder19queryLocalInterfaceERKNS_8String16E; - _ZN7android7IBinderC2Ev; - _ZN7android7IBinderD0Ev; - _ZN7android7IBinderD1Ev; - _ZN7android7IBinderD2Ev; - _ZN7android7IMemory10descriptorE; - _ZN7android7IMemory11asInterfaceERKNS_2spINS_7IBinderEEE; - _ZN7android7IMemory12default_implE; - _ZN7android7IMemory14getDefaultImplEv; - _ZN7android7IMemory14setDefaultImplENSt3__110unique_ptrIS0_NS1_14default_deleteIS0_EEEE; - _ZN7android7IMemoryC2Ev; - _ZN7android7IMemoryD0Ev; - _ZN7android7IMemoryD1Ev; - _ZN7android7IMemoryD2Ev; - _ZN7android8BnMemory10onTransactEjRKNS_6ParcelEPS1_j; - _ZN7android8BnMemoryC2Ev; - _ZN7android8BnMemoryD0Ev; - _ZN7android8BnMemoryD1Ev; - _ZN7android8BnMemoryD2Ev; - _ZN7android8BpBinder10onFirstRefEv; - _ZN7android8BpBinder10pingBinderEv; - _ZN7android8BpBinder11linkToDeathERKNS_2spINS_7IBinder14DeathRecipientEEEPvj; - _ZN7android8BpBinder12attachObjectEPKvPvS3_PFvS2_S3_S3_E; - _ZN7android8BpBinder12detachObjectEPKv; - _ZN7android8BpBinder12remoteBinderEv; - _ZN7android8BpBinder12sendObituaryEv; - _ZN7android8BpBinder12sTrackingMapE; - _ZN7android8BpBinder13getCountByUidERNS_6VectorIjEES3_; - _ZN7android8BpBinder13ObjectManager4killEv; - _ZN7android8BpBinder13ObjectManager6attachEPKvPvS4_PFvS3_S4_S4_E; - _ZN7android8BpBinder13ObjectManager6detachEPKv; - _ZN7android8BpBinder13ObjectManagerC1Ev; - _ZN7android8BpBinder13ObjectManagerC2Ev; - _ZN7android8BpBinder13ObjectManagerD1Ev; - _ZN7android8BpBinder13ObjectManagerD2Ev; - _ZN7android8BpBinder13sTrackingLockE; - _ZN7android8BpBinder13unlinkToDeathERKNS_2wpINS_7IBinder14DeathRecipientEEEPvjPS4_; - _ZN7android8BpBinder14reportOneDeathERKNS0_8ObituaryE; - _ZN7android8BpBinder14sLimitCallbackE; - _ZN7android8BpBinder15onLastStrongRefEPKv; - _ZN7android8BpBinder15sNumTrackedUidsE; - _ZN7android8BpBinder16enableCountByUidEv; - _ZN7android8BpBinder16setLimitCallbackEPFviE; - _ZN7android8BpBinder17disableCountByUidEv; - _ZN7android8BpBinder18sCountByUidEnabledE; - _ZN7android8BpBinder19getBinderProxyCountEj; - _ZN7android8BpBinder20onIncStrongAttemptedEjPKv; - _ZN7android8BpBinder20setCountByUidEnabledEb; - _ZN7android8BpBinder26sBinderProxyThrottleCreateE; - _ZN7android8BpBinder29sBinderProxyCountLowWatermarkE; - _ZN7android8BpBinder29setBinderProxyCountWatermarksEii; - _ZN7android8BpBinder30sBinderProxyCountHighWatermarkE; - _ZN7android8BpBinder4dumpEiRKNS_6VectorINS_8String16EEE; - _ZN7android8BpBinder6createEi; - _ZN7android8BpBinder6createERKNS_2spINS_10RpcSessionEEERKNS_10RpcAddressE; - _ZN7android8BpBinder8transactEjRKNS_6ParcelEPS1_j; - _ZN7android8BpBinderC1EONS0_12BinderHandleEi; - _ZN7android8BpBinderC1EONS0_9RpcHandleE; - _ZN7android8BpBinderC1EONSt3__17variantIJNS0_12BinderHandleENS0_9RpcHandleEEEE; - _ZN7android8BpBinderC2EONS0_12BinderHandleEi; - _ZN7android8BpBinderC2EONS0_9RpcHandleE; - _ZN7android8BpBinderC2EONSt3__17variantIJNS0_12BinderHandleENS0_9RpcHandleEEEE; - _ZN7android8BpBinderD0Ev; - _ZN7android8BpBinderD1Ev; - _ZN7android8BpBinderD2Ev; - _ZN7android8BpMemoryC1ERKNS_2spINS_7IBinderEEE; - _ZN7android8BpMemoryC2ERKNS_2spINS_7IBinderEEE; - _ZN7android8BpMemoryD0Ev; - _ZN7android8BpMemoryD1Ev; - _ZN7android8BpMemoryD2Ev; - _ZN7android8internal9Stability11getCategoryEPNS_7IBinderE; - _ZN7android8internal9Stability11levelStringENS1_5LevelE; - _ZN7android8internal9Stability13getLocalLevelEv; - _ZN7android8internal9Stability15isDeclaredLevelENS1_5LevelE; - _ZN7android8internal9Stability17debugLogStabilityERKNSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEERKNS_2spINS_7IBinderEEE; - _ZN7android8internal9Stability19markCompilationUnitEPNS_7IBinderE; - _ZN7android8internal9Stability22tryMarkCompilationUnitEPNS_7IBinderE; - _ZN7android8internal9Stability24requiresVintfDeclarationERKNS_2spINS_7IBinderEEE; - _ZN7android8internal9Stability25forceDowngradeToStabilityERKNS_2spINS_7IBinderEEENS1_5LevelE; - _ZN7android8internal9Stability30forceDowngradeToLocalStabilityERKNS_2spINS_7IBinderEEE; - _ZN7android8internal9Stability31forceDowngradeToSystemStabilityERKNS_2spINS_7IBinderEEE; - _ZN7android8internal9Stability31forceDowngradeToVendorStabilityERKNS_2spINS_7IBinderEEE; - _ZN7android8internal9Stability5checkENS1_8CategoryENS1_5LevelE; - _ZN7android8internal9Stability7setReprEPNS_7IBinderEij; - _ZN7android8internal9Stability8Category11debugStringEv; - _ZN7android8internal9Stability8markVndkEPNS_7IBinderE; - _ZN7android8internal9Stability9markVintfEPNS_7IBinderE; - _ZN7android8RpcState11CommandDataC1Em; - _ZN7android8RpcState11CommandDataC2Em; - _ZN7android8RpcState12countBindersEv; - _ZN7android8RpcState12getSessionIdERKNS_4base14unique_fd_implINS1_13DefaultCloserEEERKNS_2spINS_10RpcSessionEEEPi; - _ZN7android8RpcState12waitForReplyERKNS_4base14unique_fd_implINS1_13DefaultCloserEEERKNS_2spINS_10RpcSessionEEEPNS_6ParcelE; - _ZN7android8RpcState13getMaxThreadsERKNS_4base14unique_fd_implINS1_13DefaultCloserEEERKNS_2spINS_10RpcSessionEEEPm; - _ZN7android8RpcState13getRootObjectERKNS_4base14unique_fd_implINS1_13DefaultCloserEEERKNS_2spINS_10RpcSessionEEE; - _ZN7android8RpcState13sendDecStrongERKNS_4base14unique_fd_implINS1_13DefaultCloserEEERKNS_10RpcAddressE; - _ZN7android8RpcState15onBinderLeavingERKNS_2spINS_10RpcSessionEEERKNS1_INS_7IBinderEEEPNS_10RpcAddressE; - _ZN7android8RpcState15processTransactERKNS_4base14unique_fd_implINS1_13DefaultCloserEEERKNS_2spINS_10RpcSessionEEERKNS_13RpcWireHeaderE; - _ZN7android8RpcState16onBinderEnteringERKNS_2spINS_10RpcSessionEEERKNS_10RpcAddressE; - _ZN7android8RpcState16processDecStrongERKNS_4base14unique_fd_implINS1_13DefaultCloserEEERKNS_13RpcWireHeaderE; - _ZN7android8RpcState20getAndExecuteCommandERKNS_4base14unique_fd_implINS1_13DefaultCloserEEERKNS_2spINS_10RpcSessionEEE; - _ZN7android8RpcState20processServerCommandERKNS_4base14unique_fd_implINS1_13DefaultCloserEEERKNS_2spINS_10RpcSessionEEERKNS_13RpcWireHeaderE; - _ZN7android8RpcState23processTransactInternalERKNS_4base14unique_fd_implINS1_13DefaultCloserEEERKNS_2spINS_10RpcSessionEEENS0_11CommandDataE; - _ZN7android8RpcState4dumpEv; - _ZN7android8RpcState6rpcRecERKNS_4base14unique_fd_implINS1_13DefaultCloserEEEPKcPvm; - _ZN7android8RpcState7rpcSendERKNS_4base14unique_fd_implINS1_13DefaultCloserEEEPKcPKvm; - _ZN7android8RpcState8transactERKNS_4base14unique_fd_implINS1_13DefaultCloserEEERKNS_10RpcAddressEjRKNS_6ParcelERKNS_2spINS_10RpcSessionEEEPSA_j; - _ZN7android8RpcState9terminateEv; - _ZN7android8RpcStateC1Ev; - _ZN7android8RpcStateC2Ev; - _ZN7android8RpcStateD1Ev; - _ZN7android8RpcStateD2Ev; - _ZN7android9BpRefBase10onFirstRefEv; - _ZN7android9BpRefBase15onLastStrongRefEPKv; - _ZN7android9BpRefBase20onIncStrongAttemptedEjPKv; - _ZN7android9BpRefBaseC1ERKNS_2spINS_7IBinderEEE; - _ZN7android9BpRefBaseC2ERKNS_2spINS_7IBinderEEE; - _ZN7android9BpRefBaseD0Ev; - _ZN7android9BpRefBaseD1Ev; - _ZN7android9BpRefBaseD2Ev; - _ZN7android9HeapCache10binderDiedERKNS_2wpINS_7IBinderEEE; - _ZN7android9HeapCache10dump_heapsEv; - _ZN7android9HeapCache8get_heapERKNS_2spINS_7IBinderEEE; - _ZN7android9HeapCache9find_heapERKNS_2spINS_7IBinderEEE; - _ZN7android9HeapCache9free_heapERKNS_2spINS_7IBinderEEE; - _ZN7android9HeapCache9free_heapERKNS_2wpINS_7IBinderEEE; - _ZN7android9HeapCacheC1Ev; - _ZN7android9HeapCacheC2Ev; - _ZN7android9HeapCacheD0Ev; - _ZN7android9HeapCacheD1Ev; - _ZN7android9HeapCacheD2Ev; - _ZN7android9hexStringEPKvm; - _ZN7android9RpcServer12listSessionsEv; - _ZN7android9RpcServer13getMaxThreadsEv; - _ZN7android9RpcServer13getRootObjectEv; - _ZN7android9RpcServer13releaseServerEv; - _ZN7android9RpcServer13setMaxThreadsEm; - _ZN7android9RpcServer13setRootObjectERKNS_2spINS_7IBinderEEE; - _ZN7android9RpcServer15setupInetServerEjPj; - _ZN7android9RpcServer16setupVsockServerEj; - _ZN7android9RpcServer17setRootObjectWeakERKNS_2wpINS_7IBinderEEE; - _ZN7android9RpcServer17setupSocketServerERKNS_16RpcSocketAddressE; - _ZN7android9RpcServer19establishConnectionEONS_2spIS0_EENS_4base14unique_fd_implINS4_13DefaultCloserEEE; - _ZN7android9RpcServer19setupExternalServerENS_4base14unique_fd_implINS1_13DefaultCloserEEE; - _ZN7android9RpcServer20onSessionTerminatingERKNS_2spINS_10RpcSessionEEE; - _ZN7android9RpcServer21setupUnixDomainServerEPKc; - _ZN7android9RpcServer24numUninitializedSessionsEv; - _ZN7android9RpcServer4joinEv; - _ZN7android9RpcServer4makeEv; - _ZN7android9RpcServer61iUnderstandThisCodeIsExperimentalAndIWillNotUseItInProductionEv; - _ZN7android9RpcServer9acceptOneEv; - _ZN7android9RpcServer9hasServerEv; - _ZN7android9RpcServerC1Ev; - _ZN7android9RpcServerC2Ev; - _ZN7android9RpcServerD0Ev; - _ZN7android9RpcServerD1Ev; - _ZN7android9RpcServerD2Ev; - _ZN7android9SingletonINS_15PermissionCacheEE11getInstanceEv; - _ZN7android9SingletonINS_15PermissionCacheEE11hasInstanceEv; - _ZN7android9SingletonINS_15PermissionCacheEE5sLockE; - _ZN7android9SingletonINS_15PermissionCacheEE9sInstanceE; - _ZN7android9SingletonINS_15PermissionCacheEEC1Ev; - _ZN7android9SingletonINS_15PermissionCacheEEC2Ev; - _ZN7android9SingletonINS_15PermissionCacheEED1Ev; - _ZN7android9SingletonINS_15PermissionCacheEED2Ev; - _ZN7androidlsERNS_10TextOutputERKNS_7HexDumpE; - _ZN7androidlsERNS_10TextOutputERKNS_8TypeCodeE; - _ZN7androidlsIA15_cEERNS_10TextOutputES3_RKT_; - _ZN7androidlsIA24_cEERNS_10TextOutputES3_RKT_; - _ZN7androidlsIA2_cEERNS_10TextOutputES3_RKT_; - _ZN7androidlsIA34_cEERNS_10TextOutputES3_RKT_; - _ZN7androidlsIA3_cEERNS_10TextOutputES3_RKT_; - _ZN7androidlsIA43_cEERNS_10TextOutputES3_RKT_; - _ZN7androidlsIA4_cEERNS_10TextOutputES3_RKT_; - _ZN7androidlsIA5_cEERNS_10TextOutputES3_RKT_; - _ZN7androidlsIA8_cEERNS_10TextOutputES3_RKT_; - _ZN7androidlsIA9_cEERNS_10TextOutputES3_RKT_; - _ZN7androidlsIjEERNS_10TextOutputES2_RKT_; - _ZN7androidlsImEERNS_10TextOutputES2_RKT_; - _ZN7androidlsINSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEEERNS_10TextOutputES9_RKT_; - _ZN7androidlsIPcEERNS_10TextOutputES3_RKT_; - _ZN7androidlsIPvEERNS_10TextOutputES3_RKT_; - _ZN7androidlsIyEERNS_10TextOutputES2_RKT_; - _ZNK7android10MemoryBase9getMemoryEPlPm; - _ZNK7android10RpcAddress13writeToParcelEPNS_6ParcelE; - _ZNK7android10RpcAddress15viewRawEmbeddedEv; - _ZNK7android10RpcAddress6isZeroEv; - _ZNK7android10RpcAddress8toStringEv; - _ZNK7android10RpcAddressltERKS0_; - _ZNK7android11IMemoryHeap22getInterfaceDescriptorEv; - _ZNK7android12BpMemoryHeap12assertMappedEv; - _ZNK7android12BpMemoryHeap18assertReallyMappedEv; - _ZNK7android12BpMemoryHeap7getBaseEv; - _ZNK7android12BpMemoryHeap7getSizeEv; - _ZNK7android12BpMemoryHeap8getFlagsEv; - _ZNK7android12BpMemoryHeap9getHeapIDEv; - _ZNK7android12BpMemoryHeap9getOffsetEv; - _ZNK7android12MemoryDealer4dumpEPKc; - _ZNK7android12MemoryDealer4heapEv; - _ZNK7android12MemoryDealer9allocatorEv; - _ZNK7android12SortedVectorINS_15PermissionCache5EntryEE10do_compareEPKvS5_; - _ZNK7android12SortedVectorINS_15PermissionCache5EntryEE10do_destroyEPvm; - _ZNK7android12SortedVectorINS_15PermissionCache5EntryEE12do_constructEPvm; - _ZNK7android12SortedVectorINS_15PermissionCache5EntryEE15do_move_forwardEPvPKvm; - _ZNK7android12SortedVectorINS_15PermissionCache5EntryEE16do_move_backwardEPvPKvm; - _ZNK7android12SortedVectorINS_15PermissionCache5EntryEE7do_copyEPvPKvm; - _ZNK7android12SortedVectorINS_15PermissionCache5EntryEE8do_splatEPvPKvm; - _ZNK7android12SortedVectorINS_16key_value_pair_tINS_2wpINS_7IBinderEEENS_9HeapCache11heap_info_tEEEE10do_compareEPKvSA_; - _ZNK7android12SortedVectorINS_16key_value_pair_tINS_2wpINS_7IBinderEEENS_9HeapCache11heap_info_tEEEE10do_destroyEPvm; - _ZNK7android12SortedVectorINS_16key_value_pair_tINS_2wpINS_7IBinderEEENS_9HeapCache11heap_info_tEEEE12do_constructEPvm; - _ZNK7android12SortedVectorINS_16key_value_pair_tINS_2wpINS_7IBinderEEENS_9HeapCache11heap_info_tEEEE15do_move_forwardEPvPKvm; - _ZNK7android12SortedVectorINS_16key_value_pair_tINS_2wpINS_7IBinderEEENS_9HeapCache11heap_info_tEEEE16do_move_backwardEPvPKvm; - _ZNK7android12SortedVectorINS_16key_value_pair_tINS_2wpINS_7IBinderEEENS_9HeapCache11heap_info_tEEEE7do_copyEPvPKvm; - _ZNK7android12SortedVectorINS_16key_value_pair_tINS_2wpINS_7IBinderEEENS_9HeapCache11heap_info_tEEEE8do_splatEPvPKvm; - _ZNK7android12SortedVectorINS_16key_value_pair_tIPKvNS_8BpBinder13ObjectManager7entry_tEEEE10do_compareES3_S3_; - _ZNK7android12SortedVectorINS_16key_value_pair_tIPKvNS_8BpBinder13ObjectManager7entry_tEEEE10do_destroyEPvm; - _ZNK7android12SortedVectorINS_16key_value_pair_tIPKvNS_8BpBinder13ObjectManager7entry_tEEEE12do_constructEPvm; - _ZNK7android12SortedVectorINS_16key_value_pair_tIPKvNS_8BpBinder13ObjectManager7entry_tEEEE15do_move_forwardEPvS3_m; - _ZNK7android12SortedVectorINS_16key_value_pair_tIPKvNS_8BpBinder13ObjectManager7entry_tEEEE16do_move_backwardEPvS3_m; - _ZNK7android12SortedVectorINS_16key_value_pair_tIPKvNS_8BpBinder13ObjectManager7entry_tEEEE7do_copyEPvS3_m; - _ZNK7android12SortedVectorINS_16key_value_pair_tIPKvNS_8BpBinder13ObjectManager7entry_tEEEE8do_splatEPvS3_m; - _ZNK7android12SortedVectorINS_8String16EE10do_compareEPKvS4_; - _ZNK7android12SortedVectorINS_8String16EE10do_destroyEPvm; - _ZNK7android12SortedVectorINS_8String16EE12do_constructEPvm; - _ZNK7android12SortedVectorINS_8String16EE15do_move_forwardEPvPKvm; - _ZNK7android12SortedVectorINS_8String16EE16do_move_backwardEPvPKvm; - _ZNK7android12SortedVectorINS_8String16EE7do_copyEPvPKvm; - _ZNK7android12SortedVectorINS_8String16EE8do_splatEPvPKvm; - _ZNK7android14IPCThreadState13getCallingPidEv; - _ZNK7android14IPCThreadState13getCallingSidEv; - _ZNK7android14IPCThreadState13getCallingUidEv; - _ZNK7android14IPCThreadState18getCallRestrictionEv; - _ZNK7android14IPCThreadState19getStrictModePolicyEv; - _ZNK7android14IPCThreadState22getServingStackPointerEv; - _ZNK7android14IPCThreadState23getCallingWorkSourceUidEv; - _ZNK7android14IPCThreadState25shouldPropagateWorkSourceEv; - _ZNK7android14IPCThreadState29getLastTransactionBinderFlagsEv; - _ZNK7android14IShellCallback22getInterfaceDescriptorEv; - _ZNK7android14MemoryHeapBase7getBaseEv; - _ZNK7android14MemoryHeapBase7getSizeEv; - _ZNK7android14MemoryHeapBase8getFlagsEv; - _ZNK7android14MemoryHeapBase9getDeviceEv; - _ZNK7android14MemoryHeapBase9getHeapIDEv; - _ZNK7android14MemoryHeapBase9getOffsetEv; - _ZNK7android15IResultReceiver22getInterfaceDescriptorEv; - _ZNK7android15IServiceManager22getInterfaceDescriptorEv; - _ZNK7android15PermissionCache5checkEPbRKNS_8String16Ej; - _ZNK7android18BufferedTextOutput9getBufferEv; - _ZNK7android18ServiceManagerShim10getServiceERKNS_8String16E; - _ZNK7android18ServiceManagerShim12checkServiceERKNS_8String16E; - _ZNK7android21IPermissionController22getInterfaceDescriptorEv; - _ZNK7android22SimpleBestFitAllocator4dumpEPKc; - _ZNK7android22SimpleBestFitAllocator4dumpERNS_7String8EPKc; - _ZNK7android22SimpleBestFitAllocator4sizeEv; - _ZNK7android22SimpleBestFitAllocator6dump_lEPKc; - _ZNK7android22SimpleBestFitAllocator6dump_lERNS_7String8EPKc; - _ZNK7android2os15IClientCallback22getInterfaceDescriptorEv; - _ZNK7android2os15IServiceManager22getInterfaceDescriptorEv; - _ZNK7android2os16IServiceCallback22getInterfaceDescriptorEv; - _ZNK7android2os16ParcelableHolder13writeToParcelEPNS_6ParcelE; - _ZNK7android2os16ServiceDebugInfo13writeToParcelEPNS_6ParcelE; - _ZNK7android2os17PersistableBundle10getBooleanERKNS_8String16EPb; - _ZNK7android2os17PersistableBundle10getIntKeysEv; - _ZNK7android2os17PersistableBundle11getLongKeysEv; - _ZNK7android2os17PersistableBundle12getIntVectorERKNS_8String16EPNSt3__16vectorIiNS5_9allocatorIiEEEE; - _ZNK7android2os17PersistableBundle13getDoubleKeysEv; - _ZNK7android2os17PersistableBundle13getLongVectorERKNS_8String16EPNSt3__16vectorIlNS5_9allocatorIlEEEE; - _ZNK7android2os17PersistableBundle13getStringKeysEv; - _ZNK7android2os17PersistableBundle13writeToParcelEPNS_6ParcelE; - _ZNK7android2os17PersistableBundle14getBooleanKeysEv; - _ZNK7android2os17PersistableBundle15getDoubleVectorERKNS_8String16EPNSt3__16vectorIdNS5_9allocatorIdEEEE; - _ZNK7android2os17PersistableBundle15getStringVectorERKNS_8String16EPNSt3__16vectorIS2_NS5_9allocatorIS2_EEEE; - _ZNK7android2os17PersistableBundle16getBooleanVectorERKNS_8String16EPNSt3__16vectorIbNS5_9allocatorIbEEEE; - _ZNK7android2os17PersistableBundle16getIntVectorKeysEv; - _ZNK7android2os17PersistableBundle17getLongVectorKeysEv; - _ZNK7android2os17PersistableBundle18writeToParcelInnerEPNS_6ParcelE; - _ZNK7android2os17PersistableBundle19getDoubleVectorKeysEv; - _ZNK7android2os17PersistableBundle19getStringVectorKeysEv; - _ZNK7android2os17PersistableBundle20getBooleanVectorKeysEv; - _ZNK7android2os17PersistableBundle20getPersistableBundleERKNS_8String16EPS1_; - _ZNK7android2os17PersistableBundle24getPersistableBundleKeysEv; - _ZNK7android2os17PersistableBundle4sizeEv; - _ZNK7android2os17PersistableBundle5emptyEv; - _ZNK7android2os17PersistableBundle6getIntERKNS_8String16EPi; - _ZNK7android2os17PersistableBundle7getLongERKNS_8String16EPl; - _ZNK7android2os17PersistableBundle9getDoubleERKNS_8String16EPd; - _ZNK7android2os17PersistableBundle9getStringERKNS_8String16EPS2_; - _ZNK7android2os20ParcelFileDescriptor13writeToParcelEPNS_6ParcelE; - _ZNK7android6binder6Status13writeToParcelEPNS_6ParcelE; - _ZNK7android6binder6Status9toString8Ev; - _ZNK7android6Parcel10errorCheckEv; - _ZNK7android6Parcel10ipcObjectsEv; - _ZNK7android6Parcel10readDoubleEPd; - _ZNK7android6Parcel10readDoubleEv; - _ZNK7android6Parcel10readObjectEb; - _ZNK7android6Parcel10readUint32EPj; - _ZNK7android6Parcel10readUint32Ev; - _ZNK7android6Parcel10readUint64EPm; - _ZNK7android6Parcel10readUint64Ev; - _ZNK7android6Parcel10scanForFdsEv; - _ZNK7android6Parcel11ipcDataSizeEv; - _ZNK7android6Parcel11readCStringEv; - _ZNK7android6Parcel11readInplaceEm; - _ZNK7android6Parcel11readPointerEPm; - _ZNK7android6Parcel11readPointerEv; - _ZNK7android6Parcel11readString8EPNS_7String8E; - _ZNK7android6Parcel11readString8Ev; - _ZNK7android6Parcel12dataCapacityEv; - _ZNK7android6Parcel12dataPositionEv; - _ZNK7android6Parcel12objectsCountEv; - _ZNK7android6Parcel12readString16EPNS_8String16E; - _ZNK7android6Parcel12readString16EPNSt3__110unique_ptrINS_8String16ENS1_14default_deleteIS3_EEEE; - _ZNK7android6Parcel12readString16EPNSt3__18optionalINS_8String16EEE; - _ZNK7android6Parcel12readString16Ev; - _ZNK7android6Parcel13markSensitiveEv; - _ZNK7android6Parcel14checkInterfaceEPNS_7IBinderE; - _ZNK7android6Parcel14readBoolVectorEPNSt3__110unique_ptrINS1_6vectorIbNS1_9allocatorIbEEEENS1_14default_deleteIS6_EEEE; - _ZNK7android6Parcel14readBoolVectorEPNSt3__16vectorIbNS1_9allocatorIbEEEE; - _ZNK7android6Parcel14readBoolVectorEPNSt3__18optionalINS1_6vectorIbNS1_9allocatorIbEEEEEE; - _ZNK7android6Parcel14readByteVectorEPNSt3__110unique_ptrINS1_6vectorIaNS1_9allocatorIaEEEENS1_14default_deleteIS6_EEEE; - _ZNK7android6Parcel14readByteVectorEPNSt3__110unique_ptrINS1_6vectorIhNS1_9allocatorIhEEEENS1_14default_deleteIS6_EEEE; - _ZNK7android6Parcel14readByteVectorEPNSt3__16vectorIaNS1_9allocatorIaEEEE; - _ZNK7android6Parcel14readByteVectorEPNSt3__16vectorIhNS1_9allocatorIhEEEE; - _ZNK7android6Parcel14readByteVectorEPNSt3__18optionalINS1_6vectorIaNS1_9allocatorIaEEEEEE; - _ZNK7android6Parcel14readByteVectorEPNSt3__18optionalINS1_6vectorIhNS1_9allocatorIhEEEEEE; - _ZNK7android6Parcel14readCharVectorEPNSt3__110unique_ptrINS1_6vectorIDsNS1_9allocatorIDsEEEENS1_14default_deleteIS6_EEEE; - _ZNK7android6Parcel14readCharVectorEPNSt3__16vectorIDsNS1_9allocatorIDsEEEE; - _ZNK7android6Parcel14readCharVectorEPNSt3__18optionalINS1_6vectorIDsNS1_9allocatorIDsEEEEEE; - _ZNK7android6Parcel14readParcelableEPNS_10ParcelableE; - _ZNK7android6Parcel15ipcObjectsCountEv; - _ZNK7android6Parcel15readFloatVectorEPNSt3__110unique_ptrINS1_6vectorIfNS1_9allocatorIfEEEENS1_14default_deleteIS6_EEEE; - _ZNK7android6Parcel15readFloatVectorEPNSt3__16vectorIfNS1_9allocatorIfEEEE; - _ZNK7android6Parcel15readFloatVectorEPNSt3__18optionalINS1_6vectorIfNS1_9allocatorIfEEEEEE; - _ZNK7android6Parcel15readInt32VectorEPNSt3__110unique_ptrINS1_6vectorIiNS1_9allocatorIiEEEENS1_14default_deleteIS6_EEEE; - _ZNK7android6Parcel15readInt32VectorEPNSt3__16vectorIiNS1_9allocatorIiEEEE; - _ZNK7android6Parcel15readInt32VectorEPNSt3__18optionalINS1_6vectorIiNS1_9allocatorIiEEEEEE; - _ZNK7android6Parcel15readInt64VectorEPNSt3__110unique_ptrINS1_6vectorIlNS1_9allocatorIlEEEENS1_14default_deleteIS6_EEEE; - _ZNK7android6Parcel15readInt64VectorEPNSt3__16vectorIlNS1_9allocatorIlEEEE; - _ZNK7android6Parcel15readInt64VectorEPNSt3__18optionalINS1_6vectorIlNS1_9allocatorIlEEEEEE; - _ZNK7android6Parcel15setDataPositionEm; - _ZNK7android6Parcel15unflattenBinderEPNS_2spINS_7IBinderEEE; - _ZNK7android6Parcel16enforceInterfaceEPKDsmPNS_14IPCThreadStateE; - _ZNK7android6Parcel16enforceInterfaceERKNS_8String16EPNS_14IPCThreadStateE; - _ZNK7android6Parcel16readDoubleVectorEPNSt3__110unique_ptrINS1_6vectorIdNS1_9allocatorIdEEEENS1_14default_deleteIS6_EEEE; - _ZNK7android6Parcel16readDoubleVectorEPNSt3__16vectorIdNS1_9allocatorIdEEEE; - _ZNK7android6Parcel16readDoubleVectorEPNSt3__18optionalINS1_6vectorIdNS1_9allocatorIdEEEEEE; - _ZNK7android6Parcel16readNativeHandleEv; - _ZNK7android6Parcel16readStrongBinderEPNS_2spINS_7IBinderEEE; - _ZNK7android6Parcel16readStrongBinderEv; - _ZNK7android6Parcel16readStrongBinderINS_2os15IClientCallbackEEEiPNS_2spIT_EE; - _ZNK7android6Parcel16readStrongBinderINS_2os16IServiceCallbackEEEiPNS_2spIT_EE; - _ZNK7android6Parcel16readStrongBinderINS_7content2pm22IPackageChangeObserverEEEiPNS_2spIT_EE; - _ZNK7android6Parcel16readUint64VectorEPNSt3__110unique_ptrINS1_6vectorImNS1_9allocatorImEEEENS1_14default_deleteIS6_EEEE; - _ZNK7android6Parcel16readUint64VectorEPNSt3__16vectorImNS1_9allocatorImEEEE; - _ZNK7android6Parcel16readUint64VectorEPNSt3__18optionalINS1_6vectorImNS1_9allocatorImEEEEEE; - _ZNK7android6Parcel16validateReadDataEm; - _ZNK7android6Parcel17getBlobAshmemSizeEv; - _ZNK7android6Parcel17getOpenAshmemSizeEv; - _ZNK7android6Parcel17readExceptionCodeEv; - _ZNK7android6Parcel17readUtf8FromUtf16EPNSt3__110unique_ptrINS1_12basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEENS1_14default_deleteIS8_EEEE; - _ZNK7android6Parcel17readUtf8FromUtf16EPNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEE; - _ZNK7android6Parcel17readUtf8FromUtf16EPNSt3__18optionalINS1_12basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEEE; - _ZNK7android6Parcel18hasFileDescriptorsEv; - _ZNK7android6Parcel18readFileDescriptorEv; - _ZNK7android6Parcel18readString16VectorEPNSt3__110unique_ptrINS1_6vectorINS2_INS_8String16ENS1_14default_deleteIS4_EEEENS1_9allocatorIS7_EEEENS5_ISA_EEEE; - _ZNK7android6Parcel18readString16VectorEPNSt3__16vectorINS_8String16ENS1_9allocatorIS3_EEEE; - _ZNK7android6Parcel18readString16VectorEPNSt3__18optionalINS1_6vectorINS2_INS_8String16EEENS1_9allocatorIS5_EEEEEE; - _ZNK7android6Parcel18readString8InplaceEPm; - _ZNK7android6Parcel19readString16InplaceEPm; - _ZNK7android6Parcel21finishUnflattenBinderERKNS_2spINS_7IBinderEEEPS3_; - _ZNK7android6Parcel22readStrongBinderVectorEPNSt3__110unique_ptrINS1_6vectorINS_2spINS_7IBinderEEENS1_9allocatorIS6_EEEENS1_14default_deleteIS9_EEEE; - _ZNK7android6Parcel22readStrongBinderVectorEPNSt3__16vectorINS_2spINS_7IBinderEEENS1_9allocatorIS5_EEEE; - _ZNK7android6Parcel22readStrongBinderVectorEPNSt3__18optionalINS1_6vectorINS_2spINS_7IBinderEEENS1_9allocatorIS6_EEEEEE; - _ZNK7android6Parcel24readCallingWorkSourceUidEv; - _ZNK7android6Parcel24readNullableStrongBinderEPNS_2spINS_7IBinderEEE; - _ZNK7android6Parcel24readParcelFileDescriptorEv; - _ZNK7android6Parcel24readUniqueFileDescriptorEPNS_4base14unique_fd_implINS1_13DefaultCloserEEE; - _ZNK7android6Parcel29readUtf8VectorFromUtf16VectorEPNSt3__110unique_ptrINS1_6vectorINS2_INS1_12basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEENS1_14default_deleteIS9_EEEENS7_ISC_EEEENSA_ISE_EEEE; - _ZNK7android6Parcel29readUtf8VectorFromUtf16VectorEPNSt3__16vectorINS1_12basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEENS6_IS8_EEEE; - _ZNK7android6Parcel29readUtf8VectorFromUtf16VectorEPNSt3__18optionalINS1_6vectorINS2_INS1_12basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEEENS7_ISA_EEEEEE; - _ZNK7android6Parcel30readUniqueFileDescriptorVectorEPNSt3__110unique_ptrINS1_6vectorINS_4base14unique_fd_implINS4_13DefaultCloserEEENS1_9allocatorIS7_EEEENS1_14default_deleteISA_EEEE; - _ZNK7android6Parcel30readUniqueFileDescriptorVectorEPNSt3__16vectorINS_4base14unique_fd_implINS3_13DefaultCloserEEENS1_9allocatorIS6_EEEE; - _ZNK7android6Parcel30readUniqueFileDescriptorVectorEPNSt3__18optionalINS1_6vectorINS_4base14unique_fd_implINS4_13DefaultCloserEEENS1_9allocatorIS7_EEEEEE; - _ZNK7android6Parcel30readUniqueParcelFileDescriptorEPNS_4base14unique_fd_implINS1_13DefaultCloserEEE; - _ZNK7android6Parcel37updateWorkSourceRequestHeaderPositionEv; - _ZNK7android6Parcel4dataEv; - _ZNK7android6Parcel4readEPvm; - _ZNK7android6Parcel4readERNS0_26FlattenableHelperInterfaceE; - _ZNK7android6Parcel5printERNS_10TextOutputEj; - _ZNK7android6Parcel7ipcDataEv; - _ZNK7android6Parcel8allowFdsEv; - _ZNK7android6Parcel8dataSizeEv; - _ZNK7android6Parcel8isForRpcEv; - _ZNK7android6Parcel8readBlobEmPNS0_12ReadableBlobE; - _ZNK7android6Parcel8readBoolEPb; - _ZNK7android6Parcel8readBoolEv; - _ZNK7android6Parcel8readByteEPa; - _ZNK7android6Parcel8readByteEv; - _ZNK7android6Parcel8readCharEPDs; - _ZNK7android6Parcel8readCharEv; - _ZNK7android6Parcel9dataAvailEv; - _ZNK7android6Parcel9readFloatEPf; - _ZNK7android6Parcel9readFloatEv; - _ZNK7android6Parcel9readInt32EPi; - _ZNK7android6Parcel9readInt32Ev; - _ZNK7android6Parcel9readInt64EPl; - _ZNK7android6Parcel9readInt64Ev; - _ZNK7android6VectorIiE10do_destroyEPvm; - _ZNK7android6VectorIiE12do_constructEPvm; - _ZNK7android6VectorIiE15do_move_forwardEPvPKvm; - _ZNK7android6VectorIiE16do_move_backwardEPvPKvm; - _ZNK7android6VectorIiE7do_copyEPvPKvm; - _ZNK7android6VectorIiE8do_splatEPvPKvm; - _ZNK7android6VectorINS_12ProcessState12handle_entryEE10do_destroyEPvm; - _ZNK7android6VectorINS_12ProcessState12handle_entryEE12do_constructEPvm; - _ZNK7android6VectorINS_12ProcessState12handle_entryEE15do_move_forwardEPvPKvm; - _ZNK7android6VectorINS_12ProcessState12handle_entryEE16do_move_backwardEPvPKvm; - _ZNK7android6VectorINS_12ProcessState12handle_entryEE7do_copyEPvPKvm; - _ZNK7android6VectorINS_12ProcessState12handle_entryEE8do_splatEPvPKvm; - _ZNK7android6VectorINS_2spINS_18BufferedTextOutput11BufferStateEEEE10do_destroyEPvm; - _ZNK7android6VectorINS_2spINS_18BufferedTextOutput11BufferStateEEEE12do_constructEPvm; - _ZNK7android6VectorINS_2spINS_18BufferedTextOutput11BufferStateEEEE15do_move_forwardEPvPKvm; - _ZNK7android6VectorINS_2spINS_18BufferedTextOutput11BufferStateEEEE16do_move_backwardEPvPKvm; - _ZNK7android6VectorINS_2spINS_18BufferedTextOutput11BufferStateEEEE7do_copyEPvPKvm; - _ZNK7android6VectorINS_2spINS_18BufferedTextOutput11BufferStateEEEE8do_splatEPvPKvm; - _ZNK7android6VectorINS_8BpBinder8ObituaryEE10do_destroyEPvm; - _ZNK7android6VectorINS_8BpBinder8ObituaryEE12do_constructEPvm; - _ZNK7android6VectorINS_8BpBinder8ObituaryEE15do_move_forwardEPvPKvm; - _ZNK7android6VectorINS_8BpBinder8ObituaryEE16do_move_backwardEPvPKvm; - _ZNK7android6VectorINS_8BpBinder8ObituaryEE7do_copyEPvPKvm; - _ZNK7android6VectorINS_8BpBinder8ObituaryEE8do_splatEPvPKvm; - _ZNK7android6VectorINS_8String16EE10do_destroyEPvm; - _ZNK7android6VectorINS_8String16EE12do_constructEPvm; - _ZNK7android6VectorINS_8String16EE15do_move_forwardEPvPKvm; - _ZNK7android6VectorINS_8String16EE16do_move_backwardEPvPKvm; - _ZNK7android6VectorINS_8String16EE7do_copyEPvPKvm; - _ZNK7android6VectorINS_8String16EE8do_splatEPvPKvm; - _ZNK7android6VectorIPNS_7BBinderEE10do_destroyEPvm; - _ZNK7android6VectorIPNS_7BBinderEE12do_constructEPvm; - _ZNK7android6VectorIPNS_7BBinderEE15do_move_forwardEPvPKvm; - _ZNK7android6VectorIPNS_7BBinderEE16do_move_backwardEPvPKvm; - _ZNK7android6VectorIPNS_7BBinderEE7do_copyEPvPKvm; - _ZNK7android6VectorIPNS_7BBinderEE8do_splatEPvPKvm; - _ZNK7android6VectorIPNS_7RefBase12weakref_typeEE10do_destroyEPvm; - _ZNK7android6VectorIPNS_7RefBase12weakref_typeEE12do_constructEPvm; - _ZNK7android6VectorIPNS_7RefBase12weakref_typeEE15do_move_forwardEPvPKvm; - _ZNK7android6VectorIPNS_7RefBase12weakref_typeEE16do_move_backwardEPvPKvm; - _ZNK7android6VectorIPNS_7RefBase12weakref_typeEE7do_copyEPvPKvm; - _ZNK7android6VectorIPNS_7RefBase12weakref_typeEE8do_splatEPvPKvm; - _ZNK7android6VectorIPNS_7RefBaseEE10do_destroyEPvm; - _ZNK7android6VectorIPNS_7RefBaseEE12do_constructEPvm; - _ZNK7android6VectorIPNS_7RefBaseEE15do_move_forwardEPvPKvm; - _ZNK7android6VectorIPNS_7RefBaseEE16do_move_backwardEPvPKvm; - _ZNK7android6VectorIPNS_7RefBaseEE7do_copyEPvPKvm; - _ZNK7android6VectorIPNS_7RefBaseEE8do_splatEPvPKvm; - _ZNK7android7BBinder10findObjectEPKv; - _ZNK7android7BBinder13isBinderAliveEv; - _ZNK7android7BBinder22getInterfaceDescriptorEv; - _ZNK7android7content2pm18PackageChangeEvent13writeToParcelEPNS_6ParcelE; - _ZNK7android7content2pm21IPackageManagerNative22getInterfaceDescriptorEv; - _ZNK7android7content2pm22IPackageChangeObserver22getInterfaceDescriptorEv; - _ZNK7android7IBinder13checkSubclassEPKv; - _ZNK7android7IMemory11fastPointerERKNS_2spINS_7IBinderEEEl; - _ZNK7android7IMemory15unsecurePointerEv; - _ZNK7android7IMemory22getInterfaceDescriptorEv; - _ZNK7android7IMemory4sizeEv; - _ZNK7android7IMemory6offsetEv; - _ZNK7android7IMemory7pointerEv; - _ZNK7android8BpBinder10findObjectEPKv; - _ZNK7android8BpBinder10rpcAddressEv; - _ZNK7android8BpBinder10rpcSessionEv; - _ZNK7android8BpBinder11isRpcBinderEv; - _ZNK7android8BpBinder12binderHandleEv; - _ZNK7android8BpBinder13isBinderAliveEv; - _ZNK7android8BpBinder13ObjectManager4findEPKv; - _ZNK7android8BpBinder18isDescriptorCachedEv; - _ZNK7android8BpBinder22getInterfaceDescriptorEv; - _ZNK7android8BpMemory9getMemoryEPlPm; - _ZNKSt3__115basic_stringbufIcNS_11char_traitsIcEENS_9allocatorIcEEE3strEv; - _ZNKSt3__16__treeINS_12__value_typeIN7android8String16EbEENS_19__map_value_compareIS3_S4_NS_4lessIS3_EELb1EEENS_9allocatorIS4_EEE4findIS3_EENS_21__tree_const_iteratorIS4_PNS_11__tree_nodeIS4_PvEElEERKT_; - _ZNKSt3__16__treeINS_12__value_typeIN7android8String16EdEENS_19__map_value_compareIS3_S4_NS_4lessIS3_EELb1EEENS_9allocatorIS4_EEE4findIS3_EENS_21__tree_const_iteratorIS4_PNS_11__tree_nodeIS4_PvEElEERKT_; - _ZNKSt3__16__treeINS_12__value_typeIN7android8String16EiEENS_19__map_value_compareIS3_S4_NS_4lessIS3_EELb1EEENS_9allocatorIS4_EEE4findIS3_EENS_21__tree_const_iteratorIS4_PNS_11__tree_nodeIS4_PvEElEERKT_; - _ZNKSt3__16__treeINS_12__value_typeIN7android8String16ElEENS_19__map_value_compareIS3_S4_NS_4lessIS3_EELb1EEENS_9allocatorIS4_EEE4findIS3_EENS_21__tree_const_iteratorIS4_PNS_11__tree_nodeIS4_PvEElEERKT_; - _ZNKSt3__16__treeINS_12__value_typeIN7android8String16ENS2_2os17PersistableBundleEEENS_19__map_value_compareIS3_S6_NS_4lessIS3_EELb1EEENS_9allocatorIS6_EEE4findIS3_EENS_21__tree_const_iteratorIS6_PNS_11__tree_nodeIS6_PvEElEERKT_; - _ZNKSt3__16__treeINS_12__value_typeIN7android8String16ENS_6vectorIbNS_9allocatorIbEEEEEENS_19__map_value_compareIS3_S8_NS_4lessIS3_EELb1EEENS5_IS8_EEE4findIS3_EENS_21__tree_const_iteratorIS8_PNS_11__tree_nodeIS8_PvEElEERKT_; - _ZNKSt3__16__treeINS_12__value_typeIN7android8String16ENS_6vectorIdNS_9allocatorIdEEEEEENS_19__map_value_compareIS3_S8_NS_4lessIS3_EELb1EEENS5_IS8_EEE4findIS3_EENS_21__tree_const_iteratorIS8_PNS_11__tree_nodeIS8_PvEElEERKT_; - _ZNKSt3__16__treeINS_12__value_typeIN7android8String16ENS_6vectorIiNS_9allocatorIiEEEEEENS_19__map_value_compareIS3_S8_NS_4lessIS3_EELb1EEENS5_IS8_EEE4findIS3_EENS_21__tree_const_iteratorIS8_PNS_11__tree_nodeIS8_PvEElEERKT_; - _ZNKSt3__16__treeINS_12__value_typeIN7android8String16ENS_6vectorIlNS_9allocatorIlEEEEEENS_19__map_value_compareIS3_S8_NS_4lessIS3_EELb1EEENS5_IS8_EEE4findIS3_EENS_21__tree_const_iteratorIS8_PNS_11__tree_nodeIS8_PvEElEERKT_; - _ZNKSt3__16__treeINS_12__value_typeIN7android8String16ENS_6vectorIS3_NS_9allocatorIS3_EEEEEENS_19__map_value_compareIS3_S8_NS_4lessIS3_EELb1EEENS5_IS8_EEE4findIS3_EENS_21__tree_const_iteratorIS8_PNS_11__tree_nodeIS8_PvEElEERKT_; - _ZNKSt3__16__treeINS_12__value_typeIN7android8String16ES3_EENS_19__map_value_compareIS3_S4_NS_4lessIS3_EELb1EEENS_9allocatorIS4_EEE4findIS3_EENS_21__tree_const_iteratorIS4_PNS_11__tree_nodeIS4_PvEElEERKT_; - _ZNSt3__111__sift_downIRNS_4lessIN7android8RpcState10BinderNode9AsyncTodoEEENS_11__wrap_iterIPS5_EEEEvT0_SB_T_NS_15iterator_traitsISB_E15difference_typeESB_; - _ZNSt3__111unique_lockINS_5mutexEE6unlockEv; - _ZNSt3__112__hash_tableINS_17__hash_value_typeIijEENS_22__unordered_map_hasherIiS2_NS_4hashIiEELb1EEENS_21__unordered_map_equalIiS2_NS_8equal_toIiEELb1EEENS_9allocatorIS2_EEE14__erase_uniqueIiEEmRKT_; - _ZNSt3__112__hash_tableINS_17__hash_value_typeIijEENS_22__unordered_map_hasherIiS2_NS_4hashIiEELb1EEENS_21__unordered_map_equalIiS2_NS_8equal_toIiEELb1EEENS_9allocatorIS2_EEE25__emplace_unique_key_argsIiJRKNS_21piecewise_construct_tENS_5tupleIJRKiEEENSI_IJEEEEEENS_4pairINS_15__hash_iteratorIPNS_11__hash_nodeIS2_PvEEEEbEERKT_DpOT0_; - _ZNSt3__112__hash_tableINS_17__hash_value_typeIijEENS_22__unordered_map_hasherIiS2_NS_4hashIiEELb1EEENS_21__unordered_map_equalIiS2_NS_8equal_toIiEELb1EEENS_9allocatorIS2_EEE6rehashEm; - _ZNSt3__112__hash_tableINS_17__hash_value_typeIijEENS_22__unordered_map_hasherIiS2_NS_4hashIiEELb1EEENS_21__unordered_map_equalIiS2_NS_8equal_toIiEELb1EEENS_9allocatorIS2_EEE6removeENS_21__hash_const_iteratorIPNS_11__hash_nodeIS2_PvEEEE; - _ZNSt3__112__hash_tableINS_17__hash_value_typeIijEENS_22__unordered_map_hasherIiS2_NS_4hashIiEELb1EEENS_21__unordered_map_equalIiS2_NS_8equal_toIiEELb1EEENS_9allocatorIS2_EEE8__rehashEm; - _ZNSt3__113__tree_removeIPNS_16__tree_node_baseIPvEEEEvT_S5_; - _ZNSt3__114__copy_alignedINS_6vectorIbNS_9allocatorIbEEEELb0EEENS_14__bit_iteratorIT_Lb0EXLi0EEEENS5_IS6_XT0_EXLi0EEEES8_S7_; - _ZNSt3__114__copy_alignedINS_6vectorIbNS_9allocatorIbEEEELb1EEENS_14__bit_iteratorIT_Lb0EXLi0EEEENS5_IS6_XT0_EXLi0EEEES8_S7_; - _ZNSt3__114__thread_proxyINS_5tupleIJNS_10unique_ptrINS_15__thread_structENS_14default_deleteIS3_EEEEMN7android9RpcServerEFvONS7_2spIS8_EENS7_4base14unique_fd_implINSC_13DefaultCloserEEEEPS8_SA_SF_EEEEEPvSK_; - _ZNSt3__115basic_stringbufIcNS_11char_traitsIcEENS_9allocatorIcEEE7seekoffExNS_8ios_base7seekdirEj; - _ZNSt3__115basic_stringbufIcNS_11char_traitsIcEENS_9allocatorIcEEE8overflowEi; - _ZNSt3__115basic_stringbufIcNS_11char_traitsIcEENS_9allocatorIcEEE9pbackfailEi; - _ZNSt3__115basic_stringbufIcNS_11char_traitsIcEENS_9allocatorIcEEE9underflowEv; - _ZNSt3__116__copy_unalignedINS_6vectorIbNS_9allocatorIbEEEELb0EEENS_14__bit_iteratorIT_Lb0EXLi0EEEENS5_IS6_XT0_EXLi0EEEES8_S7_; - _ZNSt3__116__copy_unalignedINS_6vectorIbNS_9allocatorIbEEEELb1EEENS_14__bit_iteratorIT_Lb0EXLi0EEEENS5_IS6_XT0_EXLi0EEEES8_S7_; - _ZNSt3__120__shared_ptr_emplaceIN7android14RpcWireAddressENS_9allocatorIS2_EEE16__on_zero_sharedEv; - _ZNSt3__120__shared_ptr_emplaceIN7android14RpcWireAddressENS_9allocatorIS2_EEE21__on_zero_shared_weakEv; - _ZNSt3__120__shared_ptr_emplaceIN7android6binder8internal21ClientCounterCallbackENS_9allocatorIS4_EEE16__on_zero_sharedEv; - _ZNSt3__120__shared_ptr_emplaceIN7android6binder8internal21ClientCounterCallbackENS_9allocatorIS4_EEE21__on_zero_shared_weakEv; - _ZNSt3__124__put_character_sequenceIcNS_11char_traitsIcEEEERNS_13basic_ostreamIT_T0_EES7_PKS4_m; - _ZNSt3__127__tree_balance_after_insertIPNS_16__tree_node_baseIPvEEEEvT_S5_; - _ZNSt3__16__treeIN7android8String16ENS_4lessIS2_EENS_9allocatorIS2_EEE12__find_equalIS2_EERPNS_16__tree_node_baseIPvEERPNS_15__tree_end_nodeISC_EERKT_; - _ZNSt3__16__treeIN7android8String16ENS_4lessIS2_EENS_9allocatorIS2_EEE25__emplace_unique_key_argsIS2_JRKS2_EEENS_4pairINS_15__tree_iteratorIS2_PNS_11__tree_nodeIS2_PvEElEEbEERKT_DpOT0_; - _ZNSt3__16__treeIN7android8String16ENS_4lessIS2_EENS_9allocatorIS2_EEE7destroyEPNS_11__tree_nodeIS2_PvEE; - _ZNSt3__16__treeINS_12__value_typeIiN7android2spINS2_10RpcSessionEEEEENS_19__map_value_compareIiS6_NS_4lessIiEELb1EEENS_9allocatorIS6_EEE5eraseENS_21__tree_const_iteratorIS6_PNS_11__tree_nodeIS6_PvEElEE; - _ZNSt3__16__treeINS_12__value_typeIiN7android2spINS2_10RpcSessionEEEEENS_19__map_value_compareIiS6_NS_4lessIiEELb1EEENS_9allocatorIS6_EEE7destroyEPNS_11__tree_nodeIS6_PvEE; - _ZNSt3__16__treeINS_12__value_typeIN7android10RpcAddressENS2_8RpcState10BinderNodeEEENS_19__map_value_compareIS3_S6_NS_4lessIS3_EELb1EEENS_9allocatorIS6_EEE25__emplace_unique_key_argsIS3_JNS_4pairIKS3_S5_EEEEENSF_INS_15__tree_iteratorIS6_PNS_11__tree_nodeIS6_PvEElEEbEERKT_DpOT0_; - _ZNSt3__16__treeINS_12__value_typeIN7android10RpcAddressENS2_8RpcState10BinderNodeEEENS_19__map_value_compareIS3_S6_NS_4lessIS3_EELb1EEENS_9allocatorIS6_EEE7destroyEPNS_11__tree_nodeIS6_PvEE; - _ZNSt3__16__treeINS_12__value_typeIN7android8String16EbEENS_19__map_value_compareIS3_S4_NS_4lessIS3_EELb1EEENS_9allocatorIS4_EEE12__find_equalIS3_EERPNS_16__tree_node_baseIPvEENS_21__tree_const_iteratorIS4_PNS_11__tree_nodeIS4_SE_EElEERPNS_15__tree_end_nodeISG_EESH_RKT_; - _ZNSt3__16__treeINS_12__value_typeIN7android8String16EbEENS_19__map_value_compareIS3_S4_NS_4lessIS3_EELb1EEENS_9allocatorIS4_EEE12__find_equalIS3_EERPNS_16__tree_node_baseIPvEERPNS_15__tree_end_nodeISG_EERKT_; - _ZNSt3__16__treeINS_12__value_typeIN7android8String16EbEENS_19__map_value_compareIS3_S4_NS_4lessIS3_EELb1EEENS_9allocatorIS4_EEE14__assign_multiINS_21__tree_const_iteratorIS4_PNS_11__tree_nodeIS4_PvEElEEEEvT_SJ_; - _ZNSt3__16__treeINS_12__value_typeIN7android8String16EbEENS_19__map_value_compareIS3_S4_NS_4lessIS3_EELb1EEENS_9allocatorIS4_EEE15__emplace_multiIJRKNS_4pairIKS3_bEEEEENS_15__tree_iteratorIS4_PNS_11__tree_nodeIS4_PvEElEEDpOT_; - _ZNSt3__16__treeINS_12__value_typeIN7android8String16EbEENS_19__map_value_compareIS3_S4_NS_4lessIS3_EELb1EEENS_9allocatorIS4_EEE25__emplace_unique_key_argsIS3_JRKNS_21piecewise_construct_tENS_5tupleIJRKS3_EEENSG_IJEEEEEENS_4pairINS_15__tree_iteratorIS4_PNS_11__tree_nodeIS4_PvEElEEbEERKT_DpOT0_; - _ZNSt3__16__treeINS_12__value_typeIN7android8String16EbEENS_19__map_value_compareIS3_S4_NS_4lessIS3_EELb1EEENS_9allocatorIS4_EEE30__emplace_hint_unique_key_argsIS3_JRKNS_4pairIKS3_bEEEEENS_15__tree_iteratorIS4_PNS_11__tree_nodeIS4_PvEElEENS_21__tree_const_iteratorIS4_SM_lEERKT_DpOT0_; - _ZNSt3__16__treeINS_12__value_typeIN7android8String16EbEENS_19__map_value_compareIS3_S4_NS_4lessIS3_EELb1EEENS_9allocatorIS4_EEE4findIS3_EENS_15__tree_iteratorIS4_PNS_11__tree_nodeIS4_PvEElEERKT_; - _ZNSt3__16__treeINS_12__value_typeIN7android8String16EbEENS_19__map_value_compareIS3_S4_NS_4lessIS3_EELb1EEENS_9allocatorIS4_EEE7destroyEPNS_11__tree_nodeIS4_PvEE; - _ZNSt3__16__treeINS_12__value_typeIN7android8String16EdEENS_19__map_value_compareIS3_S4_NS_4lessIS3_EELb1EEENS_9allocatorIS4_EEE12__find_equalIS3_EERPNS_16__tree_node_baseIPvEENS_21__tree_const_iteratorIS4_PNS_11__tree_nodeIS4_SE_EElEERPNS_15__tree_end_nodeISG_EESH_RKT_; - _ZNSt3__16__treeINS_12__value_typeIN7android8String16EdEENS_19__map_value_compareIS3_S4_NS_4lessIS3_EELb1EEENS_9allocatorIS4_EEE12__find_equalIS3_EERPNS_16__tree_node_baseIPvEERPNS_15__tree_end_nodeISG_EERKT_; - _ZNSt3__16__treeINS_12__value_typeIN7android8String16EdEENS_19__map_value_compareIS3_S4_NS_4lessIS3_EELb1EEENS_9allocatorIS4_EEE14__assign_multiINS_21__tree_const_iteratorIS4_PNS_11__tree_nodeIS4_PvEElEEEEvT_SJ_; - _ZNSt3__16__treeINS_12__value_typeIN7android8String16EdEENS_19__map_value_compareIS3_S4_NS_4lessIS3_EELb1EEENS_9allocatorIS4_EEE15__emplace_multiIJRKNS_4pairIKS3_dEEEEENS_15__tree_iteratorIS4_PNS_11__tree_nodeIS4_PvEElEEDpOT_; - _ZNSt3__16__treeINS_12__value_typeIN7android8String16EdEENS_19__map_value_compareIS3_S4_NS_4lessIS3_EELb1EEENS_9allocatorIS4_EEE25__emplace_unique_key_argsIS3_JRKNS_21piecewise_construct_tENS_5tupleIJRKS3_EEENSG_IJEEEEEENS_4pairINS_15__tree_iteratorIS4_PNS_11__tree_nodeIS4_PvEElEEbEERKT_DpOT0_; - _ZNSt3__16__treeINS_12__value_typeIN7android8String16EdEENS_19__map_value_compareIS3_S4_NS_4lessIS3_EELb1EEENS_9allocatorIS4_EEE30__emplace_hint_unique_key_argsIS3_JRKNS_4pairIKS3_dEEEEENS_15__tree_iteratorIS4_PNS_11__tree_nodeIS4_PvEElEENS_21__tree_const_iteratorIS4_SM_lEERKT_DpOT0_; - _ZNSt3__16__treeINS_12__value_typeIN7android8String16EdEENS_19__map_value_compareIS3_S4_NS_4lessIS3_EELb1EEENS_9allocatorIS4_EEE4findIS3_EENS_15__tree_iteratorIS4_PNS_11__tree_nodeIS4_PvEElEERKT_; - _ZNSt3__16__treeINS_12__value_typeIN7android8String16EdEENS_19__map_value_compareIS3_S4_NS_4lessIS3_EELb1EEENS_9allocatorIS4_EEE7destroyEPNS_11__tree_nodeIS4_PvEE; - _ZNSt3__16__treeINS_12__value_typeIN7android8String16EiEENS_19__map_value_compareIS3_S4_NS_4lessIS3_EELb1EEENS_9allocatorIS4_EEE12__find_equalIS3_EERPNS_16__tree_node_baseIPvEENS_21__tree_const_iteratorIS4_PNS_11__tree_nodeIS4_SE_EElEERPNS_15__tree_end_nodeISG_EESH_RKT_; - _ZNSt3__16__treeINS_12__value_typeIN7android8String16EiEENS_19__map_value_compareIS3_S4_NS_4lessIS3_EELb1EEENS_9allocatorIS4_EEE12__find_equalIS3_EERPNS_16__tree_node_baseIPvEERPNS_15__tree_end_nodeISG_EERKT_; - _ZNSt3__16__treeINS_12__value_typeIN7android8String16EiEENS_19__map_value_compareIS3_S4_NS_4lessIS3_EELb1EEENS_9allocatorIS4_EEE14__assign_multiINS_21__tree_const_iteratorIS4_PNS_11__tree_nodeIS4_PvEElEEEEvT_SJ_; - _ZNSt3__16__treeINS_12__value_typeIN7android8String16EiEENS_19__map_value_compareIS3_S4_NS_4lessIS3_EELb1EEENS_9allocatorIS4_EEE15__emplace_multiIJRKNS_4pairIKS3_iEEEEENS_15__tree_iteratorIS4_PNS_11__tree_nodeIS4_PvEElEEDpOT_; - _ZNSt3__16__treeINS_12__value_typeIN7android8String16EiEENS_19__map_value_compareIS3_S4_NS_4lessIS3_EELb1EEENS_9allocatorIS4_EEE25__emplace_unique_key_argsIS3_JRKNS_21piecewise_construct_tENS_5tupleIJRKS3_EEENSG_IJEEEEEENS_4pairINS_15__tree_iteratorIS4_PNS_11__tree_nodeIS4_PvEElEEbEERKT_DpOT0_; - _ZNSt3__16__treeINS_12__value_typeIN7android8String16EiEENS_19__map_value_compareIS3_S4_NS_4lessIS3_EELb1EEENS_9allocatorIS4_EEE30__emplace_hint_unique_key_argsIS3_JRKNS_4pairIKS3_iEEEEENS_15__tree_iteratorIS4_PNS_11__tree_nodeIS4_PvEElEENS_21__tree_const_iteratorIS4_SM_lEERKT_DpOT0_; - _ZNSt3__16__treeINS_12__value_typeIN7android8String16EiEENS_19__map_value_compareIS3_S4_NS_4lessIS3_EELb1EEENS_9allocatorIS4_EEE4findIS3_EENS_15__tree_iteratorIS4_PNS_11__tree_nodeIS4_PvEElEERKT_; - _ZNSt3__16__treeINS_12__value_typeIN7android8String16EiEENS_19__map_value_compareIS3_S4_NS_4lessIS3_EELb1EEENS_9allocatorIS4_EEE7destroyEPNS_11__tree_nodeIS4_PvEE; - _ZNSt3__16__treeINS_12__value_typeIN7android8String16ElEENS_19__map_value_compareIS3_S4_NS_4lessIS3_EELb1EEENS_9allocatorIS4_EEE12__find_equalIS3_EERPNS_16__tree_node_baseIPvEENS_21__tree_const_iteratorIS4_PNS_11__tree_nodeIS4_SE_EElEERPNS_15__tree_end_nodeISG_EESH_RKT_; - _ZNSt3__16__treeINS_12__value_typeIN7android8String16ElEENS_19__map_value_compareIS3_S4_NS_4lessIS3_EELb1EEENS_9allocatorIS4_EEE12__find_equalIS3_EERPNS_16__tree_node_baseIPvEERPNS_15__tree_end_nodeISG_EERKT_; - _ZNSt3__16__treeINS_12__value_typeIN7android8String16ElEENS_19__map_value_compareIS3_S4_NS_4lessIS3_EELb1EEENS_9allocatorIS4_EEE14__assign_multiINS_21__tree_const_iteratorIS4_PNS_11__tree_nodeIS4_PvEElEEEEvT_SJ_; - _ZNSt3__16__treeINS_12__value_typeIN7android8String16ElEENS_19__map_value_compareIS3_S4_NS_4lessIS3_EELb1EEENS_9allocatorIS4_EEE15__emplace_multiIJRKNS_4pairIKS3_lEEEEENS_15__tree_iteratorIS4_PNS_11__tree_nodeIS4_PvEElEEDpOT_; - _ZNSt3__16__treeINS_12__value_typeIN7android8String16ElEENS_19__map_value_compareIS3_S4_NS_4lessIS3_EELb1EEENS_9allocatorIS4_EEE25__emplace_unique_key_argsIS3_JRKNS_21piecewise_construct_tENS_5tupleIJRKS3_EEENSG_IJEEEEEENS_4pairINS_15__tree_iteratorIS4_PNS_11__tree_nodeIS4_PvEElEEbEERKT_DpOT0_; - _ZNSt3__16__treeINS_12__value_typeIN7android8String16ElEENS_19__map_value_compareIS3_S4_NS_4lessIS3_EELb1EEENS_9allocatorIS4_EEE30__emplace_hint_unique_key_argsIS3_JRKNS_4pairIKS3_lEEEEENS_15__tree_iteratorIS4_PNS_11__tree_nodeIS4_PvEElEENS_21__tree_const_iteratorIS4_SM_lEERKT_DpOT0_; - _ZNSt3__16__treeINS_12__value_typeIN7android8String16ElEENS_19__map_value_compareIS3_S4_NS_4lessIS3_EELb1EEENS_9allocatorIS4_EEE4findIS3_EENS_15__tree_iteratorIS4_PNS_11__tree_nodeIS4_PvEElEERKT_; - _ZNSt3__16__treeINS_12__value_typeIN7android8String16ElEENS_19__map_value_compareIS3_S4_NS_4lessIS3_EELb1EEENS_9allocatorIS4_EEE7destroyEPNS_11__tree_nodeIS4_PvEE; - _ZNSt3__16__treeINS_12__value_typeIN7android8String16ENS2_2os17PersistableBundleEEENS_19__map_value_compareIS3_S6_NS_4lessIS3_EELb1EEENS_9allocatorIS6_EEE12__find_equalIS3_EERPNS_16__tree_node_baseIPvEENS_21__tree_const_iteratorIS6_PNS_11__tree_nodeIS6_SG_EElEERPNS_15__tree_end_nodeISI_EESJ_RKT_; - _ZNSt3__16__treeINS_12__value_typeIN7android8String16ENS2_2os17PersistableBundleEEENS_19__map_value_compareIS3_S6_NS_4lessIS3_EELb1EEENS_9allocatorIS6_EEE12__find_equalIS3_EERPNS_16__tree_node_baseIPvEERPNS_15__tree_end_nodeISI_EERKT_; - _ZNSt3__16__treeINS_12__value_typeIN7android8String16ENS2_2os17PersistableBundleEEENS_19__map_value_compareIS3_S6_NS_4lessIS3_EELb1EEENS_9allocatorIS6_EEE14__assign_multiINS_21__tree_const_iteratorIS6_PNS_11__tree_nodeIS6_PvEElEEEEvT_SL_; - _ZNSt3__16__treeINS_12__value_typeIN7android8String16ENS2_2os17PersistableBundleEEENS_19__map_value_compareIS3_S6_NS_4lessIS3_EELb1EEENS_9allocatorIS6_EEE14__erase_uniqueIS3_EEmRKT_; - _ZNSt3__16__treeINS_12__value_typeIN7android8String16ENS2_2os17PersistableBundleEEENS_19__map_value_compareIS3_S6_NS_4lessIS3_EELb1EEENS_9allocatorIS6_EEE15__emplace_multiIJRKNS_4pairIKS3_S5_EEEEENS_15__tree_iteratorIS6_PNS_11__tree_nodeIS6_PvEElEEDpOT_; - _ZNSt3__16__treeINS_12__value_typeIN7android8String16ENS2_2os17PersistableBundleEEENS_19__map_value_compareIS3_S6_NS_4lessIS3_EELb1EEENS_9allocatorIS6_EEE25__emplace_unique_key_argsIS3_JRKNS_21piecewise_construct_tENS_5tupleIJRKS3_EEENSI_IJEEEEEENS_4pairINS_15__tree_iteratorIS6_PNS_11__tree_nodeIS6_PvEElEEbEERKT_DpOT0_; - _ZNSt3__16__treeINS_12__value_typeIN7android8String16ENS2_2os17PersistableBundleEEENS_19__map_value_compareIS3_S6_NS_4lessIS3_EELb1EEENS_9allocatorIS6_EEE30__emplace_hint_unique_key_argsIS3_JRKNS_4pairIKS3_S5_EEEEENS_15__tree_iteratorIS6_PNS_11__tree_nodeIS6_PvEElEENS_21__tree_const_iteratorIS6_SO_lEERKT_DpOT0_; - _ZNSt3__16__treeINS_12__value_typeIN7android8String16ENS2_2os17PersistableBundleEEENS_19__map_value_compareIS3_S6_NS_4lessIS3_EELb1EEENS_9allocatorIS6_EEE4findIS3_EENS_15__tree_iteratorIS6_PNS_11__tree_nodeIS6_PvEElEERKT_; - _ZNSt3__16__treeINS_12__value_typeIN7android8String16ENS2_2os17PersistableBundleEEENS_19__map_value_compareIS3_S6_NS_4lessIS3_EELb1EEENS_9allocatorIS6_EEE5eraseENS_21__tree_const_iteratorIS6_PNS_11__tree_nodeIS6_PvEElEE; - _ZNSt3__16__treeINS_12__value_typeIN7android8String16ENS2_2os17PersistableBundleEEENS_19__map_value_compareIS3_S6_NS_4lessIS3_EELb1EEENS_9allocatorIS6_EEE7destroyEPNS_11__tree_nodeIS6_PvEE; - _ZNSt3__16__treeINS_12__value_typeIN7android8String16ENS_6vectorIbNS_9allocatorIbEEEEEENS_19__map_value_compareIS3_S8_NS_4lessIS3_EELb1EEENS5_IS8_EEE12__find_equalIS3_EERPNS_16__tree_node_baseIPvEENS_21__tree_const_iteratorIS8_PNS_11__tree_nodeIS8_SH_EElEERPNS_15__tree_end_nodeISJ_EESK_RKT_; - _ZNSt3__16__treeINS_12__value_typeIN7android8String16ENS_6vectorIbNS_9allocatorIbEEEEEENS_19__map_value_compareIS3_S8_NS_4lessIS3_EELb1EEENS5_IS8_EEE12__find_equalIS3_EERPNS_16__tree_node_baseIPvEERPNS_15__tree_end_nodeISJ_EERKT_; - _ZNSt3__16__treeINS_12__value_typeIN7android8String16ENS_6vectorIbNS_9allocatorIbEEEEEENS_19__map_value_compareIS3_S8_NS_4lessIS3_EELb1EEENS5_IS8_EEE14__assign_multiINS_21__tree_const_iteratorIS8_PNS_11__tree_nodeIS8_PvEElEEEEvT_SM_; - _ZNSt3__16__treeINS_12__value_typeIN7android8String16ENS_6vectorIbNS_9allocatorIbEEEEEENS_19__map_value_compareIS3_S8_NS_4lessIS3_EELb1EEENS5_IS8_EEE14__erase_uniqueIS3_EEmRKT_; - _ZNSt3__16__treeINS_12__value_typeIN7android8String16ENS_6vectorIbNS_9allocatorIbEEEEEENS_19__map_value_compareIS3_S8_NS_4lessIS3_EELb1EEENS5_IS8_EEE15__emplace_multiIJRKNS_4pairIKS3_S7_EEEEENS_15__tree_iteratorIS8_PNS_11__tree_nodeIS8_PvEElEEDpOT_; - _ZNSt3__16__treeINS_12__value_typeIN7android8String16ENS_6vectorIbNS_9allocatorIbEEEEEENS_19__map_value_compareIS3_S8_NS_4lessIS3_EELb1EEENS5_IS8_EEE16__construct_nodeIJRKNS_4pairIKS3_S7_EEEEENS_10unique_ptrINS_11__tree_nodeIS8_PvEENS_22__tree_node_destructorINS5_ISO_EEEEEEDpOT_; - _ZNSt3__16__treeINS_12__value_typeIN7android8String16ENS_6vectorIbNS_9allocatorIbEEEEEENS_19__map_value_compareIS3_S8_NS_4lessIS3_EELb1EEENS5_IS8_EEE25__emplace_unique_key_argsIS3_JRKNS_21piecewise_construct_tENS_5tupleIJRKS3_EEENSJ_IJEEEEEENS_4pairINS_15__tree_iteratorIS8_PNS_11__tree_nodeIS8_PvEElEEbEERKT_DpOT0_; - _ZNSt3__16__treeINS_12__value_typeIN7android8String16ENS_6vectorIbNS_9allocatorIbEEEEEENS_19__map_value_compareIS3_S8_NS_4lessIS3_EELb1EEENS5_IS8_EEE30__emplace_hint_unique_key_argsIS3_JRKNS_4pairIKS3_S7_EEEEENS_15__tree_iteratorIS8_PNS_11__tree_nodeIS8_PvEElEENS_21__tree_const_iteratorIS8_SP_lEERKT_DpOT0_; - _ZNSt3__16__treeINS_12__value_typeIN7android8String16ENS_6vectorIbNS_9allocatorIbEEEEEENS_19__map_value_compareIS3_S8_NS_4lessIS3_EELb1EEENS5_IS8_EEE4findIS3_EENS_15__tree_iteratorIS8_PNS_11__tree_nodeIS8_PvEElEERKT_; - _ZNSt3__16__treeINS_12__value_typeIN7android8String16ENS_6vectorIbNS_9allocatorIbEEEEEENS_19__map_value_compareIS3_S8_NS_4lessIS3_EELb1EEENS5_IS8_EEE5eraseENS_21__tree_const_iteratorIS8_PNS_11__tree_nodeIS8_PvEElEE; - _ZNSt3__16__treeINS_12__value_typeIN7android8String16ENS_6vectorIbNS_9allocatorIbEEEEEENS_19__map_value_compareIS3_S8_NS_4lessIS3_EELb1EEENS5_IS8_EEE7destroyEPNS_11__tree_nodeIS8_PvEE; - _ZNSt3__16__treeINS_12__value_typeIN7android8String16ENS_6vectorIdNS_9allocatorIdEEEEEENS_19__map_value_compareIS3_S8_NS_4lessIS3_EELb1EEENS5_IS8_EEE12__find_equalIS3_EERPNS_16__tree_node_baseIPvEENS_21__tree_const_iteratorIS8_PNS_11__tree_nodeIS8_SH_EElEERPNS_15__tree_end_nodeISJ_EESK_RKT_; - _ZNSt3__16__treeINS_12__value_typeIN7android8String16ENS_6vectorIdNS_9allocatorIdEEEEEENS_19__map_value_compareIS3_S8_NS_4lessIS3_EELb1EEENS5_IS8_EEE12__find_equalIS3_EERPNS_16__tree_node_baseIPvEERPNS_15__tree_end_nodeISJ_EERKT_; - _ZNSt3__16__treeINS_12__value_typeIN7android8String16ENS_6vectorIdNS_9allocatorIdEEEEEENS_19__map_value_compareIS3_S8_NS_4lessIS3_EELb1EEENS5_IS8_EEE14__assign_multiINS_21__tree_const_iteratorIS8_PNS_11__tree_nodeIS8_PvEElEEEEvT_SM_; - _ZNSt3__16__treeINS_12__value_typeIN7android8String16ENS_6vectorIdNS_9allocatorIdEEEEEENS_19__map_value_compareIS3_S8_NS_4lessIS3_EELb1EEENS5_IS8_EEE14__erase_uniqueIS3_EEmRKT_; - _ZNSt3__16__treeINS_12__value_typeIN7android8String16ENS_6vectorIdNS_9allocatorIdEEEEEENS_19__map_value_compareIS3_S8_NS_4lessIS3_EELb1EEENS5_IS8_EEE15__emplace_multiIJRKNS_4pairIKS3_S7_EEEEENS_15__tree_iteratorIS8_PNS_11__tree_nodeIS8_PvEElEEDpOT_; - _ZNSt3__16__treeINS_12__value_typeIN7android8String16ENS_6vectorIdNS_9allocatorIdEEEEEENS_19__map_value_compareIS3_S8_NS_4lessIS3_EELb1EEENS5_IS8_EEE25__emplace_unique_key_argsIS3_JRKNS_21piecewise_construct_tENS_5tupleIJRKS3_EEENSJ_IJEEEEEENS_4pairINS_15__tree_iteratorIS8_PNS_11__tree_nodeIS8_PvEElEEbEERKT_DpOT0_; - _ZNSt3__16__treeINS_12__value_typeIN7android8String16ENS_6vectorIdNS_9allocatorIdEEEEEENS_19__map_value_compareIS3_S8_NS_4lessIS3_EELb1EEENS5_IS8_EEE30__emplace_hint_unique_key_argsIS3_JRKNS_4pairIKS3_S7_EEEEENS_15__tree_iteratorIS8_PNS_11__tree_nodeIS8_PvEElEENS_21__tree_const_iteratorIS8_SP_lEERKT_DpOT0_; - _ZNSt3__16__treeINS_12__value_typeIN7android8String16ENS_6vectorIdNS_9allocatorIdEEEEEENS_19__map_value_compareIS3_S8_NS_4lessIS3_EELb1EEENS5_IS8_EEE4findIS3_EENS_15__tree_iteratorIS8_PNS_11__tree_nodeIS8_PvEElEERKT_; - _ZNSt3__16__treeINS_12__value_typeIN7android8String16ENS_6vectorIdNS_9allocatorIdEEEEEENS_19__map_value_compareIS3_S8_NS_4lessIS3_EELb1EEENS5_IS8_EEE5eraseENS_21__tree_const_iteratorIS8_PNS_11__tree_nodeIS8_PvEElEE; - _ZNSt3__16__treeINS_12__value_typeIN7android8String16ENS_6vectorIdNS_9allocatorIdEEEEEENS_19__map_value_compareIS3_S8_NS_4lessIS3_EELb1EEENS5_IS8_EEE7destroyEPNS_11__tree_nodeIS8_PvEE; - _ZNSt3__16__treeINS_12__value_typeIN7android8String16ENS_6vectorIiNS_9allocatorIiEEEEEENS_19__map_value_compareIS3_S8_NS_4lessIS3_EELb1EEENS5_IS8_EEE12__find_equalIS3_EERPNS_16__tree_node_baseIPvEENS_21__tree_const_iteratorIS8_PNS_11__tree_nodeIS8_SH_EElEERPNS_15__tree_end_nodeISJ_EESK_RKT_; - _ZNSt3__16__treeINS_12__value_typeIN7android8String16ENS_6vectorIiNS_9allocatorIiEEEEEENS_19__map_value_compareIS3_S8_NS_4lessIS3_EELb1EEENS5_IS8_EEE12__find_equalIS3_EERPNS_16__tree_node_baseIPvEERPNS_15__tree_end_nodeISJ_EERKT_; - _ZNSt3__16__treeINS_12__value_typeIN7android8String16ENS_6vectorIiNS_9allocatorIiEEEEEENS_19__map_value_compareIS3_S8_NS_4lessIS3_EELb1EEENS5_IS8_EEE14__assign_multiINS_21__tree_const_iteratorIS8_PNS_11__tree_nodeIS8_PvEElEEEEvT_SM_; - _ZNSt3__16__treeINS_12__value_typeIN7android8String16ENS_6vectorIiNS_9allocatorIiEEEEEENS_19__map_value_compareIS3_S8_NS_4lessIS3_EELb1EEENS5_IS8_EEE14__erase_uniqueIS3_EEmRKT_; - _ZNSt3__16__treeINS_12__value_typeIN7android8String16ENS_6vectorIiNS_9allocatorIiEEEEEENS_19__map_value_compareIS3_S8_NS_4lessIS3_EELb1EEENS5_IS8_EEE15__emplace_multiIJRKNS_4pairIKS3_S7_EEEEENS_15__tree_iteratorIS8_PNS_11__tree_nodeIS8_PvEElEEDpOT_; - _ZNSt3__16__treeINS_12__value_typeIN7android8String16ENS_6vectorIiNS_9allocatorIiEEEEEENS_19__map_value_compareIS3_S8_NS_4lessIS3_EELb1EEENS5_IS8_EEE25__emplace_unique_key_argsIS3_JRKNS_21piecewise_construct_tENS_5tupleIJRKS3_EEENSJ_IJEEEEEENS_4pairINS_15__tree_iteratorIS8_PNS_11__tree_nodeIS8_PvEElEEbEERKT_DpOT0_; - _ZNSt3__16__treeINS_12__value_typeIN7android8String16ENS_6vectorIiNS_9allocatorIiEEEEEENS_19__map_value_compareIS3_S8_NS_4lessIS3_EELb1EEENS5_IS8_EEE30__emplace_hint_unique_key_argsIS3_JRKNS_4pairIKS3_S7_EEEEENS_15__tree_iteratorIS8_PNS_11__tree_nodeIS8_PvEElEENS_21__tree_const_iteratorIS8_SP_lEERKT_DpOT0_; - _ZNSt3__16__treeINS_12__value_typeIN7android8String16ENS_6vectorIiNS_9allocatorIiEEEEEENS_19__map_value_compareIS3_S8_NS_4lessIS3_EELb1EEENS5_IS8_EEE4findIS3_EENS_15__tree_iteratorIS8_PNS_11__tree_nodeIS8_PvEElEERKT_; - _ZNSt3__16__treeINS_12__value_typeIN7android8String16ENS_6vectorIiNS_9allocatorIiEEEEEENS_19__map_value_compareIS3_S8_NS_4lessIS3_EELb1EEENS5_IS8_EEE5eraseENS_21__tree_const_iteratorIS8_PNS_11__tree_nodeIS8_PvEElEE; - _ZNSt3__16__treeINS_12__value_typeIN7android8String16ENS_6vectorIiNS_9allocatorIiEEEEEENS_19__map_value_compareIS3_S8_NS_4lessIS3_EELb1EEENS5_IS8_EEE7destroyEPNS_11__tree_nodeIS8_PvEE; - _ZNSt3__16__treeINS_12__value_typeIN7android8String16ENS_6vectorIlNS_9allocatorIlEEEEEENS_19__map_value_compareIS3_S8_NS_4lessIS3_EELb1EEENS5_IS8_EEE12__find_equalIS3_EERPNS_16__tree_node_baseIPvEENS_21__tree_const_iteratorIS8_PNS_11__tree_nodeIS8_SH_EElEERPNS_15__tree_end_nodeISJ_EESK_RKT_; - _ZNSt3__16__treeINS_12__value_typeIN7android8String16ENS_6vectorIlNS_9allocatorIlEEEEEENS_19__map_value_compareIS3_S8_NS_4lessIS3_EELb1EEENS5_IS8_EEE12__find_equalIS3_EERPNS_16__tree_node_baseIPvEERPNS_15__tree_end_nodeISJ_EERKT_; - _ZNSt3__16__treeINS_12__value_typeIN7android8String16ENS_6vectorIlNS_9allocatorIlEEEEEENS_19__map_value_compareIS3_S8_NS_4lessIS3_EELb1EEENS5_IS8_EEE14__assign_multiINS_21__tree_const_iteratorIS8_PNS_11__tree_nodeIS8_PvEElEEEEvT_SM_; - _ZNSt3__16__treeINS_12__value_typeIN7android8String16ENS_6vectorIlNS_9allocatorIlEEEEEENS_19__map_value_compareIS3_S8_NS_4lessIS3_EELb1EEENS5_IS8_EEE14__erase_uniqueIS3_EEmRKT_; - _ZNSt3__16__treeINS_12__value_typeIN7android8String16ENS_6vectorIlNS_9allocatorIlEEEEEENS_19__map_value_compareIS3_S8_NS_4lessIS3_EELb1EEENS5_IS8_EEE15__emplace_multiIJRKNS_4pairIKS3_S7_EEEEENS_15__tree_iteratorIS8_PNS_11__tree_nodeIS8_PvEElEEDpOT_; - _ZNSt3__16__treeINS_12__value_typeIN7android8String16ENS_6vectorIlNS_9allocatorIlEEEEEENS_19__map_value_compareIS3_S8_NS_4lessIS3_EELb1EEENS5_IS8_EEE25__emplace_unique_key_argsIS3_JRKNS_21piecewise_construct_tENS_5tupleIJRKS3_EEENSJ_IJEEEEEENS_4pairINS_15__tree_iteratorIS8_PNS_11__tree_nodeIS8_PvEElEEbEERKT_DpOT0_; - _ZNSt3__16__treeINS_12__value_typeIN7android8String16ENS_6vectorIlNS_9allocatorIlEEEEEENS_19__map_value_compareIS3_S8_NS_4lessIS3_EELb1EEENS5_IS8_EEE30__emplace_hint_unique_key_argsIS3_JRKNS_4pairIKS3_S7_EEEEENS_15__tree_iteratorIS8_PNS_11__tree_nodeIS8_PvEElEENS_21__tree_const_iteratorIS8_SP_lEERKT_DpOT0_; - _ZNSt3__16__treeINS_12__value_typeIN7android8String16ENS_6vectorIlNS_9allocatorIlEEEEEENS_19__map_value_compareIS3_S8_NS_4lessIS3_EELb1EEENS5_IS8_EEE4findIS3_EENS_15__tree_iteratorIS8_PNS_11__tree_nodeIS8_PvEElEERKT_; - _ZNSt3__16__treeINS_12__value_typeIN7android8String16ENS_6vectorIlNS_9allocatorIlEEEEEENS_19__map_value_compareIS3_S8_NS_4lessIS3_EELb1EEENS5_IS8_EEE5eraseENS_21__tree_const_iteratorIS8_PNS_11__tree_nodeIS8_PvEElEE; - _ZNSt3__16__treeINS_12__value_typeIN7android8String16ENS_6vectorIlNS_9allocatorIlEEEEEENS_19__map_value_compareIS3_S8_NS_4lessIS3_EELb1EEENS5_IS8_EEE7destroyEPNS_11__tree_nodeIS8_PvEE; - _ZNSt3__16__treeINS_12__value_typeIN7android8String16ENS_6vectorIS3_NS_9allocatorIS3_EEEEEENS_19__map_value_compareIS3_S8_NS_4lessIS3_EELb1EEENS5_IS8_EEE12__find_equalIS3_EERPNS_16__tree_node_baseIPvEENS_21__tree_const_iteratorIS8_PNS_11__tree_nodeIS8_SH_EElEERPNS_15__tree_end_nodeISJ_EESK_RKT_; - _ZNSt3__16__treeINS_12__value_typeIN7android8String16ENS_6vectorIS3_NS_9allocatorIS3_EEEEEENS_19__map_value_compareIS3_S8_NS_4lessIS3_EELb1EEENS5_IS8_EEE12__find_equalIS3_EERPNS_16__tree_node_baseIPvEERPNS_15__tree_end_nodeISJ_EERKT_; - _ZNSt3__16__treeINS_12__value_typeIN7android8String16ENS_6vectorIS3_NS_9allocatorIS3_EEEEEENS_19__map_value_compareIS3_S8_NS_4lessIS3_EELb1EEENS5_IS8_EEE14__assign_multiINS_21__tree_const_iteratorIS8_PNS_11__tree_nodeIS8_PvEElEEEEvT_SM_; - _ZNSt3__16__treeINS_12__value_typeIN7android8String16ENS_6vectorIS3_NS_9allocatorIS3_EEEEEENS_19__map_value_compareIS3_S8_NS_4lessIS3_EELb1EEENS5_IS8_EEE14__erase_uniqueIS3_EEmRKT_; - _ZNSt3__16__treeINS_12__value_typeIN7android8String16ENS_6vectorIS3_NS_9allocatorIS3_EEEEEENS_19__map_value_compareIS3_S8_NS_4lessIS3_EELb1EEENS5_IS8_EEE15__emplace_multiIJRKNS_4pairIKS3_S7_EEEEENS_15__tree_iteratorIS8_PNS_11__tree_nodeIS8_PvEElEEDpOT_; - _ZNSt3__16__treeINS_12__value_typeIN7android8String16ENS_6vectorIS3_NS_9allocatorIS3_EEEEEENS_19__map_value_compareIS3_S8_NS_4lessIS3_EELb1EEENS5_IS8_EEE16__construct_nodeIJRKNS_4pairIKS3_S7_EEEEENS_10unique_ptrINS_11__tree_nodeIS8_PvEENS_22__tree_node_destructorINS5_ISO_EEEEEEDpOT_; - _ZNSt3__16__treeINS_12__value_typeIN7android8String16ENS_6vectorIS3_NS_9allocatorIS3_EEEEEENS_19__map_value_compareIS3_S8_NS_4lessIS3_EELb1EEENS5_IS8_EEE25__emplace_unique_key_argsIS3_JRKNS_21piecewise_construct_tENS_5tupleIJRKS3_EEENSJ_IJEEEEEENS_4pairINS_15__tree_iteratorIS8_PNS_11__tree_nodeIS8_PvEElEEbEERKT_DpOT0_; - _ZNSt3__16__treeINS_12__value_typeIN7android8String16ENS_6vectorIS3_NS_9allocatorIS3_EEEEEENS_19__map_value_compareIS3_S8_NS_4lessIS3_EELb1EEENS5_IS8_EEE30__emplace_hint_unique_key_argsIS3_JRKNS_4pairIKS3_S7_EEEEENS_15__tree_iteratorIS8_PNS_11__tree_nodeIS8_PvEElEENS_21__tree_const_iteratorIS8_SP_lEERKT_DpOT0_; - _ZNSt3__16__treeINS_12__value_typeIN7android8String16ENS_6vectorIS3_NS_9allocatorIS3_EEEEEENS_19__map_value_compareIS3_S8_NS_4lessIS3_EELb1EEENS5_IS8_EEE4findIS3_EENS_15__tree_iteratorIS8_PNS_11__tree_nodeIS8_PvEElEERKT_; - _ZNSt3__16__treeINS_12__value_typeIN7android8String16ENS_6vectorIS3_NS_9allocatorIS3_EEEEEENS_19__map_value_compareIS3_S8_NS_4lessIS3_EELb1EEENS5_IS8_EEE5eraseENS_21__tree_const_iteratorIS8_PNS_11__tree_nodeIS8_PvEElEE; - _ZNSt3__16__treeINS_12__value_typeIN7android8String16ENS_6vectorIS3_NS_9allocatorIS3_EEEEEENS_19__map_value_compareIS3_S8_NS_4lessIS3_EELb1EEENS5_IS8_EEE7destroyEPNS_11__tree_nodeIS8_PvEE; - _ZNSt3__16__treeINS_12__value_typeIN7android8String16ES3_EENS_19__map_value_compareIS3_S4_NS_4lessIS3_EELb1EEENS_9allocatorIS4_EEE12__find_equalIS3_EERPNS_16__tree_node_baseIPvEENS_21__tree_const_iteratorIS4_PNS_11__tree_nodeIS4_SE_EElEERPNS_15__tree_end_nodeISG_EESH_RKT_; - _ZNSt3__16__treeINS_12__value_typeIN7android8String16ES3_EENS_19__map_value_compareIS3_S4_NS_4lessIS3_EELb1EEENS_9allocatorIS4_EEE12__find_equalIS3_EERPNS_16__tree_node_baseIPvEERPNS_15__tree_end_nodeISG_EERKT_; - _ZNSt3__16__treeINS_12__value_typeIN7android8String16ES3_EENS_19__map_value_compareIS3_S4_NS_4lessIS3_EELb1EEENS_9allocatorIS4_EEE14__assign_multiINS_21__tree_const_iteratorIS4_PNS_11__tree_nodeIS4_PvEElEEEEvT_SJ_; - _ZNSt3__16__treeINS_12__value_typeIN7android8String16ES3_EENS_19__map_value_compareIS3_S4_NS_4lessIS3_EELb1EEENS_9allocatorIS4_EEE14__erase_uniqueIS3_EEmRKT_; - _ZNSt3__16__treeINS_12__value_typeIN7android8String16ES3_EENS_19__map_value_compareIS3_S4_NS_4lessIS3_EELb1EEENS_9allocatorIS4_EEE15__emplace_multiIJRKNS_4pairIKS3_S3_EEEEENS_15__tree_iteratorIS4_PNS_11__tree_nodeIS4_PvEElEEDpOT_; - _ZNSt3__16__treeINS_12__value_typeIN7android8String16ES3_EENS_19__map_value_compareIS3_S4_NS_4lessIS3_EELb1EEENS_9allocatorIS4_EEE25__emplace_unique_key_argsIS3_JRKNS_21piecewise_construct_tENS_5tupleIJRKS3_EEENSG_IJEEEEEENS_4pairINS_15__tree_iteratorIS4_PNS_11__tree_nodeIS4_PvEElEEbEERKT_DpOT0_; - _ZNSt3__16__treeINS_12__value_typeIN7android8String16ES3_EENS_19__map_value_compareIS3_S4_NS_4lessIS3_EELb1EEENS_9allocatorIS4_EEE30__emplace_hint_unique_key_argsIS3_JRKNS_4pairIKS3_S3_EEEEENS_15__tree_iteratorIS4_PNS_11__tree_nodeIS4_PvEElEENS_21__tree_const_iteratorIS4_SM_lEERKT_DpOT0_; - _ZNSt3__16__treeINS_12__value_typeIN7android8String16ES3_EENS_19__map_value_compareIS3_S4_NS_4lessIS3_EELb1EEENS_9allocatorIS4_EEE4findIS3_EENS_15__tree_iteratorIS4_PNS_11__tree_nodeIS4_PvEElEERKT_; - _ZNSt3__16__treeINS_12__value_typeIN7android8String16ES3_EENS_19__map_value_compareIS3_S4_NS_4lessIS3_EELb1EEENS_9allocatorIS4_EEE5eraseENS_21__tree_const_iteratorIS4_PNS_11__tree_nodeIS4_PvEElEE; - _ZNSt3__16__treeINS_12__value_typeIN7android8String16ES3_EENS_19__map_value_compareIS3_S4_NS_4lessIS3_EELb1EEENS_9allocatorIS4_EEE7destroyEPNS_11__tree_nodeIS4_PvEE; - _ZNSt3__16__treeINS_12__value_typeINS_11__thread_idENS_6threadEEENS_19__map_value_compareIS2_S4_NS_4lessIS2_EELb1EEENS_9allocatorIS4_EEE7destroyEPNS_11__tree_nodeIS4_PvEE; - _ZNSt3__16__treeINS_12__value_typeINS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEEN7android6binder8internal25ClientCounterCallbackImpl7ServiceEEENS_19__map_value_compareIS7_SD_NS_4lessIS7_EELb1EEENS5_ISD_EEE12__find_equalIS7_EERPNS_16__tree_node_baseIPvEERPNS_15__tree_end_nodeISO_EERKT_; - _ZNSt3__16__treeINS_12__value_typeINS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEEN7android6binder8internal25ClientCounterCallbackImpl7ServiceEEENS_19__map_value_compareIS7_SD_NS_4lessIS7_EELb1EEENS5_ISD_EEE25__emplace_unique_key_argsIS7_JRKNS_21piecewise_construct_tENS_5tupleIJRKS7_EEENSO_IJEEEEEENS_4pairINS_15__tree_iteratorISD_PNS_11__tree_nodeISD_PvEElEEbEERKT_DpOT0_; - _ZNSt3__16__treeINS_12__value_typeINS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEEN7android6binder8internal25ClientCounterCallbackImpl7ServiceEEENS_19__map_value_compareIS7_SD_NS_4lessIS7_EELb1EEENS5_ISD_EEE7destroyEPNS_11__tree_nodeISD_PvEE; - _ZNSt3__16vectorIaNS_9allocatorIaEEE6insertIPKaEENS_9enable_ifIXaasr21__is_forward_iteratorIT_EE5valuesr16is_constructibleIaNS_15iterator_traitsIS8_E9referenceEEE5valueENS_11__wrap_iterIPaEEE4typeENSC_IS6_EES8_S8_; - _ZNSt3__16vectorIbNS_9allocatorIbEEE18__construct_at_endINS_14__bit_iteratorIS3_Lb0ELm0EEEEENS_9enable_ifIXsr21__is_forward_iteratorIT_EE5valueEvE4typeES8_S8_; - _ZNSt3__16vectorIbNS_9allocatorIbEEE18__construct_at_endINS_14__bit_iteratorIS3_Lb1ELm0EEEEENS_9enable_ifIXsr21__is_forward_iteratorIT_EE5valueEvE4typeES8_S8_; - _ZNSt3__16vectorIbNS_9allocatorIbEEE7reserveEm; - _ZNSt3__16vectorIbNS_9allocatorIbEEE9push_backERKb; - _ZNSt3__16vectorIbNS_9allocatorIbEEEaSERKS3_; - _ZNSt3__16vectorIdNS_9allocatorIdEEE6assignIPdEENS_9enable_ifIXaasr21__is_forward_iteratorIT_EE5valuesr16is_constructibleIdNS_15iterator_traitsIS7_E9referenceEEE5valueEvE4typeES7_S7_; - _ZNSt3__16vectorIdNS_9allocatorIdEEE6insertIPKdEENS_9enable_ifIXaasr21__is_forward_iteratorIT_EE5valuesr16is_constructibleIdNS_15iterator_traitsIS8_E9referenceEEE5valueENS_11__wrap_iterIPdEEE4typeENSC_IS6_EES8_S8_; - _ZNSt3__16vectorIDsNS_9allocatorIDsEEE24__emplace_back_slow_pathIJDsEEEvDpOT_; - _ZNSt3__16vectorIDsNS_9allocatorIDsEEE7reserveEm; - _ZNSt3__16vectorIfNS_9allocatorIfEEE6insertIPKfEENS_9enable_ifIXaasr21__is_forward_iteratorIT_EE5valuesr16is_constructibleIfNS_15iterator_traitsIS8_E9referenceEEE5valueENS_11__wrap_iterIPfEEE4typeENSC_IS6_EES8_S8_; - _ZNSt3__16vectorIhNS_9allocatorIhEEE6insertIPKhEENS_9enable_ifIXaasr21__is_forward_iteratorIT_EE5valuesr16is_constructibleIhNS_15iterator_traitsIS8_E9referenceEEE5valueENS_11__wrap_iterIPhEEE4typeENSC_IS6_EES8_S8_; - _ZNSt3__16vectorIiNS_9allocatorIiEEE6assignIPiEENS_9enable_ifIXaasr21__is_forward_iteratorIT_EE5valuesr16is_constructibleIiNS_15iterator_traitsIS7_E9referenceEEE5valueEvE4typeES7_S7_; - _ZNSt3__16vectorIiNS_9allocatorIiEEE6insertIPKiEENS_9enable_ifIXaasr21__is_forward_iteratorIT_EE5valuesr16is_constructibleIiNS_15iterator_traitsIS8_E9referenceEEE5valueENS_11__wrap_iterIPiEEE4typeENSC_IS6_EES8_S8_; - _ZNSt3__16vectorIlNS_9allocatorIlEEE6assignIPlEENS_9enable_ifIXaasr21__is_forward_iteratorIT_EE5valuesr16is_constructibleIlNS_15iterator_traitsIS7_E9referenceEEE5valueEvE4typeES7_S7_; - _ZNSt3__16vectorImNS_9allocatorImEEE6insertIPKmEENS_9enable_ifIXaasr21__is_forward_iteratorIT_EE5valuesr16is_constructibleImNS_15iterator_traitsIS8_E9referenceEEE5valueENS_11__wrap_iterIPmEEE4typeENSC_IS6_EES8_S8_; - _ZNSt3__16vectorIN7android2os16ServiceDebugInfoENS_9allocatorIS3_EEE8__appendEm; - _ZNSt3__16vectorIN7android2spINS1_10RpcSession13RpcConnectionEEENS_9allocatorIS5_EEE21__push_back_slow_pathIRKS5_EEvOT_; - _ZNSt3__16vectorIN7android2spINS1_10RpcSessionEEENS_9allocatorIS4_EEE21__push_back_slow_pathIRKS4_EEvOT_; - _ZNSt3__16vectorIN7android2spINS1_7IBinderEEENS_9allocatorIS4_EEE21__push_back_slow_pathIRKS4_EEvOT_; - _ZNSt3__16vectorIN7android2spINS1_7IBinderEEENS_9allocatorIS4_EEE8__appendEm; - _ZNSt3__16vectorIN7android4base14unique_fd_implINS2_13DefaultCloserEEENS_9allocatorIS5_EEE8__appendEm; - _ZNSt3__16vectorIN7android8RpcState10BinderNode9AsyncTodoENS_9allocatorIS4_EEE21__push_back_slow_pathIS4_EEvOT_; - _ZNSt3__16vectorIN7android8String16ENS_9allocatorIS2_EEE6assignIPS2_EENS_9enable_ifIXaasr21__is_forward_iteratorIT_EE5valuesr16is_constructibleIS2_NS_15iterator_traitsIS9_E9referenceEEE5valueEvE4typeES9_S9_; - _ZNSt3__16vectorIN7android8String16ENS_9allocatorIS2_EEE8__appendEm; - _ZNSt3__16vectorINS_10unique_ptrIN7android8String16ENS_14default_deleteIS3_EEEENS_9allocatorIS6_EEE8__appendEm; - _ZNSt3__16vectorINS_10unique_ptrINS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEENS_14default_deleteIS7_EEEENS5_ISA_EEE8__appendEm; - _ZNSt3__16vectorINS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEENS4_IS6_EEE8__appendEm; - _ZNSt3__16vectorINS_8optionalIN7android8String16EEENS_9allocatorIS4_EEE8__appendEm; - _ZNSt3__16vectorINS_8optionalINS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEEEENS5_IS8_EEE8__appendEm; - _ZTCN7android10AllocationE0_NS_10IInterfaceE; - _ZTCN7android10AllocationE0_NS_10MemoryBaseE; - _ZTCN7android10AllocationE0_NS_11BnInterfaceINS_7IMemoryEEE; - _ZTCN7android10AllocationE0_NS_7IMemoryE; - _ZTCN7android10AllocationE0_NS_8BnMemoryE; - _ZTCN7android10AllocationE8_NS_7BBinderE; - _ZTCN7android10AllocationE8_NS_7IBinderE; - _ZTCN7android10MemoryBaseE0_NS_10IInterfaceE; - _ZTCN7android10MemoryBaseE0_NS_11BnInterfaceINS_7IMemoryEEE; - _ZTCN7android10MemoryBaseE0_NS_7IMemoryE; - _ZTCN7android10MemoryBaseE0_NS_8BnMemoryE; - _ZTCN7android10MemoryBaseE8_NS_7BBinderE; - _ZTCN7android10MemoryBaseE8_NS_7IBinderE; - _ZTCN7android10PoolThreadE0_NS_6ThreadE; - _ZTCN7android11IMemoryHeapE0_NS_10IInterfaceE; - _ZTCN7android12BnMemoryHeapE0_NS_10IInterfaceE; - _ZTCN7android12BnMemoryHeapE0_NS_11BnInterfaceINS_11IMemoryHeapEEE; - _ZTCN7android12BnMemoryHeapE0_NS_11IMemoryHeapE; - _ZTCN7android12BnMemoryHeapE8_NS_7BBinderE; - _ZTCN7android12BnMemoryHeapE8_NS_7IBinderE; - _ZTCN7android12BpMemoryHeapE0_NS_10IInterfaceE; - _ZTCN7android12BpMemoryHeapE0_NS_11BpInterfaceINS_11IMemoryHeapEEE; - _ZTCN7android12BpMemoryHeapE0_NS_11IMemoryHeapE; - _ZTCN7android12BpMemoryHeapE8_NS_9BpRefBaseE; - _ZTCN7android14IShellCallbackE0_NS_10IInterfaceE; - _ZTCN7android14MemoryHeapBaseE64_NS_10IInterfaceE; - _ZTCN7android14MemoryHeapBaseE64_NS_11BnInterfaceINS_11IMemoryHeapEEE; - _ZTCN7android14MemoryHeapBaseE64_NS_11IMemoryHeapE; - _ZTCN7android14MemoryHeapBaseE64_NS_12BnMemoryHeapE; - _ZTCN7android14MemoryHeapBaseE72_NS_7BBinderE; - _ZTCN7android14MemoryHeapBaseE72_NS_7IBinderE; - _ZTCN7android15BnShellCallbackE0_NS_10IInterfaceE; - _ZTCN7android15BnShellCallbackE0_NS_11BnInterfaceINS_14IShellCallbackEEE; - _ZTCN7android15BnShellCallbackE0_NS_14IShellCallbackE; - _ZTCN7android15BnShellCallbackE8_NS_7BBinderE; - _ZTCN7android15BnShellCallbackE8_NS_7IBinderE; - _ZTCN7android15BpShellCallbackE0_NS_10IInterfaceE; - _ZTCN7android15BpShellCallbackE0_NS_11BpInterfaceINS_14IShellCallbackEEE; - _ZTCN7android15BpShellCallbackE0_NS_14IShellCallbackE; - _ZTCN7android15BpShellCallbackE8_NS_9BpRefBaseE; - _ZTCN7android15IResultReceiverE0_NS_10IInterfaceE; - _ZTCN7android15IServiceManagerE0_NS_10IInterfaceE; - _ZTCN7android16BnResultReceiverE0_NS_10IInterfaceE; - _ZTCN7android16BnResultReceiverE0_NS_11BnInterfaceINS_15IResultReceiverEEE; - _ZTCN7android16BnResultReceiverE0_NS_15IResultReceiverE; - _ZTCN7android16BnResultReceiverE8_NS_7BBinderE; - _ZTCN7android16BnResultReceiverE8_NS_7IBinderE; - _ZTCN7android16BpResultReceiverE0_NS_10IInterfaceE; - _ZTCN7android16BpResultReceiverE0_NS_11BpInterfaceINS_15IResultReceiverEEE; - _ZTCN7android16BpResultReceiverE0_NS_15IResultReceiverE; - _ZTCN7android16BpResultReceiverE8_NS_9BpRefBaseE; - _ZTCN7android18ServiceManagerShimE0_NS_10IInterfaceE; - _ZTCN7android18ServiceManagerShimE0_NS_15IServiceManagerE; - _ZTCN7android21IPermissionControllerE0_NS_10IInterfaceE; - _ZTCN7android22BnPermissionControllerE0_NS_10IInterfaceE; - _ZTCN7android22BnPermissionControllerE0_NS_11BnInterfaceINS_21IPermissionControllerEEE; - _ZTCN7android22BnPermissionControllerE0_NS_21IPermissionControllerE; - _ZTCN7android22BnPermissionControllerE8_NS_7BBinderE; - _ZTCN7android22BnPermissionControllerE8_NS_7IBinderE; - _ZTCN7android22BpPermissionControllerE0_NS_10IInterfaceE; - _ZTCN7android22BpPermissionControllerE0_NS_11BpInterfaceINS_21IPermissionControllerEEE; - _ZTCN7android22BpPermissionControllerE0_NS_21IPermissionControllerE; - _ZTCN7android22BpPermissionControllerE8_NS_9BpRefBaseE; - _ZTCN7android2os15IClientCallbackE0_NS_10IInterfaceE; - _ZTCN7android2os15IServiceManagerE0_NS_10IInterfaceE; - _ZTCN7android2os16BnClientCallbackE0_NS0_15IClientCallbackE; - _ZTCN7android2os16BnClientCallbackE0_NS_10IInterfaceE; - _ZTCN7android2os16BnClientCallbackE0_NS_11BnInterfaceINS0_15IClientCallbackEEE; - _ZTCN7android2os16BnClientCallbackE8_NS_7BBinderE; - _ZTCN7android2os16BnClientCallbackE8_NS_7IBinderE; - _ZTCN7android2os16BnServiceManagerE0_NS0_15IServiceManagerE; - _ZTCN7android2os16BnServiceManagerE0_NS_10IInterfaceE; - _ZTCN7android2os16BnServiceManagerE0_NS_11BnInterfaceINS0_15IServiceManagerEEE; - _ZTCN7android2os16BnServiceManagerE8_NS_7BBinderE; - _ZTCN7android2os16BnServiceManagerE8_NS_7IBinderE; - _ZTCN7android2os16BpClientCallbackE0_NS0_15IClientCallbackE; - _ZTCN7android2os16BpClientCallbackE0_NS_10IInterfaceE; - _ZTCN7android2os16BpClientCallbackE0_NS_11BpInterfaceINS0_15IClientCallbackEEE; - _ZTCN7android2os16BpClientCallbackE8_NS_9BpRefBaseE; - _ZTCN7android2os16BpServiceManagerE0_NS0_15IServiceManagerE; - _ZTCN7android2os16BpServiceManagerE0_NS_10IInterfaceE; - _ZTCN7android2os16BpServiceManagerE0_NS_11BpInterfaceINS0_15IServiceManagerEEE; - _ZTCN7android2os16BpServiceManagerE8_NS_9BpRefBaseE; - _ZTCN7android2os16IServiceCallbackE0_NS_10IInterfaceE; - _ZTCN7android2os17BnServiceCallbackE0_NS0_16IServiceCallbackE; - _ZTCN7android2os17BnServiceCallbackE0_NS_10IInterfaceE; - _ZTCN7android2os17BnServiceCallbackE0_NS_11BnInterfaceINS0_16IServiceCallbackEEE; - _ZTCN7android2os17BnServiceCallbackE8_NS_7BBinderE; - _ZTCN7android2os17BnServiceCallbackE8_NS_7IBinderE; - _ZTCN7android2os17BpServiceCallbackE0_NS0_16IServiceCallbackE; - _ZTCN7android2os17BpServiceCallbackE0_NS_10IInterfaceE; - _ZTCN7android2os17BpServiceCallbackE0_NS_11BpInterfaceINS0_16IServiceCallbackEEE; - _ZTCN7android2os17BpServiceCallbackE8_NS_9BpRefBaseE; - _ZTCN7android6binder8internal25ClientCounterCallbackImplE0_NS_10IInterfaceE; - _ZTCN7android6binder8internal25ClientCounterCallbackImplE0_NS_11BnInterfaceINS_2os15IClientCallbackEEE; - _ZTCN7android6binder8internal25ClientCounterCallbackImplE0_NS_2os15IClientCallbackE; - _ZTCN7android6binder8internal25ClientCounterCallbackImplE0_NS_2os16BnClientCallbackE; - _ZTCN7android6binder8internal25ClientCounterCallbackImplE8_NS_7BBinderE; - _ZTCN7android6binder8internal25ClientCounterCallbackImplE8_NS_7IBinderE; - _ZTCN7android7BBinderE0_NS_7IBinderE; - _ZTCN7android7content2pm21IPackageManagerNativeE0_NS_10IInterfaceE; - _ZTCN7android7content2pm22BnPackageManagerNativeE0_NS_10IInterfaceE; - _ZTCN7android7content2pm22BnPackageManagerNativeE0_NS_11BnInterfaceINS1_21IPackageManagerNativeEEE; - _ZTCN7android7content2pm22BnPackageManagerNativeE0_NS1_21IPackageManagerNativeE; - _ZTCN7android7content2pm22BnPackageManagerNativeE8_NS_7BBinderE; - _ZTCN7android7content2pm22BnPackageManagerNativeE8_NS_7IBinderE; - _ZTCN7android7content2pm22BpPackageManagerNativeE0_NS_10IInterfaceE; - _ZTCN7android7content2pm22BpPackageManagerNativeE0_NS_11BpInterfaceINS1_21IPackageManagerNativeEEE; - _ZTCN7android7content2pm22BpPackageManagerNativeE0_NS1_21IPackageManagerNativeE; - _ZTCN7android7content2pm22BpPackageManagerNativeE8_NS_9BpRefBaseE; - _ZTCN7android7content2pm22IPackageChangeObserverE0_NS_10IInterfaceE; - _ZTCN7android7content2pm23BnPackageChangeObserverE0_NS_10IInterfaceE; - _ZTCN7android7content2pm23BnPackageChangeObserverE0_NS_11BnInterfaceINS1_22IPackageChangeObserverEEE; - _ZTCN7android7content2pm23BnPackageChangeObserverE0_NS1_22IPackageChangeObserverE; - _ZTCN7android7content2pm23BnPackageChangeObserverE8_NS_7BBinderE; - _ZTCN7android7content2pm23BnPackageChangeObserverE8_NS_7IBinderE; - _ZTCN7android7content2pm23BpPackageChangeObserverE0_NS_10IInterfaceE; - _ZTCN7android7content2pm23BpPackageChangeObserverE0_NS_11BpInterfaceINS1_22IPackageChangeObserverEEE; - _ZTCN7android7content2pm23BpPackageChangeObserverE0_NS1_22IPackageChangeObserverE; - _ZTCN7android7content2pm23BpPackageChangeObserverE8_NS_9BpRefBaseE; - _ZTCN7android7IMemoryE0_NS_10IInterfaceE; - _ZTCN7android8BnMemoryE0_NS_10IInterfaceE; - _ZTCN7android8BnMemoryE0_NS_11BnInterfaceINS_7IMemoryEEE; - _ZTCN7android8BnMemoryE0_NS_7IMemoryE; - _ZTCN7android8BnMemoryE8_NS_7BBinderE; - _ZTCN7android8BnMemoryE8_NS_7IBinderE; - _ZTCN7android8BpBinderE0_NS_7IBinderE; - _ZTCN7android8BpMemoryE0_NS_10IInterfaceE; - _ZTCN7android8BpMemoryE0_NS_11BpInterfaceINS_7IMemoryEEE; - _ZTCN7android8BpMemoryE0_NS_7IMemoryE; - _ZTCN7android8BpMemoryE8_NS_9BpRefBaseE; - _ZTCN7android9HeapCacheE0_NS_7IBinder14DeathRecipientE; - _ZTCNSt3__118basic_stringstreamIcNS_11char_traitsIcEENS_9allocatorIcEEEE0_NS_13basic_istreamIcS2_EE; - _ZTCNSt3__118basic_stringstreamIcNS_11char_traitsIcEENS_9allocatorIcEEEE0_NS_14basic_iostreamIcS2_EE; - _ZTCNSt3__118basic_stringstreamIcNS_11char_traitsIcEENS_9allocatorIcEEEE16_NS_13basic_ostreamIcS2_EE; - _ZThn8_N7android10AllocationD0Ev; - _ZThn8_N7android10AllocationD1Ev; - _ZThn8_N7android10MemoryBaseD0Ev; - _ZThn8_N7android10MemoryBaseD1Ev; - _ZThn8_N7android12BnMemoryHeap10onTransactEjRKNS_6ParcelEPS1_j; - _ZThn8_N7android12BnMemoryHeapD0Ev; - _ZThn8_N7android12BnMemoryHeapD1Ev; - _ZThn8_N7android12BpMemoryHeapD0Ev; - _ZThn8_N7android12BpMemoryHeapD1Ev; - _ZThn8_N7android15BnShellCallback10onTransactEjRKNS_6ParcelEPS1_j; - _ZThn8_N7android16BnResultReceiver10onTransactEjRKNS_6ParcelEPS1_j; - _ZThn8_N7android22BnPermissionController10onTransactEjRKNS_6ParcelEPS1_j; - _ZThn8_N7android2os16BnClientCallback10onTransactEjRKNS_6ParcelEPS2_j; - _ZThn8_N7android2os16BnServiceManager10onTransactEjRKNS_6ParcelEPS2_j; - _ZThn8_N7android2os17BnServiceCallback10onTransactEjRKNS_6ParcelEPS2_j; - _ZThn8_N7android7content2pm22BnPackageManagerNative10onTransactEjRKNS_6ParcelEPS3_j; - _ZThn8_N7android7content2pm23BnPackageChangeObserver10onTransactEjRKNS_6ParcelEPS3_j; - _ZThn8_N7android8BnMemory10onTransactEjRKNS_6ParcelEPS1_j; - _ZThn8_N7android8BnMemoryD0Ev; - _ZThn8_N7android8BnMemoryD1Ev; - _ZThn8_N7android8BpMemoryD0Ev; - _ZThn8_N7android8BpMemoryD1Ev; - _ZTTN7android10AllocationE; - _ZTTN7android10IInterfaceE; - _ZTTN7android10MemoryBaseE; - _ZTTN7android10PoolThreadE; - _ZTTN7android10RpcSessionE; - _ZTTN7android11IMemoryHeapE; - _ZTTN7android12BnMemoryHeapE; - _ZTTN7android12BpMemoryHeapE; - _ZTTN7android12ProcessStateE; - _ZTTN7android14IShellCallbackE; - _ZTTN7android14MemoryHeapBaseE; - _ZTTN7android15BnShellCallbackE; - _ZTTN7android15BpShellCallbackE; - _ZTTN7android15IResultReceiverE; - _ZTTN7android15IServiceManagerE; - _ZTTN7android16BnResultReceiverE; - _ZTTN7android16BpResultReceiverE; - _ZTTN7android18ServiceManagerShimE; - _ZTTN7android21IPermissionControllerE; - _ZTTN7android22BnPermissionControllerE; - _ZTTN7android22BpPermissionControllerE; - _ZTTN7android2os15IClientCallbackE; - _ZTTN7android2os15IServiceManagerE; - _ZTTN7android2os16BnClientCallbackE; - _ZTTN7android2os16BnServiceManagerE; - _ZTTN7android2os16BpClientCallbackE; - _ZTTN7android2os16BpServiceManagerE; - _ZTTN7android2os16IServiceCallbackE; - _ZTTN7android2os17BnServiceCallbackE; - _ZTTN7android2os17BpServiceCallbackE; - _ZTTN7android6binder8internal25ClientCounterCallbackImplE; - _ZTTN7android7BBinderE; - _ZTTN7android7content2pm21IPackageManagerNativeE; - _ZTTN7android7content2pm22BnPackageManagerNativeE; - _ZTTN7android7content2pm22BpPackageManagerNativeE; - _ZTTN7android7content2pm22IPackageChangeObserverE; - _ZTTN7android7content2pm23BnPackageChangeObserverE; - _ZTTN7android7content2pm23BpPackageChangeObserverE; - _ZTTN7android7IBinderE; - _ZTTN7android7IMemoryE; - _ZTTN7android8BnMemoryE; - _ZTTN7android8BpBinderE; - _ZTTN7android8BpMemoryE; - _ZTTN7android9BpRefBaseE; - _ZTTN7android9HeapCacheE; - _ZTTN7android9RpcServerE; - _ZTTNSt3__118basic_stringstreamIcNS_11char_traitsIcEENS_9allocatorIcEEEE; - _ZTv0_n24_N7android10AllocationD0Ev; - _ZTv0_n24_N7android10AllocationD1Ev; - _ZTv0_n24_N7android10IInterfaceD0Ev; - _ZTv0_n24_N7android10IInterfaceD1Ev; - _ZTv0_n24_N7android10MemoryBaseD0Ev; - _ZTv0_n24_N7android10MemoryBaseD1Ev; - _ZTv0_n24_N7android10RpcSessionD0Ev; - _ZTv0_n24_N7android10RpcSessionD1Ev; - _ZTv0_n24_N7android11IMemoryHeapD0Ev; - _ZTv0_n24_N7android11IMemoryHeapD1Ev; - _ZTv0_n24_N7android12BnMemoryHeapD0Ev; - _ZTv0_n24_N7android12BnMemoryHeapD1Ev; - _ZTv0_n24_N7android12BpMemoryHeapD0Ev; - _ZTv0_n24_N7android12BpMemoryHeapD1Ev; - _ZTv0_n24_N7android12ProcessStateD0Ev; - _ZTv0_n24_N7android12ProcessStateD1Ev; - _ZTv0_n24_N7android14IShellCallbackD0Ev; - _ZTv0_n24_N7android14IShellCallbackD1Ev; - _ZTv0_n24_N7android14MemoryHeapBaseD0Ev; - _ZTv0_n24_N7android14MemoryHeapBaseD1Ev; - _ZTv0_n24_N7android15IResultReceiverD0Ev; - _ZTv0_n24_N7android15IResultReceiverD1Ev; - _ZTv0_n24_N7android15IServiceManagerD0Ev; - _ZTv0_n24_N7android15IServiceManagerD1Ev; - _ZTv0_n24_N7android21IPermissionControllerD0Ev; - _ZTv0_n24_N7android21IPermissionControllerD1Ev; - _ZTv0_n24_N7android2os15IClientCallbackD0Ev; - _ZTv0_n24_N7android2os15IClientCallbackD1Ev; - _ZTv0_n24_N7android2os15IServiceManagerD0Ev; - _ZTv0_n24_N7android2os15IServiceManagerD1Ev; - _ZTv0_n24_N7android2os16IServiceCallbackD0Ev; - _ZTv0_n24_N7android2os16IServiceCallbackD1Ev; - _ZTv0_n24_N7android7BBinderD0Ev; - _ZTv0_n24_N7android7BBinderD1Ev; - _ZTv0_n24_N7android7content2pm21IPackageManagerNativeD0Ev; - _ZTv0_n24_N7android7content2pm21IPackageManagerNativeD1Ev; - _ZTv0_n24_N7android7content2pm22IPackageChangeObserverD0Ev; - _ZTv0_n24_N7android7content2pm22IPackageChangeObserverD1Ev; - _ZTv0_n24_N7android7IBinderD0Ev; - _ZTv0_n24_N7android7IBinderD1Ev; - _ZTv0_n24_N7android7IMemoryD0Ev; - _ZTv0_n24_N7android7IMemoryD1Ev; - _ZTv0_n24_N7android8BnMemoryD0Ev; - _ZTv0_n24_N7android8BnMemoryD1Ev; - _ZTv0_n24_N7android8BpBinderD0Ev; - _ZTv0_n24_N7android8BpBinderD1Ev; - _ZTv0_n24_N7android8BpMemoryD0Ev; - _ZTv0_n24_N7android8BpMemoryD1Ev; - _ZTv0_n24_N7android9BpRefBaseD0Ev; - _ZTv0_n24_N7android9BpRefBaseD1Ev; - _ZTv0_n24_N7android9HeapCacheD0Ev; - _ZTv0_n24_N7android9HeapCacheD1Ev; - _ZTv0_n24_N7android9RpcServerD0Ev; - _ZTv0_n24_N7android9RpcServerD1Ev; - _ZTv0_n32_N7android14MemoryHeapBaseD0Ev; - _ZTv0_n32_N7android14MemoryHeapBaseD1Ev; - _ZTv0_n32_N7android8BpBinder10onFirstRefEv; - _ZTv0_n32_N7android9BpRefBase10onFirstRefEv; - _ZTv0_n40_N7android8BpBinder15onLastStrongRefEPKv; - _ZTv0_n40_N7android9BpRefBase15onLastStrongRefEPKv; - _ZTv0_n48_N7android8BpBinder20onIncStrongAttemptedEjPKv; - _ZTv0_n48_N7android9BpRefBase20onIncStrongAttemptedEjPKv; - _ZTv0_n56_NK7android14MemoryHeapBase9getHeapIDEv; - _ZTv0_n64_NK7android14MemoryHeapBase7getBaseEv; - _ZTv0_n72_NK7android14MemoryHeapBase7getSizeEv; - _ZTv0_n80_NK7android14MemoryHeapBase8getFlagsEv; - _ZTv0_n88_NK7android14MemoryHeapBase9getOffsetEv; - _ZTVN7android10AllocationE; - _ZTVN7android10IInterfaceE; - _ZTVN7android10MemoryBaseE; - _ZTVN7android10PoolThreadE; - _ZTVN7android10RpcSession13RpcConnectionE; - _ZTVN7android10RpcSessionE; - _ZTVN7android10TextOutputE; - _ZTVN7android11IMemoryHeapE; - _ZTVN7android12BnMemoryHeapE; - _ZTVN7android12BpMemoryHeapE; - _ZTVN7android12FdTextOutputE; - _ZTVN7android12MemoryDealerE; - _ZTVN7android12ProcessStateE; - _ZTVN7android12SortedVectorINS_15PermissionCache5EntryEEE; - _ZTVN7android12SortedVectorINS_16key_value_pair_tINS_2wpINS_7IBinderEEENS_9HeapCache11heap_info_tEEEEE; - _ZTVN7android12SortedVectorINS_16key_value_pair_tIPKvNS_8BpBinder13ObjectManager7entry_tEEEEE; - _ZTVN7android12SortedVectorINS_8String16EEE; - _ZTVN7android13LogTextOutputE; - _ZTVN7android14IShellCallbackE; - _ZTVN7android14MemoryHeapBaseE; - _ZTVN7android15BnShellCallbackE; - _ZTVN7android15BpShellCallbackE; - _ZTVN7android15IResultReceiverE; - _ZTVN7android15IServiceManagerE; - _ZTVN7android16BnResultReceiverE; - _ZTVN7android16BpResultReceiverE; - _ZTVN7android17InetSocketAddressE; - _ZTVN7android17UnixSocketAddressE; - _ZTVN7android18BufferedTextOutput11BufferStateE; - _ZTVN7android18BufferedTextOutputE; - _ZTVN7android18ServiceManagerShimE; - _ZTVN7android18VsockSocketAddressE; - _ZTVN7android21IPermissionControllerE; - _ZTVN7android22BnPermissionControllerE; - _ZTVN7android22BpPermissionControllerE; - _ZTVN7android2os15IClientCallbackE; - _ZTVN7android2os15IServiceManagerE; - _ZTVN7android2os16BnClientCallbackE; - _ZTVN7android2os16BnServiceManagerE; - _ZTVN7android2os16BpClientCallbackE; - _ZTVN7android2os16BpServiceManagerE; - _ZTVN7android2os16IServiceCallbackE; - _ZTVN7android2os16ParcelableHolderE; - _ZTVN7android2os16ServiceDebugInfoE; - _ZTVN7android2os17BnServiceCallbackE; - _ZTVN7android2os17BpServiceCallbackE; - _ZTVN7android2os17PersistableBundleE; - _ZTVN7android2os20ParcelFileDescriptorE; - _ZTVN7android6binder8internal25ClientCounterCallbackImplE; - _ZTVN7android6VectorIiEE; - _ZTVN7android6VectorINS_12ProcessState12handle_entryEEE; - _ZTVN7android6VectorINS_2spINS_18BufferedTextOutput11BufferStateEEEEE; - _ZTVN7android6VectorINS_8BpBinder8ObituaryEEE; - _ZTVN7android6VectorINS_8String16EEE; - _ZTVN7android6VectorIPNS_7BBinderEEE; - _ZTVN7android6VectorIPNS_7RefBase12weakref_typeEEE; - _ZTVN7android6VectorIPNS_7RefBaseEEE; - _ZTVN7android7BBinderE; - _ZTVN7android7content2pm18PackageChangeEventE; - _ZTVN7android7content2pm21IPackageManagerNativeE; - _ZTVN7android7content2pm22BnPackageManagerNativeE; - _ZTVN7android7content2pm22BpPackageManagerNativeE; - _ZTVN7android7content2pm22IPackageChangeObserverE; - _ZTVN7android7content2pm23BnPackageChangeObserverE; - _ZTVN7android7content2pm23BpPackageChangeObserverE; - _ZTVN7android7IBinderE; - _ZTVN7android7IMemoryE; - _ZTVN7android8BnMemoryE; - _ZTVN7android8BpBinderE; - _ZTVN7android8BpMemoryE; - _ZTVN7android9BpRefBaseE; - _ZTVN7android9HeapCacheE; - _ZTVN7android9RpcServerE; - _ZTvn8_n32_N7android14MemoryHeapBaseD0Ev; - _ZTvn8_n32_N7android14MemoryHeapBaseD1Ev; - _ZTVNSt3__115basic_stringbufIcNS_11char_traitsIcEENS_9allocatorIcEEEE; - _ZTVNSt3__118basic_stringstreamIcNS_11char_traitsIcEENS_9allocatorIcEEEE; - _ZTVNSt3__120__shared_ptr_emplaceIN7android14RpcWireAddressENS_9allocatorIS2_EEEE; - _ZTVNSt3__120__shared_ptr_emplaceIN7android6binder8internal21ClientCounterCallbackENS_9allocatorIS4_EEEE; - local: - *; -}; diff --git a/libs/binder/libbinder.arm64.vendor.map b/libs/binder/libbinder.arm64.vendor.map deleted file mode 100644 index 971ba925dd..0000000000 --- a/libs/binder/libbinder.arm64.vendor.map +++ /dev/null @@ -1,1525 +0,0 @@ -# b/190148312: Populate with correct list of ABI symbols -LIBBINDER { - global: - getBinderKernelReferences; - kDefaultDriver; - _ZN7android10AllocationC1ERKNS_2spINS_12MemoryDealerEEERKNS1_INS_11IMemoryHeapEEElm; - _ZN7android10AllocationC2ERKNS_2spINS_12MemoryDealerEEERKNS1_INS_11IMemoryHeapEEElm; - _ZN7android10AllocationD0Ev; - _ZN7android10AllocationD1Ev; - _ZN7android10AllocationD2Ev; - _ZN7android10IInterface8asBinderEPKS0_; - _ZN7android10IInterface8asBinderERKNS_2spIS0_EE; - _ZN7android10IInterfaceC2Ev; - _ZN7android10IInterfaceD0Ev; - _ZN7android10IInterfaceD1Ev; - _ZN7android10IInterfaceD2Ev; - _ZN7android10MemoryBaseC1ERKNS_2spINS_11IMemoryHeapEEElm; - _ZN7android10MemoryBaseC2ERKNS_2spINS_11IMemoryHeapEEElm; - _ZN7android10MemoryBaseD0Ev; - _ZN7android10MemoryBaseD1Ev; - _ZN7android10MemoryBaseD2Ev; - _ZN7android10RpcAddress14readFromParcelERKNS_6ParcelE; - _ZN7android10RpcAddress15fromRawEmbeddedEPKNS_14RpcWireAddressE; - _ZN7android10RpcAddress4zeroEv; - _ZN7android10RpcAddress6uniqueEv; - _ZN7android10RpcAddressC1Ev; - _ZN7android10RpcAddressC2Ev; - _ZN7android10RpcAddressD1Ev; - _ZN7android10RpcAddressD2Ev; - _ZN7android10RpcSession12setForServerERKNS_2wpINS_9RpcServerEEEi; - _ZN7android10RpcSession13getRootObjectEv; - _ZN7android10RpcSession13sendDecStrongERKNS_10RpcAddressE; - _ZN7android10RpcSession15setupInetClientEPKcj; - _ZN7android10RpcSession15terminateLockedEv; - _ZN7android10RpcSession16setupVsockClientEjj; - _ZN7android10RpcSession17setupSocketClientERKNS_16RpcSocketAddressE; - _ZN7android10RpcSession19addClientConnectionENS_4base14unique_fd_implINS1_13DefaultCloserEEE; - _ZN7android10RpcSession19ExclusiveConnection14findConnectionEiPNS_2spINS0_13RpcConnectionEEES5_RNSt3__16vectorIS4_NS6_9allocatorIS4_EEEEm; - _ZN7android10RpcSession19ExclusiveConnectionC1ERKNS_2spIS0_EENS0_13ConnectionUseE; - _ZN7android10RpcSession19ExclusiveConnectionC2ERKNS_2spIS0_EENS0_13ConnectionUseE; - _ZN7android10RpcSession19ExclusiveConnectionD1Ev; - _ZN7android10RpcSession19ExclusiveConnectionD2Ev; - _ZN7android10RpcSession19getRemoteMaxThreadsEPm; - _ZN7android10RpcSession20setupOneSocketClientERKNS_16RpcSocketAddressEi; - _ZN7android10RpcSession21setupUnixDomainClientEPKc; - _ZN7android10RpcSession22addNullDebuggingClientEv; - _ZN7android10RpcSession22removeServerConnectionERKNS_2spINS0_13RpcConnectionEEE; - _ZN7android10RpcSession24assignServerToThisThreadENS_4base14unique_fd_implINS1_13DefaultCloserEEE; - _ZN7android10RpcSession4joinENS_4base14unique_fd_implINS1_13DefaultCloserEEE; - _ZN7android10RpcSession4makeEv; - _ZN7android10RpcSession6readIdEv; - _ZN7android10RpcSession6serverEv; - _ZN7android10RpcSession7preJoinENSt3__16threadE; - _ZN7android10RpcSession8transactERKNS_10RpcAddressEjRKNS_6ParcelEPS4_j; - _ZN7android10RpcSessionC1Ev; - _ZN7android10RpcSessionC2Ev; - _ZN7android10RpcSessionD0Ev; - _ZN7android10RpcSessionD1Ev; - _ZN7android10RpcSessionD2Ev; - _ZN7android10TextOutputC2Ev; - _ZN7android10TextOutputD0Ev; - _ZN7android10TextOutputD1Ev; - _ZN7android10TextOutputD2Ev; - _ZN7android10zeroMemoryEPhm; - _ZN7android11BnInterfaceINS_11IMemoryHeapEE10onAsBinderEv; - _ZN7android11BnInterfaceINS_14IShellCallbackEE10onAsBinderEv; - _ZN7android11BnInterfaceINS_15IResultReceiverEE10onAsBinderEv; - _ZN7android11BnInterfaceINS_2os15IClientCallbackEE10onAsBinderEv; - _ZN7android11BnInterfaceINS_2os15IServiceManagerEE10onAsBinderEv; - _ZN7android11BnInterfaceINS_2os16IServiceCallbackEE10onAsBinderEv; - _ZN7android11BnInterfaceINS_7content2pm21IPackageManagerNativeEE10onAsBinderEv; - _ZN7android11BnInterfaceINS_7content2pm22IPackageChangeObserverEE10onAsBinderEv; - _ZN7android11BnInterfaceINS_7IMemoryEE10onAsBinderEv; - _ZN7android11IMemoryHeap10descriptorE; - _ZN7android11IMemoryHeap11asInterfaceERKNS_2spINS_7IBinderEEE; - _ZN7android11IMemoryHeap12default_implE; - _ZN7android11IMemoryHeap14getDefaultImplEv; - _ZN7android11IMemoryHeap14setDefaultImplENSt3__110unique_ptrIS0_NS1_14default_deleteIS0_EEEE; - _ZN7android11IMemoryHeapC2Ev; - _ZN7android11IMemoryHeapD0Ev; - _ZN7android11IMemoryHeapD1Ev; - _ZN7android11IMemoryHeapD2Ev; - _ZN7android12BnMemoryHeap10onTransactEjRKNS_6ParcelEPS1_j; - _ZN7android12BnMemoryHeapC2Ev; - _ZN7android12BnMemoryHeapD0Ev; - _ZN7android12BnMemoryHeapD1Ev; - _ZN7android12BnMemoryHeapD2Ev; - _ZN7android12BpMemoryHeapC1ERKNS_2spINS_7IBinderEEE; - _ZN7android12BpMemoryHeapC2ERKNS_2spINS_7IBinderEEE; - _ZN7android12BpMemoryHeapD0Ev; - _ZN7android12BpMemoryHeapD1Ev; - _ZN7android12BpMemoryHeapD2Ev; - _ZN7android12gTextBuffersE; - _ZN7android12MemoryDealer10deallocateEm; - _ZN7android12MemoryDealer22getAllocationAlignmentEv; - _ZN7android12MemoryDealer8allocateEm; - _ZN7android12MemoryDealerC1EmPKcj; - _ZN7android12MemoryDealerC2EmPKcj; - _ZN7android12MemoryDealerD0Ev; - _ZN7android12MemoryDealerD1Ev; - _ZN7android12MemoryDealerD2Ev; - _ZN7android12printHexDataEiPKvmmimbPFvPvPKcES2_; - _ZN7android12ProcessState10selfOrNullEv; - _ZN7android12ProcessState13expungeHandleEiPNS_7IBinderE; - _ZN7android12ProcessState13getDriverNameEv; - _ZN7android12ProcessState14initWithDriverEPKc; - _ZN7android12ProcessState15startThreadPoolEv; - _ZN7android12ProcessState16getContextObjectERKNS_2spINS_7IBinderEEE; - _ZN7android12ProcessState17spawnPooledThreadEb; - _ZN7android12ProcessState18giveThreadPoolNameEv; - _ZN7android12ProcessState18lookupHandleLockedEi; - _ZN7android12ProcessState18setCallRestrictionENS0_15CallRestrictionE; - _ZN7android12ProcessState19getKernelReferencesEmPm; - _ZN7android12ProcessState20becomeContextManagerEv; - _ZN7android12ProcessState20makeBinderThreadNameEv; - _ZN7android12ProcessState23getStrongProxyForHandleEi; - _ZN7android12ProcessState24getStrongRefCountForNodeERKNS_2spINS_8BpBinderEEE; - _ZN7android12ProcessState25enableOnewaySpamDetectionEb; - _ZN7android12ProcessState27setThreadPoolMaxThreadCountEm; - _ZN7android12ProcessState4initEPKcb; - _ZN7android12ProcessState4selfEv; - _ZN7android12ProcessStateC1EPKc; - _ZN7android12ProcessStateC2EPKc; - _ZN7android12ProcessStateD0Ev; - _ZN7android12ProcessStateD1Ev; - _ZN7android12ProcessStateD2Ev; - _ZN7android13printTypeCodeEjPFvPvPKcES0_; - _ZN7android14IPCThreadState10freeBufferEPNS_6ParcelEPKhmPKym; - _ZN7android14IPCThreadState10selfOrNullEv; - _ZN7android14IPCThreadState11clearCallerEv; - _ZN7android14IPCThreadState11stopProcessEb; - _ZN7android14IPCThreadState12setupPollingEPi; - _ZN7android14IPCThreadState13decWeakHandleEi; - _ZN7android14IPCThreadState13expungeHandleEiPNS_7IBinderE; - _ZN7android14IPCThreadState13flushCommandsEv; - _ZN7android14IPCThreadState13flushIfNeededEv; - _ZN7android14IPCThreadState13incWeakHandleEiPNS_8BpBinderE; - _ZN7android14IPCThreadState14clearLastErrorEv; - _ZN7android14IPCThreadState14executeCommandEi; - _ZN7android14IPCThreadState14joinThreadPoolEb; - _ZN7android14IPCThreadState14talkWithDriverEb; - _ZN7android14IPCThreadState15decStrongHandleEi; - _ZN7android14IPCThreadState15incStrongHandleEiPNS_8BpBinderE; - _ZN7android14IPCThreadState15waitForResponseEPNS_6ParcelEPi; - _ZN7android14IPCThreadState16threadDestructorEPv; - _ZN7android14IPCThreadState18setCallRestrictionENS_12ProcessState15CallRestrictionE; - _ZN7android14IPCThreadState19setStrictModePolicyEi; - _ZN7android14IPCThreadState19setTheContextObjectERKNS_2spINS_7BBinderEEE; - _ZN7android14IPCThreadState20clearCallingIdentityEv; - _ZN7android14IPCThreadState20getAndExecuteCommandEv; - _ZN7android14IPCThreadState20getProcessFreezeInfoEiPbS1_; - _ZN7android14IPCThreadState20handlePolledCommandsEv; - _ZN7android14IPCThreadState20processPendingDerefsEv; - _ZN7android14IPCThreadState20writeTransactionDataEijijRKNS_6ParcelEPi; - _ZN7android14IPCThreadState22attemptIncStrongHandleEi; - _ZN7android14IPCThreadState22clearCallingWorkSourceEv; - _ZN7android14IPCThreadState22clearDeathNotificationEiPNS_8BpBinderE; - _ZN7android14IPCThreadState22processPostWriteDerefsEv; - _ZN7android14IPCThreadState22restoreCallingIdentityEl; - _ZN7android14IPCThreadState23setCallingWorkSourceUidEj; - _ZN7android14IPCThreadState24clearPropagateWorkSourceEv; - _ZN7android14IPCThreadState24requestDeathNotificationEiPNS_8BpBinderE; - _ZN7android14IPCThreadState24restoreCallingWorkSourceEl; - _ZN7android14IPCThreadState25blockUntilThreadAvailableEv; - _ZN7android14IPCThreadState27disableBackgroundSchedulingEb; - _ZN7android14IPCThreadState28backgroundSchedulingDisabledEv; - _ZN7android14IPCThreadState29setLastTransactionBinderFlagsEi; - _ZN7android14IPCThreadState41setCallingWorkSourceUidWithoutPropagationEj; - _ZN7android14IPCThreadState4selfEv; - _ZN7android14IPCThreadState6freezeEibj; - _ZN7android14IPCThreadState7processEv; - _ZN7android14IPCThreadState8shutdownEv; - _ZN7android14IPCThreadState8transactEijRKNS_6ParcelEPS1_j; - _ZN7android14IPCThreadState9sendReplyERKNS_6ParcelEj; - _ZN7android14IPCThreadStateC1Ev; - _ZN7android14IPCThreadStateC2Ev; - _ZN7android14IPCThreadStateD1Ev; - _ZN7android14IPCThreadStateD2Ev; - _ZN7android14IShellCallback10descriptorE; - _ZN7android14IShellCallback11asInterfaceERKNS_2spINS_7IBinderEEE; - _ZN7android14IShellCallback12default_implE; - _ZN7android14IShellCallback14getDefaultImplEv; - _ZN7android14IShellCallback14setDefaultImplENSt3__110unique_ptrIS0_NS1_14default_deleteIS0_EEEE; - _ZN7android14IShellCallbackC2Ev; - _ZN7android14IShellCallbackD0Ev; - _ZN7android14IShellCallbackD1Ev; - _ZN7android14IShellCallbackD2Ev; - _ZN7android14MemoryHeapBase4initEiPvmiPKc; - _ZN7android14MemoryHeapBase5mapfdEibml; - _ZN7android14MemoryHeapBase7disposeEv; - _ZN7android14MemoryHeapBaseC1Eimjl; - _ZN7android14MemoryHeapBaseC1EmjPKc; - _ZN7android14MemoryHeapBaseC1EPKcmj; - _ZN7android14MemoryHeapBaseC1Ev; - _ZN7android14MemoryHeapBaseC2Eimjl; - _ZN7android14MemoryHeapBaseC2EmjPKc; - _ZN7android14MemoryHeapBaseC2EPKcmj; - _ZN7android14MemoryHeapBaseC2Ev; - _ZN7android14MemoryHeapBaseD0Ev; - _ZN7android14MemoryHeapBaseD1Ev; - _ZN7android14MemoryHeapBaseD2Ev; - _ZN7android15BnShellCallback10onTransactEjRKNS_6ParcelEPS1_j; - _ZN7android15IResultReceiver10descriptorE; - _ZN7android15IResultReceiver11asInterfaceERKNS_2spINS_7IBinderEEE; - _ZN7android15IResultReceiver12default_implE; - _ZN7android15IResultReceiver14getDefaultImplEv; - _ZN7android15IResultReceiver14setDefaultImplENSt3__110unique_ptrIS0_NS1_14default_deleteIS0_EEEE; - _ZN7android15IResultReceiverC2Ev; - _ZN7android15IResultReceiverD0Ev; - _ZN7android15IResultReceiverD1Ev; - _ZN7android15IResultReceiverD2Ev; - _ZN7android15IServiceManagerC2Ev; - _ZN7android15IServiceManagerD0Ev; - _ZN7android15IServiceManagerD1Ev; - _ZN7android15IServiceManagerD2Ev; - _ZN7android15stringForIndentEi; - _ZN7android16BnResultReceiver10onTransactEjRKNS_6ParcelEPS1_j; - _ZN7android18BufferedTextOutput10moveIndentEi; - _ZN7android18BufferedTextOutput10pushBundleEv; - _ZN7android18BufferedTextOutput5printEPKcm; - _ZN7android18BufferedTextOutput9popBundleEv; - _ZN7android18BufferedTextOutputC2Ej; - _ZN7android18BufferedTextOutputD0Ev; - _ZN7android18BufferedTextOutputD1Ev; - _ZN7android18BufferedTextOutputD2Ev; - _ZN7android18ServiceManagerShim10addServiceERKNS_8String16ERKNS_2spINS_7IBinderEEEbi; - _ZN7android18ServiceManagerShim10isDeclaredERKNS_8String16E; - _ZN7android18ServiceManagerShim12listServicesEi; - _ZN7android18ServiceManagerShim14waitForServiceERKNS_8String16E; - _ZN7android18ServiceManagerShim16updatableViaApexERKNS_8String16E; - _ZN7android18ServiceManagerShim20getDeclaredInstancesERKNS_8String16E; - _ZN7android18ServiceManagerShimC1ERKNS_2spINS_2os15IServiceManagerEEE; - _ZN7android18ServiceManagerShimC2ERKNS_2spINS_2os15IServiceManagerEEE; - _ZN7android18the_context_objectE; - _ZN7android21defaultServiceManagerEv; - _ZN7android22SimpleBestFitAllocator10deallocateEm; - _ZN7android22SimpleBestFitAllocator12kMemoryAlignE; - _ZN7android22SimpleBestFitAllocator5allocEmj; - _ZN7android22SimpleBestFitAllocator7deallocEm; - _ZN7android22SimpleBestFitAllocator8allocateEmj; - _ZN7android22SimpleBestFitAllocatorC1Em; - _ZN7android22SimpleBestFitAllocatorC2Em; - _ZN7android22SimpleBestFitAllocatorD1Ev; - _ZN7android22SimpleBestFitAllocatorD2Ev; - _ZN7android24setDefaultServiceManagerERKNS_2spINS_15IServiceManagerEEE; - _ZN7android2os15IClientCallback10descriptorE; - _ZN7android2os15IClientCallback11asInterfaceERKNS_2spINS_7IBinderEEE; - _ZN7android2os15IClientCallback12default_implE; - _ZN7android2os15IClientCallback14getDefaultImplEv; - _ZN7android2os15IClientCallback14setDefaultImplENSt3__110unique_ptrIS1_NS2_14default_deleteIS1_EEEE; - _ZN7android2os15IClientCallbackC2Ev; - _ZN7android2os15IClientCallbackD0Ev; - _ZN7android2os15IClientCallbackD1Ev; - _ZN7android2os15IClientCallbackD2Ev; - _ZN7android2os15IServiceManager10descriptorE; - _ZN7android2os15IServiceManager11asInterfaceERKNS_2spINS_7IBinderEEE; - _ZN7android2os15IServiceManager12default_implE; - _ZN7android2os15IServiceManager14getDefaultImplEv; - _ZN7android2os15IServiceManager14setDefaultImplENSt3__110unique_ptrIS1_NS2_14default_deleteIS1_EEEE; - _ZN7android2os15IServiceManagerC2Ev; - _ZN7android2os15IServiceManagerD0Ev; - _ZN7android2os15IServiceManagerD1Ev; - _ZN7android2os15IServiceManagerD2Ev; - _ZN7android2os16BnClientCallback10onTransactEjRKNS_6ParcelEPS2_j; - _ZN7android2os16BnClientCallbackC2Ev; - _ZN7android2os16BnServiceManager10onTransactEjRKNS_6ParcelEPS2_j; - _ZN7android2os16BnServiceManagerC2Ev; - _ZN7android2os16BpClientCallback9onClientsERKNS_2spINS_7IBinderEEEb; - _ZN7android2os16BpClientCallbackC1ERKNS_2spINS_7IBinderEEE; - _ZN7android2os16BpClientCallbackC2ERKNS_2spINS_7IBinderEEE; - _ZN7android2os16BpServiceManager10addServiceERKNSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEERKNS_2spINS_7IBinderEEEbi; - _ZN7android2os16BpServiceManager10getServiceERKNSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEPNS_2spINS_7IBinderEEE; - _ZN7android2os16BpServiceManager10isDeclaredERKNSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEPb; - _ZN7android2os16BpServiceManager12checkServiceERKNSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEPNS_2spINS_7IBinderEEE; - _ZN7android2os16BpServiceManager12listServicesEiPNSt3__16vectorINS2_12basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEENS7_IS9_EEEE; - _ZN7android2os16BpServiceManager16updatableViaApexERKNSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEPNS2_8optionalIS8_EE; - _ZN7android2os16BpServiceManager19getServiceDebugInfoEPNSt3__16vectorINS0_16ServiceDebugInfoENS2_9allocatorIS4_EEEE; - _ZN7android2os16BpServiceManager20getDeclaredInstancesERKNSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEPNS2_6vectorIS8_NS6_IS8_EEEE; - _ZN7android2os16BpServiceManager20tryUnregisterServiceERKNSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEERKNS_2spINS_7IBinderEEE; - _ZN7android2os16BpServiceManager22registerClientCallbackERKNSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEERKNS_2spINS_7IBinderEEERKNSB_INS0_15IClientCallbackEEE; - _ZN7android2os16BpServiceManager24registerForNotificationsERKNSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEERKNS_2spINS0_16IServiceCallbackEEE; - _ZN7android2os16BpServiceManager26unregisterForNotificationsERKNSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEERKNS_2spINS0_16IServiceCallbackEEE; - _ZN7android2os16BpServiceManagerC1ERKNS_2spINS_7IBinderEEE; - _ZN7android2os16BpServiceManagerC2ERKNS_2spINS_7IBinderEEE; - _ZN7android2os16IServiceCallback10descriptorE; - _ZN7android2os16IServiceCallback11asInterfaceERKNS_2spINS_7IBinderEEE; - _ZN7android2os16IServiceCallback12default_implE; - _ZN7android2os16IServiceCallback14getDefaultImplEv; - _ZN7android2os16IServiceCallback14setDefaultImplENSt3__110unique_ptrIS1_NS2_14default_deleteIS1_EEEE; - _ZN7android2os16IServiceCallbackC2Ev; - _ZN7android2os16IServiceCallbackD0Ev; - _ZN7android2os16IServiceCallbackD1Ev; - _ZN7android2os16IServiceCallbackD2Ev; - _ZN7android2os16ParcelableHolder14readFromParcelEPKNS_6ParcelE; - _ZN7android2os16ServiceDebugInfo14readFromParcelEPKNS_6ParcelE; - _ZN7android2os17BnServiceCallback10onTransactEjRKNS_6ParcelEPS2_j; - _ZN7android2os17BnServiceCallbackC2Ev; - _ZN7android2os17BpServiceCallback14onRegistrationERKNSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEERKNS_2spINS_7IBinderEEE; - _ZN7android2os17BpServiceCallbackC1ERKNS_2spINS_7IBinderEEE; - _ZN7android2os17BpServiceCallbackC2ERKNS_2spINS_7IBinderEEE; - _ZN7android2os17PersistableBundle10putBooleanERKNS_8String16Eb; - _ZN7android2os17PersistableBundle12putIntVectorERKNS_8String16ERKNSt3__16vectorIiNS5_9allocatorIiEEEE; - _ZN7android2os17PersistableBundle13putLongVectorERKNS_8String16ERKNSt3__16vectorIlNS5_9allocatorIlEEEE; - _ZN7android2os17PersistableBundle14readFromParcelEPKNS_6ParcelE; - _ZN7android2os17PersistableBundle15putDoubleVectorERKNS_8String16ERKNSt3__16vectorIdNS5_9allocatorIdEEEE; - _ZN7android2os17PersistableBundle15putStringVectorERKNS_8String16ERKNSt3__16vectorIS2_NS5_9allocatorIS2_EEEE; - _ZN7android2os17PersistableBundle16putBooleanVectorERKNS_8String16ERKNSt3__16vectorIbNS5_9allocatorIbEEEE; - _ZN7android2os17PersistableBundle19readFromParcelInnerEPKNS_6ParcelEm; - _ZN7android2os17PersistableBundle20putPersistableBundleERKNS_8String16ERKS1_; - _ZN7android2os17PersistableBundle5eraseERKNS_8String16E; - _ZN7android2os17PersistableBundle6putIntERKNS_8String16Ei; - _ZN7android2os17PersistableBundle7putLongERKNS_8String16El; - _ZN7android2os17PersistableBundle9putDoubleERKNS_8String16Ed; - _ZN7android2os17PersistableBundle9putStringERKNS_8String16ES4_; - _ZN7android2os20ParcelFileDescriptor14readFromParcelEPKNS_6ParcelE; - _ZN7android2os20ParcelFileDescriptorC1ENS_4base14unique_fd_implINS2_13DefaultCloserEEE; - _ZN7android2os20ParcelFileDescriptorC1Ev; - _ZN7android2os20ParcelFileDescriptorC2ENS_4base14unique_fd_implINS2_13DefaultCloserEEE; - _ZN7android2os20ParcelFileDescriptorC2Ev; - _ZN7android2os20ParcelFileDescriptorD0Ev; - _ZN7android2os20ParcelFileDescriptorD1Ev; - _ZN7android2os20ParcelFileDescriptorD2Ev; - _ZN7android2spINS_7BBinderEED2Ev; - _ZN7android2spINS_7IBinderEEaSEOS2_; - _ZN7android2spINS_7IBinderEEaSERKS2_; - _ZN7android2spINS_9HeapCacheEED2Ev; - _ZN7android4aerrE; - _ZN7android4alogE; - _ZN7android4aoutE; - _ZN7android6binder20LazyServiceRegistrar10reRegisterEv; - _ZN7android6binder20LazyServiceRegistrar11getInstanceEv; - _ZN7android6binder20LazyServiceRegistrar12forcePersistEb; - _ZN7android6binder20LazyServiceRegistrar13tryUnregisterEv; - _ZN7android6binder20LazyServiceRegistrar15registerServiceERKNS_2spINS_7IBinderEEERKNSt3__112basic_stringIcNS7_11char_traitsIcEENS7_9allocatorIcEEEEbi; - _ZN7android6binder20LazyServiceRegistrar25setActiveServicesCallbackERKNSt3__18functionIFbbEEE; - _ZN7android6binder20LazyServiceRegistrarC1Ev; - _ZN7android6binder20LazyServiceRegistrarC2Ev; - _ZN7android6binder6Status11fromStatusTEi; - _ZN7android6binder6Status12setExceptionEiRKNS_7String8E; - _ZN7android6binder6Status14readFromParcelERKNS_6ParcelE; - _ZN7android6binder6Status14setFromStatusTEi; - _ZN7android6binder6Status17exceptionToStringEi; - _ZN7android6binder6Status17fromExceptionCodeEi; - _ZN7android6binder6Status17fromExceptionCodeEiPKc; - _ZN7android6binder6Status17fromExceptionCodeEiRKNS_7String8E; - _ZN7android6binder6Status23setServiceSpecificErrorEiRKNS_7String8E; - _ZN7android6binder6Status24fromServiceSpecificErrorEi; - _ZN7android6binder6Status24fromServiceSpecificErrorEiPKc; - _ZN7android6binder6Status24fromServiceSpecificErrorEiRKNS_7String8E; - _ZN7android6binder6Status2okEv; - _ZN7android6binder6StatusC1Eii; - _ZN7android6binder6StatusC1EiiRKNS_7String8E; - _ZN7android6binder6StatusC2Eii; - _ZN7android6binder6StatusC2EiiRKNS_7String8E; - _ZN7android6binder8internal21ClientCounterCallback10reRegisterEv; - _ZN7android6binder8internal21ClientCounterCallback12forcePersistEb; - _ZN7android6binder8internal21ClientCounterCallback13tryUnregisterEv; - _ZN7android6binder8internal21ClientCounterCallback15registerServiceERKNS_2spINS_7IBinderEEERKNSt3__112basic_stringIcNS8_11char_traitsIcEENS8_9allocatorIcEEEEbi; - _ZN7android6binder8internal21ClientCounterCallback25setActiveServicesCallbackERKNSt3__18functionIFbbEEE; - _ZN7android6binder8internal21ClientCounterCallbackC1Ev; - _ZN7android6binder8internal21ClientCounterCallbackC2Ev; - _ZN7android6binder8internal25ClientCounterCallbackImpl10reRegisterEv; - _ZN7android6binder8internal25ClientCounterCallbackImpl11tryShutdownEv; - _ZN7android6binder8internal25ClientCounterCallbackImpl12forcePersistEb; - _ZN7android6binder8internal25ClientCounterCallbackImpl13tryUnregisterEv; - _ZN7android6binder8internal25ClientCounterCallbackImpl15registerServiceERKNS_2spINS_7IBinderEEERKNSt3__112basic_stringIcNS8_11char_traitsIcEENS8_9allocatorIcEEEEbi; - _ZN7android6binder8internal25ClientCounterCallbackImpl16maybeTryShutdownEv; - _ZN7android6binder8internal25ClientCounterCallbackImpl23assertRegisteredServiceERKNS_2spINS_7IBinderEEE; - _ZN7android6binder8internal25ClientCounterCallbackImpl25setActiveServicesCallbackERKNSt3__18functionIFbbEEE; - _ZN7android6binder8internal25ClientCounterCallbackImpl9onClientsERKNS_2spINS_7IBinderEEEb; - _ZN7android6Parcel10appendFromEPKS0_mm; - _ZN7android6Parcel10markForRpcERKNS_2spINS_10RpcSessionEEE; - _ZN7android6Parcel10writeFloatEf; - _ZN7android6Parcel10writeInt32Ei; - _ZN7android6Parcel10writeInt64El; - _ZN7android6Parcel11compareDataERKS0_; - _ZN7android6Parcel11finishWriteEm; - _ZN7android6Parcel11setDataSizeEm; - _ZN7android6Parcel11writeDoubleEd; - _ZN7android6Parcel11writeObjectERK18flat_binder_objectb; - _ZN7android6Parcel11writeUint32Ej; - _ZN7android6Parcel11writeUint64Em; - _ZN7android6Parcel12pushAllowFdsEb; - _ZN7android6Parcel12restartWriteEm; - _ZN7android6Parcel12writeCStringEPKc; - _ZN7android6Parcel12writeInplaceEm; - _ZN7android6Parcel12writePointerEm; - _ZN7android6Parcel12writeString8EPKcm; - _ZN7android6Parcel12writeString8ERKNS_7String8E; - _ZN7android6Parcel13continueWriteEm; - _ZN7android6Parcel13flattenBinderERKNS_2spINS_7IBinderEEE; - _ZN7android6Parcel13markForBinderERKNS_2spINS_7IBinderEEE; - _ZN7android6Parcel13writeString16EPKDsm; - _ZN7android6Parcel13writeString16ERKNS_8String16E; - _ZN7android6Parcel13writeString16ERKNSt3__110unique_ptrINS_8String16ENS1_14default_deleteIS3_EEEE; - _ZN7android6Parcel13writeString16ERKNSt3__18optionalINS_8String16EEE; - _ZN7android6Parcel13writeUnpaddedEPKvm; - _ZN7android6Parcel14acquireObjectsEv; - _ZN7android6Parcel14freeDataNoInitEv; - _ZN7android6Parcel14releaseObjectsEv; - _ZN7android6Parcel14writeByteArrayEmPKh; - _ZN7android6Parcel15restoreAllowFdsEb; - _ZN7android6Parcel15setDataCapacityEm; - _ZN7android6Parcel15writeBoolVectorERKNSt3__110unique_ptrINS1_6vectorIbNS1_9allocatorIbEEEENS1_14default_deleteIS6_EEEE; - _ZN7android6Parcel15writeBoolVectorERKNSt3__16vectorIbNS1_9allocatorIbEEEE; - _ZN7android6Parcel15writeBoolVectorERKNSt3__18optionalINS1_6vectorIbNS1_9allocatorIbEEEEEE; - _ZN7android6Parcel15writeByteVectorERKNSt3__110unique_ptrINS1_6vectorIaNS1_9allocatorIaEEEENS1_14default_deleteIS6_EEEE; - _ZN7android6Parcel15writeByteVectorERKNSt3__110unique_ptrINS1_6vectorIhNS1_9allocatorIhEEEENS1_14default_deleteIS6_EEEE; - _ZN7android6Parcel15writeByteVectorERKNSt3__16vectorIaNS1_9allocatorIaEEEE; - _ZN7android6Parcel15writeByteVectorERKNSt3__16vectorIhNS1_9allocatorIhEEEE; - _ZN7android6Parcel15writeByteVectorERKNSt3__18optionalINS1_6vectorIaNS1_9allocatorIaEEEEEE; - _ZN7android6Parcel15writeByteVectorERKNSt3__18optionalINS1_6vectorIhNS1_9allocatorIhEEEEEE; - _ZN7android6Parcel15writeCharVectorERKNSt3__110unique_ptrINS1_6vectorIDsNS1_9allocatorIDsEEEENS1_14default_deleteIS6_EEEE; - _ZN7android6Parcel15writeCharVectorERKNSt3__16vectorIDsNS1_9allocatorIDsEEEE; - _ZN7android6Parcel15writeCharVectorERKNSt3__18optionalINS1_6vectorIDsNS1_9allocatorIDsEEEEEE; - _ZN7android6Parcel15writeInt32ArrayEmPKi; - _ZN7android6Parcel15writeParcelableERKNS_10ParcelableE; - _ZN7android6Parcel16writeFloatVectorERKNSt3__110unique_ptrINS1_6vectorIfNS1_9allocatorIfEEEENS1_14default_deleteIS6_EEEE; - _ZN7android6Parcel16writeFloatVectorERKNSt3__16vectorIfNS1_9allocatorIfEEEE; - _ZN7android6Parcel16writeFloatVectorERKNSt3__18optionalINS1_6vectorIfNS1_9allocatorIfEEEEEE; - _ZN7android6Parcel16writeInt32VectorERKNSt3__110unique_ptrINS1_6vectorIiNS1_9allocatorIiEEEENS1_14default_deleteIS6_EEEE; - _ZN7android6Parcel16writeInt32VectorERKNSt3__16vectorIiNS1_9allocatorIiEEEE; - _ZN7android6Parcel16writeInt32VectorERKNSt3__18optionalINS1_6vectorIiNS1_9allocatorIiEEEEEE; - _ZN7android6Parcel16writeInt64VectorERKNSt3__110unique_ptrINS1_6vectorIlNS1_9allocatorIlEEEENS1_14default_deleteIS6_EEEE; - _ZN7android6Parcel16writeInt64VectorERKNSt3__16vectorIlNS1_9allocatorIlEEEE; - _ZN7android6Parcel16writeInt64VectorERKNSt3__18optionalINS1_6vectorIlNS1_9allocatorIlEEEEEE; - _ZN7android6Parcel16writeNoExceptionEv; - _ZN7android6Parcel16writeUtf8AsUtf16ERKNSt3__110unique_ptrINS1_12basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEENS1_14default_deleteIS8_EEEE; - _ZN7android6Parcel16writeUtf8AsUtf16ERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEE; - _ZN7android6Parcel16writeUtf8AsUtf16ERKNSt3__18optionalINS1_12basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEEE; - _ZN7android6Parcel17writeDoubleVectorERKNSt3__110unique_ptrINS1_6vectorIdNS1_9allocatorIdEEEENS1_14default_deleteIS6_EEEE; - _ZN7android6Parcel17writeDoubleVectorERKNSt3__16vectorIdNS1_9allocatorIdEEEE; - _ZN7android6Parcel17writeDoubleVectorERKNSt3__18optionalINS1_6vectorIdNS1_9allocatorIdEEEEEE; - _ZN7android6Parcel17writeNativeHandleEPK13native_handle; - _ZN7android6Parcel17writeStrongBinderERKNS_2spINS_7IBinderEEE; - _ZN7android6Parcel17writeUint64VectorERKNSt3__110unique_ptrINS1_6vectorImNS1_9allocatorImEEEENS1_14default_deleteIS6_EEEE; - _ZN7android6Parcel17writeUint64VectorERKNSt3__16vectorImNS1_9allocatorImEEEE; - _ZN7android6Parcel17writeUint64VectorERKNSt3__18optionalINS1_6vectorImNS1_9allocatorImEEEEEE; - _ZN7android6Parcel18getGlobalAllocSizeEv; - _ZN7android6Parcel19finishFlattenBinderERKNS_2spINS_7IBinderEEE; - _ZN7android6Parcel19getGlobalAllocCountEv; - _ZN7android6Parcel19ipcSetDataReferenceEPKhmPKymPFvPS0_S2_mS4_mE; - _ZN7android6Parcel19writeFileDescriptorEib; - _ZN7android6Parcel19writeInterfaceTokenEPKDsm; - _ZN7android6Parcel19writeInterfaceTokenERKNS_8String16E; - _ZN7android6Parcel19writeString16VectorERKNSt3__110unique_ptrINS1_6vectorINS2_INS_8String16ENS1_14default_deleteIS4_EEEENS1_9allocatorIS7_EEEENS5_ISA_EEEE; - _ZN7android6Parcel19writeString16VectorERKNSt3__16vectorINS_8String16ENS1_9allocatorIS3_EEEE; - _ZN7android6Parcel19writeString16VectorERKNSt3__18optionalINS1_6vectorINS2_INS_8String16EEENS1_9allocatorIS5_EEEEEE; - _ZN7android6Parcel20closeFileDescriptorsEv; - _ZN7android6Parcel22writeDupFileDescriptorEi; - _ZN7android6Parcel23writeStrongBinderVectorERKNSt3__110unique_ptrINS1_6vectorINS_2spINS_7IBinderEEENS1_9allocatorIS6_EEEENS1_14default_deleteIS9_EEEE; - _ZN7android6Parcel23writeStrongBinderVectorERKNSt3__16vectorINS_2spINS_7IBinderEEENS1_9allocatorIS5_EEEE; - _ZN7android6Parcel23writeStrongBinderVectorERKNSt3__18optionalINS1_6vectorINS_2spINS_7IBinderEEENS1_9allocatorIS6_EEEEEE; - _ZN7android6Parcel25writeParcelFileDescriptorEib; - _ZN7android6Parcel25writeUniqueFileDescriptorERKNS_4base14unique_fd_implINS1_13DefaultCloserEEE; - _ZN7android6Parcel26writeRawNullableParcelableEPKNS_10ParcelableE; - _ZN7android6Parcel27replaceCallingWorkSourceUidEj; - _ZN7android6Parcel28writeDupParcelFileDescriptorEi; - _ZN7android6Parcel28writeUtf8VectorAsUtf16VectorERKNSt3__110unique_ptrINS1_6vectorINS2_INS1_12basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEENS1_14default_deleteIS9_EEEENS7_ISC_EEEENSA_ISE_EEEE; - _ZN7android6Parcel28writeUtf8VectorAsUtf16VectorERKNSt3__16vectorINS1_12basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEENS6_IS8_EEEE; - _ZN7android6Parcel28writeUtf8VectorAsUtf16VectorERKNSt3__18optionalINS1_6vectorINS2_INS1_12basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEEENS7_ISA_EEEEEE; - _ZN7android6Parcel31writeUniqueFileDescriptorVectorERKNSt3__110unique_ptrINS1_6vectorINS_4base14unique_fd_implINS4_13DefaultCloserEEENS1_9allocatorIS7_EEEENS1_14default_deleteISA_EEEE; - _ZN7android6Parcel31writeUniqueFileDescriptorVectorERKNSt3__16vectorINS_4base14unique_fd_implINS3_13DefaultCloserEEENS1_9allocatorIS6_EEEE; - _ZN7android6Parcel31writeUniqueFileDescriptorVectorERKNSt3__18optionalINS1_6vectorINS_4base14unique_fd_implINS4_13DefaultCloserEEENS1_9allocatorIS7_EEEEEE; - _ZN7android6Parcel35writeDupImmutableBlobFileDescriptorEi; - _ZN7android6Parcel4Blob4initEiPvmb; - _ZN7android6Parcel4Blob5clearEv; - _ZN7android6Parcel4Blob7releaseEv; - _ZN7android6Parcel4BlobC1Ev; - _ZN7android6Parcel4BlobC2Ev; - _ZN7android6Parcel4BlobD1Ev; - _ZN7android6Parcel4BlobD2Ev; - _ZN7android6Parcel5writeEPKvm; - _ZN7android6Parcel5writeERKNS0_26FlattenableHelperInterfaceE; - _ZN7android6Parcel7setDataEPKhm; - _ZN7android6Parcel8freeDataEv; - _ZN7android6Parcel8growDataEm; - _ZN7android6Parcel8setErrorEi; - _ZN7android6Parcel9initStateEv; - _ZN7android6Parcel9writeBlobEmbPNS0_12WritableBlobE; - _ZN7android6Parcel9writeBoolEb; - _ZN7android6Parcel9writeByteEa; - _ZN7android6Parcel9writeCharEDs; - _ZN7android6ParcelC1Ev; - _ZN7android6ParcelC2Ev; - _ZN7android6ParcelD1Ev; - _ZN7android6ParcelD2Ev; - _ZN7android7BBinder10onTransactEjRKNS_6ParcelEPS1_j; - _ZN7android7BBinder10pingBinderEv; - _ZN7android7BBinder11getDebugPidEv; - _ZN7android7BBinder11isInheritRtEv; - _ZN7android7BBinder11linkToDeathERKNS_2spINS_7IBinder14DeathRecipientEEEPvj; - _ZN7android7BBinder11localBinderEv; - _ZN7android7BBinder12attachObjectEPKvPvS3_PFvS2_S3_S3_E; - _ZN7android7BBinder12detachObjectEPKv; - _ZN7android7BBinder12getExtensionEv; - _ZN7android7BBinder12setExtensionERKNS_2spINS_7IBinderEEE; - _ZN7android7BBinder12setInheritRtEb; - _ZN7android7BBinder13unlinkToDeathERKNS_2wpINS_7IBinder14DeathRecipientEEEPvjPS4_; - _ZN7android7BBinder15isRequestingSidEv; - _ZN7android7BBinder16setRequestingSidEb; - _ZN7android7BBinder17getOrCreateExtrasEv; - _ZN7android7BBinder21getMinSchedulerPolicyEv; - _ZN7android7BBinder21setMinSchedulerPolicyEii; - _ZN7android7BBinder23getMinSchedulerPriorityEv; - _ZN7android7BBinder4dumpEiRKNS_6VectorINS_8String16EEE; - _ZN7android7BBinder8transactEjRKNS_6ParcelEPS1_j; - _ZN7android7BBinderC1Ev; - _ZN7android7BBinderC2Ev; - _ZN7android7BBinderD0Ev; - _ZN7android7BBinderD1Ev; - _ZN7android7BBinderD2Ev; - _ZN7android7content2pm18PackageChangeEvent14readFromParcelEPKNS_6ParcelE; - _ZN7android7content2pm21IPackageManagerNative10descriptorE; - _ZN7android7content2pm21IPackageManagerNative11asInterfaceERKNS_2spINS_7IBinderEEE; - _ZN7android7content2pm21IPackageManagerNative12default_implE; - _ZN7android7content2pm21IPackageManagerNative14getDefaultImplEv; - _ZN7android7content2pm21IPackageManagerNative14setDefaultImplENSt3__110unique_ptrIS2_NS3_14default_deleteIS2_EEEE; - _ZN7android7content2pm21IPackageManagerNativeC2Ev; - _ZN7android7content2pm21IPackageManagerNativeD0Ev; - _ZN7android7content2pm21IPackageManagerNativeD1Ev; - _ZN7android7content2pm21IPackageManagerNativeD2Ev; - _ZN7android7content2pm22BnPackageManagerNative10onTransactEjRKNS_6ParcelEPS3_j; - _ZN7android7content2pm22BnPackageManagerNativeC2Ev; - _ZN7android7content2pm22BpPackageManagerNative14getAllPackagesEPNSt3__16vectorINS3_12basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEENS8_ISA_EEEE; - _ZN7android7content2pm22BpPackageManagerNative15getNamesForUidsERKNSt3__16vectorIiNS3_9allocatorIiEEEEPNS4_INS3_12basic_stringIcNS3_11char_traitsIcEENS5_IcEEEENS5_ISE_EEEE; - _ZN7android7content2pm22BpPackageManagerNative16getLocationFlagsERKNSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEPi; - _ZN7android7content2pm22BpPackageManagerNative16hasSystemFeatureERKNS_8String16EiPb; - _ZN7android7content2pm22BpPackageManagerNative19isPackageDebuggableERKNS_8String16EPb; - _ZN7android7content2pm22BpPackageManagerNative22getInstallerForPackageERKNS_8String16EPNSt3__112basic_stringIcNS6_11char_traitsIcEENS6_9allocatorIcEEEE; - _ZN7android7content2pm22BpPackageManagerNative24getVersionCodeForPackageERKNS_8String16EPl; - _ZN7android7content2pm22BpPackageManagerNative27hasSha256SigningCertificateERKNSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEERKNS3_6vectorIhNS7_IhEEEEPb; - _ZN7android7content2pm22BpPackageManagerNative28getModuleMetadataPackageNameEPNSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEE; - _ZN7android7content2pm22BpPackageManagerNative29getTargetSdkVersionForPackageERKNS_8String16EPi; - _ZN7android7content2pm22BpPackageManagerNative29isAudioPlaybackCaptureAllowedERKNSt3__16vectorINS3_12basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEENS8_ISA_EEEEPNS4_IbNS8_IbEEEE; - _ZN7android7content2pm22BpPackageManagerNative29registerPackageChangeObserverERKNS_2spINS1_22IPackageChangeObserverEEE; - _ZN7android7content2pm22BpPackageManagerNative31unregisterPackageChangeObserverERKNS_2spINS1_22IPackageChangeObserverEEE; - _ZN7android7content2pm22BpPackageManagerNativeC1ERKNS_2spINS_7IBinderEEE; - _ZN7android7content2pm22BpPackageManagerNativeC2ERKNS_2spINS_7IBinderEEE; - _ZN7android7content2pm22IPackageChangeObserver10descriptorE; - _ZN7android7content2pm22IPackageChangeObserver11asInterfaceERKNS_2spINS_7IBinderEEE; - _ZN7android7content2pm22IPackageChangeObserver12default_implE; - _ZN7android7content2pm22IPackageChangeObserver14getDefaultImplEv; - _ZN7android7content2pm22IPackageChangeObserver14setDefaultImplENSt3__110unique_ptrIS2_NS3_14default_deleteIS2_EEEE; - _ZN7android7content2pm22IPackageChangeObserverC2Ev; - _ZN7android7content2pm22IPackageChangeObserverD0Ev; - _ZN7android7content2pm22IPackageChangeObserverD1Ev; - _ZN7android7content2pm22IPackageChangeObserverD2Ev; - _ZN7android7content2pm23BnPackageChangeObserver10onTransactEjRKNS_6ParcelEPS3_j; - _ZN7android7content2pm23BnPackageChangeObserverC2Ev; - _ZN7android7content2pm23BpPackageChangeObserver16onPackageChangedERKNS1_18PackageChangeEventE; - _ZN7android7content2pm23BpPackageChangeObserverC1ERKNS_2spINS_7IBinderEEE; - _ZN7android7content2pm23BpPackageChangeObserverC2ERKNS_2spINS_7IBinderEEE; - _ZN7android7HexDumpC1EPKvmm; - _ZN7android7HexDumpC2EPKvmm; - _ZN7android7IBinder11getDebugPidEPi; - _ZN7android7IBinder11localBinderEv; - _ZN7android7IBinder12getExtensionEPNS_2spIS0_EE; - _ZN7android7IBinder12remoteBinderEv; - _ZN7android7IBinder12shellCommandERKNS_2spIS0_EEiiiRNS_6VectorINS_8String16EEERKNS1_INS_14IShellCallbackEEERKNS1_INS_15IResultReceiverEEE; - _ZN7android7IBinder19queryLocalInterfaceERKNS_8String16E; - _ZN7android7IBinderC2Ev; - _ZN7android7IBinderD0Ev; - _ZN7android7IBinderD1Ev; - _ZN7android7IBinderD2Ev; - _ZN7android7IMemory10descriptorE; - _ZN7android7IMemory11asInterfaceERKNS_2spINS_7IBinderEEE; - _ZN7android7IMemory12default_implE; - _ZN7android7IMemory14getDefaultImplEv; - _ZN7android7IMemory14setDefaultImplENSt3__110unique_ptrIS0_NS1_14default_deleteIS0_EEEE; - _ZN7android7IMemoryC2Ev; - _ZN7android7IMemoryD0Ev; - _ZN7android7IMemoryD1Ev; - _ZN7android7IMemoryD2Ev; - _ZN7android8BnMemory10onTransactEjRKNS_6ParcelEPS1_j; - _ZN7android8BnMemoryC2Ev; - _ZN7android8BnMemoryD0Ev; - _ZN7android8BnMemoryD1Ev; - _ZN7android8BnMemoryD2Ev; - _ZN7android8BpBinder10onFirstRefEv; - _ZN7android8BpBinder10pingBinderEv; - _ZN7android8BpBinder11linkToDeathERKNS_2spINS_7IBinder14DeathRecipientEEEPvj; - _ZN7android8BpBinder12attachObjectEPKvPvS3_PFvS2_S3_S3_E; - _ZN7android8BpBinder12detachObjectEPKv; - _ZN7android8BpBinder12remoteBinderEv; - _ZN7android8BpBinder12sendObituaryEv; - _ZN7android8BpBinder12sTrackingMapE; - _ZN7android8BpBinder13getCountByUidERNS_6VectorIjEES3_; - _ZN7android8BpBinder13ObjectManager4killEv; - _ZN7android8BpBinder13ObjectManager6attachEPKvPvS4_PFvS3_S4_S4_E; - _ZN7android8BpBinder13ObjectManager6detachEPKv; - _ZN7android8BpBinder13ObjectManagerC1Ev; - _ZN7android8BpBinder13ObjectManagerC2Ev; - _ZN7android8BpBinder13ObjectManagerD1Ev; - _ZN7android8BpBinder13ObjectManagerD2Ev; - _ZN7android8BpBinder13sTrackingLockE; - _ZN7android8BpBinder13unlinkToDeathERKNS_2wpINS_7IBinder14DeathRecipientEEEPvjPS4_; - _ZN7android8BpBinder14reportOneDeathERKNS0_8ObituaryE; - _ZN7android8BpBinder14sLimitCallbackE; - _ZN7android8BpBinder15onLastStrongRefEPKv; - _ZN7android8BpBinder15sNumTrackedUidsE; - _ZN7android8BpBinder16enableCountByUidEv; - _ZN7android8BpBinder16setLimitCallbackEPFviE; - _ZN7android8BpBinder17disableCountByUidEv; - _ZN7android8BpBinder18sCountByUidEnabledE; - _ZN7android8BpBinder19getBinderProxyCountEj; - _ZN7android8BpBinder20onIncStrongAttemptedEjPKv; - _ZN7android8BpBinder20setCountByUidEnabledEb; - _ZN7android8BpBinder26sBinderProxyThrottleCreateE; - _ZN7android8BpBinder29sBinderProxyCountLowWatermarkE; - _ZN7android8BpBinder29setBinderProxyCountWatermarksEii; - _ZN7android8BpBinder30sBinderProxyCountHighWatermarkE; - _ZN7android8BpBinder4dumpEiRKNS_6VectorINS_8String16EEE; - _ZN7android8BpBinder6createEi; - _ZN7android8BpBinder6createERKNS_2spINS_10RpcSessionEEERKNS_10RpcAddressE; - _ZN7android8BpBinder8transactEjRKNS_6ParcelEPS1_j; - _ZN7android8BpBinderC1EONS0_12BinderHandleEi; - _ZN7android8BpBinderC1EONS0_9RpcHandleE; - _ZN7android8BpBinderC1EONSt3__17variantIJNS0_12BinderHandleENS0_9RpcHandleEEEE; - _ZN7android8BpBinderC2EONS0_12BinderHandleEi; - _ZN7android8BpBinderC2EONS0_9RpcHandleE; - _ZN7android8BpBinderC2EONSt3__17variantIJNS0_12BinderHandleENS0_9RpcHandleEEEE; - _ZN7android8BpBinderD0Ev; - _ZN7android8BpBinderD1Ev; - _ZN7android8BpBinderD2Ev; - _ZN7android8BpMemoryC1ERKNS_2spINS_7IBinderEEE; - _ZN7android8BpMemoryC2ERKNS_2spINS_7IBinderEEE; - _ZN7android8BpMemoryD0Ev; - _ZN7android8BpMemoryD1Ev; - _ZN7android8BpMemoryD2Ev; - _ZN7android8internal9Stability11getCategoryEPNS_7IBinderE; - _ZN7android8internal9Stability11levelStringENS1_5LevelE; - _ZN7android8internal9Stability13getLocalLevelEv; - _ZN7android8internal9Stability15isDeclaredLevelENS1_5LevelE; - _ZN7android8internal9Stability17debugLogStabilityERKNSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEERKNS_2spINS_7IBinderEEE; - _ZN7android8internal9Stability19markCompilationUnitEPNS_7IBinderE; - _ZN7android8internal9Stability22tryMarkCompilationUnitEPNS_7IBinderE; - _ZN7android8internal9Stability24requiresVintfDeclarationERKNS_2spINS_7IBinderEEE; - _ZN7android8internal9Stability25forceDowngradeToStabilityERKNS_2spINS_7IBinderEEENS1_5LevelE; - _ZN7android8internal9Stability30forceDowngradeToLocalStabilityERKNS_2spINS_7IBinderEEE; - _ZN7android8internal9Stability31forceDowngradeToSystemStabilityERKNS_2spINS_7IBinderEEE; - _ZN7android8internal9Stability31forceDowngradeToVendorStabilityERKNS_2spINS_7IBinderEEE; - _ZN7android8internal9Stability5checkENS1_8CategoryENS1_5LevelE; - _ZN7android8internal9Stability7setReprEPNS_7IBinderEij; - _ZN7android8internal9Stability8Category11debugStringEv; - _ZN7android8internal9Stability8markVndkEPNS_7IBinderE; - _ZN7android8internal9Stability9markVintfEPNS_7IBinderE; - _ZN7android8RpcState11CommandDataC1Em; - _ZN7android8RpcState11CommandDataC2Em; - _ZN7android8RpcState12countBindersEv; - _ZN7android8RpcState12getSessionIdERKNS_4base14unique_fd_implINS1_13DefaultCloserEEERKNS_2spINS_10RpcSessionEEEPi; - _ZN7android8RpcState12waitForReplyERKNS_4base14unique_fd_implINS1_13DefaultCloserEEERKNS_2spINS_10RpcSessionEEEPNS_6ParcelE; - _ZN7android8RpcState13getMaxThreadsERKNS_4base14unique_fd_implINS1_13DefaultCloserEEERKNS_2spINS_10RpcSessionEEEPm; - _ZN7android8RpcState13getRootObjectERKNS_4base14unique_fd_implINS1_13DefaultCloserEEERKNS_2spINS_10RpcSessionEEE; - _ZN7android8RpcState13sendDecStrongERKNS_4base14unique_fd_implINS1_13DefaultCloserEEERKNS_10RpcAddressE; - _ZN7android8RpcState15onBinderLeavingERKNS_2spINS_10RpcSessionEEERKNS1_INS_7IBinderEEEPNS_10RpcAddressE; - _ZN7android8RpcState15processTransactERKNS_4base14unique_fd_implINS1_13DefaultCloserEEERKNS_2spINS_10RpcSessionEEERKNS_13RpcWireHeaderE; - _ZN7android8RpcState16onBinderEnteringERKNS_2spINS_10RpcSessionEEERKNS_10RpcAddressE; - _ZN7android8RpcState16processDecStrongERKNS_4base14unique_fd_implINS1_13DefaultCloserEEERKNS_13RpcWireHeaderE; - _ZN7android8RpcState20getAndExecuteCommandERKNS_4base14unique_fd_implINS1_13DefaultCloserEEERKNS_2spINS_10RpcSessionEEE; - _ZN7android8RpcState20processServerCommandERKNS_4base14unique_fd_implINS1_13DefaultCloserEEERKNS_2spINS_10RpcSessionEEERKNS_13RpcWireHeaderE; - _ZN7android8RpcState23processTransactInternalERKNS_4base14unique_fd_implINS1_13DefaultCloserEEERKNS_2spINS_10RpcSessionEEENS0_11CommandDataE; - _ZN7android8RpcState4dumpEv; - _ZN7android8RpcState6rpcRecERKNS_4base14unique_fd_implINS1_13DefaultCloserEEEPKcPvm; - _ZN7android8RpcState7rpcSendERKNS_4base14unique_fd_implINS1_13DefaultCloserEEEPKcPKvm; - _ZN7android8RpcState8transactERKNS_4base14unique_fd_implINS1_13DefaultCloserEEERKNS_10RpcAddressEjRKNS_6ParcelERKNS_2spINS_10RpcSessionEEEPSA_j; - _ZN7android8RpcState9terminateEv; - _ZN7android8RpcStateC1Ev; - _ZN7android8RpcStateC2Ev; - _ZN7android8RpcStateD1Ev; - _ZN7android8RpcStateD2Ev; - _ZN7android9BpRefBase10onFirstRefEv; - _ZN7android9BpRefBase15onLastStrongRefEPKv; - _ZN7android9BpRefBase20onIncStrongAttemptedEjPKv; - _ZN7android9BpRefBaseC1ERKNS_2spINS_7IBinderEEE; - _ZN7android9BpRefBaseC2ERKNS_2spINS_7IBinderEEE; - _ZN7android9BpRefBaseD0Ev; - _ZN7android9BpRefBaseD1Ev; - _ZN7android9BpRefBaseD2Ev; - _ZN7android9HeapCache10binderDiedERKNS_2wpINS_7IBinderEEE; - _ZN7android9HeapCache10dump_heapsEv; - _ZN7android9HeapCache8get_heapERKNS_2spINS_7IBinderEEE; - _ZN7android9HeapCache9find_heapERKNS_2spINS_7IBinderEEE; - _ZN7android9HeapCache9free_heapERKNS_2spINS_7IBinderEEE; - _ZN7android9HeapCache9free_heapERKNS_2wpINS_7IBinderEEE; - _ZN7android9HeapCacheC1Ev; - _ZN7android9HeapCacheC2Ev; - _ZN7android9HeapCacheD0Ev; - _ZN7android9HeapCacheD1Ev; - _ZN7android9HeapCacheD2Ev; - _ZN7android9hexStringEPKvm; - _ZN7android9RpcServer12listSessionsEv; - _ZN7android9RpcServer13getMaxThreadsEv; - _ZN7android9RpcServer13getRootObjectEv; - _ZN7android9RpcServer13releaseServerEv; - _ZN7android9RpcServer13setMaxThreadsEm; - _ZN7android9RpcServer13setRootObjectERKNS_2spINS_7IBinderEEE; - _ZN7android9RpcServer15setupInetServerEjPj; - _ZN7android9RpcServer16setupVsockServerEj; - _ZN7android9RpcServer17setRootObjectWeakERKNS_2wpINS_7IBinderEEE; - _ZN7android9RpcServer17setupSocketServerERKNS_16RpcSocketAddressE; - _ZN7android9RpcServer19establishConnectionEONS_2spIS0_EENS_4base14unique_fd_implINS4_13DefaultCloserEEE; - _ZN7android9RpcServer19setupExternalServerENS_4base14unique_fd_implINS1_13DefaultCloserEEE; - _ZN7android9RpcServer20onSessionTerminatingERKNS_2spINS_10RpcSessionEEE; - _ZN7android9RpcServer21setupUnixDomainServerEPKc; - _ZN7android9RpcServer24numUninitializedSessionsEv; - _ZN7android9RpcServer4joinEv; - _ZN7android9RpcServer4makeEv; - _ZN7android9RpcServer61iUnderstandThisCodeIsExperimentalAndIWillNotUseItInProductionEv; - _ZN7android9RpcServer9acceptOneEv; - _ZN7android9RpcServer9hasServerEv; - _ZN7android9RpcServerC1Ev; - _ZN7android9RpcServerC2Ev; - _ZN7android9RpcServerD0Ev; - _ZN7android9RpcServerD1Ev; - _ZN7android9RpcServerD2Ev; - _ZN7androidlsERNS_10TextOutputERKNS_7HexDumpE; - _ZN7androidlsERNS_10TextOutputERKNS_8TypeCodeE; - _ZN7androidlsIA15_cEERNS_10TextOutputES3_RKT_; - _ZN7androidlsIA24_cEERNS_10TextOutputES3_RKT_; - _ZN7androidlsIA2_cEERNS_10TextOutputES3_RKT_; - _ZN7androidlsIA34_cEERNS_10TextOutputES3_RKT_; - _ZN7androidlsIA3_cEERNS_10TextOutputES3_RKT_; - _ZN7androidlsIA43_cEERNS_10TextOutputES3_RKT_; - _ZN7androidlsIA4_cEERNS_10TextOutputES3_RKT_; - _ZN7androidlsIA5_cEERNS_10TextOutputES3_RKT_; - _ZN7androidlsIA8_cEERNS_10TextOutputES3_RKT_; - _ZN7androidlsIA9_cEERNS_10TextOutputES3_RKT_; - _ZN7androidlsIjEERNS_10TextOutputES2_RKT_; - _ZN7androidlsImEERNS_10TextOutputES2_RKT_; - _ZN7androidlsINSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEEERNS_10TextOutputES9_RKT_; - _ZN7androidlsIPcEERNS_10TextOutputES3_RKT_; - _ZN7androidlsIPvEERNS_10TextOutputES3_RKT_; - _ZN7androidlsIyEERNS_10TextOutputES2_RKT_; - _ZNK7android10MemoryBase9getMemoryEPlPm; - _ZNK7android10RpcAddress13writeToParcelEPNS_6ParcelE; - _ZNK7android10RpcAddress15viewRawEmbeddedEv; - _ZNK7android10RpcAddress6isZeroEv; - _ZNK7android10RpcAddress8toStringEv; - _ZNK7android10RpcAddressltERKS0_; - _ZNK7android11IMemoryHeap22getInterfaceDescriptorEv; - _ZNK7android12BpMemoryHeap12assertMappedEv; - _ZNK7android12BpMemoryHeap18assertReallyMappedEv; - _ZNK7android12BpMemoryHeap7getBaseEv; - _ZNK7android12BpMemoryHeap7getSizeEv; - _ZNK7android12BpMemoryHeap8getFlagsEv; - _ZNK7android12BpMemoryHeap9getHeapIDEv; - _ZNK7android12BpMemoryHeap9getOffsetEv; - _ZNK7android12MemoryDealer4dumpEPKc; - _ZNK7android12MemoryDealer4heapEv; - _ZNK7android12MemoryDealer9allocatorEv; - _ZNK7android12SortedVectorINS_16key_value_pair_tINS_2wpINS_7IBinderEEENS_9HeapCache11heap_info_tEEEE10do_compareEPKvSA_; - _ZNK7android12SortedVectorINS_16key_value_pair_tINS_2wpINS_7IBinderEEENS_9HeapCache11heap_info_tEEEE10do_destroyEPvm; - _ZNK7android12SortedVectorINS_16key_value_pair_tINS_2wpINS_7IBinderEEENS_9HeapCache11heap_info_tEEEE12do_constructEPvm; - _ZNK7android12SortedVectorINS_16key_value_pair_tINS_2wpINS_7IBinderEEENS_9HeapCache11heap_info_tEEEE15do_move_forwardEPvPKvm; - _ZNK7android12SortedVectorINS_16key_value_pair_tINS_2wpINS_7IBinderEEENS_9HeapCache11heap_info_tEEEE16do_move_backwardEPvPKvm; - _ZNK7android12SortedVectorINS_16key_value_pair_tINS_2wpINS_7IBinderEEENS_9HeapCache11heap_info_tEEEE7do_copyEPvPKvm; - _ZNK7android12SortedVectorINS_16key_value_pair_tINS_2wpINS_7IBinderEEENS_9HeapCache11heap_info_tEEEE8do_splatEPvPKvm; - _ZNK7android12SortedVectorINS_16key_value_pair_tIPKvNS_8BpBinder13ObjectManager7entry_tEEEE10do_compareES3_S3_; - _ZNK7android12SortedVectorINS_16key_value_pair_tIPKvNS_8BpBinder13ObjectManager7entry_tEEEE10do_destroyEPvm; - _ZNK7android12SortedVectorINS_16key_value_pair_tIPKvNS_8BpBinder13ObjectManager7entry_tEEEE12do_constructEPvm; - _ZNK7android12SortedVectorINS_16key_value_pair_tIPKvNS_8BpBinder13ObjectManager7entry_tEEEE15do_move_forwardEPvS3_m; - _ZNK7android12SortedVectorINS_16key_value_pair_tIPKvNS_8BpBinder13ObjectManager7entry_tEEEE16do_move_backwardEPvS3_m; - _ZNK7android12SortedVectorINS_16key_value_pair_tIPKvNS_8BpBinder13ObjectManager7entry_tEEEE7do_copyEPvS3_m; - _ZNK7android12SortedVectorINS_16key_value_pair_tIPKvNS_8BpBinder13ObjectManager7entry_tEEEE8do_splatEPvS3_m; - _ZNK7android14IPCThreadState13getCallingPidEv; - _ZNK7android14IPCThreadState13getCallingSidEv; - _ZNK7android14IPCThreadState13getCallingUidEv; - _ZNK7android14IPCThreadState18getCallRestrictionEv; - _ZNK7android14IPCThreadState19getStrictModePolicyEv; - _ZNK7android14IPCThreadState22getServingStackPointerEv; - _ZNK7android14IPCThreadState23getCallingWorkSourceUidEv; - _ZNK7android14IPCThreadState25shouldPropagateWorkSourceEv; - _ZNK7android14IPCThreadState29getLastTransactionBinderFlagsEv; - _ZNK7android14IShellCallback22getInterfaceDescriptorEv; - _ZNK7android14MemoryHeapBase7getBaseEv; - _ZNK7android14MemoryHeapBase7getSizeEv; - _ZNK7android14MemoryHeapBase8getFlagsEv; - _ZNK7android14MemoryHeapBase9getDeviceEv; - _ZNK7android14MemoryHeapBase9getHeapIDEv; - _ZNK7android14MemoryHeapBase9getOffsetEv; - _ZNK7android15IResultReceiver22getInterfaceDescriptorEv; - _ZNK7android15IServiceManager22getInterfaceDescriptorEv; - _ZNK7android18BufferedTextOutput9getBufferEv; - _ZNK7android18ServiceManagerShim10getServiceERKNS_8String16E; - _ZNK7android18ServiceManagerShim12checkServiceERKNS_8String16E; - _ZNK7android22SimpleBestFitAllocator4dumpEPKc; - _ZNK7android22SimpleBestFitAllocator4dumpERNS_7String8EPKc; - _ZNK7android22SimpleBestFitAllocator4sizeEv; - _ZNK7android22SimpleBestFitAllocator6dump_lEPKc; - _ZNK7android22SimpleBestFitAllocator6dump_lERNS_7String8EPKc; - _ZNK7android2os15IClientCallback22getInterfaceDescriptorEv; - _ZNK7android2os15IServiceManager22getInterfaceDescriptorEv; - _ZNK7android2os16IServiceCallback22getInterfaceDescriptorEv; - _ZNK7android2os16ParcelableHolder13writeToParcelEPNS_6ParcelE; - _ZNK7android2os16ServiceDebugInfo13writeToParcelEPNS_6ParcelE; - _ZNK7android2os17PersistableBundle10getBooleanERKNS_8String16EPb; - _ZNK7android2os17PersistableBundle10getIntKeysEv; - _ZNK7android2os17PersistableBundle11getLongKeysEv; - _ZNK7android2os17PersistableBundle12getIntVectorERKNS_8String16EPNSt3__16vectorIiNS5_9allocatorIiEEEE; - _ZNK7android2os17PersistableBundle13getDoubleKeysEv; - _ZNK7android2os17PersistableBundle13getLongVectorERKNS_8String16EPNSt3__16vectorIlNS5_9allocatorIlEEEE; - _ZNK7android2os17PersistableBundle13getStringKeysEv; - _ZNK7android2os17PersistableBundle13writeToParcelEPNS_6ParcelE; - _ZNK7android2os17PersistableBundle14getBooleanKeysEv; - _ZNK7android2os17PersistableBundle15getDoubleVectorERKNS_8String16EPNSt3__16vectorIdNS5_9allocatorIdEEEE; - _ZNK7android2os17PersistableBundle15getStringVectorERKNS_8String16EPNSt3__16vectorIS2_NS5_9allocatorIS2_EEEE; - _ZNK7android2os17PersistableBundle16getBooleanVectorERKNS_8String16EPNSt3__16vectorIbNS5_9allocatorIbEEEE; - _ZNK7android2os17PersistableBundle16getIntVectorKeysEv; - _ZNK7android2os17PersistableBundle17getLongVectorKeysEv; - _ZNK7android2os17PersistableBundle18writeToParcelInnerEPNS_6ParcelE; - _ZNK7android2os17PersistableBundle19getDoubleVectorKeysEv; - _ZNK7android2os17PersistableBundle19getStringVectorKeysEv; - _ZNK7android2os17PersistableBundle20getBooleanVectorKeysEv; - _ZNK7android2os17PersistableBundle20getPersistableBundleERKNS_8String16EPS1_; - _ZNK7android2os17PersistableBundle24getPersistableBundleKeysEv; - _ZNK7android2os17PersistableBundle4sizeEv; - _ZNK7android2os17PersistableBundle5emptyEv; - _ZNK7android2os17PersistableBundle6getIntERKNS_8String16EPi; - _ZNK7android2os17PersistableBundle7getLongERKNS_8String16EPl; - _ZNK7android2os17PersistableBundle9getDoubleERKNS_8String16EPd; - _ZNK7android2os17PersistableBundle9getStringERKNS_8String16EPS2_; - _ZNK7android2os20ParcelFileDescriptor13writeToParcelEPNS_6ParcelE; - _ZNK7android6binder6Status13writeToParcelEPNS_6ParcelE; - _ZNK7android6binder6Status9toString8Ev; - _ZNK7android6Parcel10errorCheckEv; - _ZNK7android6Parcel10ipcObjectsEv; - _ZNK7android6Parcel10readDoubleEPd; - _ZNK7android6Parcel10readDoubleEv; - _ZNK7android6Parcel10readObjectEb; - _ZNK7android6Parcel10readUint32EPj; - _ZNK7android6Parcel10readUint32Ev; - _ZNK7android6Parcel10readUint64EPm; - _ZNK7android6Parcel10readUint64Ev; - _ZNK7android6Parcel10scanForFdsEv; - _ZNK7android6Parcel11ipcDataSizeEv; - _ZNK7android6Parcel11readCStringEv; - _ZNK7android6Parcel11readInplaceEm; - _ZNK7android6Parcel11readPointerEPm; - _ZNK7android6Parcel11readPointerEv; - _ZNK7android6Parcel11readString8EPNS_7String8E; - _ZNK7android6Parcel11readString8Ev; - _ZNK7android6Parcel12dataCapacityEv; - _ZNK7android6Parcel12dataPositionEv; - _ZNK7android6Parcel12objectsCountEv; - _ZNK7android6Parcel12readString16EPNS_8String16E; - _ZNK7android6Parcel12readString16EPNSt3__110unique_ptrINS_8String16ENS1_14default_deleteIS3_EEEE; - _ZNK7android6Parcel12readString16EPNSt3__18optionalINS_8String16EEE; - _ZNK7android6Parcel12readString16Ev; - _ZNK7android6Parcel13markSensitiveEv; - _ZNK7android6Parcel14checkInterfaceEPNS_7IBinderE; - _ZNK7android6Parcel14readBoolVectorEPNSt3__110unique_ptrINS1_6vectorIbNS1_9allocatorIbEEEENS1_14default_deleteIS6_EEEE; - _ZNK7android6Parcel14readBoolVectorEPNSt3__16vectorIbNS1_9allocatorIbEEEE; - _ZNK7android6Parcel14readBoolVectorEPNSt3__18optionalINS1_6vectorIbNS1_9allocatorIbEEEEEE; - _ZNK7android6Parcel14readByteVectorEPNSt3__110unique_ptrINS1_6vectorIaNS1_9allocatorIaEEEENS1_14default_deleteIS6_EEEE; - _ZNK7android6Parcel14readByteVectorEPNSt3__110unique_ptrINS1_6vectorIhNS1_9allocatorIhEEEENS1_14default_deleteIS6_EEEE; - _ZNK7android6Parcel14readByteVectorEPNSt3__16vectorIaNS1_9allocatorIaEEEE; - _ZNK7android6Parcel14readByteVectorEPNSt3__16vectorIhNS1_9allocatorIhEEEE; - _ZNK7android6Parcel14readByteVectorEPNSt3__18optionalINS1_6vectorIaNS1_9allocatorIaEEEEEE; - _ZNK7android6Parcel14readByteVectorEPNSt3__18optionalINS1_6vectorIhNS1_9allocatorIhEEEEEE; - _ZNK7android6Parcel14readCharVectorEPNSt3__110unique_ptrINS1_6vectorIDsNS1_9allocatorIDsEEEENS1_14default_deleteIS6_EEEE; - _ZNK7android6Parcel14readCharVectorEPNSt3__16vectorIDsNS1_9allocatorIDsEEEE; - _ZNK7android6Parcel14readCharVectorEPNSt3__18optionalINS1_6vectorIDsNS1_9allocatorIDsEEEEEE; - _ZNK7android6Parcel14readParcelableEPNS_10ParcelableE; - _ZNK7android6Parcel15ipcObjectsCountEv; - _ZNK7android6Parcel15readFloatVectorEPNSt3__110unique_ptrINS1_6vectorIfNS1_9allocatorIfEEEENS1_14default_deleteIS6_EEEE; - _ZNK7android6Parcel15readFloatVectorEPNSt3__16vectorIfNS1_9allocatorIfEEEE; - _ZNK7android6Parcel15readFloatVectorEPNSt3__18optionalINS1_6vectorIfNS1_9allocatorIfEEEEEE; - _ZNK7android6Parcel15readInt32VectorEPNSt3__110unique_ptrINS1_6vectorIiNS1_9allocatorIiEEEENS1_14default_deleteIS6_EEEE; - _ZNK7android6Parcel15readInt32VectorEPNSt3__16vectorIiNS1_9allocatorIiEEEE; - _ZNK7android6Parcel15readInt32VectorEPNSt3__18optionalINS1_6vectorIiNS1_9allocatorIiEEEEEE; - _ZNK7android6Parcel15readInt64VectorEPNSt3__110unique_ptrINS1_6vectorIlNS1_9allocatorIlEEEENS1_14default_deleteIS6_EEEE; - _ZNK7android6Parcel15readInt64VectorEPNSt3__16vectorIlNS1_9allocatorIlEEEE; - _ZNK7android6Parcel15readInt64VectorEPNSt3__18optionalINS1_6vectorIlNS1_9allocatorIlEEEEEE; - _ZNK7android6Parcel15setDataPositionEm; - _ZNK7android6Parcel15unflattenBinderEPNS_2spINS_7IBinderEEE; - _ZNK7android6Parcel16enforceInterfaceEPKDsmPNS_14IPCThreadStateE; - _ZNK7android6Parcel16enforceInterfaceERKNS_8String16EPNS_14IPCThreadStateE; - _ZNK7android6Parcel16readDoubleVectorEPNSt3__110unique_ptrINS1_6vectorIdNS1_9allocatorIdEEEENS1_14default_deleteIS6_EEEE; - _ZNK7android6Parcel16readDoubleVectorEPNSt3__16vectorIdNS1_9allocatorIdEEEE; - _ZNK7android6Parcel16readDoubleVectorEPNSt3__18optionalINS1_6vectorIdNS1_9allocatorIdEEEEEE; - _ZNK7android6Parcel16readNativeHandleEv; - _ZNK7android6Parcel16readStrongBinderEPNS_2spINS_7IBinderEEE; - _ZNK7android6Parcel16readStrongBinderEv; - _ZNK7android6Parcel16readStrongBinderINS_2os15IClientCallbackEEEiPNS_2spIT_EE; - _ZNK7android6Parcel16readStrongBinderINS_2os16IServiceCallbackEEEiPNS_2spIT_EE; - _ZNK7android6Parcel16readStrongBinderINS_7content2pm22IPackageChangeObserverEEEiPNS_2spIT_EE; - _ZNK7android6Parcel16readUint64VectorEPNSt3__110unique_ptrINS1_6vectorImNS1_9allocatorImEEEENS1_14default_deleteIS6_EEEE; - _ZNK7android6Parcel16readUint64VectorEPNSt3__16vectorImNS1_9allocatorImEEEE; - _ZNK7android6Parcel16readUint64VectorEPNSt3__18optionalINS1_6vectorImNS1_9allocatorImEEEEEE; - _ZNK7android6Parcel16validateReadDataEm; - _ZNK7android6Parcel17getBlobAshmemSizeEv; - _ZNK7android6Parcel17getOpenAshmemSizeEv; - _ZNK7android6Parcel17readExceptionCodeEv; - _ZNK7android6Parcel17readUtf8FromUtf16EPNSt3__110unique_ptrINS1_12basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEENS1_14default_deleteIS8_EEEE; - _ZNK7android6Parcel17readUtf8FromUtf16EPNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEE; - _ZNK7android6Parcel17readUtf8FromUtf16EPNSt3__18optionalINS1_12basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEEE; - _ZNK7android6Parcel18hasFileDescriptorsEv; - _ZNK7android6Parcel18readFileDescriptorEv; - _ZNK7android6Parcel18readString16VectorEPNSt3__110unique_ptrINS1_6vectorINS2_INS_8String16ENS1_14default_deleteIS4_EEEENS1_9allocatorIS7_EEEENS5_ISA_EEEE; - _ZNK7android6Parcel18readString16VectorEPNSt3__16vectorINS_8String16ENS1_9allocatorIS3_EEEE; - _ZNK7android6Parcel18readString16VectorEPNSt3__18optionalINS1_6vectorINS2_INS_8String16EEENS1_9allocatorIS5_EEEEEE; - _ZNK7android6Parcel18readString8InplaceEPm; - _ZNK7android6Parcel19readString16InplaceEPm; - _ZNK7android6Parcel21finishUnflattenBinderERKNS_2spINS_7IBinderEEEPS3_; - _ZNK7android6Parcel22readStrongBinderVectorEPNSt3__110unique_ptrINS1_6vectorINS_2spINS_7IBinderEEENS1_9allocatorIS6_EEEENS1_14default_deleteIS9_EEEE; - _ZNK7android6Parcel22readStrongBinderVectorEPNSt3__16vectorINS_2spINS_7IBinderEEENS1_9allocatorIS5_EEEE; - _ZNK7android6Parcel22readStrongBinderVectorEPNSt3__18optionalINS1_6vectorINS_2spINS_7IBinderEEENS1_9allocatorIS6_EEEEEE; - _ZNK7android6Parcel24readCallingWorkSourceUidEv; - _ZNK7android6Parcel24readNullableStrongBinderEPNS_2spINS_7IBinderEEE; - _ZNK7android6Parcel24readParcelFileDescriptorEv; - _ZNK7android6Parcel24readUniqueFileDescriptorEPNS_4base14unique_fd_implINS1_13DefaultCloserEEE; - _ZNK7android6Parcel29readUtf8VectorFromUtf16VectorEPNSt3__110unique_ptrINS1_6vectorINS2_INS1_12basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEENS1_14default_deleteIS9_EEEENS7_ISC_EEEENSA_ISE_EEEE; - _ZNK7android6Parcel29readUtf8VectorFromUtf16VectorEPNSt3__16vectorINS1_12basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEENS6_IS8_EEEE; - _ZNK7android6Parcel29readUtf8VectorFromUtf16VectorEPNSt3__18optionalINS1_6vectorINS2_INS1_12basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEEENS7_ISA_EEEEEE; - _ZNK7android6Parcel30readUniqueFileDescriptorVectorEPNSt3__110unique_ptrINS1_6vectorINS_4base14unique_fd_implINS4_13DefaultCloserEEENS1_9allocatorIS7_EEEENS1_14default_deleteISA_EEEE; - _ZNK7android6Parcel30readUniqueFileDescriptorVectorEPNSt3__16vectorINS_4base14unique_fd_implINS3_13DefaultCloserEEENS1_9allocatorIS6_EEEE; - _ZNK7android6Parcel30readUniqueFileDescriptorVectorEPNSt3__18optionalINS1_6vectorINS_4base14unique_fd_implINS4_13DefaultCloserEEENS1_9allocatorIS7_EEEEEE; - _ZNK7android6Parcel30readUniqueParcelFileDescriptorEPNS_4base14unique_fd_implINS1_13DefaultCloserEEE; - _ZNK7android6Parcel37updateWorkSourceRequestHeaderPositionEv; - _ZNK7android6Parcel4dataEv; - _ZNK7android6Parcel4readEPvm; - _ZNK7android6Parcel4readERNS0_26FlattenableHelperInterfaceE; - _ZNK7android6Parcel5printERNS_10TextOutputEj; - _ZNK7android6Parcel7ipcDataEv; - _ZNK7android6Parcel8allowFdsEv; - _ZNK7android6Parcel8dataSizeEv; - _ZNK7android6Parcel8isForRpcEv; - _ZNK7android6Parcel8readBlobEmPNS0_12ReadableBlobE; - _ZNK7android6Parcel8readBoolEPb; - _ZNK7android6Parcel8readBoolEv; - _ZNK7android6Parcel8readByteEPa; - _ZNK7android6Parcel8readByteEv; - _ZNK7android6Parcel8readCharEPDs; - _ZNK7android6Parcel8readCharEv; - _ZNK7android6Parcel9dataAvailEv; - _ZNK7android6Parcel9readFloatEPf; - _ZNK7android6Parcel9readFloatEv; - _ZNK7android6Parcel9readInt32EPi; - _ZNK7android6Parcel9readInt32Ev; - _ZNK7android6Parcel9readInt64EPl; - _ZNK7android6Parcel9readInt64Ev; - _ZNK7android6VectorIiE10do_destroyEPvm; - _ZNK7android6VectorIiE12do_constructEPvm; - _ZNK7android6VectorIiE15do_move_forwardEPvPKvm; - _ZNK7android6VectorIiE16do_move_backwardEPvPKvm; - _ZNK7android6VectorIiE7do_copyEPvPKvm; - _ZNK7android6VectorIiE8do_splatEPvPKvm; - _ZNK7android6VectorINS_12ProcessState12handle_entryEE10do_destroyEPvm; - _ZNK7android6VectorINS_12ProcessState12handle_entryEE12do_constructEPvm; - _ZNK7android6VectorINS_12ProcessState12handle_entryEE15do_move_forwardEPvPKvm; - _ZNK7android6VectorINS_12ProcessState12handle_entryEE16do_move_backwardEPvPKvm; - _ZNK7android6VectorINS_12ProcessState12handle_entryEE7do_copyEPvPKvm; - _ZNK7android6VectorINS_12ProcessState12handle_entryEE8do_splatEPvPKvm; - _ZNK7android6VectorINS_2spINS_18BufferedTextOutput11BufferStateEEEE10do_destroyEPvm; - _ZNK7android6VectorINS_2spINS_18BufferedTextOutput11BufferStateEEEE12do_constructEPvm; - _ZNK7android6VectorINS_2spINS_18BufferedTextOutput11BufferStateEEEE15do_move_forwardEPvPKvm; - _ZNK7android6VectorINS_2spINS_18BufferedTextOutput11BufferStateEEEE16do_move_backwardEPvPKvm; - _ZNK7android6VectorINS_2spINS_18BufferedTextOutput11BufferStateEEEE7do_copyEPvPKvm; - _ZNK7android6VectorINS_2spINS_18BufferedTextOutput11BufferStateEEEE8do_splatEPvPKvm; - _ZNK7android6VectorINS_8BpBinder8ObituaryEE10do_destroyEPvm; - _ZNK7android6VectorINS_8BpBinder8ObituaryEE12do_constructEPvm; - _ZNK7android6VectorINS_8BpBinder8ObituaryEE15do_move_forwardEPvPKvm; - _ZNK7android6VectorINS_8BpBinder8ObituaryEE16do_move_backwardEPvPKvm; - _ZNK7android6VectorINS_8BpBinder8ObituaryEE7do_copyEPvPKvm; - _ZNK7android6VectorINS_8BpBinder8ObituaryEE8do_splatEPvPKvm; - _ZNK7android6VectorINS_8String16EE10do_destroyEPvm; - _ZNK7android6VectorINS_8String16EE12do_constructEPvm; - _ZNK7android6VectorINS_8String16EE15do_move_forwardEPvPKvm; - _ZNK7android6VectorINS_8String16EE16do_move_backwardEPvPKvm; - _ZNK7android6VectorINS_8String16EE7do_copyEPvPKvm; - _ZNK7android6VectorINS_8String16EE8do_splatEPvPKvm; - _ZNK7android6VectorIPNS_7BBinderEE10do_destroyEPvm; - _ZNK7android6VectorIPNS_7BBinderEE12do_constructEPvm; - _ZNK7android6VectorIPNS_7BBinderEE15do_move_forwardEPvPKvm; - _ZNK7android6VectorIPNS_7BBinderEE16do_move_backwardEPvPKvm; - _ZNK7android6VectorIPNS_7BBinderEE7do_copyEPvPKvm; - _ZNK7android6VectorIPNS_7BBinderEE8do_splatEPvPKvm; - _ZNK7android6VectorIPNS_7RefBase12weakref_typeEE10do_destroyEPvm; - _ZNK7android6VectorIPNS_7RefBase12weakref_typeEE12do_constructEPvm; - _ZNK7android6VectorIPNS_7RefBase12weakref_typeEE15do_move_forwardEPvPKvm; - _ZNK7android6VectorIPNS_7RefBase12weakref_typeEE16do_move_backwardEPvPKvm; - _ZNK7android6VectorIPNS_7RefBase12weakref_typeEE7do_copyEPvPKvm; - _ZNK7android6VectorIPNS_7RefBase12weakref_typeEE8do_splatEPvPKvm; - _ZNK7android6VectorIPNS_7RefBaseEE10do_destroyEPvm; - _ZNK7android6VectorIPNS_7RefBaseEE12do_constructEPvm; - _ZNK7android6VectorIPNS_7RefBaseEE15do_move_forwardEPvPKvm; - _ZNK7android6VectorIPNS_7RefBaseEE16do_move_backwardEPvPKvm; - _ZNK7android6VectorIPNS_7RefBaseEE7do_copyEPvPKvm; - _ZNK7android6VectorIPNS_7RefBaseEE8do_splatEPvPKvm; - _ZNK7android7BBinder10findObjectEPKv; - _ZNK7android7BBinder13isBinderAliveEv; - _ZNK7android7BBinder22getInterfaceDescriptorEv; - _ZNK7android7content2pm18PackageChangeEvent13writeToParcelEPNS_6ParcelE; - _ZNK7android7content2pm21IPackageManagerNative22getInterfaceDescriptorEv; - _ZNK7android7content2pm22IPackageChangeObserver22getInterfaceDescriptorEv; - _ZNK7android7IBinder13checkSubclassEPKv; - _ZNK7android7IMemory11fastPointerERKNS_2spINS_7IBinderEEEl; - _ZNK7android7IMemory15unsecurePointerEv; - _ZNK7android7IMemory22getInterfaceDescriptorEv; - _ZNK7android7IMemory4sizeEv; - _ZNK7android7IMemory6offsetEv; - _ZNK7android7IMemory7pointerEv; - _ZNK7android8BpBinder10findObjectEPKv; - _ZNK7android8BpBinder10rpcAddressEv; - _ZNK7android8BpBinder10rpcSessionEv; - _ZNK7android8BpBinder11isRpcBinderEv; - _ZNK7android8BpBinder12binderHandleEv; - _ZNK7android8BpBinder13isBinderAliveEv; - _ZNK7android8BpBinder13ObjectManager4findEPKv; - _ZNK7android8BpBinder18isDescriptorCachedEv; - _ZNK7android8BpBinder22getInterfaceDescriptorEv; - _ZNK7android8BpMemory9getMemoryEPlPm; - _ZNKSt3__115basic_stringbufIcNS_11char_traitsIcEENS_9allocatorIcEEE3strEv; - _ZNKSt3__16__treeINS_12__value_typeIN7android8String16EbEENS_19__map_value_compareIS3_S4_NS_4lessIS3_EELb1EEENS_9allocatorIS4_EEE4findIS3_EENS_21__tree_const_iteratorIS4_PNS_11__tree_nodeIS4_PvEElEERKT_; - _ZNKSt3__16__treeINS_12__value_typeIN7android8String16EdEENS_19__map_value_compareIS3_S4_NS_4lessIS3_EELb1EEENS_9allocatorIS4_EEE4findIS3_EENS_21__tree_const_iteratorIS4_PNS_11__tree_nodeIS4_PvEElEERKT_; - _ZNKSt3__16__treeINS_12__value_typeIN7android8String16EiEENS_19__map_value_compareIS3_S4_NS_4lessIS3_EELb1EEENS_9allocatorIS4_EEE4findIS3_EENS_21__tree_const_iteratorIS4_PNS_11__tree_nodeIS4_PvEElEERKT_; - _ZNKSt3__16__treeINS_12__value_typeIN7android8String16ElEENS_19__map_value_compareIS3_S4_NS_4lessIS3_EELb1EEENS_9allocatorIS4_EEE4findIS3_EENS_21__tree_const_iteratorIS4_PNS_11__tree_nodeIS4_PvEElEERKT_; - _ZNKSt3__16__treeINS_12__value_typeIN7android8String16ENS2_2os17PersistableBundleEEENS_19__map_value_compareIS3_S6_NS_4lessIS3_EELb1EEENS_9allocatorIS6_EEE4findIS3_EENS_21__tree_const_iteratorIS6_PNS_11__tree_nodeIS6_PvEElEERKT_; - _ZNKSt3__16__treeINS_12__value_typeIN7android8String16ENS_6vectorIbNS_9allocatorIbEEEEEENS_19__map_value_compareIS3_S8_NS_4lessIS3_EELb1EEENS5_IS8_EEE4findIS3_EENS_21__tree_const_iteratorIS8_PNS_11__tree_nodeIS8_PvEElEERKT_; - _ZNKSt3__16__treeINS_12__value_typeIN7android8String16ENS_6vectorIdNS_9allocatorIdEEEEEENS_19__map_value_compareIS3_S8_NS_4lessIS3_EELb1EEENS5_IS8_EEE4findIS3_EENS_21__tree_const_iteratorIS8_PNS_11__tree_nodeIS8_PvEElEERKT_; - _ZNKSt3__16__treeINS_12__value_typeIN7android8String16ENS_6vectorIiNS_9allocatorIiEEEEEENS_19__map_value_compareIS3_S8_NS_4lessIS3_EELb1EEENS5_IS8_EEE4findIS3_EENS_21__tree_const_iteratorIS8_PNS_11__tree_nodeIS8_PvEElEERKT_; - _ZNKSt3__16__treeINS_12__value_typeIN7android8String16ENS_6vectorIlNS_9allocatorIlEEEEEENS_19__map_value_compareIS3_S8_NS_4lessIS3_EELb1EEENS5_IS8_EEE4findIS3_EENS_21__tree_const_iteratorIS8_PNS_11__tree_nodeIS8_PvEElEERKT_; - _ZNKSt3__16__treeINS_12__value_typeIN7android8String16ENS_6vectorIS3_NS_9allocatorIS3_EEEEEENS_19__map_value_compareIS3_S8_NS_4lessIS3_EELb1EEENS5_IS8_EEE4findIS3_EENS_21__tree_const_iteratorIS8_PNS_11__tree_nodeIS8_PvEElEERKT_; - _ZNKSt3__16__treeINS_12__value_typeIN7android8String16ES3_EENS_19__map_value_compareIS3_S4_NS_4lessIS3_EELb1EEENS_9allocatorIS4_EEE4findIS3_EENS_21__tree_const_iteratorIS4_PNS_11__tree_nodeIS4_PvEElEERKT_; - _ZNSt3__111__sift_downIRNS_4lessIN7android8RpcState10BinderNode9AsyncTodoEEENS_11__wrap_iterIPS5_EEEEvT0_SB_T_NS_15iterator_traitsISB_E15difference_typeESB_; - _ZNSt3__111unique_lockINS_5mutexEE6unlockEv; - _ZNSt3__112__hash_tableINS_17__hash_value_typeIijEENS_22__unordered_map_hasherIiS2_NS_4hashIiEELb1EEENS_21__unordered_map_equalIiS2_NS_8equal_toIiEELb1EEENS_9allocatorIS2_EEE14__erase_uniqueIiEEmRKT_; - _ZNSt3__112__hash_tableINS_17__hash_value_typeIijEENS_22__unordered_map_hasherIiS2_NS_4hashIiEELb1EEENS_21__unordered_map_equalIiS2_NS_8equal_toIiEELb1EEENS_9allocatorIS2_EEE25__emplace_unique_key_argsIiJRKNS_21piecewise_construct_tENS_5tupleIJRKiEEENSI_IJEEEEEENS_4pairINS_15__hash_iteratorIPNS_11__hash_nodeIS2_PvEEEEbEERKT_DpOT0_; - _ZNSt3__112__hash_tableINS_17__hash_value_typeIijEENS_22__unordered_map_hasherIiS2_NS_4hashIiEELb1EEENS_21__unordered_map_equalIiS2_NS_8equal_toIiEELb1EEENS_9allocatorIS2_EEE6rehashEm; - _ZNSt3__112__hash_tableINS_17__hash_value_typeIijEENS_22__unordered_map_hasherIiS2_NS_4hashIiEELb1EEENS_21__unordered_map_equalIiS2_NS_8equal_toIiEELb1EEENS_9allocatorIS2_EEE6removeENS_21__hash_const_iteratorIPNS_11__hash_nodeIS2_PvEEEE; - _ZNSt3__112__hash_tableINS_17__hash_value_typeIijEENS_22__unordered_map_hasherIiS2_NS_4hashIiEELb1EEENS_21__unordered_map_equalIiS2_NS_8equal_toIiEELb1EEENS_9allocatorIS2_EEE8__rehashEm; - _ZNSt3__113__tree_removeIPNS_16__tree_node_baseIPvEEEEvT_S5_; - _ZNSt3__114__copy_alignedINS_6vectorIbNS_9allocatorIbEEEELb0EEENS_14__bit_iteratorIT_Lb0EXLi0EEEENS5_IS6_XT0_EXLi0EEEES8_S7_; - _ZNSt3__114__copy_alignedINS_6vectorIbNS_9allocatorIbEEEELb1EEENS_14__bit_iteratorIT_Lb0EXLi0EEEENS5_IS6_XT0_EXLi0EEEES8_S7_; - _ZNSt3__114__thread_proxyINS_5tupleIJNS_10unique_ptrINS_15__thread_structENS_14default_deleteIS3_EEEEMN7android9RpcServerEFvONS7_2spIS8_EENS7_4base14unique_fd_implINSC_13DefaultCloserEEEEPS8_SA_SF_EEEEEPvSK_; - _ZNSt3__115basic_stringbufIcNS_11char_traitsIcEENS_9allocatorIcEEE7seekoffExNS_8ios_base7seekdirEj; - _ZNSt3__115basic_stringbufIcNS_11char_traitsIcEENS_9allocatorIcEEE8overflowEi; - _ZNSt3__115basic_stringbufIcNS_11char_traitsIcEENS_9allocatorIcEEE9pbackfailEi; - _ZNSt3__115basic_stringbufIcNS_11char_traitsIcEENS_9allocatorIcEEE9underflowEv; - _ZNSt3__116__copy_unalignedINS_6vectorIbNS_9allocatorIbEEEELb0EEENS_14__bit_iteratorIT_Lb0EXLi0EEEENS5_IS6_XT0_EXLi0EEEES8_S7_; - _ZNSt3__116__copy_unalignedINS_6vectorIbNS_9allocatorIbEEEELb1EEENS_14__bit_iteratorIT_Lb0EXLi0EEEENS5_IS6_XT0_EXLi0EEEES8_S7_; - _ZNSt3__120__shared_ptr_emplaceIN7android14RpcWireAddressENS_9allocatorIS2_EEE16__on_zero_sharedEv; - _ZNSt3__120__shared_ptr_emplaceIN7android14RpcWireAddressENS_9allocatorIS2_EEE21__on_zero_shared_weakEv; - _ZNSt3__120__shared_ptr_emplaceIN7android6binder8internal21ClientCounterCallbackENS_9allocatorIS4_EEE16__on_zero_sharedEv; - _ZNSt3__120__shared_ptr_emplaceIN7android6binder8internal21ClientCounterCallbackENS_9allocatorIS4_EEE21__on_zero_shared_weakEv; - _ZNSt3__124__put_character_sequenceIcNS_11char_traitsIcEEEERNS_13basic_ostreamIT_T0_EES7_PKS4_m; - _ZNSt3__127__tree_balance_after_insertIPNS_16__tree_node_baseIPvEEEEvT_S5_; - _ZNSt3__16__treeIN7android8String16ENS_4lessIS2_EENS_9allocatorIS2_EEE12__find_equalIS2_EERPNS_16__tree_node_baseIPvEERPNS_15__tree_end_nodeISC_EERKT_; - _ZNSt3__16__treeIN7android8String16ENS_4lessIS2_EENS_9allocatorIS2_EEE25__emplace_unique_key_argsIS2_JRKS2_EEENS_4pairINS_15__tree_iteratorIS2_PNS_11__tree_nodeIS2_PvEElEEbEERKT_DpOT0_; - _ZNSt3__16__treeIN7android8String16ENS_4lessIS2_EENS_9allocatorIS2_EEE7destroyEPNS_11__tree_nodeIS2_PvEE; - _ZNSt3__16__treeINS_12__value_typeIiN7android2spINS2_10RpcSessionEEEEENS_19__map_value_compareIiS6_NS_4lessIiEELb1EEENS_9allocatorIS6_EEE5eraseENS_21__tree_const_iteratorIS6_PNS_11__tree_nodeIS6_PvEElEE; - _ZNSt3__16__treeINS_12__value_typeIiN7android2spINS2_10RpcSessionEEEEENS_19__map_value_compareIiS6_NS_4lessIiEELb1EEENS_9allocatorIS6_EEE7destroyEPNS_11__tree_nodeIS6_PvEE; - _ZNSt3__16__treeINS_12__value_typeIN7android10RpcAddressENS2_8RpcState10BinderNodeEEENS_19__map_value_compareIS3_S6_NS_4lessIS3_EELb1EEENS_9allocatorIS6_EEE25__emplace_unique_key_argsIS3_JNS_4pairIKS3_S5_EEEEENSF_INS_15__tree_iteratorIS6_PNS_11__tree_nodeIS6_PvEElEEbEERKT_DpOT0_; - _ZNSt3__16__treeINS_12__value_typeIN7android10RpcAddressENS2_8RpcState10BinderNodeEEENS_19__map_value_compareIS3_S6_NS_4lessIS3_EELb1EEENS_9allocatorIS6_EEE7destroyEPNS_11__tree_nodeIS6_PvEE; - _ZNSt3__16__treeINS_12__value_typeIN7android8String16EbEENS_19__map_value_compareIS3_S4_NS_4lessIS3_EELb1EEENS_9allocatorIS4_EEE12__find_equalIS3_EERPNS_16__tree_node_baseIPvEENS_21__tree_const_iteratorIS4_PNS_11__tree_nodeIS4_SE_EElEERPNS_15__tree_end_nodeISG_EESH_RKT_; - _ZNSt3__16__treeINS_12__value_typeIN7android8String16EbEENS_19__map_value_compareIS3_S4_NS_4lessIS3_EELb1EEENS_9allocatorIS4_EEE12__find_equalIS3_EERPNS_16__tree_node_baseIPvEERPNS_15__tree_end_nodeISG_EERKT_; - _ZNSt3__16__treeINS_12__value_typeIN7android8String16EbEENS_19__map_value_compareIS3_S4_NS_4lessIS3_EELb1EEENS_9allocatorIS4_EEE14__assign_multiINS_21__tree_const_iteratorIS4_PNS_11__tree_nodeIS4_PvEElEEEEvT_SJ_; - _ZNSt3__16__treeINS_12__value_typeIN7android8String16EbEENS_19__map_value_compareIS3_S4_NS_4lessIS3_EELb1EEENS_9allocatorIS4_EEE15__emplace_multiIJRKNS_4pairIKS3_bEEEEENS_15__tree_iteratorIS4_PNS_11__tree_nodeIS4_PvEElEEDpOT_; - _ZNSt3__16__treeINS_12__value_typeIN7android8String16EbEENS_19__map_value_compareIS3_S4_NS_4lessIS3_EELb1EEENS_9allocatorIS4_EEE25__emplace_unique_key_argsIS3_JRKNS_21piecewise_construct_tENS_5tupleIJRKS3_EEENSG_IJEEEEEENS_4pairINS_15__tree_iteratorIS4_PNS_11__tree_nodeIS4_PvEElEEbEERKT_DpOT0_; - _ZNSt3__16__treeINS_12__value_typeIN7android8String16EbEENS_19__map_value_compareIS3_S4_NS_4lessIS3_EELb1EEENS_9allocatorIS4_EEE30__emplace_hint_unique_key_argsIS3_JRKNS_4pairIKS3_bEEEEENS_15__tree_iteratorIS4_PNS_11__tree_nodeIS4_PvEElEENS_21__tree_const_iteratorIS4_SM_lEERKT_DpOT0_; - _ZNSt3__16__treeINS_12__value_typeIN7android8String16EbEENS_19__map_value_compareIS3_S4_NS_4lessIS3_EELb1EEENS_9allocatorIS4_EEE4findIS3_EENS_15__tree_iteratorIS4_PNS_11__tree_nodeIS4_PvEElEERKT_; - _ZNSt3__16__treeINS_12__value_typeIN7android8String16EbEENS_19__map_value_compareIS3_S4_NS_4lessIS3_EELb1EEENS_9allocatorIS4_EEE7destroyEPNS_11__tree_nodeIS4_PvEE; - _ZNSt3__16__treeINS_12__value_typeIN7android8String16EdEENS_19__map_value_compareIS3_S4_NS_4lessIS3_EELb1EEENS_9allocatorIS4_EEE12__find_equalIS3_EERPNS_16__tree_node_baseIPvEENS_21__tree_const_iteratorIS4_PNS_11__tree_nodeIS4_SE_EElEERPNS_15__tree_end_nodeISG_EESH_RKT_; - _ZNSt3__16__treeINS_12__value_typeIN7android8String16EdEENS_19__map_value_compareIS3_S4_NS_4lessIS3_EELb1EEENS_9allocatorIS4_EEE12__find_equalIS3_EERPNS_16__tree_node_baseIPvEERPNS_15__tree_end_nodeISG_EERKT_; - _ZNSt3__16__treeINS_12__value_typeIN7android8String16EdEENS_19__map_value_compareIS3_S4_NS_4lessIS3_EELb1EEENS_9allocatorIS4_EEE14__assign_multiINS_21__tree_const_iteratorIS4_PNS_11__tree_nodeIS4_PvEElEEEEvT_SJ_; - _ZNSt3__16__treeINS_12__value_typeIN7android8String16EdEENS_19__map_value_compareIS3_S4_NS_4lessIS3_EELb1EEENS_9allocatorIS4_EEE15__emplace_multiIJRKNS_4pairIKS3_dEEEEENS_15__tree_iteratorIS4_PNS_11__tree_nodeIS4_PvEElEEDpOT_; - _ZNSt3__16__treeINS_12__value_typeIN7android8String16EdEENS_19__map_value_compareIS3_S4_NS_4lessIS3_EELb1EEENS_9allocatorIS4_EEE25__emplace_unique_key_argsIS3_JRKNS_21piecewise_construct_tENS_5tupleIJRKS3_EEENSG_IJEEEEEENS_4pairINS_15__tree_iteratorIS4_PNS_11__tree_nodeIS4_PvEElEEbEERKT_DpOT0_; - _ZNSt3__16__treeINS_12__value_typeIN7android8String16EdEENS_19__map_value_compareIS3_S4_NS_4lessIS3_EELb1EEENS_9allocatorIS4_EEE30__emplace_hint_unique_key_argsIS3_JRKNS_4pairIKS3_dEEEEENS_15__tree_iteratorIS4_PNS_11__tree_nodeIS4_PvEElEENS_21__tree_const_iteratorIS4_SM_lEERKT_DpOT0_; - _ZNSt3__16__treeINS_12__value_typeIN7android8String16EdEENS_19__map_value_compareIS3_S4_NS_4lessIS3_EELb1EEENS_9allocatorIS4_EEE4findIS3_EENS_15__tree_iteratorIS4_PNS_11__tree_nodeIS4_PvEElEERKT_; - _ZNSt3__16__treeINS_12__value_typeIN7android8String16EdEENS_19__map_value_compareIS3_S4_NS_4lessIS3_EELb1EEENS_9allocatorIS4_EEE7destroyEPNS_11__tree_nodeIS4_PvEE; - _ZNSt3__16__treeINS_12__value_typeIN7android8String16EiEENS_19__map_value_compareIS3_S4_NS_4lessIS3_EELb1EEENS_9allocatorIS4_EEE12__find_equalIS3_EERPNS_16__tree_node_baseIPvEENS_21__tree_const_iteratorIS4_PNS_11__tree_nodeIS4_SE_EElEERPNS_15__tree_end_nodeISG_EESH_RKT_; - _ZNSt3__16__treeINS_12__value_typeIN7android8String16EiEENS_19__map_value_compareIS3_S4_NS_4lessIS3_EELb1EEENS_9allocatorIS4_EEE12__find_equalIS3_EERPNS_16__tree_node_baseIPvEERPNS_15__tree_end_nodeISG_EERKT_; - _ZNSt3__16__treeINS_12__value_typeIN7android8String16EiEENS_19__map_value_compareIS3_S4_NS_4lessIS3_EELb1EEENS_9allocatorIS4_EEE14__assign_multiINS_21__tree_const_iteratorIS4_PNS_11__tree_nodeIS4_PvEElEEEEvT_SJ_; - _ZNSt3__16__treeINS_12__value_typeIN7android8String16EiEENS_19__map_value_compareIS3_S4_NS_4lessIS3_EELb1EEENS_9allocatorIS4_EEE15__emplace_multiIJRKNS_4pairIKS3_iEEEEENS_15__tree_iteratorIS4_PNS_11__tree_nodeIS4_PvEElEEDpOT_; - _ZNSt3__16__treeINS_12__value_typeIN7android8String16EiEENS_19__map_value_compareIS3_S4_NS_4lessIS3_EELb1EEENS_9allocatorIS4_EEE25__emplace_unique_key_argsIS3_JRKNS_21piecewise_construct_tENS_5tupleIJRKS3_EEENSG_IJEEEEEENS_4pairINS_15__tree_iteratorIS4_PNS_11__tree_nodeIS4_PvEElEEbEERKT_DpOT0_; - _ZNSt3__16__treeINS_12__value_typeIN7android8String16EiEENS_19__map_value_compareIS3_S4_NS_4lessIS3_EELb1EEENS_9allocatorIS4_EEE30__emplace_hint_unique_key_argsIS3_JRKNS_4pairIKS3_iEEEEENS_15__tree_iteratorIS4_PNS_11__tree_nodeIS4_PvEElEENS_21__tree_const_iteratorIS4_SM_lEERKT_DpOT0_; - _ZNSt3__16__treeINS_12__value_typeIN7android8String16EiEENS_19__map_value_compareIS3_S4_NS_4lessIS3_EELb1EEENS_9allocatorIS4_EEE4findIS3_EENS_15__tree_iteratorIS4_PNS_11__tree_nodeIS4_PvEElEERKT_; - _ZNSt3__16__treeINS_12__value_typeIN7android8String16EiEENS_19__map_value_compareIS3_S4_NS_4lessIS3_EELb1EEENS_9allocatorIS4_EEE7destroyEPNS_11__tree_nodeIS4_PvEE; - _ZNSt3__16__treeINS_12__value_typeIN7android8String16ElEENS_19__map_value_compareIS3_S4_NS_4lessIS3_EELb1EEENS_9allocatorIS4_EEE12__find_equalIS3_EERPNS_16__tree_node_baseIPvEENS_21__tree_const_iteratorIS4_PNS_11__tree_nodeIS4_SE_EElEERPNS_15__tree_end_nodeISG_EESH_RKT_; - _ZNSt3__16__treeINS_12__value_typeIN7android8String16ElEENS_19__map_value_compareIS3_S4_NS_4lessIS3_EELb1EEENS_9allocatorIS4_EEE12__find_equalIS3_EERPNS_16__tree_node_baseIPvEERPNS_15__tree_end_nodeISG_EERKT_; - _ZNSt3__16__treeINS_12__value_typeIN7android8String16ElEENS_19__map_value_compareIS3_S4_NS_4lessIS3_EELb1EEENS_9allocatorIS4_EEE14__assign_multiINS_21__tree_const_iteratorIS4_PNS_11__tree_nodeIS4_PvEElEEEEvT_SJ_; - _ZNSt3__16__treeINS_12__value_typeIN7android8String16ElEENS_19__map_value_compareIS3_S4_NS_4lessIS3_EELb1EEENS_9allocatorIS4_EEE15__emplace_multiIJRKNS_4pairIKS3_lEEEEENS_15__tree_iteratorIS4_PNS_11__tree_nodeIS4_PvEElEEDpOT_; - _ZNSt3__16__treeINS_12__value_typeIN7android8String16ElEENS_19__map_value_compareIS3_S4_NS_4lessIS3_EELb1EEENS_9allocatorIS4_EEE25__emplace_unique_key_argsIS3_JRKNS_21piecewise_construct_tENS_5tupleIJRKS3_EEENSG_IJEEEEEENS_4pairINS_15__tree_iteratorIS4_PNS_11__tree_nodeIS4_PvEElEEbEERKT_DpOT0_; - _ZNSt3__16__treeINS_12__value_typeIN7android8String16ElEENS_19__map_value_compareIS3_S4_NS_4lessIS3_EELb1EEENS_9allocatorIS4_EEE30__emplace_hint_unique_key_argsIS3_JRKNS_4pairIKS3_lEEEEENS_15__tree_iteratorIS4_PNS_11__tree_nodeIS4_PvEElEENS_21__tree_const_iteratorIS4_SM_lEERKT_DpOT0_; - _ZNSt3__16__treeINS_12__value_typeIN7android8String16ElEENS_19__map_value_compareIS3_S4_NS_4lessIS3_EELb1EEENS_9allocatorIS4_EEE4findIS3_EENS_15__tree_iteratorIS4_PNS_11__tree_nodeIS4_PvEElEERKT_; - _ZNSt3__16__treeINS_12__value_typeIN7android8String16ElEENS_19__map_value_compareIS3_S4_NS_4lessIS3_EELb1EEENS_9allocatorIS4_EEE7destroyEPNS_11__tree_nodeIS4_PvEE; - _ZNSt3__16__treeINS_12__value_typeIN7android8String16ENS2_2os17PersistableBundleEEENS_19__map_value_compareIS3_S6_NS_4lessIS3_EELb1EEENS_9allocatorIS6_EEE12__find_equalIS3_EERPNS_16__tree_node_baseIPvEENS_21__tree_const_iteratorIS6_PNS_11__tree_nodeIS6_SG_EElEERPNS_15__tree_end_nodeISI_EESJ_RKT_; - _ZNSt3__16__treeINS_12__value_typeIN7android8String16ENS2_2os17PersistableBundleEEENS_19__map_value_compareIS3_S6_NS_4lessIS3_EELb1EEENS_9allocatorIS6_EEE12__find_equalIS3_EERPNS_16__tree_node_baseIPvEERPNS_15__tree_end_nodeISI_EERKT_; - _ZNSt3__16__treeINS_12__value_typeIN7android8String16ENS2_2os17PersistableBundleEEENS_19__map_value_compareIS3_S6_NS_4lessIS3_EELb1EEENS_9allocatorIS6_EEE14__assign_multiINS_21__tree_const_iteratorIS6_PNS_11__tree_nodeIS6_PvEElEEEEvT_SL_; - _ZNSt3__16__treeINS_12__value_typeIN7android8String16ENS2_2os17PersistableBundleEEENS_19__map_value_compareIS3_S6_NS_4lessIS3_EELb1EEENS_9allocatorIS6_EEE14__erase_uniqueIS3_EEmRKT_; - _ZNSt3__16__treeINS_12__value_typeIN7android8String16ENS2_2os17PersistableBundleEEENS_19__map_value_compareIS3_S6_NS_4lessIS3_EELb1EEENS_9allocatorIS6_EEE15__emplace_multiIJRKNS_4pairIKS3_S5_EEEEENS_15__tree_iteratorIS6_PNS_11__tree_nodeIS6_PvEElEEDpOT_; - _ZNSt3__16__treeINS_12__value_typeIN7android8String16ENS2_2os17PersistableBundleEEENS_19__map_value_compareIS3_S6_NS_4lessIS3_EELb1EEENS_9allocatorIS6_EEE25__emplace_unique_key_argsIS3_JRKNS_21piecewise_construct_tENS_5tupleIJRKS3_EEENSI_IJEEEEEENS_4pairINS_15__tree_iteratorIS6_PNS_11__tree_nodeIS6_PvEElEEbEERKT_DpOT0_; - _ZNSt3__16__treeINS_12__value_typeIN7android8String16ENS2_2os17PersistableBundleEEENS_19__map_value_compareIS3_S6_NS_4lessIS3_EELb1EEENS_9allocatorIS6_EEE30__emplace_hint_unique_key_argsIS3_JRKNS_4pairIKS3_S5_EEEEENS_15__tree_iteratorIS6_PNS_11__tree_nodeIS6_PvEElEENS_21__tree_const_iteratorIS6_SO_lEERKT_DpOT0_; - _ZNSt3__16__treeINS_12__value_typeIN7android8String16ENS2_2os17PersistableBundleEEENS_19__map_value_compareIS3_S6_NS_4lessIS3_EELb1EEENS_9allocatorIS6_EEE4findIS3_EENS_15__tree_iteratorIS6_PNS_11__tree_nodeIS6_PvEElEERKT_; - _ZNSt3__16__treeINS_12__value_typeIN7android8String16ENS2_2os17PersistableBundleEEENS_19__map_value_compareIS3_S6_NS_4lessIS3_EELb1EEENS_9allocatorIS6_EEE5eraseENS_21__tree_const_iteratorIS6_PNS_11__tree_nodeIS6_PvEElEE; - _ZNSt3__16__treeINS_12__value_typeIN7android8String16ENS2_2os17PersistableBundleEEENS_19__map_value_compareIS3_S6_NS_4lessIS3_EELb1EEENS_9allocatorIS6_EEE7destroyEPNS_11__tree_nodeIS6_PvEE; - _ZNSt3__16__treeINS_12__value_typeIN7android8String16ENS_6vectorIbNS_9allocatorIbEEEEEENS_19__map_value_compareIS3_S8_NS_4lessIS3_EELb1EEENS5_IS8_EEE12__find_equalIS3_EERPNS_16__tree_node_baseIPvEENS_21__tree_const_iteratorIS8_PNS_11__tree_nodeIS8_SH_EElEERPNS_15__tree_end_nodeISJ_EESK_RKT_; - _ZNSt3__16__treeINS_12__value_typeIN7android8String16ENS_6vectorIbNS_9allocatorIbEEEEEENS_19__map_value_compareIS3_S8_NS_4lessIS3_EELb1EEENS5_IS8_EEE12__find_equalIS3_EERPNS_16__tree_node_baseIPvEERPNS_15__tree_end_nodeISJ_EERKT_; - _ZNSt3__16__treeINS_12__value_typeIN7android8String16ENS_6vectorIbNS_9allocatorIbEEEEEENS_19__map_value_compareIS3_S8_NS_4lessIS3_EELb1EEENS5_IS8_EEE14__assign_multiINS_21__tree_const_iteratorIS8_PNS_11__tree_nodeIS8_PvEElEEEEvT_SM_; - _ZNSt3__16__treeINS_12__value_typeIN7android8String16ENS_6vectorIbNS_9allocatorIbEEEEEENS_19__map_value_compareIS3_S8_NS_4lessIS3_EELb1EEENS5_IS8_EEE14__erase_uniqueIS3_EEmRKT_; - _ZNSt3__16__treeINS_12__value_typeIN7android8String16ENS_6vectorIbNS_9allocatorIbEEEEEENS_19__map_value_compareIS3_S8_NS_4lessIS3_EELb1EEENS5_IS8_EEE15__emplace_multiIJRKNS_4pairIKS3_S7_EEEEENS_15__tree_iteratorIS8_PNS_11__tree_nodeIS8_PvEElEEDpOT_; - _ZNSt3__16__treeINS_12__value_typeIN7android8String16ENS_6vectorIbNS_9allocatorIbEEEEEENS_19__map_value_compareIS3_S8_NS_4lessIS3_EELb1EEENS5_IS8_EEE16__construct_nodeIJRKNS_4pairIKS3_S7_EEEEENS_10unique_ptrINS_11__tree_nodeIS8_PvEENS_22__tree_node_destructorINS5_ISO_EEEEEEDpOT_; - _ZNSt3__16__treeINS_12__value_typeIN7android8String16ENS_6vectorIbNS_9allocatorIbEEEEEENS_19__map_value_compareIS3_S8_NS_4lessIS3_EELb1EEENS5_IS8_EEE25__emplace_unique_key_argsIS3_JRKNS_21piecewise_construct_tENS_5tupleIJRKS3_EEENSJ_IJEEEEEENS_4pairINS_15__tree_iteratorIS8_PNS_11__tree_nodeIS8_PvEElEEbEERKT_DpOT0_; - _ZNSt3__16__treeINS_12__value_typeIN7android8String16ENS_6vectorIbNS_9allocatorIbEEEEEENS_19__map_value_compareIS3_S8_NS_4lessIS3_EELb1EEENS5_IS8_EEE30__emplace_hint_unique_key_argsIS3_JRKNS_4pairIKS3_S7_EEEEENS_15__tree_iteratorIS8_PNS_11__tree_nodeIS8_PvEElEENS_21__tree_const_iteratorIS8_SP_lEERKT_DpOT0_; - _ZNSt3__16__treeINS_12__value_typeIN7android8String16ENS_6vectorIbNS_9allocatorIbEEEEEENS_19__map_value_compareIS3_S8_NS_4lessIS3_EELb1EEENS5_IS8_EEE4findIS3_EENS_15__tree_iteratorIS8_PNS_11__tree_nodeIS8_PvEElEERKT_; - _ZNSt3__16__treeINS_12__value_typeIN7android8String16ENS_6vectorIbNS_9allocatorIbEEEEEENS_19__map_value_compareIS3_S8_NS_4lessIS3_EELb1EEENS5_IS8_EEE5eraseENS_21__tree_const_iteratorIS8_PNS_11__tree_nodeIS8_PvEElEE; - _ZNSt3__16__treeINS_12__value_typeIN7android8String16ENS_6vectorIbNS_9allocatorIbEEEEEENS_19__map_value_compareIS3_S8_NS_4lessIS3_EELb1EEENS5_IS8_EEE7destroyEPNS_11__tree_nodeIS8_PvEE; - _ZNSt3__16__treeINS_12__value_typeIN7android8String16ENS_6vectorIdNS_9allocatorIdEEEEEENS_19__map_value_compareIS3_S8_NS_4lessIS3_EELb1EEENS5_IS8_EEE12__find_equalIS3_EERPNS_16__tree_node_baseIPvEENS_21__tree_const_iteratorIS8_PNS_11__tree_nodeIS8_SH_EElEERPNS_15__tree_end_nodeISJ_EESK_RKT_; - _ZNSt3__16__treeINS_12__value_typeIN7android8String16ENS_6vectorIdNS_9allocatorIdEEEEEENS_19__map_value_compareIS3_S8_NS_4lessIS3_EELb1EEENS5_IS8_EEE12__find_equalIS3_EERPNS_16__tree_node_baseIPvEERPNS_15__tree_end_nodeISJ_EERKT_; - _ZNSt3__16__treeINS_12__value_typeIN7android8String16ENS_6vectorIdNS_9allocatorIdEEEEEENS_19__map_value_compareIS3_S8_NS_4lessIS3_EELb1EEENS5_IS8_EEE14__assign_multiINS_21__tree_const_iteratorIS8_PNS_11__tree_nodeIS8_PvEElEEEEvT_SM_; - _ZNSt3__16__treeINS_12__value_typeIN7android8String16ENS_6vectorIdNS_9allocatorIdEEEEEENS_19__map_value_compareIS3_S8_NS_4lessIS3_EELb1EEENS5_IS8_EEE14__erase_uniqueIS3_EEmRKT_; - _ZNSt3__16__treeINS_12__value_typeIN7android8String16ENS_6vectorIdNS_9allocatorIdEEEEEENS_19__map_value_compareIS3_S8_NS_4lessIS3_EELb1EEENS5_IS8_EEE15__emplace_multiIJRKNS_4pairIKS3_S7_EEEEENS_15__tree_iteratorIS8_PNS_11__tree_nodeIS8_PvEElEEDpOT_; - _ZNSt3__16__treeINS_12__value_typeIN7android8String16ENS_6vectorIdNS_9allocatorIdEEEEEENS_19__map_value_compareIS3_S8_NS_4lessIS3_EELb1EEENS5_IS8_EEE25__emplace_unique_key_argsIS3_JRKNS_21piecewise_construct_tENS_5tupleIJRKS3_EEENSJ_IJEEEEEENS_4pairINS_15__tree_iteratorIS8_PNS_11__tree_nodeIS8_PvEElEEbEERKT_DpOT0_; - _ZNSt3__16__treeINS_12__value_typeIN7android8String16ENS_6vectorIdNS_9allocatorIdEEEEEENS_19__map_value_compareIS3_S8_NS_4lessIS3_EELb1EEENS5_IS8_EEE30__emplace_hint_unique_key_argsIS3_JRKNS_4pairIKS3_S7_EEEEENS_15__tree_iteratorIS8_PNS_11__tree_nodeIS8_PvEElEENS_21__tree_const_iteratorIS8_SP_lEERKT_DpOT0_; - _ZNSt3__16__treeINS_12__value_typeIN7android8String16ENS_6vectorIdNS_9allocatorIdEEEEEENS_19__map_value_compareIS3_S8_NS_4lessIS3_EELb1EEENS5_IS8_EEE4findIS3_EENS_15__tree_iteratorIS8_PNS_11__tree_nodeIS8_PvEElEERKT_; - _ZNSt3__16__treeINS_12__value_typeIN7android8String16ENS_6vectorIdNS_9allocatorIdEEEEEENS_19__map_value_compareIS3_S8_NS_4lessIS3_EELb1EEENS5_IS8_EEE5eraseENS_21__tree_const_iteratorIS8_PNS_11__tree_nodeIS8_PvEElEE; - _ZNSt3__16__treeINS_12__value_typeIN7android8String16ENS_6vectorIdNS_9allocatorIdEEEEEENS_19__map_value_compareIS3_S8_NS_4lessIS3_EELb1EEENS5_IS8_EEE7destroyEPNS_11__tree_nodeIS8_PvEE; - _ZNSt3__16__treeINS_12__value_typeIN7android8String16ENS_6vectorIiNS_9allocatorIiEEEEEENS_19__map_value_compareIS3_S8_NS_4lessIS3_EELb1EEENS5_IS8_EEE12__find_equalIS3_EERPNS_16__tree_node_baseIPvEENS_21__tree_const_iteratorIS8_PNS_11__tree_nodeIS8_SH_EElEERPNS_15__tree_end_nodeISJ_EESK_RKT_; - _ZNSt3__16__treeINS_12__value_typeIN7android8String16ENS_6vectorIiNS_9allocatorIiEEEEEENS_19__map_value_compareIS3_S8_NS_4lessIS3_EELb1EEENS5_IS8_EEE12__find_equalIS3_EERPNS_16__tree_node_baseIPvEERPNS_15__tree_end_nodeISJ_EERKT_; - _ZNSt3__16__treeINS_12__value_typeIN7android8String16ENS_6vectorIiNS_9allocatorIiEEEEEENS_19__map_value_compareIS3_S8_NS_4lessIS3_EELb1EEENS5_IS8_EEE14__assign_multiINS_21__tree_const_iteratorIS8_PNS_11__tree_nodeIS8_PvEElEEEEvT_SM_; - _ZNSt3__16__treeINS_12__value_typeIN7android8String16ENS_6vectorIiNS_9allocatorIiEEEEEENS_19__map_value_compareIS3_S8_NS_4lessIS3_EELb1EEENS5_IS8_EEE14__erase_uniqueIS3_EEmRKT_; - _ZNSt3__16__treeINS_12__value_typeIN7android8String16ENS_6vectorIiNS_9allocatorIiEEEEEENS_19__map_value_compareIS3_S8_NS_4lessIS3_EELb1EEENS5_IS8_EEE15__emplace_multiIJRKNS_4pairIKS3_S7_EEEEENS_15__tree_iteratorIS8_PNS_11__tree_nodeIS8_PvEElEEDpOT_; - _ZNSt3__16__treeINS_12__value_typeIN7android8String16ENS_6vectorIiNS_9allocatorIiEEEEEENS_19__map_value_compareIS3_S8_NS_4lessIS3_EELb1EEENS5_IS8_EEE25__emplace_unique_key_argsIS3_JRKNS_21piecewise_construct_tENS_5tupleIJRKS3_EEENSJ_IJEEEEEENS_4pairINS_15__tree_iteratorIS8_PNS_11__tree_nodeIS8_PvEElEEbEERKT_DpOT0_; - _ZNSt3__16__treeINS_12__value_typeIN7android8String16ENS_6vectorIiNS_9allocatorIiEEEEEENS_19__map_value_compareIS3_S8_NS_4lessIS3_EELb1EEENS5_IS8_EEE30__emplace_hint_unique_key_argsIS3_JRKNS_4pairIKS3_S7_EEEEENS_15__tree_iteratorIS8_PNS_11__tree_nodeIS8_PvEElEENS_21__tree_const_iteratorIS8_SP_lEERKT_DpOT0_; - _ZNSt3__16__treeINS_12__value_typeIN7android8String16ENS_6vectorIiNS_9allocatorIiEEEEEENS_19__map_value_compareIS3_S8_NS_4lessIS3_EELb1EEENS5_IS8_EEE4findIS3_EENS_15__tree_iteratorIS8_PNS_11__tree_nodeIS8_PvEElEERKT_; - _ZNSt3__16__treeINS_12__value_typeIN7android8String16ENS_6vectorIiNS_9allocatorIiEEEEEENS_19__map_value_compareIS3_S8_NS_4lessIS3_EELb1EEENS5_IS8_EEE5eraseENS_21__tree_const_iteratorIS8_PNS_11__tree_nodeIS8_PvEElEE; - _ZNSt3__16__treeINS_12__value_typeIN7android8String16ENS_6vectorIiNS_9allocatorIiEEEEEENS_19__map_value_compareIS3_S8_NS_4lessIS3_EELb1EEENS5_IS8_EEE7destroyEPNS_11__tree_nodeIS8_PvEE; - _ZNSt3__16__treeINS_12__value_typeIN7android8String16ENS_6vectorIlNS_9allocatorIlEEEEEENS_19__map_value_compareIS3_S8_NS_4lessIS3_EELb1EEENS5_IS8_EEE12__find_equalIS3_EERPNS_16__tree_node_baseIPvEENS_21__tree_const_iteratorIS8_PNS_11__tree_nodeIS8_SH_EElEERPNS_15__tree_end_nodeISJ_EESK_RKT_; - _ZNSt3__16__treeINS_12__value_typeIN7android8String16ENS_6vectorIlNS_9allocatorIlEEEEEENS_19__map_value_compareIS3_S8_NS_4lessIS3_EELb1EEENS5_IS8_EEE12__find_equalIS3_EERPNS_16__tree_node_baseIPvEERPNS_15__tree_end_nodeISJ_EERKT_; - _ZNSt3__16__treeINS_12__value_typeIN7android8String16ENS_6vectorIlNS_9allocatorIlEEEEEENS_19__map_value_compareIS3_S8_NS_4lessIS3_EELb1EEENS5_IS8_EEE14__assign_multiINS_21__tree_const_iteratorIS8_PNS_11__tree_nodeIS8_PvEElEEEEvT_SM_; - _ZNSt3__16__treeINS_12__value_typeIN7android8String16ENS_6vectorIlNS_9allocatorIlEEEEEENS_19__map_value_compareIS3_S8_NS_4lessIS3_EELb1EEENS5_IS8_EEE14__erase_uniqueIS3_EEmRKT_; - _ZNSt3__16__treeINS_12__value_typeIN7android8String16ENS_6vectorIlNS_9allocatorIlEEEEEENS_19__map_value_compareIS3_S8_NS_4lessIS3_EELb1EEENS5_IS8_EEE15__emplace_multiIJRKNS_4pairIKS3_S7_EEEEENS_15__tree_iteratorIS8_PNS_11__tree_nodeIS8_PvEElEEDpOT_; - _ZNSt3__16__treeINS_12__value_typeIN7android8String16ENS_6vectorIlNS_9allocatorIlEEEEEENS_19__map_value_compareIS3_S8_NS_4lessIS3_EELb1EEENS5_IS8_EEE25__emplace_unique_key_argsIS3_JRKNS_21piecewise_construct_tENS_5tupleIJRKS3_EEENSJ_IJEEEEEENS_4pairINS_15__tree_iteratorIS8_PNS_11__tree_nodeIS8_PvEElEEbEERKT_DpOT0_; - _ZNSt3__16__treeINS_12__value_typeIN7android8String16ENS_6vectorIlNS_9allocatorIlEEEEEENS_19__map_value_compareIS3_S8_NS_4lessIS3_EELb1EEENS5_IS8_EEE30__emplace_hint_unique_key_argsIS3_JRKNS_4pairIKS3_S7_EEEEENS_15__tree_iteratorIS8_PNS_11__tree_nodeIS8_PvEElEENS_21__tree_const_iteratorIS8_SP_lEERKT_DpOT0_; - _ZNSt3__16__treeINS_12__value_typeIN7android8String16ENS_6vectorIlNS_9allocatorIlEEEEEENS_19__map_value_compareIS3_S8_NS_4lessIS3_EELb1EEENS5_IS8_EEE4findIS3_EENS_15__tree_iteratorIS8_PNS_11__tree_nodeIS8_PvEElEERKT_; - _ZNSt3__16__treeINS_12__value_typeIN7android8String16ENS_6vectorIlNS_9allocatorIlEEEEEENS_19__map_value_compareIS3_S8_NS_4lessIS3_EELb1EEENS5_IS8_EEE5eraseENS_21__tree_const_iteratorIS8_PNS_11__tree_nodeIS8_PvEElEE; - _ZNSt3__16__treeINS_12__value_typeIN7android8String16ENS_6vectorIlNS_9allocatorIlEEEEEENS_19__map_value_compareIS3_S8_NS_4lessIS3_EELb1EEENS5_IS8_EEE7destroyEPNS_11__tree_nodeIS8_PvEE; - _ZNSt3__16__treeINS_12__value_typeIN7android8String16ENS_6vectorIS3_NS_9allocatorIS3_EEEEEENS_19__map_value_compareIS3_S8_NS_4lessIS3_EELb1EEENS5_IS8_EEE12__find_equalIS3_EERPNS_16__tree_node_baseIPvEENS_21__tree_const_iteratorIS8_PNS_11__tree_nodeIS8_SH_EElEERPNS_15__tree_end_nodeISJ_EESK_RKT_; - _ZNSt3__16__treeINS_12__value_typeIN7android8String16ENS_6vectorIS3_NS_9allocatorIS3_EEEEEENS_19__map_value_compareIS3_S8_NS_4lessIS3_EELb1EEENS5_IS8_EEE12__find_equalIS3_EERPNS_16__tree_node_baseIPvEERPNS_15__tree_end_nodeISJ_EERKT_; - _ZNSt3__16__treeINS_12__value_typeIN7android8String16ENS_6vectorIS3_NS_9allocatorIS3_EEEEEENS_19__map_value_compareIS3_S8_NS_4lessIS3_EELb1EEENS5_IS8_EEE14__assign_multiINS_21__tree_const_iteratorIS8_PNS_11__tree_nodeIS8_PvEElEEEEvT_SM_; - _ZNSt3__16__treeINS_12__value_typeIN7android8String16ENS_6vectorIS3_NS_9allocatorIS3_EEEEEENS_19__map_value_compareIS3_S8_NS_4lessIS3_EELb1EEENS5_IS8_EEE14__erase_uniqueIS3_EEmRKT_; - _ZNSt3__16__treeINS_12__value_typeIN7android8String16ENS_6vectorIS3_NS_9allocatorIS3_EEEEEENS_19__map_value_compareIS3_S8_NS_4lessIS3_EELb1EEENS5_IS8_EEE15__emplace_multiIJRKNS_4pairIKS3_S7_EEEEENS_15__tree_iteratorIS8_PNS_11__tree_nodeIS8_PvEElEEDpOT_; - _ZNSt3__16__treeINS_12__value_typeIN7android8String16ENS_6vectorIS3_NS_9allocatorIS3_EEEEEENS_19__map_value_compareIS3_S8_NS_4lessIS3_EELb1EEENS5_IS8_EEE16__construct_nodeIJRKNS_4pairIKS3_S7_EEEEENS_10unique_ptrINS_11__tree_nodeIS8_PvEENS_22__tree_node_destructorINS5_ISO_EEEEEEDpOT_; - _ZNSt3__16__treeINS_12__value_typeIN7android8String16ENS_6vectorIS3_NS_9allocatorIS3_EEEEEENS_19__map_value_compareIS3_S8_NS_4lessIS3_EELb1EEENS5_IS8_EEE25__emplace_unique_key_argsIS3_JRKNS_21piecewise_construct_tENS_5tupleIJRKS3_EEENSJ_IJEEEEEENS_4pairINS_15__tree_iteratorIS8_PNS_11__tree_nodeIS8_PvEElEEbEERKT_DpOT0_; - _ZNSt3__16__treeINS_12__value_typeIN7android8String16ENS_6vectorIS3_NS_9allocatorIS3_EEEEEENS_19__map_value_compareIS3_S8_NS_4lessIS3_EELb1EEENS5_IS8_EEE30__emplace_hint_unique_key_argsIS3_JRKNS_4pairIKS3_S7_EEEEENS_15__tree_iteratorIS8_PNS_11__tree_nodeIS8_PvEElEENS_21__tree_const_iteratorIS8_SP_lEERKT_DpOT0_; - _ZNSt3__16__treeINS_12__value_typeIN7android8String16ENS_6vectorIS3_NS_9allocatorIS3_EEEEEENS_19__map_value_compareIS3_S8_NS_4lessIS3_EELb1EEENS5_IS8_EEE4findIS3_EENS_15__tree_iteratorIS8_PNS_11__tree_nodeIS8_PvEElEERKT_; - _ZNSt3__16__treeINS_12__value_typeIN7android8String16ENS_6vectorIS3_NS_9allocatorIS3_EEEEEENS_19__map_value_compareIS3_S8_NS_4lessIS3_EELb1EEENS5_IS8_EEE5eraseENS_21__tree_const_iteratorIS8_PNS_11__tree_nodeIS8_PvEElEE; - _ZNSt3__16__treeINS_12__value_typeIN7android8String16ENS_6vectorIS3_NS_9allocatorIS3_EEEEEENS_19__map_value_compareIS3_S8_NS_4lessIS3_EELb1EEENS5_IS8_EEE7destroyEPNS_11__tree_nodeIS8_PvEE; - _ZNSt3__16__treeINS_12__value_typeIN7android8String16ES3_EENS_19__map_value_compareIS3_S4_NS_4lessIS3_EELb1EEENS_9allocatorIS4_EEE12__find_equalIS3_EERPNS_16__tree_node_baseIPvEENS_21__tree_const_iteratorIS4_PNS_11__tree_nodeIS4_SE_EElEERPNS_15__tree_end_nodeISG_EESH_RKT_; - _ZNSt3__16__treeINS_12__value_typeIN7android8String16ES3_EENS_19__map_value_compareIS3_S4_NS_4lessIS3_EELb1EEENS_9allocatorIS4_EEE12__find_equalIS3_EERPNS_16__tree_node_baseIPvEERPNS_15__tree_end_nodeISG_EERKT_; - _ZNSt3__16__treeINS_12__value_typeIN7android8String16ES3_EENS_19__map_value_compareIS3_S4_NS_4lessIS3_EELb1EEENS_9allocatorIS4_EEE14__assign_multiINS_21__tree_const_iteratorIS4_PNS_11__tree_nodeIS4_PvEElEEEEvT_SJ_; - _ZNSt3__16__treeINS_12__value_typeIN7android8String16ES3_EENS_19__map_value_compareIS3_S4_NS_4lessIS3_EELb1EEENS_9allocatorIS4_EEE14__erase_uniqueIS3_EEmRKT_; - _ZNSt3__16__treeINS_12__value_typeIN7android8String16ES3_EENS_19__map_value_compareIS3_S4_NS_4lessIS3_EELb1EEENS_9allocatorIS4_EEE15__emplace_multiIJRKNS_4pairIKS3_S3_EEEEENS_15__tree_iteratorIS4_PNS_11__tree_nodeIS4_PvEElEEDpOT_; - _ZNSt3__16__treeINS_12__value_typeIN7android8String16ES3_EENS_19__map_value_compareIS3_S4_NS_4lessIS3_EELb1EEENS_9allocatorIS4_EEE25__emplace_unique_key_argsIS3_JRKNS_21piecewise_construct_tENS_5tupleIJRKS3_EEENSG_IJEEEEEENS_4pairINS_15__tree_iteratorIS4_PNS_11__tree_nodeIS4_PvEElEEbEERKT_DpOT0_; - _ZNSt3__16__treeINS_12__value_typeIN7android8String16ES3_EENS_19__map_value_compareIS3_S4_NS_4lessIS3_EELb1EEENS_9allocatorIS4_EEE30__emplace_hint_unique_key_argsIS3_JRKNS_4pairIKS3_S3_EEEEENS_15__tree_iteratorIS4_PNS_11__tree_nodeIS4_PvEElEENS_21__tree_const_iteratorIS4_SM_lEERKT_DpOT0_; - _ZNSt3__16__treeINS_12__value_typeIN7android8String16ES3_EENS_19__map_value_compareIS3_S4_NS_4lessIS3_EELb1EEENS_9allocatorIS4_EEE4findIS3_EENS_15__tree_iteratorIS4_PNS_11__tree_nodeIS4_PvEElEERKT_; - _ZNSt3__16__treeINS_12__value_typeIN7android8String16ES3_EENS_19__map_value_compareIS3_S4_NS_4lessIS3_EELb1EEENS_9allocatorIS4_EEE5eraseENS_21__tree_const_iteratorIS4_PNS_11__tree_nodeIS4_PvEElEE; - _ZNSt3__16__treeINS_12__value_typeIN7android8String16ES3_EENS_19__map_value_compareIS3_S4_NS_4lessIS3_EELb1EEENS_9allocatorIS4_EEE7destroyEPNS_11__tree_nodeIS4_PvEE; - _ZNSt3__16__treeINS_12__value_typeINS_11__thread_idENS_6threadEEENS_19__map_value_compareIS2_S4_NS_4lessIS2_EELb1EEENS_9allocatorIS4_EEE7destroyEPNS_11__tree_nodeIS4_PvEE; - _ZNSt3__16__treeINS_12__value_typeINS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEEN7android6binder8internal25ClientCounterCallbackImpl7ServiceEEENS_19__map_value_compareIS7_SD_NS_4lessIS7_EELb1EEENS5_ISD_EEE12__find_equalIS7_EERPNS_16__tree_node_baseIPvEERPNS_15__tree_end_nodeISO_EERKT_; - _ZNSt3__16__treeINS_12__value_typeINS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEEN7android6binder8internal25ClientCounterCallbackImpl7ServiceEEENS_19__map_value_compareIS7_SD_NS_4lessIS7_EELb1EEENS5_ISD_EEE25__emplace_unique_key_argsIS7_JRKNS_21piecewise_construct_tENS_5tupleIJRKS7_EEENSO_IJEEEEEENS_4pairINS_15__tree_iteratorISD_PNS_11__tree_nodeISD_PvEElEEbEERKT_DpOT0_; - _ZNSt3__16__treeINS_12__value_typeINS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEEN7android6binder8internal25ClientCounterCallbackImpl7ServiceEEENS_19__map_value_compareIS7_SD_NS_4lessIS7_EELb1EEENS5_ISD_EEE7destroyEPNS_11__tree_nodeISD_PvEE; - _ZNSt3__16vectorIaNS_9allocatorIaEEE6insertIPKaEENS_9enable_ifIXaasr21__is_forward_iteratorIT_EE5valuesr16is_constructibleIaNS_15iterator_traitsIS8_E9referenceEEE5valueENS_11__wrap_iterIPaEEE4typeENSC_IS6_EES8_S8_; - _ZNSt3__16vectorIbNS_9allocatorIbEEE18__construct_at_endINS_14__bit_iteratorIS3_Lb0ELm0EEEEENS_9enable_ifIXsr21__is_forward_iteratorIT_EE5valueEvE4typeES8_S8_; - _ZNSt3__16vectorIbNS_9allocatorIbEEE18__construct_at_endINS_14__bit_iteratorIS3_Lb1ELm0EEEEENS_9enable_ifIXsr21__is_forward_iteratorIT_EE5valueEvE4typeES8_S8_; - _ZNSt3__16vectorIbNS_9allocatorIbEEE7reserveEm; - _ZNSt3__16vectorIbNS_9allocatorIbEEE9push_backERKb; - _ZNSt3__16vectorIbNS_9allocatorIbEEEaSERKS3_; - _ZNSt3__16vectorIdNS_9allocatorIdEEE6assignIPdEENS_9enable_ifIXaasr21__is_forward_iteratorIT_EE5valuesr16is_constructibleIdNS_15iterator_traitsIS7_E9referenceEEE5valueEvE4typeES7_S7_; - _ZNSt3__16vectorIdNS_9allocatorIdEEE6insertIPKdEENS_9enable_ifIXaasr21__is_forward_iteratorIT_EE5valuesr16is_constructibleIdNS_15iterator_traitsIS8_E9referenceEEE5valueENS_11__wrap_iterIPdEEE4typeENSC_IS6_EES8_S8_; - _ZNSt3__16vectorIDsNS_9allocatorIDsEEE24__emplace_back_slow_pathIJDsEEEvDpOT_; - _ZNSt3__16vectorIDsNS_9allocatorIDsEEE7reserveEm; - _ZNSt3__16vectorIfNS_9allocatorIfEEE6insertIPKfEENS_9enable_ifIXaasr21__is_forward_iteratorIT_EE5valuesr16is_constructibleIfNS_15iterator_traitsIS8_E9referenceEEE5valueENS_11__wrap_iterIPfEEE4typeENSC_IS6_EES8_S8_; - _ZNSt3__16vectorIhNS_9allocatorIhEEE6insertIPKhEENS_9enable_ifIXaasr21__is_forward_iteratorIT_EE5valuesr16is_constructibleIhNS_15iterator_traitsIS8_E9referenceEEE5valueENS_11__wrap_iterIPhEEE4typeENSC_IS6_EES8_S8_; - _ZNSt3__16vectorIiNS_9allocatorIiEEE6assignIPiEENS_9enable_ifIXaasr21__is_forward_iteratorIT_EE5valuesr16is_constructibleIiNS_15iterator_traitsIS7_E9referenceEEE5valueEvE4typeES7_S7_; - _ZNSt3__16vectorIiNS_9allocatorIiEEE6insertIPKiEENS_9enable_ifIXaasr21__is_forward_iteratorIT_EE5valuesr16is_constructibleIiNS_15iterator_traitsIS8_E9referenceEEE5valueENS_11__wrap_iterIPiEEE4typeENSC_IS6_EES8_S8_; - _ZNSt3__16vectorIlNS_9allocatorIlEEE6assignIPlEENS_9enable_ifIXaasr21__is_forward_iteratorIT_EE5valuesr16is_constructibleIlNS_15iterator_traitsIS7_E9referenceEEE5valueEvE4typeES7_S7_; - _ZNSt3__16vectorImNS_9allocatorImEEE6insertIPKmEENS_9enable_ifIXaasr21__is_forward_iteratorIT_EE5valuesr16is_constructibleImNS_15iterator_traitsIS8_E9referenceEEE5valueENS_11__wrap_iterIPmEEE4typeENSC_IS6_EES8_S8_; - _ZNSt3__16vectorIN7android2os16ServiceDebugInfoENS_9allocatorIS3_EEE8__appendEm; - _ZNSt3__16vectorIN7android2spINS1_10RpcSession13RpcConnectionEEENS_9allocatorIS5_EEE21__push_back_slow_pathIRKS5_EEvOT_; - _ZNSt3__16vectorIN7android2spINS1_10RpcSessionEEENS_9allocatorIS4_EEE21__push_back_slow_pathIRKS4_EEvOT_; - _ZNSt3__16vectorIN7android2spINS1_7IBinderEEENS_9allocatorIS4_EEE21__push_back_slow_pathIRKS4_EEvOT_; - _ZNSt3__16vectorIN7android2spINS1_7IBinderEEENS_9allocatorIS4_EEE8__appendEm; - _ZNSt3__16vectorIN7android4base14unique_fd_implINS2_13DefaultCloserEEENS_9allocatorIS5_EEE8__appendEm; - _ZNSt3__16vectorIN7android8RpcState10BinderNode9AsyncTodoENS_9allocatorIS4_EEE21__push_back_slow_pathIS4_EEvOT_; - _ZNSt3__16vectorIN7android8String16ENS_9allocatorIS2_EEE6assignIPS2_EENS_9enable_ifIXaasr21__is_forward_iteratorIT_EE5valuesr16is_constructibleIS2_NS_15iterator_traitsIS9_E9referenceEEE5valueEvE4typeES9_S9_; - _ZNSt3__16vectorIN7android8String16ENS_9allocatorIS2_EEE8__appendEm; - _ZNSt3__16vectorINS_10unique_ptrIN7android8String16ENS_14default_deleteIS3_EEEENS_9allocatorIS6_EEE8__appendEm; - _ZNSt3__16vectorINS_10unique_ptrINS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEENS_14default_deleteIS7_EEEENS5_ISA_EEE8__appendEm; - _ZNSt3__16vectorINS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEENS4_IS6_EEE8__appendEm; - _ZNSt3__16vectorINS_8optionalIN7android8String16EEENS_9allocatorIS4_EEE8__appendEm; - _ZNSt3__16vectorINS_8optionalINS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEEEENS5_IS8_EEE8__appendEm; - _ZTCN7android10AllocationE0_NS_10IInterfaceE; - _ZTCN7android10AllocationE0_NS_10MemoryBaseE; - _ZTCN7android10AllocationE0_NS_11BnInterfaceINS_7IMemoryEEE; - _ZTCN7android10AllocationE0_NS_7IMemoryE; - _ZTCN7android10AllocationE0_NS_8BnMemoryE; - _ZTCN7android10AllocationE8_NS_7BBinderE; - _ZTCN7android10AllocationE8_NS_7IBinderE; - _ZTCN7android10MemoryBaseE0_NS_10IInterfaceE; - _ZTCN7android10MemoryBaseE0_NS_11BnInterfaceINS_7IMemoryEEE; - _ZTCN7android10MemoryBaseE0_NS_7IMemoryE; - _ZTCN7android10MemoryBaseE0_NS_8BnMemoryE; - _ZTCN7android10MemoryBaseE8_NS_7BBinderE; - _ZTCN7android10MemoryBaseE8_NS_7IBinderE; - _ZTCN7android10PoolThreadE0_NS_6ThreadE; - _ZTCN7android11IMemoryHeapE0_NS_10IInterfaceE; - _ZTCN7android12BnMemoryHeapE0_NS_10IInterfaceE; - _ZTCN7android12BnMemoryHeapE0_NS_11BnInterfaceINS_11IMemoryHeapEEE; - _ZTCN7android12BnMemoryHeapE0_NS_11IMemoryHeapE; - _ZTCN7android12BnMemoryHeapE8_NS_7BBinderE; - _ZTCN7android12BnMemoryHeapE8_NS_7IBinderE; - _ZTCN7android12BpMemoryHeapE0_NS_10IInterfaceE; - _ZTCN7android12BpMemoryHeapE0_NS_11BpInterfaceINS_11IMemoryHeapEEE; - _ZTCN7android12BpMemoryHeapE0_NS_11IMemoryHeapE; - _ZTCN7android12BpMemoryHeapE8_NS_9BpRefBaseE; - _ZTCN7android14IShellCallbackE0_NS_10IInterfaceE; - _ZTCN7android14MemoryHeapBaseE64_NS_10IInterfaceE; - _ZTCN7android14MemoryHeapBaseE64_NS_11BnInterfaceINS_11IMemoryHeapEEE; - _ZTCN7android14MemoryHeapBaseE64_NS_11IMemoryHeapE; - _ZTCN7android14MemoryHeapBaseE64_NS_12BnMemoryHeapE; - _ZTCN7android14MemoryHeapBaseE72_NS_7BBinderE; - _ZTCN7android14MemoryHeapBaseE72_NS_7IBinderE; - _ZTCN7android15BnShellCallbackE0_NS_10IInterfaceE; - _ZTCN7android15BnShellCallbackE0_NS_11BnInterfaceINS_14IShellCallbackEEE; - _ZTCN7android15BnShellCallbackE0_NS_14IShellCallbackE; - _ZTCN7android15BnShellCallbackE8_NS_7BBinderE; - _ZTCN7android15BnShellCallbackE8_NS_7IBinderE; - _ZTCN7android15BpShellCallbackE0_NS_10IInterfaceE; - _ZTCN7android15BpShellCallbackE0_NS_11BpInterfaceINS_14IShellCallbackEEE; - _ZTCN7android15BpShellCallbackE0_NS_14IShellCallbackE; - _ZTCN7android15BpShellCallbackE8_NS_9BpRefBaseE; - _ZTCN7android15IResultReceiverE0_NS_10IInterfaceE; - _ZTCN7android15IServiceManagerE0_NS_10IInterfaceE; - _ZTCN7android16BnResultReceiverE0_NS_10IInterfaceE; - _ZTCN7android16BnResultReceiverE0_NS_11BnInterfaceINS_15IResultReceiverEEE; - _ZTCN7android16BnResultReceiverE0_NS_15IResultReceiverE; - _ZTCN7android16BnResultReceiverE8_NS_7BBinderE; - _ZTCN7android16BnResultReceiverE8_NS_7IBinderE; - _ZTCN7android16BpResultReceiverE0_NS_10IInterfaceE; - _ZTCN7android16BpResultReceiverE0_NS_11BpInterfaceINS_15IResultReceiverEEE; - _ZTCN7android16BpResultReceiverE0_NS_15IResultReceiverE; - _ZTCN7android16BpResultReceiverE8_NS_9BpRefBaseE; - _ZTCN7android18ServiceManagerShimE0_NS_10IInterfaceE; - _ZTCN7android18ServiceManagerShimE0_NS_15IServiceManagerE; - _ZTCN7android2os15IClientCallbackE0_NS_10IInterfaceE; - _ZTCN7android2os15IServiceManagerE0_NS_10IInterfaceE; - _ZTCN7android2os16BnClientCallbackE0_NS0_15IClientCallbackE; - _ZTCN7android2os16BnClientCallbackE0_NS_10IInterfaceE; - _ZTCN7android2os16BnClientCallbackE0_NS_11BnInterfaceINS0_15IClientCallbackEEE; - _ZTCN7android2os16BnClientCallbackE8_NS_7BBinderE; - _ZTCN7android2os16BnClientCallbackE8_NS_7IBinderE; - _ZTCN7android2os16BnServiceManagerE0_NS0_15IServiceManagerE; - _ZTCN7android2os16BnServiceManagerE0_NS_10IInterfaceE; - _ZTCN7android2os16BnServiceManagerE0_NS_11BnInterfaceINS0_15IServiceManagerEEE; - _ZTCN7android2os16BnServiceManagerE8_NS_7BBinderE; - _ZTCN7android2os16BnServiceManagerE8_NS_7IBinderE; - _ZTCN7android2os16BpClientCallbackE0_NS0_15IClientCallbackE; - _ZTCN7android2os16BpClientCallbackE0_NS_10IInterfaceE; - _ZTCN7android2os16BpClientCallbackE0_NS_11BpInterfaceINS0_15IClientCallbackEEE; - _ZTCN7android2os16BpClientCallbackE8_NS_9BpRefBaseE; - _ZTCN7android2os16BpServiceManagerE0_NS0_15IServiceManagerE; - _ZTCN7android2os16BpServiceManagerE0_NS_10IInterfaceE; - _ZTCN7android2os16BpServiceManagerE0_NS_11BpInterfaceINS0_15IServiceManagerEEE; - _ZTCN7android2os16BpServiceManagerE8_NS_9BpRefBaseE; - _ZTCN7android2os16IServiceCallbackE0_NS_10IInterfaceE; - _ZTCN7android2os17BnServiceCallbackE0_NS0_16IServiceCallbackE; - _ZTCN7android2os17BnServiceCallbackE0_NS_10IInterfaceE; - _ZTCN7android2os17BnServiceCallbackE0_NS_11BnInterfaceINS0_16IServiceCallbackEEE; - _ZTCN7android2os17BnServiceCallbackE8_NS_7BBinderE; - _ZTCN7android2os17BnServiceCallbackE8_NS_7IBinderE; - _ZTCN7android2os17BpServiceCallbackE0_NS0_16IServiceCallbackE; - _ZTCN7android2os17BpServiceCallbackE0_NS_10IInterfaceE; - _ZTCN7android2os17BpServiceCallbackE0_NS_11BpInterfaceINS0_16IServiceCallbackEEE; - _ZTCN7android2os17BpServiceCallbackE8_NS_9BpRefBaseE; - _ZTCN7android6binder8internal25ClientCounterCallbackImplE0_NS_10IInterfaceE; - _ZTCN7android6binder8internal25ClientCounterCallbackImplE0_NS_11BnInterfaceINS_2os15IClientCallbackEEE; - _ZTCN7android6binder8internal25ClientCounterCallbackImplE0_NS_2os15IClientCallbackE; - _ZTCN7android6binder8internal25ClientCounterCallbackImplE0_NS_2os16BnClientCallbackE; - _ZTCN7android6binder8internal25ClientCounterCallbackImplE8_NS_7BBinderE; - _ZTCN7android6binder8internal25ClientCounterCallbackImplE8_NS_7IBinderE; - _ZTCN7android7BBinderE0_NS_7IBinderE; - _ZTCN7android7content2pm21IPackageManagerNativeE0_NS_10IInterfaceE; - _ZTCN7android7content2pm22BnPackageManagerNativeE0_NS_10IInterfaceE; - _ZTCN7android7content2pm22BnPackageManagerNativeE0_NS_11BnInterfaceINS1_21IPackageManagerNativeEEE; - _ZTCN7android7content2pm22BnPackageManagerNativeE0_NS1_21IPackageManagerNativeE; - _ZTCN7android7content2pm22BnPackageManagerNativeE8_NS_7BBinderE; - _ZTCN7android7content2pm22BnPackageManagerNativeE8_NS_7IBinderE; - _ZTCN7android7content2pm22BpPackageManagerNativeE0_NS_10IInterfaceE; - _ZTCN7android7content2pm22BpPackageManagerNativeE0_NS_11BpInterfaceINS1_21IPackageManagerNativeEEE; - _ZTCN7android7content2pm22BpPackageManagerNativeE0_NS1_21IPackageManagerNativeE; - _ZTCN7android7content2pm22BpPackageManagerNativeE8_NS_9BpRefBaseE; - _ZTCN7android7content2pm22IPackageChangeObserverE0_NS_10IInterfaceE; - _ZTCN7android7content2pm23BnPackageChangeObserverE0_NS_10IInterfaceE; - _ZTCN7android7content2pm23BnPackageChangeObserverE0_NS_11BnInterfaceINS1_22IPackageChangeObserverEEE; - _ZTCN7android7content2pm23BnPackageChangeObserverE0_NS1_22IPackageChangeObserverE; - _ZTCN7android7content2pm23BnPackageChangeObserverE8_NS_7BBinderE; - _ZTCN7android7content2pm23BnPackageChangeObserverE8_NS_7IBinderE; - _ZTCN7android7content2pm23BpPackageChangeObserverE0_NS_10IInterfaceE; - _ZTCN7android7content2pm23BpPackageChangeObserverE0_NS_11BpInterfaceINS1_22IPackageChangeObserverEEE; - _ZTCN7android7content2pm23BpPackageChangeObserverE0_NS1_22IPackageChangeObserverE; - _ZTCN7android7content2pm23BpPackageChangeObserverE8_NS_9BpRefBaseE; - _ZTCN7android7IMemoryE0_NS_10IInterfaceE; - _ZTCN7android8BnMemoryE0_NS_10IInterfaceE; - _ZTCN7android8BnMemoryE0_NS_11BnInterfaceINS_7IMemoryEEE; - _ZTCN7android8BnMemoryE0_NS_7IMemoryE; - _ZTCN7android8BnMemoryE8_NS_7BBinderE; - _ZTCN7android8BnMemoryE8_NS_7IBinderE; - _ZTCN7android8BpBinderE0_NS_7IBinderE; - _ZTCN7android8BpMemoryE0_NS_10IInterfaceE; - _ZTCN7android8BpMemoryE0_NS_11BpInterfaceINS_7IMemoryEEE; - _ZTCN7android8BpMemoryE0_NS_7IMemoryE; - _ZTCN7android8BpMemoryE8_NS_9BpRefBaseE; - _ZTCN7android9HeapCacheE0_NS_7IBinder14DeathRecipientE; - _ZTCNSt3__118basic_stringstreamIcNS_11char_traitsIcEENS_9allocatorIcEEEE0_NS_13basic_istreamIcS2_EE; - _ZTCNSt3__118basic_stringstreamIcNS_11char_traitsIcEENS_9allocatorIcEEEE0_NS_14basic_iostreamIcS2_EE; - _ZTCNSt3__118basic_stringstreamIcNS_11char_traitsIcEENS_9allocatorIcEEEE16_NS_13basic_ostreamIcS2_EE; - _ZThn8_N7android10AllocationD0Ev; - _ZThn8_N7android10AllocationD1Ev; - _ZThn8_N7android10MemoryBaseD0Ev; - _ZThn8_N7android10MemoryBaseD1Ev; - _ZThn8_N7android12BnMemoryHeap10onTransactEjRKNS_6ParcelEPS1_j; - _ZThn8_N7android12BnMemoryHeapD0Ev; - _ZThn8_N7android12BnMemoryHeapD1Ev; - _ZThn8_N7android12BpMemoryHeapD0Ev; - _ZThn8_N7android12BpMemoryHeapD1Ev; - _ZThn8_N7android15BnShellCallback10onTransactEjRKNS_6ParcelEPS1_j; - _ZThn8_N7android16BnResultReceiver10onTransactEjRKNS_6ParcelEPS1_j; - _ZThn8_N7android2os16BnClientCallback10onTransactEjRKNS_6ParcelEPS2_j; - _ZThn8_N7android2os16BnServiceManager10onTransactEjRKNS_6ParcelEPS2_j; - _ZThn8_N7android2os17BnServiceCallback10onTransactEjRKNS_6ParcelEPS2_j; - _ZThn8_N7android7content2pm22BnPackageManagerNative10onTransactEjRKNS_6ParcelEPS3_j; - _ZThn8_N7android7content2pm23BnPackageChangeObserver10onTransactEjRKNS_6ParcelEPS3_j; - _ZThn8_N7android8BnMemory10onTransactEjRKNS_6ParcelEPS1_j; - _ZThn8_N7android8BnMemoryD0Ev; - _ZThn8_N7android8BnMemoryD1Ev; - _ZThn8_N7android8BpMemoryD0Ev; - _ZThn8_N7android8BpMemoryD1Ev; - _ZTTN7android10AllocationE; - _ZTTN7android10IInterfaceE; - _ZTTN7android10MemoryBaseE; - _ZTTN7android10PoolThreadE; - _ZTTN7android10RpcSessionE; - _ZTTN7android11IMemoryHeapE; - _ZTTN7android12BnMemoryHeapE; - _ZTTN7android12BpMemoryHeapE; - _ZTTN7android12ProcessStateE; - _ZTTN7android14IShellCallbackE; - _ZTTN7android14MemoryHeapBaseE; - _ZTTN7android15BnShellCallbackE; - _ZTTN7android15BpShellCallbackE; - _ZTTN7android15IResultReceiverE; - _ZTTN7android15IServiceManagerE; - _ZTTN7android16BnResultReceiverE; - _ZTTN7android16BpResultReceiverE; - _ZTTN7android18ServiceManagerShimE; - _ZTTN7android2os15IClientCallbackE; - _ZTTN7android2os15IServiceManagerE; - _ZTTN7android2os16BnClientCallbackE; - _ZTTN7android2os16BnServiceManagerE; - _ZTTN7android2os16BpClientCallbackE; - _ZTTN7android2os16BpServiceManagerE; - _ZTTN7android2os16IServiceCallbackE; - _ZTTN7android2os17BnServiceCallbackE; - _ZTTN7android2os17BpServiceCallbackE; - _ZTTN7android6binder8internal25ClientCounterCallbackImplE; - _ZTTN7android7BBinderE; - _ZTTN7android7content2pm21IPackageManagerNativeE; - _ZTTN7android7content2pm22BnPackageManagerNativeE; - _ZTTN7android7content2pm22BpPackageManagerNativeE; - _ZTTN7android7content2pm22IPackageChangeObserverE; - _ZTTN7android7content2pm23BnPackageChangeObserverE; - _ZTTN7android7content2pm23BpPackageChangeObserverE; - _ZTTN7android7IBinderE; - _ZTTN7android7IMemoryE; - _ZTTN7android8BnMemoryE; - _ZTTN7android8BpBinderE; - _ZTTN7android8BpMemoryE; - _ZTTN7android9BpRefBaseE; - _ZTTN7android9HeapCacheE; - _ZTTN7android9RpcServerE; - _ZTTNSt3__118basic_stringstreamIcNS_11char_traitsIcEENS_9allocatorIcEEEE; - _ZTv0_n24_N7android10AllocationD0Ev; - _ZTv0_n24_N7android10AllocationD1Ev; - _ZTv0_n24_N7android10IInterfaceD0Ev; - _ZTv0_n24_N7android10IInterfaceD1Ev; - _ZTv0_n24_N7android10MemoryBaseD0Ev; - _ZTv0_n24_N7android10MemoryBaseD1Ev; - _ZTv0_n24_N7android10RpcSessionD0Ev; - _ZTv0_n24_N7android10RpcSessionD1Ev; - _ZTv0_n24_N7android11IMemoryHeapD0Ev; - _ZTv0_n24_N7android11IMemoryHeapD1Ev; - _ZTv0_n24_N7android12BnMemoryHeapD0Ev; - _ZTv0_n24_N7android12BnMemoryHeapD1Ev; - _ZTv0_n24_N7android12BpMemoryHeapD0Ev; - _ZTv0_n24_N7android12BpMemoryHeapD1Ev; - _ZTv0_n24_N7android12ProcessStateD0Ev; - _ZTv0_n24_N7android12ProcessStateD1Ev; - _ZTv0_n24_N7android14IShellCallbackD0Ev; - _ZTv0_n24_N7android14IShellCallbackD1Ev; - _ZTv0_n24_N7android14MemoryHeapBaseD0Ev; - _ZTv0_n24_N7android14MemoryHeapBaseD1Ev; - _ZTv0_n24_N7android15IResultReceiverD0Ev; - _ZTv0_n24_N7android15IResultReceiverD1Ev; - _ZTv0_n24_N7android15IServiceManagerD0Ev; - _ZTv0_n24_N7android15IServiceManagerD1Ev; - _ZTv0_n24_N7android2os15IClientCallbackD0Ev; - _ZTv0_n24_N7android2os15IClientCallbackD1Ev; - _ZTv0_n24_N7android2os15IServiceManagerD0Ev; - _ZTv0_n24_N7android2os15IServiceManagerD1Ev; - _ZTv0_n24_N7android2os16IServiceCallbackD0Ev; - _ZTv0_n24_N7android2os16IServiceCallbackD1Ev; - _ZTv0_n24_N7android7BBinderD0Ev; - _ZTv0_n24_N7android7BBinderD1Ev; - _ZTv0_n24_N7android7content2pm21IPackageManagerNativeD0Ev; - _ZTv0_n24_N7android7content2pm21IPackageManagerNativeD1Ev; - _ZTv0_n24_N7android7content2pm22IPackageChangeObserverD0Ev; - _ZTv0_n24_N7android7content2pm22IPackageChangeObserverD1Ev; - _ZTv0_n24_N7android7IBinderD0Ev; - _ZTv0_n24_N7android7IBinderD1Ev; - _ZTv0_n24_N7android7IMemoryD0Ev; - _ZTv0_n24_N7android7IMemoryD1Ev; - _ZTv0_n24_N7android8BnMemoryD0Ev; - _ZTv0_n24_N7android8BnMemoryD1Ev; - _ZTv0_n24_N7android8BpBinderD0Ev; - _ZTv0_n24_N7android8BpBinderD1Ev; - _ZTv0_n24_N7android8BpMemoryD0Ev; - _ZTv0_n24_N7android8BpMemoryD1Ev; - _ZTv0_n24_N7android9BpRefBaseD0Ev; - _ZTv0_n24_N7android9BpRefBaseD1Ev; - _ZTv0_n24_N7android9HeapCacheD0Ev; - _ZTv0_n24_N7android9HeapCacheD1Ev; - _ZTv0_n24_N7android9RpcServerD0Ev; - _ZTv0_n24_N7android9RpcServerD1Ev; - _ZTv0_n32_N7android14MemoryHeapBaseD0Ev; - _ZTv0_n32_N7android14MemoryHeapBaseD1Ev; - _ZTv0_n32_N7android8BpBinder10onFirstRefEv; - _ZTv0_n32_N7android9BpRefBase10onFirstRefEv; - _ZTv0_n40_N7android8BpBinder15onLastStrongRefEPKv; - _ZTv0_n40_N7android9BpRefBase15onLastStrongRefEPKv; - _ZTv0_n48_N7android8BpBinder20onIncStrongAttemptedEjPKv; - _ZTv0_n48_N7android9BpRefBase20onIncStrongAttemptedEjPKv; - _ZTv0_n56_NK7android14MemoryHeapBase9getHeapIDEv; - _ZTv0_n64_NK7android14MemoryHeapBase7getBaseEv; - _ZTv0_n72_NK7android14MemoryHeapBase7getSizeEv; - _ZTv0_n80_NK7android14MemoryHeapBase8getFlagsEv; - _ZTv0_n88_NK7android14MemoryHeapBase9getOffsetEv; - _ZTVN7android10AllocationE; - _ZTVN7android10IInterfaceE; - _ZTVN7android10MemoryBaseE; - _ZTVN7android10PoolThreadE; - _ZTVN7android10RpcSession13RpcConnectionE; - _ZTVN7android10RpcSessionE; - _ZTVN7android10TextOutputE; - _ZTVN7android11IMemoryHeapE; - _ZTVN7android12BnMemoryHeapE; - _ZTVN7android12BpMemoryHeapE; - _ZTVN7android12FdTextOutputE; - _ZTVN7android12MemoryDealerE; - _ZTVN7android12ProcessStateE; - _ZTVN7android12SortedVectorINS_16key_value_pair_tINS_2wpINS_7IBinderEEENS_9HeapCache11heap_info_tEEEEE; - _ZTVN7android12SortedVectorINS_16key_value_pair_tIPKvNS_8BpBinder13ObjectManager7entry_tEEEEE; - _ZTVN7android13LogTextOutputE; - _ZTVN7android14IShellCallbackE; - _ZTVN7android14MemoryHeapBaseE; - _ZTVN7android15BnShellCallbackE; - _ZTVN7android15BpShellCallbackE; - _ZTVN7android15IResultReceiverE; - _ZTVN7android15IServiceManagerE; - _ZTVN7android16BnResultReceiverE; - _ZTVN7android16BpResultReceiverE; - _ZTVN7android17InetSocketAddressE; - _ZTVN7android17UnixSocketAddressE; - _ZTVN7android18BufferedTextOutput11BufferStateE; - _ZTVN7android18BufferedTextOutputE; - _ZTVN7android18ServiceManagerShimE; - _ZTVN7android18VsockSocketAddressE; - _ZTVN7android2os15IClientCallbackE; - _ZTVN7android2os15IServiceManagerE; - _ZTVN7android2os16BnClientCallbackE; - _ZTVN7android2os16BnServiceManagerE; - _ZTVN7android2os16BpClientCallbackE; - _ZTVN7android2os16BpServiceManagerE; - _ZTVN7android2os16IServiceCallbackE; - _ZTVN7android2os16ParcelableHolderE; - _ZTVN7android2os16ServiceDebugInfoE; - _ZTVN7android2os17BnServiceCallbackE; - _ZTVN7android2os17BpServiceCallbackE; - _ZTVN7android2os17PersistableBundleE; - _ZTVN7android2os20ParcelFileDescriptorE; - _ZTVN7android6binder8internal25ClientCounterCallbackImplE; - _ZTVN7android6VectorIiEE; - _ZTVN7android6VectorINS_12ProcessState12handle_entryEEE; - _ZTVN7android6VectorINS_2spINS_18BufferedTextOutput11BufferStateEEEEE; - _ZTVN7android6VectorINS_8BpBinder8ObituaryEEE; - _ZTVN7android6VectorINS_8String16EEE; - _ZTVN7android6VectorIPNS_7BBinderEEE; - _ZTVN7android6VectorIPNS_7RefBase12weakref_typeEEE; - _ZTVN7android6VectorIPNS_7RefBaseEEE; - _ZTVN7android7BBinderE; - _ZTVN7android7content2pm18PackageChangeEventE; - _ZTVN7android7content2pm21IPackageManagerNativeE; - _ZTVN7android7content2pm22BnPackageManagerNativeE; - _ZTVN7android7content2pm22BpPackageManagerNativeE; - _ZTVN7android7content2pm22IPackageChangeObserverE; - _ZTVN7android7content2pm23BnPackageChangeObserverE; - _ZTVN7android7content2pm23BpPackageChangeObserverE; - _ZTVN7android7IBinderE; - _ZTVN7android7IMemoryE; - _ZTVN7android8BnMemoryE; - _ZTVN7android8BpBinderE; - _ZTVN7android8BpMemoryE; - _ZTVN7android9BpRefBaseE; - _ZTVN7android9HeapCacheE; - _ZTVN7android9RpcServerE; - _ZTvn8_n32_N7android14MemoryHeapBaseD0Ev; - _ZTvn8_n32_N7android14MemoryHeapBaseD1Ev; - _ZTVNSt3__115basic_stringbufIcNS_11char_traitsIcEENS_9allocatorIcEEEE; - _ZTVNSt3__118basic_stringstreamIcNS_11char_traitsIcEENS_9allocatorIcEEEE; - _ZTVNSt3__120__shared_ptr_emplaceIN7android14RpcWireAddressENS_9allocatorIS2_EEEE; - _ZTVNSt3__120__shared_ptr_emplaceIN7android6binder8internal21ClientCounterCallbackENS_9allocatorIS4_EEEE; - local: - *; -}; diff --git a/libs/binder/libbinder.map b/libs/binder/libbinder.map new file mode 100644 index 0000000000..9ca14bcec2 --- /dev/null +++ b/libs/binder/libbinder.map @@ -0,0 +1,5 @@ +# b/190148312: Populate with correct list of ABI symbols +LIBBINDER { + global: + *; +}; diff --git a/libs/binder/libbinder_rpc_unstable.cpp b/libs/binder/libbinder_rpc_unstable.cpp new file mode 100644 index 0000000000..68ec669c31 --- /dev/null +++ b/libs/binder/libbinder_rpc_unstable.cpp @@ -0,0 +1,50 @@ +/* + * Copyright (C) 2021 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include <android-base/logging.h> +#include <android/binder_libbinder.h> +#include <binder/RpcServer.h> +#include <binder/RpcSession.h> + +using android::RpcServer; +using android::RpcSession; + +extern "C" { + +bool RunRpcServer(AIBinder* service, unsigned int port) { + auto server = RpcServer::make(); + server->iUnderstandThisCodeIsExperimentalAndIWillNotUseItInProduction(); + if (!server->setupVsockServer(port)) { + LOG(ERROR) << "Failed to set up vsock server with port " << port; + return false; + } + server->setRootObject(AIBinder_toPlatformBinder(service)); + server->join(); + + // Shutdown any open sessions since server failed. + (void)server->shutdown(); + return true; +} + +AIBinder* RpcClient(unsigned int cid, unsigned int port) { + auto session = RpcSession::make(); + if (!session->setupVsockClient(cid, port)) { + LOG(ERROR) << "Failed to set up vsock client with CID " << cid << " and port " << port; + return nullptr; + } + return AIBinder_fromPlatformBinder(session->getRootObject()); +} +} diff --git a/libs/binder/libbinder_rpc_unstable.map.txt b/libs/binder/libbinder_rpc_unstable.map.txt new file mode 100644 index 0000000000..3921a4dde8 --- /dev/null +++ b/libs/binder/libbinder_rpc_unstable.map.txt @@ -0,0 +1,7 @@ +LIBBINDER_RPC_UNSTABLE_SHIM { # platform-only + global: + RunRpcServer; + RpcClient; + local: + *; +}; diff --git a/libs/binder/ndk/include_cpp/android/binder_parcel_utils.h b/libs/binder/ndk/include_cpp/android/binder_parcel_utils.h index 83190aa56e..5092d872fa 100644 --- a/libs/binder/ndk/include_cpp/android/binder_parcel_utils.h +++ b/libs/binder/ndk/include_cpp/android/binder_parcel_utils.h @@ -910,6 +910,9 @@ static inline binder_status_t AParcel_resizeVector(const AParcel* parcel, std::v if (err != STATUS_OK) return err; if (size < 0) return STATUS_UNEXPECTED_NULL; + // TODO(b/188215728): delegate to libbinder_ndk + if (size > 1000000) return STATUS_NO_MEMORY; + vec->resize(static_cast<size_t>(size)); return STATUS_OK; } @@ -931,6 +934,9 @@ static inline binder_status_t AParcel_resizeVector(const AParcel* parcel, return STATUS_OK; } + // TODO(b/188215728): delegate to libbinder_ndk + if (size > 1000000) return STATUS_NO_MEMORY; + *vec = std::optional<std::vector<T>>(std::vector<T>{}); (*vec)->resize(static_cast<size_t>(size)); return STATUS_OK; diff --git a/libs/binder/ndk/include_platform/android/binder_parcel_platform.h b/libs/binder/ndk/include_platform/android/binder_parcel_platform.h index 6372449716..b24094ef16 100644 --- a/libs/binder/ndk/include_platform/android/binder_parcel_platform.h +++ b/libs/binder/ndk/include_platform/android/binder_parcel_platform.h @@ -33,7 +33,6 @@ bool AParcel_getAllowFds(const AParcel*); #endif -#if !defined(__ANDROID_APEX__) /** * Data written to the parcel will be zero'd before being deleted or realloced. * @@ -44,6 +43,5 @@ bool AParcel_getAllowFds(const AParcel*); * \param parcel The parcel to clear associated data from. */ void AParcel_markSensitive(const AParcel* parcel); -#endif __END_DECLS diff --git a/libs/binder/ndk/libbinder_ndk.map.txt b/libs/binder/ndk/libbinder_ndk.map.txt index 7d4b82e4b6..685ebb5023 100644 --- a/libs/binder/ndk/libbinder_ndk.map.txt +++ b/libs/binder/ndk/libbinder_ndk.map.txt @@ -117,7 +117,7 @@ LIBBINDER_NDK31 { # introduced=31 ABinderProcess_setupPolling; # apex AIBinder_getCallingSid; # apex AIBinder_setRequestingSid; # apex - AParcel_markSensitive; # llndk + AParcel_markSensitive; # systemapi llndk AServiceManager_forEachDeclaredInstance; # apex llndk AServiceManager_forceLazyServicesPersist; # llndk AServiceManager_isDeclared; # apex llndk diff --git a/libs/binder/ndk/parcel.cpp b/libs/binder/ndk/parcel.cpp index ec7c7d8c88..b2f21c7408 100644 --- a/libs/binder/ndk/parcel.cpp +++ b/libs/binder/ndk/parcel.cpp @@ -46,7 +46,8 @@ using ArrayGetter = T (*)(const void* arrayData, size_t index); template <typename T> using ArraySetter = void (*)(void* arrayData, size_t index, T value); -binder_status_t WriteAndValidateArraySize(AParcel* parcel, bool isNullArray, int32_t length) { +static binder_status_t WriteAndValidateArraySize(AParcel* parcel, bool isNullArray, + int32_t length) { // only -1 can be used to represent a null array if (length < -1) return STATUS_BAD_VALUE; @@ -61,12 +62,24 @@ binder_status_t WriteAndValidateArraySize(AParcel* parcel, bool isNullArray, int Parcel* rawParcel = parcel->get(); - status_t status = rawParcel->writeInt32(static_cast<int32_t>(length)); + status_t status = rawParcel->writeInt32(length); if (status != STATUS_OK) return PruneStatusT(status); return STATUS_OK; } +static binder_status_t ReadAndValidateArraySize(const AParcel* parcel, int32_t* length) { + if (status_t status = parcel->get()->readInt32(length); status != STATUS_OK) { + return PruneStatusT(status); + } + + if (*length < -1) return STATUS_BAD_VALUE; // libbinder_ndk reserves these + if (*length <= 0) return STATUS_OK; // null + if (static_cast<size_t>(*length) > parcel->get()->dataAvail()) return STATUS_NO_MEMORY; + + return STATUS_OK; +} + template <typename T> binder_status_t WriteArray(AParcel* parcel, const T* array, int32_t length) { binder_status_t status = WriteAndValidateArraySize(parcel, array == nullptr, length); @@ -111,10 +124,9 @@ binder_status_t ReadArray(const AParcel* parcel, void* arrayData, const Parcel* rawParcel = parcel->get(); int32_t length; - status_t status = rawParcel->readInt32(&length); - - if (status != STATUS_OK) return PruneStatusT(status); - if (length < -1) return STATUS_BAD_VALUE; + if (binder_status_t status = ReadAndValidateArraySize(parcel, &length); status != STATUS_OK) { + return status; + } T* array; if (!allocator(arrayData, length, &array)) return STATUS_NO_MEMORY; @@ -140,10 +152,9 @@ binder_status_t ReadArray<char16_t>(const AParcel* parcel, void* arrayData, const Parcel* rawParcel = parcel->get(); int32_t length; - status_t status = rawParcel->readInt32(&length); - - if (status != STATUS_OK) return PruneStatusT(status); - if (length < -1) return STATUS_BAD_VALUE; + if (binder_status_t status = ReadAndValidateArraySize(parcel, &length); status != STATUS_OK) { + return status; + } char16_t* array; if (!allocator(arrayData, length, &array)) return STATUS_NO_MEMORY; @@ -155,7 +166,7 @@ binder_status_t ReadArray<char16_t>(const AParcel* parcel, void* arrayData, if (__builtin_smul_overflow(sizeof(char16_t), length, &size)) return STATUS_NO_MEMORY; for (int32_t i = 0; i < length; i++) { - status = rawParcel->readChar(array + i); + status_t status = rawParcel->readChar(array + i); if (status != STATUS_OK) return PruneStatusT(status); } @@ -189,10 +200,9 @@ binder_status_t ReadArray(const AParcel* parcel, void* arrayData, ArrayAllocator const Parcel* rawParcel = parcel->get(); int32_t length; - status_t status = rawParcel->readInt32(&length); - - if (status != STATUS_OK) return PruneStatusT(status); - if (length < -1) return STATUS_BAD_VALUE; + if (binder_status_t status = ReadAndValidateArraySize(parcel, &length); status != STATUS_OK) { + return status; + } if (!allocator(arrayData, length)) return STATUS_NO_MEMORY; @@ -200,7 +210,7 @@ binder_status_t ReadArray(const AParcel* parcel, void* arrayData, ArrayAllocator for (int32_t i = 0; i < length; i++) { T readTarget; - status = (rawParcel->*read)(&readTarget); + status_t status = (rawParcel->*read)(&readTarget); if (status != STATUS_OK) return PruneStatusT(status); setter(arrayData, i, readTarget); @@ -402,13 +412,10 @@ struct StringArrayElementAllocationAdapter { binder_status_t AParcel_readStringArray(const AParcel* parcel, void* arrayData, AParcel_stringArrayAllocator allocator, AParcel_stringArrayElementAllocator elementAllocator) { - const Parcel* rawParcel = parcel->get(); - int32_t length; - status_t status = rawParcel->readInt32(&length); - - if (status != STATUS_OK) return PruneStatusT(status); - if (length < -1) return STATUS_BAD_VALUE; + if (binder_status_t status = ReadAndValidateArraySize(parcel, &length); status != STATUS_OK) { + return status; + } if (!allocator(arrayData, length)) return STATUS_NO_MEMORY; @@ -449,13 +456,10 @@ binder_status_t AParcel_writeParcelableArray(AParcel* parcel, const void* arrayD binder_status_t AParcel_readParcelableArray(const AParcel* parcel, void* arrayData, AParcel_parcelableArrayAllocator allocator, AParcel_readParcelableElement elementReader) { - const Parcel* rawParcel = parcel->get(); - int32_t length; - status_t status = rawParcel->readInt32(&length); - - if (status != STATUS_OK) return PruneStatusT(status); - if (length < -1) return STATUS_BAD_VALUE; + if (binder_status_t status = ReadAndValidateArraySize(parcel, &length); status != STATUS_OK) { + return status; + } if (!allocator(arrayData, length)) return STATUS_NO_MEMORY; diff --git a/libs/binder/ndk/tests/Android.bp b/libs/binder/ndk/tests/Android.bp index bb51bf0b5d..488009f812 100644 --- a/libs/binder/ndk/tests/Android.bp +++ b/libs/binder/ndk/tests/Android.bp @@ -73,7 +73,10 @@ cc_test { "IBinderNdkUnitTest-cpp", "IBinderNdkUnitTest-ndk_platform", ], - test_suites: ["general-tests", "vts"], + test_suites: [ + "general-tests", + "vts", + ], require_root: true, } @@ -95,7 +98,7 @@ cc_test { "libbinder_ndk", "libutils", ], - test_suites: ["general-tests", "vts"], + test_suites: ["general-tests"], require_root: true, } @@ -115,4 +118,12 @@ aidl_interface { "IBinderNdkUnitTest.aidl", "IEmpty.aidl", ], + backend: { + java: { + enabled: false, + }, + ndk: { + apps_enabled: false, + }, + }, } diff --git a/libs/binder/ndk/tests/IBinderNdkUnitTest.aidl b/libs/binder/ndk/tests/IBinderNdkUnitTest.aidl index ecbd6490e9..a626d39d91 100644 --- a/libs/binder/ndk/tests/IBinderNdkUnitTest.aidl +++ b/libs/binder/ndk/tests/IBinderNdkUnitTest.aidl @@ -21,6 +21,7 @@ import IEmpty; +@SensitiveData interface IBinderNdkUnitTest { int repeatInt(int a); diff --git a/libs/binder/rust/Android.bp b/libs/binder/rust/Android.bp index 49d3401a4f..8d27eedb57 100644 --- a/libs/binder/rust/Android.bp +++ b/libs/binder/rust/Android.bp @@ -26,6 +26,7 @@ rust_library { }, apex_available: [ "//apex_available:platform", + "com.android.compos", "com.android.virt", ], } @@ -48,6 +49,7 @@ rust_library { }, apex_available: [ "//apex_available:platform", + "com.android.compos", "com.android.virt", ], lints: "none", @@ -99,6 +101,22 @@ rust_bindgen { }, apex_available: [ "//apex_available:platform", + "com.android.compos", + "com.android.virt", + ], +} + +// TODO(b/184872979): remove once the Rust API is created. +rust_bindgen { + name: "libbinder_rpc_unstable_bindgen", + wrapper_src: "src/binder_rpc_unstable.hpp", + crate_name: "binder_rpc_unstable_bindgen", + source_stem: "bindings", + shared_libs: [ + "libutils", + ], + apex_available: [ + "com.android.compos", "com.android.virt", ], } diff --git a/libs/binder/rust/src/binder.rs b/libs/binder/rust/src/binder.rs index 695a83e414..2a09afc6dc 100644 --- a/libs/binder/rust/src/binder.rs +++ b/libs/binder/rust/src/binder.rs @@ -25,6 +25,7 @@ use std::borrow::Borrow; use std::cmp::Ordering; use std::ffi::{c_void, CStr, CString}; use std::fmt; +use std::fs::File; use std::marker::PhantomData; use std::ops::Deref; use std::os::raw::c_char; @@ -54,6 +55,14 @@ pub trait Interface: Send { fn as_binder(&self) -> SpIBinder { panic!("This object was not a Binder object and cannot be converted into an SpIBinder.") } + + /// Dump transaction handler for this Binder object. + /// + /// This handler is a no-op by default and should be implemented for each + /// Binder service struct that wishes to respond to dump transactions. + fn dump(&self, _file: &File, _args: &[&CStr]) -> Result<()> { + Ok(()) + } } /// Interface stability promise @@ -98,6 +107,10 @@ pub trait Remotable: Send + Sync { /// `reply` may be [`None`] if the sender does not expect a reply. fn on_transact(&self, code: TransactionCode, data: &Parcel, reply: &mut Parcel) -> Result<()>; + /// Handle a request to invoke the dump transaction on this + /// object. + fn on_dump(&self, file: &File, args: &[&CStr]) -> Result<()>; + /// Retrieve the class of this remote object. /// /// This method should always return the same InterfaceClass for the same @@ -218,7 +231,7 @@ impl InterfaceClass { if class.is_null() { panic!("Expected non-null class pointer from AIBinder_Class_define!"); } - sys::AIBinder_Class_setOnDump(class, None); + sys::AIBinder_Class_setOnDump(class, Some(I::on_dump)); sys::AIBinder_Class_setHandleShellCommand(class, None); class }; @@ -492,6 +505,16 @@ pub trait InterfaceClassMethods { /// returned by `on_create` for this class. This function takes ownership of /// the provided pointer and destroys it. unsafe extern "C" fn on_destroy(object: *mut c_void); + + /// Called to handle the `dump` transaction. + /// + /// # Safety + /// + /// Must be called with a non-null, valid pointer to a local `AIBinder` that + /// contains a `T` pointer in its user data. fd should be a non-owned file + /// descriptor, and args must be an array of null-terminated string + /// poiinters with length num_args. + unsafe extern "C" fn on_dump(binder: *mut sys::AIBinder, fd: i32, args: *mut *const c_char, num_args: u32) -> status_t; } /// Interface for transforming a generic SpIBinder into a specific remote @@ -778,6 +801,10 @@ macro_rules! declare_binder_interface { } } + fn on_dump(&self, file: &std::fs::File, args: &[&std::ffi::CStr]) -> $crate::Result<()> { + self.0.dump(file, args) + } + fn get_class() -> $crate::InterfaceClass { static CLASS_INIT: std::sync::Once = std::sync::Once::new(); static mut CLASS: Option<$crate::InterfaceClass> = None; diff --git a/libs/binder/rust/src/binder_rpc_unstable.hpp b/libs/binder/rust/src/binder_rpc_unstable.hpp new file mode 100644 index 0000000000..7932d0f29c --- /dev/null +++ b/libs/binder/rust/src/binder_rpc_unstable.hpp @@ -0,0 +1,26 @@ +/* + * Copyright (C) 2021 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#pragma once + +extern "C" { + +struct AIBinder; + +bool RunRpcServer(AIBinder* service, unsigned int port); +AIBinder* RpcClient(unsigned int cid, unsigned int port); + +} diff --git a/libs/binder/rust/src/lib.rs b/libs/binder/rust/src/lib.rs index 2694cba870..cb330a65e5 100644 --- a/libs/binder/rust/src/lib.rs +++ b/libs/binder/rust/src/lib.rs @@ -115,14 +115,21 @@ pub use error::{status_t, ExceptionCode, Result, Status, StatusCode}; pub use native::add_service; pub use native::Binder; pub use parcel::Parcel; -pub use proxy::{get_interface, get_service}; +pub use proxy::{get_interface, get_service, wait_for_interface, wait_for_service}; pub use proxy::{AssociateClass, DeathRecipient, Proxy, SpIBinder, WpIBinder}; pub use state::{ProcessState, ThreadState}; +/// Unstable, in-development API that only allowlisted clients are allowed to use. +pub mod unstable_api { + pub use crate::binder::AsNative; + pub use crate::proxy::unstable_api::new_spibinder; + pub use crate::sys::AIBinder; +} + /// The public API usable outside AIDL-generated interface crates. pub mod public_api { pub use super::parcel::ParcelFileDescriptor; - pub use super::{add_service, get_interface}; + pub use super::{add_service, get_interface, wait_for_interface}; pub use super::{ BinderFeatures, DeathRecipient, ExceptionCode, IBinder, Interface, ProcessState, SpIBinder, Status, StatusCode, Strong, ThreadState, Weak, WpIBinder, diff --git a/libs/binder/rust/src/native.rs b/libs/binder/rust/src/native.rs index 39201298c3..5e324b3f5b 100644 --- a/libs/binder/rust/src/native.rs +++ b/libs/binder/rust/src/native.rs @@ -21,9 +21,13 @@ use crate::proxy::SpIBinder; use crate::sys; use std::convert::TryFrom; -use std::ffi::{c_void, CString}; +use std::ffi::{c_void, CStr, CString}; +use std::fs::File; use std::mem::ManuallyDrop; use std::ops::Deref; +use std::os::raw::c_char; +use std::os::unix::io::FromRawFd; +use std::slice; /// Rust wrapper around Binder remotable objects. /// @@ -289,6 +293,37 @@ impl<T: Remotable> InterfaceClassMethods for Binder<T> { // object created by Box. args } + + /// Called to handle the `dump` transaction. + /// + /// # Safety + /// + /// Must be called with a non-null, valid pointer to a local `AIBinder` that + /// contains a `T` pointer in its user data. fd should be a non-owned file + /// descriptor, and args must be an array of null-terminated string + /// poiinters with length num_args. + unsafe extern "C" fn on_dump(binder: *mut sys::AIBinder, fd: i32, args: *mut *const c_char, num_args: u32) -> status_t { + if fd < 0 { + return StatusCode::UNEXPECTED_NULL as status_t; + } + // We don't own this file, so we need to be careful not to drop it. + let file = ManuallyDrop::new(File::from_raw_fd(fd)); + + if args.is_null() { + return StatusCode::UNEXPECTED_NULL as status_t; + } + let args = slice::from_raw_parts(args, num_args as usize); + let args: Vec<_> = args.iter().map(|s| CStr::from_ptr(*s)).collect(); + + let object = sys::AIBinder_getUserData(binder); + let binder: &T = &*(object as *const T); + let res = binder.on_dump(&file, &args); + + match res { + Ok(()) => 0, + Err(e) => e as status_t, + } + } } impl<T: Remotable> Drop for Binder<T> { @@ -409,6 +444,10 @@ impl Remotable for () { Ok(()) } + fn on_dump(&self, _file: &File, _args: &[&CStr]) -> Result<()> { + Ok(()) + } + binder_fn_get_class!(Binder::<Self>); } diff --git a/libs/binder/rust/src/parcel.rs b/libs/binder/rust/src/parcel.rs index 6c34824a5e..a3f7620474 100644 --- a/libs/binder/rust/src/parcel.rs +++ b/libs/binder/rust/src/parcel.rs @@ -184,11 +184,17 @@ impl Parcel { } } + /// Returns the total size of the parcel. + pub fn get_data_size(&self) -> i32 { + unsafe { + // Safety: `Parcel` always contains a valid pointer to an `AParcel`, + // and this call is otherwise safe. + sys::AParcel_getDataSize(self.as_native()) + } + } + /// Move the current read/write position in the parcel. /// - /// The new position must be a position previously returned by - /// `self.get_data_position()`. - /// /// # Safety /// /// This method is safe if `pos` is less than the current size of the parcel @@ -219,6 +225,72 @@ impl Parcel { D::deserialize(self) } + /// Attempt to read a type that implements [`Deserialize`] from this + /// `Parcel` onto an existing value. This operation will overwrite the old + /// value partially or completely, depending on how much data is available. + pub fn read_onto<D: Deserialize>(&self, x: &mut D) -> Result<()> { + x.deserialize_from(self) + } + + /// Safely read a sized parcelable. + /// + /// Read the size of a parcelable, compute the end position + /// of that parcelable, then build a sized readable sub-parcel + /// and call a closure with the sub-parcel as its parameter. + /// The closure can keep reading data from the sub-parcel + /// until it runs out of input data. The closure is responsible + /// for calling [`ReadableSubParcel::has_more_data`] to check for + /// more data before every read, at least until Rust generators + /// are stabilized. + /// After the closure returns, skip to the end of the current + /// parcelable regardless of how much the closure has read. + /// + /// # Examples + /// + /// ```no_run + /// let mut parcelable = Default::default(); + /// parcel.sized_read(|subparcel| { + /// if subparcel.has_more_data() { + /// parcelable.a = subparcel.read()?; + /// } + /// if subparcel.has_more_data() { + /// parcelable.b = subparcel.read()?; + /// } + /// Ok(()) + /// }); + /// ``` + /// + pub fn sized_read<F>(&self, mut f: F) -> Result<()> + where + for<'a> F: FnMut(ReadableSubParcel<'a>) -> Result<()> + { + let start = self.get_data_position(); + let parcelable_size: i32 = self.read()?; + if parcelable_size < 0 { + return Err(StatusCode::BAD_VALUE); + } + + let end = start.checked_add(parcelable_size) + .ok_or(StatusCode::BAD_VALUE)?; + if end > self.get_data_size() { + return Err(StatusCode::NOT_ENOUGH_DATA); + } + + let subparcel = ReadableSubParcel { + parcel: self, + end_position: end, + }; + f(subparcel)?; + + // Advance the data position to the actual end, + // in case the closure read less data than was available + unsafe { + self.set_data_position(end)?; + } + + Ok(()) + } + /// Read a vector size from the `Parcel` and resize the given output vector /// to be correctly sized for that amount of data. /// @@ -264,6 +336,27 @@ impl Parcel { } } +/// A segment of a readable parcel, used for [`Parcel::sized_read`]. +pub struct ReadableSubParcel<'a> { + parcel: &'a Parcel, + end_position: i32, +} + +impl<'a> ReadableSubParcel<'a> { + /// Read a type that implements [`Deserialize`] from the sub-parcel. + pub fn read<D: Deserialize>(&self) -> Result<D> { + // The caller should have checked this, + // but it can't hurt to double-check + assert!(self.has_more_data()); + D::deserialize(self.parcel) + } + + /// Check if the sub-parcel has more data to read + pub fn has_more_data(&self) -> bool { + self.parcel.get_data_position() < self.end_position + } +} + // Internal APIs impl Parcel { pub(crate) fn write_binder(&mut self, binder: Option<&SpIBinder>) -> Result<()> { diff --git a/libs/binder/rust/src/parcel/parcelable.rs b/libs/binder/rust/src/parcel/parcelable.rs index f57788b87e..956ecfe998 100644 --- a/libs/binder/rust/src/parcel/parcelable.rs +++ b/libs/binder/rust/src/parcel/parcelable.rs @@ -39,6 +39,14 @@ pub trait Serialize { pub trait Deserialize: Sized { /// Deserialize an instance from the given [`Parcel`]. fn deserialize(parcel: &Parcel) -> Result<Self>; + + /// Deserialize an instance from the given [`Parcel`] onto the + /// current object. This operation will overwrite the old value + /// partially or completely, depending on how much data is available. + fn deserialize_from(&mut self, parcel: &Parcel) -> Result<()> { + *self = Self::deserialize(parcel)?; + Ok(()) + } } /// Helper trait for types that can be serialized as arrays. @@ -184,6 +192,14 @@ pub trait DeserializeOption: Deserialize { parcel.read().map(Some) } } + + /// Deserialize an Option of this type from the given [`Parcel`] onto the + /// current object. This operation will overwrite the current value + /// partially or completely, depending on how much data is available. + fn deserialize_option_from(this: &mut Option<Self>, parcel: &Parcel) -> Result<()> { + *this = Self::deserialize_option(parcel)?; + Ok(()) + } } /// Callback to allocate a vector for parcel array read functions. @@ -677,6 +693,75 @@ impl<T: DeserializeOption> Deserialize for Option<T> { fn deserialize(parcel: &Parcel) -> Result<Self> { DeserializeOption::deserialize_option(parcel) } + + fn deserialize_from(&mut self, parcel: &Parcel) -> Result<()> { + DeserializeOption::deserialize_option_from(self, parcel) + } +} + +/// Implement `Deserialize` trait and friends for a parcelable +/// +/// This is an internal macro used by the AIDL compiler to implement +/// `Deserialize`, `DeserializeArray` and `DeserializeOption` for +/// structured parcelables. The target type must implement a +/// `deserialize_parcelable` method with the following signature: +/// ```no_run +/// fn deserialize_parcelable( +/// &mut self, +/// parcel: &binder::parcel::Parcelable, +/// ) -> binder::Result<()> { +/// // ... +/// } +/// ``` +#[macro_export] +macro_rules! impl_deserialize_for_parcelable { + ($parcelable:ident) => { + impl $crate::parcel::Deserialize for $parcelable { + fn deserialize( + parcel: &$crate::parcel::Parcel, + ) -> $crate::Result<Self> { + $crate::parcel::DeserializeOption::deserialize_option(parcel) + .transpose() + .unwrap_or(Err($crate::StatusCode::UNEXPECTED_NULL)) + } + fn deserialize_from( + &mut self, + parcel: &$crate::parcel::Parcel, + ) -> $crate::Result<()> { + let status: i32 = parcel.read()?; + if status == 0 { + Err($crate::StatusCode::UNEXPECTED_NULL) + } else { + self.deserialize_parcelable(parcel) + } + } + } + + impl $crate::parcel::DeserializeArray for $parcelable {} + + impl $crate::parcel::DeserializeOption for $parcelable { + fn deserialize_option( + parcel: &$crate::parcel::Parcel, + ) -> $crate::Result<Option<Self>> { + let mut result = None; + Self::deserialize_option_from(&mut result, parcel)?; + Ok(result) + } + fn deserialize_option_from( + this: &mut Option<Self>, + parcel: &$crate::parcel::Parcel, + ) -> $crate::Result<()> { + let status: i32 = parcel.read()?; + if status == 0 { + *this = None; + Ok(()) + } else { + this.get_or_insert_with(Self::default) + .deserialize_parcelable(parcel) + } + } + } + } } #[test] diff --git a/libs/binder/rust/src/proxy.rs b/libs/binder/rust/src/proxy.rs index 52036f5312..e299963c9d 100644 --- a/libs/binder/rust/src/proxy.rs +++ b/libs/binder/rust/src/proxy.rs @@ -125,6 +125,21 @@ impl SpIBinder { } } +pub mod unstable_api { + use super::{sys, SpIBinder}; + + /// A temporary API to allow the client to create a `SpIBinder` from a `sys::AIBinder`. This is + /// needed to bridge RPC binder, which doesn't have Rust API yet. + /// TODO(b/184872979): remove once the Rust API is created. + /// + /// # Safety + /// + /// See `SpIBinder::from_raw`. + pub unsafe fn new_spibinder(ptr: *mut sys::AIBinder) -> Option<SpIBinder> { + SpIBinder::from_raw(ptr) + } +} + /// An object that can be associate with an [`InterfaceClass`]. pub trait AssociateClass { /// Check if this object is a valid object for the given interface class @@ -653,6 +668,18 @@ pub fn get_service(name: &str) -> Option<SpIBinder> { } } +/// Retrieve an existing service, or start it if it is configured as a dynamic +/// service and isn't yet started. +pub fn wait_for_service(name: &str) -> Option<SpIBinder> { + let name = CString::new(name).ok()?; + unsafe { + // Safety: `AServiceManager_waitforService` returns either a null + // pointer or a valid pointer to an owned `AIBinder`. Either of these + // values is safe to pass to `SpIBinder::from_raw`. + SpIBinder::from_raw(sys::AServiceManager_waitForService(name.as_ptr())) + } +} + /// Retrieve an existing service for a particular interface, blocking for a few /// seconds if it doesn't yet exist. pub fn get_interface<T: FromIBinder + ?Sized>(name: &str) -> Result<Strong<T>> { @@ -663,6 +690,16 @@ pub fn get_interface<T: FromIBinder + ?Sized>(name: &str) -> Result<Strong<T>> { } } +/// Retrieve an existing service for a particular interface, or start it if it +/// is configured as a dynamic service and isn't yet started. +pub fn wait_for_interface<T: FromIBinder + ?Sized>(name: &str) -> Result<Strong<T>> { + let service = wait_for_service(name); + match service { + Some(service) => FromIBinder::try_from(service), + None => Err(StatusCode::NAME_NOT_FOUND), + } +} + /// # Safety /// /// `SpIBinder` guarantees that `binder` always contains a valid pointer to an diff --git a/libs/binder/rust/tests/integration.rs b/libs/binder/rust/tests/integration.rs index 03320076cb..da8907decb 100644 --- a/libs/binder/rust/tests/integration.rs +++ b/libs/binder/rust/tests/integration.rs @@ -23,6 +23,9 @@ use binder::{ FIRST_CALL_TRANSACTION, }; use std::convert::{TryFrom, TryInto}; +use std::ffi::CStr; +use std::fs::File; +use std::sync::Mutex; /// Name of service runner. /// @@ -50,13 +53,11 @@ fn main() -> Result<(), &'static str> { let extension_name = args.next(); { - let mut service = Binder::new(BnTest(Box::new(TestService { - s: service_name.clone(), - }))); + let mut service = Binder::new(BnTest(Box::new(TestService::new(&service_name)))); service.set_requesting_sid(true); if let Some(extension_name) = extension_name { let extension = - BnTest::new_binder(TestService { s: extension_name }, BinderFeatures::default()); + BnTest::new_binder(TestService::new(&extension_name), BinderFeatures::default()); service .set_extension(&mut extension.as_binder()) .expect("Could not add extension"); @@ -80,14 +81,24 @@ fn print_usage() { )); } -#[derive(Clone)] struct TestService { s: String, + dump_args: Mutex<Vec<String>>, +} + +impl TestService { + fn new(s: &str) -> Self { + Self { + s: s.to_string(), + dump_args: Mutex::new(Vec::new()), + } + } } #[repr(u32)] enum TestTransactionCode { Test = FIRST_CALL_TRANSACTION, + GetDumpArgs, GetSelinuxContext, } @@ -97,6 +108,7 @@ impl TryFrom<u32> for TestTransactionCode { fn try_from(c: u32) -> Result<Self, Self::Error> { match c { _ if c == TestTransactionCode::Test as u32 => Ok(TestTransactionCode::Test), + _ if c == TestTransactionCode::GetDumpArgs as u32 => Ok(TestTransactionCode::GetDumpArgs), _ if c == TestTransactionCode::GetSelinuxContext as u32 => { Ok(TestTransactionCode::GetSelinuxContext) } @@ -105,13 +117,24 @@ impl TryFrom<u32> for TestTransactionCode { } } -impl Interface for TestService {} +impl Interface for TestService { + fn dump(&self, _file: &File, args: &[&CStr]) -> binder::Result<()> { + let mut dump_args = self.dump_args.lock().unwrap(); + dump_args.extend(args.iter().map(|s| s.to_str().unwrap().to_owned())); + Ok(()) + } +} impl ITest for TestService { fn test(&self) -> binder::Result<String> { Ok(self.s.clone()) } + fn get_dump_args(&self) -> binder::Result<Vec<String>> { + let args = self.dump_args.lock().unwrap().clone(); + Ok(args) + } + fn get_selinux_context(&self) -> binder::Result<String> { let sid = ThreadState::with_calling_sid(|sid| sid.map(|s| s.to_string_lossy().into_owned())); @@ -124,6 +147,9 @@ pub trait ITest: Interface { /// Returns a test string fn test(&self) -> binder::Result<String>; + /// Return the arguments sent via dump + fn get_dump_args(&self) -> binder::Result<Vec<String>>; + /// Returns the caller's SELinux context fn get_selinux_context(&self) -> binder::Result<String>; } @@ -145,6 +171,7 @@ fn on_transact( ) -> binder::Result<()> { match code.try_into()? { TestTransactionCode::Test => reply.write(&service.test()?), + TestTransactionCode::GetDumpArgs => reply.write(&service.get_dump_args()?), TestTransactionCode::GetSelinuxContext => reply.write(&service.get_selinux_context()?), } } @@ -157,6 +184,13 @@ impl ITest for BpTest { reply.read() } + fn get_dump_args(&self) -> binder::Result<Vec<String>> { + let reply = + self.binder + .transact(TestTransactionCode::GetDumpArgs as TransactionCode, 0, |_| Ok(()))?; + reply.read() + } + fn get_selinux_context(&self) -> binder::Result<String> { let reply = self.binder.transact( TestTransactionCode::GetSelinuxContext as TransactionCode, @@ -172,6 +206,10 @@ impl ITest for Binder<BnTest> { self.0.test() } + fn get_dump_args(&self) -> binder::Result<Vec<String>> { + self.0.get_dump_args() + } + fn get_selinux_context(&self) -> binder::Result<String> { self.0.get_selinux_context() } @@ -274,6 +312,20 @@ mod tests { } #[test] + fn check_wait_for_service() { + let mut sm = + binder::wait_for_service("manager").expect("Did not get manager binder service"); + assert!(sm.is_binder_alive()); + assert!(sm.ping_binder().is_ok()); + + // The service manager service isn't an ITest, so this must fail. + assert_eq!( + binder::wait_for_interface::<dyn ITest>("manager").err(), + Some(StatusCode::BAD_TYPE) + ); + } + + #[test] fn trivial_client() { let service_name = "trivial_client_test"; let _process = ScopedServiceProcess::new(service_name); @@ -283,6 +335,15 @@ mod tests { } #[test] + fn wait_for_trivial_client() { + let service_name = "wait_for_trivial_client_test"; + let _process = ScopedServiceProcess::new(service_name); + let test_client: Strong<dyn ITest> = + binder::wait_for_interface(service_name).expect("Did not get manager binder service"); + assert_eq!(test_client.test().unwrap(), "wait_for_trivial_client_test"); + } + + #[test] fn get_selinux_context() { let service_name = "get_selinux_context"; let _process = ScopedServiceProcess::new(service_name); @@ -409,18 +470,22 @@ mod tests { { let _process = ScopedServiceProcess::new(service_name); - let mut remote = binder::get_service(service_name); + let test_client: Strong<dyn ITest> = + binder::get_interface(service_name) + .expect("Did not get test binder service"); + let mut remote = test_client.as_binder(); assert!(remote.is_binder_alive()); remote.ping_binder().expect("Could not ping remote service"); - // We're not testing the output of dump here, as that's really a - // property of the C++ implementation. There is the risk that the - // method just does nothing, but we don't want to depend on any - // particular output from the underlying library. + let dump_args = ["dump", "args", "for", "testing"]; + let null_out = File::open("/dev/null").expect("Could not open /dev/null"); remote - .dump(&null_out, &[]) + .dump(&null_out, &dump_args) .expect("Could not dump remote service"); + + let remote_args = test_client.get_dump_args().expect("Could not fetched dumped args"); + assert_eq!(dump_args, remote_args[..], "Remote args don't match call to dump"); } // get/set_extensions is tested in test_extensions() @@ -481,9 +546,7 @@ mod tests { /// rust_ndk_interop.rs #[test] fn associate_existing_class() { - let service = Binder::new(BnTest(Box::new(TestService { - s: "testing_service".to_string(), - }))); + let service = Binder::new(BnTest(Box::new(TestService::new("testing_service")))); // This should succeed although we will have to treat the service as // remote. @@ -497,9 +560,7 @@ mod tests { fn reassociate_rust_binder() { let service_name = "testing_service"; let service_ibinder = BnTest::new_binder( - TestService { - s: service_name.to_string(), - }, + TestService::new(service_name), BinderFeatures::default(), ) .as_binder(); @@ -515,9 +576,7 @@ mod tests { fn weak_binder_upgrade() { let service_name = "testing_service"; let service = BnTest::new_binder( - TestService { - s: service_name.to_string(), - }, + TestService::new(service_name), BinderFeatures::default(), ); @@ -533,9 +592,7 @@ mod tests { let service_name = "testing_service"; let weak = { let service = BnTest::new_binder( - TestService { - s: service_name.to_string(), - }, + TestService::new(service_name), BinderFeatures::default(), ); @@ -549,9 +606,7 @@ mod tests { fn weak_binder_clone() { let service_name = "testing_service"; let service = BnTest::new_binder( - TestService { - s: service_name.to_string(), - }, + TestService::new(service_name), BinderFeatures::default(), ); @@ -570,15 +625,11 @@ mod tests { #[allow(clippy::eq_op)] fn binder_ord() { let service1 = BnTest::new_binder( - TestService { - s: "testing_service1".to_string(), - }, + TestService::new("testing_service1"), BinderFeatures::default(), ); let service2 = BnTest::new_binder( - TestService { - s: "testing_service2".to_string(), - }, + TestService::new("testing_service2"), BinderFeatures::default(), ); diff --git a/libs/binder/servicedispatcher.cpp b/libs/binder/servicedispatcher.cpp new file mode 100644 index 0000000000..62df9b7f2f --- /dev/null +++ b/libs/binder/servicedispatcher.cpp @@ -0,0 +1,261 @@ +/* + * Copyright (C) 2021 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include <sysexits.h> +#include <unistd.h> + +#include <iostream> + +#include <android-base/file.h> +#include <android-base/logging.h> +#include <android-base/properties.h> +#include <android-base/stringprintf.h> +#include <android/os/BnServiceManager.h> +#include <android/os/IServiceManager.h> +#include <binder/IServiceManager.h> +#include <binder/RpcServer.h> + +using android::BBinder; +using android::defaultServiceManager; +using android::OK; +using android::RpcServer; +using android::sp; +using android::statusToString; +using android::String16; +using android::base::Basename; +using android::base::GetBoolProperty; +using android::base::InitLogging; +using android::base::LogdLogger; +using android::base::LogId; +using android::base::LogSeverity; +using android::base::StdioLogger; +using android::base::StringPrintf; +using std::string_view_literals::operator""sv; + +namespace { + +using ServiceRetriever = decltype(&android::IServiceManager::checkService); + +int Usage(const char* program) { + auto basename = Basename(program); + auto format = R"(dispatch calls to RPC service. +Usage: + %s [-g] <service_name> + <service_name>: the service to connect to. + %s [-g] manager + Runs an RPC-friendly service that redirects calls to servicemanager. + + -g: use getService() instead of checkService(). + + If successful, writes port number and a new line character to stdout, and + blocks until killed. + Otherwise, writes error message to stderr and exits with non-zero code. +)"; + LOG(ERROR) << StringPrintf(format, basename.c_str(), basename.c_str()); + return EX_USAGE; +} + +int Dispatch(const char* name, const ServiceRetriever& serviceRetriever) { + auto sm = defaultServiceManager(); + if (nullptr == sm) { + LOG(ERROR) << "No servicemanager"; + return EX_SOFTWARE; + } + auto binder = std::invoke(serviceRetriever, defaultServiceManager(), String16(name)); + if (nullptr == binder) { + LOG(ERROR) << "No service \"" << name << "\""; + return EX_SOFTWARE; + } + auto rpcServer = RpcServer::make(); + if (nullptr == rpcServer) { + LOG(ERROR) << "Cannot create RpcServer"; + return EX_SOFTWARE; + } + rpcServer->iUnderstandThisCodeIsExperimentalAndIWillNotUseItInProduction(); + unsigned int port; + if (!rpcServer->setupInetServer(0, &port)) { + LOG(ERROR) << "setupInetServer failed"; + return EX_SOFTWARE; + } + auto socket = rpcServer->releaseServer(); + auto keepAliveBinder = sp<BBinder>::make(); + auto status = binder->setRpcClientDebug(std::move(socket), keepAliveBinder); + if (status != OK) { + LOG(ERROR) << "setRpcClientDebug failed with " << statusToString(status); + return EX_SOFTWARE; + } + LOG(INFO) << "Finish setting up RPC on service " << name << " on port " << port; + + std::cout << port << std::endl; + + TEMP_FAILURE_RETRY(pause()); + + PLOG(FATAL) << "TEMP_FAILURE_RETRY(pause()) exits; this should not happen!"; + __builtin_unreachable(); +} + +// Wrapper that wraps a BpServiceManager as a BnServiceManager. +class ServiceManagerProxyToNative : public android::os::BnServiceManager { +public: + ServiceManagerProxyToNative(const sp<android::os::IServiceManager>& impl) : mImpl(impl) {} + android::binder::Status getService(const std::string&, + android::sp<android::IBinder>*) override { + // We can't send BpBinder for regular binder over RPC. + return android::binder::Status::fromStatusT(android::INVALID_OPERATION); + } + android::binder::Status checkService(const std::string&, + android::sp<android::IBinder>*) override { + // We can't send BpBinder for regular binder over RPC. + return android::binder::Status::fromStatusT(android::INVALID_OPERATION); + } + android::binder::Status addService(const std::string&, const android::sp<android::IBinder>&, + bool, int32_t) override { + // We can't send BpBinder for RPC over regular binder. + return android::binder::Status::fromStatusT(android::INVALID_OPERATION); + } + android::binder::Status listServices(int32_t dumpPriority, + std::vector<std::string>* _aidl_return) override { + return mImpl->listServices(dumpPriority, _aidl_return); + } + android::binder::Status registerForNotifications( + const std::string&, const android::sp<android::os::IServiceCallback>&) override { + // We can't send BpBinder for RPC over regular binder. + return android::binder::Status::fromStatusT(android::INVALID_OPERATION); + } + android::binder::Status unregisterForNotifications( + const std::string&, const android::sp<android::os::IServiceCallback>&) override { + // We can't send BpBinder for RPC over regular binder. + return android::binder::Status::fromStatusT(android::INVALID_OPERATION); + } + android::binder::Status isDeclared(const std::string& name, bool* _aidl_return) override { + return mImpl->isDeclared(name, _aidl_return); + } + android::binder::Status getDeclaredInstances(const std::string& iface, + std::vector<std::string>* _aidl_return) override { + return mImpl->getDeclaredInstances(iface, _aidl_return); + } + android::binder::Status updatableViaApex(const std::string& name, + std::optional<std::string>* _aidl_return) override { + return mImpl->updatableViaApex(name, _aidl_return); + } + android::binder::Status registerClientCallback( + const std::string&, const android::sp<android::IBinder>&, + const android::sp<android::os::IClientCallback>&) override { + // We can't send BpBinder for RPC over regular binder. + return android::binder::Status::fromStatusT(android::INVALID_OPERATION); + } + android::binder::Status tryUnregisterService(const std::string&, + const android::sp<android::IBinder>&) override { + // We can't send BpBinder for RPC over regular binder. + return android::binder::Status::fromStatusT(android::INVALID_OPERATION); + } + android::binder::Status getServiceDebugInfo( + std::vector<android::os::ServiceDebugInfo>* _aidl_return) override { + return mImpl->getServiceDebugInfo(_aidl_return); + } + +private: + sp<android::os::IServiceManager> mImpl; +}; + +// Workaround for b/191059588. +// TODO(b/191059588): Once we can run RpcServer on single-threaded services, +// `servicedispatcher manager` should call Dispatch("manager") directly. +int wrapServiceManager(const ServiceRetriever& serviceRetriever) { + auto sm = defaultServiceManager(); + if (nullptr == sm) { + LOG(ERROR) << "No servicemanager"; + return EX_SOFTWARE; + } + auto service = std::invoke(serviceRetriever, defaultServiceManager(), String16("manager")); + if (nullptr == service) { + LOG(ERROR) << "No service called `manager`"; + return EX_SOFTWARE; + } + auto interface = android::os::IServiceManager::asInterface(service); + if (nullptr == interface) { + LOG(ERROR) << "Cannot cast service called `manager` to IServiceManager"; + return EX_SOFTWARE; + } + + // Work around restriction that doesn't allow us to send proxy over RPC. + interface = sp<ServiceManagerProxyToNative>::make(interface); + service = ServiceManagerProxyToNative::asBinder(interface); + + auto rpcServer = RpcServer::make(); + rpcServer->iUnderstandThisCodeIsExperimentalAndIWillNotUseItInProduction(); + rpcServer->setRootObject(service); + unsigned int port; + if (!rpcServer->setupInetServer(0, &port)) { + LOG(ERROR) << "Unable to set up inet server"; + return EX_SOFTWARE; + } + LOG(INFO) << "Finish wrapping servicemanager with RPC on port " << port; + std::cout << port << std::endl; + rpcServer->join(); + + LOG(FATAL) << "Wrapped servicemanager exits; this should not happen!"; + __builtin_unreachable(); +} + +// Log to logd. For warning and more severe messages, also log to stderr. +class ServiceDispatcherLogger { +public: + void operator()(LogId id, LogSeverity severity, const char* tag, const char* file, + unsigned int line, const char* message) { + mLogdLogger(id, severity, tag, file, line, message); + if (severity >= LogSeverity::WARNING) { + std::cout << std::flush; + std::cerr << Basename(getprogname()) << ": " << message << std::endl; + } + } + +private: + LogdLogger mLogdLogger{}; +}; + +} // namespace + +int main(int argc, char* argv[]) { + InitLogging(argv, ServiceDispatcherLogger()); + + if (!GetBoolProperty("ro.debuggable", false)) { + LOG(ERROR) << "servicedispatcher is only allowed on debuggable builds."; + return EX_NOPERM; + } + LOG(WARNING) << "WARNING: servicedispatcher is debug only. Use with caution."; + + int opt; + ServiceRetriever serviceRetriever = &android::IServiceManager::checkService; + while (-1 != (opt = getopt(argc, argv, "g"))) { + switch (opt) { + case 'g': { + serviceRetriever = &android::IServiceManager::getService; + } break; + default: { + return Usage(argv[0]); + } + } + } + + if (optind + 1 != argc) return Usage(argv[0]); + auto name = argv[optind]; + + if (name == "manager"sv) { + return wrapServiceManager(serviceRetriever); + } + return Dispatch(name, serviceRetriever); +} diff --git a/libs/binder/tests/Android.bp b/libs/binder/tests/Android.bp index fb84f04fde..326d9fd58f 100644 --- a/libs/binder/tests/Android.bp +++ b/libs/binder/tests/Android.bp @@ -60,7 +60,9 @@ cc_test { defaults: ["binder_test_defaults"], srcs: ["binderLibTest.cpp"], shared_libs: [ + "libbase", "libbinder", + "liblog", "libutils", ], static_libs: [ @@ -101,7 +103,9 @@ cc_test { srcs: ["binderLibTest.cpp"], shared_libs: [ + "libbase", "libbinder", + "liblog", "libutils", ], static_libs: [ @@ -116,6 +120,7 @@ aidl_interface { host_supported: true, unstable: true, srcs: [ + "IBinderRpcCallback.aidl", "IBinderRpcSession.aidl", "IBinderRpcTest.aidl", ], @@ -133,6 +138,9 @@ cc_test { darwin: { enabled: false, }, + android: { + test_suites: ["vts"], + }, }, defaults: [ "binder_test_defaults", @@ -156,10 +164,6 @@ cc_test { ], test_suites: ["general-tests"], require_root: true, - // Prevent the unit test target from running on sc-dev as it's not ready. - test_options: { - unit_test: false, - }, } cc_benchmark { diff --git a/libs/ui/Size.cpp b/libs/binder/tests/IBinderRpcCallback.aidl index d2996d164d..03369612f1 100644 --- a/libs/ui/Size.cpp +++ b/libs/binder/tests/IBinderRpcCallback.aidl @@ -1,5 +1,5 @@ /* - * Copyright 2019 The Android Open Source Project + * Copyright (C) 2021 The Android Open Source Project * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -14,11 +14,7 @@ * limitations under the License. */ -#include <ui/Size.h> - -namespace android::ui { - -const Size Size::INVALID{-1, -1}; -const Size Size::EMPTY{0, 0}; - -} // namespace android::ui +interface IBinderRpcCallback { + void sendCallback(@utf8InCpp String str); + oneway void sendOnewayCallback(@utf8InCpp String str); +} diff --git a/libs/binder/tests/IBinderRpcTest.aidl b/libs/binder/tests/IBinderRpcTest.aidl index ef4198d8f2..9e1078870c 100644 --- a/libs/binder/tests/IBinderRpcTest.aidl +++ b/libs/binder/tests/IBinderRpcTest.aidl @@ -54,5 +54,11 @@ interface IBinderRpcTest { void sleepMs(int ms); oneway void sleepMsAsync(int ms); + void doCallback(IBinderRpcCallback callback, boolean isOneway, boolean delayed, @utf8InCpp String value); + oneway void doCallbackAsync(IBinderRpcCallback callback, boolean isOneway, boolean delayed, @utf8InCpp String value); + void die(boolean cleanup); + void scheduleShutdown(); + + void useKernelBinderCallingId(); } diff --git a/libs/binder/tests/binderLibTest.cpp b/libs/binder/tests/binderLibTest.cpp index 5612d1db66..4c3225f302 100644 --- a/libs/binder/tests/binderLibTest.cpp +++ b/libs/binder/tests/binderLibTest.cpp @@ -15,25 +15,36 @@ */ #include <errno.h> -#include <fcntl.h> -#include <fstream> #include <poll.h> #include <pthread.h> #include <stdio.h> #include <stdlib.h> + +#include <chrono> +#include <fstream> #include <thread> #include <gmock/gmock.h> #include <gtest/gtest.h> +#include <android-base/properties.h> +#include <android-base/result-gmock.h> +#include <android-base/result.h> +#include <android-base/strings.h> +#include <android-base/unique_fd.h> #include <binder/Binder.h> +#include <binder/BpBinder.h> #include <binder/IBinder.h> #include <binder/IPCThreadState.h> #include <binder/IServiceManager.h> +#include <binder/RpcServer.h> +#include <binder/RpcSession.h> #include <linux/sched.h> #include <sys/epoll.h> #include <sys/prctl.h> +#include <sys/socket.h> +#include <sys/un.h> #include "../binder_module.h" #include "binderAbiHelper.h" @@ -41,7 +52,13 @@ #define ARRAY_SIZE(array) (sizeof array / sizeof array[0]) using namespace android; +using namespace std::string_literals; +using namespace std::chrono_literals; +using android::base::testing::HasValue; +using android::base::testing::Ok; +using testing::ExplainMatchResult; using testing::Not; +using testing::WithParamInterface; // e.g. EXPECT_THAT(expr, StatusEq(OK)) << "additional message"; MATCHER_P(StatusEq, expected, (negation ? "not " : "") + statusToString(expected)) { @@ -72,6 +89,7 @@ enum BinderLibTestTranscationCode { BINDER_LIB_TEST_REGISTER_SERVER, BINDER_LIB_TEST_ADD_SERVER, BINDER_LIB_TEST_ADD_POLL_SERVER, + BINDER_LIB_TEST_USE_CALLING_GUARD_TRANSACTION, BINDER_LIB_TEST_CALL_BACK, BINDER_LIB_TEST_CALL_BACK_VERIFY_BUF, BINDER_LIB_TEST_DELAYED_CALL_BACK, @@ -156,6 +174,20 @@ pid_t start_server_process(int arg2, bool usePoll = false) return pid; } +android::base::Result<int32_t> GetId(sp<IBinder> service) { + using android::base::Error; + Parcel data, reply; + data.markForBinder(service); + const char *prefix = data.isForRpc() ? "On RPC server, " : "On binder server, "; + status_t status = service->transact(BINDER_LIB_TEST_GET_ID_TRANSACTION, data, &reply); + if (status != OK) + return Error(status) << prefix << "transact(GET_ID): " << statusToString(status); + int32_t result = 0; + status = reply.readInt32(&result); + if (status != OK) return Error(status) << prefix << "readInt32: " << statusToString(status); + return result; +} + class BinderLibTestEnv : public ::testing::Environment { public: BinderLibTestEnv() {} @@ -404,6 +436,14 @@ class TestDeathRecipient : public IBinder::DeathRecipient, public BinderLibTestE }; }; +TEST_F(BinderLibTest, WasParceled) { + auto binder = sp<BBinder>::make(); + EXPECT_FALSE(binder->wasParceled()); + Parcel data; + data.writeStrongBinder(binder); + EXPECT_TRUE(binder->wasParceled()); +} + TEST_F(BinderLibTest, NopTransaction) { Parcel data, reply; EXPECT_THAT(m_server->transact(BINDER_LIB_TEST_NOP_TRANSACTION, data, &reply), @@ -475,12 +515,7 @@ TEST_F(BinderLibTest, SetError) { } TEST_F(BinderLibTest, GetId) { - int32_t id; - Parcel data, reply; - EXPECT_THAT(m_server->transact(BINDER_LIB_TEST_GET_ID_TRANSACTION, data, &reply), - StatusEq(NO_ERROR)); - EXPECT_THAT(reply.readInt32(&id), StatusEq(NO_ERROR)); - EXPECT_EQ(0, id); + EXPECT_THAT(GetId(m_server), HasValue(0)); } TEST_F(BinderLibTest, PtrSize) { @@ -603,6 +638,13 @@ TEST_F(BinderLibTest, CallBack) EXPECT_THAT(callBack->getResult(), StatusEq(NO_ERROR)); } +TEST_F(BinderLibTest, BinderCallContextGuard) { + sp<IBinder> binder = addServer(); + Parcel data, reply; + EXPECT_THAT(binder->transact(BINDER_LIB_TEST_USE_CALLING_GUARD_TRANSACTION, data, &reply), + StatusEq(DEAD_OBJECT)); +} + TEST_F(BinderLibTest, AddServer) { sp<IBinder> server = addServer(); @@ -1134,39 +1176,116 @@ TEST_F(BinderLibTest, GotSid) { EXPECT_THAT(server->transact(BINDER_LIB_TEST_CAN_GET_SID, data, nullptr), StatusEq(OK)); } -class BinderLibTestService : public BBinder -{ - public: - explicit BinderLibTestService(int32_t id) - : m_id(id) - , m_nextServerId(id + 1) - , m_serverStartRequested(false) - , m_callback(nullptr) - { - pthread_mutex_init(&m_serverWaitMutex, nullptr); - pthread_cond_init(&m_serverWaitCond, nullptr); +class BinderLibRpcTestBase : public BinderLibTest { +public: + void SetUp() override { + if (!base::GetBoolProperty("ro.debuggable", false)) { + GTEST_SKIP() << "Binder RPC is only enabled on debuggable builds, skipping test on " + "non-debuggable builds."; } - ~BinderLibTestService() - { - exit(EXIT_SUCCESS); + BinderLibTest::SetUp(); + } + + std::tuple<android::base::unique_fd, unsigned int> CreateSocket() { + auto rpcServer = RpcServer::make(); + EXPECT_NE(nullptr, rpcServer); + if (rpcServer == nullptr) return {}; + rpcServer->iUnderstandThisCodeIsExperimentalAndIWillNotUseItInProduction(); + unsigned int port; + if (!rpcServer->setupInetServer(0, &port)) { + ADD_FAILURE() << "setupInetServer failed"; + return {}; } + return {rpcServer->releaseServer(), port}; + } +}; - void processPendingCall() { - if (m_callback != nullptr) { - Parcel data; - data.writeInt32(NO_ERROR); - m_callback->transact(BINDER_LIB_TEST_CALL_BACK, data, nullptr, TF_ONE_WAY); - m_callback = nullptr; - } +class BinderLibRpcTest : public BinderLibRpcTestBase {}; + +TEST_F(BinderLibRpcTest, SetRpcClientDebug) { + auto binder = addServer(); + ASSERT_TRUE(binder != nullptr); + auto [socket, port] = CreateSocket(); + ASSERT_TRUE(socket.ok()); + EXPECT_THAT(binder->setRpcClientDebug(std::move(socket), sp<BBinder>::make()), StatusEq(OK)); +} + +// Tests for multiple RpcServer's on the same binder object. +TEST_F(BinderLibRpcTest, SetRpcClientDebugTwice) { + auto binder = addServer(); + ASSERT_TRUE(binder != nullptr); + + auto [socket1, port1] = CreateSocket(); + ASSERT_TRUE(socket1.ok()); + auto keepAliveBinder1 = sp<BBinder>::make(); + EXPECT_THAT(binder->setRpcClientDebug(std::move(socket1), keepAliveBinder1), StatusEq(OK)); + + auto [socket2, port2] = CreateSocket(); + ASSERT_TRUE(socket2.ok()); + auto keepAliveBinder2 = sp<BBinder>::make(); + EXPECT_THAT(binder->setRpcClientDebug(std::move(socket2), keepAliveBinder2), StatusEq(OK)); +} + +// Negative tests for RPC APIs on IBinder. Call should fail in the same way on both remote and +// local binders. +class BinderLibRpcTestP : public BinderLibRpcTestBase, public WithParamInterface<bool> { +public: + sp<IBinder> GetService() { + return GetParam() ? sp<IBinder>(addServer()) : sp<IBinder>(sp<BBinder>::make()); + } + static std::string ParamToString(const testing::TestParamInfo<ParamType> &info) { + return info.param ? "remote" : "local"; + } +}; + +TEST_P(BinderLibRpcTestP, SetRpcClientDebugNoFd) { + auto binder = GetService(); + ASSERT_TRUE(binder != nullptr); + EXPECT_THAT(binder->setRpcClientDebug(android::base::unique_fd(), sp<BBinder>::make()), + StatusEq(BAD_VALUE)); +} + +TEST_P(BinderLibRpcTestP, SetRpcClientDebugNoKeepAliveBinder) { + auto binder = GetService(); + ASSERT_TRUE(binder != nullptr); + auto [socket, port] = CreateSocket(); + ASSERT_TRUE(socket.ok()); + EXPECT_THAT(binder->setRpcClientDebug(std::move(socket), nullptr), StatusEq(UNEXPECTED_NULL)); +} +INSTANTIATE_TEST_CASE_P(BinderLibTest, BinderLibRpcTestP, testing::Bool(), + BinderLibRpcTestP::ParamToString); + +class BinderLibTestService : public BBinder { +public: + explicit BinderLibTestService(int32_t id, bool exitOnDestroy = true) + : m_id(id), + m_nextServerId(id + 1), + m_serverStartRequested(false), + m_callback(nullptr), + m_exitOnDestroy(exitOnDestroy) { + pthread_mutex_init(&m_serverWaitMutex, nullptr); + pthread_cond_init(&m_serverWaitCond, nullptr); + } + ~BinderLibTestService() { + if (m_exitOnDestroy) exit(EXIT_SUCCESS); + } + + void processPendingCall() { + if (m_callback != nullptr) { + Parcel data; + data.writeInt32(NO_ERROR); + m_callback->transact(BINDER_LIB_TEST_CALL_BACK, data, nullptr, TF_ONE_WAY); + m_callback = nullptr; } + } - virtual status_t onTransact(uint32_t code, - const Parcel& data, Parcel* reply, - uint32_t flags = 0) { - if (getuid() != (uid_t)IPCThreadState::self()->getCallingUid()) { - return PERMISSION_DENIED; - } - switch (code) { + virtual status_t onTransact(uint32_t code, const Parcel &data, Parcel *reply, + uint32_t flags = 0) { + // TODO(b/182914638): also checks getCallingUid() for RPC + if (!data.isForRpc() && getuid() != (uid_t)IPCThreadState::self()->getCallingUid()) { + return PERMISSION_DENIED; + } + switch (code) { case BINDER_LIB_TEST_REGISTER_SERVER: { int32_t id; sp<IBinder> binder; @@ -1176,8 +1295,7 @@ class BinderLibTestService : public BBinder return BAD_VALUE; } - if (m_id != 0) - return INVALID_OPERATION; + if (m_id != 0) return INVALID_OPERATION; pthread_mutex_lock(&m_serverWaitMutex); if (m_serverStartRequested) { @@ -1231,6 +1349,21 @@ class BinderLibTestService : public BBinder pthread_mutex_unlock(&m_serverWaitMutex); return ret; } + case BINDER_LIB_TEST_USE_CALLING_GUARD_TRANSACTION: { + IPCThreadState::SpGuard spGuard{ + .address = __builtin_frame_address(0), + .context = "GuardInBinderTransaction", + }; + const IPCThreadState::SpGuard *origGuard = + IPCThreadState::self()->pushGetCallingSpGuard(&spGuard); + + // if the guard works, this should abort + (void)IPCThreadState::self()->getCallingPid(); + + IPCThreadState::self()->restoreGetCallingSpGuard(origGuard); + return NO_ERROR; + } + case BINDER_LIB_TEST_GETPID: reply->writeInt32(getpid()); return NO_ERROR; @@ -1347,8 +1480,7 @@ class BinderLibTestService : public BBinder return BAD_VALUE; } ret = target->linkToDeath(testDeathRecipient); - if (ret == NO_ERROR) - ret = testDeathRecipient->waitEvent(5); + if (ret == NO_ERROR) ret = testDeathRecipient->waitEvent(5); data2.writeInt32(ret); callback->transact(BINDER_LIB_TEST_CALL_BACK, data2, &reply2); return NO_ERROR; @@ -1372,8 +1504,7 @@ class BinderLibTestService : public BBinder return BAD_VALUE; } ret = write(fd, buf, size); - if (ret != size) - return UNKNOWN_ERROR; + if (ret != size) return UNKNOWN_ERROR; return NO_ERROR; } case BINDER_LIB_TEST_WRITE_PARCEL_FILE_DESCRIPTOR_TRANSACTION: { @@ -1428,8 +1559,7 @@ class BinderLibTestService : public BBinder case BINDER_LIB_TEST_ECHO_VECTOR: { std::vector<uint64_t> vector; auto err = data.readUint64Vector(&vector); - if (err != NO_ERROR) - return err; + if (err != NO_ERROR) return err; reply->writeUint64Vector(vector); return NO_ERROR; } @@ -1441,23 +1571,33 @@ class BinderLibTestService : public BBinder } default: return UNKNOWN_TRANSACTION; - }; - } - private: - int32_t m_id; - int32_t m_nextServerId; - pthread_mutex_t m_serverWaitMutex; - pthread_cond_t m_serverWaitCond; - bool m_serverStartRequested; - sp<IBinder> m_serverStarted; - sp<IBinder> m_strongRef; - sp<IBinder> m_callback; + }; + } + +private: + int32_t m_id; + int32_t m_nextServerId; + pthread_mutex_t m_serverWaitMutex; + pthread_cond_t m_serverWaitCond; + bool m_serverStartRequested; + sp<IBinder> m_serverStarted; + sp<IBinder> m_strongRef; + sp<IBinder> m_callback; + bool m_exitOnDestroy; }; int run_server(int index, int readypipefd, bool usePoll) { binderLibTestServiceName += String16(binderserversuffix); + // Testing to make sure that calls that we are serving can use getCallin* + // even though we don't here. + IPCThreadState::SpGuard spGuard{ + .address = __builtin_frame_address(0), + .context = "main server thread", + }; + (void)IPCThreadState::self()->pushGetCallingSpGuard(&spGuard); + status_t ret; sp<IServiceManager> sm = defaultServiceManager(); BinderLibTestService* testServicePtr; diff --git a/libs/binder/tests/binderRpcTest.cpp b/libs/binder/tests/binderRpcTest.cpp index a96deb5d27..e452678755 100644 --- a/libs/binder/tests/binderRpcTest.cpp +++ b/libs/binder/tests/binderRpcTest.cpp @@ -14,6 +14,7 @@ * limitations under the License. */ +#include <BnBinderRpcCallback.h> #include <BnBinderRpcSession.h> #include <BnBinderRpcTest.h> #include <aidl/IBinderRpcTest.h> @@ -23,6 +24,7 @@ #include <android/binder_libbinder.h> #include <binder/Binder.h> #include <binder/BpBinder.h> +#include <binder/IPCThreadState.h> #include <binder/IServiceManager.h> #include <binder/ProcessState.h> #include <binder/RpcServer.h> @@ -33,6 +35,7 @@ #include <cstdlib> #include <iostream> #include <thread> +#include <type_traits> #include <sys/prctl.h> #include <unistd.h> @@ -40,6 +43,8 @@ #include "../RpcState.h" // for debugging #include "../vm_sockets.h" // for VMADDR_* +using namespace std::chrono_literals; + namespace android { TEST(BinderRpcParcel, EntireParcelFormatted) { @@ -86,6 +91,22 @@ private: }; std::atomic<int32_t> MyBinderRpcSession::gNum; +class MyBinderRpcCallback : public BnBinderRpcCallback { + Status sendCallback(const std::string& value) { + std::unique_lock _l(mMutex); + mValues.push_back(value); + _l.unlock(); + mCv.notify_one(); + return Status::ok(); + } + Status sendOnewayCallback(const std::string& value) { return sendCallback(value); } + +public: + std::mutex mMutex; + std::condition_variable mCv; + std::vector<std::string> mValues; +}; + class MyBinderRpcTest : public BnBinderRpcTest { public: wp<RpcServer> server; @@ -184,6 +205,33 @@ public: return sleepMs(ms); } + Status doCallback(const sp<IBinderRpcCallback>& callback, bool oneway, bool delayed, + const std::string& value) override { + if (callback == nullptr) { + return Status::fromExceptionCode(Status::EX_NULL_POINTER); + } + + if (delayed) { + std::thread([=]() { + ALOGE("Executing delayed callback: '%s'", value.c_str()); + Status status = doCallback(callback, oneway, false, value); + ALOGE("Delayed callback status: '%s'", status.toString8().c_str()); + }).detach(); + return Status::ok(); + } + + if (oneway) { + return callback->sendOnewayCallback(value); + } + + return callback->sendCallback(value); + } + + Status doCallbackAsync(const sp<IBinderRpcCallback>& callback, bool oneway, bool delayed, + const std::string& value) override { + return doCallback(callback, oneway, delayed, value); + } + Status die(bool cleanup) override { if (cleanup) { exit(1); @@ -191,42 +239,53 @@ public: _exit(1); } } -}; -sp<IBinder> MyBinderRpcTest::mHeldBinder; -class Pipe { -public: - Pipe() { CHECK(android::base::Pipe(&mRead, &mWrite)); } - Pipe(Pipe&&) = default; - android::base::borrowed_fd readEnd() { return mRead; } - android::base::borrowed_fd writeEnd() { return mWrite; } + Status scheduleShutdown() override { + sp<RpcServer> strongServer = server.promote(); + if (strongServer == nullptr) { + return Status::fromExceptionCode(Status::EX_NULL_POINTER); + } + std::thread([=] { + LOG_ALWAYS_FATAL_IF(!strongServer->shutdown(), "Could not shutdown"); + }).detach(); + return Status::ok(); + } -private: - android::base::unique_fd mRead; - android::base::unique_fd mWrite; + Status useKernelBinderCallingId() override { + // this is WRONG! It does not make sense when using RPC binder, and + // because it is SO wrong, and so much code calls this, it should abort! + + (void)IPCThreadState::self()->getCallingPid(); + return Status::ok(); + } }; +sp<IBinder> MyBinderRpcTest::mHeldBinder; class Process { public: Process(Process&&) = default; - Process(const std::function<void(Pipe*)>& f) { + Process(const std::function<void(android::base::borrowed_fd /* writeEnd */)>& f) { + android::base::unique_fd writeEnd; + CHECK(android::base::Pipe(&mReadEnd, &writeEnd)) << strerror(errno); if (0 == (mPid = fork())) { // racey: assume parent doesn't crash before this is set prctl(PR_SET_PDEATHSIG, SIGHUP); - f(&mPipe); + f(writeEnd); + + exit(0); } } ~Process() { if (mPid != 0) { - kill(mPid, SIGKILL); + waitpid(mPid, nullptr, 0); } } - Pipe* getPipe() { return &mPipe; } + android::base::borrowed_fd readEnd() { return mReadEnd; } private: pid_t mPid = 0; - Pipe mPipe; + android::base::unique_fd mReadEnd; }; static std::string allocateSocketAddress() { @@ -235,6 +294,11 @@ static std::string allocateSocketAddress() { return temp + "/binderRpcTest_" + std::to_string(id++); }; +static unsigned int allocateVsockPort() { + static unsigned int vsockPort = 3456; + return vsockPort++; +} + struct ProcessSession { // reference to process hosting a socket server Process host; @@ -280,11 +344,14 @@ struct BinderRpcTestProcessSession { sp<IBinderRpcTest> rootIface; // whether session should be invalidated by end of run - bool expectInvalid = false; + bool expectAlreadyShutdown = false; BinderRpcTestProcessSession(BinderRpcTestProcessSession&&) = default; ~BinderRpcTestProcessSession() { - if (!expectInvalid) { + EXPECT_NE(nullptr, rootIface); + if (rootIface == nullptr) return; + + if (!expectAlreadyShutdown) { std::vector<int32_t> remoteCounts; // calling over any sessions counts across all sessions EXPECT_OK(rootIface->countBinders(&remoteCounts)); @@ -292,6 +359,8 @@ struct BinderRpcTestProcessSession { for (auto remoteCount : remoteCounts) { EXPECT_EQ(remoteCount, 1); } + + EXPECT_OK(rootIface->scheduleShutdown()); } rootIface = nullptr; @@ -317,24 +386,24 @@ static inline std::string PrintSocketType(const testing::TestParamInfo<SocketTyp return ""; } } + class BinderRpc : public ::testing::TestWithParam<SocketType> { public: // This creates a new process serving an interface on a certain number of // threads. ProcessSession createRpcTestSocketServerProcess( - size_t numThreads, size_t numSessions, + size_t numThreads, size_t numSessions, size_t numReverseConnections, const std::function<void(const sp<RpcServer>&)>& configure) { CHECK_GE(numSessions, 1) << "Must have at least one session to a server"; SocketType socketType = GetParam(); + unsigned int vsockPort = allocateVsockPort(); std::string addr = allocateSocketAddress(); unlink(addr.c_str()); - static unsigned int vsockPort = 3456; - vsockPort++; auto ret = ProcessSession{ - .host = Process([&](Pipe* pipe) { + .host = Process([&](android::base::borrowed_fd writeEnd) { sp<RpcServer> server = RpcServer::make(); server->iUnderstandThisCodeIsExperimentalAndIWillNotUseItInProduction(); @@ -358,23 +427,28 @@ public: LOG_ALWAYS_FATAL("Unknown socket type"); } - CHECK(android::base::WriteFully(pipe->writeEnd(), &outPort, sizeof(outPort))); + CHECK(android::base::WriteFully(writeEnd, &outPort, sizeof(outPort))); configure(server); server->join(); + + // Another thread calls shutdown. Wait for it to complete. + (void)server->shutdown(); }), }; // always read socket, so that we have waited for the server to start unsigned int outPort = 0; - CHECK(android::base::ReadFully(ret.host.getPipe()->readEnd(), &outPort, sizeof(outPort))); + CHECK(android::base::ReadFully(ret.host.readEnd(), &outPort, sizeof(outPort))); if (socketType == SocketType::INET) { CHECK_NE(0, outPort); } for (size_t i = 0; i < numSessions; i++) { sp<RpcSession> session = RpcSession::make(); + session->setMaxThreads(numReverseConnections); + switch (socketType) { case SocketType::UNIX: if (session->setupUnixDomainClient(addr.c_str())) goto success; @@ -396,9 +470,11 @@ public: } BinderRpcTestProcessSession createRpcTestSocketServerProcess(size_t numThreads, - size_t numSessions = 1) { + size_t numSessions = 1, + size_t numReverseConnections = 0) { BinderRpcTestProcessSession ret{ .proc = createRpcTestSocketServerProcess(numThreads, numSessions, + numReverseConnections, [&](const sp<RpcServer>& server) { sp<MyBinderRpcTest> service = new MyBinderRpcTest; @@ -414,15 +490,6 @@ public: } }; -TEST_P(BinderRpc, RootObjectIsNull) { - auto proc = createRpcTestSocketServerProcess(1, 1, [](const sp<RpcServer>& server) { - // this is the default, but to be explicit - server->setRootObject(nullptr); - }); - - EXPECT_EQ(nullptr, proc.sessions.at(0).root); -} - TEST_P(BinderRpc, Ping) { auto proc = createRpcTestSocketServerProcess(1); ASSERT_NE(proc.rootBinder, nullptr); @@ -810,7 +877,7 @@ TEST_P(BinderRpc, ThreadingStressTest) { TEST_P(BinderRpc, OnewayStressTest) { constexpr size_t kNumClientThreads = 10; constexpr size_t kNumServerThreads = 10; - constexpr size_t kNumCalls = 100; + constexpr size_t kNumCalls = 500; auto proc = createRpcTestSocketServerProcess(kNumServerThreads); @@ -833,8 +900,7 @@ TEST_P(BinderRpc, OnewayCallDoesNotWait) { constexpr size_t kReallyLongTimeMs = 100; constexpr size_t kSleepMs = kReallyLongTimeMs * 5; - // more than one thread, just so this doesn't deadlock - auto proc = createRpcTestSocketServerProcess(2); + auto proc = createRpcTestSocketServerProcess(1); size_t epochMsBefore = epochMillis(); @@ -866,6 +932,99 @@ TEST_P(BinderRpc, OnewayCallQueueing) { size_t epochMsAfter = epochMillis(); EXPECT_GT(epochMsAfter, epochMsBefore + kSleepMs * kNumSleeps); + + // pending oneway transactions hold ref, make sure we read data on all + // sockets + std::vector<std::thread> threads; + for (size_t i = 0; i < 1 + kNumExtraServerThreads; i++) { + threads.push_back(std::thread([&] { EXPECT_OK(proc.rootIface->sleepMs(250)); })); + } + for (auto& t : threads) t.join(); +} + +TEST_P(BinderRpc, OnewayCallExhaustion) { + constexpr size_t kNumClients = 2; + constexpr size_t kTooLongMs = 1000; + + auto proc = createRpcTestSocketServerProcess(kNumClients /*threads*/, 2 /*sessions*/); + + // Build up oneway calls on the second session to make sure it terminates + // and shuts down. The first session should be unaffected (proc destructor + // checks the first session). + auto iface = interface_cast<IBinderRpcTest>(proc.proc.sessions.at(1).root); + + std::vector<std::thread> threads; + for (size_t i = 0; i < kNumClients; i++) { + // one of these threads will get stuck queueing a transaction once the + // socket fills up, the other will be able to fill up transactions on + // this object + threads.push_back(std::thread([&] { + while (iface->sleepMsAsync(kTooLongMs).isOk()) { + } + })); + } + for (auto& t : threads) t.join(); + + Status status = iface->sleepMsAsync(kTooLongMs); + EXPECT_EQ(DEAD_OBJECT, status.transactionError()) << status; + + // the second session should be shutdown in the other process by the time we + // are able to join above (it'll only be hung up once it finishes processing + // any pending commands). We need to erase this session from the record + // here, so that the destructor for our session won't check that this + // session is valid, but we still want it to test the other session. + proc.proc.sessions.erase(proc.proc.sessions.begin() + 1); +} + +TEST_P(BinderRpc, Callbacks) { + const static std::string kTestString = "good afternoon!"; + + for (bool callIsOneway : {true, false}) { + for (bool callbackIsOneway : {true, false}) { + for (bool delayed : {true, false}) { + auto proc = createRpcTestSocketServerProcess(1, 1, 1); + auto cb = sp<MyBinderRpcCallback>::make(); + + if (callIsOneway) { + EXPECT_OK(proc.rootIface->doCallbackAsync(cb, callbackIsOneway, delayed, + kTestString)); + } else { + EXPECT_OK( + proc.rootIface->doCallback(cb, callbackIsOneway, delayed, kTestString)); + } + + using std::literals::chrono_literals::operator""s; + std::unique_lock<std::mutex> _l(cb->mMutex); + cb->mCv.wait_for(_l, 1s, [&] { return !cb->mValues.empty(); }); + + EXPECT_EQ(cb->mValues.size(), 1) + << "callIsOneway: " << callIsOneway + << " callbackIsOneway: " << callbackIsOneway << " delayed: " << delayed; + if (cb->mValues.empty()) continue; + EXPECT_EQ(cb->mValues.at(0), kTestString) + << "callIsOneway: " << callIsOneway + << " callbackIsOneway: " << callbackIsOneway << " delayed: " << delayed; + + // since we are severing the connection, we need to go ahead and + // tell the server to shutdown and exit so that waitpid won't hang + EXPECT_OK(proc.rootIface->scheduleShutdown()); + + // since this session has a reverse connection w/ a threadpool, we + // need to manually shut it down + EXPECT_TRUE(proc.proc.sessions.at(0).session->shutdownAndWait(true)); + + proc.expectAlreadyShutdown = true; + } + } + } +} + +TEST_P(BinderRpc, OnewayCallbackWithNoThread) { + auto proc = createRpcTestSocketServerProcess(1); + auto cb = sp<MyBinderRpcCallback>::make(); + + Status status = proc.rootIface->doCallback(cb, true /*oneway*/, false /*delayed*/, "anything"); + EXPECT_EQ(WOULD_BLOCK, status.transactionError()); } TEST_P(BinderRpc, Die) { @@ -883,10 +1042,23 @@ TEST_P(BinderRpc, Die) { EXPECT_EQ(DEAD_OBJECT, proc.rootIface->die(doDeathCleanup).transactionError()) << "Do death cleanup: " << doDeathCleanup; - proc.expectInvalid = true; + proc.expectAlreadyShutdown = true; } } +TEST_P(BinderRpc, UseKernelBinderCallingId) { + auto proc = createRpcTestSocketServerProcess(1); + + // we can't allocate IPCThreadState so actually the first time should + // succeed :( + EXPECT_OK(proc.rootIface->useKernelBinderCallingId()); + + // second time! we catch the error :) + EXPECT_EQ(DEAD_OBJECT, proc.rootIface->useKernelBinderCallingId().transactionError()); + + proc.expectAlreadyShutdown = true; +} + TEST_P(BinderRpc, WorksWithLibbinderNdkPing) { auto proc = createRpcTestSocketServerProcess(1); @@ -931,15 +1103,33 @@ TEST_P(BinderRpc, Fds) { ASSERT_EQ(beforeFds, countFds()) << (system("ls -l /proc/self/fd/"), "fd leak?"); } -INSTANTIATE_TEST_CASE_P(PerSocket, BinderRpc, - ::testing::ValuesIn({ - SocketType::UNIX, -// TODO(b/185269356): working on host -#ifdef __BIONIC__ - SocketType::VSOCK, -#endif - SocketType::INET, - }), +static bool testSupportVsockLoopback() { + unsigned int vsockPort = allocateVsockPort(); + sp<RpcServer> server = RpcServer::make(); + server->iUnderstandThisCodeIsExperimentalAndIWillNotUseItInProduction(); + CHECK(server->setupVsockServer(vsockPort)); + server->start(); + + sp<RpcSession> session = RpcSession::make(); + bool okay = session->setupVsockClient(VMADDR_CID_LOCAL, vsockPort); + CHECK(server->shutdown()); + ALOGE("Detected vsock loopback supported: %d", okay); + return okay; +} + +static std::vector<SocketType> testSocketTypes() { + std::vector<SocketType> ret = {SocketType::UNIX, SocketType::INET}; + + static bool hasVsockLoopback = testSupportVsockLoopback(); + + if (hasVsockLoopback) { + ret.push_back(SocketType::VSOCK); + } + + return ret; +} + +INSTANTIATE_TEST_CASE_P(PerSocket, BinderRpc, ::testing::ValuesIn(testSocketTypes()), PrintSocketType); class BinderRpcServerRootObject : public ::testing::TestWithParam<std::tuple<bool, bool>> {}; @@ -970,6 +1160,54 @@ TEST_P(BinderRpcServerRootObject, WeakRootObject) { INSTANTIATE_TEST_CASE_P(BinderRpc, BinderRpcServerRootObject, ::testing::Combine(::testing::Bool(), ::testing::Bool())); +class OneOffSignal { +public: + // If notify() was previously called, or is called within |duration|, return true; else false. + template <typename R, typename P> + bool wait(std::chrono::duration<R, P> duration) { + std::unique_lock<std::mutex> lock(mMutex); + return mCv.wait_for(lock, duration, [this] { return mValue; }); + } + void notify() { + std::unique_lock<std::mutex> lock(mMutex); + mValue = true; + lock.unlock(); + mCv.notify_all(); + } + +private: + std::mutex mMutex; + std::condition_variable mCv; + bool mValue = false; +}; + +TEST(BinderRpc, Shutdown) { + auto addr = allocateSocketAddress(); + unlink(addr.c_str()); + auto server = RpcServer::make(); + server->iUnderstandThisCodeIsExperimentalAndIWillNotUseItInProduction(); + ASSERT_TRUE(server->setupUnixDomainServer(addr.c_str())); + auto joinEnds = std::make_shared<OneOffSignal>(); + + // If things are broken and the thread never stops, don't block other tests. Because the thread + // may run after the test finishes, it must not access the stack memory of the test. Hence, + // shared pointers are passed. + std::thread([server, joinEnds] { + server->join(); + joinEnds->notify(); + }).detach(); + + bool shutdown = false; + for (int i = 0; i < 10 && !shutdown; i++) { + usleep(300 * 1000); // 300ms; total 3s + if (server->shutdown()) shutdown = true; + } + ASSERT_TRUE(shutdown) << "server->shutdown() never returns true"; + + ASSERT_TRUE(joinEnds->wait(2s)) + << "After server->shutdown() returns true, join() did not stop after 2s"; +} + } // namespace android int main(int argc, char** argv) { diff --git a/libs/binder/tests/binderStabilityTest.cpp b/libs/binder/tests/binderStabilityTest.cpp index 2ce13df4b3..6c3b3d9087 100644 --- a/libs/binder/tests/binderStabilityTest.cpp +++ b/libs/binder/tests/binderStabilityTest.cpp @@ -102,7 +102,7 @@ public: return Status::ok(); } Status sendAndCallBinder(const sp<IBinder>& binder) override { - Stability::debugLogStability("sendAndCallBinder got binder", binder); + ALOGI("Debug log stability: %s", Stability::debugToString(binder).c_str()); return Status::fromExceptionCode(BadStableBinder::doUserTransaction(binder)); } Status returnNoStabilityBinder(sp<IBinder>* _aidl_return) override { diff --git a/libs/binder/tests/parcel_fuzzer/binder.cpp b/libs/binder/tests/parcel_fuzzer/binder.cpp index 624def1a7a..a717ce9e6e 100644 --- a/libs/binder/tests/parcel_fuzzer/binder.cpp +++ b/libs/binder/tests/parcel_fuzzer/binder.cpp @@ -66,6 +66,10 @@ struct ExampleLightFlattenable : public android::LightFlattenablePod<ExampleLigh int32_t mValue = 0; }; +struct BigStruct { + uint8_t data[1337]; +}; + #define PARCEL_READ_WITH_STATUS(T, FUN) \ [] (const ::android::Parcel& p, uint8_t /*data*/) {\ FUZZ_LOG() << "about to read " #T " using " #FUN " with status";\ @@ -165,22 +169,20 @@ std::vector<ParcelRead<::android::Parcel>> BINDER_PARCEL_READ_FUNCTIONS { PARCEL_READ_WITH_STATUS(android::sp<android::IBinder>, readStrongBinder), PARCEL_READ_WITH_STATUS(android::sp<android::IBinder>, readNullableStrongBinder), - // TODO(b/131868573): can force read of arbitrarily sized vector - // PARCEL_READ_WITH_STATUS(std::vector<ByteEnum>, readEnumVector), - // PARCEL_READ_WITH_STATUS(std::unique_ptr<std::vector<ByteEnum>>, readEnumVector), - // PARCEL_READ_WITH_STATUS(std::optional<std::vector<ByteEnum>>, readEnumVector), - // PARCEL_READ_WITH_STATUS(std::vector<IntEnum>, readEnumVector), - // PARCEL_READ_WITH_STATUS(std::unique_ptr<std::vector<IntEnum>>, readEnumVector), - // PARCEL_READ_WITH_STATUS(std::optional<std::vector<IntEnum>>, readEnumVector), - // PARCEL_READ_WITH_STATUS(std::vector<LongEnum>, readEnumVector), - // PARCEL_READ_WITH_STATUS(std::unique_ptr<std::vector<LongEnum>>, readEnumVector), - // PARCEL_READ_WITH_STATUS(std::optional<std::vector<LongEnum>>, readEnumVector), + PARCEL_READ_WITH_STATUS(std::vector<ByteEnum>, readEnumVector), + PARCEL_READ_WITH_STATUS(std::unique_ptr<std::vector<ByteEnum>>, readEnumVector), + PARCEL_READ_WITH_STATUS(std::optional<std::vector<ByteEnum>>, readEnumVector), + PARCEL_READ_WITH_STATUS(std::vector<IntEnum>, readEnumVector), + PARCEL_READ_WITH_STATUS(std::unique_ptr<std::vector<IntEnum>>, readEnumVector), + PARCEL_READ_WITH_STATUS(std::optional<std::vector<IntEnum>>, readEnumVector), + PARCEL_READ_WITH_STATUS(std::vector<LongEnum>, readEnumVector), + PARCEL_READ_WITH_STATUS(std::unique_ptr<std::vector<LongEnum>>, readEnumVector), + PARCEL_READ_WITH_STATUS(std::optional<std::vector<LongEnum>>, readEnumVector), // only reading one parcelable type for now - // TODO(b/131868573): can force read of arbitrarily sized vector - // PARCEL_READ_WITH_STATUS(std::unique_ptr<std::vector<std::unique_ptr<ExampleParcelable>>>, readParcelableVector), - // PARCEL_READ_WITH_STATUS(std::optional<std::vector<std::optional<ExampleParcelable>>>, readParcelableVector), - // PARCEL_READ_WITH_STATUS(std::vector<ExampleParcelable>, readParcelableVector), + PARCEL_READ_WITH_STATUS(std::unique_ptr<std::vector<std::unique_ptr<ExampleParcelable>>>, readParcelableVector), + PARCEL_READ_WITH_STATUS(std::optional<std::vector<std::optional<ExampleParcelable>>>, readParcelableVector), + PARCEL_READ_WITH_STATUS(std::vector<ExampleParcelable>, readParcelableVector), PARCEL_READ_WITH_STATUS(ExampleParcelable, readParcelable), PARCEL_READ_WITH_STATUS(std::unique_ptr<ExampleParcelable>, readParcelable), PARCEL_READ_WITH_STATUS(std::optional<ExampleParcelable>, readParcelable), @@ -189,45 +191,43 @@ std::vector<ParcelRead<::android::Parcel>> BINDER_PARCEL_READ_FUNCTIONS { PARCEL_READ_WITH_STATUS(android::sp<android::os::IServiceManager>, readStrongBinder), PARCEL_READ_WITH_STATUS(android::sp<android::os::IServiceManager>, readNullableStrongBinder), - // TODO(b/131868573): can force read of arbitrarily sized vector - // PARCEL_READ_WITH_STATUS(::std::unique_ptr<std::vector<android::sp<android::IBinder>>>, readStrongBinderVector), - // PARCEL_READ_WITH_STATUS(::std::optional<std::vector<android::sp<android::IBinder>>>, readStrongBinderVector), - // PARCEL_READ_WITH_STATUS(std::vector<android::sp<android::IBinder>>, readStrongBinderVector), + PARCEL_READ_WITH_STATUS(::std::unique_ptr<std::vector<android::sp<android::IBinder>>>, readStrongBinderVector), + PARCEL_READ_WITH_STATUS(::std::optional<std::vector<android::sp<android::IBinder>>>, readStrongBinderVector), + PARCEL_READ_WITH_STATUS(std::vector<android::sp<android::IBinder>>, readStrongBinderVector), - // TODO(b/131868573): can force read of arbitrarily sized vector - // PARCEL_READ_WITH_STATUS(std::unique_ptr<std::vector<int8_t>>, readByteVector), - // PARCEL_READ_WITH_STATUS(std::optional<std::vector<int8_t>>, readByteVector), - // PARCEL_READ_WITH_STATUS(std::vector<int8_t>, readByteVector), - // PARCEL_READ_WITH_STATUS(std::unique_ptr<std::vector<uint8_t>>, readByteVector), - // PARCEL_READ_WITH_STATUS(std::optional<std::vector<uint8_t>>, readByteVector), - // PARCEL_READ_WITH_STATUS(std::vector<uint8_t>, readByteVector), - // PARCEL_READ_WITH_STATUS(std::unique_ptr<std::vector<int32_t>>, readInt32Vector), - // PARCEL_READ_WITH_STATUS(std::optional<std::vector<int32_t>>, readInt32Vector), - // PARCEL_READ_WITH_STATUS(std::vector<int32_t>, readInt32Vector), - // PARCEL_READ_WITH_STATUS(std::unique_ptr<std::vector<int64_t>>, readInt64Vector), - // PARCEL_READ_WITH_STATUS(std::optional<std::vector<int64_t>>, readInt64Vector), - // PARCEL_READ_WITH_STATUS(std::vector<int64_t>, readInt64Vector), - // PARCEL_READ_WITH_STATUS(std::unique_ptr<std::vector<uint64_t>>, readUint64Vector), - // PARCEL_READ_WITH_STATUS(std::optional<std::vector<uint64_t>>, readUint64Vector), - // PARCEL_READ_WITH_STATUS(std::vector<uint64_t>, readUint64Vector), - // PARCEL_READ_WITH_STATUS(std::unique_ptr<std::vector<float>>, readFloatVector), - // PARCEL_READ_WITH_STATUS(std::optional<std::vector<float>>, readFloatVector), - // PARCEL_READ_WITH_STATUS(std::vector<float>, readFloatVector), - // PARCEL_READ_WITH_STATUS(std::unique_ptr<std::vector<double>>, readDoubleVector), - // PARCEL_READ_WITH_STATUS(std::optional<std::vector<double>>, readDoubleVector), - // PARCEL_READ_WITH_STATUS(std::vector<double>, readDoubleVector), - // PARCEL_READ_WITH_STATUS(std::unique_ptr<std::vector<bool>>, readBoolVector), - // PARCEL_READ_WITH_STATUS(std::optional<std::vector<bool>>, readBoolVector), - // PARCEL_READ_WITH_STATUS(std::vector<bool>, readBoolVector), - // PARCEL_READ_WITH_STATUS(std::unique_ptr<std::vector<char16_t>>, readCharVector), - // PARCEL_READ_WITH_STATUS(std::optional<std::vector<char16_t>>, readCharVector), - // PARCEL_READ_WITH_STATUS(std::vector<char16_t>, readCharVector), - // PARCEL_READ_WITH_STATUS(std::unique_ptr<std::vector<std::unique_ptr<android::String16>>>, readString16Vector), - // PARCEL_READ_WITH_STATUS(std::optional<std::vector<std::optional<android::String16>>>, readString16Vector), - // PARCEL_READ_WITH_STATUS(std::vector<android::String16>, readString16Vector), - // PARCEL_READ_WITH_STATUS(std::unique_ptr<std::vector<std::unique_ptr<std::string>>>, readUtf8VectorFromUtf16Vector), - // PARCEL_READ_WITH_STATUS(std::optional<std::vector<std::optional<std::string>>>, readUtf8VectorFromUtf16Vector), - // PARCEL_READ_WITH_STATUS(std::vector<std::string>, readUtf8VectorFromUtf16Vector), + PARCEL_READ_WITH_STATUS(std::unique_ptr<std::vector<int8_t>>, readByteVector), + PARCEL_READ_WITH_STATUS(std::optional<std::vector<int8_t>>, readByteVector), + PARCEL_READ_WITH_STATUS(std::vector<int8_t>, readByteVector), + PARCEL_READ_WITH_STATUS(std::unique_ptr<std::vector<uint8_t>>, readByteVector), + PARCEL_READ_WITH_STATUS(std::optional<std::vector<uint8_t>>, readByteVector), + PARCEL_READ_WITH_STATUS(std::vector<uint8_t>, readByteVector), + PARCEL_READ_WITH_STATUS(std::unique_ptr<std::vector<int32_t>>, readInt32Vector), + PARCEL_READ_WITH_STATUS(std::optional<std::vector<int32_t>>, readInt32Vector), + PARCEL_READ_WITH_STATUS(std::vector<int32_t>, readInt32Vector), + PARCEL_READ_WITH_STATUS(std::unique_ptr<std::vector<int64_t>>, readInt64Vector), + PARCEL_READ_WITH_STATUS(std::optional<std::vector<int64_t>>, readInt64Vector), + PARCEL_READ_WITH_STATUS(std::vector<int64_t>, readInt64Vector), + PARCEL_READ_WITH_STATUS(std::unique_ptr<std::vector<uint64_t>>, readUint64Vector), + PARCEL_READ_WITH_STATUS(std::optional<std::vector<uint64_t>>, readUint64Vector), + PARCEL_READ_WITH_STATUS(std::vector<uint64_t>, readUint64Vector), + PARCEL_READ_WITH_STATUS(std::unique_ptr<std::vector<float>>, readFloatVector), + PARCEL_READ_WITH_STATUS(std::optional<std::vector<float>>, readFloatVector), + PARCEL_READ_WITH_STATUS(std::vector<float>, readFloatVector), + PARCEL_READ_WITH_STATUS(std::unique_ptr<std::vector<double>>, readDoubleVector), + PARCEL_READ_WITH_STATUS(std::optional<std::vector<double>>, readDoubleVector), + PARCEL_READ_WITH_STATUS(std::vector<double>, readDoubleVector), + PARCEL_READ_WITH_STATUS(std::unique_ptr<std::vector<bool>>, readBoolVector), + PARCEL_READ_WITH_STATUS(std::optional<std::vector<bool>>, readBoolVector), + PARCEL_READ_WITH_STATUS(std::vector<bool>, readBoolVector), + PARCEL_READ_WITH_STATUS(std::unique_ptr<std::vector<char16_t>>, readCharVector), + PARCEL_READ_WITH_STATUS(std::optional<std::vector<char16_t>>, readCharVector), + PARCEL_READ_WITH_STATUS(std::vector<char16_t>, readCharVector), + PARCEL_READ_WITH_STATUS(std::unique_ptr<std::vector<std::unique_ptr<android::String16>>>, readString16Vector), + PARCEL_READ_WITH_STATUS(std::optional<std::vector<std::optional<android::String16>>>, readString16Vector), + PARCEL_READ_WITH_STATUS(std::vector<android::String16>, readString16Vector), + PARCEL_READ_WITH_STATUS(std::unique_ptr<std::vector<std::unique_ptr<std::string>>>, readUtf8VectorFromUtf16Vector), + PARCEL_READ_WITH_STATUS(std::optional<std::vector<std::optional<std::string>>>, readUtf8VectorFromUtf16Vector), + PARCEL_READ_WITH_STATUS(std::vector<std::string>, readUtf8VectorFromUtf16Vector), [] (const android::Parcel& p, uint8_t /*len*/) { FUZZ_LOG() << "about to read flattenable"; @@ -242,8 +242,12 @@ std::vector<ParcelRead<::android::Parcel>> BINDER_PARCEL_READ_FUNCTIONS { FUZZ_LOG() << "read lite flattenable: " << status; }, - // TODO(b/131868573): can force read of arbitrarily sized vector - // TODO: resizeOutVector + PARCEL_READ_WITH_STATUS(std::vector<uint8_t>, resizeOutVector), + PARCEL_READ_WITH_STATUS(std::optional<std::vector<uint8_t>>, resizeOutVector), + PARCEL_READ_WITH_STATUS(std::unique_ptr<std::vector<uint8_t>>, resizeOutVector), + PARCEL_READ_WITH_STATUS(std::vector<BigStruct>, resizeOutVector), + PARCEL_READ_WITH_STATUS(std::optional<std::vector<BigStruct>>, resizeOutVector), + PARCEL_READ_WITH_STATUS(std::unique_ptr<std::vector<BigStruct>>, resizeOutVector), PARCEL_READ_NO_STATUS(int32_t, readExceptionCode), [] (const android::Parcel& p, uint8_t /*len*/) { @@ -261,10 +265,9 @@ std::vector<ParcelRead<::android::Parcel>> BINDER_PARCEL_READ_FUNCTIONS { PARCEL_READ_NO_STATUS(int, readParcelFileDescriptor), PARCEL_READ_WITH_STATUS(android::base::unique_fd, readUniqueFileDescriptor), - // TODO(b/131868573): can force read of arbitrarily sized vector - // PARCEL_READ_WITH_STATUS(std::unique_ptr<std::vector<android::base::unique_fd>>, readUniqueFileDescriptorVector), - // PARCEL_READ_WITH_STATUS(std::optional<std::vector<android::base::unique_fd>>, readUniqueFileDescriptorVector), - // PARCEL_READ_WITH_STATUS(std::vector<android::base::unique_fd>, readUniqueFileDescriptorVector), + PARCEL_READ_WITH_STATUS(std::unique_ptr<std::vector<android::base::unique_fd>>, readUniqueFileDescriptorVector), + PARCEL_READ_WITH_STATUS(std::optional<std::vector<android::base::unique_fd>>, readUniqueFileDescriptorVector), + PARCEL_READ_WITH_STATUS(std::vector<android::base::unique_fd>, readUniqueFileDescriptorVector), [] (const android::Parcel& p, uint8_t len) { FUZZ_LOG() << "about to readBlob"; diff --git a/libs/binder/tests/parcel_fuzzer/binder_ndk.cpp b/libs/binder/tests/parcel_fuzzer/binder_ndk.cpp index 008780cb2e..6b783a4804 100644 --- a/libs/binder/tests/parcel_fuzzer/binder_ndk.cpp +++ b/libs/binder/tests/parcel_fuzzer/binder_ndk.cpp @@ -91,28 +91,27 @@ std::vector<ParcelRead<NdkParcelAdapter>> BINDER_NDK_PARCEL_READ_FUNCTIONS{ PARCEL_READ(ndk::ScopedFileDescriptor, ndk::AParcel_readRequiredParcelFileDescriptor), PARCEL_READ(std::string, ndk::AParcel_readString), PARCEL_READ(std::optional<std::string>, ndk::AParcel_readString), - // TODO(b/131868573): can force process to allocate arbitrary amount of - // memory - // PARCEL_READ(std::vector<std::string>, ndk::AParcel_readVector), - // PARCEL_READ(std::optional<std::vector<std::optional<std::string>>>, - // ndk::AParcel_readVector), PARCEL_READ(std::vector<SomeParcelable>, - // ndk::AParcel_readVector), PARCEL_READ(std::vector<int32_t>, ndk::AParcel_readVector), - // PARCEL_READ(std::optional<std::vector<int32_t>>, ndk::AParcel_readVector), - // PARCEL_READ(std::vector<uint32_t>, ndk::AParcel_readVector), - // PARCEL_READ(std::optional<std::vector<uint32_t>>, ndk::AParcel_readVector), - // PARCEL_READ(std::vector<int64_t>, ndk::AParcel_readVector), - // PARCEL_READ(std::optional<std::vector<int64_t>>, ndk::AParcel_readVector), - // PARCEL_READ(std::vector<uint64_t>, ndk::AParcel_readVector), - // PARCEL_READ(std::optional<std::vector<uint64_t>>, ndk::AParcel_readVector), - // PARCEL_READ(std::vector<float>, ndk::AParcel_readVector), - // PARCEL_READ(std::optional<std::vector<float>>, ndk::AParcel_readVector), - // PARCEL_READ(std::vector<double>, ndk::AParcel_readVector), - // PARCEL_READ(std::optional<std::vector<double>>, ndk::AParcel_readVector), - // PARCEL_READ(std::vector<bool>, ndk::AParcel_readVector), - // PARCEL_READ(std::optional<std::vector<bool>>, ndk::AParcel_readVector), - // PARCEL_READ(std::vector<char16_t>, ndk::AParcel_readVector), - // PARCEL_READ(std::optional<std::vector<char16_t>>, ndk::AParcel_readVector), - // PARCEL_READ(std::vector<int32_t>, ndk::AParcel_resizeVector), - // PARCEL_READ(std::optional<std::vector<int32_t>>, ndk::AParcel_resizeVector), + + PARCEL_READ(std::vector<std::string>, ndk::AParcel_readVector), + PARCEL_READ(std::optional<std::vector<std::optional<std::string>>>, ndk::AParcel_readVector), + PARCEL_READ(std::vector<SomeParcelable>, ndk::AParcel_readVector), + PARCEL_READ(std::vector<int32_t>, ndk::AParcel_readVector), + PARCEL_READ(std::optional<std::vector<int32_t>>, ndk::AParcel_readVector), + PARCEL_READ(std::vector<uint32_t>, ndk::AParcel_readVector), + PARCEL_READ(std::optional<std::vector<uint32_t>>, ndk::AParcel_readVector), + PARCEL_READ(std::vector<int64_t>, ndk::AParcel_readVector), + PARCEL_READ(std::optional<std::vector<int64_t>>, ndk::AParcel_readVector), + PARCEL_READ(std::vector<uint64_t>, ndk::AParcel_readVector), + PARCEL_READ(std::optional<std::vector<uint64_t>>, ndk::AParcel_readVector), + PARCEL_READ(std::vector<float>, ndk::AParcel_readVector), + PARCEL_READ(std::optional<std::vector<float>>, ndk::AParcel_readVector), + PARCEL_READ(std::vector<double>, ndk::AParcel_readVector), + PARCEL_READ(std::optional<std::vector<double>>, ndk::AParcel_readVector), + PARCEL_READ(std::vector<bool>, ndk::AParcel_readVector), + PARCEL_READ(std::optional<std::vector<bool>>, ndk::AParcel_readVector), + PARCEL_READ(std::vector<char16_t>, ndk::AParcel_readVector), + PARCEL_READ(std::optional<std::vector<char16_t>>, ndk::AParcel_readVector), + PARCEL_READ(std::vector<int32_t>, ndk::AParcel_resizeVector), + PARCEL_READ(std::optional<std::vector<int32_t>>, ndk::AParcel_resizeVector), }; // clang-format on diff --git a/libs/binder/tests/parcel_fuzzer/hwbinder.cpp b/libs/binder/tests/parcel_fuzzer/hwbinder.cpp index 0fec393e55..35b5ebca6f 100644 --- a/libs/binder/tests/parcel_fuzzer/hwbinder.cpp +++ b/libs/binder/tests/parcel_fuzzer/hwbinder.cpp @@ -148,28 +148,6 @@ std::vector<ParcelRead<::android::hardware::Parcel>> HWBINDER_PARCEL_READ_FUNCTI // should be null since we don't create any IPC objects CHECK(data == nullptr) << data; }, - [] (const ::android::hardware::Parcel& p, uint8_t size) { - FUZZ_LOG() << "about to readEmbeddedNativeHandle"; - size_t parent_buffer_handle = size & 0xf; - size_t parent_offset = size >> 4; - const native_handle_t* handle = nullptr; - status_t status = p.readEmbeddedNativeHandle(parent_buffer_handle, parent_offset, &handle); - FUZZ_LOG() << "readEmbeddedNativeHandle status: " << status << " handle: " << handle << " handle: " << handle; - - // should be null since we don't create any IPC objects - CHECK(handle == nullptr) << handle; - }, - [] (const ::android::hardware::Parcel& p, uint8_t size) { - FUZZ_LOG() << "about to readNullableEmbeddedNativeHandle"; - size_t parent_buffer_handle = size & 0xf; - size_t parent_offset = size >> 4; - const native_handle_t* handle = nullptr; - status_t status = p.readNullableEmbeddedNativeHandle(parent_buffer_handle, parent_offset, &handle); - FUZZ_LOG() << "readNullableEmbeddedNativeHandle status: " << status << " handle: " << handle << " handle: " << handle; - - // should be null since we don't create any IPC objects - CHECK(handle == nullptr) << handle; - }, [] (const ::android::hardware::Parcel& p, uint8_t /*data*/) { FUZZ_LOG() << "about to readNativeHandleNoDup"; const native_handle_t* handle = nullptr; @@ -180,14 +158,5 @@ std::vector<ParcelRead<::android::hardware::Parcel>> HWBINDER_PARCEL_READ_FUNCTI CHECK(handle == nullptr) << handle; CHECK(status != ::android::OK); }, - [] (const ::android::hardware::Parcel& p, uint8_t /*data*/) { - FUZZ_LOG() << "about to readNullableNativeHandleNoDup"; - const native_handle_t* handle = nullptr; - status_t status = p.readNullableNativeHandleNoDup(&handle); - FUZZ_LOG() << "readNullableNativeHandleNoDup status: " << status << " handle: " << handle; - - // should be null since we don't create any IPC objects - CHECK(handle == nullptr) << handle; - }, }; // clang-format on diff --git a/libs/binder/tests/parcel_fuzzer/main.cpp b/libs/binder/tests/parcel_fuzzer/main.cpp index a47b753497..2a79e85eca 100644 --- a/libs/binder/tests/parcel_fuzzer/main.cpp +++ b/libs/binder/tests/parcel_fuzzer/main.cpp @@ -23,7 +23,8 @@ #include <iostream> #include <android-base/logging.h> -#include <binder/RpcSession.h> +#include <android/binder_auto_utils.h> +#include <android/binder_libbinder.h> #include <fuzzbinder/random_parcel.h> #include <fuzzer/FuzzedDataProvider.h> @@ -33,7 +34,6 @@ #include <sys/time.h> using android::fillRandomParcel; -using android::RpcSession; using android::sp; void fillRandomParcel(::android::hardware::Parcel* p, FuzzedDataProvider&& provider) { @@ -46,9 +46,22 @@ static void fillRandomParcel(NdkParcelAdapter* p, FuzzedDataProvider&& provider) fillRandomParcel(p->parcel(), std::move(provider)); } +template <typename P, typename B> +void doTransactFuzz(const char* backend, const sp<B>& binder, FuzzedDataProvider&& provider) { + uint32_t code = provider.ConsumeIntegral<uint32_t>(); + uint32_t flag = provider.ConsumeIntegral<uint32_t>(); + + FUZZ_LOG() << "backend: " << backend; + + P reply; + P data; + fillRandomParcel(&data, std::move(provider)); + (void)binder->transact(code, data, &reply, flag); +} + template <typename P> -void doFuzz(const char* backend, const std::vector<ParcelRead<P>>& reads, - FuzzedDataProvider&& provider) { +void doReadFuzz(const char* backend, const std::vector<ParcelRead<P>>& reads, + FuzzedDataProvider&& provider) { // Allow some majority of the bytes to be dedicated to telling us what to // do. The fixed value added here represents that we want to test doing a // lot of 'instructions' even on really short parcels. @@ -59,18 +72,7 @@ void doFuzz(const char* backend, const std::vector<ParcelRead<P>>& reads, provider.ConsumeIntegralInRange<size_t>(0, maxInstructions)); P p; - if constexpr (std::is_same_v<P, android::Parcel>) { - if (provider.ConsumeBool()) { - auto session = sp<RpcSession>::make(); - CHECK(session->addNullDebuggingClient()); - p.markForRpc(session); - fillRandomParcelData(&p, std::move(provider)); - } else { - fillRandomParcel(&p, std::move(provider)); - } - } else { - fillRandomParcel(&p, std::move(provider)); - } + fillRandomParcel(&p, std::move(provider)); // since we are only using a byte to index CHECK(reads.size() <= 255) << reads.size(); @@ -95,25 +97,18 @@ void doFuzz(const char* backend, const std::vector<ParcelRead<P>>& reads, } } -size_t getHardMemoryLimit() { - struct rlimit limit; - CHECK(0 == getrlimit(RLIMIT_AS, &limit)) << errno; - return limit.rlim_max; +void* NothingClass_onCreate(void* args) { + return args; } - -void setMemoryLimit(size_t cur, size_t max) { - const struct rlimit kLimit = { - .rlim_cur = cur, - .rlim_max = max, - }; - CHECK(0 == setrlimit(RLIMIT_AS, &kLimit)) << errno; +void NothingClass_onDestroy(void* /*userData*/) {} +binder_status_t NothingClass_onTransact(AIBinder*, transaction_code_t, const AParcel*, AParcel*) { + return STATUS_UNKNOWN_ERROR; } +static AIBinder_Class* kNothingClass = + AIBinder_Class_define("nothing", NothingClass_onCreate, NothingClass_onDestroy, + NothingClass_onTransact); extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size) { - static constexpr size_t kMemLimit = 1 * 1024 * 1024; - size_t hardLimit = getHardMemoryLimit(); - setMemoryLimit(std::min(kMemLimit, hardLimit), hardLimit); - if (size <= 1) return 0; // no use // avoid timeouts, see b/142617274, b/142473153 @@ -121,24 +116,39 @@ extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size) { FuzzedDataProvider provider = FuzzedDataProvider(data, size); - const std::function<void(FuzzedDataProvider &&)> fuzzBackend[3] = { + const std::function<void(FuzzedDataProvider &&)> fuzzBackend[] = { + [](FuzzedDataProvider&& provider) { + doTransactFuzz< + ::android::hardware::Parcel>("hwbinder", + sp<::android::hardware::BHwBinder>::make(), + std::move(provider)); + }, + [](FuzzedDataProvider&& provider) { + doTransactFuzz<::android::Parcel>("binder", sp<::android::BBinder>::make(), + std::move(provider)); + }, + [](FuzzedDataProvider&& provider) { + // fuzz from the libbinder layer since it's a superset of the + // interface you get at the libbinder_ndk layer + auto ndkBinder = ndk::SpAIBinder(AIBinder_new(kNothingClass, nullptr)); + auto binder = AIBinder_toPlatformBinder(ndkBinder.get()); + doTransactFuzz<::android::Parcel>("binder_ndk", binder, std::move(provider)); + }, [](FuzzedDataProvider&& provider) { - doFuzz<::android::hardware::Parcel>("hwbinder", HWBINDER_PARCEL_READ_FUNCTIONS, - std::move(provider)); + doReadFuzz<::android::hardware::Parcel>("hwbinder", HWBINDER_PARCEL_READ_FUNCTIONS, + std::move(provider)); }, [](FuzzedDataProvider&& provider) { - doFuzz<::android::Parcel>("binder", BINDER_PARCEL_READ_FUNCTIONS, - std::move(provider)); + doReadFuzz<::android::Parcel>("binder", BINDER_PARCEL_READ_FUNCTIONS, + std::move(provider)); }, [](FuzzedDataProvider&& provider) { - doFuzz<NdkParcelAdapter>("binder_ndk", BINDER_NDK_PARCEL_READ_FUNCTIONS, - std::move(provider)); + doReadFuzz<NdkParcelAdapter>("binder_ndk", BINDER_NDK_PARCEL_READ_FUNCTIONS, + std::move(provider)); }, }; provider.PickValueInArray(fuzzBackend)(std::move(provider)); - setMemoryLimit(hardLimit, hardLimit); - return 0; } diff --git a/libs/binder/tests/parcel_fuzzer/random_parcel.cpp b/libs/binder/tests/parcel_fuzzer/random_parcel.cpp index b045a22eff..92fdc72cc1 100644 --- a/libs/binder/tests/parcel_fuzzer/random_parcel.cpp +++ b/libs/binder/tests/parcel_fuzzer/random_parcel.cpp @@ -18,6 +18,7 @@ #include <android-base/logging.h> #include <binder/IServiceManager.h> +#include <binder/RpcSession.h> #include <fuzzbinder/random_fd.h> #include <utils/String16.h> @@ -33,6 +34,14 @@ private: }; void fillRandomParcel(Parcel* p, FuzzedDataProvider&& provider) { + if (provider.ConsumeBool()) { + auto session = sp<RpcSession>::make(); + CHECK(session->addNullDebuggingClient()); + p->markForRpc(session); + fillRandomParcelData(p, std::move(provider)); + return; + } + while (provider.remaining_bytes() > 0) { auto fillFunc = provider.PickValueInArray<const std::function<void()>>({ // write data diff --git a/libs/binder/tests/rpc_fuzzer/main.cpp b/libs/binder/tests/rpc_fuzzer/main.cpp index 3603ebe41b..9fc496f460 100644 --- a/libs/binder/tests/rpc_fuzzer/main.cpp +++ b/libs/binder/tests/rpc_fuzzer/main.cpp @@ -13,13 +13,13 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -#include <android-base/file.h> #include <android-base/logging.h> #include <android-base/unique_fd.h> #include <binder/Binder.h> #include <binder/Parcel.h> #include <binder/RpcServer.h> #include <binder/RpcSession.h> +#include <fuzzer/FuzzedDataProvider.h> #include <sys/resource.h> #include <sys/un.h> @@ -29,20 +29,6 @@ namespace android { static const std::string kSock = std::string(getenv("TMPDIR") ?: "/tmp") + "/binderRpcFuzzerSocket_" + std::to_string(getpid()); -size_t getHardMemoryLimit() { - struct rlimit limit; - CHECK(0 == getrlimit(RLIMIT_AS, &limit)) << errno; - return limit.rlim_max; -} - -void setMemoryLimit(size_t cur, size_t max) { - const struct rlimit kLimit = { - .rlim_cur = cur, - .rlim_max = max, - }; - CHECK(0 == setrlimit(RLIMIT_AS, &kLimit)) << errno; -} - class SomeBinder : public BBinder { status_t onTransact(uint32_t code, const Parcel& data, Parcel* reply, uint32_t flags = 0) { (void)flags; @@ -67,6 +53,7 @@ class SomeBinder : public BBinder { extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size) { if (size > 50000) return 0; + FuzzedDataProvider provider(data, size); unlink(kSock.c_str()); @@ -75,11 +62,7 @@ extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size) { server->iUnderstandThisCodeIsExperimentalAndIWillNotUseItInProduction(); CHECK(server->setupUnixDomainServer(kSock.c_str())); - static constexpr size_t kMemLimit = 1llu * 1024 * 1024 * 1024; - size_t hardLimit = getHardMemoryLimit(); - setMemoryLimit(std::min(kMemLimit, hardLimit), hardLimit); - - std::thread serverThread([=] { (void)server->acceptOne(); }); + std::thread serverThread([=] { (void)server->join(); }); sockaddr_un addr{ .sun_family = AF_UNIX, @@ -87,33 +70,45 @@ extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size) { CHECK_LT(kSock.size(), sizeof(addr.sun_path)); memcpy(&addr.sun_path, kSock.c_str(), kSock.size()); - base::unique_fd clientFd(TEMP_FAILURE_RETRY(socket(AF_UNIX, SOCK_STREAM | SOCK_CLOEXEC, 0))); - CHECK_NE(clientFd.get(), -1); - CHECK_EQ(0, - TEMP_FAILURE_RETRY( - connect(clientFd.get(), reinterpret_cast<sockaddr*>(&addr), sizeof(addr)))) - << strerror(errno); - - serverThread.join(); - - // TODO(b/182938024): fuzz multiple sessions, instead of just one - -#if 0 - // make fuzzer more productive locally by forcing it to create a new session - int32_t id = -1; - CHECK(base::WriteFully(clientFd, &id, sizeof(id))); -#endif - - CHECK(base::WriteFully(clientFd, data, size)); - - clientFd.reset(); + std::vector<base::unique_fd> connections; + + bool hangupBeforeShutdown = provider.ConsumeBool(); + + while (provider.remaining_bytes() > 0) { + if (connections.empty() || provider.ConsumeBool()) { + base::unique_fd fd(TEMP_FAILURE_RETRY(socket(AF_UNIX, SOCK_STREAM | SOCK_CLOEXEC, 0))); + CHECK_NE(fd.get(), -1); + CHECK_EQ(0, + TEMP_FAILURE_RETRY( + connect(fd.get(), reinterpret_cast<sockaddr*>(&addr), sizeof(addr)))) + << strerror(errno); + connections.push_back(std::move(fd)); + } else { + size_t idx = provider.ConsumeIntegralInRange<size_t>(0, connections.size() - 1); + + if (provider.ConsumeBool()) { + std::vector<uint8_t> writeData = provider.ConsumeBytes<uint8_t>( + provider.ConsumeIntegralInRange<size_t>(0, provider.remaining_bytes())); + ssize_t size = TEMP_FAILURE_RETRY(send(connections.at(idx).get(), writeData.data(), + writeData.size(), MSG_NOSIGNAL)); + CHECK(errno == EPIPE || size == writeData.size()) + << size << " " << writeData.size() << " " << strerror(errno); + } else { + connections.erase(connections.begin() + idx); // hang up + } + } + } - // TODO(b/185167543): better way to force a server to shutdown - while (!server->listSessions().empty() && server->numUninitializedSessions()) { - usleep(1); + if (hangupBeforeShutdown) { + connections.clear(); + while (!server->listSessions().empty() && server->numUninitializedSessions()) { + // wait for all threads to finish processing existing information + usleep(1); + } } - setMemoryLimit(hardLimit, hardLimit); + while (!server->shutdown()) usleep(1); + serverThread.join(); return 0; } diff --git a/libs/binder/tests/unit_fuzzers/BinderFuzzFunctions.h b/libs/binder/tests/unit_fuzzers/BinderFuzzFunctions.h index 69f1b9dfb2..8d2b714b5c 100644 --- a/libs/binder/tests/unit_fuzzers/BinderFuzzFunctions.h +++ b/libs/binder/tests/unit_fuzzers/BinderFuzzFunctions.h @@ -72,6 +72,10 @@ static const std::vector<std::function<void(FuzzedDataProvider*, const sp<BBinde }, [](FuzzedDataProvider*, const sp<BBinder>& bbinder) -> void { bbinder->getDebugPid(); + }, + [](FuzzedDataProvider*, const sp<BBinder>& bbinder) -> void { + (void)bbinder->setRpcClientDebug(android::base::unique_fd(), + sp<BBinder>::make()); }}; } // namespace android diff --git a/libs/binder/tests/unit_fuzzers/StabilityFuzzFunctions.h b/libs/binder/tests/unit_fuzzers/StabilityFuzzFunctions.h index 8b4ed702af..371dcbd4bb 100644 --- a/libs/binder/tests/unit_fuzzers/StabilityFuzzFunctions.h +++ b/libs/binder/tests/unit_fuzzers/StabilityFuzzFunctions.h @@ -31,37 +31,27 @@ static bool marked = false; static const std::vector< std::function<void(FuzzedDataProvider*, android::sp<android::IBinder> const&)>> gStabilityOperations = { - // markCompilationUnit(IBinder* binder) [](FuzzedDataProvider*, android::sp<android::IBinder> const& bbinder) -> void { if (!marked) { android::internal::Stability::markCompilationUnit(bbinder.get()); marked = true; } }, - - // markVintf(IBinder* binder) [](FuzzedDataProvider*, android::sp<android::IBinder> const& bbinder) -> void { if (!marked) { android::internal::Stability::markVintf(bbinder.get()); marked = true; } }, - - // debugLogStability(const std::string& tag, const sp<IBinder>& binder) - [](FuzzedDataProvider* fdp, android::sp<android::IBinder> const& bbinder) -> void { - std::string tag = fdp->ConsumeRandomLengthString(STABILITY_MAX_TAG_LENGTH); - android::internal::Stability::debugLogStability(tag, bbinder); + [](FuzzedDataProvider*, android::sp<android::IBinder> const& bbinder) -> void { + (void)android::internal::Stability::debugToString(bbinder); }, - - // markVndk(IBinder* binder) [](FuzzedDataProvider*, android::sp<android::IBinder> const& bbinder) -> void { if (!marked) { android::internal::Stability::markVndk(bbinder.get()); marked = true; } }, - - // requiresVintfDeclaration(const sp<IBinder>& binder) [](FuzzedDataProvider*, android::sp<android::IBinder> const& bbinder) -> void { android::internal::Stability::requiresVintfDeclaration(bbinder); }}; diff --git a/libs/ftl/Android.bp b/libs/ftl/Android.bp index 97626bec7d..436620350a 100644 --- a/libs/ftl/Android.bp +++ b/libs/ftl/Android.bp @@ -14,10 +14,12 @@ cc_test { address: true, }, srcs: [ + "cast_test.cpp", "future_test.cpp", "small_map_test.cpp", "small_vector_test.cpp", "static_vector_test.cpp", + "string_test.cpp", ], cflags: [ "-Wall", diff --git a/libs/ftl/cast_test.cpp b/libs/ftl/cast_test.cpp new file mode 100644 index 0000000000..2abcb8fe66 --- /dev/null +++ b/libs/ftl/cast_test.cpp @@ -0,0 +1,200 @@ +/* + * Copyright 2021 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include <ftl/cast.h> +#include <gtest/gtest.h> + +#include <cfloat> +#include <cmath> +#include <limits> + +namespace android::test { + +using ftl::cast_safety; +using ftl::CastSafety; + +template <typename T> +constexpr T min = std::numeric_limits<T>::lowest(); + +template <typename T> +constexpr T max = std::numeric_limits<T>::max(); + +template <typename T> +constexpr T inf = std::numeric_limits<T>::infinity(); + +template <typename T> +constexpr T NaN = std::numeric_limits<T>::quiet_NaN(); + +// Keep in sync with example usage in header file. + +static_assert(cast_safety<uint8_t>(-1) == CastSafety::kUnderflow); +static_assert(cast_safety<int8_t>(128u) == CastSafety::kOverflow); + +static_assert(cast_safety<uint32_t>(-.1f) == CastSafety::kUnderflow); +static_assert(cast_safety<int32_t>(static_cast<float>(INT32_MAX)) == CastSafety::kOverflow); + +static_assert(cast_safety<float>(-DBL_MAX) == CastSafety::kUnderflow); + +// Unsigned to unsigned. + +static_assert(cast_safety<uint8_t>(0u) == CastSafety::kSafe); +static_assert(cast_safety<uint16_t>(max<uint8_t>) == CastSafety::kSafe); +static_assert(cast_safety<uint8_t>(static_cast<uint32_t>(max<uint8_t>)) == CastSafety::kSafe); + +static_assert(cast_safety<uint32_t>(max<uint64_t>) == CastSafety::kOverflow); +static_assert(cast_safety<uint8_t>(static_cast<uint32_t>(max<uint8_t>) + 1) == + CastSafety::kOverflow); + +// Unsigned to signed. + +static_assert(cast_safety<int16_t>(0u) == CastSafety::kSafe); +static_assert(cast_safety<int16_t>(max<uint8_t>) == CastSafety::kSafe); +static_assert(cast_safety<int16_t>(max<uint16_t>) == CastSafety::kOverflow); + +static_assert(cast_safety<int64_t>(static_cast<uint64_t>(max<int64_t>) - 1) == CastSafety::kSafe); +static_assert(cast_safety<int64_t>(static_cast<uint64_t>(max<int64_t>)) == CastSafety::kSafe); +static_assert(cast_safety<int64_t>(static_cast<uint64_t>(max<int64_t>) + 1) == + CastSafety::kOverflow); + +// Signed to unsigned. + +static_assert(cast_safety<uint16_t>(0) == CastSafety::kSafe); +static_assert(cast_safety<uint16_t>(max<int8_t>) == CastSafety::kSafe); +static_assert(cast_safety<uint16_t>(max<int16_t>) == CastSafety::kSafe); + +static_assert(cast_safety<uint32_t>(-1) == CastSafety::kUnderflow); +static_assert(cast_safety<uint32_t>(max<int64_t>) == CastSafety::kOverflow); + +static_assert(cast_safety<uint32_t>(static_cast<int64_t>(max<uint32_t>) - 1) == CastSafety::kSafe); +static_assert(cast_safety<uint32_t>(static_cast<int64_t>(max<uint32_t>)) == CastSafety::kSafe); +static_assert(cast_safety<uint32_t>(static_cast<int64_t>(max<uint32_t>) + 1) == + CastSafety::kOverflow); + +// Signed to signed. + +static_assert(cast_safety<int8_t>(-129) == CastSafety::kUnderflow); +static_assert(cast_safety<int8_t>(-128) == CastSafety::kSafe); +static_assert(cast_safety<int8_t>(127) == CastSafety::kSafe); +static_assert(cast_safety<int8_t>(128) == CastSafety::kOverflow); + +static_assert(cast_safety<int32_t>(static_cast<int64_t>(min<int32_t>)) == CastSafety::kSafe); +static_assert(cast_safety<int32_t>(static_cast<int64_t>(max<int32_t>)) == CastSafety::kSafe); + +static_assert(cast_safety<int16_t>(min<int32_t>) == CastSafety::kUnderflow); +static_assert(cast_safety<int32_t>(max<int64_t>) == CastSafety::kOverflow); + +// Float to float. + +static_assert(cast_safety<double>(max<float>) == CastSafety::kSafe); +static_assert(cast_safety<double>(min<float>) == CastSafety::kSafe); + +static_assert(cast_safety<float>(min<double>) == CastSafety::kUnderflow); +static_assert(cast_safety<float>(max<double>) == CastSafety::kOverflow); + +TEST(CastSafety, FloatToFloat) { + EXPECT_EQ(cast_safety<float>(std::nexttoward(static_cast<double>(min<float>), min<double>)), + CastSafety::kUnderflow); + EXPECT_EQ(cast_safety<float>(std::nexttoward(static_cast<double>(max<float>), max<double>)), + CastSafety::kOverflow); +} + +// Unsigned to float. + +static_assert(cast_safety<float>(0u) == CastSafety::kSafe); +static_assert(cast_safety<float>(max<uint64_t>) == CastSafety::kSafe); + +static_assert(cast_safety<double>(0u) == CastSafety::kSafe); +static_assert(cast_safety<double>(max<uint64_t>) == CastSafety::kSafe); + +// Signed to float. + +static_assert(cast_safety<float>(min<int64_t>) == CastSafety::kSafe); +static_assert(cast_safety<float>(max<int64_t>) == CastSafety::kSafe); + +static_assert(cast_safety<double>(min<int64_t>) == CastSafety::kSafe); +static_assert(cast_safety<double>(max<int64_t>) == CastSafety::kSafe); + +// Float to unsigned. + +static_assert(cast_safety<uint32_t>(0.f) == CastSafety::kSafe); +static_assert(cast_safety<uint32_t>(min<float>) == CastSafety::kUnderflow); +static_assert(cast_safety<uint32_t>(max<float>) == CastSafety::kOverflow); +static_assert(cast_safety<uint32_t>(-.1f) == CastSafety::kUnderflow); + +static_assert(cast_safety<uint16_t>(-inf<float>) == CastSafety::kUnderflow); +static_assert(cast_safety<uint32_t>(inf<float>) == CastSafety::kOverflow); +static_assert(cast_safety<uint64_t>(NaN<float>) == CastSafety::kOverflow); + +static_assert(cast_safety<uint32_t>(static_cast<float>(max<int32_t>)) == CastSafety::kSafe); +static_assert(cast_safety<uint32_t>(static_cast<float>(max<uint32_t>)) == CastSafety::kOverflow); +static_assert(cast_safety<uint32_t>(static_cast<double>(max<int32_t>)) == CastSafety::kSafe); +static_assert(cast_safety<uint32_t>(static_cast<double>(max<uint32_t>)) == CastSafety::kSafe); + +static_assert(cast_safety<uint64_t>(0.0) == CastSafety::kSafe); +static_assert(cast_safety<uint64_t>(min<double>) == CastSafety::kUnderflow); +static_assert(cast_safety<uint64_t>(max<double>) == CastSafety::kOverflow); +static_assert(cast_safety<uint64_t>(-.1) == CastSafety::kUnderflow); + +static_assert(cast_safety<uint64_t>(static_cast<float>(max<int64_t>)) == CastSafety::kSafe); +static_assert(cast_safety<uint64_t>(static_cast<float>(max<uint64_t>)) == CastSafety::kOverflow); +static_assert(cast_safety<uint64_t>(static_cast<double>(max<int64_t>)) == CastSafety::kSafe); +static_assert(cast_safety<uint64_t>(static_cast<double>(max<uint64_t>)) == CastSafety::kOverflow); + +// Float to signed. + +static_assert(cast_safety<int32_t>(0.f) == CastSafety::kSafe); +static_assert(cast_safety<int32_t>(min<float>) == CastSafety::kUnderflow); +static_assert(cast_safety<int32_t>(max<float>) == CastSafety::kOverflow); + +static_assert(cast_safety<int16_t>(-inf<double>) == CastSafety::kUnderflow); +static_assert(cast_safety<int32_t>(inf<double>) == CastSafety::kOverflow); +static_assert(cast_safety<int64_t>(NaN<double>) == CastSafety::kOverflow); + +static_assert(cast_safety<int32_t>(static_cast<float>(min<int32_t>)) == CastSafety::kSafe); +static_assert(cast_safety<int32_t>(static_cast<float>(max<int32_t>)) == CastSafety::kOverflow); +static_assert(cast_safety<int32_t>(static_cast<double>(min<int32_t>)) == CastSafety::kSafe); +static_assert(cast_safety<int32_t>(static_cast<double>(max<int32_t>)) == CastSafety::kSafe); + +static_assert(cast_safety<int64_t>(0.0) == CastSafety::kSafe); +static_assert(cast_safety<int64_t>(min<double>) == CastSafety::kUnderflow); +static_assert(cast_safety<int64_t>(max<double>) == CastSafety::kOverflow); + +static_assert(cast_safety<int64_t>(static_cast<float>(min<int64_t>)) == CastSafety::kSafe); +static_assert(cast_safety<int64_t>(static_cast<float>(max<int64_t>)) == CastSafety::kOverflow); +static_assert(cast_safety<int64_t>(static_cast<double>(min<int64_t>)) == CastSafety::kSafe); +static_assert(cast_safety<int64_t>(static_cast<double>(max<int64_t>)) == CastSafety::kOverflow); + +TEST(CastSafety, FloatToSigned) { + constexpr int32_t kMax = ftl::details::safe_limits<int32_t, float>::max(); + static_assert(kMax == 2'147'483'520); + EXPECT_EQ(kMax, static_cast<int32_t>(std::nexttowardf(max<int32_t>, 0))); + + EXPECT_EQ(cast_safety<int32_t>(std::nexttowardf(min<int32_t>, 0)), CastSafety::kSafe); + EXPECT_EQ(cast_safety<int32_t>(std::nexttowardf(max<int32_t>, 0)), CastSafety::kSafe); + EXPECT_EQ(cast_safety<int64_t>(std::nexttoward(min<int64_t>, 0)), CastSafety::kSafe); + EXPECT_EQ(cast_safety<int64_t>(std::nexttoward(max<int64_t>, 0)), CastSafety::kSafe); + + EXPECT_EQ(cast_safety<int32_t>(std::nexttowardf(min<int32_t>, min<float>)), + CastSafety::kUnderflow); + EXPECT_EQ(cast_safety<int32_t>(std::nexttowardf(max<int32_t>, max<float>)), + CastSafety::kOverflow); + EXPECT_EQ(cast_safety<int64_t>(std::nexttoward(min<int64_t>, min<double>)), + CastSafety::kUnderflow); + EXPECT_EQ(cast_safety<int64_t>(std::nexttoward(max<int64_t>, max<double>)), + CastSafety::kOverflow); +} + +} // namespace android::test diff --git a/libs/ftl/small_map_test.cpp b/libs/ftl/small_map_test.cpp index 323b9f91e7..2e81022f38 100644 --- a/libs/ftl/small_map_test.cpp +++ b/libs/ftl/small_map_test.cpp @@ -18,6 +18,9 @@ #include <gtest/gtest.h> #include <cctype> +#include <string> + +using namespace std::string_literals; namespace android::test { @@ -35,16 +38,19 @@ TEST(SmallMap, Example) { EXPECT_TRUE(map.contains(123)); - EXPECT_EQ(map.find(42, [](const std::string& s) { return s.size(); }), 3u); + EXPECT_EQ(map.get(42, [](const std::string& s) { return s.size(); }), 3u); - const auto opt = map.find(-1); + const auto opt = map.get(-1); ASSERT_TRUE(opt); std::string& ref = *opt; EXPECT_TRUE(ref.empty()); ref = "xyz"; - EXPECT_EQ(map, SmallMap(ftl::init::map(-1, "xyz")(42, "???")(123, "abc"))); + map.emplace_or_replace(0, "vanilla", 2u, 3u); + EXPECT_TRUE(map.dynamic()); + + EXPECT_EQ(map, SmallMap(ftl::init::map(-1, "xyz")(0, "nil")(42, "???")(123, "abc"))); } TEST(SmallMap, Construct) { @@ -90,42 +96,253 @@ TEST(SmallMap, Construct) { } } +TEST(SmallMap, UniqueKeys) { + { + // Duplicate mappings are discarded. + const SmallMap map = ftl::init::map<int, float>(1)(2)(3)(2)(3)(1)(3)(2)(1); + + EXPECT_EQ(map.size(), 3u); + EXPECT_EQ(map.max_size(), 9u); + + using Map = decltype(map); + EXPECT_EQ(map, Map(ftl::init::map(1, 0.f)(2, 0.f)(3, 0.f))); + } + { + // Duplicate mappings may be reordered. + const SmallMap map = ftl::init::map('a', 'A')( + 'b', 'B')('b')('b')('c', 'C')('a')('d')('c')('e', 'E')('d', 'D')('a')('f', 'F'); + + EXPECT_EQ(map.size(), 6u); + EXPECT_EQ(map.max_size(), 12u); + + using Map = decltype(map); + EXPECT_EQ(map, Map(ftl::init::map('a', 'A')('b', 'B')('c', 'C')('d', 'D')('e', 'E')('f', 'F'))); + } +} + TEST(SmallMap, Find) { { // Constant reference. - const ftl::SmallMap map = ftl::init::map('a', 'A')('b', 'B')('c', 'C'); + const SmallMap map = ftl::init::map('a', 'A')('b', 'B')('c', 'C'); - const auto opt = map.find('b'); + const auto opt = map.get('b'); EXPECT_EQ(opt, 'B'); const char d = 'D'; - const auto ref = map.find('d').value_or(std::cref(d)); + const auto ref = map.get('d').value_or(std::cref(d)); EXPECT_EQ(ref.get(), 'D'); } { // Mutable reference. - ftl::SmallMap map = ftl::init::map('a', 'A')('b', 'B')('c', 'C'); + SmallMap map = ftl::init::map('a', 'A')('b', 'B')('c', 'C'); - const auto opt = map.find('c'); + const auto opt = map.get('c'); EXPECT_EQ(opt, 'C'); char d = 'd'; - const auto ref = map.find('d').value_or(std::ref(d)); + const auto ref = map.get('d').value_or(std::ref(d)); ref.get() = 'D'; EXPECT_EQ(d, 'D'); } { // Constant unary operation. - const ftl::SmallMap map = ftl::init::map('a', 'x')('b', 'y')('c', 'z'); - EXPECT_EQ(map.find('c', [](char c) { return std::toupper(c); }), 'Z'); + const SmallMap map = ftl::init::map('a', 'x')('b', 'y')('c', 'z'); + EXPECT_EQ(map.get('c', [](char c) { return std::toupper(c); }), 'Z'); } { // Mutable unary operation. - ftl::SmallMap map = ftl::init::map('a', 'x')('b', 'y')('c', 'z'); - EXPECT_TRUE(map.find('c', [](char& c) { c = std::toupper(c); })); + SmallMap map = ftl::init::map('a', 'x')('b', 'y')('c', 'z'); + EXPECT_TRUE(map.get('c', [](char& c) { c = std::toupper(c); })); EXPECT_EQ(map, SmallMap(ftl::init::map('c', 'Z')('b', 'y')('a', 'x'))); } } +TEST(SmallMap, TryEmplace) { + SmallMap<int, std::string, 3> map; + using Pair = decltype(map)::value_type; + + { + const auto [it, ok] = map.try_emplace(123, "abc"); + ASSERT_TRUE(ok); + EXPECT_EQ(*it, Pair(123, "abc"s)); + } + { + const auto [it, ok] = map.try_emplace(42, 3u, '?'); + ASSERT_TRUE(ok); + EXPECT_EQ(*it, Pair(42, "???"s)); + } + { + const auto [it, ok] = map.try_emplace(-1); + ASSERT_TRUE(ok); + EXPECT_EQ(*it, Pair(-1, std::string())); + EXPECT_FALSE(map.dynamic()); + } + { + // Insertion fails if mapping exists. + const auto [it, ok] = map.try_emplace(42, "!!!"); + EXPECT_FALSE(ok); + EXPECT_EQ(*it, Pair(42, "???")); + EXPECT_FALSE(map.dynamic()); + } + { + // Insertion at capacity promotes the map. + const auto [it, ok] = map.try_emplace(999, "xyz"); + ASSERT_TRUE(ok); + EXPECT_EQ(*it, Pair(999, "xyz")); + EXPECT_TRUE(map.dynamic()); + } + + EXPECT_EQ(map, SmallMap(ftl::init::map(-1, ""s)(42, "???"s)(123, "abc"s)(999, "xyz"s))); +} + +namespace { + +// The mapped type does not require a copy/move assignment operator. +struct String { + template <typename... Args> + String(Args... args) : str(args...) {} + const std::string str; + + bool operator==(const String& other) const { return other.str == str; } +}; + +} // namespace + +TEST(SmallMap, TryReplace) { + SmallMap<int, String, 3> map = ftl::init::map(1, "a")(2, "B"); + using Pair = decltype(map)::value_type; + + { + // Replacing fails unless mapping exists. + const auto it = map.try_replace(3, "c"); + EXPECT_EQ(it, map.end()); + } + { + // Replacement arguments can refer to the replaced mapping. + const auto ref = map.get(2, [](const auto& s) { return s.str[0]; }); + ASSERT_TRUE(ref); + + // Construct std::string from one character. + const auto it = map.try_replace(2, 1u, static_cast<char>(std::tolower(*ref))); + ASSERT_NE(it, map.end()); + EXPECT_EQ(*it, Pair(2, "b")); + } + + EXPECT_FALSE(map.dynamic()); + EXPECT_TRUE(map.try_emplace(3, "abc").second); + EXPECT_TRUE(map.try_emplace(4, "d").second); + EXPECT_TRUE(map.dynamic()); + + { + // Replacing fails unless mapping exists. + const auto it = map.try_replace(5, "e"); + EXPECT_EQ(it, map.end()); + } + { + // Replacement arguments can refer to the replaced mapping. + const auto ref = map.get(3); + ASSERT_TRUE(ref); + + // Construct std::string from substring. + const auto it = map.try_replace(3, ref->get().str, 2u, 1u); + ASSERT_NE(it, map.end()); + EXPECT_EQ(*it, Pair(3, "c")); + } + + EXPECT_EQ(map, SmallMap(ftl::init::map(4, "d"s)(3, "c"s)(2, "b"s)(1, "a"s))); +} + +TEST(SmallMap, EmplaceOrReplace) { + SmallMap<int, String, 3> map = ftl::init::map(1, "a")(2, "B"); + using Pair = decltype(map)::value_type; + + { + // New mapping is emplaced. + const auto [it, emplace] = map.emplace_or_replace(3, "c"); + EXPECT_TRUE(emplace); + EXPECT_EQ(*it, Pair(3, "c")); + } + { + // Replacement arguments can refer to the replaced mapping. + const auto ref = map.get(2, [](const auto& s) { return s.str[0]; }); + ASSERT_TRUE(ref); + + // Construct std::string from one character. + const auto [it, emplace] = map.emplace_or_replace(2, 1u, static_cast<char>(std::tolower(*ref))); + EXPECT_FALSE(emplace); + EXPECT_EQ(*it, Pair(2, "b")); + } + + EXPECT_FALSE(map.dynamic()); + EXPECT_FALSE(map.emplace_or_replace(3, "abc").second); // Replace. + EXPECT_TRUE(map.emplace_or_replace(4, "d").second); // Emplace. + EXPECT_TRUE(map.dynamic()); + + { + // New mapping is emplaced. + const auto [it, emplace] = map.emplace_or_replace(5, "e"); + EXPECT_TRUE(emplace); + EXPECT_EQ(*it, Pair(5, "e")); + } + { + // Replacement arguments can refer to the replaced mapping. + const auto ref = map.get(3); + ASSERT_TRUE(ref); + + // Construct std::string from substring. + const auto [it, emplace] = map.emplace_or_replace(3, ref->get().str, 2u, 1u); + EXPECT_FALSE(emplace); + EXPECT_EQ(*it, Pair(3, "c")); + } + + EXPECT_EQ(map, SmallMap(ftl::init::map(5, "e"s)(4, "d"s)(3, "c"s)(2, "b"s)(1, "a"s))); +} + +TEST(SmallMap, Erase) { + { + SmallMap map = ftl::init::map(1, '1')(2, '2')(3, '3')(4, '4'); + EXPECT_FALSE(map.dynamic()); + + EXPECT_FALSE(map.erase(0)); // Key not found. + + EXPECT_TRUE(map.erase(2)); + EXPECT_EQ(map, SmallMap(ftl::init::map(1, '1')(3, '3')(4, '4'))); + + EXPECT_TRUE(map.erase(1)); + EXPECT_EQ(map, SmallMap(ftl::init::map(3, '3')(4, '4'))); + + EXPECT_TRUE(map.erase(4)); + EXPECT_EQ(map, SmallMap(ftl::init::map(3, '3'))); + + EXPECT_TRUE(map.erase(3)); + EXPECT_FALSE(map.erase(3)); // Key not found. + + EXPECT_TRUE(map.empty()); + EXPECT_FALSE(map.dynamic()); + } + { + SmallMap map = ftl::init::map(1, '1')(2, '2')(3, '3'); + map.try_emplace(4, '4'); + EXPECT_TRUE(map.dynamic()); + + EXPECT_FALSE(map.erase(0)); // Key not found. + + EXPECT_TRUE(map.erase(2)); + EXPECT_EQ(map, SmallMap(ftl::init::map(1, '1')(3, '3')(4, '4'))); + + EXPECT_TRUE(map.erase(1)); + EXPECT_EQ(map, SmallMap(ftl::init::map(3, '3')(4, '4'))); + + EXPECT_TRUE(map.erase(4)); + EXPECT_EQ(map, SmallMap(ftl::init::map(3, '3'))); + + EXPECT_TRUE(map.erase(3)); + EXPECT_FALSE(map.erase(3)); // Key not found. + + EXPECT_TRUE(map.empty()); + EXPECT_TRUE(map.dynamic()); + } +} + } // namespace android::test diff --git a/libs/ftl/string_test.cpp b/libs/ftl/string_test.cpp new file mode 100644 index 0000000000..f3d85c8319 --- /dev/null +++ b/libs/ftl/string_test.cpp @@ -0,0 +1,187 @@ +/* + * Copyright 2021 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include <ftl/string.h> +#include <gtest/gtest.h> + +#include <algorithm> +#include <cstdint> +#include <iterator> +#include <limits> +#include <sstream> +#include <type_traits> + +namespace android::test { + +// Keep in sync with example usage in header file. +TEST(String, ToChars) { + ftl::to_chars_buffer_t<> buffer; + + EXPECT_EQ(ftl::to_chars(buffer, 123u), "123"); + EXPECT_EQ(ftl::to_chars(buffer, -42, ftl::Radix::kBin), "-0b101010"); + EXPECT_EQ(ftl::to_chars(buffer, 0xcafe, ftl::Radix::kHex), "0xcafe"); + EXPECT_EQ(ftl::to_chars(buffer, '*', ftl::Radix::kHex), "0x2a"); +} + +namespace { + +template <typename F, typename T> +void ToCharsTest() { + constexpr auto kRadix = F::kRadix; + + using Limits = std::numeric_limits<T>; + constexpr auto kMin = Limits::min(); + constexpr auto kMax = Limits::max(); + constexpr auto kNeg = static_cast<T>(-42); + constexpr auto kPos = static_cast<T>(123); + + ftl::to_chars_buffer_t<T> buffer; + + EXPECT_EQ(ftl::to_chars(buffer, kMin, kRadix), F{}(kMin)); + EXPECT_EQ(ftl::to_chars(buffer, kMax, kRadix), F{}(kMax)); + EXPECT_EQ(ftl::to_chars(buffer, kNeg, kRadix), F{}(kNeg)); + EXPECT_EQ(ftl::to_chars(buffer, kPos, kRadix), F{}(kPos)); +} + +template <typename...> +struct Types {}; + +template <typename F, typename Types> +struct ToCharsTests; + +template <typename F, typename T, typename... Ts> +struct ToCharsTests<F, Types<T, Ts...>> { + static void test() { + ToCharsTest<F, T>(); + ToCharsTests<F, Types<Ts...>>::test(); + } +}; + +template <typename F> +struct ToCharsTests<F, Types<>> { + static void test() {} +}; + +template <typename T, typename U = std::make_unsigned_t<T>> +U to_unsigned(std::ostream& stream, T v) { + if (std::is_same_v<T, U>) return v; + + if (v < 0) { + stream << '-'; + return std::numeric_limits<U>::max() - static_cast<U>(v) + 1; + } else { + return static_cast<U>(v); + } +} + +struct Bin { + static constexpr auto kRadix = ftl::Radix::kBin; + + template <typename T> + std::string operator()(T v) const { + std::ostringstream stream; + auto u = to_unsigned(stream, v); + stream << "0b"; + + if (u == 0) { + stream << 0; + } else { + std::ostringstream digits; + do { + digits << (u & 1); + } while (u >>= 1); + + const auto str = digits.str(); + std::copy(str.rbegin(), str.rend(), std::ostream_iterator<char>(stream)); + } + + return stream.str(); + } +}; + +struct Dec { + static constexpr auto kRadix = ftl::Radix::kDec; + + template <typename T> + std::string operator()(T v) const { + return std::to_string(v); + } +}; + +struct Hex { + static constexpr auto kRadix = ftl::Radix::kHex; + + template <typename T> + std::string operator()(T v) const { + std::ostringstream stream; + const auto u = to_unsigned(stream, v); + stream << "0x" << std::hex << std::nouppercase; + stream << (sizeof(T) == 1 ? static_cast<unsigned>(u) : u); + return stream.str(); + } +}; + +using IntegerTypes = + Types<char, unsigned char, signed char, std::uint8_t, std::uint16_t, std::uint32_t, + std::uint64_t, std::int8_t, std::int16_t, std::int32_t, std::int64_t>; + +} // namespace + +TEST(String, ToCharsBin) { + ToCharsTests<Bin, IntegerTypes>::test(); + + { + const std::uint8_t x = 0b1111'1111; + ftl::to_chars_buffer_t<decltype(x)> buffer; + EXPECT_EQ(ftl::to_chars(buffer, x, ftl::Radix::kBin), "0b11111111"); + } + { + const std::int16_t x = -0b1000'0000'0000'0000; + ftl::to_chars_buffer_t<decltype(x)> buffer; + EXPECT_EQ(ftl::to_chars(buffer, x, ftl::Radix::kBin), "-0b1000000000000000"); + } +} + +TEST(String, ToCharsDec) { + ToCharsTests<Dec, IntegerTypes>::test(); + + { + const std::uint32_t x = UINT32_MAX; + ftl::to_chars_buffer_t<decltype(x)> buffer; + EXPECT_EQ(ftl::to_chars(buffer, x), "4294967295"); + } + { + const std::int32_t x = INT32_MIN; + ftl::to_chars_buffer_t<decltype(x)> buffer; + EXPECT_EQ(ftl::to_chars(buffer, x), "-2147483648"); + } +} + +TEST(String, ToCharsHex) { + ToCharsTests<Hex, IntegerTypes>::test(); + + { + const std::uint16_t x = 0xfade; + ftl::to_chars_buffer_t<decltype(x)> buffer; + EXPECT_EQ(ftl::to_chars(buffer, x, ftl::Radix::kHex), "0xfade"); + } + { + ftl::to_chars_buffer_t<> buffer; + EXPECT_EQ(ftl::to_chars(buffer, INT64_MIN, ftl::Radix::kHex), "-0x8000000000000000"); + } +} + +} // namespace android::test diff --git a/libs/gui/ISurfaceComposer.cpp b/libs/gui/ISurfaceComposer.cpp index 0d7795e1ba..bab9ebf618 100644 --- a/libs/gui/ISurfaceComposer.cpp +++ b/libs/gui/ISurfaceComposer.cpp @@ -123,11 +123,11 @@ public: return remote()->transact(BnSurfaceComposer::CAPTURE_DISPLAY, data, &reply); } - status_t captureDisplay(uint64_t displayOrLayerStack, + status_t captureDisplay(DisplayId displayId, const sp<IScreenCaptureListener>& captureListener) override { Parcel data, reply; data.writeInterfaceToken(ISurfaceComposer::getInterfaceDescriptor()); - SAFE_PARCEL(data.writeUint64, displayOrLayerStack); + SAFE_PARCEL(data.writeUint64, displayId.value); SAFE_PARCEL(data.writeStrongBinder, IInterface::asBinder(captureListener)); return remote()->transact(BnSurfaceComposer::CAPTURE_DISPLAY_BY_ID, data, &reply); @@ -281,9 +281,14 @@ public: NO_ERROR) { std::vector<uint64_t> rawIds; if (reply.readUint64Vector(&rawIds) == NO_ERROR) { - std::vector<PhysicalDisplayId> displayIds(rawIds.size()); - std::transform(rawIds.begin(), rawIds.end(), displayIds.begin(), - [](uint64_t rawId) { return PhysicalDisplayId(rawId); }); + std::vector<PhysicalDisplayId> displayIds; + displayIds.reserve(rawIds.size()); + + for (const uint64_t rawId : rawIds) { + if (const auto id = DisplayId::fromValue<PhysicalDisplayId>(rawId)) { + displayIds.push_back(*id); + } + } return displayIds; } } @@ -1327,12 +1332,15 @@ status_t BnSurfaceComposer::onTransact( } case CAPTURE_DISPLAY_BY_ID: { CHECK_INTERFACE(ISurfaceComposer, data, reply); - uint64_t displayOrLayerStack = 0; + uint64_t value; + SAFE_PARCEL(data.readUint64, &value); + const auto id = DisplayId::fromValue(value); + if (!id) return BAD_VALUE; + sp<IScreenCaptureListener> captureListener; - SAFE_PARCEL(data.readUint64, &displayOrLayerStack); SAFE_PARCEL(data.readStrongBinder, &captureListener); - return captureDisplay(displayOrLayerStack, captureListener); + return captureDisplay(*id, captureListener); } case CAPTURE_LAYERS: { CHECK_INTERFACE(ISurfaceComposer, data, reply); @@ -1399,9 +1407,9 @@ status_t BnSurfaceComposer::onTransact( } case GET_PHYSICAL_DISPLAY_TOKEN: { CHECK_INTERFACE(ISurfaceComposer, data, reply); - PhysicalDisplayId displayId(data.readUint64()); - sp<IBinder> display = getPhysicalDisplayToken(displayId); - reply->writeStrongBinder(display); + const auto id = DisplayId::fromValue<PhysicalDisplayId>(data.readUint64()); + if (!id) return BAD_VALUE; + reply->writeStrongBinder(getPhysicalDisplayToken(*id)); return NO_ERROR; } case GET_DISPLAY_STATE: { diff --git a/libs/gui/LayerState.cpp b/libs/gui/LayerState.cpp index e65c721ae1..d102e07623 100644 --- a/libs/gui/LayerState.cpp +++ b/libs/gui/LayerState.cpp @@ -315,6 +315,7 @@ status_t ComposerState::read(const Parcel& input) { DisplayState::DisplayState() : what(0), layerStack(0), + flags(0), layerStackSpaceRect(Rect::EMPTY_RECT), orientedDisplaySpaceRect(Rect::EMPTY_RECT), width(0), @@ -325,6 +326,7 @@ status_t DisplayState::write(Parcel& output) const { SAFE_PARCEL(output.writeStrongBinder, IInterface::asBinder(surface)); SAFE_PARCEL(output.writeUint32, what); SAFE_PARCEL(output.writeUint32, layerStack); + SAFE_PARCEL(output.writeUint32, flags); SAFE_PARCEL(output.writeUint32, toRotationInt(orientation)); SAFE_PARCEL(output.write, layerStackSpaceRect); SAFE_PARCEL(output.write, orientedDisplaySpaceRect); @@ -341,6 +343,7 @@ status_t DisplayState::read(const Parcel& input) { SAFE_PARCEL(input.readUint32, &what); SAFE_PARCEL(input.readUint32, &layerStack); + SAFE_PARCEL(input.readUint32, &flags); uint32_t tmpUint = 0; SAFE_PARCEL(input.readUint32, &tmpUint); orientation = ui::toRotation(tmpUint); @@ -361,6 +364,10 @@ void DisplayState::merge(const DisplayState& other) { what |= eLayerStackChanged; layerStack = other.layerStack; } + if (other.what & eFlagsChanged) { + what |= eFlagsChanged; + flags = other.flags; + } if (other.what & eDisplayProjectionChanged) { what |= eDisplayProjectionChanged; orientation = other.orientation; diff --git a/libs/gui/SurfaceComposerClient.cpp b/libs/gui/SurfaceComposerClient.cpp index c69435d328..cf9afa1414 100644 --- a/libs/gui/SurfaceComposerClient.cpp +++ b/libs/gui/SurfaceComposerClient.cpp @@ -1741,6 +1741,12 @@ void SurfaceComposerClient::Transaction::setDisplayLayerStack(const sp<IBinder>& s.what |= DisplayState::eLayerStackChanged; } +void SurfaceComposerClient::Transaction::setDisplayFlags(const sp<IBinder>& token, uint32_t flags) { + DisplayState& s(getDisplayState(token)); + s.flags = flags; + s.what |= DisplayState::eFlagsChanged; +} + void SurfaceComposerClient::Transaction::setDisplayProjection(const sp<IBinder>& token, ui::Rotation orientation, const Rect& layerStackRect, @@ -2146,12 +2152,12 @@ status_t ScreenshotClient::captureDisplay(const DisplayCaptureArgs& captureArgs, return s->captureDisplay(captureArgs, captureListener); } -status_t ScreenshotClient::captureDisplay(uint64_t displayOrLayerStack, +status_t ScreenshotClient::captureDisplay(DisplayId displayId, const sp<IScreenCaptureListener>& captureListener) { sp<ISurfaceComposer> s(ComposerService::getComposerService()); if (s == nullptr) return NO_INIT; - return s->captureDisplay(displayOrLayerStack, captureListener); + return s->captureDisplay(displayId, captureListener); } status_t ScreenshotClient::captureLayers(const LayerCaptureArgs& captureArgs, diff --git a/libs/gui/include/gui/ISurfaceComposer.h b/libs/gui/include/gui/ISurfaceComposer.h index 2a3f6a43d9..8ec7e6d630 100644 --- a/libs/gui/include/gui/ISurfaceComposer.h +++ b/libs/gui/include/gui/ISurfaceComposer.h @@ -115,6 +115,11 @@ public: using EventRegistrationFlags = Flags<EventRegistration>; + template <typename T> + struct SpHash { + size_t operator()(const sp<T>& k) const { return std::hash<T*>()(k.get()); } + }; + /* * Create a connection with SurfaceFlinger. */ @@ -238,24 +243,17 @@ public: * The subregion can be optionally rotated. It will also be scaled to * match the size of the output buffer. */ - virtual status_t captureDisplay(const DisplayCaptureArgs& args, - const sp<IScreenCaptureListener>& captureListener) = 0; + virtual status_t captureDisplay(const DisplayCaptureArgs&, + const sp<IScreenCaptureListener>&) = 0; - virtual status_t captureDisplay(uint64_t displayOrLayerStack, - const sp<IScreenCaptureListener>& captureListener) = 0; - - template <class AA> - struct SpHash { - size_t operator()(const sp<AA>& k) const { return std::hash<AA*>()(k.get()); } - }; + virtual status_t captureDisplay(DisplayId, const sp<IScreenCaptureListener>&) = 0; /** * Capture a subtree of the layer hierarchy, potentially ignoring the root node. * This requires READ_FRAME_BUFFER permission. This function will fail if there * is a secure window on screen */ - virtual status_t captureLayers(const LayerCaptureArgs& args, - const sp<IScreenCaptureListener>& captureListener) = 0; + virtual status_t captureLayers(const LayerCaptureArgs&, const sp<IScreenCaptureListener>&) = 0; /* Clears the frame statistics for animations. * diff --git a/libs/gui/include/gui/LayerState.h b/libs/gui/include/gui/LayerState.h index 16430b324d..869c082ab1 100644 --- a/libs/gui/include/gui/LayerState.h +++ b/libs/gui/include/gui/LayerState.h @@ -247,7 +247,8 @@ struct DisplayState { eSurfaceChanged = 0x01, eLayerStackChanged = 0x02, eDisplayProjectionChanged = 0x04, - eDisplaySizeChanged = 0x08 + eDisplaySizeChanged = 0x08, + eFlagsChanged = 0x10 }; DisplayState(); @@ -257,6 +258,7 @@ struct DisplayState { sp<IBinder> token; sp<IGraphicBufferProducer> surface; uint32_t layerStack; + uint32_t flags; // These states define how layers are projected onto the physical display. // diff --git a/libs/gui/include/gui/SurfaceComposerClient.h b/libs/gui/include/gui/SurfaceComposerClient.h index fa91bfa010..35ea10c80b 100644 --- a/libs/gui/include/gui/SurfaceComposerClient.h +++ b/libs/gui/include/gui/SurfaceComposerClient.h @@ -564,6 +564,8 @@ public: void setDisplayLayerStack(const sp<IBinder>& token, uint32_t layerStack); + void setDisplayFlags(const sp<IBinder>& token, uint32_t flags); + /* setDisplayProjection() defines the projection of layer stacks * to a given display. * @@ -629,12 +631,9 @@ private: class ScreenshotClient { public: - static status_t captureDisplay(const DisplayCaptureArgs& captureArgs, - const sp<IScreenCaptureListener>& captureListener); - static status_t captureDisplay(uint64_t displayOrLayerStack, - const sp<IScreenCaptureListener>& captureListener); - static status_t captureLayers(const LayerCaptureArgs& captureArgs, - const sp<IScreenCaptureListener>& captureListener); + static status_t captureDisplay(const DisplayCaptureArgs&, const sp<IScreenCaptureListener>&); + static status_t captureDisplay(DisplayId, const sp<IScreenCaptureListener>&); + static status_t captureLayers(const LayerCaptureArgs&, const sp<IScreenCaptureListener>&); }; // --------------------------------------------------------------------------- diff --git a/libs/gui/tests/Surface_test.cpp b/libs/gui/tests/Surface_test.cpp index 59b0c04bc3..8d7a3564e8 100644 --- a/libs/gui/tests/Surface_test.cpp +++ b/libs/gui/tests/Surface_test.cpp @@ -752,21 +752,19 @@ public: } status_t setActiveColorMode(const sp<IBinder>& /*display*/, ColorMode /*colorMode*/) override { return NO_ERROR; } - status_t captureDisplay(const DisplayCaptureArgs& /* captureArgs */, - const sp<IScreenCaptureListener>& /* captureListener */) override { - return NO_ERROR; - } void setAutoLowLatencyMode(const sp<IBinder>& /*display*/, bool /*on*/) override {} void setGameContentType(const sp<IBinder>& /*display*/, bool /*on*/) override {} - status_t captureDisplay(uint64_t /*displayOrLayerStack*/, - const sp<IScreenCaptureListener>& /* captureListener */) override { + + status_t captureDisplay(const DisplayCaptureArgs&, const sp<IScreenCaptureListener>&) override { return NO_ERROR; } - virtual status_t captureLayers( - const LayerCaptureArgs& /* captureArgs */, - const sp<IScreenCaptureListener>& /* captureListener */) override { + status_t captureDisplay(DisplayId, const sp<IScreenCaptureListener>&) override { return NO_ERROR; } + status_t captureLayers(const LayerCaptureArgs&, const sp<IScreenCaptureListener>&) override { + return NO_ERROR; + } + status_t clearAnimationFrameStats() override { return NO_ERROR; } status_t getAnimationFrameStats(FrameStats* /*outStats*/) const override { return NO_ERROR; diff --git a/libs/input/Input.cpp b/libs/input/Input.cpp index 70ed438112..124331fef1 100644 --- a/libs/input/Input.cpp +++ b/libs/input/Input.cpp @@ -307,10 +307,6 @@ void PointerCoords::scale(float globalScaleFactor, float windowXScale, float win scaleAxisValue(*this, AMOTION_EVENT_AXIS_TOOL_MINOR, globalScaleFactor); } -void PointerCoords::scale(float globalScaleFactor) { - scale(globalScaleFactor, globalScaleFactor, globalScaleFactor); -} - void PointerCoords::applyOffset(float xOffset, float yOffset) { setAxisValue(AMOTION_EVENT_AXIS_X, getX() + xOffset); setAxisValue(AMOTION_EVENT_AXIS_Y, getY() + yOffset); diff --git a/libs/nativedisplay/AChoreographer.cpp b/libs/nativedisplay/AChoreographer.cpp index 0edb213089..e7bd977876 100644 --- a/libs/nativedisplay/AChoreographer.cpp +++ b/libs/nativedisplay/AChoreographer.cpp @@ -306,8 +306,9 @@ void Choreographer::scheduleLatestConfigRequest() { // Fortunately, these events are small so sending packets across the // socket should be atomic across processes. DisplayEventReceiver::Event event; - event.header = DisplayEventReceiver::Event::Header{DisplayEventReceiver::DISPLAY_EVENT_NULL, - PhysicalDisplayId(0), systemTime()}; + event.header = + DisplayEventReceiver::Event::Header{DisplayEventReceiver::DISPLAY_EVENT_NULL, + PhysicalDisplayId::fromPort(0), systemTime()}; injectEvent(event); } } diff --git a/libs/nativewindow/include/android/hardware_buffer.h b/libs/nativewindow/include/android/hardware_buffer.h index d93a84cd25..d5e7cb299b 100644 --- a/libs/nativewindow/include/android/hardware_buffer.h +++ b/libs/nativewindow/include/android/hardware_buffer.h @@ -556,6 +556,7 @@ int AHardwareBuffer_lockAndGetInfo(AHardwareBuffer* _Nonnull buffer, uint64_t us int32_t* _Nonnull outBytesPerPixel, int32_t* _Nonnull outBytesPerStride) __INTRODUCED_IN(29); + /** * Get the system wide unique id for an AHardwareBuffer. * diff --git a/libs/ui/Android.bp b/libs/ui/Android.bp index 74d17ced74..5a118eccd3 100644 --- a/libs/ui/Android.bp +++ b/libs/ui/Android.bp @@ -137,7 +137,6 @@ cc_library_shared { "HdrCapabilities.cpp", "PixelFormat.cpp", "PublicFormat.cpp", - "Size.cpp", "StaticDisplayInfo.cpp", ], diff --git a/libs/ui/include/ui/DisplayId.h b/libs/ui/include/ui/DisplayId.h index f196ab901a..9120972a42 100644 --- a/libs/ui/include/ui/DisplayId.h +++ b/libs/ui/include/ui/DisplayId.h @@ -38,12 +38,22 @@ struct DisplayId { uint64_t value; + // For deserialization. + static constexpr std::optional<DisplayId> fromValue(uint64_t); + + // As above, but also upcast to Id. + template <typename Id> + static constexpr std::optional<Id> fromValue(uint64_t value) { + if (const auto id = Id::tryCast(DisplayId(value))) { + return id; + } + return {}; + } + protected: explicit constexpr DisplayId(uint64_t id) : value(id) {} }; -static_assert(sizeof(DisplayId) == sizeof(uint64_t)); - inline bool operator==(DisplayId lhs, DisplayId rhs) { return lhs.value == rhs.value; } @@ -80,11 +90,8 @@ struct PhysicalDisplayId : DisplayId { // TODO(b/162612135) Remove default constructor PhysicalDisplayId() = default; - // TODO(b/162612135) Remove constructor - explicit constexpr PhysicalDisplayId(uint64_t id) : DisplayId(id) {} constexpr uint16_t getManufacturerId() const { return static_cast<uint16_t>(value >> 40); } - constexpr uint8_t getPort() const { return static_cast<uint8_t>(value); } private: @@ -96,10 +103,9 @@ private: explicit constexpr PhysicalDisplayId(DisplayId other) : DisplayId(other) {} }; -static_assert(sizeof(PhysicalDisplayId) == sizeof(uint64_t)); - struct VirtualDisplayId : DisplayId { using BaseId = uint32_t; + // Flag indicating that this virtual display is backed by the GPU. static constexpr uint64_t FLAG_GPU = 1ULL << 61; @@ -163,10 +169,23 @@ private: explicit constexpr HalDisplayId(DisplayId other) : DisplayId(other) {} }; +constexpr std::optional<DisplayId> DisplayId::fromValue(uint64_t value) { + if (const auto id = fromValue<PhysicalDisplayId>(value)) { + return id; + } + if (const auto id = fromValue<VirtualDisplayId>(value)) { + return id; + } + return {}; +} + +static_assert(sizeof(DisplayId) == sizeof(uint64_t)); +static_assert(sizeof(HalDisplayId) == sizeof(uint64_t)); static_assert(sizeof(VirtualDisplayId) == sizeof(uint64_t)); + +static_assert(sizeof(PhysicalDisplayId) == sizeof(uint64_t)); static_assert(sizeof(HalVirtualDisplayId) == sizeof(uint64_t)); static_assert(sizeof(GpuVirtualDisplayId) == sizeof(uint64_t)); -static_assert(sizeof(HalDisplayId) == sizeof(uint64_t)); } // namespace android diff --git a/libs/ui/include/ui/Size.h b/libs/ui/include/ui/Size.h index f1e825286e..ecc192dcae 100644 --- a/libs/ui/include/ui/Size.h +++ b/libs/ui/include/ui/Size.h @@ -23,103 +23,70 @@ #include <type_traits> #include <utility> -namespace android { -namespace ui { +namespace android::ui { -// Forward declare a few things. -struct Size; -bool operator==(const Size& lhs, const Size& rhs); - -/** - * A simple value type representing a two-dimensional size - */ +// A simple value type representing a two-dimensional size. struct Size { - int32_t width; - int32_t height; + int32_t width = -1; + int32_t height = -1; - // Special values - static const Size INVALID; - static const Size EMPTY; + constexpr Size() = default; - // ------------------------------------------------------------------------ - // Construction - // ------------------------------------------------------------------------ - - Size() : Size(INVALID) {} template <typename T> - Size(T&& w, T&& h) - : width(Size::clamp<int32_t, T>(std::forward<T>(w))), - height(Size::clamp<int32_t, T>(std::forward<T>(h))) {} - - // ------------------------------------------------------------------------ - // Accessors - // ------------------------------------------------------------------------ + constexpr Size(T w, T h) : width(clamp<int32_t>(w)), height(clamp<int32_t>(h)) {} int32_t getWidth() const { return width; } int32_t getHeight() const { return height; } + // Valid means non-negative width and height + bool isValid() const { return width >= 0 && height >= 0; } + + // Empty means zero width and height + bool isEmpty() const; + template <typename T> - void setWidth(T&& v) { - width = Size::clamp<int32_t, T>(std::forward<T>(v)); + void setWidth(T v) { + width = clamp<int32_t>(v); } + template <typename T> - void setHeight(T&& v) { - height = Size::clamp<int32_t, T>(std::forward<T>(v)); + void setHeight(T v) { + height = clamp<int32_t>(v); } - // ------------------------------------------------------------------------ - // Assignment - // ------------------------------------------------------------------------ + void set(Size size) { *this = size; } - void set(const Size& size) { *this = size; } template <typename T> - void set(T&& w, T&& h) { - set(Size(std::forward<T>(w), std::forward<T>(h))); + void set(T w, T h) { + set(Size(w, h)); } - // Sets the value to INVALID - void makeInvalid() { set(INVALID); } + // Sets the value to kInvalidSize + void makeInvalid(); - // Sets the value to EMPTY - void clear() { set(EMPTY); } + // Sets the value to kEmptySize + void clear(); - // ------------------------------------------------------------------------ - // Semantic checks - // ------------------------------------------------------------------------ - - // Valid means non-negative width and height - bool isValid() const { return width >= 0 && height >= 0; } - - // Empty means zero width and height - bool isEmpty() const { return *this == EMPTY; } - - // ------------------------------------------------------------------------ - // Clamp Helpers - // ------------------------------------------------------------------------ - - // Note: We use only features available in C++11 here for compatibility with - // external targets which include this file directly or indirectly and which - // themselves use C++11. - - // C++11 compatible replacement for std::remove_cv_reference_t [C++20] + // TODO: Replace with std::remove_cvref_t in C++20. template <typename T> - using remove_cv_reference_t = - typename std::remove_cv<typename std::remove_reference<T>::type>::type; + using remove_cvref_t = std::remove_cv_t<std::remove_reference_t<T>>; // Takes a value of type FromType, and ensures it can be represented as a value of type ToType, // clamping the input value to the output range if necessary. template <typename ToType, typename FromType> - static Size::remove_cv_reference_t<ToType> - clamp(typename std::enable_if< - std::numeric_limits<Size::remove_cv_reference_t<ToType>>::is_specialized && - std::numeric_limits<Size::remove_cv_reference_t<FromType>>::is_specialized, - FromType>::type v) { - using BareToType = remove_cv_reference_t<ToType>; - using BareFromType = remove_cv_reference_t<FromType>; - static constexpr auto toHighest = std::numeric_limits<BareToType>::max(); - static constexpr auto toLowest = std::numeric_limits<BareToType>::lowest(); - static constexpr auto fromHighest = std::numeric_limits<BareFromType>::max(); - static constexpr auto fromLowest = std::numeric_limits<BareFromType>::lowest(); + static constexpr remove_cvref_t<ToType> clamp(FromType v) { + using BareToType = remove_cvref_t<ToType>; + using ToLimits = std::numeric_limits<BareToType>; + + using BareFromType = remove_cvref_t<FromType>; + using FromLimits = std::numeric_limits<BareFromType>; + + static_assert(ToLimits::is_specialized && FromLimits::is_specialized); + + constexpr auto toHighest = ToLimits::max(); + constexpr auto toLowest = ToLimits::lowest(); + constexpr auto fromHighest = FromLimits::max(); + constexpr auto fromLowest = FromLimits::lowest(); // Get the closest representation of [toLowest, toHighest] in type // FromType to use to clamp the input value before conversion. @@ -127,37 +94,35 @@ struct Size { // std::common_type<...> is used to get a value-preserving type for the // top end of the range. using CommonHighestType = std::common_type_t<BareToType, BareFromType>; + using CommonLimits = std::numeric_limits<CommonHighestType>; // std::make_signed<std::common_type<...>> is used to get a // value-preserving type for the bottom end of the range, except this is // a bit trickier for non-integer types like float. - using CommonLowestType = - std::conditional_t<std::numeric_limits<CommonHighestType>::is_integer, - std::make_signed_t<std::conditional_t< - std::numeric_limits<CommonHighestType>::is_integer, - CommonHighestType, int /* not used */>>, - CommonHighestType>; + using CommonLowestType = std::conditional_t< + CommonLimits::is_integer, + std::make_signed_t<std::conditional_t<CommonLimits::is_integer, CommonHighestType, + int /* not used */>>, + CommonHighestType>; // We can then compute the clamp range in a way that can be later // trivially converted to either the 'from' or 'to' types, and be - // representabile in either. - static constexpr auto commonClampHighest = - std::min(static_cast<CommonHighestType>(fromHighest), - static_cast<CommonHighestType>(toHighest)); - static constexpr auto commonClampLowest = - std::max(static_cast<CommonLowestType>(fromLowest), - static_cast<CommonLowestType>(toLowest)); + // representable in either. + constexpr auto commonClampHighest = std::min(static_cast<CommonHighestType>(fromHighest), + static_cast<CommonHighestType>(toHighest)); + constexpr auto commonClampLowest = std::max(static_cast<CommonLowestType>(fromLowest), + static_cast<CommonLowestType>(toLowest)); - static constexpr auto fromClampHighest = static_cast<BareFromType>(commonClampHighest); - static constexpr auto fromClampLowest = static_cast<BareFromType>(commonClampLowest); + constexpr auto fromClampHighest = static_cast<BareFromType>(commonClampHighest); + constexpr auto fromClampLowest = static_cast<BareFromType>(commonClampLowest); // A clamp is needed only if the range we are clamping to is not the // same as the range of the input. - static constexpr bool isClampNeeded = + constexpr bool isClampNeeded = (fromLowest != fromClampLowest) || (fromHighest != fromClampHighest); // If a clamp is not needed, the conversion is just a trivial cast. - if (!isClampNeeded) { + if constexpr (!isClampNeeded) { return static_cast<BareToType>(v); } @@ -170,34 +135,46 @@ struct Size { // Otherwise clamping is done by using the already computed endpoints // for each type. - return (v <= fromClampLowest) - ? toClampLowest - : ((v >= fromClampHighest) ? toClampHighest : static_cast<BareToType>(v)); + if (v <= fromClampLowest) { + return toClampLowest; + } + + return v >= fromClampHighest ? toClampHighest : static_cast<BareToType>(v); } }; -// ------------------------------------------------------------------------ -// Comparisons -// ------------------------------------------------------------------------ +constexpr Size kInvalidSize; +constexpr Size kEmptySize{0, 0}; + +inline void Size::makeInvalid() { + set(kInvalidSize); +} -inline bool operator==(const Size& lhs, const Size& rhs) { +inline void Size::clear() { + set(kEmptySize); +} + +inline bool operator==(Size lhs, Size rhs) { return lhs.width == rhs.width && lhs.height == rhs.height; } -inline bool operator!=(const Size& lhs, const Size& rhs) { - return !operator==(lhs, rhs); +inline bool Size::isEmpty() const { + return *this == kEmptySize; +} + +inline bool operator!=(Size lhs, Size rhs) { + return !(lhs == rhs); } -inline bool operator<(const Size& lhs, const Size& rhs) { +inline bool operator<(Size lhs, Size rhs) { // Orders by increasing width, then height. if (lhs.width != rhs.width) return lhs.width < rhs.width; return lhs.height < rhs.height; } // Defining PrintTo helps with Google Tests. -static inline void PrintTo(const Size& size, ::std::ostream* os) { - *os << "Size(" << size.width << ", " << size.height << ")"; +inline void PrintTo(Size size, std::ostream* stream) { + *stream << "Size(" << size.width << ", " << size.height << ')'; } -} // namespace ui -} // namespace android +} // namespace android::ui diff --git a/libs/ui/tests/DisplayId_test.cpp b/libs/ui/tests/DisplayId_test.cpp index 1d908b8ef1..8ddee7e740 100644 --- a/libs/ui/tests/DisplayId_test.cpp +++ b/libs/ui/tests/DisplayId_test.cpp @@ -32,6 +32,9 @@ TEST(DisplayIdTest, createPhysicalIdFromEdid) { EXPECT_FALSE(GpuVirtualDisplayId::tryCast(id)); EXPECT_TRUE(PhysicalDisplayId::tryCast(id)); EXPECT_TRUE(HalDisplayId::tryCast(id)); + + EXPECT_EQ(id, DisplayId::fromValue(id.value)); + EXPECT_EQ(id, DisplayId::fromValue<PhysicalDisplayId>(id.value)); } TEST(DisplayIdTest, createPhysicalIdFromPort) { @@ -43,6 +46,9 @@ TEST(DisplayIdTest, createPhysicalIdFromPort) { EXPECT_FALSE(GpuVirtualDisplayId::tryCast(id)); EXPECT_TRUE(PhysicalDisplayId::tryCast(id)); EXPECT_TRUE(HalDisplayId::tryCast(id)); + + EXPECT_EQ(id, DisplayId::fromValue(id.value)); + EXPECT_EQ(id, DisplayId::fromValue<PhysicalDisplayId>(id.value)); } TEST(DisplayIdTest, createGpuVirtualId) { @@ -52,6 +58,9 @@ TEST(DisplayIdTest, createGpuVirtualId) { EXPECT_FALSE(HalVirtualDisplayId::tryCast(id)); EXPECT_FALSE(PhysicalDisplayId::tryCast(id)); EXPECT_FALSE(HalDisplayId::tryCast(id)); + + EXPECT_EQ(id, DisplayId::fromValue(id.value)); + EXPECT_EQ(id, DisplayId::fromValue<GpuVirtualDisplayId>(id.value)); } TEST(DisplayIdTest, createHalVirtualId) { @@ -61,6 +70,9 @@ TEST(DisplayIdTest, createHalVirtualId) { EXPECT_FALSE(GpuVirtualDisplayId::tryCast(id)); EXPECT_FALSE(PhysicalDisplayId::tryCast(id)); EXPECT_TRUE(HalDisplayId::tryCast(id)); + + EXPECT_EQ(id, DisplayId::fromValue(id.value)); + EXPECT_EQ(id, DisplayId::fromValue<HalVirtualDisplayId>(id.value)); } } // namespace android::ui diff --git a/libs/ui/tests/Size_test.cpp b/libs/ui/tests/Size_test.cpp index 5f75aeabeb..acef47fb97 100644 --- a/libs/ui/tests/Size_test.cpp +++ b/libs/ui/tests/Size_test.cpp @@ -93,9 +93,8 @@ TEST(SizeTest, ValidAndEmpty) { } { - const auto& s = Size::INVALID; - EXPECT_FALSE(s.isValid()); - EXPECT_FALSE(s.isEmpty()); + EXPECT_FALSE(kInvalidSize.isValid()); + EXPECT_FALSE(kInvalidSize.isEmpty()); } { @@ -112,9 +111,8 @@ TEST(SizeTest, ValidAndEmpty) { } { - const auto& s = Size::EMPTY; - EXPECT_TRUE(s.isValid()); - EXPECT_TRUE(s.isEmpty()); + EXPECT_TRUE(kEmptySize.isValid()); + EXPECT_TRUE(kEmptySize.isEmpty()); } { diff --git a/services/automotive/display/AutomotiveDisplayProxyService.cpp b/services/automotive/display/AutomotiveDisplayProxyService.cpp index d6fc69562b..d205231033 100644 --- a/services/automotive/display/AutomotiveDisplayProxyService.cpp +++ b/services/automotive/display/AutomotiveDisplayProxyService.cpp @@ -34,7 +34,10 @@ AutomotiveDisplayProxyService::getIGraphicBufferProducer(uint64_t id) { sp<IBinder> displayToken = nullptr; sp<SurfaceControl> surfaceControl = nullptr; if (it == mDisplays.end()) { - displayToken = SurfaceComposerClient::getPhysicalDisplayToken(PhysicalDisplayId(id)); + if (const auto displayId = DisplayId::fromValue<PhysicalDisplayId>(id)) { + displayToken = SurfaceComposerClient::getPhysicalDisplayToken(*displayId); + } + if (displayToken == nullptr) { ALOGE("Given display id, 0x%lX, is invalid.", (unsigned long)id); return nullptr; @@ -157,7 +160,11 @@ Return<void> AutomotiveDisplayProxyService::getDisplayInfo(uint64_t id, getDispl HwDisplayConfig activeConfig; HwDisplayState activeState; - auto displayToken = SurfaceComposerClient::getPhysicalDisplayToken(PhysicalDisplayId(id)); + sp<IBinder> displayToken; + if (const auto displayId = DisplayId::fromValue<PhysicalDisplayId>(id)) { + displayToken = SurfaceComposerClient::getPhysicalDisplayToken(*displayId); + } + if (displayToken == nullptr) { ALOGE("Given display id, 0x%lX, is invalid.", (unsigned long)id); } else { diff --git a/services/inputflinger/dispatcher/Entry.cpp b/services/inputflinger/dispatcher/Entry.cpp index 881024fc6e..8d6bd8a766 100644 --- a/services/inputflinger/dispatcher/Entry.cpp +++ b/services/inputflinger/dispatcher/Entry.cpp @@ -176,10 +176,11 @@ std::string KeyEntry::getDescription() const { } return StringPrintf("KeyEvent(deviceId=%d, eventTime=%" PRIu64 ", source=0x%08x, displayId=%" PRId32 ", action=%s, " - "flags=0x%08x, keyCode=%d, scanCode=%d, metaState=0x%08x, " + "flags=0x%08x, keyCode=%s(%d), scanCode=%d, metaState=0x%08x, " "repeatCount=%d), policyFlags=0x%08x", deviceId, eventTime, source, displayId, KeyEvent::actionToString(action), - flags, keyCode, scanCode, metaState, repeatCount, policyFlags); + flags, KeyEvent::getLabel(keyCode), keyCode, scanCode, metaState, + repeatCount, policyFlags); } void KeyEntry::recycle() { diff --git a/services/inputflinger/dispatcher/InputDispatcher.cpp b/services/inputflinger/dispatcher/InputDispatcher.cpp index d2b8739f96..468d9d24cb 100644 --- a/services/inputflinger/dispatcher/InputDispatcher.cpp +++ b/services/inputflinger/dispatcher/InputDispatcher.cpp @@ -1256,6 +1256,11 @@ bool InputDispatcher::dispatchDeviceResetLocked(nsecs_t currentTime, entry.deviceId); #endif + // Reset key repeating in case a keyboard device was disabled or enabled. + if (mKeyRepeatState.lastKeyEntry && mKeyRepeatState.lastKeyEntry->deviceId == entry.deviceId) { + resetKeyRepeatLocked(); + } + CancelationOptions options(CancelationOptions::CANCEL_ALL_EVENTS, "device was reset"); options.deviceId = entry.deviceId; synthesizeCancelationEventsForAllConnectionsLocked(options); diff --git a/services/inputflinger/tests/InputDispatcher_test.cpp b/services/inputflinger/tests/InputDispatcher_test.cpp index d51acce4b2..235bf97969 100644 --- a/services/inputflinger/tests/InputDispatcher_test.cpp +++ b/services/inputflinger/tests/InputDispatcher_test.cpp @@ -2870,6 +2870,16 @@ TEST_F(InputDispatcherKeyRepeatTest, FocusedWindow_KeyRepeatStopsAfterRepeatingK mWindow->assertNoEvents(); } +TEST_F(InputDispatcherKeyRepeatTest, FocusedWindow_StopsKeyRepeatAfterDisableInputDevice) { + sendAndConsumeKeyDown(DEVICE_ID); + expectKeyRepeatOnce(1 /*repeatCount*/); + NotifyDeviceResetArgs args(10 /*id*/, 20 /*eventTime*/, DEVICE_ID); + mDispatcher->notifyDeviceReset(&args); + mWindow->consumeKeyUp(ADISPLAY_ID_DEFAULT, + AKEY_EVENT_FLAG_CANCELED | AKEY_EVENT_FLAG_LONG_PRESS); + mWindow->assertNoEvents(); +} + TEST_F(InputDispatcherKeyRepeatTest, FocusedWindow_RepeatKeyEventsUseEventIdFromInputDispatcher) { sendAndConsumeKeyDown(1 /* deviceId */); for (int32_t repeatCount = 1; repeatCount <= 10; ++repeatCount) { diff --git a/services/surfaceflinger/BufferQueueLayer.cpp b/services/surfaceflinger/BufferQueueLayer.cpp index e7f373ff3f..2f2e6731fe 100644 --- a/services/surfaceflinger/BufferQueueLayer.cpp +++ b/services/surfaceflinger/BufferQueueLayer.cpp @@ -125,11 +125,11 @@ bool BufferQueueLayer::isBufferDue(nsecs_t expectedPresentTime) const { // ----------------------------------------------------------------------- bool BufferQueueLayer::fenceHasSignaled() const { + Mutex::Autolock lock(mQueueItemLock); if (!hasFrameUpdate()) { return true; } - Mutex::Autolock lock(mQueueItemLock); if (mQueueItems[0].item.mIsDroppable) { // Even though this buffer's fence may not have signaled yet, it could // be replaced by another buffer before it has a chance to, which means @@ -148,11 +148,12 @@ bool BufferQueueLayer::fenceHasSignaled() const { } bool BufferQueueLayer::framePresentTimeIsCurrent(nsecs_t expectedPresentTime) const { + Mutex::Autolock lock(mQueueItemLock); + if (!hasFrameUpdate() || isRemovedFromCurrentState()) { return true; } - Mutex::Autolock lock(mQueueItemLock); return mQueueItems[0].item.mTimestamp <= expectedPresentTime; } @@ -264,13 +265,15 @@ status_t BufferQueueLayer::updateTexImage(bool& recomputeVisibleRegions, nsecs_t // and return early if (queuedBuffer) { Mutex::Autolock lock(mQueueItemLock); - mConsumer->mergeSurfaceDamage(mQueueItems[0].item.mSurfaceDamage); - mFlinger->mTimeStats->removeTimeRecord(layerId, mQueueItems[0].item.mFrameNumber); - if (mQueueItems[0].surfaceFrame) { - addSurfaceFrameDroppedForBuffer(mQueueItems[0].surfaceFrame); + if (mQueuedFrames > 0) { + mConsumer->mergeSurfaceDamage(mQueueItems[0].item.mSurfaceDamage); + mFlinger->mTimeStats->removeTimeRecord(layerId, mQueueItems[0].item.mFrameNumber); + if (mQueueItems[0].surfaceFrame) { + addSurfaceFrameDroppedForBuffer(mQueueItems[0].surfaceFrame); + } + mQueueItems.erase(mQueueItems.begin()); + mQueuedFrames--; } - mQueueItems.erase(mQueueItems.begin()); - mQueuedFrames--; } return BAD_VALUE; } else if (updateResult != NO_ERROR || mUpdateTexImageFailed) { @@ -300,6 +303,7 @@ status_t BufferQueueLayer::updateTexImage(bool& recomputeVisibleRegions, nsecs_t return BAD_VALUE; } + bool more_frames_pending = false; if (queuedBuffer) { // Autolock scope auto currentFrameNumber = mConsumer->getFrameNumber(); @@ -308,7 +312,7 @@ status_t BufferQueueLayer::updateTexImage(bool& recomputeVisibleRegions, nsecs_t // Remove any stale buffers that have been dropped during // updateTexImage - while (mQueueItems[0].item.mFrameNumber != currentFrameNumber) { + while (mQueuedFrames > 0 && mQueueItems[0].item.mFrameNumber != currentFrameNumber) { mConsumer->mergeSurfaceDamage(mQueueItems[0].item.mSurfaceDamage); mFlinger->mTimeStats->removeTimeRecord(layerId, mQueueItems[0].item.mFrameNumber); if (mQueueItems[0].surfaceFrame) { @@ -329,11 +333,12 @@ status_t BufferQueueLayer::updateTexImage(bool& recomputeVisibleRegions, nsecs_t latchTime); } mQueueItems.erase(mQueueItems.begin()); + more_frames_pending = (mQueuedFrames.fetch_sub(1) > 1); } // Decrement the queued-frames count. Signal another event if we // have more frames pending. - if ((queuedBuffer && mQueuedFrames.fetch_sub(1) > 1) || mAutoRefresh) { + if ((queuedBuffer && more_frames_pending) || mAutoRefresh) { mFlinger->signalLayerUpdate(); } diff --git a/services/surfaceflinger/CompositionEngine/include/compositionengine/DisplayCreationArgs.h b/services/surfaceflinger/CompositionEngine/include/compositionengine/DisplayCreationArgs.h index 14eddb1861..526e7daa80 100644 --- a/services/surfaceflinger/CompositionEngine/include/compositionengine/DisplayCreationArgs.h +++ b/services/surfaceflinger/CompositionEngine/include/compositionengine/DisplayCreationArgs.h @@ -40,7 +40,7 @@ struct DisplayCreationArgs { std::optional<ui::DisplayConnectionType> connectionType; // Size of the display in pixels - ui::Size pixels = ui::Size::INVALID; + ui::Size pixels = ui::kInvalidSize; // True if this display should be considered secure bool isSecure = false; diff --git a/services/surfaceflinger/CompositionEngine/tests/DisplayTest.cpp b/services/surfaceflinger/CompositionEngine/tests/DisplayTest.cpp index db9437b9a8..f4a58359ad 100644 --- a/services/surfaceflinger/CompositionEngine/tests/DisplayTest.cpp +++ b/services/surfaceflinger/CompositionEngine/tests/DisplayTest.cpp @@ -60,7 +60,7 @@ constexpr PhysicalDisplayId DEFAULT_DISPLAY_ID = PhysicalDisplayId::fromPort(123 constexpr HalVirtualDisplayId HAL_VIRTUAL_DISPLAY_ID{456u}; constexpr GpuVirtualDisplayId GPU_VIRTUAL_DISPLAY_ID{789u}; -const ui::Size DEFAULT_RESOLUTION{1920, 1080}; +constexpr ui::Size DEFAULT_RESOLUTION{1920, 1080}; constexpr uint32_t DEFAULT_LAYER_STACK = 42; struct Layer { diff --git a/services/surfaceflinger/CompositionEngine/tests/MockHWComposer.h b/services/surfaceflinger/CompositionEngine/tests/MockHWComposer.h index 64cbea91a3..72de0b12a2 100644 --- a/services/surfaceflinger/CompositionEngine/tests/MockHWComposer.h +++ b/services/surfaceflinger/CompositionEngine/tests/MockHWComposer.h @@ -51,6 +51,7 @@ public: bool(HalVirtualDisplayId, ui::Size, ui::PixelFormat*, std::optional<PhysicalDisplayId>)); MOCK_METHOD2(allocatePhysicalDisplay, void(hal::HWDisplayId, PhysicalDisplayId)); + MOCK_METHOD1(createLayer, std::shared_ptr<HWC2::Layer>(HalDisplayId)); MOCK_METHOD4(getDeviceCompositionChanges, status_t(HalDisplayId, bool, std::chrono::steady_clock::time_point, diff --git a/services/surfaceflinger/CompositionEngine/tests/RenderSurfaceTest.cpp b/services/surfaceflinger/CompositionEngine/tests/RenderSurfaceTest.cpp index 5090bb280f..431cc93514 100644 --- a/services/surfaceflinger/CompositionEngine/tests/RenderSurfaceTest.cpp +++ b/services/surfaceflinger/CompositionEngine/tests/RenderSurfaceTest.cpp @@ -35,7 +35,7 @@ namespace { constexpr int32_t DEFAULT_DISPLAY_WIDTH = 1920; constexpr int32_t DEFAULT_DISPLAY_HEIGHT = 1080; -constexpr DisplayId DEFAULT_DISPLAY_ID = PhysicalDisplayId(123u); +constexpr DisplayId DEFAULT_DISPLAY_ID = PhysicalDisplayId::fromPort(123u); const std::string DEFAULT_DISPLAY_NAME = "Mock Display"; using testing::_; diff --git a/services/surfaceflinger/DisplayDevice.cpp b/services/surfaceflinger/DisplayDevice.cpp index ca4b6abc03..c391901faa 100644 --- a/services/surfaceflinger/DisplayDevice.cpp +++ b/services/surfaceflinger/DisplayDevice.cpp @@ -220,6 +220,10 @@ void DisplayDevice::setLayerStack(ui::LayerStack stack) { mCompositionDisplay->setLayerStackFilter(stack, isPrimary()); } +void DisplayDevice::setFlags(uint32_t flags) { + mFlags = flags; +} + void DisplayDevice::setDisplaySize(int width, int height) { LOG_FATAL_IF(!isVirtual(), "Changing the display size is supported only for virtual displays."); mCompositionDisplay->setDisplaySize(ui::Size(width, height)); diff --git a/services/surfaceflinger/DisplayDevice.h b/services/surfaceflinger/DisplayDevice.h index 7e4d92308c..b068dafb19 100644 --- a/services/surfaceflinger/DisplayDevice.h +++ b/services/surfaceflinger/DisplayDevice.h @@ -64,6 +64,7 @@ class DisplayDevice : public RefBase { public: constexpr static float sDefaultMinLumiance = 0.0; constexpr static float sDefaultMaxLumiance = 500.0; + enum { eReceivesInput = 0x01 }; explicit DisplayDevice(DisplayDeviceCreationArgs& args); @@ -90,6 +91,7 @@ public: void setLayerStack(ui::LayerStack); void setDisplaySize(int width, int height); void setProjection(ui::Rotation orientation, Rect viewport, Rect frame); + void setFlags(uint32_t flags); ui::Rotation getPhysicalOrientation() const { return mPhysicalOrientation; } ui::Rotation getOrientation() const { return mOrientation; } @@ -102,6 +104,7 @@ public: const Rect& getOrientedDisplaySpaceRect() const; bool needsFiltering() const; ui::LayerStack getLayerStack() const; + bool receivesInput() const { return mFlags & eReceivesInput; } DisplayId getId() const; @@ -227,6 +230,8 @@ private: // TODO(b/74619554): Remove special cases for primary display. const bool mIsPrimary; + uint32_t mFlags = 0; + std::optional<DeviceProductInfo> mDeviceProductInfo; std::vector<ui::Hdr> mOverrideHdrTypes; @@ -252,6 +257,7 @@ struct DisplayDeviceState { std::optional<Physical> physical; sp<IGraphicBufferProducer> surface; ui::LayerStack layerStack = ui::NO_LAYER_STACK; + uint32_t flags = 0; Rect layerStackSpaceRect; Rect orientedDisplaySpaceRect; ui::Rotation orientation = ui::ROTATION_0; @@ -291,16 +297,4 @@ struct DisplayDeviceCreationArgs { DisplayModes supportedModes; }; -// Predicates for display lookup. - -struct WithLayerStack { - explicit WithLayerStack(ui::LayerStack layerStack) : layerStack(layerStack) {} - - bool operator()(const DisplayDevice& display) const { - return display.getLayerStack() == layerStack; - } - - ui::LayerStack layerStack; -}; - } // namespace android diff --git a/services/surfaceflinger/RefreshRateOverlay.cpp b/services/surfaceflinger/RefreshRateOverlay.cpp index a9fd16cb75..075d0eb1dc 100644 --- a/services/surfaceflinger/RefreshRateOverlay.cpp +++ b/services/surfaceflinger/RefreshRateOverlay.cpp @@ -25,6 +25,10 @@ #include "Client.h" #include "Layer.h" +#include <SkBlendMode.h> +#include <SkPaint.h> +#include <SkRect.h> +#include <SkSurface.h> #include <gui/IProducerListener.h> #undef LOG_TAG @@ -32,85 +36,64 @@ namespace android { -void RefreshRateOverlay::SevenSegmentDrawer::drawRect(const Rect& r, const half4& color, - const sp<GraphicBuffer>& buffer, - uint8_t* pixels) { - for (int32_t j = r.top; j < r.bottom; j++) { - if (j >= buffer->getHeight()) { - break; - } - - for (int32_t i = r.left; i < r.right; i++) { - if (i >= buffer->getWidth()) { - break; - } - - uint8_t* iter = pixels + 4 * (i + (buffer->getStride() * j)); - iter[0] = uint8_t(color.r * 255); - iter[1] = uint8_t(color.g * 255); - iter[2] = uint8_t(color.b * 255); - iter[3] = uint8_t(color.a * 255); - } - } -} - -void RefreshRateOverlay::SevenSegmentDrawer::drawSegment(Segment segment, int left, - const half4& color, - const sp<GraphicBuffer>& buffer, - uint8_t* pixels) { - const Rect rect = [&]() { +void RefreshRateOverlay::SevenSegmentDrawer::drawSegment(Segment segment, int left, SkColor& color, + SkCanvas& canvas) { + const SkRect rect = [&]() { switch (segment) { case Segment::Upper: - return Rect(left, 0, left + DIGIT_WIDTH, DIGIT_SPACE); + return SkRect::MakeLTRB(left, 0, left + DIGIT_WIDTH, DIGIT_SPACE); case Segment::UpperLeft: - return Rect(left, 0, left + DIGIT_SPACE, DIGIT_HEIGHT / 2); + return SkRect::MakeLTRB(left, 0, left + DIGIT_SPACE, DIGIT_HEIGHT / 2); case Segment::UpperRight: - return Rect(left + DIGIT_WIDTH - DIGIT_SPACE, 0, left + DIGIT_WIDTH, - DIGIT_HEIGHT / 2); + return SkRect::MakeLTRB(left + DIGIT_WIDTH - DIGIT_SPACE, 0, left + DIGIT_WIDTH, + DIGIT_HEIGHT / 2); case Segment::Middle: - return Rect(left, DIGIT_HEIGHT / 2 - DIGIT_SPACE / 2, left + DIGIT_WIDTH, - DIGIT_HEIGHT / 2 + DIGIT_SPACE / 2); + return SkRect::MakeLTRB(left, DIGIT_HEIGHT / 2 - DIGIT_SPACE / 2, + left + DIGIT_WIDTH, DIGIT_HEIGHT / 2 + DIGIT_SPACE / 2); case Segment::LowerLeft: - return Rect(left, DIGIT_HEIGHT / 2, left + DIGIT_SPACE, DIGIT_HEIGHT); + return SkRect::MakeLTRB(left, DIGIT_HEIGHT / 2, left + DIGIT_SPACE, DIGIT_HEIGHT); case Segment::LowerRight: - return Rect(left + DIGIT_WIDTH - DIGIT_SPACE, DIGIT_HEIGHT / 2, left + DIGIT_WIDTH, - DIGIT_HEIGHT); - case Segment::Buttom: - return Rect(left, DIGIT_HEIGHT - DIGIT_SPACE, left + DIGIT_WIDTH, DIGIT_HEIGHT); + return SkRect::MakeLTRB(left + DIGIT_WIDTH - DIGIT_SPACE, DIGIT_HEIGHT / 2, + left + DIGIT_WIDTH, DIGIT_HEIGHT); + case Segment::Bottom: + return SkRect::MakeLTRB(left, DIGIT_HEIGHT - DIGIT_SPACE, left + DIGIT_WIDTH, + DIGIT_HEIGHT); } }(); - drawRect(rect, color, buffer, pixels); + SkPaint paint; + paint.setColor(color); + paint.setBlendMode(SkBlendMode::kSrc); + canvas.drawRect(rect, paint); } -void RefreshRateOverlay::SevenSegmentDrawer::drawDigit(int digit, int left, const half4& color, - const sp<GraphicBuffer>& buffer, - uint8_t* pixels) { +void RefreshRateOverlay::SevenSegmentDrawer::drawDigit(int digit, int left, SkColor& color, + SkCanvas& canvas) { if (digit < 0 || digit > 9) return; if (digit == 0 || digit == 2 || digit == 3 || digit == 5 || digit == 6 || digit == 7 || digit == 8 || digit == 9) - drawSegment(Segment::Upper, left, color, buffer, pixels); + drawSegment(Segment::Upper, left, color, canvas); if (digit == 0 || digit == 4 || digit == 5 || digit == 6 || digit == 8 || digit == 9) - drawSegment(Segment::UpperLeft, left, color, buffer, pixels); + drawSegment(Segment::UpperLeft, left, color, canvas); if (digit == 0 || digit == 1 || digit == 2 || digit == 3 || digit == 4 || digit == 7 || digit == 8 || digit == 9) - drawSegment(Segment::UpperRight, left, color, buffer, pixels); + drawSegment(Segment::UpperRight, left, color, canvas); if (digit == 2 || digit == 3 || digit == 4 || digit == 5 || digit == 6 || digit == 8 || digit == 9) - drawSegment(Segment::Middle, left, color, buffer, pixels); + drawSegment(Segment::Middle, left, color, canvas); if (digit == 0 || digit == 2 || digit == 6 || digit == 8) - drawSegment(Segment::LowerLeft, left, color, buffer, pixels); + drawSegment(Segment::LowerLeft, left, color, canvas); if (digit == 0 || digit == 1 || digit == 3 || digit == 4 || digit == 5 || digit == 6 || digit == 7 || digit == 8 || digit == 9) - drawSegment(Segment::LowerRight, left, color, buffer, pixels); + drawSegment(Segment::LowerRight, left, color, canvas); if (digit == 0 || digit == 2 || digit == 3 || digit == 5 || digit == 6 || digit == 8 || digit == 9) - drawSegment(Segment::Buttom, left, color, buffer, pixels); + drawSegment(Segment::Bottom, left, color, canvas); } -std::vector<sp<GraphicBuffer>> RefreshRateOverlay::SevenSegmentDrawer::drawNumber( - int number, const half4& color, bool showSpinner) { +std::vector<sp<GraphicBuffer>> RefreshRateOverlay::SevenSegmentDrawer::draw( + int number, SkColor& color, ui::Transform::RotationFlags rotation, bool showSpinner) { if (number < 0 || number > 1000) return {}; const auto hundreds = number / 100; @@ -120,55 +103,76 @@ std::vector<sp<GraphicBuffer>> RefreshRateOverlay::SevenSegmentDrawer::drawNumbe std::vector<sp<GraphicBuffer>> buffers; const auto loopCount = showSpinner ? 6 : 1; for (int i = 0; i < loopCount; i++) { + // Pre-rotate the buffer before it reaches SurfaceFlinger. + SkMatrix canvasTransform = SkMatrix(); + auto [bufferWidth, bufferHeight] = [&] { + switch (rotation) { + case ui::Transform::ROT_90: + canvasTransform.setTranslate(BUFFER_HEIGHT, 0); + canvasTransform.preRotate(90); + return std::make_tuple(BUFFER_HEIGHT, BUFFER_WIDTH); + case ui::Transform::ROT_270: + canvasTransform.setRotate(270, BUFFER_WIDTH / 2.0, BUFFER_WIDTH / 2.0); + return std::make_tuple(BUFFER_HEIGHT, BUFFER_WIDTH); + default: + return std::make_tuple(BUFFER_WIDTH, BUFFER_HEIGHT); + } + }(); sp<GraphicBuffer> buffer = - new GraphicBuffer(BUFFER_WIDTH, BUFFER_HEIGHT, HAL_PIXEL_FORMAT_RGBA_8888, 1, + new GraphicBuffer(bufferWidth, bufferHeight, HAL_PIXEL_FORMAT_RGBA_8888, 1, GRALLOC_USAGE_SW_WRITE_RARELY | GRALLOC_USAGE_HW_COMPOSER | GRALLOC_USAGE_HW_TEXTURE, "RefreshRateOverlayBuffer"); const status_t bufferStatus = buffer->initCheck(); LOG_ALWAYS_FATAL_IF(bufferStatus != OK, "RefreshRateOverlay: Buffer failed to allocate: %d", bufferStatus); - uint8_t* pixels; - buffer->lock(GRALLOC_USAGE_SW_WRITE_RARELY, reinterpret_cast<void**>(&pixels)); - // Clear buffer content - drawRect(Rect(BUFFER_WIDTH, BUFFER_HEIGHT), half4(0), buffer, pixels); + + sk_sp<SkSurface> surface = SkSurface::MakeRasterN32Premul(bufferWidth, bufferHeight); + SkCanvas* canvas = surface->getCanvas(); + canvas->setMatrix(canvasTransform); + int left = 0; if (hundreds != 0) { - drawDigit(hundreds, left, color, buffer, pixels); + drawDigit(hundreds, left, color, *canvas); } left += DIGIT_WIDTH + DIGIT_SPACE; if (tens != 0) { - drawDigit(tens, left, color, buffer, pixels); + drawDigit(tens, left, color, *canvas); } left += DIGIT_WIDTH + DIGIT_SPACE; - drawDigit(ones, left, color, buffer, pixels); + drawDigit(ones, left, color, *canvas); left += DIGIT_WIDTH + DIGIT_SPACE; if (showSpinner) { switch (i) { case 0: - drawSegment(Segment::Upper, left, color, buffer, pixels); + drawSegment(Segment::Upper, left, color, *canvas); break; case 1: - drawSegment(Segment::UpperRight, left, color, buffer, pixels); + drawSegment(Segment::UpperRight, left, color, *canvas); break; case 2: - drawSegment(Segment::LowerRight, left, color, buffer, pixels); + drawSegment(Segment::LowerRight, left, color, *canvas); break; case 3: - drawSegment(Segment::Buttom, left, color, buffer, pixels); + drawSegment(Segment::Bottom, left, color, *canvas); break; case 4: - drawSegment(Segment::LowerLeft, left, color, buffer, pixels); + drawSegment(Segment::LowerLeft, left, color, *canvas); break; case 5: - drawSegment(Segment::UpperLeft, left, color, buffer, pixels); + drawSegment(Segment::UpperLeft, left, color, *canvas); break; } } + void* pixels = nullptr; + buffer->lock(GRALLOC_USAGE_SW_WRITE_RARELY, reinterpret_cast<void**>(&pixels)); + const SkImageInfo& imageInfo = surface->imageInfo(); + size_t dstRowBytes = buffer->getStride() * imageInfo.bytesPerPixel(); + canvas->readPixels(imageInfo, pixels, dstRowBytes, 0, 0); buffer->unlock(); buffers.emplace_back(buffer); } @@ -210,7 +214,22 @@ bool RefreshRateOverlay::createLayer() { const std::vector<std::shared_ptr<renderengine::ExternalTexture>>& RefreshRateOverlay::getOrCreateBuffers(uint32_t fps) { - if (mBufferCache.find(fps) == mBufferCache.end()) { + ui::Transform::RotationFlags transformHint = mLayer->getTransformHint(); + // Tell SurfaceFlinger about the pre-rotation on the buffer. + const auto transform = [&] { + switch (transformHint) { + case ui::Transform::ROT_90: + return ui::Transform::ROT_270; + case ui::Transform::ROT_270: + return ui::Transform::ROT_90; + default: + return ui::Transform::ROT_0; + } + }(); + mLayer->setTransform(transform); + + if (mBufferCache.find(transformHint) == mBufferCache.end() || + mBufferCache.at(transformHint).find(fps) == mBufferCache.at(transformHint).end()) { // Ensure the range is > 0, so we don't divide by 0. const auto rangeLength = std::max(1u, mHighFps - mLowFps); // Clip values outside the range [mLowFps, mHighFps]. The current fps may be outside @@ -218,12 +237,14 @@ RefreshRateOverlay::getOrCreateBuffers(uint32_t fps) { fps = std::max(fps, mLowFps); fps = std::min(fps, mHighFps); const auto fpsScale = static_cast<float>(fps - mLowFps) / rangeLength; - half4 color; - color.r = HIGH_FPS_COLOR.r * fpsScale + LOW_FPS_COLOR.r * (1 - fpsScale); - color.g = HIGH_FPS_COLOR.g * fpsScale + LOW_FPS_COLOR.g * (1 - fpsScale); - color.b = HIGH_FPS_COLOR.b * fpsScale + LOW_FPS_COLOR.b * (1 - fpsScale); - color.a = ALPHA; - auto buffers = SevenSegmentDrawer::drawNumber(fps, color, mShowSpinner); + SkColor4f colorBase = SkColor4f::FromColor(HIGH_FPS_COLOR) * fpsScale; + SkColor4f lowFpsColor = SkColor4f::FromColor(LOW_FPS_COLOR) * (1 - fpsScale); + colorBase.fR = colorBase.fR + lowFpsColor.fR; + colorBase.fG = colorBase.fG + lowFpsColor.fG; + colorBase.fB = colorBase.fB + lowFpsColor.fB; + colorBase.fA = ALPHA; + SkColor color = colorBase.toSkColor(); + auto buffers = SevenSegmentDrawer::draw(fps, color, transformHint, mShowSpinner); std::vector<std::shared_ptr<renderengine::ExternalTexture>> textures; std::transform(buffers.begin(), buffers.end(), std::back_inserter(textures), [&](const auto& buffer) -> std::shared_ptr<renderengine::ExternalTexture> { @@ -233,10 +254,10 @@ RefreshRateOverlay::getOrCreateBuffers(uint32_t fps) { renderengine::ExternalTexture:: Usage::READABLE); }); - mBufferCache.emplace(fps, textures); + mBufferCache[transformHint].emplace(fps, textures); } - return mBufferCache[fps]; + return mBufferCache[transformHint][fps]; } void RefreshRateOverlay::setViewport(ui::Size viewport) { diff --git a/services/surfaceflinger/RefreshRateOverlay.h b/services/surfaceflinger/RefreshRateOverlay.h index aa8329c46a..cb8b2271da 100644 --- a/services/surfaceflinger/RefreshRateOverlay.h +++ b/services/surfaceflinger/RefreshRateOverlay.h @@ -22,6 +22,8 @@ #include <ui/Size.h> #include <utils/StrongPointer.h> +#include <SkCanvas.h> +#include <SkColor.h> #include <unordered_map> #include "Fps.h" @@ -47,20 +49,16 @@ public: private: class SevenSegmentDrawer { public: - static std::vector<sp<GraphicBuffer>> drawNumber(int number, const half4& color, - bool showSpinner); + static std::vector<sp<GraphicBuffer>> draw(int number, SkColor& color, + ui::Transform::RotationFlags, bool showSpinner); static uint32_t getHeight() { return BUFFER_HEIGHT; } static uint32_t getWidth() { return BUFFER_WIDTH; } private: - enum class Segment { Upper, UpperLeft, UpperRight, Middle, LowerLeft, LowerRight, Buttom }; + enum class Segment { Upper, UpperLeft, UpperRight, Middle, LowerLeft, LowerRight, Bottom }; - static void drawRect(const Rect& r, const half4& color, const sp<GraphicBuffer>& buffer, - uint8_t* pixels); - static void drawSegment(Segment segment, int left, const half4& color, - const sp<GraphicBuffer>& buffer, uint8_t* pixels); - static void drawDigit(int digit, int left, const half4& color, - const sp<GraphicBuffer>& buffer, uint8_t* pixels); + static void drawSegment(Segment segment, int left, SkColor& color, SkCanvas& canvas); + static void drawDigit(int digit, int left, SkColor& color, SkCanvas& canvas); static constexpr uint32_t DIGIT_HEIGHT = 100; static constexpr uint32_t DIGIT_WIDTH = 64; @@ -80,13 +78,15 @@ private: sp<IBinder> mIBinder; sp<IGraphicBufferProducer> mGbp; - std::unordered_map<int, std::vector<std::shared_ptr<renderengine::ExternalTexture>>> + std::unordered_map< + ui::Transform::RotationFlags, + std::unordered_map<int, std::vector<std::shared_ptr<renderengine::ExternalTexture>>>> mBufferCache; std::optional<int> mCurrentFps; int mFrame = 0; static constexpr float ALPHA = 0.8f; - const half3 LOW_FPS_COLOR = half3(1.0f, 0.0f, 0.0f); - const half3 HIGH_FPS_COLOR = half3(0.0f, 1.0f, 0.0f); + const SkColor LOW_FPS_COLOR = SK_ColorRED; + const SkColor HIGH_FPS_COLOR = SK_ColorGREEN; const bool mShowSpinner; diff --git a/services/surfaceflinger/SurfaceFlinger.cpp b/services/surfaceflinger/SurfaceFlinger.cpp index fddec1b6fd..3a5ca1ef4e 100644 --- a/services/surfaceflinger/SurfaceFlinger.cpp +++ b/services/surfaceflinger/SurfaceFlinger.cpp @@ -2852,6 +2852,9 @@ void SurfaceFlinger::processDisplayChanged(const wp<IBinder>& displayToken, if (currentState.layerStack != drawingState.layerStack) { display->setLayerStack(currentState.layerStack); } + if (currentState.flags != drawingState.flags) { + display->setFlags(currentState.flags); + } if ((currentState.orientation != drawingState.orientation) || (currentState.layerStackSpaceRect != drawingState.layerStackSpaceRect) || (currentState.orientedDisplaySpaceRect != drawingState.orientedDisplaySpaceRect)) { @@ -3069,18 +3072,9 @@ void SurfaceFlinger::updateInputWindowInfo() { mDrawingState.traverseInReverseZOrder([&](Layer* layer) { if (!layer->needsInputInfo()) return; - sp<DisplayDevice> display; - if (enablePerWindowInputRotation()) { - for (const auto& pair : ON_MAIN_THREAD(mDisplays)) { - const auto& displayDevice = pair.second; - if (!displayDevice->getCompositionDisplay() - ->belongsInOutput(layer->getLayerStack(), - layer->getPrimaryDisplayOnly())) { - continue; - } - display = displayDevice; - } - } + sp<DisplayDevice> display = enablePerWindowInputRotation() + ? ON_MAIN_THREAD(getDisplayWithInputByLayer(layer)) + : nullptr; // When calculating the screen bounds we ignore the transparent region since it may // result in an unwanted offset. inputInfos.push_back(layer->fillInputInfo(display)); @@ -3819,6 +3813,12 @@ uint32_t SurfaceFlinger::setDisplayStateLocked(const DisplayState& s) { flags |= eDisplayTransactionNeeded; } } + if (what & DisplayState::eFlagsChanged) { + if (state.flags != s.flags) { + state.flags = s.flags; + flags |= eDisplayTransactionNeeded; + } + } if (what & DisplayState::eDisplayProjectionChanged) { if (state.orientation != s.orientation) { state.orientation = s.orientation; @@ -4485,6 +4485,26 @@ void SurfaceFlinger::initializeDisplays() { static_cast<void>(schedule([this]() MAIN_THREAD { onInitializeDisplays(); })); } +sp<DisplayDevice> SurfaceFlinger::getDisplayWithInputByLayer(Layer* layer) const { + sp<DisplayDevice> display; + for (const auto& pair : mDisplays) { + const auto& displayDevice = pair.second; + if (!displayDevice->receivesInput() || + !displayDevice->getCompositionDisplay() + ->belongsInOutput(layer->getLayerStack(), layer->getPrimaryDisplayOnly())) { + continue; + } + // Don't return immediately so that we can log duplicates. + if (display) { + ALOGE("Multiple display devices claim to accept input for the same layerstack: %d", + layer->getLayerStack()); + continue; + } + display = displayDevice; + } + return display; +} + void SurfaceFlinger::setPowerModeInternal(const sp<DisplayDevice>& display, hal::PowerMode mode) { if (display->isVirtual()) { ALOGE("%s: Invalid operation on virtual display", __FUNCTION__); @@ -5622,37 +5642,24 @@ status_t SurfaceFlinger::onTransact(uint32_t code, const Parcel& data, Parcel* r } case 1035: { const int modeId = data.readInt32(); - mDebugDisplayModeSetByBackdoor = false; - - const auto displayId = [&]() -> std::optional<PhysicalDisplayId> { - uint64_t inputDisplayId = 0; - if (data.readUint64(&inputDisplayId) == NO_ERROR) { - const auto token = getPhysicalDisplayToken( - static_cast<PhysicalDisplayId>(inputDisplayId)); - if (!token) { - ALOGE("No display with id: %" PRIu64, inputDisplayId); - return std::nullopt; - } - return std::make_optional<PhysicalDisplayId>(inputDisplayId); + const auto display = [&]() -> sp<IBinder> { + uint64_t value; + if (data.readUint64(&value) != NO_ERROR) { + return getInternalDisplayToken(); } - return getInternalDisplayId(); - }(); - - if (!displayId) { - ALOGE("No display found"); - return NO_ERROR; - } - - status_t result = setActiveMode(getPhysicalDisplayToken(*displayId), modeId); - if (result != NO_ERROR) { - return result; - } + if (const auto id = DisplayId::fromValue<PhysicalDisplayId>(value)) { + return getPhysicalDisplayToken(*id); + } - mDebugDisplayModeSetByBackdoor = true; + ALOGE("Invalid physical display ID"); + return nullptr; + }(); - return NO_ERROR; + const status_t result = setActiveMode(display, modeId); + mDebugDisplayModeSetByBackdoor = result == NO_ERROR; + return result; } case 1036: { if (data.readInt32() > 0) { @@ -5715,14 +5722,11 @@ status_t SurfaceFlinger::onTransact(uint32_t code, const Parcel& data, Parcel* r std::optional<PhysicalDisplayId> inputId = std::nullopt; if (uint64_t inputDisplayId; data.readUint64(&inputDisplayId) == NO_ERROR) { - const auto token = getPhysicalDisplayToken( - static_cast<PhysicalDisplayId>(inputDisplayId)); - if (!token) { + inputId = DisplayId::fromValue<PhysicalDisplayId>(inputDisplayId); + if (!inputId || getPhysicalDisplayToken(*inputId)) { ALOGE("No display with id: %" PRIu64, inputDisplayId); return NAME_NOT_FOUND; } - - inputId = std::make_optional<PhysicalDisplayId>(inputDisplayId); } { Mutex::Autolock lock(mStateLock); @@ -5974,7 +5978,7 @@ status_t SurfaceFlinger::captureDisplay(const DisplayCaptureArgs& args, captureListener); } -status_t SurfaceFlinger::captureDisplay(uint64_t displayIdOrLayerStack, +status_t SurfaceFlinger::captureDisplay(DisplayId displayId, const sp<IScreenCaptureListener>& captureListener) { ui::LayerStack layerStack; wp<const DisplayDevice> displayWeak; @@ -5982,21 +5986,14 @@ status_t SurfaceFlinger::captureDisplay(uint64_t displayIdOrLayerStack, ui::Dataspace dataspace; { Mutex::Autolock lock(mStateLock); - auto display = getDisplayDeviceLocked(PhysicalDisplayId{displayIdOrLayerStack}); - - // Fall back to first display whose layer stack matches. - if (!display) { - const auto layerStack = static_cast<ui::LayerStack>(displayIdOrLayerStack); - display = findDisplay(WithLayerStack(layerStack)); - } + const auto display = getDisplayDeviceLocked(displayId); if (!display) { return NAME_NOT_FOUND; } - layerStack = display->getLayerStack(); displayWeak = display; - + layerStack = display->getLayerStack(); size = display->getLayerStackSpaceRect().getSize(); dataspace = @@ -6081,7 +6078,11 @@ status_t SurfaceFlinger::captureLayers(const LayerCaptureArgs& args, } } - const auto display = findDisplay(WithLayerStack(parent->getLayerStack())); + const auto display = + findDisplay([layerStack = parent->getLayerStack()](const auto& display) { + return display.getLayerStack() == layerStack; + }); + if (!display) { return NAME_NOT_FOUND; } diff --git a/services/surfaceflinger/SurfaceFlinger.h b/services/surfaceflinger/SurfaceFlinger.h index 22d17eb153..7bc8e13b07 100644 --- a/services/surfaceflinger/SurfaceFlinger.h +++ b/services/surfaceflinger/SurfaceFlinger.h @@ -620,12 +620,10 @@ private: sp<IDisplayEventConnection> createDisplayEventConnection( ISurfaceComposer::VsyncSource vsyncSource = eVsyncSourceApp, ISurfaceComposer::EventRegistrationFlags eventRegistration = {}) override; - status_t captureDisplay(const DisplayCaptureArgs& args, - const sp<IScreenCaptureListener>& captureListener) override; - status_t captureDisplay(uint64_t displayOrLayerStack, - const sp<IScreenCaptureListener>& captureListener) override; - status_t captureLayers(const LayerCaptureArgs& args, - const sp<IScreenCaptureListener>& captureListener) override; + + status_t captureDisplay(const DisplayCaptureArgs&, const sp<IScreenCaptureListener>&) override; + status_t captureDisplay(DisplayId, const sp<IScreenCaptureListener>&) override; + status_t captureLayers(const LayerCaptureArgs&, const sp<IScreenCaptureListener>&) override; status_t getDisplayStats(const sp<IBinder>& displayToken, DisplayStatInfo* stats) override; status_t getDisplayState(const sp<IBinder>& displayToken, ui::DisplayState*) @@ -941,14 +939,6 @@ private: return it == mDisplays.end() ? nullptr : it->second; } - sp<const DisplayDevice> getDisplayDeviceLocked(PhysicalDisplayId id) const - REQUIRES(mStateLock) { - if (const auto token = getPhysicalDisplayTokenLocked(id)) { - return getDisplayDeviceLocked(token); - } - return nullptr; - } - sp<const DisplayDevice> getDefaultDisplayDeviceLocked() const REQUIRES(mStateLock) { return const_cast<SurfaceFlinger*>(this)->getDefaultDisplayDeviceLocked(); } @@ -983,6 +973,8 @@ private: // region of all screens presenting this layer stack. void invalidateLayerStack(const sp<const Layer>& layer, const Region& dirty); + sp<DisplayDevice> getDisplayWithInputByLayer(Layer* layer) const REQUIRES(mStateLock); + /* * H/W composer */ diff --git a/services/surfaceflinger/SurfaceInterceptor.cpp b/services/surfaceflinger/SurfaceInterceptor.cpp index c5f1598d15..843c966bea 100644 --- a/services/surfaceflinger/SurfaceInterceptor.cpp +++ b/services/surfaceflinger/SurfaceInterceptor.cpp @@ -160,6 +160,7 @@ void SurfaceInterceptor::addInitialDisplayStateLocked(Increment* increment, addDisplaySurfaceLocked(transaction, display.sequenceId, display.surface); addDisplayLayerStackLocked(transaction, display.sequenceId, display.layerStack); + addDisplayFlagsLocked(transaction, display.sequenceId, display.flags); addDisplaySizeLocked(transaction, display.sequenceId, display.width, display.height); addDisplayProjectionLocked(transaction, display.sequenceId, toRotationInt(display.orientation), display.layerStackSpaceRect, display.orientedDisplaySpaceRect); @@ -474,6 +475,9 @@ void SurfaceInterceptor::addDisplayChangesLocked(Transaction* transaction, if (state.what & DisplayState::eLayerStackChanged) { addDisplayLayerStackLocked(transaction, sequenceId, state.layerStack); } + if (state.what & DisplayState::eFlagsChanged) { + addDisplayFlagsLocked(transaction, sequenceId, state.flags); + } if (state.what & DisplayState::eDisplaySizeChanged) { addDisplaySizeLocked(transaction, sequenceId, state.width, state.height); } @@ -565,6 +569,13 @@ void SurfaceInterceptor::addDisplayLayerStackLocked(Transaction* transaction, layerStackChange->set_layer_stack(layerStack); } +void SurfaceInterceptor::addDisplayFlagsLocked(Transaction* transaction, int32_t sequenceId, + uint32_t flags) { + DisplayChange* dispChange(createDisplayChangeLocked(transaction, sequenceId)); + DisplayFlagsChange* flagsChange(dispChange->mutable_flags()); + flagsChange->set_flags(flags); +} + void SurfaceInterceptor::addDisplaySizeLocked(Transaction* transaction, int32_t sequenceId, uint32_t w, uint32_t h) { diff --git a/services/surfaceflinger/SurfaceInterceptor.h b/services/surfaceflinger/SurfaceInterceptor.h index 30aca8340e..e498e7d067 100644 --- a/services/surfaceflinger/SurfaceInterceptor.h +++ b/services/surfaceflinger/SurfaceInterceptor.h @@ -184,6 +184,7 @@ private: const sp<const IGraphicBufferProducer>& surface); void addDisplayLayerStackLocked(Transaction* transaction, int32_t sequenceId, uint32_t layerStack); + void addDisplayFlagsLocked(Transaction* transaction, int32_t sequenceId, uint32_t flags); void addDisplaySizeLocked(Transaction* transaction, int32_t sequenceId, uint32_t w, uint32_t h); void addDisplayProjectionLocked(Transaction* transaction, int32_t sequenceId, diff --git a/services/surfaceflinger/tests/fakehwc/SFFakeHwc_test.cpp b/services/surfaceflinger/tests/fakehwc/SFFakeHwc_test.cpp index 162711d6f5..a9e935df22 100644 --- a/services/surfaceflinger/tests/fakehwc/SFFakeHwc_test.cpp +++ b/services/surfaceflinger/tests/fakehwc/SFFakeHwc_test.cpp @@ -279,7 +279,7 @@ protected: } bool waitForHotplugEvent(Display displayId, bool connected) { - return waitForHotplugEvent(PhysicalDisplayId(displayId), connected); + return waitForHotplugEvent(physicalIdFromHwcDisplayId(displayId), connected); } bool waitForHotplugEvent(PhysicalDisplayId displayId, bool connected) { @@ -305,7 +305,7 @@ protected: } bool waitForModeChangedEvent(Display display, int32_t modeId) { - PhysicalDisplayId displayId(display); + PhysicalDisplayId displayId = physicalIdFromHwcDisplayId(display); int waitCount = 20; while (waitCount--) { while (!mReceivedDisplayEvents.empty()) { diff --git a/services/surfaceflinger/tests/unittests/Android.bp b/services/surfaceflinger/tests/unittests/Android.bp index b5086fafb7..bd6fe1d713 100644 --- a/services/surfaceflinger/tests/unittests/Android.bp +++ b/services/surfaceflinger/tests/unittests/Android.bp @@ -23,7 +23,10 @@ package { cc_test { name: "libsurfaceflinger_unittest", - defaults: ["surfaceflinger_defaults"], + defaults: [ + "skia_renderengine_deps", + "surfaceflinger_defaults", + ], test_suites: ["device-tests"], sanitize: { // Using the address sanitizer not only helps uncover issues in the code diff --git a/services/surfaceflinger/tests/unittests/CompositionTest.cpp b/services/surfaceflinger/tests/unittests/CompositionTest.cpp index 560f139719..fca3bfc242 100644 --- a/services/surfaceflinger/tests/unittests/CompositionTest.cpp +++ b/services/surfaceflinger/tests/unittests/CompositionTest.cpp @@ -77,7 +77,7 @@ constexpr hal::HWDisplayId HWC_DISPLAY = FakeHwcDisplayInjector::DEFAULT_HWC_DIS constexpr hal::HWLayerId HWC_LAYER = 5000; constexpr Transform DEFAULT_TRANSFORM = static_cast<Transform>(0); -constexpr PhysicalDisplayId DEFAULT_DISPLAY_ID(42); +constexpr PhysicalDisplayId DEFAULT_DISPLAY_ID = PhysicalDisplayId::fromPort(42u); constexpr int DEFAULT_DISPLAY_WIDTH = 1920; constexpr int DEFAULT_DISPLAY_HEIGHT = 1024; diff --git a/services/surfaceflinger/tests/unittests/DisplayTransactionTest.cpp b/services/surfaceflinger/tests/unittests/DisplayTransactionTest.cpp index cc24323c98..60b0f5334c 100644 --- a/services/surfaceflinger/tests/unittests/DisplayTransactionTest.cpp +++ b/services/surfaceflinger/tests/unittests/DisplayTransactionTest.cpp @@ -122,7 +122,7 @@ void DisplayTransactionTest::injectFakeNativeWindowSurfaceFactory() { sp<DisplayDevice> DisplayTransactionTest::injectDefaultInternalDisplay( std::function<void(FakeDisplayDeviceInjector&)> injectExtra) { - constexpr PhysicalDisplayId DEFAULT_DISPLAY_ID(777); + constexpr PhysicalDisplayId DEFAULT_DISPLAY_ID = PhysicalDisplayId::fromPort(255u); constexpr int DEFAULT_DISPLAY_WIDTH = 1080; constexpr int DEFAULT_DISPLAY_HEIGHT = 1920; constexpr HWDisplayId DEFAULT_DISPLAY_HWC_DISPLAY_ID = 0; diff --git a/services/surfaceflinger/tests/unittests/EventThreadTest.cpp b/services/surfaceflinger/tests/unittests/EventThreadTest.cpp index b4a1481e9c..62acc6b549 100644 --- a/services/surfaceflinger/tests/unittests/EventThreadTest.cpp +++ b/services/surfaceflinger/tests/unittests/EventThreadTest.cpp @@ -41,10 +41,13 @@ namespace android { namespace { -constexpr PhysicalDisplayId INTERNAL_DISPLAY_ID(111); -constexpr PhysicalDisplayId EXTERNAL_DISPLAY_ID(222); -constexpr PhysicalDisplayId DISPLAY_ID_64BIT(0xabcd12349876fedcULL); +constexpr PhysicalDisplayId INTERNAL_DISPLAY_ID = PhysicalDisplayId::fromPort(111u); +constexpr PhysicalDisplayId EXTERNAL_DISPLAY_ID = PhysicalDisplayId::fromPort(222u); +constexpr PhysicalDisplayId DISPLAY_ID_64BIT = + PhysicalDisplayId::fromEdid(0xffu, 0xffffu, 0xffff'ffffu); + constexpr std::chrono::duration VSYNC_PERIOD(16ms); + class MockVSyncSource : public VSyncSource { public: const char* getName() const override { return "test"; } diff --git a/services/surfaceflinger/tests/unittests/OneShotTimerTest.cpp b/services/surfaceflinger/tests/unittests/OneShotTimerTest.cpp index 691676420c..597e5e71a2 100644 --- a/services/surfaceflinger/tests/unittests/OneShotTimerTest.cpp +++ b/services/surfaceflinger/tests/unittests/OneShotTimerTest.cpp @@ -72,7 +72,8 @@ TEST_F(OneShotTimerTest, startStopTest) { mIdleTimer->stop(); } -TEST_F(OneShotTimerTest, resetTest) { +// TODO(b/186417847) This test is flaky. Reenable once fixed. +TEST_F(OneShotTimerTest, DISABLED_resetTest) { fake::FakeClock* clock = new fake::FakeClock(); mIdleTimer = std::make_unique<scheduler::OneShotTimer>("TestTimer", 1ms, mResetTimerCallback.getInvocable(), @@ -94,7 +95,8 @@ TEST_F(OneShotTimerTest, resetTest) { EXPECT_FALSE(mResetTimerCallback.waitForUnexpectedCall().has_value()); } -TEST_F(OneShotTimerTest, resetBackToBackTest) { +// TODO(b/186417847) This test is flaky. Reenable once fixed. +TEST_F(OneShotTimerTest, DISABLED_resetBackToBackTest) { fake::FakeClock* clock = new fake::FakeClock(); mIdleTimer = std::make_unique<scheduler::OneShotTimer>("TestTimer", 1ms, mResetTimerCallback.getInvocable(), @@ -144,7 +146,8 @@ TEST_F(OneShotTimerTest, startNotCalledTest) { EXPECT_FALSE(mResetTimerCallback.waitForUnexpectedCall().has_value()); } -TEST_F(OneShotTimerTest, idleTimerIdlesTest) { +// TODO(b/186417847) This test is flaky. Reenable once fixed. +TEST_F(OneShotTimerTest, DISABLED_idleTimerIdlesTest) { fake::FakeClock* clock = new fake::FakeClock(); mIdleTimer = std::make_unique<scheduler::OneShotTimer>("TestTimer", 1ms, mResetTimerCallback.getInvocable(), @@ -169,7 +172,8 @@ TEST_F(OneShotTimerTest, idleTimerIdlesTest) { EXPECT_FALSE(mResetTimerCallback.waitForUnexpectedCall().has_value()); } -TEST_F(OneShotTimerTest, timeoutCallbackExecutionTest) { +// TODO(b/186417847) This test is flaky. Reenable once fixed. +TEST_F(OneShotTimerTest, DISABLED_timeoutCallbackExecutionTest) { fake::FakeClock* clock = new fake::FakeClock(); mIdleTimer = std::make_unique<scheduler::OneShotTimer>("TestTimer", 1ms, mResetTimerCallback.getInvocable(), diff --git a/services/surfaceflinger/tests/unittests/SchedulerTest.cpp b/services/surfaceflinger/tests/unittests/SchedulerTest.cpp index f680d802e6..0023aa0ab3 100644 --- a/services/surfaceflinger/tests/unittests/SchedulerTest.cpp +++ b/services/surfaceflinger/tests/unittests/SchedulerTest.cpp @@ -34,7 +34,7 @@ using testing::Return; namespace android { namespace { -constexpr PhysicalDisplayId PHYSICAL_DISPLAY_ID(999); +constexpr PhysicalDisplayId PHYSICAL_DISPLAY_ID = PhysicalDisplayId::fromPort(255u); class SchedulerTest : public testing::Test { protected: diff --git a/services/surfaceflinger/tests/unittests/SurfaceFlinger_SetDisplayStateTest.cpp b/services/surfaceflinger/tests/unittests/SurfaceFlinger_SetDisplayStateTest.cpp index be019848fb..fc40818ad1 100644 --- a/services/surfaceflinger/tests/unittests/SurfaceFlinger_SetDisplayStateTest.cpp +++ b/services/surfaceflinger/tests/unittests/SurfaceFlinger_SetDisplayStateTest.cpp @@ -224,6 +224,74 @@ TEST_F(SetDisplayStateLockedTest, setDisplayStateLockedRequestsUpdateIfLayerStac EXPECT_EQ(456u, display.getCurrentDisplayState().layerStack); } +TEST_F(SetDisplayStateLockedTest, setDisplayStateLockedDoesNothingIfFlagsNotChanged) { + using Case = SimplePrimaryDisplayCase; + + // -------------------------------------------------------------------- + // Preconditions + + // A display is set up + auto display = Case::Display::makeFakeExistingDisplayInjector(this); + display.inject(); + + // The display has flags set + display.mutableCurrentDisplayState().flags = 1u; + + // The incoming request sets a different layer stack + DisplayState state; + state.what = DisplayState::eFlagsChanged; + state.token = display.token(); + state.flags = 1u; + + // -------------------------------------------------------------------- + // Invocation + + uint32_t flags = mFlinger.setDisplayStateLocked(state); + + // -------------------------------------------------------------------- + // Postconditions + + // The returned flags are empty + EXPECT_EQ(0u, flags); + + // The desired display state has been set to the new value. + EXPECT_EQ(1u, display.getCurrentDisplayState().flags); +} + +TEST_F(SetDisplayStateLockedTest, setDisplayStateLockedRequestsUpdateIfFlagsChanged) { + using Case = SimplePrimaryDisplayCase; + + // -------------------------------------------------------------------- + // Preconditions + + // A display is set up + auto display = Case::Display::makeFakeExistingDisplayInjector(this); + display.inject(); + + // The display has a layer stack set + display.mutableCurrentDisplayState().flags = 0u; + + // The incoming request sets a different layer stack + DisplayState state; + state.what = DisplayState::eFlagsChanged; + state.token = display.token(); + state.flags = 1u; + + // -------------------------------------------------------------------- + // Invocation + + uint32_t flags = mFlinger.setDisplayStateLocked(state); + + // -------------------------------------------------------------------- + // Postconditions + + // The returned flags indicate a transaction is needed + EXPECT_EQ(eDisplayTransactionNeeded, flags); + + // The desired display state has been set to the new value. + EXPECT_EQ(1u, display.getCurrentDisplayState().flags); +} + TEST_F(SetDisplayStateLockedTest, setDisplayStateLockedDoesNothingIfProjectionDidNotChange) { using Case = SimplePrimaryDisplayCase; constexpr ui::Rotation initialOrientation = ui::ROTATION_180; diff --git a/services/surfaceflinger/tests/unittests/mock/DisplayHardware/MockComposer.cpp b/services/surfaceflinger/tests/unittests/mock/DisplayHardware/MockComposer.cpp index 7de187207e..20d41e6072 100644 --- a/services/surfaceflinger/tests/unittests/mock/DisplayHardware/MockComposer.cpp +++ b/services/surfaceflinger/tests/unittests/mock/DisplayHardware/MockComposer.cpp @@ -18,6 +18,7 @@ #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wconversion" +#undef LOG_TAG #define LOG_TAG "MockComposer" #include "mock/DisplayHardware/MockComposer.h" |