1 /*
   2  * Copyright (c) 2013, 2019, Oracle and/or its affiliates. All rights reserved.
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * This code is free software; you can redistribute it and/or modify it
   6  * under the terms of the GNU General Public License version 2 only, as
   7  * published by the Free Software Foundation.
   8  *
   9  * This code is distributed in the hope that it will be useful, but WITHOUT
  10  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  11  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  12  * version 2 for more details (a copy is included in the LICENSE file that
  13  * accompanied this code).
  14  *
  15  * You should have received a copy of the GNU General Public License version
  16  * 2 along with this work; if not, write to the Free Software Foundation,
  17  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
  18  *
  19  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
  20  * or visit www.oracle.com if you need additional information or have any
  21  * questions.
  22  *
  23  */
  24 
  25 #ifndef SHARE_SERVICES_MEMTRACKER_HPP
  26 #define SHARE_SERVICES_MEMTRACKER_HPP
  27 
  28 #include "services/nmtCommon.hpp"
  29 #include "utilities/nativeCallStack.hpp"
  30 
  31 
  32 #if !INCLUDE_NMT
  33 
  34 #define CURRENT_PC   NativeCallStack::empty_stack()
  35 #define CALLER_PC    NativeCallStack::empty_stack()
  36 
  37 class Tracker : public StackObj {
  38  public:
  39   enum TrackerType {
  40      uncommit,
  41      release
  42   };
  43   Tracker(enum TrackerType type) : _type(type) { }
  44   void record(address addr, size_t size) { }
  45  private:
  46   enum TrackerType  _type;
  47 };
  48 
  49 class MemTracker : AllStatic {
  50  public:
  51   static inline NMT_TrackingLevel tracking_level() { return NMT_off; }
  52   static inline void shutdown() { }
  53   static inline void init() { }
  54   static bool check_launcher_nmt_support(const char* value) { return true; }
  55   static bool verify_nmt_option() { return true; }
  56 
  57   static inline void* record_malloc(void* mem_base, size_t size, MEMFLAGS flag,
  58     const NativeCallStack& stack, NMT_TrackingLevel level) { return mem_base; }
  59   static inline size_t malloc_header_size(NMT_TrackingLevel level) { return 0; }
  60   static inline size_t malloc_header_size(void* memblock) { return 0; }
  61   static inline void* malloc_base(void* memblock) { return memblock; }
  62   static inline void* record_free(void* memblock, NMT_TrackingLevel level) { return memblock; }
  63 
  64   static inline void record_new_arena(MEMFLAGS flag) { }
  65   static inline void record_arena_free(MEMFLAGS flag) { }
  66   static inline void record_arena_size_change(ssize_t diff, MEMFLAGS flag) { }
  67   static inline void record_virtual_memory_reserve(void* addr, size_t size, const NativeCallStack& stack,
  68                        MEMFLAGS flag = mtNone) { }
  69   static inline void record_virtual_memory_reserve_and_commit(void* addr, size_t size,
  70     const NativeCallStack& stack, MEMFLAGS flag = mtNone) { }
  71   static inline void record_virtual_memory_commit(void* addr, size_t size, const NativeCallStack& stack) { }
  72   static inline void record_virtual_memory_type(void* addr, MEMFLAGS flag) { }
  73   static inline void record_thread_stack(void* addr, size_t size) { }
  74   static inline void release_thread_stack(void* addr, size_t size) { }
  75 
  76   static void final_report(outputStream*) { }
  77   static void error_report(outputStream*) { }
  78 };
  79 
  80 #else
  81 
  82 #include "runtime/mutexLocker.hpp"
  83 #include "runtime/threadCritical.hpp"
  84 #include "services/mallocTracker.hpp"
  85 #include "services/threadStackTracker.hpp"
  86 #include "services/virtualMemoryTracker.hpp"
  87 
  88 extern volatile bool NMT_stack_walkable;
  89 
  90 #define CURRENT_PC ((MemTracker::tracking_level() == NMT_detail && NMT_stack_walkable) ? \
  91                     NativeCallStack(0, true) : NativeCallStack::empty_stack())
  92 #define CALLER_PC  ((MemTracker::tracking_level() == NMT_detail && NMT_stack_walkable) ?  \
  93                     NativeCallStack(1, true) : NativeCallStack::empty_stack())
  94 
  95 class MemBaseline;
  96 
  97 // Tracker is used for guarding 'release' semantics of virtual memory operation, to avoid
  98 // the other thread obtains and records the same region that is just 'released' by current
  99 // thread but before it can record the operation.
 100 class Tracker : public StackObj {
 101  public:
 102   enum TrackerType {
 103      uncommit,
 104      release
 105   };
 106 
 107  public:
 108   Tracker(enum TrackerType type) : _type(type) { }
 109   void record(address addr, size_t size);
 110  private:
 111   enum TrackerType  _type;
 112   // Virtual memory tracking data structures are protected by ThreadCritical lock.
 113   ThreadCritical    _tc;
 114 };
 115 
 116 class MemTracker : AllStatic {
 117   friend class VirtualMemoryTrackerTest;
 118 
 119  public:
 120   static inline NMT_TrackingLevel tracking_level() {
 121     if (_tracking_level == NMT_unknown) {
 122       // No fencing is needed here, since JVM is in single-threaded
 123       // mode.
 124       _tracking_level = init_tracking_level();
 125       _cmdline_tracking_level = _tracking_level;
 126     }
 127     return _tracking_level;
 128   }
 129 
 130   // A late initialization, for the stuff(s) can not be
 131   // done in init_tracking_level(), which can NOT malloc
 132   // any memory.
 133   static void init();
 134 
 135   // Shutdown native memory tracking
 136   static void shutdown();
 137 
 138   // Verify native memory tracking command line option.
 139   // This check allows JVM to detect if compatible launcher
 140   // is used.
 141   // If an incompatible launcher is used, NMT may not be
 142   // able to start, even it is enabled by command line option.
 143   // A warning message should be given if it is encountered.
 144   static bool check_launcher_nmt_support(const char* value);
 145 
 146   // This method checks native memory tracking environment
 147   // variable value passed by launcher.
 148   // Launcher only obligated to pass native memory tracking
 149   // option value, but not obligated to validate the value,
 150   // and launcher has option to discard native memory tracking
 151   // option from the command line once it sets up the environment
 152   // variable, so NMT has to catch the bad value here.
 153   static bool verify_nmt_option();
 154 
 155   // Transition the tracking level to specified level
 156   static bool transition_to(NMT_TrackingLevel level);
 157 
 158   static inline void* record_malloc(void* mem_base, size_t size, MEMFLAGS flag,
 159     const NativeCallStack& stack, NMT_TrackingLevel level) {
 160     if (level != NMT_off) {
 161       return MallocTracker::record_malloc(mem_base, size, flag, stack, level);
 162     }
 163     return mem_base;
 164   }
 165 
 166   static inline size_t malloc_header_size(NMT_TrackingLevel level) {
 167     return MallocTracker::malloc_header_size(level);
 168   }
 169 
 170   static size_t malloc_header_size(void* memblock) {
 171     if (tracking_level() != NMT_off) {
 172       return MallocTracker::get_header_size(memblock);
 173     }
 174     return 0;
 175   }
 176 
 177   // To malloc base address, which is the starting address
 178   // of malloc tracking header if tracking is enabled.
 179   // Otherwise, it returns the same address.
 180   static void* malloc_base(void* memblock);
 181 
 182   // Record malloc free and return malloc base address
 183   static inline void* record_free(void* memblock, NMT_TrackingLevel level) {
 184     // Never turned on
 185     if (level == NMT_off || memblock == NULL) {
 186       return memblock;
 187     }
 188     return MallocTracker::record_free(memblock);
 189   }
 190 
 191 
 192   // Record creation of an arena
 193   static inline void record_new_arena(MEMFLAGS flag) {
 194     if (tracking_level() < NMT_summary) return;
 195     MallocTracker::record_new_arena(flag);
 196   }
 197 
 198   // Record destruction of an arena
 199   static inline void record_arena_free(MEMFLAGS flag) {
 200     if (tracking_level() < NMT_summary) return;
 201     MallocTracker::record_arena_free(flag);
 202   }
 203 
 204   // Record arena size change. Arena size is the size of all arena
 205   // chuncks that backing up the arena.
 206   static inline void record_arena_size_change(ssize_t diff, MEMFLAGS flag) {
 207     if (tracking_level() < NMT_summary) return;
 208     MallocTracker::record_arena_size_change(diff, flag);
 209   }
 210 
 211   static inline void record_virtual_memory_reserve(void* addr, size_t size, const NativeCallStack& stack,
 212     MEMFLAGS flag = mtNone) {
 213     if (tracking_level() < NMT_summary) return;
 214     if (addr != NULL) {
 215       ThreadCritical tc;
 216       // Recheck to avoid potential racing during NMT shutdown
 217       if (tracking_level() < NMT_summary) return;
 218       VirtualMemoryTracker::add_reserved_region((address)addr, size, stack, flag);
 219     }
 220   }
 221 
 222   static inline void record_virtual_memory_reserve_and_commit(void* addr, size_t size,
 223     const NativeCallStack& stack, MEMFLAGS flag = mtNone) {
 224     if (tracking_level() < NMT_summary) return;
 225     if (addr != NULL) {
 226       ThreadCritical tc;
 227       if (tracking_level() < NMT_summary) return;
 228       VirtualMemoryTracker::add_reserved_region((address)addr, size, stack, flag);
 229       VirtualMemoryTracker::add_committed_region((address)addr, size, stack);
 230     }
 231   }
 232 
 233   static inline void record_virtual_memory_commit(void* addr, size_t size,
 234     const NativeCallStack& stack) {
 235     if (tracking_level() < NMT_summary) return;
 236     if (addr != NULL) {
 237       ThreadCritical tc;
 238       if (tracking_level() < NMT_summary) return;
 239       VirtualMemoryTracker::add_committed_region((address)addr, size, stack);
 240     }
 241   }
 242 
 243   static inline void record_virtual_memory_type(void* addr, MEMFLAGS flag) {
 244     if (tracking_level() < NMT_summary) return;
 245     if (addr != NULL) {
 246       ThreadCritical tc;
 247       if (tracking_level() < NMT_summary) return;
 248       VirtualMemoryTracker::set_reserved_region_type((address)addr, flag);
 249     }
 250   }
 251 
 252   static void record_thread_stack(void* addr, size_t size) {
 253     if (tracking_level() < NMT_summary) return;
 254     if (addr != NULL) {
 255       ThreadStackTracker::new_thread_stack((address)addr, size, CALLER_PC);
 256     }
 257   }
 258 
 259   static inline void release_thread_stack(void* addr, size_t size) {
 260     if (tracking_level() < NMT_summary) return;
 261     if (addr != NULL) {
 262       ThreadStackTracker::delete_thread_stack((address)addr, size);
 263     }
 264   }
 265 
 266   // Query lock is used to synchronize the access to tracking data.
 267   // So far, it is only used by JCmd query, but it may be used by
 268   // other tools.
 269   static inline Mutex* query_lock() {
 270     assert(NMTQuery_lock != NULL, "not initialized!");
 271     return NMTQuery_lock;
 272   }
 273 
 274   // Make a final report or report for hs_err file.
 275   static void error_report(outputStream* output) {
 276     if (tracking_level() >= NMT_summary) {
 277       report(true, output);  // just print summary for error case.
 278     }
 279    }
 280 
 281   static void final_report(outputStream* output);
 282 
 283   // Stored baseline
 284   static inline MemBaseline& get_baseline() {
 285     return _baseline;
 286   }
 287 
 288   static NMT_TrackingLevel cmdline_tracking_level() {
 289     return _cmdline_tracking_level;
 290   }
 291 
 292   static void tuning_statistics(outputStream* out);
 293 
 294  private:
 295   static NMT_TrackingLevel init_tracking_level();
 296   static void report(bool summary_only, outputStream* output);
 297 
 298  private:
 299   // Tracking level
 300   static volatile NMT_TrackingLevel   _tracking_level;
 301   // If NMT option value passed by launcher through environment
 302   // variable is valid
 303   static bool                         _is_nmt_env_valid;
 304   // command line tracking level
 305   static NMT_TrackingLevel            _cmdline_tracking_level;
 306   // Stored baseline
 307   static MemBaseline      _baseline;
 308   // Query lock
 309   static Mutex*           _query_lock;
 310 };
 311 
 312 #endif // INCLUDE_NMT
 313 
 314 #endif // SHARE_SERVICES_MEMTRACKER_HPP