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