session_log_buffer.c File Reference

Thread-safe circular log buffer for session screens. More...

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
bool	session_log_buffer_init (void)
void	session_log_buffer_destroy (void)
void	session_log_buffer_clear (void)
void	session_log_buffer_append (const char *message)
size_t	session_log_buffer_get_recent (session_log_entry_t *out_entries, size_t max_count)

Detailed Description

Thread-safe circular log buffer for session screens.

Definition in file session_log_buffer.c.

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

(

const char *

message

)

Definition at line 70 of file session_log_buffer.c.

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

References session_log_buffer::entries, session_log_buffer::mutex, session_log_buffer::sequence, and session_log_buffer::write_pos.

Referenced by server_status_log_append().

session_log_buffer_clear()

void session_log_buffer_clear

(

void

)

Definition at line 50 of file session_log_buffer.c.

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

References session_log_buffer::entries, session_log_buffer::mutex, session_log_buffer::sequence, and session_log_buffer::write_pos.

Referenced by server_status_log_clear().

session_log_buffer_destroy()

void session_log_buffer_destroy

(

void

)

Definition at line 42 of file session_log_buffer.c.

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

References session_log_buffer::mutex, and mutex_destroy().

Referenced by client_main(), server_status_log_destroy(), and session_client_like_run().

session_log_buffer_get_recent()

size_t session_log_buffer_get_recent	(	session_log_entry_t *	out_entries,
		size_t	max_count
	)

Definition at line 90 of file session_log_buffer.c.

                                                                                         {
  if (!g_log_buffer || !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(&g_log_buffer->mutex);
 
  size_t write_pos = atomic_load(&g_log_buffer->write_pos);
  uint64_t total_entries = atomic_load(&g_log_buffer->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 (g_log_buffer->entries[idx].sequence > 0) {
      memcpy(&out_entries[count], &g_log_buffer->entries[idx], sizeof(session_log_entry_t));
      count++;
    }
  }
 
  mutex_unlock(&g_log_buffer->mutex);
  return count;
}

References session_log_buffer::entries, session_log_buffer::mutex, session_log_buffer::sequence, write_pos, and session_log_buffer::write_pos.

Referenced by interactive_grep_gather_and_filter_logs(), and terminal_screen_render().

session_log_buffer_init()

bool session_log_buffer_init

(

void

)

Definition at line 25 of file session_log_buffer.c.

                                   {
  if (g_log_buffer) {
    return true; // Already initialized
  }
 
  g_log_buffer = SAFE_CALLOC(1, sizeof(session_log_buffer_t), session_log_buffer_t *);
  if (!g_log_buffer) {
    return false;
  }
 
  atomic_init(&g_log_buffer->write_pos, 0);
  atomic_init(&g_log_buffer->sequence, 0);
  mutex_init(&g_log_buffer->mutex);
 
  return true;
}

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

Referenced by server_status_log_init(), and splash_intro_start().