| /* |
| * Copyright (c) 2005, 2008, Oracle and/or its affiliates. All rights reserved. |
| * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. |
| * |
| * This code is free software; you can redistribute it and/or modify it |
| * under the terms of the GNU General Public License version 2 only, as |
| * published by the Free Software Foundation. Oracle designates this |
| * particular file as subject to the "Classpath" exception as provided |
| * by Oracle in the LICENSE file that accompanied this code. |
| * |
| * This code is distributed in the hope that it will be useful, but WITHOUT |
| * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or |
| * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License |
| * version 2 for more details (a copy is included in the LICENSE file that |
| * accompanied this code). |
| * |
| * You should have received a copy of the GNU General Public License version |
| * 2 along with this work; if not, write to the Free Software Foundation, |
| * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. |
| * |
| * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA |
| * or visit www.oracle.com if you need additional information or have any |
| * questions. |
| */ |
| |
| package sun.tools.jmap; |
| |
| import java.lang.reflect.Method; |
| import java.io.File; |
| import java.io.IOException; |
| import java.io.InputStream; |
| |
| import com.sun.tools.attach.VirtualMachine; |
| import com.sun.tools.attach.AttachNotSupportedException; |
| import sun.tools.attach.HotSpotVirtualMachine; |
| |
| /* |
| * This class is the main class for the JMap utility. It parses its arguments |
| * and decides if the command should be satisifed using the VM attach mechanism |
| * or an SA tool. At this time the only option that uses the VM attach mechanism |
| * is the -dump option to get a heap dump of a running application. All other |
| * options are mapped to SA tools. |
| */ |
| public class JMap { |
| |
| // Options handled by the attach mechanism |
| private static String HISTO_OPTION = "-histo"; |
| private static String LIVE_HISTO_OPTION = "-histo:live"; |
| private static String DUMP_OPTION_PREFIX = "-dump:"; |
| |
| // These options imply the use of a SA tool |
| private static String SA_TOOL_OPTIONS = |
| "-heap|-heap:format=b|-permstat|-finalizerinfo"; |
| |
| // The -F (force) option is currently not passed through to SA |
| private static String FORCE_SA_OPTION = "-F"; |
| |
| // Default option (if nothing provided) |
| private static String DEFAULT_OPTION = "-pmap"; |
| |
| public static void main(String[] args) throws Exception { |
| if (args.length == 0) { |
| usage(); // no arguments |
| } |
| |
| // used to indicate if we should use SA |
| boolean useSA = false; |
| |
| // the chosen option (-heap, -dump:*, ... ) |
| String option = null; |
| |
| // First iterate over the options (arguments starting with -). There should be |
| // one (but maybe two if -F is also used). |
| int optionCount = 0; |
| while (optionCount < args.length) { |
| String arg = args[optionCount]; |
| if (!arg.startsWith("-")) { |
| break; |
| } |
| if (arg.equals(FORCE_SA_OPTION)) { |
| useSA = true; |
| } else { |
| if (option != null) { |
| usage(); // option already specified |
| } |
| option = arg; |
| } |
| optionCount++; |
| } |
| |
| // if no option provided then use default. |
| if (option == null) { |
| option = DEFAULT_OPTION; |
| } |
| if (option.matches(SA_TOOL_OPTIONS)) { |
| useSA = true; |
| } |
| |
| // Next we check the parameter count. For the SA tools there are |
| // one or two parameters. For the built-in -dump option there is |
| // only one parameter (the process-id) |
| int paramCount = args.length - optionCount; |
| if (paramCount == 0 || paramCount > 2) { |
| usage(); |
| } |
| |
| if (optionCount == 0 || paramCount != 1) { |
| useSA = true; |
| } else { |
| // the parameter for the -dump option is a process-id. |
| // If it doesn't parse to a number then it must be SA |
| // debug server |
| if (!args[optionCount].matches("[0-9]+")) { |
| useSA = true; |
| } |
| } |
| |
| |
| // at this point we know if we are executing an SA tool or a built-in |
| // option. |
| |
| if (useSA) { |
| // parameters (<pid> or <exe> <core>) |
| String params[] = new String[paramCount]; |
| for (int i=optionCount; i<args.length; i++ ){ |
| params[i-optionCount] = args[i]; |
| } |
| runTool(option, params); |
| |
| } else { |
| String pid = args[1]; |
| // Here we handle the built-in options |
| // As more options are added we should create an abstract tool class and |
| // have a table to map the options |
| if (option.equals(HISTO_OPTION)) { |
| histo(pid, false); |
| } else if (option.equals(LIVE_HISTO_OPTION)) { |
| histo(pid, true); |
| } else if (option.startsWith(DUMP_OPTION_PREFIX)) { |
| dump(pid, option); |
| } else { |
| usage(); |
| } |
| } |
| } |
| |
| // Invoke SA tool with the given arguments |
| private static void runTool(String option, String args[]) throws Exception { |
| String[][] tools = { |
| { "-pmap", "sun.jvm.hotspot.tools.PMap" }, |
| { "-heap", "sun.jvm.hotspot.tools.HeapSummary" }, |
| { "-heap:format=b", "sun.jvm.hotspot.tools.HeapDumper" }, |
| { "-histo", "sun.jvm.hotspot.tools.ObjectHistogram" }, |
| { "-permstat", "sun.jvm.hotspot.tools.PermStat" }, |
| { "-finalizerinfo", "sun.jvm.hotspot.tools.FinalizerInfo" }, |
| }; |
| |
| String tool = null; |
| |
| // -dump option needs to be handled in a special way |
| if (option.startsWith(DUMP_OPTION_PREFIX)) { |
| // first check that the option can be parsed |
| String fn = parseDumpOptions(option); |
| if (fn == null) usage(); |
| |
| // tool for heap dumping |
| tool = "sun.jvm.hotspot.tools.HeapDumper"; |
| |
| // HeapDumper -f <file> |
| args = prepend(fn, args); |
| args = prepend("-f", args); |
| } else { |
| int i=0; |
| while (i < tools.length) { |
| if (option.equals(tools[i][0])) { |
| tool = tools[i][1]; |
| break; |
| } |
| i++; |
| } |
| } |
| if (tool == null) { |
| usage(); // no mapping to tool |
| } |
| |
| // Tool not available on this platform. |
| Class<?> c = loadClass(tool); |
| if (c == null) { |
| usage(); |
| } |
| |
| // invoke the main method with the arguments |
| Class[] argTypes = { String[].class } ; |
| Method m = c.getDeclaredMethod("main", argTypes); |
| |
| Object[] invokeArgs = { args }; |
| m.invoke(null, invokeArgs); |
| } |
| |
| // loads the given class using the system class loader |
| private static Class loadClass(String name) { |
| // |
| // We specify the system clas loader so as to cater for development |
| // environments where this class is on the boot class path but sa-jdi.jar |
| // is on the system class path. Once the JDK is deployed then both |
| // tools.jar and sa-jdi.jar are on the system class path. |
| // |
| try { |
| return Class.forName(name, true, |
| ClassLoader.getSystemClassLoader()); |
| } catch (Exception x) { } |
| return null; |
| } |
| |
| private static final String LIVE_OBJECTS_OPTION = "-live"; |
| private static final String ALL_OBJECTS_OPTION = "-all"; |
| private static void histo(String pid, boolean live) throws IOException { |
| VirtualMachine vm = attach(pid); |
| InputStream in = ((HotSpotVirtualMachine)vm). |
| heapHisto(live ? LIVE_OBJECTS_OPTION : ALL_OBJECTS_OPTION); |
| drain(vm, in); |
| } |
| |
| private static void dump(String pid, String options) throws IOException { |
| // parse the options to get the dump filename |
| String filename = parseDumpOptions(options); |
| if (filename == null) { |
| usage(); // invalid options or no filename |
| } |
| |
| // get the canonical path - important to avoid just passing |
| // a "heap.bin" and having the dump created in the target VM |
| // working directory rather than the directory where jmap |
| // is executed. |
| filename = new File(filename).getCanonicalPath(); |
| |
| // dump live objects only or not |
| boolean live = isDumpLiveObjects(options); |
| |
| VirtualMachine vm = attach(pid); |
| System.out.println("Dumping heap to " + filename + " ..."); |
| InputStream in = ((HotSpotVirtualMachine)vm). |
| dumpHeap((Object)filename, |
| (live ? LIVE_OBJECTS_OPTION : ALL_OBJECTS_OPTION)); |
| drain(vm, in); |
| } |
| |
| // Parse the options to the -dump option. Valid options are format=b and |
| // file=<file>. Returns <file> if provided. Returns null if <file> not |
| // provided, or invalid option. |
| private static String parseDumpOptions(String arg) { |
| assert arg.startsWith(DUMP_OPTION_PREFIX); |
| |
| String filename = null; |
| |
| // options are separated by comma (,) |
| String options[] = arg.substring(DUMP_OPTION_PREFIX.length()).split(","); |
| |
| for (int i=0; i<options.length; i++) { |
| String option = options[i]; |
| |
| if (option.equals("format=b")) { |
| // ignore format (not needed at this time) |
| } else if (option.equals("live")) { |
| // a valid suboption |
| } else { |
| |
| // file=<file> - check that <file> is specified |
| if (option.startsWith("file=")) { |
| filename = option.substring(5); |
| if (filename.length() == 0) { |
| return null; |
| } |
| } else { |
| return null; // option not recognized |
| } |
| } |
| } |
| return filename; |
| } |
| |
| private static boolean isDumpLiveObjects(String arg) { |
| // options are separated by comma (,) |
| String options[] = arg.substring(DUMP_OPTION_PREFIX.length()).split(","); |
| for (String suboption : options) { |
| if (suboption.equals("live")) { |
| return true; |
| } |
| } |
| return false; |
| } |
| |
| // Attach to <pid>, existing if we fail to attach |
| private static VirtualMachine attach(String pid) { |
| try { |
| return VirtualMachine.attach(pid); |
| } catch (Exception x) { |
| String msg = x.getMessage(); |
| if (msg != null) { |
| System.err.println(pid + ": " + msg); |
| } else { |
| x.printStackTrace(); |
| } |
| if ((x instanceof AttachNotSupportedException) && haveSA()) { |
| System.err.println("The -F option can be used when the " + |
| "target process is not responding"); |
| } |
| System.exit(1); |
| return null; // keep compiler happy |
| } |
| } |
| |
| // Read the stream from the target VM until EOF, then detach |
| private static void drain(VirtualMachine vm, InputStream in) throws IOException { |
| // read to EOF and just print output |
| byte b[] = new byte[256]; |
| int n; |
| do { |
| n = in.read(b); |
| if (n > 0) { |
| String s = new String(b, 0, n, "UTF-8"); |
| System.out.print(s); |
| } |
| } while (n > 0); |
| in.close(); |
| vm.detach(); |
| } |
| |
| // return a new string array with arg as the first element |
| private static String[] prepend(String arg, String args[]) { |
| String[] newargs = new String[args.length+1]; |
| newargs[0] = arg; |
| System.arraycopy(args, 0, newargs, 1, args.length); |
| return newargs; |
| } |
| |
| // returns true if SA is available |
| private static boolean haveSA() { |
| Class c = loadClass("sun.jvm.hotspot.tools.HeapSummary"); |
| return (c != null); |
| } |
| |
| // print usage message |
| private static void usage() { |
| System.out.println("Usage:"); |
| if (haveSA()) { |
| System.out.println(" jmap [option] <pid>"); |
| System.out.println(" (to connect to running process)"); |
| System.out.println(" jmap [option] <executable <core>"); |
| System.out.println(" (to connect to a core file)"); |
| System.out.println(" jmap [option] [server_id@]<remote server IP or hostname>"); |
| System.out.println(" (to connect to remote debug server)"); |
| System.out.println(""); |
| System.out.println("where <option> is one of:"); |
| System.out.println(" <none> to print same info as Solaris pmap"); |
| System.out.println(" -heap to print java heap summary"); |
| System.out.println(" -histo[:live] to print histogram of java object heap; if the \"live\""); |
| System.out.println(" suboption is specified, only count live objects"); |
| System.out.println(" -permstat to print permanent generation statistics"); |
| System.out.println(" -finalizerinfo to print information on objects awaiting finalization"); |
| System.out.println(" -dump:<dump-options> to dump java heap in hprof binary format"); |
| System.out.println(" dump-options:"); |
| System.out.println(" live dump only live objects; if not specified,"); |
| System.out.println(" all objects in the heap are dumped."); |
| System.out.println(" format=b binary format"); |
| System.out.println(" file=<file> dump heap to <file>"); |
| System.out.println(" Example: jmap -dump:live,format=b,file=heap.bin <pid>"); |
| System.out.println(" -F force. Use with -dump:<dump-options> <pid> or -histo"); |
| System.out.println(" to force a heap dump or histogram when <pid> does not"); |
| System.out.println(" respond. The \"live\" suboption is not supported"); |
| System.out.println(" in this mode."); |
| System.out.println(" -h | -help to print this help message"); |
| System.out.println(" -J<flag> to pass <flag> directly to the runtime system"); |
| } else { |
| System.out.println(" jmap -histo <pid>"); |
| System.out.println(" (to connect to running process and print histogram of java object heap"); |
| System.out.println(" jmap -dump:<dump-options> <pid>"); |
| System.out.println(" (to connect to running process and dump java heap)"); |
| System.out.println(""); |
| System.out.println(" dump-options:"); |
| System.out.println(" format=b binary default"); |
| System.out.println(" file=<file> dump heap to <file>"); |
| System.out.println(""); |
| System.out.println(" Example: jmap -dump:format=b,file=heap.bin <pid>"); |
| } |
| |
| System.exit(1); |
| } |
| } |