Example #1
0
 public ManagedCallbackData(ManagedCallbackFunction func, CommandResult result)
 {
     this.Func = func;
     this.Result = result;
 }
Example #2
0
        public bool ManagedCallback(ManagedCallbackFunction func, CommandResult result)
        {
            ManagedCallbackData data = new ManagedCallbackData (func, result);

            return (bool) SendCommand (delegate {
                Report.Debug (DebugFlags.SSE, "{0} starting managed callback: {1}", this, func);

                AcquireThreadLock ();

                if (is_managed_frame ()) {
                    //
                    // We found a managed frame; now let's first check whether we can do
                    // all the work without starting an operation.
                    //
                    OperationManagedCallback omc = new OperationManagedCallback (this, data);
                    if (omc.Run ())
                        return false;

                    //
                    // Ok, we're done -> return to the user.
                    //

                    ReleaseThreadLock ();
                    return true;
                }

                //
                // Stop all threads and check whether one of them is in managed land.
                //

                Report.Debug (DebugFlags.SSE, "{0} managed callback needs global thread lock", this);

                bool ok = false;
                process.AcquireGlobalThreadLock (this);
                foreach (SingleSteppingEngine engine in process.ThreadServants) {
                    try {
                        if (engine.is_managed_frame ()) {
                            ok = true;
                            break;
                        }
                    } catch (Exception ex) {
                        Console.WriteLine ("F**K: {0} {1}", engine, ex);
                    }
                }

                if (!ok) {
                    //
                    // None of the threads is currently in managed land; request a managed
                    // callback.
                    //
                    request_managed_callback (data);
                }

                Report.Debug (DebugFlags.SSE, "{0} managed callback releasing global thread lock", this);
                process.ReleaseGlobalThreadLock (this);

                ReleaseThreadLock ();

                Report.Debug (DebugFlags.SSE, "{0} managed callback done: {1} {2}", this, data.Running, data.Completed);
                return false;
            });
        }