Introduce spl_cache walker

Author: sdimitro

sdb/__init__.py

@@ -73,6 +73,7 @@
     'type_canonical_name',
     'type_canonicalize',
     'type_canonicalize_name',
+    'type_canonicalize_size',
     'type_equals',
 ]
 

sdb/commands/internal/fmt.py

@@ -13,13 +13,17 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 #
-
-# pylint: disable=missing-docstring
+"""
+Common String and Number formatting functions.
+"""
 
 from typing import Union
 
 
 def size_nicenum(num: Union[int, float]) -> str:
+    """
+    Return `num` bytes as a human-readable string.
+    """
     num = float(num)
     for unit in ['B', 'KB', 'MB', 'GB', 'TB']:
         if num < 1024.0:

sdb/commands/internal/p2.py

@@ -0,0 +1,25 @@
+#
+# Copyright 2020 Delphix
+#
+# 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.
+#
+"""
+Common C macros for bit-manipulation and alignment.
+"""
+
+
+def p2roundup(val: int, align: int) -> int:
+    """
+    Round up `val` to the next `align` boundary.
+    """
+    return ((val - 1) | (align - 1)) + 1

sdb/commands/linux/linked_lists.py

@@ -124,3 +124,11 @@ def _call(self, objs: Iterable[drgn.Object]) -> Iterable[drgn.Object]:
                 yield from hlist_for_each_entry(sname, obj, self.args.member)
             except LookupError as err:
                 raise sdb.CommandError(self.name, str(err))
+
+
+def is_list_empty(l: drgn.Object) -> bool:
+    """
+    True if list is empty, False otherwise.
+    """
+    assert sdb.type_canonical_name(l.type_) == 'struct list_head'
+    return int(l.address_of_().value_()) == int(l.next.value_())

sdb/commands/spl/internal/kmem_helpers.py

@@ -22,42 +22,44 @@
 import drgn.helpers.linux.list as drgn_list
 
 import sdb
+from sdb.commands.internal import p2
+from sdb.commands.linux import linked_lists
 from sdb.commands.linux.internal import slub_helpers as slub
 
 
-def list_for_each_spl_kmem_cache() -> Iterable[drgn.Object]:
+def for_each_spl_kmem_cache() -> Iterable[drgn.Object]:
     yield from drgn_list.list_for_each_entry(
         "spl_kmem_cache_t",
         sdb.get_object("spl_kmem_cache_list").address_of_(), "skc_list")
 
 
 def backed_by_linux_cache(cache: drgn.Object) -> bool:
-    assert cache.type_.type_name() == 'spl_kmem_cache_t *'
+    assert sdb.type_canonical_name(cache.type_) == 'struct spl_kmem_cache *'
     return int(cache.skc_linux_cache.value_()) != 0x0
 
 
 def slab_name(cache: drgn.Object) -> str:
-    assert cache.type_.type_name() == 'spl_kmem_cache_t *'
+    assert sdb.type_canonical_name(cache.type_) == 'struct spl_kmem_cache *'
     return str(cache.skc_name.string_().decode('utf-8'))
 
 
 def nr_slabs(cache: drgn.Object) -> int:
-    assert cache.type_.type_name() == 'spl_kmem_cache_t *'
+    assert sdb.type_canonical_name(cache.type_) == 'struct spl_kmem_cache *'
     return int(cache.skc_slab_total.value_())
 
 
 def slab_alloc(cache: drgn.Object) -> int:
-    assert cache.type_.type_name() == 'spl_kmem_cache_t *'
+    assert sdb.type_canonical_name(cache.type_) == 'struct spl_kmem_cache *'
     return int(cache.skc_slab_alloc.value_())
 
 
 def slab_size(cache: drgn.Object) -> int:
-    assert cache.type_.type_name() == 'spl_kmem_cache_t *'
+    assert sdb.type_canonical_name(cache.type_) == 'struct spl_kmem_cache *'
     return int(cache.skc_slab_size.value_())
 
 
 def slab_linux_cache_source(cache: drgn.Object) -> str:
-    assert cache.type_.type_name() == 'spl_kmem_cache_t *'
+    assert sdb.type_canonical_name(cache.type_) == 'struct spl_kmem_cache *'
     if not backed_by_linux_cache(cache):
         name = slab_name(cache)
         subsystem = "SPL"
@@ -67,46 +69,49 @@ def slab_linux_cache_source(cache: drgn.Object) -> str:
     return f"{name}[{subsystem:4}]"
 
 
-def slab_flags(cache: drgn.Object) -> str:
-    assert cache.type_.type_name() == 'spl_kmem_cache_t *'
+def for_each_slab_flag_in_cache(cache: drgn.Object) -> Iterable[str]:
+    assert sdb.type_canonical_name(cache.type_) == 'struct spl_kmem_cache *'
     flag = cache.skc_flags.value_()
-    flags_detected = []
     for enum_entry, enum_entry_bit in cache.prog_.type(
             'enum kmc_bit').enumerators:
         if flag & (1 << enum_entry_bit):
