/*

 * Copyright 2000-2004 Sun Microsystems, Inc.  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.

 *

 * 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 Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,

 * CA 95054 USA or visit www.sun.com if you need additional information or

 * have any questions.

 *

 */

package sun.jvm.hotspot.debugger.dbx;

import java.io.*;

import java.net.*;

import java.util.*;

import sun.jvm.hotspot.debugger.*;

import sun.jvm.hotspot.debugger.dbx.sparc.*;

import sun.jvm.hotspot.debugger.dbx.x86.*;

import sun.jvm.hotspot.debugger.cdbg.CDebugger;

import sun.jvm.hotspot.utilities.*;

/** <P> An implementation of the JVMDebugger interface which sits on

    top of dbx and relies on the SA's dbx import module for

    communication with the debugger. </P>

    <P> <B>NOTE</B> that since we have the notion of fetching "Java

    primitive types" from the remote process (which might have

    different sizes than we expect) we have a bootstrapping

    problem. We need to know the sizes of these types before we can

    fetch them. The current implementation solves this problem by

    requiring that it be configured with these type sizes before they

    can be fetched. The readJ(Type) routines here will throw a

    RuntimeException if they are called before the debugger is

    configured with the Java primitive type sizes. </P>

*/

public class DbxDebuggerLocal extends DebuggerBase implements DbxDebugger {

  // These may be set by DbxDebuggerRemote

  protected boolean unalignedAccessesOkay;

  protected DbxThreadFactory threadFactory;

  private String dbxPathName;

  private String[] dbxSvcAgentDSOPathNames;

  private Process dbxProcess;

  private StreamMonitor dbxOutStreamMonitor;

  private StreamMonitor dbxErrStreamMonitor;

  private PrintWriter dbxOstr;

  private PrintWriter out;

  private InputLexer in;

  private Socket importModuleSocket;

  private static final int PORT = 21928;

  private static final int  LONG_TIMEOUT = 60000;

  private static final int  DBX_MODULE_NOT_FOUND      = 101;

  private static final int  DBX_MODULE_LOADED         = 102;

  //--------------------------------------------------------------------------------

  // Implementation of Debugger interface

  //

  /** <P> machDesc may be null if it couldn't be determined yet; i.e.,

      if we're on SPARC, we need to ask the remote process whether

      we're in 32- or 64-bit mode. </P>

      <P> useCache should be set to true if debugging is being done

      locally, and to false if the debugger is being created for the

      purpose of supporting remote debugging. </P> */

  public DbxDebuggerLocal(MachineDescription machDesc,

                          String dbxPathName,

                          String[] dbxSvcAgentDSOPathNames,

                          boolean useCache) {

    this.machDesc = machDesc;

    this.dbxPathName = dbxPathName;

    this.dbxSvcAgentDSOPathNames = dbxSvcAgentDSOPathNames;

    int cacheNumPages;

    int cachePageSize;

    if (PlatformInfo.getCPU().equals("sparc")) {

      cacheNumPages = parseCacheNumPagesProperty(2048);

      cachePageSize = 8192;

      threadFactory = new DbxSPARCThreadFactory(this);

    } else if (PlatformInfo.getCPU().equals("x86")) {

      cacheNumPages = 4096;

      cachePageSize = 4096;

      threadFactory = new DbxX86ThreadFactory(this);

      unalignedAccessesOkay = true;

    } else {

      throw new RuntimeException("Thread access for CPU architecture " + PlatformInfo.getCPU() + " not yet supported");

    }

    if (useCache) {

      // Cache portion of the remote process's address space.

      // Fetching data over the socket connection to dbx is relatively

      // slow. For now, this cache works best if it covers the entire

      // heap of the remote process. FIXME: at least should make this

      // tunable from the outside, i.e., via the UI. This is a 16 MB

      // cache divided on SPARC into 2048 8K pages and on x86 into

      // 4096 4K pages; the page size must be adjusted to be the OS's

      // page size. (FIXME: should pick this up from the debugger.)

      initCache(cachePageSize, cacheNumPages);

    }

  }

  /** Only called by DbxDebuggerRemote */

  protected DbxDebuggerLocal() {

  }

  /** FIXME: implement this with a Runtime.exec() of ps followed by

      parsing of its output */

  public boolean hasProcessList() throws DebuggerException {

    return false;

  }

  public List getProcessList() throws DebuggerException {

    throw new DebuggerException("Not yet supported");

  }

  /** From the Debugger interface via JVMDebugger */

