rom/exec/semaphores.c

   1 /*
   2     Copyright © 1995-2012, The AROS Development Team. All rights reserved.
   3     $Id$
   4
   5     Desc: Semaphore internal handling
   6     Lang: english
   7 */
   8
   9 #include <aros/atomic.h>
  10 #include <aros/debug.h>
  11 #include <proto/exec.h>
  12 #include <proto/kernel.h>
  13
  14 #include "exec_util.h"
  15 #include "semaphores.h"
  16
  17 BOOL CheckSemaphore(struct SignalSemaphore *sigSem, struct TraceLocation *caller, struct ExecBase *SysBase)
  18 {
  19     /* TODO: Introduce AlertContext for this */
  20
  21     if (KernelBase && KrnIsSuper())
  22     {
  23         /* FindTask() is called only here, for speedup */
  24         struct Task *me = FindTask(NULL);
  25
  26         kprintf("%s called in supervisor mode!!!\n"
  27                 "sem = 0x%p task = 0x%p (%s)\n\n", caller->function, sigSem, me, me->tc_Node.ln_Name);
  28         Exec_ExtAlert(ACPU_PrivErr & ~AT_DeadEnd, __builtin_return_address(0), CALLER_FRAME, 0, NULL, SysBase);
  29
  30         return FALSE;
  31     }
  32
  33     if ((sigSem->ss_Link.ln_Type != NT_SIGNALSEM) || (sigSem->ss_WaitQueue.mlh_Tail != NULL))
  34     {
  35         struct Task *me = FindTask(NULL);
  36
  37         kprintf("%s called on a not initialized semaphore!!!\n"
  38                 "sem = 0x%p task = 0x%p (%s)\n\n", caller->function, sigSem, me, me->tc_Node.ln_Name);
  39         Exec_ExtAlert(AN_SemCorrupt, __builtin_return_address(0), CALLER_FRAME, 0, NULL, SysBase);
  40
  41         return FALSE;
  42     }
  43
  44     return TRUE;
  45 }
  46
  47 void InternalObtainSemaphore(struct SignalSemaphore *sigSem, struct Task *owner, struct TraceLocation *caller, struct ExecBase *SysBase)
  48 {
  49     struct Task *me = FindTask(NULL);
  50
  51     /*
  52      * If there's no ThisTask, the function is called from within memory
  53      * allocator in exec's pre-init code. We are already single-threaded,
  54      * just return. :)
  55      */
  56     if (!me)
  57         return;
  58
  59     /*
  60      * Freeing memory during RemTask(NULL). We are already single-threaded by
  61      * Forbid(), and waiting isn't possible because task context is being deallocated.
  62      */
  63     if (me->tc_State == TS_REMOVED)
  64         return;
  65
  66     if (!CheckSemaphore(sigSem, caller, SysBase))
  67         return;  /* A crude attempt to recover... */
  68
  69     /*
  70      * Arbitrate for the semaphore structure.
  71      * TODO: SMP-aware versions of this code likely need to use spinlocks here
  72      */
  73     Forbid();
  74
  75     /*
  76      * ss_QueueCount == -1 indicates that the semaphore is
  77      * free, so we increment this straight away. If it then
  78      * equals 0, then we are the first to allocate this semaphore.
  79      */
  80     sigSem->ss_QueueCount++;
  81
  82     if (sigSem->ss_QueueCount == 0)
  83     {
  84         /* We now own the semaphore. This is quick. */
  85         sigSem->ss_Owner = owner;
  86         sigSem->ss_NestCount++;
  87     }
  88     /*
  89      * The semaphore is in use.
  90      * It could be either shared (ss_Owner == NULL) or it could already be exclusively owned
  91      * by me (ss_Owner == me).
  92      * Exclusive or shared mode of this function is determined by 'owner' parameter.
  93      * Actually it's pointer to a task which is allowed to share the lock with us.
  94      * If it's equal to 'me', we are locking the semaphore in exclusive more. If it's NULL,
  95      * we are locking in shared mode. This helps to optimize code against speed, and remove
  96      * extra comparisons.
  97      */
  98     else if ((sigSem->ss_Owner == me) || (sigSem->ss_Owner == owner))
  99     {
 100         /* Yes, just increase the nesting count */
 101         sigSem->ss_NestCount++;
 102     }
 103     /* Else, some other task owns it. We have to set a waiting request here. */
 104     else
 105     {
 106         /*
 107          * We need a node to mark our semaphore request. Lets use some
 108          * stack memory.
 109          */
 110         struct SemaphoreRequest sr;
 111         sr.sr_Waiter = me;
 112
 113         if (owner == NULL)
 114             sr.sr_Waiter = (struct Task *)((IPTR)(sr.sr_Waiter) | SM_SHARED);
 115
 116         /*
 117          * Have to clear the signal to make sure that we don't
 118          * return immediately. We then add the SemReq to the
 119          * waiters list of the semaphore. We were the last to
 120          * request, so we must be the last to get the semaphore.
 121         */
 122
 123         /* This must be atomic! */
 124         AROS_ATOMIC_AND(me->tc_SigRecvd, ~SIGF_SINGLE);
 125
 126         AddTail((struct List *)&sigSem->ss_WaitQueue, (struct Node *)&sr);
 127
 128         /*
 129          * Finally, we simply wait, ReleaseSemaphore() will fill in
 130          * who owns the semaphore.
 131          */
 132         Wait(SIGF_SINGLE);
 133     }
 134
 135     /* All Done! */
 136     Permit();
 137 }
 138
 139 ULONG InternalAttemptSemaphore(struct SignalSemaphore *sigSem, struct Task *owner, struct TraceLocation *caller, struct ExecBase *SysBase)
 140 {
 141     struct Task *me = FindTask(NULL);
 142     ULONG retval = TRUE;
 143
 144     if (!CheckSemaphore(sigSem, caller, SysBase))
 145         return FALSE;  /* A crude attempt to recover... */
 146
 147     /*
 148      * Arbitrate for the semaphore structure.
 149      * TODO: SMP-aware versions of this code likely need to use spinlocks here
 150      */
 151     Forbid();
 152
 153     /* Increment the queue count */
 154     sigSem->ss_QueueCount++;
 155
 156     if (sigSem->ss_QueueCount == 0)
 157     {
 158         /* The semaphore wasn't owned. We can now own it */
 159         sigSem->ss_Owner = owner;
 160         sigSem->ss_NestCount++;
 161     }
 162     else if ((sigSem->ss_Owner == me) || (sigSem->ss_Owner == owner))
 163     {
 164         /* The semaphore was owned by me or is shared, just increase the nest count */
 165         sigSem->ss_NestCount++;
 166     }
 167     else
 168     {
 169         /* We can't get ownership, just return it. */
 170         sigSem->ss_QueueCount--;
 171         retval = FALSE;
 172     }
 173
 174     /* All done. */
 175     Permit();
 176
 177     return retval;
 178 }