session_log_buffer.c File Reference

Go to the source code of this file.

Data Structures
struct	session_log_buffer
	Internal circular buffer structure. More...

Typedefs
typedef struct session_log_buffer	session_log_buffer_t
	Internal circular buffer structure.

Functions
session_log_buffer_t *	session_log_buffer_create (void)
	Create a new session log buffer instance.
void	session_log_buffer_destroy (session_log_buffer_t *buf)
	Cleanup 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.

Typedef Documentation

session_log_buffer_t

typedef struct session_log_buffer session_log_buffer_t

Internal circular buffer structure.

Function Documentation

session_log_buffer_append()

void session_log_buffer_append	(	session_log_buffer_t *	buf,
		const char *	message
	)

Append a log message to the buffer.

Thread-safe. Called from logging system to capture messages. Message is copied into circular buffer (oldest entry overwritten if full).

Parameters

buf	Buffer instance (must not be NULL)
message	Log message text (already formatted with colors)

Definition at line 65 of file session_log_buffer.c.

                                                                               {
  if (!buf || !message) {
    // Fail silently - this is called FROM the logging system
    // Using SET_ERRNO here would cause infinite recursion
    return;
  }
 
  mutex_lock(&buf->mutex);
 
  size_t pos = atomic_load_u64(&buf->write_pos);
  uint64_t seq = atomic_fetch_add_u64(&buf->sequence, 1);
 
  SAFE_STRNCPY(buf->entries[pos].message, message, SESSION_LOG_LINE_MAX);
  buf->entries[pos].sequence = seq;
 
  atomic_store_u64(&buf->write_pos, (pos + 1) % SESSION_LOG_BUFFER_SIZE);
 
  mutex_unlock(&buf->mutex);
}

References atomic_fetch_add_u64(), atomic_load_u64(), atomic_store_u64(), session_log_buffer::entries, session_log_entry_t::message, session_log_buffer::mutex, mutex_lock, mutex_unlock, SAFE_STRNCPY, session_log_entry_t::sequence, session_log_buffer::sequence, SESSION_LOG_BUFFER_SIZE, SESSION_LOG_LINE_MAX, and session_log_buffer::write_pos.

session_log_buffer_clear()

void session_log_buffer_clear

(

session_log_buffer_t *

buf

)

Clear all log entries from buffer.

Thread-safe. Resets buffer to empty state, discarding all captured logs. Useful for clearing initialization logs before screen starts rendering.

Parameters

buf	Buffer instance (must not be NULL)

Definition at line 45 of file session_log_buffer.c.

                                                         {
  if (!buf) {
    return;
  }
 
  mutex_lock(&buf->mutex);
 
  // Reset write position and sequence
  atomic_store_u64(&buf->write_pos, 0);
  atomic_store_u64(&buf->sequence, 0);
 
  // Clear all entries
  for (size_t i = 0; i < SESSION_LOG_BUFFER_SIZE; i++) {
    buf->entries[i].message[0] = '\0';
    buf->entries[i].sequence = 0;
  }
 
  mutex_unlock(&buf->mutex);
}

References atomic_store_u64(), session_log_buffer::entries, session_log_entry_t::message, session_log_buffer::mutex, mutex_lock, mutex_unlock, session_log_entry_t::sequence, session_log_buffer::sequence, SESSION_LOG_BUFFER_SIZE, and session_log_buffer::write_pos.

session_log_buffer_create()

session_log_buffer_t * session_log_buffer_create

(

void

)

Create a new session log buffer instance.

Allocates and initializes a circular buffer for log capture. Caller is responsible for calling session_log_buffer_destroy() when done.

Returns

Pointer to new buffer instance, or NULL on allocation failure

Definition at line 23 of file session_log_buffer.c.

                                                      {
  session_log_buffer_t *buf = SAFE_CALLOC(1, sizeof(session_log_buffer_t), session_log_buffer_t *);
  if (!buf) {
    return NULL;
  }
 
  atomic_store_u64(&buf->write_pos, 0);
  atomic_store_u64(&buf->sequence, 0);
  mutex_init(&buf->mutex, "log_buffer");
 
  return buf;
}

References atomic_store_u64(), session_log_buffer::mutex, mutex_init(), SAFE_CALLOC, session_log_buffer::sequence, and session_log_buffer::write_pos.

session_log_buffer_destroy()

void session_log_buffer_destroy

(

session_log_buffer_t *

buf

)

Cleanup session log buffer instance.

Frees the buffer and all internal resources. Safe to call with NULL.

Parameters

buf	Buffer instance to destroy (can be NULL)

Definition at line 36 of file session_log_buffer.c.

                                                           {
  if (!buf) {
    return;
  }
 
  mutex_destroy(&buf->mutex);
  SAFE_FREE(buf);
}

References session_log_buffer::mutex, mutex_destroy(), and SAFE_FREE.

session_log_buffer_get_recent()

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.

Thread-safe. Copies up to max_count recent entries into out_entries. Entries are returned in chronological order (oldest first).

Parameters

buf	Buffer instance (must not be NULL)
out_entries	Output array to fill with log entries
max_count	Maximum number of entries to return

Returns

Number of entries actually copied (may be less than max_count)

Definition at line 85 of file session_log_buffer.c.

                                                                                                                    {
  if (!buf || !out_entries || max_count == 0) {
    // Fail silently - called from display code that handles 0 gracefully
    // Using SET_ERRNO here could cause recursion if error logging is enabled
    return 0;
  }
 
  mutex_lock(&buf->mutex);
 
  size_t write_pos = atomic_load_u64(&buf->write_pos);
  uint64_t total_entries = atomic_load_u64(&buf->sequence);
 
  size_t start_pos = write_pos;
  size_t entries_to_check = SESSION_LOG_BUFFER_SIZE;
 
  if (total_entries < SESSION_LOG_BUFFER_SIZE) {
    start_pos = 0;
    entries_to_check = write_pos;
  }
 
  size_t count = 0;
  for (size_t i = 0; i < entries_to_check && count < max_count; i++) {
    size_t idx = (start_pos + i) % SESSION_LOG_BUFFER_SIZE;
    if (buf->entries[idx].sequence > 0) {
      memcpy(&out_entries[count], &buf->entries[idx], sizeof(session_log_entry_t));
      count++;
    }
  }
 
  mutex_unlock(&buf->mutex);
  return count;
}

References atomic_load_u64(), session_log_buffer::entries, session_log_buffer::mutex, mutex_lock, mutex_unlock, session_log_entry_t::sequence, session_log_buffer::sequence, SESSION_LOG_BUFFER_SIZE, write_pos, and session_log_buffer::write_pos.