Exemple #1
0
void vc_hostfs_init(void)
{
   // This hostfs module is not thread safe - it allocaes a block
   // of memory and uses it without any kind of locking. 
   //
   // It offers no advantage of stdio, and so most clients should
   // not use it. Arguably FILESYS should use it in order to get
   // the FIFO support.

   const char *thread_name = vcos_thread_get_name(vcos_thread_current());
   if (strcmp(thread_name, "FILESYS") != 0 && strcmp(thread_name, "HFilesys") != 0)
   {
      fprintf(stderr,"%s: vc_hostfs is deprecated. Please use stdio\n",
              vcos_thread_get_name(vcos_thread_current()));
   }

   vcos_log_register("hostfs", &hostfs_log_cat);
   DEBUG_MINOR("init");
   // Allocate memory for the file info table
   p_file_info_table = (file_info_t *)calloc( FILE_INFO_TABLE_CHUNK_LEN, sizeof( file_info_t ) );
   assert( p_file_info_table != NULL );
   if (p_file_info_table)
   {
      file_info_table_len = FILE_INFO_TABLE_CHUNK_LEN;
   }
}
void _vcos_task_timer_set(void (*pfn)(void*), void *cxt, VCOS_UNSIGNED ms)
{
   VCOS_THREAD_T *thread = vcos_thread_current();
   VCOS_STATUS_T status;
   status = vcos_timer_create(&thread->task_timer, "vcos_task_timer", pfn, cxt);
   vcos_assert(status == VCOS_SUCCESS);
   vcos_timer_set(&thread->task_timer, ms);
}
void _vcos_task_timer_set(void (*pfn)(void*), void *cxt, VCOS_UNSIGNED ms)
{
   VCOS_THREAD_T *self = vcos_thread_current();
   vcos_assert(self);
   vcos_assert(self->_timer.pfn == NULL);
   self->_timer.pfn = pfn;
   self->_timer.cxt = cxt;
   vcos_timer_set(&self->_timer.timer, ms);
}
void _vcos_task_timer_cancel(void)
{
   VCOS_THREAD_T *self = vcos_thread_current();
   if (self->_timer.timer.linux_timer.function)
   {
      vcos_timer_cancel(&self->_timer.timer);
      vcos_timer_delete(&self->_timer.timer);
   }
}
void vcos_thread_exit(void *arg)
{
   VCOS_THREAD_T *thread = vcos_thread_current();

   vcos_assert(thread);
   vcos_assert(thread->magic == VCOS_THREAD_MAGIC);

   thread->exit_data = arg;
}
void _vcos_task_timer_set(void (*pfn)(void *), void *cxt, VCOS_UNSIGNED ms)
{
   VCOS_THREAD_T *self = vcos_thread_current();
   vcos_assert(self);
   vcos_assert(self->_timer.pfn == NULL);

   vcos_timer_create( &self->_timer.timer, "TaskTimer", pfn, cxt );
   vcos_timer_set(&self->_timer.timer, ms);
}
void _vcos_task_timer_cancel(void)
{
   VCOS_THREAD_T *thread = vcos_thread_current();
   if (thread->task_timer.pfn)
   {
      thread->task_timer.pfn = NULL;
      vcos_timer_delete(&thread->task_timer);
   }
}
void _vcos_task_timer_cancel(void)
{
   VCOS_THREAD_T *self = vcos_thread_current();
   if (self->_timer.pfn)
   {
      vcos_timer_cancel(&self->_timer.timer);
      self->_timer.pfn = NULL;
   }
}
void _vcos_task_timer_cancel(void)
{
   VCOS_THREAD_T *thread = vcos_thread_current();

   if (thread == NULL || !thread->task_timer_created)
     return;

   vcos_timer_cancel(&thread->task_timer);
   thread->orig_task_timer_expiration_routine = NULL;
}
void vcos_generic_reentrant_mutex_unlock(VCOS_REENTRANT_MUTEX_T *m)
{
   vcos_assert(m->count != 0);
   vcos_assert(m->owner == vcos_thread_current());
   m->count--;
   if (m->count == 0)
   {
      m->owner = 0;
      vcos_mutex_unlock(&m->mutex);
   }
}
void vcos_thread_exit(void *arg)
{
   VCOS_THREAD_T *thread = vcos_thread_current();

   if ( thread && thread->dummy )
   {
      vcos_free ( (void*) thread );
      thread = NULL;
   }

   pthread_exit(arg);
}
Exemple #12
0
void vcos_thread_exit(void *arg)
{
   VCOS_THREAD_T *thread = vcos_thread_current();

   if ( thread && thread->dummy )
   {
      vcos_free ( (void*) thread );
      thread = NULL;
   }

   // Do nothing
   UNREFERENCED_PARAMETER(arg);
}
void vcos_generic_reentrant_mutex_lock(VCOS_REENTRANT_MUTEX_T *m)
{
   VCOS_THREAD_T *thread = vcos_thread_current();
   vcos_assert(m);

   vcos_assert(thread != 0);

   if (m->owner != thread)
   {
      vcos_mutex_lock(&m->mutex);
      m->owner = thread;
      vcos_assert(m->count == 0);
   }
   m->count++;
}
extern void vcos_thread_deregister_at_exit(void (*pfn)(void*), void *cxt)
{
   int i;
   VCOS_THREAD_T *self = vcos_thread_current();
   vcos_assert(self);
   vcos_assert(!self->joined);
   for (i=0; i<VCOS_MAX_EXIT_HANDLERS; i++)
   {
      if ((self->at_exit[i].pfn == pfn) && (self->at_exit[i].cxt == cxt)) {
         self->at_exit[i].pfn = NULL;
         return;
      }
   }
   vcos_assert(0); /* pfn/cxt not found */
}
    // Wait on the mutex semaphore if we don't already own it.
