11da177e4SLinus Torvalds /* 21da177e4SLinus Torvalds * workqueue.h --- work queue handling for Linux. 31da177e4SLinus Torvalds */ 41da177e4SLinus Torvalds 51da177e4SLinus Torvalds #ifndef _LINUX_WORKQUEUE_H 61da177e4SLinus Torvalds #define _LINUX_WORKQUEUE_H 71da177e4SLinus Torvalds 81da177e4SLinus Torvalds #include <linux/timer.h> 91da177e4SLinus Torvalds #include <linux/linkage.h> 101da177e4SLinus Torvalds #include <linux/bitops.h> 114e6045f1SJohannes Berg #include <linux/lockdep.h> 127a22ad75STejun Heo #include <linux/threads.h> 1360063497SArun Sharma #include <linux/atomic.h> 141da177e4SLinus Torvalds 151da177e4SLinus Torvalds struct workqueue_struct; 161da177e4SLinus Torvalds 1765f27f38SDavid Howells struct work_struct; 1865f27f38SDavid Howells typedef void (*work_func_t)(struct work_struct *work); 19d8e794dfSTejun Heo void delayed_work_timer_fn(unsigned long __data); 206bb49e59SDavid Howells 21a08727baSLinus Torvalds /* 22a08727baSLinus Torvalds * The first word is the work queue pointer and the flags rolled into 23a08727baSLinus Torvalds * one 24a08727baSLinus Torvalds */ 25a08727baSLinus Torvalds #define work_data_bits(work) ((unsigned long *)(&(work)->data)) 26a08727baSLinus Torvalds 2722df02bbSTejun Heo enum { 2822df02bbSTejun Heo WORK_STRUCT_PENDING_BIT = 0, /* work item is pending execution */ 298a2e8e5dSTejun Heo WORK_STRUCT_DELAYED_BIT = 1, /* work item is delayed */ 308a2e8e5dSTejun Heo WORK_STRUCT_CWQ_BIT = 2, /* data points to cwq */ 318a2e8e5dSTejun Heo WORK_STRUCT_LINKED_BIT = 3, /* next work is linked to this one */ 3222df02bbSTejun Heo #ifdef CONFIG_DEBUG_OBJECTS_WORK 338a2e8e5dSTejun Heo WORK_STRUCT_STATIC_BIT = 4, /* static initializer (debugobjects) */ 348a2e8e5dSTejun Heo WORK_STRUCT_COLOR_SHIFT = 5, /* color for workqueue flushing */ 350f900049STejun Heo #else 368a2e8e5dSTejun Heo WORK_STRUCT_COLOR_SHIFT = 4, /* color for workqueue flushing */ 3722df02bbSTejun Heo #endif 3822df02bbSTejun Heo 3973f53c4aSTejun Heo WORK_STRUCT_COLOR_BITS = 4, 4073f53c4aSTejun Heo 4122df02bbSTejun Heo WORK_STRUCT_PENDING = 1 << WORK_STRUCT_PENDING_BIT, 428a2e8e5dSTejun Heo WORK_STRUCT_DELAYED = 1 << WORK_STRUCT_DELAYED_BIT, 43e120153dSTejun Heo WORK_STRUCT_CWQ = 1 << WORK_STRUCT_CWQ_BIT, 44affee4b2STejun Heo WORK_STRUCT_LINKED = 1 << WORK_STRUCT_LINKED_BIT, 4522df02bbSTejun Heo #ifdef CONFIG_DEBUG_OBJECTS_WORK 4622df02bbSTejun Heo WORK_STRUCT_STATIC = 1 << WORK_STRUCT_STATIC_BIT, 4722df02bbSTejun Heo #else 4822df02bbSTejun Heo WORK_STRUCT_STATIC = 0, 4922df02bbSTejun Heo #endif 5022df02bbSTejun Heo 5173f53c4aSTejun Heo /* 5273f53c4aSTejun Heo * The last color is no color used for works which don't 5373f53c4aSTejun Heo * participate in workqueue flushing. 5473f53c4aSTejun Heo */ 5573f53c4aSTejun Heo WORK_NR_COLORS = (1 << WORK_STRUCT_COLOR_BITS) - 1, 5673f53c4aSTejun Heo WORK_NO_COLOR = WORK_NR_COLORS, 5773f53c4aSTejun Heo 58bdbc5dd7STejun Heo /* special cpu IDs */ 59f3421797STejun Heo WORK_CPU_UNBOUND = NR_CPUS, 60f3421797STejun Heo WORK_CPU_NONE = NR_CPUS + 1, 61bdbc5dd7STejun Heo WORK_CPU_LAST = WORK_CPU_NONE, 62bdbc5dd7STejun Heo 6373f53c4aSTejun Heo /* 64e120153dSTejun Heo * Reserve 7 bits off of cwq pointer w/ debugobjects turned 658a2e8e5dSTejun Heo * off. This makes cwqs aligned to 256 bytes and allows 15 668a2e8e5dSTejun Heo * workqueue flush colors. 6773f53c4aSTejun Heo */ 6873f53c4aSTejun Heo WORK_STRUCT_FLAG_BITS = WORK_STRUCT_COLOR_SHIFT + 6973f53c4aSTejun Heo WORK_STRUCT_COLOR_BITS, 7073f53c4aSTejun Heo 71b5490077STejun Heo /* data contains off-queue information when !WORK_STRUCT_CWQ */ 72b5490077STejun Heo WORK_OFFQ_FLAG_BASE = WORK_STRUCT_FLAG_BITS, 73bbb68dfaSTejun Heo 74bbb68dfaSTejun Heo WORK_OFFQ_CANCELING = (1 << WORK_OFFQ_FLAG_BASE), 75bbb68dfaSTejun Heo 76bbb68dfaSTejun Heo WORK_OFFQ_FLAG_BITS = 1, 77b5490077STejun Heo WORK_OFFQ_CPU_SHIFT = WORK_OFFQ_FLAG_BASE + WORK_OFFQ_FLAG_BITS, 78b5490077STejun Heo 79b5490077STejun Heo /* convenience constants */ 800f900049STejun Heo WORK_STRUCT_FLAG_MASK = (1UL << WORK_STRUCT_FLAG_BITS) - 1, 8122df02bbSTejun Heo WORK_STRUCT_WQ_DATA_MASK = ~WORK_STRUCT_FLAG_MASK, 82b5490077STejun Heo WORK_STRUCT_NO_CPU = (unsigned long)WORK_CPU_NONE << WORK_OFFQ_CPU_SHIFT, 83dcd989cbSTejun Heo 84dcd989cbSTejun Heo /* bit mask for work_busy() return values */ 85dcd989cbSTejun Heo WORK_BUSY_PENDING = 1 << 0, 86dcd989cbSTejun Heo WORK_BUSY_RUNNING = 1 << 1, 8722df02bbSTejun Heo }; 8822df02bbSTejun Heo 891da177e4SLinus Torvalds struct work_struct { 90a08727baSLinus Torvalds atomic_long_t data; 911da177e4SLinus Torvalds struct list_head entry; 926bb49e59SDavid Howells work_func_t func; 934e6045f1SJohannes Berg #ifdef CONFIG_LOCKDEP 944e6045f1SJohannes Berg struct lockdep_map lockdep_map; 954e6045f1SJohannes Berg #endif 9652bad64dSDavid Howells }; 9752bad64dSDavid Howells 987a22ad75STejun Heo #define WORK_DATA_INIT() ATOMIC_LONG_INIT(WORK_STRUCT_NO_CPU) 997a22ad75STejun Heo #define WORK_DATA_STATIC_INIT() \ 1007a22ad75STejun Heo ATOMIC_LONG_INIT(WORK_STRUCT_NO_CPU | WORK_STRUCT_STATIC) 101a08727baSLinus Torvalds 10252bad64dSDavid Howells struct delayed_work { 10352bad64dSDavid Howells struct work_struct work; 1041da177e4SLinus Torvalds struct timer_list timer; 1051265057fSTejun Heo int cpu; 1061da177e4SLinus Torvalds }; 1071da177e4SLinus Torvalds 108bf6aede7SJean Delvare static inline struct delayed_work *to_delayed_work(struct work_struct *work) 109bf6aede7SJean Delvare { 110bf6aede7SJean Delvare return container_of(work, struct delayed_work, work); 111bf6aede7SJean Delvare } 112bf6aede7SJean Delvare 1131fa44ecaSJames Bottomley struct execute_work { 1141fa44ecaSJames Bottomley struct work_struct work; 1151fa44ecaSJames Bottomley }; 1161fa44ecaSJames Bottomley 1174e6045f1SJohannes Berg #ifdef CONFIG_LOCKDEP 1184e6045f1SJohannes Berg /* 1194e6045f1SJohannes Berg * NB: because we have to copy the lockdep_map, setting _key 1204e6045f1SJohannes Berg * here is required, otherwise it could get initialised to the 1214e6045f1SJohannes Berg * copy of the lockdep_map! 1224e6045f1SJohannes Berg */ 1234e6045f1SJohannes Berg #define __WORK_INIT_LOCKDEP_MAP(n, k) \ 1244e6045f1SJohannes Berg .lockdep_map = STATIC_LOCKDEP_MAP_INIT(n, k), 1254e6045f1SJohannes Berg #else 1264e6045f1SJohannes Berg #define __WORK_INIT_LOCKDEP_MAP(n, k) 1274e6045f1SJohannes Berg #endif 1284e6045f1SJohannes Berg 12965f27f38SDavid Howells #define __WORK_INITIALIZER(n, f) { \ 130dc186ad7SThomas Gleixner .data = WORK_DATA_STATIC_INIT(), \ 13165f27f38SDavid Howells .entry = { &(n).entry, &(n).entry }, \ 13265f27f38SDavid Howells .func = (f), \ 1334e6045f1SJohannes Berg __WORK_INIT_LOCKDEP_MAP(#n, &(n)) \ 13465f27f38SDavid Howells } 13565f27f38SDavid Howells 13665f27f38SDavid Howells #define __DELAYED_WORK_INITIALIZER(n, f) { \ 13765f27f38SDavid Howells .work = __WORK_INITIALIZER((n).work, (f)), \ 138d8e794dfSTejun Heo .timer = TIMER_INITIALIZER(delayed_work_timer_fn, \ 139d8e794dfSTejun Heo 0, (unsigned long)&(n)), \ 1401da177e4SLinus Torvalds } 1411da177e4SLinus Torvalds 142203b42f7STejun Heo #define __DEFERRABLE_WORK_INITIALIZER(n, f) { \ 143dd6414b5SPhil Carmody .work = __WORK_INITIALIZER((n).work, (f)), \ 144d8e794dfSTejun Heo .timer = TIMER_DEFERRED_INITIALIZER(delayed_work_timer_fn, \ 145d8e794dfSTejun Heo 0, (unsigned long)&(n)), \ 146dd6414b5SPhil Carmody } 147dd6414b5SPhil Carmody 14865f27f38SDavid Howells #define DECLARE_WORK(n, f) \ 14965f27f38SDavid Howells struct work_struct n = __WORK_INITIALIZER(n, f) 15065f27f38SDavid Howells 15165f27f38SDavid Howells #define DECLARE_DELAYED_WORK(n, f) \ 15265f27f38SDavid Howells struct delayed_work n = __DELAYED_WORK_INITIALIZER(n, f) 15365f27f38SDavid Howells 154203b42f7STejun Heo #define DECLARE_DEFERRABLE_WORK(n, f) \ 155203b42f7STejun Heo struct delayed_work n = __DEFERRABLE_WORK_INITIALIZER(n, f) 156dd6414b5SPhil Carmody 1571da177e4SLinus Torvalds /* 15865f27f38SDavid Howells * initialize a work item's function pointer 1591da177e4SLinus Torvalds */ 16065f27f38SDavid Howells #define PREPARE_WORK(_work, _func) \ 1611da177e4SLinus Torvalds do { \ 16252bad64dSDavid Howells (_work)->func = (_func); \ 1631da177e4SLinus Torvalds } while (0) 1641da177e4SLinus Torvalds 16565f27f38SDavid Howells #define PREPARE_DELAYED_WORK(_work, _func) \ 16665f27f38SDavid Howells PREPARE_WORK(&(_work)->work, (_func)) 16752bad64dSDavid Howells 168dc186ad7SThomas Gleixner #ifdef CONFIG_DEBUG_OBJECTS_WORK 169dc186ad7SThomas Gleixner extern void __init_work(struct work_struct *work, int onstack); 170dc186ad7SThomas Gleixner extern void destroy_work_on_stack(struct work_struct *work); 1714690c4abSTejun Heo static inline unsigned int work_static(struct work_struct *work) 1724690c4abSTejun Heo { 17322df02bbSTejun Heo return *work_data_bits(work) & WORK_STRUCT_STATIC; 1744690c4abSTejun Heo } 175dc186ad7SThomas Gleixner #else 176dc186ad7SThomas Gleixner static inline void __init_work(struct work_struct *work, int onstack) { } 177dc186ad7SThomas Gleixner static inline void destroy_work_on_stack(struct work_struct *work) { } 1784690c4abSTejun Heo static inline unsigned int work_static(struct work_struct *work) { return 0; } 179dc186ad7SThomas Gleixner #endif 180dc186ad7SThomas Gleixner 1811da177e4SLinus Torvalds /* 18252bad64dSDavid Howells * initialize all of a work item in one go 183a08727baSLinus Torvalds * 184b9049df5SDmitri Vorobiev * NOTE! No point in using "atomic_long_set()": using a direct 185a08727baSLinus Torvalds * assignment of the work data initializer allows the compiler 186a08727baSLinus Torvalds * to generate better code. 1871da177e4SLinus Torvalds */ 1884e6045f1SJohannes Berg #ifdef CONFIG_LOCKDEP 189dc186ad7SThomas Gleixner #define __INIT_WORK(_work, _func, _onstack) \ 1904e6045f1SJohannes Berg do { \ 1914e6045f1SJohannes Berg static struct lock_class_key __key; \ 1924e6045f1SJohannes Berg \ 193dc186ad7SThomas Gleixner __init_work((_work), _onstack); \ 1944e6045f1SJohannes Berg (_work)->data = (atomic_long_t) WORK_DATA_INIT(); \ 1954e6045f1SJohannes Berg lockdep_init_map(&(_work)->lockdep_map, #_work, &__key, 0); \ 1964e6045f1SJohannes Berg INIT_LIST_HEAD(&(_work)->entry); \ 1974e6045f1SJohannes Berg PREPARE_WORK((_work), (_func)); \ 1984e6045f1SJohannes Berg } while (0) 1994e6045f1SJohannes Berg #else 200dc186ad7SThomas Gleixner #define __INIT_WORK(_work, _func, _onstack) \ 2011da177e4SLinus Torvalds do { \ 202dc186ad7SThomas Gleixner __init_work((_work), _onstack); \ 20323b2e599SOleg Nesterov (_work)->data = (atomic_long_t) WORK_DATA_INIT(); \ 20465f27f38SDavid Howells INIT_LIST_HEAD(&(_work)->entry); \ 20565f27f38SDavid Howells PREPARE_WORK((_work), (_func)); \ 20665f27f38SDavid Howells } while (0) 2074e6045f1SJohannes Berg #endif 20865f27f38SDavid Howells 209dc186ad7SThomas Gleixner #define INIT_WORK(_work, _func) \ 210dc186ad7SThomas Gleixner do { \ 211dc186ad7SThomas Gleixner __INIT_WORK((_work), (_func), 0); \ 212dc186ad7SThomas Gleixner } while (0) 213dc186ad7SThomas Gleixner 214ca1cab37SAndrew Morton #define INIT_WORK_ONSTACK(_work, _func) \ 215dc186ad7SThomas Gleixner do { \ 216dc186ad7SThomas Gleixner __INIT_WORK((_work), (_func), 1); \ 217dc186ad7SThomas Gleixner } while (0) 218dc186ad7SThomas Gleixner 21965f27f38SDavid Howells #define INIT_DELAYED_WORK(_work, _func) \ 22065f27f38SDavid Howells do { \ 22165f27f38SDavid Howells INIT_WORK(&(_work)->work, (_func)); \ 22265f27f38SDavid Howells init_timer(&(_work)->timer); \ 223d8e794dfSTejun Heo (_work)->timer.function = delayed_work_timer_fn; \ 224d8e794dfSTejun Heo (_work)->timer.data = (unsigned long)(_work); \ 22565f27f38SDavid Howells } while (0) 22665f27f38SDavid Howells 227ca1cab37SAndrew Morton #define INIT_DELAYED_WORK_ONSTACK(_work, _func) \ 2286d612b0fSPeter Zijlstra do { \ 229ca1cab37SAndrew Morton INIT_WORK_ONSTACK(&(_work)->work, (_func)); \ 2306d612b0fSPeter Zijlstra init_timer_on_stack(&(_work)->timer); \ 231d8e794dfSTejun Heo (_work)->timer.function = delayed_work_timer_fn; \ 232d8e794dfSTejun Heo (_work)->timer.data = (unsigned long)(_work); \ 2336d612b0fSPeter Zijlstra } while (0) 2346d612b0fSPeter Zijlstra 235203b42f7STejun Heo #define INIT_DEFERRABLE_WORK(_work, _func) \ 23628287033SVenki Pallipadi do { \ 23728287033SVenki Pallipadi INIT_WORK(&(_work)->work, (_func)); \ 23828287033SVenki Pallipadi init_timer_deferrable(&(_work)->timer); \ 239d8e794dfSTejun Heo (_work)->timer.function = delayed_work_timer_fn; \ 240d8e794dfSTejun Heo (_work)->timer.data = (unsigned long)(_work); \ 24128287033SVenki Pallipadi } while (0) 24228287033SVenki Pallipadi 243365970a1SDavid Howells /** 244365970a1SDavid Howells * work_pending - Find out whether a work item is currently pending 245365970a1SDavid Howells * @work: The work item in question 246365970a1SDavid Howells */ 247365970a1SDavid Howells #define work_pending(work) \ 24822df02bbSTejun Heo test_bit(WORK_STRUCT_PENDING_BIT, work_data_bits(work)) 249365970a1SDavid Howells 250365970a1SDavid Howells /** 251365970a1SDavid Howells * delayed_work_pending - Find out whether a delayable work item is currently 252365970a1SDavid Howells * pending 253365970a1SDavid Howells * @work: The work item in question 254365970a1SDavid Howells */ 2550221872aSLinus Torvalds #define delayed_work_pending(w) \ 2560221872aSLinus Torvalds work_pending(&(w)->work) 257365970a1SDavid Howells 25865f27f38SDavid Howells /** 25923b2e599SOleg Nesterov * work_clear_pending - for internal use only, mark a work item as not pending 26023b2e599SOleg Nesterov * @work: The work item in question 26165f27f38SDavid Howells */ 26223b2e599SOleg Nesterov #define work_clear_pending(work) \ 26322df02bbSTejun Heo clear_bit(WORK_STRUCT_PENDING_BIT, work_data_bits(work)) 26465f27f38SDavid Howells 265c54fce6eSTejun Heo /* 266c54fce6eSTejun Heo * Workqueue flags and constants. For details, please refer to 267c54fce6eSTejun Heo * Documentation/workqueue.txt. 268c54fce6eSTejun Heo */ 26997e37d7bSTejun Heo enum { 270bdbc5dd7STejun Heo WQ_NON_REENTRANT = 1 << 0, /* guarantee non-reentrance */ 271c7fc77f7STejun Heo WQ_UNBOUND = 1 << 1, /* not bound to any cpu */ 27258a69cb4STejun Heo WQ_FREEZABLE = 1 << 2, /* freeze during suspend */ 2736370a6adSTejun Heo WQ_MEM_RECLAIM = 1 << 3, /* may be used for memory reclaim */ 274649027d7STejun Heo WQ_HIGHPRI = 1 << 4, /* high priority */ 275fb0e7bebSTejun Heo WQ_CPU_INTENSIVE = 1 << 5, /* cpu instensive workqueue */ 276b71ab8c2STejun Heo 2779c5a2ba7STejun Heo WQ_DRAINING = 1 << 6, /* internal: workqueue is draining */ 2786370a6adSTejun Heo WQ_RESCUER = 1 << 7, /* internal: workqueue has rescuer */ 279e41e704bSTejun Heo 280b71ab8c2STejun Heo WQ_MAX_ACTIVE = 512, /* I like 512, better ideas? */ 281f3421797STejun Heo WQ_MAX_UNBOUND_PER_CPU = 4, /* 4 * #cpus for unbound wq */ 282b71ab8c2STejun Heo WQ_DFL_ACTIVE = WQ_MAX_ACTIVE / 2, 28397e37d7bSTejun Heo }; 28452bad64dSDavid Howells 285f3421797STejun Heo /* unbound wq's aren't per-cpu, scale max_active according to #cpus */ 286f3421797STejun Heo #define WQ_UNBOUND_MAX_ACTIVE \ 287f3421797STejun Heo max_t(int, WQ_MAX_ACTIVE, num_possible_cpus() * WQ_MAX_UNBOUND_PER_CPU) 288f3421797STejun Heo 289d320c038STejun Heo /* 290d320c038STejun Heo * System-wide workqueues which are always present. 291d320c038STejun Heo * 292d320c038STejun Heo * system_wq is the one used by schedule[_delayed]_work[_on](). 293d320c038STejun Heo * Multi-CPU multi-threaded. There are users which expect relatively 294d320c038STejun Heo * short queue flush time. Don't queue works which can run for too 295d320c038STejun Heo * long. 296d320c038STejun Heo * 297d320c038STejun Heo * system_long_wq is similar to system_wq but may host long running 298d320c038STejun Heo * works. Queue flushing might take relatively long. 299d320c038STejun Heo * 300f3421797STejun Heo * system_unbound_wq is unbound workqueue. Workers are not bound to 301f3421797STejun Heo * any specific CPU, not concurrency managed, and all queued works are 302f3421797STejun Heo * executed immediately as long as max_active limit is not reached and 303f3421797STejun Heo * resources are available. 3044149efb2STejun Heo * 30524d51addSTejun Heo * system_freezable_wq is equivalent to system_wq except that it's 30624d51addSTejun Heo * freezable. 307d320c038STejun Heo */ 308d320c038STejun Heo extern struct workqueue_struct *system_wq; 309d320c038STejun Heo extern struct workqueue_struct *system_long_wq; 310f3421797STejun Heo extern struct workqueue_struct *system_unbound_wq; 31124d51addSTejun Heo extern struct workqueue_struct *system_freezable_wq; 312ae930e0fSTejun Heo 3133b07e9caSTejun Heo static inline struct workqueue_struct * __deprecated __system_nrt_wq(void) 314ae930e0fSTejun Heo { 315ae930e0fSTejun Heo return system_wq; 316ae930e0fSTejun Heo } 317ae930e0fSTejun Heo 3183b07e9caSTejun Heo static inline struct workqueue_struct * __deprecated __system_nrt_freezable_wq(void) 319ae930e0fSTejun Heo { 320ae930e0fSTejun Heo return system_freezable_wq; 321ae930e0fSTejun Heo } 322ae930e0fSTejun Heo 323ae930e0fSTejun Heo /* equivlalent to system_wq and system_freezable_wq, deprecated */ 324ae930e0fSTejun Heo #define system_nrt_wq __system_nrt_wq() 325ae930e0fSTejun Heo #define system_nrt_freezable_wq __system_nrt_freezable_wq() 3261da177e4SLinus Torvalds 3274e6045f1SJohannes Berg extern struct workqueue_struct * 328b196be89STejun Heo __alloc_workqueue_key(const char *fmt, unsigned int flags, int max_active, 329b196be89STejun Heo struct lock_class_key *key, const char *lock_name, ...) __printf(1, 6); 3304e6045f1SJohannes Berg 331b196be89STejun Heo /** 332b196be89STejun Heo * alloc_workqueue - allocate a workqueue 333b196be89STejun Heo * @fmt: printf format for the name of the workqueue 334b196be89STejun Heo * @flags: WQ_* flags 335b196be89STejun Heo * @max_active: max in-flight work items, 0 for default 336b196be89STejun Heo * @args: args for @fmt 337b196be89STejun Heo * 338b196be89STejun Heo * Allocate a workqueue with the specified parameters. For detailed 339b196be89STejun Heo * information on WQ_* flags, please refer to Documentation/workqueue.txt. 340b196be89STejun Heo * 341b196be89STejun Heo * The __lock_name macro dance is to guarantee that single lock_class_key 342b196be89STejun Heo * doesn't end up with different namesm, which isn't allowed by lockdep. 343b196be89STejun Heo * 344b196be89STejun Heo * RETURNS: 345b196be89STejun Heo * Pointer to the allocated workqueue on success, %NULL on failure. 346b196be89STejun Heo */ 3474e6045f1SJohannes Berg #ifdef CONFIG_LOCKDEP 348b196be89STejun Heo #define alloc_workqueue(fmt, flags, max_active, args...) \ 3494e6045f1SJohannes Berg ({ \ 3504e6045f1SJohannes Berg static struct lock_class_key __key; \ 351eb13ba87SJohannes Berg const char *__lock_name; \ 352eb13ba87SJohannes Berg \ 353b196be89STejun Heo if (__builtin_constant_p(fmt)) \ 354b196be89STejun Heo __lock_name = (fmt); \ 355eb13ba87SJohannes Berg else \ 356b196be89STejun Heo __lock_name = #fmt; \ 3574e6045f1SJohannes Berg \ 358b196be89STejun Heo __alloc_workqueue_key((fmt), (flags), (max_active), \ 359b196be89STejun Heo &__key, __lock_name, ##args); \ 3604e6045f1SJohannes Berg }) 3614e6045f1SJohannes Berg #else 362b196be89STejun Heo #define alloc_workqueue(fmt, flags, max_active, args...) \ 363b196be89STejun Heo __alloc_workqueue_key((fmt), (flags), (max_active), \ 364b196be89STejun Heo NULL, NULL, ##args) 3654e6045f1SJohannes Berg #endif 3664e6045f1SJohannes Berg 36781dcaf65STejun Heo /** 36881dcaf65STejun Heo * alloc_ordered_workqueue - allocate an ordered workqueue 369b196be89STejun Heo * @fmt: printf format for the name of the workqueue 37058a69cb4STejun Heo * @flags: WQ_* flags (only WQ_FREEZABLE and WQ_MEM_RECLAIM are meaningful) 371b196be89STejun Heo * @args: args for @fmt 37281dcaf65STejun Heo * 37381dcaf65STejun Heo * Allocate an ordered workqueue. An ordered workqueue executes at 37481dcaf65STejun Heo * most one work item at any given time in the queued order. They are 37581dcaf65STejun Heo * implemented as unbound workqueues with @max_active of one. 37681dcaf65STejun Heo * 37781dcaf65STejun Heo * RETURNS: 37881dcaf65STejun Heo * Pointer to the allocated workqueue on success, %NULL on failure. 37981dcaf65STejun Heo */ 380b196be89STejun Heo #define alloc_ordered_workqueue(fmt, flags, args...) \ 381b196be89STejun Heo alloc_workqueue(fmt, WQ_UNBOUND | (flags), 1, ##args) 38281dcaf65STejun Heo 38397e37d7bSTejun Heo #define create_workqueue(name) \ 3846370a6adSTejun Heo alloc_workqueue((name), WQ_MEM_RECLAIM, 1) 38558a69cb4STejun Heo #define create_freezable_workqueue(name) \ 38658a69cb4STejun Heo alloc_workqueue((name), WQ_FREEZABLE | WQ_UNBOUND | WQ_MEM_RECLAIM, 1) 38797e37d7bSTejun Heo #define create_singlethread_workqueue(name) \ 3886370a6adSTejun Heo alloc_workqueue((name), WQ_UNBOUND | WQ_MEM_RECLAIM, 1) 3891da177e4SLinus Torvalds 3901da177e4SLinus Torvalds extern void destroy_workqueue(struct workqueue_struct *wq); 3911da177e4SLinus Torvalds 392d4283e93STejun Heo extern bool queue_work_on(int cpu, struct workqueue_struct *wq, 393c1a220e7SZhang Rui struct work_struct *work); 394d4283e93STejun Heo extern bool queue_work(struct workqueue_struct *wq, struct work_struct *work); 395d4283e93STejun Heo extern bool queue_delayed_work_on(int cpu, struct workqueue_struct *wq, 39652bad64dSDavid Howells struct delayed_work *work, unsigned long delay); 397d4283e93STejun Heo extern bool queue_delayed_work(struct workqueue_struct *wq, 3980a13c00eSTejun Heo struct delayed_work *work, unsigned long delay); 3998376fe22STejun Heo extern bool mod_delayed_work_on(int cpu, struct workqueue_struct *wq, 4008376fe22STejun Heo struct delayed_work *dwork, unsigned long delay); 4018376fe22STejun Heo extern bool mod_delayed_work(struct workqueue_struct *wq, 4028376fe22STejun Heo struct delayed_work *dwork, unsigned long delay); 40328e53bddSOleg Nesterov 404b3c97528SHarvey Harrison extern void flush_workqueue(struct workqueue_struct *wq); 4059c5a2ba7STejun Heo extern void drain_workqueue(struct workqueue_struct *wq); 40628e53bddSOleg Nesterov extern void flush_scheduled_work(void); 4071da177e4SLinus Torvalds 408d4283e93STejun Heo extern bool schedule_work_on(int cpu, struct work_struct *work); 409d4283e93STejun Heo extern bool schedule_work(struct work_struct *work); 410d4283e93STejun Heo extern bool schedule_delayed_work_on(int cpu, struct delayed_work *work, 41128e53bddSOleg Nesterov unsigned long delay); 412d4283e93STejun Heo extern bool schedule_delayed_work(struct delayed_work *work, 4130a13c00eSTejun Heo unsigned long delay); 41465f27f38SDavid Howells extern int schedule_on_each_cpu(work_func_t func); 4151da177e4SLinus Torvalds extern int keventd_up(void); 4161da177e4SLinus Torvalds 41765f27f38SDavid Howells int execute_in_process_context(work_func_t fn, struct execute_work *); 4181da177e4SLinus Torvalds 419401a8d04STejun Heo extern bool flush_work(struct work_struct *work); 420401a8d04STejun Heo extern bool cancel_work_sync(struct work_struct *work); 421401a8d04STejun Heo 422401a8d04STejun Heo extern bool flush_delayed_work(struct delayed_work *dwork); 423401a8d04STejun Heo extern bool cancel_delayed_work_sync(struct delayed_work *dwork); 42428e53bddSOleg Nesterov 425dcd989cbSTejun Heo extern void workqueue_set_max_active(struct workqueue_struct *wq, 426dcd989cbSTejun Heo int max_active); 427dcd989cbSTejun Heo extern bool workqueue_congested(unsigned int cpu, struct workqueue_struct *wq); 428dcd989cbSTejun Heo extern unsigned int work_cpu(struct work_struct *work); 429dcd989cbSTejun Heo extern unsigned int work_busy(struct work_struct *work); 430dcd989cbSTejun Heo 4311da177e4SLinus Torvalds /* 4321da177e4SLinus Torvalds * Kill off a pending schedule_delayed_work(). Note that the work callback 433071b6386SOleg Nesterov * function may still be running on return from cancel_delayed_work(), unless 434071b6386SOleg Nesterov * it returns 1 and the work doesn't re-arm itself. Run flush_workqueue() or 43528e53bddSOleg Nesterov * cancel_work_sync() to wait on it. 4361da177e4SLinus Torvalds */ 437401a8d04STejun Heo static inline bool cancel_delayed_work(struct delayed_work *work) 4381da177e4SLinus Torvalds { 439401a8d04STejun Heo bool ret; 4401da177e4SLinus Torvalds 441223a10a9SOleg Nesterov ret = del_timer_sync(&work->timer); 4421da177e4SLinus Torvalds if (ret) 44323b2e599SOleg Nesterov work_clear_pending(&work->work); 4441da177e4SLinus Torvalds return ret; 4451da177e4SLinus Torvalds } 4461da177e4SLinus Torvalds 4474e49627bSOleg Nesterov /* 4484e49627bSOleg Nesterov * Like above, but uses del_timer() instead of del_timer_sync(). This means, 4494e49627bSOleg Nesterov * if it returns 0 the timer function may be running and the queueing is in 4504e49627bSOleg Nesterov * progress. 4514e49627bSOleg Nesterov */ 452401a8d04STejun Heo static inline bool __cancel_delayed_work(struct delayed_work *work) 4534e49627bSOleg Nesterov { 454401a8d04STejun Heo bool ret; 4554e49627bSOleg Nesterov 4564e49627bSOleg Nesterov ret = del_timer(&work->timer); 4574e49627bSOleg Nesterov if (ret) 4584e49627bSOleg Nesterov work_clear_pending(&work->work); 4594e49627bSOleg Nesterov return ret; 4604e49627bSOleg Nesterov } 4614e49627bSOleg Nesterov 462606a5020STejun Heo /* used to be different but now identical to flush_work(), deprecated */ 46343829731STejun Heo static inline bool __deprecated flush_work_sync(struct work_struct *work) 464606a5020STejun Heo { 465606a5020STejun Heo return flush_work(work); 466606a5020STejun Heo } 467606a5020STejun Heo 468606a5020STejun Heo /* used to be different but now identical to flush_delayed_work(), deprecated */ 46943829731STejun Heo static inline bool __deprecated flush_delayed_work_sync(struct delayed_work *dwork) 470606a5020STejun Heo { 471606a5020STejun Heo return flush_delayed_work(dwork); 472606a5020STejun Heo } 473606a5020STejun Heo 4742d3854a3SRusty Russell #ifndef CONFIG_SMP 4752d3854a3SRusty Russell static inline long work_on_cpu(unsigned int cpu, long (*fn)(void *), void *arg) 4762d3854a3SRusty Russell { 4772d3854a3SRusty Russell return fn(arg); 4782d3854a3SRusty Russell } 4792d3854a3SRusty Russell #else 4802d3854a3SRusty Russell long work_on_cpu(unsigned int cpu, long (*fn)(void *), void *arg); 4812d3854a3SRusty Russell #endif /* CONFIG_SMP */ 482a25909a4SPaul E. McKenney 483a0a1a5fdSTejun Heo #ifdef CONFIG_FREEZER 484a0a1a5fdSTejun Heo extern void freeze_workqueues_begin(void); 485a0a1a5fdSTejun Heo extern bool freeze_workqueues_busy(void); 486a0a1a5fdSTejun Heo extern void thaw_workqueues(void); 487a0a1a5fdSTejun Heo #endif /* CONFIG_FREEZER */ 488a0a1a5fdSTejun Heo 4891da177e4SLinus Torvalds #endif 490