| OLD | NEW |
| (Empty) |
| 1 // Copyright 2015 The Chromium Authors. All rights reserved. | |
| 2 // Use of this source code is governed by a BSD-style license that can be | |
| 3 // found in the LICENSE file. | |
| 4 | |
| 5 #include "components/tracing/graphics_memory_dump_provider_android.h" | |
| 6 | |
| 7 #include <fcntl.h> | |
| 8 #include <stdint.h> | |
| 9 #include <string.h> | |
| 10 #include <sys/socket.h> | |
| 11 #include <sys/time.h> | |
| 12 #include <sys/types.h> | |
| 13 #include <sys/un.h> | |
| 14 | |
| 15 #include "base/files/scoped_file.h" | |
| 16 #include "base/macros.h" | |
| 17 #include "base/posix/eintr_wrapper.h" | |
| 18 #include "base/strings/string_number_conversions.h" | |
| 19 #include "base/strings/string_piece.h" | |
| 20 #include "base/strings/string_tokenizer.h" | |
| 21 #include "base/trace_event/process_memory_dump.h" | |
| 22 #include "base/trace_event/process_memory_totals.h" | |
| 23 | |
| 24 using base::trace_event::MemoryAllocatorDump; | |
| 25 | |
| 26 namespace tracing { | |
| 27 | |
| 28 // static | |
| 29 const char GraphicsMemoryDumpProvider::kDumpBaseName[] = | |
| 30 "gpu/android_memtrack/"; | |
| 31 | |
| 32 // static | |
| 33 GraphicsMemoryDumpProvider* GraphicsMemoryDumpProvider::GetInstance() { | |
| 34 return base::Singleton< | |
| 35 GraphicsMemoryDumpProvider, | |
| 36 base::LeakySingletonTraits<GraphicsMemoryDumpProvider>>::get(); | |
| 37 } | |
| 38 | |
| 39 bool GraphicsMemoryDumpProvider::OnMemoryDump( | |
| 40 const base::trace_event::MemoryDumpArgs& args, | |
| 41 base::trace_event::ProcessMemoryDump* pmd) { | |
| 42 if (args.level_of_detail != | |
| 43 base::trace_event::MemoryDumpLevelOfDetail::DETAILED) | |
| 44 return true; // Dump on detailed memory dumps only. | |
| 45 | |
| 46 const char kAbstractSocketName[] = "chrome_tracing_memtrack_helper"; | |
| 47 struct sockaddr_un addr; | |
| 48 | |
| 49 const int sock = socket(AF_UNIX, SOCK_SEQPACKET, 0); | |
| 50 if (sock == -1) | |
| 51 return false; | |
| 52 // Ensures that sock is always closed, even in case of early returns. | |
| 53 base::ScopedFD sock_closer(sock); | |
| 54 | |
| 55 // Set recv() timeout to 250 ms. | |
| 56 struct timeval tv; | |
| 57 tv.tv_sec = 0; | |
| 58 tv.tv_usec = 250000; | |
| 59 setsockopt(sock, SOL_SOCKET, SO_RCVTIMEO, &tv, sizeof(tv)); | |
| 60 | |
| 61 // Connect to the UNIX abstract (i.e. no physical filesystem link) socket. | |
| 62 memset(&addr, 0, sizeof(addr)); | |
| 63 addr.sun_family = AF_UNIX; | |
| 64 strncpy(&addr.sun_path[1], kAbstractSocketName, sizeof(addr.sun_path) - 2); | |
| 65 | |
| 66 if (connect(sock, reinterpret_cast<struct sockaddr*>(&addr), sizeof(addr))) { | |
| 67 LOG(WARNING) << "Could not connect to the memtrack_helper daemon. Please " | |
| 68 "build memtrack_helper, adb push to the device and run it " | |
| 69 "before starting the trace to get graphics memory data."; | |
| 70 return false; | |
| 71 } | |
| 72 | |
| 73 // Check that the socket is owned by root (the memtrack_helper) process and | |
| 74 // not an (untrusted) user process. | |
| 75 struct ucred cred; | |
| 76 socklen_t cred_len = sizeof(cred); | |
| 77 if (getsockopt(sock, SOL_SOCKET, SO_PEERCRED, &cred, &cred_len) < 0 || | |
| 78 (static_cast<unsigned>(cred_len) < sizeof(cred)) || | |
| 79 cred.uid != 0 /* root */) { | |
| 80 LOG(WARNING) << "Untrusted (!= root) memtrack_helper daemon detected."; | |
| 81 return false; | |
| 82 } | |
| 83 | |
| 84 // Send the trace(PID) request. | |
| 85 char buf[4096]; | |
| 86 const int buf_pid_len = snprintf(buf, sizeof(buf) - 1, "%d", getpid()); | |
| 87 if (HANDLE_EINTR(send(sock, buf, buf_pid_len + 1, 0)) <= 0) | |
| 88 return false; | |
| 89 | |
| 90 // The response consists of a few lines, each one with a key value pair. E.g.: | |
| 91 // graphics_total 10616832 | |
| 92 // graphics_pss 10616832 | |
| 93 // gl_total 17911808 | |
| 94 // gl_pss 17911808 | |
| 95 ssize_t rsize; | |
| 96 if ((rsize = HANDLE_EINTR(recv(sock, buf, sizeof(buf), 0))) <= 0) | |
| 97 return false; | |
| 98 | |
| 99 buf[sizeof(buf) - 1] = '\0'; | |
| 100 ParseResponseAndAddToDump(buf, static_cast<size_t>(rsize), pmd); | |
| 101 return true; | |
| 102 } | |
| 103 | |
| 104 void GraphicsMemoryDumpProvider::ParseResponseAndAddToDump( | |
| 105 const char* response, | |
| 106 size_t length, | |
| 107 base::trace_event::ProcessMemoryDump* pmd) { | |
| 108 base::CStringTokenizer tokenizer(response, response + length, " \n"); | |
| 109 while (true) { | |
| 110 if (!tokenizer.GetNext()) | |
| 111 break; | |
| 112 base::StringPiece row_name = tokenizer.token_piece(); | |
| 113 if (!tokenizer.GetNext()) | |
| 114 break; | |
| 115 base::StringPiece value_str = tokenizer.token_piece(); | |
| 116 int64_t value; | |
| 117 if (!base::StringToInt64(value_str, &value) || value < 0) | |
| 118 continue; // Skip invalid or negative values. | |
| 119 | |
| 120 // Turn entries like graphics_total into a row named "graphics" and | |
| 121 // column named "total". | |
| 122 std::string column_name = "memtrack_"; | |
| 123 size_t key_split_point = row_name.find_last_of('_'); | |
| 124 if (key_split_point > 0 && key_split_point < row_name.size() - 1) { | |
| 125 row_name.substr(key_split_point + 1).AppendToString(&column_name); | |
| 126 row_name = row_name.substr(0, key_split_point); | |
| 127 } else { | |
| 128 column_name += "unknown"; | |
| 129 } | |
| 130 | |
| 131 // Append a row to the memory dump. | |
| 132 std::string dump_name; | |
| 133 dump_name.reserve(arraysize(kDumpBaseName) + row_name.size() + 1); | |
| 134 dump_name.assign(kDumpBaseName); | |
| 135 row_name.AppendToString(&dump_name); | |
| 136 MemoryAllocatorDump* mad = pmd->GetOrCreateAllocatorDump(dump_name); | |
| 137 const auto& long_lived_column_name = key_names_.insert(column_name).first; | |
| 138 mad->AddScalar(long_lived_column_name->c_str(), | |
| 139 MemoryAllocatorDump::kUnitsBytes, value); | |
| 140 } | |
| 141 } | |
| 142 | |
| 143 GraphicsMemoryDumpProvider::GraphicsMemoryDumpProvider() {} | |
| 144 | |
| 145 GraphicsMemoryDumpProvider::~GraphicsMemoryDumpProvider() {} | |
| 146 | |
| 147 } // namespace tracing | |
| OLD | NEW |