rk3368: tb_8846: change 8846 mode for tsadc
[firefly-linux-kernel-4.4.55.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/export.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 #include <linux/jhash.h>
45 #include <linux/hashtable.h>
46 #include <linux/rculist.h>
47 #include <linux/nodemask.h>
48 #include <linux/moduleparam.h>
49 #include <linux/uaccess.h>
50
51 #include "workqueue_internal.h"
52
53 enum {
54         /*
55          * worker_pool flags
56          *
57          * A bound pool is either associated or disassociated with its CPU.
58          * While associated (!DISASSOCIATED), all workers are bound to the
59          * CPU and none has %WORKER_UNBOUND set and concurrency management
60          * is in effect.
61          *
62          * While DISASSOCIATED, the cpu may be offline and all workers have
63          * %WORKER_UNBOUND set and concurrency management disabled, and may
64          * be executing on any CPU.  The pool behaves as an unbound one.
65          *
66          * Note that DISASSOCIATED should be flipped only while holding
67          * manager_mutex to avoid changing binding state while
68          * create_worker() is in progress.
69          */
70         POOL_MANAGE_WORKERS     = 1 << 0,       /* need to manage workers */
71         POOL_DISASSOCIATED      = 1 << 2,       /* cpu can't serve workers */
72         POOL_FREEZING           = 1 << 3,       /* freeze in progress */
73
74         /* worker flags */
75         WORKER_STARTED          = 1 << 0,       /* started */
76         WORKER_DIE              = 1 << 1,       /* die die die */
77         WORKER_IDLE             = 1 << 2,       /* is idle */
78         WORKER_PREP             = 1 << 3,       /* preparing to run works */
79         WORKER_CPU_INTENSIVE    = 1 << 6,       /* cpu intensive */
80         WORKER_UNBOUND          = 1 << 7,       /* worker is unbound */
81         WORKER_REBOUND          = 1 << 8,       /* worker was rebound */
82
83         WORKER_NOT_RUNNING      = WORKER_PREP | WORKER_CPU_INTENSIVE |
84                                   WORKER_UNBOUND | WORKER_REBOUND,
85
86         NR_STD_WORKER_POOLS     = 2,            /* # standard pools per cpu */
87
88         UNBOUND_POOL_HASH_ORDER = 6,            /* hashed by pool->attrs */
89         BUSY_WORKER_HASH_ORDER  = 6,            /* 64 pointers */
90
91         MAX_IDLE_WORKERS_RATIO  = 4,            /* 1/4 of busy can be idle */
92         IDLE_WORKER_TIMEOUT     = 300 * HZ,     /* keep idle ones for 5 mins */
93
94         MAYDAY_INITIAL_TIMEOUT  = HZ / 100 >= 2 ? HZ / 100 : 2,
95                                                 /* call for help after 10ms
96                                                    (min two ticks) */
97         MAYDAY_INTERVAL         = HZ / 10,      /* and then every 100ms */
98         CREATE_COOLDOWN         = HZ,           /* time to breath after fail */
99
100         /*
101          * Rescue workers are used only on emergencies and shared by
102          * all cpus.  Give -20.
103          */
104         RESCUER_NICE_LEVEL      = -20,
105         HIGHPRI_NICE_LEVEL      = -20,
106
107         WQ_NAME_LEN             = 24,
108 };
109
110 /*
111  * Structure fields follow one of the following exclusion rules.
112  *
113  * I: Modifiable by initialization/destruction paths and read-only for
114  *    everyone else.
115  *
116  * P: Preemption protected.  Disabling preemption is enough and should
117  *    only be modified and accessed from the local cpu.
118  *
119  * L: pool->lock protected.  Access with pool->lock held.
120  *
121  * X: During normal operation, modification requires pool->lock and should
122  *    be done only from local cpu.  Either disabling preemption on local
123  *    cpu or grabbing pool->lock is enough for read access.  If
124  *    POOL_DISASSOCIATED is set, it's identical to L.
125  *
126  * MG: pool->manager_mutex and pool->lock protected.  Writes require both
127  *     locks.  Reads can happen under either lock.
128  *
129  * PL: wq_pool_mutex protected.
130  *
131  * PR: wq_pool_mutex protected for writes.  Sched-RCU protected for reads.
132  *
133  * WQ: wq->mutex protected.
134  *
135  * WR: wq->mutex protected for writes.  Sched-RCU protected for reads.
136  *
137  * MD: wq_mayday_lock protected.
138  */
139
140 /* struct worker is defined in workqueue_internal.h */
141
142 struct worker_pool {
143         spinlock_t              lock;           /* the pool lock */
144         int                     cpu;            /* I: the associated cpu */
145         int                     node;           /* I: the associated node ID */
146         int                     id;             /* I: pool ID */
147         unsigned int            flags;          /* X: flags */
148
149         struct list_head        worklist;       /* L: list of pending works */
150         int                     nr_workers;     /* L: total number of workers */
151
152         /* nr_idle includes the ones off idle_list for rebinding */
153         int                     nr_idle;        /* L: currently idle ones */
154
155         struct list_head        idle_list;      /* X: list of idle workers */
156         struct timer_list       idle_timer;     /* L: worker idle timeout */
157         struct timer_list       mayday_timer;   /* L: SOS timer for workers */
158
159         /* a workers is either on busy_hash or idle_list, or the manager */
160         DECLARE_HASHTABLE(busy_hash, BUSY_WORKER_HASH_ORDER);
161                                                 /* L: hash of busy workers */
162
163         /* see manage_workers() for details on the two manager mutexes */
164         struct mutex            manager_arb;    /* manager arbitration */
165         struct mutex            manager_mutex;  /* manager exclusion */
166         struct idr              worker_idr;     /* MG: worker IDs and iteration */
167
168         struct workqueue_attrs  *attrs;         /* I: worker attributes */
169         struct hlist_node       hash_node;      /* PL: unbound_pool_hash node */
170         int                     refcnt;         /* PL: refcnt for unbound pools */
171
172         /*
173          * The current concurrency level.  As it's likely to be accessed
174          * from other CPUs during try_to_wake_up(), put it in a separate
175          * cacheline.
176          */
177         atomic_t                nr_running ____cacheline_aligned_in_smp;
178
179         /*
180          * Destruction of pool is sched-RCU protected to allow dereferences
181          * from get_work_pool().
182          */
183         struct rcu_head         rcu;
184 } ____cacheline_aligned_in_smp;
185
186 /*
187  * The per-pool workqueue.  While queued, the lower WORK_STRUCT_FLAG_BITS
188  * of work_struct->data are used for flags and the remaining high bits
189  * point to the pwq; thus, pwqs need to be aligned at two's power of the
190  * number of flag bits.
191  */
192 struct pool_workqueue {
193         struct worker_pool      *pool;          /* I: the associated pool */
194         struct workqueue_struct *wq;            /* I: the owning workqueue */
195         int                     work_color;     /* L: current color */
196         int                     flush_color;    /* L: flushing color */
197         int                     refcnt;         /* L: reference count */
198         int                     nr_in_flight[WORK_NR_COLORS];
199                                                 /* L: nr of in_flight works */
200         int                     nr_active;      /* L: nr of active works */
201         int                     max_active;     /* L: max active works */
202         struct list_head        delayed_works;  /* L: delayed works */
203         struct list_head        pwqs_node;      /* WR: node on wq->pwqs */
204         struct list_head        mayday_node;    /* MD: node on wq->maydays */
205
206         /*
207          * Release of unbound pwq is punted to system_wq.  See put_pwq()
208          * and pwq_unbound_release_workfn() for details.  pool_workqueue
209          * itself is also sched-RCU protected so that the first pwq can be
210          * determined without grabbing wq->mutex.
211          */
212         struct work_struct      unbound_release_work;
213         struct rcu_head         rcu;
214 } __aligned(1 << WORK_STRUCT_FLAG_BITS);
215
216 /*
217  * Structure used to wait for workqueue flush.
218  */
219 struct wq_flusher {
220         struct list_head        list;           /* WQ: list of flushers */
221         int                     flush_color;    /* WQ: flush color waiting for */
222         struct completion       done;           /* flush completion */
223 };
224
225 struct wq_device;
226
227 /*
228  * The externally visible workqueue.  It relays the issued work items to
229  * the appropriate worker_pool through its pool_workqueues.
230  */
231 struct workqueue_struct {
232         struct list_head        pwqs;           /* WR: all pwqs of this wq */
233         struct list_head        list;           /* PL: list of all workqueues */
234
235         struct mutex            mutex;          /* protects this wq */
236         int                     work_color;     /* WQ: current work color */
237         int                     flush_color;    /* WQ: current flush color */
238         atomic_t                nr_pwqs_to_flush; /* flush in progress */
239         struct wq_flusher       *first_flusher; /* WQ: first flusher */
240         struct list_head        flusher_queue;  /* WQ: flush waiters */
241         struct list_head        flusher_overflow; /* WQ: flush overflow list */
242
243         struct list_head        maydays;        /* MD: pwqs requesting rescue */
244         struct worker           *rescuer;       /* I: rescue worker */
245
246         int                     nr_drainers;    /* WQ: drain in progress */
247         int                     saved_max_active; /* WQ: saved pwq max_active */
248
249         struct workqueue_attrs  *unbound_attrs; /* WQ: only for unbound wqs */
250         struct pool_workqueue   *dfl_pwq;       /* WQ: only for unbound wqs */
251
252 #ifdef CONFIG_SYSFS
253         struct wq_device        *wq_dev;        /* I: for sysfs interface */
254 #endif
255 #ifdef CONFIG_LOCKDEP
256         struct lockdep_map      lockdep_map;
257 #endif
258         char                    name[WQ_NAME_LEN]; /* I: workqueue name */
259
260         /* hot fields used during command issue, aligned to cacheline */
261         unsigned int            flags ____cacheline_aligned; /* WQ: WQ_* flags */
262         struct pool_workqueue __percpu *cpu_pwqs; /* I: per-cpu pwqs */
263         struct pool_workqueue __rcu *numa_pwq_tbl[]; /* FR: unbound pwqs indexed by node */
264 };
265
266 static struct kmem_cache *pwq_cache;
267
268 static int wq_numa_tbl_len;             /* highest possible NUMA node id + 1 */
269 static cpumask_var_t *wq_numa_possible_cpumask;
270                                         /* possible CPUs of each node */
271
272 static bool wq_disable_numa;
273 module_param_named(disable_numa, wq_disable_numa, bool, 0444);
274
275 /* see the comment above the definition of WQ_POWER_EFFICIENT */
276 #ifdef CONFIG_WQ_POWER_EFFICIENT_DEFAULT
277 static bool wq_power_efficient = true;
278 #else
279 static bool wq_power_efficient;
280 #endif
281
282 module_param_named(power_efficient, wq_power_efficient, bool, 0444);
283
284 static bool wq_numa_enabled;            /* unbound NUMA affinity enabled */
285
286 /* buf for wq_update_unbound_numa_attrs(), protected by CPU hotplug exclusion */
287 static struct workqueue_attrs *wq_update_unbound_numa_attrs_buf;
288
289 static DEFINE_MUTEX(wq_pool_mutex);     /* protects pools and workqueues list */
290 static DEFINE_SPINLOCK(wq_mayday_lock); /* protects wq->maydays list */
291
292 static LIST_HEAD(workqueues);           /* PL: list of all workqueues */
293 static bool workqueue_freezing;         /* PL: have wqs started freezing? */
294
295 /* the per-cpu worker pools */
296 static DEFINE_PER_CPU_SHARED_ALIGNED(struct worker_pool [NR_STD_WORKER_POOLS],
297                                      cpu_worker_pools);
298
299 static DEFINE_IDR(worker_pool_idr);     /* PR: idr of all pools */
300
301 /* PL: hash of all unbound pools keyed by pool->attrs */
302 static DEFINE_HASHTABLE(unbound_pool_hash, UNBOUND_POOL_HASH_ORDER);
303
304 /* I: attributes used when instantiating standard unbound pools on demand */
305 static struct workqueue_attrs *unbound_std_wq_attrs[NR_STD_WORKER_POOLS];
306
307 /* I: attributes used when instantiating ordered pools on demand */
308 static struct workqueue_attrs *ordered_wq_attrs[NR_STD_WORKER_POOLS];
309
310 struct workqueue_struct *system_wq __read_mostly;
311 EXPORT_SYMBOL(system_wq);
312 struct workqueue_struct *system_highpri_wq __read_mostly;
313 EXPORT_SYMBOL_GPL(system_highpri_wq);
314 struct workqueue_struct *system_long_wq __read_mostly;
315 EXPORT_SYMBOL_GPL(system_long_wq);
316 struct workqueue_struct *system_unbound_wq __read_mostly;
317 EXPORT_SYMBOL_GPL(system_unbound_wq);
318 struct workqueue_struct *system_freezable_wq __read_mostly;
319 EXPORT_SYMBOL_GPL(system_freezable_wq);
320 struct workqueue_struct *system_power_efficient_wq __read_mostly;
321 EXPORT_SYMBOL_GPL(system_power_efficient_wq);
322 struct workqueue_struct *system_freezable_power_efficient_wq __read_mostly;
323 EXPORT_SYMBOL_GPL(system_freezable_power_efficient_wq);
324
325 static int worker_thread(void *__worker);
326 static void copy_workqueue_attrs(struct workqueue_attrs *to,
327                                  const struct workqueue_attrs *from);
328
329 #define CREATE_TRACE_POINTS
330 #include <trace/events/workqueue.h>
331
332 #define assert_rcu_or_pool_mutex()                                      \
333         rcu_lockdep_assert(rcu_read_lock_sched_held() ||                \
334                            lockdep_is_held(&wq_pool_mutex),             \
335                            "sched RCU or wq_pool_mutex should be held")
336
337 #define assert_rcu_or_wq_mutex(wq)                                      \
338         rcu_lockdep_assert(rcu_read_lock_sched_held() ||                \
339                            lockdep_is_held(&wq->mutex),                 \
340                            "sched RCU or wq->mutex should be held")
341
342 #ifdef CONFIG_LOCKDEP
343 #define assert_manager_or_pool_lock(pool)                               \
344         WARN_ONCE(debug_locks &&                                        \
345                   !lockdep_is_held(&(pool)->manager_mutex) &&           \
346                   !lockdep_is_held(&(pool)->lock),                      \
347                   "pool->manager_mutex or ->lock should be held")
348 #else
349 #define assert_manager_or_pool_lock(pool)       do { } while (0)
350 #endif
351
352 #define for_each_cpu_worker_pool(pool, cpu)                             \
353         for ((pool) = &per_cpu(cpu_worker_pools, cpu)[0];               \
354              (pool) < &per_cpu(cpu_worker_pools, cpu)[NR_STD_WORKER_POOLS]; \
355              (pool)++)
356
357 /**
358  * for_each_pool - iterate through all worker_pools in the system
359  * @pool: iteration cursor
360  * @pi: integer used for iteration
361  *
362  * This must be called either with wq_pool_mutex held or sched RCU read
363  * locked.  If the pool needs to be used beyond the locking in effect, the
364  * caller is responsible for guaranteeing that the pool stays online.
365  *
366  * The if/else clause exists only for the lockdep assertion and can be
367  * ignored.
368  */
369 #define for_each_pool(pool, pi)                                         \
370         idr_for_each_entry(&worker_pool_idr, pool, pi)                  \
371                 if (({ assert_rcu_or_pool_mutex(); false; })) { }       \
372                 else
373
374 /**
375  * for_each_pool_worker - iterate through all workers of a worker_pool
376  * @worker: iteration cursor
377  * @wi: integer used for iteration
378  * @pool: worker_pool to iterate workers of
379  *
380  * This must be called with either @pool->manager_mutex or ->lock held.
381  *
382  * The if/else clause exists only for the lockdep assertion and can be
383  * ignored.
384  */
385 #define for_each_pool_worker(worker, wi, pool)                          \
386         idr_for_each_entry(&(pool)->worker_idr, (worker), (wi))         \
387                 if (({ assert_manager_or_pool_lock((pool)); false; })) { } \
388                 else
389
390 /**
391  * for_each_pwq - iterate through all pool_workqueues of the specified workqueue
392  * @pwq: iteration cursor
393  * @wq: the target workqueue
394  *
395  * This must be called either with wq->mutex held or sched RCU read locked.
396  * If the pwq needs to be used beyond the locking in effect, the caller is
397  * responsible for guaranteeing that the pwq stays online.
398  *
399  * The if/else clause exists only for the lockdep assertion and can be
400  * ignored.
401  */
402 #define for_each_pwq(pwq, wq)                                           \
403         list_for_each_entry_rcu((pwq), &(wq)->pwqs, pwqs_node)          \
404                 if (({ assert_rcu_or_wq_mutex(wq); false; })) { }       \
405                 else
406
407 #ifdef CONFIG_DEBUG_OBJECTS_WORK
408
409 static struct debug_obj_descr work_debug_descr;
410
411 static void *work_debug_hint(void *addr)
412 {
413         return ((struct work_struct *) addr)->func;
414 }
415
416 /*
417  * fixup_init is called when:
418  * - an active object is initialized
419  */
420 static int work_fixup_init(void *addr, enum debug_obj_state state)
421 {
422         struct work_struct *work = addr;
423
424         switch (state) {
425         case ODEBUG_STATE_ACTIVE:
426                 cancel_work_sync(work);
427                 debug_object_init(work, &work_debug_descr);
428                 return 1;
429         default:
430                 return 0;
431         }
432 }
433
434 /*
435  * fixup_activate is called when:
436  * - an active object is activated
437  * - an unknown object is activated (might be a statically initialized object)
438  */
439 static int work_fixup_activate(void *addr, enum debug_obj_state state)
440 {
441         struct work_struct *work = addr;
442
443         switch (state) {
444
445         case ODEBUG_STATE_NOTAVAILABLE:
446                 /*
447                  * This is not really a fixup. The work struct was
448                  * statically initialized. We just make sure that it
449                  * is tracked in the object tracker.
450                  */
451                 if (test_bit(WORK_STRUCT_STATIC_BIT, work_data_bits(work))) {
452                         debug_object_init(work, &work_debug_descr);
453                         debug_object_activate(work, &work_debug_descr);
454                         return 0;
455                 }
456                 WARN_ON_ONCE(1);
457                 return 0;
458
459         case ODEBUG_STATE_ACTIVE:
460                 WARN_ON(1);
461
462         default:
463                 return 0;
464         }
465 }
466
467 /*
468  * fixup_free is called when:
469  * - an active object is freed
470  */
471 static int work_fixup_free(void *addr, enum debug_obj_state state)
472 {
473         struct work_struct *work = addr;
474
475         switch (state) {
476         case ODEBUG_STATE_ACTIVE:
477                 cancel_work_sync(work);
478                 debug_object_free(work, &work_debug_descr);
479                 return 1;
480         default:
481                 return 0;
482         }
483 }
484
485 static struct debug_obj_descr work_debug_descr = {
486         .name           = "work_struct",
487         .debug_hint     = work_debug_hint,
488         .fixup_init     = work_fixup_init,
489         .fixup_activate = work_fixup_activate,
490         .fixup_free     = work_fixup_free,
491 };
492
493 static inline void debug_work_activate(struct work_struct *work)
494 {
495         debug_object_activate(work, &work_debug_descr);
496 }
497
498 static inline void debug_work_deactivate(struct work_struct *work)
499 {
500         debug_object_deactivate(work, &work_debug_descr);
501 }
502
503 void __init_work(struct work_struct *work, int onstack)
504 {
505         if (onstack)
506                 debug_object_init_on_stack(work, &work_debug_descr);
507         else
508                 debug_object_init(work, &work_debug_descr);
509 }
510 EXPORT_SYMBOL_GPL(__init_work);
511
512 void destroy_work_on_stack(struct work_struct *work)
513 {
514         debug_object_free(work, &work_debug_descr);
515 }
516 EXPORT_SYMBOL_GPL(destroy_work_on_stack);
517
518 #else
519 static inline void debug_work_activate(struct work_struct *work) { }
520 static inline void debug_work_deactivate(struct work_struct *work) { }
521 #endif
522
523 /* allocate ID and assign it to @pool */
524 static int worker_pool_assign_id(struct worker_pool *pool)
525 {
526         int ret;
527
528         lockdep_assert_held(&wq_pool_mutex);
529
530         ret = idr_alloc(&worker_pool_idr, pool, 0, 0, GFP_KERNEL);
531         if (ret >= 0) {
532                 pool->id = ret;
533                 return 0;
534         }
535         return ret;
536 }
537
538 /**
539  * unbound_pwq_by_node - return the unbound pool_workqueue for the given node
540  * @wq: the target workqueue
541  * @node: the node ID
542  *
543  * This must be called either with pwq_lock held or sched RCU read locked.
544  * If the pwq needs to be used beyond the locking in effect, the caller is
545  * responsible for guaranteeing that the pwq stays online.
546  */
547 static struct pool_workqueue *unbound_pwq_by_node(struct workqueue_struct *wq,
548                                                   int node)
549 {
550         assert_rcu_or_wq_mutex(wq);
551         return rcu_dereference_raw(wq->numa_pwq_tbl[node]);
552 }
553
554 static unsigned int work_color_to_flags(int color)
555 {
556         return color << WORK_STRUCT_COLOR_SHIFT;
557 }
558
559 static int get_work_color(struct work_struct *work)
560 {
561         return (*work_data_bits(work) >> WORK_STRUCT_COLOR_SHIFT) &
562                 ((1 << WORK_STRUCT_COLOR_BITS) - 1);
563 }
564
565 static int work_next_color(int color)
566 {
567         return (color + 1) % WORK_NR_COLORS;
568 }
569
570 /*
571  * While queued, %WORK_STRUCT_PWQ is set and non flag bits of a work's data
572  * contain the pointer to the queued pwq.  Once execution starts, the flag
573  * is cleared and the high bits contain OFFQ flags and pool ID.
574  *
575  * set_work_pwq(), set_work_pool_and_clear_pending(), mark_work_canceling()
576  * and clear_work_data() can be used to set the pwq, pool or clear
577  * work->data.  These functions should only be called while the work is
578  * owned - ie. while the PENDING bit is set.
579  *
580  * get_work_pool() and get_work_pwq() can be used to obtain the pool or pwq
581  * corresponding to a work.  Pool is available once the work has been
582  * queued anywhere after initialization until it is sync canceled.  pwq is
583  * available only while the work item is queued.
584  *
585  * %WORK_OFFQ_CANCELING is used to mark a work item which is being
586  * canceled.  While being canceled, a work item may have its PENDING set
587  * but stay off timer and worklist for arbitrarily long and nobody should
588  * try to steal the PENDING bit.
589  */
590 static inline void set_work_data(struct work_struct *work, unsigned long data,
591                                  unsigned long flags)
592 {
593         WARN_ON_ONCE(!work_pending(work));
594         atomic_long_set(&work->data, data | flags | work_static(work));
595 }
596
597 static void set_work_pwq(struct work_struct *work, struct pool_workqueue *pwq,
598                          unsigned long extra_flags)
599 {
600         set_work_data(work, (unsigned long)pwq,
601                       WORK_STRUCT_PENDING | WORK_STRUCT_PWQ | extra_flags);
602 }
603
604 static void set_work_pool_and_keep_pending(struct work_struct *work,
605                                            int pool_id)
606 {
607         set_work_data(work, (unsigned long)pool_id << WORK_OFFQ_POOL_SHIFT,
608                       WORK_STRUCT_PENDING);
609 }
610
611 static void set_work_pool_and_clear_pending(struct work_struct *work,
612                                             int pool_id)
613 {
614         /*
615          * The following wmb is paired with the implied mb in
616          * test_and_set_bit(PENDING) and ensures all updates to @work made
617          * here are visible to and precede any updates by the next PENDING
618          * owner.
619          */
620         smp_wmb();
621         set_work_data(work, (unsigned long)pool_id << WORK_OFFQ_POOL_SHIFT, 0);
622 }
623
624 static void clear_work_data(struct work_struct *work)
625 {
626         smp_wmb();      /* see set_work_pool_and_clear_pending() */
627         set_work_data(work, WORK_STRUCT_NO_POOL, 0);
628 }
629
630 static struct pool_workqueue *get_work_pwq(struct work_struct *work)
631 {
632         unsigned long data = atomic_long_read(&work->data);
633
634         if (data & WORK_STRUCT_PWQ)
635                 return (void *)(data & WORK_STRUCT_WQ_DATA_MASK);
636         else
637                 return NULL;
638 }
639
640 /**
641  * get_work_pool - return the worker_pool a given work was associated with
642  * @work: the work item of interest
643  *
644  * Return the worker_pool @work was last associated with.  %NULL if none.
645  *
646  * Pools are created and destroyed under wq_pool_mutex, and allows read
647  * access under sched-RCU read lock.  As such, this function should be
648  * called under wq_pool_mutex or with preemption disabled.
649  *
650  * All fields of the returned pool are accessible as long as the above
651  * mentioned locking is in effect.  If the returned pool needs to be used
652  * beyond the critical section, the caller is responsible for ensuring the
653  * returned pool is and stays online.
654  */
655 static struct worker_pool *get_work_pool(struct work_struct *work)
656 {
657         unsigned long data = atomic_long_read(&work->data);
658         int pool_id;
659
660         assert_rcu_or_pool_mutex();
661
662         if (data & WORK_STRUCT_PWQ)
663                 return ((struct pool_workqueue *)
664                         (data & WORK_STRUCT_WQ_DATA_MASK))->pool;
665
666         pool_id = data >> WORK_OFFQ_POOL_SHIFT;
667         if (pool_id == WORK_OFFQ_POOL_NONE)
668                 return NULL;
669
670         return idr_find(&worker_pool_idr, pool_id);
671 }
672
673 /**
674  * get_work_pool_id - return the worker pool ID a given work is associated with
675  * @work: the work item of interest
676  *
677  * Return the worker_pool ID @work was last associated with.
678  * %WORK_OFFQ_POOL_NONE if none.
679  */
680 static int get_work_pool_id(struct work_struct *work)
681 {
682         unsigned long data = atomic_long_read(&work->data);
683
684         if (data & WORK_STRUCT_PWQ)
685                 return ((struct pool_workqueue *)
686                         (data & WORK_STRUCT_WQ_DATA_MASK))->pool->id;
687
688         return data >> WORK_OFFQ_POOL_SHIFT;
689 }
690
691 static void mark_work_canceling(struct work_struct *work)
692 {
693         unsigned long pool_id = get_work_pool_id(work);
694
695         pool_id <<= WORK_OFFQ_POOL_SHIFT;
696         set_work_data(work, pool_id | WORK_OFFQ_CANCELING, WORK_STRUCT_PENDING);
697 }
698
699 static bool work_is_canceling(struct work_struct *work)
700 {
701         unsigned long data = atomic_long_read(&work->data);
702
703         return !(data & WORK_STRUCT_PWQ) && (data & WORK_OFFQ_CANCELING);
704 }
705
706 /*
707  * Policy functions.  These define the policies on how the global worker
708  * pools are managed.  Unless noted otherwise, these functions assume that
709  * they're being called with pool->lock held.
710  */
711
712 static bool __need_more_worker(struct worker_pool *pool)
713 {
714         return !atomic_read(&pool->nr_running);
715 }
716
717 /*
718  * Need to wake up a worker?  Called from anything but currently
719  * running workers.
720  *
721  * Note that, because unbound workers never contribute to nr_running, this
722  * function will always return %true for unbound pools as long as the
723  * worklist isn't empty.
724  */
725 static bool need_more_worker(struct worker_pool *pool)
726 {
727         return !list_empty(&pool->worklist) && __need_more_worker(pool);
728 }
729
730 /* Can I start working?  Called from busy but !running workers. */
731 static bool may_start_working(struct worker_pool *pool)
732 {
733         return pool->nr_idle;
734 }
735
736 /* Do I need to keep working?  Called from currently running workers. */
737 static bool keep_working(struct worker_pool *pool)
738 {
739         return !list_empty(&pool->worklist) &&
740                 atomic_read(&pool->nr_running) <= 1;
741 }
742
743 /* Do we need a new worker?  Called from manager. */
744 static bool need_to_create_worker(struct worker_pool *pool)
745 {
746         return need_more_worker(pool) && !may_start_working(pool);
747 }
748
749 /* Do I need to be the manager? */
750 static bool need_to_manage_workers(struct worker_pool *pool)
751 {
752         return need_to_create_worker(pool) ||
753                 (pool->flags & POOL_MANAGE_WORKERS);
754 }
755
756 /* Do we have too many workers and should some go away? */
757 static bool too_many_workers(struct worker_pool *pool)
758 {
759         bool managing = mutex_is_locked(&pool->manager_arb);
760         int nr_idle = pool->nr_idle + managing; /* manager is considered idle */
761         int nr_busy = pool->nr_workers - nr_idle;
762
763         /*
764          * nr_idle and idle_list may disagree if idle rebinding is in
765          * progress.  Never return %true if idle_list is empty.
766          */
767         if (list_empty(&pool->idle_list))
768                 return false;
769
770         return nr_idle > 2 && (nr_idle - 2) * MAX_IDLE_WORKERS_RATIO >= nr_busy;
771 }
772
773 /*
774  * Wake up functions.
775  */
776
777 /* Return the first worker.  Safe with preemption disabled */
778 static struct worker *first_worker(struct worker_pool *pool)
779 {
780         if (unlikely(list_empty(&pool->idle_list)))
781                 return NULL;
782
783         return list_first_entry(&pool->idle_list, struct worker, entry);
784 }
785
786 /**
787  * wake_up_worker - wake up an idle worker
788  * @pool: worker pool to wake worker from
789  *
790  * Wake up the first idle worker of @pool.
791  *
792  * CONTEXT:
793  * spin_lock_irq(pool->lock).
794  */
795 static void wake_up_worker(struct worker_pool *pool)
796 {
797         struct worker *worker = first_worker(pool);
798
799         if (likely(worker))
800                 wake_up_process(worker->task);
801 }
802
803 /**
804  * wq_worker_waking_up - a worker is waking up
805  * @task: task waking up
806  * @cpu: CPU @task is waking up to
807  *
808  * This function is called during try_to_wake_up() when a worker is
809  * being awoken.
810  *
811  * CONTEXT:
812  * spin_lock_irq(rq->lock)
813  */
814 void wq_worker_waking_up(struct task_struct *task, int cpu)
815 {
816         struct worker *worker = kthread_data(task);
817
818         if (!(worker->flags & WORKER_NOT_RUNNING)) {
819                 WARN_ON_ONCE(worker->pool->cpu != cpu);
820                 atomic_inc(&worker->pool->nr_running);
821         }
822 }
823
824 /**
825  * wq_worker_sleeping - a worker is going to sleep
826  * @task: task going to sleep
827  * @cpu: CPU in question, must be the current CPU number
828  *
829  * This function is called during schedule() when a busy worker is
830  * going to sleep.  Worker on the same cpu can be woken up by
831  * returning pointer to its task.
832  *
833  * CONTEXT:
834  * spin_lock_irq(rq->lock)
835  *
836  * RETURNS:
837  * Worker task on @cpu to wake up, %NULL if none.
838  */
839 struct task_struct *wq_worker_sleeping(struct task_struct *task, int cpu)
840 {
841         struct worker *worker = kthread_data(task), *to_wakeup = NULL;
842         struct worker_pool *pool;
843
844         /*
845          * Rescuers, which may not have all the fields set up like normal
846          * workers, also reach here, let's not access anything before
847          * checking NOT_RUNNING.
848          */
849         if (worker->flags & WORKER_NOT_RUNNING)
850                 return NULL;
851
852         pool = worker->pool;
853
854         /* this can only happen on the local cpu */
855         if (WARN_ON_ONCE(cpu != raw_smp_processor_id()))
856                 return NULL;
857
858         /*
859          * The counterpart of the following dec_and_test, implied mb,
860          * worklist not empty test sequence is in insert_work().
861          * Please read comment there.
862          *
863          * NOT_RUNNING is clear.  This means that we're bound to and
864          * running on the local cpu w/ rq lock held and preemption
865          * disabled, which in turn means that none else could be
866          * manipulating idle_list, so dereferencing idle_list without pool
867          * lock is safe.
868          */
869         if (atomic_dec_and_test(&pool->nr_running) &&
870             !list_empty(&pool->worklist))
871                 to_wakeup = first_worker(pool);
872         return to_wakeup ? to_wakeup->task : NULL;
873 }
874
875 /**
876  * worker_set_flags - set worker flags and adjust nr_running accordingly
877  * @worker: self
878  * @flags: flags to set
879  * @wakeup: wakeup an idle worker if necessary
880  *
881  * Set @flags in @worker->flags and adjust nr_running accordingly.  If
882  * nr_running becomes zero and @wakeup is %true, an idle worker is
883  * woken up.
884  *
885  * CONTEXT:
886  * spin_lock_irq(pool->lock)
887  */
888 static inline void worker_set_flags(struct worker *worker, unsigned int flags,
889                                     bool wakeup)
890 {
891         struct worker_pool *pool = worker->pool;
892
893         WARN_ON_ONCE(worker->task != current);
894
895         /*
896          * If transitioning into NOT_RUNNING, adjust nr_running and
897          * wake up an idle worker as necessary if requested by
898          * @wakeup.
899          */
900         if ((flags & WORKER_NOT_RUNNING) &&
901             !(worker->flags & WORKER_NOT_RUNNING)) {
902                 if (wakeup) {
903                         if (atomic_dec_and_test(&pool->nr_running) &&
904                             !list_empty(&pool->worklist))
905                                 wake_up_worker(pool);
906                 } else
907                         atomic_dec(&pool->nr_running);
908         }
909
910         worker->flags |= flags;
911 }
912
913 /**
914  * worker_clr_flags - clear worker flags and adjust nr_running accordingly
915  * @worker: self
916  * @flags: flags to clear
917  *
918  * Clear @flags in @worker->flags and adjust nr_running accordingly.
919  *
920  * CONTEXT:
921  * spin_lock_irq(pool->lock)
922  */
923 static inline void worker_clr_flags(struct worker *worker, unsigned int flags)
924 {
925         struct worker_pool *pool = worker->pool;
926         unsigned int oflags = worker->flags;
927
928         WARN_ON_ONCE(worker->task != current);
929
930         worker->flags &= ~flags;
931
932         /*
933          * If transitioning out of NOT_RUNNING, increment nr_running.  Note
934          * that the nested NOT_RUNNING is not a noop.  NOT_RUNNING is mask
935          * of multiple flags, not a single flag.
936          */
937         if ((flags & WORKER_NOT_RUNNING) && (oflags & WORKER_NOT_RUNNING))
938                 if (!(worker->flags & WORKER_NOT_RUNNING))
939                         atomic_inc(&pool->nr_running);
940 }
941
942 /**
943  * find_worker_executing_work - find worker which is executing a work
944  * @pool: pool of interest
945  * @work: work to find worker for
946  *
947  * Find a worker which is executing @work on @pool by searching
948  * @pool->busy_hash which is keyed by the address of @work.  For a worker
949  * to match, its current execution should match the address of @work and
950  * its work function.  This is to avoid unwanted dependency between
951  * unrelated work executions through a work item being recycled while still
952  * being executed.
953  *
954  * This is a bit tricky.  A work item may be freed once its execution
955  * starts and nothing prevents the freed area from being recycled for
956  * another work item.  If the same work item address ends up being reused
957  * before the original execution finishes, workqueue will identify the
958  * recycled work item as currently executing and make it wait until the
959  * current execution finishes, introducing an unwanted dependency.
960  *
961  * This function checks the work item address and work function to avoid
962  * false positives.  Note that this isn't complete as one may construct a
963  * work function which can introduce dependency onto itself through a
964  * recycled work item.  Well, if somebody wants to shoot oneself in the
965  * foot that badly, there's only so much we can do, and if such deadlock
966  * actually occurs, it should be easy to locate the culprit work function.
967  *
968  * CONTEXT:
969  * spin_lock_irq(pool->lock).
970  *
971  * RETURNS:
972  * Pointer to worker which is executing @work if found, NULL
973  * otherwise.
974  */
975 static struct worker *find_worker_executing_work(struct worker_pool *pool,
976                                                  struct work_struct *work)
977 {
978         struct worker *worker;
979
980         hash_for_each_possible(pool->busy_hash, worker, hentry,
981                                (unsigned long)work)
982                 if (worker->current_work == work &&
983                     worker->current_func == work->func)
984                         return worker;
985
986         return NULL;
987 }
988
989 /**
990  * move_linked_works - move linked works to a list
991  * @work: start of series of works to be scheduled
992  * @head: target list to append @work to
993  * @nextp: out paramter for nested worklist walking
994  *
995  * Schedule linked works starting from @work to @head.  Work series to
996  * be scheduled starts at @work and includes any consecutive work with
997  * WORK_STRUCT_LINKED set in its predecessor.
998  *
999  * If @nextp is not NULL, it's updated to point to the next work of
1000  * the last scheduled work.  This allows move_linked_works() to be
1001  * nested inside outer list_for_each_entry_safe().
1002  *
1003  * CONTEXT:
1004  * spin_lock_irq(pool->lock).
1005  */
1006 static void move_linked_works(struct work_struct *work, struct list_head *head,
1007                               struct work_struct **nextp)
1008 {
1009         struct work_struct *n;
1010
1011         /*
1012          * Linked worklist will always end before the end of the list,
1013          * use NULL for list head.
1014          */
1015         list_for_each_entry_safe_from(work, n, NULL, entry) {
1016                 list_move_tail(&work->entry, head);
1017                 if (!(*work_data_bits(work) & WORK_STRUCT_LINKED))
1018                         break;
1019         }
1020
1021         /*
1022          * If we're already inside safe list traversal and have moved
1023          * multiple works to the scheduled queue, the next position
1024          * needs to be updated.
1025          */
1026         if (nextp)
1027                 *nextp = n;
1028 }
1029
1030 /**
1031  * get_pwq - get an extra reference on the specified pool_workqueue
1032  * @pwq: pool_workqueue to get
1033  *
1034  * Obtain an extra reference on @pwq.  The caller should guarantee that
1035  * @pwq has positive refcnt and be holding the matching pool->lock.
1036  */
1037 static void get_pwq(struct pool_workqueue *pwq)
1038 {
1039         lockdep_assert_held(&pwq->pool->lock);
1040         WARN_ON_ONCE(pwq->refcnt <= 0);
1041         pwq->refcnt++;
1042 }
1043
1044 /**
1045  * put_pwq - put a pool_workqueue reference
1046  * @pwq: pool_workqueue to put
1047  *
1048  * Drop a reference of @pwq.  If its refcnt reaches zero, schedule its
1049  * destruction.  The caller should be holding the matching pool->lock.
1050  */
1051 static void put_pwq(struct pool_workqueue *pwq)
1052 {
1053         lockdep_assert_held(&pwq->pool->lock);
1054         if (likely(--pwq->refcnt))
1055                 return;
1056         if (WARN_ON_ONCE(!(pwq->wq->flags & WQ_UNBOUND)))
1057                 return;
1058         /*
1059          * @pwq can't be released under pool->lock, bounce to
1060          * pwq_unbound_release_workfn().  This never recurses on the same
1061          * pool->lock as this path is taken only for unbound workqueues and
1062          * the release work item is scheduled on a per-cpu workqueue.  To
1063          * avoid lockdep warning, unbound pool->locks are given lockdep
1064          * subclass of 1 in get_unbound_pool().
1065          */
1066         schedule_work(&pwq->unbound_release_work);
1067 }
1068
1069 /**
1070  * put_pwq_unlocked - put_pwq() with surrounding pool lock/unlock
1071  * @pwq: pool_workqueue to put (can be %NULL)
1072  *
1073  * put_pwq() with locking.  This function also allows %NULL @pwq.
1074  */
1075 static void put_pwq_unlocked(struct pool_workqueue *pwq)
1076 {
1077         if (pwq) {
1078                 /*
1079                  * As both pwqs and pools are sched-RCU protected, the
1080                  * following lock operations are safe.
1081                  */
1082                 spin_lock_irq(&pwq->pool->lock);
1083                 put_pwq(pwq);
1084                 spin_unlock_irq(&pwq->pool->lock);
1085         }
1086 }
1087
1088 static void pwq_activate_delayed_work(struct work_struct *work)
1089 {
1090         struct pool_workqueue *pwq = get_work_pwq(work);
1091
1092         trace_workqueue_activate_work(work);
1093         move_linked_works(work, &pwq->pool->worklist, NULL);
1094         __clear_bit(WORK_STRUCT_DELAYED_BIT, work_data_bits(work));
1095         pwq->nr_active++;
1096 }
1097
1098 static void pwq_activate_first_delayed(struct pool_workqueue *pwq)
1099 {
1100         struct work_struct *work = list_first_entry(&pwq->delayed_works,
1101                                                     struct work_struct, entry);
1102
1103         pwq_activate_delayed_work(work);
1104 }
1105
1106 /**
1107  * pwq_dec_nr_in_flight - decrement pwq's nr_in_flight
1108  * @pwq: pwq of interest
1109  * @color: color of work which left the queue
1110  *
1111  * A work either has completed or is removed from pending queue,
1112  * decrement nr_in_flight of its pwq and handle workqueue flushing.
1113  *
1114  * CONTEXT:
1115  * spin_lock_irq(pool->lock).
1116  */
1117 static void pwq_dec_nr_in_flight(struct pool_workqueue *pwq, int color)
1118 {
1119         /* uncolored work items don't participate in flushing or nr_active */
1120         if (color == WORK_NO_COLOR)
1121                 goto out_put;
1122
1123         pwq->nr_in_flight[color]--;
1124
1125         pwq->nr_active--;
1126         if (!list_empty(&pwq->delayed_works)) {
1127                 /* one down, submit a delayed one */
1128                 if (pwq->nr_active < pwq->max_active)
1129                         pwq_activate_first_delayed(pwq);
1130         }
1131
1132         /* is flush in progress and are we at the flushing tip? */
1133         if (likely(pwq->flush_color != color))
1134                 goto out_put;
1135
1136         /* are there still in-flight works? */
1137         if (pwq->nr_in_flight[color])
1138                 goto out_put;
1139
1140         /* this pwq is done, clear flush_color */
1141         pwq->flush_color = -1;
1142
1143         /*
1144          * If this was the last pwq, wake up the first flusher.  It
1145          * will handle the rest.
1146          */
1147         if (atomic_dec_and_test(&pwq->wq->nr_pwqs_to_flush))
1148                 complete(&pwq->wq->first_flusher->done);
1149 out_put:
1150         put_pwq(pwq);
1151 }
1152
1153 /**
1154  * try_to_grab_pending - steal work item from worklist and disable irq
1155  * @work: work item to steal
1156  * @is_dwork: @work is a delayed_work
1157  * @flags: place to store irq state
1158  *
1159  * Try to grab PENDING bit of @work.  This function can handle @work in any
1160  * stable state - idle, on timer or on worklist.  Return values are
1161  *
1162  *  1           if @work was pending and we successfully stole PENDING
1163  *  0           if @work was idle and we claimed PENDING
1164  *  -EAGAIN     if PENDING couldn't be grabbed at the moment, safe to busy-retry
1165  *  -ENOENT     if someone else is canceling @work, this state may persist
1166  *              for arbitrarily long
1167  *
1168  * On >= 0 return, the caller owns @work's PENDING bit.  To avoid getting
1169  * interrupted while holding PENDING and @work off queue, irq must be
1170  * disabled on entry.  This, combined with delayed_work->timer being
1171  * irqsafe, ensures that we return -EAGAIN for finite short period of time.
1172  *
1173  * On successful return, >= 0, irq is disabled and the caller is
1174  * responsible for releasing it using local_irq_restore(*@flags).
1175  *
1176  * This function is safe to call from any context including IRQ handler.
1177  */
1178 static int try_to_grab_pending(struct work_struct *work, bool is_dwork,
1179                                unsigned long *flags)
1180 {
1181         struct worker_pool *pool;
1182         struct pool_workqueue *pwq;
1183
1184         local_irq_save(*flags);
1185
1186         /* try to steal the timer if it exists */
1187         if (is_dwork) {
1188                 struct delayed_work *dwork = to_delayed_work(work);
1189
1190                 /*
1191                  * dwork->timer is irqsafe.  If del_timer() fails, it's
1192                  * guaranteed that the timer is not queued anywhere and not
1193                  * running on the local CPU.
1194                  */
1195                 if (likely(del_timer(&dwork->timer)))
1196                         return 1;
1197         }
1198
1199         /* try to claim PENDING the normal way */
1200         if (!test_and_set_bit(WORK_STRUCT_PENDING_BIT, work_data_bits(work)))
1201                 return 0;
1202
1203         /*
1204          * The queueing is in progress, or it is already queued. Try to
1205          * steal it from ->worklist without clearing WORK_STRUCT_PENDING.
1206          */
1207         pool = get_work_pool(work);
1208         if (!pool)
1209                 goto fail;
1210
1211         spin_lock(&pool->lock);
1212         /*
1213          * work->data is guaranteed to point to pwq only while the work
1214          * item is queued on pwq->wq, and both updating work->data to point
1215          * to pwq on queueing and to pool on dequeueing are done under
1216          * pwq->pool->lock.  This in turn guarantees that, if work->data
1217          * points to pwq which is associated with a locked pool, the work
1218          * item is currently queued on that pool.
1219          */
1220         pwq = get_work_pwq(work);
1221         if (pwq && pwq->pool == pool) {
1222                 debug_work_deactivate(work);
1223
1224                 /*
1225                  * A delayed work item cannot be grabbed directly because
1226                  * it might have linked NO_COLOR work items which, if left
1227                  * on the delayed_list, will confuse pwq->nr_active
1228                  * management later on and cause stall.  Make sure the work
1229                  * item is activated before grabbing.
1230                  */
1231                 if (*work_data_bits(work) & WORK_STRUCT_DELAYED)
1232                         pwq_activate_delayed_work(work);
1233
1234                 list_del_init(&work->entry);
1235                 pwq_dec_nr_in_flight(get_work_pwq(work), get_work_color(work));
1236
1237                 /* work->data points to pwq iff queued, point to pool */
1238                 set_work_pool_and_keep_pending(work, pool->id);
1239
1240                 spin_unlock(&pool->lock);
1241                 return 1;
1242         }
1243         spin_unlock(&pool->lock);
1244 fail:
1245         local_irq_restore(*flags);
1246         if (work_is_canceling(work))
1247                 return -ENOENT;
1248         cpu_relax();
1249         return -EAGAIN;
1250 }
1251
1252 /**
1253  * insert_work - insert a work into a pool
1254  * @pwq: pwq @work belongs to
1255  * @work: work to insert
1256  * @head: insertion point
1257  * @extra_flags: extra WORK_STRUCT_* flags to set
1258  *
1259  * Insert @work which belongs to @pwq after @head.  @extra_flags is or'd to
1260  * work_struct flags.
1261  *
1262  * CONTEXT:
1263  * spin_lock_irq(pool->lock).
1264  */
1265 static void insert_work(struct pool_workqueue *pwq, struct work_struct *work,
1266                         struct list_head *head, unsigned int extra_flags)
1267 {
1268         struct worker_pool *pool = pwq->pool;
1269
1270         /* we own @work, set data and link */
1271         set_work_pwq(work, pwq, extra_flags);
1272         list_add_tail(&work->entry, head);
1273         get_pwq(pwq);
1274
1275         /*
1276          * Ensure either wq_worker_sleeping() sees the above
1277          * list_add_tail() or we see zero nr_running to avoid workers lying
1278          * around lazily while there are works to be processed.
1279          */
1280         smp_mb();
1281
1282         if (__need_more_worker(pool))
1283                 wake_up_worker(pool);
1284 }
1285
1286 /*
1287  * Test whether @work is being queued from another work executing on the
1288  * same workqueue.
1289  */
1290 static bool is_chained_work(struct workqueue_struct *wq)
1291 {
1292         struct worker *worker;
1293
1294         worker = current_wq_worker();
1295         /*
1296          * Return %true iff I'm a worker execuing a work item on @wq.  If
1297          * I'm @worker, it's safe to dereference it without locking.
1298          */
1299         return worker && worker->current_pwq->wq == wq;
1300 }
1301
1302 static void __queue_work(int cpu, struct workqueue_struct *wq,
1303                          struct work_struct *work)
1304 {
1305         struct pool_workqueue *pwq;
1306         struct worker_pool *last_pool;
1307         struct list_head *worklist;
1308         unsigned int work_flags;
1309         unsigned int req_cpu = cpu;
1310
1311         /*
1312          * While a work item is PENDING && off queue, a task trying to
1313          * steal the PENDING will busy-loop waiting for it to either get
1314          * queued or lose PENDING.  Grabbing PENDING and queueing should
1315          * happen with IRQ disabled.
1316          */
1317         WARN_ON_ONCE(!irqs_disabled());
1318
1319         debug_work_activate(work);
1320
1321         /* if dying, only works from the same workqueue are allowed */
1322         if (unlikely(wq->flags & __WQ_DRAINING) &&
1323             WARN_ON_ONCE(!is_chained_work(wq)))
1324                 return;
1325 retry:
1326         if (req_cpu == WORK_CPU_UNBOUND)
1327                 cpu = raw_smp_processor_id();
1328
1329         /* pwq which will be used unless @work is executing elsewhere */
1330         if (!(wq->flags & WQ_UNBOUND))
1331                 pwq = per_cpu_ptr(wq->cpu_pwqs, cpu);
1332         else
1333                 pwq = unbound_pwq_by_node(wq, cpu_to_node(cpu));
1334
1335         /*
1336          * If @work was previously on a different pool, it might still be
1337          * running there, in which case the work needs to be queued on that
1338          * pool to guarantee non-reentrancy.
1339          */
1340         last_pool = get_work_pool(work);
1341         if (last_pool && last_pool != pwq->pool) {
1342                 struct worker *worker;
1343
1344                 spin_lock(&last_pool->lock);
1345
1346                 worker = find_worker_executing_work(last_pool, work);
1347
1348                 if (worker && worker->current_pwq->wq == wq) {
1349                         pwq = worker->current_pwq;
1350                 } else {
1351                         /* meh... not running there, queue here */
1352                         spin_unlock(&last_pool->lock);
1353                         spin_lock(&pwq->pool->lock);
1354                 }
1355         } else {
1356                 spin_lock(&pwq->pool->lock);
1357         }
1358
1359         /*
1360          * pwq is determined and locked.  For unbound pools, we could have
1361          * raced with pwq release and it could already be dead.  If its
1362          * refcnt is zero, repeat pwq selection.  Note that pwqs never die
1363          * without another pwq replacing it in the numa_pwq_tbl or while
1364          * work items are executing on it, so the retrying is guaranteed to
1365          * make forward-progress.
1366          */
1367         if (unlikely(!pwq->refcnt)) {
1368                 if (wq->flags & WQ_UNBOUND) {
1369                         spin_unlock(&pwq->pool->lock);
1370                         cpu_relax();
1371                         goto retry;
1372                 }
1373                 /* oops */
1374                 WARN_ONCE(true, "workqueue: per-cpu pwq for %s on cpu%d has 0 refcnt",
1375                           wq->name, cpu);
1376         }
1377
1378         /* pwq determined, queue */
1379         trace_workqueue_queue_work(req_cpu, pwq, work);
1380
1381         if (WARN_ON(!list_empty(&work->entry))) {
1382                 spin_unlock(&pwq->pool->lock);
1383                 return;
1384         }
1385
1386         pwq->nr_in_flight[pwq->work_color]++;
1387         work_flags = work_color_to_flags(pwq->work_color);
1388
1389         if (likely(pwq->nr_active < pwq->max_active)) {
1390                 trace_workqueue_activate_work(work);
1391                 pwq->nr_active++;
1392                 worklist = &pwq->pool->worklist;
1393         } else {
1394                 work_flags |= WORK_STRUCT_DELAYED;
1395                 worklist = &pwq->delayed_works;
1396         }
1397
1398         insert_work(pwq, work, worklist, work_flags);
1399
1400         spin_unlock(&pwq->pool->lock);
1401 }
1402
1403 /**
1404  * queue_work_on - queue work on specific cpu
1405  * @cpu: CPU number to execute work on
1406  * @wq: workqueue to use
1407  * @work: work to queue
1408  *
1409  * Returns %false if @work was already on a queue, %true otherwise.
1410  *
1411  * We queue the work to a specific CPU, the caller must ensure it
1412  * can't go away.
1413  */
1414 bool queue_work_on(int cpu, struct workqueue_struct *wq,
1415                    struct work_struct *work)
1416 {
1417         bool ret = false;
1418         unsigned long flags;
1419
1420         local_irq_save(flags);
1421
1422         if (!test_and_set_bit(WORK_STRUCT_PENDING_BIT, work_data_bits(work))) {
1423                 __queue_work(cpu, wq, work);
1424                 ret = true;
1425         }
1426
1427         local_irq_restore(flags);
1428         return ret;
1429 }
1430 EXPORT_SYMBOL(queue_work_on);
1431
1432 void delayed_work_timer_fn(unsigned long __data)
1433 {
1434         struct delayed_work *dwork = (struct delayed_work *)__data;
1435
1436         /* should have been called from irqsafe timer with irq already off */
1437         __queue_work(dwork->cpu, dwork->wq, &dwork->work);
1438 }
1439 EXPORT_SYMBOL(delayed_work_timer_fn);
1440
1441 static void __queue_delayed_work(int cpu, struct workqueue_struct *wq,
1442                                 struct delayed_work *dwork, unsigned long delay)
1443 {
1444         struct timer_list *timer = &dwork->timer;
1445         struct work_struct *work = &dwork->work;
1446
1447         WARN_ON_ONCE(timer->function != delayed_work_timer_fn ||
1448                      timer->data != (unsigned long)dwork);
1449         WARN_ON_ONCE(timer_pending(timer));
1450         WARN_ON_ONCE(!list_empty(&work->entry));
1451
1452         /*
1453          * If @delay is 0, queue @dwork->work immediately.  This is for
1454          * both optimization and correctness.  The earliest @timer can
1455          * expire is on the closest next tick and delayed_work users depend
1456          * on that there's no such delay when @delay is 0.
1457          */
1458         if (!delay) {
1459                 __queue_work(cpu, wq, &dwork->work);
1460                 return;
1461         }
1462
1463         timer_stats_timer_set_start_info(&dwork->timer);
1464
1465         dwork->wq = wq;
1466         dwork->cpu = cpu;
1467         timer->expires = jiffies + delay;
1468
1469         if (unlikely(cpu != WORK_CPU_UNBOUND))
1470                 add_timer_on(timer, cpu);
1471         else
1472                 add_timer(timer);
1473 }
1474
1475 /**
1476  * queue_delayed_work_on - queue work on specific CPU after delay
1477  * @cpu: CPU number to execute work on
1478  * @wq: workqueue to use
1479  * @dwork: work to queue
1480  * @delay: number of jiffies to wait before queueing
1481  *
1482  * Returns %false if @work was already on a queue, %true otherwise.  If
1483  * @delay is zero and @dwork is idle, it will be scheduled for immediate
1484  * execution.
1485  */
1486 bool queue_delayed_work_on(int cpu, struct workqueue_struct *wq,
1487                            struct delayed_work *dwork, unsigned long delay)
1488 {
1489         struct work_struct *work = &dwork->work;
1490         bool ret = false;
1491         unsigned long flags;
1492
1493         /* read the comment in __queue_work() */
1494         local_irq_save(flags);
1495
1496         if (!test_and_set_bit(WORK_STRUCT_PENDING_BIT, work_data_bits(work))) {
1497                 __queue_delayed_work(cpu, wq, dwork, delay);
1498                 ret = true;
1499         }
1500
1501         local_irq_restore(flags);
1502         return ret;
1503 }
1504 EXPORT_SYMBOL(queue_delayed_work_on);
1505
1506 /**
1507  * mod_delayed_work_on - modify delay of or queue a delayed work on specific CPU
1508  * @cpu: CPU number to execute work on
1509  * @wq: workqueue to use
1510  * @dwork: work to queue
1511  * @delay: number of jiffies to wait before queueing
1512  *
1513  * If @dwork is idle, equivalent to queue_delayed_work_on(); otherwise,
1514  * modify @dwork's timer so that it expires after @delay.  If @delay is
1515  * zero, @work is guaranteed to be scheduled immediately regardless of its
1516  * current state.
1517  *
1518  * Returns %false if @dwork was idle and queued, %true if @dwork was
1519  * pending and its timer was modified.
1520  *
1521  * This function is safe to call from any context including IRQ handler.
1522  * See try_to_grab_pending() for details.
1523  */
1524 bool mod_delayed_work_on(int cpu, struct workqueue_struct *wq,
1525                          struct delayed_work *dwork, unsigned long delay)
1526 {
1527         unsigned long flags;
1528         int ret;
1529
1530         do {
1531                 ret = try_to_grab_pending(&dwork->work, true, &flags);
1532         } while (unlikely(ret == -EAGAIN));
1533
1534         if (likely(ret >= 0)) {
1535                 __queue_delayed_work(cpu, wq, dwork, delay);
1536                 local_irq_restore(flags);
1537         }
1538
1539         /* -ENOENT from try_to_grab_pending() becomes %true */
1540         return ret;
1541 }
1542 EXPORT_SYMBOL_GPL(mod_delayed_work_on);
1543
1544 /**
1545  * worker_enter_idle - enter idle state
1546  * @worker: worker which is entering idle state
1547  *
1548  * @worker is entering idle state.  Update stats and idle timer if
1549  * necessary.
1550  *
1551  * LOCKING:
1552  * spin_lock_irq(pool->lock).
1553  */
1554 static void worker_enter_idle(struct worker *worker)
1555 {
1556         struct worker_pool *pool = worker->pool;
1557
1558         if (WARN_ON_ONCE(worker->flags & WORKER_IDLE) ||
1559             WARN_ON_ONCE(!list_empty(&worker->entry) &&
1560                          (worker->hentry.next || worker->hentry.pprev)))
1561                 return;
1562
1563         /* can't use worker_set_flags(), also called from start_worker() */
1564         worker->flags |= WORKER_IDLE;
1565         pool->nr_idle++;
1566         worker->last_active = jiffies;
1567
1568         /* idle_list is LIFO */
1569         list_add(&worker->entry, &pool->idle_list);
1570
1571         if (too_many_workers(pool) && !timer_pending(&pool->idle_timer))
1572                 mod_timer(&pool->idle_timer, jiffies + IDLE_WORKER_TIMEOUT);
1573
1574         /*
1575          * Sanity check nr_running.  Because wq_unbind_fn() releases
1576          * pool->lock between setting %WORKER_UNBOUND and zapping
1577          * nr_running, the warning may trigger spuriously.  Check iff
1578          * unbind is not in progress.
1579          */
1580         WARN_ON_ONCE(!(pool->flags & POOL_DISASSOCIATED) &&
1581                      pool->nr_workers == pool->nr_idle &&
1582                      atomic_read(&pool->nr_running));
1583 }
1584
1585 /**
1586  * worker_leave_idle - leave idle state
1587  * @worker: worker which is leaving idle state
1588  *
1589  * @worker is leaving idle state.  Update stats.
1590  *
1591  * LOCKING:
1592  * spin_lock_irq(pool->lock).
1593  */
1594 static void worker_leave_idle(struct worker *worker)
1595 {
1596         struct worker_pool *pool = worker->pool;
1597
1598         if (WARN_ON_ONCE(!(worker->flags & WORKER_IDLE)))
1599                 return;
1600         worker_clr_flags(worker, WORKER_IDLE);
1601         pool->nr_idle--;
1602         list_del_init(&worker->entry);
1603 }
1604
1605 /**
1606  * worker_maybe_bind_and_lock - try to bind %current to worker_pool and lock it
1607  * @pool: target worker_pool
1608  *
1609  * Bind %current to the cpu of @pool if it is associated and lock @pool.
1610  *
1611  * Works which are scheduled while the cpu is online must at least be
1612  * scheduled to a worker which is bound to the cpu so that if they are
1613  * flushed from cpu callbacks while cpu is going down, they are
1614  * guaranteed to execute on the cpu.
1615  *
1616  * This function is to be used by unbound workers and rescuers to bind
1617  * themselves to the target cpu and may race with cpu going down or
1618  * coming online.  kthread_bind() can't be used because it may put the
1619  * worker to already dead cpu and set_cpus_allowed_ptr() can't be used
1620  * verbatim as it's best effort and blocking and pool may be
1621  * [dis]associated in the meantime.
1622  *
1623  * This function tries set_cpus_allowed() and locks pool and verifies the
1624  * binding against %POOL_DISASSOCIATED which is set during
1625  * %CPU_DOWN_PREPARE and cleared during %CPU_ONLINE, so if the worker
1626  * enters idle state or fetches works without dropping lock, it can
1627  * guarantee the scheduling requirement described in the first paragraph.
1628  *
1629  * CONTEXT:
1630  * Might sleep.  Called without any lock but returns with pool->lock
1631  * held.
1632  *
1633  * RETURNS:
1634  * %true if the associated pool is online (@worker is successfully
1635  * bound), %false if offline.
1636  */
1637 static bool worker_maybe_bind_and_lock(struct worker_pool *pool)
1638 __acquires(&pool->lock)
1639 {
1640         while (true) {
1641                 /*
1642                  * The following call may fail, succeed or succeed
1643                  * without actually migrating the task to the cpu if
1644                  * it races with cpu hotunplug operation.  Verify
1645                  * against POOL_DISASSOCIATED.
1646                  */
1647                 if (!(pool->flags & POOL_DISASSOCIATED))
1648                         set_cpus_allowed_ptr(current, pool->attrs->cpumask);
1649
1650                 spin_lock_irq(&pool->lock);
1651                 if (pool->flags & POOL_DISASSOCIATED)
1652                         return false;
1653                 if (task_cpu(current) == pool->cpu &&
1654                     cpumask_equal(&current->cpus_allowed, pool->attrs->cpumask))
1655                         return true;
1656                 spin_unlock_irq(&pool->lock);
1657
1658                 /*
1659                  * We've raced with CPU hot[un]plug.  Give it a breather
1660                  * and retry migration.  cond_resched() is required here;
1661                  * otherwise, we might deadlock against cpu_stop trying to
1662                  * bring down the CPU on non-preemptive kernel.
1663                  */
1664                 cpu_relax();
1665                 cond_resched();
1666         }
1667 }
1668
1669 static struct worker *alloc_worker(void)
1670 {
1671         struct worker *worker;
1672
1673         worker = kzalloc(sizeof(*worker), GFP_KERNEL);
1674         if (worker) {
1675                 INIT_LIST_HEAD(&worker->entry);
1676                 INIT_LIST_HEAD(&worker->scheduled);
1677                 /* on creation a worker is in !idle && prep state */
1678                 worker->flags = WORKER_PREP;
1679         }
1680         return worker;
1681 }
1682
1683 /**
1684  * create_worker - create a new workqueue worker
1685  * @pool: pool the new worker will belong to
1686  *
1687  * Create a new worker which is bound to @pool.  The returned worker
1688  * can be started by calling start_worker() or destroyed using
1689  * destroy_worker().
1690  *
1691  * CONTEXT:
1692  * Might sleep.  Does GFP_KERNEL allocations.
1693  *
1694  * RETURNS:
1695  * Pointer to the newly created worker.
1696  */
1697 static struct worker *create_worker(struct worker_pool *pool)
1698 {
1699         struct worker *worker = NULL;
1700         int id = -1;
1701         char id_buf[16];
1702
1703         lockdep_assert_held(&pool->manager_mutex);
1704
1705         /*
1706          * ID is needed to determine kthread name.  Allocate ID first
1707          * without installing the pointer.
1708          */
1709         idr_preload(GFP_KERNEL);
1710         spin_lock_irq(&pool->lock);
1711
1712         id = idr_alloc(&pool->worker_idr, NULL, 0, 0, GFP_NOWAIT);
1713
1714         spin_unlock_irq(&pool->lock);
1715         idr_preload_end();
1716         if (id < 0)
1717                 goto fail;
1718
1719         worker = alloc_worker();
1720         if (!worker)
1721                 goto fail;
1722
1723         worker->pool = pool;
1724         worker->id = id;
1725
1726         if (pool->cpu >= 0)
1727                 snprintf(id_buf, sizeof(id_buf), "%d:%d%s", pool->cpu, id,
1728                          pool->attrs->nice < 0  ? "H" : "");
1729         else
1730                 snprintf(id_buf, sizeof(id_buf), "u%d:%d", pool->id, id);
1731
1732         worker->task = kthread_create_on_node(worker_thread, worker, pool->node,
1733                                               "kworker/%s", id_buf);
1734         if (IS_ERR(worker->task))
1735                 goto fail;
1736
1737         /*
1738          * set_cpus_allowed_ptr() will fail if the cpumask doesn't have any
1739          * online CPUs.  It'll be re-applied when any of the CPUs come up.
1740          */
1741         set_user_nice(worker->task, pool->attrs->nice);
1742         set_cpus_allowed_ptr(worker->task, pool->attrs->cpumask);
1743
1744         /* prevent userland from meddling with cpumask of workqueue workers */
1745         worker->task->flags |= PF_NO_SETAFFINITY;
1746
1747         /*
1748          * The caller is responsible for ensuring %POOL_DISASSOCIATED
1749          * remains stable across this function.  See the comments above the
1750          * flag definition for details.
1751          */
1752         if (pool->flags & POOL_DISASSOCIATED)
1753                 worker->flags |= WORKER_UNBOUND;
1754
1755         /* successful, commit the pointer to idr */
1756         spin_lock_irq(&pool->lock);
1757         idr_replace(&pool->worker_idr, worker, worker->id);
1758         spin_unlock_irq(&pool->lock);
1759
1760         return worker;
1761
1762 fail:
1763         if (id >= 0) {
1764                 spin_lock_irq(&pool->lock);
1765                 idr_remove(&pool->worker_idr, id);
1766                 spin_unlock_irq(&pool->lock);
1767         }
1768         kfree(worker);
1769         return NULL;
1770 }
1771
1772 /**
1773  * start_worker - start a newly created worker
1774  * @worker: worker to start
1775  *
1776  * Make the pool aware of @worker and start it.
1777  *
1778  * CONTEXT:
1779  * spin_lock_irq(pool->lock).
1780  */
1781 static void start_worker(struct worker *worker)
1782 {
1783         worker->flags |= WORKER_STARTED;
1784         worker->pool->nr_workers++;
1785         worker_enter_idle(worker);
1786         wake_up_process(worker->task);
1787 }
1788
1789 /**
1790  * create_and_start_worker - create and start a worker for a pool
1791  * @pool: the target pool
1792  *
1793  * Grab the managership of @pool and create and start a new worker for it.
1794  */
1795 static int create_and_start_worker(struct worker_pool *pool)
1796 {
1797         struct worker *worker;
1798
1799         mutex_lock(&pool->manager_mutex);
1800
1801         worker = create_worker(pool);
1802         if (worker) {
1803                 spin_lock_irq(&pool->lock);
1804                 start_worker(worker);
1805                 spin_unlock_irq(&pool->lock);
1806         }
1807
1808         mutex_unlock(&pool->manager_mutex);
1809
1810         return worker ? 0 : -ENOMEM;
1811 }
1812
1813 /**
1814  * destroy_worker - destroy a workqueue worker
1815  * @worker: worker to be destroyed
1816  *
1817  * Destroy @worker and adjust @pool stats accordingly.
1818  *
1819  * CONTEXT:
1820  * spin_lock_irq(pool->lock) which is released and regrabbed.
1821  */
1822 static void destroy_worker(struct worker *worker)
1823 {
1824         struct worker_pool *pool = worker->pool;
1825
1826         lockdep_assert_held(&pool->manager_mutex);
1827         lockdep_assert_held(&pool->lock);
1828
1829         /* sanity check frenzy */
1830         if (WARN_ON(worker->current_work) ||
1831             WARN_ON(!list_empty(&worker->scheduled)))
1832                 return;
1833
1834         if (worker->flags & WORKER_STARTED)
1835                 pool->nr_workers--;
1836         if (worker->flags & WORKER_IDLE)
1837                 pool->nr_idle--;
1838
1839         /*
1840          * Once WORKER_DIE is set, the kworker may destroy itself at any
1841          * point.  Pin to ensure the task stays until we're done with it.
1842          */
1843         get_task_struct(worker->task);
1844
1845         list_del_init(&worker->entry);
1846         worker->flags |= WORKER_DIE;
1847
1848         idr_remove(&pool->worker_idr, worker->id);
1849
1850         spin_unlock_irq(&pool->lock);
1851
1852         kthread_stop(worker->task);
1853         put_task_struct(worker->task);
1854         kfree(worker);
1855
1856         spin_lock_irq(&pool->lock);
1857 }
1858
1859 static void idle_worker_timeout(unsigned long __pool)
1860 {
1861         struct worker_pool *pool = (void *)__pool;
1862
1863         spin_lock_irq(&pool->lock);
1864
1865         if (too_many_workers(pool)) {
1866                 struct worker *worker;
1867                 unsigned long expires;
1868
1869                 /* idle_list is kept in LIFO order, check the last one */
1870                 worker = list_entry(pool->idle_list.prev, struct worker, entry);
1871                 expires = worker->last_active + IDLE_WORKER_TIMEOUT;
1872
1873                 if (time_before(jiffies, expires))
1874                         mod_timer(&pool->idle_timer, expires);
1875                 else {
1876                         /* it's been idle for too long, wake up manager */
1877                         pool->flags |= POOL_MANAGE_WORKERS;
1878                         wake_up_worker(pool);
1879                 }
1880         }
1881
1882         spin_unlock_irq(&pool->lock);
1883 }
1884
1885 static void send_mayday(struct work_struct *work)
1886 {
1887         struct pool_workqueue *pwq = get_work_pwq(work);
1888         struct workqueue_struct *wq = pwq->wq;
1889
1890         lockdep_assert_held(&wq_mayday_lock);
1891
1892         if (!wq->rescuer)
1893                 return;
1894
1895         /* mayday mayday mayday */
1896         if (list_empty(&pwq->mayday_node)) {
1897                 /*
1898                  * If @pwq is for an unbound wq, its base ref may be put at
1899                  * any time due to an attribute change.  Pin @pwq until the
1900                  * rescuer is done with it.
1901                  */
1902                 get_pwq(pwq);
1903                 list_add_tail(&pwq->mayday_node, &wq->maydays);
1904                 wake_up_process(wq->rescuer->task);
1905         }
1906 }
1907
1908 static void pool_mayday_timeout(unsigned long __pool)
1909 {
1910         struct worker_pool *pool = (void *)__pool;
1911         struct work_struct *work;
1912
1913         spin_lock_irq(&wq_mayday_lock);         /* for wq->maydays */
1914         spin_lock(&pool->lock);
1915
1916         if (need_to_create_worker(pool)) {
1917                 /*
1918                  * We've been trying to create a new worker but
1919                  * haven't been successful.  We might be hitting an
1920                  * allocation deadlock.  Send distress signals to
1921                  * rescuers.
1922                  */
1923                 list_for_each_entry(work, &pool->worklist, entry)
1924                         send_mayday(work);
1925         }
1926
1927         spin_unlock(&pool->lock);
1928         spin_unlock_irq(&wq_mayday_lock);
1929
1930         mod_timer(&pool->mayday_timer, jiffies + MAYDAY_INTERVAL);
1931 }
1932
1933 /**
1934  * maybe_create_worker - create a new worker if necessary
1935  * @pool: pool to create a new worker for
1936  *
1937  * Create a new worker for @pool if necessary.  @pool is guaranteed to
1938  * have at least one idle worker on return from this function.  If
1939  * creating a new worker takes longer than MAYDAY_INTERVAL, mayday is
1940  * sent to all rescuers with works scheduled on @pool to resolve
1941  * possible allocation deadlock.
1942  *
1943  * On return, need_to_create_worker() is guaranteed to be %false and
1944  * may_start_working() %true.
1945  *
1946  * LOCKING:
1947  * spin_lock_irq(pool->lock) which may be released and regrabbed
1948  * multiple times.  Does GFP_KERNEL allocations.  Called only from
1949  * manager.
1950  */
1951 static void maybe_create_worker(struct worker_pool *pool)
1952 __releases(&pool->lock)
1953 __acquires(&pool->lock)
1954 {
1955         if (!need_to_create_worker(pool))
1956                 return;
1957 restart:
1958         spin_unlock_irq(&pool->lock);
1959
1960         /* if we don't make progress in MAYDAY_INITIAL_TIMEOUT, call for help */
1961         mod_timer(&pool->mayday_timer, jiffies + MAYDAY_INITIAL_TIMEOUT);
1962
1963         while (true) {
1964                 struct worker *worker;
1965
1966                 worker = create_worker(pool);
1967                 if (worker) {
1968                         del_timer_sync(&pool->mayday_timer);
1969                         spin_lock_irq(&pool->lock);
1970                         start_worker(worker);
1971                         if (WARN_ON_ONCE(need_to_create_worker(pool)))
1972                                 goto restart;
1973                         return;
1974                 }
1975
1976                 if (!need_to_create_worker(pool))
1977                         break;
1978
1979                 __set_current_state(TASK_INTERRUPTIBLE);
1980                 schedule_timeout(CREATE_COOLDOWN);
1981
1982                 if (!need_to_create_worker(pool))
1983                         break;
1984         }
1985
1986         del_timer_sync(&pool->mayday_timer);
1987         spin_lock_irq(&pool->lock);
1988         if (need_to_create_worker(pool))
1989                 goto restart;
1990         return;
1991 }
1992
1993 /**
1994  * maybe_destroy_worker - destroy workers which have been idle for a while
1995  * @pool: pool to destroy workers for
1996  *
1997  * Destroy @pool workers which have been idle for longer than
1998  * IDLE_WORKER_TIMEOUT.
1999  *
2000  * LOCKING:
2001  * spin_lock_irq(pool->lock) which may be released and regrabbed
2002  * multiple times.  Called only from manager.
2003  */
2004 static void maybe_destroy_workers(struct worker_pool *pool)
2005 {
2006         while (too_many_workers(pool)) {
2007                 struct worker *worker;
2008                 unsigned long expires;
2009
2010                 worker = list_entry(pool->idle_list.prev, struct worker, entry);
2011                 expires = worker->last_active + IDLE_WORKER_TIMEOUT;
2012
2013                 if (time_before(jiffies, expires)) {
2014                         mod_timer(&pool->idle_timer, expires);
2015                         break;
2016                 }
2017
2018                 destroy_worker(worker);
2019         }
2020 }
2021
2022 /**
2023  * manage_workers - manage worker pool
2024  * @worker: self
2025  *
2026  * Assume the manager role and manage the worker pool @worker belongs
2027  * to.  At any given time, there can be only zero or one manager per
2028  * pool.  The exclusion is handled automatically by this function.
2029  *
2030  * The caller can safely start processing works on false return.  On
2031  * true return, it's guaranteed that need_to_create_worker() is false
2032  * and may_start_working() is true.
2033  *
2034  * CONTEXT:
2035  * spin_lock_irq(pool->lock) which may be released and regrabbed
2036  * multiple times.  Does GFP_KERNEL allocations.
2037  *
2038  * RETURNS:
2039  * %false if the pool doesn't need management and the caller can safely
2040  * start processing works, %true if management function was performed and
2041  * the conditions that the caller verified before calling the function may
2042  * no longer be true.
2043  */
2044 static bool manage_workers(struct worker *worker)
2045 {
2046         struct worker_pool *pool = worker->pool;
2047
2048         /*
2049          * Managership is governed by two mutexes - manager_arb and
2050          * manager_mutex.  manager_arb handles arbitration of manager role.
2051          * Anyone who successfully grabs manager_arb wins the arbitration
2052          * and becomes the manager.  mutex_trylock() on pool->manager_arb
2053          * failure while holding pool->lock reliably indicates that someone
2054          * else is managing the pool and the worker which failed trylock
2055          * can proceed to executing work items.  This means that anyone
2056          * grabbing manager_arb is responsible for actually performing
2057          * manager duties.  If manager_arb is grabbed and released without
2058          * actual management, the pool may stall indefinitely.
2059          *
2060          * manager_mutex is used for exclusion of actual management
2061          * operations.  The holder of manager_mutex can be sure that none
2062          * of management operations, including creation and destruction of
2063          * workers, won't take place until the mutex is released.  Because
2064          * manager_mutex doesn't interfere with manager role arbitration,
2065          * it is guaranteed that the pool's management, while may be
2066          * delayed, won't be disturbed by someone else grabbing
2067          * manager_mutex.
2068          */
2069         if (!mutex_trylock(&pool->manager_arb))
2070                 return false;
2071
2072         /*
2073          * With manager arbitration won, manager_mutex would be free in
2074          * most cases.  trylock first without dropping @pool->lock.
2075          */
2076         if (unlikely(!mutex_trylock(&pool->manager_mutex))) {
2077                 spin_unlock_irq(&pool->lock);
2078                 mutex_lock(&pool->manager_mutex);
2079                 spin_lock_irq(&pool->lock);
2080         }
2081
2082         pool->flags &= ~POOL_MANAGE_WORKERS;
2083
2084         /*
2085          * Destroy and then create so that may_start_working() is true
2086          * on return.
2087          */
2088         maybe_destroy_workers(pool);
2089         maybe_create_worker(pool);
2090
2091         mutex_unlock(&pool->manager_mutex);
2092         mutex_unlock(&pool->manager_arb);
2093         return true;
2094 }
2095
2096 /**
2097  * process_one_work - process single work
2098  * @worker: self
2099  * @work: work to process
2100  *
2101  * Process @work.  This function contains all the logics necessary to
2102  * process a single work including synchronization against and
2103  * interaction with other workers on the same cpu, queueing and
2104  * flushing.  As long as context requirement is met, any worker can
2105  * call this function to process a work.
2106  *
2107  * CONTEXT:
2108  * spin_lock_irq(pool->lock) which is released and regrabbed.
2109  */
2110 static void process_one_work(struct worker *worker, struct work_struct *work)
2111 __releases(&pool->lock)
2112 __acquires(&pool->lock)
2113 {
2114         struct pool_workqueue *pwq = get_work_pwq(work);
2115         struct worker_pool *pool = worker->pool;
2116         bool cpu_intensive = pwq->wq->flags & WQ_CPU_INTENSIVE;
2117         int work_color;
2118         struct worker *collision;
2119 #ifdef CONFIG_LOCKDEP
2120         /*
2121          * It is permissible to free the struct work_struct from
2122          * inside the function that is called from it, this we need to
2123          * take into account for lockdep too.  To avoid bogus "held
2124          * lock freed" warnings as well as problems when looking into
2125          * work->lockdep_map, make a copy and use that here.
2126          */
2127         struct lockdep_map lockdep_map;
2128
2129         lockdep_copy_map(&lockdep_map, &work->lockdep_map);
2130 #endif
2131         /*
2132          * Ensure we're on the correct CPU.  DISASSOCIATED test is
2133          * necessary to avoid spurious warnings from rescuers servicing the
2134          * unbound or a disassociated pool.
2135          */
2136         WARN_ON_ONCE(!(worker->flags & WORKER_UNBOUND) &&
2137                      !(pool->flags & POOL_DISASSOCIATED) &&
2138                      raw_smp_processor_id() != pool->cpu);
2139
2140         /*
2141          * A single work shouldn't be executed concurrently by
2142          * multiple workers on a single cpu.  Check whether anyone is
2143          * already processing the work.  If so, defer the work to the
2144          * currently executing one.
2145          */
2146         collision = find_worker_executing_work(pool, work);
2147         if (unlikely(collision)) {
2148                 move_linked_works(work, &collision->scheduled, NULL);
2149                 return;
2150         }
2151
2152         /* claim and dequeue */
2153         debug_work_deactivate(work);
2154         hash_add(pool->busy_hash, &worker->hentry, (unsigned long)work);
2155         worker->current_work = work;
2156         worker->current_func = work->func;
2157         worker->current_pwq = pwq;
2158         work_color = get_work_color(work);
2159
2160         list_del_init(&work->entry);
2161
2162         /*
2163          * CPU intensive works don't participate in concurrency
2164          * management.  They're the scheduler's responsibility.
2165          */
2166         if (unlikely(cpu_intensive))
2167                 worker_set_flags(worker, WORKER_CPU_INTENSIVE, true);
2168
2169         /*
2170          * Unbound pool isn't concurrency managed and work items should be
2171          * executed ASAP.  Wake up another worker if necessary.
2172          */
2173         if ((worker->flags & WORKER_UNBOUND) && need_more_worker(pool))
2174                 wake_up_worker(pool);
2175
2176         /*
2177          * Record the last pool and clear PENDING which should be the last
2178          * update to @work.  Also, do this inside @pool->lock so that
2179          * PENDING and queued state changes happen together while IRQ is
2180          * disabled.
2181          */
2182         set_work_pool_and_clear_pending(work, pool->id);
2183
2184         spin_unlock_irq(&pool->lock);
2185
2186         lock_map_acquire_read(&pwq->wq->lockdep_map);
2187         lock_map_acquire(&lockdep_map);
2188         trace_workqueue_execute_start(work);
2189         worker->current_func(work);
2190         /*
2191          * While we must be careful to not use "work" after this, the trace
2192          * point will only record its address.
2193          */
2194         trace_workqueue_execute_end(work);
2195         lock_map_release(&lockdep_map);
2196         lock_map_release(&pwq->wq->lockdep_map);
2197
2198         if (unlikely(in_atomic() || lockdep_depth(current) > 0)) {
2199                 pr_err("BUG: workqueue leaked lock or atomic: %s/0x%08x/%d\n"
2200                        "     last function: %pf\n",
2201                        current->comm, preempt_count(), task_pid_nr(current),
2202                        worker->current_func);
2203                 debug_show_held_locks(current);
2204                 dump_stack();
2205         }
2206
2207         /*
2208          * The following prevents a kworker from hogging CPU on !PREEMPT
2209          * kernels, where a requeueing work item waiting for something to
2210          * happen could deadlock with stop_machine as such work item could
2211          * indefinitely requeue itself while all other CPUs are trapped in
2212          * stop_machine.
2213          */
2214         cond_resched();
2215
2216         spin_lock_irq(&pool->lock);
2217
2218         /* clear cpu intensive status */
2219         if (unlikely(cpu_intensive))
2220                 worker_clr_flags(worker, WORKER_CPU_INTENSIVE);
2221
2222         /* we're done with it, release */
2223         hash_del(&worker->hentry);
2224         worker->current_work = NULL;
2225         worker->current_func = NULL;
2226         worker->current_pwq = NULL;
2227         worker->desc_valid = false;
2228         pwq_dec_nr_in_flight(pwq, work_color);
2229 }
2230
2231 /**
2232  * process_scheduled_works - process scheduled works
2233  * @worker: self
2234  *
2235  * Process all scheduled works.  Please note that the scheduled list
2236  * may change while processing a work, so this function repeatedly
2237  * fetches a work from the top and executes it.
2238  *
2239  * CONTEXT:
2240  * spin_lock_irq(pool->lock) which may be released and regrabbed
2241  * multiple times.
2242  */
2243 static void process_scheduled_works(struct worker *worker)
2244 {
2245         while (!list_empty(&worker->scheduled)) {
2246                 struct work_struct *work = list_first_entry(&worker->scheduled,
2247                                                 struct work_struct, entry);
2248                 process_one_work(worker, work);
2249         }
2250 }
2251
2252 /**
2253  * worker_thread - the worker thread function
2254  * @__worker: self
2255  *
2256  * The worker thread function.  All workers belong to a worker_pool -
2257  * either a per-cpu one or dynamic unbound one.  These workers process all
2258  * work items regardless of their specific target workqueue.  The only
2259  * exception is work items which belong to workqueues with a rescuer which
2260  * will be explained in rescuer_thread().
2261  */
2262 static int worker_thread(void *__worker)
2263 {
2264         struct worker *worker = __worker;
2265         struct worker_pool *pool = worker->pool;
2266
2267         /* tell the scheduler that this is a workqueue worker */
2268         worker->task->flags |= PF_WQ_WORKER;
2269 woke_up:
2270         spin_lock_irq(&pool->lock);
2271
2272         /* am I supposed to die? */
2273         if (unlikely(worker->flags & WORKER_DIE)) {
2274                 spin_unlock_irq(&pool->lock);
2275                 WARN_ON_ONCE(!list_empty(&worker->entry));
2276                 worker->task->flags &= ~PF_WQ_WORKER;
2277                 return 0;
2278         }
2279
2280         worker_leave_idle(worker);
2281 recheck:
2282         /* no more worker necessary? */
2283         if (!need_more_worker(pool))
2284                 goto sleep;
2285
2286         /* do we need to manage? */
2287         if (unlikely(!may_start_working(pool)) && manage_workers(worker))
2288                 goto recheck;
2289
2290         /*
2291          * ->scheduled list can only be filled while a worker is
2292          * preparing to process a work or actually processing it.
2293          * Make sure nobody diddled with it while I was sleeping.
2294          */
2295         WARN_ON_ONCE(!list_empty(&worker->scheduled));
2296
2297         /*
2298          * Finish PREP stage.  We're guaranteed to have at least one idle
2299          * worker or that someone else has already assumed the manager
2300          * role.  This is where @worker starts participating in concurrency
2301          * management if applicable and concurrency management is restored
2302          * after being rebound.  See rebind_workers() for details.
2303          */
2304         worker_clr_flags(worker, WORKER_PREP | WORKER_REBOUND);
2305
2306         do {
2307                 struct work_struct *work =
2308                         list_first_entry(&pool->worklist,
2309                                          struct work_struct, entry);
2310
2311                 if (likely(!(*work_data_bits(work) & WORK_STRUCT_LINKED))) {
2312                         /* optimization path, not strictly necessary */
2313                         process_one_work(worker, work);
2314                         if (unlikely(!list_empty(&worker->scheduled)))
2315                                 process_scheduled_works(worker);
2316                 } else {
2317                         move_linked_works(work, &worker->scheduled, NULL);
2318                         process_scheduled_works(worker);
2319                 }
2320         } while (keep_working(pool));
2321
2322         worker_set_flags(worker, WORKER_PREP, false);
2323 sleep:
2324         if (unlikely(need_to_manage_workers(pool)) && manage_workers(worker))
2325                 goto recheck;
2326
2327         /*
2328          * pool->lock is held and there's no work to process and no need to
2329          * manage, sleep.  Workers are woken up only while holding
2330          * pool->lock or from local cpu, so setting the current state
2331          * before releasing pool->lock is enough to prevent losing any
2332          * event.
2333          */
2334         worker_enter_idle(worker);
2335         __set_current_state(TASK_INTERRUPTIBLE);
2336         spin_unlock_irq(&pool->lock);
2337         schedule();
2338         goto woke_up;
2339 }
2340
2341 /**
2342  * rescuer_thread - the rescuer thread function
2343  * @__rescuer: self
2344  *
2345  * Workqueue rescuer thread function.  There's one rescuer for each
2346  * workqueue which has WQ_MEM_RECLAIM set.
2347  *
2348  * Regular work processing on a pool may block trying to create a new
2349  * worker which uses GFP_KERNEL allocation which has slight chance of
2350  * developing into deadlock if some works currently on the same queue
2351  * need to be processed to satisfy the GFP_KERNEL allocation.  This is
2352  * the problem rescuer solves.
2353  *
2354  * When such condition is possible, the pool summons rescuers of all
2355  * workqueues which have works queued on the pool and let them process
2356  * those works so that forward progress can be guaranteed.
2357  *
2358  * This should happen rarely.
2359  */
2360 static int rescuer_thread(void *__rescuer)
2361 {
2362         struct worker *rescuer = __rescuer;
2363         struct workqueue_struct *wq = rescuer->rescue_wq;
2364         struct list_head *scheduled = &rescuer->scheduled;
2365         bool should_stop;
2366
2367         set_user_nice(current, RESCUER_NICE_LEVEL);
2368
2369         /*
2370          * Mark rescuer as worker too.  As WORKER_PREP is never cleared, it
2371          * doesn't participate in concurrency management.
2372          */
2373         rescuer->task->flags |= PF_WQ_WORKER;
2374 repeat:
2375         set_current_state(TASK_INTERRUPTIBLE);
2376
2377         /*
2378          * By the time the rescuer is requested to stop, the workqueue
2379          * shouldn't have any work pending, but @wq->maydays may still have
2380          * pwq(s) queued.  This can happen by non-rescuer workers consuming
2381          * all the work items before the rescuer got to them.  Go through
2382          * @wq->maydays processing before acting on should_stop so that the
2383          * list is always empty on exit.
2384          */
2385         should_stop = kthread_should_stop();
2386
2387         /* see whether any pwq is asking for help */
2388         spin_lock_irq(&wq_mayday_lock);
2389
2390         while (!list_empty(&wq->maydays)) {
2391                 struct pool_workqueue *pwq = list_first_entry(&wq->maydays,
2392                                         struct pool_workqueue, mayday_node);
2393                 struct worker_pool *pool = pwq->pool;
2394                 struct work_struct *work, *n;
2395
2396                 __set_current_state(TASK_RUNNING);
2397                 list_del_init(&pwq->mayday_node);
2398
2399                 spin_unlock_irq(&wq_mayday_lock);
2400
2401                 /* migrate to the target cpu if possible */
2402                 worker_maybe_bind_and_lock(pool);
2403                 rescuer->pool = pool;
2404
2405                 /*
2406                  * Slurp in all works issued via this workqueue and
2407                  * process'em.
2408                  */
2409                 WARN_ON_ONCE(!list_empty(&rescuer->scheduled));
2410                 list_for_each_entry_safe(work, n, &pool->worklist, entry)
2411                         if (get_work_pwq(work) == pwq)
2412                                 move_linked_works(work, scheduled, &n);
2413
2414                 process_scheduled_works(rescuer);
2415
2416                 /*
2417                  * Put the reference grabbed by send_mayday().  @pool won't
2418                  * go away while we're holding its lock.
2419                  */
2420                 put_pwq(pwq);
2421
2422                 /*
2423                  * Leave this pool.  If keep_working() is %true, notify a
2424                  * regular worker; otherwise, we end up with 0 concurrency
2425                  * and stalling the execution.
2426                  */
2427                 if (keep_working(pool))
2428                         wake_up_worker(pool);
2429
2430                 rescuer->pool = NULL;
2431                 spin_unlock(&pool->lock);
2432                 spin_lock(&wq_mayday_lock);
2433         }
2434
2435         spin_unlock_irq(&wq_mayday_lock);
2436
2437         if (should_stop) {
2438                 __set_current_state(TASK_RUNNING);
2439                 rescuer->task->flags &= ~PF_WQ_WORKER;
2440                 return 0;
2441         }
2442
2443         /* rescuers should never participate in concurrency management */
2444         WARN_ON_ONCE(!(rescuer->flags & WORKER_NOT_RUNNING));
2445         schedule();
2446         goto repeat;
2447 }
2448
2449 struct wq_barrier {
2450         struct work_struct      work;
2451         struct completion       done;
2452 };
2453
2454 static void wq_barrier_func(struct work_struct *work)
2455 {
2456         struct wq_barrier *barr = container_of(work, struct wq_barrier, work);
2457         complete(&barr->done);
2458 }
2459
2460 /**
2461  * insert_wq_barrier - insert a barrier work
2462  * @pwq: pwq to insert barrier into
2463  * @barr: wq_barrier to insert
2464  * @target: target work to attach @barr to
2465  * @worker: worker currently executing @target, NULL if @target is not executing
2466  *
2467  * @barr is linked to @target such that @barr is completed only after
2468  * @target finishes execution.  Please note that the ordering
2469  * guarantee is observed only with respect to @target and on the local
2470  * cpu.
2471  *
2472  * Currently, a queued barrier can't be canceled.  This is because
2473  * try_to_grab_pending() can't determine whether the work to be
2474  * grabbed is at the head of the queue and thus can't clear LINKED
2475  * flag of the previous work while there must be a valid next work
2476  * after a work with LINKED flag set.
2477  *
2478  * Note that when @worker is non-NULL, @target may be modified
2479  * underneath us, so we can't reliably determine pwq from @target.
2480  *
2481  * CONTEXT:
2482  * spin_lock_irq(pool->lock).
2483  */
2484 static void insert_wq_barrier(struct pool_workqueue *pwq,
2485                               struct wq_barrier *barr,
2486                               struct work_struct *target, struct worker *worker)
2487 {
2488         struct list_head *head;
2489         unsigned int linked = 0;
2490
2491         /*
2492          * debugobject calls are safe here even with pool->lock locked
2493          * as we know for sure that this will not trigger any of the
2494          * checks and call back into the fixup functions where we
2495          * might deadlock.
2496          */
2497         INIT_WORK_ONSTACK(&barr->work, wq_barrier_func);
2498         __set_bit(WORK_STRUCT_PENDING_BIT, work_data_bits(&barr->work));
2499         init_completion(&barr->done);
2500
2501         /*
2502          * If @target is currently being executed, schedule the
2503          * barrier to the worker; otherwise, put it after @target.
2504          */
2505         if (worker)
2506                 head = worker->scheduled.next;
2507         else {
2508                 unsigned long *bits = work_data_bits(target);
2509
2510                 head = target->entry.next;
2511                 /* there can already be other linked works, inherit and set */
2512                 linked = *bits & WORK_STRUCT_LINKED;
2513                 __set_bit(WORK_STRUCT_LINKED_BIT, bits);
2514         }
2515
2516         debug_work_activate(&barr->work);
2517         insert_work(pwq, &barr->work, head,
2518                     work_color_to_flags(WORK_NO_COLOR) | linked);
2519 }
2520
2521 /**
2522  * flush_workqueue_prep_pwqs - prepare pwqs for workqueue flushing
2523  * @wq: workqueue being flushed
2524  * @flush_color: new flush color, < 0 for no-op
2525  * @work_color: new work color, < 0 for no-op
2526  *
2527  * Prepare pwqs for workqueue flushing.
2528  *
2529  * If @flush_color is non-negative, flush_color on all pwqs should be
2530  * -1.  If no pwq has in-flight commands at the specified color, all
2531  * pwq->flush_color's stay at -1 and %false is returned.  If any pwq
2532  * has in flight commands, its pwq->flush_color is set to
2533  * @flush_color, @wq->nr_pwqs_to_flush is updated accordingly, pwq
2534  * wakeup logic is armed and %true is returned.
2535  *
2536  * The caller should have initialized @wq->first_flusher prior to
2537  * calling this function with non-negative @flush_color.  If
2538  * @flush_color is negative, no flush color update is done and %false
2539  * is returned.
2540  *
2541  * If @work_color is non-negative, all pwqs should have the same
2542  * work_color which is previous to @work_color and all will be
2543  * advanced to @work_color.
2544  *
2545  * CONTEXT:
2546  * mutex_lock(wq->mutex).
2547  *
2548  * RETURNS:
2549  * %true if @flush_color >= 0 and there's something to flush.  %false
2550  * otherwise.
2551  */
2552 static bool flush_workqueue_prep_pwqs(struct workqueue_struct *wq,
2553                                       int flush_color, int work_color)
2554 {
2555         bool wait = false;
2556         struct pool_workqueue *pwq;
2557
2558         if (flush_color >= 0) {
2559                 WARN_ON_ONCE(atomic_read(&wq->nr_pwqs_to_flush));
2560                 atomic_set(&wq->nr_pwqs_to_flush, 1);
2561         }
2562
2563         for_each_pwq(pwq, wq) {
2564                 struct worker_pool *pool = pwq->pool;
2565
2566                 spin_lock_irq(&pool->lock);
2567
2568                 if (flush_color >= 0) {
2569                         WARN_ON_ONCE(pwq->flush_color != -1);
2570
2571                         if (pwq->nr_in_flight[flush_color]) {
2572                                 pwq->flush_color = flush_color;
2573                                 atomic_inc(&wq->nr_pwqs_to_flush);
2574                                 wait = true;
2575                         }
2576                 }
2577
2578                 if (work_color >= 0) {
2579                         WARN_ON_ONCE(work_color != work_next_color(pwq->work_color));
2580                         pwq->work_color = work_color;
2581                 }
2582
2583                 spin_unlock_irq(&pool->lock);
2584         }
2585
2586         if (flush_color >= 0 && atomic_dec_and_test(&wq->nr_pwqs_to_flush))
2587                 complete(&wq->first_flusher->done);
2588
2589         return wait;
2590 }
2591
2592 /**
2593  * flush_workqueue - ensure that any scheduled work has run to completion.
2594  * @wq: workqueue to flush
2595  *
2596  * This function sleeps until all work items which were queued on entry
2597  * have finished execution, but it is not livelocked by new incoming ones.
2598  */
2599 void flush_workqueue(struct workqueue_struct *wq)
2600 {
2601         struct wq_flusher this_flusher = {
2602                 .list = LIST_HEAD_INIT(this_flusher.list),
2603                 .flush_color = -1,
2604                 .done = COMPLETION_INITIALIZER_ONSTACK(this_flusher.done),
2605         };
2606         int next_color;
2607
2608         lock_map_acquire(&wq->lockdep_map);
2609         lock_map_release(&wq->lockdep_map);
2610
2611         mutex_lock(&wq->mutex);
2612
2613         /*
2614          * Start-to-wait phase
2615          */
2616         next_color = work_next_color(wq->work_color);
2617
2618         if (next_color != wq->flush_color) {
2619                 /*
2620                  * Color space is not full.  The current work_color
2621                  * becomes our flush_color and work_color is advanced
2622                  * by one.
2623                  */
2624                 WARN_ON_ONCE(!list_empty(&wq->flusher_overflow));
2625                 this_flusher.flush_color = wq->work_color;
2626                 wq->work_color = next_color;
2627
2628                 if (!wq->first_flusher) {
2629                         /* no flush in progress, become the first flusher */
2630                         WARN_ON_ONCE(wq->flush_color != this_flusher.flush_color);
2631
2632                         wq->first_flusher = &this_flusher;
2633
2634                         if (!flush_workqueue_prep_pwqs(wq, wq->flush_color,
2635                                                        wq->work_color)) {
2636                                 /* nothing to flush, done */
2637                                 wq->flush_color = next_color;
2638                                 wq->first_flusher = NULL;
2639                                 goto out_unlock;
2640                         }
2641                 } else {
2642                         /* wait in queue */
2643                         WARN_ON_ONCE(wq->flush_color == this_flusher.flush_color);
2644                         list_add_tail(&this_flusher.list, &wq->flusher_queue);
2645                         flush_workqueue_prep_pwqs(wq, -1, wq->work_color);
2646                 }
2647         } else {
2648                 /*
2649                  * Oops, color space is full, wait on overflow queue.
2650                  * The next flush completion will assign us
2651                  * flush_color and transfer to flusher_queue.
2652                  */
2653                 list_add_tail(&this_flusher.list, &wq->flusher_overflow);
2654         }
2655
2656         mutex_unlock(&wq->mutex);
2657
2658         wait_for_completion(&this_flusher.done);
2659
2660         /*
2661          * Wake-up-and-cascade phase
2662          *
2663          * First flushers are responsible for cascading flushes and
2664          * handling overflow.  Non-first flushers can simply return.
2665          */
2666         if (wq->first_flusher != &this_flusher)
2667                 return;
2668
2669         mutex_lock(&wq->mutex);
2670
2671         /* we might have raced, check again with mutex held */
2672         if (wq->first_flusher != &this_flusher)
2673                 goto out_unlock;
2674
2675         wq->first_flusher = NULL;
2676
2677         WARN_ON_ONCE(!list_empty(&this_flusher.list));
2678         WARN_ON_ONCE(wq->flush_color != this_flusher.flush_color);
2679
2680         while (true) {
2681                 struct wq_flusher *next, *tmp;
2682
2683                 /* complete all the flushers sharing the current flush color */
2684                 list_for_each_entry_safe(next, tmp, &wq->flusher_queue, list) {
2685                         if (next->flush_color != wq->flush_color)
2686                                 break;
2687                         list_del_init(&next->list);
2688                         complete(&next->done);
2689                 }
2690
2691                 WARN_ON_ONCE(!list_empty(&wq->flusher_overflow) &&
2692                              wq->flush_color != work_next_color(wq->work_color));
2693
2694                 /* this flush_color is finished, advance by one */
2695                 wq->flush_color = work_next_color(wq->flush_color);
2696
2697                 /* one color has been freed, handle overflow queue */
2698                 if (!list_empty(&wq->flusher_overflow)) {
2699                         /*
2700                          * Assign the same color to all overflowed
2701                          * flushers, advance work_color and append to
2702                          * flusher_queue.  This is the start-to-wait
2703                          * phase for these overflowed flushers.
2704                          */
2705                         list_for_each_entry(tmp, &wq->flusher_overflow, list)
2706                                 tmp->flush_color = wq->work_color;
2707
2708                         wq->work_color = work_next_color(wq->work_color);
2709
2710                         list_splice_tail_init(&wq->flusher_overflow,
2711                                               &wq->flusher_queue);
2712                         flush_workqueue_prep_pwqs(wq, -1, wq->work_color);
2713                 }
2714
2715                 if (list_empty(&wq->flusher_queue)) {
2716                         WARN_ON_ONCE(wq->flush_color != wq->work_color);
2717                         break;
2718                 }
2719
2720                 /*
2721                  * Need to flush more colors.  Make the next flusher
2722                  * the new first flusher and arm pwqs.
2723                  */
2724                 WARN_ON_ONCE(wq->flush_color == wq->work_color);
2725                 WARN_ON_ONCE(wq->flush_color != next->flush_color);
2726
2727                 list_del_init(&next->list);
2728                 wq->first_flusher = next;
2729
2730                 if (flush_workqueue_prep_pwqs(wq, wq->flush_color, -1))
2731                         break;
2732
2733                 /*
2734                  * Meh... this color is already done, clear first
2735                  * flusher and repeat cascading.
2736                  */
2737                 wq->first_flusher = NULL;
2738         }
2739
2740 out_unlock:
2741         mutex_unlock(&wq->mutex);
2742 }
2743 EXPORT_SYMBOL_GPL(flush_workqueue);
2744
2745 /**
2746  * drain_workqueue - drain a workqueue
2747  * @wq: workqueue to drain
2748  *
2749  * Wait until the workqueue becomes empty.  While draining is in progress,
2750  * only chain queueing is allowed.  IOW, only currently pending or running
2751  * work items on @wq can queue further work items on it.  @wq is flushed
2752  * repeatedly until it becomes empty.  The number of flushing is detemined
2753  * by the depth of chaining and should be relatively short.  Whine if it
2754  * takes too long.
2755  */
2756 void drain_workqueue(struct workqueue_struct *wq)
2757 {
2758         unsigned int flush_cnt = 0;
2759         struct pool_workqueue *pwq;
2760
2761         /*
2762          * __queue_work() needs to test whether there are drainers, is much
2763          * hotter than drain_workqueue() and already looks at @wq->flags.
2764          * Use __WQ_DRAINING so that queue doesn't have to check nr_drainers.
2765          */
2766         mutex_lock(&wq->mutex);
2767         if (!wq->nr_drainers++)
2768                 wq->flags |= __WQ_DRAINING;
2769         mutex_unlock(&wq->mutex);
2770 reflush:
2771         flush_workqueue(wq);
2772
2773         mutex_lock(&wq->mutex);
2774
2775         for_each_pwq(pwq, wq) {
2776                 bool drained;
2777
2778                 spin_lock_irq(&pwq->pool->lock);
2779                 drained = !pwq->nr_active && list_empty(&pwq->delayed_works);
2780                 spin_unlock_irq(&pwq->pool->lock);
2781
2782                 if (drained)
2783                         continue;
2784
2785                 if (++flush_cnt == 10 ||
2786                     (flush_cnt % 100 == 0 && flush_cnt <= 1000))
2787                         pr_warn("workqueue %s: drain_workqueue() isn't complete after %u tries\n",
2788                                 wq->name, flush_cnt);
2789
2790                 mutex_unlock(&wq->mutex);
2791                 goto reflush;
2792         }
2793
2794         if (!--wq->nr_drainers)
2795                 wq->flags &= ~__WQ_DRAINING;
2796         mutex_unlock(&wq->mutex);
2797 }
2798 EXPORT_SYMBOL_GPL(drain_workqueue);
2799
2800 static bool start_flush_work(struct work_struct *work, struct wq_barrier *barr)
2801 {
2802         struct worker *worker = NULL;
2803         struct worker_pool *pool;
2804         struct pool_workqueue *pwq;
2805
2806         might_sleep();
2807
2808         local_irq_disable();
2809         pool = get_work_pool(work);
2810         if (!pool) {
2811                 local_irq_enable();
2812                 return false;
2813         }
2814
2815         spin_lock(&pool->lock);
2816         /* see the comment in try_to_grab_pending() with the same code */
2817         pwq = get_work_pwq(work);
2818         if (pwq) {
2819                 if (unlikely(pwq->pool != pool))
2820                         goto already_gone;
2821         } else {
2822                 worker = find_worker_executing_work(pool, work);
2823                 if (!worker)
2824                         goto already_gone;
2825                 pwq = worker->current_pwq;
2826         }
2827
2828         insert_wq_barrier(pwq, barr, work, worker);
2829         spin_unlock_irq(&pool->lock);
2830
2831         /*
2832          * If @max_active is 1 or rescuer is in use, flushing another work
2833          * item on the same workqueue may lead to deadlock.  Make sure the
2834          * flusher is not running on the same workqueue by verifying write
2835          * access.
2836          */
2837         if (pwq->wq->saved_max_active == 1 || pwq->wq->rescuer)
2838                 lock_map_acquire(&pwq->wq->lockdep_map);
2839         else
2840                 lock_map_acquire_read(&pwq->wq->lockdep_map);
2841         lock_map_release(&pwq->wq->lockdep_map);
2842
2843         return true;
2844 already_gone:
2845         spin_unlock_irq(&pool->lock);
2846         return false;
2847 }
2848
2849 /**
2850  * flush_work - wait for a work to finish executing the last queueing instance
2851  * @work: the work to flush
2852  *
2853  * Wait until @work has finished execution.  @work is guaranteed to be idle
2854  * on return if it hasn't been requeued since flush started.
2855  *
2856  * RETURNS:
2857  * %true if flush_work() waited for the work to finish execution,
2858  * %false if it was already idle.
2859  */
2860 bool flush_work(struct work_struct *work)
2861 {
2862         struct wq_barrier barr;
2863
2864         lock_map_acquire(&work->lockdep_map);
2865         lock_map_release(&work->lockdep_map);
2866
2867         if (start_flush_work(work, &barr)) {
2868                 wait_for_completion(&barr.done);
2869                 destroy_work_on_stack(&barr.work);
2870                 return true;
2871         } else {
2872                 return false;
2873         }
2874 }
2875 EXPORT_SYMBOL_GPL(flush_work);
2876
2877 static bool __cancel_work_timer(struct work_struct *work, bool is_dwork)
2878 {
2879         unsigned long flags;
2880         int ret;
2881
2882         do {
2883                 ret = try_to_grab_pending(work, is_dwork, &flags);
2884                 /*
2885                  * If someone else is canceling, wait for the same event it
2886                  * would be waiting for before retrying.
2887                  */
2888                 if (unlikely(ret == -ENOENT))
2889                         flush_work(work);
2890         } while (unlikely(ret < 0));
2891
2892         /* tell other tasks trying to grab @work to back off */
2893         mark_work_canceling(work);
2894         local_irq_restore(flags);
2895
2896         flush_work(work);
2897         clear_work_data(work);
2898         return ret;
2899 }
2900
2901 /**
2902  * cancel_work_sync - cancel a work and wait for it to finish
2903  * @work: the work to cancel
2904  *
2905  * Cancel @work and wait for its execution to finish.  This function
2906  * can be used even if the work re-queues itself or migrates to
2907  * another workqueue.  On return from this function, @work is
2908  * guaranteed to be not pending or executing on any CPU.
2909  *
2910  * cancel_work_sync(&delayed_work->work) must not be used for
2911  * delayed_work's.  Use cancel_delayed_work_sync() instead.
2912  *
2913  * The caller must ensure that the workqueue on which @work was last
2914  * queued can't be destroyed before this function returns.
2915  *
2916  * RETURNS:
2917  * %true if @work was pending, %false otherwise.
2918  */
2919 bool cancel_work_sync(struct work_struct *work)
2920 {
2921         return __cancel_work_timer(work, false);
2922 }
2923 EXPORT_SYMBOL_GPL(cancel_work_sync);
2924
2925 /**
2926  * flush_delayed_work - wait for a dwork to finish executing the last queueing
2927  * @dwork: the delayed work to flush
2928  *
2929  * Delayed timer is cancelled and the pending work is queued for
2930  * immediate execution.  Like flush_work(), this function only
2931  * considers the last queueing instance of @dwork.
2932  *
2933  * RETURNS:
2934  * %true if flush_work() waited for the work to finish execution,
2935  * %false if it was already idle.
2936  */
2937 bool flush_delayed_work(struct delayed_work *dwork)
2938 {
2939         local_irq_disable();
2940         if (del_timer_sync(&dwork->timer))
2941                 __queue_work(dwork->cpu, dwork->wq, &dwork->work);
2942         local_irq_enable();
2943         return flush_work(&dwork->work);
2944 }
2945 EXPORT_SYMBOL(flush_delayed_work);
2946
2947 /**
2948  * cancel_delayed_work - cancel a delayed work
2949  * @dwork: delayed_work to cancel
2950  *
2951  * Kill off a pending delayed_work.  Returns %true if @dwork was pending
2952  * and canceled; %false if wasn't pending.  Note that the work callback
2953  * function may still be running on return, unless it returns %true and the
2954  * work doesn't re-arm itself.  Explicitly flush or use
2955  * cancel_delayed_work_sync() to wait on it.
2956  *
2957  * This function is safe to call from any context including IRQ handler.
2958  */
2959 bool cancel_delayed_work(struct delayed_work *dwork)
2960 {
2961         unsigned long flags;
2962         int ret;
2963
2964         do {
2965                 ret = try_to_grab_pending(&dwork->work, true, &flags);
2966         } while (unlikely(ret == -EAGAIN));
2967
2968         if (unlikely(ret < 0))
2969                 return false;
2970
2971         set_work_pool_and_clear_pending(&dwork->work,
2972                                         get_work_pool_id(&dwork->work));
2973         local_irq_restore(flags);
2974         return ret;
2975 }
2976 EXPORT_SYMBOL(cancel_delayed_work);
2977
2978 /**
2979  * cancel_delayed_work_sync - cancel a delayed work and wait for it to finish
2980  * @dwork: the delayed work cancel
2981  *
2982  * This is cancel_work_sync() for delayed works.
2983  *
2984  * RETURNS:
2985  * %true if @dwork was pending, %false otherwise.
2986  */
2987 bool cancel_delayed_work_sync(struct delayed_work *dwork)
2988 {
2989         return __cancel_work_timer(&dwork->work, true);
2990 }
2991 EXPORT_SYMBOL(cancel_delayed_work_sync);
2992
2993 /**
2994  * schedule_on_each_cpu - execute a function synchronously on each online CPU
2995  * @func: the function to call
2996  *
2997  * schedule_on_each_cpu() executes @func on each online CPU using the
2998  * system workqueue and blocks until all CPUs have completed.
2999  * schedule_on_each_cpu() is very slow.
3000  *
3001  * RETURNS:
3002  * 0 on success, -errno on failure.
3003  */
3004 int schedule_on_each_cpu(work_func_t func)
3005 {
3006         int cpu;
3007         struct work_struct __percpu *works;
3008
3009         works = alloc_percpu(struct work_struct);
3010         if (!works)
3011                 return -ENOMEM;
3012
3013         get_online_cpus();
3014
3015         for_each_online_cpu(cpu) {
3016                 struct work_struct *work = per_cpu_ptr(works, cpu);
3017
3018                 INIT_WORK(work, func);
3019                 schedule_work_on(cpu, work);
3020         }
3021
3022         for_each_online_cpu(cpu)
3023                 flush_work(per_cpu_ptr(works, cpu));
3024
3025         put_online_cpus();
3026         free_percpu(works);
3027         return 0;
3028 }
3029
3030 /**
3031  * flush_scheduled_work - ensure that any scheduled work has run to completion.
3032  *
3033  * Forces execution of the kernel-global workqueue and blocks until its
3034  * completion.
3035  *
3036  * Think twice before calling this function!  It's very easy to get into
3037  * trouble if you don't take great care.  Either of the following situations
3038  * will lead to deadlock:
3039  *
3040  *      One of the work items currently on the workqueue needs to acquire
3041  *      a lock held by your code or its caller.
3042  *
3043  *      Your code is running in the context of a work routine.
3044  *
3045  * They will be detected by lockdep when they occur, but the first might not
3046  * occur very often.  It depends on what work items are on the workqueue and
3047  * what locks they need, which you have no control over.
3048  *
3049  * In most situations flushing the entire workqueue is overkill; you merely
3050  * need to know that a particular work item isn't queued and isn't running.
3051  * In such cases you should use cancel_delayed_work_sync() or
3052  * cancel_work_sync() instead.
3053  */
3054 void flush_scheduled_work(void)
3055 {
3056         flush_workqueue(system_wq);
3057 }
3058 EXPORT_SYMBOL(flush_scheduled_work);
3059
3060 /**
3061  * execute_in_process_context - reliably execute the routine with user context
3062  * @fn:         the function to execute
3063  * @ew:         guaranteed storage for the execute work structure (must
3064  *              be available when the work executes)
3065  *
3066  * Executes the function immediately if process context is available,
3067  * otherwise schedules the function for delayed execution.
3068  *
3069  * Returns:     0 - function was executed
3070  *              1 - function was scheduled for execution
3071  */
3072 int execute_in_process_context(work_func_t fn, struct execute_work *ew)
3073 {
3074         if (!in_interrupt()) {
3075                 fn(&ew->work);
3076                 return 0;
3077         }
3078
3079         INIT_WORK(&ew->work, fn);
3080         schedule_work(&ew->work);
3081
3082         return 1;
3083 }
3084 EXPORT_SYMBOL_GPL(execute_in_process_context);
3085
3086 #ifdef CONFIG_SYSFS
3087 /*
3088  * Workqueues with WQ_SYSFS flag set is visible to userland via
3089  * /sys/bus/workqueue/devices/WQ_NAME.  All visible workqueues have the
3090  * following attributes.
3091  *
3092  *  per_cpu     RO bool : whether the workqueue is per-cpu or unbound
3093  *  max_active  RW int  : maximum number of in-flight work items
3094  *
3095  * Unbound workqueues have the following extra attributes.
3096  *
3097  *  id          RO int  : the associated pool ID
3098  *  nice        RW int  : nice value of the workers
3099  *  cpumask     RW mask : bitmask of allowed CPUs for the workers
3100  */
3101 struct wq_device {
3102         struct workqueue_struct         *wq;
3103         struct device                   dev;
3104 };
3105
3106 static struct workqueue_struct *dev_to_wq(struct device *dev)
3107 {
3108         struct wq_device *wq_dev = container_of(dev, struct wq_device, dev);
3109
3110         return wq_dev->wq;
3111 }
3112
3113 static ssize_t wq_per_cpu_show(struct device *dev,
3114                                struct device_attribute *attr, char *buf)
3115 {
3116         struct workqueue_struct *wq = dev_to_wq(dev);
3117
3118         return scnprintf(buf, PAGE_SIZE, "%d\n", (bool)!(wq->flags & WQ_UNBOUND));
3119 }
3120
3121 static ssize_t wq_max_active_show(struct device *dev,
3122                                   struct device_attribute *attr, char *buf)
3123 {
3124         struct workqueue_struct *wq = dev_to_wq(dev);
3125
3126         return scnprintf(buf, PAGE_SIZE, "%d\n", wq->saved_max_active);
3127 }
3128
3129 static ssize_t wq_max_active_store(struct device *dev,
3130                                    struct device_attribute *attr,
3131                                    const char *buf, size_t count)
3132 {
3133         struct workqueue_struct *wq = dev_to_wq(dev);
3134         int val;
3135
3136         if (sscanf(buf, "%d", &val) != 1 || val <= 0)
3137                 return -EINVAL;
3138
3139         workqueue_set_max_active(wq, val);
3140         return count;
3141 }
3142
3143 static struct device_attribute wq_sysfs_attrs[] = {
3144         __ATTR(per_cpu, 0444, wq_per_cpu_show, NULL),
3145         __ATTR(max_active, 0644, wq_max_active_show, wq_max_active_store),
3146         __ATTR_NULL,
3147 };
3148
3149 static ssize_t wq_pool_ids_show(struct device *dev,
3150                                 struct device_attribute *attr, char *buf)
3151 {
3152         struct workqueue_struct *wq = dev_to_wq(dev);
3153         const char *delim = "";
3154         int node, written = 0;
3155
3156         rcu_read_lock_sched();
3157         for_each_node(node) {
3158                 written += scnprintf(buf + written, PAGE_SIZE - written,
3159                                      "%s%d:%d", delim, node,
3160                                      unbound_pwq_by_node(wq, node)->pool->id);
3161                 delim = " ";
3162         }
3163         written += scnprintf(buf + written, PAGE_SIZE - written, "\n");
3164         rcu_read_unlock_sched();
3165
3166         return written;
3167 }
3168
3169 static ssize_t wq_nice_show(struct device *dev, struct device_attribute *attr,
3170                             char *buf)
3171 {
3172         struct workqueue_struct *wq = dev_to_wq(dev);
3173         int written;
3174
3175         mutex_lock(&wq->mutex);
3176         written = scnprintf(buf, PAGE_SIZE, "%d\n", wq->unbound_attrs->nice);
3177         mutex_unlock(&wq->mutex);
3178
3179         return written;
3180 }
3181
3182 /* prepare workqueue_attrs for sysfs store operations */
3183 static struct workqueue_attrs *wq_sysfs_prep_attrs(struct workqueue_struct *wq)
3184 {
3185         struct workqueue_attrs *attrs;
3186
3187         attrs = alloc_workqueue_attrs(GFP_KERNEL);
3188         if (!attrs)
3189                 return NULL;
3190
3191         mutex_lock(&wq->mutex);
3192         copy_workqueue_attrs(attrs, wq->unbound_attrs);
3193         mutex_unlock(&wq->mutex);
3194         return attrs;
3195 }
3196
3197 static ssize_t wq_nice_store(struct device *dev, struct device_attribute *attr,
3198                              const char *buf, size_t count)
3199 {
3200         struct workqueue_struct *wq = dev_to_wq(dev);
3201         struct workqueue_attrs *attrs;
3202         int ret;
3203
3204         attrs = wq_sysfs_prep_attrs(wq);
3205         if (!attrs)
3206                 return -ENOMEM;
3207
3208         if (sscanf(buf, "%d", &attrs->nice) == 1 &&
3209             attrs->nice >= -20 && attrs->nice <= 19)
3210                 ret = apply_workqueue_attrs(wq, attrs);
3211         else
3212                 ret = -EINVAL;
3213
3214         free_workqueue_attrs(attrs);
3215         return ret ?: count;
3216 }
3217
3218 static ssize_t wq_cpumask_show(struct device *dev,
3219                                struct device_attribute *attr, char *buf)
3220 {
3221         struct workqueue_struct *wq = dev_to_wq(dev);
3222         int written;
3223
3224         mutex_lock(&wq->mutex);
3225         written = cpumask_scnprintf(buf, PAGE_SIZE, wq->unbound_attrs->cpumask);
3226         mutex_unlock(&wq->mutex);
3227
3228         written += scnprintf(buf + written, PAGE_SIZE - written, "\n");
3229         return written;
3230 }
3231
3232 static ssize_t wq_cpumask_store(struct device *dev,
3233                                 struct device_attribute *attr,
3234                                 const char *buf, size_t count)
3235 {
3236         struct workqueue_struct *wq = dev_to_wq(dev);
3237         struct workqueue_attrs *attrs;
3238         int ret;
3239
3240         attrs = wq_sysfs_prep_attrs(wq);
3241         if (!attrs)
3242                 return -ENOMEM;
3243
3244         ret = cpumask_parse(buf, attrs->cpumask);
3245         if (!ret)
3246                 ret = apply_workqueue_attrs(wq, attrs);
3247
3248         free_workqueue_attrs(attrs);
3249         return ret ?: count;
3250 }
3251
3252 static ssize_t wq_numa_show(struct device *dev, struct device_attribute *attr,
3253                             char *buf)
3254 {
3255         struct workqueue_struct *wq = dev_to_wq(dev);
3256         int written;
3257
3258         mutex_lock(&wq->mutex);
3259         written = scnprintf(buf, PAGE_SIZE, "%d\n",
3260                             !wq->unbound_attrs->no_numa);
3261         mutex_unlock(&wq->mutex);
3262
3263         return written;
3264 }
3265
3266 static ssize_t wq_numa_store(struct device *dev, struct device_attribute *attr,
3267                              const char *buf, size_t count)
3268 {
3269         struct workqueue_struct *wq = dev_to_wq(dev);
3270         struct workqueue_attrs *attrs;
3271         int v, ret;
3272
3273         attrs = wq_sysfs_prep_attrs(wq);
3274         if (!attrs)
3275                 return -ENOMEM;
3276
3277         ret = -EINVAL;
3278         if (sscanf(buf, "%d", &v) == 1) {
3279                 attrs->no_numa = !v;
3280                 ret = apply_workqueue_attrs(wq, attrs);
3281         }
3282
3283         free_workqueue_attrs(attrs);
3284         return ret ?: count;
3285 }
3286
3287 static struct device_attribute wq_sysfs_unbound_attrs[] = {
3288         __ATTR(pool_ids, 0444, wq_pool_ids_show, NULL),
3289         __ATTR(nice, 0644, wq_nice_show, wq_nice_store),
3290         __ATTR(cpumask, 0644, wq_cpumask_show, wq_cpumask_store),
3291         __ATTR(numa, 0644, wq_numa_show, wq_numa_store),
3292         __ATTR_NULL,
3293 };
3294
3295 static struct bus_type wq_subsys = {
3296         .name                           = "workqueue",
3297         .dev_attrs                      = wq_sysfs_attrs,
3298 };
3299
3300 static int __init wq_sysfs_init(void)
3301 {
3302         return subsys_virtual_register(&wq_subsys, NULL);
3303 }
3304 core_initcall(wq_sysfs_init);
3305
3306 static void wq_device_release(struct device *dev)
3307 {
3308         struct wq_device *wq_dev = container_of(dev, struct wq_device, dev);
3309
3310         kfree(wq_dev);
3311 }
3312
3313 /**
3314  * workqueue_sysfs_register - make a workqueue visible in sysfs
3315  * @wq: the workqueue to register
3316  *
3317  * Expose @wq in sysfs under /sys/bus/workqueue/devices.
3318  * alloc_workqueue*() automatically calls this function if WQ_SYSFS is set
3319  * which is the preferred method.
3320  *
3321  * Workqueue user should use this function directly iff it wants to apply
3322  * workqueue_attrs before making the workqueue visible in sysfs; otherwise,
3323  * apply_workqueue_attrs() may race against userland updating the
3324  * attributes.
3325  *
3326  * Returns 0 on success, -errno on failure.
3327  */
3328 int workqueue_sysfs_register(struct workqueue_struct *wq)
3329 {
3330         struct wq_device *wq_dev;
3331         int ret;
3332
3333         /*
3334          * Adjusting max_active or creating new pwqs by applyting
3335          * attributes breaks ordering guarantee.  Disallow exposing ordered
3336          * workqueues.
3337          */
3338         if (WARN_ON(wq->flags & __WQ_ORDERED))
3339                 return -EINVAL;
3340
3341         wq->wq_dev = wq_dev = kzalloc(sizeof(*wq_dev), GFP_KERNEL);
3342         if (!wq_dev)
3343                 return -ENOMEM;
3344
3345         wq_dev->wq = wq;
3346         wq_dev->dev.bus = &wq_subsys;
3347         wq_dev->dev.init_name = wq->name;
3348         wq_dev->dev.release = wq_device_release;
3349
3350         /*
3351          * unbound_attrs are created separately.  Suppress uevent until
3352          * everything is ready.
3353          */
3354         dev_set_uevent_suppress(&wq_dev->dev, true);
3355
3356         ret = device_register(&wq_dev->dev);
3357         if (ret) {
3358                 kfree(wq_dev);
3359                 wq->wq_dev = NULL;
3360                 return ret;
3361         }
3362
3363         if (wq->flags & WQ_UNBOUND) {
3364                 struct device_attribute *attr;
3365
3366                 for (attr = wq_sysfs_unbound_attrs; attr->attr.name; attr++) {
3367                         ret = device_create_file(&wq_dev->dev, attr);
3368                         if (ret) {
3369                                 device_unregister(&wq_dev->dev);
3370                                 wq->wq_dev = NULL;
3371                                 return ret;
3372                         }
3373                 }
3374         }
3375
3376         dev_set_uevent_suppress(&wq_dev->dev, false);
3377         kobject_uevent(&wq_dev->dev.kobj, KOBJ_ADD);
3378         return 0;
3379 }
3380
3381 /**
3382  * workqueue_sysfs_unregister - undo workqueue_sysfs_register()
3383  * @wq: the workqueue to unregister
3384  *
3385  * If @wq is registered to sysfs by workqueue_sysfs_register(), unregister.
3386  */
3387 static void workqueue_sysfs_unregister(struct workqueue_struct *wq)
3388 {
3389         struct wq_device *wq_dev = wq->wq_dev;
3390
3391         if (!wq->wq_dev)
3392                 return;
3393
3394         wq->wq_dev = NULL;
3395         device_unregister(&wq_dev->dev);
3396 }
3397 #else   /* CONFIG_SYSFS */
3398 static void workqueue_sysfs_unregister(struct workqueue_struct *wq)     { }
3399 #endif  /* CONFIG_SYSFS */
3400
3401 /**
3402  * free_workqueue_attrs - free a workqueue_attrs
3403  * @attrs: workqueue_attrs to free
3404  *
3405  * Undo alloc_workqueue_attrs().
3406  */
3407 void free_workqueue_attrs(struct workqueue_attrs *attrs)
3408 {
3409         if (attrs) {
3410                 free_cpumask_var(attrs->cpumask);
3411                 kfree(attrs);
3412         }
3413 }
3414
3415 /**
3416  * alloc_workqueue_attrs - allocate a workqueue_attrs
3417  * @gfp_mask: allocation mask to use
3418  *
3419  * Allocate a new workqueue_attrs, initialize with default settings and
3420  * return it.  Returns NULL on failure.
3421  */
3422 struct workqueue_attrs *alloc_workqueue_attrs(gfp_t gfp_mask)
3423 {
3424         struct workqueue_attrs *attrs;
3425
3426         attrs = kzalloc(sizeof(*attrs), gfp_mask);
3427         if (!attrs)
3428                 goto fail;
3429         if (!alloc_cpumask_var(&attrs->cpumask, gfp_mask))
3430                 goto fail;
3431
3432         cpumask_copy(attrs->cpumask, cpu_possible_mask);
3433         return attrs;
3434 fail:
3435         free_workqueue_attrs(attrs);
3436         return NULL;
3437 }
3438
3439 static void copy_workqueue_attrs(struct workqueue_attrs *to,
3440                                  const struct workqueue_attrs *from)
3441 {
3442         to->nice = from->nice;
3443         cpumask_copy(to->cpumask, from->cpumask);
3444         /*
3445          * Unlike hash and equality test, this function doesn't ignore
3446          * ->no_numa as it is used for both pool and wq attrs.  Instead,
3447          * get_unbound_pool() explicitly clears ->no_numa after copying.
3448          */
3449         to->no_numa = from->no_numa;
3450 }
3451
3452 /* hash value of the content of @attr */
3453 static u32 wqattrs_hash(const struct workqueue_attrs *attrs)
3454 {
3455         u32 hash = 0;
3456
3457         hash = jhash_1word(attrs->nice, hash);
3458         hash = jhash(cpumask_bits(attrs->cpumask),
3459                      BITS_TO_LONGS(nr_cpumask_bits) * sizeof(long), hash);
3460         return hash;
3461 }
3462
3463 /* content equality test */
3464 static bool wqattrs_equal(const struct workqueue_attrs *a,
3465                           const struct workqueue_attrs *b)
3466 {
3467         if (a->nice != b->nice)
3468                 return false;
3469         if (!cpumask_equal(a->cpumask, b->cpumask))
3470                 return false;
3471         return true;
3472 }
3473
3474 /**
3475  * init_worker_pool - initialize a newly zalloc'd worker_pool
3476  * @pool: worker_pool to initialize
3477  *
3478  * Initiailize a newly zalloc'd @pool.  It also allocates @pool->attrs.
3479  * Returns 0 on success, -errno on failure.  Even on failure, all fields
3480  * inside @pool proper are initialized and put_unbound_pool() can be called
3481  * on @pool safely to release it.
3482  */
3483 static int init_worker_pool(struct worker_pool *pool)
3484 {
3485         spin_lock_init(&pool->lock);
3486         pool->id = -1;
3487         pool->cpu = -1;
3488         pool->node = NUMA_NO_NODE;
3489         pool->flags |= POOL_DISASSOCIATED;
3490         INIT_LIST_HEAD(&pool->worklist);
3491         INIT_LIST_HEAD(&pool->idle_list);
3492         hash_init(pool->busy_hash);
3493
3494         init_timer_deferrable(&pool->idle_timer);
3495         pool->idle_timer.function = idle_worker_timeout;
3496         pool->idle_timer.data = (unsigned long)pool;
3497
3498         setup_timer(&pool->mayday_timer, pool_mayday_timeout,
3499                     (unsigned long)pool);
3500
3501         mutex_init(&pool->manager_arb);
3502         mutex_init(&pool->manager_mutex);
3503         idr_init(&pool->worker_idr);
3504
3505         INIT_HLIST_NODE(&pool->hash_node);
3506         pool->refcnt = 1;
3507
3508         /* shouldn't fail above this point */
3509         pool->attrs = alloc_workqueue_attrs(GFP_KERNEL);
3510         if (!pool->attrs)
3511                 return -ENOMEM;
3512         return 0;
3513 }
3514
3515 static void rcu_free_pool(struct rcu_head *rcu)
3516 {
3517         struct worker_pool *pool = container_of(rcu, struct worker_pool, rcu);
3518
3519         idr_destroy(&pool->worker_idr);
3520         free_workqueue_attrs(pool->attrs);
3521         kfree(pool);
3522 }
3523
3524 /**
3525  * put_unbound_pool - put a worker_pool
3526  * @pool: worker_pool to put
3527  *
3528  * Put @pool.  If its refcnt reaches zero, it gets destroyed in sched-RCU
3529  * safe manner.  get_unbound_pool() calls this function on its failure path
3530  * and this function should be able to release pools which went through,
3531  * successfully or not, init_worker_pool().
3532  *
3533  * Should be called with wq_pool_mutex held.
3534  */
3535 static void put_unbound_pool(struct worker_pool *pool)
3536 {
3537         struct worker *worker;
3538
3539         lockdep_assert_held(&wq_pool_mutex);
3540
3541         if (--pool->refcnt)
3542                 return;
3543
3544         /* sanity checks */
3545         if (WARN_ON(!(pool->flags & POOL_DISASSOCIATED)) ||
3546             WARN_ON(!list_empty(&pool->worklist)))
3547                 return;
3548
3549         /* release id and unhash */
3550         if (pool->id >= 0)
3551                 idr_remove(&worker_pool_idr, pool->id);
3552         hash_del(&pool->hash_node);
3553
3554         /*
3555          * Become the manager and destroy all workers.  Grabbing
3556          * manager_arb prevents @pool's workers from blocking on
3557          * manager_mutex.
3558          */
3559         mutex_lock(&pool->manager_arb);
3560         mutex_lock(&pool->manager_mutex);
3561         spin_lock_irq(&pool->lock);
3562
3563         while ((worker = first_worker(pool)))
3564                 destroy_worker(worker);
3565         WARN_ON(pool->nr_workers || pool->nr_idle);
3566
3567         spin_unlock_irq(&pool->lock);
3568         mutex_unlock(&pool->manager_mutex);
3569         mutex_unlock(&pool->manager_arb);
3570
3571         /* shut down the timers */
3572         del_timer_sync(&pool->idle_timer);
3573         del_timer_sync(&pool->mayday_timer);
3574
3575         /* sched-RCU protected to allow dereferences from get_work_pool() */
3576         call_rcu_sched(&pool->rcu, rcu_free_pool);
3577 }
3578
3579 /**
3580  * get_unbound_pool - get a worker_pool with the specified attributes
3581  * @attrs: the attributes of the worker_pool to get
3582  *
3583  * Obtain a worker_pool which has the same attributes as @attrs, bump the
3584  * reference count and return it.  If there already is a matching
3585  * worker_pool, it will be used; otherwise, this function attempts to
3586  * create a new one.  On failure, returns NULL.
3587  *
3588  * Should be called with wq_pool_mutex held.
3589  */
3590 static struct worker_pool *get_unbound_pool(const struct workqueue_attrs *attrs)
3591 {
3592         u32 hash = wqattrs_hash(attrs);
3593         struct worker_pool *pool;
3594         int node;
3595
3596         lockdep_assert_held(&wq_pool_mutex);
3597
3598         /* do we already have a matching pool? */
3599         hash_for_each_possible(unbound_pool_hash, pool, hash_node, hash) {
3600                 if (wqattrs_equal(pool->attrs, attrs)) {
3601                         pool->refcnt++;
3602                         goto out_unlock;
3603                 }
3604         }
3605
3606         /* nope, create a new one */
3607         pool = kzalloc(sizeof(*pool), GFP_KERNEL);
3608         if (!pool || init_worker_pool(pool) < 0)
3609                 goto fail;
3610
3611         if (workqueue_freezing)
3612                 pool->flags |= POOL_FREEZING;
3613
3614         lockdep_set_subclass(&pool->lock, 1);   /* see put_pwq() */
3615         copy_workqueue_attrs(pool->attrs, attrs);
3616
3617         /*
3618          * no_numa isn't a worker_pool attribute, always clear it.  See
3619          * 'struct workqueue_attrs' comments for detail.
3620          */
3621         pool->attrs->no_numa = false;
3622
3623         /* if cpumask is contained inside a NUMA node, we belong to that node */
3624         if (wq_numa_enabled) {
3625                 for_each_node(node) {
3626                         if (cpumask_subset(pool->attrs->cpumask,
3627                                            wq_numa_possible_cpumask[node])) {
3628                                 pool->node = node;
3629                                 break;
3630                         }
3631                 }
3632         }
3633
3634         if (worker_pool_assign_id(pool) < 0)
3635                 goto fail;
3636
3637         /* create and start the initial worker */
3638         if (create_and_start_worker(pool) < 0)
3639                 goto fail;
3640
3641         /* install */
3642         hash_add(unbound_pool_hash, &pool->hash_node, hash);
3643 out_unlock:
3644         return pool;
3645 fail:
3646         if (pool)
3647                 put_unbound_pool(pool);
3648         return NULL;
3649 }
3650
3651 static void rcu_free_pwq(struct rcu_head *rcu)
3652 {
3653         kmem_cache_free(pwq_cache,
3654                         container_of(rcu, struct pool_workqueue, rcu));
3655 }
3656
3657 /*
3658  * Scheduled on system_wq by put_pwq() when an unbound pwq hits zero refcnt
3659  * and needs to be destroyed.
3660  */
3661 static void pwq_unbound_release_workfn(struct work_struct *work)
3662 {
3663         struct pool_workqueue *pwq = container_of(work, struct pool_workqueue,
3664                                                   unbound_release_work);
3665         struct workqueue_struct *wq = pwq->wq;
3666         struct worker_pool *pool = pwq->pool;
3667         bool is_last;
3668
3669         if (WARN_ON_ONCE(!(wq->flags & WQ_UNBOUND)))
3670                 return;
3671
3672         /*
3673          * Unlink @pwq.  Synchronization against wq->mutex isn't strictly
3674          * necessary on release but do it anyway.  It's easier to verify
3675          * and consistent with the linking path.
3676          */
3677         mutex_lock(&wq->mutex);
3678         list_del_rcu(&pwq->pwqs_node);
3679         is_last = list_empty(&wq->pwqs);
3680         mutex_unlock(&wq->mutex);
3681
3682         mutex_lock(&wq_pool_mutex);
3683         put_unbound_pool(pool);
3684         mutex_unlock(&wq_pool_mutex);
3685
3686         call_rcu_sched(&pwq->rcu, rcu_free_pwq);
3687
3688         /*
3689          * If we're the last pwq going away, @wq is already dead and no one
3690          * is gonna access it anymore.  Free it.
3691          */
3692         if (is_last) {
3693                 free_workqueue_attrs(wq->unbound_attrs);
3694                 kfree(wq);
3695         }
3696 }
3697
3698 /**
3699  * pwq_adjust_max_active - update a pwq's max_active to the current setting
3700  * @pwq: target pool_workqueue
3701  *
3702  * If @pwq isn't freezing, set @pwq->max_active to the associated
3703  * workqueue's saved_max_active and activate delayed work items
3704  * accordingly.  If @pwq is freezing, clear @pwq->max_active to zero.
3705  */
3706 static void pwq_adjust_max_active(struct pool_workqueue *pwq)
3707 {
3708         struct workqueue_struct *wq = pwq->wq;
3709         bool freezable = wq->flags & WQ_FREEZABLE;
3710
3711         /* for @wq->saved_max_active */
3712         lockdep_assert_held(&wq->mutex);
3713
3714         /* fast exit for non-freezable wqs */
3715         if (!freezable && pwq->max_active == wq->saved_max_active)
3716                 return;
3717
3718         spin_lock_irq(&pwq->pool->lock);
3719
3720         if (!freezable || !(pwq->pool->flags & POOL_FREEZING)) {
3721                 pwq->max_active = wq->saved_max_active;
3722
3723                 while (!list_empty(&pwq->delayed_works) &&
3724                        pwq->nr_active < pwq->max_active)
3725                         pwq_activate_first_delayed(pwq);
3726
3727                 /*
3728                  * Need to kick a worker after thawed or an unbound wq's
3729                  * max_active is bumped.  It's a slow path.  Do it always.
3730                  */
3731                 wake_up_worker(pwq->pool);
3732         } else {
3733                 pwq->max_active = 0;
3734         }
3735
3736         spin_unlock_irq(&pwq->pool->lock);
3737 }
3738
3739 /* initialize newly alloced @pwq which is associated with @wq and @pool */
3740 static void init_pwq(struct pool_workqueue *pwq, struct workqueue_struct *wq,
3741                      struct worker_pool *pool)
3742 {
3743         BUG_ON((unsigned long)pwq & WORK_STRUCT_FLAG_MASK);
3744
3745         memset(pwq, 0, sizeof(*pwq));
3746
3747         pwq->pool = pool;
3748         pwq->wq = wq;
3749         pwq->flush_color = -1;
3750         pwq->refcnt = 1;
3751         INIT_LIST_HEAD(&pwq->delayed_works);
3752         INIT_LIST_HEAD(&pwq->pwqs_node);
3753         INIT_LIST_HEAD(&pwq->mayday_node);
3754         INIT_WORK(&pwq->unbound_release_work, pwq_unbound_release_workfn);
3755 }
3756
3757 /* sync @pwq with the current state of its associated wq and link it */
3758 static void link_pwq(struct pool_workqueue *pwq)
3759 {
3760         struct workqueue_struct *wq = pwq->wq;
3761
3762         lockdep_assert_held(&wq->mutex);
3763
3764         /* may be called multiple times, ignore if already linked */
3765         if (!list_empty(&pwq->pwqs_node))
3766                 return;
3767
3768         /*
3769          * Set the matching work_color.  This is synchronized with
3770          * wq->mutex to avoid confusing flush_workqueue().
3771          */
3772         pwq->work_color = wq->work_color;
3773
3774         /* sync max_active to the current setting */
3775         pwq_adjust_max_active(pwq);
3776
3777         /* link in @pwq */
3778         list_add_rcu(&pwq->pwqs_node, &wq->pwqs);
3779 }
3780
3781 /* obtain a pool matching @attr and create a pwq associating the pool and @wq */
3782 static struct pool_workqueue *alloc_unbound_pwq(struct workqueue_struct *wq,
3783                                         const struct workqueue_attrs *attrs)
3784 {
3785         struct worker_pool *pool;
3786         struct pool_workqueue *pwq;
3787
3788         lockdep_assert_held(&wq_pool_mutex);
3789
3790         pool = get_unbound_pool(attrs);
3791         if (!pool)
3792                 return NULL;
3793
3794         pwq = kmem_cache_alloc_node(pwq_cache, GFP_KERNEL, pool->node);
3795         if (!pwq) {
3796                 put_unbound_pool(pool);
3797                 return NULL;
3798         }
3799
3800         init_pwq(pwq, wq, pool);
3801         return pwq;
3802 }
3803
3804 /* undo alloc_unbound_pwq(), used only in the error path */
3805 static void free_unbound_pwq(struct pool_workqueue *pwq)
3806 {
3807         lockdep_assert_held(&wq_pool_mutex);
3808
3809         if (pwq) {
3810                 put_unbound_pool(pwq->pool);
3811                 kmem_cache_free(pwq_cache, pwq);
3812         }
3813 }
3814
3815 /**
3816  * wq_calc_node_mask - calculate a wq_attrs' cpumask for the specified node
3817  * @attrs: the wq_attrs of interest
3818  * @node: the target NUMA node
3819  * @cpu_going_down: if >= 0, the CPU to consider as offline
3820  * @cpumask: outarg, the resulting cpumask
3821  *
3822  * Calculate the cpumask a workqueue with @attrs should use on @node.  If
3823  * @cpu_going_down is >= 0, that cpu is considered offline during
3824  * calculation.  The result is stored in @cpumask.  This function returns
3825  * %true if the resulting @cpumask is different from @attrs->cpumask,
3826  * %false if equal.
3827  *
3828  * If NUMA affinity is not enabled, @attrs->cpumask is always used.  If
3829  * enabled and @node has online CPUs requested by @attrs, the returned
3830  * cpumask is the intersection of the possible CPUs of @node and
3831  * @attrs->cpumask.
3832  *
3833  * The caller is responsible for ensuring that the cpumask of @node stays
3834  * stable.
3835  */
3836 static bool wq_calc_node_cpumask(const struct workqueue_attrs *attrs, int node,
3837                                  int cpu_going_down, cpumask_t *cpumask)
3838 {
3839         if (!wq_numa_enabled || attrs->no_numa)
3840                 goto use_dfl;
3841
3842         /* does @node have any online CPUs @attrs wants? */
3843         cpumask_and(cpumask, cpumask_of_node(node), attrs->cpumask);
3844         if (cpu_going_down >= 0)
3845                 cpumask_clear_cpu(cpu_going_down, cpumask);
3846
3847         if (cpumask_empty(cpumask))
3848                 goto use_dfl;
3849
3850         /* yeap, return possible CPUs in @node that @attrs wants */
3851         cpumask_and(cpumask, attrs->cpumask, wq_numa_possible_cpumask[node]);
3852         return !cpumask_equal(cpumask, attrs->cpumask);
3853
3854 use_dfl:
3855         cpumask_copy(cpumask, attrs->cpumask);
3856         return false;
3857 }
3858
3859 /* install @pwq into @wq's numa_pwq_tbl[] for @node and return the old pwq */
3860 static struct pool_workqueue *numa_pwq_tbl_install(struct workqueue_struct *wq,
3861                                                    int node,
3862                                                    struct pool_workqueue *pwq)
3863 {
3864         struct pool_workqueue *old_pwq;
3865
3866         lockdep_assert_held(&wq->mutex);
3867
3868         /* link_pwq() can handle duplicate calls */
3869         link_pwq(pwq);
3870
3871         old_pwq = rcu_access_pointer(wq->numa_pwq_tbl[node]);
3872         rcu_assign_pointer(wq->numa_pwq_tbl[node], pwq);
3873         return old_pwq;
3874 }
3875
3876 /**
3877  * apply_workqueue_attrs - apply new workqueue_attrs to an unbound workqueue
3878  * @wq: the target workqueue
3879  * @attrs: the workqueue_attrs to apply, allocated with alloc_workqueue_attrs()
3880  *
3881  * Apply @attrs to an unbound workqueue @wq.  Unless disabled, on NUMA
3882  * machines, this function maps a separate pwq to each NUMA node with
3883  * possibles CPUs in @attrs->cpumask so that work items are affine to the
3884  * NUMA node it was issued on.  Older pwqs are released as in-flight work
3885  * items finish.  Note that a work item which repeatedly requeues itself
3886  * back-to-back will stay on its current pwq.
3887  *
3888  * Performs GFP_KERNEL allocations.  Returns 0 on success and -errno on
3889  * failure.
3890  */
3891 int apply_workqueue_attrs(struct workqueue_struct *wq,
3892                           const struct workqueue_attrs *attrs)
3893 {
3894         struct workqueue_attrs *new_attrs, *tmp_attrs;
3895         struct pool_workqueue **pwq_tbl, *dfl_pwq;
3896         int node, ret;
3897
3898         /* only unbound workqueues can change attributes */
3899         if (WARN_ON(!(wq->flags & WQ_UNBOUND)))
3900                 return -EINVAL;
3901
3902         /* creating multiple pwqs breaks ordering guarantee */
3903         if (WARN_ON((wq->flags & __WQ_ORDERED) && !list_empty(&wq->pwqs)))
3904                 return -EINVAL;
3905
3906         pwq_tbl = kzalloc(wq_numa_tbl_len * sizeof(pwq_tbl[0]), GFP_KERNEL);
3907         new_attrs = alloc_workqueue_attrs(GFP_KERNEL);
3908         tmp_attrs = alloc_workqueue_attrs(GFP_KERNEL);
3909         if (!pwq_tbl || !new_attrs || !tmp_attrs)
3910                 goto enomem;
3911
3912         /* make a copy of @attrs and sanitize it */
3913         copy_workqueue_attrs(new_attrs, attrs);
3914         cpumask_and(new_attrs->cpumask, new_attrs->cpumask, cpu_possible_mask);
3915
3916         /*
3917          * We may create multiple pwqs with differing cpumasks.  Make a
3918          * copy of @new_attrs which will be modified and used to obtain
3919          * pools.
3920          */
3921         copy_workqueue_attrs(tmp_attrs, new_attrs);
3922
3923         /*
3924          * CPUs should stay stable across pwq creations and installations.
3925          * Pin CPUs, determine the target cpumask for each node and create
3926          * pwqs accordingly.
3927          */
3928         get_online_cpus();
3929
3930         mutex_lock(&wq_pool_mutex);
3931
3932         /*
3933          * If something goes wrong during CPU up/down, we'll fall back to
3934          * the default pwq covering whole @attrs->cpumask.  Always create
3935          * it even if we don't use it immediately.
3936          */
3937         dfl_pwq = alloc_unbound_pwq(wq, new_attrs);
3938         if (!dfl_pwq)
3939                 goto enomem_pwq;
3940
3941         for_each_node(node) {
3942                 if (wq_calc_node_cpumask(attrs, node, -1, tmp_attrs->cpumask)) {
3943                         pwq_tbl[node] = alloc_unbound_pwq(wq, tmp_attrs);
3944                         if (!pwq_tbl[node])
3945                                 goto enomem_pwq;
3946                 } else {
3947                         dfl_pwq->refcnt++;
3948                         pwq_tbl[node] = dfl_pwq;
3949                 }
3950         }
3951
3952         mutex_unlock(&wq_pool_mutex);
3953
3954         /* all pwqs have been created successfully, let's install'em */
3955         mutex_lock(&wq->mutex);
3956
3957         copy_workqueue_attrs(wq->unbound_attrs, new_attrs);
3958
3959         /* save the previous pwq and install the new one */
3960         for_each_node(node)
3961                 pwq_tbl[node] = numa_pwq_tbl_install(wq, node, pwq_tbl[node]);
3962
3963         /* @dfl_pwq might not have been used, ensure it's linked */
3964         link_pwq(dfl_pwq);
3965         swap(wq->dfl_pwq, dfl_pwq);
3966
3967         mutex_unlock(&wq->mutex);
3968
3969         /* put the old pwqs */
3970         for_each_node(node)
3971                 put_pwq_unlocked(pwq_tbl[node]);
3972         put_pwq_unlocked(dfl_pwq);
3973
3974         put_online_cpus();
3975         ret = 0;
3976         /* fall through */
3977 out_free:
3978         free_workqueue_attrs(tmp_attrs);
3979         free_workqueue_attrs(new_attrs);
3980         kfree(pwq_tbl);
3981         return ret;
3982
3983 enomem_pwq:
3984         free_unbound_pwq(dfl_pwq);
3985         for_each_node(node)
3986                 if (pwq_tbl && pwq_tbl[node] != dfl_pwq)
3987                         free_unbound_pwq(pwq_tbl[node]);
3988         mutex_unlock(&wq_pool_mutex);
3989         put_online_cpus();
3990 enomem:
3991         ret = -ENOMEM;
3992         goto out_free;
3993 }
3994
3995 /**
3996  * wq_update_unbound_numa - update NUMA affinity of a wq for CPU hot[un]plug
3997  * @wq: the target workqueue
3998  * @cpu: the CPU coming up or going down
3999  * @online: whether @cpu is coming up or going down
4000  *
4001  * This function is to be called from %CPU_DOWN_PREPARE, %CPU_ONLINE and
4002  * %CPU_DOWN_FAILED.  @cpu is being hot[un]plugged, update NUMA affinity of
4003  * @wq accordingly.
4004  *
4005  * If NUMA affinity can't be adjusted due to memory allocation failure, it
4006  * falls back to @wq->dfl_pwq which may not be optimal but is always
4007  * correct.
4008  *
4009  * Note that when the last allowed CPU of a NUMA node goes offline for a
4010  * workqueue with a cpumask spanning multiple nodes, the workers which were
4011  * already executing the work items for the workqueue will lose their CPU
4012  * affinity and may execute on any CPU.  This is similar to how per-cpu
4013  * workqueues behave on CPU_DOWN.  If a workqueue user wants strict
4014  * affinity, it's the user's responsibility to flush the work item from
4015  * CPU_DOWN_PREPARE.
4016  */
4017 static void wq_update_unbound_numa(struct workqueue_struct *wq, int cpu,
4018                                    bool online)
4019 {
4020         int node = cpu_to_node(cpu);
4021         int cpu_off = online ? -1 : cpu;
4022         struct pool_workqueue *old_pwq = NULL, *pwq;
4023         struct workqueue_attrs *target_attrs;
4024         cpumask_t *cpumask;
4025
4026         lockdep_assert_held(&wq_pool_mutex);
4027
4028         if (!wq_numa_enabled || !(wq->flags & WQ_UNBOUND))
4029                 return;
4030
4031         /*
4032          * We don't wanna alloc/free wq_attrs for each wq for each CPU.
4033          * Let's use a preallocated one.  The following buf is protected by
4034          * CPU hotplug exclusion.
4035          */
4036         target_attrs = wq_update_unbound_numa_attrs_buf;
4037         cpumask = target_attrs->cpumask;
4038
4039         mutex_lock(&wq->mutex);
4040         if (wq->unbound_attrs->no_numa)
4041                 goto out_unlock;
4042
4043         copy_workqueue_attrs(target_attrs, wq->unbound_attrs);
4044         pwq = unbound_pwq_by_node(wq, node);
4045
4046         /*
4047          * Let's determine what needs to be done.  If the target cpumask is
4048          * different from wq's, we need to compare it to @pwq's and create
4049          * a new one if they don't match.  If the target cpumask equals
4050          * wq's, the default pwq should be used.  If @pwq is already the
4051          * default one, nothing to do; otherwise, install the default one.
4052          */
4053         if (wq_calc_node_cpumask(wq->unbound_attrs, node, cpu_off, cpumask)) {
4054                 if (cpumask_equal(cpumask, pwq->pool->attrs->cpumask))
4055                         goto out_unlock;
4056         } else {
4057                 if (pwq == wq->dfl_pwq)
4058                         goto out_unlock;
4059                 else
4060                         goto use_dfl_pwq;
4061         }
4062
4063         mutex_unlock(&wq->mutex);
4064
4065         /* create a new pwq */
4066         pwq = alloc_unbound_pwq(wq, target_attrs);
4067         if (!pwq) {
4068                 pr_warning("workqueue: allocation failed while updating NUMA affinity of \"%s\"\n",
4069                            wq->name);
4070                 mutex_lock(&wq->mutex);
4071                 goto use_dfl_pwq;
4072         }
4073
4074         /*
4075          * Install the new pwq.  As this function is called only from CPU
4076          * hotplug callbacks and applying a new attrs is wrapped with
4077          * get/put_online_cpus(), @wq->unbound_attrs couldn't have changed
4078          * inbetween.
4079          */
4080         mutex_lock(&wq->mutex);
4081         old_pwq = numa_pwq_tbl_install(wq, node, pwq);
4082         goto out_unlock;
4083
4084 use_dfl_pwq:
4085         spin_lock_irq(&wq->dfl_pwq->pool->lock);
4086         get_pwq(wq->dfl_pwq);
4087         spin_unlock_irq(&wq->dfl_pwq->pool->lock);
4088         old_pwq = numa_pwq_tbl_install(wq, node, wq->dfl_pwq);
4089 out_unlock:
4090         mutex_unlock(&wq->mutex);
4091         put_pwq_unlocked(old_pwq);
4092 }
4093
4094 static int alloc_and_link_pwqs(struct workqueue_struct *wq)
4095 {
4096         bool highpri = wq->flags & WQ_HIGHPRI;
4097         int cpu, ret;
4098
4099         if (!(wq->flags & WQ_UNBOUND)) {
4100                 wq->cpu_pwqs = alloc_percpu(struct pool_workqueue);
4101                 if (!wq->cpu_pwqs)
4102                         return -ENOMEM;
4103
4104                 for_each_possible_cpu(cpu) {
4105                         struct pool_workqueue *pwq =
4106                                 per_cpu_ptr(wq->cpu_pwqs, cpu);
4107                         struct worker_pool *cpu_pools =
4108                                 per_cpu(cpu_worker_pools, cpu);
4109
4110                         init_pwq(pwq, wq, &cpu_pools[highpri]);
4111
4112                         mutex_lock(&wq->mutex);
4113                         link_pwq(pwq);
4114                         mutex_unlock(&wq->mutex);
4115                 }
4116                 return 0;
4117         } else if (wq->flags & __WQ_ORDERED) {
4118                 ret = apply_workqueue_attrs(wq, ordered_wq_attrs[highpri]);
4119                 /* there should only be single pwq for ordering guarantee */
4120                 WARN(!ret && (wq->pwqs.next != &wq->dfl_pwq->pwqs_node ||
4121                               wq->pwqs.prev != &wq->dfl_pwq->pwqs_node),
4122                      "ordering guarantee broken for workqueue %s\n", wq->name);
4123                 return ret;
4124         } else {
4125                 return apply_workqueue_attrs(wq, unbound_std_wq_attrs[highpri]);
4126         }
4127 }
4128
4129 static int wq_clamp_max_active(int max_active, unsigned int flags,
4130                                const char *name)
4131 {
4132         int lim = flags & WQ_UNBOUND ? WQ_UNBOUND_MAX_ACTIVE : WQ_MAX_ACTIVE;
4133
4134         if (max_active < 1 || max_active > lim)
4135                 pr_warn("workqueue: max_active %d requested for %s is out of range, clamping between %d and %d\n",
4136                         max_active, name, 1, lim);
4137
4138         return clamp_val(max_active, 1, lim);
4139 }
4140
4141 struct workqueue_struct *__alloc_workqueue_key(const char *fmt,
4142                                                unsigned int flags,
4143                                                int max_active,
4144                                                struct lock_class_key *key,
4145                                                const char *lock_name, ...)
4146 {
4147         size_t tbl_size = 0;
4148         va_list args;
4149         struct workqueue_struct *wq;
4150         struct pool_workqueue *pwq;
4151
4152         /* see the comment above the definition of WQ_POWER_EFFICIENT */
4153         if ((flags & WQ_POWER_EFFICIENT) && wq_power_efficient)
4154                 flags |= WQ_UNBOUND;
4155
4156         /* allocate wq and format name */
4157         if (flags & WQ_UNBOUND)
4158                 tbl_size = wq_numa_tbl_len * sizeof(wq->numa_pwq_tbl[0]);
4159
4160         wq = kzalloc(sizeof(*wq) + tbl_size, GFP_KERNEL);
4161         if (!wq)
4162                 return NULL;
4163
4164         if (flags & WQ_UNBOUND) {
4165                 wq->unbound_attrs = alloc_workqueue_attrs(GFP_KERNEL);
4166                 if (!wq->unbound_attrs)
4167                         goto err_free_wq;
4168         }
4169
4170         va_start(args, lock_name);
4171         vsnprintf(wq->name, sizeof(wq->name), fmt, args);
4172         va_end(args);
4173
4174         max_active = max_active ?: WQ_DFL_ACTIVE;
4175         max_active = wq_clamp_max_active(max_active, flags, wq->name);
4176
4177         /* init wq */
4178         wq->flags = flags;
4179         wq->saved_max_active = max_active;
4180         mutex_init(&wq->mutex);
4181         atomic_set(&wq->nr_pwqs_to_flush, 0);
4182         INIT_LIST_HEAD(&wq->pwqs);
4183         INIT_LIST_HEAD(&wq->flusher_queue);
4184         INIT_LIST_HEAD(&wq->flusher_overflow);
4185         INIT_LIST_HEAD(&wq->maydays);
4186
4187         lockdep_init_map(&wq->lockdep_map, lock_name, key, 0);
4188         INIT_LIST_HEAD(&wq->list);
4189
4190         if (alloc_and_link_pwqs(wq) < 0)
4191                 goto err_free_wq;
4192
4193         /*
4194          * Workqueues which may be used during memory reclaim should
4195          * have a rescuer to guarantee forward progress.
4196          */
4197         if (flags & WQ_MEM_RECLAIM) {
4198                 struct worker *rescuer;
4199
4200                 rescuer = alloc_worker();
4201                 if (!rescuer)
4202                         goto err_destroy;
4203
4204                 rescuer->rescue_wq = wq;
4205                 rescuer->task = kthread_create(rescuer_thread, rescuer, "%s",
4206                                                wq->name);
4207                 if (IS_ERR(rescuer->task)) {
4208                         kfree(rescuer);
4209                         goto err_destroy;
4210                 }
4211
4212                 wq->rescuer = rescuer;
4213                 rescuer->task->flags |= PF_NO_SETAFFINITY;
4214                 wake_up_process(rescuer->task);
4215         }
4216
4217         if ((wq->flags & WQ_SYSFS) && workqueue_sysfs_register(wq))
4218                 goto err_destroy;
4219
4220         /*
4221          * wq_pool_mutex protects global freeze state and workqueues list.
4222          * Grab it, adjust max_active and add the new @wq to workqueues
4223          * list.
4224          */
4225         mutex_lock(&wq_pool_mutex);
4226
4227         mutex_lock(&wq->mutex);
4228         for_each_pwq(pwq, wq)
4229                 pwq_adjust_max_active(pwq);
4230         mutex_unlock(&wq->mutex);
4231
4232         list_add(&wq->list, &workqueues);
4233
4234         mutex_unlock(&wq_pool_mutex);
4235
4236         return wq;
4237
4238 err_free_wq:
4239         free_workqueue_attrs(wq->unbound_attrs);
4240         kfree(wq);
4241         return NULL;
4242 err_destroy:
4243         destroy_workqueue(wq);
4244         return NULL;
4245 }
4246 EXPORT_SYMBOL_GPL(__alloc_workqueue_key);
4247
4248 /**
4249  * destroy_workqueue - safely terminate a workqueue
4250  * @wq: target workqueue
4251  *
4252  * Safely destroy a workqueue. All work currently pending will be done first.
4253  */
4254 void destroy_workqueue(struct workqueue_struct *wq)
4255 {
4256         struct pool_workqueue *pwq;
4257         int node;
4258
4259         /* drain it before proceeding with destruction */
4260         drain_workqueue(wq);
4261
4262         /* sanity checks */
4263         mutex_lock(&wq->mutex);
4264         for_each_pwq(pwq, wq) {
4265                 int i;
4266
4267                 for (i = 0; i < WORK_NR_COLORS; i++) {
4268                         if (WARN_ON(pwq->nr_in_flight[i])) {
4269                                 mutex_unlock(&wq->mutex);
4270                                 return;
4271                         }
4272                 }
4273
4274                 if (WARN_ON((pwq != wq->dfl_pwq) && (pwq->refcnt > 1)) ||
4275                     WARN_ON(pwq->nr_active) ||
4276                     WARN_ON(!list_empty(&pwq->delayed_works))) {
4277                         mutex_unlock(&wq->mutex);
4278                         return;
4279                 }
4280         }
4281         mutex_unlock(&wq->mutex);
4282
4283         /*
4284          * wq list is used to freeze wq, remove from list after
4285          * flushing is complete in case freeze races us.
4286          */
4287         mutex_lock(&wq_pool_mutex);
4288         list_del_init(&wq->list);
4289         mutex_unlock(&wq_pool_mutex);
4290
4291         workqueue_sysfs_unregister(wq);
4292
4293         if (wq->rescuer) {
4294                 kthread_stop(wq->rescuer->task);
4295                 kfree(wq->rescuer);
4296                 wq->rescuer = NULL;
4297         }
4298
4299         if (!(wq->flags & WQ_UNBOUND)) {
4300                 /*
4301                  * The base ref is never dropped on per-cpu pwqs.  Directly
4302                  * free the pwqs and wq.
4303                  */
4304                 free_percpu(wq->cpu_pwqs);
4305                 kfree(wq);
4306         } else {
4307                 /*
4308                  * We're the sole accessor of @wq at this point.  Directly
4309                  * access numa_pwq_tbl[] and dfl_pwq to put the base refs.
4310                  * @wq will be freed when the last pwq is released.
4311                  */
4312                 for_each_node(node) {
4313                         pwq = rcu_access_pointer(wq->numa_pwq_tbl[node]);
4314                         RCU_INIT_POINTER(wq->numa_pwq_tbl[node], NULL);
4315                         put_pwq_unlocked(pwq);
4316                 }
4317
4318                 /*
4319                  * Put dfl_pwq.  @wq may be freed any time after dfl_pwq is
4320                  * put.  Don't access it afterwards.
4321                  */
4322                 pwq = wq->dfl_pwq;
4323                 wq->dfl_pwq = NULL;
4324                 put_pwq_unlocked(pwq);
4325         }
4326 }
4327 EXPORT_SYMBOL_GPL(destroy_workqueue);
4328
4329 /**
4330  * workqueue_set_max_active - adjust max_active of a workqueue
4331  * @wq: target workqueue
4332  * @max_active: new max_active value.
4333  *
4334  * Set max_active of @wq to @max_active.
4335  *
4336  * CONTEXT:
4337  * Don't call from IRQ context.
4338  */
4339 void workqueue_set_max_active(struct workqueue_struct *wq, int max_active)
4340 {
4341         struct pool_workqueue *pwq;
4342
4343         /* disallow meddling with max_active for ordered workqueues */
4344         if (WARN_ON(wq->flags & __WQ_ORDERED))
4345                 return;
4346
4347         max_active = wq_clamp_max_active(max_active, wq->flags, wq->name);
4348
4349         mutex_lock(&wq->mutex);
4350
4351         wq->saved_max_active = max_active;
4352
4353         for_each_pwq(pwq, wq)
4354                 pwq_adjust_max_active(pwq);
4355
4356         mutex_unlock(&wq->mutex);
4357 }
4358 EXPORT_SYMBOL_GPL(workqueue_set_max_active);
4359
4360 /**
4361  * current_is_workqueue_rescuer - is %current workqueue rescuer?
4362  *
4363  * Determine whether %current is a workqueue rescuer.  Can be used from
4364  * work functions to determine whether it's being run off the rescuer task.
4365  */
4366 bool current_is_workqueue_rescuer(void)
4367 {
4368         struct worker *worker = current_wq_worker();
4369
4370         return worker && worker->rescue_wq;
4371 }
4372
4373 /**
4374  * workqueue_congested - test whether a workqueue is congested
4375  * @cpu: CPU in question
4376  * @wq: target workqueue
4377  *
4378  * Test whether @wq's cpu workqueue for @cpu is congested.  There is
4379  * no synchronization around this function and the test result is
4380  * unreliable and only useful as advisory hints or for debugging.
4381  *
4382  * If @cpu is WORK_CPU_UNBOUND, the test is performed on the local CPU.
4383  * Note that both per-cpu and unbound workqueues may be associated with
4384  * multiple pool_workqueues which have separate congested states.  A
4385  * workqueue being congested on one CPU doesn't mean the workqueue is also
4386  * contested on other CPUs / NUMA nodes.
4387  *
4388  * RETURNS:
4389  * %true if congested, %false otherwise.
4390  */
4391 bool workqueue_congested(int cpu, struct workqueue_struct *wq)
4392 {
4393         struct pool_workqueue *pwq;
4394         bool ret;
4395
4396         rcu_read_lock_sched();
4397
4398         if (cpu == WORK_CPU_UNBOUND)
4399                 cpu = smp_processor_id();
4400
4401         if (!(wq->flags & WQ_UNBOUND))
4402                 pwq = per_cpu_ptr(wq->cpu_pwqs, cpu);
4403         else
4404                 pwq = unbound_pwq_by_node(wq, cpu_to_node(cpu));
4405
4406         ret = !list_empty(&pwq->delayed_works);
4407         rcu_read_unlock_sched();
4408
4409         return ret;
4410 }
4411 EXPORT_SYMBOL_GPL(workqueue_congested);
4412
4413 /**
4414  * work_busy - test whether a work is currently pending or running
4415  * @work: the work to be tested
4416  *
4417  * Test whether @work is currently pending or running.  There is no
4418  * synchronization around this function and the test result is
4419  * unreliable and only useful as advisory hints or for debugging.
4420  *
4421  * RETURNS:
4422  * OR'd bitmask of WORK_BUSY_* bits.
4423  */
4424 unsigned int work_busy(struct work_struct *work)
4425 {
4426         struct worker_pool *pool;
4427         unsigned long flags;
4428         unsigned int ret = 0;
4429
4430         if (work_pending(work))
4431                 ret |= WORK_BUSY_PENDING;
4432
4433         local_irq_save(flags);
4434         pool = get_work_pool(work);
4435         if (pool) {
4436                 spin_lock(&pool->lock);
4437                 if (find_worker_executing_work(pool, work))
4438                         ret |= WORK_BUSY_RUNNING;
4439                 spin_unlock(&pool->lock);
4440         }
4441         local_irq_restore(flags);
4442
4443         return ret;
4444 }
4445 EXPORT_SYMBOL_GPL(work_busy);
4446
4447 /**
4448  * set_worker_desc - set description for the current work item
4449  * @fmt: printf-style format string
4450  * @...: arguments for the format string
4451  *
4452  * This function can be called by a running work function to describe what
4453  * the work item is about.  If the worker task gets dumped, this
4454  * information will be printed out together to help debugging.  The
4455  * description can be at most WORKER_DESC_LEN including the trailing '\0'.
4456  */
4457 void set_worker_desc(const char *fmt, ...)
4458 {
4459         struct worker *worker = current_wq_worker();
4460         va_list args;
4461
4462         if (worker) {
4463                 va_start(args, fmt);
4464                 vsnprintf(worker->desc, sizeof(worker->desc), fmt, args);
4465                 va_end(args);
4466                 worker->desc_valid = true;
4467         }
4468 }
4469
4470 /**
4471  * print_worker_info - print out worker information and description
4472  * @log_lvl: the log level to use when printing
4473  * @task: target task
4474  *
4475  * If @task is a worker and currently executing a work item, print out the
4476  * name of the workqueue being serviced and worker description set with
4477  * set_worker_desc() by the currently executing work item.
4478  *
4479  * This function can be safely called on any task as long as the
4480  * task_struct itself is accessible.  While safe, this function isn't
4481  * synchronized and may print out mixups or garbages of limited length.
4482  */
4483 void print_worker_info(const char *log_lvl, struct task_struct *task)
4484 {
4485         work_func_t *fn = NULL;
4486         char name[WQ_NAME_LEN] = { };
4487         char desc[WORKER_DESC_LEN] = { };
4488         struct pool_workqueue *pwq = NULL;
4489         struct workqueue_struct *wq = NULL;
4490         bool desc_valid = false;
4491         struct worker *worker;
4492
4493         if (!(task->flags & PF_WQ_WORKER))
4494                 return;
4495
4496         /*
4497          * This function is called without any synchronization and @task
4498          * could be in any state.  Be careful with dereferences.
4499          */
4500         worker = probe_kthread_data(task);
4501
4502         /*
4503          * Carefully copy the associated workqueue's workfn and name.  Keep
4504          * the original last '\0' in case the original contains garbage.
4505          */
4506         probe_kernel_read(&fn, &worker->current_func, sizeof(fn));
4507         probe_kernel_read(&pwq, &worker->current_pwq, sizeof(pwq));
4508         probe_kernel_read(&wq, &pwq->wq, sizeof(wq));
4509         probe_kernel_read(name, wq->name, sizeof(name) - 1);
4510
4511         /* copy worker description */
4512         probe_kernel_read(&desc_valid, &worker->desc_valid, sizeof(desc_valid));
4513         if (desc_valid)
4514                 probe_kernel_read(desc, worker->desc, sizeof(desc) - 1);
4515
4516         if (fn || name[0] || desc[0]) {
4517                 printk("%sWorkqueue: %s %pf", log_lvl, name, fn);
4518                 if (desc[0])
4519                         pr_cont(" (%s)", desc);
4520                 pr_cont("\n");
4521         }
4522 }
4523
4524 /*
4525  * CPU hotplug.
4526  *
4527  * There are two challenges in supporting CPU hotplug.  Firstly, there
4528  * are a lot of assumptions on strong associations among work, pwq and
4529  * pool which make migrating pending and scheduled works very
4530  * difficult to implement without impacting hot paths.  Secondly,
4531  * worker pools serve mix of short, long and very long running works making
4532  * blocked draining impractical.
4533  *
4534  * This is solved by allowing the pools to be disassociated from the CPU
4535  * running as an unbound one and allowing it to be reattached later if the
4536  * cpu comes back online.
4537  */
4538
4539 static void wq_unbind_fn(struct work_struct *work)
4540 {
4541         int cpu = smp_processor_id();
4542         struct worker_pool *pool;
4543         struct worker *worker;
4544         int wi;
4545
4546         for_each_cpu_worker_pool(pool, cpu) {
4547                 WARN_ON_ONCE(cpu != smp_processor_id());
4548
4549                 mutex_lock(&pool->manager_mutex);
4550                 spin_lock_irq(&pool->lock);
4551
4552                 /*
4553                  * We've blocked all manager operations.  Make all workers
4554                  * unbound and set DISASSOCIATED.  Before this, all workers
4555                  * except for the ones which are still executing works from
4556                  * before the last CPU down must be on the cpu.  After
4557                  * this, they may become diasporas.
4558                  */
4559                 for_each_pool_worker(worker, wi, pool)
4560                         worker->flags |= WORKER_UNBOUND;
4561
4562                 pool->flags |= POOL_DISASSOCIATED;
4563
4564                 spin_unlock_irq(&pool->lock);
4565                 mutex_unlock(&pool->manager_mutex);
4566
4567                 /*
4568                  * Call schedule() so that we cross rq->lock and thus can
4569                  * guarantee sched callbacks see the %WORKER_UNBOUND flag.
4570                  * This is necessary as scheduler callbacks may be invoked
4571                  * from other cpus.
4572                  */
4573                 schedule();
4574
4575                 /*
4576                  * Sched callbacks are disabled now.  Zap nr_running.
4577                  * After this, nr_running stays zero and need_more_worker()
4578                  * and keep_working() are always true as long as the
4579                  * worklist is not empty.  This pool now behaves as an
4580                  * unbound (in terms of concurrency management) pool which
4581                  * are served by workers tied to the pool.
4582                  */
4583                 atomic_set(&pool->nr_running, 0);
4584
4585                 /*
4586                  * With concurrency management just turned off, a busy
4587                  * worker blocking could lead to lengthy stalls.  Kick off
4588                  * unbound chain execution of currently pending work items.
4589                  */
4590                 spin_lock_irq(&pool->lock);
4591                 wake_up_worker(pool);
4592                 spin_unlock_irq(&pool->lock);
4593         }
4594 }
4595
4596 /**
4597  * rebind_workers - rebind all workers of a pool to the associated CPU
4598  * @pool: pool of interest
4599  *
4600  * @pool->cpu is coming online.  Rebind all workers to the CPU.
4601  */
4602 static void rebind_workers(struct worker_pool *pool)
4603 {
4604         struct worker *worker;
4605         int wi;
4606
4607         lockdep_assert_held(&pool->manager_mutex);
4608
4609         /*
4610          * Restore CPU affinity of all workers.  As all idle workers should
4611          * be on the run-queue of the associated CPU before any local
4612          * wake-ups for concurrency management happen, restore CPU affinty
4613          * of all workers first and then clear UNBOUND.  As we're called
4614          * from CPU_ONLINE, the following shouldn't fail.
4615          */
4616         for_each_pool_worker(worker, wi, pool)
4617                 WARN_ON_ONCE(set_cpus_allowed_ptr(worker->task,
4618                                                   pool->attrs->cpumask) < 0);
4619
4620         spin_lock_irq(&pool->lock);
4621
4622         for_each_pool_worker(worker, wi, pool) {
4623                 unsigned int worker_flags = worker->flags;
4624
4625                 /*
4626                  * A bound idle worker should actually be on the runqueue
4627                  * of the associated CPU for local wake-ups targeting it to
4628                  * work.  Kick all idle workers so that they migrate to the
4629                  * associated CPU.  Doing this in the same loop as
4630                  * replacing UNBOUND with REBOUND is safe as no worker will
4631                  * be bound before @pool->lock is released.
4632                  */
4633                 if (worker_flags & WORKER_IDLE)
4634                         wake_up_process(worker->task);
4635
4636                 /*
4637                  * We want to clear UNBOUND but can't directly call
4638                  * worker_clr_flags() or adjust nr_running.  Atomically
4639                  * replace UNBOUND with another NOT_RUNNING flag REBOUND.
4640                  * @worker will clear REBOUND using worker_clr_flags() when
4641                  * it initiates the next execution cycle thus restoring
4642                  * concurrency management.  Note that when or whether
4643                  * @worker clears REBOUND doesn't affect correctness.
4644                  *
4645                  * ACCESS_ONCE() is necessary because @worker->flags may be
4646                  * tested without holding any lock in
4647                  * wq_worker_waking_up().  Without it, NOT_RUNNING test may
4648                  * fail incorrectly leading to premature concurrency
4649                  * management operations.
4650                  */
4651                 WARN_ON_ONCE(!(worker_flags & WORKER_UNBOUND));
4652                 worker_flags |= WORKER_REBOUND;
4653                 worker_flags &= ~WORKER_UNBOUND;
4654                 ACCESS_ONCE(worker->flags) = worker_flags;
4655         }
4656
4657         spin_unlock_irq(&pool->lock);
4658 }
4659
4660 /**
4661  * restore_unbound_workers_cpumask - restore cpumask of unbound workers
4662  * @pool: unbound pool of interest
4663  * @cpu: the CPU which is coming up
4664  *
4665  * An unbound pool may end up with a cpumask which doesn't have any online
4666  * CPUs.  When a worker of such pool get scheduled, the scheduler resets
4667  * its cpus_allowed.  If @cpu is in @pool's cpumask which didn't have any
4668  * online CPU before, cpus_allowed of all its workers should be restored.
4669  */
4670 static void restore_unbound_workers_cpumask(struct worker_pool *pool, int cpu)
4671 {
4672         static cpumask_t cpumask;
4673         struct worker *worker;
4674         int wi;
4675
4676         lockdep_assert_held(&pool->manager_mutex);
4677
4678         /* is @cpu allowed for @pool? */
4679         if (!cpumask_test_cpu(cpu, pool->attrs->cpumask))
4680                 return;
4681
4682         /* is @cpu the only online CPU? */
4683         cpumask_and(&cpumask, pool->attrs->cpumask, cpu_online_mask);
4684         if (cpumask_weight(&cpumask) != 1)
4685                 return;
4686
4687         /* as we're called from CPU_ONLINE, the following shouldn't fail */
4688         for_each_pool_worker(worker, wi, pool)
4689                 WARN_ON_ONCE(set_cpus_allowed_ptr(worker->task,
4690                                                   pool->attrs->cpumask) < 0);
4691 }
4692
4693 /*
4694  * Workqueues should be brought up before normal priority CPU notifiers.
4695  * This will be registered high priority CPU notifier.
4696  */
4697 static int __cpuinit workqueue_cpu_up_callback(struct notifier_block *nfb,
4698                                                unsigned long action,
4699                                                void *hcpu)
4700 {
4701         int cpu = (unsigned long)hcpu;
4702         struct worker_pool *pool;
4703         struct workqueue_struct *wq;
4704         int pi;
4705
4706         switch (action & ~CPU_TASKS_FROZEN) {
4707         case CPU_UP_PREPARE:
4708                 for_each_cpu_worker_pool(pool, cpu) {
4709                         if (pool->nr_workers)
4710                                 continue;
4711                         if (create_and_start_worker(pool) < 0)
4712                                 return NOTIFY_BAD;
4713                 }
4714                 break;
4715
4716         case CPU_DOWN_FAILED:
4717         case CPU_ONLINE:
4718                 mutex_lock(&wq_pool_mutex);
4719
4720                 for_each_pool(pool, pi) {
4721                         mutex_lock(&pool->manager_mutex);
4722
4723                         if (pool->cpu == cpu) {
4724                                 spin_lock_irq(&pool->lock);
4725                                 pool->flags &= ~POOL_DISASSOCIATED;
4726                                 spin_unlock_irq(&pool->lock);
4727
4728                                 rebind_workers(pool);
4729                         } else if (pool->cpu < 0) {
4730                                 restore_unbound_workers_cpumask(pool, cpu);
4731                         }
4732
4733                         mutex_unlock(&pool->manager_mutex);
4734                 }
4735
4736                 /* update NUMA affinity of unbound workqueues */
4737                 list_for_each_entry(wq, &workqueues, list)
4738                         wq_update_unbound_numa(wq, cpu, true);
4739
4740                 mutex_unlock(&wq_pool_mutex);
4741                 break;
4742         }
4743         return NOTIFY_OK;
4744 }
4745
4746 /*
4747  * Workqueues should be brought down after normal priority CPU notifiers.
4748  * This will be registered as low priority CPU notifier.
4749  */
4750 static int __cpuinit workqueue_cpu_down_callback(struct notifier_block *nfb,
4751                                                  unsigned long action,
4752                                                  void *hcpu)
4753 {
4754         int cpu = (unsigned long)hcpu;
4755         struct work_struct unbind_work;
4756         struct workqueue_struct *wq;
4757
4758         switch (action & ~CPU_TASKS_FROZEN) {
4759         case CPU_DOWN_PREPARE:
4760                 /* unbinding per-cpu workers should happen on the local CPU */
4761                 INIT_WORK_ONSTACK(&unbind_work, wq_unbind_fn);
4762                 queue_work_on(cpu, system_highpri_wq, &unbind_work);
4763
4764                 /* update NUMA affinity of unbound workqueues */
4765                 mutex_lock(&wq_pool_mutex);
4766                 list_for_each_entry(wq, &workqueues, list)
4767                         wq_update_unbound_numa(wq, cpu, false);
4768                 mutex_unlock(&wq_pool_mutex);
4769
4770                 /* wait for per-cpu unbinding to finish */
4771                 flush_work(&unbind_work);
4772                 break;
4773         }
4774         return NOTIFY_OK;
4775 }
4776
4777 #ifdef CONFIG_SMP
4778
4779 struct work_for_cpu {
4780         struct work_struct work;
4781         long (*fn)(void *);
4782         void *arg;
4783         long ret;
4784 };
4785
4786 static void work_for_cpu_fn(struct work_struct *work)
4787 {
4788         struct work_for_cpu *wfc = container_of(work, struct work_for_cpu, work);
4789
4790         wfc->ret = wfc->fn(wfc->arg);
4791 }
4792
4793 /**
4794  * work_on_cpu - run a function in user context on a particular cpu
4795  * @cpu: the cpu to run on
4796  * @fn: the function to run
4797  * @arg: the function arg
4798  *
4799  * This will return the value @fn returns.
4800  * It is up to the caller to ensure that the cpu doesn't go offline.
4801  * The caller must not hold any locks which would prevent @fn from completing.
4802  */
4803 long work_on_cpu(int cpu, long (*fn)(void *), void *arg)
4804 {
4805         struct work_for_cpu wfc = { .fn = fn, .arg = arg };
4806
4807         INIT_WORK_ONSTACK(&wfc.work, work_for_cpu_fn);
4808         schedule_work_on(cpu, &wfc.work);
4809         flush_work(&wfc.work);
4810         return wfc.ret;
4811 }
4812 EXPORT_SYMBOL_GPL(work_on_cpu);
4813 #endif /* CONFIG_SMP */
4814
4815 #ifdef CONFIG_FREEZER
4816
4817 /**
4818  * freeze_workqueues_begin - begin freezing workqueues
4819  *
4820  * Start freezing workqueues.  After this function returns, all freezable
4821  * workqueues will queue new works to their delayed_works list instead of
4822  * pool->worklist.
4823  *
4824  * CONTEXT:
4825  * Grabs and releases wq_pool_mutex, wq->mutex and pool->lock's.
4826  */
4827 void freeze_workqueues_begin(void)
4828 {
4829         struct worker_pool *pool;
4830         struct workqueue_struct *wq;
4831         struct pool_workqueue *pwq;
4832         int pi;
4833
4834         mutex_lock(&wq_pool_mutex);
4835
4836         WARN_ON_ONCE(workqueue_freezing);
4837         workqueue_freezing = true;
4838
4839         /* set FREEZING */
4840         for_each_pool(pool, pi) {
4841                 spin_lock_irq(&pool->lock);
4842                 WARN_ON_ONCE(pool->flags & POOL_FREEZING);
4843                 pool->flags |= POOL_FREEZING;
4844                 spin_unlock_irq(&pool->lock);
4845         }
4846
4847         list_for_each_entry(wq, &workqueues, list) {
4848                 mutex_lock(&wq->mutex);
4849                 for_each_pwq(pwq, wq)
4850                         pwq_adjust_max_active(pwq);
4851                 mutex_unlock(&wq->mutex);
4852         }
4853
4854         mutex_unlock(&wq_pool_mutex);
4855 }
4856
4857 /**
4858  * freeze_workqueues_busy - are freezable workqueues still busy?
4859  *
4860  * Check whether freezing is complete.  This function must be called
4861  * between freeze_workqueues_begin() and thaw_workqueues().
4862  *
4863  * CONTEXT:
4864  * Grabs and releases wq_pool_mutex.
4865  *
4866  * RETURNS:
4867  * %true if some freezable workqueues are still busy.  %false if freezing
4868  * is complete.
4869  */
4870 bool freeze_workqueues_busy(void)
4871 {
4872         bool busy = false;
4873         struct workqueue_struct *wq;
4874         struct pool_workqueue *pwq;
4875
4876         mutex_lock(&wq_pool_mutex);
4877
4878         WARN_ON_ONCE(!workqueue_freezing);
4879
4880         list_for_each_entry(wq, &workqueues, list) {
4881                 if (!(wq->flags & WQ_FREEZABLE))
4882                         continue;
4883                 /*
4884                  * nr_active is monotonically decreasing.  It's safe
4885                  * to peek without lock.
4886                  */
4887                 rcu_read_lock_sched();
4888                 for_each_pwq(pwq, wq) {
4889                         WARN_ON_ONCE(pwq->nr_active < 0);
4890                         if (pwq->nr_active) {
4891                                 busy = true;
4892                                 rcu_read_unlock_sched();
4893                                 goto out_unlock;
4894                         }
4895                 }
4896                 rcu_read_unlock_sched();
4897         }
4898 out_unlock:
4899         mutex_unlock(&wq_pool_mutex);
4900         return busy;
4901 }
4902
4903 /**
4904  * thaw_workqueues - thaw workqueues
4905  *
4906  * Thaw workqueues.  Normal queueing is restored and all collected
4907  * frozen works are transferred to their respective pool worklists.
4908  *
4909  * CONTEXT:
4910  * Grabs and releases wq_pool_mutex, wq->mutex and pool->lock's.
4911  */
4912 void thaw_workqueues(void)
4913 {
4914         struct workqueue_struct *wq;
4915         struct pool_workqueue *pwq;
4916         struct worker_pool *pool;
4917         int pi;
4918
4919         mutex_lock(&wq_pool_mutex);
4920
4921         if (!workqueue_freezing)
4922                 goto out_unlock;
4923
4924         /* clear FREEZING */
4925         for_each_pool(pool, pi) {
4926                 spin_lock_irq(&pool->lock);
4927                 WARN_ON_ONCE(!(pool->flags & POOL_FREEZING));
4928                 pool->flags &= ~POOL_FREEZING;
4929                 spin_unlock_irq(&pool->lock);
4930         }
4931
4932         /* restore max_active and repopulate worklist */
4933         list_for_each_entry(wq, &workqueues, list) {
4934                 mutex_lock(&wq->mutex);
4935                 for_each_pwq(pwq, wq)
4936                         pwq_adjust_max_active(pwq);
4937                 mutex_unlock(&wq->mutex);
4938         }
4939
4940         workqueue_freezing = false;
4941 out_unlock:
4942         mutex_unlock(&wq_pool_mutex);
4943 }
4944 #endif /* CONFIG_FREEZER */
4945
4946 static void __init wq_numa_init(void)
4947 {
4948         cpumask_var_t *tbl;
4949         int node, cpu;
4950
4951         /* determine NUMA pwq table len - highest node id + 1 */
4952         for_each_node(node)
4953                 wq_numa_tbl_len = max(wq_numa_tbl_len, node + 1);
4954
4955         if (num_possible_nodes() <= 1)
4956                 return;
4957
4958         if (wq_disable_numa) {
4959                 pr_info("workqueue: NUMA affinity support disabled\n");
4960                 return;
4961         }
4962
4963         wq_update_unbound_numa_attrs_buf = alloc_workqueue_attrs(GFP_KERNEL);
4964         BUG_ON(!wq_update_unbound_numa_attrs_buf);
4965
4966         /*
4967          * We want masks of possible CPUs of each node which isn't readily
4968          * available.  Build one from cpu_to_node() which should have been
4969          * fully initialized by now.
4970          */
4971         tbl = kzalloc(wq_numa_tbl_len * sizeof(tbl[0]), GFP_KERNEL);
4972         BUG_ON(!tbl);
4973
4974         for_each_node(node)
4975                 BUG_ON(!zalloc_cpumask_var_node(&tbl[node], GFP_KERNEL,
4976                                 node_online(node) ? node : NUMA_NO_NODE));
4977
4978         for_each_possible_cpu(cpu) {
4979                 node = cpu_to_node(cpu);
4980                 if (WARN_ON(node == NUMA_NO_NODE)) {
4981                         pr_warn("workqueue: NUMA node mapping not available for cpu%d, disabling NUMA support\n", cpu);
4982                         /* happens iff arch is bonkers, let's just proceed */
4983                         return;
4984                 }
4985                 cpumask_set_cpu(cpu, tbl[node]);
4986         }
4987
4988         wq_numa_possible_cpumask = tbl;
4989         wq_numa_enabled = true;
4990 }
4991
4992 static int __init init_workqueues(void)
4993 {
4994         int std_nice[NR_STD_WORKER_POOLS] = { 0, HIGHPRI_NICE_LEVEL };
4995         int i, cpu;
4996
4997         /* make sure we have enough bits for OFFQ pool ID */
4998         BUILD_BUG_ON((1LU << (BITS_PER_LONG - WORK_OFFQ_POOL_SHIFT)) <
4999                      WORK_CPU_END * NR_STD_WORKER_POOLS);
5000
5001         WARN_ON(__alignof__(struct pool_workqueue) < __alignof__(long long));
5002
5003         pwq_cache = KMEM_CACHE(pool_workqueue, SLAB_PANIC);
5004
5005         cpu_notifier(workqueue_cpu_up_callback, CPU_PRI_WORKQUEUE_UP);
5006         hotcpu_notifier(workqueue_cpu_down_callback, CPU_PRI_WORKQUEUE_DOWN);
5007
5008         wq_numa_init();
5009
5010         /* initialize CPU pools */
5011         for_each_possible_cpu(cpu) {
5012                 struct worker_pool *pool;
5013
5014                 i = 0;
5015                 for_each_cpu_worker_pool(pool, cpu) {
5016                         BUG_ON(init_worker_pool(pool));
5017                         pool->cpu = cpu;
5018                         cpumask_copy(pool->attrs->cpumask, cpumask_of(cpu));
5019                         pool->attrs->nice = std_nice[i++];
5020                         pool->node = cpu_to_node(cpu);
5021
5022                         /* alloc pool ID */
5023                         mutex_lock(&wq_pool_mutex);
5024                         BUG_ON(worker_pool_assign_id(pool));
5025                         mutex_unlock(&wq_pool_mutex);
5026                 }
5027         }
5028
5029         /* create the initial worker */
5030         for_each_online_cpu(cpu) {
5031                 struct worker_pool *pool;
5032
5033                 for_each_cpu_worker_pool(pool, cpu) {
5034                         pool->flags &= ~POOL_DISASSOCIATED;
5035                         BUG_ON(create_and_start_worker(pool) < 0);
5036                 }
5037         }
5038
5039         /* create default unbound and ordered wq attrs */
5040         for (i = 0; i < NR_STD_WORKER_POOLS; i++) {
5041                 struct workqueue_attrs *attrs;
5042
5043                 BUG_ON(!(attrs = alloc_workqueue_attrs(GFP_KERNEL)));
5044                 attrs->nice = std_nice[i];
5045                 unbound_std_wq_attrs[i] = attrs;
5046
5047                 /*
5048                  * An ordered wq should have only one pwq as ordering is
5049                  * guaranteed by max_active which is enforced by pwqs.
5050                  * Turn off NUMA so that dfl_pwq is used for all nodes.
5051                  */
5052                 BUG_ON(!(attrs = alloc_workqueue_attrs(GFP_KERNEL)));
5053                 attrs->nice = std_nice[i];
5054                 attrs->no_numa = true;
5055                 ordered_wq_attrs[i] = attrs;
5056         }
5057
5058         system_wq = alloc_workqueue("events", 0, 0);
5059         system_highpri_wq = alloc_workqueue("events_highpri", WQ_HIGHPRI, 0);
5060         system_long_wq = alloc_workqueue("events_long", 0, 0);
5061         system_unbound_wq = alloc_workqueue("events_unbound", WQ_UNBOUND,
5062                                             WQ_UNBOUND_MAX_ACTIVE);
5063         system_freezable_wq = alloc_workqueue("events_freezable",
5064                                               WQ_FREEZABLE, 0);
5065         system_power_efficient_wq = alloc_workqueue("events_power_efficient",
5066                                               WQ_POWER_EFFICIENT, 0);
5067         system_freezable_power_efficient_wq = alloc_workqueue("events_freezable_power_efficient",
5068                                               WQ_FREEZABLE | WQ_POWER_EFFICIENT,
5069                                               0);
5070         BUG_ON(!system_wq || !system_highpri_wq || !system_long_wq ||
5071                !system_unbound_wq || !system_freezable_wq ||
5072                !system_power_efficient_wq ||
5073                !system_freezable_power_efficient_wq);
5074         return 0;
5075 }
5076 early_initcall(init_workqueues);