【Bug已解决】openclaw: "daemon crashed" / SIGSEGV segfault — OpenClaw 守护进程崩溃解决方案

1. 问题描述

在长时间运行 OpenClaw 守护进程时，系统报出进程崩溃或段错误：

# 守护进程崩溃 $ openclaw --daemon-start Error: daemon crashed Process exited with signal 11 (SIGSEGV) Segmentation fault at address 0x0000000000000000 Core dumped to: /var/core/openclaw.core.12345 # 段错误 $ openclaw "执行复杂分析" Error: SIGSEGV segfault Invalid memory access PC: 0x00007fff12345678 SP: 0x00007ffee87654320 Fault address: 0x0000000000000010 # 进程异常退出 $ openclaw --daemon-status Error: daemon not running Last exit: SIGSEGV (signal 11) Restart count: 5 Uptime before crash: 3600s Crash log: .openclaw/logs/crash_20240707.log # 内存损坏 $ openclaw "处理大型数据" Error: heap corruption detected malloc(): corrupted top size Backtrace: [0x1234, 0x5678, 0x9abc]

这个问题在以下场景中特别常见：

• 长时间运行后内存累积导致段错误
• 原生模块（N-API/C++）存在内存安全 bug
• 并发条件下数据竞争导致崩溃
• 处理特殊/畸形输入数据
• 资源泄漏导致 OOM 后段错误
• 操作系统或库版本不兼容

2. 原因分析

守护进程运行 ↓ 内存管理异常 ←──── 空指针/越界/双重释放 ↓ 操作系统发送信号 ←──── SIGSEGV/SIGABRT ↓ 进程崩溃 ←──── 核心转储 ↓ 服务不可用

深层原理

SIGSEGV（Segmentation Fault）是操作系统在进程访问非法内存地址时发送的信号。常见原因包括：解引用空指针（访问地址 0）、访问已释放的内存（use-after-free）、数组越界访问、栈溢出（无限递归导致栈空间耗尽）。在 Node.js/OpenClaw 中，JavaScript 代码本身运行在 V8 沙箱中不会直接导致段错误，但通过 N-API 调用的原生 C/C++ 模块如果存在内存管理 bug 就可能导致 SIGSEGV。此外，V8 引擎本身的 bug、JavaScript 堆内存耗尽后的异常行为、以及操作系统级别的资源限制都可能导致进程崩溃。

3. 解决方案

方案一：配置自动重启和崩溃恢复（最推荐）

# 配置守护进程自动重启 python3 -c " import json with open('.openclaw/config.json', 'r') as f: config = json.load(f) config['daemon'] = { 'autoRestart': True, # 自动重启 'maxRestarts': 10, # 最大重启次数 'restartDelay': 5000, # 重启延迟5秒 'backoffMultiplier': 2, # 退避倍数 'maxRestartDelay': 60000, # 最大延迟60秒 'resetCountAfter': 3600000, # 1小时后重置计数 'crashLog': True, # 记录崩溃日志 'crashLogDir': '.openclaw/logs/crashes/', 'coreDump': True, # 启用核心转储 'coreDumpDir': '/var/core/', 'gracefulShutdown': True, # 优雅关闭 'shutdownTimeout': 10000, # 10秒优雅关闭 'healthCheck': { 'enabled': True, # 启用健康检查 'interval': 30000, # 30秒检查 'timeout': 5000, # 5秒超时 'unhealthyThreshold': 3 # 3次失败重启 } } with open('.openclaw/config.json', 'w') as f: json.dump(config, f, indent=2) print('守护进程配置: 自动重启+退避+健康检查+核心转储') " # 使用 systemd 管理守护进程 cat > /etc/systemd/system/openclaw.service << 'EOF' [Unit] Description=OpenClaw Daemon After=network.target [Service] Type=simple ExecStart=/usr/local/bin/openclaw --daemon Restart=always RestartSec=5 RestartPreventExitStatus=0 # 核心转储 LimitCORE=infinity # 内存限制 LimitNOFILE=65536 # 工作目录 WorkingDirectory=/opt/openclaw # 用户 User=openclaw Group=openclaw # 环境 Environment=NODE_ENV=production Environment=NODE_OPTIONS=--max-old-space-size=4096 # 超时 TimeoutStopSec=30 [Install] WantedBy=multi-user.target EOF sudo systemctl daemon-reload sudo systemctl enable openclaw sudo systemctl start openclaw # 查看服务状态 sudo systemctl status openclaw

