/**************************************************************************** * Copyright (C) 2017 Intel Corporation. All Rights Reserved. * * Permission is hereby granted, free of charge, to any person obtaining a * copy of this software and associated documentation files (the "Software"), * to deal in the Software without restriction, including without limitation * the rights to use, copy, modify, merge, publish, distribute, sublicense, * and/or sell copies of the Software, and to permit persons to whom the * Software is furnished to do so, subject to the following conditions: * * The above copyright notice and this permission notice (including the next * paragraph) shall be included in all copies or substantial portions of the * Software. * * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS * IN THE SOFTWARE. ****************************************************************************/ #include "common/os.h" #include #include #include #if defined(_WIN32) #include #endif // Windows #if defined(__APPLE__) || defined(FORCE_LINUX) || defined(__linux__) || defined(__gnu_linux__) #include #endif // Linux #if defined(_WIN32) static const DWORD MS_VC_EXCEPTION = 0x406D1388; #pragma pack(push,8) typedef struct tagTHREADNAME_INFO { DWORD dwType; // Must be 0x1000. LPCSTR szName; // Pointer to name (in user addr space). DWORD dwThreadID; // Thread ID (-1=caller thread). DWORD dwFlags; // Reserved for future use, must be zero. } THREADNAME_INFO; #pragma pack(pop) void LegacySetThreadName(const char* pThreadName) { THREADNAME_INFO info; info.dwType = 0x1000; info.szName = pThreadName; info.dwThreadID = GetCurrentThreadId(); info.dwFlags = 0; if (!IsDebuggerPresent()) { // No debugger attached to interpret exception, no need to actually do it return; } #pragma warning(push) #pragma warning(disable: 6320 6322) __try { RaiseException(MS_VC_EXCEPTION, 0, sizeof(info) / sizeof(ULONG_PTR), (ULONG_PTR*)&info); } __except (EXCEPTION_EXECUTE_HANDLER) { } #pragma warning(pop) } #endif // _WIN32 void SWR_API SetCurrentThreadName(const char* pThreadName) { #if defined(_WIN32) // The SetThreadDescription API was brought in version 1607 of Windows 10. typedef HRESULT(WINAPI* PFNSetThreadDescription)(HANDLE hThread, PCWSTR lpThreadDescription); // The SetThreadDescription API works even if no debugger is attached. auto pfnSetThreadDescription = reinterpret_cast( GetProcAddress(GetModuleHandleA("Kernel32.dll"), "SetThreadDescription")); if (!pfnSetThreadDescription) { // try KernelBase.dll pfnSetThreadDescription = reinterpret_cast( GetProcAddress(GetModuleHandleA("KernelBase.dll"), "SetThreadDescription")); } if (pfnSetThreadDescription) { std::string utf8Name = pThreadName; std::wstring wideName; wideName.resize(utf8Name.size() + 1); swprintf_s(&(wideName.front()), wideName.size(), L"%S", utf8Name.c_str()); HRESULT hr = pfnSetThreadDescription(GetCurrentThread(), wideName.c_str()); SWR_ASSERT(SUCCEEDED(hr), "Failed to set thread name to %s", pThreadName); // Fall through - it seems like some debuggers only recognize the exception } // Fall back to exception based hack LegacySetThreadName(pThreadName); #endif // _WIN32 #if defined(FORCE_LINUX) || defined(__linux__) || defined(__gnu_linux__) pthread_setname_np(pthread_self(), pThreadName); #endif // Linux } static void SplitString(std::vector& out_segments, const std::string& input, char splitToken) { out_segments.clear(); std::istringstream f(input); std::string s; while (std::getline(f, s, splitToken)) { if (s.size()) { out_segments.push_back(s); } } } void SWR_API CreateDirectoryPath(const std::string& path) { #if defined(_WIN32) SHCreateDirectoryExA(nullptr, path.c_str(), nullptr); #endif // Windows #if defined(__APPLE__) || defined(FORCE_LINUX) || defined(__linux__) || defined(__gnu_linux__) std::vector pathSegments; SplitString(pathSegments, path, '/'); std::string tmpPath; for (auto const& segment : pathSegments) { tmpPath.push_back('/'); tmpPath += segment; int result = mkdir(tmpPath.c_str(), 0777); if (result == -1 && errno != EEXIST) { break; } } #endif // Unix } /// Execute Command (block until finished) /// @returns process exit value int SWR_API ExecCmd( const std::string& cmd, ///< (In) Command line string const char* pOptEnvStrings, ///< (Optional In) Environment block for new process std::string* pOptStdOut, ///< (Optional Out) Standard Output text std::string* pOptStdErr, ///< (Optional Out) Standard Error text const std::string* pOptStdIn) ///< (Optional In) Standard Input text { int rvalue = -1; #if defined(_WIN32) struct WinPipe { HANDLE hRead; HANDLE hWrite; }; std::array hPipes = {}; SECURITY_ATTRIBUTES saAttr = { sizeof(SECURITY_ATTRIBUTES) }; saAttr.bInheritHandle = TRUE; //Pipe handles are inherited by child process. saAttr.lpSecurityDescriptor = NULL; { bool bFail = false; for (WinPipe& p : hPipes) { if (!CreatePipe(&p.hRead, &p.hWrite, &saAttr, 0)) { bFail = true; } } if (bFail) { for (WinPipe& p : hPipes) { CloseHandle(p.hRead); CloseHandle(p.hWrite); } return rvalue; } } STARTUPINFOA StartupInfo{}; StartupInfo.cb = sizeof(STARTUPINFOA); StartupInfo.dwFlags = STARTF_USESTDHANDLES; StartupInfo.dwFlags |= STARTF_USESHOWWINDOW; StartupInfo.wShowWindow = SW_HIDE; if (pOptStdIn) { StartupInfo.hStdInput = hPipes[0].hRead; } StartupInfo.hStdOutput = hPipes[1].hWrite; StartupInfo.hStdError = hPipes[2].hWrite; PROCESS_INFORMATION procInfo{}; // CreateProcess can modify the string std::string local_cmd = cmd; BOOL ProcessValue = CreateProcessA( NULL, (LPSTR)local_cmd.c_str(), NULL, NULL, TRUE, 0, (LPVOID)pOptEnvStrings, NULL, &StartupInfo, &procInfo); if (ProcessValue && procInfo.hProcess) { auto ReadFromPipe = [](HANDLE hPipe, std::string* pOutStr) { char buf[1024]; DWORD dwRead = 0; DWORD dwAvail = 0; while (true) { if (!::PeekNamedPipe(hPipe, NULL, 0, NULL, &dwAvail, NULL)) { break; } if (!dwAvail) // no data available, return { break; } if (!::ReadFile(hPipe, buf, std::min(sizeof(buf) - 1, size_t(dwAvail)), &dwRead, NULL) || !dwRead) { // error, the child process might ended break; } buf[dwRead] = 0; if (pOutStr) { (*pOutStr) += buf; } } }; bool bProcessEnded = false; size_t bytesWritten = 0; do { if (pOptStdIn && (pOptStdIn->size() > bytesWritten)) { DWORD bytesToWrite = static_cast(pOptStdIn->size()) - bytesWritten; if (!::WriteFile( hPipes[0].hWrite, pOptStdIn->data() + bytesWritten, bytesToWrite, &bytesToWrite, nullptr)) { // Failed to write to pipe break; } bytesWritten += bytesToWrite; } // Give some timeslice (50ms), so we won't waste 100% cpu. bProcessEnded = (WaitForSingleObject(procInfo.hProcess, 50) == WAIT_OBJECT_0); ReadFromPipe(hPipes[1].hRead, pOptStdOut); ReadFromPipe(hPipes[2].hRead, pOptStdErr); } while (!bProcessEnded); DWORD exitVal = 0; if (!GetExitCodeProcess(procInfo.hProcess, &exitVal)) { exitVal = 1; } CloseHandle(procInfo.hProcess); CloseHandle(procInfo.hThread); rvalue = exitVal; } for (WinPipe& p : hPipes) { CloseHandle(p.hRead); CloseHandle(p.hWrite); } #else // Non-Windows implementation #endif return rvalue; }