dm: add WQ_PERCPU to alloc_workqueue users

This continues the effort to refactor workqueue APIs, which began with
the introduction of new workqueues and a new alloc_workqueue flag in:

   commit 128ea9f6ccfb ("workqueue: Add system_percpu_wq and system_dfl_wq")
   commit 930c2ea566af ("workqueue: Add new WQ_PERCPU flag")

The refactoring is going to alter the default behavior of
alloc_workqueue() to be unbound by default.

With the introduction of the WQ_PERCPU flag (equivalent to !WQ_UNBOUND),
any alloc_workqueue() caller that doesn’t explicitly specify WQ_UNBOUND
must now use WQ_PERCPU. For more details see the Link tag below.

In order to keep alloc_workqueue() behavior identical, explicitly request
WQ_PERCPU.

Link: https://lore.kernel.org/all/20250221112003.1dSuoGyc@linutronix.de/
Suggested-by: Tejun Heo <tj@kernel.org>
Signed-off-by: Marco Crivellari <marco.crivellari@suse.com>
Signed-off-by: Mikulas Patocka <mpatocka@redhat.com>

diff --git a/drivers/md/dm-bufio.c b/drivers/md/dm-bufio.c
index 5235f3e4924b7a132286690e6c48285a7d32c65c..f41f649c01d4eaf07c95b989026b00406672167c 100644 (file)
--- a/drivers/md/dm-bufio.c
+++ b/drivers/md/dm-bufio.c
@@ -2833,7 +2833,8 @@ static int __init dm_bufio_init(void)
        __cache_size_refresh();
        mutex_unlock(&dm_bufio_clients_lock);
 
-       dm_bufio_wq = alloc_workqueue("dm_bufio_cache", WQ_MEM_RECLAIM, 0);
+       dm_bufio_wq = alloc_workqueue("dm_bufio_cache",
+                                     WQ_MEM_RECLAIM | WQ_PERCPU, 0);
        if (!dm_bufio_wq)
                return -ENOMEM;
 

diff --git a/drivers/md/dm-cache-target.c b/drivers/md/dm-cache-target.c
index 350a0aa53365a2115b713c94df1bc419f5da260d..62d1060619ddf463801b4f197e73931c960268cb 100644 (file)
--- a/drivers/md/dm-cache-target.c
+++ b/drivers/md/dm-cache-target.c
@@ -2526,7 +2526,8 @@ static int cache_create(struct cache_args *ca, struct cache **result)
                goto bad;
        }
 
