Branch data     Line data    Source code

       1                 :            : // SPDX-License-Identifier: GPL-2.0
       2                 :            : #include <linux/bitops.h>
       3                 :            : #include <linux/seq_file.h>
       4                 :            : #include <scsi/scsi_cmnd.h>
       5                 :            : #include <scsi/scsi_dbg.h>
       6                 :            : #include "scsi_debugfs.h"
       7                 :            : 
       8                 :            : #define SCSI_CMD_FLAG_NAME(name)[const_ilog2(SCMD_##name)] = #name
       9                 :            : static const char *const scsi_cmd_flags[] = {
      10                 :            :         SCSI_CMD_FLAG_NAME(TAGGED),
      11                 :            :         SCSI_CMD_FLAG_NAME(UNCHECKED_ISA_DMA),
      12                 :            :         SCSI_CMD_FLAG_NAME(INITIALIZED),
      13                 :            : };
      14                 :            : #undef SCSI_CMD_FLAG_NAME
      15                 :            : 
      16                 :          0 : static int scsi_flags_show(struct seq_file *m, const unsigned long flags,
      17                 :            :                            const char *const *flag_name, int flag_name_count)
      18                 :            : {
      19                 :          0 :         bool sep = false;
      20                 :          0 :         int i;
      21                 :            : 
      22         [ #  # ]:          0 :         for_each_set_bit(i, &flags, BITS_PER_LONG) {
      23         [ #  # ]:          0 :                 if (sep)
      24                 :          0 :                         seq_puts(m, "|");
      25                 :          0 :                 sep = true;
      26   [ #  #  #  # ]:          0 :                 if (i < flag_name_count && flag_name[i])
      27                 :          0 :                         seq_puts(m, flag_name[i]);
      28                 :            :                 else
      29                 :          0 :                         seq_printf(m, "%d", i);
      30                 :            :         }
      31                 :          0 :         return 0;
      32                 :            : }
      33                 :            : 
      34                 :          0 : void scsi_show_rq(struct seq_file *m, struct request *rq)
      35                 :            : {
      36                 :          0 :         struct scsi_cmnd *cmd = container_of(scsi_req(rq), typeof(*cmd), req);
      37                 :          0 :         int alloc_ms = jiffies_to_msecs(jiffies - cmd->jiffies_at_alloc);
      38                 :          0 :         int timeout_ms = jiffies_to_msecs(rq->timeout);
      39         [ #  # ]:          0 :         const u8 *const cdb = READ_ONCE(cmd->cmnd);
      40                 :          0 :         char buf[80] = "(?)";
      41                 :            : 
      42         [ #  # ]:          0 :         if (cdb)
      43                 :          0 :                 __scsi_format_command(buf, sizeof(buf), cdb, cmd->cmd_len);
      44                 :          0 :         seq_printf(m, ", .cmd=%s, .retries=%d, .result = %#x, .flags=", buf,
      45                 :            :                    cmd->retries, cmd->result);
      46                 :          0 :         scsi_flags_show(m, cmd->flags, scsi_cmd_flags,
      47                 :            :                         ARRAY_SIZE(scsi_cmd_flags));
      48                 :          0 :         seq_printf(m, ", .timeout=%d.%03d, allocated %d.%03d s ago",
      49                 :            :                    timeout_ms / 1000, timeout_ms % 1000,
      50                 :            :                    alloc_ms / 1000, alloc_ms % 1000);
      51                 :          0 : }