Example #1
0
        public void Send(IDebugEvent2 eventObject, string iidEvent, IDebugProgram2 program, IDebugThread2 thread)
        {
            uint attributes;
            var  riidEvent = new Guid(iidEvent);

            EngineUtils.RequireOk(eventObject.GetAttributes(out attributes));
            EngineUtils.RequireOk(m_ad7Callback.Event(m_engine, null, program, thread, eventObject, ref riidEvent, attributes));
        }
        /// <summary>
        ///     Sends this callback to the specified engine.
        /// </summary>
        /// <param name="callback">The callback.</param>
        /// <param name="engine">The engine.</param>
        /// <param name="eventObject">The event object.</param>
        /// <param name="eventId">The event identifier.</param>
        /// <param name="program">The program.</param>
        /// <param name="thread">The thread.</param>
        public static void Send(this IDebugEventCallback2 callback, MonoEngine engine, IDebugEvent2 eventObject,
                                string eventId, IDebugProgram2 program, IDebugThread2 thread)
        {
            uint attributes;
            var  @event = new Guid(eventId);

            eventObject.GetAttributes(out attributes);
            callback.Event(engine, null, program, thread, eventObject, ref @event, attributes);
        }
Example #3
0
        private void SendInternal(EventModel model)
        {
            uint attributes;
            Guid riidEvent = new Guid(model.IidEvent);

            EngineUtils.RequireOk(model.EventObject.GetAttributes(out attributes));
            EngineUtils.RequireOk(_eventCallback.Event(_engine, null, model.Program, model.Thread, model.EventObject, ref riidEvent, attributes));

            model.Set();
        }
Example #4
0
        public static int Event(this IDebugEventCallback2 callback, IDebugEngine2 engine, IDebugProcess2 process, IDebugProgram2 program, IDebugThread2 thread, DebugEvent debugEvent)
        {
            Contract.Requires <ArgumentNullException>(callback != null, "callback");
            Contract.Requires <ArgumentNullException>(debugEvent != null, "debugEvent");
            Contract.Requires <ArgumentNullException>(engine != null, "engine");

            Guid guid = debugEvent.EventGuid;
            enum_EVENTATTRIBUTES attributes = debugEvent.Attributes;

            return(callback.Event(engine, process, program, thread, debugEvent, ref guid, (uint)attributes));
        }
Example #5
0
        public void Send(IDebugEvent2 eventObject, string iidEvent, IDebugProgram2 program, IDebugThread2 thread)
        {
            uint attributes;
            Guid riidEvent = new Guid(iidEvent);

            if (!(eventObject is AD7OutputDebugStringEvent))
            {
                _engine.Logger.WriteLine("Send Event {0}", eventObject.GetType().Name);
            }
            EngineUtils.RequireOk(eventObject.GetAttributes(out attributes));
            EngineUtils.RequireOk(_eventCallback.Event(_engine, null, program, thread, eventObject, ref riidEvent, attributes));
        }
        /// <summary>
        /// Perform actual send
        /// </summary>
        private void Send(IDebugProcess2 process, IDebugProgram2 program, IDebugThread2 thread, BaseEvent @event)
        {
            var guid = @event.IID;

            DLog.Debug(DContext.VSDebuggerEvent, "DebugEngine Event {0} {1}", @event.GetType().Name, guid);
            var rc = callback.Event(engine, process, program, thread, @event, ref guid, (uint)@event.Attributes);

            if (!ErrorHandler.Succeeded(rc))
            {
                DLog.Error(DContext.VSDebuggerEvent, "DebugEngine Event failed {0}", rc);
            }
        }
Example #7
0
        public int Event(IDebugEngine2 pEngine, IDebugProcess2 pProcess, IDebugProgram2 pProgram,
                         IDebugThread2 pThread, IDebugEvent2 pEvent, ref Guid riidEvent, uint dwAttrib)
        {
            _taskContext.ThrowIfNotOnMainThread();

            _logger.Trace($"Note right of VS: <IN> IDebugEventCallback2 {pEvent.GetType()}");

            var result = _callback.Event(pEngine, pProcess, pProgram, pThread, pEvent,
                                         ref riidEvent, dwAttrib);

            _logger.Trace($"Note right of VS: <OUT> IDebugEventCallback2 {pEvent.GetType()}");

            return(result);
        }
