Rename cmd directory to src

src/ectl/go.mod

@@ -0,0 +1,5 @@
+module ectl
+
+go 1.23.4
+
+require gopkg.in/yaml.v3 v3.0.1

src/ectl/go.sum

@@ -0,0 +1,4 @@
+gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405 h1:yhCVgyC4o1eVCa2tZl7eS0r+SDo693bJlVdllGtEeKM=
+gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
+gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA=
+gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=

src/ectl/main.go

@@ -0,0 +1,340 @@
+package main
+
+import (
+	"flag"
+	"fmt"
+	"gopkg.in/yaml.v3"
+	"log"
+	"net"
+	"os"
+	"path"
+	"strconv"
+	"strings"
+	"syscall"
+	"time"
+)
+
+// Build-time variables
+var version = "dev"
+var sysconfdir = "/etc/"
+var runstatedir = "/var/run/"
+
+var socket net.Conn
+
+func main() {
+
+	// Set and parse flags
+	printVersion := flag.Bool("version", false, "print version and exit")
+	flag.Parse()
+
+	// Dial esvm socket
+	dialSocket()
+	defer socket.Close()
+
+	if flag.NArg() < 1 {
+		printUsage()
+		os.Exit(1)
+	}
+
+	if *printVersion || flag.Args()[0] == "version" {
+		fmt.Printf("Enit Control version %s\n", version)
+		return
+	} else if flag.Args()[0] == "help" {
+		printUsage()
+		return
+	} else if flag.Args()[0] == "shutdown" || flag.Args()[0] == "poweroff" || flag.Args()[0] == "halt" {
+		err := syscall.Kill(1, syscall.SIGUSR1)
+		if err != nil {
+			log.Fatalf("Could not send shutdown signal! Error: %s\n", err)
+		}
+		return
+	} else if flag.Args()[0] == "reboot" || flag.Args()[0] == "restart" || flag.Args()[0] == "reset" {
+		err := syscall.Kill(1, syscall.SIGTERM)
+		if err != nil {
+			log.Fatalf("Could not send shutdown signal! Error: %s\n", err)
+		}
+		return
+	} else if flag.Args()[0] == "service" || flag.Args()[0] == "sv" {
+		if len(flag.Args()) <= 1 {
+			fmt.Println("Usage: ectl service <start/stop/enable/disable/status/list> [service]")
+			return
+		} else if flag.Args()[1] == "list" {
+			if _, err := os.Stat(path.Join(runstatedir, "esvm")); err != nil {
+				log.Fatalf("Could not list services! Error: %s\n", err)
+			}
+
+			entries, err := os.ReadDir(path.Join(runstatedir, "esvm"))
+			if err != nil {
+				log.Fatalf("Could not list services! Error: %s\n", err)
+			}
+
+			for _, entry := range entries {
+				if !entry.IsDir() {
+					continue
+				}
+
+				state := getServiceState(entry.Name())
+				enabled := strconv.FormatBool(isServiceEnabled(entry.Name()))
+				enabled = strings.ToUpper(enabled[:1]) + strings.ToLower(enabled[1:])
+
+				fmt.Println("Service name: " + entry.Name())
+				fmt.Printf("    State: %s\n", state)
+				fmt.Printf("    Enabled: %s\n", enabled)
+			}
+			return
+		} else if len(flag.Args()) <= 2 {
+			fmt.Printf("Usage: ectl service %s <service>\n", flag.Args()[1])
+			return
+		} else if flag.Args()[1] == "start" {
+			if _, err := os.Stat(path.Join(runstatedir, "esvm", flag.Args()[2])); err != nil {
+				log.Fatalf("Could not start service! Error: %s\n", err)
+			}
+
+			_, err := socket.Write([]byte("start " + flag.Args()[2]))
+			if err != nil {
+				log.Fatalf("Could not start service! Error: %s\n", err)
+			}
+
+			buf := make([]byte, 1024)
+			n, err := socket.Read(buf)
+			if err != nil {
+				log.Fatalf("Could not start service! Error: %s\n", err)
+			}
+			if string(buf[:n]) != "ok" {
+				log.Fatalf("Could not start service! Error: expcted 'ok' got '%s'\n", string(buf))
+			}
+
+			fmt.Println("Service started successfully!")
+			return
+		} else if flag.Args()[1] == "stop" {
+			if _, err := os.Stat(path.Join(runstatedir, "esvm", flag.Args()[2])); err != nil {
+				log.Fatalf("Could not stop service! Error: %s\n", err)
+			}
+
+			_, err := socket.Write([]byte("stop " + flag.Args()[2]))
+			if err != nil {
+				log.Fatalf("Could not stop service! Error: %s\n", err)
+			}
+
+			buf := make([]byte, 1024)
+			n, err := socket.Read(buf)
+			if err != nil {
+				log.Fatalf("Could not stop service! Error: %s\n", err)
+			}
+			if string(buf[:n]) != "ok" {
+				log.Fatalf("Could not stop service! Error: expcted 'ok' got '%s'\n", string(buf))
+			}
+			fmt.Println("Service stopped successfully!")
+			return
+		} else if flag.Args()[1] == "restart" || flag.Args()[1] == "reload" {
+			if _, err := os.Stat(path.Join(runstatedir, "esvm", flag.Args()[2])); err != nil {
+				log.Fatalf("Could not restart service! Error: %s\n", err)
+			}
+
+			_, err := socket.Write([]byte("restart " + flag.Args()[2]))
+			if err != nil {
+				log.Fatalf("Could not restart service! Error: %s\n", err)
+			}
+
+			buf := make([]byte, 1024)
+			n, err := socket.Read(buf)
+			if err != nil {
+				log.Fatalf("Could not restart service! Error: %s\n", err)
+			}
+			if string(buf[:n]) != "ok" {
+				log.Fatalf("Could not restart service! Error: expcted 'ok' got '%s'\n", string(buf))
+			}
+			fmt.Println("Service restarted successfully!")
+			return
+		} else if flag.Args()[1] == "enable" {
+			// Check if service exists
+			found := false
+			entries, err := os.ReadDir(path.Join(sysconfdir, "esvm/services/"))
+			if err != nil {
+				log.Fatalf("Could not enable service! Error: %s\n", err)
+			}
+			type minimalServiceStruct struct {
+				Name string `yaml:"name"`
+			}
+			for _, entry := range entries {
+				if entry.IsDir() || !strings.HasSuffix(entry.Name(), ".esv") {
+					continue
+				}
+
+				bytes, err := os.ReadFile(path.Join(sysconfdir, "esvm/services", entry.Name()))
+				if err != nil {
+					log.Fatalf("Could not enable service! Error: %s\n", err)
+				}
+
+				sv := minimalServiceStruct{Name: ""}
+				err = yaml.Unmarshal(bytes, &sv)
+				if err != nil {
+					log.Fatalf("Could not enable service! Error: %s\n", err)
+				}
+
+				if sv.Name == flag.Args()[2] {
+					found = true
+					break
+				}
+			}
+			if !found {
+				log.Fatalf("Service does not exist!")
+			}
+
+			if _, err := os.Stat(path.Join(sysconfdir, "esvm/enabled_services")); err != nil {
+				err := os.WriteFile(path.Join(sysconfdir, "esvm/enabled_services"), []byte(flag.Args()[2]+"\n"), 0644)
+				if err != nil {
+					log.Fatalf("Could not enable service! Error: %s\n", err)
+				}
+				return
+			}
+
+			file, err := os.ReadFile(path.Join(sysconfdir, "esvm/enabled_services"))
+			if err != nil {
+				log.Fatalf("Could not enable service! Error: %s\n", err)
+			}
+			for _, line := range strings.Split(string(file), "\n") {
+				if strings.TrimSpace(line) == flag.Args()[2] {
+					fmt.Println("Service is already enabled!")
+					return
+				}
+			}
+
+			err = os.WriteFile(path.Join(sysconfdir, "esvm/enabled_services"), []byte(string(file)+flag.Args()[2]+"\n"), 0644)
+			if err != nil {
+				log.Fatalf("Could not enable service! Error: %s\n", err)
+			}
+
+			fmt.Printf("Service (%s) has been enabled!\n", flag.Args()[2])
+			return
+		} else if flag.Args()[1] == "disable" {
+			if _, err := os.Stat(path.Join(sysconfdir, "esvm/enabled_services")); err != nil {
+				fmt.Println("Service is already disabled!")
+				return
+			}
+
+			file, err := os.ReadFile(path.Join(sysconfdir, "esvm/enabled_services"))
+			if err != nil {
+				log.Fatalf("Could not disable service! Error: %s\n", err)
+			}
+
+			lines := strings.Split(string(file), "\n")
+			found := false
+			for i := len(lines) - 1; i >= 0; i-- {
+				line := strings.TrimSpace(lines[i])
+				if strings.TrimSpace(line) == flag.Args()[2] {
+					lines = append(lines[:i], lines[i+1:]...)
+					found = true
+				} else if strings.TrimSpace(line) == "" {
+					lines = append(lines[:i], lines[i+1:]...)
+				}
+			}
+
+			if !found {
+				fmt.Println("Service is already disabled!")
+				return
+			}
+
+			err = os.WriteFile(path.Join(sysconfdir, "esvm/enabled_services"), []byte(strings.Join(lines, "\n")+"\n"), 0644)
+			if err != nil {
+				log.Fatalf("Could not disable service! Error: %s\n", err)
+			}
+
+			fmt.Printf("Service (%s) has been disabled!\n", flag.Args()[2])
+			return
+		} else if flag.Args()[1] == "status" {
+			if _, err := os.Stat(path.Join(runstatedir, "esvm", flag.Args()[2])); err != nil {
+				log.Fatalf("Could not get service status! Error: %s\n", err)
+			}
+
+			state := getServiceState(flag.Args()[2])
+			enabled := strconv.FormatBool(isServiceEnabled(flag.Args()[2]))
+			enabled = strings.ToUpper(enabled[:1]) + strings.ToLower(enabled[1:])
+
+			fmt.Println("Service name: " + flag.Args()[2])
+			fmt.Printf("    State: %s\n", state)
+			fmt.Printf("    Enabled: %s\n", enabled)
+			return
+		}
+	}
+
+	printUsage()
+	os.Exit(1)
+}
+
+func getServiceState(serviceName string) string {
+	if _, err := os.Stat(path.Join(runstatedir, "esvm", serviceName)); err != nil {
+		return ""
+	}
+
+	var state uint64
+	bytes, err := os.ReadFile(path.Join(runstatedir, "esvm", serviceName, "state"))
+	if err != nil {
+		state = 0
+	}
+	state, err = strconv.ParseUint(string(bytes), 10, 8)
+
+	switch state {
+	case 1:
+		return "Unloaded"
+	case 2:
+		return "Running"
+	case 3:
+		return "Stopped"
+	case 4:
+		return "Crashed"
+	case 5:
+		return "Completed"
+	default:
+		return "Unknown"
+	}
+}
+
+func isServiceEnabled(serviceName string) bool {
+	if _, err := os.Stat(path.Join(sysconfdir, "esvm/enabled_services")); err != nil {
+		return false
+	}
+
+	file, err := os.ReadFile(path.Join(sysconfdir, "esvm/enabled_services"))
+	if err != nil {
+		return false
+	}
+
+	for _, line := range strings.Split(string(file), "\n") {
+		if strings.TrimSpace(line) == serviceName {
+			return true
+		}
+	}
+
+	return false
+}
+
+func printUsage() {
+	fmt.Println("Available sucommands:")
+	fmt.Println("ectl version | Show enit version")
+	fmt.Println("ectl shutdown/poweroff/halt | Shutdown the system")
+	fmt.Println("ectl reboot/restart | Reboot the system")
+	fmt.Println("ectl help | Show command explanations")
+	fmt.Println("ectl sv/service start <service> | Start a service")
+	fmt.Println("ectl sv/service stop <service> | Stop a service")
+	fmt.Println("ectl sv/service enable <service> | Enable a service at startup")
+	fmt.Println("ectl sv/service disable <service> | Disable a service at startup")
+	fmt.Println("ectl sv/service status <service> | Show service status")
+	fmt.Println("ectl sv/service list | Show all enabled services")
+}
+
+func dialSocket() {
+	if _, err := os.Stat(path.Join(runstatedir, "esvm/esvm.sock")); err != nil {
+		log.Fatalf("Could not find esvm.sock! Error: %s\n", err)
+	}
+
+	var err error
+	socket, err = net.Dial("unix", path.Join(runstatedir, "esvm/esvm.sock"))
+	if err != nil {
+		log.Fatalf("Failed to connect to esvm.sock! Error: %s\n", err)
+	}
+
+	if err := socket.SetDeadline(time.Now().Add(5 * time.Second)); err != nil {
+		log.Fatalf("Failed to set write deadline! Error: %s\n", err)
+	}
+}

