nel/src/misc/win_thread.cpp

   1 // NeL - MMORPG Framework <http://dev.ryzom.com/projects/nel/>
   2 // Copyright (C) 2010  Winch Gate Property Limited
   3 //
   4 // This source file has been modified by the following contributors:
   5 // Copyright (C) 2012-2020  Jan BOON (Kaetemi) <jan.boon@kaetemi.be>
   6 //
   7 // This program is free software: you can redistribute it and/or modify
   8 // it under the terms of the GNU Affero General Public License as
   9 // published by the Free Software Foundation, either version 3 of the
  10 // License, or (at your option) any later version.
  11 //
  12 // This program is distributed in the hope that it will be useful,
  13 // but WITHOUT ANY WARRANTY; without even the implied warranty of
  14 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15 // GNU Affero General Public License for more details.
  16 //
  17 // You should have received a copy of the GNU Affero General Public License
  18 // along with this program.  If not, see <http://www.gnu.org/licenses/>.
  19
  20 #include "stdmisc.h"
  21 #include "nel/misc/win_thread.h"
  22
  23 #ifdef NL_OS_WINDOWS
  24
  25 #include "nel/misc/path.h"
  26 #ifndef NL_COMP_MINGW
  27 #define NOMINMAX
  28 #endif
  29 #include <windows.h>
  30
  31 #include <typeinfo>
  32
  33 #ifdef DEBUG_NEW
  34         #define new DEBUG_NEW
  35 #endif
  36
  37 namespace NLMISC {
  38
  39 CWinThread MainThread ((void*)GetCurrentThread (), GetCurrentThreadId());
  40 DWORD TLSThreadPointer = 0xFFFFFFFF;
  41
  42 // the IThread static creator
  43 IThread *IThread::create (IRunnable *runnable, uint32 stackSize)
  44 {
  45         return new CWinThread (runnable, stackSize);
  46 }
  47
  48 IThread *IThread::getCurrentThread ()
  49 {
  50         // TLS alloc must have been done
  51         nlassert (TLSThreadPointer != 0xffffffff);
  52
  53         // Get the thread pointer
  54         IThread *thread = (IThread*)TlsGetValue (TLSThreadPointer);
  55
  56         // Return current thread
  57         return thread;
  58 }
  59
  60 static unsigned long __stdcall ProxyFunc (void *arg)
  61 {
  62         CWinThread *parent = (CWinThread *) arg;
  63
  64         // TLS alloc must have been done
  65         nlassert (TLSThreadPointer != 0xffffffff);
  66
  67         // Set the thread pointer in TLS memory
  68         nlverify (TlsSetValue (TLSThreadPointer, (void*)parent) != 0);
  69
  70         // Attach exception handler
  71         attachExceptionHandler();
  72
  73         // Run the thread
  74         parent->Runnable->run();
  75
  76         return 0;
  77 }
  78
  79 CWinThread::CWinThread (IRunnable *runnable, uint32 stackSize)
  80 {
  81         _StackSize = stackSize;
  82         this->Runnable = runnable;
  83         ThreadHandle = NULL;
  84         _SuspendCount = -1;
  85         _MainThread = false;
  86 }
  87
  88 namespace {
  89 class CWinCriticalSection
  90 {
  91 private:
  92         CRITICAL_SECTION cs;
  93 public:
  94         CWinCriticalSection() { InitializeCriticalSection(&cs); }
  95         ~CWinCriticalSection() { DeleteCriticalSection(&cs); }
  96         inline void enter() { EnterCriticalSection(&cs); }
  97         inline void leave() { LeaveCriticalSection(&cs); }
  98 };
  99 CWinCriticalSection s_CS;
 100 }/* anonymous namespace */
 101
 102 CWinThread::CWinThread (void* threadHandle, uint32 threadId)
 103 {
 104         // Main thread
 105         _MainThread = true;
 106         this->Runnable = NULL;
 107         ThreadHandle = threadHandle;
 108         ThreadId = threadId;
 109
 110         // TLS alloc must have been done
 111         TLSThreadPointer = TlsAlloc ();
 112         nlassert (TLSThreadPointer!=0xffffffff);
 113
 114         // Set the thread pointer in TLS memory
 115         nlverify (TlsSetValue (TLSThreadPointer, (void*)this) != 0);
 116
 117         if (GetCurrentThreadId() == threadId)
 118         {
 119                 _SuspendCount = 0; // is calling thread call this itself, well, if we reach this place
 120                                                    // there are chances that it is not suspended ...
 121         }
 122         else
 123         {
 124                 // initialized from another thread (very unlikely ...)
 125                 nlassert(0); // WARNING: following code has not tested! don't know if it work fo real ...
 126                                          // This is just a suggestion of a possible solution, should this situation one day occur ...
 127                 // Ensure that this thread don't get deleted, or we could suspend the main thread
 128                 s_CS.enter();
 129                 // the 2 following statement must be executed atomicaly among the threads of the current process !
 130                 SuspendThread(threadHandle);
 131                 _SuspendCount = ResumeThread(threadHandle);
 132                 s_CS.leave();
 133         }
 134 }
 135
 136
 137 void CWinThread::incSuspendCount()
 138 {
 139         nlassert(ThreadHandle); // start was not called !!
 140         int newSuspendCount = ::SuspendThread(ThreadHandle) + 1;
 141         nlassert(newSuspendCount != 0xffffffff); // more infos with 'GetLastError'
 142         nlassert(newSuspendCount == _SuspendCount + 1); // is this assert fire , then 'SuspendThread' or 'ResumeThread'
 143                                                                                                         // have been called outside of this object interface! (on this thread handle ...)
 144         _SuspendCount = newSuspendCount;
 145 }
 146
 147 void CWinThread::decSuspendCount()
 148 {
 149         nlassert(ThreadHandle); // 'start' was not called !!
 150         nlassert(_SuspendCount > 0);
 151         int newSuspendCount = ::ResumeThread(ThreadHandle) - 1;
 152         nlassert(newSuspendCount != 0xffffffff); // more infos with 'GetLastError'
 153         nlassert(newSuspendCount == _SuspendCount - 1); // is this assert fire , then 'SuspendThread' or 'ResumeThread'
 154                                                                                                         // have been called outside of this object interface! (on this thread handle ...)
 155         _SuspendCount = newSuspendCount;
 156 }
 157
 158 void CWinThread::suspend()
 159 {
 160         if (getSuspendCount() == 0)
 161         {
 162                 incSuspendCount();
 163         }
 164 }
 165
 166 void CWinThread::resume()
 167 {
 168         while (getSuspendCount() != 0)
 169         {
 170                 decSuspendCount();
 171         }
 172 }
 173
 174 void CWinThread::setPriority(TThreadPriority priority)
 175 {
 176         nlassert(ThreadHandle); // 'start' was not called !!
 177         BOOL result = SetThreadPriority(ThreadHandle, (int)priority);
 178         nlassert(result);
 179 }
 180
 181 void CWinThread::enablePriorityBoost(bool enabled)
 182 {
 183         nlassert(ThreadHandle); // 'start' was not called !!
 184         SetThreadPriorityBoost(ThreadHandle, enabled ? TRUE : FALSE);
 185 }
 186
 187
 188 CWinThread::~CWinThread ()
 189 {
 190         // If not the main thread
 191         if (_MainThread)
 192         {
 193                 // Free TLS memory
 194                 nlassert (TLSThreadPointer!=0xffffffff);
 195                 TlsFree (TLSThreadPointer);
 196         }
 197         else
 198         {
 199                 if (ThreadHandle != NULL) terminate();
 200         }
 201 }
 202
 203 void CWinThread::start ()
 204 {
 205         if (isRunning())
 206                 throw EThread("Starting a thread that is already started, existing thread will continue running, this should not happen");
 207
 208 //      ThreadHandle = (void *) ::CreateThread (NULL, _StackSize, ProxyFunc, this, 0, (DWORD *)&ThreadId);
 209         ThreadHandle = (void *) ::CreateThread (NULL, 0, ProxyFunc, this, 0, (DWORD *)&ThreadId);
 210 //      nldebug("NLMISC: thread %x started for runnable '%x'", typeid( Runnable ).name());
 211 //      OutputDebugString(toString(NL_LOC_MSG " NLMISC: thread %x started for runnable '%s'\n", ThreadId, typeid( *Runnable ).name()).c_str());
 212         if (ThreadHandle == NULL)
 213         {
 214                 throw EThread ( "Cannot create new thread" );
 215         }
 216         SetThreadPriorityBoost (ThreadHandle, TRUE); // FALSE == Enable Priority Boost
 217
 218         _SuspendCount = 0;
 219 }
 220
 221 bool CWinThread::isRunning()
 222 {
 223         if (ThreadHandle == NULL)
 224                 return false;
 225
 226         DWORD exitCode;
 227         if (!GetExitCodeThread(ThreadHandle, &exitCode))
 228                 return false;
 229
 230         return exitCode == STILL_ACTIVE;
 231 }
 232
 233
 234 void CWinThread::terminate ()
 235 {
 236         TerminateThread((HANDLE)ThreadHandle, 0);
 237         CloseHandle((HANDLE)ThreadHandle);
 238         ThreadHandle = NULL;
 239         _SuspendCount = -1;
 240 }
 241
 242 void CWinThread::wait ()
 243 {
 244         if (ThreadHandle == NULL) return;
 245
 246         WaitForSingleObject(ThreadHandle, INFINITE);
 247         CloseHandle(ThreadHandle);
 248         ThreadHandle = NULL;
 249         _SuspendCount = -1;
 250 }
 251
 252 bool CWinThread::setCPUMask(uint64 cpuMask)
 253 {
 254         // Thread must exist
 255         if (ThreadHandle == NULL)
 256                 return false;
 257
 258         // Ask the system for number of processor available for this process
 259         return SetThreadAffinityMask ((HANDLE)ThreadHandle, (DWORD_PTR)cpuMask) != 0;
 260 }
 261
 262 uint64 CWinThread::getCPUMask()
 263 {
 264         // Thread must exist
 265         if (ThreadHandle == NULL)
 266                 return 1;
 267
 268         // Get the current process mask
 269         uint64 mask=IProcess::getCurrentProcess ()->getCPUMask ();
 270
 271         // Get thread affinity mask
 272         DWORD_PTR old = SetThreadAffinityMask ((HANDLE)ThreadHandle, (DWORD_PTR)mask);
 273         nlassert (old != 0);
 274         if (old == 0)
 275                 return 1;
 276
 277         // Reset it
 278         SetThreadAffinityMask ((HANDLE)ThreadHandle, old);
 279
 280         // Return the mask
 281         return (uint64)old;
 282 }
 283
 284 std::string CWinThread::getUserName()
 285 {
 286         wchar_t userName[512];
 287         DWORD size = 512;
 288         GetUserNameW (userName, &size);
 289         return wideToUtf8(userName);
 290 }
 291
 292 // **** Process
 293
 294 // The current process
 295 CWinProcess CurrentProcess ((void*)GetCurrentProcess());
 296
 297 // Get the current process
 298 IProcess *IProcess::getCurrentProcess ()
 299 {
 300         return &CurrentProcess;
 301 }
 302
 303 CWinProcess::CWinProcess (void *handle)
 304 {
 305         // Get the current process handle
 306         _ProcessHandle = handle;
 307 }
 308
 309 uint64 CWinProcess::getCPUMask()
 310 {
 311         // Ask the system for number of processor available for this process
 312         DWORD_PTR processAffinityMask;
 313         DWORD_PTR systemAffinityMask;
 314         if (GetProcessAffinityMask((HANDLE)_ProcessHandle, &processAffinityMask, &systemAffinityMask))
 315         {
 316                 // Return the CPU mask
 317                 return (uint64)processAffinityMask;
 318         }
 319         else
 320                 return 1;
 321 }
 322
 323 bool CWinProcess::setCPUMask(uint64 mask)
 324 {
 325         // Ask the system for number of processor available for this process
 326         DWORD_PTR processAffinityMask= (DWORD_PTR)mask;
 327         return SetProcessAffinityMask((HANDLE)_ProcessHandle, processAffinityMask)!=0;
 328 }
 329
 330 // ****************************************************************************************************************
 331 /**
 332  * Simple wrapper around the PSAPI library
 333  * \author Nicolas Vizerie
 334  * \author GameForge
 335  * \date 2007
 336  */
 337
 338 class CPSAPILib
 339 {
 340 public:
 341         typedef BOOL  (WINAPI *EnumProcessesFunPtr)(DWORD *lpidProcess, DWORD cb, DWORD *cbNeeded);
 342         typedef DWORD (WINAPI *GetModuleFileNameExWFunPtr)(HANDLE hProcess, HMODULE hModule, LPWSTR lpFilename, DWORD nSize);
 343         typedef BOOL  (WINAPI *EnumProcessModulesFunPtr)(HANDLE hProcess, HMODULE *lphModule, DWORD cb, LPDWORD lpcbNeeded);
 344         EnumProcessesFunPtr               EnumProcesses;
 345         GetModuleFileNameExWFunPtr GetModuleFileNameExW;
 346         EnumProcessModulesFunPtr  EnumProcessModules;
 347 public:
 348         CPSAPILib();
 349         ~CPSAPILib();
 350         bool init();
 351 private:
 352         HINSTANCE _PSAPILibHandle;
 353         bool      _LoadFailed;
 354 };
 355
 356 // ****************************************************************************************************************
 357 CPSAPILib::CPSAPILib()
 358 {
 359         _LoadFailed = false;
 360         _PSAPILibHandle     = NULL;
 361         EnumProcesses       = NULL;
 362         GetModuleFileNameExW = NULL;
 363         EnumProcessModules  = NULL;
 364 }
 365
 366 // ****************************************************************************************************************
 367 CPSAPILib::~CPSAPILib()
 368 {
 369         if (_PSAPILibHandle)
 370         {
 371                 FreeLibrary(_PSAPILibHandle);
 372         }
 373 }
 374
 375 // ****************************************************************************************************************
 376 bool CPSAPILib::init()
 377 {
 378         //
 379         if (_LoadFailed) return false;
 380         if (!_PSAPILibHandle)
 381         {
 382                 _PSAPILibHandle = LoadLibraryA("psapi.dll");
 383                 if (!_PSAPILibHandle)
 384                 {
 385                         nlwarning("couldn't load psapi.dll, possibly not supported by os");
 386                         _LoadFailed = true;
 387                         return false;
 388                 }
 389                 EnumProcesses           = (EnumProcessesFunPtr)           GetProcAddress(_PSAPILibHandle, "EnumProcesses");
 390                 GetModuleFileNameExW = (GetModuleFileNameExWFunPtr) GetProcAddress(_PSAPILibHandle, "GetModuleFileNameExW");
 391                 EnumProcessModules  = (EnumProcessModulesFunPtr)  GetProcAddress(_PSAPILibHandle, "EnumProcessModules");
 392                 if (!EnumProcesses ||
 393                         !GetModuleFileNameExW ||
 394                         !EnumProcessModules
 395                    )
 396                 {
 397                         nlwarning("Failed to import functions from psapi.dll!");
 398                         _LoadFailed = true;
 399                         return false;
 400                 }
 401         }
 402         return true;
 403 }
 404
 405
 406 static CPSAPILib PSAPILib;
 407
 408
 409
 410 // ****************************************************************************************************************
 411 bool CWinProcess::enumProcessesId(std::vector<uint32> &processesId)
 412 {
 413         if (!PSAPILib.init()) return false;
 414         // list of processes
 415         std::vector<uint32> prcIds(16);
 416         for (;;)
 417         {
 418                 DWORD cbNeeded;
 419                 if (!PSAPILib.EnumProcesses((DWORD *) &prcIds[0], (DWORD)(prcIds.size() * sizeof(DWORD)), &cbNeeded))
 420                 {
 421                         nlwarning("Processes enumeration failed!");
 422                         return false;
 423                 }
 424                 if (cbNeeded < prcIds.size() * sizeof(DWORD))
 425                 {
 426                         prcIds.resize(cbNeeded / sizeof(DWORD));
 427                         break;
 428                 }
 429                 // make some more room
 430                 prcIds.resize(prcIds.size() * 2);
 431         }
 432         processesId.swap(prcIds);
 433         return true;
 434 }
 435
 436 // ****************************************************************************************************************
 437 bool CWinProcess::enumProcessModules(uint32 processId, std::vector<std::string> &moduleNames)
 438 {
 439         if (!PSAPILib.init()) return false;
 440         HANDLE hProcess = OpenProcess(PROCESS_QUERY_INFORMATION|PROCESS_VM_READ, FALSE, (DWORD) processId);
 441         if (!hProcess) return false;
 442         // list of modules
 443         std::vector<HMODULE> prcModules(2);
 444         for (;;)
 445         {
 446                 DWORD cbNeeded;
 447                 if (!PSAPILib.EnumProcessModules(hProcess, (HMODULE *) &prcModules[0], (DWORD)(prcModules.size() * sizeof(HMODULE)), &cbNeeded))
 448                 {
 449                         //nlwarning("Processe modules enumeration failed!");
 450                         return false;
 451                 }
 452                 if (cbNeeded < prcModules.size() * sizeof(HMODULE))
 453                 {
 454                         prcModules.resize(cbNeeded / sizeof(HMODULE));
 455                         break;
 456                 }
 457                 // make some more room
 458                 prcModules.resize(prcModules.size() * 2);
 459         }
 460         moduleNames.clear();
 461         std::vector<std::string> resultModuleNames;
 462         wchar_t moduleName[MAX_PATH + 1];
 463         for (uint m = 0; m < prcModules.size(); ++m)
 464         {
 465                 if (PSAPILib.GetModuleFileNameExW(hProcess, prcModules[m], moduleName, MAX_PATH))
 466                 {
 467                         moduleNames.push_back(wideToUtf8(moduleName));
 468                 }
 469         }
 470         CloseHandle(hProcess);
 471         return true;
 472 }
 473
 474 // ****************************************************************************************************************
 475 uint32 CWinProcess::getProcessIdFromModuleFilename(const std::string &moduleFileName)
 476 {
 477         std::vector<uint32> processesId;
 478         if (!enumProcessesId(processesId)) return false;
 479         std::vector<std::string> moduleNames;
 480         for (uint prc = 0; prc < processesId.size(); ++prc)
 481         {
 482                 if (enumProcessModules(processesId[prc], moduleNames))
 483                 {
 484                         for (uint m = 0; m < moduleNames.size(); ++m)
 485                         {
 486                                 if (nlstricmp(CFile::getFilename(moduleNames[m]), moduleFileName) == 0)
 487                                 {
 488                                         return processesId[prc];
 489                                 }
 490                         }
 491                 }
 492         }
 493         return 0;
 494 }
 495
 496 // ****************************************************************************************************************
 497 bool CWinProcess::terminateProcess(uint32 processId, uint exitCode)
 498 {
 499         if (!processId) return false;
 500         HANDLE hProcess = OpenProcess(PROCESS_TERMINATE, FALSE, (DWORD) processId);
 501         if (!hProcess) return false;
 502         BOOL ok = TerminateProcess(hProcess, (UINT) exitCode);
 503         CloseHandle(hProcess);
 504         return ok != FALSE;
 505 }
 506
 507 // ****************************************************************************************************************
 508 bool CWinProcess::terminateProcessFromModuleName(const std::string &moduleName, uint exitCode)
 509 {
 510         return terminateProcess(getProcessIdFromModuleFilename(moduleName), exitCode);
 511 }
 512
 513
 514 ///////////////////
 515 // CProcessWatch //
 516 ///////////////////
 517
 518
 519 /*
 520
 521 //  I didn't use and test that code, eventually, but maybe useful in the future
 522
 523 class CProcessWatchTask : public IRunnable
 524 {
 525 public:
 526         HANDLE HProcess;
 527 public:
 528         CProcessWatchTask(HANDLE hProcess) : HProcess(hProcess)
 529         {
 530         }
 531         virtual void run()
 532         {
 533                 WaitForSingleObject(HProcess, INFINITE);
 534         }
 535 };
 536
 537 class CProcessWatchImpl
 538 {
 539 public:
 540         bool Launched;
 541         IThread                         *WatchThread;
 542         CProcessWatchTask       *WatchTask;
 543 public:
 544         CProcessWatchImpl() : Launched(false), WatchThread(NULL), WatchTask(NULL)
 545         {
 546         }
 547         ~CProcessWatchImpl()
 548         {
 549                 reset();
 550         }
 551         void reset()
 552         {
 553                 if (WatchThread)
 554                 {
 555                         if (WatchThread->isRunning())
 556                         {
 557                                 WatchThread->terminate();
 558                         }
 559                         delete WatchTask;
 560                         delete WatchThread;
 561                         WatchTask = NULL;
 562                         WatchThread = NULL;
 563                         Launched = false;
 564                 }
 565         }
 566         bool launch(const std::string &programName, const std::string &arguments)
 567         {
 568                 if (isRunning()) return false;
 569                 PROCESS_INFORMATION processInfo;
 570                 STARTUPINFO startupInfo = {0};
 571                 startupInfo.cb = sizeof(STARTUPINFO);
 572                 if (CreateProcessW(programName.c_str(), const_cast<LPTSTR>(arguments.c_str()), NULL, NULL, FALSE, 0, NULL, NULL, &startupInfo, &processInfo))
 573                 {
 574                         WatchTask = new CProcessWatchTask(processInfo.hProcess);
 575                         WatchThread = IThread::create(WatchTask);
 576                         WatchThread->start();
 577                         Launched = true;
 578                         return true;
 579                 }
 580                 return false;
 581         }
 582         bool isRunning()
 583         {
 584                 if (!Launched) return false;
 585                 nlassert(WatchThread);
 586                 nlassert(WatchTask);
 587                 if (WatchThread->isRunning()) return true;
 588                 reset();
 589                 return false;
 590         }
 591 };
 592
 593
 594 CProcessWatch::CProcessWatch()
 595 {
 596         _PImpl = new CProcessWatchImpl;
 597 }
 598
 599 CProcessWatch::~CProcessWatch()
 600 {
 601         delete _PImpl;
 602 }
 603
 604 bool CProcessWatch::launch(const std::string &programName, const std::string &arguments)
 605 {
 606         return _PImpl->launch(programName, arguments);
 607 }
 608
 609 bool CProcessWatch::isRunning() const
 610 {
 611         return _PImpl->isRunning();
 612 }
 613
 614 */
 615 } // NLMISC
 616
 617 #endif // NL_OS_WINDOWS