platform: Add OOM Report & Crash Report

experimental/libbox/command_client.go

@@ -540,6 +540,31 @@ func (c *CommandClient) SetSystemProxyEnabled(isEnabled bool) error {
 	return err
 }
 
+func (c *CommandClient) TriggerGoCrash() error {
+	_, err := callWithResult(c, func(client daemon.StartedServiceClient) (*emptypb.Empty, error) {
+		return client.TriggerDebugCrash(context.Background(), &daemon.DebugCrashRequest{
+			Type: daemon.DebugCrashRequest_GO,
+		})
+	})
+	return err
+}
+
+func (c *CommandClient) TriggerNativeCrash() error {
+	_, err := callWithResult(c, func(client daemon.StartedServiceClient) (*emptypb.Empty, error) {
+		return client.TriggerDebugCrash(context.Background(), &daemon.DebugCrashRequest{
+			Type: daemon.DebugCrashRequest_NATIVE,
+		})
+	})
+	return err
+}
+
+func (c *CommandClient) TriggerOOMReport() error {
+	_, err := callWithResult(c, func(client daemon.StartedServiceClient) (*emptypb.Empty, error) {
+		return client.TriggerOOMReport(context.Background(), &emptypb.Empty{})
+	})
+	return err
+}
+
 func (c *CommandClient) GetDeprecatedNotes() (DeprecatedNoteIterator, error) {
 	return callWithResult(c, func(client daemon.StartedServiceClient) (DeprecatedNoteIterator, error) {
 		warnings, err := client.GetDeprecatedWarnings(context.Background(), &emptypb.Empty{})

experimental/libbox/command_server.go

@@ -39,6 +39,7 @@ type CommandServerHandler interface {
 	ServiceReload() error
 	GetSystemProxyStatus() (*SystemProxyStatus, error)
 	SetSystemProxyEnabled(enabled bool) error
+	TriggerNativeCrash() error
 	WriteDebugMessage(message string)
 }
 
@@ -57,10 +58,12 @@ func NewCommandServer(handler CommandServerHandler, platformInterface PlatformIn
 	server.StartedService = daemon.NewStartedService(daemon.ServiceOptions{
 		Context: ctx,
 		// Platform:         platformWrapper,
-		Handler:     (*platformHandler)(server),
-		Debug:       sDebug,
-		LogMaxLines: sLogMaxLines,
-		OOMKiller:   memoryLimitEnabled,
+		Handler:           (*platformHandler)(server),
+		Debug:             sDebug,
+		LogMaxLines:       sLogMaxLines,
+		OOMKillerEnabled:  sOOMKillerEnabled,
+		OOMKillerDisabled: sOOMKillerDisabled,
+		OOMMemoryLimit:    uint64(sOOMMemoryLimit),
 		// WorkingDirectory: sWorkingPath,
 		// TempDirectory:    sTempPath,
 		// UserID:           sUserID,
@@ -170,11 +173,16 @@ type OverrideOptions struct {
 }
 
 func (s *CommandServer) StartOrReloadService(configContent string, options *OverrideOptions) error {
-	return s.StartedService.StartOrReloadService(configContent, &daemon.OverrideOptions{
+	saveConfigSnapshot(configContent)
+	err := s.StartedService.StartOrReloadService(configContent, &daemon.OverrideOptions{
 		AutoRedirect:   options.AutoRedirect,
 		IncludePackage: iteratorToArray(options.IncludePackage),
 		ExcludePackage: iteratorToArray(options.ExcludePackage),
 	})
+	if err != nil {
+		return err
+	}
+	return nil
 }
 
 func (s *CommandServer) CloseService() error {
@@ -271,6 +279,10 @@ func (h *platformHandler) SetSystemProxyEnabled(enabled bool) error {
 	return (*CommandServer)(h).handler.SetSystemProxyEnabled(enabled)
 }
 
+func (h *platformHandler) TriggerNativeCrash() error {
+	return (*CommandServer)(h).handler.TriggerNativeCrash()
+}
+
 func (h *platformHandler) WriteDebugMessage(message string) {
 	(*CommandServer)(h).handler.WriteDebugMessage(message)
 }

experimental/libbox/config.go

@@ -12,6 +12,7 @@ import (
 	"github.com/sagernet/sing-box/include"
 	"github.com/sagernet/sing-box/log"
 	"github.com/sagernet/sing-box/option"
+	"github.com/sagernet/sing-box/service/oomkiller"
 	tun "github.com/sagernet/sing-tun"
 	"github.com/sagernet/sing/common/control"
 	E "github.com/sagernet/sing/common/exceptions"
@@ -22,6 +23,8 @@ import (
 	"github.com/sagernet/sing/service/filemanager"
 )
 
+var sOOMReporter oomkiller.OOMReporter
+
 func baseContext(platformInterface PlatformInterface) context.Context {
 	dnsRegistry := include.DNSTransportRegistry()
 	if platformInterface != nil {
@@ -33,6 +36,9 @@ func baseContext(platformInterface PlatformInterface) context.Context {
 	}
 	ctx := context.Background()
 	ctx = filemanager.WithDefault(ctx, sWorkingPath, sTempPath, sUserID, sGroupID)
+	if sOOMReporter != nil {
+		ctx = service.ContextWith[oomkiller.OOMReporter](ctx, sOOMReporter)
+	}
 	return box.Context(ctx, include.InboundRegistry(), include.OutboundRegistry(), include.EndpointRegistry(), dnsRegistry, include.ServiceRegistry(), include.CertificateProviderRegistry())
 }
 

experimental/libbox/debug.go

@@ -0,0 +1,9 @@
+package libbox
+
+import "time"
+
+func TriggerGoPanic() {
+	time.AfterFunc(200*time.Millisecond, func() {
+		panic("debug go crash")
+	})
+}

experimental/libbox/internal/oomprofile/builder.go

@@ -0,0 +1,390 @@
+//go:build darwin || linux || windows
+
+package oomprofile
+
+import (
+	"fmt"
+	"io"
+	"runtime"
+	"time"
+)
+
+const (
+	tagProfile_SampleType        = 1
+	tagProfile_Sample            = 2
+	tagProfile_Mapping           = 3
+	tagProfile_Location          = 4
+	tagProfile_Function          = 5
+	tagProfile_StringTable       = 6
+	tagProfile_TimeNanos         = 9
+	tagProfile_PeriodType        = 11
+	tagProfile_Period            = 12
+	tagProfile_DefaultSampleType = 14
+
+	tagValueType_Type = 1
+	tagValueType_Unit = 2
+
+	tagSample_Location = 1
+	tagSample_Value    = 2
+	tagSample_Label    = 3
+
+	tagLabel_Key = 1
+	tagLabel_Str = 2
+	tagLabel_Num = 3
+
+	tagMapping_ID              = 1
+	tagMapping_Start           = 2
+	tagMapping_Limit           = 3
+	tagMapping_Offset          = 4
+	tagMapping_Filename        = 5
+	tagMapping_BuildID         = 6
+	tagMapping_HasFunctions    = 7
+	tagMapping_HasFilenames    = 8
+	tagMapping_HasLineNumbers  = 9
+	tagMapping_HasInlineFrames = 10
+
+	tagLocation_ID        = 1
+	tagLocation_MappingID = 2
+	tagLocation_Address   = 3
+	tagLocation_Line      = 4
+
+	tagLine_FunctionID = 1
+	tagLine_Line       = 2
+
+	tagFunction_ID         = 1
+	tagFunction_Name       = 2
+	tagFunction_SystemName = 3
+	tagFunction_Filename   = 4
+	tagFunction_StartLine  = 5
+)
+
+type memMap struct {
+	start   uintptr
+	end     uintptr
+	offset  uint64
+	file    string
+	buildID string
+	funcs   symbolizeFlag
+	fake    bool
+}
+
+type symbolizeFlag uint8
+
+const (
+	lookupTried symbolizeFlag = 1 << iota
+	lookupFailed
+)
+
+func newProfileBuilder(w io.Writer) *profileBuilder {
+	builder := &profileBuilder{
+		start:     time.Now(),
+		w:         w,
+		strings:   []string{""},
+		stringMap: map[string]int{"": 0},
+		locs:      map[uintptr]locInfo{},
+		funcs:     map[string]int{},
+	}
+	builder.readMapping()
+	return builder
+}
+
+func (b *profileBuilder) stringIndex(s string) int64 {
+	id, ok := b.stringMap[s]
+	if !ok {
+		id = len(b.strings)
+		b.strings = append(b.strings, s)
+		b.stringMap[s] = id
+	}
+	return int64(id)
+}
+
+func (b *profileBuilder) flush() {
+	const dataFlush = 4096
+	if b.err != nil || b.pb.nest != 0 || len(b.pb.data) <= dataFlush {
+		return
+	}
+
+	_, b.err = b.w.Write(b.pb.data)
+	b.pb.data = b.pb.data[:0]
+}
+
+func (b *profileBuilder) pbValueType(tag int, typ string, unit string) {
+	start := b.pb.startMessage()
+	b.pb.int64(tagValueType_Type, b.stringIndex(typ))
+	b.pb.int64(tagValueType_Unit, b.stringIndex(unit))
+	b.pb.endMessage(tag, start)
+}
+
+func (b *profileBuilder) pbSample(values []int64, locs []uint64, labels func()) {
+	start := b.pb.startMessage()
+	b.pb.int64s(tagSample_Value, values)
+	b.pb.uint64s(tagSample_Location, locs)
+	if labels != nil {
+		labels()
+	}
+	b.pb.endMessage(tagProfile_Sample, start)
+	b.flush()
+}
+
+func (b *profileBuilder) pbLabel(tag int, key string, str string, num int64) {
+	start := b.pb.startMessage()
+	b.pb.int64Opt(tagLabel_Key, b.stringIndex(key))
+	b.pb.int64Opt(tagLabel_Str, b.stringIndex(str))
+	b.pb.int64Opt(tagLabel_Num, num)
+	b.pb.endMessage(tag, start)
+}
+
+func (b *profileBuilder) pbLine(tag int, funcID uint64, line int64) {
+	start := b.pb.startMessage()
+	b.pb.uint64Opt(tagLine_FunctionID, funcID)
+	b.pb.int64Opt(tagLine_Line, line)
+	b.pb.endMessage(tag, start)
+}
+
+func (b *profileBuilder) pbMapping(tag int, id uint64, base uint64, limit uint64, offset uint64, file string, buildID string, hasFuncs bool) {
+	start := b.pb.startMessage()
+	b.pb.uint64Opt(tagMapping_ID, id)
+	b.pb.uint64Opt(tagMapping_Start, base)
+	b.pb.uint64Opt(tagMapping_Limit, limit)
+	b.pb.uint64Opt(tagMapping_Offset, offset)
+	b.pb.int64Opt(tagMapping_Filename, b.stringIndex(file))
+	b.pb.int64Opt(tagMapping_BuildID, b.stringIndex(buildID))
+	if hasFuncs {
+		b.pb.bool(tagMapping_HasFunctions, true)
+	}
+	b.pb.endMessage(tag, start)
+}
+
+func (b *profileBuilder) build() error {
+	if b.err != nil {
+		return b.err
+	}
+
+	b.pb.int64Opt(tagProfile_TimeNanos, b.start.UnixNano())
+	for i, mapping := range b.mem {
+		hasFunctions := mapping.funcs == lookupTried
+		b.pbMapping(tagProfile_Mapping, uint64(i+1), uint64(mapping.start), uint64(mapping.end), mapping.offset, mapping.file, mapping.buildID, hasFunctions)
+	}
+	b.pb.strings(tagProfile_StringTable, b.strings)
+	if b.err != nil {
+		return b.err
+	}
+	_, err := b.w.Write(b.pb.data)
+	return err
+}
+
+func allFrames(addr uintptr) ([]runtime.Frame, symbolizeFlag) {
+	frames := runtime.CallersFrames([]uintptr{addr})
+	frame, more := frames.Next()
+	if frame.Function == "runtime.goexit" {
+		return nil, 0
+	}
+
+	result := lookupTried
+	if frame.PC == 0 || frame.Function == "" || frame.File == "" || frame.Line == 0 {
+		result |= lookupFailed
+	}
+	if frame.PC == 0 {
+		frame.PC = addr - 1
+	}
+
+	ret := []runtime.Frame{frame}
+	for frame.Function != "runtime.goexit" && more {
+		frame, more = frames.Next()
+		ret = append(ret, frame)
+	}
+	return ret, result
+}
+
+type locInfo struct {
+	id uint64
+
+	pcs []uintptr
+
+	firstPCFrames          []runtime.Frame
+	firstPCSymbolizeResult symbolizeFlag
+}
+
+func (b *profileBuilder) appendLocsForStack(locs []uint64, stk []uintptr) []uint64 {
+	b.deck.reset()
+	origStk := stk
+	stk = runtimeExpandFinalInlineFrame(stk)
+
+	for len(stk) > 0 {
+		addr := stk[0]
+		if loc, ok := b.locs[addr]; ok {
+			if len(b.deck.pcs) > 0 {
+				if b.deck.tryAdd(addr, loc.firstPCFrames, loc.firstPCSymbolizeResult) {
+					stk = stk[1:]
+					continue
+				}
+			}
+			if id := b.emitLocation(); id > 0 {
+				locs = append(locs, id)
+			}
+			locs = append(locs, loc.id)
+			if len(loc.pcs) > len(stk) {
+				panic(fmt.Sprintf("stack too short to match cached location; stk = %#x, loc.pcs = %#x, original stk = %#x", stk, loc.pcs, origStk))
+			}
+			stk = stk[len(loc.pcs):]
+			continue
+		}
+
+		frames, symbolizeResult := allFrames(addr)
+		if len(frames) == 0 {
+			if id := b.emitLocation(); id > 0 {
+				locs = append(locs, id)
+			}
+			stk = stk[1:]
+			continue
+		}
+
+		if b.deck.tryAdd(addr, frames, symbolizeResult) {
+			stk = stk[1:]
+			continue
+		}
+		if id := b.emitLocation(); id > 0 {
+			locs = append(locs, id)
+		}
+
+		if loc, ok := b.locs[addr]; ok {
+			locs = append(locs, loc.id)
+			stk = stk[len(loc.pcs):]
+		} else {
+			b.deck.tryAdd(addr, frames, symbolizeResult)
+			stk = stk[1:]
+		}
+	}
+	if id := b.emitLocation(); id > 0 {
+		locs = append(locs, id)
+	}
+	return locs
+}
+
+type pcDeck struct {
+	pcs             []uintptr
+	frames          []runtime.Frame
+	symbolizeResult symbolizeFlag
+
+	firstPCFrames          int
+	firstPCSymbolizeResult symbolizeFlag
+}
+
+func (d *pcDeck) reset() {
+	d.pcs = d.pcs[:0]
+	d.frames = d.frames[:0]
+	d.symbolizeResult = 0
+	d.firstPCFrames = 0
+	d.firstPCSymbolizeResult = 0
+}
+
+func (d *pcDeck) tryAdd(pc uintptr, frames []runtime.Frame, symbolizeResult symbolizeFlag) bool {
+	if existing := len(d.frames); existing > 0 {
+		newFrame := frames[0]
+		last := d.frames[existing-1]
+		if last.Func != nil {
+			return false
+		}
+		if last.Entry == 0 || newFrame.Entry == 0 {
+			return false
+		}
+		if last.Entry != newFrame.Entry {
+			return false
+		}
+		if runtimeFrameSymbolName(&last) == runtimeFrameSymbolName(&newFrame) {
+			return false
+		}
+	}
+
+	d.pcs = append(d.pcs, pc)
+	d.frames = append(d.frames, frames...)
+	d.symbolizeResult |= symbolizeResult
+	if len(d.pcs) == 1 {
+		d.firstPCFrames = len(d.frames)
+		d.firstPCSymbolizeResult = symbolizeResult
+	}
+	return true
+}
+
+func (b *profileBuilder) emitLocation() uint64 {
+	if len(b.deck.pcs) == 0 {
+		return 0
+	}
+	defer b.deck.reset()
+
+	addr := b.deck.pcs[0]
+	firstFrame := b.deck.frames[0]
+
+	type newFunc struct {
+		id        uint64
+		name      string
+		file      string
+		startLine int64
+	}
+
+	newFuncs := make([]newFunc, 0, 8)
+	id := uint64(len(b.locs)) + 1
+	b.locs[addr] = locInfo{
+		id:                     id,
+		pcs:                    append([]uintptr{}, b.deck.pcs...),
+		firstPCFrames:          append([]runtime.Frame{}, b.deck.frames[:b.deck.firstPCFrames]...),
+		firstPCSymbolizeResult: b.deck.firstPCSymbolizeResult,
+	}
+
+	start := b.pb.startMessage()
+	b.pb.uint64Opt(tagLocation_ID, id)
+	b.pb.uint64Opt(tagLocation_Address, uint64(firstFrame.PC))
+	for _, frame := range b.deck.frames {
+		funcName := runtimeFrameSymbolName(&frame)
+		funcID := uint64(b.funcs[funcName])
+		if funcID == 0 {
+			funcID = uint64(len(b.funcs)) + 1
+			b.funcs[funcName] = int(funcID)
+			newFuncs = append(newFuncs, newFunc{
+				id:        funcID,
+				name:      funcName,
+				file:      frame.File,
+				startLine: int64(runtimeFrameStartLine(&frame)),
+			})
+		}
+		b.pbLine(tagLocation_Line, funcID, int64(frame.Line))
+	}
+	for i := range b.mem {
+		if (b.mem[i].start <= addr && addr < b.mem[i].end) || b.mem[i].fake {
+			b.pb.uint64Opt(tagLocation_MappingID, uint64(i+1))
+			mapping := b.mem[i]
+			mapping.funcs |= b.deck.symbolizeResult
+			b.mem[i] = mapping
+			break
+		}
+	}
+	b.pb.endMessage(tagProfile_Location, start)
+
+	for _, fn := range newFuncs {
+		start := b.pb.startMessage()
+		b.pb.uint64Opt(tagFunction_ID, fn.id)
+		b.pb.int64Opt(tagFunction_Name, b.stringIndex(fn.name))
+		b.pb.int64Opt(tagFunction_SystemName, b.stringIndex(fn.name))
+		b.pb.int64Opt(tagFunction_Filename, b.stringIndex(fn.file))
+		b.pb.int64Opt(tagFunction_StartLine, fn.startLine)
+		b.pb.endMessage(tagProfile_Function, start)
+	}
+
+	b.flush()
+	return id
+}
+
+func (b *profileBuilder) addMapping(lo uint64, hi uint64, offset uint64, file string, buildID string) {
+	b.addMappingEntry(lo, hi, offset, file, buildID, false)
+}
+
+func (b *profileBuilder) addMappingEntry(lo uint64, hi uint64, offset uint64, file string, buildID string, fake bool) {
+	b.mem = append(b.mem, memMap{
+		start:   uintptr(lo),
+		end:     uintptr(hi),
+		offset:  offset,
+		file:    file,
+		buildID: buildID,
+		fake:    fake,
+	})
+}

experimental/libbox/internal/oomprofile/defs_darwin_amd64.go

@@ -0,0 +1,24 @@
+//go:build darwin && amd64
+
+package oomprofile
+
+type machVMRegionBasicInfoData struct {
+	Protection     int32
+	MaxProtection  int32
+	Inheritance    uint32
+	Shared         uint32
+	Reserved       uint32
+	Offset         [8]byte
+	Behavior       int32
+	UserWiredCount uint16
+	PadCgo1        [2]byte
+}
+
+const (
+	_VM_PROT_READ    = 0x1
+	_VM_PROT_EXECUTE = 0x4
+
+	_MACH_SEND_INVALID_DEST = 0x10000003
+
+	_MAXPATHLEN = 0x400
+)

experimental/libbox/internal/oomprofile/defs_darwin_arm64.go

@@ -0,0 +1,24 @@
+//go:build darwin && arm64
+
+package oomprofile
+
+type machVMRegionBasicInfoData struct {
+	Protection     int32
+	MaxProtection  int32
+	Inheritance    uint32
+	Shared         int32
+	Reserved       int32
+	Offset         [8]byte
+	Behavior       int32
+	UserWiredCount uint16
+	PadCgo1        [2]byte
+}
+
+const (
+	_VM_PROT_READ    = 0x1
+	_VM_PROT_EXECUTE = 0x4
+
+	_MACH_SEND_INVALID_DEST = 0x10000003
+
+	_MAXPATHLEN = 0x400
+)

experimental/libbox/internal/oomprofile/linkname.go

@@ -0,0 +1,47 @@
+//go:build darwin || linux || windows
+
+package oomprofile
+
+import (
+	"runtime"
+	_ "runtime/pprof"
+	"unsafe"
+
+	_ "unsafe"
+)
+
+//go:linkname runtimeMemProfileInternal runtime.pprof_memProfileInternal
+func runtimeMemProfileInternal(p []memProfileRecord, inuseZero bool) (n int, ok bool)
+
+//go:linkname runtimeBlockProfileInternal runtime.pprof_blockProfileInternal
+func runtimeBlockProfileInternal(p []blockProfileRecord) (n int, ok bool)
+
+//go:linkname runtimeMutexProfileInternal runtime.pprof_mutexProfileInternal
+func runtimeMutexProfileInternal(p []blockProfileRecord) (n int, ok bool)
+
+//go:linkname runtimeThreadCreateInternal runtime.pprof_threadCreateInternal
+func runtimeThreadCreateInternal(p []stackRecord) (n int, ok bool)
+
+//go:linkname runtimeGoroutineProfileWithLabels runtime.pprof_goroutineProfileWithLabels
+func runtimeGoroutineProfileWithLabels(p []stackRecord, labels []unsafe.Pointer) (n int, ok bool)
+
+//go:linkname runtimeCyclesPerSecond runtime/pprof.runtime_cyclesPerSecond
+func runtimeCyclesPerSecond() int64
+
+//go:linkname runtimeMakeProfStack runtime.pprof_makeProfStack
+func runtimeMakeProfStack() []uintptr
+
+//go:linkname runtimeFrameStartLine runtime/pprof.runtime_FrameStartLine
+func runtimeFrameStartLine(f *runtime.Frame) int
+
+//go:linkname runtimeFrameSymbolName runtime/pprof.runtime_FrameSymbolName
+func runtimeFrameSymbolName(f *runtime.Frame) string
+
+//go:linkname runtimeExpandFinalInlineFrame runtime/pprof.runtime_expandFinalInlineFrame
+func runtimeExpandFinalInlineFrame(stk []uintptr) []uintptr
+
+//go:linkname stdParseProcSelfMaps runtime/pprof.parseProcSelfMaps
+func stdParseProcSelfMaps(data []byte, addMapping func(lo uint64, hi uint64, offset uint64, file string, buildID string))
+
+//go:linkname stdELFBuildID runtime/pprof.elfBuildID
+func stdELFBuildID(file string) (string, error)

experimental/libbox/internal/oomprofile/mapping_darwin.go

@@ -0,0 +1,57 @@
+//go:build darwin
+
+package oomprofile
+
+import (
+	"encoding/binary"
+	"os"
+	"unsafe"
+
+	_ "unsafe"
+)
+
+func isExecutable(protection int32) bool {
+	return (protection&_VM_PROT_EXECUTE) != 0 && (protection&_VM_PROT_READ) != 0
+}
+
+func (b *profileBuilder) readMapping() {
+	if !machVMInfo(b.addMapping) {
+		b.addMappingEntry(0, 0, 0, "", "", true)
+	}
+}
+
+func machVMInfo(addMapping func(lo uint64, hi uint64, off uint64, file string, buildID string)) bool {
+	added := false
+	addr := uint64(0x1)
+	for {
+		var regionSize uint64
+		var info machVMRegionBasicInfoData
+		kr := machVMRegion(&addr, &regionSize, unsafe.Pointer(&info))
+		if kr != 0 {
+			if kr == _MACH_SEND_INVALID_DEST {
+				return true
+			}
+			return added
+		}
+		if isExecutable(info.Protection) {
+			addMapping(addr, addr+regionSize, binary.LittleEndian.Uint64(info.Offset[:]), regionFilename(addr), "")
+			added = true
+		}
+		addr += regionSize
+	}
+}
+
+func regionFilename(address uint64) string {
+	buf := make([]byte, _MAXPATHLEN)
+	n := procRegionFilename(os.Getpid(), address, unsafe.SliceData(buf), int64(cap(buf)))
+	if n == 0 {
+		return ""
+	}
+	return string(buf[:n])
+}
+
+//go:linkname machVMRegion runtime/pprof.mach_vm_region
+func machVMRegion(address *uint64, regionSize *uint64, info unsafe.Pointer) int32
+
+//go:linkname procRegionFilename runtime/pprof.proc_regionfilename
+func procRegionFilename(pid int, address uint64, buf *byte, buflen int64) int32

experimental/libbox/internal/oomprofile/mapping_linux.go

@@ -0,0 +1,13 @@
+//go:build linux
+
+package oomprofile
+
+import "os"
+
+func (b *profileBuilder) readMapping() {
+	data, _ := os.ReadFile("/proc/self/maps")
+	stdParseProcSelfMaps(data, b.addMapping)
+	if len(b.mem) == 0 {
+		b.addMappingEntry(0, 0, 0, "", "", true)
+	}
+}

experimental/libbox/internal/oomprofile/mapping_windows.go

@@ -0,0 +1,58 @@
+//go:build windows
+
+package oomprofile
+
+import (
+	"errors"
+	"os"
+
+	"golang.org/x/sys/windows"
+)
+
+func (b *profileBuilder) readMapping() {
+	snapshot, err := createModuleSnapshot()
+	if err != nil {
+		b.addMappingEntry(0, 0, 0, "", "", true)
+		return
+	}
+	defer windows.CloseHandle(snapshot)
+
+	var module windows.ModuleEntry32
+	module.Size = uint32(windows.SizeofModuleEntry32)
+	err = windows.Module32First(snapshot, &module)
+	if err != nil {
+		b.addMappingEntry(0, 0, 0, "", "", true)
+		return
+	}
+	for err == nil {
+		exe := windows.UTF16ToString(module.ExePath[:])
+		b.addMappingEntry(
+			uint64(module.ModBaseAddr),
+			uint64(module.ModBaseAddr)+uint64(module.ModBaseSize),
+			0,
+			exe,
+			peBuildID(exe),
+			false,
+		)
+		err = windows.Module32Next(snapshot, &module)
+	}
+}
+
+func createModuleSnapshot() (windows.Handle, error) {
+	for {
+		snapshot, err := windows.CreateToolhelp32Snapshot(windows.TH32CS_SNAPMODULE|windows.TH32CS_SNAPMODULE32, uint32(windows.GetCurrentProcessId()))
+		var errno windows.Errno
+		if err != nil && errors.As(err, &errno) && errno == windows.ERROR_BAD_LENGTH {
+			continue
+		}
+		return snapshot, err
+	}
+}
+
+func peBuildID(file string) string {
+	info, err := os.Stat(file)
+	if err != nil {
+		return file
+	}
+	return file + info.ModTime().String()
+}

experimental/libbox/internal/oomprofile/oomprofile.go

@@ -0,0 +1,380 @@
+//go:build darwin || linux || windows
+
+package oomprofile
+
+import (
+	"fmt"
+	"io"
+	"math"
+	"os"
+	"path/filepath"
+	"runtime"
+	"sort"
+	"strings"
+	"time"
+	"unsafe"
+)
+
+type stackRecord struct {
+	Stack []uintptr
+}
+
+type memProfileRecord struct {
+	AllocBytes, FreeBytes     int64
+	AllocObjects, FreeObjects int64
+	Stack                     []uintptr
+}
+
+func (r *memProfileRecord) InUseBytes() int64 {
+	return r.AllocBytes - r.FreeBytes
+}
+
+func (r *memProfileRecord) InUseObjects() int64 {
+	return r.AllocObjects - r.FreeObjects
+}
+
+type blockProfileRecord struct {
+	Count  int64
+	Cycles int64
+	Stack  []uintptr
+}
+
+type label struct {
+	key   string
+	value string
+}
+
+type labelSet struct {
+	list []label
+}
+
+type labelMap struct {
+	labelSet
+}
+
+func WriteFile(destPath string, name string) (string, error) {
+	writer, ok := profileWriters[name]
+	if !ok {
+		return "", fmt.Errorf("unsupported profile %q", name)
+	}
+
+	filePath := filepath.Join(destPath, name+".pb")
+	file, err := os.Create(filePath)
+	if err != nil {
+		return "", err
+	}
+	defer file.Close()
+
+	if err := writer(file); err != nil {
+		_ = os.Remove(filePath)
+		return "", err
+	}
+	if err := file.Close(); err != nil {
+		_ = os.Remove(filePath)
+		return "", err
+	}
+	return filePath, nil
+}
+
+var profileWriters = map[string]func(io.Writer) error{
+	"allocs":       writeAlloc,
+	"block":        writeBlock,
+	"goroutine":    writeGoroutine,
+	"heap":         writeHeap,
+	"mutex":        writeMutex,
+	"threadcreate": writeThreadCreate,
+}
+
+func writeHeap(w io.Writer) error {
+	return writeHeapInternal(w, "")
+}
+
+func writeAlloc(w io.Writer) error {
+	return writeHeapInternal(w, "alloc_space")
+}
+
+func writeHeapInternal(w io.Writer, defaultSampleType string) error {
+	var profile []memProfileRecord
+	n, ok := runtimeMemProfileInternal(nil, true)
+	for {
+		profile = make([]memProfileRecord, n+50)
+		n, ok = runtimeMemProfileInternal(profile, true)
+		if ok {
+			profile = profile[:n]
+			break
+		}
+	}
+	return writeHeapProto(w, profile, int64(runtime.MemProfileRate), defaultSampleType)
+}
+
+func writeGoroutine(w io.Writer) error {
+	return writeRuntimeProfile(w, "goroutine", runtimeGoroutineProfileWithLabels)
+}
+
+func writeThreadCreate(w io.Writer) error {
+	return writeRuntimeProfile(w, "threadcreate", func(p []stackRecord, _ []unsafe.Pointer) (int, bool) {
+		return runtimeThreadCreateInternal(p)
+	})
+}
+
+func writeRuntimeProfile(w io.Writer, name string, fetch func([]stackRecord, []unsafe.Pointer) (int, bool)) error {
+	var profile []stackRecord
+	var labels []unsafe.Pointer
+
+	n, ok := fetch(nil, nil)
+	for {
+		profile = make([]stackRecord, n+10)
+		labels = make([]unsafe.Pointer, n+10)
+		n, ok = fetch(profile, labels)
+		if ok {
+			profile = profile[:n]
+			labels = labels[:n]
+			break
+		}
+	}
+
+	return writeCountProfile(w, name, &runtimeProfile{profile, labels})
+}
+
+func writeBlock(w io.Writer) error {
+	return writeCycleProfile(w, "contentions", "delay", runtimeBlockProfileInternal)
+}
+
+func writeMutex(w io.Writer) error {
+	return writeCycleProfile(w, "contentions", "delay", runtimeMutexProfileInternal)
+}
+
+func writeCycleProfile(w io.Writer, countName string, cycleName string, fetch func([]blockProfileRecord) (int, bool)) error {
+	var profile []blockProfileRecord
+	n, ok := fetch(nil)
+	for {
+		profile = make([]blockProfileRecord, n+50)
+		n, ok = fetch(profile)
+		if ok {
+			profile = profile[:n]
+			break
+		}
+	}
+
+	sort.Slice(profile, func(i, j int) bool {
+		return profile[i].Cycles > profile[j].Cycles
+	})
+
+	builder := newProfileBuilder(w)
+	builder.pbValueType(tagProfile_PeriodType, countName, "count")
+	builder.pb.int64Opt(tagProfile_Period, 1)
+	builder.pbValueType(tagProfile_SampleType, countName, "count")
+	builder.pbValueType(tagProfile_SampleType, cycleName, "nanoseconds")
+
+	cpuGHz := float64(runtimeCyclesPerSecond()) / 1e9
+	values := []int64{0, 0}
+	var locs []uint64
+	expandedStack := runtimeMakeProfStack()
+	for _, record := range profile {
+		values[0] = record.Count
+		if cpuGHz > 0 {
+			values[1] = int64(float64(record.Cycles) / cpuGHz)
+		} else {
+			values[1] = 0
+		}
+		n := expandInlinedFrames(expandedStack, record.Stack)
+		locs = builder.appendLocsForStack(locs[:0], expandedStack[:n])
+		builder.pbSample(values, locs, nil)
+	}
+
+	return builder.build()
+}
+
+type countProfile interface {
+	Len() int
+	Stack(i int) []uintptr
+	Label(i int) *labelMap
+}
+
+type runtimeProfile struct {
+	stk    []stackRecord
+	labels []unsafe.Pointer
+}
+
+func (p *runtimeProfile) Len() int {
+	return len(p.stk)
+}
+
+func (p *runtimeProfile) Stack(i int) []uintptr {
+	return p.stk[i].Stack
+}
+
+func (p *runtimeProfile) Label(i int) *labelMap {
+	return (*labelMap)(p.labels[i])
+}
+
+func writeCountProfile(w io.Writer, name string, profile countProfile) error {
+	var buf strings.Builder
+	key := func(stk []uintptr, labels *labelMap) string {
+		buf.Reset()
+		buf.WriteByte('@')
+		for _, pc := range stk {
+			fmt.Fprintf(&buf, " %#x", pc)
+		}
+		if labels != nil {
+			buf.WriteString("\n# labels:")
+			for _, label := range labels.list {
+				fmt.Fprintf(&buf, " %q:%q", label.key, label.value)
+			}
+		}
+		return buf.String()
+	}
+
+	counts := make(map[string]int)
+	index := make(map[string]int)
+	var keys []string
+	for i := 0; i < profile.Len(); i++ {
+		k := key(profile.Stack(i), profile.Label(i))
+		if counts[k] == 0 {
+			index[k] = i
+			keys = append(keys, k)
+		}
+		counts[k]++
+	}
+
+	sort.Sort(&keysByCount{keys: keys, count: counts})
+
+	builder := newProfileBuilder(w)
+	builder.pbValueType(tagProfile_PeriodType, name, "count")
+	builder.pb.int64Opt(tagProfile_Period, 1)
+	builder.pbValueType(tagProfile_SampleType, name, "count")
+
+	values := []int64{0}
+	var locs []uint64
+	for _, k := range keys {
+		values[0] = int64(counts[k])
+		idx := index[k]
+		locs = builder.appendLocsForStack(locs[:0], profile.Stack(idx))
+
+		var labels func()
+		if profile.Label(idx) != nil {
+			labels = func() {
+				for _, label := range profile.Label(idx).list {
+					builder.pbLabel(tagSample_Label, label.key, label.value, 0)
+				}
+			}
+		}
+		builder.pbSample(values, locs, labels)
+	}
+
+	return builder.build()
+}
+
+type keysByCount struct {
+	keys  []string
+	count map[string]int
+}
+
+func (x *keysByCount) Len() int {
+	return len(x.keys)
+}
+
+func (x *keysByCount) Swap(i int, j int) {
+	x.keys[i], x.keys[j] = x.keys[j], x.keys[i]
+}
+
+func (x *keysByCount) Less(i int, j int) bool {
+	ki, kj := x.keys[i], x.keys[j]
+	ci, cj := x.count[ki], x.count[kj]
+	if ci != cj {
+		return ci > cj
+	}
+	return ki < kj
+}
+
+func expandInlinedFrames(dst []uintptr, pcs []uintptr) int {
+	frames := runtime.CallersFrames(pcs)
+	var n int
+	for n < len(dst) {
+		frame, more := frames.Next()
+		dst[n] = frame.PC + 1
+		n++
+		if !more {
+			break
+		}
+	}
+	return n
+}
+
+func writeHeapProto(w io.Writer, profile []memProfileRecord, rate int64, defaultSampleType string) error {
+	builder := newProfileBuilder(w)
+	builder.pbValueType(tagProfile_PeriodType, "space", "bytes")
+	builder.pb.int64Opt(tagProfile_Period, rate)
+	builder.pbValueType(tagProfile_SampleType, "alloc_objects", "count")
+	builder.pbValueType(tagProfile_SampleType, "alloc_space", "bytes")
+	builder.pbValueType(tagProfile_SampleType, "inuse_objects", "count")
+	builder.pbValueType(tagProfile_SampleType, "inuse_space", "bytes")
+	if defaultSampleType != "" {
+		builder.pb.int64Opt(tagProfile_DefaultSampleType, builder.stringIndex(defaultSampleType))
+	}
+
+	values := []int64{0, 0, 0, 0}
+	var locs []uint64
+	for _, record := range profile {
+		hideRuntime := true
+		for tries := 0; tries < 2; tries++ {
+			stk := record.Stack
+			if hideRuntime {
+				for i, addr := range stk {
+					if f := runtime.FuncForPC(addr); f != nil && (strings.HasPrefix(f.Name(), "runtime.") || strings.HasPrefix(f.Name(), "internal/runtime/")) {
+						continue
+					}
+					stk = stk[i:]
+					break
+				}
+			}
+			locs = builder.appendLocsForStack(locs[:0], stk)
+			if len(locs) > 0 {
+				break
+			}
+			hideRuntime = false
+		}
+
+		values[0], values[1] = scaleHeapSample(record.AllocObjects, record.AllocBytes, rate)
+		values[2], values[3] = scaleHeapSample(record.InUseObjects(), record.InUseBytes(), rate)
+
+		var blockSize int64
+		if record.AllocObjects > 0 {
+			blockSize = record.AllocBytes / record.AllocObjects
+		}
+		builder.pbSample(values, locs, func() {
+			if blockSize != 0 {
+				builder.pbLabel(tagSample_Label, "bytes", "", blockSize)
+			}
+		})
+	}
+
+	return builder.build()
+}
+
+func scaleHeapSample(count int64, size int64, rate int64) (int64, int64) {
+	if count == 0 || size == 0 {
+		return 0, 0
+	}
+	if rate <= 1 {
+		return count, size
+	}
+
+	avgSize := float64(size) / float64(count)
+	scale := 1 / (1 - math.Exp(-avgSize/float64(rate)))
+	return int64(float64(count) * scale), int64(float64(size) * scale)
+}
+
+type profileBuilder struct {
+	start time.Time
+	w     io.Writer
+	err   error
+
+	pb        protobuf
+	strings   []string
+	stringMap map[string]int
+	locs      map[uintptr]locInfo
+	funcs     map[string]int
+	mem       []memMap
+	deck      pcDeck
+}

experimental/libbox/internal/oomprofile/protobuf.go

@@ -0,0 +1,120 @@
+//go:build darwin || linux || windows
+
+package oomprofile
+
+type protobuf struct {
+	data []byte
+	tmp  [16]byte
+	nest int
+}
+
+func (b *protobuf) varint(x uint64) {
+	for x >= 128 {
+		b.data = append(b.data, byte(x)|0x80)
+		x >>= 7
+	}
+	b.data = append(b.data, byte(x))
+}
+
+func (b *protobuf) length(tag int, length int) {
+	b.varint(uint64(tag)<<3 | 2)
+	b.varint(uint64(length))
+}
+
+func (b *protobuf) uint64(tag int, x uint64) {
+	b.varint(uint64(tag)<<3 | 0)
+	b.varint(x)
+}
+
+func (b *protobuf) uint64s(tag int, x []uint64) {
+	if len(x) > 2 {
+		n1 := len(b.data)
+		for _, u := range x {
+			b.varint(u)
+		}
+		n2 := len(b.data)
+		b.length(tag, n2-n1)
+		n3 := len(b.data)
+		copy(b.tmp[:], b.data[n2:n3])
+		copy(b.data[n1+(n3-n2):], b.data[n1:n2])
+		copy(b.data[n1:], b.tmp[:n3-n2])
+		return
+	}
+	for _, u := range x {
+		b.uint64(tag, u)
+	}
+}
+
+func (b *protobuf) uint64Opt(tag int, x uint64) {
+	if x == 0 {
+		return
+	}
+	b.uint64(tag, x)
+}
+
+func (b *protobuf) int64(tag int, x int64) {
+	b.uint64(tag, uint64(x))
+}
+
+func (b *protobuf) int64Opt(tag int, x int64) {
+	if x == 0 {
+		return
+	}
+	b.int64(tag, x)
+}
+
+func (b *protobuf) int64s(tag int, x []int64) {
+	if len(x) > 2 {
+		n1 := len(b.data)
+		for _, u := range x {
+			b.varint(uint64(u))
+		}
+		n2 := len(b.data)
+		b.length(tag, n2-n1)
+		n3 := len(b.data)
+		copy(b.tmp[:], b.data[n2:n3])
+		copy(b.data[n1+(n3-n2):], b.data[n1:n2])
+		copy(b.data[n1:], b.tmp[:n3-n2])
+		return
+	}
+	for _, u := range x {
+		b.int64(tag, u)
+	}
+}
+
+func (b *protobuf) bool(tag int, x bool) {
+	if x {
+		b.uint64(tag, 1)
+	} else {
+		b.uint64(tag, 0)
+	}
+}
+
+func (b *protobuf) string(tag int, x string) {
+	b.length(tag, len(x))
+	b.data = append(b.data, x...)
+}
+
+func (b *protobuf) strings(tag int, x []string) {
+	for _, s := range x {
+		b.string(tag, s)
+	}
+}
+
+type msgOffset int
+
+func (b *protobuf) startMessage() msgOffset {
+	b.nest++
+	return msgOffset(len(b.data))
+}
+
+func (b *protobuf) endMessage(tag int, start msgOffset) {
+	n1 := int(start)
+	n2 := len(b.data)
+	b.length(tag, n2-n1)
+	n3 := len(b.data)
+	copy(b.tmp[:], b.data[n2:n3])
+	copy(b.data[n1+(n3-n2):], b.data[n1:n2])
+	copy(b.data[n1:], b.tmp[:n3-n2])
+	b.nest--
+}

experimental/libbox/log.go

@@ -1,24 +1,76 @@
-//go:build darwin || linux
+//go:build darwin || linux || windows
 
 package libbox
 
 import (
+	"archive/zip"
+	"io"
+	"io/fs"
 	"os"
+	"path/filepath"
 	"runtime"
 	"runtime/debug"
+	"time"
 )
 
-var crashOutputFile *os.File
+type crashReportMetadata struct {
+	reportMetadata
+	CrashedAt       string `json:"crashedAt,omitempty"`
+	SignalName      string `json:"signalName,omitempty"`
+	SignalCode      string `json:"signalCode,omitempty"`
+	ExceptionName   string `json:"exceptionName,omitempty"`
+	ExceptionReason string `json:"exceptionReason,omitempty"`
+}
 
-func RedirectStderr(path string) error {
-	if stats, err := os.Stat(path); err == nil && stats.Size() > 0 {
-		_ = os.Rename(path, path+".old")
+func archiveCrashReport(path string, crashReportsDir string) {
+	content, err := os.ReadFile(path)
+	if err != nil || len(content) == 0 {
+		return
 	}
+
+	info, _ := os.Stat(path)
+	crashTime := time.Now().UTC()
+	if info != nil {
+		crashTime = info.ModTime().UTC()
+	}
+
+	initReportDir(crashReportsDir)
+	destPath, err := nextAvailableReportPath(crashReportsDir, crashTime)
+	if err != nil {
+		return
+	}
+	initReportDir(destPath)
+
+	writeReportFile(destPath, "go.log", content)
+	metadata := crashReportMetadata{
+		reportMetadata: baseReportMetadata(),
+		CrashedAt:      crashTime.Format(time.RFC3339),
+	}
+	writeReportMetadata(destPath, metadata)
+	os.Remove(path)
+	copyConfigSnapshot(destPath)
+}
+
+func configSnapshotPath() string {
+	return filepath.Join(sBasePath, "configuration.json")
+}
+
+func saveConfigSnapshot(configContent string) {
+	snapshotPath := configSnapshotPath()
+	os.WriteFile(snapshotPath, []byte(configContent), 0o666)
+	chownReport(snapshotPath)
+}
+
+func redirectStderr(path string) error {
+	crashReportsDir := filepath.Join(sWorkingPath, "crash_reports")
+	archiveCrashReport(path, crashReportsDir)
+	archiveCrashReport(path+".old", crashReportsDir)
+
 	outputFile, err := os.Create(path)
 	if err != nil {
 		return err
 	}
-	if runtime.GOOS != "android" {
+	if runtime.GOOS != "android" && runtime.GOOS != "windows" {
 		err = outputFile.Chown(sUserID, sGroupID)
 		if err != nil {
 			outputFile.Close()
@@ -26,12 +78,88 @@ func RedirectStderr(path string) error {
 			return err
 		}
 	}
+
 	err = debug.SetCrashOutput(outputFile, debug.CrashOptions{})
 	if err != nil {
 		outputFile.Close()
 		os.Remove(outputFile.Name())
 		return err
 	}
-	crashOutputFile = outputFile
+	_ = outputFile.Close()
 	return nil
 }
+
+func CreateZipArchive(sourcePath string, destinationPath string) error {
+	sourceInfo, err := os.Stat(sourcePath)
+	if err != nil {
+		return err
+	}
+	if !sourceInfo.IsDir() {
+		return os.ErrInvalid
+	}
+
+	destinationFile, err := os.Create(destinationPath)
+	if err != nil {
+		return err
+	}
+	defer func() {
+		_ = destinationFile.Close()
+	}()
+
+	zipWriter := zip.NewWriter(destinationFile)
+
+	rootName := filepath.Base(sourcePath)
+	err = filepath.WalkDir(sourcePath, func(path string, d fs.DirEntry, err error) error {
+		if err != nil {
+			return err
+		}
+
+		relativePath, err := filepath.Rel(sourcePath, path)
+		if err != nil {
+			return err
+		}
+		if relativePath == "." {
+			return nil
+		}
+
+		archivePath := filepath.ToSlash(filepath.Join(rootName, relativePath))
+		if d.IsDir() {
+			_, err = zipWriter.Create(archivePath + "/")
+			return err
+		}
+
+		fileInfo, err := d.Info()
+		if err != nil {
+			return err
+		}
+		header, err := zip.FileInfoHeader(fileInfo)
+		if err != nil {
+			return err
+		}
+		header.Name = archivePath
+		header.Method = zip.Deflate
+
+		writer, err := zipWriter.CreateHeader(header)
+		if err != nil {
+			return err
+		}
+
+		sourceFile, err := os.Open(path)
+		if err != nil {
+			return err
+		}
+
+		_, err = io.Copy(writer, sourceFile)
+		closeErr := sourceFile.Close()
+		if err != nil {
+			return err
+		}
+		return closeErr
+	})
+	if err != nil {
+		_ = zipWriter.Close()
+		return err
+	}
+
+	return zipWriter.Close()
+}

experimental/libbox/memory.go

@@ -1,26 +0,0 @@
-package libbox
-
-import (
-	"math"
-	runtimeDebug "runtime/debug"
-
-	C "github.com/sagernet/sing-box/constant"
-)
-
-var memoryLimitEnabled bool
-
-func SetMemoryLimit(enabled bool) {
-	memoryLimitEnabled = enabled
-	const memoryLimitGo = 45 * 1024 * 1024
-	if enabled {
-		runtimeDebug.SetGCPercent(10)
-		if C.IsIos {
-			runtimeDebug.SetMemoryLimit(memoryLimitGo)
-		}
-	} else {
-		runtimeDebug.SetGCPercent(100)
-		if C.IsIos {
-			runtimeDebug.SetMemoryLimit(math.MaxInt64)
-		}
-	}
-}

experimental/libbox/oom_report.go

@@ -0,0 +1,141 @@
+//go:build darwin || linux || windows
+
+package libbox
+
+import (
+	"os"
+	"path/filepath"
+	"runtime"
+	"strings"
+	"time"
+
+	"github.com/sagernet/sing-box/experimental/libbox/internal/oomprofile"
+	"github.com/sagernet/sing-box/service/oomkiller"
+	"github.com/sagernet/sing/common/byteformats"
+	"github.com/sagernet/sing/common/memory"
+)
+
+func init() {
+	sOOMReporter = &oomReporter{}
+}
+
+var oomReportProfiles = []string{
+	"allocs",
+	"block",
+	"goroutine",
+	"heap",
+	"mutex",
+	"threadcreate",
+}
+
+type oomReportMetadata struct {
+	reportMetadata
+	RecordedAt      string `json:"recordedAt"`
+	MemoryUsage     string `json:"memoryUsage"`
+	AvailableMemory string `json:"availableMemory,omitempty"`
+	// Heap
+	HeapAlloc    string `json:"heapAlloc,omitempty"`
+	HeapObjects  uint64 `json:"heapObjects,omitempty,string"`
+	HeapInuse    string `json:"heapInuse,omitempty"`
+	HeapIdle     string `json:"heapIdle,omitempty"`
+	HeapReleased string `json:"heapReleased,omitempty"`
+	HeapSys      string `json:"heapSys,omitempty"`
+	// Stack
+	StackInuse string `json:"stackInuse,omitempty"`
+	StackSys   string `json:"stackSys,omitempty"`
+	// Runtime metadata
+	MSpanInuse  string `json:"mSpanInuse,omitempty"`
+	MSpanSys    string `json:"mSpanSys,omitempty"`
+	MCacheSys   string `json:"mCacheSys,omitempty"`
+	BuckHashSys string `json:"buckHashSys,omitempty"`
+	GCSys       string `json:"gcSys,omitempty"`
+	OtherSys    string `json:"otherSys,omitempty"`
+	Sys         string `json:"sys,omitempty"`
+	// GC & runtime
+	TotalAlloc   string `json:"totalAlloc,omitempty"`
+	NumGC        uint32 `json:"numGC,omitempty,string"`
+	NumGoroutine int    `json:"numGoroutine,omitempty,string"`
+	NextGC       string `json:"nextGC,omitempty"`
+	LastGC       string `json:"lastGC,omitempty"`
+}
+
+type oomReporter struct{}
+
+var _ oomkiller.OOMReporter = (*oomReporter)(nil)
+
+func (r *oomReporter) WriteReport(memoryUsage uint64) error {
+	now := time.Now().UTC()
+	reportsDir := filepath.Join(sWorkingPath, "oom_reports")
+	err := os.MkdirAll(reportsDir, 0o777)
+	if err != nil {
+		return err
+	}
+	chownReport(reportsDir)
+
+	destPath, err := nextAvailableReportPath(reportsDir, now)
+	if err != nil {
+		return err
+	}
+	err = os.MkdirAll(destPath, 0o777)
+	if err != nil {
+		return err
+	}
+	chownReport(destPath)
+
+	for _, name := range oomReportProfiles {
+		writeOOMProfile(destPath, name)
+	}
+
+	writeReportFile(destPath, "cmdline", []byte(strings.Join(os.Args, "\000")))
+
+	var memStats runtime.MemStats
+	runtime.ReadMemStats(&memStats)
+
+	metadata := oomReportMetadata{
+		reportMetadata: baseReportMetadata(),
+		RecordedAt:     now.Format(time.RFC3339),
+		MemoryUsage:    byteformats.FormatMemoryBytes(memoryUsage),
+		// Heap
+		HeapAlloc:    byteformats.FormatMemoryBytes(memStats.HeapAlloc),
+		HeapObjects:  memStats.HeapObjects,
+		HeapInuse:    byteformats.FormatMemoryBytes(memStats.HeapInuse),
+		HeapIdle:     byteformats.FormatMemoryBytes(memStats.HeapIdle),
+		HeapReleased: byteformats.FormatMemoryBytes(memStats.HeapReleased),
+		HeapSys:      byteformats.FormatMemoryBytes(memStats.HeapSys),
+		// Stack
+		StackInuse: byteformats.FormatMemoryBytes(memStats.StackInuse),
+		StackSys:   byteformats.FormatMemoryBytes(memStats.StackSys),
+		// Runtime metadata
+		MSpanInuse:  byteformats.FormatMemoryBytes(memStats.MSpanInuse),
+		MSpanSys:    byteformats.FormatMemoryBytes(memStats.MSpanSys),
+		MCacheSys:   byteformats.FormatMemoryBytes(memStats.MCacheSys),
+		BuckHashSys: byteformats.FormatMemoryBytes(memStats.BuckHashSys),
+		GCSys:       byteformats.FormatMemoryBytes(memStats.GCSys),
+		OtherSys:    byteformats.FormatMemoryBytes(memStats.OtherSys),
+		Sys:         byteformats.FormatMemoryBytes(memStats.Sys),
+		// GC & runtime
+		TotalAlloc:   byteformats.FormatMemoryBytes(memStats.TotalAlloc),
+		NumGC:        memStats.NumGC,
+		NumGoroutine: runtime.NumGoroutine(),
+		NextGC:       byteformats.FormatMemoryBytes(memStats.NextGC),
+	}
+	if memStats.LastGC > 0 {
+		metadata.LastGC = time.Unix(0, int64(memStats.LastGC)).UTC().Format(time.RFC3339)
+	}
+	availableMemory := memory.Available()
+	if availableMemory > 0 {
+		metadata.AvailableMemory = byteformats.FormatMemoryBytes(availableMemory)
+	}
+	writeReportMetadata(destPath, metadata)
+	copyConfigSnapshot(destPath)
+
+	return nil
+}
+
+func writeOOMProfile(destPath string, name string) {
+	filePath, err := oomprofile.WriteFile(destPath, name)
+	if err != nil {
+		return
+	}
+	chownReport(filePath)
+}

experimental/libbox/report.go

@@ -0,0 +1,97 @@
+//go:build darwin || linux || windows
+
+package libbox
+
+import (
+	"bytes"
+	"encoding/json"
+	"os"
+	"path/filepath"
+	"runtime"
+	"strconv"
+	"time"
+
+	C "github.com/sagernet/sing-box/constant"
+	E "github.com/sagernet/sing/common/exceptions"
+)
+
+type reportMetadata struct {
+	Source              string `json:"source,omitempty"`
+	BundleIdentifier    string `json:"bundleIdentifier,omitempty"`
+	ProcessName         string `json:"processName,omitempty"`
+	ProcessPath         string `json:"processPath,omitempty"`
+	StartedAt           string `json:"startedAt,omitempty"`
+	AppVersion          string `json:"appVersion,omitempty"`
+	AppMarketingVersion string `json:"appMarketingVersion,omitempty"`
+	CoreVersion         string `json:"coreVersion,omitempty"`
+	GoVersion           string `json:"goVersion,omitempty"`
+}
+
+func baseReportMetadata() reportMetadata {
+	processPath, _ := os.Executable()
+	processName := filepath.Base(processPath)
+	if processName == "." {
+		processName = ""
+	}
+	return reportMetadata{
+		Source:      sCrashReportSource,
+		ProcessName: processName,
+		ProcessPath: processPath,
+		CoreVersion: C.Version,
+		GoVersion:   GoVersion(),
+	}
+}
+
+func writeReportFile(destPath string, name string, content []byte) {
+	filePath := filepath.Join(destPath, name)
+	os.WriteFile(filePath, content, 0o666)
+	chownReport(filePath)
+}
+
+func writeReportMetadata(destPath string, metadata any) {
+	data, err := json.Marshal(metadata)
+	if err != nil {
+		return
+	}
+	writeReportFile(destPath, "metadata.json", data)
+}
+
+func copyConfigSnapshot(destPath string) {
+	snapshotPath := configSnapshotPath()
+	content, err := os.ReadFile(snapshotPath)
+	if err != nil {
+		return
+	}
+	if len(bytes.TrimSpace(content)) == 0 {
+		return
+	}
+	writeReportFile(destPath, "configuration.json", content)
+}
+
+func initReportDir(path string) {
+	os.MkdirAll(path, 0o777)
+	chownReport(path)
+}
+
+func chownReport(path string) {
+	if runtime.GOOS != "android" && runtime.GOOS != "windows" {
+		os.Chown(path, sUserID, sGroupID)
+	}
+}
+
+func nextAvailableReportPath(reportsDir string, timestamp time.Time) (string, error) {
+	destName := timestamp.Format("2006-01-02T15-04-05")
+	destPath := filepath.Join(reportsDir, destName)
+	_, err := os.Stat(destPath)
+	if os.IsNotExist(err) {
+		return destPath, nil
+	}
+	for i := 1; i <= 1000; i++ {
+		suffixedPath := filepath.Join(reportsDir, destName+"-"+strconv.Itoa(i))
+		_, err = os.Stat(suffixedPath)
+		if os.IsNotExist(err) {
+			return suffixedPath, nil
+		}
+	}
+	return "", E.New("no available report path for ", destName)
+}

experimental/libbox/setup.go

@@ -1,13 +1,17 @@
 package libbox
 
 import (
+	"math"
 	"os"
+	"path/filepath"
+	"runtime"
 	"runtime/debug"
 	"time"
 
 	C "github.com/sagernet/sing-box/constant"
 	"github.com/sagernet/sing-box/experimental/locale"
 	"github.com/sagernet/sing-box/log"
+	"github.com/sagernet/sing-box/service/oomkiller"
 	"github.com/sagernet/sing/common/byteformats"
 )
 
@@ -22,6 +26,10 @@ var (
 	sCommandServerSecret     string
 	sLogMaxLines             int
 	sDebug                   bool
+	sCrashReportSource       string
+	sOOMKillerEnabled        bool
+	sOOMKillerDisabled       bool
+	sOOMMemoryLimit          int64
 )
 
 func init() {
@@ -38,9 +46,13 @@ type SetupOptions struct {
 	CommandServerSecret     string
 	LogMaxLines             int
 	Debug                   bool
+	CrashReportSource       string
+	OomKillerEnabled        bool
+	OomKillerDisabled       bool
+	OomMemoryLimit          int64
 }
 
-func Setup(options *SetupOptions) error {
+func applySetupOptions(options *SetupOptions) {
 	sBasePath = options.BasePath
 	sWorkingPath = options.WorkingPath
 	sTempPath = options.TempPath
@@ -56,10 +68,33 @@ func Setup(options *SetupOptions) error {
 	sCommandServerSecret = options.CommandServerSecret
 	sLogMaxLines = options.LogMaxLines
 	sDebug = options.Debug
+	sCrashReportSource = options.CrashReportSource
+	ReloadSetupOptions(options)
+}
 
+func ReloadSetupOptions(options *SetupOptions) {
+	sOOMKillerEnabled = options.OomKillerEnabled
+	sOOMKillerDisabled = options.OomKillerDisabled
+	sOOMMemoryLimit = options.OomMemoryLimit
+	if sOOMKillerEnabled {
+		if sOOMMemoryLimit == 0 && C.IsIos {
+			sOOMMemoryLimit = oomkiller.DefaultAppleNetworkExtensionMemoryLimit
+		}
+		if sOOMMemoryLimit > 0 {
+			debug.SetMemoryLimit(sOOMMemoryLimit * 3 / 4)
+		} else {
+			debug.SetMemoryLimit(math.MaxInt64)
+		}
+	} else {
+		debug.SetMemoryLimit(math.MaxInt64)
+	}
+}
+
+func Setup(options *SetupOptions) error {
+	applySetupOptions(options)
 	os.MkdirAll(sWorkingPath, 0o777)
 	os.MkdirAll(sTempPath, 0o777)
-	return nil
+	return redirectStderr(filepath.Join(sWorkingPath, "CrashReport-"+sCrashReportSource+".log"))
 }
 
 func SetLocale(localeId string) {
@@ -70,6 +105,10 @@ func Version() string {
 	return C.Version
 }
 
+func GoVersion() string {
+	return runtime.Version() + ", " + runtime.GOOS + "/" + runtime.GOARCH
+}
+
 func FormatBytes(length int64) string {
 	return byteformats.FormatKBytes(uint64(length))
 }