-            flags_detected.append(enum_entry.replace('_BIT', ''))
-    return '|'.join(flags_detected)
+            yield enum_entry.replace('_BIT', '')
+
+
+def slab_flags(cache: drgn.Object) -> str:
+    assert sdb.type_canonical_name(cache.type_) == 'struct spl_kmem_cache *'
+    return '|'.join(for_each_slab_flag_in_cache(cache))
 
 
 def object_size(cache: drgn.Object) -> int:
-    assert cache.type_.type_name() == 'spl_kmem_cache_t *'
+    assert sdb.type_canonical_name(cache.type_) == 'struct spl_kmem_cache *'
     return int(cache.skc_obj_size.value_())
 
 
 def nr_objects(cache: drgn.Object) -> int:
-    assert cache.type_.type_name() == 'spl_kmem_cache_t *'
+    assert sdb.type_canonical_name(cache.type_) == 'struct spl_kmem_cache *'
     if backed_by_linux_cache(cache):
         return int(cache.skc_obj_alloc.value_())
     return int(cache.skc_obj_total.value_())
 
 
 def obj_alloc(cache: drgn.Object) -> int:
-    assert cache.type_.type_name() == 'spl_kmem_cache_t *'
+    assert sdb.type_canonical_name(cache.type_) == 'struct spl_kmem_cache *'
     return int(cache.skc_obj_alloc.value_())
 
 
 def obj_inactive(cache: drgn.Object) -> int:
-    assert cache.type_.type_name() == 'spl_kmem_cache_t *'
+    assert sdb.type_canonical_name(cache.type_) == 'struct spl_kmem_cache *'
     return nr_objects(cache) - obj_alloc(cache)
 
 
 def objs_per_slab(cache: drgn.Object) -> int:
-    assert cache.type_.type_name() == 'spl_kmem_cache_t *'
+    assert sdb.type_canonical_name(cache.type_) == 'struct spl_kmem_cache *'
     return int(cache.skc_slab_objs.value_())
 
 
 def entry_size(cache: drgn.Object) -> int:
-    assert cache.type_.type_name() == 'spl_kmem_cache_t *'
+    assert sdb.type_canonical_name(cache.type_) == 'struct spl_kmem_cache *'
     if backed_by_linux_cache(cache):
         return slub.entry_size(cache.skc_linux_cache)
     ops = objs_per_slab(cache)
@@ -116,20 +121,85 @@ def entry_size(cache: drgn.Object) -> int:
 
 
 def active_memory(cache: drgn.Object) -> int:
-    assert cache.type_.type_name() == 'spl_kmem_cache_t *'
+    assert sdb.type_canonical_name(cache.type_) == 'struct spl_kmem_cache *'
     return obj_alloc(cache) * entry_size(cache)
 
 
 def total_memory(cache: drgn.Object) -> int:
-    assert cache.type_.type_name() == 'spl_kmem_cache_t *'
+    assert sdb.type_canonical_name(cache.type_) == 'struct spl_kmem_cache *'
     if backed_by_linux_cache(cache):
         return slub.total_memory(cache.skc_linux_cache)
     return slab_size(cache) * nr_slabs(cache)
 
 
 def util(cache: drgn.Object) -> int:
-    assert cache.type_.type_name() == 'spl_kmem_cache_t *'
+    assert sdb.type_canonical_name(cache.type_) == 'struct spl_kmem_cache *'
     total_mem = total_memory(cache)
     if total_mem == 0:
         return 0
     return int((active_memory(cache) / total_mem) * 100)
