1/* 2 * workqueue.h --- work queue handling for Linux. 3 */ 4 5#ifndef _LINUX_WORKQUEUE_H 6#define _LINUX_WORKQUEUE_H 7 8#include <linux/timer.h> 9#include <linux/linkage.h> 10#include <linux/bitops.h> 11#include <linux/lockdep.h> 12#include <linux/threads.h> 13#include <linux/atomic.h> 14#include <linux/cpumask.h> 15 16struct workqueue_struct; 17 18struct work_struct; 19typedef void (*work_func_t)(struct work_struct *work); 20void delayed_work_timer_fn(unsigned long __data); 21 22/* 23 * The first word is the work queue pointer and the flags rolled into 24 * one 25 */ 26#define work_data_bits(work) ((unsigned long *)(&(work)->data)) 27 28enum { 29 WORK_STRUCT_PENDING_BIT = 0, /* work item is pending execution */ 30 WORK_STRUCT_DELAYED_BIT = 1, /* work item is delayed */ 31 WORK_STRUCT_PWQ_BIT = 2, /* data points to pwq */ 32 WORK_STRUCT_LINKED_BIT = 3, /* next work is linked to this one */ 33#ifdef CONFIG_DEBUG_OBJECTS_WORK 34 WORK_STRUCT_STATIC_BIT = 4, /* static initializer (debugobjects) */ 35 WORK_STRUCT_COLOR_SHIFT = 5, /* color for workqueue flushing */ 36#else 37 WORK_STRUCT_COLOR_SHIFT = 4, /* color for workqueue flushing */ 38#endif 39 40 WORK_STRUCT_COLOR_BITS = 4, 41 42 WORK_STRUCT_PENDING = 1 << WORK_STRUCT_PENDING_BIT, 43 WORK_STRUCT_DELAYED = 1 << WORK_STRUCT_DELAYED_BIT, 44 WORK_STRUCT_PWQ = 1 << WORK_STRUCT_PWQ_BIT, 45 WORK_STRUCT_LINKED = 1 << WORK_STRUCT_LINKED_BIT, 46#ifdef CONFIG_DEBUG_OBJECTS_WORK 47 WORK_STRUCT_STATIC = 1 << WORK_STRUCT_STATIC_BIT, 48#else 49 WORK_STRUCT_STATIC = 0, 50#endif 51 52 /* 53 * The last color is no color used for works which don't 54 * participate in workqueue flushing. 55 */ 56 WORK_NR_COLORS = (1 << WORK_STRUCT_COLOR_BITS) - 1, 57 WORK_NO_COLOR = WORK_NR_COLORS, 58 59 /* not bound to any CPU, prefer the local CPU */ 60 WORK_CPU_UNBOUND = NR_CPUS, 61 62 /* 63 * Reserve 7 bits off of pwq pointer w/ debugobjects turned off. 64 * This makes pwqs aligned to 256 bytes and allows 15 workqueue 65 * flush colors. 66 */ 67 WORK_STRUCT_FLAG_BITS = WORK_STRUCT_COLOR_SHIFT + 68 WORK_STRUCT_COLOR_BITS, 69 70 /* data contains off-queue information when !WORK_STRUCT_PWQ */ 71 WORK_OFFQ_FLAG_BASE = WORK_STRUCT_COLOR_SHIFT, 72 73 __WORK_OFFQ_CANCELING = WORK_OFFQ_FLAG_BASE, 74 WORK_OFFQ_CANCELING = (1 << __WORK_OFFQ_CANCELING), 75 76 /* 77 * When a work item is off queue, its high bits point to the last 78 * pool it was on. Cap at 31 bits and use the highest number to 79 * indicate that no pool is associated. 80 */ 81 WORK_OFFQ_FLAG_BITS = 1, 82 WORK_OFFQ_POOL_SHIFT = WORK_OFFQ_FLAG_BASE + WORK_OFFQ_FLAG_BITS, 83 WORK_OFFQ_LEFT = BITS_PER_LONG - WORK_OFFQ_POOL_SHIFT, 84 WORK_OFFQ_POOL_BITS = WORK_OFFQ_LEFT <= 31 ? WORK_OFFQ_LEFT : 31, 85 WORK_OFFQ_POOL_NONE = (1LU << WORK_OFFQ_POOL_BITS) - 1, 86 87 /* convenience constants */ 88 WORK_STRUCT_FLAG_MASK = (1UL << WORK_STRUCT_FLAG_BITS) - 1, 89 WORK_STRUCT_WQ_DATA_MASK = ~WORK_STRUCT_FLAG_MASK, 90 WORK_STRUCT_NO_POOL = (unsigned long)WORK_OFFQ_POOL_NONE << WORK_OFFQ_POOL_SHIFT, 91 92 /* bit mask for work_busy() return values */ 93 WORK_BUSY_PENDING = 1 << 0, 94 WORK_BUSY_RUNNING = 1 << 1, 95 96 /* maximum string length for set_worker_desc() */ 97 WORKER_DESC_LEN = 24, 98}; 99 100struct work_struct { 101 atomic_long_t data; 102 struct list_head entry; 103 work_func_t func; 104#ifdef CONFIG_LOCKDEP 105 struct lockdep_map lockdep_map; 106#endif 107}; 108 109#define WORK_DATA_INIT() ATOMIC_LONG_INIT(WORK_STRUCT_NO_POOL) 110#define WORK_DATA_STATIC_INIT() \ 111 ATOMIC_LONG_INIT(WORK_STRUCT_NO_POOL | WORK_STRUCT_STATIC) 112 113struct delayed_work { 114 struct work_struct work; 115 struct timer_list timer; 116 117 /* target workqueue and CPU ->timer uses to queue ->work */ 118 struct workqueue_struct *wq; 119 int cpu; 120}; 121 122/* 123 * A struct for workqueue attributes. This can be used to change 124 * attributes of an unbound workqueue. 125 * 126 * Unlike other fields, ->no_numa isn't a property of a worker_pool. It 127 * only modifies how apply_workqueue_attrs() select pools and thus doesn't 128 * participate in pool hash calculations or equality comparisons. 129 */ 130struct workqueue_attrs { 131 int nice; /* nice level */ 132 cpumask_var_t cpumask; /* allowed CPUs */ 133 bool no_numa; /* disable NUMA affinity */ 134}; 135 136static inline struct delayed_work *to_delayed_work(struct work_struct *work) 137{ 138 return container_of(work, struct delayed_work, work); 139} 140 141struct execute_work { 142 struct work_struct work; 143}; 144 145#ifdef CONFIG_LOCKDEP 146/* 147 * NB: because we have to copy the lockdep_map, setting _key 148 * here is required, otherwise it could get initialised to the 149 * copy of the lockdep_map! 150 */ 151#define __WORK_INIT_LOCKDEP_MAP(n, k) \ 152 .lockdep_map = STATIC_LOCKDEP_MAP_INIT(n, k), 153#else 154#define __WORK_INIT_LOCKDEP_MAP(n, k) 155#endif 156 157#define __WORK_INITIALIZER(n, f) { \ 158 .data = WORK_DATA_STATIC_INIT(), \ 159 .entry = { &(n).entry, &(n).entry }, \ 160 .func = (f), \ 161 __WORK_INIT_LOCKDEP_MAP(#n, &(n)) \ 162 } 163 164#define __DELAYED_WORK_INITIALIZER(n, f, tflags) { \ 165 .work = __WORK_INITIALIZER((n).work, (f)), \ 166 .timer = __TIMER_INITIALIZER(delayed_work_timer_fn, \ 167 0, (unsigned long)&(n), \ 168 (tflags) | TIMER_IRQSAFE), \ 169 } 170 171#define DECLARE_WORK(n, f) \ 172 struct work_struct n = __WORK_INITIALIZER(n, f) 173 174#define DECLARE_DELAYED_WORK(n, f) \ 175 struct delayed_work n = __DELAYED_WORK_INITIALIZER(n, f, 0) 176 177#define DECLARE_DEFERRABLE_WORK(n, f) \ 178 struct delayed_work n = __DELAYED_WORK_INITIALIZER(n, f, TIMER_DEFERRABLE) 179 180#ifdef CONFIG_DEBUG_OBJECTS_WORK 181extern void __init_work(struct work_struct *work, int onstack); 182extern void destroy_work_on_stack(struct work_struct *work); 183extern void destroy_delayed_work_on_stack(struct delayed_work *work); 184static inline unsigned int work_static(struct work_struct *work) 185{ 186 return *work_data_bits(work) & WORK_STRUCT_STATIC; 187} 188#else 189static inline void __init_work(struct work_struct *work, int onstack) { } 190static inline void destroy_work_on_stack(struct work_struct *work) { } 191static inline void destroy_delayed_work_on_stack(struct delayed_work *work) { } 192static inline unsigned int work_static(struct work_struct *work) { return 0; } 193#endif 194 195/* 196 * initialize all of a work item in one go 197 * 198 * NOTE! No point in using "atomic_long_set()": using a direct 199 * assignment of the work data initializer allows the compiler 200 * to generate better code. 201 */ 202#ifdef CONFIG_LOCKDEP 203#define __INIT_WORK(_work, _func, _onstack) \ 204 do { \ 205 static struct lock_class_key __key; \ 206 \ 207 __init_work((_work), _onstack); \ 208 (_work)->data = (atomic_long_t) WORK_DATA_INIT(); \ 209 lockdep_init_map(&(_work)->lockdep_map, #_work, &__key, 0); \ 210 INIT_LIST_HEAD(&(_work)->entry); \ 211 (_work)->func = (_func); \ 212 } while (0) 213#else 214#define __INIT_WORK(_work, _func, _onstack) \ 215 do { \ 216 __init_work((_work), _onstack); \ 217 (_work)->data = (atomic_long_t) WORK_DATA_INIT(); \ 218 INIT_LIST_HEAD(&(_work)->entry); \ 219 (_work)->func = (_func); \ 220 } while (0) 221#endif 222 223#define INIT_WORK(_work, _func) \ 224 __INIT_WORK((_work), (_func), 0) 225 226#define INIT_WORK_ONSTACK(_work, _func) \ 227 __INIT_WORK((_work), (_func), 1) 228 229#define __INIT_DELAYED_WORK(_work, _func, _tflags) \ 230 do { \ 231 INIT_WORK(&(_work)->work, (_func)); \ 232 __setup_timer(&(_work)->timer, delayed_work_timer_fn, \ 233 (unsigned long)(_work), \ 234 (_tflags) | TIMER_IRQSAFE); \ 235 } while (0) 236 237#define __INIT_DELAYED_WORK_ONSTACK(_work, _func, _tflags) \ 238 do { \ 239 INIT_WORK_ONSTACK(&(_work)->work, (_func)); \ 240 __setup_timer_on_stack(&(_work)->timer, \ 241 delayed_work_timer_fn, \ 242 (unsigned long)(_work), \ 243 (_tflags) | TIMER_IRQSAFE); \ 244 } while (0) 245 246#define INIT_DELAYED_WORK(_work, _func) \ 247 __INIT_DELAYED_WORK(_work, _func, 0) 248 249#define INIT_DELAYED_WORK_ONSTACK(_work, _func) \ 250 __INIT_DELAYED_WORK_ONSTACK(_work, _func, 0) 251 252#define INIT_DEFERRABLE_WORK(_work, _func) \ 253 __INIT_DELAYED_WORK(_work, _func, TIMER_DEFERRABLE) 254 255#define INIT_DEFERRABLE_WORK_ONSTACK(_work, _func) \ 256 __INIT_DELAYED_WORK_ONSTACK(_work, _func, TIMER_DEFERRABLE) 257 258/** 259 * work_pending - Find out whether a work item is currently pending 260 * @work: The work item in question 261 */ 262#define work_pending(work) \ 263 test_bit(WORK_STRUCT_PENDING_BIT, work_data_bits(work)) 264 265/** 266 * delayed_work_pending - Find out whether a delayable work item is currently 267 * pending 268 * @work: The work item in question 269 */ 270#define delayed_work_pending(w) \ 271 work_pending(&(w)->work) 272 273/* 274 * Workqueue flags and constants. For details, please refer to 275 * Documentation/workqueue.txt. 276 */ 277enum { 278 WQ_UNBOUND = 1 << 1, /* not bound to any cpu */ 279 WQ_FREEZABLE = 1 << 2, /* freeze during suspend */ 280 WQ_MEM_RECLAIM = 1 << 3, /* may be used for memory reclaim */ 281 WQ_HIGHPRI = 1 << 4, /* high priority */ 282 WQ_CPU_INTENSIVE = 1 << 5, /* cpu intensive workqueue */ 283 WQ_SYSFS = 1 << 6, /* visible in sysfs, see wq_sysfs_register() */ 284 285 /* 286 * Per-cpu workqueues are generally preferred because they tend to 287 * show better performance thanks to cache locality. Per-cpu 288 * workqueues exclude the scheduler from choosing the CPU to 289 * execute the worker threads, which has an unfortunate side effect 290 * of increasing power consumption. 291 * 292 * The scheduler considers a CPU idle if it doesn't have any task 293 * to execute and tries to keep idle cores idle to conserve power; 294 * however, for example, a per-cpu work item scheduled from an 295 * interrupt handler on an idle CPU will force the scheduler to 296 * excute the work item on that CPU breaking the idleness, which in 297 * turn may lead to more scheduling choices which are sub-optimal 298 * in terms of power consumption. 299 * 300 * Workqueues marked with WQ_POWER_EFFICIENT are per-cpu by default 301 * but become unbound if workqueue.power_efficient kernel param is 302 * specified. Per-cpu workqueues which are identified to 303 * contribute significantly to power-consumption are identified and 304 * marked with this flag and enabling the power_efficient mode 305 * leads to noticeable power saving at the cost of small 306 * performance disadvantage. 307 * 308 * http://thread.gmane.org/gmane.linux.kernel/1480396 309 */ 310 WQ_POWER_EFFICIENT = 1 << 7, 311 312 __WQ_DRAINING = 1 << 16, /* internal: workqueue is draining */ 313 __WQ_ORDERED = 1 << 17, /* internal: workqueue is ordered */ 314 315 WQ_MAX_ACTIVE = 512, /* I like 512, better ideas? */ 316 WQ_MAX_UNBOUND_PER_CPU = 4, /* 4 * #cpus for unbound wq */ 317 WQ_DFL_ACTIVE = WQ_MAX_ACTIVE / 2, 318}; 319 320/* unbound wq's aren't per-cpu, scale max_active according to #cpus */ 321#define WQ_UNBOUND_MAX_ACTIVE \ 322 max_t(int, WQ_MAX_ACTIVE, num_possible_cpus() * WQ_MAX_UNBOUND_PER_CPU) 323 324/* 325 * System-wide workqueues which are always present. 326 * 327 * system_wq is the one used by schedule[_delayed]_work[_on](). 328 * Multi-CPU multi-threaded. There are users which expect relatively 329 * short queue flush time. Don't queue works which can run for too 330 * long. 331 * 332 * system_highpri_wq is similar to system_wq but for work items which 333 * require WQ_HIGHPRI. 334 * 335 * system_long_wq is similar to system_wq but may host long running 336 * works. Queue flushing might take relatively long. 337 * 338 * system_unbound_wq is unbound workqueue. Workers are not bound to 339 * any specific CPU, not concurrency managed, and all queued works are 340 * executed immediately as long as max_active limit is not reached and 341 * resources are available. 342 * 343 * system_freezable_wq is equivalent to system_wq except that it's 344 * freezable. 345 * 346 * *_power_efficient_wq are inclined towards saving power and converted 347 * into WQ_UNBOUND variants if 'wq_power_efficient' is enabled; otherwise, 348 * they are same as their non-power-efficient counterparts - e.g. 349 * system_power_efficient_wq is identical to system_wq if 350 * 'wq_power_efficient' is disabled. See WQ_POWER_EFFICIENT for more info. 351 */ 352extern struct workqueue_struct *system_wq; 353extern struct workqueue_struct *system_highpri_wq; 354extern struct workqueue_struct *system_long_wq; 355extern struct workqueue_struct *system_unbound_wq; 356extern struct workqueue_struct *system_freezable_wq; 357extern struct workqueue_struct *system_power_efficient_wq; 358extern struct workqueue_struct *system_freezable_power_efficient_wq; 359 360extern struct workqueue_struct * 361__alloc_workqueue_key(const char *fmt, unsigned int flags, int max_active, 362 struct lock_class_key *key, const char *lock_name, ...) __printf(1, 6); 363 364/** 365 * alloc_workqueue - allocate a workqueue 366 * @fmt: printf format for the name of the workqueue 367 * @flags: WQ_* flags 368 * @max_active: max in-flight work items, 0 for default 369 * @args: args for @fmt 370 * 371 * Allocate a workqueue with the specified parameters. For detailed 372 * information on WQ_* flags, please refer to Documentation/workqueue.txt. 373 * 374 * The __lock_name macro dance is to guarantee that single lock_class_key 375 * doesn't end up with different namesm, which isn't allowed by lockdep. 376 * 377 * RETURNS: 378 * Pointer to the allocated workqueue on success, %NULL on failure. 379 */ 380#ifdef CONFIG_LOCKDEP 381#define alloc_workqueue(fmt, flags, max_active, args...) \ 382({ \ 383 static struct lock_class_key __key; \ 384 const char *__lock_name; \ 385 \ 386 __lock_name = #fmt#args; \ 387 \ 388 __alloc_workqueue_key((fmt), (flags), (max_active), \ 389 &__key, __lock_name, ##args); \ 390}) 391#else 392#define alloc_workqueue(fmt, flags, max_active, args...) \ 393 __alloc_workqueue_key((fmt), (flags), (max_active), \ 394 NULL, NULL, ##args) 395#endif 396 397/** 398 * alloc_ordered_workqueue - allocate an ordered workqueue 399 * @fmt: printf format for the name of the workqueue 400 * @flags: WQ_* flags (only WQ_FREEZABLE and WQ_MEM_RECLAIM are meaningful) 401 * @args: args for @fmt 402 * 403 * Allocate an ordered workqueue. An ordered workqueue executes at 404 * most one work item at any given time in the queued order. They are 405 * implemented as unbound workqueues with @max_active of one. 406 * 407 * RETURNS: 408 * Pointer to the allocated workqueue on success, %NULL on failure. 409 */ 410#define alloc_ordered_workqueue(fmt, flags, args...) \ 411 alloc_workqueue(fmt, WQ_UNBOUND | __WQ_ORDERED | (flags), 1, ##args) 412 413#define create_workqueue(name) \ 414 alloc_workqueue("%s", WQ_MEM_RECLAIM, 1, (name)) 415#define create_freezable_workqueue(name) \ 416 alloc_workqueue("%s", WQ_FREEZABLE | WQ_UNBOUND | WQ_MEM_RECLAIM, \ 417 1, (name)) 418#define create_singlethread_workqueue(name) \ 419 alloc_ordered_workqueue("%s", WQ_MEM_RECLAIM, name) 420 421extern void destroy_workqueue(struct workqueue_struct *wq); 422 423struct workqueue_attrs *alloc_workqueue_attrs(gfp_t gfp_mask); 424void free_workqueue_attrs(struct workqueue_attrs *attrs); 425int apply_workqueue_attrs(struct workqueue_struct *wq, 426 const struct workqueue_attrs *attrs); 427 428extern bool queue_work_on(int cpu, struct workqueue_struct *wq, 429 struct work_struct *work); 430extern bool queue_delayed_work_on(int cpu, struct workqueue_struct *wq, 431 struct delayed_work *work, unsigned long delay); 432extern bool mod_delayed_work_on(int cpu, struct workqueue_struct *wq, 433 struct delayed_work *dwork, unsigned long delay); 434 435extern void flush_workqueue(struct workqueue_struct *wq); 436extern void drain_workqueue(struct workqueue_struct *wq); 437extern void flush_scheduled_work(void); 438 439extern int schedule_on_each_cpu(work_func_t func); 440 441int execute_in_process_context(work_func_t fn, struct execute_work *); 442 443extern bool flush_work(struct work_struct *work); 444extern bool cancel_work_sync(struct work_struct *work); 445 446extern bool flush_delayed_work(struct delayed_work *dwork); 447extern bool cancel_delayed_work(struct delayed_work *dwork); 448extern bool cancel_delayed_work_sync(struct delayed_work *dwork); 449 450extern void workqueue_set_max_active(struct workqueue_struct *wq, 451 int max_active); 452extern bool current_is_workqueue_rescuer(void); 453extern bool workqueue_congested(int cpu, struct workqueue_struct *wq); 454extern unsigned int work_busy(struct work_struct *work); 455extern __printf(1, 2) void set_worker_desc(const char *fmt, ...); 456extern void print_worker_info(const char *log_lvl, struct task_struct *task); 457extern void show_workqueue_state(void); 458 459/** 460 * queue_work - queue work on a workqueue 461 * @wq: workqueue to use 462 * @work: work to queue 463 * 464 * Returns %false if @work was already on a queue, %true otherwise. 465 * 466 * We queue the work to the CPU on which it was submitted, but if the CPU dies 467 * it can be processed by another CPU. 468 */ 469static inline bool queue_work(struct workqueue_struct *wq, 470 struct work_struct *work) 471{ 472 return queue_work_on(WORK_CPU_UNBOUND, wq, work); 473} 474 475/** 476 * queue_delayed_work - queue work on a workqueue after delay 477 * @wq: workqueue to use 478 * @dwork: delayable work to queue 479 * @delay: number of jiffies to wait before queueing 480 * 481 * Equivalent to queue_delayed_work_on() but tries to use the local CPU. 482 */ 483static inline bool queue_delayed_work(struct workqueue_struct *wq, 484 struct delayed_work *dwork, 485 unsigned long delay) 486{ 487 return queue_delayed_work_on(WORK_CPU_UNBOUND, wq, dwork, delay); 488} 489 490/** 491 * mod_delayed_work - modify delay of or queue a delayed work 492 * @wq: workqueue to use 493 * @dwork: work to queue 494 * @delay: number of jiffies to wait before queueing 495 * 496 * mod_delayed_work_on() on local CPU. 497 */ 498static inline bool mod_delayed_work(struct workqueue_struct *wq, 499 struct delayed_work *dwork, 500 unsigned long delay) 501{ 502 return mod_delayed_work_on(WORK_CPU_UNBOUND, wq, dwork, delay); 503} 504 505/** 506 * schedule_work_on - put work task on a specific cpu 507 * @cpu: cpu to put the work task on 508 * @work: job to be done 509 * 510 * This puts a job on a specific cpu 511 */ 512static inline bool schedule_work_on(int cpu, struct work_struct *work) 513{ 514 return queue_work_on(cpu, system_wq, work); 515} 516 517/** 518 * schedule_work - put work task in global workqueue 519 * @work: job to be done 520 * 521 * Returns %false if @work was already on the kernel-global workqueue and 522 * %true otherwise. 523 * 524 * This puts a job in the kernel-global workqueue if it was not already 525 * queued and leaves it in the same position on the kernel-global 526 * workqueue otherwise. 527 */ 528static inline bool schedule_work(struct work_struct *work) 529{ 530 return queue_work(system_wq, work); 531} 532 533/** 534 * schedule_delayed_work_on - queue work in global workqueue on CPU after delay 535 * @cpu: cpu to use 536 * @dwork: job to be done 537 * @delay: number of jiffies to wait 538 * 539 * After waiting for a given time this puts a job in the kernel-global 540 * workqueue on the specified CPU. 541 */ 542static inline bool schedule_delayed_work_on(int cpu, struct delayed_work *dwork, 543 unsigned long delay) 544{ 545 return queue_delayed_work_on(cpu, system_wq, dwork, delay); 546} 547 548/** 549 * schedule_delayed_work - put work task in global workqueue after delay 550 * @dwork: job to be done 551 * @delay: number of jiffies to wait or 0 for immediate execution 552 * 553 * After waiting for a given time this puts a job in the kernel-global 554 * workqueue. 555 */ 556static inline bool schedule_delayed_work(struct delayed_work *dwork, 557 unsigned long delay) 558{ 559 return queue_delayed_work(system_wq, dwork, delay); 560} 561 562/** 563 * keventd_up - is workqueue initialized yet? 564 */ 565static inline bool keventd_up(void) 566{ 567 return system_wq != NULL; 568} 569 570#ifndef CONFIG_SMP 571static inline long work_on_cpu(int cpu, long (*fn)(void *), void *arg) 572{ 573 return fn(arg); 574} 575#else 576long work_on_cpu(int cpu, long (*fn)(void *), void *arg); 577#endif /* CONFIG_SMP */ 578 579#ifdef CONFIG_FREEZER 580extern void freeze_workqueues_begin(void); 581extern bool freeze_workqueues_busy(void); 582extern void thaw_workqueues(void); 583#endif /* CONFIG_FREEZER */ 584 585#ifdef CONFIG_SYSFS 586int workqueue_sysfs_register(struct workqueue_struct *wq); 587#else /* CONFIG_SYSFS */ 588static inline int workqueue_sysfs_register(struct workqueue_struct *wq) 589{ return 0; } 590#endif /* CONFIG_SYSFS */ 591 592#endif 593