sun.jvm.hotspot.debugger.DebuggerException Java Examples

public WorkerThreadTask execute(WorkerThreadTask task) throws DebuggerException {
   synchronized (workerThread) {
      this.task = task;
      workerThread.notifyAll();
      while (this.task != null) {
         try {
            workerThread.wait();
         } catch (InterruptedException x) {}
      }
      if (lastException != null) {
         throw new DebuggerException(lastException);
      } else {
         return task;
      }
   }
}
 

public void run() {
   synchronized (workerThread) {
      for (;;) {
         if (task != null) {
            lastException = null;
            try {
               task.doit(debugger);
            } catch (DebuggerException exp) {
               lastException = exp;
            }
            task = null;
            workerThread.notifyAll();
         }

         try {
            workerThread.wait();
         } catch (InterruptedException x) {}
      }
   }
}
 

public WorkerThreadTask execute(WorkerThreadTask task) throws DebuggerException {
   synchronized (workerThread) {
      this.task = task;
      workerThread.notifyAll();
      while (this.task != null) {
         try {
            workerThread.wait();
         } catch (InterruptedException x) {}
      }
      if (lastException != null) {
         throw new DebuggerException(lastException);
      } else {
         return task;
      }
   }
}
 

public void run() {
   synchronized (workerThread) {
      for (;;) {
         if (task != null) {
            lastException = null;
            try {
               task.doit(debugger);
            } catch (DebuggerException exp) {
               lastException = exp;
            }
            task = null;
            workerThread.notifyAll();
         }

         try {
            workerThread.wait();
         } catch (InterruptedException x) {}
      }
   }
}
 

public synchronized long[] getThreadIntegerRegisterSet(long unique_thread_id)
                                        throws DebuggerException {
    requireAttach();
    if (isCore) {
        return getThreadIntegerRegisterSet0(unique_thread_id);
    } else {
        class GetThreadIntegerRegisterSetTask implements WorkerThreadTask {
            long unique_thread_id;
            long[] result;
            public void doit(BsdDebuggerLocal debugger) {
                result = debugger.getThreadIntegerRegisterSet0(unique_thread_id);
            }
        }

        GetThreadIntegerRegisterSetTask task = new GetThreadIntegerRegisterSetTask();
        task.unique_thread_id = unique_thread_id;
        workerThread.execute(task);
        return task.result;
    }
}
 

public WorkerThreadTask execute(WorkerThreadTask task) throws DebuggerException {
   synchronized (workerThread) {
      this.task = task;
      workerThread.notifyAll();
      while (this.task != null) {
         try {
            workerThread.wait();
         } catch (InterruptedException x) {}
      }
      if (lastException != null) {
         throw new DebuggerException(lastException);
      } else {
         return task;
      }
   }
}
 

public void run() {
   synchronized (workerThread) {
      for (;;) {
         if (task != null) {
            lastException = null;
            try {
               task.doit(debugger);
            } catch (DebuggerException exp) {
               lastException = exp;
            }
            task = null;
            workerThread.notifyAll();
         }

         try {
            workerThread.wait();
         } catch (InterruptedException x) {}
      }
   }
}
 

/** From the Debugger interface via JVMDebugger */
public synchronized void attach(int processID) throws DebuggerException {
    checkAttached();
    threadList = new ArrayList();
    loadObjectList = new ArrayList();
    class AttachTask implements WorkerThreadTask {
       int pid;
       public void doit(LinuxDebuggerLocal debugger) {
          debugger.attach0(pid);
          debugger.attached = true;
          debugger.isCore = false;
          findABIVersion();
       }
    }

    AttachTask task = new AttachTask();
    task.pid = processID;
    workerThread.execute(task);
}
 

public void run() {
   synchronized (workerThread) {
      for (;;) {
         if (task != null) {
            lastException = null;
            try {
               task.doit(debugger);
            } catch (DebuggerException exp) {
               lastException = exp;
            }
            task = null;
            workerThread.notifyAll();
         }

         try {
            workerThread.wait();
         } catch (InterruptedException x) {}
      }
   }
}
 

public void run() {
   synchronized (workerThread) {
      for (;;) {
         if (task != null) {
            lastException = null;
            try {
               task.doit(debugger);
            } catch (DebuggerException exp) {
               lastException = exp;
            }
            task = null;
            workerThread.notifyAll();
         }

         try {
            workerThread.wait();
         } catch (InterruptedException x) {}
      }
   }
}
 

