コード例 #1
0
ファイル: TypeTests.cs プロジェクト: WillVan/clrmd
        public void AsEnumTest()
        {
            using DataTarget dt      = TestTargets.Types.LoadFullDump();
            using ClrRuntime runtime = dt.ClrVersions.Single().CreateRuntime();

            ClrModule typesModule = runtime.GetModule(ModuleName);
            ClrType   type        = typesModule.GetTypeByName("Types");

            ClrStaticField field = type.GetStaticFieldByName("s_enum");

            Assert.True(field.Type.IsEnum);

            ClrEnum clrEnum = field.Type.AsEnum();

            Assert.NotNull(clrEnum);

            string[] propertyNames = clrEnum.GetEnumNames().ToArray();
            Assert.NotEmpty(propertyNames);
            Assert.Contains(nameof(FileAccess.Read), propertyNames);
            Assert.Contains(nameof(FileAccess.Write), propertyNames);
            Assert.Contains(nameof(FileAccess.ReadWrite), propertyNames);

            Assert.Equal(ClrElementType.Int32, clrEnum.ElementType);

            Assert.Equal(FileAccess.Read, clrEnum.GetEnumValue <FileAccess>(nameof(FileAccess.Read)));
            Assert.Equal(FileAccess.Write, clrEnum.GetEnumValue <FileAccess>(nameof(FileAccess.Write)));
            Assert.Equal(FileAccess.ReadWrite, clrEnum.GetEnumValue <FileAccess>(nameof(FileAccess.ReadWrite)));
        }
コード例 #2
0
        public void NoTypeCachingTest()
        {
            using DataTarget dt            = TestTargets.Types.LoadFullDump();
            dt.CacheOptions.CacheTypes     = false;
            dt.CacheOptions.CacheTypeNames = StringCaching.None;

            using ClrRuntime runtime = dt.ClrVersions.Single().CreateRuntime();
            ClrModule module = runtime.GetModule("sharedlibrary.dll");
            ClrType   type   = module.GetTypeByName("Foo");

            Assert.NotEqual(0ul, type.MethodTable);  // Sanity test

            ClrType type2 = runtime.GetTypeByMethodTable(type.MethodTable);

            Assert.Equal(type, type2);
            Assert.NotSame(type, type2);

            Assert.NotNull(type.Name);
            Assert.Equal(type.Name, type.Name);
            Assert.NotSame(type.Name, type.Name);

            dt.CacheOptions.CacheTypeNames = StringCaching.Intern;
            Assert.Same(type.Name, type.Name);
            Assert.Same(type.Name, string.Intern(type.Name));
        }
コード例 #3
0
ファイル: MethodTests.cs プロジェクト: lhutyra/clrmd
        public void MethodHandleMultiDomainTests()
        {
            ulong[] methodDescs;
            using (DataTarget dt = TestTargets.AppDomains.LoadFullDump())
            {
                ClrRuntime runtime = dt.ClrVersions.Single().CreateRuntime();

                ClrModule module = runtime.GetModule("sharedlibrary.dll");
                ClrType   type   = module.GetTypeByName("Foo");
                ClrMethod method = type.GetMethod("Bar");
                methodDescs = method.EnumerateMethodDescs().ToArray();

                Assert.Equal(2, methodDescs.Length);
            }

            using (DataTarget dt = TestTargets.AppDomains.LoadFullDump())
            {
                ClrRuntime runtime = dt.ClrVersions.Single().CreateRuntime();
                ClrMethod  method  = runtime.GetMethodByHandle(methodDescs[0]);

                Assert.NotNull(method);
                Assert.Equal("Bar", method.Name);
                Assert.Equal("Foo", method.Type.Name);
            }

            using (DataTarget dt = TestTargets.AppDomains.LoadFullDump())
            {
                ClrRuntime runtime = dt.ClrVersions.Single().CreateRuntime();
                ClrMethod  method  = runtime.GetMethodByHandle(methodDescs[1]);

                Assert.NotNull(method);
                Assert.Equal("Bar", method.Name);
                Assert.Equal("Foo", method.Type.Name);
            }
        }
コード例 #4
0
        public void TestGetTypeByName()
        {
            using (DataTarget dt = TestTargets.Types.LoadFullDump())
            {
                ClrRuntime runtime = dt.ClrVersions.Single().CreateRuntime();
                ClrHeap    heap    = runtime.Heap;

                ClrModule shared = runtime.GetModule("sharedlibrary.dll");
                Assert.NotNull(shared.GetTypeByName("Foo"));
                Assert.Null(shared.GetTypeByName("Types"));

                ClrModule types = runtime.GetModule("types.exe");
                Assert.NotNull(types.GetTypeByName("Types"));
                Assert.Null(types.GetTypeByName("Foo"));
            }
        }
