Fix some nil pointer reference errors

internal/status/disk.go

@@ -106,22 +106,32 @@ func HandleInodes(cv config.Values) interface{} {
 func getDisks(units string) ([]Disk, error) {
 	var disks []Disk
 	d, err := disk.Partitions(true)
-	if err != nil || d == nil {
+	if err != nil {
 		return disks, err
 	}
 	for _, i := range d {
 		if !config.Contains(config.Settings.ExcludeFsTypes, i.Fstype) {
-			u, _ := disk.Usage(i.Mountpoint)
-			disks = append(disks, Disk{
+			u, err := disk.Usage(i.Mountpoint)
+			if err != nil {
+				config.LogDebug(err)
+			}
+			d := Disk{
 				Path:        i.Mountpoint,
 				Device:      i.Device,
 				Fstype:      i.Fstype,
-				Total:       ConvertToUnit(u.Total, units),
-				Free:        ConvertToUnit(u.Free, units),
-				Used:        ConvertToUnit(u.Used, units),
-				UsedPercent: u.UsedPercent,
+				Total:       0,
+				Free:        0,
+				Used:        0,
+				UsedPercent: 0,
 				Units:       units,
-			})
+			}
+			if u != nil {
+				d.Total = ConvertToUnit(u.Total, units)
+				d.Free = ConvertToUnit(u.Free, units)
+				d.Used = ConvertToUnit(u.Used, units)
+				d.UsedPercent = u.UsedPercent
+			}
+			disks = append(disks, d)
 		}
 	}
 	return disks, nil
@@ -130,21 +140,31 @@ func getDisks(units string) ([]Disk, error) {
 func getDisksInodes(units string) ([]Inodes, error) {
 	var inodes []Inodes
 	d, err := disk.Partitions(true)
-	if err != nil || d == nil {
+	if err != nil {
 		return inodes, err
 	}
 	for _, i := range d {
 		if !config.Contains(config.Settings.ExcludeFsTypes, i.Fstype) {
-			u, _ := disk.Usage(i.Mountpoint)
-			inodes = append(inodes, Inodes{
+			u, err := disk.Usage(i.Mountpoint)
+			if err != nil {
+				config.LogDebug(err)
+			}
+			n := Inodes{
 				Path:        i.Mountpoint,
 				Device:      i.Device,
 				Fstype:      i.Fstype,
-				Total:       float64(u.InodesTotal),
-				Free:        float64(u.InodesFree),
-				Used:        float64(u.InodesUsed),
-				UsedPercent: u.InodesUsedPercent,
-			})
+				Total:       0,
+				Free:        0,
+				Used:        0,
+				UsedPercent: 0,
+			}
+			if u != nil {
+				n.Total = float64(u.InodesTotal)
+				n.Free = float64(u.InodesFree)
+				n.Used = float64(u.InodesUsed)
+				n.UsedPercent = u.InodesUsedPercent
+			}
+			inodes = append(inodes, n)
 		}
 	}
 	return inodes, nil

internal/status/memory.go

@@ -74,42 +74,49 @@ func (s SwapStatus) PerfData(warn, crit string) string {
 func HandleMemory(cv config.Values) interface{} {
 	data, err := memoryUsage(cv.Units())
 	if err != nil {
-		return MemoryStatus{}
+		config.Log.Error(err)
 	}
 	return data
 }
 
 func HandleSwap(cv config.Values) interface{} {
 	data, err := swapUsage(cv.Units())
 	if err != nil {
-		return SwapStatus{}
+		config.Log.Error(err)
 	}
 	return data
 }
 
 func memoryUsage(units string) (MemoryStatus, error) {
+	m := MemoryStatus{}
 	v, err := mem.VirtualMemory()
-	// usedPercent is rounded for some reason, so we are
-	// calculating that ourselves which is just used/total*100
-	mem := MemoryStatus{
-		Total:       ConvertToUnit(v.Total, units),
-		Available:   ConvertToUnit(v.Available, units),
-		Used:        ConvertToUnit(v.Used, units),
-		Free:        ConvertToUnit(v.Free, units),
-		UsedPercent: (float64(v.Used) / float64(v.Total) * 100),
-		Units:       units,
+
+	m.Units = units
+	if v != nil {
+		m.Total = ConvertToUnit(v.Total, units)
+		m.Available = ConvertToUnit(v.Available, units)
+		m.Used = ConvertToUnit(v.Used, units)
+		m.Free = ConvertToUnit(v.Free, units)
+
+		// usedPercent is rounded for some reason, so we are
+		// calculating that ourselves which is just used/total*100
+		m.UsedPercent = (float64(v.Used) / float64(v.Total) * 100)
 	}
-	return mem, err
+
+	return m, err
 }
 
 func swapUsage(units string) (SwapStatus, error) {
+	ss := SwapStatus{}
 	s, err := mem.SwapMemory()
-	swap := SwapStatus{
-		Total:       ConvertToUnit(s.Total, units),
-		Used:        ConvertToUnit(s.Used, units),
-		Free:        ConvertToUnit(s.Free, units),
-		UsedPercent: s.UsedPercent,
-		Units:       units,
+
+	ss.Units = units
+	if s != nil {
+		ss.Total = ConvertToUnit(s.Total, units)
+		ss.Used = ConvertToUnit(s.Used, units)
+		ss.Free = ConvertToUnit(s.Free, units)
+		ss.UsedPercent = s.UsedPercent
 	}
-	return swap, err
+
+	return ss, err
 }

internal/status/processes.go

@@ -40,10 +40,10 @@ func (p ProcessList) PerfData(warn, crit string) string {
 }
 
 func HandleProcesses(cv config.Values) interface{} {
-	var procs []Process
+	procs := []Process{}
 	data, err := process.Processes()
-	if err != nil {
-		return []Process{}
+	if err != nil || data == nil {
+		return procs
 	}
 
 	for _, p := range data {