Commit 3f959aa3 authored by Valentin Schneider's avatar Valentin Schneider Committed by Tejun Heo
Browse files

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: default avatarValentin Schneider <vschneid@redhat.com>
Reviewed-by: default avatarLai Jiangshan <jiangshanlai@gmail.com>
Signed-off-by: default avatarTejun Heo <tj@kernel.org>
parent 793777bc

kernel/workqueue.c

+50 −2
Original line number Diff line number Diff line
@@ -169,6 +169,8 @@ struct worker_pool { 


	struct list_head	idle_list;	/* L: list of idle workers */

	struct timer_list	idle_timer;	/* L: worker idle timeout */

	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 */
@@ -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() */