方案二：进程管理器

# 使用 PM2 进程管理器 npm install -g pm2 # PM2 配置 cat > ecosystem.config.js << 'EOF' module.exports = { apps: [{ name: 'openclaw', script: '/usr/local/bin/openclaw', args: '--daemon', instances: 1, autorestart: true, max_restarts: 10, restart_delay: 5000, exp_backoff_restart_delay: 100, max_memory_restart: '4G', // 崩溃处理 kill_timeout: 10000, listen_timeout: 30000, // 日志 error_file: '.openclaw/logs/error.log', out_file: '.openclaw/logs/output.log', merge_logs: true, log_date_format: 'YYYY-MM-DD HH:mm:ss', // 环境 env: { NODE_ENV: 'production', NODE_OPTIONS: '--max-old-space-size=4096' }, // 健康检查 health_check: { interval: 30000, timeout: 5000 } }] }; EOF # 启动 pm2 start ecosystem.config.js pm2 save pm2 startup # 开机自启 # 监控 pm2 monit pm2 logs openclaw pm2 status

方案三：崩溃日志分析

# 创建崩溃日志分析工具 import os import re import json import subprocess from datetime import datetime class CrashAnalyzer: """崩溃日志分析工具""" def __init__(self, crash_dir='.openclaw/logs/crashes/'): self.crash_dir = crash_dir def analyze_latest_crash(self): """分析最近的崩溃""" crash_files = self._get_crash_files() if not crash_files: print("未找到崩溃日志") return None latest = crash_files[0] print(f"分析崩溃日志: {latest}") with open(latest, 'r') as f: content = f.read() analysis = { 'file': latest, 'timestamp': self._extract_timestamp(content), 'signal': self._extract_signal(content), 'fault_address': self._extract_fault_address(content), 'backtrace': self._extract_backtrace(content), 'heap_info': self._extract_heap_info(content), 'module': self._identify_crash_module(content), 'suggestion': None } # 生成建议 analysis['suggestion'] = self._generate_suggestion(analysis) return analysis def _get_crash_files(self): """获取崩溃文件列表（按时间排序）""" if not os.path.isdir(self.crash_dir): return [] files = [os.path.join(self.crash_dir, f) for f in os.listdir(self.crash_dir) if f.startswith('crash_')] files.sort(key=lambda f: os.path.getmtime(f), reverse=True) return files def _extract_timestamp(self, content): """提取时间戳""" match = re.search(r'timestamp:\s*(.+)', content) return match.group(1).strip() if match else 'unknown' def _extract_signal(self, content): """提取信号""" match = re.search(r'signal:\s*(\d+)\s*\((\w+)\)', content) if match: return {'number': int(match.group(1)), 'name': match.group(2)} return None def _extract_fault_address(self, content): """提取错误地址""" match = re.search(f'fault address:\s*(0x[0-9a-fA-F]+)', content) return match.group(1) if match else None def _extract_backtrace(self, content): """提取调用栈""" backtrace = [] in_backtrace = False for line in content.split('\n'): if 'Backtrace:' in line or 'at:' in line: in_backtrace = True continue if in_backtrace: if line.strip() and not line.startswith(' '): break match = re.search(r'\[(0x[0-9a-fA-F]+)\]\s*(.+)', line) if match: backtrace.append({ 'address': match.group(1), 'info': match.group(2).strip() }) return backtrace def _extract_heap_info(self, content): """提取堆信息""" info = {} match = re.search(r'heap.*?(\d+)\s*bytes', content, re.IGNORECASE) if match: info['heap_size'] = int(match.group(1)) match = re.search(r'rss.*?(\d+)\s*bytes', content, re.IGNORECASE) if match: info['rss'] = int(match.group(1)) if 'corrupted' in content.lower(): info['heap_corruption'] = True return info def _identify_crash_module(self, content): """识别崩溃模块""" modules = { 'native addon': r'\.node', 'V8 engine': r'v8::|V8::', 'libuv': r'libuv|uv_', 'openssl': r'openssl|SSL_', 'sqlite': r'sqlite', } for name, pattern in modules.items(): if re.search(pattern, content): return name return 'unknown' def _generate_suggestion(self, analysis): """生成修复建议""" suggestions = [] signal = analysis.get('signal', {}) if signal and signal.get('number') == 11: suggestions.append("SIGSEGV: 检查原生模块是否有空指针/越界访问") if analysis.get('heap_info', {}).get('heap_corruption'): suggestions.append("堆损坏: 检查原生模块的内存管理（双重释放/use-after-free）") module = analysis.get('module', 'unknown') if module == 'native addon': suggestions.append("原生模块崩溃: 更新或替换 .node 模块") elif module == 'V8 engine': suggestions.append("V8 崩溃: 升级 Node.js 版本") if not suggestions: suggestions.append("未知崩溃: 收集核心转储并用 GDB 分析") return suggestions def report(self): """生成报告""" analysis = self.analyze_latest_crash() if not analysis: return print("=" * 60) print("OpenClaw 崩溃分析报告") print("=" * 60) print(f"文件: {analysis['file']}") print(f"时间: {analysis['timestamp']}") if analysis['signal']: print(f"信号: {analysis['signal']['number']} ({analysis['signal']['name']})") if analysis['fault_address']: print(f"错误地址: {analysis['fault_address']}") print(f"崩溃模块: {analysis['module']}") if analysis['backtrace']: print("\n调用栈:") for i, frame in enumerate(analysis['backtrace'][:10]): print(f" #{i}: {frame['address']} {frame['info']}") if analysis['heap_info']: print(f"\n堆信息: {analysis['heap_info']}") if analysis['suggestion']: print("\n建议:") for s in analysis['suggestion']: print(f" → {s}") print("\n" + "=" * 60) if __name__ == "__main__": analyzer = CrashAnalyzer() analyzer.report()

