crash.subsystem.{filesystem,storage}: refactor bio decoders

The current bio decoders are essentially open coded everywhere. This commit formalizes the interface to make it easier to extend. Signed-off-by: Jeff Mahoney <jeffm@suse.com>
prakashsurya · Apr 29, 2019 · Apr 29, 2019 · Sep 19, 2018 · Apr 29, 2019 · Apr 29, 2019
commit b7085be43b7e6183347c02edea8d3f2cdf0e18dd
diff --git a/crash/subsystem/filesystem/__init__.py b/crash/subsystem/filesystem/__init__.py
@@ -78,30 +78,6 @@ class FileSystem(CrashBaseClass):
                   'struct buffer_head *',
                   'struct super_block' ]
     __symvals__ = [ 'super_blocks' ]
-    __symbol_callbacks__ = [
-                    ('dio_bio_end_io', '_register_dio_bio_end'),
-                    ('dio_bio_end_aio', '_register_dio_bio_end'),
-                    ('mpage_end_io', '_register_mpage_end_io'),
-                    ('end_bio_bh_io_sync', '_register_end_bio_bh_io_sync') ]
-
-    buffer_head_decoders = {}
-
-    @classmethod
-    def _register_dio_bio(cls, symval):
-        block.register_bio_decoder(cls.dio_bio_end, cls.decode_dio_bio)
-
-    @classmethod
-    def _register_dio_bio_end(cls, sym):
-        block.register_bio_decoder(sym, cls.decode_dio_bio)
-
-    @classmethod
-    def _register_mpage_end_io(cls, sym):
-        block.register_bio_decoder(sym, cls.decode_mpage)
-
-    @classmethod
-    def _register_end_bio_bh_io_sync(cls, sym):
-        block.register_bio_decoder(sym, cls.decode_bio_buffer_head)
-
     @export
     @staticmethod
     def super_fstype(sb: gdb.Value) -> str:
