Merge pull request #385 from dominikh/freebsd-no-c

Replace some FreeBSD collectors with pure Go versions

collector/cpu_freebsd.go

@@ -16,95 +16,67 @@
 package collector
 
 import (
-	"errors"
 	"strconv"
 	"unsafe"
 
 	"github.com/prometheus/client_golang/prometheus"
+	"golang.org/x/sys/unix"
 )
 
-/*
+type clockinfo struct {
-#cgo LDFLAGS:
+	hz     int32 // clock frequency
-#include <fcntl.h>
+	tick   int32 // micro-seconds per hz tick
-#include <stdlib.h>
+	spare  int32
-#include <sys/param.h>
+	stathz int32 // statistics clock frequency
-#include <sys/pcpu.h>
+	profhz int32 // profiling clock frequency
-#include <sys/resource.h>
+}
-#include <sys/sysctl.h>
-#include <sys/time.h>
-
-static int mibs_set_up = 0;
-
-static int mib_kern_cp_times[2];
-static size_t mib_kern_cp_times_len = 2;
-
-static const int mib_hw_ncpu[] = {CTL_HW, HW_NCPU};
-static const size_t mib_hw_ncpu_len = 2;
-
-static const int mib_kern_clockrate[] = {CTL_KERN, KERN_CLOCKRATE};
-static size_t mib_kern_clockrate_len = 2;
 
-// Setup method for MIBs not available as constants.
+type cputime struct {
-// Calls to this method must be synchronized externally.
+	user float64
-int setupSysctlMIBs() {
+	nice float64
-	int ret = sysctlnametomib("kern.cp_times", mib_kern_cp_times, &mib_kern_cp_times_len);
+	sys  float64
-	if (ret == 0) mibs_set_up = 1;
+	intr float64
-	return ret;
+	idle float64
 }
 
-int getCPUTimes(int *ncpu, double **cpu_times, size_t *cp_times_length) {
+func getCPUTimes() ([]cputime, error) {
+	const states = 5
 
-	// Assert that mibs are set up through setupSysctlMIBs
+	clockb, err := unix.SysctlRaw("kern.clockrate")
-	if (!mibs_set_up) {
+	if err != nil {
-		return -1;
+		return nil, err
 	}
-
+	clock := *(*clockinfo)(unsafe.Pointer(&clockb[0]))
-	// Retrieve number of cpu cores
+	cpb, err := unix.SysctlRaw("kern.cp_times")
-	size_t ncpu_size = sizeof(*ncpu);
+	if err != nil {
-	if (sysctl(mib_hw_ncpu, mib_hw_ncpu_len, ncpu, &ncpu_size, NULL, 0) == -1 ||
+		return nil, err
-	    sizeof(*ncpu) != ncpu_size) {
-		return -1;
 	}
 
-	// Retrieve clockrate
+	var cpufreq float64
-	struct clockinfo clockrate;
+	if clock.stathz > 0 {
-	size_t clockrate_size = sizeof(clockrate);
+		cpufreq = float64(clock.stathz)
-	if (sysctl(mib_kern_clockrate, mib_kern_clockrate_len, &clockrate, &clockrate_size, NULL, 0) == -1 ||
+	} else {
-	    sizeof(clockrate) != clockrate_size) {
+		cpufreq = float64(clock.hz)
-		return -1;
 	}
-
+	var times []float64
-	// Retrieve cp_times values
+	for len(cpb) >= int(unsafe.Sizeof(int(0))) {
-	*cp_times_length = (*ncpu) * CPUSTATES;
+		t := *(*int)(unsafe.Pointer(&cpb[0]))
-
+		times = append(times, float64(t)/cpufreq)
-	long cp_times[*cp_times_length];
+		cpb = cpb[unsafe.Sizeof(int(0)):]
-	size_t cp_times_size = sizeof(cp_times);
-
-	if (sysctl(mib_kern_cp_times, mib_kern_cp_times_len, &cp_times, &cp_times_size, NULL, 0) == -1 ||
-	    sizeof(cp_times) != cp_times_size) {
-		return -1;
 	}
 
-	// Compute absolute time for different CPU states
+	cpus := make([]cputime, len(times)/states)
-	long cpufreq = clockrate.stathz > 0 ? clockrate.stathz : clockrate.hz;
+	for i := 0; i < len(times); i += states {
-	*cpu_times = (double *) malloc(sizeof(double)*(*cp_times_length));
+		cpu := &cpus[i/states]
-	for (int i = 0; i < (*cp_times_length); i++) {
+		cpu.user = times[i]
-		(*cpu_times)[i] = ((double) cp_times[i]) / cpufreq;
+		cpu.nice = times[i+1]
+		cpu.sys = times[i+2]
+		cpu.intr = times[i+3]
+		cpu.idle = times[i+4]
 	}
-
+	return cpus, nil
-	return 0;
-
 }
 
-void freeCPUTimes(double *cpu_times) {
-	free(cpu_times);
-}
-
-*/
-import "C"
-
-const maxCPUTimesLen = C.MAXCPU * C.CPUSTATES
-
 type statCollector struct {
 	cpu *prometheus.CounterVec
 }
