Adapt vGPU liveness guards to the identity struct resolver

The claim guard and startup reconcile protection predate the
HypervisorProcessIdentity struct and the removal of the standalone
identity-exists helpers. Route both through resolveLiveHypervisorPID:
the claim guard keeps failing closed on unresolvable ownership, and
reconcile protection gets a fail-open HypervisorMayBeAlive wrapper so
unresolvable ownership still protects the device.

Author: yummybomb

cmd/api/main.go

@@ -196,7 +196,7 @@ func liveInstanceVGPUDevicePaths(ctx context.Context, instanceManager instances.
 		if inst.GPUDevicePath == "" {
 			continue
 		}
-		if inst.HypervisorPID != nil && instances.HypervisorProcessIdentityExists(*inst.HypervisorPID, inst.HypervisorStartTime, inst.HypervisorBootID, inst.SocketPath) {
+		if inst.HypervisorPID != nil && instances.HypervisorMayBeAlive(inst.HypervisorProcessIdentity, inst.SocketPath) {
 			protected[inst.GPUDevicePath] = struct{}{}
 			continue
 		}

cmd/api/main_test.go

@@ -362,8 +362,8 @@ func TestLiveInstanceVGPUDevicePathsBoundsStartupProtection(t *testing.T) {
 		{StoredMetadata: instances.StoredMetadata{Id: "booting", GPUDevicePath: "/sys/bus/pci/devices/0000:82:00.4", GPUAssignedAt: &recent}},
 		{StoredMetadata: instances.StoredMetadata{Id: "orphaned", GPUDevicePath: "/sys/bus/pci/devices/0000:82:00.5", GPUAssignedAt: &stale}},
 		{StoredMetadata: instances.StoredMetadata{Id: "legacy", GPUDevicePath: "/sys/bus/pci/devices/0000:82:00.6"}},
-		{StoredMetadata: instances.StoredMetadata{Id: "dead", GPUDevicePath: "/sys/bus/pci/devices/0000:82:00.7", HypervisorPID: &deadPID}},
-		{StoredMetadata: instances.StoredMetadata{Id: "stale-pid-booting", GPUDevicePath: "/sys/bus/pci/devices/0000:82:00.8", HypervisorPID: &deadPID, GPUAssignedAt: &recent}},
+		{StoredMetadata: instances.StoredMetadata{Id: "dead", GPUDevicePath: "/sys/bus/pci/devices/0000:82:00.7", HypervisorProcessIdentity: instances.HypervisorProcessIdentity{HypervisorPID: &deadPID}}},
+		{StoredMetadata: instances.StoredMetadata{Id: "stale-pid-booting", GPUDevicePath: "/sys/bus/pci/devices/0000:82:00.8", HypervisorProcessIdentity: instances.HypervisorProcessIdentity{HypervisorPID: &deadPID}, GPUAssignedAt: &recent}},
 	}}
 
 	protected, retryAfter, err := liveInstanceVGPUDevicePaths(context.Background(), manager)

lib/instances/lifecycle_noop_test.go

@@ -258,17 +258,17 @@ func TestDeleteDropsStaleVGPUClaimedByLiveInstance(t *testing.T) {
 	require.NoError(t, err)
 	defer listener.Close()
 	require.NoError(t, m.saveMetadata(&metadata{StoredMetadata: StoredMetadata{
-		Id:             claimantID,
-		Name:           claimantID,
-		Image:          "test-image",
-		CreatedAt:      now,
-		HypervisorType: lifecycleNoopHypervisorType,
-		HypervisorPID:  &pid,
-		SocketPath:     socketPath,
-		DataDir:        m.paths.InstanceDir(claimantID),
-		GPUProfile:     "NVIDIA L40S-2Q",
-		GPUFramework:   devices.VGPUFrameworkVendorVFIO,
-		GPUDevicePath:  "/sys/bus/pci/devices/0000:82:00.4",
+		Id:                        claimantID,
+		Name:                      claimantID,
+		Image:                     "test-image",
+		CreatedAt:                 now,
+		HypervisorType:            lifecycleNoopHypervisorType,
+		HypervisorProcessIdentity: HypervisorProcessIdentity{HypervisorPID: &pid},
+		SocketPath:                socketPath,
+		DataDir:                   m.paths.InstanceDir(claimantID),
+		GPUProfile:                "NVIDIA L40S-2Q",
+		GPUFramework:              devices.VGPUFrameworkVendorVFIO,
+		GPUDevicePath:             "/sys/bus/pci/devices/0000:82:00.4",
 	}}))
 
 	require.NoError(t, m.DeleteInstance(context.Background(), id))

lib/instances/process_identity.go

@@ -162,6 +162,16 @@ func classifyResolvedHypervisorOwner(socketPath string, stored, resolved int, er
 	return 0, fmt.Errorf("cannot confirm ownership of socket %s: %w", socketPath, err)
 }
 
+// HypervisorMayBeAlive reports whether the recorded hypervisor process may
+// still be running. It fails open: when ownership cannot be resolved it
+// returns true, which is the safe direction for its callers (reconcile
+// protection and claim checks, where true means "protect"). Do not use it to
+// authorize teardown.
+func HypervisorMayBeAlive(id HypervisorProcessIdentity, socketPath string) bool {
+	pid, err := resolveLiveHypervisorPID(id, socketPath)
+	return err != nil || pid > 0
+}
+
 // ProcessExists reports whether pid belongs to a live, non-zombie process.
 func ProcessExists(pid int) bool {
 	if pid <= 0 {

lib/instances/process_identity_linux_test.go

@@ -435,7 +435,7 @@ func TestRefreshHypervisorPIDResolvesSocketOwnerWhenStoredPIDIsDead(t *testing.T
 
 func TestVGPUAssignmentClaimedByLiveInstanceProtectsReusedPIDClaim(t *testing.T) {
 	socketPath := filepath.Join(t.TempDir(), "test.sock")
-	owner := exec.Command(os.Args[0], "-test.run=^TestHypervisorProcessExistsWithReboundSocketPathHelper$")
+	owner := exec.Command(os.Args[0], "-test.run=^TestSocketListenerHelper$")
 	owner.Env = append(os.Environ(), "HYPERVISOR_SOCKET_HELPER=1", "HYPERVISOR_SOCKET_PATH="+socketPath)
 	stdin, err := owner.StdinPipe()
 	require.NoError(t, err)
@@ -462,11 +462,11 @@ func TestVGPUAssignmentClaimedByLiveInstanceProtectsReusedPIDClaim(t *testing.T)
 	stalePID := stale.Process.Pid
 	require.NoError(t, m.ensureDirectories("live-claimant"))
 	require.NoError(t, m.saveMetadata(&metadata{StoredMetadata: StoredMetadata{
-		Id:            "live-claimant",
-		GPUFramework:  devices.VGPUFrameworkVendorVFIO,
-		GPUDevicePath: devicePath,
-		HypervisorPID: &stalePID,
-		SocketPath:    socketPath,
+		Id:                        "live-claimant",
+		GPUFramework:              devices.VGPUFrameworkVendorVFIO,
+		GPUDevicePath:             devicePath,
+		HypervisorProcessIdentity: HypervisorProcessIdentity{HypervisorPID: &stalePID},
+		SocketPath:                socketPath,
 	}}))
 
 	claimed, err := m.vgpuAssignmentClaimedByLiveInstance(context.Background(), "other-instance", devicePath)

lib/instances/vgpu.go

@@ -201,7 +201,7 @@ func (m *manager) vgpuAssignmentClaimedByLiveInstance(ctx context.Context, exclu
 			}
 			return false, fmt.Errorf("cannot confirm liveness of recent vGPU claimant %s on %s: no persisted hypervisor PID", id, devicePath)
 		}
-		pid, err := resolveLiveHypervisorPID(stored.HypervisorPID, stored.HypervisorStartTime, stored.HypervisorBootID, stored.SocketPath)
+		pid, err := resolveLiveHypervisorPID(stored.HypervisorProcessIdentity, stored.SocketPath)
 		if err != nil {
 			return false, fmt.Errorf("cannot confirm liveness of vGPU claimant %s on %s: %w", id, devicePath, err)
 		}

lib/instances/vgpu_test.go

@@ -483,10 +483,10 @@ func TestVGPUAssignmentClaimedByLiveInstanceNormalizesLegacyMdevPath(t *testing.
 	require.NoError(t, m.ensureDirectories("legacy-claimant"))
 	pid := os.Getpid()
 	require.NoError(t, m.saveMetadata(&metadata{StoredMetadata: StoredMetadata{
-		Id:            "legacy-claimant",
-		Name:          "legacy-claimant",
-		GPUMdevUUID:   "legacy-uuid",
-		HypervisorPID: &pid,
+		Id:                        "legacy-claimant",
+		Name:                      "legacy-claimant",
+		GPUMdevUUID:               "legacy-uuid",
+		HypervisorProcessIdentity: HypervisorProcessIdentity{HypervisorPID: &pid},
 	}}))
 
 	claimed, err := m.vgpuAssignmentClaimedByLiveInstance(context.Background(), "other-instance", "/sys/bus/mdev/devices/legacy-uuid")
@@ -538,11 +538,11 @@ func TestVGPUAssignmentClaimedByLiveInstanceGracesRecentDeadPIDClaim(t *testing.
 	require.False(t, ProcessExists(deadPID))
 	assignedAt := time.Now().UTC()
 	require.NoError(t, m.saveMetadata(&metadata{StoredMetadata: StoredMetadata{
-		Id:            claimantID,
-		HypervisorPID: &deadPID,
-		GPUFramework:  devices.VGPUFrameworkVendorVFIO,
-		GPUDevicePath: "/sys/bus/pci/devices/0000:82:00.4",
-		GPUAssignedAt: &assignedAt,
+		Id:                        claimantID,
+		HypervisorProcessIdentity: HypervisorProcessIdentity{HypervisorPID: &deadPID},
+		GPUFramework:              devices.VGPUFrameworkVendorVFIO,
+		GPUDevicePath:             "/sys/bus/pci/devices/0000:82:00.4",
+		GPUAssignedAt:             &assignedAt,
 	}}))
 
 	// Same bounded grace as startup reconcile: a recent claim whose PID is
@@ -569,10 +569,10 @@ func TestVGPUAssignmentClaimedByLiveInstanceIgnoresDeadClaim(t *testing.T) {
 	require.NoError(t, m.ensureDirectories("dead-claimant"))
 	deadPID := 1 << 30
 	require.NoError(t, m.saveMetadata(&metadata{StoredMetadata: StoredMetadata{
-		Id:            "dead-claimant",
-		Name:          "dead-claimant",
-		GPUDevicePath: "/sys/bus/pci/devices/0000:82:00.4",
-		HypervisorPID: &deadPID,
+		Id:                        "dead-claimant",
+		Name:                      "dead-claimant",
+		GPUDevicePath:             "/sys/bus/pci/devices/0000:82:00.4",
+		HypervisorProcessIdentity: HypervisorProcessIdentity{HypervisorPID: &deadPID},
 	}}))
 
 	claimed, err := m.vgpuAssignmentClaimedByLiveInstance(context.Background(), "other-instance", "/sys/bus/pci/devices/0000:82:00.4")