diff --git a/src/traced/probes/filesystem/inode_file_data_source.cc b/src/traced/probes/filesystem/inode_file_data_source.cc
index 3186b3f..fd308ac 100644
--- a/src/traced/probes/filesystem/inode_file_data_source.cc
+++ b/src/traced/probes/filesystem/inode_file_data_source.cc
@@ -223,7 +223,8 @@
     BlockDeviceID block_device_id = inodes_pair.second;
     inode_file_maps[block_device_id].emplace(inode_number);
   }
-  PERFETTO_DLOG("Saw %zu block devices.", inode_file_maps.size());
+  if (inode_file_maps.size() > 1)
+    PERFETTO_DLOG("Saw %zu block devices.", inode_file_maps.size());
 
   // Write a TracePacket with an InodeFileMap proto for each block device id
   for (const auto& inode_file_map_data : inode_file_maps) {
diff --git a/src/traced/probes/probes_producer.cc b/src/traced/probes/probes_producer.cc
index 5d29fd9..b460971 100644
--- a/src/traced/probes/probes_producer.cc
+++ b/src/traced/probes/probes_producer.cc
@@ -188,7 +188,7 @@
   auto trace_writer = endpoint_->CreateTraceWriter(
       static_cast<BufferID>(source_config.target_buffer()));
   if (system_inodes_.empty())
-    CreateStaticDeviceToInodeMap("/system/", &system_inodes_);
+    CreateStaticDeviceToInodeMap("/system", &system_inodes_);
   auto file_map_source =
       std::unique_ptr<InodeFileDataSource>(new InodeFileDataSource(
           session_id, &system_inodes_, &cache_, std::move(trace_writer)));
diff --git a/src/tracing/core/shared_memory_arbiter_impl.cc b/src/tracing/core/shared_memory_arbiter_impl.cc
index c500936..b6c6fd9 100644
--- a/src/tracing/core/shared_memory_arbiter_impl.cc
+++ b/src/tracing/core/shared_memory_arbiter_impl.cc
@@ -215,7 +215,6 @@
   PERFETTO_DCHECK_THREAD(thread_checker_);
 
   std::unique_ptr<CommitDataRequest> req;
-  std::vector<uint32_t> pages_to_notify;
   {
     std::lock_guard<std::mutex> scoped_lock(lock_);
     req = std::move(commit_data_req_);
diff --git a/tools/ftrace_proto_gen/ftrace_proto_gen.cc b/tools/ftrace_proto_gen/ftrace_proto_gen.cc
index 4a1df78..3c25934 100644
--- a/tools/ftrace_proto_gen/ftrace_proto_gen.cc
+++ b/tools/ftrace_proto_gen/ftrace_proto_gen.cc
@@ -103,10 +103,10 @@
   }
 }
 
