[scudo] Adding an interface function to print allocator stats

[cryptoad]

Summary

This adds __scudo_print_stats as an interface function to display the Primary
and Secondary allocator statistics for Scudo.

[cryptoad]

Added a very generic test.

[alekseyshl]

include/sanitizer/scudo_interface.h

31

Add a comment describing the intended use and what kind of stats (in general) it prints.

[cryptoad]

Add description of the function in the interface header.

include/sanitizer/scudo_interface.h

#endif
   // a string containing Scudo runtime options. See scudo_flags.h for details.
   const char* __scudo_default_options(void);
 
   // This function allows to set the RSS limit at runtime. This can be either
   // the hard limit (HardLimit=1) or the soft limit (HardLimit=0). The limit
   // can be removed by setting LimitMb to 0. This function's parameters should
   // be fully trusted to avoid security mishaps.
   void __scudo_set_rss_limit(size_t LimitMb, int HardLimit);
+
+  // This function outputs various allocator statistics for both the Primary
+  // and Secondary allocators, including memory usage, number of allocations
+  // and deallocations.
+  void __scudo_print_stats(void);
 #ifdef __cplusplus
 }  // extern "C"
 #endif
 
 #endif  // SANITIZER_SCUDO_INTERFACE_H_

lib/scudo/scudo_allocator.cpp

struct ScudoAllocator {
 
   void setRssLimit(uptr LimitMb, bool HardLimit) {
     if (HardLimit)
       HardRssLimitMb = LimitMb;
     else
       SoftRssLimitMb = LimitMb;
     CheckRssLimit = HardRssLimitMb || SoftRssLimitMb;
   }
+
+  void printStats() {
+    initThreadMaybe();
+    BackendAllocator.printStats();
+  }
 };
 
 static ScudoAllocator Instance(LINKER_INITIALIZED);
 
 static ScudoBackendAllocator &getBackendAllocator() {
   return Instance.BackendAllocator;
 }
 

 
 // Interface functions
 
 void __scudo_set_rss_limit(uptr LimitMb, s32 HardLimit) {
   if (!SCUDO_CAN_USE_PUBLIC_INTERFACE)
     return;
   Instance.setRssLimit(LimitMb, !!HardLimit);
 }
+
+void __scudo_print_stats() {
+  Instance.printStats();
+}

lib/scudo/scudo_allocator_combined.h

public:
   void destroyCache(AllocatorCache *Cache) {
     Cache->Destroy(&Primary, &Stats);
   }
 
   void getStats(AllocatorStatCounters StatType) const {
     Stats.Get(StatType);
   }
 
+  void printStats() {
+    Primary.PrintStats();
+    Secondary.PrintStats();
+  }
+
  private:
   PrimaryAllocator Primary;
   SecondaryAllocator Secondary;
   AllocatorGlobalStats Stats;
 };
 
 #endif  // SCUDO_ALLOCATOR_COMBINED_H_

lib/scudo/scudo_interface_internal.h

 using __sanitizer::s32;
 
 extern "C" {
 SANITIZER_INTERFACE_ATTRIBUTE SANITIZER_WEAK_ATTRIBUTE
 const char* __scudo_default_options();
 
 SANITIZER_INTERFACE_ATTRIBUTE
 void __scudo_set_rss_limit(uptr LimitMb, s32 HardLimit);
+
+SANITIZER_INTERFACE_ATTRIBUTE
+void __scudo_print_stats();
 }  // extern "C"
 
 #endif  // SCUDO_INTERFACE_INTERNAL_H_

test/scudo/stats.c

+// RUN: %clang_scudo %s -o %t
+// RUN: %run %t 2>&1 | FileCheck %s
+
+// Tests that the allocator stats printing function exists and outputs
+// "something". Currently that "something" is fairly nebulous, as the 32-bit
+// primary doesn't output anything, and for the 64-bit one it's highly dependent
+// on the size class map and potential library allocations. So keep it very
+// generic for now.
+
+#include <stdlib.h>
+
+#include <sanitizer/scudo_interface.h>
+
+int main(int argc, char **argv)
+{
+  free(malloc(1U));
+  __scudo_print_stats();
+  return 0;
+}
+
+// CHECK: Stats: