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