Example #8
0
        internal void Send(IDebugEvent2 eventObject, string iidEvent, IDebugProgram2 program, IDebugThread2 thread)
        {
            uint attributes;
            Guid riidEvent = new Guid(iidEvent);

            EngineUtils.RequireOk(eventObject.GetAttributes(out attributes));

            Debug.WriteLine(String.Format("Sending Event: {0} {1}", eventObject.GetType(), iidEvent));
            try {
                EngineUtils.RequireOk(_events.Event(this, null, program, thread, eventObject, ref riidEvent, attributes));
            } catch (InvalidCastException) {
                // COM object has gone away
            }
        }
Example #9
0
        public int Attach(IDebugProgram2[] rgpPrograms, IDebugProgramNode2[] rgpProgramNodes, uint celtPrograms, IDebugEventCallback2 pCallback, enum_ATTACH_REASON dwReason)
        {
            if (celtPrograms == 0)
            {
                return(VSConstants.S_OK);
            }

            if (pCallback == null)
            {
                throw new ArgumentNullException("pCallback");
            }
            if (rgpPrograms == null || rgpPrograms.Length < celtPrograms)
            {
                throw new ArgumentException();
            }
            if (rgpProgramNodes == null || rgpProgramNodes.Length < celtPrograms)
            {
                throw new ArgumentException();
            }

            if (celtPrograms > 1)
            {
                throw new NotImplementedException();
            }

            if (dwReason != enum_ATTACH_REASON.ATTACH_REASON_LAUNCH)
            {
                throw new NotImplementedException();
            }

            JavaDebugProgram program = rgpProgramNodes[0] as JavaDebugProgram;

            if (program == null)
            {
                throw new NotSupportedException();
            }

            lock (_programs)
            {
                _programs.Add(program);
            }

            DebugEvent @event = new DebugEngineCreateEvent(enum_EVENTATTRIBUTES.EVENT_ASYNCHRONOUS, this);

            pCallback.Event(this, program.GetProcess(), program, null, @event);

            program.InitializeDebuggerChannel(this, pCallback);
            return(VSConstants.S_OK);
        }
        private void CreateAndRegisterXamarinThread(Client.ThreadInfo threadInfo)
        {
            XamarinThread            thread = new XamarinThread(this, threadInfo.Id, threadInfo.Name, threadInfo.Location, _session);
            uint                     attributes;
            Guid                     riidEvent   = new Guid(XamarinThreadCreateEvent.IID);
            IDebugThreadCreateEvent2 evnt        = new XamarinThreadCreateEvent();
            IDebugEvent2             eventObject = evnt as IDebugEvent2;

            if (eventObject.GetAttributes(out attributes) != VisualStudioExtensionConstants.S_OK)
            {
                throw new InvalidOperationException("Failed to create and register a thread. The event object failed to get its attributes");
            }
            if (_eventCallback.Event(_engine, null, _activeProgram, thread, eventObject, ref riidEvent, attributes) != VisualStudioExtensionConstants.S_OK)
            {
                throw new InvalidOperationException("Failed to create and register a thread. The event has not been sent succesfully");
            }
        }
        async Task <int> SendEventAsync(DebugEvent evnt, IGgpDebugProgram program,
                                        IDebugThread2 thread)
        {
            await _taskContext.Factory.SwitchToMainThreadAsync();

            if (((IDebugEvent2)evnt).GetAttributes(out uint attributes) != VSConstants.S_OK)
            {
                Trace.WriteLine($"Could not get event attributes of event ({evnt})");
                return(VSConstants.E_FAIL);
            }

            Guid eventIid = evnt.Iid;

            DebugLogSend(evnt, program, thread, attributes);
            return(_eventCallback.Event(_debugEngine, null, program, thread, evnt, ref eventIid,
                                        attributes));
        }
        private void SendEvaluationCompleteEvent(Task <IDebugProperty2> task, IDebugEventCallback2 callback)
        {
            var thread  = _context.StackFrame.Thread;
            var program = thread.Program;
            var engine  = program.DebugEngine;
            var process = program.Process;

            IDebugProperty2 property;

            if (task != null)
            {
                property = task.Result;
            }
            else
            {
                property = new JavaDebugProperty(null, new EvaluatedExpression("?", "?", default(IValue), false));
            }

            DebugEvent debugEvent = new DebugExpressionEvaluationCompleteEvent(enum_EVENTATTRIBUTES.EVENT_ASYNCHRONOUS, this, property);

            callback.Event(engine, process, program, thread, debugEvent);
        }
