/* * Copyright (C) 2026 Linux Studio Plugins Project * (C) 2026 Vladimir Sadovnikov * * This file is part of lsp-runtime-lib * Created on: 25 февр. 2019 г. * * lsp-runtime-lib is free software: you can redistribute it and/or modify * it under the terms of the GNU Lesser General Public License as published by * the Free Software Foundation, either version 3 of the License, or * any later version. * * lsp-runtime-lib is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU Lesser General Public License for more details. * * You should have received a copy of the GNU Lesser General Public License * along with lsp-runtime-lib. If not, see . */ #include #include #include #include #include #include #if defined(PLATFORM_WINDOWS) #include #include #elif defined(PLATFORM_LINUX) #include #include #elif defined(PLATFORM_SOLARIS) #include #elif defined(PLATFORM_FREEBSD) #include #include #elif defined(PLATFORM_NETBSD) #include #include #elif defined(PLATFORM_MACOSX) #include #include #include #elif defined(PLATFORM_DRAGONFLYBSD) #include #include #elif defined(PLATFORM_HAIKU) #include #endif /* PLATFORM_WINDOWS */ namespace lsp { namespace ipc { __thread Thread *Thread::pThis = NULL; #if defined(PLATFORM_WINDOWS) #define CLR_HANDLE(hThread) hThread = INVALID_HANDLE_VALUE; #else #define CLR_HANDLE(hThread) hThread = 0; #endif Thread::Thread() { atomic_store(&enState, TS_CREATED); nResult = STATUS_OK; bCancelled = false; CLR_HANDLE(hThread); sBinding.proc = NULL; sBinding.arg = NULL; sBinding.runnable = NULL; } Thread::Thread(thread_proc_t proc) { atomic_store(&enState, TS_CREATED); nResult = STATUS_OK; bCancelled = false; CLR_HANDLE(hThread); sBinding.proc = proc; sBinding.arg = NULL; sBinding.runnable = NULL; } Thread::Thread(thread_proc_t proc, void *arg) { atomic_store(&enState, TS_CREATED); nResult = STATUS_OK; bCancelled = false; CLR_HANDLE(hThread); sBinding.proc = proc; sBinding.runnable = NULL; sBinding.arg = arg; } Thread::Thread(IRunnable *runnable) { atomic_store(&enState, TS_CREATED); nResult = STATUS_OK; bCancelled = false; CLR_HANDLE(hThread); sBinding.proc = NULL; sBinding.arg = NULL; sBinding.runnable = runnable; } Thread::~Thread() { #if defined(PLATFORM_WINDOWS) if (hThread != INVALID_HANDLE_VALUE) CloseHandle(hThread); #endif /* PLATFORM_WINDOWS */ CLR_HANDLE(hThread); } status_t Thread::run() { if (sBinding.proc != NULL) return sBinding.proc(sBinding.arg); else if (sBinding.runnable != NULL) return sBinding.runnable->run(); return STATUS_OK; } status_t Thread::cancel() { switch (atomic_load(&enState)) { case TS_PENDING: case TS_RUNNING: break; default: return STATUS_BAD_STATE; } bCancelled = true; return STATUS_OK; } #if defined(PLATFORM_WINDOWS) DWORD WINAPI Thread::thread_launcher(_In_ LPVOID lpParameter) { Thread *_this = reinterpret_cast(lpParameter); pThis = _this; // Wait until we are ready to launch while (!atomic_cas(&_this->enState, TS_PENDING, TS_RUNNING)) {} // Execute the thread status_t res = _this->run(); pThis = NULL; // Commit the 'FINISHED' status int state; do { state = atomic_load(&_this->enState); } while (!atomic_cas(&_this->enState, state, TS_FINISHED)); _this->nResult = res; return 0; } status_t Thread::start() { DWORD tid; HANDLE thandle = CreateThread(NULL, 0, thread_launcher, this, 0, &tid); if (thandle == INVALID_HANDLE_VALUE) return STATUS_UNKNOWN_ERR; hThread = thandle; atomic_store(&enState, TS_PENDING); return STATUS_OK; } status_t Thread::join() { switch (atomic_load(&enState)) { case TS_CREATED: return STATUS_BAD_STATE; case TS_PENDING: case TS_RUNNING: { DWORD res = WaitForSingleObject(hThread, INFINITE); if ((res != WAIT_OBJECT_0) && (res != WAIT_ABANDONED)) return STATUS_UNKNOWN_ERR; break; } case TS_FINISHED: return STATUS_OK; default: return STATUS_BAD_STATE; } return STATUS_OK; } status_t Thread::sleep(wsize_t millis) { if (pThis == NULL) { while (millis > 0) { DWORD interval = (millis > 500) ? 500 : millis; Sleep(interval); millis -= interval; } } else { if (pThis->bCancelled) return STATUS_CANCELLED; while (millis > 0) { if (pThis->bCancelled) return STATUS_CANCELLED; DWORD interval = (millis > 100) ? 100 : millis; Sleep(interval); millis -= interval; } } return STATUS_OK; } void Thread::yield() { SwitchToThread(); } #else void *Thread::thread_launcher(void *arg) { Thread *_this = reinterpret_cast(arg); pThis = _this; // Cleanup cancellation state pthread_setcancelstate(PTHREAD_CANCEL_DISABLE, NULL); pthread_setcanceltype(PTHREAD_CANCEL_DEFERRED, NULL); // Wait until we are ready to launch while (!atomic_cas(&_this->enState, TS_PENDING, TS_RUNNING)) {} // Execute the thread status_t res = _this->run(); // Commit the 'FINISHED' status int state; do { state = atomic_load(&_this->enState); } while (!atomic_cas(&_this->enState, state, TS_FINISHED)); _this->nResult = res; return NULL; } status_t Thread::start() { pthread_t tid; if (pthread_create(&tid, NULL, &thread_launcher, this) != 0) return STATUS_UNKNOWN_ERR; hThread = tid; atomic_store(&enState, TS_PENDING); return STATUS_OK; } status_t Thread::join() { switch (atomic_load(&enState)) { case TS_CREATED: return STATUS_BAD_STATE; case TS_PENDING: case TS_RUNNING: if (pthread_join(hThread, NULL) != 0) return STATUS_UNKNOWN_ERR; break; case TS_FINISHED: return STATUS_OK; default: return STATUS_BAD_STATE; } return STATUS_OK; } status_t Thread::sleep(wsize_t millis) { struct timespec req, rem; if (pThis == NULL) { req.tv_sec = millis / 1000; req.tv_nsec = (millis % 1000) * 1000000; while (::nanosleep(&req, &rem) != 0) { int code = errno; if (code != EINTR) return STATUS_UNKNOWN_ERR; req = rem; } } else { if (pThis->bCancelled) return STATUS_CANCELLED; while (millis > 0) { if (pThis->bCancelled) return STATUS_CANCELLED; wsize_t interval = (millis > 100) ? 100 : millis; req.tv_sec = 0; req.tv_nsec = interval * 1000000; while (::nanosleep(&req, &rem) != 0) { int code = errno; if (code != EINTR) return STATUS_UNKNOWN_ERR; if (pThis->bCancelled) return STATUS_CANCELLED; req = rem; } millis -= interval; } } return STATUS_OK; } void Thread::yield() { sched_yield(); } #endif /* PLATFORM_WINDOWS */ thread_id_t Thread::current_thread_id() { thread_id_t result = INVALID_THREAD_ID; #if defined(PLATFORM_WINDOWS) return GetCurrentThreadId(); #elif defined(PLATFORM_LINUX) result = syscall( __NR_gettid ); #elif defined(PLATFORM_SOLARIS) result = pthread_self(); #elif defined(PLATFORM_MACOSX) const mach_port_t port = mach_thread_self(); mach_port_deallocate(mach_task_self(), port); result = port; #elif defined(PLATFORM_NETBSD) result = _lwp_self(); #elif defined(PLATFORM_FREEBSD) long lwpid; thr_self( &lwpid ); result = lwpid; #elif defined(PLATFORM_DRAGONFLYBSD) result = lwp_gettid(); #elif defined (PLATFORM_HAIKU) result = find_thread(NULL); #else #error "need to implement Thread::current_thread_id" #endif return result; } } /* namespace ipc */ } /* namespace lsp */