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