C++ GetNativeSystemInfo函数代码示例

JNIEXPORT void JNICALL
Java_net_rubygrapefruit_platform_internal_jni_NativeLibraryFunctions_getSystemInfo(JNIEnv *env, jclass target, jobject info, jobject result) {
    jclass infoClass = env->GetObjectClass(info);

    OSVERSIONINFOEX versionInfo;
    versionInfo.dwOSVersionInfoSize = sizeof(OSVERSIONINFOEX);
    if (GetVersionEx((OSVERSIONINFO*)&versionInfo) == 0) {
        mark_failed_with_errno(env, "could not get version info", result);
        return;
    }

    SYSTEM_INFO systemInfo;
    GetNativeSystemInfo(&systemInfo);
    jstring arch = NULL;
    if (systemInfo.wProcessorArchitecture == PROCESSOR_ARCHITECTURE_AMD64) {
        arch = env->NewStringUTF("amd64");
    } else if (systemInfo.wProcessorArchitecture == PROCESSOR_ARCHITECTURE_INTEL) {
        arch = env->NewStringUTF("x86");
    } else if (systemInfo.wProcessorArchitecture == PROCESSOR_ARCHITECTURE_IA64) {
        arch = env->NewStringUTF("ia64");
    } else {
        arch = env->NewStringUTF("unknown");
    }

    jmethodID method = env->GetMethodID(infoClass, "windows", "(IIIZLjava/lang/String;)V");
    env->CallVoidMethod(info, method, versionInfo.dwMajorVersion, versionInfo.dwMinorVersion,
                        versionInfo.dwBuildNumber, versionInfo.wProductType == VER_NT_WORKSTATION,
                        arch);
}

QTCREATOR_UTILS_EXPORT bool winIs64BitSystem()
{
    SYSTEM_INFO systemInfo;
    GetNativeSystemInfo(&systemInfo);
    return systemInfo.wProcessorArchitecture == PROCESSOR_ARCHITECTURE_AMD64
            || systemInfo.wProcessorArchitecture == PROCESSOR_ARCHITECTURE_IA64;
}

/**
@Status Caveat
@Notes Only HW_AVAILCPU is supported
*/
extern "C" int sysctl(const int* name, u_int namelen, void* oldp, size_t* oldlenp, const void* newp, size_t newlen) {
    if (namelen < 2 || name == nullptr) {
        errno = EINVAL;
        return -1;
    }

    if (namelen != 2 ||
        name[0] != CTL_HW ||
        name[1] != HW_AVAILCPU) {

        UNIMPLEMENTED_WITH_MSG("sysctl only supports querying HW_AVAILCPU");
        errno = EOPNOTSUPP;
        return -1;
    }

    if (*oldlenp < sizeof(int)) {
        *oldlenp = sizeof(int);
        errno = ENOMEM;
        return -1;
    }

    SYSTEM_INFO systemInfo;
    GetNativeSystemInfo(&systemInfo);

    *static_cast<int*>(oldp) = systemInfo.dwNumberOfProcessors;
    *oldlenp = sizeof(int);

    return 0;
}

	NTSTATUS ProcessCore::Init() {
		// Detect x86 OS
		SYSTEM_INFO info = {{0}};
		GetNativeSystemInfo(&info);
		if(info.wProcessorArchitecture == PROCESSOR_ARCHITECTURE_INTEL) {
			_native.reset(new x86Native(_hProcess));
		} else {
			// Detect wow64 barrier
			BOOL wowSrc = FALSE;
			IsWow64Process(GetCurrentProcess(), &wowSrc);
			if(wowSrc == TRUE)
				_native.reset(new NativeWow64(_hProcess));
			else
				_native.reset(new Native(_hProcess));
		}
		// Get DEP info
		// For native x64 processes DEP is always enabled
		if(_native->GetWow64Barrier().targetWow64 == false) {
			_dep = true;
		} else {
			DWORD flags = 0;
			BOOL perm = 0;
			if(SAFE_CALL(GetProcessDEPPolicy, _hProcess, &flags, &perm))
				_dep = (flags & PROCESS_DEP_ENABLE) != 0;
		}
		return STATUS_SUCCESS;
	}