方案四：核心转储分析

# 启用核心转储 ulimit -c unlimited # 当前会话 # 永久设置 echo "ulimit -c unlimited" >> ~/.zshrc # macOS 核心转储 sudo sysctl kern.corefile=/var/core/core.%P # 或使用 Report Crash launchctl load -w /System/Library/LaunchDaemons/com.apple.ReportCrash.Root.plist # Linux 核心转储 echo '/var/core/core.%e.%p.%t' | sudo tee /proc/sys/kernel/core_pattern sudo mkdir -p /var/core sudo chmod 1777 /var/core # 分析核心转储 # 需要 GDB gdb /usr/local/bin/node /var/core/core.openclaw.12345.1234567890 # GDB 命令 (gdb) bt # 完整调用栈 (gdb) bt full # 详细调用栈 (gdb) info registers # 寄存器 (gdb) info threads # 线程信息 (gdb) thread apply all bt # 所有线程调用栈 # 使用 lldb (macOS) lldb -c /var/core/core.12345 (lldb) bt (lldb) thread backtrace all # 自动化分析脚本 cat > .openclaw/analyze_core.sh << 'EOF' #!/bin/bash # 核心转储自动分析 CORE_FILE=$1 NODE_BIN=$(which node) if [ -z "$CORE_FILE" ]; then CORE_FILE=$(ls -t /var/core/core.* 2>/dev/null | head -1) fi if [ -z "$CORE_FILE" ]; then echo "未找到核心转储文件" exit 1 fi echo "分析核心转储: $CORE_FILE" echo "" if command -v gdb &> /dev/null; then echo "=== GDB 分析 ===" gdb -batch -ex "bt" -ex "info registers" -ex "info threads" \ "$NODE_BIN" "$CORE_FILE" 2>/dev/null elif command -v lldb &> /dev/null; then echo "=== LLDB 分析 ===" lldb -c "$CORE_FILE" -o "bt" -o "thread backtrace all" -o "quit" 2>/dev/null else echo "未安装调试器 (GDB/LLDB)" fi EOF chmod +x .openclaw/analyze_core.sh

