podman

1
//go:build !remote
2

3
package libpod
4

5
import (
6
	"bufio"
7
	"fmt"
8
	"math"
9
	"os"
10
	"strconv"
11
	"strings"
12

13
	"github.com/containers/common/libnetwork/pasta"
14
	"github.com/containers/common/libnetwork/slirp4netns"
15
	"github.com/containers/common/pkg/apparmor"
16
	"github.com/containers/common/pkg/cgroups"
17
	"github.com/containers/common/pkg/seccomp"
18
	"github.com/containers/common/pkg/version"
19
	"github.com/containers/podman/v5/libpod/define"
20
	"github.com/containers/podman/v5/pkg/rootless"
21
	"github.com/containers/podman/v5/pkg/util"
22
	"github.com/containers/storage/pkg/unshare"
23
	"github.com/opencontainers/selinux/go-selinux"
24
	"github.com/sirupsen/logrus"
25
)
26

27
func (r *Runtime) setPlatformHostInfo(info *define.HostInfo) error {
28
	seccompProfilePath, err := DefaultSeccompPath()
29
	if err != nil {
30
		return fmt.Errorf("getting Seccomp profile path: %w", err)
31
	}
32

33
	// Cgroups version
34
	unified, err := cgroups.IsCgroup2UnifiedMode()
35
	if err != nil {
36
		return fmt.Errorf("reading cgroups mode: %w", err)
37
	}
38

39
	// Get Map of all available controllers
40
	availableControllers, err := cgroups.AvailableControllers(nil, unified)
41
	if err != nil {
42
		return fmt.Errorf("getting available cgroup controllers: %w", err)
43
	}
44

45
	info.CgroupManager = r.config.Engine.CgroupManager
46
	info.CgroupControllers = availableControllers
47
	info.IDMappings = define.IDMappings{}
48
	info.Security = define.SecurityInfo{
49
		AppArmorEnabled:     apparmor.IsEnabled(),
50
		DefaultCapabilities: strings.Join(r.config.Containers.DefaultCapabilities.Get(), ","),
51
		Rootless:            rootless.IsRootless(),
52
		SECCOMPEnabled:      seccomp.IsEnabled(),
53
		SECCOMPProfilePath:  seccompProfilePath,
54
		SELinuxEnabled:      selinux.GetEnabled(),
55
	}
56
	info.Slirp4NetNS = define.SlirpInfo{}
57

58
	cgroupVersion := "v1"
59
	if unified {
60
		cgroupVersion = "v2"
61
	}
62
	info.CgroupsVersion = cgroupVersion
63

64
	slirp4netnsPath := r.config.Engine.NetworkCmdPath
65
	if slirp4netnsPath == "" {
66
		slirp4netnsPath, _ = r.config.FindHelperBinary(slirp4netns.BinaryName, true)
67
	}
68
	if slirp4netnsPath != "" {
69
		ver, err := version.Program(slirp4netnsPath)
70
		if err != nil {
71
			logrus.Warnf("Failed to retrieve program version for %s: %v", slirp4netnsPath, err)
72
		}
73
		program := define.SlirpInfo{
74
			Executable: slirp4netnsPath,
75
			Package:    version.Package(slirp4netnsPath),
76
			Version:    ver,
77
		}
78
		info.Slirp4NetNS = program
79
	}
80

81
	pastaPath, _ := r.config.FindHelperBinary(pasta.BinaryName, true)
82
	if pastaPath != "" {
83
		ver, err := version.Program(pastaPath)
84
		if err != nil {
85
			logrus.Warnf("Failed to retrieve program version for %s: %v", pastaPath, err)
86
		}
87
		program := define.PastaInfo{
88
			Executable: pastaPath,
89
			Package:    version.Package(pastaPath),
90
			Version:    ver,
91
		}
92
		info.Pasta = program
93
	}
94

95
	if rootless.IsRootless() {
96
		uidmappings, gidmappings, err := unshare.GetHostIDMappings("")
97
		if err != nil {
98
			return fmt.Errorf("reading id mappings: %w", err)
99
		}
100
		idmappings := define.IDMappings{
101
			GIDMap: util.RuntimeSpecToIDtools(gidmappings),
102
			UIDMap: util.RuntimeSpecToIDtools(uidmappings),
103
		}
104
		info.IDMappings = idmappings
105
	}
106

107
	return nil
108
}
109

110
func statToPercent(stats []string) (*define.CPUUsage, error) {
111
	userTotal, err := strconv.ParseFloat(stats[1], 64)
112
	if err != nil {
113
		return nil, fmt.Errorf("unable to parse user value %q: %w", stats[1], err)
114
	}
115
	systemTotal, err := strconv.ParseFloat(stats[3], 64)
116
	if err != nil {
117
		return nil, fmt.Errorf("unable to parse system value %q: %w", stats[3], err)
118
	}
119
	idleTotal, err := strconv.ParseFloat(stats[4], 64)
120
	if err != nil {
121
		return nil, fmt.Errorf("unable to parse idle value %q: %w", stats[4], err)
122
	}
123
	total := userTotal + systemTotal + idleTotal
124
	s := define.CPUUsage{
125
		UserPercent:   math.Round((userTotal/total*100)*100) / 100,
126
		SystemPercent: math.Round((systemTotal/total*100)*100) / 100,
127
		IdlePercent:   math.Round((idleTotal/total*100)*100) / 100,
128
	}
129
	return &s, nil
130
}
131

132
// getCPUUtilization Returns a CPUUsage object that summarizes CPU
133
// usage for userspace, system, and idle time.
134
func getCPUUtilization() (*define.CPUUsage, error) {
135
	f, err := os.Open("/proc/stat")
136
	if err != nil {
137
		return nil, err
138
	}
139
	defer f.Close()
140
	scanner := bufio.NewScanner(f)
141
	// Read first line of /proc/stat that has entries for system ("cpu" line)
142
	for scanner.Scan() {
143
		break
144
	}
145
	// column 1 is user, column 3 is system, column 4 is idle
146
	stats := strings.Fields(scanner.Text())
147
	return statToPercent(stats)
148
}
149