* vim:ts=4:sw=4:expandtab
*
* i3 - an improved dynamic tiling window manager
- * © 2009-2011 Michael Stapelberg and contributors (see also: LICENSE)
+ * © 2009 Michael Stapelberg and contributors (see also: LICENSE)
*
* log.c: Logging functions.
*
*/
+#include <config.h>
+
#include <stdarg.h>
#include <stdio.h>
#include <string.h>
#include <sys/mman.h>
#include <sys/stat.h>
#include <errno.h>
-#if defined(__APPLE__)
-#include <sys/types.h>
-#include <sys/sysctl.h>
+#if !defined(__OpenBSD__)
+#include <pthread.h>
#endif
#include "util.h"
#include "libi3.h"
#include "shmlog.h"
+#if defined(__APPLE__)
+#include <sys/sysctl.h>
+#endif
+
static bool debug_logging = false;
static bool verbose = false;
static FILE *errorfile;
static char *logbuffer;
/* A pointer (within logbuffer) where data will be written to next. */
static char *logwalk;
+/* A pointer to the shmlog header */
+static i3_shmlog_header *header;
/* A pointer to the byte where we last wrapped. Necessary to not print the
* left-overs at the end of the ringbuffer. */
static char *loglastwrap;
static int logbuffer_size;
/* File descriptor for shm_open. */
static int logbuffer_shm;
+/* Size (in bytes) of physical memory */
+static long long physical_mem_bytes;
/*
* Writes the offsets for the next write and for the last wrap to the
*
*/
static void store_log_markers(void) {
- i3_shmlog_header *header = (i3_shmlog_header*)logbuffer;
-
header->offset_next_write = (logwalk - logbuffer);
header->offset_last_wrap = (loglastwrap - logbuffer);
header->size = logbuffer_size;
void init_logging(void) {
if (!errorfilename) {
if (!(errorfilename = get_process_filename("errorlog")))
- ELOG("Could not initialize errorlog\n");
+ fprintf(stderr, "Could not initialize errorlog\n");
else {
errorfile = fopen(errorfilename, "w");
- if (fcntl(fileno(errorfile), F_SETFD, FD_CLOEXEC)) {
- ELOG("Could not set close-on-exec flag\n");
+ if (!errorfile) {
+ fprintf(stderr, "Could not initialize errorlog on %s: %s\n",
+ errorfilename, strerror(errno));
+ } else {
+ if (fcntl(fileno(errorfile), F_SETFD, FD_CLOEXEC)) {
+ fprintf(stderr, "Could not set close-on-exec flag\n");
+ }
}
}
}
-
- /* If this is a debug build (not a release version), we will enable SHM
- * logging by default, unless the user turned it off explicitly. */
- if (logbuffer == NULL && shmlog_size > 0) {
- /* Reserve 1% of the RAM for the logfile, but at max 25 MiB.
- * For 512 MiB of RAM this will lead to a 5 MiB log buffer.
- * At the moment (2011-12-10), no testcase leads to an i3 log
- * of more than ~ 600 KiB. */
- long long physical_mem_bytes;
+ if (physical_mem_bytes == 0) {
#if defined(__APPLE__)
- int mib[2] = { CTL_HW, HW_MEMSIZE };
+ int mib[2] = {CTL_HW, HW_MEMSIZE};
size_t length = sizeof(long long);
sysctl(mib, 2, &physical_mem_bytes, &length, NULL, 0);
#else
physical_mem_bytes = (long long)sysconf(_SC_PHYS_PAGES) *
- sysconf(_SC_PAGESIZE);
+ sysconf(_SC_PAGESIZE);
#endif
- logbuffer_size = min(physical_mem_bytes * 0.01, shmlog_size);
- sasprintf(&shmlogname, "/i3-log-%d", getpid());
- logbuffer_shm = shm_open(shmlogname, O_RDWR | O_CREAT | O_TRUNC, S_IREAD | S_IWRITE);
- if (logbuffer_shm == -1) {
- ELOG("Could not shm_open SHM segment for the i3 log: %s\n", strerror(errno));
- return;
- }
+ }
+ /* Start SHM logging if shmlog_size is > 0. shmlog_size is SHMLOG_SIZE by
+ * default on development versions, and 0 on release versions. If it is
+ * not > 0, the user has turned it off, so let's close the logbuffer. */
+ if (shmlog_size > 0 && logbuffer == NULL)
+ open_logbuffer();
+ else if (shmlog_size <= 0 && logbuffer)
+ close_logbuffer();
+ atexit(purge_zerobyte_logfile);
+}
- if (ftruncate(logbuffer_shm, logbuffer_size) == -1) {
- close(logbuffer_shm);
- shm_unlink("/i3-log-");
- ELOG("Could not ftruncate SHM segment for the i3 log: %s\n", strerror(errno));
- return;
- }
+/*
+ * Opens the logbuffer.
+ *
+ */
+void open_logbuffer(void) {
+ /* Reserve 1% of the RAM for the logfile, but at max 25 MiB.
+ * For 512 MiB of RAM this will lead to a 5 MiB log buffer.
+ * At the moment (2011-12-10), no testcase leads to an i3 log
+ * of more than ~ 600 KiB. */
+ logbuffer_size = min(physical_mem_bytes * 0.01, shmlog_size);
+#if defined(__FreeBSD__)
+ sasprintf(&shmlogname, "/tmp/i3-log-%d", getpid());
+#else
+ sasprintf(&shmlogname, "/i3-log-%d", getpid());
+#endif
+ logbuffer_shm = shm_open(shmlogname, O_RDWR | O_CREAT, S_IREAD | S_IWRITE);
+ if (logbuffer_shm == -1) {
+ fprintf(stderr, "Could not shm_open SHM segment for the i3 log: %s\n", strerror(errno));
+ return;
+ }
- logbuffer = mmap(NULL, logbuffer_size, PROT_READ | PROT_WRITE, MAP_SHARED, logbuffer_shm, 0);
- if (logbuffer == MAP_FAILED) {
- close(logbuffer_shm);
- shm_unlink("/i3-log-");
- ELOG("Could not mmap SHM segment for the i3 log: %s\n", strerror(errno));
- logbuffer = NULL;
- return;
- }
- logwalk = logbuffer + sizeof(i3_shmlog_header);
- loglastwrap = logbuffer + logbuffer_size;
- store_log_markers();
+#if defined(__OpenBSD__) || defined(__APPLE__)
+ if (ftruncate(logbuffer_shm, logbuffer_size) == -1) {
+ fprintf(stderr, "Could not ftruncate SHM segment for the i3 log: %s\n", strerror(errno));
+#else
+ int ret;
+ if ((ret = posix_fallocate(logbuffer_shm, 0, logbuffer_size)) != 0) {
+ fprintf(stderr, "Could not ftruncate SHM segment for the i3 log: %s\n", strerror(ret));
+#endif
+ close(logbuffer_shm);
+ shm_unlink(shmlogname);
+ return;
}
+
+ logbuffer = mmap(NULL, logbuffer_size, PROT_READ | PROT_WRITE, MAP_SHARED, logbuffer_shm, 0);
+ if (logbuffer == MAP_FAILED) {
+ close_logbuffer();
+ fprintf(stderr, "Could not mmap SHM segment for the i3 log: %s\n", strerror(errno));
+ return;
+ }
+
+ /* Initialize with 0-bytes, just to be sure… */
+ memset(logbuffer, '\0', logbuffer_size);
+
+ header = (i3_shmlog_header *)logbuffer;
+
+#if !defined(__OpenBSD__)
+ pthread_condattr_t cond_attr;
+ pthread_condattr_init(&cond_attr);
+ if (pthread_condattr_setpshared(&cond_attr, PTHREAD_PROCESS_SHARED) != 0)
+ fprintf(stderr, "pthread_condattr_setpshared() failed, i3-dump-log -f will not work!\n");
+ pthread_cond_init(&(header->condvar), &cond_attr);
+#endif
+
+ logwalk = logbuffer + sizeof(i3_shmlog_header);
+ loglastwrap = logbuffer + logbuffer_size;
+ store_log_markers();
+}
+
+/*
+ * Closes the logbuffer.
+ *
+ */
+void close_logbuffer(void) {
+ close(logbuffer_shm);
+ shm_unlink(shmlogname);
+ free(shmlogname);
+ logbuffer = NULL;
+ shmlogname = "";
}
/*
verbose = _verbose;
}
+/*
+ * Get debug logging.
+ *
+ */
+bool get_debug_logging(void) {
+ return debug_logging;
+}
+
/*
* Set debug logging.
*
len += vsnprintf(message + len, sizeof(message) - len, fmt, args);
if (len >= sizeof(message)) {
fprintf(stderr, "BUG: single log message > 4k\n");
+
+ /* vsnprintf returns the number of bytes that *would have been written*,
+ * not the actual amount written. Thus, limit len to sizeof(message) to avoid
+ * memory corruption and outputting garbage later. */
+ len = sizeof(message);
+
+ /* Punch in a newline so the next log message is not dangling at
+ * the end of the truncated message. */
+ message[len - 2] = '\n';
}
- /* If there is no space for the current message (plus trailing
- * nullbyte) in the ringbuffer, we need to wrap and write to the
- * beginning again. */
- if ((len+1) >= (logbuffer_size - (logwalk - logbuffer))) {
+ /* If there is no space for the current message in the ringbuffer, we
+ * need to wrap and write to the beginning again. */
+ if (len >= (size_t)(logbuffer_size - (logwalk - logbuffer))) {
loglastwrap = logwalk;
logwalk = logbuffer + sizeof(i3_shmlog_header);
+ store_log_markers();
+ header->wrap_count++;
}
- /* Copy the buffer, terminate it, move the write pointer to the byte after
- * our current message. */
+ /* Copy the buffer, move the write pointer to the byte after our
+ * current message. */
strncpy(logwalk, message, len);
- logwalk[len] = '\0';
- logwalk += len + 1;
+ logwalk += len;
store_log_markers();
+#if !defined(__OpenBSD__)
+ /* Wake up all (i3-dump-log) processes waiting for condvar. */
+ pthread_cond_broadcast(&(header->condvar));
+#endif
+
if (print)
fwrite(message, len, 1, stdout);
}
vlog(debug_logging, fmt, args);
va_end(args);
}
+
+/*
+ * Deletes the unused log files. Useful if i3 exits immediately, eg.
+ * because --get-socketpath was called. We don't care for syscall
+ * failures. This function is invoked automatically when exiting.
+ */
+void purge_zerobyte_logfile(void) {
+ struct stat st;
+ char *slash;
+
+ if (!errorfilename)
+ return;
+
+ /* don't delete the log file if it contains something */
+ if ((stat(errorfilename, &st)) == -1 || st.st_size > 0)
+ return;
+
+ if (unlink(errorfilename) == -1)
+ return;
+
+ if ((slash = strrchr(errorfilename, '/')) != NULL) {
+ *slash = '\0';
+ /* possibly fails with ENOTEMPTY if there are files (or
+ * sockets) left. */
+ rmdir(errorfilename);
+ }
+}
projects / i3 / i3 / blobdiff