コード例 #5
0
        public void NoFieldCachingTest()
        {
            using DataTarget dt             = TestTargets.Types.LoadFullDump();
            dt.CacheOptions.CacheFields     = false;
            dt.CacheOptions.CacheFieldNames = StringCaching.None;

            using ClrRuntime runtime = dt.ClrVersions.Single().CreateRuntime();
            ClrModule module = runtime.GetModule("sharedlibrary.dll");
            ClrType   type   = module.GetTypeByName("Foo");

            Assert.NotEqual(0ul, type.MethodTable);  // Sanity test

            Assert.NotSame(type.Fields, type.Fields);

            ClrField field  = type.GetFieldByName("o");
            ClrField field2 = type.Fields.Single(f => f.Name == "o");

            Assert.NotSame(field, field2);
            Assert.NotSame(field.Name, field.Name);

            dt.CacheOptions.CacheFieldNames = StringCaching.Intern;

            Assert.Same(field.Name, field.Name);
            Assert.Same(field.Name, string.Intern(field.Name));
        }
コード例 #6
0
        public void MethodCachingTest()
        {
            // Test that when we cache method names they are not re-read
            using DataTarget dt          = TestTargets.Types.LoadFullDump();
            dt.CacheOptions.CacheMethods = true;

            // We want to make sure we are getting the same string because it was cached,
            // not because it was interned
            dt.CacheOptions.CacheMethodNames = StringCaching.Cache;

            using ClrRuntime runtime = dt.ClrVersions.Single().CreateRuntime();
            ClrModule module = runtime.GetModule("sharedlibrary.dll");
            ClrType   type   = module.GetTypeByName("Foo");
            ClrMethod method = type.GetMethod("Bar");

            Assert.NotEqual(0ul, method.MethodDesc);  // Sanity test

            ClrMethod method2 = type.GetMethod("Bar");

            Assert.Equal(method, method2);
            Assert.Same(method, method2);


            string signature1 = method.Signature;
            string signature2 = method2.Signature;

            Assert.NotNull(signature1);
            Assert.Equal(signature1, signature2);

            Assert.Equal(signature1, method.Signature);
            Assert.Same(signature1, method.Signature);
        }
コード例 #7
0
ファイル: TypeTests.cs プロジェクト: southpolenator/clrmd
        public void TypeEqualityTest()
        {
            // This test ensures that only one ClrType is created when we have a type loaded into two different AppDomains with two different
            // method tables.

            const string TypeName = "Foo";

            using (DataTarget dt = TestTargets.AppDomains.LoadFullDump())
            {
                ClrRuntime runtime = dt.ClrVersions.Single().CreateRuntime();
                ClrHeap    heap    = runtime.Heap;

                ClrType[] types = (from obj in heap.EnumerateObjectAddresses()
                                   let t = heap.GetObjectType(obj)
                                           where t.Name == TypeName
                                           select t).ToArray();

                Assert.Equal(2, types.Length);
                Assert.NotSame(types[0], types[1]);

                ClrModule module         = runtime.Modules.Single(m => Path.GetFileName(m.FileName).Equals("sharedlibrary.dll", StringComparison.OrdinalIgnoreCase));
                ClrType   typeFromModule = module.GetTypeByName(TypeName);

                Assert.Equal(TypeName, typeFromModule.Name);
                Assert.Equal(types[0], typeFromModule);
            }
        }
コード例 #8
0
ファイル: TypeTests.cs プロジェクト: WillVan/clrmd
        public void IntegerObjectClrType()
        {
            using DataTarget dt      = TestTargets.Types.LoadFullDump();
            using ClrRuntime runtime = dt.ClrVersions.Single().CreateRuntime();
            ClrHeap heap = runtime.Heap;

            ClrModule      module    = runtime.GetModule(ModuleName);
            ClrType        typesType = module.GetTypeByName("Types");
            ClrStaticField field     = typesType.GetStaticFieldByName("s_i");

            ClrObject obj = field.ReadObject();

            Assert.False(obj.IsNull);

            ClrType type = obj.Type;

            Assert.NotNull(type);

            Assert.True(type.IsPrimitive);
            Assert.False(type.IsObjectReference);
            Assert.False(type.IsValueType);

            var fds = obj.Type.Fields;

            int value = obj.ReadBoxed <int>();

            Assert.Equal(42, value);

            Assert.Contains(obj.Address, heap.EnumerateObjects().Select(a => a.Address));
        }
コード例 #9
0
ファイル: GCRootTests.cs プロジェクト: WillVan/clrmd
        private static void GetKnownSourceAndTarget(ClrHeap heap, out ulong source, out ulong target)
        {
            ClrModule module   = heap.Runtime.GetMainModule();
            ClrType   mainType = module.GetTypeByName("GCRootTarget");

            source = mainType.GetStaticObjectValue("TheRoot").Address;
            target = heap.GetObjectsOfType("TargetType").Single();
        }
