Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 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> |
Johannes Berg | 4e6045f | 2007-10-18 23:39:55 -0700 | [diff] [blame] | 11 | #include <linux/lockdep.h> |
Tejun Heo | 7a22ad7 | 2010-06-29 10:07:13 +0200 | [diff] [blame] | 12 | #include <linux/threads.h> |
Arun Sharma | 60063497 | 2011-07-26 16:09:06 -0700 | [diff] [blame] | 13 | #include <linux/atomic.h> |
Tejun Heo | 7a4e344 | 2013-03-12 11:30:00 -0700 | [diff] [blame] | 14 | #include <linux/cpumask.h> |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 15 | |
| 16 | struct workqueue_struct; |
| 17 | |
David Howells | 65f27f3 | 2006-11-22 14:55:48 +0000 | [diff] [blame] | 18 | struct work_struct; |
| 19 | typedef void (*work_func_t)(struct work_struct *work); |
Tejun Heo | d8e794d | 2012-08-03 10:30:45 -0700 | [diff] [blame] | 20 | void delayed_work_timer_fn(unsigned long __data); |
David Howells | 6bb49e5 | 2006-11-22 14:54:45 +0000 | [diff] [blame] | 21 | |
Linus Torvalds | a08727b | 2006-12-16 09:53:50 -0800 | [diff] [blame] | 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 | |
Tejun Heo | 22df02b | 2010-06-29 10:07:10 +0200 | [diff] [blame] | 28 | enum { |
| 29 | WORK_STRUCT_PENDING_BIT = 0, /* work item is pending execution */ |
Tejun Heo | 8a2e8e5d | 2010-08-25 10:33:56 +0200 | [diff] [blame] | 30 | WORK_STRUCT_DELAYED_BIT = 1, /* work item is delayed */ |
Tejun Heo | 112202d | 2013-02-13 19:29:12 -0800 | [diff] [blame] | 31 | WORK_STRUCT_PWQ_BIT = 2, /* data points to pwq */ |
Tejun Heo | 8a2e8e5d | 2010-08-25 10:33:56 +0200 | [diff] [blame] | 32 | WORK_STRUCT_LINKED_BIT = 3, /* next work is linked to this one */ |
Tejun Heo | 22df02b | 2010-06-29 10:07:10 +0200 | [diff] [blame] | 33 | #ifdef CONFIG_DEBUG_OBJECTS_WORK |
Tejun Heo | 8a2e8e5d | 2010-08-25 10:33:56 +0200 | [diff] [blame] | 34 | WORK_STRUCT_STATIC_BIT = 4, /* static initializer (debugobjects) */ |
| 35 | WORK_STRUCT_COLOR_SHIFT = 5, /* color for workqueue flushing */ |
Tejun Heo | 0f90004 | 2010-06-29 10:07:11 +0200 | [diff] [blame] | 36 | #else |
Tejun Heo | 8a2e8e5d | 2010-08-25 10:33:56 +0200 | [diff] [blame] | 37 | WORK_STRUCT_COLOR_SHIFT = 4, /* color for workqueue flushing */ |
Tejun Heo | 22df02b | 2010-06-29 10:07:10 +0200 | [diff] [blame] | 38 | #endif |
| 39 | |
Tejun Heo | 73f53c4 | 2010-06-29 10:07:11 +0200 | [diff] [blame] | 40 | WORK_STRUCT_COLOR_BITS = 4, |
| 41 | |
Tejun Heo | 22df02b | 2010-06-29 10:07:10 +0200 | [diff] [blame] | 42 | WORK_STRUCT_PENDING = 1 << WORK_STRUCT_PENDING_BIT, |
Tejun Heo | 8a2e8e5d | 2010-08-25 10:33:56 +0200 | [diff] [blame] | 43 | WORK_STRUCT_DELAYED = 1 << WORK_STRUCT_DELAYED_BIT, |
Tejun Heo | 112202d | 2013-02-13 19:29:12 -0800 | [diff] [blame] | 44 | WORK_STRUCT_PWQ = 1 << WORK_STRUCT_PWQ_BIT, |
Tejun Heo | affee4b | 2010-06-29 10:07:12 +0200 | [diff] [blame] | 45 | WORK_STRUCT_LINKED = 1 << WORK_STRUCT_LINKED_BIT, |
Tejun Heo | 22df02b | 2010-06-29 10:07:10 +0200 | [diff] [blame] | 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 | |
Tejun Heo | 73f53c4 | 2010-06-29 10:07:11 +0200 | [diff] [blame] | 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 | |
Tejun Heo | bdbc5dd | 2010-07-02 10:03:51 +0200 | [diff] [blame] | 59 | /* special cpu IDs */ |
Tejun Heo | f342179 | 2010-07-02 10:03:51 +0200 | [diff] [blame] | 60 | WORK_CPU_UNBOUND = NR_CPUS, |
Lai Jiangshan | 6be1958 | 2013-02-06 18:04:53 -0800 | [diff] [blame] | 61 | WORK_CPU_END = NR_CPUS + 1, |
Tejun Heo | bdbc5dd | 2010-07-02 10:03:51 +0200 | [diff] [blame] | 62 | |
Tejun Heo | 73f53c4 | 2010-06-29 10:07:11 +0200 | [diff] [blame] | 63 | /* |
Tejun Heo | 112202d | 2013-02-13 19:29:12 -0800 | [diff] [blame] | 64 | * Reserve 7 bits off of pwq pointer w/ debugobjects turned off. |
| 65 | * This makes pwqs aligned to 256 bytes and allows 15 workqueue |
| 66 | * flush colors. |
Tejun Heo | 73f53c4 | 2010-06-29 10:07:11 +0200 | [diff] [blame] | 67 | */ |
| 68 | WORK_STRUCT_FLAG_BITS = WORK_STRUCT_COLOR_SHIFT + |
| 69 | WORK_STRUCT_COLOR_BITS, |
| 70 | |
Tejun Heo | 112202d | 2013-02-13 19:29:12 -0800 | [diff] [blame] | 71 | /* data contains off-queue information when !WORK_STRUCT_PWQ */ |
Lai Jiangshan | 45d9550 | 2013-02-19 12:17:01 -0800 | [diff] [blame] | 72 | WORK_OFFQ_FLAG_BASE = WORK_STRUCT_COLOR_SHIFT, |
Tejun Heo | bbb68df | 2012-08-03 10:30:46 -0700 | [diff] [blame] | 73 | |
| 74 | WORK_OFFQ_CANCELING = (1 << WORK_OFFQ_FLAG_BASE), |
| 75 | |
Tejun Heo | 715b06b | 2013-01-24 11:01:33 -0800 | [diff] [blame] | 76 | /* |
| 77 | * When a work item is off queue, its high bits point to the last |
Tejun Heo | 7c3eed5 | 2013-01-24 11:01:33 -0800 | [diff] [blame] | 78 | * pool it was on. Cap at 31 bits and use the highest number to |
| 79 | * indicate that no pool is associated. |
Tejun Heo | 715b06b | 2013-01-24 11:01:33 -0800 | [diff] [blame] | 80 | */ |
Tejun Heo | bbb68df | 2012-08-03 10:30:46 -0700 | [diff] [blame] | 81 | WORK_OFFQ_FLAG_BITS = 1, |
Tejun Heo | 7c3eed5 | 2013-01-24 11:01:33 -0800 | [diff] [blame] | 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, |
Tejun Heo | b549007 | 2012-08-03 10:30:46 -0700 | [diff] [blame] | 86 | |
| 87 | /* convenience constants */ |
Tejun Heo | 0f90004 | 2010-06-29 10:07:11 +0200 | [diff] [blame] | 88 | WORK_STRUCT_FLAG_MASK = (1UL << WORK_STRUCT_FLAG_BITS) - 1, |
Tejun Heo | 22df02b | 2010-06-29 10:07:10 +0200 | [diff] [blame] | 89 | WORK_STRUCT_WQ_DATA_MASK = ~WORK_STRUCT_FLAG_MASK, |
Tejun Heo | 7c3eed5 | 2013-01-24 11:01:33 -0800 | [diff] [blame] | 90 | WORK_STRUCT_NO_POOL = (unsigned long)WORK_OFFQ_POOL_NONE << WORK_OFFQ_POOL_SHIFT, |
Tejun Heo | dcd989c | 2010-06-29 10:07:14 +0200 | [diff] [blame] | 91 | |
| 92 | /* bit mask for work_busy() return values */ |
| 93 | WORK_BUSY_PENDING = 1 << 0, |
| 94 | WORK_BUSY_RUNNING = 1 << 1, |
Tejun Heo | 3d1cb20 | 2013-04-30 15:27:22 -0700 | [diff] [blame] | 95 | |
| 96 | /* maximum string length for set_worker_desc() */ |
| 97 | WORKER_DESC_LEN = 24, |
Tejun Heo | 22df02b | 2010-06-29 10:07:10 +0200 | [diff] [blame] | 98 | }; |
| 99 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 100 | struct work_struct { |
Linus Torvalds | a08727b | 2006-12-16 09:53:50 -0800 | [diff] [blame] | 101 | atomic_long_t data; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 102 | struct list_head entry; |
David Howells | 6bb49e5 | 2006-11-22 14:54:45 +0000 | [diff] [blame] | 103 | work_func_t func; |
Johannes Berg | 4e6045f | 2007-10-18 23:39:55 -0700 | [diff] [blame] | 104 | #ifdef CONFIG_LOCKDEP |
| 105 | struct lockdep_map lockdep_map; |
| 106 | #endif |
David Howells | 52bad64 | 2006-11-22 14:54:01 +0000 | [diff] [blame] | 107 | }; |
| 108 | |
Tejun Heo | 7c3eed5 | 2013-01-24 11:01:33 -0800 | [diff] [blame] | 109 | #define WORK_DATA_INIT() ATOMIC_LONG_INIT(WORK_STRUCT_NO_POOL) |
Tejun Heo | 7a22ad7 | 2010-06-29 10:07:13 +0200 | [diff] [blame] | 110 | #define WORK_DATA_STATIC_INIT() \ |
Tejun Heo | 7c3eed5 | 2013-01-24 11:01:33 -0800 | [diff] [blame] | 111 | ATOMIC_LONG_INIT(WORK_STRUCT_NO_POOL | WORK_STRUCT_STATIC) |
Linus Torvalds | a08727b | 2006-12-16 09:53:50 -0800 | [diff] [blame] | 112 | |
David Howells | 52bad64 | 2006-11-22 14:54:01 +0000 | [diff] [blame] | 113 | struct delayed_work { |
| 114 | struct work_struct work; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 115 | struct timer_list timer; |
Lai Jiangshan | 60c057b | 2013-02-06 18:04:53 -0800 | [diff] [blame] | 116 | |
| 117 | /* target workqueue and CPU ->timer uses to queue ->work */ |
| 118 | struct workqueue_struct *wq; |
Tejun Heo | 1265057 | 2012-08-08 09:38:42 -0700 | [diff] [blame] | 119 | int cpu; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 120 | }; |
| 121 | |
Tejun Heo | 7a4e344 | 2013-03-12 11:30:00 -0700 | [diff] [blame] | 122 | /* |
| 123 | * A struct for workqueue attributes. This can be used to change |
| 124 | * attributes of an unbound workqueue. |
Tejun Heo | d55262c | 2013-04-01 11:23:38 -0700 | [diff] [blame] | 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. |
Tejun Heo | 7a4e344 | 2013-03-12 11:30:00 -0700 | [diff] [blame] | 129 | */ |
| 130 | struct workqueue_attrs { |
| 131 | int nice; /* nice level */ |
| 132 | cpumask_var_t cpumask; /* allowed CPUs */ |
Tejun Heo | d55262c | 2013-04-01 11:23:38 -0700 | [diff] [blame] | 133 | bool no_numa; /* disable NUMA affinity */ |
Tejun Heo | 7a4e344 | 2013-03-12 11:30:00 -0700 | [diff] [blame] | 134 | }; |
| 135 | |
Jean Delvare | bf6aede | 2009-04-02 16:56:54 -0700 | [diff] [blame] | 136 | static inline struct delayed_work *to_delayed_work(struct work_struct *work) |
| 137 | { |
| 138 | return container_of(work, struct delayed_work, work); |
| 139 | } |
| 140 | |
James Bottomley | 1fa44ec | 2006-02-23 12:43:43 -0600 | [diff] [blame] | 141 | struct execute_work { |
| 142 | struct work_struct work; |
| 143 | }; |
| 144 | |
Johannes Berg | 4e6045f | 2007-10-18 23:39:55 -0700 | [diff] [blame] | 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 | |
Tejun Heo | ee64e7f | 2012-08-21 13:18:23 -0700 | [diff] [blame] | 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)) \ |
David Howells | 65f27f3 | 2006-11-22 14:55:48 +0000 | [diff] [blame] | 162 | } |
| 163 | |
Tejun Heo | f991b31 | 2012-08-21 13:18:23 -0700 | [diff] [blame] | 164 | #define __DELAYED_WORK_INITIALIZER(n, f, tflags) { \ |
Tejun Heo | ee64e7f | 2012-08-21 13:18:23 -0700 | [diff] [blame] | 165 | .work = __WORK_INITIALIZER((n).work, (f)), \ |
Tejun Heo | f991b31 | 2012-08-21 13:18:23 -0700 | [diff] [blame] | 166 | .timer = __TIMER_INITIALIZER(delayed_work_timer_fn, \ |
Tejun Heo | e0aecdd | 2012-08-21 13:18:24 -0700 | [diff] [blame] | 167 | 0, (unsigned long)&(n), \ |
| 168 | (tflags) | TIMER_IRQSAFE), \ |
Phil Carmody | dd6414b | 2010-10-20 15:57:33 -0700 | [diff] [blame] | 169 | } |
| 170 | |
Tejun Heo | ee64e7f | 2012-08-21 13:18:23 -0700 | [diff] [blame] | 171 | #define DECLARE_WORK(n, f) \ |
David Howells | 65f27f3 | 2006-11-22 14:55:48 +0000 | [diff] [blame] | 172 | struct work_struct n = __WORK_INITIALIZER(n, f) |
| 173 | |
Tejun Heo | ee64e7f | 2012-08-21 13:18:23 -0700 | [diff] [blame] | 174 | #define DECLARE_DELAYED_WORK(n, f) \ |
Tejun Heo | f991b31 | 2012-08-21 13:18:23 -0700 | [diff] [blame] | 175 | struct delayed_work n = __DELAYED_WORK_INITIALIZER(n, f, 0) |
David Howells | 65f27f3 | 2006-11-22 14:55:48 +0000 | [diff] [blame] | 176 | |
Tejun Heo | 203b42f | 2012-08-21 13:18:23 -0700 | [diff] [blame] | 177 | #define DECLARE_DEFERRABLE_WORK(n, f) \ |
Tejun Heo | f991b31 | 2012-08-21 13:18:23 -0700 | [diff] [blame] | 178 | struct delayed_work n = __DELAYED_WORK_INITIALIZER(n, f, TIMER_DEFERRABLE) |
Phil Carmody | dd6414b | 2010-10-20 15:57:33 -0700 | [diff] [blame] | 179 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 180 | /* |
David Howells | 65f27f3 | 2006-11-22 14:55:48 +0000 | [diff] [blame] | 181 | * initialize a work item's function pointer |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 182 | */ |
Tejun Heo | ee64e7f | 2012-08-21 13:18:23 -0700 | [diff] [blame] | 183 | #define PREPARE_WORK(_work, _func) \ |
| 184 | do { \ |
| 185 | (_work)->func = (_func); \ |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 186 | } while (0) |
| 187 | |
Tejun Heo | ee64e7f | 2012-08-21 13:18:23 -0700 | [diff] [blame] | 188 | #define PREPARE_DELAYED_WORK(_work, _func) \ |
David Howells | 65f27f3 | 2006-11-22 14:55:48 +0000 | [diff] [blame] | 189 | PREPARE_WORK(&(_work)->work, (_func)) |
David Howells | 52bad64 | 2006-11-22 14:54:01 +0000 | [diff] [blame] | 190 | |
Thomas Gleixner | dc186ad | 2009-11-16 01:09:48 +0900 | [diff] [blame] | 191 | #ifdef CONFIG_DEBUG_OBJECTS_WORK |
| 192 | extern void __init_work(struct work_struct *work, int onstack); |
| 193 | extern void destroy_work_on_stack(struct work_struct *work); |
Tejun Heo | 4690c4a | 2010-06-29 10:07:10 +0200 | [diff] [blame] | 194 | static inline unsigned int work_static(struct work_struct *work) |
| 195 | { |
Tejun Heo | 22df02b | 2010-06-29 10:07:10 +0200 | [diff] [blame] | 196 | return *work_data_bits(work) & WORK_STRUCT_STATIC; |
Tejun Heo | 4690c4a | 2010-06-29 10:07:10 +0200 | [diff] [blame] | 197 | } |
Thomas Gleixner | dc186ad | 2009-11-16 01:09:48 +0900 | [diff] [blame] | 198 | #else |
| 199 | static inline void __init_work(struct work_struct *work, int onstack) { } |
| 200 | static inline void destroy_work_on_stack(struct work_struct *work) { } |
Tejun Heo | 4690c4a | 2010-06-29 10:07:10 +0200 | [diff] [blame] | 201 | static inline unsigned int work_static(struct work_struct *work) { return 0; } |
Thomas Gleixner | dc186ad | 2009-11-16 01:09:48 +0900 | [diff] [blame] | 202 | #endif |
| 203 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 204 | /* |
David Howells | 52bad64 | 2006-11-22 14:54:01 +0000 | [diff] [blame] | 205 | * initialize all of a work item in one go |
Linus Torvalds | a08727b | 2006-12-16 09:53:50 -0800 | [diff] [blame] | 206 | * |
Dmitri Vorobiev | b9049df | 2009-06-23 12:09:29 +0200 | [diff] [blame] | 207 | * NOTE! No point in using "atomic_long_set()": using a direct |
Linus Torvalds | a08727b | 2006-12-16 09:53:50 -0800 | [diff] [blame] | 208 | * assignment of the work data initializer allows the compiler |
| 209 | * to generate better code. |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 210 | */ |
Johannes Berg | 4e6045f | 2007-10-18 23:39:55 -0700 | [diff] [blame] | 211 | #ifdef CONFIG_LOCKDEP |
Thomas Gleixner | dc186ad | 2009-11-16 01:09:48 +0900 | [diff] [blame] | 212 | #define __INIT_WORK(_work, _func, _onstack) \ |
Johannes Berg | 4e6045f | 2007-10-18 23:39:55 -0700 | [diff] [blame] | 213 | do { \ |
| 214 | static struct lock_class_key __key; \ |
| 215 | \ |
Thomas Gleixner | dc186ad | 2009-11-16 01:09:48 +0900 | [diff] [blame] | 216 | __init_work((_work), _onstack); \ |
Johannes Berg | 4e6045f | 2007-10-18 23:39:55 -0700 | [diff] [blame] | 217 | (_work)->data = (atomic_long_t) WORK_DATA_INIT(); \ |
Tejun Heo | ee64e7f | 2012-08-21 13:18:23 -0700 | [diff] [blame] | 218 | lockdep_init_map(&(_work)->lockdep_map, #_work, &__key, 0); \ |
Johannes Berg | 4e6045f | 2007-10-18 23:39:55 -0700 | [diff] [blame] | 219 | INIT_LIST_HEAD(&(_work)->entry); \ |
| 220 | PREPARE_WORK((_work), (_func)); \ |
| 221 | } while (0) |
| 222 | #else |
Thomas Gleixner | dc186ad | 2009-11-16 01:09:48 +0900 | [diff] [blame] | 223 | #define __INIT_WORK(_work, _func, _onstack) \ |
David Howells | 65f27f3 | 2006-11-22 14:55:48 +0000 | [diff] [blame] | 224 | do { \ |
Thomas Gleixner | dc186ad | 2009-11-16 01:09:48 +0900 | [diff] [blame] | 225 | __init_work((_work), _onstack); \ |
Oleg Nesterov | 23b2e59 | 2007-05-09 02:34:19 -0700 | [diff] [blame] | 226 | (_work)->data = (atomic_long_t) WORK_DATA_INIT(); \ |
David Howells | 65f27f3 | 2006-11-22 14:55:48 +0000 | [diff] [blame] | 227 | INIT_LIST_HEAD(&(_work)->entry); \ |
| 228 | PREPARE_WORK((_work), (_func)); \ |
| 229 | } while (0) |
Johannes Berg | 4e6045f | 2007-10-18 23:39:55 -0700 | [diff] [blame] | 230 | #endif |
David Howells | 65f27f3 | 2006-11-22 14:55:48 +0000 | [diff] [blame] | 231 | |
Tejun Heo | ee64e7f | 2012-08-21 13:18:23 -0700 | [diff] [blame] | 232 | #define INIT_WORK(_work, _func) \ |
| 233 | do { \ |
| 234 | __INIT_WORK((_work), (_func), 0); \ |
Thomas Gleixner | dc186ad | 2009-11-16 01:09:48 +0900 | [diff] [blame] | 235 | } while (0) |
| 236 | |
Tejun Heo | ee64e7f | 2012-08-21 13:18:23 -0700 | [diff] [blame] | 237 | #define INIT_WORK_ONSTACK(_work, _func) \ |
| 238 | do { \ |
| 239 | __INIT_WORK((_work), (_func), 1); \ |
Thomas Gleixner | dc186ad | 2009-11-16 01:09:48 +0900 | [diff] [blame] | 240 | } while (0) |
| 241 | |
Tejun Heo | f991b31 | 2012-08-21 13:18:23 -0700 | [diff] [blame] | 242 | #define __INIT_DELAYED_WORK(_work, _func, _tflags) \ |
Tejun Heo | ee64e7f | 2012-08-21 13:18:23 -0700 | [diff] [blame] | 243 | do { \ |
| 244 | INIT_WORK(&(_work)->work, (_func)); \ |
Tejun Heo | f991b31 | 2012-08-21 13:18:23 -0700 | [diff] [blame] | 245 | __setup_timer(&(_work)->timer, delayed_work_timer_fn, \ |
Tejun Heo | e0aecdd | 2012-08-21 13:18:24 -0700 | [diff] [blame] | 246 | (unsigned long)(_work), \ |
| 247 | (_tflags) | TIMER_IRQSAFE); \ |
David Howells | 65f27f3 | 2006-11-22 14:55:48 +0000 | [diff] [blame] | 248 | } while (0) |
| 249 | |
Tejun Heo | f991b31 | 2012-08-21 13:18:23 -0700 | [diff] [blame] | 250 | #define __INIT_DELAYED_WORK_ONSTACK(_work, _func, _tflags) \ |
Tejun Heo | ee64e7f | 2012-08-21 13:18:23 -0700 | [diff] [blame] | 251 | do { \ |
| 252 | INIT_WORK_ONSTACK(&(_work)->work, (_func)); \ |
Tejun Heo | f991b31 | 2012-08-21 13:18:23 -0700 | [diff] [blame] | 253 | __setup_timer_on_stack(&(_work)->timer, \ |
| 254 | delayed_work_timer_fn, \ |
| 255 | (unsigned long)(_work), \ |
Tejun Heo | e0aecdd | 2012-08-21 13:18:24 -0700 | [diff] [blame] | 256 | (_tflags) | TIMER_IRQSAFE); \ |
Peter Zijlstra | 6d612b0 | 2009-01-12 12:52:23 +0100 | [diff] [blame] | 257 | } while (0) |
| 258 | |
Tejun Heo | f991b31 | 2012-08-21 13:18:23 -0700 | [diff] [blame] | 259 | #define INIT_DELAYED_WORK(_work, _func) \ |
| 260 | __INIT_DELAYED_WORK(_work, _func, 0) |
| 261 | |
| 262 | #define INIT_DELAYED_WORK_ONSTACK(_work, _func) \ |
| 263 | __INIT_DELAYED_WORK_ONSTACK(_work, _func, 0) |
| 264 | |
Tejun Heo | 203b42f | 2012-08-21 13:18:23 -0700 | [diff] [blame] | 265 | #define INIT_DEFERRABLE_WORK(_work, _func) \ |
Tejun Heo | f991b31 | 2012-08-21 13:18:23 -0700 | [diff] [blame] | 266 | __INIT_DELAYED_WORK(_work, _func, TIMER_DEFERRABLE) |
| 267 | |
| 268 | #define INIT_DEFERRABLE_WORK_ONSTACK(_work, _func) \ |
| 269 | __INIT_DELAYED_WORK_ONSTACK(_work, _func, TIMER_DEFERRABLE) |
Venki Pallipadi | 2828703 | 2007-05-08 00:27:47 -0700 | [diff] [blame] | 270 | |
David Howells | 365970a | 2006-11-22 14:54:49 +0000 | [diff] [blame] | 271 | /** |
| 272 | * work_pending - Find out whether a work item is currently pending |
| 273 | * @work: The work item in question |
| 274 | */ |
| 275 | #define work_pending(work) \ |
Tejun Heo | 22df02b | 2010-06-29 10:07:10 +0200 | [diff] [blame] | 276 | test_bit(WORK_STRUCT_PENDING_BIT, work_data_bits(work)) |
David Howells | 365970a | 2006-11-22 14:54:49 +0000 | [diff] [blame] | 277 | |
| 278 | /** |
| 279 | * delayed_work_pending - Find out whether a delayable work item is currently |
| 280 | * pending |
| 281 | * @work: The work item in question |
| 282 | */ |
Linus Torvalds | 0221872 | 2006-12-15 14:13:51 -0800 | [diff] [blame] | 283 | #define delayed_work_pending(w) \ |
| 284 | work_pending(&(w)->work) |
David Howells | 365970a | 2006-11-22 14:54:49 +0000 | [diff] [blame] | 285 | |
David Howells | 65f27f3 | 2006-11-22 14:55:48 +0000 | [diff] [blame] | 286 | /** |
Oleg Nesterov | 23b2e59 | 2007-05-09 02:34:19 -0700 | [diff] [blame] | 287 | * work_clear_pending - for internal use only, mark a work item as not pending |
| 288 | * @work: The work item in question |
David Howells | 65f27f3 | 2006-11-22 14:55:48 +0000 | [diff] [blame] | 289 | */ |
Oleg Nesterov | 23b2e59 | 2007-05-09 02:34:19 -0700 | [diff] [blame] | 290 | #define work_clear_pending(work) \ |
Tejun Heo | 22df02b | 2010-06-29 10:07:10 +0200 | [diff] [blame] | 291 | clear_bit(WORK_STRUCT_PENDING_BIT, work_data_bits(work)) |
David Howells | 65f27f3 | 2006-11-22 14:55:48 +0000 | [diff] [blame] | 292 | |
Tejun Heo | c54fce6 | 2010-09-10 16:51:36 +0200 | [diff] [blame] | 293 | /* |
| 294 | * Workqueue flags and constants. For details, please refer to |
| 295 | * Documentation/workqueue.txt. |
| 296 | */ |
Tejun Heo | 97e37d7 | 2010-06-29 10:07:10 +0200 | [diff] [blame] | 297 | enum { |
Tejun Heo | bdbc5dd | 2010-07-02 10:03:51 +0200 | [diff] [blame] | 298 | WQ_NON_REENTRANT = 1 << 0, /* guarantee non-reentrance */ |
Tejun Heo | c7fc77f | 2010-07-02 10:03:51 +0200 | [diff] [blame] | 299 | WQ_UNBOUND = 1 << 1, /* not bound to any cpu */ |
Tejun Heo | 58a69cb | 2011-02-16 09:25:31 +0100 | [diff] [blame] | 300 | WQ_FREEZABLE = 1 << 2, /* freeze during suspend */ |
Tejun Heo | 6370a6a | 2010-10-11 15:12:27 +0200 | [diff] [blame] | 301 | WQ_MEM_RECLAIM = 1 << 3, /* may be used for memory reclaim */ |
Tejun Heo | 649027d | 2010-06-29 10:07:14 +0200 | [diff] [blame] | 302 | WQ_HIGHPRI = 1 << 4, /* high priority */ |
Tejun Heo | fb0e7be | 2010-06-29 10:07:15 +0200 | [diff] [blame] | 303 | WQ_CPU_INTENSIVE = 1 << 5, /* cpu instensive workqueue */ |
Tejun Heo | 226223a | 2013-03-12 11:30:05 -0700 | [diff] [blame] | 304 | WQ_SYSFS = 1 << 6, /* visible in sysfs, see wq_sysfs_register() */ |
Tejun Heo | b71ab8c | 2010-06-29 10:07:14 +0200 | [diff] [blame] | 305 | |
Viresh Kumar | cee22a1 | 2013-04-08 16:45:40 +0530 | [diff] [blame] | 306 | /* |
| 307 | * Per-cpu workqueues are generally preferred because they tend to |
| 308 | * show better performance thanks to cache locality. Per-cpu |
| 309 | * workqueues exclude the scheduler from choosing the CPU to |
| 310 | * execute the worker threads, which has an unfortunate side effect |
| 311 | * of increasing power consumption. |
| 312 | * |
| 313 | * The scheduler considers a CPU idle if it doesn't have any task |
| 314 | * to execute and tries to keep idle cores idle to conserve power; |
| 315 | * however, for example, a per-cpu work item scheduled from an |
| 316 | * interrupt handler on an idle CPU will force the scheduler to |
| 317 | * excute the work item on that CPU breaking the idleness, which in |
| 318 | * turn may lead to more scheduling choices which are sub-optimal |
| 319 | * in terms of power consumption. |
| 320 | * |
| 321 | * Workqueues marked with WQ_POWER_EFFICIENT are per-cpu by default |
| 322 | * but become unbound if workqueue.power_efficient kernel param is |
| 323 | * specified. Per-cpu workqueues which are identified to |
| 324 | * contribute significantly to power-consumption are identified and |
| 325 | * marked with this flag and enabling the power_efficient mode |
| 326 | * leads to noticeable power saving at the cost of small |
| 327 | * performance disadvantage. |
| 328 | * |
| 329 | * http://thread.gmane.org/gmane.linux.kernel/1480396 |
| 330 | */ |
| 331 | WQ_POWER_EFFICIENT = 1 << 7, |
| 332 | |
Tejun Heo | 618b01e | 2013-03-12 11:30:04 -0700 | [diff] [blame] | 333 | __WQ_DRAINING = 1 << 16, /* internal: workqueue is draining */ |
Tejun Heo | 8719dce | 2013-03-12 11:30:04 -0700 | [diff] [blame] | 334 | __WQ_ORDERED = 1 << 17, /* internal: workqueue is ordered */ |
Tejun Heo | e41e704 | 2010-08-24 14:22:47 +0200 | [diff] [blame] | 335 | |
Tejun Heo | b71ab8c | 2010-06-29 10:07:14 +0200 | [diff] [blame] | 336 | WQ_MAX_ACTIVE = 512, /* I like 512, better ideas? */ |
Tejun Heo | f342179 | 2010-07-02 10:03:51 +0200 | [diff] [blame] | 337 | WQ_MAX_UNBOUND_PER_CPU = 4, /* 4 * #cpus for unbound wq */ |
Tejun Heo | b71ab8c | 2010-06-29 10:07:14 +0200 | [diff] [blame] | 338 | WQ_DFL_ACTIVE = WQ_MAX_ACTIVE / 2, |
Tejun Heo | 97e37d7 | 2010-06-29 10:07:10 +0200 | [diff] [blame] | 339 | }; |
David Howells | 52bad64 | 2006-11-22 14:54:01 +0000 | [diff] [blame] | 340 | |
Tejun Heo | f342179 | 2010-07-02 10:03:51 +0200 | [diff] [blame] | 341 | /* unbound wq's aren't per-cpu, scale max_active according to #cpus */ |
| 342 | #define WQ_UNBOUND_MAX_ACTIVE \ |
| 343 | max_t(int, WQ_MAX_ACTIVE, num_possible_cpus() * WQ_MAX_UNBOUND_PER_CPU) |
| 344 | |
Tejun Heo | d320c03 | 2010-06-29 10:07:14 +0200 | [diff] [blame] | 345 | /* |
| 346 | * System-wide workqueues which are always present. |
| 347 | * |
| 348 | * system_wq is the one used by schedule[_delayed]_work[_on](). |
| 349 | * Multi-CPU multi-threaded. There are users which expect relatively |
| 350 | * short queue flush time. Don't queue works which can run for too |
| 351 | * long. |
| 352 | * |
| 353 | * system_long_wq is similar to system_wq but may host long running |
| 354 | * works. Queue flushing might take relatively long. |
| 355 | * |
Tejun Heo | f342179 | 2010-07-02 10:03:51 +0200 | [diff] [blame] | 356 | * system_unbound_wq is unbound workqueue. Workers are not bound to |
| 357 | * any specific CPU, not concurrency managed, and all queued works are |
| 358 | * executed immediately as long as max_active limit is not reached and |
| 359 | * resources are available. |
Tejun Heo | 4149efb | 2011-02-08 10:39:03 +0100 | [diff] [blame] | 360 | * |
Tejun Heo | 24d51ad | 2011-02-21 09:52:50 +0100 | [diff] [blame] | 361 | * system_freezable_wq is equivalent to system_wq except that it's |
| 362 | * freezable. |
Viresh Kumar | 0668106 | 2013-04-24 17:12:54 +0530 | [diff] [blame] | 363 | * |
| 364 | * *_power_efficient_wq are inclined towards saving power and converted |
| 365 | * into WQ_UNBOUND variants if 'wq_power_efficient' is enabled; otherwise, |
| 366 | * they are same as their non-power-efficient counterparts - e.g. |
| 367 | * system_power_efficient_wq is identical to system_wq if |
| 368 | * 'wq_power_efficient' is disabled. See WQ_POWER_EFFICIENT for more info. |
Tejun Heo | d320c03 | 2010-06-29 10:07:14 +0200 | [diff] [blame] | 369 | */ |
| 370 | extern struct workqueue_struct *system_wq; |
| 371 | extern struct workqueue_struct *system_long_wq; |
Tejun Heo | f342179 | 2010-07-02 10:03:51 +0200 | [diff] [blame] | 372 | extern struct workqueue_struct *system_unbound_wq; |
Tejun Heo | 24d51ad | 2011-02-21 09:52:50 +0100 | [diff] [blame] | 373 | extern struct workqueue_struct *system_freezable_wq; |
Viresh Kumar | 0668106 | 2013-04-24 17:12:54 +0530 | [diff] [blame] | 374 | extern struct workqueue_struct *system_power_efficient_wq; |
| 375 | extern struct workqueue_struct *system_freezable_power_efficient_wq; |
Tejun Heo | ae930e0 | 2012-08-20 14:51:23 -0700 | [diff] [blame] | 376 | |
Tejun Heo | 3b07e9c | 2012-08-20 14:51:24 -0700 | [diff] [blame] | 377 | static inline struct workqueue_struct * __deprecated __system_nrt_wq(void) |
Tejun Heo | ae930e0 | 2012-08-20 14:51:23 -0700 | [diff] [blame] | 378 | { |
| 379 | return system_wq; |
| 380 | } |
| 381 | |
Tejun Heo | 3b07e9c | 2012-08-20 14:51:24 -0700 | [diff] [blame] | 382 | static inline struct workqueue_struct * __deprecated __system_nrt_freezable_wq(void) |
Tejun Heo | ae930e0 | 2012-08-20 14:51:23 -0700 | [diff] [blame] | 383 | { |
| 384 | return system_freezable_wq; |
| 385 | } |
| 386 | |
| 387 | /* equivlalent to system_wq and system_freezable_wq, deprecated */ |
| 388 | #define system_nrt_wq __system_nrt_wq() |
| 389 | #define system_nrt_freezable_wq __system_nrt_freezable_wq() |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 390 | |
Johannes Berg | 4e6045f | 2007-10-18 23:39:55 -0700 | [diff] [blame] | 391 | extern struct workqueue_struct * |
Tejun Heo | b196be8 | 2012-01-10 15:11:35 -0800 | [diff] [blame] | 392 | __alloc_workqueue_key(const char *fmt, unsigned int flags, int max_active, |
| 393 | struct lock_class_key *key, const char *lock_name, ...) __printf(1, 6); |
Johannes Berg | 4e6045f | 2007-10-18 23:39:55 -0700 | [diff] [blame] | 394 | |
Tejun Heo | b196be8 | 2012-01-10 15:11:35 -0800 | [diff] [blame] | 395 | /** |
| 396 | * alloc_workqueue - allocate a workqueue |
| 397 | * @fmt: printf format for the name of the workqueue |
| 398 | * @flags: WQ_* flags |
| 399 | * @max_active: max in-flight work items, 0 for default |
| 400 | * @args: args for @fmt |
| 401 | * |
| 402 | * Allocate a workqueue with the specified parameters. For detailed |
| 403 | * information on WQ_* flags, please refer to Documentation/workqueue.txt. |
| 404 | * |
| 405 | * The __lock_name macro dance is to guarantee that single lock_class_key |
| 406 | * doesn't end up with different namesm, which isn't allowed by lockdep. |
| 407 | * |
| 408 | * RETURNS: |
| 409 | * Pointer to the allocated workqueue on success, %NULL on failure. |
| 410 | */ |
Johannes Berg | 4e6045f | 2007-10-18 23:39:55 -0700 | [diff] [blame] | 411 | #ifdef CONFIG_LOCKDEP |
Tejun Heo | ee64e7f | 2012-08-21 13:18:23 -0700 | [diff] [blame] | 412 | #define alloc_workqueue(fmt, flags, max_active, args...) \ |
| 413 | ({ \ |
| 414 | static struct lock_class_key __key; \ |
| 415 | const char *__lock_name; \ |
| 416 | \ |
| 417 | if (__builtin_constant_p(fmt)) \ |
| 418 | __lock_name = (fmt); \ |
| 419 | else \ |
| 420 | __lock_name = #fmt; \ |
| 421 | \ |
| 422 | __alloc_workqueue_key((fmt), (flags), (max_active), \ |
| 423 | &__key, __lock_name, ##args); \ |
Johannes Berg | 4e6045f | 2007-10-18 23:39:55 -0700 | [diff] [blame] | 424 | }) |
| 425 | #else |
Tejun Heo | ee64e7f | 2012-08-21 13:18:23 -0700 | [diff] [blame] | 426 | #define alloc_workqueue(fmt, flags, max_active, args...) \ |
| 427 | __alloc_workqueue_key((fmt), (flags), (max_active), \ |
Tejun Heo | b196be8 | 2012-01-10 15:11:35 -0800 | [diff] [blame] | 428 | NULL, NULL, ##args) |
Johannes Berg | 4e6045f | 2007-10-18 23:39:55 -0700 | [diff] [blame] | 429 | #endif |
| 430 | |
Tejun Heo | 81dcaf6 | 2010-09-16 10:17:35 +0200 | [diff] [blame] | 431 | /** |
| 432 | * alloc_ordered_workqueue - allocate an ordered workqueue |
Tejun Heo | b196be8 | 2012-01-10 15:11:35 -0800 | [diff] [blame] | 433 | * @fmt: printf format for the name of the workqueue |
Tejun Heo | 58a69cb | 2011-02-16 09:25:31 +0100 | [diff] [blame] | 434 | * @flags: WQ_* flags (only WQ_FREEZABLE and WQ_MEM_RECLAIM are meaningful) |
Tejun Heo | b196be8 | 2012-01-10 15:11:35 -0800 | [diff] [blame] | 435 | * @args: args for @fmt |
Tejun Heo | 81dcaf6 | 2010-09-16 10:17:35 +0200 | [diff] [blame] | 436 | * |
| 437 | * Allocate an ordered workqueue. An ordered workqueue executes at |
| 438 | * most one work item at any given time in the queued order. They are |
| 439 | * implemented as unbound workqueues with @max_active of one. |
| 440 | * |
| 441 | * RETURNS: |
| 442 | * Pointer to the allocated workqueue on success, %NULL on failure. |
| 443 | */ |
Tejun Heo | ee64e7f | 2012-08-21 13:18:23 -0700 | [diff] [blame] | 444 | #define alloc_ordered_workqueue(fmt, flags, args...) \ |
Tejun Heo | 8719dce | 2013-03-12 11:30:04 -0700 | [diff] [blame] | 445 | alloc_workqueue(fmt, WQ_UNBOUND | __WQ_ORDERED | (flags), 1, ##args) |
Tejun Heo | 81dcaf6 | 2010-09-16 10:17:35 +0200 | [diff] [blame] | 446 | |
Tejun Heo | ee64e7f | 2012-08-21 13:18:23 -0700 | [diff] [blame] | 447 | #define create_workqueue(name) \ |
Kees Cook | d853754 | 2013-07-03 15:04:57 -0700 | [diff] [blame] | 448 | alloc_workqueue("%s", WQ_MEM_RECLAIM, 1, (name)) |
Tejun Heo | ee64e7f | 2012-08-21 13:18:23 -0700 | [diff] [blame] | 449 | #define create_freezable_workqueue(name) \ |
Kees Cook | d853754 | 2013-07-03 15:04:57 -0700 | [diff] [blame] | 450 | alloc_workqueue("%s", WQ_FREEZABLE | WQ_UNBOUND | WQ_MEM_RECLAIM, \ |
| 451 | 1, (name)) |
Tejun Heo | ee64e7f | 2012-08-21 13:18:23 -0700 | [diff] [blame] | 452 | #define create_singlethread_workqueue(name) \ |
Kees Cook | d853754 | 2013-07-03 15:04:57 -0700 | [diff] [blame] | 453 | alloc_workqueue("%s", WQ_UNBOUND | WQ_MEM_RECLAIM, 1, (name)) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 454 | |
| 455 | extern void destroy_workqueue(struct workqueue_struct *wq); |
| 456 | |
Tejun Heo | 7a4e344 | 2013-03-12 11:30:00 -0700 | [diff] [blame] | 457 | struct workqueue_attrs *alloc_workqueue_attrs(gfp_t gfp_mask); |
| 458 | void free_workqueue_attrs(struct workqueue_attrs *attrs); |
Tejun Heo | 9e8cd2f | 2013-03-12 11:30:04 -0700 | [diff] [blame] | 459 | int apply_workqueue_attrs(struct workqueue_struct *wq, |
| 460 | const struct workqueue_attrs *attrs); |
Tejun Heo | 7a4e344 | 2013-03-12 11:30:00 -0700 | [diff] [blame] | 461 | |
Tejun Heo | d4283e9 | 2012-08-03 10:30:44 -0700 | [diff] [blame] | 462 | extern bool queue_work_on(int cpu, struct workqueue_struct *wq, |
Zhang Rui | c1a220e | 2008-07-23 21:28:39 -0700 | [diff] [blame] | 463 | struct work_struct *work); |
Tejun Heo | d4283e9 | 2012-08-03 10:30:44 -0700 | [diff] [blame] | 464 | extern bool queue_delayed_work_on(int cpu, struct workqueue_struct *wq, |
Oleg Nesterov | 28e53bd | 2007-05-09 02:34:22 -0700 | [diff] [blame] | 465 | struct delayed_work *work, unsigned long delay); |
Tejun Heo | 8376fe2 | 2012-08-03 10:30:47 -0700 | [diff] [blame] | 466 | extern bool mod_delayed_work_on(int cpu, struct workqueue_struct *wq, |
| 467 | struct delayed_work *dwork, unsigned long delay); |
Oleg Nesterov | 28e53bd | 2007-05-09 02:34:22 -0700 | [diff] [blame] | 468 | |
Harvey Harrison | b3c9752 | 2008-02-13 15:03:15 -0800 | [diff] [blame] | 469 | extern void flush_workqueue(struct workqueue_struct *wq); |
Tejun Heo | 9c5a2ba | 2011-04-05 18:01:44 +0200 | [diff] [blame] | 470 | extern void drain_workqueue(struct workqueue_struct *wq); |
Oleg Nesterov | 28e53bd | 2007-05-09 02:34:22 -0700 | [diff] [blame] | 471 | extern void flush_scheduled_work(void); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 472 | |
David Howells | 65f27f3 | 2006-11-22 14:55:48 +0000 | [diff] [blame] | 473 | extern int schedule_on_each_cpu(work_func_t func); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 474 | |
David Howells | 65f27f3 | 2006-11-22 14:55:48 +0000 | [diff] [blame] | 475 | int execute_in_process_context(work_func_t fn, struct execute_work *); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 476 | |
Tejun Heo | 401a8d0 | 2010-09-16 10:36:00 +0200 | [diff] [blame] | 477 | extern bool flush_work(struct work_struct *work); |
| 478 | extern bool cancel_work_sync(struct work_struct *work); |
| 479 | |
| 480 | extern bool flush_delayed_work(struct delayed_work *dwork); |
Tejun Heo | 57b30ae | 2012-08-21 13:18:24 -0700 | [diff] [blame] | 481 | extern bool cancel_delayed_work(struct delayed_work *dwork); |
Tejun Heo | 401a8d0 | 2010-09-16 10:36:00 +0200 | [diff] [blame] | 482 | extern bool cancel_delayed_work_sync(struct delayed_work *dwork); |
Oleg Nesterov | 28e53bd | 2007-05-09 02:34:22 -0700 | [diff] [blame] | 483 | |
Tejun Heo | dcd989c | 2010-06-29 10:07:14 +0200 | [diff] [blame] | 484 | extern void workqueue_set_max_active(struct workqueue_struct *wq, |
| 485 | int max_active); |
Tejun Heo | e6267616 | 2013-03-12 17:41:37 -0700 | [diff] [blame] | 486 | extern bool current_is_workqueue_rescuer(void); |
Tejun Heo | d84ff05 | 2013-03-12 11:29:59 -0700 | [diff] [blame] | 487 | extern bool workqueue_congested(int cpu, struct workqueue_struct *wq); |
Tejun Heo | dcd989c | 2010-06-29 10:07:14 +0200 | [diff] [blame] | 488 | extern unsigned int work_busy(struct work_struct *work); |
Tejun Heo | 3d1cb20 | 2013-04-30 15:27:22 -0700 | [diff] [blame] | 489 | extern __printf(1, 2) void set_worker_desc(const char *fmt, ...); |
| 490 | extern void print_worker_info(const char *log_lvl, struct task_struct *task); |
Tejun Heo | dcd989c | 2010-06-29 10:07:14 +0200 | [diff] [blame] | 491 | |
Tejun Heo | 8425e3d5 | 2013-03-13 16:51:36 -0700 | [diff] [blame] | 492 | /** |
| 493 | * queue_work - queue work on a workqueue |
| 494 | * @wq: workqueue to use |
| 495 | * @work: work to queue |
| 496 | * |
| 497 | * Returns %false if @work was already on a queue, %true otherwise. |
| 498 | * |
| 499 | * We queue the work to the CPU on which it was submitted, but if the CPU dies |
| 500 | * it can be processed by another CPU. |
| 501 | */ |
| 502 | static inline bool queue_work(struct workqueue_struct *wq, |
| 503 | struct work_struct *work) |
| 504 | { |
| 505 | return queue_work_on(WORK_CPU_UNBOUND, wq, work); |
| 506 | } |
| 507 | |
| 508 | /** |
| 509 | * queue_delayed_work - queue work on a workqueue after delay |
| 510 | * @wq: workqueue to use |
| 511 | * @dwork: delayable work to queue |
| 512 | * @delay: number of jiffies to wait before queueing |
| 513 | * |
| 514 | * Equivalent to queue_delayed_work_on() but tries to use the local CPU. |
| 515 | */ |
| 516 | static inline bool queue_delayed_work(struct workqueue_struct *wq, |
| 517 | struct delayed_work *dwork, |
| 518 | unsigned long delay) |
| 519 | { |
| 520 | return queue_delayed_work_on(WORK_CPU_UNBOUND, wq, dwork, delay); |
| 521 | } |
| 522 | |
| 523 | /** |
| 524 | * mod_delayed_work - modify delay of or queue a delayed work |
| 525 | * @wq: workqueue to use |
| 526 | * @dwork: work to queue |
| 527 | * @delay: number of jiffies to wait before queueing |
| 528 | * |
| 529 | * mod_delayed_work_on() on local CPU. |
| 530 | */ |
| 531 | static inline bool mod_delayed_work(struct workqueue_struct *wq, |
| 532 | struct delayed_work *dwork, |
| 533 | unsigned long delay) |
| 534 | { |
| 535 | return mod_delayed_work_on(WORK_CPU_UNBOUND, wq, dwork, delay); |
| 536 | } |
| 537 | |
| 538 | /** |
| 539 | * schedule_work_on - put work task on a specific cpu |
| 540 | * @cpu: cpu to put the work task on |
| 541 | * @work: job to be done |
| 542 | * |
| 543 | * This puts a job on a specific cpu |
| 544 | */ |
| 545 | static inline bool schedule_work_on(int cpu, struct work_struct *work) |
| 546 | { |
| 547 | return queue_work_on(cpu, system_wq, work); |
| 548 | } |
| 549 | |
| 550 | /** |
| 551 | * schedule_work - put work task in global workqueue |
| 552 | * @work: job to be done |
| 553 | * |
| 554 | * Returns %false if @work was already on the kernel-global workqueue and |
| 555 | * %true otherwise. |
| 556 | * |
| 557 | * This puts a job in the kernel-global workqueue if it was not already |
| 558 | * queued and leaves it in the same position on the kernel-global |
| 559 | * workqueue otherwise. |
| 560 | */ |
| 561 | static inline bool schedule_work(struct work_struct *work) |
| 562 | { |
| 563 | return queue_work(system_wq, work); |
| 564 | } |
| 565 | |
| 566 | /** |
| 567 | * schedule_delayed_work_on - queue work in global workqueue on CPU after delay |
| 568 | * @cpu: cpu to use |
| 569 | * @dwork: job to be done |
| 570 | * @delay: number of jiffies to wait |
| 571 | * |
| 572 | * After waiting for a given time this puts a job in the kernel-global |
| 573 | * workqueue on the specified CPU. |
| 574 | */ |
| 575 | static inline bool schedule_delayed_work_on(int cpu, struct delayed_work *dwork, |
| 576 | unsigned long delay) |
| 577 | { |
| 578 | return queue_delayed_work_on(cpu, system_wq, dwork, delay); |
| 579 | } |
| 580 | |
| 581 | /** |
| 582 | * schedule_delayed_work - put work task in global workqueue after delay |
| 583 | * @dwork: job to be done |
| 584 | * @delay: number of jiffies to wait or 0 for immediate execution |
| 585 | * |
| 586 | * After waiting for a given time this puts a job in the kernel-global |
| 587 | * workqueue. |
| 588 | */ |
| 589 | static inline bool schedule_delayed_work(struct delayed_work *dwork, |
| 590 | unsigned long delay) |
| 591 | { |
| 592 | return queue_delayed_work(system_wq, dwork, delay); |
| 593 | } |
| 594 | |
| 595 | /** |
| 596 | * keventd_up - is workqueue initialized yet? |
| 597 | */ |
| 598 | static inline bool keventd_up(void) |
| 599 | { |
| 600 | return system_wq != NULL; |
| 601 | } |
| 602 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 603 | /* |
Oleg Nesterov | 4e49627 | 2009-09-05 11:17:06 -0700 | [diff] [blame] | 604 | * Like above, but uses del_timer() instead of del_timer_sync(). This means, |
| 605 | * if it returns 0 the timer function may be running and the queueing is in |
| 606 | * progress. |
| 607 | */ |
Tejun Heo | 136b572 | 2012-08-21 13:18:24 -0700 | [diff] [blame] | 608 | static inline bool __deprecated __cancel_delayed_work(struct delayed_work *work) |
Oleg Nesterov | 4e49627 | 2009-09-05 11:17:06 -0700 | [diff] [blame] | 609 | { |
Tejun Heo | 401a8d0 | 2010-09-16 10:36:00 +0200 | [diff] [blame] | 610 | bool ret; |
Oleg Nesterov | 4e49627 | 2009-09-05 11:17:06 -0700 | [diff] [blame] | 611 | |
| 612 | ret = del_timer(&work->timer); |
| 613 | if (ret) |
| 614 | work_clear_pending(&work->work); |
| 615 | return ret; |
| 616 | } |
| 617 | |
Tejun Heo | 606a502 | 2012-08-20 14:51:23 -0700 | [diff] [blame] | 618 | /* used to be different but now identical to flush_work(), deprecated */ |
Tejun Heo | 4382973 | 2012-08-20 14:51:24 -0700 | [diff] [blame] | 619 | static inline bool __deprecated flush_work_sync(struct work_struct *work) |
Tejun Heo | 606a502 | 2012-08-20 14:51:23 -0700 | [diff] [blame] | 620 | { |
| 621 | return flush_work(work); |
| 622 | } |
| 623 | |
| 624 | /* used to be different but now identical to flush_delayed_work(), deprecated */ |
Tejun Heo | 4382973 | 2012-08-20 14:51:24 -0700 | [diff] [blame] | 625 | static inline bool __deprecated flush_delayed_work_sync(struct delayed_work *dwork) |
Tejun Heo | 606a502 | 2012-08-20 14:51:23 -0700 | [diff] [blame] | 626 | { |
| 627 | return flush_delayed_work(dwork); |
| 628 | } |
| 629 | |
Rusty Russell | 2d3854a | 2008-11-05 13:39:10 +1100 | [diff] [blame] | 630 | #ifndef CONFIG_SMP |
Tejun Heo | d84ff05 | 2013-03-12 11:29:59 -0700 | [diff] [blame] | 631 | static inline long work_on_cpu(int cpu, long (*fn)(void *), void *arg) |
Rusty Russell | 2d3854a | 2008-11-05 13:39:10 +1100 | [diff] [blame] | 632 | { |
| 633 | return fn(arg); |
| 634 | } |
| 635 | #else |
Tejun Heo | d84ff05 | 2013-03-12 11:29:59 -0700 | [diff] [blame] | 636 | long work_on_cpu(int cpu, long (*fn)(void *), void *arg); |
Rusty Russell | 2d3854a | 2008-11-05 13:39:10 +1100 | [diff] [blame] | 637 | #endif /* CONFIG_SMP */ |
Paul E. McKenney | a25909a | 2010-05-13 12:32:28 -0700 | [diff] [blame] | 638 | |
Tejun Heo | a0a1a5f | 2010-06-29 10:07:12 +0200 | [diff] [blame] | 639 | #ifdef CONFIG_FREEZER |
| 640 | extern void freeze_workqueues_begin(void); |
| 641 | extern bool freeze_workqueues_busy(void); |
| 642 | extern void thaw_workqueues(void); |
| 643 | #endif /* CONFIG_FREEZER */ |
| 644 | |
Tejun Heo | 226223a | 2013-03-12 11:30:05 -0700 | [diff] [blame] | 645 | #ifdef CONFIG_SYSFS |
| 646 | int workqueue_sysfs_register(struct workqueue_struct *wq); |
| 647 | #else /* CONFIG_SYSFS */ |
| 648 | static inline int workqueue_sysfs_register(struct workqueue_struct *wq) |
| 649 | { return 0; } |
| 650 | #endif /* CONFIG_SYSFS */ |
| 651 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 652 | #endif |