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
+}