@@ -133,200 +109,6 @@ def super_flags(sb: gdb.Value) -> str:
         """
         return decode_flags(sb['s_flags'], SB_FLAGS)
 
-    @export
-    @classmethod
-    def register_buffer_head_decoder(cls, sym, decoder):
-        """
-        Registers a buffer_head decoder with the filesystem subsystem.
-
-        A buffer_head decoder is a method thats acepts a buffer_head,
-        potentially interprets the private members of the buffer_head,
-        and returns a dictionary.  The only mandatory member of the
-        dictionary is 'description' which contains a human-readable
-        description of the purpose of this buffer_head.
-
-        If the buffer_head is part of a stack, the 'next' item should contain
-        the next object in the stack.  It does not necessarily need to be
-        a buffer_head.  It does need to have a 'decoder' item declared
-        that will accept the given object.  The decoder does not need to
-        be registered unless it will be a top-level decoder.
-
-        Other items can be added as-needed to allow informed callers
-        to obtain direct informatiom.
-
-        Args:
-            sym (gdb.Value<void (*)(struct buffer_head *, int)>):
-                The kernel function used as buffer_head->b_h_end_io callback
-        """
-
-        cls.buffer_head_decoders[sym] = decoder
-
-    @classmethod
-    def decode_dio_bio(cls, bio):
-        """
-        Decodes a bio used for direct i/o.
-
-        This method decodes a bio generated by the direct-io component of
-        the file system subsystem.  The bio can either have been submitted
-        directly or asynchronously.
-
-        Args:
-            bio(gdb.Value<struct bio>): The struct bio to be decoded, generated
-                by the direct i/o component
-
-        Returns:
-            dict: Contains the following items:
-                - description (str): Human-readable description of the bio
-                - bio (gdb.Value<struct bio>): The struct bio being decoded
-                - dio (gdb.Value<struct dio>): The direct i/o component of
-                    the bio
-                - fstype (str): The name of the file system which submitted
-                    this bio
-                - inode (gdb.Value<struct inode>): The struct inode, if any,
-                    that owns the file associated with this bio
-                - offset (int): The offset within the file, in bytes
-                - devname (str): The device name associated with this bio
-        """
-        dio = bio['bi_private'].cast(cls.dio_p_type)
-        fstype = cls.super_fstype(dio['inode']['i_sb'])
-        dev = block_device_name(dio['inode']['i_sb']['s_bdev'])
-        offset = dio['block_in_file'] << dio['blkbits']
-
-        chain = {
-            'description' : "{:x} bio: Direct I/O for {} inode {}, sector {} on {}".format(
-                            int(bio), fstype, dio['inode']['i_ino'],
-                            bio['bi_sector'], dev),
-            'bio' : bio,
-            'dio' : dio,
-            'fstype' : fstype,
-            'inode' : dio['inode'],
-            'offset' : offset,
-            'devname' : dev,
-        }
-        return chain
-
-    @classmethod
-    def decode_mpage(cls, bio):
-        """
-        Decodes a bio used for multipage i/o.
-
-        This method decodes a bio generated by the mpage component of
-        the file system subsystem.
-
-        Args:
-            bio(gdb.Value<struct bio>): The struct bio to be decoded, generated
-                by the mpage component
-
-        Returns:
-            dict: Contains the following items:
-                - description (str): Human-readable description of the bio
-                - bio (gdb.Value<struct bio>): The struct bio being decoded
-                - fstype (str): The name of the file system which submitted
-                    this bio
-                - inode (gdb.Value<struct inode>): The struct inode, if any,
-                    that owns the file associated with this bio
-        """
-        inode = bio['bi_io_vec'][0]['bv_page']['mapping']['host']
-        fstype = cls.super_fstype(inode['i_sb'])
-        chain = {
-            'description' :
-                "{:x} bio: Multipage I/O: inode {}, type {}, dev {}".format(
-                        int(bio), inode['i_ino'], fstype,
-                        block_device_name(bio['bi_bdev'])),
-            'bio' : bio,
-            'fstype' : fstype,
-            'inode' : inode,
-        }
-        return chain
-
-    @classmethod
-    def decode_bio_buffer_head(cls, bio):
-        """
-        Decodes a bio used to perform i/o for buffer_heads
-
-        This method decodes a bio generated by buffer head submission.
-
-        Args:
-            bio(gdb.Value<struct bio>): The struct bio to be decoded, generated
-                by buffer head submission
-
-        Returns:
-            dict: Contains the following items:
-                - description (str): Human-readable description of the bio
-                - bio (gdb.Value<struct bio>): The struct bio being decoded
-                - next (gdb.Value<struct buffer_head>): The buffer_head that
-                  initiated this bio.
-                - decoder (gdb.Value<void (*)(struct buffer_head *, int)>):
-                  A decoder for the buffer head
-        """
-        bh = bio['bi_private'].cast(cls.buffer_head_p_type)
-        chain = {
-            'description' :
-                "{:x} bio: Bio representation of buffer head".format(int(bio)),
-            'bio' : bio,
-            'next' : bh,
-            'decoder' : cls.decode_buffer_head,
-        }
-
-        return chain
-
-    @classmethod
-    def decode_buffer_head(cls, bh):
-        """
-        Decodes a struct buffer_head
-
-        This method decodes a struct buffer_head, using an
-        implementation-specific decoder, if available
-
-        Args:
-            bio(gdb.Value<struct buffer_head>): The struct buffer_head to be
-                decoded.
-
-        Returns:
-            dict: Minimally contains the following items.
-                - description (str): Human-readable description of the bio
-                - bh (gdb.Value<struct buffer_head>): The struct buffer_head
-                Additional items may be available based on the
-                implmentation-specific decoder.
-        """
-        endio = bh['b_end_io']
-        try:
-            return cls.buffer_head_decoders[endio](bh)
-        except KeyError:
-            pass
-        desc = "{:x} buffer_head: for dev {}, block {}, size {} (undecoded)".format(
-                    int(bh), block_device_name(bh['b_bdev']),
-                    bh['b_blocknr'], bh['b_size'])
-        chain = {
-            'description' : desc,
-            'bh' : bh,
-        }
-        return chain
-
-    @classmethod
-    def decode_end_buffer_write_sync(cls, bh):
-        """
-        Decodes a struct buffer_head submitted by file systems for routine
-        synchronous writeback.
-
-        Args:
-            bio(gdb.Value<struct buffer_head>): The struct buffer_head to be
-                decoded.
-
-        Returns:
-            dict: Minimally contains the following items.
-                - description (str): Human-readable description of the bio
-                - bh (gdb.Value<struct buffer_head>): The struct buffer_head
-        """
-        desc = ("{:x} buffer_head: for dev {}, block {}, size {} (unassociated)"
-                .format(block_device_name(bh['b_bdev']),
-                        bh['b_blocknr'], bh['b_size']))
-        chain = {
-            'description' : desc,
-            'bh' : bh,
-        }
-        return chain
-
     @export
     @classmethod
     def for_each_super_block(cls) -> Iterable[gdb.Value]:

diff --git a/crash/subsystem/filesystem/decoders.py b/crash/subsystem/filesystem/decoders.py
@@ -0,0 +1,138 @@
+# -*- coding: utf-8 -*-
+# vim:set shiftwidth=4 softtabstop=4 expandtab textwidth=79:
+
+import gdb
+from crash.util.symbols import Types
+from crash.subsystem.storage import block_device_name
+from crash.subsystem.storage.decoders import Decoder, decode_bh
+from crash.subsystem.filesystem import super_fstype
+
+class DIOBioDecoder(Decoder):
+    """
+    Decodes a bio used for direct i/o.
+
+    This method decodes a bio generated by the direct-io component of
+    the file system subsystem.  The bio can either have been submitted
+    directly or asynchronously.
+
+    Args:
+        bio(gdb.Value<struct bio>): The struct bio to be decoded, generated
+            by the direct i/o component
+    """
+
+    types = Types([ 'struct dio *' ])
+    __endio__ = [ 'dio_bio_end_io', 'dio_bio_end_io' ]
+    description = "{:x} bio: Direct I/O for {} inode {}, sector {} on {}"
+
+    def __init__(self, bio):
+        super().__init__()
+        self.bio = bio
+
+    def interpret(self):
+        self.dio = self.bio['bi_private'].cast(self.types.dio_p_type)
+        self.fstype = super_fstype(self.dio['inode']['i_sb'])
+        self.dev = block_device_name(self.dio['inode']['i_sb']['s_bdev'])
+        self.offset = self.dio['block_in_file'] << self.dio['blkbits']
+
+    def __str__(self):
+        return self.description.format(int(self.bio), self.fstype,
+                                       self.dio['inode']['i_ino'],
+                                       self.bio['bi_sector'], self.dev)
+
+    def __next__(self):
+        return None
+
+DIOBioDecoder.register()
+
+class DecodeMPage(Decoder):
+    """
+    Decodes a bio used for multipage i/o.
+
+    This method decodes a bio generated by the mpage component of
+    the file system subsystem.
+
+    Args:
+        bio(gdb.Value<struct bio>): The struct bio to be decoded, generated
+            by the mpage component
+
+    Returns:
+        dict: Contains the following items:
+            - description (str): Human-readable description of the bio
+            - bio (gdb.Value<struct bio>): The struct bio being decoded
+            - fstype (str): The name of the file system which submitted
+                this bio
+            - inode (gdb.Value<struct inode>): The struct inode, if any,
+                that owns the file associated with this bio
+    """
+
+    __endio__ = 'mpage_end_io'
+
+    description = "{:x} bio: Multipage I/O: inode {}, type {}, dev {}"
+
+    def __init__(self, bio):
+        super().__init__()
+
+        self.bio = bio
+
+    def interpret(self):
+        self.inode = bio['bi_io_vec'][0]['bv_page']['mapping']['host']
+        self.fstype = super_fstype(inode['i_sb'])
+
+    def __str__(self):
+        return self.description.format(int(self.bio), self.inode['i_ino'],
+                                       self.fstype,
+                                       block_device_name(bio['bi_bdev']))
+
+DecodeMPage.register()
+
+class DecodeBioBH(Decoder):
+    """
+    Decodes a bio used to perform i/o for buffer_heads
+
+    This method decodes a bio generated by buffer head submission.
+
+    Args:
+        bio(gdb.Value<struct bio>): The struct bio to be decoded, generated
+            by buffer head submission
+
+    """
+    types = Types([ 'struct buffer_head *' ])
+    __endio__ = 'end_bio_bh_io_sync'
+    description = "{:x} bio: Bio representation of buffer head"
+
+    def __init__(self, bio):
+        super().__init__()
+        self.bio = bio
+
+    def interpret(self):
+        self.bh = self.bio['bi_private'].cast(self.types.buffer_head_p_type)
+
+    def __str__(self):
+        return self.description.format(int(bio))
+
+    def __next__(self):
+        return decode_bh(self.bh)
+
+DecodeBioBH.register()
+
+class DecodeSyncWBBH(Decoder):
+    """
+    Decodes a struct buffer_head submitted by file systems for routine
+    synchronous writeback.
+
+    Args:
+        bio(gdb.Value<struct buffer_head>): The struct buffer_head to be
+            decoded.
+    """
+    __endio__  = 'end_buffer_write_sync'
+    description = "{:x} buffer_head: for dev {}, block {}, size {} (unassociated)"
+
+    def __init__(self, bh):
+        super().__init__()
+        self.bh = bh
+
+    def __str__(self):
+        self.description.format(block_device_name(bh['b_bdev']),
+                                self.bh['b_blocknr'], self.bh['b_size'])
+
+DecodeSyncWBBH.register()