コード例 #10
0
        private int GetClrModuleTypeByName(Tuple <int, ulong, string> input)
        {
            int        runtimeId  = input.Item1;
            ulong      imageBase  = input.Item2;
            string     typeName   = input.Item3;
            ClrRuntime clrRuntime = runtimesCache[runtimeId];
            ClrModule  clrModule  = clrRuntime.Modules.FirstOrDefault(m => m.ImageBase == imageBase);

            return(GetClrTypeId(clrModule.GetTypeByName(typeName)));
        }
コード例 #11
0
ファイル: MethodTests.cs プロジェクト: lhutyra/clrmd
        public void CompleteSignatureIsRetrievedForMethodsWithGenericParameters()
        {
            using DataTarget dt = TestTargets.AppDomains.LoadFullDump();
            ClrRuntime runtime = dt.ClrVersions.Single().CreateRuntime();

            ClrModule module = runtime.GetModule("sharedlibrary.dll");
            ClrType   type   = module.GetTypeByName("Foo");

            ClrMethod genericMethod = type.GetMethod("GenericBar");

            string methodName = genericMethod.GetFullSignature();

            Assert.Equal(')', methodName.Last());
        }
コード例 #12
0
ファイル: TypeTests.cs プロジェクト: mikem8361/clrmd
        public void TestTypeModifiers()
        {
            using DataTarget dt      = TestTargets.NestedTypes.LoadFullDump();
            using ClrRuntime runtime = dt.ClrVersions.Single().CreateRuntime();

            ClrModule module  = runtime.GetModule(NestedTypesModuleName);
            ClrType   program = module.GetTypeByName("Program");

            Assert.True(program.IsPublic);
            Assert.False(program.IsAbstract);
            Assert.False(program.IsSealed);

            ClrType publicClass = module.GetTypeByName("Program+PublicClass");

            Assert.True(publicClass.IsPublic);

            ClrType privateClass = module.GetTypeByName("Program+PrivateClass");

            Assert.True(privateClass.IsPrivate);

            ClrType internalClass = module.GetTypeByName("Program+InternalClass");

            Assert.True(internalClass.IsInternal);

            ClrType protectedClass = module.GetTypeByName("Program+ProtectedClass");

            Assert.True(protectedClass.IsProtected);

            ClrType abstractClass = module.GetTypeByName("Program+AbstractClass");

            Assert.True(abstractClass.IsAbstract);
            Assert.False(abstractClass.IsSealed);

            ClrType sealedClass = module.GetTypeByName("Program+SealedClass");

            Assert.True(sealedClass.IsSealed);
            Assert.False(sealedClass.IsAbstract);

            ClrType staticClass = module.GetTypeByName("Program+StaticClass");

            Assert.True(staticClass.IsAbstract);
            Assert.True(staticClass.IsSealed);
        }
コード例 #13
0
        private IEnumerable <ThreadPoolItem> EnumerateLocalThreadPoolItemsInNetFramework(ClrModule mscorlib)
        {
            // look into the local stealing queues in each thread TLS
            // hopefully, they are all stored in static (one per app domain) instance
            // of ThreadPoolWorkQueue.SparseArray<ThreadPoolWorkQueue.WorkStealingQueue>
            //
            var queueType = mscorlib.GetTypeByName("System.Threading.ThreadPoolWorkQueue");

            if (queueType == null)
            {
                yield break;
            }

            ClrStaticField threadQueuesField = queueType.GetStaticFieldByName("allThreadQueues");

            if (threadQueuesField == null)
            {
                yield break;
            }

            foreach (ClrAppDomain domain in _clr.AppDomains)
            {
                var threadQueue = threadQueuesField.ReadObject(domain);
                if (!threadQueue.IsValid)
                {
                    continue;
                }

                var sparseArray = threadQueue.ReadObjectField("m_array").AsArray();
                for (int current = 0; current < sparseArray.Length; current++)
                {
                    var stealingQueue = sparseArray.GetObjectValue(current);
                    if (!stealingQueue.IsValid)
                    {
                        continue;
                    }

                    foreach (var item in EnumerateThreadPoolStealingQueue(stealingQueue))
                    {
                        yield return(item);
                    }
                }
            }
        }
コード例 #14
0
ファイル: ClrDelegateTests.cs プロジェクト: mikem8361/clrmd
        public void GetDelegateTest()
        {
            using DataTarget dt      = TestTargets.Types.LoadFullDump();
            using ClrRuntime runtime = dt.ClrVersions.Single().CreateRuntime();
            ClrModule typesModule = runtime.GetModule(TypeTests.ModuleName);
            ClrType   Types       = typesModule.GetTypeByName("Types");

            ClrDelegate TestDelegate = Types.GetStaticFieldByName("TestDelegate").ReadObject(runtime.AppDomains.Single()).AsDelegate();

            ClrDelegateTarget delegateTarget = TestDelegate.GetDelegateTarget();

            Assert.NotNull(delegateTarget);
            CompareToInner(Types, TestDelegate, delegateTarget);

            ClrDelegate       TestEvent   = Types.GetStaticFieldByName("TestEvent").ReadObject(runtime.AppDomains.Single()).AsDelegate();
            ClrDelegateTarget eventTarget = TestEvent.GetDelegateTarget();

            Assert.Null(eventTarget);
        }