Example #13
0
        int IDebugEventCallback2.Event(IDebugEngine2 engine, IDebugProcess2 process, IDebugProgram2 program, IDebugThread2 thread, IDebugEvent2 @event, ref Guid riidEvent, uint attribs)
        {
            IDebugEventCallback2 ad7EventCallback = GetAD7EventCallback();

            return(ad7EventCallback.Event(engine, process, program, thread, @event, ref riidEvent, attribs));
        }
Example #14
0
        /// <summary>
        /// Attach the debug engine to a program. (http://msdn.microsoft.com/en-us/library/bb145136.aspx)
        /// </summary>
        /// <param name="rgpPrograms"> Represent programs to be attached to. These are port programs. </param>
        /// <param name="rgpProgramNodes"> Represent program nodes, one for each program. The program nodes in this array represent 
        /// the same programs as in pProgram. The program nodes are given so that the DE can identify the programs to attach to. </param>
        /// <param name="aCeltPrograms"> Number of programs and/or program nodes in the pProgram and rgpProgramNodes arrays. </param>
        /// <param name="ad7Callback"> The IDebugEventCallback2 object to be used to send debug events to the SDM. </param>
        /// <param name="dwReason">  A value from the ATTACH_REASON enumeration that specifies the reason for attaching these programs. </param>
        /// <returns> If successful, returns S_OK; otherwise, returns an error code. </returns>
        int IDebugEngine2.Attach(IDebugProgram2[] rgpPrograms, IDebugProgramNode2[] rgpProgramNodes, uint aCeltPrograms, IDebugEventCallback2 ad7Callback, enum_ATTACH_REASON dwReason)
        {
            if (aCeltPrograms != 1)
            {
                System.Diagnostics.Debug.Fail("VSNDK Debugger only supports one debug target at a time.");
                throw new ArgumentException();
            }

            try
            {
                EngineUtils.RequireOk(rgpPrograms[0].GetProgramId(out m_programGUID));

                m_program = rgpPrograms[0];

                // It is NULL when the user attached the debugger to a running process (by using Attach to Process UI). When that
                // happens, some objects must be instantiated, as well as GDB must be launched. Those ones are instantiated/launched
                // by LaunchSuspended and ResumeProcess methods when debugging an open project.
                if (this.m_engineCallback == null)
                {
                    VSNDK.Package.ControlDebugEngine.isDebugEngineRunning = true;
                    m_engineCallback = new EngineCallback(this, ad7Callback);

                    AD7ProgramNodeAttach pnt = (AD7ProgramNodeAttach)m_program;
                    m_process = pnt.m_process;
                    AD7Port port = pnt.m_process._portAttach;
                    string publicKeyPath = Environment.GetEnvironmentVariable("AppData") + @"\BlackBerry\bbt_id_rsa.pub";
                    string progName = pnt.m_programName.Substring(pnt.m_programName.LastIndexOf('/') + 1);

                    string exePath = "";
                    string processesPaths = "";
                    System.IO.StreamReader readProcessesPathsFile = null;
                    // Read the file ProcessesPath.txt to try to get the file location of the executable file.
                    try
                    {
                        readProcessesPathsFile = new System.IO.StreamReader(System.Environment.GetFolderPath(Environment.SpecialFolder.LocalApplicationData) + @"\Research In Motion\ProcessesPath.txt");
                        processesPaths = readProcessesPathsFile.ReadToEnd();
                        readProcessesPathsFile.Close();
                    }
                    catch (Exception e)
                    {
                        processesPaths = "";
                    }

                    string searchProgName = progName + "_" + port.m_isSimulator;
                    int begin = processesPaths.IndexOf(searchProgName + ":>");

                    if (begin != -1)
                    {
                        begin += searchProgName.Length + 2;
                        int end = processesPaths.IndexOf("\r\n", begin);

                        exePath = processesPaths.Substring(begin, end - begin) + progName;
                    }
                    else
                    {
                        exePath = "CannotAttachToRunningProcess";
                    }

                    exePath = exePath.Replace("\\", "\\\\\\\\");

                    if (GDBParser.LaunchProcess(pnt.m_programID, exePath, port.m_IP, port.m_isSimulator, port.m_toolsPath, publicKeyPath, port.m_password))
                    {
                        if (exePath == "CannotAttachToRunningProcess")
                        {
                            MessageBox.Show(progName + " is attached to the debugger. However, to be able to debug your application, you must build and deploy it from this computer first.", "No executable file with symbols found.", MessageBoxButtons.OK, MessageBoxIcon.Warning);
                        }
                        m_eventDispatcher = new EventDispatcher(this);
                        m_module = new AD7Module();
                        m_progNode = new AD7ProgramNode(m_process._processGUID, m_process._processID, exePath, new Guid(AD7Engine.Id));
                        AddThreadsToProgram();
                    }
                    else
                    {
                        GDBParser.exitGDB();
                        VSNDK.Package.ControlDebugEngine.isDebugEngineRunning = false;
                        return VSConstants.E_FAIL;
                    }
                }
                AD7EngineCreateEvent.Send(this);
                AD7ProgramCreateEvent.Send(this);
                AD7ModuleLoadEvent.Send(this, m_module, true);
                AD7LoadCompleteEvent.Send(this, currentThread());

                // If the reason for attaching is ATTACH_REASON_LAUNCH, the DE needs to send the IDebugEntryPointEvent2 event.
                // See http://msdn.microsoft.com/en-us/library/bb145136%28v=vs.100%29.aspx
                if (dwReason == enum_ATTACH_REASON.ATTACH_REASON_LAUNCH)
                {
                    AD7EntryPointEvent ad7Event = new AD7EntryPointEvent();
                    Guid riidEvent = new Guid(AD7EntryPointEvent.IID);
                    uint attributes = (uint)enum_EVENTATTRIBUTES.EVENT_STOPPING | (uint)enum_EVENTATTRIBUTES.EVENT_SYNCHRONOUS;
                    int rc = ad7Callback.Event(this, null, m_program, currentThread(), ad7Event, ref riidEvent, attributes);
                    Debug.Assert(rc == VSConstants.S_OK);
                }
            }
            catch (Exception e)
            {
                return EngineUtils.UnexpectedException(e);
            }
            return VSConstants.S_OK;
        }
