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/unistd.h> 13 #include <linux/file.h> 14 #include <linux/module.h> 15 #include <linux/mutex.h> 16 17 #define KTHREAD_NICE_LEVEL (-5) 18 19 static DEFINE_SPINLOCK(kthread_create_lock); 20 static LIST_HEAD(kthread_create_list); 21 struct task_struct *kthreadd_task; 22 23 struct kthread_create_info 24 { 25 /* Information passed to kthread() from kthreadd. */ 26 int (*threadfn)(void *data); 27 void *data; 28 struct completion started; 29 30 /* Result passed back to kthread_create() from kthreadd. */ 31 struct task_struct *result; 32 struct completion done; 33 34 struct list_head list; 35 }; 36 37 struct kthread_stop_info 38 { 39 struct task_struct *k; 40 int err; 41 struct completion done; 42 }; 43 44 /* Thread stopping is done by setthing this var: lock serializes 45 * multiple kthread_stop calls. */ 46 static DEFINE_MUTEX(kthread_stop_lock); 47 static struct kthread_stop_info kthread_stop_info; 48 49 /** 50 * kthread_should_stop - should this kthread return now? 51 * 52 * When someone calls kthread_stop() on your kthread, it will be woken 53 * and this will return true. You should then return, and your return 54 * value will be passed through to kthread_stop(). 55 */ 56 int kthread_should_stop(void) 57 { 58 return (kthread_stop_info.k == current); 59 } 60 EXPORT_SYMBOL(kthread_should_stop); 61 62 static int kthread(void *_create) 63 { 64 struct kthread_create_info *create = _create; 65 int (*threadfn)(void *data); 66 void *data; 67 int ret = -EINTR; 68 69 /* Copy data: it's on kthread's stack */ 70 threadfn = create->threadfn; 71 data = create->data; 72 73 /* OK, tell user we're spawned, wait for stop or wakeup */ 74 __set_current_state(TASK_UNINTERRUPTIBLE); 75 complete(&create->started); 76 schedule(); 77 78 if (!kthread_should_stop()) 79 ret = threadfn(data); 80 81 /* It might have exited on its own, w/o kthread_stop. Check. */ 82 if (kthread_should_stop()) { 83 kthread_stop_info.err = ret; 84 complete(&kthread_stop_info.done); 85 } 86 return 0; 87 } 88 89 static void create_kthread(struct kthread_create_info *create) 90 { 91 int pid; 92 93 /* We want our own signal handler (we take no signals by default). */ 94 pid = kernel_thread(kthread, create, CLONE_FS | CLONE_FILES | SIGCHLD); 95 if (pid < 0) { 96 create->result = ERR_PTR(pid); 97 } else { 98 struct sched_param param = { .sched_priority = 0 }; 99 wait_for_completion(&create->started); 100 read_lock(&tasklist_lock); 101 create->result = find_task_by_pid(pid); 102 read_unlock(&tasklist_lock); 103 /* 104 * root may have changed our (kthreadd's) priority or CPU mask. 105 * The kernel thread should not inherit these properties. 106 */ 107 sched_setscheduler(create->result, SCHED_NORMAL, ¶m); 108 set_user_nice(create->result, KTHREAD_NICE_LEVEL); 109 set_cpus_allowed(create->result, CPU_MASK_ALL); 110 } 111 complete(&create->done); 112 } 113 114 /** 115 * kthread_create - create a kthread. 116 * @threadfn: the function to run until signal_pending(current). 117 * @data: data ptr for @threadfn. 118 * @namefmt: printf-style name for the thread. 119 * 120 * Description: This helper function creates and names a kernel 121 * thread. The thread will be stopped: use wake_up_process() to start 122 * it. See also kthread_run(), kthread_create_on_cpu(). 123 * 124 * When woken, the thread will run @threadfn() with @data as its 125 * argument. @threadfn() can either call do_exit() directly if it is a 126 * standalone thread for which noone will call kthread_stop(), or 127 * return when 'kthread_should_stop()' is true (which means 128 * kthread_stop() has been called). The return value should be zero 129 * or a negative error number; it will be passed to kthread_stop(). 130 * 131 * Returns a task_struct or ERR_PTR(-ENOMEM). 132 */ 133 struct task_struct *kthread_create(int (*threadfn)(void *data), 134 void *data, 135 const char namefmt[], 136 ...) 137 { 138 struct kthread_create_info create; 139 140 create.threadfn = threadfn; 141 create.data = data; 142 init_completion(&create.started); 143 init_completion(&create.done); 144 145 spin_lock(&kthread_create_lock); 146 list_add_tail(&create.list, &kthread_create_list); 147 wake_up_process(kthreadd_task); 148 spin_unlock(&kthread_create_lock); 149 150 wait_for_completion(&create.done); 151 152 if (!IS_ERR(create.result)) { 153 va_list args; 154 va_start(args, namefmt); 155 vsnprintf(create.result->comm, sizeof(create.result->comm), 156 namefmt, args); 157 va_end(args); 158 } 159 return create.result; 160 } 161 EXPORT_SYMBOL(kthread_create); 162 163 /** 164 * kthread_bind - bind a just-created kthread to a cpu. 165 * @k: thread created by kthread_create(). 166 * @cpu: cpu (might not be online, must be possible) for @k to run on. 167 * 168 * Description: This function is equivalent to set_cpus_allowed(), 169 * except that @cpu doesn't need to be online, and the thread must be 170 * stopped (i.e., just returned from kthread_create()). 171 */ 172 void kthread_bind(struct task_struct *k, unsigned int cpu) 173 { 174 if (k->state != TASK_UNINTERRUPTIBLE) { 175 WARN_ON(1); 176 return; 177 } 178 /* Must have done schedule() in kthread() before we set_task_cpu */ 179 wait_task_inactive(k); 180 set_task_cpu(k, cpu); 181 k->cpus_allowed = cpumask_of_cpu(cpu); 182 } 183 EXPORT_SYMBOL(kthread_bind); 184 185 /** 186 * kthread_stop - stop a thread created by kthread_create(). 187 * @k: thread created by kthread_create(). 188 * 189 * Sets kthread_should_stop() for @k to return true, wakes it, and 190 * waits for it to exit. Your threadfn() must not call do_exit() 191 * itself if you use this function! This can also be called after 192 * kthread_create() instead of calling wake_up_process(): the thread 193 * will exit without calling threadfn(). 194 * 195 * Returns the result of threadfn(), or %-EINTR if wake_up_process() 196 * was never called. 197 */ 198 int kthread_stop(struct task_struct *k) 199 { 200 int ret; 201 202 mutex_lock(&kthread_stop_lock); 203 204 /* It could exit after stop_info.k set, but before wake_up_process. */ 205 get_task_struct(k); 206 207 /* Must init completion *before* thread sees kthread_stop_info.k */ 208 init_completion(&kthread_stop_info.done); 209 smp_wmb(); 210 211 /* Now set kthread_should_stop() to true, and wake it up. */ 212 kthread_stop_info.k = k; 213 wake_up_process(k); 214 put_task_struct(k); 215 216 /* Once it dies, reset stop ptr, gather result and we're done. */ 217 wait_for_completion(&kthread_stop_info.done); 218 kthread_stop_info.k = NULL; 219 ret = kthread_stop_info.err; 220 mutex_unlock(&kthread_stop_lock); 221 222 return ret; 223 } 224 EXPORT_SYMBOL(kthread_stop); 225 226 int kthreadd(void *unused) 227 { 228 struct task_struct *tsk = current; 229 230 /* Setup a clean context for our children to inherit. */ 231 set_task_comm(tsk, "kthreadd"); 232 ignore_signals(tsk); 233 set_user_nice(tsk, KTHREAD_NICE_LEVEL); 234 set_cpus_allowed(tsk, CPU_MASK_ALL); 235 236 current->flags |= PF_NOFREEZE; 237 238 for (;;) { 239 set_current_state(TASK_INTERRUPTIBLE); 240 if (list_empty(&kthread_create_list)) 241 schedule(); 242 __set_current_state(TASK_RUNNING); 243 244 spin_lock(&kthread_create_lock); 245 while (!list_empty(&kthread_create_list)) { 246 struct kthread_create_info *create; 247 248 create = list_entry(kthread_create_list.next, 249 struct kthread_create_info, list); 250 list_del_init(&create->list); 251 spin_unlock(&kthread_create_lock); 252 253 create_kthread(create); 254 255 spin_lock(&kthread_create_lock); 256 } 257 spin_unlock(&kthread_create_lock); 258 } 259 260 return 0; 261 } 262