From f215e02bf85f68d3a6106c2a1f4f7f063f819064 Mon Sep 17 00:00:00 2001 From: Daniel Baumann Date: Thu, 11 Apr 2024 10:17:27 +0200 Subject: Adding upstream version 7.0.14-dfsg. Signed-off-by: Daniel Baumann --- src/VBox/Runtime/nt/semeventmulti-nt.cpp | 520 +++++++++++++++++++++++++++++++ 1 file changed, 520 insertions(+) create mode 100644 src/VBox/Runtime/nt/semeventmulti-nt.cpp (limited to 'src/VBox/Runtime/nt/semeventmulti-nt.cpp') diff --git a/src/VBox/Runtime/nt/semeventmulti-nt.cpp b/src/VBox/Runtime/nt/semeventmulti-nt.cpp new file mode 100644 index 00000000..b5be9fc6 --- /dev/null +++ b/src/VBox/Runtime/nt/semeventmulti-nt.cpp @@ -0,0 +1,520 @@ +/* $Id: semeventmulti-nt.cpp $ */ +/** @file + * IPRT - Multiple Release Event Semaphores, Ring-0 Driver, NT. + */ + +/* + * Copyright (C) 2006-2023 Oracle and/or its affiliates. + * + * This file is part of VirtualBox base platform packages, as + * available from https://www.virtualbox.org. + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation, in version 3 of the + * License. + * + * This program 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 + * General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, see . + * + * The contents of this file may alternatively be used under the terms + * of the Common Development and Distribution License Version 1.0 + * (CDDL), a copy of it is provided in the "COPYING.CDDL" file included + * in the VirtualBox distribution, in which case the provisions of the + * CDDL are applicable instead of those of the GPL. + * + * You may elect to license modified versions of this file under the + * terms and conditions of either the GPL or the CDDL or both. + * + * SPDX-License-Identifier: GPL-3.0-only OR CDDL-1.0 + */ + + +/********************************************************************************************************************************* +* Header Files * +*********************************************************************************************************************************/ +#define RTSEMEVENTMULTI_WITHOUT_REMAPPING +#ifdef IN_RING0 +# include "../r0drv/nt/the-nt-kernel.h" +#else +# include +#endif +#include + +#include +#include +#include +#include +#include +#include +#include + +#include "internal/magics.h" + + +/********************************************************************************************************************************* +* Structures and Typedefs * +*********************************************************************************************************************************/ +/** + * NT event semaphore. + */ +typedef struct RTSEMEVENTMULTIINTERNAL +{ + /** Magic value (RTSEMEVENTMULTI_MAGIC). */ + uint32_t volatile u32Magic; + /** Reference counter. */ + uint32_t volatile cRefs; +#ifdef IN_RING0 + /** The NT event object. */ + KEVENT Event; +#elif defined(IN_RING3) + /** Handle to the NT event object. */ + HANDLE hEvent; +#endif +#if defined(RTSEMEVENT_STRICT) && defined(IN_RING3) + /** Signallers. */ + RTLOCKVALRECSHRD Signallers; + /** Indicates that lock validation should be performed. */ + bool volatile fEverHadSignallers; +#endif +} RTSEMEVENTMULTIINTERNAL, *PRTSEMEVENTMULTIINTERNAL; + + +RTDECL(int) RTSemEventMultiCreate(PRTSEMEVENTMULTI phEventMultiSem) +{ + return RTSemEventMultiCreateEx(phEventMultiSem, 0 /*fFlags*/, NIL_RTLOCKVALCLASS, NULL); +} + + +RTDECL(int) RTSemEventMultiCreateEx(PRTSEMEVENTMULTI phEventMultiSem, uint32_t fFlags, RTLOCKVALCLASS hClass, + const char *pszNameFmt, ...) +{ + AssertReturn(!(fFlags & ~RTSEMEVENTMULTI_FLAGS_NO_LOCK_VAL), VERR_INVALID_PARAMETER); + RT_NOREF2(hClass, pszNameFmt); + + AssertCompile(sizeof(RTSEMEVENTMULTIINTERNAL) > sizeof(void *)); + PRTSEMEVENTMULTIINTERNAL pThis = (PRTSEMEVENTMULTIINTERNAL)RTMemAlloc(sizeof(*pThis)); + if (pThis) + { + pThis->u32Magic = RTSEMEVENTMULTI_MAGIC; + pThis->cRefs = 1; +#ifdef IN_RING0 + KeInitializeEvent(&pThis->Event, NotificationEvent, FALSE /* not signalled */); +#else + NTSTATUS rcNt = NtCreateEvent(&pThis->hEvent, EVENT_ALL_ACCESS, NULL /*pObjAttr*/, + NotificationEvent, FALSE /*not signalled*/); + if (NT_SUCCESS(rcNt)) +#endif + { +#if defined(RTSEMEVENT_STRICT) && defined(IN_RING3) + if (!pszNameFmt) + { + static uint32_t volatile s_iSemEventMultiAnon = 0; + RTLockValidatorRecSharedInit(&pThis->Signallers, hClass, RTLOCKVAL_SUB_CLASS_ANY, pThis, + true /*fSignaller*/, !(fFlags & RTSEMEVENTMULTI_FLAGS_NO_LOCK_VAL), + "RTSemEventMulti-%u", ASMAtomicIncU32(&s_iSemEventMultiAnon) - 1); + } + else + { + va_list va; + va_start(va, pszNameFmt); + RTLockValidatorRecSharedInitV(&pThis->Signallers, hClass, RTLOCKVAL_SUB_CLASS_ANY, pThis, + true /*fSignaller*/, !(fFlags & RTSEMEVENTMULTI_FLAGS_NO_LOCK_VAL), + pszNameFmt, va); + va_end(va); + } + pThis->fEverHadSignallers = false; +#else + RT_NOREF_PV(hClass); RT_NOREF_PV(pszNameFmt); +#endif + + *phEventMultiSem = pThis; + return VINF_SUCCESS; + } +#ifdef IN_RING3 + RTMemFree(pThis); + return RTErrConvertFromNtStatus(rcNt); +#endif + } + return VERR_NO_MEMORY; +} + + +/** + * Retains a reference to the semaphore. + * + * @param pThis The semaphore to retain. + */ +DECLINLINE(void) rtR0SemEventMultiNtRetain(PRTSEMEVENTMULTIINTERNAL pThis) +{ + uint32_t cRefs = ASMAtomicIncU32(&pThis->cRefs); + Assert(cRefs < 100000); NOREF(cRefs); +} + + +/** + * Releases a reference to the semaphore. + * + * @param pThis The semaphore to release + */ +DECLINLINE(void) rtR0SemEventMultiNtRelease(PRTSEMEVENTMULTIINTERNAL pThis) +{ + if (ASMAtomicDecU32(&pThis->cRefs) == 0) + { +#ifdef IN_RING3 + NTSTATUS rcNt = NtClose(pThis->hEvent); + AssertMsg(NT_SUCCESS(rcNt), ("%#x\n", rcNt)); RT_NOREF(rcNt); + pThis->hEvent = NULL; +#endif +#if defined(RTSEMEVENT_STRICT) && defined(IN_RING3) + RTLockValidatorRecSharedDelete(&pThis->Signallers); +#endif + RTMemFree(pThis); + } +} + + +RTDECL(int) RTSemEventMultiDestroy(RTSEMEVENTMULTI hEventMultiSem) +{ + /* + * Validate input. + */ + PRTSEMEVENTMULTIINTERNAL pThis = (PRTSEMEVENTMULTIINTERNAL)hEventMultiSem; + if (pThis == NIL_RTSEMEVENTMULTI) + return VINF_SUCCESS; + AssertPtrReturn(pThis, VERR_INVALID_PARAMETER); + AssertMsgReturn(pThis->u32Magic == RTSEMEVENTMULTI_MAGIC, ("%p u32Magic=%RX32\n", pThis, pThis->u32Magic), VERR_INVALID_PARAMETER); + + /* + * Invalidate it and signal the object just in case. + */ + ASMAtomicIncU32(&pThis->u32Magic); +#ifdef IN_RING0 + KeSetEvent(&pThis->Event, 0xfff, FALSE); +#else + NtSetEvent(pThis->hEvent, NULL); +#endif + + rtR0SemEventMultiNtRelease(pThis); + return VINF_SUCCESS; +} + + +RTDECL(int) RTSemEventMultiSignal(RTSEMEVENTMULTI hEventMultiSem) +{ + /* + * Validate input. + */ + PRTSEMEVENTMULTIINTERNAL pThis = (PRTSEMEVENTMULTIINTERNAL)hEventMultiSem; + if (!pThis) + return VERR_INVALID_PARAMETER; + AssertPtrReturn(pThis, VERR_INVALID_PARAMETER); + AssertMsgReturn(pThis->u32Magic == RTSEMEVENTMULTI_MAGIC, ("%p u32Magic=%RX32\n", pThis, pThis->u32Magic), VERR_INVALID_PARAMETER); + rtR0SemEventMultiNtRetain(pThis); + +#if defined(RTSEMEVENT_STRICT) && defined(IN_RING3) + if (pThis->fEverHadSignallers) + { + int rc9 = RTLockValidatorRecSharedCheckSignaller(&pThis->Signallers, NIL_RTTHREAD); + if (RT_FAILURE(rc9)) + return rc9; + } +#endif + + /* + * Signal the event object. + */ +#ifdef IN_RING0 + KeSetEvent(&pThis->Event, 1, FALSE); +#else + NTSTATUS rcNt = NtSetEvent(pThis->hEvent, NULL); +#endif + + rtR0SemEventMultiNtRelease(pThis); +#ifdef IN_RING3 + AssertMsgReturn(NT_SUCCESS(rcNt), ("Signaling hEventMultiSem %p failed: %#x\n", pThis, rcNt), RTErrConvertFromNtStatus(rcNt)); +#endif + return VINF_SUCCESS; +} + + +RTDECL(int) RTSemEventMultiReset(RTSEMEVENTMULTI hEventMultiSem) +{ + /* + * Validate input. + */ + PRTSEMEVENTMULTIINTERNAL pThis = (PRTSEMEVENTMULTIINTERNAL)hEventMultiSem; + if (!pThis) + return VERR_INVALID_PARAMETER; + AssertPtrReturn(pThis, VERR_INVALID_PARAMETER); + AssertMsgReturn(pThis->u32Magic == RTSEMEVENTMULTI_MAGIC, ("%p u32Magic=%RX32\n", pThis, pThis->u32Magic), VERR_INVALID_PARAMETER); + rtR0SemEventMultiNtRetain(pThis); + + /* + * Reset the event object. + */ +#ifdef IN_RING0 + KeResetEvent(&pThis->Event); +#else + NTSTATUS rcNt = NtResetEvent(pThis->hEvent, NULL); +#endif + + rtR0SemEventMultiNtRelease(pThis); +#ifdef IN_RING3 + AssertMsgReturn(NT_SUCCESS(rcNt), ("Resetting hEventMultiSem %p failed: %#x\n", pThis, rcNt), RTErrConvertFromNtStatus(rcNt)); +#endif + return VINF_SUCCESS; +} + + +/** + * Worker for RTSemEventMultiWaitEx and RTSemEventMultiWaitExDebug. + * + * @returns VBox status code. + * @param pThis The event semaphore. + * @param fFlags See RTSemEventMultiWaitEx. + * @param uTimeout See RTSemEventMultiWaitEx. + * @param pSrcPos The source code position of the wait. + */ +DECLINLINE(int) rtR0SemEventMultiNtWait(PRTSEMEVENTMULTIINTERNAL pThis, uint32_t fFlags, uint64_t uTimeout, + PCRTLOCKVALSRCPOS pSrcPos) +{ + /* + * Validate input. + */ + if (!pThis) + return VERR_INVALID_PARAMETER; + AssertPtrReturn(pThis, VERR_INVALID_PARAMETER); + AssertMsgReturn(pThis->u32Magic == RTSEMEVENTMULTI_MAGIC, ("%p u32Magic=%RX32\n", pThis, pThis->u32Magic), VERR_INVALID_PARAMETER); + AssertReturn(RTSEMWAIT_FLAGS_ARE_VALID(fFlags), VERR_INVALID_PARAMETER); + RT_NOREF1(pSrcPos); + + rtR0SemEventMultiNtRetain(pThis); + + /* + * Lock validation needs to be done only when not polling. + */ +#if defined(RTSEMEVENT_STRICT) && defined(IN_RING3) + RTTHREAD const hThreadSelf = RTThreadSelfAutoAdopt(); + if ( pThis->fEverHadSignallers + && ( uTimeout != 0 + || (fFlags & (RTSEMWAIT_FLAGS_INDEFINITE | RTSEMWAIT_FLAGS_ABSOLUTE))) ) + { + int rc9 = RTLockValidatorRecSharedCheckBlocking(&pThis->Signallers, hThreadSelf, NULL /*pSrcPos*/, false, + fFlags & RTSEMWAIT_FLAGS_INDEFINITE + ? RT_INDEFINITE_WAIT : RT_MS_30SEC /*whatever*/, + RTTHREADSTATE_EVENT_MULTI, true); + if (RT_FAILURE(rc9)) + return rc9; + } +#elif defined(IN_RING3) + RTTHREAD const hThreadSelf = RTThreadSelf(); +#endif + + /* + * Convert the timeout to a relative one because KeWaitForSingleObject + * takes system time instead of interrupt time as input for absolute + * timeout specifications. So, we're best of by giving it relative time. + * + * Lazy bird converts uTimeout to relative nanoseconds and then to Nt time. + */ +#ifdef IN_RING3 + uint64_t nsStartNow = 0; +#endif + if (!(fFlags & RTSEMWAIT_FLAGS_INDEFINITE)) + { + if (fFlags & RTSEMWAIT_FLAGS_MILLISECS) + uTimeout = uTimeout < UINT64_MAX / RT_NS_1MS + ? uTimeout * RT_NS_1MS + : UINT64_MAX; + if (uTimeout == UINT64_MAX) + fFlags |= RTSEMWAIT_FLAGS_INDEFINITE; + else + { +#ifdef IN_RING3 + if (fFlags & (RTSEMWAIT_FLAGS_RESUME | RTSEMWAIT_FLAGS_ABSOLUTE)) + nsStartNow = RTTimeSystemNanoTS(); +#endif + if (fFlags & RTSEMWAIT_FLAGS_ABSOLUTE) + { +#ifdef IN_RING0 + uint64_t const nsStartNow = RTTimeSystemNanoTS(); +#endif + uTimeout = nsStartNow < uTimeout + ? uTimeout - nsStartNow + : 0; + } + } + } + + /* + * Wait for it. + * We're assuming interruptible waits should happen at UserMode level. + */ + int rc; +#ifdef IN_RING3 + for (;;) +#endif + { +#ifdef IN_RING0 + BOOLEAN fInterruptible = !!(fFlags & RTSEMWAIT_FLAGS_INTERRUPTIBLE); + KPROCESSOR_MODE WaitMode = fInterruptible ? UserMode : KernelMode; +#endif + NTSTATUS rcNt; +#ifdef IN_RING3 + RTThreadBlocking(hThreadSelf, RTTHREADSTATE_EVENT_MULTI, true); +#endif + if (fFlags & RTSEMWAIT_FLAGS_INDEFINITE) +#ifdef IN_RING0 + rcNt = KeWaitForSingleObject(&pThis->Event, Executive, WaitMode, fInterruptible, NULL); +#else + rcNt = NtWaitForSingleObject(pThis->hEvent, TRUE /*Alertable*/, NULL); +#endif + else + { + LARGE_INTEGER Timeout; + Timeout.QuadPart = -(int64_t)(uTimeout / 100); +#ifdef IN_RING0 + rcNt = KeWaitForSingleObject(&pThis->Event, Executive, WaitMode, fInterruptible, &Timeout); +#else + rcNt = NtWaitForSingleObject(pThis->hEvent, TRUE /*Alertable*/, &Timeout); +#endif + } +#ifdef IN_RING3 + RTThreadUnblocked(hThreadSelf, RTTHREADSTATE_EVENT_MULTI); +#endif + if (pThis->u32Magic == RTSEMEVENTMULTI_MAGIC) + { + switch (rcNt) + { + case STATUS_SUCCESS: + rc = VINF_SUCCESS; + break; + + case STATUS_TIMEOUT: + Assert(!(fFlags & RTSEMWAIT_FLAGS_INDEFINITE)); + rc = VERR_TIMEOUT; + break; + + case STATUS_USER_APC: + case STATUS_ALERTED: + rc = VERR_INTERRUPTED; +#ifdef IN_RING3 + /* Loop if when automatically resuming on interruption, adjusting the timeout. */ + if (fFlags & RTSEMWAIT_FLAGS_RESUME) + { + if (!(fFlags & RTSEMWAIT_FLAGS_INDEFINITE) && uTimeout > 0) + { + uint64_t const nsNewNow = RTTimeSystemNanoTS(); + uint64_t const cNsElapsed = nsNewNow - nsStartNow; + if (cNsElapsed < uTimeout) + uTimeout -= cNsElapsed; + else + uTimeout = 0; + nsStartNow = nsNewNow; + } + continue; + } +#endif + break; + +#ifdef IN_RING3 + case STATUS_ABANDONED_WAIT_0: + rc = VERR_SEM_OWNER_DIED; + break; +#endif + default: + AssertMsgFailed(("pThis->u32Magic=%RX32 pThis=%p: wait returned %x!\n", pThis->u32Magic, pThis, rcNt)); + rc = VERR_INTERNAL_ERROR_4; + break; + } + } + else + rc = VERR_SEM_DESTROYED; +#ifdef IN_RING3 + break; +#endif + } + + rtR0SemEventMultiNtRelease(pThis); + return rc; +} + + +RTDECL(int) RTSemEventMultiWaitEx(RTSEMEVENTMULTI hEventMultiSem, uint32_t fFlags, uint64_t uTimeout) +{ +#ifndef RTSEMEVENT_STRICT + return rtR0SemEventMultiNtWait(hEventMultiSem, fFlags, uTimeout, NULL); +#else + RTLOCKVALSRCPOS SrcPos = RTLOCKVALSRCPOS_INIT_NORMAL_API(); + return rtR0SemEventMultiNtWait(hEventMultiSem, fFlags, uTimeout, &SrcPos); +#endif +} + + +RTDECL(int) RTSemEventMultiWaitExDebug(RTSEMEVENTMULTI hEventMultiSem, uint32_t fFlags, uint64_t uTimeout, + RTHCUINTPTR uId, RT_SRC_POS_DECL) +{ + RTLOCKVALSRCPOS SrcPos = RTLOCKVALSRCPOS_INIT_DEBUG_API(); + return rtR0SemEventMultiNtWait(hEventMultiSem, fFlags, uTimeout, &SrcPos); +} + + +#ifdef IN_RING0 +RTR0DECL(bool) RTSemEventMultiIsSignalSafe(void) +{ + return KeGetCurrentIrql() <= DISPATCH_LEVEL; +} +#endif + +#ifdef IN_RING3 + +RTDECL(void) RTSemEventMultiSetSignaller(RTSEMEVENTMULTI hEventMultiSem, RTTHREAD hThread) +{ +# ifdef RTSEMEVENT_STRICT + struct RTSEMEVENTMULTIINTERNAL *pThis = hEventMultiSem; + AssertPtrReturnVoid(pThis); + AssertReturnVoid(pThis->u32Magic == RTSEMEVENTMULTI_MAGIC); + + ASMAtomicWriteBool(&pThis->fEverHadSignallers, true); + RTLockValidatorRecSharedResetOwner(&pThis->Signallers, hThread, NULL); +# else + RT_NOREF_PV(hEventMultiSem); RT_NOREF_PV(hThread); +# endif +} + + +RTDECL(void) RTSemEventMultiAddSignaller(RTSEMEVENTMULTI hEventMultiSem, RTTHREAD hThread) +{ +# ifdef RTSEMEVENT_STRICT + struct RTSEMEVENTMULTIINTERNAL *pThis = hEventMultiSem; + AssertPtrReturnVoid(pThis); + AssertReturnVoid(pThis->u32Magic == RTSEMEVENTMULTI_MAGIC); + + ASMAtomicWriteBool(&pThis->fEverHadSignallers, true); + RTLockValidatorRecSharedAddOwner(&pThis->Signallers, hThread, NULL); +# else + RT_NOREF_PV(hEventMultiSem); RT_NOREF_PV(hThread); +# endif +} + + +RTDECL(void) RTSemEventMultiRemoveSignaller(RTSEMEVENTMULTI hEventMultiSem, RTTHREAD hThread) +{ +# ifdef RTSEMEVENT_STRICT + struct RTSEMEVENTMULTIINTERNAL *pThis = hEventMultiSem; + AssertPtrReturnVoid(pThis); + AssertReturnVoid(pThis->u32Magic == RTSEMEVENTMULTI_MAGIC); + + RTLockValidatorRecSharedRemoveOwner(&pThis->Signallers, hThread); +# else + RT_NOREF_PV(hEventMultiSem); RT_NOREF_PV(hThread); +# endif +} + +#endif /* IN_RING3 */ -- cgit v1.2.3