source: code/trunk/vendor/github.com/prometheus/procfs/mountstats.go@ 824

// Copyright 2018 The Prometheus Authors
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.

package procfs

// While implementing parsing of /proc/[pid]/mountstats, this blog was used
// heavily as a reference:
//   https://utcc.utoronto.ca/~cks/space/blog/linux/NFSMountstatsIndex
//
// Special thanks to Chris Siebenmann for all of his posts explaining the
// various statistics available for NFS.

import (
        "bufio"
        "fmt"
        "io"
        "strconv"
        "strings"
        "time"
)

// Constants shared between multiple functions.
const (
        deviceEntryLen = 8

        fieldBytesLen  = 8
        fieldEventsLen = 27

        statVersion10 = "1.0"
        statVersion11 = "1.1"

        fieldTransport10TCPLen = 10
        fieldTransport10UDPLen = 7

        fieldTransport11TCPLen = 13
        fieldTransport11UDPLen = 10
)

// A Mount is a device mount parsed from /proc/[pid]/mountstats.
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 MountStats is a type which contains detailed statistics for a specific
// type of Mount.
type MountStats interface {
        mountStats()
}

// A MountStatsNFS is a MountStats implementation for NFSv3 and v4 mounts.
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
}

// mountStats implements MountStats.
func (m MountStatsNFS) mountStats() {}

// A NFSBytesStats contains statistics about the number of bytes read and written
// by an NFS client to and from an NFS server.
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 NFSEventsStats contains statistics about NFS event occurrences.
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 NFSOperationStats contains statistics for a single operation.
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 NFSTransportStats contains statistics for the NFS mount RPC requests and
// responses.
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

        // Stats below only available with stat version 1.1.

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

// parseMountStats parses a /proc/[pid]/mountstats file and returns a slice
// of Mount structures containing detailed information about each mount.
// If available, statistics for each mount are parsed as well.
func parseMountStats(r io.Reader) ([]*Mount, error) {
        const (
                device            = "device"
                statVersionPrefix = "statvers="

                nfs3Type = "nfs"
                nfs4Type = "nfs4"
        )

        var mounts []*Mount

        s := bufio.NewScanner(r)
        for s.Scan() {
                // Only look for device entries in this function
                ss := strings.Fields(string(s.Bytes()))
                if len(ss) == 0 || ss[0] != device {
                        continue
                }

                m, err := parseMount(ss)
                if err != nil {
                        return nil, err
                }

                // Does this mount also possess statistics information?
                if len(ss) > deviceEntryLen {
                        // Only NFSv3 and v4 are supported for parsing statistics
                        if m.Type != nfs3Type && m.Type != nfs4Type {
                                return nil, fmt.Errorf("cannot parse MountStats for fstype %q", m.Type)
                        }

                        statVersion := strings.TrimPrefix(ss[8], statVersionPrefix)

                        stats, err := parseMountStatsNFS(s, statVersion)
                        if err != nil {
                                return nil, err
                        }

                        m.Stats = stats
                }

                mounts = append(mounts, m)
        }

        return mounts, s.Err()
}

// parseMount parses an entry in /proc/[pid]/mountstats in the format:
//   device [device] mounted on [mount] with fstype [type]
func parseMount(ss []string) (*Mount, error) {
        if len(ss) < deviceEntryLen {
                return nil, fmt.Errorf("invalid device entry: %v", ss)
        }

        // Check for specific words appearing at specific indices to ensure
        // the format is consistent with what we expect
        format := []struct {
                i int
                s string
        }{
                {i: 0, s: "device"},
                {i: 2, s: "mounted"},
                {i: 3, s: "on"},
                {i: 5, s: "with"},
                {i: 6, s: "fstype"},
        }

        for _, f := range format {
                if ss[f.i] != f.s {
                        return nil, fmt.Errorf("invalid device entry: %v", ss)
                }
        }

        return &Mount{
                Device: ss[1],
                Mount:  ss[4],
                Type:   ss[7],
        }, nil
}

