stable release: Merge pull request #11 from matveynator/tvey/set-system-limits-on-program-start

Fix per-OS rlimit handling

Author: matveynator

pkg/limits/limits_posix_darwin.go

@@ -0,0 +1,96 @@
+//go:build darwin
+// +build darwin
+
+// Package limits includes POSIX-specific limit tuning to mirror xinetd-like defaults on macOS.
+// Using a macOS-specific file keeps type handling aligned with the unsigned Rlimit fields.
+package limits
+
+import (
+	"fmt"
+	"log"
+	"syscall"
+)
+
+// collectLimitRequests assembles the desired RLIMIT adjustments for macOS.
+// Keeping the list together documents which resources mirror the xinetd expectations.
+func collectLimitRequests(logger *log.Logger) []limitRequest {
+	desiredOpenFiles := uint64(100000)
+	desiredProcesses := uint64(100000)
+
+	requests := []limitRequest{
+		buildInfinityRequest("virtual memory (rlimit_as)", syscall.RLIMIT_AS),
+		buildInfinityRequest("CPU time (rlimit_cpu)", syscall.RLIMIT_CPU),
+		buildTargetRequest("open files (rlimit_files)", syscall.RLIMIT_NOFILE, desiredOpenFiles, logger),
+	}
+
+	if procResource, ok := processLimitResource(); ok {
+		requests = append(requests, buildTargetRequest("process count (rlimit_proc)", procResource, desiredProcesses, logger))
+	} else {
+		logger.Printf("Process limit resource is unavailable on this platform; skipping rlimit_proc")
+	}
+
+	return requests
+}
+
+// buildInfinityRequest raises a resource to the platform infinity constant.
+// Using RLIM_INFINITY avoids unsafe conversions across architectures.
+func buildInfinityRequest(label string, resource int) limitRequest {
+	return limitRequest{
+		description: fmt.Sprintf("%s -> unlimited", label),
+		apply: func() error {
+			current := &syscall.Rlimit{}
+			if err := syscall.Getrlimit(resource, current); err != nil {
+				return fmt.Errorf("failed reading %s: %w", label, err)
+			}
+
+			unlimited := ^uint64(0)
+			desired := &syscall.Rlimit{Cur: unlimited, Max: unlimited}
+			if current.Cur == desired.Cur && current.Max == desired.Max {
+				return nil
+			}
+
+			if err := syscall.Setrlimit(resource, desired); err != nil {
+				return fmt.Errorf("failed setting %s to unlimited: %w", label, err)
+			}
+			return nil
+		},
+	}
+}
+
+// buildTargetRequest nudges a resource toward the requested level while honoring the hard ceiling.
+// When raising the hard limit is denied, the fallback keeps the process running with the best available values.
+func buildTargetRequest(label string, resource int, target uint64, logger *log.Logger) limitRequest {
+	return limitRequest{
+		description: fmt.Sprintf("%s -> %d", label, target),
+		apply: func() error {
+			current := &syscall.Rlimit{}
+			if err := syscall.Getrlimit(resource, current); err != nil {
+				return fmt.Errorf("failed reading %s: %w", label, err)
+			}
+
+			desired := &syscall.Rlimit{Cur: target, Max: target}
+			if current.Max > desired.Max {
+				desired.Max = current.Max
+			}
+			if desired.Cur > desired.Max {
+				desired.Cur = desired.Max
+			}
+
+			if current.Cur >= desired.Cur && current.Max >= desired.Max {
+				return nil
+			}
+
+			if err := syscall.Setrlimit(resource, desired); err != nil {
+				logger.Printf("Adjusting %s hit %v; trying best-effort with existing max", label, err)
+				fallback := &syscall.Rlimit{Cur: desired.Cur, Max: current.Max}
+				if fallback.Cur > fallback.Max {
+					fallback.Cur = fallback.Max
+				}
+				if setErr := syscall.Setrlimit(resource, fallback); setErr != nil {
+					return fmt.Errorf("failed setting %s even after fallback: %w", label, setErr)
+				}
+			}
+			return nil
+		},
+	}
+}

pkg/limits/limits_posix_freebsd.go