  public synchronized void attach(int processID) throws DebuggerException {

    try {

      launchProcess();

      dbxErrStreamMonitor.addTrigger("dbx: no process", 1);

      dbxErrStreamMonitor.addTrigger("dbx: Cannot open", 1);

      dbxErrStreamMonitor.addTrigger("dbx: Cannot find", DBX_MODULE_NOT_FOUND);

      dbxOstr = new PrintWriter(dbxProcess.getOutputStream(), true);

      dbxOstr.println("debug - " + processID);

      dbxOstr.println("kprint -u2 \\(ready\\)");

      boolean seen = dbxErrStreamMonitor.waitFor("(ready)", LONG_TIMEOUT);

      if (!seen) {

        detach();

        throw new DebuggerException("Timed out while connecting to process " + processID);

      }

      List retVals = dbxErrStreamMonitor.getTriggersSeen();

      if (retVals.contains(new Integer(1))) {

        detach();

        throw new DebuggerException("No such process " + processID);

      }

      // Throws DebuggerException upon failure

      importDbxModule();

      dbxOstr.println("svc_agent_run");

      connectToImportModule();

      // Set "fail fast" mode on process memory reads

      printlnToOutput("peek_fail_fast 1");

    }

    catch (IOException e) {

      detach();

      throw new DebuggerException("Error while connecting to dbx process", e);

    }

  }

  /** From the Debugger interface via JVMDebugger */

  public synchronized void attach(String executableName, String coreFileName) throws DebuggerException {

    try {

      launchProcess();

      // Missing executable

      dbxErrStreamMonitor.addTrigger("dbx: Cannot open", 1);

      // Missing core file

      dbxErrStreamMonitor.addTrigger("dbx: can't read", 2);

      // Corrupt executable

      dbxErrStreamMonitor.addTrigger("dbx: File", 3);

      // Corrupt core file

      dbxErrStreamMonitor.addTrigger("dbx: Unable to read", 4);

      // Mismatched core and executable

      dbxErrStreamMonitor.addTrigger("dbx: core object name", 5);

      // Missing loadobject

      dbxErrStreamMonitor.addTrigger("dbx: can't stat", 6);

      // Successful load of svc module

      dbxOstr = new PrintWriter(dbxProcess.getOutputStream(), true);

      dbxOstr.println("debug " + executableName + " " + coreFileName);

      dbxOstr.println("kprint -u2 \\(ready\\)");

      boolean seen = dbxErrStreamMonitor.waitFor("(ready)", LONG_TIMEOUT);

      if (!seen) {

        detach();

        throw new DebuggerException("Timed out while attaching to core file");

      }

      List retVals = dbxErrStreamMonitor.getTriggersSeen();

      if (retVals.size() > 0) {

        detach();

        if (retVals.contains(new Integer(1))) {

          throw new DebuggerException("Can not find executable \"" + executableName + "\"");

        } else if (retVals.contains(new Integer(2))) {

          throw new DebuggerException("Can not find core file \"" + coreFileName + "\"");

        } else if (retVals.contains(new Integer(3))) {

          throw new DebuggerException("Corrupt executable \"" + executableName + "\"");

        } else if (retVals.contains(new Integer(4))) {

          throw new DebuggerException("Corrupt core file \"" + coreFileName + "\"");

        } else if (retVals.contains(new Integer(5))) {

          throw new DebuggerException("Mismatched core file/executable \"" + coreFileName + "\"/\"" + executableName + "\"");

        } else {

          throw new DebuggerException("Couldn't find all loaded libraries for executable \"" + executableName + "\"");

        }

      }

      // Throws DebuggerException upon failure

      importDbxModule();

      dbxOstr.println("svc_agent_run");

      connectToImportModule();

      // Set "fail fast" mode on process memory reads

      printlnToOutput("peek_fail_fast 1");

    }

    catch (IOException e) {

      detach();

      throw new DebuggerException("Error while connecting to dbx process", e);

    }

  }

  /** From the Debugger interface via JVMDebugger */

  public synchronized boolean detach() {

    try {

      if (dbxProcess == null) {

        return false;

      }

      if (out != null && dbxOstr != null) {

        printlnToOutput("exit");

        dbxOstr.println("exit");

        // Wait briefly for the process to exit (FIXME: should make this

        // nicer)

        try {

          Thread.sleep(500);

        }

        catch (InterruptedException e) {

        }

      }

      shutdown();

      return true;

    } catch (IOException e) {

      e.printStackTrace();

      return false;

    }

  }

  /** From the Debugger interface via JVMDebugger */

  public Address parseAddress(String addressString) throws NumberFormatException {

    long addr = utils.scanAddress(addressString);

    if (addr == 0) {

      return null;

    }

    return new DbxAddress(this, addr);

  }

  /** From the Debugger interface via JVMDebugger */

  public String getOS() {

    return PlatformInfo.getOS();

  }

  /** From the Debugger interface via JVMDebugger */

  public String getCPU() {

    return PlatformInfo.getCPU();

  }

  public boolean hasConsole() throws DebuggerException {

    return true;

  }

  public synchronized String consoleExecuteCommand(String cmd) throws DebuggerException {

    try {

      // A little tricky. We need to cause the dbx import module to

      // exit, then print our command on dbx's stdin along with a

      // command which will allow our StreamMonitors to

      // resynchronize. We need save the output from the StreamMonitors

      // along the way.

      printlnToOutput("exit");

      importModuleSocket.close();

      importModuleSocket = null;

      out = null;

      in = null;

      dbxOstr.println("kprint \\(ready\\)");

      dbxOstr.flush();

      dbxOutStreamMonitor.waitFor("(ready)", LONG_TIMEOUT);

      dbxOutStreamMonitor.startCapture();

      dbxErrStreamMonitor.startCapture();

      dbxOstr.println(cmd);

      dbxOstr.println("kprint \\(ready\\)");

      dbxOutStreamMonitor.waitFor("(ready)", LONG_TIMEOUT);

      String result = dbxOutStreamMonitor.stopCapture();

      String result2 = dbxErrStreamMonitor.stopCapture();

      result = result + result2;

      // Cut out the "(ready)" string

      StringBuffer outBuf = new StringBuffer(result.length());

      BufferedReader reader = new BufferedReader(new StringReader(result));

      // FIXME: bug in BufferedReader? readLine returns null when

      // ready() returns true.

      String line = null;

      do {

        line = reader.readLine();

        if ((line != null) && (!line.equals("(ready)"))) {

          outBuf.append(line);

          outBuf.append("\n");

        }

      } while (line != null);

      dbxOstr.println("svc_agent_run");

      dbxOstr.flush();

      connectToImportModule();

      return outBuf.toString();

    }

    catch (IOException e) {

      detach();

      throw new DebuggerException("Error while executing command on dbx console", e);

    }

  }

  public String getConsolePrompt() throws DebuggerException {

    return "(dbx) ";

  }

  public CDebugger getCDebugger() throws DebuggerException {

    return null;

  }

  /** From the SymbolLookup interface via Debugger and JVMDebugger */

  public synchronized Address lookup(String objectName, String symbol) {

    long addr = lookupInProcess(objectName, symbol);

    if (addr == 0) {

      return null;

    }

    return new DbxAddress(this, addr);

  }

  /** From the SymbolLookup interface via Debugger and JVMDebugger */

  public synchronized OopHandle lookupOop(String objectName, String symbol) {

    long addr = lookupInProcess(objectName, symbol);

    if (addr == 0) {

      return null;

    }

    return new DbxOopHandle(this, addr);

  }

  /** From the Debugger interface */

  public MachineDescription getMachineDescription() {

    return machDesc;

  }

  /** Internal routine supporting lazy setting of MachineDescription,

      since on SPARC we will need to query the remote process to ask

      it what its data model is (32- or 64-bit). NOTE that this is NOT

      present in the DbxDebugger interface because it should not be

      called across the wire (until we support attaching to multiple

      remote processes via RMI -- see the documentation for

      DbxDebuggerRemoteIntf.) */

  public void setMachineDescription(MachineDescription machDesc) {

    this.machDesc = machDesc;

    setBigEndian(machDesc.isBigEndian());

    utils = new DebuggerUtilities(machDesc.getAddressSize(), machDesc.isBigEndian());

  }

  /** Internal routine which queries the remote process about its data

      model -- i.e., size of addresses. Returns -1 upon error.

      Currently supported return values are 32 and 64. NOTE that this

      is NOT present in the DbxDebugger interface because it should

      not be called across the wire (until we support attaching to

      multiple remote processes via RMI -- see the documentation for

      DbxDebuggerRemoteIntf.) */

  public int getRemoteProcessAddressSize() {

    if (dbxProcess == null) {

      throw new RuntimeException("Not attached to remote process");

    }

    try {

      printlnToOutput("address_size");

      int i = in.parseInt();

      return i;

    }

    catch (IOException e) {

      return -1;

    }

  }

