Update hugetlb tests to be more portable

Not all arches/setups supports all page sizes. Should only
use the ones supported on the current platform

Signed-off-by: Odin Ugedal <odin@ugedal.com>

Author: odinuge

validation/linux_cgroups_hugetlb/linux_cgroups_hugetlb.go

@@ -10,31 +10,35 @@ import (
 	"github.com/opencontainers/runtime-tools/validation/util"
 )
 
+const (
+	B = 1 << (10 * iota)
+	KiB
+	MiB
+	GiB
+)
+
 func testHugetlbCgroups() error {
 	t := tap.New()
 	t.Header(0)
 	defer t.AutoPlan()
 
-	// limit =~ 100 * page size
-	// NOTE: on some systems, pagesize "1GB" doesn't seem to work.
-	// Ideally we should auto-detect the value.
-	cases := []struct {
-		page  string
-		limit uint64
-	}{
-		{"2MB", 100 * 2 * 1024 * 1024},
-		{"1GB", 100 * 1024 * 1024 * 1024},
-		{"2MB", 100 * 2 * 1024 * 1024},
-		{"1GB", 100 * 1024 * 1024 * 1024},
+	pageSizes, err := cgroups.GetHugePageSize()
+
+	if err != nil {
+		t.Fail(fmt.Sprintf("error when getting hugepage sizes: %+v", err))
 	}
 
-	for _, c := range cases {
+	// When setting the limit just for checking if writing works, the amount of memory
+	// requested does not matter, as all insigned integers will be accepted.
+	const limit = 2 * GiB
+
+	for _, pageSize := range pageSizes {
 		g, err := util.GetDefaultGenerator()
 		if err != nil {
 			return err
 		}
 		g.SetLinuxCgroupsPath(cgroups.AbsCgroupPath)
-		g.AddLinuxResourcesHugepageLimit(c.page, c.limit)
+		g.AddLinuxResourcesHugepageLimit(pageSize, limit)
 		err = util.RuntimeOutsideValidate(g, t, func(config *rspec.Spec, t *tap.T, state *rspec.State) error {
 			cg, err := cgroups.FindCgroup()
 			if err != nil {
@@ -45,11 +49,11 @@ func testHugetlbCgroups() error {
 				return err
 			}
 			for _, lhl := range lhd {
-				if lhl.Pagesize != c.page {
+				if lhl.Pagesize != pageSize {
 					continue
 				}
-				t.Ok(lhl.Limit == c.limit, "hugepage limit is set correctly")
-				t.Diagnosticf("expect: %d, actual: %d", c.limit, lhl.Limit)
+				t.Ok(lhl.Limit == limit, fmt.Sprintf("hugepage limit is set correctly for size: %s", pageSize))
+				t.Diagnosticf("expect: %d, actual: %d", limit, lhl.Limit)
 			}
 			return nil
 		})
@@ -63,7 +67,8 @@ func testHugetlbCgroups() error {
 
 func testWrongHugetlb() error {
 	// We deliberately set the page size to a wrong value, "3MB", to see
-	// if the container really returns an error.
+	// if the container really returns an error. Page sizes will always be a
+	// on the format 2^(integer)
 	page := "3MB"
 	var limit uint64 = 100 * 3 * 1024 * 1024
 

validation/linux_cgroups_relative_hugetlb/linux_cgroups_relative_hugetlb.go

@@ -1,55 +1,71 @@
 package main
 
 import (
+	"fmt"
 	"github.com/mndrix/tap-go"
 	rspec "github.com/opencontainers/runtime-spec/specs-go"
 	"github.com/opencontainers/runtime-tools/cgroups"
 	"github.com/opencontainers/runtime-tools/validation/util"
 )
 
-func main() {
-	page := "1GB"
-	var limit uint64 = 56892210544640
+const (
+	B = 1 << (10 * iota)
+	KiB
+	MiB
+	GiB
+)
 
+func main() {
 	t := tap.New()
 	t.Header(0)
 	defer t.AutoPlan()
 
-	g, err := util.GetDefaultGenerator()
+	pageSizes, err := cgroups.GetHugePageSize()
+
 	if err != nil {
-		util.Fatal(err)
+		t.Fail(fmt.Sprintf("error when getting hugepage sizes: %+v", err))
 	}
-	g.SetLinuxCgroupsPath(cgroups.RelCgroupPath)
-	g.AddLinuxResourcesHugepageLimit(page, limit)
-	err = util.RuntimeOutsideValidate(g, t, func(config *rspec.Spec, t *tap.T, state *rspec.State) error {
-		cg, err := cgroups.FindCgroup()
-		t.Ok((err == nil), "find hugetlb cgroup")
-		if err != nil {
-			t.Diagnostic(err.Error())
-			return nil
-		}
+	// When setting the limit just for checking if writing works, the amount of memory
+	// requested does not matter, as all insigned integers will be accepted.
+	const limit = 2 * GiB
 
-		lhd, err := cg.GetHugepageLimitData(state.Pid, config.Linux.CgroupsPath)
-		t.Ok((err == nil), "get hugetlb cgroup data")
+	for _, pageSize := range pageSizes {
+		g, err := util.GetDefaultGenerator()
 		if err != nil {
-			t.Diagnostic(err.Error())
-			return nil
+			util.Fatal(err)
 		}
+		g.SetLinuxCgroupsPath(cgroups.RelCgroupPath)
+		g.AddLinuxResourcesHugepageLimit(pageSize, limit)
+		err = util.RuntimeOutsideValidate(g, t, func(config *rspec.Spec, t *tap.T, state *rspec.State) error {
+			cg, err := cgroups.FindCgroup()
+			t.Ok((err == nil), "find hugetlb cgroup")
+			if err != nil {
+				t.Diagnostic(err.Error())
+				return nil
+			}
 
-		found := false
-		for _, lhl := range lhd {
-			if lhl.Pagesize == page {
-				found = true
-				t.Ok(lhl.Limit == limit, "hugepage limit is set correctly")
-				t.Diagnosticf("expect: %d, actual: %d", limit, lhl.Limit)
+			lhd, err := cg.GetHugepageLimitData(state.Pid, config.Linux.CgroupsPath)
+			t.Ok((err == nil), "get hugetlb cgroup data")
+			if err != nil {
+				t.Diagnostic(err.Error())
+				return nil
 			}
-		}
-		t.Ok(found, "hugepage limit found")
 
-		return nil
-	})
+			found := false
+			for _, lhl := range lhd {
+				if lhl.Pagesize == pageSize {
+					found = true
+					t.Ok(lhl.Limit == limit, fmt.Sprintf("hugepage limit is set correctly for size: %s", pageSize))
+					t.Diagnosticf("expect: %d, actual: %d", limit, lhl.Limit)
+				}
+			}
+			t.Ok(found, "hugepage limit found")
 
-	if err != nil {
-		t.Fail(err.Error())
+			return nil
+		})
+
+		if err != nil {
+			t.Fail(err.Error())
+		}
 	}
 }