libpod: check if cgroup exists before creating it

do not create the pod cgroup if it already exists.

Signed-off-by: Giuseppe Scrivano <gscrivan@redhat.com>

libpod/util_linux.go

@@ -5,6 +5,8 @@ package libpod
 
 import (
 	"fmt"
+	"os"
+	"path/filepath"
 	"strings"
 	"syscall"
 
@@ -17,22 +19,36 @@ import (
 	"golang.org/x/sys/unix"
 )
 
+func cgroupExist(path string) bool {
+	cgroupv2, _ := cgroups.IsCgroup2UnifiedMode()
+	var fullPath string
+	if cgroupv2 {
+		fullPath = filepath.Join("/sys/fs/cgroup", path)
+	} else {
+		fullPath = filepath.Join("/sys/fs/cgroup/memory", path)
+	}
+	_, err := os.Stat(fullPath)
+	return err == nil
+}
+
 // systemdSliceFromPath makes a new systemd slice under the given parent with
 // the given name.
 // The parent must be a slice. The name must NOT include ".slice"
 func systemdSliceFromPath(parent, name string, resources *spec.LinuxResources) (string, error) {
-	cgroupPath, err := assembleSystemdCgroupName(parent, name)
+	cgroupPath, systemdPath, err := assembleSystemdCgroupName(parent, name)
 	if err != nil {
 		return "", err
 	}
 
-	logrus.Debugf("Created cgroup path %s for parent %s and name %s", cgroupPath, parent, name)
+	logrus.Debugf("Created cgroup path %s for parent %s and name %s", systemdPath, parent, name)
 
-	if err := makeSystemdCgroup(cgroupPath, resources); err != nil {
-		return "", fmt.Errorf("creating cgroup %s: %w", cgroupPath, err)
+	if !cgroupExist(cgroupPath) {
+		if err := makeSystemdCgroup(systemdPath, resources); err != nil {
+			return "", fmt.Errorf("creating cgroup %s: %w", cgroupPath, err)
+		}
 	}
 
-	logrus.Debugf("Created cgroup %s", cgroupPath)
+	logrus.Debugf("Created cgroup %s", systemdPath)
 
 	return cgroupPath, nil
 }
@@ -88,19 +104,27 @@ func deleteSystemdCgroup(path string, resources *spec.LinuxResources) error {
 }
 
 // assembleSystemdCgroupName creates a systemd cgroup path given a base and
-// a new component to add.
+// a new component to add.  It also returns the path to the cgroup as it accessible
+// below the cgroup mounts.
 // The base MUST be systemd slice (end in .slice)
-func assembleSystemdCgroupName(baseSlice, newSlice string) (string, error) {
+func assembleSystemdCgroupName(baseSlice, newSlice string) (string, string, error) {
 	const sliceSuffix = ".slice"
 
 	if !strings.HasSuffix(baseSlice, sliceSuffix) {
-		return "", fmt.Errorf("cannot assemble cgroup path with base %q - must end in .slice: %w", baseSlice, define.ErrInvalidArg)
+		return "", "", fmt.Errorf("cannot assemble cgroup path with base %q - must end in .slice: %w", baseSlice, define.ErrInvalidArg)
 	}
 
 	noSlice := strings.TrimSuffix(baseSlice, sliceSuffix)
-	final := fmt.Sprintf("%s/%s-%s%s", baseSlice, noSlice, newSlice, sliceSuffix)
+	systemdPath := fmt.Sprintf("%s/%s-%s%s", baseSlice, noSlice, newSlice, sliceSuffix)
 
-	return final, nil
+	if rootless.IsRootless() {
+		// When we run as rootless, the cgroup has a path like the following:
+		///sys/fs/cgroup/user.slice/user-@$UID.slice/user@$UID.service/user.slice/user-libpod_pod_$POD_ID.slice
+		uid := rootless.GetRootlessUID()
+		raw := fmt.Sprintf("user.slice/%s-%d.slice/user@%d.service/%s/%s-%s%s", noSlice, uid, uid, baseSlice, noSlice, newSlice, sliceSuffix)
+		return raw, systemdPath, nil
+	}
+	return systemdPath, systemdPath, nil
 }
 
 var lvpRelabel = label.Relabel