glib_os_hnd.c File Reference

#include <config.h>
#include <stdlib.h>
#include <errno.h>
#include <stdio.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <unistd.h>
#include <pthread.h>
#include <string.h>
#include <signal.h>
#include <OpenIPMI/os_handler.h>
#include <glib.h>

Go to the source code of this file.

Classes
struct	g_os_hnd_data_s
struct	os_hnd_fd_id_s
struct	os_hnd_timer_id_s
struct	vlog_data_s
struct	os_hnd_lock_s
struct	os_hnd_cond_s
Defines
#define	_GNU_SOURCE
Typedefs
typedef g_os_hnd_data_s	g_os_hnd_data_t
typedef vlog_data_s	vlog_data_t
Functions
static gboolean	fd_handler (GIOChannel *source, GIOCondition condition, gpointer data)
static void	free_fd_data (gpointer data)
static int	add_fd (os_handler_t *handler, int fd, os_data_ready_t data_ready, void *cb_data, os_fd_data_freed_t freed, os_hnd_fd_id_t **id)
static int	remove_fd (os_handler_t *handler, os_hnd_fd_id_t *fd_data)
static gboolean	timer_handler (gpointer data)
static int	start_timer (os_handler_t *handler, os_hnd_timer_id_t *id, struct timeval *timeout, os_timed_out_t timed_out, void *cb_data)
static int	stop_timer (os_handler_t *handler, os_hnd_timer_id_t *id)
static int	alloc_timer (os_handler_t *handler, os_hnd_timer_id_t **id)
static int	free_timer (os_handler_t *handler, os_hnd_timer_id_t *id)
static int	get_random (os_handler_t *handler, void *data, unsigned int len)
static void	vlog_data_destroy (gpointer data)
static vlog_data_t *	get_vlog_data (void)
static void	add_vlog_data (vlog_data_t *info, const char *format, va_list ap)
static void	glib_vlog (os_handler_t *handler, enum ipmi_log_type_e log_type, const char *format, va_list ap)
static void	glib_log (os_handler_t *handler, enum ipmi_log_type_e log_type, const char *format,...)
static int	create_lock (os_handler_t *handler, os_hnd_lock_t **id)
static int	destroy_lock (os_handler_t *handler, os_hnd_lock_t *id)
static int	lock (os_handler_t *handler, os_hnd_lock_t *id)
static int	unlock (os_handler_t *handler, os_hnd_lock_t *id)
static int	create_cond (os_handler_t *handler, os_hnd_cond_t **new_cond)
static int	destroy_cond (os_handler_t *handler, os_hnd_cond_t *cond)
static int	cond_wait (os_handler_t *handler, os_hnd_cond_t *cond, os_hnd_lock_t *lock)
static int	cond_timedwait (os_handler_t *handler, os_hnd_cond_t *cond, os_hnd_lock_t *lock, struct timeval *rtimeout)
static int	cond_wake (os_handler_t *handler, os_hnd_cond_t *cond)
static int	cond_broadcast (os_handler_t *handler, os_hnd_cond_t *cond)
static gint	timeout_callback (gpointer data)
static int	perform_one_op (os_handler_t *os_hnd, struct timeval *timeout)
static void	operation_loop (os_handler_t *os_hnd)
static void	free_os_handler (os_handler_t *os_hnd)
static void *	glib_malloc (int size)
static void	glib_free (void *data)
static void	sset_log_handler (os_handler_t *handler, os_vlog_t log_handler)
os_handler_t *	ipmi_glib_get_os_handler (int priority)
static void	glib_handle_log (const gchar *log_domain, GLogLevelFlags log_level, const gchar *message, gpointer user_data)
void	ipmi_glib_set_log_handler (void(*hndlr)(const char *domain, const char *pfx, const char *msg))
Variables
static GStaticPrivate	vlog_private = G_STATIC_PRIVATE_INIT
static os_handler_t	ipmi_glib_os_handler
static void(*	log_hndlr )(const char *domain, const char *pfx, const char *msg)

---

Define Documentation

#define _GNU_SOURCE

Definition at line 37 of file glib_os_hnd.c.

---

Typedef Documentation

typedef struct g_os_hnd_data_s g_os_hnd_data_t

typedef struct vlog_data_s vlog_data_t

---

Function Documentation

static int add_fd (  os_handler_t *  handler, int  fd, os_data_ready_t  data_ready, void *  cb_data, os_fd_data_freed_t  freed, os_hnd_fd_id_t **  id )  [static]

