1 /* Kernel thread helper functions.
2 * Copyright (C) 2004 IBM Corporation, Rusty Russell.
3 *
4 * Creation is done via kthreadd, so that we get a clean environment
5 * even if we're invoked from userspace (think modprobe, hotplug cpu,
6 * etc.).
7 */
8 #include <linux/sched.h>
9 #include <linux/kthread.h>
10 #include <linux/completion.h>
11 #include <linux/err.h>
12 #include <linux/cpuset.h>
13 #include <linux/unistd.h>
14 #include <linux/file.h>
15 #include <linux/export.h>
16 #include <linux/mutex.h>
17 #include <linux/slab.h>
18 #include <linux/freezer.h>
19 #include <linux/ptrace.h>
20 #include <linux/uaccess.h>
21 #include <trace/events/sched.h>
22
23 static DEFINE_SPINLOCK(kthread_create_lock);
24 static LIST_HEAD(kthread_create_list);
25 struct task_struct *kthreadd_task;
26
27 struct kthread_create_info
28 {
29 /* Information passed to kthread() from kthreadd. */
30 int (*threadfn)(void *data);
31 void *data;
32 int node;
33
34 /* Result passed back to kthread_create() from kthreadd. */
35 struct task_struct *result;
36 struct completion *done;
37
38 struct list_head list;
39 };
40
41 struct kthread {
42 unsigned long flags;
43 unsigned int cpu;
44 void *data;
45 struct completion parked;
46 struct completion exited;
47 };
48
49 enum KTHREAD_BITS {
50 KTHREAD_IS_PER_CPU = 0,
51 KTHREAD_SHOULD_STOP,
52 KTHREAD_SHOULD_PARK,
53 KTHREAD_IS_PARKED,
54 };
55
56 #define __to_kthread(vfork) \
57 container_of(vfork, struct kthread, exited)
58
to_kthread(struct task_struct * k)59 static inline struct kthread *to_kthread(struct task_struct *k)
60 {
61 return __to_kthread(k->vfork_done);
62 }
63
to_live_kthread(struct task_struct * k)64 static struct kthread *to_live_kthread(struct task_struct *k)
65 {
66 struct completion *vfork = ACCESS_ONCE(k->vfork_done);
67 if (likely(vfork))
68 return __to_kthread(vfork);
69 return NULL;
70 }
71
72 /**
73 * kthread_should_stop - should this kthread return now?
74 *
75 * When someone calls kthread_stop() on your kthread, it will be woken
76 * and this will return true. You should then return, and your return
77 * value will be passed through to kthread_stop().
78 */
kthread_should_stop(void)79 bool kthread_should_stop(void)
80 {
81 return test_bit(KTHREAD_SHOULD_STOP, &to_kthread(current)->flags);
82 }
83 EXPORT_SYMBOL(kthread_should_stop);
84
85 /**
86 * kthread_should_park - should this kthread park now?
87 *
88 * When someone calls kthread_park() on your kthread, it will be woken
89 * and this will return true. You should then do the necessary
90 * cleanup and call kthread_parkme()
91 *
92 * Similar to kthread_should_stop(), but this keeps the thread alive
93 * and in a park position. kthread_unpark() "restarts" the thread and
94 * calls the thread function again.
95 */
kthread_should_park(void)96 bool kthread_should_park(void)
97 {
98 return test_bit(KTHREAD_SHOULD_PARK, &to_kthread(current)->flags);
99 }
100
101 /**
102 * kthread_freezable_should_stop - should this freezable kthread return now?
103 * @was_frozen: optional out parameter, indicates whether %current was frozen
104 *
105 * kthread_should_stop() for freezable kthreads, which will enter
106 * refrigerator if necessary. This function is safe from kthread_stop() /
107 * freezer deadlock and freezable kthreads should use this function instead
108 * of calling try_to_freeze() directly.
109 */
kthread_freezable_should_stop(bool * was_frozen)110 bool kthread_freezable_should_stop(bool *was_frozen)
111 {
112 bool frozen = false;
113
114 might_sleep();
115
116 if (unlikely(freezing(current)))
117 frozen = __refrigerator(true);
118
119 if (was_frozen)
120 *was_frozen = frozen;
121
122 return kthread_should_stop();
123 }
124 EXPORT_SYMBOL_GPL(kthread_freezable_should_stop);
125
126 /**
127 * kthread_data - return data value specified on kthread creation
128 * @task: kthread task in question
129 *
130 * Return the data value specified when kthread @task was created.
131 * The caller is responsible for ensuring the validity of @task when
132 * calling this function.
133 */
kthread_data(struct task_struct * task)134 void *kthread_data(struct task_struct *task)
135 {
136 return to_kthread(task)->data;
137 }
138
139 /**
140 * probe_kthread_data - speculative version of kthread_data()
141 * @task: possible kthread task in question
142 *
143 * @task could be a kthread task. Return the data value specified when it
144 * was created if accessible. If @task isn't a kthread task or its data is
145 * inaccessible for any reason, %NULL is returned. This function requires
146 * that @task itself is safe to dereference.
147 */
probe_kthread_data(struct task_struct * task)148 void *probe_kthread_data(struct task_struct *task)
149 {
150 struct kthread *kthread = to_kthread(task);
151 void *data = NULL;
152
153 probe_kernel_read(&data, &kthread->data, sizeof(data));
154 return data;
155 }
156
__kthread_parkme(struct kthread * self)157 static void __kthread_parkme(struct kthread *self)
158 {
159 __set_current_state(TASK_PARKED);
160 while (test_bit(KTHREAD_SHOULD_PARK, &self->flags)) {
161 if (!test_and_set_bit(KTHREAD_IS_PARKED, &self->flags))
162 complete(&self->parked);
163 schedule();
164 __set_current_state(TASK_PARKED);
165 }
166 clear_bit(KTHREAD_IS_PARKED, &self->flags);
167 __set_current_state(TASK_RUNNING);
168 }
169
kthread_parkme(void)170 void kthread_parkme(void)
171 {
172 __kthread_parkme(to_kthread(current));
173 }
174
kthread(void * _create)175 static int kthread(void *_create)
176 {
177 /* Copy data: it's on kthread's stack */
178 struct kthread_create_info *create = _create;
179 int (*threadfn)(void *data) = create->threadfn;
180 void *data = create->data;
181 struct completion *done;
182 struct kthread self;
183 int ret;
184
185 self.flags = 0;
186 self.data = data;
187 init_completion(&self.exited);
188 init_completion(&self.parked);
189 current->vfork_done = &self.exited;
190
191 /* If user was SIGKILLed, I release the structure. */
192 done = xchg(&create->done, NULL);
193 if (!done) {
194 kfree(create);
195 do_exit(-EINTR);
196 }
197 /* OK, tell user we're spawned, wait for stop or wakeup */
198 __set_current_state(TASK_UNINTERRUPTIBLE);
199 create->result = current;
200 complete(done);
201 schedule();
202
203 ret = -EINTR;
204
205 if (!test_bit(KTHREAD_SHOULD_STOP, &self.flags)) {
206 __kthread_parkme(&self);
207 ret = threadfn(data);
208 }
209 /* we can't just return, we must preserve "self" on stack */
210 do_exit(ret);
211 }
212
213 /* called from do_fork() to get node information for about to be created task */
tsk_fork_get_node(struct task_struct * tsk)214 int tsk_fork_get_node(struct task_struct *tsk)
215 {
216 #ifdef CONFIG_NUMA
217 if (tsk == kthreadd_task)
218 return tsk->pref_node_fork;
219 #endif
220 return NUMA_NO_NODE;
221 }
222
create_kthread(struct kthread_create_info * create)223 static void create_kthread(struct kthread_create_info *create)
224 {
225 int pid;
226
227 #ifdef CONFIG_NUMA
228 current->pref_node_fork = create->node;
229 #endif
230 /* We want our own signal handler (we take no signals by default). */
231 pid = kernel_thread(kthread, create, CLONE_FS | CLONE_FILES | SIGCHLD);
232 if (pid < 0) {
233 /* If user was SIGKILLed, I release the structure. */
234 struct completion *done = xchg(&create->done, NULL);
235
236 if (!done) {
237 kfree(create);
238 return;
239 }
240 create->result = ERR_PTR(pid);
241 complete(done);
242 }
243 }
244
245 /**
246 * kthread_create_on_node - create a kthread.
247 * @threadfn: the function to run until signal_pending(current).
248 * @data: data ptr for @threadfn.
249 * @node: memory node number.
250 * @namefmt: printf-style name for the thread.
251 *
252 * Description: This helper function creates and names a kernel
253 * thread. The thread will be stopped: use wake_up_process() to start
254 * it. See also kthread_run().
255 *
256 * If thread is going to be bound on a particular cpu, give its node
257 * in @node, to get NUMA affinity for kthread stack, or else give -1.
258 * When woken, the thread will run @threadfn() with @data as its
259 * argument. @threadfn() can either call do_exit() directly if it is a
260 * standalone thread for which no one will call kthread_stop(), or
261 * return when 'kthread_should_stop()' is true (which means
262 * kthread_stop() has been called). The return value should be zero
263 * or a negative error number; it will be passed to kthread_stop().
264 *
265 * Returns a task_struct or ERR_PTR(-ENOMEM) or ERR_PTR(-EINTR).
266 */
kthread_create_on_node(int (* threadfn)(void * data),void * data,int node,const char namefmt[],...)267 struct task_struct *kthread_create_on_node(int (*threadfn)(void *data),
268 void *data, int node,
269 const char namefmt[],
270 ...)
271 {
272 DECLARE_COMPLETION_ONSTACK(done);
273 struct task_struct *task;
274 struct kthread_create_info *create = kmalloc(sizeof(*create),
275 GFP_KERNEL);
276
277 if (!create)
278 return ERR_PTR(-ENOMEM);
279 create->threadfn = threadfn;
280 create->data = data;
281 create->node = node;
282 create->done = &done;
283
284 spin_lock(&kthread_create_lock);
285 list_add_tail(&create->list, &kthread_create_list);
286 spin_unlock(&kthread_create_lock);
287
288 wake_up_process(kthreadd_task);
289 /*
290 * Wait for completion in killable state, for I might be chosen by
291 * the OOM killer while kthreadd is trying to allocate memory for
292 * new kernel thread.
293 */
294 if (unlikely(wait_for_completion_killable(&done))) {
295 /*
296 * If I was SIGKILLed before kthreadd (or new kernel thread)
297 * calls complete(), leave the cleanup of this structure to
298 * that thread.
299 */
300 if (xchg(&create->done, NULL))
301 return ERR_PTR(-EINTR);
302 /*
303 * kthreadd (or new kernel thread) will call complete()
304 * shortly.
305 */
306 wait_for_completion(&done);
307 }
308 task = create->result;
309 if (!IS_ERR(task)) {
310 static const struct sched_param param = { .sched_priority = 0 };
311 va_list args;
312
313 va_start(args, namefmt);
314 vsnprintf(task->comm, sizeof(task->comm), namefmt, args);
315 va_end(args);
316 /*
317 * root may have changed our (kthreadd's) priority or CPU mask.
318 * The kernel thread should not inherit these properties.
319 */
320 sched_setscheduler_nocheck(task, SCHED_NORMAL, ¶m);
321 set_cpus_allowed_ptr(task, cpu_all_mask);
322 }
323 kfree(create);
324 return task;
325 }
326 EXPORT_SYMBOL(kthread_create_on_node);
327
__kthread_bind_mask(struct task_struct * p,const struct cpumask * mask,long state)328 static void __kthread_bind_mask(struct task_struct *p, const struct cpumask *mask, long state)
329 {
330 unsigned long flags;
331
332 if (!wait_task_inactive(p, state)) {
333 WARN_ON(1);
334 return;
335 }
336
337 /* It's safe because the task is inactive. */
338 raw_spin_lock_irqsave(&p->pi_lock, flags);
339 do_set_cpus_allowed(p, mask);
340 p->flags |= PF_NO_SETAFFINITY;
341 raw_spin_unlock_irqrestore(&p->pi_lock, flags);
342 }
343
__kthread_bind(struct task_struct * p,unsigned int cpu,long state)344 static void __kthread_bind(struct task_struct *p, unsigned int cpu, long state)
345 {
346 __kthread_bind_mask(p, cpumask_of(cpu), state);
347 }
348
kthread_bind_mask(struct task_struct * p,const struct cpumask * mask)349 void kthread_bind_mask(struct task_struct *p, const struct cpumask *mask)
350 {
351 __kthread_bind_mask(p, mask, TASK_UNINTERRUPTIBLE);
352 }
353
354 /**
355 * kthread_bind - bind a just-created kthread to a cpu.
356 * @p: thread created by kthread_create().
357 * @cpu: cpu (might not be online, must be possible) for @k to run on.
358 *
359 * Description: This function is equivalent to set_cpus_allowed(),
360 * except that @cpu doesn't need to be online, and the thread must be
361 * stopped (i.e., just returned from kthread_create()).
362 */
kthread_bind(struct task_struct * p,unsigned int cpu)363 void kthread_bind(struct task_struct *p, unsigned int cpu)
364 {
365 __kthread_bind(p, cpu, TASK_UNINTERRUPTIBLE);
366 }
367 EXPORT_SYMBOL(kthread_bind);
368
369 /**
370 * kthread_create_on_cpu - Create a cpu bound kthread
371 * @threadfn: the function to run until signal_pending(current).
372 * @data: data ptr for @threadfn.
373 * @cpu: The cpu on which the thread should be bound,
374 * @namefmt: printf-style name for the thread. Format is restricted
375 * to "name.*%u". Code fills in cpu number.
376 *
377 * Description: This helper function creates and names a kernel thread
378 * The thread will be woken and put into park mode.
379 */
kthread_create_on_cpu(int (* threadfn)(void * data),void * data,unsigned int cpu,const char * namefmt)380 struct task_struct *kthread_create_on_cpu(int (*threadfn)(void *data),
381 void *data, unsigned int cpu,
382 const char *namefmt)
383 {
384 struct task_struct *p;
385
386 p = kthread_create_on_node(threadfn, data, cpu_to_node(cpu), namefmt,
387 cpu);
388 if (IS_ERR(p))
389 return p;
390 set_bit(KTHREAD_IS_PER_CPU, &to_kthread(p)->flags);
391 to_kthread(p)->cpu = cpu;
392 /* Park the thread to get it out of TASK_UNINTERRUPTIBLE state */
393 kthread_park(p);
394 return p;
395 }
396
__kthread_unpark(struct task_struct * k,struct kthread * kthread)397 static void __kthread_unpark(struct task_struct *k, struct kthread *kthread)
398 {
399 clear_bit(KTHREAD_SHOULD_PARK, &kthread->flags);
400 /*
401 * We clear the IS_PARKED bit here as we don't wait
402 * until the task has left the park code. So if we'd
403 * park before that happens we'd see the IS_PARKED bit
404 * which might be about to be cleared.
405 */
406 if (test_and_clear_bit(KTHREAD_IS_PARKED, &kthread->flags)) {
407 if (test_bit(KTHREAD_IS_PER_CPU, &kthread->flags))
408 __kthread_bind(k, kthread->cpu, TASK_PARKED);
409 wake_up_state(k, TASK_PARKED);
410 }
411 }
412
413 /**
414 * kthread_unpark - unpark a thread created by kthread_create().
415 * @k: thread created by kthread_create().
416 *
417 * Sets kthread_should_park() for @k to return false, wakes it, and
418 * waits for it to return. If the thread is marked percpu then its
419 * bound to the cpu again.
420 */
kthread_unpark(struct task_struct * k)421 void kthread_unpark(struct task_struct *k)
422 {
423 struct kthread *kthread = to_live_kthread(k);
424
425 if (kthread)
426 __kthread_unpark(k, kthread);
427 }
428
429 /**
430 * kthread_park - park a thread created by kthread_create().
431 * @k: thread created by kthread_create().
432 *
433 * Sets kthread_should_park() for @k to return true, wakes it, and
434 * waits for it to return. This can also be called after kthread_create()
435 * instead of calling wake_up_process(): the thread will park without
436 * calling threadfn().
437 *
438 * Returns 0 if the thread is parked, -ENOSYS if the thread exited.
439 * If called by the kthread itself just the park bit is set.
440 */
kthread_park(struct task_struct * k)441 int kthread_park(struct task_struct *k)
442 {
443 struct kthread *kthread = to_live_kthread(k);
444 int ret = -ENOSYS;
445
446 if (kthread) {
447 if (!test_bit(KTHREAD_IS_PARKED, &kthread->flags)) {
448 set_bit(KTHREAD_SHOULD_PARK, &kthread->flags);
449 if (k != current) {
450 wake_up_process(k);
451 wait_for_completion(&kthread->parked);
452 }
453 }
454 ret = 0;
455 }
456 return ret;
457 }
458
459 /**
460 * kthread_stop - stop a thread created by kthread_create().
461 * @k: thread created by kthread_create().
462 *
463 * Sets kthread_should_stop() for @k to return true, wakes it, and
464 * waits for it to exit. This can also be called after kthread_create()
465 * instead of calling wake_up_process(): the thread will exit without
466 * calling threadfn().
467 *
468 * If threadfn() may call do_exit() itself, the caller must ensure
469 * task_struct can't go away.
470 *
471 * Returns the result of threadfn(), or %-EINTR if wake_up_process()
472 * was never called.
473 */
kthread_stop(struct task_struct * k)474 int kthread_stop(struct task_struct *k)
475 {
476 struct kthread *kthread;
477 int ret;
478
479 trace_sched_kthread_stop(k);
480
481 get_task_struct(k);
482 kthread = to_live_kthread(k);
483 if (kthread) {
484 set_bit(KTHREAD_SHOULD_STOP, &kthread->flags);
485 __kthread_unpark(k, kthread);
486 wake_up_process(k);
487 wait_for_completion(&kthread->exited);
488 }
489 ret = k->exit_code;
490 put_task_struct(k);
491
492 trace_sched_kthread_stop_ret(ret);
493 return ret;
494 }
495 EXPORT_SYMBOL(kthread_stop);
496
kthreadd(void * unused)497 int kthreadd(void *unused)
498 {
499 struct task_struct *tsk = current;
500
501 /* Setup a clean context for our children to inherit. */
502 set_task_comm(tsk, "kthreadd");
503 ignore_signals(tsk);
504 set_cpus_allowed_ptr(tsk, cpu_all_mask);
505 set_mems_allowed(node_states[N_MEMORY]);
506
507 current->flags |= PF_NOFREEZE;
508
509 for (;;) {
510 set_current_state(TASK_INTERRUPTIBLE);
511 if (list_empty(&kthread_create_list))
512 schedule();
513 __set_current_state(TASK_RUNNING);
514
515 spin_lock(&kthread_create_lock);
516 while (!list_empty(&kthread_create_list)) {
517 struct kthread_create_info *create;
518
519 create = list_entry(kthread_create_list.next,
520 struct kthread_create_info, list);
521 list_del_init(&create->list);
522 spin_unlock(&kthread_create_lock);
523
524 create_kthread(create);
525
526 spin_lock(&kthread_create_lock);
527 }
528 spin_unlock(&kthread_create_lock);
529 }
530
531 return 0;
532 }
533
__init_kthread_worker(struct kthread_worker * worker,const char * name,struct lock_class_key * key)534 void __init_kthread_worker(struct kthread_worker *worker,
535 const char *name,
536 struct lock_class_key *key)
537 {
538 spin_lock_init(&worker->lock);
539 lockdep_set_class_and_name(&worker->lock, key, name);
540 INIT_LIST_HEAD(&worker->work_list);
541 worker->task = NULL;
542 }
543 EXPORT_SYMBOL_GPL(__init_kthread_worker);
544
545 /**
546 * kthread_worker_fn - kthread function to process kthread_worker
547 * @worker_ptr: pointer to initialized kthread_worker
548 *
549 * This function can be used as @threadfn to kthread_create() or
550 * kthread_run() with @worker_ptr argument pointing to an initialized
551 * kthread_worker. The started kthread will process work_list until
552 * the it is stopped with kthread_stop(). A kthread can also call
553 * this function directly after extra initialization.
554 *
555 * Different kthreads can be used for the same kthread_worker as long
556 * as there's only one kthread attached to it at any given time. A
557 * kthread_worker without an attached kthread simply collects queued
558 * kthread_works.
559 */
kthread_worker_fn(void * worker_ptr)560 int kthread_worker_fn(void *worker_ptr)
561 {
562 struct kthread_worker *worker = worker_ptr;
563 struct kthread_work *work;
564
565 WARN_ON(worker->task);
566 worker->task = current;
567 repeat:
568 set_current_state(TASK_INTERRUPTIBLE); /* mb paired w/ kthread_stop */
569
570 if (kthread_should_stop()) {
571 __set_current_state(TASK_RUNNING);
572 spin_lock_irq(&worker->lock);
573 worker->task = NULL;
574 spin_unlock_irq(&worker->lock);
575 return 0;
576 }
577
578 work = NULL;
579 spin_lock_irq(&worker->lock);
580 if (!list_empty(&worker->work_list)) {
581 work = list_first_entry(&worker->work_list,
582 struct kthread_work, node);
583 list_del_init(&work->node);
584 }
585 worker->current_work = work;
586 spin_unlock_irq(&worker->lock);
587
588 if (work) {
589 __set_current_state(TASK_RUNNING);
590 work->func(work);
591 } else if (!freezing(current))
592 schedule();
593
594 try_to_freeze();
595 goto repeat;
596 }
597 EXPORT_SYMBOL_GPL(kthread_worker_fn);
598
599 /* insert @work before @pos in @worker */
insert_kthread_work(struct kthread_worker * worker,struct kthread_work * work,struct list_head * pos)600 static void insert_kthread_work(struct kthread_worker *worker,
601 struct kthread_work *work,
602 struct list_head *pos)
603 {
604 lockdep_assert_held(&worker->lock);
605
606 list_add_tail(&work->node, pos);
607 work->worker = worker;
608 if (!worker->current_work && likely(worker->task))
609 wake_up_process(worker->task);
610 }
611
612 /**
613 * queue_kthread_work - queue a kthread_work
614 * @worker: target kthread_worker
615 * @work: kthread_work to queue
616 *
617 * Queue @work to work processor @task for async execution. @task
618 * must have been created with kthread_worker_create(). Returns %true
619 * if @work was successfully queued, %false if it was already pending.
620 */
queue_kthread_work(struct kthread_worker * worker,struct kthread_work * work)621 bool queue_kthread_work(struct kthread_worker *worker,
622 struct kthread_work *work)
623 {
624 bool ret = false;
625 unsigned long flags;
626
627 spin_lock_irqsave(&worker->lock, flags);
628 if (list_empty(&work->node)) {
629 insert_kthread_work(worker, work, &worker->work_list);
630 ret = true;
631 }
632 spin_unlock_irqrestore(&worker->lock, flags);
633 return ret;
634 }
635 EXPORT_SYMBOL_GPL(queue_kthread_work);
636
637 struct kthread_flush_work {
638 struct kthread_work work;
639 struct completion done;
640 };
641
kthread_flush_work_fn(struct kthread_work * work)642 static void kthread_flush_work_fn(struct kthread_work *work)
643 {
644 struct kthread_flush_work *fwork =
645 container_of(work, struct kthread_flush_work, work);
646 complete(&fwork->done);
647 }
648
649 /**
650 * flush_kthread_work - flush a kthread_work
651 * @work: work to flush
652 *
653 * If @work is queued or executing, wait for it to finish execution.
654 */
flush_kthread_work(struct kthread_work * work)655 void flush_kthread_work(struct kthread_work *work)
656 {
657 struct kthread_flush_work fwork = {
658 KTHREAD_WORK_INIT(fwork.work, kthread_flush_work_fn),
659 COMPLETION_INITIALIZER_ONSTACK(fwork.done),
660 };
661 struct kthread_worker *worker;
662 bool noop = false;
663
664 retry:
665 worker = work->worker;
666 if (!worker)
667 return;
668
669 spin_lock_irq(&worker->lock);
670 if (work->worker != worker) {
671 spin_unlock_irq(&worker->lock);
672 goto retry;
673 }
674
675 if (!list_empty(&work->node))
676 insert_kthread_work(worker, &fwork.work, work->node.next);
677 else if (worker->current_work == work)
678 insert_kthread_work(worker, &fwork.work, worker->work_list.next);
679 else
680 noop = true;
681
682 spin_unlock_irq(&worker->lock);
683
684 if (!noop)
685 wait_for_completion(&fwork.done);
686 }
687 EXPORT_SYMBOL_GPL(flush_kthread_work);
688
689 /**
690 * flush_kthread_worker - flush all current works on a kthread_worker
691 * @worker: worker to flush
692 *
693 * Wait until all currently executing or pending works on @worker are
694 * finished.
695 */
flush_kthread_worker(struct kthread_worker * worker)696 void flush_kthread_worker(struct kthread_worker *worker)
697 {
698 struct kthread_flush_work fwork = {
699 KTHREAD_WORK_INIT(fwork.work, kthread_flush_work_fn),
700 COMPLETION_INITIALIZER_ONSTACK(fwork.done),
701 };
702
703 queue_kthread_work(worker, &fwork.work);
704 wait_for_completion(&fwork.done);
705 }
706 EXPORT_SYMBOL_GPL(flush_kthread_worker);
707