1. docker
  2. Commit c2bc637a0306657a86f3739bd5bdcd5db8d22539
Browse code

Remove pointers from the SysInfo struct.

Because they can just be values.

Signed-off-by: David Calavera <david.calavera@gmail.com>

David Calavera authored on 2015/08/07 07:29:10
Showing 2 changed files
pkg/sysinfo/sysinfo.go
History View file @ c2bc637
... ... 
@@ -6,10 +6,10 @@ type SysInfo struct {
6 6 
 	// Whether the kernel supports AppArmor or not
7 7 
 	AppArmor bool
8 8
9 
-	*cgroupMemInfo
10 
-	*cgroupCPUInfo
11 
-	*cgroupBlkioInfo
12 
-	*cgroupCpusetInfo
9 
+	cgroupMemInfo
10 
+	cgroupCPUInfo
11 
+	cgroupBlkioInfo
12 
+	cgroupCpusetInfo
13 13
14 14 
 	// Whether IPv4 forwarding is supported or not, if this was disabled, networking will not work
15 15 
 	IPv4ForwardingDisabled bool
pkg/sysinfo/sysinfo_linux.go
History View file @ c2bc637
... ... 
@@ -33,89 +33,96 @@ func New(quiet bool) *SysInfo {
33 33 
 	return sysInfo
34 34 
 }
35 35
36 
-func checkCgroupMem(quiet bool) *cgroupMemInfo {
37 
-	info := &cgroupMemInfo{}
36 
+// checkCgroupMem reads the memory information from the memory cgroup mount point.
37 
+func checkCgroupMem(quiet bool) cgroupMemInfo {
38 38 
 	mountPoint, err := cgroups.FindCgroupMountpoint("memory")
39 39 
 	if err != nil {
40 40 
 		if !quiet {
41 41 
 			logrus.Warnf("Your kernel does not support cgroup memory limit: %v", err)
42 42 
 		}
43 
-		return info
43 
+		return cgroupMemInfo{}
44 44 
 	}
45 
-	info.MemoryLimit = true
46 45
47 
-	info.SwapLimit = cgroupEnabled(mountPoint, "memory.memsw.limit_in_bytes")
48 
-	if !quiet && !info.SwapLimit {
46 
+	swapLimit := cgroupEnabled(mountPoint, "memory.memsw.limit_in_bytes")
47 
+	if !quiet && !swapLimit {
49 48 
 		logrus.Warn("Your kernel does not support swap memory limit.")
50 49 
 	}
51 
-	info.OomKillDisable = cgroupEnabled(mountPoint, "memory.oom_control")
52 
-	if !quiet && !info.OomKillDisable {
50 
+	oomKillDisable := cgroupEnabled(mountPoint, "memory.oom_control")
51 
+	if !quiet && !oomKillDisable {
53 52 
 		logrus.Warnf("Your kernel does not support oom control.")
54 53 
 	}
55 
-	info.MemorySwappiness = cgroupEnabled(mountPoint, "memory.swappiness")
56 
-	if !quiet && !info.MemorySwappiness {
54 
+	memorySwappiness := cgroupEnabled(mountPoint, "memory.swappiness")
55 
+	if !quiet && !memorySwappiness {
57 56 
 		logrus.Warnf("Your kernel does not support memory swappiness.")
58 57 
 	}
59 58
60 
-	return info
59 
+	return cgroupMemInfo{
60 
+		MemoryLimit:      true,
61 
+		SwapLimit:        swapLimit,
62 
+		OomKillDisable:   oomKillDisable,
63 
+		MemorySwappiness: memorySwappiness,
64 
+	}
61 65 
 }
62 66
63 
-func checkCgroupCPU(quiet bool) *cgroupCPUInfo {
64 
-	info := &cgroupCPUInfo{}
67 
+// checkCgroupCPU reads the cpu information from the cpu cgroup mount point.
68 
+func checkCgroupCPU(quiet bool) cgroupCPUInfo {
65 69 
 	mountPoint, err := cgroups.FindCgroupMountpoint("cpu")
66 70 
 	if err != nil {
67 71 
 		if !quiet {
68 72 
 			logrus.Warn(err)
69 73 
 		}
70 
-		return info
74 
+		return cgroupCPUInfo{}
71 75 
 	}
72 76
73 
-	info.CPUShares = cgroupEnabled(mountPoint, "cpu.shares")
74 
-	if !quiet && !info.CPUShares {
77 
+	cpuShares := cgroupEnabled(mountPoint, "cpu.shares")
78 
+	if !quiet && !cpuShares {
75 79 
 		logrus.Warn("Your kernel does not support cgroup cpu shares")
76 80 
 	}
77 81
78 
-	info.CPUCfsPeriod = cgroupEnabled(mountPoint, "cpu.cfs_period_us")
79 
-	if !quiet && !info.CPUCfsPeriod {
82 
+	cpuCfsPeriod := cgroupEnabled(mountPoint, "cpu.cfs_period_us")
83 
+	if !quiet && !cpuCfsPeriod {
80 84 
 		logrus.Warn("Your kernel does not support cgroup cfs period")
81 85 
 	}
82 86
83 
-	info.CPUCfsQuota = cgroupEnabled(mountPoint, "cpu.cfs_quota_us")
84 
-	if !quiet && !info.CPUCfsQuota {
87 
+	cpuCfsQuota := cgroupEnabled(mountPoint, "cpu.cfs_quota_us")
88 
+	if !quiet && !cpuCfsQuota {
85 89 
 		logrus.Warn("Your kernel does not support cgroup cfs quotas")
86 90 
 	}
87 
-	return info
91 
+	return cgroupCPUInfo{
92 
+		CPUShares:    cpuShares,
93 
+		CPUCfsPeriod: cpuCfsPeriod,
94 
+		CPUCfsQuota:  cpuCfsQuota,
95 
+	}
88 96 
 }
89 97
90 
-func checkCgroupBlkioInfo(quiet bool) *cgroupBlkioInfo {
91 
-	info := &cgroupBlkioInfo{}
98 
+// checkCgroupBlkioInfo reads the blkio information from the blkio cgroup mount point.
99 
+func checkCgroupBlkioInfo(quiet bool) cgroupBlkioInfo {
92 100 
 	mountPoint, err := cgroups.FindCgroupMountpoint("blkio")
93 101 
 	if err != nil {
94 102 
 		if !quiet {
95 103 
 			logrus.Warn(err)
96 104 
 		}
97 
-		return info
105 
+		return cgroupBlkioInfo{}
98 106 
 	}
99 107
100 
-	info.BlkioWeight = cgroupEnabled(mountPoint, "blkio.weight")
101 
-	if !quiet && !info.BlkioWeight {
108 
+	w := cgroupEnabled(mountPoint, "blkio.weight")
109 
+	if !quiet && !w {
102 110 
 		logrus.Warn("Your kernel does not support cgroup blkio weight")
103 111 
 	}
104 
-	return info
112 
+	return cgroupBlkioInfo{BlkioWeight: w}
105 113 
 }
106 114
107 
-func checkCgroupCpusetInfo(quiet bool) *cgroupCpusetInfo {
108 
-	info := &cgroupCpusetInfo{}
115 
+// checkCgroupCpusetInfo reads the cpuset information from the cpuset cgroup mount point.
116 
+func checkCgroupCpusetInfo(quiet bool) cgroupCpusetInfo {
109 117 
 	_, err := cgroups.FindCgroupMountpoint("cpuset")
110 118 
 	if err != nil {
111 119 
 		if !quiet {
112 120 
 			logrus.Warn(err)
113 121 
 		}
114 
-		return info
122 
+		return cgroupCpusetInfo{}
115 123 
 	}
116 124
117 
-	info.Cpuset = true
118 
-	return info
125 
+	return cgroupCpusetInfo{Cpuset: true}
119 126 
 }
120 127
121 128 
 func cgroupEnabled(mountPoint, name string) bool {