rom/exec/releasesemaphore.c

   1 /*
   2     Copyright © 1995-2013, The AROS Development Team. All rights reserved.
   3     $Id$
   4
   5     Desc: Release a semaphore.
   6     Lang: english
   7 */
   8
   9 #include <exec/semaphores.h>
  10 #include <proto/exec.h>
  11
  12 #include "exec_intern.h"
  13 #include "exec_util.h"
  14 #include "semaphores.h"
  15
  16 #define CHECK_TASK      0 /* it seems to be legal to call ObtainSemaphore in one task and ReleaseSemaphore in another */
  17
  18 /*****************************************************************************/
  19 #undef  Exec
  20 #ifdef UseExecstubs
  21 #    define Exec _Exec
  22 #endif
  23
  24 /*  NAME  */
  25         #include <proto/exec.h>
  26
  27         AROS_LH1(void, ReleaseSemaphore,
  28
  29 /*  SYNOPSIS  */
  30         AROS_LHA(struct SignalSemaphore *, sigSem, A0),
  31
  32 /*  LOCATION  */
  33         struct ExecBase *, SysBase, 95, Exec)
  34
  35 /*  FUNCTION
  36         Releases a lock on a semaphore obtained with either ObtainSemaphore(),
  37         ObtainSemaphoreShared(), AttemptSemaphore or AttemptSemaphoreShared().
  38         Each call to one of those functions must be accompanied by one call
  39         to ReleaseSemaphore().
  40
  41     INPUTS
  42         sigSem - pointer to semaphore structure
  43
  44     RESULT
  45
  46     NOTES
  47         This function preserves all registers.
  48
  49     EXAMPLE
  50
  51     BUGS
  52
  53     SEE ALSO
  54
  55     INTERNALS
  56
  57 *****************************************************************************/
  58 {
  59 #undef Exec
  60
  61     AROS_LIBFUNC_INIT
  62
  63     struct TraceLocation tp = CURRENT_LOCATION("ReleaseSemaphore");
  64     struct Task *me = FindTask(NULL);
  65
  66     /* We can be called from within exec's pre-init code. It's okay. */
  67     if (!me)
  68         return;
  69
  70     if (me->tc_State == TS_REMOVED)
  71         return;
  72
  73     if (!CheckSemaphore(sigSem, &tp, SysBase))
  74         return;
  75
  76     /* Protect the semaphore structure from multiple access. */
  77     Forbid();
  78
  79     /* Release one on the nest count */
  80     sigSem->ss_NestCount--;
  81     sigSem->ss_QueueCount--;
  82
  83     if(sigSem->ss_NestCount == 0)
  84     {
  85         /*
  86             There are two cases here. Either we are a shared
  87             semaphore, or not. If we are not, make sure that the
  88             correct Task is calling ReleaseSemaphore()
  89         */
  90
  91 #if CHECK_TASK
  92         if (sigSem->ss_Owner != NULL && sigSem->ss_Owner != me)
  93         {
  94             /*
  95                 If it is not, there is a chance that the semaphore
  96                 is corrupt. It will be afterwards anyway :-)
  97             */
  98             Alert( AN_SemCorrupt );
  99         }
 100 #endif
 101
 102         /*
 103             Do not try and wake anything unless there are a number
 104             of tasks waiting. We do both the tests, this is another
 105             opportunity to throw an alert if there is an error.
 106         */
 107         if(
 108             sigSem->ss_QueueCount >= 0
 109          && sigSem->ss_WaitQueue.mlh_Head->mln_Succ != NULL
 110         )
 111         {
 112             struct SemaphoreRequest *sr, *srn;
 113
 114             /*
 115                 Look at the first node, but only to see whether it
 116                 is shared or not.
 117             */
 118             sr = (struct SemaphoreRequest *)sigSem->ss_WaitQueue.mlh_Head;
 119
 120             /*
 121                 A node is shared if the ln_Name/sr_Waiter field is
 122                 odd (ie it has bit 1 set).
 123
 124                 If the sr_Waiter field is != NULL, then this is a
 125                 task waiting, otherwise it is a message.
 126             */
 127             if( ((IPTR)sr->sr_Waiter & SM_SHARED) == SM_SHARED )
 128             {
 129                 /* This is a shared lock, so ss_Owner == NULL */
 130                 sigSem->ss_Owner = NULL;
 131
 132                 /* Go through all the nodes to find the shared ones */
 133                 ForeachNodeSafe( &sigSem->ss_WaitQueue, sr, srn)
 134                 {
 135                     srn = (struct SemaphoreRequest *)sr->sr_Link.mln_Succ;
 136
 137                     if( ((IPTR)sr->sr_Waiter & SM_SHARED) == SM_SHARED )
 138                     {
 139                         Remove((struct Node *)sr);
 140
 141                         /* Clear the bit, and update the owner count */
 142                         sr->sr_Waiter = (APTR)((IPTR)sr->sr_Waiter & ~1);
 143                         sigSem->ss_NestCount++;
 144
 145                         if(sr->sr_Waiter != NULL)
 146                         {
 147                             /* This is a task, signal it */
 148                             Signal(sr->sr_Waiter, SIGF_SINGLE);
 149                         }
 150                         else
 151                         {
 152                             /* This is a message, send it back to its owner */
 153                             ((struct SemaphoreMessage *)sr)->ssm_Semaphore = sigSem;
 154                             ReplyMsg((struct Message *)sr);
 155                         }
 156                     }
 157                 }
 158             }
 159
 160             /*  This is an exclusive lock - awaken first node */
 161             else
 162             {
 163                 /* Save typing */
 164                 struct SemaphoreMessage *sm = (struct SemaphoreMessage *)sr;
 165
 166                 /* Only awaken the first of the nodes */
 167                 Remove((struct Node *)sr);
 168                 sigSem->ss_NestCount++;
 169
 170                 if(sr->sr_Waiter != NULL)
 171                 {
 172                     sigSem->ss_Owner = sr->sr_Waiter;
 173                     Signal(sr->sr_Waiter, SIGF_SINGLE);
 174                 }
 175                 else
 176                 {
 177                     sigSem->ss_Owner = (struct Task *)sm->ssm_Semaphore;
 178                     sm->ssm_Semaphore = sigSem;
 179                     ReplyMsg((struct Message *)sr);
 180                 }
 181             }
 182         } /* there are waiters */
 183
 184         /*  Otherwise, there are not tasks waiting. */
 185         else
 186         {
 187             sigSem->ss_Owner = NULL;
 188             sigSem->ss_QueueCount = -1;
 189
 190             D(bug("ReleaseSemaphore(): No tasks - ss_NestCount == %ld\n",
 191                 sigSem->ss_NestCount));
 192         }
 193     }
 194     else if(sigSem->ss_NestCount < 0)
 195     {
 196         /*
 197             This can't happen. It means that somebody has released
 198             more times than they have obtained.
 199         */
 200         Alert( AN_SemCorrupt );
 201     }
 202
 203     /* All done. */
 204     Permit();
 205
 206     AROS_LIBFUNC_EXIT
 207 } /* ReleaseSemaphore */