コード例 #15
0
ファイル: GCRootTests.cs プロジェクト: WillVan/clrmd
        public void EnumerateGCRefsArray()
        {
            using DataTarget dataTarget = TestTargets.GCRoot.LoadFullDump();
            using ClrRuntime runtime    = dataTarget.ClrVersions.Single().CreateRuntime();
            ClrHeap heap = runtime.Heap;

            ClrModule module   = heap.Runtime.GetMainModule();
            ClrType   mainType = module.GetTypeByName("GCRootTarget");

            ClrObject obj = mainType.GetStaticObjectValue("TheRoot");

            obj = obj.GetObjectField("Item1");

            Assert.Equal("System.Object[]", obj.Type.Name);

            ClrObject[] refs = obj.EnumerateReferences(false).ToArray();
            Assert.Single(refs);
            Assert.Equal("DoubleRef", refs[0].Type.Name);
        }
コード例 #16
0
        /// <summary>
        /// Gets the type with the specified name.
        /// </summary>
        /// <param name="name">The CLR type name.</param>
        private CodeType GetClrTypeByName(string name)
        {
            try
            {
                // Try to find code type inside CLR module
                var clrType = ClrModule.GetTypeByName(name);

                if (clrType != null)
                {
                    // Create a code type
                    return(ClrTypes[clrType]);
                }
            }
            catch (Exception)
            {
            }

            return(null);
        }
コード例 #17
0
ファイル: ClrDelegateTests.cs プロジェクト: mikem8361/clrmd
        public void IsDelegateTest()
        {
            using DataTarget dt      = TestTargets.Types.LoadFullDump();
            using ClrRuntime runtime = dt.ClrVersions.Single().CreateRuntime();
            ClrModule typesModule = runtime.GetModule(TypeTests.ModuleName);
            ClrType   type        = typesModule.GetTypeByName("Types");

            ClrObject TestDelegate = type.GetStaticFieldByName("TestDelegate").ReadObject(runtime.AppDomains.Single());

            Assert.True(TestDelegate.IsValid);
            Assert.True(TestDelegate.IsDelegate);
            Assert.False(TestDelegate.AsDelegate().HasMultipleTargets);

            ClrObject TestEvent = type.GetStaticFieldByName("TestEvent").ReadObject(runtime.AppDomains.Single());

            Assert.True(TestEvent.IsValid);
            Assert.True(TestEvent.IsDelegate);
            Assert.True(TestEvent.AsDelegate().HasMultipleTargets);
        }
コード例 #18
0
        // The ThreadPool is keeping track of the pending work items into two different areas:
        // - a global queue: stored by ThreadPoolWorkQueue instances of the ThreadPoolGlobals.workQueue static field
        // - several per thread (TLS) local queues: stored in SparseArray<ThreadPoolWorkQueue+WorkStealingQueue> linked from ThreadPoolWorkQueue.allThreadQueues static fields
        // both are using arrays of Task or QueueUserWorkItemCallback
        //
        // NOTE: don't show other thread pool related topics such as timer callbacks or wait objects
        //
        private IEnumerable <ThreadPoolItem> EnumerateGlobalThreadPoolItemsInNetFramework(ClrModule mscorlib)
        {
            ClrType queueType = mscorlib.GetTypeByName("System.Threading.ThreadPoolGlobals");

            if (queueType == null)
            {
                yield break;
            }

            ClrStaticField workQueueField = queueType.GetStaticFieldByName("workQueue");

            if (workQueueField == null)
            {
                yield break;
            }

            // the CLR keeps one static instance per application domain
            foreach (var appDomain in _clr.AppDomains)
            {
                var workQueue = workQueueField.ReadObject(appDomain);
                if (!workQueue.IsValid)
                {
                    continue;
                }

                // should be  System.Threading.ThreadPoolWorkQueue
                var workQueueType = workQueue.Type;
                if (workQueueType == null)
                {
                    continue;
                }
                if (string.CompareOrdinal(workQueueType.Name, "System.Threading.ThreadPoolWorkQueue") != 0)
                {
                    continue;
                }

                foreach (var item in EnumerateThreadPoolWorkQueue(workQueue))
                {
                    yield return(item);
                }
            }
        }