// parseMountStatsNFS parses a MountStatsNFS by scanning additional information
// related to NFS statistics.
func parseMountStatsNFS(s *bufio.Scanner, statVersion string) (*MountStatsNFS, error) {
        // Field indicators for parsing specific types of data
        const (
                fieldOpts       = "opts:"
                fieldAge        = "age:"
                fieldBytes      = "bytes:"
                fieldEvents     = "events:"
                fieldPerOpStats = "per-op"
                fieldTransport  = "xprt:"
        )

        stats := &MountStatsNFS{
                StatVersion: statVersion,
        }

        for s.Scan() {
                ss := strings.Fields(string(s.Bytes()))
                if len(ss) == 0 {
                        break
                }

                switch ss[0] {
                case fieldOpts:
                        if len(ss) < 2 {
                                return nil, fmt.Errorf("not enough information for NFS stats: %v", ss)
                        }
                        if stats.Opts == nil {
                                stats.Opts = map[string]string{}
                        }
                        for _, opt := range strings.Split(ss[1], ",") {
                                split := strings.Split(opt, "=")
                                if len(split) == 2 {
                                        stats.Opts[split[0]] = split[1]
                                } else {
                                        stats.Opts[opt] = ""
                                }
                        }
                case fieldAge:
                        if len(ss) < 2 {
                                return nil, fmt.Errorf("not enough information for NFS stats: %v", ss)
                        }
                        // Age integer is in seconds
                        d, err := time.ParseDuration(ss[1] + "s")
                        if err != nil {
                                return nil, err
                        }

                        stats.Age = d
                case fieldBytes:
                        if len(ss) < 2 {
                                return nil, fmt.Errorf("not enough information for NFS stats: %v", ss)
                        }
                        bstats, err := parseNFSBytesStats(ss[1:])
                        if err != nil {
                                return nil, err
                        }

                        stats.Bytes = *bstats
                case fieldEvents:
                        if len(ss) < 2 {
                                return nil, fmt.Errorf("not enough information for NFS stats: %v", ss)
                        }
                        estats, err := parseNFSEventsStats(ss[1:])
                        if err != nil {
                                return nil, err
                        }

                        stats.Events = *estats
                case fieldTransport:
                        if len(ss) < 3 {
                                return nil, fmt.Errorf("not enough information for NFS transport stats: %v", ss)
                        }

                        tstats, err := parseNFSTransportStats(ss[1:], statVersion)
                        if err != nil {
                                return nil, err
                        }

                        stats.Transport = *tstats
                }

                // When encountering "per-operation statistics", we must break this
                // loop and parse them separately to ensure we can terminate parsing
                // before reaching another device entry; hence why this 'if' statement
                // is not just another switch case
                if ss[0] == fieldPerOpStats {
                        break
                }
        }

        if err := s.Err(); err != nil {
                return nil, err
        }

        // NFS per-operation stats appear last before the next device entry
        perOpStats, err := parseNFSOperationStats(s)
        if err != nil {
                return nil, err
        }

        stats.Operations = perOpStats

        return stats, nil
}

// parseNFSBytesStats parses a NFSBytesStats line using an input set of
// integer fields.
func parseNFSBytesStats(ss []string) (*NFSBytesStats, error) {
        if len(ss) != fieldBytesLen {
                return nil, fmt.Errorf("invalid NFS bytes stats: %v", ss)
        }

        ns := make([]uint64, 0, fieldBytesLen)
        for _, s := range ss {
                n, err := strconv.ParseUint(s, 10, 64)
                if err != nil {
                        return nil, err
                }

                ns = append(ns, n)
        }

        return &NFSBytesStats{
                Read:        ns[0],
                Write:       ns[1],
                DirectRead:  ns[2],
                DirectWrite: ns[3],
                ReadTotal:   ns[4],
                WriteTotal:  ns[5],
                ReadPages:   ns[6],
                WritePages:  ns[7],
        }, nil
}

// parseNFSEventsStats parses a NFSEventsStats line using an input set of
// integer fields.
func parseNFSEventsStats(ss []string) (*NFSEventsStats, error) {
        if len(ss) != fieldEventsLen {
                return nil, fmt.Errorf("invalid NFS events stats: %v", ss)
        }

        ns := make([]uint64, 0, fieldEventsLen)
        for _, s := range ss {
                n, err := strconv.ParseUint(s, 10, 64)
                if err != nil {
                        return nil, err
                }

                ns = append(ns, n)
        }

        return &NFSEventsStats{
                InodeRevalidate:     ns[0],
                DnodeRevalidate:     ns[1],
                DataInvalidate:      ns[2],
                AttributeInvalidate: ns[3],
                VFSOpen:             ns[4],
                VFSLookup:           ns[5],
                VFSAccess:           ns[6],
                VFSUpdatePage:       ns[7],
                VFSReadPage:         ns[8],
                VFSReadPages:        ns[9],
                VFSWritePage:        ns[10],
                VFSWritePages:       ns[11],
                VFSGetdents:         ns[12],
                VFSSetattr:          ns[13],
                VFSFlush:            ns[14],
                VFSFsync:            ns[15],
                VFSLock:             ns[16],
                VFSFileRelease:      ns[17],
                CongestionWait:      ns[18],
                Truncation:          ns[19],
                WriteExtension:      ns[20],
                SillyRename:         ns[21],
                ShortRead:           ns[22],
                ShortWrite:          ns[23],
                JukeboxDelay:        ns[24],
                PNFSRead:            ns[25],
                PNFSWrite:           ns[26],
        }, nil
}

