318  * functions which do some additional work in non-modular code such as
964  * when they finish. There is defined a safe point for freezing when one work
973 	struct kthread_work *work;  in kthread_worker_fn()  local
996 	work = NULL;  in kthread_worker_fn()
999 		work = list_first_entry(&worker->work_list,  in kthread_worker_fn()
1001 		list_del_init(&work->node);  in kthread_worker_fn()
1003 	worker->current_work = work;  in kthread_worker_fn()
1006 	if (work) {  in kthread_worker_fn()
1007 		kthread_work_func_t func = work->func;  in kthread_worker_fn()
1009 		trace_sched_kthread_work_execute_start(work);  in kthread_worker_fn()
1010 		work->func(work);  in kthread_worker_fn()
1012 		 * Avoid dereferencing work after this point.  The trace  in kthread_worker_fn()
1015 		trace_sched_kthread_work_execute_end(work, func);  in kthread_worker_fn()
1104  * how to handle pending work items, prevent queuing new ones, and
1136  * Returns true when the work could not be queued at the moment.
1141 				   struct kthread_work *work)  in queuing_blocked()  argument
1145 	return !list_empty(&work->node) || work->canceling;  in queuing_blocked()
1149 					     struct kthread_work *work)  in kthread_insert_work_sanity_check()  argument
1152 	WARN_ON_ONCE(!list_empty(&work->node));  in kthread_insert_work_sanity_check()
1153 	/* Do not use a work with >1 worker, see kthread_queue_work() */  in kthread_insert_work_sanity_check()
1154 	WARN_ON_ONCE(work->worker && work->worker != worker);  in kthread_insert_work_sanity_check()
1157 /* insert @work before @pos in @worker */
1159 				struct kthread_work *work,  in kthread_insert_work()  argument
1162 	kthread_insert_work_sanity_check(worker, work);  in kthread_insert_work()
1164 	trace_sched_kthread_work_queue_work(worker, work);  in kthread_insert_work()
1166 	list_add_tail(&work->node, pos);  in kthread_insert_work()
1167 	work->worker = worker;  in kthread_insert_work()
1175  * @work: kthread_work to queue
1177  * Queue @work to work processor @task for async execution.  @task
1179  * if @work was successfully queued, %false if it was already pending.
1181  * Reinitialize the work if it needs to be used by another worker.
1185 			struct kthread_work *work)  in kthread_queue_work()  argument
1191 	if (!queuing_blocked(worker, work)) {  in kthread_queue_work()
1192 		kthread_insert_work(worker, work, &worker->work_list);  in kthread_queue_work()
1202  *	delayed work when the timer expires.
1212 	struct kthread_work *work = &dwork->work;  in kthread_delayed_work_timer_fn()  local
1213 	struct kthread_worker *worker = work->worker;  in kthread_delayed_work_timer_fn()
1217 	 * This might happen when a pending work is reinitialized.  in kthread_delayed_work_timer_fn()
1224 	/* Work must not be used with >1 worker, see kthread_queue_work(). */  in kthread_delayed_work_timer_fn()
1225 	WARN_ON_ONCE(work->worker != worker);  in kthread_delayed_work_timer_fn()
1227 	/* Move the work from worker->delayed_work_list. */  in kthread_delayed_work_timer_fn()
1228 	WARN_ON_ONCE(list_empty(&work->node));  in kthread_delayed_work_timer_fn()
1229 	list_del_init(&work->node);  in kthread_delayed_work_timer_fn()
1230 	if (!work->canceling)  in kthread_delayed_work_timer_fn()
1231 		kthread_insert_work(worker, work, &worker->work_list);  in kthread_delayed_work_timer_fn()
1242 	struct kthread_work *work = &dwork->work;  in __kthread_queue_delayed_work()  local
1247 	 * If @delay is 0, queue @dwork->work immediately.  This is for  in __kthread_queue_delayed_work()
1253 		kthread_insert_work(worker, work, &worker->work_list);  in __kthread_queue_delayed_work()
1258 	kthread_insert_work_sanity_check(worker, work);  in __kthread_queue_delayed_work()
1260 	list_add(&work->node, &worker->delayed_work_list);  in __kthread_queue_delayed_work()
1261 	work->worker = worker;  in __kthread_queue_delayed_work()
1267  * kthread_queue_delayed_work - queue the associated kthread work
1273  * If the work has not been pending it starts a timer that will queue
1274  * the work after the given @delay. If @delay is zero, it queues the
1275  * work immediately.
1277  * Return: %false if the @work has already been pending. It means that
1278  * either the timer was running or the work was queued. It returns %true
1285 	struct kthread_work *work = &dwork->work;  in kthread_queue_delayed_work()  local
1291 	if (!queuing_blocked(worker, work)) {  in kthread_queue_delayed_work()
1302 	struct kthread_work	work;  member
1306 static void kthread_flush_work_fn(struct kthread_work *work)  in kthread_flush_work_fn()  argument
1309 		container_of(work, struct kthread_flush_work, work);  in kthread_flush_work_fn()
1315  * @work: work to flush
1317  * If @work is queued or executing, wait for it to finish execution.
1319 void kthread_flush_work(struct kthread_work *work)  in kthread_flush_work()  argument
1322 		KTHREAD_WORK_INIT(fwork.work, kthread_flush_work_fn),  in kthread_flush_work()
1328 	worker = work->worker;  in kthread_flush_work()
1333 	/* Work must not be used with >1 worker, see kthread_queue_work(). */  in kthread_flush_work()
1334 	WARN_ON_ONCE(work->worker != worker);  in kthread_flush_work()
1336 	if (!list_empty(&work->node))  in kthread_flush_work()
1337 		kthread_insert_work(worker, &fwork.work, work->node.next);  in kthread_flush_work()
1338 	else if (worker->current_work == work)  in kthread_flush_work()
1339 		kthread_insert_work(worker, &fwork.work,  in kthread_flush_work()
1353  * not manipulate the work list_head any longer.
1358 static void kthread_cancel_delayed_work_timer(struct kthread_work *work,  in kthread_cancel_delayed_work_timer()  argument
1362 		container_of(work, struct kthread_delayed_work, work);  in kthread_cancel_delayed_work_timer()
1363 	struct kthread_worker *worker = work->worker;  in kthread_cancel_delayed_work_timer()
1371 	work->canceling++;  in kthread_cancel_delayed_work_timer()
1375 	work->canceling--;  in kthread_cancel_delayed_work_timer()
1379  * This function removes the work from the worker queue.
1382  * the timer used by delayed work is not running, e.g. by calling
1385  * The work might still be in use when this function finishes. See the
1388  * Return: %true if @work was pending and successfully canceled,
1389  *	%false if @work was not pending
1391 static bool __kthread_cancel_work(struct kthread_work *work)  in __kthread_cancel_work()  argument
1394 	 * Try to remove the work from a worker list. It might either  in __kthread_cancel_work()
1397 	if (!list_empty(&work->node)) {  in __kthread_cancel_work()
1398 		list_del_init(&work->node);  in __kthread_cancel_work()
1406  * kthread_mod_delayed_work - modify delay of or queue a kthread delayed work
1408  * @dwork: kthread delayed work to queue
1413  * @work is guaranteed to be queued immediately.
1417  * A special case is when the work is being canceled in parallel.
1432 	struct kthread_work *work = &dwork->work;  in kthread_mod_delayed_work()  local
1439 	if (!work->worker) {  in kthread_mod_delayed_work()
1444 	/* Work must not be used with >1 worker, see kthread_queue_work() */  in kthread_mod_delayed_work()
1445 	WARN_ON_ONCE(work->worker != worker);  in kthread_mod_delayed_work()
1448 	 * Temporary cancel the work but do not fight with another command  in kthread_mod_delayed_work()
1449 	 * that is canceling the work as well.  in kthread_mod_delayed_work()
1455 	 * when doing so. But the work can be removed from the queue (list)  in kthread_mod_delayed_work()
1459 	kthread_cancel_delayed_work_timer(work, &flags);  in kthread_mod_delayed_work()
1460 	if (work->canceling) {  in kthread_mod_delayed_work()
1465 	ret = __kthread_cancel_work(work);  in kthread_mod_delayed_work()
1475 static bool __kthread_cancel_work_sync(struct kthread_work *work, bool is_dwork)  in __kthread_cancel_work_sync()  argument
1477 	struct kthread_worker *worker = work->worker;  in __kthread_cancel_work_sync()
1485 	/* Work must not be used with >1 worker, see kthread_queue_work(). */  in __kthread_cancel_work_sync()
1486 	WARN_ON_ONCE(work->worker != worker);  in __kthread_cancel_work_sync()
1489 		kthread_cancel_delayed_work_timer(work, &flags);  in __kthread_cancel_work_sync()
1491 	ret = __kthread_cancel_work(work);  in __kthread_cancel_work_sync()
1493 	if (worker->current_work != work)  in __kthread_cancel_work_sync()
1497 	 * The work is in progress and we need to wait with the lock released.  in __kthread_cancel_work_sync()
1500 	work->canceling++;  in __kthread_cancel_work_sync()
1502 	kthread_flush_work(work);  in __kthread_cancel_work_sync()
1504 	work->canceling--;  in __kthread_cancel_work_sync()
1513  * kthread_cancel_work_sync - cancel a kthread work and wait for it to finish
1514  * @work: the kthread work to cancel
1516  * Cancel @work and wait for its execution to finish.  This function
1517  * can be used even if the work re-queues itself. On return from this
1518  * function, @work is guaranteed to be not pending or executing on any CPU.
1520  * kthread_cancel_work_sync(&delayed_work->work) must not be used for
1523  * The caller must ensure that the worker on which @work was last
1526  * Return: %true if @work was pending, %false otherwise.
1528 bool kthread_cancel_work_sync(struct kthread_work *work)  in kthread_cancel_work_sync()  argument
1530 	return __kthread_cancel_work_sync(work, false);  in kthread_cancel_work_sync()
1535  * kthread_cancel_delayed_work_sync - cancel a kthread delayed work and
1537  * @dwork: the kthread delayed work to cancel
1545 	return __kthread_cancel_work_sync(&dwork->work, true);  in kthread_cancel_delayed_work_sync()
1559 		KTHREAD_WORK_INIT(fwork.work, kthread_flush_work_fn),  in kthread_flush_worker()
1563 	kthread_queue_work(worker, &fwork.work);  in kthread_flush_worker()
1576  * Note that this function is not responsible for handling delayed work, so
1577  * caller should be responsible for queuing or canceling all delayed work items