@@ -0,0 +1,95 @@
+//go:build freebsd
+// +build freebsd
+
+// Package limits includes POSIX-specific limit tuning to mirror xinetd-like defaults on FreeBSD.
+// Using a FreeBSD-focused file keeps type handling compatible with the signed Rlimit definitions.
+package limits
+
+import (
+	"fmt"
+	"log"
+	"syscall"
+)
+
+// collectLimitRequests assembles the desired RLIMIT adjustments for macOS and FreeBSD.
+// Keeping the list together documents which resources mirror the xinetd expectations.
+func collectLimitRequests(logger *log.Logger) []limitRequest {
+	desiredOpenFiles := int64(100000)
+	desiredProcesses := int64(100000)
+
+	requests := []limitRequest{
+		buildInfinityRequest("virtual memory (rlimit_as)", syscall.RLIMIT_AS),
+		buildInfinityRequest("CPU time (rlimit_cpu)", syscall.RLIMIT_CPU),
+		buildTargetRequest("open files (rlimit_files)", syscall.RLIMIT_NOFILE, desiredOpenFiles, logger),
+	}
+
+	if procResource, ok := processLimitResource(); ok {
+		requests = append(requests, buildTargetRequest("process count (rlimit_proc)", procResource, desiredProcesses, logger))
+	} else {
+		logger.Printf("Process limit resource is unavailable on this platform; skipping rlimit_proc")
+	}
+
+	return requests
+}
+
+// buildInfinityRequest raises a resource to RLIM_INFINITY so workloads are not capped unexpectedly.
+// Using RLIM_INFINITY matches the signed fields exposed by the BSD syscall package.
+func buildInfinityRequest(label string, resource int) limitRequest {
+	return limitRequest{
+		description: fmt.Sprintf("%s -> unlimited", label),
+		apply: func() error {
+			current := &syscall.Rlimit{}
+			if err := syscall.Getrlimit(resource, current); err != nil {
+				return fmt.Errorf("failed reading %s: %w", label, err)
+			}
+
+			desired := &syscall.Rlimit{Cur: syscall.RLIM_INFINITY, Max: syscall.RLIM_INFINITY}
+			if current.Cur == desired.Cur && current.Max == desired.Max {
+				return nil
+			}
+
+			if err := syscall.Setrlimit(resource, desired); err != nil {
+				return fmt.Errorf("failed setting %s to unlimited: %w", label, err)
+			}
+			return nil
+		},
+	}
+}
+
+// buildTargetRequest nudges a resource toward the requested level while honoring the hard ceiling.
+// When raising the hard limit is denied, the fallback keeps the process running with the best available values.
+func buildTargetRequest(label string, resource int, target int64, logger *log.Logger) limitRequest {
+	return limitRequest{
+		description: fmt.Sprintf("%s -> %d", label, target),
+		apply: func() error {
+			current := &syscall.Rlimit{}
+			if err := syscall.Getrlimit(resource, current); err != nil {
+				return fmt.Errorf("failed reading %s: %w", label, err)
+			}
+
+			desired := &syscall.Rlimit{Cur: target, Max: target}
+			if current.Max > desired.Max {
+				desired.Max = current.Max
+			}
+			if desired.Cur > desired.Max {
+				desired.Cur = desired.Max
+			}
+
+			if current.Cur >= desired.Cur && current.Max >= desired.Max {
+				return nil
+			}
+
+			if err := syscall.Setrlimit(resource, desired); err != nil {
+				logger.Printf("Adjusting %s hit %v; trying best-effort with existing max", label, err)
+				fallback := &syscall.Rlimit{Cur: desired.Cur, Max: current.Max}
+				if fallback.Cur > fallback.Max {
+					fallback.Cur = fallback.Max
+				}
+				if setErr := syscall.Setrlimit(resource, fallback); setErr != nil {
+					return fmt.Errorf("failed setting %s even after fallback: %w", label, setErr)
+				}
+			}
+			return nil
+		},
+	}
+}

pkg/limits/limits_posix_openbsd.go

@@ -14,8 +14,8 @@ import (
 // collectLimitRequests assembles the desired RLIMIT adjustments for OpenBSD.
 // RLIMIT_DATA stands in for address space limits because RLIMIT_AS is unavailable on this platform.
 func collectLimitRequests(logger *log.Logger) []limitRequest {
-	desiredOpenFiles := int64(100000)
-	desiredProcesses := int64(100000)
+	desiredOpenFiles := uint64(100000)
+	desiredProcesses := uint64(100000)
 
 	requests := []limitRequest{
 		buildInfinityRequest("data segment (rlimit_data)", syscall.RLIMIT_DATA),
@@ -33,7 +33,7 @@ func collectLimitRequests(logger *log.Logger) []limitRequest {
 }
 
 // buildInfinityRequest raises a resource to RLIM_INFINITY so the proxy is not capped prematurely.
-// Using the constant directly matches the int64 fields exposed by the OpenBSD syscall package.
+// Using the computed infinity mirrors the unsigned fields exposed by the OpenBSD syscall package.
 func buildInfinityRequest(label string, resource int) limitRequest {
 	return limitRequest{
 		description: fmt.Sprintf("%s -> unlimited", label),
@@ -43,7 +43,8 @@ func buildInfinityRequest(label string, resource int) limitRequest {
 				return fmt.Errorf("failed reading %s: %w", label, err)
 			}
 
-			desired := &syscall.Rlimit{Cur: syscall.RLIM_INFINITY, Max: syscall.RLIM_INFINITY}
+			unlimited := ^uint64(0)
+			desired := &syscall.Rlimit{Cur: unlimited, Max: unlimited}
 			if current.Cur == desired.Cur && current.Max == desired.Max {
 				return nil
 			}
@@ -58,7 +59,7 @@ func buildInfinityRequest(label string, resource int) limitRequest {
 
 // buildTargetRequest nudges a resource toward the requested target and keeps the hard limit unchanged when required.
 // The fallback path maintains availability even if the kernel refuses to raise the maximum.
-func buildTargetRequest(label string, resource int, target int64, logger *log.Logger) limitRequest {
+func buildTargetRequest(label string, resource int, target uint64, logger *log.Logger) limitRequest {
 	return limitRequest{
 		description: fmt.Sprintf("%s -> %d", label, target),
 		apply: func() error {