@@ -116,9 +88,6 @@ func init() {
 // Takes a prometheus registry and returns a new Collector exposing
 // CPU stats.
 func NewStatCollector() (Collector, error) {
-	if C.setupSysctlMIBs() == -1 {
-		return nil, errors.New("could not initialize sysctl MIBs")
-	}
 	return &statCollector{
 		cpu: prometheus.NewCounterVec(
 			prometheus.CounterOpts{
@@ -133,7 +102,6 @@ func NewStatCollector() (Collector, error) {
 
 // Expose CPU stats using sysctl.
 func (c *statCollector) Update(ch chan<- prometheus.Metric) (err error) {
-
 	// We want time spent per-cpu per CPUSTATE.
 	// CPUSTATES (number of CPUSTATES) is defined as 5U.
 	// Order: CP_USER | CP_NICE | CP_SYS | CP_IDLE | CP_INTR
@@ -145,29 +113,17 @@ func (c *statCollector) Update(ch chan<- prometheus.Metric) (err error) {
 	//
 	// Look into sys/kern/kern_clock.c for details.
 
-	var ncpu C.int
+	cpuTimes, err := getCPUTimes()
-	var cpuTimesC *C.double
+	if err != nil {
-	var cpuTimesLength C.size_t
+		return err
-	if C.getCPUTimes(&ncpu, &cpuTimesC, &cpuTimesLength) == -1 {
-		return errors.New("could not retrieve CPU times")
 	}
-	defer C.freeCPUTimes(cpuTimesC)
+	for cpu, t := range cpuTimes {
-	if cpuTimesLength > maxCPUTimesLen {
+		c.cpu.With(prometheus.Labels{"cpu": strconv.Itoa(cpu), "mode": "user"}).Set(t.user)
-		return errors.New("more CPU's than MAXCPU?")
+		c.cpu.With(prometheus.Labels{"cpu": strconv.Itoa(cpu), "mode": "nice"}).Set(t.nice)
+		c.cpu.With(prometheus.Labels{"cpu": strconv.Itoa(cpu), "mode": "system"}).Set(t.sys)
+		c.cpu.With(prometheus.Labels{"cpu": strconv.Itoa(cpu), "mode": "interrupt"}).Set(t.intr)
+		c.cpu.With(prometheus.Labels{"cpu": strconv.Itoa(cpu), "mode": "idle"}).Set(t.idle)
 	}
-
-	// Convert C.double array to Go array (https://github.com/golang/go/wiki/cgo#turning-c-arrays-into-go-slices).
-	cpuTimes := (*[maxCPUTimesLen]C.double)(unsafe.Pointer(cpuTimesC))[:cpuTimesLength:cpuTimesLength]
-
-	for cpu := 0; cpu < int(ncpu); cpu++ {
-		base_idx := C.CPUSTATES * cpu
-		c.cpu.With(prometheus.Labels{"cpu": strconv.Itoa(cpu), "mode": "user"}).Set(float64(cpuTimes[base_idx+C.CP_USER]))
-		c.cpu.With(prometheus.Labels{"cpu": strconv.Itoa(cpu), "mode": "nice"}).Set(float64(cpuTimes[base_idx+C.CP_NICE]))
-		c.cpu.With(prometheus.Labels{"cpu": strconv.Itoa(cpu), "mode": "system"}).Set(float64(cpuTimes[base_idx+C.CP_SYS]))
-		c.cpu.With(prometheus.Labels{"cpu": strconv.Itoa(cpu), "mode": "interrupt"}).Set(float64(cpuTimes[base_idx+C.CP_INTR]))
-		c.cpu.With(prometheus.Labels{"cpu": strconv.Itoa(cpu), "mode": "idle"}).Set(float64(cpuTimes[base_idx+C.CP_IDLE]))
-	}
-
 	c.cpu.Collect(ch)
 	return err
 }

collector/filesystem_bsd.go

@@ -11,7 +11,7 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-// +build freebsd openbsd darwin,amd64 dragonfly
+// +build openbsd darwin,amd64 dragonfly
 // +build !nofilesystem
 
 package collector

collector/filesystem_freebsd.go

@@ -0,0 +1,88 @@
+// Copyright 2015 The Prometheus 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.
+
+// +build !nofilesystem
+
+package collector
+
+import (
+	"bytes"
+	"unsafe"
+
+	"github.com/prometheus/common/log"
+	"golang.org/x/sys/unix"
+)
+
+const (
+	defIgnoredMountPoints = "^/(dev)($|/)"
+	defIgnoredFSTypes     = "^devfs$"
+	MNT_RDONLY            = 0x1
+	MNT_NOWAIT            = 0x2
+)
+
+func gostring(b []int8) string {
+	bb := *(*[]byte)(unsafe.Pointer(&b))
+	idx := bytes.IndexByte(bb, 0)
+	if idx < 0 {
+		return ""
+	}
+	return string(bb[:idx])
+}
+
+// Expose filesystem fullness.
+func (c *filesystemCollector) GetStats() (stats []filesystemStats, err error) {
+	buf := make([]unix.Statfs_t, 16)
+	for {
+		n, err := unix.Getfsstat(buf, MNT_NOWAIT)
+		if err != nil {
+			return nil, err
+		}
+		if n < len(buf) {
+			buf = buf[:n]
+			break
+		}
+		buf = make([]unix.Statfs_t, len(buf)*2)
+	}
+	stats = []filesystemStats{}
+	for _, fs := range buf {
+		mountpoint := gostring(fs.Mntonname[:])
+		if c.ignoredMountPointsPattern.MatchString(mountpoint) {
+			log.Debugf("Ignoring mount point: %s", mountpoint)
+			continue
+		}
+
+		device := gostring(fs.Mntfromname[:])
+		fstype := gostring(fs.Fstypename[:])
+		if c.ignoredFSTypesPattern.MatchString(fstype) {
+			log.Debugf("Ignoring fs type: %s", fstype)
+			continue
+		}
+
+		var ro float64
+		if (fs.Flags & MNT_RDONLY) != 0 {
+			ro = 1
+		}
+
+		labelValues := []string{device, mountpoint, fstype}
+		stats = append(stats, filesystemStats{
+			labelValues: labelValues,
+			size:        float64(fs.Blocks) * float64(fs.Bsize),
+			free:        float64(fs.Bfree) * float64(fs.Bsize),
+			avail:       float64(fs.Bavail) * float64(fs.Bsize),
+			files:       float64(fs.Files),
+			filesFree:   float64(fs.Ffree),
+			ro:          ro,
+		})
+	}
+	return stats, nil
+}

collector/loadavg_freebsd.go

@@ -0,0 +1,27 @@
+// +build !noloadavg
+
+package collector
+
+import (
+	"unsafe"
+
+	"golang.org/x/sys/unix"
+)
+
+func getLoad() ([]float64, error) {
+	type loadavg struct {
+		load  [3]uint32
+		scale int
+	}
+	b, err := unix.SysctlRaw("vm.loadavg")
+	if err != nil {
+		return nil, err
+	}
+	load := *(*loadavg)(unsafe.Pointer((&b[0])))
+	scale := float64(load.scale)
+	return []float64{
+		float64(load.load[0]) / scale,
+		float64(load.load[1]) / scale,
+		float64(load.load[2]) / scale,
+	}, nil
+}

collector/loadavg_unix.go

@@ -11,7 +11,7 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-// +build darwin dragonfly freebsd netbsd openbsd solaris
+// +build darwin dragonfly netbsd openbsd solaris
 // +build !noloadavg
 
 package collector

collector/meminfo_bsd.go

@@ -17,30 +17,12 @@
 package collector
 
 import (
-	"errors"
+	"fmt"
 
 	"github.com/prometheus/client_golang/prometheus"
+	"golang.org/x/sys/unix"
 )
 
-/*
-#include <stddef.h>
-#include <sys/sysctl.h>
-
-int _sysctl(const char* name) {
-        int val;
-        size_t size = sizeof(val);
-        int res = sysctlbyname(name, &val, &size, NULL, 0);
-        if (res == -1) {
-                return -1;
-        }
-        if (size != sizeof(val)) {
-                return -2;
-        }
-        return val;
-}
-*/
-import "C"
-
 const (
 	memInfoSubsystem = "memory"
 )
@@ -58,34 +40,20 @@ func NewMeminfoCollector() (Collector, error) {
 }
 
 func (c *meminfoCollector) Update(ch chan<- prometheus.Metric) (err error) {
-	var pages map[string]C.int
+	pages := make(map[string]uint32)
-	pages = make(map[string]C.int)
-
-	size := C._sysctl(C.CString("vm.stats.vm.v_page_size"))
-	if size == -1 {
-		return errors.New("sysctl(vm.stats.vm.v_page_size) failed")
-	}
-	if size == -2 {
-		return errors.New("sysctl(vm.stats.vm.v_page_size) failed, wrong buffer size")
-	}
-
-	pages["active"] = C._sysctl(C.CString("vm.stats.vm.v_active_count"))
-	pages["inactive"] = C._sysctl(C.CString("vm.stats.vm.v_inactive_count"))
-	pages["wire"] = C._sysctl(C.CString("vm.stats.vm.v_wire_count"))
-	pages["cache"] = C._sysctl(C.CString("vm.stats.vm.v_cache_count"))
-	pages["free"] = C._sysctl(C.CString("vm.stats.vm.v_free_count"))
-	pages["swappgsin"] = C._sysctl(C.CString("vm.stats.vm.v_swappgsin"))
-	pages["swappgsout"] = C._sysctl(C.CString("vm.stats.vm.v_swappgsout"))
-	pages["total"] = C._sysctl(C.CString("vm.stats.vm.v_page_count"))
 
-	for key := range pages {
+	size, err := unix.SysctlUint32("vm.stats.vm.v_page_size")
-		if pages[key] == -1 {
+	if err != nil {
-			return errors.New("sysctl() failed for " + key)
+		return fmt.Errorf("sysctl(vm.stats.vm.v_page_size) failed: %s", err)
-		}
-		if pages[key] == -2 {
-			return errors.New("sysctl() failed for " + key + ", wrong buffer size")
-		}
 	}
+	pages["active"], _ = unix.SysctlUint32("vm.stats.vm.v_active_count")
+	pages["inactive"], _ = unix.SysctlUint32("vm.stats.vm.v_inactive_count")
+	pages["wire"], _ = unix.SysctlUint32("vm.stats.vm.v_wire_count")
+	pages["cache"], _ = unix.SysctlUint32("vm.stats.vm.v_cache_count")
+	pages["free"], _ = unix.SysctlUint32("vm.stats.vm.v_free_count")
+	pages["swappgsin"], _ = unix.SysctlUint32("vm.stats.vm.v_swappgsin")
+	pages["swappgsout"], _ = unix.SysctlUint32("vm.stats.vm.v_swappgsout")
+	pages["total"], _ = unix.SysctlUint32("vm.stats.vm.v_page_count")
 
 	for k, v := range pages {
 		ch <- prometheus.MustNewConstMetric(