summaryrefslogtreecommitdiff
path: root/pkg/sysinfo/sysinfo_solaris.go
blob: 7463cdd8f03acfc5ec4e1423bc2d61f60602c653 (plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
// +build solaris,cgo

package sysinfo

import (
	"bytes"
	"os/exec"
	"strconv"
	"strings"
)

/*
#cgo LDFLAGS: -llgrp
#cgo CFLAGS: -Wall -Werror
#include <unistd.h>
#include <stdlib.h>
#include <sys/lgrp_user.h>
int getLgrpCount() {
	lgrp_cookie_t lgrpcookie = LGRP_COOKIE_NONE;
	uint_t nlgrps;

	if ((lgrpcookie = lgrp_init(LGRP_VIEW_OS)) == LGRP_COOKIE_NONE) {
		return -1;
	}
	nlgrps = lgrp_nlgrps(lgrpcookie);
	return nlgrps;
}
*/
import "C"

// IsCPUSharesAvailable returns whether CPUShares setting is supported.
// We need FSS to be set as default scheduling class to support CPU Shares
func IsCPUSharesAvailable() bool {
	cmd := exec.Command("/usr/sbin/dispadmin", "-d")
	outBuf := new(bytes.Buffer)
	errBuf := new(bytes.Buffer)
	cmd.Stderr = errBuf
	cmd.Stdout = outBuf

	if err := cmd.Run(); err != nil {
		return false
	}
	return (strings.Contains(outBuf.String(), "FSS"))
}

// New returns a new SysInfo, using the filesystem to detect which features
// the kernel supports.
//NOTE Solaris: If we change the below capabilities be sure
// to update verifyPlatformContainerSettings() in daemon_solaris.go
func New(quiet bool) *SysInfo {
	sysInfo := &SysInfo{}
	sysInfo.cgroupMemInfo = setCgroupMem(quiet)
	sysInfo.cgroupCPUInfo = setCgroupCPU(quiet)
	sysInfo.cgroupBlkioInfo = setCgroupBlkioInfo(quiet)
	sysInfo.cgroupCpusetInfo = setCgroupCPUsetInfo(quiet)

	sysInfo.IPv4ForwardingDisabled = false

	sysInfo.AppArmor = false

	return sysInfo
}

// setCgroupMem reads the memory information for Solaris.
func setCgroupMem(quiet bool) cgroupMemInfo {

	return cgroupMemInfo{
		MemoryLimit:       true,
		SwapLimit:         true,
		MemoryReservation: false,
		OomKillDisable:    false,
		MemorySwappiness:  false,
		KernelMemory:      false,
	}
}

// setCgroupCPU reads the cpu information for Solaris.
func setCgroupCPU(quiet bool) cgroupCPUInfo {

	return cgroupCPUInfo{
		CPUShares:          true,
		CPUCfsPeriod:       false,
		CPUCfsQuota:        true,
		CPURealtimePeriod:  false,
		CPURealtimeRuntime: false,
	}
}

// blkio switches are not supported in Solaris.
func setCgroupBlkioInfo(quiet bool) cgroupBlkioInfo {

	return cgroupBlkioInfo{
		BlkioWeight:       false,
		BlkioWeightDevice: false,
	}
}

// setCgroupCPUsetInfo reads the cpuset information for Solaris.
func setCgroupCPUsetInfo(quiet bool) cgroupCpusetInfo {

	return cgroupCpusetInfo{
		Cpuset: true,
		Cpus:   getCPUCount(),
		Mems:   getLgrpCount(),
	}
}

func getCPUCount() string {
	ncpus := C.sysconf(C._SC_NPROCESSORS_ONLN)
	if ncpus <= 0 {
		return ""
	}
	return strconv.FormatInt(int64(ncpus), 16)
}

func getLgrpCount() string {
	nlgrps := C.getLgrpCount()
	if nlgrps <= 0 {
		return ""
	}
	return strconv.FormatInt(int64(nlgrps), 16)
}