ascii-chat
Binary v0.16.50-198-g78f51665f
Library lib/v0.3.2-2240-g78f51665f
Video chat in your terminal
Loading...
Searching...
No Matches
mmap.c File Reference

Lock-free memory-mapped text logging implementation. More...

Go to the source code of this file.

Macros

#define LOG_MMAP_DIAGNOSTIC_BUFFER_SIZE   64

Functions

void log_mmap_install_crash_handlers (void)
 Install signal handlers for crash safety.
asciichat_error_t log_mmap_init (const log_mmap_config_t *config)
 Initialize mmap-based text logging.
asciichat_error_t log_mmap_init_simple (const char *log_path, size_t max_size)
 Initialize mmap logging with simple parameters.
void log_mmap_destroy (void)
 Shutdown mmap logging.
void log_mmap_write (int level, const char *file, int line, const char *func, const char *fmt,...)
 Write a log entry directly to the mmap'd file (lock-free).
bool log_mmap_is_active (void)
 Check if mmap logging is active.
void log_mmap_sync (void)
 Force sync the mmap'd file to disk.
void log_mmap_get_stats (uint64_t *bytes_written, uint64_t *wrap_count)
 Get statistics about the mmap log.
bool log_mmap_get_usage (size_t *used, size_t *capacity)
 Get current mmap log usage.
void log_mmap_rotate (void)
 Rotate the mmap log (tail-keeping rotation).

Detailed Description

Lock-free memory-mapped text logging implementation.

Writes human-readable log text directly to a memory-mapped file. On crash, the log file is immediately readable with cat/tail.

Definition in file mmap.c.

Macro Definition Documentation

◆ LOG_MMAP_DIAGNOSTIC_BUFFER_SIZE

#define LOG_MMAP_DIAGNOSTIC_BUFFER_SIZE   64

Definition at line 11 of file mmap.c.

Function Documentation

◆ log_mmap_destroy()

void log_mmap_destroy ( void )

Shutdown mmap logging.

Syncs and unmaps the log file.

Definition at line 263 of file mmap.c.

263 {
264 if (!g_mmap_log.initialized) {
265 return;
266 }
267
268 /* Write shutdown marker */
269 log_mmap_write(1 /* LOG_INFO */, NULL, 0, NULL, "=== Log ended ===");
270
271 /* Sync to disk */
272 platform_mmap_sync(&g_mmap_log.mmap, true);
273
274 /* Truncate file to actual content size to save space
275 * This converts the large mmap file (4MB with newlines) to just the actual log content */
276 uint64_t final_pos = atomic_load_u64(&g_mmap_log.write_pos);
277 if (final_pos < g_mmap_log.text_capacity && strlen(g_mmap_log.file_path) > 0) {
278#ifdef _WIN32
279 /* Windows: Close mmap first, then truncate file, then reopen for truncation */
280 platform_mmap_close(&g_mmap_log.mmap);
281 HANDLE hFile = CreateFileA(g_mmap_log.file_path, GENERIC_WRITE, 0, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);
282 if (hFile != INVALID_HANDLE_VALUE) {
283 LARGE_INTEGER size;
284 size.QuadPart = (LONGLONG)final_pos;
285 if (SetFilePointerEx(hFile, size, NULL, FILE_BEGIN)) {
286 SetEndOfFile(hFile);
287 }
288 CloseHandle(hFile);
289 log_debug("mmap log: truncated %s to %zu bytes (was %zu MB)", g_mmap_log.file_path, (size_t)final_pos, g_mmap_log.text_capacity / 1024 / 1024);
290 }
291#else
292 /* POSIX: Use ftruncate() on the file descriptor */
293 if (g_mmap_log.mmap.fd >= 0) {
294 if (ftruncate(g_mmap_log.mmap.fd, (off_t)final_pos) == 0) {
295 log_debug("mmap log: truncated %s to %zu bytes (was %zu MB)", g_mmap_log.file_path, (size_t)final_pos, g_mmap_log.text_capacity / 1024 / 1024);
296 }
297 }
298 platform_mmap_close(&g_mmap_log.mmap);
299#endif
300 } else {
301 /* No truncation needed or path not set */
302 platform_mmap_close(&g_mmap_log.mmap);
303 }
304
305 g_mmap_log.text_region = NULL;
306 g_mmap_log.file_path[0] = '\0';
307
308 g_mmap_log.initialized = false;
309 log_debug("mmap log: destroyed");
310}
uint64_t atomic_load_u64(atomic_t *a)
Atomically load a uint64_t value.
unsigned long long uint64_t
#define log_debug(...)
Log a DEBUG message.
Definition log/log.h:589
void log_mmap_write(int level, const char *file, int line, const char *func, const char *fmt,...)
Write a log entry directly to the mmap'd file (lock-free).
Definition mmap.c:312

