mirror of
https://github.com/kubernetes-sigs/node-feature-discovery.git
synced 2025-03-05 08:17:04 +00:00
231 lines
5.4 KiB
Go
231 lines
5.4 KiB
Go
/*
|
|
Copyright 2018 The Kubernetes Authors.
|
|
|
|
Licensed under the Apache License, Version 2.0 (the "License");
|
|
you may not use this file except in compliance with the License.
|
|
You may obtain a copy of the License at
|
|
|
|
http://www.apache.org/licenses/LICENSE-2.0
|
|
|
|
Unless required by applicable law or agreed to in writing, software
|
|
distributed under the License 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 kernel
|
|
|
|
import (
|
|
"bytes"
|
|
"compress/gzip"
|
|
"fmt"
|
|
"io/ioutil"
|
|
"log"
|
|
"os"
|
|
"path/filepath"
|
|
"regexp"
|
|
"strings"
|
|
|
|
"k8s.io/apimachinery/pkg/util/validation"
|
|
"sigs.k8s.io/node-feature-discovery/source"
|
|
)
|
|
|
|
// Configuration file options
|
|
type Config struct {
|
|
KconfigFile string
|
|
ConfigOpts []string `json:"configOpts,omitempty"`
|
|
}
|
|
|
|
// newDefaultConfig returns a new config with pre-populated defaults
|
|
func newDefaultConfig() *Config {
|
|
return &Config{
|
|
KconfigFile: "",
|
|
ConfigOpts: []string{
|
|
"NO_HZ",
|
|
"NO_HZ_IDLE",
|
|
"NO_HZ_FULL",
|
|
"PREEMPT",
|
|
},
|
|
}
|
|
}
|
|
|
|
// Implement FeatureSource interface
|
|
type Source struct {
|
|
config *Config
|
|
}
|
|
|
|
func (s *Source) Name() string { return "kernel" }
|
|
|
|
// NewConfig method of the FeatureSource interface
|
|
func (s *Source) NewConfig() source.Config { return newDefaultConfig() }
|
|
|
|
// GetConfig method of the FeatureSource interface
|
|
func (s *Source) GetConfig() source.Config { return s.config }
|
|
|
|
// SetConfig method of the FeatureSource interface
|
|
func (s *Source) SetConfig(conf source.Config) {
|
|
switch v := conf.(type) {
|
|
case *Config:
|
|
s.config = v
|
|
default:
|
|
log.Printf("PANIC: invalid config type: %T", conf)
|
|
}
|
|
}
|
|
|
|
func (s *Source) Discover() (source.Features, error) {
|
|
features := source.Features{}
|
|
|
|
// Read kernel version
|
|
version, err := parseVersion()
|
|
if err != nil {
|
|
log.Printf("ERROR: Failed to get kernel version: %s", err)
|
|
} else {
|
|
for key := range version {
|
|
features["version."+key] = version[key]
|
|
}
|
|
}
|
|
|
|
// Read kconfig
|
|
kconfig, err := parseKconfig(s.config.KconfigFile)
|
|
if err != nil {
|
|
log.Printf("ERROR: Failed to read kconfig: %s", err)
|
|
}
|
|
|
|
// Check flags
|
|
for _, opt := range s.config.ConfigOpts {
|
|
if val, ok := kconfig[opt]; ok {
|
|
features["config."+opt] = val
|
|
}
|
|
}
|
|
|
|
selinux, err := SelinuxEnabled()
|
|
if err != nil {
|
|
log.Print(err)
|
|
} else if selinux {
|
|
features["selinux.enabled"] = true
|
|
}
|
|
|
|
return features, nil
|
|
}
|
|
|
|
// Read and parse kernel version
|
|
func parseVersion() (map[string]string, error) {
|
|
version := map[string]string{}
|
|
|
|
// Open file for reading
|
|
raw, err := ioutil.ReadFile("/proc/sys/kernel/osrelease")
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
full := strings.TrimSpace(string(raw))
|
|
|
|
// Replace forbidden symbols
|
|
fullRegex := regexp.MustCompile("[^-A-Za-z0-9_.]")
|
|
full = fullRegex.ReplaceAllString(full, "_")
|
|
|
|
version["full"] = full
|
|
|
|
// Regexp for parsing version components
|
|
re := regexp.MustCompile(`^(?P<major>\d+)(\.(?P<minor>\d+))?(\.(?P<revision>\d+))?(-.*)?$`)
|
|
if m := re.FindStringSubmatch(full); m != nil {
|
|
for i, name := range re.SubexpNames() {
|
|
if i != 0 && name != "" {
|
|
version[name] = m[i]
|
|
}
|
|
}
|
|
}
|
|
|
|
return version, nil
|
|
}
|
|
|
|
// Read gzipped kernel config
|
|
func readKconfigGzip(filename string) ([]byte, error) {
|
|
// Open file for reading
|
|
f, err := os.Open(filename)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
defer f.Close()
|
|
|
|
// Uncompress data
|
|
r, err := gzip.NewReader(f)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
defer r.Close()
|
|
|
|
return ioutil.ReadAll(r)
|
|
}
|
|
|
|
// Read kconfig into a map
|
|
func parseKconfig(configPath string) (map[string]string, error) {
|
|
kconfig := map[string]string{}
|
|
raw := []byte(nil)
|
|
var err error
|
|
var searchPaths []string
|
|
|
|
unameRaw, err := ioutil.ReadFile("/proc/sys/kernel/osrelease")
|
|
kVer := strings.TrimSpace(string(unameRaw))
|
|
if err != nil {
|
|
searchPaths = []string{
|
|
"/proc/config.gz",
|
|
"/usr/src/linux/.config",
|
|
}
|
|
} else {
|
|
// from k8s.io/system-validator used by kubeadm
|
|
// preflight checks
|
|
searchPaths = []string{
|
|
"/proc/config.gz",
|
|
"/usr/src/linux-" + kVer + "/.config",
|
|
"/usr/src/linux/.config",
|
|
"/usr/lib/modules/" + kVer + "/config",
|
|
"/usr/lib/ostree-boot/config-" + kVer,
|
|
"/usr/lib/kernel/config-" + kVer,
|
|
"/usr/src/linux-headers-" + kVer + "/.config",
|
|
"/lib/modules/" + kVer + "/build/.config",
|
|
source.BootDir.Path("config-" + kVer),
|
|
}
|
|
}
|
|
|
|
for _, path := range append([]string{configPath}, searchPaths...) {
|
|
if len(path) > 0 {
|
|
if ".gz" == filepath.Ext(path) {
|
|
if raw, err = readKconfigGzip(path); err == nil {
|
|
break
|
|
}
|
|
} else {
|
|
if raw, err = ioutil.ReadFile(path); err == nil {
|
|
break
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
if raw == nil {
|
|
return nil, fmt.Errorf("Failed to read kernel config from %+v:", append([]string{configPath}, searchPaths...))
|
|
}
|
|
|
|
// Regexp for matching kconfig flags
|
|
re := regexp.MustCompile(`^CONFIG_(?P<flag>\w+)=(?P<value>.+)`)
|
|
|
|
// Process data, line-by-line
|
|
lines := bytes.Split(raw, []byte("\n"))
|
|
for _, line := range lines {
|
|
if m := re.FindStringSubmatch(string(line)); m != nil {
|
|
if m[2] == "y" || m[2] == "m" {
|
|
kconfig[m[1]] = "true"
|
|
} else {
|
|
value := strings.Trim(m[2], `"`)
|
|
if len(value) > validation.LabelValueMaxLength {
|
|
log.Printf("WARNING: ignoring kconfig option '%s': value exceeds max length of %d characters", m[1], validation.LabelValueMaxLength)
|
|
continue
|
|
}
|
|
kconfig[m[1]] = value
|
|
}
|
|
}
|
|
}
|
|
|
|
return kconfig, nil
|
|
}
|