0
0
//go:build linux
package vmruntime
import (
"context"
"encoding/json"
"errors"
"fmt"
"net"
"os"
"path/filepath"
"strconv"
"strings"
"time"
"github.com/johnandersen777/socialweb-computer-kcp/internal/fcapi"
)
const (
QEMUComm = "qemu-system-x86"
QEMUExtraTasks = 64
)
type vmmAPI interface {
Describe(ctx context.Context) (fcapi.Instance, error)
SendCtrlAltDel(ctx context.Context) error
}
func apiFor(vmm, socket string) vmmAPI {
if vmm == VMMFirecracker {
return fcapi.NewClient(socket, 2*time.Second)
}
return qmpClient{socket: socket, timeout: 2 * time.Second}
}
func qemuRoot(exe string) string { return filepath.Dir(filepath.Dir(filepath.Dir(exe))) }
func qemuDataDir(exe string) string { return filepath.Join(qemuRoot(exe), "usr", "share", "qemu") }
func qemuLibDir(exe string) string {
d := filepath.Join(qemuRoot(exe), "usr", "lib", "sys")
if st, err := os.Stat(d); err == nil && st.IsDir() {
return d
}
return ""
}
func qemuEnv(exe string) []string {
if d := qemuLibDir(exe); d != "" {
return []string{"LD_LIBRARY_PATH=" + d}
}
return nil
}
func qemuArgv(exe, vmmID string, c fcapi.Config, socket string) ([]string, error) {
for _, d := range c.Drives {
if strings.Contains(d.PathOnHost, ",") {
return nil, fmt.Errorf("vmruntime: drive path %s holds a comma, which QEMU reads as an option separator", d.PathOnHost)
}
}
argv := []string{QEMUExecutable, "-name", vmmID,
"-M", "microvm,acpi=off", "-accel", "kvm", "-cpu", qemuCPU(HostSGXDisabled()),
"-smp", strconv.Itoa(c.MachineConfig.VcpuCount), "-m", strconv.Itoa(c.MachineConfig.MemSizeMiB),
"-nodefaults", "-no-user-config", "-display", "none", "-no-reboot",
"-sandbox", "on,obsolete=deny,elevateprivileges=deny,spawn=deny,resourcecontrol=deny",
"-L", qemuDataDir(exe), "-serial", "stdio", "-device", "i8042",
"-kernel", c.BootSource.KernelImagePath, "-append", c.BootSource.BootArgs,
"-qmp", "unix:" + socket + ",server=on,wait=off"}
for _, d := range c.Drives {
drive := "id=" + d.DriveID + ",file=" + d.PathOnHost + ",format=raw,if=none,cache=none,aio=native"
if d.IsReadOnly {
drive += ",readonly=on"
}
argv = append(argv, "-drive", drive, "-device", "virtio-blk-device,drive="+d.DriveID)
}
for _, n := range c.NetworkInterfaces {
argv = append(argv, "-netdev", "tap,id="+n.IfaceID+",ifname="+n.HostDevName+",script=no,downscript=no",
"-device", "virtio-net-device,netdev="+n.IfaceID+",mac="+n.GuestMAC)
}
return argv, nil
}
type qmpClient struct {
socket string
timeout time.Duration
}
type qmpReply struct {
Return json.RawMessage `json:"return"`
Error *struct {
Class string `json:"class"`
Desc string `json:"desc"`
} `json:"error"`
Event string `json:"event"`
}
func (q qmpClient) run(ctx context.Context, cmds ...map[string]any) ([]json.RawMessage, error) {
d := net.Dialer{Timeout: q.timeout}
c, err := d.DialContext(ctx, "unix", q.socket)
if err != nil {
return nil, fmt.Errorf("qmp: dialing %s: %w", q.socket, err)
}
defer c.Close()
deadline := time.Now().Add(q.timeout)
if dl, ok := ctx.Deadline(); ok && dl.Before(deadline) {
deadline = dl
}
c.SetDeadline(deadline)
dec, enc := json.NewDecoder(c), json.NewEncoder(c)
var greeting map[string]json.RawMessage
if err := dec.Decode(&greeting); err != nil {
return nil, fmt.Errorf("qmp: greeting on %s: %w", q.socket, err)
}
if _, ok := greeting["QMP"]; !ok {
return nil, fmt.Errorf("qmp: %s does not greet as QMP", q.socket)
}
var out []json.RawMessage
for _, cmd := range append([]map[string]any{{"execute": "qmp_capabilities"}}, cmds...) {
if err := enc.Encode(cmd); err != nil {
return nil, fmt.Errorf("qmp: %v: %w", cmd["execute"], err)
}
for {
var r qmpReply
if err := dec.Decode(&r); err != nil {
return nil, fmt.Errorf("qmp: %v: %w", cmd["execute"], err)
}
if r.Event != "" {
continue
}
if r.Error != nil {
return nil, fmt.Errorf("qmp: %v: %s: %s", cmd["execute"], r.Error.Class, r.Error.Desc)
}
out = append(out, r.Return)
break
}
}
return out[1:], nil
}
func (q qmpClient) Describe(ctx context.Context) (fcapi.Instance, error) {
out, err := q.run(ctx, map[string]any{"execute": "query-name"}, map[string]any{"execute": "query-status"})
if err != nil {
return fcapi.Instance{}, err
}
var name struct {
Name string `json:"name"`
}
var status struct {
Status string `json:"status"`
Running bool `json:"running"`
}
if err := errors.Join(json.Unmarshal(out[0], &name), json.Unmarshal(out[1], &status)); err != nil {
return fcapi.Instance{}, fmt.Errorf("qmp: %w", err)
}
in := fcapi.Instance{ID: name.Name, State: status.Status}
if status.Running {
in.State = fcapi.StateRunning
}
return in, nil
}
func (q qmpClient) SendCtrlAltDel(ctx context.Context) error {
keys := []map[string]string{{"type": "qcode", "data": "ctrl"}, {"type": "qcode", "data": "alt"}, {"type": "qcode", "data": "delete"}}
_, err := q.run(ctx, map[string]any{"execute": "send-key", "arguments": map[string]any{"keys": keys}})
return err
}