Definition at line 110 of file glib_os_hnd.c. References fd_handler(), free_fd_data(), os_handler_s::internal_data, and g_os_hnd_data_s::priority. { os_hnd_fd_id_t *fd_data; g_os_hnd_data_t *info = handler->internal_data; fd_data = g_malloc(sizeof(*fd_data)); if (!fd_data) return ENOMEM; memset(fd_data, 0, sizeof(fd_data)); fd_data->chan = g_io_channel_unix_new(fd); if (!fd_data->chan) { g_free(fd_data); return ENOMEM; } fd_data->fd = fd; fd_data->cb_data = cb_data; fd_data->data_ready = data_ready; fd_data->handler = handler; fd_data->freed = freed; fd_data->ev_id = g_io_add_watch_full(fd_data->chan, info->priority, G_IO_IN, fd_handler, fd_data, free_fd_data); *id = fd_data; return 0; }

static void add_vlog_data (  vlog_data_t *  info, const char *  format, va_list  ap )  [static]

Definition at line 335 of file glib_os_hnd.c. References vlog_data_s::curr, vlog_data_s::data, and vlog_data_s::len. Referenced by glib_vlog(). { int len; len = vsnprintf(info->data+info->curr, info->len-info->curr, format, ap); if ((len + info->curr) > info->len) { char *nd; int new_size; new_size = info->len + 64; while (new_size < (len + info->curr)) new_size += 64; nd = g_malloc(new_size); if (!nd) return; if (info->data) { memcpy(nd, info->data, info->curr); g_free(info->data); } info->data = nd; info->len = new_size; len = vsnprintf(info->data+info->curr, info->len-info->curr, format, ap); } info->curr += len; }

static int alloc_timer (  os_handler_t *  handler, os_hnd_timer_id_t **  id )  [static]

Definition at line 220 of file glib_os_hnd.c. { os_hnd_timer_id_t *timer_data; timer_data = g_malloc(sizeof(*timer_data)); if (!timer_data) return ENOMEM; timer_data->running = 0; timer_data->timed_out = NULL; timer_data->handler = handler; *id = timer_data; return 0; }

static int cond_broadcast (  os_handler_t *  handler, os_hnd_cond_t *  cond )  [static]

Definition at line 560 of file glib_os_hnd.c. References os_hnd_cond_s::cond. { g_cond_broadcast(cond->cond); return 0; }

static int cond_timedwait (  os_handler_t *  handler, os_hnd_cond_t *  cond, os_hnd_lock_t *  lock, struct timeval *  rtimeout )  [static]

Definition at line 528 of file glib_os_hnd.c. References os_hnd_cond_s::cond, and os_hnd_lock_s::mutex. { GTimeVal timeout; GTimeVal now; int rv; g_get_current_time(&now); timeout.tv_sec = rtimeout->tv_sec + now.tv_sec; timeout.tv_usec = rtimeout->tv_usec + now.tv_usec; while (timeout.tv_usec > 1000000) { timeout.tv_sec += 1; timeout.tv_usec -= 1000000; } rv = g_cond_timed_wait(cond->cond, lock->mutex, &timeout); if (rv) return ETIMEDOUT; return 0; }

static int cond_wait (  os_handler_t *  handler, os_hnd_cond_t *  cond, os_hnd_lock_t *  lock )  [static]

Definition at line 519 of file glib_os_hnd.c. References os_hnd_cond_s::cond, and os_hnd_lock_s::mutex. { g_cond_wait(cond->cond, lock->mutex); return 0; }

static int cond_wake (  os_handler_t *  handler, os_hnd_cond_t *  cond )  [static]

Definition at line 552 of file glib_os_hnd.c. References os_hnd_cond_s::cond. { g_cond_signal(cond->cond); return 0; }

static int create_cond (  os_handler_t *  handler, os_hnd_cond_t **  new_cond )  [static]

Definition at line 491 of file glib_os_hnd.c. { os_hnd_cond_t *cond; cond = g_malloc(sizeof(*cond)); if (!cond) return ENOMEM; cond->cond = g_cond_new(); if (!cond->cond) { g_free(cond); return ENOMEM; } *new_cond = cond; return 0; }

static int create_lock (  os_handler_t *  handler, os_hnd_lock_t **  id )  [static]

Definition at line 442 of file glib_os_hnd.c. References lock(). { os_hnd_lock_t *lock; lock = g_malloc(sizeof(*lock)); if (!lock) return ENOMEM; lock->mutex = g_mutex_new(); if (!lock->mutex) { g_free(lock); return ENOMEM; } *id = lock; return 0; }

static int destroy_cond (  os_handler_t *  handler, os_hnd_cond_t *  cond )  [static]

