/* 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;
}
