libmeminfo/libdmabufinfo/dmabufinfo.cpp - LeafOS-Project/android_system_core - Gitiles

 /*
  * 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;
         }

         uint64_t inode = sb.st_ino;
         auto buf = std::find_if(dmabufs->begin(), dmabufs->end(),
                                 [&inode](const DmaBuffer& dbuf) { return dbuf.inode() == inode; });
         if (buf != dmabufs->end()) {
             if (buf->name() == "" || buf->name() == "<unknown>")
                 buf->SetName(name);
             if (buf->exporter() == "" || buf->exporter() == "<unknown>")
                 buf->SetExporter(exporter);
             if (buf->count() == 0)
                 buf->SetCount(count);
             buf->AddFdRef(pid);
             continue;
         }

         DmaBuffer& db =
                 dmabufs->emplace_back(sb.st_ino, sb.st_blocks * 512, count, exporter, name);
         db.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();
     return AppendDmaBufInfo(pid, dmabufs);
 }

 bool AppendDmaBufInfo(pid_t pid, std::vector<DmaBuffer>* dmabufs) {
     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
	/*
	* 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;
	}

	uint64_t inode = sb.st_ino;
	auto buf = std::find_if(dmabufs->begin(), dmabufs->end(),
	[&inode](const DmaBuffer& dbuf) { return dbuf.inode() == inode; });
	if (buf != dmabufs->end()) {
	if (buf->name() == "" \|\| buf->name() == "<unknown>")
	buf->SetName(name);
	if (buf->exporter() == "" \|\| buf->exporter() == "<unknown>")
	buf->SetExporter(exporter);
	if (buf->count() == 0)
	buf->SetCount(count);
	buf->AddFdRef(pid);
	continue;
	}

	DmaBuffer& db =
	dmabufs->emplace_back(sb.st_ino, sb.st_blocks * 512, count, exporter, name);
	db.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();
	return AppendDmaBufInfo(pid, dmabufs);
	}

	bool AppendDmaBufInfo(pid_t pid, std::vector<DmaBuffer>* dmabufs) {
	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