int Engine::GetPrcessorInfo(){
	SYSTEM_INFO stInfo;
	//GetSystemInfo(&stInfo);

	GetNativeSystemInfo(&stInfo);

	switch (stInfo.wProcessorArchitecture)
	{
	case PROCESSOR_ARCHITECTURE_INTEL:
		//printf("Processor Architecture: Intel x86\n");
		return 0;
		break;
	case PROCESSOR_ARCHITECTURE_IA64:
		//printf("Processor Type: Intel x64\n");
		return 6;
		break;
	case PROCESSOR_ARCHITECTURE_AMD64:
		//printf("Processor Type: AMD 64\n");
		return 9;
		break;
	default:
		//printf("Unknown processor architecture\n");
		return -1;
	}
}

  virtual int load_driver_()
  {
      SYSTEM_INFO sys_info;
      ZeroMemory(&sys_info, sizeof(sys_info));

      GetCurrentDirectory(MAX_PATH - 10, driver_filename);

      GetNativeSystemInfo(&sys_info);
      switch(sys_info.wProcessorArchitecture)
      {
          case PROCESSOR_ARCHITECTURE_AMD64:
            wcscat_s(driver_filename, MAX_PATH, L"\\winpmem_64.sys");
            if(GetFileAttributes(driver_filename) ==  INVALID_FILE_ATTRIBUTES)
            {
                std::cout << "ERROR: winpmem_64.sys not found in current directory. Download it from https://volatility.googlecode.com/svn-history/r2813/branches/scudette/tools/windows/winpmem/binaries/winpmem_64.sys ." << std::endl;
                std::cout << "ERROR: Memory bandwidth statistics will not be available." << std::endl;
            }
            break;
          case PROCESSOR_ARCHITECTURE_INTEL:
            wcscat_s(driver_filename, MAX_PATH, L"\\winpmem_32.sys");
            if(GetFileAttributes(driver_filename) ==  INVALID_FILE_ATTRIBUTES)
            {
                std::cout << "ERROR: winpmem_32.sys not found in current directory. Download it from https://volatility.googlecode.com/svn-history/r2813/branches/scudette/tools/windows/winpmem/binaries/winpmem_32.sys ." << std::endl;
                std::cout << "ERROR: Memory bandwidth statistics will not be available." << std::endl;
            }
            break;
        default:
            return -1;
      }
      return 1;
  }

