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