302 lines
8.7 KiB
C#
302 lines
8.7 KiB
C#
// This Source Code Form is subject to the terms of the Mozilla Public License, v. 2.0.
|
|
// If a copy of the MPL was not distributed with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
|
|
// Copyright (C) LibreHardwareMonitor and Contributors.
|
|
// Partial Copyright (C) Michael Möller <mmoeller@openhardwaremonitor.org> and Contributors.
|
|
// All Rights Reserved.
|
|
|
|
using System;
|
|
using System.Reflection;
|
|
using System.Runtime.InteropServices;
|
|
|
|
namespace LibreHardwareMonitor.Hardware;
|
|
|
|
internal static class OpCode
|
|
{
|
|
public static CpuidDelegate CpuId;
|
|
public static RdtscDelegate Rdtsc;
|
|
|
|
private static IntPtr _codeBuffer;
|
|
private static ulong _size;
|
|
|
|
// void __stdcall cpuidex(unsigned int index, unsigned int ecxValue,
|
|
// unsigned int* eax, unsigned int* ebx, unsigned int* ecx,
|
|
// unsigned int* edx)
|
|
// {
|
|
// int info[4];
|
|
// __cpuidex(info, index, ecxValue);
|
|
// *eax = info[0];
|
|
// *ebx = info[1];
|
|
// *ecx = info[2];
|
|
// *edx = info[3];
|
|
// }
|
|
|
|
private static readonly byte[] CpuId32 =
|
|
{
|
|
0x55, // push ebp
|
|
0x8B,
|
|
0xEC, // mov ebp, esp
|
|
0x83,
|
|
0xEC,
|
|
0x10, // sub esp, 10h
|
|
0x8B,
|
|
0x45,
|
|
0x08, // mov eax, dword ptr [ebp+8]
|
|
0x8B,
|
|
0x4D,
|
|
0x0C, // mov ecx, dword ptr [ebp+0Ch]
|
|
0x53, // push ebx
|
|
0x0F,
|
|
0xA2, // cpuid
|
|
0x56, // push esi
|
|
0x8D,
|
|
0x75,
|
|
0xF0, // lea esi, [info]
|
|
0x89,
|
|
0x06, // mov dword ptr [esi],eax
|
|
0x8B,
|
|
0x45,
|
|
0x10, // mov eax, dword ptr [eax]
|
|
0x89,
|
|
0x5E,
|
|
0x04, // mov dword ptr [esi+4], ebx
|
|
0x89,
|
|
0x4E,
|
|
0x08, // mov dword ptr [esi+8], ecx
|
|
0x89,
|
|
0x56,
|
|
0x0C, // mov dword ptr [esi+0Ch], edx
|
|
0x8B,
|
|
0x4D,
|
|
0xF0, // mov ecx, dword ptr [info]
|
|
0x89,
|
|
0x08, // mov dword ptr [eax], ecx
|
|
0x8B,
|
|
0x45,
|
|
0x14, // mov eax, dword ptr [ebx]
|
|
0x8B,
|
|
0x4D,
|
|
0xF4, // mov ecx, dword ptr [ebp-0Ch]
|
|
0x89,
|
|
0x08, // mov dword ptr [eax], ecx
|
|
0x8B,
|
|
0x45,
|
|
0x18, // mov eax, dword ptr [ecx]
|
|
0x8B,
|
|
0x4D,
|
|
0xF8, // mov ecx, dword ptr [ebp-8]
|
|
0x89,
|
|
0x08, // mov dword ptr [eax], ecx
|
|
0x8B,
|
|
0x45,
|
|
0x1C, // mov eax, dword ptr [edx]
|
|
0x8B,
|
|
0x4D,
|
|
0xFC, // mov ecx, dword ptr [ebp-4]
|
|
0x5E, // pop esi
|
|
0x89,
|
|
0x08, // mov dword ptr [eax], ecx
|
|
0x5B, // pop ebx
|
|
0xC9, // leave
|
|
0xC2,
|
|
0x18,
|
|
0x00 // ret 18h
|
|
};
|
|
|
|
private static readonly byte[] CpuId64Linux =
|
|
{
|
|
0x49,
|
|
0x89,
|
|
0xD2, // mov r10, rdx
|
|
0x49,
|
|
0x89,
|
|
0xCB, // mov r11, rcx
|
|
0x53, // push rbx
|
|
0x89,
|
|
0xF8, // mov eax, edi
|
|
0x89,
|
|
0xF1, // mov ecx, esi
|
|
0x0F,
|
|
0xA2, // cpuid
|
|
0x41,
|
|
0x89,
|
|
0x02, // mov dword ptr [r10], eax
|
|
0x41,
|
|
0x89,
|
|
0x1B, // mov dword ptr [r11], ebx
|
|
0x41,
|
|
0x89,
|
|
0x08, // mov dword ptr [r8], ecx
|
|
0x41,
|
|
0x89,
|
|
0x11, // mov dword ptr [r9], edx
|
|
0x5B, // pop rbx
|
|
0xC3 // ret
|
|
};
|
|
|
|
private static readonly byte[] CpuId64Windows =
|
|
{
|
|
0x48,
|
|
0x89,
|
|
0x5C,
|
|
0x24,
|
|
0x08, // mov qword ptr [rsp+8], rbx
|
|
0x8B,
|
|
0xC1, // mov eax, ecx
|
|
0x8B,
|
|
0xCA, // mov ecx, edx
|
|
0x0F,
|
|
0xA2, // cpuid
|
|
0x41,
|
|
0x89,
|
|
0x00, // mov dword ptr [r8], eax
|
|
0x48,
|
|
0x8B,
|
|
0x44,
|
|
0x24,
|
|
0x28, // mov rax, qword ptr [rsp+28h]
|
|
0x41,
|
|
0x89,
|
|
0x19, // mov dword ptr [r9], ebx
|
|
0x48,
|
|
0x8B,
|
|
0x5C,
|
|
0x24,
|
|
0x08, // mov rbx, qword ptr [rsp+8]
|
|
0x89,
|
|
0x08, // mov dword ptr [rax], ecx
|
|
0x48,
|
|
0x8B,
|
|
0x44,
|
|
0x24,
|
|
0x30, // mov rax, qword ptr [rsp+30h]
|
|
0x89,
|
|
0x10, // mov dword ptr [rax], edx
|
|
0xC3 // ret
|
|
};
|
|
|
|
// unsigned __int64 __stdcall rdtsc() {
|
|
// return __rdtsc();
|
|
// }
|
|
|
|
private static readonly byte[] Rdtsc32 =
|
|
{
|
|
0x0F,
|
|
0x31, // rdtsc
|
|
0xC3 // ret
|
|
};
|
|
|
|
private static readonly byte[] Rdtsc64 =
|
|
{
|
|
0x0F,
|
|
0x31, // rdtsc
|
|
0x48,
|
|
0xC1,
|
|
0xE2,
|
|
0x20, // shl rdx, 20h
|
|
0x48,
|
|
0x0B,
|
|
0xC2, // or rax, rdx
|
|
0xC3 // ret
|
|
};
|
|
|
|
[UnmanagedFunctionPointer(CallingConvention.StdCall)]
|
|
public delegate bool CpuidDelegate(uint index, uint ecxValue, out uint eax, out uint ebx, out uint ecx, out uint edx);
|
|
|
|
[UnmanagedFunctionPointer(CallingConvention.StdCall)]
|
|
public delegate ulong RdtscDelegate();
|
|
|
|
public static void Open()
|
|
{
|
|
byte[] rdTscCode;
|
|
byte[] cpuidCode;
|
|
if (IntPtr.Size == 4)
|
|
{
|
|
rdTscCode = Rdtsc32;
|
|
cpuidCode = CpuId32;
|
|
}
|
|
else
|
|
{
|
|
rdTscCode = Rdtsc64;
|
|
cpuidCode = Software.OperatingSystem.IsUnix ? CpuId64Linux : CpuId64Windows;
|
|
}
|
|
|
|
_size = (ulong)(rdTscCode.Length + cpuidCode.Length);
|
|
|
|
if (Software.OperatingSystem.IsUnix)
|
|
{
|
|
#if NETFRAMEWORK
|
|
Assembly assembly = Assembly.Load("Mono.Posix, Version=2.0.0.0, Culture=neutral, " + "PublicKeyToken=0738eb9f132ed756");
|
|
#else
|
|
Assembly assembly = Assembly.Load("Mono.Posix.NETStandard, Version=1.0.0.0, Culture=neutral");
|
|
#endif
|
|
|
|
Type sysCall = assembly.GetType("Mono.Unix.Native.Syscall");
|
|
MethodInfo mmap = sysCall.GetMethod("mmap");
|
|
|
|
Type mmapProts = assembly.GetType("Mono.Unix.Native.MmapProts");
|
|
object mmapProtsParam = Enum.ToObject(mmapProts,
|
|
(int)mmapProts.GetField("PROT_READ").GetValue(null) |
|
|
(int)mmapProts.GetField("PROT_WRITE").GetValue(null) |
|
|
(int)mmapProts.GetField("PROT_EXEC").GetValue(null));
|
|
|
|
Type mmapFlags = assembly.GetType("Mono.Unix.Native.MmapFlags");
|
|
object mmapFlagsParam = Enum.ToObject(mmapFlags,
|
|
(int)mmapFlags.GetField("MAP_ANONYMOUS").GetValue(null) |
|
|
(int)mmapFlags.GetField("MAP_PRIVATE").GetValue(null));
|
|
|
|
if (mmap != null)
|
|
_codeBuffer = (IntPtr)mmap.Invoke(null, new[] { IntPtr.Zero, _size, mmapProtsParam, mmapFlagsParam, -1, 0 });
|
|
}
|
|
else
|
|
{
|
|
_codeBuffer = Interop.Kernel32.VirtualAlloc(IntPtr.Zero,
|
|
(UIntPtr)_size,
|
|
Interop.Kernel32.MEM.MEM_COMMIT | Interop.Kernel32.MEM.MEM_RESERVE,
|
|
Interop.Kernel32.PAGE.PAGE_EXECUTE_READWRITE);
|
|
}
|
|
|
|
Marshal.Copy(rdTscCode, 0, _codeBuffer, rdTscCode.Length);
|
|
Rdtsc = Marshal.GetDelegateForFunctionPointer(_codeBuffer, typeof(RdtscDelegate)) as RdtscDelegate;
|
|
IntPtr cpuidAddress = (IntPtr)((long)_codeBuffer + rdTscCode.Length);
|
|
Marshal.Copy(cpuidCode, 0, cpuidAddress, cpuidCode.Length);
|
|
CpuId = Marshal.GetDelegateForFunctionPointer(cpuidAddress, typeof(CpuidDelegate)) as CpuidDelegate;
|
|
}
|
|
|
|
public static void Close()
|
|
{
|
|
Rdtsc = null;
|
|
CpuId = null;
|
|
|
|
if (Software.OperatingSystem.IsUnix)
|
|
{
|
|
#if NETFRAMEWORK
|
|
Assembly assembly = Assembly.Load("Mono.Posix, Version=2.0.0.0, Culture=neutral, " + "PublicKeyToken=0738eb9f132ed756");
|
|
#else
|
|
Assembly assembly = Assembly.Load("Mono.Posix.NETStandard, Version=1.0.0.0, Culture=neutral");
|
|
#endif
|
|
|
|
Type sysCall = assembly.GetType("Mono.Unix.Native.Syscall");
|
|
MethodInfo method = sysCall.GetMethod("munmap");
|
|
method?.Invoke(null, new object[] { _codeBuffer, _size });
|
|
}
|
|
else
|
|
{
|
|
Interop.Kernel32.VirtualFree(_codeBuffer, UIntPtr.Zero, Interop.Kernel32.MEM.MEM_RELEASE);
|
|
}
|
|
}
|
|
|
|
public static bool CpuIdTx(uint index, uint ecxValue, out uint eax, out uint ebx, out uint ecx, out uint edx, GroupAffinity affinity)
|
|
{
|
|
GroupAffinity previousAffinity = ThreadAffinity.Set(affinity);
|
|
if (previousAffinity == GroupAffinity.Undefined)
|
|
{
|
|
eax = ebx = ecx = edx = 0;
|
|
return false;
|
|
}
|
|
|
|
CpuId(index, ecxValue, out eax, out ebx, out ecx, out edx);
|
|
ThreadAffinity.Set(previousAffinity);
|
|
return true;
|
|
}
|
|
}
|