Example #15
0
        public int Attach(IDebugProgram2[] rgpPrograms, IDebugProgramNode2[] rgpProgramNodes, uint celtPrograms, IDebugEventCallback2 pCallback, enum_ATTACH_REASON dwReason)
        {
            if (celtPrograms == 0)
                return VSConstants.S_OK;

            if (pCallback == null)
                throw new ArgumentNullException("pCallback");
            if (rgpPrograms == null || rgpPrograms.Length < celtPrograms)
                throw new ArgumentException();
            if (rgpProgramNodes == null || rgpProgramNodes.Length < celtPrograms)
                throw new ArgumentException();

            if (celtPrograms > 1)
                throw new NotImplementedException();

            if (dwReason != enum_ATTACH_REASON.ATTACH_REASON_LAUNCH)
                throw new NotImplementedException();

            JavaDebugProgram program = rgpProgramNodes[0] as JavaDebugProgram;
            if (program == null)
                throw new NotSupportedException();

            lock (_programs)
            {
                _programs.Add(program);
            }

            DebugEvent @event = new DebugEngineCreateEvent(enum_EVENTATTRIBUTES.EVENT_ASYNCHRONOUS, this);
            pCallback.Event(this, program.GetProcess(), program, null, @event);

            program.InitializeDebuggerChannel(this, pCallback);
            return VSConstants.S_OK;
        }