int main(int argc, char *argv[])
{
    uv_setup_args(argc, argv); // no-op on Windows
#else
static void lock_low32() {
#if defined(_P64) && defined(JL_DEBUG_BUILD)
    // block usage of the 32-bit address space on win64, to catch pointer cast errors
    char *const max32addr = (char*)0xffffffffL;
    SYSTEM_INFO info;
    MEMORY_BASIC_INFORMATION meminfo;
    GetNativeSystemInfo(&info);
    memset(&meminfo, 0, sizeof(meminfo));
    meminfo.BaseAddress = info.lpMinimumApplicationAddress;
    while ((char*)meminfo.BaseAddress < max32addr) {
        VirtualQuery(meminfo.BaseAddress, &meminfo, sizeof(meminfo));
        if (meminfo.State == MEM_FREE) { // reserve all free pages in the first 4GB of memory
            char *first = (char*)meminfo.BaseAddress;
            char *last = first + meminfo.RegionSize;
            char *p;
            if (last > max32addr)
                last = max32addr;
            // adjust first up to the first allocation granularity boundary
            // adjust last down to the last allocation granularity boundary
            first = (char*)(((long long)first + info.dwAllocationGranularity - 1) & ~(info.dwAllocationGranularity - 1));
            last = (char*)((long long)last & ~(info.dwAllocationGranularity - 1));
            if (last != first) {
                p = VirtualAlloc(first, last - first, MEM_RESERVE, PAGE_NOACCESS); // reserve all memory in between
                assert(p == first);
            }
        }
        meminfo.BaseAddress += meminfo.RegionSize;
    }
#endif
}

		WitchSystemInfo::ProcessorArchitecture WitchSystemInfo::architecture()
		{
			static WitchSystemInfo::ProcessorArchitecture arch;
			
			if(arch)
				return arch;
				
#if WITCHENGINE_PLATFORM == WITCHENGINE_PLATFORM_WIN32 || WITCHENGINE_PLATFORM == WITCHENGINE_PLATFORM_WIN64
			SYSTEM_INFO sysinfo;
			
			GetNativeSystemInfo(&sysinfo);

			if(sysinfo.wProcessorArchitecture == 9)
			{
				arch = WitchSystemInfo::PA_AMD64;
			}
			else if(sysinfo.wProcessorArchitecture == 6)
			{
				arch = WitchSystemInfo::PA_IA64;
			}
			else if(sysinfo.wProcessorArchitecture == 0)
			{
				arch = WitchSystemInfo::PA_INTEL;
			}
			else
			{
				arch = WitchSystemInfo::PA_UNKNOWN;
			}
#endif

			return arch;
		}

CStdString CSysInfo::GetUAWindowsVersion()
{
  OSVERSIONINFOEX osvi = {};

  osvi.dwOSVersionInfoSize = sizeof(osvi);
  CStdString strVersion = "Windows NT";

  if (GetVersionEx((OSVERSIONINFO *)&osvi))
  {
    strVersion += StringUtils::Format(" %d.%d", osvi.dwMajorVersion, osvi.dwMinorVersion);
  }

  SYSTEM_INFO si = {};
  GetSystemInfo(&si);

  BOOL bIsWow = FALSE;
  if (IsWow64Process(GetCurrentProcess(), &bIsWow))
  {
    if (bIsWow)
    {
      strVersion.append(";WOW64");
      GetNativeSystemInfo(&si);     // different function to read the info under Wow
    }
  }

  if (si.wProcessorArchitecture==PROCESSOR_ARCHITECTURE_AMD64)
    strVersion.append(";Win64;x64");
  else if (si.wProcessorArchitecture==PROCESSOR_ARCHITECTURE_IA64)
    strVersion.append(";Win64;IA64");

  return strVersion;
}

   /// <summary>Identify the windows version</summary>
   WindowsVersion::WindowsVersion() : Version(OS::Future)
   {
      // Prepare
      ZeroMemory((OSVERSIONINFO*)this, sizeof(OSVERSIONINFO));
      dwOSVersionInfoSize = sizeof(OSVERSIONINFO);
   
      // Query windows version
      if (GetVersionEx(this))
      {
         switch (dwMajorVersion)
         {
         // [WINDOWS NT 5] Windows 2000 or Windows XP
         case 5:  
            switch (dwMinorVersion)
            {
            case 0:  Version = OS::Win2000;     break;
            case 1:  Version = OS::WinXP;       break;
            case 2:  Version = OS::Server2003;  break;
            }
            break;

         // [WINDOWS NT 6] Windows Vista, 7, or newer
         case 6:
            switch (dwMinorVersion)
            {
            case 0:  Version = OS::Vista;   break;
            case 1:  Version = OS::Win7;    break;
            default: Version = OS::Future;  break;
            }
            break;
         }
      }

      // Set name
      switch (Version)
      {
      case OS::Win2000:    Name = L"Windows 2000";         break;
      case OS::WinXP:      Name = L"Windows XP";           break;
      case OS::Server2003: Name = L"Windows Server 2003";  break;
      case OS::Vista:      Name = L"Windows Vista";        break;
      case OS::Win7:       Name = L"Windows 7";            break;
      case OS::Future:     Name = L"Windows Future";       break;
      }

      // Set Full name
      FullName = VString(L"%s %s (v%d.%d)", Name.c_str(), szCSDVersion, dwMajorVersion, dwMinorVersion);

      // Query architecture
      SYSTEM_INFO si;
      GetNativeSystemInfo(&si);
      switch (si.wProcessorArchitecture)
      {
      case PROCESSOR_ARCHITECTURE_AMD64:   Architecture = L"x64";      break;
      case PROCESSOR_ARCHITECTURE_IA64:    Architecture = L"Itanium";  break;
      case PROCESSOR_ARCHITECTURE_INTEL:   Architecture = L"x86";      break;
      default:
      case PROCESSOR_ARCHITECTURE_UNKNOWN: Architecture = L"Unknown";  break;
      }
   }

/* Create a YAML file describing the image encoded into a null terminated
   string. Caller will own the memory.
   */
char *store_metadata_(struct PmemMemoryInfo *info)
{
	SYSTEM_INFO sys_info;
	struct tm newtime;
	__time32_t aclock;

	char time_buffer[32];
	errno_t errNum;
	char *arch = NULL;

	_time32(&aclock);   // Get time in seconds.
	_gmtime32_s(&newtime, &aclock);   // Convert time to struct tm form.

	// Print local time as a string.
	errNum = asctime_s(time_buffer, 32, &newtime);
	if (errNum) {
		time_buffer[0] = 0;
	}

	// Get basic architecture information (Note that we always write ELF64 core
	// dumps - even on 32 bit platforms).
	ZeroMemory(&sys_info, sizeof(sys_info));
	GetNativeSystemInfo(&sys_info);

	switch (sys_info.wProcessorArchitecture) {
	case PROCESSOR_ARCHITECTURE_AMD64:
		arch = "AMD64";
		break;

	case PROCESSOR_ARCHITECTURE_INTEL:
		arch = "I386";
		break;

	default:
		arch = "Unknown";
	}

	char *buffer = (char *)malloc(1000);
	_snprintf_s(buffer, 1000, _TRUNCATE,
		// A YAML File describing metadata about this image.
		"# PMEM\n"
		"---\n"   // The start of the YAML file.
		"acquisition_tool: 'WinPMEM " PMEM_VERSION "'\n"
		"acquisition_timestamp: %s\n"
		"CR3: %#llx\n"
		"NtBuildNumber: %#llx\n"
		"NtBuildNumberAddr: %#llx\n"
		"KernBase: %#llx\n"
		"Arch: %s\n"
		"...\n",  // This is the end of a YAML file.
		time_buffer,
		info->CR3.QuadPart,
		info->NtBuildNumber.QuadPart,
		info->NtBuildNumberAddr.QuadPart,
		info->KernBase.QuadPart,
		arch
	);
	return buffer;
};

/*** CPU ***/
unsigned vlc_GetCPUCount (void)
{
    SYSTEM_INFO systemInfo;

    GetNativeSystemInfo(&systemInfo);

    return systemInfo.dwNumberOfProcessors;
}

int
cpu_count()
{
  SYSTEM_INFO si;

  GetNativeSystemInfo( &si );
  return (int)si.dwNumberOfProcessors;
}

/// <summary>
/// Capture stack frames
/// </summary>
/// <param name="ip">Current instruction pointer</param>
/// <param name="sp">Current stack pointer</param>
/// <param name="results">Found frames.</param>
/// <param name="depth">Frame depth limit</param>
/// <returns>Number of found frames</returns>
size_t TraceHook::StackBacktrace( uintptr_t ip, uintptr_t sp, vecStackFrames& results, uintptr_t depth /*= 10 */ )
{
    SYSTEM_INFO sysinfo = { 0 };
    uintptr_t stack_base = (uintptr_t)((PNT_TIB)NtCurrentTeb())->StackBase;

    GetNativeSystemInfo( &sysinfo );

    // Store exception address
    results.emplace_back( std::make_pair( 0, ip ) );

    // Walk stack
    for (uintptr_t stackPtr = sp; stackPtr < stack_base && results.size() <= depth; stackPtr += sizeof(void*))
    {
        uintptr_t stack_val = *(uintptr_t*)stackPtr;
        MEMORY_BASIC_INFORMATION meminfo = { 0 };

        // Decode value
        uintptr_t original = stack_val & HIGHEST_BIT_UNSET;

        // Invalid value
        if ( original < (uintptr_t)sysinfo.lpMinimumApplicationAddress ||
             original > (uintptr_t)sysinfo.lpMaximumApplicationAddress)
        {
            continue;
        }

        // Check if memory is executable
        if (VirtualQuery( (LPVOID)original, &meminfo, sizeof(meminfo) ) != sizeof(meminfo))
            continue;

        if ( meminfo.Protect != PAGE_EXECUTE_READ &&
             meminfo.Protect != PAGE_EXECUTE_WRITECOPY &&
             meminfo.Protect != PAGE_EXECUTE_READWRITE)
        {
            continue;
        }

        // Detect 'call' instruction
        for (uintptr_t j = 1; j < 8; j++)
        {
            DISASM info = { 0 };
            info.EIP = original - j;

        #ifdef _M_AMD64
            info.Archi = 64;
        #endif  

            if (Disasm( &info ) > 0 && info.Instruction.BranchType == CallType)
            {
                results.emplace_back( std::make_pair( stackPtr, stack_val ) );
                break;
            }
        }

    }

    return results.size();
}

int iam32on64 ()
{
  SYSTEM_INFO sysinfo_32, sysinfo_64;
  sysinfo_32.wProcessorArchitecture = 0;
  sysinfo_64.wProcessorArchitecture = 0;
  GetNativeSystemInfo (&sysinfo_64);
  GetSystemInfo (&sysinfo_32);
  return sysinfo_64.wProcessorArchitecture != sysinfo_32.wProcessorArchitecture && sysinfo_64.wProcessorArchitecture == PROCESSOR_ARCHITECTURE_AMD64;
}