Wala shell

Advanced PHP File Manager

Server IP: 127.0.0.1 | PHP Version: 8.3.30 | Domains Hosted: 54

Name	Size	Last Modified	Actions
📁 ..	-	2025-05-25 12:27
📄 parse.go // Copyright 2017 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 xfs import ( "bufio" "fmt" "io" "strings" "github.com/prometheus/procfs/internal/util" ) // ParseStats parses a Stats from an input io.Reader, using the format // found in /proc/fs/xfs/stat. func ParseStats(r io.Reader) (*Stats, error) { const ( // Fields parsed into stats structures. fieldExtentAlloc = "extent_alloc" fieldAbt = "abt" fieldBlkMap = "blk_map" fieldBmbt = "bmbt" fieldDir = "dir" fieldTrans = "trans" fieldIg = "ig" fieldLog = "log" fieldPushAil = "push_ail" fieldXstrat = "xstrat" fieldRw = "rw" fieldAttr = "attr" fieldIcluster = "icluster" fieldVnodes = "vnodes" fieldBuf = "buf" fieldXpc = "xpc" fieldAbtb2 = "abtb2" fieldAbtc2 = "abtc2" fieldBmbt2 = "bmbt2" fieldIbt2 = "ibt2" //fieldFibt2 = "fibt2" fieldQm = "qm" fieldDebug = "debug" // Unimplemented at this time due to lack of documentation. //fieldRmapbt = "rmapbt" //fieldRefcntbt = "refcntbt" ) var xfss Stats s := bufio.NewScanner(r) for s.Scan() { // Expect at least a string label and a single integer value, ex: // - abt 0 // - rw 1 2 ss := strings.Fields(string(s.Bytes())) if len(ss) < 2 { continue } label := ss[0] // Extended precision counters are uint64 values. if label == fieldXpc { us, err := util.ParseUint64s(ss[1:]) if err != nil { return nil, err } xfss.ExtendedPrecision, err = extendedPrecisionStats(us) if err != nil { return nil, err } continue } // All other counters are uint32 values. us, err := util.ParseUint32s(ss[1:]) if err != nil { return nil, err } switch label { case fieldExtentAlloc: xfss.ExtentAllocation, err = extentAllocationStats(us) case fieldAbt: xfss.AllocationBTree, err = btreeStats(us) case fieldBlkMap: xfss.BlockMapping, err = blockMappingStats(us) case fieldBmbt: xfss.BlockMapBTree, err = btreeStats(us) case fieldDir: xfss.DirectoryOperation, err = directoryOperationStats(us) case fieldTrans: xfss.Transaction, err = transactionStats(us) case fieldIg: xfss.InodeOperation, err = inodeOperationStats(us) case fieldLog: xfss.LogOperation, err = logOperationStats(us) case fieldRw: xfss.ReadWrite, err = readWriteStats(us) case fieldAttr: xfss.AttributeOperation, err = attributeOperationStats(us) case fieldIcluster: xfss.InodeClustering, err = inodeClusteringStats(us) case fieldVnodes: xfss.Vnode, err = vnodeStats(us) case fieldBuf: xfss.Buffer, err = bufferStats(us) case fieldPushAil: xfss.PushAil, err = pushAilStats(us) case fieldXstrat: xfss.Xstrat, err = xStratStats(us) case fieldAbtb2: xfss.BtreeAllocBlocks2, err = btreeAllocBlocks2Stats(us) case fieldAbtc2: xfss.BtreeAllocContig2, err = btreeAllocContig2Stats(us) case fieldBmbt2: xfss.BtreeBlockMap2, err = btreeBlockMap2Stats(us) case fieldIbt2: xfss.BtreeInode2, err = btreeInode2Stats(us) //case fieldFibt2: case fieldQm: xfss.QuotaManager, err = quotaManagerStats(us) case fieldDebug: xfss.Debug, err = debugStats(us) } if err != nil { return nil, err } } return &xfss, s.Err() } // extentAllocationStats builds an ExtentAllocationStats from a slice of uint32s. func extentAllocationStats(us []uint32) (ExtentAllocationStats, error) { if l := len(us); l != 4 { return ExtentAllocationStats{}, fmt.Errorf("incorrect number of values for XFS extent allocation stats: %d", l) } return ExtentAllocationStats{ ExtentsAllocated: us[0], BlocksAllocated: us[1], ExtentsFreed: us[2], BlocksFreed: us[3], }, nil } // btreeStats builds a BTreeStats from a slice of uint32s. func btreeStats(us []uint32) (BTreeStats, error) { if l := len(us); l != 4 { return BTreeStats{}, fmt.Errorf("incorrect number of values for XFS btree stats: %d", l) } return BTreeStats{ Lookups: us[0], Compares: us[1], RecordsInserted: us[2], RecordsDeleted: us[3], }, nil } // BlockMappingStat builds a BlockMappingStats from a slice of uint32s. func blockMappingStats(us []uint32) (BlockMappingStats, error) { if l := len(us); l != 7 { return BlockMappingStats{}, fmt.Errorf("incorrect number of values for XFS block mapping stats: %d", l) } return BlockMappingStats{ Reads: us[0], Writes: us[1], Unmaps: us[2], ExtentListInsertions: us[3], ExtentListDeletions: us[4], ExtentListLookups: us[5], ExtentListCompares: us[6], }, nil } // DirectoryOperationStats builds a DirectoryOperationStats from a slice of uint32s. func directoryOperationStats(us []uint32) (DirectoryOperationStats, error) { if l := len(us); l != 4 { return DirectoryOperationStats{}, fmt.Errorf("incorrect number of values for XFS directory operation stats: %d", l) } return DirectoryOperationStats{ Lookups: us[0], Creates: us[1], Removes: us[2], Getdents: us[3], }, nil } // TransactionStats builds a TransactionStats from a slice of uint32s. func transactionStats(us []uint32) (TransactionStats, error) { if l := len(us); l != 3 { return TransactionStats{}, fmt.Errorf("incorrect number of values for XFS transaction stats: %d", l) } return TransactionStats{ Sync: us[0], Async: us[1], Empty: us[2], }, nil } // InodeOperationStats builds an InodeOperationStats from a slice of uint32s. func inodeOperationStats(us []uint32) (InodeOperationStats, error) { if l := len(us); l != 7 { return InodeOperationStats{}, fmt.Errorf("incorrect number of values for XFS inode operation stats: %d", l) } return InodeOperationStats{ Attempts: us[0], Found: us[1], Recycle: us[2], Missed: us[3], Duplicate: us[4], Reclaims: us[5], AttributeChange: us[6], }, nil } // LogOperationStats builds a LogOperationStats from a slice of uint32s. func logOperationStats(us []uint32) (LogOperationStats, error) { if l := len(us); l != 5 { return LogOperationStats{}, fmt.Errorf("incorrect number of values for XFS log operation stats: %d", l) } return LogOperationStats{ Writes: us[0], Blocks: us[1], NoInternalBuffers: us[2], Force: us[3], ForceSleep: us[4], }, nil } // pushAilStats handles push_ail stats. func pushAilStats(us []uint32) (PushAilStats, error) { if l := len(us); l != 10 { return PushAilStats{}, fmt.Errorf("incorrect number of values for XFS push ail stats: %d", l) } return PushAilStats{ TryLogspace: us[0], SleepLogspace: us[1], Pushes: us[2], Success: us[3], PushBuf: us[4], Pinned: us[5], Locked: us[6], Flushing: us[7], Restarts: us[8], Flush: us[9], }, nil } // xStratStats handles xstrat stats. func xStratStats(us []uint32) (XstratStats, error) { if l := len(us); l != 2 { return XstratStats{}, fmt.Errorf("incorrect number of values for XFS xstrat stats: %d", l) } return XstratStats{ Quick: us[0], Split: us[1], }, nil } // readWriteStats handles rw stats. func readWriteStats(us []uint32) (ReadWriteStats, error) { if l := len(us); l != 2 { return ReadWriteStats{}, fmt.Errorf("incorrect number of values for XFS read write stats: %d", l) } return ReadWriteStats{ Write: us[0], Read: us[1], }, nil } // AttributeOperationStats builds an AttributeOperationStats from a slice of uint32s. func attributeOperationStats(us []uint32) (AttributeOperationStats, error) { if l := len(us); l != 4 { return AttributeOperationStats{}, fmt.Errorf("incorrect number of values for XFS attribute operation stats: %d", l) } return AttributeOperationStats{ Get: us[0], Set: us[1], Remove: us[2], List: us[3], }, nil } // InodeClusteringStats builds an InodeClusteringStats from a slice of uint32s. func inodeClusteringStats(us []uint32) (InodeClusteringStats, error) { if l := len(us); l != 3 { return InodeClusteringStats{}, fmt.Errorf("incorrect number of values for XFS inode clustering stats: %d", l) } return InodeClusteringStats{ Iflush: us[0], Flush: us[1], FlushInode: us[2], }, nil } // VnodeStats builds a VnodeStats from a slice of uint32s. func vnodeStats(us []uint32) (VnodeStats, error) { // The attribute "Free" appears to not be available on older XFS // stats versions. Therefore, 7 or 8 elements may appear in // this slice. l := len(us) if l != 7 && l != 8 { return VnodeStats{}, fmt.Errorf("incorrect number of values for XFS vnode stats: %d", l) } s := VnodeStats{ Active: us[0], Allocate: us[1], Get: us[2], Hold: us[3], Release: us[4], Reclaim: us[5], Remove: us[6], } // Skip adding free, unless it is present. The zero value will // be used in place of an actual count. if l == 7 { return s, nil } s.Free = us[7] return s, nil } // BufferStats builds a BufferStats from a slice of uint32s. func bufferStats(us []uint32) (BufferStats, error) { if l := len(us); l != 9 { return BufferStats{}, fmt.Errorf("incorrect number of values for XFS buffer stats: %d", l) } return BufferStats{ Get: us[0], Create: us[1], GetLocked: us[2], GetLockedWaited: us[3], BusyLocked: us[4], MissLocked: us[5], PageRetries: us[6], PageFound: us[7], GetRead: us[8], }, nil } // ExtendedPrecisionStats builds an ExtendedPrecisionStats from a slice of uint32s. func extendedPrecisionStats(us []uint64) (ExtendedPrecisionStats, error) { if l := len(us); l != 3 { return ExtendedPrecisionStats{}, fmt.Errorf("incorrect number of values for XFS extended precision stats: %d", l) } return ExtendedPrecisionStats{ FlushBytes: us[0], WriteBytes: us[1], ReadBytes: us[2], }, nil } func quotaManagerStats(us []uint32) (QuotaManagerStats, error) { // The "Unused" attribute first appears in Linux 4.20 // As a result either 8 or 9 elements may appear in this slice depending on // the kernel version. l := len(us) if l != 8 && l != 9 { return QuotaManagerStats{}, fmt.Errorf("incorrect number of values for XFS quota stats: %d", l) } s := QuotaManagerStats{ Reclaims: us[0], ReclaimMisses: us[1], DquoteDups: us[2], CacheMisses: us[3], CacheHits: us[4], Wants: us[5], ShakeReclaims: us[6], InactReclaims: us[7], } if l > 8 { s.Unused = us[8] } return s, nil } func debugStats(us []uint32) (DebugStats, error) { if l := len(us); l != 1 { return DebugStats{}, fmt.Errorf("incorrect number of values for XFS debug stats: %d", l) } return DebugStats{ Enabled: us[0], }, nil } // btreeAllocBlocks2Stats handles abtb2 stats. func btreeAllocBlocks2Stats(us []uint32) (BtreeAllocBlocks2Stats, error) { if l := len(us); l != 15 { return BtreeAllocBlocks2Stats{}, fmt.Errorf("incorrect number of values for abtb2 stats: %d", 1) } return BtreeAllocBlocks2Stats{ Lookup: us[0], Compare: us[1], Insrec: us[2], Delrec: us[3], NewRoot: us[4], KillRoot: us[5], Increment: us[6], Decrement: us[7], Lshift: us[8], Rshift: us[9], Split: us[10], Join: us[11], Alloc: us[12], Free: us[13], Moves: us[14], }, nil } // btreeAllocContig2Stats handles abtc2 stats. func btreeAllocContig2Stats(us []uint32) (BtreeAllocContig2Stats, error) { if l := len(us); l != 15 { return BtreeAllocContig2Stats{}, fmt.Errorf("incorrect number of values for abtc2 stats: %d", 1) } return BtreeAllocContig2Stats{ Lookup: us[0], Compare: us[1], Insrec: us[2], Delrec: us[3], NewRoot: us[4], KillRoot: us[5], Increment: us[6], Decrement: us[7], Lshift: us[8], Rshift: us[9], Split: us[10], Join: us[11], Alloc: us[12], Free: us[13], Moves: us[14], }, nil } // btreeBlockMap2Stats handles bmbt2 stats. func btreeBlockMap2Stats(us []uint32) (BtreeBlockMap2Stats, error) { if l := len(us); l != 15 { return BtreeBlockMap2Stats{}, fmt.Errorf("incorrect number of values for bmbt2 stats: %d", 1) } return BtreeBlockMap2Stats{ Lookup: us[0], Compare: us[1], Insrec: us[2], Delrec: us[3], NewRoot: us[4], KillRoot: us[5], Increment: us[6], Decrement: us[7], Lshift: us[8], Rshift: us[9], Split: us[10], Join: us[11], Alloc: us[12], Free: us[13], Moves: us[14], }, nil } // btreeInode2Stats handles ibt2 stats. func btreeInode2Stats(us []uint32) (BtreeInode2Stats, error) { if l := len(us); l != 15 { return BtreeInode2Stats{}, fmt.Errorf("incorrect number of values for ibt2 stats: %d", 1) } return BtreeInode2Stats{ Lookup: us[0], Compare: us[1], Insrec: us[2], Delrec: us[3], NewRoot: us[4], KillRoot: us[5], Increment: us[6], Decrement: us[7], Lshift: us[8], Rshift: us[9], Split: us[10], Join: us[11], Alloc: us[12], Free: us[13], Moves: us[14], }, nil }	13.37 KB	2025-05-25 12:27
📄 parse_test.go // Copyright 2017 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 xfs_test import ( "reflect" "strings" "testing" "github.com/prometheus/procfs/xfs" ) func TestParseStats(t testing.T) { tests := []struct { name string s string fs bool stats xfs.Stats invalid bool }{ { name: "empty file OK", }, { name: "short or empty lines and unknown labels ignored", s: "one\n\ntwo 1 2 3\n", stats: &xfs.Stats{}, }, { name: "bad uint32", s: "extent_alloc XXX", invalid: true, }, { name: "bad uint64", s: "xpc XXX", invalid: true, }, { name: "extent_alloc bad", s: "extent_alloc 1", invalid: true, }, { name: "extent_alloc OK", s: "extent_alloc 1 2 3 4", stats: &xfs.Stats{ ExtentAllocation: xfs.ExtentAllocationStats{ ExtentsAllocated: 1, BlocksAllocated: 2, ExtentsFreed: 3, BlocksFreed: 4, }, }, }, { name: "abt bad", s: "abt 1", invalid: true, }, { name: "abt OK", s: "abt 1 2 3 4", stats: &xfs.Stats{ AllocationBTree: xfs.BTreeStats{ Lookups: 1, Compares: 2, RecordsInserted: 3, RecordsDeleted: 4, }, }, }, { name: "blk_map bad", s: "blk_map 1", invalid: true, }, { name: "blk_map OK", s: "blk_map 1 2 3 4 5 6 7", stats: &xfs.Stats{ BlockMapping: xfs.BlockMappingStats{ Reads: 1, Writes: 2, Unmaps: 3, ExtentListInsertions: 4, ExtentListDeletions: 5, ExtentListLookups: 6, ExtentListCompares: 7, }, }, }, { name: "bmbt bad", s: "bmbt 1", invalid: true, }, { name: "bmbt OK", s: "bmbt 1 2 3 4", stats: &xfs.Stats{ BlockMapBTree: xfs.BTreeStats{ Lookups: 1, Compares: 2, RecordsInserted: 3, RecordsDeleted: 4, }, }, }, { name: "dir bad", s: "dir 1", invalid: true, }, { name: "dir OK", s: "dir 1 2 3 4", stats: &xfs.Stats{ DirectoryOperation: xfs.DirectoryOperationStats{ Lookups: 1, Creates: 2, Removes: 3, Getdents: 4, }, }, }, { name: "trans bad", s: "trans 1", invalid: true, }, { name: "trans OK", s: "trans 1 2 3", stats: &xfs.Stats{ Transaction: xfs.TransactionStats{ Sync: 1, Async: 2, Empty: 3, }, }, }, { name: "ig bad", s: "ig 1", invalid: true, }, { name: "ig OK", s: "ig 1 2 3 4 5 6 7", stats: &xfs.Stats{ InodeOperation: xfs.InodeOperationStats{ Attempts: 1, Found: 2, Recycle: 3, Missed: 4, Duplicate: 5, Reclaims: 6, AttributeChange: 7, }, }, }, { name: "log bad", s: "log 1", invalid: true, }, { name: "log OK", s: "log 1 2 3 4 5", stats: &xfs.Stats{ LogOperation: xfs.LogOperationStats{ Writes: 1, Blocks: 2, NoInternalBuffers: 3, Force: 4, ForceSleep: 5, }, }, }, { name: "rw bad", s: "rw 1", invalid: true, }, { name: "rw OK", s: "rw 1 2", stats: &xfs.Stats{ ReadWrite: xfs.ReadWriteStats{ Write: 1, Read: 2, }, }, }, { name: "attr bad", s: "attr 1", invalid: true, }, { name: "attr OK", s: "attr 1 2 3 4", stats: &xfs.Stats{ AttributeOperation: xfs.AttributeOperationStats{ Get: 1, Set: 2, Remove: 3, List: 4, }, }, }, { name: "icluster bad", s: "icluster 1", invalid: true, }, { name: "icluster OK", s: "icluster 1 2 3", stats: &xfs.Stats{ InodeClustering: xfs.InodeClusteringStats{ Iflush: 1, Flush: 2, FlushInode: 3, }, }, }, { name: "vnodes bad", s: "vnodes 1", invalid: true, }, { name: "vnodes (missing free) OK", s: "vnodes 1 2 3 4 5 6 7", stats: &xfs.Stats{ Vnode: xfs.VnodeStats{ Active: 1, Allocate: 2, Get: 3, Hold: 4, Release: 5, Reclaim: 6, Remove: 7, }, }, }, { name: "vnodes (with free) OK", s: "vnodes 1 2 3 4 5 6 7 8", stats: &xfs.Stats{ Vnode: xfs.VnodeStats{ Active: 1, Allocate: 2, Get: 3, Hold: 4, Release: 5, Reclaim: 6, Remove: 7, Free: 8, }, }, }, { name: "buf bad", s: "buf 1", invalid: true, }, { name: "buf OK", s: "buf 1 2 3 4 5 6 7 8 9", stats: &xfs.Stats{ Buffer: xfs.BufferStats{ Get: 1, Create: 2, GetLocked: 3, GetLockedWaited: 4, BusyLocked: 5, MissLocked: 6, PageRetries: 7, PageFound: 8, GetRead: 9, }, }, }, { name: "xpc bad", s: "xpc 1", invalid: true, }, { name: "xpc OK", s: "xpc 1 2 3", stats: &xfs.Stats{ ExtendedPrecision: xfs.ExtendedPrecisionStats{ FlushBytes: 1, WriteBytes: 2, ReadBytes: 3, }, }, }, { name: "xstrat bad", s: "xstrat 1", invalid: true, }, { name: "xstrat OK", s: "xstrat 1 2", stats: &xfs.Stats{ Xstrat: xfs.XstratStats{ Quick: 1, Split: 2, }, }, }, { name: "push_ail bad", s: "push_ail 1 2 3 4 5", invalid: true, }, { name: "push_ail OK", s: "push_ail 1 2 3 4 5 6 7 8 9 10", stats: &xfs.Stats{ PushAil: xfs.PushAilStats{ TryLogspace: 1, SleepLogspace: 2, Pushes: 3, Success: 4, PushBuf: 5, Pinned: 6, Locked: 7, Flushing: 8, Restarts: 9, Flush: 10, }, }, }, { name: "debug bad", s: "debug 1 2", invalid: true, }, { name: "debug OK", s: "debug 1", stats: &xfs.Stats{ Debug: xfs.DebugStats{ Enabled: 1, }, }, }, { name: "qm bad", s: "qm 1 2 3 4 5 6 7", invalid: true, }, { name: "qm bad", s: "qm 1 2 3 4 5 6 7 8 9 10", invalid: true, }, { name: "qm OK", s: "qm 1 2 3 4 5 6 7 8", stats: &xfs.Stats{ QuotaManager: xfs.QuotaManagerStats{ Reclaims: 1, ReclaimMisses: 2, DquoteDups: 3, CacheMisses: 4, CacheHits: 5, Wants: 6, ShakeReclaims: 7, InactReclaims: 8, }, }, }, { name: "qm OK", s: "qm 1 2 3 4 5 6 7 8 9", stats: &xfs.Stats{ QuotaManager: xfs.QuotaManagerStats{ Reclaims: 1, ReclaimMisses: 2, DquoteDups: 3, CacheMisses: 4, CacheHits: 5, Wants: 6, ShakeReclaims: 7, InactReclaims: 8, Unused: 9, }, }, }, { name: "abtb2 bad", s: "abtb2 1 2 3 4 5 6", invalid: true, }, { name: "abtb2 OK", s: "abtb2 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15", stats: &xfs.Stats{ BtreeAllocBlocks2: xfs.BtreeAllocBlocks2Stats{ Lookup: 1, Compare: 2, Insrec: 3, Delrec: 4, NewRoot: 5, KillRoot: 6, Increment: 7, Decrement: 8, Lshift: 9, Rshift: 10, Split: 11, Join: 12, Alloc: 13, Free: 14, Moves: 15, }, }, }, { name: "abtc2 bad", s: "abtc2 1 2 3 4 5 6", invalid: true, }, { name: "abtc2 OK", s: "abtc2 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15", stats: &xfs.Stats{ BtreeAllocContig2: xfs.BtreeAllocContig2Stats{ Lookup: 1, Compare: 2, Insrec: 3, Delrec: 4, NewRoot: 5, KillRoot: 6, Increment: 7, Decrement: 8, Lshift: 9, Rshift: 10, Split: 11, Join: 12, Alloc: 13, Free: 14, Moves: 15, }, }, }, { name: "bmbt2 bad", s: "bmbt2 1 2 3 4 5 6", invalid: true, }, { name: "bmbt2 OK", s: "bmbt2 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15", stats: &xfs.Stats{ BtreeBlockMap2: xfs.BtreeBlockMap2Stats{ Lookup: 1, Compare: 2, Insrec: 3, Delrec: 4, NewRoot: 5, KillRoot: 6, Increment: 7, Decrement: 8, Lshift: 9, Rshift: 10, Split: 11, Join: 12, Alloc: 13, Free: 14, Moves: 15, }, }, }, { name: "ibt2 bad", s: "ibt2 1 2 3 4 5 6", invalid: true, }, { name: "ibt2 OK", s: "ibt2 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15", stats: &xfs.Stats{ BtreeInode2: xfs.BtreeInode2Stats{ Lookup: 1, Compare: 2, Insrec: 3, Delrec: 4, NewRoot: 5, KillRoot: 6, Increment: 7, Decrement: 8, Lshift: 9, Rshift: 10, Split: 11, Join: 12, Alloc: 13, Free: 14, Moves: 15, }, }, }, { name: "fixtures OK", fs: true, stats: &xfs.Stats{ ExtentAllocation: xfs.ExtentAllocationStats{ ExtentsAllocated: 92447, BlocksAllocated: 97589, ExtentsFreed: 92448, BlocksFreed: 93751, }, AllocationBTree: xfs.BTreeStats{ Lookups: 0, Compares: 0, RecordsInserted: 0, RecordsDeleted: 0, }, BlockMapping: xfs.BlockMappingStats{ Reads: 1767055, Writes: 188820, Unmaps: 184891, ExtentListInsertions: 92447, ExtentListDeletions: 92448, ExtentListLookups: 2140766, ExtentListCompares: 0, }, BlockMapBTree: xfs.BTreeStats{ Lookups: 0, Compares: 0, RecordsInserted: 0, RecordsDeleted: 0, }, DirectoryOperation: xfs.DirectoryOperationStats{ Lookups: 185039, Creates: 92447, Removes: 92444, Getdents: 136422, }, Transaction: xfs.TransactionStats{ Sync: 706, Async: 944304, Empty: 0, }, InodeOperation: xfs.InodeOperationStats{ Attempts: 185045, Found: 58807, Recycle: 0, Missed: 126238, Duplicate: 0, Reclaims: 33637, AttributeChange: 22, }, LogOperation: xfs.LogOperationStats{ Writes: 2883, Blocks: 113448, NoInternalBuffers: 9, Force: 17360, ForceSleep: 739, }, ReadWrite: xfs.ReadWriteStats{ Write: 107739, Read: 94045, }, AttributeOperation: xfs.AttributeOperationStats{ Get: 4, Set: 0, Remove: 0, List: 0, }, InodeClustering: xfs.InodeClusteringStats{ Iflush: 8677, Flush: 7849, FlushInode: 135802, }, Vnode: xfs.VnodeStats{ Active: 92601, Allocate: 0, Get: 0, Hold: 0, Release: 92444, Reclaim: 92444, Remove: 92444, Free: 0, }, Buffer: xfs.BufferStats{ Get: 2666287, Create: 7122, GetLocked: 2659202, GetLockedWaited: 3599, BusyLocked: 2, MissLocked: 7085, PageRetries: 0, PageFound: 10297, GetRead: 7085, }, ExtendedPrecision: xfs.ExtendedPrecisionStats{ FlushBytes: 399724544, WriteBytes: 92823103, ReadBytes: 86219234, }, PushAil: xfs.PushAilStats{ TryLogspace: 945014, SleepLogspace: 0, Pushes: 134260, Success: 15483, PushBuf: 0, Pinned: 3940, Locked: 464, Flushing: 159985, Restarts: 0, Flush: 40, }, Xstrat: xfs.XstratStats{ Quick: 92447, Split: 0, }, Debug: xfs.DebugStats{ Enabled: 0, }, QuotaManager: xfs.QuotaManagerStats{ Reclaims: 0, ReclaimMisses: 0, DquoteDups: 0, CacheMisses: 0, CacheHits: 0, Wants: 0, ShakeReclaims: 0, InactReclaims: 0, }, BtreeAllocBlocks2: xfs.BtreeAllocBlocks2Stats{ Lookup: 184941, Compare: 1277345, Insrec: 13257, Delrec: 13278, NewRoot: 0, KillRoot: 0, Increment: 0, Decrement: 0, Lshift: 0, Rshift: 0, Split: 0, Join: 0, Alloc: 0, Free: 0, Moves: 2746147, }, BtreeAllocContig2: xfs.BtreeAllocContig2Stats{ Lookup: 345295, Compare: 2416764, Insrec: 172637, Delrec: 172658, NewRoot: 0, KillRoot: 0, Increment: 0, Decrement: 0, Lshift: 0, Rshift: 0, Split: 0, Join: 0, Alloc: 0, Free: 0, Moves: 21406023, }, BtreeBlockMap2: xfs.BtreeBlockMap2Stats{ Lookup: 0, Compare: 0, Insrec: 0, Delrec: 0, NewRoot: 0, KillRoot: 0, Increment: 0, Decrement: 0, Lshift: 0, Rshift: 0, Split: 0, Join: 0, Alloc: 0, Free: 0, Moves: 0, }, BtreeInode2: xfs.BtreeInode2Stats{ Lookup: 343004, Compare: 1358467, Insrec: 0, Delrec: 0, NewRoot: 0, KillRoot: 0, Increment: 0, Decrement: 0, Lshift: 0, Rshift: 0, Split: 0, Join: 0, Alloc: 0, Free: 0, Moves: 0, }, }, }, } for _, tt := range tests { var ( stats *xfs.Stats err error ) if tt.s != "" { stats, err = xfs.ParseStats(strings.NewReader(tt.s)) } if tt.fs { xfs, err := xfs.NewFS("testdata/fixtures/proc", "testdata/fixtures/sys") if err != nil { t.Fatalf("failed to access xfs fs: %v", err) } stats, err = xfs.ProcStat() if err != nil { t.Fatalf("failed to gather xfs stats: %v", err) } } if tt.invalid && err == nil { t.Error("expected an error, but none occurred") } if !tt.invalid && err != nil { t.Errorf("unexpected error: %v", err) } if want, have := tt.stats, stats; !reflect.DeepEqual(want, have) { t.Errorf("unexpected XFS stats:\nwant:\n%v\nhave:\n%v", want, have) } } }	14.69 KB	2025-05-25 12:27
📄 xfs.go // Copyright 2017 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 xfs provides access to statistics exposed by the XFS filesystem. package xfs import ( "os" "path/filepath" "strings" "github.com/prometheus/procfs/internal/fs" ) // Stats contains XFS filesystem runtime statistics, parsed from // /proc/fs/xfs/stat. // // The names and meanings of each statistic were taken from // http://xfs.org/index.php/Runtime_Stats and xfs_stats.h in the Linux // kernel source. Most counters are uint32s (same data types used in // xfs_stats.h), but some of the "extended precision stats" are uint64s. type Stats struct { // The name of the filesystem used to source these statistics. // If empty, this indicates aggregated statistics for all XFS // filesystems on the host. Name string ExtentAllocation ExtentAllocationStats AllocationBTree BTreeStats BlockMapping BlockMappingStats BlockMapBTree BTreeStats DirectoryOperation DirectoryOperationStats Transaction TransactionStats InodeOperation InodeOperationStats LogOperation LogOperationStats ReadWrite ReadWriteStats AttributeOperation AttributeOperationStats InodeClustering InodeClusteringStats Vnode VnodeStats Buffer BufferStats ExtendedPrecision ExtendedPrecisionStats Xstrat XstratStats // xstrat PushAil PushAilStats // push_ail Debug DebugStats // debug QuotaManager QuotaManagerStats // qm BtreeAllocBlocks2 BtreeAllocBlocks2Stats // abtb2 BtreeAllocContig2 BtreeAllocContig2Stats // abtc2 BtreeBlockMap2 BtreeBlockMap2Stats // bmbt2 BtreeInode2 BtreeInode2Stats // ibt2 } // ExtentAllocationStats contains statistics regarding XFS extent allocations. type ExtentAllocationStats struct { ExtentsAllocated uint32 BlocksAllocated uint32 ExtentsFreed uint32 BlocksFreed uint32 } // BTreeStats contains statistics regarding an XFS internal B-tree. type BTreeStats struct { Lookups uint32 Compares uint32 RecordsInserted uint32 RecordsDeleted uint32 } // BlockMappingStats contains statistics regarding XFS block maps. type BlockMappingStats struct { Reads uint32 Writes uint32 Unmaps uint32 ExtentListInsertions uint32 ExtentListDeletions uint32 ExtentListLookups uint32 ExtentListCompares uint32 } // DirectoryOperationStats contains statistics regarding XFS directory entries. type DirectoryOperationStats struct { Lookups uint32 Creates uint32 Removes uint32 Getdents uint32 } // TransactionStats contains statistics regarding XFS metadata transactions. type TransactionStats struct { Sync uint32 Async uint32 Empty uint32 } // InodeOperationStats contains statistics regarding XFS inode operations. type InodeOperationStats struct { Attempts uint32 Found uint32 Recycle uint32 Missed uint32 Duplicate uint32 Reclaims uint32 AttributeChange uint32 } // LogOperationStats contains statistics regarding the XFS log buffer. type LogOperationStats struct { Writes uint32 Blocks uint32 NoInternalBuffers uint32 Force uint32 ForceSleep uint32 } // ReadWriteStats contains statistics regarding the number of read and write // system calls for XFS filesystems. type ReadWriteStats struct { Write uint32 Read uint32 } // AttributeOperationStats contains statistics regarding manipulation of // XFS extended file attributes. type AttributeOperationStats struct { Get uint32 Set uint32 Remove uint32 List uint32 } // InodeClusteringStats contains statistics regarding XFS inode clustering // operations. type InodeClusteringStats struct { Iflush uint32 Flush uint32 FlushInode uint32 } // VnodeStats contains statistics regarding XFS vnode operations. type VnodeStats struct { Active uint32 Allocate uint32 Get uint32 Hold uint32 Release uint32 Reclaim uint32 Remove uint32 Free uint32 } // BufferStats contains statistics regarding XFS read/write I/O buffers. type BufferStats struct { Get uint32 Create uint32 GetLocked uint32 GetLockedWaited uint32 BusyLocked uint32 MissLocked uint32 PageRetries uint32 PageFound uint32 GetRead uint32 } // ExtendedPrecisionStats contains high precision counters used to track the // total number of bytes read, written, or flushed, during XFS operations. type ExtendedPrecisionStats struct { FlushBytes uint64 WriteBytes uint64 ReadBytes uint64 } // PushAilStats contains statistics on tail-pushing operations. type PushAilStats struct { TryLogspace uint32 SleepLogspace uint32 Pushes uint32 Success uint32 PushBuf uint32 Pinned uint32 Locked uint32 Flushing uint32 Restarts uint32 Flush uint32 } // QuotaManagerStats contain statistics regarding quota processing. type QuotaManagerStats struct { Reclaims uint32 ReclaimMisses uint32 DquoteDups uint32 CacheMisses uint32 CacheHits uint32 Wants uint32 ShakeReclaims uint32 InactReclaims uint32 Unused uint32 } // XstratStats contains statistics regarding bytes processed by the XFS daemon. type XstratStats struct { Quick uint32 Split uint32 } // DebugStats indicate if XFS debugging is enabled. type DebugStats struct { Enabled uint32 } // BtreeAllocBlocks2Stats contains statistics on B-Tree v2 allocations. type BtreeAllocBlocks2Stats struct { Lookup uint32 Compare uint32 Insrec uint32 Delrec uint32 NewRoot uint32 KillRoot uint32 Increment uint32 Decrement uint32 Lshift uint32 Rshift uint32 Split uint32 Join uint32 Alloc uint32 Free uint32 Moves uint32 } // BtreeAllocContig2Stats contain statistics on B-tree v2 free-space-by-size record operations. type BtreeAllocContig2Stats struct { Lookup uint32 Compare uint32 Insrec uint32 Delrec uint32 NewRoot uint32 KillRoot uint32 Increment uint32 Decrement uint32 Lshift uint32 Rshift uint32 Split uint32 Join uint32 Alloc uint32 Free uint32 Moves uint32 } // BtreeBlockMap2Stats contain statistics on B-tree v2 block map operations. type BtreeBlockMap2Stats struct { Lookup uint32 Compare uint32 Insrec uint32 Delrec uint32 NewRoot uint32 KillRoot uint32 Increment uint32 Decrement uint32 Lshift uint32 Rshift uint32 Split uint32 Join uint32 Alloc uint32 Free uint32 Moves uint32 } // BtreeInode2Stats contain statistics on B-tree v2 inode allocations. type BtreeInode2Stats struct { Lookup uint32 Compare uint32 Insrec uint32 Delrec uint32 NewRoot uint32 KillRoot uint32 Increment uint32 Decrement uint32 Lshift uint32 Rshift uint32 Split uint32 Join uint32 Alloc uint32 Free uint32 Moves uint32 } // FS represents the pseudo-filesystems proc and sys, which provides an interface to // kernel data structures. type FS struct { proc fs.FS sys fs.FS } // NewDefaultFS returns a new XFS handle using the default proc and sys mountPoints. // It will error if either of the mounts point can't be read. func NewDefaultFS() (FS, error) { return NewFS(fs.DefaultProcMountPoint, fs.DefaultSysMountPoint) } // NewFS returns a new XFS handle using the given proc and sys mountPoints. It will error // if either of the mounts point can't be read. func NewFS(procMountPoint string, sysMountPoint string) (FS, error) { if strings.TrimSpace(procMountPoint) == "" { procMountPoint = fs.DefaultProcMountPoint } procfs, err := fs.NewFS(procMountPoint) if err != nil { return FS{}, err } if strings.TrimSpace(sysMountPoint) == "" { sysMountPoint = fs.DefaultSysMountPoint } sysfs, err := fs.NewFS(sysMountPoint) if err != nil { return FS{}, err } return FS{&procfs, &sysfs}, nil } // ProcStat retrieves XFS filesystem runtime statistics // from proc/fs/xfs/stat given the profs mount point. func (fs FS) ProcStat() (Stats, error) { f, err := os.Open(fs.proc.Path("fs/xfs/stat")) if err != nil { return nil, err } defer f.Close() return ParseStats(f) } // SysStats retrieves XFS filesystem runtime statistics for each mounted XFS // filesystem. Only available on kernel 4.4+. On older kernels, an empty // slice of xfs.Stats will be returned. func (fs FS) SysStats() ([]Stats, error) { matches, err := filepath.Glob(fs.sys.Path("fs/xfs//stats/stats")) if err != nil { return nil, err } stats := make([]Stats, 0, len(matches)) for _, m := range matches { f, err := os.Open(m) if err != nil { return nil, err } // "" used in glob above indicates the name of the filesystem. name := filepath.Base(filepath.Dir(filepath.Dir(m))) // File must be closed after parsing, regardless of success or // failure. Defer is not used because of the loop. s, err := ParseStats(f) _ = f.Close() if err != nil { return nil, err } s.Name = name stats = append(stats, s) } return stats, nil }	9.52 KB	2025-05-25 12:27
📄 xfs_test.go // Copyright 2019 The Prometheus Authors // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. // Package xfs provides access to statistics exposed by the XFS filesystem. package xfs_test import ( "testing" "github.com/prometheus/procfs/xfs" ) func TestReadProcStat(t testing.T) { xfs, err := xfs.NewFS("testdata/fixtures/proc", "testdata/fixtures/sys") if err != nil { t.Fatalf("failed to access xfs fs: %v", err) } stats, err := xfs.ProcStat() if err != nil { t.Fatalf("failed to parse XFS stats: %v", err) } // Very lightweight test just to sanity check the path used // to open XFS stats. Heavier tests in package xfs. if want, got := uint32(92447), stats.ExtentAllocation.ExtentsAllocated; want != got { t.Errorf("unexpected extents allocated:\nwant: %d\nhave: %d", want, got) } } func TestReadSysStats(t testing.T) { xfs, err := xfs.NewFS("testdata/fixtures/proc", "testdata/fixtures/sys") if err != nil { t.Fatalf("failed to access xfs fs: %v", err) } stats, err := xfs.SysStats() if err != nil { t.Fatalf("failed to parse XFS stats: %v", err) } tests := []struct { name string allocated uint32 }{ { name: "sda1", allocated: 1, }, { name: "sdb1", allocated: 2, }, } const expect = 2 if l := len(stats); l != expect { t.Fatalf("unexpected number of XFS stats: %d", l) } if l := len(tests); l != expect { t.Fatalf("unexpected number of tests: %d", l) } for i, tt := range tests { if want, got := tt.name, stats[i].Name; want != got { t.Errorf("unexpected stats name:\nwant: %q\nhave: %q", want, got) } if want, got := tt.allocated, stats[i].ExtentAllocation.ExtentsAllocated; want != got { t.Errorf("unexpected extents allocated:\nwant: %d\nhave: %d", want, got) } } }	2.23 KB	2025-05-25 12:27

Terminal