/*
* DWN - Desktop Window Manager
* retoor <retoor@molodetz.nl>
* Specialized Worker Threads - Implementation
*/
#include "thread_workers.h"
#include "util.h"
#include <stdlib.h>
#include <string.h>
#include <stdio.h>
#include <unistd.h>
#include <fcntl.h>
#include <sys/stat.h>
#include <dirent.h>
#include <curl/curl.h>
#include <errno.h>
/* ============================================================================
* I/O Worker Implementation
* ============================================================================ */
typedef struct {
char path[512];
IoCallback callback;
void *user_data;
void *data;
size_t size;
int error;
} IoOperation;
static AsyncContext *g_io_context = NULL;
static size_t dwn_curl_write_cb(void *contents, size_t size, size_t nmemb, void *userp)
{
size_t total = size * nmemb;
IoOperation *op = userp;
void *new_data = realloc(op->data, op->size + total + 1);
if (!new_data) return 0;
op->data = new_data;
memcpy((char*)op->data + op->size, contents, total);
op->size += total;
((char*)op->data)[op->size] = '\0';
return total;
}
static void io_read_file_worker(void *user_data, atomic_int *cancelled)
{
(void)cancelled;
IoOperation *op = user_data;
int fd = open(op->path, O_RDONLY);
if (fd < 0) {
op->error = errno;
return;
}
struct stat st;
if (fstat(fd, &st) < 0) {
op->error = errno;
close(fd);
return;
}
op->size = st.st_size;
op->data = malloc(op->size + 1);
if (!op->data) {
op->error = ENOMEM;
close(fd);
return;
}
ssize_t n = read(fd, op->data, op->size);
close(fd);
if (n < 0) {
op->error = errno;
free(op->data);
op->data = NULL;
return;
}
((char*)op->data)[n] = '\0';
}
static void io_write_file_worker(void *user_data, atomic_int *cancelled)
{
(void)cancelled;
IoOperation *op = user_data;
int fd = open(op->path, O_WRONLY | O_CREAT | O_TRUNC, 0644);
if (fd < 0) {
op->error = errno;
return;
}
ssize_t n = write(fd, op->data, op->size);
close(fd);
if (n < 0 || (size_t)n != op->size) {
op->error = errno;
return;
}
op->error = 0;
}
static void io_read_dir_worker(void *user_data, atomic_int *cancelled)
{
(void)cancelled;
IoOperation *op = user_data;
DIR *dir = opendir(op->path);
if (!dir) {
op->error = errno;
return;
}
size_t total_size = 0;
struct dirent *entry;
while ((entry = readdir(dir)) != NULL) {
total_size += strlen(entry->d_name) + 1;
}
rewinddir(dir);
op->data = malloc(total_size + 1);
if (!op->data) {
op->error = ENOMEM;
closedir(dir);
return;
}
char *p = op->data;
while ((entry = readdir(dir)) != NULL) {
if (strcmp(entry->d_name, ".") == 0 || strcmp(entry->d_name, "..") == 0) {
continue;
}
size_t name_len = strlen(entry->d_name);
size_t remaining = total_size - (size_t)(p - (char*)op->data);
if (name_len + 1 > remaining) break;
memcpy(p, entry->d_name, name_len);
p[name_len] = '\0';
p += name_len + 1;
}
*p = '\0';
op->size = p - (char*)op->data;
closedir(dir);
}
static void io_http_get_worker(void *user_data, atomic_int *cancelled)
{
(void)cancelled;
IoOperation *op = user_data;
CURL *curl = curl_easy_init();
if (!curl) {
op->error = -1;
return;
}
curl_easy_setopt(curl, CURLOPT_URL, op->path);
curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, dwn_curl_write_cb);
curl_easy_setopt(curl, CURLOPT_WRITEDATA, op);
curl_easy_setopt(curl, CURLOPT_FOLLOWLOCATION, 1L);
curl_easy_setopt(curl, CURLOPT_TIMEOUT, 30L);
curl_easy_setopt(curl, CURLOPT_NOSIGNAL, 1L);
/* Check for cancellation periodically */
/* Note: curl doesn't easily support cancellation mid-transfer */
CURLcode res = curl_easy_perform(curl);
if (res != CURLE_OK) {
op->error = res;
if (op->data) {
free(op->data);
op->data = NULL;
op->size = 0;
}
}
curl_easy_cleanup(curl);
}
static void io_operation_cleanup(Task *task, void *user_data, ThreadStatus status)
{
(void)task;
(void)status;
IoOperation *op = user_data;
if (op->callback) {
op->callback(op->data, op->size, op->error, op->user_data);
}
if (op->data && op->error != 0) {
free(op->data);
}
free(op);
}
bool io_worker_init(void)
{
if (g_io_context) return true;
g_io_context = async_context_create("io");
return g_io_context != NULL;
}
void io_worker_shutdown(void)
{
if (g_io_context) {
async_context_destroy(g_io_context);
g_io_context = NULL;
}
}
TaskHandle io_read_file_async(const char *path, IoCallback callback, void *user_data)
{
if (!g_io_context || !path) return NULL;
IoOperation *op = calloc(1, sizeof(IoOperation));
if (!op) return NULL;
strncpy(op->path, path, sizeof(op->path) - 1);
op->callback = callback;
op->user_data = user_data;
TaskHandle task = task_create_with_callback(
io_read_file_worker, op, TASK_PRIORITY_NORMAL,
io_operation_cleanup, op
);
if (!task || thread_pool_submit(thread_pool_default(), task) != THREAD_OK) {
free(op);
return NULL;
}
return task;
}
TaskHandle io_write_file_async(const char *path, const void *data, size_t size,
IoCallback callback, void *user_data)
{
if (!g_io_context || !path || !data) return NULL;
IoOperation *op = calloc(1, sizeof(IoOperation));
if (!op) return NULL;
strncpy(op->path, path, sizeof(op->path) - 1);
op->data = malloc(size);
if (!op->data) {
free(op);
return NULL;
}
memcpy(op->data, data, size);
op->size = size;
op->callback = callback;
op->user_data = user_data;
TaskHandle task = task_create_with_callback(
io_write_file_worker, op, TASK_PRIORITY_NORMAL,
io_operation_cleanup, op
);
if (!task || thread_pool_submit(thread_pool_default(), task) != THREAD_OK) {
free(op->data);
free(op);
return NULL;
}
return task;
}
TaskHandle io_read_dir_async(const char *path, IoCallback callback, void *user_data)
{
if (!g_io_context || !path) return NULL;
IoOperation *op = calloc(1, sizeof(IoOperation));
if (!op) return NULL;
strncpy(op->path, path, sizeof(op->path) - 1);
op->callback = callback;
op->user_data = user_data;
TaskHandle task = task_create_with_callback(
io_read_dir_worker, op, TASK_PRIORITY_NORMAL,
io_operation_cleanup, op
);
if (!task || thread_pool_submit(thread_pool_default(), task) != THREAD_OK) {
free(op);
return NULL;
}
return task;
}
TaskHandle io_http_get_async(const char *url, IoCallback callback, void *user_data)
{
if (!g_io_context || !url) return NULL;
IoOperation *op = calloc(1, sizeof(IoOperation));
if (!op) return NULL;
strncpy(op->path, url, sizeof(op->path) - 1);
op->callback = callback;
op->user_data = user_data;
TaskHandle task = task_create_with_callback(
io_http_get_worker, op, TASK_PRIORITY_NORMAL,
io_operation_cleanup, op
);
if (!task || thread_pool_submit(thread_pool_default(), task) != THREAD_OK) {
free(op);
return NULL;
}
return task;
}
/* ============================================================================
* System Worker Implementation
* ============================================================================ */
static AsyncContext *g_system_context = NULL;
static SystemStats g_cached_stats;
static pthread_mutex_t g_stats_mutex = PTHREAD_MUTEX_INITIALIZER;
static uint32_t g_stats_timer_id = 0;
static void parse_meminfo(uint64_t *total, uint64_t *available)
{
*total = 0;
*available = 0;
FILE *f = fopen("/proc/meminfo", "r");
if (!f) return;
char line[256];
while (fgets(line, sizeof(line), f)) {
if (strncmp(line, "MemTotal:", 9) == 0) {
sscanf(line, "MemTotal: %lu", total);
*total *= 1024;
} else if (strncmp(line, "MemAvailable:", 13) == 0) {
sscanf(line, "MemAvailable: %lu", available);
*available *= 1024;
break;
} else if (strncmp(line, "MemFree:", 8) == 0 && *available == 0) {
/* Fallback if MemAvailable not present */
sscanf(line, "MemFree: %lu", available);
*available *= 1024;
}
}
fclose(f);
}
static void parse_loadavg(float load[3])
{
FILE *f = fopen("/proc/loadavg", "r");
if (!f) return;
if (fscanf(f, "%f %f %f", &load[0], &load[1], &load[2]) != 3) {
load[0] = load[1] = load[2] = 0.0f;
}
fclose(f);
}
static void parse_stat(float *cpu_percent)
{
static uint64_t prev_idle = 0, prev_total = 0;
FILE *f = fopen("/proc/stat", "r");
if (!f) return;
char line[256];
if (fgets(line, sizeof(line), f)) {
unsigned long user, nice, system, idle, iowait, irq, softirq, steal;
sscanf(line, "cpu %lu %lu %lu %lu %lu %lu %lu %lu",
&user, &nice, &system, &idle, &iowait, &irq, &softirq, &steal);
uint64_t idle_time = idle + iowait;
uint64_t total_time = user + nice + system + idle + iowait + irq + softirq + steal;
uint64_t diff_idle = idle_time - prev_idle;
uint64_t diff_total = total_time - prev_total;
if (diff_total > 0) {
*cpu_percent = 100.0f * (1.0f - ((float)diff_idle / diff_total));
}
prev_idle = idle_time;
prev_total = total_time;
}
fclose(f);
}
static void system_stats_worker(void *user_data, atomic_int *cancelled)
{
(void)user_data;
(void)cancelled;
SystemStats stats;
memset(&stats, 0, sizeof(stats));
parse_stat(&stats.cpu_percent);
uint64_t mem_available = 0;
parse_meminfo(&stats.memory_total, &mem_available);
stats.memory_used = stats.memory_total - mem_available;
if (stats.memory_total > 0) {
stats.memory_percent = 100.0f * (float)stats.memory_used / stats.memory_total;
}
parse_loadavg(stats.load_avg);
FILE *f = fopen("/proc/uptime", "r");
if (f) {
double uptime = 0.0;
if (fscanf(f, "%lf", &uptime) == 1) {
stats.uptime_seconds = (uint64_t)uptime;
}
fclose(f);
}
pthread_mutex_lock(&g_stats_mutex);
g_cached_stats = stats;
pthread_mutex_unlock(&g_stats_mutex);
}
static void stats_timer_callback(TimerId id, void *user_data)
{
(void)id;
(void)user_data;
ASYNC(system_stats_worker, NULL);
}
bool system_worker_init(void)
{
if (g_system_context) return true;
g_system_context = async_context_create("system");
if (!g_system_context) return false;
/* Initial stats read */
system_stats_worker(NULL, NULL);
/* Start periodic updates */
g_stats_timer_id = timer_schedule_repeating(1000, stats_timer_callback, NULL);
return true;
}
void system_worker_shutdown(void)
{
if (g_stats_timer_id) {
timer_cancel(g_stats_timer_id);
g_stats_timer_id = 0;
}
if (g_system_context) {
async_context_destroy(g_system_context);
g_system_context = NULL;
}
}
bool system_worker_get_cached_stats(SystemStats *stats)
{
if (!stats) return false;
pthread_mutex_lock(&g_stats_mutex);
*stats = g_cached_stats;
pthread_mutex_unlock(&g_stats_mutex);
return true;
}
/* ============================================================================
* Deferred Worker Implementation
* ============================================================================ */
static bool g_deferred_initialized = false;
bool deferred_worker_init(void)
{
g_deferred_initialized = true;
return true;
}
void deferred_worker_shutdown(void)
{
g_deferred_initialized = false;
}
DeferredId deferred_after(uint64_t delay_ms, DeferredCallback callback, void *user_data)
{
if (!g_deferred_initialized) return 0;
return timer_schedule(delay_ms, (TimerCallback)callback, user_data);
}
DeferredId deferred_every(uint64_t interval_ms, DeferredCallback callback, void *user_data)
{
if (!g_deferred_initialized) return 0;
return timer_schedule_repeating(interval_ms, (TimerCallback)callback, user_data);
}
bool deferred_cancel(DeferredId id)
{
return timer_cancel(id);
}
uint32_t deferred_process(void)
{
return timer_process();
}
int deferred_get_poll_fd(void)
{
return timer_get_poll_fd();
}
/* ============================================================================
* Integration
* ============================================================================ */
bool thread_workers_init(void)
{
if (!io_worker_init()) return false;
if (!system_worker_init()) {
io_worker_shutdown();
return false;
}
if (!deferred_worker_init()) {
system_worker_shutdown();
io_worker_shutdown();
return false;
}
return true;
}
void thread_workers_shutdown(void)
{
deferred_worker_shutdown();
system_worker_shutdown();
io_worker_shutdown();
}
bool thread_workers_process_all(void)
{
bool work_done = false;
/* Process timers */
if (deferred_process() > 0) work_done = true;
/* Process event bus */
if (event_bus_process(event_bus_default()) > 0) work_done = true;
return work_done;
}
int thread_workers_get_poll_fds(int *fds)
{
int count = 0;
int fd = deferred_get_poll_fd();
if (fd >= 0) fds[count++] = fd;
/* Note: event bus fd would be added here if exposed */
return count;
}
Reference in New Issue View Git Blame Copy Permalink