-       cache->wq = alloc_workqueue("dm-" DM_MSG_PREFIX, WQ_MEM_RECLAIM, 0);
+       cache->wq = alloc_workqueue("dm-" DM_MSG_PREFIX,
+                                   WQ_MEM_RECLAIM | WQ_PERCPU, 0);
        if (!cache->wq) {
                *error = "could not create workqueue for metadata object";
                goto bad;

diff --git a/drivers/md/dm-clone-target.c b/drivers/md/dm-clone-target.c
index ac94e3466560e9feff8a91c4445704336c18fac2..a7f73861a8cdb33f812de967f3524a9856e8ca56 100644 (file)
--- a/drivers/md/dm-clone-target.c
+++ b/drivers/md/dm-clone-target.c
@@ -1861,7 +1861,8 @@ static int clone_ctr(struct dm_target *ti, unsigned int argc, char **argv)
        clone->hydration_offset = 0;
        atomic_set(&clone->hydrations_in_flight, 0);
 
-       clone->wq = alloc_workqueue("dm-" DM_MSG_PREFIX, WQ_MEM_RECLAIM, 0);
+       clone->wq = alloc_workqueue("dm-" DM_MSG_PREFIX,
+                                   WQ_MEM_RECLAIM | WQ_PERCPU, 0);
        if (!clone->wq) {
                ti->error = "Failed to allocate workqueue";
                r = -ENOMEM;

diff --git a/drivers/md/dm-crypt.c b/drivers/md/dm-crypt.c
index 79704fbc523b5a45dd8fa68d300853b2bf4722e0..0e479de75ad0c667e38fd526437b91a6b49a0730 100644 (file)
--- a/drivers/md/dm-crypt.c
+++ b/drivers/md/dm-crypt.c
@@ -3400,7 +3400,9 @@ static int crypt_ctr(struct dm_target *ti, unsigned int argc, char **argv)
        if (test_bit(DM_CRYPT_HIGH_PRIORITY, &cc->flags))
                common_wq_flags |= WQ_HIGHPRI;
 
-       cc->io_queue = alloc_workqueue("kcryptd_io-%s-%d", common_wq_flags, 1, devname, wq_id);
+       cc->io_queue = alloc_workqueue("kcryptd_io-%s-%d",
+                                      common_wq_flags | WQ_PERCPU, 1,
+                                      devname, wq_id);
        if (!cc->io_queue) {
                ti->error = "Couldn't create kcryptd io queue";
                goto bad;
@@ -3408,7 +3410,7 @@ static int crypt_ctr(struct dm_target *ti, unsigned int argc, char **argv)
 
        if (test_bit(DM_CRYPT_SAME_CPU, &cc->flags)) {
                cc->crypt_queue = alloc_workqueue("kcryptd-%s-%d",
-                                                 common_wq_flags | WQ_CPU_INTENSIVE,
+                                                 common_wq_flags | WQ_CPU_INTENSIVE | WQ_PERCPU,
                                                  1, devname, wq_id);
        } else {
                /*

diff --git a/drivers/md/dm-delay.c b/drivers/md/dm-delay.c
index 4bb6553278c74630c8c015f963ebd8e1f7e86bcb..029f04776490a145405393e2c6f428b58d04bec9 100644 (file)
--- a/drivers/md/dm-delay.c
+++ b/drivers/md/dm-delay.c
@@ -290,7 +290,9 @@ out:
        } else {
                timer_setup(&dc->delay_timer, handle_delayed_timer, 0);
                INIT_WORK(&dc->flush_expired_bios, flush_expired_bios);
-               dc->kdelayd_wq = alloc_workqueue("kdelayd", WQ_MEM_RECLAIM, 0);
+               dc->kdelayd_wq = alloc_workqueue("kdelayd",
+                                                WQ_MEM_RECLAIM | WQ_PERCPU,
+                                                0);
                if (!dc->kdelayd_wq) {
                        ret = -EINVAL;
                        DMERR("Couldn't start kdelayd");

diff --git a/drivers/md/dm-integrity.c b/drivers/md/dm-integrity.c
index 79d60495454a518a0f4be2ce7af7c8c705d087b2..380527f43b2a1cbad3f7d5f0086a42671a4a1562 100644 (file)
--- a/drivers/md/dm-integrity.c
+++ b/drivers/md/dm-integrity.c
@@ -4990,7 +4990,8 @@ static int dm_integrity_ctr(struct dm_target *ti, unsigned int argc, char **argv
        }
 
        ic->metadata_wq = alloc_workqueue("dm-integrity-metadata",
-                                         WQ_MEM_RECLAIM, METADATA_WORKQUEUE_MAX_ACTIVE);
+                                         WQ_MEM_RECLAIM | WQ_PERCPU,
+                                         METADATA_WORKQUEUE_MAX_ACTIVE);
        if (!ic->metadata_wq) {
                ti->error = "Cannot allocate workqueue";
                r = -ENOMEM;
@@ -5008,7 +5009,8 @@ static int dm_integrity_ctr(struct dm_target *ti, unsigned int argc, char **argv
                goto bad;
        }
 
-       ic->offload_wq = alloc_workqueue("dm-integrity-offload", WQ_MEM_RECLAIM,
+       ic->offload_wq = alloc_workqueue("dm-integrity-offload",
+                                         WQ_MEM_RECLAIM | WQ_PERCPU,
                                          METADATA_WORKQUEUE_MAX_ACTIVE);
        if (!ic->offload_wq) {
                ti->error = "Cannot allocate workqueue";
@@ -5016,7 +5018,8 @@ static int dm_integrity_ctr(struct dm_target *ti, unsigned int argc, char **argv
                goto bad;
        }
 
-       ic->commit_wq = alloc_workqueue("dm-integrity-commit", WQ_MEM_RECLAIM, 1);
+       ic->commit_wq = alloc_workqueue("dm-integrity-commit",
+                                       WQ_MEM_RECLAIM | WQ_PERCPU, 1);
        if (!ic->commit_wq) {
                ti->error = "Cannot allocate workqueue";
                r = -ENOMEM;
@@ -5025,7 +5028,8 @@ static int dm_integrity_ctr(struct dm_target *ti, unsigned int argc, char **argv
        INIT_WORK(&ic->commit_work, integrity_commit);
 
        if (ic->mode == 'J' || ic->mode == 'B') {
-               ic->writer_wq = alloc_workqueue("dm-integrity-writer", WQ_MEM_RECLAIM, 1);
+               ic->writer_wq = alloc_workqueue("dm-integrity-writer",
+                                               WQ_MEM_RECLAIM | WQ_PERCPU, 1);
                if (!ic->writer_wq) {
                        ti->error = "Cannot allocate workqueue";
                        r = -ENOMEM;
@@ -5197,7 +5201,8 @@ try_smaller_buffer:
        }
 
        if (ic->internal_hash) {
-               ic->recalc_wq = alloc_workqueue("dm-integrity-recalc", WQ_MEM_RECLAIM, 1);
+               ic->recalc_wq = alloc_workqueue("dm-integrity-recalc",
+                                               WQ_MEM_RECLAIM | WQ_PERCPU, 1);
                if (!ic->recalc_wq) {
                        ti->error = "Cannot allocate workqueue";
                        r = -ENOMEM;

diff --git a/drivers/md/dm-kcopyd.c b/drivers/md/dm-kcopyd.c
index 6ea75436a433aa6a48560ce3a6f517f4e9ac8221..cec9a60227b6f0e81279a1c7b8a62c6f4ccc3e9a 100644 (file)
--- a/drivers/md/dm-kcopyd.c
+++ b/drivers/md/dm-kcopyd.c
@@ -934,7 +934,8 @@ struct dm_kcopyd_client *dm_kcopyd_client_create(struct dm_kcopyd_throttle *thro
                goto bad_slab;
 
        INIT_WORK(&kc->kcopyd_work, do_work);
-       kc->kcopyd_wq = alloc_workqueue("kcopyd", WQ_MEM_RECLAIM, 0);
+       kc->kcopyd_wq = alloc_workqueue("kcopyd", WQ_MEM_RECLAIM | WQ_PERCPU,
+                                       0);
        if (!kc->kcopyd_wq) {
                r = -ENOMEM;
                goto bad_workqueue;

diff --git a/drivers/md/dm-log-userspace-base.c b/drivers/md/dm-log-userspace-base.c
index 9fbb4b48fb2bb87dcf41fd204aedb181e9ff9b75..607436804a8b2e1e102e905e72a21dba1717ff6f 100644 (file)
--- a/drivers/md/dm-log-userspace-base.c
+++ b/drivers/md/dm-log-userspace-base.c
@@ -299,7 +299,8 @@ static int userspace_ctr(struct dm_dirty_log *log, struct dm_target *ti,
        }
 
        if (lc->integrated_flush) {
-               lc->dmlog_wq = alloc_workqueue("dmlogd", WQ_MEM_RECLAIM, 0);
+               lc->dmlog_wq = alloc_workqueue("dmlogd",
+                                              WQ_MEM_RECLAIM | WQ_PERCPU, 0);
                if (!lc->dmlog_wq) {
                        DMERR("couldn't start dmlogd");
                        r = -ENOMEM;

diff --git a/drivers/md/dm-mpath.c b/drivers/md/dm-mpath.c
index d5d6ef7ba8381acaf405c80f8b01029ea6355150..c748e7f952c443f8f05100f42b221b6a134be7d1 100644 (file)
--- a/drivers/md/dm-mpath.c
+++ b/drivers/md/dm-mpath.c
@@ -2328,7 +2328,8 @@ static int __init dm_multipath_init(void)
 {
        int r = -ENOMEM;
 
-       kmultipathd = alloc_workqueue("kmpathd", WQ_MEM_RECLAIM, 0);
+       kmultipathd = alloc_workqueue("kmpathd", WQ_MEM_RECLAIM | WQ_PERCPU,
+                                     0);
        if (!kmultipathd) {
                DMERR("failed to create workqueue kmpathd");
                goto bad_alloc_kmultipathd;
@@ -2347,7 +2348,7 @@ static int __init dm_multipath_init(void)
                goto bad_alloc_kmpath_handlerd;
        }
 
-       dm_mpath_wq = alloc_workqueue("dm_mpath_wq", 0, 0);
+       dm_mpath_wq = alloc_workqueue("dm_mpath_wq", WQ_PERCPU, 0);
        if (!dm_mpath_wq) {
                DMERR("failed to create workqueue dm_mpath_wq");
                goto bad_alloc_dm_mpath_wq;

diff --git a/drivers/md/dm-raid1.c b/drivers/md/dm-raid1.c
index 268f734ca9c38ab8f4d1110ff60fa279613fdaba..943c0c6b2087decaa2d626a6f597bd568665b252 100644 (file)
--- a/drivers/md/dm-raid1.c
+++ b/drivers/md/dm-raid1.c
@@ -1128,7 +1128,8 @@ static int mirror_ctr(struct dm_target *ti, unsigned int argc, char **argv)
        ti->num_discard_bios = 1;
        ti->per_io_data_size = sizeof(struct dm_raid1_bio_record);
 
-       ms->kmirrord_wq = alloc_workqueue("kmirrord", WQ_MEM_RECLAIM, 0);
+       ms->kmirrord_wq = alloc_workqueue("kmirrord",
+                                         WQ_MEM_RECLAIM | WQ_PERCPU, 0);
        if (!ms->kmirrord_wq) {
                DMERR("couldn't start kmirrord");
                r = -ENOMEM;
@@ -1500,7 +1501,7 @@ static int __init dm_mirror_init(void)
 {
        int r;
 
-       dm_raid1_wq = alloc_workqueue("dm_raid1_wq", 0, 0);
+       dm_raid1_wq = alloc_workqueue("dm_raid1_wq", WQ_PERCPU, 0);
        if (!dm_raid1_wq) {
                DMERR("Failed to alloc workqueue");
                return -ENOMEM;

diff --git a/drivers/md/dm-snap-persistent.c b/drivers/md/dm-snap-persistent.c
index 568d10842b1f46f31ff009e129c2069cd2812f26..0e13d60bfdd12d497c523936fd563ef1511d249f 100644 (file)
--- a/drivers/md/dm-snap-persistent.c
+++ b/drivers/md/dm-snap-persistent.c
@@ -871,7 +871,8 @@ static int persistent_ctr(struct dm_exception_store *store, char *options)
        atomic_set(&ps->pending_count, 0);
        ps->callbacks = NULL;
 
-       ps->metadata_wq = alloc_workqueue("ksnaphd", WQ_MEM_RECLAIM, 0);
+       ps->metadata_wq = alloc_workqueue("ksnaphd",
+                                         WQ_MEM_RECLAIM | WQ_PERCPU, 0);
        if (!ps->metadata_wq) {
                DMERR("couldn't start header metadata update thread");
                r = -ENOMEM;

diff --git a/drivers/md/dm-stripe.c b/drivers/md/dm-stripe.c
index 8a872f5d633e92eeed05dae36f0199b9140fdd53..20cce876d80caffc12959da85acfc71d1f3d5a0e 100644 (file)
--- a/drivers/md/dm-stripe.c
+++ b/drivers/md/dm-stripe.c
@@ -497,7 +497,7 @@ int __init dm_stripe_init(void)
 {
        int r;
 
-       dm_stripe_wq = alloc_workqueue("dm_stripe_wq", 0, 0);
+       dm_stripe_wq = alloc_workqueue("dm_stripe_wq", WQ_PERCPU, 0);
        if (!dm_stripe_wq)
                return -ENOMEM;
        r = dm_register_target(&stripe_target);

diff --git a/drivers/md/dm-verity-target.c b/drivers/md/dm-verity-target.c
index 777a0ebe8536e70e0b16bf908e56ac6f122cec75..91fb465274bad96a1c6629e9304eb20274d6302d 100644 (file)
--- a/drivers/md/dm-verity-target.c
+++ b/drivers/md/dm-verity-target.c
@@ -1648,7 +1648,9 @@ static int verity_ctr(struct dm_target *ti, unsigned int argc, char **argv)
         * will fall-back to using it for error handling (or if the bufio cache
         * doesn't have required hashes).
         */
-       v->verify_wq = alloc_workqueue("kverityd", WQ_MEM_RECLAIM | WQ_HIGHPRI, 0);
+       v->verify_wq = alloc_workqueue("kverityd",
+                                      WQ_MEM_RECLAIM | WQ_HIGHPRI | WQ_PERCPU,
+                                      0);
        if (!v->verify_wq) {
                ti->error = "Cannot allocate workqueue";
                r = -ENOMEM;

diff --git a/drivers/md/dm-writecache.c b/drivers/md/dm-writecache.c
index d8de4a3076a17de270f0401eb9c11037ab66d9b1..af54e289bcebe456c6a2009649a07b9911e4f0e9 100644 (file)
--- a/drivers/md/dm-writecache.c
+++ b/drivers/md/dm-writecache.c
@@ -2275,7 +2275,8 @@ static int writecache_ctr(struct dm_target *ti, unsigned int argc, char **argv)
                goto bad;
        }
 
-       wc->writeback_wq = alloc_workqueue("writecache-writeback", WQ_MEM_RECLAIM, 1);
+       wc->writeback_wq = alloc_workqueue("writecache-writeback",
+                                          WQ_MEM_RECLAIM | WQ_PERCPU, 1);
        if (!wc->writeback_wq) {
                r = -ENOMEM;
                ti->error = "Could not allocate writeback workqueue";

diff --git a/drivers/md/dm.c b/drivers/md/dm.c
index b632792022601274d85e3ce829d10fe0b4159fec..ea2c43cddde1f140a6359def2a1f547313293554 100644 (file)
--- a/drivers/md/dm.c
+++ b/drivers/md/dm.c
@@ -2366,7 +2366,8 @@ static struct mapped_device *alloc_dev(int minor)
 
        format_dev_t(md->name, MKDEV(_major, minor));
 
-       md->wq = alloc_workqueue("kdmflush/%s", WQ_MEM_RECLAIM, 0, md->name);
+       md->wq = alloc_workqueue("kdmflush/%s", WQ_MEM_RECLAIM | WQ_PERCPU, 0,
+                                md->name);
        if (!md->wq)
                goto bad;
 

diff --git a/drivers/md/md.c b/drivers/md/md.c
index e5922a6829532fb876eed524bc9aef28f36f8d13..a8c75cb929522a43a95f2a47cfcb2353b94bc066 100644 (file)
--- a/drivers/md/md.c
+++ b/drivers/md/md.c
@@ -10454,11 +10454,11 @@ static int __init md_init(void)
                goto err_bitmap;
 
        ret = -ENOMEM;
-       md_wq = alloc_workqueue("md", WQ_MEM_RECLAIM, 0);
+       md_wq = alloc_workqueue("md", WQ_MEM_RECLAIM | WQ_PERCPU, 0);
        if (!md_wq)
                goto err_wq;
 
-       md_misc_wq = alloc_workqueue("md_misc", 0, 0);
+       md_misc_wq = alloc_workqueue("md_misc", WQ_PERCPU, 0);
        if (!md_misc_wq)
                goto err_misc_wq;