Lomanic
/
gopsutil
mirror of https://github.com/shirou/gopsutil
1
0
Fork 0
Code Issues Releases Activity

[mem][linux] Fix #1002 only try to parse /proc/meminfo numeric values on fields we're interested in

Browse Source
pull/1004/head
Lomanic 5 years ago
parent 07887a9e9f
commit cd25417bd7
6 changed files with 446 additions and 8 deletions
Show Stats Download Patch File Download Diff File

148
mem/mem_linux.go
Unescape Escape View File

@ -73,86 +73,226 @@ func fillFromMeminfoWithContext(ctx context.Context) (*VirtualMemoryStat, *Virtu
value := strings.TrimSpace(fields[1]) value := strings.TrimSpace(fields[1])
value = strings.Replace(value, " kB", "", -1) value = strings.Replace(value, " kB", "", -1)
t, err := strconv.ParseUint(value, 10, 64)
if err != nil {
return ret, retEx,err
}
switch key { switch key {
case "MemTotal": case "MemTotal":
t, err := strconv.ParseUint(value, 10, 64)
if err != nil {
return ret, retEx, err
}
ret.Total = t * 1024 ret.Total = t * 1024
case "MemFree": case "MemFree":
t, err := strconv.ParseUint(value, 10, 64)
if err != nil {
return ret, retEx, err
}
ret.Free = t * 1024 ret.Free = t * 1024
case "MemAvailable": case "MemAvailable":
t, err := strconv.ParseUint(value, 10, 64)
if err != nil {
return ret, retEx, err
}
memavail = true memavail = true
ret.Available = t * 1024 ret.Available = t * 1024
case "Buffers": case "Buffers":
t, err := strconv.ParseUint(value, 10, 64)
if err != nil {
return ret, retEx, err
}
ret.Buffers = t * 1024 ret.Buffers = t * 1024
case "Cached": case "Cached":
t, err := strconv.ParseUint(value, 10, 64)
if err != nil {
return ret, retEx, err
}
ret.Cached = t * 1024 ret.Cached = t * 1024
case "Active": case "Active":
t, err := strconv.ParseUint(value, 10, 64)
if err != nil {
return ret, retEx, err
}
ret.Active = t * 1024 ret.Active = t * 1024
case "Inactive": case "Inactive":
t, err := strconv.ParseUint(value, 10, 64)
if err != nil {
return ret, retEx, err
}
ret.Inactive = t * 1024 ret.Inactive = t * 1024
case "Active(anon)": case "Active(anon)":
t, err := strconv.ParseUint(value, 10, 64)
if err != nil {
return ret, retEx, err
}
retEx.ActiveAnon = t * 1024 retEx.ActiveAnon = t * 1024
case "Inactive(anon)": case "Inactive(anon)":
t, err := strconv.ParseUint(value, 10, 64)
if err != nil {
return ret, retEx, err
}
retEx.InactiveAnon = t * 1024 retEx.InactiveAnon = t * 1024
case "Active(file)": case "Active(file)":
t, err := strconv.ParseUint(value, 10, 64)
if err != nil {
return ret, retEx, err
}
activeFile = true activeFile = true
retEx.ActiveFile = t * 1024 retEx.ActiveFile = t * 1024
case "Inactive(file)": case "Inactive(file)":
t, err := strconv.ParseUint(value, 10, 64)
if err != nil {
return ret, retEx, err
}
inactiveFile = true inactiveFile = true
retEx.InactiveFile = t * 1024 retEx.InactiveFile = t * 1024
case "Unevictable": case "Unevictable":
t, err := strconv.ParseUint(value, 10, 64)
if err != nil {
return ret, retEx, err
}
retEx.Unevictable = t * 1024 retEx.Unevictable = t * 1024
case "Writeback": case "Writeback":
t, err := strconv.ParseUint(value, 10, 64)
if err != nil {
return ret, retEx, err
}
ret.Writeback = t * 1024 ret.Writeback = t * 1024
case "WritebackTmp": case "WritebackTmp":
t, err := strconv.ParseUint(value, 10, 64)
if err != nil {
return ret, retEx, err
}
ret.WritebackTmp = t * 1024 ret.WritebackTmp = t * 1024
case "Dirty": case "Dirty":
t, err := strconv.ParseUint(value, 10, 64)
if err != nil {
return ret, retEx, err
}
ret.Dirty = t * 1024 ret.Dirty = t * 1024
case "Shmem": case "Shmem":
t, err := strconv.ParseUint(value, 10, 64)
if err != nil {
return ret, retEx, err
}
ret.Shared = t * 1024 ret.Shared = t * 1024
case "Slab": case "Slab":
t, err := strconv.ParseUint(value, 10, 64)
if err != nil {
return ret, retEx, err
}
ret.Slab = t * 1024 ret.Slab = t * 1024
case "SReclaimable": case "SReclaimable":
t, err := strconv.ParseUint(value, 10, 64)
if err != nil {
return ret, retEx, err
}
sReclaimable = true sReclaimable = true
ret.SReclaimable = t * 1024 ret.SReclaimable = t * 1024
case "SUnreclaim": case "SUnreclaim":
t, err := strconv.ParseUint(value, 10, 64)
if err != nil {
return ret, retEx, err
}
ret.SUnreclaim = t * 1024 ret.SUnreclaim = t * 1024
case "PageTables": case "PageTables":
t, err := strconv.ParseUint(value, 10, 64)
if err != nil {
return ret, retEx, err
}
ret.PageTables = t * 1024 ret.PageTables = t * 1024
case "SwapCached": case "SwapCached":
t, err := strconv.ParseUint(value, 10, 64)
if err != nil {
return ret, retEx, err
}
ret.SwapCached = t * 1024 ret.SwapCached = t * 1024
case "CommitLimit": case "CommitLimit":
t, err := strconv.ParseUint(value, 10, 64)
if err != nil {
return ret, retEx, err
}
ret.CommitLimit = t * 1024 ret.CommitLimit = t * 1024
case "Committed_AS": case "Committed_AS":
t, err := strconv.ParseUint(value, 10, 64)
if err != nil {
return ret, retEx, err
}
ret.CommittedAS = t * 1024 ret.CommittedAS = t * 1024
case "HighTotal": case "HighTotal":
t, err := strconv.ParseUint(value, 10, 64)
if err != nil {
return ret, retEx, err
}
ret.HighTotal = t * 1024 ret.HighTotal = t * 1024
case "HighFree": case "HighFree":
t, err := strconv.ParseUint(value, 10, 64)
if err != nil {
return ret, retEx, err
}
ret.HighFree = t * 1024 ret.HighFree = t * 1024
case "LowTotal": case "LowTotal":
t, err := strconv.ParseUint(value, 10, 64)
if err != nil {
return ret, retEx, err
}
ret.LowTotal = t * 1024 ret.LowTotal = t * 1024
case "LowFree": case "LowFree":
t, err := strconv.ParseUint(value, 10, 64)
if err != nil {
return ret, retEx, err
}
ret.LowFree = t * 1024 ret.LowFree = t * 1024
case "SwapTotal": case "SwapTotal":
t, err := strconv.ParseUint(value, 10, 64)
if err != nil {
return ret, retEx, err
}
ret.SwapTotal = t * 1024 ret.SwapTotal = t * 1024
case "SwapFree": case "SwapFree":
t, err := strconv.ParseUint(value, 10, 64)
if err != nil {
return ret, retEx, err
}
ret.SwapFree = t * 1024 ret.SwapFree = t * 1024
case "Mapped": case "Mapped":
t, err := strconv.ParseUint(value, 10, 64)
if err != nil {
return ret, retEx, err
}
ret.Mapped = t * 1024 ret.Mapped = t * 1024
case "VmallocTotal": case "VmallocTotal":
t, err := strconv.ParseUint(value, 10, 64)
if err != nil {
return ret, retEx, err
}
ret.VMallocTotal = t * 1024 ret.VMallocTotal = t * 1024
case "VmallocUsed": case "VmallocUsed":
t, err := strconv.ParseUint(value, 10, 64)
if err != nil {
return ret, retEx, err
}
ret.VMallocUsed = t * 1024 ret.VMallocUsed = t * 1024
case "VmallocChunk": case "VmallocChunk":
t, err := strconv.ParseUint(value, 10, 64)
if err != nil {
return ret, retEx, err
}
ret.VMallocChunk = t * 1024 ret.VMallocChunk = t * 1024
case "HugePages_Total": case "HugePages_Total":
t, err := strconv.ParseUint(value, 10, 64)
if err != nil {
return ret, retEx, err
}
ret.HugePagesTotal = t ret.HugePagesTotal = t
case "HugePages_Free": case "HugePages_Free":
t, err := strconv.ParseUint(value, 10, 64)
if err != nil {
return ret, retEx, err
}
ret.HugePagesFree = t ret.HugePagesFree = t
case "Hugepagesize": case "Hugepagesize":
t, err := strconv.ParseUint(value, 10, 64)
if err != nil {
return ret, retEx, err
}
ret.HugePageSize = t * 1024 ret.HugePageSize = t * 1024
} }
} }

