rom/exec/semaphores.c

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