1 /*
   2  * Copyright (c) 2012, 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 package sun.hotspot;
  26 
  27 import java.lang.management.MemoryUsage;
  28 import java.lang.reflect.Executable;
  29 import java.util.Arrays;
  30 import java.util.List;
  31 import java.util.function.Function;
  32 import java.util.stream.Stream;
  33 import java.security.BasicPermission;
  34 import java.net.URL;
  35 
  36 import sun.hotspot.parser.DiagnosticCommand;
  37 
  38 public class WhiteBox {
  39 
  40   @SuppressWarnings("serial")
  41   public static class WhiteBoxPermission extends BasicPermission {
  42     public WhiteBoxPermission(String s) {
  43       super(s);
  44     }
  45   }
  46 
  47   private WhiteBox() {}
  48   private static final WhiteBox instance = new WhiteBox();
  49   private static native void registerNatives();
  50 
  51   /**
  52    * Returns the singleton WhiteBox instance.
  53    *
  54    * The returned WhiteBox object should be carefully guarded
  55    * by the caller, since it can be used to read and write data
  56    * at arbitrary memory addresses. It must never be passed to
  57    * untrusted code.
  58    */
  59   public synchronized static WhiteBox getWhiteBox() {
  60     SecurityManager sm = System.getSecurityManager();
  61     if (sm != null) {
  62       sm.checkPermission(new WhiteBoxPermission("getInstance"));
  63     }
  64     return instance;
  65   }
  66 
  67   static {
  68     registerNatives();
  69   }
  70 
  71   // Get the maximum heap size supporting COOPs
  72   public native long getCompressedOopsMaxHeapSize();
  73   // Arguments
  74   public native void printHeapSizes();
  75 
  76   // Memory
  77   public native long getObjectAddress(Object o);
  78   public native int  getHeapOopSize();
  79   public native long getHeapAlignment();
  80   public native int  getVMPageSize();
  81   public native long getVMLargePageSize();
  82 
  83   public native boolean isObjectInOldGen(Object o);
  84   public native long getObjectSize(Object o);
  85 
  86   // Runtime
  87   // Make sure class name is in the correct format
  88   public boolean isClassAlive(String name) {
  89     return isClassAlive0(name.replace('.', '/'));
  90   }
  91   private native boolean isClassAlive0(String name);
  92   public native boolean isMonitorInflated(Object obj);
  93   public native void forceSafepoint();
  94 
  95   // Resource/Class Lookup Cache
  96   public native boolean classKnownToNotExist(ClassLoader loader, String name);
  97   public native URL[] getLookupCacheURLs(ClassLoader loader);
  98   public native int[] getLookupCacheMatches(ClassLoader loader, String name);
  99 
 100   // JVMTI
 101   public native void addToBootstrapClassLoaderSearch(String segment);
 102   public native void addToSystemClassLoaderSearch(String segment);
 103 
 104   // G1
 105   public native boolean g1InConcurrentMark();
 106   public native boolean g1IsHumongous(Object o);
 107   public native long    g1NumMaxRegions();
 108   public native long    g1NumFreeRegions();
 109   public native int     g1RegionSize();
 110   public native MemoryUsage g1AuxiliaryMemoryUsage();
 111   public native Object[]    parseCommandLine(String commandline, DiagnosticCommand[] args);
 112 
 113   // NMT
 114   public native long NMTMalloc(long size);
 115   public native void NMTFree(long mem);
 116   public native long NMTReserveMemory(long size);
 117   public native void NMTCommitMemory(long addr, long size);
 118   public native void NMTUncommitMemory(long addr, long size);
 119   public native void NMTReleaseMemory(long addr, long size);
 120   public native long NMTMallocWithPseudoStack(long size, int index);
 121   public native long NMTMallocWithPseudoStackAndType(long size, int index, int type);
 122   public native boolean NMTIsDetailSupported();
 123   public native boolean NMTChangeTrackingLevel();
 124   public native int NMTGetHashSize();
 125 
 126   // Compiler
 127   public native void    deoptimizeAll();
 128   public        boolean isMethodCompiled(Executable method) {
 129     return isMethodCompiled(method, false /*not osr*/);
 130   }
 131   public native boolean isMethodCompiled(Executable method, boolean isOsr);
 132   public        boolean isMethodCompilable(Executable method) {
 133     return isMethodCompilable(method, -1 /*any*/);
 134   }
 135   public        boolean isMethodCompilable(Executable method, int compLevel) {
 136     return isMethodCompilable(method, compLevel, false /*not osr*/);
 137   }
 138   public native boolean isMethodCompilable(Executable method, int compLevel, boolean isOsr);
 139   public native boolean isMethodQueuedForCompilation(Executable method);
 140   public        int     deoptimizeMethod(Executable method) {
 141     return deoptimizeMethod(method, false /*not osr*/);
 142   }
 143   public native int     deoptimizeMethod(Executable method, boolean isOsr);
 144   public        void    makeMethodNotCompilable(Executable method) {
 145     makeMethodNotCompilable(method, -1 /*any*/);
 146   }
 147   public        void    makeMethodNotCompilable(Executable method, int compLevel) {
 148     makeMethodNotCompilable(method, compLevel, false /*not osr*/);
 149   }
 150   public native void    makeMethodNotCompilable(Executable method, int compLevel, boolean isOsr);
 151   public        int     getMethodCompilationLevel(Executable method) {
 152     return getMethodCompilationLevel(method, false /*not ost*/);
 153   }
 154   public native int     getMethodCompilationLevel(Executable method, boolean isOsr);
 155   public native boolean testSetDontInlineMethod(Executable method, boolean value);
 156   public        int     getCompileQueuesSize() {
 157     return getCompileQueueSize(-1 /*any*/);
 158   }
 159   public native int     getCompileQueueSize(int compLevel);
 160   public native boolean testSetForceInlineMethod(Executable method, boolean value);
 161   public        boolean enqueueMethodForCompilation(Executable method, int compLevel) {
 162     return enqueueMethodForCompilation(method, compLevel, -1 /*InvocationEntryBci*/);
 163   }
 164   public boolean enqueueMethodForCompilation(Executable method, int compLevel, int entry_bci) {
 165     return enqueueMethodForCompilation0(method, compLevel, entry_bci);
 166   }
 167 
 168   public native boolean enqueueInitializerForCompilation0(Class clazz, int compLevel);
 169   public native boolean enqueueMethodForCompilation0(Executable method, int compLevel, int entry_bci);
 170   public native void    clearMethodState(Executable method);
 171   public native void    markMethodProfiled(Executable method);
 172   public native int     getMethodEntryBci(Executable method);
 173   public native Object[] getNMethod(Executable method, boolean isOsr);
 174 
 175   // Intered strings
 176   public native boolean isInStringTable(String str);
 177 
 178   // Memory
 179   public native void readReservedMemory();
 180   public native long allocateCodeBlob(int size, int blobType);
 181   public native void freeCodeBlob(long address);
 182   public native Object[] getCodeBlob(long address);
 183   public native long allocateMetaspace(ClassLoader classLoader, long size);
 184   public native void freeMetaspace(ClassLoader classLoader, long addr, long size);
 185   public native long incMetaspaceCapacityUntilGC(long increment);
 186   public native long metaspaceCapacityUntilGC();
 187 
 188   // Force Young GC
 189   public native void youngGC();
 190 
 191   // Force Full GC
 192   public native void fullGC();
 193 
 194   // Method tries to start concurrent mark cycle.
 195   // It returns false if CM Thread is always in concurrent cycle.
 196   public native boolean g1StartConcMarkCycle();
 197 
 198   // Tests on ReservedSpace/VirtualSpace classes
 199   public native int stressVirtualSpaceResize(long reservedSpaceSize, long magnitude, long iterations);
 200   public native void runMemoryUnitTests();
 201   public native void readFromNoaccessArea();
 202   public native long getThreadStackSize();
 203   public native long getThreadRemainingStackSize();
 204 
 205   // CPU features
 206   public native String getCPUFeatures();
 207 
 208   // Native extensions
 209   public native long getHeapUsageForContext(int context);
 210   public native long getHeapRegionCountForContext(int context);
 211   public native int getContextForObject(Object obj);
 212   public native void printRegionInfo(int context);
 213 
 214   // VM flags
 215   public native void    setBooleanVMFlag(String name, boolean value);
 216   public native void    setIntxVMFlag(String name, long value);
 217   public native void    setUintxVMFlag(String name, long value);
 218   public native void    setUint64VMFlag(String name, long value);
 219   public native void    setStringVMFlag(String name, String value);
 220   public native void    setDoubleVMFlag(String name, double value);
 221   public native Boolean getBooleanVMFlag(String name);
 222   public native Long    getIntxVMFlag(String name);
 223   public native Long    getUintxVMFlag(String name);
 224   public native Long    getUint64VMFlag(String name);
 225   public native String  getStringVMFlag(String name);
 226   public native Double  getDoubleVMFlag(String name);
 227   private final List<Function<String,Object>> flagsGetters = Arrays.asList(
 228     this::getBooleanVMFlag, this::getIntxVMFlag, this::getUintxVMFlag,
 229     this::getUint64VMFlag, this::getStringVMFlag, this::getDoubleVMFlag);
 230 
 231   public Object getVMFlag(String name) {
 232     return flagsGetters.stream()
 233                        .map(f -> f.apply(name))
 234                        .filter(x -> x != null)
 235                        .findAny()
 236                        .orElse(null);
 237   }
 238   public native int getOffsetForName0(String name);
 239   public int getOffsetForName(String name) throws Exception {
 240     int offset = getOffsetForName0(name);
 241     if (offset == -1) {
 242       throw new RuntimeException(name + " not found");
 243     }
 244     return offset;
 245   }
 246 
 247   // Class Data Sharing
 248   public native boolean isSharedClass(Class<?> c);
 249 
 250   // Returns true on linux if library has the noexecstack flag set.
 251   public native boolean checkLibSpecifiesNoexecstack(String libfilename);
 252 
 253   // Container testing
 254   public native boolean isContainerized();
 255   public native void printOsInfo();
 256 
 257 }