方案五：内存安全配置

# 配置内存安全选项 python3 -c " import json with open('.openclaw/config.json', 'r') as f: config = json.load(f) config['memory'] = { 'maxHeapSize': 4096, # 最大堆4GB 'maxOldSpace': 2048, # 老年代2GB 'maxYoungSpace': 256, # 新生代256MB 'maxStackSize': 8, # 栈8MB 'gcInterval': 30000, # GC间隔30秒 'gcOnLowMemory': True, # 低内存时GC 'oomProtection': True, # OOM保护 'oomKillPrevent': True, # 阻止OOM Kill 'memoryLeakDetection': True, # 内存泄漏检测 'leakThreshold': 104857600, # 100MB增长阈值 'leakCheckInterval': 300000, # 5分钟检查 'autoRestartOnLeak': True, # 泄漏时重启 'heapSnapshot': { 'enabled': True, # 启用堆快照 'onSignal': True, # 信号触发 'signal': 'SIGUSR2', # SIGUSR2触发 'snapshotDir': '.openclaw/heapdump/' } } with open('.openclaw/config.json', 'w') as f: json.dump(config, f, indent=2) print('内存安全: 4GB堆+OOM保护+泄漏检测+堆快照') " # 使用 AddressSanitizer 检测内存问题（开发环境） # 需要 Debug 版本的 Node.js export NODE_OPTIONS="--max-old-space-size=4096 --abort-on-uncaught-exception" export UV_THREADPOOL_SIZE=16 export NODE_ENV=development # 堆快照分析 kill -USR2 $(cat .openclaw/daemon.pid) # 触发堆快照 # 分析堆快照 # 使用 Chrome DevTools 或 heapdump 分析工具 node -e " const heapdump = require('heapdump'); const fs = require('fs'); // 定期捕获堆快照 setInterval(() => { const file = '.openclaw/heapdump/heap_' + Date.now() + '.heapsnapshot'; heapdump.writeSnapshot(file, (err, filename) => { if (!err) { const size = fs.statSync(filename).size; console.log('堆快照: ' + filename + ' (' + (size/1024/1024).toFixed(1) + 'MB)'); } }); }, 300000); // 5分钟一次 "

方案六：安全沙箱隔离

