Google Git
Sign in
eclipse / cdt / org.eclipse.cdt / 27b9002fbcae130209c845d6d702f590608c4e1c / . / dsf-gdb / org.eclipse.cdt.dsf.gdb / src / org / eclipse / cdt / dsf / gdb / service / GDBProcesses_7_0.java
blob: a53634e9013db065ba94bb96faa106ae376f8d28 [file] [log] [blame]
/*******************************************************************************
* Copyright (c) 2008, 2016 Ericsson and others.
*
* This program and the accompanying materials
* are made available under the terms of the Eclipse Public License 2.0
* which accompanies this distribution, and is available at
* https://www.eclipse.org/legal/epl-2.0/
*
* SPDX-License-Identifier: EPL-2.0
*
* Contributors:
* Ericsson - initial API and implementation
* Onur Akdemir (TUBITAK BILGEM-ITI) - Multi-process debugging (Bug 237306)
* John Dallaway - GDB 7.x MI thread details field ignored (Bug 325556)
* Marc Khouzam (Ericsson) - Make each thread an IDisassemblyDMContext (bug 352748)
* Andy Jin (QNX) - Not output thread osId as a string when it is null (Bug 397039)
* Marc Khouzam (Ericsson) - Move IBreakpointsTargetDMContext from MIContainerDMC
* to GDBContainerDMC to ease inheritance (Bug 389945)
* Marc Khouzam (Ericsson) - Support for exited processes in the debug view (bug 407340)
*******************************************************************************/
package org.eclipse.cdt.dsf.gdb.service;
import java.io.IOException;
import java.io.OutputStream;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Hashtable;
import java.util.Iterator;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Set;
import java.util.concurrent.TimeUnit;
import org.eclipse.cdt.core.CCorePlugin;
import org.eclipse.cdt.core.IProcessInfo;
import org.eclipse.cdt.core.IProcessList;
import org.eclipse.cdt.dsf.concurrent.DataRequestMonitor;
import org.eclipse.cdt.dsf.concurrent.DsfExecutor;
import org.eclipse.cdt.dsf.concurrent.DsfRunnable;
import org.eclipse.cdt.dsf.concurrent.ImmediateDataRequestMonitor;
import org.eclipse.cdt.dsf.concurrent.ImmediateExecutor;
import org.eclipse.cdt.dsf.concurrent.ImmediateRequestMonitor;
import org.eclipse.cdt.dsf.concurrent.Immutable;
import org.eclipse.cdt.dsf.concurrent.RequestMonitor;
import org.eclipse.cdt.dsf.concurrent.Sequence;
import org.eclipse.cdt.dsf.datamodel.AbstractDMContext;
import org.eclipse.cdt.dsf.datamodel.AbstractDMEvent;
import org.eclipse.cdt.dsf.datamodel.DMContexts;
import org.eclipse.cdt.dsf.datamodel.IDMContext;
import org.eclipse.cdt.dsf.debug.service.IBreakpoints.IBreakpointsTargetDMContext;
import org.eclipse.cdt.dsf.debug.service.ICachingService;
import org.eclipse.cdt.dsf.debug.service.IDisassembly.IDisassemblyDMContext;
import org.eclipse.cdt.dsf.debug.service.IMemory.IMemoryDMContext;
import org.eclipse.cdt.dsf.debug.service.IProcesses;
import org.eclipse.cdt.dsf.debug.service.IRunControl;
import org.eclipse.cdt.dsf.debug.service.IRunControl.IContainerDMContext;
import org.eclipse.cdt.dsf.debug.service.IRunControl.IContainerResumedDMEvent;
import org.eclipse.cdt.dsf.debug.service.IRunControl.IContainerSuspendedDMEvent;
import org.eclipse.cdt.dsf.debug.service.IRunControl.IExecutionDMContext;
import org.eclipse.cdt.dsf.debug.service.IRunControl.IExitedDMEvent;
import org.eclipse.cdt.dsf.debug.service.IRunControl.IResumedDMEvent;
import org.eclipse.cdt.dsf.debug.service.IRunControl.IStartedDMEvent;
import org.eclipse.cdt.dsf.debug.service.IRunControl.ISuspendedDMEvent;
import org.eclipse.cdt.dsf.debug.service.command.BufferedCommandControl;
import org.eclipse.cdt.dsf.debug.service.command.CommandCache;
import org.eclipse.cdt.dsf.debug.service.command.ICommandControlService.ICommandControlDMContext;
import org.eclipse.cdt.dsf.debug.service.command.ICommandControlService.ICommandControlShutdownDMEvent;
import org.eclipse.cdt.dsf.debug.service.command.IEventListener;
import org.eclipse.cdt.dsf.gdb.IGDBLaunchConfigurationConstants;
import org.eclipse.cdt.dsf.gdb.IGdbDebugConstants;
import org.eclipse.cdt.dsf.gdb.IGdbDebugPreferenceConstants;
import org.eclipse.cdt.dsf.gdb.internal.GdbPlugin;
import org.eclipse.cdt.dsf.gdb.launching.InferiorRuntimeProcess;
import org.eclipse.cdt.dsf.gdb.service.command.IGDBControl;
import org.eclipse.cdt.dsf.mi.service.IMICommandControl;
import org.eclipse.cdt.dsf.mi.service.IMIContainerDMContext;
import org.eclipse.cdt.dsf.mi.service.IMIExecutionDMContext;
import org.eclipse.cdt.dsf.mi.service.IMIProcessDMContext;
import org.eclipse.cdt.dsf.mi.service.IMIProcesses;
import org.eclipse.cdt.dsf.mi.service.IMIRunControl;
import org.eclipse.cdt.dsf.mi.service.IMIRunControl.MIRunMode;
import org.eclipse.cdt.dsf.mi.service.MIBreakpointsManager;
import org.eclipse.cdt.dsf.mi.service.MIProcesses;
import org.eclipse.cdt.dsf.mi.service.command.CommandFactory;
import org.eclipse.cdt.dsf.mi.service.command.MIInferiorProcess;
import org.eclipse.cdt.dsf.mi.service.command.events.MIThreadGroupCreatedEvent;
import org.eclipse.cdt.dsf.mi.service.command.events.MIThreadGroupExitedEvent;
import org.eclipse.cdt.dsf.mi.service.command.output.MIConst;
import org.eclipse.cdt.dsf.mi.service.command.output.MIInfo;
import org.eclipse.cdt.dsf.mi.service.command.output.MIListThreadGroupsInfo;
import org.eclipse.cdt.dsf.mi.service.command.output.MIListThreadGroupsInfo.IThreadGroupInfo;
import org.eclipse.cdt.dsf.mi.service.command.output.MINotifyAsyncOutput;
import org.eclipse.cdt.dsf.mi.service.command.output.MIOOBRecord;
import org.eclipse.cdt.dsf.mi.service.command.output.MIOutput;
import org.eclipse.cdt.dsf.mi.service.command.output.MIResult;
import org.eclipse.cdt.dsf.mi.service.command.output.MIThread;
import org.eclipse.cdt.dsf.mi.service.command.output.MIThreadInfoInfo;
import org.eclipse.cdt.dsf.mi.service.command.output.MIValue;
import org.eclipse.cdt.dsf.service.AbstractDsfService;
import org.eclipse.cdt.dsf.service.DsfServiceEventHandler;
import org.eclipse.cdt.dsf.service.DsfSession;
import org.eclipse.cdt.utils.pty.PTY;
import org.eclipse.cdt.utils.pty.PersistentPTY;
import org.eclipse.core.runtime.CoreException;
import org.eclipse.core.runtime.IStatus;
import org.eclipse.core.runtime.Platform;
import org.eclipse.core.runtime.Status;
import org.eclipse.debug.core.DebugPlugin;
import org.eclipse.debug.core.ILaunch;
import org.eclipse.debug.core.model.IProcess;
import org.osgi.framework.BundleContext;
/**
* This class implements the IProcesses interface for GDB 7.0
* which supports the new -list-thread-groups command.
*/
public class GDBProcesses_7_0 extends AbstractDsfService implements IGDBProcesses, ICachingService, IEventListener {
/**
* The maximum amount of exited processes we can show.
* Each one is shown in the debug view.
*/
private final static int MAX_NUMBER_EXITED_PROCESS = 5;
// Below is the context hierarchy that is implemented between the
// MIProcesses service and the MIRunControl service for the MI
// implementation of DSF:
//
// MIControlDMContext (ICommandControlDMContext)
// |
// MIProcessDMC (IProcess)
// / \
// / \
// MIContainerDMC MIThreadDMC (IThread)
// (IContainer) /
// \ /
// MIExecutionDMC
// (IExecution)
//
/**
* Context representing a thread in GDB/MI
*/
@Immutable
private static class MIExecutionDMC extends AbstractDMContext
implements IMIExecutionDMContext, IDisassemblyDMContext {
/**
* String ID that is used to identify the thread in the GDB/MI protocol.
*/
private final String fThreadId;
/**
* Constructor for the context. It should not be called directly by clients.
* Instead clients should call {@link IMIProcesses#createExecutionContext()}
* to create instances of this context based on the thread ID.
* <p/>
*
* @param sessionId Session that this context belongs to.
* @param containerDmc The container that this context belongs to.
* @param threadDmc The thread context parents of this context.
* @param threadId GDB/MI thread identifier.
*/
protected MIExecutionDMC(String sessionId, IContainerDMContext containerDmc, IThreadDMContext threadDmc,
String threadId) {
super(sessionId,
containerDmc == null && threadDmc == null ? new IDMContext[0]
: containerDmc == null ? new IDMContext[] { threadDmc }
: threadDmc == null ? new IDMContext[] { containerDmc }
: new IDMContext[] { containerDmc, threadDmc });
fThreadId = threadId;
}
/**
* Returns the GDB/MI thread identifier of this context.
* @return
*/
@Override
public String getThreadId() {
return fThreadId;
}
/* Unused; reintroduce if needed
public String getId(){
return fThreadId;
}
*/
@Override
public String toString() {
return baseToString() + ".thread[" + fThreadId + "]"; //$NON-NLS-1$//$NON-NLS-2$
}
@Override
public boolean equals(Object obj) {
return baseEquals(obj) && ((MIExecutionDMC) obj).fThreadId.equals(fThreadId);
}
@Override
public int hashCode() {
return baseHashCode() ^ fThreadId.hashCode();
}
}
/**
* Context representing a thread group of GDB/MI.
*/
@Immutable
static class MIContainerDMC extends AbstractDMContext implements IMIContainerDMContext, IDisassemblyDMContext {
/**
* String ID that is used to identify the thread group in the GDB/MI protocol.
*/
private final String fId;
/**
* Constructor for the context. It should not be called directly by clients.
* Instead clients should call {@link IMIProcesses#createContainerContext
* to create instances of this context based on the group name.
*
* @param sessionId Session that this context belongs to.
* @param processDmc The process context that is the parent of this context.
* @param groupId GDB/MI thread group identifier.
*/
public MIContainerDMC(String sessionId, IProcessDMContext processDmc, String groupId) {
super(sessionId, processDmc == null ? new IDMContext[0] : new IDMContext[] { processDmc });
fId = groupId;
}
/**
* Returns the GDB/MI thread group identifier of this context.
*/
@Override
public String getGroupId() {
return fId;
}
@Override
public String toString() {
return baseToString() + ".threadGroup[" + fId + "]"; //$NON-NLS-1$//$NON-NLS-2$
}
@Override
public boolean equals(Object obj) {
return baseEquals(obj)
&& (((MIContainerDMC) obj).fId == null ? fId == null : ((MIContainerDMC) obj).fId.equals(fId));
}
@Override
public int hashCode() {
return baseHashCode() ^ (fId == null ? 0 : fId.hashCode());
}
}
private static class GDBContainerDMC extends MIContainerDMC
implements IMemoryDMContext, IBreakpointsTargetDMContext {
public GDBContainerDMC(String sessionId, IProcessDMContext processDmc, String groupId) {
super(sessionId, processDmc, groupId);
}
}
/**
* Context representing a thread.
* @since 4.0
*/
@Immutable
protected static class MIThreadDMC extends AbstractDMContext implements IThreadDMContext {
/**
* ID used by GDB to refer to threads.
*/
private final String fId;
/**
* Constructor for the context. It should not be called directly by clients.
* Instead clients should call {@link IMIProcesses#createThreadContext}
* to create instances of this context based on the thread ID.
* <p/>
*
* @param sessionId Session that this context belongs to.
* @param processDmc The process that this thread belongs to.
* @param id thread identifier.
*/
public MIThreadDMC(String sessionId, IProcessDMContext processDmc, String id) {
super(sessionId, processDmc == null ? new IDMContext[0] : new IDMContext[] { processDmc });
fId = id;
}
/**
* Returns the thread identifier of this context.
* @return
*/
public String getId() {
return fId;
}
@Override
public String toString() {
return baseToString() + ".OSthread[" + fId + "]"; //$NON-NLS-1$//$NON-NLS-2$
}
@Override
public boolean equals(Object obj) {
return baseEquals(obj)
&& (((MIThreadDMC) obj).fId == null ? fId == null : ((MIThreadDMC) obj).fId.equals(fId));
}
@Override
public int hashCode() {
return baseHashCode() ^ (fId == null ? 0 : fId.hashCode());
}
}
@Immutable
private static class MIProcessDMC extends AbstractDMContext implements IMIProcessDMContext {
/**
* ID given by the OS.
*/
private final String fId;
/**
* Constructor for the context. It should not be called directly by clients.
* Instead clients should call {@link IMIProcesses#createProcessContext}
* to create instances of this context based on the PID.
* <p/>
*
* @param sessionId Session that this context belongs to.
* @param controlDmc The control context parent of this process.
* @param id process identifier.
*/
public MIProcessDMC(String sessionId, ICommandControlDMContext controlDmc, String id) {
super(sessionId, controlDmc == null ? new IDMContext[0] : new IDMContext[] { controlDmc });
fId = id;
}
@Override
public String getProcId() {
return fId;
}
@Override
public String toString() {
return baseToString() + ".proc[" + fId + "]"; //$NON-NLS-1$//$NON-NLS-2$
}
@Override
public boolean equals(Object obj) {
// We treat the UNKNOWN_PROCESS_ID as a wildcard. Any processId (except null) will be considered
// equal to the UNKNOWN_PROCESS_ID. This is important because before starting a process, we don't
// have a pid yet, but we still need to create a process context, and we must use UNKNOWN_PROCESS_ID.
// Bug 336890
if (!baseEquals(obj)) {
return false;
}
MIProcessDMC other = (MIProcessDMC) obj;
if (fId == null || other.fId == null) {
return fId == null && other.fId == null;
}
// Now that we know neither is null, check for UNKNOWN_PROCESS_ID wildcard
if (fId.equals(MIProcesses.UNKNOWN_PROCESS_ID) || other.fId.equals(MIProcesses.UNKNOWN_PROCESS_ID)) {
return true;
}
return fId.equals(other.fId);
}
@Override
public int hashCode() {
// We cannot use fId in the hashCode. This is because we support
// the wildCard MIProcesses.UNKNOWN_PROCESS_ID which is equal to any other fId.
// But we also need the hashCode of the wildCard to be the same
// as the one of all other fIds, which is why we need a constant hashCode
// See bug 336890
return baseHashCode();
}
}
/**
* A process context representing a process that has exited.
* Since an exited process no longer has a pid, we need another way
* of characterizing it. We use the groupId instead.
* Note that with GDB 7.0 and 7.1, the groupId is the pid, so that
* does not help us, but since we only handle single-process debugging
* for those versions of GDB, we don't need any id to know we are
* dealing with our single process.
* Starting with GDB 7.2, we handle multi-process, but then we
* can use the groupId as a persistent identifier of each process,
* even an exited one.
* @since 4.7
*/
@Immutable
protected static class MIExitedProcessDMC extends MIProcessDMC {
private final String fGroupId;
public MIExitedProcessDMC(String sessionId, ICommandControlDMContext controlDmc, String pid, String groupId) {
super(sessionId, controlDmc, pid);
fGroupId = groupId;
}
public String getGroupId() {
return fGroupId;
}
@Override
public String toString() {
return super.toString() + ".group[" + getGroupId() + "]"; //$NON-NLS-1$//$NON-NLS-2$
}
@Override
public boolean equals(Object obj) {
if (!super.equals(obj)) {
return false;
}
MIExitedProcessDMC other = (MIExitedProcessDMC) obj;
if (fGroupId == null || other.fGroupId == null) {
return fGroupId == null && other.fGroupId == null;
}
return fGroupId.equals(other.fGroupId);
}
@Override
public int hashCode() {
return super.hashCode() ^ (fGroupId == null ? 0 : fGroupId.hashCode());
}
}
/**
* The data of a corresponding thread or process.
*/
@Immutable
protected static class MIThreadDMData implements IThreadDMData {
final String fName;
final String fId;
public MIThreadDMData(String name, String id) {
fName = name;
fId = id;
}
@Override
public String getId() {
return fId;
}
@Override
public String getName() {
return fName;
}
@Override
public boolean isDebuggerAttached() {
return true;
}
}
/**
* The data corresponding to an exited process.
* @since 4.7
*/
@Immutable
protected static class MIExitedProcessDMData implements IGdbThreadExitedDMData {
final String fName;
final String fId;
final Integer fExitCode;
public MIExitedProcessDMData(String name, String id, Integer exitCode) {
fName = name;
fId = id;
fExitCode = exitCode;
}
@Override
public String getId() {
return fId;
}
@Override
public String getName() {
return fName;
}
@Override
public boolean isDebuggerAttached() {
return false;
}
@Override
public Integer getExitCode() {
return fExitCode;
}
}
/**
* This class provides an implementation of both a process context and process data.
* It is used to be able to return a list of processes including their data all at once.
* @since 4.0
*/
@Immutable
protected static class MIProcessDMCAndData extends MIProcessDMC implements IGdbThreadDMData2 {
final String fName;
// Note that cores are only available from GDB 7.1.
final String[] fCores;
final String fOwner;
final String fDescription;
public MIProcessDMCAndData(String sessionId, ICommandControlDMContext controlDmc, String id, String name,
String[] cores, String owner) {
this(sessionId, controlDmc, id, name, cores, owner, null);
}
/**
* @since 5.6
*/
public MIProcessDMCAndData(String sessionId, ICommandControlDMContext controlDmc, String id, String name,
String[] cores, String owner, String description) {
super(sessionId, controlDmc, id);
fName = name;
fCores = cores;
fOwner = owner;
fDescription = description;
}
@Override
public String getId() {
return getProcId();
}
@Override
public String getName() {
return fName;
}
/**
* @since 5.6
*/
@Override
public String getDescription() {
return fDescription;
}
@Override
public boolean isDebuggerAttached() {
return true;
}
@Override
public String[] getCores() {
return fCores;
}
@Override
public String getOwner() {
return fOwner;
}
@Override
public String toString() {
return baseToString() + ".proc[" + getId() + "," + getName() + "," + getOwner() + "]"; //$NON-NLS-1$//$NON-NLS-2$//$NON-NLS-3$//$NON-NLS-4$
}
@Override
public boolean equals(Object obj) {
return super.equals(obj)
&& (((MIProcessDMCAndData) obj).fName == null ? fName == null
: ((MIProcessDMCAndData) obj).fName.equals(fName))
&& (((MIProcessDMCAndData) obj).fOwner == null ? fOwner == null
: ((MIProcessDMCAndData) obj).fOwner.equals(fOwner));
}
@Override
public int hashCode() {
return super.hashCode() ^ (fName == null ? 0 : fName.hashCode()) ^ (fOwner == null ? 0 : fOwner.hashCode());
}
}
/**
* Event indicating that an container (debugged process) has started. This event
* implements the {@link IStartedMDEvent} from the IRunControl service.
*/
public static class ContainerStartedDMEvent extends AbstractDMEvent<IExecutionDMContext>
implements IStartedDMEvent {
public ContainerStartedDMEvent(IContainerDMContext context) {
super(context);
}
}
/**
* Event indicating that an container is no longer being debugged. This event
* implements the {@link IExitedMDEvent} from the IRunControl service.
*/
public static class ContainerExitedDMEvent extends AbstractDMEvent<IExecutionDMContext> implements IExitedDMEvent {
public ContainerExitedDMEvent(IContainerDMContext context) {
super(context);
}
}
/**
* @since 4.7
*/
protected static class ProcessRemovedDMEvent extends AbstractDMEvent<IThreadDMContext>
implements IThreadRemovedDMEvent {
public ProcessRemovedDMEvent(IProcessDMContext context) {
super(context);
}
}
/**
* A map of thread id to thread group id. We use this to find out to which threadGroup a thread belongs.
*/
private Map<String, String> fThreadToGroupMap = new HashMap<>();
/**
* A map of thread group id to process id. We use this to find out to which pid a group refers.
*/
private Map<String, String> fGroupToPidMap = new HashMap<>();
private IGDBControl fCommandControl;
private IGDBBackend fBackend;
private CommandFactory fCommandFactory;
// A cache for commands about the threadGroups
private CommandCache fContainerCommandCache;
//A cache for commands about the threads
private CommandCache fThreadCommandCache;
// A temporary cache to avoid using -list-thread-groups --available more than once at the same time.
// We cannot cache this command because it lists all available processes, which can
// change at any time. However, it is inefficient to send more than one of this command at
// the same time. This cache will help us avoid that. The idea is that we cache the command,
// but as soon as it returns, we clear the cache. So the cache will only trigger for those
// overlapping situations. Using this cache also allows to handle the all-stop case
// when the target can be unavailable and instead of hanging, the cache will return an error.
private CommandCache fListThreadGroupsAvailableCache;
// A map of process id to process names. A name is fetched whenever we start
// debugging a process, and removed when we stop.
// This allows us to make sure that if a pid is re-used, we will not use an
// old name for it. Bug 275497
// This map also serves as a list of processes we are currently debugging.
// This is important because we cannot always ask GDB for the list, since it may
// be running at the time. Bug 303503
private Map<String, String> fDebuggedProcessesAndNames = new HashMap<>();
/**
* A map that keeps track of the PTY associated with an inferior (groupId)
*/
private Map<String, PTY> fGroupIdToPTYMap = new HashMap<>();
/**
* A list of groupIds that have exited.
*/
private List<String> fExitedGroupId = new ArrayList<>();
/**
* Information about an exited process
* @since 4.7
*/
protected class ExitedProcInfo {
private String pid;
private String name;
private Integer exitCode;
public ExitedProcInfo(String aPid, String aName) {
pid = aPid;
name = aName;
}
protected String getPid() {
return pid;
}
protected String getName() {
return name;
}
protected Integer getExitCode() {
return exitCode;
}
protected void setExitCode(Integer code) {
exitCode = code;
}
}
/**
* A LRU (least-recently-used) map that limits the amount of exited process list.
* Once the limit is reached, oldest exited processes are automatically removed
* when new ones are inserted. This avoids the risk of growing the list
* of exited processes too much and showing too many in the debug view.
*/
private class LRUExitedProcessMap extends LinkedHashMap<String, ExitedProcInfo> {
public static final long serialVersionUID = 0;
@Override
protected boolean removeEldestEntry(Entry<String, ExitedProcInfo> eldest) {
return size() > MAX_NUMBER_EXITED_PROCESS;
}
}
/**
* Map of groupId to ExitedProcInfo.
* This map contains the information of each process that has exited.
* Note that we must maintain this information ourselves since GDB
* sometimes prunes its list of inferiors, which implies we cannot
* count on GDB to keep track of exited processes.
*/
private Map<String, ExitedProcInfo> fProcExitedMap = new LRUExitedProcessMap();
/**
* Set of groupId of processes that we detached from.
* The content is very short-lived as it is only kept until
* we receive the =thread-group-exited event from GDB
* and need to know if the process in question was detached from.
* Using this set, we can know if we should store the process
* in the fExitedProcesses map or not.
*/
private Set<String> fProcDetachedSet = new HashSet<>();
private static final String FAKE_THREAD_ID = "0"; //$NON-NLS-1$
/**
* Keeps track of how many processes we are currently connected to
*/
private int fNumConnected;
/**
* Keeps track if we are dealing with the very first process of GDB.
*/
private boolean fInitialProcess = true;
public GDBProcesses_7_0(DsfSession session) {
super(session);
}
/**
* This method initializes this service.
*
* @param requestMonitor
* The request monitor indicating the operation is finished
*/
@Override
public void initialize(final RequestMonitor requestMonitor) {
super.initialize(new ImmediateRequestMonitor(requestMonitor) {
@Override
protected void handleSuccess() {
doInitialize(requestMonitor);
}
});
}
/**
* This method initializes this service after our superclass's initialize()
* method succeeds.
*
* @param requestMonitor
* The call-back object to notify when this service's
* initialization is done.
*/
private void doInitialize(RequestMonitor requestMonitor) {
fCommandControl = getServicesTracker().getService(IGDBControl.class);
fBackend = getServicesTracker().getService(IGDBBackend.class);
BufferedCommandControl bufferedCommandControl = new BufferedCommandControl(fCommandControl, getExecutor(), 2);
fCommandFactory = getServicesTracker().getService(IMICommandControl.class).getCommandFactory();
// These caches store the result of a command when received; also, these caches
// are manipulated when receiving events. Currently, events are received after
// three scheduling of the executor, while command results after only one. This
// can cause problems because command results might be processed before an event
// that actually arrived before the command result.
// To solve this, we use a bufferedCommandControl that will delay the command
// result by two scheduling of the executor.
// See bug 280461
fContainerCommandCache = new CommandCache(getSession(), bufferedCommandControl);
fContainerCommandCache.setContextAvailable(fCommandControl.getContext(), true);
fThreadCommandCache = new CommandCache(getSession(), bufferedCommandControl);
fThreadCommandCache.setContextAvailable(fCommandControl.getContext(), true);
// No need to use the bufferedCommandControl for the listThreadGroups cache
// because it is not being affected by events.
fListThreadGroupsAvailableCache = new CommandCache(getSession(), fCommandControl);
fListThreadGroupsAvailableCache.setContextAvailable(fCommandControl.getContext(), true);
getSession().addServiceEventListener(this, null);
fCommandControl.addEventListener(this);
// Register this service.
register(new String[] { IProcesses.class.getName(), IMIProcesses.class.getName(), IGDBProcesses.class.getName(),
GDBProcesses_7_0.class.getName() }, new Hashtable<String, String>());
requestMonitor.done();
}
/**
* This method shuts down this service. It unregisters the service, stops
* receiving service events, and calls the superclass shutdown() method to
* finish the shutdown process.
*
* @return void
*/
@Override
public void shutdown(RequestMonitor requestMonitor) {
unregister();
getSession().removeServiceEventListener(this);
fCommandControl.removeEventListener(this);
super.shutdown(requestMonitor);
}
/**
* @return The bundle context of the plug-in to which this service belongs.
*/
@Override
protected BundleContext getBundleContext() {
return GdbPlugin.getBundleContext();
}
/** @since 4.0 */
protected Map<String, String> getThreadToGroupMap() {
return fThreadToGroupMap;
}
/** @since 4.0 */
protected Map<String, String> getGroupToPidMap() {
return fGroupToPidMap;
}
/** @since 4.0 */
protected int getNumConnected() {
return fNumConnected;
}
/** @since 4.0 */
protected void setNumConnected(int num) {
fNumConnected = num;
}
/** @since 4.0 */
protected boolean isInitialProcess() {
return fInitialProcess;
}
/** @since 4.0 */
protected void setIsInitialProcess(boolean isInitial) {
fInitialProcess = isInitial;
}
/**@since 4.7 */
protected Map<String, ExitedProcInfo> getExitedProcesses() {
return fProcExitedMap;
}
/** @since 4.7 */
protected Set<String> getDetachedProcesses() {
return fProcDetachedSet;
}
/**
* Returns the groupId that is associated with the provided pId
* @since 4.0
*/
protected String getGroupFromPid(String pid) {
if (pid == null)
return null;
for (Map.Entry<String, String> entry : getGroupToPidMap().entrySet()) {
if (pid.equals(entry.getValue())) {
return entry.getKey();
}
}
return null;
}
@Override
public IThreadDMContext createThreadContext(IProcessDMContext processDmc, String threadId) {
return new MIThreadDMC(getSession().getId(), processDmc, threadId);
}
@Override
public IProcessDMContext createProcessContext(ICommandControlDMContext controlDmc, String pid) {
return new MIProcessDMC(getSession().getId(), controlDmc, pid);
}
/**
* Create a special context describing a process that has exited.
* @param controlDmc Its parent context.
* @param groupId The GDB groupId to which this process refers to. Since an exited process no longer
* has a pid, we use this id to characterize it uniquely.
* Note that with GDB 7.0 and 7.1, the groupId is the pid, so that
* does not help us, but since we only handle single-process debugging
* for those versions of GDB, we don't need any id to know we are
* dealing with our single process.
* Starting with GDB 7.2, we handle multi-process, but then we
* can use the groupId as a persistent identifier of each process,
* even an exited one.
*/
private IProcessDMContext createExitedProcessContext(ICommandControlDMContext controlDmc, String pid,
String groupId) {
return new MIExitedProcessDMC(getSession().getId(), controlDmc, pid, groupId);
}
@Override
public IMIExecutionDMContext createExecutionContext(IContainerDMContext containerDmc, IThreadDMContext threadDmc,
String threadId) {
return new MIExecutionDMC(getSession().getId(), containerDmc, threadDmc, threadId);
}
@Override
public IMIContainerDMContext createContainerContext(IProcessDMContext processDmc, String groupId) {
return new GDBContainerDMC(getSession().getId(), processDmc, groupId);
}
@Override
public IMIContainerDMContext createContainerContextFromThreadId(ICommandControlDMContext controlDmc,
String threadId) {
String groupId = getThreadToGroupMap().get(threadId);
if (groupId == null) {
// this can happen if the threadId was 'all'
// In such a case, we choose the first process we find
// This works when we run a single process
// but will break for multi-process!!!
if (getThreadToGroupMap().isEmpty()) {
groupId = MIProcesses.UNIQUE_GROUP_ID;
} else {
Collection<String> values = getThreadToGroupMap().values();
for (String value : values) {
groupId = value;
break;
}
}
}
return createContainerContextFromGroupId(controlDmc, groupId);
}
/** @since 4.0 */
@Override
public IMIContainerDMContext createContainerContextFromGroupId(ICommandControlDMContext controlDmc,
String groupId) {
if (groupId == null || groupId.length() == 0) {
// This happens when we are doing non-attach, so for GDB < 7.2, we know that in that case
// we are single process, so lets see if we have the group in our map.
assert getGroupToPidMap().size() <= 1 : "More than one process in our map"; //$NON-NLS-1$
if (getGroupToPidMap().size() == 1) {
for (String key : getGroupToPidMap().keySet()) {
groupId = key;
break;
}
}
}
String pid = getGroupToPidMap().get(groupId);
if (pid == null) {
// For GDB 7.0 and 7.1, the groupId is the pid, so we can use it directly
pid = groupId;
}
IProcessDMContext processDmc = createProcessContext(controlDmc, pid);
return createContainerContext(processDmc, groupId);
}
@Override
public IMIExecutionDMContext[] getExecutionContexts(IMIContainerDMContext containerDmc) {
if (isExitedProcess(containerDmc)) {
// No threads for an exited process
return new IMIExecutionDMContext[0];
}
String groupId = containerDmc.getGroupId();
List<IMIExecutionDMContext> execDmcList = new ArrayList<>();
Iterator<Map.Entry<String, String>> iterator = getThreadToGroupMap().entrySet().iterator();
while (iterator.hasNext()) {
Map.Entry<String, String> entry = iterator.next();
if (entry.getValue().equals(groupId)) {
String threadId = entry.getKey();
IProcessDMContext procDmc = DMContexts.getAncestorOfType(containerDmc, IProcessDMContext.class);
IMIExecutionDMContext execDmc = createExecutionContext(containerDmc,
createThreadContext(procDmc, threadId), threadId);
execDmcList.add(execDmc);
}
}
return execDmcList.toArray(new IMIExecutionDMContext[0]);
}
@Override
public void getExecutionData(IThreadDMContext dmc, final DataRequestMonitor<IThreadDMData> rm) {
if (dmc instanceof MIExitedProcessDMC) {
ExitedProcInfo info = getExitedProcesses().get(((MIExitedProcessDMC) dmc).getGroupId());
if (info != null) {
rm.done(new MIExitedProcessDMData(info.getName(), info.getPid(), info.getExitCode()));
} else {
// This can happen for example, when restarting an exited process,
// where we've deleted the process from our table, but it has
// yet to be cleaned up from the view
rm.done(new Status(IStatus.ERROR, GdbPlugin.PLUGIN_ID, INVALID_STATE,
"Unavailable info about exited process", null)); //$NON-NLS-1$
}
return;
}
if (dmc instanceof IMIProcessDMContext) {
String id = ((IMIProcessDMContext) dmc).getProcId();
String name = null;
if (fBackend.getSessionType() == SessionType.CORE || "42000".equals(id)) { //$NON-NLS-1$
// For the Core session, the process is no longer running.
// Therefore, we cannot get its name with the -list-thread-groups command.
// As for id 42000, it is a special id used by GDB to indicate the real proc
// id is not known. This will happen in a Remote session, when we use
// -target-select remote instead of -target-select extended-remote.
//
// So, we take the name from the binary we are using.
name = fBackend.getProgramPath().lastSegment();
// Also, the pid we get from GDB is 1 or 42000, which is not correct.
// I haven't found a good way to get the pid yet, so let's not show it.
id = null;
} else {
if (fDebuggedProcessesAndNames.containsKey(id)) {
name = fDebuggedProcessesAndNames.get(id);
assert name != null;
if (name == null) {
// Should not happen, but just in case...use the
// binary file name (absolute path)
name = fBackend.getProgramPath().toOSString();
fDebuggedProcessesAndNames.put(id, name);
} else if (name.isEmpty()) {
// We know of the process but haven't fetched its name yet.
// Let's fetch it now.
// GDB is debugging a new process. Let's fetch its
// name and remember it. In order to get the name,
// we have to request all running processes, not
// just the ones being debugged. We got a lot more
// information when we request all processes.
final String finalPId = id;
fListThreadGroupsAvailableCache.execute(
fCommandFactory.createMIListThreadGroups(fCommandControl.getContext(), true),
new DataRequestMonitor<MIListThreadGroupsInfo>(getExecutor(), null) {
@Override
protected void handleCompleted() {
// We cannot actually cache this command since the process
// list may change. But this cache allows to avoid overlapping
// sending of this command and proper handling if the target is
// unavailable.
fListThreadGroupsAvailableCache.reset();
// Note that the output of the "-list-thread-groups --available" command
// still shows the pid as a groupId, even for GDB 7.2.
String name = null;
if (isSuccess()) {
for (IThreadGroupInfo groupInfo : getData().getGroupList()) {
if (groupInfo.getPid().equals(finalPId)) {
name = groupInfo.getName();
fDebuggedProcessesAndNames.put(finalPId, name);
break;
}
}
} else {
// Looks like this gdb doesn't truly support
// "-list-thread-groups --available". Get the
// process list natively if we're debugging locally
if (fBackend.getSessionType() == SessionType.LOCAL) {
try {
IProcessList list = CCorePlugin.getDefault().getProcessList();
if (list != null) {
int pId_int = Integer.parseInt(finalPId);
for (IProcessInfo procInfo : list.getProcessList()) {
if (procInfo.getPid() == pId_int) {
name = procInfo.getName();
fDebuggedProcessesAndNames.put(finalPId, name);
break;
}
}
}
} catch (Exception e) {
rm.setStatus(new Status(IStatus.ERROR, GdbPlugin.PLUGIN_ID,
REQUEST_FAILED, "Could not get process name", e)); //$NON-NLS-1$
}
}
}
if (name == null) {
// No way to get the name right now, so use the binary file name (absolute path)
name = fBackend.getProgramPath().toOSString();
fDebuggedProcessesAndNames.put(finalPId, name);
}
rm.done(new MIThreadDMData(name, finalPId));
}
});
return;
}
} else {
// We don't have the name in our map. This could happen
// if a process has terminated but the
// debug session is not terminated because the preference
// to keep GDB running has been selected or because there
// are other processes part of that session.
name = "Unknown name"; //$NON-NLS-1$
}
}
rm.setData(new MIThreadDMData(name, id));
rm.done();
} else if (dmc instanceof MIThreadDMC) {
final MIThreadDMC threadDmc = (MIThreadDMC) dmc;
ICommandControlDMContext controlDmc = DMContexts.getAncestorOfType(dmc, ICommandControlDMContext.class);
fThreadCommandCache.execute(fCommandFactory.createMIThreadInfo(controlDmc, threadDmc.getId()),
new DataRequestMonitor<MIThreadInfoInfo>(getExecutor(), rm) {
@Override
protected void handleSuccess() {
IThreadDMData threadData = null;
if (getData().getThreadList().length != 0) {
MIThread thread = getData().getThreadList()[0];
if (thread.getThreadId().equals(threadDmc.getId())) {
String id = ""; //$NON-NLS-1$
if (thread.getOsId() != null) {
id = thread.getOsId();
}
// append thread details (if any) to the thread ID
// as for GDB 6.x with CLIInfoThreadsInfo#getOsId()
final String details = thread.getDetails();
if (details != null && !details.isEmpty()) {
if (!id.isEmpty())
id += " "; //$NON-NLS-1$
id += "(" + details + ")"; //$NON-NLS-1$ //$NON-NLS-2$
}
// We must indicate and empty id by using null
if (id.isEmpty())
id = null;
threadData = new MIThreadDMData("", id); //$NON-NLS-1$
}
}
if (threadData != null) {
rm.setData(threadData);
} else {
rm.setStatus(new Status(IStatus.ERROR, GdbPlugin.PLUGIN_ID, INVALID_HANDLE,
"Could not get thread info", null)); //$NON-NLS-1$
}
rm.done();
}
});
} else {
rm.setStatus(new Status(IStatus.ERROR, GdbPlugin.PLUGIN_ID, INVALID_HANDLE, "Invalid DMC type", null)); //$NON-NLS-1$
rm.done();
}
}
@Override
public void getDebuggingContext(IThreadDMContext dmc, DataRequestMonitor<IDMContext> rm) {
if (dmc instanceof MIExitedProcessDMC) {
MIExitedProcessDMC exitedProc = (MIExitedProcessDMC) dmc;
IMIContainerDMContext containerDmc = createContainerContext(exitedProc, exitedProc.getGroupId());
rm.setData(containerDmc);
} else if (dmc instanceof MIProcessDMC) {
MIProcessDMC procDmc = (MIProcessDMC) dmc;
IMIContainerDMContext containerDmc = createContainerContext(procDmc, getGroupFromPid(procDmc.getProcId()));
rm.setData(containerDmc);
} else if (dmc instanceof MIThreadDMC) {
MIThreadDMC threadDmc = (MIThreadDMC) dmc;
IMIProcessDMContext procDmc = DMContexts.getAncestorOfType(dmc, IMIProcessDMContext.class);
IMIContainerDMContext containerDmc = createContainerContext(procDmc, getGroupFromPid(procDmc.getProcId()));
rm.setData(createExecutionContext(containerDmc, threadDmc, threadDmc.getId()));
} else {
rm.setStatus(
new Status(IStatus.ERROR, GdbPlugin.PLUGIN_ID, INTERNAL_ERROR, "Invalid thread context.", null)); //$NON-NLS-1$
}
rm.done();
}
/** @since 4.0 */
protected boolean doIsDebuggerAttachSupported() {
return fBackend.getIsAttachSession() && fNumConnected == 0;
}
@Override
public void isDebuggerAttachSupported(IDMContext dmc, DataRequestMonitor<Boolean> rm) {
rm.setData(doIsDebuggerAttachSupported());
rm.done();
}
@Override
public void attachDebuggerToProcess(IProcessDMContext procCtx, DataRequestMonitor<IDMContext> rm) {
attachDebuggerToProcess(procCtx, null, rm);
}
/**
* @since 4.0
*/
@Override
public void attachDebuggerToProcess(final IProcessDMContext procCtx, final String binaryPath,
final DataRequestMonitor<IDMContext> dataRm) {
if (procCtx instanceof IMIProcessDMContext) {
if (!doIsDebuggerAttachSupported()) {
dataRm.setStatus(
new Status(IStatus.ERROR, GdbPlugin.PLUGIN_ID, INTERNAL_ERROR, "Attach not supported.", null)); //$NON-NLS-1$
dataRm.done();
return;
}
// Use a sequence for better control of each step
ImmediateExecutor.getInstance().execute(new Sequence(getExecutor(), dataRm) {
private IMIContainerDMContext fContainerDmc;
private Step[] steps = new Step[] {
// For remote attach, we must set the binary first
// For a local attach, GDB can figure out the binary automatically,
// so we don't specify it.
new Step() {
@Override
public void execute(RequestMonitor rm) {
if (isInitialProcess()) {
// To be proper, set the initialProcess variable to false
// it may be necessary for a class that extends this class
setIsInitialProcess(false);
}
// There is no groupId until we attach, so we can use the default groupId
fContainerDmc = createContainerContext(procCtx, MIProcesses.UNIQUE_GROUP_ID);
if (binaryPath != null) {
fCommandControl.queueCommand(
fCommandFactory.createMIFileExecAndSymbols(fContainerDmc, binaryPath),
new ImmediateDataRequestMonitor<MIInfo>(rm));
return;
}
rm.done();
}
},
// Attach to the process
new Step() {
@Override
public void execute(RequestMonitor rm) {
// For non-stop mode, we do a non-interrupting attach
// Bug 333284
boolean shouldInterrupt = true;
IMIRunControl runControl = getServicesTracker().getService(IMIRunControl.class);
if (runControl != null && runControl.getRunMode() == MIRunMode.NON_STOP) {
shouldInterrupt = false;
}
fCommandControl.queueCommand(
fCommandFactory.createMITargetAttach(fContainerDmc,
((IMIProcessDMContext) procCtx).getProcId(), shouldInterrupt),
new DataRequestMonitor<MIInfo>(getExecutor(), rm));
}
}, new Step() {
@Override
public void execute(RequestMonitor rm) {
// By now, GDB has reported the groupId that was created for this process
fContainerDmc = createContainerContext(procCtx,
getGroupFromPid(((IMIProcessDMContext) procCtx).getProcId()));
// Store the fully formed container context so it can be returned to the caller.
dataRm.setData(fContainerDmc);
// Initialize memory data for this process.
IGDBMemory memory = getServicesTracker().getService(IGDBMemory.class);
IMemoryDMContext memContext = DMContexts.getAncestorOfType(fContainerDmc,
IMemoryDMContext.class);
if (memory == null || memContext == null) {
rm.done();
return;
}
memory.initializeMemoryData(memContext, rm);
}
}, new Step() {
@Override
public void execute(RequestMonitor rm) {
// Start tracking breakpoints.
MIBreakpointsManager bpmService = getServicesTracker()
.getService(MIBreakpointsManager.class);
bpmService.startTrackingBpForProcess(fContainerDmc, rm);
}
},
// Turn on reverse debugging if it was enabled as a launch option
new Step() {
@Override
public void execute(RequestMonitor rm) {
doReverseDebugStep(procCtx, rm);
}
}, };
@Override
public Step[] getSteps() {
return steps;
}
});
} else {
dataRm.setStatus(
new Status(IStatus.ERROR, GdbPlugin.PLUGIN_ID, INTERNAL_ERROR, "Invalid process context.", null)); //$NON-NLS-1$
dataRm.done();
}
}
/** @since 5.0 */
protected void doReverseDebugStep(final IProcessDMContext procCtx, RequestMonitor rm) {
// Turn on reverse debugging if it was enabled as a launch option
IReverseRunControl reverseService = getServicesTracker().getService(IReverseRunControl.class);
if (reverseService != null) {
ILaunch launch = procCtx.getAdapter(ILaunch.class);
if (launch != null) {
try {
boolean reverseEnabled = launch.getLaunchConfiguration().getAttribute(
IGDBLaunchConfigurationConstants.ATTR_DEBUGGER_REVERSE,
IGDBLaunchConfigurationConstants.DEBUGGER_REVERSE_DEFAULT);
if (reverseEnabled) {
reverseService.enableReverseMode(fCommandControl.getContext(), true, rm);
return;
}
} catch (CoreException e) {
// Ignore, just don't set reverse
}
}
}
rm.done();
}
/** @since 4.0 */
protected boolean doCanDetachDebuggerFromProcess() {
return fNumConnected > 0;
}
private boolean isExitedProcess(IDMContext dmc) {
return DMContexts.getAncestorOfType(dmc, MIExitedProcessDMC.class) != null;
}
@Override
public void canDetachDebuggerFromProcess(IDMContext dmc, DataRequestMonitor<Boolean> rm) {
MIExitedProcessDMC exitedProc = DMContexts.getAncestorOfType(dmc, MIExitedProcessDMC.class);
if (exitedProc != null) {
// Allow to use the disconnect button to remove an exited process
rm.done(true);
return;
}
rm.done(doCanDetachDebuggerFromProcess());
}
@Override
public void detachDebuggerFromProcess(final IDMContext dmc, final RequestMonitor rm) {
MIExitedProcessDMC exitedProc = DMContexts.getAncestorOfType(dmc, MIExitedProcessDMC.class);
if (exitedProc != null) {
// For an exited process, remove the entry from our table to stop showing it, and
// remove the entry from the launch itself to remove the process's console
String groupId = exitedProc.getGroupId();
getExitedProcesses().remove(groupId);
removeProcessFromLaunch(groupId);
getSession().dispatchEvent(new ProcessRemovedDMEvent(exitedProc), null);
return;
}
ICommandControlDMContext controlDmc = DMContexts.getAncestorOfType(dmc, ICommandControlDMContext.class);
final IMIProcessDMContext procDmc = DMContexts.getAncestorOfType(dmc, IMIProcessDMContext.class);
if (controlDmc != null && procDmc != null) {
if (!doCanDetachDebuggerFromProcess()) {
rm.setStatus(
new Status(IStatus.ERROR, GdbPlugin.PLUGIN_ID, INTERNAL_ERROR, "Detach not supported.", null)); //$NON-NLS-1$
rm.done();
return;
}
IMIRunControl runControl = getServicesTracker().getService(IMIRunControl.class);
if (runControl != null && !runControl.isTargetAcceptingCommands()) {
fBackend.interrupt();
}
// Remember that this process was detached so we don't show it as an exited process.
// We must set this before sending the detach command to gdb to avoid race conditions
final IMIContainerDMContext containerDmc = DMContexts.getAncestorOfType(dmc, IMIContainerDMContext.class);
if (containerDmc != null) {
getDetachedProcesses().add(containerDmc.getGroupId());
}
fCommandControl.queueCommand(fCommandFactory.createMITargetDetach(controlDmc, procDmc.getProcId()),
new DataRequestMonitor<MIInfo>(getExecutor(), rm) {
@Override
protected void handleFailure() {
// The detach failed
if (containerDmc != null) {
getDetachedProcesses().remove(containerDmc.getGroupId());
}
super.handleFailure();
}
});
} else {
rm.setStatus(new Status(IStatus.ERROR, GdbPlugin.PLUGIN_ID, INTERNAL_ERROR, "Invalid context.", null)); //$NON-NLS-1$
rm.done();
}
}
@Override
public void canTerminate(IThreadDMContext thread, DataRequestMonitor<Boolean> rm) {
if (thread instanceof MIExitedProcessDMC) {
// Allow pressing the terminate button to remove an exited process
rm.setData(true);
} else {
rm.setData(true);
}
rm.done();
}
@Override
public void isDebugNewProcessSupported(IDMContext dmc, DataRequestMonitor<Boolean> rm) {
rm.setData(doIsDebugNewProcessSupported());
rm.done();
}
/** @since 4.0 */
protected boolean doIsDebugNewProcessSupported() {
return false;
}
@Override
public void debugNewProcess(IDMContext dmc, String file, Map<String, Object> attributes,
DataRequestMonitor<IDMContext> rm) {
// Store the current value of the initialProcess variable because we will use it later
// and we are about to change it.
boolean isInitial = isInitialProcess();
if (isInitialProcess()) {
setIsInitialProcess(false);
} else {
// If we are trying to create another process than the initial one, see if we are allowed
if (!doIsDebugNewProcessSupported()) {
rm.setStatus(new Status(IStatus.ERROR, GdbPlugin.PLUGIN_ID, INVALID_STATE,
"Not allowed to create a new process", null)); //$NON-NLS-1$
rm.done();
return;
}
}
ImmediateExecutor.getInstance()
.execute(getDebugNewProcessSequence(getExecutor(), isInitial, dmc, file, attributes, rm));
}
/**
* Return the sequence that is to be used to create a new process the specified process.
* Allows others to extend more easily.
* @since 4.0
*/
protected Sequence getDebugNewProcessSequence(DsfExecutor executor, boolean isInitial, IDMContext dmc, String file,
Map<String, Object> attributes, DataRequestMonitor<IDMContext> rm) {
return new DebugNewProcessSequence(executor, isInitial, dmc, file, attributes, rm);
}
@Override
public void getProcessesBeingDebugged(final IDMContext dmc, final DataRequestMonitor<IDMContext[]> rm) {
final ICommandControlDMContext controlDmc = DMContexts.getAncestorOfType(dmc, ICommandControlDMContext.class);
final IMIContainerDMContext containerDmc = DMContexts.getAncestorOfType(dmc, IMIContainerDMContext.class);
if (containerDmc != null) {
if (isExitedProcess(containerDmc)) {
// No threads for an exited process
rm.done(new IMIExecutionDMContext[0]);
return;
}
fThreadCommandCache.execute(fCommandFactory.createMIListThreadGroups(controlDmc, containerDmc.getGroupId()),
new DataRequestMonitor<MIListThreadGroupsInfo>(getExecutor(), rm) {
@Override
protected void handleSuccess() {
rm.setData(makeExecutionDMCs(containerDmc, getData().getThreadInfo().getThreadList()));
rm.done();
}
});
} else {
final DataRequestMonitor<IMIContainerDMContext[]> addExitedDRM = new ImmediateDataRequestMonitor<IMIContainerDMContext[]>(
rm) {
@Override
protected void handleCompleted() {
List<IMIContainerDMContext> containerDmcs = new ArrayList<>(Arrays.asList(getData()));
// Add the exited processes to our list in reverse order of insertion so that
// the latest exited process is at the top
List<Entry<String, ExitedProcInfo>> entries = new ArrayList<>(getExitedProcesses().entrySet());
for (int i = entries.size() - 1; i >= 0; i--) {
Entry<String, ExitedProcInfo> entry = entries.get(i);
String groupId = entry.getKey();
String pid = entry.getValue().getPid();
IProcessDMContext processDmc = createExitedProcessContext(controlDmc, pid, groupId);
containerDmcs.add(createContainerContext(processDmc, groupId));
}
rm.done(containerDmcs.toArray(new IMIContainerDMContext[containerDmcs.size()]));
}
};
fContainerCommandCache.execute(fCommandFactory.createMIListThreadGroups(controlDmc),
new DataRequestMonitor<MIListThreadGroupsInfo>(getExecutor(), addExitedDRM) {
@Override
protected void handleSuccess() {
addExitedDRM.done(makeContainerDMCs(controlDmc, getData().getGroupList()));
}
@Override
protected void handleFailure() {
// If the target is not available, generate the list ourselves
IMIContainerDMContext[] containerDmcs = new IMIContainerDMContext[getGroupToPidMap()
.size()];
int i = 0;
for (String groupId : getGroupToPidMap().keySet()) {
containerDmcs[i++] = createContainerContextFromGroupId(controlDmc, groupId);
}
addExitedDRM.done(containerDmcs);
}
});
}
}
private IExecutionDMContext[] makeExecutionDMCs(IContainerDMContext containerDmc, MIThread[] threadInfos) {
final IProcessDMContext procDmc = DMContexts.getAncestorOfType(containerDmc, IProcessDMContext.class);
if (threadInfos.length == 0) {
// Main thread always exist even if it is not reported by GDB.
// So create thread-id = 0 when no thread is reported.
// This hack is necessary to prevent AbstractMIControl from issuing a thread-select
// because it doesn't work if the application was not compiled with pthread.
return new IMIExecutionDMContext[] { createExecutionContext(containerDmc,
createThreadContext(procDmc, FAKE_THREAD_ID), FAKE_THREAD_ID) };
} else {
IExecutionDMContext[] executionDmcs = new IMIExecutionDMContext[threadInfos.length];
for (int i = 0; i < threadInfos.length; i++) {
String threadId = threadInfos[i].getThreadId();
executionDmcs[i] = createExecutionContext(containerDmc, createThreadContext(procDmc, threadId),
threadId);
}
return executionDmcs;
}
}
private IMIContainerDMContext[] makeContainerDMCs(ICommandControlDMContext controlDmc, IThreadGroupInfo[] groups) {
// This is a workaround for post-mortem tracing because the early GDB release
// does not report a process when we do -list-thread-group
// GDB 7.2 will properly report the process so this
// code can be removed when GDB 7.2 is released
// START OF WORKAROUND
if (groups.length == 0 && fBackend.getSessionType() == SessionType.CORE) {
return new IMIContainerDMContext[] {
createContainerContextFromGroupId(controlDmc, MIProcesses.UNIQUE_GROUP_ID) };
}
// END OF WORKAROUND to be removed when GDB 7.2 is available
// With GDB 7.1, we can receive a bogus process when we are not debugging anything
// -list-thread-groups
// ^done,groups=[{id="0",type="process",pid="0"}]
// As for GDB 7.2, the pid field is missing altogether in this case
// -list-thread-groups
// ^done,groups=[{id="i1",type="process"}]
// Just ignore that entry
List<IMIContainerDMContext> containerDmcs = new ArrayList<>(groups.length);
for (IThreadGroupInfo group : groups) {
if (group.getPid() == null || group.getPid().isEmpty() || group.getPid().equals("0")) { //$NON-NLS-1$
continue;
}
String groupId = group.getGroupId();
containerDmcs.add(createContainerContextFromGroupId(controlDmc, groupId));
}
return containerDmcs.toArray(new IMIContainerDMContext[containerDmcs.size()]);
}
@Override
public void getRunningProcesses(final IDMContext dmc, final DataRequestMonitor<IProcessDMContext[]> rm) {
final ICommandControlDMContext controlDmc = DMContexts.getAncestorOfType(dmc, ICommandControlDMContext.class);
if (controlDmc != null) {
fListThreadGroupsAvailableCache.execute(fCommandFactory.createMIListThreadGroups(controlDmc, true),
new DataRequestMonitor<MIListThreadGroupsInfo>(getExecutor(), rm) {
@Override
protected void handleCompleted() {
// We cannot actually cache this command since the process
// list may change. But this cache allows to avoid overlapping
// sending of this command.
fListThreadGroupsAvailableCache.reset();
if (isSuccess()) {
rm.setData(makeProcessDMCAndData(controlDmc, getData().getGroupList()));
} else {
// Looks like this gdb doesn't truly support
// "-list-thread-groups --available". If we're
// debugging locally, resort to getting the
// list natively (as we do with gdb 6.8). If
// we're debugging remotely, the user is out
// of luck
if (fBackend.getSessionType() == SessionType.LOCAL) {
IProcessList list = null;
try {
list = CCorePlugin.getDefault().getProcessList();
} catch (CoreException e) {
}
if (list == null) {
rm.setData(new IProcessDMContext[0]);
} else {
IProcessInfo[] procInfos = list.getProcessList();
rm.setData(makeProcessDMCAndData(controlDmc, procInfos));
}
} else {
rm.setData(new IProcessDMContext[0]);
}
}
rm.done();
}
});
} else {
rm.setStatus(new Status(IStatus.ERROR, GdbPlugin.PLUGIN_ID, INTERNAL_ERROR, "Invalid context.", null)); //$NON-NLS-1$
rm.done();
}
}
/**
* Create the joint process DMC and data based on IProcessInfo, which is a local listing.
* @since 4.0
*/
protected MIProcessDMCAndData[] makeProcessDMCAndData(ICommandControlDMContext controlDmc,
IProcessInfo[] processes) {
MIProcessDMCAndData[] procDmcs = new MIProcessDMCAndData[processes.length];
for (int i = 0; i < procDmcs.length; i++) {
procDmcs[i] = new MIProcessDMCAndData(controlDmc.getSessionId(), controlDmc,
Integer.toString(processes[i].getPid()), processes[i].getName(), null, null);
}
return procDmcs;
}
/**
* Create the joint process DMC and data based on IThreadGroupInfo, which is obtained from GDB.
* @since 4.0
*/
protected MIProcessDMCAndData[] makeProcessDMCAndData(ICommandControlDMContext controlDmc,
IThreadGroupInfo[] processes) {
MIProcessDMCAndData[] procDmcs = new MIProcessDMCAndData[processes.length];
int i = 0;
for (IThreadGroupInfo process : processes) {
procDmcs[i++] = new MIProcessDMCAndData(controlDmc.getSessionId(), controlDmc, process.getGroupId(),
process.getName(), process.getCores(), process.getUser(), process.getDesciption());
}
return procDmcs;
}
@Override
public void isRunNewProcessSupported(IDMContext dmc, DataRequestMonitor<Boolean> rm) {
rm.setData(false);
rm.done();
}
@Override
public void runNewProcess(IDMContext dmc, String file, Map<String, Object> attributes,
DataRequestMonitor<IProcessDMContext> rm) {
rm.setStatus(new Status(IStatus.ERROR, GdbPlugin.PLUGIN_ID, NOT_SUPPORTED, "Not supported", null)); //$NON-NLS-1$
rm.done();
}
@Override
public void terminate(IThreadDMContext thread, final RequestMonitor rm) {
if (thread instanceof MIExitedProcessDMC) {
// For an exited process, remove the entry from our table to stop showing it, and
// remove the entry from the launch itself to remove the process's console
String groupId = ((MIExitedProcessDMC) thread).getGroupId();
getExitedProcesses().remove(groupId);
removeProcessFromLaunch(groupId);
getSession().dispatchEvent(new ProcessRemovedDMEvent((IProcessDMContext) thread), null);
} else if (fBackend.getSessionType() == SessionType.CORE) {
// For a core session, there is no concept of killing the inferior,
// so lets kill GDB
fCommandControl.terminate(rm);
} else if (thread instanceof IMIProcessDMContext) {
getDebuggingContext(thread, new ImmediateDataRequestMonitor<IDMContext>(rm) {
@Override
protected void handleSuccess() {
if (getData() instanceof IMIContainerDMContext) {
IMIRunControl runControl = getServicesTracker().getService(IMIRunControl.class);
if (runControl != null && !runControl.isTargetAcceptingCommands()) {
fBackend.interrupt();
}
fCommandControl.queueCommand(
fCommandFactory.createMIInterpreterExecConsoleKill((IMIContainerDMContext) getData()),
new ImmediateDataRequestMonitor<MIInfo>(rm));
} else {
rm.setStatus(new Status(IStatus.ERROR, GdbPlugin.PLUGIN_ID, INTERNAL_ERROR,
"Invalid process context.", null)); //$NON-NLS-1$
rm.done();
}
}
});
} else {
rm.setStatus(
new Status(IStatus.ERROR, GdbPlugin.PLUGIN_ID, INTERNAL_ERROR, "Invalid process context.", null)); //$NON-NLS-1$
rm.done();
}
}
/** @since 4.0 */
@Override
public void canRestart(IContainerDMContext containerDmc, DataRequestMonitor<Boolean> rm) {
if (fBackend.getIsAttachSession() || fBackend.getSessionType() == SessionType.CORE) {
rm.setData(false);
rm.done();
return;
}
// Before GDB6.8, the Linux gdbserver would restart a new
// process when getting a -exec-run but the communication
// with GDB had a bug and everything hung.
// with GDB6.8 the program restarts properly one time,
// but on a second attempt, gdbserver crashes.
// So, lets just turn off the Restart for Remote debugging
if (fBackend.getSessionType() == SessionType.REMOTE) {
rm.setData(false);
rm.done();
return;
}
rm.setData(true);
rm.done();
}
/**
* Creates the container context that is to be used for the new process that will
* be created by the restart operation.
* This container does not have its pid yet, while the container of the process
* that is being restarted does have its pid.
* Also, for GDB 7.0 and 7.1, the groupId being the pid, we cannot use the old
* container's groupId, but must use the default groupId until the pid is created.
*
* @since 4.0
*/
protected IMIContainerDMContext createContainerContextForRestart(String groupId) {
IProcessDMContext processDmc = createProcessContext(fCommandControl.getContext(),
MIProcesses.UNKNOWN_PROCESS_ID);
// Don't use the groupId passed in, since it is the old pid.
return createContainerContext(processDmc, MIProcesses.UNIQUE_GROUP_ID);
}
/** @since 4.0 */
@Override
public void restart(IContainerDMContext containerDmc, final Map<String, Object> attributes,
final DataRequestMonitor<IContainerDMContext> rm) {
// Before performing the restart, check if the process is properly suspended.
// For such a case, we usually use IMIRunControl.isTargetAcceptingCommands().
// However, in non-stop, although the target is accepting command, a restart
// won't work because it needs to be able to set breakpoints. So, to allow
// for breakpoints to be set, we make sure process is actually suspended.
//
// The other way to make this work is to have the restart code set the breakpoints
// using the breakpoint service, instead of sending the breakpoint command directly.
// This required more changes than suspending the process, so it was not done
// just yet.
// Bug 246740
final String groupId = ((IMIContainerDMContext) containerDmc).getGroupId();
// This request monitor actually performs the restart
RequestMonitor restartRm = new ImmediateRequestMonitor(rm) {
@Override
protected void handleSuccess() {
// For a restart, we are given the container context of the original process. However, we want to start
// a new process with a new pid, so we should create a container for it, and not use the old container with the old pid.
// Pass in the groupId because starting with GDB 7.2, we must re-use the same groupId.
IContainerDMContext newContainerDmc = createContainerContextForRestart(groupId);
startOrRestart(newContainerDmc, attributes, true,
new ImmediateDataRequestMonitor<IContainerDMContext>(rm) {
@Override
protected void handleCompleted() {
// In case the process we restarted was already exited, remove it from our list
// We do this here for GDB 7.1, because we know the proper groupId here which
// will change when the new restarted process will start. For GDB >= 7.2
// the groupId is fixed so we don't have to do this right away, but it won't hurt.
getExitedProcesses().remove(groupId);
setData(getData());
super.handleCompleted();
}
});
}
};
IRunControl runControl = getServicesTracker().getService(IRunControl.class);
if (runControl != null && !runControl.isSuspended(containerDmc)) {
// The process is running. Let's suspended it before doing the restart
runControl.suspend(containerDmc, restartRm);
} else {
// The process is already suspended, we can just trigger the restart
restartRm.done();
}
}
/** @since 4.0 */
@Override
public void start(IContainerDMContext containerDmc, Map<String, Object> attributes,
DataRequestMonitor<IContainerDMContext> rm) {
startOrRestart(containerDmc, attributes, false, rm);
}
/** @since 4.0 */
protected void startOrRestart(IContainerDMContext containerDmc, Map<String, Object> attributes, boolean restart,
DataRequestMonitor<IContainerDMContext> rm) {
ImmediateExecutor.getInstance()
.execute(getStartOrRestartProcessSequence(getExecutor(), containerDmc, attributes, restart, rm));
}
/**
* Return the sequence that is to be used to start or restart the specified process.
* Allows others to extend more easily.
* @since 4.0
*/
protected Sequence getStartOrRestartProcessSequence(DsfExecutor executor, IContainerDMContext containerDmc,
Map<String, Object> attributes, boolean restart, DataRequestMonitor<IContainerDMContext> rm) {
return new StartOrRestartProcessSequence_7_0(executor, containerDmc, attributes, restart, rm);
}
/**
* Removes the process with the specified groupId from the launch.
*
* @return The label used for the console of that process.
*/
private String removeProcessFromLaunch(String groupId) {
ILaunch launch = (ILaunch) getSession().getModelAdapter(ILaunch.class);
IProcess[] launchProcesses = launch.getProcesses();
for (IProcess process : launchProcesses) {
if (process instanceof InferiorRuntimeProcess) {
String groupAttribute = process.getAttribute(IGdbDebugConstants.INFERIOR_GROUPID_ATTR);
// if the groupAttribute is not set in the process we know we are dealing
// with single process debugging so the one process is the one we want.
// If the groupAttribute is set, then we must make sure it is the proper inferior
if (groupAttribute == null || groupAttribute.equals(MIProcesses.UNIQUE_GROUP_ID)
|| groupAttribute.equals(groupId)) {
launch.removeProcess(process);
return process.getLabel();
}
}
}
return null;
}
/**
* Add the specified process to the launch.
*/
private void addProcessToLaunch(Process inferior, String groupId, String label) {
// Add the inferior to the launch.
// This cannot be done on the executor or things deadlock.
DebugPlugin.getDefault().asyncExec(() -> {
// Add the inferior
// Need to go through DebugPlugin.newProcess so that we can use
// the overrideable process factory to allow others to override.
// First set attribute to specify we want to create an inferior process.
// Bug 210366
ILaunch launch = (ILaunch) getSession().getModelAdapter(ILaunch.class);
Map<String, String> attributes = new HashMap<>();
attributes.put(IGdbDebugConstants.PROCESS_TYPE_CREATION_ATTR,
IGdbDebugConstants.INFERIOR_PROCESS_CREATION_VALUE);
IProcess runtimeInferior = DebugPlugin.newProcess(launch, inferior, label != null ? label : "", //$NON-NLS-1$
attributes);
// Now set the inferior groupId
runtimeInferior.setAttribute(IGdbDebugConstants.INFERIOR_GROUPID_ATTR, groupId);
});
}
/**
* @since 5.2
*/
@Override
public void addInferiorToLaunch(IContainerDMContext containerDmc, String label, PTY pty, RequestMonitor rm) {
if (containerDmc instanceof IMIContainerDMContext) {
String groupId = ((IMIContainerDMContext) containerDmc).getGroupId();
// Create an MIInferiorProcess to track the new instance of the process,
// remove the old one from the launch, and add the new one to the launch.
Process inferiorProcess;
if (pty == null) {
inferiorProcess = createInferiorProcess(containerDmc, fBackend.getMIOutputStream());
} else {
fGroupIdToPTYMap.put(groupId, pty);
inferiorProcess = createInferiorProcess(containerDmc, pty);
}
addProcessToLaunch(inferiorProcess, groupId, label);
}
rm.done();
}
@DsfServiceEventHandler
public void eventDispatched(final MIThreadGroupCreatedEvent e) {
IProcessDMContext procDmc = e.getDMContext();
IMIContainerDMContext containerDmc = e.getGroupId() != null ? createContainerContext(procDmc, e.getGroupId())
: null;
getSession().dispatchEvent(new ContainerStartedDMEvent(containerDmc), getProperties());
}
@DsfServiceEventHandler
public void eventDispatched(final MIThreadGroupExitedEvent e) {
IProcessDMContext procDmc = e.getDMContext();
IMIContainerDMContext containerDmc = e.getGroupId() != null ? createContainerContext(procDmc, e.getGroupId())
: null;
getSession().dispatchEvent(new ContainerExitedDMEvent(containerDmc), getProperties());
}
@DsfServiceEventHandler
public void eventDispatched(IResumedDMEvent e) {
if (e instanceof IContainerResumedDMEvent) {
// This will happen in all-stop mode
fContainerCommandCache.setContextAvailable(e.getDMContext(), false);
fThreadCommandCache.setContextAvailable(e.getDMContext(), false);
fListThreadGroupsAvailableCache.setContextAvailable(e.getDMContext(), false);
} else {
// This will happen in non-stop mode
// Keep target available for Container commands
}
}
/** @since 5.2 */
protected MIInferiorProcess createInferiorProcess(IContainerDMContext container, OutputStream outputStream) {
return new MIInferiorProcess(container, outputStream);
}
/** @since 5.2 */
protected MIInferiorProcess createInferiorProcess(IContainerDMContext container, PTY pty) {
return new MIInferiorProcess(container, pty);
}
private void handleRestartingProcess(IMIContainerDMContext containerDmc) {
String label = removeProcessFromLaunch(containerDmc.getGroupId());
if (label != null) {
// We only add the process to the launch if the original process was part of the launch.
// For example, in the attach case, there is no process added to the launch
// We re-use the same PTY as the one used before the restart.
addInferiorToLaunch(containerDmc, label, fGroupIdToPTYMap.get(containerDmc.getGroupId()),
new ImmediateRequestMonitor());
}
}
@DsfServiceEventHandler
public void eventDispatched(ISuspendedDMEvent e) {
if (e instanceof IContainerSuspendedDMEvent) {
// This will happen in all-stop mode
fContainerCommandCache.setContextAvailable(fCommandControl.getContext(), true);
fThreadCommandCache.setContextAvailable(fCommandControl.getContext(), true);
fListThreadGroupsAvailableCache.setContextAvailable(fCommandControl.getContext(), true);
} else {
// This will happen in non-stop mode
}
// If user is debugging a gdb target that doesn't send thread
// creation events, make sure we don't use cached thread
// information. Reset the cache after every suspend. See bugzilla
// 280631
try {
if (fBackend.getUpdateThreadListOnSuspend()) {
// We need to clear the cache for the context that we use to fill the cache,
// and it is the controDMC in this case.
ICommandControlDMContext controlDmc = DMContexts.getAncestorOfType(e.getDMContext(),
ICommandControlDMContext.class);
fThreadCommandCache.reset(controlDmc);
}
} catch (CoreException exc) {
}
}
// Event handler when a thread or threadGroup starts
@DsfServiceEventHandler
public void eventDispatched(IStartedDMEvent e) {
if (e.getDMContext() instanceof IMIContainerDMContext) {
String groupId = ((IMIContainerDMContext) e.getDMContext()).getGroupId();
if (fExitedGroupId.remove(groupId)) {
// The process in question is restarting.
handleRestartingProcess((IMIContainerDMContext) e.getDMContext());
}
fContainerCommandCache.reset();
fNumConnected++;
} else {
fThreadCommandCache.reset();
}
}
// Event handler when a thread or a threadGroup exits
@DsfServiceEventHandler
public void eventDispatched(IExitedDMEvent e) {
if (e.getDMContext() instanceof IMIContainerDMContext) {
fExitedGroupId.add(((IMIContainerDMContext) e.getDMContext()).getGroupId());
fContainerCommandCache.reset();
assert fNumConnected > 0;
fNumConnected--;
if (fNumConnected == 0 && Platform.getPreferencesService().getBoolean(GdbPlugin.PLUGIN_ID,
IGdbDebugPreferenceConstants.PREF_AUTO_TERMINATE_GDB, true, null)) {
// If the last process we are debugging finishes and does not restart
// let's terminate GDB. We wait a small delay to see if the process will restart.
// We also do this for a remote attach session, since the 'auto terminate' preference
// is enabled. If users want to keep the session alive to attach to another process,
// they can simply disable that preference
getExecutor().schedule(new DsfRunnable() {
@Override
public void run() {
// Verify the process didn't restart by checking that we still have nothing connected
if (fNumConnected == 0) {
fCommandControl.terminate(new ImmediateRequestMonitor());
}
}
}, 500, TimeUnit.MILLISECONDS);
}
} else {
fThreadCommandCache.reset();
}
}
/**
* @since 5.2
*/
@DsfServiceEventHandler
public void eventDispatched(ICommandControlShutdownDMEvent e) {
// Now that the debug session is over, close the persistent PTY streams
for (PTY pty : fGroupIdToPTYMap.values()) {
if (pty instanceof PersistentPTY) {
try {
((PersistentPTY) pty).closeStreams();
} catch (IOException e1) {
}
}
}
fGroupIdToPTYMap.clear();
fExitedGroupId.clear();
}
@Override
public void flushCache(IDMContext context) {
fContainerCommandCache.reset(context);
fThreadCommandCache.reset(context);
// Not technically needed since we are supposed to have
// cleared this cache as soon as the it gets the answer
// from GDB; but to be more future-proof, might as well
// clear it here also.
fListThreadGroupsAvailableCache.reset(context);
}
/*
* Catch =thread-created/exited and =thread-group-exited events to update our
* groupId to threadId map.
*/
@Override
public void eventReceived(Object output) {
for (MIOOBRecord oobr : ((MIOutput) output).getMIOOBRecords()) {
if (oobr instanceof MINotifyAsyncOutput) {
MINotifyAsyncOutput exec = (MINotifyAsyncOutput) oobr;
String miEvent = exec.getAsyncClass();
if ("thread-created".equals(miEvent) || "thread-exited".equals(miEvent)) { //$NON-NLS-1$ //$NON-NLS-2$
String threadId = null;
String groupId = null;
MIResult[] results = exec.getMIResults();
for (int i = 0; i < results.length; i++) {
String var = results[i].getVariable();
MIValue val = results[i].getMIValue();
if (var.equals("group-id")) { //$NON-NLS-1$
if (val instanceof MIConst) {
groupId = ((MIConst) val).getString();
}
} else if (var.equals("id")) { //$NON-NLS-1$
if (val instanceof MIConst) {
threadId = ((MIConst) val).getString();
}
}
}
if ("thread-created".equals(miEvent)) { //$NON-NLS-1$
// Update the thread to groupId map with the new groupId
getThreadToGroupMap().put(threadId, groupId);
} else {
getThreadToGroupMap().remove(threadId);
}
// "thread-group-created" was used before GDB 7.2, while "thread-group-started" is used with GDB 7.2
} else if ("thread-group-created".equals(miEvent) || "thread-group-started".equals(miEvent)) { //$NON-NLS-1$ //$NON-NLS-2$
String groupId = null;
String pId = null;
MIResult[] results = exec.getMIResults();
for (int i = 0; i < results.length; i++) {
String var = results[i].getVariable();
MIValue val = results[i].getMIValue();
if (var.equals("id")) { //$NON-NLS-1$
if (val instanceof MIConst) {
groupId = ((MIConst) val).getString().trim();
}
} else if (var.equals("pid")) { //$NON-NLS-1$
// Available starting with GDB 7.2
if (val instanceof MIConst) {
pId = ((MIConst) val).getString().trim();
}
}
}
if (pId == null) {
// Before GDB 7.2, the groupId was the pid of the process
pId = groupId;
}
if (groupId != null) {
// In case the process that just started was already exited (so we are dealing
// with a restart), remove it from our list.
// Do this here to handle the restart case triggered by GDB itself
// (user typing 'run' from the GDB console). In this case, we don't know yet
// we are dealing with a restart, but when we see the process come back, we
// know to remove it from the exited list. Note that this won't work
// for GDB 7.1 because the groupId of the new process is not the same as the old
// one. Not worth fixing for such an old version.
getExitedProcesses().remove(groupId);
getGroupToPidMap().put(groupId, pId);
// Mark that we know this new process, but don't fetch its
// name until it is requested.
fDebuggedProcessesAndNames.put(pId, ""); //$NON-NLS-1$
}
} else if ("thread-group-exited".equals(miEvent)) { //$NON-NLS-1$
String groupId = null;
MIResult[] results = exec.getMIResults();
for (int i = 0; i < results.length; i++) {
String var = results[i].getVariable();
MIValue val = results[i].getMIValue();
if (var.equals("id")) { //$NON-NLS-1$
if (val instanceof MIConst) {
groupId = ((MIConst) val).getString().trim();
}
}
}
if (groupId != null) {
String pId = getGroupToPidMap().remove(groupId);
// GDB is no longer debugging this process. Remove it from our list
String name = fDebuggedProcessesAndNames.remove(pId);
if (!getDetachedProcesses().remove(groupId)) {
// If the process was not detached,
// store it in the list of exited processes.
getExitedProcesses().put(groupId, new ExitedProcInfo(pId, name));
}
// Remove any entries for that group from our thread to group map
// When detaching from a group, we won't have received any thread-exited event
// but we don't want to keep those entries.
if (getThreadToGroupMap().containsValue(groupId)) {
Iterator<Map.Entry<String, String>> iterator = getThreadToGroupMap().entrySet().iterator();
while (iterator.hasNext()) {
if (iterator.next().getValue().equals(groupId)) {
iterator.remove();
}
}
}
}
}
}
}
}
}