ARM: tegra3: initialize pll_a during boot
[linux-2.6.git] / kernel / workqueue.c
1 /*
2  * kernel/workqueue.c - generic async execution with shared worker pool
3  *
4  * Copyright (C) 2002           Ingo Molnar
5  *
6  *   Derived from the taskqueue/keventd code by:
7  *     David Woodhouse <dwmw2@infradead.org>
8  *     Andrew Morton
9  *     Kai Petzke <wpp@marie.physik.tu-berlin.de>
10  *     Theodore Ts'o <tytso@mit.edu>
11  *
12  * Made to use alloc_percpu by Christoph Lameter.
13  *
14  * Copyright (C) 2010           SUSE Linux Products GmbH
15  * Copyright (C) 2010           Tejun Heo <tj@kernel.org>
16  *
17  * This is the generic async execution mechanism.  Work items as are
18  * executed in process context.  The worker pool is shared and
19  * automatically managed.  There is one worker pool for each CPU and
20  * one extra for works which are better served by workers which are
21  * not bound to any specific CPU.
22  *
23  * Please read Documentation/workqueue.txt for details.
24  */
25
26 #include <linux/module.h>
27 #include <linux/kernel.h>
28 #include <linux/sched.h>
29 #include <linux/init.h>
30 #include <linux/signal.h>
31 #include <linux/completion.h>
32 #include <linux/workqueue.h>
33 #include <linux/slab.h>
34 #include <linux/cpu.h>
35 #include <linux/notifier.h>
36 #include <linux/kthread.h>
37 #include <linux/hardirq.h>
38 #include <linux/mempolicy.h>
39 #include <linux/freezer.h>
40 #include <linux/kallsyms.h>
41 #include <linux/debug_locks.h>
42 #include <linux/lockdep.h>
43 #include <linux/idr.h>
44
45 #include "workqueue_sched.h"
46
47 enum {
48         /*
49          * global_cwq flags
50          *
51          * A bound gcwq is either associated or disassociated with its CPU.
52          * While associated (!DISASSOCIATED), all workers are bound to the
53          * CPU and none has %WORKER_UNBOUND set and concurrency management
54          * is in effect.
55          *
56          * While DISASSOCIATED, the cpu may be offline and all workers have
57          * %WORKER_UNBOUND set and concurrency management disabled, and may
58          * be executing on any CPU.  The gcwq behaves as an unbound one.
59          *
60          * Note that DISASSOCIATED can be flipped only while holding
61          * managership of all pools on the gcwq to avoid changing binding
62          * state while create_worker() is in progress.
63          */
64         GCWQ_DISASSOCIATED      = 1 << 0,       /* cpu can't serve workers */
65         GCWQ_FREEZING           = 1 << 1,       /* freeze in progress */
66
67         /* pool flags */
68         POOL_MANAGE_WORKERS     = 1 << 0,       /* need to manage workers */
69
70         /* worker flags */
71         WORKER_STARTED          = 1 << 0,       /* started */
72         WORKER_DIE              = 1 << 1,       /* die die die */
73         WORKER_IDLE             = 1 << 2,       /* is idle */
74         WORKER_PREP             = 1 << 3,       /* preparing to run works */
75         WORKER_REBIND           = 1 << 5,       /* mom is home, come back */
76         WORKER_CPU_INTENSIVE    = 1 << 6,       /* cpu intensive */
77         WORKER_UNBOUND          = 1 << 7,       /* worker is unbound */
78
79         WORKER_NOT_RUNNING      = WORKER_PREP | WORKER_REBIND | WORKER_UNBOUND |
80                                   WORKER_CPU_INTENSIVE,
81
82         NR_WORKER_POOLS         = 2,            /* # worker pools per gcwq */
83
84         BUSY_WORKER_HASH_ORDER  = 6,            /* 64 pointers */
85         BUSY_WORKER_HASH_SIZE   = 1 << BUSY_WORKER_HASH_ORDER,
86         BUSY_WORKER_HASH_MASK   = BUSY_WORKER_HASH_SIZE - 1,
87
88         MAX_IDLE_WORKERS_RATIO  = 4,            /* 1/4 of busy can be idle */
89         IDLE_WORKER_TIMEOUT     = 300 * HZ,     /* keep idle ones for 5 mins */
90
91         MAYDAY_INITIAL_TIMEOUT  = HZ / 100 >= 2 ? HZ / 100 : 2,
92                                                 /* call for help after 10ms
93                                                    (min two ticks) */
94         MAYDAY_INTERVAL         = HZ / 10,      /* and then every 100ms */
95         CREATE_COOLDOWN         = HZ,           /* time to breath after fail */
96
97         /*
98          * Rescue workers are used only on emergencies and shared by
99          * all cpus.  Give -20.
100          */
101         RESCUER_NICE_LEVEL      = -20,
102         HIGHPRI_NICE_LEVEL      = -20,
103 };
104
105 /*
106  * Structure fields follow one of the following exclusion rules.
107  *
108  * I: Modifiable by initialization/destruction paths and read-only for
109  *    everyone else.
110  *
111  * P: Preemption protected.  Disabling preemption is enough and should
112  *    only be modified and accessed from the local cpu.
113  *
114  * L: gcwq->lock protected.  Access with gcwq->lock held.
115  *
116  * X: During normal operation, modification requires gcwq->lock and
117  *    should be done only from local cpu.  Either disabling preemption
118  *    on local cpu or grabbing gcwq->lock is enough for read access.
119  *    If GCWQ_DISASSOCIATED is set, it's identical to L.
120  *
121  * F: wq->flush_mutex protected.
122  *
123  * W: workqueue_lock protected.
124  */
125
126 struct global_cwq;
127 struct worker_pool;
128 struct idle_rebind;
129
130 /*
131  * The poor guys doing the actual heavy lifting.  All on-duty workers
132  * are either serving the manager role, on idle list or on busy hash.
133  */
134 struct worker {
135         /* on idle list while idle, on busy hash table while busy */
136         union {
137                 struct list_head        entry;  /* L: while idle */
138                 struct hlist_node       hentry; /* L: while busy */
139         };
140
141         struct work_struct      *current_work;  /* L: work being processed */
142         struct cpu_workqueue_struct *current_cwq; /* L: current_work's cwq */
143         struct list_head        scheduled;      /* L: scheduled works */
144         struct task_struct      *task;          /* I: worker task */
145         struct worker_pool      *pool;          /* I: the associated pool */
146         /* 64 bytes boundary on 64bit, 32 on 32bit */
147         unsigned long           last_active;    /* L: last active timestamp */
148         unsigned int            flags;          /* X: flags */
149         int                     id;             /* I: worker id */
150
151         /* for rebinding worker to CPU */
152         struct idle_rebind      *idle_rebind;   /* L: for idle worker */
153         struct work_struct      rebind_work;    /* L: for busy worker */
154 };
155
156 struct worker_pool {
157         struct global_cwq       *gcwq;          /* I: the owning gcwq */
158         unsigned int            flags;          /* X: flags */
159
160         struct list_head        worklist;       /* L: list of pending works */
161         int                     nr_workers;     /* L: total number of workers */
162         int                     nr_idle;        /* L: currently idle ones */
163
164         struct list_head        idle_list;      /* X: list of idle workers */
165         struct timer_list       idle_timer;     /* L: worker idle timeout */
166         struct timer_list       mayday_timer;   /* L: SOS timer for dworkers */
167
168         struct mutex            manager_mutex;  /* mutex manager should hold */
169         struct ida              worker_ida;     /* L: for worker IDs */
170 };
171
172 /*
173  * Global per-cpu workqueue.  There's one and only one for each cpu
174  * and all works are queued and processed here regardless of their
175  * target workqueues.
176  */
177 struct global_cwq {
178         spinlock_t              lock;           /* the gcwq lock */
179         unsigned int            cpu;            /* I: the associated cpu */
180         unsigned int            flags;          /* L: GCWQ_* flags */
181
182         /* workers are chained either in busy_head or pool idle_list */
183         struct hlist_head       busy_hash[BUSY_WORKER_HASH_SIZE];
184                                                 /* L: hash of busy workers */
185
186         struct worker_pool      pools[2];       /* normal and highpri pools */
187
188         wait_queue_head_t       rebind_hold;    /* rebind hold wait */
189 } ____cacheline_aligned_in_smp;
190
191 /*
192  * The per-CPU workqueue.  The lower WORK_STRUCT_FLAG_BITS of
193  * work_struct->data are used for flags and thus cwqs need to be
194  * aligned at two's power of the number of flag bits.
195  */
196 struct cpu_workqueue_struct {
197         struct worker_pool      *pool;          /* I: the associated pool */
198         struct workqueue_struct *wq;            /* I: the owning workqueue */
199         int                     work_color;     /* L: current color */
200         int                     flush_color;    /* L: flushing color */
201         int                     nr_in_flight[WORK_NR_COLORS];
202                                                 /* L: nr of in_flight works */
203         int                     nr_active;      /* L: nr of active works */
204         int                     max_active;     /* L: max active works */
205         struct list_head        delayed_works;  /* L: delayed works */
206 };
207
208 /*
209  * Structure used to wait for workqueue flush.
210  */
211 struct wq_flusher {
212         struct list_head        list;           /* F: list of flushers */
213         int                     flush_color;    /* F: flush color waiting for */
214         struct completion       done;           /* flush completion */
215 };
216
217 /*
218  * All cpumasks are assumed to be always set on UP and thus can't be
219  * used to determine whether there's something to be done.
220  */
221 #ifdef CONFIG_SMP
222 typedef cpumask_var_t mayday_mask_t;
223 #define mayday_test_and_set_cpu(cpu, mask)      \
224         cpumask_test_and_set_cpu((cpu), (mask))
225 #define mayday_clear_cpu(cpu, mask)             cpumask_clear_cpu((cpu), (mask))
226 #define for_each_mayday_cpu(cpu, mask)          for_each_cpu((cpu), (mask))
227 #define alloc_mayday_mask(maskp, gfp)           zalloc_cpumask_var((maskp), (gfp))
228 #define free_mayday_mask(mask)                  free_cpumask_var((mask))
229 #else
230 typedef unsigned long mayday_mask_t;
231 #define mayday_test_and_set_cpu(cpu, mask)      test_and_set_bit(0, &(mask))
232 #define mayday_clear_cpu(cpu, mask)             clear_bit(0, &(mask))
233 #define for_each_mayday_cpu(cpu, mask)          if ((cpu) = 0, (mask))
234 #define alloc_mayday_mask(maskp, gfp)           true
235 #define free_mayday_mask(mask)                  do { } while (0)
236 #endif
237
238 /*
239  * The externally visible workqueue abstraction is an array of
240  * per-CPU workqueues:
241  */
242 struct workqueue_struct {
243         unsigned int            flags;          /* W: WQ_* flags */
244         union {
245                 struct cpu_workqueue_struct __percpu    *pcpu;
246                 struct cpu_workqueue_struct             *single;
247                 unsigned long                           v;
248         } cpu_wq;                               /* I: cwq's */
249         struct list_head        list;           /* W: list of all workqueues */
250
251         struct mutex            flush_mutex;    /* protects wq flushing */
252         int                     work_color;     /* F: current work color */
253         int                     flush_color;    /* F: current flush color */
254         atomic_t                nr_cwqs_to_flush; /* flush in progress */
255         struct wq_flusher       *first_flusher; /* F: first flusher */
256         struct list_head        flusher_queue;  /* F: flush waiters */
257         struct list_head        flusher_overflow; /* F: flush overflow list */
258
259         mayday_mask_t           mayday_mask;    /* cpus requesting rescue */
260         struct worker           *rescuer;       /* I: rescue worker */
261
262         int                     nr_drainers;    /* W: drain in progress */
263         int                     saved_max_active; /* W: saved cwq max_active */
264         const char              *name;          /* I: workqueue name */
265 #ifdef CONFIG_LOCKDEP
266         struct lockdep_map      lockdep_map;
267 #endif
268 };
269
270 struct workqueue_struct *system_wq __read_mostly;
271 struct workqueue_struct *system_long_wq __read_mostly;
272 struct workqueue_struct *system_nrt_wq __read_mostly;
273 struct workqueue_struct *system_unbound_wq __read_mostly;
274 struct workqueue_struct *system_freezable_wq __read_mostly;
275 EXPORT_SYMBOL_GPL(system_wq);
276 EXPORT_SYMBOL_GPL(system_long_wq);
277 EXPORT_SYMBOL_GPL(system_nrt_wq);
278 EXPORT_SYMBOL_GPL(system_unbound_wq);
279 EXPORT_SYMBOL_GPL(system_freezable_wq);
280
281 #define CREATE_TRACE_POINTS
282 #include <trace/events/workqueue.h>
283
284 #define for_each_worker_pool(pool, gcwq)                                \
285         for ((pool) = &(gcwq)->pools[0];                                \
286              (pool) < &(gcwq)->pools[NR_WORKER_POOLS]; (pool)++)
287
288 #define for_each_busy_worker(worker, i, pos, gcwq)                      \
289         for (i = 0; i < BUSY_WORKER_HASH_SIZE; i++)                     \
290                 hlist_for_each_entry(worker, pos, &gcwq->busy_hash[i], hentry)
291
292 static inline int __next_gcwq_cpu(int cpu, const struct cpumask *mask,
293                                   unsigned int sw)
294 {
295         if (cpu < nr_cpu_ids) {
296                 if (sw & 1) {
297                         cpu = cpumask_next(cpu, mask);
298                         if (cpu < nr_cpu_ids)
299                                 return cpu;
300                 }
301                 if (sw & 2)
302                         return WORK_CPU_UNBOUND;
303         }
304         return WORK_CPU_NONE;
305 }
306
307 static inline int __next_wq_cpu(int cpu, const struct cpumask *mask,
308                                 struct workqueue_struct *wq)
309 {
310         return __next_gcwq_cpu(cpu, mask, !(wq->flags & WQ_UNBOUND) ? 1 : 2);
311 }
312
313 /*
314  * CPU iterators
315  *
316  * An extra gcwq is defined for an invalid cpu number
317  * (WORK_CPU_UNBOUND) to host workqueues which are not bound to any
318  * specific CPU.  The following iterators are similar to
319  * for_each_*_cpu() iterators but also considers the unbound gcwq.
320  *
321  * for_each_gcwq_cpu()          : possible CPUs + WORK_CPU_UNBOUND
322  * for_each_online_gcwq_cpu()   : online CPUs + WORK_CPU_UNBOUND
323  * for_each_cwq_cpu()           : possible CPUs for bound workqueues,
324  *                                WORK_CPU_UNBOUND for unbound workqueues
325  */
326 #define for_each_gcwq_cpu(cpu)                                          \
327         for ((cpu) = __next_gcwq_cpu(-1, cpu_possible_mask, 3);         \
328              (cpu) < WORK_CPU_NONE;                                     \
329              (cpu) = __next_gcwq_cpu((cpu), cpu_possible_mask, 3))
330
331 #define for_each_online_gcwq_cpu(cpu)                                   \
332         for ((cpu) = __next_gcwq_cpu(-1, cpu_online_mask, 3);           \
333              (cpu) < WORK_CPU_NONE;                                     \
334              (cpu) = __next_gcwq_cpu((cpu), cpu_online_mask, 3))
335
336 #define for_each_cwq_cpu(cpu, wq)                                       \
337         for ((cpu) = __next_wq_cpu(-1, cpu_possible_mask, (wq));        \
338              (cpu) < WORK_CPU_NONE;                                     \
339              (cpu) = __next_wq_cpu((cpu), cpu_possible_mask, (wq)))
340
341 #ifdef CONFIG_DEBUG_OBJECTS_WORK
342
343 static struct debug_obj_descr work_debug_descr;
344
345 static void *work_debug_hint(void *addr)
346 {
347         return ((struct work_struct *) addr)->func;
348 }
349
350 /*
351  * fixup_init is called when:
352  * - an active object is initialized
353  */
354 static int work_fixup_init(void *addr, enum debug_obj_state state)
355 {
356         struct work_struct *work = addr;
357
358         switch (state) {
359         case ODEBUG_STATE_ACTIVE:
360                 cancel_work_sync(work);
361                 debug_object_init(work, &work_debug_descr);
362                 return 1;
363         default:
364                 return 0;
365         }
366 }
367
368 /*
369  * fixup_activate is called when:
370  * - an active object is activated
371  * - an unknown object is activated (might be a statically initialized object)
372  */
373 static int work_fixup_activate(void *addr, enum debug_obj_state state)
374 {
375         struct work_struct *work = addr;
376
377         switch (state) {
378
379         case ODEBUG_STATE_NOTAVAILABLE:
380                 /*
381                  * This is not really a fixup. The work struct was
382                  * statically initialized. We just make sure that it
383                  * is tracked in the object tracker.
384                  */
385                 if (test_bit(WORK_STRUCT_STATIC_BIT, work_data_bits(work))) {
386                         debug_object_init(work, &work_debug_descr);
387                         debug_object_activate(work, &work_debug_descr);
388                         return 0;
389                 }
390                 WARN_ON_ONCE(1);
391                 return 0;
392
393         case ODEBUG_STATE_ACTIVE:
394                 WARN_ON(1);
395
396         default:
397                 return 0;
398         }
399 }
400
401 /*
402  * fixup_free is called when:
403  * - an active object is freed
404  */
405 static int work_fixup_free(void *addr, enum debug_obj_state state)
406 {
407         struct work_struct *work = addr;
408
409         switch (state) {
410         case ODEBUG_STATE_ACTIVE:
411                 cancel_work_sync(work);
412                 debug_object_free(work, &work_debug_descr);
413                 return 1;
414         default:
415                 return 0;
416         }
417 }
418
419 static struct debug_obj_descr work_debug_descr = {
420         .name           = "work_struct",
421         .debug_hint     = work_debug_hint,
422         .fixup_init     = work_fixup_init,
423         .fixup_activate = work_fixup_activate,
424         .fixup_free     = work_fixup_free,
425 };
426
427 static inline void debug_work_activate(struct work_struct *work)
428 {
429         debug_object_activate(work, &work_debug_descr);
430 }
431
432 static inline void debug_work_deactivate(struct work_struct *work)
433 {
434         debug_object_deactivate(work, &work_debug_descr);
435 }
436
437 void __init_work(struct work_struct *work, int onstack)
438 {
439         if (onstack)
440                 debug_object_init_on_stack(work, &work_debug_descr);
441         else
442                 debug_object_init(work, &work_debug_descr);
443 }
444 EXPORT_SYMBOL_GPL(__init_work);
445
446 void destroy_work_on_stack(struct work_struct *work)
447 {
448         debug_object_free(work, &work_debug_descr);
449 }
450 EXPORT_SYMBOL_GPL(destroy_work_on_stack);
451
452 #else
453 static inline void debug_work_activate(struct work_struct *work) { }
454 static inline void debug_work_deactivate(struct work_struct *work) { }
455 #endif
456
457 /* Serializes the accesses to the list of workqueues. */
458 static DEFINE_SPINLOCK(workqueue_lock);
459 static LIST_HEAD(workqueues);
460 static bool workqueue_freezing;         /* W: have wqs started freezing? */
461
462 /*
463  * The almighty global cpu workqueues.  nr_running is the only field
464  * which is expected to be used frequently by other cpus via
465  * try_to_wake_up().  Put it in a separate cacheline.
466  */
467 static DEFINE_PER_CPU(struct global_cwq, global_cwq);
468 static DEFINE_PER_CPU_SHARED_ALIGNED(atomic_t, pool_nr_running[NR_WORKER_POOLS]);
469
470 /*
471  * Global cpu workqueue and nr_running counter for unbound gcwq.  The
472  * gcwq is always online, has GCWQ_DISASSOCIATED set, and all its
473  * workers have WORKER_UNBOUND set.
474  */
475 static struct global_cwq unbound_global_cwq;
476 static atomic_t unbound_pool_nr_running[NR_WORKER_POOLS] = {
477         [0 ... NR_WORKER_POOLS - 1]     = ATOMIC_INIT(0),       /* always 0 */
478 };
479
480 static int worker_thread(void *__worker);
481
482 static int worker_pool_pri(struct worker_pool *pool)
483 {
484         return pool - pool->gcwq->pools;
485 }
486
487 static struct global_cwq *get_gcwq(unsigned int cpu)
488 {
489         if (cpu != WORK_CPU_UNBOUND)
490                 return &per_cpu(global_cwq, cpu);
491         else
492                 return &unbound_global_cwq;
493 }
494
495 static atomic_t *get_pool_nr_running(struct worker_pool *pool)
496 {
497         int cpu = pool->gcwq->cpu;
498         atomic_t (*nr_running)[NR_WORKER_POOLS];
499
500         if (cpu != WORK_CPU_UNBOUND)
501                 nr_running = &per_cpu(pool_nr_running, cpu);
502         else
503                 nr_running = &unbound_pool_nr_running;
504
505         return nr_running[worker_pool_pri(pool)];
506 }
507
508 static struct cpu_workqueue_struct *get_cwq(unsigned int cpu,
509                                             struct workqueue_struct *wq)
510 {
511         if (!(wq->flags & WQ_UNBOUND)) {
512                 if (likely(cpu < nr_cpu_ids)) {
513 #ifdef CONFIG_SMP
514                         return per_cpu_ptr(wq->cpu_wq.pcpu, cpu);
515 #else
516                         return wq->cpu_wq.single;
517 #endif
518                 }
519         } else if (likely(cpu == WORK_CPU_UNBOUND))
520                 return wq->cpu_wq.single;
521         return NULL;
522 }
523
524 static unsigned int work_color_to_flags(int color)
525 {
526         return color << WORK_STRUCT_COLOR_SHIFT;
527 }
528
529 static int get_work_color(struct work_struct *work)
530 {
531         return (*work_data_bits(work) >> WORK_STRUCT_COLOR_SHIFT) &
532                 ((1 << WORK_STRUCT_COLOR_BITS) - 1);
533 }
534
535 static int work_next_color(int color)
536 {
537         return (color + 1) % WORK_NR_COLORS;
538 }
539
540 /*
541  * A work's data points to the cwq with WORK_STRUCT_CWQ set while the
542  * work is on queue.  Once execution starts, WORK_STRUCT_CWQ is
543  * cleared and the work data contains the cpu number it was last on.
544  *
545  * set_work_{cwq|cpu}() and clear_work_data() can be used to set the
546  * cwq, cpu or clear work->data.  These functions should only be
547  * called while the work is owned - ie. while the PENDING bit is set.
548  *
549  * get_work_[g]cwq() can be used to obtain the gcwq or cwq
550  * corresponding to a work.  gcwq is available once the work has been
551  * queued anywhere after initialization.  cwq is available only from
552  * queueing until execution starts.
553  */
554 static inline void set_work_data(struct work_struct *work, unsigned long data,
555                                  unsigned long flags)
556 {
557         BUG_ON(!work_pending(work));
558         atomic_long_set(&work->data, data | flags | work_static(work));
559 }
560
561 static void set_work_cwq(struct work_struct *work,
562                          struct cpu_workqueue_struct *cwq,
563                          unsigned long extra_flags)
564 {
565         set_work_data(work, (unsigned long)cwq,
566                       WORK_STRUCT_PENDING | WORK_STRUCT_CWQ | extra_flags);
567 }
568
569 static void set_work_cpu(struct work_struct *work, unsigned int cpu)
570 {
571         set_work_data(work, cpu << WORK_STRUCT_FLAG_BITS, WORK_STRUCT_PENDING);
572 }
573
574 static void clear_work_data(struct work_struct *work)
575 {
576         set_work_data(work, WORK_STRUCT_NO_CPU, 0);
577 }
578
579 static struct cpu_workqueue_struct *get_work_cwq(struct work_struct *work)
580 {
581         unsigned long data = atomic_long_read(&work->data);
582
583         if (data & WORK_STRUCT_CWQ)
584                 return (void *)(data & WORK_STRUCT_WQ_DATA_MASK);
585         else
586                 return NULL;
587 }
588
589 static struct global_cwq *get_work_gcwq(struct work_struct *work)
590 {
591         unsigned long data = atomic_long_read(&work->data);
592         unsigned int cpu;
593
594         if (data & WORK_STRUCT_CWQ)
595                 return ((struct cpu_workqueue_struct *)
596                         (data & WORK_STRUCT_WQ_DATA_MASK))->pool->gcwq;
597
598         cpu = data >> WORK_STRUCT_FLAG_BITS;
599         if (cpu == WORK_CPU_NONE)
600                 return NULL;
601
602         BUG_ON(cpu >= nr_cpu_ids && cpu != WORK_CPU_UNBOUND);
603         return get_gcwq(cpu);
604 }
605
606 /*
607  * Policy functions.  These define the policies on how the global worker
608  * pools are managed.  Unless noted otherwise, these functions assume that
609  * they're being called with gcwq->lock held.
610  */
611
612 static bool __need_more_worker(struct worker_pool *pool)
613 {
614         return !atomic_read(get_pool_nr_running(pool));
615 }
616
617 /*
618  * Need to wake up a worker?  Called from anything but currently
619  * running workers.
620  *
621  * Note that, because unbound workers never contribute to nr_running, this
622  * function will always return %true for unbound gcwq as long as the
623  * worklist isn't empty.
624  */
625 static bool need_more_worker(struct worker_pool *pool)
626 {
627         return !list_empty(&pool->worklist) && __need_more_worker(pool);
628 }
629
630 /* Can I start working?  Called from busy but !running workers. */
631 static bool may_start_working(struct worker_pool *pool)
632 {
633         return pool->nr_idle;
634 }
635
636 /* Do I need to keep working?  Called from currently running workers. */
637 static bool keep_working(struct worker_pool *pool)
638 {
639         atomic_t *nr_running = get_pool_nr_running(pool);
640
641         return !list_empty(&pool->worklist) && atomic_read(nr_running) <= 1;
642 }
643
644 /* Do we need a new worker?  Called from manager. */
645 static bool need_to_create_worker(struct worker_pool *pool)
646 {
647         return need_more_worker(pool) && !may_start_working(pool);
648 }
649
650 /* Do I need to be the manager? */
651 static bool need_to_manage_workers(struct worker_pool *pool)
652 {
653         return need_to_create_worker(pool) ||
654                 (pool->flags & POOL_MANAGE_WORKERS);
655 }
656
657 /* Do we have too many workers and should some go away? */
658 static bool too_many_workers(struct worker_pool *pool)
659 {
660         bool managing = mutex_is_locked(&pool->manager_mutex);
661         int nr_idle = pool->nr_idle + managing; /* manager is considered idle */
662         int nr_busy = pool->nr_workers - nr_idle;
663
664         return nr_idle > 2 && (nr_idle - 2) * MAX_IDLE_WORKERS_RATIO >= nr_busy;
665 }
666
667 /*
668  * Wake up functions.
669  */
670
671 /* Return the first worker.  Safe with preemption disabled */
672 static struct worker *first_worker(struct worker_pool *pool)
673 {
674         if (unlikely(list_empty(&pool->idle_list)))
675                 return NULL;
676
677         return list_first_entry(&pool->idle_list, struct worker, entry);
678 }
679
680 /**
681  * wake_up_worker - wake up an idle worker
682  * @pool: worker pool to wake worker from
683  *
684  * Wake up the first idle worker of @pool.
685  *
686  * CONTEXT:
687  * spin_lock_irq(gcwq->lock).
688  */
689 static void wake_up_worker(struct worker_pool *pool)
690 {
691         struct worker *worker = first_worker(pool);
692
693         if (likely(worker))
694                 wake_up_process(worker->task);
695 }
696
697 /**
698  * wq_worker_waking_up - a worker is waking up
699  * @task: task waking up
700  * @cpu: CPU @task is waking up to
701  *
702  * This function is called during try_to_wake_up() when a worker is
703  * being awoken.
704  *
705  * CONTEXT:
706  * spin_lock_irq(rq->lock)
707  */
708 void wq_worker_waking_up(struct task_struct *task, unsigned int cpu)
709 {
710         struct worker *worker = kthread_data(task);
711
712         if (!(worker->flags & WORKER_NOT_RUNNING))
713                 atomic_inc(get_pool_nr_running(worker->pool));
714 }
715
716 /**
717  * wq_worker_sleeping - a worker is going to sleep
718  * @task: task going to sleep
719  * @cpu: CPU in question, must be the current CPU number
720  *
721  * This function is called during schedule() when a busy worker is
722  * going to sleep.  Worker on the same cpu can be woken up by
723  * returning pointer to its task.
724  *
725  * CONTEXT:
726  * spin_lock_irq(rq->lock)
727  *
728  * RETURNS:
729  * Worker task on @cpu to wake up, %NULL if none.
730  */
731 struct task_struct *wq_worker_sleeping(struct task_struct *task,
732                                        unsigned int cpu)
733 {
734         struct worker *worker = kthread_data(task), *to_wakeup = NULL;
735         struct worker_pool *pool = worker->pool;
736         atomic_t *nr_running = get_pool_nr_running(pool);
737
738         if (worker->flags & WORKER_NOT_RUNNING)
739                 return NULL;
740
741         /* this can only happen on the local cpu */
742         BUG_ON(cpu != raw_smp_processor_id());
743
744         /*
745          * The counterpart of the following dec_and_test, implied mb,
746          * worklist not empty test sequence is in insert_work().
747          * Please read comment there.
748          *
749          * NOT_RUNNING is clear.  This means that we're bound to and
750          * running on the local cpu w/ rq lock held and preemption
751          * disabled, which in turn means that none else could be
752          * manipulating idle_list, so dereferencing idle_list without gcwq
753          * lock is safe.
754          */
755         if (atomic_dec_and_test(nr_running) && !list_empty(&pool->worklist))
756                 to_wakeup = first_worker(pool);
757         return to_wakeup ? to_wakeup->task : NULL;
758 }
759
760 /**
761  * worker_set_flags - set worker flags and adjust nr_running accordingly
762  * @worker: self
763  * @flags: flags to set
764  * @wakeup: wakeup an idle worker if necessary
765  *
766  * Set @flags in @worker->flags and adjust nr_running accordingly.  If
767  * nr_running becomes zero and @wakeup is %true, an idle worker is
768  * woken up.
769  *
770  * CONTEXT:
771  * spin_lock_irq(gcwq->lock)
772  */
773 static inline void worker_set_flags(struct worker *worker, unsigned int flags,
774                                     bool wakeup)
775 {
776         struct worker_pool *pool = worker->pool;
777
778         WARN_ON_ONCE(worker->task != current);
779
780         /*
781          * If transitioning into NOT_RUNNING, adjust nr_running and
782          * wake up an idle worker as necessary if requested by
783          * @wakeup.
784          */
785         if ((flags & WORKER_NOT_RUNNING) &&
786             !(worker->flags & WORKER_NOT_RUNNING)) {
787                 atomic_t *nr_running = get_pool_nr_running(pool);
788
789                 if (wakeup) {
790                         if (atomic_dec_and_test(nr_running) &&
791                             !list_empty(&pool->worklist))
792                                 wake_up_worker(pool);
793                 } else
794                         atomic_dec(nr_running);
795         }
796
797         worker->flags |= flags;
798 }
799
800 /**
801  * worker_clr_flags - clear worker flags and adjust nr_running accordingly
802  * @worker: self
803  * @flags: flags to clear
804  *
805  * Clear @flags in @worker->flags and adjust nr_running accordingly.
806  *
807  * CONTEXT:
808  * spin_lock_irq(gcwq->lock)
809  */
810 static inline void worker_clr_flags(struct worker *worker, unsigned int flags)
811 {
812         struct worker_pool *pool = worker->pool;
813         unsigned int oflags = worker->flags;
814
815         WARN_ON_ONCE(worker->task != current);
816
817         worker->flags &= ~flags;
818
819         /*
820          * If transitioning out of NOT_RUNNING, increment nr_running.  Note
821          * that the nested NOT_RUNNING is not a noop.  NOT_RUNNING is mask
822          * of multiple flags, not a single flag.
823          */
824         if ((flags & WORKER_NOT_RUNNING) && (oflags & WORKER_NOT_RUNNING))
825                 if (!(worker->flags & WORKER_NOT_RUNNING))
826                         atomic_inc(get_pool_nr_running(pool));
827 }
828
829 /**
830  * busy_worker_head - return the busy hash head for a work
831  * @gcwq: gcwq of interest
832  * @work: work to be hashed
833  *
834  * Return hash head of @gcwq for @work.
835  *
836  * CONTEXT:
837  * spin_lock_irq(gcwq->lock).
838  *
839  * RETURNS:
840  * Pointer to the hash head.
841  */
842 static struct hlist_head *busy_worker_head(struct global_cwq *gcwq,
843                                            struct work_struct *work)
844 {
845         const int base_shift = ilog2(sizeof(struct work_struct));
846         unsigned long v = (unsigned long)work;
847
848         /* simple shift and fold hash, do we need something better? */
849         v >>= base_shift;
850         v += v >> BUSY_WORKER_HASH_ORDER;
851         v &= BUSY_WORKER_HASH_MASK;
852
853         return &gcwq->busy_hash[v];
854 }
855
856 /**
857  * __find_worker_executing_work - find worker which is executing a work
858  * @gcwq: gcwq of interest
859  * @bwh: hash head as returned by busy_worker_head()
860  * @work: work to find worker for
861  *
862  * Find a worker which is executing @work on @gcwq.  @bwh should be
863  * the hash head obtained by calling busy_worker_head() with the same
864  * work.
865  *
866  * CONTEXT:
867  * spin_lock_irq(gcwq->lock).
868  *
869  * RETURNS:
870  * Pointer to worker which is executing @work if found, NULL
871  * otherwise.
872  */
873 static struct worker *__find_worker_executing_work(struct global_cwq *gcwq,
874                                                    struct hlist_head *bwh,
875                                                    struct work_struct *work)
876 {
877         struct worker *worker;
878         struct hlist_node *tmp;
879
880         hlist_for_each_entry(worker, tmp, bwh, hentry)
881                 if (worker->current_work == work)
882                         return worker;
883         return NULL;
884 }
885
886 /**
887  * find_worker_executing_work - find worker which is executing a work
888  * @gcwq: gcwq of interest
889  * @work: work to find worker for
890  *
891  * Find a worker which is executing @work on @gcwq.  This function is
892  * identical to __find_worker_executing_work() except that this
893  * function calculates @bwh itself.
894  *
895  * CONTEXT:
896  * spin_lock_irq(gcwq->lock).
897  *
898  * RETURNS:
899  * Pointer to worker which is executing @work if found, NULL
900  * otherwise.
901  */
902 static struct worker *find_worker_executing_work(struct global_cwq *gcwq,
903                                                  struct work_struct *work)
904 {
905         return __find_worker_executing_work(gcwq, busy_worker_head(gcwq, work),
906                                             work);
907 }
908
909 /**
910  * insert_work - insert a work into gcwq
911  * @cwq: cwq @work belongs to
912  * @work: work to insert
913  * @head: insertion point
914  * @extra_flags: extra WORK_STRUCT_* flags to set
915  *
916  * Insert @work which belongs to @cwq into @gcwq after @head.
917  * @extra_flags is or'd to work_struct flags.
918  *
919  * CONTEXT:
920  * spin_lock_irq(gcwq->lock).
921  */
922 static void insert_work(struct cpu_workqueue_struct *cwq,
923                         struct work_struct *work, struct list_head *head,
924                         unsigned int extra_flags)
925 {
926         struct worker_pool *pool = cwq->pool;
927
928         /* we own @work, set data and link */
929         set_work_cwq(work, cwq, extra_flags);
930
931         /*
932          * Ensure that we get the right work->data if we see the
933          * result of list_add() below, see try_to_grab_pending().
934          */
935         smp_wmb();
936
937         list_add_tail(&work->entry, head);
938
939         /*
940          * Ensure either worker_sched_deactivated() sees the above
941          * list_add_tail() or we see zero nr_running to avoid workers
942          * lying around lazily while there are works to be processed.
943          */
944         smp_mb();
945
946         if (__need_more_worker(pool))
947                 wake_up_worker(pool);
948 }
949
950 /*
951  * Test whether @work is being queued from another work executing on the
952  * same workqueue.  This is rather expensive and should only be used from
953  * cold paths.
954  */
955 static bool is_chained_work(struct workqueue_struct *wq)
956 {
957         unsigned long flags;
958         unsigned int cpu;
959
960         for_each_gcwq_cpu(cpu) {
961                 struct global_cwq *gcwq = get_gcwq(cpu);
962                 struct worker *worker;
963                 struct hlist_node *pos;
964                 int i;
965
966                 spin_lock_irqsave(&gcwq->lock, flags);
967                 for_each_busy_worker(worker, i, pos, gcwq) {
968                         if (worker->task != current)
969                                 continue;
970                         spin_unlock_irqrestore(&gcwq->lock, flags);
971                         /*
972                          * I'm @worker, no locking necessary.  See if @work
973                          * is headed to the same workqueue.
974                          */
975                         return worker->current_cwq->wq == wq;
976                 }
977                 spin_unlock_irqrestore(&gcwq->lock, flags);
978         }
979         return false;
980 }
981
982 static void __queue_work(unsigned int cpu, struct workqueue_struct *wq,
983                          struct work_struct *work)
984 {
985         struct global_cwq *gcwq;
986         struct cpu_workqueue_struct *cwq;
987         struct list_head *worklist;
988         unsigned int work_flags;
989         unsigned long flags;
990
991         debug_work_activate(work);
992
993         /* if dying, only works from the same workqueue are allowed */
994         if (unlikely(wq->flags & WQ_DRAINING) &&
995             WARN_ON_ONCE(!is_chained_work(wq)))
996                 return;
997
998         /* determine gcwq to use */
999         if (!(wq->flags & WQ_UNBOUND)) {
1000                 struct global_cwq *last_gcwq;
1001
1002                 if (unlikely(cpu == WORK_CPU_UNBOUND))
1003                         cpu = raw_smp_processor_id();
1004
1005                 /*
1006                  * It's multi cpu.  If @wq is non-reentrant and @work
1007                  * was previously on a different cpu, it might still
1008                  * be running there, in which case the work needs to
1009                  * be queued on that cpu to guarantee non-reentrance.
1010                  */
1011                 gcwq = get_gcwq(cpu);
1012                 if (wq->flags & WQ_NON_REENTRANT &&
1013                     (last_gcwq = get_work_gcwq(work)) && last_gcwq != gcwq) {
1014                         struct worker *worker;
1015
1016                         spin_lock_irqsave(&last_gcwq->lock, flags);
1017
1018                         worker = find_worker_executing_work(last_gcwq, work);
1019
1020                         if (worker && worker->current_cwq->wq == wq)
1021                                 gcwq = last_gcwq;
1022                         else {
1023                                 /* meh... not running there, queue here */
1024                                 spin_unlock_irqrestore(&last_gcwq->lock, flags);
1025                                 spin_lock_irqsave(&gcwq->lock, flags);
1026                         }
1027                 } else
1028                         spin_lock_irqsave(&gcwq->lock, flags);
1029         } else {
1030                 gcwq = get_gcwq(WORK_CPU_UNBOUND);
1031                 spin_lock_irqsave(&gcwq->lock, flags);
1032         }
1033
1034         /* gcwq determined, get cwq and queue */
1035         cwq = get_cwq(gcwq->cpu, wq);
1036         trace_workqueue_queue_work(cpu, cwq, work);
1037
1038         BUG_ON(!list_empty(&work->entry));
1039
1040         cwq->nr_in_flight[cwq->work_color]++;
1041         work_flags = work_color_to_flags(cwq->work_color);
1042
1043         if (likely(cwq->nr_active < cwq->max_active)) {
1044                 trace_workqueue_activate_work(work);
1045                 cwq->nr_active++;
1046                 worklist = &cwq->pool->worklist;
1047         } else {
1048                 work_flags |= WORK_STRUCT_DELAYED;
1049                 worklist = &cwq->delayed_works;
1050         }
1051
1052         insert_work(cwq, work, worklist, work_flags);
1053
1054         spin_unlock_irqrestore(&gcwq->lock, flags);
1055 }
1056
1057 /**
1058  * queue_work - queue work on a workqueue
1059  * @wq: workqueue to use
1060  * @work: work to queue
1061  *
1062  * Returns 0 if @work was already on a queue, non-zero otherwise.
1063  *
1064  * We queue the work to the CPU on which it was submitted, but if the CPU dies
1065  * it can be processed by another CPU.
1066  */
1067 int queue_work(struct workqueue_struct *wq, struct work_struct *work)
1068 {
1069         int ret;
1070
1071         ret = queue_work_on(get_cpu(), wq, work);
1072         put_cpu();
1073
1074         return ret;
1075 }
1076 EXPORT_SYMBOL_GPL(queue_work);
1077
1078 /**
1079  * queue_work_on - queue work on specific cpu
1080  * @cpu: CPU number to execute work on
1081  * @wq: workqueue to use
1082  * @work: work to queue
1083  *
1084  * Returns 0 if @work was already on a queue, non-zero otherwise.
1085  *
1086  * We queue the work to a specific CPU, the caller must ensure it
1087  * can't go away.
1088  */
1089 int
1090 queue_work_on(int cpu, struct workqueue_struct *wq, struct work_struct *work)
1091 {
1092         int ret = 0;
1093
1094         if (!test_and_set_bit(WORK_STRUCT_PENDING_BIT, work_data_bits(work))) {
1095                 __queue_work(cpu, wq, work);
1096                 ret = 1;
1097         }
1098         return ret;
1099 }
1100 EXPORT_SYMBOL_GPL(queue_work_on);
1101
1102 static void delayed_work_timer_fn(unsigned long __data)
1103 {
1104         struct delayed_work *dwork = (struct delayed_work *)__data;
1105         struct cpu_workqueue_struct *cwq = get_work_cwq(&dwork->work);
1106
1107         __queue_work(smp_processor_id(), cwq->wq, &dwork->work);
1108 }
1109
1110 /**
1111  * queue_delayed_work - queue work on a workqueue after delay
1112  * @wq: workqueue to use
1113  * @dwork: delayable work to queue
1114  * @delay: number of jiffies to wait before queueing
1115  *
1116  * Returns 0 if @work was already on a queue, non-zero otherwise.
1117  */
1118 int queue_delayed_work(struct workqueue_struct *wq,
1119                         struct delayed_work *dwork, unsigned long delay)
1120 {
1121         if (delay == 0)
1122                 return queue_work(wq, &dwork->work);
1123
1124         return queue_delayed_work_on(-1, wq, dwork, delay);
1125 }
1126 EXPORT_SYMBOL_GPL(queue_delayed_work);
1127
1128 /**
1129  * queue_delayed_work_on - queue work on specific CPU after delay
1130  * @cpu: CPU number to execute work on
1131  * @wq: workqueue to use
1132  * @dwork: work to queue
1133  * @delay: number of jiffies to wait before queueing
1134  *
1135  * Returns 0 if @work was already on a queue, non-zero otherwise.
1136  */
1137 int queue_delayed_work_on(int cpu, struct workqueue_struct *wq,
1138                         struct delayed_work *dwork, unsigned long delay)
1139 {
1140         int ret = 0;
1141         struct timer_list *timer = &dwork->timer;
1142         struct work_struct *work = &dwork->work;
1143
1144         if (!test_and_set_bit(WORK_STRUCT_PENDING_BIT, work_data_bits(work))) {
1145                 unsigned int lcpu;
1146
1147                 BUG_ON(timer_pending(timer));
1148                 BUG_ON(!list_empty(&work->entry));
1149
1150                 timer_stats_timer_set_start_info(&dwork->timer);
1151
1152                 /*
1153                  * This stores cwq for the moment, for the timer_fn.
1154                  * Note that the work's gcwq is preserved to allow
1155                  * reentrance detection for delayed works.
1156                  */
1157                 if (!(wq->flags & WQ_UNBOUND)) {
1158                         struct global_cwq *gcwq = get_work_gcwq(work);
1159
1160                         if (gcwq && gcwq->cpu != WORK_CPU_UNBOUND)
1161                                 lcpu = gcwq->cpu;
1162                         else
1163                                 lcpu = raw_smp_processor_id();
1164                 } else
1165                         lcpu = WORK_CPU_UNBOUND;
1166
1167                 set_work_cwq(work, get_cwq(lcpu, wq), 0);
1168
1169                 timer->expires = jiffies + delay;
1170                 timer->data = (unsigned long)dwork;
1171                 timer->function = delayed_work_timer_fn;
1172
1173                 if (unlikely(cpu >= 0))
1174                         add_timer_on(timer, cpu);
1175                 else
1176                         add_timer(timer);
1177                 ret = 1;
1178         }
1179         return ret;
1180 }
1181 EXPORT_SYMBOL_GPL(queue_delayed_work_on);
1182
1183 /**
1184  * worker_enter_idle - enter idle state
1185  * @worker: worker which is entering idle state
1186  *
1187  * @worker is entering idle state.  Update stats and idle timer if
1188  * necessary.
1189  *
1190  * LOCKING:
1191  * spin_lock_irq(gcwq->lock).
1192  */
1193 static void worker_enter_idle(struct worker *worker)
1194 {
1195         struct worker_pool *pool = worker->pool;
1196         struct global_cwq *gcwq = pool->gcwq;
1197
1198         BUG_ON(worker->flags & WORKER_IDLE);
1199         BUG_ON(!list_empty(&worker->entry) &&
1200                (worker->hentry.next || worker->hentry.pprev));
1201
1202         /* can't use worker_set_flags(), also called from start_worker() */
1203         worker->flags |= WORKER_IDLE;
1204         pool->nr_idle++;
1205         worker->last_active = jiffies;
1206
1207         /* idle_list is LIFO */
1208         list_add(&worker->entry, &pool->idle_list);
1209
1210         if (too_many_workers(pool) && !timer_pending(&pool->idle_timer))
1211                 mod_timer(&pool->idle_timer, jiffies + IDLE_WORKER_TIMEOUT);
1212
1213         /*
1214          * Sanity check nr_running.  Because gcwq_unbind_fn() releases
1215          * gcwq->lock between setting %WORKER_UNBOUND and zapping
1216          * nr_running, the warning may trigger spuriously.  Check iff
1217          * unbind is not in progress.
1218          */
1219          WARN_ON_ONCE(!(gcwq->flags & GCWQ_DISASSOCIATED) &&
1220                      pool->nr_workers == pool->nr_idle &&
1221                      atomic_read(get_pool_nr_running(pool)));
1222 }
1223
1224 /**
1225  * worker_leave_idle - leave idle state
1226  * @worker: worker which is leaving idle state
1227  *
1228  * @worker is leaving idle state.  Update stats.
1229  *
1230  * LOCKING:
1231  * spin_lock_irq(gcwq->lock).
1232  */
1233 static void worker_leave_idle(struct worker *worker)
1234 {
1235         struct worker_pool *pool = worker->pool;
1236
1237         BUG_ON(!(worker->flags & WORKER_IDLE));
1238         worker_clr_flags(worker, WORKER_IDLE);
1239         pool->nr_idle--;
1240         list_del_init(&worker->entry);
1241 }
1242
1243 /**
1244  * worker_maybe_bind_and_lock - bind worker to its cpu if possible and lock gcwq
1245  * @worker: self
1246  *
1247  * Works which are scheduled while the cpu is online must at least be
1248  * scheduled to a worker which is bound to the cpu so that if they are
1249  * flushed from cpu callbacks while cpu is going down, they are
1250  * guaranteed to execute on the cpu.
1251  *
1252  * This function is to be used by rogue workers and rescuers to bind
1253  * themselves to the target cpu and may race with cpu going down or
1254  * coming online.  kthread_bind() can't be used because it may put the
1255  * worker to already dead cpu and set_cpus_allowed_ptr() can't be used
1256  * verbatim as it's best effort and blocking and gcwq may be
1257  * [dis]associated in the meantime.
1258  *
1259  * This function tries set_cpus_allowed() and locks gcwq and verifies the
1260  * binding against %GCWQ_DISASSOCIATED which is set during
1261  * %CPU_DOWN_PREPARE and cleared during %CPU_ONLINE, so if the worker
1262  * enters idle state or fetches works without dropping lock, it can
1263  * guarantee the scheduling requirement described in the first paragraph.
1264  *
1265  * CONTEXT:
1266  * Might sleep.  Called without any lock but returns with gcwq->lock
1267  * held.
1268  *
1269  * RETURNS:
1270  * %true if the associated gcwq is online (@worker is successfully
1271  * bound), %false if offline.
1272  */
1273 static bool worker_maybe_bind_and_lock(struct worker *worker)
1274 __acquires(&gcwq->lock)
1275 {
1276         struct global_cwq *gcwq = worker->pool->gcwq;
1277         struct task_struct *task = worker->task;
1278
1279         while (true) {
1280                 /*
1281                  * The following call may fail, succeed or succeed
1282                  * without actually migrating the task to the cpu if
1283                  * it races with cpu hotunplug operation.  Verify
1284                  * against GCWQ_DISASSOCIATED.
1285                  */
1286                 if (!(gcwq->flags & GCWQ_DISASSOCIATED))
1287                         set_cpus_allowed_ptr(task, get_cpu_mask(gcwq->cpu));
1288
1289                 spin_lock_irq(&gcwq->lock);
1290                 if (gcwq->flags & GCWQ_DISASSOCIATED)
1291                         return false;
1292                 if (task_cpu(task) == gcwq->cpu &&
1293                     cpumask_equal(&current->cpus_allowed,
1294                                   get_cpu_mask(gcwq->cpu)))
1295                         return true;
1296                 spin_unlock_irq(&gcwq->lock);
1297
1298                 /*
1299                  * We've raced with CPU hot[un]plug.  Give it a breather
1300                  * and retry migration.  cond_resched() is required here;
1301                  * otherwise, we might deadlock against cpu_stop trying to
1302                  * bring down the CPU on non-preemptive kernel.
1303                  */
1304                 cpu_relax();
1305                 cond_resched();
1306         }
1307 }
1308
1309 struct idle_rebind {
1310         int                     cnt;            /* # workers to be rebound */
1311         struct completion       done;           /* all workers rebound */
1312 };
1313
1314 /*
1315  * Rebind an idle @worker to its CPU.  During CPU onlining, this has to
1316  * happen synchronously for idle workers.  worker_thread() will test
1317  * %WORKER_REBIND before leaving idle and call this function.
1318  */
1319 static void idle_worker_rebind(struct worker *worker)
1320 {
1321         struct global_cwq *gcwq = worker->pool->gcwq;
1322
1323         /* CPU must be online at this point */
1324         WARN_ON(!worker_maybe_bind_and_lock(worker));
1325         if (!--worker->idle_rebind->cnt)
1326                 complete(&worker->idle_rebind->done);
1327         spin_unlock_irq(&worker->pool->gcwq->lock);
1328
1329         /* we did our part, wait for rebind_workers() to finish up */
1330         wait_event(gcwq->rebind_hold, !(worker->flags & WORKER_REBIND));
1331 }
1332
1333 /*
1334  * Function for @worker->rebind.work used to rebind unbound busy workers to
1335  * the associated cpu which is coming back online.  This is scheduled by
1336  * cpu up but can race with other cpu hotplug operations and may be
1337  * executed twice without intervening cpu down.
1338  */
1339 static void busy_worker_rebind_fn(struct work_struct *work)
1340 {
1341         struct worker *worker = container_of(work, struct worker, rebind_work);
1342         struct global_cwq *gcwq = worker->pool->gcwq;
1343
1344         if (worker_maybe_bind_and_lock(worker))
1345                 worker_clr_flags(worker, WORKER_REBIND);
1346
1347         spin_unlock_irq(&gcwq->lock);
1348 }
1349
1350 /**
1351  * rebind_workers - rebind all workers of a gcwq to the associated CPU
1352  * @gcwq: gcwq of interest
1353  *
1354  * @gcwq->cpu is coming online.  Rebind all workers to the CPU.  Rebinding
1355  * is different for idle and busy ones.
1356  *
1357  * The idle ones should be rebound synchronously and idle rebinding should
1358  * be complete before any worker starts executing work items with
1359  * concurrency management enabled; otherwise, scheduler may oops trying to
1360  * wake up non-local idle worker from wq_worker_sleeping().
1361  *
1362  * This is achieved by repeatedly requesting rebinding until all idle
1363  * workers are known to have been rebound under @gcwq->lock and holding all
1364  * idle workers from becoming busy until idle rebinding is complete.
1365  *
1366  * Once idle workers are rebound, busy workers can be rebound as they
1367  * finish executing their current work items.  Queueing the rebind work at
1368  * the head of their scheduled lists is enough.  Note that nr_running will
1369  * be properbly bumped as busy workers rebind.
1370  *
1371  * On return, all workers are guaranteed to either be bound or have rebind
1372  * work item scheduled.
1373  */
1374 static void rebind_workers(struct global_cwq *gcwq)
1375         __releases(&gcwq->lock) __acquires(&gcwq->lock)
1376 {
1377         struct idle_rebind idle_rebind;
1378         struct worker_pool *pool;
1379         struct worker *worker;
1380         struct hlist_node *pos;
1381         int i;
1382
1383         lockdep_assert_held(&gcwq->lock);
1384
1385         for_each_worker_pool(pool, gcwq)
1386                 lockdep_assert_held(&pool->manager_mutex);
1387
1388         /*
1389          * Rebind idle workers.  Interlocked both ways.  We wait for
1390          * workers to rebind via @idle_rebind.done.  Workers will wait for
1391          * us to finish up by watching %WORKER_REBIND.
1392          */
1393         init_completion(&idle_rebind.done);
1394 retry:
1395         idle_rebind.cnt = 1;
1396         INIT_COMPLETION(idle_rebind.done);
1397
1398         /* set REBIND and kick idle ones, we'll wait for these later */
1399         for_each_worker_pool(pool, gcwq) {
1400                 list_for_each_entry(worker, &pool->idle_list, entry) {
1401                         if (worker->flags & WORKER_REBIND)
1402                                 continue;
1403
1404                         /* morph UNBOUND to REBIND */
1405                         worker->flags &= ~WORKER_UNBOUND;
1406                         worker->flags |= WORKER_REBIND;
1407
1408                         idle_rebind.cnt++;
1409                         worker->idle_rebind = &idle_rebind;
1410
1411                         /* worker_thread() will call idle_worker_rebind() */
1412                         wake_up_process(worker->task);
1413                 }
1414         }
1415
1416         if (--idle_rebind.cnt) {
1417                 spin_unlock_irq(&gcwq->lock);
1418                 wait_for_completion(&idle_rebind.done);
1419                 spin_lock_irq(&gcwq->lock);
1420                 /* busy ones might have become idle while waiting, retry */
1421                 goto retry;
1422         }
1423
1424         /*
1425          * All idle workers are rebound and waiting for %WORKER_REBIND to
1426          * be cleared inside idle_worker_rebind().  Clear and release.
1427          * Clearing %WORKER_REBIND from this foreign context is safe
1428          * because these workers are still guaranteed to be idle.
1429          */
1430         for_each_worker_pool(pool, gcwq)
1431                 list_for_each_entry(worker, &pool->idle_list, entry)
1432                         worker->flags &= ~WORKER_REBIND;
1433
1434         wake_up_all(&gcwq->rebind_hold);
1435
1436         /* rebind busy workers */
1437         for_each_busy_worker(worker, i, pos, gcwq) {
1438                 struct work_struct *rebind_work = &worker->rebind_work;
1439
1440                 /* morph UNBOUND to REBIND */
1441                 worker->flags &= ~WORKER_UNBOUND;
1442                 worker->flags |= WORKER_REBIND;
1443
1444                 if (test_and_set_bit(WORK_STRUCT_PENDING_BIT,
1445                                      work_data_bits(rebind_work)))
1446                         continue;
1447
1448                 /* wq doesn't matter, use the default one */
1449                 debug_work_activate(rebind_work);
1450                 insert_work(get_cwq(gcwq->cpu, system_wq), rebind_work,
1451                             worker->scheduled.next,
1452                             work_color_to_flags(WORK_NO_COLOR));
1453         }
1454 }
1455
1456 static struct worker *alloc_worker(void)
1457 {
1458         struct worker *worker;
1459
1460         worker = kzalloc(sizeof(*worker), GFP_KERNEL);
1461         if (worker) {
1462                 INIT_LIST_HEAD(&worker->entry);
1463                 INIT_LIST_HEAD(&worker->scheduled);
1464                 INIT_WORK(&worker->rebind_work, busy_worker_rebind_fn);
1465                 /* on creation a worker is in !idle && prep state */
1466                 worker->flags = WORKER_PREP;
1467         }
1468         return worker;
1469 }
1470
1471 /**
1472  * create_worker - create a new workqueue worker
1473  * @pool: pool the new worker will belong to
1474  *
1475  * Create a new worker which is bound to @pool.  The returned worker
1476  * can be started by calling start_worker() or destroyed using
1477  * destroy_worker().
1478  *
1479  * CONTEXT:
1480  * Might sleep.  Does GFP_KERNEL allocations.
1481  *
1482  * RETURNS:
1483  * Pointer to the newly created worker.
1484  */
1485 static struct worker *create_worker(struct worker_pool *pool)
1486 {
1487         struct global_cwq *gcwq = pool->gcwq;
1488         const char *pri = worker_pool_pri(pool) ? "H" : "";
1489         struct worker *worker = NULL;
1490         int id = -1;
1491
1492         spin_lock_irq(&gcwq->lock);
1493         while (ida_get_new(&pool->worker_ida, &id)) {
1494                 spin_unlock_irq(&gcwq->lock);
1495                 if (!ida_pre_get(&pool->worker_ida, GFP_KERNEL))
1496                         goto fail;
1497                 spin_lock_irq(&gcwq->lock);
1498         }
1499         spin_unlock_irq(&gcwq->lock);
1500
1501         worker = alloc_worker();
1502         if (!worker)
1503                 goto fail;
1504
1505         worker->pool = pool;
1506         worker->id = id;
1507
1508         if (gcwq->cpu != WORK_CPU_UNBOUND)
1509                 worker->task = kthread_create_on_node(worker_thread,
1510                                         worker, cpu_to_node(gcwq->cpu),
1511                                         "kworker/%u:%d%s", gcwq->cpu, id, pri);
1512         else
1513                 worker->task = kthread_create(worker_thread, worker,
1514                                               "kworker/u:%d%s", id, pri);
1515         if (IS_ERR(worker->task))
1516                 goto fail;
1517
1518         if (worker_pool_pri(pool))
1519                 set_user_nice(worker->task, HIGHPRI_NICE_LEVEL);
1520
1521         /*
1522          * Determine CPU binding of the new worker depending on
1523          * %GCWQ_DISASSOCIATED.  The caller is responsible for ensuring the
1524          * flag remains stable across this function.  See the comments
1525          * above the flag definition for details.
1526          *
1527          * As an unbound worker may later become a regular one if CPU comes
1528          * online, make sure every worker has %PF_THREAD_BOUND set.
1529          */
1530         if (!(gcwq->flags & GCWQ_DISASSOCIATED)) {
1531                 kthread_bind(worker->task, gcwq->cpu);
1532         } else {
1533                 worker->task->flags |= PF_THREAD_BOUND;
1534                 worker->flags |= WORKER_UNBOUND;
1535         }
1536
1537         return worker;
1538 fail:
1539         if (id >= 0) {
1540                 spin_lock_irq(&gcwq->lock);
1541                 ida_remove(&pool->worker_ida, id);
1542                 spin_unlock_irq(&gcwq->lock);
1543         }
1544         kfree(worker);
1545         return NULL;
1546 }
1547
1548 /**
1549  * start_worker - start a newly created worker
1550  * @worker: worker to start
1551  *
1552  * Make the gcwq aware of @worker and start it.
1553  *
1554  * CONTEXT:
1555  * spin_lock_irq(gcwq->lock).
1556  */
1557 static void start_worker(struct worker *worker)
1558 {
1559         worker->flags |= WORKER_STARTED;
1560         worker->pool->nr_workers++;
1561         worker_enter_idle(worker);
1562         wake_up_process(worker->task);
1563 }
1564
1565 /**
1566  * destroy_worker - destroy a workqueue worker
1567  * @worker: worker to be destroyed
1568  *
1569  * Destroy @worker and adjust @gcwq stats accordingly.
1570  *
1571  * CONTEXT:
1572  * spin_lock_irq(gcwq->lock) which is released and regrabbed.
1573  */
1574 static void destroy_worker(struct worker *worker)
1575 {
1576         struct worker_pool *pool = worker->pool;
1577         struct global_cwq *gcwq = pool->gcwq;
1578         int id = worker->id;
1579
1580         /* sanity check frenzy */
1581         BUG_ON(worker->current_work);
1582         BUG_ON(!list_empty(&worker->scheduled));
1583
1584         if (worker->flags & WORKER_STARTED)
1585                 pool->nr_workers--;
1586         if (worker->flags & WORKER_IDLE)
1587                 pool->nr_idle--;
1588
1589         list_del_init(&worker->entry);
1590         worker->flags |= WORKER_DIE;
1591
1592         spin_unlock_irq(&gcwq->lock);
1593
1594         kthread_stop(worker->task);
1595         kfree(worker);
1596
1597         spin_lock_irq(&gcwq->lock);
1598         ida_remove(&pool->worker_ida, id);
1599 }
1600
1601 static void idle_worker_timeout(unsigned long __pool)
1602 {
1603         struct worker_pool *pool = (void *)__pool;
1604         struct global_cwq *gcwq = pool->gcwq;
1605
1606         spin_lock_irq(&gcwq->lock);
1607
1608         if (too_many_workers(pool)) {
1609                 struct worker *worker;
1610                 unsigned long expires;
1611
1612                 /* idle_list is kept in LIFO order, check the last one */
1613                 worker = list_entry(pool->idle_list.prev, struct worker, entry);
1614                 expires = worker->last_active + IDLE_WORKER_TIMEOUT;
1615
1616                 if (time_before(jiffies, expires))
1617                         mod_timer(&pool->idle_timer, expires);
1618                 else {
1619                         /* it's been idle for too long, wake up manager */
1620                         pool->flags |= POOL_MANAGE_WORKERS;
1621                         wake_up_worker(pool);
1622                 }
1623         }
1624
1625         spin_unlock_irq(&gcwq->lock);
1626 }
1627
1628 static bool send_mayday(struct work_struct *work)
1629 {
1630         struct cpu_workqueue_struct *cwq = get_work_cwq(work);
1631         struct workqueue_struct *wq = cwq->wq;
1632         unsigned int cpu;
1633
1634         if (!(wq->flags & WQ_RESCUER))
1635                 return false;
1636
1637         /* mayday mayday mayday */
1638         cpu = cwq->pool->gcwq->cpu;
1639         /* WORK_CPU_UNBOUND can't be set in cpumask, use cpu 0 instead */
1640         if (cpu == WORK_CPU_UNBOUND)
1641                 cpu = 0;
1642         if (!mayday_test_and_set_cpu(cpu, wq->mayday_mask))
1643                 wake_up_process(wq->rescuer->task);
1644         return true;
1645 }
1646
1647 static void gcwq_mayday_timeout(unsigned long __pool)
1648 {
1649         struct worker_pool *pool = (void *)__pool;
1650         struct global_cwq *gcwq = pool->gcwq;
1651         struct work_struct *work;
1652
1653         spin_lock_irq(&gcwq->lock);
1654
1655         if (need_to_create_worker(pool)) {
1656                 /*
1657                  * We've been trying to create a new worker but
1658                  * haven't been successful.  We might be hitting an
1659                  * allocation deadlock.  Send distress signals to
1660                  * rescuers.
1661                  */
1662                 list_for_each_entry(work, &pool->worklist, entry)
1663                         send_mayday(work);
1664         }
1665
1666         spin_unlock_irq(&gcwq->lock);
1667
1668         mod_timer(&pool->mayday_timer, jiffies + MAYDAY_INTERVAL);
1669 }
1670
1671 /**
1672  * maybe_create_worker - create a new worker if necessary
1673  * @pool: pool to create a new worker for
1674  *
1675  * Create a new worker for @pool if necessary.  @pool is guaranteed to
1676  * have at least one idle worker on return from this function.  If
1677  * creating a new worker takes longer than MAYDAY_INTERVAL, mayday is
1678  * sent to all rescuers with works scheduled on @pool to resolve
1679  * possible allocation deadlock.
1680  *
1681  * On return, need_to_create_worker() is guaranteed to be false and
1682  * may_start_working() true.
1683  *
1684  * LOCKING:
1685  * spin_lock_irq(gcwq->lock) which may be released and regrabbed
1686  * multiple times.  Does GFP_KERNEL allocations.  Called only from
1687  * manager.
1688  *
1689  * RETURNS:
1690  * false if no action was taken and gcwq->lock stayed locked, true
1691  * otherwise.
1692  */
1693 static bool maybe_create_worker(struct worker_pool *pool)
1694 __releases(&gcwq->lock)
1695 __acquires(&gcwq->lock)
1696 {
1697         struct global_cwq *gcwq = pool->gcwq;
1698
1699         if (!need_to_create_worker(pool))
1700                 return false;
1701 restart:
1702         spin_unlock_irq(&gcwq->lock);
1703
1704         /* if we don't make progress in MAYDAY_INITIAL_TIMEOUT, call for help */
1705         mod_timer(&pool->mayday_timer, jiffies + MAYDAY_INITIAL_TIMEOUT);
1706
1707         while (true) {
1708                 struct worker *worker;
1709
1710                 worker = create_worker(pool);
1711                 if (worker) {
1712                         del_timer_sync(&pool->mayday_timer);
1713                         spin_lock_irq(&gcwq->lock);
1714                         start_worker(worker);
1715                         BUG_ON(need_to_create_worker(pool));
1716                         return true;
1717                 }
1718
1719                 if (!need_to_create_worker(pool))
1720                         break;
1721
1722                 __set_current_state(TASK_INTERRUPTIBLE);
1723                 schedule_timeout(CREATE_COOLDOWN);
1724
1725                 if (!need_to_create_worker(pool))
1726                         break;
1727         }
1728
1729         del_timer_sync(&pool->mayday_timer);
1730         spin_lock_irq(&gcwq->lock);
1731         if (need_to_create_worker(pool))
1732                 goto restart;
1733         return true;
1734 }
1735
1736 /**
1737  * maybe_destroy_worker - destroy workers which have been idle for a while
1738  * @pool: pool to destroy workers for
1739  *
1740  * Destroy @pool workers which have been idle for longer than
1741  * IDLE_WORKER_TIMEOUT.
1742  *
1743  * LOCKING:
1744  * spin_lock_irq(gcwq->lock) which may be released and regrabbed
1745  * multiple times.  Called only from manager.
1746  *
1747  * RETURNS:
1748  * false if no action was taken and gcwq->lock stayed locked, true
1749  * otherwise.
1750  */
1751 static bool maybe_destroy_workers(struct worker_pool *pool)
1752 {
1753         bool ret = false;
1754
1755         while (too_many_workers(pool)) {
1756                 struct worker *worker;
1757                 unsigned long expires;
1758
1759                 worker = list_entry(pool->idle_list.prev, struct worker, entry);
1760                 expires = worker->last_active + IDLE_WORKER_TIMEOUT;
1761
1762                 if (time_before(jiffies, expires)) {
1763                         mod_timer(&pool->idle_timer, expires);
1764                         break;
1765                 }
1766
1767                 destroy_worker(worker);
1768                 ret = true;
1769         }
1770
1771         return ret;
1772 }
1773
1774 /**
1775  * manage_workers - manage worker pool
1776  * @worker: self
1777  *
1778  * Assume the manager role and manage gcwq worker pool @worker belongs
1779  * to.  At any given time, there can be only zero or one manager per
1780  * gcwq.  The exclusion is handled automatically by this function.
1781  *
1782  * The caller can safely start processing works on false return.  On
1783  * true return, it's guaranteed that need_to_create_worker() is false
1784  * and may_start_working() is true.
1785  *
1786  * CONTEXT:
1787  * spin_lock_irq(gcwq->lock) which may be released and regrabbed
1788  * multiple times.  Does GFP_KERNEL allocations.
1789  *
1790  * RETURNS:
1791  * false if no action was taken and gcwq->lock stayed locked, true if
1792  * some action was taken.
1793  */
1794 static bool manage_workers(struct worker *worker)
1795 {
1796         struct worker_pool *pool = worker->pool;
1797         bool ret = false;
1798
1799         if (!mutex_trylock(&pool->manager_mutex))
1800                 return ret;
1801
1802         pool->flags &= ~POOL_MANAGE_WORKERS;
1803
1804         /*
1805          * Destroy and then create so that may_start_working() is true
1806          * on return.
1807          */
1808         ret |= maybe_destroy_workers(pool);
1809         ret |= maybe_create_worker(pool);
1810
1811         mutex_unlock(&pool->manager_mutex);
1812         return ret;
1813 }
1814
1815 /**
1816  * move_linked_works - move linked works to a list
1817  * @work: start of series of works to be scheduled
1818  * @head: target list to append @work to
1819  * @nextp: out paramter for nested worklist walking
1820  *
1821  * Schedule linked works starting from @work to @head.  Work series to
1822  * be scheduled starts at @work and includes any consecutive work with
1823  * WORK_STRUCT_LINKED set in its predecessor.
1824  *
1825  * If @nextp is not NULL, it's updated to point to the next work of
1826  * the last scheduled work.  This allows move_linked_works() to be
1827  * nested inside outer list_for_each_entry_safe().
1828  *
1829  * CONTEXT:
1830  * spin_lock_irq(gcwq->lock).
1831  */
1832 static void move_linked_works(struct work_struct *work, struct list_head *head,
1833                               struct work_struct **nextp)
1834 {
1835         struct work_struct *n;
1836
1837         /*
1838          * Linked worklist will always end before the end of the list,
1839          * use NULL for list head.
1840          */
1841         list_for_each_entry_safe_from(work, n, NULL, entry) {
1842                 list_move_tail(&work->entry, head);
1843                 if (!(*work_data_bits(work) & WORK_STRUCT_LINKED))
1844                         break;
1845         }
1846
1847         /*
1848          * If we're already inside safe list traversal and have moved
1849          * multiple works to the scheduled queue, the next position
1850          * needs to be updated.
1851          */
1852         if (nextp)
1853                 *nextp = n;
1854 }
1855
1856 static void cwq_activate_first_delayed(struct cpu_workqueue_struct *cwq)
1857 {
1858         struct work_struct *work = list_first_entry(&cwq->delayed_works,
1859                                                     struct work_struct, entry);
1860
1861         trace_workqueue_activate_work(work);
1862         move_linked_works(work, &cwq->pool->worklist, NULL);
1863         __clear_bit(WORK_STRUCT_DELAYED_BIT, work_data_bits(work));
1864         cwq->nr_active++;
1865 }
1866
1867 /**
1868  * cwq_dec_nr_in_flight - decrement cwq's nr_in_flight
1869  * @cwq: cwq of interest
1870  * @color: color of work which left the queue
1871  * @delayed: for a delayed work
1872  *
1873  * A work either has completed or is removed from pending queue,
1874  * decrement nr_in_flight of its cwq and handle workqueue flushing.
1875  *
1876  * CONTEXT:
1877  * spin_lock_irq(gcwq->lock).
1878  */
1879 static void cwq_dec_nr_in_flight(struct cpu_workqueue_struct *cwq, int color,
1880                                  bool delayed)
1881 {
1882         /* ignore uncolored works */
1883         if (color == WORK_NO_COLOR)
1884                 return;
1885
1886         cwq->nr_in_flight[color]--;
1887
1888         if (!delayed) {
1889                 cwq->nr_active--;
1890                 if (!list_empty(&cwq->delayed_works)) {
1891                         /* one down, submit a delayed one */
1892                         if (cwq->nr_active < cwq->max_active)
1893                                 cwq_activate_first_delayed(cwq);
1894                 }
1895         }
1896
1897         /* is flush in progress and are we at the flushing tip? */
1898         if (likely(cwq->flush_color != color))
1899                 return;
1900
1901         /* are there still in-flight works? */
1902         if (cwq->nr_in_flight[color])
1903                 return;
1904
1905         /* this cwq is done, clear flush_color */
1906         cwq->flush_color = -1;
1907
1908         /*
1909          * If this was the last cwq, wake up the first flusher.  It
1910          * will handle the rest.
1911          */
1912         if (atomic_dec_and_test(&cwq->wq->nr_cwqs_to_flush))
1913                 complete(&cwq->wq->first_flusher->done);
1914 }
1915
1916 /**
1917  * process_one_work - process single work
1918  * @worker: self
1919  * @work: work to process
1920  *
1921  * Process @work.  This function contains all the logics necessary to
1922  * process a single work including synchronization against and
1923  * interaction with other workers on the same cpu, queueing and
1924  * flushing.  As long as context requirement is met, any worker can
1925  * call this function to process a work.
1926  *
1927  * CONTEXT:
1928  * spin_lock_irq(gcwq->lock) which is released and regrabbed.
1929  */
1930 static void process_one_work(struct worker *worker, struct work_struct *work)
1931 __releases(&gcwq->lock)
1932 __acquires(&gcwq->lock)
1933 {
1934         struct cpu_workqueue_struct *cwq = get_work_cwq(work);
1935         struct worker_pool *pool = worker->pool;
1936         struct global_cwq *gcwq = pool->gcwq;
1937         struct hlist_head *bwh = busy_worker_head(gcwq, work);
1938         bool cpu_intensive = cwq->wq->flags & WQ_CPU_INTENSIVE;
1939         work_func_t f = work->func;
1940         int work_color;
1941         struct worker *collision;
1942 #ifdef CONFIG_LOCKDEP
1943         /*
1944          * It is permissible to free the struct work_struct from
1945          * inside the function that is called from it, this we need to
1946          * take into account for lockdep too.  To avoid bogus "held
1947          * lock freed" warnings as well as problems when looking into
1948          * work->lockdep_map, make a copy and use that here.
1949          */
1950         struct lockdep_map lockdep_map = work->lockdep_map;
1951 #endif
1952         WARN_ON_ONCE(!(worker->flags & (WORKER_UNBOUND | WORKER_REBIND)) &&
1953                      raw_smp_processor_id() != gcwq->cpu);
1954
1955         /*
1956          * A single work shouldn't be executed concurrently by
1957          * multiple workers on a single cpu.  Check whether anyone is
1958          * already processing the work.  If so, defer the work to the
1959          * currently executing one.
1960          */
1961         collision = __find_worker_executing_work(gcwq, bwh, work);
1962         if (unlikely(collision)) {
1963                 move_linked_works(work, &collision->scheduled, NULL);
1964                 return;
1965         }
1966
1967         /* claim and process */
1968         debug_work_deactivate(work);
1969         hlist_add_head(&worker->hentry, bwh);
1970         worker->current_work = work;
1971         worker->current_cwq = cwq;
1972         work_color = get_work_color(work);
1973
1974         /* record the current cpu number in the work data and dequeue */
1975         set_work_cpu(work, gcwq->cpu);
1976         list_del_init(&work->entry);
1977
1978         /*
1979          * CPU intensive works don't participate in concurrency
1980          * management.  They're the scheduler's responsibility.
1981          */
1982         if (unlikely(cpu_intensive))
1983                 worker_set_flags(worker, WORKER_CPU_INTENSIVE, true);
1984
1985         /*
1986          * Unbound gcwq isn't concurrency managed and work items should be
1987          * executed ASAP.  Wake up another worker if necessary.
1988          */
1989         if ((worker->flags & WORKER_UNBOUND) && need_more_worker(pool))
1990                 wake_up_worker(pool);
1991
1992         spin_unlock_irq(&gcwq->lock);
1993
1994         work_clear_pending(work);
1995         lock_map_acquire_read(&cwq->wq->lockdep_map);
1996         lock_map_acquire(&lockdep_map);
1997         trace_workqueue_execute_start(work);
1998         f(work);
1999         /*
2000          * While we must be careful to not use "work" after this, the trace
2001          * point will only record its address.
2002          */
2003         trace_workqueue_execute_end(work);
2004         lock_map_release(&lockdep_map);
2005         lock_map_release(&cwq->wq->lockdep_map);
2006
2007         if (unlikely(in_atomic() || lockdep_depth(current) > 0)) {
2008                 printk(KERN_ERR "BUG: workqueue leaked lock or atomic: "
2009                        "%s/0x%08x/%d\n",
2010                        current->comm, preempt_count(), task_pid_nr(current));
2011                 printk(KERN_ERR "    last function: ");
2012                 print_symbol("%s\n", (unsigned long)f);
2013                 debug_show_held_locks(current);
2014                 dump_stack();
2015         }
2016
2017         spin_lock_irq(&gcwq->lock);
2018
2019         /* clear cpu intensive status */
2020         if (unlikely(cpu_intensive))
2021                 worker_clr_flags(worker, WORKER_CPU_INTENSIVE);
2022
2023         /* we're done with it, release */
2024         hlist_del_init(&worker->hentry);
2025         worker->current_work = NULL;
2026         worker->current_cwq = NULL;
2027         cwq_dec_nr_in_flight(cwq, work_color, false);
2028 }
2029
2030 /**
2031  * process_scheduled_works - process scheduled works
2032  * @worker: self
2033  *
2034  * Process all scheduled works.  Please note that the scheduled list
2035  * may change while processing a work, so this function repeatedly
2036  * fetches a work from the top and executes it.
2037  *
2038  * CONTEXT:
2039  * spin_lock_irq(gcwq->lock) which may be released and regrabbed
2040  * multiple times.
2041  */
2042 static void process_scheduled_works(struct worker *worker)
2043 {
2044         while (!list_empty(&worker->scheduled)) {
2045                 struct work_struct *work = list_first_entry(&worker->scheduled,
2046                                                 struct work_struct, entry);
2047                 process_one_work(worker, work);
2048         }
2049 }
2050
2051 /**
2052  * worker_thread - the worker thread function
2053  * @__worker: self
2054  *
2055  * The gcwq worker thread function.  There's a single dynamic pool of
2056  * these per each cpu.  These workers process all works regardless of
2057  * their specific target workqueue.  The only exception is works which
2058  * belong to workqueues with a rescuer which will be explained in
2059  * rescuer_thread().
2060  */
2061 static int worker_thread(void *__worker)
2062 {
2063         struct worker *worker = __worker;
2064         struct worker_pool *pool = worker->pool;
2065         struct global_cwq *gcwq = pool->gcwq;
2066
2067         /* tell the scheduler that this is a workqueue worker */
2068         worker->task->flags |= PF_WQ_WORKER;
2069 woke_up:
2070         spin_lock_irq(&gcwq->lock);
2071
2072         /*
2073          * DIE can be set only while idle and REBIND set while busy has
2074          * @worker->rebind_work scheduled.  Checking here is enough.
2075          */
2076         if (unlikely(worker->flags & (WORKER_REBIND | WORKER_DIE))) {
2077                 spin_unlock_irq(&gcwq->lock);
2078
2079                 if (worker->flags & WORKER_DIE) {
2080                         worker->task->flags &= ~PF_WQ_WORKER;
2081                         return 0;
2082                 }
2083
2084                 idle_worker_rebind(worker);
2085                 goto woke_up;
2086         }
2087
2088         worker_leave_idle(worker);
2089 recheck:
2090         /* no more worker necessary? */
2091         if (!need_more_worker(pool))
2092                 goto sleep;
2093
2094         /* do we need to manage? */
2095         if (unlikely(!may_start_working(pool)) && manage_workers(worker))
2096                 goto recheck;
2097
2098         /*
2099          * ->scheduled list can only be filled while a worker is
2100          * preparing to process a work or actually processing it.
2101          * Make sure nobody diddled with it while I was sleeping.
2102          */
2103         BUG_ON(!list_empty(&worker->scheduled));
2104
2105         /*
2106          * When control reaches this point, we're guaranteed to have
2107          * at least one idle worker or that someone else has already
2108          * assumed the manager role.
2109          */
2110         worker_clr_flags(worker, WORKER_PREP);
2111
2112         do {
2113                 struct work_struct *work =
2114                         list_first_entry(&pool->worklist,
2115                                          struct work_struct, entry);
2116
2117                 if (likely(!(*work_data_bits(work) & WORK_STRUCT_LINKED))) {
2118                         /* optimization path, not strictly necessary */
2119                         process_one_work(worker, work);
2120                         if (unlikely(!list_empty(&worker->scheduled)))
2121                                 process_scheduled_works(worker);
2122                 } else {
2123                         move_linked_works(work, &worker->scheduled, NULL);
2124                         process_scheduled_works(worker);
2125                 }
2126         } while (keep_working(pool));
2127
2128         worker_set_flags(worker, WORKER_PREP, false);
2129 sleep:
2130         if (unlikely(need_to_manage_workers(pool)) && manage_workers(worker))
2131                 goto recheck;
2132
2133         /*
2134          * gcwq->lock is held and there's no work to process and no
2135          * need to manage, sleep.  Workers are woken up only while
2136          * holding gcwq->lock or from local cpu, so setting the
2137          * current state before releasing gcwq->lock is enough to
2138          * prevent losing any event.
2139          */
2140         worker_enter_idle(worker);
2141         __set_current_state(TASK_INTERRUPTIBLE);
2142         spin_unlock_irq(&gcwq->lock);
2143         schedule();
2144         goto woke_up;
2145 }
2146
2147 /**
2148  * rescuer_thread - the rescuer thread function
2149  * @__wq: the associated workqueue
2150  *
2151  * Workqueue rescuer thread function.  There's one rescuer for each
2152  * workqueue which has WQ_RESCUER set.
2153  *
2154  * Regular work processing on a gcwq may block trying to create a new
2155  * worker which uses GFP_KERNEL allocation which has slight chance of
2156  * developing into deadlock if some works currently on the same queue
2157  * need to be processed to satisfy the GFP_KERNEL allocation.  This is
2158  * the problem rescuer solves.
2159  *
2160  * When such condition is possible, the gcwq summons rescuers of all
2161  * workqueues which have works queued on the gcwq and let them process
2162  * those works so that forward progress can be guaranteed.
2163  *
2164  * This should happen rarely.
2165  */
2166 static int rescuer_thread(void *__wq)
2167 {
2168         struct workqueue_struct *wq = __wq;
2169         struct worker *rescuer = wq->rescuer;
2170         struct list_head *scheduled = &rescuer->scheduled;
2171         bool is_unbound = wq->flags & WQ_UNBOUND;
2172         unsigned int cpu;
2173
2174         set_user_nice(current, RESCUER_NICE_LEVEL);
2175 repeat:
2176         set_current_state(TASK_INTERRUPTIBLE);
2177
2178         if (kthread_should_stop())
2179                 return 0;
2180
2181         /*
2182          * See whether any cpu is asking for help.  Unbounded
2183          * workqueues use cpu 0 in mayday_mask for CPU_UNBOUND.
2184          */
2185         for_each_mayday_cpu(cpu, wq->mayday_mask) {
2186                 unsigned int tcpu = is_unbound ? WORK_CPU_UNBOUND : cpu;
2187                 struct cpu_workqueue_struct *cwq = get_cwq(tcpu, wq);
2188                 struct worker_pool *pool = cwq->pool;
2189                 struct global_cwq *gcwq = pool->gcwq;
2190                 struct work_struct *work, *n;
2191
2192                 __set_current_state(TASK_RUNNING);
2193                 mayday_clear_cpu(cpu, wq->mayday_mask);
2194
2195                 /* migrate to the target cpu if possible */
2196                 rescuer->pool = pool;
2197                 worker_maybe_bind_and_lock(rescuer);
2198
2199                 /*
2200                  * Slurp in all works issued via this workqueue and
2201                  * process'em.
2202                  */
2203                 BUG_ON(!list_empty(&rescuer->scheduled));
2204                 list_for_each_entry_safe(work, n, &pool->worklist, entry)
2205                         if (get_work_cwq(work) == cwq)
2206                                 move_linked_works(work, scheduled, &n);
2207
2208                 process_scheduled_works(rescuer);
2209
2210                 /*
2211                  * Leave this gcwq.  If keep_working() is %true, notify a
2212                  * regular worker; otherwise, we end up with 0 concurrency
2213                  * and stalling the execution.
2214                  */
2215                 if (keep_working(pool))
2216                         wake_up_worker(pool);
2217
2218                 spin_unlock_irq(&gcwq->lock);
2219         }
2220
2221         schedule();
2222         goto repeat;
2223 }
2224
2225 struct wq_barrier {
2226         struct work_struct      work;
2227         struct completion       done;
2228 };
2229
2230 static void wq_barrier_func(struct work_struct *work)
2231 {
2232         struct wq_barrier *barr = container_of(work, struct wq_barrier, work);
2233         complete(&barr->done);
2234 }
2235
2236 /**
2237  * insert_wq_barrier - insert a barrier work
2238  * @cwq: cwq to insert barrier into
2239  * @barr: wq_barrier to insert
2240  * @target: target work to attach @barr to
2241  * @worker: worker currently executing @target, NULL if @target is not executing
2242  *
2243  * @barr is linked to @target such that @barr is completed only after
2244  * @target finishes execution.  Please note that the ordering
2245  * guarantee is observed only with respect to @target and on the local
2246  * cpu.
2247  *
2248  * Currently, a queued barrier can't be canceled.  This is because
2249  * try_to_grab_pending() can't determine whether the work to be
2250  * grabbed is at the head of the queue and thus can't clear LINKED
2251  * flag of the previous work while there must be a valid next work
2252  * after a work with LINKED flag set.
2253  *
2254  * Note that when @worker is non-NULL, @target may be modified
2255  * underneath us, so we can't reliably determine cwq from @target.
2256  *
2257  * CONTEXT:
2258  * spin_lock_irq(gcwq->lock).
2259  */
2260 static void insert_wq_barrier(struct cpu_workqueue_struct *cwq,
2261                               struct wq_barrier *barr,
2262                               struct work_struct *target, struct worker *worker)
2263 {
2264         struct list_head *head;
2265         unsigned int linked = 0;
2266
2267         /*
2268          * debugobject calls are safe here even with gcwq->lock locked
2269          * as we know for sure that this will not trigger any of the
2270          * checks and call back into the fixup functions where we
2271          * might deadlock.
2272          */
2273         INIT_WORK_ONSTACK(&barr->work, wq_barrier_func);
2274         __set_bit(WORK_STRUCT_PENDING_BIT, work_data_bits(&barr->work));
2275         init_completion(&barr->done);
2276
2277         /*
2278          * If @target is currently being executed, schedule the
2279          * barrier to the worker; otherwise, put it after @target.
2280          */
2281         if (worker)
2282                 head = worker->scheduled.next;
2283         else {
2284                 unsigned long *bits = work_data_bits(target);
2285
2286                 head = target->entry.next;
2287                 /* there can already be other linked works, inherit and set */
2288                 linked = *bits & WORK_STRUCT_LINKED;
2289                 __set_bit(WORK_STRUCT_LINKED_BIT, bits);
2290         }
2291
2292         debug_work_activate(&barr->work);
2293         insert_work(cwq, &barr->work, head,
2294                     work_color_to_flags(WORK_NO_COLOR) | linked);
2295 }
2296
2297 /**
2298  * flush_workqueue_prep_cwqs - prepare cwqs for workqueue flushing
2299  * @wq: workqueue being flushed
2300  * @flush_color: new flush color, < 0 for no-op
2301  * @work_color: new work color, < 0 for no-op
2302  *
2303  * Prepare cwqs for workqueue flushing.
2304  *
2305  * If @flush_color is non-negative, flush_color on all cwqs should be
2306  * -1.  If no cwq has in-flight commands at the specified color, all
2307  * cwq->flush_color's stay at -1 and %false is returned.  If any cwq
2308  * has in flight commands, its cwq->flush_color is set to
2309  * @flush_color, @wq->nr_cwqs_to_flush is updated accordingly, cwq
2310  * wakeup logic is armed and %true is returned.
2311  *
2312  * The caller should have initialized @wq->first_flusher prior to
2313  * calling this function with non-negative @flush_color.  If
2314  * @flush_color is negative, no flush color update is done and %false
2315  * is returned.
2316  *
2317  * If @work_color is non-negative, all cwqs should have the same
2318  * work_color which is previous to @work_color and all will be
2319  * advanced to @work_color.
2320  *
2321  * CONTEXT:
2322  * mutex_lock(wq->flush_mutex).
2323  *
2324  * RETURNS:
2325  * %true if @flush_color >= 0 and there's something to flush.  %false
2326  * otherwise.
2327  */
2328 static bool flush_workqueue_prep_cwqs(struct workqueue_struct *wq,
2329                                       int flush_color, int work_color)
2330 {
2331         bool wait = false;
2332         unsigned int cpu;
2333
2334         if (flush_color >= 0) {
2335                 BUG_ON(atomic_read(&wq->nr_cwqs_to_flush));
2336                 atomic_set(&wq->nr_cwqs_to_flush, 1);
2337         }
2338
2339         for_each_cwq_cpu(cpu, wq) {
2340                 struct cpu_workqueue_struct *cwq = get_cwq(cpu, wq);
2341                 struct global_cwq *gcwq = cwq->pool->gcwq;
2342
2343                 spin_lock_irq(&gcwq->lock);
2344
2345                 if (flush_color >= 0) {
2346                         BUG_ON(cwq->flush_color != -1);
2347
2348                         if (cwq->nr_in_flight[flush_color]) {
2349                                 cwq->flush_color = flush_color;
2350                                 atomic_inc(&wq->nr_cwqs_to_flush);
2351                                 wait = true;
2352                         }
2353                 }
2354
2355                 if (work_color >= 0) {
2356                         BUG_ON(work_color != work_next_color(cwq->work_color));
2357                         cwq->work_color = work_color;
2358                 }
2359
2360                 spin_unlock_irq(&gcwq->lock);
2361         }
2362
2363         if (flush_color >= 0 && atomic_dec_and_test(&wq->nr_cwqs_to_flush))
2364                 complete(&wq->first_flusher->done);
2365
2366         return wait;
2367 }
2368
2369 /**
2370  * flush_workqueue - ensure that any scheduled work has run to completion.
2371  * @wq: workqueue to flush
2372  *
2373  * Forces execution of the workqueue and blocks until its completion.
2374  * This is typically used in driver shutdown handlers.
2375  *
2376  * We sleep until all works which were queued on entry have been handled,
2377  * but we are not livelocked by new incoming ones.
2378  */
2379 void flush_workqueue(struct workqueue_struct *wq)
2380 {
2381         struct wq_flusher this_flusher = {
2382                 .list = LIST_HEAD_INIT(this_flusher.list),
2383                 .flush_color = -1,
2384                 .done = COMPLETION_INITIALIZER_ONSTACK(this_flusher.done),
2385         };
2386         int next_color;
2387
2388         lock_map_acquire(&wq->lockdep_map);
2389         lock_map_release(&wq->lockdep_map);
2390
2391         mutex_lock(&wq->flush_mutex);
2392
2393         /*
2394          * Start-to-wait phase
2395          */
2396         next_color = work_next_color(wq->work_color);
2397
2398         if (next_color != wq->flush_color) {
2399                 /*
2400                  * Color space is not full.  The current work_color
2401                  * becomes our flush_color and work_color is advanced
2402                  * by one.
2403                  */
2404                 BUG_ON(!list_empty(&wq->flusher_overflow));
2405                 this_flusher.flush_color = wq->work_color;
2406                 wq->work_color = next_color;
2407
2408                 if (!wq->first_flusher) {
2409                         /* no flush in progress, become the first flusher */
2410                         BUG_ON(wq->flush_color != this_flusher.flush_color);
2411
2412                         wq->first_flusher = &this_flusher;
2413
2414                         if (!flush_workqueue_prep_cwqs(wq, wq->flush_color,
2415                                                        wq->work_color)) {
2416                                 /* nothing to flush, done */
2417                                 wq->flush_color = next_color;
2418                                 wq->first_flusher = NULL;
2419                                 goto out_unlock;
2420                         }
2421                 } else {
2422                         /* wait in queue */
2423                         BUG_ON(wq->flush_color == this_flusher.flush_color);
2424                         list_add_tail(&this_flusher.list, &wq->flusher_queue);
2425                         flush_workqueue_prep_cwqs(wq, -1, wq->work_color);
2426                 }
2427         } else {
2428                 /*
2429                  * Oops, color space is full, wait on overflow queue.
2430                  * The next flush completion will assign us
2431                  * flush_color and transfer to flusher_queue.
2432                  */
2433                 list_add_tail(&this_flusher.list, &wq->flusher_overflow);
2434         }
2435
2436         mutex_unlock(&wq->flush_mutex);
2437
2438         wait_for_completion(&this_flusher.done);
2439
2440         /*
2441          * Wake-up-and-cascade phase
2442          *
2443          * First flushers are responsible for cascading flushes and
2444          * handling overflow.  Non-first flushers can simply return.
2445          */
2446         if (wq->first_flusher != &this_flusher)
2447                 return;
2448
2449         mutex_lock(&wq->flush_mutex);
2450
2451         /* we might have raced, check again with mutex held */
2452         if (wq->first_flusher != &this_flusher)
2453                 goto out_unlock;
2454
2455         wq->first_flusher = NULL;
2456
2457         BUG_ON(!list_empty(&this_flusher.list));
2458         BUG_ON(wq->flush_color != this_flusher.flush_color);
2459
2460         while (true) {
2461                 struct wq_flusher *next, *tmp;
2462
2463                 /* complete all the flushers sharing the current flush color */
2464                 list_for_each_entry_safe(next, tmp, &wq->flusher_queue, list) {
2465                         if (next->flush_color != wq->flush_color)
2466                                 break;
2467                         list_del_init(&next->list);
2468                         complete(&next->done);
2469                 }
2470
2471                 BUG_ON(!list_empty(&wq->flusher_overflow) &&
2472                        wq->flush_color != work_next_color(wq->work_color));
2473
2474                 /* this flush_color is finished, advance by one */
2475                 wq->flush_color = work_next_color(wq->flush_color);
2476
2477                 /* one color has been freed, handle overflow queue */
2478                 if (!list_empty(&wq->flusher_overflow)) {
2479                         /*
2480                          * Assign the same color to all overflowed
2481                          * flushers, advance work_color and append to
2482                          * flusher_queue.  This is the start-to-wait
2483                          * phase for these overflowed flushers.
2484                          */
2485                         list_for_each_entry(tmp, &wq->flusher_overflow, list)
2486                                 tmp->flush_color = wq->work_color;
2487
2488                         wq->work_color = work_next_color(wq->work_color);
2489
2490                         list_splice_tail_init(&wq->flusher_overflow,
2491                                               &wq->flusher_queue);
2492                         flush_workqueue_prep_cwqs(wq, -1, wq->work_color);
2493                 }
2494
2495                 if (list_empty(&wq->flusher_queue)) {
2496                         BUG_ON(wq->flush_color != wq->work_color);
2497                         break;
2498                 }
2499
2500                 /*
2501                  * Need to flush more colors.  Make the next flusher
2502                  * the new first flusher and arm cwqs.
2503                  */
2504                 BUG_ON(wq->flush_color == wq->work_color);
2505                 BUG_ON(wq->flush_color != next->flush_color);
2506
2507                 list_del_init(&next->list);
2508                 wq->first_flusher = next;
2509
2510                 if (flush_workqueue_prep_cwqs(wq, wq->flush_color, -1))
2511                         break;
2512
2513                 /*
2514                  * Meh... this color is already done, clear first
2515                  * flusher and repeat cascading.
2516                  */
2517                 wq->first_flusher = NULL;
2518         }
2519
2520 out_unlock:
2521         mutex_unlock(&wq->flush_mutex);
2522 }
2523 EXPORT_SYMBOL_GPL(flush_workqueue);
2524
2525 /**
2526  * drain_workqueue - drain a workqueue
2527  * @wq: workqueue to drain
2528  *
2529  * Wait until the workqueue becomes empty.  While draining is in progress,
2530  * only chain queueing is allowed.  IOW, only currently pending or running
2531  * work items on @wq can queue further work items on it.  @wq is flushed
2532  * repeatedly until it becomes empty.  The number of flushing is detemined
2533  * by the depth of chaining and should be relatively short.  Whine if it
2534  * takes too long.
2535  */
2536 void drain_workqueue(struct workqueue_struct *wq)
2537 {
2538         unsigned int flush_cnt = 0;
2539         unsigned int cpu;
2540
2541         /*
2542          * __queue_work() needs to test whether there are drainers, is much
2543          * hotter than drain_workqueue() and already looks at @wq->flags.
2544          * Use WQ_DRAINING so that queue doesn't have to check nr_drainers.
2545          */
2546         spin_lock(&workqueue_lock);
2547         if (!wq->nr_drainers++)
2548                 wq->flags |= WQ_DRAINING;
2549         spin_unlock(&workqueue_lock);
2550 reflush:
2551         flush_workqueue(wq);
2552
2553         for_each_cwq_cpu(cpu, wq) {
2554                 struct cpu_workqueue_struct *cwq = get_cwq(cpu, wq);
2555                 bool drained;
2556
2557                 spin_lock_irq(&cwq->pool->gcwq->lock);
2558                 drained = !cwq->nr_active && list_empty(&cwq->delayed_works);
2559                 spin_unlock_irq(&cwq->pool->gcwq->lock);
2560
2561                 if (drained)
2562                         continue;
2563
2564                 if (++flush_cnt == 10 ||
2565                     (flush_cnt % 100 == 0 && flush_cnt <= 1000))
2566                         pr_warning("workqueue %s: flush on destruction isn't complete after %u tries\n",
2567                                    wq->name, flush_cnt);
2568                 goto reflush;
2569         }
2570
2571         spin_lock(&workqueue_lock);
2572         if (!--wq->nr_drainers)
2573                 wq->flags &= ~WQ_DRAINING;
2574         spin_unlock(&workqueue_lock);
2575 }
2576 EXPORT_SYMBOL_GPL(drain_workqueue);
2577
2578 static bool start_flush_work(struct work_struct *work, struct wq_barrier *barr,
2579                              bool wait_executing)
2580 {
2581         struct worker *worker = NULL;
2582         struct global_cwq *gcwq;
2583         struct cpu_workqueue_struct *cwq;
2584
2585         might_sleep();
2586         gcwq = get_work_gcwq(work);
2587         if (!gcwq)
2588                 return false;
2589
2590         spin_lock_irq(&gcwq->lock);
2591         if (!list_empty(&work->entry)) {
2592                 /*
2593                  * See the comment near try_to_grab_pending()->smp_rmb().
2594                  * If it was re-queued to a different gcwq under us, we
2595                  * are not going to wait.
2596                  */
2597                 smp_rmb();
2598                 cwq = get_work_cwq(work);
2599                 if (unlikely(!cwq || gcwq != cwq->pool->gcwq))
2600                         goto already_gone;
2601         } else if (wait_executing) {
2602                 worker = find_worker_executing_work(gcwq, work);
2603                 if (!worker)
2604                         goto already_gone;
2605                 cwq = worker->current_cwq;
2606         } else
2607                 goto already_gone;
2608
2609         insert_wq_barrier(cwq, barr, work, worker);
2610         spin_unlock_irq(&gcwq->lock);
2611
2612         /*
2613          * If @max_active is 1 or rescuer is in use, flushing another work
2614          * item on the same workqueue may lead to deadlock.  Make sure the
2615          * flusher is not running on the same workqueue by verifying write
2616          * access.
2617          */
2618         if (cwq->wq->saved_max_active == 1 || cwq->wq->flags & WQ_RESCUER)
2619                 lock_map_acquire(&cwq->wq->lockdep_map);
2620         else
2621                 lock_map_acquire_read(&cwq->wq->lockdep_map);
2622         lock_map_release(&cwq->wq->lockdep_map);
2623
2624         return true;
2625 already_gone:
2626         spin_unlock_irq(&gcwq->lock);
2627         return false;
2628 }
2629
2630 /**
2631  * flush_work - wait for a work to finish executing the last queueing instance
2632  * @work: the work to flush
2633  *
2634  * Wait until @work has finished execution.  This function considers
2635  * only the last queueing instance of @work.  If @work has been
2636  * enqueued across different CPUs on a non-reentrant workqueue or on
2637  * multiple workqueues, @work might still be executing on return on
2638  * some of the CPUs from earlier queueing.
2639  *
2640  * If @work was queued only on a non-reentrant, ordered or unbound
2641  * workqueue, @work is guaranteed to be idle on return if it hasn't
2642  * been requeued since flush started.
2643  *
2644  * RETURNS:
2645  * %true if flush_work() waited for the work to finish execution,
2646  * %false if it was already idle.
2647  */
2648 bool flush_work(struct work_struct *work)
2649 {
2650         struct wq_barrier barr;
2651
2652         if (start_flush_work(work, &barr, true)) {
2653                 wait_for_completion(&barr.done);
2654                 destroy_work_on_stack(&barr.work);
2655                 return true;
2656         } else
2657                 return false;
2658 }
2659 EXPORT_SYMBOL_GPL(flush_work);
2660
2661 static bool wait_on_cpu_work(struct global_cwq *gcwq, struct work_struct *work)
2662 {
2663         struct wq_barrier barr;
2664         struct worker *worker;
2665
2666         spin_lock_irq(&gcwq->lock);
2667
2668         worker = find_worker_executing_work(gcwq, work);
2669         if (unlikely(worker))
2670                 insert_wq_barrier(worker->current_cwq, &barr, work, worker);
2671
2672         spin_unlock_irq(&gcwq->lock);
2673
2674         if (unlikely(worker)) {
2675                 wait_for_completion(&barr.done);
2676                 destroy_work_on_stack(&barr.work);
2677                 return true;
2678         } else
2679                 return false;
2680 }
2681
2682 static bool wait_on_work(struct work_struct *work)
2683 {
2684         bool ret = false;
2685         int cpu;
2686
2687         might_sleep();
2688
2689         lock_map_acquire(&work->lockdep_map);
2690         lock_map_release(&work->lockdep_map);
2691
2692         for_each_gcwq_cpu(cpu)
2693                 ret |= wait_on_cpu_work(get_gcwq(cpu), work);
2694         return ret;
2695 }
2696
2697 /**
2698  * flush_work_sync - wait until a work has finished execution
2699  * @work: the work to flush
2700  *
2701  * Wait until @work has finished execution.  On return, it's
2702  * guaranteed that all queueing instances of @work which happened
2703  * before this function is called are finished.  In other words, if
2704  * @work hasn't been requeued since this function was called, @work is
2705  * guaranteed to be idle on return.
2706  *
2707  * RETURNS:
2708  * %true if flush_work_sync() waited for the work to finish execution,
2709  * %false if it was already idle.
2710  */
2711 bool flush_work_sync(struct work_struct *work)
2712 {
2713         struct wq_barrier barr;
2714         bool pending, waited;
2715
2716         /* we'll wait for executions separately, queue barr only if pending */
2717         pending = start_flush_work(work, &barr, false);
2718
2719         /* wait for executions to finish */
2720         waited = wait_on_work(work);
2721
2722         /* wait for the pending one */
2723         if (pending) {
2724                 wait_for_completion(&barr.done);
2725                 destroy_work_on_stack(&barr.work);
2726         }
2727
2728         return pending || waited;
2729 }
2730 EXPORT_SYMBOL_GPL(flush_work_sync);
2731
2732 /*
2733  * Upon a successful return (>= 0), the caller "owns" WORK_STRUCT_PENDING bit,
2734  * so this work can't be re-armed in any way.
2735  */
2736 static int try_to_grab_pending(struct work_struct *work)
2737 {
2738         struct global_cwq *gcwq;
2739         int ret = -1;
2740
2741         if (!test_and_set_bit(WORK_STRUCT_PENDING_BIT, work_data_bits(work)))
2742                 return 0;
2743
2744         /*
2745          * The queueing is in progress, or it is already queued. Try to
2746          * steal it from ->worklist without clearing WORK_STRUCT_PENDING.
2747          */
2748         gcwq = get_work_gcwq(work);
2749         if (!gcwq)
2750                 return ret;
2751
2752         spin_lock_irq(&gcwq->lock);
2753         if (!list_empty(&work->entry)) {
2754                 /*
2755                  * This work is queued, but perhaps we locked the wrong gcwq.
2756                  * In that case we must see the new value after rmb(), see
2757                  * insert_work()->wmb().
2758                  */
2759                 smp_rmb();
2760                 if (gcwq == get_work_gcwq(work)) {
2761                         debug_work_deactivate(work);
2762                         list_del_init(&work->entry);
2763                         cwq_dec_nr_in_flight(get_work_cwq(work),
2764                                 get_work_color(work),
2765                                 *work_data_bits(work) & WORK_STRUCT_DELAYED);
2766                         ret = 1;
2767                 }
2768         }
2769         spin_unlock_irq(&gcwq->lock);
2770
2771         return ret;
2772 }
2773
2774 static bool __cancel_work_timer(struct work_struct *work,
2775                                 struct timer_list* timer)
2776 {
2777         int ret;
2778
2779         do {
2780                 ret = (timer && likely(del_timer(timer)));
2781                 if (!ret)
2782                         ret = try_to_grab_pending(work);
2783                 wait_on_work(work);
2784         } while (unlikely(ret < 0));
2785
2786         clear_work_data(work);
2787         return ret;
2788 }
2789
2790 /**
2791  * cancel_work_sync - cancel a work and wait for it to finish
2792  * @work: the work to cancel
2793  *
2794  * Cancel @work and wait for its execution to finish.  This function
2795  * can be used even if the work re-queues itself or migrates to
2796  * another workqueue.  On return from this function, @work is
2797  * guaranteed to be not pending or executing on any CPU.
2798  *
2799  * cancel_work_sync(&delayed_work->work) must not be used for
2800  * delayed_work's.  Use cancel_delayed_work_sync() instead.
2801  *
2802  * The caller must ensure that the workqueue on which @work was last
2803  * queued can't be destroyed before this function returns.
2804  *
2805  * RETURNS:
2806  * %true if @work was pending, %false otherwise.
2807  */
2808 bool cancel_work_sync(struct work_struct *work)
2809 {
2810         return __cancel_work_timer(work, NULL);
2811 }
2812 EXPORT_SYMBOL_GPL(cancel_work_sync);
2813
2814 /**
2815  * flush_delayed_work - wait for a dwork to finish executing the last queueing
2816  * @dwork: the delayed work to flush
2817  *
2818  * Delayed timer is cancelled and the pending work is queued for
2819  * immediate execution.  Like flush_work(), this function only
2820  * considers the last queueing instance of @dwork.
2821  *
2822  * RETURNS:
2823  * %true if flush_work() waited for the work to finish execution,
2824  * %false if it was already idle.
2825  */
2826 bool flush_delayed_work(struct delayed_work *dwork)
2827 {
2828         if (del_timer_sync(&dwork->timer))
2829                 __queue_work(raw_smp_processor_id(),
2830                              get_work_cwq(&dwork->work)->wq, &dwork->work);
2831         return flush_work(&dwork->work);
2832 }
2833 EXPORT_SYMBOL(flush_delayed_work);
2834
2835 /**
2836  * flush_delayed_work_sync - wait for a dwork to finish
2837  * @dwork: the delayed work to flush
2838  *
2839  * Delayed timer is cancelled and the pending work is queued for
2840  * execution immediately.  Other than timer handling, its behavior
2841  * is identical to flush_work_sync().
2842  *
2843  * RETURNS:
2844  * %true if flush_work_sync() waited for the work to finish execution,
2845  * %false if it was already idle.
2846  */
2847 bool flush_delayed_work_sync(struct delayed_work *dwork)
2848 {
2849         if (del_timer_sync(&dwork->timer))
2850                 __queue_work(raw_smp_processor_id(),
2851                              get_work_cwq(&dwork->work)->wq, &dwork->work);
2852         return flush_work_sync(&dwork->work);
2853 }
2854 EXPORT_SYMBOL(flush_delayed_work_sync);
2855
2856 /**
2857  * cancel_delayed_work_sync - cancel a delayed work and wait for it to finish
2858  * @dwork: the delayed work cancel
2859  *
2860  * This is cancel_work_sync() for delayed works.
2861  *
2862  * RETURNS:
2863  * %true if @dwork was pending, %false otherwise.
2864  */
2865 bool cancel_delayed_work_sync(struct delayed_work *dwork)
2866 {
2867         return __cancel_work_timer(&dwork->work, &dwork->timer);
2868 }
2869 EXPORT_SYMBOL(cancel_delayed_work_sync);
2870
2871 /**
2872  * schedule_work - put work task in global workqueue
2873  * @work: job to be done
2874  *
2875  * Returns zero if @work was already on the kernel-global workqueue and
2876  * non-zero otherwise.
2877  *
2878  * This puts a job in the kernel-global workqueue if it was not already
2879  * queued and leaves it in the same position on the kernel-global
2880  * workqueue otherwise.
2881  */
2882 int schedule_work(struct work_struct *work)
2883 {
2884         return queue_work(system_wq, work);
2885 }
2886 EXPORT_SYMBOL(schedule_work);
2887
2888 /*
2889  * schedule_work_on - put work task on a specific cpu
2890  * @cpu: cpu to put the work task on
2891  * @work: job to be done
2892  *
2893  * This puts a job on a specific cpu
2894  */
2895 int schedule_work_on(int cpu, struct work_struct *work)
2896 {
2897         return queue_work_on(cpu, system_wq, work);
2898 }
2899 EXPORT_SYMBOL(schedule_work_on);
2900
2901 /**
2902  * schedule_delayed_work - put work task in global workqueue after delay
2903  * @dwork: job to be done
2904  * @delay: number of jiffies to wait or 0 for immediate execution
2905  *
2906  * After waiting for a given time this puts a job in the kernel-global
2907  * workqueue.
2908  */
2909 int schedule_delayed_work(struct delayed_work *dwork,
2910                                         unsigned long delay)
2911 {
2912         return queue_delayed_work(system_wq, dwork, delay);
2913 }
2914 EXPORT_SYMBOL(schedule_delayed_work);
2915
2916 /**
2917  * schedule_delayed_work_on - queue work in global workqueue on CPU after delay
2918  * @cpu: cpu to use
2919  * @dwork: job to be done
2920  * @delay: number of jiffies to wait
2921  *
2922  * After waiting for a given time this puts a job in the kernel-global
2923  * workqueue on the specified CPU.
2924  */
2925 int schedule_delayed_work_on(int cpu,
2926                         struct delayed_work *dwork, unsigned long delay)
2927 {
2928         return queue_delayed_work_on(cpu, system_wq, dwork, delay);
2929 }
2930 EXPORT_SYMBOL(schedule_delayed_work_on);
2931
2932 /**
2933  * schedule_on_each_cpu - execute a function synchronously on each online CPU
2934  * @func: the function to call
2935  *
2936  * schedule_on_each_cpu() executes @func on each online CPU using the
2937  * system workqueue and blocks until all CPUs have completed.
2938  * schedule_on_each_cpu() is very slow.
2939  *
2940  * RETURNS:
2941  * 0 on success, -errno on failure.
2942  */
2943 int schedule_on_each_cpu(work_func_t func)
2944 {
2945         int cpu;
2946         struct work_struct __percpu *works;
2947
2948         works = alloc_percpu(struct work_struct);
2949         if (!works)
2950                 return -ENOMEM;
2951
2952         get_online_cpus();
2953
2954         for_each_online_cpu(cpu) {
2955                 struct work_struct *work = per_cpu_ptr(works, cpu);
2956
2957                 INIT_WORK(work, func);
2958                 schedule_work_on(cpu, work);
2959         }
2960
2961         for_each_online_cpu(cpu)
2962                 flush_work(per_cpu_ptr(works, cpu));
2963
2964         put_online_cpus();
2965         free_percpu(works);
2966         return 0;
2967 }
2968
2969 /**
2970  * flush_scheduled_work - ensure that any scheduled work has run to completion.
2971  *
2972  * Forces execution of the kernel-global workqueue and blocks until its
2973  * completion.
2974  *
2975  * Think twice before calling this function!  It's very easy to get into
2976  * trouble if you don't take great care.  Either of the following situations
2977  * will lead to deadlock:
2978  *
2979  *      One of the work items currently on the workqueue needs to acquire
2980  *      a lock held by your code or its caller.
2981  *
2982  *      Your code is running in the context of a work routine.
2983  *
2984  * They will be detected by lockdep when they occur, but the first might not
2985  * occur very often.  It depends on what work items are on the workqueue and
2986  * what locks they need, which you have no control over.
2987  *
2988  * In most situations flushing the entire workqueue is overkill; you merely
2989  * need to know that a particular work item isn't queued and isn't running.
2990  * In such cases you should use cancel_delayed_work_sync() or
2991  * cancel_work_sync() instead.
2992  */
2993 void flush_scheduled_work(void)
2994 {
2995         flush_workqueue(system_wq);
2996 }
2997 EXPORT_SYMBOL(flush_scheduled_work);
2998
2999 /**
3000  * execute_in_process_context - reliably execute the routine with user context
3001  * @fn:         the function to execute
3002  * @ew:         guaranteed storage for the execute work structure (must
3003  *              be available when the work executes)
3004  *
3005  * Executes the function immediately if process context is available,
3006  * otherwise schedules the function for delayed execution.
3007  *
3008  * Returns:     0 - function was executed
3009  *              1 - function was scheduled for execution
3010  */
3011 int execute_in_process_context(work_func_t fn, struct execute_work *ew)
3012 {
3013         if (!in_interrupt()) {
3014                 fn(&ew->work);
3015                 return 0;
3016         }
3017
3018         INIT_WORK(&ew->work, fn);
3019         schedule_work(&ew->work);
3020
3021         return 1;
3022 }
3023 EXPORT_SYMBOL_GPL(execute_in_process_context);
3024
3025 int keventd_up(void)
3026 {
3027         return system_wq != NULL;
3028 }
3029
3030 static int alloc_cwqs(struct workqueue_struct *wq)
3031 {
3032         /*
3033          * cwqs are forced aligned according to WORK_STRUCT_FLAG_BITS.
3034          * Make sure that the alignment isn't lower than that of
3035          * unsigned long long.
3036          */
3037         const size_t size = sizeof(struct cpu_workqueue_struct);
3038         const size_t align = max_t(size_t, 1 << WORK_STRUCT_FLAG_BITS,
3039                                    __alignof__(unsigned long long));
3040 #ifdef CONFIG_SMP
3041         bool percpu = !(wq->flags & WQ_UNBOUND);
3042 #else
3043         bool percpu = false;
3044 #endif
3045
3046         if (percpu)
3047                 wq->cpu_wq.pcpu = __alloc_percpu(size, align);
3048         else {
3049                 void *ptr;
3050
3051                 /*
3052                  * Allocate enough room to align cwq and put an extra
3053                  * pointer at the end pointing back to the originally
3054                  * allocated pointer which will be used for free.
3055                  */
3056                 ptr = kzalloc(size + align + sizeof(void *), GFP_KERNEL);
3057                 if (ptr) {
3058                         wq->cpu_wq.single = PTR_ALIGN(ptr, align);
3059                         *(void **)(wq->cpu_wq.single + 1) = ptr;
3060                 }
3061         }
3062
3063         /* just in case, make sure it's actually aligned */
3064         BUG_ON(!IS_ALIGNED(wq->cpu_wq.v, align));
3065         return wq->cpu_wq.v ? 0 : -ENOMEM;
3066 }
3067
3068 static void free_cwqs(struct workqueue_struct *wq)
3069 {
3070 #ifdef CONFIG_SMP
3071         bool percpu = !(wq->flags & WQ_UNBOUND);
3072 #else
3073         bool percpu = false;
3074 #endif
3075
3076         if (percpu)
3077                 free_percpu(wq->cpu_wq.pcpu);
3078         else if (wq->cpu_wq.single) {
3079                 /* the pointer to free is stored right after the cwq */
3080                 kfree(*(void **)(wq->cpu_wq.single + 1));
3081         }
3082 }
3083
3084 static int wq_clamp_max_active(int max_active, unsigned int flags,
3085                                const char *name)
3086 {
3087         int lim = flags & WQ_UNBOUND ? WQ_UNBOUND_MAX_ACTIVE : WQ_MAX_ACTIVE;
3088
3089         if (max_active < 1 || max_active > lim)
3090                 printk(KERN_WARNING "workqueue: max_active %d requested for %s "
3091                        "is out of range, clamping between %d and %d\n",
3092                        max_active, name, 1, lim);
3093
3094         return clamp_val(max_active, 1, lim);
3095 }
3096
3097 struct workqueue_struct *__alloc_workqueue_key(const char *name,
3098                                                unsigned int flags,
3099                                                int max_active,
3100                                                struct lock_class_key *key,
3101                                                const char *lock_name)
3102 {
3103         struct workqueue_struct *wq;
3104         unsigned int cpu;
3105
3106         /*
3107          * Workqueues which may be used during memory reclaim should
3108          * have a rescuer to guarantee forward progress.
3109          */
3110         if (flags & WQ_MEM_RECLAIM)
3111                 flags |= WQ_RESCUER;
3112
3113         max_active = max_active ?: WQ_DFL_ACTIVE;
3114         max_active = wq_clamp_max_active(max_active, flags, name);
3115
3116         wq = kzalloc(sizeof(*wq), GFP_KERNEL);
3117         if (!wq)
3118                 goto err;
3119
3120         wq->flags = flags;
3121         wq->saved_max_active = max_active;
3122         mutex_init(&wq->flush_mutex);
3123         atomic_set(&wq->nr_cwqs_to_flush, 0);
3124         INIT_LIST_HEAD(&wq->flusher_queue);
3125         INIT_LIST_HEAD(&wq->flusher_overflow);
3126
3127         wq->name = name;
3128         lockdep_init_map(&wq->lockdep_map, lock_name, key, 0);
3129         INIT_LIST_HEAD(&wq->list);
3130
3131         if (alloc_cwqs(wq) < 0)
3132                 goto err;
3133
3134         for_each_cwq_cpu(cpu, wq) {
3135                 struct cpu_workqueue_struct *cwq = get_cwq(cpu, wq);
3136                 struct global_cwq *gcwq = get_gcwq(cpu);
3137                 int pool_idx = (bool)(flags & WQ_HIGHPRI);
3138
3139                 BUG_ON((unsigned long)cwq & WORK_STRUCT_FLAG_MASK);
3140                 cwq->pool = &gcwq->pools[pool_idx];
3141                 cwq->wq = wq;
3142                 cwq->flush_color = -1;
3143                 cwq->max_active = max_active;
3144                 INIT_LIST_HEAD(&cwq->delayed_works);
3145         }
3146
3147         if (flags & WQ_RESCUER) {
3148                 struct worker *rescuer;
3149
3150                 if (!alloc_mayday_mask(&wq->mayday_mask, GFP_KERNEL))
3151                         goto err;
3152
3153                 wq->rescuer = rescuer = alloc_worker();
3154                 if (!rescuer)
3155                         goto err;
3156
3157                 rescuer->task = kthread_create(rescuer_thread, wq, "%s", name);
3158                 if (IS_ERR(rescuer->task))
3159                         goto err;
3160
3161                 rescuer->task->flags |= PF_THREAD_BOUND;
3162                 wake_up_process(rescuer->task);
3163         }
3164
3165         /*
3166          * workqueue_lock protects global freeze state and workqueues
3167          * list.  Grab it, set max_active accordingly and add the new
3168          * workqueue to workqueues list.
3169          */
3170         spin_lock(&workqueue_lock);
3171
3172         if (workqueue_freezing && wq->flags & WQ_FREEZABLE)
3173                 for_each_cwq_cpu(cpu, wq)
3174                         get_cwq(cpu, wq)->max_active = 0;
3175
3176         list_add(&wq->list, &workqueues);
3177
3178         spin_unlock(&workqueue_lock);
3179
3180         return wq;
3181 err:
3182         if (wq) {
3183                 free_cwqs(wq);
3184                 free_mayday_mask(wq->mayday_mask);
3185                 kfree(wq->rescuer);
3186                 kfree(wq);
3187         }
3188         return NULL;
3189 }
3190 EXPORT_SYMBOL_GPL(__alloc_workqueue_key);
3191
3192 /**
3193  * destroy_workqueue - safely terminate a workqueue
3194  * @wq: target workqueue
3195  *
3196  * Safely destroy a workqueue. All work currently pending will be done first.
3197  */
3198 void destroy_workqueue(struct workqueue_struct *wq)
3199 {
3200         unsigned int cpu;
3201
3202         /* drain it before proceeding with destruction */
3203         drain_workqueue(wq);
3204
3205         /*
3206          * wq list is used to freeze wq, remove from list after
3207          * flushing is complete in case freeze races us.
3208          */
3209         spin_lock(&workqueue_lock);
3210         list_del(&wq->list);
3211         spin_unlock(&workqueue_lock);
3212
3213         /* sanity check */
3214         for_each_cwq_cpu(cpu, wq) {
3215                 struct cpu_workqueue_struct *cwq = get_cwq(cpu, wq);
3216                 int i;
3217
3218                 for (i = 0; i < WORK_NR_COLORS; i++)
3219                         BUG_ON(cwq->nr_in_flight[i]);
3220                 BUG_ON(cwq->nr_active);
3221                 BUG_ON(!list_empty(&cwq->delayed_works));
3222         }
3223
3224         if (wq->flags & WQ_RESCUER) {
3225                 kthread_stop(wq->rescuer->task);
3226                 free_mayday_mask(wq->mayday_mask);
3227                 kfree(wq->rescuer);
3228         }
3229
3230         free_cwqs(wq);
3231         kfree(wq);
3232 }
3233 EXPORT_SYMBOL_GPL(destroy_workqueue);
3234
3235 /**
3236  * workqueue_set_max_active - adjust max_active of a workqueue
3237  * @wq: target workqueue
3238  * @max_active: new max_active value.
3239  *
3240  * Set max_active of @wq to @max_active.
3241  *
3242  * CONTEXT:
3243  * Don't call from IRQ context.
3244  */
3245 void workqueue_set_max_active(struct workqueue_struct *wq, int max_active)
3246 {
3247         unsigned int cpu;
3248
3249         max_active = wq_clamp_max_active(max_active, wq->flags, wq->name);
3250
3251         spin_lock(&workqueue_lock);
3252
3253         wq->saved_max_active = max_active;
3254
3255         for_each_cwq_cpu(cpu, wq) {
3256                 struct global_cwq *gcwq = get_gcwq(cpu);
3257
3258                 spin_lock_irq(&gcwq->lock);
3259
3260                 if (!(wq->flags & WQ_FREEZABLE) ||
3261                     !(gcwq->flags & GCWQ_FREEZING))
3262                         get_cwq(gcwq->cpu, wq)->max_active = max_active;
3263
3264                 spin_unlock_irq(&gcwq->lock);
3265         }
3266
3267         spin_unlock(&workqueue_lock);
3268 }
3269 EXPORT_SYMBOL_GPL(workqueue_set_max_active);
3270
3271 /**
3272  * workqueue_congested - test whether a workqueue is congested
3273  * @cpu: CPU in question
3274  * @wq: target workqueue
3275  *
3276  * Test whether @wq's cpu workqueue for @cpu is congested.  There is
3277  * no synchronization around this function and the test result is
3278  * unreliable and only useful as advisory hints or for debugging.
3279  *
3280  * RETURNS:
3281  * %true if congested, %false otherwise.
3282  */
3283 bool workqueue_congested(unsigned int cpu, struct workqueue_struct *wq)
3284 {
3285         struct cpu_workqueue_struct *cwq = get_cwq(cpu, wq);
3286
3287         return !list_empty(&cwq->delayed_works);
3288 }
3289 EXPORT_SYMBOL_GPL(workqueue_congested);
3290
3291 /**
3292  * work_cpu - return the last known associated cpu for @work
3293  * @work: the work of interest
3294  *
3295  * RETURNS:
3296  * CPU number if @work was ever queued.  WORK_CPU_NONE otherwise.
3297  */
3298 unsigned int work_cpu(struct work_struct *work)
3299 {
3300         struct global_cwq *gcwq = get_work_gcwq(work);
3301
3302         return gcwq ? gcwq->cpu : WORK_CPU_NONE;
3303 }
3304 EXPORT_SYMBOL_GPL(work_cpu);
3305
3306 /**
3307  * work_busy - test whether a work is currently pending or running
3308  * @work: the work to be tested
3309  *
3310  * Test whether @work is currently pending or running.  There is no
3311  * synchronization around this function and the test result is
3312  * unreliable and only useful as advisory hints or for debugging.
3313  * Especially for reentrant wqs, the pending state might hide the
3314  * running state.
3315  *
3316  * RETURNS:
3317  * OR'd bitmask of WORK_BUSY_* bits.
3318  */
3319 unsigned int work_busy(struct work_struct *work)
3320 {
3321         struct global_cwq *gcwq = get_work_gcwq(work);
3322         unsigned long flags;
3323         unsigned int ret = 0;
3324
3325         if (!gcwq)
3326                 return false;
3327
3328         spin_lock_irqsave(&gcwq->lock, flags);
3329
3330         if (work_pending(work))
3331                 ret |= WORK_BUSY_PENDING;
3332         if (find_worker_executing_work(gcwq, work))
3333                 ret |= WORK_BUSY_RUNNING;
3334
3335         spin_unlock_irqrestore(&gcwq->lock, flags);
3336
3337         return ret;
3338 }
3339 EXPORT_SYMBOL_GPL(work_busy);
3340
3341 /*
3342  * CPU hotplug.
3343  *
3344  * There are two challenges in supporting CPU hotplug.  Firstly, there
3345  * are a lot of assumptions on strong associations among work, cwq and
3346  * gcwq which make migrating pending and scheduled works very
3347  * difficult to implement without impacting hot paths.  Secondly,
3348  * gcwqs serve mix of short, long and very long running works making
3349  * blocked draining impractical.
3350  *
3351  * This is solved by allowing a gcwq to be disassociated from the CPU
3352  * running as an unbound one and allowing it to be reattached later if the
3353  * cpu comes back online.
3354  */
3355
3356 /* claim manager positions of all pools */
3357 static void gcwq_claim_management_and_lock(struct global_cwq *gcwq)
3358 {
3359         struct worker_pool *pool;
3360
3361         for_each_worker_pool(pool, gcwq)
3362                 mutex_lock_nested(&pool->manager_mutex, pool - gcwq->pools);
3363         spin_lock_irq(&gcwq->lock);
3364 }
3365
3366 /* release manager positions */
3367 static void gcwq_release_management_and_unlock(struct global_cwq *gcwq)
3368 {
3369         struct worker_pool *pool;
3370
3371         spin_unlock_irq(&gcwq->lock);
3372         for_each_worker_pool(pool, gcwq)
3373                 mutex_unlock(&pool->manager_mutex);
3374 }
3375
3376 static void gcwq_unbind_fn(struct work_struct *work)
3377 {
3378         struct global_cwq *gcwq = get_gcwq(smp_processor_id());
3379         struct worker_pool *pool;
3380         struct worker *worker;
3381         struct hlist_node *pos;
3382         int i;
3383
3384         BUG_ON(gcwq->cpu != smp_processor_id());
3385
3386         gcwq_claim_management_and_lock(gcwq);
3387
3388         /*
3389          * We've claimed all manager positions.  Make all workers unbound
3390          * and set DISASSOCIATED.  Before this, all workers except for the
3391          * ones which are still executing works from before the last CPU
3392          * down must be on the cpu.  After this, they may become diasporas.
3393          */
3394         for_each_worker_pool(pool, gcwq)
3395                 list_for_each_entry(worker, &pool->idle_list, entry)
3396                         worker->flags |= WORKER_UNBOUND;
3397
3398         for_each_busy_worker(worker, i, pos, gcwq)
3399                 worker->flags |= WORKER_UNBOUND;
3400
3401         gcwq->flags |= GCWQ_DISASSOCIATED;
3402
3403         gcwq_release_management_and_unlock(gcwq);
3404
3405         /*
3406          * Call schedule() so that we cross rq->lock and thus can guarantee
3407          * sched callbacks see the %WORKER_UNBOUND flag.  This is necessary
3408          * as scheduler callbacks may be invoked from other cpus.
3409          */
3410         schedule();
3411
3412         /*
3413          * Sched callbacks are disabled now.  Zap nr_running.  After this,
3414          * nr_running stays zero and need_more_worker() and keep_working()
3415          * are always true as long as the worklist is not empty.  @gcwq now
3416          * behaves as unbound (in terms of concurrency management) gcwq
3417          * which is served by workers tied to the CPU.
3418          *
3419          * On return from this function, the current worker would trigger
3420          * unbound chain execution of pending work items if other workers
3421          * didn't already.
3422          */
3423         for_each_worker_pool(pool, gcwq)
3424                 atomic_set(get_pool_nr_running(pool), 0);
3425 }
3426
3427 /*
3428  * Workqueues should be brought up before normal priority CPU notifiers.
3429  * This will be registered high priority CPU notifier.
3430  */
3431 static int __devinit workqueue_cpu_up_callback(struct notifier_block *nfb,
3432                                                unsigned long action,
3433                                                void *hcpu)
3434 {
3435         unsigned int cpu = (unsigned long)hcpu;
3436         struct global_cwq *gcwq = get_gcwq(cpu);
3437         struct worker_pool *pool;
3438
3439         switch (action & ~CPU_TASKS_FROZEN) {
3440         case CPU_UP_PREPARE:
3441                 for_each_worker_pool(pool, gcwq) {
3442                         struct worker *worker;
3443
3444                         if (pool->nr_workers)
3445                                 continue;
3446
3447                         worker = create_worker(pool);
3448                         if (!worker)
3449                                 return NOTIFY_BAD;
3450
3451                         spin_lock_irq(&gcwq->lock);
3452                         start_worker(worker);
3453                         spin_unlock_irq(&gcwq->lock);
3454                 }
3455                 break;
3456
3457         case CPU_DOWN_FAILED:
3458         case CPU_ONLINE:
3459                 gcwq_claim_management_and_lock(gcwq);
3460                 gcwq->flags &= ~GCWQ_DISASSOCIATED;
3461                 rebind_workers(gcwq);
3462                 gcwq_release_management_and_unlock(gcwq);
3463                 break;
3464         }
3465         return NOTIFY_OK;
3466 }
3467
3468 /*
3469  * Workqueues should be brought down after normal priority CPU notifiers.
3470  * This will be registered as low priority CPU notifier.
3471  */
3472 static int __devinit workqueue_cpu_down_callback(struct notifier_block *nfb,
3473                                                  unsigned long action,
3474                                                  void *hcpu)
3475 {
3476         unsigned int cpu = (unsigned long)hcpu;
3477         struct work_struct unbind_work;
3478
3479         switch (action & ~CPU_TASKS_FROZEN) {
3480         case CPU_DOWN_PREPARE:
3481                 /* unbinding should happen on the local CPU */
3482                 INIT_WORK_ONSTACK(&unbind_work, gcwq_unbind_fn);
3483                 schedule_work_on(cpu, &unbind_work);
3484                 flush_work(&unbind_work);
3485                 break;
3486         }
3487         return NOTIFY_OK;
3488 }
3489
3490 #ifdef CONFIG_SMP
3491
3492 struct work_for_cpu {
3493         struct completion completion;
3494         long (*fn)(void *);
3495         void *arg;
3496         long ret;
3497 };
3498
3499 static int do_work_for_cpu(void *_wfc)
3500 {
3501         struct work_for_cpu *wfc = _wfc;
3502         wfc->ret = wfc->fn(wfc->arg);
3503         complete(&wfc->completion);
3504         return 0;
3505 }
3506
3507 /**
3508  * work_on_cpu - run a function in user context on a particular cpu
3509  * @cpu: the cpu to run on
3510  * @fn: the function to run
3511  * @arg: the function arg
3512  *
3513  * This will return the value @fn returns.
3514  * It is up to the caller to ensure that the cpu doesn't go offline.
3515  * The caller must not hold any locks which would prevent @fn from completing.
3516  */
3517 long work_on_cpu(unsigned int cpu, long (*fn)(void *), void *arg)
3518 {
3519         struct task_struct *sub_thread;
3520         struct work_for_cpu wfc = {
3521                 .completion = COMPLETION_INITIALIZER_ONSTACK(wfc.completion),
3522                 .fn = fn,
3523                 .arg = arg,
3524         };
3525
3526         sub_thread = kthread_create(do_work_for_cpu, &wfc, "work_for_cpu");
3527         if (IS_ERR(sub_thread))
3528                 return PTR_ERR(sub_thread);
3529         kthread_bind(sub_thread, cpu);
3530         wake_up_process(sub_thread);
3531         wait_for_completion(&wfc.completion);
3532         return wfc.ret;
3533 }
3534 EXPORT_SYMBOL_GPL(work_on_cpu);
3535 #endif /* CONFIG_SMP */
3536
3537 #ifdef CONFIG_FREEZER
3538
3539 /**
3540  * freeze_workqueues_begin - begin freezing workqueues
3541  *
3542  * Start freezing workqueues.  After this function returns, all freezable
3543  * workqueues will queue new works to their frozen_works list instead of
3544  * gcwq->worklist.
3545  *
3546  * CONTEXT:
3547  * Grabs and releases workqueue_lock and gcwq->lock's.
3548  */
3549 void freeze_workqueues_begin(void)
3550 {
3551         unsigned int cpu;
3552
3553         spin_lock(&workqueue_lock);
3554
3555         BUG_ON(workqueue_freezing);
3556         workqueue_freezing = true;
3557
3558         for_each_gcwq_cpu(cpu) {
3559                 struct global_cwq *gcwq = get_gcwq(cpu);
3560                 struct workqueue_struct *wq;
3561
3562                 spin_lock_irq(&gcwq->lock);
3563
3564                 BUG_ON(gcwq->flags & GCWQ_FREEZING);
3565                 gcwq->flags |= GCWQ_FREEZING;
3566
3567                 list_for_each_entry(wq, &workqueues, list) {
3568                         struct cpu_workqueue_struct *cwq = get_cwq(cpu, wq);
3569
3570                         if (cwq && wq->flags & WQ_FREEZABLE)
3571                                 cwq->max_active = 0;
3572                 }
3573
3574                 spin_unlock_irq(&gcwq->lock);
3575         }
3576
3577         spin_unlock(&workqueue_lock);
3578 }
3579
3580 /**
3581  * freeze_workqueues_busy - are freezable workqueues still busy?
3582  *
3583  * Check whether freezing is complete.  This function must be called
3584  * between freeze_workqueues_begin() and thaw_workqueues().
3585  *
3586  * CONTEXT:
3587  * Grabs and releases workqueue_lock.
3588  *
3589  * RETURNS:
3590  * %true if some freezable workqueues are still busy.  %false if freezing
3591  * is complete.
3592  */
3593 bool freeze_workqueues_busy(void)
3594 {
3595         unsigned int cpu;
3596         bool busy = false;
3597
3598         spin_lock(&workqueue_lock);
3599
3600         BUG_ON(!workqueue_freezing);
3601
3602         for_each_gcwq_cpu(cpu) {
3603                 struct workqueue_struct *wq;
3604                 /*
3605                  * nr_active is monotonically decreasing.  It's safe
3606                  * to peek without lock.
3607                  */
3608                 list_for_each_entry(wq, &workqueues, list) {
3609                         struct cpu_workqueue_struct *cwq = get_cwq(cpu, wq);
3610
3611                         if (!cwq || !(wq->flags & WQ_FREEZABLE))
3612                                 continue;
3613
3614                         BUG_ON(cwq->nr_active < 0);
3615                         if (cwq->nr_active) {
3616                                 busy = true;
3617                                 goto out_unlock;
3618                         }
3619                 }
3620         }
3621 out_unlock:
3622         spin_unlock(&workqueue_lock);
3623         return busy;
3624 }
3625
3626 /**
3627  * thaw_workqueues - thaw workqueues
3628  *
3629  * Thaw workqueues.  Normal queueing is restored and all collected
3630  * frozen works are transferred to their respective gcwq worklists.
3631  *
3632  * CONTEXT:
3633  * Grabs and releases workqueue_lock and gcwq->lock's.
3634  */
3635 void thaw_workqueues(void)
3636 {
3637         unsigned int cpu;
3638
3639         spin_lock(&workqueue_lock);
3640
3641         if (!workqueue_freezing)
3642                 goto out_unlock;
3643
3644         for_each_gcwq_cpu(cpu) {
3645                 struct global_cwq *gcwq = get_gcwq(cpu);
3646                 struct worker_pool *pool;
3647                 struct workqueue_struct *wq;
3648
3649                 spin_lock_irq(&gcwq->lock);
3650
3651                 BUG_ON(!(gcwq->flags & GCWQ_FREEZING));
3652                 gcwq->flags &= ~GCWQ_FREEZING;
3653
3654                 list_for_each_entry(wq, &workqueues, list) {
3655                         struct cpu_workqueue_struct *cwq = get_cwq(cpu, wq);
3656
3657                         if (!cwq || !(wq->flags & WQ_FREEZABLE))
3658                                 continue;
3659
3660                         /* restore max_active and repopulate worklist */
3661                         cwq->max_active = wq->saved_max_active;
3662
3663                         while (!list_empty(&cwq->delayed_works) &&
3664                                cwq->nr_active < cwq->max_active)
3665                                 cwq_activate_first_delayed(cwq);
3666                 }
3667
3668                 for_each_worker_pool(pool, gcwq)
3669                         wake_up_worker(pool);
3670
3671                 spin_unlock_irq(&gcwq->lock);
3672         }
3673
3674         workqueue_freezing = false;
3675 out_unlock:
3676         spin_unlock(&workqueue_lock);
3677 }
3678 #endif /* CONFIG_FREEZER */
3679
3680 static int __init init_workqueues(void)
3681 {
3682         unsigned int cpu;
3683         int i;
3684
3685         cpu_notifier(workqueue_cpu_up_callback, CPU_PRI_WORKQUEUE_UP);
3686         cpu_notifier(workqueue_cpu_down_callback, CPU_PRI_WORKQUEUE_DOWN);
3687
3688         /* initialize gcwqs */
3689         for_each_gcwq_cpu(cpu) {
3690                 struct global_cwq *gcwq = get_gcwq(cpu);
3691                 struct worker_pool *pool;
3692
3693                 spin_lock_init(&gcwq->lock);
3694                 gcwq->cpu = cpu;
3695                 gcwq->flags |= GCWQ_DISASSOCIATED;
3696
3697                 for (i = 0; i < BUSY_WORKER_HASH_SIZE; i++)
3698                         INIT_HLIST_HEAD(&gcwq->busy_hash[i]);
3699
3700                 for_each_worker_pool(pool, gcwq) {
3701                         pool->gcwq = gcwq;
3702                         INIT_LIST_HEAD(&pool->worklist);
3703                         INIT_LIST_HEAD(&pool->idle_list);
3704
3705                         init_timer_deferrable(&pool->idle_timer);
3706                         pool->idle_timer.function = idle_worker_timeout;
3707                         pool->idle_timer.data = (unsigned long)pool;
3708
3709                         setup_timer(&pool->mayday_timer, gcwq_mayday_timeout,
3710                                     (unsigned long)pool);
3711
3712                         mutex_init(&pool->manager_mutex);
3713                         ida_init(&pool->worker_ida);
3714                 }
3715
3716                 init_waitqueue_head(&gcwq->rebind_hold);
3717         }
3718
3719         /* create the initial worker */
3720         for_each_online_gcwq_cpu(cpu) {
3721                 struct global_cwq *gcwq = get_gcwq(cpu);
3722                 struct worker_pool *pool;
3723
3724                 if (cpu != WORK_CPU_UNBOUND)
3725                         gcwq->flags &= ~GCWQ_DISASSOCIATED;
3726
3727                 for_each_worker_pool(pool, gcwq) {
3728                         struct worker *worker;
3729
3730                         worker = create_worker(pool);
3731                         BUG_ON(!worker);
3732                         spin_lock_irq(&gcwq->lock);
3733                         start_worker(worker);
3734                         spin_unlock_irq(&gcwq->lock);
3735                 }
3736         }
3737
3738         system_wq = alloc_workqueue("events", 0, 0);
3739         system_long_wq = alloc_workqueue("events_long", 0, 0);
3740         system_nrt_wq = alloc_workqueue("events_nrt", WQ_NON_REENTRANT, 0);
3741         system_unbound_wq = alloc_workqueue("events_unbound", WQ_UNBOUND,
3742                                             WQ_UNBOUND_MAX_ACTIVE);
3743         system_freezable_wq = alloc_workqueue("events_freezable",
3744                                               WQ_FREEZABLE, 0);
3745         BUG_ON(!system_wq || !system_long_wq || !system_nrt_wq ||
3746                !system_unbound_wq || !system_freezable_wq);
3747         return 0;
3748 }
3749 early_initcall(init_workqueues);