Example #16
0
        public void EngineCreated()
        {
            Debug.WriteLine("Event EngineCreated");
            Guid iid = new Guid(EngineCreateEvent.IID);

            _callback.Event(_engine, null, null, null, new EngineCreateEvent(_engine), ref iid, EngineCreateEvent.Attributes);
        }
        /// <summary>
        /// Fires the event notifying the SDM that the debug engine has loaded.
        /// </summary>
        public void EngineCreated()
        {
            Log.Debug("EngineCreated");
            var iid = new Guid(EngineCreateEvent.IID);

            _callback.Event(_engine, null, null, null, new EngineCreateEvent(_engine), ref iid, EngineCreateEvent.Attributes);
        }
 public void OnProgramDestroyed(IDebugProgram2 program, uint exitCode)
 {
     _callback.Event(_engine, null, program, null, new DebugEventProgramDestory(exitCode), ref DebugEventProgramDestory.ID, DebugEventProgramDestory.Attributes);
 }
Example #19
0
        // Attach the debug engine to a program.
        int IDebugEngine2.Attach(IDebugProgram2[] rgpPrograms, IDebugProgramNode2[] rgpProgramNodes, uint aCeltPrograms, IDebugEventCallback2 ad7Callback, enum_ATTACH_REASON dwReason)
        {
            // Attach the debug engine to a program.
            //
            // Attach can either be called to attach to a new process, or to complete an attach
            // to a launched process.
            // So could we simplify and move code from LaunchSuspended to here and maybe even
            // eliminate the debughost? Although I supposed DebugHost has some other uses as well.

            if (aCeltPrograms != 1)
            {
                System.Diagnostics.Debug.Fail("Cosmos Debugger only supports one debug target at a time.");
                throw new ArgumentException();
            }

            try
            {
                EngineUtils.RequireOk(rgpPrograms[0].GetProgramId(out m_programGUID));

                m_program = rgpPrograms[0];
                AD7EngineCreateEvent.Send(this);
                AD7ProgramCreateEvent.Send(this);
                AD7ModuleLoadEvent.Send(this, m_module, true);

                // Dummy main thread
                // We dont support threads yet, but the debugger expects threads.
                // So we create a dummy object to represente our only "thread".
            //                m_thread = m_process._threads;
            //                m_thread = new AD7Thread(this, m_process);
                AD7LoadCompleteEvent.Send(this, currentThread());

                // If the reason for attaching is ATTACH_REASON_LAUNCH, the DE needs to send the IDebugEntryPointEvent2 event.
                // See http://msdn.microsoft.com/en-us/library/bb145136%28v=vs.100%29.aspx
                if (dwReason == enum_ATTACH_REASON.ATTACH_REASON_LAUNCH)
                {
                    AD7EntryPointEvent ad7Event = new AD7EntryPointEvent();
                    Guid riidEvent = new Guid(AD7EntryPointEvent.IID);
                    uint attributes = (uint)enum_EVENTATTRIBUTES.EVENT_STOPPING | (uint)enum_EVENTATTRIBUTES.EVENT_SYNCHRONOUS;
                    int rc = ad7Callback.Event(this, null, m_program, currentThread(), ad7Event, ref riidEvent, attributes);
                    Debug.Assert(rc == VSConstants.S_OK);
                }
            }
            catch (Exception e)
            {
                return EngineUtils.UnexpectedException(e);
            }
            return VSConstants.S_OK;
        }
