1 package fs
2
3 import (
4 "fmt"
5 "strconv"
6 "testing"
7
8 "github.com/opencontainers/runc/libcontainer/cgroups"
9 "github.com/opencontainers/runc/libcontainer/cgroups/fscommon"
10 "github.com/opencontainers/runc/libcontainer/configs"
11 )
12
13 const (
14 hugetlbUsageContents = "128\n"
15 hugetlbMaxUsageContents = "256\n"
16 hugetlbFailcnt = "100\n"
17 )
18
19 const (
20 usage = "hugetlb.%s.usage_in_bytes"
21 limit = "hugetlb.%s.limit_in_bytes"
22 maxUsage = "hugetlb.%s.max_usage_in_bytes"
23 failcnt = "hugetlb.%s.failcnt"
24
25 rsvdUsage = "hugetlb.%s.rsvd.usage_in_bytes"
26 rsvdLimit = "hugetlb.%s.rsvd.limit_in_bytes"
27 rsvdMaxUsage = "hugetlb.%s.rsvd.max_usage_in_bytes"
28 rsvdFailcnt = "hugetlb.%s.rsvd.failcnt"
29 )
30
31 func TestHugetlbSetHugetlb(t *testing.T) {
32 path := tempDir(t, "hugetlb")
33
34 const (
35 hugetlbBefore = 256
36 hugetlbAfter = 512
37 )
38
39 for _, pageSize := range cgroups.HugePageSizes() {
40 writeFileContents(t, path, map[string]string{
41 fmt.Sprintf(limit, pageSize): strconv.Itoa(hugetlbBefore),
42 })
43 }
44
45 r := &configs.Resources{}
46 for _, pageSize := range cgroups.HugePageSizes() {
47 r.HugetlbLimit = []*configs.HugepageLimit{
48 {
49 Pagesize: pageSize,
50 Limit: hugetlbAfter,
51 },
52 }
53 hugetlb := &HugetlbGroup{}
54 if err := hugetlb.Set(path, r); err != nil {
55 t.Fatal(err)
56 }
57 }
58
59 for _, pageSize := range cgroups.HugePageSizes() {
60 for _, f := range []string{limit, rsvdLimit} {
61 limit := fmt.Sprintf(f, pageSize)
62 value, err := fscommon.GetCgroupParamUint(path, limit)
63 if err != nil {
64 t.Fatal(err)
65 }
66 if value != hugetlbAfter {
67 t.Fatalf("Set %s failed. Expected: %v, Got: %v", limit, hugetlbAfter, value)
68 }
69 }
70 }
71 }
72
73 func TestHugetlbStats(t *testing.T) {
74 path := tempDir(t, "hugetlb")
75 for _, pageSize := range cgroups.HugePageSizes() {
76 writeFileContents(t, path, map[string]string{
77 fmt.Sprintf(usage, pageSize): hugetlbUsageContents,
78 fmt.Sprintf(maxUsage, pageSize): hugetlbMaxUsageContents,
79 fmt.Sprintf(failcnt, pageSize): hugetlbFailcnt,
80 })
81 }
82
83 hugetlb := &HugetlbGroup{}
84 actualStats := *cgroups.NewStats()
85 err := hugetlb.GetStats(path, &actualStats)
86 if err != nil {
87 t.Fatal(err)
88 }
89 expectedStats := cgroups.HugetlbStats{Usage: 128, MaxUsage: 256, Failcnt: 100}
90 for _, pageSize := range cgroups.HugePageSizes() {
91 expectHugetlbStatEquals(t, expectedStats, actualStats.HugetlbStats[pageSize])
92 }
93 }
94
95 func TestHugetlbRStatsRsvd(t *testing.T) {
96 path := tempDir(t, "hugetlb")
97 for _, pageSize := range cgroups.HugePageSizes() {
98 writeFileContents(t, path, map[string]string{
99 fmt.Sprintf(rsvdUsage, pageSize): hugetlbUsageContents,
100 fmt.Sprintf(rsvdMaxUsage, pageSize): hugetlbMaxUsageContents,
101 fmt.Sprintf(rsvdFailcnt, pageSize): hugetlbFailcnt,
102 })
103 }
104
105 hugetlb := &HugetlbGroup{}
106 actualStats := *cgroups.NewStats()
107 err := hugetlb.GetStats(path, &actualStats)
108 if err != nil {
109 t.Fatal(err)
110 }
111 expectedStats := cgroups.HugetlbStats{Usage: 128, MaxUsage: 256, Failcnt: 100}
112 for _, pageSize := range cgroups.HugePageSizes() {
113 expectHugetlbStatEquals(t, expectedStats, actualStats.HugetlbStats[pageSize])
114 }
115 }
116
117 func TestHugetlbStatsNoUsageFile(t *testing.T) {
118 path := tempDir(t, "hugetlb")
119 writeFileContents(t, path, map[string]string{
120 maxUsage: hugetlbMaxUsageContents,
121 })
122
123 hugetlb := &HugetlbGroup{}
124 actualStats := *cgroups.NewStats()
125 err := hugetlb.GetStats(path, &actualStats)
126 if err == nil {
127 t.Fatal("Expected failure")
128 }
129 }
130
131 func TestHugetlbStatsNoMaxUsageFile(t *testing.T) {
132 path := tempDir(t, "hugetlb")
133 for _, pageSize := range cgroups.HugePageSizes() {
134 writeFileContents(t, path, map[string]string{
135 fmt.Sprintf(usage, pageSize): hugetlbUsageContents,
136 })
137 }
138
139 hugetlb := &HugetlbGroup{}
140 actualStats := *cgroups.NewStats()
141 err := hugetlb.GetStats(path, &actualStats)
142 if err == nil {
143 t.Fatal("Expected failure")
144 }
145 }
146
147 func TestHugetlbStatsBadUsageFile(t *testing.T) {
148 path := tempDir(t, "hugetlb")
149 for _, pageSize := range cgroups.HugePageSizes() {
150 writeFileContents(t, path, map[string]string{
151 fmt.Sprintf(usage, pageSize): "bad",
152 maxUsage: hugetlbMaxUsageContents,
153 })
154 }
155
156 hugetlb := &HugetlbGroup{}
157 actualStats := *cgroups.NewStats()
158 err := hugetlb.GetStats(path, &actualStats)
159 if err == nil {
160 t.Fatal("Expected failure")
161 }
162 }
163
164 func TestHugetlbStatsBadMaxUsageFile(t *testing.T) {
165 path := tempDir(t, "hugetlb")
166 writeFileContents(t, path, map[string]string{
167 usage: hugetlbUsageContents,
168 maxUsage: "bad",
169 })
170
171 hugetlb := &HugetlbGroup{}
172 actualStats := *cgroups.NewStats()
173 err := hugetlb.GetStats(path, &actualStats)
174 if err == nil {
175 t.Fatal("Expected failure")
176 }
177 }
178
View as plain text