/* Cluster logging function */
void
cl_log(int priority, const char * fmt, ...)
{
va_list ap;
char buf[MAXLINE];
ssize_t nbytes;
int needprivs = !cl_have_full_privs();
cl_process_pid = (int)getpid();
cl_log_depth++;
buf[MAXLINE-1] = EOS;
va_start(ap, fmt);
nbytes=vsnprintf(buf, sizeof(buf), fmt, ap);
va_end(ap);
if (nbytes >= (ssize_t)sizeof(buf)){
nbytes = sizeof(buf) -1 ;
}
if (needprivs) {
return_to_orig_privs();
}
if (stderr_enabled) {
print_logline(stderr, cl_log_entity,cl_process_pid,
NULLTIME, prio2str(priority), buf);
}
if (use_logging_daemon && cl_log_depth <= 1) {
LogToLoggingDaemon(priority, buf, nbytes, TRUE);
}else{
/* this may cause blocking... maybe should make it optional? */
cl_direct_log(priority, buf, TRUE, NULL, cl_process_pid, NULLTIME);
}
cl_log_depth--;
return;
}
static gboolean
direct_log(IPC_Channel* ch, gpointer user_data)
{
IPC_Message* ipcmsg;
GMainLoop* loop;
int pri = LOG_DEBUG + 1;
loop =(GMainLoop*)user_data;
while(ch->ops->is_message_pending(ch)){
if (ch->ch_status == IPC_DISCONNECT){
cl_log(LOG_ERR, "read channel is disconnected:"
"something very wrong happened");
return FALSE;
}
ipcmsg = getIPCmsg(ch);
if (ipcmsg == NULL){
return TRUE;
}
if( ipcmsg->msg_body
&& ipcmsg->msg_len > 0 ){
LogDaemonMsgHdr *logmsghdr;
LogDaemonMsgHdr copy;
char *msgtext;
logmsghdr = (LogDaemonMsgHdr*) ipcmsg->msg_body;
/* this copy nonsense is here because apparently ia64
* complained about "unaligned memory access. */
#define COPYFIELD(copy, msg, field) memcpy(((u_char*)©.field), ((u_char*)&msg->field), sizeof(copy.field))
COPYFIELD(copy, logmsghdr, use_pri_str);
COPYFIELD(copy, logmsghdr, entity);
COPYFIELD(copy, logmsghdr, entity_pid);
COPYFIELD(copy, logmsghdr, timestamp);
COPYFIELD(copy, logmsghdr, priority);
/* Don't want to copy the following message text */
msgtext = (char *)logmsghdr + sizeof(LogDaemonMsgHdr);
cl_direct_log(copy.priority, msgtext
, copy.use_pri_str
, copy.entity, copy.entity_pid
, copy.timestamp);
if (copy.priority < pri)
pri = copy.priority;
(void)logd_log;
/*
if (verbose){
logd_log("%s[%d]: %s %s\n",
logmsg->entity[0]=='\0'?
"unknown": copy.entity,
copy.entity_pid,
ha_timestamp(copy.timestamp),
msgtext);
}
*/
if (ipcmsg->msg_done){
ipcmsg->msg_done(ipcmsg);
}
}
}
/* current message backlog processed,
* about to return to mainloop,
* fflush and potentially fsync stuff */
cl_log_do_fflush(pri <= LOG_ERR);
if(needs_shutdown) {
cl_log(LOG_INFO, "Exiting write process");
g_main_quit(loop);
return FALSE;
}
return TRUE;
}
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;
}