Definition at line 510 of file glib_os_hnd.c. References os_hnd_cond_s::cond. { g_cond_free(cond->cond); g_free(cond); return 0; }

static int destroy_lock (  os_handler_t *  handler, os_hnd_lock_t *  id )  [static]

Definition at line 461 of file glib_os_hnd.c. References os_hnd_lock_s::mutex. { g_mutex_free(id->mutex); g_free(id); return 0; }

static gboolean fd_handler (  GIOChannel *  source, GIOCondition  condition, gpointer  data )  [static]

Definition at line 83 of file glib_os_hnd.c. References os_hnd_fd_id_s::cb_data, os_hnd_fd_id_s::data_ready, os_hnd_fd_id_s::fd, and handler. { os_hnd_fd_id_t *fd_data = (os_hnd_fd_id_t *) data; void *cb_data; os_data_ready_t handler; int fd; handler = fd_data->data_ready; cb_data = fd_data->cb_data; fd = fd_data->fd; handler(fd, cb_data, fd_data); return TRUE; }

static void free_fd_data (  gpointer  data  )  [static]

Definition at line 100 of file glib_os_hnd.c. References os_hnd_fd_id_s::cb_data, os_hnd_fd_id_s::fd, and os_hnd_fd_id_s::freed. { os_hnd_fd_id_t *fd_data = (void *) data; if (fd_data->freed) fd_data->freed(fd_data->fd, fd_data->cb_data); g_free(data); }

static void free_os_handler (  os_handler_t *  os_hnd  )  [static]