コード例 #19
0
        public void NoMethodCachingTest()
        {
            using DataTarget dt              = TestTargets.Types.LoadFullDump();
            dt.CacheOptions.CacheMethods     = false;
            dt.CacheOptions.CacheMethodNames = StringCaching.None;

            using ClrRuntime runtime = dt.ClrVersions.Single().CreateRuntime();


            ClrModule module = runtime.GetModule("sharedlibrary.dll");
            ClrType   type   = module.GetTypeByName("Foo");
            ClrMethod method = type.GetMethod("Bar");

            Assert.NotEqual(0ul, method.MethodDesc);  // Sanity test

            ClrMethod method2 = type.GetMethod("Bar");

            Assert.Equal(method, method2);
            Assert.NotSame(method, method2);


            string signature1 = method.Signature;
            string signature2 = method2.Signature;

            Assert.NotNull(signature1);
            Assert.Equal(signature1, signature2);

            Assert.Equal(signature1, method.Signature);
            Assert.NotSame(signature1, method.Signature);
            Assert.NotSame(method2.Signature, method.Signature);

            // Ensure that we can swap this at runtime and that we get interned strings
            dt.CacheOptions.CacheMethodNames = StringCaching.Intern;

            Assert.NotNull(method.Signature);
            Assert.Same(method2.Signature, method.Signature);
            Assert.Same(method.Signature, string.Intern(method.Signature));
        }
コード例 #20
0
ファイル: Module.cs プロジェクト: d4nnyk/WinDbgCs
        /// <summary>
        /// Gets the CLR static variable.
        /// </summary>
        /// <param name="name">The name.</param>
        /// <param name="appDomain">The application domain.</param>
        /// <returns>Static variable if found</returns>
        public Variable GetClrVariable(string name, CsDebugScript.CLR.AppDomain appDomain)
        {
            int    variableNameIndex = name.LastIndexOf('.');
            string typeName          = name.Substring(0, variableNameIndex);
            var    clrType           = ClrModule.GetTypeByName(typeName);

            if (clrType == null)
            {
                throw new Exception("CLR type not found " + typeName);
            }

            string variableName = name.Substring(variableNameIndex + 1);
            var    staticField  = clrType.GetStaticFieldByName(variableName);

            if (staticField == null)
            {
                throw new Exception("Field " + staticField + " wasn't found in CLR type " + typeName);
            }

            var address = staticField.GetAddress(appDomain.ClrAppDomain);

            return(Variable.CreateNoCast(FromClrType(clrType), address, variableName));
        }
コード例 #21
0
ファイル: ClrDelegateTests.cs プロジェクト: mikem8361/clrmd
        public void EnumerateDelegateTest()
        {
            using DataTarget dt      = TestTargets.Types.LoadFullDump();
            using ClrRuntime runtime = dt.ClrVersions.Single().CreateRuntime();
            ClrModule typesModule = runtime.GetModule(TypeTests.ModuleName);
            ClrType   Types       = typesModule.GetTypeByName("Types");

            ClrDelegate TestDelegate = Types.GetStaticFieldByName("TestDelegate").ReadObject(runtime.AppDomains.Single()).AsDelegate();

            ClrDelegateTarget[] methods = TestDelegate.EnumerateDelegateTargets().ToArray();

            Assert.Single(methods);
            CompareToInner(Types, TestDelegate, methods[0]);


            ClrDelegate TestEvent = Types.GetStaticFieldByName("TestEvent").ReadObject(runtime.AppDomains.Single()).AsDelegate();

            methods = TestEvent.EnumerateDelegateTargets().ToArray();

            Assert.Equal(2, methods.Length);
            CompareToInner(Types, TestEvent, methods[0]);
            CompareToInstanceMethod(Types, TestEvent, methods[1]);
        }
コード例 #22
0
ファイル: MethodTests.cs プロジェクト: wilvk/dotnet-sos
        public void MethodHandleSingleDomainTests()
        {
            ulong methodDesc;

            using (DataTarget dt = TestTargets.Types.LoadFullDump())
            {
                using ClrRuntime runtime = dt.ClrVersions.Single().CreateRuntime();

                ClrModule module = runtime.GetModule("sharedlibrary.dll");
                ClrType   type   = module.GetTypeByName("Foo");
                ClrMethod method = type.GetMethod("Bar");
                methodDesc = method.MethodDesc;

                Assert.NotEqual(0ul, methodDesc);
            }

            using (DataTarget dt = TestTargets.Types.LoadFullDump())
            {
                using ClrRuntime runtime = dt.ClrVersions.Single().CreateRuntime();
                ClrMethod method = runtime.GetMethodByHandle(methodDesc);

                Assert.NotNull(method);
                Assert.Equal("Bar", method.Name);
                Assert.Equal("Foo", method.Type.Name);
            }

            using (DataTarget dt = TestTargets.Types.LoadFullDump())
            {
                using ClrRuntime runtime = dt.ClrVersions.Single().CreateRuntime();

                ClrModule module = runtime.GetModule("sharedlibrary.dll");
                ClrType   type   = module.GetTypeByName("Foo");
                ClrMethod method = type.GetMethod("Bar");
                Assert.Equal(methodDesc, method.MethodDesc);
                Assert.Equal(method, runtime.GetMethodByHandle(methodDesc));
            }
        }
