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 read_lock(&tasklist_lock); 119 create->result = find_task_by_pid(pid); 120 read_unlock(&tasklist_lock); 121 } 122 complete(&create->done); 123 } 124 125 struct task_struct *kthread_create(int (*threadfn)(void *data), 126 void *data, 127 const char namefmt[], 128 ...) 129 { 130 struct kthread_create_info create; 131 DECLARE_WORK(work, keventd_create_kthread, &create); 132 133 create.threadfn = threadfn; 134 create.data = data; 135 init_completion(&create.started); 136 init_completion(&create.done); 137 138 /* 139 * The workqueue needs to start up first: 140 */ 141 if (!helper_wq) 142 work.func(work.data); 143 else { 144 queue_work(helper_wq, &work); 145 wait_for_completion(&create.done); 146 } 147 if (!IS_ERR(create.result)) { 148 va_list args; 149 va_start(args, namefmt); 150 vsnprintf(create.result->comm, sizeof(create.result->comm), 151 namefmt, args); 152 va_end(args); 153 } 154 155 return create.result; 156 } 157 EXPORT_SYMBOL(kthread_create); 158 159 void kthread_bind(struct task_struct *k, unsigned int cpu) 160 { 161 BUG_ON(k->state != TASK_INTERRUPTIBLE); 162 /* Must have done schedule() in kthread() before we set_task_cpu */ 163 wait_task_inactive(k); 164 set_task_cpu(k, cpu); 165 k->cpus_allowed = cpumask_of_cpu(cpu); 166 } 167 EXPORT_SYMBOL(kthread_bind); 168 169 int kthread_stop(struct task_struct *k) 170 { 171 return kthread_stop_sem(k, NULL); 172 } 173 EXPORT_SYMBOL(kthread_stop); 174 175 int kthread_stop_sem(struct task_struct *k, struct semaphore *s) 176 { 177 int ret; 178 179 mutex_lock(&kthread_stop_lock); 180 181 /* It could exit after stop_info.k set, but before wake_up_process. */ 182 get_task_struct(k); 183 184 /* Must init completion *before* thread sees kthread_stop_info.k */ 185 init_completion(&kthread_stop_info.done); 186 smp_wmb(); 187 188 /* Now set kthread_should_stop() to true, and wake it up. */ 189 kthread_stop_info.k = k; 190 if (s) 191 up(s); 192 else 193 wake_up_process(k); 194 put_task_struct(k); 195 196 /* Once it dies, reset stop ptr, gather result and we're done. */ 197 wait_for_completion(&kthread_stop_info.done); 198 kthread_stop_info.k = NULL; 199 ret = kthread_stop_info.err; 200 mutex_unlock(&kthread_stop_lock); 201 202 return ret; 203 } 204 EXPORT_SYMBOL(kthread_stop_sem); 205 206 static __init int helper_init(void) 207 { 208 helper_wq = create_singlethread_workqueue("kthread"); 209 BUG_ON(!helper_wq); 210 211 return 0; 212 } 213 core_initcall(helper_init); 214 215