// parseNFSOperationStats parses a slice of NFSOperationStats by scanning
// additional information about per-operation statistics until an empty
// line is reached.
func parseNFSOperationStats(s *bufio.Scanner) ([]NFSOperationStats, error) {
        const (
                // Minimum number of expected fields in each per-operation statistics set
                minFields = 9
        )

        var ops []NFSOperationStats

        for s.Scan() {
                ss := strings.Fields(string(s.Bytes()))
                if len(ss) == 0 {
                        // Must break when reading a blank line after per-operation stats to
                        // enable top-level function to parse the next device entry
                        break
                }

                if len(ss) < minFields {
                        return nil, fmt.Errorf("invalid NFS per-operations stats: %v", ss)
                }

                // Skip string operation name for integers
                ns := make([]uint64, 0, minFields-1)
                for _, st := range ss[1:] {
                        n, err := strconv.ParseUint(st, 10, 64)
                        if err != nil {
                                return nil, err
                        }

                        ns = append(ns, n)
                }

                opStats := NFSOperationStats{
                        Operation:                           strings.TrimSuffix(ss[0], ":"),
                        Requests:                            ns[0],
                        Transmissions:                       ns[1],
                        MajorTimeouts:                       ns[2],
                        BytesSent:                           ns[3],
                        BytesReceived:                       ns[4],
                        CumulativeQueueMilliseconds:         ns[5],
                        CumulativeTotalResponseMilliseconds: ns[6],
                        CumulativeTotalRequestMilliseconds:  ns[7],
                }

                if len(ns) > 8 {
                        opStats.Errors = ns[8]
                }

                ops = append(ops, opStats)
        }

        return ops, s.Err()
}

// parseNFSTransportStats parses a NFSTransportStats line using an input set of
// integer fields matched to a specific stats version.
func parseNFSTransportStats(ss []string, statVersion string) (*NFSTransportStats, error) {
        // Extract the protocol field. It is the only string value in the line
        protocol := ss[0]
        ss = ss[1:]

        switch statVersion {
        case statVersion10:
                var expectedLength int
                if protocol == "tcp" {
                        expectedLength = fieldTransport10TCPLen
                } else if protocol == "udp" {
                        expectedLength = fieldTransport10UDPLen
                } else {
                        return nil, fmt.Errorf("invalid NFS protocol \"%s\" in stats 1.0 statement: %v", protocol, ss)
                }
                if len(ss) != expectedLength {
                        return nil, fmt.Errorf("invalid NFS transport stats 1.0 statement: %v", ss)
                }
        case statVersion11:
                var expectedLength int
                if protocol == "tcp" {
                        expectedLength = fieldTransport11TCPLen
                } else if protocol == "udp" {
                        expectedLength = fieldTransport11UDPLen
                } else {
                        return nil, fmt.Errorf("invalid NFS protocol \"%s\" in stats 1.1 statement: %v", protocol, ss)
                }
                if len(ss) != expectedLength {
                        return nil, fmt.Errorf("invalid NFS transport stats 1.1 statement: %v", ss)
                }
        default:
                return nil, fmt.Errorf("unrecognized NFS transport stats version: %q", statVersion)
        }

        // Allocate enough for v1.1 stats since zero value for v1.1 stats will be okay
        // in a v1.0 response. Since the stat length is bigger for TCP stats, we use
        // the TCP length here.
        //
        // Note: slice length must be set to length of v1.1 stats to avoid a panic when
        // only v1.0 stats are present.
        // See: https://github.com/prometheus/node_exporter/issues/571.
        ns := make([]uint64, fieldTransport11TCPLen)
        for i, s := range ss {
                n, err := strconv.ParseUint(s, 10, 64)
                if err != nil {
                        return nil, err
                }

                ns[i] = n
        }

        // The fields differ depending on the transport protocol (TCP or UDP)
        // From https://utcc.utoronto.ca/%7Ecks/space/blog/linux/NFSMountstatsXprt
        //
        // For the udp RPC transport there is no connection count, connect idle time,
        // or idle time (fields #3, #4, and #5); all other fields are the same. So
        // we set them to 0 here.
        if protocol == "udp" {
                ns = append(ns[:2], append(make([]uint64, 3), ns[2:]...)...)
        }

        return &NFSTransportStats{
                Protocol:                 protocol,
                Port:                     ns[0],
                Bind:                     ns[1],
                Connect:                  ns[2],
                ConnectIdleTime:          ns[3],
                IdleTimeSeconds:          ns[4],
                Sends:                    ns[5],
                Receives:                 ns[6],
                BadTransactionIDs:        ns[7],
                CumulativeActiveRequests: ns[8],
                CumulativeBacklog:        ns[9],
                MaximumRPCSlotsUsed:      ns[10],
                CumulativeSendingQueue:   ns[11],
                CumulativePendingQueue:   ns[12],
        }, nil
}