References atomic_load_u64(), log_debug, and log_mmap_write().

Referenced by log_destroy(), log_disable_mmap(), and log_mmap_init().

◆ log_mmap_get_stats()

void log_mmap_get_stats ( uint64_t * bytes_written,
uint64_t * wrap_count )

Get statistics about the mmap log.

Parameters
[out]bytes_writtenTotal bytes written since init
[out]wrap_countNumber of times log has wrapped

Definition at line 399 of file mmap.c.

399 {
400 if (bytes_written) {
401 *bytes_written = atomic_load_u64(&g_mmap_log.bytes_written);
402 }
403 if (wrap_count) {
404 *wrap_count = atomic_load_u64(&g_mmap_log.wrap_count);
405 }
406}
atomic_t bytes_written
Definition mmap.c:45
atomic_t wrap_count
Definition mmap.c:46

References atomic_load_u64(), bytes_written, and wrap_count.

◆ log_mmap_get_usage()

bool log_mmap_get_usage ( size_t * used,
size_t * capacity )

Get current mmap log usage.

Parameters
[out]usedCurrent bytes used in the log
[out]capacityTotal capacity of the log
Returns
true if mmap is active and values are valid

Definition at line 408 of file mmap.c.

408 {
409 if (!g_mmap_log.initialized) {
410 return false;
411 }
412
413 if (used) {
414 *used = (size_t)atomic_load_u64(&g_mmap_log.write_pos);
415 }
416 if (capacity) {
417 *capacity = g_mmap_log.text_capacity;
418 }
419 return true;
420}

References atomic_load_u64().

◆ log_mmap_init()

asciichat_error_t log_mmap_init ( const log_mmap_config_t * config)

Initialize mmap-based text logging.

Creates or opens a memory-mapped log file. Text is written directly to the file, so it's readable even after a crash.

Parameters
configConfiguration options
Returns
ASCIICHAT_OK on success, error code on failure

Definition at line 194 of file mmap.c.

194 {
195 if (!config || !config->log_path) {
196 return SET_ERRNO(ERROR_INVALID_PARAM, "mmap log: config or log_path is NULL");
197 }
198
199 if (g_mmap_log.initialized) {
200 log_warn("mmap log: already initialized, destroying first");
202 }
203
204 /* Determine file size */
205 size_t file_size = config->max_size > 0 ? config->max_size : LOG_MMAP_DEFAULT_SIZE;
206 if (file_size < 1024) {
207 file_size = 1024; /* Minimum reasonable size */
208 }
209
210 /* Store file path for later truncation */
211 SAFE_STRNCPY(g_mmap_log.file_path, config->log_path, sizeof(g_mmap_log.file_path) - 1);
212
213 /* Open mmap file */
214 platform_mmap_init(&g_mmap_log.mmap);
215 asciichat_error_t result = platform_mmap_open("mmap_log_file", config->log_path, file_size, &g_mmap_log.mmap);
216 if (result != ASCIICHAT_OK) {
217 return result;
218 }
219
220 /* Entire file is text - no header */
221 g_mmap_log.text_region = (char *)g_mmap_log.mmap.addr;
222 g_mmap_log.text_capacity = file_size;
223
224 /* Find where existing content ends (scan for last newline before spaces/nulls) */
225 size_t existing_pos = find_content_end(g_mmap_log.text_region, file_size);
226 atomic_store_u64(&g_mmap_log.write_pos, existing_pos);
227
228 /* Clear unused portion with newlines (grep-friendly without needing -a flag)
229 * We truncate the file on clean shutdown to save space */
230 if (existing_pos < file_size) {
231 memset(g_mmap_log.text_region + existing_pos, '\n', file_size - existing_pos);
232 }
233
234 if (existing_pos > 0) {
235 log_info("mmap log: resumed existing log at position %zu", existing_pos);
236 } else {
237 log_info("mmap log: created new log file %s (%zu bytes)", config->log_path, file_size);
238 }
239
240 /* Reset statistics */
241 atomic_store_u64(&g_mmap_log.bytes_written, 0);
242 atomic_store_u64(&g_mmap_log.wrap_count, 0);
243
244 /* Install crash handlers */
246
247 g_mmap_log.initialized = true;
248
249 /* Write startup marker */
250 log_mmap_write(1 /* LOG_INFO */, NULL, 0, NULL, "=== Log started (mmap text mode, %zu bytes) ===", file_size);
251
252 return ASCIICHAT_OK;
253}
#define SET_ERRNO(code,...)
void atomic_store_u64(atomic_t *a, uint64_t value)
Atomically store a uint64_t value.
#define SAFE_STRNCPY(dst, src, size)
asciichat_error_t
Error and exit codes - unified status values (0-255).
Definition error_codes.h:48
@ ASCIICHAT_OK
Definition error_codes.h:50
@ ERROR_INVALID_PARAM
#define log_warn(...)
Log a WARN message.
Definition log/log.h:615
#define log_info(...)
Log an INFO message.
Definition log/log.h:602
void log_mmap_install_crash_handlers(void)
Install signal handlers for crash safety.
Definition mmap.c:147
void log_mmap_destroy(void)
Shutdown mmap logging.
Definition mmap.c:263
#define LOG_MMAP_DEFAULT_SIZE
Default mmap log file size (4MB).
Definition mmap.h:46
size_t max_size
Definition mmap.h:58
const char * log_path
Definition mmap.h:57