37
mem/mem_linux_test.go
Unescape Escape View File

@ -57,6 +57,43 @@ var virtualMemoryTests = []struct {
HugePagesFree: 0, HugePagesFree: 0,
HugePageSize: 2097152}, HugePageSize: 2097152},
}, },
{"issue1002", &VirtualMemoryStat{
Total: 260579328,
Available: 215199744,
Used: 34328576,
UsedPercent: 13.173944481121694,
Free: 124506112,
Active: 108785664,
Inactive: 8581120,
Wired: 0,
Laundry: 0,
Buffers: 4915200,
Cached: 96829440,
Writeback: 0,
Dirty: 0,
WritebackTmp: 0,
Shared: 0,
Slab: 9293824,
SReclaimable: 2764800,
SUnreclaim: 6529024,
PageTables: 405504,
SwapCached: 0,
CommitLimit: 130289664,
CommittedAS: 25567232,
HighTotal: 134217728,
HighFree: 67784704,
LowTotal: 126361600,
LowFree: 56721408,
SwapTotal: 0,
SwapFree: 0,
Mapped: 38793216,
VMallocTotal: 1996488704,
VMallocUsed: 0,
VMallocChunk: 0,
HugePagesTotal: 0,
HugePagesFree: 0,
HugePageSize: 0},
},
} }
func TestVirtualMemoryLinux(t *testing.T) { func TestVirtualMemoryLinux(t *testing.T) {

42
mem/testdata/linux/virtualmemory/issue1002/proc/meminfo vendored
Unescape Escape View File

@ -0,0 +1,42 @@
total: used: free: shared: buffers: cached:
Mem: 260579328 136073216 124506112 0 4915200 94064640
Swap: 0 0 0
MemTotal: 254472 kB
MemFree: 121588 kB
MemShared: 0 kB
Buffers: 4800 kB
Cached: 91860 kB
SwapCached: 0 kB
Active: 106236 kB
Inactive: 8380 kB
MemAvailable: 210156 kB
Active(anon): 17956 kB
Inactive(anon): 0 kB
Active(file): 88280 kB
Inactive(file): 8380 kB
Unevictable: 0 kB
Mlocked: 0 kB
HighTotal: 131072 kB
HighFree: 66196 kB
LowTotal: 123400 kB
LowFree: 55392 kB
SwapTotal: 0 kB
SwapFree: 0 kB
Dirty: 0 kB
Writeback: 0 kB
AnonPages: 17992 kB
Mapped: 37884 kB
Shmem: 0 kB
Slab: 9076 kB
SReclaimable: 2700 kB
SUnreclaim: 6376 kB
KernelStack: 624 kB
PageTables: 396 kB
NFS_Unstable: 0 kB
Bounce: 0 kB
WritebackTmp: 0 kB
CommitLimit: 127236 kB
Committed_AS: 24968 kB
VmallocTotal: 1949696 kB
VmallocUsed: 0 kB
VmallocChunk: 0 kB

148
v3/mem/mem_linux.go
Unescape Escape View File

@ -73,86 +73,226 @@ func fillFromMeminfoWithContext(ctx context.Context) (*VirtualMemoryStat, *Virtu
value := strings.TrimSpace(fields[1]) value := strings.TrimSpace(fields[1])
value = strings.Replace(value, " kB", "", -1) value = strings.Replace(value, " kB", "", -1)
t, err := strconv.ParseUint(value, 10, 64)
if err != nil {
return ret, retEx,err
}
switch key { switch key {
case "MemTotal": case "MemTotal":
t, err := strconv.ParseUint(value, 10, 64)
if err != nil {
return ret, retEx, err
}
ret.Total = t * 1024 ret.Total = t * 1024
case "MemFree": case "MemFree":
t, err := strconv.ParseUint(value, 10, 64)
if err != nil {
return ret, retEx, err
}
ret.Free = t * 1024 ret.Free = t * 1024
case "MemAvailable": case "MemAvailable":
t, err := strconv.ParseUint(value, 10, 64)
if err != nil {
return ret, retEx, err
}
memavail = true memavail = true
ret.Available = t * 1024 ret.Available = t * 1024
case "Buffers": case "Buffers":
t, err := strconv.ParseUint(value, 10, 64)
if err != nil {
return ret, retEx, err
}
ret.Buffers = t * 1024 ret.Buffers = t * 1024
case "Cached": case "Cached":
t, err := strconv.ParseUint(value, 10, 64)
if err != nil {
return ret, retEx, err
}
ret.Cached = t * 1024 ret.Cached = t * 1024
case "Active": case "Active":
t, err := strconv.ParseUint(value, 10, 64)
if err != nil {
return ret, retEx, err
}
ret.Active = t * 1024 ret.Active = t * 1024
case "Inactive": case "Inactive":
t, err := strconv.ParseUint(value, 10, 64)
if err != nil {
return ret, retEx, err
}
ret.Inactive = t * 1024 ret.Inactive = t * 1024
case "Active(anon)": case "Active(anon)":
t, err := strconv.ParseUint(value, 10, 64)
if err != nil {
return ret, retEx, err
}
retEx.ActiveAnon = t * 1024 retEx.ActiveAnon = t * 1024
case "Inactive(anon)": case "Inactive(anon)":
t, err := strconv.ParseUint(value, 10, 64)
if err != nil {
return ret, retEx, err
}
retEx.InactiveAnon = t * 1024 retEx.InactiveAnon = t * 1024
case "Active(file)": case "Active(file)":
t, err := strconv.ParseUint(value, 10, 64)
if err != nil {
return ret, retEx, err
}
activeFile = true activeFile = true
retEx.ActiveFile = t * 1024 retEx.ActiveFile = t * 1024
case "Inactive(file)": case "Inactive(file)":
t, err := strconv.ParseUint(value, 10, 64)
if err != nil {
return ret, retEx, err
}
inactiveFile = true inactiveFile = true
retEx.InactiveFile = t * 1024 retEx.InactiveFile = t * 1024
case "Unevictable": case "Unevictable":
t, err := strconv.ParseUint(value, 10, 64)
if err != nil {
return ret, retEx, err
}
retEx.Unevictable = t * 1024 retEx.Unevictable = t * 1024
case "WriteBack": case "WriteBack":
t, err := strconv.ParseUint(value, 10, 64)
if err != nil {
return ret, retEx, err
}
ret.WriteBack = t * 1024 ret.WriteBack = t * 1024
case "WriteBackTmp": case "WriteBackTmp":
t, err := strconv.ParseUint(value, 10, 64)
if err != nil {
return ret, retEx, err
}
ret.WriteBackTmp = t * 1024 ret.WriteBackTmp = t * 1024
case "Dirty": case "Dirty":
t, err := strconv.ParseUint(value, 10, 64)
if err != nil {
return ret, retEx, err
}
ret.Dirty = t * 1024 ret.Dirty = t * 1024
case "Shmem": case "Shmem":
t, err := strconv.ParseUint(value, 10, 64)
if err != nil {
return ret, retEx, err
}
ret.Shared = t * 1024 ret.Shared = t * 1024
case "Slab": case "Slab":
t, err := strconv.ParseUint(value, 10, 64)
if err != nil {
return ret, retEx, err
}
ret.Slab = t * 1024 ret.Slab = t * 1024
case "SReclaimable": case "SReclaimable":
t, err := strconv.ParseUint(value, 10, 64)
if err != nil {
return ret, retEx, err
}
sReclaimable = true sReclaimable = true
ret.Sreclaimable = t * 1024 ret.Sreclaimable = t * 1024
case "SUnreclaim": case "SUnreclaim":
t, err := strconv.ParseUint(value, 10, 64)
if err != nil {
return ret, retEx, err
}
ret.Sunreclaim = t * 1024 ret.Sunreclaim = t * 1024
case "PageTables": case "PageTables":
t, err := strconv.ParseUint(value, 10, 64)
if err != nil {
return ret, retEx, err
}
ret.PageTables = t * 1024 ret.PageTables = t * 1024
case "SwapCached": case "SwapCached":
t, err := strconv.ParseUint(value, 10, 64)
if err != nil {
return ret, retEx, err
}
ret.SwapCached = t * 1024 ret.SwapCached = t * 1024
case "CommitLimit": case "CommitLimit":
t, err := strconv.ParseUint(value, 10, 64)
if err != nil {
return ret, retEx, err
}
ret.CommitLimit = t * 1024 ret.CommitLimit = t * 1024
case "Committed_AS": case "Committed_AS":
t, err := strconv.ParseUint(value, 10, 64)
if err != nil {
return ret, retEx, err
}
ret.CommittedAS = t * 1024 ret.CommittedAS = t * 1024
case "HighTotal": case "HighTotal":
t, err := strconv.ParseUint(value, 10, 64)
if err != nil {
return ret, retEx, err
}
ret.HighTotal = t * 1024 ret.HighTotal = t * 1024
case "HighFree": case "HighFree":
t, err := strconv.ParseUint(value, 10, 64)
if err != nil {
return ret, retEx, err
}
ret.HighFree = t * 1024 ret.HighFree = t * 1024
case "LowTotal": case "LowTotal":
t, err := strconv.ParseUint(value, 10, 64)
if err != nil {
return ret, retEx, err
}
ret.LowTotal = t * 1024 ret.LowTotal = t * 1024
case "LowFree": case "LowFree":
t, err := strconv.ParseUint(value, 10, 64)
if err != nil {
return ret, retEx, err
}
ret.LowFree = t * 1024 ret.LowFree = t * 1024
case "SwapTotal": case "SwapTotal":
t, err := strconv.ParseUint(value, 10, 64)
if err != nil {
return ret, retEx, err
}
ret.SwapTotal = t * 1024 ret.SwapTotal = t * 1024
case "SwapFree": case "SwapFree":
t, err := strconv.ParseUint(value, 10, 64)
if err != nil {
return ret, retEx, err
}
ret.SwapFree = t * 1024 ret.SwapFree = t * 1024
case "Mapped": case "Mapped":
t, err := strconv.ParseUint(value, 10, 64)
if err != nil {
return ret, retEx, err
}
ret.Mapped = t * 1024 ret.Mapped = t * 1024
case "VmallocTotal": case "VmallocTotal":
t, err := strconv.ParseUint(value, 10, 64)
if err != nil {
return ret, retEx, err
}
ret.VmallocTotal = t * 1024 ret.VmallocTotal = t * 1024
case "VmallocUsed": case "VmallocUsed":
t, err := strconv.ParseUint(value, 10, 64)
if err != nil {
return ret, retEx, err
}
ret.VmallocUsed = t * 1024 ret.VmallocUsed = t * 1024
case "VmallocChunk": case "VmallocChunk":
t, err := strconv.ParseUint(value, 10, 64)
if err != nil {
return ret, retEx, err
}
ret.VmallocChunk = t * 1024 ret.VmallocChunk = t * 1024
case "HugePages_Total": case "HugePages_Total":
t, err := strconv.ParseUint(value, 10, 64)
if err != nil {
return ret, retEx, err
}
ret.HugePagesTotal = t ret.HugePagesTotal = t
case "HugePages_Free": case "HugePages_Free":
t, err := strconv.ParseUint(value, 10, 64)
if err != nil {
return ret, retEx, err
}
ret.HugePagesFree = t ret.HugePagesFree = t
case "Hugepagesize": case "Hugepagesize":
t, err := strconv.ParseUint(value, 10, 64)
if err != nil {
return ret, retEx, err
}
ret.HugePageSize = t * 1024 ret.HugePageSize = t * 1024
} }
} }

37
v3/mem/mem_linux_test.go
Unescape Escape View File

@ -57,6 +57,43 @@ var virtualMemoryTests = []struct {
HugePagesFree: 0, HugePagesFree: 0,
HugePageSize: 2097152}, HugePageSize: 2097152},
}, },
{"issue1002", &VirtualMemoryStat{
Total: 260579328,
Available: 215199744,
Used: 34328576,
UsedPercent: 13.173944481121694,
Free: 124506112,
Active: 108785664,
Inactive: 8581120,
Wired: 0,
Laundry: 0,
Buffers: 4915200,
Cached: 96829440,
WriteBack: 0,
Dirty: 0,
WriteBackTmp: 0,
Shared: 0,
Slab: 9293824,
Sreclaimable: 2764800,
Sunreclaim: 6529024,
PageTables: 405504,
SwapCached: 0,
CommitLimit: 130289664,
CommittedAS: 25567232,
HighTotal: 134217728,
HighFree: 67784704,
LowTotal: 126361600,
LowFree: 56721408,
SwapTotal: 0,
SwapFree: 0,
Mapped: 38793216,
VmallocTotal: 1996488704,
VmallocUsed: 0,
VmallocChunk: 0,
HugePagesTotal: 0,
HugePagesFree: 0,
HugePageSize: 0},
},
} }
func TestVirtualMemoryLinux(t *testing.T) { func TestVirtualMemoryLinux(t *testing.T) {

42
v3/mem/testdata/linux/virtualmemory/issue1002/proc/meminfo vendored
Unescape Escape View File

@ -0,0 +1,42 @@
total: used: free: shared: buffers: cached:
Mem: 260579328 136073216 124506112 0 4915200 94064640
Swap: 0 0 0
MemTotal: 254472 kB
MemFree: 121588 kB
MemShared: 0 kB
Buffers: 4800 kB
Cached: 91860 kB
SwapCached: 0 kB
Active: 106236 kB
Inactive: 8380 kB
MemAvailable: 210156 kB
Active(anon): 17956 kB
Inactive(anon): 0 kB
Active(file): 88280 kB
Inactive(file): 8380 kB
Unevictable: 0 kB
Mlocked: 0 kB
HighTotal: 131072 kB
HighFree: 66196 kB
LowTotal: 123400 kB
LowFree: 55392 kB
SwapTotal: 0 kB
SwapFree: 0 kB
Dirty: 0 kB
Writeback: 0 kB
AnonPages: 17992 kB
Mapped: 37884 kB
Shmem: 0 kB
Slab: 9076 kB
SReclaimable: 2700 kB
SUnreclaim: 6376 kB
KernelStack: 624 kB
PageTables: 396 kB
NFS_Unstable: 0 kB
Bounce: 0 kB
WritebackTmp: 0 kB
CommitLimit: 127236 kB
Committed_AS: 24968 kB
VmallocTotal: 1949696 kB
VmallocUsed: 0 kB
VmallocChunk: 0 kB
Write Preview
Loading…
Cancel
Save