public synchronized long[] getThreadIntegerRegisterSet(int lwp_id)
                                        throws DebuggerException {
    requireAttach();
    if (isCore) {
        return getThreadIntegerRegisterSet0(lwp_id);
    } else {
        class GetThreadIntegerRegisterSetTask implements WorkerThreadTask {
            int lwp_id;
            long[] result;
            public void doit(LinuxDebuggerLocal debugger) {
                result = debugger.getThreadIntegerRegisterSet0(lwp_id);
            }
        }

        GetThreadIntegerRegisterSetTask task = new GetThreadIntegerRegisterSetTask();
        task.lwp_id = lwp_id;
        workerThread.execute(task);
        return task.result;
    }
}
 

/** From the Debugger interface via JVMDebugger */
public synchronized void attach(int processID) throws DebuggerException {
    checkAttached();
    threadList = new ArrayList();
    loadObjectList = new ArrayList();
    class AttachTask implements WorkerThreadTask {
       int pid;
       public void doit(BsdDebuggerLocal debugger) {
          debugger.attach0(pid);
          debugger.attached = true;
          debugger.isCore = false;
          findABIVersion();
       }
    }

    AttachTask task = new AttachTask();
    task.pid = processID;
    workerThread.execute(task);
}
 

public static Remote lookup(String debugServerID) throws DebuggerException {
    // debugServerID follows the pattern [unique_id@]host[:port]
    // we have to transform this as //host[:port]/<serverNamePrefix>['_'<unique_id>]

    int index = debugServerID.indexOf('@');
    StringBuffer nameBuf = new StringBuffer("//");
    String uniqueID = null;
    if (index != -1) {
        nameBuf.append(debugServerID.substring(index + 1));
        uniqueID = debugServerID.substring(0, index);
    } else {
        nameBuf.append(debugServerID);
    }

    nameBuf.append('/');
    nameBuf.append(serverNamePrefix);
    if (uniqueID != null) {
        nameBuf.append('_');
        nameBuf.append(uniqueID);
    }

    try {
        return Naming.lookup(nameBuf.toString());
    } catch (Exception exp) {
        throw new DebuggerException(exp);
    }
}
 

private void findABIVersion() throws DebuggerException {
    if (lookupByName0("libjvm.so", "__vt_10JavaThread") != 0) {
        // old C++ ABI
        useGCC32ABI = false;
    } else {
        // new C++ ABI
        useGCC32ABI = true;
    }
}
 

private long handleGCC32ABI(long addr, String symbol) throws DebuggerException {
    if (useGCC32ABI && symbol.startsWith("_ZTV")) {
        return addr + (2 * machDesc.getAddressSize());
    } else {
        return addr;
    }
}
 

private long handleGCC32ABI(long addr, String symbol) throws DebuggerException {
    if (useGCC32ABI && symbol.startsWith("_ZTV")) {
        return addr + (2 * machDesc.getAddressSize());
    } else {
        return addr;
    }
}
 

private void checkAttached() throws DebuggerException {
    if (attached) {
        if (isCore) {
            throw new DebuggerException("attached to a core dump already");
        } else {
            throw new DebuggerException("attached to a process already");
        }
    }
}
 

/** This opens a core file on the local machine */
public synchronized void attach(String javaExecutableName, String coreFileName)
throws DebuggerException {
    if (debugger != null) {
        throw new DebuggerException("Already attached");
    }
    if ((javaExecutableName == null) || (coreFileName == null)) {
        throw new DebuggerException("Both the core file name and Java executable name must be specified");
    }
    this.javaExecutableName = javaExecutableName;
    this.coreFileName = coreFileName;
    startupMode = CORE_FILE_MODE;
    isServer = false;
    go();
}
 

private void setupDebuggerDarwin() {
    setupJVMLibNamesDarwin();

    if (cpu.equals("amd64") || cpu.equals("x86_64")) {
        machDesc = new MachineDescriptionAMD64();
    } else {
        throw new DebuggerException("Darwin only supported on x86_64. Current arch: " + cpu);
    }

    BsdDebuggerLocal dbg = new BsdDebuggerLocal(machDesc, !isServer);
    debugger = dbg;

    attachDebugger();
}
 

