README

procfs

This package provides functions to retrieve system, kernel, and process metrics from the pseudo-filesystems /proc and /sys.

WARNING: This package is a work in progress. Its API may still break in backwards-incompatible ways without warnings. Use it at your own risk.

GoDoc Build Status Go Report Card

Usage

The procfs library is organized by packages based on whether the gathered data is coming from /proc, /sys, or both. Each package contains an FS type which represents the path to either /proc, /sys, or both. For example, cpu statistics are gathered from /proc/stat and are available via the root procfs package. First, the proc filesystem mount point is initialized, and then the stat information is read.

fs, err := procfs.NewFS("/proc")
stats, err := fs.Stat()

Some sub-packages such as blockdevice, require access to both the proc and sys filesystems.

    fs, err := blockdevice.NewFS("/proc", "/sys")
    stats, err := fs.ProcDiskstats()

Package Organization

The packages in this project are organized according to (1) whether the data comes from the /proc or /sys filesystem and (2) the type of information being retrieved. For example, most process information can be gathered from the functions in the root procfs package. Information about block devices such as disk drives is available in the blockdevices sub-package.

Building and Testing

The procfs library is intended to be built as part of another application, so there are no distributable binaries.
However, most of the API includes unit tests which can be run with make test.

Updating Test Fixtures

The procfs library includes a set of test fixtures which include many example files from the /proc and /sys filesystems. These fixtures are included as a ttar file which is extracted automatically during testing. To add/update the test fixtures, first ensure the fixtures directory is up to date by removing the existing directory and then extracting the ttar file using make fixtures/.unpacked or just make test.

rm -rf fixtures
make test

Next, make the required changes to the extracted files in the fixtures directory. When the changes are complete, run make update_fixtures to create a new fixtures.ttar file based on the updated fixtures directory. And finally, verify the changes using git diff fixtures.ttar.

Expand ▾ Collapse ▴

Documentation

