lkml.org 
[lkml]   [2015]   [Nov]   [18]   [last100]   RSS Feed
Views: [wrap][no wrap]   [headers]  [forward] 
 
Messages in this thread
Patch in this message
/
From
Subject[PATCH v3 07/22] kthread: Detect when a kthread work is used by more workers
Date
Nothing currently prevents a work from queuing for a kthread worker
when it is already running on another one. This means that the work
might run in parallel on more workers. Also some operations, e.g.
flush or drain are not reliable.

This problem will be even more visible after we add cancel_kthread_work()
function. It will only have "work" as the parameter and will use
worker->lock to synchronize with others.

Well, normally this is not a problem because the API users are sane.
But bugs might happen and users also might be crazy.

This patch adds a warning when we try to insert the work for another
worker. It does not fully prevent the misuse because it would make the
code much more complicated without a big benefit.

Note that we need to clear the information about the current worker
when the work is not longer used. It is important when the worker
is destroyed and later created again. For example, this is
useful when a service might get disabled and enabled via sysfs.

Also note that kthread_work_pending() function will get more
complicated once we add support for a delayed kthread work and
allow to cancel works.

Just for completeness, the patch adds a check for disabled interrupts
and an empty queue.

The patch also puts all the checks into a separate function. It will
be reused when implementing delayed works.

Signed-off-by: Petr Mladek <pmladek@suse.com>
---
kernel/kthread.c | 45 +++++++++++++++++++++++++++++++++++++++++----
1 file changed, 41 insertions(+), 4 deletions(-)

diff --git a/kernel/kthread.c b/kernel/kthread.c
index 1d41e0faef2d..378d2203c8b0 100644
--- a/kernel/kthread.c
+++ b/kernel/kthread.c
@@ -563,6 +563,18 @@ void __init_kthread_worker(struct kthread_worker *worker,
}
EXPORT_SYMBOL_GPL(__init_kthread_worker);

+/*
+ * Returns true when there is a pending operation for this work.
+ * In particular, it checks if the work is:
+ * - queued
+ *
+ * This function must be called with locked work.
+ */
+static inline bool kthread_work_pending(const struct kthread_work *work)
+{
+ return !list_empty(&work->node);
+}
+
/**
* kthread_worker_fn - kthread function to process kthread_worker
* @worker_ptr: pointer to initialized kthread_worker
@@ -574,6 +586,9 @@ EXPORT_SYMBOL_GPL(__init_kthread_worker);
* The works are not allowed to keep any locks, disable preemption or interrupts
* when they finish. There is defined a safe point for freezing when one work
* finishes and before a new one is started.
+ *
+ * Also the works must not be handled by more workers at the same time, see also
+ * queue_kthread_work().
*/
int kthread_worker_fn(void *worker_ptr)
{
@@ -610,6 +625,12 @@ repeat:
if (work) {
__set_current_state(TASK_RUNNING);
work->func(work);
+
+ spin_lock_irq(&worker->lock);
+ /* Allow to queue the work into another worker */
+ if (!kthread_work_pending(work))
+ work->worker = NULL;
+ spin_unlock_irq(&worker->lock);
} else if (!freezing(current))
schedule();

@@ -696,12 +717,22 @@ create_kthread_worker_on_cpu(int cpu, const char namefmt[])
}
EXPORT_SYMBOL(create_kthread_worker_on_cpu);

+static void insert_kthread_work_sanity_check(struct kthread_worker *worker,
+ struct kthread_work *work)
+{
+ lockdep_assert_held(&worker->lock);
+ WARN_ON_ONCE(!irqs_disabled());
+ WARN_ON_ONCE(!list_empty(&work->node));
+ /* Do not use a work with more workers, see queue_kthread_work() */
+ WARN_ON_ONCE(work->worker && work->worker != worker);
+}
+
/* insert @work before @pos in @worker */
static void insert_kthread_work(struct kthread_worker *worker,
- struct kthread_work *work,
- struct list_head *pos)
+ struct kthread_work *work,
+ struct list_head *pos)
{
- lockdep_assert_held(&worker->lock);
+ insert_kthread_work_sanity_check(worker, work);

list_add_tail(&work->node, pos);
work->worker = worker;
@@ -717,6 +748,12 @@ static void insert_kthread_work(struct kthread_worker *worker,
* Queue @work to work processor @task for async execution. @task
* must have been created with kthread_worker_create(). Returns %true
* if @work was successfully queued, %false if it was already pending.
+ *
+ * Never queue a work into a worker when it is being processed by another
+ * one. Otherwise, some operations, e.g. cancel or flush, will not work
+ * correctly or the work might run in parallel. This is not enforced
+ * because it would make the code too complex. There are only warnings
+ * printed when such a situation is detected.
*/
bool queue_kthread_work(struct kthread_worker *worker,
struct kthread_work *work)
@@ -725,7 +762,7 @@ bool queue_kthread_work(struct kthread_worker *worker,
unsigned long flags;

spin_lock_irqsave(&worker->lock, flags);
- if (list_empty(&work->node)) {
+ if (!kthread_work_pending(work)) {
insert_kthread_work(worker, work, &worker->work_list);
ret = true;
}
--
1.8.5.6


\
 
 \ /
  Last update: 2015-11-18 15:01    [W:0.201 / U:1.056 seconds]
©2003-2018 Jasper Spaans|hosted at Digital Ocean and TransIP|Read the blog|Advertise on this site