include/linux/workqueue.h

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