[VOL-5486] Fix deprecated versions
Change-Id: If0b888d6c2f33b2f415c8b03b08dc994bb3df3f4
Signed-off-by: Abhay Kumar <abhay.kumar@radisys.com>
diff --git a/vendor/github.com/prometheus/procfs/meminfo.go b/vendor/github.com/prometheus/procfs/meminfo.go
new file mode 100644
index 0000000..4b2c405
--- /dev/null
+++ b/vendor/github.com/prometheus/procfs/meminfo.go
@@ -0,0 +1,389 @@
+// 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
+ Percpu *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
+
+ // 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 {
+ return Meminfo{}, fmt.Errorf("%w: %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())
+ var val, valBytes uint64
+
+ val, err := strconv.ParseUint(fields[1], 0, 64)
+ if err != nil {
+ return nil, err
+ }
+
+ 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:":
+ m.MemTotal = &val
+ m.MemTotalBytes = &valBytes
+ case "MemFree:":
+ m.MemFree = &val
+ m.MemFreeBytes = &valBytes
+ case "MemAvailable:":
+ m.MemAvailable = &val
+ m.MemAvailableBytes = &valBytes
+ case "Buffers:":
+ m.Buffers = &val
+ m.BuffersBytes = &valBytes
+ case "Cached:":
+ m.Cached = &val
+ m.CachedBytes = &valBytes
+ case "SwapCached:":
+ m.SwapCached = &val
+ m.SwapCachedBytes = &valBytes
+ case "Active:":
+ m.Active = &val
+ m.ActiveBytes = &valBytes
+ case "Inactive:":
+ m.Inactive = &val
+ m.InactiveBytes = &valBytes
+ case "Active(anon):":
+ m.ActiveAnon = &val
+ m.ActiveAnonBytes = &valBytes
+ case "Inactive(anon):":
+ m.InactiveAnon = &val
+ m.InactiveAnonBytes = &valBytes
+ case "Active(file):":
+ m.ActiveFile = &val
+ m.ActiveFileBytes = &valBytes
+ case "Inactive(file):":
+ m.InactiveFile = &val
+ m.InactiveFileBytes = &valBytes
+ case "Unevictable:":
+ m.Unevictable = &val
+ m.UnevictableBytes = &valBytes
+ case "Mlocked:":
+ m.Mlocked = &val
+ m.MlockedBytes = &valBytes
+ case "SwapTotal:":
+ m.SwapTotal = &val
+ m.SwapTotalBytes = &valBytes
+ case "SwapFree:":
+ m.SwapFree = &val
+ m.SwapFreeBytes = &valBytes
+ case "Dirty:":
+ m.Dirty = &val
+ m.DirtyBytes = &valBytes
+ case "Writeback:":
+ m.Writeback = &val
+ m.WritebackBytes = &valBytes
+ case "AnonPages:":
+ m.AnonPages = &val
+ m.AnonPagesBytes = &valBytes
+ case "Mapped:":
+ m.Mapped = &val
+ m.MappedBytes = &valBytes
+ case "Shmem:":
+ m.Shmem = &val
+ m.ShmemBytes = &valBytes
+ case "Slab:":
+ m.Slab = &val
+ m.SlabBytes = &valBytes
+ case "SReclaimable:":
+ m.SReclaimable = &val
+ m.SReclaimableBytes = &valBytes
+ case "SUnreclaim:":
+ m.SUnreclaim = &val
+ m.SUnreclaimBytes = &valBytes
+ case "KernelStack:":
+ m.KernelStack = &val
+ m.KernelStackBytes = &valBytes
+ case "PageTables:":
+ m.PageTables = &val
+ m.PageTablesBytes = &valBytes
+ case "NFS_Unstable:":
+ m.NFSUnstable = &val
+ m.NFSUnstableBytes = &valBytes
+ case "Bounce:":
+ m.Bounce = &val
+ m.BounceBytes = &valBytes
+ case "WritebackTmp:":
+ m.WritebackTmp = &val
+ m.WritebackTmpBytes = &valBytes
+ case "CommitLimit:":
+ m.CommitLimit = &val
+ m.CommitLimitBytes = &valBytes
+ case "Committed_AS:":
+ m.CommittedAS = &val
+ m.CommittedASBytes = &valBytes
+ case "VmallocTotal:":
+ m.VmallocTotal = &val
+ m.VmallocTotalBytes = &valBytes
+ case "VmallocUsed:":
+ m.VmallocUsed = &val
+ m.VmallocUsedBytes = &valBytes
+ case "VmallocChunk:":
+ m.VmallocChunk = &val
+ m.VmallocChunkBytes = &valBytes
+ case "Percpu:":
+ m.Percpu = &val
+ m.PercpuBytes = &valBytes
+ case "HardwareCorrupted:":
+ m.HardwareCorrupted = &val
+ m.HardwareCorruptedBytes = &valBytes
+ case "AnonHugePages:":
+ m.AnonHugePages = &val
+ m.AnonHugePagesBytes = &valBytes
+ case "ShmemHugePages:":
+ m.ShmemHugePages = &val
+ m.ShmemHugePagesBytes = &valBytes
+ case "ShmemPmdMapped:":
+ m.ShmemPmdMapped = &val
+ m.ShmemPmdMappedBytes = &valBytes
+ case "CmaTotal:":
+ m.CmaTotal = &val
+ m.CmaTotalBytes = &valBytes
+ case "CmaFree:":
+ m.CmaFree = &val
+ m.CmaFreeBytes = &valBytes
+ case "HugePages_Total:":
+ m.HugePagesTotal = &val
+ case "HugePages_Free:":
+ m.HugePagesFree = &val
+ case "HugePages_Rsvd:":
+ m.HugePagesRsvd = &val
+ case "HugePages_Surp:":
+ m.HugePagesSurp = &val
+ case "Hugepagesize:":
+ m.Hugepagesize = &val
+ m.HugepagesizeBytes = &valBytes
+ case "DirectMap4k:":
+ m.DirectMap4k = &val
+ m.DirectMap4kBytes = &valBytes
+ case "DirectMap2M:":
+ m.DirectMap2M = &val
+ m.DirectMap2MBytes = &valBytes
+ case "DirectMap1G:":
+ m.DirectMap1G = &val
+ m.DirectMap1GBytes = &valBytes
+ }
+ }
+
+ return &m, nil
+}