block: simplify tag allocation policy selection

Use a plain BLK_MQ_F_* flag to select the round robin tag selection
instead of overlaying an enum with just two possible values into the
flags space.

Doing so allows adding a BLK_MQ_F_MAX sentinel for simplified overflow
checking in the messy debugfs helpers.

Signed-off-by: Christoph Hellwig <hch@lst.de>
Reviewed-by: John Garry <john.g.garry@oracle.com>
Link: https://lore.kernel.org/r/20250106083531.799976-5-hch@lst.de
Signed-off-by: Jens Axboe <axboe@kernel.dk>

diff --git a/block/blk-mq-debugfs.c b/block/blk-mq-debugfs.c
index 64b3c333aa476fb213a968c8d7d77235feb87700..adf5f0697b6b04bb82d6ff2528f098a9300de1b5 100644 (file)
--- a/block/blk-mq-debugfs.c
+++ b/block/blk-mq-debugfs.c
@@ -172,19 +172,13 @@ static int hctx_state_show(void *data, struct seq_file *m)
        return 0;
 }
 
-#define BLK_TAG_ALLOC_NAME(name) [BLK_TAG_ALLOC_##name] = #name
-static const char *const alloc_policy_name[] = {
-       BLK_TAG_ALLOC_NAME(FIFO),
-       BLK_TAG_ALLOC_NAME(RR),
-};
-#undef BLK_TAG_ALLOC_NAME
-
 #define HCTX_FLAG_NAME(name) [ilog2(BLK_MQ_F_##name)] = #name
 static const char *const hctx_flag_name[] = {
        HCTX_FLAG_NAME(TAG_QUEUE_SHARED),
        HCTX_FLAG_NAME(STACKING),
        HCTX_FLAG_NAME(TAG_HCTX_SHARED),
        HCTX_FLAG_NAME(BLOCKING),
+       HCTX_FLAG_NAME(TAG_RR),
        HCTX_FLAG_NAME(NO_SCHED_BY_DEFAULT),
 };
 #undef HCTX_FLAG_NAME
