/* g_main_loop-style dispatch function */ static gboolean Gmain_timeout_dispatch(GSource* src, GSourceFunc func, gpointer user_data) { struct GTimeoutAppend* append = GTIMEOUT(src); longclock_t dispstart; gboolean ret; g_assert(IS_TIMEOUTSRC(append)); lc_store(append->detecttime, append->nexttime); CHECK_DISPATCH_DELAY(append); /* Schedule our next dispatch */ append->nexttime = add_longclock(time_longclock() , msto_longclock(append->interval)); /* Then call the user function */ ret = func(user_data); CHECK_DISPATCH_TIME(append); return ret; }
guint Gmain_timeout_add_full(gint priority , guint interval , GSourceFunc function , gpointer data , GDestroyNotify notify) { struct GTimeoutAppend* append; GSource* source = g_source_new( &Gmain_timeout_funcs, sizeof(struct GTimeoutAppend)); append = GTIMEOUT(source); append->magno = MAG_GTIMEOUTSRC; append->maxdispatchms = DEFAULT_MAXDISPATCH; append->maxdispatchdelayms = DEFAULT_MAXDELAY; append->description = "(timeout)"; lc_store((append->detecttime), zero_longclock); append->udata = NULL; append->nexttime = add_longclock(time_longclock() , msto_longclock(interval)); append->interval = interval; g_source_set_priority(source, priority); g_source_set_can_recurse(source, FALSE); g_source_set_callback(source, function, data, notify); append->gsourceid = g_source_attach(source, NULL); g_source_unref(source); return append->gsourceid; }
int LogToLoggingDaemon(int priority, const char * buf, int bufstrlen, gboolean use_pri_str) { IPC_Channel* chan = logging_daemon_chan; static longclock_t nexttime = 0; IPC_Message* msg; int sendrc = IPC_FAIL; int intval = conn_logd_time; if (chan == NULL) { longclock_t lnow = time_longclock(); if (cmp_longclock(lnow, nexttime) >= 0){ nexttime = add_longclock( lnow, msto_longclock(intval)); logging_daemon_chan = chan = create_logging_channel(); } } if (chan == NULL){ cl_direct_log( priority, buf, TRUE, NULL, cl_process_pid, NULLTIME); return HA_FAIL; } msg = ChildLogIPCMessage(priority, buf, bufstrlen, use_pri_str, chan); if (msg == NULL) { drop_msg_num++; return HA_FAIL; } if (chan->ch_status == IPC_CONNECT){ if (chan->ops->is_sending_blocked(chan)) { chan->ops->resume_io(chan); } /* Make sure there is room for the drop message _and_ the * one we wish to log. Otherwise there is no point. * * Try to avoid bouncing on the limit by additionally * waiting until there is room for QUEUE_SATURATION_FUZZ * messages. */ if (drop_msg_num > 0 && chan->send_queue->current_qlen < (chan->send_queue->max_qlen -1 -QUEUE_SATURATION_FUZZ)) { /* have to send it this way so the order is correct */ send_dropped_message(use_pri_str, chan); } sendrc = chan->ops->send(chan, msg); } if (sendrc == IPC_OK) { return HA_OK; } else { if (chan->ops->get_chan_status(chan) != IPC_CONNECT) { if (!logging_chan_in_main_loop){ chan->ops->destroy(chan); } logging_daemon_chan = NULL; cl_direct_log(priority, buf, TRUE, NULL, cl_process_pid, NULLTIME); if (drop_msg_num > 0){ /* Direct logging here is ok since we're * switching to that for everything * "for a while" */ cl_log(LOG_ERR, "cl_log: %d messages were dropped" " : channel destroyed", drop_msg_num); } drop_msg_num=0; FreeChildLogIPCMessage(msg); return HA_FAIL; } drop_msg_num++; } FreeChildLogIPCMessage(msg); return HA_FAIL; }