*/
#include "includes.h"
-#include "lib/events/events.h"
-#include "../include/ctdb.h"
+#include "lib/tevent/tevent.h"
+#include "../include/ctdb_client.h"
#include "../include/ctdb_private.h"
#include "system/syslog.h"
#include "system/time.h"
{
struct sockaddr_in syslog_sin;
struct ctdb_syslog_state *state;
+ struct tevent_fd *fde;
state = talloc(ctdb, struct ctdb_syslog_state);
CTDB_NO_MEMORY(ctdb, state);
return -1;
}
- ctdb->syslogd_pid = fork();
+ ctdb->syslogd_pid = ctdb_fork(ctdb);
if (ctdb->syslogd_pid == (pid_t)-1) {
printf("Failed to create syslog child process\n");
close(state->fd[0]);
return 0;
}
+ debug_extra = talloc_asprintf(NULL, "syslogd:");
talloc_free(ctdb->ev);
ctdb->ev = event_context_init(NULL);
+ tevent_loop_allow_nesting(ctdb->ev);
syslog(LOG_ERR, "Starting SYSLOG daemon with pid:%d", (int)getpid());
close(state->fd[0]);
- event_add_fd(ctdb->ev, state, state->fd[1], EVENT_FD_READ|EVENT_FD_AUTOCLOSE,
+ set_close_on_exec(state->fd[1]);
+ fde = event_add_fd(ctdb->ev, state, state->fd[1], EVENT_FD_READ,
ctdb_syslog_terminate_handler, state);
+ tevent_fd_set_auto_close(fde);
state->syslog_fd = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP);
if (state->syslog_fd == -1) {
return -1;
}
+ set_close_on_exec(state->syslog_fd);
+
syslog_sin.sin_family = AF_INET;
syslog_sin.sin_port = htons(CTDB_PORT);
syslog_sin.sin_addr.s_addr = htonl(INADDR_LOOPBACK);
}
- event_add_fd(ctdb->ev, state, state->syslog_fd, EVENT_FD_READ|EVENT_FD_AUTOCLOSE,
+ fde = event_add_fd(ctdb->ev, state, state->syslog_fd, EVENT_FD_READ,
ctdb_syslog_handler, state);
+ tevent_fd_set_auto_close(fde);
event_loop_wait(ctdb->ev);
}
struct ctdb_log_state {
+ struct ctdb_context *ctdb;
int fd, pfd;
char buf[1024];
uint16_t buf_used;
bool use_syslog;
+ void (*logfn)(const char *, uint16_t, void *);
+ void *logfn_private;
};
/* we need this global to keep the DEBUG() syntax */
break;
}
- len = offsetof(struct syslog_message, message) + strlen(s) + 1;
+ len = offsetof(struct syslog_message, message) + strlen(debug_extra) + strlen(s) + 1;
msg = malloc(len);
if (msg == NULL) {
free(s);
return;
}
msg->level = level;
- msg->len = strlen(s);
- strcpy(msg->message, s);
+ msg->len = strlen(debug_extra) + strlen(s);
+ strcpy(msg->message, debug_extra);
+ strcat(msg->message, s);
if (syslogd_is_started == 0) {
syslog(msg->level, "%s", msg->message);
strftime(tbuf,sizeof(tbuf)-1,"%Y/%m/%d %H:%M:%S", tm);
- ret = asprintf(&s2, "%s.%06u [%5u]: %s",
- tbuf, (unsigned)t.tv_usec, (unsigned)getpid(), s);
+ ret = asprintf(&s2, "%s.%06u [%s%5u]: %s",
+ tbuf, (unsigned)t.tv_usec,
+ debug_extra, (unsigned)getpid(), s);
free(s);
if (ret == -1) {
const char *errstr = "asprintf failed\n";
abort();
}
+ ctdb->log->ctdb = ctdb;
log_state = ctdb->log;
if (use_syslog) {
return 0;
}
-
+/* Note that do_debug always uses the global log state. */
+static void write_to_log(struct ctdb_log_state *log,
+ const char *buf, unsigned int len)
+{
+ if (script_log_level <= LogLevel) {
+ do_debug("%*.*s\n", len, len, buf);
+ /* log it in the eventsystem as well */
+ if (log->logfn)
+ log->logfn(log->buf, len, log->logfn_private);
+ }
+}
/*
called when log data comes in from a child process
static void ctdb_log_handler(struct event_context *ev, struct fd_event *fde,
uint16_t flags, void *private)
{
- struct ctdb_context *ctdb = talloc_get_type(private, struct ctdb_context);
+ struct ctdb_log_state *log = talloc_get_type(private, struct ctdb_log_state);
char *p;
int n;
return;
}
- n = read(ctdb->log->pfd, &ctdb->log->buf[ctdb->log->buf_used],
- sizeof(ctdb->log->buf) - ctdb->log->buf_used);
+ n = read(log->pfd, &log->buf[log->buf_used],
+ sizeof(log->buf) - log->buf_used);
if (n > 0) {
- ctdb->log->buf_used += n;
+ log->buf_used += n;
+ } else if (n == 0) {
+ if (log != log_state) {
+ talloc_free(log);
+ }
+ return;
}
this_log_level = script_log_level;
- while (ctdb->log->buf_used > 0 &&
- (p = memchr(ctdb->log->buf, '\n', ctdb->log->buf_used)) != NULL) {
- int n1 = (p - ctdb->log->buf)+1;
+ while (log->buf_used > 0 &&
+ (p = memchr(log->buf, '\n', log->buf_used)) != NULL) {
+ int n1 = (p - log->buf)+1;
int n2 = n1 - 1;
/* swallow \r from child processes */
- if (n2 > 0 && ctdb->log->buf[n2-1] == '\r') {
+ if (n2 > 0 && log->buf[n2-1] == '\r') {
n2--;
}
- if (script_log_level <= LogLevel) {
- do_debug("%*.*s\n", n2, n2, ctdb->log->buf);
- /* log it in the eventsystem as well */
- ctdb_log_event_script_output(ctdb, ctdb->log->buf, n2);
- }
- memmove(ctdb->log->buf, p+1, sizeof(ctdb->log->buf) - n1);
- ctdb->log->buf_used -= n1;
+ write_to_log(log, log->buf, n2);
+ memmove(log->buf, p+1, sizeof(log->buf) - n1);
+ log->buf_used -= n1;
}
/* the buffer could have completely filled - unfortunately we have
no choice but to dump it out straight away */
- if (ctdb->log->buf_used == sizeof(ctdb->log->buf)) {
- if (script_log_level <= LogLevel) {
- do_debug("%*.*s\n",
- (int)ctdb->log->buf_used, (int)ctdb->log->buf_used, ctdb->log->buf);
- /* log it in the eventsystem as well */
- ctdb_log_event_script_output(ctdb, ctdb->log->buf, ctdb->log->buf_used);
- }
- ctdb->log->buf_used = 0;
+ if (log->buf_used == sizeof(log->buf)) {
+ write_to_log(log, log->buf, log->buf_used);
+ log->buf_used = 0;
+ }
+}
+
+static int log_context_destructor(struct ctdb_log_state *log)
+{
+ /* Flush buffer in case it wasn't \n-terminated. */
+ if (log->buf_used > 0) {
+ this_log_level = script_log_level;
+ write_to_log(log, log->buf, log->buf_used);
}
+ return 0;
}
+/*
+ fork(), redirecting child output to logging and specified callback.
+*/
+struct ctdb_log_state *ctdb_fork_with_logging(TALLOC_CTX *mem_ctx,
+ struct ctdb_context *ctdb,
+ void (*logfn)(const char *, uint16_t, void *),
+ void *logfn_private, pid_t *pid)
+{
+ int p[2];
+ struct ctdb_log_state *log;
+ struct tevent_fd *fde;
+
+ log = talloc_zero(mem_ctx, struct ctdb_log_state);
+ CTDB_NO_MEMORY_NULL(ctdb, log);
+ log->ctdb = ctdb;
+ log->logfn = logfn;
+ log->logfn_private = (void *)logfn_private;
+
+ if (pipe(p) != 0) {
+ DEBUG(DEBUG_ERR,(__location__ " Failed to setup for child logging pipe\n"));
+ goto free_log;
+ }
+
+ *pid = ctdb_fork(ctdb);
+ /* Child? */
+ if (*pid == 0) {
+ close(STDOUT_FILENO);
+ close(STDERR_FILENO);
+ dup2(p[1], STDOUT_FILENO);
+ dup2(p[1], STDERR_FILENO);
+ close(p[0]);
+ close(p[1]);
+ return log;
+ }
+ close(p[1]);
+
+ /* We failed? */
+ if (*pid < 0) {
+ DEBUG(DEBUG_ERR, (__location__ " fork failed for child process\n"));
+ close(p[0]);
+ goto free_log;
+ }
+
+ log->pfd = p[0];
+ set_close_on_exec(log->pfd);
+ talloc_set_destructor(log, log_context_destructor);
+ fde = event_add_fd(ctdb->ev, log, log->pfd,
+ EVENT_FD_READ, ctdb_log_handler, log);
+ tevent_fd_set_auto_close(fde);
+
+ return log;
+
+free_log:
+ talloc_free(log);
+ return NULL;
+}
/*
setup for logging of child process stdout
int ctdb_set_child_logging(struct ctdb_context *ctdb)
{
int p[2];
- int ret;
+ int old_stdout, old_stderr;
+ struct tevent_fd *fde;
- if (ctdb->log->fd == 1) {
+ if (ctdb->log->fd == STDOUT_FILENO) {
/* not needed for stdout logging */
return 0;
}
return -1;
}
- event_add_fd(ctdb->ev, ctdb, p[0], EVENT_FD_READ,
- ctdb_log_handler, ctdb);
+ /* We'll fail if stderr/stdout not already open; it's simpler. */
+ old_stdout = dup(STDOUT_FILENO);
+ old_stderr = dup(STDERR_FILENO);
+ if (dup2(p[1], STDOUT_FILENO) < 0 || dup2(p[1], STDERR_FILENO) < 0) {
+ int saved_errno = errno;
+ dup2(old_stdout, STDOUT_FILENO);
+ dup2(old_stderr, STDERR_FILENO);
+ close(old_stdout);
+ close(old_stderr);
+ close(p[0]);
+ close(p[1]);
+ errno = saved_errno;
+
+ printf(__location__ " dup2 failed: %s\n",
+ strerror(errno));
+ return -1;
+ }
+ close(p[1]);
+ close(old_stdout);
+ close(old_stderr);
+
+ /* Is this correct for STDOUT and STDERR ? */
+ set_close_on_exec(STDOUT_FILENO);
+ set_close_on_exec(STDERR_FILENO);
set_close_on_exec(p[0]);
+
+ fde = event_add_fd(ctdb->ev, ctdb->log, p[0],
+ EVENT_FD_READ, ctdb_log_handler, ctdb->log);
+ tevent_fd_set_auto_close(fde);
+
ctdb->log->pfd = p[0];
- DEBUG(DEBUG_NOTICE, (__location__ " Created PIPE FD:%d for logging\n", p[0]));
+ DEBUG(DEBUG_DEBUG, (__location__ " Created PIPE FD:%d for logging\n", p[0]));
- close(1);
- close(2);
- if (p[1] != 1) {
- ret = dup2(p[1], 1);
- if (ret == -1) {
- printf("dup2 failed: %s\n", strerror(errno));
- return -1;
- }
- close(p[1]);
- }
- /* also catch stderr of subcommands to the log */
- ret = dup2(1, 2);
- if (ret == -1) {
- printf("dup2 failed: %s\n", strerror(errno));
- return -1;
+ return 0;
+}
+
+
+/*
+ * set up a log handler to catch logging from TEVENT
+ */
+static void ctdb_tevent_logging(void *private_data,
+ enum tevent_debug_level level,
+ const char *fmt,
+ va_list ap)
+{
+ enum debug_level lvl = DEBUG_EMERG;
+
+ switch (level) {
+ case TEVENT_DEBUG_FATAL:
+ lvl = DEBUG_EMERG;
+ break;
+ case TEVENT_DEBUG_ERROR:
+ lvl = DEBUG_ERR;
+ break;
+ case TEVENT_DEBUG_WARNING:
+ lvl = DEBUG_WARNING;
+ break;
+ case TEVENT_DEBUG_TRACE:
+ lvl = DEBUG_DEBUG;
+ break;
}
- return 0;
+ if (lvl <= LogLevel) {
+ this_log_level = lvl;
+ do_debug_v(fmt, ap);
+ }
}
+int ctdb_init_tevent_logging(struct ctdb_context *ctdb)
+{
+ int ret;
+ ret = tevent_set_debug(ctdb->ev,
+ ctdb_tevent_logging,
+ ctdb);
+ return ret;
+}