meminfo: Add memtrack dmabufinfo library
This is the userspace component for the improved shared memory buffer
tracking.
A new static library called libdmabufinfo will provide APIs to parse dmabuf
debugfs entries. The library can also map and read the file descriptors
per process to cross-reference the global data per process.
This change only adds a global API to read dmabuf stats from debugfs.
Bug: 63860998
Test: dmabufinfo_test
Change-Id: Ib0deedc73337a70875e03e07d3e9a692c4c33e63
Signed-off-by: Greg Hackmann <ghackmann@google.com>
Signed-off-by: Erick Reyes <erickreyes@google.com>
Signed-off-by: Sandeep Patil <sspatil@google.com>
diff --git a/libmeminfo/libdmabufinfo/dmabufinfo.cpp b/libmeminfo/libdmabufinfo/dmabufinfo.cpp
new file mode 100644
index 0000000..41ecc51
--- /dev/null
+++ b/libmeminfo/libdmabufinfo/dmabufinfo.cpp
@@ -0,0 +1,241 @@
+/*
+ * Copyright (C) 2019 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 <dmabufinfo/dmabufinfo.h>
+
+#include <inttypes.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <sys/stat.h>
+#include <sys/types.h>
+#include <unistd.h>
+
+#include <filesystem>
+#include <memory>
+#include <string>
+#include <vector>
+
+#include <android-base/file.h>
+#include <android-base/logging.h>
+#include <android-base/parseint.h>
+#include <android-base/stringprintf.h>
+#include <android-base/strings.h>
+#include <procinfo/process_map.h>
+
+namespace android {
+namespace dmabufinfo {
+
+static bool FileIsDmaBuf(const std::string& path) {
+ return ::android::base::StartsWith(path, "/dmabuf");
+}
+
+static bool ReadDmaBufFdInfo(pid_t pid, int fd, std::string* name, std::string* exporter,
+ uint64_t* count) {
+ std::string fdinfo = ::android::base::StringPrintf("/proc/%d/fdinfo/%d", pid, fd);
+ auto fp = std::unique_ptr<FILE, decltype(&fclose)>{fopen(fdinfo.c_str(), "re"), fclose};
+ if (fp == nullptr) {
+ LOG(ERROR) << "Failed to open dmabuf info from debugfs";
+ return false;
+ }
+
+ char* line = nullptr;
+ size_t len = 0;
+ while (getline(&line, &len, fp.get()) > 0) {
+ switch (line[0]) {
+ case 'c':
+ if (strncmp(line, "count:", 6) == 0) {
+ char* c = line + 6;
+ *count = strtoull(c, nullptr, 10);
+ }
+ break;
+ case 'e':
+ if (strncmp(line, "exp_name:", 9) == 0) {
+ char* c = line + 9;
+ *exporter = ::android::base::Trim(c);
+ }
+ break;
+ case 'n':
+ if (strncmp(line, "name:", 5) == 0) {
+ char* c = line + 5;
+ *name = ::android::base::Trim(std::string(c));
+ }
+ break;
+ }
+ }
+
+ free(line);
+ return true;
+}
+
+static bool ReadDmaBufFdRefs(pid_t pid, std::vector<DmaBuffer>* dmabufs) {
+ std::string fdpath = ::android::base::StringPrintf("/proc/%d/fd", pid);
+ for (auto& de : std::filesystem::directory_iterator(fdpath)) {
+ if (!std::filesystem::is_symlink(de.path())) {
+ continue;
+ }
+
+ std::string target;
+ if (!::android::base::Readlink(de.path().string(), &target)) {
+ LOG(ERROR) << "Failed to find target for symlink: " << de.path().string();
+ return false;
+ }
+
+ if (!FileIsDmaBuf(target)) {
+ continue;
+ }
+
+ int fd;
+ if (!::android::base::ParseInt(de.path().filename().string(), &fd)) {
+ LOG(ERROR) << "Dmabuf fd: " << de.path().string() << " is invalid";
+ return false;
+ }
+
+ // Set defaults in case the kernel doesn't give us the information
+ // we need in fdinfo
+ std::string name = "<unknown>";
+ std::string exporter = "<unknown>";
+ uint64_t count = 0;
+ if (!ReadDmaBufFdInfo(pid, fd, &name, &exporter, &count)) {
+ LOG(ERROR) << "Failed to read fdinfo for: " << de.path().string();
+ return false;
+ }
+
+ struct stat sb;
+ if (stat(de.path().c_str(), &sb) < 0) {
+ PLOG(ERROR) << "Failed to stat: " << de.path().string();
+ return false;
+ }
+
+ DmaBuffer& buf =
+ dmabufs->emplace_back(sb.st_ino, sb.st_blocks * 512, count, exporter, name);
+ buf.AddFdRef(pid);
+ }
+
+ return true;
+}
+
+static bool ReadDmaBufMapRefs(pid_t pid, std::vector<DmaBuffer>* dmabufs) {
+ std::string mapspath = ::android::base::StringPrintf("/proc/%d/maps", pid);
+ auto fp = std::unique_ptr<FILE, decltype(&fclose)>{fopen(mapspath.c_str(), "re"), fclose};
+ if (fp == nullptr) {
+ LOG(ERROR) << "Failed to open maps for pid: " << pid;
+ return false;
+ }
+
+ char* line = nullptr;
+ size_t len = 0;
+
+ // Process the map if it is dmabuf. Add map reference to existing object in 'dmabufs'
+ // if it was already found. If it wasn't create a new one and append it to 'dmabufs'
+ auto account_dmabuf = [&](uint64_t start, uint64_t end, uint16_t /* flags */,
+ uint64_t /* pgoff */, const char* name) {
+ // no need to look into this mapping if it is not dmabuf
+ if (!FileIsDmaBuf(std::string(name))) {
+ return;
+ }
+
+ // TODO (b/123532375) : Add inode number to the callback of ReadMapFileContent.
+ //
+ // Workaround: we know 'name' points to the name at the end of 'line'.
+ // We use that to backtrack and pick up the inode number from the line as well.
+ // start end flag pgoff mj:mn inode name
+ // 00400000-00409000 r-xp 00000000 00:00 426998 /dmabuf (deleted)
+ const char* p = name;
+ p--;
+ // skip spaces
+ while (p != line && *p == ' ') {
+ p--;
+ }
+ // walk backwards to the beginning of inode number
+ while (p != line && isdigit(*p)) {
+ p--;
+ }
+ uint64_t inode = strtoull(p, nullptr, 10);
+ auto buf = std::find_if(dmabufs->begin(), dmabufs->end(),
+ [&inode](const DmaBuffer& dbuf) { return dbuf.inode() == inode; });
+ if (buf != dmabufs->end()) {
+ buf->AddMapRef(pid);
+ return;
+ }
+
+ // We have a new buffer, but unknown count and name
+ DmaBuffer& dbuf = dmabufs->emplace_back(inode, end - start, 0, "<unknown>", "<unknown>");
+ dbuf.AddMapRef(pid);
+ };
+
+ while (getline(&line, &len, fp.get()) > 0) {
+ if (!::android::procinfo::ReadMapFileContent(line, account_dmabuf)) {
+ LOG(ERROR) << "Failed t parse maps for pid: " << pid;
+ return false;
+ }
+ }
+
+ free(line);
+ return true;
+}
+
+// Public methods
+bool ReadDmaBufInfo(std::vector<DmaBuffer>* dmabufs, const std::string& path) {
+ auto fp = std::unique_ptr<FILE, decltype(&fclose)>{fopen(path.c_str(), "re"), fclose};
+ if (fp == nullptr) {
+ LOG(ERROR) << "Failed to open dmabuf info from debugfs";
+ return false;
+ }
+
+ char* line = nullptr;
+ size_t len = 0;
+ dmabufs->clear();
+ while (getline(&line, &len, fp.get()) > 0) {
+ // The new dmabuf bufinfo format adds inode number and a name at the end
+ // We are looking for lines as follows:
+ // size flags mode count exp_name ino name
+ // 01048576 00000002 00000007 00000001 ion 00018758 CAMERA
+ // 01048576 00000002 00000007 00000001 ion 00018758
+ uint64_t size, count;
+ char* exporter_name = nullptr;
+ ino_t inode;
+ char* name = nullptr;
+ int matched = sscanf(line, "%" SCNu64 "%*x %*x %" SCNu64 " %ms %lu %ms", &size, &count,
+ &exporter_name, &inode, &name);
+ if (matched < 4) {
+ continue;
+ }
+ dmabufs->emplace_back(inode, size, count, exporter_name, matched > 4 ? name : "");
+ free(exporter_name);
+ free(name);
+ }
+
+ free(line);
+
+ return true;
+}
+
+bool ReadDmaBufInfo(pid_t pid, std::vector<DmaBuffer>* dmabufs) {
+ dmabufs->clear();
+ if (!ReadDmaBufFdRefs(pid, dmabufs)) {
+ LOG(ERROR) << "Failed to read dmabuf fd references";
+ return false;
+ }
+
+ if (!ReadDmaBufMapRefs(pid, dmabufs)) {
+ LOG(ERROR) << "Failed to read dmabuf map references";
+ return false;
+ }
+ return true;
+}
+
+} // namespace dmabufinfo
+} // namespace android