compiler/pthread/pthread_cond_timedwait.c

   1 /*
   2   Copyright (C) 2014 Szilard Biro
   3
   4   This software is provided 'as-is', without any express or implied
   5   warranty.  In no event will the authors be held liable for any damages
   6   arising from the use of this software.
   7
   8   Permission is granted to anyone to use this software for any purpose,
   9   including commercial applications, and to alter it and redistribute it
  10   freely, subject to the following restrictions:
  11
  12   1. The origin of this software must not be misrepresented; you must not
  13      claim that you wrote the original software. If you use this software
  14      in a product, an acknowledgment in the product documentation would be
  15      appreciated but is not required.
  16   2. Altered source versions must be plainly marked as such, and must not be
  17      misrepresented as being the original software.
  18   3. This notice may not be removed or altered from any source distribution.
  19 */
  20
  21 #include <proto/timer.h>
  22
  23 #include "pthread_intern.h"
  24 #include "debug.h"
  25
  26 int _pthread_cond_timedwait(pthread_cond_t *cond, pthread_mutex_t *mutex, const struct timespec *abstime, BOOL relative)
  27 {
  28     CondWaiter waiter;
  29     BYTE signal;
  30     ULONG sigs = 0;
  31     ULONG timermask = 0;
  32     struct MsgPort timermp;
  33     struct timerequest timerio;
  34     struct Task *task;
  35
  36     DB2(bug("%s(%p, %p, %p)\n", __FUNCTION__, cond, mutex, abstime));
  37
  38     if (cond == NULL || mutex == NULL)
  39         return EINVAL;
  40
  41     pthread_testcancel();
  42
  43     // initialize static conditions
  44     if (SemaphoreIsInvalid(&cond->semaphore))
  45         pthread_cond_init(cond, NULL);
  46
  47     task = FindTask(NULL);
  48
  49     if (abstime)
  50     {
  51         // prepare MsgPort
  52         timermp.mp_Node.ln_Type = NT_MSGPORT;
  53         timermp.mp_Node.ln_Pri = 0;
  54         timermp.mp_Node.ln_Name = NULL;
  55         timermp.mp_Flags = PA_SIGNAL;
  56         timermp.mp_SigTask = task;
  57         signal = AllocSignal(-1);
  58         if (signal == -1)
  59         {
  60             signal = SIGB_TIMER_FALLBACK;
  61             SetSignal(SIGF_TIMER_FALLBACK, 0);
  62         }
  63         timermp.mp_SigBit = signal;
  64         NEWLIST(&timermp.mp_MsgList);
  65
  66         // prepare IORequest
  67         timerio.tr_node.io_Message.mn_Node.ln_Type = NT_MESSAGE;
  68         timerio.tr_node.io_Message.mn_Node.ln_Pri = 0;
  69         timerio.tr_node.io_Message.mn_Node.ln_Name = NULL;
  70         timerio.tr_node.io_Message.mn_ReplyPort = &timermp;
  71         timerio.tr_node.io_Message.mn_Length = sizeof(struct timerequest);
  72
  73         // open timer.device
  74         if (OpenDevice((STRPTR)TIMERNAME, UNIT_MICROHZ, &timerio.tr_node, 0) != 0)
  75         {
  76             if (timermp.mp_SigBit != SIGB_TIMER_FALLBACK)
  77                 FreeSignal(timermp.mp_SigBit);
  78
  79             return EINVAL;
  80         }
  81
  82         // prepare the device command and send it
  83         timerio.tr_node.io_Command = TR_ADDREQUEST;
  84         timerio.tr_node.io_Flags = 0;
  85         TIMESPEC_TO_TIMEVAL(&timerio.tr_time, abstime);
  86         if (!relative)
  87         {
  88             struct timeval starttime;
  89             // absolute time has to be converted to relative
  90             // GetSysTime can't be used due to the timezone offset in abstime
  91             gettimeofday(&starttime, NULL);
  92             timersub(&timerio.tr_time, &starttime, &timerio.tr_time);
  93         }
  94         timermask = 1 << timermp.mp_SigBit;
  95         sigs |= timermask;
  96         SendIO((struct IORequest *)&timerio);
  97     }
  98
  99     // prepare a waiter node
 100     waiter.task = task;
 101     signal = AllocSignal(-1);
 102     if (signal == -1)
 103     {
 104         signal = SIGB_COND_FALLBACK;
 105         SetSignal(SIGF_COND_FALLBACK, 0);
 106     }
 107     waiter.sigmask = 1 << signal;
 108     sigs |= waiter.sigmask;
 109
 110     // add it to the end of the list
 111     ObtainSemaphore(&cond->semaphore);
 112     AddTail((struct List *)&cond->waiters, (struct Node *)&waiter);
 113     ReleaseSemaphore(&cond->semaphore);
 114
 115     // wait for the condition to be signalled or the timeout
 116     mutex->incond++;
 117     pthread_mutex_unlock(mutex);
 118     sigs = Wait(sigs);
 119     pthread_mutex_lock(mutex);
 120     mutex->incond--;
 121
 122     // remove the node from the list
 123     ObtainSemaphore(&cond->semaphore);
 124     Remove((struct Node *)&waiter);
 125     ReleaseSemaphore(&cond->semaphore);
 126
 127     if (signal != SIGB_COND_FALLBACK)
 128         FreeSignal(signal);
 129
 130     if (abstime)
 131     {
 132         // clean up the timerequest
 133         if (!CheckIO((struct IORequest *)&timerio))
 134         {
 135             AbortIO((struct IORequest *)&timerio);
 136             WaitIO((struct IORequest *)&timerio);
 137         }
 138         CloseDevice((struct IORequest *)&timerio);
 139
 140         if (timermp.mp_SigBit != SIGB_TIMER_FALLBACK)
 141             FreeSignal(timermp.mp_SigBit);
 142
 143         // did we timeout?
 144         if (sigs & timermask)
 145             return ETIMEDOUT;
 146     }
 147
 148     return 0;
 149 }
 150
 151 int pthread_cond_timedwait(pthread_cond_t *cond, pthread_mutex_t *mutex, const struct timespec *abstime)
 152 {
 153     D(bug("%s(%p, %p, %p)\n", __FUNCTION__, cond, mutex, abstime));
 154
 155     return _pthread_cond_timedwait(cond, mutex, abstime, FALSE);
 156 }