| lists.openwall.net | lists / announce owl-users owl-dev john-users john-dev passwdqc-users yescrypt popa3d-users / oss-security kernel-hardening musl sabotage tlsify passwords / crypt-dev xvendor / Bugtraq Full-Disclosure linux-kernel linux-netdev linux-ext4 linux-hardening linux-cve-announce PHC | |
|
Open Source and information security mailing list archives
| ||
|
Message-Id: <20221122192937.2386494-5-vschneid@redhat.com>
Date: Tue, 22 Nov 2022 19:29:36 +0000
From: Valentin Schneider <vschneid@...hat.com>
To: linux-kernel@...r.kernel.org
Cc: Tejun Heo <tj@...nel.org>, Lai Jiangshan <jiangshanlai@...il.com>,
Peter Zijlstra <peterz@...radead.org>,
Frederic Weisbecker <frederic@...nel.org>,
Juri Lelli <juri.lelli@...hat.com>,
Phil Auld <pauld@...hat.com>,
Marcelo Tosatti <mtosatti@...hat.com>
Subject: [PATCH v5 4/5] workqueue: Convert the idle_timer to a timer + work_struct
A later patch will require a sleepable context in the idle worker timeout
function. Converting worker_pool.idle_timer to a delayed_work gives us just
that, however this would imply turning all idle_timer expiries into
scheduler events (waking up a worker to handle the dwork).
Instead, implement a "custom dwork" where the timer callback does some
extra checks before queuing the associated work.
No change in functionality intended.
The new worker_pool.idle_cull_list is made ____cacheline_aligned to prevent
it from sitting over two cachelines.
Signed-off-by: Valentin Schneider <vschneid@...hat.com>
---
kernel/workqueue.c | 68 +++++++++++++++++++++++++++++++++++++++++++---
1 file changed, 64 insertions(+), 4 deletions(-)
diff --git a/kernel/workqueue.c b/kernel/workqueue.c
index 4fc8085f3fe17..b744288c58a4b 100644
--- a/kernel/workqueue.c
+++ b/kernel/workqueue.c
@@ -169,7 +169,12 @@ struct worker_pool {
struct list_head idle_list; /* L: list of idle workers */
struct timer_list idle_timer; /* L: worker idle timeout */
- struct timer_list mayday_timer; /* L: SOS timer for workers */
+
+ struct list_head idle_cull_list /* L: list of idle workers to cull */
+ ____cacheline_aligned;
+ struct work_struct idle_cull_work; /* L: worker idle cleanup */
+
+ struct timer_list mayday_timer; /* L: SOS timer for workers */
/* a workers is either on busy_hash or idle_list, or the manager */
DECLARE_HASHTABLE(busy_hash, BUSY_WORKER_HASH_ORDER);
@@ -1812,7 +1817,9 @@ static void worker_enter_idle(struct worker *worker)
/* idle_list is LIFO */
list_add(&worker->entry, &pool->idle_list);
- if (worker_cull_count(pool) && !timer_pending(&pool->idle_timer))
+ if (worker_cull_count(pool) &&
+ !timer_pending(&pool->idle_timer) &&
+ !work_pending(&pool->idle_cull_work))
mod_timer(&pool->idle_timer, jiffies + IDLE_WORKER_TIMEOUT);
/* Sanity check nr_running. */
@@ -2025,13 +2032,27 @@ static void destroy_worker(struct worker *worker)
wake_up_process(worker->task);
}
+/*
+ * idle_worker_timeout - check if some idle workers can now be deleted.
+ *
+ * The timer is armed in worker_enter_idle(). Note that it isn't disarmed in
+ * worker_leave_idle(), as a worker flicking between idle and active while its
+ * pool is at the worker_cull_count() tipping point would cause too much timer
+ * housekeeping overhead. Since IDLE_WORKER_TIMEOUT is long enough, we just let
+ * it expire and re-evaluate things from there.
+ */
static void idle_worker_timeout(struct timer_list *t)
{
struct worker_pool *pool = from_timer(pool, t, idle_timer);
+ unsigned int max_cull_cnt, cull_cnt;
+
+ if (work_pending(&pool->idle_cull_work))
+ return;
raw_spin_lock_irq(&pool->lock);
- while (worker_cull_count(pool)) {
+ max_cull_cnt = worker_cull_count(pool);
+ for (cull_cnt = 0; cull_cnt < max_cull_cnt; cull_cnt++) {
struct worker *worker;
unsigned long expires;
@@ -2039,12 +2060,48 @@ static void idle_worker_timeout(struct timer_list *t)
worker = list_entry(pool->idle_list.prev, struct worker, entry);
expires = worker->last_active + IDLE_WORKER_TIMEOUT;
+ /* All remaining entries will be younger than this */
if (time_before(jiffies, expires)) {
- mod_timer(&pool->idle_timer, expires);
+ if (!cull_cnt)
+ mod_timer(&pool->idle_timer, expires);
break;
}
+ /*
+ * Mark the idle worker ripe for culling.
+ * If a preempted idle worker gets to run before the idle cull
+ * handles it, it will just pop itself out of that list and
+ * continue as normal.
+ */
+ list_move(&worker->entry, &pool->idle_cull_list);
+ }
+ raw_spin_unlock_irq(&pool->lock);
+
+ if (cull_cnt)
+ queue_work(system_unbound_wq, &pool->idle_cull_work);
+}
+
+/*
+ * idle_cull_fn - cull workers that have been idle for too long.
+ */
+static void idle_cull_fn(struct work_struct *work)
+{
+ struct worker_pool *pool = container_of(work, struct worker_pool, idle_cull_work);
+ struct worker *worker, *tmp;
+
+ raw_spin_lock_irq(&pool->lock);
+
+ list_for_each_entry_safe(worker, tmp, &pool->idle_cull_list, entry)
destroy_worker(worker);
+
+ /* Re-arm the idle timer if necessary */
+ if (pool->nr_idle) {
+ unsigned long expires;
+
+ worker = list_entry(pool->idle_list.prev, struct worker, entry);
+ expires = worker->last_active + IDLE_WORKER_TIMEOUT;
+ if (time_before(jiffies, expires))
+ mod_timer(&pool->idle_timer, expires);
}
raw_spin_unlock_irq(&pool->lock);
@@ -3482,9 +3539,11 @@ static int init_worker_pool(struct worker_pool *pool)
pool->watchdog_ts = jiffies;
INIT_LIST_HEAD(&pool->worklist);
INIT_LIST_HEAD(&pool->idle_list);
+ INIT_LIST_HEAD(&pool->idle_cull_list);
hash_init(pool->busy_hash);
timer_setup(&pool->idle_timer, idle_worker_timeout, TIMER_DEFERRABLE);
+ INIT_WORK(&pool->idle_cull_work, idle_cull_fn);
timer_setup(&pool->mayday_timer, pool_mayday_timeout, 0);
@@ -3632,6 +3691,7 @@ static void put_unbound_pool(struct worker_pool *pool)
/* shut down the timers */
del_timer_sync(&pool->idle_timer);
+ cancel_work_sync(&pool->idle_cull_work);
del_timer_sync(&pool->mayday_timer);
/* RCU protected to allow dereferences from get_work_pool() */
--
2.31.1
Powered by blists - more mailing lists