diff --git a/vendor/github.com/prometheus/procfs/meminfo.go b/vendor/github.com/prometheus/procfs/meminfo.go
new file mode 100644
index 0000000..f65e174
--- /dev/null
+++ b/vendor/github.com/prometheus/procfs/meminfo.go
@@ -0,0 +1,277 @@
+// 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
+}