437 lines
16 KiB
C
437 lines
16 KiB
C
/*
|
||
* standby.c — режим standby с duty-cycle (активный/неактивный интервалы)
|
||
*
|
||
* Синглтон (одна instance на процесс — как instance_lite.c).
|
||
* Таймеры только через uasync. Интервалы читаются лениво из chat_setting,
|
||
* поэтому их изменение через GUI применяется на границе следующей фазы.
|
||
*
|
||
* Duty-cycle:
|
||
* standby включён → фаза ACTIVE на standby_active_sec, затем SLEEP на
|
||
* standby_sleep_sec, и так по кругу, пока standby не выключат.
|
||
*
|
||
* Досрочное пробуждение:
|
||
* в фазе SLEEP первые standby_min_sleep_sec секунд спим безусловно;
|
||
* после них standby_notify_network_activity() (внешняя сетевая активность)
|
||
* пробуждает досрочно — следующий цикл как обычно.
|
||
*
|
||
* Список ожидающих (standby_wait) — двусвязный список, элементы из memory_pool.
|
||
* В SLEEP ожидающие будятся фазовым таймером после анонса ACTIVE пирам.
|
||
* При выходе из standby они будятся после восстановления режима линков.
|
||
*/
|
||
#include "standby.h"
|
||
#include "chat_setting.h"
|
||
#include "utun_instance.h"
|
||
#include "debug_config.h"
|
||
#include "memory_pool.h"
|
||
|
||
#define STANDBY_TB_PER_SEC 10000 /* timebase = 0.1ms → 1 сек = 10000 TB */
|
||
|
||
#define PHASE_ACTIVE 0
|
||
#define PHASE_SLEEP 1
|
||
|
||
struct standby_wait_entry {
|
||
struct standby_wait_entry* prev;
|
||
struct standby_wait_entry* next;
|
||
void* timer_id; /* handle uasync_set_timeout */
|
||
void (*cb)(void* arg);
|
||
void* arg;
|
||
int dispatching; /* отцеплен для пробуждения; cancel только снимает cb */
|
||
};
|
||
|
||
static struct UASYNC* g_ua = NULL;
|
||
static struct UTUN_INSTANCE* g_inst = NULL; /* для чтения chat_setting (per-instance) */
|
||
static int g_enabled = 0;
|
||
static int g_phase = PHASE_ACTIVE;
|
||
static uint64_t g_phase_start_tb = 0; /* начало текущей фазы */
|
||
static uint64_t g_phase_end_tb = 0; /* дедлайн текущей фазы */
|
||
static uint64_t g_min_sleep_end_tb = 0; /* до этой точки спим безусловно */
|
||
static void* g_phase_timer = NULL;
|
||
static void (*g_switch_cb)(int enabled, void* arg) = NULL;
|
||
static void* g_switch_arg = NULL;
|
||
static void (*g_phase_cb)(int sleeping, void* arg) = NULL;
|
||
static void* g_phase_cb_arg = NULL;
|
||
|
||
static struct memory_pool* g_wait_pool = NULL;
|
||
static struct standby_wait_entry* g_wait_head = NULL;
|
||
static struct standby_wait_entry* g_wait_tail = NULL;
|
||
|
||
/* счётчики для диагностики */
|
||
static uint32_t g_cnt_wakes_timer = 0;
|
||
static uint32_t g_cnt_wakes_early = 0;
|
||
static uint32_t g_cnt_sleeps = 0;
|
||
static uint32_t g_cnt_net_events = 0;
|
||
static uint32_t g_cnt_net_ignored = 0;
|
||
|
||
static int standby_active_sec(void) {
|
||
return chat_setting_get_int(g_inst, "standby_active_sec", 2);
|
||
}
|
||
|
||
static int standby_sleep_sec(void) {
|
||
return chat_setting_get_int(g_inst, "standby_sleep_sec", 60);
|
||
}
|
||
|
||
static int standby_min_sleep_sec(void) {
|
||
int m = chat_setting_get_int(g_inst, "standby_min_sleep_sec", 15);
|
||
if (m < 0) m = 0;
|
||
int s = standby_sleep_sec();
|
||
if (m > s) m = s;
|
||
return m;
|
||
}
|
||
|
||
/* override интервалов (мс) для тестов: 0 = использовать chat_setting */
|
||
static int g_override = 0;
|
||
static int g_active_ms = 0;
|
||
static int g_sleep_ms = 0;
|
||
static int g_min_sleep_ms = 0;
|
||
|
||
static int standby_active_tb(void) {
|
||
return g_override ? g_active_ms * 10 : standby_active_sec() * STANDBY_TB_PER_SEC;
|
||
}
|
||
|
||
static int standby_sleep_tb(void) {
|
||
return g_override ? g_sleep_ms * 10 : standby_sleep_sec() * STANDBY_TB_PER_SEC;
|
||
}
|
||
|
||
static int standby_min_sleep_tb(void) {
|
||
int m = g_override ? g_min_sleep_ms * 10 : standby_min_sleep_sec() * STANDBY_TB_PER_SEC;
|
||
if (m < 0) m = 0;
|
||
int s = standby_sleep_tb();
|
||
if (m > s) m = s;
|
||
return m;
|
||
}
|
||
|
||
/* ── фазовый таймер ── */
|
||
|
||
static void standby_phase_timer_cb(void* arg);
|
||
|
||
/* Сначала создаёт новый таймер; при ошибке сохраняет прежнюю фазу и её таймер. */
|
||
static int standby_arm_phase(int phase) {
|
||
int dur_tb = (phase == PHASE_ACTIVE) ? standby_active_tb() : standby_sleep_tb();
|
||
uint64_t now = get_time_tb();
|
||
void* timer = uasync_set_timeout(g_ua, dur_tb, NULL, standby_phase_timer_cb, "standby_phase");
|
||
if (!timer) {
|
||
DEBUG_ERROR(DEBUG_CATEGORY_GENERAL, "standby: failed to arm phase=%d duration=%dms", phase, dur_tb / 10);
|
||
return -1;
|
||
}
|
||
if (g_phase_timer) uasync_cancel_timeout(g_ua, g_phase_timer);
|
||
g_phase_timer = timer;
|
||
g_phase = phase;
|
||
g_phase_start_tb = now;
|
||
g_phase_end_tb = now + (uint64_t)dur_tb;
|
||
g_min_sleep_end_tb = phase == PHASE_SLEEP ? now + (uint64_t)standby_min_sleep_tb() : 0;
|
||
return 0;
|
||
}
|
||
|
||
static void standby_wake_all_waiters(void);
|
||
|
||
static void standby_phase_timer_cb(void* arg) {
|
||
(void)arg;
|
||
g_phase_timer = NULL;
|
||
if (!g_enabled) return;
|
||
uint64_t elapsed = get_time_tb() - g_phase_start_tb;
|
||
/* переармить фазу ДО фазового колбэка: колбэк читает g_phase_end_tb
|
||
(ka_active_remaining_01s), иначе он увидит старый (уже истёкший) дедлайн. */
|
||
if (standby_arm_phase(g_phase == PHASE_ACTIVE ? PHASE_SLEEP : PHASE_ACTIVE) < 0) {
|
||
DEBUG_ERROR(DEBUG_CATEGORY_GENERAL, "standby: phase timer lost; returning to normal mode");
|
||
if (g_inst) utun_set_client_activity(g_inst, 1); else standby_set_enabled(NULL, 0);
|
||
return;
|
||
}
|
||
if (g_phase == PHASE_SLEEP) {
|
||
g_cnt_sleeps++;
|
||
DEBUG_INFO(DEBUG_CATEGORY_GENERAL,
|
||
"standby: SLEEP (active done in %d.%ds, sleep=%dms min_sleep=%dms)",
|
||
(int)(elapsed / STANDBY_TB_PER_SEC), (int)((elapsed % STANDBY_TB_PER_SEC) / 1000),
|
||
standby_sleep_tb() / 10, standby_min_sleep_tb() / 10);
|
||
if (g_phase_cb) g_phase_cb(1, g_phase_cb_arg);
|
||
} else {
|
||
g_cnt_wakes_timer++;
|
||
DEBUG_INFO(DEBUG_CATEGORY_GENERAL, "standby: WAKE (timer), slept %d.%ds",
|
||
(int)(elapsed / STANDBY_TB_PER_SEC), (int)((elapsed % STANDBY_TB_PER_SEC) / 1000));
|
||
if (g_phase_cb) g_phase_cb(0, g_phase_cb_arg);
|
||
standby_wake_all_waiters();
|
||
}
|
||
}
|
||
|
||
/* ── список ожидающих ── */
|
||
|
||
static struct standby_wait_entry* wait_entry_alloc(void) {
|
||
if (!g_wait_pool) {
|
||
g_wait_pool = memory_pool_init(sizeof(struct standby_wait_entry), "standby_pool");
|
||
if (!g_wait_pool) return NULL;
|
||
}
|
||
return (struct standby_wait_entry*)memory_pool_alloc(g_wait_pool);
|
||
}
|
||
|
||
static void wait_entry_free(struct standby_wait_entry* e) {
|
||
memory_pool_free(g_wait_pool, e);
|
||
}
|
||
|
||
static void wait_list_remove(struct standby_wait_entry* e) {
|
||
if (e->prev) e->prev->next = e->next; else g_wait_head = e->next;
|
||
if (e->next) e->next->prev = e->prev; else g_wait_tail = e->prev;
|
||
e->prev = e->next = NULL;
|
||
}
|
||
|
||
static void wait_list_push(struct standby_wait_entry* e) {
|
||
e->prev = g_wait_tail;
|
||
e->next = NULL;
|
||
if (g_wait_tail) g_wait_tail->next = e; else g_wait_head = e;
|
||
g_wait_tail = e;
|
||
}
|
||
|
||
/* Отменяет все wait-таймеры и вызывает их колбэки немедленно.
|
||
* Сначала отцепляем весь список — новые регистрации в колбэках
|
||
* (standby_wait) попадут в свежий список и не будут задеты этим проходом. */
|
||
static void standby_wake_all_waiters(void) {
|
||
struct standby_wait_entry* list = g_wait_head;
|
||
g_wait_head = g_wait_tail = NULL;
|
||
for (struct standby_wait_entry* e = list; e; e = e->next) {
|
||
e->dispatching = 1;
|
||
if (e->timer_id) {
|
||
uasync_cancel_timeout(g_ua, e->timer_id);
|
||
e->timer_id = NULL;
|
||
}
|
||
}
|
||
while (list) {
|
||
struct standby_wait_entry* e = list;
|
||
list = e->next;
|
||
void (*cb)(void*) = e->cb;
|
||
void* arg = e->arg;
|
||
wait_entry_free(e);
|
||
if (cb) cb(arg);
|
||
}
|
||
}
|
||
|
||
static void standby_wait_timer_cb(void* arg) {
|
||
struct standby_wait_entry* e = (struct standby_wait_entry*)arg;
|
||
e->timer_id = NULL;
|
||
wait_list_remove(e);
|
||
void (*cb)(void*) = e->cb;
|
||
void* user_arg = e->arg;
|
||
wait_entry_free(e);
|
||
cb(user_arg);
|
||
}
|
||
|
||
/* ── публичный API ── */
|
||
|
||
void standby_init(struct UASYNC* ua) {
|
||
g_ua = ua;
|
||
g_inst = NULL;
|
||
g_enabled = 0;
|
||
g_phase = PHASE_ACTIVE;
|
||
g_phase_timer = NULL;
|
||
g_cnt_wakes_timer = g_cnt_wakes_early = 0;
|
||
g_cnt_sleeps = g_cnt_net_events = g_cnt_net_ignored = 0;
|
||
DEBUG_INFO(DEBUG_CATEGORY_GENERAL, "standby: init (active=%dms sleep=%dms min_sleep=%dms)",
|
||
standby_active_tb() / 10, standby_sleep_tb() / 10, standby_min_sleep_tb() / 10);
|
||
}
|
||
|
||
void standby_deinit(void) {
|
||
if (g_phase_timer && g_ua) {
|
||
uasync_cancel_timeout(g_ua, g_phase_timer);
|
||
g_phase_timer = NULL;
|
||
}
|
||
while (g_wait_head) {
|
||
struct standby_wait_entry* e = g_wait_head;
|
||
if (e->timer_id && g_ua) uasync_cancel_timeout(g_ua, e->timer_id);
|
||
wait_list_remove(e);
|
||
wait_entry_free(e);
|
||
}
|
||
if (g_wait_pool) {
|
||
memory_pool_destroy(g_wait_pool);
|
||
g_wait_pool = NULL;
|
||
}
|
||
g_enabled = 0;
|
||
g_phase = PHASE_ACTIVE;
|
||
g_phase_start_tb = g_phase_end_tb = g_min_sleep_end_tb = 0;
|
||
g_ua = NULL;
|
||
g_inst = NULL;
|
||
g_switch_cb = NULL;
|
||
g_switch_arg = NULL;
|
||
g_phase_cb = NULL;
|
||
g_phase_cb_arg = NULL;
|
||
DEBUG_INFO(DEBUG_CATEGORY_GENERAL, "standby: deinit (wakes_timer=%u wakes_early=%u sleeps=%u net=%u ignored=%u)",
|
||
g_cnt_wakes_timer, g_cnt_wakes_early, g_cnt_sleeps, g_cnt_net_events, g_cnt_net_ignored);
|
||
}
|
||
|
||
int standby_set_enabled(struct UTUN_INSTANCE* inst, int enabled) {
|
||
if (!g_ua || (inst && inst->ua != g_ua)) {
|
||
DEBUG_ERROR(DEBUG_CATEGORY_GENERAL, "standby: set_enabled(%d) ua=%p instance_ua=%p", enabled,
|
||
(void*)g_ua, (void*)(inst ? inst->ua : NULL));
|
||
return -1;
|
||
}
|
||
enabled = !!enabled;
|
||
if (inst) g_inst = inst;
|
||
if (g_enabled == enabled) return 0;
|
||
|
||
if (enabled) {
|
||
if (standby_arm_phase(PHASE_ACTIVE) < 0) return -1;
|
||
g_enabled = 1;
|
||
DEBUG_INFO(DEBUG_CATEGORY_GENERAL, "standby: ENTER (active=%dms sleep=%dms min_sleep=%dms)",
|
||
standby_active_tb() / 10, standby_sleep_tb() / 10, standby_min_sleep_tb() / 10);
|
||
} else {
|
||
g_enabled = 0;
|
||
if (g_phase_timer) {
|
||
uasync_cancel_timeout(g_ua, g_phase_timer);
|
||
g_phase_timer = NULL;
|
||
}
|
||
DEBUG_INFO(DEBUG_CATEGORY_GENERAL, "standby: EXIT (wakes_timer=%u wakes_early=%u sleeps=%u net=%u ignored=%u)",
|
||
g_cnt_wakes_timer, g_cnt_wakes_early, g_cnt_sleeps, g_cnt_net_events, g_cnt_net_ignored);
|
||
}
|
||
|
||
if (g_switch_cb) g_switch_cb(enabled, g_switch_arg);
|
||
if (!enabled) standby_wake_all_waiters();
|
||
return 0;
|
||
}
|
||
|
||
int standby_is_enabled(void) {
|
||
return g_enabled;
|
||
}
|
||
|
||
void standby_set_switch_callback(void (*cb)(int enabled, void* arg), void* arg) {
|
||
g_switch_cb = cb;
|
||
g_switch_arg = arg;
|
||
}
|
||
|
||
int standby_get_sleep_tb(void) {
|
||
if (!g_enabled) return 0;
|
||
if (g_phase == PHASE_ACTIVE) return 0;
|
||
uint64_t now = get_time_tb();
|
||
if (now >= g_phase_end_tb) return 0;
|
||
return (int)(g_phase_end_tb - now);
|
||
}
|
||
|
||
int standby_get_active_remaining_tb(void) {
|
||
if (!g_enabled) return 0;
|
||
if (g_phase == PHASE_SLEEP) return 0;
|
||
uint64_t now = get_time_tb();
|
||
if (now >= g_phase_end_tb) return 0;
|
||
return (int)(g_phase_end_tb - now);
|
||
}
|
||
|
||
int standby_get_sleep_duration_tb(void) {
|
||
return standby_sleep_tb();
|
||
}
|
||
|
||
int standby_get_wake_deadline_tb(void) {
|
||
if (!g_enabled) return 0;
|
||
if (g_phase == PHASE_SLEEP) return standby_get_sleep_tb();
|
||
/* ACTIVE: остаток активного + полная длительность предстоящего сна */
|
||
return standby_get_active_remaining_tb() + standby_sleep_tb();
|
||
}
|
||
|
||
int standby_get_keepalive_ms(void) {
|
||
int ms = chat_setting_get_int(g_inst, "standby_keepalive_ms", 30000);
|
||
if (ms < 100) ms = 100;
|
||
return ms;
|
||
}
|
||
|
||
void standby_set_phase_callback(void (*cb)(int sleeping, void* arg), void* arg) {
|
||
g_phase_cb = cb;
|
||
g_phase_cb_arg = arg;
|
||
}
|
||
|
||
void* standby_wait(void* arg, void (*cb)(void* arg)) {
|
||
if (!cb) return NULL;
|
||
if (!g_ua) {
|
||
DEBUG_ERROR(DEBUG_CATEGORY_GENERAL, "standby: wait() but not initialized");
|
||
return NULL;
|
||
}
|
||
if (!g_enabled) {
|
||
/* standby выключен → будим сразу (отложенно, чтобы не было рекурсии) */
|
||
uasync_call_soon(g_ua, arg, (timeout_callback_t)cb);
|
||
return NULL;
|
||
}
|
||
|
||
struct standby_wait_entry* e = wait_entry_alloc();
|
||
if (!e) {
|
||
DEBUG_ERROR(DEBUG_CATEGORY_GENERAL, "standby: wait_entry_alloc failed");
|
||
cb(arg);
|
||
return NULL;
|
||
}
|
||
e->cb = cb;
|
||
e->arg = arg;
|
||
e->dispatching = 0;
|
||
|
||
/* SLEEP ждёт фазового события; ACTIVE вызывает cb отложенно, без рекурсии. */
|
||
e->timer_id = NULL;
|
||
if (g_phase == PHASE_ACTIVE) {
|
||
e->timer_id = uasync_set_timeout(g_ua, 0, e, standby_wait_timer_cb, "standby_wait");
|
||
if (!e->timer_id) {
|
||
DEBUG_ERROR(DEBUG_CATEGORY_GENERAL, "standby: uasync_set_timeout failed");
|
||
wait_entry_free(e);
|
||
cb(arg);
|
||
return NULL;
|
||
}
|
||
}
|
||
wait_list_push(e);
|
||
return e;
|
||
}
|
||
|
||
void standby_wait_cancel(void* handle) {
|
||
if (!handle) return;
|
||
struct standby_wait_entry* e = (struct standby_wait_entry*)handle;
|
||
if (e->dispatching) { e->cb = NULL; return; }
|
||
if (e->timer_id && g_ua) {
|
||
uasync_cancel_timeout(g_ua, e->timer_id);
|
||
e->timer_id = NULL;
|
||
}
|
||
wait_list_remove(e);
|
||
wait_entry_free(e);
|
||
}
|
||
|
||
/* ── внешняя сетевая активность ── */
|
||
|
||
void standby_notify_network_activity(void) {
|
||
g_cnt_net_events++;
|
||
if (!g_enabled) {
|
||
DEBUG_DEBUG(DEBUG_CATEGORY_GENERAL, "standby: network activity ignored (standby off)");
|
||
return;
|
||
}
|
||
if (g_phase != PHASE_SLEEP) {
|
||
DEBUG_DEBUG(DEBUG_CATEGORY_GENERAL, "standby: network activity ignored (phase=ACTIVE)");
|
||
return;
|
||
}
|
||
|
||
uint64_t now = get_time_tb();
|
||
uint64_t slept = now - g_phase_start_tb;
|
||
if (now < g_min_sleep_end_tb) {
|
||
g_cnt_net_ignored++;
|
||
DEBUG_INFO(DEBUG_CATEGORY_GENERAL,
|
||
"standby: network activity caught, min_sleep not elapsed (%d.%ds left)",
|
||
(int)((g_min_sleep_end_tb - now) / STANDBY_TB_PER_SEC),
|
||
(int)(((g_min_sleep_end_tb - now) % STANDBY_TB_PER_SEC) / 1000));
|
||
return;
|
||
}
|
||
|
||
if (standby_arm_phase(PHASE_ACTIVE) < 0) return;
|
||
g_cnt_wakes_early++;
|
||
DEBUG_INFO(DEBUG_CATEGORY_GENERAL,
|
||
"standby: WAKE early (network activity), slept %d.%ds min_sleep=%dms",
|
||
(int)(slept / STANDBY_TB_PER_SEC), (int)((slept % STANDBY_TB_PER_SEC) / 1000),
|
||
standby_min_sleep_tb() / 10);
|
||
|
||
if (g_phase_cb) g_phase_cb(0, g_phase_cb_arg);
|
||
standby_wake_all_waiters();
|
||
}
|
||
|
||
void standby_log_rx(const char* kind, const char* who) {
|
||
if (!g_enabled || g_phase != PHASE_SLEEP) return;
|
||
uint64_t slept = get_time_tb() - g_phase_start_tb;
|
||
DEBUG_INFO(DEBUG_CATEGORY_DEBUG,
|
||
"standby: rx in SLEEP: %s from %s, slept %d.%ds",
|
||
kind ? kind : "?", who ? who : "?",
|
||
(int)(slept / STANDBY_TB_PER_SEC), (int)((slept % STANDBY_TB_PER_SEC) / 1000));
|
||
}
|
||
|
||
void standby_set_intervals_ms(int active_ms, int sleep_ms, int min_sleep_ms) {
|
||
if (active_ms <= 0 || sleep_ms <= 0) {
|
||
g_override = 0;
|
||
return;
|
||
}
|
||
g_override = 1;
|
||
g_active_ms = active_ms;
|
||
g_sleep_ms = sleep_ms;
|
||
g_min_sleep_ms = min_sleep_ms < 0 ? 0 : min_sleep_ms;
|
||
}
|