コード例 #1
0
void vcos_thread_join(VCOS_THREAD_T *thread,
                             void **pData)
{
   pthread_join(thread->thread, pData);
   vcos_semaphore_delete(&thread->suspend);

   /* Delete the task timer, if present */
   _vcos_task_timer_cancel();
   if (thread->task_timer.pfn)
   {
      vcos_timer_delete(&thread->task_timer);
      thread->task_timer.pfn = NULL;
   }
}
コード例 #2
0
extern VCOS_STATUS_T vcos_generic_event_flags_get(VCOS_EVENT_FLAGS_T *flags,
                                                  VCOS_UNSIGNED bitmask,
                                                  VCOS_OPTION op,
                                                  VCOS_UNSIGNED suspend,
                                                  VCOS_UNSIGNED *retrieved_bits)
{
   VCOS_EVENT_WAITER_T waitreq;
   VCOS_STATUS_T rc = VCOS_EAGAIN;
   int satisfied = 0;

   vcos_assert(flags);

   /* default retrieved bits to 0 */
   *retrieved_bits = 0;

   vcos_mutex_lock(&flags->lock);
   switch (op & VCOS_EVENT_FLAG_OP_MASK)
   {
   case VCOS_AND:
      if ((flags->events & bitmask) == bitmask)
      {
         *retrieved_bits = flags->events;
         rc = VCOS_SUCCESS;
         satisfied = 1;
         if (op & VCOS_CONSUME)
            flags->events &= ~bitmask;
      }
      break;

   case VCOS_OR:
      if (flags->events & bitmask)
      {
         *retrieved_bits = flags->events;
         rc = VCOS_SUCCESS;
         satisfied = 1;
         if (op & VCOS_CONSUME)
            flags->events &= ~bitmask;
      }
      break;

   default:
      vcos_assert(0);
      rc = VCOS_EINVAL;
      break;
   }

   if (!satisfied && suspend)
   {
      /* Have to go to sleep.
       *
       * Append to tail so we get FIFO ordering.
       */
      waitreq.requested_events = bitmask;
      waitreq.op = op;
      waitreq.return_status = VCOS_EAGAIN;
      waitreq.flags = flags;
      waitreq.actual_events = 0;
      waitreq.thread = vcos_thread_current();
      waitreq.next = 0;
      vcos_assert(waitreq.thread != (VCOS_THREAD_T*)-1);
      VCOS_QUEUE_APPEND_TAIL(&flags->waiters, &waitreq);

      if (suspend != (VCOS_UNSIGNED)-1)
         _vcos_task_timer_set(event_flags_timer_expired, &waitreq, suspend);

      vcos_mutex_unlock(&flags->lock);
      /* go to sleep and wait to be signalled or timeout */

      _vcos_thread_sem_wait();

      *retrieved_bits = waitreq.actual_events;
      rc = waitreq.return_status;

      /* cancel the timer - do not do this while holding the mutex as it
       * might be waiting for the timeout function to complete, which will
       * try to take the mutex.
       */
      if (suspend != (VCOS_UNSIGNED)-1)
         _vcos_task_timer_cancel();
   }
   else
   {
      vcos_mutex_unlock(&flags->lock);
   }

   return rc;
}