rom/exec/releasesemaphore.c

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