private void connectRemoteDebugger() throws DebuggerException {
    RemoteDebugger remote =
    (RemoteDebugger) RMIHelper.lookup(debugServerID);
    debugger = new RemoteDebuggerClient(remote);
    machDesc = ((RemoteDebuggerClient) debugger).getMachineDescription();
    os = debugger.getOS();
    setupJVMLibNames(os);
    cpu = debugger.getCPU();
}
 

private void checkAttached() throws DebuggerException {
    if (attached) {
        if (isCore) {
            throw new DebuggerException("attached to a core dump already");
        } else {
            throw new DebuggerException("attached to a process already");
        }
    }
}
 

/** This opens a core file on the local machine */
public synchronized void attach(String javaExecutableName, String coreFileName)
throws DebuggerException {
    if (debugger != null) {
        throw new DebuggerException("Already attached");
    }
    if ((javaExecutableName == null) || (coreFileName == null)) {
        throw new DebuggerException("Both the core file name and Java executable name must be specified");
    }
    this.javaExecutableName = javaExecutableName;
    this.coreFileName = coreFileName;
    startupMode = CORE_FILE_MODE;
    isServer = false;
    go();
}
 

public static Remote lookup(String debugServerID) throws DebuggerException {
    // debugServerID follows the pattern [unique_id@]host[:port]
    // we have to transform this as //host[:port]/<serverNamePrefix>['_'<unique_id>]

    int index = debugServerID.indexOf('@');
    StringBuffer nameBuf = new StringBuffer("//");
    String uniqueID = null;
    if (index != -1) {
        nameBuf.append(debugServerID.substring(index + 1));
        uniqueID = debugServerID.substring(0, index);
    } else {
        nameBuf.append(debugServerID);
    }

    nameBuf.append('/');
    nameBuf.append(serverNamePrefix);
    if (uniqueID != null) {
        nameBuf.append('_');
        nameBuf.append(uniqueID);
    }

    try {
        return Naming.lookup(nameBuf.toString());
    } catch (Exception exp) {
        throw new DebuggerException(exp);
    }
}
 

private boolean detachInternal() {
    if (debugger == null) {
        return false;
    }
    boolean retval = true;
    if (!isServer) {
        VM.shutdown();
    }
    // We must not call detach() if we are a client and are connected
    // to a remote debugger
    Debugger dbg = null;
    DebuggerException ex = null;
    if (isServer) {
        try {
            RMIHelper.unbind(serverID);
        }
        catch (DebuggerException de) {
            ex = de;
        }
        dbg = debugger;
    } else {
        if (startupMode != REMOTE_MODE) {
            dbg = debugger;
        }
    }
    if (dbg != null) {
        retval = dbg.detach();
    }

    debugger = null;
    machDesc = null;
    db = null;
    if (ex != null) {
        throw(ex);
    }
    return retval;
}
 

/** This should only be called by the user on the client machine,
  not the server machine */
public synchronized boolean detach() throws DebuggerException {
    if (isServer) {
        throw new DebuggerException("Should not call detach() for server configuration");
    }
    return detachInternal();
}
 

private void connectRemoteDebugger() throws DebuggerException {
    RemoteDebugger remote =
    (RemoteDebugger) RMIHelper.lookup(debugServerID);
    debugger = new RemoteDebuggerClient(remote);
    machDesc = ((RemoteDebuggerClient) debugger).getMachineDescription();
    os = debugger.getOS();
    setupJVMLibNames(os);
    cpu = debugger.getCPU();
}
 

private long handleGCC32ABI(long addr, String symbol) throws DebuggerException {
    if (useGCC32ABI && symbol.startsWith("_ZTV")) {
        return addr + (2 * machDesc.getAddressSize());
    } else {
        return addr;
    }
}
 

/** This should only be called by the user on the client machine,
  not the server machine */
public synchronized boolean detach() throws DebuggerException {
    if (isServer) {
        throw new DebuggerException("Should not call detach() for server configuration");
    }
    return detachInternal();
}
 

/** This attaches to a process running on the local machine. */
public synchronized void attach(int processID)
throws DebuggerException {
    if (debugger != null) {
        throw new DebuggerException("Already attached");
    }
    pid = processID;
    startupMode = PROCESS_MODE;
    isServer = false;
    go();
}
 

private long handleGCC32ABI(long addr, String symbol) throws DebuggerException {
    if (useGCC32ABI && symbol.startsWith("_ZTV")) {
        return addr + (2 * machDesc.getAddressSize());
    } else {
        return addr;
    }
}