@@ -192,22 +186,11 @@ static const char *const hctx_flag_name[] = {
 static int hctx_flags_show(void *data, struct seq_file *m)
 {
        struct blk_mq_hw_ctx *hctx = data;
-       const int alloc_policy = BLK_MQ_FLAG_TO_ALLOC_POLICY(hctx->flags);
 
-       BUILD_BUG_ON(ARRAY_SIZE(hctx_flag_name) !=
-                       BLK_MQ_F_ALLOC_POLICY_START_BIT);
-       BUILD_BUG_ON(ARRAY_SIZE(alloc_policy_name) != BLK_TAG_ALLOC_MAX);
+       BUILD_BUG_ON(ARRAY_SIZE(hctx_flag_name) != ilog2(BLK_MQ_F_MAX));
 
-       seq_puts(m, "alloc_policy=");
-       if (alloc_policy < ARRAY_SIZE(alloc_policy_name) &&
-           alloc_policy_name[alloc_policy])
-               seq_puts(m, alloc_policy_name[alloc_policy]);
-       else
-               seq_printf(m, "%d", alloc_policy);
-       seq_puts(m, " ");
-       blk_flags_show(m,
-                      hctx->flags ^ BLK_ALLOC_POLICY_TO_MQ_FLAG(alloc_policy),
-                      hctx_flag_name, ARRAY_SIZE(hctx_flag_name));
+       blk_flags_show(m, hctx->flags, hctx_flag_name,
+                       ARRAY_SIZE(hctx_flag_name));
        seq_puts(m, "\n");
        return 0;
 }

diff --git a/block/blk-mq-tag.c b/block/blk-mq-tag.c
index ab4a66791a2063925710d810f34190c8f820ce88..b9f417d980b46d54b74dec8adcb5b04e6a78635c 100644 (file)
--- a/block/blk-mq-tag.c
+++ b/block/blk-mq-tag.c
@@ -545,11 +545,10 @@ static int bt_alloc(struct sbitmap_queue *bt, unsigned int depth,
 }
 
 struct blk_mq_tags *blk_mq_init_tags(unsigned int total_tags,
-                                    unsigned int reserved_tags,
-                                    int node, int alloc_policy)
+               unsigned int reserved_tags, unsigned int flags, int node)
 {
        unsigned int depth = total_tags - reserved_tags;
-       bool round_robin = alloc_policy == BLK_TAG_ALLOC_RR;
+       bool round_robin = flags & BLK_MQ_F_TAG_RR;
        struct blk_mq_tags *tags;
 
        if (total_tags > BLK_MQ_TAG_MAX) {

diff --git a/block/blk-mq.c b/block/blk-mq.c
index 17f10683d640f78b1d32eaf3c4d8a9146472b870..2e6132f778fd958aae3cad545e4b3dd623c9c304 100644 (file)
--- a/block/blk-mq.c
+++ b/block/blk-mq.c
@@ -3476,8 +3476,7 @@ static struct blk_mq_tags *blk_mq_alloc_rq_map(struct blk_mq_tag_set *set,
        if (node == NUMA_NO_NODE)
                node = set->numa_node;
 
-       tags = blk_mq_init_tags(nr_tags, reserved_tags, node,
-                               BLK_MQ_FLAG_TO_ALLOC_POLICY(set->flags));
+       tags = blk_mq_init_tags(nr_tags, reserved_tags, set->flags, node);
        if (!tags)
                return NULL;
 

diff --git a/block/blk-mq.h b/block/blk-mq.h
index 3bb9ea80f9b6b661919b1388d9ada425c3ac90d1..c872bbbe641185d1ae044d0bc8afd830c671afd8 100644 (file)
--- a/block/blk-mq.h
+++ b/block/blk-mq.h
@@ -163,7 +163,7 @@ struct blk_mq_alloc_data {
 };
 
 struct blk_mq_tags *blk_mq_init_tags(unsigned int nr_tags,
-               unsigned int reserved_tags, int node, int alloc_policy);
+               unsigned int reserved_tags, unsigned int flags, int node);
 void blk_mq_free_tags(struct blk_mq_tags *tags);
 
 unsigned int blk_mq_get_tag(struct blk_mq_alloc_data *data);

diff --git a/drivers/ata/ahci.h b/drivers/ata/ahci.h
index 8f40f75ba08cff4deca261b1162ee9a0fb91fed6..06781bdde0d287cded3c25b9270622ddd40c8b56 100644 (file)
--- a/drivers/ata/ahci.h
+++ b/drivers/ata/ahci.h
@@ -396,7 +396,7 @@ extern const struct attribute_group *ahci_sdev_groups[];
        .shost_groups           = ahci_shost_groups,                    \
        .sdev_groups            = ahci_sdev_groups,                     \
        .change_queue_depth     = ata_scsi_change_queue_depth,          \
-       .tag_alloc_policy       = BLK_TAG_ALLOC_RR,                     \
+       .tag_alloc_policy_rr    = true,                                 \
        .device_configure       = ata_scsi_device_configure
 
 extern struct ata_port_operations ahci_ops;

diff --git a/drivers/ata/pata_macio.c b/drivers/ata/pata_macio.c
index f2f36e55a1f4d25b06e8467a949b3d1f5460fd37..4b01bb6880b031d84e871e3c720c7bd9ad183003 100644 (file)
--- a/drivers/ata/pata_macio.c
+++ b/drivers/ata/pata_macio.c
@@ -935,7 +935,7 @@ static const struct scsi_host_template pata_macio_sht = {
        .device_configure       = pata_macio_device_configure,
        .sdev_groups            = ata_common_sdev_groups,
        .can_queue              = ATA_DEF_QUEUE,
-       .tag_alloc_policy       = BLK_TAG_ALLOC_RR,
+       .tag_alloc_policy_rr    = true,
 };
 
 static struct ata_port_operations pata_macio_ops = {

diff --git a/drivers/ata/sata_mv.c b/drivers/ata/sata_mv.c
index b8f363370e1aa46dfe45e40971f2e800143dec07..21c72650f9ccdf6981ff40af12e7c9ee4048fa41 100644 (file)
--- a/drivers/ata/sata_mv.c
+++ b/drivers/ata/sata_mv.c
@@ -672,7 +672,7 @@ static const struct scsi_host_template mv6_sht = {
        .dma_boundary           = MV_DMA_BOUNDARY,
        .sdev_groups            = ata_ncq_sdev_groups,
        .change_queue_depth     = ata_scsi_change_queue_depth,
-       .tag_alloc_policy       = BLK_TAG_ALLOC_RR,
+       .tag_alloc_policy_rr    = true,
        .device_configure       = ata_scsi_device_configure
 };
 

diff --git a/drivers/ata/sata_nv.c b/drivers/ata/sata_nv.c
index 36d99043ef50ff15eaaee78ba6efc0da36c4e61a..823cce5ea1e9018fee93daa55360e5fad0c97b79 100644 (file)
--- a/drivers/ata/sata_nv.c
+++ b/drivers/ata/sata_nv.c
@@ -385,7 +385,7 @@ static const struct scsi_host_template nv_adma_sht = {
        .device_configure       = nv_adma_device_configure,
        .sdev_groups            = ata_ncq_sdev_groups,
        .change_queue_depth     = ata_scsi_change_queue_depth,
-       .tag_alloc_policy       = BLK_TAG_ALLOC_RR,
+       .tag_alloc_policy_rr    = true,
 };
 
 static const struct scsi_host_template nv_swncq_sht = {
@@ -396,7 +396,7 @@ static const struct scsi_host_template nv_swncq_sht = {
        .device_configure       = nv_swncq_device_configure,
        .sdev_groups            = ata_ncq_sdev_groups,
        .change_queue_depth     = ata_scsi_change_queue_depth,
-       .tag_alloc_policy       = BLK_TAG_ALLOC_RR,
+       .tag_alloc_policy_rr    = true,
 };
 
 /*

diff --git a/drivers/ata/sata_sil24.c b/drivers/ata/sata_sil24.c
index 72c03cbdaff43b02f1b21b7bdb4f3cf458bc0887..935b13e79decc415ffd616881d34915f6d0f7561 100644 (file)
--- a/drivers/ata/sata_sil24.c
+++ b/drivers/ata/sata_sil24.c
@@ -378,7 +378,6 @@ static const struct scsi_host_template sil24_sht = {
        .can_queue              = SIL24_MAX_CMDS,
        .sg_tablesize           = SIL24_MAX_SGE,
        .dma_boundary           = ATA_DMA_BOUNDARY,
-       .tag_alloc_policy       = BLK_TAG_ALLOC_FIFO,
        .sdev_groups            = ata_ncq_sdev_groups,
        .change_queue_depth     = ata_scsi_change_queue_depth,
        .device_configure       = ata_scsi_device_configure

diff --git a/drivers/scsi/hisi_sas/hisi_sas_v3_hw.c b/drivers/scsi/hisi_sas/hisi_sas_v3_hw.c
index 79129c9777048c4a9eb3bebc9ab62ad7497a142c..35501d0aa65559bae9aedd7c04590085bdc2212a 100644 (file)
--- a/drivers/scsi/hisi_sas/hisi_sas_v3_hw.c
+++ b/drivers/scsi/hisi_sas/hisi_sas_v3_hw.c
@@ -3345,7 +3345,7 @@ static const struct scsi_host_template sht_v3_hw = {
        .slave_alloc            = hisi_sas_slave_alloc,
        .shost_groups           = host_v3_hw_groups,
        .sdev_groups            = sdev_groups_v3_hw,
-       .tag_alloc_policy       = BLK_TAG_ALLOC_RR,
+       .tag_alloc_policy_rr    = true,
        .host_reset             = hisi_sas_host_reset,
        .host_tagset            = 1,
        .mq_poll                = queue_complete_v3_hw,

diff --git a/drivers/scsi/scsi_lib.c b/drivers/scsi/scsi_lib.c
index 5cf124e130974cdbd996c154a046282dedc91d79..51c496ca93806e8e64a8b1080b7b6fef57038cd0 100644 (file)
--- a/drivers/scsi/scsi_lib.c
+++ b/drivers/scsi/scsi_lib.c
@@ -2065,8 +2065,8 @@ int scsi_mq_setup_tags(struct Scsi_Host *shost)
        tag_set->queue_depth = shost->can_queue;
        tag_set->cmd_size = cmd_size;
        tag_set->numa_node = dev_to_node(shost->dma_dev);
-       tag_set->flags |=
-               BLK_ALLOC_POLICY_TO_MQ_FLAG(shost->hostt->tag_alloc_policy);
+       if (shost->hostt->tag_alloc_policy_rr)
+               tag_set->flags |= BLK_MQ_F_TAG_RR;
        if (shost->queuecommand_may_block)
                tag_set->flags |= BLK_MQ_F_BLOCKING;
        tag_set->driver_data = shost;

diff --git a/include/linux/blk-mq.h b/include/linux/blk-mq.h
index f2ff0ffa05351da338c523f69f59cf5339e594ed..a0a9007cc1e36f89ebb21e699de3234a3cf9ef5b 100644 (file)
--- a/include/linux/blk-mq.h
+++ b/include/linux/blk-mq.h
@@ -296,13 +296,6 @@ enum blk_eh_timer_return {
        BLK_EH_RESET_TIMER,
 };
 
-/* Keep alloc_policy_name[] in sync with the definitions below */
-enum {
-       BLK_TAG_ALLOC_FIFO,     /* allocate starting from 0 */
-       BLK_TAG_ALLOC_RR,       /* allocate starting from last allocated tag */
-       BLK_TAG_ALLOC_MAX
-};
-
 /**
  * struct blk_mq_hw_ctx - State for a hardware queue facing the hardware
  * block device
@@ -677,20 +670,19 @@ enum {
        BLK_MQ_F_TAG_HCTX_SHARED = 1 << 3,
        BLK_MQ_F_BLOCKING       = 1 << 4,
 
+       /*
+        * Alloc tags on a round-robin base instead of the first available one.
+        */
+       BLK_MQ_F_TAG_RR         = 1 << 5,
+
        /*
         * Select 'none' during queue registration in case of a single hwq
         * or shared hwqs instead of 'mq-deadline'.
         */
        BLK_MQ_F_NO_SCHED_BY_DEFAULT    = 1 << 6,
-       BLK_MQ_F_ALLOC_POLICY_START_BIT = 7,
-       BLK_MQ_F_ALLOC_POLICY_BITS = 1,
+
+       BLK_MQ_F_MAX = 1 << 7,
 };
-#define BLK_MQ_FLAG_TO_ALLOC_POLICY(flags) \
-       ((flags >> BLK_MQ_F_ALLOC_POLICY_START_BIT) & \
-               ((1 << BLK_MQ_F_ALLOC_POLICY_BITS) - 1))
-#define BLK_ALLOC_POLICY_TO_MQ_FLAG(policy) \
-       ((policy & ((1 << BLK_MQ_F_ALLOC_POLICY_BITS) - 1)) \
-               << BLK_MQ_F_ALLOC_POLICY_START_BIT)
 
 #define BLK_MQ_MAX_DEPTH       (10240)
 #define BLK_MQ_NO_HCTX_IDX     (-1U)

diff --git a/include/linux/libata.h b/include/linux/libata.h
index c1a85d46eba6d51a6fd119d787cb4badff28e06b..be5183d75736dc974ada18691e0b73b0c2407063 100644 (file)
--- a/include/linux/libata.h
+++ b/include/linux/libata.h
@@ -1467,13 +1467,13 @@ extern const struct attribute_group *ata_common_sdev_groups[];
 #define ATA_SUBBASE_SHT(drv_name)                              \
        __ATA_BASE_SHT(drv_name),                               \
        .can_queue              = ATA_DEF_QUEUE,                \
-       .tag_alloc_policy       = BLK_TAG_ALLOC_RR,             \
+       .tag_alloc_policy_rr    = true,                         \
        .device_configure       = ata_scsi_device_configure
 
 #define ATA_SUBBASE_SHT_QD(drv_name, drv_qd)                   \
        __ATA_BASE_SHT(drv_name),                               \
        .can_queue              = drv_qd,                       \
-       .tag_alloc_policy       = BLK_TAG_ALLOC_RR,             \
+       .tag_alloc_policy_rr    = true,                         \
        .device_configure       = ata_scsi_device_configure
 
 #define ATA_BASE_SHT(drv_name)                                 \

diff --git a/include/scsi/scsi_host.h b/include/scsi/scsi_host.h
index 2b4ab0369ffbe9dcdb82f0d19fc7ac1e214364b8..02823d6af37de6a7f08f0d742c3db068734005ba 100644 (file)
--- a/include/scsi/scsi_host.h
+++ b/include/scsi/scsi_host.h
@@ -438,8 +438,10 @@ struct scsi_host_template {
         */
        short cmd_per_lun;
 
-       /* If use block layer to manage tags, this is tag allocation policy */
-       int tag_alloc_policy;
+       /*
+        * Allocate tags starting from last allocated tag.
+        */
+       bool tag_alloc_policy_rr : 1;
 
        /*
         * Track QUEUE_FULL events and reduce queue depth on demand.