event.c

Go to the documentation of this file.

/*
 SPDX-FileCopyrightText: © 2010, 2011, 2012 Hewlett-Packard Development Company, L.P.
 
 SPDX-License-Identifier: GPL-2.0-only
*/
/* local includes */
#include <event.h>
#include <logging.h>
#include <scheduler.h>
 
/* std libaray includes */
#include <stdlib.h>
#include <string.h>
#include <stdio.h>
 
/* ************************************************************************** */
/* **** Local(private) fields *********************************************** */
/* ************************************************************************** */
 
event_loop_t vl_singleton;
 
int el_created = 0;
 
event_loop_t* event_loop_get()
{
 
  /* if the event loop has already been created, return it */
  if(el_created)
  {
    return &vl_singleton;
  }
 
  vl_singleton.queue = g_async_queue_new_full((GDestroyNotify)event_destroy);
  vl_singleton.occupied   = 0;
  vl_singleton.terminated = 0;
  el_created = 1;
 
  return &vl_singleton;
}
 
int event_loop_put(event_loop_t* event_loop, event_t* e)
{
  g_async_queue_push(event_loop->queue, e);
  return 1;
}
 
event_t* event_loop_take(event_loop_t* event_loop)
{
#if !GLIB_CHECK_VERSION(2, 32, 0)
  GTimeVal timeout;
#endif
  event_t* ret;
  int sec = 0;
  int usec = 0;
 
  if(event_loop->terminated)
  {
    return NULL;
  }
 
  /* wait for 1 second */
  sec = 1;
  usec = 0;
#if GLIB_CHECK_VERSION(2, 32, 0)
  if((ret = g_async_queue_timeout_pop(event_loop->queue,
      sec * 1000000 + usec)) == NULL)
    return ret;
#else
  timeout.tv_sec  = sec;
  timeout.tv_usec = usec;
  g_get_current_time(&timeout);
  g_time_val_add(&timeout, 1000000);
  if((ret = g_async_queue_timed_pop(event_loop->queue, &timeout)) == NULL)
    return ret;
#endif
 
  if(ret->func == NULL)
  {
    event_destroy(ret);
    ret = NULL;
  }
 
  return ret;
}
 
/* ************************************************************************** */
/* **** Constructor Destructor ********************************************** */
/* ************************************************************************** */
 
event_t* event_init(void(*func)(scheduler_t*, void*), void* arg, char* name, char* source_name, uint16_t source_line)
{
  event_t* e = g_new(event_t, 1);
 
  e->func = func;
  e->argument = arg;
  e->name = name;
  e->source_name = source_name;
  e->source_line = source_line;
 
  return e;
}
 
void event_destroy(event_t* e)
{
  e->func     = NULL;
  e->argument = NULL;
  e->name     = NULL;
 
  g_free(e);
}
 
void event_loop_destroy()
{
  g_async_queue_unref(event_loop_get()->queue);
  el_created = 0;
}
 
/* ************************************************************************** */
/* **** EventLoop Functions ************************************************* */
/* ************************************************************************** */
 
void event_signal_ext(void* func, void* args, char* name, char* s_name, uint16_t s_line)
{
  V_EVENT("EVENT: creating event: [%p, %p, %s, %s, %d]", func, args, name, s_name, s_line);
  event_loop_put(event_loop_get(), event_init((event_function)func, args, name, s_name, s_line));
}
 
int event_loop_enter(scheduler_t* scheduler,
    void(*update_call)(scheduler_t*),
    void(*signal_call)(scheduler_t*))
{
  event_t* e;
  event_loop_t* event_loop = event_loop_get();
 
  /* start by checking to make sure this is the only thread in this loop */
  g_async_queue_lock(event_loop->queue);
  if(event_loop->occupied)
  {
    g_async_queue_unlock(event_loop->queue);
    return 0x1;
  }
  event_loop->occupied = 1;
  event_loop->terminated = 0;
  g_async_queue_unlock(event_loop->queue);
 
  main_thread = g_thread_self();
 
  /* from here on out, this is the only thread in this event loop     */
  /* the loop to execute events is very simple, grab event, run event */
  while(!event_loop->terminated)
  {
    e = event_loop_take(event_loop);
 
    if(signal_call)
      signal_call(scheduler);
    if(e == NULL)
      continue;
 
    if(TVERB_EVENT && strcmp(e->name, "log_event") != 0)
      log_printf("EVENT: calling %s, source[%s.%d] \n", e->name, e->source_name, e->source_line);
    e->func(scheduler, e->argument);
 
    if(TVERB_EVENT && strcmp(e->name, "log_event") != 0)
      log_printf("EVENT: finished %s, source[%s.%d] \n", e->name, e->source_name, e->source_line);
 
    event_destroy(e);
 
    if(update_call)
      update_call(scheduler);
  }
 
  return 0x0;
}
 
void event_loop_terminate()
{
  event_loop_t* event_loop = event_loop_get();
 
  event_loop->terminated = 1;
  event_loop->occupied = 0;
  event_signal(NULL, NULL);
}