References ASCIICHAT_OK, atomic_store_u64(), ERROR_INVALID_PARAM, log_info, LOG_MMAP_DEFAULT_SIZE, log_mmap_destroy(), log_mmap_install_crash_handlers(), log_mmap_write(), log_mmap_config::log_path, log_warn, log_mmap_config::max_size, SAFE_STRNCPY, and SET_ERRNO.

Referenced by log_mmap_init_simple().

◆ log_mmap_init_simple()

asciichat_error_t log_mmap_init_simple ( const char * log_path,
size_t max_size )

Initialize mmap logging with simple parameters.

Convenience wrapper around log_mmap_init().

Parameters
log_pathPath to log file
max_sizeMaximum file size (0 = default 4MB)
Returns
ASCIICHAT_OK on success, error code on failure

Definition at line 255 of file mmap.c.

255 {
256 log_mmap_config_t config = {
257 .log_path = log_path,
258 .max_size = max_size,
259 };
260 return log_mmap_init(&config);
261}
struct log_mmap_config log_mmap_config_t
Definition log/log.h:902
asciichat_error_t log_mmap_init(const log_mmap_config_t *config)
Initialize mmap-based text logging.
Definition mmap.c:194

References log_mmap_init().

Referenced by log_enable_mmap_sized(), and log_init().

◆ log_mmap_install_crash_handlers()

void log_mmap_install_crash_handlers ( void )

Install signal handlers for crash safety.

Registers handlers for SIGSEGV, SIGABRT, etc. that sync the mmap before the process terminates.

Note
Signal handlers are automatically installed by log_mmap_init().

Definition at line 147 of file mmap.c.

147 {
148#ifndef _WIN32
149 struct sigaction sa = {0};
150 sa.sa_handler = crash_signal_handler;
151 sigemptyset(&sa.sa_mask);
152 sa.sa_flags = (int)SA_RESETHAND; /* One-shot */
153
154 sigaction(SIGSEGV, &sa, NULL);
155 sigaction(SIGABRT, &sa, NULL);
156 sigaction(SIGBUS, &sa, NULL);
157 sigaction(SIGFPE, &sa, NULL);
158 sigaction(SIGILL, &sa, NULL);
159#else
160 SetUnhandledExceptionFilter(windows_crash_handler);
161#endif
162}

Referenced by log_mmap_init().

◆ log_mmap_is_active()

bool log_mmap_is_active ( void )

Check if mmap logging is active.

Returns
true if mmap logging is initialized and active

Definition at line 389 of file mmap.c.

389 {
390 return g_mmap_log.initialized;
391}

Referenced by log_destroy(), log_disable_mmap(), log_file_msg(), log_msg(), and log_plain_msg().

◆ log_mmap_rotate()

void log_mmap_rotate ( void )

Rotate the mmap log (tail-keeping rotation).