Overview

    Package procfs provides functions to retrieve system, kernel and process metrics from the pseudo-filesystem proc.

    Example:

    package main
    
    import (
    	"fmt"
    	"log"
    
    	"github.com/prometheus/procfs"
    )
    
    func main() {
    	p, err := procfs.Self()
    	if err != nil {
    		log.Fatalf("could not get process: %s", err)
    	}
    
    	stat, err := p.NewStat()
    	if err != nil {
    		log.Fatalf("could not get process stat: %s", err)
    	}
    
    	fmt.Printf("command:  %s\n", stat.Comm)
    	fmt.Printf("cpu time: %fs\n", stat.CPUTime())
    	fmt.Printf("vsize:    %dB\n", stat.VirtualMemory())
    	fmt.Printf("rss:      %dB\n", stat.ResidentMemory())
    }
    

    Index

    Constants

    View Source
    const DefaultMountPoint = fs.DefaultProcMountPoint

      DefaultMountPoint is the common mount point of the proc filesystem.

      Variables

      This section is empty.

      Functions

      This section is empty.

      Types

      type ARPEntry

      type ARPEntry struct {
      	// IP address
      	IPAddr net.IP
      	// MAC address
      	HWAddr net.HardwareAddr
      	// Name of the device
      	Device string
      }

        ARPEntry contains a single row of the columnar data represented in /proc/net/arp.

        type BuddyInfo

        type BuddyInfo struct {
        	Node  string
        	Zone  string
        	Sizes []float64
        }

          A BuddyInfo is the details parsed from /proc/buddyinfo. The data is comprised of an array of free fragments of each size. The sizes are 2^n*PAGE_SIZE, where n is the array index.

          type CPUInfo

          type CPUInfo struct {
          	Processor       uint
          	VendorID        string
          	CPUFamily       string
          	Model           string
          	ModelName       string
          	Stepping        string
          	Microcode       string
          	CPUMHz          float64
          	CacheSize       string
          	PhysicalID      string
          	Siblings        uint
          	CoreID          string
          	CPUCores        uint
          	APICID          string
          	InitialAPICID   string
          	FPU             string
          	FPUException    string
          	CPUIDLevel      uint
          	WP              string
          	Flags           []string
          	Bugs            []string
          	BogoMips        float64
          	CLFlushSize     uint
          	CacheAlignment  uint
          	AddressSizes    string
          	PowerManagement string
          }

            CPUInfo contains general information about a system CPU found in /proc/cpuinfo

            type CPUStat

            type CPUStat struct {
            	User      float64
            	Nice      float64
            	System    float64
            	Idle      float64
            	Iowait    float64
            	IRQ       float64
            	SoftIRQ   float64
            	Steal     float64
            	Guest     float64
            	GuestNice float64
            }

              CPUStat shows how much time the cpu spend in various stages.

              type Cgroup

              type Cgroup struct {
              	// HierarchyID that can be matched to a named hierarchy using /proc/cgroups. Cgroups V2 only has one
              	// hierarchy, so HierarchyID is always 0. For cgroups v1 this is a unique ID number
              	HierarchyID int
              	// Controllers using this hierarchy of processes. Controllers are also known as subsystems. For
              	// Cgroups V2 this may be empty, as all active controllers use the same hierarchy
              	Controllers []string
              	// Path of this control group, relative to the mount point of the cgroupfs representing this specific
              	// hierarchy
              	Path string
              }

                Cgroup models one line from /proc/[pid]/cgroup. Each Cgroup struct describes the the placement of a PID inside a specific control hierarchy. The kernel has two cgroup APIs, v1 and v2. v1 has one hierarchy per available resource controller, while v2 has one unified hierarchy shared by all controllers. Regardless of v1 or v2, all hierarchies contain all running processes, so the question answerable with a Cgroup struct is 'where is this process in this hierarchy' (where==what path on the specific cgroupfs). By prefixing this path with the mount point of *this specific* hierarchy, you can locate the relevant pseudo-files needed to read/set the data for this PID in this hierarchy

                Also see http://man7.org/linux/man-pages/man7/cgroups.7.html

                type ConntrackStatEntry

                type ConntrackStatEntry struct {
                	Entries       uint64
                	Found         uint64
                	Invalid       uint64
                	Ignore        uint64
                	Insert        uint64
                	InsertFailed  uint64
                	Drop          uint64
                	EarlyDrop     uint64
                	SearchRestart uint64
                }

                  A ConntrackStatEntry represents one line from net/stat/nf_conntrack and contains netfilter conntrack statistics at one CPU core

                  type Crypto

                  type Crypto struct {
                  	Alignmask   *uint64
                  	Async       bool
                  	Blocksize   *uint64
                  	Chunksize   *uint64
                  	Ctxsize     *uint64
                  	Digestsize  *uint64
                  	Driver      string
                  	Geniv       string
                  	Internal    string
                  	Ivsize      *uint64
                  	Maxauthsize *uint64
                  	MaxKeysize  *uint64
                  	MinKeysize  *uint64
                  	Module      string
                  	Name        string
                  	Priority    *int64
                  	Refcnt      *int64
                  	Seedsize    *uint64
                  	Selftest    string
                  	Type        string
                  	Walksize    *uint64
                  }

                    Crypto holds info parsed from /proc/crypto.

                    type FS

                    type FS struct {
                    	// contains filtered or unexported fields
                    }

                      FS represents the pseudo-filesystem sys, which provides an interface to kernel data structures.

                      func NewDefaultFS

                      func NewDefaultFS() (FS, error)

                        NewDefaultFS returns a new proc FS mounted under the default proc mountPoint. It will error if the mount point directory can't be read or is a file.

                        func NewFS

                        func NewFS(mountPoint string) (FS, error)

                          NewFS returns a new proc FS mounted under the given proc mountPoint. It will error if the mount point directory can't be read or is a file.

                          func (FS) AllProcs

                          func (fs FS) AllProcs() (Procs, error)

                            AllProcs returns a list of all currently available processes.

                            func (FS) BuddyInfo

                            func (fs FS) BuddyInfo() ([]BuddyInfo, error)

                              BuddyInfo reads the buddyinfo statistics from the specified `proc` filesystem.

                              func (FS) CPUInfo

                              func (fs FS) CPUInfo() ([]CPUInfo, error)

                                CPUInfo returns information about current system CPUs. See https://www.kernel.org/doc/Documentation/filesystems/proc.txt

                                func (FS) ConntrackStat

                                func (fs FS) ConntrackStat() ([]ConntrackStatEntry, error)

                                  ConntrackStat retrieves netfilter's conntrack statistics, split by CPU cores

                                  func (FS) Crypto

                                  func (fs FS) Crypto() ([]Crypto, error)

                                    Crypto parses an crypto-file (/proc/crypto) and returns a slice of structs containing the relevant info. More information available here: https://kernel.readthedocs.io/en/sphinx-samples/crypto-API.html

                                    func (FS) Fscacheinfo

                                    func (fs FS) Fscacheinfo() (Fscacheinfo, error)

                                      Fscacheinfo returns information about current fscache statistics. See https://www.kernel.org/doc/Documentation/filesystems/caching/fscache.txt

                                      func (FS) GatherARPEntries

                                      func (fs FS) GatherARPEntries() ([]ARPEntry, error)

                                        GatherARPEntries retrieves all the ARP entries, parse the relevant columns, and then return a slice of ARPEntry's.

                                        func (FS) IPVSBackendStatus

                                        func (fs FS) IPVSBackendStatus() ([]IPVSBackendStatus, error)

                                          IPVSBackendStatus reads and returns the status of all (virtual,real) server pairs from the specified `proc` filesystem.

                                          func (FS) IPVSStats

                                          func (fs FS) IPVSStats() (IPVSStats, error)

                                            IPVSStats reads the IPVS statistics from the specified `proc` filesystem.

                                            func (FS) KernelRandom

                                            func (fs FS) KernelRandom() (KernelRandom, error)

                                              KernelRandom returns values from /proc/sys/kernel/random.

                                              func (FS) LoadAvg

                                              func (fs FS) LoadAvg() (*LoadAvg, error)

                                                LoadAvg returns loadavg from /proc.

                                                func (FS) MDStat

                                                func (fs FS) MDStat() ([]MDStat, error)

                                                  MDStat parses an mdstat-file (/proc/mdstat) and returns a slice of structs containing the relevant info. More information available here: https://raid.wiki.kernel.org/index.php/Mdstat

                                                  func (FS) Meminfo

                                                  func (fs FS) Meminfo() (Meminfo, error)

                                                    Meminfo returns an information about current kernel/system memory statistics. See https://www.kernel.org/doc/Documentation/filesystems/proc.txt

                                                    func (FS) NetDev

                                                    func (fs FS) NetDev() (NetDev, error)

                                                      NetDev returns kernel/system statistics read from /proc/net/dev.

                                                      func (FS) NetProtocols

                                                      func (fs FS) NetProtocols() (NetProtocolStats, error)

                                                        NetProtocols reads stats from /proc/net/protocols and returns a map of PortocolStatLine entries. As of this writing no official Linux Documentation exists, however the source is fairly self-explanatory and the format seems stable since its introduction in 2.6.12-rc2 Linux 2.6.12-rc2 - https://elixir.bootlin.com/linux/v2.6.12-rc2/source/net/core/sock.c#L1452 Linux 5.10 - https://elixir.bootlin.com/linux/v5.10.4/source/net/core/sock.c#L3586

                                                        func (FS) NetSockstat

                                                        func (fs FS) NetSockstat() (*NetSockstat, error)

                                                          NetSockstat retrieves IPv4 socket statistics.

                                                          func (FS) NetSockstat6

                                                          func (fs FS) NetSockstat6() (*NetSockstat, error)

                                                            NetSockstat6 retrieves IPv6 socket statistics.

                                                            If IPv6 is disabled on this kernel, the returned error can be checked with os.IsNotExist.

                                                            func (FS) NetSoftnetStat

                                                            func (fs FS) NetSoftnetStat() ([]SoftnetStat, error)

                                                              NetSoftnetStat reads data from /proc/net/softnet_stat.

                                                              func (FS) NetTCP

                                                              func (fs FS) NetTCP() (NetTCP, error)

                                                                NetTCP returns the IPv4 kernel/networking statistics for TCP datagrams read from /proc/net/tcp.

                                                                func (FS) NetTCP6

                                                                func (fs FS) NetTCP6() (NetTCP, error)

                                                                  NetTCP6 returns the IPv6 kernel/networking statistics for TCP datagrams read from /proc/net/tcp6.

                                                                  func (FS) NetTCP6Summary

                                                                  func (fs FS) NetTCP6Summary() (*NetTCPSummary, error)

                                                                    NetTCP6Summary returns already computed statistics like the total queue lengths for TCP datagrams read from /proc/net/tcp6.

                                                                    func (FS) NetTCPSummary

                                                                    func (fs FS) NetTCPSummary() (*NetTCPSummary, error)

                                                                      NetTCPSummary returns already computed statistics like the total queue lengths for TCP datagrams read from /proc/net/tcp.

                                                                      func (FS) NetUDP

                                                                      func (fs FS) NetUDP() (NetUDP, error)

                                                                        NetUDP returns the IPv4 kernel/networking statistics for UDP datagrams read from /proc/net/udp.

                                                                        func (FS) NetUDP6

                                                                        func (fs FS) NetUDP6() (NetUDP, error)

                                                                          NetUDP6 returns the IPv6 kernel/networking statistics for UDP datagrams read from /proc/net/udp6.

                                                                          func (FS) NetUDP6Summary

                                                                          func (fs FS) NetUDP6Summary() (*NetUDPSummary, error)

                                                                            NetUDP6Summary returns already computed statistics like the total queue lengths for UDP datagrams read from /proc/net/udp6.

                                                                            func (FS) NetUDPSummary

                                                                            func (fs FS) NetUDPSummary() (*NetUDPSummary, error)

                                                                              NetUDPSummary returns already computed statistics like the total queue lengths for UDP datagrams read from /proc/net/udp.

                                                                              func (FS) NetUNIX

                                                                              func (fs FS) NetUNIX() (*NetUNIX, error)

                                                                                NetUNIX returns data read from /proc/net/unix.

                                                                                func (FS) NewProc

                                                                                func (fs FS) NewProc(pid int) (Proc, error)

                                                                                  NewProc returns a process for the given pid.

                                                                                  Deprecated: use fs.Proc() instead

                                                                                  func (FS) NewStat

                                                                                  func (fs FS) NewStat() (Stat, error)

                                                                                    NewStat returns information about current cpu/process statistics. See https://www.kernel.org/doc/Documentation/filesystems/proc.txt

                                                                                    Deprecated: use fs.Stat() instead

                                                                                    func (FS) NewXfrmStat

                                                                                    func (fs FS) NewXfrmStat() (XfrmStat, error)

                                                                                      NewXfrmStat reads the xfrm_stat statistics from the 'proc' filesystem.

                                                                                      func (FS) PSIStatsForResource

                                                                                      func (fs FS) PSIStatsForResource(resource string) (PSIStats, error)

                                                                                        PSIStatsForResource reads pressure stall information for the specified resource from /proc/pressure/<resource>. At time of writing this can be either "cpu", "memory" or "io".

                                                                                        func (FS) Proc

                                                                                        func (fs FS) Proc(pid int) (Proc, error)

                                                                                          Proc returns a process for the given pid.

                                                                                          func (FS) Schedstat

                                                                                          func (fs FS) Schedstat() (*Schedstat, error)

                                                                                            Schedstat reads data from /proc/schedstat

                                                                                            func (FS) Self

                                                                                            func (fs FS) Self() (Proc, error)

                                                                                              Self returns a process for the current process.

                                                                                              func (FS) SlabInfo

                                                                                              func (fs FS) SlabInfo() (SlabInfo, error)

                                                                                                SlabInfo reads data from /proc/slabinfo

                                                                                                func (FS) Stat

                                                                                                func (fs FS) Stat() (Stat, error)

                                                                                                  Stat returns information about current cpu/process statistics. See https://www.kernel.org/doc/Documentation/filesystems/proc.txt

                                                                                                  func (FS) Swaps

                                                                                                  func (fs FS) Swaps() ([]*Swap, error)

                                                                                                    Swaps returns a slice of all configured swap devices on the system.

                                                                                                    func (FS) VM

                                                                                                    func (fs FS) VM() (*VM, error)

                                                                                                      VM reads the VM statistics from the specified `proc` filesystem.

                                                                                                      func (FS) Zoneinfo

                                                                                                      func (fs FS) Zoneinfo() ([]Zoneinfo, error)

                                                                                                        Zoneinfo parses an zoneinfo-file (/proc/zoneinfo) and returns a slice of structs containing the relevant info. More information available here: https://www.kernel.org/doc/Documentation/sysctl/vm.txt

                                                                                                        type Fscacheinfo

                                                                                                        type Fscacheinfo struct {
                                                                                                        	// Number of index cookies allocated
                                                                                                        	IndexCookiesAllocated uint64
                                                                                                        	// data storage cookies allocated
                                                                                                        	DataStorageCookiesAllocated uint64
                                                                                                        	// Number of special cookies allocated
                                                                                                        	SpecialCookiesAllocated uint64
                                                                                                        	// Number of objects allocated
                                                                                                        	ObjectsAllocated uint64
                                                                                                        	// Number of object allocation failures
                                                                                                        	ObjectAllocationsFailure uint64
                                                                                                        	// Number of objects that reached the available state
                                                                                                        	ObjectsAvailable uint64
                                                                                                        	// Number of objects that reached the dead state
                                                                                                        	ObjectsDead uint64
                                                                                                        	// Number of objects that didn't have a coherency check
                                                                                                        	ObjectsWithoutCoherencyCheck uint64
                                                                                                        	// Number of objects that passed a coherency check
                                                                                                        	ObjectsWithCoherencyCheck uint64
                                                                                                        	// Number of objects that needed a coherency data update
                                                                                                        	ObjectsNeedCoherencyCheckUpdate uint64
                                                                                                        	// Number of objects that were declared obsolete
                                                                                                        	ObjectsDeclaredObsolete uint64
                                                                                                        	// Number of pages marked as being cached
                                                                                                        	PagesMarkedAsBeingCached uint64
                                                                                                        	// Number of uncache page requests seen
                                                                                                        	UncachePagesRequestSeen uint64
                                                                                                        	// Number of acquire cookie requests seen
                                                                                                        	AcquireCookiesRequestSeen uint64
                                                                                                        	// Number of acq reqs given a NULL parent
                                                                                                        	AcquireRequestsWithNullParent uint64
                                                                                                        	// Number of acq reqs rejected due to no cache available
                                                                                                        	AcquireRequestsRejectedNoCacheAvailable uint64
                                                                                                        	// Number of acq reqs succeeded
                                                                                                        	AcquireRequestsSucceeded uint64
                                                                                                        	// Number of acq reqs rejected due to error
                                                                                                        	AcquireRequestsRejectedDueToError uint64
                                                                                                        	// Number of acq reqs failed on ENOMEM
                                                                                                        	AcquireRequestsFailedDueToEnomem uint64
                                                                                                        	// Number of lookup calls made on cache backends
                                                                                                        	LookupsNumber uint64
                                                                                                        	// Number of negative lookups made
                                                                                                        	LookupsNegative uint64
                                                                                                        	// Number of positive lookups made
                                                                                                        	LookupsPositive uint64
                                                                                                        	// Number of objects created by lookup
                                                                                                        	ObjectsCreatedByLookup uint64
                                                                                                        	// Number of lookups timed out and requeued
                                                                                                        	LookupsTimedOutAndRequed uint64
                                                                                                        	InvalidationsNumber      uint64
                                                                                                        	InvalidationsRunning     uint64
                                                                                                        	// Number of update cookie requests seen
                                                                                                        	UpdateCookieRequestSeen uint64
                                                                                                        	// Number of upd reqs given a NULL parent
                                                                                                        	UpdateRequestsWithNullParent uint64
                                                                                                        	// Number of upd reqs granted CPU time
                                                                                                        	UpdateRequestsRunning uint64
                                                                                                        	// Number of relinquish cookie requests seen
                                                                                                        	RelinquishCookiesRequestSeen uint64
                                                                                                        	// Number of rlq reqs given a NULL parent
                                                                                                        	RelinquishCookiesWithNullParent uint64
                                                                                                        	// Number of rlq reqs waited on completion of creation
                                                                                                        	RelinquishRequestsWaitingCompleteCreation uint64
                                                                                                        	// Relinqs rtr
                                                                                                        	RelinquishRetries uint64
                                                                                                        	// Number of attribute changed requests seen
                                                                                                        	AttributeChangedRequestsSeen uint64
                                                                                                        	// Number of attr changed requests queued
                                                                                                        	AttributeChangedRequestsQueued uint64
                                                                                                        	// Number of attr changed rejected -ENOBUFS
                                                                                                        	AttributeChangedRejectDueToEnobufs uint64
                                                                                                        	// Number of attr changed failed -ENOMEM
                                                                                                        	AttributeChangedFailedDueToEnomem uint64
                                                                                                        	// Number of attr changed ops given CPU time
                                                                                                        	AttributeChangedOps uint64
                                                                                                        	// Number of allocation requests seen
                                                                                                        	AllocationRequestsSeen uint64
                                                                                                        	// Number of successful alloc reqs
                                                                                                        	AllocationOkRequests uint64
                                                                                                        	// Number of alloc reqs that waited on lookup completion
                                                                                                        	AllocationWaitingOnLookup uint64
                                                                                                        	// Number of alloc reqs rejected -ENOBUFS
                                                                                                        	AllocationsRejectedDueToEnobufs uint64
                                                                                                        	// Number of alloc reqs aborted -ERESTARTSYS
                                                                                                        	AllocationsAbortedDueToErestartsys uint64
                                                                                                        	// Number of alloc reqs submitted
                                                                                                        	AllocationOperationsSubmitted uint64
                                                                                                        	// Number of alloc reqs waited for CPU time
                                                                                                        	AllocationsWaitedForCPU uint64
                                                                                                        	// Number of alloc reqs aborted due to object death
                                                                                                        	AllocationsAbortedDueToObjectDeath uint64
                                                                                                        	// Number of retrieval (read) requests seen
                                                                                                        	RetrievalsReadRequests uint64
                                                                                                        	// Number of successful retr reqs
                                                                                                        	RetrievalsOk uint64
                                                                                                        	// Number of retr reqs that waited on lookup completion
                                                                                                        	RetrievalsWaitingLookupCompletion uint64
                                                                                                        	// Number of retr reqs returned -ENODATA
                                                                                                        	RetrievalsReturnedEnodata uint64
                                                                                                        	// Number of retr reqs rejected -ENOBUFS
                                                                                                        	RetrievalsRejectedDueToEnobufs uint64
                                                                                                        	// Number of retr reqs aborted -ERESTARTSYS
                                                                                                        	RetrievalsAbortedDueToErestartsys uint64
                                                                                                        	// Number of retr reqs failed -ENOMEM
                                                                                                        	RetrievalsFailedDueToEnomem uint64
                                                                                                        	// Number of retr reqs submitted
                                                                                                        	RetrievalsRequests uint64
                                                                                                        	// Number of retr reqs waited for CPU time
                                                                                                        	RetrievalsWaitingCPU uint64
                                                                                                        	// Number of retr reqs aborted due to object death
                                                                                                        	RetrievalsAbortedDueToObjectDeath uint64
                                                                                                        	// Number of storage (write) requests seen
                                                                                                        	StoreWriteRequests uint64
                                                                                                        	// Number of successful store reqs
                                                                                                        	StoreSuccessfulRequests uint64
                                                                                                        	// Number of store reqs on a page already pending storage
                                                                                                        	StoreRequestsOnPendingStorage uint64
                                                                                                        	// Number of store reqs rejected -ENOBUFS
                                                                                                        	StoreRequestsRejectedDueToEnobufs uint64
                                                                                                        	// Number of store reqs failed -ENOMEM
                                                                                                        	StoreRequestsFailedDueToEnomem uint64
                                                                                                        	// Number of store reqs submitted
                                                                                                        	StoreRequestsSubmitted uint64
                                                                                                        	// Number of store reqs granted CPU time
                                                                                                        	StoreRequestsRunning uint64
                                                                                                        	// Number of pages given store req processing time
                                                                                                        	StorePagesWithRequestsProcessing uint64
                                                                                                        	// Number of store reqs deleted from tracking tree
                                                                                                        	StoreRequestsDeleted uint64
                                                                                                        	// Number of store reqs over store limit
                                                                                                        	StoreRequestsOverStoreLimit uint64
                                                                                                        	// Number of release reqs against pages with no pending store
                                                                                                        	ReleaseRequestsAgainstPagesWithNoPendingStorage uint64
                                                                                                        	// Number of release reqs against pages stored by time lock granted
                                                                                                        	ReleaseRequestsAgainstPagesStoredByTimeLockGranted uint64
                                                                                                        	// Number of release reqs ignored due to in-progress store
                                                                                                        	ReleaseRequestsIgnoredDueToInProgressStore uint64
                                                                                                        	// Number of page stores cancelled due to release req
                                                                                                        	PageStoresCancelledByReleaseRequests uint64
                                                                                                        	VmscanWaiting                        uint64
                                                                                                        	// Number of times async ops added to pending queues
                                                                                                        	OpsPending uint64
                                                                                                        	// Number of times async ops given CPU time
                                                                                                        	OpsRunning uint64
                                                                                                        	// Number of times async ops queued for processing
                                                                                                        	OpsEnqueued uint64
                                                                                                        	// Number of async ops cancelled
                                                                                                        	OpsCancelled uint64
                                                                                                        	// Number of async ops rejected due to object lookup/create failure
                                                                                                        	OpsRejected uint64
                                                                                                        	// Number of async ops initialised
                                                                                                        	OpsInitialised uint64
                                                                                                        	// Number of async ops queued for deferred release
                                                                                                        	OpsDeferred uint64
                                                                                                        	// Number of async ops released (should equal ini=N when idle)
                                                                                                        	OpsReleased uint64
                                                                                                        	// Number of deferred-release async ops garbage collected
                                                                                                        	OpsGarbageCollected uint64
                                                                                                        	// Number of in-progress alloc_object() cache ops
                                                                                                        	CacheopAllocationsinProgress uint64
                                                                                                        	// Number of in-progress lookup_object() cache ops
                                                                                                        	CacheopLookupObjectInProgress uint64
                                                                                                        	// Number of in-progress lookup_complete() cache ops
                                                                                                        	CacheopLookupCompleteInPorgress uint64
                                                                                                        	// Number of in-progress grab_object() cache ops
                                                                                                        	CacheopGrabObjectInProgress uint64
                                                                                                        	CacheopInvalidations        uint64
                                                                                                        	// Number of in-progress update_object() cache ops
                                                                                                        	CacheopUpdateObjectInProgress uint64
                                                                                                        	// Number of in-progress drop_object() cache ops
                                                                                                        	CacheopDropObjectInProgress uint64
                                                                                                        	// Number of in-progress put_object() cache ops
                                                                                                        	CacheopPutObjectInProgress uint64
                                                                                                        	// Number of in-progress attr_changed() cache ops
                                                                                                        	CacheopAttributeChangeInProgress uint64
                                                                                                        	// Number of in-progress sync_cache() cache ops
                                                                                                        	CacheopSyncCacheInProgress uint64
                                                                                                        	// Number of in-progress read_or_alloc_page() cache ops
                                                                                                        	CacheopReadOrAllocPageInProgress uint64
                                                                                                        	// Number of in-progress read_or_alloc_pages() cache ops
                                                                                                        	CacheopReadOrAllocPagesInProgress uint64
                                                                                                        	// Number of in-progress allocate_page() cache ops
                                                                                                        	CacheopAllocatePageInProgress uint64
                                                                                                        	// Number of in-progress allocate_pages() cache ops
                                                                                                        	CacheopAllocatePagesInProgress uint64
                                                                                                        	// Number of in-progress write_page() cache ops
                                                                                                        	CacheopWritePagesInProgress uint64
                                                                                                        	// Number of in-progress uncache_page() cache ops
                                                                                                        	CacheopUncachePagesInProgress uint64
                                                                                                        	// Number of in-progress dissociate_pages() cache ops
                                                                                                        	CacheopDissociatePagesInProgress uint64
                                                                                                        	// Number of object lookups/creations rejected due to lack of space
                                                                                                        	CacheevLookupsAndCreationsRejectedLackSpace uint64
                                                                                                        	// Number of stale objects deleted
                                                                                                        	CacheevStaleObjectsDeleted uint64
                                                                                                        	// Number of objects retired when relinquished
                                                                                                        	CacheevRetiredWhenReliquished uint64
                                                                                                        	// Number of objects culled
                                                                                                        	CacheevObjectsCulled uint64
                                                                                                        }

                                                                                                          Fscacheinfo represents fscache statistics.

                                                                                                          type IPVSBackendStatus

                                                                                                          type IPVSBackendStatus struct {
                                                                                                          	// The local (virtual) IP address.
                                                                                                          	LocalAddress net.IP
                                                                                                          	// The remote (real) IP address.
                                                                                                          	RemoteAddress net.IP
                                                                                                          	// The local (virtual) port.
                                                                                                          	LocalPort uint16
                                                                                                          	// The remote (real) port.
                                                                                                          	RemotePort uint16
                                                                                                          	// The local firewall mark
                                                                                                          	LocalMark string
                                                                                                          	// The transport protocol (TCP, UDP).
                                                                                                          	Proto string
                                                                                                          	// The current number of active connections for this virtual/real address pair.
                                                                                                          	ActiveConn uint64
                                                                                                          	// The current number of inactive connections for this virtual/real address pair.
                                                                                                          	InactConn uint64
                                                                                                          	// The current weight of this virtual/real address pair.
                                                                                                          	Weight uint64
                                                                                                          }

                                                                                                            IPVSBackendStatus holds current metrics of one virtual / real address pair.

                                                                                                            type IPVSStats

                                                                                                            type IPVSStats struct {
                                                                                                            	// Total count of connections.
                                                                                                            	Connections uint64
                                                                                                            	// Total incoming packages processed.
                                                                                                            	IncomingPackets uint64
                                                                                                            	// Total outgoing packages processed.
                                                                                                            	OutgoingPackets uint64
                                                                                                            	// Total incoming traffic.
                                                                                                            	IncomingBytes uint64
                                                                                                            	// Total outgoing traffic.
                                                                                                            	OutgoingBytes uint64
                                                                                                            }

                                                                                                              IPVSStats holds IPVS statistics, as exposed by the kernel in `/proc/net/ip_vs_stats`.

                                                                                                              type InotifyInfo

                                                                                                              type InotifyInfo struct {
                                                                                                              	// Watch descriptor number
                                                                                                              	WD string
                                                                                                              	// Inode number
                                                                                                              	Ino string
                                                                                                              	// Device ID
                                                                                                              	Sdev string
                                                                                                              	// Mask of events being monitored
                                                                                                              	Mask string
                                                                                                              }

                                                                                                                InotifyInfo represents a single inotify line in the fdinfo file.

                                                                                                                type KernelRandom

                                                                                                                type KernelRandom struct {
                                                                                                                	// EntropyAvaliable gives the available entropy, in bits.
                                                                                                                	EntropyAvaliable *uint64
                                                                                                                	// PoolSize gives the size of the entropy pool, in bits.
                                                                                                                	PoolSize *uint64
                                                                                                                	// URandomMinReseedSeconds is the number of seconds after which the DRNG will be reseeded.
                                                                                                                	URandomMinReseedSeconds *uint64
                                                                                                                	// WriteWakeupThreshold the number of bits of entropy below which we wake up processes
                                                                                                                	// that do a select(2) or poll(2) for write access to /dev/random.
                                                                                                                	WriteWakeupThreshold *uint64
                                                                                                                	// ReadWakeupThreshold is the number of bits of entropy required for waking up processes that sleep
                                                                                                                	// waiting for entropy from /dev/random.
                                                                                                                	ReadWakeupThreshold *uint64
                                                                                                                }

                                                                                                                  KernelRandom contains information about to the kernel's random number generator.

                                                                                                                  type LoadAvg

                                                                                                                  type LoadAvg struct {
                                                                                                                  	Load1  float64
                                                                                                                  	Load5  float64
                                                                                                                  	Load15 float64
                                                                                                                  }

                                                                                                                    LoadAvg represents an entry in /proc/loadavg

                                                                                                                    type MDStat

                                                                                                                    type MDStat struct {
                                                                                                                    	// Name of the device.
                                                                                                                    	Name string
                                                                                                                    	// activity-state of the device.
                                                                                                                    	ActivityState string
                                                                                                                    	// Number of active disks.
                                                                                                                    	DisksActive int64
                                                                                                                    	// Total number of disks the device requires.
                                                                                                                    	DisksTotal int64
                                                                                                                    	// Number of failed disks.
                                                                                                                    	DisksFailed int64
                                                                                                                    	// Spare disks in the device.
                                                                                                                    	DisksSpare int64
                                                                                                                    	// Number of blocks the device holds.
                                                                                                                    	BlocksTotal int64
                                                                                                                    	// Number of blocks on the device that are in sync.
                                                                                                                    	BlocksSynced int64
                                                                                                                    	// Name of md component devices
                                                                                                                    	Devices []string
                                                                                                                    }

                                                                                                                      MDStat holds info parsed from /proc/mdstat.

                                                                                                                      type Meminfo

                                                                                                                      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 represents memory statistics.

                                                                                                                        type Mount

                                                                                                                        type Mount struct {
                                                                                                                        	// Name of the device.
                                                                                                                        	Device string
                                                                                                                        	// The mount point of the device.
                                                                                                                        	Mount string
                                                                                                                        	// The filesystem type used by the device.
                                                                                                                        	Type string
                                                                                                                        	// If available additional statistics related to this Mount.
                                                                                                                        	// Use a type assertion to determine if additional statistics are available.
                                                                                                                        	Stats MountStats
                                                                                                                        }

                                                                                                                          A Mount is a device mount parsed from /proc/[pid]/mountstats.

                                                                                                                          type MountInfo

                                                                                                                          type MountInfo struct {
                                                                                                                          	// Unique ID for the mount
                                                                                                                          	MountID int
                                                                                                                          	// The ID of the parent mount
                                                                                                                          	ParentID int
                                                                                                                          	// The value of `st_dev` for the files on this FS
                                                                                                                          	MajorMinorVer string
                                                                                                                          	// The pathname of the directory in the FS that forms
                                                                                                                          	// the root for this mount
                                                                                                                          	Root string
                                                                                                                          	// The pathname of the mount point relative to the root
                                                                                                                          	MountPoint string
                                                                                                                          	// Mount options
                                                                                                                          	Options map[string]string
                                                                                                                          	// Zero or more optional fields
                                                                                                                          	OptionalFields map[string]string
                                                                                                                          	// The Filesystem type
                                                                                                                          	FSType string
                                                                                                                          	// FS specific information or "none"
                                                                                                                          	Source string
                                                                                                                          	// Superblock options
                                                                                                                          	SuperOptions map[string]string
                                                                                                                          }

                                                                                                                            A MountInfo is a type that describes the details, options for each mount, parsed from /proc/self/mountinfo. The fields described in each entry of /proc/self/mountinfo is described in the following man page. http://man7.org/linux/man-pages/man5/proc.5.html

                                                                                                                            func GetMounts

                                                                                                                            func GetMounts() ([]*MountInfo, error)

                                                                                                                              GetMounts retrieves mountinfo information from `/proc/self/mountinfo`.

                                                                                                                              func GetProcMounts

                                                                                                                              func GetProcMounts(pid int) ([]*MountInfo, error)

                                                                                                                                GetProcMounts retrieves mountinfo information from a processes' `/proc/<pid>/mountinfo`.

                                                                                                                                type MountStats

                                                                                                                                type MountStats interface {
                                                                                                                                	// contains filtered or unexported methods
                                                                                                                                }

                                                                                                                                  A MountStats is a type which contains detailed statistics for a specific type of Mount.

                                                                                                                                  type MountStatsNFS

                                                                                                                                  type MountStatsNFS struct {
                                                                                                                                  	// The version of statistics provided.
                                                                                                                                  	StatVersion string
                                                                                                                                  	// The mount options of the NFS mount.
                                                                                                                                  	Opts map[string]string
                                                                                                                                  	// The age of the NFS mount.
                                                                                                                                  	Age time.Duration
                                                                                                                                  	// Statistics related to byte counters for various operations.
                                                                                                                                  	Bytes NFSBytesStats
                                                                                                                                  	// Statistics related to various NFS event occurrences.
                                                                                                                                  	Events NFSEventsStats
                                                                                                                                  	// Statistics broken down by filesystem operation.
                                                                                                                                  	Operations []NFSOperationStats
                                                                                                                                  	// Statistics about the NFS RPC transport.
                                                                                                                                  	Transport NFSTransportStats
                                                                                                                                  }

                                                                                                                                    A MountStatsNFS is a MountStats implementation for NFSv3 and v4 mounts.

                                                                                                                                    type NFSBytesStats

                                                                                                                                    type NFSBytesStats struct {
                                                                                                                                    	// Number of bytes read using the read() syscall.
                                                                                                                                    	Read uint64
                                                                                                                                    	// Number of bytes written using the write() syscall.
                                                                                                                                    	Write uint64
                                                                                                                                    	// Number of bytes read using the read() syscall in O_DIRECT mode.
                                                                                                                                    	DirectRead uint64
                                                                                                                                    	// Number of bytes written using the write() syscall in O_DIRECT mode.
                                                                                                                                    	DirectWrite uint64
                                                                                                                                    	// Number of bytes read from the NFS server, in total.
                                                                                                                                    	ReadTotal uint64
                                                                                                                                    	// Number of bytes written to the NFS server, in total.
                                                                                                                                    	WriteTotal uint64
                                                                                                                                    	// Number of pages read directly via mmap()'d files.
                                                                                                                                    	ReadPages uint64
                                                                                                                                    	// Number of pages written directly via mmap()'d files.
                                                                                                                                    	WritePages uint64
                                                                                                                                    }

                                                                                                                                      A NFSBytesStats contains statistics about the number of bytes read and written by an NFS client to and from an NFS server.

                                                                                                                                      type NFSEventsStats

                                                                                                                                      type NFSEventsStats struct {
                                                                                                                                      	// Number of times cached inode attributes are re-validated from the server.
                                                                                                                                      	InodeRevalidate uint64
                                                                                                                                      	// Number of times cached dentry nodes are re-validated from the server.
                                                                                                                                      	DnodeRevalidate uint64
                                                                                                                                      	// Number of times an inode cache is cleared.
                                                                                                                                      	DataInvalidate uint64
                                                                                                                                      	// Number of times cached inode attributes are invalidated.
                                                                                                                                      	AttributeInvalidate uint64
                                                                                                                                      	// Number of times files or directories have been open()'d.
                                                                                                                                      	VFSOpen uint64
                                                                                                                                      	// Number of times a directory lookup has occurred.
                                                                                                                                      	VFSLookup uint64
                                                                                                                                      	// Number of times permissions have been checked.
                                                                                                                                      	VFSAccess uint64
                                                                                                                                      	// Number of updates (and potential writes) to pages.
                                                                                                                                      	VFSUpdatePage uint64
                                                                                                                                      	// Number of pages read directly via mmap()'d files.
                                                                                                                                      	VFSReadPage uint64
                                                                                                                                      	// Number of times a group of pages have been read.
                                                                                                                                      	VFSReadPages uint64
                                                                                                                                      	// Number of pages written directly via mmap()'d files.
                                                                                                                                      	VFSWritePage uint64
                                                                                                                                      	// Number of times a group of pages have been written.
                                                                                                                                      	VFSWritePages uint64
                                                                                                                                      	// Number of times directory entries have been read with getdents().
                                                                                                                                      	VFSGetdents uint64
                                                                                                                                      	// Number of times attributes have been set on inodes.
                                                                                                                                      	VFSSetattr uint64
                                                                                                                                      	// Number of pending writes that have been forcefully flushed to the server.
                                                                                                                                      	VFSFlush uint64
                                                                                                                                      	// Number of times fsync() has been called on directories and files.
                                                                                                                                      	VFSFsync uint64
                                                                                                                                      	// Number of times locking has been attempted on a file.
                                                                                                                                      	VFSLock uint64
                                                                                                                                      	// Number of times files have been closed and released.
                                                                                                                                      	VFSFileRelease uint64
                                                                                                                                      	// Unknown.  Possibly unused.
                                                                                                                                      	CongestionWait uint64
                                                                                                                                      	// Number of times files have been truncated.
                                                                                                                                      	Truncation uint64
                                                                                                                                      	// Number of times a file has been grown due to writes beyond its existing end.
                                                                                                                                      	WriteExtension uint64
                                                                                                                                      	// Number of times a file was removed while still open by another process.
                                                                                                                                      	SillyRename uint64
                                                                                                                                      	// Number of times the NFS server gave less data than expected while reading.
                                                                                                                                      	ShortRead uint64
                                                                                                                                      	// Number of times the NFS server wrote less data than expected while writing.
                                                                                                                                      	ShortWrite uint64
                                                                                                                                      	// Number of times the NFS server indicated EJUKEBOX; retrieving data from
                                                                                                                                      	// offline storage.
                                                                                                                                      	JukeboxDelay uint64
                                                                                                                                      	// Number of NFS v4.1+ pNFS reads.
                                                                                                                                      	PNFSRead uint64
                                                                                                                                      	// Number of NFS v4.1+ pNFS writes.
                                                                                                                                      	PNFSWrite uint64
                                                                                                                                      }

                                                                                                                                        A NFSEventsStats contains statistics about NFS event occurrences.

                                                                                                                                        type NFSOperationStats

                                                                                                                                        type NFSOperationStats struct {
                                                                                                                                        	// The name of the operation.
                                                                                                                                        	Operation string
                                                                                                                                        	// Number of requests performed for this operation.
                                                                                                                                        	Requests uint64
                                                                                                                                        	// Number of times an actual RPC request has been transmitted for this operation.
                                                                                                                                        	Transmissions uint64
                                                                                                                                        	// Number of times a request has had a major timeout.
                                                                                                                                        	MajorTimeouts uint64
                                                                                                                                        	// Number of bytes sent for this operation, including RPC headers and payload.
                                                                                                                                        	BytesSent uint64
                                                                                                                                        	// Number of bytes received for this operation, including RPC headers and payload.
                                                                                                                                        	BytesReceived uint64
                                                                                                                                        	// Duration all requests spent queued for transmission before they were sent.
                                                                                                                                        	CumulativeQueueMilliseconds uint64
                                                                                                                                        	// Duration it took to get a reply back after the request was transmitted.
                                                                                                                                        	CumulativeTotalResponseMilliseconds uint64
                                                                                                                                        	// Duration from when a request was enqueued to when it was completely handled.
                                                                                                                                        	CumulativeTotalRequestMilliseconds uint64
                                                                                                                                        	// The count of operations that complete with tk_status < 0.  These statuses usually indicate error conditions.
                                                                                                                                        	Errors uint64
                                                                                                                                        }

                                                                                                                                          A NFSOperationStats contains statistics for a single operation.

                                                                                                                                          type NFSTransportStats

                                                                                                                                          type NFSTransportStats struct {
                                                                                                                                          	// The transport protocol used for the NFS mount.
                                                                                                                                          	Protocol string
                                                                                                                                          	// The local port used for the NFS mount.
                                                                                                                                          	Port uint64
                                                                                                                                          	// Number of times the client has had to establish a connection from scratch
                                                                                                                                          	// to the NFS server.
                                                                                                                                          	Bind uint64
                                                                                                                                          	// Number of times the client has made a TCP connection to the NFS server.
                                                                                                                                          	Connect uint64
                                                                                                                                          	// Duration (in jiffies, a kernel internal unit of time) the NFS mount has
                                                                                                                                          	// spent waiting for connections to the server to be established.
                                                                                                                                          	ConnectIdleTime uint64
                                                                                                                                          	// Duration since the NFS mount last saw any RPC traffic.
                                                                                                                                          	IdleTimeSeconds uint64
                                                                                                                                          	// Number of RPC requests for this mount sent to the NFS server.
                                                                                                                                          	Sends uint64
                                                                                                                                          	// Number of RPC responses for this mount received from the NFS server.
                                                                                                                                          	Receives uint64
                                                                                                                                          	// Number of times the NFS server sent a response with a transaction ID
                                                                                                                                          	// unknown to this client.
                                                                                                                                          	BadTransactionIDs uint64
                                                                                                                                          	// A running counter, incremented on each request as the current difference
                                                                                                                                          	// ebetween sends and receives.
                                                                                                                                          	CumulativeActiveRequests uint64
                                                                                                                                          	// A running counter, incremented on each request by the current backlog
                                                                                                                                          	// queue size.
                                                                                                                                          	CumulativeBacklog uint64
                                                                                                                                          
                                                                                                                                          	// Maximum number of simultaneously active RPC requests ever used.
                                                                                                                                          	MaximumRPCSlotsUsed uint64
                                                                                                                                          	// A running counter, incremented on each request as the current size of the
                                                                                                                                          	// sending queue.
                                                                                                                                          	CumulativeSendingQueue uint64
                                                                                                                                          	// A running counter, incremented on each request as the current size of the
                                                                                                                                          	// pending queue.
                                                                                                                                          	CumulativePendingQueue uint64
                                                                                                                                          }

                                                                                                                                            A NFSTransportStats contains statistics for the NFS mount RPC requests and responses.

                                                                                                                                            type Namespace

                                                                                                                                            type Namespace struct {
                                                                                                                                            	Type  string // Namespace type.
                                                                                                                                            	Inode uint32 // Inode number of the namespace. If two processes are in the same namespace their inodes will match.
                                                                                                                                            }

                                                                                                                                              Namespace represents a single namespace of a process.

                                                                                                                                              type Namespaces

                                                                                                                                              type Namespaces map[string]Namespace

                                                                                                                                                Namespaces contains all of the namespaces that the process is contained in.

                                                                                                                                                type NetDev

                                                                                                                                                type NetDev map[string]NetDevLine

                                                                                                                                                  NetDev is parsed from /proc/net/dev or /proc/[pid]/net/dev. The map keys are interface names.

                                                                                                                                                  func (NetDev) Total

                                                                                                                                                  func (netDev NetDev) Total() NetDevLine

                                                                                                                                                    Total aggregates the values across interfaces and returns a new NetDevLine. The Name field will be a sorted comma separated list of interface names.

                                                                                                                                                    type NetDevLine

                                                                                                                                                    type NetDevLine struct {
                                                                                                                                                    	Name         string `json:"name"`          // The name of the interface.
                                                                                                                                                    	RxBytes      uint64 `json:"rx_bytes"`      // Cumulative count of bytes received.
                                                                                                                                                    	RxPackets    uint64 `json:"rx_packets"`    // Cumulative count of packets received.
                                                                                                                                                    	RxErrors     uint64 `json:"rx_errors"`     // Cumulative count of receive errors encountered.
                                                                                                                                                    	RxDropped    uint64 `json:"rx_dropped"`    // Cumulative count of packets dropped while receiving.
                                                                                                                                                    	RxFIFO       uint64 `json:"rx_fifo"`       // Cumulative count of FIFO buffer errors.
                                                                                                                                                    	RxFrame      uint64 `json:"rx_frame"`      // Cumulative count of packet framing errors.
                                                                                                                                                    	RxCompressed uint64 `json:"rx_compressed"` // Cumulative count of compressed packets received by the device driver.
                                                                                                                                                    	RxMulticast  uint64 `json:"rx_multicast"`  // Cumulative count of multicast frames received by the device driver.
                                                                                                                                                    	TxBytes      uint64 `json:"tx_bytes"`      // Cumulative count of bytes transmitted.
                                                                                                                                                    	TxPackets    uint64 `json:"tx_packets"`    // Cumulative count of packets transmitted.
                                                                                                                                                    	TxErrors     uint64 `json:"tx_errors"`     // Cumulative count of transmit errors encountered.
                                                                                                                                                    	TxDropped    uint64 `json:"tx_dropped"`    // Cumulative count of packets dropped while transmitting.
                                                                                                                                                    	TxFIFO       uint64 `json:"tx_fifo"`       // Cumulative count of FIFO buffer errors.
                                                                                                                                                    	TxCollisions uint64 `json:"tx_collisions"` // Cumulative count of collisions detected on the interface.
                                                                                                                                                    	TxCarrier    uint64 `json:"tx_carrier"`    // Cumulative count of carrier losses detected by the device driver.
                                                                                                                                                    	TxCompressed uint64 `json:"tx_compressed"` // Cumulative count of compressed packets transmitted by the device driver.
                                                                                                                                                    }

                                                                                                                                                      NetDevLine is single line parsed from /proc/net/dev or /proc/[pid]/net/dev.

                                                                                                                                                      type NetIPSocket

                                                                                                                                                      type NetIPSocket []*netIPSocketLine

                                                                                                                                                        NetIPSocket represents the contents of /proc/net/{t,u}dp{,6} file without the header.

                                                                                                                                                        type NetIPSocketSummary

                                                                                                                                                        type NetIPSocketSummary struct {
                                                                                                                                                        	// TxQueueLength shows the total queue length of all parsed tx_queue lengths.
                                                                                                                                                        	TxQueueLength uint64
                                                                                                                                                        	// RxQueueLength shows the total queue length of all parsed rx_queue lengths.
                                                                                                                                                        	RxQueueLength uint64
                                                                                                                                                        	// UsedSockets shows the total number of parsed lines representing the
                                                                                                                                                        	// number of used sockets.
                                                                                                                                                        	UsedSockets uint64
                                                                                                                                                        }

                                                                                                                                                          NetIPSocketSummary provides already computed values like the total queue lengths or the total number of used sockets. In contrast to NetIPSocket it does not collect the parsed lines into a slice.

                                                                                                                                                          type NetProtocolCapabilities

                                                                                                                                                          type NetProtocolCapabilities struct {
                                                                                                                                                          	Close               bool // 8
                                                                                                                                                          	Connect             bool // 9
                                                                                                                                                          	Disconnect          bool // 10
                                                                                                                                                          	Accept              bool // 11
                                                                                                                                                          	IoCtl               bool // 12
                                                                                                                                                          	Init                bool // 13
                                                                                                                                                          	Destroy             bool // 14
                                                                                                                                                          	Shutdown            bool // 15
                                                                                                                                                          	SetSockOpt          bool // 16
                                                                                                                                                          	GetSockOpt          bool // 17
                                                                                                                                                          	SendMsg             bool // 18
                                                                                                                                                          	RecvMsg             bool // 19
                                                                                                                                                          	SendPage            bool // 20
                                                                                                                                                          	Bind                bool // 21
                                                                                                                                                          	BacklogRcv          bool // 22
                                                                                                                                                          	Hash                bool // 23
                                                                                                                                                          	UnHash              bool // 24
                                                                                                                                                          	GetPort             bool // 25
                                                                                                                                                          	EnterMemoryPressure bool // 26
                                                                                                                                                          }

                                                                                                                                                            NetProtocolCapabilities contains a list of capabilities for each protocol

                                                                                                                                                            type NetProtocolStatLine

                                                                                                                                                            type NetProtocolStatLine struct {
                                                                                                                                                            	Name         string // 0 The name of the protocol
                                                                                                                                                            	Size         uint64 // 1 The size, in bytes, of a given protocol structure. e.g. sizeof(struct tcp_sock) or sizeof(struct unix_sock)
                                                                                                                                                            	Sockets      int64  // 2 Number of sockets in use by this protocol
                                                                                                                                                            	Memory       int64  // 3 Number of 4KB pages allocated by all sockets of this protocol
                                                                                                                                                            	Pressure     int    // 4 This is either yes, no, or NI (not implemented). For the sake of simplicity we treat NI as not experiencing memory pressure.
                                                                                                                                                            	MaxHeader    uint64 // 5 Protocol specific max header size
                                                                                                                                                            	Slab         bool   // 6 Indicates whether or not memory is allocated from the SLAB
                                                                                                                                                            	ModuleName   string // 7 The name of the module that implemented this protocol or "kernel" if not from a module
                                                                                                                                                            	Capabilities NetProtocolCapabilities
                                                                                                                                                            }

                                                                                                                                                              NetProtocolStatLine contains a single line parsed from /proc/net/protocols. We only care about the first six columns as the rest are not likely to change and only serve to provide a set of capabilities for each protocol.

                                                                                                                                                              type NetProtocolStats

                                                                                                                                                              type NetProtocolStats map[string]NetProtocolStatLine

                                                                                                                                                                NetProtocolStats stores the contents from /proc/net/protocols

                                                                                                                                                                type NetSockstat

                                                                                                                                                                type NetSockstat struct {
                                                                                                                                                                	// Used is non-nil for IPv4 sockstat results, but nil for IPv6.
                                                                                                                                                                	Used      *int
                                                                                                                                                                	Protocols []NetSockstatProtocol
                                                                                                                                                                }

                                                                                                                                                                  A NetSockstat contains the output of /proc/net/sockstat{,6} for IPv4 or IPv6, respectively.

                                                                                                                                                                  type NetSockstatProtocol

                                                                                                                                                                  type NetSockstatProtocol struct {
                                                                                                                                                                  	Protocol string
                                                                                                                                                                  	InUse    int
                                                                                                                                                                  	Orphan   *int
                                                                                                                                                                  	TW       *int
                                                                                                                                                                  	Alloc    *int
                                                                                                                                                                  	Mem      *int
                                                                                                                                                                  	Memory   *int
                                                                                                                                                                  }

                                                                                                                                                                    A NetSockstatProtocol contains statistics about a given socket protocol. Pointer fields indicate that the value may or may not be present on any given protocol.

                                                                                                                                                                    type NetTCP

                                                                                                                                                                    type NetTCP []*netIPSocketLine

                                                                                                                                                                      NetTCP represents the contents of /proc/net/tcp{,6} file without the header.

                                                                                                                                                                      type NetTCPSummary

                                                                                                                                                                      type NetTCPSummary NetIPSocketSummary

                                                                                                                                                                        NetTCPSummary provides already computed values like the total queue lengths or the total number of used sockets. In contrast to NetTCP it does not collect the parsed lines into a slice.

                                                                                                                                                                        type NetUDP

                                                                                                                                                                        type NetUDP []*netIPSocketLine

                                                                                                                                                                          NetUDP represents the contents of /proc/net/udp{,6} file without the header.

                                                                                                                                                                          type NetUDPSummary

                                                                                                                                                                          type NetUDPSummary NetIPSocketSummary

                                                                                                                                                                            NetUDPSummary provides already computed values like the total queue lengths or the total number of used sockets. In contrast to NetUDP it does not collect the parsed lines into a slice.

                                                                                                                                                                            type NetUNIX

                                                                                                                                                                            type NetUNIX struct {
                                                                                                                                                                            	Rows []*NetUNIXLine
                                                                                                                                                                            }

                                                                                                                                                                              NetUNIX holds the data read from /proc/net/unix.

                                                                                                                                                                              type NetUNIXFlags

                                                                                                                                                                              type NetUNIXFlags uint64

                                                                                                                                                                                NetUNIXFlags is the type of the flags field.

                                                                                                                                                                                func (NetUNIXFlags) String

                                                                                                                                                                                func (f NetUNIXFlags) String() string

                                                                                                                                                                                type NetUNIXLine

                                                                                                                                                                                type NetUNIXLine struct {
                                                                                                                                                                                	KernelPtr string
                                                                                                                                                                                	RefCount  uint64
                                                                                                                                                                                	Protocol  uint64
                                                                                                                                                                                	Flags     NetUNIXFlags
                                                                                                                                                                                	Type      NetUNIXType
                                                                                                                                                                                	State     NetUNIXState
                                                                                                                                                                                	Inode     uint64
                                                                                                                                                                                	Path      string
                                                                                                                                                                                }

                                                                                                                                                                                  NetUNIXLine represents a line of /proc/net/unix.

                                                                                                                                                                                  type NetUNIXState

                                                                                                                                                                                  type NetUNIXState uint64

                                                                                                                                                                                    NetUNIXState is the type of the state field.

                                                                                                                                                                                    func (NetUNIXState) String

                                                                                                                                                                                    func (s NetUNIXState) String() string

                                                                                                                                                                                    type NetUNIXType

                                                                                                                                                                                    type NetUNIXType uint64

                                                                                                                                                                                      NetUNIXType is the type of the type field.

                                                                                                                                                                                      func (NetUNIXType) String

                                                                                                                                                                                      func (t NetUNIXType) String() string

                                                                                                                                                                                      type PSILine

                                                                                                                                                                                      type PSILine struct {
                                                                                                                                                                                      	Avg10  float64
                                                                                                                                                                                      	Avg60  float64
                                                                                                                                                                                      	Avg300 float64
                                                                                                                                                                                      	Total  uint64
                                                                                                                                                                                      }

                                                                                                                                                                                        PSILine is a single line of values as returned by /proc/pressure/* The Avg entries are averages over n seconds, as a percentage The Total line is in microseconds

                                                                                                                                                                                        type PSIStats

                                                                                                                                                                                        type PSIStats struct {
                                                                                                                                                                                        	Some *PSILine
                                                                                                                                                                                        	Full *PSILine
                                                                                                                                                                                        }

                                                                                                                                                                                          PSIStats represent pressure stall information from /proc/pressure/* Some indicates the share of time in which at least some tasks are stalled Full indicates the share of time in which all non-idle tasks are stalled simultaneously

                                                                                                                                                                                          type Proc

                                                                                                                                                                                          type Proc struct {
                                                                                                                                                                                          	// The process ID.
                                                                                                                                                                                          	PID int
                                                                                                                                                                                          	// contains filtered or unexported fields
                                                                                                                                                                                          }

                                                                                                                                                                                            Proc provides information about a running process.

                                                                                                                                                                                            func NewProc

                                                                                                                                                                                            func NewProc(pid int) (Proc, error)

                                                                                                                                                                                              NewProc returns a process for the given pid under /proc.

                                                                                                                                                                                              func Self

                                                                                                                                                                                              func Self() (Proc, error)

                                                                                                                                                                                                Self returns a process for the current process read via /proc/self.

                                                                                                                                                                                                func (Proc) Cgroups

                                                                                                                                                                                                func (p Proc) Cgroups() ([]Cgroup, error)

                                                                                                                                                                                                  Cgroups reads from /proc/<pid>/cgroups and returns a []*Cgroup struct locating this PID in each process control hierarchy running on this system. On every system (v1 and v2), all hierarchies contain all processes, so the len of the returned struct is equal to the number of active hierarchies on this system

                                                                                                                                                                                                  func (Proc) CmdLine

                                                                                                                                                                                                  func (p Proc) CmdLine() ([]string, error)

                                                                                                                                                                                                    CmdLine returns the command line of a process.

                                                                                                                                                                                                    func (Proc) Comm

                                                                                                                                                                                                    func (p Proc) Comm() (string, error)

                                                                                                                                                                                                      Comm returns the command name of a process.

                                                                                                                                                                                                      func (Proc) Cwd

                                                                                                                                                                                                      func (p Proc) Cwd() (string, error)

                                                                                                                                                                                                        Cwd returns the absolute path to the current working directory of the process.

                                                                                                                                                                                                        func (Proc) Environ

                                                                                                                                                                                                        func (p Proc) Environ() ([]string, error)

                                                                                                                                                                                                          Environ reads process environments from /proc/<pid>/environ

                                                                                                                                                                                                          func (Proc) Executable

                                                                                                                                                                                                          func (p Proc) Executable() (string, error)

                                                                                                                                                                                                            Executable returns the absolute path of the executable command of a process.

                                                                                                                                                                                                            func (Proc) FDInfo

                                                                                                                                                                                                            func (p Proc) FDInfo(fd string) (*ProcFDInfo, error)

                                                                                                                                                                                                              FDInfo constructor. On kernels older than 3.8, InotifyInfos will always be empty.

                                                                                                                                                                                                              func (Proc) FileDescriptorTargets

                                                                                                                                                                                                              func (p Proc) FileDescriptorTargets() ([]string, error)

                                                                                                                                                                                                                FileDescriptorTargets returns the targets of all file descriptors of a process. If a file descriptor is not a symlink to a file (like a socket), that value will be the empty string.

                                                                                                                                                                                                                func (Proc) FileDescriptors

                                                                                                                                                                                                                func (p Proc) FileDescriptors() ([]uintptr, error)

                                                                                                                                                                                                                  FileDescriptors returns the currently open file descriptors of a process.

                                                                                                                                                                                                                  func (Proc) FileDescriptorsInfo

                                                                                                                                                                                                                  func (p Proc) FileDescriptorsInfo() (ProcFDInfos, error)

                                                                                                                                                                                                                    FileDescriptorsInfo retrieves information about all file descriptors of the process.

                                                                                                                                                                                                                    func (Proc) FileDescriptorsLen

                                                                                                                                                                                                                    func (p Proc) FileDescriptorsLen() (int, error)

                                                                                                                                                                                                                      FileDescriptorsLen returns the number of currently open file descriptors of a process.

                                                                                                                                                                                                                      func (Proc) IO

                                                                                                                                                                                                                      func (p Proc) IO() (ProcIO, error)

                                                                                                                                                                                                                        IO creates a new ProcIO instance from a given Proc instance.

                                                                                                                                                                                                                        func (Proc) Limits

                                                                                                                                                                                                                        func (p Proc) Limits() (ProcLimits, error)

                                                                                                                                                                                                                          Limits returns the current soft limits of the process.

                                                                                                                                                                                                                          func (Proc) MountInfo

                                                                                                                                                                                                                          func (p Proc) MountInfo() ([]*MountInfo, error)

                                                                                                                                                                                                                            MountInfo retrieves mount information for mount points in a process's namespace. It supplies information missing in `/proc/self/mounts` and fixes various other problems with that file too.

                                                                                                                                                                                                                            func (Proc) MountStats

                                                                                                                                                                                                                            func (p Proc) MountStats() ([]*Mount, error)

                                                                                                                                                                                                                              MountStats retrieves statistics and configuration for mount points in a process's namespace.

                                                                                                                                                                                                                              func (Proc) Namespaces

                                                                                                                                                                                                                              func (p Proc) Namespaces() (Namespaces, error)

                                                                                                                                                                                                                                Namespaces reads from /proc/<pid>/ns/* to get the namespaces of which the process is a member.

                                                                                                                                                                                                                                func (Proc) NetDev

                                                                                                                                                                                                                                func (p Proc) NetDev() (NetDev, error)

                                                                                                                                                                                                                                  NetDev returns kernel/system statistics read from /proc/[pid]/net/dev.

                                                                                                                                                                                                                                  func (Proc) NewLimits

                                                                                                                                                                                                                                  func (p Proc) NewLimits() (ProcLimits, error)

                                                                                                                                                                                                                                    NewLimits returns the current soft limits of the process.

                                                                                                                                                                                                                                    Deprecated: use p.Limits() instead

                                                                                                                                                                                                                                    func (Proc) NewStat

                                                                                                                                                                                                                                    func (p Proc) NewStat() (ProcStat, error)

                                                                                                                                                                                                                                      NewStat returns the current status information of the process.

                                                                                                                                                                                                                                      Deprecated: use p.Stat() instead

                                                                                                                                                                                                                                      func (Proc) NewStatus

                                                                                                                                                                                                                                      func (p Proc) NewStatus() (ProcStatus, error)

                                                                                                                                                                                                                                        NewStatus returns the current status information of the process.

                                                                                                                                                                                                                                        func (Proc) ProcMaps

                                                                                                                                                                                                                                        func (p Proc) ProcMaps() ([]*ProcMap, error)

                                                                                                                                                                                                                                          ProcMaps reads from /proc/[pid]/maps to get the memory-mappings of the process.

                                                                                                                                                                                                                                          func (Proc) ProcSMapsRollup

                                                                                                                                                                                                                                          func (p Proc) ProcSMapsRollup() (ProcSMapsRollup, error)

                                                                                                                                                                                                                                            ProcSMapsRollup reads from /proc/[pid]/smaps_rollup to get summed memory information of the process.

                                                                                                                                                                                                                                            If smaps_rollup does not exists (require kernel >= 4.15), the content of /proc/pid/smaps will we read and summed.

                                                                                                                                                                                                                                            func (Proc) RootDir

                                                                                                                                                                                                                                            func (p Proc) RootDir() (string, error)

                                                                                                                                                                                                                                              RootDir returns the absolute path to the process's root directory (as set by chroot)

                                                                                                                                                                                                                                              func (Proc) Schedstat

                                                                                                                                                                                                                                              func (p Proc) Schedstat() (ProcSchedstat, error)

                                                                                                                                                                                                                                                Schedstat returns task scheduling information for the process.

                                                                                                                                                                                                                                                func (Proc) Stat

                                                                                                                                                                                                                                                func (p Proc) Stat() (ProcStat, error)

                                                                                                                                                                                                                                                  Stat returns the current status information of the process.

                                                                                                                                                                                                                                                  func (Proc) Wchan

                                                                                                                                                                                                                                                  func (p Proc) Wchan() (string, error)

                                                                                                                                                                                                                                                    Wchan returns the wchan (wait channel) of a process.

                                                                                                                                                                                                                                                    type ProcFDInfo

                                                                                                                                                                                                                                                    type ProcFDInfo struct {
                                                                                                                                                                                                                                                    	// File descriptor
                                                                                                                                                                                                                                                    	FD string
                                                                                                                                                                                                                                                    	// File offset
                                                                                                                                                                                                                                                    	Pos string
                                                                                                                                                                                                                                                    	// File access mode and status flags
                                                                                                                                                                                                                                                    	Flags string
                                                                                                                                                                                                                                                    	// Mount point ID
                                                                                                                                                                                                                                                    	MntID string
                                                                                                                                                                                                                                                    	// List of inotify lines (structured) in the fdinfo file (kernel 3.8+ only)
                                                                                                                                                                                                                                                    	InotifyInfos []InotifyInfo
                                                                                                                                                                                                                                                    }

                                                                                                                                                                                                                                                      ProcFDInfo contains represents file descriptor information.

                                                                                                                                                                                                                                                      type ProcFDInfos

                                                                                                                                                                                                                                                      type ProcFDInfos []ProcFDInfo

                                                                                                                                                                                                                                                        ProcFDInfos represents a list of ProcFDInfo structs.

                                                                                                                                                                                                                                                        func (ProcFDInfos) InotifyWatchLen

                                                                                                                                                                                                                                                        func (p ProcFDInfos) InotifyWatchLen() (int, error)

                                                                                                                                                                                                                                                          InotifyWatchLen returns the total number of inotify watches

                                                                                                                                                                                                                                                          func (ProcFDInfos) Len

                                                                                                                                                                                                                                                          func (p ProcFDInfos) Len() int

                                                                                                                                                                                                                                                          func (ProcFDInfos) Less

                                                                                                                                                                                                                                                          func (p ProcFDInfos) Less(i, j int) bool

                                                                                                                                                                                                                                                          func (ProcFDInfos) Swap

                                                                                                                                                                                                                                                          func (p ProcFDInfos) Swap(i, j int)

                                                                                                                                                                                                                                                          type ProcIO

                                                                                                                                                                                                                                                          type ProcIO struct {
                                                                                                                                                                                                                                                          	// Chars read.
                                                                                                                                                                                                                                                          	RChar uint64
                                                                                                                                                                                                                                                          	// Chars written.
                                                                                                                                                                                                                                                          	WChar uint64
                                                                                                                                                                                                                                                          	// Read syscalls.
                                                                                                                                                                                                                                                          	SyscR uint64
                                                                                                                                                                                                                                                          	// Write syscalls.
                                                                                                                                                                                                                                                          	SyscW uint64
                                                                                                                                                                                                                                                          	// Bytes read.
                                                                                                                                                                                                                                                          	ReadBytes uint64
                                                                                                                                                                                                                                                          	// Bytes written.
                                                                                                                                                                                                                                                          	WriteBytes uint64
                                                                                                                                                                                                                                                          	// Bytes written, but taking into account truncation. See
                                                                                                                                                                                                                                                          	// Documentation/filesystems/proc.txt in the kernel sources for
                                                                                                                                                                                                                                                          	// detailed explanation.
                                                                                                                                                                                                                                                          	CancelledWriteBytes int64
                                                                                                                                                                                                                                                          }

                                                                                                                                                                                                                                                            ProcIO models the content of /proc/<pid>/io.

                                                                                                                                                                                                                                                            type ProcLimits

                                                                                                                                                                                                                                                            type ProcLimits struct {
                                                                                                                                                                                                                                                            	// CPU time limit in seconds.
                                                                                                                                                                                                                                                            	CPUTime uint64
                                                                                                                                                                                                                                                            	// Maximum size of files that the process may create.
                                                                                                                                                                                                                                                            	FileSize uint64
                                                                                                                                                                                                                                                            	// Maximum size of the process's data segment (initialized data,
                                                                                                                                                                                                                                                            	// uninitialized data, and heap).
                                                                                                                                                                                                                                                            	DataSize uint64
                                                                                                                                                                                                                                                            	// Maximum size of the process stack in bytes.
                                                                                                                                                                                                                                                            	StackSize uint64
                                                                                                                                                                                                                                                            	// Maximum size of a core file.
                                                                                                                                                                                                                                                            	CoreFileSize uint64
                                                                                                                                                                                                                                                            	// Limit of the process's resident set in pages.
                                                                                                                                                                                                                                                            	ResidentSet uint64
                                                                                                                                                                                                                                                            	// Maximum number of processes that can be created for the real user ID of
                                                                                                                                                                                                                                                            	// the calling process.
                                                                                                                                                                                                                                                            	Processes uint64
                                                                                                                                                                                                                                                            	// Value one greater than the maximum file descriptor number that can be
                                                                                                                                                                                                                                                            	// opened by this process.
                                                                                                                                                                                                                                                            	OpenFiles uint64
                                                                                                                                                                                                                                                            	// Maximum number of bytes of memory that may be locked into RAM.
                                                                                                                                                                                                                                                            	LockedMemory uint64
                                                                                                                                                                                                                                                            	// Maximum size of the process's virtual memory address space in bytes.
                                                                                                                                                                                                                                                            	AddressSpace uint64
                                                                                                                                                                                                                                                            	// Limit on the combined number of flock(2) locks and fcntl(2) leases that
                                                                                                                                                                                                                                                            	// this process may establish.
                                                                                                                                                                                                                                                            	FileLocks uint64
                                                                                                                                                                                                                                                            	// Limit of signals that may be queued for the real user ID of the calling
                                                                                                                                                                                                                                                            	// process.
                                                                                                                                                                                                                                                            	PendingSignals uint64
                                                                                                                                                                                                                                                            	// Limit on the number of bytes that can be allocated for POSIX message
                                                                                                                                                                                                                                                            	// queues for the real user ID of the calling process.
                                                                                                                                                                                                                                                            	MsqqueueSize uint64
                                                                                                                                                                                                                                                            	// Limit of the nice priority set using setpriority(2) or nice(2).
                                                                                                                                                                                                                                                            	NicePriority uint64
                                                                                                                                                                                                                                                            	// Limit of the real-time priority set using sched_setscheduler(2) or
                                                                                                                                                                                                                                                            	// sched_setparam(2).
                                                                                                                                                                                                                                                            	RealtimePriority uint64
                                                                                                                                                                                                                                                            	// Limit (in microseconds) on the amount of CPU time that a process
                                                                                                                                                                                                                                                            	// scheduled under a real-time scheduling policy may consume without making
                                                                                                                                                                                                                                                            	// a blocking system call.
                                                                                                                                                                                                                                                            	RealtimeTimeout uint64
                                                                                                                                                                                                                                                            }

                                                                                                                                                                                                                                                              ProcLimits represents the soft limits for each of the process's resource limits. For more information see getrlimit(2): http://man7.org/linux/man-pages/man2/getrlimit.2.html.

                                                                                                                                                                                                                                                              type ProcMap

                                                                                                                                                                                                                                                              type ProcMap struct {
                                                                                                                                                                                                                                                              	// The start address of current mapping.
                                                                                                                                                                                                                                                              	StartAddr uintptr
                                                                                                                                                                                                                                                              	// The end address of the current mapping
                                                                                                                                                                                                                                                              	EndAddr uintptr
                                                                                                                                                                                                                                                              	// The permissions for this mapping
                                                                                                                                                                                                                                                              	Perms *ProcMapPermissions
                                                                                                                                                                                                                                                              	// The current offset into the file/fd (e.g., shared libs)
                                                                                                                                                                                                                                                              	Offset int64
                                                                                                                                                                                                                                                              	// Device owner of this mapping (major:minor) in Mkdev format.
                                                                                                                                                                                                                                                              	Dev uint64
                                                                                                                                                                                                                                                              	// The inode of the device above
                                                                                                                                                                                                                                                              	Inode uint64
                                                                                                                                                                                                                                                              	// The file or psuedofile (or empty==anonymous)
                                                                                                                                                                                                                                                              	Pathname string
                                                                                                                                                                                                                                                              }

                                                                                                                                                                                                                                                                ProcMap contains the process memory-mappings of the process, read from /proc/[pid]/maps

                                                                                                                                                                                                                                                                type ProcMapPermissions

                                                                                                                                                                                                                                                                type ProcMapPermissions struct {
                                                                                                                                                                                                                                                                	// mapping has the [R]ead flag set
                                                                                                                                                                                                                                                                	Read bool
                                                                                                                                                                                                                                                                	// mapping has the [W]rite flag set
                                                                                                                                                                                                                                                                	Write bool
                                                                                                                                                                                                                                                                	// mapping has the [X]ecutable flag set
                                                                                                                                                                                                                                                                	Execute bool
                                                                                                                                                                                                                                                                	// mapping has the [S]hared flag set
                                                                                                                                                                                                                                                                	Shared bool
                                                                                                                                                                                                                                                                	// mapping is marked as [P]rivate (copy on write)
                                                                                                                                                                                                                                                                	Private bool
                                                                                                                                                                                                                                                                }

                                                                                                                                                                                                                                                                  ProcMapPermissions contains permission settings read from /proc/[pid]/maps

                                                                                                                                                                                                                                                                  type ProcSMapsRollup

                                                                                                                                                                                                                                                                  type ProcSMapsRollup struct {
                                                                                                                                                                                                                                                                  	// Amount of the mapping that is currently resident in RAM
                                                                                                                                                                                                                                                                  	Rss uint64
                                                                                                                                                                                                                                                                  	// Process's proportional share of this mapping
                                                                                                                                                                                                                                                                  	Pss uint64
                                                                                                                                                                                                                                                                  	// Size in bytes of clean shared pages
                                                                                                                                                                                                                                                                  	SharedClean uint64
                                                                                                                                                                                                                                                                  	// Size in bytes of dirty shared pages
                                                                                                                                                                                                                                                                  	SharedDirty uint64
                                                                                                                                                                                                                                                                  	// Size in bytes of clean private pages
                                                                                                                                                                                                                                                                  	PrivateClean uint64
                                                                                                                                                                                                                                                                  	// Size in bytes of dirty private pages
                                                                                                                                                                                                                                                                  	PrivateDirty uint64
                                                                                                                                                                                                                                                                  	// Amount of memory currently marked as referenced or accessed
                                                                                                                                                                                                                                                                  	Referenced uint64
                                                                                                                                                                                                                                                                  	// Amount of memory that does not belong to any file
                                                                                                                                                                                                                                                                  	Anonymous uint64
                                                                                                                                                                                                                                                                  	// Amount would-be-anonymous memory currently on swap
                                                                                                                                                                                                                                                                  	Swap uint64
                                                                                                                                                                                                                                                                  	// Process's proportional memory on swap
                                                                                                                                                                                                                                                                  	SwapPss uint64
                                                                                                                                                                                                                                                                  }

                                                                                                                                                                                                                                                                  type ProcSchedstat

                                                                                                                                                                                                                                                                  type ProcSchedstat struct {
                                                                                                                                                                                                                                                                  	RunningNanoseconds uint64
                                                                                                                                                                                                                                                                  	WaitingNanoseconds uint64
                                                                                                                                                                                                                                                                  	RunTimeslices      uint64
                                                                                                                                                                                                                                                                  }

                                                                                                                                                                                                                                                                    ProcSchedstat contains the values from /proc/<pid>/schedstat

                                                                                                                                                                                                                                                                    type ProcStat

                                                                                                                                                                                                                                                                    type ProcStat struct {
                                                                                                                                                                                                                                                                    	// The process ID.
                                                                                                                                                                                                                                                                    	PID int
                                                                                                                                                                                                                                                                    	// The filename of the executable.
                                                                                                                                                                                                                                                                    	Comm string
                                                                                                                                                                                                                                                                    	// The process state.
                                                                                                                                                                                                                                                                    	State string
                                                                                                                                                                                                                                                                    	// The PID of the parent of this process.
                                                                                                                                                                                                                                                                    	PPID int
                                                                                                                                                                                                                                                                    	// The process group ID of the process.
                                                                                                                                                                                                                                                                    	PGRP int
                                                                                                                                                                                                                                                                    	// The session ID of the process.
                                                                                                                                                                                                                                                                    	Session int
                                                                                                                                                                                                                                                                    	// The controlling terminal of the process.
                                                                                                                                                                                                                                                                    	TTY int
                                                                                                                                                                                                                                                                    	// The ID of the foreground process group of the controlling terminal of
                                                                                                                                                                                                                                                                    	// the process.
                                                                                                                                                                                                                                                                    	TPGID int
                                                                                                                                                                                                                                                                    	// The kernel flags word of the process.
                                                                                                                                                                                                                                                                    	Flags uint
                                                                                                                                                                                                                                                                    	// The number of minor faults the process has made which have not required
                                                                                                                                                                                                                                                                    	// loading a memory page from disk.
                                                                                                                                                                                                                                                                    	MinFlt uint
                                                                                                                                                                                                                                                                    	// The number of minor faults that the process's waited-for children have
                                                                                                                                                                                                                                                                    	// made.
                                                                                                                                                                                                                                                                    	CMinFlt uint
                                                                                                                                                                                                                                                                    	// The number of major faults the process has made which have required
                                                                                                                                                                                                                                                                    	// loading a memory page from disk.
                                                                                                                                                                                                                                                                    	MajFlt uint
                                                                                                                                                                                                                                                                    	// The number of major faults that the process's waited-for children have
                                                                                                                                                                                                                                                                    	// made.
                                                                                                                                                                                                                                                                    	CMajFlt uint
                                                                                                                                                                                                                                                                    	// Amount of time that this process has been scheduled in user mode,
                                                                                                                                                                                                                                                                    	// measured in clock ticks.
                                                                                                                                                                                                                                                                    	UTime uint
                                                                                                                                                                                                                                                                    	// Amount of time that this process has been scheduled in kernel mode,
                                                                                                                                                                                                                                                                    	// measured in clock ticks.
                                                                                                                                                                                                                                                                    	STime uint
                                                                                                                                                                                                                                                                    	// Amount of time that this process's waited-for children have been
                                                                                                                                                                                                                                                                    	// scheduled in user mode, measured in clock ticks.
                                                                                                                                                                                                                                                                    	CUTime uint
                                                                                                                                                                                                                                                                    	// Amount of time that this process's waited-for children have been
                                                                                                                                                                                                                                                                    	// scheduled in kernel mode, measured in clock ticks.
                                                                                                                                                                                                                                                                    	CSTime uint
                                                                                                                                                                                                                                                                    	// For processes running a real-time scheduling policy, this is the negated
                                                                                                                                                                                                                                                                    	// scheduling priority, minus one.
                                                                                                                                                                                                                                                                    	Priority int
                                                                                                                                                                                                                                                                    	// The nice value, a value in the range 19 (low priority) to -20 (high
                                                                                                                                                                                                                                                                    	// priority).
                                                                                                                                                                                                                                                                    	Nice int
                                                                                                                                                                                                                                                                    	// Number of threads in this process.
                                                                                                                                                                                                                                                                    	NumThreads int
                                                                                                                                                                                                                                                                    	// The time the process started after system boot, the value is expressed
                                                                                                                                                                                                                                                                    	// in clock ticks.
                                                                                                                                                                                                                                                                    	Starttime uint64
                                                                                                                                                                                                                                                                    	// Virtual memory size in bytes.
                                                                                                                                                                                                                                                                    	VSize uint
                                                                                                                                                                                                                                                                    	// Resident set size in pages.
                                                                                                                                                                                                                                                                    	RSS int
                                                                                                                                                                                                                                                                    	// contains filtered or unexported fields
                                                                                                                                                                                                                                                                    }

                                                                                                                                                                                                                                                                      ProcStat provides status information about the process, read from /proc/[pid]/stat.

                                                                                                                                                                                                                                                                      func (ProcStat) CPUTime

                                                                                                                                                                                                                                                                      func (s ProcStat) CPUTime() float64

                                                                                                                                                                                                                                                                        CPUTime returns the total CPU user and system time in seconds.

                                                                                                                                                                                                                                                                        func (ProcStat) ResidentMemory

                                                                                                                                                                                                                                                                        func (s ProcStat) ResidentMemory() int

                                                                                                                                                                                                                                                                          ResidentMemory returns the resident memory size in bytes.

                                                                                                                                                                                                                                                                          func (ProcStat) StartTime

                                                                                                                                                                                                                                                                          func (s ProcStat) StartTime() (float64, error)

                                                                                                                                                                                                                                                                            StartTime returns the unix timestamp of the process in seconds.

                                                                                                                                                                                                                                                                            func (ProcStat) VirtualMemory

                                                                                                                                                                                                                                                                            func (s ProcStat) VirtualMemory() uint

                                                                                                                                                                                                                                                                              VirtualMemory returns the virtual memory size in bytes.

                                                                                                                                                                                                                                                                              type ProcStatus

                                                                                                                                                                                                                                                                              type ProcStatus struct {
                                                                                                                                                                                                                                                                              	// The process ID.
                                                                                                                                                                                                                                                                              	PID int
                                                                                                                                                                                                                                                                              	// The process name.
                                                                                                                                                                                                                                                                              	Name string
                                                                                                                                                                                                                                                                              
                                                                                                                                                                                                                                                                              	// Thread group ID.
                                                                                                                                                                                                                                                                              	TGID int
                                                                                                                                                                                                                                                                              
                                                                                                                                                                                                                                                                              	// Peak virtual memory size.
                                                                                                                                                                                                                                                                              	VmPeak uint64 // nolint:golint
                                                                                                                                                                                                                                                                              	// Virtual memory size.
                                                                                                                                                                                                                                                                              	VmSize uint64 // nolint:golint
                                                                                                                                                                                                                                                                              	// Locked memory size.
                                                                                                                                                                                                                                                                              	VmLck uint64 // nolint:golint
                                                                                                                                                                                                                                                                              	// Pinned memory size.
                                                                                                                                                                                                                                                                              	VmPin uint64 // nolint:golint
                                                                                                                                                                                                                                                                              	// Peak resident set size.
                                                                                                                                                                                                                                                                              	VmHWM uint64 // nolint:golint
                                                                                                                                                                                                                                                                              	// Resident set size (sum of RssAnnon RssFile and RssShmem).
                                                                                                                                                                                                                                                                              	VmRSS uint64 // nolint:golint
                                                                                                                                                                                                                                                                              	// Size of resident anonymous memory.
                                                                                                                                                                                                                                                                              	RssAnon uint64 // nolint:golint
                                                                                                                                                                                                                                                                              	// Size of resident file mappings.
                                                                                                                                                                                                                                                                              	RssFile uint64 // nolint:golint
                                                                                                                                                                                                                                                                              	// Size of resident shared memory.
                                                                                                                                                                                                                                                                              	RssShmem uint64 // nolint:golint
                                                                                                                                                                                                                                                                              	// Size of data segments.
                                                                                                                                                                                                                                                                              	VmData uint64 // nolint:golint
                                                                                                                                                                                                                                                                              	// Size of stack segments.
                                                                                                                                                                                                                                                                              	VmStk uint64 // nolint:golint
                                                                                                                                                                                                                                                                              	// Size of text segments.
                                                                                                                                                                                                                                                                              	VmExe uint64 // nolint:golint
                                                                                                                                                                                                                                                                              	// Shared library code size.
                                                                                                                                                                                                                                                                              	VmLib uint64 // nolint:golint
                                                                                                                                                                                                                                                                              	// Page table entries size.
                                                                                                                                                                                                                                                                              	VmPTE uint64 // nolint:golint
                                                                                                                                                                                                                                                                              	// Size of second-level page tables.
                                                                                                                                                                                                                                                                              	VmPMD uint64 // nolint:golint
                                                                                                                                                                                                                                                                              	// Swapped-out virtual memory size by anonymous private.
                                                                                                                                                                                                                                                                              	VmSwap uint64 // nolint:golint
                                                                                                                                                                                                                                                                              	// Size of hugetlb memory portions
                                                                                                                                                                                                                                                                              	HugetlbPages uint64
                                                                                                                                                                                                                                                                              
                                                                                                                                                                                                                                                                              	// Number of voluntary context switches.
                                                                                                                                                                                                                                                                              	VoluntaryCtxtSwitches uint64
                                                                                                                                                                                                                                                                              	// Number of involuntary context switches.
                                                                                                                                                                                                                                                                              	NonVoluntaryCtxtSwitches uint64
                                                                                                                                                                                                                                                                              
                                                                                                                                                                                                                                                                              	// UIDs of the process (Real, effective, saved set, and filesystem UIDs)
                                                                                                                                                                                                                                                                              	UIDs [4]string
                                                                                                                                                                                                                                                                              	// GIDs of the process (Real, effective, saved set, and filesystem GIDs)
                                                                                                                                                                                                                                                                              	GIDs [4]string
                                                                                                                                                                                                                                                                              }

                                                                                                                                                                                                                                                                                ProcStatus provides status information about the process, read from /proc/[pid]/stat.

                                                                                                                                                                                                                                                                                func (ProcStatus) TotalCtxtSwitches

                                                                                                                                                                                                                                                                                func (s ProcStatus) TotalCtxtSwitches() uint64

                                                                                                                                                                                                                                                                                  TotalCtxtSwitches returns the total context switch.

                                                                                                                                                                                                                                                                                  type Procs

                                                                                                                                                                                                                                                                                  type Procs []Proc

                                                                                                                                                                                                                                                                                    Procs represents a list of Proc structs.

                                                                                                                                                                                                                                                                                    func AllProcs

                                                                                                                                                                                                                                                                                    func AllProcs() (Procs, error)

                                                                                                                                                                                                                                                                                      AllProcs returns a list of all currently available processes under /proc.

                                                                                                                                                                                                                                                                                      func (Procs) Len

                                                                                                                                                                                                                                                                                      func (p Procs) Len() int

                                                                                                                                                                                                                                                                                      func (Procs) Less

                                                                                                                                                                                                                                                                                      func (p Procs) Less(i, j int) bool

                                                                                                                                                                                                                                                                                      func (Procs) Swap

                                                                                                                                                                                                                                                                                      func (p Procs) Swap(i, j int)

                                                                                                                                                                                                                                                                                      type Schedstat

                                                                                                                                                                                                                                                                                      type Schedstat struct {
                                                                                                                                                                                                                                                                                      	CPUs []*SchedstatCPU
                                                                                                                                                                                                                                                                                      }

                                                                                                                                                                                                                                                                                        Schedstat contains scheduler statistics from /proc/schedstat

                                                                                                                                                                                                                                                                                        See https://www.kernel.org/doc/Documentation/scheduler/sched-stats.txt for a detailed description of what these numbers mean.

                                                                                                                                                                                                                                                                                        Note the current kernel documentation claims some of the time units are in jiffies when they are actually in nanoseconds since 2.6.23 with the introduction of CFS. A fix to the documentation is pending. See https://lore.kernel.org/patchwork/project/lkml/list/?series=403473

                                                                                                                                                                                                                                                                                        type SchedstatCPU

                                                                                                                                                                                                                                                                                        type SchedstatCPU struct {
                                                                                                                                                                                                                                                                                        	CPUNum string
                                                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                                                        	RunningNanoseconds uint64
                                                                                                                                                                                                                                                                                        	WaitingNanoseconds uint64
                                                                                                                                                                                                                                                                                        	RunTimeslices      uint64
                                                                                                                                                                                                                                                                                        }

                                                                                                                                                                                                                                                                                          SchedstatCPU contains the values from one "cpu<N>" line

                                                                                                                                                                                                                                                                                          type Slab

                                                                                                                                                                                                                                                                                          type Slab struct {
                                                                                                                                                                                                                                                                                          	Name         string
                                                                                                                                                                                                                                                                                          	ObjActive    int64
                                                                                                                                                                                                                                                                                          	ObjNum       int64
                                                                                                                                                                                                                                                                                          	ObjSize      int64
                                                                                                                                                                                                                                                                                          	ObjPerSlab   int64
                                                                                                                                                                                                                                                                                          	PagesPerSlab int64
                                                                                                                                                                                                                                                                                          	// tunables
                                                                                                                                                                                                                                                                                          	Limit        int64
                                                                                                                                                                                                                                                                                          	Batch        int64
                                                                                                                                                                                                                                                                                          	SharedFactor int64
                                                                                                                                                                                                                                                                                          	SlabActive   int64
                                                                                                                                                                                                                                                                                          	SlabNum      int64
                                                                                                                                                                                                                                                                                          	SharedAvail  int64
                                                                                                                                                                                                                                                                                          }

                                                                                                                                                                                                                                                                                            Slab represents a slab pool in the kernel.

                                                                                                                                                                                                                                                                                            type SlabInfo

                                                                                                                                                                                                                                                                                            type SlabInfo struct {
                                                                                                                                                                                                                                                                                            	Slabs []*Slab
                                                                                                                                                                                                                                                                                            }

                                                                                                                                                                                                                                                                                              SlabInfo represents info for all slabs.

                                                                                                                                                                                                                                                                                              type SoftIRQStat

                                                                                                                                                                                                                                                                                              type SoftIRQStat struct {
                                                                                                                                                                                                                                                                                              	Hi          uint64
                                                                                                                                                                                                                                                                                              	Timer       uint64
                                                                                                                                                                                                                                                                                              	NetTx       uint64
                                                                                                                                                                                                                                                                                              	NetRx       uint64
                                                                                                                                                                                                                                                                                              	Block       uint64
                                                                                                                                                                                                                                                                                              	BlockIoPoll uint64
                                                                                                                                                                                                                                                                                              	Tasklet     uint64
                                                                                                                                                                                                                                                                                              	Sched       uint64
                                                                                                                                                                                                                                                                                              	Hrtimer     uint64
                                                                                                                                                                                                                                                                                              	Rcu         uint64
                                                                                                                                                                                                                                                                                              }

                                                                                                                                                                                                                                                                                                SoftIRQStat represent the softirq statistics as exported in the procfs stat file. A nice introduction can be found at https://0xax.gitbooks.io/linux-insides/content/interrupts/interrupts-9.html It is possible to get per-cpu stats by reading /proc/softirqs

                                                                                                                                                                                                                                                                                                type SoftnetStat

                                                                                                                                                                                                                                                                                                type SoftnetStat struct {
                                                                                                                                                                                                                                                                                                	// Number of processed packets
                                                                                                                                                                                                                                                                                                	Processed uint32
                                                                                                                                                                                                                                                                                                	// Number of dropped packets
                                                                                                                                                                                                                                                                                                	Dropped uint32
                                                                                                                                                                                                                                                                                                	// Number of times processing packets ran out of quota
                                                                                                                                                                                                                                                                                                	TimeSqueezed uint32
                                                                                                                                                                                                                                                                                                }

                                                                                                                                                                                                                                                                                                  SoftnetStat contains a single row of data from /proc/net/softnet_stat

                                                                                                                                                                                                                                                                                                  type Stat

                                                                                                                                                                                                                                                                                                  type Stat struct {
                                                                                                                                                                                                                                                                                                  	// Boot time in seconds since the Epoch.
                                                                                                                                                                                                                                                                                                  	BootTime uint64
                                                                                                                                                                                                                                                                                                  	// Summed up cpu statistics.
                                                                                                                                                                                                                                                                                                  	CPUTotal CPUStat
                                                                                                                                                                                                                                                                                                  	// Per-CPU statistics.
                                                                                                                                                                                                                                                                                                  	CPU []CPUStat
                                                                                                                                                                                                                                                                                                  	// Number of times interrupts were handled, which contains numbered and unnumbered IRQs.
                                                                                                                                                                                                                                                                                                  	IRQTotal uint64
                                                                                                                                                                                                                                                                                                  	// Number of times a numbered IRQ was triggered.
                                                                                                                                                                                                                                                                                                  	IRQ []uint64
                                                                                                                                                                                                                                                                                                  	// Number of times a context switch happened.
                                                                                                                                                                                                                                                                                                  	ContextSwitches uint64
                                                                                                                                                                                                                                                                                                  	// Number of times a process was created.
                                                                                                                                                                                                                                                                                                  	ProcessCreated uint64
                                                                                                                                                                                                                                                                                                  	// Number of processes currently running.
                                                                                                                                                                                                                                                                                                  	ProcessesRunning uint64
                                                                                                                                                                                                                                                                                                  	// Number of processes currently blocked (waiting for IO).
                                                                                                                                                                                                                                                                                                  	ProcessesBlocked uint64
                                                                                                                                                                                                                                                                                                  	// Number of times a softirq was scheduled.
                                                                                                                                                                                                                                                                                                  	SoftIRQTotal uint64
                                                                                                                                                                                                                                                                                                  	// Detailed softirq statistics.
                                                                                                                                                                                                                                                                                                  	SoftIRQ SoftIRQStat
                                                                                                                                                                                                                                                                                                  }

                                                                                                                                                                                                                                                                                                    Stat represents kernel/system statistics.

                                                                                                                                                                                                                                                                                                    func NewStat

                                                                                                                                                                                                                                                                                                    func NewStat() (Stat, error)

                                                                                                                                                                                                                                                                                                      NewStat returns information about current cpu/process statistics. See https://www.kernel.org/doc/Documentation/filesystems/proc.txt

                                                                                                                                                                                                                                                                                                      Deprecated: use fs.Stat() instead

                                                                                                                                                                                                                                                                                                      type Swap

                                                                                                                                                                                                                                                                                                      type Swap struct {
                                                                                                                                                                                                                                                                                                      	Filename string
                                                                                                                                                                                                                                                                                                      	Type     string
                                                                                                                                                                                                                                                                                                      	Size     int
                                                                                                                                                                                                                                                                                                      	Used     int
                                                                                                                                                                                                                                                                                                      	Priority int
                                                                                                                                                                                                                                                                                                      }

                                                                                                                                                                                                                                                                                                        Swap represents an entry in /proc/swaps.

                                                                                                                                                                                                                                                                                                        type VM

                                                                                                                                                                                                                                                                                                        type VM struct {
                                                                                                                                                                                                                                                                                                        	AdminReserveKbytes        *int64   // /proc/sys/vm/admin_reserve_kbytes
                                                                                                                                                                                                                                                                                                        	BlockDump                 *int64   // /proc/sys/vm/block_dump
                                                                                                                                                                                                                                                                                                        	CompactUnevictableAllowed *int64   // /proc/sys/vm/compact_unevictable_allowed
                                                                                                                                                                                                                                                                                                        	DirtyBackgroundBytes      *int64   // /proc/sys/vm/dirty_background_bytes
                                                                                                                                                                                                                                                                                                        	DirtyBackgroundRatio      *int64   // /proc/sys/vm/dirty_background_ratio
                                                                                                                                                                                                                                                                                                        	DirtyBytes                *int64   // /proc/sys/vm/dirty_bytes
                                                                                                                                                                                                                                                                                                        	DirtyExpireCentisecs      *int64   // /proc/sys/vm/dirty_expire_centisecs
                                                                                                                                                                                                                                                                                                        	DirtyRatio                *int64   // /proc/sys/vm/dirty_ratio
                                                                                                                                                                                                                                                                                                        	DirtytimeExpireSeconds    *int64   // /proc/sys/vm/dirtytime_expire_seconds
                                                                                                                                                                                                                                                                                                        	DirtyWritebackCentisecs   *int64   // /proc/sys/vm/dirty_writeback_centisecs
                                                                                                                                                                                                                                                                                                        	DropCaches                *int64   // /proc/sys/vm/drop_caches
                                                                                                                                                                                                                                                                                                        	ExtfragThreshold          *int64   // /proc/sys/vm/extfrag_threshold
                                                                                                                                                                                                                                                                                                        	HugetlbShmGroup           *int64   // /proc/sys/vm/hugetlb_shm_group
                                                                                                                                                                                                                                                                                                        	LaptopMode                *int64   // /proc/sys/vm/laptop_mode
                                                                                                                                                                                                                                                                                                        	LegacyVaLayout            *int64   // /proc/sys/vm/legacy_va_layout
                                                                                                                                                                                                                                                                                                        	LowmemReserveRatio        []*int64 // /proc/sys/vm/lowmem_reserve_ratio
                                                                                                                                                                                                                                                                                                        	MaxMapCount               *int64   // /proc/sys/vm/max_map_count
                                                                                                                                                                                                                                                                                                        	MemoryFailureEarlyKill    *int64   // /proc/sys/vm/memory_failure_early_kill
                                                                                                                                                                                                                                                                                                        	MemoryFailureRecovery     *int64   // /proc/sys/vm/memory_failure_recovery
                                                                                                                                                                                                                                                                                                        	MinFreeKbytes             *int64   // /proc/sys/vm/min_free_kbytes
                                                                                                                                                                                                                                                                                                        	MinSlabRatio              *int64   // /proc/sys/vm/min_slab_ratio
                                                                                                                                                                                                                                                                                                        	MinUnmappedRatio          *int64   // /proc/sys/vm/min_unmapped_ratio
                                                                                                                                                                                                                                                                                                        	MmapMinAddr               *int64   // /proc/sys/vm/mmap_min_addr
                                                                                                                                                                                                                                                                                                        	NrHugepages               *int64   // /proc/sys/vm/nr_hugepages
                                                                                                                                                                                                                                                                                                        	NrHugepagesMempolicy      *int64   // /proc/sys/vm/nr_hugepages_mempolicy
                                                                                                                                                                                                                                                                                                        	NrOvercommitHugepages     *int64   // /proc/sys/vm/nr_overcommit_hugepages
                                                                                                                                                                                                                                                                                                        	NumaStat                  *int64   // /proc/sys/vm/numa_stat
                                                                                                                                                                                                                                                                                                        	NumaZonelistOrder         string   // /proc/sys/vm/numa_zonelist_order
                                                                                                                                                                                                                                                                                                        	OomDumpTasks              *int64   // /proc/sys/vm/oom_dump_tasks
                                                                                                                                                                                                                                                                                                        	OomKillAllocatingTask     *int64   // /proc/sys/vm/oom_kill_allocating_task
                                                                                                                                                                                                                                                                                                        	OvercommitKbytes          *int64   // /proc/sys/vm/overcommit_kbytes
                                                                                                                                                                                                                                                                                                        	OvercommitMemory          *int64   // /proc/sys/vm/overcommit_memory
                                                                                                                                                                                                                                                                                                        	OvercommitRatio           *int64   // /proc/sys/vm/overcommit_ratio
                                                                                                                                                                                                                                                                                                        	PageCluster               *int64   // /proc/sys/vm/page-cluster
                                                                                                                                                                                                                                                                                                        	PanicOnOom                *int64   // /proc/sys/vm/panic_on_oom
                                                                                                                                                                                                                                                                                                        	PercpuPagelistFraction    *int64   // /proc/sys/vm/percpu_pagelist_fraction
                                                                                                                                                                                                                                                                                                        	StatInterval              *int64   // /proc/sys/vm/stat_interval
                                                                                                                                                                                                                                                                                                        	Swappiness                *int64   // /proc/sys/vm/swappiness
                                                                                                                                                                                                                                                                                                        	UserReserveKbytes         *int64   // /proc/sys/vm/user_reserve_kbytes
                                                                                                                                                                                                                                                                                                        	VfsCachePressure          *int64   // /proc/sys/vm/vfs_cache_pressure
                                                                                                                                                                                                                                                                                                        	WatermarkBoostFactor      *int64   // /proc/sys/vm/watermark_boost_factor
                                                                                                                                                                                                                                                                                                        	WatermarkScaleFactor      *int64   // /proc/sys/vm/watermark_scale_factor
                                                                                                                                                                                                                                                                                                        	ZoneReclaimMode           *int64   // /proc/sys/vm/zone_reclaim_mode
                                                                                                                                                                                                                                                                                                        }

                                                                                                                                                                                                                                                                                                          The VM interface is described at

                                                                                                                                                                                                                                                                                                          https://www.kernel.org/doc/Documentation/sysctl/vm.txt
                                                                                                                                                                                                                                                                                                          

                                                                                                                                                                                                                                                                                                          Each setting is exposed as a single file. Each file contains one line with a single numerical value, except lowmem_reserve_ratio which holds an array and numa_zonelist_order (deprecated) which is a string

                                                                                                                                                                                                                                                                                                          type XfrmStat

                                                                                                                                                                                                                                                                                                          type XfrmStat struct {
                                                                                                                                                                                                                                                                                                          	// All errors which are not matched by other
                                                                                                                                                                                                                                                                                                          	XfrmInError int
                                                                                                                                                                                                                                                                                                          	// No buffer is left
                                                                                                                                                                                                                                                                                                          	XfrmInBufferError int
                                                                                                                                                                                                                                                                                                          	// Header Error
                                                                                                                                                                                                                                                                                                          	XfrmInHdrError int
                                                                                                                                                                                                                                                                                                          	// No state found
                                                                                                                                                                                                                                                                                                          	// i.e. either inbound SPI, address, or IPSEC protocol at SA is wrong
                                                                                                                                                                                                                                                                                                          	XfrmInNoStates int
                                                                                                                                                                                                                                                                                                          	// Transformation protocol specific error
                                                                                                                                                                                                                                                                                                          	// e.g. SA Key is wrong
                                                                                                                                                                                                                                                                                                          	XfrmInStateProtoError int
                                                                                                                                                                                                                                                                                                          	// Transformation mode specific error
                                                                                                                                                                                                                                                                                                          	XfrmInStateModeError int
                                                                                                                                                                                                                                                                                                          	// Sequence error
                                                                                                                                                                                                                                                                                                          	// e.g. sequence number is out of window
                                                                                                                                                                                                                                                                                                          	XfrmInStateSeqError int
                                                                                                                                                                                                                                                                                                          	// State is expired
                                                                                                                                                                                                                                                                                                          	XfrmInStateExpired int
                                                                                                                                                                                                                                                                                                          	// State has mismatch option
                                                                                                                                                                                                                                                                                                          	// e.g. UDP encapsulation type is mismatched
                                                                                                                                                                                                                                                                                                          	XfrmInStateMismatch int
                                                                                                                                                                                                                                                                                                          	// State is invalid
                                                                                                                                                                                                                                                                                                          	XfrmInStateInvalid int
                                                                                                                                                                                                                                                                                                          	// No matching template for states
                                                                                                                                                                                                                                                                                                          	// e.g. Inbound SAs are correct but SP rule is wrong
                                                                                                                                                                                                                                                                                                          	XfrmInTmplMismatch int
                                                                                                                                                                                                                                                                                                          	// No policy is found for states
                                                                                                                                                                                                                                                                                                          	// e.g. Inbound SAs are correct but no SP is found
                                                                                                                                                                                                                                                                                                          	XfrmInNoPols int
                                                                                                                                                                                                                                                                                                          	// Policy discards
                                                                                                                                                                                                                                                                                                          	XfrmInPolBlock int
                                                                                                                                                                                                                                                                                                          	// Policy error
                                                                                                                                                                                                                                                                                                          	XfrmInPolError int
                                                                                                                                                                                                                                                                                                          	// All errors which are not matched by others
                                                                                                                                                                                                                                                                                                          	XfrmOutError int
                                                                                                                                                                                                                                                                                                          	// Bundle generation error
                                                                                                                                                                                                                                                                                                          	XfrmOutBundleGenError int
                                                                                                                                                                                                                                                                                                          	// Bundle check error
                                                                                                                                                                                                                                                                                                          	XfrmOutBundleCheckError int
                                                                                                                                                                                                                                                                                                          	// No state was found
                                                                                                                                                                                                                                                                                                          	XfrmOutNoStates int
                                                                                                                                                                                                                                                                                                          	// Transformation protocol specific error
                                                                                                                                                                                                                                                                                                          	XfrmOutStateProtoError int
                                                                                                                                                                                                                                                                                                          	// Transportation mode specific error
                                                                                                                                                                                                                                                                                                          	XfrmOutStateModeError int
                                                                                                                                                                                                                                                                                                          	// Sequence error
                                                                                                                                                                                                                                                                                                          	// i.e sequence number overflow
                                                                                                                                                                                                                                                                                                          	XfrmOutStateSeqError int
                                                                                                                                                                                                                                                                                                          	// State is expired
                                                                                                                                                                                                                                                                                                          	XfrmOutStateExpired int
                                                                                                                                                                                                                                                                                                          	// Policy discads
                                                                                                                                                                                                                                                                                                          	XfrmOutPolBlock int
                                                                                                                                                                                                                                                                                                          	// Policy is dead
                                                                                                                                                                                                                                                                                                          	XfrmOutPolDead int
                                                                                                                                                                                                                                                                                                          	// Policy Error
                                                                                                                                                                                                                                                                                                          	XfrmOutPolError     int
                                                                                                                                                                                                                                                                                                          	XfrmFwdHdrError     int
                                                                                                                                                                                                                                                                                                          	XfrmOutStateInvalid int
                                                                                                                                                                                                                                                                                                          	XfrmAcquireError    int
                                                                                                                                                                                                                                                                                                          }

                                                                                                                                                                                                                                                                                                            XfrmStat models the contents of /proc/net/xfrm_stat.

                                                                                                                                                                                                                                                                                                            func NewXfrmStat

                                                                                                                                                                                                                                                                                                            func NewXfrmStat() (XfrmStat, error)

                                                                                                                                                                                                                                                                                                              NewXfrmStat reads the xfrm_stat statistics.

                                                                                                                                                                                                                                                                                                              type Zoneinfo

                                                                                                                                                                                                                                                                                                              type Zoneinfo struct {
                                                                                                                                                                                                                                                                                                              	Node                       string
                                                                                                                                                                                                                                                                                                              	Zone                       string
                                                                                                                                                                                                                                                                                                              	NrFreePages                *int64
                                                                                                                                                                                                                                                                                                              	Min                        *int64
                                                                                                                                                                                                                                                                                                              	Low                        *int64
                                                                                                                                                                                                                                                                                                              	High                       *int64
                                                                                                                                                                                                                                                                                                              	Scanned                    *int64
                                                                                                                                                                                                                                                                                                              	Spanned                    *int64
                                                                                                                                                                                                                                                                                                              	Present                    *int64
                                                                                                                                                                                                                                                                                                              	Managed                    *int64
                                                                                                                                                                                                                                                                                                              	NrActiveAnon               *int64
                                                                                                                                                                                                                                                                                                              	NrInactiveAnon             *int64
                                                                                                                                                                                                                                                                                                              	NrIsolatedAnon             *int64
                                                                                                                                                                                                                                                                                                              	NrAnonPages                *int64
                                                                                                                                                                                                                                                                                                              	NrAnonTransparentHugepages *int64
                                                                                                                                                                                                                                                                                                              	NrActiveFile               *int64
                                                                                                                                                                                                                                                                                                              	NrInactiveFile             *int64
                                                                                                                                                                                                                                                                                                              	NrIsolatedFile             *int64
                                                                                                                                                                                                                                                                                                              	NrFilePages                *int64
                                                                                                                                                                                                                                                                                                              	NrSlabReclaimable          *int64
                                                                                                                                                                                                                                                                                                              	NrSlabUnreclaimable        *int64
                                                                                                                                                                                                                                                                                                              	NrMlockStack               *int64
                                                                                                                                                                                                                                                                                                              	NrKernelStack              *int64
                                                                                                                                                                                                                                                                                                              	NrMapped                   *int64
                                                                                                                                                                                                                                                                                                              	NrDirty                    *int64
                                                                                                                                                                                                                                                                                                              	NrWriteback                *int64
                                                                                                                                                                                                                                                                                                              	NrUnevictable              *int64
                                                                                                                                                                                                                                                                                                              	NrShmem                    *int64
                                                                                                                                                                                                                                                                                                              	NrDirtied                  *int64
                                                                                                                                                                                                                                                                                                              	NrWritten                  *int64
                                                                                                                                                                                                                                                                                                              	NumaHit                    *int64
                                                                                                                                                                                                                                                                                                              	NumaMiss                   *int64
                                                                                                                                                                                                                                                                                                              	NumaForeign                *int64
                                                                                                                                                                                                                                                                                                              	NumaInterleave             *int64
                                                                                                                                                                                                                                                                                                              	NumaLocal                  *int64
                                                                                                                                                                                                                                                                                                              	NumaOther                  *int64
                                                                                                                                                                                                                                                                                                              	Protection                 []*int64
                                                                                                                                                                                                                                                                                                              }

                                                                                                                                                                                                                                                                                                                Zoneinfo holds info parsed from /proc/zoneinfo.

                                                                                                                                                                                                                                                                                                                GOOS=linux, GOARCH=amd64

                                                                                                                                                                                                                                                                                                                Directories

                                                                                                                                                                                                                                                                                                                Path Synopsis
                                                                                                                                                                                                                                                                                                                Package bcache provides access to statistics exposed by the bcache (Linux block cache).
                                                                                                                                                                                                                                                                                                                Package bcache provides access to statistics exposed by the bcache (Linux block cache).
                                                                                                                                                                                                                                                                                                                Package btrfs provides access to statistics exposed by Btrfs filesystems.
                                                                                                                                                                                                                                                                                                                Package btrfs provides access to statistics exposed by Btrfs filesystems.
                                                                                                                                                                                                                                                                                                                internal
                                                                                                                                                                                                                                                                                                                fs
                                                                                                                                                                                                                                                                                                                Package nfs implements parsing of /proc/net/rpc/nfsd.
                                                                                                                                                                                                                                                                                                                Package nfs implements parsing of /proc/net/rpc/nfsd.
                                                                                                                                                                                                                                                                                                                Package sysfs provides functions to retrieve system and kernel metrics from the pseudo-filesystem sys.
                                                                                                                                                                                                                                                                                                                Package sysfs provides functions to retrieve system and kernel metrics from the pseudo-filesystem sys.
                                                                                                                                                                                                                                                                                                                Package xfs provides access to statistics exposed by the XFS filesystem.
                                                                                                                                                                                                                                                                                                                Package xfs provides access to statistics exposed by the XFS filesystem.