v5:
- [v4] https://lore.kernel.org/lkml/[email protected]/
- Streamline patch 2 by simplifying unplug_oldest_pwq() and calling it
only in pwq_release_workfn().
v4:
- [v3] https://lore.kernel.org/lkml/[email protected]/
- Rebase on the latest for-6.9 branch again & discard the use of
__WQ_ORDERED_EXPLICIT and resetting of __WQ_ORDERED.
- Add a new patch 1 to change the ordering of pwq's in wq->pwqs from
oldest to newest.
- Change the terminalogy from freeze/thaw to plug/unplug.
- Allow more than 2 pwq's in wq->pwqs of ordered workqueue but only the
oldest one is unplugged. This eliminates the need to wait for
the draining of extra pwq in workqueue_apply_unbound_cpumask().
v3:
- [v2] https://lore.kernel.org/lkml/[email protected]/
- Drop patch 1 as it has been merged into the for-6.9 branch.
- Use rcu_access_pointer() to access wq->dfl_pwq.
- Use RCU protection instead of acquiring wq->mutex in
apply_wqattrs_cleanup().
Ordered workqueues does not currently follow changes made to the
global unbound cpumask because per-pool workqueue changes may break
the ordering guarantee. IOW, a work function in an ordered workqueue
may run on a cpuset isolated CPU.
This series enables ordered workqueues to follow changes made to the
global unbound cpumask by temporaily suspending (plugging) the execution
of work items in the newly allocated pool_workqueue until the old pwq
has been properly drained.
The cpumask of the rescuer task of each workqueue is also made to follow
changes in workqueue unbound cpumask as well as its sysfs cpumask,
if available.
Juri Lelli (1):
kernel/workqueue: Let rescuers follow unbound wq cpumask changes
Waiman Long (3):
workqueue: Link pwq's into wq->pwqs from oldest to newest
workqueue: Enable unbound cpumask update on ordered workqueues
workqueue: Bind unbound workqueue rescuer to wq_unbound_cpumask
kernel/workqueue.c | 81 +++++++++++++++++++++++++++++++++++++++-------
1 file changed, 69 insertions(+), 12 deletions(-)
--
2.39.3
Ordered workqueues does not currently follow changes made to the
global unbound cpumask because per-pool workqueue changes may break
the ordering guarantee. IOW, a work function in an ordered workqueue
may run on an isolated CPU.
This patch enables ordered workqueues to follow changes made to the
global unbound cpumask by temporaily plug or suspend the newly allocated
pool_workqueue from executing newly queued work items until the old
pwq has been properly drained. For ordered workqueues, there should
only be one pwq that is unplugged, the rests should be plugged.
This enables ordered workqueues to follow the unbound cpumask changes
like other unbound workqueues at the expense of some delay in execution
of work functions during the transition period.
Signed-off-by: Waiman Long <[email protected]>
---
kernel/workqueue.c | 69 +++++++++++++++++++++++++++++++++++++++-------
1 file changed, 59 insertions(+), 10 deletions(-)
diff --git a/kernel/workqueue.c b/kernel/workqueue.c
index fa7bd3b34f52..da124859a691 100644
--- a/kernel/workqueue.c
+++ b/kernel/workqueue.c
@@ -255,6 +255,7 @@ struct pool_workqueue {
int refcnt; /* L: reference count */
int nr_in_flight[WORK_NR_COLORS];
/* L: nr of in_flight works */
+ bool plugged; /* L: execution suspended */
/*
* nr_active management and WORK_STRUCT_INACTIVE:
@@ -1708,6 +1709,9 @@ static bool pwq_tryinc_nr_active(struct pool_workqueue *pwq, bool fill)
goto out;
}
+ if (unlikely(pwq->plugged))
+ return false;
+
/*
* Unbound workqueue uses per-node shared nr_active $nna. If @pwq is
* already waiting on $nna, pwq_dec_nr_active() will maintain the
@@ -1782,6 +1786,43 @@ static bool pwq_activate_first_inactive(struct pool_workqueue *pwq, bool fill)
}
}
+/**
+ * unplug_oldest_pwq - restart an oldest plugged pool_workqueue
+ * @wq: workqueue_struct to be restarted
+ *
+ * pwq's are linked into wq->pwqs with the oldest first. For ordered
+ * workqueues, only the oldest pwq is unplugged, the others are plugged to
+ * suspend execution until the oldest one is drained. When this happens, the
+ * next oldest one (first plugged pwq in iteration) will be unplugged to
+ * restart work item execution to ensure proper work item ordering.
+ *
+ * dfl_pwq --------------+ [P] - plugged
+ * |
+ * v
+ * pwqs -> A -> B [P] -> C [P] (newest)
+ * | | |
+ * 1 3 5
+ * | | |
+ * 2 4 6
+ */
+static void unplug_oldest_pwq(struct workqueue_struct *wq)
+{
+ struct pool_workqueue *pwq;
+
+ lockdep_assert_held(&wq->mutex);
+
+ /* Caller should make sure that pwqs isn't empty before calling */
+ pwq = list_first_entry_or_null(&wq->pwqs, struct pool_workqueue,
+ pwqs_node);
+ raw_spin_lock_irq(&pwq->pool->lock);
+ if (pwq->plugged) {
+ pwq->plugged = false;
+ if (pwq_activate_first_inactive(pwq, true))
+ kick_pool(pwq->pool);
+ }
+ raw_spin_unlock_irq(&pwq->pool->lock);
+}
+
/**
* node_activate_pending_pwq - Activate a pending pwq on a wq_node_nr_active
* @nna: wq_node_nr_active to activate a pending pwq for
@@ -4740,6 +4781,13 @@ static void pwq_release_workfn(struct kthread_work *work)
mutex_lock(&wq->mutex);
list_del_rcu(&pwq->pwqs_node);
is_last = list_empty(&wq->pwqs);
+
+ /*
+ * For ordered workqueue with a plugged dfl_pwq, restart it now.
+ */
+ if (!is_last && (wq->flags & __WQ_ORDERED))
+ unplug_oldest_pwq(wq);
+
mutex_unlock(&wq->mutex);
}
@@ -4966,6 +5014,15 @@ apply_wqattrs_prepare(struct workqueue_struct *wq,
cpumask_copy(new_attrs->__pod_cpumask, new_attrs->cpumask);
ctx->attrs = new_attrs;
+ /*
+ * For initialized ordered workqueues, there should only be one pwq
+ * (dfl_pwq). Set the plugged flag of ctx->dfl_pwq to suspend execution
+ * of newly queued work items until execution of older work items in
+ * the old pwq's have completed.
+ */
+ if ((wq->flags & __WQ_ORDERED) && !list_empty(&wq->pwqs))
+ ctx->dfl_pwq->plugged = true;
+
ctx->wq = wq;
return ctx;
@@ -5006,10 +5063,6 @@ static int apply_workqueue_attrs_locked(struct workqueue_struct *wq,
if (WARN_ON(!(wq->flags & WQ_UNBOUND)))
return -EINVAL;
- /* creating multiple pwqs breaks ordering guarantee */
- if (!list_empty(&wq->pwqs) && WARN_ON(wq->flags & __WQ_ORDERED))
- return -EINVAL;
-
ctx = apply_wqattrs_prepare(wq, attrs, wq_unbound_cpumask);
if (IS_ERR(ctx))
return PTR_ERR(ctx);
@@ -6489,9 +6542,6 @@ static int workqueue_apply_unbound_cpumask(const cpumask_var_t unbound_cpumask)
list_for_each_entry(wq, &workqueues, list) {
if (!(wq->flags & WQ_UNBOUND) || (wq->flags & __WQ_DESTROYING))
continue;
- /* creating multiple pwqs breaks ordering guarantee */
- if (wq->flags & __WQ_ORDERED)
- continue;
ctx = apply_wqattrs_prepare(wq, wq->unbound_attrs, unbound_cpumask);
if (IS_ERR(ctx)) {
@@ -7006,9 +7056,8 @@ int workqueue_sysfs_register(struct workqueue_struct *wq)
int ret;
/*
- * Adjusting max_active or creating new pwqs by applying
- * attributes breaks ordering guarantee. Disallow exposing ordered
- * workqueues.
+ * Adjusting max_active breaks ordering guarantee. Disallow exposing
+ * ordered workqueues.
*/
if (WARN_ON(wq->flags & __WQ_ORDERED))
return -EINVAL;
--
2.39.3
On 2/8/24 14:26, Tejun Heo wrote:
> On Thu, Feb 08, 2024 at 11:10:10AM -0500, Waiman Long wrote:
>> v5:
>> - [v4] https://lore.kernel.org/lkml/[email protected]/
>> - Streamline patch 2 by simplifying unplug_oldest_pwq() and calling it
>> only in pwq_release_workfn().
>>
>> v4:
>> - [v3] https://lore.kernel.org/lkml/[email protected]/
>> - Rebase on the latest for-6.9 branch again & discard the use of
>> __WQ_ORDERED_EXPLICIT and resetting of __WQ_ORDERED.
>> - Add a new patch 1 to change the ordering of pwq's in wq->pwqs from
>> oldest to newest.
>> - Change the terminalogy from freeze/thaw to plug/unplug.
>> - Allow more than 2 pwq's in wq->pwqs of ordered workqueue but only the
>> oldest one is unplugged. This eliminates the need to wait for
>> the draining of extra pwq in workqueue_apply_unbound_cpumask().
>>
>> v3:
>> - [v2] https://lore.kernel.org/lkml/[email protected]/
>> - Drop patch 1 as it has been merged into the for-6.9 branch.
>> - Use rcu_access_pointer() to access wq->dfl_pwq.
>> - Use RCU protection instead of acquiring wq->mutex in
>> apply_wqattrs_cleanup().
> Applied the series w/ (w/ the updated second patch) to wq/for-6.9.
>
> Thanks for working on this. It's really great that this got solved finally.
Me too. Thanks for all the good suggestions that you had given me as I
don't have a full understanding of all the different pieces of the
workqueue code.
Cheers,
Longman
On Thu, Feb 08, 2024 at 11:10:10AM -0500, Waiman Long wrote:
> v5:
> - [v4] https://lore.kernel.org/lkml/[email protected]/
> - Streamline patch 2 by simplifying unplug_oldest_pwq() and calling it
> only in pwq_release_workfn().
>
> v4:
> - [v3] https://lore.kernel.org/lkml/[email protected]/
> - Rebase on the latest for-6.9 branch again & discard the use of
> __WQ_ORDERED_EXPLICIT and resetting of __WQ_ORDERED.
> - Add a new patch 1 to change the ordering of pwq's in wq->pwqs from
> oldest to newest.
> - Change the terminalogy from freeze/thaw to plug/unplug.
> - Allow more than 2 pwq's in wq->pwqs of ordered workqueue but only the
> oldest one is unplugged. This eliminates the need to wait for
> the draining of extra pwq in workqueue_apply_unbound_cpumask().
>
> v3:
> - [v2] https://lore.kernel.org/lkml/[email protected]/
> - Drop patch 1 as it has been merged into the for-6.9 branch.
> - Use rcu_access_pointer() to access wq->dfl_pwq.
> - Use RCU protection instead of acquiring wq->mutex in
> apply_wqattrs_cleanup().
Applied the series w/ (w/ the updated second patch) to wq/for-6.9.
Thanks for working on this. It's really great that this got solved finally.
--
tejun