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> 301fa44ecaSJames Bottomley #include <linux/hardirq.h> 3146934023SChristoph Lameter #include <linux/mempolicy.h> 32341a5958SRafael J. Wysocki #include <linux/freezer.h> 33d5abe669SPeter Zijlstra #include <linux/kallsyms.h> 34d5abe669SPeter Zijlstra #include <linux/debug_locks.h> 351da177e4SLinus Torvalds 361da177e4SLinus Torvalds /* 37f756d5e2SNathan Lynch * The per-CPU workqueue (if single thread, we always use the first 38f756d5e2SNathan Lynch * possible cpu). 391da177e4SLinus Torvalds */ 401da177e4SLinus Torvalds struct cpu_workqueue_struct { 411da177e4SLinus Torvalds 421da177e4SLinus Torvalds spinlock_t lock; 431da177e4SLinus Torvalds 441da177e4SLinus Torvalds struct list_head worklist; 451da177e4SLinus Torvalds wait_queue_head_t more_work; 463af24433SOleg Nesterov struct work_struct *current_work; 471da177e4SLinus Torvalds 481da177e4SLinus Torvalds struct workqueue_struct *wq; 4936c8b586SIngo Molnar struct task_struct *thread; 503af24433SOleg Nesterov int should_stop; 511da177e4SLinus Torvalds 521da177e4SLinus Torvalds int run_depth; /* Detect run_workqueue() recursion depth */ 531da177e4SLinus Torvalds } ____cacheline_aligned; 541da177e4SLinus Torvalds 551da177e4SLinus Torvalds /* 561da177e4SLinus Torvalds * The externally visible workqueue abstraction is an array of 571da177e4SLinus Torvalds * per-CPU workqueues: 581da177e4SLinus Torvalds */ 591da177e4SLinus Torvalds struct workqueue_struct { 6089ada679SChristoph Lameter struct cpu_workqueue_struct *cpu_wq; 611da177e4SLinus Torvalds const char *name; 621da177e4SLinus Torvalds struct list_head list; /* Empty if single thread */ 63319c2a98SOleg Nesterov int freezeable; /* Freeze threads during suspend */ 641da177e4SLinus Torvalds }; 651da177e4SLinus Torvalds 661da177e4SLinus Torvalds /* All the per-cpu workqueues on the system, for hotplug cpu to add/remove 671da177e4SLinus Torvalds threads to each one as cpus come/go. */ 689b41ea72SAndrew Morton static DEFINE_MUTEX(workqueue_mutex); 691da177e4SLinus Torvalds static LIST_HEAD(workqueues); 701da177e4SLinus Torvalds 713af24433SOleg Nesterov static int singlethread_cpu __read_mostly; 723af24433SOleg Nesterov /* optimization, we could use cpu_possible_map */ 733af24433SOleg Nesterov static cpumask_t cpu_populated_map __read_mostly; 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 814594bf15SDavid Howells /* 824594bf15SDavid Howells * Set the workqueue on which a work item is to be run 834594bf15SDavid Howells * - Must *only* be called if the pending flag is set 844594bf15SDavid Howells */ 85365970a1SDavid Howells static inline void set_wq_data(struct work_struct *work, void *wq) 86365970a1SDavid Howells { 874594bf15SDavid Howells unsigned long new; 88365970a1SDavid Howells 894594bf15SDavid Howells BUG_ON(!work_pending(work)); 904594bf15SDavid Howells 91365970a1SDavid Howells new = (unsigned long) wq | (1UL << WORK_STRUCT_PENDING); 92a08727baSLinus Torvalds new |= WORK_STRUCT_FLAG_MASK & *work_data_bits(work); 93a08727baSLinus Torvalds atomic_long_set(&work->data, new); 94365970a1SDavid Howells } 95365970a1SDavid Howells 96365970a1SDavid Howells static inline void *get_wq_data(struct work_struct *work) 97365970a1SDavid Howells { 98a08727baSLinus Torvalds return (void *) (atomic_long_read(&work->data) & WORK_STRUCT_WQ_DATA_MASK); 99365970a1SDavid Howells } 100365970a1SDavid Howells 10168380b58SLinus Torvalds static int __run_work(struct cpu_workqueue_struct *cwq, struct work_struct *work) 10268380b58SLinus Torvalds { 10368380b58SLinus Torvalds int ret = 0; 10468380b58SLinus Torvalds unsigned long flags; 10568380b58SLinus Torvalds 10668380b58SLinus Torvalds spin_lock_irqsave(&cwq->lock, flags); 10768380b58SLinus Torvalds /* 10868380b58SLinus Torvalds * We need to re-validate the work info after we've gotten 10968380b58SLinus Torvalds * the cpu_workqueue lock. We can run the work now iff: 11068380b58SLinus Torvalds * 11168380b58SLinus Torvalds * - the wq_data still matches the cpu_workqueue_struct 11268380b58SLinus Torvalds * - AND the work is still marked pending 11368380b58SLinus Torvalds * - AND the work is still on a list (which will be this 11468380b58SLinus Torvalds * workqueue_struct list) 11568380b58SLinus Torvalds * 11668380b58SLinus Torvalds * All these conditions are important, because we 11768380b58SLinus Torvalds * need to protect against the work being run right 11868380b58SLinus Torvalds * now on another CPU (all but the last one might be 11968380b58SLinus Torvalds * true if it's currently running and has not been 12068380b58SLinus Torvalds * released yet, for example). 12168380b58SLinus Torvalds */ 12268380b58SLinus Torvalds if (get_wq_data(work) == cwq 12368380b58SLinus Torvalds && work_pending(work) 12468380b58SLinus Torvalds && !list_empty(&work->entry)) { 12568380b58SLinus Torvalds work_func_t f = work->func; 126b89deed3SOleg Nesterov cwq->current_work = work; 12768380b58SLinus Torvalds list_del_init(&work->entry); 12868380b58SLinus Torvalds spin_unlock_irqrestore(&cwq->lock, flags); 12968380b58SLinus Torvalds 130a08727baSLinus Torvalds if (!test_bit(WORK_STRUCT_NOAUTOREL, work_data_bits(work))) 13168380b58SLinus Torvalds work_release(work); 13268380b58SLinus Torvalds f(work); 13368380b58SLinus Torvalds 13468380b58SLinus Torvalds spin_lock_irqsave(&cwq->lock, flags); 135b89deed3SOleg Nesterov cwq->current_work = NULL; 13668380b58SLinus Torvalds ret = 1; 13768380b58SLinus Torvalds } 13868380b58SLinus Torvalds spin_unlock_irqrestore(&cwq->lock, flags); 13968380b58SLinus Torvalds return ret; 14068380b58SLinus Torvalds } 14168380b58SLinus Torvalds 14268380b58SLinus Torvalds /** 14368380b58SLinus Torvalds * run_scheduled_work - run scheduled work synchronously 14468380b58SLinus Torvalds * @work: work to run 14568380b58SLinus Torvalds * 14668380b58SLinus Torvalds * This checks if the work was pending, and runs it 14768380b58SLinus Torvalds * synchronously if so. It returns a boolean to indicate 14868380b58SLinus Torvalds * whether it had any scheduled work to run or not. 14968380b58SLinus Torvalds * 15068380b58SLinus Torvalds * NOTE! This _only_ works for normal work_structs. You 15168380b58SLinus Torvalds * CANNOT use this for delayed work, because the wq data 15268380b58SLinus Torvalds * for delayed work will not point properly to the per- 15368380b58SLinus Torvalds * CPU workqueue struct, but will change! 15468380b58SLinus Torvalds */ 15568380b58SLinus Torvalds int fastcall run_scheduled_work(struct work_struct *work) 15668380b58SLinus Torvalds { 15768380b58SLinus Torvalds for (;;) { 15868380b58SLinus Torvalds struct cpu_workqueue_struct *cwq; 15968380b58SLinus Torvalds 16068380b58SLinus Torvalds if (!work_pending(work)) 16168380b58SLinus Torvalds return 0; 16268380b58SLinus Torvalds if (list_empty(&work->entry)) 16368380b58SLinus Torvalds return 0; 16468380b58SLinus Torvalds /* NOTE! This depends intimately on __queue_work! */ 16568380b58SLinus Torvalds cwq = get_wq_data(work); 16668380b58SLinus Torvalds if (!cwq) 16768380b58SLinus Torvalds return 0; 16868380b58SLinus Torvalds if (__run_work(cwq, work)) 16968380b58SLinus Torvalds return 1; 17068380b58SLinus Torvalds } 17168380b58SLinus Torvalds } 17268380b58SLinus Torvalds EXPORT_SYMBOL(run_scheduled_work); 17368380b58SLinus Torvalds 174b89deed3SOleg Nesterov static void insert_work(struct cpu_workqueue_struct *cwq, 175b89deed3SOleg Nesterov struct work_struct *work, int tail) 176b89deed3SOleg Nesterov { 177b89deed3SOleg Nesterov set_wq_data(work, cwq); 178b89deed3SOleg Nesterov if (tail) 179b89deed3SOleg Nesterov list_add_tail(&work->entry, &cwq->worklist); 180b89deed3SOleg Nesterov else 181b89deed3SOleg Nesterov list_add(&work->entry, &cwq->worklist); 182b89deed3SOleg Nesterov wake_up(&cwq->more_work); 183b89deed3SOleg Nesterov } 184b89deed3SOleg Nesterov 1851da177e4SLinus Torvalds /* Preempt must be disabled. */ 1861da177e4SLinus Torvalds static void __queue_work(struct cpu_workqueue_struct *cwq, 1871da177e4SLinus Torvalds struct work_struct *work) 1881da177e4SLinus Torvalds { 1891da177e4SLinus Torvalds unsigned long flags; 1901da177e4SLinus Torvalds 1911da177e4SLinus Torvalds spin_lock_irqsave(&cwq->lock, flags); 192b89deed3SOleg Nesterov insert_work(cwq, work, 1); 1931da177e4SLinus Torvalds spin_unlock_irqrestore(&cwq->lock, flags); 1941da177e4SLinus Torvalds } 1951da177e4SLinus Torvalds 1960fcb78c2SRolf Eike Beer /** 1970fcb78c2SRolf Eike Beer * queue_work - queue work on a workqueue 1980fcb78c2SRolf Eike Beer * @wq: workqueue to use 1990fcb78c2SRolf Eike Beer * @work: work to queue 2000fcb78c2SRolf Eike Beer * 201057647fcSAlan Stern * Returns 0 if @work was already on a queue, non-zero otherwise. 2021da177e4SLinus Torvalds * 2031da177e4SLinus Torvalds * We queue the work to the CPU it was submitted, but there is no 2041da177e4SLinus Torvalds * guarantee that it will be processed by that CPU. 2051da177e4SLinus Torvalds */ 2061da177e4SLinus Torvalds int fastcall queue_work(struct workqueue_struct *wq, struct work_struct *work) 2071da177e4SLinus Torvalds { 2081da177e4SLinus Torvalds int ret = 0, cpu = get_cpu(); 2091da177e4SLinus Torvalds 210a08727baSLinus Torvalds if (!test_and_set_bit(WORK_STRUCT_PENDING, work_data_bits(work))) { 2111da177e4SLinus Torvalds if (unlikely(is_single_threaded(wq))) 212f756d5e2SNathan Lynch cpu = singlethread_cpu; 2131da177e4SLinus Torvalds BUG_ON(!list_empty(&work->entry)); 21489ada679SChristoph Lameter __queue_work(per_cpu_ptr(wq->cpu_wq, cpu), work); 2151da177e4SLinus Torvalds ret = 1; 2161da177e4SLinus Torvalds } 2171da177e4SLinus Torvalds put_cpu(); 2181da177e4SLinus Torvalds return ret; 2191da177e4SLinus Torvalds } 220ae90dd5dSDave Jones EXPORT_SYMBOL_GPL(queue_work); 2211da177e4SLinus Torvalds 22282f67cd9SIngo Molnar void delayed_work_timer_fn(unsigned long __data) 2231da177e4SLinus Torvalds { 22452bad64dSDavid Howells struct delayed_work *dwork = (struct delayed_work *)__data; 225365970a1SDavid Howells struct workqueue_struct *wq = get_wq_data(&dwork->work); 2261da177e4SLinus Torvalds int cpu = smp_processor_id(); 2271da177e4SLinus Torvalds 2281da177e4SLinus Torvalds if (unlikely(is_single_threaded(wq))) 229f756d5e2SNathan Lynch cpu = singlethread_cpu; 2301da177e4SLinus Torvalds 23152bad64dSDavid Howells __queue_work(per_cpu_ptr(wq->cpu_wq, cpu), &dwork->work); 2321da177e4SLinus Torvalds } 2331da177e4SLinus Torvalds 2340fcb78c2SRolf Eike Beer /** 2350fcb78c2SRolf Eike Beer * queue_delayed_work - queue work on a workqueue after delay 2360fcb78c2SRolf Eike Beer * @wq: workqueue to use 237af9997e4SRandy Dunlap * @dwork: delayable work to queue 2380fcb78c2SRolf Eike Beer * @delay: number of jiffies to wait before queueing 2390fcb78c2SRolf Eike Beer * 240057647fcSAlan Stern * Returns 0 if @work was already on a queue, non-zero otherwise. 2410fcb78c2SRolf Eike Beer */ 2421da177e4SLinus Torvalds int fastcall queue_delayed_work(struct workqueue_struct *wq, 24352bad64dSDavid Howells struct delayed_work *dwork, unsigned long delay) 2441da177e4SLinus Torvalds { 2451da177e4SLinus Torvalds int ret = 0; 24652bad64dSDavid Howells struct timer_list *timer = &dwork->timer; 24752bad64dSDavid Howells struct work_struct *work = &dwork->work; 24852bad64dSDavid Howells 24982f67cd9SIngo Molnar timer_stats_timer_set_start_info(timer); 25052bad64dSDavid Howells if (delay == 0) 25152bad64dSDavid Howells return queue_work(wq, work); 2521da177e4SLinus Torvalds 253a08727baSLinus Torvalds if (!test_and_set_bit(WORK_STRUCT_PENDING, work_data_bits(work))) { 2541da177e4SLinus Torvalds BUG_ON(timer_pending(timer)); 2551da177e4SLinus Torvalds BUG_ON(!list_empty(&work->entry)); 2561da177e4SLinus Torvalds 2571da177e4SLinus Torvalds /* This stores wq for the moment, for the timer_fn */ 258365970a1SDavid Howells set_wq_data(work, wq); 2591da177e4SLinus Torvalds timer->expires = jiffies + delay; 26052bad64dSDavid Howells timer->data = (unsigned long)dwork; 2611da177e4SLinus Torvalds timer->function = delayed_work_timer_fn; 2621da177e4SLinus Torvalds add_timer(timer); 2631da177e4SLinus Torvalds ret = 1; 2641da177e4SLinus Torvalds } 2651da177e4SLinus Torvalds return ret; 2661da177e4SLinus Torvalds } 267ae90dd5dSDave Jones EXPORT_SYMBOL_GPL(queue_delayed_work); 2681da177e4SLinus Torvalds 2690fcb78c2SRolf Eike Beer /** 2700fcb78c2SRolf Eike Beer * queue_delayed_work_on - queue work on specific CPU after delay 2710fcb78c2SRolf Eike Beer * @cpu: CPU number to execute work on 2720fcb78c2SRolf Eike Beer * @wq: workqueue to use 273af9997e4SRandy Dunlap * @dwork: work to queue 2740fcb78c2SRolf Eike Beer * @delay: number of jiffies to wait before queueing 2750fcb78c2SRolf Eike Beer * 276057647fcSAlan Stern * Returns 0 if @work was already on a queue, non-zero otherwise. 2770fcb78c2SRolf Eike Beer */ 2787a6bc1cdSVenkatesh Pallipadi int queue_delayed_work_on(int cpu, struct workqueue_struct *wq, 27952bad64dSDavid Howells struct delayed_work *dwork, unsigned long delay) 2807a6bc1cdSVenkatesh Pallipadi { 2817a6bc1cdSVenkatesh Pallipadi int ret = 0; 28252bad64dSDavid Howells struct timer_list *timer = &dwork->timer; 28352bad64dSDavid Howells struct work_struct *work = &dwork->work; 2847a6bc1cdSVenkatesh Pallipadi 285a08727baSLinus Torvalds if (!test_and_set_bit(WORK_STRUCT_PENDING, work_data_bits(work))) { 2867a6bc1cdSVenkatesh Pallipadi BUG_ON(timer_pending(timer)); 2877a6bc1cdSVenkatesh Pallipadi BUG_ON(!list_empty(&work->entry)); 2887a6bc1cdSVenkatesh Pallipadi 2897a6bc1cdSVenkatesh Pallipadi /* This stores wq for the moment, for the timer_fn */ 290365970a1SDavid Howells set_wq_data(work, wq); 2917a6bc1cdSVenkatesh Pallipadi timer->expires = jiffies + delay; 29252bad64dSDavid Howells timer->data = (unsigned long)dwork; 2937a6bc1cdSVenkatesh Pallipadi timer->function = delayed_work_timer_fn; 2947a6bc1cdSVenkatesh Pallipadi add_timer_on(timer, cpu); 2957a6bc1cdSVenkatesh Pallipadi ret = 1; 2967a6bc1cdSVenkatesh Pallipadi } 2977a6bc1cdSVenkatesh Pallipadi return ret; 2987a6bc1cdSVenkatesh Pallipadi } 299ae90dd5dSDave Jones EXPORT_SYMBOL_GPL(queue_delayed_work_on); 3001da177e4SLinus Torvalds 301858119e1SArjan van de Ven static void run_workqueue(struct cpu_workqueue_struct *cwq) 3021da177e4SLinus Torvalds { 3031da177e4SLinus Torvalds unsigned long flags; 3041da177e4SLinus Torvalds 3051da177e4SLinus Torvalds /* 3061da177e4SLinus Torvalds * Keep taking off work from the queue until 3071da177e4SLinus Torvalds * done. 3081da177e4SLinus Torvalds */ 3091da177e4SLinus Torvalds spin_lock_irqsave(&cwq->lock, flags); 3101da177e4SLinus Torvalds cwq->run_depth++; 3111da177e4SLinus Torvalds if (cwq->run_depth > 3) { 3121da177e4SLinus Torvalds /* morton gets to eat his hat */ 3131da177e4SLinus Torvalds printk("%s: recursion depth exceeded: %d\n", 3141da177e4SLinus Torvalds __FUNCTION__, cwq->run_depth); 3151da177e4SLinus Torvalds dump_stack(); 3161da177e4SLinus Torvalds } 3171da177e4SLinus Torvalds while (!list_empty(&cwq->worklist)) { 3181da177e4SLinus Torvalds struct work_struct *work = list_entry(cwq->worklist.next, 3191da177e4SLinus Torvalds struct work_struct, entry); 3206bb49e59SDavid Howells work_func_t f = work->func; 3211da177e4SLinus Torvalds 322b89deed3SOleg Nesterov cwq->current_work = work; 3231da177e4SLinus Torvalds list_del_init(cwq->worklist.next); 3241da177e4SLinus Torvalds spin_unlock_irqrestore(&cwq->lock, flags); 3251da177e4SLinus Torvalds 326365970a1SDavid Howells BUG_ON(get_wq_data(work) != cwq); 327a08727baSLinus Torvalds if (!test_bit(WORK_STRUCT_NOAUTOREL, work_data_bits(work))) 32865f27f38SDavid Howells work_release(work); 32965f27f38SDavid Howells f(work); 3301da177e4SLinus Torvalds 331d5abe669SPeter Zijlstra if (unlikely(in_atomic() || lockdep_depth(current) > 0)) { 332d5abe669SPeter Zijlstra printk(KERN_ERR "BUG: workqueue leaked lock or atomic: " 333d5abe669SPeter Zijlstra "%s/0x%08x/%d\n", 334d5abe669SPeter Zijlstra current->comm, preempt_count(), 335d5abe669SPeter Zijlstra current->pid); 336d5abe669SPeter Zijlstra printk(KERN_ERR " last function: "); 337d5abe669SPeter Zijlstra print_symbol("%s\n", (unsigned long)f); 338d5abe669SPeter Zijlstra debug_show_held_locks(current); 339d5abe669SPeter Zijlstra dump_stack(); 340d5abe669SPeter Zijlstra } 341d5abe669SPeter Zijlstra 3421da177e4SLinus Torvalds spin_lock_irqsave(&cwq->lock, flags); 343b89deed3SOleg Nesterov cwq->current_work = NULL; 3441da177e4SLinus Torvalds } 3451da177e4SLinus Torvalds cwq->run_depth--; 3461da177e4SLinus Torvalds spin_unlock_irqrestore(&cwq->lock, flags); 3471da177e4SLinus Torvalds } 3481da177e4SLinus Torvalds 3493af24433SOleg Nesterov /* 3503af24433SOleg Nesterov * NOTE: the caller must not touch *cwq if this func returns true 3513af24433SOleg Nesterov */ 3523af24433SOleg Nesterov static int cwq_should_stop(struct cpu_workqueue_struct *cwq) 3533af24433SOleg Nesterov { 3543af24433SOleg Nesterov int should_stop = cwq->should_stop; 3553af24433SOleg Nesterov 3563af24433SOleg Nesterov if (unlikely(should_stop)) { 3573af24433SOleg Nesterov spin_lock_irq(&cwq->lock); 3583af24433SOleg Nesterov should_stop = cwq->should_stop && list_empty(&cwq->worklist); 3593af24433SOleg Nesterov if (should_stop) 3603af24433SOleg Nesterov cwq->thread = NULL; 3613af24433SOleg Nesterov spin_unlock_irq(&cwq->lock); 3623af24433SOleg Nesterov } 3633af24433SOleg Nesterov 3643af24433SOleg Nesterov return should_stop; 3653af24433SOleg Nesterov } 3663af24433SOleg Nesterov 3671da177e4SLinus Torvalds static int worker_thread(void *__cwq) 3681da177e4SLinus Torvalds { 3691da177e4SLinus Torvalds struct cpu_workqueue_struct *cwq = __cwq; 3703af24433SOleg Nesterov DEFINE_WAIT(wait); 3711da177e4SLinus Torvalds struct k_sigaction sa; 3721da177e4SLinus Torvalds sigset_t blocked; 3731da177e4SLinus Torvalds 374319c2a98SOleg Nesterov if (!cwq->wq->freezeable) 3751da177e4SLinus Torvalds current->flags |= PF_NOFREEZE; 3761da177e4SLinus Torvalds 3771da177e4SLinus Torvalds set_user_nice(current, -5); 3781da177e4SLinus Torvalds 3791da177e4SLinus Torvalds /* Block and flush all signals */ 3801da177e4SLinus Torvalds sigfillset(&blocked); 3811da177e4SLinus Torvalds sigprocmask(SIG_BLOCK, &blocked, NULL); 3821da177e4SLinus Torvalds flush_signals(current); 3831da177e4SLinus Torvalds 38446934023SChristoph Lameter /* 38546934023SChristoph Lameter * We inherited MPOL_INTERLEAVE from the booting kernel. 38646934023SChristoph Lameter * Set MPOL_DEFAULT to insure node local allocations. 38746934023SChristoph Lameter */ 38846934023SChristoph Lameter numa_default_policy(); 38946934023SChristoph Lameter 3901da177e4SLinus Torvalds /* SIG_IGN makes children autoreap: see do_notify_parent(). */ 3911da177e4SLinus Torvalds sa.sa.sa_handler = SIG_IGN; 3921da177e4SLinus Torvalds sa.sa.sa_flags = 0; 3931da177e4SLinus Torvalds siginitset(&sa.sa.sa_mask, sigmask(SIGCHLD)); 3941da177e4SLinus Torvalds do_sigaction(SIGCHLD, &sa, (struct k_sigaction *)0); 3951da177e4SLinus Torvalds 3963af24433SOleg Nesterov for (;;) { 397319c2a98SOleg Nesterov if (cwq->wq->freezeable) 398341a5958SRafael J. Wysocki try_to_freeze(); 399341a5958SRafael J. Wysocki 4003af24433SOleg Nesterov prepare_to_wait(&cwq->more_work, &wait, TASK_INTERRUPTIBLE); 4013af24433SOleg Nesterov if (!cwq->should_stop && list_empty(&cwq->worklist)) 4021da177e4SLinus Torvalds schedule(); 4033af24433SOleg Nesterov finish_wait(&cwq->more_work, &wait); 4041da177e4SLinus Torvalds 4053af24433SOleg Nesterov if (cwq_should_stop(cwq)) 4063af24433SOleg Nesterov break; 4073af24433SOleg Nesterov 4081da177e4SLinus Torvalds run_workqueue(cwq); 4091da177e4SLinus Torvalds } 4103af24433SOleg Nesterov 4111da177e4SLinus Torvalds return 0; 4121da177e4SLinus Torvalds } 4131da177e4SLinus Torvalds 414fc2e4d70SOleg Nesterov struct wq_barrier { 415fc2e4d70SOleg Nesterov struct work_struct work; 416fc2e4d70SOleg Nesterov struct completion done; 417fc2e4d70SOleg Nesterov }; 418fc2e4d70SOleg Nesterov 419fc2e4d70SOleg Nesterov static void wq_barrier_func(struct work_struct *work) 420fc2e4d70SOleg Nesterov { 421fc2e4d70SOleg Nesterov struct wq_barrier *barr = container_of(work, struct wq_barrier, work); 422fc2e4d70SOleg Nesterov complete(&barr->done); 423fc2e4d70SOleg Nesterov } 424fc2e4d70SOleg Nesterov 42583c22520SOleg Nesterov static void insert_wq_barrier(struct cpu_workqueue_struct *cwq, 42683c22520SOleg Nesterov struct wq_barrier *barr, int tail) 427fc2e4d70SOleg Nesterov { 428fc2e4d70SOleg Nesterov INIT_WORK(&barr->work, wq_barrier_func); 429fc2e4d70SOleg Nesterov __set_bit(WORK_STRUCT_PENDING, work_data_bits(&barr->work)); 430fc2e4d70SOleg Nesterov 431fc2e4d70SOleg Nesterov init_completion(&barr->done); 43283c22520SOleg Nesterov 43383c22520SOleg Nesterov insert_work(cwq, &barr->work, tail); 434fc2e4d70SOleg Nesterov } 435fc2e4d70SOleg Nesterov 4361da177e4SLinus Torvalds static void flush_cpu_workqueue(struct cpu_workqueue_struct *cwq) 4371da177e4SLinus Torvalds { 4381da177e4SLinus Torvalds if (cwq->thread == current) { 4391da177e4SLinus Torvalds /* 4401da177e4SLinus Torvalds * Probably keventd trying to flush its own queue. So simply run 4411da177e4SLinus Torvalds * it by hand rather than deadlocking. 4421da177e4SLinus Torvalds */ 4431da177e4SLinus Torvalds run_workqueue(cwq); 4441da177e4SLinus Torvalds } else { 445fc2e4d70SOleg Nesterov struct wq_barrier barr; 44683c22520SOleg Nesterov int active = 0; 4471da177e4SLinus Torvalds 44883c22520SOleg Nesterov spin_lock_irq(&cwq->lock); 44983c22520SOleg Nesterov if (!list_empty(&cwq->worklist) || cwq->current_work != NULL) { 45083c22520SOleg Nesterov insert_wq_barrier(cwq, &barr, 1); 45183c22520SOleg Nesterov active = 1; 45283c22520SOleg Nesterov } 45383c22520SOleg Nesterov spin_unlock_irq(&cwq->lock); 4541da177e4SLinus Torvalds 455d721304dSOleg Nesterov if (active) 456fc2e4d70SOleg Nesterov wait_for_completion(&barr.done); 4571da177e4SLinus Torvalds } 45883c22520SOleg Nesterov } 4591da177e4SLinus Torvalds 4600fcb78c2SRolf Eike Beer /** 4611da177e4SLinus Torvalds * flush_workqueue - ensure that any scheduled work has run to completion. 4620fcb78c2SRolf Eike Beer * @wq: workqueue to flush 4631da177e4SLinus Torvalds * 4641da177e4SLinus Torvalds * Forces execution of the workqueue and blocks until its completion. 4651da177e4SLinus Torvalds * This is typically used in driver shutdown handlers. 4661da177e4SLinus Torvalds * 467fc2e4d70SOleg Nesterov * We sleep until all works which were queued on entry have been handled, 468fc2e4d70SOleg Nesterov * but we are not livelocked by new incoming ones. 4691da177e4SLinus Torvalds * 4701da177e4SLinus Torvalds * This function used to run the workqueues itself. Now we just wait for the 4711da177e4SLinus Torvalds * helper threads to do it. 4721da177e4SLinus Torvalds */ 4731da177e4SLinus Torvalds void fastcall flush_workqueue(struct workqueue_struct *wq) 4741da177e4SLinus Torvalds { 4753af24433SOleg Nesterov if (is_single_threaded(wq)) 476f756d5e2SNathan Lynch flush_cpu_workqueue(per_cpu_ptr(wq->cpu_wq, singlethread_cpu)); 4773af24433SOleg Nesterov else { 4781da177e4SLinus Torvalds int cpu; 4791da177e4SLinus Torvalds 4803af24433SOleg Nesterov for_each_cpu_mask(cpu, cpu_populated_map) 48189ada679SChristoph Lameter flush_cpu_workqueue(per_cpu_ptr(wq->cpu_wq, cpu)); 4821da177e4SLinus Torvalds } 4831da177e4SLinus Torvalds } 484ae90dd5dSDave Jones EXPORT_SYMBOL_GPL(flush_workqueue); 4851da177e4SLinus Torvalds 486b89deed3SOleg Nesterov static void wait_on_work(struct cpu_workqueue_struct *cwq, 487b89deed3SOleg Nesterov struct work_struct *work) 488b89deed3SOleg Nesterov { 489b89deed3SOleg Nesterov struct wq_barrier barr; 490b89deed3SOleg Nesterov int running = 0; 491b89deed3SOleg Nesterov 492b89deed3SOleg Nesterov spin_lock_irq(&cwq->lock); 493b89deed3SOleg Nesterov if (unlikely(cwq->current_work == work)) { 49483c22520SOleg Nesterov insert_wq_barrier(cwq, &barr, 0); 495b89deed3SOleg Nesterov running = 1; 496b89deed3SOleg Nesterov } 497b89deed3SOleg Nesterov spin_unlock_irq(&cwq->lock); 498b89deed3SOleg Nesterov 4993af24433SOleg Nesterov if (unlikely(running)) 500b89deed3SOleg Nesterov wait_for_completion(&barr.done); 501b89deed3SOleg Nesterov } 502b89deed3SOleg Nesterov 503b89deed3SOleg Nesterov /** 504b89deed3SOleg Nesterov * flush_work - block until a work_struct's callback has terminated 505b89deed3SOleg Nesterov * @wq: the workqueue on which the work is queued 506b89deed3SOleg Nesterov * @work: the work which is to be flushed 507b89deed3SOleg Nesterov * 508b89deed3SOleg Nesterov * flush_work() will attempt to cancel the work if it is queued. If the work's 509b89deed3SOleg Nesterov * callback appears to be running, flush_work() will block until it has 510b89deed3SOleg Nesterov * completed. 511b89deed3SOleg Nesterov * 512b89deed3SOleg Nesterov * flush_work() is designed to be used when the caller is tearing down data 513b89deed3SOleg Nesterov * structures which the callback function operates upon. It is expected that, 514b89deed3SOleg Nesterov * prior to calling flush_work(), the caller has arranged for the work to not 515b89deed3SOleg Nesterov * be requeued. 516b89deed3SOleg Nesterov */ 517b89deed3SOleg Nesterov void flush_work(struct workqueue_struct *wq, struct work_struct *work) 518b89deed3SOleg Nesterov { 519b89deed3SOleg Nesterov struct cpu_workqueue_struct *cwq; 520b89deed3SOleg Nesterov 521b89deed3SOleg Nesterov cwq = get_wq_data(work); 522b89deed3SOleg Nesterov /* Was it ever queued ? */ 523b89deed3SOleg Nesterov if (!cwq) 5243af24433SOleg Nesterov return; 525b89deed3SOleg Nesterov 526b89deed3SOleg Nesterov /* 5273af24433SOleg Nesterov * This work can't be re-queued, no need to re-check that 5283af24433SOleg Nesterov * get_wq_data() is still the same when we take cwq->lock. 529b89deed3SOleg Nesterov */ 530b89deed3SOleg Nesterov spin_lock_irq(&cwq->lock); 531b89deed3SOleg Nesterov list_del_init(&work->entry); 532b89deed3SOleg Nesterov work_release(work); 533b89deed3SOleg Nesterov spin_unlock_irq(&cwq->lock); 534b89deed3SOleg Nesterov 5353af24433SOleg Nesterov if (is_single_threaded(wq)) 536b89deed3SOleg Nesterov wait_on_work(per_cpu_ptr(wq->cpu_wq, singlethread_cpu), work); 5373af24433SOleg Nesterov else { 538b89deed3SOleg Nesterov int cpu; 539b89deed3SOleg Nesterov 5403af24433SOleg Nesterov for_each_cpu_mask(cpu, cpu_populated_map) 541b89deed3SOleg Nesterov wait_on_work(per_cpu_ptr(wq->cpu_wq, cpu), work); 542b89deed3SOleg Nesterov } 543b89deed3SOleg Nesterov } 544b89deed3SOleg Nesterov EXPORT_SYMBOL_GPL(flush_work); 545b89deed3SOleg Nesterov 5461da177e4SLinus Torvalds 5471da177e4SLinus Torvalds static struct workqueue_struct *keventd_wq; 5481da177e4SLinus Torvalds 5490fcb78c2SRolf Eike Beer /** 5500fcb78c2SRolf Eike Beer * schedule_work - put work task in global workqueue 5510fcb78c2SRolf Eike Beer * @work: job to be done 5520fcb78c2SRolf Eike Beer * 5530fcb78c2SRolf Eike Beer * This puts a job in the kernel-global workqueue. 5540fcb78c2SRolf Eike Beer */ 5551da177e4SLinus Torvalds int fastcall schedule_work(struct work_struct *work) 5561da177e4SLinus Torvalds { 5571da177e4SLinus Torvalds return queue_work(keventd_wq, work); 5581da177e4SLinus Torvalds } 559ae90dd5dSDave Jones EXPORT_SYMBOL(schedule_work); 5601da177e4SLinus Torvalds 5610fcb78c2SRolf Eike Beer /** 5620fcb78c2SRolf Eike Beer * schedule_delayed_work - put work task in global workqueue after delay 56352bad64dSDavid Howells * @dwork: job to be done 56452bad64dSDavid Howells * @delay: number of jiffies to wait or 0 for immediate execution 5650fcb78c2SRolf Eike Beer * 5660fcb78c2SRolf Eike Beer * After waiting for a given time this puts a job in the kernel-global 5670fcb78c2SRolf Eike Beer * workqueue. 5680fcb78c2SRolf Eike Beer */ 56982f67cd9SIngo Molnar int fastcall schedule_delayed_work(struct delayed_work *dwork, 57082f67cd9SIngo Molnar unsigned long delay) 5711da177e4SLinus Torvalds { 57282f67cd9SIngo Molnar timer_stats_timer_set_start_info(&dwork->timer); 57352bad64dSDavid Howells return queue_delayed_work(keventd_wq, dwork, delay); 5741da177e4SLinus Torvalds } 575ae90dd5dSDave Jones EXPORT_SYMBOL(schedule_delayed_work); 5761da177e4SLinus Torvalds 5770fcb78c2SRolf Eike Beer /** 5780fcb78c2SRolf Eike Beer * schedule_delayed_work_on - queue work in global workqueue on CPU after delay 5790fcb78c2SRolf Eike Beer * @cpu: cpu to use 58052bad64dSDavid Howells * @dwork: job to be done 5810fcb78c2SRolf Eike Beer * @delay: number of jiffies to wait 5820fcb78c2SRolf Eike Beer * 5830fcb78c2SRolf Eike Beer * After waiting for a given time this puts a job in the kernel-global 5840fcb78c2SRolf Eike Beer * workqueue on the specified CPU. 5850fcb78c2SRolf Eike Beer */ 5861da177e4SLinus Torvalds int schedule_delayed_work_on(int cpu, 58752bad64dSDavid Howells struct delayed_work *dwork, unsigned long delay) 5881da177e4SLinus Torvalds { 58952bad64dSDavid Howells return queue_delayed_work_on(cpu, keventd_wq, dwork, delay); 5901da177e4SLinus Torvalds } 591ae90dd5dSDave Jones EXPORT_SYMBOL(schedule_delayed_work_on); 5921da177e4SLinus Torvalds 593b6136773SAndrew Morton /** 594b6136773SAndrew Morton * schedule_on_each_cpu - call a function on each online CPU from keventd 595b6136773SAndrew Morton * @func: the function to call 596b6136773SAndrew Morton * 597b6136773SAndrew Morton * Returns zero on success. 598b6136773SAndrew Morton * Returns -ve errno on failure. 599b6136773SAndrew Morton * 600b6136773SAndrew Morton * Appears to be racy against CPU hotplug. 601b6136773SAndrew Morton * 602b6136773SAndrew Morton * schedule_on_each_cpu() is very slow. 603b6136773SAndrew Morton */ 60465f27f38SDavid Howells int schedule_on_each_cpu(work_func_t func) 60515316ba8SChristoph Lameter { 60615316ba8SChristoph Lameter int cpu; 607b6136773SAndrew Morton struct work_struct *works; 60815316ba8SChristoph Lameter 609b6136773SAndrew Morton works = alloc_percpu(struct work_struct); 610b6136773SAndrew Morton if (!works) 61115316ba8SChristoph Lameter return -ENOMEM; 612b6136773SAndrew Morton 613e18f3ffbSAndrew Morton preempt_disable(); /* CPU hotplug */ 61415316ba8SChristoph Lameter for_each_online_cpu(cpu) { 6159bfb1839SIngo Molnar struct work_struct *work = per_cpu_ptr(works, cpu); 6169bfb1839SIngo Molnar 6179bfb1839SIngo Molnar INIT_WORK(work, func); 6189bfb1839SIngo Molnar set_bit(WORK_STRUCT_PENDING, work_data_bits(work)); 6199bfb1839SIngo Molnar __queue_work(per_cpu_ptr(keventd_wq->cpu_wq, cpu), work); 62015316ba8SChristoph Lameter } 621e18f3ffbSAndrew Morton preempt_enable(); 62215316ba8SChristoph Lameter flush_workqueue(keventd_wq); 623b6136773SAndrew Morton free_percpu(works); 62415316ba8SChristoph Lameter return 0; 62515316ba8SChristoph Lameter } 62615316ba8SChristoph Lameter 6271da177e4SLinus Torvalds void flush_scheduled_work(void) 6281da177e4SLinus Torvalds { 6291da177e4SLinus Torvalds flush_workqueue(keventd_wq); 6301da177e4SLinus Torvalds } 631ae90dd5dSDave Jones EXPORT_SYMBOL(flush_scheduled_work); 6321da177e4SLinus Torvalds 633b89deed3SOleg Nesterov void flush_work_keventd(struct work_struct *work) 634b89deed3SOleg Nesterov { 635b89deed3SOleg Nesterov flush_work(keventd_wq, work); 636b89deed3SOleg Nesterov } 637b89deed3SOleg Nesterov EXPORT_SYMBOL(flush_work_keventd); 638b89deed3SOleg Nesterov 6391da177e4SLinus Torvalds /** 64072fd4a35SRobert P. J. Day * cancel_rearming_delayed_workqueue - reliably kill off a delayed work whose handler rearms the delayed work. 6411da177e4SLinus Torvalds * @wq: the controlling workqueue structure 64252bad64dSDavid Howells * @dwork: the delayed work struct 6431da177e4SLinus Torvalds */ 64481ddef77SJames Bottomley void cancel_rearming_delayed_workqueue(struct workqueue_struct *wq, 64552bad64dSDavid Howells struct delayed_work *dwork) 6461da177e4SLinus Torvalds { 64752bad64dSDavid Howells while (!cancel_delayed_work(dwork)) 6481da177e4SLinus Torvalds flush_workqueue(wq); 6491da177e4SLinus Torvalds } 65081ddef77SJames Bottomley EXPORT_SYMBOL(cancel_rearming_delayed_workqueue); 6511da177e4SLinus Torvalds 6521da177e4SLinus Torvalds /** 65372fd4a35SRobert P. J. Day * cancel_rearming_delayed_work - reliably kill off a delayed keventd work whose handler rearms the delayed work. 65452bad64dSDavid Howells * @dwork: the delayed work struct 6551da177e4SLinus Torvalds */ 65652bad64dSDavid Howells void cancel_rearming_delayed_work(struct delayed_work *dwork) 6571da177e4SLinus Torvalds { 65852bad64dSDavid Howells cancel_rearming_delayed_workqueue(keventd_wq, dwork); 6591da177e4SLinus Torvalds } 6601da177e4SLinus Torvalds EXPORT_SYMBOL(cancel_rearming_delayed_work); 6611da177e4SLinus Torvalds 6621fa44ecaSJames Bottomley /** 6631fa44ecaSJames Bottomley * execute_in_process_context - reliably execute the routine with user context 6641fa44ecaSJames Bottomley * @fn: the function to execute 6651fa44ecaSJames Bottomley * @ew: guaranteed storage for the execute work structure (must 6661fa44ecaSJames Bottomley * be available when the work executes) 6671fa44ecaSJames Bottomley * 6681fa44ecaSJames Bottomley * Executes the function immediately if process context is available, 6691fa44ecaSJames Bottomley * otherwise schedules the function for delayed execution. 6701fa44ecaSJames Bottomley * 6711fa44ecaSJames Bottomley * Returns: 0 - function was executed 6721fa44ecaSJames Bottomley * 1 - function was scheduled for execution 6731fa44ecaSJames Bottomley */ 67465f27f38SDavid Howells int execute_in_process_context(work_func_t fn, struct execute_work *ew) 6751fa44ecaSJames Bottomley { 6761fa44ecaSJames Bottomley if (!in_interrupt()) { 67765f27f38SDavid Howells fn(&ew->work); 6781fa44ecaSJames Bottomley return 0; 6791fa44ecaSJames Bottomley } 6801fa44ecaSJames Bottomley 68165f27f38SDavid Howells INIT_WORK(&ew->work, fn); 6821fa44ecaSJames Bottomley schedule_work(&ew->work); 6831fa44ecaSJames Bottomley 6841fa44ecaSJames Bottomley return 1; 6851fa44ecaSJames Bottomley } 6861fa44ecaSJames Bottomley EXPORT_SYMBOL_GPL(execute_in_process_context); 6871fa44ecaSJames Bottomley 6881da177e4SLinus Torvalds int keventd_up(void) 6891da177e4SLinus Torvalds { 6901da177e4SLinus Torvalds return keventd_wq != NULL; 6911da177e4SLinus Torvalds } 6921da177e4SLinus Torvalds 6931da177e4SLinus Torvalds int current_is_keventd(void) 6941da177e4SLinus Torvalds { 6951da177e4SLinus Torvalds struct cpu_workqueue_struct *cwq; 6961da177e4SLinus Torvalds int cpu = smp_processor_id(); /* preempt-safe: keventd is per-cpu */ 6971da177e4SLinus Torvalds int ret = 0; 6981da177e4SLinus Torvalds 6991da177e4SLinus Torvalds BUG_ON(!keventd_wq); 7001da177e4SLinus Torvalds 70189ada679SChristoph Lameter cwq = per_cpu_ptr(keventd_wq->cpu_wq, cpu); 7021da177e4SLinus Torvalds if (current == cwq->thread) 7031da177e4SLinus Torvalds ret = 1; 7041da177e4SLinus Torvalds 7051da177e4SLinus Torvalds return ret; 7061da177e4SLinus Torvalds 7071da177e4SLinus Torvalds } 7081da177e4SLinus Torvalds 7093af24433SOleg Nesterov static struct cpu_workqueue_struct * 7103af24433SOleg Nesterov init_cpu_workqueue(struct workqueue_struct *wq, int cpu) 7111da177e4SLinus Torvalds { 71289ada679SChristoph Lameter struct cpu_workqueue_struct *cwq = per_cpu_ptr(wq->cpu_wq, cpu); 7133af24433SOleg Nesterov 7143af24433SOleg Nesterov cwq->wq = wq; 7153af24433SOleg Nesterov spin_lock_init(&cwq->lock); 7163af24433SOleg Nesterov INIT_LIST_HEAD(&cwq->worklist); 7173af24433SOleg Nesterov init_waitqueue_head(&cwq->more_work); 7183af24433SOleg Nesterov 7193af24433SOleg Nesterov return cwq; 7203af24433SOleg Nesterov } 7213af24433SOleg Nesterov 7223af24433SOleg Nesterov static int create_workqueue_thread(struct cpu_workqueue_struct *cwq, int cpu) 7233af24433SOleg Nesterov { 7243af24433SOleg Nesterov struct workqueue_struct *wq = cwq->wq; 7253af24433SOleg Nesterov const char *fmt = is_single_threaded(wq) ? "%s" : "%s/%d"; 7263af24433SOleg Nesterov struct task_struct *p; 7273af24433SOleg Nesterov 7283af24433SOleg Nesterov p = kthread_create(worker_thread, cwq, fmt, wq->name, cpu); 7293af24433SOleg Nesterov /* 7303af24433SOleg Nesterov * Nobody can add the work_struct to this cwq, 7313af24433SOleg Nesterov * if (caller is __create_workqueue) 7323af24433SOleg Nesterov * nobody should see this wq 7333af24433SOleg Nesterov * else // caller is CPU_UP_PREPARE 7343af24433SOleg Nesterov * cpu is not on cpu_online_map 7353af24433SOleg Nesterov * so we can abort safely. 7363af24433SOleg Nesterov */ 7373af24433SOleg Nesterov if (IS_ERR(p)) 7383af24433SOleg Nesterov return PTR_ERR(p); 7393af24433SOleg Nesterov 7403af24433SOleg Nesterov cwq->thread = p; 7413af24433SOleg Nesterov cwq->should_stop = 0; 7423af24433SOleg Nesterov if (!is_single_threaded(wq)) 7433af24433SOleg Nesterov kthread_bind(p, cpu); 7443af24433SOleg Nesterov 7453af24433SOleg Nesterov if (is_single_threaded(wq) || cpu_online(cpu)) 7463af24433SOleg Nesterov wake_up_process(p); 7473af24433SOleg Nesterov 7483af24433SOleg Nesterov return 0; 7493af24433SOleg Nesterov } 7503af24433SOleg Nesterov 7513af24433SOleg Nesterov struct workqueue_struct *__create_workqueue(const char *name, 7523af24433SOleg Nesterov int singlethread, int freezeable) 7533af24433SOleg Nesterov { 7543af24433SOleg Nesterov struct workqueue_struct *wq; 7553af24433SOleg Nesterov struct cpu_workqueue_struct *cwq; 7563af24433SOleg Nesterov int err = 0, cpu; 7573af24433SOleg Nesterov 7583af24433SOleg Nesterov wq = kzalloc(sizeof(*wq), GFP_KERNEL); 7593af24433SOleg Nesterov if (!wq) 7603af24433SOleg Nesterov return NULL; 7613af24433SOleg Nesterov 7623af24433SOleg Nesterov wq->cpu_wq = alloc_percpu(struct cpu_workqueue_struct); 7633af24433SOleg Nesterov if (!wq->cpu_wq) { 7643af24433SOleg Nesterov kfree(wq); 7653af24433SOleg Nesterov return NULL; 7663af24433SOleg Nesterov } 7673af24433SOleg Nesterov 7683af24433SOleg Nesterov wq->name = name; 7693af24433SOleg Nesterov wq->freezeable = freezeable; 7703af24433SOleg Nesterov 7713af24433SOleg Nesterov if (singlethread) { 7723af24433SOleg Nesterov INIT_LIST_HEAD(&wq->list); 7733af24433SOleg Nesterov cwq = init_cpu_workqueue(wq, singlethread_cpu); 7743af24433SOleg Nesterov err = create_workqueue_thread(cwq, singlethread_cpu); 7753af24433SOleg Nesterov } else { 7763af24433SOleg Nesterov mutex_lock(&workqueue_mutex); 7773af24433SOleg Nesterov list_add(&wq->list, &workqueues); 7783af24433SOleg Nesterov 7793af24433SOleg Nesterov for_each_possible_cpu(cpu) { 7803af24433SOleg Nesterov cwq = init_cpu_workqueue(wq, cpu); 7813af24433SOleg Nesterov if (err || !cpu_online(cpu)) 7823af24433SOleg Nesterov continue; 7833af24433SOleg Nesterov err = create_workqueue_thread(cwq, cpu); 7843af24433SOleg Nesterov } 7853af24433SOleg Nesterov mutex_unlock(&workqueue_mutex); 7863af24433SOleg Nesterov } 7873af24433SOleg Nesterov 7883af24433SOleg Nesterov if (err) { 7893af24433SOleg Nesterov destroy_workqueue(wq); 7903af24433SOleg Nesterov wq = NULL; 7913af24433SOleg Nesterov } 7923af24433SOleg Nesterov return wq; 7933af24433SOleg Nesterov } 7943af24433SOleg Nesterov EXPORT_SYMBOL_GPL(__create_workqueue); 7953af24433SOleg Nesterov 7963af24433SOleg Nesterov static void cleanup_workqueue_thread(struct cpu_workqueue_struct *cwq, int cpu) 7973af24433SOleg Nesterov { 7983af24433SOleg Nesterov struct wq_barrier barr; 7993af24433SOleg Nesterov int alive = 0; 8001da177e4SLinus Torvalds 8011da177e4SLinus Torvalds spin_lock_irq(&cwq->lock); 8023af24433SOleg Nesterov if (cwq->thread != NULL) { 8033af24433SOleg Nesterov insert_wq_barrier(cwq, &barr, 1); 8043af24433SOleg Nesterov cwq->should_stop = 1; 8053af24433SOleg Nesterov alive = 1; 8061da177e4SLinus Torvalds } 8071da177e4SLinus Torvalds spin_unlock_irq(&cwq->lock); 8083af24433SOleg Nesterov 8093af24433SOleg Nesterov if (alive) { 8103af24433SOleg Nesterov wait_for_completion(&barr.done); 8113af24433SOleg Nesterov 8123af24433SOleg Nesterov while (unlikely(cwq->thread != NULL)) 8133af24433SOleg Nesterov cpu_relax(); 8143af24433SOleg Nesterov /* 8153af24433SOleg Nesterov * Wait until cwq->thread unlocks cwq->lock, 8163af24433SOleg Nesterov * it won't touch *cwq after that. 8173af24433SOleg Nesterov */ 8183af24433SOleg Nesterov smp_rmb(); 8193af24433SOleg Nesterov spin_unlock_wait(&cwq->lock); 8203af24433SOleg Nesterov } 8211da177e4SLinus Torvalds } 8221da177e4SLinus Torvalds 8233af24433SOleg Nesterov /** 8243af24433SOleg Nesterov * destroy_workqueue - safely terminate a workqueue 8253af24433SOleg Nesterov * @wq: target workqueue 8263af24433SOleg Nesterov * 8273af24433SOleg Nesterov * Safely destroy a workqueue. All work currently pending will be done first. 8283af24433SOleg Nesterov */ 8293af24433SOleg Nesterov void destroy_workqueue(struct workqueue_struct *wq) 8303af24433SOleg Nesterov { 8313af24433SOleg Nesterov struct cpu_workqueue_struct *cwq; 8323af24433SOleg Nesterov 8333af24433SOleg Nesterov if (is_single_threaded(wq)) { 8343af24433SOleg Nesterov cwq = per_cpu_ptr(wq->cpu_wq, singlethread_cpu); 8353af24433SOleg Nesterov cleanup_workqueue_thread(cwq, singlethread_cpu); 8363af24433SOleg Nesterov } else { 8373af24433SOleg Nesterov int cpu; 8383af24433SOleg Nesterov 8393af24433SOleg Nesterov mutex_lock(&workqueue_mutex); 8403af24433SOleg Nesterov list_del(&wq->list); 8413af24433SOleg Nesterov mutex_unlock(&workqueue_mutex); 8423af24433SOleg Nesterov 8433af24433SOleg Nesterov for_each_cpu_mask(cpu, cpu_populated_map) { 8443af24433SOleg Nesterov cwq = per_cpu_ptr(wq->cpu_wq, cpu); 8453af24433SOleg Nesterov cleanup_workqueue_thread(cwq, cpu); 8463af24433SOleg Nesterov } 8473af24433SOleg Nesterov } 8483af24433SOleg Nesterov 8493af24433SOleg Nesterov free_percpu(wq->cpu_wq); 8503af24433SOleg Nesterov kfree(wq); 8513af24433SOleg Nesterov } 8523af24433SOleg Nesterov EXPORT_SYMBOL_GPL(destroy_workqueue); 8533af24433SOleg Nesterov 8549c7b216dSChandra Seetharaman static int __devinit workqueue_cpu_callback(struct notifier_block *nfb, 8551da177e4SLinus Torvalds unsigned long action, 8561da177e4SLinus Torvalds void *hcpu) 8571da177e4SLinus Torvalds { 8583af24433SOleg Nesterov unsigned int cpu = (unsigned long)hcpu; 8593af24433SOleg Nesterov struct cpu_workqueue_struct *cwq; 8601da177e4SLinus Torvalds struct workqueue_struct *wq; 8611da177e4SLinus Torvalds 8621da177e4SLinus Torvalds switch (action) { 8633af24433SOleg Nesterov case CPU_LOCK_ACQUIRE: 8649b41ea72SAndrew Morton mutex_lock(&workqueue_mutex); 8653af24433SOleg Nesterov return NOTIFY_OK; 8663af24433SOleg Nesterov 8673af24433SOleg Nesterov case CPU_LOCK_RELEASE: 8683af24433SOleg Nesterov mutex_unlock(&workqueue_mutex); 8693af24433SOleg Nesterov return NOTIFY_OK; 8703af24433SOleg Nesterov 8713af24433SOleg Nesterov case CPU_UP_PREPARE: 8723af24433SOleg Nesterov cpu_set(cpu, cpu_populated_map); 8733af24433SOleg Nesterov } 8743af24433SOleg Nesterov 8751da177e4SLinus Torvalds list_for_each_entry(wq, &workqueues, list) { 8763af24433SOleg Nesterov cwq = per_cpu_ptr(wq->cpu_wq, cpu); 8773af24433SOleg Nesterov 8783af24433SOleg Nesterov switch (action) { 8793af24433SOleg Nesterov case CPU_UP_PREPARE: 8803af24433SOleg Nesterov if (!create_workqueue_thread(cwq, cpu)) 8811da177e4SLinus Torvalds break; 8823af24433SOleg Nesterov printk(KERN_ERR "workqueue for %i failed\n", cpu); 8833af24433SOleg Nesterov return NOTIFY_BAD; 8841da177e4SLinus Torvalds 8851da177e4SLinus Torvalds case CPU_ONLINE: 88689ada679SChristoph Lameter wake_up_process(cwq->thread); 8871da177e4SLinus Torvalds break; 8881da177e4SLinus Torvalds 8891da177e4SLinus Torvalds case CPU_UP_CANCELED: 8903af24433SOleg Nesterov if (cwq->thread) 8913af24433SOleg Nesterov wake_up_process(cwq->thread); 8921da177e4SLinus Torvalds case CPU_DEAD: 8933af24433SOleg Nesterov cleanup_workqueue_thread(cwq, cpu); 8941da177e4SLinus Torvalds break; 8951da177e4SLinus Torvalds } 8963af24433SOleg Nesterov } 8971da177e4SLinus Torvalds 8981da177e4SLinus Torvalds return NOTIFY_OK; 8991da177e4SLinus Torvalds } 9001da177e4SLinus Torvalds 9011da177e4SLinus Torvalds void init_workqueues(void) 9021da177e4SLinus Torvalds { 9033af24433SOleg Nesterov cpu_populated_map = cpu_online_map; 904f756d5e2SNathan Lynch singlethread_cpu = first_cpu(cpu_possible_map); 9051da177e4SLinus Torvalds hotcpu_notifier(workqueue_cpu_callback, 0); 9061da177e4SLinus Torvalds keventd_wq = create_workqueue("events"); 9071da177e4SLinus Torvalds BUG_ON(!keventd_wq); 9081da177e4SLinus Torvalds } 909