Add numa cpuset support

This change adds support for specifying a set of cpu and memory nodes
during the CreateVM call. This will run the jailed process on those set
of cpus and restrict access to the specified nodes. This change also
adds the cpuset.Builder which allows for easy creation of cpus and mems
strings

Signed-off-by: xibz <[email protected]>

Author: xibz

proto/firecracker.pb.go

@@ -81,5 +81,12 @@ message GetVMMetadataResponse {
 
 message JailerConfig {
     string NetNS = 1;
+
+	// The list of CPUs to run the jailed application on. This field can only
+	// be used on numa architectures
+    string CPUs = 2;
+	// The list of memory nodes to run with the jailed application on. This
+	// field can only be used on numa architectures
+    string Mems = 3;
 }
 

proto/firecracker.proto

@@ -0,0 +1,119 @@
+// Copyright 2018-2019 Amazon.com, Inc. or its affiliates. All Rights Reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License"). You may
+// not use this file except in compliance with the License. A copy of the
+// License is located at
+//
+//	http://aws.amazon.com/apache2.0/
+//
+// or in the "license" file accompanying this file. This file is distributed
+// on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either
+// express or implied. See the License for the specific language governing
+// permissions and limitations under the License.
+
+package cpuset
+
+import (
+	"fmt"
+)
+
+// Builder will allow building of cpuset fields
+// http://man7.org/linux/man-pages/man7/cpuset.7.html
+type Builder struct {
+	cpus      []int
+	cpuRanges []_range
+
+	mems      []int
+	memRanges []_range
+}
+
+type _range struct {
+	min, max int
+}
+
+// CPUSet represents the linux CPUSet which is a series of configurable values
+// that allow processes to run on a specific CPUs and those CPUs are then bound
+// to the memory nodes specified.
+type CPUSet struct {
+	cpus string
+	mems string
+}
+
+// CPUs returns the cpuset.cpus string
+func (c CPUSet) CPUs() string {
+	return c.cpus
+}
+
+// Mems returns the cpuset.mems string
+func (c CPUSet) Mems() string {
+	return c.mems
+}
+
+// AddCPU will add the physical CPU number that the process is allowed to run
+// on.
+func (b Builder) AddCPU(cpu int) Builder {
+	b.cpus = append(b.cpus, cpu)
+	return b
+}
+
+// AddCPURange adds a range of physical CPU numbers that the process is allowed
+// to run on
+func (b Builder) AddCPURange(min, max int) Builder {
+	b.cpuRanges = append(b.cpuRanges, _range{
+		min: min,
+		max: max,
+	})
+
+	return b
+}
+
+// AddMem adds a memory node which limit where the cpus can allocate memory
+func (b Builder) AddMem(mem int) Builder {
+	b.mems = append(b.mems, mem)
+	return b
+}
+
+// AddMemRange adds a range of memory nodes by utilizing the minimum node to
+// use to the maximum node to use.
+func (b Builder) AddMemRange(min, max int) Builder {
+	b.memRanges = append(b.memRanges, _range{
+		min: min,
+		max: max,
+	})
+
+	return b
+}
+
+// Build constructs a new CPUSet
+func (b Builder) Build() CPUSet {
+	cpus := stringify(b.cpus, b.cpuRanges)
+	mems := stringify(b.mems, b.memRanges)
+
+	return CPUSet{
+		cpus: cpus,
+		mems: mems,
+	}
+}
+
+func stringify(elems []int, ranges []_range) string {
+	str := ""
+	for _, elem := range elems {
+		sep := ","
+		if len(str) == 0 {
+			sep = ""
+		}
+
+		str += fmt.Sprintf("%s%d", sep, elem)
+	}
+
+	for _, r := range ranges {
+		sep := ","
+		if len(str) == 0 {
+			sep = ""
+		}
+
+		str += fmt.Sprintf("%s%d-%d", sep, r.min, r.max)
+	}
+
+	return str
+}

runtime/cpuset/cpuset_builder.go

@@ -0,0 +1,166 @@
+// Copyright 2018-2019 Amazon.com, Inc. or its affiliates. All Rights Reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License"). You may
+// not use this file except in compliance with the License. A copy of the
+// License is located at
+//
+//	http://aws.amazon.com/apache2.0/
+//
+// or in the "license" file accompanying this file. This file is distributed
+// on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either
+// express or implied. See the License for the specific language governing
+// permissions and limitations under the License.
+
+package cpuset
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+)
+
+func TestCPUSet(t *testing.T) {
+	cases := []struct {
+		name           string
+		cpus           []int
+		mems           []int
+		cpuRanges      []_range
+		memRanges      []_range
+		expectedCPUSet CPUSet
+	}{
+		{
+			name: "single cpu only",
+			cpus: []int{0},
+			expectedCPUSet: CPUSet{
+				cpus: "0",
+			},
+		},
+		{
+			name: "cpus only",
+			cpus: []int{0, 5, 6},
+			expectedCPUSet: CPUSet{
+				cpus: "0,5,6",
+			},
+		},
+		{
+			name: "single mem only",
+			mems: []int{2},
+			expectedCPUSet: CPUSet{
+				mems: "2",
+			},
+		},
+		{
+			name: "mems only",
+			mems: []int{2, 8, 3},
+			expectedCPUSet: CPUSet{
+				mems: "2,8,3",
+			},
+		},
+		{
+			name: "cpu single range only",
+			cpuRanges: []_range{
+				{
+					min: 0,
+					max: 3,
+				},
+			},
+			expectedCPUSet: CPUSet{
+				cpus: "0-3",
+			},
+		},
+		{
+			name: "cpu ranges only",
+			cpuRanges: []_range{
+				{
+					min: 0,
+					max: 3,
+				},
+				{
+					min: 5,
+					max: 10,
+				},
+			},
+			expectedCPUSet: CPUSet{
+				cpus: "0-3,5-10",
+			},
+		},
+		{
+			name: "mem single range only",
+			memRanges: []_range{
+				{
+					min: 0,
+					max: 1,
+				},
+			},
+			expectedCPUSet: CPUSet{
+				mems: "0-1",
+			},
+		},
+		{
+			name: "mem ranges only",
+			memRanges: []_range{
+				{
+					min: 0,
+					max: 1,
+				},
+				{
+					min: 2,
+					max: 3,
+				},
+			},
+			expectedCPUSet: CPUSet{
+				mems: "0-1,2-3",
+			},
+		},
+		{
+			name: "all inclusive",
+			cpus: []int{15, 17, 31},
+			cpuRanges: []_range{
+				{
+					min: 0,
+					max: 3,
+				},
+			},
+			mems: []int{128, 131, 140},
+			memRanges: []_range{
+				{
+					min: 0,
+					max: 1,
+				},
+				{
+					min: 2,
+					max: 3,
+				},
+			},
+			expectedCPUSet: CPUSet{
+				cpus: "15,17,31,0-3",
+				mems: "128,131,140,0-1,2-3",
+			},
+		},
+	}
+
+	for _, _c := range cases {
+		c := _c
+		t.Run(c.name, func(t *testing.T) {
+			b := Builder{}
+			for _, cpu := range c.cpus {
+				b = b.AddCPU(cpu)
+			}
+
+			for _, r := range c.cpuRanges {
+				b = b.AddCPURange(r.min, r.max)
+			}
+
+			for _, mem := range c.mems {
+				b = b.AddMem(mem)
+			}
+
+			for _, r := range c.memRanges {
+				b = b.AddMemRange(r.min, r.max)
+			}
+
+			cpuSet := b.Build()
+			assert.Equal(t, c.expectedCPUSet, cpuSet)
+		})
+	}
+}