Keeps the most recent log entries (tail) and discards old ones. This is the mmap equivalent of file-based log rotation.

Note
Caller must hold the rotation mutex from logging.c. This is called by maybe_rotate_log() which handles locking.

Definition at line 422 of file mmap.c.

422 {
423 if (!g_mmap_log.initialized || !g_mmap_log.text_region) {
424 return;
425 }
426
427 /* NOTE: Caller must hold the rotation mutex from logging.c */
428
429 uint64_t current_pos = atomic_load_u64(&g_mmap_log.write_pos);
430 size_t capacity = g_mmap_log.text_capacity;
431
432 /* Keep last 2/3 of the log (same ratio as file rotation) */
433 size_t keep_size = capacity * 2 / 3;
434 if (current_pos <= keep_size) {
435 return;
436 }
437
438 /* Find where to start keeping (skip to beginning of current_pos - keep_size) */
439 size_t skip_bytes = (size_t)current_pos - keep_size;
440 char *keep_start = g_mmap_log.text_region + skip_bytes;
441
442 /* Skip to next line boundary to avoid partial lines */
443 size_t skipped = 0;
444 while (skipped < keep_size && *keep_start != '\n') {
445 keep_start++;
446 skipped++;
447 }
448 if (skipped < keep_size && *keep_start == '\n') {
449 keep_start++;
450 skipped++;
451 }
452
453 size_t actual_keep = keep_size - skipped;
454 if (actual_keep == 0) {
455 /* Nothing to keep - just reset */
456 atomic_store_u64(&g_mmap_log.write_pos, 0);
457 memset(g_mmap_log.text_region, '\n', capacity);
458 return;
459 }
460
461 /* Move the tail to the beginning using memmove (handles overlap) */
462 memmove(g_mmap_log.text_region, keep_start, actual_keep);
463
464 /* Clear the rest with newlines (grep-friendly without needing -a flag) */
465 memset(g_mmap_log.text_region + actual_keep, '\n', capacity - actual_keep);
466
467 /* Update write position */
468 atomic_store_u64(&g_mmap_log.write_pos, actual_keep);
469
470 /* Write rotation marker */
471 const char *rotate_msg = "\n=== LOG ROTATED ===\n";
472 size_t rotate_len = strlen(rotate_msg);
473 if (actual_keep + rotate_len < capacity) {
474 memcpy(g_mmap_log.text_region + actual_keep, rotate_msg, rotate_len);
475 atomic_store_u64(&g_mmap_log.write_pos, actual_keep + rotate_len);
476 }
477
478 atomic_fetch_add_u64(&g_mmap_log.wrap_count, 1);
479
480 /* Sync after rotation */
481 platform_mmap_sync(&g_mmap_log.mmap, true);
482}
uint64_t atomic_fetch_add_u64(atomic_t *a, uint64_t delta)
Atomically add to a uint64_t and return the previous value.

References atomic_fetch_add_u64(), atomic_load_u64(), and atomic_store_u64().

◆ log_mmap_sync()

void log_mmap_sync ( void )

Force sync the mmap'd file to disk.

Ensures all written data is flushed to the underlying file. Called automatically for ERROR/FATAL levels and on shutdown.

Definition at line 393 of file mmap.c.

393 {
394 if (g_mmap_log.initialized) {
395 platform_mmap_sync(&g_mmap_log.mmap, true);
396 }
397}

◆ log_mmap_write()

void log_mmap_write ( int level,
const char * file,
int line,
const char * func,
const char * fmt,
... )

Write a log entry directly to the mmap'd file (lock-free).

Formats the log message and writes it directly as human-readable text. Uses atomic operations only, no mutex.

Parameters
levelLog level
fileSource file (can be NULL)
lineSource line
funcFunction name (can be NULL)
fmtFormat string
...Format arguments

Definition at line 312 of file mmap.c.

