gc for vm

Author: CMGS

config/cloudhypervisor.go

@@ -0,0 +1,54 @@
+package config
+
+import (
+	"path/filepath"
+
+	"github.com/projecteru2/cocoon/utils"
+)
+
+// EnsureCHDirs creates all static directories required by the Cloud Hypervisor backend.
+// Per-VM runtime and log directories are created on demand via EnsureCHVMDirs.
+func (c *Config) EnsureCHDirs() error {
+	return utils.EnsureDirs(
+		c.chDBDir(),
+		c.chLogDir(),
+	)
+}
+
+// EnsureCHVMDirs creates per-VM runtime and log directories.
+// Called when a VM is created or started.
+func (c *Config) EnsureCHVMDirs(vmID string) error {
+	return utils.EnsureDirs(
+		c.CHVMRunDir(vmID),
+		c.CHVMLogDir(vmID),
+	)
+}
+
+// Derived path helpers. All CH persistent data lives under {RootDir}/cloudhypervisor/.
+
+func (c *Config) chDir() string   { return filepath.Join(c.RootDir, "cloudhypervisor") }
+func (c *Config) chDBDir() string { return filepath.Join(c.chDir(), "db") }
+
+// CHIndexFile and CHIndexLock are the VM index store paths.
+func (c *Config) CHIndexFile() string { return filepath.Join(c.chDBDir(), "vms.json") }
+func (c *Config) CHIndexLock() string { return filepath.Join(c.chDBDir(), "vms.lock") }
+
+// Runtime paths (per VM, under RunDir — ephemeral).
+
+func (c *Config) CHVMRunDir(vmID string) string  { return filepath.Join(c.RunDir, "cloudhypervisor", vmID) }
+func (c *Config) CHVMSocketPath(vmID string) string { return filepath.Join(c.CHVMRunDir(vmID), "api.sock") }
+func (c *Config) CHVMPIDFile(vmID string) string    { return filepath.Join(c.CHVMRunDir(vmID), "ch.pid") }
+
+// Log paths (per VM, under {LogDir}/cloudhypervisor/).
+// Namespaced under "cloudhypervisor" so future backends (e.g. qemu) scan
+// their own subdirectory and never conflict during GC.
+
+func (c *Config) chLogDir() string                   { return filepath.Join(c.LogDir, "cloudhypervisor") }
+func (c *Config) CHVMLogDir(vmID string) string      { return filepath.Join(c.chLogDir(), vmID) }
+func (c *Config) CHVMSerialLog(vmID string) string   { return filepath.Join(c.CHVMLogDir(vmID), "serial.log") }
+func (c *Config) CHVMProcessLog(vmID string) string  { return filepath.Join(c.CHVMLogDir(vmID), "ch.log") }
+
+// FirmwarePath returns the path to the UEFI firmware blob (CLOUDHV.fd).
+func (c *Config) FirmwarePath() string {
+	return filepath.Join(c.RootDir, "firmware", "CLOUDHV.fd")
+}

config/config.go

