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.

Signed-off-by: Valentin Schneider <vschneid@redhat.com>
Reviewed-by: Lai Jiangshan <jiangshanlai@gmail.com>
Signed-off-by: Tejun Heo <tj@kernel.org>

diff --git a/kernel/workqueue.c b/kernel/workqueue.c
index f1386be..e918164 100644 (file)
--- a/kernel/workqueue.c
+++ b/kernel/workqueue.c
@@ -169,7 +169,9 @@ 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 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);
@@ -2023,17 +2025,61 @@ static void destroy_worker(struct worker *worker)
        wake_up_process(worker->task);
 }
 
+/**
+ * idle_worker_timeout - check if some idle workers can now be deleted.
+ * @t: The pool's idle_timer that just expired
+ *
+ * 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 too_many_workers() 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);
+       bool do_cull = false;
+
+       if (work_pending(&pool->idle_cull_work))
+               return;
 
        raw_spin_lock_irq(&pool->lock);
 
-       while (too_many_workers(pool)) {
+       if (too_many_workers(pool)) {
                struct worker *worker;
                unsigned long expires;
 
                /* idle_list is kept in LIFO order, check the last one */
+               worker = list_entry(pool->idle_list.prev, struct worker, entry);
+               expires = worker->last_active + IDLE_WORKER_TIMEOUT;
+               do_cull = !time_before(jiffies, expires);
+
+               if (!do_cull)
+                       mod_timer(&pool->idle_timer, expires);
+       }
+       raw_spin_unlock_irq(&pool->lock);
+
+       if (do_cull)
+               queue_work(system_unbound_wq, &pool->idle_cull_work);
+}
+
+/**
+ * idle_cull_fn - cull workers that have been idle for too long.
+ * @work: the pool's work for handling these idle workers
+ *
+ * This goes through a pool's idle workers and gets rid of those that have been
+ * idle for at least IDLE_WORKER_TIMEOUT seconds.
+ */
+static void idle_cull_fn(struct work_struct *work)
+{
+       struct worker_pool *pool = container_of(work, struct worker_pool, idle_cull_work);
+
+       raw_spin_lock_irq(&pool->lock);
+
+       while (too_many_workers(pool)) {
+               struct worker *worker;
+               unsigned long expires;
+
                worker = list_entry(pool->idle_list.prev, struct worker, entry);
                expires = worker->last_active + IDLE_WORKER_TIMEOUT;
 
@@ -3483,6 +3529,7 @@ static int init_worker_pool(struct worker_pool *pool)
        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);
 
@@ -3630,6 +3677,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() */