コード例 #23
0
ファイル: FieldTests.cs プロジェクト: wilvk/dotnet-sos
        public void TestStaticFieldModifiers()
        {
            using DataTarget dt      = TestTargets.NestedTypes.LoadFullDump();
            using ClrRuntime runtime = dt.ClrVersions.Single().CreateRuntime();

            ClrModule module  = runtime.GetModule(TypeTests.NestedTypesModuleName);
            ClrType   program = module.GetTypeByName("Program");

            ClrStaticField publicField = program.GetStaticFieldByName("s_publicField");

            Assert.True(publicField.IsPublic);

            ClrStaticField privateField = program.GetStaticFieldByName("s_privateField");

            Assert.True(privateField.IsPrivate);

            ClrStaticField internalField = program.GetStaticFieldByName("s_internalField");

            Assert.True(internalField.IsInternal);

            ClrStaticField protectedField = program.GetStaticFieldByName("s_protectedField");

            Assert.True(protectedField.IsProtected);
        }
コード例 #24
0
        /// <summary>
        /// Gets the CLR static variable.
        /// </summary>
        /// <param name="name">The name.</param>
        /// <param name="appDomain">The application domain.</param>
        /// <returns>Static variable if found</returns>
        public Variable GetClrVariable(string name, IClrAppDomain appDomain)
        {
            int    variableNameIndex = name.LastIndexOf('.');
            string typeName          = name.Substring(0, variableNameIndex);
            var    clrType           = ClrModule.GetTypeByName(typeName);

            if (clrType == null)
            {
                throw new Exception($"CLR type not found {typeName}");
            }

            string variableName = name.Substring(variableNameIndex + 1);
            var    staticField  = clrType.GetStaticFieldByName(variableName);

            if (staticField == null)
            {
                throw new Exception($"Field {staticField} wasn't found in CLR type {typeName}");
            }

            var      address = staticField.GetAddress(appDomain);
            Variable field   = Variable.CreateNoCast(FromClrType(clrType), address, variableName);

            return(Variable.UpcastClrVariable(field));
        }
コード例 #25
0
ファイル: PdbTests.cs プロジェクト: zforks/KeeThief
        public void PdbMethodTest()
        {
            // Ensure all methods in our source file is in the pdb.
            using (DataTarget dt = TestTargets.NestedException.LoadFullDump())
            {
                ClrRuntime runtime = dt.ClrVersions.Single().CreateRuntime();
                ClrModule  module  = runtime.Modules.Where(m => m.Name.Equals(TestTargets.NestedException.Executable, StringComparison.OrdinalIgnoreCase)).Single();
                ClrType    type    = module.GetTypeByName("Program");

                using (PdbReader pdb = new PdbReader(TestTargets.NestedException.Pdb))
                {
                    foreach (ClrMethod method in type.Methods)
                    {
                        // ignore inherited methods and constructors
                        if (method.Type != type || method.IsConstructor || method.IsClassConstructor)
                        {
                            continue;
                        }

                        Assert.IsNotNull(pdb.GetFunctionFromToken(method.MetadataToken));
                    }
                }
            }
        }
コード例 #26
0
 /// <summary>
 ///     Attempts to obtain a ClrType based on the name of the type.  Note this is a "best effort" due to
 ///     the way that the dac handles types.  This function will fail for Generics, and types which have
 ///     never been constructed in the target process.  Please be sure to null-check the return value of
 ///     this function.
 /// </summary>
 /// <param name="name">The name of the type.  (This would be the EXACT value returned by ClrType.Name.</param>
 /// <returns>The requested ClrType, or null if the type doesn't exist or couldn't be constructed.</returns>
 /// <exception cref="NotImplementedException"></exception>
 /// <inheritdoc />
 public IClrType GetTypeByName(string name) => Converter.Convert(Module.GetTypeByName(name));
