- Added missing structure members to ETCP_CONN (ack_packets_count, last_rx_ack_id, rtt_history, rtt_history_idx, total_packets_sent) - Added missing bandwidth member to ETCP_LINK structure - Fixed include path for ll_queue.h header - Added math library linking (-lm) to build system - Added etcp_loadbalancer.c to build sources - Fixed forward declarations and function calls in ETCP modules - Updated test dependencies to include loadbalancer object files All simple compilation errors resolved, project builds successfully and tests pass (except TUN permission test which is expected in container).
829 lines
30 KiB
Plaintext
Executable File
829 lines
30 KiB
Plaintext
Executable File
// ll_queue.c
|
||
#include <stdlib.h>
|
||
#include <string.h>
|
||
#include <stdio.h>
|
||
#include <assert.h>
|
||
#include "ll_queue.h"
|
||
#include "u_async.h"
|
||
#include "debug_config.h"
|
||
|
||
// Предварительное объявление для отложенного возобновления
|
||
static void queue_resume_timeout_cb(void* arg);
|
||
|
||
// Проверить и запустить ожидающие коллбэки
|
||
static void check_waiters(struct ll_queue* q) {
|
||
if (!q || !q->waiters) return;
|
||
|
||
DEBUG_DEBUG(DEBUG_CATEGORY_LL_QUEUE, "check_waiters: checking waiters, count=%d, bytes=%zu",
|
||
q->count, q->total_bytes);
|
||
|
||
// Сначала собрать список коллбэков для вызова, чтобы избежать проблем с модификацией списка во время итерации
|
||
struct queue_waiter* to_call = NULL;
|
||
struct queue_waiter* to_call_tail = NULL;
|
||
|
||
struct queue_waiter** pprev = &q->waiters;
|
||
struct queue_waiter* waiter = q->waiters;
|
||
|
||
while (waiter) {
|
||
struct queue_waiter* next = waiter->next;
|
||
|
||
// Проверить условие: не больше max_packets и не больше max_bytes
|
||
// max_bytes = 0 означает "не проверять байты"
|
||
if (q->count <= waiter->max_packets && (waiter->max_bytes == 0 || q->total_bytes <= waiter->max_bytes)) {
|
||
DEBUG_DEBUG(DEBUG_CATEGORY_LL_QUEUE, "check_waiters: condition met, calling callback, count=%d<=%d, bytes=%zu<=%zu (max_bytes_check=%s)",
|
||
q->count, waiter->max_packets, q->total_bytes, waiter->max_bytes,
|
||
waiter->max_bytes == 0 ? "disabled" : "enabled");
|
||
// Удалить waiter из списка
|
||
*pprev = next;
|
||
// Добавить в список для вызова
|
||
waiter->next = NULL;
|
||
if (to_call_tail) {
|
||
to_call_tail->next = waiter;
|
||
} else {
|
||
to_call = waiter;
|
||
}
|
||
to_call_tail = waiter;
|
||
} else {
|
||
// Условие не выполнено - оставить в списке
|
||
DEBUG_DEBUG(DEBUG_CATEGORY_LL_QUEUE, "check_waiters: condition NOT met, count=%d>%d or bytes=%zu>%zu (max_bytes_check=%s)",
|
||
q->count, waiter->max_packets, q->total_bytes, waiter->max_bytes,
|
||
waiter->max_bytes == 0 ? "disabled" : "enabled");
|
||
pprev = &waiter->next;
|
||
}
|
||
waiter = next;
|
||
}
|
||
|
||
// Теперь вызвать коллбэки
|
||
waiter = to_call;
|
||
while (waiter) {
|
||
struct queue_waiter* next = waiter->next;
|
||
waiter->callback(q, waiter->callback_arg);
|
||
if (q->pool) {
|
||
memory_pool_free(q->pool, waiter);
|
||
} else {
|
||
free(waiter);
|
||
}
|
||
waiter = next;
|
||
}
|
||
}
|
||
|
||
// ==================== Управление очередью ====================
|
||
|
||
struct ll_queue* queue_new(struct UASYNC* ua, struct memory_pool* pool) {
|
||
if (!ua) return NULL;
|
||
|
||
struct ll_queue* q = calloc(1, sizeof(struct ll_queue));
|
||
if (!q) return NULL;
|
||
|
||
q->head = NULL;
|
||
q->tail = NULL;
|
||
q->count = 0;
|
||
q->total_bytes = 0;
|
||
q->size_limit = -1; // По умолчанию без ограничения
|
||
q->callback = NULL;
|
||
q->callback_arg = NULL;
|
||
q->callback_suspended = 0; // Коллбэки разрешены изначально
|
||
q->resume_timeout_id = NULL;
|
||
q->ua = ua;
|
||
q->waiters = NULL;
|
||
q->pool=pool;
|
||
q->version = 0;
|
||
|
||
return q;
|
||
}
|
||
|
||
void queue_free(struct ll_queue* q) {
|
||
if (!q) return;
|
||
|
||
DEBUG_DEBUG(DEBUG_CATEGORY_LL_QUEUE, "queue_free: freeing queue %p, head=%p, tail=%p, count=%d",
|
||
q, q->head, q->tail, q->count);
|
||
|
||
// Освободить все элементы (уменьшить счетчик ссылок)
|
||
struct ll_entry* entry = q->head;
|
||
int entry_count = 0;
|
||
while (entry) {
|
||
struct ll_entry* next = entry->next;
|
||
DEBUG_DEBUG(DEBUG_CATEGORY_LL_QUEUE, "queue_free: releasing entry %p (entry %d), ref_count=%d",
|
||
entry, entry_count++, entry->ref_count);
|
||
entry->ref_count--; // Дополнительно уменьшить за присутствие в очереди
|
||
queue_entry_free(entry); // Это уменьшит ref_count и освободит только если ref_count == 0
|
||
entry = next;
|
||
}
|
||
|
||
// Освободить все ожидающие коллбэки
|
||
struct queue_waiter* waiter = q->waiters;
|
||
int waiter_count = 0;
|
||
while (waiter) {
|
||
struct queue_waiter* next = waiter->next;
|
||
DEBUG_DEBUG(DEBUG_CATEGORY_LL_QUEUE, "queue_free: freeing waiter %p (waiter %d)", waiter, waiter_count++);
|
||
if (q->pool) {
|
||
memory_pool_free(q->pool, waiter);
|
||
} else {
|
||
free(waiter);
|
||
}
|
||
waiter = next;
|
||
}
|
||
|
||
// Отменить отложенное возобновление если запланировано
|
||
if (q->resume_timeout_id) {
|
||
DEBUG_DEBUG(DEBUG_CATEGORY_LL_QUEUE, "queue_free: cancelling resume timeout %p", q->resume_timeout_id);
|
||
uasync_cancel_timeout(q->ua, q->resume_timeout_id);
|
||
}
|
||
|
||
DEBUG_DEBUG(DEBUG_CATEGORY_LL_QUEUE, "queue_free: freeing queue structure %p", q);
|
||
free(q);
|
||
}
|
||
|
||
// ==================== Конфигурация очереди ====================
|
||
|
||
void queue_set_callback(struct ll_queue* q, queue_callback_fn cbk_fn, void* arg) {
|
||
if (!q) return;
|
||
q->callback = cbk_fn;
|
||
q->callback_arg = arg;
|
||
}
|
||
|
||
static void queue_resume_timeout_cb(void* arg) {
|
||
struct ll_queue* q = (struct ll_queue*)arg;
|
||
if (!q || !q->callback) return;
|
||
|
||
// Очистить ID таймаута (таймаут сработал)
|
||
q->resume_timeout_id = NULL;
|
||
|
||
// Разрешить коллбэки
|
||
q->callback_suspended = 0;
|
||
|
||
// Если в очереди есть элементы, вызвать коллбэк с первым элементом
|
||
// Обработчик должен извлечь этот элемент вызовом queue_entry_get()
|
||
if (q->head) {
|
||
q->callback(q, q->head, q->callback_arg);
|
||
}
|
||
}
|
||
|
||
void queue_resume_callback(struct ll_queue* q) {
|
||
if (!q || !q->callback) return;
|
||
|
||
// Если уже есть отложенное возобновление, ничего не делать
|
||
if (q->resume_timeout_id) {
|
||
return;
|
||
}
|
||
|
||
// Запланировать отложенное возобновление через uasync
|
||
q->resume_timeout_id = uasync_set_timeout(q->ua, 0, q, queue_resume_timeout_cb);
|
||
}
|
||
|
||
void queue_set_size_limit(struct ll_queue* q, int lim) {
|
||
if (!q) return;
|
||
q->size_limit = lim;
|
||
}
|
||
|
||
// ==================== Управление элементами ====================
|
||
|
||
struct ll_entry* queue_entry_new(size_t data_size) {
|
||
// Выделить память под структуру + область данных
|
||
struct ll_entry* entry = malloc(sizeof(struct ll_entry) + data_size);
|
||
if (!entry) return NULL;
|
||
|
||
entry->next = NULL;
|
||
entry->prev = NULL; // Инициализировать prev для двусвязного списка
|
||
entry->size = data_size;
|
||
entry->ref_count = 1; // Начальный счетчик ссылок
|
||
// Область данных оставить неинициализированной для производительности
|
||
|
||
DEBUG_DEBUG(DEBUG_CATEGORY_LL_QUEUE, "queue_entry_new: created entry %p, size=%zu, ref_count=%d",
|
||
entry, data_size, entry->ref_count);
|
||
|
||
return entry;
|
||
}
|
||
|
||
void queue_entry_free(struct ll_entry* entry) {
|
||
if (!entry) return;
|
||
|
||
DEBUG_DEBUG(DEBUG_CATEGORY_LL_QUEUE, "queue_entry_free: entry=%p, ref_count=%d",
|
||
entry, entry->ref_count);
|
||
|
||
if (entry->ref_count <= 0) {
|
||
DEBUG_ERROR(DEBUG_CATEGORY_LL_QUEUE, "queue_entry_free: entry %p has invalid ref_count=%d",
|
||
entry, entry->ref_count);
|
||
return; // Предотвратить double-free
|
||
}
|
||
|
||
entry->ref_count--;
|
||
if (entry->ref_count == 0) {
|
||
DEBUG_DEBUG(DEBUG_CATEGORY_LL_QUEUE, "queue_entry_free: actually freeing entry %p", entry);
|
||
free(entry);
|
||
} else {
|
||
DEBUG_DEBUG(DEBUG_CATEGORY_LL_QUEUE, "queue_entry_free: decremented ref_count to %d for entry %p",
|
||
entry->ref_count, entry);
|
||
}
|
||
}
|
||
|
||
// ==================== Операции с очередью ====================
|
||
|
||
int queue_entry_put(struct ll_queue* q, struct ll_entry* entry) {
|
||
if (!q || !entry) return -1;
|
||
|
||
DEBUG_DEBUG(DEBUG_CATEGORY_LL_QUEUE, "queue_entry_put: entry=%p, size=%zu, count=%d",
|
||
entry, entry->size, q->count);
|
||
|
||
// Проверить лимит размера
|
||
if (q->size_limit >= 0 && q->count >= q->size_limit) {
|
||
DEBUG_DEBUG(DEBUG_CATEGORY_LL_QUEUE, "queue_entry_put: size limit exceeded, freeing entry %p", entry);
|
||
queue_entry_free(entry);
|
||
return -1;
|
||
}
|
||
|
||
// Увеличить счетчик ссылок при добавлении в очередь
|
||
entry->ref_count++;
|
||
|
||
// Добавить в хвост (FIFO) - двусвязный список
|
||
entry->next = NULL;
|
||
entry->prev = q->tail;
|
||
|
||
if (q->tail) {
|
||
q->tail->next = entry;
|
||
} else {
|
||
q->head = entry; // Очередь была пустой
|
||
}
|
||
q->tail = entry;
|
||
q->count++;
|
||
q->total_bytes += entry->size;
|
||
|
||
DEBUG_DEBUG(DEBUG_CATEGORY_LL_QUEUE, "queue_entry_put: added entry %p, new count=%d, total_bytes=%zu, ref_count=%d",
|
||
entry, q->count, q->total_bytes, entry->ref_count);
|
||
|
||
// Инвалидировать позиции
|
||
q->version++;
|
||
|
||
// Если коллбэки разрешены - вызвать коллбэк
|
||
// Это запускает автоматическую обработку очереди
|
||
if (!q->callback_suspended && q->callback) {
|
||
DEBUG_DEBUG(DEBUG_CATEGORY_LL_QUEUE, "queue_entry_put: calling callback for entry %p", entry);
|
||
|
||
// Приостановить коллбэки во время выполнения коллбэка, чтобы предотвратить рекурсию
|
||
q->callback_suspended = 1;
|
||
q->callback(q, q->head, q->callback_arg);
|
||
// Не восстанавливать здесь - восстановление происходит через queue_resume_callback
|
||
}
|
||
|
||
// Проверить ожидающие коллбэки
|
||
check_waiters(q);
|
||
|
||
return 0;
|
||
}
|
||
|
||
int queue_entry_put_first(struct ll_queue* q, struct ll_entry* entry) {
|
||
if (!q || !entry) return -1;
|
||
|
||
DEBUG_DEBUG(DEBUG_CATEGORY_LL_QUEUE, "queue_entry_put_first: entry=%p, size=%zu, count=%d",
|
||
entry, entry->size, q->count);
|
||
|
||
// Проверить лимит размера
|
||
if (q->size_limit >= 0 && q->count >= q->size_limit) {
|
||
DEBUG_DEBUG(DEBUG_CATEGORY_LL_QUEUE, "queue_entry_put_first: size limit exceeded, freeing entry %p", entry);
|
||
queue_entry_free(entry);
|
||
return -1;
|
||
}
|
||
|
||
// Увеличить счетчик ссылок при добавлении в очередь
|
||
entry->ref_count++;
|
||
|
||
// Добавить в голову (LIFO, высокий приоритет) - двусвязный список
|
||
entry->next = q->head;
|
||
entry->prev = NULL;
|
||
|
||
if (q->head) {
|
||
q->head->prev = entry;
|
||
} else {
|
||
q->tail = entry; // Очередь была пустой
|
||
}
|
||
q->head = entry;
|
||
q->count++;
|
||
q->total_bytes += entry->size;
|
||
|
||
DEBUG_DEBUG(DEBUG_CATEGORY_LL_QUEUE, "queue_entry_put_first: added entry %p, new count=%d, total_bytes=%zu, ref_count=%d",
|
||
entry, q->count, q->total_bytes, entry->ref_count);
|
||
|
||
// Инвалидировать позиции
|
||
q->version++;
|
||
|
||
// Если коллбэки разрешены - вызвать коллбэк
|
||
if (!q->callback_suspended && q->callback) {
|
||
DEBUG_DEBUG(DEBUG_CATEGORY_LL_QUEUE, "queue_entry_put_first: calling callback for entry %p", entry);
|
||
q->callback_suspended = 1;
|
||
q->callback(q, q->head, q->callback_arg);
|
||
}
|
||
|
||
// Проверить ожидающие коллбэки
|
||
check_waiters(q);
|
||
|
||
return 0;
|
||
}
|
||
|
||
struct ll_entry* queue_entry_get(struct ll_queue* q) {
|
||
if (!q || !q->head) return NULL;
|
||
|
||
struct ll_entry* entry = q->head;
|
||
DEBUG_DEBUG(DEBUG_CATEGORY_LL_QUEUE, "queue_entry_get: retrieving entry %p, size=%zu, ref_count=%d",
|
||
entry, entry->size, entry->ref_count);
|
||
|
||
// Удалить из двусвязного списка
|
||
q->head = entry->next;
|
||
if (q->head) {
|
||
q->head->prev = NULL;
|
||
} else {
|
||
q->tail = NULL; // Очередь стала пустой
|
||
}
|
||
q->count--;
|
||
q->total_bytes -= entry->size;
|
||
|
||
DEBUG_DEBUG(DEBUG_CATEGORY_LL_QUEUE, "queue_entry_get: removed entry %p, new count=%d, total_bytes=%zu",
|
||
entry, q->count, q->total_bytes);
|
||
|
||
entry->next = NULL;
|
||
entry->prev = NULL; // Полностью отсоединить от очереди
|
||
|
||
// Уменьшить счетчик ссылок при извлечении из очереди
|
||
// entry->ref_count был увеличен при добавлении в очередь
|
||
// теперь уменьшаем, но не освобождаем, так как вызывающий код должен это сделать
|
||
entry->ref_count--;
|
||
|
||
// Инвалидировать позиции
|
||
q->version++;
|
||
|
||
// При извлечении элемента приостанавливаем коллбэки
|
||
// Это предотвращает рекурсию если во время обработки добавляются новые элементы
|
||
q->callback_suspended = 1;
|
||
|
||
// Проверить ожидающие коллбэки при извлечении элемента
|
||
// Это важно для waiters, которые ожидают уменьшения очереди
|
||
DEBUG_DEBUG(DEBUG_CATEGORY_LL_QUEUE, "queue_entry_get: about to call check_waiters, count=%d", q->count);
|
||
check_waiters(q);
|
||
|
||
return entry;
|
||
}
|
||
|
||
int queue_entry_count(struct ll_queue* q) {
|
||
if (!q) return 0;
|
||
return q->count;
|
||
}
|
||
|
||
// ==================== Асинхронное ожидание ====================
|
||
|
||
struct queue_waiter* queue_wait_threshold(struct ll_queue* q, int max_packets, size_t max_bytes,
|
||
queue_threshold_callback_fn callback, void* arg) {
|
||
if (!q || !callback) return NULL;
|
||
|
||
// Создать новый waiter
|
||
struct queue_waiter* waiter;
|
||
if (q->pool) {
|
||
waiter = (struct queue_waiter*)memory_pool_alloc(q->pool);
|
||
} else {
|
||
waiter = malloc(sizeof(struct queue_waiter));
|
||
}
|
||
if (!waiter) return NULL;
|
||
|
||
waiter->max_packets = max_packets;
|
||
waiter->max_bytes = max_bytes;
|
||
waiter->callback = callback;
|
||
waiter->callback_arg = arg;
|
||
waiter->next = NULL;
|
||
|
||
// Проверить условие немедленно
|
||
if (q->count <= max_packets && (max_bytes == 0 || q->total_bytes <= max_bytes)) {
|
||
// Условие уже выполнено - вызвать коллбэк и освободить waiter
|
||
DEBUG_DEBUG(DEBUG_CATEGORY_LL_QUEUE, "queue_wait_threshold: condition already met, count=%d<=%d, bytes=%zu<=%zu, calling callback",
|
||
q->count, max_packets, q->total_bytes, max_bytes);
|
||
callback(q, arg);
|
||
if (q->pool) {
|
||
memory_pool_free(q->pool, waiter);
|
||
} else {
|
||
free(waiter);
|
||
}
|
||
return NULL;
|
||
}
|
||
|
||
DEBUG_DEBUG(DEBUG_CATEGORY_LL_QUEUE, "queue_wait_threshold: registering waiter, count=%d, bytes=%zu, max_packets=%d, max_bytes=%zu",
|
||
q->count, q->total_bytes, max_packets, max_bytes);
|
||
|
||
// Добавить в список ожидающих
|
||
waiter->next = q->waiters;
|
||
q->waiters = waiter;
|
||
|
||
DEBUG_DEBUG(DEBUG_CATEGORY_LL_QUEUE, "queue_wait_threshold: waiter registered successfully");
|
||
return waiter;
|
||
}
|
||
|
||
void queue_cancel_wait(struct ll_queue* q, struct queue_waiter* waiter) {
|
||
if (!q || !waiter) return;
|
||
|
||
// Найти и удалить waiter из списка
|
||
struct queue_waiter** pprev = &q->waiters;
|
||
struct queue_waiter* w = q->waiters;
|
||
|
||
while (w) {
|
||
if (w == waiter) {
|
||
*pprev = w->next;
|
||
if (q->pool) {
|
||
memory_pool_free(q->pool, w);
|
||
} else {
|
||
free(w);
|
||
}
|
||
return;
|
||
}
|
||
pprev = &w->next;
|
||
w = w->next;
|
||
}
|
||
}
|
||
|
||
// ==================== Статистика и метрики ====================
|
||
|
||
void queue_get_pool_stats(struct ll_queue* q, size_t* waiter_allocations, size_t* waiter_reuse) {
|
||
if (!q || !q->pool) {
|
||
if (waiter_allocations) *waiter_allocations = 0;
|
||
if (waiter_reuse) *waiter_reuse = 0;
|
||
return;
|
||
}
|
||
|
||
memory_pool_get_stats(q->pool, waiter_allocations, waiter_reuse);
|
||
}
|
||
|
||
// ==================== Управление позициями ====================
|
||
|
||
struct ll_queue_pos* queue_pos_new(struct ll_queue* queue) {
|
||
if (!queue) {
|
||
DEBUG_ERROR(DEBUG_CATEGORY_LL_QUEUE, "queue_pos_new: queue is NULL");
|
||
return NULL;
|
||
}
|
||
|
||
struct ll_queue_pos* pos = malloc(sizeof(struct ll_queue_pos));
|
||
if (!pos) {
|
||
DEBUG_ERROR(DEBUG_CATEGORY_LL_QUEUE, "queue_pos_new: failed to allocate position");
|
||
return NULL;
|
||
}
|
||
|
||
pos->queue = queue;
|
||
pos->current = NULL;
|
||
pos->prev = NULL;
|
||
pos->index = -1; // Перед head
|
||
pos->valid = 1;
|
||
pos->version = queue->version;
|
||
|
||
DEBUG_DEBUG(DEBUG_CATEGORY_LL_QUEUE, "queue_pos_new: created position %p for queue %p", pos, queue);
|
||
return pos;
|
||
}
|
||
|
||
void queue_pos_free(struct ll_queue_pos* pos) {
|
||
if (!pos) return;
|
||
|
||
DEBUG_DEBUG(DEBUG_CATEGORY_LL_QUEUE, "queue_pos_free: freeing position %p", pos);
|
||
free(pos);
|
||
}
|
||
|
||
void queue_pos_reset(struct ll_queue_pos* pos) {
|
||
if (!pos) {
|
||
DEBUG_ERROR(DEBUG_CATEGORY_LL_QUEUE, "queue_pos_reset: pos is NULL");
|
||
return;
|
||
}
|
||
|
||
// Обновить версию позиции при необходимости (вместо инвалидации)
|
||
if (pos->queue->version != pos->version) {
|
||
DEBUG_DEBUG(DEBUG_CATEGORY_LL_QUEUE, "queue_pos_reset: updating position version from %lu to %lu",
|
||
(unsigned long)pos->version, (unsigned long)pos->queue->version);
|
||
pos->version = pos->queue->version;
|
||
}
|
||
|
||
pos->current = NULL;
|
||
pos->prev = NULL;
|
||
pos->index = -1;
|
||
pos->valid = 1;
|
||
|
||
DEBUG_DEBUG(DEBUG_CATEGORY_LL_QUEUE, "queue_pos_reset: position reset");
|
||
}
|
||
|
||
int queue_pos_next(struct ll_queue_pos* pos) {
|
||
if (!pos || !pos->valid) {
|
||
DEBUG_ERROR(DEBUG_CATEGORY_LL_QUEUE, "queue_pos_next: invalid position");
|
||
return 0;
|
||
}
|
||
|
||
if (pos->queue->version != pos->version) {
|
||
pos->valid = 0;
|
||
DEBUG_ERROR(DEBUG_CATEGORY_LL_QUEUE, "queue_pos_next: position invalidated due to queue version change");
|
||
return 0;
|
||
}
|
||
|
||
if (!pos->current) {
|
||
// Перед head - переходим к head
|
||
if (!pos->queue->head) {
|
||
// Очередь пуста - некуда переходить
|
||
return 0;
|
||
}
|
||
pos->current = pos->queue->head;
|
||
pos->prev = NULL;
|
||
pos->index = 0;
|
||
} else if (pos->current->next) {
|
||
// Есть следующий элемент
|
||
pos->prev = pos->current;
|
||
pos->current = pos->current->next;
|
||
pos->index++;
|
||
} else {
|
||
// Достигнут конец очереди
|
||
return 0;
|
||
}
|
||
|
||
DEBUG_DEBUG(DEBUG_CATEGORY_LL_QUEUE, "queue_pos_next: moved to index %d, entry %p",
|
||
pos->index, pos->current);
|
||
return 1;
|
||
}
|
||
|
||
int queue_pos_prev(struct ll_queue_pos* pos) {
|
||
if (!pos || !pos->valid) {
|
||
DEBUG_ERROR(DEBUG_CATEGORY_LL_QUEUE, "queue_pos_prev: invalid position");
|
||
return 0;
|
||
}
|
||
|
||
if (pos->queue->version != pos->version) {
|
||
pos->valid = 0;
|
||
DEBUG_ERROR(DEBUG_CATEGORY_LL_QUEUE, "queue_pos_prev: position invalidated due to queue version change");
|
||
return 0;
|
||
}
|
||
|
||
if (!pos->current) {
|
||
// Уже перед head - дальше некуда
|
||
return 0;
|
||
} else if (pos->current->prev) {
|
||
// Есть предыдущий элемент
|
||
pos->current = pos->current->prev;
|
||
pos->prev = pos->current->prev;
|
||
pos->index--;
|
||
} else {
|
||
// Достигнуто начало очереди
|
||
pos->current = NULL;
|
||
pos->prev = NULL;
|
||
pos->index = -1;
|
||
}
|
||
|
||
DEBUG_DEBUG(DEBUG_CATEGORY_LL_QUEUE, "queue_pos_prev: moved to index %d, entry %p",
|
||
pos->index, pos->current);
|
||
return 1;
|
||
}
|
||
|
||
int queue_pos_seek(struct ll_queue_pos* pos, int target_index) {
|
||
if (!pos || !pos->valid) {
|
||
DEBUG_ERROR(DEBUG_CATEGORY_LL_QUEUE, "queue_pos_seek: invalid position");
|
||
return 0;
|
||
}
|
||
|
||
// Обновить версию позиции при необходимости (вместо инвалидации)
|
||
if (pos->queue->version != pos->version) {
|
||
DEBUG_DEBUG(DEBUG_CATEGORY_LL_QUEUE, "queue_pos_seek: updating position version from %lu to %lu",
|
||
(unsigned long)pos->version, (unsigned long)pos->queue->version);
|
||
pos->version = pos->queue->version;
|
||
// Сбросить позицию, так как структура очереди могла измениться
|
||
queue_pos_reset(pos);
|
||
}
|
||
|
||
if (target_index < -1 || target_index >= pos->queue->count) {
|
||
DEBUG_ERROR(DEBUG_CATEGORY_LL_QUEUE, "queue_pos_seek: invalid target index %d (count=%d)",
|
||
target_index, pos->queue->count);
|
||
return 0;
|
||
}
|
||
|
||
// Простая реализация: начинаем с начала и идем вперед
|
||
// Можно оптимизировать позже, если потребуется
|
||
queue_pos_reset(pos);
|
||
|
||
for (int i = 0; i <= target_index; i++) {
|
||
if (!queue_pos_next(pos)) {
|
||
DEBUG_ERROR(DEBUG_CATEGORY_LL_QUEUE, "queue_pos_seek: failed to reach index %d", target_index);
|
||
return 0;
|
||
}
|
||
}
|
||
|
||
DEBUG_DEBUG(DEBUG_CATEGORY_LL_QUEUE, "queue_pos_seek: seeked to index %d, entry %p",
|
||
pos->index, pos->current);
|
||
return 1;
|
||
}
|
||
|
||
int queue_pos_insert(struct ll_queue_pos* pos, struct ll_entry* entry, int mode) {
|
||
if (!pos || !pos->valid || !entry) {
|
||
DEBUG_ERROR(DEBUG_CATEGORY_LL_QUEUE, "queue_pos_insert: invalid parameters");
|
||
return -1;
|
||
}
|
||
|
||
if (pos->queue->version != pos->version) {
|
||
pos->valid = 0;
|
||
DEBUG_ERROR(DEBUG_CATEGORY_LL_QUEUE, "queue_pos_insert: position invalidated due to queue version change");
|
||
return -1;
|
||
}
|
||
|
||
struct ll_queue* q = pos->queue;
|
||
|
||
// Проверить лимит размера
|
||
if (q->size_limit >= 0 && q->count >= q->size_limit) {
|
||
DEBUG_DEBUG(DEBUG_CATEGORY_LL_QUEUE, "queue_pos_insert: size limit exceeded, freeing entry %p", entry);
|
||
queue_entry_free(entry);
|
||
return -1;
|
||
}
|
||
|
||
entry->ref_count++;
|
||
|
||
if (mode == 0) {
|
||
// Вставить перед current
|
||
if (!pos->current) {
|
||
// Вставить в head
|
||
entry->next = q->head;
|
||
entry->prev = NULL;
|
||
if (q->head) {
|
||
q->head->prev = entry;
|
||
} else {
|
||
q->tail = entry; // Очередь была пустой
|
||
}
|
||
q->head = entry;
|
||
} else {
|
||
// Вставить перед current
|
||
entry->next = pos->current;
|
||
entry->prev = pos->current->prev;
|
||
|
||
if (pos->current->prev) {
|
||
pos->current->prev->next = entry;
|
||
} else {
|
||
q->head = entry; // Вставляем в начало
|
||
}
|
||
pos->current->prev = entry;
|
||
}
|
||
} else {
|
||
// Вставить после current
|
||
if (!pos->current) {
|
||
// Вставить в head (current = NULL, значит перед head)
|
||
entry->next = q->head;
|
||
entry->prev = NULL;
|
||
if (q->head) {
|
||
q->head->prev = entry;
|
||
} else {
|
||
q->tail = entry; // Очередь была пустой
|
||
}
|
||
q->head = entry;
|
||
} else {
|
||
// Вставить после current
|
||
entry->next = pos->current->next;
|
||
entry->prev = pos->current;
|
||
|
||
if (pos->current->next) {
|
||
pos->current->next->prev = entry;
|
||
} else {
|
||
q->tail = entry; // Вставляем в конец
|
||
}
|
||
pos->current->next = entry;
|
||
}
|
||
}
|
||
|
||
q->count++;
|
||
q->total_bytes += entry->size;
|
||
|
||
// Обновить версию очереди и позиции (вместо полной инвалидации)
|
||
q->version++;
|
||
|
||
// Обновить текущую позицию, если она активна
|
||
if (pos->current) {
|
||
pos->version = q->version;
|
||
pos->valid = 1; // Сделать позицию снова валидной
|
||
// Корректировка индекса в зависимости от режима вставки
|
||
if (mode == 0) {
|
||
// Вставка перед текущим - индекс остается тем же
|
||
// pos->index не меняется
|
||
} else {
|
||
// Вставка после текущего - текущий элемент смещается
|
||
pos->index++;
|
||
}
|
||
}
|
||
pos->valid = 0; // Текущая позиция теперь invalid
|
||
|
||
DEBUG_DEBUG(DEBUG_CATEGORY_LL_QUEUE, "queue_pos_insert: inserted entry %p, mode=%d, count=%d",
|
||
entry, mode, q->count);
|
||
|
||
// Проверить ожидающие коллбэки
|
||
check_waiters(q);
|
||
|
||
return 0;
|
||
}
|
||
|
||
struct ll_entry* queue_pos_remove(struct ll_queue_pos* pos) {
|
||
if (!pos || !pos->valid || !pos->current) {
|
||
DEBUG_ERROR(DEBUG_CATEGORY_LL_QUEUE, "queue_pos_remove: invalid position or no current element");
|
||
return NULL;
|
||
}
|
||
|
||
if (pos->queue->version != pos->version) {
|
||
pos->valid = 0;
|
||
DEBUG_ERROR(DEBUG_CATEGORY_LL_QUEUE, "queue_pos_remove: position invalidated due to queue version change");
|
||
return NULL;
|
||
}
|
||
|
||
struct ll_queue* q = pos->queue;
|
||
struct ll_entry* entry = pos->current;
|
||
|
||
// Удалить из двусвязного списка
|
||
if (entry->prev) {
|
||
entry->prev->next = entry->next;
|
||
} else {
|
||
q->head = entry->next; // Удаляем head
|
||
}
|
||
|
||
if (entry->next) {
|
||
entry->next->prev = entry->prev;
|
||
} else {
|
||
q->tail = entry->prev; // Удаляем tail
|
||
}
|
||
|
||
q->count--;
|
||
q->total_bytes -= entry->size;
|
||
|
||
// Обновить позицию: перейти к следующему элементу
|
||
pos->current = entry->next;
|
||
pos->prev = entry->prev;
|
||
if (pos->current) {
|
||
// Остались элементы после удаленного
|
||
pos->index = pos->index; // Индекс остается тем же
|
||
} else {
|
||
// Удалили последний элемент
|
||
pos->index = q->count; // Указывает за конец
|
||
if (pos->index == 0) {
|
||
pos->current = NULL;
|
||
pos->prev = NULL;
|
||
pos->index = -1;
|
||
}
|
||
}
|
||
|
||
entry->next = NULL;
|
||
entry->prev = NULL;
|
||
entry->ref_count--; // Уменьшить счетчик ссылок
|
||
|
||
// Обновить версию очереди и позицию (вместо полной инвалидации)
|
||
q->version++;
|
||
if (pos->current) {
|
||
pos->version = q->version;
|
||
pos->valid = 1; // Сделать позицию снова валидной
|
||
// pos->index уже обновлен выше
|
||
}
|
||
|
||
DEBUG_DEBUG(DEBUG_CATEGORY_LL_QUEUE, "queue_pos_remove: removed entry %p, new count=%d",
|
||
entry, q->count);
|
||
|
||
// Проверить ожидающие коллбэки
|
||
check_waiters(q);
|
||
|
||
return entry;
|
||
}
|
||
|
||
int queue_entry_remove(struct ll_queue* q, struct ll_entry* entry) {
|
||
if (!q || !entry) {
|
||
DEBUG_ERROR(DEBUG_CATEGORY_LL_QUEUE, "queue_entry_remove: invalid parameters");
|
||
return -1;
|
||
}
|
||
|
||
// Проверить, что элемент действительно в этой очереди
|
||
struct ll_entry* curr = q->head;
|
||
while (curr) {
|
||
if (curr == entry) {
|
||
break;
|
||
}
|
||
curr = curr->next;
|
||
}
|
||
|
||
if (!curr) {
|
||
DEBUG_ERROR(DEBUG_CATEGORY_LL_QUEUE, "queue_entry_remove: entry %p not found in queue", entry);
|
||
return -1;
|
||
}
|
||
|
||
// Удалить из двусвязного списка
|
||
if (entry->prev) {
|
||
entry->prev->next = entry->next;
|
||
} else {
|
||
q->head = entry->next; // Удаляем head
|
||
}
|
||
|
||
if (entry->next) {
|
||
entry->next->prev = entry->prev;
|
||
} else {
|
||
q->tail = entry->prev; // Удаляем tail
|
||
}
|
||
|
||
q->count--;
|
||
q->total_bytes -= entry->size;
|
||
|
||
entry->next = NULL;
|
||
entry->prev = NULL;
|
||
entry->ref_count--;
|
||
|
||
// Инвалидировать позиции
|
||
q->version++;
|
||
|
||
DEBUG_DEBUG(DEBUG_CATEGORY_LL_QUEUE, "queue_entry_remove: removed entry %p, new count=%d",
|
||
entry, q->count);
|
||
|
||
// Проверить ожидающие коллбэки
|
||
check_waiters(q);
|
||
|
||
return 0;
|
||
} |