1 /*
   2  * Copyright (c) 2000, 2008, 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.jvm.hotspot.debugger.win32;
  26 
  27 import java.io.*;
  28 import java.net.*;
  29 import java.util.*;
  30 import sun.jvm.hotspot.debugger.*;
  31 import sun.jvm.hotspot.debugger.x86.*;
  32 import sun.jvm.hotspot.debugger.win32.coff.*;
  33 import sun.jvm.hotspot.debugger.cdbg.*;
  34 import sun.jvm.hotspot.debugger.cdbg.basic.BasicDebugEvent;
  35 import sun.jvm.hotspot.utilities.*;
  36 import sun.jvm.hotspot.utilities.memo.*;
  37 
  38 /** <P> An implementation of the JVMDebugger interface which talks to
  39     the Free Windows Debug Server (FwDbgSrv) over a socket to
  40     implement attach/detach and read from process memory. All DLL and
  41     symbol table management is done in Java. </P>
  42 
  43     <P> <B>NOTE</B> that since we have the notion of fetching "Java
  44     primitive types" from the remote process (which might have
  45     different sizes than we expect) we have a bootstrapping
  46     problem. We need to know the sizes of these types before we can
  47     fetch them. The current implementation solves this problem by
  48     requiring that it be configured with these type sizes before they
  49     can be fetched. The readJ(Type) routines here will throw a
  50     RuntimeException if they are called before the debugger is
  51     configured with the Java primitive type sizes. </P> */
  52 
  53 public class Win32DebuggerLocal extends DebuggerBase implements Win32Debugger {
  54   private Socket debuggerSocket;
  55   private boolean attached;
  56   // FIXME: update when core files supported
  57   private long pid;
  58   // Communication with debug server
  59   private PrintWriter out;
  60   private DataOutputStream rawOut;
  61   private InputLexer in;
  62   private static final int PORT = 27000;
  63   private PageCache cache;
  64   private static final long SHORT_TIMEOUT = 2000;
  65   private static final long LONG_TIMEOUT = 20000;
  66 
  67   // Symbol lookup support
  68   // This is a map of library names to DLLs
  69   private Map nameToDllMap;
  70 
  71   // C/C++ debugging support
  72   private List/*<LoadObject>*/ loadObjects;
  73   private CDebugger cdbg;
  74 
  75   // ProcessControl support
  76   private boolean suspended;
  77   // Maps Long objects (addresses) to Byte objects (original instructions)
  78   // (Longs used instead of Addresses to properly represent breakpoints at 0x0 if needed)
  79   private Map     breakpoints;
  80   // Current debug event, if any
  81   private DebugEvent curDebugEvent;
  82 
  83   //--------------------------------------------------------------------------------
  84   // Implementation of Debugger interface
  85   //
  86 
  87   /** <P> machDesc may not be null. </P>
  88 
  89       <P> useCache should be set to true if debugging is being done
  90       locally, and to false if the debugger is being created for the
  91       purpose of supporting remote debugging. </P> */
  92   public Win32DebuggerLocal(MachineDescription machDesc,
  93                             boolean useCache) throws DebuggerException {
  94     this.machDesc = machDesc;
  95     utils = new DebuggerUtilities(machDesc.getAddressSize(), machDesc.isBigEndian());
  96     if (useCache) {
  97       // Cache portion of the remote process's address space.
  98       // Fetching data over the socket connection to dbx is slow.
  99       // Might be faster if we were using a binary protocol to talk to
 100       // dbx, but would have to test. For now, this cache works best
 101       // if it covers the entire heap of the remote process. FIXME: at
 102       // least should make this tunable from the outside, i.e., via
 103       // the UI. This is a cache of 4096 4K pages, or 16 MB. The page
 104       // size must be adjusted to be the hardware's page size.
 105       // (FIXME: should pick this up from the debugger.)
 106       initCache(4096, parseCacheNumPagesProperty(4096));
 107     }
 108     // FIXME: add instantiation of thread factory
 109 
 110     try {
 111       connectToDebugServer();
 112     } catch (IOException e) {
 113       throw new DebuggerException(e);
 114     }
 115   }
 116 
 117   /** From the Debugger interface via JVMDebugger */
 118   public boolean hasProcessList() throws DebuggerException {
 119     return true;
 120   }
 121 
 122   /** From the Debugger interface via JVMDebugger */
 123   public List getProcessList() throws DebuggerException {
 124     List processes = new ArrayList();
 125 
 126     try {
 127       printlnToOutput("proclist");
 128       int num = in.parseInt();
 129       for (int i = 0; i < num; i++) {
 130         int pid = in.parseInt();
 131         String name = parseString();
 132         // NOTE: Win32 hack
 133         if (name.equals("")) {
 134           name = "System Idle Process";
 135         }
 136         processes.add(new ProcessInfo(name, pid));
 137       }
 138       return processes;
 139     }
 140     catch (IOException e) {
 141       throw new DebuggerException(e);
 142     }
 143   }
 144 
 145   /** From the Debugger interface via JVMDebugger */
 146   public synchronized void attach(int processID) throws DebuggerException {
 147     if (attached) {
 148       // FIXME: update when core files supported
 149       throw new DebuggerException("Already attached to process " + pid);
 150     }
 151 
 152     try {
 153       printlnToOutput("attach " + processID);
 154       if (!in.parseBoolean()) {
 155         throw new DebuggerException("Error attaching to process, or no such process");
 156       }
 157 
 158       attached = true;
 159       pid = processID;
 160       suspended = true;
 161       breakpoints = new HashMap();
 162       curDebugEvent = null;
 163       nameToDllMap = null;
 164       loadObjects = null;
 165     }
 166     catch (IOException e) {
 167         throw new DebuggerException(e);
 168     }
 169   }
 170 
 171   /** From the Debugger interface via JVMDebugger */
 172   public synchronized void attach(String executableName, String coreFileName) throws DebuggerException {
 173     throw new DebuggerException("Core files not yet supported on Win32");
 174   }
 175 
 176   /** From the Debugger interface via JVMDebugger */
 177   public synchronized boolean detach() {
 178     if (!attached) {
 179       return false;
 180     }
 181 
 182     attached = false;
 183     suspended = false;
 184     breakpoints = null;
 185 
 186     // Close all open DLLs
 187     if (nameToDllMap != null) {
 188       for (Iterator iter = nameToDllMap.values().iterator(); iter.hasNext(); ) {
 189         DLL dll = (DLL) iter.next();
 190         dll.close();
 191       }
 192       nameToDllMap = null;
 193       loadObjects = null;
 194     }
 195 
 196     cdbg = null;
 197     clearCache();
 198 
 199     try {
 200       printlnToOutput("detach");
 201       return in.parseBoolean();
 202     }
 203     catch (IOException e) {
 204       throw new DebuggerException(e);
 205     }
 206   }
 207 
 208   /** From the Debugger interface via JVMDebugger */
 209   public Address parseAddress(String addressString) throws NumberFormatException {
 210     return newAddress(utils.scanAddress(addressString));
 211   }
 212 
 213   /** From the Debugger interface via JVMDebugger */
 214   public String getOS() {
 215     return PlatformInfo.getOS();
 216   }
 217 
 218   /** From the Debugger interface via JVMDebugger */
 219   public String getCPU() {
 220     return PlatformInfo.getCPU();
 221   }
 222 
 223   public boolean hasConsole() throws DebuggerException {
 224     return false;
 225   }
 226 
 227   public String consoleExecuteCommand(String cmd) throws DebuggerException {
 228     throw new DebuggerException("No debugger console available on Win32");
 229   }
 230 
 231   public String getConsolePrompt() throws DebuggerException {
 232     return null;
 233   }
 234 
 235   public CDebugger getCDebugger() throws DebuggerException {
 236     if (cdbg == null) {
 237       cdbg = new Win32CDebugger(this);
 238     }
 239     return cdbg;
 240   }
 241 
 242   /** From the SymbolLookup interface via Debugger and JVMDebugger */
 243   public synchronized Address lookup(String objectName, String symbol) {
 244     if (!attached) {
 245       return null;
 246     }
 247     return newAddress(lookupInProcess(objectName, symbol));
 248   }
 249 
 250   /** From the SymbolLookup interface via Debugger and JVMDebugger */
 251   public synchronized OopHandle lookupOop(String objectName, String symbol) {
 252     Address addr = lookup(objectName, symbol);
 253     if (addr == null) {
 254       return null;
 255     }
 256     return addr.addOffsetToAsOopHandle(0);
 257   }
 258 
 259   /** From the Debugger interface */
 260   public MachineDescription getMachineDescription() {
 261     return machDesc;
 262   }
 263 
 264   //--------------------------------------------------------------------------------
 265   // Implementation of ThreadAccess interface
 266   //
 267 
 268   /** From the ThreadAccess interface via Debugger and JVMDebugger */
 269   public ThreadProxy getThreadForIdentifierAddress(Address addr) {
 270     return new Win32Thread(this, addr);
 271   }
 272 
 273   public ThreadProxy getThreadForThreadId(long handle) {
 274     return new Win32Thread(this, handle);
 275   }
 276 
 277   //----------------------------------------------------------------------
 278   // Overridden from DebuggerBase because we need to relax alignment
 279   // constraints on x86
 280 
 281   public long readJLong(long address)
 282     throws UnmappedAddressException, UnalignedAddressException {
 283     checkJavaConfigured();
 284     // FIXME: allow this to be configurable. Undesirable to add a
 285     // dependency on the runtime package here, though, since this
 286     // package should be strictly underneath it.
 287     //    utils.checkAlignment(address, jlongSize);
 288     utils.checkAlignment(address, jintSize);
 289     byte[] data = readBytes(address, jlongSize);
 290     return utils.dataToJLong(data, jlongSize);
 291   }
 292 
 293   //--------------------------------------------------------------------------------
 294   // Internal routines (for implementation of Win32Address).
 295   // These must not be called until the MachineDescription has been set up.
 296   //
 297 
 298   /** From the Win32Debugger interface */
 299   public String addressValueToString(long address) {
 300     return utils.addressValueToString(address);
 301   }
 302 
 303   /** From the Win32Debugger interface */
 304   public Win32Address readAddress(long address)
 305     throws UnmappedAddressException, UnalignedAddressException {
 306     return (Win32Address) newAddress(readAddressValue(address));
 307   }
 308 
 309   public Win32Address readCompOopAddress(long address)
 310     throws UnmappedAddressException, UnalignedAddressException {
 311     return (Win32Address) newAddress(readCompOopAddressValue(address));
 312   }
 313 
 314   /** From the Win32Debugger interface */
 315   public Win32OopHandle readOopHandle(long address)
 316     throws UnmappedAddressException, UnalignedAddressException, NotInHeapException {
 317     long value = readAddressValue(address);
 318     return (value == 0 ? null : new Win32OopHandle(this, value));
 319   }
 320   public Win32OopHandle readCompOopHandle(long address)
 321     throws UnmappedAddressException, UnalignedAddressException, NotInHeapException {
 322     long value = readCompOopAddressValue(address);
 323     return (value == 0 ? null : new Win32OopHandle(this, value));
 324   }
 325 
 326   /** From the Win32Debugger interface */
 327   public void writeAddress(long address, Win32Address value) {
 328     writeAddressValue(address, getAddressValue(value));
 329   }
 330 
 331   /** From the Win32Debugger interface */
 332   public void writeOopHandle(long address, Win32OopHandle value) {
 333     writeAddressValue(address, getAddressValue(value));
 334   }
 335 
 336   //--------------------------------------------------------------------------------
 337   // Thread context access
 338   //
 339 
 340   public synchronized long[] getThreadIntegerRegisterSet(int threadHandleValue,
 341                                                          boolean mustDuplicateHandle)
 342     throws DebuggerException {
 343     if (!suspended) {
 344       throw new DebuggerException("Process not suspended");
 345     }
 346 
 347     try {
 348       int handle = threadHandleValue;
 349       if (mustDuplicateHandle) {
 350         printlnToOutput("duphandle 0x" + Integer.toHexString(threadHandleValue));
 351         if (!in.parseBoolean()) {
 352           throw new DebuggerException("Error duplicating thread handle 0x" + threadHandleValue);
 353         }
 354         handle = (int) in.parseAddress(); // Must close to avoid leaks
 355       }
 356       printlnToOutput("getcontext 0x" + Integer.toHexString(handle));
 357       if (!in.parseBoolean()) {
 358         if (mustDuplicateHandle) {
 359           printlnToOutput("closehandle 0x" + Integer.toHexString(handle));
 360         }
 361         String failMessage = "GetThreadContext failed for thread handle 0x" +
 362                              Integer.toHexString(handle);
 363         if (mustDuplicateHandle) {
 364           failMessage = failMessage + ", duplicated from thread handle " +
 365                         Integer.toHexString(threadHandleValue);
 366         }
 367         throw new DebuggerException(failMessage);
 368       }
 369       // Otherwise, parse all registers. See
 370       // src/os/win32/agent/README-commands.txt for the format.
 371       // Note the array we have to return has to match that specified by
 372       // X86ThreadContext.java.
 373       int numRegs = 22;
 374       long[] winRegs = new long[numRegs];
 375       for (int i = 0; i < numRegs; i++) {
 376         winRegs[i] = in.parseAddress();
 377       }
 378       if (mustDuplicateHandle) {
 379         // Clean up after ourselves
 380         printlnToOutput("closehandle 0x" + Integer.toHexString(handle));
 381       }
 382       // Now create the real return value
 383       long[] retval = new long[X86ThreadContext.NPRGREG];
 384       retval[X86ThreadContext.EAX] = winRegs[0];
 385       retval[X86ThreadContext.EBX] = winRegs[1];
 386       retval[X86ThreadContext.ECX] = winRegs[2];
 387       retval[X86ThreadContext.EDX] = winRegs[3];
 388       retval[X86ThreadContext.ESI] = winRegs[4];
 389       retval[X86ThreadContext.EDI] = winRegs[5];
 390       retval[X86ThreadContext.EBP] = winRegs[6];
 391       retval[X86ThreadContext.ESP] = winRegs[7];
 392       retval[X86ThreadContext.EIP] = winRegs[8];
 393       retval[X86ThreadContext.DS]  = winRegs[9];
 394       retval[X86ThreadContext.ES]  = winRegs[10];
 395       retval[X86ThreadContext.FS]  = winRegs[11];
 396       retval[X86ThreadContext.GS]  = winRegs[12];
 397       retval[X86ThreadContext.CS]  = winRegs[13];
 398       retval[X86ThreadContext.SS]  = winRegs[14];
 399       retval[X86ThreadContext.EFL] = winRegs[15];
 400       retval[X86ThreadContext.DR0] = winRegs[16];
 401       retval[X86ThreadContext.DR1] = winRegs[17];
 402       retval[X86ThreadContext.DR2] = winRegs[18];
 403       retval[X86ThreadContext.DR3] = winRegs[19];
 404       retval[X86ThreadContext.DR6] = winRegs[20];
 405       retval[X86ThreadContext.DR7] = winRegs[21];
 406       return retval;
 407     } catch (IOException e) {
 408       throw new DebuggerException(e);
 409     }
 410   }
 411 
 412   public synchronized void setThreadIntegerRegisterSet(int threadHandleValue,
 413                                                        boolean mustDuplicateHandle,
 414                                                        long[] context)
 415     throws DebuggerException {
 416     if (!suspended) {
 417       throw new DebuggerException("Process not suspended");
 418     }
 419 
 420     try {
 421       int handle = threadHandleValue;
 422       if (mustDuplicateHandle) {
 423         printlnToOutput("duphandle 0x" + Integer.toHexString(threadHandleValue));
 424         if (!in.parseBoolean()) {
 425           throw new DebuggerException("Error duplicating thread handle 0x" + threadHandleValue);
 426         }
 427         handle = (int) in.parseAddress(); // Must close to avoid leaks
 428       }
 429       // Change order of registers to match that of debug server
 430       long[] winRegs = new long[context.length];
 431       winRegs[0] = context[X86ThreadContext.EAX];
 432       winRegs[1] = context[X86ThreadContext.EBX];
 433       winRegs[2] = context[X86ThreadContext.ECX];
 434       winRegs[3] = context[X86ThreadContext.EDX];
 435       winRegs[4] = context[X86ThreadContext.ESI];
 436       winRegs[5] = context[X86ThreadContext.EDI];
 437       winRegs[6] = context[X86ThreadContext.EBP];
 438       winRegs[7] = context[X86ThreadContext.ESP];
 439       winRegs[8] = context[X86ThreadContext.EIP];
 440       winRegs[9] = context[X86ThreadContext.DS];
 441       winRegs[10] = context[X86ThreadContext.ES];
 442       winRegs[11] = context[X86ThreadContext.FS];
 443       winRegs[12] = context[X86ThreadContext.GS];
 444       winRegs[13] = context[X86ThreadContext.CS];
 445       winRegs[14] = context[X86ThreadContext.SS];
 446       winRegs[15] = context[X86ThreadContext.EFL];
 447       winRegs[16] = context[X86ThreadContext.DR0];
 448       winRegs[17] = context[X86ThreadContext.DR1];
 449       winRegs[18] = context[X86ThreadContext.DR2];
 450       winRegs[19] = context[X86ThreadContext.DR3];
 451       winRegs[20] = context[X86ThreadContext.DR6];
 452       winRegs[21] = context[X86ThreadContext.DR7];
 453       StringBuffer cmd = new StringBuffer();
 454       cmd.append("setcontext 0x");
 455       cmd.append(Integer.toHexString(threadHandleValue));
 456       for (int i = 0; i < context.length; i++) {
 457         cmd.append(" 0x");
 458         cmd.append(Long.toHexString(winRegs[i]));
 459       }
 460       printlnToOutput(cmd.toString());
 461       boolean res = in.parseBoolean();
 462       if (mustDuplicateHandle) {
 463         printlnToOutput("closehandle 0x" + Integer.toHexString(handle));
 464       }
 465       if (!res) {
 466         String failMessage = "SetThreadContext failed for thread handle 0x" +
 467           Integer.toHexString(handle);
 468         if (mustDuplicateHandle) {
 469           failMessage = failMessage + ", duplicated from thread handle " +
 470             Integer.toHexString(threadHandleValue);
 471         }
 472         throw new DebuggerException(failMessage);
 473       }
 474     } catch (IOException e) {
 475       throw new DebuggerException(e);
 476     }
 477   }
 478 
 479   /** Fetches the Win32 LDT_ENTRY for the given thread and selector.
 480       This data structure allows the conversion of a segment-relative
 481       address to a linear virtual address. For example, it allows the
 482       expression of operations like "mov eax, fs:[18h]", which fetches
 483       the thread information block, allowing access to the thread
 484       ID. */
 485   public synchronized Win32LDTEntry getThreadSelectorEntry(int threadHandleValue,
 486                                                            boolean mustDuplicateHandle,
 487                                                            int selector)
 488     throws DebuggerException {
 489     try {
 490       int handle = threadHandleValue;
 491       if (mustDuplicateHandle) {
 492         printlnToOutput("duphandle 0x" + Integer.toHexString(threadHandleValue));
 493         if (!in.parseBoolean()) {
 494           throw new DebuggerException("Error duplicating thread handle 0x" + threadHandleValue);
 495         }
 496         handle = (int) in.parseAddress(); // Must close to avoid leaks
 497       }
 498       printlnToOutput("selectorentry 0x" + Integer.toHexString(handle) + " " + selector);
 499       if (!in.parseBoolean()) {
 500         if (mustDuplicateHandle) {
 501           printlnToOutput("closehandle 0x" + Integer.toHexString(handle));
 502         }
 503         throw new DebuggerException("GetThreadContext failed for thread handle 0x" + handle +
 504                                     ", duplicated from thread handle " + threadHandleValue);
 505       }
 506       // Parse result. See
 507       // src/os/win32/agent/README-commands.txt for the format.
 508       short limitLow = (short) in.parseAddress();
 509       short baseLow  = (short) in.parseAddress();
 510       byte  baseMid  = (byte)  in.parseAddress();
 511       byte  flags1   = (byte)  in.parseAddress();
 512       byte  flags2   = (byte)  in.parseAddress();
 513       byte  baseHi   = (byte)  in.parseAddress();
 514       return new Win32LDTEntry(limitLow, baseLow, baseMid, flags1, flags2, baseHi);
 515     } catch (IOException e) {
 516       throw new DebuggerException(e);
 517     }
 518   }
 519 
 520   public synchronized List getThreadList() throws DebuggerException {
 521     if (!suspended) {
 522       throw new DebuggerException("Process not suspended");
 523     }
 524 
 525     try {
 526       printlnToOutput("threadlist");
 527       List ret = new ArrayList();
 528       int numThreads = in.parseInt();
 529       for (int i = 0; i < numThreads; i++) {
 530         int handle = (int) in.parseAddress();
 531         ret.add(new Win32Thread(this, handle));
 532       }
 533       return ret;
 534     } catch (IOException e) {
 535       throw new DebuggerException(e);
 536     }
 537   }
 538 
 539   public synchronized List getLoadObjectList() throws DebuggerException {
 540     if (!suspended) {
 541       throw new DebuggerException("Process not suspended");
 542     }
 543 
 544     try {
 545       if (loadObjects == null) {
 546         loadObjects  = new ArrayList();
 547         nameToDllMap = new HashMap();
 548         // Get list of library names and base addresses
 549         printlnToOutput("libinfo");
 550         int numInfo = in.parseInt();
 551 
 552         for (int i = 0; i < numInfo; i++) {
 553           // NOTE: because Win32 is case insensitive, we standardize on
 554           // lowercase file names.
 555           String  fullPathName = parseString().toLowerCase();
 556           Address base         = newAddress(in.parseAddress());
 557 
 558           File   file = new File(fullPathName);
 559           long   size = file.length();
 560           DLL    dll  = new DLL(this, fullPathName, size, base);
 561           String name = file.getName();
 562           nameToDllMap.put(name, dll);
 563           loadObjects.add(dll);
 564         }
 565       }
 566     } catch (IOException e) {
 567       throw new DebuggerException(e);
 568     }
 569 
 570     return loadObjects;
 571   }
 572 
 573   //----------------------------------------------------------------------
 574   // Process control access
 575   //
 576 
 577   public synchronized void writeBytesToProcess(long startAddress, long numBytes, byte[] data)
 578     throws UnmappedAddressException, DebuggerException {
 579     try {
 580       printToOutput("poke 0x" + Long.toHexString(startAddress) +
 581                     " |");
 582       writeIntToOutput((int) numBytes);
 583       writeToOutput(data, 0, (int) numBytes);
 584       printlnToOutput("");
 585       if (!in.parseBoolean()) {
 586         throw new UnmappedAddressException(startAddress);
 587       }
 588     } catch (IOException e) {
 589       throw new DebuggerException(e);
 590     }
 591   }
 592 
 593   public synchronized void suspend() throws DebuggerException {
 594     try {
 595       if (suspended) {
 596         throw new DebuggerException("Process already suspended");
 597       }
 598       printlnToOutput("suspend");
 599       suspended = true;
 600       enableCache();
 601       reresolveLoadObjects();
 602     } catch (IOException e) {
 603       throw new DebuggerException(e);
 604     }
 605   }
 606 
 607   public synchronized void resume() throws DebuggerException {
 608     try {
 609       if (!suspended) {
 610         throw new DebuggerException("Process not suspended");
 611       }
 612       disableCache();
 613       printlnToOutput("resume");
 614       suspended = false;
 615     } catch (IOException e) {
 616       throw new DebuggerException(e);
 617     }
 618   }
 619 
 620   public synchronized boolean isSuspended() throws DebuggerException {
 621     return suspended;
 622   }
 623 
 624   public synchronized void setBreakpoint(Address addr) throws DebuggerException {
 625     if (!suspended) {
 626       throw new DebuggerException("Process not suspended");
 627     }
 628 
 629     long addrVal = getAddressValue(addr);
 630     Long where = new Long(addrVal);
 631     if (breakpoints.get(where) != null) {
 632       throw new DebuggerException("Breakpoint already set at " + addr);
 633     }
 634     Byte what = new Byte(readBytes(addrVal, 1)[0]);
 635     // Now put 0xCC (int 3) at the target address, fail if can not
 636     writeBytesToProcess(addrVal, 1, new byte[] { (byte) 0xCC });
 637     // OK, the breakpoint is set.
 638     breakpoints.put(where, what);
 639   }
 640 
 641   public synchronized void clearBreakpoint(Address addr) throws DebuggerException {
 642     if (!suspended) {
 643       throw new DebuggerException("Process not suspended");
 644     }
 645 
 646     long addrVal = getAddressValue(addr);
 647     Long where = new Long(addrVal);
 648     Byte what = (Byte) breakpoints.get(where);
 649     if (what == null) {
 650       throw new DebuggerException("Breakpoint not set at " + addr);
 651     }
 652     // Put original data back at address
 653     writeBytesToProcess(addrVal, 1, new byte[] { what.byteValue() });
 654     // OK, breakpoint is cleared
 655     breakpoints.remove(where);
 656   }
 657 
 658   public synchronized boolean isBreakpointSet(Address addr) throws DebuggerException {
 659     return (breakpoints.get(new Long(getAddressValue(addr))) != null);
 660   }
 661 
 662   // Following constants taken from winnt.h
 663   private static final int EXCEPTION_DEBUG_EVENT  = 1;
 664   private static final int LOAD_DLL_DEBUG_EVENT   = 6;
 665   private static final int UNLOAD_DLL_DEBUG_EVENT = 7;
 666   private static final int EXCEPTION_ACCESS_VIOLATION = 0xC0000005;
 667   private static final int EXCEPTION_BREAKPOINT       = 0x80000003;
 668   private static final int EXCEPTION_SINGLE_STEP      = 0x80000004;
 669 
 670   public synchronized DebugEvent debugEventPoll() throws DebuggerException {
 671     if (curDebugEvent != null) {
 672       return curDebugEvent;
 673     }
 674 
 675     try {
 676       printlnToOutput("pollevent");
 677       if (!in.parseBoolean()) {
 678         return null;
 679       }
 680       // Otherwise, got a debug event. Need to figure out what kind it is.
 681       int handle = (int) in.parseAddress();
 682       ThreadProxy thread = new Win32Thread(this, handle);
 683       int code = in.parseInt();
 684       DebugEvent ev = null;
 685       switch (code) {
 686       case LOAD_DLL_DEBUG_EVENT: {
 687         Address addr = newAddress(in.parseAddress());
 688         ev = BasicDebugEvent.newLoadObjectLoadEvent(thread, addr);
 689         break;
 690       }
 691 
 692       case UNLOAD_DLL_DEBUG_EVENT: {
 693         Address addr = newAddress(in.parseAddress());
 694         ev = BasicDebugEvent.newLoadObjectUnloadEvent(thread, addr);
 695         break;
 696       }
 697 
 698       case EXCEPTION_DEBUG_EVENT: {
 699         int exceptionCode = in.parseInt();
 700         Address pc = newAddress(in.parseAddress());
 701         switch (exceptionCode) {
 702         case EXCEPTION_ACCESS_VIOLATION:
 703           boolean wasWrite = in.parseBoolean();
 704           Address addr = newAddress(in.parseAddress());
 705           ev = BasicDebugEvent.newAccessViolationEvent(thread, pc, wasWrite, addr);
 706           break;
 707 
 708         case EXCEPTION_BREAKPOINT:
 709           ev = BasicDebugEvent.newBreakpointEvent(thread, pc);
 710           break;
 711 
 712         case EXCEPTION_SINGLE_STEP:
 713           ev = BasicDebugEvent.newSingleStepEvent(thread, pc);
 714           break;
 715 
 716         default:
 717           ev = BasicDebugEvent.newUnknownEvent(thread,
 718                                                "Exception 0x" + Integer.toHexString(exceptionCode) +
 719                                                " at PC " + pc);
 720           break;
 721         }
 722         break;
 723       }
 724 
 725       default:
 726         ev = BasicDebugEvent.newUnknownEvent(thread,
 727                                              "Debug event " + code + " occurred");
 728         break;
 729       }
 730       if (Assert.ASSERTS_ENABLED) {
 731         Assert.that(ev != null, "Must have created event");
 732       }
 733       curDebugEvent = ev;
 734     } catch (IOException e) {
 735       throw new DebuggerException(e);
 736     }
 737 
 738     return curDebugEvent;
 739   }
 740 
 741   public synchronized void debugEventContinue() throws DebuggerException {
 742     if (curDebugEvent == null) {
 743       throw new DebuggerException("No debug event pending");
 744     }
 745 
 746     try {
 747       ///////////////////////////////////////////////////////////////////
 748       //                                                               //
 749       // FIXME: this **must** be modified to handle breakpoint events
 750       // properly. Must temporarily remove the breakpoint and enable
 751       // single-stepping mode (hiding those single-step events from
 752       // the user unless they have been requested; currently there is
 753       // no way to request single-step events; and it isn't clear how
 754       // to enable them or how the hardware and/or OS typically
 755       // supports them, i.e., are they on a per-process or per-thread
 756       // level?) until the process steps past the breakpoint, then put
 757       // the breakpoint back.
 758       //                                                               //
 759       ///////////////////////////////////////////////////////////////////
 760 
 761       DebugEvent.Type t = curDebugEvent.getType();
 762       boolean shouldPassOn = true;
 763       if (t == DebugEvent.Type.BREAKPOINT) {
 764         // FIXME: correct algorithm appears to be as follows:
 765         //
 766         // 1. Check to see whether we know about this breakpoint. If
 767         // not, it's requested by the user's program and we should
 768         // ignore it (not pass it on to the program).
 769         //
 770         // 2. Replace the original opcode.
 771         //
 772         // 3. Set single-stepping mode in the debug registers.
 773         //
 774         // 4. Back up the PC.
 775         //
 776         // 5. In debugEventPoll(), watch for a single-step event on
 777         // this thread. When we get it, put the breakpoint back. Only
 778         // deliver that single-step event if the user has requested
 779         // single-step events (FIXME: must figure out whether they are
 780         // per-thread or per-process, and also expose a way to turn
 781         // them on.)
 782 
 783         // To make breakpoints work for now, we will just back up the
 784         // PC, which we have to do in order to not disrupt the program
 785         // execution in case the user decides to disable the breakpoint.
 786 
 787         if (breakpoints.get(new Long(getAddressValue(curDebugEvent.getPC()))) != null) {
 788           System.err.println("Backing up PC due to breakpoint");
 789           X86ThreadContext ctx = (X86ThreadContext) curDebugEvent.getThread().getContext();
 790           ctx.setRegister(X86ThreadContext.EIP, ctx.getRegister(X86ThreadContext.EIP) - 1);
 791           curDebugEvent.getThread().setContext(ctx);
 792         } else {
 793           System.err.println("Skipping back up of PC since I didn't know about this breakpoint");
 794           System.err.println("Known breakpoints:");
 795           for (Iterator iter = breakpoints.keySet().iterator(); iter.hasNext(); ) {
 796             System.err.println("  0x" + Long.toHexString(((Long) iter.next()).longValue()));
 797           }
 798         }
 799         shouldPassOn = false;
 800       } else if (t == DebugEvent.Type.SINGLE_STEP) {
 801         shouldPassOn = false;
 802       }
 803       // Other kinds of debug events are either ignored if passed on
 804       // or probably should be passed on so the program exits
 805       // FIXME: generate process exiting events (should be easy)
 806 
 807       int val = (shouldPassOn ? 1 : 0);
 808       printlnToOutput("continueevent " + val);
 809       if (!in.parseBoolean()) {
 810         throw new DebuggerException("Unknown error while attempting to continue past debug event");
 811       }
 812       curDebugEvent = null;
 813     } catch (IOException e) {
 814       throw new DebuggerException(e);
 815     }
 816   }
 817 
 818   //--------------------------------------------------------------------------------
 819   // Address access
 820   //
 821 
 822   /** From the Debugger interface */
 823   public long getAddressValue(Address addr) {
 824     if (addr == null) return 0;
 825     return ((Win32Address) addr).getValue();
 826   }
 827 
 828   /** From the Win32Debugger interface */
 829   public Address newAddress(long value) {
 830     if (value == 0) return null;
 831     return new Win32Address(this, value);
 832   }
 833 
 834   //--------------------------------------------------------------------------------
 835   // Internals only below this point
 836   //
 837 
 838   private String parseString() throws IOException {
 839     int charSize = in.parseInt();
 840     int numChars = in.parseInt();
 841     in.skipByte();
 842     String str;
 843     if (charSize == 1) {
 844       str = in.readByteString(numChars);
 845     } else {
 846       str = in.readCharString(numChars);
 847     }
 848     return str;
 849   }
 850 
 851   /** Looks up an address in the remote process's address space.
 852       Returns 0 if symbol not found or upon error. Package private to
 853       allow Win32DebuggerRemoteIntfImpl access. NOTE that this returns
 854       a long instead of an Address because we do not want to serialize
 855       Addresses. */
 856   synchronized long lookupInProcess(String objectName, String symbol) {
 857     // NOTE: this assumes that process is suspended (which is probably
 858     // necessary assumption given that DLLs can be loaded/unloaded as
 859     // process runs). Should update documentation.
 860     if (nameToDllMap == null) {
 861       getLoadObjectList();
 862     }
 863     DLL dll = (DLL) nameToDllMap.get(objectName);
 864     // The DLL can be null because we use this to search through known
 865     // DLLs in HotSpotTypeDataBase (for example)
 866     if (dll != null) {
 867       Win32Address addr = (Win32Address) dll.lookupSymbol(symbol);
 868       if (addr != null) {
 869         return addr.getValue();
 870       }
 871     }
 872     return 0;
 873   }
 874 
 875   /** This reads bytes from the remote process. */
 876   public synchronized ReadResult readBytesFromProcess(long address, long numBytes)
 877     throws UnmappedAddressException, DebuggerException {
 878     try {
 879       String cmd = "peek " + utils.addressValueToString(address) + " " + numBytes;
 880       printlnToOutput(cmd);
 881       while (in.readByte() != 'B') {
 882       }
 883       byte res = in.readByte();
 884       if (res == 0) {
 885         System.err.println("Failing command: " + cmd);
 886         throw new DebuggerException("Read of remote process address space failed");
 887       }
 888       // NOTE: must read ALL of the data regardless of whether we need
 889       // to throw an UnmappedAddressException. Otherwise will corrupt
 890       // the input stream each time we have a failure. Not good. Do
 891       // not want to risk "flushing" the input stream in case a huge
 892       // read has a hangup in the middle and we leave data on the
 893       // stream.
 894       byte[] buf = new byte[(int) numBytes];
 895       boolean bailOut = false;
 896       long failureAddress = 0;
 897       while (numBytes > 0) {
 898         long len = in.readUnsignedInt();
 899         boolean isMapped = ((in.readByte() == 0) ? false : true);
 900         if (!isMapped) {
 901           if (!bailOut) {
 902             bailOut = true;
 903             failureAddress = address;
 904           }
 905         } else {
 906           // This won't work if we have unmapped regions, but if we do
 907           // then we're going to throw an exception anyway
 908 
 909           // NOTE: there is a factor of 20 speed difference between
 910           // these two ways of doing this read.
 911           in.readBytes(buf, 0, (int) len);
 912         }
 913 
 914         // Do NOT do this:
 915         //        for (int i = 0; i < (int) len; i++) {
 916         //          buf[i] = in.readByte();
 917         //        }
 918 
 919         numBytes -= len;
 920         address += len;
 921       }
 922       if (Assert.ASSERTS_ENABLED) {
 923         Assert.that(numBytes == 0, "Bug in debug server's implementation of peek");
 924       }
 925       if (bailOut) {
 926         return new ReadResult(failureAddress);
 927       }
 928       return new ReadResult(buf);
 929     }
 930     catch (IOException e) {
 931       throw new DebuggerException(e);
 932     }
 933   }
 934 
 935   /** Convenience routines */
 936   private void printlnToOutput(String s) throws IOException {
 937     out.println(s);
 938     if (out.checkError()) {
 939       throw new IOException("Error occurred while writing to debug server");
 940     }
 941   }
 942 
 943   private void printToOutput(String s) throws IOException {
 944     out.print(s);
 945     if (out.checkError()) {
 946       throw new IOException("Error occurred while writing to debug server");
 947     }
 948   }
 949 
 950   private void writeIntToOutput(int val) throws IOException {
 951     rawOut.writeInt(val);
 952     rawOut.flush();
 953   }
 954 
 955   private void writeToOutput(byte[] buf, int off, int len) throws IOException {
 956     rawOut.write(buf, off, len);
 957     rawOut.flush();
 958   }
 959 
 960   /** Connects to the debug server, setting up out and in streams. */
 961   private void connectToDebugServer() throws IOException {
 962     // Try for a short period of time to connect to debug server; time out
 963     // with failure if didn't succeed
 964     debuggerSocket = null;
 965     long endTime = System.currentTimeMillis() + SHORT_TIMEOUT;
 966 
 967     while ((debuggerSocket == null) && (System.currentTimeMillis() < endTime)) {
 968       try {
 969         // FIXME: this does not work if we are on a DHCP machine which
 970         // did not get an IP address this session. It appears to use
 971         // an old cached address and the connection does not actually
 972         // succeed. Must file a bug.
 973         // debuggerSocket = new Socket(InetAddress.getLocalHost(), PORT);
 974         debuggerSocket = new Socket(InetAddress.getByName("127.0.0.1"), PORT);
 975         debuggerSocket.setTcpNoDelay(true);
 976       }
 977       catch (IOException e) {
 978         // Swallow IO exceptions while attempting connection
 979         debuggerSocket = null;
 980         try {
 981           // Don't swamp the CPU
 982           Thread.sleep(750);
 983         }
 984         catch (InterruptedException ex) {
 985         }
 986       }
 987     }
 988 
 989     if (debuggerSocket == null) {
 990       // Failed to connect because of timeout
 991       throw new DebuggerException("Timed out while attempting to connect to debug server (please start SwDbgSrv.exe)");
 992     }
 993 
 994     out = new PrintWriter(new BufferedWriter(new OutputStreamWriter(debuggerSocket.getOutputStream(), "US-ASCII")), true);
 995     rawOut = new DataOutputStream(new BufferedOutputStream(debuggerSocket.getOutputStream()));
 996     in = new InputLexer(new BufferedInputStream(debuggerSocket.getInputStream()));
 997   }
 998 
 999   private DLL findDLLByName(String fullPathName) {
1000     for (Iterator iter = loadObjects.iterator(); iter.hasNext(); ) {
1001       DLL dll = (DLL) iter.next();
1002       if (dll.getName().equals(fullPathName)) {
1003         return dll;
1004       }
1005     }
1006     return null;
1007   }
1008 
1009   private void reresolveLoadObjects() throws DebuggerException {
1010     try {
1011       // It is too expensive to throw away the loadobject list every
1012       // time the process is suspended, largely because of debug
1013       // information re-parsing. When we suspend the target process we
1014       // instead fetch the list of loaded libraries in the target and
1015       // see whether any loadobject needs to be thrown away (because it
1016       // was unloaded) or invalidated (because it was unloaded and
1017       // reloaded at a different target address). Note that we don't
1018       // properly handle the case of a loaded DLL being unloaded,
1019       // recompiled, and reloaded. We could handle this by keeping a
1020       // time stamp.
1021 
1022       if (loadObjects == null) {
1023         return;
1024       }
1025 
1026       // Need to create new list since have to figure out which ones
1027       // were unloaded
1028       List newLoadObjects = new ArrayList();
1029 
1030     // Get list of library names and base addresses
1031       printlnToOutput("libinfo");
1032       int numInfo = in.parseInt();
1033 
1034       for (int i = 0; i < numInfo; i++) {
1035         // NOTE: because Win32 is case insensitive, we standardize on
1036         // lowercase file names.
1037         String  fullPathName = parseString().toLowerCase();
1038         Address base         = newAddress(in.parseAddress());
1039 
1040         // Look for full path name in DLL list
1041         DLL dll = findDLLByName(fullPathName);
1042         boolean mustLoad = true;
1043         if (dll != null) {
1044           loadObjects.remove(dll);
1045 
1046           // See whether base addresses match; otherwise, need to reload
1047           if (AddressOps.equal(base, dll.getBase())) {
1048             mustLoad = false;
1049           }
1050         }
1051 
1052         if (mustLoad) {
1053           // Create new DLL
1054           File   file = new File(fullPathName);
1055           long   size = file.length();
1056           String name = file.getName();
1057           dll  = new DLL(this, fullPathName, size, base);
1058           nameToDllMap.put(name, dll);
1059         }
1060         newLoadObjects.add(dll);
1061       }
1062 
1063       // All remaining entries in loadObjects have to be removed from
1064       // the nameToDllMap
1065       for (Iterator dllIter = loadObjects.iterator(); dllIter.hasNext(); ) {
1066         DLL dll = (DLL) dllIter.next();
1067         for (Iterator iter = nameToDllMap.keySet().iterator(); iter.hasNext(); ) {
1068           String name = (String) iter.next();
1069           if (nameToDllMap.get(name) == dll) {
1070             nameToDllMap.remove(name);
1071             break;
1072           }
1073         }
1074       }
1075 
1076       loadObjects = newLoadObjects;
1077     } catch (IOException e) {
1078       loadObjects = null;
1079       nameToDllMap = null;
1080       throw new DebuggerException(e);
1081     }
1082   }
1083 }