static gboolean
G_SIG_check(GSource* source)
{
GSIGSource* sig_src = (GSIGSource*)source;
g_assert(IS_SIGSOURCE(sig_src));
if (sig_src->signal_triggered) {
clock_t now;
clock_t diff;
if (cmp_longclock(lc_fetch(sig_src->detecttime), zero_longclock) != 0){
return TRUE;
}
/* Otherwise, this is when it was first detected */
now = cl_times();
diff = now - sig_src->sh_detecttime;
lc_store(
sig_src->detecttime,
sub_longclock(time_longclock(), (longclock_t)diff)
);
return TRUE;
}
return FALSE;
}
/* g_main_loop-style check function */
static gboolean
Gmain_timeout_check (GSource* src)
{
struct GTimeoutAppend* append = GTIMEOUT(src);
longclock_t lnow = time_longclock();
g_assert(IS_TIMEOUTSRC(append));
if (cmp_longclock(lnow, append->nexttime) >= 0) {
return TRUE;
}
return FALSE;
}
static gboolean
G_TRIG_check(GSource* source)
{
GTRIGSource* trig_src = (GTRIGSource*)source;
g_assert(IS_TRIGSOURCE(trig_src));
if (trig_src->manual_trigger
&& cmp_longclock(lc_fetch(trig_src->detecttime), zero_longclock) == 0) {
lc_store((trig_src->detecttime), time_longclock());
}
return trig_src->manual_trigger;
}
/* g_main_loop-style prepare function */
static gboolean
Gmain_timeout_prepare(GSource* src, gint* timeout)
{
struct GTimeoutAppend* append = GTIMEOUT(src);
longclock_t lnow = time_longclock();
longclock_t remain;
g_assert(IS_TIMEOUTSRC(append));
if (cmp_longclock(lnow, append->nexttime) >= 0) {
*timeout = 0L;
return TRUE;
}
/* This is safe - we will always have a positive result */
remain = sub_longclock(append->nexttime, lnow);
/* This is also safe - we started out in 'ms' */
*timeout = longclockto_ms(remain);
return ((*timeout) == 0);
}
static gboolean
G_SIG_prepare(GSource* source, gint* timeoutms)
{
GSIGSource* sig_src = (GSIGSource*)source;
g_assert(IS_SIGSOURCE(sig_src));
/* Don't let a timing window keep us in poll() forever
*
* The timing window in question looks like this:
* No signal has occurred up to the point of prepare being called.
* Signal comes in _after_ prepare was called, but _before_ poll.
* signal_detected gets set, but no one checks it before going into poll
* We wait in poll forever... It's not a pretty sight :-(.
*/
*timeoutms = 1000; /* Sigh... */
if (sig_src->signal_triggered) {
clock_t now;
clock_t diff;
/* detecttime is reset in the dispatch function */
if (cmp_longclock(lc_fetch(sig_src->detecttime), zero_longclock) != 0) {
cl_log(LOG_ERR, "%s: detecttime already set?", __FUNCTION__);
return TRUE;
}
/* Otherwise, this is when it was first detected */
now = cl_times();
diff = now - sig_src->sh_detecttime; /* How long since signal occurred? */
lc_store(
sig_src->detecttime,
sub_longclock(time_longclock(), (longclock_t)diff)
);
return TRUE;
}
return FALSE;
}
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;
}