Real-time monitoring dashboard for Proxmox VE, PBS, Docker, Kubernetes, TrueNAS and vSphere. Self-hosted, with alerts for failed backups, full disks, unhealthy containers and offline nodes.
Go aialertsdashboarddockerdocker-monitoringgohomelabinfrastructure-monitoringkubernetesmonitoringmspproxmoxproxmox-backup-serverproxmox-mail-gatewayproxmox-veself-hostedtruenastypescriptvspherewebhooks
Keep guest memory trustworthy through rejected and cached reads
pulse-triage[bot]aa98a002ed09
diff --git a/docs/release-control/v6/internal/subsystems/monitoring.md b/docs/release-control/v6/internal/subsystems/monitoring.mdindex be7663fa11..0b11f67b9a 100644--- a/docs/release-control/v6/internal/subsystems/monitoring.md+++ b/docs/release-control/v6/internal/subsystems/monitoring.md@@ -205,6 +205,50 @@ full-pressure/zero-available, legacy, resize and age controls remain distinct.These are secret-free source fixtures, not native balloon or freeze recovery,reporter #2762 cause/resolution, or release acceptance.+### Contradictory guest meminfo cannot manufacture healthy pressure++The QGA `/proc/meminfo` parser rejects physical counters above their sample's+MemTotal, integer-overflowing cache estimates and derived availability above+that total. It does not clamp contradictory evidence into a trusted zero-used+sample. Shmem is subtracted before checking the derived bound; valid older-kernel+estimates, exact-total/zero-used readings and explicit zero MemAvailable retain+their semantics. Swap capacity is not physical RAM, and explicit MemAvailable+still takes precedence over the optional cache estimate.++A completed but contradictory file-read remains an ordinary failed observation,+not a QGA transport pause. Existing negative-cache timing and independent+provider/linked-agent selection remain unchanged. A cold guest can retain an+independent provider tuple; an existing successful guest reading may instead+remain bounded last-known evidence with its original observation time. Neither+provider usage nor held guest data becomes current cache-aware guest pressure,+and neither can clear an incident established by an earlier qualified sample. Normal valid polling can restore guest authority and+clear it. The original backup-lock, single-attempt, uncertainty, observation-age+and History rules remain required; no command or recovery route is added.++Retained snapshots carry their explicitly annotated original source through+subsequent failed and negative-cache polls. The `previous-snapshot` wrapper+cannot discard a qualified origin after one poll and thereby clear a held+incident using an independent provider fallback. This continuity remains+last-known, uses the unchanged two-minute original-observation window and+capacity fence, and adds no History points or guest-pressure authority. A+wrapper with unknown/low-trust provenance, a missing/future/expired original,+or a capacity change remains ineligible; independent current qualified memory+still wins. `TestGuestMemoryRetainedOriginSurvivesRepeatedLowTrustPolls` covers+those controls and 125 synthetic poll transitions across the original deadline.++`pkg/proxmox/meminfo_integrity_test.go` covers contradictory physical components,+overflow and the supported zero/shared-memory/modern-available boundaries.+`TestGuestMeminfoIntegrityPollingContract` exercises both ordinary collectors+with actual single/cluster HTTP clients for every physical-counter and+estimate-refusal branch, canonical views, negative caching, backup-lock+admission and the production alert decision. Rejected, negative-cached and+locked polls must leave both percentage and byte History point sets exactly+unchanged, including original times. Valid recovery and genuine zero must add+only their own points. Each synthetic poll has a bounded caller context without+changing production timeouts. These are+synthetic source controls, not #2762 attribution, native freeze/restart recovery,+resolution of #2439/#2619/#2822 or released availability.+### Existing memory origins cannot be renewed by AI consumersAI query/context/fact consumers now retain the selected guest observation anddiff --git a/docs/release-control/v6/internal/subsystems/registry.json b/docs/release-control/v6/internal/subsystems/registry.jsonindex cd79f6a036..434f644fd7 100644--- a/docs/release-control/v6/internal/subsystems/registry.json+++ b/docs/release-control/v6/internal/subsystems/registry.json@@ -6341,7 +6341,7 @@},{"id": "proxmox-guest-counter-runtime",- "label": "Proxmox guest cumulative-counter presence and receipt-time proof",+ "label": "Proxmox guest counter presence, receipt-time and memory integrity proof","match_prefixes": [],"match_files": ["pkg/proxmox/client.go",@@ -6351,11 +6351,13 @@"test_prefixes": [],"exact_files": ["internal/api/router_state_test.go",+ "internal/monitoring/guest_meminfo_integrity_test.go","internal/monitoring/issue1613_contract_test.go","internal/monitoring/monitor_pve_guest_lxc_test.go","internal/monitoring/ratetracker_test.go","pkg/proxmox/host_diagnostics_regression_test.go",- "pkg/proxmox/io_counters_test.go"+ "pkg/proxmox/io_counters_test.go",+ "pkg/proxmox/meminfo_integrity_test.go"]},{@@ -6556,6 +6558,8 @@"internal/monitoring/canonical_guardrails_test.go","internal/monitoring/ceph_test.go","internal/monitoring/deadman_test.go",+ "internal/monitoring/guest_meminfo_integrity_test.go",+ "internal/monitoring/guest_memory_stability_test.go","internal/monitoring/guest_poll_ownership_test.go","internal/monitoring/issue1485_unraid_lifecycle_test.go","internal/monitoring/issue1595_collection_trust_test.go",diff --git a/internal/monitoring/guest_meminfo_integrity_test.go b/internal/monitoring/guest_meminfo_integrity_test.gonew file mode 100644index 0000000000..fa5efb28ec--- /dev/null+++ b/internal/monitoring/guest_meminfo_integrity_test.go@@ -0,0 +1,268 @@+package monitoring++import (+ "context"+ "encoding/json"+ "fmt"+ "net/http"+ "net/http/httptest"+ "reflect"+ "strings"+ "sync/atomic"+ "testing"+ "time"++ "github.com/rcourtman/pulse-go-rewrite/internal/alerts"+ "github.com/rcourtman/pulse-go-rewrite/internal/config"+ "github.com/rcourtman/pulse-go-rewrite/internal/mock"+ "github.com/rcourtman/pulse-go-rewrite/internal/models"+ "github.com/rcourtman/pulse-go-rewrite/internal/unifiedresources"+ "github.com/rcourtman/pulse-go-rewrite/pkg/proxmox"+)++// A complete QGA file-read can still contain contradictory memory counters.+// Both ordinary collectors must preserve the independently known provider+// reading, not invent healthy guest pressure or clear an existing incident.+// These are synthetic loopback controls, not native guest/restart acceptance.+func TestGuestMeminfoIntegrityPollingContract(t *testing.T) {+ wasMock := mock.IsMockEnabled()+ mustSetMockEnabled(t, false)+ t.Cleanup(func() { mustSetMockEnabled(t, wasMock) })+ const gib = uint64(1024 * 1024 * 1024)+ // Exercise each refusal branch through the real polling consumer, not+ // just the over-total estimate used by the original connected fixture.+ for _, rejection := range []struct{ name, content string }{+ {"derived-over-total", "MemTotal: 4194304 kB\nMemFree: 3145728 kB\nBuffers: 0 kB\nCached: 2097152 kB\n"},+ {"free-over-total-with-shmem", "MemTotal: 4194304 kB\nMemFree: 6291456 kB\nBuffers: 0 kB\nCached: 524288 kB\nShmem: 3145728 kB\n"},+ {"buffers-over-total", "MemTotal: 4194304 kB\nMemFree: 524288 kB\nBuffers: 6291456 kB\nCached: 524288 kB\n"},+ {"cached-over-total", "MemTotal: 4194304 kB\nMemFree: 524288 kB\nBuffers: 0 kB\nCached: 6291456 kB\n"},+ {"reclaimable-over-total", "MemTotal: 4194304 kB\nMemFree: 524288 kB\nBuffers: 0 kB\nCached: 524288 kB\nSReclaimable: 6291456 kB\n"},+ {"shmem-over-total", "MemTotal: 4194304 kB\nMemFree: 524288 kB\nBuffers: 0 kB\nCached: 524288 kB\nShmem: 6291456 kB\n"},+ {"explicit-available-with-impossible-free", "MemTotal: 4194304 kB\nMemAvailable: 2097152 kB\nMemFree: 6291456 kB\n"},+ {"derived-sum-overflow", "MemTotal: 18014398509481983 kB\nMemFree: 18014398509481982 kB\nBuffers: 0 kB\nCached: 2 kB\n"},+ } {+ for _, kind := range []string{"client", "cluster-client"} {+ for _, collector := range []string{"cluster", "node"} {+ t.Run(rejection.name+"/"+kind+"/"+collector, func(t *testing.T) {+ var phase, commands, fileReads atomic.Int32+ server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {+ if r.Header.Get("Authorization") != "PVEAPIToken=fixture@pve!pulse=fixture" {+ t.Error("configured fixture authentication changed")+ w.WriteHeader(http.StatusForbidden)+ return+ }+ w.Header().Set("Content-Type", "application/json")+ switch {+ case strings.HasSuffix(r.URL.Path, "/nodes"):+ fmt.Fprint(w, `{"data":[]}`)+ case strings.HasSuffix(r.URL.Path, "/config"):+ if phase.Load() == 2 {+ fmt.Fprint(w, `{"data":{"lock":"backup"}}`)+ } else {+ fmt.Fprint(w, `{"data":{}}`)+ }+ case strings.HasSuffix(r.URL.Path, "/status/current"):+ lock := ""+ if phase.Load() == 2 {+ lock = `,"lock":"backup"`+ }+ fmt.Fprintf(w, `{"data":{"status":"running","agent":1,"maxmem":%d,"mem":%d,"cpu":0.1%s}}`, 8*gib, 4*gib, lock)+ case strings.Contains(r.URL.Path, "/agent/"):+ commands.Add(1)+ switch {+ case strings.HasSuffix(r.URL.Path, "/get-fsinfo"):+ fmt.Fprintf(w, `{"data":{"result":[{"mountpoint":"/","type":"ext4","total-bytes":%d,"used-bytes":%d}]}}`, gib, gib/4)+ case strings.HasSuffix(r.URL.Path, "/get-osinfo"):+ fmt.Fprint(w, `{"data":{"name":"Linux","version":"fixture"}}`)+ case strings.HasSuffix(r.URL.Path, "/file-read"):+ fileReads.Add(1)+ if r.URL.Query().Get("file") != "/proc/meminfo" {+ t.Error("unexpected guest file")+ }+ content := "MemTotal: 4194304 kB\nMemFree: 0 kB\nMemAvailable: 0 kB\n"+ if phase.Load() == 1 {+ content = rejection.content+ }+ if phase.Load() == 3 {+ content = "MemTotal: 4194304 kB\nMemFree: 524288 kB\nBuffers: 524288 kB\nCached: 1048576 kB\nSReclaimable: 262144 kB\nShmem: 262144 kB\n"+ }+ if phase.Load() == 4 {+ content = "MemTotal: 4194304 kB\nMemFree: 2097152 kB\nBuffers: 0 kB\nCached: 2097152 kB\n"+ }+ _ = json.NewEncoder(w).Encode(map[string]any{"data": map[string]any{"content": content, "truncated": false}})+ default:+ fmt.Fprint(w, `{"data":{"result":{"version":"fixture"}}}`)+ }+ default:+ http.NotFound(w, r)+ }+ }))+ t.Cleanup(server.Close)+ client := windowsBootstrapClient(t, server.URL, kind)+ am := alerts.NewManagerWithDataDir(t.TempDir(), alerts.WithoutPersistedAlertRestore())+ t.Cleanup(am.Stop)+ cfg := am.GetConfig()+ cfg.Enabled = true+ cfg.GuestDefaults.Memory = &alerts.HysteresisThreshold{Trigger: 85, Clear: 80}+ cfg.GuestDefaults.CPU = &alerts.HysteresisThreshold{Trigger: 90, Clear: 85}+ cfg.GuestDefaults.Disk = &alerts.HysteresisThreshold{Trigger: 90, Clear: 85}+ cfg.MetricTimeThresholds = map[string]map[string]int{"guest": {"memory": 0, "cpu": 0, "disk": 0}}+ am.UpdateConfig(cfg)+ registry := unifiedresources.NewRegistry(nil)+ m := &Monitor{config: &config.Config{}, state: models.NewState(), alertManager: am, rateTracker: NewRateTracker(), metricsHistory: NewMetricsHistory(32, time.Hour), guestMetadataLimiter: make(map[string]time.Time)}+ id := makeGuestID("meminfo-integrity", "node", 105)+ previous := map[string]models.VM{}+ build := func() models.VM {+ t.Helper()+ // Bound this synthetic poll independently of the executor. No+ // product request, admission or retry timeout is changed.+ ctx, cancel := context.WithTimeout(context.Background(), windowsPollingHangGuard)+ defer cancel()+ res := proxmox.ClusterResource{Type: "qemu", Node: "node", Name: "cache-aware-guest", VMID: 105, Status: "running", MaxMem: 8 * gib, Mem: 4 * gib, MaxDisk: gib, CPU: .1}+ var vms []models.VM+ if collector == "cluster" {+ vms = m.collectClusterVMResources(ctx, "meminfo-integrity", []indexedClusterResource{{resource: res, guestID: id}}, client, previous, nil)+ } else {+ vms, _ = m.pollNodeVMsWithClusterResourceBuilder(ctx, "meminfo-integrity", "node", []proxmox.VM{{VMID: 105, Name: res.Name, Status: "running", MaxMem: res.MaxMem, Mem: res.Mem, MaxDisk: gib, CPU: .1}}, client, previous, nil)+ }+ if len(vms) != 1 {+ t.Fatalf("collector lost guest: %d", len(vms))+ }+ m.recordGuestMetrics(vms, nil, time.Now().Add(-time.Second))+ m.state.UpdateVMs(vms)+ // Use the production canonical projection, without fabricating the+ // full monitor's persistence/identity wiring in this polling fixture.+ registry.IngestSnapshot(models.StateSnapshot{VMs: vms})+ views := registry.VMs()+ if len(views) != 1 {+ t.Fatalf("canonical ingest lost guest: %d", len(views))+ }+ view := views[0]+ if vms[0].Memory.HasKnownUsage() && (view.MemoryTotal() != vms[0].Memory.Total || view.MemoryUsed() != vms[0].Memory.Used || view.MemoryPercent() != vms[0].Memory.Usage) {+ t.Error("canonical view changed producer tuple")+ }+ if !vms[0].Memory.HasKnownUsage() && view.MemoryEvidence(time.Now()).Available {+ t.Error("unavailable memory became a canonical measurement")+ }+ previous[id] = previousVMFromView(view)+ return vms[0]+ }+ assertMemoryAlerts := func(want int) {+ t.Helper()+ if len(am.GetActiveAlerts()) != want {+ t.Errorf("active alerts=%d, want %d", len(am.GetActiveAlerts()), want)+ }+ for _, a := range am.GetActiveAlerts() {+ if a.Type != "memory" || a.Value != 100 {+ t.Errorf("untrusted input changed established incident: type=%s value=%v", a.Type, a.Value)+ }+ }+ }+ key := guestMemoryCacheKey("meminfo-integrity", "node", 105)+ expireMemory := func() {+ entry := m.vmAgentMemCache[key]+ entry.fetchedAt = time.Now().Add(-2 * vmAgentMemNegativeTTL)+ m.vmAgentMemCache[key] = entry+ }+ // With no successful guest observation, reject the impossible+ // estimate and keep the independently supplied provider tuple.+ phase.Store(1)+ corrupt := build()+ if corrupt.Memory.Observation.Source != "status-mem" || corrupt.Memory.Total != int64(8*gib) || corrupt.Memory.Used != int64(4*gib) || corrupt.Memory.Usage != 50 || corrupt.GuestAgentStatus != "available" || !m.vmAgentMemCache[key].negative {+ t.Errorf("cold contradictory sample became trustworthy or a transport pause: %+v", corrupt.Memory)+ }+ if registry.VMs()[0].MemoryEvidence(time.Now()).PressureKnown {+ t.Error("independent provider reading acquired guest-pressure authority")+ }+ assertMemoryAlerts(0)+ phase.Store(0)+ expireMemory()+ pressure := build()+ if pressure.Memory.Usage != 100 || pressure.Memory.Total != int64(4*gib) {+ t.Error("valid pressure sample changed")+ }+ assertMemoryAlerts(1)+ trustedHistory := map[string][]MetricPoint{}+ for _, metric := range []string{"memory", "memoryused"} {+ trustedHistory[metric] = m.metricsHistory.GetGuestMetrics(id, metric, time.Hour)+ if len(trustedHistory[metric]) != 2 {+ t.Fatalf("cold provider and qualified pressure did not establish %s History", metric)+ }+ }+ assertHistoryUnchanged := func() {+ t.Helper()+ for metric, original := range trustedHistory {+ if got := m.metricsHistory.GetGuestMetrics(id, metric, time.Hour); !reflect.DeepEqual(got, original) {+ t.Errorf("rejected or deferred evidence renewed %s History: %+v", metric, got)+ }+ }+ }+ phase.Store(1)+ expireMemory()+ retained := build()+ if retained.Memory.Usage != 100 || retained.Memory.Total != pressure.Memory.Total || retained.Memory.Observation.State != "last-known" || !retained.Memory.Observation.ObservedAt.Equal(pressure.Memory.Observation.ObservedAt) || !m.vmAgentMemCache[key].negative {+ t.Errorf("corrupt refresh lost original bounded last-known evidence: %+v", retained.Memory)+ }+ if registry.VMs()[0].MemoryEvidence(time.Now()).PressureKnown {+ t.Error("held guest evidence became current pressure")+ }+ assertMemoryAlerts(1)+ assertHistoryUnchanged()+ before := fileReads.Load()+ negative := m.vmAgentMemCache[key]+ _ = build()+ if fileReads.Load() != before || m.vmAgentMemCache[key] != negative {+ t.Error("negative cache retried or renewed corrupt memory")+ }+ assertMemoryAlerts(1)+ assertHistoryUnchanged()+ beforeCommands := commands.Load()+ phase.Store(2)+ locked := build()+ if commands.Load() != beforeCommands || locked.GuestAgentStatus != "deferred" {+ t.Error("integrity rejection weakened backup-lock admission")+ }+ assertMemoryAlerts(1)+ assertHistoryUnchanged()+ phase.Store(3)+ expireMemory()+ recovered := build()+ if recovered.Memory.Observation.Source != "guest-agent-meminfo-derived" || recovered.Memory.Usage != 50 || recovered.Memory.Total != int64(4*gib) || recovered.Memory.Free != int64(gib/2) || recovered.Memory.Cache != int64(3*gib/2) || !registry.VMs()[0].MemoryEvidence(time.Now()).PressureKnown {+ t.Errorf("normal valid recovery lost tuple/trust: %+v", recovered.Memory)+ }+ assertMemoryAlerts(0)+ phase.Store(4)+ expireMemory()+ zero := build()+ if zero.Memory.Used != 0 || zero.Memory.Usage != 0 || zero.Memory.Observation.Source != "guest-agent-meminfo-derived" || !registry.VMs()[0].MemoryEvidence(time.Now()).PressureKnown {+ t.Error("genuine measured zero usage was rejected")+ }+ assertMemoryAlerts(0)+ for metric, values := range map[string][]float64{+ "memory": {50, 100, 50, 0},+ "memoryused": {float64(4 * gib), float64(4 * gib), float64(2 * gib), 0},+ } {+ points := m.metricsHistory.GetGuestMetrics(id, metric, time.Hour)+ if len(points) != len(values) || !reflect.DeepEqual(points[:2], trustedHistory[metric]) {+ t.Errorf("recovery lost original or added unqualified %s History: %+v", metric, points)+ continue+ }+ for i, value := range values {+ if points[i].Value != value {+ t.Errorf("%s point %d=%v, want %v", metric, i, points[i].Value, value)+ }+ }+ }+ if fileReads.Load() != 5 {+ t.Errorf("ordinary cold-malformed/pressure/malformed/resumed/zero reads=%d, want 5", fileReads.Load())+ }+ data, err := json.Marshal(map[string]any{"rejection": rejection.name, "client": kind, "collector": collector, "pressure": pressure, "corrupt": corrupt, "retained": retained, "recovered": recovered, "zero": zero, "history": m.metricsHistory.GetGuestMetrics(id, "memory", time.Hour)})+ if err != nil {+ t.Fatal(err)+ }+ t.Logf("MEMINFO_BROWSER_JSON:%s", data)+ })+ }+ }+ }+}diff --git a/internal/monitoring/guest_memory_stability.go b/internal/monitoring/guest_memory_stability.goindex 750f8ee16c..fb0024757f 100644--- a/internal/monitoring/guest_memory_stability.go+++ b/internal/monitoring/guest_memory_stability.go@@ -107,6 +107,17 @@ func stabilizeGuestLowTrustMemory(return currentUsed, currentSource, nil}+// A retained snapshot is a wrapper around an original observation, not a+// downgrade of that observation's origin. The caller still checks its original+// age and capacity; neither this wrapper nor RetrievedAt can renew the sample.+func guestMemorySnapshotReliability(prev *GuestMemorySnapshot) int {+ source := CanonicalMemorySource(prev.MemorySource)+ if source == "previous-snapshot" && (prev.Memory.Observation.State == "current" || prev.Memory.Observation.State == "last-known") {+ source = CanonicalMemorySource(prev.Memory.Observation.Source)+ }+ return guestMemorySourceReliability(source)+}+func shouldCarryForwardPreviousGuestMemory(prev *GuestMemorySnapshot, currentStatus, currentSource string, currentTotal, currentUsed uint64, now time.Time) bool {if prev == nil || currentStatus != "running" || prev.Status != "running" {return false@@ -118,7 +129,7 @@ func shouldCarryForwardPreviousGuestMemory(prev *GuestMemorySnapshot, currentStareturn false}- prevReliability := guestMemorySourceReliability(prev.MemorySource)+ prevReliability := guestMemorySnapshotReliability(prev)currentReliability := guestMemorySourceReliability(currentSource)if prevReliability < guestMemoryReliabilityTrusted || currentReliability > guestMemoryReliabilityFallback {return falsediff --git a/internal/monitoring/guest_memory_stability_test.go b/internal/monitoring/guest_memory_stability_test.goindex 06ae9b8a51..53d123cb84 100644--- a/internal/monitoring/guest_memory_stability_test.go+++ b/internal/monitoring/guest_memory_stability_test.go@@ -232,3 +232,63 @@ func TestPollVMsWithNodesPreservesHealthyGuestMemoryFromPreviousSnapshot(t *testt.Fatalf("snapshot.Notes = %#v, want healthy guest carry-forward note", snap.Notes)}}++// The first malformed refresh must not consume the prior observation's source+// authority. Negative-cache and later failed polls carry the same bounded+// last-known tuple, never a new pressure or History observation.+func TestGuestMemoryRetainedOriginSurvivesRepeatedLowTrustPolls(t *testing.T) {+ original := time.Date(2026, time.October, 13, 5, 0, 0, 0, time.UTC)+ for _, tc := range []struct {+ name, source, state, origin string+ age time.Duration+ total uint64+ currentSource string+ want bool+ }{+ {"direct", "guest-agent-meminfo", "current", "guest-agent-meminfo", time.Second, 100, "status-mem", true},+ {"retained", "previous-snapshot", "last-known", "guest-agent-meminfo", time.Second, 100, "status-mem", true},+ {"retained-derived", "previous-snapshot", "last-known", "guest-agent-meminfo-derived", time.Minute, 100, "unavailable", true},+ {"inclusive-original-age", "previous-snapshot", "last-known", "guest-agent-meminfo", guestMemoryCarryForwardMaxAge, 100, "status-mem", true},+ {"expired-original", "previous-snapshot", "last-known", "guest-agent-meminfo", guestMemoryCarryForwardMaxAge + time.Nanosecond, 100, "status-mem", false},+ {"future-original", "previous-snapshot", "last-known", "guest-agent-meminfo", -time.Second, 100, "status-mem", false},+ {"legacy-wrapper", "previous-snapshot", "", "", time.Second, 100, "status-mem", false},+ {"unavailable-wrapper", "previous-snapshot", "unavailable", "guest-agent-meminfo", time.Second, 100, "status-mem", false},+ {"unknown-wrapper-state", "previous-snapshot", "future-state", "guest-agent-meminfo", time.Second, 100, "status-mem", false},+ {"unknown-original-source", "previous-snapshot", "last-known", "future-source", time.Second, 100, "status-mem", false},+ {"wrapper-without-origin", "previous-snapshot", "last-known", "previous-snapshot", time.Second, 100, "status-mem", false},+ {"provider-wrapper-is-not-guest-pressure", "previous-snapshot", "last-known", "status-mem", time.Second, 100, "status-mem", false},+ {"provider-label-cannot-borrow-annotation", "status-mem", "last-known", "guest-agent-meminfo", time.Second, 100, "status-mem", false},+ {"resized", "previous-snapshot", "last-known", "guest-agent-meminfo", time.Second, 101, "status-mem", false},+ {"independent-current-memory-wins", "previous-snapshot", "last-known", "guest-agent-meminfo", time.Second, 100, "available-field", false},+ } {+ t.Run(tc.name, func(t *testing.T) {+ now := original.Add(tc.age)+ prev := &GuestMemorySnapshot{Status: "running", MemorySource: tc.source, RetrievedAt: now,+ Memory: models.Memory{Total: 100, Used: 100, Usage: 100, Observation: models.MemoryObservation{State: tc.state, Source: tc.origin, ObservedAt: original}}}+ if tc.state == "" {+ prev.Memory.Observation = models.MemoryObservation{}+ }+ if got := shouldCarryForwardPreviousGuestMemory(prev, "running", tc.currentSource, tc.total, 50, now); got != tc.want {+ t.Errorf("bounded original-source retention=%t, want %t", got, tc.want)+ }+ })+ }+ prev := &GuestMemorySnapshot{Status: "running", MemorySource: "guest-agent-meminfo", RetrievedAt: original,+ Memory: models.Memory{Total: 100, Used: 100, Usage: 100, Observation: models.MemoryObservation{State: "current", Source: "guest-agent-meminfo", ObservedAt: original}}}+ for second := 1; second <= 125; second++ {+ now := original.Add(time.Duration(second) * time.Second)+ used, source, _ := stabilizeGuestLowTrustMemory(prev, "running", "status-mem", 100, 50, now, true)+ if second <= int(guestMemoryCarryForwardMaxAge/time.Second) {+ if used != 100 || source != "previous-snapshot" {+ t.Fatalf("poll %d lost bounded original guest reading: %d/%s", second, used, source)+ }+ prev.MemorySource, prev.Memory.Observation.State = source, "last-known"+ prev.RetrievedAt = now+ } else if used != 50 || source != "status-mem" {+ t.Fatalf("poll %d renewed expired original reading: %d/%s", second, used, source)+ }+ if !prev.Memory.Observation.ObservedAt.Equal(original) {+ t.Fatal("retained poll renewed the original observation time")+ }+ }+}diff --git a/pkg/proxmox/client.go b/pkg/proxmox/client.goindex c12f0e8f49..f28c0ac5a6 100644--- a/pkg/proxmox/client.go+++ b/pkg/proxmox/client.go@@ -2352,7 +2352,9 @@ type LinuxMemoryAvailability struct {// ParseLinuxMemoryAvailability parses /proc/meminfo. New kernels provide// MemAvailable directly. Older kernels use the conservative cache-aware// estimate Free + Buffers + Cached + SReclaimable - Shmem. A partial payload-// containing only MemTotal/MemFree is deliberately rejected.+// containing only MemTotal/MemFree is deliberately rejected. Impossible+// physical counters or a derived estimate above MemTotal are not measurements;+// clamping them would manufacture a trusted zero-usage sample.func ParseLinuxMemoryAvailability(content string, truncated bool) (LinuxMemoryAvailability, error) {var result LinuxMemoryAvailabilityseen := make(map[string]struct{})@@ -2395,6 +2397,14 @@ func ParseLinuxMemoryAvailability(content string, truncated bool) (LinuxMemoryAv*target = kB * 1024}+ if result.Total > 0 {+ for _, name := range []string{"MemFree", "Buffers", "Cached", "SReclaimable", "Shmem"} {+ if *fieldsByName[name] > result.Total {+ return LinuxMemoryAvailability{}, fmt.Errorf("%s exceeds MemTotal", name)+ }+ }+ }+if _, present := seen["MemAvailable"]; present {if _, ok := seen["MemTotal"]; !ok || result.Total == 0 {return LinuxMemoryAvailability{}, fmt.Errorf("MemAvailable has no valid MemTotal")@@ -2425,8 +2435,7 @@ func ParseLinuxMemoryAvailability(content string, truncated bool) (LinuxMemoryAvavailable := result.Freefor _, value := range []uint64{result.Buffers, result.Cached, result.SReclaimable} {if math.MaxUint64-available < value {- available = math.MaxUint64- break+ return LinuxMemoryAvailability{}, fmt.Errorf("cache-aware /proc/meminfo estimate overflows uint64")}available += value}@@ -2436,7 +2445,7 @@ func ParseLinuxMemoryAvailability(content string, truncated bool) (LinuxMemoryAvavailable -= result.Shmem}if available > result.Total {- available = result.Total+ return LinuxMemoryAvailability{}, fmt.Errorf("derived MemAvailable exceeds MemTotal")}result.EffectiveAvailable = availableresult.Source = "meminfo-derived"diff --git a/pkg/proxmox/guest_agent_lock_response_test.go b/pkg/proxmox/guest_agent_lock_response_test.goindex 58f5cd0083..69f15cf08e 100644--- a/pkg/proxmox/guest_agent_lock_response_test.go+++ b/pkg/proxmox/guest_agent_lock_response_test.go@@ -157,7 +157,15 @@ func TestVMConfigCompleteWhitespaceAtResponseLimit(t *testing.T) {fmt.Fprint(w, strings.Repeat(" ", int(maxResponseBodyBytes)-len(config)))}))defer server.Close()- got, err := backupTestClient(t, server.URL).GetVMConfig(context.Background(), "node", 105)+ // This checks the complete 8 MiB response boundary, not throughput. The+ // shared one-second client fixture can time out while race-instrumented+ // body collection/decoding is still completing. Keep a bounded hang guard+ // here without changing any production timeout or lock/size requirement.+ client, err := NewClient(ClientConfig{Host: server.URL, TokenName: "fixture@pve!pulse", TokenValue: "fixture", Timeout: time.Minute})+ if err != nil {+ t.Fatal(err)+ }+ got, err := client.GetVMConfig(context.Background(), "node", 105)if err != nil || got["name"] != "fixture" || got["agent"] != float64(1) {t.Fatalf("complete bounded config rejected or changed: %#v %v", got, err)}diff --git a/pkg/proxmox/meminfo_integrity_test.go b/pkg/proxmox/meminfo_integrity_test.gonew file mode 100644index 0000000000..42edb3347c--- /dev/null+++ b/pkg/proxmox/meminfo_integrity_test.go@@ -0,0 +1,48 @@+package proxmox++import (+ "testing"+)++// Contradictory counters must not become a trusted zero-usage sample. These are+// synthetic parser inputs, not a replay or diagnosis of a native guest failure.+func TestParseLinuxMemoryAvailabilityRejectsContradictoryEvidence(t *testing.T) {+ for name, content := range map[string]string{+ "derived-over-total": "MemTotal: 8192 kB\nMemFree: 6144 kB\nBuffers: 1024 kB\nCached: 4096 kB\n",+ "free-over-total-with-shmem": "MemTotal: 8192 kB\nMemFree: 12288 kB\nBuffers: 0 kB\nCached: 1024 kB\nShmem: 6144 kB\n",+ "buffers-over-total": "MemTotal: 8192 kB\nMemFree: 1024 kB\nBuffers: 12288 kB\nCached: 1024 kB\n",+ "cached-over-total": "MemTotal: 8192 kB\nMemFree: 1024 kB\nBuffers: 0 kB\nCached: 12288 kB\n",+ "reclaimable-over-total": "MemTotal: 8192 kB\nMemFree: 1024 kB\nBuffers: 0 kB\nCached: 1024 kB\nSReclaimable: 12288 kB\n",+ "shmem-over-total": "MemTotal: 8192 kB\nMemFree: 1024 kB\nBuffers: 0 kB\nCached: 1024 kB\nShmem: 12288 kB\n",+ "explicit-available-with-impossible-free": "MemTotal: 8192 kB\nMemAvailable: 4096 kB\nMemFree: 12288 kB\n",+ "derived-sum-overflow": "MemTotal: 18014398509481983 kB\nMemFree: 18014398509481982 kB\nBuffers: 0 kB\nCached: 2 kB\n",+ } {+ t.Run(name, func(t *testing.T) {+ got, err := ParseLinuxMemoryAvailability(content, false)+ if err == nil || got != (LinuxMemoryAvailability{}) {+ t.Errorf("contradictory sample acquired memory authority: source=%q available=%d total=%d error=%v", got.Source, got.EffectiveAvailable, got.Total, err)+ }+ })+ }+}++func TestParseLinuxMemoryAvailabilityPreservesValidBoundaries(t *testing.T) {+ for _, tc := range []struct {+ name, content, source string+ available uint64+ }{+ {"old-kernel", "MemTotal: 8192 kB\nMemFree: 1024 kB\nBuffers: 512 kB\nCached: 2048 kB\nSReclaimable: 512 kB\nShmem: 256 kB\n", "meminfo-derived", 3840 * 1024},+ {"shared-subtracted-before-bound", "MemTotal: 8192 kB\nMemFree: 4096 kB\nBuffers: 0 kB\nCached: 6144 kB\nShmem: 4096 kB\n", "meminfo-derived", 6144 * 1024},+ {"derived-exact-total-measured-zero-used", "MemTotal: 8192 kB\nMemFree: 4096 kB\nBuffers: 0 kB\nCached: 4096 kB\n", "meminfo-derived", 8192 * 1024},+ {"shared-full-pressure", "MemTotal: 8192 kB\nMemFree: 0 kB\nBuffers: 0 kB\nCached: 1024 kB\nShmem: 1024 kB\n", "meminfo-derived", 0},+ {"explicit-zero-available", "MemTotal: 8192 kB\nMemAvailable: 0 kB\nMemFree: 0 kB\n", "meminfo-available", 0},+ {"explicit-available-does-not-use-estimate", "MemTotal: 8192 kB\nMemAvailable: 4096 kB\nMemFree: 4096 kB\nCached: 6144 kB\nSwapTotal: 16384 kB\nSwapFree: 12288 kB\n", "meminfo-available", 4096 * 1024},+ } {+ t.Run(tc.name, func(t *testing.T) {+ got, err := ParseLinuxMemoryAvailability(tc.content, false)+ if err != nil || got.Source != tc.source || got.EffectiveAvailable != tc.available || got.Total != 8192*1024 {+ t.Errorf("valid boundary changed: %+v error=%v", got, err)+ }+ })+ }+}