コード例 #27
0
        public void RunDone()
        {
            _workItems     = new Dictionary <string, WorkInfo>();
            _workItemCount = 0;
            _tasks         = new Dictionary <string, WorkInfo>();
            _taskCount     = 0;

            ClrMDHelper helper = new ClrMDHelper(_host.Session.Clr);

            // The ThreadPool is keeping track of the pending work items into two different areas:
            // - a global queue: stored by ThreadPoolWorkQueue instances of the ThreadPoolGlobals.workQueue static field
            // - several per thread (TLS) local queues: stored in SparseArray<ThreadPoolWorkQueue+WorkStealingQueue> linked from ThreadPoolWorkQueue.allThreadQueues static fields
            // both are using arrays of Task or QueueUserWorkItemCallback
            //
            // NOTE: don't show other thread pool related topics such as timer callbacks or wait objects
            //
            try
            {
                var heap = _host.Session.Clr.Heap;
                var clr  = _host.Session.Clr;

                _host.WriteLine("global work item queue________________________________");
                // look for the ThreadPoolGlobals.workQueue static field
                ClrModule mscorlib = helper.GetMscorlib();
                if (mscorlib == null)
                {
                    return;
                }

                ClrType queueType = mscorlib.GetTypeByName("System.Threading.ThreadPoolGlobals");
                if (queueType == null)
                {
                    return;
                }

                ClrStaticField workQueueField = queueType.GetStaticFieldByName("workQueue");
                if (workQueueField == null)
                {
                    return;
                }

                // the CLR keeps one static instance per application domain
                foreach (var appDomain in clr.AppDomains)
                {
                    object workQueueValue = workQueueField.GetValue(appDomain);
                    ulong  workQueueRef   = (workQueueValue == null) ? 0L : (ulong)workQueueValue;
                    if (workQueueRef == 0)
                    {
                        continue;
                    }

                    // should be  System.Threading.ThreadPoolWorkQueue
                    ClrType workQueueType = heap.GetObjectType(workQueueRef);
                    if (workQueueType == null)
                    {
                        continue;
                    }
                    if (workQueueType.Name != "System.Threading.ThreadPoolWorkQueue")
                    {
                        continue;
                    }

                    if (!DumpThreadPoolWorkQueue(workQueueType, workQueueRef))
                    {
                        _host.WriteLine("Impossible to dump thread pool work queue @ 0x" + workQueueRef.ToString("X"));
                    }
                }



                // look into the local stealing queues in each thread TLS
                // hopefully, they are all stored in static (one per app domain) instance
                // of ThreadPoolWorkQueue.SparseArray<ThreadPoolWorkQueue.WorkStealingQueue>
                //
                _host.WriteLine("\r\nlocal per thread work items_____________________________________");
                try
                {
                    queueType = mscorlib.GetTypeByName("System.Threading.ThreadPoolWorkQueue");
                    if (queueType == null)
                    {
                        return;
                    }

                    ClrStaticField threadQueuesField = queueType.GetStaticFieldByName("allThreadQueues");
                    if (threadQueuesField == null)
                    {
                        return;
                    }

                    foreach (ClrAppDomain domain in clr.AppDomains)
                    {
                        ulong?threadQueue = (ulong?)threadQueuesField.GetValue(domain);
                        if (!threadQueue.HasValue || threadQueue.Value == 0)
                        {
                            continue;
                        }

                        ClrType threadQueueType = heap.GetObjectType(threadQueue.Value);
                        if (threadQueueType == null)
                        {
                            continue;
                        }

                        var sparseArrayRef = _host.Session.GetFieldValue(threadQueue.Value, "m_array");
                        _host.Session.ForEach((ulong)sparseArrayRef, stealingQueue =>
                        {
                            if (stealingQueue != 0)
                            {
                                var arrayRef = _host.Session.GetFieldValue(stealingQueue, "m_array");
                                DumpThreadPoolWorkItems((ulong)arrayRef);
                            }
                        });
                    }
                }
                finally
                {
                    // provide a summary sorted by count
                    // tasks first if any
                    if (_tasks.Values.Count > 0)
                    {
                        foreach (var item in _tasks.Values.OrderBy(wi => wi.Count))
                        {
                            _host.WriteLine(string.Format(" {0,4} Task  {1}", item.Count.ToString(), item.Name));
                        }
                        _host.WriteLine(" ----");
                        _host.WriteLine(string.Format(" {0,4}\r\n", _taskCount.ToString()));
                    }

                    // then QueueUserWorkItem next if any
                    if (_workItems.Values.Count > 0)
                    {
                        foreach (var item in _workItems.Values.OrderBy(wi => wi.Count))
                        {
                            _host.WriteLine(string.Format(" {0,4} Work  {1}", item.Count.ToString(), item.Name));
                        }
                        _host.WriteLine(" ----");
                        _host.WriteLine(string.Format(" {0,4}\r\n", _workItemCount.ToString()));
                    }

                    var threadPool = _host.Session.Clr.ThreadPool;
                    _host.WriteLine(string.Format(
                                        "\r\nCPU = {0}% for {1} threads (#idle = {2} + #running = {3} | #dead = {4} | #max = {5})",
                                        threadPool.CpuUtilization.ToString(),
                                        threadPool.TotalThreads.ToString(),
                                        threadPool.IdleThreads.ToString(),
                                        threadPool.RunningThreads.ToString(),
                                        _host.Session.Clr.Threads.Count(t => t.IsThreadpoolWorker && !t.IsThreadpoolCompletionPort && !t.IsAlive && !t.IsThreadpoolGate && !t.IsThreadpoolTimer && !t.IsThreadpoolWait).ToString(),
                                        threadPool.MaxThreads.ToString()
                                        ));

                    // show the running worker threads
                    DumpRunningThreadpoolThreads(helper);
                }
            }
            catch (Exception x)
            {
                _host.WriteLine(x.Message);
            }
        }