  //--------------------------------------------------------------------------------

  // Implementation of ThreadAccess interface

  //

  /** From the ThreadAccess interface via Debugger and JVMDebugger */

  public ThreadProxy getThreadForIdentifierAddress(Address addr) {

    return threadFactory.createThreadWrapper(addr);

  }

  public ThreadProxy getThreadForThreadId(long id) {

    return threadFactory.createThreadWrapper(id);

  }

  //----------------------------------------------------------------------

  // Overridden from DebuggerBase because we need to relax alignment

  // constraints on x86

  public long readJLong(long address)

    throws UnmappedAddressException, UnalignedAddressException {

    checkJavaConfigured();

    // FIXME: allow this to be configurable. Undesirable to add a

    // dependency on the runtime package here, though, since this

    // package should be strictly underneath it.

    if (unalignedAccessesOkay) {

      utils.checkAlignment(address, jintSize);

    } else {

      utils.checkAlignment(address, jlongSize);

    }

    byte[] data = readBytes(address, jlongSize);

    return utils.dataToJLong(data, jlongSize);

  }

  //--------------------------------------------------------------------------------

  // Internal routines (for implementation of DbxAddress).

  // These must not be called until the MachineDescription has been set up.

  //

  /** From the DbxDebugger interface */

  public String addressValueToString(long address) {

    return utils.addressValueToString(address);

  }

  /** Need to override this to relax alignment checks on Solaris/x86. */

  public long readCInteger(long address, long numBytes, boolean isUnsigned)

    throws UnmappedAddressException, UnalignedAddressException {

    checkConfigured();

    if (!unalignedAccessesOkay) {

      utils.checkAlignment(address, numBytes);

    } else {

      // Only slightly relaxed semantics -- this is a hack, but is

      // necessary on Solaris/x86 where it seems the compiler is

      // putting some global 64-bit data on 32-bit boundaries

      if (numBytes == 8) {

        utils.checkAlignment(address, 4);

      } else {

        utils.checkAlignment(address, numBytes);

      }

    }

    byte[] data = readBytes(address, numBytes);

    return utils.dataToCInteger(data, isUnsigned);

  }

  /** From the DbxDebugger interface */

  public DbxAddress readAddress(long address)

    throws UnmappedAddressException, UnalignedAddressException {

    long value = readAddressValue(address);

    return (value == 0 ? null : new DbxAddress(this, value));

  }

  /** From the DbxDebugger interface */

  public DbxOopHandle readOopHandle(long address)

    throws UnmappedAddressException, UnalignedAddressException, NotInHeapException {

    long value = readAddressValue(address);

    return (value == 0 ? null : new DbxOopHandle(this, value));

  }

  //--------------------------------------------------------------------------------

  // Thread context access. Can not be package private, but should

  // only be accessed by the architecture-specific subpackages.

  /** From the DbxDebugger interface. May have to redefine this later. */

  public synchronized long[] getThreadIntegerRegisterSet(int tid) {

    try {

      printlnToOutput("thr_gregs " + tid);

      int num = in.parseInt();

      long[] res = new long[num];

      for (int i = 0; i < num; i++) {

        res[i] = in.parseAddress();

      }

      return res;

    }

    catch (Exception e) {

      e.printStackTrace();

      return null;

    }

  }

  //--------------------------------------------------------------------------------

  // Address access. Can not be package private, but should only be

  // accessed by the architecture-specific subpackages.

  /** From the Debugger interface */

  public long getAddressValue(Address addr) {

    if (addr == null) return 0;

    return ((DbxAddress) addr).getValue();

  }

  /** From the DbxDebugger interface */

  public Address newAddress(long value) {

    if (value == 0) return null;

    return new DbxAddress(this, value);

  }

  //--------------------------------------------------------------------------------

  // Internals only below this point

  //

  private void launchProcess() throws IOException {

    dbxProcess = Runtime.getRuntime().exec(dbxPathName);

    //      dbxOutStreamMonitor = new StreamMonitor(dbxProcess.getInputStream());

    //      dbxErrStreamMonitor = new StreamMonitor(dbxProcess.getErrorStream());

    dbxOutStreamMonitor = new StreamMonitor(dbxProcess.getInputStream(), "dbx stdout", true);

    dbxErrStreamMonitor = new StreamMonitor(dbxProcess.getErrorStream(), "dbx stderr", true);