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 enum wq_affn_scope { 129 WQ_AFFN_DFL, /* use system default */ 130 WQ_AFFN_CPU, /* one pod per CPU */ 131 WQ_AFFN_SMT, /* one pod poer SMT */ 132 WQ_AFFN_CACHE, /* one pod per LLC */ 133 WQ_AFFN_NUMA, /* one pod per NUMA node */ 134 WQ_AFFN_SYSTEM, /* one pod across the whole system */ 135 136 WQ_AFFN_NR_TYPES, 137 }; 138 139 /** 140 * struct workqueue_attrs - A struct for workqueue attributes. 141 * 142 * This can be used to change attributes of an unbound workqueue. 143 */ 144 struct workqueue_attrs { 145 /** 146 * @nice: nice level 147 */ 148 int nice; 149 150 /** 151 * @cpumask: allowed CPUs 152 * 153 * Work items in this workqueue are affine to these CPUs and not allowed 154 * to execute on other CPUs. A pool serving a workqueue must have the 155 * same @cpumask. 156 */ 157 cpumask_var_t cpumask; 158 159 /** 160 * @__pod_cpumask: internal attribute used to create per-pod pools 161 * 162 * Internal use only. 163 * 164 * Per-pod unbound worker pools are used to improve locality. Always a 165 * subset of ->cpumask. A workqueue can be associated with multiple 166 * worker pools with disjoint @__pod_cpumask's. Whether the enforcement 167 * of a pool's @__pod_cpumask is strict depends on @affn_strict. 168 */ 169 cpumask_var_t __pod_cpumask; 170 171 /** 172 * @affn_strict: affinity scope is strict 173 * 174 * If clear, workqueue will make a best-effort attempt at starting the 175 * worker inside @__pod_cpumask but the scheduler is free to migrate it 176 * outside. 177 * 178 * If set, workers are only allowed to run inside @__pod_cpumask. 179 */ 180 bool affn_strict; 181 182 /* 183 * Below fields aren't properties of a worker_pool. They only modify how 184 * :c:func:`apply_workqueue_attrs` select pools and thus don't 185 * participate in pool hash calculations or equality comparisons. 186 */ 187 188 /** 189 * @affn_scope: unbound CPU affinity scope 190 * 191 * CPU pods are used to improve execution locality of unbound work 192 * items. There are multiple pod types, one for each wq_affn_scope, and 193 * every CPU in the system belongs to one pod in every pod type. CPUs 194 * that belong to the same pod share the worker pool. For example, 195 * selecting %WQ_AFFN_NUMA makes the workqueue use a separate worker 196 * pool for each NUMA node. 197 */ 198 enum wq_affn_scope affn_scope; 199 200 /** 201 * @ordered: work items must be executed one by one in queueing order 202 */ 203 bool ordered; 204 }; 205 206 static inline struct delayed_work *to_delayed_work(struct work_struct *work) 207 { 208 return container_of(work, struct delayed_work, work); 209 } 210 211 static inline struct rcu_work *to_rcu_work(struct work_struct *work) 212 { 213 return container_of(work, struct rcu_work, work); 214 } 215 216 struct execute_work { 217 struct work_struct work; 218 }; 219 220 #ifdef CONFIG_LOCKDEP 221 /* 222 * NB: because we have to copy the lockdep_map, setting _key 223 * here is required, otherwise it could get initialised to the 224 * copy of the lockdep_map! 225 */ 226 #define __WORK_INIT_LOCKDEP_MAP(n, k) \ 227 .lockdep_map = STATIC_LOCKDEP_MAP_INIT(n, k), 228 #else 229 #define __WORK_INIT_LOCKDEP_MAP(n, k) 230 #endif 231 232 #define __WORK_INITIALIZER(n, f) { \ 233 .data = WORK_DATA_STATIC_INIT(), \ 234 .entry = { &(n).entry, &(n).entry }, \ 235 .func = (f), \ 236 __WORK_INIT_LOCKDEP_MAP(#n, &(n)) \ 237 } 238 239 #define __DELAYED_WORK_INITIALIZER(n, f, tflags) { \ 240 .work = __WORK_INITIALIZER((n).work, (f)), \ 241 .timer = __TIMER_INITIALIZER(delayed_work_timer_fn,\ 242 (tflags) | TIMER_IRQSAFE), \ 243 } 244 245 #define DECLARE_WORK(n, f) \ 246 struct work_struct n = __WORK_INITIALIZER(n, f) 247 248 #define DECLARE_DELAYED_WORK(n, f) \ 249 struct delayed_work n = __DELAYED_WORK_INITIALIZER(n, f, 0) 250 251 #define DECLARE_DEFERRABLE_WORK(n, f) \ 252 struct delayed_work n = __DELAYED_WORK_INITIALIZER(n, f, TIMER_DEFERRABLE) 253 254 #ifdef CONFIG_DEBUG_OBJECTS_WORK 255 extern void __init_work(struct work_struct *work, int onstack); 256 extern void destroy_work_on_stack(struct work_struct *work); 257 extern void destroy_delayed_work_on_stack(struct delayed_work *work); 258 static inline unsigned int work_static(struct work_struct *work) 259 { 260 return *work_data_bits(work) & WORK_STRUCT_STATIC; 261 } 262 #else 263 static inline void __init_work(struct work_struct *work, int onstack) { } 264 static inline void destroy_work_on_stack(struct work_struct *work) { } 265 static inline void destroy_delayed_work_on_stack(struct delayed_work *work) { } 266 static inline unsigned int work_static(struct work_struct *work) { return 0; } 267 #endif 268 269 /* 270 * initialize all of a work item in one go 271 * 272 * NOTE! No point in using "atomic_long_set()": using a direct 273 * assignment of the work data initializer allows the compiler 274 * to generate better code. 275 */ 276 #ifdef CONFIG_LOCKDEP 277 #define __INIT_WORK(_work, _func, _onstack) \ 278 do { \ 279 static struct lock_class_key __key; \ 280 \ 281 __init_work((_work), _onstack); \ 282 (_work)->data = (atomic_long_t) WORK_DATA_INIT(); \ 283 lockdep_init_map(&(_work)->lockdep_map, "(work_completion)"#_work, &__key, 0); \ 284 INIT_LIST_HEAD(&(_work)->entry); \ 285 (_work)->func = (_func); \ 286 } while (0) 287 #else 288 #define __INIT_WORK(_work, _func, _onstack) \ 289 do { \ 290 __init_work((_work), _onstack); \ 291 (_work)->data = (atomic_long_t) WORK_DATA_INIT(); \ 292 INIT_LIST_HEAD(&(_work)->entry); \ 293 (_work)->func = (_func); \ 294 } while (0) 295 #endif 296 297 #define INIT_WORK(_work, _func) \ 298 __INIT_WORK((_work), (_func), 0) 299 300 #define INIT_WORK_ONSTACK(_work, _func) \ 301 __INIT_WORK((_work), (_func), 1) 302 303 #define __INIT_DELAYED_WORK(_work, _func, _tflags) \ 304 do { \ 305 INIT_WORK(&(_work)->work, (_func)); \ 306 __init_timer(&(_work)->timer, \ 307 delayed_work_timer_fn, \ 308 (_tflags) | TIMER_IRQSAFE); \ 309 } while (0) 310 311 #define __INIT_DELAYED_WORK_ONSTACK(_work, _func, _tflags) \ 312 do { \ 313 INIT_WORK_ONSTACK(&(_work)->work, (_func)); \ 314 __init_timer_on_stack(&(_work)->timer, \ 315 delayed_work_timer_fn, \ 316 (_tflags) | TIMER_IRQSAFE); \ 317 } while (0) 318 319 #define INIT_DELAYED_WORK(_work, _func) \ 320 __INIT_DELAYED_WORK(_work, _func, 0) 321 322 #define INIT_DELAYED_WORK_ONSTACK(_work, _func) \ 323 __INIT_DELAYED_WORK_ONSTACK(_work, _func, 0) 324 325 #define INIT_DEFERRABLE_WORK(_work, _func) \ 326 __INIT_DELAYED_WORK(_work, _func, TIMER_DEFERRABLE) 327 328 #define INIT_DEFERRABLE_WORK_ONSTACK(_work, _func) \ 329 __INIT_DELAYED_WORK_ONSTACK(_work, _func, TIMER_DEFERRABLE) 330 331 #define INIT_RCU_WORK(_work, _func) \ 332 INIT_WORK(&(_work)->work, (_func)) 333 334 #define INIT_RCU_WORK_ONSTACK(_work, _func) \ 335 INIT_WORK_ONSTACK(&(_work)->work, (_func)) 336 337 /** 338 * work_pending - Find out whether a work item is currently pending 339 * @work: The work item in question 340 */ 341 #define work_pending(work) \ 342 test_bit(WORK_STRUCT_PENDING_BIT, work_data_bits(work)) 343 344 /** 345 * delayed_work_pending - Find out whether a delayable work item is currently 346 * pending 347 * @w: The work item in question 348 */ 349 #define delayed_work_pending(w) \ 350 work_pending(&(w)->work) 351 352 /* 353 * Workqueue flags and constants. For details, please refer to 354 * Documentation/core-api/workqueue.rst. 355 */ 356 enum { 357 WQ_UNBOUND = 1 << 1, /* not bound to any cpu */ 358 WQ_FREEZABLE = 1 << 2, /* freeze during suspend */ 359 WQ_MEM_RECLAIM = 1 << 3, /* may be used for memory reclaim */ 360 WQ_HIGHPRI = 1 << 4, /* high priority */ 361 WQ_CPU_INTENSIVE = 1 << 5, /* cpu intensive workqueue */ 362 WQ_SYSFS = 1 << 6, /* visible in sysfs, see workqueue_sysfs_register() */ 363 364 /* 365 * Per-cpu workqueues are generally preferred because they tend to 366 * show better performance thanks to cache locality. Per-cpu 367 * workqueues exclude the scheduler from choosing the CPU to 368 * execute the worker threads, which has an unfortunate side effect 369 * of increasing power consumption. 370 * 371 * The scheduler considers a CPU idle if it doesn't have any task 372 * to execute and tries to keep idle cores idle to conserve power; 373 * however, for example, a per-cpu work item scheduled from an 374 * interrupt handler on an idle CPU will force the scheduler to 375 * execute the work item on that CPU breaking the idleness, which in 376 * turn may lead to more scheduling choices which are sub-optimal 377 * in terms of power consumption. 378 * 379 * Workqueues marked with WQ_POWER_EFFICIENT are per-cpu by default 380 * but become unbound if workqueue.power_efficient kernel param is 381 * specified. Per-cpu workqueues which are identified to 382 * contribute significantly to power-consumption are identified and 383 * marked with this flag and enabling the power_efficient mode 384 * leads to noticeable power saving at the cost of small 385 * performance disadvantage. 386 * 387 * http://thread.gmane.org/gmane.linux.kernel/1480396 388 */ 389 WQ_POWER_EFFICIENT = 1 << 7, 390 391 __WQ_DESTROYING = 1 << 15, /* internal: workqueue is destroying */ 392 __WQ_DRAINING = 1 << 16, /* internal: workqueue is draining */ 393 __WQ_ORDERED = 1 << 17, /* internal: workqueue is ordered */ 394 __WQ_LEGACY = 1 << 18, /* internal: create*_workqueue() */ 395 __WQ_ORDERED_EXPLICIT = 1 << 19, /* internal: alloc_ordered_workqueue() */ 396 397 WQ_MAX_ACTIVE = 512, /* I like 512, better ideas? */ 398 WQ_UNBOUND_MAX_ACTIVE = WQ_MAX_ACTIVE, 399 WQ_DFL_ACTIVE = WQ_MAX_ACTIVE / 2, 400 }; 401 402 /* 403 * System-wide workqueues which are always present. 404 * 405 * system_wq is the one used by schedule[_delayed]_work[_on](). 406 * Multi-CPU multi-threaded. There are users which expect relatively 407 * short queue flush time. Don't queue works which can run for too 408 * long. 409 * 410 * system_highpri_wq is similar to system_wq but for work items which 411 * require WQ_HIGHPRI. 412 * 413 * system_long_wq is similar to system_wq but may host long running 414 * works. Queue flushing might take relatively long. 415 * 416 * system_unbound_wq is unbound workqueue. Workers are not bound to 417 * any specific CPU, not concurrency managed, and all queued works are 418 * executed immediately as long as max_active limit is not reached and 419 * resources are available. 420 * 421 * system_freezable_wq is equivalent to system_wq except that it's 422 * freezable. 423 * 424 * *_power_efficient_wq are inclined towards saving power and converted 425 * into WQ_UNBOUND variants if 'wq_power_efficient' is enabled; otherwise, 426 * they are same as their non-power-efficient counterparts - e.g. 427 * system_power_efficient_wq is identical to system_wq if 428 * 'wq_power_efficient' is disabled. See WQ_POWER_EFFICIENT for more info. 429 */ 430 extern struct workqueue_struct *system_wq; 431 extern struct workqueue_struct *system_highpri_wq; 432 extern struct workqueue_struct *system_long_wq; 433 extern struct workqueue_struct *system_unbound_wq; 434 extern struct workqueue_struct *system_freezable_wq; 435 extern struct workqueue_struct *system_power_efficient_wq; 436 extern struct workqueue_struct *system_freezable_power_efficient_wq; 437 438 /** 439 * alloc_workqueue - allocate a workqueue 440 * @fmt: printf format for the name of the workqueue 441 * @flags: WQ_* flags 442 * @max_active: max in-flight work items per CPU, 0 for default 443 * remaining args: args for @fmt 444 * 445 * Allocate a workqueue with the specified parameters. For detailed 446 * information on WQ_* flags, please refer to 447 * Documentation/core-api/workqueue.rst. 448 * 449 * RETURNS: 450 * Pointer to the allocated workqueue on success, %NULL on failure. 451 */ 452 __printf(1, 4) struct workqueue_struct * 453 alloc_workqueue(const char *fmt, unsigned int flags, int max_active, ...); 454 455 /** 456 * alloc_ordered_workqueue - allocate an ordered workqueue 457 * @fmt: printf format for the name of the workqueue 458 * @flags: WQ_* flags (only WQ_FREEZABLE and WQ_MEM_RECLAIM are meaningful) 459 * @args: args for @fmt 460 * 461 * Allocate an ordered workqueue. An ordered workqueue executes at 462 * most one work item at any given time in the queued order. They are 463 * implemented as unbound workqueues with @max_active of one. 464 * 465 * RETURNS: 466 * Pointer to the allocated workqueue on success, %NULL on failure. 467 */ 468 #define alloc_ordered_workqueue(fmt, flags, args...) \ 469 alloc_workqueue(fmt, WQ_UNBOUND | __WQ_ORDERED | \ 470 __WQ_ORDERED_EXPLICIT | (flags), 1, ##args) 471 472 #define create_workqueue(name) \ 473 alloc_workqueue("%s", __WQ_LEGACY | WQ_MEM_RECLAIM, 1, (name)) 474 #define create_freezable_workqueue(name) \ 475 alloc_workqueue("%s", __WQ_LEGACY | WQ_FREEZABLE | WQ_UNBOUND | \ 476 WQ_MEM_RECLAIM, 1, (name)) 477 #define create_singlethread_workqueue(name) \ 478 alloc_ordered_workqueue("%s", __WQ_LEGACY | WQ_MEM_RECLAIM, name) 479 480 extern void destroy_workqueue(struct workqueue_struct *wq); 481 482 struct workqueue_attrs *alloc_workqueue_attrs(void); 483 void free_workqueue_attrs(struct workqueue_attrs *attrs); 484 int apply_workqueue_attrs(struct workqueue_struct *wq, 485 const struct workqueue_attrs *attrs); 486 int workqueue_set_unbound_cpumask(cpumask_var_t cpumask); 487 488 extern bool queue_work_on(int cpu, struct workqueue_struct *wq, 489 struct work_struct *work); 490 extern bool queue_work_node(int node, struct workqueue_struct *wq, 491 struct work_struct *work); 492 extern bool queue_delayed_work_on(int cpu, struct workqueue_struct *wq, 493 struct delayed_work *work, unsigned long delay); 494 extern bool mod_delayed_work_on(int cpu, struct workqueue_struct *wq, 495 struct delayed_work *dwork, unsigned long delay); 496 extern bool queue_rcu_work(struct workqueue_struct *wq, struct rcu_work *rwork); 497 498 extern void __flush_workqueue(struct workqueue_struct *wq); 499 extern void drain_workqueue(struct workqueue_struct *wq); 500 501 extern int schedule_on_each_cpu(work_func_t func); 502 503 int execute_in_process_context(work_func_t fn, struct execute_work *); 504 505 extern bool flush_work(struct work_struct *work); 506 extern bool cancel_work(struct work_struct *work); 507 extern bool cancel_work_sync(struct work_struct *work); 508 509 extern bool flush_delayed_work(struct delayed_work *dwork); 510 extern bool cancel_delayed_work(struct delayed_work *dwork); 511 extern bool cancel_delayed_work_sync(struct delayed_work *dwork); 512 513 extern bool flush_rcu_work(struct rcu_work *rwork); 514 515 extern void workqueue_set_max_active(struct workqueue_struct *wq, 516 int max_active); 517 extern struct work_struct *current_work(void); 518 extern bool current_is_workqueue_rescuer(void); 519 extern bool workqueue_congested(int cpu, struct workqueue_struct *wq); 520 extern unsigned int work_busy(struct work_struct *work); 521 extern __printf(1, 2) void set_worker_desc(const char *fmt, ...); 522 extern void print_worker_info(const char *log_lvl, struct task_struct *task); 523 extern void show_all_workqueues(void); 524 extern void show_freezable_workqueues(void); 525 extern void show_one_workqueue(struct workqueue_struct *wq); 526 extern void wq_worker_comm(char *buf, size_t size, struct task_struct *task); 527 528 /** 529 * queue_work - queue work on a workqueue 530 * @wq: workqueue to use 531 * @work: work to queue 532 * 533 * Returns %false if @work was already on a queue, %true otherwise. 534 * 535 * We queue the work to the CPU on which it was submitted, but if the CPU dies 536 * it can be processed by another CPU. 537 * 538 * Memory-ordering properties: If it returns %true, guarantees that all stores 539 * preceding the call to queue_work() in the program order will be visible from 540 * the CPU which will execute @work by the time such work executes, e.g., 541 * 542 * { x is initially 0 } 543 * 544 * CPU0 CPU1 545 * 546 * WRITE_ONCE(x, 1); [ @work is being executed ] 547 * r0 = queue_work(wq, work); r1 = READ_ONCE(x); 548 * 549 * Forbids: r0 == true && r1 == 0 550 */ 551 static inline bool queue_work(struct workqueue_struct *wq, 552 struct work_struct *work) 553 { 554 return queue_work_on(WORK_CPU_UNBOUND, wq, work); 555 } 556 557 /** 558 * queue_delayed_work - queue work on a workqueue after delay 559 * @wq: workqueue to use 560 * @dwork: delayable work to queue 561 * @delay: number of jiffies to wait before queueing 562 * 563 * Equivalent to queue_delayed_work_on() but tries to use the local CPU. 564 */ 565 static inline bool queue_delayed_work(struct workqueue_struct *wq, 566 struct delayed_work *dwork, 567 unsigned long delay) 568 { 569 return queue_delayed_work_on(WORK_CPU_UNBOUND, wq, dwork, delay); 570 } 571 572 /** 573 * mod_delayed_work - modify delay of or queue a delayed work 574 * @wq: workqueue to use 575 * @dwork: work to queue 576 * @delay: number of jiffies to wait before queueing 577 * 578 * mod_delayed_work_on() on local CPU. 579 */ 580 static inline bool mod_delayed_work(struct workqueue_struct *wq, 581 struct delayed_work *dwork, 582 unsigned long delay) 583 { 584 return mod_delayed_work_on(WORK_CPU_UNBOUND, wq, dwork, delay); 585 } 586 587 /** 588 * schedule_work_on - put work task on a specific cpu 589 * @cpu: cpu to put the work task on 590 * @work: job to be done 591 * 592 * This puts a job on a specific cpu 593 */ 594 static inline bool schedule_work_on(int cpu, struct work_struct *work) 595 { 596 return queue_work_on(cpu, system_wq, work); 597 } 598 599 /** 600 * schedule_work - put work task in global workqueue 601 * @work: job to be done 602 * 603 * Returns %false if @work was already on the kernel-global workqueue and 604 * %true otherwise. 605 * 606 * This puts a job in the kernel-global workqueue if it was not already 607 * queued and leaves it in the same position on the kernel-global 608 * workqueue otherwise. 609 * 610 * Shares the same memory-ordering properties of queue_work(), cf. the 611 * DocBook header of queue_work(). 612 */ 613 static inline bool schedule_work(struct work_struct *work) 614 { 615 return queue_work(system_wq, work); 616 } 617 618 /* 619 * Detect attempt to flush system-wide workqueues at compile time when possible. 620 * Warn attempt to flush system-wide workqueues at runtime. 621 * 622 * See https://lkml.kernel.org/r/49925af7-78a8-a3dd-bce6-cfc02e1a9236@I-love.SAKURA.ne.jp 623 * for reasons and steps for converting system-wide workqueues into local workqueues. 624 */ 625 extern void __warn_flushing_systemwide_wq(void) 626 __compiletime_warning("Please avoid flushing system-wide workqueues."); 627 628 /* Please stop using this function, for this function will be removed in near future. */ 629 #define flush_scheduled_work() \ 630 ({ \ 631 __warn_flushing_systemwide_wq(); \ 632 __flush_workqueue(system_wq); \ 633 }) 634 635 #define flush_workqueue(wq) \ 636 ({ \ 637 struct workqueue_struct *_wq = (wq); \ 638 \ 639 if ((__builtin_constant_p(_wq == system_wq) && \ 640 _wq == system_wq) || \ 641 (__builtin_constant_p(_wq == system_highpri_wq) && \ 642 _wq == system_highpri_wq) || \ 643 (__builtin_constant_p(_wq == system_long_wq) && \ 644 _wq == system_long_wq) || \ 645 (__builtin_constant_p(_wq == system_unbound_wq) && \ 646 _wq == system_unbound_wq) || \ 647 (__builtin_constant_p(_wq == system_freezable_wq) && \ 648 _wq == system_freezable_wq) || \ 649 (__builtin_constant_p(_wq == system_power_efficient_wq) && \ 650 _wq == system_power_efficient_wq) || \ 651 (__builtin_constant_p(_wq == system_freezable_power_efficient_wq) && \ 652 _wq == system_freezable_power_efficient_wq)) \ 653 __warn_flushing_systemwide_wq(); \ 654 __flush_workqueue(_wq); \ 655 }) 656 657 /** 658 * schedule_delayed_work_on - queue work in global workqueue on CPU after delay 659 * @cpu: cpu to use 660 * @dwork: job to be done 661 * @delay: number of jiffies to wait 662 * 663 * After waiting for a given time this puts a job in the kernel-global 664 * workqueue on the specified CPU. 665 */ 666 static inline bool schedule_delayed_work_on(int cpu, struct delayed_work *dwork, 667 unsigned long delay) 668 { 669 return queue_delayed_work_on(cpu, system_wq, dwork, delay); 670 } 671 672 /** 673 * schedule_delayed_work - put work task in global workqueue after delay 674 * @dwork: job to be done 675 * @delay: number of jiffies to wait or 0 for immediate execution 676 * 677 * After waiting for a given time this puts a job in the kernel-global 678 * workqueue. 679 */ 680 static inline bool schedule_delayed_work(struct delayed_work *dwork, 681 unsigned long delay) 682 { 683 return queue_delayed_work(system_wq, dwork, delay); 684 } 685 686 #ifndef CONFIG_SMP 687 static inline long work_on_cpu(int cpu, long (*fn)(void *), void *arg) 688 { 689 return fn(arg); 690 } 691 static inline long work_on_cpu_safe(int cpu, long (*fn)(void *), void *arg) 692 { 693 return fn(arg); 694 } 695 #else 696 long work_on_cpu(int cpu, long (*fn)(void *), void *arg); 697 long work_on_cpu_safe(int cpu, long (*fn)(void *), void *arg); 698 #endif /* CONFIG_SMP */ 699 700 #ifdef CONFIG_FREEZER 701 extern void freeze_workqueues_begin(void); 702 extern bool freeze_workqueues_busy(void); 703 extern void thaw_workqueues(void); 704 #endif /* CONFIG_FREEZER */ 705 706 #ifdef CONFIG_SYSFS 707 int workqueue_sysfs_register(struct workqueue_struct *wq); 708 #else /* CONFIG_SYSFS */ 709 static inline int workqueue_sysfs_register(struct workqueue_struct *wq) 710 { return 0; } 711 #endif /* CONFIG_SYSFS */ 712 713 #ifdef CONFIG_WQ_WATCHDOG 714 void wq_watchdog_touch(int cpu); 715 #else /* CONFIG_WQ_WATCHDOG */ 716 static inline void wq_watchdog_touch(int cpu) { } 717 #endif /* CONFIG_WQ_WATCHDOG */ 718 719 #ifdef CONFIG_SMP 720 int workqueue_prepare_cpu(unsigned int cpu); 721 int workqueue_online_cpu(unsigned int cpu); 722 int workqueue_offline_cpu(unsigned int cpu); 723 #endif 724 725 void __init workqueue_init_early(void); 726 void __init workqueue_init(void); 727 void __init workqueue_init_topology(void); 728 729 #endif 730