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 };
 230
 231 extern struct workqueue_struct *
 232 __create_workqueue_key(const char *name, unsigned int flags, int max_active,
 233                        struct lock_class_key *key, const char *lock_name);
 234
 235 #ifdef CONFIG_LOCKDEP
 236 #define __create_workqueue(name, flags, max_active)             \
 237 ({                                                              \
 238         static struct lock_class_key __key;                     \
 239         const char *__lock_name;                                \
 240                                                                 \
 241         if (__builtin_constant_p(name))                         \
 242                 __lock_name = (name);                           \
 243         else                                                    \
 244                 __lock_name = #name;                            \
 245                                                                 \
 246         __create_workqueue_key((name), (flags), (max_active),   \
 247                                 &__key, __lock_name);           \
 248 })
 249 #else
 250 #define __create_workqueue(name, flags, max_active)             \
 251         __create_workqueue_key((name), (flags), (max_active), NULL, NULL)
 252 #endif
 253
 254 #define create_workqueue(name)                                  \
 255         __create_workqueue((name), 0, 1)
 256 #define create_freezeable_workqueue(name)                       \
 257         __create_workqueue((name), WQ_FREEZEABLE | WQ_SINGLE_CPU, 1)
 258 #define create_singlethread_workqueue(name)                     \
 259         __create_workqueue((name), WQ_SINGLE_CPU, 1)
 260
 261 extern void destroy_workqueue(struct workqueue_struct *wq);
 262
 263 extern int queue_work(struct workqueue_struct *wq, struct work_struct *work);
 264 extern int queue_work_on(int cpu, struct workqueue_struct *wq,
 265                         struct work_struct *work);
 266 extern int queue_delayed_work(struct workqueue_struct *wq,
 267                         struct delayed_work *work, unsigned long delay);
 268 extern int queue_delayed_work_on(int cpu, struct workqueue_struct *wq,
 269                         struct delayed_work *work, unsigned long delay);
 270
 271 extern void flush_workqueue(struct workqueue_struct *wq);
 272 extern void flush_scheduled_work(void);
 273 extern void flush_delayed_work(struct delayed_work *work);
 274
 275 extern int schedule_work(struct work_struct *work);
 276 extern int schedule_work_on(int cpu, struct work_struct *work);
 277 extern int schedule_delayed_work(struct delayed_work *work, unsigned long delay);
 278 extern int schedule_delayed_work_on(int cpu, struct delayed_work *work,
 279                                         unsigned long delay);
 280 extern int schedule_on_each_cpu(work_func_t func);
 281 extern int current_is_keventd(void);
 282 extern int keventd_up(void);
 283
 284 extern void init_workqueues(void);
 285 int execute_in_process_context(work_func_t fn, struct execute_work *);
 286
 287 extern int flush_work(struct work_struct *work);
 288
 289 extern int cancel_work_sync(struct work_struct *work);
 290
 291 /*
 292  * Kill off a pending schedule_delayed_work().  Note that the work callback
 293  * function may still be running on return from cancel_delayed_work(), unless
 294  * it returns 1 and the work doesn't re-arm itself. Run flush_workqueue() or
 295  * cancel_work_sync() to wait on it.
 296  */
 297 static inline int cancel_delayed_work(struct delayed_work *work)
 298 {
 299         int ret;
 300
 301         ret = del_timer_sync(&work->timer);
 302         if (ret)
 303                 work_clear_pending(&work->work);
 304         return ret;
 305 }
 306
 307 /*
 308  * Like above, but uses del_timer() instead of del_timer_sync(). This means,
 309  * if it returns 0 the timer function may be running and the queueing is in
 310  * progress.
 311  */
 312 static inline int __cancel_delayed_work(struct delayed_work *work)
 313 {
 314         int ret;
 315
 316         ret = del_timer(&work->timer);
 317         if (ret)
 318                 work_clear_pending(&work->work);
 319         return ret;
 320 }
 321
 322 extern int cancel_delayed_work_sync(struct delayed_work *work);
 323
 324 /* Obsolete. use cancel_delayed_work_sync() */
 325 static inline
 326 void cancel_rearming_delayed_workqueue(struct workqueue_struct *wq,
 327                                         struct delayed_work *work)
 328 {
 329         cancel_delayed_work_sync(work);
 330 }
 331
 332 /* Obsolete. use cancel_delayed_work_sync() */
 333 static inline
 334 void cancel_rearming_delayed_work(struct delayed_work *work)
 335 {
 336         cancel_delayed_work_sync(work);
 337 }
 338
 339 #ifndef CONFIG_SMP
 340 static inline long work_on_cpu(unsigned int cpu, long (*fn)(void *), void *arg)
 341 {
 342         return fn(arg);
 343 }
 344 #else
 345 long work_on_cpu(unsigned int cpu, long (*fn)(void *), void *arg);
 346 #endif /* CONFIG_SMP */
 347
 348 #ifdef CONFIG_FREEZER
 349 extern void freeze_workqueues_begin(void);
 350 extern bool freeze_workqueues_busy(void);
 351 extern void thaw_workqueues(void);
 352 #endif /* CONFIG_FREEZER */
 353
 354 #endif