1377 lines
47 KiB
Python
Executable File
1377 lines
47 KiB
Python
Executable File
#!/usr/local/bin/python
|
|
#
|
|
# $Id: arc_summary.pl,v 388:e27800740aa2 2011-07-08 02:53:29Z jhell $
|
|
#
|
|
# Copyright (c) 2008 Ben Rockwood <benr@cuddletech.com>,
|
|
# Copyright (c) 2010 Martin Matuska <mm@FreeBSD.org>,
|
|
# Copyright (c) 2010-2011 Jason J. Hellenthal <jhell@DataIX.net>,
|
|
# All rights reserved.
|
|
#
|
|
# Redistribution and use in source and binary forms, with or without
|
|
# modification, are permitted provided that the following conditions
|
|
# are met:
|
|
#
|
|
# 1. Redistributions of source code must retain the above copyright
|
|
# notice, this list of conditions and the following disclaimer.
|
|
# 2. Redistributions in binary form must reproduce the above copyright
|
|
# notice, this list of conditions and the following disclaimer in the
|
|
# documentation and/or other materials provided with the distribution.
|
|
#
|
|
# THIS SOFTWARE IS PROVIDED BY AUTHOR AND CONTRIBUTORS ``AS IS'' AND
|
|
# ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
|
|
# IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
|
|
# ARE DISCLAIMED. IN NO EVENT SHALL AUTHOR OR CONTRIBUTORS BE LIABLE
|
|
# FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
|
|
# DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
|
|
# OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
|
|
# HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
|
|
# LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
|
|
# OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
|
|
# SUCH DAMAGE.
|
|
#
|
|
# If you are having troubles when using this script from cron(8) please try
|
|
# adjusting your PATH before reporting problems.
|
|
#
|
|
# /usr/bin & /sbin
|
|
#
|
|
# Binaries used are:
|
|
#
|
|
# dc(1), kldstat(8), sed(1), sysctl(8) & vmstat(8)
|
|
#
|
|
# Binaries that I am working on phasing out are:
|
|
#
|
|
# dc(1) & sed(1)
|
|
|
|
import sys
|
|
import time
|
|
import getopt
|
|
import re
|
|
|
|
from subprocess import Popen, PIPE
|
|
from decimal import Decimal as D
|
|
|
|
|
|
usetunable = True
|
|
show_sysctl_descriptions = False
|
|
alternate_sysctl_layout = False
|
|
kstat_pobj = re.compile("^([^:]+):\s+(.+)\s*$", flags=re.M)
|
|
|
|
|
|
def get_Kstat():
|
|
Kstats = [
|
|
"hw.pagesize",
|
|
"hw.physmem",
|
|
"kern.maxusers",
|
|
"vm.kmem_map_free",
|
|
"vm.kmem_map_size",
|
|
"vm.kmem_size",
|
|
"vm.kmem_size_max",
|
|
"vm.kmem_size_min",
|
|
"vm.kmem_size_scale",
|
|
"vm.stats",
|
|
"vm.swap_total",
|
|
"vm.swap_reserved",
|
|
"kstat.zfs",
|
|
"vfs.zfs"
|
|
]
|
|
|
|
sysctls = " ".join(str(x) for x in Kstats)
|
|
p = Popen("/sbin/sysctl -q %s" % sysctls, stdin=PIPE,
|
|
stdout=PIPE, stderr=PIPE, shell=True, close_fds=True)
|
|
p.wait()
|
|
|
|
kstat_pull = p.communicate()[0].split('\n')
|
|
if p.returncode != 0:
|
|
sys.exit(1)
|
|
|
|
Kstat = {}
|
|
for kstat in kstat_pull:
|
|
kstat = kstat.strip()
|
|
mobj = kstat_pobj.match(kstat)
|
|
if mobj:
|
|
key = mobj.group(1).strip()
|
|
val = mobj.group(2).strip()
|
|
Kstat[key] = D(val)
|
|
|
|
return Kstat
|
|
|
|
|
|
def div1():
|
|
sys.stdout.write("\n")
|
|
for i in xrange(18):
|
|
sys.stdout.write("%s" % "----")
|
|
sys.stdout.write("\n")
|
|
|
|
|
|
def div2():
|
|
div1()
|
|
sys.stdout.write("\n")
|
|
|
|
|
|
def fBytes(Bytes=0, Decimal=2):
|
|
kbytes = (2 ** 10)
|
|
mbytes = (2 ** 20)
|
|
gbytes = (2 ** 30)
|
|
tbytes = (2 ** 40)
|
|
pbytes = (2 ** 50)
|
|
ebytes = (2 ** 60)
|
|
zbytes = (2 ** 70)
|
|
ybytes = (2 ** 80)
|
|
|
|
if Bytes >= ybytes:
|
|
return str("%0." + str(Decimal) + "f") % (Bytes / ybytes) + "\tYiB"
|
|
elif Bytes >= zbytes:
|
|
return str("%0." + str(Decimal) + "f") % (Bytes / zbytes) + "\tZiB"
|
|
elif Bytes >= ebytes:
|
|
return str("%0." + str(Decimal) + "f") % (Bytes / ebytes) + "\tEiB"
|
|
elif Bytes >= pbytes:
|
|
return str("%0." + str(Decimal) + "f") % (Bytes / pbytes) + "\tPiB"
|
|
elif Bytes >= tbytes:
|
|
return str("%0." + str(Decimal) + "f") % (Bytes / tbytes) + "\tTiB"
|
|
elif Bytes >= gbytes:
|
|
return str("%0." + str(Decimal) + "f") % (Bytes / gbytes) + "\tGiB"
|
|
elif Bytes >= mbytes:
|
|
return str("%0." + str(Decimal) + "f") % (Bytes / mbytes) + "\tMiB"
|
|
elif Bytes >= kbytes:
|
|
return str("%0." + str(Decimal) + "f") % (Bytes / kbytes) + "\tKiB"
|
|
elif Bytes == 0:
|
|
return str("%d" % 0) + "\tBytes"
|
|
else:
|
|
return str("%d" % Bytes) + "\tBytes"
|
|
|
|
|
|
def fHits(Hits=0, Decimal=2):
|
|
khits = (10 ** 3)
|
|
mhits = (10 ** 6)
|
|
bhits = (10 ** 9)
|
|
thits = (10 ** 12)
|
|
qhits = (10 ** 15)
|
|
Qhits = (10 ** 18)
|
|
shits = (10 ** 21)
|
|
Shits = (10 ** 24)
|
|
|
|
if Hits >= Shits:
|
|
return str("%0." + str(Decimal) + "f") % (Hits / Shits) + "S"
|
|
elif Hits >= shits:
|
|
return str("%0." + str(Decimal) + "f") % (Hits / shits) + "s"
|
|
elif Hits >= Qhits:
|
|
return str("%0." + str(Decimal) + "f") % (Hits / Qhits) + "Q"
|
|
elif Hits >= qhits:
|
|
return str("%0." + str(Decimal) + "f") % (Hits / qhits) + "q"
|
|
elif Hits >= thits:
|
|
return str("%0." + str(Decimal) + "f") % (Hits / thits) + "t"
|
|
elif Hits >= bhits:
|
|
return str("%0." + str(Decimal) + "f") % (Hits / bhits) + "b"
|
|
elif Hits >= mhits:
|
|
return str("%0." + str(Decimal) + "f") % (Hits / mhits) + "m"
|
|
elif Hits >= khits:
|
|
return str("%0." + str(Decimal) + "f") % (Hits / khits) + "k"
|
|
elif Hits == 0:
|
|
return str("%d" % 0)
|
|
else:
|
|
return str("%d" % Hits)
|
|
|
|
|
|
def fPerc(lVal=0, rVal=0, Decimal=2):
|
|
if rVal > 0:
|
|
return str("%0." + str(Decimal) + "f") % (100 * (lVal / rVal)) + "%"
|
|
else:
|
|
return str("%0." + str(Decimal) + "f") % 100 + "%"
|
|
|
|
|
|
def get_system_memory(Kstat):
|
|
def mem_rounded(mem_size):
|
|
chip_size = 1
|
|
chip_guess = (int(mem_size) / 8) - 1
|
|
while chip_guess != 0:
|
|
chip_guess >>= 1
|
|
chip_size <<= 1
|
|
|
|
mem_round = (int(mem_size / chip_size) + 1) * chip_size
|
|
return mem_round
|
|
|
|
output = {}
|
|
|
|
pagesize = Kstat["hw.pagesize"]
|
|
mem_hw = mem_rounded(Kstat["hw.physmem"])
|
|
mem_phys = Kstat["hw.physmem"]
|
|
mem_all = Kstat["vm.stats.vm.v_page_count"] * pagesize
|
|
mem_wire = Kstat["vm.stats.vm.v_wire_count"] * pagesize
|
|
mem_active = Kstat["vm.stats.vm.v_active_count"] * pagesize
|
|
mem_inactive = Kstat["vm.stats.vm.v_inactive_count"] * pagesize
|
|
mem_cache = Kstat["vm.stats.vm.v_cache_count"] * pagesize
|
|
mem_free = Kstat["vm.stats.vm.v_free_count"] * pagesize
|
|
|
|
mem_gap_vm = mem_all - (
|
|
mem_wire + mem_active + mem_inactive + mem_cache + mem_free
|
|
)
|
|
|
|
mem_total = mem_hw
|
|
mem_avail = mem_inactive + mem_cache + mem_free
|
|
mem_used = mem_total - mem_avail
|
|
output["active"] = {
|
|
'per': fPerc(mem_active, mem_all),
|
|
'num': fBytes(mem_active),
|
|
}
|
|
output["inact"] = {
|
|
'per': fPerc(mem_inactive, mem_all),
|
|
'num': fBytes(mem_inactive),
|
|
}
|
|
output["wired"] = {
|
|
'per': fPerc(mem_wire, mem_all),
|
|
'num': fBytes(mem_wire),
|
|
}
|
|
output["cache"] = {
|
|
'per': fPerc(mem_cache, mem_all),
|
|
'num': fBytes(mem_cache),
|
|
}
|
|
output["free"] = {
|
|
'per': fPerc(mem_free, mem_all),
|
|
'num': fBytes(mem_free),
|
|
}
|
|
output["gap"] = {
|
|
'per': fPerc(mem_gap_vm, mem_all),
|
|
'num': fBytes(mem_gap_vm),
|
|
}
|
|
output["real_installed"] = fBytes(mem_hw)
|
|
output["real_available"] = {
|
|
'per': fPerc(mem_phys, mem_hw),
|
|
'num': fBytes(mem_phys),
|
|
}
|
|
output["real_managed"] = {
|
|
'per': fPerc(mem_all, mem_phys),
|
|
'num': fBytes(mem_all),
|
|
}
|
|
output["logical_total"] = fBytes(mem_total)
|
|
output["logical_used"] = {
|
|
'per': fPerc(mem_used, mem_total),
|
|
'num': fBytes(mem_used),
|
|
}
|
|
output["logical_free"] = {
|
|
'per': fPerc(mem_avail, mem_total),
|
|
'num': fBytes(mem_avail),
|
|
}
|
|
|
|
swap_total = Kstat["vm.swap_total"]
|
|
output["swap_total"] = fBytes(swap_total)
|
|
output["swap_reserved"] = fBytes(Kstat["vm.swap_reserved"])
|
|
|
|
if int(swap_total) > 0:
|
|
proc = Popen(
|
|
"/usr/sbin/swapinfo -k|tail -1|awk '{print $3}'",
|
|
shell=True,
|
|
stdout=PIPE,
|
|
stderr=PIPE,
|
|
)
|
|
try:
|
|
swap_used = int(proc.communicate()[0])
|
|
except:
|
|
swap_used = 0
|
|
output['swap_used'] = fBytes(swap_used * 1024)
|
|
else:
|
|
output['swap_used'] = fBytes(0)
|
|
|
|
output['kmem_map_size'] = Kstat["vm.kmem_map_size"]
|
|
output['kmem_map_free'] = Kstat["vm.kmem_map_free"]
|
|
|
|
return output
|
|
|
|
|
|
def _system_memory(Kstat):
|
|
|
|
arc = get_system_memory(Kstat)
|
|
|
|
sys.stdout.write("System Memory:\n")
|
|
sys.stdout.write("\n")
|
|
sys.stdout.write("\t%s\t%s Active,\t" % (
|
|
arc['active']['per'],
|
|
arc['active']['num'],
|
|
)
|
|
)
|
|
|
|
sys.stdout.write("%s\t%s Inact\n" % (
|
|
arc['inact']['per'],
|
|
arc['inact']['num'],
|
|
)
|
|
)
|
|
sys.stdout.write("\t%s\t%s Wired,\t" % (
|
|
arc['wired']['per'],
|
|
arc['wired']['num'],
|
|
)
|
|
)
|
|
sys.stdout.write("%s\t%s Cache\n" % (
|
|
arc['cache']['per'],
|
|
arc['cache']['num'],
|
|
)
|
|
)
|
|
sys.stdout.write("\t%s\t%s Free,\t" % (
|
|
arc['free']['per'],
|
|
arc['free']['num'],
|
|
)
|
|
)
|
|
sys.stdout.write("%s\t%s Gap\n" % (
|
|
arc['gap']['per'],
|
|
arc['gap']['num'],
|
|
)
|
|
)
|
|
sys.stdout.write("\n")
|
|
sys.stdout.write("\tReal Installed:\t\t\t\t%s\n" % arc['real_installed'])
|
|
sys.stdout.write("\tReal Available:\t\t\t%s\t%s\n" % (
|
|
arc['real_available']['per'],
|
|
arc['real_available']['num'],
|
|
)
|
|
)
|
|
sys.stdout.write("\tReal Managed:\t\t\t%s\t%s\n" % (
|
|
arc['real_managed']['per'],
|
|
arc['real_managed']['num'],
|
|
)
|
|
)
|
|
|
|
sys.stdout.write("\n")
|
|
sys.stdout.write("\tLogical Total:\t\t\t\t%s\n" % arc['logical_total'])
|
|
sys.stdout.write("\tLogical Used:\t\t\t%s\t%s\n" % (
|
|
arc['logical_used']['per'],
|
|
arc['logical_used']['num'],
|
|
)
|
|
)
|
|
sys.stdout.write("\tLogical Free:\t\t\t%s\t%s\n" % (
|
|
arc['logical_free']['per'],
|
|
arc['logical_free']['num'],
|
|
)
|
|
)
|
|
sys.stdout.write("\n")
|
|
|
|
cmd1 = """
|
|
/sbin/kldstat | \
|
|
/usr/bin/awk '
|
|
BEGIN {
|
|
print "16i 0";
|
|
}
|
|
NR > 1 {
|
|
print toupper($4) "+";
|
|
}
|
|
END {
|
|
print "p";
|
|
}
|
|
' | /usr/bin/dc
|
|
"""
|
|
|
|
cmd2 = """
|
|
/usr/bin/vmstat -m | \
|
|
/usr/bin/sed -Ee '1s/.*/0/;s/.* ([0-9]+)K.*/\\1+/;$s/$/1024*p/' | \
|
|
/usr/bin/dc
|
|
"""
|
|
|
|
p1 = Popen(cmd1, stdin=PIPE, stdout=PIPE, stderr=PIPE, shell=True, close_fds=True)
|
|
p2 = Popen(cmd2, stdin=PIPE, stdout=PIPE, stderr=PIPE, shell=True, close_fds=True)
|
|
|
|
ktext = D(p1.communicate()[0].strip())
|
|
kdata = D(p2.communicate()[0].strip())
|
|
|
|
if p1.returncode != 0 or p2.returncode != 0:
|
|
sys.exit(1)
|
|
|
|
kmem = ktext + kdata
|
|
kmem_map_size = arc['kmem_map_size']
|
|
kmem_map_free = arc['kmem_map_free']
|
|
kmem_map_total = kmem_map_size + kmem_map_free
|
|
|
|
sys.stdout.write("Kernel Memory:\t\t\t\t\t%s\n" % fBytes(kmem))
|
|
sys.stdout.write("\tData:\t\t\t\t%s\t%s\n" % (fPerc(kdata, kmem), fBytes(kdata)))
|
|
sys.stdout.write("\tText:\t\t\t\t%s\t%s\n\n" % (fPerc(ktext, kmem), fBytes(ktext)))
|
|
|
|
sys.stdout.write("Kernel Memory Map:\t\t\t\t%s\n" % fBytes(kmem_map_total))
|
|
sys.stdout.write("\tSize:\t\t\t\t%s\t%s\n" % (fPerc(kmem_map_size, kmem_map_total), fBytes(kmem_map_size)))
|
|
sys.stdout.write("\tFree:\t\t\t\t%s\t%s\n" % (fPerc(kmem_map_free, kmem_map_total), fBytes(kmem_map_free)))
|
|
|
|
|
|
def get_arc_summary(Kstat):
|
|
|
|
output = {}
|
|
if "vfs.zfs.version.spa" not in Kstat:
|
|
return {}
|
|
|
|
spa = Kstat["vfs.zfs.version.spa"]
|
|
zpl = Kstat["vfs.zfs.version.zpl"]
|
|
memory_throttle_count = Kstat[
|
|
"kstat.zfs.misc.arcstats.memory_throttle_count"
|
|
]
|
|
|
|
if memory_throttle_count > 0:
|
|
output['health'] = 'THROTTLED'
|
|
else:
|
|
output['health'] = 'HEALTHY'
|
|
|
|
output['storage_pool_ver'] = spa
|
|
output['filesystem_ver'] = zpl
|
|
output['memory_throttle_count'] = fHits(memory_throttle_count)
|
|
|
|
### ARC Misc. ###
|
|
deleted = Kstat["kstat.zfs.misc.arcstats.deleted"]
|
|
#evict_skip = Kstat["kstat.zfs.misc.arcstats.evict_skip"]
|
|
mutex_miss = Kstat["kstat.zfs.misc.arcstats.mutex_miss"]
|
|
recycle_miss = Kstat["kstat.zfs.misc.arcstats.recycle_miss"]
|
|
|
|
### ARC Misc. ###
|
|
output["arc_misc"] = {}
|
|
output["arc_misc"]["deleted"] = fHits(deleted)
|
|
output["arc_misc"]['recycle_miss'] = fHits(recycle_miss)
|
|
output["arc_misc"]['mutex_miss'] = fHits(mutex_miss)
|
|
output["arc_misc"]['evict_skips'] = fHits(mutex_miss)
|
|
|
|
### ARC Sizing ###
|
|
arc_size = Kstat["kstat.zfs.misc.arcstats.size"]
|
|
mru_size = Kstat["kstat.zfs.misc.arcstats.p"]
|
|
target_max_size = Kstat["kstat.zfs.misc.arcstats.c_max"]
|
|
target_min_size = Kstat["kstat.zfs.misc.arcstats.c_min"]
|
|
target_size = Kstat["kstat.zfs.misc.arcstats.c"]
|
|
|
|
target_size_ratio = (target_max_size / target_min_size)
|
|
|
|
### ARC Sizing ###
|
|
output['arc_sizing'] = {}
|
|
output['arc_sizing']['arc_size'] = {
|
|
'per': fPerc(arc_size, target_max_size),
|
|
'num': fBytes(arc_size),
|
|
}
|
|
output['arc_sizing']['target_max_size'] = {
|
|
'ratio': target_size_ratio,
|
|
'num': fBytes(target_max_size),
|
|
}
|
|
output['arc_sizing']['target_min_size'] = {
|
|
'per': fPerc(target_min_size, target_max_size),
|
|
'num': fBytes(target_min_size),
|
|
}
|
|
output['arc_sizing']['target_size'] = {
|
|
'per': fPerc(target_size, target_max_size),
|
|
'num': fBytes(target_size),
|
|
}
|
|
|
|
### ARC Hash Breakdown ###
|
|
output['arc_hash_break'] = {}
|
|
output['arc_hash_break']['hash_chain_max'] = Kstat[
|
|
"kstat.zfs.misc.arcstats.hash_chain_max"
|
|
]
|
|
output['arc_hash_break']['hash_chains'] = Kstat[
|
|
"kstat.zfs.misc.arcstats.hash_chains"
|
|
]
|
|
output['arc_hash_break']['hash_collisions'] = Kstat[
|
|
"kstat.zfs.misc.arcstats.hash_collisions"
|
|
]
|
|
output['arc_hash_break']['hash_elements'] = Kstat[
|
|
"kstat.zfs.misc.arcstats.hash_elements"
|
|
]
|
|
output['arc_hash_break']['hash_elements_max'] = Kstat[
|
|
"kstat.zfs.misc.arcstats.hash_elements_max"
|
|
]
|
|
|
|
output['arc_size_break'] = {}
|
|
if arc_size > target_size:
|
|
mfu_size = (arc_size - mru_size)
|
|
output['arc_size_break']['recently_used_cache_size'] = {
|
|
'per': fPerc(mru_size, arc_size),
|
|
'num': fBytes(mru_size),
|
|
}
|
|
output['arc_size_break']['frequently_used_cache_size'] = {
|
|
'per': fPerc(mfu_size, arc_size),
|
|
'num': fBytes(mfu_size),
|
|
}
|
|
|
|
elif arc_size < target_size:
|
|
mfu_size = (target_size - mru_size)
|
|
output['arc_size_break']['recently_used_cache_size'] = {
|
|
'per': fPerc(mru_size, target_size),
|
|
'num': fBytes(mru_size),
|
|
}
|
|
output['arc_size_break']['frequently_used_cache_size'] = {
|
|
'per': fPerc(mfu_size, target_size),
|
|
'num': fBytes(mfu_size),
|
|
}
|
|
|
|
### ARC Hash Breakdown ###
|
|
hash_chain_max = Kstat["kstat.zfs.misc.arcstats.hash_chain_max"]
|
|
hash_chains = Kstat["kstat.zfs.misc.arcstats.hash_chains"]
|
|
hash_collisions = Kstat["kstat.zfs.misc.arcstats.hash_collisions"]
|
|
hash_elements = Kstat["kstat.zfs.misc.arcstats.hash_elements"]
|
|
hash_elements_max = Kstat["kstat.zfs.misc.arcstats.hash_elements_max"]
|
|
|
|
output['arc_hash_break'] = {}
|
|
output['arc_hash_break']['elements_max'] = fHits(hash_elements_max)
|
|
output['arc_hash_break']['elements_current'] = {
|
|
'per': fPerc(hash_elements, hash_elements_max),
|
|
'num': fHits(hash_elements),
|
|
}
|
|
output['arc_hash_break']['collisions'] = fHits(hash_collisions)
|
|
output['arc_hash_break']['chain_max'] = fHits(hash_chain_max)
|
|
output['arc_hash_break']['chains'] = fHits(hash_chains)
|
|
|
|
return output
|
|
|
|
|
|
def _arc_summary(Kstat):
|
|
### ARC Sizing ###
|
|
arc = get_arc_summary(Kstat)
|
|
|
|
sys.stdout.write("ARC Summary: (%s)\n" % arc['health'])
|
|
|
|
sys.stdout.write("\tStorage pool Version:\t\t\t%d\n" % arc['storage_pool_ver'])
|
|
sys.stdout.write("\tFilesystem Version:\t\t\t%d\n" % arc['filesystem_ver'])
|
|
sys.stdout.write("\tMemory Throttle Count:\t\t\t%s\n" % arc['memory_throttle_count'])
|
|
sys.stdout.write("\n")
|
|
|
|
### ARC Misc. ###
|
|
sys.stdout.write("ARC Misc:\n")
|
|
sys.stdout.write("\tDeleted:\t\t\t\t%s\n" % arc['arc_misc']['deleted'])
|
|
sys.stdout.write("\tRecycle Misses:\t\t\t\t%s\n" % arc['arc_misc']['recycle_miss'])
|
|
sys.stdout.write("\tMutex Misses:\t\t\t\t%s\n" % arc['arc_misc']['mutex_miss'])
|
|
sys.stdout.write("\tEvict Skips:\t\t\t\t%s\n" % arc['arc_misc']['mutex_miss'])
|
|
sys.stdout.write("\n")
|
|
|
|
### ARC Sizing ###
|
|
sys.stdout.write("ARC Size:\t\t\t\t%s\t%s\n" % (
|
|
arc['arc_sizing']['arc_size']['per'],
|
|
arc['arc_sizing']['arc_size']['num']
|
|
)
|
|
)
|
|
sys.stdout.write("\tTarget Size: (Adaptive)\t\t%s\t%s\n" % (
|
|
arc['arc_sizing']['target_size']['per'],
|
|
arc['arc_sizing']['target_size']['num'],
|
|
)
|
|
)
|
|
|
|
sys.stdout.write("\tMin Size (Hard Limit):\t\t%s\t%s\n" % (
|
|
arc['arc_sizing']['target_min_size']['per'],
|
|
arc['arc_sizing']['target_min_size']['num'],
|
|
)
|
|
)
|
|
|
|
sys.stdout.write("\tMax Size (High Water):\t\t%d:1\t%s\n" % (
|
|
arc['arc_sizing']['target_max_size']['ratio'],
|
|
arc['arc_sizing']['target_max_size']['num'],
|
|
)
|
|
)
|
|
|
|
sys.stdout.write("\nARC Size Breakdown:\n")
|
|
sys.stdout.write("\tRecently Used Cache Size:\t%s\t%s\n" % (
|
|
arc['arc_size_break']['recently_used_cache_size']['per'],
|
|
arc['arc_size_break']['recently_used_cache_size']['num'],
|
|
)
|
|
)
|
|
sys.stdout.write("\tFrequently Used Cache Size:\t%s\t%s\n" % (
|
|
arc['arc_size_break']['frequently_used_cache_size']['per'],
|
|
arc['arc_size_break']['frequently_used_cache_size']['num'],
|
|
)
|
|
)
|
|
|
|
sys.stdout.write("\n")
|
|
|
|
### ARC Hash Breakdown ###
|
|
sys.stdout.write("ARC Hash Breakdown:\n")
|
|
sys.stdout.write("\tElements Max:\t\t\t\t%s\n" % arc['arc_hash_break']['elements_max'])
|
|
sys.stdout.write("\tElements Current:\t\t%s\t%s\n" % (
|
|
arc['arc_hash_break']['elements_current']['per'],
|
|
arc['arc_hash_break']['elements_current']['num'],
|
|
)
|
|
)
|
|
sys.stdout.write("\tCollisions:\t\t\t\t%s\n" % arc['arc_hash_break']['collisions'])
|
|
sys.stdout.write("\tChain Max:\t\t\t\t%s\n" % arc['arc_hash_break']['chain_max'])
|
|
sys.stdout.write("\tChains:\t\t\t\t\t%s\n" % arc['arc_hash_break']['chains'])
|
|
|
|
|
|
def get_arc_efficiency(Kstat):
|
|
output = {}
|
|
|
|
if "vfs.zfs.version.spa" not in Kstat:
|
|
return
|
|
|
|
arc_hits = Kstat["kstat.zfs.misc.arcstats.hits"]
|
|
arc_misses = Kstat["kstat.zfs.misc.arcstats.misses"]
|
|
demand_data_hits = Kstat["kstat.zfs.misc.arcstats.demand_data_hits"]
|
|
demand_data_misses = Kstat["kstat.zfs.misc.arcstats.demand_data_misses"]
|
|
demand_metadata_hits = Kstat[
|
|
"kstat.zfs.misc.arcstats.demand_metadata_hits"
|
|
]
|
|
demand_metadata_misses = Kstat[
|
|
"kstat.zfs.misc.arcstats.demand_metadata_misses"
|
|
]
|
|
mfu_ghost_hits = Kstat["kstat.zfs.misc.arcstats.mfu_ghost_hits"]
|
|
mfu_hits = Kstat["kstat.zfs.misc.arcstats.mfu_hits"]
|
|
mru_ghost_hits = Kstat["kstat.zfs.misc.arcstats.mru_ghost_hits"]
|
|
mru_hits = Kstat["kstat.zfs.misc.arcstats.mru_hits"]
|
|
prefetch_data_hits = Kstat["kstat.zfs.misc.arcstats.prefetch_data_hits"]
|
|
prefetch_data_misses = Kstat[
|
|
"kstat.zfs.misc.arcstats.prefetch_data_misses"
|
|
]
|
|
prefetch_metadata_hits = Kstat[
|
|
"kstat.zfs.misc.arcstats.prefetch_metadata_hits"
|
|
]
|
|
prefetch_metadata_misses = Kstat[
|
|
"kstat.zfs.misc.arcstats.prefetch_metadata_misses"
|
|
]
|
|
|
|
anon_hits = arc_hits - (
|
|
mfu_hits + mru_hits + mfu_ghost_hits + mru_ghost_hits
|
|
)
|
|
arc_accesses_total = (arc_hits + arc_misses)
|
|
demand_data_total = (demand_data_hits + demand_data_misses)
|
|
prefetch_data_total = (prefetch_data_hits + prefetch_data_misses)
|
|
real_hits = (mfu_hits + mru_hits)
|
|
|
|
output["total_accesses"] = fHits(arc_accesses_total)
|
|
output["cache_hit_ratio"] = {
|
|
'per': fPerc(arc_hits, arc_accesses_total),
|
|
'num': fHits(arc_hits),
|
|
}
|
|
output["cache_miss_ratio"] = {
|
|
'per': fPerc(arc_misses, arc_accesses_total),
|
|
'num': fHits(arc_misses),
|
|
}
|
|
output["actual_hit_ratio"] = {
|
|
'per': fPerc(real_hits, arc_accesses_total),
|
|
'num': fHits(real_hits),
|
|
}
|
|
output["data_demand_efficiency"] = {
|
|
'per': fPerc(demand_data_hits, demand_data_total),
|
|
'num': fHits(demand_data_total),
|
|
}
|
|
|
|
if prefetch_data_total > 0:
|
|
output["data_prefetch_efficiency"] = {
|
|
'per': fPerc(prefetch_data_hits, prefetch_data_total),
|
|
'num': fHits(prefetch_data_total),
|
|
}
|
|
|
|
if anon_hits > 0:
|
|
output["cache_hits_by_cache_list"] = {}
|
|
output["cache_hits_by_cache_list"]["anonymously_used"] = {
|
|
'per': fPerc(anon_hits, arc_hits),
|
|
'num': fHits(anon_hits),
|
|
}
|
|
|
|
output["most_recently_used"] = {
|
|
'per': fPerc(mru_hits, arc_hits),
|
|
'num': fHits(mru_hits),
|
|
}
|
|
output["most_frequently_used"] = {
|
|
'per': fPerc(mfu_hits, arc_hits),
|
|
'num': fHits(mfu_hits),
|
|
}
|
|
output["most_recently_used_ghost"] = {
|
|
'per': fPerc(mru_ghost_hits, arc_hits),
|
|
'num': fHits(mru_ghost_hits),
|
|
}
|
|
output["most_frequently_used_ghost"] = {
|
|
'per': fPerc(mfu_ghost_hits, arc_hits),
|
|
'num': fHits(mfu_ghost_hits),
|
|
}
|
|
|
|
output["cache_hits_by_data_type"] = {}
|
|
output["cache_hits_by_data_type"]["demand_data"] = {
|
|
'per': fPerc(demand_data_hits, arc_hits),
|
|
'num': fHits(demand_data_hits),
|
|
}
|
|
output["cache_hits_by_data_type"]["prefetch_data"] = {
|
|
'per': fPerc(prefetch_data_hits, arc_hits),
|
|
'num': fHits(prefetch_data_hits),
|
|
}
|
|
output["cache_hits_by_data_type"]["demand_metadata"] = {
|
|
'per': fPerc(demand_metadata_hits, arc_hits),
|
|
'num': fHits(demand_metadata_hits),
|
|
}
|
|
output["cache_hits_by_data_type"]["prefetch_metadata"] = {
|
|
'per': fPerc(prefetch_metadata_hits, arc_hits),
|
|
'num': fHits(prefetch_metadata_hits),
|
|
}
|
|
|
|
output["cache_misses_by_data_type"] = {}
|
|
output["cache_misses_by_data_type"]["demand_data"] = {
|
|
'per': fPerc(demand_data_misses, arc_misses),
|
|
'num': fHits(demand_data_misses),
|
|
}
|
|
output["cache_misses_by_data_type"]["prefetch_data"] = {
|
|
'per': fPerc(prefetch_data_misses, arc_misses),
|
|
'num': fHits(prefetch_data_misses),
|
|
}
|
|
output["cache_misses_by_data_type"]["demand_metadata"] = {
|
|
'per': fPerc(demand_metadata_misses, arc_misses),
|
|
'num': fHits(demand_metadata_misses),
|
|
}
|
|
output["cache_misses_by_data_type"]["prefetch_metadata"] = {
|
|
'per': fPerc(prefetch_metadata_misses, arc_misses),
|
|
'num': fHits(prefetch_metadata_misses),
|
|
}
|
|
|
|
return output
|
|
|
|
|
|
def _arc_efficiency(Kstat):
|
|
arc = get_arc_efficiency(Kstat)
|
|
|
|
sys.stdout.write("ARC Total accesses:\t\t\t\t\t%s\n" % arc['total_accesses'])
|
|
sys.stdout.write("\tCache Hit Ratio:\t\t%s\t%s\n" % (
|
|
arc['cache_hit_ratio']['per'],
|
|
arc['cache_hit_ratio']['num'],
|
|
)
|
|
)
|
|
sys.stdout.write("\tCache Miss Ratio:\t\t%s\t%s\n" % (
|
|
arc['cache_miss_ratio']['per'],
|
|
arc['cache_miss_ratio']['num'],
|
|
)
|
|
)
|
|
|
|
sys.stdout.write("\tActual Hit Ratio:\t\t%s\t%s\n" % (
|
|
arc['actual_hit_ratio']['per'],
|
|
arc['actual_hit_ratio']['num'],
|
|
)
|
|
)
|
|
|
|
sys.stdout.write("\n")
|
|
sys.stdout.write("\tData Demand Efficiency:\t\t%s\t%s\n" % (
|
|
arc['data_demand_efficiency']['per'],
|
|
arc['data_demand_efficiency']['num'],
|
|
)
|
|
)
|
|
|
|
if 'data_prefetch_efficiency' in arc:
|
|
sys.stdout.write("\tData Prefetch Efficiency:\t%s\t%s\n" % (
|
|
arc['data_prefetch_efficiency']['per'],
|
|
arc['data_prefetch_efficiency']['num'],
|
|
)
|
|
)
|
|
sys.stdout.write("\n")
|
|
|
|
sys.stdout.write("\tCACHE HITS BY CACHE LIST:\n")
|
|
if 'cache_hits_by_cache_list' in arc:
|
|
sys.stdout.write("\t Anonymously Used:\t\t%s\t%s\n" % (
|
|
arc['cache_hits_by_cache_list']['anonymously_used']['per'],
|
|
arc['cache_hits_by_cache_list']['anonymously_used']['num'],
|
|
)
|
|
)
|
|
sys.stdout.write("\t Most Recently Used:\t\t%s\t%s\n" % (
|
|
arc['most_recently_used']['per'],
|
|
arc['most_recently_used']['num'],
|
|
)
|
|
)
|
|
sys.stdout.write("\t Most Frequently Used:\t\t%s\t%s\n" % (
|
|
arc['most_frequently_used']['per'],
|
|
arc['most_frequently_used']['num'],
|
|
)
|
|
)
|
|
sys.stdout.write("\t Most Recently Used Ghost:\t%s\t%s\n" % (
|
|
arc['most_recently_used_ghost']['per'],
|
|
arc['most_recently_used_ghost']['num'],
|
|
)
|
|
)
|
|
sys.stdout.write("\t Most Frequently Used Ghost:\t%s\t%s\n" % (
|
|
arc['most_frequently_used_ghost']['per'],
|
|
arc['most_frequently_used_ghost']['num'],
|
|
)
|
|
)
|
|
|
|
sys.stdout.write("\n\tCACHE HITS BY DATA TYPE:\n")
|
|
sys.stdout.write("\t Demand Data:\t\t\t%s\t%s\n" % (
|
|
arc["cache_hits_by_data_type"]['demand_data']['per'],
|
|
arc["cache_hits_by_data_type"]['demand_data']['num'],
|
|
)
|
|
)
|
|
sys.stdout.write("\t Prefetch Data:\t\t%s\t%s\n" % (
|
|
arc["cache_hits_by_data_type"]['prefetch_data']['per'],
|
|
arc["cache_hits_by_data_type"]['prefetch_data']['num'],
|
|
)
|
|
)
|
|
sys.stdout.write("\t Demand Metadata:\t\t%s\t%s\n" % (
|
|
arc["cache_hits_by_data_type"]['demand_metadata']['per'],
|
|
arc["cache_hits_by_data_type"]['demand_metadata']['num'],
|
|
)
|
|
)
|
|
sys.stdout.write("\t Prefetch Metadata:\t\t%s\t%s\n" % (
|
|
arc["cache_hits_by_data_type"]['prefetch_metadata']['per'],
|
|
arc["cache_hits_by_data_type"]['prefetch_metadata']['num'],
|
|
)
|
|
)
|
|
|
|
sys.stdout.write("\n\tCACHE MISSES BY DATA TYPE:\n")
|
|
sys.stdout.write("\t Demand Data:\t\t\t%s\t%s\n" % (
|
|
arc["cache_misses_by_data_type"]['demand_data']['per'],
|
|
arc["cache_misses_by_data_type"]['demand_data']['num'],
|
|
)
|
|
)
|
|
sys.stdout.write("\t Prefetch Data:\t\t%s\t%s\n" % (
|
|
arc["cache_misses_by_data_type"]['prefetch_data']['per'],
|
|
arc["cache_misses_by_data_type"]['prefetch_data']['num'],
|
|
)
|
|
)
|
|
sys.stdout.write("\t Demand Metadata:\t\t%s\t%s\n" % (
|
|
arc["cache_misses_by_data_type"]['demand_metadata']['per'],
|
|
arc["cache_misses_by_data_type"]['demand_metadata']['num'],
|
|
)
|
|
)
|
|
sys.stdout.write("\t Prefetch Metadata:\t\t%s\t%s\n" % (
|
|
arc["cache_misses_by_data_type"]['prefetch_metadata']['per'],
|
|
arc["cache_misses_by_data_type"]['prefetch_metadata']['num'],
|
|
)
|
|
)
|
|
|
|
|
|
def get_l2arc_summary(Kstat):
|
|
output = {}
|
|
|
|
if "vfs.zfs.version.spa" not in Kstat:
|
|
return
|
|
|
|
l2_abort_lowmem = Kstat["kstat.zfs.misc.arcstats.l2_abort_lowmem"]
|
|
l2_cksum_bad = Kstat["kstat.zfs.misc.arcstats.l2_cksum_bad"]
|
|
l2_evict_lock_retry = Kstat["kstat.zfs.misc.arcstats.l2_evict_lock_retry"]
|
|
l2_evict_reading = Kstat["kstat.zfs.misc.arcstats.l2_evict_reading"]
|
|
l2_feeds = Kstat["kstat.zfs.misc.arcstats.l2_feeds"]
|
|
l2_free_on_write = Kstat["kstat.zfs.misc.arcstats.l2_free_on_write"]
|
|
l2_hdr_size = Kstat["kstat.zfs.misc.arcstats.l2_hdr_size"]
|
|
l2_hits = Kstat["kstat.zfs.misc.arcstats.l2_hits"]
|
|
l2_io_error = Kstat["kstat.zfs.misc.arcstats.l2_io_error"]
|
|
l2_misses = Kstat["kstat.zfs.misc.arcstats.l2_misses"]
|
|
l2_rw_clash = Kstat["kstat.zfs.misc.arcstats.l2_rw_clash"]
|
|
l2_size = Kstat["kstat.zfs.misc.arcstats.l2_size"]
|
|
l2_write_buffer_bytes_scanned = Kstat["kstat.zfs.misc.arcstats.l2_write_buffer_bytes_scanned"]
|
|
l2_write_buffer_iter = Kstat["kstat.zfs.misc.arcstats.l2_write_buffer_iter"]
|
|
l2_write_buffer_list_iter = Kstat["kstat.zfs.misc.arcstats.l2_write_buffer_list_iter"]
|
|
l2_write_buffer_list_null_iter = Kstat["kstat.zfs.misc.arcstats.l2_write_buffer_list_null_iter"]
|
|
#l2_write_bytes = Kstat["kstat.zfs.misc.arcstats.l2_write_bytes"]
|
|
l2_write_full = Kstat["kstat.zfs.misc.arcstats.l2_write_full"]
|
|
#l2_write_in_l2 = Kstat["kstat.zfs.misc.arcstats.l2_write_in_l2"]
|
|
l2_write_io_in_progress = Kstat["kstat.zfs.misc.arcstats.l2_write_io_in_progress"]
|
|
#l2_write_not_cacheable = Kstat["kstat.zfs.misc.arcstats.l2_write_not_cacheable"]
|
|
l2_write_passed_headroom = Kstat["kstat.zfs.misc.arcstats.l2_write_passed_headroom"]
|
|
#l2_write_pios = Kstat["kstat.zfs.misc.arcstats.l2_write_pios"]
|
|
l2_write_spa_mismatch = Kstat["kstat.zfs.misc.arcstats.l2_write_spa_mismatch"]
|
|
l2_write_trylock_fail = Kstat["kstat.zfs.misc.arcstats.l2_write_trylock_fail"]
|
|
l2_writes_done = Kstat["kstat.zfs.misc.arcstats.l2_writes_done"]
|
|
l2_writes_error = Kstat["kstat.zfs.misc.arcstats.l2_writes_error"]
|
|
#l2_writes_hdr_miss = Kstat["kstat.zfs.misc.arcstats.l2_writes_hdr_miss"]
|
|
l2_writes_sent = Kstat["kstat.zfs.misc.arcstats.l2_writes_sent"]
|
|
|
|
l2_access_total = (l2_hits + l2_misses)
|
|
output['l2_health_count'] = (l2_writes_error + l2_cksum_bad + l2_io_error)
|
|
|
|
output['l2_access_total'] = l2_access_total
|
|
output['l2_size'] = l2_size
|
|
|
|
if l2_size > 0 and l2_access_total > 0:
|
|
|
|
if output['l2_health_count'] > 0:
|
|
output["health"] = "DEGRADED"
|
|
else:
|
|
output["health"] = "HEALTHY"
|
|
|
|
output["passed_headroom"] = fHits(l2_write_passed_headroom)
|
|
output["tried_lock_failure"] = fHits(l2_write_trylock_fail)
|
|
output["io_in_progress"] = fHits(l2_write_io_in_progress)
|
|
output["low_memory_aborts"] = fHits(l2_abort_lowmem)
|
|
output["free_on_write"] = fHits(l2_free_on_write)
|
|
output["writes_while_full"] = fHits(l2_write_full)
|
|
output["rw_clashes"] = fHits(l2_rw_clash)
|
|
output["bad_checksums"] = fHits(l2_cksum_bad)
|
|
output["io_errors"] = fHits(l2_io_error)
|
|
output["spa_mismatch"] = fHits(l2_write_spa_mismatch)
|
|
|
|
output["l2_arc_size"] = {}
|
|
output["l2_arc_size"]["adative"] = fBytes(l2_size)
|
|
output["l2_arc_size"]["head_size"] = {
|
|
'per': fPerc(l2_hdr_size, l2_size),
|
|
'num': fBytes(l2_hdr_size),
|
|
}
|
|
|
|
output["l2_arc_evicts"] = {}
|
|
output["l2_arc_evicts"]['lock_retries'] = fHits(l2_evict_lock_retry)
|
|
output["l2_arc_evicts"]['reading'] = fHits(l2_evict_reading)
|
|
|
|
output['l2_arc_breakdown'] = {}
|
|
output['l2_arc_breakdown']['value'] = fHits(l2_access_total)
|
|
output['l2_arc_breakdown']['hit_ratio'] = {
|
|
'per': fPerc(l2_hits, l2_access_total),
|
|
'num': fHits(l2_hits),
|
|
}
|
|
output['l2_arc_breakdown']['miss_ratio'] = {
|
|
'per': fPerc(l2_misses, l2_access_total),
|
|
'num': fHits(l2_misses),
|
|
}
|
|
output['l2_arc_breakdown']['feeds'] = fHits(l2_feeds)
|
|
|
|
output['l2_arc_buffer'] = {}
|
|
output['l2_arc_buffer']['bytes_scanned'] = fBytes(l2_write_buffer_bytes_scanned)
|
|
output['l2_arc_buffer']['buffer_iterations'] = fHits(l2_write_buffer_iter)
|
|
output['l2_arc_buffer']['list_iterations'] = fHits(l2_write_buffer_list_iter)
|
|
output['l2_arc_buffer']['null_list_iterations'] = fHits(l2_write_buffer_list_null_iter)
|
|
|
|
output['l2_arc_writes'] = {}
|
|
output['l2_writes_done'] = l2_writes_done
|
|
output['l2_writes_sent'] = l2_writes_sent
|
|
if l2_writes_done != l2_writes_sent:
|
|
output['l2_arc_writes']['writes_sent'] = {
|
|
'value': "FAULTED",
|
|
'num': fHits(l2_writes_sent),
|
|
}
|
|
output['l2_arc_writes']['done_ratio'] = {
|
|
'per': fPerc(l2_writes_done, l2_writes_sent),
|
|
'num': fHits(l2_writes_done),
|
|
}
|
|
output['l2_arc_writes']['error_ratio'] = {
|
|
'per': fPerc(l2_writes_error, l2_writes_sent),
|
|
'num': fHits(l2_writes_error),
|
|
}
|
|
else:
|
|
output['l2_arc_writes']['writes_sent'] = {
|
|
'per': fPerc(100),
|
|
'num': fHits(l2_writes_sent),
|
|
}
|
|
|
|
return output
|
|
|
|
|
|
def _l2arc_summary(Kstat):
|
|
|
|
if not Kstat["vfs.zfs.version.spa"]:
|
|
return
|
|
|
|
arc = get_l2arc_summary(Kstat)
|
|
|
|
if arc['l2_size'] > 0 and arc['l2_access_total'] > 0:
|
|
sys.stdout.write("L2 ARC Summary: ")
|
|
if arc['l2_health_count'] > 0:
|
|
sys.stdout.write("(DEGRADED)\n")
|
|
else:
|
|
sys.stdout.write("(HEALTHY)\n")
|
|
sys.stdout.write("\tPassed Headroom:\t\t\t%s\n" % arc['passed_headroom'])
|
|
sys.stdout.write("\tTried Lock Failures:\t\t\t%s\n" % arc['tried_lock_failure'])
|
|
sys.stdout.write("\tIO In Progress:\t\t\t\t%s\n" % arc['io_in_progress'])
|
|
sys.stdout.write("\tLow Memory Aborts:\t\t\t%s\n" % arc['low_memory_aborts'])
|
|
sys.stdout.write("\tFree on Write:\t\t\t\t%s\n" % arc['free_on_write'])
|
|
sys.stdout.write("\tWrites While Full:\t\t\t%s\n" % arc['writes_while_full'])
|
|
sys.stdout.write("\tR/W Clashes:\t\t\t\t%s\n" % arc['rw_clashes'])
|
|
sys.stdout.write("\tBad Checksums:\t\t\t\t%s\n" % arc['bad_checksums'])
|
|
sys.stdout.write("\tIO Errors:\t\t\t\t%s\n" % arc['io_errors'])
|
|
sys.stdout.write("\tSPA Mismatch:\t\t\t\t%s\n" % arc['spa_mismatch'])
|
|
sys.stdout.write("\n")
|
|
|
|
sys.stdout.write("L2 ARC Size: (Adaptive)\t\t\t\t%s\n" % arc["l2_arc_size"]["adative"])
|
|
sys.stdout.write("\tHeader Size:\t\t\t%s\t%s\n" % (
|
|
arc["l2_arc_size"]["head_size"]["per"],
|
|
arc["l2_arc_size"]["head_size"]["num"],
|
|
)
|
|
)
|
|
sys.stdout.write("\n")
|
|
|
|
if arc["l2_arc_evicts"]['lock_retries'] + arc["l2_arc_evicts"]["reading"] > 0:
|
|
sys.stdout.write("L2 ARC Evicts:\n")
|
|
sys.stdout.write("\tLock Retries:\t\t\t\t%s\n" % arc["l2_arc_evicts"]['lock_retries'])
|
|
sys.stdout.write("\tUpon Reading:\t\t\t\t%s\n" % arc["l2_arc_evicts"]["reading"])
|
|
sys.stdout.write("\n")
|
|
|
|
sys.stdout.write("L2 ARC Breakdown:\t\t\t\t%s\n" % arc['l2_arc_breakdown']['value'])
|
|
sys.stdout.write("\tHit Ratio:\t\t\t%s\t%s\n" % (
|
|
arc['l2_arc_breakdown']['hit_ratio']['per'],
|
|
arc['l2_arc_breakdown']['hit_ratio']['num'],
|
|
)
|
|
)
|
|
|
|
sys.stdout.write("\tMiss Ratio:\t\t\t%s\t%s\n" % (
|
|
arc['l2_arc_breakdown']['miss_ratio']['per'],
|
|
arc['l2_arc_breakdown']['miss_ratio']['num'],
|
|
)
|
|
)
|
|
|
|
sys.stdout.write("\tFeeds:\t\t\t\t\t%s\n" % arc['l2_arc_breakdown']['feeds'])
|
|
sys.stdout.write("\n")
|
|
|
|
sys.stdout.write("L2 ARC Buffer:\n")
|
|
sys.stdout.write("\tBytes Scanned:\t\t\t\t%s\n" % arc['l2_arc_buffer']['bytes_scanned'])
|
|
sys.stdout.write("\tBuffer Iterations:\t\t\t%s\n" % arc['l2_arc_buffer']['buffer_iterations'])
|
|
sys.stdout.write("\tList Iterations:\t\t\t%s\n" % arc['l2_arc_buffer']['list_iterations'])
|
|
sys.stdout.write("\tNULL List Iterations:\t\t\t%s\n" % arc['l2_arc_buffer']['null_list_iterations'])
|
|
sys.stdout.write("\n")
|
|
|
|
sys.stdout.write("L2 ARC Writes:\n")
|
|
if arc['l2_writes_done'] != arc['l2_writes_sent']:
|
|
sys.stdout.write("\tWrites Sent: (%s)\t\t\t\t%s\n" % (
|
|
arc['l2_arc_writes']['writes_sent']['value'],
|
|
arc['l2_arc_writes']['writes_sent']['num'],
|
|
)
|
|
)
|
|
sys.stdout.write("\t Done Ratio:\t\t\t%s\t%s\n" % (
|
|
arc['l2_arc_writes']['done_ratio']['per'],
|
|
arc['l2_arc_writes']['done_ratio']['num'],
|
|
)
|
|
)
|
|
sys.stdout.write("\t Error Ratio:\t\t\t%s\t%s\n" % (
|
|
arc['l2_arc_writes']['error_ratio']['per'],
|
|
arc['l2_arc_writes']['error_ratio']['num'],
|
|
)
|
|
)
|
|
else:
|
|
sys.stdout.write("\tWrites Sent:\t\t\t%s\t%s\n" % (
|
|
arc['l2_arc_writes']['writes_sent']['per'],
|
|
arc['l2_arc_writes']['writes_sent']['num'],
|
|
)
|
|
)
|
|
|
|
|
|
def get_dmu_summary(Kstat):
|
|
output = {}
|
|
|
|
if "vfs.zfs.version.spa" not in Kstat:
|
|
return output
|
|
|
|
zfetch_bogus_streams = Kstat["kstat.zfs.misc.zfetchstats.bogus_streams"]
|
|
zfetch_colinear_hits = Kstat["kstat.zfs.misc.zfetchstats.colinear_hits"]
|
|
zfetch_colinear_misses = Kstat["kstat.zfs.misc.zfetchstats.colinear_misses"]
|
|
zfetch_hits = Kstat["kstat.zfs.misc.zfetchstats.hits"]
|
|
zfetch_misses = Kstat["kstat.zfs.misc.zfetchstats.misses"]
|
|
zfetch_reclaim_failures = Kstat["kstat.zfs.misc.zfetchstats.reclaim_failures"]
|
|
zfetch_reclaim_successes = Kstat["kstat.zfs.misc.zfetchstats.reclaim_successes"]
|
|
zfetch_streams_noresets = Kstat["kstat.zfs.misc.zfetchstats.streams_noresets"]
|
|
zfetch_streams_resets = Kstat["kstat.zfs.misc.zfetchstats.streams_resets"]
|
|
zfetch_stride_hits = Kstat["kstat.zfs.misc.zfetchstats.stride_hits"]
|
|
zfetch_stride_misses = Kstat["kstat.zfs.misc.zfetchstats.stride_misses"]
|
|
|
|
zfetch_access_total = (zfetch_hits + zfetch_misses)
|
|
zfetch_colinear_total = (zfetch_colinear_hits + zfetch_colinear_misses)
|
|
zfetch_health_count = (zfetch_bogus_streams)
|
|
zfetch_reclaim_total = (zfetch_reclaim_successes + zfetch_reclaim_failures)
|
|
zfetch_streams_total = (zfetch_streams_resets + zfetch_streams_noresets + zfetch_bogus_streams)
|
|
zfetch_stride_total = (zfetch_stride_hits + zfetch_stride_misses)
|
|
output['zfetch_access_total'] = zfetch_access_total
|
|
|
|
if zfetch_access_total > 0:
|
|
|
|
output['file_level_prefetch'] = {}
|
|
if zfetch_health_count > 0:
|
|
output['file_level_prefetch']['health'] = 'DEGRADED'
|
|
else:
|
|
output['file_level_prefetch']['health'] = 'HEALTHY'
|
|
|
|
output['dmu'] = {}
|
|
output['dmu']['efficiency'] = {}
|
|
output['dmu']['efficiency']['value'] = fHits(zfetch_access_total)
|
|
output['dmu']['efficiency']['hit_ratio'] = {
|
|
'per': fPerc(zfetch_hits, zfetch_access_total),
|
|
'num': fHits(zfetch_hits),
|
|
}
|
|
output['dmu']['efficiency']['miss_ratio'] = {
|
|
'per': fPerc(zfetch_misses, zfetch_access_total),
|
|
'num': fHits(zfetch_misses),
|
|
}
|
|
|
|
output['dmu']['colinear'] = {}
|
|
output['dmu']['colinear']['value'] = fHits(zfetch_colinear_total)
|
|
output['dmu']['colinear']['hit_ratio'] = {
|
|
'per': fPerc(zfetch_colinear_hits, zfetch_colinear_total),
|
|
'num': fHits(zfetch_colinear_hits),
|
|
}
|
|
output['dmu']['colinear']['miss_ratio'] = {
|
|
'per': fPerc(zfetch_colinear_misses, zfetch_colinear_total),
|
|
'num': fHits(zfetch_colinear_misses),
|
|
}
|
|
|
|
output['dmu']['stride'] = {}
|
|
output['dmu']['stride']['value'] = fHits(zfetch_stride_total)
|
|
output['dmu']['stride']['hit_ratio'] = {
|
|
'per': fPerc(zfetch_stride_hits, zfetch_stride_total),
|
|
'num': fHits(zfetch_stride_hits),
|
|
}
|
|
output['dmu']['stride']['miss_ratio'] = {
|
|
'per': fPerc(zfetch_stride_misses, zfetch_stride_total),
|
|
'num': fHits(zfetch_stride_misses),
|
|
}
|
|
|
|
output['dmu_misc'] = {}
|
|
if zfetch_health_count > 0:
|
|
output['dmu_misc']['status'] = "FAULTED"
|
|
else:
|
|
output['dmu_misc']['status'] = ""
|
|
|
|
output['dmu_misc']['reclaim'] = {}
|
|
output['dmu_misc']['reclaim']['value'] = fHits(zfetch_reclaim_total)
|
|
output['dmu_misc']['reclaim']['successes'] = {
|
|
'per': fPerc(zfetch_reclaim_successes, zfetch_reclaim_total),
|
|
'num': fHits(zfetch_reclaim_successes),
|
|
}
|
|
output['dmu_misc']['reclaim']['failure'] = {
|
|
'per': fPerc(zfetch_reclaim_failures, zfetch_reclaim_total),
|
|
'num': fHits(zfetch_reclaim_failures),
|
|
}
|
|
|
|
output['dmu_misc']['streams'] = {}
|
|
output['dmu_misc']['streams']['value'] = fHits(zfetch_streams_total)
|
|
output['dmu_misc']['streams']['plus_resets'] = {
|
|
'per': fPerc(zfetch_streams_resets, zfetch_streams_total),
|
|
'num': fHits(zfetch_streams_resets),
|
|
}
|
|
output['dmu_misc']['streams']['neg_resets'] = {
|
|
'per': fPerc(zfetch_streams_noresets, zfetch_streams_total),
|
|
'num': fHits(zfetch_streams_noresets),
|
|
}
|
|
output['dmu_misc']['streams']['bogus'] = fHits(zfetch_bogus_streams)
|
|
|
|
return output
|
|
|
|
|
|
def _dmu_summary(Kstat):
|
|
|
|
arc = get_dmu_summary(Kstat)
|
|
|
|
if arc['zfetch_access_total'] > 0:
|
|
sys.stdout.write("File-Level Prefetch: (%s)" % arc['file_level_prefetch']['health'])
|
|
|
|
sys.stdout.write("DMU Efficiency:\t\t\t\t\t%s\n" % arc['dmu']['efficiency']['value'])
|
|
sys.stdout.write("\tHit Ratio:\t\t\t%s\t%s\n" % (
|
|
arc['dmu']['efficiency']['hit_ratio']['per'],
|
|
arc['dmu']['efficiency']['hit_ratio']['num'],
|
|
)
|
|
)
|
|
sys.stdout.write("\tMiss Ratio:\t\t\t%s\t%s\n" % (
|
|
arc['dmu']['efficiency']['miss_ratio']['per'],
|
|
arc['dmu']['efficiency']['miss_ratio']['num'],
|
|
)
|
|
)
|
|
|
|
sys.stdout.write("\n")
|
|
|
|
sys.stdout.write("\tColinear:\t\t\t\t%s\n" % arc['dmu']['colinear']['value'])
|
|
sys.stdout.write("\t Hit Ratio:\t\t\t%s\t%s\n" % (
|
|
arc['dmu']['colinear']['hit_ratio']['per'],
|
|
arc['dmu']['colinear']['hit_ratio']['num'],
|
|
)
|
|
)
|
|
|
|
sys.stdout.write("\t Miss Ratio:\t\t\t%s\t%s\n" % (
|
|
arc['dmu']['colinear']['miss_ratio']['per'],
|
|
arc['dmu']['colinear']['miss_ratio']['num'],
|
|
)
|
|
)
|
|
|
|
sys.stdout.write("\n")
|
|
|
|
sys.stdout.write("\tStride:\t\t\t\t\t%s\n" % arc['dmu']['stride']['value'])
|
|
sys.stdout.write("\t Hit Ratio:\t\t\t%s\t%s\n" % (
|
|
arc['dmu']['stride']['hit_ratio']['per'],
|
|
arc['dmu']['stride']['hit_ratio']['num'],
|
|
)
|
|
)
|
|
|
|
sys.stdout.write("\t Miss Ratio:\t\t\t%s\t%s\n" % (
|
|
arc['dmu']['stride']['miss_ratio']['per'],
|
|
arc['dmu']['stride']['miss_ratio']['num'],
|
|
)
|
|
)
|
|
|
|
sys.stdout.write("\n")
|
|
sys.stdout.write("DMU Misc: %s\n" % arc['dmu_misc']['status'])
|
|
|
|
sys.stdout.write("\tReclaim:\t\t\t\t%s\n" % arc['dmu_misc']['reclaim']['value'])
|
|
sys.stdout.write("\t Successes:\t\t\t%s\t%s\n" % (
|
|
arc['dmu_misc']['reclaim']['successes']['per'],
|
|
arc['dmu_misc']['reclaim']['successes']['num'],
|
|
)
|
|
)
|
|
|
|
sys.stdout.write("\t Failures:\t\t\t%s\t%s\n" % (
|
|
arc['dmu_misc']['reclaim']['failure']['per'],
|
|
arc['dmu_misc']['reclaim']['failure']['num'],
|
|
)
|
|
)
|
|
|
|
sys.stdout.write("\n\tStreams:\t\t\t\t%s\n" % arc['dmu_misc']['streams']['value'])
|
|
sys.stdout.write("\t +Resets:\t\t\t%s\t%s\n" % (
|
|
arc['dmu_misc']['streams']['plus_resets']['per'],
|
|
arc['dmu_misc']['streams']['plus_resets']['num'],
|
|
)
|
|
)
|
|
|
|
sys.stdout.write("\t -Resets:\t\t\t%s\t%s\n" % (
|
|
arc['dmu_misc']['streams']['neg_resets']['per'],
|
|
arc['dmu_misc']['streams']['neg_resets']['num'],
|
|
)
|
|
)
|
|
|
|
sys.stdout.write("\t Bogus:\t\t\t\t%s\n" % arc['dmu_misc']['streams']['bogus'])
|
|
|
|
|
|
def get_vdev_summary(Kstat):
|
|
output = {}
|
|
|
|
if "vfs.zfs.version.spa" not in Kstat:
|
|
return
|
|
|
|
vdev_cache_delegations = Kstat["kstat.zfs.misc.vdev_cache_stats.delegations"]
|
|
vdev_cache_misses = Kstat["kstat.zfs.misc.vdev_cache_stats.misses"]
|
|
vdev_cache_hits = Kstat["kstat.zfs.misc.vdev_cache_stats.hits"]
|
|
vdev_cache_total = (vdev_cache_misses + vdev_cache_hits + vdev_cache_delegations)
|
|
|
|
output['vdev_cache_total'] = vdev_cache_total
|
|
|
|
if vdev_cache_total > 0:
|
|
output['summary'] = fHits(vdev_cache_total)
|
|
output['hit_ratio'] = {
|
|
'per': fPerc(vdev_cache_hits, vdev_cache_total),
|
|
'num': fHits(vdev_cache_hits),
|
|
}
|
|
output['miss_ratio'] = {
|
|
'per': fPerc(vdev_cache_misses, vdev_cache_total),
|
|
'num': fHits(vdev_cache_misses),
|
|
}
|
|
output['delegations'] = {
|
|
'per': fPerc(vdev_cache_delegations, vdev_cache_total),
|
|
'num': fHits(vdev_cache_delegations),
|
|
}
|
|
|
|
return output
|
|
|
|
|
|
def _vdev_summary(Kstat):
|
|
arc = get_vdev_summary(Kstat)
|
|
|
|
if arc['vdev_cache_total'] > 0:
|
|
sys.stdout.write("VDEV Cache Summary:\t\t\t\t%s\n" % arc['summary'])
|
|
sys.stdout.write("\tHit Ratio:\t\t\t%s\t%s\n" % (
|
|
arc['hit_ratio']['per'],
|
|
arc['hit_ratio']['num'],
|
|
))
|
|
sys.stdout.write("\tMiss Ratio:\t\t\t%s\t%s\n" % (
|
|
arc['miss_ratio']['per'],
|
|
arc['miss_ratio']['num'],
|
|
))
|
|
sys.stdout.write("\tDelegations:\t\t\t%s\t%s\n" % (
|
|
arc['delegations']['per'],
|
|
arc['delegations']['num'],
|
|
))
|
|
|
|
|
|
def get_systl_summary(Kstat):
|
|
output = {}
|
|
return output
|
|
|
|
|
|
def _sysctl_summary(Kstat):
|
|
global show_sysctl_descriptions
|
|
global alternate_sysctl_layout
|
|
|
|
Tunable = [
|
|
"kern.maxusers",
|
|
"vm.kmem_size",
|
|
"vm.kmem_size_scale",
|
|
"vm.kmem_size_min",
|
|
"vm.kmem_size_max",
|
|
"vfs.zfs"
|
|
]
|
|
|
|
if not usetunable:
|
|
return
|
|
|
|
sysctl_descriptions = {}
|
|
if show_sysctl_descriptions:
|
|
tunables = " ".join(str(x) for x in Tunable)
|
|
p = Popen("/sbin/sysctl -qde %s" % tunables, stdin=PIPE,
|
|
stdout=PIPE, stderr=PIPE, shell=True, close_fds=True)
|
|
p.wait()
|
|
|
|
descriptions = p.communicate()[0].split('\n')
|
|
if p.returncode != 0:
|
|
sys.exit(1)
|
|
|
|
for tunable in descriptions:
|
|
if not tunable:
|
|
continue
|
|
tunable = tunable.strip()
|
|
name, description = tunable.split('=')[:2]
|
|
name = name.strip()
|
|
description = description.strip()
|
|
if not description:
|
|
description = "Description unavailable"
|
|
sysctl_descriptions[name] = description
|
|
|
|
tunables = " ".join(str(x) for x in Tunable)
|
|
p = Popen("/sbin/sysctl -qe %s" % tunables, stdin=PIPE,
|
|
stdout=PIPE, stderr=PIPE, shell=True, close_fds=True)
|
|
p.wait()
|
|
|
|
zfs_tunables = p.communicate()[0].split('\n')
|
|
if p.returncode != 0:
|
|
sys.exit(1)
|
|
|
|
sys.stdout.write("ZFS Tunable (sysctl):\n")
|
|
for tunable in zfs_tunables:
|
|
if not tunable:
|
|
continue
|
|
tunable = tunable.strip()
|
|
name, value = tunable.split("=")[0:2]
|
|
name = name.strip()
|
|
value = D(value.strip())
|
|
format = "\t%s=%d\n" if alternate_sysctl_layout else "\t%-40s%d\n"
|
|
if show_sysctl_descriptions:
|
|
sys.stdout.write("\t\# %s\n" % sysctl_descriptions[name])
|
|
sys.stdout.write(format % (name, value))
|
|
|
|
|
|
unSub = [
|
|
_system_memory,
|
|
_arc_summary,
|
|
_arc_efficiency,
|
|
_l2arc_summary,
|
|
_dmu_summary,
|
|
_vdev_summary,
|
|
_sysctl_summary
|
|
]
|
|
|
|
|
|
def _call_all():
|
|
page = 1
|
|
Kstat = get_Kstat()
|
|
for unsub in unSub:
|
|
unsub(Kstat)
|
|
sys.stdout.write("\t\t\t\t\t\t\t\tPage: %2d" % page)
|
|
div2()
|
|
page += 1
|
|
|
|
|
|
def zfs_header():
|
|
daydate = time.strftime("%a %b %d %H:%M:%S %Y")
|
|
|
|
div1()
|
|
sys.stdout.write("ZFS Subsystem Report\t\t\t\t%s" % daydate)
|
|
div2()
|
|
|
|
|
|
def main():
|
|
global show_sysctl_descriptions
|
|
global alternate_sysctl_layout
|
|
|
|
opts, args = getopt.getopt(
|
|
sys.argv[1:], "adp:"
|
|
)
|
|
|
|
args = {}
|
|
for opt, arg in opts:
|
|
if opt == '-a':
|
|
args['a'] = True
|
|
if opt == '-d':
|
|
args['d'] = True
|
|
if opt == '-p':
|
|
args['p'] = arg
|
|
|
|
if args:
|
|
alternate_sysctl_layout = True if 'a' in args else False
|
|
show_sysctl_descriptions = True if 'd' in args else False
|
|
try:
|
|
zfs_header()
|
|
unSub[int(args['p']) - 1]()
|
|
div2()
|
|
|
|
except:
|
|
_call_all()
|
|
|
|
else:
|
|
_call_all()
|
|
|
|
|
|
if __name__ == '__main__':
|
|
main()
|