| /******************************************************************************* |
| * Copyright (c) 2006, 2014 Wind River Systems and others. |
| * All rights reserved. This program and the accompanying materials |
| * are made available under the terms of the Eclipse Public License v1.0 |
| * which accompanies this distribution, and is available at |
| * http://www.eclipse.org/legal/epl-v10.html |
| * |
| * Contributors: |
| * Wind River Systems - initial API and implementation |
| * Ericsson - Modified for additional features in DSF Reference implementation |
| * Nokia - create and use backend service. |
| * Vladimir Prus (CodeSourcery) - Support for -data-read-memory-bytes (bug 322658) |
| * Jens Elmenthaler (Verigy) - Added Full GDB pretty-printing support (bug 302121) |
| * Mikhail Khodjaiants (Mentor Graphics) - Refactor common code in GDBControl* classes (bug 372795) |
| * Marc Khouzam (Ericsson) - Pass errorStream to startCommandProcessing() (Bug 350837) |
| * Mikhail Khodjaiants (Mentor Graphics) - Terminate should cancel the initialization sequence |
| * if it is still running (bug 373845) |
| * Marc Khouzam (Ericsson) - Terminate the session if we lose the connection to the remote target (bug 422586) |
| * Marc Khouzam (Ericsson) - Allow to override the creation of the ControlDMC (Bug 389945) |
| *******************************************************************************/ |
| package org.eclipse.cdt.dsf.gdb.service.command; |
| |
| import java.io.IOException; |
| import java.io.InputStream; |
| import java.io.OutputStream; |
| import java.util.ArrayList; |
| import java.util.Hashtable; |
| import java.util.List; |
| import java.util.Map; |
| import java.util.Map.Entry; |
| import java.util.Properties; |
| import java.util.concurrent.Future; |
| import java.util.concurrent.TimeUnit; |
| |
| import org.eclipse.cdt.dsf.concurrent.ConfinedToDsfExecutor; |
| import org.eclipse.cdt.dsf.concurrent.CountingRequestMonitor; |
| import org.eclipse.cdt.dsf.concurrent.DataRequestMonitor; |
| import org.eclipse.cdt.dsf.concurrent.DsfRunnable; |
| import org.eclipse.cdt.dsf.concurrent.IDsfStatusConstants; |
| import org.eclipse.cdt.dsf.concurrent.ImmediateExecutor; |
| import org.eclipse.cdt.dsf.concurrent.ImmediateRequestMonitor; |
| import org.eclipse.cdt.dsf.concurrent.RequestMonitor; |
| import org.eclipse.cdt.dsf.concurrent.RequestMonitorWithProgress; |
| import org.eclipse.cdt.dsf.concurrent.Sequence; |
| import org.eclipse.cdt.dsf.datamodel.AbstractDMEvent; |
| import org.eclipse.cdt.dsf.debug.service.IRunControl.IContainerDMContext; |
| import org.eclipse.cdt.dsf.debug.service.command.ICommandControl; |
| import org.eclipse.cdt.dsf.debug.service.command.ICommandControlService; |
| import org.eclipse.cdt.dsf.debug.service.command.ICommandResult; |
| import org.eclipse.cdt.dsf.debug.service.command.ICommandToken; |
| import org.eclipse.cdt.dsf.gdb.IGdbDebugConstants; |
| import org.eclipse.cdt.dsf.gdb.internal.GdbPlugin; |
| import org.eclipse.cdt.dsf.gdb.internal.Messages; |
| import org.eclipse.cdt.dsf.gdb.launching.FinalLaunchSequence; |
| import org.eclipse.cdt.dsf.gdb.service.IGDBBackend; |
| import org.eclipse.cdt.dsf.gdb.service.IGDBProcesses; |
| import org.eclipse.cdt.dsf.gdb.service.command.GdbCommandTimeoutManager.ICommandTimeoutListener; |
| import org.eclipse.cdt.dsf.mi.service.IMIBackend; |
| import org.eclipse.cdt.dsf.mi.service.IMIBackend.BackendStateChangedEvent; |
| import org.eclipse.cdt.dsf.mi.service.IMIBackend2; |
| import org.eclipse.cdt.dsf.mi.service.IMICommandControl; |
| import org.eclipse.cdt.dsf.mi.service.IMIRunControl; |
| import org.eclipse.cdt.dsf.mi.service.MIProcesses; |
| import org.eclipse.cdt.dsf.mi.service.MIProcesses.ContainerExitedDMEvent; |
| import org.eclipse.cdt.dsf.mi.service.command.AbstractCLIProcess; |
| import org.eclipse.cdt.dsf.mi.service.command.AbstractMIControl; |
| import org.eclipse.cdt.dsf.mi.service.command.CLIEventProcessor; |
| import org.eclipse.cdt.dsf.mi.service.command.CommandFactory; |
| import org.eclipse.cdt.dsf.mi.service.command.IEventProcessor; |
| import org.eclipse.cdt.dsf.mi.service.command.MIControlDMContext; |
| import org.eclipse.cdt.dsf.mi.service.command.MIRunControlEventProcessor; |
| import org.eclipse.cdt.dsf.mi.service.command.output.MIConsoleStreamOutput; |
| 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.MILogStreamOutput; |
| 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.MIResultRecord; |
| import org.eclipse.cdt.dsf.mi.service.command.output.MIValue; |
| import org.eclipse.cdt.dsf.service.DsfServiceEventHandler; |
| import org.eclipse.cdt.dsf.service.DsfSession; |
| import org.eclipse.core.runtime.CoreException; |
| import org.eclipse.core.runtime.IProgressMonitor; |
| import org.eclipse.core.runtime.IStatus; |
| import org.eclipse.core.runtime.NullProgressMonitor; |
| import org.eclipse.core.runtime.Status; |
| import org.eclipse.debug.core.DebugPlugin; |
| import org.eclipse.debug.core.ILaunch; |
| import org.eclipse.debug.core.ILaunchConfiguration; |
| import org.eclipse.debug.core.IStatusHandler; |
| import org.osgi.framework.BundleContext; |
| |
| /** |
| * GDB Debugger control implementation. This implementation extends the |
| * base MI control implementation to provide the GDB-specific debugger |
| * features. This includes:<br> |
| * - CLI console support,<br> |
| * - inferior process status tracking.<br> |
| */ |
| public class GDBControl extends AbstractMIControl implements IGDBControl { |
| |
| private static final int STATUS_CODE_COMMAND_TIMED_OUT = 20100; |
| |
| /** |
| * Event indicating that the back end process has started. |
| */ |
| private static class GDBControlInitializedDMEvent extends AbstractDMEvent<ICommandControlDMContext> |
| implements ICommandControlInitializedDMEvent |
| { |
| public GDBControlInitializedDMEvent(ICommandControlDMContext context) { |
| super(context); |
| } |
| } |
| |
| /** |
| * Event indicating that the CommandControl (back end process) has terminated. |
| */ |
| private static class GDBControlShutdownDMEvent extends AbstractDMEvent<ICommandControlDMContext> |
| implements ICommandControlShutdownDMEvent |
| { |
| public GDBControlShutdownDMEvent(ICommandControlDMContext context) { |
| super(context); |
| } |
| } |
| |
| private class TimeoutListener implements ICommandTimeoutListener { |
| |
| @Override |
| public void commandTimedOut(final ICommandToken token) { |
| getExecutor().execute(new DsfRunnable() { |
| |
| @Override |
| public void run() { |
| GDBControl.this.commandTimedOut(token); |
| } |
| }); |
| } |
| } |
| |
| /** |
| * An event processor that handles some GDB life cycle events. |
| * Currently, it detects a lost connection with the remote. |
| */ |
| private class ControlEventProcessor implements IEventProcessor { |
| |
| public ControlEventProcessor() { |
| addCommandListener(this); |
| addEventListener(this); |
| } |
| |
| @Override |
| public void dispose() { |
| removeEventListener(this); |
| removeCommandListener(this); |
| } |
| |
| @Override |
| public void eventReceived(Object output) { |
| if (output instanceof MIOutput) { |
| verifyConnectionLost((MIOutput)output); |
| } else { |
| assert false; |
| } |
| } |
| |
| @Override |
| public void commandDone(ICommandToken token, ICommandResult cmdResult) { |
| if (cmdResult instanceof MIInfo) { |
| verifyConnectionLost(((MIInfo)cmdResult).getMIOutput()); |
| } else { |
| assert false; |
| } |
| } |
| |
| @Override |
| public void commandQueued(ICommandToken token) { |
| } |
| |
| @Override |
| public void commandSent(ICommandToken token) { |
| } |
| |
| @Override |
| public void commandRemoved(ICommandToken token) { |
| } |
| } |
| |
| private ICommandControlDMContext fControlDmc; |
| |
| private IGDBBackend fMIBackend; |
| |
| private IEventProcessor fMIEventProcessor; |
| private IEventProcessor fCLICommandProcessor; |
| private IEventProcessor fControlEventProcessor; |
| private AbstractCLIProcess fCLIProcess; |
| |
| private GdbCommandTimeoutManager fCommandTimeoutManager; |
| |
| private ICommandTimeoutListener fTimeoutListener = new TimeoutListener(); |
| |
| /** |
| * GDBControl is only used for GDB earlier that 7.0. Although -list-features |
| * is available in 6.8, it does not report anything we care about, so |
| * return empty list. |
| */ |
| private final List<String> fFeatures = new ArrayList<String>(); |
| |
| private Sequence fInitializationSequence; |
| |
| /** |
| * Indicator to distinguish whether this service is initialized. |
| * <code>fInitializationSequence</code> can not be used for this |
| * purpose because there is a period of time when the service is already |
| * initializing but the initialization sequence has not created yet. |
| */ |
| private boolean fInitialized = false; |
| |
| private boolean fTerminated; |
| |
| /** |
| * @since 3.0 |
| */ |
| public GDBControl(DsfSession session, ILaunchConfiguration config, CommandFactory factory) { |
| this(session, false, config, factory); |
| } |
| |
| /** |
| * @since 4.1 |
| */ |
| protected GDBControl(DsfSession session, boolean useThreadAndFrameOptions, ILaunchConfiguration config, CommandFactory factory) { |
| super(session, useThreadAndFrameOptions, factory); |
| } |
| |
| @Override |
| protected BundleContext getBundleContext() { |
| return GdbPlugin.getBundleContext(); |
| } |
| |
| @Override |
| public void initialize(final RequestMonitor requestMonitor) { |
| super.initialize( new ImmediateRequestMonitor(requestMonitor) { |
| @Override |
| protected void handleSuccess() { |
| doInitialize(requestMonitor); |
| } |
| }); |
| } |
| |
| private void doInitialize(final RequestMonitor requestMonitor) { |
| |
| fMIBackend = getServicesTracker().getService(IGDBBackend.class); |
| |
| // getId, called to create this context, uses the MIBackend service, |
| // which is why we must wait until we have MIBackend, before we can create the below context. |
| fControlDmc = createComandControlContext(); |
| |
| getExecutor().execute(getStartupSequence(requestMonitor)); |
| } |
| |
| @Override |
| public void shutdown(final RequestMonitor requestMonitor) { |
| getExecutor().execute(getShutdownSequence(new RequestMonitor(getExecutor(), requestMonitor) { |
| |
| @Override |
| protected void handleCompleted() { |
| GDBControl.super.shutdown(requestMonitor); |
| } |
| })); |
| } |
| |
| @Override |
| public String getId() { |
| return fMIBackend.getId(); |
| } |
| |
| /** |
| * Create the commandControl context. |
| * This method can be overridden to provide a different context. |
| * @since 4.4 |
| */ |
| protected ICommandControlDMContext createComandControlContext() { |
| return new GDBControlDMContext(getSession().getId(), getId()); |
| } |
| |
| @Deprecated |
| @Override |
| public MIControlDMContext getControlDMContext() { |
| assert fControlDmc instanceof MIControlDMContext; |
| if (fControlDmc instanceof MIControlDMContext) { |
| return (MIControlDMContext)fControlDmc; |
| } |
| return null; |
| } |
| |
| @Override |
| public ICommandControlDMContext getContext() { |
| return fControlDmc; |
| } |
| |
| @Override |
| public void terminate(final RequestMonitor rm) { |
| if (fTerminated) { |
| rm.done(); |
| return; |
| } |
| fTerminated = true; |
| |
| // If the initialization sequence is still running mark it as cancelled, |
| // to avoid reporting errors to the user, since we are terminating anyway. |
| if (fInitializationSequence != null) { |
| fInitializationSequence.getRequestMonitor().cancel(); |
| } |
| |
| // To fix bug 234467: |
| // Interrupt GDB in case the inferior is running. |
| // That way, the inferior will also be killed when we exit GDB. |
| // |
| IMIRunControl runControl = getServicesTracker().getService(IMIRunControl.class); |
| if (runControl != null && !runControl.isTargetAcceptingCommands()) { |
| fMIBackend.interrupt(); |
| } |
| |
| // Schedule a runnable to be executed 2 seconds from now. |
| // If we don't get a response to the quit command, this |
| // runnable will kill the task. |
| final Future<?> forceQuitTask = getExecutor().schedule( |
| new DsfRunnable() { |
| @Override |
| public void run() { |
| fMIBackend.destroy(); |
| rm.done(); |
| } |
| |
| @Override |
| protected boolean isExecutionRequired() { |
| return false; |
| } |
| }, |
| getGDBExitWaitTime(), TimeUnit.SECONDS); |
| |
| queueCommand( |
| getCommandFactory().createMIGDBExit(getContext()), |
| new DataRequestMonitor<MIInfo>(getExecutor(), rm) { |
| @Override |
| public void handleCompleted() { |
| if (isSuccess()) { |
| // Cancel the time out runnable (if it hasn't run yet). |
| if (forceQuitTask.cancel(false)) { |
| rm.done(); |
| } |
| } |
| // else: the forceQuitTask has or will handle it. |
| // It is good to wait for the forceQuitTask to trigger |
| // to leave enough time for the interrupt() to complete. |
| } |
| } |
| ); |
| } |
| |
| @Override |
| public AbstractCLIProcess getCLIProcess() { |
| return fCLIProcess; |
| } |
| |
| /** |
| * @since 2.0 |
| */ |
| @Override |
| public void setTracingStream(OutputStream tracingStream) { |
| setMITracingStream(tracingStream); |
| } |
| |
| /** @since 3.0 */ |
| @Override |
| public void setEnvironment(Properties props, boolean clear, final RequestMonitor rm) { |
| int count = 0; |
| CountingRequestMonitor countingRm = new CountingRequestMonitor(getExecutor(), rm); |
| |
| // First clear the environment if requested. |
| if (clear) { |
| count++; |
| queueCommand( |
| getCommandFactory().createCLIUnsetEnv(getContext()), |
| new DataRequestMonitor<MIInfo>(getExecutor(), countingRm)); |
| } |
| |
| // Now set the new variables |
| for (Entry<Object,Object> property : props.entrySet()) { |
| count++; |
| String name = (String)property.getKey(); |
| String value = (String)property.getValue(); |
| queueCommand( |
| getCommandFactory().createMIGDBSetEnv(getContext(), name, value), |
| new DataRequestMonitor<MIInfo>(getExecutor(), countingRm)); |
| } |
| countingRm.setDoneCount(count); |
| } |
| |
| /** |
| * @since 4.0 |
| */ |
| @Override |
| public void completeInitialization(final RequestMonitor rm) { |
| // We take the attributes from the launchConfiguration |
| ILaunch launch = (ILaunch)getSession().getModelAdapter(ILaunch.class); |
| Map<String, Object> attributes = null; |
| try { |
| attributes = launch.getLaunchConfiguration().getAttributes(); |
| } catch (CoreException e) {} |
| |
| // We need a RequestMonitorWithProgress, if we don't have one, we create one. |
| IProgressMonitor monitor = (rm instanceof RequestMonitorWithProgress) ? |
| ((RequestMonitorWithProgress)rm).getProgressMonitor() : new NullProgressMonitor(); |
| RequestMonitorWithProgress progressRm = new RequestMonitorWithProgress(getExecutor(), monitor) { |
| |
| @Override |
| protected void handleCompleted() { |
| fInitializationSequence = null; |
| fInitialized = true; |
| if (!isCanceled()) { |
| // Only set the status if the user has not cancelled the operation already. |
| rm.setStatus(getStatus()); |
| } else { |
| rm.cancel(); |
| } |
| rm.done(); |
| } |
| }; |
| |
| fInitializationSequence = getCompleteInitializationSequence(attributes, progressRm); |
| ImmediateExecutor.getInstance().execute(fInitializationSequence); |
| } |
| |
| /** |
| * Return the sequence that is to be used to complete the initialization of GDB. |
| * |
| * @param rm A RequestMonitorWithProgress that will indicate when the sequence is completed, but that |
| * also contains an IProgressMonitor to be able to cancel the launch. A NullProgressMonitor |
| * can be used if cancellation is not required. |
| * |
| * @since 4.0 |
| */ |
| protected Sequence getCompleteInitializationSequence(Map<String, Object> attributes, RequestMonitorWithProgress rm) { |
| return new FinalLaunchSequence(getSession(), attributes, rm); |
| } |
| |
| @DsfServiceEventHandler |
| public void eventDispatched(ICommandControlShutdownDMEvent e) { |
| // Handle our "GDB Exited" event and stop processing commands. |
| stopCommandProcessing(); |
| |
| // Before GDB 7.0, we have to send the containerExited event ourselves |
| IGDBProcesses procService = getServicesTracker().getService(IGDBProcesses.class); |
| if (procService != null) { |
| IContainerDMContext processContainerDmc = procService.createContainerContextFromGroupId(getContext(), MIProcesses.UNIQUE_GROUP_ID); |
| getSession().dispatchEvent( |
| new ContainerExitedDMEvent(processContainerDmc), getProperties()); |
| } |
| } |
| |
| @DsfServiceEventHandler |
| public void eventDispatched(BackendStateChangedEvent e) { |
| if (e.getState() == IMIBackend.State.TERMINATED && e.getBackendId().equals(fMIBackend.getId())) { |
| // Handle "GDB Exited" event, just relay to following event. |
| getSession().dispatchEvent(new GDBControlShutdownDMEvent(getContext()), getProperties()); |
| } |
| } |
| |
| public static class InitializationShutdownStep extends Sequence.Step { |
| public enum Direction { INITIALIZING, SHUTTING_DOWN } |
| |
| private Direction fDirection; |
| public InitializationShutdownStep(Direction direction) { fDirection = direction; } |
| |
| @Override |
| final public void execute(RequestMonitor requestMonitor) { |
| if (fDirection == Direction.INITIALIZING) { |
| initialize(requestMonitor); |
| } else { |
| shutdown(requestMonitor); |
| } |
| } |
| |
| @Override |
| final public void rollBack(RequestMonitor requestMonitor) { |
| if (fDirection == Direction.INITIALIZING) { |
| shutdown(requestMonitor); |
| } else { |
| super.rollBack(requestMonitor); |
| } |
| } |
| |
| protected void initialize(RequestMonitor requestMonitor) { |
| requestMonitor.done(); |
| } |
| |
| protected void shutdown(RequestMonitor requestMonitor) { |
| requestMonitor.done(); |
| } |
| } |
| |
| protected class CommandMonitoringStep extends InitializationShutdownStep { |
| CommandMonitoringStep(Direction direction) { super(direction); } |
| |
| @Override |
| protected void initialize(final RequestMonitor requestMonitor) { |
| doCommandMonitoringStep(requestMonitor); |
| } |
| |
| @Override |
| protected void shutdown(RequestMonitor requestMonitor) { |
| undoCommandMonitoringStep(requestMonitor); |
| } |
| } |
| |
| /** @since 5.1 */ |
| protected void doCommandMonitoringStep(final RequestMonitor requestMonitor) { |
| InputStream errorStream = null; |
| if (fMIBackend instanceof IMIBackend2) { |
| errorStream = ((IMIBackend2)fMIBackend).getMIErrorStream(); |
| } |
| startCommandProcessing(fMIBackend.getMIInputStream(), fMIBackend.getMIOutputStream(), errorStream); |
| requestMonitor.done(); |
| } |
| |
| /** @since 5.1 */ |
| protected void undoCommandMonitoringStep(RequestMonitor requestMonitor) { |
| stopCommandProcessing(); |
| requestMonitor.done(); |
| } |
| |
| protected class CommandProcessorsStep extends InitializationShutdownStep { |
| CommandProcessorsStep(Direction direction) { super(direction); } |
| |
| @Override |
| public void initialize(final RequestMonitor requestMonitor) { |
| doCommandProcessorsStep(requestMonitor); |
| } |
| |
| @Override |
| protected void shutdown(RequestMonitor requestMonitor) { |
| undoCommandProcessorsStep(requestMonitor); |
| } |
| } |
| |
| /** @since 5.1 */ |
| protected void doCommandProcessorsStep(final RequestMonitor requestMonitor) { |
| try { |
| fCLIProcess = new GDBBackendCLIProcess(GDBControl.this, fMIBackend); |
| } |
| catch(IOException e) { |
| requestMonitor.setStatus(new Status(IStatus.ERROR, GdbPlugin.PLUGIN_ID, IDsfStatusConstants.REQUEST_FAILED, "Failed to create CLI Process", e)); //$NON-NLS-1$ |
| requestMonitor.done(); |
| return; |
| } |
| |
| fCLICommandProcessor = createCLIEventProcessor(GDBControl.this, getContext()); |
| fMIEventProcessor = createMIRunControlEventProcessor(GDBControl.this, getContext()); |
| fControlEventProcessor = createControlEventProcessor(); |
| |
| requestMonitor.done(); |
| } |
| |
| /** @since 5.1 */ |
| protected void undoCommandProcessorsStep(RequestMonitor requestMonitor) { |
| fControlEventProcessor.dispose(); |
| fCLICommandProcessor.dispose(); |
| fMIEventProcessor.dispose(); |
| fCLIProcess.dispose(); |
| |
| requestMonitor.done(); |
| } |
| |
| /** |
| * @since 4.1 |
| */ |
| protected class CommandTimeoutStep extends InitializationShutdownStep { |
| CommandTimeoutStep( Direction direction ) { |
| super( direction ); |
| } |
| |
| @Override |
| public void initialize( final RequestMonitor requestMonitor ) { |
| doCommandTimeoutStep(requestMonitor); |
| } |
| |
| @Override |
| protected void shutdown( RequestMonitor requestMonitor ) { |
| undoCommandTimeoutStep(requestMonitor); |
| } |
| } |
| |
| /** @since 5.1 */ |
| protected void doCommandTimeoutStep(final RequestMonitor requestMonitor) { |
| fCommandTimeoutManager = createCommandTimeoutManager( GDBControl.this ); |
| if (fCommandTimeoutManager != null) { |
| fCommandTimeoutManager.addCommandTimeoutListener(fTimeoutListener); |
| } |
| requestMonitor.done(); |
| } |
| |
| /** @since 5.1 */ |
| protected void undoCommandTimeoutStep(RequestMonitor requestMonitor) { |
| if ( fCommandTimeoutManager != null ) { |
| fCommandTimeoutManager.removeCommandTimeoutListener(fTimeoutListener); |
| fCommandTimeoutManager.dispose(); |
| } |
| requestMonitor.done(); |
| } |
| |
| protected class RegisterStep extends InitializationShutdownStep { |
| RegisterStep(Direction direction) { super(direction); } |
| @Override |
| public void initialize(final RequestMonitor requestMonitor) { |
| doRegisterStep(requestMonitor); |
| } |
| |
| @Override |
| protected void shutdown(RequestMonitor requestMonitor) { |
| undoRegisterStep(requestMonitor); |
| } |
| } |
| |
| /** @since 5.1 */ |
| protected void doRegisterStep(final RequestMonitor requestMonitor) { |
| getSession().addServiceEventListener(GDBControl.this, null); |
| register( |
| new String[]{ ICommandControl.class.getName(), |
| ICommandControlService.class.getName(), |
| IMICommandControl.class.getName(), |
| AbstractMIControl.class.getName(), |
| IGDBControl.class.getName() }, |
| new Hashtable<String,String>()); |
| getSession().dispatchEvent(new GDBControlInitializedDMEvent(getContext()), getProperties()); |
| requestMonitor.done(); |
| } |
| |
| /** @since 5.1 */ |
| protected void undoRegisterStep(RequestMonitor requestMonitor) { |
| unregister(); |
| getSession().removeServiceEventListener(GDBControl.this); |
| requestMonitor.done(); |
| } |
| |
| /** @since 4.0 */ |
| @Override |
| public List<String> getFeatures() { |
| return fFeatures; |
| } |
| |
| /** |
| * @since 4.0 |
| */ |
| @Override |
| public void enablePrettyPrintingForMIVariableObjects(RequestMonitor rm) { |
| rm.done(); |
| } |
| |
| /** |
| * @since 4.0 |
| */ |
| @Override |
| public void setPrintPythonErrors(boolean enabled, RequestMonitor rm) { |
| rm.done(); |
| } |
| |
| /** |
| * @since 4.1 |
| */ |
| protected Sequence getStartupSequence(final RequestMonitor requestMonitor) { |
| final Sequence.Step[] initializeSteps = new Sequence.Step[] { |
| new CommandMonitoringStep(InitializationShutdownStep.Direction.INITIALIZING), |
| new CommandProcessorsStep(InitializationShutdownStep.Direction.INITIALIZING), |
| new CommandTimeoutStep(InitializationShutdownStep.Direction.INITIALIZING), |
| new RegisterStep(InitializationShutdownStep.Direction.INITIALIZING), |
| }; |
| |
| return new Sequence(getExecutor(), requestMonitor) { |
| @Override public Step[] getSteps() { return initializeSteps; } |
| }; |
| } |
| |
| /** |
| * @since 4.1 |
| */ |
| protected Sequence getShutdownSequence(RequestMonitor requestMonitor) { |
| final Sequence.Step[] shutdownSteps = new Sequence.Step[] { |
| new RegisterStep(InitializationShutdownStep.Direction.SHUTTING_DOWN), |
| new CommandTimeoutStep(InitializationShutdownStep.Direction.SHUTTING_DOWN), |
| new CommandProcessorsStep(InitializationShutdownStep.Direction.SHUTTING_DOWN), |
| new CommandMonitoringStep(InitializationShutdownStep.Direction.SHUTTING_DOWN), |
| }; |
| return new Sequence(getExecutor(), requestMonitor) { |
| @Override public Step[] getSteps() { return shutdownSteps; } |
| }; |
| } |
| |
| /** |
| * @since 4.1 |
| */ |
| protected IEventProcessor createCLIEventProcessor(ICommandControlService connection, ICommandControlDMContext controlDmc) { |
| return new CLIEventProcessor(connection, controlDmc); |
| } |
| |
| /** |
| * @since 4.1 |
| */ |
| protected IEventProcessor createMIRunControlEventProcessor(AbstractMIControl connection, ICommandControlDMContext controlDmc) { |
| return new MIRunControlEventProcessor(connection, controlDmc); |
| } |
| |
| /** @since 4.3 */ |
| protected IEventProcessor createControlEventProcessor() { |
| return new ControlEventProcessor(); |
| } |
| |
| /** |
| * @since 4.1 |
| */ |
| protected void setFeatures(List<String> features) { |
| fFeatures.clear(); |
| fFeatures.addAll(features); |
| } |
| |
| /** |
| * @since 4.1 |
| */ |
| protected GdbCommandTimeoutManager createCommandTimeoutManager(ICommandControl commandControl) { |
| GdbCommandTimeoutManager manager = new GdbCommandTimeoutManager(commandControl); |
| manager.initialize(); |
| return manager; |
| } |
| |
| /** |
| * @since 4.1 |
| */ |
| @ConfinedToDsfExecutor("this.getExecutor()") |
| protected void commandTimedOut(ICommandToken token) { |
| String commandText = token.getCommand().toString(); |
| if (commandText.endsWith("\n")) //$NON-NLS-1$ |
| commandText = commandText.substring(0, commandText.length() - 1); |
| final String errorMessage = String.format("Command '%s' is timed out", commandText); //$NON-NLS-1$ |
| commandFailed(token, STATUS_CODE_COMMAND_TIMED_OUT, errorMessage); |
| |
| // If the timeout occurs while the launch sequence is running |
| // the error will be reported by the launcher's error reporting mechanism. |
| // We need to show the error message only when the session is initialized. |
| if (isInitialized()) { |
| // The session is terminated if a command is timed out. |
| terminate(new RequestMonitor(getExecutor(), null) { |
| |
| @Override |
| protected void handleErrorOrWarning() { |
| GdbPlugin.getDefault().getLog().log(getStatus()); |
| super.handleErrorOrWarning(); |
| }; |
| } ); |
| |
| IStatus status = new Status( |
| IStatus.ERROR, |
| GdbPlugin.PLUGIN_ID, |
| IGdbDebugConstants.STATUS_HANDLER_CODE, |
| String.format( Messages.GDBControl_Session_is_terminated, errorMessage ), |
| null); |
| IStatusHandler statusHandler = DebugPlugin.getDefault().getStatusHandler(status); |
| if (statusHandler != null) { |
| try { |
| statusHandler.handleStatus(status, null); |
| } |
| catch(CoreException e) { |
| GdbPlugin.getDefault().getLog().log(e.getStatus()); |
| } |
| } |
| } |
| } |
| |
| /** |
| * Parse output from GDB to determine if the connection to the remote was lost. |
| * |
| * @param output The output received from GDB that must be parsed |
| * to determine if the connection to the remote was lost. |
| * |
| * @return True if the connection was lost, false otherwise. |
| * @since 4.3 |
| */ |
| protected boolean verifyConnectionLost(MIOutput output) { |
| boolean connectionLost = false; |
| String reason = null; |
| |
| // Check if any command has a result that indicates a lost connection. |
| // This can happen as a normal command result, or as an out-of-band event. |
| // The out-of-band case can happen when GDB sends another response to |
| // a previous command. This case can happen, for example, in all-stop |
| // when sending an -exec-continue and then killing gdbserver while connected |
| // to a process; in that case a second result to -exec-continue will be sent |
| // and will indicate the remote connection is closed. |
| MIResultRecord rr = output.getMIResultRecord(); |
| if (rr != null) { |
| String state = rr.getResultClass(); |
| if ("error".equals(state)) { //$NON-NLS-1$ |
| MIResult[] results = rr.getMIResults(); |
| for (MIResult result : results) { |
| String var = result.getVariable(); |
| if (var.equals("msg")) { //$NON-NLS-1$ |
| MIValue value = result.getMIValue(); |
| if (value instanceof MIConst) { |
| String str = ((MIConst)value).getCString(); |
| if (str != null && str.startsWith("Remote connection closed")) { //$NON-NLS-1$ |
| connectionLost = true; |
| reason = str; |
| } |
| } |
| } |
| } |
| } |
| } else { |
| // Only check for out-of-band records when there is no result record. |
| // This is because OOBRecords that precede a result are included in the |
| // result output even though they have already been processed. To avoid |
| // processing them a second time, we only handle them when not dealing |
| // with a result record. |
| for (MIOOBRecord oobr : output.getMIOOBRecords()) { |
| if (oobr instanceof MIConsoleStreamOutput) { |
| MIConsoleStreamOutput out = (MIConsoleStreamOutput) oobr; |
| String str = out.getString(); |
| if (str != null && str.startsWith("Ending remote debugging")) { //$NON-NLS-1$ |
| // This happens if the user types 'disconnect' in the console |
| connectionLost = true; |
| reason = str; |
| break; |
| |
| // Note that this will not trigger in the case where a |
| // -target-disconnect is used. This is a case that CDT handles |
| // explicitly as it is an MI command; we shouldn't have to catch it here. |
| // In fact, catching it here and terminating the session would break |
| // the workaround for GDB 7.2 handled by GDBProcesses_7_2.needFixForGDB72Bug352998() |
| } |
| } else if (oobr instanceof MILogStreamOutput) { |
| MILogStreamOutput out = (MILogStreamOutput) oobr; |
| String str = out.getString().trim(); |
| if (str != null && str.startsWith("Remote connection closed")) { //$NON-NLS-1$ |
| // This happens if gdbserver is killed or dies |
| connectionLost = true; |
| reason = str; |
| break; |
| } |
| } |
| } |
| } |
| |
| if (connectionLost) { |
| connectionLost(reason); |
| return true; |
| } |
| |
| return false; |
| } |
| |
| /** |
| * Handle the loss of the connection to the remote. |
| * The default implementation terminates the debug session. |
| * |
| * @param reason A string indicating as much as possible why the connection was lost. Can be null. |
| * @since 4.3 |
| */ |
| protected void connectionLost(String reason) { |
| terminate(new ImmediateRequestMonitor() { |
| @Override |
| protected void handleErrorOrWarning() { |
| GdbPlugin.getDefault().getLog().log(getStatus()); |
| super.handleErrorOrWarning(); |
| }; |
| }); |
| } |
| |
| /** |
| * @since 4.1 |
| */ |
| protected boolean isInitialized() { |
| return fInitialized; |
| } |
| |
| /** |
| * Returns the time (in seconds) the debugger will wait for "gdb-exit" to complete. |
| * |
| * @since 4.2 |
| */ |
| protected int getGDBExitWaitTime() { |
| return 2; |
| } |
| } |
