GNU Linux-libre 4.19.211-gnu1
[releases.git] / kernel / kthread.c
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 <uapi/linux/sched/types.h>
9 #include <linux/sched.h>
10 #include <linux/sched/task.h>
11 #include <linux/kthread.h>
12 #include <linux/completion.h>
13 #include <linux/err.h>
14 #include <linux/cpuset.h>
15 #include <linux/unistd.h>
16 #include <linux/file.h>
17 #include <linux/export.h>
18 #include <linux/mutex.h>
19 #include <linux/slab.h>
20 #include <linux/freezer.h>
21 #include <linux/ptrace.h>
22 #include <linux/uaccess.h>
23 #include <trace/events/sched.h>
24
25 static DEFINE_SPINLOCK(kthread_create_lock);
26 static LIST_HEAD(kthread_create_list);
27 struct task_struct *kthreadd_task;
28
29 struct kthread_create_info
30 {
31         /* Information passed to kthread() from kthreadd. */
32         int (*threadfn)(void *data);
33         void *data;
34         int node;
35
36         /* Result passed back to kthread_create() from kthreadd. */
37         struct task_struct *result;
38         struct completion *done;
39
40         struct list_head list;
41 };
42
43 struct kthread {
44         unsigned long flags;
45         unsigned int cpu;
46         void *data;
47         struct completion parked;
48         struct completion exited;
49 #ifdef CONFIG_BLK_CGROUP
50         struct cgroup_subsys_state *blkcg_css;
51 #endif
52 };
53
54 enum KTHREAD_BITS {
55         KTHREAD_IS_PER_CPU = 0,
56         KTHREAD_SHOULD_STOP,
57         KTHREAD_SHOULD_PARK,
58 };
59
60 static inline void set_kthread_struct(void *kthread)
61 {
62         /*
63          * We abuse ->set_child_tid to avoid the new member and because it
64          * can't be wrongly copied by copy_process(). We also rely on fact
65          * that the caller can't exec, so PF_KTHREAD can't be cleared.
66          */
67         current->set_child_tid = (__force void __user *)kthread;
68 }
69
70 static inline struct kthread *to_kthread(struct task_struct *k)
71 {
72         WARN_ON(!(k->flags & PF_KTHREAD));
73         return (__force void *)k->set_child_tid;
74 }
75
76 void free_kthread_struct(struct task_struct *k)
77 {
78         struct kthread *kthread;
79
80         /*
81          * Can be NULL if this kthread was created by kernel_thread()
82          * or if kmalloc() in kthread() failed.
83          */
84         kthread = to_kthread(k);
85 #ifdef CONFIG_BLK_CGROUP
86         WARN_ON_ONCE(kthread && kthread->blkcg_css);
87 #endif
88         kfree(kthread);
89 }
90
91 /**
92  * kthread_should_stop - should this kthread return now?
93  *
94  * When someone calls kthread_stop() on your kthread, it will be woken
95  * and this will return true.  You should then return, and your return
96  * value will be passed through to kthread_stop().
97  */
98 bool kthread_should_stop(void)
99 {
100         return test_bit(KTHREAD_SHOULD_STOP, &to_kthread(current)->flags);
101 }
102 EXPORT_SYMBOL(kthread_should_stop);
103
104 /**
105  * kthread_should_park - should this kthread park now?
106  *
107  * When someone calls kthread_park() on your kthread, it will be woken
108  * and this will return true.  You should then do the necessary
109  * cleanup and call kthread_parkme()
110  *
111  * Similar to kthread_should_stop(), but this keeps the thread alive
112  * and in a park position. kthread_unpark() "restarts" the thread and
113  * calls the thread function again.
114  */
115 bool kthread_should_park(void)
116 {
117         return test_bit(KTHREAD_SHOULD_PARK, &to_kthread(current)->flags);
118 }
119 EXPORT_SYMBOL_GPL(kthread_should_park);
120
121 /**
122  * kthread_freezable_should_stop - should this freezable kthread return now?
123  * @was_frozen: optional out parameter, indicates whether %current was frozen
124  *
125  * kthread_should_stop() for freezable kthreads, which will enter
126  * refrigerator if necessary.  This function is safe from kthread_stop() /
127  * freezer deadlock and freezable kthreads should use this function instead
128  * of calling try_to_freeze() directly.
129  */
130 bool kthread_freezable_should_stop(bool *was_frozen)
131 {
132         bool frozen = false;
133
134         might_sleep();
135
136         if (unlikely(freezing(current)))
137                 frozen = __refrigerator(true);
138
139         if (was_frozen)
140                 *was_frozen = frozen;
141
142         return kthread_should_stop();
143 }
144 EXPORT_SYMBOL_GPL(kthread_freezable_should_stop);
145
146 /**
147  * kthread_data - return data value specified on kthread creation
148  * @task: kthread task in question
149  *
150  * Return the data value specified when kthread @task was created.
151  * The caller is responsible for ensuring the validity of @task when
152  * calling this function.
153  */
154 void *kthread_data(struct task_struct *task)
155 {
156         return to_kthread(task)->data;
157 }
158
159 /**
160  * kthread_probe_data - speculative version of kthread_data()
161  * @task: possible kthread task in question
162  *
163  * @task could be a kthread task.  Return the data value specified when it
164  * was created if accessible.  If @task isn't a kthread task or its data is
165  * inaccessible for any reason, %NULL is returned.  This function requires
166  * that @task itself is safe to dereference.
167  */
168 void *kthread_probe_data(struct task_struct *task)
169 {
170         struct kthread *kthread = to_kthread(task);
171         void *data = NULL;
172
173         probe_kernel_read(&data, &kthread->data, sizeof(data));
174         return data;
175 }
176
177 static void __kthread_parkme(struct kthread *self)
178 {
179         for (;;) {
180                 /*
181                  * TASK_PARKED is a special state; we must serialize against
182                  * possible pending wakeups to avoid store-store collisions on
183                  * task->state.
184                  *
185                  * Such a collision might possibly result in the task state
186                  * changin from TASK_PARKED and us failing the
187                  * wait_task_inactive() in kthread_park().
188                  */
189                 set_special_state(TASK_PARKED);
190                 if (!test_bit(KTHREAD_SHOULD_PARK, &self->flags))
191                         break;
192
193                 /*
194                  * Thread is going to call schedule(), do not preempt it,
195                  * or the caller of kthread_park() may spend more time in
196                  * wait_task_inactive().
197                  */
198                 preempt_disable();
199                 complete(&self->parked);
200                 schedule_preempt_disabled();
201                 preempt_enable();
202         }
203         __set_current_state(TASK_RUNNING);
204 }
205
206 void kthread_parkme(void)
207 {
208         __kthread_parkme(to_kthread(current));
209 }
210 EXPORT_SYMBOL_GPL(kthread_parkme);
211
212 static int kthread(void *_create)
213 {
214         /* Copy data: it's on kthread's stack */
215         struct kthread_create_info *create = _create;
216         int (*threadfn)(void *data) = create->threadfn;
217         void *data = create->data;
218         struct completion *done;
219         struct kthread *self;
220         int ret;
221
222         self = kzalloc(sizeof(*self), GFP_KERNEL);
223         set_kthread_struct(self);
224
225         /* If user was SIGKILLed, I release the structure. */
226         done = xchg(&create->done, NULL);
227         if (!done) {
228                 kfree(create);
229                 do_exit(-EINTR);
230         }
231
232         if (!self) {
233                 create->result = ERR_PTR(-ENOMEM);
234                 complete(done);
235                 do_exit(-ENOMEM);
236         }
237
238         self->data = data;
239         init_completion(&self->exited);
240         init_completion(&self->parked);
241         current->vfork_done = &self->exited;
242
243         /* OK, tell user we're spawned, wait for stop or wakeup */
244         __set_current_state(TASK_UNINTERRUPTIBLE);
245         create->result = current;
246         /*
247          * Thread is going to call schedule(), do not preempt it,
248          * or the creator may spend more time in wait_task_inactive().
249          */
250         preempt_disable();
251         complete(done);
252         schedule_preempt_disabled();
253         preempt_enable();
254
255         ret = -EINTR;
256         if (!test_bit(KTHREAD_SHOULD_STOP, &self->flags)) {
257                 cgroup_kthread_ready();
258                 __kthread_parkme(self);
259                 ret = threadfn(data);
260         }
261         do_exit(ret);
262 }
263
264 /* called from do_fork() to get node information for about to be created task */
265 int tsk_fork_get_node(struct task_struct *tsk)
266 {
267 #ifdef CONFIG_NUMA
268         if (tsk == kthreadd_task)
269                 return tsk->pref_node_fork;
270 #endif
271         return NUMA_NO_NODE;
272 }
273
274 static void create_kthread(struct kthread_create_info *create)
275 {
276         int pid;
277
278 #ifdef CONFIG_NUMA
279         current->pref_node_fork = create->node;
280 #endif
281         /* We want our own signal handler (we take no signals by default). */
282         pid = kernel_thread(kthread, create, CLONE_FS | CLONE_FILES | SIGCHLD);
283         if (pid < 0) {
284                 /* If user was SIGKILLed, I release the structure. */
285                 struct completion *done = xchg(&create->done, NULL);
286
287                 if (!done) {
288                         kfree(create);
289                         return;
290                 }
291                 create->result = ERR_PTR(pid);
292                 complete(done);
293         }
294 }
295
296 static __printf(4, 0)
297 struct task_struct *__kthread_create_on_node(int (*threadfn)(void *data),
298                                                     void *data, int node,
299                                                     const char namefmt[],
300                                                     va_list args)
301 {
302         DECLARE_COMPLETION_ONSTACK(done);
303         struct task_struct *task;
304         struct kthread_create_info *create = kmalloc(sizeof(*create),
305                                                      GFP_KERNEL);
306
307         if (!create)
308                 return ERR_PTR(-ENOMEM);
309         create->threadfn = threadfn;
310         create->data = data;
311         create->node = node;
312         create->done = &done;
313
314         spin_lock(&kthread_create_lock);
315         list_add_tail(&create->list, &kthread_create_list);
316         spin_unlock(&kthread_create_lock);
317
318         wake_up_process(kthreadd_task);
319         /*
320          * Wait for completion in killable state, for I might be chosen by
321          * the OOM killer while kthreadd is trying to allocate memory for
322          * new kernel thread.
323          */
324         if (unlikely(wait_for_completion_killable(&done))) {
325                 /*
326                  * If I was SIGKILLed before kthreadd (or new kernel thread)
327                  * calls complete(), leave the cleanup of this structure to
328                  * that thread.
329                  */
330                 if (xchg(&create->done, NULL))
331                         return ERR_PTR(-EINTR);
332                 /*
333                  * kthreadd (or new kernel thread) will call complete()
334                  * shortly.
335                  */
336                 wait_for_completion(&done);
337         }
338         task = create->result;
339         if (!IS_ERR(task)) {
340                 static const struct sched_param param = { .sched_priority = 0 };
341                 char name[TASK_COMM_LEN];
342
343                 /*
344                  * task is already visible to other tasks, so updating
345                  * COMM must be protected.
346                  */
347                 vsnprintf(name, sizeof(name), namefmt, args);
348                 set_task_comm(task, name);
349                 /*
350                  * root may have changed our (kthreadd's) priority or CPU mask.
351                  * The kernel thread should not inherit these properties.
352                  */
353                 sched_setscheduler_nocheck(task, SCHED_NORMAL, &param);
354                 set_cpus_allowed_ptr(task, cpu_all_mask);
355         }
356         kfree(create);
357         return task;
358 }
359
360 /**
361  * kthread_create_on_node - create a kthread.
362  * @threadfn: the function to run until signal_pending(current).
363  * @data: data ptr for @threadfn.
364  * @node: task and thread structures for the thread are allocated on this node
365  * @namefmt: printf-style name for the thread.
366  *
367  * Description: This helper function creates and names a kernel
368  * thread.  The thread will be stopped: use wake_up_process() to start
369  * it.  See also kthread_run().  The new thread has SCHED_NORMAL policy and
370  * is affine to all CPUs.
371  *
372  * If thread is going to be bound on a particular cpu, give its node
373  * in @node, to get NUMA affinity for kthread stack, or else give NUMA_NO_NODE.
374  * When woken, the thread will run @threadfn() with @data as its
375  * argument. @threadfn() can either call do_exit() directly if it is a
376  * standalone thread for which no one will call kthread_stop(), or
377  * return when 'kthread_should_stop()' is true (which means
378  * kthread_stop() has been called).  The return value should be zero
379  * or a negative error number; it will be passed to kthread_stop().
380  *
381  * Returns a task_struct or ERR_PTR(-ENOMEM) or ERR_PTR(-EINTR).
382  */
383 struct task_struct *kthread_create_on_node(int (*threadfn)(void *data),
384                                            void *data, int node,
385                                            const char namefmt[],
386                                            ...)
387 {
388         struct task_struct *task;
389         va_list args;
390
391         va_start(args, namefmt);
392         task = __kthread_create_on_node(threadfn, data, node, namefmt, args);
393         va_end(args);
394
395         return task;
396 }
397 EXPORT_SYMBOL(kthread_create_on_node);
398
399 static void __kthread_bind_mask(struct task_struct *p, const struct cpumask *mask, long state)
400 {
401         unsigned long flags;
402
403         if (!wait_task_inactive(p, state)) {
404                 WARN_ON(1);
405                 return;
406         }
407
408         /* It's safe because the task is inactive. */
409         raw_spin_lock_irqsave(&p->pi_lock, flags);
410         do_set_cpus_allowed(p, mask);
411         p->flags |= PF_NO_SETAFFINITY;
412         raw_spin_unlock_irqrestore(&p->pi_lock, flags);
413 }
414
415 static void __kthread_bind(struct task_struct *p, unsigned int cpu, long state)
416 {
417         __kthread_bind_mask(p, cpumask_of(cpu), state);
418 }
419
420 void kthread_bind_mask(struct task_struct *p, const struct cpumask *mask)
421 {
422         __kthread_bind_mask(p, mask, TASK_UNINTERRUPTIBLE);
423 }
424
425 /**
426  * kthread_bind - bind a just-created kthread to a cpu.
427  * @p: thread created by kthread_create().
428  * @cpu: cpu (might not be online, must be possible) for @k to run on.
429  *
430  * Description: This function is equivalent to set_cpus_allowed(),
431  * except that @cpu doesn't need to be online, and the thread must be
432  * stopped (i.e., just returned from kthread_create()).
433  */
434 void kthread_bind(struct task_struct *p, unsigned int cpu)
435 {
436         __kthread_bind(p, cpu, TASK_UNINTERRUPTIBLE);
437 }
438 EXPORT_SYMBOL(kthread_bind);
439
440 /**
441  * kthread_create_on_cpu - Create a cpu bound kthread
442  * @threadfn: the function to run until signal_pending(current).
443  * @data: data ptr for @threadfn.
444  * @cpu: The cpu on which the thread should be bound,
445  * @namefmt: printf-style name for the thread. Format is restricted
446  *           to "name.*%u". Code fills in cpu number.
447  *
448  * Description: This helper function creates and names a kernel thread
449  * The thread will be woken and put into park mode.
450  */
451 struct task_struct *kthread_create_on_cpu(int (*threadfn)(void *data),
452                                           void *data, unsigned int cpu,
453                                           const char *namefmt)
454 {
455         struct task_struct *p;
456
457         p = kthread_create_on_node(threadfn, data, cpu_to_node(cpu), namefmt,
458                                    cpu);
459         if (IS_ERR(p))
460                 return p;
461         kthread_bind(p, cpu);
462         /* CPU hotplug need to bind once again when unparking the thread. */
463         to_kthread(p)->cpu = cpu;
464         return p;
465 }
466
467 void kthread_set_per_cpu(struct task_struct *k, int cpu)
468 {
469         struct kthread *kthread = to_kthread(k);
470         if (!kthread)
471                 return;
472
473         WARN_ON_ONCE(!(k->flags & PF_NO_SETAFFINITY));
474
475         if (cpu < 0) {
476                 clear_bit(KTHREAD_IS_PER_CPU, &kthread->flags);
477                 return;
478         }
479
480         kthread->cpu = cpu;
481         set_bit(KTHREAD_IS_PER_CPU, &kthread->flags);
482 }
483
484 bool kthread_is_per_cpu(struct task_struct *k)
485 {
486         struct kthread *kthread = to_kthread(k);
487         if (!kthread)
488                 return false;
489
490         return test_bit(KTHREAD_IS_PER_CPU, &kthread->flags);
491 }
492
493 /**
494  * kthread_unpark - unpark a thread created by kthread_create().
495  * @k:          thread created by kthread_create().
496  *
497  * Sets kthread_should_park() for @k to return false, wakes it, and
498  * waits for it to return. If the thread is marked percpu then its
499  * bound to the cpu again.
500  */
501 void kthread_unpark(struct task_struct *k)
502 {
503         struct kthread *kthread = to_kthread(k);
504
505         /*
506          * Newly created kthread was parked when the CPU was offline.
507          * The binding was lost and we need to set it again.
508          */
509         if (test_bit(KTHREAD_IS_PER_CPU, &kthread->flags))
510                 __kthread_bind(k, kthread->cpu, TASK_PARKED);
511
512         clear_bit(KTHREAD_SHOULD_PARK, &kthread->flags);
513         /*
514          * __kthread_parkme() will either see !SHOULD_PARK or get the wakeup.
515          */
516         wake_up_state(k, TASK_PARKED);
517 }
518 EXPORT_SYMBOL_GPL(kthread_unpark);
519
520 /**
521  * kthread_park - park a thread created by kthread_create().
522  * @k: thread created by kthread_create().
523  *
524  * Sets kthread_should_park() for @k to return true, wakes it, and
525  * waits for it to return. This can also be called after kthread_create()
526  * instead of calling wake_up_process(): the thread will park without
527  * calling threadfn().
528  *
529  * Returns 0 if the thread is parked, -ENOSYS if the thread exited.
530  * If called by the kthread itself just the park bit is set.
531  */
532 int kthread_park(struct task_struct *k)
533 {
534         struct kthread *kthread = to_kthread(k);
535
536         if (WARN_ON(k->flags & PF_EXITING))
537                 return -ENOSYS;
538
539         if (WARN_ON_ONCE(test_bit(KTHREAD_SHOULD_PARK, &kthread->flags)))
540                 return -EBUSY;
541
542         set_bit(KTHREAD_SHOULD_PARK, &kthread->flags);
543         if (k != current) {
544                 wake_up_process(k);
545                 /*
546                  * Wait for __kthread_parkme() to complete(), this means we
547                  * _will_ have TASK_PARKED and are about to call schedule().
548                  */
549                 wait_for_completion(&kthread->parked);
550                 /*
551                  * Now wait for that schedule() to complete and the task to
552                  * get scheduled out.
553                  */
554                 WARN_ON_ONCE(!wait_task_inactive(k, TASK_PARKED));
555         }
556
557         return 0;
558 }
559 EXPORT_SYMBOL_GPL(kthread_park);
560
561 /**
562  * kthread_stop - stop a thread created by kthread_create().
563  * @k: thread created by kthread_create().
564  *
565  * Sets kthread_should_stop() for @k to return true, wakes it, and
566  * waits for it to exit. This can also be called after kthread_create()
567  * instead of calling wake_up_process(): the thread will exit without
568  * calling threadfn().
569  *
570  * If threadfn() may call do_exit() itself, the caller must ensure
571  * task_struct can't go away.
572  *
573  * Returns the result of threadfn(), or %-EINTR if wake_up_process()
574  * was never called.
575  */
576 int kthread_stop(struct task_struct *k)
577 {
578         struct kthread *kthread;
579         int ret;
580
581         trace_sched_kthread_stop(k);
582
583         get_task_struct(k);
584         kthread = to_kthread(k);
585         set_bit(KTHREAD_SHOULD_STOP, &kthread->flags);
586         kthread_unpark(k);
587         wake_up_process(k);
588         wait_for_completion(&kthread->exited);
589         ret = k->exit_code;
590         put_task_struct(k);
591
592         trace_sched_kthread_stop_ret(ret);
593         return ret;
594 }
595 EXPORT_SYMBOL(kthread_stop);
596
597 int kthreadd(void *unused)
598 {
599         struct task_struct *tsk = current;
600
601         /* Setup a clean context for our children to inherit. */
602         set_task_comm(tsk, "kthreadd");
603         ignore_signals(tsk);
604         set_cpus_allowed_ptr(tsk, cpu_all_mask);
605         set_mems_allowed(node_states[N_MEMORY]);
606
607         current->flags |= PF_NOFREEZE;
608         cgroup_init_kthreadd();
609
610         for (;;) {
611                 set_current_state(TASK_INTERRUPTIBLE);
612                 if (list_empty(&kthread_create_list))
613                         schedule();
614                 __set_current_state(TASK_RUNNING);
615
616                 spin_lock(&kthread_create_lock);
617                 while (!list_empty(&kthread_create_list)) {
618                         struct kthread_create_info *create;
619
620                         create = list_entry(kthread_create_list.next,
621                                             struct kthread_create_info, list);
622                         list_del_init(&create->list);
623                         spin_unlock(&kthread_create_lock);
624
625                         create_kthread(create);
626
627                         spin_lock(&kthread_create_lock);
628                 }
629                 spin_unlock(&kthread_create_lock);
630         }
631
632         return 0;
633 }
634
635 void __kthread_init_worker(struct kthread_worker *worker,
636                                 const char *name,
637                                 struct lock_class_key *key)
638 {
639         memset(worker, 0, sizeof(struct kthread_worker));
640         spin_lock_init(&worker->lock);
641         lockdep_set_class_and_name(&worker->lock, key, name);
642         INIT_LIST_HEAD(&worker->work_list);
643         INIT_LIST_HEAD(&worker->delayed_work_list);
644 }
645 EXPORT_SYMBOL_GPL(__kthread_init_worker);
646
647 /**
648  * kthread_worker_fn - kthread function to process kthread_worker
649  * @worker_ptr: pointer to initialized kthread_worker
650  *
651  * This function implements the main cycle of kthread worker. It processes
652  * work_list until it is stopped with kthread_stop(). It sleeps when the queue
653  * is empty.
654  *
655  * The works are not allowed to keep any locks, disable preemption or interrupts
656  * when they finish. There is defined a safe point for freezing when one work
657  * finishes and before a new one is started.
658  *
659  * Also the works must not be handled by more than one worker at the same time,
660  * see also kthread_queue_work().
661  */
662 int kthread_worker_fn(void *worker_ptr)
663 {
664         struct kthread_worker *worker = worker_ptr;
665         struct kthread_work *work;
666
667         /*
668          * FIXME: Update the check and remove the assignment when all kthread
669          * worker users are created using kthread_create_worker*() functions.
670          */
671         WARN_ON(worker->task && worker->task != current);
672         worker->task = current;
673
674         if (worker->flags & KTW_FREEZABLE)
675                 set_freezable();
676
677 repeat:
678         set_current_state(TASK_INTERRUPTIBLE);  /* mb paired w/ kthread_stop */
679
680         if (kthread_should_stop()) {
681                 __set_current_state(TASK_RUNNING);
682                 spin_lock_irq(&worker->lock);
683                 worker->task = NULL;
684                 spin_unlock_irq(&worker->lock);
685                 return 0;
686         }
687
688         work = NULL;
689         spin_lock_irq(&worker->lock);
690         if (!list_empty(&worker->work_list)) {
691                 work = list_first_entry(&worker->work_list,
692                                         struct kthread_work, node);
693                 list_del_init(&work->node);
694         }
695         worker->current_work = work;
696         spin_unlock_irq(&worker->lock);
697
698         if (work) {
699                 __set_current_state(TASK_RUNNING);
700                 work->func(work);
701         } else if (!freezing(current))
702                 schedule();
703
704         try_to_freeze();
705         cond_resched();
706         goto repeat;
707 }
708 EXPORT_SYMBOL_GPL(kthread_worker_fn);
709
710 static __printf(3, 0) struct kthread_worker *
711 __kthread_create_worker(int cpu, unsigned int flags,
712                         const char namefmt[], va_list args)
713 {
714         struct kthread_worker *worker;
715         struct task_struct *task;
716         int node = -1;
717
718         worker = kzalloc(sizeof(*worker), GFP_KERNEL);
719         if (!worker)
720                 return ERR_PTR(-ENOMEM);
721
722         kthread_init_worker(worker);
723
724         if (cpu >= 0)
725                 node = cpu_to_node(cpu);
726
727         task = __kthread_create_on_node(kthread_worker_fn, worker,
728                                                 node, namefmt, args);
729         if (IS_ERR(task))
730                 goto fail_task;
731
732         if (cpu >= 0)
733                 kthread_bind(task, cpu);
734
735         worker->flags = flags;
736         worker->task = task;
737         wake_up_process(task);
738         return worker;
739
740 fail_task:
741         kfree(worker);
742         return ERR_CAST(task);
743 }
744
745 /**
746  * kthread_create_worker - create a kthread worker
747  * @flags: flags modifying the default behavior of the worker
748  * @namefmt: printf-style name for the kthread worker (task).
749  *
750  * Returns a pointer to the allocated worker on success, ERR_PTR(-ENOMEM)
751  * when the needed structures could not get allocated, and ERR_PTR(-EINTR)
752  * when the worker was SIGKILLed.
753  */
754 struct kthread_worker *
755 kthread_create_worker(unsigned int flags, const char namefmt[], ...)
756 {
757         struct kthread_worker *worker;
758         va_list args;
759
760         va_start(args, namefmt);
761         worker = __kthread_create_worker(-1, flags, namefmt, args);
762         va_end(args);
763
764         return worker;
765 }
766 EXPORT_SYMBOL(kthread_create_worker);
767
768 /**
769  * kthread_create_worker_on_cpu - create a kthread worker and bind it
770  *      it to a given CPU and the associated NUMA node.
771  * @cpu: CPU number
772  * @flags: flags modifying the default behavior of the worker
773  * @namefmt: printf-style name for the kthread worker (task).
774  *
775  * Use a valid CPU number if you want to bind the kthread worker
776  * to the given CPU and the associated NUMA node.
777  *
778  * A good practice is to add the cpu number also into the worker name.
779  * For example, use kthread_create_worker_on_cpu(cpu, "helper/%d", cpu).
780  *
781  * Returns a pointer to the allocated worker on success, ERR_PTR(-ENOMEM)
782  * when the needed structures could not get allocated, and ERR_PTR(-EINTR)
783  * when the worker was SIGKILLed.
784  */
785 struct kthread_worker *
786 kthread_create_worker_on_cpu(int cpu, unsigned int flags,
787                              const char namefmt[], ...)
788 {
789         struct kthread_worker *worker;
790         va_list args;
791
792         va_start(args, namefmt);
793         worker = __kthread_create_worker(cpu, flags, namefmt, args);
794         va_end(args);
795
796         return worker;
797 }
798 EXPORT_SYMBOL(kthread_create_worker_on_cpu);
799
800 /*
801  * Returns true when the work could not be queued at the moment.
802  * It happens when it is already pending in a worker list
803  * or when it is being cancelled.
804  */
805 static inline bool queuing_blocked(struct kthread_worker *worker,
806                                    struct kthread_work *work)
807 {
808         lockdep_assert_held(&worker->lock);
809
810         return !list_empty(&work->node) || work->canceling;
811 }
812
813 static void kthread_insert_work_sanity_check(struct kthread_worker *worker,
814                                              struct kthread_work *work)
815 {
816         lockdep_assert_held(&worker->lock);
817         WARN_ON_ONCE(!list_empty(&work->node));
818         /* Do not use a work with >1 worker, see kthread_queue_work() */
819         WARN_ON_ONCE(work->worker && work->worker != worker);
820 }
821
822 /* insert @work before @pos in @worker */
823 static void kthread_insert_work(struct kthread_worker *worker,
824                                 struct kthread_work *work,
825                                 struct list_head *pos)
826 {
827         kthread_insert_work_sanity_check(worker, work);
828
829         list_add_tail(&work->node, pos);
830         work->worker = worker;
831         if (!worker->current_work && likely(worker->task))
832                 wake_up_process(worker->task);
833 }
834
835 /**
836  * kthread_queue_work - queue a kthread_work
837  * @worker: target kthread_worker
838  * @work: kthread_work to queue
839  *
840  * Queue @work to work processor @task for async execution.  @task
841  * must have been created with kthread_worker_create().  Returns %true
842  * if @work was successfully queued, %false if it was already pending.
843  *
844  * Reinitialize the work if it needs to be used by another worker.
845  * For example, when the worker was stopped and started again.
846  */
847 bool kthread_queue_work(struct kthread_worker *worker,
848                         struct kthread_work *work)
849 {
850         bool ret = false;
851         unsigned long flags;
852
853         spin_lock_irqsave(&worker->lock, flags);
854         if (!queuing_blocked(worker, work)) {
855                 kthread_insert_work(worker, work, &worker->work_list);
856                 ret = true;
857         }
858         spin_unlock_irqrestore(&worker->lock, flags);
859         return ret;
860 }
861 EXPORT_SYMBOL_GPL(kthread_queue_work);
862
863 /**
864  * kthread_delayed_work_timer_fn - callback that queues the associated kthread
865  *      delayed work when the timer expires.
866  * @t: pointer to the expired timer
867  *
868  * The format of the function is defined by struct timer_list.
869  * It should have been called from irqsafe timer with irq already off.
870  */
871 void kthread_delayed_work_timer_fn(struct timer_list *t)
872 {
873         struct kthread_delayed_work *dwork = from_timer(dwork, t, timer);
874         struct kthread_work *work = &dwork->work;
875         struct kthread_worker *worker = work->worker;
876
877         /*
878          * This might happen when a pending work is reinitialized.
879          * It means that it is used a wrong way.
880          */
881         if (WARN_ON_ONCE(!worker))
882                 return;
883
884         spin_lock(&worker->lock);
885         /* Work must not be used with >1 worker, see kthread_queue_work(). */
886         WARN_ON_ONCE(work->worker != worker);
887
888         /* Move the work from worker->delayed_work_list. */
889         WARN_ON_ONCE(list_empty(&work->node));
890         list_del_init(&work->node);
891         if (!work->canceling)
892                 kthread_insert_work(worker, work, &worker->work_list);
893
894         spin_unlock(&worker->lock);
895 }
896 EXPORT_SYMBOL(kthread_delayed_work_timer_fn);
897
898 void __kthread_queue_delayed_work(struct kthread_worker *worker,
899                                   struct kthread_delayed_work *dwork,
900                                   unsigned long delay)
901 {
902         struct timer_list *timer = &dwork->timer;
903         struct kthread_work *work = &dwork->work;
904
905         WARN_ON_ONCE(timer->function != kthread_delayed_work_timer_fn);
906
907         /*
908          * If @delay is 0, queue @dwork->work immediately.  This is for
909          * both optimization and correctness.  The earliest @timer can
910          * expire is on the closest next tick and delayed_work users depend
911          * on that there's no such delay when @delay is 0.
912          */
913         if (!delay) {
914                 kthread_insert_work(worker, work, &worker->work_list);
915                 return;
916         }
917
918         /* Be paranoid and try to detect possible races already now. */
919         kthread_insert_work_sanity_check(worker, work);
920
921         list_add(&work->node, &worker->delayed_work_list);
922         work->worker = worker;
923         timer->expires = jiffies + delay;
924         add_timer(timer);
925 }
926
927 /**
928  * kthread_queue_delayed_work - queue the associated kthread work
929  *      after a delay.
930  * @worker: target kthread_worker
931  * @dwork: kthread_delayed_work to queue
932  * @delay: number of jiffies to wait before queuing
933  *
934  * If the work has not been pending it starts a timer that will queue
935  * the work after the given @delay. If @delay is zero, it queues the
936  * work immediately.
937  *
938  * Return: %false if the @work has already been pending. It means that
939  * either the timer was running or the work was queued. It returns %true
940  * otherwise.
941  */
942 bool kthread_queue_delayed_work(struct kthread_worker *worker,
943                                 struct kthread_delayed_work *dwork,
944                                 unsigned long delay)
945 {
946         struct kthread_work *work = &dwork->work;
947         unsigned long flags;
948         bool ret = false;
949
950         spin_lock_irqsave(&worker->lock, flags);
951
952         if (!queuing_blocked(worker, work)) {
953                 __kthread_queue_delayed_work(worker, dwork, delay);
954                 ret = true;
955         }
956
957         spin_unlock_irqrestore(&worker->lock, flags);
958         return ret;
959 }
960 EXPORT_SYMBOL_GPL(kthread_queue_delayed_work);
961
962 struct kthread_flush_work {
963         struct kthread_work     work;
964         struct completion       done;
965 };
966
967 static void kthread_flush_work_fn(struct kthread_work *work)
968 {
969         struct kthread_flush_work *fwork =
970                 container_of(work, struct kthread_flush_work, work);
971         complete(&fwork->done);
972 }
973
974 /**
975  * kthread_flush_work - flush a kthread_work
976  * @work: work to flush
977  *
978  * If @work is queued or executing, wait for it to finish execution.
979  */
980 void kthread_flush_work(struct kthread_work *work)
981 {
982         struct kthread_flush_work fwork = {
983                 KTHREAD_WORK_INIT(fwork.work, kthread_flush_work_fn),
984                 COMPLETION_INITIALIZER_ONSTACK(fwork.done),
985         };
986         struct kthread_worker *worker;
987         bool noop = false;
988
989         worker = work->worker;
990         if (!worker)
991                 return;
992
993         spin_lock_irq(&worker->lock);
994         /* Work must not be used with >1 worker, see kthread_queue_work(). */
995         WARN_ON_ONCE(work->worker != worker);
996
997         if (!list_empty(&work->node))
998                 kthread_insert_work(worker, &fwork.work, work->node.next);
999         else if (worker->current_work == work)
1000                 kthread_insert_work(worker, &fwork.work,
1001                                     worker->work_list.next);
1002         else
1003                 noop = true;
1004
1005         spin_unlock_irq(&worker->lock);
1006
1007         if (!noop)
1008                 wait_for_completion(&fwork.done);
1009 }
1010 EXPORT_SYMBOL_GPL(kthread_flush_work);
1011
1012 /*
1013  * Make sure that the timer is neither set nor running and could
1014  * not manipulate the work list_head any longer.
1015  *
1016  * The function is called under worker->lock. The lock is temporary
1017  * released but the timer can't be set again in the meantime.
1018  */
1019 static void kthread_cancel_delayed_work_timer(struct kthread_work *work,
1020                                               unsigned long *flags)
1021 {
1022         struct kthread_delayed_work *dwork =
1023                 container_of(work, struct kthread_delayed_work, work);
1024         struct kthread_worker *worker = work->worker;
1025
1026         /*
1027          * del_timer_sync() must be called to make sure that the timer
1028          * callback is not running. The lock must be temporary released
1029          * to avoid a deadlock with the callback. In the meantime,
1030          * any queuing is blocked by setting the canceling counter.
1031          */
1032         work->canceling++;
1033         spin_unlock_irqrestore(&worker->lock, *flags);
1034         del_timer_sync(&dwork->timer);
1035         spin_lock_irqsave(&worker->lock, *flags);
1036         work->canceling--;
1037 }
1038
1039 /*
1040  * This function removes the work from the worker queue.
1041  *
1042  * It is called under worker->lock. The caller must make sure that
1043  * the timer used by delayed work is not running, e.g. by calling
1044  * kthread_cancel_delayed_work_timer().
1045  *
1046  * The work might still be in use when this function finishes. See the
1047  * current_work proceed by the worker.
1048  *
1049  * Return: %true if @work was pending and successfully canceled,
1050  *      %false if @work was not pending
1051  */
1052 static bool __kthread_cancel_work(struct kthread_work *work)
1053 {
1054         /*
1055          * Try to remove the work from a worker list. It might either
1056          * be from worker->work_list or from worker->delayed_work_list.
1057          */
1058         if (!list_empty(&work->node)) {
1059                 list_del_init(&work->node);
1060                 return true;
1061         }
1062
1063         return false;
1064 }
1065
1066 /**
1067  * kthread_mod_delayed_work - modify delay of or queue a kthread delayed work
1068  * @worker: kthread worker to use
1069  * @dwork: kthread delayed work to queue
1070  * @delay: number of jiffies to wait before queuing
1071  *
1072  * If @dwork is idle, equivalent to kthread_queue_delayed_work(). Otherwise,
1073  * modify @dwork's timer so that it expires after @delay. If @delay is zero,
1074  * @work is guaranteed to be queued immediately.
1075  *
1076  * Return: %true if @dwork was pending and its timer was modified,
1077  * %false otherwise.
1078  *
1079  * A special case is when the work is being canceled in parallel.
1080  * It might be caused either by the real kthread_cancel_delayed_work_sync()
1081  * or yet another kthread_mod_delayed_work() call. We let the other command
1082  * win and return %false here. The caller is supposed to synchronize these
1083  * operations a reasonable way.
1084  *
1085  * This function is safe to call from any context including IRQ handler.
1086  * See __kthread_cancel_work() and kthread_delayed_work_timer_fn()
1087  * for details.
1088  */
1089 bool kthread_mod_delayed_work(struct kthread_worker *worker,
1090                               struct kthread_delayed_work *dwork,
1091                               unsigned long delay)
1092 {
1093         struct kthread_work *work = &dwork->work;
1094         unsigned long flags;
1095         int ret = false;
1096
1097         spin_lock_irqsave(&worker->lock, flags);
1098
1099         /* Do not bother with canceling when never queued. */
1100         if (!work->worker)
1101                 goto fast_queue;
1102
1103         /* Work must not be used with >1 worker, see kthread_queue_work() */
1104         WARN_ON_ONCE(work->worker != worker);
1105
1106         /*
1107          * Temporary cancel the work but do not fight with another command
1108          * that is canceling the work as well.
1109          *
1110          * It is a bit tricky because of possible races with another
1111          * mod_delayed_work() and cancel_delayed_work() callers.
1112          *
1113          * The timer must be canceled first because worker->lock is released
1114          * when doing so. But the work can be removed from the queue (list)
1115          * only when it can be queued again so that the return value can
1116          * be used for reference counting.
1117          */
1118         kthread_cancel_delayed_work_timer(work, &flags);
1119         if (work->canceling)
1120                 goto out;
1121         ret = __kthread_cancel_work(work);
1122
1123 fast_queue:
1124         __kthread_queue_delayed_work(worker, dwork, delay);
1125 out:
1126         spin_unlock_irqrestore(&worker->lock, flags);
1127         return ret;
1128 }
1129 EXPORT_SYMBOL_GPL(kthread_mod_delayed_work);
1130
1131 static bool __kthread_cancel_work_sync(struct kthread_work *work, bool is_dwork)
1132 {
1133         struct kthread_worker *worker = work->worker;
1134         unsigned long flags;
1135         int ret = false;
1136
1137         if (!worker)
1138                 goto out;
1139
1140         spin_lock_irqsave(&worker->lock, flags);
1141         /* Work must not be used with >1 worker, see kthread_queue_work(). */
1142         WARN_ON_ONCE(work->worker != worker);
1143
1144         if (is_dwork)
1145                 kthread_cancel_delayed_work_timer(work, &flags);
1146
1147         ret = __kthread_cancel_work(work);
1148
1149         if (worker->current_work != work)
1150                 goto out_fast;
1151
1152         /*
1153          * The work is in progress and we need to wait with the lock released.
1154          * In the meantime, block any queuing by setting the canceling counter.
1155          */
1156         work->canceling++;
1157         spin_unlock_irqrestore(&worker->lock, flags);
1158         kthread_flush_work(work);
1159         spin_lock_irqsave(&worker->lock, flags);
1160         work->canceling--;
1161
1162 out_fast:
1163         spin_unlock_irqrestore(&worker->lock, flags);
1164 out:
1165         return ret;
1166 }
1167
1168 /**
1169  * kthread_cancel_work_sync - cancel a kthread work and wait for it to finish
1170  * @work: the kthread work to cancel
1171  *
1172  * Cancel @work and wait for its execution to finish.  This function
1173  * can be used even if the work re-queues itself. On return from this
1174  * function, @work is guaranteed to be not pending or executing on any CPU.
1175  *
1176  * kthread_cancel_work_sync(&delayed_work->work) must not be used for
1177  * delayed_work's. Use kthread_cancel_delayed_work_sync() instead.
1178  *
1179  * The caller must ensure that the worker on which @work was last
1180  * queued can't be destroyed before this function returns.
1181  *
1182  * Return: %true if @work was pending, %false otherwise.
1183  */
1184 bool kthread_cancel_work_sync(struct kthread_work *work)
1185 {
1186         return __kthread_cancel_work_sync(work, false);
1187 }
1188 EXPORT_SYMBOL_GPL(kthread_cancel_work_sync);
1189
1190 /**
1191  * kthread_cancel_delayed_work_sync - cancel a kthread delayed work and
1192  *      wait for it to finish.
1193  * @dwork: the kthread delayed work to cancel
1194  *
1195  * This is kthread_cancel_work_sync() for delayed works.
1196  *
1197  * Return: %true if @dwork was pending, %false otherwise.
1198  */
1199 bool kthread_cancel_delayed_work_sync(struct kthread_delayed_work *dwork)
1200 {
1201         return __kthread_cancel_work_sync(&dwork->work, true);
1202 }
1203 EXPORT_SYMBOL_GPL(kthread_cancel_delayed_work_sync);
1204
1205 /**
1206  * kthread_flush_worker - flush all current works on a kthread_worker
1207  * @worker: worker to flush
1208  *
1209  * Wait until all currently executing or pending works on @worker are
1210  * finished.
1211  */
1212 void kthread_flush_worker(struct kthread_worker *worker)
1213 {
1214         struct kthread_flush_work fwork = {
1215                 KTHREAD_WORK_INIT(fwork.work, kthread_flush_work_fn),
1216                 COMPLETION_INITIALIZER_ONSTACK(fwork.done),
1217         };
1218
1219         kthread_queue_work(worker, &fwork.work);
1220         wait_for_completion(&fwork.done);
1221 }
1222 EXPORT_SYMBOL_GPL(kthread_flush_worker);
1223
1224 /**
1225  * kthread_destroy_worker - destroy a kthread worker
1226  * @worker: worker to be destroyed
1227  *
1228  * Flush and destroy @worker.  The simple flush is enough because the kthread
1229  * worker API is used only in trivial scenarios.  There are no multi-step state
1230  * machines needed.
1231  */
1232 void kthread_destroy_worker(struct kthread_worker *worker)
1233 {
1234         struct task_struct *task;
1235
1236         task = worker->task;
1237         if (WARN_ON(!task))
1238                 return;
1239
1240         kthread_flush_worker(worker);
1241         kthread_stop(task);
1242         WARN_ON(!list_empty(&worker->work_list));
1243         kfree(worker);
1244 }
1245 EXPORT_SYMBOL(kthread_destroy_worker);
1246
1247 #ifdef CONFIG_BLK_CGROUP
1248 /**
1249  * kthread_associate_blkcg - associate blkcg to current kthread
1250  * @css: the cgroup info
1251  *
1252  * Current thread must be a kthread. The thread is running jobs on behalf of
1253  * other threads. In some cases, we expect the jobs attach cgroup info of
1254  * original threads instead of that of current thread. This function stores
1255  * original thread's cgroup info in current kthread context for later
1256  * retrieval.
1257  */
1258 void kthread_associate_blkcg(struct cgroup_subsys_state *css)
1259 {
1260         struct kthread *kthread;
1261
1262         if (!(current->flags & PF_KTHREAD))
1263                 return;
1264         kthread = to_kthread(current);
1265         if (!kthread)
1266                 return;
1267
1268         if (kthread->blkcg_css) {
1269                 css_put(kthread->blkcg_css);
1270                 kthread->blkcg_css = NULL;
1271         }
1272         if (css) {
1273                 css_get(css);
1274                 kthread->blkcg_css = css;
1275         }
1276 }
1277 EXPORT_SYMBOL(kthread_associate_blkcg);
1278
1279 /**
1280  * kthread_blkcg - get associated blkcg css of current kthread
1281  *
1282  * Current thread must be a kthread.
1283  */
1284 struct cgroup_subsys_state *kthread_blkcg(void)
1285 {
1286         struct kthread *kthread;
1287
1288         if (current->flags & PF_KTHREAD) {
1289                 kthread = to_kthread(current);
1290                 if (kthread)
1291                         return kthread->blkcg_css;
1292         }
1293         return NULL;
1294 }
1295 EXPORT_SYMBOL(kthread_blkcg);
1296 #endif