+
+
+def sko_from_obj(cache: drgn.Object, obj: drgn.Object) -> drgn.Object:
+    assert sdb.type_canonical_name(cache.type_) == 'struct spl_kmem_cache *'
+    cache_obj_align = cache.skc_obj_align.value_()
+    return sdb.create_object(
+        'spl_kmem_obj_t *',
+        obj.value_() + p2.p2roundup(object_size(cache), cache_obj_align))
+
+
+def spl_aligned_obj_size(cache: drgn.Object) -> int:
+    assert sdb.type_canonical_name(cache.type_) == 'struct spl_kmem_cache *'
+    cache_obj_align = cache.skc_obj_align.value_()
+    spl_obj_type_size = sdb.type_canonicalize_size('spl_kmem_obj_t')
+    return p2.p2roundup(object_size(cache), cache_obj_align) + p2.p2roundup(
+        spl_obj_type_size, cache_obj_align)
+
+
+def spl_aligned_slab_size(cache: drgn.Object) -> int:
+    assert sdb.type_canonical_name(cache.type_) == 'struct spl_kmem_cache *'
+    cache_obj_align = cache.skc_obj_align.value_()
+    spl_slab_type_size = sdb.type_canonicalize_size('spl_kmem_slab_t')
+    return p2.p2roundup(spl_slab_type_size, cache_obj_align)
+
+
+def for_each_onslab_object_in_slab(slab: drgn.Object) -> Iterable[drgn.Object]:
+    assert sdb.type_canonical_name(slab.type_) == 'struct spl_kmem_slab *'
+    cache = slab.sks_cache
+    sks_size = spl_aligned_slab_size(cache)
+    spl_obj_size = spl_aligned_obj_size(cache)
+
+    for i in range(slab.sks_objs.value_()):
+        obj = sdb.create_object('void *',
+                                slab.value_() + sks_size + (i * spl_obj_size))
+        #
+        # If the sko_list of the object is empty, it means that
+        # this object is not part of the slab's internal free list
+        # and therefore it is allocated. NOTE: sko_list in the
+        # actual code is not a list, but a link on a list. Thus,
+        # the check below is not checking whether the "object
+        # list" is empty for this slab, but rather whether the
+        # link is part of any list.
+        #
+        sko = sko_from_obj(cache, obj)
+        assert sko.sko_magic.value_() == 0x20202020  # SKO_MAGIC
+        if linked_lists.is_list_empty(sko.sko_list):
+            yield obj
+
+
+def for_each_object_in_spl_cache(cache: drgn.Object) -> Iterable[drgn.Object]:
+    assert sdb.type_canonical_name(cache.type_) == 'struct spl_kmem_cache *'
+    #
+    # ZFSonLinux initially implemented OFFSLAB caches for certain cases
+    # that never showed up and thus have never been used in practice.
+    # Ensure here that we are not looking at such a cache.
+    #
+    if 'KMC_OFFSLAB' in list(for_each_slab_flag_in_cache(cache)):
+        raise sdb.CommandError("spl_caches",
+                               "KMC_OFFSLAB caches are not supported")
+
+    for slab_list in [cache.skc_complete_list, cache.skc_partial_list]:
+        for slab in drgn_list.list_for_each_entry("spl_kmem_slab_t",
+                                                  slab_list.address_of_(),
+                                                  "sks_list"):
+            yield from for_each_onslab_object_in_slab(slab)

sdb/commands/spl/spl_kmem_caches.py

@@ -25,6 +25,7 @@
 import sdb
 from sdb.commands.internal.fmt import size_nicenum
 from sdb.commands.internal.table import Table
+from sdb.commands.linux.internal import slub_helpers as slub
 from sdb.commands.spl.internal import kmem_helpers as kmem
 
 
@@ -97,12 +98,12 @@ def no_input(self) -> Iterable[drgn.Object]:
                 raise sdb.CommandInvalidInputError(
                     self.name, f"'{self.args.s}' is not a valid field")
             yield from sorted(
-                kmem.list_for_each_spl_kmem_cache(),
+                kmem.for_each_spl_kmem_cache(),
                 key=SplKmemCaches.FIELDS[self.args.s],
                 reverse=(self.args.s not in
                          SplKmemCaches.DEFAULT_INCREASING_ORDER_FIELDS))
         else:
-            yield from kmem.list_for_each_spl_kmem_cache()
+            yield from kmem.for_each_spl_kmem_cache()
 
     FIELDS = {
         "address": lambda obj: hex(obj.value_()),
@@ -203,3 +204,35 @@ def pretty_print(self, objs: Iterable[drgn.Object]) -> None:
             table.add_row(row_dict[sort_field], row_dict)
         table.print_(print_headers=self.args.H,
                      reverse_sort=(sort_field not in ["name", "address"]))
+
+
+class SplKmemCacheWalker(sdb.Walker):
+    """
+    Walk through all allocated entries of an spl_kmem_cache.
+
+    DESCRIPTION
+        Walk through all allocated entries of an spl_kmem_cache. If
+        the cache is backed by a SLUB cache then iteration will be
+        delegated to the appropriate walker (keep in mind that in
+        this case not all objects may be part of the actual SPL
+        cache due to the SLUB allocator in Linux merging objects).
+
+    EXAMPLES
+        Print all the objects in the ddt_cache:
+
+            sdb> spl_kmem_caches | filter obj.skc_name == "ddt_cache" | spl_cache
+            (void *)0xffffa08937e80040
+            (void *)0xffffa08937e86180
+            (void *)0xffffa08937e8c2c0
+            (void *)0xffffa08937e92400
+            ...
+    """
+
+    names = ["spl_cache"]
+    input_type = "spl_kmem_cache_t *"
+
+    def walk(self, obj: drgn.Object) -> Iterable[drgn.Object]:
+        if kmem.backed_by_linux_cache(obj):
+            yield from slub.for_each_object_in_cache(obj.skc_linux_cache)
+        else:
+            yield from kmem.for_each_object_in_spl_cache(obj)

sdb/target.py

@@ -117,7 +117,7 @@ def type_canonical_name(t: drgn.Type) -> str:
     """
     Return the "canonical name" of this type.  See type_canonicalize().
     """
-    return type_canonicalize(t).type_name()
+    return str(type_canonicalize(t).type_name())
 
 
 def type_canonicalize_name(type_name: str) -> str:
@@ -137,7 +137,7 @@ def type_canonicalize_size(t: Union[drgn.Type, str]) -> int:
     else:
         assert isinstance(t, drgn.Type)
         type_ = t
-    return type_canonicalize(type_).size
+    return int(type_canonicalize(type_).size)
 
 
 def type_equals(a: drgn.Type, b: drgn.Type) -> bool: