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