Added SCSI inflight commands, removed hash_map and fix bugs.

Signed-off-by: Rajan Shanmugavelu <[email protected]

Author: vashanmu

drgn_tools/iscsi.py

@@ -122,7 +122,7 @@ def print_iscsi_sessions(prog: Program) -> None:
         )
 
         for scsi_dev in for_each_scsi_host_device(prog):
-            name = scsi_device_name(prog, scsi_dev)
+            name = scsi_device_name(scsi_dev)
             print(
                 "scsi{} Channel {} Id {} Lun: {}".format(
                     session.host.host_no.value_(),

drgn_tools/scsi.py

@@ -12,22 +12,18 @@
 from drgn import FaultError
 from drgn import Object
 from drgn import Program
+from drgn import sizeof
 from drgn.helpers.linux.block import _class_to_subsys
 from drgn.helpers.linux.block import for_each_disk
 from drgn.helpers.linux.list import list_for_each_entry
 
+from drgn_tools.block import for_each_mq_pending_request
+from drgn_tools.block import for_each_sq_pending_request
 from drgn_tools.corelens import CorelensModule
 from drgn_tools.module import ensure_debuginfo
 from drgn_tools.table import print_table
 from drgn_tools.util import has_member
-
-
-"""
- Dictionary of gendisks being used as hashmap with request_queue address as the key,
- this is need to lookup the disk names for UEK6 or older kernel where gendisk is not
- part of the request_queue structure.
-"""
-gendisk_map = {}
+from drgn_tools.util import timestamp_str
 
 
 def for_each_scsi_host(prog: Program) -> Iterator[Object]:
@@ -79,7 +75,45 @@ def for_each_scsi_host_device(shost: Object) -> Iterator[Object]:
         yield scsi_dev
 
 
-def scsi_device_name(prog: Program, sdev: Object) -> str:
+def for_each_scsi_cmnd(prog: Program, scsi_disk: Object) -> Iterator[Object]:
+    """
+    Iterates thru all scsi commands for a given scsi device.
+    Return each scsi_cmnd for a given scsi device.
+    """
+    rq = scsi_disk.queue
+    if has_member(rq, "mq_ops") and rq.mq_ops:
+        for scmnd in for_each_scsi_cmd_mq(prog, rq):
+            yield scmnd
+    else:
+        for scmnd in for_each_scsi_cmd_sq(prog, rq):
+            yield scmnd
+
+
+def for_each_scsi_cmd_sq(prog: Program, requestq: Object) -> Iterator[Object]:
+    """
+    Iterates thru all SCSI commands from the block layer pending requests.
+    Return each scsi_command
+    """
+    for rq in for_each_sq_pending_request(requestq):
+        scmnd = rq.value_() + sizeof(prog.type("struct request"))
+        if scmnd == 0:
+            continue
+        yield Object(prog, "struct scsi_cmnd *", value=scmnd)
+
+
+def for_each_scsi_cmd_mq(prog: Program, requestq: Object):
+    """
+    Iterates thru all SCSI commands in all multi hardware queue.
+    Return each scsi_command
+    """
+    for _, rq in for_each_mq_pending_request(requestq):
+        scmnd = rq.value_() + sizeof(prog.type("struct request"))
+        if scmnd == 0:
+            continue
+        yield Object(prog, "struct scsi_cmnd *", value=scmnd)
+
+
+def scsi_device_name(sdev: Object) -> str:
     """
     Get the device name associated with scsi_device.
     :return ``str``
@@ -92,21 +126,6 @@ def scsi_device_name(prog: Program, sdev: Object) -> str:
         return ""
 
 
-def load_gendisk(prog: Program) -> None:
-    """
-    This method loads the all the gendisk into the global hashmap.
-    """
-    msg = ensure_debuginfo(prog, ["sd_mod"])
-    if msg:
-        print(msg)
-        return
-
-    for disk in for_each_disk(prog):
-        disk_rq = hex(disk.queue)
-        gendisk_map[disk_rq] = disk
-    return
-
-
 def scsi_id(scsi_dev: Object) -> str:
     """
     Return Host:Controller:Target:Lun as a string.
@@ -241,20 +260,12 @@ def print_shost_devs(prog: Program) -> None:
         ]
 
         for scsi_dev in for_each_scsi_host_device(shost):
-            if prog.type("struct request_queue").has_member("disk"):
-                gendisk = cast("struct gendisk *", scsi_dev.request_queue.disk)
-                if not gendisk:
-                    continue
-                diskname = gendisk.disk_name.address_of_().string_().decode()
-            else:
-                diskname = gendisk_map[hex(scsi_dev.request_queue)].disk_name.string_().decode()
-
             vendor = scsi_dev.vendor.string_().decode()
             devstate = str(scsi_dev.sdev_state.format_(type_name=False))
 
             output.append(
                 [
-                    str(diskname),
+                    scsi_device_name(scsi_dev),
                     scsi_id(scsi_dev),
                     hex(scsi_dev),
                     str(vendor),
@@ -267,6 +278,90 @@ def print_shost_devs(prog: Program) -> None:
         print_table(output)
 
 
+def print_scsi_cmnds(prog: Program):
+
+    for disk in for_each_disk(prog):
+
+        counter = 0
+        output = [
+            [
+                "Count",
+                "Request",
+                "Bio",
+                "SCSI Cmnd",
+                "Opcode",
+                "Length",
+                "Age",
+                "Sector",
+            ]
+        ]
+
+        for scsi_cmnd in for_each_scsi_cmnd(prog, disk):
+
+            if not scsi_cmnd:
+                continue
+
+            if counter == 0:
+                scsi_disk = cast("struct scsi_disk *", disk.private_data)
+                scsi_device = cast("struct scsi_device *", scsi_disk.device)
+                if not scsi_disk or not scsi_device:
+                    continue
+
+                vendor = scsi_device.vendor.string_().decode()
+                devstate = str(scsi_device.sdev_state.format_(type_name=False))
+                diskname = disk.disk_name.string_().decode()
+                scsiid = scsi_id(scsi_device)
+
+                print(f" Diskname : {diskname} {scsiid}\t\t\tSCSI Device Addr : {hex(scsi_device.value_())}")
+                print(f" Vendor   : {vendor}    \tDevice State\t : {devstate}")
+                print(
+                    "--------------------------------------------------"
+                    "-------------------------------------------------"
+                )
+
+            if has_member(scsi_cmnd, "request"):
+                req = scsi_cmnd.request
+            else:
+                reqp = scsi_cmnd.value_() - sizeof(prog.type("struct request"))
+                req = Object(prog, "struct request *", value=reqp)
+
+            if scsi_cmnd.cmnd[0] == 0x2a or scsi_cmnd.cmnd[0] == 0x28:
+                xfer_len = (scsi_cmnd.cmnd[7] << 8 | scsi_cmnd.cmnd[8]) \
+                    * scsi_cmnd.transfersize
+            else:
+                xfer_len = 0
+
+            if req.bio:
+                if has_member(req.bio, "bi_sector"):
+                    sector = req.bio.bi_sector
+                else:
+                    sector = req.bio.bi_iter.bi_sector
+
+            age = (prog["jiffies"] - scsi_cmnd.jiffies_at_alloc).value_() * 1000000
+            counter += 1
+
+            output.append(
+                [
+                    str(counter),
+                    hex(req.value_()),
+                    hex(req.bio.value_()),
+                    hex(scsi_cmnd.value_()),
+                    hex(scsi_cmnd.cmnd[0].value_()),
+                    str(int(xfer_len)),
+                    timestamp_str(age),
+                    str(int(sector)),
+                ]
+            )
+
+        if len(output) > 1:
+            print_table(output)
+            print(
+                "--------------------------------------------------"
+                "-------------------------------------------------"
+            )
+    return
+
+
 class ScsiInfo(CorelensModule):
     """
     Corelens Module for scsi device information
@@ -280,6 +375,7 @@ class ScsiInfo(CorelensModule):
         [
             "--hosts",
             "--devices",
+            "--queue",
         ]
     ]
 
@@ -294,10 +390,16 @@ def add_args(self, parser: argparse.ArgumentParser) -> None:
             action="store_true",
             help="Print Scsi Devices",
         )
+        parser.add_argument(
+            "--queue",
+            action="store_true",
+            help="Print Inflight SCSI commands",
+        )
 
     def run(self, prog: Program, args: argparse.Namespace) -> None:
         if args.hosts:
             print_scsi_hosts(prog)
         if args.devices:
-            load_gendisk(prog)
             print_shost_devs(prog)
+        if args.queue:
+            print_scsi_cmnds(prog)