rom/exec/semaphores.c

   1 /*
   2     Copyright ¿ 1995-2011, The AROS Development Team. All rights reserved.
   3     $Id: obtainsemaphore.c 43362 2011-12-30 07:45:42Z sonic $
   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 intialized 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         /*
 114          * Have to clear the signal to make sure that we don't
 115          * return immediately. We then add the SemReq to the
 116          * waiters list of the semaphore. We were the last to
 117          * request, so we must be the last to get the semaphore.
 118         */
 119
 120         /* This must be atomic! */
 121         AROS_ATOMIC_AND(me->tc_SigRecvd, ~SIGF_SINGLE);
 122
 123         AddTail((struct List *)&sigSem->ss_WaitQueue, (struct Node *)&sr);
 124
 125         /*
 126          * Finally, we simply wait, ReleaseSemaphore() will fill in
 127          * who owns the semaphore.
 128          */
 129         Wait(SIGF_SINGLE);
 130     }
 131
 132     /* All Done! */
 133     Permit();
 134 }
 135
 136 ULONG InternalAttemptSemaphore(struct SignalSemaphore *sigSem, struct Task *owner, struct TraceLocation *caller, struct ExecBase *SysBase)
 137 {
 138     struct Task *me = FindTask(NULL);
 139     ULONG retval = TRUE;
 140
 141     if (!CheckSemaphore(sigSem, caller, SysBase))
 142         return FALSE;  /* A crude attempt to recover... */
 143
 144     /*
 145      * Arbitrate for the semaphore structure.
 146      * TODO: SMP-aware versions of this code likely need to use spinlocks here
 147      */
 148     Forbid();
 149
 150     /* Increment the queue count */
 151     sigSem->ss_QueueCount++;
 152
 153     if (sigSem->ss_QueueCount == 0)
 154     {
 155         /* The semaphore wasn't owned. We can now own it */
 156         sigSem->ss_Owner = owner;
 157         sigSem->ss_NestCount++;
 158     }
 159     else if ((sigSem->ss_Owner == me) || (sigSem->ss_Owner == owner))
 160     {
 161         /* The semaphore was owned by me or is shared, just increase the nest count */
 162         sigSem->ss_NestCount++;
 163     }
 164     else
 165     {
 166         /* We can't get ownership, just return it. */
 167         sigSem->ss_QueueCount--;
 168         retval = FALSE;
 169     }
 170
 171     /* All done. */
 172     Permit();
 173
 174     return retval;
 175 }