Merge "Revert^2 "Linker namespace configuration for the Runtime APEX.""
diff --git a/adb/adb_io.cpp b/adb/adb_io.cpp
index 6cc274b..e6fefda 100644
--- a/adb/adb_io.cpp
+++ b/adb/adb_io.cpp
@@ -38,7 +38,8 @@
// The cost of sending two strings outweighs the cost of formatting.
// "adb sync" performance is affected by this.
- return WriteFdFmt(fd, "%04x%.*s", length, length, s.c_str());
+ auto str = android::base::StringPrintf("%04x", length).append(s);
+ return WriteFdExactly(fd, str);
}
bool ReadProtocolString(int fd, std::string* s, std::string* error) {
diff --git a/fastboot/device/flashing.cpp b/fastboot/device/flashing.cpp
index 963916c..f737405 100644
--- a/fastboot/device/flashing.cpp
+++ b/fastboot/device/flashing.cpp
@@ -143,6 +143,11 @@
return device->WriteFail("Data is not a valid logical partition metadata image");
}
+ if (!FindPhysicalPartition(super_name)) {
+ return device->WriteFail("Cannot find " + super_name +
+ ", build may be missing broken or missing boot_devices");
+ }
+
// If we are unable to read the existing metadata, then the super partition
// is corrupt. In this case we reflash the whole thing using the provided
// image.
diff --git a/fs_mgr/libdm/Android.bp b/fs_mgr/libdm/Android.bp
index 22af123..90bce51 100644
--- a/fs_mgr/libdm/Android.bp
+++ b/fs_mgr/libdm/Android.bp
@@ -20,10 +20,6 @@
recovery_available: true,
export_include_dirs: ["include"],
- cflags: [
- // TODO(b/110035986): Allows us to create a skeleton of required classes
- "-Wno-unused-private-field",
- ],
srcs: [
"dm_table.cpp",
diff --git a/init/first_stage_mount.cpp b/init/first_stage_mount.cpp
index acefdf0..b5ff658 100644
--- a/init/first_stage_mount.cpp
+++ b/init/first_stage_mount.cpp
@@ -395,6 +395,11 @@
return false;
}
if (fs_mgr_do_mount_one(*fstab_entry)) {
+ if (fstab_entry->fs_mgr_flags.formattable) {
+ PLOG(INFO) << "Failed to mount '" << fstab_entry->mount_point << "', "
+ << "ignoring mount for formattable partition";
+ return true;
+ }
PLOG(ERROR) << "Failed to mount '" << fstab_entry->mount_point << "'";
return false;
}
diff --git a/libmeminfo/tools/Android.bp b/libmeminfo/tools/Android.bp
index 715d63d..1f93494 100644
--- a/libmeminfo/tools/Android.bp
+++ b/libmeminfo/tools/Android.bp
@@ -13,11 +13,24 @@
// limitations under the License.
cc_binary {
+ name: "librank2",
+ cflags: [
+ "-Wall",
+ "-Werror",
+ ],
+
+ srcs: ["librank.cpp"],
+ shared_libs: [
+ "libbase",
+ "libmeminfo",
+ ],
+}
+
+cc_binary {
name: "procmem2",
cflags: [
"-Wall",
"-Werror",
- "-Wno-unused-parameter",
],
srcs: ["procmem.cpp"],
@@ -32,7 +45,6 @@
cflags: [
"-Wall",
"-Werror",
- "-Wno-unused-parameter",
],
srcs: ["procrank.cpp"],
diff --git a/libmeminfo/tools/librank.cpp b/libmeminfo/tools/librank.cpp
new file mode 100644
index 0000000..7668640
--- /dev/null
+++ b/libmeminfo/tools/librank.cpp
@@ -0,0 +1,350 @@
+/*
+ * Copyright (C) 2018 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 <dirent.h>
+#include <errno.h>
+#include <error.h>
+#include <inttypes.h>
+#include <linux/kernel-page-flags.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <sys/mman.h>
+#include <sys/types.h>
+#include <unistd.h>
+
+#include <algorithm>
+#include <memory>
+#include <vector>
+
+#include <android-base/file.h>
+#include <android-base/parseint.h>
+#include <android-base/stringprintf.h>
+#include <android-base/strings.h>
+
+#include <meminfo/procmeminfo.h>
+
+using ::android::meminfo::MemUsage;
+using ::android::meminfo::ProcMemInfo;
+using ::android::meminfo::Vma;
+
+[[noreturn]] static void usage(const char* myname, int exit_status) {
+ fprintf(stderr,
+ "Usage: %s [ -P | -L ] [ -v | -r | -p | -u | -s | -h ]\n"
+ "\n"
+ "Sort options:\n"
+ " -v Sort processes by VSS.\n"
+ " -r Sort processes by RSS.\n"
+ " -p Sort processes by PSS.\n"
+ " -u Sort processes by USS.\n"
+ " -s Sort processes by swap.\n"
+ " (Default sort order is PSS.)\n"
+ " -a Show all mappings, including stack, heap and anon.\n"
+ " -P /path Limit libraries displayed to those in path.\n"
+ " -R Reverse sort order (default is descending).\n"
+ " -m [r][w][x] Only list pages that exactly match permissions\n"
+ " -c Only show cached (storage backed) pages\n"
+ " -C Only show non-cached (ram/swap backed) pages\n"
+ " -k Only show pages collapsed by KSM\n"
+ " -h Display this help screen.\n",
+ myname);
+ exit(exit_status);
+}
+
+static void add_mem_usage(MemUsage* to, const MemUsage& from) {
+ to->vss += from.vss;
+ to->rss += from.rss;
+ to->pss += from.pss;
+ to->uss += from.uss;
+
+ to->swap += from.swap;
+
+ to->private_clean += from.private_clean;
+ to->private_dirty += from.private_dirty;
+
+ to->shared_clean += from.shared_clean;
+ to->shared_dirty += from.shared_dirty;
+}
+
+struct ProcessRecord {
+ public:
+ ProcessRecord(pid_t pid) : pid_(-1), cmdline_("") {
+ std::string fname = ::android::base::StringPrintf("/proc/%d/cmdline", pid);
+ std::string cmdline;
+ if (!::android::base::ReadFileToString(fname, &cmdline)) {
+ fprintf(stderr, "Failed to read cmdline from: %s\n", fname.c_str());
+ return;
+ }
+ // We deliberately don't read the proc/<pid>cmdline file directly into 'cmdline_'
+ // because of some processes showing up cmdlines that end with "0x00 0x0A 0x00"
+ // e.g. xtra-daemon, lowi-server
+ // The .c_str() assignment below then takes care of trimming the cmdline at the first
+ // 0x00. This is how original procrank worked (luckily)
+ cmdline_ = cmdline.c_str();
+ pid_ = pid;
+ usage_.clear();
+ }
+
+ ~ProcessRecord() = default;
+
+ bool valid() const { return pid_ != -1; }
+
+ // Getters
+ pid_t pid() const { return pid_; }
+ const std::string& cmdline() const { return cmdline_; }
+ const MemUsage& usage() const { return usage_; }
+
+ // Add to the usage
+ void AddUsage(const MemUsage& mem_usage) { add_mem_usage(&usage_, mem_usage); }
+
+ private:
+ pid_t pid_;
+ std::string cmdline_;
+ MemUsage usage_;
+};
+
+struct LibRecord {
+ public:
+ LibRecord(const std::string& name) : name_(name) {}
+ ~LibRecord() = default;
+
+ const std::string& name() const { return name_; }
+ const MemUsage& usage() const { return usage_; }
+ const std::vector<ProcessRecord>& processes() const { return procs_; }
+ uint64_t pss() const { return usage_.pss; }
+ void AddUsage(const ProcessRecord& proc, const MemUsage& mem_usage) {
+ auto process = std::find_if(procs_.begin(), procs_.end(),
+ [&](auto p) -> bool { return p.pid() == proc.pid(); });
+ if (process == procs_.end()) {
+ process = procs_.emplace(procs_.end(), proc.pid());
+ }
+ process->AddUsage(mem_usage);
+ add_mem_usage(&usage_, mem_usage);
+ }
+
+ void Sort(std::function<bool(const ProcessRecord&, const ProcessRecord&)>& sorter) {
+ std::sort(procs_.begin(), procs_.end(), sorter);
+ }
+
+ private:
+ std::string name_;
+ MemUsage usage_;
+ std::vector<ProcessRecord> procs_;
+};
+
+// List of every library / map
+static std::vector<LibRecord> g_libs;
+
+// List of library/map names that we don't want to show by default
+static const std::vector<std::string> g_blacklisted_libs = {"[heap]", "[stack]"};
+
+// Global flags affected by command line
+static uint64_t g_pgflags = 0;
+static uint64_t g_pgflags_mask = 0;
+static uint16_t g_mapflags_mask = 0;
+static bool g_all_libs = false;
+static bool g_has_swap = false;
+static bool g_reverse_sort = false;
+static std::string g_prefix_filter = "";
+
+static bool read_all_pids(std::function<bool(pid_t pid)> for_each_pid) {
+ std::unique_ptr<DIR, int (*)(DIR*)> procdir(opendir("/proc"), closedir);
+ if (!procdir) return false;
+
+ struct dirent* dir;
+ pid_t pid;
+ while ((dir = readdir(procdir.get()))) {
+ if (!::android::base::ParseInt(dir->d_name, &pid)) continue;
+ if (!for_each_pid(pid)) return false;
+ }
+
+ return true;
+}
+
+static bool scan_libs_per_process(pid_t pid) {
+ ProcMemInfo pmem(pid, false, g_pgflags, g_pgflags_mask);
+ const std::vector<Vma> maps = pmem.Maps();
+ if (maps.size() == 0) {
+ // nothing to do here, continue
+ return true;
+ }
+
+ ProcessRecord proc(pid);
+ if (!proc.valid()) {
+ fprintf(stderr, "Failed to create process record for process: %d\n", pid);
+ return false;
+ }
+
+ for (auto& map : maps) {
+ // skip library / map if prefix for the path doesn't match
+ if (!g_prefix_filter.empty() && !::android::base::StartsWith(map.name, g_prefix_filter)) {
+ continue;
+ }
+ // Skip maps based on map permissions
+ if (g_mapflags_mask &&
+ ((map.flags & (PROT_READ | PROT_WRITE | PROT_EXEC)) != g_mapflags_mask)) {
+ continue;
+ }
+
+ // skip blacklisted library / map names
+ if (!g_all_libs && (std::find(g_blacklisted_libs.begin(), g_blacklisted_libs.end(),
+ map.name) != g_blacklisted_libs.end())) {
+ continue;
+ }
+
+ auto lib = std::find_if(g_libs.begin(), g_libs.end(),
+ [&](auto l) -> bool { return map.name == l.name(); });
+ if (lib == g_libs.end()) {
+ lib = g_libs.emplace(g_libs.end(), map.name);
+ }
+
+ lib->AddUsage(proc, map.usage);
+ if (!g_has_swap && map.usage.swap) {
+ g_has_swap = true;
+ }
+ }
+
+ return true;
+}
+
+static uint16_t parse_mapflags(const char* mapflags) {
+ uint16_t ret = 0;
+ for (const char* p = mapflags; *p; p++) {
+ switch (*p) {
+ case 'r':
+ ret |= PROT_READ;
+ break;
+ case 'w':
+ ret |= PROT_WRITE;
+ break;
+ case 'x':
+ ret |= PROT_EXEC;
+ break;
+ default:
+ error(EXIT_FAILURE, 0, "Invalid permissions string: %s, %s", mapflags, p);
+ }
+ }
+
+ return ret;
+}
+
+int main(int argc, char* argv[]) {
+ int opt;
+
+ auto pss_sort = [](const ProcessRecord& a, const ProcessRecord& b) {
+ return g_reverse_sort ? a.usage().pss < b.usage().pss : a.usage().pss > b.usage().pss;
+ };
+
+ auto uss_sort = [](const ProcessRecord& a, const ProcessRecord& b) {
+ return g_reverse_sort ? a.usage().uss < b.usage().uss : a.usage().uss > b.usage().uss;
+ };
+
+ auto vss_sort = [](const ProcessRecord& a, const ProcessRecord& b) {
+ return g_reverse_sort ? a.usage().vss < b.usage().vss : a.usage().vss > b.usage().vss;
+ };
+
+ auto rss_sort = [](const ProcessRecord& a, const ProcessRecord& b) {
+ return g_reverse_sort ? a.usage().rss < b.usage().rss : a.usage().rss > b.usage().rss;
+ };
+
+ auto swap_sort = [](const ProcessRecord& a, const ProcessRecord& b) {
+ return g_reverse_sort ? a.usage().swap < b.usage().swap : a.usage().swap > b.usage().swap;
+ };
+
+ std::function<bool(const ProcessRecord&, const ProcessRecord&)> sort_func = pss_sort;
+
+ while ((opt = getopt(argc, argv, "acChkm:pP:uvrsR")) != -1) {
+ switch (opt) {
+ case 'a':
+ g_all_libs = true;
+ break;
+ case 'c':
+ g_pgflags = 0;
+ g_pgflags_mask = (1 << KPF_SWAPBACKED);
+ break;
+ case 'C':
+ g_pgflags = g_pgflags_mask = (1 << KPF_SWAPBACKED);
+ break;
+ case 'h':
+ usage(argv[0], EXIT_SUCCESS);
+ case 'k':
+ g_pgflags = g_pgflags_mask = (1 << KPF_KSM);
+ break;
+ case 'm':
+ g_mapflags_mask = parse_mapflags(optarg);
+ break;
+ case 'p':
+ sort_func = pss_sort;
+ break;
+ case 'P':
+ g_prefix_filter = optarg;
+ break;
+ case 'u':
+ sort_func = uss_sort;
+ break;
+ case 'v':
+ sort_func = vss_sort;
+ break;
+ case 'r':
+ sort_func = rss_sort;
+ break;
+ case 's':
+ sort_func = swap_sort;
+ break;
+ case 'R':
+ g_reverse_sort = true;
+ break;
+ default:
+ usage(argv[0], EXIT_FAILURE);
+ }
+ }
+
+ if (!read_all_pids(scan_libs_per_process)) {
+ error(EXIT_FAILURE, 0, "Failed to read all pids from the system");
+ }
+
+ printf(" %6s %7s %6s %6s %6s ", "RSStot", "VSS", "RSS", "PSS", "USS");
+ if (g_has_swap) {
+ printf(" %6s ", "Swap");
+ }
+ printf("Name/PID\n");
+
+ // sort the libraries by their pss
+ std::sort(g_libs.begin(), g_libs.end(),
+ [](const LibRecord& l1, const LibRecord& l2) { return l1.pss() > l2.pss(); });
+
+ for (auto& lib : g_libs) {
+ printf("%6" PRIu64 "K %7s %6s %6s %6s ", lib.pss() / 1024, "", "", "", "");
+ if (g_has_swap) {
+ printf(" %6s ", "");
+ }
+ printf("%s\n", lib.name().c_str());
+
+ // sort all mappings first
+ lib.Sort(sort_func);
+
+ for (auto& p : lib.processes()) {
+ const MemUsage& usage = p.usage();
+ printf(" %6s %7" PRIu64 "K %6" PRIu64 "K %6" PRIu64 "K %6" PRIu64 "K ", "",
+ usage.vss / 1024, usage.rss / 1024, usage.pss / 1024, usage.uss / 1024);
+ if (g_has_swap) {
+ printf("%6" PRIu64 "K ", usage.swap / 1024);
+ }
+ printf(" %s [%d]\n", p.cmdline().c_str(), p.pid());
+ }
+ }
+
+ return 0;
+}
diff --git a/libunwindstack/DwarfCfa.cpp b/libunwindstack/DwarfCfa.cpp
index 4ba8a4b..c128b9b 100644
--- a/libunwindstack/DwarfCfa.cpp
+++ b/libunwindstack/DwarfCfa.cpp
@@ -204,7 +204,7 @@
bool DwarfCfa<AddressType>::LogInstruction(uint32_t indent, uint64_t cfa_offset, uint8_t op,
uint64_t* cur_pc) {
const auto* cfa = &DwarfCfaInfo::kTable[op];
- if (cfa->name == nullptr) {
+ if (cfa->name[0] == '\0') {
log(indent, "Illegal");
log(indent, "Raw Data: 0x%02x", op);
return true;
@@ -677,29 +677,29 @@
{DW_EH_PE_uleb128, DW_EH_PE_block},
{DWARF_DISPLAY_REGISTER, DWARF_DISPLAY_EVAL_BLOCK},
},
- {nullptr, 0, 0, {}, {}}, // 0x17 illegal cfa
- {nullptr, 0, 0, {}, {}}, // 0x18 illegal cfa
- {nullptr, 0, 0, {}, {}}, // 0x19 illegal cfa
- {nullptr, 0, 0, {}, {}}, // 0x1a illegal cfa
- {nullptr, 0, 0, {}, {}}, // 0x1b illegal cfa
- {nullptr, 0, 0, {}, {}}, // 0x1c DW_CFA_lo_user (Treat as illegal)
- {nullptr, 0, 0, {}, {}}, // 0x1d illegal cfa
- {nullptr, 0, 0, {}, {}}, // 0x1e illegal cfa
- {nullptr, 0, 0, {}, {}}, // 0x1f illegal cfa
- {nullptr, 0, 0, {}, {}}, // 0x20 illegal cfa
- {nullptr, 0, 0, {}, {}}, // 0x21 illegal cfa
- {nullptr, 0, 0, {}, {}}, // 0x22 illegal cfa
- {nullptr, 0, 0, {}, {}}, // 0x23 illegal cfa
- {nullptr, 0, 0, {}, {}}, // 0x24 illegal cfa
- {nullptr, 0, 0, {}, {}}, // 0x25 illegal cfa
- {nullptr, 0, 0, {}, {}}, // 0x26 illegal cfa
- {nullptr, 0, 0, {}, {}}, // 0x27 illegal cfa
- {nullptr, 0, 0, {}, {}}, // 0x28 illegal cfa
- {nullptr, 0, 0, {}, {}}, // 0x29 illegal cfa
- {nullptr, 0, 0, {}, {}}, // 0x2a illegal cfa
- {nullptr, 0, 0, {}, {}}, // 0x2b illegal cfa
- {nullptr, 0, 0, {}, {}}, // 0x2c illegal cfa
- {nullptr, 0, 0, {}, {}}, // 0x2d DW_CFA_GNU_window_save (Treat as illegal)
+ {"", 0, 0, {}, {}}, // 0x17 illegal cfa
+ {"", 0, 0, {}, {}}, // 0x18 illegal cfa
+ {"", 0, 0, {}, {}}, // 0x19 illegal cfa
+ {"", 0, 0, {}, {}}, // 0x1a illegal cfa
+ {"", 0, 0, {}, {}}, // 0x1b illegal cfa
+ {"", 0, 0, {}, {}}, // 0x1c DW_CFA_lo_user (Treat as illegal)
+ {"", 0, 0, {}, {}}, // 0x1d illegal cfa
+ {"", 0, 0, {}, {}}, // 0x1e illegal cfa
+ {"", 0, 0, {}, {}}, // 0x1f illegal cfa
+ {"", 0, 0, {}, {}}, // 0x20 illegal cfa
+ {"", 0, 0, {}, {}}, // 0x21 illegal cfa
+ {"", 0, 0, {}, {}}, // 0x22 illegal cfa
+ {"", 0, 0, {}, {}}, // 0x23 illegal cfa
+ {"", 0, 0, {}, {}}, // 0x24 illegal cfa
+ {"", 0, 0, {}, {}}, // 0x25 illegal cfa
+ {"", 0, 0, {}, {}}, // 0x26 illegal cfa
+ {"", 0, 0, {}, {}}, // 0x27 illegal cfa
+ {"", 0, 0, {}, {}}, // 0x28 illegal cfa
+ {"", 0, 0, {}, {}}, // 0x29 illegal cfa
+ {"", 0, 0, {}, {}}, // 0x2a illegal cfa
+ {"", 0, 0, {}, {}}, // 0x2b illegal cfa
+ {"", 0, 0, {}, {}}, // 0x2c illegal cfa
+ {"", 0, 0, {}, {}}, // 0x2d DW_CFA_GNU_window_save (Treat as illegal)
{
"DW_CFA_GNU_args_size", // 0x2e DW_CFA_GNU_args_size
2,
@@ -714,21 +714,21 @@
{DW_EH_PE_uleb128, DW_EH_PE_uleb128},
{DWARF_DISPLAY_REGISTER, DWARF_DISPLAY_NUMBER},
},
- {nullptr, 0, 0, {}, {}}, // 0x31 illegal cfa
- {nullptr, 0, 0, {}, {}}, // 0x32 illegal cfa
- {nullptr, 0, 0, {}, {}}, // 0x33 illegal cfa
- {nullptr, 0, 0, {}, {}}, // 0x34 illegal cfa
- {nullptr, 0, 0, {}, {}}, // 0x35 illegal cfa
- {nullptr, 0, 0, {}, {}}, // 0x36 illegal cfa
- {nullptr, 0, 0, {}, {}}, // 0x37 illegal cfa
- {nullptr, 0, 0, {}, {}}, // 0x38 illegal cfa
- {nullptr, 0, 0, {}, {}}, // 0x39 illegal cfa
- {nullptr, 0, 0, {}, {}}, // 0x3a illegal cfa
- {nullptr, 0, 0, {}, {}}, // 0x3b illegal cfa
- {nullptr, 0, 0, {}, {}}, // 0x3c illegal cfa
- {nullptr, 0, 0, {}, {}}, // 0x3d illegal cfa
- {nullptr, 0, 0, {}, {}}, // 0x3e illegal cfa
- {nullptr, 0, 0, {}, {}}, // 0x3f DW_CFA_hi_user (Treat as illegal)
+ {"", 0, 0, {}, {}}, // 0x31 illegal cfa
+ {"", 0, 0, {}, {}}, // 0x32 illegal cfa
+ {"", 0, 0, {}, {}}, // 0x33 illegal cfa
+ {"", 0, 0, {}, {}}, // 0x34 illegal cfa
+ {"", 0, 0, {}, {}}, // 0x35 illegal cfa
+ {"", 0, 0, {}, {}}, // 0x36 illegal cfa
+ {"", 0, 0, {}, {}}, // 0x37 illegal cfa
+ {"", 0, 0, {}, {}}, // 0x38 illegal cfa
+ {"", 0, 0, {}, {}}, // 0x39 illegal cfa
+ {"", 0, 0, {}, {}}, // 0x3a illegal cfa
+ {"", 0, 0, {}, {}}, // 0x3b illegal cfa
+ {"", 0, 0, {}, {}}, // 0x3c illegal cfa
+ {"", 0, 0, {}, {}}, // 0x3d illegal cfa
+ {"", 0, 0, {}, {}}, // 0x3e illegal cfa
+ {"", 0, 0, {}, {}}, // 0x3f DW_CFA_hi_user (Treat as illegal)
};
// Explicitly instantiate DwarfCfa.
diff --git a/libunwindstack/DwarfCfa.h b/libunwindstack/DwarfCfa.h
index c5ffb8e..569c17c 100644
--- a/libunwindstack/DwarfCfa.h
+++ b/libunwindstack/DwarfCfa.h
@@ -49,7 +49,14 @@
};
struct Info {
- const char* name;
+ // It may seem cleaner to just change the type of 'name' to 'const char *'.
+ // However, having a pointer here would require relocation at runtime,
+ // causing 'kTable' to be placed in data.rel.ro section instead of rodata
+ // section, adding memory pressure to the system. Note that this is only
+ // safe because this is only used in C++ code. C++ standard, unlike C
+ // standard, mandates the array size to be large enough to hold the NULL
+ // terminator when initialized with a string literal.
+ const char name[36];
uint8_t supported_version;
uint8_t num_operands;
uint8_t operands[2];
diff --git a/logd/LogBufferElement.cpp b/logd/LogBufferElement.cpp
index 19e6d68..2fd9f95 100644
--- a/logd/LogBufferElement.cpp
+++ b/logd/LogBufferElement.cpp
@@ -55,8 +55,19 @@
mMsgLen(elem.mMsgLen),
mLogId(elem.mLogId),
mDropped(elem.mDropped) {
- mMsg = new char[mMsgLen];
- memcpy(mMsg, elem.mMsg, mMsgLen);
+ if (mDropped) {
+ if (elem.isBinary() && elem.mMsg != nullptr) {
+ // for the following "len" value, refer to : setDropped(uint16_t value), getTag()
+ const int len = sizeof(android_event_header_t);
+ mMsg = new char[len];
+ memcpy(mMsg, elem.mMsg, len);
+ } else {
+ mMsg = nullptr;
+ }
+ } else {
+ mMsg = new char[mMsgLen];
+ memcpy(mMsg, elem.mMsg, mMsgLen);
+ }
}
LogBufferElement::~LogBufferElement() {
diff --git a/rootdir/init.rc b/rootdir/init.rc
index 6fb1a8b..483fc51 100644
--- a/rootdir/init.rc
+++ b/rootdir/init.rc
@@ -545,6 +545,7 @@
mkdir /data/anr 0775 system system
mkdir /data/apex 0770 root root
+ mkdir /data/staging 0750 system system
# NFC: create data/nfc for nv storage
mkdir /data/nfc 0770 nfc nfc