blob: 429148244eeb9f28ce3f31428c38a9a1b3ec9cd5 [file] [log] [blame]
Willy Tarreaubaaee002006-06-26 02:48:02 +02001/*
Willy Tarreau24f4efa2010-08-27 17:56:48 +02002 * include/proto/task.h
3 * Functions for task management.
4 *
5 * Copyright (C) 2000-2010 Willy Tarreau - w@1wt.eu
6 *
7 * This library is free software; you can redistribute it and/or
8 * modify it under the terms of the GNU Lesser General Public
9 * License as published by the Free Software Foundation, version 2.1
10 * exclusively.
11 *
12 * This library is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15 * Lesser General Public License for more details.
16 *
17 * You should have received a copy of the GNU Lesser General Public
18 * License along with this library; if not, write to the Free Software
19 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
20 */
Willy Tarreaubaaee002006-06-26 02:48:02 +020021
22#ifndef _PROTO_TASK_H
23#define _PROTO_TASK_H
24
25
26#include <sys/time.h>
Willy Tarreaue3ba5f02006-06-29 18:54:54 +020027
28#include <common/config.h>
Willy Tarreau2dd0d472006-06-29 17:53:05 +020029#include <common/memory.h>
Willy Tarreau96bcfd72007-04-29 10:41:56 +020030#include <common/mini-clist.h>
31#include <common/standard.h>
Willy Tarreaud0a201b2009-03-08 15:53:06 +010032#include <common/ticks.h>
Emeric Brunc60def82017-09-27 14:59:38 +020033#include <common/hathreads.h>
34
Willy Tarreau8d388052017-11-05 13:34:20 +010035#include <eb32sctree.h>
Willy Tarreau45cb4fb2009-10-26 21:10:04 +010036#include <eb32tree.h>
Willy Tarreau96bcfd72007-04-29 10:41:56 +020037
Willy Tarreaueb118892014-11-13 16:57:19 +010038#include <types/global.h>
Willy Tarreaue3ba5f02006-06-29 18:54:54 +020039#include <types/task.h>
Willy Tarreaubaaee002006-06-26 02:48:02 +020040
Willy Tarreaud0a201b2009-03-08 15:53:06 +010041/* Principle of the wait queue.
42 *
43 * We want to be able to tell whether an expiration date is before of after the
44 * current time <now>. We KNOW that expiration dates are never too far apart,
45 * because they are measured in ticks (milliseconds). We also know that almost
46 * all dates will be in the future, and that a very small part of them will be
47 * in the past, they are the ones which have expired since last time we checked
48 * them. Using ticks, we know if a date is in the future or in the past, but we
49 * cannot use that to store sorted information because that reference changes
50 * all the time.
51 *
Willy Tarreaue35c94a2009-03-21 10:01:42 +010052 * We'll use the fact that the time wraps to sort timers. Timers above <now>
53 * are in the future, timers below <now> are in the past. Here, "above" and
54 * "below" are to be considered modulo 2^31.
Willy Tarreaud0a201b2009-03-08 15:53:06 +010055 *
Willy Tarreaue35c94a2009-03-21 10:01:42 +010056 * Timers are stored sorted in an ebtree. We use the new ability for ebtrees to
57 * lookup values starting from X to only expire tasks between <now> - 2^31 and
58 * <now>. If the end of the tree is reached while walking over it, we simply
59 * loop back to the beginning. That way, we have no problem keeping sorted
60 * wrapping timers in a tree, between (now - 24 days) and (now + 24 days). The
61 * keys in the tree always reflect their real position, none can be infinite.
62 * This reduces the number of checks to be performed.
Willy Tarreaud0a201b2009-03-08 15:53:06 +010063 *
64 * Another nice optimisation is to allow a timer to stay at an old place in the
65 * queue as long as it's not further than the real expiration date. That way,
66 * we use the tree as a place holder for a minorant of the real expiration
67 * date. Since we have a very low chance of hitting a timeout anyway, we can
68 * bounce the nodes to their right place when we scan the tree if we encounter
69 * a misplaced node once in a while. This even allows us not to remove the
70 * infinite timers from the wait queue.
71 *
72 * So, to summarize, we have :
73 * - node->key always defines current position in the wait queue
74 * - timer is the real expiration date (possibly infinite)
Willy Tarreaue35c94a2009-03-21 10:01:42 +010075 * - node->key is always before or equal to timer
Willy Tarreaud0a201b2009-03-08 15:53:06 +010076 *
77 * The run queue works similarly to the wait queue except that the current date
78 * is replaced by an insertion counter which can also wrap without any problem.
79 */
80
Willy Tarreaue35c94a2009-03-21 10:01:42 +010081/* The farthest we can look back in a timer tree */
82#define TIMER_LOOK_BACK (1U << 31)
Willy Tarreaud0a201b2009-03-08 15:53:06 +010083
84/* a few exported variables */
Willy Tarreaua4613182009-03-21 18:13:21 +010085extern unsigned int nb_tasks; /* total number of tasks */
Christopher Faulet3911ee82017-11-14 10:26:53 +010086extern unsigned long active_tasks_mask; /* Mask of threads with active tasks */
Christopher Faulet34c5cc92016-12-06 09:15:30 +010087extern unsigned int tasks_run_queue; /* run queue size */
88extern unsigned int tasks_run_queue_cur;
Willy Tarreauc7bdf092009-03-21 18:33:52 +010089extern unsigned int nb_tasks_cur;
Willy Tarreau91e99932008-06-30 07:51:00 +020090extern unsigned int niced_tasks; /* number of niced tasks in the run queue */
Willy Tarreaubafbe012017-11-24 17:34:44 +010091extern struct pool_head *pool_head_task;
92extern struct pool_head *pool_head_notification;
Christopher Faulet9dcf9b62017-11-13 10:34:01 +010093
94__decl_hathreads(extern HA_SPINLOCK_T rq_lock); /* spin lock related to run queue */
95__decl_hathreads(extern HA_SPINLOCK_T wq_lock); /* spin lock related to wait queue */
Willy Tarreauc6ca1a02007-05-13 19:43:47 +020096
Willy Tarreau4726f532009-03-07 17:25:21 +010097/* return 0 if task is in run queue, otherwise non-zero */
98static inline int task_in_rq(struct task *t)
99{
100 return t->rq.node.leaf_p != NULL;
101}
102
103/* return 0 if task is in wait queue, otherwise non-zero */
104static inline int task_in_wq(struct task *t)
105{
106 return t->wq.node.leaf_p != NULL;
107}
108
Willy Tarreaufdccded2008-08-29 18:19:04 +0200109/* puts the task <t> in run queue with reason flags <f>, and returns <t> */
Willy Tarreau4df82062008-08-29 15:26:14 +0200110struct task *__task_wakeup(struct task *t);
Willy Tarreaufdccded2008-08-29 18:19:04 +0200111static inline struct task *task_wakeup(struct task *t, unsigned int f)
Willy Tarreau4df82062008-08-29 15:26:14 +0200112{
Christopher Faulet2a944ee2017-11-07 10:42:54 +0100113 HA_SPIN_LOCK(TASK_RQ_LOCK, &rq_lock);
Emeric Brunc60def82017-09-27 14:59:38 +0200114
Emeric Brun01948972017-03-30 15:37:25 +0200115 /* If task is running, we postpone the call
116 * and backup the state.
117 */
118 if (unlikely(t->state & TASK_RUNNING)) {
119 t->pending_state |= f;
Christopher Faulet2a944ee2017-11-07 10:42:54 +0100120 HA_SPIN_UNLOCK(TASK_RQ_LOCK, &rq_lock);
Emeric Brun01948972017-03-30 15:37:25 +0200121 return t;
122 }
Willy Tarreau4726f532009-03-07 17:25:21 +0100123 if (likely(!task_in_rq(t)))
Willy Tarreaufdccded2008-08-29 18:19:04 +0200124 __task_wakeup(t);
125 t->state |= f;
Christopher Faulet2a944ee2017-11-07 10:42:54 +0100126 HA_SPIN_UNLOCK(TASK_RQ_LOCK, &rq_lock);
Emeric Brunc60def82017-09-27 14:59:38 +0200127
Willy Tarreaufdccded2008-08-29 18:19:04 +0200128 return t;
Willy Tarreau4df82062008-08-29 15:26:14 +0200129}
Willy Tarreaubaaee002006-06-26 02:48:02 +0200130
Willy Tarreauf65610a2017-10-31 16:06:06 +0100131/* change the thread affinity of a task to <thread_mask> */
Emeric Brunc60def82017-09-27 14:59:38 +0200132static inline void task_set_affinity(struct task *t, unsigned long thread_mask)
133{
Willy Tarreauf65610a2017-10-31 16:06:06 +0100134 t->thread_mask = thread_mask;
Emeric Brunc60def82017-09-27 14:59:38 +0200135}
Willy Tarreauf65610a2017-10-31 16:06:06 +0100136
Willy Tarreau4726f532009-03-07 17:25:21 +0100137/*
138 * Unlink the task from the wait queue, and possibly update the last_timer
139 * pointer. A pointer to the task itself is returned. The task *must* already
140 * be in the wait queue before calling this function. If unsure, use the safer
141 * task_unlink_wq() function.
Willy Tarreaubaaee002006-06-26 02:48:02 +0200142 */
Willy Tarreau4726f532009-03-07 17:25:21 +0100143static inline struct task *__task_unlink_wq(struct task *t)
144{
145 eb32_delete(&t->wq);
Willy Tarreau4726f532009-03-07 17:25:21 +0100146 return t;
147}
148
149static inline struct task *task_unlink_wq(struct task *t)
Willy Tarreaubaaee002006-06-26 02:48:02 +0200150{
Christopher Faulet2a944ee2017-11-07 10:42:54 +0100151 HA_SPIN_LOCK(TASK_WQ_LOCK, &wq_lock);
Willy Tarreau4726f532009-03-07 17:25:21 +0100152 if (likely(task_in_wq(t)))
153 __task_unlink_wq(t);
Christopher Faulet2a944ee2017-11-07 10:42:54 +0100154 HA_SPIN_UNLOCK(TASK_WQ_LOCK, &wq_lock);
Willy Tarreau96bcfd72007-04-29 10:41:56 +0200155 return t;
Willy Tarreaubaaee002006-06-26 02:48:02 +0200156}
157
158/*
Christopher Faulet34c5cc92016-12-06 09:15:30 +0100159 * Unlink the task from the run queue. The tasks_run_queue size and number of
160 * niced tasks are updated too. A pointer to the task itself is returned. The
161 * task *must* already be in the run queue before calling this function. If
162 * unsure, use the safer task_unlink_rq() function. Note that the pointer to the
163 * next run queue entry is neither checked nor updated.
Willy Tarreaubaaee002006-06-26 02:48:02 +0200164 */
Willy Tarreau4726f532009-03-07 17:25:21 +0100165static inline struct task *__task_unlink_rq(struct task *t)
Willy Tarreaubaaee002006-06-26 02:48:02 +0200166{
Willy Tarreau8d388052017-11-05 13:34:20 +0100167 eb32sc_delete(&t->rq);
Christopher Faulet34c5cc92016-12-06 09:15:30 +0100168 tasks_run_queue--;
Willy Tarreau4726f532009-03-07 17:25:21 +0100169 if (likely(t->nice))
170 niced_tasks--;
Willy Tarreauce44f122008-07-05 18:16:19 +0200171 return t;
172}
Willy Tarreau9789f7b2008-06-24 08:17:16 +0200173
Willy Tarreau501260b2015-02-23 16:07:01 +0100174/* This function unlinks task <t> from the run queue if it is in it. It also
175 * takes care of updating the next run queue task if it was this task.
176 */
Willy Tarreau4726f532009-03-07 17:25:21 +0100177static inline struct task *task_unlink_rq(struct task *t)
178{
Christopher Faulet2a944ee2017-11-07 10:42:54 +0100179 HA_SPIN_LOCK(TASK_RQ_LOCK, &rq_lock);
Emeric Brunc60def82017-09-27 14:59:38 +0200180 if (likely(task_in_rq(t)))
Willy Tarreau4726f532009-03-07 17:25:21 +0100181 __task_unlink_rq(t);
Christopher Faulet2a944ee2017-11-07 10:42:54 +0100182 HA_SPIN_UNLOCK(TASK_RQ_LOCK, &rq_lock);
Willy Tarreau4726f532009-03-07 17:25:21 +0100183 return t;
184}
185
Willy Tarreauce44f122008-07-05 18:16:19 +0200186/*
187 * Unlinks the task and adjusts run queue stats.
188 * A pointer to the task itself is returned.
189 */
190static inline struct task *task_delete(struct task *t)
191{
Willy Tarreau4726f532009-03-07 17:25:21 +0100192 task_unlink_wq(t);
193 task_unlink_rq(t);
Willy Tarreau9789f7b2008-06-24 08:17:16 +0200194 return t;
195}
196
197/*
Willy Tarreaua4613182009-03-21 18:13:21 +0100198 * Initialize a new task. The bare minimum is performed (queue pointers and
199 * state). The task is returned. This function should not be used outside of
200 * task_new().
Willy Tarreau9789f7b2008-06-24 08:17:16 +0200201 */
Emeric Brunc60def82017-09-27 14:59:38 +0200202static inline struct task *task_init(struct task *t, unsigned long thread_mask)
Willy Tarreau9789f7b2008-06-24 08:17:16 +0200203{
Willy Tarreau4726f532009-03-07 17:25:21 +0100204 t->wq.node.leaf_p = NULL;
205 t->rq.node.leaf_p = NULL;
Emeric Brun01948972017-03-30 15:37:25 +0200206 t->pending_state = t->state = TASK_SLEEPING;
Willy Tarreauf65610a2017-10-31 16:06:06 +0100207 t->thread_mask = thread_mask;
Willy Tarreau91e99932008-06-30 07:51:00 +0200208 t->nice = 0;
Willy Tarreau3884cba2009-03-28 17:54:35 +0100209 t->calls = 0;
Willy Tarreauf4219992017-07-24 17:52:58 +0200210 t->expire = TICK_ETERNITY;
Willy Tarreaubaaee002006-06-26 02:48:02 +0200211 return t;
212}
213
214/*
Willy Tarreaua4613182009-03-21 18:13:21 +0100215 * Allocate and initialise a new task. The new task is returned, or NULL in
216 * case of lack of memory. The task count is incremented. Tasks should only
217 * be allocated this way, and must be freed using task_free().
218 */
Emeric Brunc60def82017-09-27 14:59:38 +0200219static inline struct task *task_new(unsigned long thread_mask)
Willy Tarreaua4613182009-03-21 18:13:21 +0100220{
Willy Tarreaubafbe012017-11-24 17:34:44 +0100221 struct task *t = pool_alloc(pool_head_task);
Willy Tarreaua4613182009-03-21 18:13:21 +0100222 if (t) {
Emeric Brunc60def82017-09-27 14:59:38 +0200223 HA_ATOMIC_ADD(&nb_tasks, 1);
224 task_init(t, thread_mask);
Willy Tarreaua4613182009-03-21 18:13:21 +0100225 }
226 return t;
227}
228
229/*
230 * Free a task. Its context must have been freed since it will be lost.
231 * The task count is decremented.
Willy Tarreaubaaee002006-06-26 02:48:02 +0200232 */
233static inline void task_free(struct task *t)
234{
Willy Tarreaubafbe012017-11-24 17:34:44 +0100235 pool_free(pool_head_task, t);
Willy Tarreaueb118892014-11-13 16:57:19 +0100236 if (unlikely(stopping))
Willy Tarreaubafbe012017-11-24 17:34:44 +0100237 pool_flush(pool_head_task);
Emeric Brunc60def82017-09-27 14:59:38 +0200238 HA_ATOMIC_SUB(&nb_tasks, 1);
Willy Tarreaubaaee002006-06-26 02:48:02 +0200239}
240
Willy Tarreau4726f532009-03-07 17:25:21 +0100241/* Place <task> into the wait queue, where it may already be. If the expiration
Willy Tarreau531cf0c2009-03-08 16:35:27 +0100242 * timer is infinite, do nothing and rely on wake_expired_task to clean up.
Willy Tarreaubaaee002006-06-26 02:48:02 +0200243 */
Willy Tarreau531cf0c2009-03-08 16:35:27 +0100244void __task_queue(struct task *task);
245static inline void task_queue(struct task *task)
246{
247 /* If we already have a place in the wait queue no later than the
248 * timeout we're trying to set, we'll stay there, because it is very
249 * unlikely that we will reach the timeout anyway. If the timeout
250 * has been disabled, it's useless to leave the queue as well. We'll
251 * rely on wake_expired_tasks() to catch the node and move it to the
252 * proper place should it ever happen. Finally we only add the task
253 * to the queue if it was not there or if it was further than what
254 * we want.
255 */
256 if (!tick_isset(task->expire))
257 return;
258
Christopher Faulet2a944ee2017-11-07 10:42:54 +0100259 HA_SPIN_LOCK(TASK_WQ_LOCK, &wq_lock);
Willy Tarreaue35c94a2009-03-21 10:01:42 +0100260 if (!task_in_wq(task) || tick_is_lt(task->expire, task->wq.key))
Willy Tarreau531cf0c2009-03-08 16:35:27 +0100261 __task_queue(task);
Christopher Faulet2a944ee2017-11-07 10:42:54 +0100262 HA_SPIN_UNLOCK(TASK_WQ_LOCK, &wq_lock);
Willy Tarreau531cf0c2009-03-08 16:35:27 +0100263}
Willy Tarreaubaaee002006-06-26 02:48:02 +0200264
Willy Tarreau26e48812011-07-25 14:30:42 +0200265/* Ensure <task> will be woken up at most at <when>. If the task is already in
266 * the run queue (but not running), nothing is done. It may be used that way
267 * with a delay : task_schedule(task, tick_add(now_ms, delay));
268 */
269static inline void task_schedule(struct task *task, int when)
270{
Emeric Brunc60def82017-09-27 14:59:38 +0200271 /* TODO: mthread, check if there is no tisk with this test */
Willy Tarreau26e48812011-07-25 14:30:42 +0200272 if (task_in_rq(task))
273 return;
274
Christopher Faulet2a944ee2017-11-07 10:42:54 +0100275 HA_SPIN_LOCK(TASK_WQ_LOCK, &wq_lock);
Willy Tarreau26e48812011-07-25 14:30:42 +0200276 if (task_in_wq(task))
277 when = tick_first(when, task->expire);
278
279 task->expire = when;
280 if (!task_in_wq(task) || tick_is_lt(task->expire, task->wq.key))
281 __task_queue(task);
Christopher Faulet2a944ee2017-11-07 10:42:54 +0100282 HA_SPIN_UNLOCK(TASK_WQ_LOCK, &wq_lock);
Willy Tarreau26e48812011-07-25 14:30:42 +0200283}
284
Thierry FOURNIERd6975962017-07-12 14:31:10 +0200285/* This function register a new signal. "lua" is the current lua
286 * execution context. It contains a pointer to the associated task.
287 * "link" is a list head attached to an other task that must be wake
288 * the lua task if an event occurs. This is useful with external
289 * events like TCP I/O or sleep functions. This funcion allocate
290 * memory for the signal.
291 */
292static inline struct notification *notification_new(struct list *purge, struct list *event, struct task *wakeup)
293{
Willy Tarreaubafbe012017-11-24 17:34:44 +0100294 struct notification *com = pool_alloc(pool_head_notification);
Thierry FOURNIERd6975962017-07-12 14:31:10 +0200295 if (!com)
296 return NULL;
297 LIST_ADDQ(purge, &com->purge_me);
298 LIST_ADDQ(event, &com->wake_me);
Christopher Faulet2a944ee2017-11-07 10:42:54 +0100299 HA_SPIN_INIT(&com->lock);
Thierry FOURNIERd6975962017-07-12 14:31:10 +0200300 com->task = wakeup;
301 return com;
302}
303
304/* This function purge all the pending signals when the LUA execution
305 * is finished. This prevent than a coprocess try to wake a deleted
306 * task. This function remove the memory associated to the signal.
307 */
308static inline void notification_purge(struct list *purge)
309{
310 struct notification *com, *back;
311
312 /* Delete all pending communication signals. */
313 list_for_each_entry_safe(com, back, purge, purge_me) {
Christopher Faulet2a944ee2017-11-07 10:42:54 +0100314 HA_SPIN_LOCK(NOTIF_LOCK, &com->lock);
Thierry FOURNIERd6975962017-07-12 14:31:10 +0200315 LIST_DEL(&com->purge_me);
Thierry FOURNIER738a6d72017-07-17 00:14:07 +0200316 if (!com->task) {
Christopher Faulet2a944ee2017-11-07 10:42:54 +0100317 HA_SPIN_UNLOCK(NOTIF_LOCK, &com->lock);
Willy Tarreaubafbe012017-11-24 17:34:44 +0100318 pool_free(pool_head_notification, com);
Thierry FOURNIER738a6d72017-07-17 00:14:07 +0200319 continue;
320 }
321 com->task = NULL;
Christopher Faulet2a944ee2017-11-07 10:42:54 +0100322 HA_SPIN_UNLOCK(NOTIF_LOCK, &com->lock);
Thierry FOURNIERd6975962017-07-12 14:31:10 +0200323 }
324}
325
326/* This function sends signals. It wakes all the tasks attached
327 * to a list head, and remove the signal, and free the used
328 * memory.
329 */
330static inline void notification_wake(struct list *wake)
331{
332 struct notification *com, *back;
333
334 /* Wake task and delete all pending communication signals. */
335 list_for_each_entry_safe(com, back, wake, wake_me) {
Christopher Faulet2a944ee2017-11-07 10:42:54 +0100336 HA_SPIN_LOCK(NOTIF_LOCK, &com->lock);
Thierry FOURNIERd6975962017-07-12 14:31:10 +0200337 LIST_DEL(&com->wake_me);
Thierry FOURNIER738a6d72017-07-17 00:14:07 +0200338 if (!com->task) {
Christopher Faulet2a944ee2017-11-07 10:42:54 +0100339 HA_SPIN_UNLOCK(NOTIF_LOCK, &com->lock);
Willy Tarreaubafbe012017-11-24 17:34:44 +0100340 pool_free(pool_head_notification, com);
Thierry FOURNIER738a6d72017-07-17 00:14:07 +0200341 continue;
342 }
Thierry FOURNIERd6975962017-07-12 14:31:10 +0200343 task_wakeup(com->task, TASK_WOKEN_MSG);
Thierry FOURNIER738a6d72017-07-17 00:14:07 +0200344 com->task = NULL;
Christopher Faulet2a944ee2017-11-07 10:42:54 +0100345 HA_SPIN_UNLOCK(NOTIF_LOCK, &com->lock);
Thierry FOURNIERd6975962017-07-12 14:31:10 +0200346 }
347}
348
Willy Tarreaubaaee002006-06-26 02:48:02 +0200349/*
Willy Tarreau918ff602011-07-25 16:33:49 +0200350 * This does 3 things :
Willy Tarreaubaaee002006-06-26 02:48:02 +0200351 * - wake up all expired tasks
352 * - call all runnable tasks
Willy Tarreaud825eef2007-05-12 22:35:00 +0200353 * - return the date of next event in <next> or eternity.
Willy Tarreaubaaee002006-06-26 02:48:02 +0200354 */
355
Thierry FOURNIER9cf7c4b2014-12-15 13:26:01 +0100356void process_runnable_tasks();
Willy Tarreaubaaee002006-06-26 02:48:02 +0200357
Willy Tarreau58b458d2008-06-29 22:40:23 +0200358/*
359 * Extract all expired timers from the timer queue, and wakes up all
360 * associated tasks. Returns the date of next event (or eternity).
361 */
Thierry FOURNIER9cf7c4b2014-12-15 13:26:01 +0100362int wake_expired_tasks();
Willy Tarreau58b458d2008-06-29 22:40:23 +0200363
Willy Tarreaud0a201b2009-03-08 15:53:06 +0100364/* Perform minimal initializations, report 0 in case of error, 1 if OK. */
365int init_task();
Willy Tarreaubaaee002006-06-26 02:48:02 +0200366
367#endif /* _PROTO_TASK_H */
368
369/*
370 * Local variables:
371 * c-indent-level: 8
372 * c-basic-offset: 8
373 * End:
374 */