ascii-chat
Binary v0.16.50-198-g78f51665f
Library lib/v0.3.2-2240-g78f51665f
Video chat in your terminal
Loading...
Searching...
No Matches
session_log_buffer.c
Go to the documentation of this file.
1
5
7#include <libplatform/compiler.h>
8#include <libplatform/system.h>
9#include <libplatform/terminal.h>
11#include <ascii-chat/common.h>
12#include <string.h>
13#include <libplatform/atomic.h>
14
30
33 if (!buf) {
34 return NULL;
35 }
36
38 atomic_store_u64(&buf->sequence, 0);
39 mutex_init(&buf->mutex, "log_buffer");
40
41 return buf;
42}
43
45 if (!buf) {
46 return;
47 }
48
49 mutex_destroy(&buf->mutex);
50 SAFE_FREE(buf);
51}
52
54 if (!buf) {
55 return;
56 }
57
58 mutex_lock(&buf->mutex);
59
60 // Reset write position and sequence
62 atomic_store_u64(&buf->sequence, 0);
63
64 // Clear all entries
65 for (size_t i = 0; i < SESSION_LOG_BUFFER_SIZE; i++) {
66 buf->entries[i].message[0] = '\0';
67 buf->entries[i].sequence = 0;
68 }
69
70 mutex_unlock(&buf->mutex);
71}
72
73void session_log_buffer_append(session_log_buffer_t *buf, const char *message) {
74 if (!buf || !message) {
75 // Fail silently - this is called FROM the logging system
76 // Using SET_ERRNO here would cause infinite recursion
77 return;
78 }
79
80 mutex_lock(&buf->mutex);
81
82 // Keep every line of multiline notices and split long lines at UTF-8 boundaries.
83 // Hold the lock for the entire message so concurrent producers cannot interleave it.
84 do {
85 const char *newline = strchr(message, '\n');
86 size_t length = newline ? (size_t)(newline - message) : strlen(message);
87 if (length >= SESSION_LOG_LINE_MAX) {
88 length = SESSION_LOG_LINE_MAX - 1;
89 while (length && ((unsigned char)message[length] & 0xc0) == 0x80)
90 --length;
91 if (!length)
92 length = SESSION_LOG_LINE_MAX - 1; // Malformed UTF-8 must still make progress.
93 }
94 size_t pos = atomic_load_u64(&buf->write_pos);
95 memcpy(buf->entries[pos].message, message, length);
96 buf->entries[pos].message[length] = '\0';
97 buf->entries[pos].sequence = atomic_fetch_add_u64(&buf->sequence, 1) + 1;
99 message += length;
100 if (*message == '\n')
101 ++message;
102 } while (*message);
103
104 mutex_unlock(&buf->mutex);
105}
106
107size_t session_log_buffer_get_recent(session_log_buffer_t *buf, session_log_entry_t *out_entries, size_t max_count) {
108 if (!buf || !out_entries || max_count == 0) {
109 // Fail silently - called from display code that handles 0 gracefully
110 // Using SET_ERRNO here could cause recursion if error logging is enabled
111 return 0;
112 }
113
114 mutex_lock(&buf->mutex);
115
116 size_t write_pos = atomic_load_u64(&buf->write_pos);
117 uint64_t total_entries = atomic_load_u64(&buf->sequence);
118
119 size_t entries_to_check = total_entries < SESSION_LOG_BUFFER_SIZE ? (size_t)total_entries : SESSION_LOG_BUFFER_SIZE;
120 if (entries_to_check > max_count)
121 entries_to_check = max_count;
122 size_t start_pos = (write_pos + SESSION_LOG_BUFFER_SIZE - entries_to_check) % SESSION_LOG_BUFFER_SIZE;
123
124 size_t count = 0;
125 for (size_t i = 0; i < entries_to_check && count < max_count; i++) {
126 size_t idx = (start_pos + i) % SESSION_LOG_BUFFER_SIZE;
127 if (buf->entries[idx].sequence > 0) {
128 memcpy(&out_entries[count], &buf->entries[idx], sizeof(session_log_entry_t));
129 count++;
130 }
131 }
132
133 mutex_unlock(&buf->mutex);
134 return count;
135}
uint64_t atomic_fetch_add_u64(atomic_t *a, uint64_t delta)
Atomically add to a uint64_t and return the previous value.
void atomic_store_u64(atomic_t *a, uint64_t value)
Atomically store a uint64_t value.
uint64_t atomic_load_u64(atomic_t *a)
Atomically load a uint64_t value.
#define SAFE_FREE(ptr)
#define SAFE_CALLOC(count, size, cast)
unsigned long long uint64_t
struct session_log_buffer session_log_buffer_t
Thread-safe fixed-size history ring for session-screen log lines.
⚙️ Common definitions, error codes, macros, and types shared throughout the application
atomic_t write_pos
Definition mmap.c:40
session_log_buffer_t * session_log_buffer_create(void)
Create a new session log buffer instance.
void session_log_buffer_clear(session_log_buffer_t *buf)
Clear all log entries from buffer.
void session_log_buffer_append(session_log_buffer_t *buf, const char *message)
Append a log message to the buffer.
size_t session_log_buffer_get_recent(session_log_buffer_t *buf, session_log_entry_t *out_entries, size_t max_count)
Get recent log entries from buffer.
void session_log_buffer_destroy(session_log_buffer_t *buf)
Cleanup session log buffer instance.
Thread-safe circular log buffer for session screens (status, splash).
#define SESSION_LOG_BUFFER_SIZE
#define SESSION_LOG_LINE_MAX
🔤 String Manipulation and Shell Escaping Utilities
Atomic value wrapper for integral/boolean types.
Definition atomic.h:76
Thread-safe fixed-size history ring for session-screen log lines.
session_log_entry_t entries[SESSION_LOG_BUFFER_SIZE]
One formatted session log line and its monotonic history sequence.
char message[1024]
Formatted log message (may include ANSI colors).
uint64_t sequence
Sequence number (monotonic, for ordering).