171 lines
3.3 KiB
C
171 lines
3.3 KiB
C
/* SPDX-License-Identifier: MIT
|
|
*
|
|
* Copyright © 2018-2019 WireGuard LLC. All Rights Reserved.
|
|
*/
|
|
|
|
#include <string.h>
|
|
#include <stdio.h>
|
|
#include <stdint.h>
|
|
#include <stdlib.h>
|
|
#include <stdatomic.h>
|
|
#include <stdbool.h>
|
|
#include <time.h>
|
|
#include <errno.h>
|
|
#include <unistd.h>
|
|
#include <fcntl.h>
|
|
#include <sys/types.h>
|
|
#include <sys/stat.h>
|
|
#include <sys/time.h>
|
|
#include <sys/mman.h>
|
|
#include "ringlogger.h"
|
|
|
|
enum {
|
|
MAX_LOG_LINE_LENGTH = 512,
|
|
MAX_LINES = 2048,
|
|
MAGIC = 0xabadbeefU
|
|
};
|
|
|
|
struct log_line {
|
|
atomic_uint_fast64_t time_ns;
|
|
char line[MAX_LOG_LINE_LENGTH];
|
|
};
|
|
|
|
struct log {
|
|
atomic_uint_fast32_t next_index;
|
|
struct log_line lines[MAX_LINES];
|
|
uint32_t magic;
|
|
};
|
|
|
|
void write_msg_to_log(struct log *log, const char *tag, const char *msg)
|
|
{
|
|
uint32_t index;
|
|
struct log_line *line;
|
|
struct timespec ts;
|
|
|
|
clock_gettime(CLOCK_REALTIME, &ts);
|
|
|
|
index = atomic_fetch_add(&log->next_index, 1);
|
|
line = &log->lines[index % MAX_LINES];
|
|
|
|
atomic_store(&line->time_ns, 0);
|
|
memset(line->line, 0, MAX_LOG_LINE_LENGTH);
|
|
|
|
snprintf(line->line, MAX_LOG_LINE_LENGTH, "[%s] %s", tag, msg);
|
|
atomic_store(&line->time_ns, ts.tv_sec * 1000000000ULL + ts.tv_nsec);
|
|
|
|
msync(&log->next_index, sizeof(log->next_index), MS_ASYNC);
|
|
msync(line, sizeof(*line), MS_ASYNC);
|
|
}
|
|
|
|
int write_log_to_file(const char *file_name, const struct log *input_log)
|
|
{
|
|
struct log *log;
|
|
uint32_t l, i;
|
|
FILE *file;
|
|
int ret;
|
|
|
|
log = malloc(sizeof(*log));
|
|
if (!log)
|
|
return -errno;
|
|
memcpy(log, input_log, sizeof(*log));
|
|
|
|
file = fopen(file_name, "w");
|
|
if (!file) {
|
|
free(log);
|
|
return -errno;
|
|
}
|
|
|
|
for (l = 0, i = log->next_index; l < MAX_LINES; ++l, ++i) {
|
|
const struct log_line *line = &log->lines[i % MAX_LINES];
|
|
time_t seconds = line->time_ns / 1000000000ULL;
|
|
uint32_t useconds = (line->time_ns % 1000000000ULL) / 1000ULL;
|
|
struct tm tm;
|
|
|
|
if (!line->time_ns)
|
|
continue;
|
|
|
|
if (!localtime_r(&seconds, &tm))
|
|
goto err;
|
|
|
|
if (fprintf(file, "%04d-%02d-%02d %02d:%02d:%02d.%06d: %s\n",
|
|
tm.tm_year + 1900, tm.tm_mon + 1, tm.tm_mday,
|
|
tm.tm_hour, tm.tm_min, tm.tm_sec, useconds,
|
|
line->line) < 0)
|
|
goto err;
|
|
|
|
|
|
}
|
|
errno = 0;
|
|
|
|
err:
|
|
ret = -errno;
|
|
fclose(file);
|
|
free(log);
|
|
return ret;
|
|
}
|
|
|
|
uint32_t view_lines_from_cursor(const struct log *input_log, uint32_t cursor, void(*cb)(const char *, uint64_t))
|
|
{
|
|
struct log *log;
|
|
uint32_t l, i = cursor;
|
|
|
|
log = malloc(sizeof(*log));
|
|
if (!log)
|
|
return cursor;
|
|
memcpy(log, input_log, sizeof(*log));
|
|
|
|
if (i == -1)
|
|
i = log->next_index;
|
|
|
|
for (l = 0; l < MAX_LINES; ++l, ++i) {
|
|
const struct log_line *line = &log->lines[i % MAX_LINES];
|
|
|
|
if (cursor != -1 && i % MAX_LINES == log->next_index % MAX_LINES)
|
|
break;
|
|
|
|
if (!line->time_ns) {
|
|
if (cursor == -1)
|
|
continue;
|
|
else
|
|
break;
|
|
}
|
|
cb(line->line, line->time_ns);
|
|
cursor = (i + 1) % MAX_LINES;
|
|
}
|
|
free(log);
|
|
return cursor;
|
|
}
|
|
|
|
struct log *open_log(const char *file_name)
|
|
{
|
|
int fd;
|
|
struct log *log;
|
|
|
|
fd = open(file_name, O_RDWR | O_CREAT, S_IRUSR | S_IWUSR);
|
|
if (fd < 0)
|
|
return NULL;
|
|
if (ftruncate(fd, sizeof(*log)))
|
|
goto err;
|
|
log = mmap(NULL, sizeof(*log), PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0);
|
|
if (log == MAP_FAILED)
|
|
goto err;
|
|
close(fd);
|
|
|
|
if (log->magic != MAGIC) {
|
|
memset(log, 0, sizeof(*log));
|
|
log->magic = MAGIC;
|
|
msync(log, sizeof(*log), MS_ASYNC);
|
|
}
|
|
|
|
return log;
|
|
|
|
err:
|
|
close(fd);
|
|
return NULL;
|
|
}
|
|
|
|
void close_log(struct log *log)
|
|
{
|
|
munmap(log, sizeof(*log));
|
|
}
|