// Get information about system memory. func Get() (Memory, error) { m := Memory{} o, err := common.LoadFileFields("/proc/meminfo", ":", []string{ "MemTotal", }) if err != nil { return Memory{}, err } m.TotalGB, err = strconv.Atoi(strings.TrimRight(o["MemTotal"], " kB")) if err != nil { return Memory{}, err } m.TotalGB = m.TotalGB / 1024 / 1024 return m, nil }
func (m *memory) ForceUpdate() error { m.cache.LastUpdated = time.Now() m.cache.FromCache = false o, err := common.LoadFileFields("/proc/meminfo", ":", []string{ "MemTotal", "MemFree", "MemAvailable", "Buffers", "Cached", "SwapCached", "Active", "Inactive", "Active(anon)", "Inactive(anon)", "Active(file)", "Inactive(file)", "Unevictable", "Mlocked", "SwapTotal", "SwapFree", "Dirty", "Writeback", "AnonPages", "Mapped", "Shmem", "Slab", "SReclaimable", "SUnreclaim", "KernelStack", "PageTables", "NFS_Unstable", "Bounce", "WritebackTmp", "CommitLimit", "Committed_AS", "VmallocTotal", "VmallocUsed", "VmallocChunk", "HardwareCorrupted", "AnonHugePages", "HugePages_Total", "HugePages_Free", "HugePages_Rsvd", "HugePages_Surp", "Hugepagesize", "DirectMap4k", "DirectMap2M", "DirectMap1G", }) if err != nil { return err } // MemTotal m.data.TotalKB, err = strconv.Atoi(strings.TrimRight(o["MemTotal"], " kB")) if err != nil { return fmt.Errorf("failed parsing field: %s error: %s", "MemTotal", err.Error()) } m.data.TotalGB = m.data.TotalKB / 1024 / 1024 // MemFree m.data.FreeKB, err = strconv.Atoi(strings.TrimRight(o["MemFree"], " kB")) if err != nil { return fmt.Errorf("failed parsing field: %s error: %s", "MemFree", err.Error()) } m.data.FreeGB = m.data.FreeKB / 1024 / 1024 // MemAvailable m.data.AvailableKB, err = strconv.Atoi(strings.TrimRight(o["MemAvailable"], " kB")) if err != nil { return fmt.Errorf("failed parsing field: %s error: %s", "MemAvailable", err.Error()) } m.data.AvailableGB = m.data.AvailableKB / 1024 / 1024 // Buffers m.data.BuffersKB, err = strconv.Atoi(strings.TrimRight(o["Buffers"], " kB")) if err != nil { return fmt.Errorf("failed parsing field: %s error: %s", "Buffers", err.Error()) } m.data.BuffersGB = m.data.BuffersKB / 1024 / 1024 // Cached m.data.CachedKB, err = strconv.Atoi(strings.TrimRight(o["Cached"], " kB")) if err != nil { return fmt.Errorf("failed parsing field: %s error: %s", "Cached", err.Error()) } m.data.CachedGB = m.data.CachedKB / 1024 / 1024 // SwapCached m.data.SwapCachedKB, err = strconv.Atoi(strings.TrimRight(o["SwapCached"], " kB")) if err != nil { return fmt.Errorf("failed parsing field: %s error: %s", "SwapCached", err.Error()) } m.data.SwapCachedGB = m.data.SwapCachedKB / 1024 / 1024 // Active m.data.ActiveKB, err = strconv.Atoi(strings.TrimRight(o["Active"], " kB")) if err != nil { return fmt.Errorf("failed parsing field: %s error: %s", "Active", err.Error()) } m.data.ActiveGB = m.data.ActiveKB / 1024 / 1024 // Inactive m.data.InactiveKB, err = strconv.Atoi(strings.TrimRight(o["Inactive"], " kB")) if err != nil { return fmt.Errorf("failed parsing field: %s error: %s", "Inactive", err.Error()) } m.data.InactiveGB = m.data.InactiveKB / 1024 / 1024 // Active(anon) m.data.ActiveAnonKB, err = strconv.Atoi(strings.TrimRight(o["Active(anon)"], " kB")) if err != nil { return fmt.Errorf("failed parsing field: %s error: %s", "Active(anon)", err.Error()) } m.data.ActiveAnonGB = m.data.ActiveAnonKB / 1024 / 1024 // Inactive(anon) m.data.InactiveAnonKB, err = strconv.Atoi(strings.TrimRight(o["Inactive(anon)"], " kB")) if err != nil { return fmt.Errorf("failed parsing field: %s error: %s", "Inactive(anon)", err.Error()) } m.data.InactiveAnonGB = m.data.InactiveAnonKB / 1024 / 1024 // Active(file) m.data.ActiveFileKB, err = strconv.Atoi(strings.TrimRight(o["Active(file)"], " kB")) if err != nil { return fmt.Errorf("failed parsing field: %s error: %s", "Active(file)", err.Error()) } m.data.ActiveFileGB = m.data.ActiveFileKB / 1024 / 1024 // Inactive(file) m.data.InactiveFileKB, err = strconv.Atoi(strings.TrimRight(o["Inactive(file)"], " kB")) if err != nil { return fmt.Errorf("failed parsing field: %s error: %s", "Inactive(file)", err.Error()) } m.data.InactiveFileGB = m.data.InactiveFileKB / 1024 / 1024 // Unevictable m.data.UnevictableKB, err = strconv.Atoi(strings.TrimRight(o["Unevictable"], " kB")) if err != nil { return fmt.Errorf("failed parsing field: %s error: %s", "Unevictable", err.Error()) } m.data.UnevictableGB = m.data.UnevictableKB / 1024 / 1024 // Mlocked m.data.MLockedKB, err = strconv.Atoi(strings.TrimRight(o["Mlocked"], " kB")) if err != nil { return fmt.Errorf("failed parsing field: %s error: %s", "Mlocked", err.Error()) } m.data.MLockedGB = m.data.MLockedKB / 1024 / 1024 // SwapTotal m.data.SwapTotalKB, err = strconv.Atoi(strings.TrimRight(o["SwapTotal"], " kB")) if err != nil { return fmt.Errorf("failed parsing field: %s error: %s", "SwapTotal", err.Error()) } m.data.SwapTotalGB = m.data.SwapTotalKB / 1024 / 1024 // SwapFree m.data.SwapFreeKB, err = strconv.Atoi(strings.TrimRight(o["SwapFree"], " kB")) if err != nil { return fmt.Errorf("failed parsing field: %s error: %s", "SwapFree", err.Error()) } m.data.SwapFreeGB = m.data.SwapFreeKB / 1024 / 1024 // Dirty m.data.DirtyKB, err = strconv.Atoi(strings.TrimRight(o["Dirty"], " kB")) if err != nil { return fmt.Errorf("failed parsing field: %s error: %s", "Dirty", err.Error()) } m.data.DirtyGB = m.data.DirtyKB / 1024 / 1024 // Writeback m.data.WritebackKB, err = strconv.Atoi(strings.TrimRight(o["Writeback"], " kB")) if err != nil { return fmt.Errorf("failed parsing field: %s error: %s", "Writeback", err.Error()) } m.data.WritebackGB = m.data.WritebackKB / 1024 / 1024 // AnonPages m.data.AnonPagesKB, err = strconv.Atoi(strings.TrimRight(o["AnonPages"], " kB")) if err != nil { return fmt.Errorf("failed parsing field: %s error: %s", "AnonPages", err.Error()) } m.data.AnonPagesGB = m.data.AnonPagesKB / 1024 / 1024 // Mapped m.data.MappedKB, err = strconv.Atoi(strings.TrimRight(o["Mapped"], " kB")) if err != nil { return fmt.Errorf("failed parsing field: %s error: %s", "Mapped", err.Error()) } m.data.MappedGB = m.data.MappedKB / 1024 / 1024 // Shmem m.data.ShmemKB, err = strconv.Atoi(strings.TrimRight(o["Shmem"], " kB")) if err != nil { return fmt.Errorf("failed parsing field: %s error: %s", "Shmem", err.Error()) } m.data.ShmemGB = m.data.ShmemKB / 1024 / 1024 // Slab m.data.SlabKB, err = strconv.Atoi(strings.TrimRight(o["Slab"], " kB")) if err != nil { return fmt.Errorf("failed parsing field: %s error: %s", "Slab", err.Error()) } m.data.SlabGB = m.data.SlabKB / 1024 / 1024 // SReclaimable m.data.SReclaimableKB, err = strconv.Atoi(strings.TrimRight(o["SReclaimable"], " kB")) if err != nil { return fmt.Errorf("failed parsing field: %s error: %s", "SReclaimable", err.Error()) } m.data.SReclaimableGB = m.data.SReclaimableKB / 1024 / 1024 // SUnreclaim m.data.SUnreclaimKB, err = strconv.Atoi(strings.TrimRight(o["SUnreclaim"], " kB")) if err != nil { return fmt.Errorf("failed parsing field: %s error: %s", "SUnreclaim", err.Error()) } m.data.SUnreclaimGB = m.data.SUnreclaimKB / 1024 / 1024 // KernelStack m.data.KernelStackKB, err = strconv.Atoi(strings.TrimRight(o["KernelStack"], " kB")) if err != nil { return fmt.Errorf("failed parsing field: %s error: %s", "KernelStack", err.Error()) } m.data.KernelStackGB = m.data.KernelStackKB / 1024 / 1024 // PageTables m.data.PageTablesKB, err = strconv.Atoi(strings.TrimRight(o["PageTables"], " kB")) if err != nil { return fmt.Errorf("failed parsing field: %s error: %s", "PageTables", err.Error()) } m.data.PageTablesGB = m.data.PageTablesKB / 1024 / 1024 // NFS_Unstable m.data.NFSUnstableKB, err = strconv.Atoi(strings.TrimRight(o["NFS_Unstable"], " kB")) if err != nil { return fmt.Errorf("failed parsing field: %s error: %s", "NFS_Unstable", err.Error()) } m.data.NFSUnstableGB = m.data.NFSUnstableKB / 1024 / 1024 // Bounce m.data.BounceKB, err = strconv.Atoi(strings.TrimRight(o["Bounce"], " kB")) if err != nil { return fmt.Errorf("failed parsing field: %s error: %s", "Bounce", err.Error()) } m.data.BounceGB = m.data.BounceKB / 1024 / 1024 // WritebackTmp m.data.WritebackTmpKB, err = strconv.Atoi(strings.TrimRight(o["WritebackTmp"], " kB")) if err != nil { return fmt.Errorf("failed parsing field: %s error: %s", "WritebackTmp", err.Error()) } m.data.WritebackTmpGB = m.data.WritebackTmpKB / 1024 / 1024 // CommitLimit m.data.CommitLimitKB, err = strconv.Atoi(strings.TrimRight(o["CommitLimit"], " kB")) if err != nil { return fmt.Errorf("failed parsing field: %s error: %s", "CommitLimit", err.Error()) } m.data.CommitLimitGB = m.data.CommitLimitKB / 1024 / 1024 // Committed_AS m.data.CommittedASKB, err = strconv.Atoi(strings.TrimRight(o["Committed_AS"], " kB")) if err != nil { return fmt.Errorf("failed parsing field: %s error: %s", "Committed_AS", err.Error()) } m.data.CommittedASGB = m.data.CommittedASKB / 1024 / 1024 // VmallocTotal m.data.VmallocTotalKB, err = strconv.Atoi(strings.TrimRight(o["VmallocTotal"], " kB")) if err != nil { return fmt.Errorf("failed parsing field: %s error: %s", "VmallocTotal", err.Error()) } m.data.VmallocTotalGB = m.data.VmallocTotalKB / 1024 / 1024 // VmallocUsed m.data.VmallocUsedKB, err = strconv.Atoi(strings.TrimRight(o["VmallocUsed"], " kB")) if err != nil { return fmt.Errorf("failed parsing field: %s error: %s", "VmallocUsed", err.Error()) } m.data.VmallocUsedGB = m.data.VmallocUsedKB / 1024 / 1024 // VmallocChunk m.data.VmallocChunkKB, err = strconv.Atoi(strings.TrimRight(o["VmallocChunk"], " kB")) if err != nil { return fmt.Errorf("failed parsing field: %s error: %s", "VmallocChunk", err.Error()) } m.data.VmallocChunkGB = m.data.VmallocChunkKB / 1024 / 1024 // HardwareCorrupted m.data.HardwareCorruptedKB, err = strconv.Atoi(strings.TrimRight(o["HardwareCorrupted"], " kB")) if err != nil { return fmt.Errorf("failed parsing field: %s error: %s", "HardwareCorrupted", err.Error()) } m.data.HardwareCorruptedGB = m.data.HardwareCorruptedKB / 1024 / 1024 // AnonHugePages m.data.AnonHugePagesKB, err = strconv.Atoi(strings.TrimRight(o["AnonHugePages"], " kB")) if err != nil { return fmt.Errorf("failed parsing field: %s error: %s", "AnonHugePages", err.Error()) } m.data.AnonHugePagesGB = m.data.AnonHugePagesKB / 1024 / 1024 // HugePages_Total m.data.HugePagesTot, err = strconv.Atoi(o["HugePages_Total"]) if err != nil { return fmt.Errorf("failed parsing field: %s error: %s", "HugePages_Total", err.Error()) } // HugePages_Free m.data.HugePagesFree, err = strconv.Atoi(o["HugePages_Free"]) if err != nil { return fmt.Errorf("failed parsing field: %s error: %s", "HugePages_Free", err.Error()) } // HugePages_Rsvd m.data.HugePagesRsvd, err = strconv.Atoi(o["HugePages_Rsvd"]) if err != nil { return fmt.Errorf("failed parsing field: %s error: %s", "HugePages_Rsvd", err.Error()) } // Hugepagesize m.data.HugePageSizeKB, err = strconv.Atoi(strings.TrimRight(o["Hugepagesize"], " kB")) if err != nil { return fmt.Errorf("failed parsing field: %s error: %s", "Hugepagesize", err.Error()) } // DirectMap4k m.data.DirectMap4kKB, err = strconv.Atoi(strings.TrimRight(o["DirectMap4k"], " kB")) if err != nil { return fmt.Errorf("failed parsing field: %s error: %s", "DirectMap4k", err.Error()) } // DirectMap2M m.data.DirectMap2MKB, err = strconv.Atoi(strings.TrimRight(o["DirectMap2M"], " kB")) if err != nil { return fmt.Errorf("failed parsing field: %s error: %s", "DirectMap2M", err.Error()) } // DirectMap1G m.data.DirectMap1GKB, err = strconv.Atoi(strings.TrimRight(o["DirectMap1G"], " kB")) if err != nil { return fmt.Errorf("failed parsing field: %s error: %s", "DirectMap1G", err.Error()) } return nil }