514 lines
16 KiB
C
514 lines
16 KiB
C
/* meow_bgplay.c — M4 后台播放保活 + 无头后台服务运行时表（见 meow_bgplay.h 头注释）。 */
|
||
#include "meow_bgplay.h"
|
||
|
||
#include <stdarg.h>
|
||
#include <stdio.h>
|
||
#include <signal.h>
|
||
#include <stdlib.h>
|
||
#include <string.h>
|
||
#include <time.h>
|
||
#include <unistd.h>
|
||
#include <sys/wait.h>
|
||
#include <fcntl.h>
|
||
|
||
static meow_bgplay_ops g_ops;
|
||
static meow_bg_entry_t g_bg[MEOW_BG_MAX];
|
||
static meow_svc_rt_t g_svc[MEOW_SVC_RT_MAX];
|
||
static uint32_t g_change_seq;
|
||
|
||
static const uint32_t k_backoff[] = {
|
||
MEOW_SVC_BACKOFF_1, MEOW_SVC_BACKOFF_2, MEOW_SVC_BACKOFF_4, MEOW_SVC_BACKOFF_10
|
||
};
|
||
#define BACKOFF_STEPS ((int)(sizeof(k_backoff) / sizeof(k_backoff[0])))
|
||
|
||
/* SIGTERM 后 SIGKILL 兜底宽限（ms） */
|
||
#define TERM_GRACE_MS 500u
|
||
|
||
/* ------------------------------------------------------------------ */
|
||
|
||
static void bg_log(const char *fmt, ...)
|
||
{
|
||
va_list ap;
|
||
char buf[384];
|
||
|
||
if (!g_ops.log) return;
|
||
va_start(ap, fmt);
|
||
vsnprintf(buf, sizeof(buf), fmt, ap);
|
||
va_end(ap);
|
||
g_ops.log("%s", buf);
|
||
}
|
||
|
||
static uint64_t bg_now_ms(void)
|
||
{
|
||
struct timespec ts;
|
||
|
||
if (g_ops.now_ms) return g_ops.now_ms();
|
||
clock_gettime(CLOCK_MONOTONIC, &ts);
|
||
return (uint64_t)ts.tv_sec * 1000u + (uint64_t)ts.tv_nsec / 1000000u;
|
||
}
|
||
|
||
static int bg_card_present(void)
|
||
{
|
||
return g_ops.card_present ? g_ops.card_present() : 1;
|
||
}
|
||
|
||
void meow_bgplay_init(const meow_bgplay_ops *ops)
|
||
{
|
||
memset(&g_ops, 0, sizeof(g_ops));
|
||
memset(g_bg, 0, sizeof(g_bg));
|
||
memset(g_svc, 0, sizeof(g_svc));
|
||
g_change_seq = 0;
|
||
if (ops) g_ops = *ops;
|
||
}
|
||
|
||
/* ================= 后台播放保活 ================= */
|
||
|
||
int meow_bg_should_keep(int bg_audio_declared, int media_resident, int keepalive_declared)
|
||
{
|
||
if (keepalive_declared) return 1; /* 通用常驻：进后台即保活 */
|
||
return bg_audio_declared && media_resident; /* 播放类：播放/暂停/缓冲都保活 */
|
||
}
|
||
|
||
static meow_bg_entry_t *bg_find(const char *app_id)
|
||
{
|
||
int i;
|
||
|
||
for (i = 0; i < MEOW_BG_MAX; i++)
|
||
if (g_bg[i].used && strcmp(g_bg[i].app_id, app_id) == 0)
|
||
return &g_bg[i];
|
||
return NULL;
|
||
}
|
||
|
||
int meow_bg_add(const char *app_id, pid_t pid, int out_fd, int on_card, int keepalive)
|
||
{
|
||
int i;
|
||
|
||
if (!app_id || !app_id[0] || pid <= 0) return MEOW_ERR_INVAL;
|
||
if (bg_find(app_id)) return MEOW_ERR_EXISTS;
|
||
for (i = 0; i < MEOW_BG_MAX; i++) {
|
||
if (!g_bg[i].used) {
|
||
meow_bg_entry_t *e = &g_bg[i];
|
||
|
||
memset(e, 0, sizeof(*e));
|
||
e->used = 1;
|
||
snprintf(e->app_id, sizeof(e->app_id), "%s", app_id);
|
||
e->pid = pid;
|
||
e->out_fd = out_fd;
|
||
e->on_card = on_card;
|
||
e->bg_since_ms = bg_now_ms(); /* 批①：转后台时刻 */
|
||
e->keepalive = keepalive ? 1 : 0; /* 批①：常驻类型标记 */
|
||
g_change_seq++;
|
||
bg_log("[bgplay] 转后台保活: %s pid=%d on_card=%d keepalive=%d",
|
||
app_id, (int)pid, on_card, e->keepalive);
|
||
return 0;
|
||
}
|
||
}
|
||
return MEOW_ERR_NOMEM;
|
||
}
|
||
|
||
int meow_bg_take(const char *app_id, int *out_fd, pid_t *pid)
|
||
{
|
||
meow_bg_entry_t *e;
|
||
|
||
if (!app_id || !app_id[0]) return -1;
|
||
e = bg_find(app_id);
|
||
if (!e) return -1;
|
||
if (out_fd) *out_fd = e->out_fd;
|
||
if (pid) *pid = e->pid;
|
||
bg_log("[bgplay] 回前台: %s pid=%d", app_id, (int)e->pid);
|
||
memset(e, 0, sizeof(*e));
|
||
g_change_seq++;
|
||
return 0;
|
||
}
|
||
|
||
int meow_bg_is_backgrounded(const char *app_id)
|
||
{
|
||
return app_id && app_id[0] && bg_find(app_id) != NULL;
|
||
}
|
||
|
||
int meow_bg_count(void)
|
||
{
|
||
int i, n = 0;
|
||
|
||
for (i = 0; i < MEOW_BG_MAX; i++)
|
||
if (g_bg[i].used) n++;
|
||
return n;
|
||
}
|
||
|
||
const meow_bg_entry_t *meow_bg_at(int i)
|
||
{
|
||
if (i < 0 || i >= MEOW_BG_MAX || !g_bg[i].used) return NULL;
|
||
return &g_bg[i];
|
||
}
|
||
|
||
uint32_t meow_bgplay_change_seq(void)
|
||
{
|
||
return g_change_seq;
|
||
}
|
||
|
||
void meow_bg_tick(void)
|
||
{
|
||
uint64_t now = bg_now_ms();
|
||
int i;
|
||
|
||
for (i = 0; i < MEOW_BG_MAX; i++) {
|
||
meow_bg_entry_t *e = &g_bg[i];
|
||
int st;
|
||
pid_t r;
|
||
|
||
if (!e->used) continue;
|
||
|
||
/* 卡拔例外：二进制在卡上 → SIGTERM（防 SIGBUS），500ms 未死 SIGKILL */
|
||
if (e->on_card && !bg_card_present()) {
|
||
if (e->term_at_ms == 0) {
|
||
bg_log("[bgplay] 卡拔出，终止卡上后台 App: %s pid=%d",
|
||
e->app_id, (int)e->pid);
|
||
kill(e->pid, SIGTERM);
|
||
e->term_at_ms = now;
|
||
} else if (now - e->term_at_ms >= TERM_GRACE_MS) {
|
||
kill(e->pid, SIGKILL);
|
||
e->term_at_ms = now; /* 500ms 节流重复 SIGKILL 直至 reap */
|
||
}
|
||
}
|
||
|
||
r = waitpid(e->pid, &st, WNOHANG);
|
||
if (r == e->pid) {
|
||
char id[MEOW_APP_ID_MAX];
|
||
pid_t pid = e->pid;
|
||
|
||
snprintf(id, sizeof(id), "%s", e->app_id);
|
||
memset(e, 0, sizeof(*e));
|
||
g_change_seq++;
|
||
bg_log("[bgplay] 后台 App 退出: %s pid=%d status=0x%x", id, (int)pid, st);
|
||
if (g_ops.on_bg_dead) g_ops.on_bg_dead(id, pid, st);
|
||
}
|
||
}
|
||
}
|
||
|
||
/* ================= 无头后台服务 ================= */
|
||
|
||
static meow_svc_rt_t *svc_find_mut(const char *app_id, const char *svc)
|
||
{
|
||
int i;
|
||
|
||
for (i = 0; i < MEOW_SVC_RT_MAX; i++)
|
||
if (g_svc[i].used && strcmp(g_svc[i].app_id, app_id) == 0 &&
|
||
strcmp(g_svc[i].svc, svc) == 0)
|
||
return &g_svc[i];
|
||
return NULL;
|
||
}
|
||
|
||
const meow_svc_rt_t *meow_svc_find(const char *app_id, const char *svc)
|
||
{
|
||
if (!app_id || !svc) return NULL;
|
||
return svc_find_mut(app_id, svc);
|
||
}
|
||
|
||
/* spawn 服务子进程：stdio→/dev/null，env={PATH,HOME,MEOW_SERVICE[,MEOW_LOG_DIR/MEOW_LOG_APP]}。
|
||
* 父进程返回 pid；子进程不返回（execve 或 _exit(127)）。 */
|
||
static pid_t svc_spawn(meow_svc_rt_t *s)
|
||
{
|
||
char env_service[32];
|
||
char env_logdir[160];
|
||
char env_logapp[64];
|
||
char *envp[6];
|
||
int n = 0;
|
||
pid_t pid;
|
||
|
||
envp[n++] = (char *)"PATH=/usr/bin:/bin:/usr/sbin:/sbin";
|
||
envp[n++] = (char *)"HOME=/root";
|
||
snprintf(env_service, sizeof(env_service), "MEOW_SERVICE=%s", s->svc);
|
||
envp[n++] = env_service;
|
||
if (g_ops.log_dir && g_ops.log_dir[0]) {
|
||
snprintf(env_logdir, sizeof(env_logdir), "MEOW_LOG_DIR=%s", g_ops.log_dir);
|
||
envp[n++] = env_logdir;
|
||
snprintf(env_logapp, sizeof(env_logapp), "MEOW_LOG_APP=%s", s->app_id);
|
||
envp[n++] = env_logapp;
|
||
}
|
||
envp[n] = NULL;
|
||
|
||
pid = fork();
|
||
if (pid != 0) return pid; /* 父：pid 或 -1 */
|
||
|
||
/* 子进程：脱离终端会话，stdio 全部重定向 /dev/null（无头服务） */
|
||
setsid();
|
||
{
|
||
int dn = open("/dev/null", O_RDWR);
|
||
if (dn >= 0) {
|
||
dup2(dn, STDIN_FILENO);
|
||
dup2(dn, STDOUT_FILENO);
|
||
dup2(dn, STDERR_FILENO);
|
||
if (dn > STDERR_FILENO) close(dn);
|
||
}
|
||
}
|
||
{
|
||
char *argv[2];
|
||
|
||
argv[0] = s->exec;
|
||
argv[1] = NULL;
|
||
execve(s->exec, argv, envp);
|
||
}
|
||
_exit(127); /* exec 失败：父进程 tick 回收后按退避/熔断处理 */
|
||
}
|
||
|
||
int meow_svc_register(const char *app_id, const char *svc, const char *exec,
|
||
int restart, int max_restart, int window_ms,
|
||
int on_card, int reg_fd)
|
||
{
|
||
meow_svc_rt_t *s;
|
||
pid_t pid;
|
||
int i;
|
||
|
||
if (!app_id || !app_id[0] || !svc || !svc[0] || !exec || !exec[0])
|
||
return MEOW_ERR_INVAL;
|
||
if (access(exec, X_OK) != 0) return MEOW_ERR_NOENT;
|
||
|
||
s = svc_find_mut(app_id, svc);
|
||
if (s) {
|
||
if (s->pid > 0) return MEOW_ERR_EXISTS;
|
||
if (!s->circuit) return MEOW_ERR_EXISTS; /* 退避排程中也视为在册 */
|
||
/* 熔断槽重注册：复位熔断，重新武装 */
|
||
bg_log("[bgplay] 服务熔断复位重注册: %s/%s", app_id, svc);
|
||
s->circuit = 0;
|
||
s->stopping = 0;
|
||
s->restart_count = 0;
|
||
s->window_start_ms = bg_now_ms();
|
||
s->next_retry_ms = 0;
|
||
s->reg_fd = reg_fd;
|
||
s->on_card = on_card;
|
||
} else {
|
||
for (i = 0; i < MEOW_SVC_RT_MAX; i++)
|
||
if (!g_svc[i].used) break;
|
||
if (i >= MEOW_SVC_RT_MAX) return MEOW_ERR_NOMEM;
|
||
s = &g_svc[i];
|
||
memset(s, 0, sizeof(*s));
|
||
s->used = 1;
|
||
snprintf(s->app_id, sizeof(s->app_id), "%s", app_id);
|
||
snprintf(s->svc, sizeof(s->svc), "%s", svc);
|
||
snprintf(s->exec, sizeof(s->exec), "%s", exec);
|
||
s->restart = restart;
|
||
s->max_restart = max_restart;
|
||
s->window_ms = window_ms;
|
||
s->on_card = on_card;
|
||
s->reg_fd = reg_fd;
|
||
s->window_start_ms = bg_now_ms();
|
||
}
|
||
|
||
pid = svc_spawn(s);
|
||
if (pid < 0) {
|
||
if (s->pid == 0 && s->restart_count == 0 && !s->circuit)
|
||
memset(s, 0, sizeof(*s)); /* 新槽首次 fork 即败：不留尸槽 */
|
||
return MEOW_ERR_IO;
|
||
}
|
||
s->pid = pid;
|
||
s->term_at_ms = 0;
|
||
bg_log("[bgplay] 服务拉起: %s/%s pid=%d restart=%d max=%d",
|
||
app_id, svc, (int)pid, restart, max_restart);
|
||
return (int)pid;
|
||
}
|
||
|
||
int meow_svc_stop(const char *app_id, const char *svc)
|
||
{
|
||
meow_svc_rt_t *s;
|
||
|
||
if (!app_id || !svc) return MEOW_ERR_INVAL;
|
||
s = svc_find_mut(app_id, svc);
|
||
if (!s) return MEOW_ERR_NOENT;
|
||
bg_log("[bgplay] 服务停止: %s/%s pid=%d", app_id, svc, (int)s->pid);
|
||
if (s->pid > 0) {
|
||
s->stopping = 1;
|
||
kill(s->pid, SIGTERM);
|
||
s->term_at_ms = bg_now_ms();
|
||
} else {
|
||
/* 未在跑（退避中/熔断）：直接清槽 */
|
||
if (g_ops.on_svc_dead) g_ops.on_svc_dead(s->app_id, s->svc);
|
||
memset(s, 0, sizeof(*s));
|
||
}
|
||
return 0;
|
||
}
|
||
|
||
/* 服务死亡后的退避/熔断判定。返回 1=已排程重启；0=槽已清或熔断。 */
|
||
static int svc_on_exit(meow_svc_rt_t *s, int st)
|
||
{
|
||
uint64_t now = bg_now_ms();
|
||
|
||
bg_log("[bgplay] 服务退出: %s/%s pid=%d status=0x%x stopping=%d",
|
||
s->app_id, s->svc, (int)s->pid, st, s->stopping);
|
||
s->pid = 0;
|
||
|
||
if (s->stopping || !s->restart) {
|
||
if (g_ops.on_svc_dead) g_ops.on_svc_dead(s->app_id, s->svc);
|
||
memset(s, 0, sizeof(*s));
|
||
return 0;
|
||
}
|
||
|
||
/* 滑窗：超窗复位计数 */
|
||
if (s->window_ms > 0 && now - s->window_start_ms >= (uint64_t)s->window_ms) {
|
||
s->restart_count = 0;
|
||
s->window_start_ms = now;
|
||
}
|
||
s->restart_count++;
|
||
|
||
if (s->max_restart > 0 && s->restart_count > s->max_restart) {
|
||
/* 熔断：清通知 + 广播 MSG_SYS{SVC_DEAD}，槽保留待重注册复位 */
|
||
m_sys_t m;
|
||
|
||
s->circuit = 1;
|
||
s->next_retry_ms = 0;
|
||
bg_log("[bgplay] 服务熔断: %s/%s 窗口内重启 %d 次超 max=%d",
|
||
s->app_id, s->svc, s->restart_count, s->max_restart);
|
||
if (g_ops.notif_clear_app)
|
||
g_ops.notif_clear_app(s->app_id);
|
||
if (g_ops.send_frame && s->reg_fd >= 0) {
|
||
memset(&m, 0, sizeof(m));
|
||
m.event = MEOW_SYS_SVC_DEAD;
|
||
snprintf(m.app_id, sizeof(m.app_id), "%s", s->app_id);
|
||
snprintf(m.svc, sizeof(m.svc), "%s", s->svc);
|
||
g_ops.send_frame(s->reg_fd, MSG_SYS, 0, &m, sizeof(m));
|
||
}
|
||
if (g_ops.on_svc_dead) g_ops.on_svc_dead(s->app_id, s->svc);
|
||
return 0;
|
||
}
|
||
|
||
{
|
||
int step = s->restart_count - 1;
|
||
uint32_t dly;
|
||
|
||
if (step >= BACKOFF_STEPS) step = BACKOFF_STEPS - 1;
|
||
dly = k_backoff[step];
|
||
s->next_retry_ms = now + dly;
|
||
bg_log("[bgplay] 服务退避重启: %s/%s 第 %d 次，%ums 后拉起",
|
||
s->app_id, s->svc, s->restart_count, (unsigned)dly);
|
||
}
|
||
return 1;
|
||
}
|
||
|
||
void meow_svc_tick(void)
|
||
{
|
||
uint64_t now = bg_now_ms();
|
||
int i;
|
||
|
||
for (i = 0; i < MEOW_SVC_RT_MAX; i++) {
|
||
meow_svc_rt_t *s = &g_svc[i];
|
||
|
||
if (!s->used) continue;
|
||
|
||
/* 卡拔例外：exec 在卡上 → SIGTERM + stopping=1（不重启防空转死循环） */
|
||
if (s->on_card && s->pid > 0 && !bg_card_present() && !s->stopping) {
|
||
bg_log("[bgplay] 卡拔出，终止卡上服务: %s/%s pid=%d",
|
||
s->app_id, s->svc, (int)s->pid);
|
||
s->stopping = 1;
|
||
kill(s->pid, SIGTERM);
|
||
s->term_at_ms = now;
|
||
}
|
||
/* SIGTERM 宽限超时 → SIGKILL */
|
||
if (s->stopping && s->pid > 0 && s->term_at_ms &&
|
||
now - s->term_at_ms >= TERM_GRACE_MS) {
|
||
kill(s->pid, SIGKILL);
|
||
s->term_at_ms = now;
|
||
}
|
||
|
||
if (s->pid > 0) {
|
||
int st;
|
||
pid_t r = waitpid(s->pid, &st, WNOHANG);
|
||
|
||
if (r == s->pid) svc_on_exit(s, st);
|
||
continue;
|
||
}
|
||
|
||
/* 退避到点 → 重新拉起 */
|
||
if (!s->circuit && !s->stopping && s->restart &&
|
||
s->next_retry_ms && now >= s->next_retry_ms) {
|
||
pid_t pid = svc_spawn(s);
|
||
|
||
s->next_retry_ms = 0;
|
||
if (pid > 0) {
|
||
s->pid = pid;
|
||
bg_log("[bgplay] 服务重启: %s/%s pid=%d（第 %d 次）",
|
||
s->app_id, s->svc, (int)pid, s->restart_count);
|
||
} else {
|
||
/* fork 失败：压到下一档重试 */
|
||
s->next_retry_ms = now + k_backoff[BACKOFF_STEPS - 1];
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
/* ================= 关机前回收 ================= */
|
||
|
||
void meow_bgplay_kill_all(void)
|
||
{
|
||
uint64_t deadline;
|
||
int i;
|
||
|
||
/* best-effort 广播 SHUTDOWN */
|
||
if (g_ops.send_frame) {
|
||
m_sys_t m;
|
||
|
||
memset(&m, 0, sizeof(m));
|
||
m.event = MEOW_SYS_SHUTDOWN;
|
||
for (i = 0; i < MEOW_SVC_RT_MAX; i++)
|
||
if (g_svc[i].used && g_svc[i].reg_fd >= 0)
|
||
g_ops.send_frame(g_svc[i].reg_fd, MSG_SYS, 0, &m, sizeof(m));
|
||
}
|
||
|
||
for (i = 0; i < MEOW_BG_MAX; i++)
|
||
if (g_bg[i].used && g_bg[i].pid > 0) kill(g_bg[i].pid, SIGTERM);
|
||
for (i = 0; i < MEOW_SVC_RT_MAX; i++)
|
||
if (g_svc[i].used && g_svc[i].pid > 0) kill(g_svc[i].pid, SIGTERM);
|
||
|
||
/* 有界等 1s（轮询 reap，期间 tick 语义不在——直接 waitpid） */
|
||
deadline = bg_now_ms() + 1000u;
|
||
while (bg_now_ms() < deadline) {
|
||
int alive = 0;
|
||
|
||
for (i = 0; i < MEOW_BG_MAX; i++) {
|
||
if (!g_bg[i].used) continue;
|
||
if (waitpid(g_bg[i].pid, NULL, WNOHANG) == g_bg[i].pid)
|
||
memset(&g_bg[i], 0, sizeof(g_bg[i]));
|
||
else
|
||
alive++;
|
||
}
|
||
for (i = 0; i < MEOW_SVC_RT_MAX; i++) {
|
||
if (!g_svc[i].used) continue;
|
||
if (waitpid(g_svc[i].pid, NULL, WNOHANG) == g_svc[i].pid)
|
||
memset(&g_svc[i], 0, sizeof(g_svc[i]));
|
||
else
|
||
alive++;
|
||
}
|
||
if (!alive) break;
|
||
usleep(50 * 1000);
|
||
}
|
||
|
||
/* 兜底 SIGKILL + 有界 reap（waitpid 阻塞上限由 SIGKILL 必死保证） */
|
||
for (i = 0; i < MEOW_BG_MAX; i++)
|
||
if (g_bg[i].used) {
|
||
kill(g_bg[i].pid, SIGKILL);
|
||
waitpid(g_bg[i].pid, NULL, 0);
|
||
memset(&g_bg[i], 0, sizeof(g_bg[i]));
|
||
}
|
||
for (i = 0; i < MEOW_SVC_RT_MAX; i++)
|
||
if (g_svc[i].used) {
|
||
kill(g_svc[i].pid, SIGKILL);
|
||
waitpid(g_svc[i].pid, NULL, 0);
|
||
memset(&g_svc[i], 0, sizeof(g_svc[i]));
|
||
}
|
||
g_change_seq++;
|
||
bg_log("[bgplay] kill_all 完成（关机/退出回收）");
|
||
}
|
||
|
||
void meow_bgplay_dump(const char *prefix)
|
||
{
|
||
int i;
|
||
|
||
for (i = 0; i < MEOW_BG_MAX; i++)
|
||
if (g_bg[i].used)
|
||
bg_log("%s bg[%d] %s pid=%d on_card=%d", prefix, i,
|
||
g_bg[i].app_id, (int)g_bg[i].pid, g_bg[i].on_card);
|
||
for (i = 0; i < MEOW_SVC_RT_MAX; i++)
|
||
if (g_svc[i].used)
|
||
bg_log("%s svc[%d] %s/%s pid=%d restart=%d count=%d circuit=%d",
|
||
prefix, i, g_svc[i].app_id, g_svc[i].svc, (int)g_svc[i].pid,
|
||
g_svc[i].restart, g_svc[i].restart_count, g_svc[i].circuit);
|
||
}
|