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 <asm/atomic.h>
  12
  13 struct workqueue_struct;
  14
  15 struct work_struct;
  16 typedef void (*work_func_t)(struct work_struct *work);
  17
  18 /*
  19  * The first word is the work queue pointer and the flags rolled into
  20  * one
  21  */
  22 #define work_data_bits(work) ((unsigned long *)(&(work)->data))
  23
  24 struct work_struct {
  25         atomic_long_t data;
  26 #define WORK_STRUCT_PENDING 0           /* T if work item pending execution */
  27 #define WORK_STRUCT_NOAUTOREL 1         /* F if work item automatically released on exec */
  28 #define WORK_STRUCT_FLAG_MASK (3UL)
  29 #define WORK_STRUCT_WQ_DATA_MASK (~WORK_STRUCT_FLAG_MASK)
  30         struct list_head entry;
  31         work_func_t func;
  32 };
  33
  34 #define WORK_DATA_INIT(autorelease) \
  35         ATOMIC_LONG_INIT((autorelease) << WORK_STRUCT_NOAUTOREL)
  36
  37 struct delayed_work {
  38         struct work_struct work;
  39         struct timer_list timer;
  40 };
  41
  42 struct execute_work {
  43         struct work_struct work;
  44 };
  45
  46 #define __WORK_INITIALIZER(n, f) {                              \
  47         .data = WORK_DATA_INIT(0),                              \
  48         .entry  = { &(n).entry, &(n).entry },                   \
  49         .func = (f),                                            \
  50         }
  51
  52 #define __WORK_INITIALIZER_NAR(n, f) {                          \
  53         .data = WORK_DATA_INIT(1),                              \
  54         .entry  = { &(n).entry, &(n).entry },                   \
  55         .func = (f),                                            \
  56         }
  57
  58 #define __DELAYED_WORK_INITIALIZER(n, f) {                      \
  59         .work = __WORK_INITIALIZER((n).work, (f)),              \
  60         .timer = TIMER_INITIALIZER(NULL, 0, 0),                 \
  61         }
  62
  63 #define __DELAYED_WORK_INITIALIZER_NAR(n, f) {                  \
  64         .work = __WORK_INITIALIZER_NAR((n).work, (f)),          \
  65         .timer = TIMER_INITIALIZER(NULL, 0, 0),                 \
  66         }
  67
  68 #define DECLARE_WORK(n, f)                                      \
  69         struct work_struct n = __WORK_INITIALIZER(n, f)
  70
  71 #define DECLARE_WORK_NAR(n, f)                                  \
  72         struct work_struct n = __WORK_INITIALIZER_NAR(n, f)
  73
  74 #define DECLARE_DELAYED_WORK(n, f)                              \
  75         struct delayed_work n = __DELAYED_WORK_INITIALIZER(n, f)
  76
  77 #define DECLARE_DELAYED_WORK_NAR(n, f)                  \
  78         struct dwork_struct n = __DELAYED_WORK_INITIALIZER_NAR(n, f)
  79
  80 /*
  81  * initialize a work item's function pointer
  82  */
  83 #define PREPARE_WORK(_work, _func)                              \
  84         do {                                                    \
  85                 (_work)->func = (_func);                        \
  86         } while (0)
  87
  88 #define PREPARE_DELAYED_WORK(_work, _func)                      \
  89         PREPARE_WORK(&(_work)->work, (_func))
  90
  91 /*
  92  * initialize all of a work item in one go
  93  *
  94  * NOTE! No point in using "atomic_long_set()": useing a direct
  95  * assignment of the work data initializer allows the compiler
  96  * to generate better code.
  97  */
  98 #define INIT_WORK(_work, _func)                                 \
  99         do {                                                    \
 100                 (_work)->data = (atomic_long_t) WORK_DATA_INIT(0);      \
 101                 INIT_LIST_HEAD(&(_work)->entry);                \
 102                 PREPARE_WORK((_work), (_func));                 \
 103         } while (0)
 104
 105 #define INIT_WORK_NAR(_work, _func)                                     \
 106         do {                                                            \
 107                 (_work)->data = (atomic_long_t) WORK_DATA_INIT(1);      \
 108                 INIT_LIST_HEAD(&(_work)->entry);                        \
 109                 PREPARE_WORK((_work), (_func));                         \
 110         } while (0)
 111
 112 #define INIT_DELAYED_WORK(_work, _func)                         \
 113         do {                                                    \
 114                 INIT_WORK(&(_work)->work, (_func));             \
 115                 init_timer(&(_work)->timer);                    \
 116         } while (0)
 117
 118 #define INIT_DELAYED_WORK_NAR(_work, _func)                     \
 119         do {                                                    \
 120                 INIT_WORK_NAR(&(_work)->work, (_func));         \
 121                 init_timer(&(_work)->timer);                    \
 122         } while (0)
 123
 124 #define INIT_DELAYED_WORK_DEFERRABLE(_work, _func)                      \
 125         do {                                                    \
 126                 INIT_WORK(&(_work)->work, (_func));             \
 127                 init_timer_deferrable(&(_work)->timer);         \
 128         } while (0)
 129
 130 /**
 131  * work_pending - Find out whether a work item is currently pending
 132  * @work: The work item in question
 133  */
 134 #define work_pending(work) \
 135         test_bit(WORK_STRUCT_PENDING, work_data_bits(work))
 136
 137 /**
 138  * delayed_work_pending - Find out whether a delayable work item is currently
 139  * pending
 140  * @work: The work item in question
 141  */
 142 #define delayed_work_pending(w) \
 143         work_pending(&(w)->work)
 144
 145 /**
 146  * work_release - Release a work item under execution
 147  * @work: The work item to release
 148  *
 149  * This is used to release a work item that has been initialised with automatic
 150  * release mode disabled (WORK_STRUCT_NOAUTOREL is set).  This gives the work
 151  * function the opportunity to grab auxiliary data from the container of the
 152  * work_struct before clearing the pending bit as the work_struct may be
 153  * subject to deallocation the moment the pending bit is cleared.
 154  *
 155  * In such a case, this should be called in the work function after it has
 156  * fetched any data it may require from the containter of the work_struct.
 157  * After this function has been called, the work_struct may be scheduled for
 158  * further execution or it may be deallocated unless other precautions are
 159  * taken.
 160  *
 161  * This should also be used to release a delayed work item.
 162  */
 163 #define work_release(work) \
 164         clear_bit(WORK_STRUCT_PENDING, work_data_bits(work))
 165
 166
 167 extern struct workqueue_struct *__create_workqueue(const char *name,
 168                                                     int singlethread,
 169                                                     int freezeable);
 170 #define create_workqueue(name) __create_workqueue((name), 0, 0)
 171 #define create_freezeable_workqueue(name) __create_workqueue((name), 0, 1)
 172 #define create_singlethread_workqueue(name) __create_workqueue((name), 1, 0)
 173
 174 extern void destroy_workqueue(struct workqueue_struct *wq);
 175
 176 extern int FASTCALL(queue_work(struct workqueue_struct *wq, struct work_struct *work));
 177 extern int FASTCALL(queue_delayed_work(struct workqueue_struct *wq, struct delayed_work *work, unsigned long delay));
 178 extern int queue_delayed_work_on(int cpu, struct workqueue_struct *wq,
 179         struct delayed_work *work, unsigned long delay);
 180 extern void FASTCALL(flush_workqueue(struct workqueue_struct *wq));
 181
 182 extern int FASTCALL(schedule_work(struct work_struct *work));
 183 extern int FASTCALL(run_scheduled_work(struct work_struct *work));
 184 extern int FASTCALL(schedule_delayed_work(struct delayed_work *work, unsigned long delay));
 185
 186 extern int schedule_delayed_work_on(int cpu, struct delayed_work *work, unsigned long delay);
 187 extern int schedule_on_each_cpu(work_func_t func);
 188 extern void flush_scheduled_work(void);
 189 extern int current_is_keventd(void);
 190 extern int keventd_up(void);
 191
 192 extern void init_workqueues(void);
 193 void cancel_rearming_delayed_work(struct delayed_work *work);
 194 void cancel_rearming_delayed_workqueue(struct workqueue_struct *,
 195                                        struct delayed_work *);
 196 int execute_in_process_context(work_func_t fn, struct execute_work *);
 197
 198 /*
 199  * Kill off a pending schedule_delayed_work().  Note that the work callback
 200  * function may still be running on return from cancel_delayed_work(), unless
 201  * it returns 1 and the work doesn't re-arm itself. Run flush_workqueue() or
 202  * cancel_work_sync() to wait on it.
 203  */
 204 static inline int cancel_delayed_work(struct delayed_work *work)
 205 {
 206         int ret;
 207
 208         ret = del_timer(&work->timer);
 209         if (ret)
 210                 work_release(&work->work);
 211         return ret;
 212 }
 213
 214 #endif