src/enit/go.mod

@@ -0,0 +1,5 @@
+module enit
+
+go 1.23.4
+
+require golang.org/x/sys v0.31.0

src/enit/go.sum

@@ -0,0 +1,2 @@
+golang.org/x/sys v0.31.0 h1:ioabZlmFYtWhL+TRYpcnNlLwhyxaM9kWTDEmfnprqik=
+golang.org/x/sys v0.31.0/go.mod h1:BJP2sWEmIv4KK5OTEluFJCKSidICx8ciO85XgH3Ak8k=

src/enit/main.go

@@ -0,0 +1,264 @@
+package main
+
+import (
+	"flag"
+	"fmt"
+	"log"
+	"os"
+	"os/exec"
+	"os/signal"
+	"path"
+	"strings"
+	"syscall"
+	"time"
+	"unsafe"
+)
+
+// Build-time variables
+var version = "dev"
+var sysconfdir = "/etc/"
+var runstatedir = "/var/run/"
+
+var serviceManagerPid int
+
+func main() {
+	// Set Process Name
+	err := setProcessName()
+	if err != nil {
+		log.Printf("Could not set process name! Error: %s", err)
+	}
+
+	// Parse flags
+	printVersion := flag.Bool("version", false, "print version and exit")
+	flag.Parse()
+
+	if *printVersion {
+		fmt.Printf("Enit version %s\n", version)
+		os.Exit(0)
+	}
+
+	if os.Getpid() != 1 {
+		fmt.Println("Enit must be run as PID 1!")
+		os.Exit(1)
+	}
+
+	fmt.Println("Starting Enit...")
+
+	// Mount virtual filesystems
+	mountVirtualFilesystems()
+	// Mount filesystems in fstab
+	mountFilesystems()
+	// Set hostname
+	setHostname()
+	// Start service manager
+	startServiceManager()
+
+	// Run function once to wait zombie processes created by initcpio
+	waitZombieProcesses()
+
+	fmt.Println()
+
+	// Catch signals
+	catchSignals()
+}
+
+func setProcessName() error {
+	bytes := append([]byte("enit"), 0)
+	ptr := unsafe.Pointer(&bytes[0])
+	if _, _, errno := syscall.RawSyscall6(syscall.SYS_PRCTL, syscall.PR_SET_NAME, uintptr(ptr), 0, 0, 0, 0); errno != 0 {
+		return errno
+	}
+	return nil
+}
+
+func mountVirtualFilesystems() {
+	fmt.Print("Mounting virtual filesystems... ")
+
+	commonOptions := "rw,nosuid,relatime"
+
+	// Mount /proc
+	if err := mount("proc", "/proc", "proc", commonOptions+",nodev,noexec", false); err != nil {
+		panic(err)
+	}
+
+	// Mount /sys
+	if err := mount("sys", "/sys", "sysfs", commonOptions+",nodev,noexec", false); err != nil {
+		panic(err)
+	}
+
+	// Mount /dev
+	if err := mount("dev", "/dev", "devtmpfs", commonOptions+",mode=755,inode64", false); err != nil {
+		panic(err)
+	}
+
+	// Mount /run
+	if err := mount("run", "/run", "tmpfs", commonOptions+",nodev,mode=755,inode64", false); err != nil {
+		panic(err)
+	}
+
+	// Mount /dev/pts
+	if err := mount("devpts", "/dev/pts", "devpts", commonOptions+",gid=5,mode=620,ptmxmode=000", true); err != nil {
+		panic(err)
+	}
+
+	// Mount /dev/shm
+	if err := mount("shm", "/dev/shm", "tmpfs", commonOptions+",nodev,inode64", true); err != nil {
+		panic(err)
+	}
+
+	// Mount securityfs
+	if err := mount("securityfs", "/sys/kernel/security", "securityfs", commonOptions, false); err != nil {
+		panic(err)
+	}
+
+	// Mount cgroups v2
+	if err := mount("cgroup2", "/sys/fs/cgroup", "cgroup2", commonOptions+",noexec,nsdelegate,memory_recursiveprot", false); err != nil {
+		panic(err)
+	}
+
+	fmt.Println("Done.")
+}
+
+func mountFilesystems() {
+	fmt.Print("Mounting fstab entries... ")
+
+	if err := mountFstabEntries(); err != nil {
+		log.Println("Could not mount fstab entries!")
+		panic(err)
+	}
+
+	fmt.Println("Done.")
+}
+
+func startServiceManager() {
+	fmt.Print("Initializing service manager... ")
+
+	cmd := exec.Command("/sbin/esvm", path.Join(runstatedir, "esvm"), path.Join(sysconfdir, "esvm"))
+	cmd.Stdout = os.Stdout
+	cmd.Stderr = os.Stderr
+	err := cmd.Start()
+	if err != nil {
+		log.Println("Could not initialize service manager!")
+		panic(err)
+	}
+	serviceManagerPid = cmd.Process.Pid
+
+	fmt.Println("Done")
+}
+
+func stopServiceManager() {
+	fmt.Println("Stopping service manager... ")
+
+	err := syscall.Kill(serviceManagerPid, syscall.SIGTERM)
+	if err != nil {
+		log.Println("Could not stop service manager!")
+	}
+
+	// Check if service manager has stopped gracefully, otherwise send sigkill on timeout
+	exit := false
+	for timeout := time.After(60 * time.Second); ; {
+		if exit {
+			break
+		}
+		select {
+		case <-timeout:
+			log.Println("Could not stop service manager!")
+			err := syscall.Kill(serviceManagerPid, syscall.SIGKILL)
+			if err != nil {
+				log.Println("Could not stop service manager!")
+			}
+			exit = true
+		default:
+			waitZombieProcesses()
+			p, err := os.FindProcess(serviceManagerPid)
+			if err != nil {
+				exit = true
+				break
+			}
+			err = p.Signal(syscall.Signal(0))
+			if err != nil {
+				exit = true
+			}
+		}
+	}
+
+	fmt.Println("Done.")
+}
+
+func setHostname() {
+	fmt.Print("Setting hostname... ")
+
+	bytes, err := os.ReadFile("/etc/hostname")
+	if err != nil {
+		log.Println("Could not set hostname!")
+		return
+	}
+
+	hostname := strings.TrimSpace(string(bytes))
+
+	if err := syscall.Sethostname([]byte(hostname)); err != nil {
+		log.Println("Could not set hostname!")
+		return
+	}
+
+	fmt.Println("Done.")
+}
+
+func waitZombieProcesses() {
+	for {
+		if wpid, _ := syscall.Wait4(-1, nil, syscall.WNOHANG, nil); wpid <= 0 {
+			break
+		}
+	}
+}
+
+func catchSignals() {
+	sigc := make(chan os.Signal, 1)
+	signal.Notify(sigc, syscall.SIGUSR1, syscall.SIGTERM, syscall.SIGINT, syscall.SIGCHLD)
+	defer close(sigc)
+	defer signal.Stop(sigc)
+	for {
+		switch <-sigc {
+		case syscall.SIGUSR1:
+			close(sigc)
+			signal.Stop(sigc)
+			shutdownSystem()
+		case syscall.SIGTERM, syscall.SIGINT:
+			close(sigc)
+			signal.Stop(sigc)
+			rebootSystem()
+		case syscall.SIGCHLD:
+			waitZombieProcesses()
+		}
+	}
+}
+
+func shutdownSystem() {
+	fmt.Println("Shutting down...")
+
+	stopServiceManager()
+
+	fmt.Println("Syncing disks...")
+	syscall.Sync()
+
+	fmt.Println("Sending shutdown syscall...")
+	err := syscall.Reboot(syscall.LINUX_REBOOT_CMD_POWER_OFF)
+	if err != nil {
+		panic(err)
+	}
+}
+
+func rebootSystem() {
+	fmt.Println("Rebooting...")
+
+	stopServiceManager()
+
+	fmt.Println("Syncing disks...")
+	syscall.Sync()
+
+	fmt.Println("Sending reboot syscall...")
+	err := syscall.Reboot(syscall.LINUX_REBOOT_CMD_RESTART)
+	if err != nil {
+		panic(err)
+	}
+}

src/enit/mount.go

@@ -0,0 +1,157 @@
+package main
+
+import (
+	"fmt"
+	"golang.org/x/sys/unix"
+	"os"
+	"slices"
+	"strings"
+	"unsafe"
+)
+
+var flagsEquivalence = map[string]uintptr{
+	"dirsync":     unix.MS_DIRSYNC,
+	"lazytime":    unix.MS_LAZYTIME,
+	"noatime":     unix.MS_NOATIME,
+	"nodev":       unix.MS_NODEV,
+	"nodiratime":  unix.MS_NODIRATIME,
+	"noexec":      unix.MS_NOEXEC,
+	"nosuid":      unix.MS_NOSUID,
+	"ro":          unix.MS_RDONLY,
+	"rw":          0,
+	"relatime":    unix.MS_RELATIME,
+	"silent":      unix.MS_SILENT,
+	"strictatime": unix.MS_STRICTATIME,
+	"sync":        unix.MS_SYNCHRONOUS,
+	"defaults":    0,
+}
+
+// Split string flags to mount flags and mount data
+func convertMountOptions(options string) (flags []uintptr, data string) {
+	for _, flag := range strings.Split(options, ",") {
+		if unixFlag, ok := flagsEquivalence[flag]; ok {
+			flags = append(flags, unixFlag)
+		} else {
+			if data == "" {
+				data = flag
+			} else {
+				data += "," + flag
+			}
+		}
+	}
+
+	return flags, data
+}
+
+// Combine a unix flag slice or array into a single uintptr
+func combineUnixFlags(flagsSlice []uintptr) (flags uintptr) {
+	flags = 0
+	for _, flag := range flagsSlice {
+		flags |= flag
+	}
+
+	return flags
+}
+
+// Check whether a certain path is a mountpoint
+func isMountpoint(mountpoint string) bool {
+	if mountpoint != "/" {
+		mountpoint = strings.TrimRight(mountpoint, "/")
+	}
+
+	if _, err := os.Stat("/proc/mounts"); err != nil {
+		return false
+	}
+
+	bytes, err := os.ReadFile("/proc/mounts")
+	if err != nil {
+		return false
+	}
+
+	for _, line := range strings.Split(string(bytes), "\n") {
+		line = strings.TrimSpace(line)
+		if line == "" {
+			continue
+		}
+
+		if strings.Split(line, " ")[1] == mountpoint {
+			return true
+		}
+	}
+
+	return false
+}
+
+func mount(source, target, fstype string, options string, mkdir bool) error {
+	flags, data := convertMountOptions(options)
+
+	if isMountpoint(target) && !slices.Contains(flags, unix.MS_REMOUNT) {
+		flags = append(flags, unix.MS_REMOUNT)
+	}
+
+	if mkdir {
+		err := os.MkdirAll(target, 0755)
+		if err != nil {
+			return err
+		}
+	}
+
+	if err := unix.Mount(source, target, fstype, combineUnixFlags(flags), data); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func mountFstabEntries() error {
+	if _, err := os.Stat("/etc/fstab"); err != nil {
+		return err
+	}
+
+	bytes, err := os.ReadFile("/etc/fstab")
+	if err != nil {
+		return err
+	}
+
+	swapPriority := -2
+
+	for _, line := range strings.Split(string(bytes), "\n") {
+		line = strings.TrimSpace(line)
+		if strings.HasPrefix(line, "#") || line == "" {
+			continue
+		}
+
+		source := strings.Split(line, " ")[0]
+		target := strings.Split(line, " ")[1]
+		fstype := strings.Split(line, " ")[2]
+		options := strings.Split(line, " ")[3]
+
+		flags, data := convertMountOptions(options)
+
+		if slices.Contains(strings.Split(data, ","), "noauto") {
+			continue
+		}
+
+		if fstype == "swap" {
+			b := append([]byte(source), 0)
+			const SwapFlagPrioShift = 0
+			const SwapFlagPrioMask = 0x7fff
+			_, _, err := unix.Syscall(unix.SYS_SWAPON, uintptr(unsafe.Pointer(&b[0])), uintptr((swapPriority<<SwapFlagPrioShift)&SwapFlagPrioMask), 0)
+			swapPriority--
+			if err != 0 {
+				return fmt.Errorf("swapon syscall returned none-zero error code: %d", err)
+			}
+			continue
+		}
+
+		if isMountpoint(target) && !slices.Contains(flags, unix.MS_REMOUNT) {
+			flags = append(flags, unix.MS_REMOUNT)
+		}
+
+		if err := unix.Mount(source, target, fstype, combineUnixFlags(flags), data); err != nil {
+			return err
+		}
+	}
+
+	return nil
+}

src/esvm/go.mod

@@ -0,0 +1,5 @@
+module esvm
+
+go 1.23.4
+
+require gopkg.in/yaml.v3 v3.0.1

src/esvm/go.sum

@@ -0,0 +1,4 @@
+gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405 h1:yhCVgyC4o1eVCa2tZl7eS0r+SDo693bJlVdllGtEeKM=
+gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
+gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA=
+gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=

src/esvm/main.go

@@ -0,0 +1,644 @@
+package main
+
+import (
+	"flag"
+	"fmt"
+	"gopkg.in/yaml.v3"
+	"io"
+	"log"
+	"net"
+	"os"
+	"os/exec"
+	"os/signal"
+	"path"
+	"slices"
+	"strconv"
+	"strings"
+	"syscall"
+	"time"
+)
+
+type EnitServiceState uint8
+
+const (
+	EnitServiceUnknown EnitServiceState = iota
+	EnitServiceUnloaded
+	EnitServiceRunning
+	EnitServiceStopped
+	EnitServiceCrashed
+	EnitServiceCompleted
+)
+
+type EnitService struct {
+	Name            string   `yaml:"name"`
+	Description     string   `yaml:"description,omitempty"`
+	Dependencies    []string `yaml:"dependencies,omitempty"`
+	Type            string   `yaml:"type"`
+	StartCmd        string   `yaml:"start_cmd"`
+	ExitMethod      string   `yaml:"exit_method"`
+	CrashOnSafeExit bool     `yaml:"crash_on_safe_exit"`
+	StopCmd         string   `yaml:"stop_cmd,omitempty"`
+	Restart         string   `yaml:"restart,omitempty"`
+	LogOutput       bool     `yaml:"log_output,omitempty"`
+	ServiceRunPath  string
+	restartCount    int
+	stopChannel     chan bool
+}
+
+// Build-time variables
+var version = "dev"
+
+var runtimeServiceDir string
+var serviceConfigDir string
+
+var Services = make([]EnitService, 0)
+var EnabledServices = make([]string, 0)
+
+var logger *log.Logger
+var socket net.Listener
+
+func main() {
+	// Parse flags
+	printVersion := flag.Bool("version", false, "print version and exit")
+	flag.Parse()
+
+	if *printVersion || flag.NArg() != 2 {
+		fmt.Printf("Enit Service Manager version %s\n", version)
+		os.Exit(0)
+	}
+
+	if os.Getppid() != 1 {
+		fmt.Println("Esvm must be run by PID 1!")
+		os.Exit(1)
+	}
+
+	// Setup main logger
+	err := setupESVMLogger()
+	if err != nil {
+		log.Printf("Could not setup main ESVM logger! Error: %s\n", err)
+		logger = log.Default()
+	}
+
+	// Set directory variables
+	runtimeServiceDir = flag.Arg(0)
+	serviceConfigDir = flag.Arg(1)
+
+	Init()
+	if err != nil {
+
+	}
+
+	sigc := make(chan os.Signal, 1)
+	signal.Notify(sigc, syscall.SIGINT, syscall.SIGTERM)
+	go func() {
+		<-sigc
+		Destroy()
+		os.Exit(0)
+	}()
+
+	for {
+		listenToSocket()
+	}
+}
+
+func setupESVMLogger() error {
+	err := os.MkdirAll("/var/log/esvm", 0755)
+	if err != nil {
+		return err
+	}
+	loggerFile, err := os.OpenFile("/var/log/esvm/esvm.log", os.O_CREATE|os.O_WRONLY|os.O_APPEND, 0666)
+	if err != nil {
+		return err
+	}
+	logger = log.New(loggerFile, "[ESVM] ", log.Lshortfile|log.LstdFlags)
+	// Print an empty line as separator
+	_, err = loggerFile.WriteString("------ " + time.Now().Format(time.UnixDate) + " ------\n")
+
+	return nil
+}
+
+func Init() {
+	logger.Println("Initializing ESVM...")
+
+	if _, err := os.Stat(runtimeServiceDir); err == nil {
+		logger.Fatalf("Could not initialize ESVM! Error: %s", fmt.Errorf("runtime service directory %s already exists", runtimeServiceDir))
+	}
+
+	err := os.MkdirAll(runtimeServiceDir, 0755)
+	if err != nil {
+		logger.Fatalf("Could not initialize ESVM! Error: %s", err)
+	}
+
+	socket, err = net.Listen("unix", path.Join(runtimeServiceDir, "esvm.sock"))
+	if err != nil {
+		logger.Fatalf("Could not initialize ESVM! Error: %s", err)
+	}
+
+	if stat, err := os.Stat(serviceConfigDir); err != nil || !stat.IsDir() {
+		logger.Println("ESVM initialized successfully!")
+		return
+	}
+
+	dirEntries, err := os.ReadDir(path.Join(serviceConfigDir, "services"))
+	if err != nil {
+		logger.Fatalf("Could not initialize ESVM! Error: %s", err)
+	}
+
+	// Read and initialize service files
+	for _, entry := range dirEntries {
+		if !entry.IsDir() && strings.HasSuffix(entry.Name(), ".esv") {
+			logger.Printf("Initializing service (%s)...\n", entry.Name())
+			bytes, err := os.ReadFile(path.Join(serviceConfigDir, "services", entry.Name()))
+			if err != nil {
+				logger.Printf("Could not read service file at %s!\n", path.Join(serviceConfigDir, "services", entry.Name()))
+				continue
+			}
+
+			service := EnitService{
+				Name:            "",
+				Description:     "",
+				Dependencies:    make([]string, 0),
+				Type:            "",
+				StartCmd:        "",
+				ExitMethod:      "",
+				StopCmd:         "",
+				Restart:         "",
+				CrashOnSafeExit: true,
+				ServiceRunPath:  "",
+				restartCount:    0,
+				stopChannel:     make(chan bool),
+				LogOutput:       true,
+			}
+			if err := yaml.Unmarshal(bytes, &service); err != nil {
+				logger.Printf("Could not read service file at %s!\n", path.Join(serviceConfigDir, "services", entry.Name()))
+				continue
+			}
+
+			for _, sv := range Services {
+				if sv.Name == service.Name {
+					logger.Printf("Service with name (%s) has already been initialized!", service.Name)
+				}
+			}
+
+			switch service.Type {
+			case "simple", "background":
+			default:
+				logger.Printf("Unknown service type: %s\n", service.Type)
+				continue
+			}
+
+			switch service.ExitMethod {
+			case "stop_command", "kill":
+			default:
+				logger.Printf("Unknown exit method: %s\n", service.ExitMethod)
+				continue
+			}
+
+			switch service.Restart {
+			case "true", "always":
+			default:
+				service.Restart = "false"
+			}
+
+			service.ServiceRunPath = path.Join(runtimeServiceDir, service.Name)
+			err = os.MkdirAll(path.Join(service.ServiceRunPath), 0755)
+			if err != nil {
+				logger.Fatalf("Could not initialize ESVM! Error: %s", err)
+			}
+
+			err = service.setCurrentState(EnitServiceUnloaded)
+			if err != nil {
+				logger.Fatalf("Could not initialize ESVM! Error: %s", err)
+			}
+
+			Services = append(Services, service)
+
+			logger.Printf("Service (%s) has been initialized!\n", service.Name)
+		}
+	}
+
+	// Get enabled services
+	if _, err := os.Stat(path.Join(serviceConfigDir, "enabled_services")); err == nil {
+		file, err := os.ReadFile(path.Join(serviceConfigDir, "enabled_services"))
+		if err != nil {
+			return
+		}
+		for _, line := range strings.Split(string(file), "\n") {
+			if line != "" {
+				EnabledServices = append(EnabledServices, line)
+			}
+		}
+	}
+
+	// Get enabled services that meet their dependencies
+	servicesWithMetDepends := make([]EnitService, 0)
+	for _, service := range Services {
+		if slices.Contains(EnabledServices, service.Name) && len(service.GetUnmetDependencies()) == 0 {
+			servicesWithMetDepends = append(servicesWithMetDepends, service)
+		}
+	}
+
+	// Loop until all enabled services have started or timed out
+	for start := time.Now(); time.Since(start) < 60*time.Second; {
+		if len(servicesWithMetDepends) == 0 {
+			break
+		}
+
+		for i := len(servicesWithMetDepends) - 1; i >= 0; i-- {
+			service := servicesWithMetDepends[i]
+			canStart := true
+			for _, dependency := range service.Dependencies {
+				if strings.HasPrefix(dependency, "/") {
+					// File dependency
+					if _, err := os.Stat(dependency); err != nil {
+						canStart = false
+						break
+					}
+				} else {
+					// Service dependency
+					if GetServiceByName(dependency).GetCurrentState() != EnitServiceRunning && GetServiceByName(dependency).GetCurrentState() != EnitServiceCompleted {
+						canStart = false
+						break
+					}
+				}
+			}
+			if canStart {
+				err := service.StartService()
+				if err != nil {
+					logger.Printf("Could not start service (%s)! Error: %s", service.Name, err)
+				}
+				servicesWithMetDepends = append(servicesWithMetDepends[:i], servicesWithMetDepends[i+1:]...)
+			}
+		}
+	}
+
+	if len(servicesWithMetDepends) > 0 {
+		for _, service := range servicesWithMetDepends {
+			logger.Printf("Could not start service (%s)! Error: dependencies not met", service.Name)
+		}
+	}
+
+	logger.Println("ESVM initialized successfully!")
+}
+
+func Destroy() {
+	logger.Println("Stopping all ESVM services...")
+	for _, service := range Services {
+		if err := service.StopService(); err != nil {
+			logger.Printf("Error stopping service %s! Error: %s\n", service.Name, err)
+		}
+	}
+	logger.Println("All ESVM services have stopped!")
+}
+
+func GetServiceByName(name string) *EnitService {
+	for _, service := range Services {
+		if service.Name == name {
+			return &service
+		}
+	}
+	return nil
+}
+
+func (service *EnitService) GetUnmetDependencies() (missingDependencies []string) {
+	for _, dependency := range service.Dependencies {
+		if strings.HasPrefix(dependency, "/") {
+			// File dependency
+			if _, err := os.Stat(dependency); err != nil {
+				missingDependencies = append(missingDependencies, dependency)
+			}
+		} else {
+			// Service dependency
+			depService := GetServiceByName(dependency)
+			if depService == nil {
+				missingDependencies = append(missingDependencies, dependency)
+			}
+		}
+	}
+
+	return missingDependencies
+}
+
+func (service *EnitService) GetProcess() *os.Process {
+	bytes, err := os.ReadFile(path.Join(service.ServiceRunPath, "process"))
+	if err != nil {
+		return nil
+	}
+
+	pid, err := strconv.Atoi(strings.TrimSpace(string(bytes)))
+	if err != nil {
+		return nil
+	}
+
+	process, err := os.FindProcess(pid)
+	if err != nil {
+		return nil
+	}
+
+	return process
+}
+
+func (service *EnitService) setProcessID(pid int) error {
+	if err := os.WriteFile(path.Join(service.ServiceRunPath, "process"), []byte(strconv.Itoa(pid)), 0644); err != nil {
+		return err
+	}
+	return nil
+}
+
+func (service *EnitService) GetCurrentState() EnitServiceState {
+	bytes, err := os.ReadFile(path.Join(service.ServiceRunPath, "state"))
+	if err != nil {
+		return EnitServiceUnknown
+	}
+
+	state, err := strconv.Atoi(strings.TrimSpace(string(bytes)))
+	if err != nil {
+		return EnitServiceUnknown
+	}
+	return EnitServiceState(state)
+}
+
+func (service *EnitService) setCurrentState(state EnitServiceState) error {
+	if err := os.WriteFile(path.Join(service.ServiceRunPath, "state"), []byte(strconv.Itoa(int(state))), 0644); err != nil {
+		return err
+	}
+	return nil
+}
+
+func (service *EnitService) GetLogFile() (file *os.File, err error) {
+	err = os.MkdirAll(path.Join("/var/log/esvm/"), 0755)
+	if err != nil {
+		return nil, err
+	}
+
+	file, err = os.OpenFile(path.Join("/var/log/esvm/", service.Name+".log"), os.O_APPEND|os.O_WRONLY|os.O_CREATE, 0644)
+	if err != nil {
+		return nil, err
+	}
+
+	_, err = file.WriteString("------ " + time.Now().Format(time.UnixDate) + " ------\n")
+	if err != nil {
+		file.Close()
+		return nil, err
+	}
+
+	return file, nil
+}
+
+func (service *EnitService) StartService() error {
+	if service == nil {
+		return nil
+	}
+	if service.GetCurrentState() == EnitServiceRunning {
+		return nil
+	}
+
+	logger.Printf("Starting service (%s)...\n", service.Name)
+
+	// Get log file if service logs output
+	var logFile *os.File
+	if service.LogOutput {
+		var err error
+		logFile, err = service.GetLogFile()
+		if err != nil {
+			return err
+		}
+	}
+
+	cmd := exec.Command("/bin/sh", "-c", "exec "+service.StartCmd)
+	if logFile != nil {
+		cmd.Stdout = logFile
+		cmd.Stderr = logFile
+	}
+	if err := cmd.Start(); err != nil {
+		// Close log file if not nil
+		if logFile != nil {
+			logFile.Close()
+		}
+
+		return err
+	}
+
+	err := service.setProcessID(cmd.Process.Pid)
+	if err != nil {
+		// Close log file if not nil
+		if logFile != nil {
+			logFile.Close()
+		}
+
+		return err
+	}
+
+	err = service.setCurrentState(EnitServiceRunning)
+	if err != nil {
+		// Close log file if not nil
+		if logFile != nil {
+			logFile.Close()
+		}
+
+		return err
+	}
+
+	go func() {
+		err := cmd.Wait()
+
+		// Close log file if not nil
+		if logFile != nil {
+			logFile.Close()
+		}
+
+		select {
+		case <-service.stopChannel:
+			service.restartCount = 0
+			_ = service.setCurrentState(EnitServiceStopped)
+		default:
+			if service.Type == "simple" && err == nil {
+				service.restartCount = 0
+				_ = service.setCurrentState(EnitServiceCompleted)
+				return
+			}
+			if !service.CrashOnSafeExit {
+				logger.Printf("Service (%s) has exited\n", service.Name)
+				_ = service.setCurrentState(EnitServiceStopped)
+			} else {
+				logger.Printf("Service (%s) has crashed!\n", service.Name)
+				_ = service.setCurrentState(EnitServiceCrashed)
+			}
+
+			if service.Restart == "always" {
+				_ = service.StartService()
+			} else if service.Restart == "true" && service.restartCount < 5 {
+				service.restartCount++
+				_ = service.StartService()
+			}
+		}
+	}()
+
+	logger.Printf("Service (%s) has started!\n", service.Name)
+
+	return nil
+}
+
+func (service *EnitService) StopService() error {
+	if service.GetCurrentState() != EnitServiceRunning {
+		return nil
+	}
+
+	logger.Printf("Stopping service (%s)...\n", service.Name)
+
+	if service.ExitMethod == "kill" {
+		process := service.GetProcess()
+		if err := process.Signal(syscall.Signal(0)); err != nil {
+			logger.Printf("Service (%s) has stopped. (Process already dead)\n", service.Name)
+			return nil
+		}
+
+		go func() { service.stopChannel <- true }()
+
+		err := service.GetProcess().Signal(syscall.SIGTERM)
+		if err != nil {
+			return err
+		}
+
+		exit := false
+		for timeout := time.After(5 * time.Second); ; {
+			if exit {
+				break
+			}
+			select {
+			case <-timeout:
+				logger.Println("Process took too long to finish. Forcefully killing process...")
+				err := service.GetProcess().Kill()
+				if err != nil {
+					return err
+				}
+				exit = true
+			default:
+				if process == nil {
+					exit = true
+					break
+				}
+				err = process.Signal(syscall.Signal(0))
+				if err != nil {
+					exit = true
+				}
+			}
+		}
+	} else {
+		cmd := exec.Command("/bin/sh", "-c", service.StopCmd)
+		if err := cmd.Run(); err != nil {
+			return err
+		}
+	}
+
+	err := service.setCurrentState(EnitServiceStopped)
+	if err != nil {
+		return err
+	}
+
+	err = service.setProcessID(0)
+	if err != nil {
+		return err
+	}
+
+	logger.Printf("Service (%s) has stopped!\n", service.Name)
+
+	return nil
+}
+
+func (service *EnitService) RestartService() error {
+	if err := service.StopService(); err != nil {
+		return err
+	}
+
+	if err := service.StartService(); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func listenToSocket() {
+	conn, err := socket.Accept()
+	if err != nil {
+		logger.Println("Could not accept socket connection!")
+		panic(err)
+	}
+
+	// Handle the connection in a separate goroutine.
+	go func(conn net.Conn) {
+		defer conn.Close()
+		// Create a buffer for incoming data.
+		buf := make([]byte, 4096)
+
+		// Read data from the connection.
+		n, err := conn.Read(buf)
+		if err == io.EOF {
+			return
+		}
+		if err != nil {
+			logger.Fatal(err)
+		}
+
+		command := string(buf[:n])
+		commandSplit := strings.Split(command, " ")
+
+		if len(commandSplit) >= 2 {
+			if commandSplit[0] == "start" {
+				service := GetServiceByName(commandSplit[1])
+				if service == nil {
+					_, err := conn.Write([]byte("service not found"))
+					if err != nil {
+						return
+					}
+				}
+				if err := service.StartService(); err != nil {
+					_, err := conn.Write([]byte("could not start service"))
+					if err != nil {
+						return
+					}
+				}
+				_, err := conn.Write([]byte("ok"))
+				if err != nil {
+					return
+				}
+			} else if commandSplit[0] == "stop" {
+				service := GetServiceByName(commandSplit[1])
+				if service == nil {
+					_, err := conn.Write([]byte("service not found"))
+					if err != nil {
+						return
+					}
+				}
+				if err := service.StopService(); err != nil {
+					_, err := conn.Write([]byte("could not stop service"))
+					if err != nil {
+						return
+					}
+				}
+				_, err := conn.Write([]byte("ok"))
+				if err != nil {
+					return
+				}
+			} else if commandSplit[0] == "restart" {
+				service := GetServiceByName(commandSplit[1])
+				if service == nil {
+					_, err := conn.Write([]byte("service not found"))
+					if err != nil {
+						return
+					}
+				}
+				if err := service.RestartService(); err != nil {
+					_, err := conn.Write([]byte("could not restart service"))
+					if err != nil {
+						return
+					}
+				}
+				_, err := conn.Write([]byte("ok"))
+				if err != nil {
+					return
+				}
+			}
+		}
+	}(conn)
+}