commit 5e8fa4b6f11c49df07e70314f79060109a72ad42
author Anna Zappone <azappone@google.com> Thu Mar 29 12:56:22 2018 +0100
committer Anna Zappone <azappone@google.com> Thu Mar 29 14:38:57 2018 +0000
tree c6489a1a2d229fb80e6215da09610582b593eee9
parent 9daa483d6ec09b56b9832bd7ecd1f08c7f00c26c

trace_to_text: Verify filesystem scanning numbers

Add sanity checks in trace to text by comparing inodes seen in
ftrace events to the inodes resolved in InodeFileMap trace packets.

Bug: 73625480
Bug: 74584014
Change-Id: I82e2081b46c03375e907342578626874efda1f20

tools/trace_to_text/main.cc

diff --git a/tools/trace_to_text/main.cc b/tools/trace_to_text/main.cc
index 7f352b8..2f0c96b 100644
--- a/tools/trace_to_text/main.cc
+++ b/tools/trace_to_text/main.cc
@@ -255,15 +255,47 @@
 }
 
 void PrintInodeStats(std::ostream* output,
-                     const std::set<uint64_t>& inode_numbers,
-                     const uint64_t& events_with_inodes) {
+                     const std::set<uint64_t>& ftrace_inodes,
+                     const uint64_t& ftrace_inode_count,
+                     const std::set<uint64_t>& resolved_map_inodes,
+                     const std::set<uint64_t>& resolved_scan_inodes) {
   *output << "--------------------Inode Stats-------------------\n";
   char line[2048];
-  sprintf(line, "Unique inodes: %zu\n", inode_numbers.size());
+
+  sprintf(line, "Events with inodes: %" PRIu64 "\n", ftrace_inode_count);
   *output << std::string(line);
 
-  sprintf(line, "Events with inodes: %" PRIu64 "\n", events_with_inodes);
+  sprintf(line, "Unique inodes from events: %zu\n", ftrace_inodes.size());
   *output << std::string(line);
+
+  sprintf(line, "Resolved inodes from static map: %zu\n",
+          resolved_map_inodes.size());
+  *output << std::string(line);
+
+  sprintf(line, "Resolved inodes from scan and cache: %zu\n",
+          resolved_scan_inodes.size());
+  *output << std::string(line);
+
+  std::set<uint64_t> resolved_inodes;
+  set_union(resolved_map_inodes.begin(), resolved_map_inodes.end(),
+            resolved_scan_inodes.begin(), resolved_scan_inodes.end(),
+            std::inserter(resolved_inodes, resolved_inodes.begin()));
+
+  sprintf(line, "Total resolved inodes: %zu\n", resolved_inodes.size());
+  *output << std::string(line);
+
+  std::set<uint64_t> intersect;
+  set_intersection(resolved_inodes.begin(), resolved_inodes.end(),
+                   ftrace_inodes.begin(), ftrace_inodes.end(),
+                   std::inserter(intersect, intersect.begin()));
+
+  sprintf(line, "Unresolved inodes: %" PRIu64 "\n",
+          ftrace_inodes.size() - intersect.size());
+
+  sprintf(line, "Unexpected inodes from filesystem: %" PRIu64 "\n",
+          resolved_inodes.size() - intersect.size());
+  *output << std::string(line);
+
   *output << "\n";
 }
 
@@ -300,13 +332,15 @@
   std::multiset<uint64_t> ftrace_timestamps;
   std::set<pid_t> tids_in_tree;
   std::set<pid_t> tids_in_events;
-  std::set<uint64_t> inode_numbers;
-  uint64_t events_with_inodes = 0;
+  std::set<uint64_t> ftrace_inodes;
+  uint64_t ftrace_inode_count = 0;
+  std::set<uint64_t> resolved_map_inodes;
+  std::set<uint64_t> resolved_scan_inodes;
 
   ForEachPacketInTrace(
-      input,
-      [&start, &end, &ftrace_timestamps, &tids_in_tree, &tids_in_events,
-       &inode_numbers, &events_with_inodes](const protos::TracePacket& packet) {
+      input, [&start, &end, &ftrace_timestamps, &tids_in_tree, &tids_in_events,
+              &ftrace_inodes, &ftrace_inode_count, &resolved_map_inodes,
+              &resolved_scan_inodes](const protos::TracePacket& packet) {
 
         if (packet.has_process_tree()) {
           const ProcessTree& tree = packet.process_tree();
@@ -317,6 +351,18 @@
           }
         }
 
+        if (packet.has_inode_file_map()) {
+          const InodeFileMap& inode_file_map = packet.inode_file_map();
+          const auto& mount_points = inode_file_map.mount_points();
+          bool from_scan = std::find(mount_points.begin(), mount_points.end(),
+                                     "/data") != mount_points.end();
+          for (const auto& entry : inode_file_map.entries())
+            if (from_scan)
+              resolved_scan_inodes.insert(entry.inode_number());
+            else
+              resolved_map_inodes.insert(entry.inode_number());
+        }
+
         if (!packet.has_ftrace_events())
           return;
 
@@ -324,8 +370,8 @@
         uint64_t inode_number = 0;
         for (const FtraceEvent& event : bundle.event()) {
           if (ParseInode(event, &inode_number)) {
-            inode_numbers.insert(inode_number);
-            events_with_inodes++;
+            ftrace_inodes.insert(inode_number);
+            ftrace_inode_count++;
           }
           if (event.pid()) {
             tids_in_events.insert(event.pid());
@@ -346,7 +392,8 @@
 
   PrintFtraceTrack(output, start, end, ftrace_timestamps);
   PrintProcessStats(output, tids_in_tree, tids_in_events);
-  PrintInodeStats(output, inode_numbers, events_with_inodes);
+  PrintInodeStats(output, ftrace_inodes, ftrace_inode_count,
+                  resolved_map_inodes, resolved_scan_inodes);
 
   return 0;
 }