# 配置沙箱隔离模式 python3 -c " import json with open('.openclaw/config.json', 'r') as f: config = json.load(f) config['sandbox'] = { 'enabled': True, # 启用沙箱 'isolation': 'process', # process | container | vm 'maxProcesses': 4, # 最大工作进程 'restartOnCrash': True, # 崩溃时重启工作进程 'maxWorkerRestarts': 10, # 工作进程最大重启 'workerTimeout': 3600000, # 工作进程1小时超时 'recycleAfter': 100, # 100个请求后回收 'recycleOnMemory': 524288000, # 500MB内存回收 'ipcTimeout': 5000, # IPC超时5秒 'crashIsolation': True # 崩溃隔离 } with open('.openclaw/config.json', 'w') as f: json.dump(config, f, indent=2) print('沙箱隔离: 多工作进程+崩溃隔离+自动回收') " # 创建工作进程管理器 cat > .openclaw/worker_pool.js << 'JEOF' // 工作进程池管理器 const { Worker } = require('worker_threads'); const path = require('path'); const os = require('os'); class WorkerPool { constructor(workerScript, options = {}) { this.workerScript = workerScript; this.maxWorkers = options.maxWorkers || os.cpus().length; this.maxRestarts = options.maxRestarts || 10; this.recycleAfter = options.recycleAfter || 100; this.recycleOnMemory = options.recycleOnMemory || 500 * 1024 * 1024; this.workers = []; this.taskQueue = []; this.stats = { totalTasks: 0, completedTasks: 0, failedTasks: 0, workerRestarts: 0, crashes: 0 }; this.init(); } init() { for (let i = 0; i < this.maxWorkers; i++) { this.createWorker(i); } } createWorker(id) { const worker = new Worker(this.workerScript, { workerData: { workerId: id } }); const workerInfo = { id, worker, tasksHandled: 0, createdAt: Date.now(), isBusy: false, currentTask: null }; worker.on('message', (msg) => { if (msg.type === 'result' && workerInfo.currentTask) { workerInfo.currentTask.resolve(msg.result); workerInfo.isBusy = false; workerInfo.currentTask = null; workerInfo.tasksHandled++; this.stats.completedTasks++; // 检查是否需要回收 if (this.shouldRecycle(workerInfo)) { this.recycleWorker(workerInfo); } else { this.processQueue(); } } else if (msg.type === 'error') { if (workerInfo.currentTask) { workerInfo.currentTask.reject(new Error(msg.error)); workerInfo.isBusy = false; workerInfo.currentTask = null; this.stats.failedTasks++; } } }); worker.on('error', (err) => { console.error(`工作进程 ${id} 错误: ${err.message}`); this.stats.crashes++; this.handleWorkerCrash(workerInfo); }); worker.on('exit', (code) => { if (code !== 0) { console.warn(`工作进程 ${id} 异常退出 (code: ${code})`); this.stats.crashes++; this.handleWorkerCrash(workerInfo); } }); this.workers[id] = workerInfo; } shouldRecycle(workerInfo) { if (workerInfo.tasksHandled >= this.recycleAfter) { return true; } // 检查内存使用（通过 worker.memoryUsage 或 process.report） // 如果内存过高，回收 return false; } recycleWorker(workerInfo) { console.log(`回收工作进程 ${workerInfo.id} (已处理 ${workerInfo.tasksHandled} 个任务)`); workerInfo.worker.terminate(); this.createWorker(workerInfo.id); } handleWorkerCrash(workerInfo) { if (this.stats.workerRestarts < this.maxRestarts) { console.log(`重启工作进程 ${workerInfo.id}`); this.stats.workerRestarts++; // 如果有当前任务，重新入队 if (workerInfo.currentTask) { this.taskQueue.unshift(workerInfo.currentTask); } this.createWorker(workerInfo.id); this.processQueue(); } else { console.error(`工作进程 ${workerInfo.id} 达到最大重启次数`); } } execute(task) { return new Promise((resolve, reject) => { const taskObj = { task, resolve, reject }; this.taskQueue.push(taskObj); this.stats.totalTasks++; this.processQueue(); }); } processQueue() { if (this.taskQueue.length === 0) return; const freeWorker = this.workers.find(w => w && !w.isBusy); if (!freeWorker) return; const taskObj = this.taskQueue.shift(); freeWorker.isBusy = true; freeWorker.currentTask = taskObj; freeWorker.worker.postMessage({ type: 'task', data: taskObj.task }); } getStats() { return { ...this.stats, activeWorkers: this.workers.filter(w => w && w.isBusy).length, totalWorkers: this.workers.length, queueLength: this.taskQueue.length }; } } module.exports = WorkerPool; JEOF

4. 各方案对比总结

5. 常见问题 FAQ

5.1 Windows 上无核心转储

Windows 不使用 core dump 而是使用 minidump：

# Windows 使用 WER (Windows Error Reporting) # 检查 WER Get-EventLog -LogName Application -Source "Application Error" -Newest 5 # 配置 minidump # 注册表: HKLM\SOFTWARE\Microsoft\Windows\Windows Error Reporting\LocalDumps reg add "HKLM\SOFTWARE\Microsoft\Windows\Windows Error Reporting\LocalDumps\openclaw.exe" /v DumpFolder /t REG_EXPAND_SZ /d "C:\CrashDumps" /f reg add "HKLM\SOFTWARE\Microsoft\Windows\Windows Error Reporting\LocalDumps\openclaw.exe" /v DumpType /t REG_DWORD /d 2 /f # 分析 minidump (使用 Visual Studio 或 WinDbg) # WinDbg: File > Open Crash Dump

