ubuntu/vbox/r0drv/linux/semeventmulti-r0drv-linux.c

   1 /* $Id: semeventmulti-r0drv-linux.c $ */
   2 /** @file
   3  * IPRT - Multiple Release Event Semaphores, Ring-0 Driver, Linux.
   4  */
   5
   6 /*
   7  * Copyright (C) 2006-2016 Oracle Corporation
   8  *
   9  * This file is part of VirtualBox Open Source Edition (OSE), as
  10  * available from http://www.virtualbox.org. This file is free software;
  11  * you can redistribute it and/or modify it under the terms of the GNU
  12  * General Public License (GPL) as published by the Free Software
  13  * Foundation, in version 2 as it comes in the "COPYING" file of the
  14  * VirtualBox OSE distribution. VirtualBox OSE is distributed in the
  15  * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
  16  *
  17  * The contents of this file may alternatively be used under the terms
  18  * of the Common Development and Distribution License Version 1.0
  19  * (CDDL) only, as it comes in the "COPYING.CDDL" file of the
  20  * VirtualBox OSE distribution, in which case the provisions of the
  21  * CDDL are applicable instead of those of the GPL.
  22  *
  23  * You may elect to license modified versions of this file under the
  24  * terms and conditions of either the GPL or the CDDL or both.
  25  */
  26
  27
  28 /*********************************************************************************************************************************
  29 *   Header Files                                                                                                                 *
  30 *********************************************************************************************************************************/
  31 #define RTSEMEVENTMULTI_WITHOUT_REMAPPING
  32 #include "the-linux-kernel.h"
  33 #include "internal/iprt.h"
  34 #include <iprt/semaphore.h>
  35
  36 #include <iprt/assert.h>
  37 #include <iprt/asm.h>
  38 #include <iprt/err.h>
  39 #include <iprt/mem.h>
  40 #include <iprt/lockvalidator.h>
  41
  42 #include "waitqueue-r0drv-linux.h"
  43 #include "internal/magics.h"
  44
  45
  46 /*********************************************************************************************************************************
  47 *   Defined Constants And Macros                                                                                                 *
  48 *********************************************************************************************************************************/
  49 /** @name fStateAndGen values
  50  * @{ */
  51 /** The state bit number. */
  52 #define RTSEMEVENTMULTILNX_STATE_BIT        0
  53 /** The state mask. */
  54 #define RTSEMEVENTMULTILNX_STATE_MASK       RT_BIT_32(RTSEMEVENTMULTILNX_STATE_BIT)
  55 /** The generation mask. */
  56 #define RTSEMEVENTMULTILNX_GEN_MASK         ~RTSEMEVENTMULTILNX_STATE_MASK
  57 /** The generation shift. */
  58 #define RTSEMEVENTMULTILNX_GEN_SHIFT        1
  59 /** The initial variable value. */
  60 #define RTSEMEVENTMULTILNX_STATE_GEN_INIT   UINT32_C(0xfffffffc)
  61 /** @}  */
  62
  63
  64 /*********************************************************************************************************************************
  65 *   Structures and Typedefs                                                                                                      *
  66 *********************************************************************************************************************************/
  67 /**
  68  * Linux event semaphore.
  69  */
  70 typedef struct RTSEMEVENTMULTIINTERNAL
  71 {
  72     /** Magic value (RTSEMEVENTMULTI_MAGIC). */
  73     uint32_t volatile   u32Magic;
  74     /** The object state bit and generation counter.
  75      * The generation counter is incremented every time the object is
  76      * signalled. */
  77     uint32_t volatile   fStateAndGen;
  78     /** Reference counter. */
  79     uint32_t volatile   cRefs;
  80     /** The wait queue. */
  81     wait_queue_head_t   Head;
  82 } RTSEMEVENTMULTIINTERNAL, *PRTSEMEVENTMULTIINTERNAL;
  83
  84
  85
  86
  87
  88 RTDECL(int)  RTSemEventMultiCreate(PRTSEMEVENTMULTI phEventMultiSem)
  89 {
  90     return RTSemEventMultiCreateEx(phEventMultiSem, 0 /*fFlags*/, NIL_RTLOCKVALCLASS, NULL);
  91 }
  92
  93
  94 RTDECL(int)  RTSemEventMultiCreateEx(PRTSEMEVENTMULTI phEventMultiSem, uint32_t fFlags, RTLOCKVALCLASS hClass,
  95                                      const char *pszNameFmt, ...)
  96 {
  97     PRTSEMEVENTMULTIINTERNAL pThis;
  98     IPRT_LINUX_SAVE_EFL_AC();
  99     RT_NOREF_PV(hClass); RT_NOREF_PV(pszNameFmt);
 100
 101     AssertReturn(!(fFlags & ~RTSEMEVENTMULTI_FLAGS_NO_LOCK_VAL), VERR_INVALID_PARAMETER);
 102     pThis = (PRTSEMEVENTMULTIINTERNAL)RTMemAlloc(sizeof(*pThis));
 103     if (pThis)
 104     {
 105         pThis->u32Magic     = RTSEMEVENTMULTI_MAGIC;
 106         pThis->fStateAndGen = RTSEMEVENTMULTILNX_STATE_GEN_INIT;
 107         pThis->cRefs        = 1;
 108         init_waitqueue_head(&pThis->Head);
 109
 110         *phEventMultiSem = pThis;
 111         IPRT_LINUX_RESTORE_EFL_AC();
 112         return VINF_SUCCESS;
 113     }
 114     IPRT_LINUX_RESTORE_EFL_AC();
 115     return VERR_NO_MEMORY;
 116 }
 117 RT_EXPORT_SYMBOL(RTSemEventMultiCreate);
 118
 119
 120 /**
 121  * Retain a reference to the semaphore.
 122  *
 123  * @param   pThis       The semaphore.
 124  */
 125 DECLINLINE(void) rtR0SemEventMultiLnxRetain(PRTSEMEVENTMULTIINTERNAL pThis)
 126 {
 127     uint32_t cRefs = ASMAtomicIncU32(&pThis->cRefs);
 128     NOREF(cRefs);
 129     Assert(cRefs && cRefs < 100000);
 130 }
 131
 132
 133 /**
 134  * Release a reference, destroy the thing if necessary.
 135  *
 136  * @param   pThis       The semaphore.
 137  */
 138 DECLINLINE(void) rtR0SemEventMultiLnxRelease(PRTSEMEVENTMULTIINTERNAL pThis)
 139 {
 140     if (RT_UNLIKELY(ASMAtomicDecU32(&pThis->cRefs) == 0))
 141     {
 142         Assert(pThis->u32Magic != RTSEMEVENTMULTI_MAGIC);
 143         RTMemFree(pThis);
 144     }
 145 }
 146
 147
 148 RTDECL(int) RTSemEventMultiDestroy(RTSEMEVENTMULTI hEventMultiSem)
 149 {
 150     IPRT_LINUX_SAVE_EFL_AC();
 151
 152     /*
 153      * Validate input.
 154      */
 155     PRTSEMEVENTMULTIINTERNAL pThis = (PRTSEMEVENTMULTIINTERNAL)hEventMultiSem;
 156     if (pThis == NIL_RTSEMEVENTMULTI)
 157         return VINF_SUCCESS;
 158     AssertPtrReturn(pThis, VERR_INVALID_PARAMETER);
 159     AssertMsgReturn(pThis->u32Magic == RTSEMEVENTMULTI_MAGIC, ("%p u32Magic=%RX32\n", pThis, pThis->u32Magic), VERR_INVALID_PARAMETER);
 160     Assert(pThis->cRefs > 0);
 161
 162     /*
 163      * Invalidate it and signal the object just in case.
 164      */
 165     ASMAtomicWriteU32(&pThis->u32Magic, ~RTSEMEVENTMULTI_MAGIC);
 166     ASMAtomicAndU32(&pThis->fStateAndGen, RTSEMEVENTMULTILNX_GEN_MASK);
 167     Assert(!waitqueue_active(&pThis->Head));
 168     wake_up_all(&pThis->Head);
 169     rtR0SemEventMultiLnxRelease(pThis);
 170
 171     IPRT_LINUX_RESTORE_EFL_AC();
 172     return VINF_SUCCESS;
 173 }
 174 RT_EXPORT_SYMBOL(RTSemEventMultiDestroy);
 175
 176
 177 RTDECL(int) RTSemEventMultiSignal(RTSEMEVENTMULTI hEventMultiSem)
 178 {
 179     IPRT_LINUX_SAVE_EFL_AC();
 180     uint32_t fNew;
 181     uint32_t fOld;
 182
 183     /*
 184      * Validate input.
 185      */
 186     PRTSEMEVENTMULTIINTERNAL pThis = (PRTSEMEVENTMULTIINTERNAL)hEventMultiSem;
 187     if (!pThis)
 188         return VERR_INVALID_PARAMETER;
 189     AssertPtrReturn(pThis, VERR_INVALID_PARAMETER);
 190     AssertMsgReturn(pThis->u32Magic == RTSEMEVENTMULTI_MAGIC, ("%p u32Magic=%RX32\n", pThis, pThis->u32Magic), VERR_INVALID_PARAMETER);
 191     rtR0SemEventMultiLnxRetain(pThis);
 192
 193     /*
 194      * Signal the event object.  The cause of the paranoia here is racing to try
 195      * deal with racing RTSemEventMultiSignal calls (should probably be
 196      * forbidden, but it's relatively easy to handle).
 197      */
 198     do
 199     {
 200         fNew = fOld = ASMAtomicUoReadU32(&pThis->fStateAndGen);
 201         fNew += 1 << RTSEMEVENTMULTILNX_GEN_SHIFT;
 202         fNew |= RTSEMEVENTMULTILNX_STATE_MASK;
 203     }
 204     while (!ASMAtomicCmpXchgU32(&pThis->fStateAndGen, fNew, fOld));
 205
 206     wake_up_all(&pThis->Head);
 207
 208     rtR0SemEventMultiLnxRelease(pThis);
 209     IPRT_LINUX_RESTORE_EFL_AC();
 210     return VINF_SUCCESS;
 211 }
 212 RT_EXPORT_SYMBOL(RTSemEventMultiSignal);
 213
 214
 215 RTDECL(int) RTSemEventMultiReset(RTSEMEVENTMULTI hEventMultiSem)
 216 {
 217     /*
 218      * Validate input.
 219      */
 220     PRTSEMEVENTMULTIINTERNAL pThis = (PRTSEMEVENTMULTIINTERNAL)hEventMultiSem;
 221     if (!pThis)
 222         return VERR_INVALID_PARAMETER;
 223     AssertPtrReturn(pThis, VERR_INVALID_PARAMETER);
 224     AssertMsgReturn(pThis->u32Magic == RTSEMEVENTMULTI_MAGIC, ("%p u32Magic=%RX32\n", pThis, pThis->u32Magic), VERR_INVALID_PARAMETER);
 225     rtR0SemEventMultiLnxRetain(pThis);
 226
 227     /*
 228      * Reset it.
 229      */
 230     ASMAtomicAndU32(&pThis->fStateAndGen, ~RTSEMEVENTMULTILNX_STATE_MASK);
 231
 232     rtR0SemEventMultiLnxRelease(pThis);
 233     return VINF_SUCCESS;
 234 }
 235 RT_EXPORT_SYMBOL(RTSemEventMultiReset);
 236
 237
 238 /**
 239  * Worker for RTSemEventMultiWaitEx and RTSemEventMultiWaitExDebug.
 240  *
 241  * @returns VBox status code.
 242  * @param   pThis           The event semaphore.
 243  * @param   fFlags          See RTSemEventMultiWaitEx.
 244  * @param   uTimeout        See RTSemEventMultiWaitEx.
 245  * @param   pSrcPos         The source code position of the wait.
 246  */
 247 static int rtR0SemEventMultiLnxWait(PRTSEMEVENTMULTIINTERNAL pThis, uint32_t fFlags, uint64_t uTimeout,
 248                                     PCRTLOCKVALSRCPOS pSrcPos)
 249 {
 250     uint32_t    fOrgStateAndGen;
 251     int         rc;
 252     RT_NOREF_PV(pSrcPos);
 253
 254     /*
 255      * Validate the input.
 256      */
 257     AssertPtrReturn(pThis, VERR_INVALID_PARAMETER);
 258     AssertMsgReturn(pThis->u32Magic == RTSEMEVENTMULTI_MAGIC, ("%p u32Magic=%RX32\n", pThis, pThis->u32Magic), VERR_INVALID_PARAMETER);
 259     AssertReturn(RTSEMWAIT_FLAGS_ARE_VALID(fFlags), VERR_INVALID_PARAMETER);
 260     rtR0SemEventMultiLnxRetain(pThis);
 261
 262     /*
 263      * Is the event already signalled or do we have to wait?
 264      */
 265     fOrgStateAndGen = ASMAtomicUoReadU32(&pThis->fStateAndGen);
 266     if (fOrgStateAndGen & RTSEMEVENTMULTILNX_STATE_MASK)
 267         rc = VINF_SUCCESS;
 268     else
 269     {
 270         /*
 271          * We have to wait.
 272          */
 273         RTR0SEMLNXWAIT Wait;
 274         IPRT_LINUX_SAVE_EFL_AC();
 275         rc = rtR0SemLnxWaitInit(&Wait, fFlags, uTimeout, &pThis->Head);
 276         if (RT_SUCCESS(rc))
 277         {
 278             IPRT_DEBUG_SEMS_STATE(pThis, 'E');
 279             for (;;)
 280             {
 281                 /* The destruction test. */
 282                 if (RT_UNLIKELY(pThis->u32Magic != RTSEMEVENTMULTI_MAGIC))
 283                     rc = VERR_SEM_DESTROYED;
 284                 else
 285                 {
 286                     rtR0SemLnxWaitPrepare(&Wait);
 287
 288                     /* Check the exit conditions. */
 289                     if (RT_UNLIKELY(pThis->u32Magic != RTSEMEVENTMULTI_MAGIC))
 290                         rc = VERR_SEM_DESTROYED;
 291                     else if (ASMAtomicUoReadU32(&pThis->fStateAndGen) != fOrgStateAndGen)
 292                         rc = VINF_SUCCESS;
 293                     else if (rtR0SemLnxWaitHasTimedOut(&Wait))
 294                         rc = VERR_TIMEOUT;
 295                     else if (rtR0SemLnxWaitWasInterrupted(&Wait))
 296                         rc = VERR_INTERRUPTED;
 297                     else
 298                     {
 299                         /* Do the wait and then recheck the conditions. */
 300                         rtR0SemLnxWaitDoIt(&Wait);
 301                         continue;
 302                     }
 303                 }
 304                 break;
 305             }
 306
 307             rtR0SemLnxWaitDelete(&Wait);
 308             IPRT_DEBUG_SEMS_STATE_RC(pThis, 'E', rc);
 309         }
 310         IPRT_LINUX_RESTORE_EFL_AC();
 311     }
 312
 313     rtR0SemEventMultiLnxRelease(pThis);
 314     return rc;
 315 }
 316
 317
 318 RTDECL(int)  RTSemEventMultiWaitEx(RTSEMEVENTMULTI hEventMultiSem, uint32_t fFlags, uint64_t uTimeout)
 319 {
 320 #ifndef RTSEMEVENT_STRICT
 321     return rtR0SemEventMultiLnxWait(hEventMultiSem, fFlags, uTimeout, NULL);
 322 #else
 323     RTLOCKVALSRCPOS SrcPos = RTLOCKVALSRCPOS_INIT_NORMAL_API();
 324     return rtR0SemEventMultiLnxWait(hEventMultiSem, fFlags, uTimeout, &SrcPos);
 325 #endif
 326 }
 327 RT_EXPORT_SYMBOL(RTSemEventMultiWaitEx);
 328
 329
 330 RTDECL(int)  RTSemEventMultiWaitExDebug(RTSEMEVENTMULTI hEventMultiSem, uint32_t fFlags, uint64_t uTimeout,
 331                                         RTHCUINTPTR uId, RT_SRC_POS_DECL)
 332 {
 333     RTLOCKVALSRCPOS SrcPos = RTLOCKVALSRCPOS_INIT_DEBUG_API();
 334     return rtR0SemEventMultiLnxWait(hEventMultiSem, fFlags, uTimeout, &SrcPos);
 335 }
 336 RT_EXPORT_SYMBOL(RTSemEventMultiWaitExDebug);
 337
 338
 339 RTDECL(uint32_t) RTSemEventMultiGetResolution(void)
 340 {
 341     return rtR0SemLnxWaitGetResolution();
 342 }
 343 RT_EXPORT_SYMBOL(RTSemEventMultiGetResolution);
 344