Example #20
0
        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

        #region DebugEngineCallbackInterface Members

        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

        public int Event(IDebugEngine2 pEngine, IDebugProcess2 pProcess, IDebugProgram2 pProgram, IDebugThread2 pThread, IDebugEvent2 pEvent, ref Guid riidEvent, uint dwAttrib)
        {
            LoggingUtils.Print("[DebugEngineCallback] Event: " + riidEvent.ToString());

            //
            // Process any registered function handler before passing the event to AD7 callback.
            //

            int handle = Constants.E_NOTIMPL;

            try
            {
                DebuggerEventDelegate eventCallback;

                if (m_debuggerCallback.TryGetValue(riidEvent, out eventCallback))
                {
                    handle = eventCallback(pEngine, pProcess, pProgram, pThread, pEvent, ref riidEvent, dwAttrib);
                }

                if (handle != Constants.E_NOTIMPL)
                {
                    LoggingUtils.RequireOk(handle);
                }
            }
            catch (Exception e)
            {
                LoggingUtils.HandleException(e);

                throw;
            }
            finally
            {
                try
                {
                    handle = m_ad7EventCallback.Event(pEngine, pProcess, pProgram, pThread, pEvent, ref riidEvent, dwAttrib);

                    if (handle != Constants.E_NOTIMPL)
                    {
                        LoggingUtils.RequireOk(handle);
                    }
                }
                catch (Exception e)
                {
                    LoggingUtils.HandleException(e);

                    throw;
                }
            }

            //
            // (Managed Code) It is strongly advised that ReleaseComObject be invoked on the various interfaces that are passed to IDebugEventCallback2::Event.
            //

#if false
            Marshal.ReleaseComObject(pEngine);

            Marshal.ReleaseComObject(pProcess);

            Marshal.ReleaseComObject(pProgram);

            Marshal.ReleaseComObject(pThread);

            Marshal.ReleaseComObject(pEvent);
#endif

            return(handle);
        }
Example #21
0
 private void Send(IDebugEvent2 eventObject, Guid eventGuid)
 {
     ErrorHandler.ThrowOnFailure(eventObject.GetAttributes(out var attributes));
     ErrorHandler.ThrowOnFailure(_ad7Callback.Event(
                                     _engine, _process, _program, _program, eventObject, eventGuid, attributes));
 }
Example #22
0
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

    public void Broadcast (IDebugEventCallback2 callback, IDebugEvent2 debugEvent, IDebugProgram2 program, IDebugThread2 thread)
    {
      LoggingUtils.PrintFunction ();

      if (callback == null)
      {
        throw new ArgumentNullException ("callback");
      }

      Guid eventGuid = ComUtils.GuidOf (debugEvent);

      uint eventAttributes = 0;

      LoggingUtils.RequireOk (debugEvent.GetAttributes (out eventAttributes));

      if (((eventAttributes & (uint) enum_EVENTATTRIBUTES.EVENT_STOPPING) != 0) && (thread == null))
      {
        throw new ArgumentNullException ("thread", "For stopping events, this parameter cannot be a null value as the stack frame is obtained from this parameter.");
      }

      try
      {
        int handle = callback.Event (this, null, program, thread, debugEvent, ref eventGuid, eventAttributes);

        if (handle != Constants.E_NOTIMPL)
        {
          LoggingUtils.RequireOk (handle);
        }
      }
      catch (Exception e)
      {
        LoggingUtils.HandleException (e);

        throw;
      }
      finally
      {
        if ((eventAttributes & (uint) enum_EVENTATTRIBUTES.EVENT_SYNCHRONOUS) != 0)
        {
          while (!m_broadcastHandleLock.WaitOne (0))
          {
            Thread.Sleep (100);
          }
        }
      }
    }
Example #23
0
        private void SendEvaluationCompleteEvent(Task<IDebugProperty2> task, IDebugEventCallback2 callback)
        {
            var thread = _context.StackFrame.Thread;
            var program = thread.Program;
            var engine = program.DebugEngine;
            var process = program.Process;

            IDebugProperty2 property;
            if (task != null)
                property = task.Result;
            else
                property = new JavaDebugProperty(null, new EvaluatedExpression("?", "?", default(IValue), false));

            DebugEvent debugEvent = new DebugExpressionEvaluationCompleteEvent(enum_EVENTATTRIBUTES.EVENT_ASYNCHRONOUS, this, property);
            callback.Event(engine, process, program, thread, debugEvent);
        }