312 {
313 if (!g_mmap_log.initialized || !g_mmap_log.text_region) {
314 return;
315 }
316
317 static const char *level_names[] = {"DEV", "DEBUG", "INFO", "WARN", "ERROR", "FATAL"};
318 const char *level_name = (level >= 0 && level < 6) ? level_names[level] : "???";
319
320 /* Format the complete log line into a local buffer first */
321 char line_buf[LOG_MMAP_MSG_BUFFER_SIZE];
322 char time_buf[LOG_TIMESTAMP_BUFFER_SIZE];
323 format_timestamp(time_buf, sizeof(time_buf));
324
325 int prefix_len;
326 if (file && func) {
327 prefix_len = safe_snprintf(line_buf, sizeof(line_buf), "[%s] [%s] %s:%d in %s(): ", time_buf, level_name, file, line, func);
328 } else {
329 prefix_len = safe_snprintf(line_buf, sizeof(line_buf), "[%s] [%s] ", time_buf, level_name);
330 }
331
332 if (prefix_len < 0) {
333 return;
334 }
335
336 /* Format the message */
337 va_list args;
338 va_start(args, fmt);
339 int msg_len = safe_vsnprintf(line_buf + prefix_len, sizeof(line_buf) - (size_t)prefix_len - 1, fmt, args);
340 va_end(args);
341
342 if (msg_len < 0) {
343 return;
344 }
345
346 /* Add newline */
347 size_t total_len = (size_t)prefix_len + (size_t)msg_len;
348 if (total_len >= sizeof(line_buf) - 1) {
349 total_len = sizeof(line_buf) - 2; /* Truncate if too long */
350 }
351 line_buf[total_len] = '\n';
352 total_len++;
353 line_buf[total_len] = '\0';
354
355 /* Strip ANSI escape codes from the log message before writing to file */
356 char *stripped = ansi_strip_escapes(line_buf, total_len);
357 const char *write_buf = stripped ? stripped : line_buf;
358 size_t write_len = stripped ? strlen(stripped) : total_len;
359
360 /* Atomically claim space in the mmap'd region */
361 uint64_t pos = atomic_fetch_add_u64(&g_mmap_log.write_pos, write_len);
362
363 /* Check if we exceeded capacity - drop this message if so */
364 /* Rotation is handled by maybe_rotate_log() called from logging.c */
365 if (pos + write_len > g_mmap_log.text_capacity) {
366 /* Undo our claim - we can't fit */
367 atomic_fetch_sub_u64(&g_mmap_log.write_pos, write_len);
368 if (stripped) {
369 SAFE_FREE(stripped);
370 }
371 return;
372 }
373
374 /* Copy formatted text to mmap'd region */
375 memcpy(g_mmap_log.text_region + pos, write_buf, write_len);
376
377 atomic_fetch_add_u64(&g_mmap_log.bytes_written, write_len);
378
379 if (stripped) {
380 SAFE_FREE(stripped);
381 }
382
383 /* Sync for ERROR/FATAL to ensure visibility on crash */
384 if (level >= 4 /* LOG_ERROR */) {
385 platform_mmap_sync(&g_mmap_log.mmap, false);
386 }
387}
uint64_t atomic_fetch_sub_u64(atomic_t *a, uint64_t delta)
Atomically subtract from a uint64_t and return the previous value.
char * ansi_strip_escapes(const char *input, size_t input_len)
When code needs to work with rgb error, it keeps r, g, b here instead of scattering it across globals...
Definition ansi.c:27
#define SAFE_FREE(ptr)
#define LOG_TIMESTAMP_BUFFER_SIZE
Maximum size of a timestamp string.
Definition log/log.h:100
#define LOG_MMAP_MSG_BUFFER_SIZE
Maximum size of a log message in mmap mode.
Definition log/log.h:94
action_args_t args

References ansi_strip_escapes(), args, atomic_fetch_add_u64(), atomic_fetch_sub_u64(), LOG_MMAP_MSG_BUFFER_SIZE, LOG_TIMESTAMP_BUFFER_SIZE, and SAFE_FREE.

Referenced by log_file_msg(), log_mmap_destroy(), log_mmap_init(), log_msg(), and log_plain_msg().

Variable Documentation

◆ bytes_written

◆ file_path

◆ initialized

bool initialized

Definition at line 41 of file mmap.c.

Referenced by registry_init_from_builders(), and test_get_binary_path().

◆ mmap

platform_mmap_t mmap

Definition at line 37 of file mmap.c.

◆ text_capacity

size_t text_capacity

Definition at line 39 of file mmap.c.

◆ text_region

char* text_region

Definition at line 38 of file mmap.c.

◆ wrap_count

atomic_t wrap_count

Definition at line 46 of file mmap.c.

Referenced by log_mmap_get_stats().

◆ write_pos

atomic_t write_pos

Definition at line 40 of file mmap.c.

Referenced by session_log_buffer_get_recent().