workqueue.h 13 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437
  1. /*
  2. * workqueue.h --- work queue handling for Linux.
  3. */
  4. #ifndef _LINUX_WORKQUEUE_H
  5. #define _LINUX_WORKQUEUE_H
  6. #include <linux/timer.h>
  7. #include <linux/linkage.h>
  8. #include <linux/bitops.h>
  9. #include <linux/lockdep.h>
  10. #include <linux/threads.h>
  11. #include <asm/atomic.h>
  12. struct workqueue_struct;
  13. struct work_struct;
  14. typedef void (*work_func_t)(struct work_struct *work);
  15. /*
  16. * The first word is the work queue pointer and the flags rolled into
  17. * one
  18. */
  19. #define work_data_bits(work) ((unsigned long *)(&(work)->data))
  20. enum {
  21. WORK_STRUCT_PENDING_BIT = 0, /* work item is pending execution */
  22. WORK_STRUCT_DELAYED_BIT = 1, /* work item is delayed */
  23. WORK_STRUCT_CWQ_BIT = 2, /* data points to cwq */
  24. WORK_STRUCT_LINKED_BIT = 3, /* next work is linked to this one */
  25. #ifdef CONFIG_DEBUG_OBJECTS_WORK
  26. WORK_STRUCT_STATIC_BIT = 4, /* static initializer (debugobjects) */
  27. WORK_STRUCT_COLOR_SHIFT = 5, /* color for workqueue flushing */
  28. #else
  29. WORK_STRUCT_COLOR_SHIFT = 4, /* color for workqueue flushing */
  30. #endif
  31. WORK_STRUCT_COLOR_BITS = 4,
  32. WORK_STRUCT_PENDING = 1 << WORK_STRUCT_PENDING_BIT,
  33. WORK_STRUCT_DELAYED = 1 << WORK_STRUCT_DELAYED_BIT,
  34. WORK_STRUCT_CWQ = 1 << WORK_STRUCT_CWQ_BIT,
  35. WORK_STRUCT_LINKED = 1 << WORK_STRUCT_LINKED_BIT,
  36. #ifdef CONFIG_DEBUG_OBJECTS_WORK
  37. WORK_STRUCT_STATIC = 1 << WORK_STRUCT_STATIC_BIT,
  38. #else
  39. WORK_STRUCT_STATIC = 0,
  40. #endif
  41. /*
  42. * The last color is no color used for works which don't
  43. * participate in workqueue flushing.
  44. */
  45. WORK_NR_COLORS = (1 << WORK_STRUCT_COLOR_BITS) - 1,
  46. WORK_NO_COLOR = WORK_NR_COLORS,
  47. /* special cpu IDs */
  48. WORK_CPU_UNBOUND = NR_CPUS,
  49. WORK_CPU_NONE = NR_CPUS + 1,
  50. WORK_CPU_LAST = WORK_CPU_NONE,
  51. /*
  52. * Reserve 7 bits off of cwq pointer w/ debugobjects turned
  53. * off. This makes cwqs aligned to 256 bytes and allows 15
  54. * workqueue flush colors.
  55. */
  56. WORK_STRUCT_FLAG_BITS = WORK_STRUCT_COLOR_SHIFT +
  57. WORK_STRUCT_COLOR_BITS,
  58. WORK_STRUCT_FLAG_MASK = (1UL << WORK_STRUCT_FLAG_BITS) - 1,
  59. WORK_STRUCT_WQ_DATA_MASK = ~WORK_STRUCT_FLAG_MASK,
  60. WORK_STRUCT_NO_CPU = WORK_CPU_NONE << WORK_STRUCT_FLAG_BITS,
  61. /* bit mask for work_busy() return values */
  62. WORK_BUSY_PENDING = 1 << 0,
  63. WORK_BUSY_RUNNING = 1 << 1,
  64. };
  65. struct work_struct {
  66. atomic_long_t data;
  67. struct list_head entry;
  68. work_func_t func;
  69. #ifdef CONFIG_LOCKDEP
  70. struct lockdep_map lockdep_map;
  71. #endif
  72. };
  73. #define WORK_DATA_INIT() ATOMIC_LONG_INIT(WORK_STRUCT_NO_CPU)
  74. #define WORK_DATA_STATIC_INIT() \
  75. ATOMIC_LONG_INIT(WORK_STRUCT_NO_CPU | WORK_STRUCT_STATIC)
  76. struct delayed_work {
  77. struct work_struct work;
  78. struct timer_list timer;
  79. };
  80. static inline struct delayed_work *to_delayed_work(struct work_struct *work)
  81. {
  82. return container_of(work, struct delayed_work, work);
  83. }
  84. struct execute_work {
  85. struct work_struct work;
  86. };
  87. #ifdef CONFIG_LOCKDEP
  88. /*
  89. * NB: because we have to copy the lockdep_map, setting _key
  90. * here is required, otherwise it could get initialised to the
  91. * copy of the lockdep_map!
  92. */
  93. #define __WORK_INIT_LOCKDEP_MAP(n, k) \
  94. .lockdep_map = STATIC_LOCKDEP_MAP_INIT(n, k),
  95. #else
  96. #define __WORK_INIT_LOCKDEP_MAP(n, k)
  97. #endif
  98. #define __WORK_INITIALIZER(n, f) { \
  99. .data = WORK_DATA_STATIC_INIT(), \
  100. .entry = { &(n).entry, &(n).entry }, \
  101. .func = (f), \
  102. __WORK_INIT_LOCKDEP_MAP(#n, &(n)) \
  103. }
  104. #define __DELAYED_WORK_INITIALIZER(n, f) { \
  105. .work = __WORK_INITIALIZER((n).work, (f)), \
  106. .timer = TIMER_INITIALIZER(NULL, 0, 0), \
  107. }
  108. #define DECLARE_WORK(n, f) \
  109. struct work_struct n = __WORK_INITIALIZER(n, f)
  110. #define DECLARE_DELAYED_WORK(n, f) \
  111. struct delayed_work n = __DELAYED_WORK_INITIALIZER(n, f)
  112. /*
  113. * initialize a work item's function pointer
  114. */
  115. #define PREPARE_WORK(_work, _func) \
  116. do { \
  117. (_work)->func = (_func); \
  118. } while (0)
  119. #define PREPARE_DELAYED_WORK(_work, _func) \
  120. PREPARE_WORK(&(_work)->work, (_func))
  121. #ifdef CONFIG_DEBUG_OBJECTS_WORK
  122. extern void __init_work(struct work_struct *work, int onstack);
  123. extern void destroy_work_on_stack(struct work_struct *work);
  124. static inline unsigned int work_static(struct work_struct *work)
  125. {
  126. return *work_data_bits(work) & WORK_STRUCT_STATIC;
  127. }
  128. #else
  129. static inline void __init_work(struct work_struct *work, int onstack) { }
  130. static inline void destroy_work_on_stack(struct work_struct *work) { }
  131. static inline unsigned int work_static(struct work_struct *work) { return 0; }
  132. #endif
  133. /*
  134. * initialize all of a work item in one go
  135. *
  136. * NOTE! No point in using "atomic_long_set()": using a direct
  137. * assignment of the work data initializer allows the compiler
  138. * to generate better code.
  139. */
  140. #ifdef CONFIG_LOCKDEP
  141. #define __INIT_WORK(_work, _func, _onstack) \
  142. do { \
  143. static struct lock_class_key __key; \
  144. \
  145. __init_work((_work), _onstack); \
  146. (_work)->data = (atomic_long_t) WORK_DATA_INIT(); \
  147. lockdep_init_map(&(_work)->lockdep_map, #_work, &__key, 0);\
  148. INIT_LIST_HEAD(&(_work)->entry); \
  149. PREPARE_WORK((_work), (_func)); \
  150. } while (0)
  151. #else
  152. #define __INIT_WORK(_work, _func, _onstack) \
  153. do { \
  154. __init_work((_work), _onstack); \
  155. (_work)->data = (atomic_long_t) WORK_DATA_INIT(); \
  156. INIT_LIST_HEAD(&(_work)->entry); \
  157. PREPARE_WORK((_work), (_func)); \
  158. } while (0)
  159. #endif
  160. #define INIT_WORK(_work, _func) \
  161. do { \
  162. __INIT_WORK((_work), (_func), 0); \
  163. } while (0)
  164. #define INIT_WORK_ON_STACK(_work, _func) \
  165. do { \
  166. __INIT_WORK((_work), (_func), 1); \
  167. } while (0)
  168. #define INIT_DELAYED_WORK(_work, _func) \
  169. do { \
  170. INIT_WORK(&(_work)->work, (_func)); \
  171. init_timer(&(_work)->timer); \
  172. } while (0)
  173. #define INIT_DELAYED_WORK_ON_STACK(_work, _func) \
  174. do { \
  175. INIT_WORK_ON_STACK(&(_work)->work, (_func)); \
  176. init_timer_on_stack(&(_work)->timer); \
  177. } while (0)
  178. #define INIT_DELAYED_WORK_DEFERRABLE(_work, _func) \
  179. do { \
  180. INIT_WORK(&(_work)->work, (_func)); \
  181. init_timer_deferrable(&(_work)->timer); \
  182. } while (0)
  183. /**
  184. * work_pending - Find out whether a work item is currently pending
  185. * @work: The work item in question
  186. */
  187. #define work_pending(work) \
  188. test_bit(WORK_STRUCT_PENDING_BIT, work_data_bits(work))
  189. /**
  190. * delayed_work_pending - Find out whether a delayable work item is currently
  191. * pending
  192. * @work: The work item in question
  193. */
  194. #define delayed_work_pending(w) \
  195. work_pending(&(w)->work)
  196. /**
  197. * work_clear_pending - for internal use only, mark a work item as not pending
  198. * @work: The work item in question
  199. */
  200. #define work_clear_pending(work) \
  201. clear_bit(WORK_STRUCT_PENDING_BIT, work_data_bits(work))
  202. /*
  203. * Workqueue flags and constants. For details, please refer to
  204. * Documentation/workqueue.txt.
  205. */
  206. enum {
  207. WQ_NON_REENTRANT = 1 << 0, /* guarantee non-reentrance */
  208. WQ_UNBOUND = 1 << 1, /* not bound to any cpu */
  209. WQ_FREEZEABLE = 1 << 2, /* freeze during suspend */
  210. WQ_MEM_RECLAIM = 1 << 3, /* may be used for memory reclaim */
  211. WQ_HIGHPRI = 1 << 4, /* high priority */
  212. WQ_CPU_INTENSIVE = 1 << 5, /* cpu instensive workqueue */
  213. WQ_DYING = 1 << 6, /* internal: workqueue is dying */
  214. WQ_RESCUER = 1 << 7, /* internal: workqueue has rescuer */
  215. WQ_MAX_ACTIVE = 512, /* I like 512, better ideas? */
  216. WQ_MAX_UNBOUND_PER_CPU = 4, /* 4 * #cpus for unbound wq */
  217. WQ_DFL_ACTIVE = WQ_MAX_ACTIVE / 2,
  218. };
  219. /* unbound wq's aren't per-cpu, scale max_active according to #cpus */
  220. #define WQ_UNBOUND_MAX_ACTIVE \
  221. max_t(int, WQ_MAX_ACTIVE, num_possible_cpus() * WQ_MAX_UNBOUND_PER_CPU)
  222. /*
  223. * System-wide workqueues which are always present.
  224. *
  225. * system_wq is the one used by schedule[_delayed]_work[_on]().
  226. * Multi-CPU multi-threaded. There are users which expect relatively
  227. * short queue flush time. Don't queue works which can run for too
  228. * long.
  229. *
  230. * system_long_wq is similar to system_wq but may host long running
  231. * works. Queue flushing might take relatively long.
  232. *
  233. * system_nrt_wq is non-reentrant and guarantees that any given work
  234. * item is never executed in parallel by multiple CPUs. Queue
  235. * flushing might take relatively long.
  236. *
  237. * system_unbound_wq is unbound workqueue. Workers are not bound to
  238. * any specific CPU, not concurrency managed, and all queued works are
  239. * executed immediately as long as max_active limit is not reached and
  240. * resources are available.
  241. */
  242. extern struct workqueue_struct *system_wq;
  243. extern struct workqueue_struct *system_long_wq;
  244. extern struct workqueue_struct *system_nrt_wq;
  245. extern struct workqueue_struct *system_unbound_wq;
  246. extern struct workqueue_struct *
  247. __alloc_workqueue_key(const char *name, unsigned int flags, int max_active,
  248. struct lock_class_key *key, const char *lock_name);
  249. #ifdef CONFIG_LOCKDEP
  250. #define alloc_workqueue(name, flags, max_active) \
  251. ({ \
  252. static struct lock_class_key __key; \
  253. const char *__lock_name; \
  254. \
  255. if (__builtin_constant_p(name)) \
  256. __lock_name = (name); \
  257. else \
  258. __lock_name = #name; \
  259. \
  260. __alloc_workqueue_key((name), (flags), (max_active), \
  261. &__key, __lock_name); \
  262. })
  263. #else
  264. #define alloc_workqueue(name, flags, max_active) \
  265. __alloc_workqueue_key((name), (flags), (max_active), NULL, NULL)
  266. #endif
  267. /**
  268. * alloc_ordered_workqueue - allocate an ordered workqueue
  269. * @name: name of the workqueue
  270. * @flags: WQ_* flags (only WQ_FREEZEABLE and WQ_MEM_RECLAIM are meaningful)
  271. *
  272. * Allocate an ordered workqueue. An ordered workqueue executes at
  273. * most one work item at any given time in the queued order. They are
  274. * implemented as unbound workqueues with @max_active of one.
  275. *
  276. * RETURNS:
  277. * Pointer to the allocated workqueue on success, %NULL on failure.
  278. */
  279. static inline struct workqueue_struct *
  280. alloc_ordered_workqueue(const char *name, unsigned int flags)
  281. {
  282. return alloc_workqueue(name, WQ_UNBOUND | flags, 1);
  283. }
  284. #define create_workqueue(name) \
  285. alloc_workqueue((name), WQ_MEM_RECLAIM, 1)
  286. #define create_freezeable_workqueue(name) \
  287. alloc_workqueue((name), WQ_FREEZEABLE | WQ_UNBOUND | WQ_MEM_RECLAIM, 1)
  288. #define create_singlethread_workqueue(name) \
  289. alloc_workqueue((name), WQ_UNBOUND | WQ_MEM_RECLAIM, 1)
  290. extern void destroy_workqueue(struct workqueue_struct *wq);
  291. extern int queue_work(struct workqueue_struct *wq, struct work_struct *work);
  292. extern int queue_work_on(int cpu, struct workqueue_struct *wq,
  293. struct work_struct *work);
  294. extern int queue_delayed_work(struct workqueue_struct *wq,
  295. struct delayed_work *work, unsigned long delay);
  296. extern int queue_delayed_work_on(int cpu, struct workqueue_struct *wq,
  297. struct delayed_work *work, unsigned long delay);
  298. extern void flush_workqueue(struct workqueue_struct *wq);
  299. extern void flush_scheduled_work(void);
  300. extern int schedule_work(struct work_struct *work);
  301. extern int schedule_work_on(int cpu, struct work_struct *work);
  302. extern int schedule_delayed_work(struct delayed_work *work, unsigned long delay);
  303. extern int schedule_delayed_work_on(int cpu, struct delayed_work *work,
  304. unsigned long delay);
  305. extern int schedule_on_each_cpu(work_func_t func);
  306. extern int keventd_up(void);
  307. int execute_in_process_context(work_func_t fn, struct execute_work *);
  308. extern bool flush_work(struct work_struct *work);
  309. extern bool flush_work_sync(struct work_struct *work);
  310. extern bool cancel_work_sync(struct work_struct *work);
  311. extern bool flush_delayed_work(struct delayed_work *dwork);
  312. extern bool flush_delayed_work_sync(struct delayed_work *work);
  313. extern bool cancel_delayed_work_sync(struct delayed_work *dwork);
  314. extern void workqueue_set_max_active(struct workqueue_struct *wq,
  315. int max_active);
  316. extern bool workqueue_congested(unsigned int cpu, struct workqueue_struct *wq);
  317. extern unsigned int work_cpu(struct work_struct *work);
  318. extern unsigned int work_busy(struct work_struct *work);
  319. /*
  320. * Kill off a pending schedule_delayed_work(). Note that the work callback
  321. * function may still be running on return from cancel_delayed_work(), unless
  322. * it returns 1 and the work doesn't re-arm itself. Run flush_workqueue() or
  323. * cancel_work_sync() to wait on it.
  324. */
  325. static inline bool cancel_delayed_work(struct delayed_work *work)
  326. {
  327. bool ret;
  328. ret = del_timer_sync(&work->timer);
  329. if (ret)
  330. work_clear_pending(&work->work);
  331. return ret;
  332. }
  333. /*
  334. * Like above, but uses del_timer() instead of del_timer_sync(). This means,
  335. * if it returns 0 the timer function may be running and the queueing is in
  336. * progress.
  337. */
  338. static inline bool __cancel_delayed_work(struct delayed_work *work)
  339. {
  340. bool ret;
  341. ret = del_timer(&work->timer);
  342. if (ret)
  343. work_clear_pending(&work->work);
  344. return ret;
  345. }
  346. /* Obsolete. use cancel_delayed_work_sync() */
  347. static inline
  348. void cancel_rearming_delayed_workqueue(struct workqueue_struct *wq,
  349. struct delayed_work *work)
  350. {
  351. cancel_delayed_work_sync(work);
  352. }
  353. /* Obsolete. use cancel_delayed_work_sync() */
  354. static inline
  355. void cancel_rearming_delayed_work(struct delayed_work *work)
  356. {
  357. cancel_delayed_work_sync(work);
  358. }
  359. #ifndef CONFIG_SMP
  360. static inline long work_on_cpu(unsigned int cpu, long (*fn)(void *), void *arg)
  361. {
  362. return fn(arg);
  363. }
  364. #else
  365. long work_on_cpu(unsigned int cpu, long (*fn)(void *), void *arg);
  366. #endif /* CONFIG_SMP */
  367. #ifdef CONFIG_FREEZER
  368. extern void freeze_workqueues_begin(void);
  369. extern bool freeze_workqueues_busy(void);
  370. extern void thaw_workqueues(void);
  371. #endif /* CONFIG_FREEZER */
  372. #ifdef CONFIG_LOCKDEP
  373. int in_workqueue_context(struct workqueue_struct *wq);
  374. #endif
  375. #endif