procfs

package module
v0.0.11 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Mar 17, 2020 License: Apache-2.0 Imports: 17 Imported by: 1,505

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.

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 added in v0.0.4 

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 added in v0.0.5 

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 ConntrackStatEntry added in v0.0.9 

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 added in v0.0.4 

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 added in v0.0.2 

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 added in v0.0.2 

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

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

func (FS) CPUInfo added in v0.0.5 

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 added in v0.0.9 

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

Retrieves netfilter's conntrack statistics, split by CPU cores

func (FS) Crypto added in v0.0.4 

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) GatherARPEntries added in v0.0.4 

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 added in v0.0.2 

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 added in v0.0.2 

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

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

func (FS) LoadAvg added in v0.0.9 

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

LoadAvg returns loadavg from /proc.

func (FS) MDStat added in v0.0.2 

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 added in v0.0.6 

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 added in v0.0.2 

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

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

func (FS) NetSockstat added in v0.0.8 

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

NetSockstat retrieves IPv4 socket statistics.

func (FS) NetSockstat6 added in v0.0.8 

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 added in v0.0.9 

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

NetSoftnetStat reads data from /proc/net/softnet_stat.

func (FS) NetUDP added in v0.0.9 

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

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

func (FS) NetUDP6 added in v0.0.9 

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

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

func (FS) NetUDP6Summary added in v0.0.9 

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 added in v0.0.9 

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 added in v0.0.9 

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

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

func (FS) NewProc deprecated 

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

NewProc returns a process for the given pid.

Deprecated: use fs.Proc() instead

func (FS) NewStat deprecated 

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 added in v0.0.2 

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 added in v0.0.2 

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

Proc returns a process for the given pid.

func (FS) Schedstat added in v0.0.4 

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) Stat added in v0.0.2 

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 added in v0.0.9 

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

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

func (FS) VM added in v0.0.4 

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

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

func (FS) Zoneinfo added in v0.0.4 

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 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 added in v0.0.4 

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 LoadAvg added in v0.0.9 

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
}

MDStat holds info parsed from /proc/mdstat.

type Meminfo added in v0.0.6 

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 added in v0.0.3 

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 added in v0.0.3 

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

Retrieves mountinfo information from `/proc/self/mountinfo`.

func GetProcMounts added in v0.0.3 

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

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
}

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 NetSockstat added in v0.0.8 

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 added in v0.0.8 

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 NetUDP added in v0.0.9 

type NetUDP []*netUDPLine

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

type NetUDPSummary added in v0.0.9 

type NetUDPSummary 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
}

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 added in v0.0.9 

type NetUNIX struct {
	Rows []*NetUNIXLine
}

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

type NetUNIXFlags added in v0.0.9 

type NetUNIXFlags uint64

NetUNIXFlags is the type of the flags field.

func (NetUNIXFlags) String added in v0.0.9 

func (f NetUNIXFlags) String() string

type NetUNIXLine added in v0.0.9 

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 added in v0.0.9 

type NetUNIXState uint64

NetUNIXState is the type of the state field.

func (NetUNIXState) String added in v0.0.9 

func (s NetUNIXState) String() string

type NetUNIXType added in v0.0.9 

type NetUNIXType uint64

NetUNIXType is the type of the type field.

func (NetUNIXType) String added in v0.0.9 

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) 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 added in v0.0.3 

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 added in v0.0.4 

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 added in v0.0.4 

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 added in v0.0.2 

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

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

func (Proc) Limits added in v0.0.2 

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

Limits returns the current soft limits of the process.

func (Proc) MountInfo added in v0.0.3 

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 added in v0.0.2 

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 added in v0.0.2 

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

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

func (Proc) NewLimits deprecated 

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

NewLimits returns the current soft limits of the process.

Deprecated: use p.Limits() instead

func (Proc) NewStat deprecated 

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 added in v0.0.11 

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

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

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 added in v0.0.4 

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

Schedstat returns task scheduling information for the process.

func (Proc) Stat added in v0.0.2 

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

Stat returns the current status information of the process.

type ProcFDInfo added in v0.0.4 

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 (structed) in the fdinfo file (kernel 3.8+ only)
	InotifyInfos []InotifyInfo
}

ProcFDInfo contains represents file descriptor information.

type ProcFDInfos added in v0.0.4 

type ProcFDInfos []ProcFDInfo

ProcFDInfos represents a list of ProcFDInfo structs.

func (ProcFDInfos) InotifyWatchLen added in v0.0.4 

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

InotifyWatchLen returns the total number of inotify watches

func (ProcFDInfos) Len added in v0.0.4 

func (p ProcFDInfos) Len() int

func (ProcFDInfos) Less added in v0.0.4 

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

func (ProcFDInfos) Swap added in v0.0.4 

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 int64
	// Maximum size of files that the process may create.
	FileSize int64
	// Maximum size of the process's data segment (initialized data,
	// uninitialized data, and heap).
	DataSize int64
	// Maximum size of the process stack in bytes.
	StackSize int64
	// Maximum size of a core file.
	CoreFileSize int64
	// Limit of the process's resident set in pages.
	ResidentSet int64
	// Maximum number of processes that can be created for the real user ID of
	// the calling process.
	Processes int64
	// Value one greater than the maximum file descriptor number that can be
	// opened by this process.
	OpenFiles int64
	// Maximum number of bytes of memory that may be locked into RAM.
	LockedMemory int64
	// Maximum size of the process's virtual memory address space in bytes.
	AddressSpace int64
	// Limit on the combined number of flock(2) locks and fcntl(2) leases that
	// this process may establish.
	FileLocks int64
	// Limit of signals that may be queued for the real user ID of the calling
	// process.
	PendingSignals int64
	// Limit on the number of bytes that can be allocated for POSIX message
	// queues for the real user ID of the calling process.
	MsqqueueSize int64
	// Limit of the nice priority set using setpriority(2) or nice(2).
	NicePriority int64
	// Limit of the real-time priority set using sched_setscheduler(2) or
	// sched_setparam(2).
	RealtimePriority int64
	// 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 int64
}

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 added in v0.0.11 

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 added in v0.0.11 

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
}

type ProcSchedstat added in v0.0.4 

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 (GIDs))
	UIDs [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 added in v0.0.4 

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 added in v0.0.4 

type SchedstatCPU struct {
	CPUNum string

	RunningNanoseconds uint64
	WaitingNanoseconds uint64
	RunTimeslices      uint64
}

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

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 added in v0.0.9 

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 deprecated 

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 added in v0.0.9 

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

Swap represents an entry in /proc/swaps.

type VM added in v0.0.4 

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 added in v0.0.4 

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.

Source Files

View all Source files

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
util
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.

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.