1 /* SPDX-License-Identifier: GPL-2.0 */ 2 /* 3 * workqueue.h --- work queue handling for Linux. 4 */ 5 6 #ifndef _LINUX_WORKQUEUE_H 7 #define _LINUX_WORKQUEUE_H 8 9 #include <linux/timer.h> 10 #include <linux/linkage.h> 11 #include <linux/bitops.h> 12 #include <linux/lockdep.h> 13 #include <linux/threads.h> 14 #include <linux/atomic.h> 15 #include <linux/cpumask.h> 16 #include <linux/rcupdate.h> 17 18 struct workqueue_struct; 19 20 struct work_struct; 21 typedef void (*work_func_t)(struct work_struct *work); 22 void delayed_work_timer_fn(struct timer_list *t); 23 24 /* 25 * The first word is the work queue pointer and the flags rolled into 26 * one 27 */ 28 #define work_data_bits(work) ((unsigned long *)(&(work)->data)) 29 30 enum { 31 WORK_STRUCT_PENDING_BIT = 0, /* work item is pending execution */ 32 WORK_STRUCT_INACTIVE_BIT= 1, /* work item is inactive */ 33 WORK_STRUCT_PWQ_BIT = 2, /* data points to pwq */ 34 WORK_STRUCT_LINKED_BIT = 3, /* next work is linked to this one */ 35 #ifdef CONFIG_DEBUG_OBJECTS_WORK 36 WORK_STRUCT_STATIC_BIT = 4, /* static initializer (debugobjects) */ 37 WORK_STRUCT_COLOR_SHIFT = 5, /* color for workqueue flushing */ 38 #else 39 WORK_STRUCT_COLOR_SHIFT = 4, /* color for workqueue flushing */ 40 #endif 41 42 WORK_STRUCT_COLOR_BITS = 4, 43 44 WORK_STRUCT_PENDING = 1 << WORK_STRUCT_PENDING_BIT, 45 WORK_STRUCT_INACTIVE = 1 << WORK_STRUCT_INACTIVE_BIT, 46 WORK_STRUCT_PWQ = 1 << WORK_STRUCT_PWQ_BIT, 47 WORK_STRUCT_LINKED = 1 << WORK_STRUCT_LINKED_BIT, 48 #ifdef CONFIG_DEBUG_OBJECTS_WORK 49 WORK_STRUCT_STATIC = 1 << WORK_STRUCT_STATIC_BIT, 50 #else 51 WORK_STRUCT_STATIC = 0, 52 #endif 53 54 WORK_NR_COLORS = (1 << WORK_STRUCT_COLOR_BITS), 55 56 /* not bound to any CPU, prefer the local CPU */ 57 WORK_CPU_UNBOUND = NR_CPUS, 58 59 /* 60 * Reserve 8 bits off of pwq pointer w/ debugobjects turned off. 61 * This makes pwqs aligned to 256 bytes and allows 16 workqueue 62 * flush colors. 63 */ 64 WORK_STRUCT_FLAG_BITS = WORK_STRUCT_COLOR_SHIFT + 65 WORK_STRUCT_COLOR_BITS, 66 67 /* data contains off-queue information when !WORK_STRUCT_PWQ */ 68 WORK_OFFQ_FLAG_BASE = WORK_STRUCT_COLOR_SHIFT, 69 70 __WORK_OFFQ_CANCELING = WORK_OFFQ_FLAG_BASE, 71 72 /* 73 * When a work item is off queue, its high bits point to the last 74 * pool it was on. Cap at 31 bits and use the highest number to 75 * indicate that no pool is associated. 76 */ 77 WORK_OFFQ_FLAG_BITS = 1, 78 WORK_OFFQ_POOL_SHIFT = WORK_OFFQ_FLAG_BASE + WORK_OFFQ_FLAG_BITS, 79 WORK_OFFQ_LEFT = BITS_PER_LONG - WORK_OFFQ_POOL_SHIFT, 80 WORK_OFFQ_POOL_BITS = WORK_OFFQ_LEFT <= 31 ? WORK_OFFQ_LEFT : 31, 81 82 /* bit mask for work_busy() return values */ 83 WORK_BUSY_PENDING = 1 << 0, 84 WORK_BUSY_RUNNING = 1 << 1, 85 86 /* maximum string length for set_worker_desc() */ 87 WORKER_DESC_LEN = 24, 88 }; 89 90 /* Convenience constants - of type 'unsigned long', not 'enum'! */ 91 #define WORK_OFFQ_CANCELING (1ul << __WORK_OFFQ_CANCELING) 92 #define WORK_OFFQ_POOL_NONE ((1ul << WORK_OFFQ_POOL_BITS) - 1) 93 #define WORK_STRUCT_NO_POOL (WORK_OFFQ_POOL_NONE << WORK_OFFQ_POOL_SHIFT) 94 95 #define WORK_STRUCT_FLAG_MASK ((1ul << WORK_STRUCT_FLAG_BITS) - 1) 96 #define WORK_STRUCT_WQ_DATA_MASK (~WORK_STRUCT_FLAG_MASK) 97 98 struct work_struct { 99 atomic_long_t data; 100 struct list_head entry; 101 work_func_t func; 102 #ifdef CONFIG_LOCKDEP 103 struct lockdep_map lockdep_map; 104 #endif 105 }; 106 107 #define WORK_DATA_INIT() ATOMIC_LONG_INIT((unsigned long)WORK_STRUCT_NO_POOL) 108 #define WORK_DATA_STATIC_INIT() \ 109 ATOMIC_LONG_INIT((unsigned long)(WORK_STRUCT_NO_POOL | WORK_STRUCT_STATIC)) 110 111 struct delayed_work { 112 struct work_struct work; 113 struct timer_list timer; 114 115 /* target workqueue and CPU ->timer uses to queue ->work */ 116 struct workqueue_struct *wq; 117 int cpu; 118 }; 119 120 struct rcu_work { 121 struct work_struct work; 122 struct rcu_head rcu; 123 124 /* target workqueue ->rcu uses to queue ->work */ 125 struct workqueue_struct *wq; 126 }; 127 128 /** 129 * struct workqueue_attrs - A struct for workqueue attributes. 130 * 131 * This can be used to change attributes of an unbound workqueue. 132 */ 133 struct workqueue_attrs { 134 /** 135 * @nice: nice level 136 */ 137 int nice; 138 139 /** 140 * @cpumask: allowed CPUs 141 */ 142 cpumask_var_t cpumask; 143 144 /** 145 * @no_numa: disable NUMA affinity 146 * 147 * Unlike other fields, ``no_numa`` isn't a property of a worker_pool. It 148 * only modifies how :c:func:`apply_workqueue_attrs` select pools and thus 149 * doesn't participate in pool hash calculations or equality comparisons. 150 */ 151 bool no_numa; 152 }; 153 154 static inline struct delayed_work *to_delayed_work(struct work_struct *work) 155 { 156 return container_of(work, struct delayed_work, work); 157 } 158 159 static inline struct rcu_work *to_rcu_work(struct work_struct *work) 160 { 161 return container_of(work, struct rcu_work, work); 162 } 163 164 struct execute_work { 165 struct work_struct work; 166 }; 167 168 #ifdef CONFIG_LOCKDEP 169 /* 170 * NB: because we have to copy the lockdep_map, setting _key 171 * here is required, otherwise it could get initialised to the 172 * copy of the lockdep_map! 173 */ 174 #define __WORK_INIT_LOCKDEP_MAP(n, k) \ 175 .lockdep_map = STATIC_LOCKDEP_MAP_INIT(n, k), 176 #else 177 #define __WORK_INIT_LOCKDEP_MAP(n, k) 178 #endif 179 180 #define __WORK_INITIALIZER(n, f) { \ 181 .data = WORK_DATA_STATIC_INIT(), \ 182 .entry = { &(n).entry, &(n).entry }, \ 183 .func = (f), \ 184 __WORK_INIT_LOCKDEP_MAP(#n, &(n)) \ 185 } 186 187 #define __DELAYED_WORK_INITIALIZER(n, f, tflags) { \ 188 .work = __WORK_INITIALIZER((n).work, (f)), \ 189 .timer = __TIMER_INITIALIZER(delayed_work_timer_fn,\ 190 (tflags) | TIMER_IRQSAFE), \ 191 } 192 193 #define DECLARE_WORK(n, f) \ 194 struct work_struct n = __WORK_INITIALIZER(n, f) 195 196 #define DECLARE_DELAYED_WORK(n, f) \ 197 struct delayed_work n = __DELAYED_WORK_INITIALIZER(n, f, 0) 198 199 #define DECLARE_DEFERRABLE_WORK(n, f) \ 200 struct delayed_work n = __DELAYED_WORK_INITIALIZER(n, f, TIMER_DEFERRABLE) 201 202 #ifdef CONFIG_DEBUG_OBJECTS_WORK 203 extern void __init_work(struct work_struct *work, int onstack); 204 extern void destroy_work_on_stack(struct work_struct *work); 205 extern void destroy_delayed_work_on_stack(struct delayed_work *work); 206 static inline unsigned int work_static(struct work_struct *work) 207 { 208 return *work_data_bits(work) & WORK_STRUCT_STATIC; 209 } 210 #else 211 static inline void __init_work(struct work_struct *work, int onstack) { } 212 static inline void destroy_work_on_stack(struct work_struct *work) { } 213 static inline void destroy_delayed_work_on_stack(struct delayed_work *work) { } 214 static inline unsigned int work_static(struct work_struct *work) { return 0; } 215 #endif 216 217 /* 218 * initialize all of a work item in one go 219 * 220 * NOTE! No point in using "atomic_long_set()": using a direct 221 * assignment of the work data initializer allows the compiler 222 * to generate better code. 223 */ 224 #ifdef CONFIG_LOCKDEP 225 #define __INIT_WORK(_work, _func, _onstack) \ 226 do { \ 227 static struct lock_class_key __key; \ 228 \ 229 __init_work((_work), _onstack); \ 230 (_work)->data = (atomic_long_t) WORK_DATA_INIT(); \ 231 lockdep_init_map(&(_work)->lockdep_map, "(work_completion)"#_work, &__key, 0); \ 232 INIT_LIST_HEAD(&(_work)->entry); \ 233 (_work)->func = (_func); \ 234 } while (0) 235 #else 236 #define __INIT_WORK(_work, _func, _onstack) \ 237 do { \ 238 __init_work((_work), _onstack); \ 239 (_work)->data = (atomic_long_t) WORK_DATA_INIT(); \ 240 INIT_LIST_HEAD(&(_work)->entry); \ 241 (_work)->func = (_func); \ 242 } while (0) 243 #endif 244 245 #define INIT_WORK(_work, _func) \ 246 __INIT_WORK((_work), (_func), 0) 247 248 #define INIT_WORK_ONSTACK(_work, _func) \ 249 __INIT_WORK((_work), (_func), 1) 250 251 #define __INIT_DELAYED_WORK(_work, _func, _tflags) \ 252 do { \ 253 INIT_WORK(&(_work)->work, (_func)); \ 254 __init_timer(&(_work)->timer, \ 255 delayed_work_timer_fn, \ 256 (_tflags) | TIMER_IRQSAFE); \ 257 } while (0) 258 259 #define __INIT_DELAYED_WORK_ONSTACK(_work, _func, _tflags) \ 260 do { \ 261 INIT_WORK_ONSTACK(&(_work)->work, (_func)); \ 262 __init_timer_on_stack(&(_work)->timer, \ 263 delayed_work_timer_fn, \ 264 (_tflags) | TIMER_IRQSAFE); \ 265 } while (0) 266 267 #define INIT_DELAYED_WORK(_work, _func) \ 268 __INIT_DELAYED_WORK(_work, _func, 0) 269 270 #define INIT_DELAYED_WORK_ONSTACK(_work, _func) \ 271 __INIT_DELAYED_WORK_ONSTACK(_work, _func, 0) 272 273 #define INIT_DEFERRABLE_WORK(_work, _func) \ 274 __INIT_DELAYED_WORK(_work, _func, TIMER_DEFERRABLE) 275 276 #define INIT_DEFERRABLE_WORK_ONSTACK(_work, _func) \ 277 __INIT_DELAYED_WORK_ONSTACK(_work, _func, TIMER_DEFERRABLE) 278 279 #define INIT_RCU_WORK(_work, _func) \ 280 INIT_WORK(&(_work)->work, (_func)) 281 282 #define INIT_RCU_WORK_ONSTACK(_work, _func) \ 283 INIT_WORK_ONSTACK(&(_work)->work, (_func)) 284 285 /** 286 * work_pending - Find out whether a work item is currently pending 287 * @work: The work item in question 288 */ 289 #define work_pending(work) \ 290 test_bit(WORK_STRUCT_PENDING_BIT, work_data_bits(work)) 291 292 /** 293 * delayed_work_pending - Find out whether a delayable work item is currently 294 * pending 295 * @w: The work item in question 296 */ 297 #define delayed_work_pending(w) \ 298 work_pending(&(w)->work) 299 300 /* 301 * Workqueue flags and constants. For details, please refer to 302 * Documentation/core-api/workqueue.rst. 303 */ 304 enum { 305 WQ_UNBOUND = 1 << 1, /* not bound to any cpu */ 306 WQ_FREEZABLE = 1 << 2, /* freeze during suspend */ 307 WQ_MEM_RECLAIM = 1 << 3, /* may be used for memory reclaim */ 308 WQ_HIGHPRI = 1 << 4, /* high priority */ 309 WQ_CPU_INTENSIVE = 1 << 5, /* cpu intensive workqueue */ 310 WQ_SYSFS = 1 << 6, /* visible in sysfs, see workqueue_sysfs_register() */ 311 312 /* 313 * Per-cpu workqueues are generally preferred because they tend to 314 * show better performance thanks to cache locality. Per-cpu 315 * workqueues exclude the scheduler from choosing the CPU to 316 * execute the worker threads, which has an unfortunate side effect 317 * of increasing power consumption. 318 * 319 * The scheduler considers a CPU idle if it doesn't have any task 320 * to execute and tries to keep idle cores idle to conserve power; 321 * however, for example, a per-cpu work item scheduled from an 322 * interrupt handler on an idle CPU will force the scheduler to 323 * execute the work item on that CPU breaking the idleness, which in 324 * turn may lead to more scheduling choices which are sub-optimal 325 * in terms of power consumption. 326 * 327 * Workqueues marked with WQ_POWER_EFFICIENT are per-cpu by default 328 * but become unbound if workqueue.power_efficient kernel param is 329 * specified. Per-cpu workqueues which are identified to 330 * contribute significantly to power-consumption are identified and 331 * marked with this flag and enabling the power_efficient mode 332 * leads to noticeable power saving at the cost of small 333 * performance disadvantage. 334 * 335 * http://thread.gmane.org/gmane.linux.kernel/1480396 336 */ 337 WQ_POWER_EFFICIENT = 1 << 7, 338 339 __WQ_DESTROYING = 1 << 15, /* internal: workqueue is destroying */ 340 __WQ_DRAINING = 1 << 16, /* internal: workqueue is draining */ 341 __WQ_ORDERED = 1 << 17, /* internal: workqueue is ordered */ 342 __WQ_LEGACY = 1 << 18, /* internal: create*_workqueue() */ 343 __WQ_ORDERED_EXPLICIT = 1 << 19, /* internal: alloc_ordered_workqueue() */ 344 345 WQ_MAX_ACTIVE = 512, /* I like 512, better ideas? */ 346 WQ_MAX_UNBOUND_PER_CPU = 4, /* 4 * #cpus for unbound wq */ 347 WQ_DFL_ACTIVE = WQ_MAX_ACTIVE / 2, 348 }; 349 350 /* unbound wq's aren't per-cpu, scale max_active according to #cpus */ 351 #define WQ_UNBOUND_MAX_ACTIVE \ 352 max_t(int, WQ_MAX_ACTIVE, num_possible_cpus() * WQ_MAX_UNBOUND_PER_CPU) 353 354 /* 355 * System-wide workqueues which are always present. 356 * 357 * system_wq is the one used by schedule[_delayed]_work[_on](). 358 * Multi-CPU multi-threaded. There are users which expect relatively 359 * short queue flush time. Don't queue works which can run for too 360 * long. 361 * 362 * system_highpri_wq is similar to system_wq but for work items which 363 * require WQ_HIGHPRI. 364 * 365 * system_long_wq is similar to system_wq but may host long running 366 * works. Queue flushing might take relatively long. 367 * 368 * system_unbound_wq is unbound workqueue. Workers are not bound to 369 * any specific CPU, not concurrency managed, and all queued works are 370 * executed immediately as long as max_active limit is not reached and 371 * resources are available. 372 * 373 * system_freezable_wq is equivalent to system_wq except that it's 374 * freezable. 375 * 376 * *_power_efficient_wq are inclined towards saving power and converted 377 * into WQ_UNBOUND variants if 'wq_power_efficient' is enabled; otherwise, 378 * they are same as their non-power-efficient counterparts - e.g. 379 * system_power_efficient_wq is identical to system_wq if 380 * 'wq_power_efficient' is disabled. See WQ_POWER_EFFICIENT for more info. 381 */ 382 extern struct workqueue_struct *system_wq; 383 extern struct workqueue_struct *system_highpri_wq; 384 extern struct workqueue_struct *system_long_wq; 385 extern struct workqueue_struct *system_unbound_wq; 386 extern struct workqueue_struct *system_freezable_wq; 387 extern struct workqueue_struct *system_power_efficient_wq; 388 extern struct workqueue_struct *system_freezable_power_efficient_wq; 389 390 /** 391 * alloc_workqueue - allocate a workqueue 392 * @fmt: printf format for the name of the workqueue 393 * @flags: WQ_* flags 394 * @max_active: max in-flight work items, 0 for default 395 * remaining args: args for @fmt 396 * 397 * Allocate a workqueue with the specified parameters. For detailed 398 * information on WQ_* flags, please refer to 399 * Documentation/core-api/workqueue.rst. 400 * 401 * RETURNS: 402 * Pointer to the allocated workqueue on success, %NULL on failure. 403 */ 404 __printf(1, 4) struct workqueue_struct * 405 alloc_workqueue(const char *fmt, unsigned int flags, int max_active, ...); 406 407 /** 408 * alloc_ordered_workqueue - allocate an ordered workqueue 409 * @fmt: printf format for the name of the workqueue 410 * @flags: WQ_* flags (only WQ_FREEZABLE and WQ_MEM_RECLAIM are meaningful) 411 * @args: args for @fmt 412 * 413 * Allocate an ordered workqueue. An ordered workqueue executes at 414 * most one work item at any given time in the queued order. They are 415 * implemented as unbound workqueues with @max_active of one. 416 * 417 * RETURNS: 418 * Pointer to the allocated workqueue on success, %NULL on failure. 419 */ 420 #define alloc_ordered_workqueue(fmt, flags, args...) \ 421 alloc_workqueue(fmt, WQ_UNBOUND | __WQ_ORDERED | \ 422 __WQ_ORDERED_EXPLICIT | (flags), 1, ##args) 423 424 #define create_workqueue(name) \ 425 alloc_workqueue("%s", __WQ_LEGACY | WQ_MEM_RECLAIM, 1, (name)) 426 #define create_freezable_workqueue(name) \ 427 alloc_workqueue("%s", __WQ_LEGACY | WQ_FREEZABLE | WQ_UNBOUND | \ 428 WQ_MEM_RECLAIM, 1, (name)) 429 #define create_singlethread_workqueue(name) \ 430 alloc_ordered_workqueue("%s", __WQ_LEGACY | WQ_MEM_RECLAIM, name) 431 432 extern void destroy_workqueue(struct workqueue_struct *wq); 433 434 struct workqueue_attrs *alloc_workqueue_attrs(void); 435 void free_workqueue_attrs(struct workqueue_attrs *attrs); 436 int apply_workqueue_attrs(struct workqueue_struct *wq, 437 const struct workqueue_attrs *attrs); 438 int workqueue_set_unbound_cpumask(cpumask_var_t cpumask); 439 440 extern bool queue_work_on(int cpu, struct workqueue_struct *wq, 441 struct work_struct *work); 442 extern bool queue_work_node(int node, struct workqueue_struct *wq, 443 struct work_struct *work); 444 extern bool queue_delayed_work_on(int cpu, struct workqueue_struct *wq, 445 struct delayed_work *work, unsigned long delay); 446 extern bool mod_delayed_work_on(int cpu, struct workqueue_struct *wq, 447 struct delayed_work *dwork, unsigned long delay); 448 extern bool queue_rcu_work(struct workqueue_struct *wq, struct rcu_work *rwork); 449 450 extern void __flush_workqueue(struct workqueue_struct *wq); 451 extern void drain_workqueue(struct workqueue_struct *wq); 452 453 extern int schedule_on_each_cpu(work_func_t func); 454 455 int execute_in_process_context(work_func_t fn, struct execute_work *); 456 457 extern bool flush_work(struct work_struct *work); 458 extern bool cancel_work(struct work_struct *work); 459 extern bool cancel_work_sync(struct work_struct *work); 460 461 extern bool flush_delayed_work(struct delayed_work *dwork); 462 extern bool cancel_delayed_work(struct delayed_work *dwork); 463 extern bool cancel_delayed_work_sync(struct delayed_work *dwork); 464 465 extern bool flush_rcu_work(struct rcu_work *rwork); 466 467 extern void workqueue_set_max_active(struct workqueue_struct *wq, 468 int max_active); 469 extern struct work_struct *current_work(void); 470 extern bool current_is_workqueue_rescuer(void); 471 extern bool workqueue_congested(int cpu, struct workqueue_struct *wq); 472 extern unsigned int work_busy(struct work_struct *work); 473 extern __printf(1, 2) void set_worker_desc(const char *fmt, ...); 474 extern void print_worker_info(const char *log_lvl, struct task_struct *task); 475 extern void show_all_workqueues(void); 476 extern void show_freezable_workqueues(void); 477 extern void show_one_workqueue(struct workqueue_struct *wq); 478 extern void wq_worker_comm(char *buf, size_t size, struct task_struct *task); 479 480 /** 481 * queue_work - queue work on a workqueue 482 * @wq: workqueue to use 483 * @work: work to queue 484 * 485 * Returns %false if @work was already on a queue, %true otherwise. 486 * 487 * We queue the work to the CPU on which it was submitted, but if the CPU dies 488 * it can be processed by another CPU. 489 * 490 * Memory-ordering properties: If it returns %true, guarantees that all stores 491 * preceding the call to queue_work() in the program order will be visible from 492 * the CPU which will execute @work by the time such work executes, e.g., 493 * 494 * { x is initially 0 } 495 * 496 * CPU0 CPU1 497 * 498 * WRITE_ONCE(x, 1); [ @work is being executed ] 499 * r0 = queue_work(wq, work); r1 = READ_ONCE(x); 500 * 501 * Forbids: r0 == true && r1 == 0 502 */ 503 static inline bool queue_work(struct workqueue_struct *wq, 504 struct work_struct *work) 505 { 506 return queue_work_on(WORK_CPU_UNBOUND, wq, work); 507 } 508 509 /** 510 * queue_delayed_work - queue work on a workqueue after delay 511 * @wq: workqueue to use 512 * @dwork: delayable work to queue 513 * @delay: number of jiffies to wait before queueing 514 * 515 * Equivalent to queue_delayed_work_on() but tries to use the local CPU. 516 */ 517 static inline bool queue_delayed_work(struct workqueue_struct *wq, 518 struct delayed_work *dwork, 519 unsigned long delay) 520 { 521 return queue_delayed_work_on(WORK_CPU_UNBOUND, wq, dwork, delay); 522 } 523 524 /** 525 * mod_delayed_work - modify delay of or queue a delayed work 526 * @wq: workqueue to use 527 * @dwork: work to queue 528 * @delay: number of jiffies to wait before queueing 529 * 530 * mod_delayed_work_on() on local CPU. 531 */ 532 static inline bool mod_delayed_work(struct workqueue_struct *wq, 533 struct delayed_work *dwork, 534 unsigned long delay) 535 { 536 return mod_delayed_work_on(WORK_CPU_UNBOUND, wq, dwork, delay); 537 } 538 539 /** 540 * schedule_work_on - put work task on a specific cpu 541 * @cpu: cpu to put the work task on 542 * @work: job to be done 543 * 544 * This puts a job on a specific cpu 545 */ 546 static inline bool schedule_work_on(int cpu, struct work_struct *work) 547 { 548 return queue_work_on(cpu, system_wq, work); 549 } 550 551 /** 552 * schedule_work - put work task in global workqueue 553 * @work: job to be done 554 * 555 * Returns %false if @work was already on the kernel-global workqueue and 556 * %true otherwise. 557 * 558 * This puts a job in the kernel-global workqueue if it was not already 559 * queued and leaves it in the same position on the kernel-global 560 * workqueue otherwise. 561 * 562 * Shares the same memory-ordering properties of queue_work(), cf. the 563 * DocBook header of queue_work(). 564 */ 565 static inline bool schedule_work(struct work_struct *work) 566 { 567 return queue_work(system_wq, work); 568 } 569 570 /* 571 * Detect attempt to flush system-wide workqueues at compile time when possible. 572 * 573 * See https://lkml.kernel.org/r/49925af7-78a8-a3dd-bce6-cfc02e1a9236@I-love.SAKURA.ne.jp 574 * for reasons and steps for converting system-wide workqueues into local workqueues. 575 */ 576 extern void __warn_flushing_systemwide_wq(void) 577 __compiletime_warning("Please avoid flushing system-wide workqueues."); 578 579 /** 580 * flush_scheduled_work - ensure that any scheduled work has run to completion. 581 * 582 * Forces execution of the kernel-global workqueue and blocks until its 583 * completion. 584 * 585 * It's very easy to get into trouble if you don't take great care. 586 * Either of the following situations will lead to deadlock: 587 * 588 * One of the work items currently on the workqueue needs to acquire 589 * a lock held by your code or its caller. 590 * 591 * Your code is running in the context of a work routine. 592 * 593 * They will be detected by lockdep when they occur, but the first might not 594 * occur very often. It depends on what work items are on the workqueue and 595 * what locks they need, which you have no control over. 596 * 597 * In most situations flushing the entire workqueue is overkill; you merely 598 * need to know that a particular work item isn't queued and isn't running. 599 * In such cases you should use cancel_delayed_work_sync() or 600 * cancel_work_sync() instead. 601 * 602 * Please stop calling this function! A conversion to stop flushing system-wide 603 * workqueues is in progress. This function will be removed after all in-tree 604 * users stopped calling this function. 605 */ 606 /* 607 * The background of commit 771c035372a036f8 ("deprecate the 608 * '__deprecated' attribute warnings entirely and for good") is that, 609 * since Linus builds all modules between every single pull he does, 610 * the standard kernel build needs to be _clean_ in order to be able to 611 * notice when new problems happen. Therefore, don't emit warning while 612 * there are in-tree users. 613 */ 614 #define flush_scheduled_work() \ 615 ({ \ 616 if (0) \ 617 __warn_flushing_systemwide_wq(); \ 618 __flush_workqueue(system_wq); \ 619 }) 620 621 /* 622 * Although there is no longer in-tree caller, for now just emit warning 623 * in order to give out-of-tree callers time to update. 624 */ 625 #define flush_workqueue(wq) \ 626 ({ \ 627 struct workqueue_struct *_wq = (wq); \ 628 \ 629 if ((__builtin_constant_p(_wq == system_wq) && \ 630 _wq == system_wq) || \ 631 (__builtin_constant_p(_wq == system_highpri_wq) && \ 632 _wq == system_highpri_wq) || \ 633 (__builtin_constant_p(_wq == system_long_wq) && \ 634 _wq == system_long_wq) || \ 635 (__builtin_constant_p(_wq == system_unbound_wq) && \ 636 _wq == system_unbound_wq) || \ 637 (__builtin_constant_p(_wq == system_freezable_wq) && \ 638 _wq == system_freezable_wq) || \ 639 (__builtin_constant_p(_wq == system_power_efficient_wq) && \ 640 _wq == system_power_efficient_wq) || \ 641 (__builtin_constant_p(_wq == system_freezable_power_efficient_wq) && \ 642 _wq == system_freezable_power_efficient_wq)) \ 643 __warn_flushing_systemwide_wq(); \ 644 __flush_workqueue(_wq); \ 645 }) 646 647 /** 648 * schedule_delayed_work_on - queue work in global workqueue on CPU after delay 649 * @cpu: cpu to use 650 * @dwork: job to be done 651 * @delay: number of jiffies to wait 652 * 653 * After waiting for a given time this puts a job in the kernel-global 654 * workqueue on the specified CPU. 655 */ 656 static inline bool schedule_delayed_work_on(int cpu, struct delayed_work *dwork, 657 unsigned long delay) 658 { 659 return queue_delayed_work_on(cpu, system_wq, dwork, delay); 660 } 661 662 /** 663 * schedule_delayed_work - put work task in global workqueue after delay 664 * @dwork: job to be done 665 * @delay: number of jiffies to wait or 0 for immediate execution 666 * 667 * After waiting for a given time this puts a job in the kernel-global 668 * workqueue. 669 */ 670 static inline bool schedule_delayed_work(struct delayed_work *dwork, 671 unsigned long delay) 672 { 673 return queue_delayed_work(system_wq, dwork, delay); 674 } 675 676 #ifndef CONFIG_SMP 677 static inline long work_on_cpu(int cpu, long (*fn)(void *), void *arg) 678 { 679 return fn(arg); 680 } 681 static inline long work_on_cpu_safe(int cpu, long (*fn)(void *), void *arg) 682 { 683 return fn(arg); 684 } 685 #else 686 long work_on_cpu(int cpu, long (*fn)(void *), void *arg); 687 long work_on_cpu_safe(int cpu, long (*fn)(void *), void *arg); 688 #endif /* CONFIG_SMP */ 689 690 #ifdef CONFIG_FREEZER 691 extern void freeze_workqueues_begin(void); 692 extern bool freeze_workqueues_busy(void); 693 extern void thaw_workqueues(void); 694 #endif /* CONFIG_FREEZER */ 695 696 #ifdef CONFIG_SYSFS 697 int workqueue_sysfs_register(struct workqueue_struct *wq); 698 #else /* CONFIG_SYSFS */ 699 static inline int workqueue_sysfs_register(struct workqueue_struct *wq) 700 { return 0; } 701 #endif /* CONFIG_SYSFS */ 702 703 #ifdef CONFIG_WQ_WATCHDOG 704 void wq_watchdog_touch(int cpu); 705 #else /* CONFIG_WQ_WATCHDOG */ 706 static inline void wq_watchdog_touch(int cpu) { } 707 #endif /* CONFIG_WQ_WATCHDOG */ 708 709 #ifdef CONFIG_SMP 710 int workqueue_prepare_cpu(unsigned int cpu); 711 int workqueue_online_cpu(unsigned int cpu); 712 int workqueue_offline_cpu(unsigned int cpu); 713 #endif 714 715 void __init workqueue_init_early(void); 716 void __init workqueue_init(void); 717 718 #endif 719