1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27#include <linux/export.h>
28#include <linux/kernel.h>
29#include <linux/sched.h>
30#include <linux/init.h>
31#include <linux/signal.h>
32#include <linux/completion.h>
33#include <linux/workqueue.h>
34#include <linux/slab.h>
35#include <linux/cpu.h>
36#include <linux/notifier.h>
37#include <linux/kthread.h>
38#include <linux/hardirq.h>
39#include <linux/mempolicy.h>
40#include <linux/freezer.h>
41#include <linux/kallsyms.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
52#include "workqueue_internal.h"
53
54enum {
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71 POOL_DISASSOCIATED = 1 << 2,
72
73
74 WORKER_DIE = 1 << 1,
75 WORKER_IDLE = 1 << 2,
76 WORKER_PREP = 1 << 3,
77 WORKER_CPU_INTENSIVE = 1 << 6,
78 WORKER_UNBOUND = 1 << 7,
79 WORKER_REBOUND = 1 << 8,
80
81 WORKER_NOT_RUNNING = WORKER_PREP | WORKER_CPU_INTENSIVE |
82 WORKER_UNBOUND | WORKER_REBOUND,
83
84 NR_STD_WORKER_POOLS = 2,
85
86 UNBOUND_POOL_HASH_ORDER = 6,
87 BUSY_WORKER_HASH_ORDER = 6,
88
89 MAX_IDLE_WORKERS_RATIO = 4,
90 IDLE_WORKER_TIMEOUT = 300 * HZ,
91
92 MAYDAY_INITIAL_TIMEOUT = HZ / 100 >= 2 ? HZ / 100 : 2,
93
94
95 MAYDAY_INTERVAL = HZ / 10,
96 CREATE_COOLDOWN = HZ,
97
98
99
100
101
102 RESCUER_NICE_LEVEL = MIN_NICE,
103 HIGHPRI_NICE_LEVEL = MIN_NICE,
104
105 WQ_NAME_LEN = 24,
106};
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144struct worker_pool {
145 spinlock_t lock;
146 int cpu;
147 int node;
148 int id;
149 unsigned int flags;
150
151 unsigned long watchdog_ts;
152
153 struct list_head worklist;
154 int nr_workers;
155
156
157 int nr_idle;
158
159 struct list_head idle_list;
160 struct timer_list idle_timer;
161 struct timer_list mayday_timer;
162
163
164 DECLARE_HASHTABLE(busy_hash, BUSY_WORKER_HASH_ORDER);
165
166
167
168 struct mutex manager_arb;
169 struct worker *manager;
170 struct mutex attach_mutex;
171 struct list_head workers;
172 struct completion *detach_completion;
173
174 struct ida worker_ida;
175
176 struct workqueue_attrs *attrs;
177 struct hlist_node hash_node;
178 int refcnt;
179
180
181
182
183
184
185 atomic_t nr_running ____cacheline_aligned_in_smp;
186
187
188
189
190
191 struct rcu_head rcu;
192} ____cacheline_aligned_in_smp;
193
194
195
196
197
198
199
200struct pool_workqueue {
201 struct worker_pool *pool;
202 struct workqueue_struct *wq;
203 int work_color;
204 int flush_color;
205 int refcnt;
206 int nr_in_flight[WORK_NR_COLORS];
207
208 int nr_active;
209 int max_active;
210 struct list_head delayed_works;
211 struct list_head pwqs_node;
212 struct list_head mayday_node;
213
214
215
216
217
218
219
220 struct work_struct unbound_release_work;
221 struct rcu_head rcu;
222} __aligned(1 << WORK_STRUCT_FLAG_BITS);
223
224
225
226
227struct wq_flusher {
228 struct list_head list;
229 int flush_color;
230 struct completion done;
231};
232
233struct wq_device;
234
235
236
237
238
239struct workqueue_struct {
240 struct list_head pwqs;
241 struct list_head list;
242
243 struct mutex mutex;
244 int work_color;
245 int flush_color;
246 atomic_t nr_pwqs_to_flush;
247 struct wq_flusher *first_flusher;
248 struct list_head flusher_queue;
249 struct list_head flusher_overflow;
250
251 struct list_head maydays;
252 struct worker *rescuer;
253
254 int nr_drainers;
255 int saved_max_active;
256
257 struct workqueue_attrs *unbound_attrs;
258 struct pool_workqueue *dfl_pwq;
259
260#ifdef CONFIG_SYSFS
261 struct wq_device *wq_dev;
262#endif
263#ifdef CONFIG_LOCKDEP
264 struct lockdep_map lockdep_map;
265#endif
266 char name[WQ_NAME_LEN];
267
268
269
270
271
272
273 struct rcu_head rcu;
274
275
276 unsigned int flags ____cacheline_aligned;
277 struct pool_workqueue __percpu *cpu_pwqs;
278 struct pool_workqueue __rcu *numa_pwq_tbl[];
279};
280
281static struct kmem_cache *pwq_cache;
282
283static cpumask_var_t *wq_numa_possible_cpumask;
284
285
286static bool wq_disable_numa;
287module_param_named(disable_numa, wq_disable_numa, bool, 0444);
288
289
290static bool wq_power_efficient = IS_ENABLED(CONFIG_WQ_POWER_EFFICIENT_DEFAULT);
291module_param_named(power_efficient, wq_power_efficient, bool, 0444);
292
293static bool wq_numa_enabled;
294
295
296static struct workqueue_attrs *wq_update_unbound_numa_attrs_buf;
297
298static DEFINE_MUTEX(wq_pool_mutex);
299static DEFINE_SPINLOCK(wq_mayday_lock);
300
301static LIST_HEAD(workqueues);
302static bool workqueue_freezing;
303
304
305static cpumask_var_t wq_unbound_cpumask;
306
307
308static DEFINE_PER_CPU(int, wq_rr_cpu_last);
309
310
311
312
313
314
315#ifdef CONFIG_DEBUG_WQ_FORCE_RR_CPU
316static bool wq_debug_force_rr_cpu = true;
317#else
318static bool wq_debug_force_rr_cpu = false;
319#endif
320module_param_named(debug_force_rr_cpu, wq_debug_force_rr_cpu, bool, 0644);
321
322
323static DEFINE_PER_CPU_SHARED_ALIGNED(struct worker_pool [NR_STD_WORKER_POOLS], cpu_worker_pools);
324
325static DEFINE_IDR(worker_pool_idr);
326
327
328static DEFINE_HASHTABLE(unbound_pool_hash, UNBOUND_POOL_HASH_ORDER);
329
330
331static struct workqueue_attrs *unbound_std_wq_attrs[NR_STD_WORKER_POOLS];
332
333
334static struct workqueue_attrs *ordered_wq_attrs[NR_STD_WORKER_POOLS];
335
336struct workqueue_struct *system_wq __read_mostly;
337EXPORT_SYMBOL(system_wq);
338struct workqueue_struct *system_highpri_wq __read_mostly;
339EXPORT_SYMBOL_GPL(system_highpri_wq);
340struct workqueue_struct *system_long_wq __read_mostly;
341EXPORT_SYMBOL_GPL(system_long_wq);
342struct workqueue_struct *system_unbound_wq __read_mostly;
343EXPORT_SYMBOL_GPL(system_unbound_wq);
344struct workqueue_struct *system_freezable_wq __read_mostly;
345EXPORT_SYMBOL_GPL(system_freezable_wq);
346struct workqueue_struct *system_power_efficient_wq __read_mostly;
347EXPORT_SYMBOL_GPL(system_power_efficient_wq);
348struct workqueue_struct *system_freezable_power_efficient_wq __read_mostly;
349EXPORT_SYMBOL_GPL(system_freezable_power_efficient_wq);
350
351static int worker_thread(void *__worker);
352static void workqueue_sysfs_unregister(struct workqueue_struct *wq);
353
354#define CREATE_TRACE_POINTS
355#include <trace/events/workqueue.h>
356
357#define assert_rcu_or_pool_mutex() \
358 RCU_LOCKDEP_WARN(!rcu_read_lock_sched_held() && \
359 !lockdep_is_held(&wq_pool_mutex), \
360 "sched RCU or wq_pool_mutex should be held")
361
362#define assert_rcu_or_wq_mutex(wq) \
363 RCU_LOCKDEP_WARN(!rcu_read_lock_sched_held() && \
364 !lockdep_is_held(&wq->mutex), \
365 "sched RCU or wq->mutex should be held")
366
367#define assert_rcu_or_wq_mutex_or_pool_mutex(wq) \
368 RCU_LOCKDEP_WARN(!rcu_read_lock_sched_held() && \
369 !lockdep_is_held(&wq->mutex) && \
370 !lockdep_is_held(&wq_pool_mutex), \
371 "sched RCU, wq->mutex or wq_pool_mutex should be held")
372
373#define for_each_cpu_worker_pool(pool, cpu) \
374 for ((pool) = &per_cpu(cpu_worker_pools, cpu)[0]; \
375 (pool) < &per_cpu(cpu_worker_pools, cpu)[NR_STD_WORKER_POOLS]; \
376 (pool)++)
377
378
379
380
381
382
383
384
385
386
387
388
389
390#define for_each_pool(pool, pi) \
391 idr_for_each_entry(&worker_pool_idr, pool, pi) \
392 if (({ assert_rcu_or_pool_mutex(); false; })) { } \
393 else
394
395
396
397
398
399
400
401
402
403
404
405#define for_each_pool_worker(worker, pool) \
406 list_for_each_entry((worker), &(pool)->workers, node) \
407 if (({ lockdep_assert_held(&pool->attach_mutex); false; })) { } \
408 else
409
410
411
412
413
414
415
416
417
418
419
420
421
422#define for_each_pwq(pwq, wq) \
423 list_for_each_entry_rcu((pwq), &(wq)->pwqs, pwqs_node) \
424 if (({ assert_rcu_or_wq_mutex(wq); false; })) { } \
425 else
426
427#ifdef CONFIG_DEBUG_OBJECTS_WORK
428
429static struct debug_obj_descr work_debug_descr;
430
431static void *work_debug_hint(void *addr)
432{
433 return ((struct work_struct *) addr)->func;
434}
435
436
437
438
439
440static int work_fixup_init(void *addr, enum debug_obj_state state)
441{
442 struct work_struct *work = addr;
443
444 switch (state) {
445 case ODEBUG_STATE_ACTIVE:
446 cancel_work_sync(work);
447 debug_object_init(work, &work_debug_descr);
448 return 1;
449 default:
450 return 0;
451 }
452}
453
454
455
456
457
458
459static int work_fixup_activate(void *addr, enum debug_obj_state state)
460{
461 struct work_struct *work = addr;
462
463 switch (state) {
464
465 case ODEBUG_STATE_NOTAVAILABLE:
466
467
468
469
470
471 if (test_bit(WORK_STRUCT_STATIC_BIT, work_data_bits(work))) {
472 debug_object_init(work, &work_debug_descr);
473 debug_object_activate(work, &work_debug_descr);
474 return 0;
475 }
476 WARN_ON_ONCE(1);
477 return 0;
478
479 case ODEBUG_STATE_ACTIVE:
480 WARN_ON(1);
481
482 default:
483 return 0;
484 }
485}
486
487
488
489
490
491static int work_fixup_free(void *addr, enum debug_obj_state state)
492{
493 struct work_struct *work = addr;
494
495 switch (state) {
496 case ODEBUG_STATE_ACTIVE:
497 cancel_work_sync(work);
498 debug_object_free(work, &work_debug_descr);
499 return 1;
500 default:
501 return 0;
502 }
503}
504
505static struct debug_obj_descr work_debug_descr = {
506 .name = "work_struct",
507 .debug_hint = work_debug_hint,
508 .fixup_init = work_fixup_init,
509 .fixup_activate = work_fixup_activate,
510 .fixup_free = work_fixup_free,
511};
512
513static inline void debug_work_activate(struct work_struct *work)
514{
515 debug_object_activate(work, &work_debug_descr);
516}
517
518static inline void debug_work_deactivate(struct work_struct *work)
519{
520 debug_object_deactivate(work, &work_debug_descr);
521}
522
523void __init_work(struct work_struct *work, int onstack)
524{
525 if (onstack)
526 debug_object_init_on_stack(work, &work_debug_descr);
527 else
528 debug_object_init(work, &work_debug_descr);
529}
530EXPORT_SYMBOL_GPL(__init_work);
531
532void destroy_work_on_stack(struct work_struct *work)
533{
534 debug_object_free(work, &work_debug_descr);
535}
536EXPORT_SYMBOL_GPL(destroy_work_on_stack);
537
538void destroy_delayed_work_on_stack(struct delayed_work *work)
539{
540 destroy_timer_on_stack(&work->timer);
541 debug_object_free(&work->work, &work_debug_descr);
542}
543EXPORT_SYMBOL_GPL(destroy_delayed_work_on_stack);
544
545#else
546static inline void debug_work_activate(struct work_struct *work) { }
547static inline void debug_work_deactivate(struct work_struct *work) { }
548#endif
549
550
551
552
553
554
555
556
557static int worker_pool_assign_id(struct worker_pool *pool)
558{
559 int ret;
560
561 lockdep_assert_held(&wq_pool_mutex);
562
563 ret = idr_alloc(&worker_pool_idr, pool, 0, WORK_OFFQ_POOL_NONE,
564 GFP_KERNEL);
565 if (ret >= 0) {
566 pool->id = ret;
567 return 0;
568 }
569 return ret;
570}
571
572
573
574
575
576
577
578
579
580
581
582
583
584static struct pool_workqueue *unbound_pwq_by_node(struct workqueue_struct *wq,
585 int node)
586{
587 assert_rcu_or_wq_mutex_or_pool_mutex(wq);
588
589
590
591
592
593
594
595 if (unlikely(node == NUMA_NO_NODE))
596 return wq->dfl_pwq;
597
598 return rcu_dereference_raw(wq->numa_pwq_tbl[node]);
599}
600
601static unsigned int work_color_to_flags(int color)
602{
603 return color << WORK_STRUCT_COLOR_SHIFT;
604}
605
606static int get_work_color(struct work_struct *work)
607{
608 return (*work_data_bits(work) >> WORK_STRUCT_COLOR_SHIFT) &
609 ((1 << WORK_STRUCT_COLOR_BITS) - 1);
610}
611
612static int work_next_color(int color)
613{
614 return (color + 1) % WORK_NR_COLORS;
615}
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637static inline void set_work_data(struct work_struct *work, unsigned long data,
638 unsigned long flags)
639{
640 WARN_ON_ONCE(!work_pending(work));
641 atomic_long_set(&work->data, data | flags | work_static(work));
642}
643
644static void set_work_pwq(struct work_struct *work, struct pool_workqueue *pwq,
645 unsigned long extra_flags)
646{
647 set_work_data(work, (unsigned long)pwq,
648 WORK_STRUCT_PENDING | WORK_STRUCT_PWQ | extra_flags);
649}
650
651static void set_work_pool_and_keep_pending(struct work_struct *work,
652 int pool_id)
653{
654 set_work_data(work, (unsigned long)pool_id << WORK_OFFQ_POOL_SHIFT,
655 WORK_STRUCT_PENDING);
656}
657
658static void set_work_pool_and_clear_pending(struct work_struct *work,
659 int pool_id)
660{
661
662
663
664
665
666
667 smp_wmb();
668 set_work_data(work, (unsigned long)pool_id << WORK_OFFQ_POOL_SHIFT, 0);
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697 smp_mb();
698}
699
700static void clear_work_data(struct work_struct *work)
701{
702 smp_wmb();
703 set_work_data(work, WORK_STRUCT_NO_POOL, 0);
704}
705
706static struct pool_workqueue *get_work_pwq(struct work_struct *work)
707{
708 unsigned long data = atomic_long_read(&work->data);
709
710 if (data & WORK_STRUCT_PWQ)
711 return (void *)(data & WORK_STRUCT_WQ_DATA_MASK);
712 else
713 return NULL;
714}
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731static struct worker_pool *get_work_pool(struct work_struct *work)
732{
733 unsigned long data = atomic_long_read(&work->data);
734 int pool_id;
735
736 assert_rcu_or_pool_mutex();
737
738 if (data & WORK_STRUCT_PWQ)
739 return ((struct pool_workqueue *)
740 (data & WORK_STRUCT_WQ_DATA_MASK))->pool;
741
742 pool_id = data >> WORK_OFFQ_POOL_SHIFT;
743 if (pool_id == WORK_OFFQ_POOL_NONE)
744 return NULL;
745
746 return idr_find(&worker_pool_idr, pool_id);
747}
748
749
750
751
752
753
754
755
756static int get_work_pool_id(struct work_struct *work)
757{
758 unsigned long data = atomic_long_read(&work->data);
759
760 if (data & WORK_STRUCT_PWQ)
761 return ((struct pool_workqueue *)
762 (data & WORK_STRUCT_WQ_DATA_MASK))->pool->id;
763
764 return data >> WORK_OFFQ_POOL_SHIFT;
765}
766
767static void mark_work_canceling(struct work_struct *work)
768{
769 unsigned long pool_id = get_work_pool_id(work);
770
771 pool_id <<= WORK_OFFQ_POOL_SHIFT;
772 set_work_data(work, pool_id | WORK_OFFQ_CANCELING, WORK_STRUCT_PENDING);
773}
774
775static bool work_is_canceling(struct work_struct *work)
776{
777 unsigned long data = atomic_long_read(&work->data);
778
779 return !(data & WORK_STRUCT_PWQ) && (data & WORK_OFFQ_CANCELING);
780}
781
782
783
784
785
786
787
788static bool __need_more_worker(struct worker_pool *pool)
789{
790 return !atomic_read(&pool->nr_running);
791}
792
793
794
795
796
797
798
799
800
801static bool need_more_worker(struct worker_pool *pool)
802{
803 return !list_empty(&pool->worklist) && __need_more_worker(pool);
804}
805
806
807static bool may_start_working(struct worker_pool *pool)
808{
809 return pool->nr_idle;
810}
811
812
813static bool keep_working(struct worker_pool *pool)
814{
815 return !list_empty(&pool->worklist) &&
816 atomic_read(&pool->nr_running) <= 1;
817}
818
819
820static bool need_to_create_worker(struct worker_pool *pool)
821{
822 return need_more_worker(pool) && !may_start_working(pool);
823}
824
825
826static bool too_many_workers(struct worker_pool *pool)
827{
828 bool managing = mutex_is_locked(&pool->manager_arb);
829 int nr_idle = pool->nr_idle + managing;
830 int nr_busy = pool->nr_workers - nr_idle;
831
832 return nr_idle > 2 && (nr_idle - 2) * MAX_IDLE_WORKERS_RATIO >= nr_busy;
833}
834
835
836
837
838
839
840static struct worker *first_idle_worker(struct worker_pool *pool)
841{
842 if (unlikely(list_empty(&pool->idle_list)))
843 return NULL;
844
845 return list_first_entry(&pool->idle_list, struct worker, entry);
846}
847
848
849
850
851
852
853
854
855
856
857static void wake_up_worker(struct worker_pool *pool)
858{
859 struct worker *worker = first_idle_worker(pool);
860
861 if (likely(worker))
862 wake_up_process(worker->task);
863}
864
865
866
867
868
869
870
871
872
873
874
875
876void wq_worker_waking_up(struct task_struct *task, int cpu)
877{
878 struct worker *worker = kthread_data(task);
879
880 if (!(worker->flags & WORKER_NOT_RUNNING)) {
881 WARN_ON_ONCE(worker->pool->cpu != cpu);
882 atomic_inc(&worker->pool->nr_running);
883 }
884}
885
886
887
888
889
890
891
892
893
894
895
896
897
898
899
900struct task_struct *wq_worker_sleeping(struct task_struct *task)
901{
902 struct worker *worker = kthread_data(task), *to_wakeup = NULL;
903 struct worker_pool *pool;
904
905
906
907
908
909
910 if (worker->flags & WORKER_NOT_RUNNING)
911 return NULL;
912
913 pool = worker->pool;
914
915
916 if (WARN_ON_ONCE(pool->cpu != raw_smp_processor_id()))
917 return NULL;
918
919
920
921
922
923
924
925
926
927
928
929
930 if (atomic_dec_and_test(&pool->nr_running) &&
931 !list_empty(&pool->worklist))
932 to_wakeup = first_idle_worker(pool);
933 return to_wakeup ? to_wakeup->task : NULL;
934}
935
936
937
938
939
940
941
942
943
944
945
946static inline void worker_set_flags(struct worker *worker, unsigned int flags)
947{
948 struct worker_pool *pool = worker->pool;
949
950 WARN_ON_ONCE(worker->task != current);
951
952
953 if ((flags & WORKER_NOT_RUNNING) &&
954 !(worker->flags & WORKER_NOT_RUNNING)) {
955 atomic_dec(&pool->nr_running);
956 }
957
958 worker->flags |= flags;
959}
960
961
962
963
964
965
966
967
968
969
970
971static inline void worker_clr_flags(struct worker *worker, unsigned int flags)
972{
973 struct worker_pool *pool = worker->pool;
974 unsigned int oflags = worker->flags;
975
976 WARN_ON_ONCE(worker->task != current);
977
978 worker->flags &= ~flags;
979
980
981
982
983
984
985 if ((flags & WORKER_NOT_RUNNING) && (oflags & WORKER_NOT_RUNNING))
986 if (!(worker->flags & WORKER_NOT_RUNNING))
987 atomic_inc(&pool->nr_running);
988}
989
990
991
992
993
994
995
996
997
998
999
1000
1001
1002
1003
1004
1005
1006
1007
1008
1009
1010
1011
1012
1013
1014
1015
1016
1017
1018
1019
1020
1021
1022
1023static struct worker *find_worker_executing_work(struct worker_pool *pool,
1024 struct work_struct *work)
1025{
1026 struct worker *worker;
1027
1028 hash_for_each_possible(pool->busy_hash, worker, hentry,
1029 (unsigned long)work)
1030 if (worker->current_work == work &&
1031 worker->current_func == work->func)
1032 return worker;
1033
1034 return NULL;
1035}
1036
1037
1038
1039
1040
1041
1042
1043
1044
1045
1046
1047
1048
1049
1050
1051
1052
1053
1054static void move_linked_works(struct work_struct *work, struct list_head *head,
1055 struct work_struct **nextp)
1056{
1057 struct work_struct *n;
1058
1059
1060
1061
1062
1063 list_for_each_entry_safe_from(work, n, NULL, entry) {
1064 list_move_tail(&work->entry, head);
1065 if (!(*work_data_bits(work) & WORK_STRUCT_LINKED))
1066 break;
1067 }
1068
1069
1070
1071
1072
1073
1074 if (nextp)
1075 *nextp = n;
1076}
1077
1078
1079
1080
1081
1082
1083
1084
1085static void get_pwq(struct pool_workqueue *pwq)
1086{
1087 lockdep_assert_held(&pwq->pool->lock);
1088 WARN_ON_ONCE(pwq->refcnt <= 0);
1089 pwq->refcnt++;
1090}
1091
1092
1093
1094
1095
1096
1097
1098
1099static void put_pwq(struct pool_workqueue *pwq)
1100{
1101 lockdep_assert_held(&pwq->pool->lock);
1102 if (likely(--pwq->refcnt))
1103 return;
1104 if (WARN_ON_ONCE(!(pwq->wq->flags & WQ_UNBOUND)))
1105 return;
1106
1107
1108
1109
1110
1111
1112
1113
1114 schedule_work(&pwq->unbound_release_work);
1115}
1116
1117
1118
1119
1120
1121
1122
1123static void put_pwq_unlocked(struct pool_workqueue *pwq)
1124{
1125 if (pwq) {
1126
1127
1128
1129
1130 spin_lock_irq(&pwq->pool->lock);
1131 put_pwq(pwq);
1132 spin_unlock_irq(&pwq->pool->lock);
1133 }
1134}
1135
1136static void pwq_activate_delayed_work(struct work_struct *work)
1137{
1138 struct pool_workqueue *pwq = get_work_pwq(work);
1139
1140 trace_workqueue_activate_work(work);
1141 if (list_empty(&pwq->pool->worklist))
1142 pwq->pool->watchdog_ts = jiffies;
1143 move_linked_works(work, &pwq->pool->worklist, NULL);
1144 __clear_bit(WORK_STRUCT_DELAYED_BIT, work_data_bits(work));
1145 pwq->nr_active++;
1146}
1147
1148static void pwq_activate_first_delayed(struct pool_workqueue *pwq)
1149{
1150 struct work_struct *work = list_first_entry(&pwq->delayed_works,
1151 struct work_struct, entry);
1152
1153 pwq_activate_delayed_work(work);
1154}
1155
1156
1157
1158
1159
1160
1161
1162
1163
1164
1165
1166
1167static void pwq_dec_nr_in_flight(struct pool_workqueue *pwq, int color)
1168{
1169
1170 if (color == WORK_NO_COLOR)
1171 goto out_put;
1172
1173 pwq->nr_in_flight[color]--;
1174
1175 pwq->nr_active--;
1176 if (!list_empty(&pwq->delayed_works)) {
1177
1178 if (pwq->nr_active < pwq->max_active)
1179 pwq_activate_first_delayed(pwq);
1180 }
1181
1182
1183 if (likely(pwq->flush_color != color))
1184 goto out_put;
1185
1186
1187 if (pwq->nr_in_flight[color])
1188 goto out_put;
1189
1190
1191 pwq->flush_color = -1;
1192
1193
1194
1195
1196
1197 if (atomic_dec_and_test(&pwq->wq->nr_pwqs_to_flush))
1198 complete(&pwq->wq->first_flusher->done);
1199out_put:
1200 put_pwq(pwq);
1201}
1202
1203
1204
1205
1206
1207
1208
1209
1210
1211
1212
1213
1214
1215
1216
1217
1218
1219
1220
1221
1222
1223
1224
1225
1226
1227
1228
1229
1230static int try_to_grab_pending(struct work_struct *work, bool is_dwork,
1231 unsigned long *flags)
1232{
1233 struct worker_pool *pool;
1234 struct pool_workqueue *pwq;
1235
1236 local_irq_save(*flags);
1237
1238
1239 if (is_dwork) {
1240 struct delayed_work *dwork = to_delayed_work(work);
1241
1242
1243
1244
1245
1246
1247 if (likely(del_timer(&dwork->timer)))
1248 return 1;
1249 }
1250
1251
1252 if (!test_and_set_bit(WORK_STRUCT_PENDING_BIT, work_data_bits(work)))
1253 return 0;
1254
1255
1256
1257
1258
1259 pool = get_work_pool(work);
1260 if (!pool)
1261 goto fail;
1262
1263 spin_lock(&pool->lock);
1264
1265
1266
1267
1268
1269
1270
1271
1272 pwq = get_work_pwq(work);
1273 if (pwq && pwq->pool == pool) {
1274 debug_work_deactivate(work);
1275
1276
1277
1278
1279
1280
1281
1282
1283 if (*work_data_bits(work) & WORK_STRUCT_DELAYED)
1284 pwq_activate_delayed_work(work);
1285
1286 list_del_init(&work->entry);
1287 pwq_dec_nr_in_flight(pwq, get_work_color(work));
1288
1289
1290 set_work_pool_and_keep_pending(work, pool->id);
1291
1292 spin_unlock(&pool->lock);
1293 return 1;
1294 }
1295 spin_unlock(&pool->lock);
1296fail:
1297 local_irq_restore(*flags);
1298 if (work_is_canceling(work))
1299 return -ENOENT;
1300 cpu_relax();
1301 return -EAGAIN;
1302}
1303
1304
1305
1306
1307
1308
1309
1310
1311
1312
1313
1314
1315
1316
1317static void insert_work(struct pool_workqueue *pwq, struct work_struct *work,
1318 struct list_head *head, unsigned int extra_flags)
1319{
1320 struct worker_pool *pool = pwq->pool;
1321
1322
1323 set_work_pwq(work, pwq, extra_flags);
1324 list_add_tail(&work->entry, head);
1325 get_pwq(pwq);
1326
1327
1328
1329
1330
1331
1332 smp_mb();
1333
1334 if (__need_more_worker(pool))
1335 wake_up_worker(pool);
1336}
1337
1338
1339
1340
1341
1342static bool is_chained_work(struct workqueue_struct *wq)
1343{
1344 struct worker *worker;
1345
1346 worker = current_wq_worker();
1347
1348
1349
1350
1351 return worker && worker->current_pwq->wq == wq;
1352}
1353
1354
1355
1356
1357
1358
1359static int wq_select_unbound_cpu(int cpu)
1360{
1361 static bool printed_dbg_warning;
1362 int new_cpu;
1363
1364 if (likely(!wq_debug_force_rr_cpu)) {
1365 if (cpumask_test_cpu(cpu, wq_unbound_cpumask))
1366 return cpu;
1367 } else if (!printed_dbg_warning) {
1368 pr_warn("workqueue: round-robin CPU selection forced, expect performance impact\n");
1369 printed_dbg_warning = true;
1370 }
1371
1372 if (cpumask_empty(wq_unbound_cpumask))
1373 return cpu;
1374
1375 new_cpu = __this_cpu_read(wq_rr_cpu_last);
1376 new_cpu = cpumask_next_and(new_cpu, wq_unbound_cpumask, cpu_online_mask);
1377 if (unlikely(new_cpu >= nr_cpu_ids)) {
1378 new_cpu = cpumask_first_and(wq_unbound_cpumask, cpu_online_mask);
1379 if (unlikely(new_cpu >= nr_cpu_ids))
1380 return cpu;
1381 }
1382 __this_cpu_write(wq_rr_cpu_last, new_cpu);
1383
1384 return new_cpu;
1385}
1386
1387static void __queue_work(int cpu, struct workqueue_struct *wq,
1388 struct work_struct *work)
1389{
1390 struct pool_workqueue *pwq;
1391 struct worker_pool *last_pool;
1392 struct list_head *worklist;
1393 unsigned int work_flags;
1394 unsigned int req_cpu = cpu;
1395
1396
1397
1398
1399
1400
1401
1402 WARN_ON_ONCE(!irqs_disabled());
1403
1404 debug_work_activate(work);
1405
1406
1407 if (unlikely(wq->flags & __WQ_DRAINING) &&
1408 WARN_ON_ONCE(!is_chained_work(wq)))
1409 return;
1410retry:
1411 if (req_cpu == WORK_CPU_UNBOUND)
1412 cpu = wq_select_unbound_cpu(raw_smp_processor_id());
1413
1414
1415 if (!(wq->flags & WQ_UNBOUND))
1416 pwq = per_cpu_ptr(wq->cpu_pwqs, cpu);
1417 else
1418 pwq = unbound_pwq_by_node(wq, cpu_to_node(cpu));
1419
1420
1421
1422
1423
1424
1425 last_pool = get_work_pool(work);
1426 if (last_pool && last_pool != pwq->pool) {
1427 struct worker *worker;
1428
1429 spin_lock(&last_pool->lock);
1430
1431 worker = find_worker_executing_work(last_pool, work);
1432
1433 if (worker && worker->current_pwq->wq == wq) {
1434 pwq = worker->current_pwq;
1435 } else {
1436
1437 spin_unlock(&last_pool->lock);
1438 spin_lock(&pwq->pool->lock);
1439 }
1440 } else {
1441 spin_lock(&pwq->pool->lock);
1442 }
1443
1444
1445
1446
1447
1448
1449
1450
1451
1452 if (unlikely(!pwq->refcnt)) {
1453 if (wq->flags & WQ_UNBOUND) {
1454 spin_unlock(&pwq->pool->lock);
1455 cpu_relax();
1456 goto retry;
1457 }
1458
1459 WARN_ONCE(true, "workqueue: per-cpu pwq for %s on cpu%d has 0 refcnt",
1460 wq->name, cpu);
1461 }
1462
1463
1464 trace_workqueue_queue_work(req_cpu, pwq, work);
1465
1466 if (WARN_ON(!list_empty(&work->entry))) {
1467 spin_unlock(&pwq->pool->lock);
1468 return;
1469 }
1470
1471 pwq->nr_in_flight[pwq->work_color]++;
1472 work_flags = work_color_to_flags(pwq->work_color);
1473
1474 if (likely(pwq->nr_active < pwq->max_active)) {
1475 trace_workqueue_activate_work(work);
1476 pwq->nr_active++;
1477 worklist = &pwq->pool->worklist;
1478 if (list_empty(worklist))
1479 pwq->pool->watchdog_ts = jiffies;
1480 } else {
1481 work_flags |= WORK_STRUCT_DELAYED;
1482 worklist = &pwq->delayed_works;
1483 }
1484
1485 insert_work(pwq, work, worklist, work_flags);
1486
1487 spin_unlock(&pwq->pool->lock);
1488}
1489
1490
1491
1492
1493
1494
1495
1496
1497
1498
1499
1500
1501bool queue_work_on(int cpu, struct workqueue_struct *wq,
1502 struct work_struct *work)
1503{
1504 bool ret = false;
1505 unsigned long flags;
1506
1507 local_irq_save(flags);
1508
1509 if (!test_and_set_bit(WORK_STRUCT_PENDING_BIT, work_data_bits(work))) {
1510 __queue_work(cpu, wq, work);
1511 ret = true;
1512 }
1513
1514 local_irq_restore(flags);
1515 return ret;
1516}
1517EXPORT_SYMBOL(queue_work_on);
1518
1519void delayed_work_timer_fn(unsigned long __data)
1520{
1521 struct delayed_work *dwork = (struct delayed_work *)__data;
1522
1523
1524 __queue_work(dwork->cpu, dwork->wq, &dwork->work);
1525}
1526EXPORT_SYMBOL(delayed_work_timer_fn);
1527
1528static void __queue_delayed_work(int cpu, struct workqueue_struct *wq,
1529 struct delayed_work *dwork, unsigned long delay)
1530{
1531 struct timer_list *timer = &dwork->timer;
1532 struct work_struct *work = &dwork->work;
1533
1534 WARN_ON_ONCE(timer->function != delayed_work_timer_fn ||
1535 timer->data != (unsigned long)dwork);
1536 WARN_ON_ONCE(timer_pending(timer));
1537 WARN_ON_ONCE(!list_empty(&work->entry));
1538
1539
1540
1541
1542
1543
1544
1545 if (!delay) {
1546 __queue_work(cpu, wq, &dwork->work);
1547 return;
1548 }
1549
1550 timer_stats_timer_set_start_info(&dwork->timer);
1551
1552 dwork->wq = wq;
1553 dwork->cpu = cpu;
1554 timer->expires = jiffies + delay;
1555
1556 if (unlikely(cpu != WORK_CPU_UNBOUND))
1557 add_timer_on(timer, cpu);
1558 else
1559 add_timer(timer);
1560}
1561
1562
1563
1564
1565
1566
1567
1568
1569
1570
1571
1572
1573bool queue_delayed_work_on(int cpu, struct workqueue_struct *wq,
1574 struct delayed_work *dwork, unsigned long delay)
1575{
1576 struct work_struct *work = &dwork->work;
1577 bool ret = false;
1578 unsigned long flags;
1579
1580
1581 local_irq_save(flags);
1582
1583 if (!test_and_set_bit(WORK_STRUCT_PENDING_BIT, work_data_bits(work))) {
1584 __queue_delayed_work(cpu, wq, dwork, delay);
1585 ret = true;
1586 }
1587
1588 local_irq_restore(flags);
1589 return ret;
1590}
1591EXPORT_SYMBOL(queue_delayed_work_on);
1592
1593
1594
1595
1596
1597
1598
1599
1600
1601
1602
1603
1604
1605
1606
1607
1608
1609
1610
1611bool mod_delayed_work_on(int cpu, struct workqueue_struct *wq,
1612 struct delayed_work *dwork, unsigned long delay)
1613{
1614 unsigned long flags;
1615 int ret;
1616
1617 do {
1618 ret = try_to_grab_pending(&dwork->work, true, &flags);
1619 } while (unlikely(ret == -EAGAIN));
1620
1621 if (likely(ret >= 0)) {
1622 __queue_delayed_work(cpu, wq, dwork, delay);
1623 local_irq_restore(flags);
1624 }
1625
1626
1627 return ret;
1628}
1629EXPORT_SYMBOL_GPL(mod_delayed_work_on);
1630
1631
1632
1633
1634
1635
1636
1637
1638
1639
1640
1641static void worker_enter_idle(struct worker *worker)
1642{
1643 struct worker_pool *pool = worker->pool;
1644
1645 if (WARN_ON_ONCE(worker->flags & WORKER_IDLE) ||
1646 WARN_ON_ONCE(!list_empty(&worker->entry) &&
1647 (worker->hentry.next || worker->hentry.pprev)))
1648 return;
1649
1650
1651 worker->flags |= WORKER_IDLE;
1652 pool->nr_idle++;
1653 worker->last_active = jiffies;
1654
1655
1656 list_add(&worker->entry, &pool->idle_list);
1657
1658 if (too_many_workers(pool) && !timer_pending(&pool->idle_timer))
1659 mod_timer(&pool->idle_timer, jiffies + IDLE_WORKER_TIMEOUT);
1660
1661
1662
1663
1664
1665
1666
1667 WARN_ON_ONCE(!(pool->flags & POOL_DISASSOCIATED) &&
1668 pool->nr_workers == pool->nr_idle &&
1669 atomic_read(&pool->nr_running));
1670}
1671
1672
1673
1674
1675
1676
1677
1678
1679
1680
1681static void worker_leave_idle(struct worker *worker)
1682{
1683 struct worker_pool *pool = worker->pool;
1684
1685 if (WARN_ON_ONCE(!(worker->flags & WORKER_IDLE)))
1686 return;
1687 worker_clr_flags(worker, WORKER_IDLE);
1688 pool->nr_idle--;
1689 list_del_init(&worker->entry);
1690}
1691
1692static struct worker *alloc_worker(int node)
1693{
1694 struct worker *worker;
1695
1696 worker = kzalloc_node(sizeof(*worker), GFP_KERNEL, node);
1697 if (worker) {
1698 INIT_LIST_HEAD(&worker->entry);
1699 INIT_LIST_HEAD(&worker->scheduled);
1700 INIT_LIST_HEAD(&worker->node);
1701
1702 worker->flags = WORKER_PREP;
1703 }
1704 return worker;
1705}
1706
1707
1708
1709
1710
1711
1712
1713
1714
1715
1716static void worker_attach_to_pool(struct worker *worker,
1717 struct worker_pool *pool)
1718{
1719 mutex_lock(&pool->attach_mutex);
1720
1721
1722
1723
1724
1725 set_cpus_allowed_ptr(worker->task, pool->attrs->cpumask);
1726
1727
1728
1729
1730
1731
1732 if (pool->flags & POOL_DISASSOCIATED)
1733 worker->flags |= WORKER_UNBOUND;
1734
1735 list_add_tail(&worker->node, &pool->workers);
1736
1737 mutex_unlock(&pool->attach_mutex);
1738}
1739
1740
1741
1742
1743
1744
1745
1746
1747
1748
1749static void worker_detach_from_pool(struct worker *worker,
1750 struct worker_pool *pool)
1751{
1752 struct completion *detach_completion = NULL;
1753
1754 mutex_lock(&pool->attach_mutex);
1755 list_del(&worker->node);
1756 if (list_empty(&pool->workers))
1757 detach_completion = pool->detach_completion;
1758 mutex_unlock(&pool->attach_mutex);
1759
1760
1761 worker->flags &= ~(WORKER_UNBOUND | WORKER_REBOUND);
1762
1763 if (detach_completion)
1764 complete(detach_completion);
1765}
1766
1767
1768
1769
1770
1771
1772
1773
1774
1775
1776
1777
1778
1779static struct worker *create_worker(struct worker_pool *pool)
1780{
1781 struct worker *worker = NULL;
1782 int id = -1;
1783 char id_buf[16];
1784
1785
1786 id = ida_simple_get(&pool->worker_ida, 0, 0, GFP_KERNEL);
1787 if (id < 0)
1788 goto fail;
1789
1790 worker = alloc_worker(pool->node);
1791 if (!worker)
1792 goto fail;
1793
1794 worker->pool = pool;
1795 worker->id = id;
1796
1797 if (pool->cpu >= 0)
1798 snprintf(id_buf, sizeof(id_buf), "%d:%d%s", pool->cpu, id,
1799 pool->attrs->nice < 0 ? "H" : "");
1800 else
1801 snprintf(id_buf, sizeof(id_buf), "u%d:%d", pool->id, id);
1802
1803 worker->task = kthread_create_on_node(worker_thread, worker, pool->node,
1804 "kworker/%s", id_buf);
1805 if (IS_ERR(worker->task))
1806 goto fail;
1807
1808 set_user_nice(worker->task, pool->attrs->nice);
1809 kthread_bind_mask(worker->task, pool->attrs->cpumask);
1810
1811
1812 worker_attach_to_pool(worker, pool);
1813
1814
1815 spin_lock_irq(&pool->lock);
1816 worker->pool->nr_workers++;
1817 worker_enter_idle(worker);
1818 wake_up_process(worker->task);
1819 spin_unlock_irq(&pool->lock);
1820
1821 return worker;
1822
1823fail:
1824 if (id >= 0)
1825 ida_simple_remove(&pool->worker_ida, id);
1826 kfree(worker);
1827 return NULL;
1828}
1829
1830
1831
1832
1833
1834
1835
1836
1837
1838
1839
1840static void destroy_worker(struct worker *worker)
1841{
1842 struct worker_pool *pool = worker->pool;
1843
1844 lockdep_assert_held(&pool->lock);
1845
1846
1847 if (WARN_ON(worker->current_work) ||
1848 WARN_ON(!list_empty(&worker->scheduled)) ||
1849 WARN_ON(!(worker->flags & WORKER_IDLE)))
1850 return;
1851
1852 pool->nr_workers--;
1853 pool->nr_idle--;
1854
1855 list_del_init(&worker->entry);
1856 worker->flags |= WORKER_DIE;
1857 wake_up_process(worker->task);
1858}
1859
1860static void idle_worker_timeout(unsigned long __pool)
1861{
1862 struct worker_pool *pool = (void *)__pool;
1863
1864 spin_lock_irq(&pool->lock);
1865
1866 while (too_many_workers(pool)) {
1867 struct worker *worker;
1868 unsigned long expires;
1869
1870
1871 worker = list_entry(pool->idle_list.prev, struct worker, entry);
1872 expires = worker->last_active + IDLE_WORKER_TIMEOUT;
1873
1874 if (time_before(jiffies, expires)) {
1875 mod_timer(&pool->idle_timer, expires);
1876 break;
1877 }
1878
1879 destroy_worker(worker);
1880 }
1881
1882 spin_unlock_irq(&pool->lock);
1883}
1884
1885static void send_mayday(struct work_struct *work)
1886{
1887 struct pool_workqueue *pwq = get_work_pwq(work);
1888 struct workqueue_struct *wq = pwq->wq;
1889
1890 lockdep_assert_held(&wq_mayday_lock);
1891
1892 if (!wq->rescuer)
1893 return;
1894
1895
1896 if (list_empty(&pwq->mayday_node)) {
1897
1898
1899
1900
1901
1902 get_pwq(pwq);
1903 list_add_tail(&pwq->mayday_node, &wq->maydays);
1904 wake_up_process(wq->rescuer->task);
1905 }
1906}
1907
1908static void pool_mayday_timeout(unsigned long __pool)
1909{
1910 struct worker_pool *pool = (void *)__pool;
1911 struct work_struct *work;
1912
1913 spin_lock_irq(&pool->lock);
1914 spin_lock(&wq_mayday_lock);
1915
1916 if (need_to_create_worker(pool)) {
1917
1918
1919
1920
1921
1922
1923 list_for_each_entry(work, &pool->worklist, entry)
1924 send_mayday(work);
1925 }
1926
1927 spin_unlock(&wq_mayday_lock);
1928 spin_unlock_irq(&pool->lock);
1929
1930 mod_timer(&pool->mayday_timer, jiffies + MAYDAY_INTERVAL);
1931}
1932
1933
1934
1935
1936
1937
1938
1939
1940
1941
1942
1943
1944
1945
1946
1947
1948
1949
1950
1951static void maybe_create_worker(struct worker_pool *pool)
1952__releases(&pool->lock)
1953__acquires(&pool->lock)
1954{
1955restart:
1956 spin_unlock_irq(&pool->lock);
1957
1958
1959 mod_timer(&pool->mayday_timer, jiffies + MAYDAY_INITIAL_TIMEOUT);
1960
1961 while (true) {
1962 if (create_worker(pool) || !need_to_create_worker(pool))
1963 break;
1964
1965 schedule_timeout_interruptible(CREATE_COOLDOWN);
1966
1967 if (!need_to_create_worker(pool))
1968 break;
1969 }
1970
1971 del_timer_sync(&pool->mayday_timer);
1972 spin_lock_irq(&pool->lock);
1973
1974
1975
1976
1977
1978 if (need_to_create_worker(pool))
1979 goto restart;
1980}
1981
1982
1983
1984
1985
1986
1987
1988
1989
1990
1991
1992
1993
1994
1995
1996
1997
1998
1999
2000
2001
2002
2003
2004static bool manage_workers(struct worker *worker)
2005{
2006 struct worker_pool *pool = worker->pool;
2007
2008
2009
2010
2011
2012
2013
2014
2015
2016
2017
2018 if (!mutex_trylock(&pool->manager_arb))
2019 return false;
2020 pool->manager = worker;
2021
2022 maybe_create_worker(pool);
2023
2024 pool->manager = NULL;
2025 mutex_unlock(&pool->manager_arb);
2026 return true;
2027}
2028
2029
2030
2031
2032
2033
2034
2035
2036
2037
2038
2039
2040
2041
2042
2043static void process_one_work(struct worker *worker, struct work_struct *work)
2044__releases(&pool->lock)
2045__acquires(&pool->lock)
2046{
2047 struct pool_workqueue *pwq = get_work_pwq(work);
2048 struct worker_pool *pool = worker->pool;
2049 bool cpu_intensive = pwq->wq->flags & WQ_CPU_INTENSIVE;
2050 int work_color;
2051 struct worker *collision;
2052#ifdef CONFIG_LOCKDEP
2053
2054
2055
2056
2057
2058
2059
2060 struct lockdep_map lockdep_map;
2061
2062 lockdep_copy_map(&lockdep_map, &work->lockdep_map);
2063#endif
2064
2065 WARN_ON_ONCE(!(pool->flags & POOL_DISASSOCIATED) &&
2066 raw_smp_processor_id() != pool->cpu);
2067
2068
2069
2070
2071
2072
2073
2074 collision = find_worker_executing_work(pool, work);
2075 if (unlikely(collision)) {
2076 move_linked_works(work, &collision->scheduled, NULL);
2077 return;
2078 }
2079
2080
2081 debug_work_deactivate(work);
2082 hash_add(pool->busy_hash, &worker->hentry, (unsigned long)work);
2083 worker->current_work = work;
2084 worker->current_func = work->func;
2085 worker->current_pwq = pwq;
2086 work_color = get_work_color(work);
2087
2088 list_del_init(&work->entry);
2089
2090
2091
2092
2093
2094
2095
2096 if (unlikely(cpu_intensive))
2097 worker_set_flags(worker, WORKER_CPU_INTENSIVE);
2098
2099
2100
2101
2102
2103
2104
2105
2106 if (need_more_worker(pool))
2107 wake_up_worker(pool);
2108
2109
2110
2111
2112
2113
2114
2115 set_work_pool_and_clear_pending(work, pool->id);
2116
2117 spin_unlock_irq(&pool->lock);
2118
2119 lock_map_acquire_read(&pwq->wq->lockdep_map);
2120 lock_map_acquire(&lockdep_map);
2121 trace_workqueue_execute_start(work);
2122 worker->current_func(work);
2123
2124
2125
2126
2127 trace_workqueue_execute_end(work);
2128 lock_map_release(&lockdep_map);
2129 lock_map_release(&pwq->wq->lockdep_map);
2130
2131 if (unlikely(in_atomic() || lockdep_depth(current) > 0)) {
2132 pr_err("BUG: workqueue leaked lock or atomic: %s/0x%08x/%d\n"
2133 " last function: %pf\n",
2134 current->comm, preempt_count(), task_pid_nr(current),
2135 worker->current_func);
2136 debug_show_held_locks(current);
2137 dump_stack();
2138 }
2139
2140
2141
2142
2143
2144
2145
2146
2147
2148 cond_resched_rcu_qs();
2149
2150 spin_lock_irq(&pool->lock);
2151
2152
2153 if (unlikely(cpu_intensive))
2154 worker_clr_flags(worker, WORKER_CPU_INTENSIVE);
2155
2156
2157 hash_del(&worker->hentry);
2158 worker->current_work = NULL;
2159 worker->current_func = NULL;
2160 worker->current_pwq = NULL;
2161 worker->desc_valid = false;
2162 pwq_dec_nr_in_flight(pwq, work_color);
2163}
2164
2165
2166
2167
2168
2169
2170
2171
2172
2173
2174
2175
2176
2177static void process_scheduled_works(struct worker *worker)
2178{
2179 while (!list_empty(&worker->scheduled)) {
2180 struct work_struct *work = list_first_entry(&worker->scheduled,
2181 struct work_struct, entry);
2182 process_one_work(worker, work);
2183 }
2184}
2185
2186
2187
2188
2189
2190
2191
2192
2193
2194
2195
2196
2197
2198static int worker_thread(void *__worker)
2199{
2200 struct worker *worker = __worker;
2201 struct worker_pool *pool = worker->pool;
2202
2203
2204 worker->task->flags |= PF_WQ_WORKER;
2205woke_up:
2206 spin_lock_irq(&pool->lock);
2207
2208
2209 if (unlikely(worker->flags & WORKER_DIE)) {
2210 spin_unlock_irq(&pool->lock);
2211 WARN_ON_ONCE(!list_empty(&worker->entry));
2212 worker->task->flags &= ~PF_WQ_WORKER;
2213
2214 set_task_comm(worker->task, "kworker/dying");
2215 ida_simple_remove(&pool->worker_ida, worker->id);
2216 worker_detach_from_pool(worker, pool);
2217 kfree(worker);
2218 return 0;
2219 }
2220
2221 worker_leave_idle(worker);
2222recheck:
2223
2224 if (!need_more_worker(pool))
2225 goto sleep;
2226
2227
2228 if (unlikely(!may_start_working(pool)) && manage_workers(worker))
2229 goto recheck;
2230
2231
2232
2233
2234
2235
2236 WARN_ON_ONCE(!list_empty(&worker->scheduled));
2237
2238
2239
2240
2241
2242
2243
2244
2245 worker_clr_flags(worker, WORKER_PREP | WORKER_REBOUND);
2246
2247 do {
2248 struct work_struct *work =
2249 list_first_entry(&pool->worklist,
2250 struct work_struct, entry);
2251
2252 pool->watchdog_ts = jiffies;
2253
2254 if (likely(!(*work_data_bits(work) & WORK_STRUCT_LINKED))) {
2255
2256 process_one_work(worker, work);
2257 if (unlikely(!list_empty(&worker->scheduled)))
2258 process_scheduled_works(worker);
2259 } else {
2260 move_linked_works(work, &worker->scheduled, NULL);
2261 process_scheduled_works(worker);
2262 }
2263 } while (keep_working(pool));
2264
2265 worker_set_flags(worker, WORKER_PREP);
2266sleep:
2267
2268
2269
2270
2271
2272
2273
2274 worker_enter_idle(worker);
2275 __set_current_state(TASK_INTERRUPTIBLE);
2276 spin_unlock_irq(&pool->lock);
2277 schedule();
2278 goto woke_up;
2279}
2280
2281
2282
2283
2284
2285
2286
2287
2288
2289
2290
2291
2292
2293
2294
2295
2296
2297
2298
2299
2300
2301
2302static int rescuer_thread(void *__rescuer)
2303{
2304 struct worker *rescuer = __rescuer;
2305 struct workqueue_struct *wq = rescuer->rescue_wq;
2306 struct list_head *scheduled = &rescuer->scheduled;
2307 bool should_stop;
2308
2309 set_user_nice(current, RESCUER_NICE_LEVEL);
2310
2311
2312
2313
2314
2315 rescuer->task->flags |= PF_WQ_WORKER;
2316repeat:
2317 set_current_state(TASK_INTERRUPTIBLE);
2318
2319
2320
2321
2322
2323
2324
2325
2326
2327 should_stop = kthread_should_stop();
2328
2329
2330 spin_lock_irq(&wq_mayday_lock);
2331
2332 while (!list_empty(&wq->maydays)) {
2333 struct pool_workqueue *pwq = list_first_entry(&wq->maydays,
2334 struct pool_workqueue, mayday_node);
2335 struct worker_pool *pool = pwq->pool;
2336 struct work_struct *work, *n;
2337 bool first = true;
2338
2339 __set_current_state(TASK_RUNNING);
2340 list_del_init(&pwq->mayday_node);
2341
2342 spin_unlock_irq(&wq_mayday_lock);
2343
2344 worker_attach_to_pool(rescuer, pool);
2345
2346 spin_lock_irq(&pool->lock);
2347 rescuer->pool = pool;
2348
2349
2350
2351
2352
2353 WARN_ON_ONCE(!list_empty(scheduled));
2354 list_for_each_entry_safe(work, n, &pool->worklist, entry) {
2355 if (get_work_pwq(work) == pwq) {
2356 if (first)
2357 pool->watchdog_ts = jiffies;
2358 move_linked_works(work, scheduled, &n);
2359 }
2360 first = false;
2361 }
2362
2363 if (!list_empty(scheduled)) {
2364 process_scheduled_works(rescuer);
2365
2366
2367
2368
2369
2370
2371
2372
2373
2374
2375 if (need_to_create_worker(pool)) {
2376 spin_lock(&wq_mayday_lock);
2377 get_pwq(pwq);
2378 list_move_tail(&pwq->mayday_node, &wq->maydays);
2379 spin_unlock(&wq_mayday_lock);
2380 }
2381 }
2382
2383
2384
2385
2386
2387 put_pwq(pwq);
2388
2389
2390
2391
2392
2393
2394 if (need_more_worker(pool))
2395 wake_up_worker(pool);
2396
2397 rescuer->pool = NULL;
2398 spin_unlock_irq(&pool->lock);
2399
2400 worker_detach_from_pool(rescuer, pool);
2401
2402 spin_lock_irq(&wq_mayday_lock);
2403 }
2404
2405 spin_unlock_irq(&wq_mayday_lock);
2406
2407 if (should_stop) {
2408 __set_current_state(TASK_RUNNING);
2409 rescuer->task->flags &= ~PF_WQ_WORKER;
2410 return 0;
2411 }
2412
2413
2414 WARN_ON_ONCE(!(rescuer->flags & WORKER_NOT_RUNNING));
2415 schedule();
2416 goto repeat;
2417}
2418
2419
2420
2421
2422
2423
2424
2425
2426
2427
2428
2429
2430static void check_flush_dependency(struct workqueue_struct *target_wq,
2431 struct work_struct *target_work)
2432{
2433 work_func_t target_func = target_work ? target_work->func : NULL;
2434 struct worker *worker;
2435
2436 if (target_wq->flags & WQ_MEM_RECLAIM)
2437 return;
2438
2439 worker = current_wq_worker();
2440
2441 WARN_ONCE(current->flags & PF_MEMALLOC,
2442 "workqueue: PF_MEMALLOC task %d(%s) is flushing !WQ_MEM_RECLAIM %s:%pf",
2443 current->pid, current->comm, target_wq->name, target_func);
2444 WARN_ONCE(worker && ((worker->current_pwq->wq->flags &
2445 (WQ_MEM_RECLAIM | __WQ_LEGACY)) == WQ_MEM_RECLAIM),
2446 "workqueue: WQ_MEM_RECLAIM %s:%pf is flushing !WQ_MEM_RECLAIM %s:%pf",
2447 worker->current_pwq->wq->name, worker->current_func,
2448 target_wq->name, target_func);
2449}
2450
2451struct wq_barrier {
2452 struct work_struct work;
2453 struct completion done;
2454 struct task_struct *task;
2455};
2456
2457static void wq_barrier_func(struct work_struct *work)
2458{
2459 struct wq_barrier *barr = container_of(work, struct wq_barrier, work);
2460 complete(&barr->done);
2461}
2462
2463
2464
2465
2466
2467
2468
2469
2470
2471
2472
2473
2474
2475
2476
2477
2478
2479
2480
2481
2482
2483
2484
2485
2486
2487static void insert_wq_barrier(struct pool_workqueue *pwq,
2488 struct wq_barrier *barr,
2489 struct work_struct *target, struct worker *worker)
2490{
2491 struct list_head *head;
2492 unsigned int linked = 0;
2493
2494
2495
2496
2497
2498
2499
2500 INIT_WORK_ONSTACK(&barr->work, wq_barrier_func);
2501 __set_bit(WORK_STRUCT_PENDING_BIT, work_data_bits(&barr->work));
2502 init_completion(&barr->done);
2503 barr->task = current;
2504
2505
2506
2507
2508
2509 if (worker)
2510 head = worker->scheduled.next;
2511 else {
2512 unsigned long *bits = work_data_bits(target);
2513
2514 head = target->entry.next;
2515
2516 linked = *bits & WORK_STRUCT_LINKED;
2517 __set_bit(WORK_STRUCT_LINKED_BIT, bits);
2518 }
2519
2520 debug_work_activate(&barr->work);
2521 insert_work(pwq, &barr->work, head,
2522 work_color_to_flags(WORK_NO_COLOR) | linked);
2523}
2524
2525
2526
2527
2528
2529
2530
2531
2532
2533
2534
2535
2536
2537
2538
2539
2540
2541
2542
2543
2544
2545
2546
2547
2548
2549
2550
2551
2552
2553
2554
2555
2556static bool flush_workqueue_prep_pwqs(struct workqueue_struct *wq,
2557 int flush_color, int work_color)
2558{
2559 bool wait = false;
2560 struct pool_workqueue *pwq;
2561
2562 if (flush_color >= 0) {
2563 WARN_ON_ONCE(atomic_read(&wq->nr_pwqs_to_flush));
2564 atomic_set(&wq->nr_pwqs_to_flush, 1);
2565 }
2566
2567 for_each_pwq(pwq, wq) {
2568 struct worker_pool *pool = pwq->pool;
2569
2570 spin_lock_irq(&pool->lock);
2571
2572 if (flush_color >= 0) {
2573 WARN_ON_ONCE(pwq->flush_color != -1);
2574
2575 if (pwq->nr_in_flight[flush_color]) {
2576 pwq->flush_color = flush_color;
2577 atomic_inc(&wq->nr_pwqs_to_flush);
2578 wait = true;
2579 }
2580 }
2581
2582 if (work_color >= 0) {
2583 WARN_ON_ONCE(work_color != work_next_color(pwq->work_color));
2584 pwq->work_color = work_color;
2585 }
2586
2587 spin_unlock_irq(&pool->lock);
2588 }
2589
2590 if (flush_color >= 0 && atomic_dec_and_test(&wq->nr_pwqs_to_flush))
2591 complete(&wq->first_flusher->done);
2592
2593 return wait;
2594}
2595
2596
2597
2598
2599
2600
2601
2602
2603void flush_workqueue(struct workqueue_struct *wq)
2604{
2605 struct wq_flusher this_flusher = {
2606 .list = LIST_HEAD_INIT(this_flusher.list),
2607 .flush_color = -1,
2608 .done = COMPLETION_INITIALIZER_ONSTACK(this_flusher.done),
2609 };
2610 int next_color;
2611
2612 lock_map_acquire(&wq->lockdep_map);
2613 lock_map_release(&wq->lockdep_map);
2614
2615 mutex_lock(&wq->mutex);
2616
2617
2618
2619
2620 next_color = work_next_color(wq->work_color);
2621
2622 if (next_color != wq->flush_color) {
2623
2624
2625
2626
2627
2628 WARN_ON_ONCE(!list_empty(&wq->flusher_overflow));
2629 this_flusher.flush_color = wq->work_color;
2630 wq->work_color = next_color;
2631
2632 if (!wq->first_flusher) {
2633
2634 WARN_ON_ONCE(wq->flush_color != this_flusher.flush_color);
2635
2636 wq->first_flusher = &this_flusher;
2637
2638 if (!flush_workqueue_prep_pwqs(wq, wq->flush_color,
2639 wq->work_color)) {
2640
2641 wq->flush_color = next_color;
2642 wq->first_flusher = NULL;
2643 goto out_unlock;
2644 }
2645 } else {
2646
2647 WARN_ON_ONCE(wq->flush_color == this_flusher.flush_color);
2648 list_add_tail(&this_flusher.list, &wq->flusher_queue);
2649 flush_workqueue_prep_pwqs(wq, -1, wq->work_color);
2650 }
2651 } else {
2652
2653
2654
2655
2656
2657 list_add_tail(&this_flusher.list, &wq->flusher_overflow);
2658 }
2659
2660 check_flush_dependency(wq, NULL);
2661
2662 mutex_unlock(&wq->mutex);
2663
2664 wait_for_completion(&this_flusher.done);
2665
2666
2667
2668
2669
2670
2671
2672 if (wq->first_flusher != &this_flusher)
2673 return;
2674
2675 mutex_lock(&wq->mutex);
2676
2677
2678 if (wq->first_flusher != &this_flusher)
2679 goto out_unlock;
2680
2681 wq->first_flusher = NULL;
2682
2683 WARN_ON_ONCE(!list_empty(&this_flusher.list));
2684 WARN_ON_ONCE(wq->flush_color != this_flusher.flush_color);
2685
2686 while (true) {
2687 struct wq_flusher *next, *tmp;
2688
2689
2690 list_for_each_entry_safe(next, tmp, &wq->flusher_queue, list) {
2691 if (next->flush_color != wq->flush_color)
2692 break;
2693 list_del_init(&next->list);
2694 complete(&next->done);
2695 }
2696
2697 WARN_ON_ONCE(!list_empty(&wq->flusher_overflow) &&
2698 wq->flush_color != work_next_color(wq->work_color));
2699
2700
2701 wq->flush_color = work_next_color(wq->flush_color);
2702
2703
2704 if (!list_empty(&wq->flusher_overflow)) {
2705
2706
2707
2708
2709
2710
2711 list_for_each_entry(tmp, &wq->flusher_overflow, list)
2712 tmp->flush_color = wq->work_color;
2713
2714 wq->work_color = work_next_color(wq->work_color);
2715
2716 list_splice_tail_init(&wq->flusher_overflow,
2717 &wq->flusher_queue);
2718 flush_workqueue_prep_pwqs(wq, -1, wq->work_color);
2719 }
2720
2721 if (list_empty(&wq->flusher_queue)) {
2722 WARN_ON_ONCE(wq->flush_color != wq->work_color);
2723 break;
2724 }
2725
2726
2727
2728
2729
2730 WARN_ON_ONCE(wq->flush_color == wq->work_color);
2731 WARN_ON_ONCE(wq->flush_color != next->flush_color);
2732
2733 list_del_init(&next->list);
2734 wq->first_flusher = next;
2735
2736 if (flush_workqueue_prep_pwqs(wq, wq->flush_color, -1))
2737 break;
2738
2739
2740
2741
2742
2743 wq->first_flusher = NULL;
2744 }
2745
2746out_unlock:
2747 mutex_unlock(&wq->mutex);
2748}
2749EXPORT_SYMBOL(flush_workqueue);
2750
2751
2752
2753
2754
2755
2756
2757
2758
2759
2760
2761
2762void drain_workqueue(struct workqueue_struct *wq)
2763{
2764 unsigned int flush_cnt = 0;
2765 struct pool_workqueue *pwq;
2766
2767
2768
2769
2770
2771
2772 mutex_lock(&wq->mutex);
2773 if (!wq->nr_drainers++)
2774 wq->flags |= __WQ_DRAINING;
2775 mutex_unlock(&wq->mutex);
2776reflush:
2777 flush_workqueue(wq);
2778
2779 mutex_lock(&wq->mutex);
2780
2781 for_each_pwq(pwq, wq) {
2782 bool drained;
2783
2784 spin_lock_irq(&pwq->pool->lock);
2785 drained = !pwq->nr_active && list_empty(&pwq->delayed_works);
2786 spin_unlock_irq(&pwq->pool->lock);
2787
2788 if (drained)
2789 continue;
2790
2791 if (++flush_cnt == 10 ||
2792 (flush_cnt % 100 == 0 && flush_cnt <= 1000))
2793 pr_warn("workqueue %s: drain_workqueue() isn't complete after %u tries\n",
2794 wq->name, flush_cnt);
2795
2796 mutex_unlock(&wq->mutex);
2797 goto reflush;
2798 }
2799
2800 if (!--wq->nr_drainers)
2801 wq->flags &= ~__WQ_DRAINING;
2802 mutex_unlock(&wq->mutex);
2803}
2804EXPORT_SYMBOL_GPL(drain_workqueue);
2805
2806static bool start_flush_work(struct work_struct *work, struct wq_barrier *barr)
2807{
2808 struct worker *worker = NULL;
2809 struct worker_pool *pool;
2810 struct pool_workqueue *pwq;
2811
2812 might_sleep();
2813
2814 local_irq_disable();
2815 pool = get_work_pool(work);
2816 if (!pool) {
2817 local_irq_enable();
2818 return false;
2819 }
2820
2821 spin_lock(&pool->lock);
2822
2823 pwq = get_work_pwq(work);
2824 if (pwq) {
2825 if (unlikely(pwq->pool != pool))
2826 goto already_gone;
2827 } else {
2828 worker = find_worker_executing_work(pool, work);
2829 if (!worker)
2830 goto already_gone;
2831 pwq = worker->current_pwq;
2832 }
2833
2834 check_flush_dependency(pwq->wq, work);
2835
2836 insert_wq_barrier(pwq, barr, work, worker);
2837 spin_unlock_irq(&pool->lock);
2838
2839
2840
2841
2842
2843
2844
2845 if (pwq->wq->saved_max_active == 1 || pwq->wq->rescuer)
2846 lock_map_acquire(&pwq->wq->lockdep_map);
2847 else
2848 lock_map_acquire_read(&pwq->wq->lockdep_map);
2849 lock_map_release(&pwq->wq->lockdep_map);
2850
2851 return true;
2852already_gone:
2853 spin_unlock_irq(&pool->lock);
2854 return false;
2855}
2856
2857
2858
2859
2860
2861
2862
2863
2864
2865
2866
2867
2868bool flush_work(struct work_struct *work)
2869{
2870 struct wq_barrier barr;
2871
2872 lock_map_acquire(&work->lockdep_map);
2873 lock_map_release(&work->lockdep_map);
2874
2875 if (start_flush_work(work, &barr)) {
2876 wait_for_completion(&barr.done);
2877 destroy_work_on_stack(&barr.work);
2878 return true;
2879 } else {
2880 return false;
2881 }
2882}
2883EXPORT_SYMBOL_GPL(flush_work);
2884
2885struct cwt_wait {
2886 wait_queue_t wait;
2887 struct work_struct *work;
2888};
2889
2890static int cwt_wakefn(wait_queue_t *wait, unsigned mode, int sync, void *key)
2891{
2892 struct cwt_wait *cwait = container_of(wait, struct cwt_wait, wait);
2893
2894 if (cwait->work != key)
2895 return 0;
2896 return autoremove_wake_function(wait, mode, sync, key);
2897}
2898
2899static bool __cancel_work_timer(struct work_struct *work, bool is_dwork)
2900{
2901 static DECLARE_WAIT_QUEUE_HEAD(cancel_waitq);
2902 unsigned long flags;
2903 int ret;
2904
2905 do {
2906 ret = try_to_grab_pending(work, is_dwork, &flags);
2907
2908
2909
2910
2911
2912
2913
2914
2915
2916
2917
2918
2919
2920
2921
2922
2923 if (unlikely(ret == -ENOENT)) {
2924 struct cwt_wait cwait;
2925
2926 init_wait(&cwait.wait);
2927 cwait.wait.func = cwt_wakefn;
2928 cwait.work = work;
2929
2930 prepare_to_wait_exclusive(&cancel_waitq, &cwait.wait,
2931 TASK_UNINTERRUPTIBLE);
2932 if (work_is_canceling(work))
2933 schedule();
2934 finish_wait(&cancel_waitq, &cwait.wait);
2935 }
2936 } while (unlikely(ret < 0));
2937
2938
2939 mark_work_canceling(work);
2940 local_irq_restore(flags);
2941
2942 flush_work(work);
2943 clear_work_data(work);
2944
2945
2946
2947
2948
2949
2950 smp_mb();
2951 if (waitqueue_active(&cancel_waitq))
2952 __wake_up(&cancel_waitq, TASK_NORMAL, 1, work);
2953
2954 return ret;
2955}
2956
2957
2958
2959
2960
2961
2962
2963
2964
2965
2966
2967
2968
2969
2970
2971
2972
2973
2974
2975bool cancel_work_sync(struct work_struct *work)
2976{
2977 return __cancel_work_timer(work, false);
2978}
2979EXPORT_SYMBOL_GPL(cancel_work_sync);
2980
2981
2982
2983
2984
2985
2986
2987
2988
2989
2990
2991
2992
2993bool flush_delayed_work(struct delayed_work *dwork)
2994{
2995 local_irq_disable();
2996 if (del_timer_sync(&dwork->timer))
2997 __queue_work(dwork->cpu, dwork->wq, &dwork->work);
2998 local_irq_enable();
2999 return flush_work(&dwork->work);
3000}
3001EXPORT_SYMBOL(flush_delayed_work);
3002
3003
3004
3005
3006
3007
3008
3009
3010
3011
3012
3013
3014
3015
3016
3017
3018
3019bool cancel_delayed_work(struct delayed_work *dwork)
3020{
3021 unsigned long flags;
3022 int ret;
3023
3024 do {
3025 ret = try_to_grab_pending(&dwork->work, true, &flags);
3026 } while (unlikely(ret == -EAGAIN));
3027
3028 if (unlikely(ret < 0))
3029 return false;
3030
3031 set_work_pool_and_clear_pending(&dwork->work,
3032 get_work_pool_id(&dwork->work));
3033 local_irq_restore(flags);
3034 return ret;
3035}
3036EXPORT_SYMBOL(cancel_delayed_work);
3037
3038
3039
3040
3041
3042
3043
3044
3045
3046
3047bool cancel_delayed_work_sync(struct delayed_work *dwork)
3048{
3049 return __cancel_work_timer(&dwork->work, true);
3050}
3051EXPORT_SYMBOL(cancel_delayed_work_sync);
3052
3053
3054
3055
3056
3057
3058
3059
3060
3061
3062
3063
3064int schedule_on_each_cpu(work_func_t func)
3065{
3066 int cpu;
3067 struct work_struct __percpu *works;
3068
3069 works = alloc_percpu(struct work_struct);
3070 if (!works)
3071 return -ENOMEM;
3072
3073 get_online_cpus();
3074
3075 for_each_online_cpu(cpu) {
3076 struct work_struct *work = per_cpu_ptr(works, cpu);
3077
3078 INIT_WORK(work, func);
3079 schedule_work_on(cpu, work);
3080 }
3081
3082 for_each_online_cpu(cpu)
3083 flush_work(per_cpu_ptr(works, cpu));
3084
3085 put_online_cpus();
3086 free_percpu(works);
3087 return 0;
3088}
3089
3090
3091
3092
3093
3094
3095
3096
3097
3098
3099
3100
3101
3102int execute_in_process_context(work_func_t fn, struct execute_work *ew)
3103{
3104 if (!in_interrupt()) {
3105 fn(&ew->work);
3106 return 0;
3107 }
3108
3109 INIT_WORK(&ew->work, fn);
3110 schedule_work(&ew->work);
3111
3112 return 1;
3113}
3114EXPORT_SYMBOL_GPL(execute_in_process_context);
3115
3116
3117
3118
3119
3120
3121
3122void free_workqueue_attrs(struct workqueue_attrs *attrs)
3123{
3124 if (attrs) {
3125 free_cpumask_var(attrs->cpumask);
3126 kfree(attrs);
3127 }
3128}
3129
3130
3131
3132
3133
3134
3135
3136
3137
3138
3139struct workqueue_attrs *alloc_workqueue_attrs(gfp_t gfp_mask)
3140{
3141 struct workqueue_attrs *attrs;
3142
3143 attrs = kzalloc(sizeof(*attrs), gfp_mask);
3144 if (!attrs)
3145 goto fail;
3146 if (!alloc_cpumask_var(&attrs->cpumask, gfp_mask))
3147 goto fail;
3148
3149 cpumask_copy(attrs->cpumask, cpu_possible_mask);
3150 return attrs;
3151fail:
3152 free_workqueue_attrs(attrs);
3153 return NULL;
3154}
3155
3156static void copy_workqueue_attrs(struct workqueue_attrs *to,
3157 const struct workqueue_attrs *from)
3158{
3159 to->nice = from->nice;
3160 cpumask_copy(to->cpumask, from->cpumask);
3161
3162
3163
3164
3165
3166 to->no_numa = from->no_numa;
3167}
3168
3169
3170static u32 wqattrs_hash(const struct workqueue_attrs *attrs)
3171{
3172 u32 hash = 0;
3173
3174 hash = jhash_1word(attrs->nice, hash);
3175 hash = jhash(cpumask_bits(attrs->cpumask),
3176 BITS_TO_LONGS(nr_cpumask_bits) * sizeof(long), hash);
3177 return hash;
3178}
3179
3180
3181static bool wqattrs_equal(const struct workqueue_attrs *a,
3182 const struct workqueue_attrs *b)
3183{
3184 if (a->nice != b->nice)
3185 return false;
3186 if (!cpumask_equal(a->cpumask, b->cpumask))
3187 return false;
3188 return true;
3189}
3190
3191
3192
3193
3194
3195
3196
3197
3198
3199
3200
3201static int init_worker_pool(struct worker_pool *pool)
3202{
3203 spin_lock_init(&pool->lock);
3204 pool->id = -1;
3205 pool->cpu = -1;
3206 pool->node = NUMA_NO_NODE;
3207 pool->flags |= POOL_DISASSOCIATED;
3208 pool->watchdog_ts = jiffies;
3209 INIT_LIST_HEAD(&pool->worklist);
3210 INIT_LIST_HEAD(&pool->idle_list);
3211 hash_init(pool->busy_hash);
3212
3213 init_timer_deferrable(&pool->idle_timer);
3214 pool->idle_timer.function = idle_worker_timeout;
3215 pool->idle_timer.data = (unsigned long)pool;
3216
3217 setup_timer(&pool->mayday_timer, pool_mayday_timeout,
3218 (unsigned long)pool);
3219
3220 mutex_init(&pool->manager_arb);
3221 mutex_init(&pool->attach_mutex);
3222 INIT_LIST_HEAD(&pool->workers);
3223
3224 ida_init(&pool->worker_ida);
3225 INIT_HLIST_NODE(&pool->hash_node);
3226 pool->refcnt = 1;
3227
3228
3229 pool->attrs = alloc_workqueue_attrs(GFP_KERNEL);
3230 if (!pool->attrs)
3231 return -ENOMEM;
3232 return 0;
3233}
3234
3235static void rcu_free_wq(struct rcu_head *rcu)
3236{
3237 struct workqueue_struct *wq =
3238 container_of(rcu, struct workqueue_struct, rcu);
3239
3240 if (!(wq->flags & WQ_UNBOUND))
3241 free_percpu(wq->cpu_pwqs);
3242 else
3243 free_workqueue_attrs(wq->unbound_attrs);
3244
3245 kfree(wq->rescuer);
3246 kfree(wq);
3247}
3248
3249static void rcu_free_pool(struct rcu_head *rcu)
3250{
3251 struct worker_pool *pool = container_of(rcu, struct worker_pool, rcu);
3252
3253 ida_destroy(&pool->worker_ida);
3254 free_workqueue_attrs(pool->attrs);
3255 kfree(pool);
3256}
3257
3258
3259
3260
3261
3262
3263
3264
3265
3266
3267
3268
3269static void put_unbound_pool(struct worker_pool *pool)
3270{
3271 DECLARE_COMPLETION_ONSTACK(detach_completion);
3272 struct worker *worker;
3273
3274 lockdep_assert_held(&wq_pool_mutex);
3275
3276 if (--pool->refcnt)
3277 return;
3278
3279
3280 if (WARN_ON(!(pool->cpu < 0)) ||
3281 WARN_ON(!list_empty(&pool->worklist)))
3282 return;
3283
3284
3285 if (pool->id >= 0)
3286 idr_remove(&worker_pool_idr, pool->id);
3287 hash_del(&pool->hash_node);
3288
3289
3290
3291
3292
3293
3294 mutex_lock(&pool->manager_arb);
3295
3296 spin_lock_irq(&pool->lock);
3297 while ((worker = first_idle_worker(pool)))
3298 destroy_worker(worker);
3299 WARN_ON(pool->nr_workers || pool->nr_idle);
3300 spin_unlock_irq(&pool->lock);
3301
3302 mutex_lock(&pool->attach_mutex);
3303 if (!list_empty(&pool->workers))
3304 pool->detach_completion = &detach_completion;
3305 mutex_unlock(&pool->attach_mutex);
3306
3307 if (pool->detach_completion)
3308 wait_for_completion(pool->detach_completion);
3309
3310 mutex_unlock(&pool->manager_arb);
3311
3312
3313 del_timer_sync(&pool->idle_timer);
3314 del_timer_sync(&pool->mayday_timer);
3315
3316
3317 call_rcu_sched(&pool->rcu, rcu_free_pool);
3318}
3319
3320
3321
3322
3323
3324
3325
3326
3327
3328
3329
3330
3331
3332
3333
3334static struct worker_pool *get_unbound_pool(const struct workqueue_attrs *attrs)
3335{
3336 u32 hash = wqattrs_hash(attrs);
3337 struct worker_pool *pool;
3338 int node;
3339 int target_node = NUMA_NO_NODE;
3340
3341 lockdep_assert_held(&wq_pool_mutex);
3342
3343
3344 hash_for_each_possible(unbound_pool_hash, pool, hash_node, hash) {
3345 if (wqattrs_equal(pool->attrs, attrs)) {
3346 pool->refcnt++;
3347 return pool;
3348 }
3349 }
3350
3351
3352 if (wq_numa_enabled) {
3353 for_each_node(node) {
3354 if (cpumask_subset(attrs->cpumask,
3355 wq_numa_possible_cpumask[node])) {
3356 target_node = node;
3357 break;
3358 }
3359 }
3360 }
3361
3362
3363 pool = kzalloc_node(sizeof(*pool), GFP_KERNEL, target_node);
3364 if (!pool || init_worker_pool(pool) < 0)
3365 goto fail;
3366
3367 lockdep_set_subclass(&pool->lock, 1);
3368 copy_workqueue_attrs(pool->attrs, attrs);
3369 pool->node = target_node;
3370
3371
3372
3373
3374
3375 pool->attrs->no_numa = false;
3376
3377 if (worker_pool_assign_id(pool) < 0)
3378 goto fail;
3379
3380
3381 if (!create_worker(pool))
3382 goto fail;
3383
3384
3385 hash_add(unbound_pool_hash, &pool->hash_node, hash);
3386
3387 return pool;
3388fail:
3389 if (pool)
3390 put_unbound_pool(pool);
3391 return NULL;
3392}
3393
3394static void rcu_free_pwq(struct rcu_head *rcu)
3395{
3396 kmem_cache_free(pwq_cache,
3397 container_of(rcu, struct pool_workqueue, rcu));
3398}
3399
3400
3401
3402
3403
3404static void pwq_unbound_release_workfn(struct work_struct *work)
3405{
3406 struct pool_workqueue *pwq = container_of(work, struct pool_workqueue,
3407 unbound_release_work);
3408 struct workqueue_struct *wq = pwq->wq;
3409 struct worker_pool *pool = pwq->pool;
3410 bool is_last;
3411
3412 if (WARN_ON_ONCE(!(wq->flags & WQ_UNBOUND)))
3413 return;
3414
3415 mutex_lock(&wq->mutex);
3416 list_del_rcu(&pwq->pwqs_node);
3417 is_last = list_empty(&wq->pwqs);
3418 mutex_unlock(&wq->mutex);
3419
3420 mutex_lock(&wq_pool_mutex);
3421 put_unbound_pool(pool);
3422 mutex_unlock(&wq_pool_mutex);
3423
3424 call_rcu_sched(&pwq->rcu, rcu_free_pwq);
3425
3426
3427
3428
3429
3430 if (is_last)
3431 call_rcu_sched(&wq->rcu, rcu_free_wq);
3432}
3433
3434
3435
3436
3437
3438
3439
3440
3441
3442static void pwq_adjust_max_active(struct pool_workqueue *pwq)
3443{
3444 struct workqueue_struct *wq = pwq->wq;
3445 bool freezable = wq->flags & WQ_FREEZABLE;
3446
3447
3448 lockdep_assert_held(&wq->mutex);
3449
3450
3451 if (!freezable && pwq->max_active == wq->saved_max_active)
3452 return;
3453
3454 spin_lock_irq(&pwq->pool->lock);
3455
3456
3457
3458
3459
3460
3461 if (!freezable || !workqueue_freezing) {
3462 pwq->max_active = wq->saved_max_active;
3463
3464 while (!list_empty(&pwq->delayed_works) &&
3465 pwq->nr_active < pwq->max_active)
3466 pwq_activate_first_delayed(pwq);
3467
3468
3469
3470
3471
3472 wake_up_worker(pwq->pool);
3473 } else {
3474 pwq->max_active = 0;
3475 }
3476
3477 spin_unlock_irq(&pwq->pool->lock);
3478}
3479
3480
3481static void init_pwq(struct pool_workqueue *pwq, struct workqueue_struct *wq,
3482 struct worker_pool *pool)
3483{
3484 BUG_ON((unsigned long)pwq & WORK_STRUCT_FLAG_MASK);
3485
3486 memset(pwq, 0, sizeof(*pwq));
3487
3488 pwq->pool = pool;
3489 pwq->wq = wq;
3490 pwq->flush_color = -1;
3491 pwq->refcnt = 1;
3492 INIT_LIST_HEAD(&pwq->delayed_works);
3493 INIT_LIST_HEAD(&pwq->pwqs_node);
3494 INIT_LIST_HEAD(&pwq->mayday_node);
3495 INIT_WORK(&pwq->unbound_release_work, pwq_unbound_release_workfn);
3496}
3497
3498
3499static void link_pwq(struct pool_workqueue *pwq)
3500{
3501 struct workqueue_struct *wq = pwq->wq;
3502
3503 lockdep_assert_held(&wq->mutex);
3504
3505
3506 if (!list_empty(&pwq->pwqs_node))
3507 return;
3508
3509
3510 pwq->work_color = wq->work_color;
3511
3512
3513 pwq_adjust_max_active(pwq);
3514
3515
3516 list_add_rcu(&pwq->pwqs_node, &wq->pwqs);
3517}
3518
3519
3520static struct pool_workqueue *alloc_unbound_pwq(struct workqueue_struct *wq,
3521 const struct workqueue_attrs *attrs)
3522{
3523 struct worker_pool *pool;
3524 struct pool_workqueue *pwq;
3525
3526 lockdep_assert_held(&wq_pool_mutex);
3527
3528 pool = get_unbound_pool(attrs);
3529 if (!pool)
3530 return NULL;
3531
3532 pwq = kmem_cache_alloc_node(pwq_cache, GFP_KERNEL, pool->node);
3533 if (!pwq) {
3534 put_unbound_pool(pool);
3535 return NULL;
3536 }
3537
3538 init_pwq(pwq, wq, pool);
3539 return pwq;
3540}
3541
3542
3543
3544
3545
3546
3547
3548
3549
3550
3551
3552
3553
3554
3555
3556
3557
3558
3559
3560
3561
3562
3563
3564static bool wq_calc_node_cpumask(const struct workqueue_attrs *attrs, int node,
3565 int cpu_going_down, cpumask_t *cpumask)
3566{
3567 if (!wq_numa_enabled || attrs->no_numa)
3568 goto use_dfl;
3569
3570
3571 cpumask_and(cpumask, cpumask_of_node(node), attrs->cpumask);
3572 if (cpu_going_down >= 0)
3573 cpumask_clear_cpu(cpu_going_down, cpumask);
3574
3575 if (cpumask_empty(cpumask))
3576 goto use_dfl;
3577
3578
3579 cpumask_and(cpumask, attrs->cpumask, wq_numa_possible_cpumask[node]);
3580 return !cpumask_equal(cpumask, attrs->cpumask);
3581
3582use_dfl:
3583 cpumask_copy(cpumask, attrs->cpumask);
3584 return false;
3585}
3586
3587
3588static struct pool_workqueue *numa_pwq_tbl_install(struct workqueue_struct *wq,
3589 int node,
3590 struct pool_workqueue *pwq)
3591{
3592 struct pool_workqueue *old_pwq;
3593
3594 lockdep_assert_held(&wq_pool_mutex);
3595 lockdep_assert_held(&wq->mutex);
3596
3597
3598 link_pwq(pwq);
3599
3600 old_pwq = rcu_access_pointer(wq->numa_pwq_tbl[node]);
3601 rcu_assign_pointer(wq->numa_pwq_tbl[node], pwq);
3602 return old_pwq;
3603}
3604
3605
3606struct apply_wqattrs_ctx {
3607 struct workqueue_struct *wq;
3608 struct workqueue_attrs *attrs;
3609 struct list_head list;
3610 struct pool_workqueue *dfl_pwq;
3611 struct pool_workqueue *pwq_tbl[];
3612};
3613
3614
3615static void apply_wqattrs_cleanup(struct apply_wqattrs_ctx *ctx)
3616{
3617 if (ctx) {
3618 int node;
3619
3620 for_each_node(node)
3621 put_pwq_unlocked(ctx->pwq_tbl[node]);
3622 put_pwq_unlocked(ctx->dfl_pwq);
3623
3624 free_workqueue_attrs(ctx->attrs);
3625
3626 kfree(ctx);
3627 }
3628}
3629
3630
3631static struct apply_wqattrs_ctx *
3632apply_wqattrs_prepare(struct workqueue_struct *wq,
3633 const struct workqueue_attrs *attrs)
3634{
3635 struct apply_wqattrs_ctx *ctx;
3636 struct workqueue_attrs *new_attrs, *tmp_attrs;
3637 int node;
3638
3639 lockdep_assert_held(&wq_pool_mutex);
3640
3641 ctx = kzalloc(sizeof(*ctx) + nr_node_ids * sizeof(ctx->pwq_tbl[0]),
3642 GFP_KERNEL);
3643
3644 new_attrs = alloc_workqueue_attrs(GFP_KERNEL);
3645 tmp_attrs = alloc_workqueue_attrs(GFP_KERNEL);
3646 if (!ctx || !new_attrs || !tmp_attrs)
3647 goto out_free;
3648
3649
3650
3651
3652
3653
3654 copy_workqueue_attrs(new_attrs, attrs);
3655 cpumask_and(new_attrs->cpumask, new_attrs->cpumask, wq_unbound_cpumask);
3656 if (unlikely(cpumask_empty(new_attrs->cpumask)))
3657 cpumask_copy(new_attrs->cpumask, wq_unbound_cpumask);
3658
3659
3660
3661
3662
3663
3664 copy_workqueue_attrs(tmp_attrs, new_attrs);
3665
3666
3667
3668
3669
3670
3671 ctx->dfl_pwq = alloc_unbound_pwq(wq, new_attrs);
3672 if (!ctx->dfl_pwq)
3673 goto out_free;
3674
3675 for_each_node(node) {
3676 if (wq_calc_node_cpumask(new_attrs, node, -1, tmp_attrs->cpumask)) {
3677 ctx->pwq_tbl[node] = alloc_unbound_pwq(wq, tmp_attrs);
3678 if (!ctx->pwq_tbl[node])
3679 goto out_free;
3680 } else {
3681 ctx->dfl_pwq->refcnt++;
3682 ctx->pwq_tbl[node] = ctx->dfl_pwq;
3683 }
3684 }
3685
3686
3687 copy_workqueue_attrs(new_attrs, attrs);
3688 cpumask_and(new_attrs->cpumask, new_attrs->cpumask, cpu_possible_mask);
3689 ctx->attrs = new_attrs;
3690
3691 ctx->wq = wq;
3692 free_workqueue_attrs(tmp_attrs);
3693 return ctx;
3694
3695out_free:
3696 free_workqueue_attrs(tmp_attrs);
3697 free_workqueue_attrs(new_attrs);
3698 apply_wqattrs_cleanup(ctx);
3699 return NULL;
3700}
3701
3702
3703static void apply_wqattrs_commit(struct apply_wqattrs_ctx *ctx)
3704{
3705 int node;
3706
3707
3708 mutex_lock(&ctx->wq->mutex);
3709
3710 copy_workqueue_attrs(ctx->wq->unbound_attrs, ctx->attrs);
3711
3712
3713 for_each_node(node)
3714 ctx->pwq_tbl[node] = numa_pwq_tbl_install(ctx->wq, node,
3715 ctx->pwq_tbl[node]);
3716
3717
3718 link_pwq(ctx->dfl_pwq);
3719 swap(ctx->wq->dfl_pwq, ctx->dfl_pwq);
3720
3721 mutex_unlock(&ctx->wq->mutex);
3722}
3723
3724static void apply_wqattrs_lock(void)
3725{
3726
3727 get_online_cpus();
3728 mutex_lock(&wq_pool_mutex);
3729}
3730
3731static void apply_wqattrs_unlock(void)
3732{
3733 mutex_unlock(&wq_pool_mutex);
3734 put_online_cpus();
3735}
3736
3737static int apply_workqueue_attrs_locked(struct workqueue_struct *wq,
3738 const struct workqueue_attrs *attrs)
3739{
3740 struct apply_wqattrs_ctx *ctx;
3741
3742
3743 if (WARN_ON(!(wq->flags & WQ_UNBOUND)))
3744 return -EINVAL;
3745
3746
3747 if (WARN_ON((wq->flags & __WQ_ORDERED) && !list_empty(&wq->pwqs)))
3748 return -EINVAL;
3749
3750 ctx = apply_wqattrs_prepare(wq, attrs);
3751 if (!ctx)
3752 return -ENOMEM;
3753
3754
3755 apply_wqattrs_commit(ctx);
3756 apply_wqattrs_cleanup(ctx);
3757
3758 return 0;
3759}
3760
3761
3762
3763
3764
3765
3766
3767
3768
3769
3770
3771
3772
3773
3774
3775
3776
3777int apply_workqueue_attrs(struct workqueue_struct *wq,
3778 const struct workqueue_attrs *attrs)
3779{
3780 int ret;
3781
3782 apply_wqattrs_lock();
3783 ret = apply_workqueue_attrs_locked(wq, attrs);
3784 apply_wqattrs_unlock();
3785
3786 return ret;
3787}
3788
3789
3790
3791
3792
3793
3794
3795
3796
3797
3798
3799
3800
3801
3802
3803
3804
3805
3806
3807
3808
3809
3810
3811static void wq_update_unbound_numa(struct workqueue_struct *wq, int cpu,
3812 bool online)
3813{
3814 int node = cpu_to_node(cpu);
3815 int cpu_off = online ? -1 : cpu;
3816 struct pool_workqueue *old_pwq = NULL, *pwq;
3817 struct workqueue_attrs *target_attrs;
3818 cpumask_t *cpumask;
3819
3820 lockdep_assert_held(&wq_pool_mutex);
3821
3822 if (!wq_numa_enabled || !(wq->flags & WQ_UNBOUND) ||
3823 wq->unbound_attrs->no_numa)
3824 return;
3825
3826
3827
3828
3829
3830
3831 target_attrs = wq_update_unbound_numa_attrs_buf;
3832 cpumask = target_attrs->cpumask;
3833
3834 copy_workqueue_attrs(target_attrs, wq->unbound_attrs);
3835 pwq = unbound_pwq_by_node(wq, node);
3836
3837
3838
3839
3840
3841
3842
3843 if (wq_calc_node_cpumask(wq->dfl_pwq->pool->attrs, node, cpu_off, cpumask)) {
3844 if (cpumask_equal(cpumask, pwq->pool->attrs->cpumask))
3845 return;
3846 } else {
3847 goto use_dfl_pwq;
3848 }
3849
3850
3851 pwq = alloc_unbound_pwq(wq, target_attrs);
3852 if (!pwq) {
3853 pr_warn("workqueue: allocation failed while updating NUMA affinity of \"%s\"\n",
3854 wq->name);
3855 goto use_dfl_pwq;
3856 }
3857
3858
3859 mutex_lock(&wq->mutex);
3860 old_pwq = numa_pwq_tbl_install(wq, node, pwq);
3861 goto out_unlock;
3862
3863use_dfl_pwq:
3864 mutex_lock(&wq->mutex);
3865 spin_lock_irq(&wq->dfl_pwq->pool->lock);
3866 get_pwq(wq->dfl_pwq);
3867 spin_unlock_irq(&wq->dfl_pwq->pool->lock);
3868 old_pwq = numa_pwq_tbl_install(wq, node, wq->dfl_pwq);
3869out_unlock:
3870 mutex_unlock(&wq->mutex);
3871 put_pwq_unlocked(old_pwq);
3872}
3873
3874static int alloc_and_link_pwqs(struct workqueue_struct *wq)
3875{
3876 bool highpri = wq->flags & WQ_HIGHPRI;
3877 int cpu, ret;
3878
3879 if (!(wq->flags & WQ_UNBOUND)) {
3880 wq->cpu_pwqs = alloc_percpu(struct pool_workqueue);
3881 if (!wq->cpu_pwqs)
3882 return -ENOMEM;
3883
3884 for_each_possible_cpu(cpu) {
3885 struct pool_workqueue *pwq =
3886 per_cpu_ptr(wq->cpu_pwqs, cpu);
3887 struct worker_pool *cpu_pools =
3888 per_cpu(cpu_worker_pools, cpu);
3889
3890 init_pwq(pwq, wq, &cpu_pools[highpri]);
3891
3892 mutex_lock(&wq->mutex);
3893 link_pwq(pwq);
3894 mutex_unlock(&wq->mutex);
3895 }
3896 return 0;
3897 } else if (wq->flags & __WQ_ORDERED) {
3898 ret = apply_workqueue_attrs(wq, ordered_wq_attrs[highpri]);
3899
3900 WARN(!ret && (wq->pwqs.next != &wq->dfl_pwq->pwqs_node ||
3901 wq->pwqs.prev != &wq->dfl_pwq->pwqs_node),
3902 "ordering guarantee broken for workqueue %s\n", wq->name);
3903 return ret;
3904 } else {
3905 return apply_workqueue_attrs(wq, unbound_std_wq_attrs[highpri]);
3906 }
3907}
3908
3909static int wq_clamp_max_active(int max_active, unsigned int flags,
3910 const char *name)
3911{
3912 int lim = flags & WQ_UNBOUND ? WQ_UNBOUND_MAX_ACTIVE : WQ_MAX_ACTIVE;
3913
3914 if (max_active < 1 || max_active > lim)
3915 pr_warn("workqueue: max_active %d requested for %s is out of range, clamping between %d and %d\n",
3916 max_active, name, 1, lim);
3917
3918 return clamp_val(max_active, 1, lim);
3919}
3920
3921struct workqueue_struct *__alloc_workqueue_key(const char *fmt,
3922 unsigned int flags,
3923 int max_active,
3924 struct lock_class_key *key,
3925 const char *lock_name, ...)
3926{
3927 size_t tbl_size = 0;
3928 va_list args;
3929 struct workqueue_struct *wq;
3930 struct pool_workqueue *pwq;
3931
3932
3933 if ((flags & WQ_POWER_EFFICIENT) && wq_power_efficient)
3934 flags |= WQ_UNBOUND;
3935
3936
3937 if (flags & WQ_UNBOUND)
3938 tbl_size = nr_node_ids * sizeof(wq->numa_pwq_tbl[0]);
3939
3940 wq = kzalloc(sizeof(*wq) + tbl_size, GFP_KERNEL);
3941 if (!wq)
3942 return NULL;
3943
3944 if (flags & WQ_UNBOUND) {
3945 wq->unbound_attrs = alloc_workqueue_attrs(GFP_KERNEL);
3946 if (!wq->unbound_attrs)
3947 goto err_free_wq;
3948 }
3949
3950 va_start(args, lock_name);
3951 vsnprintf(wq->name, sizeof(wq->name), fmt, args);
3952 va_end(args);
3953
3954 max_active = max_active ?: WQ_DFL_ACTIVE;
3955 max_active = wq_clamp_max_active(max_active, flags, wq->name);
3956
3957
3958 wq->flags = flags;
3959 wq->saved_max_active = max_active;
3960 mutex_init(&wq->mutex);
3961 atomic_set(&wq->nr_pwqs_to_flush, 0);
3962 INIT_LIST_HEAD(&wq->pwqs);
3963 INIT_LIST_HEAD(&wq->flusher_queue);
3964 INIT_LIST_HEAD(&wq->flusher_overflow);
3965 INIT_LIST_HEAD(&wq->maydays);
3966
3967 lockdep_init_map(&wq->lockdep_map, lock_name, key, 0);
3968 INIT_LIST_HEAD(&wq->list);
3969
3970 if (alloc_and_link_pwqs(wq) < 0)
3971 goto err_free_wq;
3972
3973
3974
3975
3976
3977 if (flags & WQ_MEM_RECLAIM) {
3978 struct worker *rescuer;
3979
3980 rescuer = alloc_worker(NUMA_NO_NODE);
3981 if (!rescuer)
3982 goto err_destroy;
3983
3984 rescuer->rescue_wq = wq;
3985 rescuer->task = kthread_create(rescuer_thread, rescuer, "%s",
3986 wq->name);
3987 if (IS_ERR(rescuer->task)) {
3988 kfree(rescuer);
3989 goto err_destroy;
3990 }
3991
3992 wq->rescuer = rescuer;
3993 kthread_bind_mask(rescuer->task, cpu_possible_mask);
3994 wake_up_process(rescuer->task);
3995 }
3996
3997 if ((wq->flags & WQ_SYSFS) && workqueue_sysfs_register(wq))
3998 goto err_destroy;
3999
4000
4001
4002
4003
4004
4005 mutex_lock(&wq_pool_mutex);
4006
4007 mutex_lock(&wq->mutex);
4008 for_each_pwq(pwq, wq)
4009 pwq_adjust_max_active(pwq);
4010 mutex_unlock(&wq->mutex);
4011
4012 list_add_tail_rcu(&wq->list, &workqueues);
4013
4014 mutex_unlock(&wq_pool_mutex);
4015
4016 return wq;
4017
4018err_free_wq:
4019 free_workqueue_attrs(wq->unbound_attrs);
4020 kfree(wq);
4021 return NULL;
4022err_destroy:
4023 destroy_workqueue(wq);
4024 return NULL;
4025}
4026EXPORT_SYMBOL_GPL(__alloc_workqueue_key);
4027
4028
4029
4030
4031
4032
4033
4034void destroy_workqueue(struct workqueue_struct *wq)
4035{
4036 struct pool_workqueue *pwq;
4037 int node;
4038
4039
4040 drain_workqueue(wq);
4041
4042
4043 mutex_lock(&wq->mutex);
4044 for_each_pwq(pwq, wq) {
4045 int i;
4046
4047 for (i = 0; i < WORK_NR_COLORS; i++) {
4048 if (WARN_ON(pwq->nr_in_flight[i])) {
4049 mutex_unlock(&wq->mutex);
4050 return;
4051 }
4052 }
4053
4054 if (WARN_ON((pwq != wq->dfl_pwq) && (pwq->refcnt > 1)) ||
4055 WARN_ON(pwq->nr_active) ||
4056 WARN_ON(!list_empty(&pwq->delayed_works))) {
4057 mutex_unlock(&wq->mutex);
4058 return;
4059 }
4060 }
4061 mutex_unlock(&wq->mutex);
4062
4063
4064
4065
4066
4067 mutex_lock(&wq_pool_mutex);
4068 list_del_rcu(&wq->list);
4069 mutex_unlock(&wq_pool_mutex);
4070
4071 workqueue_sysfs_unregister(wq);
4072
4073 if (wq->rescuer)
4074 kthread_stop(wq->rescuer->task);
4075
4076 if (!(wq->flags & WQ_UNBOUND)) {
4077
4078
4079
4080
4081 call_rcu_sched(&wq->rcu, rcu_free_wq);
4082 } else {
4083
4084
4085
4086
4087
4088 for_each_node(node) {
4089 pwq = rcu_access_pointer(wq->numa_pwq_tbl[node]);
4090 RCU_INIT_POINTER(wq->numa_pwq_tbl[node], NULL);
4091 put_pwq_unlocked(pwq);
4092 }
4093
4094
4095
4096
4097
4098 pwq = wq->dfl_pwq;
4099 wq->dfl_pwq = NULL;
4100 put_pwq_unlocked(pwq);
4101 }
4102}
4103EXPORT_SYMBOL_GPL(destroy_workqueue);
4104
4105
4106
4107
4108
4109
4110
4111
4112
4113
4114
4115void workqueue_set_max_active(struct workqueue_struct *wq, int max_active)
4116{
4117 struct pool_workqueue *pwq;
4118
4119
4120 if (WARN_ON(wq->flags & __WQ_ORDERED))
4121 return;
4122
4123 max_active = wq_clamp_max_active(max_active, wq->flags, wq->name);
4124
4125 mutex_lock(&wq->mutex);
4126
4127 wq->saved_max_active = max_active;
4128
4129 for_each_pwq(pwq, wq)
4130 pwq_adjust_max_active(pwq);
4131
4132 mutex_unlock(&wq->mutex);
4133}
4134EXPORT_SYMBOL_GPL(workqueue_set_max_active);
4135
4136
4137
4138
4139
4140
4141
4142
4143
4144bool current_is_workqueue_rescuer(void)
4145{
4146 struct worker *worker = current_wq_worker();
4147
4148 return worker && worker->rescue_wq;
4149}
4150
4151
4152
4153
4154
4155
4156
4157
4158
4159
4160
4161
4162
4163
4164
4165
4166
4167
4168
4169bool workqueue_congested(int cpu, struct workqueue_struct *wq)
4170{
4171 struct pool_workqueue *pwq;
4172 bool ret;
4173
4174 rcu_read_lock_sched();
4175
4176 if (cpu == WORK_CPU_UNBOUND)
4177 cpu = smp_processor_id();
4178
4179 if (!(wq->flags & WQ_UNBOUND))
4180 pwq = per_cpu_ptr(wq->cpu_pwqs, cpu);
4181 else
4182 pwq = unbound_pwq_by_node(wq, cpu_to_node(cpu));
4183
4184 ret = !list_empty(&pwq->delayed_works);
4185 rcu_read_unlock_sched();
4186
4187 return ret;
4188}
4189EXPORT_SYMBOL_GPL(workqueue_congested);
4190
4191
4192
4193
4194
4195
4196
4197
4198
4199
4200
4201
4202unsigned int work_busy(struct work_struct *work)
4203{
4204 struct worker_pool *pool;
4205 unsigned long flags;
4206 unsigned int ret = 0;
4207
4208 if (work_pending(work))
4209 ret |= WORK_BUSY_PENDING;
4210
4211 local_irq_save(flags);
4212 pool = get_work_pool(work);
4213 if (pool) {
4214 spin_lock(&pool->lock);
4215 if (find_worker_executing_work(pool, work))
4216 ret |= WORK_BUSY_RUNNING;
4217 spin_unlock(&pool->lock);
4218 }
4219 local_irq_restore(flags);
4220
4221 return ret;
4222}
4223EXPORT_SYMBOL_GPL(work_busy);
4224
4225
4226
4227
4228
4229
4230
4231
4232
4233
4234
4235void set_worker_desc(const char *fmt, ...)
4236{
4237 struct worker *worker = current_wq_worker();
4238 va_list args;
4239
4240 if (worker) {
4241 va_start(args, fmt);
4242 vsnprintf(worker->desc, sizeof(worker->desc), fmt, args);
4243 va_end(args);
4244 worker->desc_valid = true;
4245 }
4246}
4247
4248
4249
4250
4251
4252
4253
4254
4255
4256
4257
4258
4259
4260
4261void print_worker_info(const char *log_lvl, struct task_struct *task)
4262{
4263 work_func_t *fn = NULL;
4264 char name[WQ_NAME_LEN] = { };
4265 char desc[WORKER_DESC_LEN] = { };
4266 struct pool_workqueue *pwq = NULL;
4267 struct workqueue_struct *wq = NULL;
4268 bool desc_valid = false;
4269 struct worker *worker;
4270
4271 if (!(task->flags & PF_WQ_WORKER))
4272 return;
4273
4274
4275
4276
4277
4278 worker = probe_kthread_data(task);
4279
4280
4281
4282
4283
4284 probe_kernel_read(&fn, &worker->current_func, sizeof(fn));
4285 probe_kernel_read(&pwq, &worker->current_pwq, sizeof(pwq));
4286 probe_kernel_read(&wq, &pwq->wq, sizeof(wq));
4287 probe_kernel_read(name, wq->name, sizeof(name) - 1);
4288
4289
4290 probe_kernel_read(&desc_valid, &worker->desc_valid, sizeof(desc_valid));
4291 if (desc_valid)
4292 probe_kernel_read(desc, worker->desc, sizeof(desc) - 1);
4293
4294 if (fn || name[0] || desc[0]) {
4295 printk("%sWorkqueue: %s %pf", log_lvl, name, fn);
4296 if (desc[0])
4297 pr_cont(" (%s)", desc);
4298 pr_cont("\n");
4299 }
4300}
4301
4302static void pr_cont_pool_info(struct worker_pool *pool)
4303{
4304 pr_cont(" cpus=%*pbl", nr_cpumask_bits, pool->attrs->cpumask);
4305 if (pool->node != NUMA_NO_NODE)
4306 pr_cont(" node=%d", pool->node);
4307 pr_cont(" flags=0x%x nice=%d", pool->flags, pool->attrs->nice);
4308}
4309
4310static void pr_cont_work(bool comma, struct work_struct *work)
4311{
4312 if (work->func == wq_barrier_func) {
4313 struct wq_barrier *barr;
4314
4315 barr = container_of(work, struct wq_barrier, work);
4316
4317 pr_cont("%s BAR(%d)", comma ? "," : "",
4318 task_pid_nr(barr->task));
4319 } else {
4320 pr_cont("%s %pf", comma ? "," : "", work->func);
4321 }
4322}
4323
4324static void show_pwq(struct pool_workqueue *pwq)
4325{
4326 struct worker_pool *pool = pwq->pool;
4327 struct work_struct *work;
4328 struct worker *worker;
4329 bool has_in_flight = false, has_pending = false;
4330 int bkt;
4331
4332 pr_info(" pwq %d:", pool->id);
4333 pr_cont_pool_info(pool);
4334
4335 pr_cont(" active=%d/%d%s\n", pwq->nr_active, pwq->max_active,
4336 !list_empty(&pwq->mayday_node) ? " MAYDAY" : "");
4337
4338 hash_for_each(pool->busy_hash, bkt, worker, hentry) {
4339 if (worker->current_pwq == pwq) {
4340 has_in_flight = true;
4341 break;
4342 }
4343 }
4344 if (has_in_flight) {
4345 bool comma = false;
4346
4347 pr_info(" in-flight:");
4348 hash_for_each(pool->busy_hash, bkt, worker, hentry) {
4349 if (worker->current_pwq != pwq)
4350 continue;
4351
4352 pr_cont("%s %d%s:%pf", comma ? "," : "",
4353 task_pid_nr(worker->task),
4354 worker == pwq->wq->rescuer ? "(RESCUER)" : "",
4355 worker->current_func);
4356 list_for_each_entry(work, &worker->scheduled, entry)
4357 pr_cont_work(false, work);
4358 comma = true;
4359 }
4360 pr_cont("\n");
4361 }
4362
4363 list_for_each_entry(work, &pool->worklist, entry) {
4364 if (get_work_pwq(work) == pwq) {
4365 has_pending = true;
4366 break;
4367 }
4368 }
4369 if (has_pending) {
4370 bool comma = false;
4371
4372 pr_info(" pending:");
4373 list_for_each_entry(work, &pool->worklist, entry) {
4374 if (get_work_pwq(work) != pwq)
4375 continue;
4376
4377 pr_cont_work(comma, work);
4378 comma = !(*work_data_bits(work) & WORK_STRUCT_LINKED);
4379 }
4380 pr_cont("\n");
4381 }
4382
4383 if (!list_empty(&pwq->delayed_works)) {
4384 bool comma = false;
4385
4386 pr_info(" delayed:");
4387 list_for_each_entry(work, &pwq->delayed_works, entry) {
4388 pr_cont_work(comma, work);
4389 comma = !(*work_data_bits(work) & WORK_STRUCT_LINKED);
4390 }
4391 pr_cont("\n");
4392 }
4393}
4394
4395
4396
4397
4398
4399
4400
4401void show_workqueue_state(void)
4402{
4403 struct workqueue_struct *wq;
4404 struct worker_pool *pool;
4405 unsigned long flags;
4406 int pi;
4407
4408 rcu_read_lock_sched();
4409
4410 pr_info("Showing busy workqueues and worker pools:\n");
4411
4412 list_for_each_entry_rcu(wq, &workqueues, list) {
4413 struct pool_workqueue *pwq;
4414 bool idle = true;
4415
4416 for_each_pwq(pwq, wq) {
4417 if (pwq->nr_active || !list_empty(&pwq->delayed_works)) {
4418 idle = false;
4419 break;
4420 }
4421 }
4422 if (idle)
4423 continue;
4424
4425 pr_info("workqueue %s: flags=0x%x\n", wq->name, wq->flags);
4426
4427 for_each_pwq(pwq, wq) {
4428 spin_lock_irqsave(&pwq->pool->lock, flags);
4429 if (pwq->nr_active || !list_empty(&pwq->delayed_works))
4430 show_pwq(pwq);
4431 spin_unlock_irqrestore(&pwq->pool->lock, flags);
4432 }
4433 }
4434
4435 for_each_pool(pool, pi) {
4436 struct worker *worker;
4437 bool first = true;
4438
4439 spin_lock_irqsave(&pool->lock, flags);
4440 if (pool->nr_workers == pool->nr_idle)
4441 goto next_pool;
4442
4443 pr_info("pool %d:", pool->id);
4444 pr_cont_pool_info(pool);
4445 pr_cont(" hung=%us workers=%d",
4446 jiffies_to_msecs(jiffies - pool->watchdog_ts) / 1000,
4447 pool->nr_workers);
4448 if (pool->manager)
4449 pr_cont(" manager: %d",
4450 task_pid_nr(pool->manager->task));
4451 list_for_each_entry(worker, &pool->idle_list, entry) {
4452 pr_cont(" %s%d", first ? "idle: " : "",
4453 task_pid_nr(worker->task));
4454 first = false;
4455 }
4456 pr_cont("\n");
4457 next_pool:
4458 spin_unlock_irqrestore(&pool->lock, flags);
4459 }
4460
4461 rcu_read_unlock_sched();
4462}
4463
4464
4465
4466
4467
4468
4469
4470
4471
4472
4473
4474
4475
4476
4477
4478
4479static void wq_unbind_fn(struct work_struct *work)
4480{
4481 int cpu = smp_processor_id();
4482 struct worker_pool *pool;
4483 struct worker *worker;
4484
4485 for_each_cpu_worker_pool(pool, cpu) {
4486 mutex_lock(&pool->attach_mutex);
4487 spin_lock_irq(&pool->lock);
4488
4489
4490
4491
4492
4493
4494
4495
4496 for_each_pool_worker(worker, pool)
4497 worker->flags |= WORKER_UNBOUND;
4498
4499 pool->flags |= POOL_DISASSOCIATED;
4500
4501 spin_unlock_irq(&pool->lock);
4502 mutex_unlock(&pool->attach_mutex);
4503
4504
4505
4506
4507
4508
4509
4510 schedule();
4511
4512
4513
4514
4515
4516
4517
4518
4519
4520 atomic_set(&pool->nr_running, 0);
4521
4522
4523
4524
4525
4526
4527 spin_lock_irq(&pool->lock);
4528 wake_up_worker(pool);
4529 spin_unlock_irq(&pool->lock);
4530 }
4531}
4532
4533
4534
4535
4536
4537
4538
4539static void rebind_workers(struct worker_pool *pool)
4540{
4541 struct worker *worker;
4542
4543 lockdep_assert_held(&pool->attach_mutex);
4544
4545
4546
4547
4548
4549
4550
4551
4552 for_each_pool_worker(worker, pool)
4553 WARN_ON_ONCE(set_cpus_allowed_ptr(worker->task,
4554 pool->attrs->cpumask) < 0);
4555
4556 spin_lock_irq(&pool->lock);
4557
4558
4559
4560
4561
4562
4563 if (!(pool->flags & POOL_DISASSOCIATED)) {
4564 spin_unlock_irq(&pool->lock);
4565 return;
4566 }
4567
4568 pool->flags &= ~POOL_DISASSOCIATED;
4569
4570 for_each_pool_worker(worker, pool) {
4571 unsigned int worker_flags = worker->flags;
4572
4573
4574
4575
4576
4577
4578
4579
4580
4581 if (worker_flags & WORKER_IDLE)
4582 wake_up_process(worker->task);
4583
4584
4585
4586
4587
4588
4589
4590
4591
4592
4593
4594
4595
4596
4597
4598
4599 WARN_ON_ONCE(!(worker_flags & WORKER_UNBOUND));
4600 worker_flags |= WORKER_REBOUND;
4601 worker_flags &= ~WORKER_UNBOUND;
4602 ACCESS_ONCE(worker->flags) = worker_flags;
4603 }
4604
4605 spin_unlock_irq(&pool->lock);
4606}
4607
4608
4609
4610
4611
4612
4613
4614
4615
4616
4617
4618static void restore_unbound_workers_cpumask(struct worker_pool *pool, int cpu)
4619{
4620 static cpumask_t cpumask;
4621 struct worker *worker;
4622
4623 lockdep_assert_held(&pool->attach_mutex);
4624
4625
4626 if (!cpumask_test_cpu(cpu, pool->attrs->cpumask))
4627 return;
4628
4629
4630 cpumask_and(&cpumask, pool->attrs->cpumask, cpu_online_mask);
4631 if (cpumask_weight(&cpumask) != 1)
4632 return;
4633
4634
4635 for_each_pool_worker(worker, pool)
4636 WARN_ON_ONCE(set_cpus_allowed_ptr(worker->task,
4637 pool->attrs->cpumask) < 0);
4638}
4639
4640
4641
4642
4643
4644static int workqueue_cpu_up_callback(struct notifier_block *nfb,
4645 unsigned long action,
4646 void *hcpu)
4647{
4648 int cpu = (unsigned long)hcpu;
4649 struct worker_pool *pool;
4650 struct workqueue_struct *wq;
4651 int pi;
4652
4653 switch (action & ~CPU_TASKS_FROZEN) {
4654 case CPU_UP_PREPARE:
4655 for_each_cpu_worker_pool(pool, cpu) {
4656 if (pool->nr_workers)
4657 continue;
4658 if (!create_worker(pool))
4659 return NOTIFY_BAD;
4660 }
4661 break;
4662
4663 case CPU_DOWN_FAILED:
4664 case CPU_ONLINE:
4665 mutex_lock(&wq_pool_mutex);
4666
4667 for_each_pool(pool, pi) {
4668 mutex_lock(&pool->attach_mutex);
4669
4670 if (pool->cpu == cpu)
4671 rebind_workers(pool);
4672 else if (pool->cpu < 0)
4673 restore_unbound_workers_cpumask(pool, cpu);
4674
4675 mutex_unlock(&pool->attach_mutex);
4676 }
4677
4678
4679 list_for_each_entry(wq, &workqueues, list)
4680 wq_update_unbound_numa(wq, cpu, true);
4681
4682 mutex_unlock(&wq_pool_mutex);
4683 break;
4684 }
4685 return NOTIFY_OK;
4686}
4687
4688
4689
4690
4691
4692static int workqueue_cpu_down_callback(struct notifier_block *nfb,
4693 unsigned long action,
4694 void *hcpu)
4695{
4696 int cpu = (unsigned long)hcpu;
4697 struct work_struct unbind_work;
4698 struct workqueue_struct *wq;
4699
4700 switch (action & ~CPU_TASKS_FROZEN) {
4701 case CPU_DOWN_PREPARE:
4702
4703 INIT_WORK_ONSTACK(&unbind_work, wq_unbind_fn);
4704 queue_work_on(cpu, system_highpri_wq, &unbind_work);
4705
4706
4707 mutex_lock(&wq_pool_mutex);
4708 list_for_each_entry(wq, &workqueues, list)
4709 wq_update_unbound_numa(wq, cpu, false);
4710 mutex_unlock(&wq_pool_mutex);
4711
4712
4713 flush_work(&unbind_work);
4714 destroy_work_on_stack(&unbind_work);
4715 break;
4716 }
4717 return NOTIFY_OK;
4718}
4719
4720#ifdef CONFIG_SMP
4721
4722struct work_for_cpu {
4723 struct work_struct work;
4724 long (*fn)(void *);
4725 void *arg;
4726 long ret;
4727};
4728
4729static void work_for_cpu_fn(struct work_struct *work)
4730{
4731 struct work_for_cpu *wfc = container_of(work, struct work_for_cpu, work);
4732
4733 wfc->ret = wfc->fn(wfc->arg);
4734}
4735
4736
4737
4738
4739
4740
4741
4742
4743
4744
4745
4746
4747long work_on_cpu(int cpu, long (*fn)(void *), void *arg)
4748{
4749 struct work_for_cpu wfc = { .fn = fn, .arg = arg };
4750
4751 INIT_WORK_ONSTACK(&wfc.work, work_for_cpu_fn);
4752 schedule_work_on(cpu, &wfc.work);
4753 flush_work(&wfc.work);
4754 destroy_work_on_stack(&wfc.work);
4755 return wfc.ret;
4756}
4757EXPORT_SYMBOL_GPL(work_on_cpu);
4758#endif
4759
4760#ifdef CONFIG_FREEZER
4761
4762
4763
4764
4765
4766
4767
4768
4769
4770
4771
4772void freeze_workqueues_begin(void)
4773{
4774 struct workqueue_struct *wq;
4775 struct pool_workqueue *pwq;
4776
4777 mutex_lock(&wq_pool_mutex);
4778
4779 WARN_ON_ONCE(workqueue_freezing);
4780 workqueue_freezing = true;
4781
4782 list_for_each_entry(wq, &workqueues, list) {
4783 mutex_lock(&wq->mutex);
4784 for_each_pwq(pwq, wq)
4785 pwq_adjust_max_active(pwq);
4786 mutex_unlock(&wq->mutex);
4787 }
4788
4789 mutex_unlock(&wq_pool_mutex);
4790}
4791
4792
4793
4794
4795
4796
4797
4798
4799
4800
4801
4802
4803
4804
4805bool freeze_workqueues_busy(void)
4806{
4807 bool busy = false;
4808 struct workqueue_struct *wq;
4809 struct pool_workqueue *pwq;
4810
4811 mutex_lock(&wq_pool_mutex);
4812
4813 WARN_ON_ONCE(!workqueue_freezing);
4814
4815 list_for_each_entry(wq, &workqueues, list) {
4816 if (!(wq->flags & WQ_FREEZABLE))
4817 continue;
4818
4819
4820
4821
4822 rcu_read_lock_sched();
4823 for_each_pwq(pwq, wq) {
4824 WARN_ON_ONCE(pwq->nr_active < 0);
4825 if (pwq->nr_active) {
4826 busy = true;
4827 rcu_read_unlock_sched();
4828 goto out_unlock;
4829 }
4830 }
4831 rcu_read_unlock_sched();
4832 }
4833out_unlock:
4834 mutex_unlock(&wq_pool_mutex);
4835 return busy;
4836}
4837
4838
4839
4840
4841
4842
4843
4844
4845
4846
4847void thaw_workqueues(void)
4848{
4849 struct workqueue_struct *wq;
4850 struct pool_workqueue *pwq;
4851
4852 mutex_lock(&wq_pool_mutex);
4853
4854 if (!workqueue_freezing)
4855 goto out_unlock;
4856
4857 workqueue_freezing = false;
4858
4859
4860 list_for_each_entry(wq, &workqueues, list) {
4861 mutex_lock(&wq->mutex);
4862 for_each_pwq(pwq, wq)
4863 pwq_adjust_max_active(pwq);
4864 mutex_unlock(&wq->mutex);
4865 }
4866
4867out_unlock:
4868 mutex_unlock(&wq_pool_mutex);
4869}
4870#endif
4871
4872static int workqueue_apply_unbound_cpumask(void)
4873{
4874 LIST_HEAD(ctxs);
4875 int ret = 0;
4876 struct workqueue_struct *wq;
4877 struct apply_wqattrs_ctx *ctx, *n;
4878
4879 lockdep_assert_held(&wq_pool_mutex);
4880
4881 list_for_each_entry(wq, &workqueues, list) {
4882 if (!(wq->flags & WQ_UNBOUND))
4883 continue;
4884
4885 if (wq->flags & __WQ_ORDERED)
4886 continue;
4887
4888 ctx = apply_wqattrs_prepare(wq, wq->unbound_attrs);
4889 if (!ctx) {
4890 ret = -ENOMEM;
4891 break;
4892 }
4893
4894 list_add_tail(&ctx->list, &ctxs);
4895 }
4896
4897 list_for_each_entry_safe(ctx, n, &ctxs, list) {
4898 if (!ret)
4899 apply_wqattrs_commit(ctx);
4900 apply_wqattrs_cleanup(ctx);
4901 }
4902
4903 return ret;
4904}
4905
4906
4907
4908
4909
4910
4911
4912
4913
4914
4915
4916
4917
4918int workqueue_set_unbound_cpumask(cpumask_var_t cpumask)
4919{
4920 int ret = -EINVAL;
4921 cpumask_var_t saved_cpumask;
4922
4923 if (!zalloc_cpumask_var(&saved_cpumask, GFP_KERNEL))
4924 return -ENOMEM;
4925
4926 cpumask_and(cpumask, cpumask, cpu_possible_mask);
4927 if (!cpumask_empty(cpumask)) {
4928 apply_wqattrs_lock();
4929
4930
4931 cpumask_copy(saved_cpumask, wq_unbound_cpumask);
4932
4933
4934 cpumask_copy(wq_unbound_cpumask, cpumask);
4935 ret = workqueue_apply_unbound_cpumask();
4936
4937
4938 if (ret < 0)
4939 cpumask_copy(wq_unbound_cpumask, saved_cpumask);
4940
4941 apply_wqattrs_unlock();
4942 }
4943
4944 free_cpumask_var(saved_cpumask);
4945 return ret;
4946}
4947
4948#ifdef CONFIG_SYSFS
4949
4950
4951
4952
4953
4954
4955
4956
4957
4958
4959
4960
4961
4962
4963struct wq_device {
4964 struct workqueue_struct *wq;
4965 struct device dev;
4966};
4967
4968static struct workqueue_struct *dev_to_wq(struct device *dev)
4969{
4970 struct wq_device *wq_dev = container_of(dev, struct wq_device, dev);
4971
4972 return wq_dev->wq;
4973}
4974
4975static ssize_t per_cpu_show(struct device *dev, struct device_attribute *attr,
4976 char *buf)
4977{
4978 struct workqueue_struct *wq = dev_to_wq(dev);
4979
4980 return scnprintf(buf, PAGE_SIZE, "%d\n", (bool)!(wq->flags & WQ_UNBOUND));
4981}
4982static DEVICE_ATTR_RO(per_cpu);
4983
4984static ssize_t max_active_show(struct device *dev,
4985 struct device_attribute *attr, char *buf)
4986{
4987 struct workqueue_struct *wq = dev_to_wq(dev);
4988
4989 return scnprintf(buf, PAGE_SIZE, "%d\n", wq->saved_max_active);
4990}
4991
4992static ssize_t max_active_store(struct device *dev,
4993 struct device_attribute *attr, const char *buf,
4994 size_t count)
4995{
4996 struct workqueue_struct *wq = dev_to_wq(dev);
4997 int val;
4998
4999 if (sscanf(buf, "%d", &val) != 1 || val <= 0)
5000 return -EINVAL;
5001
5002 workqueue_set_max_active(wq, val);
5003 return count;
5004}
5005static DEVICE_ATTR_RW(max_active);
5006
5007static struct attribute *wq_sysfs_attrs[] = {
5008 &dev_attr_per_cpu.attr,
5009 &dev_attr_max_active.attr,
5010 NULL,
5011};
5012ATTRIBUTE_GROUPS(wq_sysfs);
5013
5014static ssize_t wq_pool_ids_show(struct device *dev,
5015 struct device_attribute *attr, char *buf)
5016{
5017 struct workqueue_struct *wq = dev_to_wq(dev);
5018 const char *delim = "";
5019 int node, written = 0;
5020
5021 rcu_read_lock_sched();
5022 for_each_node(node) {
5023 written += scnprintf(buf + written, PAGE_SIZE - written,
5024 "%s%d:%d", delim, node,
5025 unbound_pwq_by_node(wq, node)->pool->id);
5026 delim = " ";
5027 }
5028 written += scnprintf(buf + written, PAGE_SIZE - written, "\n");
5029 rcu_read_unlock_sched();
5030
5031 return written;
5032}
5033
5034static ssize_t wq_nice_show(struct device *dev, struct device_attribute *attr,
5035 char *buf)
5036{
5037 struct workqueue_struct *wq = dev_to_wq(dev);
5038 int written;
5039
5040 mutex_lock(&wq->mutex);
5041 written = scnprintf(buf, PAGE_SIZE, "%d\n", wq->unbound_attrs->nice);
5042 mutex_unlock(&wq->mutex);
5043
5044 return written;
5045}
5046
5047
5048static struct workqueue_attrs *wq_sysfs_prep_attrs(struct workqueue_struct *wq)
5049{
5050 struct workqueue_attrs *attrs;
5051
5052 lockdep_assert_held(&wq_pool_mutex);
5053
5054 attrs = alloc_workqueue_attrs(GFP_KERNEL);
5055 if (!attrs)
5056 return NULL;
5057
5058 copy_workqueue_attrs(attrs, wq->unbound_attrs);
5059 return attrs;
5060}
5061
5062static ssize_t wq_nice_store(struct device *dev, struct device_attribute *attr,
5063 const char *buf, size_t count)
5064{
5065 struct workqueue_struct *wq = dev_to_wq(dev);
5066 struct workqueue_attrs *attrs;
5067 int ret = -ENOMEM;
5068
5069 apply_wqattrs_lock();
5070
5071 attrs = wq_sysfs_prep_attrs(wq);
5072 if (!attrs)
5073 goto out_unlock;
5074
5075 if (sscanf(buf, "%d", &attrs->nice) == 1 &&
5076 attrs->nice >= MIN_NICE && attrs->nice <= MAX_NICE)
5077 ret = apply_workqueue_attrs_locked(wq, attrs);
5078 else
5079 ret = -EINVAL;
5080
5081out_unlock:
5082 apply_wqattrs_unlock();
5083 free_workqueue_attrs(attrs);
5084 return ret ?: count;
5085}
5086
5087static ssize_t wq_cpumask_show(struct device *dev,
5088 struct device_attribute *attr, char *buf)
5089{
5090 struct workqueue_struct *wq = dev_to_wq(dev);
5091 int written;
5092
5093 mutex_lock(&wq->mutex);
5094 written = scnprintf(buf, PAGE_SIZE, "%*pb\n",
5095 cpumask_pr_args(wq->unbound_attrs->cpumask));
5096 mutex_unlock(&wq->mutex);
5097 return written;
5098}
5099
5100static ssize_t wq_cpumask_store(struct device *dev,
5101 struct device_attribute *attr,
5102 const char *buf, size_t count)
5103{
5104 struct workqueue_struct *wq = dev_to_wq(dev);
5105 struct workqueue_attrs *attrs;
5106 int ret = -ENOMEM;
5107
5108 apply_wqattrs_lock();
5109
5110 attrs = wq_sysfs_prep_attrs(wq);
5111 if (!attrs)
5112 goto out_unlock;
5113
5114 ret = cpumask_parse(buf, attrs->cpumask);
5115 if (!ret)
5116 ret = apply_workqueue_attrs_locked(wq, attrs);
5117
5118out_unlock:
5119 apply_wqattrs_unlock();
5120 free_workqueue_attrs(attrs);
5121 return ret ?: count;
5122}
5123
5124static ssize_t wq_numa_show(struct device *dev, struct device_attribute *attr,
5125 char *buf)
5126{
5127 struct workqueue_struct *wq = dev_to_wq(dev);
5128 int written;
5129
5130 mutex_lock(&wq->mutex);
5131 written = scnprintf(buf, PAGE_SIZE, "%d\n",
5132 !wq->unbound_attrs->no_numa);
5133 mutex_unlock(&wq->mutex);
5134
5135 return written;
5136}
5137
5138static ssize_t wq_numa_store(struct device *dev, struct device_attribute *attr,
5139 const char *buf, size_t count)
5140{
5141 struct workqueue_struct *wq = dev_to_wq(dev);
5142 struct workqueue_attrs *attrs;
5143 int v, ret = -ENOMEM;
5144
5145 apply_wqattrs_lock();
5146
5147 attrs = wq_sysfs_prep_attrs(wq);
5148 if (!attrs)
5149 goto out_unlock;
5150
5151 ret = -EINVAL;
5152 if (sscanf(buf, "%d", &v) == 1) {
5153 attrs->no_numa = !v;
5154 ret = apply_workqueue_attrs_locked(wq, attrs);
5155 }
5156
5157out_unlock:
5158 apply_wqattrs_unlock();
5159 free_workqueue_attrs(attrs);
5160 return ret ?: count;
5161}
5162
5163static struct device_attribute wq_sysfs_unbound_attrs[] = {
5164 __ATTR(pool_ids, 0444, wq_pool_ids_show, NULL),
5165 __ATTR(nice, 0644, wq_nice_show, wq_nice_store),
5166 __ATTR(cpumask, 0644, wq_cpumask_show, wq_cpumask_store),
5167 __ATTR(numa, 0644, wq_numa_show, wq_numa_store),
5168 __ATTR_NULL,
5169};
5170
5171static struct bus_type wq_subsys = {
5172 .name = "workqueue",
5173 .dev_groups = wq_sysfs_groups,
5174};
5175
5176static ssize_t wq_unbound_cpumask_show(struct device *dev,
5177 struct device_attribute *attr, char *buf)
5178{
5179 int written;
5180
5181 mutex_lock(&wq_pool_mutex);
5182 written = scnprintf(buf, PAGE_SIZE, "%*pb\n",
5183 cpumask_pr_args(wq_unbound_cpumask));
5184 mutex_unlock(&wq_pool_mutex);
5185
5186 return written;
5187}
5188
5189static ssize_t wq_unbound_cpumask_store(struct device *dev,
5190 struct device_attribute *attr, const char *buf, size_t count)
5191{
5192 cpumask_var_t cpumask;
5193 int ret;
5194
5195 if (!zalloc_cpumask_var(&cpumask, GFP_KERNEL))
5196 return -ENOMEM;
5197
5198 ret = cpumask_parse(buf, cpumask);
5199 if (!ret)
5200 ret = workqueue_set_unbound_cpumask(cpumask);
5201
5202 free_cpumask_var(cpumask);
5203 return ret ? ret : count;
5204}
5205
5206static struct device_attribute wq_sysfs_cpumask_attr =
5207 __ATTR(cpumask, 0644, wq_unbound_cpumask_show,
5208 wq_unbound_cpumask_store);
5209
5210static int __init wq_sysfs_init(void)
5211{
5212 int err;
5213
5214 err = subsys_virtual_register(&wq_subsys, NULL);
5215 if (err)
5216 return err;
5217
5218 return device_create_file(wq_subsys.dev_root, &wq_sysfs_cpumask_attr);
5219}
5220core_initcall(wq_sysfs_init);
5221
5222static void wq_device_release(struct device *dev)
5223{
5224 struct wq_device *wq_dev = container_of(dev, struct wq_device, dev);
5225
5226 kfree(wq_dev);
5227}
5228
5229
5230
5231
5232
5233
5234
5235
5236
5237
5238
5239
5240
5241
5242
5243
5244int workqueue_sysfs_register(struct workqueue_struct *wq)
5245{
5246 struct wq_device *wq_dev;
5247 int ret;
5248
5249
5250
5251
5252
5253
5254 if (WARN_ON(wq->flags & __WQ_ORDERED))
5255 return -EINVAL;
5256
5257 wq->wq_dev = wq_dev = kzalloc(sizeof(*wq_dev), GFP_KERNEL);
5258 if (!wq_dev)
5259 return -ENOMEM;
5260
5261 wq_dev->wq = wq;
5262 wq_dev->dev.bus = &wq_subsys;
5263 wq_dev->dev.release = wq_device_release;
5264 dev_set_name(&wq_dev->dev, "%s", wq->name);
5265
5266
5267
5268
5269
5270 dev_set_uevent_suppress(&wq_dev->dev, true);
5271
5272 ret = device_register(&wq_dev->dev);
5273 if (ret) {
5274 kfree(wq_dev);
5275 wq->wq_dev = NULL;
5276 return ret;
5277 }
5278
5279 if (wq->flags & WQ_UNBOUND) {
5280 struct device_attribute *attr;
5281
5282 for (attr = wq_sysfs_unbound_attrs; attr->attr.name; attr++) {
5283 ret = device_create_file(&wq_dev->dev, attr);
5284 if (ret) {
5285 device_unregister(&wq_dev->dev);
5286 wq->wq_dev = NULL;
5287 return ret;
5288 }
5289 }
5290 }
5291
5292 dev_set_uevent_suppress(&wq_dev->dev, false);
5293 kobject_uevent(&wq_dev->dev.kobj, KOBJ_ADD);
5294 return 0;
5295}
5296
5297
5298
5299
5300
5301
5302
5303static void workqueue_sysfs_unregister(struct workqueue_struct *wq)
5304{
5305 struct wq_device *wq_dev = wq->wq_dev;
5306
5307 if (!wq->wq_dev)
5308 return;
5309
5310 wq->wq_dev = NULL;
5311 device_unregister(&wq_dev->dev);
5312}
5313#else
5314static void workqueue_sysfs_unregister(struct workqueue_struct *wq) { }
5315#endif
5316
5317
5318
5319
5320
5321
5322
5323
5324
5325
5326
5327
5328
5329
5330
5331
5332
5333
5334#ifdef CONFIG_WQ_WATCHDOG
5335
5336static void wq_watchdog_timer_fn(unsigned long data);
5337
5338static unsigned long wq_watchdog_thresh = 30;
5339static struct timer_list wq_watchdog_timer =
5340 TIMER_DEFERRED_INITIALIZER(wq_watchdog_timer_fn, 0, 0);
5341
5342static unsigned long wq_watchdog_touched = INITIAL_JIFFIES;
5343static DEFINE_PER_CPU(unsigned long, wq_watchdog_touched_cpu) = INITIAL_JIFFIES;
5344
5345static void wq_watchdog_reset_touched(void)
5346{
5347 int cpu;
5348
5349 wq_watchdog_touched = jiffies;
5350 for_each_possible_cpu(cpu)
5351 per_cpu(wq_watchdog_touched_cpu, cpu) = jiffies;
5352}
5353
5354static void wq_watchdog_timer_fn(unsigned long data)
5355{
5356 unsigned long thresh = READ_ONCE(wq_watchdog_thresh) * HZ;
5357 bool lockup_detected = false;
5358 struct worker_pool *pool;
5359 int pi;
5360
5361 if (!thresh)
5362 return;
5363
5364 rcu_read_lock();
5365
5366 for_each_pool(pool, pi) {
5367 unsigned long pool_ts, touched, ts;
5368
5369 if (list_empty(&pool->worklist))
5370 continue;
5371
5372
5373 pool_ts = READ_ONCE(pool->watchdog_ts);
5374 touched = READ_ONCE(wq_watchdog_touched);
5375
5376 if (time_after(pool_ts, touched))
5377 ts = pool_ts;
5378 else
5379 ts = touched;
5380
5381 if (pool->cpu >= 0) {
5382 unsigned long cpu_touched =
5383 READ_ONCE(per_cpu(wq_watchdog_touched_cpu,
5384 pool->cpu));
5385 if (time_after(cpu_touched, ts))
5386 ts = cpu_touched;
5387 }
5388
5389
5390 if (time_after(jiffies, ts + thresh)) {
5391 lockup_detected = true;
5392 pr_emerg("BUG: workqueue lockup - pool");
5393 pr_cont_pool_info(pool);
5394 pr_cont(" stuck for %us!\n",
5395 jiffies_to_msecs(jiffies - pool_ts) / 1000);
5396 }
5397 }
5398
5399 rcu_read_unlock();
5400
5401 if (lockup_detected)
5402 show_workqueue_state();
5403
5404 wq_watchdog_reset_touched();
5405 mod_timer(&wq_watchdog_timer, jiffies + thresh);
5406}
5407
5408void wq_watchdog_touch(int cpu)
5409{
5410 if (cpu >= 0)
5411 per_cpu(wq_watchdog_touched_cpu, cpu) = jiffies;
5412 else
5413 wq_watchdog_touched = jiffies;
5414}
5415
5416static void wq_watchdog_set_thresh(unsigned long thresh)
5417{
5418 wq_watchdog_thresh = 0;
5419 del_timer_sync(&wq_watchdog_timer);
5420
5421 if (thresh) {
5422 wq_watchdog_thresh = thresh;
5423 wq_watchdog_reset_touched();
5424 mod_timer(&wq_watchdog_timer, jiffies + thresh * HZ);
5425 }
5426}
5427
5428static int wq_watchdog_param_set_thresh(const char *val,
5429 const struct kernel_param *kp)
5430{
5431 unsigned long thresh;
5432 int ret;
5433
5434 ret = kstrtoul(val, 0, &thresh);
5435 if (ret)
5436 return ret;
5437
5438 if (system_wq)
5439 wq_watchdog_set_thresh(thresh);
5440 else
5441 wq_watchdog_thresh = thresh;
5442
5443 return 0;
5444}
5445
5446static const struct kernel_param_ops wq_watchdog_thresh_ops = {
5447 .set = wq_watchdog_param_set_thresh,
5448 .get = param_get_ulong,
5449};
5450
5451module_param_cb(watchdog_thresh, &wq_watchdog_thresh_ops, &wq_watchdog_thresh,
5452 0644);
5453
5454static void wq_watchdog_init(void)
5455{
5456 wq_watchdog_set_thresh(wq_watchdog_thresh);
5457}
5458
5459#else
5460
5461static inline void wq_watchdog_init(void) { }
5462
5463#endif
5464
5465static void __init wq_numa_init(void)
5466{
5467 cpumask_var_t *tbl;
5468 int node, cpu;
5469
5470 if (num_possible_nodes() <= 1)
5471 return;
5472
5473 if (wq_disable_numa) {
5474 pr_info("workqueue: NUMA affinity support disabled\n");
5475 return;
5476 }
5477
5478 wq_update_unbound_numa_attrs_buf = alloc_workqueue_attrs(GFP_KERNEL);
5479 BUG_ON(!wq_update_unbound_numa_attrs_buf);
5480
5481
5482
5483
5484
5485
5486 tbl = kzalloc(nr_node_ids * sizeof(tbl[0]), GFP_KERNEL);
5487 BUG_ON(!tbl);
5488
5489 for_each_node(node)
5490 BUG_ON(!zalloc_cpumask_var_node(&tbl[node], GFP_KERNEL,
5491 node_online(node) ? node : NUMA_NO_NODE));
5492
5493 for_each_possible_cpu(cpu) {
5494 node = cpu_to_node(cpu);
5495 if (WARN_ON(node == NUMA_NO_NODE)) {
5496 pr_warn("workqueue: NUMA node mapping not available for cpu%d, disabling NUMA support\n", cpu);
5497
5498 return;
5499 }
5500 cpumask_set_cpu(cpu, tbl[node]);
5501 }
5502
5503 wq_numa_possible_cpumask = tbl;
5504 wq_numa_enabled = true;
5505}
5506
5507static int __init init_workqueues(void)
5508{
5509 int std_nice[NR_STD_WORKER_POOLS] = { 0, HIGHPRI_NICE_LEVEL };
5510 int i, cpu;
5511
5512 WARN_ON(__alignof__(struct pool_workqueue) < __alignof__(long long));
5513
5514 BUG_ON(!alloc_cpumask_var(&wq_unbound_cpumask, GFP_KERNEL));
5515 cpumask_copy(wq_unbound_cpumask, cpu_possible_mask);
5516
5517 pwq_cache = KMEM_CACHE(pool_workqueue, SLAB_PANIC);
5518
5519 cpu_notifier(workqueue_cpu_up_callback, CPU_PRI_WORKQUEUE_UP);
5520 hotcpu_notifier(workqueue_cpu_down_callback, CPU_PRI_WORKQUEUE_DOWN);
5521
5522 wq_numa_init();
5523
5524
5525 for_each_possible_cpu(cpu) {
5526 struct worker_pool *pool;
5527
5528 i = 0;
5529 for_each_cpu_worker_pool(pool, cpu) {
5530 BUG_ON(init_worker_pool(pool));
5531 pool->cpu = cpu;
5532 cpumask_copy(pool->attrs->cpumask, cpumask_of(cpu));
5533 pool->attrs->nice = std_nice[i++];
5534 pool->node = cpu_to_node(cpu);
5535
5536
5537 mutex_lock(&wq_pool_mutex);
5538 BUG_ON(worker_pool_assign_id(pool));
5539 mutex_unlock(&wq_pool_mutex);
5540 }
5541 }
5542
5543
5544 for_each_online_cpu(cpu) {
5545 struct worker_pool *pool;
5546
5547 for_each_cpu_worker_pool(pool, cpu) {
5548 pool->flags &= ~POOL_DISASSOCIATED;
5549 BUG_ON(!create_worker(pool));
5550 }
5551 }
5552
5553
5554 for (i = 0; i < NR_STD_WORKER_POOLS; i++) {
5555 struct workqueue_attrs *attrs;
5556
5557 BUG_ON(!(attrs = alloc_workqueue_attrs(GFP_KERNEL)));
5558 attrs->nice = std_nice[i];
5559 unbound_std_wq_attrs[i] = attrs;
5560
5561
5562
5563
5564
5565
5566 BUG_ON(!(attrs = alloc_workqueue_attrs(GFP_KERNEL)));
5567 attrs->nice = std_nice[i];
5568 attrs->no_numa = true;
5569 ordered_wq_attrs[i] = attrs;
5570 }
5571
5572 system_wq = alloc_workqueue("events", 0, 0);
5573 system_highpri_wq = alloc_workqueue("events_highpri", WQ_HIGHPRI, 0);
5574 system_long_wq = alloc_workqueue("events_long", 0, 0);
5575 system_unbound_wq = alloc_workqueue("events_unbound", WQ_UNBOUND,
5576 WQ_UNBOUND_MAX_ACTIVE);
5577 system_freezable_wq = alloc_workqueue("events_freezable",
5578 WQ_FREEZABLE, 0);
5579 system_power_efficient_wq = alloc_workqueue("events_power_efficient",
5580 WQ_POWER_EFFICIENT, 0);
5581 system_freezable_power_efficient_wq = alloc_workqueue("events_freezable_power_efficient",
5582 WQ_FREEZABLE | WQ_POWER_EFFICIENT,
5583 0);
5584 BUG_ON(!system_wq || !system_highpri_wq || !system_long_wq ||
5585 !system_unbound_wq || !system_freezable_wq ||
5586 !system_power_efficient_wq ||
5587 !system_freezable_power_efficient_wq);
5588
5589 wq_watchdog_init();
5590
5591 return 0;
5592}
5593early_initcall(init_workqueues);
5594