コード例 #28
0
ファイル: ClrMdModule.cs プロジェクト: wy182000/PadAnalyzer
 /// <summary>
 /// Attempts to obtain a <see cref="T:CsDebugScript.CLR.IClrType" /> based on the name of the type.
 /// Note this is a "best effort" due to the way that the DAC handles types.
 /// This function will fail for Generics, and types which have never been constructed in the target process.
 /// Please be sure to null-check the return value of this function.
 /// </summary>
 /// <param name="typeName">The name of the type. (This would be the EXACT value returned by <see cref="P:CsDebugScript.CLR.IClrType.Name" />).</param>
 public IClrType GetTypeByName(string typeName)
 {
     return(Provider.FromClrType(ClrModule.GetTypeByName(typeName)));
 }
コード例 #29
0
ファイル: threadpool.cs プロジェクト: popotans/netext
        private IEnumerable <ulong> EnumerateManagedThreadpoolObjects()
        {
            _heap = _runtime.GetHeap();

            ClrModule mscorlib = GetMscorlib();

            if (mscorlib != null)
            {
                ClrType queueType = mscorlib.GetTypeByName("System.Threading.ThreadPoolGlobals");
                if (queueType != null)
                {
                    ClrStaticField workQueueField = queueType.GetStaticFieldByName("workQueue");
                    if (workQueueField != null)
                    {
                        foreach (var appDomain in _runtime.AppDomains)
                        {
                            object  workQueueValue = workQueueField.GetValue(appDomain);
                            ulong   workQueue      = workQueueValue == null ? 0L : (ulong)workQueueValue;
                            ClrType workQueueType  = _heap.GetObjectType(workQueue);

                            if (workQueue == 0 || workQueueType == null)
                            {
                                continue;
                            }

                            ulong   queueHead;
                            ClrType queueHeadType;
                            do
                            {
                                if (!GetFieldObject(workQueueType, workQueue, "queueHead", out queueHeadType, out queueHead))
                                {
                                    break;
                                }

                                ulong   nodes;
                                ClrType nodesType;
                                if (GetFieldObject(queueHeadType, queueHead, "nodes", out nodesType, out nodes) && nodesType.IsArray)
                                {
                                    int len = nodesType.GetArrayLength(nodes);
                                    for (int i = 0; i < len; ++i)
                                    {
                                        ulong addr = (ulong)nodesType.GetArrayElementValue(nodes, i);
                                        if (addr != 0)
                                        {
                                            yield return(addr);
                                        }
                                    }
                                }

                                if (!GetFieldObject(queueHeadType, queueHead, "Next", out queueHeadType, out queueHead))
                                {
                                    break;
                                }
                            } while (queueHead != 0);
                        }
                    }
                }


                queueType = mscorlib.GetTypeByName("System.Threading.ThreadPoolWorkQueue");
                if (queueType != null)
                {
                    ClrStaticField threadQueuesField = queueType.GetStaticFieldByName("allThreadQueues");
                    if (threadQueuesField != null)
                    {
                        foreach (ClrAppDomain domain in _runtime.AppDomains)
                        {
                            ulong?threadQueue = (ulong?)threadQueuesField.GetValue(domain);
                            if (!threadQueue.HasValue || threadQueue.Value == 0)
                            {
                                continue;
                            }

                            ClrType threadQueueType = _heap.GetObjectType(threadQueue.Value);
                            if (threadQueueType == null)
                            {
                                continue;
                            }

                            ulong   outerArray     = 0;
                            ClrType outerArrayType = null;
                            if (!GetFieldObject(threadQueueType, threadQueue.Value, "m_array", out outerArrayType, out outerArray) || !outerArrayType.IsArray)
                            {
                                continue;
                            }

                            int outerLen = outerArrayType.GetArrayLength(outerArray);
                            for (int i = 0; i < outerLen; ++i)
                            {
                                ulong entry = (ulong)outerArrayType.GetArrayElementValue(outerArray, i);
                                if (entry == 0)
                                {
                                    continue;
                                }

                                ClrType entryType = _heap.GetObjectType(entry);
                                if (entryType == null)
                                {
                                    continue;
                                }

                                ulong   array;
                                ClrType arrayType;
                                if (!GetFieldObject(entryType, entry, "m_array", out arrayType, out array) || !arrayType.IsArray)
                                {
                                    continue;
                                }

                                int len = arrayType.GetArrayLength(array);
                                for (int j = 0; j < len; ++j)
                                {
                                    ulong addr = (ulong)arrayType.GetArrayElementValue(array, i);
                                    if (addr != 0)
                                    {
                                        yield return(addr);
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }