diff --git a/common/pkg/cgroups/blkio_linux.go b/common/pkg/cgroups/blkio_linux.go
index 4d85ba4a70..c1b73f2fd8 100644
--- a/common/pkg/cgroups/blkio_linux.go
+++ b/common/pkg/cgroups/blkio_linux.go
@@ -3,10 +3,6 @@
 package cgroups
 
 import (
-	"bufio"
-	"errors"
-	"fmt"
-	"os"
 	"path/filepath"
 	"strconv"
 	"strings"
@@ -26,23 +22,16 @@ func getBlkioHandler() *linuxBlkioHandler {
 
 // Apply set the specified constraints.
 func (c *linuxBlkioHandler) Apply(ctr *CgroupControl, res *cgroups.Resources) error {
-	if ctr.cgroup2 {
-		man, err := fs2.NewManager(ctr.config, filepath.Join(cgroupRoot, ctr.config.Path))
-		if err != nil {
-			return err
-		}
-		return man.Set(res)
+	man, err := fs2.NewManager(ctr.config, filepath.Join(cgroupRoot, ctr.config.Path))
+	if err != nil {
+		return err
 	}
-	path := filepath.Join(cgroupRoot, Blkio, ctr.config.Path)
-	return c.Blkio.Set(path, res)
+	return man.Set(res)
 }
 
 // Create the cgroup.
 func (c *linuxBlkioHandler) Create(ctr *CgroupControl) (bool, error) {
-	if ctr.cgroup2 {
-		return false, nil
-	}
-	return ctr.createCgroupDirectory(Blkio)
+	return false, nil
 }
 
 // Destroy the cgroup.
@@ -54,94 +43,45 @@ func (c *linuxBlkioHandler) Destroy(ctr *CgroupControl) error {
 func (c *linuxBlkioHandler) Stat(ctr *CgroupControl, m *cgroups.Stats) error {
 	var ioServiceBytesRecursive []cgroups.BlkioStatEntry
 
-	if ctr.cgroup2 {
-		// more details on the io.stat file format:X https://facebookmicrosites.github.io/cgroup2/docs/io-controller.html
-		values, err := readCgroup2MapFile(ctr, "io.stat")
+	// more details on the io.stat file format:X https://facebookmicrosites.github.io/cgroup2/docs/io-controller.html
+	values, err := readCgroup2MapFile(ctr, "io.stat")
+	if err != nil {
+		return err
+	}
+	for k, v := range values {
+		d := strings.Split(k, ":")
+		if len(d) != 2 {
+			continue
+		}
+		minor, err := strconv.ParseUint(d[0], 10, 0)
 		if err != nil {
 			return err
 		}
-		for k, v := range values {
-			d := strings.Split(k, ":")
-			if len(d) != 2 {
-				continue
-			}
-			minor, err := strconv.ParseUint(d[0], 10, 0)
-			if err != nil {
-				return err
-			}
-			major, err := strconv.ParseUint(d[1], 10, 0)
-			if err != nil {
-				return err
-			}
-
-			for _, item := range v {
-				d := strings.Split(item, "=")
-				if len(d) != 2 {
-					continue
-				}
-				op := d[0]
-
-				// Accommodate the cgroup v1 naming
-				switch op {
-				case "rbytes":
-					op = "read"
-				case "wbytes":
-					op = "write"
-				}
-
-				value, err := strconv.ParseUint(d[1], 10, 0)
-				if err != nil {
-					return err
-				}
-
-				entry := cgroups.BlkioStatEntry{
-					Op:    op,
-					Major: major,
-					Minor: minor,
-					Value: value,
-				}
-				ioServiceBytesRecursive = append(ioServiceBytesRecursive, entry)
-			}
-		}
-	} else {
-		BlkioRoot := ctr.getCgroupv1Path(Blkio)
-
-		p := filepath.Join(BlkioRoot, "blkio.throttle.io_service_bytes_recursive")
-		f, err := os.Open(p)
+		major, err := strconv.ParseUint(d[1], 10, 0)
 		if err != nil {
-			if errors.Is(err, os.ErrNotExist) {
-				return nil
-			}
-			return fmt.Errorf("open %s: %w", p, err)
+			return err
 		}
-		defer f.Close()
 
-		scanner := bufio.NewScanner(f)
-		for scanner.Scan() {
-			line := scanner.Text()
-			parts := strings.Fields(line)
-			if len(parts) < 3 {
-				continue
-			}
-			d := strings.Split(parts[0], ":")
+		for _, item := range v {
+			d := strings.Split(item, "=")
 			if len(d) != 2 {
 				continue
 			}
-			minor, err := strconv.ParseUint(d[0], 10, 0)
-			if err != nil {
-				return err
-			}
-			major, err := strconv.ParseUint(d[1], 10, 0)
-			if err != nil {
-				return err
+			op := d[0]
+
+			// Accommodate the cgroup v1 naming
+			switch op {
+			case "rbytes":
+				op = "read"
+			case "wbytes":
+				op = "write"
 			}
 
-			op := parts[1]
-
-			value, err := strconv.ParseUint(parts[2], 10, 0)
+			value, err := strconv.ParseUint(d[1], 10, 0)
 			if err != nil {
 				return err
 			}
+
 			entry := cgroups.BlkioStatEntry{
 				Op:    op,
 				Major: major,
@@ -150,9 +90,6 @@ func (c *linuxBlkioHandler) Stat(ctr *CgroupControl, m *cgroups.Stats) error {
 			}
 			ioServiceBytesRecursive = append(ioServiceBytesRecursive, entry)
 		}
-		if err := scanner.Err(); err != nil {
-			return fmt.Errorf("parse %s: %w", p, err)
-		}
 	}
 	m.BlkioStats.IoServiceBytesRecursive = ioServiceBytesRecursive
 	return nil
diff --git a/common/pkg/cgroups/cgroups_linux.go b/common/pkg/cgroups/cgroups_linux.go
index 1c66a8d9cc..4c1ce30ee1 100644
--- a/common/pkg/cgroups/cgroups_linux.go
+++ b/common/pkg/cgroups/cgroups_linux.go
@@ -8,14 +8,11 @@ import (
 	"context"
 	"errors"
 	"fmt"
-	"maps"
 	"math"
 	"os"
 	"path/filepath"
-	"slices"
 	"strconv"
 	"strings"
-	"sync"
 	"syscall"
 	"time"
 
@@ -32,23 +29,13 @@ import (
 var (
 	// ErrCgroupDeleted means the cgroup was deleted.
 	ErrCgroupDeleted = errors.New("cgroup deleted")
-	// ErrCgroupV1Rootless means the cgroup v1 were attempted to be used in rootless environment.
-	ErrCgroupV1Rootless = errors.New("no support for CGroups V1 in rootless environments")
-	ErrStatCgroup       = errors.New("no cgroup available for gathering user statistics")
-
-	isUnifiedOnce sync.Once
-	isUnified     bool
-	isUnifiedErr  error
+	ErrStatCgroup    = errors.New("no cgroup available for gathering user statistics")
 )
 
 // CgroupControl controls a cgroup hierarchy.
 type CgroupControl struct {
-	cgroup2 bool
 	config  *cgroups.Cgroup
 	systemd bool
-	// List of additional cgroup subsystems joined that
-	// do not have a custom handler.
-	additionalControllers []controller
 }
 
 type controller struct {
@@ -225,10 +212,8 @@ func (c *CgroupControl) initialize() (err error) {
 			}
 		}
 	}()
-	if c.cgroup2 {
-		if err := createCgroupv2Path(filepath.Join(cgroupRoot, c.config.Path)); err != nil {
-			return fmt.Errorf("creating cgroup path %s: %w", c.config.Path, err)
-		}
+	if err := createCgroupv2Path(filepath.Join(cgroupRoot, c.config.Path)); err != nil {
+		return fmt.Errorf("creating cgroup path %s: %w", c.config.Path, err)
 	}
 	for name, handler := range handlers {
 		created, err := handler.Create(c)
@@ -239,20 +224,6 @@ func (c *CgroupControl) initialize() (err error) {
 			createdSoFar[name] = handler
 		}
 	}
-
-	if !c.cgroup2 {
-		// We won't need to do this for cgroup v2
-		for _, ctr := range c.additionalControllers {
-			if ctr.symlink {
-				continue
-			}
-			path := c.getCgroupv1Path(ctr.name)
-			if err := os.MkdirAll(path, 0o755); err != nil {
-				return fmt.Errorf("creating cgroup path for %s: %w", ctr.name, err)
-			}
-		}
-	}
-
 	return nil
 }
 
@@ -297,26 +268,13 @@ func readFileByKeyAsUint64(path, key string) (uint64, error) {
 
 // New creates a new cgroup control.
 func New(path string, resources *cgroups.Resources) (*CgroupControl, error) {
-	cgroup2, err := IsCgroup2UnifiedMode()
-	if err != nil {
-		return nil, err
-	}
 	control := &CgroupControl{
-		cgroup2: cgroup2,
 		config: &cgroups.Cgroup{
 			Path:      path,
 			Resources: resources,
 		},
 	}
 
-	if !cgroup2 {
-		controllers, err := getAvailableControllers(handlers, false)
-		if err != nil {
-			return nil, err
-		}
-		control.additionalControllers = controllers
-	}
-
 	if err := control.initialize(); err != nil {
 		return nil, err
 	}
@@ -326,12 +284,7 @@ func New(path string, resources *cgroups.Resources) (*CgroupControl, error) {
 
 // NewSystemd creates a new cgroup control.
 func NewSystemd(path string, resources *cgroups.Resources) (*CgroupControl, error) {
-	cgroup2, err := IsCgroup2UnifiedMode()
-	if err != nil {
-		return nil, err
-	}
 	control := &CgroupControl{
-		cgroup2: cgroup2,
 		systemd: true,
 		config: &cgroups.Cgroup{
 			Path:      path,
@@ -345,45 +298,12 @@ func NewSystemd(path string, resources *cgroups.Resources) (*CgroupControl, erro
 
 // Load loads an existing cgroup control.
 func Load(path string) (*CgroupControl, error) {
-	cgroup2, err := IsCgroup2UnifiedMode()
-	if err != nil {
-		return nil, err
-	}
 	control := &CgroupControl{
-		cgroup2: cgroup2,
 		systemd: false,
 		config: &cgroups.Cgroup{
 			Path: path,
 		},
 	}
-	if !cgroup2 {
-		controllers, err := getAvailableControllers(handlers, false)
-		if err != nil {
-			return nil, err
-		}
-		control.additionalControllers = controllers
-	}
-	if !cgroup2 {
-		oneExists := false
-		// check that the cgroup exists at least under one controller
-		for name := range handlers {
-			p := control.getCgroupv1Path(name)
-			if err := fileutils.Exists(p); err == nil {
-				oneExists = true
-				break
-			}
-		}
-
-		// if there is no controller at all, raise an error
-		if !oneExists {
-			if unshare.IsRootless() {
-				return nil, ErrCgroupV1Rootless
-			}
-			// compatible with the error code
-			// used by containerd/cgroups
-			return nil, ErrCgroupDeleted
-		}
-	}
 	return control, nil
 }
 
@@ -448,26 +368,7 @@ func (c *CgroupControl) DeleteByPathConn(path string, conn *systemdDbus.Conn) er
 	if c.systemd {
 		return systemdDestroyConn(path, conn)
 	}
-	if c.cgroup2 {
-		return rmDirRecursively(filepath.Join(cgroupRoot, c.config.Path))
-	}
-	var lastError error
-	for _, h := range handlers {
-		if err := h.Destroy(c); err != nil {
-			lastError = err
-		}
-	}
-
-	for _, ctr := range c.additionalControllers {
-		if ctr.symlink {
-			continue
-		}
-		p := c.getCgroupv1Path(ctr.name)
-		if err := rmDirRecursively(p); err != nil {
-			lastError = fmt.Errorf("remove %s: %w", p, err)
-		}
-	}
-	return lastError
+	return rmDirRecursively(filepath.Join(cgroupRoot, c.config.Path))
 }
 
 // DeleteByPath deletes the specified cgroup path.
@@ -495,32 +396,8 @@ func (c *CgroupControl) Update(resources *cgroups.Resources) error {
 
 // AddPid moves the specified pid to the cgroup.
 func (c *CgroupControl) AddPid(pid int) error {
-	pidString := []byte(fmt.Sprintf("%d\n", pid))
-
-	if c.cgroup2 {
-		path := filepath.Join(cgroupRoot, c.config.Path)
-		return fs2.CreateCgroupPath(path, c.config)
-	}
-
-	names := slices.Collect(maps.Keys(handlers))
-
-	for _, c := range c.additionalControllers {
-		if !c.symlink {
-			names = append(names, c.name)
-		}
-	}
-
-	for _, n := range names {
-		// If we aren't using cgroup2, we won't write correctly to unified hierarchy
-		if !c.cgroup2 && n == "unified" {
-			continue
-		}
-		p := filepath.Join(c.getCgroupv1Path(n), "tasks")
-		if err := os.WriteFile(p, pidString, 0o644); err != nil {
-			return fmt.Errorf("write %s: %w", p, err)
-		}
-	}
-	return nil
+	path := filepath.Join(cgroupRoot, c.config.Path)
+	return fs2.CreateCgroupPath(path, c.config)
 }
 
 // Stat returns usage statistics for the cgroup.
@@ -573,23 +450,6 @@ func readCgroup2MapFile(ctr *CgroupControl, name string) (map[string][]string, e
 	return readCgroupMapPath(p)
 }
 
-func (c *CgroupControl) createCgroupDirectory(controller string) (bool, error) {
-	cPath := c.getCgroupv1Path(controller)
-	err := fileutils.Exists(cPath)
-	if err == nil {
-		return false, nil
-	}
-
-	if !errors.Is(err, os.ErrNotExist) {
-		return false, err
-	}
-
-	if err := os.MkdirAll(cPath, 0o755); err != nil {
-		return false, fmt.Errorf("creating cgroup for %s: %w", controller, err)
-	}
-	return true, nil
-}
-
 var TestMode bool
 
 func createCgroupv2Path(path string) (deferredError error) {
@@ -671,32 +531,6 @@ func cleanString(s string) string {
 	return strings.Trim(s, "\n")
 }
 
-func readAcct(ctr *CgroupControl, name string) (uint64, error) {
-	p := filepath.Join(ctr.getCgroupv1Path(CPUAcct), name)
-	return readFileAsUint64(p)
-}
-
-func readAcctList(ctr *CgroupControl, name string) ([]uint64, error) {
-	p := filepath.Join(ctr.getCgroupv1Path(CPUAcct), name)
-	data, err := os.ReadFile(p)
-	if err != nil {
-		return nil, err
-	}
-	r := []uint64{}
-	for s := range strings.SplitSeq(string(data), " ") {
-		s = cleanString(s)
-		if s == "" {
-			break
-		}
-		v, err := strconv.ParseUint(s, 10, 64)
-		if err != nil {
-			return nil, fmt.Errorf("parsing %s: %w", s, err)
-		}
-		r = append(r, v)
-	}
-	return r, nil
-}
-
 func cpusetCopyFromParent(path string, cgroupv2 bool) error {
 	for _, file := range []string{"cpuset.cpus", "cpuset.mems"} {
 		if _, err := cpusetCopyFileFromParent(path, file, cgroupv2); err != nil {
@@ -739,15 +573,6 @@ func cpusetCopyFileFromParent(dir, file string, cgroupv2 bool) ([]byte, error) {
 
 // SystemCPUUsage returns the system usage for all the cgroups.
 func SystemCPUUsage() (uint64, error) {
-	cgroupv2, err := IsCgroup2UnifiedMode()
-	if err != nil {
-		return 0, err
-	}
-	if !cgroupv2 {
-		p := filepath.Join(cgroupRoot, CPUAcct, "cpuacct.usage")
-		return readFileAsUint64(p)
-	}
-
 	files, err := os.ReadDir(cgroupRoot)
 	if err != nil {
 		return 0, err
@@ -775,19 +600,6 @@ func SystemCPUUsage() (uint64, error) {
 	return total, nil
 }
 
-// IsCgroup2UnifiedMode returns whether we are running in cgroup 2 cgroup2 mode.
-func IsCgroup2UnifiedMode() (bool, error) {
-	isUnifiedOnce.Do(func() {
-		var st syscall.Statfs_t
-		if err := syscall.Statfs("/sys/fs/cgroup", &st); err != nil {
-			isUnified, isUnifiedErr = false, err
-		} else {
-			isUnified, isUnifiedErr = st.Type == unix.CGROUP2_SUPER_MAGIC, nil
-		}
-	})
-	return isUnified, isUnifiedErr
-}
-
 // UserConnection returns an user connection to D-BUS.
 func UserConnection(uid int) (*systemdDbus.Conn, error) {
 	return systemdDbus.NewConnection(func() (*dbus.Conn, error) {
@@ -800,11 +612,6 @@ func UserConnection(uid int) (*systemdDbus.Conn, error) {
 func UserOwnsCurrentSystemdCgroup() (bool, error) {
 	uid := os.Geteuid()
 
-	cgroup2, err := IsCgroup2UnifiedMode()
-	if err != nil {
-		return false, err
-	}
-
 	f, err := os.Open("/proc/self/cgroup")
 	if err != nil {
 		return false, err
@@ -822,20 +629,11 @@ func UserOwnsCurrentSystemdCgroup() (bool, error) {
 
 		// If we are on a cgroup v2 system and there are cgroup v1 controllers
 		// mounted, ignore them when the current process is at the root cgroup.
-		if cgroup2 && parts[1] != "" && parts[2] == "/" {
+		if parts[1] != "" && parts[2] == "/" {
 			continue
 		}
 
-		var cgroupPath string
-
-		if cgroup2 {
-			cgroupPath = filepath.Join(cgroupRoot, parts[2])
-		} else {
-			if parts[1] != "name=systemd" {
-				continue
-			}
-			cgroupPath = filepath.Join(cgroupRoot, "systemd", parts[2])
-		}
+		cgroupPath := filepath.Join(cgroupRoot, parts[2])
 
 		st, err := os.Stat(cgroupPath)
 		if err != nil {
diff --git a/common/pkg/cgroups/cgroups_unsupported.go b/common/pkg/cgroups/cgroups_unsupported.go
index 5940dc82d9..9a26e6a041 100644
--- a/common/pkg/cgroups/cgroups_unsupported.go
+++ b/common/pkg/cgroups/cgroups_unsupported.go
@@ -2,11 +2,6 @@
 
 package cgroups
 
-// IsCgroup2UnifiedMode returns whether we are running in cgroup 2 cgroup2 mode.
-func IsCgroup2UnifiedMode() (bool, error) {
-	return false, nil
-}
-
 // UserOwnsCurrentSystemdCgroup checks whether the current EUID owns the
 // current cgroup.
 func UserOwnsCurrentSystemdCgroup() (bool, error) {
diff --git a/common/pkg/cgroups/cpu_linux.go b/common/pkg/cgroups/cpu_linux.go
index 899a86d5d3..beecd5a0ed 100644
--- a/common/pkg/cgroups/cpu_linux.go
+++ b/common/pkg/cgroups/cpu_linux.go
@@ -3,8 +3,6 @@
 package cgroups
 
 import (
-	"errors"
-	"os"
 	"path/filepath"
 	"strconv"
 
@@ -23,23 +21,16 @@ func getCPUHandler() *linuxCPUHandler {
 
 // Apply set the specified constraints.
 func (c *linuxCPUHandler) Apply(ctr *CgroupControl, res *cgroups.Resources) error {
-	if ctr.cgroup2 {
-		man, err := fs2.NewManager(ctr.config, filepath.Join(cgroupRoot, ctr.config.Path))
-		if err != nil {
-			return err
-		}
-		return man.Set(res)
+	man, err := fs2.NewManager(ctr.config, filepath.Join(cgroupRoot, ctr.config.Path))
+	if err != nil {
+		return err
 	}
-	path := filepath.Join(cgroupRoot, CPU, ctr.config.Path)
-	return c.CPU.Set(path, res)
+	return man.Set(res)
 }
 
 // Create the cgroup.
 func (c *linuxCPUHandler) Create(ctr *CgroupControl) (bool, error) {
-	if ctr.cgroup2 {
-		return false, nil
-	}
-	return ctr.createCgroupDirectory(CPU)
+	return false, nil
 }
 
 // Destroy the cgroup.
@@ -51,47 +42,23 @@ func (c *linuxCPUHandler) Destroy(ctr *CgroupControl) error {
 func (c *linuxCPUHandler) Stat(ctr *CgroupControl, m *cgroups.Stats) error {
 	var err error
 	cpu := cgroups.CpuStats{}
-	if ctr.cgroup2 {
-		values, err := readCgroup2MapFile(ctr, "cpu.stat")
+	values, err := readCgroup2MapFile(ctr, "cpu.stat")
+	if err != nil {
+		return err
+	}
+	if val, found := values["usage_usec"]; found {
+		cpu.CpuUsage.TotalUsage, err = strconv.ParseUint(cleanString(val[0]), 10, 64)
 		if err != nil {
 			return err
 		}
-		if val, found := values["usage_usec"]; found {
-			cpu.CpuUsage.TotalUsage, err = strconv.ParseUint(cleanString(val[0]), 10, 64)
-			if err != nil {
-				return err
-			}
-			cpu.CpuUsage.UsageInKernelmode *= 1000
-		}
-		if val, found := values["system_usec"]; found {
-			cpu.CpuUsage.UsageInKernelmode, err = strconv.ParseUint(cleanString(val[0]), 10, 64)
-			if err != nil {
-				return err
-			}
-			cpu.CpuUsage.TotalUsage *= 1000
-		}
-	} else {
-		cpu.CpuUsage.TotalUsage, err = readAcct(ctr, "cpuacct.usage")
-		if err != nil {
-			if !errors.Is(err, os.ErrNotExist) {
-				return err
-			}
-			cpu.CpuUsage.TotalUsage = 0
-		}
-		cpu.CpuUsage.UsageInKernelmode, err = readAcct(ctr, "cpuacct.usage_sys")
-		if err != nil {
-			if !errors.Is(err, os.ErrNotExist) {
-				return err
-			}
-			cpu.CpuUsage.UsageInKernelmode = 0
-		}
-		cpu.CpuUsage.PercpuUsage, err = readAcctList(ctr, "cpuacct.usage_percpu")
+		cpu.CpuUsage.UsageInKernelmode *= 1000
+	}
+	if val, found := values["system_usec"]; found {
+		cpu.CpuUsage.UsageInKernelmode, err = strconv.ParseUint(cleanString(val[0]), 10, 64)
 		if err != nil {
-			if !errors.Is(err, os.ErrNotExist) {
-				return err
-			}
-			cpu.CpuUsage.PercpuUsage = nil
+			return err
 		}
+		cpu.CpuUsage.TotalUsage *= 1000
 	}
 	m.CpuStats = cpu
 	return nil
diff --git a/common/pkg/cgroups/cpuset_linux.go b/common/pkg/cgroups/cpuset_linux.go
index 10b2298e12..c13f082911 100644
--- a/common/pkg/cgroups/cpuset_linux.go
+++ b/common/pkg/cgroups/cpuset_linux.go
@@ -20,28 +20,17 @@ func getCpusetHandler() *linuxCpusetHandler {
 
 // Apply set the specified constraints.
 func (c *linuxCpusetHandler) Apply(ctr *CgroupControl, res *cgroups.Resources) error {
-	if ctr.cgroup2 {
-		man, err := fs2.NewManager(ctr.config, filepath.Join(cgroupRoot, ctr.config.Path))
-		if err != nil {
-			return err
-		}
-		return man.Set(res)
+	man, err := fs2.NewManager(ctr.config, filepath.Join(cgroupRoot, ctr.config.Path))
+	if err != nil {
+		return err
 	}
-	path := filepath.Join(cgroupRoot, CPUset, ctr.config.Path)
-	return c.CPUSet.Set(path, res)
+	return man.Set(res)
 }
 
 // Create the cgroup.
 func (c *linuxCpusetHandler) Create(ctr *CgroupControl) (bool, error) {
-	if ctr.cgroup2 {
-		path := filepath.Join(cgroupRoot, ctr.config.Path)
-		return true, cpusetCopyFromParent(path, true)
-	}
-	created, err := ctr.createCgroupDirectory(CPUset)
-	if !created || err != nil {
-		return created, err
-	}
-	return true, cpusetCopyFromParent(ctr.getCgroupv1Path(CPUset), false)
+	path := filepath.Join(cgroupRoot, ctr.config.Path)
+	return true, cpusetCopyFromParent(path, true)
 }
 
 // Destroy the cgroup.
diff --git a/common/pkg/cgroups/memory_linux.go b/common/pkg/cgroups/memory_linux.go
index 7f61900308..c54cb2c91d 100644
--- a/common/pkg/cgroups/memory_linux.go
+++ b/common/pkg/cgroups/memory_linux.go
@@ -20,23 +20,16 @@ func getMemoryHandler() *linuxMemHandler {
 
 // Apply set the specified constraints.
 func (c *linuxMemHandler) Apply(ctr *CgroupControl, res *cgroups.Resources) error {
-	if ctr.cgroup2 {
-		man, err := fs2.NewManager(ctr.config, filepath.Join(cgroupRoot, ctr.config.Path))
-		if err != nil {
-			return err
-		}
-		return man.Set(res)
+	man, err := fs2.NewManager(ctr.config, filepath.Join(cgroupRoot, ctr.config.Path))
+	if err != nil {
+		return err
 	}
-	path := filepath.Join(cgroupRoot, Memory, ctr.config.Path)
-	return c.Mem.Set(path, res)
+	return man.Set(res)
 }
 
 // Create the cgroup.
 func (c *linuxMemHandler) Create(ctr *CgroupControl) (bool, error) {
-	if ctr.cgroup2 {
-		return false, nil
-	}
-	return ctr.createCgroupDirectory(Memory)
+	return false, nil
 }
 
 // Destroy the cgroup.
@@ -52,48 +45,25 @@ func (c *linuxMemHandler) Stat(ctr *CgroupControl, m *cgroups.Stats) error {
 	var memoryRoot string
 	var limitFilename string
 
-	if ctr.cgroup2 {
-		memoryRoot = filepath.Join(cgroupRoot, ctr.config.Path)
-		limitFilename = "memory.max"
-
-		// Read memory.current
-		current, err := readFileAsUint64(filepath.Join(memoryRoot, "memory.current"))
-		if err != nil {
-			return err
-		}
-
-		// Read inactive_file from memory.stat
-		inactiveFile, err := readFileByKeyAsUint64(filepath.Join(memoryRoot, "memory.stat"), "inactive_file")
-		if err != nil {
-			return err
-		}
-
-		// Docker calculation: memory.current - memory.stat['inactive_file']
-		memUsage.Usage.Usage = 0
-		if inactiveFile < current {
-			memUsage.Usage.Usage = current - inactiveFile
-		}
-	} else {
-		memoryRoot = ctr.getCgroupv1Path(Memory)
-		limitFilename = "memory.limit_in_bytes"
-
-		// Read memory.usage_in_bytes
-		usageInBytes, err := readFileAsUint64(filepath.Join(memoryRoot, "memory.usage_in_bytes"))
-		if err != nil {
-			return err
-		}
-
-		// Read total_inactive_file from memory.stat
-		totalInactiveFile, err := readFileByKeyAsUint64(filepath.Join(memoryRoot, "memory.stat"), "total_inactive_file")
-		if err != nil {
-			return err
-		}
-
-		// Docker calculation: memory.usage_in_bytes - memory.stat['total_inactive_file']
-		memUsage.Usage.Usage = 0
-		if totalInactiveFile < usageInBytes {
-			memUsage.Usage.Usage = usageInBytes - totalInactiveFile
-		}
+	memoryRoot = filepath.Join(cgroupRoot, ctr.config.Path)
+	limitFilename = "memory.max"
+
+	// Read memory.current
+	current, err := readFileAsUint64(filepath.Join(memoryRoot, "memory.current"))
+	if err != nil {
+		return err
+	}
+
+	// Read inactive_file from memory.stat
+	inactiveFile, err := readFileByKeyAsUint64(filepath.Join(memoryRoot, "memory.stat"), "inactive_file")
+	if err != nil {
+		return err
+	}
+
+	// Docker calculation: memory.current - memory.stat['inactive_file']
+	memUsage.Usage.Usage = 0
+	if inactiveFile < current {
+		memUsage.Usage.Usage = current - inactiveFile
 	}
 
 	memUsage.Usage.Limit, err = readFileAsUint64(filepath.Join(memoryRoot, limitFilename))
diff --git a/common/pkg/cgroups/pids_linux.go b/common/pkg/cgroups/pids_linux.go
index 82202830e0..c7881dccd2 100644
--- a/common/pkg/cgroups/pids_linux.go
+++ b/common/pkg/cgroups/pids_linux.go
@@ -20,24 +20,16 @@ func getPidsHandler() *linuxPidHandler {
 
 // Apply set the specified constraints.
 func (c *linuxPidHandler) Apply(ctr *CgroupControl, res *cgroups.Resources) error {
-	if ctr.cgroup2 {
-		man, err := fs2.NewManager(ctr.config, filepath.Join(cgroupRoot, ctr.config.Path))
-		if err != nil {
-			return err
-		}
-		return man.Set(res)
+	man, err := fs2.NewManager(ctr.config, filepath.Join(cgroupRoot, ctr.config.Path))
+	if err != nil {
+		return err
 	}
-
-	path := filepath.Join(cgroupRoot, Pids, ctr.config.Path)
-	return c.Pid.Set(path, res)
+	return man.Set(res)
 }
 
 // Create the cgroup.
 func (c *linuxPidHandler) Create(ctr *CgroupControl) (bool, error) {
-	if ctr.cgroup2 {
-		return false, nil
-	}
-	return ctr.createCgroupDirectory(Pids)
+	return false, nil
 }
 
 // Destroy the cgroup.
@@ -52,12 +44,7 @@ func (c *linuxPidHandler) Stat(ctr *CgroupControl, m *cgroups.Stats) error {
 		return nil
 	}
 
-	var PIDRoot string
-	if ctr.cgroup2 {
-		PIDRoot = filepath.Join(cgroupRoot, ctr.config.Path)
-	} else {
-		PIDRoot = ctr.getCgroupv1Path(Pids)
-	}
+	PIDRoot := filepath.Join(cgroupRoot, ctr.config.Path)
 
 	current, err := readFileAsUint64(filepath.Join(PIDRoot, "pids.current"))
 	if err != nil {
diff --git a/common/pkg/cgroups/systemd_linux.go b/common/pkg/cgroups/systemd_linux.go
index c0bc6d9d38..15ba00b139 100644
--- a/common/pkg/cgroups/systemd_linux.go
+++ b/common/pkg/cgroups/systemd_linux.go
@@ -32,13 +32,7 @@ func systemdCreate(resources *cgroups.Resources, path string, c *systemdDbus.Con
 			systemdDbus.PropDescription("cgroup " + name),
 			systemdDbus.PropWants(slice),
 		}
-		var ioString string
-		v2, _ := IsCgroup2UnifiedMode()
-		if v2 {
-			ioString = "IOAccounting"
-		} else {
-			ioString = "BlockIOAccounting"
-		}
+		ioString := "IOAccounting"
 		pMap := map[string]bool{
 			"DefaultDependencies": false,
 			"MemoryAccounting":    true,
@@ -57,7 +51,7 @@ func systemdCreate(resources *cgroups.Resources, path string, c *systemdDbus.Con
 			properties = append(properties, p)
 		}
 
-		uMap, sMap, bMap, iMap, structMap, err := resourcesToProps(resources, v2)
+		uMap, sMap, bMap, iMap, structMap, err := resourcesToProps(resources, true)
 		if err != nil {
 			lastError = err
 			continue
@@ -176,13 +170,8 @@ func resourcesToProps(res *cgroups.Resources, v2 bool) (map[string]uint64, map[s
 
 	if res.CpuShares != 0 {
 		// convert from shares to weight. weight only supports 1-10000
-		v2, _ := IsCgroup2UnifiedMode()
-		if v2 {
-			wt := (1 + ((res.CpuShares-2)*9999)/262142)
-			uMap["CPUWeight"] = wt
-		} else {
-			uMap["CPUShares"] = res.CpuShares
-		}
+		wt := (1 + ((res.CpuShares-2)*9999)/262142)
+		uMap["CPUWeight"] = wt
 	}
 
 	// CPUSet
diff --git a/common/pkg/cgroups/utils_linux.go b/common/pkg/cgroups/utils_linux.go
index a1b18a9695..68034cc45c 100644
--- a/common/pkg/cgroups/utils_linux.go
+++ b/common/pkg/cgroups/utils_linux.go
@@ -15,7 +15,6 @@ import (
 
 	"github.com/opencontainers/cgroups"
 	"github.com/sirupsen/logrus"
-	"go.podman.io/storage/pkg/fileutils"
 	"golang.org/x/sys/unix"
 )
 
@@ -207,11 +206,6 @@ func MoveUnderCgroup(cgroup, subtree string, processes []uint32) error {
 	}
 	defer f.Close()
 
-	unifiedMode, err := IsCgroup2UnifiedMode()
-	if err != nil {
-		return err
-	}
-
 	scanner := bufio.NewScanner(f)
 	for scanner.Scan() {
 		line := scanner.Text()
@@ -221,24 +215,12 @@ func MoveUnderCgroup(cgroup, subtree string, processes []uint32) error {
 		}
 
 		// root cgroup, skip it
-		if parts[2] == "/" && (!unifiedMode || parts[1] != "") {
+		if parts[2] == "/" && parts[1] != "" {
 			continue
 		}
 
 		cgroupRoot := "/sys/fs/cgroup"
-		// Special case the unified mount on hybrid cgroup and named hierarchies.
-		// This works on Fedora 31, but we should really parse the mounts to see
-		// where the cgroup hierarchy is mounted.
-		if parts[1] == "" && !unifiedMode {
-			// If it is not using unified mode, the cgroup v2 hierarchy is
-			// usually mounted under /sys/fs/cgroup/unified
-			cgroupRoot = filepath.Join(cgroupRoot, "unified")
-
-			// Ignore the unified mount if it doesn't exist
-			if err := fileutils.Exists(cgroupRoot); err != nil && os.IsNotExist(err) {
-				continue
-			}
-		} else if parts[1] != "" {
+		if parts[1] != "" {
 			// Assume the controller is mounted at /sys/fs/cgroup/$CONTROLLER.
 			controller := strings.TrimPrefix(parts[1], "name=")
 			cgroupRoot = filepath.Join(cgroupRoot, controller)
@@ -292,15 +274,6 @@ var (
 // it is running in the root cgroup on a system that uses cgroupv2.
 func MaybeMoveToSubCgroup() error {
 	maybeMoveToSubCgroupSync.Do(func() {
-		unifiedMode, err := IsCgroup2UnifiedMode()
-		if err != nil {
-			maybeMoveToSubCgroupSyncErr = err
-			return
-		}
-		if !unifiedMode {
-			maybeMoveToSubCgroupSyncErr = nil
-			return
-		}
 		cgroup, err := GetOwnCgroup()
 		if err != nil {
 			maybeMoveToSubCgroupSyncErr = err
diff --git a/common/pkg/config/default.go b/common/pkg/config/default.go
index 3bf0bc1692..8548ec5d7a 100644
--- a/common/pkg/config/default.go
+++ b/common/pkg/config/default.go
@@ -15,7 +15,6 @@ import (
 	"go.podman.io/common/internal/attributedstring"
 	nettypes "go.podman.io/common/libnetwork/types"
 	"go.podman.io/common/pkg/apparmor"
-	"go.podman.io/common/pkg/cgroupv2"
 	"go.podman.io/storage/pkg/fileutils"
 	"go.podman.io/storage/pkg/homedir"
 	"go.podman.io/storage/pkg/unshare"
@@ -230,10 +229,7 @@ func defaultConfig() (*Config, error) {
 		}
 	}
 
-	cgroupNS := "host"
-	if cgroup2, _ := cgroupv2.Enabled(); cgroup2 {
-		cgroupNS = "private"
-	}
+	cgroupNS := "private"
 
 	return &Config{
 		Containers: ContainersConfig{
@@ -652,12 +648,7 @@ func (c *Config) PidsLimit() int64 {
 		if c.Engine.CgroupManager != SystemdCgroupsManager {
 			return 0
 		}
-		cgroup2, _ := cgroupv2.Enabled()
-		if !cgroup2 {
-			return 0
-		}
 	}
-
 	return c.Containers.PidsLimit
 }
 
diff --git a/common/pkg/config/systemd.go b/common/pkg/config/systemd.go
index e7c15b5909..120656528f 100644
--- a/common/pkg/config/systemd.go
+++ b/common/pkg/config/systemd.go
@@ -7,7 +7,6 @@ import (
 	"path/filepath"
 	"sync"
 
-	"go.podman.io/common/pkg/cgroupv2"
 	"go.podman.io/common/pkg/systemd"
 	"go.podman.io/storage/pkg/unshare"
 )
@@ -26,8 +25,7 @@ func defaultCgroupManager() string {
 	if !useSystemd() {
 		return CgroupfsCgroupsManager
 	}
-	enabled, err := cgroupv2.Enabled()
-	if err == nil && !enabled && unshare.IsRootless() {
+	if unshare.IsRootless() {
 		return CgroupfsCgroupsManager
 	}
 
diff --git a/common/pkg/sysinfo/sysinfo_linux.go b/common/pkg/sysinfo/sysinfo_linux.go
index ea98d49481..efb0a8ce6b 100644
--- a/common/pkg/sysinfo/sysinfo_linux.go
+++ b/common/pkg/sysinfo/sysinfo_linux.go
@@ -9,7 +9,6 @@ import (
 
 	"github.com/opencontainers/cgroups"
 	"github.com/sirupsen/logrus"
-	"go.podman.io/common/pkg/cgroupv2"
 	"go.podman.io/storage/pkg/fileutils"
 	"golang.org/x/sys/unix"
 )
@@ -41,7 +40,6 @@ func New(quiet bool) *SysInfo {
 		sysInfo.cgroupCPUInfo = checkCgroupCPU(cgMounts, quiet)
 		sysInfo.cgroupBlkioInfo = checkCgroupBlkioInfo(cgMounts, quiet)
 		sysInfo.cgroupCpusetInfo = checkCgroupCpusetInfo(cgMounts, quiet)
-		sysInfo.cgroupPids = checkCgroupPids(cgMounts, quiet)
 	}
 
 	_, ok := cgMounts["devices"]
@@ -227,28 +225,6 @@ func checkCgroupCpusetInfo(cgMounts map[string]string, quiet bool) cgroupCpusetI
 	}
 }
 
-// checkCgroupPids reads the pids information from the pids cgroup mount point.
-func checkCgroupPids(cgMounts map[string]string, quiet bool) cgroupPids {
-	cgroup2, err := cgroupv2.Enabled()
-	if err != nil {
-		logrus.Errorf("Failed to check cgroups version: %v", err)
-		return cgroupPids{}
-	}
-	if !cgroup2 {
-		_, ok := cgMounts["pids"]
-		if !ok {
-			if !quiet {
-				logrus.Warn("Unable to find pids cgroup in mounts")
-			}
-			return cgroupPids{}
-		}
-	}
-
-	return cgroupPids{
-		PidsLimit: true,
-	}
-}
-
 func cgroupEnabled(mountPoint, name string) bool {
 	err := fileutils.Exists(path.Join(mountPoint, name))
 	return err == nil
diff --git a/common/pkg/systemd/systemd_linux.go b/common/pkg/systemd/systemd_linux.go
index a189cfbe05..82e3b8014c 100644
--- a/common/pkg/systemd/systemd_linux.go
+++ b/common/pkg/systemd/systemd_linux.go
@@ -88,11 +88,7 @@ func MovePauseProcessToScope(pausePidPath string) {
 	}
 
 	if err != nil {
-		unified, err2 := cgroups.IsCgroup2UnifiedMode()
-		if err2 != nil {
-			logrus.Warnf("Failed to detect if running with cgroup unified: %v", err)
-		}
-		if RunsOnSystemd() && unified {
+		if RunsOnSystemd() {
 			logrus.Warnf("Failed to add pause process to systemd sandbox cgroup: %v", err)
 		} else {
 			logrus.Debugf("Failed to add pause process to systemd sandbox cgroup: %v", err)