5.2 Docker 中崩溃处理

容器内崩溃行为不同：

# Docker 重启策略 docker run --restart=unless-stopped openclaw --daemon # Docker Compose services: openclaw: restart: unless-stopped deploy: restart_policy: condition: on-failure max_attempts: 10 delay: 5s window: 120s # 捕获核心转储 docker run --ulimit core=-1:-1 -v /var/core:/var/core openclaw --daemon # Docker 内设置 # 在 Dockerfile 中: # RUN echo '/var/core/core.%e.%p' > /proc/sys/kernel/core_pattern

5.3 CI/CD 中崩溃检测

CI 中进程崩溃需要特殊处理：

steps: - name: Run with crash detection run: | # 设置核心转储 ulimit -c unlimited # 运行并捕获退出码 openclaw --daemon & DAEMON_PID=$! sleep 10 # 检查进程 if ! kill -0 $DAEMON_PID 2>/dev/null; then echo "❌ 守护进程崩溃" # 分析崩溃 if [ -f /var/core/core.* ]; then gdb -batch -ex "bt" node /var/core/core.* fi exit 1 fi echo "✅ 守护进程运行正常" - name: Upload crash logs if: failure() uses: actions/upload-artifact@v3 with: name: crash-logs path: .openclaw/logs/crashes/

5.4 原生模块导致崩溃

第三方 .node 模块导致段错误：

# 识别有问题的原生模块 openclaw --list-native-modules # 输出: # Module Version ABI Path # better-sqlite3 11.0.0 108 node_modules/better-sqlite3 # sharp 0.32.0 108 node_modules/sharp # canvas 2.11.0 108 node_modules/canvas # 测试单个模块 node -e "require('better-sqlite3'); console.log('✅ 加载成功')" # 如果崩溃，该模块有问题 # 更新模块 npm update better-sqlite3 # 或重新编译 npm rebuild better-sqlite3 # 使用 JS 替代原生模块 # 例: better-sqlite3 → sql.js (纯JS) # 例: sharp → jimp (纯JS)

5.5 V8 引擎崩溃

Node.js/V8 本身的 bug：

# 检查 Node.js 版本 node --version # 升级 Node.js（修复已知 bug） nvm install 20.10.0 nvm use 20.10.0 # 使用 LTS 版本 nvm install --lts # 报告 V8 崩溃 node --report # 生成诊断报告 node --v8-options | grep -i "stack" # 配置 V8 标志 export NODE_OPTIONS=" --max-old-space-size=4096 --abort-on-uncaught-exception --report-on-fatalerror --report-directory=.openclaw/reports/ "

5.6 栈溢出导致崩溃

无限递归导致栈溢出：

# 增加栈大小 ulimit -s 65536 # 64MB 栈 # 或在 Node.js 中 export NODE_OPTIONS="--stack-size=65536" # 检测递归 python3 -c " import json with open('.openclaw/config.json', 'r') as f: config = json.load(f) config['safety'] = { 'maxCallDepth': 1000, # 最大调用深度1000 'maxRecursionWarn': 500, # 500层警告 'detectInfiniteLoop': True, # 检测无限循环 'loopTimeout': 5000, # 循环超时5秒 'stackTraceOnDepth': True # 深度过大时打印栈 } with open('.openclaw/config.json', 'w') as f: json.dump(config, f, indent=2) print('递归保护: 最大1000层+500层警告+循环超时') "

5.7 崩溃后数据一致性

崩溃可能导致数据损坏：