@@ -4,16 +4,24 @@ import (
 	"encoding/json"
 	"fmt"
 	"os"
-	"path/filepath"
+
 	"runtime"
 
 	coretypes "github.com/projecteru2/core/types"
 )
 
 // Config holds global Cocoon configuration.
 type Config struct {
-	// RootDir is the base directory for persistent data.
+	// RootDir is the base directory for persistent data (images, firmware, VM DB).
+	// Env: COCOON_ROOT_DIR. Default: /var/lib/cocoon.
 	RootDir string `json:"root_dir"`
+	// RunDir is the base directory for runtime state (PID files, Unix sockets).
+	// Contents are ephemeral and may not survive reboots.
+	// Env: COCOON_RUN_DIR. Default: /var/run/cocoon.
+	RunDir string `json:"run_dir"`
+	// LogDir is the base directory for VM and process logs.
+	// Env: COCOON_LOG_DIR. Default: /var/log/cocoon.
+	LogDir string `json:"log_dir"`
 	// PoolSize is the goroutine pool size for concurrent operations.
 	// Defaults to runtime.NumCPU() if zero.
 	PoolSize int `json:"pool_size"`
@@ -25,6 +33,8 @@ type Config struct {
 func DefaultConfig() *Config {
 	return &Config{
 		RootDir:  "/var/lib/cocoon",
+		RunDir:   "/var/run/cocoon",
+		LogDir:   "/var/log/cocoon",
 		PoolSize: runtime.NumCPU(),
 		Log: coretypes.ServerLogConfig{
 			Level:      "info",
@@ -60,7 +70,3 @@ func LoadConfig(path string) (*Config, error) {
 	return conf, nil
 }
 
-// FirmwarePath returns the path to the UEFI firmware file (CLOUDHV.fd).
-func (c *Config) FirmwarePath() string {
-	return filepath.Join(c.RootDir, "firmware", "CLOUDHV.fd")
-}

hypervisor/cloudhypervisor/cloudhypervisor.go

@@ -0,0 +1,62 @@
+package cloudhypervisor
+
+import (
+	"context"
+	"fmt"
+
+	"github.com/projecteru2/cocoon/config"
+	"github.com/projecteru2/cocoon/hypervisor"
+	"github.com/projecteru2/cocoon/lock"
+	"github.com/projecteru2/cocoon/lock/flock"
+	storejson "github.com/projecteru2/cocoon/storage/json"
+	"github.com/projecteru2/cocoon/storage"
+	"github.com/projecteru2/cocoon/types"
+)
+
+const typ = "cloud-hypervisor"
+
+// CloudHypervisor implements hypervisor.Hypervisor using the Cloud Hypervisor VMM.
+type CloudHypervisor struct {
+	conf   *config.Config
+	store  storage.Store[hypervisor.VMIndex]
+	locker lock.Locker
+}
+
+// New creates a CloudHypervisor backend.
+func New(conf *config.Config) (*CloudHypervisor, error) {
+	if err := conf.EnsureCHDirs(); err != nil {
+		return nil, fmt.Errorf("ensure dirs: %w", err)
+	}
+	locker := flock.New(conf.CHIndexLock())
+	store := storejson.New[hypervisor.VMIndex](conf.CHIndexFile(), locker)
+	return &CloudHypervisor{conf: conf, store: store, locker: locker}, nil
+}
+
+func (ch *CloudHypervisor) Type() string { return typ }
+
+// Create, Start, Stop, Inspect, List, Delete — to be implemented.
+
+func (ch *CloudHypervisor) Create(_ context.Context, _ *types.VMConfig, _ []*types.StorageConfig, _ *types.BootConfig) (*types.VMInfo, error) {
+	panic("not implemented")
+}
+
+func (ch *CloudHypervisor) Start(_ context.Context, _ []string) ([]string, error) {
+	panic("not implemented")
+}
+
+func (ch *CloudHypervisor) Stop(_ context.Context, _ []string) ([]string, error) {
+	panic("not implemented")
+}
+
+func (ch *CloudHypervisor) Inspect(_ context.Context, _ string) (*types.VMInfo, error) {
+	panic("not implemented")
+}
+
+func (ch *CloudHypervisor) List(_ context.Context) ([]*types.VMInfo, error) {
+	panic("not implemented")
+}
+
+func (ch *CloudHypervisor) Delete(_ context.Context, _ []string) ([]string, error) {
+	panic("not implemented")
+}
+

hypervisor/cloudhypervisor/gc.go

@@ -0,0 +1,83 @@
+package cloudhypervisor
+
+import (
+	"context"
+	"errors"
+	"os"
+	"path/filepath"
+
+	"github.com/projecteru2/cocoon/gc"
+	"github.com/projecteru2/cocoon/hypervisor"
+	"github.com/projecteru2/cocoon/utils"
+)
+
+// compile-time interface check.
+var _ hypervisor.Hypervisor = (*CloudHypervisor)(nil)
+
+// chSnapshot is the typed GC snapshot for the Cloud Hypervisor backend.
+type chSnapshot struct {
+	vmIDs   map[string]struct{} // VM IDs present in the DB index
+	runDirs []string            // VM IDs that have a runtime dir on disk
+	logDirs []string            // VM IDs that have a log dir on disk
+}
+
+// GCModule returns a typed gc.Module[chSnapshot] for the Cloud Hypervisor backend.
+//
+// ReadDB (under lock): reads the VM index and scans the runtime/log base dirs
+// on disk, returning a snapshot of what exists vs what is recorded.
+//
+// Resolve: returns VM IDs whose runtime or log dirs are orphaned (present on
+// disk but no longer in the DB).
+//
+// Collect (under lock): removes the orphaned dirs for each VM ID.
+func (ch *CloudHypervisor) GCModule() gc.Module[chSnapshot] {
+	return gc.Module[chSnapshot]{
+		Name:   typ,
+		Locker: ch.locker,
+		ReadDB: func(ctx context.Context) (chSnapshot, error) {
+			var snap chSnapshot
+			if err := ch.store.Read(func(idx *hypervisor.VMIndex) error {
+				snap.vmIDs = make(map[string]struct{}, len(idx.VMs))
+				for id := range idx.VMs {
+					snap.vmIDs[id] = struct{}{}
+				}
+				return nil
+			}); err != nil {
+				return snap, err
+			}
+			snap.runDirs = utils.ScanSubdirs(filepath.Join(ch.conf.RunDir, "cloudhypervisor"))
+			snap.logDirs = utils.ScanSubdirs(filepath.Join(ch.conf.LogDir, "cloudhypervisor"))
+			return snap, nil
+		},
+		Resolve: func(snap chSnapshot, _ map[string]any) []string {
+			unreferenced := utils.FilterUnreferenced(snap.runDirs, snap.vmIDs)
+			seen := make(map[string]struct{}, len(unreferenced))
+			for _, id := range unreferenced {
+				seen[id] = struct{}{}
+			}
+			for _, id := range utils.FilterUnreferenced(snap.logDirs, snap.vmIDs) {
+				if _, already := seen[id]; !already {
+					unreferenced = append(unreferenced, id)
+				}
+			}
+			return unreferenced
+		},
+		Collect: func(ctx context.Context, ids []string) error {
+			var errs []error
+			for _, vmID := range ids {
+				if err := os.RemoveAll(ch.conf.CHVMRunDir(vmID)); err != nil && !os.IsNotExist(err) {
+					errs = append(errs, err)
+				}
+				if err := os.RemoveAll(ch.conf.CHVMLogDir(vmID)); err != nil && !os.IsNotExist(err) {
+					errs = append(errs, err)
+				}
+			}
+			return errors.Join(errs...)
+		},
+	}
+}
+
+// RegisterGC registers the Cloud Hypervisor GC module with the given Orchestrator.
+func (ch *CloudHypervisor) RegisterGC(orch *gc.Orchestrator) {
+	gc.Register(orch, ch.GCModule())
+}

hypervisor/db.go

@@ -0,0 +1,38 @@
+package hypervisor
+
+import "github.com/projecteru2/cocoon/types"
+
+// VMRecord is the persisted record for a single VM.
+// It extends types.VMInfo with the disk and boot configuration needed to
+// restart a VM without re-resolving the image.
+//
+// PID and SocketPath on types.VMInfo are NOT stored here:
+//   - SocketPath is deterministic: derived from config at query time.
+//   - PID changes on every start; Inspect reads the live value from the PID
+//     file instead, avoiding stale PIDs after a crash or reboot.
+type VMRecord struct {
+	types.VMInfo
+
+	// StorageConfigs holds the ordered disk attachments at creation time
+	// (EROFS layers first, then the COW disk). Persisted so that a stopped
+	// VM can be restarted with the same disk layout.
+	StorageConfigs []*types.StorageConfig `json:"storage_configs"`
+
+	// BootConfig holds the kernel and initrd paths for direct-boot VMs.
+	// Nil for UEFI-boot VMs (cloud images).
+	BootConfig *types.BootConfig `json:"boot_config,omitempty"`
+}
+
+// VMIndex is the top-level DB structure shared by all hypervisor backends.
+// Each backend stores its VMs under a separate index file
+// (e.g. {RootDir}/cloudhypervisor/db/vms.json).
+type VMIndex struct {
+	VMs map[string]*VMRecord `json:"vms"`
+}
+
+// Init implements storage.Initer — initialises the nil map after deserialization.
+func (idx *VMIndex) Init() {
+	if idx.VMs == nil {
+		idx.VMs = make(map[string]*VMRecord)
+	}
+}

images/index.go

@@ -149,28 +149,11 @@ func ListImages[E Entry](images map[string]*E, typ string, sizer func(*E) int64)
 }
 
 // ScanBlobHexes returns the digest hexes of all files with the given suffix in dir.
-// Used by GC ReadDB implementations to build the on-disk candidate set.
-func ScanBlobHexes(dir, suffix string) []string {
-	entries, _ := os.ReadDir(dir)
-	var hexes []string
-	for _, e := range entries {
-		if strings.HasSuffix(e.Name(), suffix) {
-			hexes = append(hexes, strings.TrimSuffix(e.Name(), suffix))
-		}
-	}
-	return hexes
-}
+func ScanBlobHexes(dir, suffix string) []string { return utils.ScanFileStems(dir, suffix) }
 
 // FilterUnreferenced returns elements of candidates not present in refs.
-// Used by GC Resolve implementations to compute the deletion set.
 func FilterUnreferenced(candidates []string, refs map[string]struct{}) []string {
-	var out []string
-	for _, s := range candidates {
-		if _, ok := refs[s]; !ok {
-			out = append(out, s)
-		}
-	}
-	return out
+	return utils.FilterUnreferenced(candidates, refs)
 }
 
 // GCStaleTemp removes temp entries older than StaleTempAge.

utils/file.go

@@ -5,6 +5,7 @@ import (
 	"fmt"
 	"os"
 	"path/filepath"
+	"strings"
 	"time"
 
 	"github.com/projecteru2/core/log"
@@ -29,6 +30,44 @@ func ValidFile(path string) bool {
 	return err == nil && info.Mode().IsRegular() && info.Size() > 0
 }
 
+// ScanFileStems returns the name-without-suffix of every file in dir whose
+// name ends with suffix. Used by GC to enumerate on-disk blobs.
+func ScanFileStems(dir, suffix string) []string {
+	entries, _ := os.ReadDir(dir)
+	var stems []string
+	for _, e := range entries {
+		if !e.IsDir() && strings.HasSuffix(e.Name(), suffix) {
+			stems = append(stems, strings.TrimSuffix(e.Name(), suffix))
+		}
+	}
+	return stems
+}
+
+// ScanSubdirs returns the names of all immediate subdirectories of dir.
+// Used by GC to enumerate per-VM runtime and log directories.
+func ScanSubdirs(dir string) []string {
+	entries, _ := os.ReadDir(dir)
+	var names []string
+	for _, e := range entries {
+		if e.IsDir() {
+			names = append(names, e.Name())
+		}
+	}
+	return names
+}
+
+// FilterUnreferenced returns the elements of candidates not present in refs.
+// Used by GC Resolve implementations to compute the deletion set.
+func FilterUnreferenced(candidates []string, refs map[string]struct{}) []string {
+	var out []string
+	for _, s := range candidates {
+		if _, ok := refs[s]; !ok {
+			out = append(out, s)
+		}
+	}
+	return out
+}
+
 // RemoveMatching scans dir and removes entries where match returns true.
 // Returns a slice of errors for entries that could not be removed.
 func RemoveMatching(ctx context.Context, dir string, match func(os.DirEntry) bool) []error {