kernel/kthread.c

   1 /* Kernel thread helper functions.
   2  *   Copyright (C) 2004 IBM Corporation, Rusty Russell.
   3  *
   4  * Creation is done via keventd, 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/unistd.h>
  13 #include <linux/file.h>
  14 #include <linux/module.h>
  15 #include <asm/semaphore.h>
  16
  17 struct kthread_create_info
  18 {
  19         /* Information passed to kthread() from keventd. */
  20         int (*threadfn)(void *data);
  21         void *data;
  22         struct completion started;
  23
  24         /* Result passed back to kthread_create() from keventd. */
  25         struct task_struct *result;
  26         struct completion done;
  27 };
  28
  29 struct kthread_stop_info
  30 {
  31         struct task_struct *k;
  32         int err;
  33         struct completion done;
  34 };
  35
  36 /* Thread stopping is done by setthing this var: lock serializes
  37  * multiple kthread_stop calls. */
  38 static DECLARE_MUTEX(kthread_stop_lock);
  39 static struct kthread_stop_info kthread_stop_info;
  40
  41 int kthread_should_stop(void)
  42 {
  43         return (kthread_stop_info.k == current);
  44 }
  45 EXPORT_SYMBOL(kthread_should_stop);
  46
  47 static void kthread_exit_files(void)
  48 {
  49         struct fs_struct *fs;
  50         struct task_struct *tsk = current;
  51
  52         exit_fs(tsk);           /* current->fs->count--; */
  53         fs = init_task.fs;
  54         tsk->fs = fs;
  55         atomic_inc(&fs->count);
  56         exit_files(tsk);
  57         current->files = init_task.files;
  58         atomic_inc(&tsk->files->count);
  59 }
  60
  61 static int kthread(void *_create)
  62 {
  63         struct kthread_create_info *create = _create;
  64         int (*threadfn)(void *data);
  65         void *data;
  66         sigset_t blocked;
  67         int ret = -EINTR;
  68
  69         kthread_exit_files();
  70
  71         /* Copy data: it's on keventd's stack */
  72         threadfn = create->threadfn;
  73         data = create->data;
  74
  75         /* Block and flush all signals (in case we're not from keventd). */
  76         sigfillset(&blocked);
  77         sigprocmask(SIG_BLOCK, &blocked, NULL);
  78         flush_signals(current);
  79
  80         /* By default we can run anywhere, unlike keventd. */
  81         set_cpus_allowed(current, CPU_MASK_ALL);
  82
  83         /* OK, tell user we're spawned, wait for stop or wakeup */
  84         __set_current_state(TASK_INTERRUPTIBLE);
  85         complete(&create->started);
  86         schedule();
  87
  88         if (!kthread_should_stop())
  89                 ret = threadfn(data);
  90
  91         /* It might have exited on its own, w/o kthread_stop.  Check. */
  92         if (kthread_should_stop()) {
  93                 kthread_stop_info.err = ret;
  94                 complete(&kthread_stop_info.done);
  95         }
  96         return 0;
  97 }
  98
  99 /* We are keventd: create a thread. */
 100 static void keventd_create_kthread(void *_create)
 101 {
 102         struct kthread_create_info *create = _create;
 103         int pid;
 104
 105         /* We want our own signal handler (we take no signals by default). */
 106         pid = kernel_thread(kthread, create, CLONE_FS | CLONE_FILES | SIGCHLD);
 107         if (pid < 0) {
 108                 create->result = ERR_PTR(pid);
 109         } else {
 110                 wait_for_completion(&create->started);
 111                 create->result = find_task_by_pid(pid);
 112         }
 113         complete(&create->done);
 114 }
 115
 116 struct task_struct *kthread_create(int (*threadfn)(void *data),
 117                                    void *data,
 118                                    const char namefmt[],
 119                                    ...)
 120 {
 121         struct kthread_create_info create;
 122         DECLARE_WORK(work, keventd_create_kthread, &create);
 123
 124         create.threadfn = threadfn;
 125         create.data = data;
 126         init_completion(&create.started);
 127         init_completion(&create.done);
 128
 129         /* If we're being called to start the first workqueue, we
 130          * can't use keventd. */
 131         if (!keventd_up())
 132                 work.func(work.data);
 133         else {
 134                 schedule_work(&work);
 135                 wait_for_completion(&create.done);
 136         }
 137         if (!IS_ERR(create.result)) {
 138                 va_list args;
 139                 va_start(args, namefmt);
 140                 vsnprintf(create.result->comm, sizeof(create.result->comm),
 141                           namefmt, args);
 142                 va_end(args);
 143         }
 144
 145         return create.result;
 146 }
 147 EXPORT_SYMBOL(kthread_create);
 148
 149 void kthread_bind(struct task_struct *k, unsigned int cpu)
 150 {
 151         BUG_ON(k->state != TASK_INTERRUPTIBLE);
 152         /* Must have done schedule() in kthread() before we set_task_cpu */
 153         wait_task_inactive(k);
 154         set_task_cpu(k, cpu);
 155         k->cpus_allowed = cpumask_of_cpu(cpu);
 156 }
 157 EXPORT_SYMBOL(kthread_bind);
 158
 159 int kthread_stop(struct task_struct *k)
 160 {
 161         int ret;
 162
 163         down(&kthread_stop_lock);
 164
 165         /* It could exit after stop_info.k set, but before wake_up_process. */
 166         get_task_struct(k);
 167
 168         /* Must init completion *before* thread sees kthread_stop_info.k */
 169         init_completion(&kthread_stop_info.done);
 170         wmb();
 171
 172         /* Now set kthread_should_stop() to true, and wake it up. */
 173         kthread_stop_info.k = k;
 174         wake_up_process(k);
 175         put_task_struct(k);
 176
 177         /* Once it dies, reset stop ptr, gather result and we're done. */
 178         wait_for_completion(&kthread_stop_info.done);
 179         kthread_stop_info.k = NULL;
 180         ret = kthread_stop_info.err;
 181         up(&kthread_stop_lock);
 182
 183         return ret;
 184 }
 185 EXPORT_SYMBOL(kthread_stop);