11da177e4SLinus Torvalds /* 21da177e4SLinus Torvalds * linux/kernel/workqueue.c 31da177e4SLinus Torvalds * 41da177e4SLinus Torvalds * Generic mechanism for defining kernel helper threads for running 51da177e4SLinus Torvalds * arbitrary tasks in process context. 61da177e4SLinus Torvalds * 71da177e4SLinus Torvalds * Started by Ingo Molnar, Copyright (C) 2002 81da177e4SLinus Torvalds * 91da177e4SLinus Torvalds * Derived from the taskqueue/keventd code by: 101da177e4SLinus Torvalds * 111da177e4SLinus Torvalds * David Woodhouse <dwmw2@infradead.org> 121da177e4SLinus Torvalds * Andrew Morton <andrewm@uow.edu.au> 131da177e4SLinus Torvalds * Kai Petzke <wpp@marie.physik.tu-berlin.de> 141da177e4SLinus Torvalds * Theodore Ts'o <tytso@mit.edu> 1589ada679SChristoph Lameter * 1689ada679SChristoph Lameter * Made to use alloc_percpu by Christoph Lameter <clameter@sgi.com>. 171da177e4SLinus Torvalds */ 181da177e4SLinus Torvalds 191da177e4SLinus Torvalds #include <linux/module.h> 201da177e4SLinus Torvalds #include <linux/kernel.h> 211da177e4SLinus Torvalds #include <linux/sched.h> 221da177e4SLinus Torvalds #include <linux/init.h> 231da177e4SLinus Torvalds #include <linux/signal.h> 241da177e4SLinus Torvalds #include <linux/completion.h> 251da177e4SLinus Torvalds #include <linux/workqueue.h> 261da177e4SLinus Torvalds #include <linux/slab.h> 271da177e4SLinus Torvalds #include <linux/cpu.h> 281da177e4SLinus Torvalds #include <linux/notifier.h> 291da177e4SLinus Torvalds #include <linux/kthread.h> 301da177e4SLinus Torvalds 311da177e4SLinus Torvalds /* 32f756d5e2SNathan Lynch * The per-CPU workqueue (if single thread, we always use the first 33f756d5e2SNathan Lynch * possible cpu). 341da177e4SLinus Torvalds * 351da177e4SLinus Torvalds * The sequence counters are for flush_scheduled_work(). It wants to wait 361da177e4SLinus Torvalds * until until all currently-scheduled works are completed, but it doesn't 371da177e4SLinus Torvalds * want to be livelocked by new, incoming ones. So it waits until 381da177e4SLinus Torvalds * remove_sequence is >= the insert_sequence which pertained when 391da177e4SLinus Torvalds * flush_scheduled_work() was called. 401da177e4SLinus Torvalds */ 411da177e4SLinus Torvalds struct cpu_workqueue_struct { 421da177e4SLinus Torvalds 431da177e4SLinus Torvalds spinlock_t lock; 441da177e4SLinus Torvalds 451da177e4SLinus Torvalds long remove_sequence; /* Least-recently added (next to run) */ 461da177e4SLinus Torvalds long insert_sequence; /* Next to add */ 471da177e4SLinus Torvalds 481da177e4SLinus Torvalds struct list_head worklist; 491da177e4SLinus Torvalds wait_queue_head_t more_work; 501da177e4SLinus Torvalds wait_queue_head_t work_done; 511da177e4SLinus Torvalds 521da177e4SLinus Torvalds struct workqueue_struct *wq; 531da177e4SLinus Torvalds task_t *thread; 541da177e4SLinus Torvalds 551da177e4SLinus Torvalds int run_depth; /* Detect run_workqueue() recursion depth */ 561da177e4SLinus Torvalds } ____cacheline_aligned; 571da177e4SLinus Torvalds 581da177e4SLinus Torvalds /* 591da177e4SLinus Torvalds * The externally visible workqueue abstraction is an array of 601da177e4SLinus Torvalds * per-CPU workqueues: 611da177e4SLinus Torvalds */ 621da177e4SLinus Torvalds struct workqueue_struct { 6389ada679SChristoph Lameter struct cpu_workqueue_struct *cpu_wq; 641da177e4SLinus Torvalds const char *name; 651da177e4SLinus Torvalds struct list_head list; /* Empty if single thread */ 661da177e4SLinus Torvalds }; 671da177e4SLinus Torvalds 681da177e4SLinus Torvalds /* All the per-cpu workqueues on the system, for hotplug cpu to add/remove 691da177e4SLinus Torvalds threads to each one as cpus come/go. */ 701da177e4SLinus Torvalds static DEFINE_SPINLOCK(workqueue_lock); 711da177e4SLinus Torvalds static LIST_HEAD(workqueues); 721da177e4SLinus Torvalds 73f756d5e2SNathan Lynch static int singlethread_cpu; 74f756d5e2SNathan Lynch 751da177e4SLinus Torvalds /* If it's single threaded, it isn't in the list of workqueues. */ 761da177e4SLinus Torvalds static inline int is_single_threaded(struct workqueue_struct *wq) 771da177e4SLinus Torvalds { 781da177e4SLinus Torvalds return list_empty(&wq->list); 791da177e4SLinus Torvalds } 801da177e4SLinus Torvalds 811da177e4SLinus Torvalds /* Preempt must be disabled. */ 821da177e4SLinus Torvalds static void __queue_work(struct cpu_workqueue_struct *cwq, 831da177e4SLinus Torvalds struct work_struct *work) 841da177e4SLinus Torvalds { 851da177e4SLinus Torvalds unsigned long flags; 861da177e4SLinus Torvalds 871da177e4SLinus Torvalds spin_lock_irqsave(&cwq->lock, flags); 881da177e4SLinus Torvalds work->wq_data = cwq; 891da177e4SLinus Torvalds list_add_tail(&work->entry, &cwq->worklist); 901da177e4SLinus Torvalds cwq->insert_sequence++; 911da177e4SLinus Torvalds wake_up(&cwq->more_work); 921da177e4SLinus Torvalds spin_unlock_irqrestore(&cwq->lock, flags); 931da177e4SLinus Torvalds } 941da177e4SLinus Torvalds 951da177e4SLinus Torvalds /* 961da177e4SLinus Torvalds * Queue work on a workqueue. Return non-zero if it was successfully 971da177e4SLinus Torvalds * added. 981da177e4SLinus Torvalds * 991da177e4SLinus Torvalds * We queue the work to the CPU it was submitted, but there is no 1001da177e4SLinus Torvalds * guarantee that it will be processed by that CPU. 1011da177e4SLinus Torvalds */ 1021da177e4SLinus Torvalds int fastcall queue_work(struct workqueue_struct *wq, struct work_struct *work) 1031da177e4SLinus Torvalds { 1041da177e4SLinus Torvalds int ret = 0, cpu = get_cpu(); 1051da177e4SLinus Torvalds 1061da177e4SLinus Torvalds if (!test_and_set_bit(0, &work->pending)) { 1071da177e4SLinus Torvalds if (unlikely(is_single_threaded(wq))) 108f756d5e2SNathan Lynch cpu = singlethread_cpu; 1091da177e4SLinus Torvalds BUG_ON(!list_empty(&work->entry)); 11089ada679SChristoph Lameter __queue_work(per_cpu_ptr(wq->cpu_wq, cpu), work); 1111da177e4SLinus Torvalds ret = 1; 1121da177e4SLinus Torvalds } 1131da177e4SLinus Torvalds put_cpu(); 1141da177e4SLinus Torvalds return ret; 1151da177e4SLinus Torvalds } 1161da177e4SLinus Torvalds 1171da177e4SLinus Torvalds static void delayed_work_timer_fn(unsigned long __data) 1181da177e4SLinus Torvalds { 1191da177e4SLinus Torvalds struct work_struct *work = (struct work_struct *)__data; 1201da177e4SLinus Torvalds struct workqueue_struct *wq = work->wq_data; 1211da177e4SLinus Torvalds int cpu = smp_processor_id(); 1221da177e4SLinus Torvalds 1231da177e4SLinus Torvalds if (unlikely(is_single_threaded(wq))) 124f756d5e2SNathan Lynch cpu = singlethread_cpu; 1251da177e4SLinus Torvalds 12689ada679SChristoph Lameter __queue_work(per_cpu_ptr(wq->cpu_wq, cpu), work); 1271da177e4SLinus Torvalds } 1281da177e4SLinus Torvalds 1291da177e4SLinus Torvalds int fastcall queue_delayed_work(struct workqueue_struct *wq, 1301da177e4SLinus Torvalds struct work_struct *work, unsigned long delay) 1311da177e4SLinus Torvalds { 1321da177e4SLinus Torvalds int ret = 0; 1331da177e4SLinus Torvalds struct timer_list *timer = &work->timer; 1341da177e4SLinus Torvalds 1351da177e4SLinus Torvalds if (!test_and_set_bit(0, &work->pending)) { 1361da177e4SLinus Torvalds BUG_ON(timer_pending(timer)); 1371da177e4SLinus Torvalds BUG_ON(!list_empty(&work->entry)); 1381da177e4SLinus Torvalds 1391da177e4SLinus Torvalds /* This stores wq for the moment, for the timer_fn */ 1401da177e4SLinus Torvalds work->wq_data = wq; 1411da177e4SLinus Torvalds timer->expires = jiffies + delay; 1421da177e4SLinus Torvalds timer->data = (unsigned long)work; 1431da177e4SLinus Torvalds timer->function = delayed_work_timer_fn; 1441da177e4SLinus Torvalds add_timer(timer); 1451da177e4SLinus Torvalds ret = 1; 1461da177e4SLinus Torvalds } 1471da177e4SLinus Torvalds return ret; 1481da177e4SLinus Torvalds } 1491da177e4SLinus Torvalds 1501da177e4SLinus Torvalds static inline void run_workqueue(struct cpu_workqueue_struct *cwq) 1511da177e4SLinus Torvalds { 1521da177e4SLinus Torvalds unsigned long flags; 1531da177e4SLinus Torvalds 1541da177e4SLinus Torvalds /* 1551da177e4SLinus Torvalds * Keep taking off work from the queue until 1561da177e4SLinus Torvalds * done. 1571da177e4SLinus Torvalds */ 1581da177e4SLinus Torvalds spin_lock_irqsave(&cwq->lock, flags); 1591da177e4SLinus Torvalds cwq->run_depth++; 1601da177e4SLinus Torvalds if (cwq->run_depth > 3) { 1611da177e4SLinus Torvalds /* morton gets to eat his hat */ 1621da177e4SLinus Torvalds printk("%s: recursion depth exceeded: %d\n", 1631da177e4SLinus Torvalds __FUNCTION__, cwq->run_depth); 1641da177e4SLinus Torvalds dump_stack(); 1651da177e4SLinus Torvalds } 1661da177e4SLinus Torvalds while (!list_empty(&cwq->worklist)) { 1671da177e4SLinus Torvalds struct work_struct *work = list_entry(cwq->worklist.next, 1681da177e4SLinus Torvalds struct work_struct, entry); 1691da177e4SLinus Torvalds void (*f) (void *) = work->func; 1701da177e4SLinus Torvalds void *data = work->data; 1711da177e4SLinus Torvalds 1721da177e4SLinus Torvalds list_del_init(cwq->worklist.next); 1731da177e4SLinus Torvalds spin_unlock_irqrestore(&cwq->lock, flags); 1741da177e4SLinus Torvalds 1751da177e4SLinus Torvalds BUG_ON(work->wq_data != cwq); 1761da177e4SLinus Torvalds clear_bit(0, &work->pending); 1771da177e4SLinus Torvalds f(data); 1781da177e4SLinus Torvalds 1791da177e4SLinus Torvalds spin_lock_irqsave(&cwq->lock, flags); 1801da177e4SLinus Torvalds cwq->remove_sequence++; 1811da177e4SLinus Torvalds wake_up(&cwq->work_done); 1821da177e4SLinus Torvalds } 1831da177e4SLinus Torvalds cwq->run_depth--; 1841da177e4SLinus Torvalds spin_unlock_irqrestore(&cwq->lock, flags); 1851da177e4SLinus Torvalds } 1861da177e4SLinus Torvalds 1871da177e4SLinus Torvalds static int worker_thread(void *__cwq) 1881da177e4SLinus Torvalds { 1891da177e4SLinus Torvalds struct cpu_workqueue_struct *cwq = __cwq; 1901da177e4SLinus Torvalds DECLARE_WAITQUEUE(wait, current); 1911da177e4SLinus Torvalds struct k_sigaction sa; 1921da177e4SLinus Torvalds sigset_t blocked; 1931da177e4SLinus Torvalds 1941da177e4SLinus Torvalds current->flags |= PF_NOFREEZE; 1951da177e4SLinus Torvalds 1961da177e4SLinus Torvalds set_user_nice(current, -5); 1971da177e4SLinus Torvalds 1981da177e4SLinus Torvalds /* Block and flush all signals */ 1991da177e4SLinus Torvalds sigfillset(&blocked); 2001da177e4SLinus Torvalds sigprocmask(SIG_BLOCK, &blocked, NULL); 2011da177e4SLinus Torvalds flush_signals(current); 2021da177e4SLinus Torvalds 2031da177e4SLinus Torvalds /* SIG_IGN makes children autoreap: see do_notify_parent(). */ 2041da177e4SLinus Torvalds sa.sa.sa_handler = SIG_IGN; 2051da177e4SLinus Torvalds sa.sa.sa_flags = 0; 2061da177e4SLinus Torvalds siginitset(&sa.sa.sa_mask, sigmask(SIGCHLD)); 2071da177e4SLinus Torvalds do_sigaction(SIGCHLD, &sa, (struct k_sigaction *)0); 2081da177e4SLinus Torvalds 2091da177e4SLinus Torvalds set_current_state(TASK_INTERRUPTIBLE); 2101da177e4SLinus Torvalds while (!kthread_should_stop()) { 2111da177e4SLinus Torvalds add_wait_queue(&cwq->more_work, &wait); 2121da177e4SLinus Torvalds if (list_empty(&cwq->worklist)) 2131da177e4SLinus Torvalds schedule(); 2141da177e4SLinus Torvalds else 2151da177e4SLinus Torvalds __set_current_state(TASK_RUNNING); 2161da177e4SLinus Torvalds remove_wait_queue(&cwq->more_work, &wait); 2171da177e4SLinus Torvalds 2181da177e4SLinus Torvalds if (!list_empty(&cwq->worklist)) 2191da177e4SLinus Torvalds run_workqueue(cwq); 2201da177e4SLinus Torvalds set_current_state(TASK_INTERRUPTIBLE); 2211da177e4SLinus Torvalds } 2221da177e4SLinus Torvalds __set_current_state(TASK_RUNNING); 2231da177e4SLinus Torvalds return 0; 2241da177e4SLinus Torvalds } 2251da177e4SLinus Torvalds 2261da177e4SLinus Torvalds static void flush_cpu_workqueue(struct cpu_workqueue_struct *cwq) 2271da177e4SLinus Torvalds { 2281da177e4SLinus Torvalds if (cwq->thread == current) { 2291da177e4SLinus Torvalds /* 2301da177e4SLinus Torvalds * Probably keventd trying to flush its own queue. So simply run 2311da177e4SLinus Torvalds * it by hand rather than deadlocking. 2321da177e4SLinus Torvalds */ 2331da177e4SLinus Torvalds run_workqueue(cwq); 2341da177e4SLinus Torvalds } else { 2351da177e4SLinus Torvalds DEFINE_WAIT(wait); 2361da177e4SLinus Torvalds long sequence_needed; 2371da177e4SLinus Torvalds 2381da177e4SLinus Torvalds spin_lock_irq(&cwq->lock); 2391da177e4SLinus Torvalds sequence_needed = cwq->insert_sequence; 2401da177e4SLinus Torvalds 2411da177e4SLinus Torvalds while (sequence_needed - cwq->remove_sequence > 0) { 2421da177e4SLinus Torvalds prepare_to_wait(&cwq->work_done, &wait, 2431da177e4SLinus Torvalds TASK_UNINTERRUPTIBLE); 2441da177e4SLinus Torvalds spin_unlock_irq(&cwq->lock); 2451da177e4SLinus Torvalds schedule(); 2461da177e4SLinus Torvalds spin_lock_irq(&cwq->lock); 2471da177e4SLinus Torvalds } 2481da177e4SLinus Torvalds finish_wait(&cwq->work_done, &wait); 2491da177e4SLinus Torvalds spin_unlock_irq(&cwq->lock); 2501da177e4SLinus Torvalds } 2511da177e4SLinus Torvalds } 2521da177e4SLinus Torvalds 2531da177e4SLinus Torvalds /* 2541da177e4SLinus Torvalds * flush_workqueue - ensure that any scheduled work has run to completion. 2551da177e4SLinus Torvalds * 2561da177e4SLinus Torvalds * Forces execution of the workqueue and blocks until its completion. 2571da177e4SLinus Torvalds * This is typically used in driver shutdown handlers. 2581da177e4SLinus Torvalds * 2591da177e4SLinus Torvalds * This function will sample each workqueue's current insert_sequence number and 2601da177e4SLinus Torvalds * will sleep until the head sequence is greater than or equal to that. This 2611da177e4SLinus Torvalds * means that we sleep until all works which were queued on entry have been 2621da177e4SLinus Torvalds * handled, but we are not livelocked by new incoming ones. 2631da177e4SLinus Torvalds * 2641da177e4SLinus Torvalds * This function used to run the workqueues itself. Now we just wait for the 2651da177e4SLinus Torvalds * helper threads to do it. 2661da177e4SLinus Torvalds */ 2671da177e4SLinus Torvalds void fastcall flush_workqueue(struct workqueue_struct *wq) 2681da177e4SLinus Torvalds { 2691da177e4SLinus Torvalds might_sleep(); 2701da177e4SLinus Torvalds 2711da177e4SLinus Torvalds if (is_single_threaded(wq)) { 272bce61dd4SBen Collins /* Always use first cpu's area. */ 273f756d5e2SNathan Lynch flush_cpu_workqueue(per_cpu_ptr(wq->cpu_wq, singlethread_cpu)); 2741da177e4SLinus Torvalds } else { 2751da177e4SLinus Torvalds int cpu; 2761da177e4SLinus Torvalds 2771da177e4SLinus Torvalds lock_cpu_hotplug(); 2781da177e4SLinus Torvalds for_each_online_cpu(cpu) 27989ada679SChristoph Lameter flush_cpu_workqueue(per_cpu_ptr(wq->cpu_wq, cpu)); 2801da177e4SLinus Torvalds unlock_cpu_hotplug(); 2811da177e4SLinus Torvalds } 2821da177e4SLinus Torvalds } 2831da177e4SLinus Torvalds 2841da177e4SLinus Torvalds static struct task_struct *create_workqueue_thread(struct workqueue_struct *wq, 2851da177e4SLinus Torvalds int cpu) 2861da177e4SLinus Torvalds { 28789ada679SChristoph Lameter struct cpu_workqueue_struct *cwq = per_cpu_ptr(wq->cpu_wq, cpu); 2881da177e4SLinus Torvalds struct task_struct *p; 2891da177e4SLinus Torvalds 2901da177e4SLinus Torvalds spin_lock_init(&cwq->lock); 2911da177e4SLinus Torvalds cwq->wq = wq; 2921da177e4SLinus Torvalds cwq->thread = NULL; 2931da177e4SLinus Torvalds cwq->insert_sequence = 0; 2941da177e4SLinus Torvalds cwq->remove_sequence = 0; 2951da177e4SLinus Torvalds INIT_LIST_HEAD(&cwq->worklist); 2961da177e4SLinus Torvalds init_waitqueue_head(&cwq->more_work); 2971da177e4SLinus Torvalds init_waitqueue_head(&cwq->work_done); 2981da177e4SLinus Torvalds 2991da177e4SLinus Torvalds if (is_single_threaded(wq)) 3001da177e4SLinus Torvalds p = kthread_create(worker_thread, cwq, "%s", wq->name); 3011da177e4SLinus Torvalds else 3021da177e4SLinus Torvalds p = kthread_create(worker_thread, cwq, "%s/%d", wq->name, cpu); 3031da177e4SLinus Torvalds if (IS_ERR(p)) 3041da177e4SLinus Torvalds return NULL; 3051da177e4SLinus Torvalds cwq->thread = p; 3061da177e4SLinus Torvalds return p; 3071da177e4SLinus Torvalds } 3081da177e4SLinus Torvalds 3091da177e4SLinus Torvalds struct workqueue_struct *__create_workqueue(const char *name, 3101da177e4SLinus Torvalds int singlethread) 3111da177e4SLinus Torvalds { 3121da177e4SLinus Torvalds int cpu, destroy = 0; 3131da177e4SLinus Torvalds struct workqueue_struct *wq; 3141da177e4SLinus Torvalds struct task_struct *p; 3151da177e4SLinus Torvalds 316dd392710SPekka J Enberg wq = kzalloc(sizeof(*wq), GFP_KERNEL); 3171da177e4SLinus Torvalds if (!wq) 3181da177e4SLinus Torvalds return NULL; 3191da177e4SLinus Torvalds 32089ada679SChristoph Lameter wq->cpu_wq = alloc_percpu(struct cpu_workqueue_struct); 321676121fcSBen Collins if (!wq->cpu_wq) { 322676121fcSBen Collins kfree(wq); 323676121fcSBen Collins return NULL; 324676121fcSBen Collins } 325676121fcSBen Collins 3261da177e4SLinus Torvalds wq->name = name; 3271da177e4SLinus Torvalds /* We don't need the distraction of CPUs appearing and vanishing. */ 3281da177e4SLinus Torvalds lock_cpu_hotplug(); 3291da177e4SLinus Torvalds if (singlethread) { 3301da177e4SLinus Torvalds INIT_LIST_HEAD(&wq->list); 331f756d5e2SNathan Lynch p = create_workqueue_thread(wq, singlethread_cpu); 3321da177e4SLinus Torvalds if (!p) 3331da177e4SLinus Torvalds destroy = 1; 3341da177e4SLinus Torvalds else 3351da177e4SLinus Torvalds wake_up_process(p); 3361da177e4SLinus Torvalds } else { 3371da177e4SLinus Torvalds spin_lock(&workqueue_lock); 3381da177e4SLinus Torvalds list_add(&wq->list, &workqueues); 3391da177e4SLinus Torvalds spin_unlock(&workqueue_lock); 3401da177e4SLinus Torvalds for_each_online_cpu(cpu) { 3411da177e4SLinus Torvalds p = create_workqueue_thread(wq, cpu); 3421da177e4SLinus Torvalds if (p) { 3431da177e4SLinus Torvalds kthread_bind(p, cpu); 3441da177e4SLinus Torvalds wake_up_process(p); 3451da177e4SLinus Torvalds } else 3461da177e4SLinus Torvalds destroy = 1; 3471da177e4SLinus Torvalds } 3481da177e4SLinus Torvalds } 3491da177e4SLinus Torvalds unlock_cpu_hotplug(); 3501da177e4SLinus Torvalds 3511da177e4SLinus Torvalds /* 3521da177e4SLinus Torvalds * Was there any error during startup? If yes then clean up: 3531da177e4SLinus Torvalds */ 3541da177e4SLinus Torvalds if (destroy) { 3551da177e4SLinus Torvalds destroy_workqueue(wq); 3561da177e4SLinus Torvalds wq = NULL; 3571da177e4SLinus Torvalds } 3581da177e4SLinus Torvalds return wq; 3591da177e4SLinus Torvalds } 3601da177e4SLinus Torvalds 3611da177e4SLinus Torvalds static void cleanup_workqueue_thread(struct workqueue_struct *wq, int cpu) 3621da177e4SLinus Torvalds { 3631da177e4SLinus Torvalds struct cpu_workqueue_struct *cwq; 3641da177e4SLinus Torvalds unsigned long flags; 3651da177e4SLinus Torvalds struct task_struct *p; 3661da177e4SLinus Torvalds 36789ada679SChristoph Lameter cwq = per_cpu_ptr(wq->cpu_wq, cpu); 3681da177e4SLinus Torvalds spin_lock_irqsave(&cwq->lock, flags); 3691da177e4SLinus Torvalds p = cwq->thread; 3701da177e4SLinus Torvalds cwq->thread = NULL; 3711da177e4SLinus Torvalds spin_unlock_irqrestore(&cwq->lock, flags); 3721da177e4SLinus Torvalds if (p) 3731da177e4SLinus Torvalds kthread_stop(p); 3741da177e4SLinus Torvalds } 3751da177e4SLinus Torvalds 3761da177e4SLinus Torvalds void destroy_workqueue(struct workqueue_struct *wq) 3771da177e4SLinus Torvalds { 3781da177e4SLinus Torvalds int cpu; 3791da177e4SLinus Torvalds 3801da177e4SLinus Torvalds flush_workqueue(wq); 3811da177e4SLinus Torvalds 3821da177e4SLinus Torvalds /* We don't need the distraction of CPUs appearing and vanishing. */ 3831da177e4SLinus Torvalds lock_cpu_hotplug(); 3841da177e4SLinus Torvalds if (is_single_threaded(wq)) 385f756d5e2SNathan Lynch cleanup_workqueue_thread(wq, singlethread_cpu); 3861da177e4SLinus Torvalds else { 3871da177e4SLinus Torvalds for_each_online_cpu(cpu) 3881da177e4SLinus Torvalds cleanup_workqueue_thread(wq, cpu); 3891da177e4SLinus Torvalds spin_lock(&workqueue_lock); 3901da177e4SLinus Torvalds list_del(&wq->list); 3911da177e4SLinus Torvalds spin_unlock(&workqueue_lock); 3921da177e4SLinus Torvalds } 3931da177e4SLinus Torvalds unlock_cpu_hotplug(); 39489ada679SChristoph Lameter free_percpu(wq->cpu_wq); 3951da177e4SLinus Torvalds kfree(wq); 3961da177e4SLinus Torvalds } 3971da177e4SLinus Torvalds 3981da177e4SLinus Torvalds static struct workqueue_struct *keventd_wq; 3991da177e4SLinus Torvalds 4001da177e4SLinus Torvalds int fastcall schedule_work(struct work_struct *work) 4011da177e4SLinus Torvalds { 4021da177e4SLinus Torvalds return queue_work(keventd_wq, work); 4031da177e4SLinus Torvalds } 4041da177e4SLinus Torvalds 4051da177e4SLinus Torvalds int fastcall schedule_delayed_work(struct work_struct *work, unsigned long delay) 4061da177e4SLinus Torvalds { 4071da177e4SLinus Torvalds return queue_delayed_work(keventd_wq, work, delay); 4081da177e4SLinus Torvalds } 4091da177e4SLinus Torvalds 4101da177e4SLinus Torvalds int schedule_delayed_work_on(int cpu, 4111da177e4SLinus Torvalds struct work_struct *work, unsigned long delay) 4121da177e4SLinus Torvalds { 4131da177e4SLinus Torvalds int ret = 0; 4141da177e4SLinus Torvalds struct timer_list *timer = &work->timer; 4151da177e4SLinus Torvalds 4161da177e4SLinus Torvalds if (!test_and_set_bit(0, &work->pending)) { 4171da177e4SLinus Torvalds BUG_ON(timer_pending(timer)); 4181da177e4SLinus Torvalds BUG_ON(!list_empty(&work->entry)); 4191da177e4SLinus Torvalds /* This stores keventd_wq for the moment, for the timer_fn */ 4201da177e4SLinus Torvalds work->wq_data = keventd_wq; 4211da177e4SLinus Torvalds timer->expires = jiffies + delay; 4221da177e4SLinus Torvalds timer->data = (unsigned long)work; 4231da177e4SLinus Torvalds timer->function = delayed_work_timer_fn; 4241da177e4SLinus Torvalds add_timer_on(timer, cpu); 4251da177e4SLinus Torvalds ret = 1; 4261da177e4SLinus Torvalds } 4271da177e4SLinus Torvalds return ret; 4281da177e4SLinus Torvalds } 4291da177e4SLinus Torvalds 43015316ba8SChristoph Lameter int schedule_on_each_cpu(void (*func) (void *info), void *info) 43115316ba8SChristoph Lameter { 43215316ba8SChristoph Lameter int cpu; 43315316ba8SChristoph Lameter struct work_struct *work; 43415316ba8SChristoph Lameter 43515316ba8SChristoph Lameter work = kmalloc(NR_CPUS * sizeof(struct work_struct), GFP_KERNEL); 43615316ba8SChristoph Lameter 43715316ba8SChristoph Lameter if (!work) 43815316ba8SChristoph Lameter return -ENOMEM; 43915316ba8SChristoph Lameter for_each_online_cpu(cpu) { 44015316ba8SChristoph Lameter INIT_WORK(work + cpu, func, info); 44115316ba8SChristoph Lameter __queue_work(per_cpu_ptr(keventd_wq->cpu_wq, cpu), 44215316ba8SChristoph Lameter work + cpu); 44315316ba8SChristoph Lameter } 44415316ba8SChristoph Lameter flush_workqueue(keventd_wq); 44515316ba8SChristoph Lameter kfree(work); 44615316ba8SChristoph Lameter return 0; 44715316ba8SChristoph Lameter } 44815316ba8SChristoph Lameter 4491da177e4SLinus Torvalds void flush_scheduled_work(void) 4501da177e4SLinus Torvalds { 4511da177e4SLinus Torvalds flush_workqueue(keventd_wq); 4521da177e4SLinus Torvalds } 4531da177e4SLinus Torvalds 4541da177e4SLinus Torvalds /** 4551da177e4SLinus Torvalds * cancel_rearming_delayed_workqueue - reliably kill off a delayed 4561da177e4SLinus Torvalds * work whose handler rearms the delayed work. 4571da177e4SLinus Torvalds * @wq: the controlling workqueue structure 4581da177e4SLinus Torvalds * @work: the delayed work struct 4591da177e4SLinus Torvalds */ 46081ddef77SJames Bottomley void cancel_rearming_delayed_workqueue(struct workqueue_struct *wq, 4611da177e4SLinus Torvalds struct work_struct *work) 4621da177e4SLinus Torvalds { 4631da177e4SLinus Torvalds while (!cancel_delayed_work(work)) 4641da177e4SLinus Torvalds flush_workqueue(wq); 4651da177e4SLinus Torvalds } 46681ddef77SJames Bottomley EXPORT_SYMBOL(cancel_rearming_delayed_workqueue); 4671da177e4SLinus Torvalds 4681da177e4SLinus Torvalds /** 4691da177e4SLinus Torvalds * cancel_rearming_delayed_work - reliably kill off a delayed keventd 4701da177e4SLinus Torvalds * work whose handler rearms the delayed work. 4711da177e4SLinus Torvalds * @work: the delayed work struct 4721da177e4SLinus Torvalds */ 4731da177e4SLinus Torvalds void cancel_rearming_delayed_work(struct work_struct *work) 4741da177e4SLinus Torvalds { 4751da177e4SLinus Torvalds cancel_rearming_delayed_workqueue(keventd_wq, work); 4761da177e4SLinus Torvalds } 4771da177e4SLinus Torvalds EXPORT_SYMBOL(cancel_rearming_delayed_work); 4781da177e4SLinus Torvalds 4791da177e4SLinus Torvalds int keventd_up(void) 4801da177e4SLinus Torvalds { 4811da177e4SLinus Torvalds return keventd_wq != NULL; 4821da177e4SLinus Torvalds } 4831da177e4SLinus Torvalds 4841da177e4SLinus Torvalds int current_is_keventd(void) 4851da177e4SLinus Torvalds { 4861da177e4SLinus Torvalds struct cpu_workqueue_struct *cwq; 4871da177e4SLinus Torvalds int cpu = smp_processor_id(); /* preempt-safe: keventd is per-cpu */ 4881da177e4SLinus Torvalds int ret = 0; 4891da177e4SLinus Torvalds 4901da177e4SLinus Torvalds BUG_ON(!keventd_wq); 4911da177e4SLinus Torvalds 49289ada679SChristoph Lameter cwq = per_cpu_ptr(keventd_wq->cpu_wq, cpu); 4931da177e4SLinus Torvalds if (current == cwq->thread) 4941da177e4SLinus Torvalds ret = 1; 4951da177e4SLinus Torvalds 4961da177e4SLinus Torvalds return ret; 4971da177e4SLinus Torvalds 4981da177e4SLinus Torvalds } 4991da177e4SLinus Torvalds 5001da177e4SLinus Torvalds #ifdef CONFIG_HOTPLUG_CPU 5011da177e4SLinus Torvalds /* Take the work from this (downed) CPU. */ 5021da177e4SLinus Torvalds static void take_over_work(struct workqueue_struct *wq, unsigned int cpu) 5031da177e4SLinus Torvalds { 50489ada679SChristoph Lameter struct cpu_workqueue_struct *cwq = per_cpu_ptr(wq->cpu_wq, cpu); 5051da177e4SLinus Torvalds LIST_HEAD(list); 5061da177e4SLinus Torvalds struct work_struct *work; 5071da177e4SLinus Torvalds 5081da177e4SLinus Torvalds spin_lock_irq(&cwq->lock); 5091da177e4SLinus Torvalds list_splice_init(&cwq->worklist, &list); 5101da177e4SLinus Torvalds 5111da177e4SLinus Torvalds while (!list_empty(&list)) { 5121da177e4SLinus Torvalds printk("Taking work for %s\n", wq->name); 5131da177e4SLinus Torvalds work = list_entry(list.next,struct work_struct,entry); 5141da177e4SLinus Torvalds list_del(&work->entry); 51589ada679SChristoph Lameter __queue_work(per_cpu_ptr(wq->cpu_wq, smp_processor_id()), work); 5161da177e4SLinus Torvalds } 5171da177e4SLinus Torvalds spin_unlock_irq(&cwq->lock); 5181da177e4SLinus Torvalds } 5191da177e4SLinus Torvalds 5201da177e4SLinus Torvalds /* We're holding the cpucontrol mutex here */ 5211da177e4SLinus Torvalds static int __devinit workqueue_cpu_callback(struct notifier_block *nfb, 5221da177e4SLinus Torvalds unsigned long action, 5231da177e4SLinus Torvalds void *hcpu) 5241da177e4SLinus Torvalds { 5251da177e4SLinus Torvalds unsigned int hotcpu = (unsigned long)hcpu; 5261da177e4SLinus Torvalds struct workqueue_struct *wq; 5271da177e4SLinus Torvalds 5281da177e4SLinus Torvalds switch (action) { 5291da177e4SLinus Torvalds case CPU_UP_PREPARE: 5301da177e4SLinus Torvalds /* Create a new workqueue thread for it. */ 5311da177e4SLinus Torvalds list_for_each_entry(wq, &workqueues, list) { 532230649daSMika Kukkonen if (!create_workqueue_thread(wq, hotcpu)) { 5331da177e4SLinus Torvalds printk("workqueue for %i failed\n", hotcpu); 5341da177e4SLinus Torvalds return NOTIFY_BAD; 5351da177e4SLinus Torvalds } 5361da177e4SLinus Torvalds } 5371da177e4SLinus Torvalds break; 5381da177e4SLinus Torvalds 5391da177e4SLinus Torvalds case CPU_ONLINE: 5401da177e4SLinus Torvalds /* Kick off worker threads. */ 5411da177e4SLinus Torvalds list_for_each_entry(wq, &workqueues, list) { 54289ada679SChristoph Lameter struct cpu_workqueue_struct *cwq; 54389ada679SChristoph Lameter 54489ada679SChristoph Lameter cwq = per_cpu_ptr(wq->cpu_wq, hotcpu); 54589ada679SChristoph Lameter kthread_bind(cwq->thread, hotcpu); 54689ada679SChristoph Lameter wake_up_process(cwq->thread); 5471da177e4SLinus Torvalds } 5481da177e4SLinus Torvalds break; 5491da177e4SLinus Torvalds 5501da177e4SLinus Torvalds case CPU_UP_CANCELED: 5511da177e4SLinus Torvalds list_for_each_entry(wq, &workqueues, list) { 5521da177e4SLinus Torvalds /* Unbind so it can run. */ 55389ada679SChristoph Lameter kthread_bind(per_cpu_ptr(wq->cpu_wq, hotcpu)->thread, 554a4c4af7cSHeiko Carstens any_online_cpu(cpu_online_map)); 5551da177e4SLinus Torvalds cleanup_workqueue_thread(wq, hotcpu); 5561da177e4SLinus Torvalds } 5571da177e4SLinus Torvalds break; 5581da177e4SLinus Torvalds 5591da177e4SLinus Torvalds case CPU_DEAD: 5601da177e4SLinus Torvalds list_for_each_entry(wq, &workqueues, list) 5611da177e4SLinus Torvalds cleanup_workqueue_thread(wq, hotcpu); 5621da177e4SLinus Torvalds list_for_each_entry(wq, &workqueues, list) 5631da177e4SLinus Torvalds take_over_work(wq, hotcpu); 5641da177e4SLinus Torvalds break; 5651da177e4SLinus Torvalds } 5661da177e4SLinus Torvalds 5671da177e4SLinus Torvalds return NOTIFY_OK; 5681da177e4SLinus Torvalds } 5691da177e4SLinus Torvalds #endif 5701da177e4SLinus Torvalds 5711da177e4SLinus Torvalds void init_workqueues(void) 5721da177e4SLinus Torvalds { 573f756d5e2SNathan Lynch singlethread_cpu = first_cpu(cpu_possible_map); 5741da177e4SLinus Torvalds hotcpu_notifier(workqueue_cpu_callback, 0); 5751da177e4SLinus Torvalds keventd_wq = create_workqueue("events"); 5761da177e4SLinus Torvalds BUG_ON(!keventd_wq); 5771da177e4SLinus Torvalds } 5781da177e4SLinus Torvalds 5791da177e4SLinus Torvalds EXPORT_SYMBOL_GPL(__create_workqueue); 5801da177e4SLinus Torvalds EXPORT_SYMBOL_GPL(queue_work); 5811da177e4SLinus Torvalds EXPORT_SYMBOL_GPL(queue_delayed_work); 5821da177e4SLinus Torvalds EXPORT_SYMBOL_GPL(flush_workqueue); 5831da177e4SLinus Torvalds EXPORT_SYMBOL_GPL(destroy_workqueue); 5841da177e4SLinus Torvalds 5851da177e4SLinus Torvalds EXPORT_SYMBOL(schedule_work); 5861da177e4SLinus Torvalds EXPORT_SYMBOL(schedule_delayed_work); 5871da177e4SLinus Torvalds EXPORT_SYMBOL(schedule_delayed_work_on); 5881da177e4SLinus Torvalds EXPORT_SYMBOL(flush_scheduled_work); 589