# 配置事务性写入 python3 -c " import json with open('.openclaw/config.json', 'r') as f: config = json.load(f) config['storage'] = { 'atomicWrites': True, # 原子写入 'writeAheadLog': True, # WAL日志 'checksumOnWrite': True, # 写入校验 'checksumOnRead': True, # 读取校验 'autoRecover': True, # 自动恢复 'backupInterval': 300000, # 5分钟备份 'fsyncOnWrite': True # 写入后fsync } with open('.openclaw/config.json', 'w') as f: json.dump(config, f, indent=2) print('数据一致性: 原子写入+WAL+校验+自动恢复') " # 崩溃后恢复 openclaw --recover # 自动恢复 openclaw --check-integrity # 检查数据完整性

5.8 生产环境高可用

防止单点崩溃影响服务：

# 配置多实例高可用 python3 -c " import json with open('.openclaw/config.json', 'r') as f: config = json.load(f) config['highAvailability'] = { 'mode': 'active-active', # active-active | active-passive 'instances': 3, # 3个实例 'loadBalancer': 'nginx', # 负载均衡 'healthCheck': '/health', 'failoverTimeout': 5000, # 5秒故障转移 'sharedState': 'redis', # 共享状态 'sessionSticky': True # 会话保持 } with open('.openclaw/config.json', 'w') as f: json.dump(config, f, indent=2) print('高可用: 3实例+active-active+5秒故障转移') " # 负载均衡配置 cat > ~/.openclaw/ha_config.json << 'EOF' { "loadBalancer": { "strategy": "round-robin", "healthCheck": { "interval": 5000, "timeout": 3000, "unhealthyThreshold": 3, "healthyThreshold": 2 }, "failover": { "enabled": true, "delay": 5000 } } } EOF

排查清单速查表

□ 1. 启用自动重启: maxRestarts=10, 退避策略 □ 2. 启用核心转储: ulimit -c unlimited □ 3. 使用 PM2 或 systemd 管理进程 □ 4. 分析崩溃日志: 信号/调用栈/模块 □ 5. 检查原生模块: 更新或替换 □ 6. 配置内存安全: OOM保护+泄漏检测 □ 7. 配置健康检查: 30秒间隔+3次失败重启 □ 8. 使用沙箱工作进程隔离崩溃 □ 9. 原子写入+WAL防止数据损坏 □ 10. 部署多实例高可用

6. 总结

1. 最常见原因：原生模块（N-API/C++）内存安全 bug（30%）和内存泄漏导致 OOM 段错误（25%）
2. 自动恢复：配置autoRestart=true，maxRestarts=10，指数退避重启，PM2/systemd 管理进程
3. 崩溃分析：启用核心转储，用 GDB/LLDB 分析调用栈，识别崩溃模块（原生模块/V8/libuv）
4. 内存安全：配置 OOM 保护、内存泄漏检测（100MB 阈值）、定期堆快照分析
5. 最佳实践建议：使用工作进程池沙箱隔离崩溃（单个工作进程崩溃不影响主进程），配置原子写入和 WAL 日志防止崩溃后数据损坏，部署多实例高可用架构（active-active + 5 秒故障转移），原生模块优先使用纯 JS 替代方案

故障排查流程图

flowchart TD A[守护进程崩溃] --> B[检查崩溃日志] B --> C[分析信号类型] C --> D{SIGSEGV?} D -->|是| E[段错误] D -->|SIGABRT| F[内存损坏] D -->|SIGKILL| G[OOM Kill] E --> H[检查原生模块] F --> I[检查内存管理] G --> J[增加内存限制] H --> K[更新/替换.node模块] I --> L[启用ASAN检测] J --> M[max-old-space-size=4096] K --> N[配置自动重启] L --> N M --> N N --> O[maxRestarts=10+退避] O --> P[PM2/systemd管理] P --> Q[openclaw --daemon测试] Q --> R{稳定?} R -->|是| S[✅ 问题解决] R -->|否| T[分析核心转储] T --> U[GDB/LLDB调用栈] U --> V[使用沙箱工作进程] V --> W[多实例高可用] W --> S S --> X[部署监控告警] X --> Y[✅ 长期稳定]