-void PrintTraceToTextMain(const std::set<std::string>& events) {
+void PrintEventFormatterMain(const std::set<std::string>& events) {
   printf(
-      "\nAdd output to TraceToSystrace for loop in "
-      "tools/ftrace_proto_gen/main.cc\n");
+      "\nAdd output to FormatEventText in "
+      "tools/ftrace_proto_gen/ftrace_event_formatter.cc\n");
   for (auto event : events) {
     printf(
         "else if (event.has_%s()) {\nconst auto& inner = event.%s();\nline = "
@@ -115,17 +115,30 @@
   }
 }
 
-void PrintTraceToTextUsingStatements(const std::set<std::string>& events) {
-  printf("\nAdd output to tools/ftrace_proto_gen/main.cc\n");
+// Add output to ParseInode in ftrace_inode_handler
+void PrintInodeHandlerMain(const std::string& event_name,
+                           const perfetto::Proto& proto) {
+  for (const auto& field : proto.fields) {
+    if (Contains(field.name, "ino") && !Contains(field.name, "minor"))
+      printf(
+          "else if (event.has_%s() && event.%s().%s()) {\n*inode = "
+          "static_cast<uint64_t>(event.%s().%s());\n return true;\n} ",
+          event_name.c_str(), event_name.c_str(), field.name.c_str(),
+          event_name.c_str(), field.name.c_str());
+  }
+}
+
+void PrintEventFormatterUsingStatements(const std::set<std::string>& events) {
+  printf("\nAdd output to tools/ftrace_proto_gen/ftrace_event_formatter.cc\n");
   for (auto event : events) {
     printf("using protos::%sFtraceEvent;\n", ToCamelCase(event).c_str());
   }
 }
 
-void PrintTraceToTextFunctions(const std::set<std::string>& events) {
+void PrintEventFormatterFunctions(const std::set<std::string>& events) {
   printf(
-      "\nAdd output to tools/ftrace_proto_gen/main.cc and then manually go "
-      "through format files to match fields\n");
+      "\nAdd output to tools/ftrace_proto_gen/ftrace_event_formatter.cc and "
+      "then manually go through format files to match fields\n");
   for (auto event : events) {
     printf(
         "std::string Format%s(const %sFtraceEvent& event) {"
diff --git a/tools/ftrace_proto_gen/ftrace_proto_gen.h b/tools/ftrace_proto_gen/ftrace_proto_gen.h
index a5be4f4..11cf5cf 100644
--- a/tools/ftrace_proto_gen/ftrace_proto_gen.h
+++ b/tools/ftrace_proto_gen/ftrace_proto_gen.h
@@ -38,9 +38,11 @@
 };
 
 void PrintFtraceEventProtoAdditions(const std::set<std::string>& events);
-void PrintTraceToTextMain(const std::set<std::string>& events);
-void PrintTraceToTextUsingStatements(const std::set<std::string>& events);
-void PrintTraceToTextFunctions(const std::set<std::string>& events);
+void PrintEventFormatterMain(const std::set<std::string>& events);
+void PrintEventFormatterUsingStatements(const std::set<std::string>& events);
+void PrintEventFormatterFunctions(const std::set<std::string>& events);
+void PrintInodeHandlerMain(const std::string& event_name,
+                           const perfetto::Proto& proto);
 
 bool GenerateProto(const FtraceEvent& format, Proto* proto_out);
 std::string InferProtoType(const FtraceEvent::Field& field);
diff --git a/tools/ftrace_proto_gen/main.cc b/tools/ftrace_proto_gen/main.cc
index 33d8abb..c701d39 100644
--- a/tools/ftrace_proto_gen/main.cc
+++ b/tools/ftrace_proto_gen/main.cc
@@ -62,9 +62,12 @@
 
   if (!new_events.empty()) {
     perfetto::PrintFtraceEventProtoAdditions(new_events);
-    perfetto::PrintTraceToTextMain(new_events);
-    perfetto::PrintTraceToTextUsingStatements(new_events);
-    perfetto::PrintTraceToTextFunctions(new_events);
+    perfetto::PrintEventFormatterMain(new_events);
+    perfetto::PrintEventFormatterUsingStatements(new_events);
+    perfetto::PrintEventFormatterFunctions(new_events);
+    printf(
+        "\nAdd output to ParseInode in "
+        "tools/ftrace_proto_gen/ftrace_inode_handler.cc\n");
   }
 
   for (auto event : events) {
@@ -105,6 +108,9 @@
       return 1;
     }
 
+    if (!new_events.empty())
+      PrintInodeHandlerMain(format.name, proto);
+
     events_info.push_back(
         perfetto::SingleEventInfo(format, proto, group, proto_field_id));
 
diff --git a/tools/trace_to_text/BUILD.gn b/tools/trace_to_text/BUILD.gn
index 90e1233c..5f1f9e0 100644
--- a/tools/trace_to_text/BUILD.gn
+++ b/tools/trace_to_text/BUILD.gn
@@ -23,6 +23,8 @@
     sources = [
       "ftrace_event_formatter.cc",
       "ftrace_event_formatter.h",
+      "ftrace_inode_handler.cc",
+      "ftrace_inode_handler.h",
       "main.cc",
     ]
   }
diff --git a/tools/trace_to_text/ftrace_event_formatter.cc b/tools/trace_to_text/ftrace_event_formatter.cc
index 1120d7a..1af2a1d 100644
--- a/tools/trace_to_text/ftrace_event_formatter.cc
+++ b/tools/trace_to_text/ftrace_event_formatter.cc
@@ -17,6 +17,8 @@
 #include "tools/trace_to_text/ftrace_event_formatter.h"
 
 #include <inttypes.h>
+#include <algorithm>
+#include <string>
 
 namespace perfetto {
 namespace {
diff --git a/tools/trace_to_text/ftrace_inode_handler.cc b/tools/trace_to_text/ftrace_inode_handler.cc
new file mode 100644
index 0000000..ad0d9b2
--- /dev/null
+++ b/tools/trace_to_text/ftrace_inode_handler.cc
@@ -0,0 +1,333 @@
+/*
+ * 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 "tools/trace_to_text/ftrace_inode_handler.h"
+
+namespace perfetto {
+
+bool ParseInode(const protos::FtraceEvent& event, uint64_t* inode) {
+  if (event.has_ext4_alloc_da_blocks() && event.ext4_alloc_da_blocks().ino()) {
+    *inode = static_cast<uint64_t>(event.ext4_alloc_da_blocks().ino());
+    return true;
+  } else if (event.has_ext4_allocate_blocks() &&
+             event.ext4_allocate_blocks().ino()) {
+    *inode = static_cast<uint64_t>(event.ext4_allocate_blocks().ino());
+    return true;
+  } else if (event.has_ext4_allocate_inode() &&
+             event.ext4_allocate_inode().ino()) {
+    *inode = static_cast<uint64_t>(event.ext4_allocate_inode().ino());
+    return true;
+  } else if (event.has_ext4_begin_ordered_truncate() &&
+             event.ext4_begin_ordered_truncate().ino()) {
+    *inode = static_cast<uint64_t>(event.ext4_begin_ordered_truncate().ino());
+    return true;
+  } else if (event.has_ext4_collapse_range() &&
+             event.ext4_collapse_range().ino()) {
+    *inode = static_cast<uint64_t>(event.ext4_collapse_range().ino());
+    return true;
+  } else if (event.has_ext4_da_release_space() &&
+             event.ext4_da_release_space().ino()) {
+    *inode = static_cast<uint64_t>(event.ext4_da_release_space().ino());
+    return true;
+  } else if (event.has_ext4_da_reserve_space() &&
+             event.ext4_da_reserve_space().ino()) {
+    *inode = static_cast<uint64_t>(event.ext4_da_reserve_space().ino());
+    return true;
+  } else if (event.has_ext4_da_update_reserve_space() &&
+             event.ext4_da_update_reserve_space().ino()) {
+    *inode = static_cast<uint64_t>(event.ext4_da_update_reserve_space().ino());
+    return true;
+  } else if (event.has_ext4_da_write_begin() &&
+             event.ext4_da_write_begin().ino()) {
+    *inode = static_cast<uint64_t>(event.ext4_da_write_begin().ino());
+    return true;
+  } else if (event.has_ext4_da_write_end() && event.ext4_da_write_end().ino()) {
+    *inode = static_cast<uint64_t>(event.ext4_da_write_end().ino());
+    return true;
+  } else if (event.has_ext4_da_write_pages() &&
+             event.ext4_da_write_pages().ino()) {
+    *inode = static_cast<uint64_t>(event.ext4_da_write_pages().ino());
+    return true;
+  } else if (event.has_ext4_da_write_pages_extent() &&
+             event.ext4_da_write_pages_extent().ino()) {
+    *inode = static_cast<uint64_t>(event.ext4_da_write_pages_extent().ino());
+    return true;
+  } else if (event.has_ext4_direct_io_enter() &&
+             event.ext4_direct_io_enter().ino()) {
+    *inode = static_cast<uint64_t>(event.ext4_direct_io_enter().ino());
+    return true;
+  } else if (event.has_ext4_direct_io_exit() &&
+             event.ext4_direct_io_exit().ino()) {
+    *inode = static_cast<uint64_t>(event.ext4_direct_io_exit().ino());
+    return true;
+  } else if (event.has_ext4_discard_preallocations() &&
+             event.ext4_discard_preallocations().ino()) {
+    *inode = static_cast<uint64_t>(event.ext4_discard_preallocations().ino());
+    return true;
+  } else if (event.has_ext4_drop_inode() && event.ext4_drop_inode().ino()) {
+    *inode = static_cast<uint64_t>(event.ext4_drop_inode().ino());
+    return true;
+  } else if (event.has_ext4_es_cache_extent() &&
+             event.ext4_es_cache_extent().ino()) {
+    *inode = static_cast<uint64_t>(event.ext4_es_cache_extent().ino());
+    return true;
+  } else if (event.has_ext4_es_find_delayed_extent_range_enter() &&
+             event.ext4_es_find_delayed_extent_range_enter().ino()) {
+    *inode = static_cast<uint64_t>(
+        event.ext4_es_find_delayed_extent_range_enter().ino());
+    return true;
+  } else if (event.has_ext4_es_find_delayed_extent_range_exit() &&
+             event.ext4_es_find_delayed_extent_range_exit().ino()) {
+    *inode = static_cast<uint64_t>(
+        event.ext4_es_find_delayed_extent_range_exit().ino());
+    return true;
+  } else if (event.has_ext4_es_insert_extent() &&
+             event.ext4_es_insert_extent().ino()) {
+    *inode = static_cast<uint64_t>(event.ext4_es_insert_extent().ino());
+    return true;
+  } else if (event.has_ext4_es_lookup_extent_enter() &&
+             event.ext4_es_lookup_extent_enter().ino()) {
+    *inode = static_cast<uint64_t>(event.ext4_es_lookup_extent_enter().ino());
+    return true;
+  } else if (event.has_ext4_es_lookup_extent_exit() &&
+             event.ext4_es_lookup_extent_exit().ino()) {
+    *inode = static_cast<uint64_t>(event.ext4_es_lookup_extent_exit().ino());
+    return true;
+  } else if (event.has_ext4_es_remove_extent() &&
+             event.ext4_es_remove_extent().ino()) {
+    *inode = static_cast<uint64_t>(event.ext4_es_remove_extent().ino());
+    return true;
+  } else if (event.has_ext4_evict_inode() && event.ext4_evict_inode().ino()) {
+    *inode = static_cast<uint64_t>(event.ext4_evict_inode().ino());
+    return true;
+  } else if (event.has_ext4_ext_convert_to_initialized_enter() &&
+             event.ext4_ext_convert_to_initialized_enter().ino()) {
+    *inode = static_cast<uint64_t>(
+        event.ext4_ext_convert_to_initialized_enter().ino());
+    return true;
+  } else if (event.has_ext4_ext_convert_to_initialized_fastpath() &&
+             event.ext4_ext_convert_to_initialized_fastpath().ino()) {
+    *inode = static_cast<uint64_t>(
+        event.ext4_ext_convert_to_initialized_fastpath().ino());
+    return true;
+  } else if (event.has_ext4_ext_handle_unwritten_extents() &&
+             event.ext4_ext_handle_unwritten_extents().ino()) {
+    *inode =
+        static_cast<uint64_t>(event.ext4_ext_handle_unwritten_extents().ino());
+    return true;
+  } else if (event.has_ext4_ext_in_cache() && event.ext4_ext_in_cache().ino()) {
+    *inode = static_cast<uint64_t>(event.ext4_ext_in_cache().ino());
+    return true;
+  } else if (event.has_ext4_ext_load_extent() &&
+             event.ext4_ext_load_extent().ino()) {
+    *inode = static_cast<uint64_t>(event.ext4_ext_load_extent().ino());
+    return true;
+  } else if (event.has_ext4_ext_map_blocks_enter() &&
+             event.ext4_ext_map_blocks_enter().ino()) {
+    *inode = static_cast<uint64_t>(event.ext4_ext_map_blocks_enter().ino());
+    return true;
+  } else if (event.has_ext4_ext_map_blocks_exit() &&
+             event.ext4_ext_map_blocks_exit().ino()) {
+    *inode = static_cast<uint64_t>(event.ext4_ext_map_blocks_exit().ino());
+    return true;
+  } else if (event.has_ext4_ext_put_in_cache() &&
+             event.ext4_ext_put_in_cache().ino()) {
+    *inode = static_cast<uint64_t>(event.ext4_ext_put_in_cache().ino());
+    return true;
+  } else if (event.has_ext4_ext_remove_space() &&
+             event.ext4_ext_remove_space().ino()) {
+    *inode = static_cast<uint64_t>(event.ext4_ext_remove_space().ino());
+    return true;
+  } else if (event.has_ext4_ext_remove_space_done() &&
+             event.ext4_ext_remove_space_done().ino()) {
+    *inode = static_cast<uint64_t>(event.ext4_ext_remove_space_done().ino());
+    return true;
+  } else if (event.has_ext4_ext_rm_idx() && event.ext4_ext_rm_idx().ino()) {
+    *inode = static_cast<uint64_t>(event.ext4_ext_rm_idx().ino());
+    return true;
+  } else if (event.has_ext4_ext_rm_leaf() && event.ext4_ext_rm_leaf().ino()) {
+    *inode = static_cast<uint64_t>(event.ext4_ext_rm_leaf().ino());
+    return true;
+  } else if (event.has_ext4_ext_show_extent() &&
+             event.ext4_ext_show_extent().ino()) {
+    *inode = static_cast<uint64_t>(event.ext4_ext_show_extent().ino());
+    return true;
+  } else if (event.has_ext4_fallocate_enter() &&
+             event.ext4_fallocate_enter().ino()) {
+    *inode = static_cast<uint64_t>(event.ext4_fallocate_enter().ino());
+    return true;
+  } else if (event.has_ext4_fallocate_exit() &&
+             event.ext4_fallocate_exit().ino()) {
+    *inode = static_cast<uint64_t>(event.ext4_fallocate_exit().ino());
+    return true;
+  } else if (event.has_ext4_find_delalloc_range() &&
+             event.ext4_find_delalloc_range().ino()) {
+    *inode = static_cast<uint64_t>(event.ext4_find_delalloc_range().ino());
+    return true;
+  } else if (event.has_ext4_forget() && event.ext4_forget().ino()) {
+    *inode = static_cast<uint64_t>(event.ext4_forget().ino());
+    return true;
+  } else if (event.has_ext4_free_blocks() && event.ext4_free_blocks().ino()) {
+    *inode = static_cast<uint64_t>(event.ext4_free_blocks().ino());
+    return true;
+  } else if (event.has_ext4_free_inode() && event.ext4_free_inode().ino()) {
+    *inode = static_cast<uint64_t>(event.ext4_free_inode().ino());
+    return true;
+  } else if (event.has_ext4_get_reserved_cluster_alloc() &&
+             event.ext4_get_reserved_cluster_alloc().ino()) {
+    *inode =
+        static_cast<uint64_t>(event.ext4_get_reserved_cluster_alloc().ino());
+    return true;
+  } else if (event.has_ext4_ind_map_blocks_enter() &&
+             event.ext4_ind_map_blocks_enter().ino()) {
+    *inode = static_cast<uint64_t>(event.ext4_ind_map_blocks_enter().ino());
+    return true;
+  } else if (event.has_ext4_ind_map_blocks_exit() &&
+             event.ext4_ind_map_blocks_exit().ino()) {
+    *inode = static_cast<uint64_t>(event.ext4_ind_map_blocks_exit().ino());
+    return true;
+  } else if (event.has_ext4_insert_range() && event.ext4_insert_range().ino()) {
+    *inode = static_cast<uint64_t>(event.ext4_insert_range().ino());
+    return true;
+  } else if (event.has_ext4_invalidatepage() &&
+             event.ext4_invalidatepage().ino()) {
+    *inode = static_cast<uint64_t>(event.ext4_invalidatepage().ino());
+    return true;
+  } else if (event.has_ext4_journalled_invalidatepage() &&
+             event.ext4_journalled_invalidatepage().ino()) {
+    *inode =
+        static_cast<uint64_t>(event.ext4_journalled_invalidatepage().ino());
+    return true;
+  } else if (event.has_ext4_journalled_write_end() &&
+             event.ext4_journalled_write_end().ino()) {
+    *inode = static_cast<uint64_t>(event.ext4_journalled_write_end().ino());
+    return true;
+  } else if (event.has_ext4_load_inode() && event.ext4_load_inode().ino()) {
+    *inode = static_cast<uint64_t>(event.ext4_load_inode().ino());
+    return true;
+  } else if (event.has_ext4_mark_inode_dirty() &&
+             event.ext4_mark_inode_dirty().ino()) {
+    *inode = static_cast<uint64_t>(event.ext4_mark_inode_dirty().ino());
+    return true;
+  } else if (event.has_ext4_mb_new_group_pa() &&
+             event.ext4_mb_new_group_pa().ino()) {
+    *inode = static_cast<uint64_t>(event.ext4_mb_new_group_pa().ino());
+    return true;
+  } else if (event.has_ext4_mb_new_inode_pa() &&
+             event.ext4_mb_new_inode_pa().ino()) {
+    *inode = static_cast<uint64_t>(event.ext4_mb_new_inode_pa().ino());
+    return true;
+  } else if (event.has_ext4_mb_release_inode_pa() &&
+             event.ext4_mb_release_inode_pa().ino()) {
+    *inode = static_cast<uint64_t>(event.ext4_mb_release_inode_pa().ino());
+    return true;
+  } else if (event.has_ext4_mballoc_alloc() &&
+             event.ext4_mballoc_alloc().ino()) {
+    *inode = static_cast<uint64_t>(event.ext4_mballoc_alloc().ino());
+    return true;
+  } else if (event.has_ext4_mballoc_discard() &&
+             event.ext4_mballoc_discard().ino()) {
+    *inode = static_cast<uint64_t>(event.ext4_mballoc_discard().ino());
+    return true;
+  } else if (event.has_ext4_mballoc_free() && event.ext4_mballoc_free().ino()) {
+    *inode = static_cast<uint64_t>(event.ext4_mballoc_free().ino());
+    return true;
+  } else if (event.has_ext4_mballoc_prealloc() &&
+             event.ext4_mballoc_prealloc().ino()) {
+    *inode = static_cast<uint64_t>(event.ext4_mballoc_prealloc().ino());
+    return true;
+  } else if (event.has_ext4_other_inode_update_time() &&
+             event.ext4_other_inode_update_time().ino()) {
+    *inode = static_cast<uint64_t>(event.ext4_other_inode_update_time().ino());
+    return true;
+  } else if (event.has_ext4_other_inode_update_time() &&
+             event.ext4_other_inode_update_time().orig_ino()) {
+    *inode =
+        static_cast<uint64_t>(event.ext4_other_inode_update_time().orig_ino());
+    return true;
+  } else if (event.has_ext4_punch_hole() && event.ext4_punch_hole().ino()) {
+    *inode = static_cast<uint64_t>(event.ext4_punch_hole().ino());
+    return true;
+  } else if (event.has_ext4_readpage() && event.ext4_readpage().ino()) {
+    *inode = static_cast<uint64_t>(event.ext4_readpage().ino());
+    return true;
+  } else if (event.has_ext4_releasepage() && event.ext4_releasepage().ino()) {
+    *inode = static_cast<uint64_t>(event.ext4_releasepage().ino());
+    return true;
+  } else if (event.has_ext4_remove_blocks() &&
+             event.ext4_remove_blocks().ino()) {
+    *inode = static_cast<uint64_t>(event.ext4_remove_blocks().ino());
+    return true;
+  } else if (event.has_ext4_request_blocks() &&
+             event.ext4_request_blocks().ino()) {
+    *inode = static_cast<uint64_t>(event.ext4_request_blocks().ino());
+    return true;
+  } else if (event.has_ext4_sync_file_enter() &&
+             event.ext4_sync_file_enter().ino()) {
+    *inode = static_cast<uint64_t>(event.ext4_sync_file_enter().ino());
+    return true;
+  } else if (event.has_ext4_sync_file_exit() &&
+             event.ext4_sync_file_exit().ino()) {
+    *inode = static_cast<uint64_t>(event.ext4_sync_file_exit().ino());
+    return true;
+  } else if (event.has_ext4_truncate_enter() &&
+             event.ext4_truncate_enter().ino()) {
+    *inode = static_cast<uint64_t>(event.ext4_truncate_enter().ino());
+    return true;
+  } else if (event.has_ext4_truncate_exit() &&
+             event.ext4_truncate_exit().ino()) {
+    *inode = static_cast<uint64_t>(event.ext4_truncate_exit().ino());
+    return true;
+  } else if (event.has_ext4_unlink_enter() && event.ext4_unlink_enter().ino()) {
+    *inode = static_cast<uint64_t>(event.ext4_unlink_enter().ino());
+    return true;
+  } else if (event.has_ext4_unlink_exit() && event.ext4_unlink_exit().ino()) {
+    *inode = static_cast<uint64_t>(event.ext4_unlink_exit().ino());
+    return true;
+  } else if (event.has_ext4_write_begin() && event.ext4_write_begin().ino()) {
+    *inode = static_cast<uint64_t>(event.ext4_write_begin().ino());
+    return true;
+  } else if (event.has_ext4_write_end() && event.ext4_write_end().ino()) {
+    *inode = static_cast<uint64_t>(event.ext4_write_end().ino());
+    return true;
+  } else if (event.has_ext4_writepage() && event.ext4_writepage().ino()) {
+    *inode = static_cast<uint64_t>(event.ext4_writepage().ino());
+    return true;
+  } else if (event.has_ext4_writepages() && event.ext4_writepages().ino()) {
+    *inode = static_cast<uint64_t>(event.ext4_writepages().ino());
+    return true;
+  } else if (event.has_ext4_writepages_result() &&
+             event.ext4_writepages_result().ino()) {
+    *inode = static_cast<uint64_t>(event.ext4_writepages_result().ino());
+    return true;
+  } else if (event.has_ext4_zero_range() && event.ext4_zero_range().ino()) {
+    *inode = static_cast<uint64_t>(event.ext4_zero_range().ino());
+    return true;
+  } else if (event.has_mm_filemap_add_to_page_cache() &&
+             event.mm_filemap_add_to_page_cache().i_ino()) {
+    *inode =
+        static_cast<uint64_t>(event.mm_filemap_add_to_page_cache().i_ino());
+    return true;
+  } else if (event.has_mm_filemap_delete_from_page_cache() &&
+             event.mm_filemap_delete_from_page_cache().i_ino()) {
+    *inode = static_cast<uint64_t>(
+        event.mm_filemap_delete_from_page_cache().i_ino());
+    return true;
+  }
+  return false;
+}
+
+}  // namespace perfetto
diff --git a/tools/trace_to_text/ftrace_inode_handler.h b/tools/trace_to_text/ftrace_inode_handler.h
new file mode 100644
index 0000000..77b5a8a
--- /dev/null
+++ b/tools/trace_to_text/ftrace_inode_handler.h
@@ -0,0 +1,30 @@
+/*
+ * 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.
+ */
+
+#ifndef TOOLS_TRACE_TO_TEXT_FTRACE_INODE_HANDLER_H_
+#define TOOLS_TRACE_TO_TEXT_FTRACE_INODE_HANDLER_H_
+
+#include "tools/trace_to_text/ftrace_inode_handler.h"
+
+#include "perfetto/trace/trace_packet.pb.h"
+
+namespace perfetto {
+
+bool ParseInode(const protos::FtraceEvent&, uint64_t* inode);
+
+}  // namespace perfetto
+
+#endif  // TOOLS_TRACE_TO_TEXT_FTRACE_INODE_HANDLER_H_
diff --git a/tools/trace_to_text/main.cc b/tools/trace_to_text/main.cc
index 8769466..da9136d 100644
--- a/tools/trace_to_text/main.cc
+++ b/tools/trace_to_text/main.cc
@@ -22,6 +22,7 @@
 
 #include <algorithm>
 #include <fstream>
+#include <functional>
 #include <iostream>
 #include <istream>
 #include <limits>
@@ -29,7 +30,6 @@
 #include <memory>
 #include <ostream>
 #include <sstream>
-#include <string>
 #include <utility>
 
 #include <google/protobuf/compiler/importer.h>
@@ -43,6 +43,7 @@
 #include "perfetto/trace/trace.pb.h"
 #include "perfetto/trace/trace_packet.pb.h"
 #include "tools/trace_to_text/ftrace_event_formatter.h"
+#include "tools/trace_to_text/ftrace_inode_handler.h"
 
 namespace perfetto {
 namespace {
@@ -279,33 +280,10 @@
   return 0;
 }
 
-int TraceToSummary(std::istream* input, std::ostream* output) {
-  uint64_t start = std::numeric_limits<uint64_t>::max();
-  uint64_t end = 0;
-  std::multiset<uint64_t> ftrace_timestamps;
-
-  ForEachPacketInTrace(input, [&start, &end, &ftrace_timestamps](
-                                  const protos::TracePacket& packet) {
-    if (!packet.has_ftrace_events())
-      return;
-
-    const FtraceEventBundle& bundle = packet.ftrace_events();
-
-    for (const FtraceEvent& event : bundle.event()) {
-      if (event.timestamp()) {
-        start = std::min<uint64_t>(start, event.timestamp());
-        end = std::max<uint64_t>(end, event.timestamp());
-        ftrace_timestamps.insert(event.timestamp());
-      }
-    }
-  });
-
-  fprintf(stderr, "\n");
-
-  char line[2048];
-  sprintf(line, "Duration: %" PRIu64 "ms\n", (end - start) / (1000 * 1000));
-  *output << std::string(line);
-
+void PrintFtraceTrack(std::ostream* output,
+                      const uint64_t& start,
+                      const uint64_t& end,
+                      const std::multiset<uint64_t>& ftrace_timestamps) {
   constexpr char kFtraceTrackName[] = "ftrace ";
   size_t width = GetWidth();
   size_t bucket_count = width - strlen(kFtraceTrackName);
@@ -321,14 +299,115 @@
 
   std::vector<std::string> out =
       std::vector<std::string>({" ", "▁", "▂", "▃", "▄", "▅", "▆", "▇"});
-  *output << kFtraceTrackName;
+  *output << "-------------------- " << kFtraceTrackName
+          << "--------------------\n";
+  char line[2048];
   for (size_t i = 0; i < bucket_count; i++) {
     sprintf(
         line, "%s",
         out[std::min(buckets[i] / (max / out.size()), out.size() - 1)].c_str());
     *output << std::string(line);
   }
+  *output << "\n\n";
+}
+
+void PrintInodeStats(std::ostream* output,
+                     const std::set<uint64_t>& inode_numbers,
+                     const uint64_t& events_with_inodes) {
+  *output << "--------------------Inode Stats-------------------\n";
+  char line[2048];
+  sprintf(line, "Unique inodes: %" PRIu64 "\n", inode_numbers.size());
+  *output << std::string(line);
+
+  sprintf(line, "Events with inodes: %" PRIu64 "\n", events_with_inodes);
+  *output << std::string(line);
   *output << "\n";
+}
+
+void PrintProcessStats(std::ostream* output,
+                       const std::set<pid_t>& tids_in_tree,
+                       const std::set<pid_t>& tids_in_events) {
+  *output << "----------------Process Tree Stats----------------\n";
+
+  char tid[2048];
+  sprintf(tid, "Unique thread ids in process tree: %" PRIu64 "\n",
+          tids_in_tree.size());
+  *output << std::string(tid);
+
+  char tid_event[2048];
+  sprintf(tid_event, "Unique thread ids in ftrace events: %" PRIu64 "\n",
+          tids_in_events.size());
+  *output << std::string(tid_event);
+
+  std::set<pid_t> intersect;
+  set_intersection(tids_in_tree.begin(), tids_in_tree.end(),
+                   tids_in_events.begin(), tids_in_events.end(),
+                   std::inserter(intersect, intersect.begin()));
+
+  char matching[2048];
+  sprintf(matching,
+          "Thread ids with process info: %" PRIu64 "/%" PRIu64 " -> %" PRIu64
+          "%%\n\n",
+          intersect.size(), tids_in_events.size(),
+          (intersect.size() * 100) / tids_in_events.size());
+  *output << std::string(matching);
+  *output << "\n";
+}
+
+int TraceToSummary(std::istream* input, std::ostream* output) {
+  uint64_t start = std::numeric_limits<uint64_t>::max();
+  uint64_t end = 0;
+  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;
+
+  ForEachPacketInTrace(
+      input,
+      [&start, &end, &ftrace_timestamps, &tids_in_tree, &tids_in_events,
+       &inode_numbers, &events_with_inodes](const protos::TracePacket& packet) {
+
+        if (packet.has_process_tree()) {
+          const ProcessTree& tree = packet.process_tree();
+          for (Process process : tree.processes()) {
+            for (ProcessTree::Thread thread : process.threads()) {
+              tids_in_tree.insert(thread.tid());
+            }
+          }
+        }
+
+        if (!packet.has_ftrace_events())
+          return;
+
+        const FtraceEventBundle& bundle = packet.ftrace_events();
+        uint64_t inode_number = 0;
+        for (const FtraceEvent& event : bundle.event()) {
+          if (ParseInode(event, &inode_number)) {
+            inode_numbers.insert(inode_number);
+            events_with_inodes++;
+          }
+          if (event.pid()) {
+            tids_in_events.insert(event.pid());
+          }
+          if (event.timestamp()) {
+            start = std::min<uint64_t>(start, event.timestamp());
+            end = std::max<uint64_t>(end, event.timestamp());
+            ftrace_timestamps.insert(event.timestamp());
+          }
+        }
+      });
+
+  fprintf(stderr, "\n");
+
+  char line[2048];
+  sprintf(line, "Duration: %" PRIu64 "ms\n", (end - start) / (1000 * 1000));
+  *output << std::string(line);
+
+  PrintFtraceTrack(output, start, end, ftrace_timestamps);
+  PrintProcessStats(output, tids_in_tree, tids_in_events);
+  PrintInodeStats(output, inode_numbers, events_with_inodes);
+
   return 0;
 }