vendor/github.com/prometheus/procfs/meminfo.go - voltha-go - Gitiles

 // 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)
 	MemTotal *uint64
 	// The sum of LowFree+HighFree
 	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.
 	MemAvailable *uint64
 	// Relatively temporary storage for raw disk blocks shouldn't
 	// get tremendously large (20MB or so)
 	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)
 	SwapCached *uint64
 	// Memory that has been used more recently and usually not
 	// reclaimed unless absolutely necessary.
 	Active *uint64
 	// Memory which has been less recently used.  It is more
 	// eligible to be reclaimed for other purposes
 	Inactive     *uint64
 	ActiveAnon   *uint64
 	InactiveAnon *uint64
 	ActiveFile   *uint64
 	InactiveFile *uint64
 	Unevictable  *uint64
 	Mlocked      *uint64
 	// total amount of swap space available
 	SwapTotal *uint64
 	// Memory which has been evicted from RAM, and is temporarily
 	// on the disk
 	SwapFree *uint64
 	// Memory which is waiting to get written back to the disk
 	Dirty *uint64
 	// Memory which is actively being written back to the disk
 	Writeback *uint64
 	// Non-file backed pages mapped into userspace page tables
 	AnonPages *uint64
 	// files which have been mapped, such as libraries
 	Mapped *uint64
 	Shmem  *uint64
 	// in-kernel data structures cache
 	Slab *uint64
 	// Part of Slab, that might be reclaimed, such as caches
 	SReclaimable *uint64
 	// Part of Slab, that cannot be reclaimed on memory pressure
 	SUnreclaim  *uint64
 	KernelStack *uint64
 	// amount of memory dedicated to the lowest level of page
 	// tables.
 	PageTables *uint64
 	// NFS pages sent to the server, but not yet committed to
 	// stable storage
 	NFSUnstable *uint64
 	// Memory used for block device "bounce buffers"
 	Bounce *uint64
 	// Memory used by FUSE for temporary writeback buffers
 	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.
 	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.
 	CommittedAS *uint64
 	// total size of vmalloc memory area
 	VmallocTotal *uint64
 	// amount of vmalloc area which is used
 	VmallocUsed *uint64
 	// largest contiguous block of vmalloc area which is free
 	VmallocChunk      *uint64
 	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
 }

 // 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 {
 		return Meminfo{}, fmt.Errorf("failed to parse meminfo: %w", err)
 	}

 	return *m, nil
 }

 func parseMemInfo(r io.Reader) (*Meminfo, error) {
 	var m Meminfo
 	s := bufio.NewScanner(r)
 	for s.Scan() {
 		// Each line has at least a name and value; we ignore the unit.
 		fields := strings.Fields(s.Text())
 		if len(fields) < 2 {
 			return nil, fmt.Errorf("malformed meminfo line: %q", s.Text())
 		}

 		v, err := strconv.ParseUint(fields[1], 0, 64)
 		if err != nil {
 			return nil, err
 		}

 		switch fields[0] {
 		case "MemTotal:":
 			m.MemTotal = &v
 		case "MemFree:":
 			m.MemFree = &v
 		case "MemAvailable:":
 			m.MemAvailable = &v
 		case "Buffers:":
 			m.Buffers = &v
 		case "Cached:":
 			m.Cached = &v
 		case "SwapCached:":
 			m.SwapCached = &v
 		case "Active:":
 			m.Active = &v
 		case "Inactive:":
 			m.Inactive = &v
 		case "Active(anon):":
 			m.ActiveAnon = &v
 		case "Inactive(anon):":
 			m.InactiveAnon = &v
 		case "Active(file):":
 			m.ActiveFile = &v
 		case "Inactive(file):":
 			m.InactiveFile = &v
 		case "Unevictable:":
 			m.Unevictable = &v
 		case "Mlocked:":
 			m.Mlocked = &v
 		case "SwapTotal:":
 			m.SwapTotal = &v
 		case "SwapFree:":
 			m.SwapFree = &v
 		case "Dirty:":
 			m.Dirty = &v
 		case "Writeback:":
 			m.Writeback = &v
 		case "AnonPages:":
 			m.AnonPages = &v
 		case "Mapped:":
 			m.Mapped = &v
 		case "Shmem:":
 			m.Shmem = &v
 		case "Slab:":
 			m.Slab = &v
 		case "SReclaimable:":
 			m.SReclaimable = &v
 		case "SUnreclaim:":
 			m.SUnreclaim = &v
 		case "KernelStack:":
 			m.KernelStack = &v
 		case "PageTables:":
 			m.PageTables = &v
 		case "NFS_Unstable:":
 			m.NFSUnstable = &v
 		case "Bounce:":
 			m.Bounce = &v
 		case "WritebackTmp:":
 			m.WritebackTmp = &v
 		case "CommitLimit:":
 			m.CommitLimit = &v
 		case "Committed_AS:":
 			m.CommittedAS = &v
 		case "VmallocTotal:":
 			m.VmallocTotal = &v
 		case "VmallocUsed:":
 			m.VmallocUsed = &v
 		case "VmallocChunk:":
 			m.VmallocChunk = &v
 		case "HardwareCorrupted:":
 			m.HardwareCorrupted = &v
 		case "AnonHugePages:":
 			m.AnonHugePages = &v
 		case "ShmemHugePages:":
 			m.ShmemHugePages = &v
 		case "ShmemPmdMapped:":
 			m.ShmemPmdMapped = &v
 		case "CmaTotal:":
 			m.CmaTotal = &v
 		case "CmaFree:":
 			m.CmaFree = &v
 		case "HugePages_Total:":
 			m.HugePagesTotal = &v
 		case "HugePages_Free:":
 			m.HugePagesFree = &v
 		case "HugePages_Rsvd:":
 			m.HugePagesRsvd = &v
 		case "HugePages_Surp:":
 			m.HugePagesSurp = &v
 		case "Hugepagesize:":
 			m.Hugepagesize = &v
 		case "DirectMap4k:":
 			m.DirectMap4k = &v
 		case "DirectMap2M:":
 			m.DirectMap2M = &v
 		case "DirectMap1G:":
 			m.DirectMap1G = &v
 		}
 	}

 	return &m, nil
 }
	// 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)
	MemTotal *uint64
	// The sum of LowFree+HighFree
	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.
	MemAvailable *uint64
	// Relatively temporary storage for raw disk blocks shouldn't
	// get tremendously large (20MB or so)
	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)
	SwapCached *uint64
	// Memory that has been used more recently and usually not
	// reclaimed unless absolutely necessary.
	Active *uint64
	// Memory which has been less recently used. It is more
	// eligible to be reclaimed for other purposes
	Inactive *uint64
	ActiveAnon *uint64
	InactiveAnon *uint64
	ActiveFile *uint64
	InactiveFile *uint64
	Unevictable *uint64
	Mlocked *uint64
	// total amount of swap space available
	SwapTotal *uint64
	// Memory which has been evicted from RAM, and is temporarily
	// on the disk
	SwapFree *uint64
	// Memory which is waiting to get written back to the disk
	Dirty *uint64
	// Memory which is actively being written back to the disk
	Writeback *uint64
	// Non-file backed pages mapped into userspace page tables
	AnonPages *uint64
	// files which have been mapped, such as libraries
	Mapped *uint64
	Shmem *uint64
	// in-kernel data structures cache
	Slab *uint64
	// Part of Slab, that might be reclaimed, such as caches
	SReclaimable *uint64
	// Part of Slab, that cannot be reclaimed on memory pressure
	SUnreclaim *uint64
	KernelStack *uint64
	// amount of memory dedicated to the lowest level of page
	// tables.
	PageTables *uint64
	// NFS pages sent to the server, but not yet committed to
	// stable storage
	NFSUnstable *uint64
	// Memory used for block device "bounce buffers"
	Bounce *uint64
	// Memory used by FUSE for temporary writeback buffers
	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.
	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.
	CommittedAS *uint64
	// total size of vmalloc memory area
	VmallocTotal *uint64
	// amount of vmalloc area which is used
	VmallocUsed *uint64
	// largest contiguous block of vmalloc area which is free
	VmallocChunk *uint64
	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
	}

	// 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 {
	return Meminfo{}, fmt.Errorf("failed to parse meminfo: %w", err)
	}

	return *m, nil
	}

	func parseMemInfo(r io.Reader) (*Meminfo, error) {
	var m Meminfo
	s := bufio.NewScanner(r)
	for s.Scan() {
	// Each line has at least a name and value; we ignore the unit.
	fields := strings.Fields(s.Text())
	if len(fields) < 2 {
	return nil, fmt.Errorf("malformed meminfo line: %q", s.Text())
	}

	v, err := strconv.ParseUint(fields[1], 0, 64)
	if err != nil {
	return nil, err
	}

	switch fields[0] {
	case "MemTotal:":
	m.MemTotal = &v
	case "MemFree:":
	m.MemFree = &v
	case "MemAvailable:":
	m.MemAvailable = &v
	case "Buffers:":
	m.Buffers = &v
	case "Cached:":
	m.Cached = &v
	case "SwapCached:":
	m.SwapCached = &v
	case "Active:":
	m.Active = &v
	case "Inactive:":
	m.Inactive = &v
	case "Active(anon):":
	m.ActiveAnon = &v
	case "Inactive(anon):":
	m.InactiveAnon = &v
	case "Active(file):":
	m.ActiveFile = &v
	case "Inactive(file):":
	m.InactiveFile = &v
	case "Unevictable:":
	m.Unevictable = &v
	case "Mlocked:":
	m.Mlocked = &v
	case "SwapTotal:":
	m.SwapTotal = &v
	case "SwapFree:":
	m.SwapFree = &v
	case "Dirty:":
	m.Dirty = &v
	case "Writeback:":
	m.Writeback = &v
	case "AnonPages:":
	m.AnonPages = &v
	case "Mapped:":
	m.Mapped = &v
	case "Shmem:":
	m.Shmem = &v
	case "Slab:":
	m.Slab = &v
	case "SReclaimable:":
	m.SReclaimable = &v
	case "SUnreclaim:":
	m.SUnreclaim = &v
	case "KernelStack:":
	m.KernelStack = &v
	case "PageTables:":
	m.PageTables = &v
	case "NFS_Unstable:":
	m.NFSUnstable = &v
	case "Bounce:":
	m.Bounce = &v
	case "WritebackTmp:":
	m.WritebackTmp = &v
	case "CommitLimit:":
	m.CommitLimit = &v
	case "Committed_AS:":
	m.CommittedAS = &v
	case "VmallocTotal:":
	m.VmallocTotal = &v
	case "VmallocUsed:":
	m.VmallocUsed = &v
	case "VmallocChunk:":
	m.VmallocChunk = &v
	case "HardwareCorrupted:":
	m.HardwareCorrupted = &v
	case "AnonHugePages:":
	m.AnonHugePages = &v
	case "ShmemHugePages:":
	m.ShmemHugePages = &v
	case "ShmemPmdMapped:":
	m.ShmemPmdMapped = &v
	case "CmaTotal:":
	m.CmaTotal = &v
	case "CmaFree:":
	m.CmaFree = &v
	case "HugePages_Total:":
	m.HugePagesTotal = &v
	case "HugePages_Free:":
	m.HugePagesFree = &v
	case "HugePages_Rsvd:":
	m.HugePagesRsvd = &v
	case "HugePages_Surp:":
	m.HugePagesSurp = &v
	case "Hugepagesize:":
	m.Hugepagesize = &v
	case "DirectMap4k:":
	m.DirectMap4k = &v
	case "DirectMap2M:":
	m.DirectMap2M = &v
	case "DirectMap1G:":
	m.DirectMap1G = &v
	}
	}

	return &m, nil
	}