mirror/runc
1
0
Fork 0
mirror of https://github.com/opencontainers/runc.git synced 2026-07-11 06:03:57 +08:00
Code Issues Packages Projects Releases Wiki Activity

Revert "Set temporary single CPU affinity..."

Browse Source 
There's too much logic here figuring out which CPUs to use. Runc is a
low level tool and is not supposed to be that "smart". What's worse,
this logic is executed on every exec, making it slower. Some of the
logic in (*setnsProcess).start is executed even if no annotation is set,
thus making ALL execs slow.

Also, this should be a property of a process, rather than annotation.

The plan is to rework this.

This reverts commit afc23e3397.

Signed-off-by: Kir Kolyshkin <kolyshkin@gmail.com>
This commit is contained in:
Kir Kolyshkin
2024-05-17 17:21:15 -07:00
committed by lfbzhm
parent 67a1477959
commit 1c505fffdc
15 changed files with 16 additions and 961 deletions
Download Patch File Download Diff File Expand all files Collapse all files
libcontainer/system/kernelparam/lookup.go
-41
View File
@@ -1,41 +0,0 @@
package kernelparam
import (
"io/fs"
"strings"
)
func runeFilter(c rune) bool {
return c < '!' || c > '~'
}
// LookupKernelBootParameters returns the selected kernel parameters specified
// in the kernel command line. The parameters are returned as a map of key-value pairs.
func LookupKernelBootParameters(rootFS fs.FS, lookupParameters ...string) (map[string]string, error) {
cmdline, err := fs.ReadFile(rootFS, "proc/cmdline")
if err != nil {
return nil, err
}
kernelParameters := make(map[string]string)
remaining := len(lookupParameters)
for _, parameter := range strings.FieldsFunc(string(cmdline), runeFilter) {
if remaining == 0 {
break
}
idx := strings.IndexByte(parameter, '=')
if idx == -1 {
continue
}
for _, lookupParam := range lookupParameters {
if lookupParam == parameter[:idx] {
kernelParameters[lookupParam] = parameter[idx+1:]
remaining--
break
}
}
}
return kernelParameters, nil
}
libcontainer/system/kernelparam/lookup_test.go
-60
View File
@@ -1,60 +0,0 @@
package kernelparam
import (
"testing"
"testing/fstest"
)
func TestLookupKernelBootParameters(t *testing.T) {
for _, test := range []struct {
cmdline string
lookupParameters []string
expectedKernelParameters map[string]string
}{
{
cmdline: "root=/dev/sda1 ro console=ttyS0 console=tty0",
lookupParameters: []string{"root"},
expectedKernelParameters: map[string]string{
"root": "/dev/sda1",
},
},
{
cmdline: "ro runc.kernel_parameter=a_value console=ttyS0 console=tty0",
lookupParameters: []string{"runc.kernel_parameter"},
expectedKernelParameters: map[string]string{
"runc.kernel_parameter": "a_value",
},
},
{
cmdline: "ro runc.kernel_parameter_a=value_a runc.kernel_parameter_b=value_a:value_b",
lookupParameters: []string{
"runc.kernel_parameter_a",
"runc.kernel_parameter_b",
},
expectedKernelParameters: map[string]string{
"runc.kernel_parameter_a": "value_a",
"runc.kernel_parameter_b": "value_a:value_b",
},
},
{
cmdline: "root=/dev/sda1 ro console=ttyS0 console=tty0",
lookupParameters: []string{"runc.kernel_parameter_a"},
expectedKernelParameters: map[string]string{},
},
} {
params, err := LookupKernelBootParameters(fstest.MapFS{
"proc/cmdline": &fstest.MapFile{Data: []byte(test.cmdline + "\n")},
}, test.lookupParameters...)
if err != nil {
t.Fatalf("unexpected error: %s", err)
}
if len(params) != len(test.expectedKernelParameters) {
t.Fatalf("expected %d parameters, got %d", len(test.expectedKernelParameters), len(params))
}
for k, v := range test.expectedKernelParameters {
if params[k] != v {
t.Fatalf("expected parameter %s to be %s, got %s", k, v, params[k])
}
}
}
}