Definition at line 626 of file glib_os_hnd.c. References os_handler_s::internal_data. { g_os_hnd_data_t *info = os_hnd->internal_data; #ifdef HAVE_GDBM g_mutex_free(info->gdbm_lock); if (info->gdbm_filename) free(info->gdbm_filename); if (info->gdbmf) gdbm_close(info->gdbmf); #endif g_free(info); g_free(os_hnd); }

static int free_timer (  os_handler_t *  handler, os_hnd_timer_id_t *  id )  [static]

Definition at line 238 of file glib_os_hnd.c. References os_hnd_timer_id_s::running. { if (id->running) return EBUSY; g_free(id); return 0; }

static int get_random (  os_handler_t *  handler, void *  data, unsigned int  len )  [static]

Definition at line 249 of file glib_os_hnd.c. { #if GLIB_MAJOR_VERSION < 2 int fd = open("/dev/urandom", O_RDONLY); int rv = 0; if (fd == -1) return errno; while (len > 0) { rv = read(fd, data, len); if (rv < 0) { rv = errno; goto out; } len -= rv; } rv = 0; out: close(fd); return rv; #else gint32 val; char *out = data; while (len >= sizeof(val)) { val = g_random_int(); memcpy(out, &val, sizeof(val)); len -= sizeof(val); out += sizeof(val); } if (len) { val = g_random_int(); memcpy(out, &val, len); len -= sizeof(val); } return 0; #endif }

static vlog_data_t* get_vlog_data (  void   )  [static]

Definition at line 313 of file glib_os_hnd.c. References vlog_data_destroy(), and vlog_private. Referenced by glib_vlog(). { vlog_data_t *rv; rv = g_static_private_get(&vlog_private); if (!rv) { rv = g_malloc(sizeof(*rv)); if (rv) { memset(rv, 0, sizeof(*rv)); rv->data = g_malloc(1024); if (rv->data) rv->len = 1024; else rv->len = 0; g_static_private_set(&vlog_private, rv, vlog_data_destroy); } } return rv; }

static void glib_free (  void *  data  )  [static]

Definition at line 648 of file glib_os_hnd.c. { g_free(data); }

static void glib_handle_log (  const gchar *  log_domain, GLogLevelFlags  log_level, const gchar *  message, gpointer  user_data )  [static]

Definition at line 863 of file glib_os_hnd.c. References log_hndlr. Referenced by ipmi_glib_set_log_handler(), and main(). { void (*hndlr)(const char *domain, const char *pfx, const char *msg); char *pfx = ""; if (log_level & G_LOG_LEVEL_ERROR) pfx = "FATL"; else if (log_level & G_LOG_LEVEL_CRITICAL) pfx = "SEVR"; else if (log_level & G_LOG_LEVEL_WARNING) pfx = "WARN"; else if (log_level & G_LOG_LEVEL_MESSAGE) pfx = "EINF"; else if (log_level & G_LOG_LEVEL_INFO) pfx = "INFO"; else if (log_level & G_LOG_LEVEL_DEBUG) pfx = "DEBG"; hndlr = log_hndlr; if (hndlr) hndlr(log_domain, pfx, message); }

static void glib_log (  os_handler_t *  handler, enum ipmi_log_type_e  log_type, const char *  format,   ... )  [static]

Definition at line 423 of file glib_os_hnd.c. References glib_vlog(). { va_list ap; va_start(ap, format); glib_vlog(handler, log_type, format, ap); va_end(ap); }

static void* glib_malloc (  int  size  )  [static]

Definition at line 642 of file glib_os_hnd.c. { return g_malloc(size); }

static void glib_vlog (  os_handler_t *  handler, enum ipmi_log_type_e  log_type, const char *  format, va_list  ap )  [static]

Definition at line 367 of file glib_os_hnd.c. References add_vlog_data(), vlog_data_s::curr, vlog_data_s::data, flags, get_vlog_data(), os_handler_s::internal_data, IPMI_LOG_DEBUG, IPMI_LOG_DEBUG_CONT, IPMI_LOG_DEBUG_END, IPMI_LOG_DEBUG_START, IPMI_LOG_ERR_INFO, IPMI_LOG_FATAL, IPMI_LOG_INFO, IPMI_LOG_SEVERE, IPMI_LOG_WARNING, g_os_hnd_data_s::log_handler, and log_handler. Referenced by glib_log(). { GLogLevelFlags flags; vlog_data_t *info; g_os_hnd_data_t *ginfo = handler->internal_data; os_vlog_t log_handler = ginfo->log_handler; if (log_handler) { log_handler(handler, format, log_type, ap); return; } switch (log_type) { case IPMI_LOG_INFO: flags = G_LOG_LEVEL_INFO; break; case IPMI_LOG_WARNING: flags = G_LOG_LEVEL_WARNING; break; case IPMI_LOG_SEVERE: flags = G_LOG_LEVEL_CRITICAL; break; case IPMI_LOG_FATAL: flags = G_LOG_LEVEL_ERROR; break; case IPMI_LOG_ERR_INFO: flags = G_LOG_LEVEL_MESSAGE; break; case IPMI_LOG_DEBUG: flags = G_LOG_LEVEL_DEBUG; break; case IPMI_LOG_DEBUG_END: info = get_vlog_data(); if (!info) return; add_vlog_data(info, format, ap); g_log("OpenIPMI", G_LOG_LEVEL_DEBUG, "%s", info->data); info->curr = 0; return; case IPMI_LOG_DEBUG_START: info = get_vlog_data(); if (!info) return; info->curr = 0; add_vlog_data(info, format, ap); return; case IPMI_LOG_DEBUG_CONT: info = get_vlog_data(); if (!info) return; add_vlog_data(info, format, ap); return; default: flags = G_LOG_LEVEL_INFO; break; } g_logv("OpenIPMI", flags, format, ap); }

os_handler_t* ipmi_glib_get_os_handler (  int  priority  )

Definition at line 824 of file glib_os_hnd.c. Referenced by main(). { os_handler_t *rv; g_os_hnd_data_t *info; if (!g_thread_supported ()) g_thread_init(NULL); rv = g_malloc(sizeof(*rv)); if (!rv) return NULL; memcpy(rv, &ipmi_glib_os_handler, sizeof(*rv)); info = g_malloc(sizeof(*info)); if (! info) { g_free(rv); return NULL; } memset(info, 0, sizeof(*info)); #ifdef HAVE_GDBM info->gdbm_lock = g_mutex_new(); if (!info->gdbm_lock) { free(info); free(rv); return NULL; } #endif info->priority = priority; rv->internal_data = info; return rv; }

void ipmi_glib_set_log_handler (  void(*)(const char *domain, const char *pfx, const char *msg)  hndlr  )

Definition at line 889 of file glib_os_hnd.c. References glib_handle_log(), and log_hndlr. { log_hndlr = hndlr; g_log_set_handler("OpenIPMI", G_LOG_LEVEL_ERROR | G_LOG_LEVEL_CRITICAL | G_LOG_LEVEL_WARNING | G_LOG_LEVEL_MESSAGE | G_LOG_LEVEL_INFO | G_LOG_LEVEL_DEBUG | G_LOG_FLAG_FATAL, glib_handle_log, NULL); }

static int lock (  os_handler_t *  handler, os_hnd_lock_t *  id )  [static]

Definition at line 470 of file glib_os_hnd.c. References os_hnd_lock_s::mutex. Referenced by create_lock(), find_free_lan_fd(), ipmi_create_lock_os_hnd(), ipmi_create_rwlock_os_hnd(), ll_std_lock(), ll_std_unlock(), and locked_list_alloc(). { g_mutex_lock(id->mutex); return 0; }

static void operation_loop (  os_handler_t *  os_hnd  )  [static]

Definition at line 619 of file glib_os_hnd.c. { for (;;) g_main_iteration(TRUE); }

static int perform_one_op (  os_handler_t *  os_hnd, struct timeval *  timeout )  [static]

Definition at line 605 of file glib_os_hnd.c. References timeout_callback(). { /* Note that this is not technically 100% correct in a multi-threaded environment, since another thread may run it, but it is pretty close, I guess. */ int time_ms = (timeout->tv_sec * 1000) + ((timeout->tv_usec+500) / 1000); guint guid = g_timeout_add(time_ms, timeout_callback, NULL); g_main_iteration(TRUE); g_source_remove(guid); return 0; }

static int remove_fd (  os_handler_t *  handler, os_hnd_fd_id_t *  fd_data )  [static]

Definition at line 148 of file glib_os_hnd.c. References os_hnd_fd_id_s::ev_id. { g_source_remove(fd_data->ev_id); /* fd_data gets freed in the free_fd_data callback registered at set time. */ return 0; }

static void sset_log_handler (  os_handler_t *  handler, os_vlog_t  log_handler )  [static]

Definition at line 766 of file glib_os_hnd.c. References os_handler_s::internal_data, and g_os_hnd_data_s::log_handler. { g_os_hnd_data_t *info = handler->internal_data; info->log_handler = log_handler; }

static int start_timer (  os_handler_t *  handler, os_hnd_timer_id_t *  id, struct timeval *  timeout, os_timed_out_t  timed_out, void *  cb_data )  [static]

Definition at line 182 of file glib_os_hnd.c. References os_handler_s::internal_data, g_os_hnd_data_s::priority, os_hnd_timer_id_s::running, and timer_handler(). { g_os_hnd_data_t *info = handler->internal_data; guint interval; if (id->running) return EBUSY; id->running = 1; id->cb_data = cb_data; id->timed_out = timed_out; interval = (timeout->tv_sec * 1000) | ((timeout->tv_usec + 999) / 1000); id->ev_id = g_timeout_add_full(info->priority, interval, timer_handler, id, NULL); return 0; }

static int stop_timer (  os_handler_t *  handler, os_hnd_timer_id_t *  id )  [static]

Definition at line 208 of file glib_os_hnd.c. References os_hnd_timer_id_s::ev_id, and os_hnd_timer_id_s::running. { if (!id->running) return EINVAL; id->running = 0; g_source_remove(id->ev_id); return 0; }

static gint timeout_callback (  gpointer  data  )  [static]

Definition at line 598 of file glib_os_hnd.c. Referenced by perform_one_op(). { /* We continually run the timer until it is cancelled. */ return TRUE; }

static gboolean timer_handler (  gpointer  data  )  [static]

Definition at line 166 of file glib_os_hnd.c. References os_hnd_timer_id_s::cb_data, os_hnd_timer_id_s::running, and os_hnd_timer_id_s::timed_out. { os_hnd_timer_id_t *timer_data = (os_hnd_timer_id_t *) data; /* Make a copy of this, because the handler may delete the timer data. */ void *cb_data; os_timed_out_t timed_out; timed_out = timer_data->timed_out; cb_data = timer_data->cb_data; timer_data->running = 0; timed_out(cb_data, timer_data); return FALSE; }

static int unlock (  os_handler_t *  handler, os_hnd_lock_t *  id )  [static]

Definition at line 478 of file glib_os_hnd.c. References os_hnd_lock_s::mutex. { g_mutex_unlock(id->mutex); return 0; }

static void vlog_data_destroy (  gpointer  data  )  [static]

Definition at line 303 of file glib_os_hnd.c. References vlog_data_s::data. Referenced by get_vlog_data(). { vlog_data_t *info = data; if (info->data) g_free(info->data); g_free(info); }

---

Variable Documentation

os_handler_t ipmi_glib_os_handler [static]

Definition at line 774 of file glib_os_hnd.c.

void(* log_hndlr)(const char *domain, const char *pfx, const char *msg) [static]

Definition at line 860 of file glib_os_hnd.c. Referenced by glib_handle_log(), and ipmi_glib_set_log_handler().

GStaticPrivate vlog_private = G_STATIC_PRIVATE_INIT [static]

Definition at line 293 of file glib_os_hnd.c. Referenced by get_vlog_data().

---

© sourcejam.com 2005-2008