debian/patches/0009-arc-stat-summary-guard-access-to-freshly-introduced-.patch

   1 From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
   2 From: Thomas Lamprecht <t.lamprecht@proxmox.com>
   3 Date: Wed, 10 Nov 2021 09:29:47 +0100
   4 Subject: [PATCH] arc stat/summary: guard access to freshly introduced stats
   5
   6 l2arc MFU/MRU and zfetch past future and stride stats were introduced
   7 in 2.1 and 2.2.4 respectively:
   8
   9 commit 085321621e79a75bea41c2b6511da6ebfbf2ba0a added printing MFU
  10 and MRU stats for 2.1 user space tools, but those keys are not
  11 available in the 2.0 module. That means it may break the arcstat and
  12 arc_summary tools after upgrade to 2.1 (user space), before a reboot
  13 to the new 2.1 ZFS kernel-module happened, due to python raising a
  14 KeyError on the dict access then.
  15
  16 Move those two keys to a .get accessor with `0` as fallback, as it
  17 should be better to show some possible wrong data for new stat-keys
  18 than throwing an exception.
  19
  20 also move l2_mfu_asize  l2_mru_asize l2_prefetch_asize
  21 l2_bufc_data_asize l2_bufc_metadata_asize to .get accessor
  22 (these are only present with a cache device in the pool)
  23
  24 guard access to iohits and uncached state introduced in
  25 792a6ee462efc15a7614f27e13f0f8aaa9414a08
  26
  27 guard access to zfetch past future stride stats introduced in
  28 026fe796465e3da7b27d06ef5338634ee6dd30d8
  29
  30 These are present in the current kernel, but lead to an exception, if
  31 running the new user-space with an old kernel module.
  32
  33 Signed-off-by: Stoiko Ivanov <s.ivanov@proxmox.com>
  34 ---
  35  cmd/arc_summary | 132 ++++++++++++++++++++++++------------------------
  36  cmd/arcstat.in  |  48 +++++++++---------
  37  2 files changed, 90 insertions(+), 90 deletions(-)
  38
  39 diff --git a/cmd/arc_summary b/cmd/arc_summary
  40 index 100fb1987..30f5d23e9 100755
  41 --- a/cmd/arc_summary
  42 +++ b/cmd/arc_summary
  43 @@ -551,21 +551,21 @@ def section_arc(kstats_dict):
  44      arc_target_size = arc_stats['c']
  45      arc_max = arc_stats['c_max']
  46      arc_min = arc_stats['c_min']
  47 -    meta = arc_stats['meta']
  48 -    pd = arc_stats['pd']
  49 -    pm = arc_stats['pm']
  50 -    anon_data = arc_stats['anon_data']
  51 -    anon_metadata = arc_stats['anon_metadata']
  52 -    mfu_data = arc_stats['mfu_data']
  53 -    mfu_metadata = arc_stats['mfu_metadata']
  54 -    mru_data = arc_stats['mru_data']
  55 -    mru_metadata = arc_stats['mru_metadata']
  56 -    mfug_data = arc_stats['mfu_ghost_data']
  57 -    mfug_metadata = arc_stats['mfu_ghost_metadata']
  58 -    mrug_data = arc_stats['mru_ghost_data']
  59 -    mrug_metadata = arc_stats['mru_ghost_metadata']
  60 -    unc_data = arc_stats['uncached_data']
  61 -    unc_metadata = arc_stats['uncached_metadata']
  62 +    meta = arc_stats.get('meta', 0)
  63 +    pd = arc_stats.get('pd', 0)
  64 +    pm = arc_stats.get('pm', 0)
  65 +    anon_data = arc_stats.get('anon_data', 0)
  66 +    anon_metadata = arc_stats.get('anon_metadata', 0)
  67 +    mfu_data = arc_stats.get('mfu_data', 0)
  68 +    mfu_metadata = arc_stats.get('mfu_metadata', 0)
  69 +    mru_data = arc_stats.get('mru_data', 0)
  70 +    mru_metadata = arc_stats.get('mru_metadata', 0)
  71 +    mfug_data = arc_stats.get('mfu_ghost_data', 0)
  72 +    mfug_metadata = arc_stats.get('mfu_ghost_metadata', 0)
  73 +    mrug_data = arc_stats.get('mru_ghost_data', 0)
  74 +    mrug_metadata = arc_stats.get('mru_ghost_metadata', 0)
  75 +    unc_data = arc_stats.get('uncached_data', 0)
  76 +    unc_metadata = arc_stats.get('uncached_metadata', 0)
  77      bonus_size = arc_stats['bonus_size']
  78      dnode_limit = arc_stats['arc_dnode_limit']
  79      dnode_size = arc_stats['dnode_size']
  80 @@ -655,13 +655,13 @@ def section_arc(kstats_dict):
  81      prt_i1('L2 cached evictions:', f_bytes(arc_stats['evict_l2_cached']))
  82      prt_i1('L2 eligible evictions:', f_bytes(arc_stats['evict_l2_eligible']))
  83      prt_i2('L2 eligible MFU evictions:',
  84 -           f_perc(arc_stats['evict_l2_eligible_mfu'],
  85 +           f_perc(arc_stats.get('evict_l2_eligible_mfu', 0), # 2.0 module compat
  86             arc_stats['evict_l2_eligible']),
  87 -           f_bytes(arc_stats['evict_l2_eligible_mfu']))
  88 +           f_bytes(arc_stats.get('evict_l2_eligible_mfu', 0)))
  89      prt_i2('L2 eligible MRU evictions:',
  90 -           f_perc(arc_stats['evict_l2_eligible_mru'],
  91 +           f_perc(arc_stats.get('evict_l2_eligible_mru', 0), # 2.0 module compat
  92             arc_stats['evict_l2_eligible']),
  93 -           f_bytes(arc_stats['evict_l2_eligible_mru']))
  94 +           f_bytes(arc_stats.get('evict_l2_eligible_mru', 0)))
  95      prt_i1('L2 ineligible evictions:',
  96             f_bytes(arc_stats['evict_l2_ineligible']))
  97      print()
  98 @@ -672,106 +672,106 @@ def section_archits(kstats_dict):
  99      """
 100
 101      arc_stats = isolate_section('arcstats', kstats_dict)
 102 -    all_accesses = int(arc_stats['hits'])+int(arc_stats['iohits'])+\
 103 +    all_accesses = int(arc_stats['hits'])+int(arc_stats.get('iohits', 0))+\
 104          int(arc_stats['misses'])
 105
 106      prt_1('ARC total accesses:', f_hits(all_accesses))
 107      ta_todo = (('Total hits:', arc_stats['hits']),
 108 -               ('Total I/O hits:', arc_stats['iohits']),
 109 +               ('Total I/O hits:', arc_stats.get('iohits', 0)),
 110                 ('Total misses:', arc_stats['misses']))
 111      for title, value in ta_todo:
 112          prt_i2(title, f_perc(value, all_accesses), f_hits(value))
 113      print()
 114
 115      dd_total = int(arc_stats['demand_data_hits']) +\
 116 -        int(arc_stats['demand_data_iohits']) +\
 117 +        int(arc_stats.get('demand_data_iohits', 0)) +\
 118          int(arc_stats['demand_data_misses'])
 119      prt_2('ARC demand data accesses:', f_perc(dd_total, all_accesses),
 120           f_hits(dd_total))
 121      dd_todo = (('Demand data hits:', arc_stats['demand_data_hits']),
 122 -               ('Demand data I/O hits:', arc_stats['demand_data_iohits']),
 123 +               ('Demand data I/O hits:', arc_stats.get('demand_data_iohits', 0)),
 124                 ('Demand data misses:', arc_stats['demand_data_misses']))
 125      for title, value in dd_todo:
 126          prt_i2(title, f_perc(value, dd_total), f_hits(value))
 127      print()
 128
 129      dm_total = int(arc_stats['demand_metadata_hits']) +\
 130 -        int(arc_stats['demand_metadata_iohits']) +\
 131 +        int(arc_stats.get('demand_metadata_iohits', 0)) +\
 132          int(arc_stats['demand_metadata_misses'])
 133      prt_2('ARC demand metadata accesses:', f_perc(dm_total, all_accesses),
 134            f_hits(dm_total))
 135      dm_todo = (('Demand metadata hits:', arc_stats['demand_metadata_hits']),
 136                 ('Demand metadata I/O hits:',
 137 -                arc_stats['demand_metadata_iohits']),
 138 +                arc_stats.get('demand_metadata_iohits', 0)),
 139                 ('Demand metadata misses:', arc_stats['demand_metadata_misses']))
 140      for title, value in dm_todo:
 141          prt_i2(title, f_perc(value, dm_total), f_hits(value))
 142      print()
 143
 144      pd_total = int(arc_stats['prefetch_data_hits']) +\
 145 -        int(arc_stats['prefetch_data_iohits']) +\
 146 +        int(arc_stats.get('prefetch_data_iohits', 0)) +\
 147          int(arc_stats['prefetch_data_misses'])
 148      prt_2('ARC prefetch data accesses:', f_perc(pd_total, all_accesses),
 149            f_hits(pd_total))
 150      pd_todo = (('Prefetch data hits:', arc_stats['prefetch_data_hits']),
 151 -               ('Prefetch data I/O hits:', arc_stats['prefetch_data_iohits']),
 152 +               ('Prefetch data I/O hits:', arc_stats.get('prefetch_data_iohits', 0)),
 153                 ('Prefetch data misses:', arc_stats['prefetch_data_misses']))
 154      for title, value in pd_todo:
 155          prt_i2(title, f_perc(value, pd_total), f_hits(value))
 156      print()
 157
 158      pm_total = int(arc_stats['prefetch_metadata_hits']) +\
 159 -        int(arc_stats['prefetch_metadata_iohits']) +\
 160 +        int(arc_stats.get('prefetch_metadata_iohits', 0)) +\
 161          int(arc_stats['prefetch_metadata_misses'])
 162      prt_2('ARC prefetch metadata accesses:', f_perc(pm_total, all_accesses),
 163            f_hits(pm_total))
 164      pm_todo = (('Prefetch metadata hits:',
 165                  arc_stats['prefetch_metadata_hits']),
 166                 ('Prefetch metadata I/O hits:',
 167 -                arc_stats['prefetch_metadata_iohits']),
 168 +                arc_stats.get('prefetch_metadata_iohits', 0)),
 169                 ('Prefetch metadata misses:',
 170                  arc_stats['prefetch_metadata_misses']))
 171      for title, value in pm_todo:
 172          prt_i2(title, f_perc(value, pm_total), f_hits(value))
 173      print()
 174
 175 -    all_prefetches = int(arc_stats['predictive_prefetch'])+\
 176 -        int(arc_stats['prescient_prefetch'])
 177 +    all_prefetches = int(arc_stats.get('predictive_prefetch', 0))+\
 178 +        int(arc_stats.get('prescient_prefetch', 0))
 179      prt_2('ARC predictive prefetches:',
 180 -           f_perc(arc_stats['predictive_prefetch'], all_prefetches),
 181 -           f_hits(arc_stats['predictive_prefetch']))
 182 +           f_perc(arc_stats.get('predictive_prefetch', 0), all_prefetches),
 183 +           f_hits(arc_stats.get('predictive_prefetch', 0)))
 184      prt_i2('Demand hits after predictive:',
 185             f_perc(arc_stats['demand_hit_predictive_prefetch'],
 186 -                  arc_stats['predictive_prefetch']),
 187 +                  arc_stats.get('predictive_prefetch', 0)),
 188             f_hits(arc_stats['demand_hit_predictive_prefetch']))
 189      prt_i2('Demand I/O hits after predictive:',
 190 -           f_perc(arc_stats['demand_iohit_predictive_prefetch'],
 191 -                  arc_stats['predictive_prefetch']),
 192 -           f_hits(arc_stats['demand_iohit_predictive_prefetch']))
 193 -    never = int(arc_stats['predictive_prefetch']) -\
 194 +           f_perc(arc_stats.get('demand_iohit_predictive_prefetch', 0),
 195 +                  arc_stats.get('predictive_prefetch', 0)),
 196 +           f_hits(arc_stats.get('demand_iohit_predictive_prefetch', 0)))
 197 +    never = int(arc_stats.get('predictive_prefetch', 0)) -\
 198          int(arc_stats['demand_hit_predictive_prefetch']) -\
 199 -        int(arc_stats['demand_iohit_predictive_prefetch'])
 200 +        int(arc_stats.get('demand_iohit_predictive_prefetch', 0))
 201      prt_i2('Never demanded after predictive:',
 202 -           f_perc(never, arc_stats['predictive_prefetch']),
 203 +           f_perc(never, arc_stats.get('predictive_prefetch', 0)),
 204             f_hits(never))
 205      print()
 206
 207      prt_2('ARC prescient prefetches:',
 208 -           f_perc(arc_stats['prescient_prefetch'], all_prefetches),
 209 -           f_hits(arc_stats['prescient_prefetch']))
 210 +           f_perc(arc_stats.get('prescient_prefetch', 0), all_prefetches),
 211 +           f_hits(arc_stats.get('prescient_prefetch', 0)))
 212      prt_i2('Demand hits after prescient:',
 213             f_perc(arc_stats['demand_hit_prescient_prefetch'],
 214 -                  arc_stats['prescient_prefetch']),
 215 +                  arc_stats.get('prescient_prefetch', 0)),
 216             f_hits(arc_stats['demand_hit_prescient_prefetch']))
 217      prt_i2('Demand I/O hits after prescient:',
 218 -           f_perc(arc_stats['demand_iohit_prescient_prefetch'],
 219 -                  arc_stats['prescient_prefetch']),
 220 -           f_hits(arc_stats['demand_iohit_prescient_prefetch']))
 221 -    never = int(arc_stats['prescient_prefetch'])-\
 222 +           f_perc(arc_stats.get('demand_iohit_prescient_prefetch', 0),
 223 +                  arc_stats.get('prescient_prefetch', 0)),
 224 +           f_hits(arc_stats.get('demand_iohit_prescient_prefetch', 0)))
 225 +    never = int(arc_stats.get('prescient_prefetch', 0))-\
 226          int(arc_stats['demand_hit_prescient_prefetch'])-\
 227 -        int(arc_stats['demand_iohit_prescient_prefetch'])
 228 +        int(arc_stats.get('demand_iohit_prescient_prefetch', 0))
 229      prt_i2('Never demanded after prescient:',
 230 -           f_perc(never, arc_stats['prescient_prefetch']),
 231 +           f_perc(never, arc_stats.get('prescient_prefetch', 0)),
 232             f_hits(never))
 233      print()
 234
 235 @@ -782,7 +782,7 @@ def section_archits(kstats_dict):
 236                  arc_stats['mfu_ghost_hits']),
 237                 ('Most recently used (MRU) ghost:',
 238                  arc_stats['mru_ghost_hits']),
 239 -               ('Uncached:', arc_stats['uncached_hits']))
 240 +               ('Uncached:', arc_stats.get('uncached_hits', 0)))
 241      for title, value in cl_todo:
 242          prt_i2(title, f_perc(value, all_accesses), f_hits(value))
 243      print()
 244 @@ -794,26 +794,26 @@ def section_dmu(kstats_dict):
 245      zfetch_stats = isolate_section('zfetchstats', kstats_dict)
 246
 247      zfetch_access_total = int(zfetch_stats['hits']) +\
 248 -        int(zfetch_stats['future']) + int(zfetch_stats['stride']) +\
 249 -        int(zfetch_stats['past']) + int(zfetch_stats['misses'])
 250 +        int(zfetch_stats.get('future', 0)) + int(zfetch_stats.get('stride', 0)) +\
 251 +        int(zfetch_stats.get('past', 0)) + int(zfetch_stats['misses'])
 252
 253      prt_1('DMU predictive prefetcher calls:', f_hits(zfetch_access_total))
 254      prt_i2('Stream hits:',
 255             f_perc(zfetch_stats['hits'], zfetch_access_total),
 256             f_hits(zfetch_stats['hits']))
 257 -    future = int(zfetch_stats['future']) + int(zfetch_stats['stride'])
 258 +    future = int(zfetch_stats.get('future', 0)) + int(zfetch_stats.get('stride', 0))
 259      prt_i2('Hits ahead of stream:', f_perc(future, zfetch_access_total),
 260             f_hits(future))
 261      prt_i2('Hits behind stream:',
 262 -           f_perc(zfetch_stats['past'], zfetch_access_total),
 263 -           f_hits(zfetch_stats['past']))
 264 +           f_perc(zfetch_stats.get('past', 0), zfetch_access_total),
 265 +           f_hits(zfetch_stats.get('past', 0)))
 266      prt_i2('Stream misses:',
 267             f_perc(zfetch_stats['misses'], zfetch_access_total),
 268             f_hits(zfetch_stats['misses']))
 269      prt_i2('Streams limit reached:',
 270             f_perc(zfetch_stats['max_streams'], zfetch_stats['misses']),
 271             f_hits(zfetch_stats['max_streams']))
 272 -    prt_i1('Stream strides:', f_hits(zfetch_stats['stride']))
 273 +    prt_i1('Stream strides:', f_hits(zfetch_stats.get('stride', 0)))
 274      prt_i1('Prefetches issued', f_hits(zfetch_stats['io_issued']))
 275      print()
 276
 277 @@ -860,20 +860,20 @@ def section_l2arc(kstats_dict):
 278             f_perc(arc_stats['l2_hdr_size'], arc_stats['l2_size']),
 279             f_bytes(arc_stats['l2_hdr_size']))
 280      prt_i2('MFU allocated size:',
 281 -           f_perc(arc_stats['l2_mfu_asize'], arc_stats['l2_asize']),
 282 -           f_bytes(arc_stats['l2_mfu_asize']))
 283 +           f_perc(arc_stats.get('l2_mfu_asize', 0), arc_stats['l2_asize']),
 284 +           f_bytes(arc_stats.get('l2_mfu_asize', 0))) # 2.0 module compat
 285      prt_i2('MRU allocated size:',
 286 -           f_perc(arc_stats['l2_mru_asize'], arc_stats['l2_asize']),
 287 -           f_bytes(arc_stats['l2_mru_asize']))
 288 +           f_perc(arc_stats.get('l2_mru_asize', 0), arc_stats['l2_asize']),
 289 +           f_bytes(arc_stats.get('l2_mru_asize', 0))) # 2.0 module compat
 290      prt_i2('Prefetch allocated size:',
 291 -           f_perc(arc_stats['l2_prefetch_asize'], arc_stats['l2_asize']),
 292 -           f_bytes(arc_stats['l2_prefetch_asize']))
 293 +           f_perc(arc_stats.get('l2_prefetch_asize', 0), arc_stats['l2_asize']),
 294 +           f_bytes(arc_stats.get('l2_prefetch_asize',0))) # 2.0 module compat
 295      prt_i2('Data (buffer content) allocated size:',
 296 -           f_perc(arc_stats['l2_bufc_data_asize'], arc_stats['l2_asize']),
 297 -           f_bytes(arc_stats['l2_bufc_data_asize']))
 298 +           f_perc(arc_stats.get('l2_bufc_data_asize', 0), arc_stats['l2_asize']),
 299 +           f_bytes(arc_stats.get('l2_bufc_data_asize', 0))) # 2.0 module compat
 300      prt_i2('Metadata (buffer content) allocated size:',
 301 -           f_perc(arc_stats['l2_bufc_metadata_asize'], arc_stats['l2_asize']),
 302 -           f_bytes(arc_stats['l2_bufc_metadata_asize']))
 303 +           f_perc(arc_stats.get('l2_bufc_metadata_asize', 0), arc_stats['l2_asize']),
 304 +           f_bytes(arc_stats.get('l2_bufc_metadata_asize', 0))) # 2.0 module compat
 305
 306      print()
 307      prt_1('L2ARC breakdown:', f_hits(l2_access_total))
 308 diff --git a/cmd/arcstat.in b/cmd/arcstat.in
 309 index c4f10a1d6..bf47ec90e 100755
 310 --- a/cmd/arcstat.in
 311 +++ b/cmd/arcstat.in
 312 @@ -510,7 +510,7 @@ def calculate():
 313      v = dict()
 314      v["time"] = time.strftime("%H:%M:%S", time.localtime())
 315      v["hits"] = d["hits"] // sint
 316 -    v["iohs"] = d["iohits"] // sint
 317 +    v["iohs"] = d.get("iohits", 0) // sint
 318      v["miss"] = d["misses"] // sint
 319      v["read"] = v["hits"] + v["iohs"] + v["miss"]
 320      v["hit%"] = 100 * v["hits"] // v["read"] if v["read"] > 0 else 0
 321 @@ -518,7 +518,7 @@ def calculate():
 322      v["miss%"] = 100 - v["hit%"] - v["ioh%"] if v["read"] > 0 else 0
 323
 324      v["dhit"] = (d["demand_data_hits"] + d["demand_metadata_hits"]) // sint
 325 -    v["dioh"] = (d["demand_data_iohits"] + d["demand_metadata_iohits"]) // sint
 326 +    v["dioh"] = (d.get("demand_data_iohits", 0) + d.get("demand_metadata_iohits", 0)) // sint
 327      v["dmis"] = (d["demand_data_misses"] + d["demand_metadata_misses"]) // sint
 328
 329      v["dread"] = v["dhit"] + v["dioh"] + v["dmis"]
 330 @@ -527,7 +527,7 @@ def calculate():
 331      v["dm%"] = 100 - v["dh%"] - v["di%"] if v["dread"] > 0 else 0
 332
 333      v["ddhit"] = d["demand_data_hits"] // sint
 334 -    v["ddioh"] = d["demand_data_iohits"] // sint
 335 +    v["ddioh"] = d.get("demand_data_iohits", 0) // sint
 336      v["ddmis"] = d["demand_data_misses"] // sint
 337
 338      v["ddread"] = v["ddhit"] + v["ddioh"] + v["ddmis"]
 339 @@ -536,7 +536,7 @@ def calculate():
 340      v["ddm%"] = 100 - v["ddh%"] - v["ddi%"] if v["ddread"] > 0 else 0
 341
 342      v["dmhit"] = d["demand_metadata_hits"] // sint
 343 -    v["dmioh"] = d["demand_metadata_iohits"] // sint
 344 +    v["dmioh"] = d.get("demand_metadata_iohits", 0) // sint
 345      v["dmmis"] = d["demand_metadata_misses"] // sint
 346
 347      v["dmread"] = v["dmhit"] + v["dmioh"] + v["dmmis"]
 348 @@ -545,8 +545,8 @@ def calculate():
 349      v["dmm%"] = 100 - v["dmh%"] - v["dmi%"] if v["dmread"] > 0 else 0
 350
 351      v["phit"] = (d["prefetch_data_hits"] + d["prefetch_metadata_hits"]) // sint
 352 -    v["pioh"] = (d["prefetch_data_iohits"] +
 353 -                 d["prefetch_metadata_iohits"]) // sint
 354 +    v["pioh"] = (d.get("prefetch_data_iohits", 0) +
 355 +                 d.get("prefetch_metadata_iohits", 0)) // sint
 356      v["pmis"] = (d["prefetch_data_misses"] +
 357                   d["prefetch_metadata_misses"]) // sint
 358
 359 @@ -556,7 +556,7 @@ def calculate():
 360      v["pm%"] = 100 - v["ph%"] - v["pi%"] if v["pread"] > 0 else 0
 361
 362      v["pdhit"] = d["prefetch_data_hits"] // sint
 363 -    v["pdioh"] = d["prefetch_data_iohits"] // sint
 364 +    v["pdioh"] = d.get("prefetch_data_iohits", 0) // sint
 365      v["pdmis"] = d["prefetch_data_misses"] // sint
 366
 367      v["pdread"] = v["pdhit"] + v["pdioh"] + v["pdmis"]
 368 @@ -565,7 +565,7 @@ def calculate():
 369      v["pdm%"] = 100 - v["pdh%"] - v["pdi%"] if v["pdread"] > 0 else 0
 370
 371      v["pmhit"] = d["prefetch_metadata_hits"] // sint
 372 -    v["pmioh"] = d["prefetch_metadata_iohits"] // sint
 373 +    v["pmioh"] = d.get("prefetch_metadata_iohits", 0) // sint
 374      v["pmmis"] = d["prefetch_metadata_misses"] // sint
 375
 376      v["pmread"] = v["pmhit"] + v["pmioh"] + v["pmmis"]
 377 @@ -575,8 +575,8 @@ def calculate():
 378
 379      v["mhit"] = (d["prefetch_metadata_hits"] +
 380                   d["demand_metadata_hits"]) // sint
 381 -    v["mioh"] = (d["prefetch_metadata_iohits"] +
 382 -                 d["demand_metadata_iohits"]) // sint
 383 +    v["mioh"] = (d.get("prefetch_metadata_iohits", 0) +
 384 +                 d.get("demand_metadata_iohits", 0)) // sint
 385      v["mmis"] = (d["prefetch_metadata_misses"] +
 386                   d["demand_metadata_misses"]) // sint
 387
 388 @@ -592,24 +592,24 @@ def calculate():
 389      v["mru"] = d["mru_hits"] // sint
 390      v["mrug"] = d["mru_ghost_hits"] // sint
 391      v["mfug"] = d["mfu_ghost_hits"] // sint
 392 -    v["unc"] = d["uncached_hits"] // sint
 393 +    v["unc"] = d.get("uncached_hits", 0) // sint
 394      v["eskip"] = d["evict_skip"] // sint
 395      v["el2skip"] = d["evict_l2_skip"] // sint
 396      v["el2cach"] = d["evict_l2_cached"] // sint
 397      v["el2el"] = d["evict_l2_eligible"] // sint
 398 -    v["el2mfu"] = d["evict_l2_eligible_mfu"] // sint
 399 -    v["el2mru"] = d["evict_l2_eligible_mru"] // sint
 400 +    v["el2mfu"] = d.get("evict_l2_eligible_mfu", 0) // sint
 401 +    v["el2mru"] = d.get("evict_l2_eligible_mru", 0) // sint
 402      v["el2inel"] = d["evict_l2_ineligible"] // sint
 403      v["mtxmis"] = d["mutex_miss"] // sint
 404 -    v["ztotal"] = (d["zfetch_hits"] + d["zfetch_future"] + d["zfetch_stride"] +
 405 -                   d["zfetch_past"] + d["zfetch_misses"]) // sint
 406 +    v["ztotal"] = (d["zfetch_hits"] + d.get("zfetch_future", 0) + d.get("zfetch_stride", 0) +
 407 +                   d.get("zfetch_past", 0) + d["zfetch_misses"]) // sint
 408      v["zhits"] = d["zfetch_hits"] // sint
 409 -    v["zahead"] = (d["zfetch_future"] + d["zfetch_stride"]) // sint
 410 -    v["zpast"] = d["zfetch_past"] // sint
 411 +    v["zahead"] = (d.get("zfetch_future", 0) + d.get("zfetch_stride", 0)) // sint
 412 +    v["zpast"] = d.get("zfetch_past", 0) // sint
 413      v["zmisses"] = d["zfetch_misses"] // sint
 414      v["zmax"] = d["zfetch_max_streams"] // sint
 415 -    v["zfuture"] = d["zfetch_future"] // sint
 416 -    v["zstride"] = d["zfetch_stride"] // sint
 417 +    v["zfuture"] = d.get("zfetch_future", 0) // sint
 418 +    v["zstride"] = d.get("zfetch_stride", 0) // sint
 419      v["zissued"] = d["zfetch_io_issued"] // sint
 420      v["zactive"] = d["zfetch_io_active"] // sint
 421
 422 @@ -624,11 +624,11 @@ def calculate():
 423          v["l2size"] = cur["l2_size"]
 424          v["l2bytes"] = d["l2_read_bytes"] // sint
 425
 426 -        v["l2pref"] = cur["l2_prefetch_asize"]
 427 -        v["l2mfu"] = cur["l2_mfu_asize"]
 428 -        v["l2mru"] = cur["l2_mru_asize"]
 429 -        v["l2data"] = cur["l2_bufc_data_asize"]
 430 -        v["l2meta"] = cur["l2_bufc_metadata_asize"]
 431 +        v["l2pref"] = cur.get("l2_prefetch_asize", 0)
 432 +        v["l2mfu"] = cur.get("l2_mfu_asize", 0)
 433 +        v["l2mru"] = cur.get("l2_mru_asize", 0)
 434 +        v["l2data"] = cur.get("l2_bufc_data_asize", 0)
 435 +        v["l2meta"] = cur.get("l2_bufc_metadata_asize", 0)
 436          v["l2pref%"] = 100 * v["l2pref"] // v["l2asize"]
 437          v["l2mfu%"] = 100 * v["l2mfu"] // v["l2asize"]
 438          v["l2mru%"] = 100 * v["l2mru"] // v["l2asize"]