void _mwmutex_lock(_lock_t sem)
{
#if _REENTRANT
   if (sem != 0)
   {
      void *self = vcos_thread_current();
      if (sem->th_id == self)
         sem->count++;
      else
      {
	 rtos_latch_get( &sem->latch );
	 sem->th_id = self;
	 sem->count = 1;
      }
   }
#endif
}
Exemple #16
0
static _VCOS_INLINE
void vcos_msg_send_helper(VCOS_MSGQUEUE_T *src,
                           VCOS_MSGQUEUE_T *dest,
                           uint32_t code,
                           VCOS_MSG_T *msg)
{
   vcos_assert(msg);
   vcos_assert(dest);

   msg->code = code;
   msg->dst = dest;
   msg->src = src;
   msg->next = NULL;
   msg->src_thread = vcos_thread_current();

   msgq_append(dest, msg);
   vcos_semaphore_post(&dest->sem);
}
bool khrn_worker_init(void)
{
#ifndef KHRN_WORKER_USE_LLAT
   VCOS_THREAD_ATTR_T attr;
#endif
   vcos_assert(!inited);

   khrn_worker_enter_pos = 0;
   khrn_worker_exit_pos_0 = 0;
   khrn_worker_exit_pos_1 = 0;

   khrn_worker_msg.post = msgs;
   khrn_worker_msg.done_it = msgs;
   khrn_worker_msg.cleanup = msgs;

#ifdef KHRN_WORKER_USE_LLAT
   llat_i = khrn_llat_register(khrn_worker_llat_callback);
   vcos_assert(llat_i != -1);
#else
   if (vcos_event_create(&event, "khrn_worker_event") != VCOS_SUCCESS) {
      return false;
   }

   exit_thread = false;

   vcos_thread_attr_init(&attr);
   vcos_thread_attr_setpriority(&attr, THREAD_PRIORITY);
#if !defined(V3D_LEAN)
   switch (vcos_thread_get_affinity(vcos_thread_current())) {
   case VCOS_AFFINITY_CPU0: vcos_thread_attr_setaffinity(&attr, VCOS_AFFINITY_CPU1); break;
   case VCOS_AFFINITY_CPU1: vcos_thread_attr_setaffinity(&attr, VCOS_AFFINITY_CPU0); break;
   }
   vcos_thread_attr_setstacksize(&attr, THREAD_STACK_SIZE);
#endif /* V3D_LEAN */
   if (vcos_thread_create(&thread, "khrn_worker_thread", &attr, khrn_worker_main, NULL) != VCOS_SUCCESS) {
      vcos_event_delete(&event);
      return false;
   }
#endif

   inited = true;

   return true;
}
extern VCOS_STATUS_T vcos_thread_at_exit(void (*pfn)(void*), void *cxt)
{
   int i;
   VCOS_THREAD_T *self = vcos_thread_current();
   if (!self)
   {
      vcos_assert(0);
      return VCOS_EINVAL;
   }
   for (i=0; i<VCOS_MAX_EXIT_HANDLERS; i++)
   {
      if (self->at_exit[i].pfn == NULL)
      {
         self->at_exit[i].pfn = pfn;
         self->at_exit[i].cxt = cxt;
         return VCOS_SUCCESS;
      }
   }
   return VCOS_ENOSPC;
}
/** Exit the thread. Resources must still be cleaned up via a call to thread_join().
  */
void vcos_thread_exit(void *data)
{

   /* Get the current task pointer, and cast to the joinable thread
    * structure - this works with Nucleus and ThreadX style threads
    * which is what this is designed for, but may not work with
    * other thread types.
    */

   VCOS_THREAD_T *thread = vcos_thread_current();

   vcos_assert(thread);
   vcos_assert(thread->magic == VCOS_THREAD_MAGIC);

   thread->exit_data = data;

   /* Wake up our parent */
   vcos_semaphore_post(&thread->wait);

   vcos_llthread_exit();
}
void _vcos_task_timer_set(void (*pfn)(void*), void *cxt, VCOS_UNSIGNED ms)
{
   VCOS_THREAD_T *thread = vcos_thread_current();

   if (thread == NULL)
      return;

   vcos_assert(thread->orig_task_timer_expiration_routine == NULL);

   if (!thread->task_timer_created)
   {
      VCOS_STATUS_T st = vcos_timer_create(&thread->task_timer, NULL,
                                _task_timer_expiration_routine, thread);
      (void)st;
      vcos_assert(st == VCOS_SUCCESS);
      thread->task_timer_created = 1;
   }

   thread->orig_task_timer_expiration_routine = pfn;
   thread->orig_task_timer_context = cxt;

   vcos_timer_set(&thread->task_timer, ms);
}
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;
}
Exemple #22
0
static void
pool_object_logging( const char *fname, VC_POOL_OBJECT_T *object )
{
   logging_message( LOGGING_VMCS,"%s: %p: task %s: refcount=%d", fname, object,
                    vcos_thread_get_name( vcos_thread_current() ), object->refcount );
}