X-Git-Url: https://git.sur5r.net/?a=blobdiff_plain;f=src%2Flog.c;h=916085f456a8d8c1a95dbfca8c13d3d5b038db12;hb=HEAD;hp=d424ffd3261b0c97bdf824c49249e993ccc12275;hpb=7eacf8dd049dd2e92ae4e5e92f12f148290e81fa;p=i3%2Fi3 diff --git a/src/log.c b/src/log.c index d424ffd3..916085f4 100644 --- a/src/log.c +++ b/src/log.c @@ -2,45 +2,191 @@ * vim:ts=4:sw=4:expandtab * * i3 - an improved dynamic tiling window manager + * © 2009 Michael Stapelberg and contributors (see also: LICENSE) * - * © 2009-2010 Michael Stapelberg and contributors - * - * See file LICENSE for license information. - * - * src/log.c: handles the setting of loglevels, contains the logging functions. + * log.c: Logging functions. * */ +#include + #include #include #include #include #include #include +#include +#include +#include +#include +#include +#if !defined(__OpenBSD__) +#include +#endif #include "util.h" #include "log.h" +#include "i3.h" +#include "libi3.h" +#include "shmlog.h" -/* loglevels.h is autogenerated at make time */ -#include "loglevels.h" +#if defined(__APPLE__) +#include +#endif -static uint64_t loglevel = 0; +static bool debug_logging = false; static bool verbose = false; static FILE *errorfile; char *errorfilename; +/* SHM logging variables */ + +/* The name for the SHM (/i3-log-%pid). Will end up on /dev/shm on most + * systems. Global so that we can clean up at exit. */ +char *shmlogname = ""; +/* Size limit for the SHM log, by default 25 MiB. Can be overwritten using the + * flag --shmlog-size. */ +int shmlog_size = 0; +/* If enabled, logbuffer will point to a memory mapping of the i3 SHM log. */ +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; +/* Size (in bytes) of the i3 SHM log. */ +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 + * shmlog_header. + * Necessary to print the i3 SHM log in the correct order. + * + */ +static void store_log_markers(void) { + header->offset_next_write = (logwalk - logbuffer); + header->offset_last_wrap = (loglastwrap - logbuffer); + header->size = logbuffer_size; +} + /* * Initializes logging by creating an error logfile in /tmp (or * XDG_RUNTIME_DIR, see get_process_filename()). * + * Will be called twice if --shmlog-size is specified. + * + */ +void init_logging(void) { + if (!errorfilename) { + if (!(errorfilename = get_process_filename("errorlog"))) + fprintf(stderr, "Could not initialize errorlog\n"); + else { + errorfile = fopen(errorfilename, "w"); + 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 (physical_mem_bytes == 0) { +#if defined(__APPLE__) + 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); +#endif + } + /* 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); +} + +/* + * Opens the logbuffer. + * */ -void init_logging() { - errorfilename = get_process_filename("errorlog"); - if (errorfilename == NULL) { - ELOG("Could not initialize errorlog\n"); +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; + } + +#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; } - errorfile = fopen(errorfilename, "w"); + /* 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 = ""; } /* @@ -54,50 +200,100 @@ void set_verbosity(bool _verbose) { } /* - * Enables the given loglevel. + * Get debug logging. * */ -void add_loglevel(const char *level) { - /* Handle the special loglevel "all" */ - if (strcasecmp(level, "all") == 0) { - loglevel = UINT64_MAX; - return; - } - - for (int i = 0; i < sizeof(loglevels) / sizeof(char*); i++) { - if (strcasecmp(loglevels[i], level) != 0) - continue; +bool get_debug_logging(void) { + return debug_logging; +} - /* The position in the array (plus one) is the amount of times - * which we need to shift 1 to the left to get our bitmask for - * the specific loglevel. */ - loglevel |= (1 << (i+1)); - break; - } +/* + * Set debug logging. + * + */ +void set_debug_logging(const bool _debug_logging) { + debug_logging = _debug_logging; } /* - * Logs the given message to stdout while prefixing the current time to it. + * Logs the given message to stdout (if print is true) while prefixing the + * current time to it. Additionally, the message will be saved in the i3 SHM + * log if enabled. * This is to be called by *LOG() which includes filename/linenumber/function. * */ -void vlog(char *fmt, va_list args) { - char timebuf[64]; +static void vlog(const bool print, const char *fmt, va_list args) { + /* Precisely one page to not consume too much memory but to hold enough + * data to be useful. */ + static char message[4096]; + static struct tm result; + static time_t t; + static struct tm *tmp; + static size_t len; /* Get current time */ - time_t t = time(NULL); + t = time(NULL); /* Convert time to local time (determined by the locale) */ - struct tm *tmp = localtime(&t); + tmp = localtime_r(&t, &result); /* Generate time prefix */ - strftime(timebuf, sizeof(timebuf), "%x %X - ", tmp); + len = strftime(message, sizeof(message), "%x %X - ", tmp); + + /* + * logbuffer print + * ---------------- + * true true format message, save, print + * true false format message, save + * false true print message only + * false false INVALID, never called + */ + if (!logbuffer) { #ifdef DEBUG_TIMING - struct timeval tv; - gettimeofday(&tv, NULL); - printf("%s%d.%d - ", timebuf, tv.tv_sec, tv.tv_usec); + struct timeval tv; + gettimeofday(&tv, NULL); + printf("%s%d.%d - ", message, tv.tv_sec, tv.tv_usec); #else - printf("%s", timebuf); + printf("%s", message); +#endif + vprintf(fmt, args); + } else { + 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 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, move the write pointer to the byte after our + * current message. */ + strncpy(logwalk, message, len); + logwalk += len; + + store_log_markers(); + +#if !defined(__OpenBSD__) + /* Wake up all (i3-dump-log) processes waiting for condvar. */ + pthread_cond_broadcast(&(header->condvar)); #endif - vprintf(fmt, args); + + if (print) + fwrite(message, len, 1, stdout); + } } /* @@ -108,11 +304,11 @@ void vlog(char *fmt, va_list args) { void verboselog(char *fmt, ...) { va_list args; - if (!verbose) + if (!logbuffer && !verbose) return; va_start(args, fmt); - vlog(fmt, args); + vlog(verbose, fmt, args); va_end(args); } @@ -124,7 +320,7 @@ void errorlog(char *fmt, ...) { va_list args; va_start(args, fmt); - vlog(fmt, args); + vlog(true, fmt, args); va_end(args); /* also log to the error logfile, if opened */ @@ -136,17 +332,44 @@ void errorlog(char *fmt, ...) { /* * Logs the given message to stdout while prefixing the current time to it, - * but only if the corresponding debug loglevel was activated. + * but only if debug logging was activated. * This is to be called by DLOG() which includes filename/linenumber * */ -void debuglog(uint64_t lev, char *fmt, ...) { +void debuglog(char *fmt, ...) { va_list args; - if ((loglevel & lev) == 0) + if (!logbuffer && !(debug_logging)) return; va_start(args, fmt); - vlog(fmt, args); + 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); + } +}