VictoriaMetrics/vendor/github.com/prometheus/procfs/meminfo.go

390 lines
12 KiB
Go
Raw Normal View History

// Copyright 2019 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.
package procfs
import (
"bufio"
"bytes"
"fmt"
"io"
"strconv"
"strings"
"github.com/prometheus/procfs/internal/util"
)
// Meminfo represents memory statistics.
type Meminfo struct {
// Total usable ram (i.e. physical ram minus a few reserved
// bits and the kernel binary code)
2021-02-01 18:39:00 +01:00
MemTotal *uint64
// The sum of LowFree+HighFree
2021-02-01 18:39:00 +01:00
MemFree *uint64
// An estimate of how much memory is available for starting
// new applications, without swapping. Calculated from
// MemFree, SReclaimable, the size of the file LRU lists, and
// the low watermarks in each zone. The estimate takes into
// account that the system needs some page cache to function
// well, and that not all reclaimable slab will be
// reclaimable, due to items being in use. The impact of those
// factors will vary from system to system.
2021-02-01 18:39:00 +01:00
MemAvailable *uint64
// Relatively temporary storage for raw disk blocks shouldn't
// get tremendously large (20MB or so)
2021-02-01 18:39:00 +01:00
Buffers *uint64
Cached *uint64
// Memory that once was swapped out, is swapped back in but
// still also is in the swapfile (if memory is needed it
// doesn't need to be swapped out AGAIN because it is already
// in the swapfile. This saves I/O)
2021-02-01 18:39:00 +01:00
SwapCached *uint64
// Memory that has been used more recently and usually not
// reclaimed unless absolutely necessary.
2021-02-01 18:39:00 +01:00
Active *uint64
// Memory which has been less recently used. It is more
// eligible to be reclaimed for other purposes
2021-02-01 18:39:00 +01:00
Inactive *uint64
ActiveAnon *uint64
InactiveAnon *uint64
ActiveFile *uint64
InactiveFile *uint64
Unevictable *uint64
Mlocked *uint64
// total amount of swap space available
2021-02-01 18:39:00 +01:00
SwapTotal *uint64
// Memory which has been evicted from RAM, and is temporarily
// on the disk
2021-02-01 18:39:00 +01:00
SwapFree *uint64
// Memory which is waiting to get written back to the disk
2021-02-01 18:39:00 +01:00
Dirty *uint64
// Memory which is actively being written back to the disk
2021-02-01 18:39:00 +01:00
Writeback *uint64
// Non-file backed pages mapped into userspace page tables
2021-02-01 18:39:00 +01:00
AnonPages *uint64
// files which have been mapped, such as libraries
2021-02-01 18:39:00 +01:00
Mapped *uint64
Shmem *uint64
// in-kernel data structures cache
2021-02-01 18:39:00 +01:00
Slab *uint64
// Part of Slab, that might be reclaimed, such as caches
2021-02-01 18:39:00 +01:00
SReclaimable *uint64
// Part of Slab, that cannot be reclaimed on memory pressure
2021-02-01 18:39:00 +01:00
SUnreclaim *uint64
KernelStack *uint64
// amount of memory dedicated to the lowest level of page
// tables.
2021-02-01 18:39:00 +01:00
PageTables *uint64
// NFS pages sent to the server, but not yet committed to
// stable storage
2021-02-01 18:39:00 +01:00
NFSUnstable *uint64
// Memory used for block device "bounce buffers"
2021-02-01 18:39:00 +01:00
Bounce *uint64
// Memory used by FUSE for temporary writeback buffers
2021-02-01 18:39:00 +01:00
WritebackTmp *uint64
// Based on the overcommit ratio ('vm.overcommit_ratio'),
// this is the total amount of memory currently available to
// be allocated on the system. This limit is only adhered to
// if strict overcommit accounting is enabled (mode 2 in
// 'vm.overcommit_memory').
// The CommitLimit is calculated with the following formula:
// CommitLimit = ([total RAM pages] - [total huge TLB pages]) *
// overcommit_ratio / 100 + [total swap pages]
// For example, on a system with 1G of physical RAM and 7G
// of swap with a `vm.overcommit_ratio` of 30 it would
// yield a CommitLimit of 7.3G.
// For more details, see the memory overcommit documentation
// in vm/overcommit-accounting.
2021-02-01 18:39:00 +01:00
CommitLimit *uint64
// The amount of memory presently allocated on the system.
// The committed memory is a sum of all of the memory which
// has been allocated by processes, even if it has not been
// "used" by them as of yet. A process which malloc()'s 1G
// of memory, but only touches 300M of it will show up as
// using 1G. This 1G is memory which has been "committed" to
// by the VM and can be used at any time by the allocating
// application. With strict overcommit enabled on the system
// (mode 2 in 'vm.overcommit_memory'),allocations which would
// exceed the CommitLimit (detailed above) will not be permitted.
// This is useful if one needs to guarantee that processes will
// not fail due to lack of memory once that memory has been
// successfully allocated.
2021-02-01 18:39:00 +01:00
CommittedAS *uint64
// total size of vmalloc memory area
2021-02-01 18:39:00 +01:00
VmallocTotal *uint64
// amount of vmalloc area which is used
2021-02-01 18:39:00 +01:00
VmallocUsed *uint64
// largest contiguous block of vmalloc area which is free
2021-02-01 18:39:00 +01:00
VmallocChunk *uint64
2024-03-17 23:51:41 +01:00
Percpu *uint64
2021-02-01 18:39:00 +01:00
HardwareCorrupted *uint64
AnonHugePages *uint64
ShmemHugePages *uint64
ShmemPmdMapped *uint64
CmaTotal *uint64
CmaFree *uint64
HugePagesTotal *uint64
HugePagesFree *uint64
HugePagesRsvd *uint64
HugePagesSurp *uint64
Hugepagesize *uint64
DirectMap4k *uint64
DirectMap2M *uint64
DirectMap1G *uint64
2024-03-17 23:51:41 +01:00
// The struct fields below are the byte-normalized counterparts to the
// existing struct fields. Values are normalized using the optional
// unit field in the meminfo line.
MemTotalBytes *uint64
MemFreeBytes *uint64
MemAvailableBytes *uint64
BuffersBytes *uint64
CachedBytes *uint64
SwapCachedBytes *uint64
ActiveBytes *uint64
InactiveBytes *uint64
ActiveAnonBytes *uint64
InactiveAnonBytes *uint64
ActiveFileBytes *uint64
InactiveFileBytes *uint64
UnevictableBytes *uint64
MlockedBytes *uint64
SwapTotalBytes *uint64
SwapFreeBytes *uint64
DirtyBytes *uint64
WritebackBytes *uint64
AnonPagesBytes *uint64
MappedBytes *uint64
ShmemBytes *uint64
SlabBytes *uint64
SReclaimableBytes *uint64
SUnreclaimBytes *uint64
KernelStackBytes *uint64
PageTablesBytes *uint64
NFSUnstableBytes *uint64
BounceBytes *uint64
WritebackTmpBytes *uint64
CommitLimitBytes *uint64
CommittedASBytes *uint64
VmallocTotalBytes *uint64
VmallocUsedBytes *uint64
VmallocChunkBytes *uint64
PercpuBytes *uint64
HardwareCorruptedBytes *uint64
AnonHugePagesBytes *uint64
ShmemHugePagesBytes *uint64
ShmemPmdMappedBytes *uint64
CmaTotalBytes *uint64
CmaFreeBytes *uint64
HugepagesizeBytes *uint64
DirectMap4kBytes *uint64
DirectMap2MBytes *uint64
DirectMap1GBytes *uint64
}
// Meminfo returns an information about current kernel/system memory statistics.
// See https://www.kernel.org/doc/Documentation/filesystems/proc.txt
func (fs FS) Meminfo() (Meminfo, error) {
b, err := util.ReadFileNoStat(fs.proc.Path("meminfo"))
if err != nil {
return Meminfo{}, err
}
m, err := parseMemInfo(bytes.NewReader(b))
if err != nil {
2023-07-07 09:04:32 +02:00
return Meminfo{}, fmt.Errorf("%s: %w", ErrFileParse, err)
}
return *m, nil
}
func parseMemInfo(r io.Reader) (*Meminfo, error) {
var m Meminfo
s := bufio.NewScanner(r)
for s.Scan() {
fields := strings.Fields(s.Text())
2024-03-17 23:51:41 +01:00
var val, valBytes uint64
2024-03-17 23:51:41 +01:00
val, err := strconv.ParseUint(fields[1], 0, 64)
if err != nil {
return nil, err
}
2024-03-17 23:51:41 +01:00
switch len(fields) {
case 2:
// No unit present, use the parsed the value as bytes directly.
valBytes = val
case 3:
// Unit present in optional 3rd field, convert it to
// bytes. The only unit supported within the Linux
// kernel is `kB`.
if fields[2] != "kB" {
return nil, fmt.Errorf("%w: Unsupported unit in optional 3rd field %q", ErrFileParse, fields[2])
}
valBytes = 1024 * val
default:
return nil, fmt.Errorf("%w: Malformed line %q", ErrFileParse, s.Text())
}
switch fields[0] {
case "MemTotal:":
2024-03-17 23:51:41 +01:00
m.MemTotal = &val
m.MemTotalBytes = &valBytes
case "MemFree:":
2024-03-17 23:51:41 +01:00
m.MemFree = &val
m.MemFreeBytes = &valBytes
case "MemAvailable:":
2024-03-17 23:51:41 +01:00
m.MemAvailable = &val
m.MemAvailableBytes = &valBytes
case "Buffers:":
2024-03-17 23:51:41 +01:00
m.Buffers = &val
m.BuffersBytes = &valBytes
case "Cached:":
2024-03-17 23:51:41 +01:00
m.Cached = &val
m.CachedBytes = &valBytes
case "SwapCached:":
2024-03-17 23:51:41 +01:00
m.SwapCached = &val
m.SwapCachedBytes = &valBytes
case "Active:":
2024-03-17 23:51:41 +01:00
m.Active = &val
m.ActiveBytes = &valBytes
case "Inactive:":
2024-03-17 23:51:41 +01:00
m.Inactive = &val
m.InactiveBytes = &valBytes
case "Active(anon):":
2024-03-17 23:51:41 +01:00
m.ActiveAnon = &val
m.ActiveAnonBytes = &valBytes
case "Inactive(anon):":
2024-03-17 23:51:41 +01:00
m.InactiveAnon = &val
m.InactiveAnonBytes = &valBytes
case "Active(file):":
2024-03-17 23:51:41 +01:00
m.ActiveFile = &val
m.ActiveFileBytes = &valBytes
case "Inactive(file):":
2024-03-17 23:51:41 +01:00
m.InactiveFile = &val
m.InactiveFileBytes = &valBytes
case "Unevictable:":
2024-03-17 23:51:41 +01:00
m.Unevictable = &val
m.UnevictableBytes = &valBytes
case "Mlocked:":
2024-03-17 23:51:41 +01:00
m.Mlocked = &val
m.MlockedBytes = &valBytes
case "SwapTotal:":
2024-03-17 23:51:41 +01:00
m.SwapTotal = &val
m.SwapTotalBytes = &valBytes
case "SwapFree:":
2024-03-17 23:51:41 +01:00
m.SwapFree = &val
m.SwapFreeBytes = &valBytes
case "Dirty:":
2024-03-17 23:51:41 +01:00
m.Dirty = &val
m.DirtyBytes = &valBytes
case "Writeback:":
2024-03-17 23:51:41 +01:00
m.Writeback = &val
m.WritebackBytes = &valBytes
case "AnonPages:":
2024-03-17 23:51:41 +01:00
m.AnonPages = &val
m.AnonPagesBytes = &valBytes
case "Mapped:":
2024-03-17 23:51:41 +01:00
m.Mapped = &val
m.MappedBytes = &valBytes
case "Shmem:":
2024-03-17 23:51:41 +01:00
m.Shmem = &val
m.ShmemBytes = &valBytes
case "Slab:":
2024-03-17 23:51:41 +01:00
m.Slab = &val
m.SlabBytes = &valBytes
case "SReclaimable:":
2024-03-17 23:51:41 +01:00
m.SReclaimable = &val
m.SReclaimableBytes = &valBytes
case "SUnreclaim:":
2024-03-17 23:51:41 +01:00
m.SUnreclaim = &val
m.SUnreclaimBytes = &valBytes
case "KernelStack:":
2024-03-17 23:51:41 +01:00
m.KernelStack = &val
m.KernelStackBytes = &valBytes
case "PageTables:":
2024-03-17 23:51:41 +01:00
m.PageTables = &val
m.PageTablesBytes = &valBytes
case "NFS_Unstable:":
2024-03-17 23:51:41 +01:00
m.NFSUnstable = &val
m.NFSUnstableBytes = &valBytes
case "Bounce:":
2024-03-17 23:51:41 +01:00
m.Bounce = &val
m.BounceBytes = &valBytes
case "WritebackTmp:":
2024-03-17 23:51:41 +01:00
m.WritebackTmp = &val
m.WritebackTmpBytes = &valBytes
case "CommitLimit:":
2024-03-17 23:51:41 +01:00
m.CommitLimit = &val
m.CommitLimitBytes = &valBytes
case "Committed_AS:":
2024-03-17 23:51:41 +01:00
m.CommittedAS = &val
m.CommittedASBytes = &valBytes
case "VmallocTotal:":
2024-03-17 23:51:41 +01:00
m.VmallocTotal = &val
m.VmallocTotalBytes = &valBytes
case "VmallocUsed:":
2024-03-17 23:51:41 +01:00
m.VmallocUsed = &val
m.VmallocUsedBytes = &valBytes
case "VmallocChunk:":
2024-03-17 23:51:41 +01:00
m.VmallocChunk = &val
m.VmallocChunkBytes = &valBytes
case "Percpu:":
m.Percpu = &val
m.PercpuBytes = &valBytes
case "HardwareCorrupted:":
2024-03-17 23:51:41 +01:00
m.HardwareCorrupted = &val
m.HardwareCorruptedBytes = &valBytes
case "AnonHugePages:":
2024-03-17 23:51:41 +01:00
m.AnonHugePages = &val
m.AnonHugePagesBytes = &valBytes
case "ShmemHugePages:":
2024-03-17 23:51:41 +01:00
m.ShmemHugePages = &val
m.ShmemHugePagesBytes = &valBytes
case "ShmemPmdMapped:":
2024-03-17 23:51:41 +01:00
m.ShmemPmdMapped = &val
m.ShmemPmdMappedBytes = &valBytes
case "CmaTotal:":
2024-03-17 23:51:41 +01:00
m.CmaTotal = &val
m.CmaTotalBytes = &valBytes
case "CmaFree:":
2024-03-17 23:51:41 +01:00
m.CmaFree = &val
m.CmaFreeBytes = &valBytes
case "HugePages_Total:":
2024-03-17 23:51:41 +01:00
m.HugePagesTotal = &val
case "HugePages_Free:":
2024-03-17 23:51:41 +01:00
m.HugePagesFree = &val
case "HugePages_Rsvd:":
2024-03-17 23:51:41 +01:00
m.HugePagesRsvd = &val
case "HugePages_Surp:":
2024-03-17 23:51:41 +01:00
m.HugePagesSurp = &val
case "Hugepagesize:":
2024-03-17 23:51:41 +01:00
m.Hugepagesize = &val
m.HugepagesizeBytes = &valBytes
case "DirectMap4k:":
2024-03-17 23:51:41 +01:00
m.DirectMap4k = &val
m.DirectMap4kBytes = &valBytes
case "DirectMap2M:":
2024-03-17 23:51:41 +01:00
m.DirectMap2M = &val
m.DirectMap2MBytes = &valBytes
case "DirectMap1G:":
2024-03-17 23:51:41 +01:00
m.DirectMap1G = &val
m.DirectMap1GBytes = &valBytes
}
}
return &m, nil
}